diff --git a/README.txt b/README.txt new file mode 100644 index 0000000..d6eedfd --- /dev/null +++ b/README.txt @@ -0,0 +1,15 @@ + This is the instructional package for 'Multicopter Design and Control Practice'. + The model in "e0" is mainly used for the introduction of the experimental platform, corresponding to the relevant content in Chapters 3 and 4 of the book. + The last 8 chapters of the book correspond to 8 experiments, of which Propulsion System Design Experiment has no relevant instructional package. Experiments 2 to 8 correspond to the contents of Chapters 6 to 12, and the corresponding files are e2 to e8. + There are three sub-files in each folder, which correspond to the basic experiment, analysis experiment and design experiment in each experiment. Analysis experiment of chapter 2 has no source file package--"e2/e2.2",becasuse it mainly focus on theoretical calculation and analysis. + + The comparison between the instructional package and each experiment is as follows: + e2:Dynamic Modeling Experiment; + e3:Sensor Calibration Experiment; + e4:State Estimation and Filter Design Experiment; + e5:Attitude Controller Design Experiment; + e6:Set-point Controller Design Experiment; + e7:Semi-autonomous Control Model Design Experiment; + e8:Failsafe Logic Design Experiment. + + We don't provid design experiment package for students, and the code begining with "%@ " should be compeleted to make it right to run.If you can be certified as a teacher, we will give you all the packages. \ No newline at end of file diff --git a/e0/1.SoftwareSimExps/CopterSim3DEnvironment.slx b/e0/1.SoftwareSimExps/CopterSim3DEnvironment.slx new file mode 100644 index 0000000..be47137 Binary files /dev/null and b/e0/1.SoftwareSimExps/CopterSim3DEnvironment.slx differ diff --git a/e0/1.SoftwareSimExps/Init_control.m b/e0/1.SoftwareSimExps/Init_control.m new file mode 100644 index 0000000..880e0e5 --- /dev/null +++ b/e0/1.SoftwareSimExps/Init_control.m @@ -0,0 +1,21 @@ +path(path, './icon/'); + +%ģ�Ͳ��� ����ģ�ͳ�ʼ���ļ�icon/init.m +Init; + + +%PID���� +Kp_RP_ANGLE =6.5; +Kp_RP_AgngleRate = 0.55; +Ki_RP_AgngleRate = 0.01; +Kd_RP_AgngleRate = 0.005; + +Kp_YAW_AngleRate = 3.2; +Ki_YAW_AngleRate = 0.8; +Kd_YAW_AngleRate = 0.05; +%�����ƽǶȣ���λ�� +MAX_CONTROL_ANGLE_RP = 45; +MAX_CONTROL_ANGLE_Y = 180; +%�����ƽ��ٶȣ���λ�� +MAX_CONTROL_ANGLE_RATE_RP = 180; +MAX_CONTROL_ANGLE_RATE_Y = 90; diff --git a/e0/1.SoftwareSimExps/icon/Battery_sf.mexw64 b/e0/1.SoftwareSimExps/icon/Battery_sf.mexw64 new file mode 100644 index 0000000..1bbdd22 Binary files /dev/null and b/e0/1.SoftwareSimExps/icon/Battery_sf.mexw64 differ diff --git a/e0/1.SoftwareSimExps/icon/Environment_sf.mexw64 b/e0/1.SoftwareSimExps/icon/Environment_sf.mexw64 new file mode 100644 index 0000000..ca15ae0 Binary files /dev/null and b/e0/1.SoftwareSimExps/icon/Environment_sf.mexw64 differ diff --git a/e0/1.SoftwareSimExps/icon/F450.png b/e0/1.SoftwareSimExps/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e0/1.SoftwareSimExps/icon/F450.png differ diff --git a/e0/1.SoftwareSimExps/icon/Fail_sf.mexw64 b/e0/1.SoftwareSimExps/icon/Fail_sf.mexw64 new file mode 100644 index 0000000..72486af Binary files /dev/null and b/e0/1.SoftwareSimExps/icon/Fail_sf.mexw64 differ diff --git a/e0/1.SoftwareSimExps/icon/FlightGear.png b/e0/1.SoftwareSimExps/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e0/1.SoftwareSimExps/icon/FlightGear.png differ diff --git a/e0/1.SoftwareSimExps/icon/Force_sf.mexw64 b/e0/1.SoftwareSimExps/icon/Force_sf.mexw64 new file mode 100644 index 0000000..8767223 Binary files /dev/null and b/e0/1.SoftwareSimExps/icon/Force_sf.mexw64 differ diff --git a/e0/1.SoftwareSimExps/icon/Init.m b/e0/1.SoftwareSimExps/icon/Init.m new file mode 100644 index 0000000..af3e616 --- /dev/null +++ b/e0/1.SoftwareSimExps/icon/Init.m @@ -0,0 +1,70 @@ +load MavLinkStruct.mat; +%PID Parameters +Kp_RP_ANGLE =6.5; +Kp_RP_AgngleRate = 0.10; +Ki_RP_AgngleRate = 0.02; +Kd_RP_AgngleRate = 0.001; + +Kp_YAW_AngleRate = 0.3; +Ki_YAW_AngleRate = 0.1; +Kd_YAW_AngleRate = 0.00; +%integral saturation +Saturation_I_RP_Max=0.3; +Saturation_I_RP_Min=-0.3; +Saturation_I_Y_Max=0.2; +Saturation_I_Y_Min=-0.2; +%thrust when UAV hover +THR_HOVER=0.609; +%max control angle +%default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%max control angle rate +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; + +%Initial condition +ModelInit_PosE = [0,0,0]; +ModelInit_VelB = [0,0,0]; +ModelInit_AngEuler = [0,0,0]; +ModelInit_RateB = [0,0,0]; +ModelInit_RPM = 0; %Initial motor speed(rad/s) + +%UAV model parameter +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx,0,0;... + 0,ModelParam_uavJyy,0;... + 0,0,ModelParam_uavJzz]; +ModelParam_uavType = int8(3); %X-type quadrotor��refer to "���Ͷ����ĵ�.docx" for specific definitions +ModelParam_uavMotNumbs = int8(4); %Number of motors +ModelParam_uavR = 0.225; %Body radius(m) + +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb =-141.4; %Motor speed-throttle curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) +%M=Cm*w^2 +ModelParam_rotorCm = 1.779e-07; %Rotor torque coefficient(kg.m^2) +%T=Ct**w^2 +ModelParam_rotorCt = 1.105e-05; %Rotor thrust coefficient(kg.m^2) +ModelParam_motorMinThr = 0.05; %Motor throttle dead zone(kg.m^2) + +ModelParam_uavCd = 0.073; %Damping coefficient(N/(m/s)^2) +ModelParam_uavCCm = [0.01 0.01 0.0055]; %Damping moment coefficient vector(N/(m/s)^2) +ModelParam_uavDearo = 0.12; %Vertical position difference of Aerodynamic center and gravity center(m) + +ModelParam_GlobalNoiseGainSwitch =1; %Noise level gain + +%Environment Parameter +ModelParam_envGravityAcc = 9.8; %Gravity acceleration(m/s^2) +ModelParam_envLongitude = 116.259368300000; +ModelParam_envLatitude = 40.1540302; +ModelParam_GPSLatLong = [ModelParam_envLatitude ModelParam_envLongitude]; %Latitude and longitude +ModelParam_envAltitude = -41.5260009765625; %Reference height, down is positive +ModelParam_BusSampleRate = 0.001; %Model sampling rate + diff --git a/e0/1.SoftwareSimExps/icon/MavLinkStruct.mat b/e0/1.SoftwareSimExps/icon/MavLinkStruct.mat new file mode 100644 index 0000000..3e1d05f Binary files /dev/null and b/e0/1.SoftwareSimExps/icon/MavLinkStruct.mat differ diff --git a/e0/1.SoftwareSimExps/icon/Motor_sf.mexw64 b/e0/1.SoftwareSimExps/icon/Motor_sf.mexw64 new file mode 100644 index 0000000..6be8fa7 Binary files /dev/null and b/e0/1.SoftwareSimExps/icon/Motor_sf.mexw64 differ diff --git a/e0/1.SoftwareSimExps/icon/OutputPort_sf.mexw64 b/e0/1.SoftwareSimExps/icon/OutputPort_sf.mexw64 new file mode 100644 index 0000000..f2ec536 Binary files /dev/null and b/e0/1.SoftwareSimExps/icon/OutputPort_sf.mexw64 differ diff --git a/e0/1.SoftwareSimExps/icon/pixhawk.png b/e0/1.SoftwareSimExps/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e0/1.SoftwareSimExps/icon/pixhawk.png differ diff --git "a/e0/1.SoftwareSimExps/icon/\346\234\272\345\236\213\345\256\232\344\271\211\346\226\207\346\241\243.docx" "b/e0/1.SoftwareSimExps/icon/\346\234\272\345\236\213\345\256\232\344\271\211\346\226\207\346\241\243.docx" new file mode 100644 index 0000000..1f0b6e3 Binary files /dev/null and "b/e0/1.SoftwareSimExps/icon/\346\234\272\345\236\213\345\256\232\344\271\211\346\226\207\346\241\243.docx" differ diff --git a/e0/2.PSPOfficialExps/ExternalMode_Examples/ext_mode_intro.slx b/e0/2.PSPOfficialExps/ExternalMode_Examples/ext_mode_intro.slx new file mode 100644 index 0000000..a05f258 Binary files /dev/null and b/e0/2.PSPOfficialExps/ExternalMode_Examples/ext_mode_intro.slx differ diff --git a/e0/2.PSPOfficialExps/ExternalMode_Examples/parameter_tune.slx b/e0/2.PSPOfficialExps/ExternalMode_Examples/parameter_tune.slx new file mode 100644 index 0000000..37b5e77 Binary files /dev/null and b/e0/2.PSPOfficialExps/ExternalMode_Examples/parameter_tune.slx differ diff --git a/e0/2.PSPOfficialExps/ExternalMode_Examples/px4demo_attitude_system_multi_task.slx b/e0/2.PSPOfficialExps/ExternalMode_Examples/px4demo_attitude_system_multi_task.slx new file mode 100644 index 0000000..4e602e8 Binary files /dev/null and b/e0/2.PSPOfficialExps/ExternalMode_Examples/px4demo_attitude_system_multi_task.slx differ diff --git a/e0/2.PSPOfficialExps/ExternalMode_Examples/readme.docx b/e0/2.PSPOfficialExps/ExternalMode_Examples/readme.docx new file mode 100644 index 0000000..1d61f12 Binary files /dev/null and b/e0/2.PSPOfficialExps/ExternalMode_Examples/readme.docx differ diff --git a/e0/2.PSPOfficialExps/Pixhawk_Pilot_Support_Package.pdf b/e0/2.PSPOfficialExps/Pixhawk_Pilot_Support_Package.pdf new file mode 100644 index 0000000..65e3255 Binary files /dev/null and b/e0/2.PSPOfficialExps/Pixhawk_Pilot_Support_Package.pdf differ diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/CommObjSerial.cpp b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/CommObjSerial.cpp new file mode 100644 index 0000000..9d5f926 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/CommObjSerial.cpp @@ -0,0 +1,851 @@ + +// +// CLASS: CCommSerial +// +// Author: Steve Kuznicki +// + +#include "stdafx.h" +#include +#include +#include +#ifdef _forLinux +#include +#include +#include +#endif +#include +#include +#include +#include "CommObjSerial.h" +#include "asciidef.h" + +// #define VERBOSE_READ_PKT + +#ifdef _forLinux // function prototypes +bool ReadFile(HANDLE hFile,char *lpBuffer,long nNumberOfBytesToRead, unsigned long *lpNumberOfBytesRead,void *lpOverlapped); +bool WriteFile(HANDLE hFile,char *lpBuffer,long nNumberOfBytesToWrite, unsigned long *lpNumberOfBytesWritten,void *lpOverlapped); +#endif + + +CCommSerial::CCommSerial() : CComm(CComm::opServer) +{ + m_hComm = INVALID_HANDLE_VALUE; +} + +CCommSerial::CCommSerial(opMode om) : CComm(om) +{ + whatIAm = om; + m_hComm = INVALID_HANDLE_VALUE; +} + +CCommSerial::CCommSerial(char *configStr, opMode om) : CComm(om) +{ + m_hComm = INVALID_HANDLE_VALUE; + Init(configStr); +} + +CCommSerial::~CCommSerial() +{ + // free buffers which were allocated by the Comm class + if(inputBuffer) + { + free(inputBuffer); + inputBuffer = NULL; + } + if(outputBuffer) + { + free(outputBuffer); + outputBuffer = NULL; + } + if(argBuffer) + { + free(argBuffer); + argBuffer = NULL; + } + if (m_serialData.pcInitString) + { + free(m_serialData.pcInitString); + m_serialData.pcInitString = NULL; + } +} + +int CCommSerial::Init(char *configString) +{ + int rc = COMMRET_SUCCESS; + + m_readTimeout = 200; + + if(strlen(configString) == 0) + { + rc = COMMRET_ERROR; + goto EXIT_INIT; + } + + // initialize the serial communications + if(whatIAm == opClient || whatIAm == opServer) + { + char cfgstr[300]; + strcpy_s(cfgstr, configString); +#ifndef _forLinux + char *stmp = NULL; + int nModeLen = 0; + stmp = strchr(cfgstr, ':'); + if(stmp){ + stmp[0] = 0; + } + m_serialData.comPort = (short)atoi(&(cfgstr[3])); + stmp[0] = ':'; + if(stmp){ + nModeLen = (int)strlen(cfgstr)+1; + if ((m_serialData.pcInitString = (char *)malloc(nModeLen)) == NULL) + { + rc = COMMRET_ERROR; + goto EXIT_INIT; + } + strncpy_s(m_serialData.pcInitString, nModeLen, cfgstr, nModeLen); + } + else{ + m_serialData.pcInitString = NULL; + } +#else + m_serialData.pcInitString = configString; + m_serialData.comPort = atoi(cfgstr); +#endif + } + else + { + // if not a client or server, then do NOT init + rc = COMMRET_ERROR; + goto EXIT_INIT; + } + + if((rc = initSerialComm()) == COMMRET_SUCCESS) + commActive = true; + +EXIT_INIT: + return(rc); +} + +// +// FUNCTION: int initSerialComm(short port) +int CCommSerial::initSerialComm() +{ + int rc = COMMRET_SUCCESS; +#ifndef _forLinux + // Initialize DCB structure + if(!BuildCommDCB(m_serialData.pcInitString, &(m_serialData.dcbControlBlock))) + { + rc = COMMRET_ERROR; + } +#else + // run stty here to set the serial port attributes... + char setupStr[100]; + sprintf(setupStr,"stty baud=9600 stopb=1 bits=8 par=none < /dev/ttyS%1d",m_serialData.comPort); + system(setupStr); +#endif + +/* + m_serialData.dcbControlBlock.DCBlength; // sizeof(DCB) + m_serialData.dcbControlBlock.fBinary = 1; // binary mode, no EOF check + m_serialData.dcbControlBlock.fParity = 1; // enable parity checking + m_serialData.dcbControlBlock.fOutxCtsFlow = 1; // CTS output flow control + m_serialData.dcbControlBlock.fOutxDsrFlow = 1; // DSR output flow control + m_serialData.dcbControlBlock.fDtrControl = 2; // DTR flow control type + m_serialData.dcbControlBlock.fDsrSensitivity = 1; // DSR sensitivity + m_serialData.dcbControlBlock.fTXContinueOnXoff = 1; // XOFF continues Tx + m_serialData.dcbControlBlock.fOutX = 1; // XON/XOFF out flow control + m_serialData.dcbControlBlock.fInX = 1; // XON/XOFF in flow control + m_serialData.dcbControlBlock.fErrorChar = 1; // enable error replacement + m_serialData.dcbControlBlock.fNull = 1; // enable null stripping + m_serialData.dcbControlBlock.fRtsControl = 2; // RTS flow control + m_serialData.dcbControlBlock.fAbortOnError = 1; // abort reads/writes on error + m_serialData.dcbControlBlock.fDummy2 = 17; // reserved + m_serialData.dcbControlBlock.wReserved; // not currently used + m_serialData.dcbControlBlock.XonLim; // transmit XON threshold + m_serialData.dcbControlBlock.XoffLim; // transmit XOFF threshold + m_serialData.dcbControlBlock.ByteSize; // number of bits/byte, 4-8 + m_serialData.dcbControlBlock.XonChar; // Tx and Rx XON character + m_serialData.dcbControlBlock.XoffChar; // Tx and Rx XOFF character + m_serialData.dcbControlBlock.ErrorChar; // error replacement character + m_serialData.dcbControlBlock.EofChar; // end of input character + m_serialData.dcbControlBlock.EvtChar; // received event character + m_serialData.dcbControlBlock.wReserved1; // reserved; do not use +*/ + return(rc); +} + +int CCommSerial::Receive(bool bResponse) +{ // option is for blocking or non-blocking + int rc = COMMRET_SUCCESS; + + if (commActive == false) + rc = COMMRET_ERROR; + +#ifdef _forLinux // select the serial port to see if data pending first... + // do a select first to see if there is data there + fd_set serSet; + timeval waitFor = {0L,timeout}; // do non-blocking select + timeval *waitForPtr; + // these are the two timeval members + //long tv_sec; /* seconds */ + //long tv_usec; /* and microseconds */ + + if(timeout == -1){ + waitForPtr = NULL; + } + else{ + waitForPtr = &waitFor; + } + + FD_ZERO(&serSet); //Initializes the set to the NULL set. + FD_SET(m_hComm, &serSet); // Adds descriptor s to set. + rc = select(m_hComm+1,&serSet,NULL,NULL,waitForPtr); + // select() returns the number of ready fd's, or zero for timeout, or -1 for error. + + if (rc >= 1) { // normal condition + rc = packet_read(bResponse); + } + else if (rc == 0) { // timed out: + rc = COMMRET_TIMED_OUT; + } + else { // rc < 0; error: + rc = COMMRET_ERROR; + } + +#else + rc = packet_read(bResponse); + +#ifdef VERBOSE_READ_PKT + if (rc == COMMRET_ERROR) + TRACE("Error Receiving\n"); +#endif + +#endif + + return(rc); +} + +int CCommSerial::Send(int nLoops) +{ + int rc = COMMRET_SUCCESS; + // bool bSuccess = false; + // unsigned long dwRead; + // char ch = NAK; + int flags = 0; + m_error = COMMRET_ERROR; + + if (commActive == false) + { + rc = COMMRET_ERROR; + goto EXIT_S; + } + int maxLoops = nLoops; + do /* Loop until packet received correctly, ACK received */ + { + TRACE("Sending Packet x %d\n", (maxLoops - nLoops + 1)); + // clear the flags before sending again + flags = m_flags; + rc = packet_send(); /* send body of command */ + // if this is a ACK/NAK send, then do NOT wait for response! + if(m_flags & (FLAGS_MSG_TYPE_NAK|FLAGS_MSG_TYPE_ACK)) + break; + resetInBuffer(); + TRACE("Waiting for Response Packet x %d\n", (maxLoops - nLoops + 1)); + + if ((rc = Receive(true)) == COMMRET_SUCCESS) { + if (m_flags & FLAGS_MSG_TYPE_NAK) { + TRACE("Recv x %d: NAK. Error = %d (%s)\n", (maxLoops - nLoops + 1), m_error, ErrorString(m_error)); + } + else { + if (m_flags & FLAGS_MSG_TYPE_ACK) { + TRACE("Recv x %d: ACK\n", (maxLoops - nLoops + 1)); + break; + } + } + } + + m_flags = flags; + nLoops--; + } + while(nLoops > 0); + + // reset the output length and pointer + resetOutBuffer(); + +EXIT_S: + return(rc); +} + +int CCommSerial::SendSync() +{ + int rc = COMMRET_SUCCESS; + unsigned char c = 'S'; + unsigned long dwWrote; + + if (commActive == false) + { + rc = COMMRET_ERROR; + goto EXIT_SS; + } + + if(!WriteFile(m_hComm, (char *)&c, 1, &dwWrote, NULL)) + { + rc = COMMRET_ERROR; + } + +EXIT_SS: + return(rc); +} + +int CCommSerial::Close() +{ + int rc = COMMRET_SUCCESS; + +#ifdef _forLinux + if(close(m_hComm) == 0) + rc = COMMRET_ERROR; +#else + if(CloseHandle(m_hComm) == 0) + rc = COMMRET_ERROR; +#endif + return(rc); +} + +int CCommSerial::Open() +{ + int rc = COMMRET_ERROR; + + if(commActive == true ) + { + switch(whatIAm) + { + case opClient: + rc = Connect(); + break; + case opServer: + rc = Connect(); + break; + default: + rc = COMMRET_ERROR; + break; + } + } + return(rc); +} + +int CCommSerial::Connect() +{ + int rc = COMMRET_SUCCESS; + +#ifdef _forLinux + char serStr[20]; + sprintf(serStr,"/dev/ttyS%1d",m_serialData.comPort); + if((m_hComm = open(serStr,O_RDWR)) == -1){ + rc = COMMRET_ERROR; + } +#else + DCB dcb; + char strPortName[5]; + sprintf_s(strPortName, "COM%.1d", m_serialData.comPort); + m_hComm = CreateFile((const char *)strPortName, + GENERIC_READ | GENERIC_WRITE, + 0, // comm devices must be opened w/exclusive-access + NULL, // no security attrs + OPEN_EXISTING, // comm devices must use OPEN_EXISTING + 0, // not overlapped I/O + NULL // hTemplate must be NULL for comm devices + ); + + if (m_hComm == INVALID_HANDLE_VALUE) + { + rc = COMMRET_ERROR; + // MessageBox(NULL,"BAD Handle on CreateFile connect.",NULL,MB_OK); + MessageBox(NULL,"Another application has this COM port open. \nEither close the application that is using \nthis COM port or choose another COM port.",NULL,MB_OK); + } + else + { + if(!GetCommState(m_hComm, &dcb)) + { + rc = COMMRET_ERROR; + MessageBox(NULL,"Error getting Comm State",NULL,MB_OK); + } + else + { + dcb.BaudRate = m_serialData.dcbControlBlock.BaudRate; + dcb.ByteSize = m_serialData.dcbControlBlock.ByteSize; + dcb.Parity = m_serialData.dcbControlBlock.Parity; + dcb.StopBits = m_serialData.dcbControlBlock.StopBits; + + if(!SetCommState(m_hComm, &dcb)) + { + rc = COMMRET_ERROR; + char str[100]; + long perr = GetLastError(); + sprintf_s(str, "Error Setting Comm State: %d, %s", perr, strerror(perr) ); + MessageBox(NULL,str,NULL,MB_OK); + } + SetTimeout(m_readTimeout); + } + } +#endif + + return(rc); +} + +#ifdef _forLinux +bool CCommSerial::SetTimeout(int timeout) { + bool rb = true; + return rb; +} +int CCommSerial::GetTimeout() { + return m_readTimeout; +} +#else +bool CCommSerial::SetTimeout(int timeout){ + COMMTIMEOUTS cto; + bool rb = true; + if (m_hComm != INVALID_HANDLE_VALUE){ + if(!GetCommTimeouts(m_hComm, &cto)) + { + rb = false; + MessageBox(NULL,"Error getting Comm Timeouts",NULL,MB_OK); + } + else + { + cto.ReadTotalTimeoutConstant = timeout; + cto.ReadTotalTimeoutMultiplier = 1; + + if(!SetCommTimeouts(m_hComm, &cto)) + { + rb = false; + char str[100]; + long perr = GetLastError(); + sprintf_s(str, "Error Setting Comm Timeouts: %d, %s", perr, strerror(perr) ); + MessageBox(NULL,str,NULL,MB_OK); + } + } + } + return rb; +} + +int CCommSerial::GetTimeout(){ + COMMTIMEOUTS cto; + if (m_hComm != INVALID_HANDLE_VALUE){ + if(!GetCommTimeouts(m_hComm, &cto)) + { + MessageBox(NULL,"Error getting Comm Timeouts",NULL,MB_OK); + } + else + { + m_readTimeout = cto.ReadTotalTimeoutConstant; + } + } + return m_readTimeout; +} +#endif + +unsigned short CCommSerial::CRC_Calc(unsigned char * s, unsigned short msglen, unsigned short CRCval) +{ + short i; + + i = msglen; + while (--i >= 0) + { + CRCval += (unsigned short)(*s++); + } + + return (CRCval); +} + +unsigned char CCommSerial::CRC_Calc8(unsigned char * buf, unsigned short nbytes) +{ + unsigned char poly, j, bit_point, crc_reg = ~0; + unsigned short i; + + for (i = 0; i < nbytes; ++i, ++buf) + { + for (j = 0, bit_point = 0x80; j<8; ++j, bit_point >>= 1) + { + if (bit_point & *buf) // case for new bit =1 + { + poly = (crc_reg & 0x80) ? 1 : 0x1c; + crc_reg = ((crc_reg << 1) | 1) ^ poly; + } + else // case for new bit =0 + { + poly = (crc_reg & 0x80) ? 0 : 0x1d; + crc_reg = (crc_reg << 1) ^ poly; + } + } + } + return ~crc_reg; +} + +int CCommSerial::packet_read(bool bResponse) +{ + int rc = COMMRET_SUCCESS; + unsigned long dwRead, dwWrote, totalRead; + short packetLen; + unsigned char crc8a = 0; + unsigned char crc8b = 0; + int hdrIdx = 0; + bool resync = true; + int dataLen, max, readHdrAttempts = 0; + unsigned char cBuf[HEADER_SIZE] = { '0', '1', '2', '3', '4' }; + unsigned char sentinel[HEADER_SIZE] = { '0', '1', '2', '3', '4' }; + static unsigned char nak[HEADER_SIZE] = { COMM_HEADER, FLAGS_MSG_TYPE_NAK | FLAGS_DL_DATA_BYTE, 0, 0, 0 }; + + /* maximum times to try reading packet */ + max = DEFAULT_MAX_NAKS; + inPtr = &inputBuffer[0]; + m_bCancelRead = false; +#ifdef VERBOSE_READ_PKT + TRACE("START packet_read \n"); +#endif + do + { +#ifdef VERBOSE_READ_PKT + TRACE("Reading Header : Size = %d (x %d)\n", HEADER_SIZE, (DEFAULT_MAX_NAKS - max + 1)); +#endif + ReadFile(m_hComm, (char *)&cBuf[0], 1, &dwRead, NULL); + int resyncCount = inMaxLen + 1; + while (cBuf[0] != COMM_HEADER && resyncCount-- > 0) { + ReadFile(m_hComm, (char *)&cBuf[0], 1, &dwRead, NULL); + } + hdrIdx = 1; + if (!ReadFile(m_hComm, (char *)&cBuf[hdrIdx], HEADER_SIZE-hdrIdx, &dwRead, NULL)) { + if ((rc = GetLastError()) == 0) { + if (m_bCancelRead) + break; + continue; + } + rc = COMMRET_ERROR; + break; + } + if (dwRead != HEADER_SIZE-hdrIdx) { + rc = GetLastError(); + TRACE("Read Attempt did not read HEADER_SIZE (rc=%d). Trying AGAIN (Read %d bytes).\n", rc, dwRead); + if (rc == 0) { + totalRead = dwRead+hdrIdx; + hdrIdx += dwRead; + while (++readHdrAttempts <= 20 && totalRead != HEADER_SIZE) { + TRACE(" Read Header Attempt %d/20\n", readHdrAttempts); + if (!ReadFile(m_hComm, (char *)&cBuf[hdrIdx], HEADER_SIZE - totalRead, &dwRead, NULL)) { + if ((rc = GetLastError()) == 0) { + if (m_bCancelRead) + break; + continue; + } + else { // Read Comm error + rc = COMMRET_ERROR; + break; + } + } + totalRead += dwRead; + hdrIdx += dwRead; + TRACE(" Read: %d Total: %d ->cBuf[%d]\n", dwRead, totalRead, hdrIdx); + } + } + else { + rc = COMMRET_ERROR; + continue; + } + } + if (!memcmp(&cBuf[0], &sentinel[0], HEADER_SIZE)) { + rc = GetLastError(); +#ifdef VERBOSE_READ_PKT + TRACE("Read Attempt did not read Valid Buffer (rc=%d). Trying AGAIN.\n", rc); +#endif + rc = COMMRET_ERROR; + continue; + } + m_flags = cBuf[1]; + m_command = cBuf[2]; + packetLen = cBuf[3]; + crc8a = cBuf[4]; + + TRACE("READ Header: %02X %02X %02X %02X %02X \n", + cBuf[0], + cBuf[1], + cBuf[2], + cBuf[3], + cBuf[4]); + + nak[2] = m_command; + nak[4] = CRC_Calc8(nak, 4); + + // if NOT a ACK or NAK, then check validity first... + // check validity of header + if (cBuf[0] != COMM_HEADER) { + TRACE("*** Header Corrupt. header = %c\n", cBuf[0]); + rc = COMMRET_ERROR; + if (!bResponse) { + TRACE("*** sending NAK, Error = 0xEE\n"); + nak[3] = ERR_INVALID_HDR; // 0xEE; + WriteFile(m_hComm, &nak[0], HEADER_SIZE, &dwWrote, NULL);/* send not-acknowledge, reread packet */ + continue; + } + } + + // check Header CRC + crc8b = CRC_Calc8(&cBuf[0], 4); + if (crc8a != crc8b) { + /* Checksum not correct */ + TRACE("*** Header CRC incorrect, calc = %04x, read = %04x\n", crc8b, crc8a); + rc = COMMRET_ERROR; + if (!bResponse) { + TRACE("*** sending NAK, Error = 0x02\n"); + /* send not-acknowledge, reread packet */ + nak[3] = ERR_INVALID_HDR_CRC; + if (!WriteFile(m_hComm, &nak[0], HEADER_SIZE, &dwWrote, NULL))/* send not-acknowledge, reread packet */ + { + continue; + } + } + } + // reset the inLen + inLen = 0; + if (m_flags & FLAGS_DL_DATA_BYTE) { + // save the single data byte in the Error field + m_error = cBuf[3]; +#ifdef VERBOSE_READ_PKT + TRACE("Single Data Byte (0x%x = %s). Return COMMRET_SUCCESS.\n", m_error, ErrorString(m_error)); +#endif + rc = COMMRET_SUCCESS; + break; + } + else { // copy the data into the input buffer + m_error = 0; + /* Read body of command */ + dataLen = packetLen; + if (dataLen > inMaxLen) + { + /* inBuffer too small for all characters */ + TRACE("*** Buffer too small, size = %d, data = %d\n", inMaxLen, dataLen); + TRACE("*** sending NAK, Error = 0x03\n"); + nak[3] = ERR_DATA_LENGTH_EXCEEDS_BLK_SIZE; // 0xEF; + if (!WriteFile(m_hComm, &nak[0], HEADER_SIZE, &dwWrote, NULL))/* send not-acknowledge, reread packet */ + { + rc = COMMRET_ERROR; + continue; + } + } + else + { + inLen = dataLen; + totalRead = 0; + // NOTE: need to check - if NO data - do we still have a CRC? (of 0) + if (inLen > 0) { + TRACE("Reading Data Payload: Size = %d ( + CRC_SIZE of %d)\n", dataLen, CRC_SIZE); + if (!ReadFile(m_hComm, (char *)inputBuffer, (dataLen + CRC_SIZE), &dwRead, NULL)) { + rc = COMMRET_ERROR; + break; + } + totalRead = dwRead; + if (dwRead != (dataLen + CRC_SIZE)) { + int toRead = (dataLen + CRC_SIZE) - totalRead; + TRACE("ERROR. Did NOT Read in (dataLen+CRC_SIZE) = %d. Read %d bytes.\n", (dataLen + CRC_SIZE), dwRead); + int nLoops = 10; + while (totalRead != (dataLen + CRC_SIZE)) { + if (nLoops-- == 0) { + nLoops = -1; + break; + } + if (!ReadFile(m_hComm, (char *)&inputBuffer[totalRead], toRead, &dwRead, NULL)) { + nLoops = -1; + break; + } + totalRead += dwRead; + toRead = (dataLen + CRC_SIZE) - totalRead; + } + if (nLoops == -1) { + rc = COMMRET_ERROR; + break; + } + } + crc8a = inputBuffer[dataLen]; + crc8b = CRC_Calc8(inputBuffer, dataLen); + + rc = COMMRET_SUCCESS; + /* Verify CRC */ + if (crc8a == crc8b) + { + /* the upper protocol needs to send acknowledge */ + break; + } + TRACE("*** CRC incorrect, read = %04x, calc = %04x\n", crc8a, crc8b); + if (!bResponse) { + /* Checksum not correct */ + TRACE("*** sending NAK, Error = 0x04\n"); + /* send not-acknowledge, reread packet */ + nak[3] = ERR_INVALID_DATA_CRC; + if (!WriteFile(m_hComm, &nak[0], HEADER_SIZE, &dwWrote, NULL))/* send not-acknowledge, reread packet */ + { + rc = COMMRET_ERROR; + continue; + } + } + else + { + TRACE("*** CRC incorrect on a ACK/NAK response, read = %04x, calc = %04x\n", crc8a, crc8b); + rc = COMMRET_ERROR; + } + } + else + { +#ifdef VERBOSE_READ_PKT + TRACE("No Input Buffer Length. Returning COMMRET_SUCCESS.\n"); +#endif + rc = COMMRET_SUCCESS; + break; + } + } + } + } while (--max); + +#ifdef VERBOSE_READ_PKT + TRACE("END packet_read (rc = %d)\n", rc); +#endif + + return rc; +} + +int CCommSerial::packet_send() +{ + int rc = COMMRET_SUCCESS; + unsigned char pchPacketBuffer[MAX_PACKET_SIZE]; + short packetLen; + unsigned short crc1 = 0; + unsigned long dwWrote; + unsigned char crc8; + + TRACE("START packet_send (buffer: %6.6s)\n", outputBuffer); + + //packetLen = outLen + PACKET_OVERHEAD; /* send 2 bytes for byte count */ + //pchPacketBuffer[0] = (unsigned char)packetLen; + pchPacketBuffer[0] = COMM_HEADER; /* header character */ + pchPacketBuffer[1] = (unsigned char)m_flags; /* flag character */ + pchPacketBuffer[2] = (unsigned char)m_command; /* command character */ + pchPacketBuffer[3] = (unsigned char)outLen; /* byte count (or Single Data Byte) */ + crc8 = CRC_Calc8(pchPacketBuffer, 4); + pchPacketBuffer[4] = (unsigned char)crc8; /* Header CRC */ + + if (outLen > 0) { + packetLen = HEADER_SIZE + outLen + CRC_SIZE; // header size + outlen + data crc8 + } + else { + packetLen = HEADER_SIZE; + } + + // check to see if datalen field is length or a data byte + crc8 = 0; + if (!(m_flags & FLAGS_DL_DATA_BYTE)) { + + if (outLen > 0) { + TRACE("Copying Data Payload into outBuffer (size=%d) \n", outLen); + memcpy(pchPacketBuffer + DATA_OFFSET, outputBuffer, outLen); + // Calculate CRC value + crc8 = CRC_Calc8(outputBuffer, outLen); + } + } + else { + pchPacketBuffer[3] = (unsigned char)m_error; + // Calculate CRC value + crc8 = CRC_Calc8(outputBuffer, outLen); + } + + // Write CRC value to buffer + pchPacketBuffer[DATA_OFFSET + outLen] = (unsigned char)crc8; /* Header CRC */ + + TRACE("SEND Header: %02X %02X %02X %02X %02X : Data CRC : %02X \n", + pchPacketBuffer[0], + pchPacketBuffer[1], + pchPacketBuffer[2], + pchPacketBuffer[3], + pchPacketBuffer[4], + pchPacketBuffer[DATA_OFFSET + outLen]); + + // Write Buffer + if (!WriteFile(m_hComm, (char *)pchPacketBuffer, packetLen, &dwWrote, NULL)) + { + rc = COMMRET_ERROR; + goto EXIT_PS; + } + if (dwWrote != (unsigned long)(packetLen)) + { + rc = COMMRET_ERROR; + TRACE("ERROR. number bytes in buffer != number sent (%d)\n", dwWrote); + } +EXIT_PS: + TRACE("END packet_send \n"); + return(rc); +} + + +#ifdef _forLinux +bool ReadFile( HANDLE hFile, // handle of file to read + char *lpBuffer, // address of buffer that receives data + long nNumberOfBytesToRead, // number of bytes to read + unsigned long *lpNumberOfBytesRead, // address of number of bytes read + void *lpOverlapped // address of structure for data +){ + bool rc = true; + lpOverlapped = lpOverlapped; + int localRc = 0; + int bytesToRead = nNumberOfBytesToRead; + *lpNumberOfBytesRead = 0; + + while(*lpNumberOfBytesRead < nNumberOfBytesToRead){ + localRc = read((int)hFile, &lpBuffer[*lpNumberOfBytesRead], bytesToRead); + if(localRc == -1){ + if(errno != EINTR){ // read was interrupted before it could read anything... + rc = false; + break; + } + } + else{ + *lpNumberOfBytesRead += localRc; + bytesToRead -= localRc; + } + } + // last check for number of bytes actually read + if(*lpNumberOfBytesRead != nNumberOfBytesToRead) + rc = false; + + return(rc); +} + +bool WriteFile( HANDLE hFile, // handle to file to write to + char *lpBuffer, // pointer to data to write to file + long nNumberOfBytesToWrite, // number of bytes to write + unsigned long *lpNumberOfBytesWritten,// pointer to number of bytes written + void *lpOverlapped // pointer to structure needed for overlapped I/O +){ + bool rc = true; + lpOverlapped = lpOverlapped; + int localRc = 0; + int bytesToWrite = nNumberOfBytesToWrite; + + *lpNumberOfBytesWritten = 0; + + while(*lpNumberOfBytesWritten < nNumberOfBytesToWrite){ + localRc = write((int)hFile,&lpBuffer[*lpNumberOfBytesWritten], bytesToWrite); + if(localRc == -1){ + if(errno != EINTR){ // write was interrupted before it could write anything... + rc = false; + break; + } + } + else{ + *lpNumberOfBytesWritten += localRc; + bytesToWrite -= localRc; + } + } + // last check to see if total bytes written are actually written + if(*lpNumberOfBytesWritten != nNumberOfBytesToWrite) + rc = false; + + return(rc); +} +#endif \ No newline at end of file diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/CommObjSerial.h b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/CommObjSerial.h new file mode 100644 index 0000000..42508b1 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/CommObjSerial.h @@ -0,0 +1,99 @@ +// +// CLASS: CCommSerial +// +// Author: Steve Kuznicki +// + +#ifndef __INCCCommSerial +#define __INCCCommSerial + +#pragma pack(push,4) + +#ifdef _forLinux + +#define CommDllExImport + +#include + +typedef int HANDLE; +#if !defined(ERR) || ((ERR) != -1) +#define ERR (-1) +#endif + +#else + +#ifdef EIM_DLL_Compile +#define EIM_DLL_Export +#else +#define EIM_DLL_Import +#endif + +#ifdef EIM_DLL_Export +#define CommDllExImport __declspec( dllexport ) +#endif + +#ifdef EIM_DLL_Import +#define CommDllExImport __declspec( dllimport ) +#endif + +#ifdef LOCAL_COMM +#undef CommDllExImport +#define CommDllExImport +#endif + +#endif + +#include "Commobj.h" + +enum COMMANDS +{ + CMD_PING = 0, + CMD_RESET = 1, + CMD_TELEM_DATA = 2, + CMD_SPECIAL_COMMAND = 100 +}; + +class CommDllExImport CCommSerial : public CComm { + private: + HANDLE m_hComm; + struct serialStruct { + unsigned short comPort; +#ifndef _forLinux + DCB dcbControlBlock; +#endif + char *pcInitString; + } m_serialData; + + bool m_bCancelRead; + unsigned short CRC_Calc(unsigned char *s, unsigned short msglen, unsigned short CRCval); + unsigned char CRC_Calc8(unsigned char * buf, unsigned short nbytes); + + int packet_send(); + int packet_read(bool bResponse = false); + protected: + int Connect(); + // int Listen(); + int initSerialComm(); + public: + // Constructors + CCommSerial(); + CCommSerial(opMode om); + CCommSerial(char *configStr, opMode om); + ~CCommSerial(); + + // Base Class Member Functions + // these are the commands that need to be provided for each mode of communication + int Init(char *configString); + int Open(); + int Close(); + int Receive(bool response = false); + int SendSync(); + int Send(int nLoops = DEFAULT_MAX_NAKS); + bool SetTimeout(int to); + int GetTimeout(); + +}; + +#pragma pack(pop) +#endif + diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/Commobj.h b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/Commobj.h new file mode 100644 index 0000000..9a3bbe8 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/Commobj.h @@ -0,0 +1,231 @@ +// +// CLASS: CComm +// +// Author: Steve Kuznicki +// + +#ifndef __INCCComm +#define __INCCComm + +#pragma pack(push,4) + +#ifdef _forLinux + +#define CommDllExImport + +#include +#include + +#else // _forLinux is not defined, use WINDOWS version: + +#ifdef EIM_DLL_Compile +#define EIM_DLL_Export +#else +#define EIM_DLL_Import +#endif + +#ifdef EIM_DLL_Export +#define CommDllExImport __declspec( dllexport ) +#endif + +#ifdef EIM_DLL_Import +#define CommDllExImport __declspec( dllimport ) +#endif + +#ifdef LOCAL_COMM +#undef CommDllExImport +#define CommDllExImport +#endif + +#include + +#endif // _forLinux, else clause + +// MACHINE SPECIFIC DEFINE, set to TRUE or FALSE depending on +// machine architecture (Motorola = FALSE, Intel = TRUE) +// ONLY Supports Big and Little Endian byte ORDER right now +// Typically TRUE = 1, and FALSE = 0 if not defined in your environment +#define LITTLE_ENDIAN true + +#define COMMRET_ERROR -1 +#define COMMRET_SUCCESS 0 +#define COMMRET_NO_DATA 1 +#define COMMRET_TIMED_OUT 2 +#define COMMRET_ALIVE 3 + +#define COMM_HEADER 'X' + +#define FLAG_SIZE 1 +#define COMMAND_SIZE 1 +#define CRC_SIZE 1 +#define LENGTH_SIZE 1 +#define HEADER_SIZE 5 +#define DATA_OFFSET 5 +#define DEFAULT_MAX_NAKS 3 +#define MAX_PACKET_SIZE 262 +#define PACKET_OVERHEAD (HEADER_SIZE+CRC_SIZE) +#define CRCTAB_SIZE 256 + +enum COMM_FLAGS +{ + FLAGS_MSG_TYPE_CMD = 0x00, + FLAGS_MSG_TYPE_NAK = 0x01, + FLAGS_MSG_TYPE_ACK = 0x02, + FLAGS_DL_DATA_BYTE = 0x04, + FLAGS_MSG_TYPE_MASK = 0x08 +}; + +enum COMM_ERR_MSGS +{ + ERR_NONE = 0, + ERR_INVALID_HDR_CRC = 1, + ERR_INVALID_DATA_CRC = 2, + ERR_UNSUPPORTED_CMD = 3, + ERR_INVALID_HDR = 4, + ERR_INVALID_LENGTH_PARAM = 5, + ERR_DATA_LENGTH_EXCEEDS_BLK_SIZE = 6, + ERR_INVALID_FLAGS_COMBINATION = 7, +}; + +#ifdef _forLinux +#define COMMRET_WOULD_BLOCK 4 +#else // for winsuck +#define COMMRET_WOULD_BLOCK WSAEWOULDBLOCK +//#define EWOULDBLOCK WSAEWOULDBLOCK +#endif + +#ifndef NULL +#define NULL 0 +#endif + +char *ErrorString(int err); + +static char *errMsgStr[] = { + "No Error", + "Invalid Header CRC", + "Invalid Data CRC", + "Unsupported Command", + "Invalid Header", + "Invalid Length Parameter", + "Data Length Exceeds Block Size", + "Invalid Flags Combination", + "Special Command Invalid Parameter", + "Special Command Timed Out", + "Special Command Failed", +}; + +const int DEFAULT_IN_BUFF_LEN = 262; +const int DEFAULT_OUT_BUFF_LEN = 262; + +class CommDllExImport CComm { + public: + enum opMode {opClient = 0, opServer, opSpecial}; + protected: + unsigned char *inputBuffer, *inPtr; + unsigned char *outputBuffer, *outPtr; + int inMaxLen, outMaxLen; + int inLen, outLen; + char *argBuffer; + bool commActive; + opMode whatIAm; + bool waiting_for_command; + bool bSwapData; + int m_readTimeout; + short connectionTimeout; // time in seconds for connection timeout + inline bool IamLittleEndian(){return LITTLE_ENDIAN;} + inline bool NeedDataSwapped(){return bSwapData;} + unsigned short swapShort(unsigned short value); + unsigned int swapInt(unsigned int value); + unsigned int swapTriByte(unsigned int value); + unsigned long swapLong(unsigned long value); + unsigned long long swapLongLong(unsigned long long value); + bool bOpened; // TRUE when link (eg: socket) opened, FALSE when link is not open or was closed. + + // protocol specific vars + int m_command; + int m_flags; + int m_error; + + public: + // Constructors + CComm(){argBuffer = NULL;inputBuffer=NULL;outputBuffer=NULL;waiting_for_command=false;bSwapData=true;} + CComm(opMode om); + virtual ~CComm(); + + // these are the commands that need to be provided for each mode of communication + virtual int Open(); + virtual int Close(); + virtual int CancelReceive(); + virtual int Reset(int delay); + virtual int serverAcceptConnections(); + virtual int setBufferSizes(int inSize, int outSize); + virtual int Receive(bool response = false); + virtual int SendSync(); + virtual int Send(int test = 1); + virtual int Init(char *configString) = 0; + virtual bool ConnectionIsOpen(); + virtual char *GetErrString(); + virtual bool SetTimeout(int to){ return false; } + virtual int GetTimeout(){ return m_readTimeout; } + + // Base Class Member Functions + inline void SetHeaderInfo(int command, int flags){m_command = command; m_flags = flags;} + inline int getFlags(){return m_flags;} + inline int getCommand(){return m_command;} + inline int getError(){return m_error;} + inline void setError(int err){m_error = err;} + + inline void swapDataIs(bool sw){bSwapData = sw;} + inline int getInMaxBufferLen(){return inMaxLen;} + inline int getOutMaxBufferLen(){return outMaxLen;} + inline int getInLen(){return inLen;} + inline int getOutLen(){return outLen;} + inline unsigned char *outBuffer(){return outputBuffer;} + inline unsigned char *inBuffer(){return inputBuffer;} + inline unsigned char *getInPtr(){return inPtr;} + inline unsigned char *getOutPtr(){return outPtr;} + inline void resetInBuffer(){inLen = 0;inPtr = &inputBuffer[0];} + inline void resetOutBuffer(){outLen = 0;outPtr = &outputBuffer[0];} + inline void setOutLen(int rl){ outLen = rl;return;} + inline void setOutBuffer(unsigned char *ob){outputBuffer = ob; outPtr = ob;} + inline void setOutPtr(unsigned char *op){outPtr = op;} + inline void setInLen(int rl){ inLen = rl;return;} + inline void setInBuffer(unsigned char *ib){inputBuffer = ib; inPtr = ib;} + inline void setInPtr(unsigned char *ip){inPtr = ip;} + inline void setConnectionTimeout(short ct){ connectionTimeout = ct;return;} + // these functions operate on the buffers so they are common to all + int AllocateBuffers(); + char *ArgBuffer(); + char readChar(); // 8-bit + unsigned char readUChar(); // + short readShort(); // 16-bit + unsigned short readUShort(); // + int readTriByte(); // 24-bit + unsigned int readUTriByte(); // + long readLong(); // 32-bit + unsigned long readULong(); // + long long readLongLong(); // 64-bit + unsigned long long readULongLong(); // + char *readString(); // string + void *readBuffer(int len); // buffer + float readFloat(); // 32-bit single + double readDouble(); // 64-bit double + int writeChar(char data); // 8-bit + int writeUChar(unsigned char data); // + int writeShort(short data); // 16-bit + int writeUShort(unsigned short data); // + int writeTriByte(int data); // 24-bit + int writeUTriByte(unsigned int data); // + int writeLong(long data); // 32-bit + int writeULong(unsigned long); // + int writeLongLong(long long data); // 64-bit + int writeULongLong(unsigned long long); // + int writeString(char *data); // string + int writeBuffer(char *data, int len); // buffer + int writeFloat(float data); // 32-bit single + int writeDouble(double data); // 64-bit double +}; + +#pragma pack(pop) + +#endif diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/Resource.h b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/Resource.h new file mode 100644 index 0000000..cca8055 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/Resource.h @@ -0,0 +1,15 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by commobj.rc +// + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 101 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1000 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/asciidef.h b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/asciidef.h new file mode 100644 index 0000000..e617689 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/asciidef.h @@ -0,0 +1,72 @@ +#ifndef _ASCIIDEF_DOT_H +#define _ASCIIDEF_DOT_H +/* + * asciidef + * Most Low-order ASCII chars defined here. + */ + +#define NUL 0 +#define SOH 1 +#define STX 2 +#define ETX 3 +#define EOT 4 +#define ENQ 5 +#define ACK 6 +#define BEL 7 +#define BS 8 +#define HT 9 +#define LF 10 +#define VT 11 +#define FF 12 +#define CR 13 +#define SO 14 +#define SI 15 +#define DLE 16 +#define DC1 17 +#define DC2 18 +#define DC3 19 +#define DC4 20 +#define NAK 21 +#define SYN 22 +#define ETB 23 +#define CAN 24 +#define EM 25 +#define SUB 26 +#define ESC 27 +#define FS 28 +#define GS 29 +#define RS 30 +#define US 31 + +#define XON 17 +#define XOFF 19 + +#define CTRL_A 1 +#define CTRL_B 2 +#define CTRL_C 3 +#define CTRL_D 4 +#define CTRL_E 5 +#define CTRL_F 6 +#define CTRL_G 7 +#define CTRL_H 8 +#define CTRL_I 9 +#define CTRL_J 10 +#define CTRL_K 11 +#define CTRL_L 12 +#define CTRL_M 13 +#define CTRL_N 14 +#define CTRL_O 15 +#define CTRL_P 16 +#define CTRL_Q 17 +#define CTRL_R 18 +#define CTRL_S 19 +#define CTRL_T 20 +#define CTRL_U 21 +#define CTRL_V 22 +#define CTRL_W 23 +#define CTRL_X 24 +#define CTRL_Y 25 +#define CTRL_Z 26 + +#endif /* #ifndef _ASCIIDEF_DOT_H */ + diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.cpp b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.cpp new file mode 100644 index 0000000..fe851e4 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.cpp @@ -0,0 +1,642 @@ +// +// CLASS: CComm +// +// Author: Steve Kuznicki +// +// this is the file containing the Comm Object's member functions + +#include "stdafx.h" + +#ifdef _forLinux +#include +#include +#else +#include +#endif + +#include +#include +#include "Commobj.h" + +char *ErrorString(int err) { + if (err >= 0 && err <= (sizeof(errMsgStr) / sizeof(char*))) { + return errMsgStr[err]; + } + return "Unknown Error"; +} + +#ifndef _forLinux +void errorMsg(char *fn, int ln, char *format, ...) +{ + va_list argptr; + char str[500]; + CString fStr; + + va_start( argptr, format ); + vsprintf( str, format, argptr ); + va_end( argptr ); + + fStr.Format("Error: %s File %s, Line %d",str, fn, ln); + fprintf(stderr,"%s\n",fStr); + MessageBox(NULL, fStr, "Communication Error", MB_OK|MB_TASKMODAL|MB_ICONEXCLAMATION); + return; +} +#endif + +// message definition +// +// byte 0: M (COMM_HEADER) +// byte 1: flags +// byte 2: command +// byte 3: data length (or 1 data byte - see flags) +// byte 4: header crc8 +// +// byte 4...n: data +// byte n+1: data crc8 +// +// note: all values are BIG endian +// + +// Flags Definitions... +// +// 7 6 5 4 3 2 1 0 +// x x x x x x x x +// | | | | | | |_|_ 00: message is a command +// | | | | | | 01: message is a NAK +// | | | | | | 10: message is an ACK +// | | | | | | 11: reserved +// | | | | | | +// | | | | | |_____ 0: data length field contains length +// | | | | | 1: data length field contains 1 data byte (or err code for NAK) +// | | | | | +// |_|_|_|_|_______ 0: reserved +// 1: reserved + +// Constructors +CComm::CComm(opMode om){ + argBuffer = NULL; + inputBuffer=NULL; + outputBuffer=NULL; + waiting_for_command=false; + bSwapData=true; + whatIAm = om; + commActive = false; + bOpened = false; + m_error = 0; + setConnectionTimeout(1); + setBufferSizes(DEFAULT_IN_BUFF_LEN, DEFAULT_OUT_BUFF_LEN); +} + +// Destructors +CComm::~CComm(){ + // Buffers which were allocated in AllocateBuffers() + // are free'd in the individual sub-classes. +} + +// Member Functions +int CComm::AllocateBuffers(){ + int rc = COMMRET_SUCCESS; + if(inputBuffer != NULL){ + free(inputBuffer); + inputBuffer = NULL; + } + if((inputBuffer = (unsigned char *)malloc(inMaxLen)) == NULL){ + rc = COMMRET_ERROR; // don't exit yet, try the outputBuffer + } + if(outputBuffer != NULL){ + free(outputBuffer); + outputBuffer = NULL; + } + if((outputBuffer = (unsigned char *)malloc(outMaxLen)) == NULL){ + rc = COMMRET_ERROR; + goto EXIT_AB; + } +EXIT_AB: + return(rc); +} + +int CComm::setBufferSizes(int inSize, int outSize){ + int rc = COMMRET_SUCCESS; + inMaxLen = inSize; + outMaxLen = outSize; + AllocateBuffers(); + return(rc); +} + +char *CComm::ArgBuffer(){ + if(!argBuffer) + argBuffer = (char *)malloc(inMaxLen); + return argBuffer; +} + + +int CComm::Close(){ + int rc = COMMRET_SUCCESS; + return(rc); +} + +int CComm::Open(){ + int rc = COMMRET_SUCCESS; + return(rc); +} + +bool CComm::ConnectionIsOpen(){ + return bOpened; +} + +int CComm::CancelReceive(){ + int rc = COMMRET_SUCCESS; + return(rc); +} + +int CComm::serverAcceptConnections(){ + int rc = COMMRET_SUCCESS; + return(rc); +} + +int CComm::Receive(bool bResponse){ // option is for checking for commmand for responses + int rc = COMMRET_SUCCESS; + if(commActive == false){ + rc = COMMRET_ERROR; + } + // to avoid compiler warning: + bResponse = bResponse; + return(rc); +} + +int CComm::Send(int test){ + int rc = COMMRET_SUCCESS; + if(commActive == false){ + rc = COMMRET_ERROR; + } + return(rc); +} + +int CComm::SendSync(){ + int rc = COMMRET_SUCCESS; + if(commActive == false){ + rc = COMMRET_ERROR; + } + return(rc); +} + +int CComm::Reset(int delay){ + int rc = COMMRET_SUCCESS; + +#ifdef _forLinux + // from : struct timespec { long tv_sec, tv_nsec; } ; + struct timespec tspec; + tspec.tv_sec = 0; + tspec.tv_nsec = delay*1000; // '*1000' converts millisecs to nanoseconds + nanosleep( &tspec, NULL ); //ignore the result code; may get no sleep +#else + Sleep(delay); +#endif + + return(rc); +} + +char * CComm::GetErrString(){ + return NULL; +} + +char CComm::readChar(){ + char rval = 0; + + if((char *)inPtr <= (char *)(inputBuffer+inMaxLen-1)){ + rval = (char)inPtr[0]; + inPtr += sizeof(char); + } + return(rval); +} + +unsigned char CComm::readUChar(){ + unsigned char rval = 0; + + if((char *)inPtr <= (char *)(inputBuffer+inMaxLen-1)){ + rval = (unsigned char)inPtr[0]; + inPtr += sizeof(char); + } + return(rval); +} + +short CComm::readShort(){ + short rval = 0; + + if((char *)inPtr <= (char *)(inputBuffer+inMaxLen-1)){ + rval = (short)inPtr; + memcpy(&rval,inPtr,sizeof(short)); + inPtr += sizeof(short); + } + if(IamLittleEndian() && NeedDataSwapped()){ + rval = (signed short)swapShort((unsigned short)rval); + } + return(rval); +} + +unsigned short CComm::readUShort(){ + unsigned short rval = 0; + + if((char *)inPtr <= (char *)(inputBuffer+inMaxLen-1)){ + memcpy(&rval,inPtr,sizeof(short)); + inPtr += sizeof(short); + } + if(IamLittleEndian() && NeedDataSwapped()){ + rval = (unsigned short)swapShort((unsigned short)rval); + } + return(rval); +} + +int CComm::readTriByte(){ + long rval = 0L; + + if((char *)inPtr <= (char *)(inputBuffer+inMaxLen-1)){ + memcpy(&rval,inPtr,3); + inPtr += 3; + } + if(IamLittleEndian() && NeedDataSwapped()){ + rval = (signed int)swapTriByte((unsigned int)rval); + } + return(rval); +} + +unsigned int CComm::readUTriByte(){ + unsigned int rval = 0L; + + if((char *)inPtr <= (char *)(inputBuffer+inMaxLen-1)){ + memcpy(&rval,inPtr,3); + inPtr += 3; + } + if(IamLittleEndian() && NeedDataSwapped()){ + rval = (unsigned int)swapTriByte((unsigned int)rval); + } + return(rval); +} + +long CComm::readLong(){ + long rval = 0L; + + if((char *)inPtr <= (char *)(inputBuffer+inMaxLen-1)){ + memcpy(&rval,inPtr,sizeof(long)); + inPtr += sizeof(long); + } + if(IamLittleEndian() && NeedDataSwapped()){ + rval = (signed long)swapLong((unsigned long)rval); + } + return(rval); +} + +unsigned long CComm::readULong(){ + unsigned long rval = 0L; + + if((char *)inPtr <= (char *)(inputBuffer+inMaxLen-1)){ + memcpy(&rval,inPtr,sizeof(long)); + inPtr += sizeof(long); + } + if(IamLittleEndian() && NeedDataSwapped()){ + rval = (unsigned long)swapLong((unsigned long)rval); + } + return(rval); +} + +long long CComm::readLongLong() { + long long rval = 0L; + + if ((char *)inPtr <= (char *)(inputBuffer + inMaxLen - 1)) { + memcpy(&rval, inPtr, sizeof(long long)); + inPtr += sizeof(long long); + } + if (IamLittleEndian() && NeedDataSwapped()) { + rval = (signed long long)swapLongLong((unsigned long long)rval); + } + return(rval); +} + +unsigned long long CComm::readULongLong() { + unsigned long long rval = 0L; + + if ((char *)inPtr <= (char *)(inputBuffer + inMaxLen - 1)) { + memcpy(&rval, inPtr, sizeof(long long)); + inPtr += sizeof(long long); + } + if (IamLittleEndian() && NeedDataSwapped()) { + rval = (unsigned long long)swapLongLong((unsigned long long)rval); + } + return(rval); +} + + +char *CComm::readString(){ + char *rval = NULL; + + if((char *)inPtr <= (char *)(inputBuffer+inMaxLen-1)){ + rval = (char *)inPtr; + while(inPtr[0]){ + if((char *)inPtr > (char *)(inputBuffer+inMaxLen-1)){ + break; + } + inPtr++; + } + inPtr++; + } + return(rval); +} + +void *CComm::readBuffer(int len){ + void *rval = NULL; + + if((char *)inPtr <= (char *)(inputBuffer+inMaxLen-1)){ + rval = (char *)inPtr; + memcpy(rval, inPtr, len); + inPtr += len; + } + return(rval); +} + +float CComm::readFloat(){ + float rval = (float)0.0; + + if((char *)inPtr <= (char *)(inputBuffer+inMaxLen-1)){ + memcpy(&rval,inPtr,sizeof(float)); + inPtr += sizeof(float); + } + return(rval); +} + +double CComm::readDouble(){ + double rval = 0.0; + + if((char *)inPtr <= (char *)(inputBuffer+inMaxLen-1)){ + memcpy(&rval,inPtr,sizeof(double)); + inPtr += sizeof(double); + } + return(rval); +} + +int CComm::writeChar(char data){ + int rc = COMMRET_SUCCESS; + + if((char *)outPtr <= (char *)(outputBuffer+outMaxLen-1)){ + outPtr[0] = data; + outPtr += sizeof(char); + outLen += sizeof(char); + } + else + rc = COMMRET_ERROR; + return(rc); +} + +int CComm::writeUChar(unsigned char data){ + int rc = COMMRET_SUCCESS; + + if((char *)outPtr <= (char *)(outputBuffer+outMaxLen-1)){ + outPtr[0] = data; + outPtr += sizeof(char); + outLen += sizeof(char); + } + else + rc = COMMRET_ERROR; + return(rc); +} + +int CComm::writeShort(short data){ + int rc = COMMRET_SUCCESS; + + if(IamLittleEndian() && NeedDataSwapped()){ + data = (signed short)swapShort((unsigned short)data); + } + if((char *)outPtr <= (char *)(outputBuffer+outMaxLen-sizeof(short))){ + memcpy(outPtr,(const void *)&data,sizeof(short)); + outPtr += sizeof(short); + outLen += sizeof(short); + } + else + rc = COMMRET_ERROR; + return(rc); +} + +int CComm::writeUShort(unsigned short data){ + int rc = COMMRET_SUCCESS; + + if(IamLittleEndian() && NeedDataSwapped()){ + data = (unsigned short)swapShort((unsigned short)data); + } + if((char *)outPtr <= (char *)(outputBuffer+outMaxLen-sizeof(short))){ + memcpy(outPtr,(const void *)&data,sizeof(short)); + outPtr += sizeof(short); + outLen += sizeof(short); + } + else + rc = COMMRET_ERROR; + return(rc); +} + +// Write three bytes of signed data +int CComm::writeTriByte(int data){ + int rc = COMMRET_SUCCESS; + if(IamLittleEndian() && NeedDataSwapped()){ + data = (signed int)swapTriByte((unsigned int)data); + } + if((char *)outPtr <= (char *)(outputBuffer+outMaxLen-3)){ + memcpy(outPtr,(const void *)&data, 3); + outPtr += 3; + outLen += 3; + } + else + rc = COMMRET_ERROR; + return(rc); +} + +// Write three bytes of unsigned data +int CComm::writeUTriByte(unsigned int data){ + int rc = COMMRET_SUCCESS; + + if(IamLittleEndian() && NeedDataSwapped()){ + data = (unsigned int)swapTriByte((unsigned int)data); + } + if((char *)outPtr <= (char *)(outputBuffer+outMaxLen-3)){ + memcpy(outPtr,(const void *)&data, 3); + outPtr += 3; + outLen += 3; + } + else + rc = COMMRET_ERROR; + return(rc); +} + +int CComm::writeLong(long data){ + int rc = COMMRET_SUCCESS; + + if(IamLittleEndian() && NeedDataSwapped()){ + data = (signed long)swapLong((unsigned long)data); + } + if((char *)outPtr <= (char *)(outputBuffer+outMaxLen-sizeof(long))){ + memcpy(outPtr,(const void *)&data,sizeof(long)); + outPtr += sizeof(long); + outLen += sizeof(long); + } + else + rc = COMMRET_ERROR; + return(rc); +} + +int CComm::writeULong(unsigned long data){ + int rc = COMMRET_SUCCESS; + + if(IamLittleEndian() && NeedDataSwapped()){ + data = (unsigned long)swapLong((unsigned long)data); + } + if((char *)outPtr <= (char *)(outputBuffer+outMaxLen-sizeof(long))){ + memcpy(outPtr,(const void *)&data,sizeof(long)); + outPtr += sizeof(long); + outLen += sizeof(long); + } + else + rc = COMMRET_ERROR; + return(rc); +} + +int CComm::writeLongLong(long long data) { + int rc = COMMRET_SUCCESS; + + if (IamLittleEndian() && NeedDataSwapped()) { + data = (signed long long)swapLongLong((unsigned long long)data); + } + if ((char *)outPtr <= (char *)(outputBuffer + outMaxLen - sizeof(long long))) { + memcpy(outPtr, (const void *)&data, sizeof(long long)); + outPtr += sizeof(long long); + outLen += sizeof(long long); + } + else + rc = COMMRET_ERROR; + return(rc); +} + +int CComm::writeULongLong(unsigned long long data) { + int rc = COMMRET_SUCCESS; + + if (IamLittleEndian() && NeedDataSwapped()) { + data = (unsigned long long)swapLongLong((unsigned long long)data); + } + if ((char *)outPtr <= (char *)(outputBuffer + outMaxLen - sizeof(long long))) { + memcpy(outPtr, (const void *)&data, sizeof(long long)); + outPtr += sizeof(long long); + outLen += sizeof(long long); + } + else + rc = COMMRET_ERROR; + return(rc); +} + +int CComm::writeString(char *data){ + int rc = COMMRET_SUCCESS; + + if((char *)outPtr <= (char *)(outputBuffer+outMaxLen-strlen(data))){ + strcpy((char *)outPtr,data); + outPtr += strlen(data); + outLen += (int)strlen(data); + } + else + rc = COMMRET_ERROR; + return(rc); +} + +int CComm::writeBuffer(char *data, int len){ + int rc = COMMRET_SUCCESS; + + if((char *)outPtr <= (char *)(outputBuffer+outMaxLen-len)){ + memcpy((char *)outPtr,data,len); + outPtr += len; + outLen += len; + } + else + rc = COMMRET_ERROR; + return(rc); +} + +int CComm::writeFloat(float data){ + int rc = COMMRET_SUCCESS; + + if((char *)outPtr <= (char *)(outputBuffer+outMaxLen-sizeof(float))){ + memcpy(outPtr,(const void *)&data,sizeof(float)); + outPtr += sizeof(float); + outLen += sizeof(float); + } + else + rc = COMMRET_ERROR; + return(rc); +} + +int CComm::writeDouble(double data){ + int rc = COMMRET_SUCCESS; + + if((char *)outPtr <= (char *)(outputBuffer+outMaxLen-sizeof(double))){ + memcpy(outPtr,(const void *)&data,sizeof(double)); + outPtr += sizeof(double); + outLen += sizeof(double); + } + else + rc = COMMRET_ERROR; + return(rc); +} + + +// this does a SAFE short 16-bit swap +// v = (((x & 0xff00) >> 8) | +// ((x & 0x00ff) << 8)); +unsigned short CComm::swapShort(unsigned short value){ + register unsigned short v = 0; + v = value&0xff; + v <<= 8; + v += ((value>>8)&0xff); + return(v); +} + +// this does a SAFE int 32-bit swap +unsigned int CComm::swapInt(unsigned int value){ + return(swapLong((unsigned long)value)); +} + +// this does a SAFE 24-bit swap +// v = (((x & 0xff0000) >> 16) | +// ((x & 0x00ff00) ) | +// ((x & 0x0000ff) << 16)); +unsigned int CComm::swapTriByte(unsigned int value){ + register unsigned int v = value; + v = ((v & 0xff) << 16) | (v & 0xff00) | ((v & 0xff0000) >> 16); + return(v); +} + +// this does a SAFE long 32-bit swap +// v = (((x & 0xff000000) >> 24) | +// ((x & 0x00ff0000) >> 8) | +// ((x & 0x0000ff00) << 8) | +// ((x & 0x000000ff) << 24)); +unsigned long CComm::swapLong(unsigned long value){ + register unsigned long v = 0; + v = value&0xffff; + v = (unsigned short)swapShort((unsigned short)v); + v <<= 16; + value >>= 16; + v += (unsigned short)swapShort((unsigned short)value); + return(v); +} + +// this does a SAFE long 64-bit swap +//v = (((x & 0xff00000000000000ULL) >> 56) | +// ((x & 0x00ff000000000000ULL) >> 40) | +// ((x & 0x0000ff0000000000ULL) >> 24) | +// ((x & 0x000000ff00000000ULL) >> 8) | +// ((x & 0x00000000ff000000ULL) << 8) | +// ((x & 0x0000000000ff0000ULL) << 24) | +// ((x & 0x000000000000ff00ULL) << 40) | +// ((x & 0x00000000000000ffULL) << 56)); +unsigned long long CComm::swapLongLong(unsigned long long value) { + register unsigned long long v = 0; + v = value & 0xffffffff; + v = (unsigned long)swapLong((unsigned long)v); + v <<= 32; + value >>= 32; + v += (unsigned long)swapLong((unsigned long)value); + return(v); +} diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.def b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.def new file mode 100644 index 0000000..bdf163b --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.def @@ -0,0 +1,7 @@ +; commobj.def : Declares the module parameters for the DLL. + +LIBRARY "commobj" + +EXPORTS +; Explicit exports can go here + diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.sln b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.sln new file mode 100644 index 0000000..e8002bd --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.sln @@ -0,0 +1,22 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2013 +VisualStudioVersion = 12.0.30110.0 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "commobj", "commobj.vcxproj", "{3F10E2A6-BE01-48CB-BD13-AC52EAB212D2}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {3F10E2A6-BE01-48CB-BD13-AC52EAB212D2}.Debug|Win32.ActiveCfg = Debug|Win32 + {3F10E2A6-BE01-48CB-BD13-AC52EAB212D2}.Debug|Win32.Build.0 = Debug|Win32 + {3F10E2A6-BE01-48CB-BD13-AC52EAB212D2}.Release|Win32.ActiveCfg = Release|Win32 + {3F10E2A6-BE01-48CB-BD13-AC52EAB212D2}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.vcproj b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.vcproj new file mode 100644 index 0000000..7e68f3d --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.vcproj @@ -0,0 +1,322 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.vcxproj b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.vcxproj new file mode 100644 index 0000000..3990bcb --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj.vcxproj @@ -0,0 +1,153 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {3F10E2A6-BE01-48CB-BD13-AC52EAB212D2} + commobj + MFCDLLProj + + + + DynamicLibrary + v140 + Dynamic + MultiByte + + + DynamicLibrary + v140 + Dynamic + MultiByte + + + + + + + + + + + + + + + <_ProjectFileVersion>14.0.25431.1 + + + Debug\ + Debug\ + true + + + Release\ + Release\ + false + + + + _DEBUG;%(PreprocessorDefinitions) + false + + + Disabled + WIN32;_WINDOWS;_DEBUG;_USRDLL;EIM_DLL_Compile;%(PreprocessorDefinitions) + true + EnableFastChecks + MultiThreadedDebugDLL + true + Use + Level3 + EditAndContinue + + + _DEBUG;%(PreprocessorDefinitions) + 0x0409 + $(IntDir);%(AdditionalIncludeDirectories) + + + $(OutDir)commobj.dll + .\commobj.def + true + Windows + $(OutDir)commobj.lib + MachineX86 + + + copy to commtest path + copy $(TargetPath) ..\commtest + + + + + + + NDEBUG;%(PreprocessorDefinitions) + false + + + MaxSpeed + OnlyExplicitInline + true + WIN32;_WINDOWS;NDEBUG;_USRDLL;EIM_DLL_Compile;%(PreprocessorDefinitions) + true + MultiThreadedDLL + true + true + Use + Level3 + ProgramDatabase + + + NDEBUG;%(PreprocessorDefinitions) + 0x0409 + $(IntDir);%(AdditionalIncludeDirectories) + + + $(OutDir)commobj.dll + .\commobj.def + true + Windows + true + true + $(OutDir)commobj.lib + MachineX86 + + + + + + + + + + + + + + + + Create + Create + + + + + + + + + + + + + \ No newline at end of file diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj1.rc b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj1.rc new file mode 100644 index 0000000..c03da26 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/commobj1.rc @@ -0,0 +1,101 @@ +// Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 1,0,0,1 + PRODUCTVERSION 1,0,0,1 + FILEFLAGSMASK 0x17L +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" + BEGIN + VALUE "FileDescription", "Comm Dynamic Link Library" + VALUE "FileVersion", "1, 0, 0, 1" + VALUE "InternalName", "commobj" + VALUE "LegalCopyright", "Copyright (C) 2005" + VALUE "OriginalFilename", "commobj.dll" + VALUE "ProductName", "Comm Dynamic Link Library" + VALUE "ProductVersion", "1, 0, 0, 1" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/hex2bin.cpp b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/hex2bin.cpp new file mode 100644 index 0000000..94ec814 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/hex2bin.cpp @@ -0,0 +1,68 @@ +#include "stdafx.h" +#include +#include +#include +#include +#include + +/* @function: Converts a two byte hex ascii number to binary. Returns + the binary form, or -1 for illegal hex number. */ +int hex_to_binary(unsigned char *hex) /* ptr to 2 byte hex code */ +{ + int i, binary[2]; + _strupr((char *)hex); + + for(i=0; i<2; ++i) + { + if('0' <= hex[i] && hex[i] <= '9') + binary[i] = hex[i] - '0'; + else if('A' <= hex[i] && hex[i] <= 'F') + binary[i] = hex[i] - 'A' + 10; + else + return -1; + } + return binary[0]*16 + binary[1]; +} + +/********************************* +* +* Function: char *strip(char *in) +* Inputs: char *in - a pointer to a string variable +* Outputs: the resulting string, striped of white space from the end +* Return: a pointer to the string +* +**********************************/ +char *strip(char *in){ + size_t len = strlen(in); + while(len--){ + if(isspace(in[len])) + in[len] = 0; + else + break; + } + return(in); +} + +/********************************* +* +* Function: unsigned long htol(char *in) +* Inputs: char *in - a pointer to a string variable +* Outputs: none +* Return: a long value corresponding to the value of the hex string +* +**********************************/ +unsigned long htol(char *in){ + static int hexVal[] = {0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,0,10,11,12,13,14,15}; + unsigned long val = 0L; + size_t len; + int i = 0; + _strupr(in); + if(in[1] == 'X') + in += 2; + strip(in); + len = strlen(in); + while(len--){ + val = val + (hexVal[in[(int)len]-'0'] * (unsigned long)(pow((float)16,(float)i++))); + } + return(val); +} diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/hex2bin.h b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/hex2bin.h new file mode 100644 index 0000000..3050db8 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/hex2bin.h @@ -0,0 +1,11 @@ +/********************************* +* +* Header File: hex2bin.h +* Purpose: Provides functions for converting char strings +* to canonical values +**********************************/ + +// * Function Prototypes * +int hex_to_binary(unsigned char *hex); +char *strip(char *in); +unsigned long htol(char *in); diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/res/commobj.rc2 b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/res/commobj.rc2 new file mode 100644 index 0000000..8933270 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/res/commobj.rc2 @@ -0,0 +1,13 @@ +// +// commobj.RC2 - resources Microsoft Visual C++ does not edit directly +// + +#ifdef APSTUDIO_INVOKED +#error this file is not editable by Microsoft Visual C++ +#endif //APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// Add manually edited resources here... + +///////////////////////////////////////////////////////////////////////////// diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/res/vssver.scc b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/res/vssver.scc new file mode 100644 index 0000000..613ed64 Binary files /dev/null and b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/res/vssver.scc differ diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/stdafx.cpp b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/stdafx.cpp new file mode 100644 index 0000000..ba85bc0 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/stdafx.cpp @@ -0,0 +1,8 @@ +// stdafx.cpp : source file that includes just the standard includes +// commtest.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/stdafx.h b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/stdafx.h new file mode 100644 index 0000000..6f9eae3 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commobj/stdafx.h @@ -0,0 +1,53 @@ +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently + +#pragma once + +#ifndef VC_EXTRALEAN +#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers +#endif + +// Modify the following defines if you have to target a platform prior to the ones specified below. +// Refer to MSDN for the latest info on corresponding values for different platforms. +#ifndef WINVER // Allow use of features specific to Windows 95 and Windows NT 4 or later. +#define WINVER 0x0501 // Change this to the appropriate value to target Windows 98 and Windows 2000 or later. +#endif + +#ifndef _WIN32_WINNT // Allow use of features specific to Windows NT 4 or later. +#define _WIN32_WINNT 0x0501 // Change this to the appropriate value to target Windows 2000 or later. +#endif + +#ifndef _WIN32_WINDOWS // Allow use of features specific to Windows 98 or later. +#define _WIN32_WINDOWS 0x0410 // Change this to the appropriate value to target Windows Me or later. +#endif + +#ifndef _WIN32_IE // Allow use of features specific to IE 4.0 or later. +#define _WIN32_IE 0x0400 // Change this to the appropriate value to target IE 5.0 or later. +#endif + +#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // some CString constructors will be explicit + +#include // MFC core and standard components +#include // MFC extensions + +#ifndef _AFX_NO_OLE_SUPPORT +#include // MFC OLE classes +#include // MFC OLE dialog classes +#include // MFC Automation classes +#endif // _AFX_NO_OLE_SUPPORT + +#ifndef _AFX_NO_DB_SUPPORT +#include // MFC ODBC database classes +#endif // _AFX_NO_DB_SUPPORT + +#ifndef _AFX_NO_DAO_SUPPORT +#include // MFC DAO database classes +#endif // _AFX_NO_DAO_SUPPORT + +#include // MFC support for Internet Explorer 4 Common Controls +#ifndef _AFX_NO_AFXCMN_SUPPORT +#include // MFC support for Windows Common Controls +#endif // _AFX_NO_AFXCMN_SUPPORT + +#include // MFC socket extensions diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commobj.dll b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commobj.dll new file mode 100644 index 0000000..32da17b Binary files /dev/null and b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commobj.dll differ diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commtest.cpp b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commtest.cpp new file mode 100644 index 0000000..61dc0cd --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commtest.cpp @@ -0,0 +1,235 @@ +// commtest.cpp : Defines the entry point for the console application. +// + +#include "stdafx.h" +#include +#include +#include +#include +#include +#include "commobj.h" +#include "commobjserial.h" + +using namespace std; + +CComm *g_comm; + +float gVersion = 1.0; +bool gbInit = false; + +static int membyte = 0; + +bool StartTx() { + bool rc = false; + bool done = false; + int numch, currNum; + char hdrkey = 'A'; + int count = 0, frame = 0, interval = 100; + char kp = 'a'; + float ch[30] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + cout << "Enter in configuration to send : " << endl; + cout << " Number Max Channels : "; + cin >> numch; + numch = min(numch, 30); + cout << " Transmit interval in millisec : "; + cin >> interval; + cout << "Sending " << numch << " channels per packet every " << interval << " milliseconds" << endl; + cout << "Press any key to start transmitting...Press 'q' to quit." << endl; + _getch(); + // start transmiting. Channel number value is channel + currNum = 1; + while (!done) { + //-------------------------------------------------------- + // THIS IS THE CODE THAT CREATES THE DATA PACKET AND SEND + g_comm->resetOutBuffer(); + g_comm->SetHeaderInfo(CMD_TELEM_DATA, FLAGS_MSG_TYPE_CMD); + g_comm->writeBuffer("PX4HD", 5); + g_comm->writeChar(hdrkey); + g_comm->writeUShort((unsigned short)currNum); + for (int idx = 0; idx < currNum; idx++) { + float v = ch[idx] + (float)(count*frame); + g_comm->writeFloat(v); + } + TRACE("SENDING: PX4HD%c NumCh:%d\n", hdrkey, currNum); + g_comm->Send(5); // 5 retries! + //-------------------------------------------------------- + // EXAMPLE: SEND PING CMD + //g_comm->resetOutBuffer(); + //g_comm->SetHeaderInfo(CMD_PING, FLAGS_MSG_TYPE_CMD); + //g_comm->writeBuffer("PING", 4); + //g_comm->writeULong(counter++); + //g_comm->Send(); + //-------------------------------------------------------- + if(currNum++ == numch) + currNum = 1; + if (hdrkey == 'Z') { + hdrkey = 'A'; + } + else { + hdrkey++; + } + if (_kbhit()) { + kp = _getch(); + if (kp == 'q') + done = true; + else + cout << "KeyPress " << kp << ". Press 'q' to quit." << endl; + } + count++; + if (count == 10) { + cout << "Tx+" << count << "[" << frame << "]" << endl; + count = 0; + frame++; + } + Sleep(interval); + } + return rc; +} + +bool StartRx() { + int rc = COMMRET_NO_DATA; + bool done = false; + int numch; + unsigned short val[10]; + double ts; + unsigned char *hdr; + int count = 0, frame = 0, interval = 100; + char kp = 'a'; + cout << "Press any key to start receiving. Press 'q' to quit." << endl; + g_comm->swapDataIs(false); + _getch(); + // start recv + while (!done) { + //-------------------------------------------------------- + // THIS IS THE CODE THAT ACCEPTS THE DATA PACKETS + rc = g_comm->Receive(); + TRACE("Receive rc = %d\n", rc); + if(rc == COMMRET_SUCCESS) { + hdr = (unsigned char *)g_comm->readBuffer(6); + numch = g_comm->readUShort(); + TRACE("RECV: %6.6s NumCh:%d\n", hdr, numch); + ts = g_comm->readDouble(); + numch = min(numch, 10); + for (int currNum = 0; currNum < numch; currNum++) { + val[currNum] = g_comm->readShort(); + } + TRACE(" ch[0-3]:%d %d %d %d\n", val[0], val[1], val[2], val[3]); + } + //-------------------------------------------------------- + if (_kbhit()) { + kp = _getch(); + if (kp == 'q') + done = true; + else + cout << "KeyPress " << kp << ". Press 'q' to quit." << endl; + } + count++; + if (count == 10) { + cout << "Tx+" << count << "[" << frame << "]" << endl; + count = 0; + frame++; + } + Sleep(interval); + } + return (rc==COMMRET_SUCCESS); +} + + +bool InitComm(){ + bool rb = true; + char commch; + char baudstr[20]; + + if(g_comm != NULL) + { + delete g_comm; + g_comm = NULL; + } + + g_comm = new CCommSerial(); + g_comm->AllocateBuffers(); + + char initStr[200]; + cout << "Enter in COM PORT Number 1, 2, ... : "; + cin >> commch; + cin.getline(&baudstr[0], 20); + cout << endl << "Enter in Baud Rate (e.g. 57600) : "; + cin.getline(&baudstr[0], 20); + cout << endl; + if (commch == 0) { + commch = '1'; + } + if (strlen(baudstr) == 0) { + strcpy_s(baudstr, "57600"); + } + sprintf_s(initStr, "COM%c: baud=%s parity=N data=8 stop=1", commch, baudstr); + if(g_comm->Init(initStr) == -1) + { + cout << "ERROR initializing COM Port with " << initStr << ". Try something else..." << endl; + gbInit = false; + } + cout << initStr << endl << endl; + if(g_comm->Open() == 0) + { + gbInit = true; + } + + return rb; +} + +bool WriteString(char *str){ + bool rb = true; + + g_comm->resetOutBuffer(); + g_comm->writeString(str); + g_comm->Send(); + + return rb; +} + +void DisplayMenuLoop(){ + char inch = 'Z'; + + while(inch != 'x'){ + cout << " ** Menu (FW Version = " << gVersion << ") **" << endl; + cout << " i = initialize COM port " << endl; + cout << " s = start sending serial data" << endl; + cout << " r = start receiving serial data" << endl; + cout << " x = exit " << endl; + cout << "Choose Menu Option: "; + cin >> inch; + cout << endl; + + switch(inch){ + case 'i': + InitComm(); + break; + case 's': + StartTx(); + break; + case 'r': + StartRx(); + break; + case 'x': + cout << "thanks. good-bye." << endl; + break; + default: + cout << "unknown command" << endl; + break; + } + } +} + + +int _tmain(int argc, _TCHAR* argv[]) +{ + DisplayMenuLoop(); + if(g_comm != NULL){ + g_comm->Close(); + delete g_comm; + } + return 0; +} + diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commtest.sln b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commtest.sln new file mode 100644 index 0000000..c6155a7 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commtest.sln @@ -0,0 +1,27 @@ +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 14 +VisualStudioVersion = 14.0.25420.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "commtest", "commtest.vcxproj", "{F03510D3-87DF-4D33-9DD8-667B80F973D7}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "commobj", "..\commobj\commobj.vcxproj", "{3F10E2A6-BE01-48CB-BD13-AC52EAB212D2}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {F03510D3-87DF-4D33-9DD8-667B80F973D7}.Debug|Win32.ActiveCfg = Debug|Win32 + {F03510D3-87DF-4D33-9DD8-667B80F973D7}.Debug|Win32.Build.0 = Debug|Win32 + {F03510D3-87DF-4D33-9DD8-667B80F973D7}.Release|Win32.ActiveCfg = Release|Win32 + {F03510D3-87DF-4D33-9DD8-667B80F973D7}.Release|Win32.Build.0 = Release|Win32 + {3F10E2A6-BE01-48CB-BD13-AC52EAB212D2}.Debug|Win32.ActiveCfg = Debug|Win32 + {3F10E2A6-BE01-48CB-BD13-AC52EAB212D2}.Debug|Win32.Build.0 = Debug|Win32 + {3F10E2A6-BE01-48CB-BD13-AC52EAB212D2}.Release|Win32.ActiveCfg = Release|Win32 + {3F10E2A6-BE01-48CB-BD13-AC52EAB212D2}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commtest.vcproj b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commtest.vcproj new file mode 100644 index 0000000..07262fb --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commtest.vcproj @@ -0,0 +1,234 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commtest.vcxproj b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commtest.vcxproj new file mode 100644 index 0000000..0ab9b4d --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/commtest.vcxproj @@ -0,0 +1,111 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {F03510D3-87DF-4D33-9DD8-667B80F973D7} + Win32Proj + + + + Application + v140 + MultiByte + + + Application + v140 + MultiByte + + + + + + + + + + + + + + + <_ProjectFileVersion>14.0.25431.1 + + + Debug\ + Debug\ + true + + + Release\ + Release\ + false + + + + Disabled + ..\commobj;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + EnableFastChecks + MultiThreadedDebug + Use + Level3 + EditAndContinue + + + $(OutDir)commtest.exe + true + $(OutDir)commtest.pdb + Console + MachineX86 + + + + + ..\commobj;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + MultiThreaded + Use + Level3 + ProgramDatabase + + + $(OutDir)commtest.exe + true + Console + true + true + MachineX86 + + + + + {3f10e2a6-be01-48cb-bd13-ac52eab212d2} + true + true + + + + + + Create + Create + + + + + + + + + \ No newline at end of file diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/stdafx.cpp b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/stdafx.cpp new file mode 100644 index 0000000..ba85bc0 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/stdafx.cpp @@ -0,0 +1,8 @@ +// stdafx.cpp : source file that includes just the standard includes +// commtest.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file diff --git a/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/stdafx.h b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/stdafx.h new file mode 100644 index 0000000..4697ed6 --- /dev/null +++ b/e0/2.PSPOfficialExps/SerialCommProtocolExample/commtest/stdafx.h @@ -0,0 +1,14 @@ +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#pragma once + + +#include +#include + +#include + +// TODO: reference additional headers your program requires here diff --git a/e0/2.PSPOfficialExps/datalog_A.bin b/e0/2.PSPOfficialExps/datalog_A.bin new file mode 100644 index 0000000..46e3861 Binary files /dev/null and b/e0/2.PSPOfficialExps/datalog_A.bin differ diff --git a/e0/2.PSPOfficialExps/pixhawk_A.bin b/e0/2.PSPOfficialExps/pixhawk_A.bin new file mode 100644 index 0000000..52150af Binary files /dev/null and b/e0/2.PSPOfficialExps/pixhawk_A.bin differ diff --git a/e0/2.PSPOfficialExps/px4_read_binary_file.m b/e0/2.PSPOfficialExps/px4_read_binary_file.m new file mode 100644 index 0000000..5380100 --- /dev/null +++ b/e0/2.PSPOfficialExps/px4_read_binary_file.m @@ -0,0 +1,61 @@ +%% Load the data into MATLAB from a binary log file +% Usage: >> [datapoints, numpoints] = readdata('datafile.log') +% Header information format: +% String "MWLOGV##" +% Time/Date 4 bytes (time()) +% Number of Signals per record Logged 1 bytes (256 max) +% Data Type of Signals Logged 1 bytes (1-10) +% Number of bytes per record 2 (65535 max) +% Plot Data Example: plot([1:numpoints], datapoints(1,:), [1:numpoints], datapoints(2,:)) +% MathWorks Pilot Engineering 2015 +% Steve Kuznicki +function [datapts, numpts] = px4_read_binary_file(dataFile) +%% +datapts = 0; +numpts = 0; + +if nargin == 0 + dataFile = 'data.bin'; +end + +fid = fopen(dataFile, 'r'); +% load the header information +hdrToken = fread(fid, 8, 'char'); +if strncmp(char(hdrToken),'MWLOGV',6) == true + logTime = uint32(fread(fid, 1, 'uint32')); + numflds = double(fread(fid, 1, 'uint8')); + typefld = uint8(fread(fid, 1, 'uint8')); + recSize = uint16(fread(fid, 1, 'uint16')); + fieldTypeStr = get_elem_type(typefld); + datapts = fread(fid, double([numflds, Inf]), fieldTypeStr); + fclose(fid); + numpts = size(datapts,2); +end + +end + +%% get the element type string +function [dtypeStr] = get_elem_type(dtype) + switch(dtype) + case 1 + dtypeStr = 'double'; + case 2 + dtypeStr = 'single'; + case 3 + dtypeStr = 'int32'; + case 4 + dtypeStr = 'uint32'; + case 5 + dtypeStr = 'int16'; + case 6 + dtypeStr = 'uint16'; + case 7 + dtypeStr = 'int8'; + case 8 + dtypeStr = 'uint8'; + case 9 + dtypeStr = 'logical'; + case 10 + dtypeStr = 'embedded.fi'; + end +end \ No newline at end of file diff --git a/e0/2.PSPOfficialExps/px4demo_ADC_example.slx b/e0/2.PSPOfficialExps/px4demo_ADC_example.slx new file mode 100644 index 0000000..0a2c522 Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_ADC_example.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_HostSerial_TxRx.slx b/e0/2.PSPOfficialExps/px4demo_HostSerial_TxRx.slx new file mode 100644 index 0000000..ff7f4ee Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_HostSerial_TxRx.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_ParameterUpdate_CSC_example.slx b/e0/2.PSPOfficialExps/px4demo_ParameterUpdate_CSC_example.slx new file mode 100644 index 0000000..8562b0f Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_ParameterUpdate_CSC_example.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_Parameter_CSC_example.slx b/e0/2.PSPOfficialExps/px4demo_Parameter_CSC_example.slx new file mode 100644 index 0000000..de38eb9 Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_Parameter_CSC_example.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_Serial_TxRx.slx b/e0/2.PSPOfficialExps/px4demo_Serial_TxRx.slx new file mode 100644 index 0000000..7551baf Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_Serial_TxRx.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_attitude_control.slx b/e0/2.PSPOfficialExps/px4demo_attitude_control.slx new file mode 100644 index 0000000..ce716f4 Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_attitude_control.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_attitude_plant.slx b/e0/2.PSPOfficialExps/px4demo_attitude_plant.slx new file mode 100644 index 0000000..1c3f702 Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_attitude_plant.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_attitude_system.slx b/e0/2.PSPOfficialExps/px4demo_attitude_system.slx new file mode 100644 index 0000000..1f803e9 Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_attitude_system.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_fcn_call_uorb_example.slx b/e0/2.PSPOfficialExps/px4demo_fcn_call_uorb_example.slx new file mode 100644 index 0000000..325f9a1 Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_fcn_call_uorb_example.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_gps.slx b/e0/2.PSPOfficialExps/px4demo_gps.slx new file mode 100644 index 0000000..3bf1cb1 Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_gps.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_input_rc.slx b/e0/2.PSPOfficialExps/px4demo_input_rc.slx new file mode 100644 index 0000000..16359f0 Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_input_rc.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_log.slx b/e0/2.PSPOfficialExps/px4demo_log.slx new file mode 100644 index 0000000..80714a5 Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_log.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_mavlink_rc.slx b/e0/2.PSPOfficialExps/px4demo_mavlink_rc.slx new file mode 100644 index 0000000..78c4c74 Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_mavlink_rc.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_read_uorb_example.slx b/e0/2.PSPOfficialExps/px4demo_read_uorb_example.slx new file mode 100644 index 0000000..70902e5 Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_read_uorb_example.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_rgbled.slx b/e0/2.PSPOfficialExps/px4demo_rgbled.slx new file mode 100644 index 0000000..a4a7ffb Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_rgbled.slx differ diff --git a/e0/2.PSPOfficialExps/px4demo_write_uorb_example.slx b/e0/2.PSPOfficialExps/px4demo_write_uorb_example.slx new file mode 100644 index 0000000..0d9e4cb Binary files /dev/null and b/e0/2.PSPOfficialExps/px4demo_write_uorb_example.slx differ diff --git a/e0/2.PSPOfficialExps/px4fmu-v3_default1.7.3Stable.px4 b/e0/2.PSPOfficialExps/px4fmu-v3_default1.7.3Stable.px4 new file mode 100644 index 0000000..6ae22aa --- /dev/null +++ b/e0/2.PSPOfficialExps/px4fmu-v3_default1.7.3Stable.px4 @@ -0,0 +1,18 @@ +{ + "board_id": 9, + "airframe_xml": "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", + "airframe_xml_size": 31619, + "magic": "PX4FWv1", + "description": "Firmware for the PX4FMUv3 board", + "image": "eNrsvHt8U1XWMLx3zsmlSaDpBQhthZOkYNpwCbRoFS8hLaeXFAvizDDIOIGicwoqAdSpl5HQ4li8PIPCM4PgzKCoD47O2BQ6Y0drUHC8jTMJFKfctIoaSlFPaUtOrudd66QVZr7f+37f99/3x5ffb5+9z76svfbaa6/L3vuEEwj38QKiu6Lh/w//XwsEfvL5d57+yS/U727VGUKcyBDPxe9WfXzxj6ueG6SUlLgk1hELN4hkvEr0v6XrJOL10ndD+a2VIsu0DuW3TajLE2yiqzLP+/zIJxvyhMphH5PnJeKnMSKeksZ7suuIZbt73NHxdZCufdxtOErE0hQr7pMbhuPrtTVy9JBcKbGF5yM3S2w2pAznIyRY/h3pIzmEc95BuH1dExFP7rcmwm3srPHU1BcINTeRaW6Rqgq807wFglXcssE67J9b4K2sm4vvw35rgdfOn0Y8Ujd6CoQbPXlV1JFznHJE3J1qgLol/PwaIjrT19aU8vA+B7BK23kiPpGaDfXdCrTyOvo03UVKG07R3XPriOPq03nCnNpK0b80z2uAkboqDV4bjF5kbBgPeysrh0llJt23tHJ4z9JMWsqrHD6YB2lPmdfsmSwsEP3rJ3snC1tp8thUj+uCGt4QDsNUiioFFiMaGZ0jHjbXTvboBAb68QjQL+Px5ggTPAag9oS6CZ4cAVOqdl93gbCNebWH7qLXvhghFSqXDgILweQkxbfYiSuXzlH74D2/ZTJxQUx8xGW+xaUl16lcTniX6T1EU3N3qArSc+7XEl+1fP7gEJOnc2T1auqImE1ulmwctU0OMHEiblvpqzY5YzBPVUdMupn9YjXUnaibxfLkQqf/Vs9SabqPDLts+0fIbGirJuIz/v0jLkhvh9gP8VY/sXw3lOM32VqHctoYa8O5hePnC6r4+AtHKlXnGCONjx+qPGdkmJL53odC7LCrDNrd+EAIIN5oDDaIKiNwpDEhGOPjk6oS5pyKqT/HMMbg4SHmOizRznwCahXrGkROl/A+EXxxUMc4+N1kmaTd1iBm6/VxJm6MM8mSc/qs+nNZDB2Ur3tzkGbXSFrnTb3QXyP0tG4h9OdaVxXaO+IXegcJUzmgY/4l6fwMYKc6p1PlVb7hpVZs9yDgrr5Q1ps/TDY5Q3mVtORBryl0Rj3+GCsaWXPtH0njMrVoVGdb/+CyAbaauHrkisrbFx/s8MP4Cdd9Vnz04BCxyNEqmVrWRxjLuojKclcEx/I4PKmxLaKyHYwwtrcixPZmBGH8PbJOnEA+j+Ac6Cqo62CHHL0mODZv43q1dTBnTpy7giZqw3kzufODZp5wvmoM2I6B1VuoSR5TecxeyA2SZuJiIeg6G0S/m1jyYY38LpkPq9Qo58EzS86ry6uFFT/8C1gDsGKvsw2/sdQmFjFuSBuQ7xttImUMXgPw9XHLZKUOrIqllcDRWEfXjfxX80QWqYZggr7ysT8Ips6QdNi1R3rV9IVAh0MbrcOhDXmVZ7yQyy1toiKlCHly5ZKVpm5TJ3DPlgz3yNEv5C87tkDq3/NrA9jyqHBzEwPQVCAt8ioNfqTxh5fVD0l7TGHpdWcY+l6mC0sHnfsT4tCyrC+Ea8PmLEbMZmiZe5i4b9V94a08R/KgHmn1Wofblz4ltXO0dFYY1nbjU1KAZNlVIZ1dFdYHKof9S8PYtxefT0kdJK/JNuxaqgsgJfJWZnIPkKWYu5ELhKUeUxaWbVwKY2PEqdDnrTor9Ho4oirVBQFe48cRwNTZKvWZfNWYOioddv7YeyltFg4OHYSyik41D3nkEh3WB9qBpgY2qwfkDpWjK2U7rxKrpQwNKrqx1KKU3CIPRxSKOLdL+0k+7wwclULEHMjh5aiU4vhRerl6pFOEiIFUj/Sl8+AgR3a6s0I90lkutIKWcQ5dkNgOQ4mpm3DJiK+zVZjS5LqQnfeMewL/CbQG+eEPjLRtyjrhukAh1xIKjGzetCi0TjSTCX1E3AOlOzdFwz0wqh7pfXJbEy3Vh13DxCdHP0jxok6DJbetBB7ulqMHU9MhZyRCSon4G3+P9LrJxFPRH98htTsN+6mjQTSp8gEjzpZXuUPq4HZIB0yk1BgkVtZaCRIXc/dzpARyLKAH1mfKGobJBpCtla/4P4oU8J8DdCG0vY0RGRVT2hg+rmaO9Ug9HCn9SWiXkg5B+kehPOhrCjy5bGNQZaO2LYDDK22HhvzMFqlDSRHIO6CkXJDa77QDrvb4Yel14gQav57eEYE23JcRmL1HMrN3QHrVue5cZeW6c0srnfwL8IYcbJSRMtywi+OG/T7XsJ+To/NT33Q8Ai02XNYaa8nRWSmEcmhoPIPtqQX7GkhHFPmxIjPjrh3SmzCnP08QK6Zy+O6zJpdK3PiGfL5CKdfWYr4VOKcpoebNXZn66xN2vqKbBPtria6iMx816b0wO1yesLvjGc0L0p+ck49B36Y2zYRjHIy1Qaa2A9KfuByNFvO5XA2j5BPIp9fTEHF8FiZcRXeeOJ4pCi4ViC2i8L2eRx6/AuyHWaG83udGXEsed08J0RH/SoyfGyEQ28MTa2De5ugDep5YiOj+ax7ULxitlQ21zAsed08IG2tAqi4YiOihtt8SieiwleUMxJylL6KGUv+CUxCbLMcjYzJR0Zkm6kL9mKGHGvrggI5/SxGLHeJX5R5F2thghdtA1h31ZmhfDqvk7xA7Ie4huoAcdUAqpKSmpzIrSZ/MxC8kcOWcclZ0Z/qgFjVA3iRnIHmSGUjVyTFI7iRCsgeQDzI8cE0SsQA+N6HE+cXSrFGJM4bbWxsRL5SnY5J66UrE/sFUpsaYpCYgu4BXSEW3fP7qTuZ+xCZvf4/UC1iWJKCuKcdzGHHejuues7FgP9UmyDSEAmt/8dImPdhJLoCOI6M2K1hWm4BXmHYnrNltMrH3hiSwH4iakh/XE93lcuWRxJhcOVhgDlIOpQ4LOH4jcwFO4UsqOt4ydT8t9TnzAiYo+S6I9kpFp24RKf6BVExMAVwjsSQt1824GGZqus9WuOToD4Ik+CzovPNgS27qzK7NrjEtoiKfMoJee1IeXysAH86XiK2IBximawK3FQm8s+xJKctJxbJUGY/QBsMsWFskiDDeBFgI7wMIl+sdS00I5tAW2Ab4GWCW9shT/iPnN3LBf+T8lzzpP3IeAX377zkPyab/yNkoG/8jZ833mo0ED6sI1w4z+SxLOLSf29SEQ7x7KeHygKLjBjU0C8Z+e1I/QxUeB9wjJfrAhhhJdEsaEwMl9UmOV7WbRsdrOnBpjJM85rrJwuMdFCRmc8DURp0mf1cgt21NgNgyGHwUYLmfSKyHiJWvm9oqArTim4ht2L8xq253R553IEJKouHcNlL6dYitA/22Mc9LbZ9HsIWy5sA+1U0nnLouR2i4KDcaXHlexkOsBX45+kbwUnkW2OrEDjWW0HMqmh9EuU2s7nPoGahCBUKuNnkM4bFQv6WdWKsu1Oe0jzywKauXWFfbc+Cpt0+Gp+4NsKKrwdrf/bhbdXrPyAO+gQjdTcvo9pEI5u4fCa+jJ1dXfPlvuS856Gl9xenRvItKngnyaMUn3+ddzhmMYDtHqb5S5T3T0arM0ndDav8Ukc1Whb4bytr8JL+GVw0KKmjROvMb02Mz+5MNqL9aoG4Tfyf/mbQ4RMQbUxa+zZ0XIoN30sBZMTtw3qR/6qyRUMHSbySWb0x6S7+Y3X422bDtvOkxpi8AKajzGPZjDG4e0rVtHspqw/591WIJ4bLtpk7TaVNFVQ4zsIVhBr2VzMhK8DiIOJWM2o1emP3ucR6Dl7UzYZCaZXnekYgabB2gd5kU0Sgpv20okg3lLNSjtm/AapWdZ2CNF39D+kx9pK+orgKsShnaLvVu9xZ4CuoKvAX1hXUgbyHP5n3+Yv7N70hF1+cKdO4R4LcW98QwmZbvya+9wlvKGziVOEMq5XNrGUhdKaG/tAl8LSK+Fkett+rPoIcGvUvoyOolWwl1GryfQt/+z0mfDvonLqIrgtgMAcdcspzoRn5MdHmdfhv9QxOP8uVBuaLrdD+Zkz3jX8ECYbL3sUrgIeD+vE7yfZ2m/6ijH63jq0YqfhQ0VYAHzWBgLuYv/SioUHOwz8aMrK5kKw4S4FawcuTiLS7rOVZFkbaVZoW6LU3oR08F35lpZh2tzQ3ijSpVnLnQCpJ608byoM5itKCHuHwxyro9g4WMxmHqzD1+o31uaM9gDcM61Mf3DN7CqBxM757BBoZy6j7Xhd/koAU/PQErvq7y3EFSbKGQZhwZqAjvsSBrJVZjcXhZS7Mlrhqk4o10Z1BXTOOqC18sPtRkCKjW7KxGDAmntZ0EmvaAvLtHQzip01RvamBHTPdNm0qtqA2JuDlVyl/D50vgwYk/kFGzbJfxTY6ukIvL86UrjX4LUvGA+8uwBHKlGeD8YAlBH3LBwaFDmuxFWr6Y81WqB4iOdc4wg/wR35ZcXcU2JqFZqhW12s98LtAB4mYqTkszAuv4JuS6oM1RwSj3x0kQ8UL8WKdKnNolnxc71b/d0jRduKhN9miat0mqg+ys4uFN9wA9rzReWSwy7I3TNXHjxa+XbGl6zru56UNvE+MObm46YtavbGlaCjmHm/WCGvxPq+hdZR12za08V9UIfoQXSpvUw33rbeIbTGDEv8kcrBS1oO82NzF1BqHAxXgcLqwndk8leek++Utq6jzYr83d3KSr1wmc2wX+iDZMHOag0aYL5tuwLtAY3otsFyOEsqDpR95qbVom+KpVwwcrwR/9qalzInik/gZzqLWrcsrkKmpbMYV168NP6A8MbJs9JaQSD27oGCHZE0LG3ucDhCvuq5zCDCygKtu5CKY2U9b2VaRjELANdQwe3PRNuJCSvt2EzmfckfACV47oazgTJqLP1T54sIENaXtNgfZB8tPjYdTCJ8m5CLw1SKH2QVPDCDz7GgbBGwW/55TrHAO+By3TV0Qjuk4KuuRsUuX50FrgXQpB111sJy69B3dlUArjrkoH+PPM0XXiRoKSt0C4WaPC/Yu5YoRwIxEj1M/rlKPH5WxPdi3u8HAg0TMtH3Prj0M7Vu+RAR6BvjpG9VSB8LSGUaDQp89FSPE3ChxZpgT7x30K16IF9bMEypVXgRZO0hnm4w3Drg05/HWg7UpT89ESdKPtUJxCuL9Mkumgb+T399Or9LNiYTrjql5n35ybygQG/Lb9I65NA6HPpFP+WQ29EtnzL4lsw50lotjXTAq9CP8cTKeSmV4wHU3aPO9DbezpPWhBLA6vk383IkfXySz/fpeh74b9SBV7H51hPS5Hl8nmWoNwq+bbY5MyO20gISZ6JoLsBG9b9IOnTYrzv6fEzCTSvjSp9ziU92lJMuOT8DgPtRb4MrsMJHj5fhAL6W/T/4gjnXQQTBDGF21S6DUMcpJAjHsFvs7ptdMXsbxBKBV0Qqs7HtZbVGK2+p0hlQkkymLO+84QMw3enPjmhTe6GHLc8GZ93gteNDk0xFgPDdEJ4ANdRRNqNU1opkPe4kOZWhwZXK1atfLQkLtMa92fuHDhnYF3VLsL6A17V37lnb6SjMS9aB9ToCERdyTsVX3g/3Gr0BbDMRBlfqUGFU8EOdqZ1vKLIQ6kN/PbIP5jGnxiiF9Ot/CmJuqUoy+kWX5bE7FfE3Ixv+xY3LS6Qo7uSvthfvakixR6zz5Wd47lnJUzWdc5ncvsWXguq4QTN7k48SCpPafVTvUu+34GEHIrb6rPWWQTXnFrQjgHQmKaMgOrE8bvZ+e2xDKQXdKvGoa9/GGY8fugFbF/Ef5A4VMcA87NdzAfSH/S+Xg7fRn0fYLuQ5vZ0A7WUQJlWs5NOQ1b28fxnDiVfdVNj2a1i91nmrTb9zZptjc2qbfbmtjtZwRm+15Btb1RoNttAtk+l7eBZAY6i2fiXDnq5QGQk2t7TDon2IKPtLfHjIuJeFfMtpb898f9lGHr2Fp25KWN2OLDuBrsdgnq/64H9/v8NXfyaxvW1s0XtrYzUOfjfpLn5xl+K8D/WS0RO+KwFtrfiBmdxOESu/yNnilCw3D8AfYGG79y0cq6VbUI9ffxn9Z5ldSuuINfUXebkt4Rbxiev3FZ3Qrl7UnQkHNiP6j7cS2j4P5I/FW3tvfFkfkbn3Uzx0t49MB+Li9d5BDKAkWCp85Ta1PqrY/X1N2kQLgzXsYvrKtW0nfEl/LuuoVK2htfBpw0It1Q5x6F/aP4S27t0ZcG9PpbFjLH5yiwa+VSgZQuCB29O2fd4nU71v1aOCIZDx6RTH03N5GnPu5Xf/FxP3Mn0IstrytX4JbHS4XtTeEm05pb1nyy7ohEoLa/74i0hRurT1lsY68rUeoXQf0jUpvzZuG7ofzNhANaWix1NqBidtwhTKnbvcai1NPFQcPWUPHDpMB7+GsEN8+IX0CNwq75wn6g9NIutBozdmY6clKq8J6UnHv4CAVrqTxhnEU4y1GTzgFBe8ykQxsoH9K3QfBB8EN4GsILRzNlf4aYhfAeBAlCCcz7DyA89yOikzq19Vp+HD9dsADntyQq+BLccUlwwnQv6nRsr+u8hI3ao6ktFDR1OIoXY69YWJC1p9MkOANssTDAPAxBhPDR3RQsGiOfFWKOqhz6ENocPVbdOiLeJEkR/TrWU+AdjmRyFkqr1oGWVPpi5tAqiwgGD1gz7xeo6/y6ycJTbhLWdfmJr5otoxUXI9+99cdP6dqcgGutHI0EdbyvOuNTjsi2teYCUzfw3HoKeB1H3+JKxB/LDo7M9+m6zZ+1ffax5uP7HjpqPHq85XjuDKLWZ+dPnmKzk+BrQ8RPOukBIrISfZN0Z97ZUu9JIjLjVw61jn/Ac/TseBHzx0KOROcTCM8PUtX/Lg26aqq9VHsycFaaugfC84N2lb00euIz6dnPG849bfj0rEFcIrHzXRCmg4VvJnsgWCBVAakKUgSpZkg1k0mQAnUDIRdTFFJ0HKYYSDE6TGkhpUU/QcqGVDZoiakqkVGRUl2QdI9hRa/9379lxv3/Znz20nkncYw4Pk5SzW84l1e5emhqZcO5/Krbh6ZWNZybsPCOoakLG85N5H82NJVvODepWhiaWt1wzlzTNDS1puHc5No1Q1NrG84V1K0dmlrXcK7Qc+fQVA/i33CuqB5gfpSh2ccncDxs6W9OIr3G+sL4+UFW9dfI/xNs2VL5YvNr2B5zoL1tDE6mBqv6JkLIQfApQhB0nd4AWGENWUeILbdD5W/1VXqZzYe8TIuZ13VT8QNpoo3xoneEthLhqKiKu6dgfyqJ3kgcsbCvWtup9dCnC5uZBXkiZZgQ/QMRJ6cZ3swzihY4oCPc+ANMJ/OHmyW2kD4tR7+WVVgywIA1dXCNr/rtVai3WQ+1l0kmJ/ikAVpm5tEXNsL6bxh+f8O2xIUhVSKPaQysto6lbQGTyICXSG3EhrWpLRGBeWq4rk4NEnxl43i+M3FhUJXIufmR9o7EUIJJFNqus7oudN4COltUJUzg85Jtcz2diaER14W7JrGJCfl/JOoLHQ8shtV2WCZ2Y3A+3zD8l4173apeOu/LAjFiGiQ6c7BBpDqDjVypHWCyGs41ZWUB3U38Ap7ZroLR7Za3uE/3q2zOIwv4GsWr2OKecSRrUC77vfurkwv4CsjbKtNysnujt7iA7i7z8vNu5u8v+ls/e+/f+lUH0DcplNpXLubnNclRv0yLzEGq7NvdLRMbW+Xkh1eWrVK3A6/8ahLfE2mA4F9CiX/qL7Wqkt6galCea6pqEFnm6cTQkLmqN2ics05sHH1TXQP03AjpC6qqtwcW5Bi5pxLioJbTVz2dEMWDAweJqQB35kPSC5yaN/I3B/IewF02g2vJA4bKpRvyAosFKr4XPybtczYGJj+wQDRSo+vHDxgrV2woDiwTcP+Kin/5K+4LsiB5ccf0qjjpAo9XfF5GL4gJbbPgjs2cJJn5XWidyBAxUnMMdbVU2SoUNbGDNdo2oBK1TIAxn5I1U7JPkpkrQj3SC86NgR7od2mA2N6XjM51YramQtlBd6Kt0kptDKwjdqBFVVLGDrQy7OCKrHck1k8sWBvnolM+IPmcB2L3cIUdtGyXuzdIbAekDVxuxy63ObhT0i2u4dnBh7Lyg2pRpSbTqHgz6DJsuRNabuMOSE87czsKx2oDzKIgA1x/RSUVr4+faS4LLBSN6oyu/4ncHiEz/xSKRnoltC5eDl3hBTwWvxhB669d8i1uj93jnNlB57F8G/8U/wpiM61BNOkBI2dhxytuQwixfX5dYcfMDpXE+An3ArRCq6xrkGTPDoHeevQxZd89U98SPtPMiLIh0UWn90jPOu/w7V6DtsHO6jkwKg68tHky5mv43Wt+rOTLHY9C+zPNjV1k1qETOBf/jJDpQ5F14iaNCE89eQ/T5DDgHG1oFejTOD8Paf0wszhDuLsPflaW82SDSLJgXegBfwPd/cxCzZEvmuv2I540DBCygHomoB53ILaDZHXkdjzlPnjhMf9YLuZsLdDj2hY3uzW9gCU3Yc2EALFy/L5qnOP/itWAPEGeV6BAO1NHVsdmtwX4YqeJzs1agZBzO7YhFa0vQJ0v2nLF0mx1SF+iC+eKXLY5OM5S4oO1mkXn/TEyrkSCXBXk6i1DEcTzj2HwjJx5oivr2jD2X8s/3cTx26ovx/Ep97QwUP2XjyvnFc9y1JKp80VzR9cWSbWHWtjBcqDz5vTFjl/iaamdOflFMym9cfje1840E8em4ftfAypn/Vyh6vnI5TAakd5ZayJj48vtaClQxTcPbkSptiCzMow6anEBby1Ja6ZccRIhusLTmum8CaKsviFEZ16N2D2asWVs98sdG7twvjm+UNhZrZmiPYGz7QJqRiSnsjORKd2tlCIuzImlAvIFeKQ24DXnGf8LwFsvSNsgPO203c8E1Dbb5u1N1IK1ENo03ycKtxyF5yRNKCKfx3VMBldoWeAPlHWJlHrK1JNItQxeQA+bCvAlpfNC2Ae0VmMvoxSbqTlZcNMo1mt3Vrv24+z/SrIrKxzzt0h02+41GQwy1Pgwhflq4Gqi5JKZvSdh5XC4LjKr9YvwP/FkOgtWgW4w4uSzxccSfwebjHtOS/DUr6gJIRQ2jecnQHvT4ORsl/hrv+uCuux37itDulN/Hnls010h14UJeb9zE3GL39ftuqCBsutxRwfii0j3zWOnYJf3XHMC05hXCPwDXuL8vL7L6ypzPVrXeArTmJep+2FHi3Li7vD+bYwrCHA51CYduQXfRi6Hs4FDWZGBoz6lSDnIK+w4ERktg5b3KC0/j4xi+H1ObkFHRLGBrdgfnbkTVpB6UJ73bBBmnsO1RGc+q6wqH3eyYyfkbuCw1wcjeMbhc8lRdZDYNw3f8xqekv4O5NafRzZv2jR852v3BhxtZ/xr22ybB9oaNzdG5gXOtDn8tq1r/Y1bB/y3Kqd6yyKZGQDuVmv4zAnV50lbM3VojtP5Nh/edPmVjCeoxIKzZPHtbsJZLgPPV9WjnGulL3FXhnNOAkfb7reNcv+t8DbKXRaUg0R8TSbKSiXiH2Rcsysg9aKSeghSe5RUDaR2y0FcfdWtghZk9ES+qEkvLk1ygTPN+wPIt7Y+Ir6cJvaLYYChpxa0HFqT6imTTiqSmBr2LwbsnfLZiO1+4lgZurS/rhvQaF9fqAlnTiDm8cjf4qNmid6qn4knHOloa8LOp6P+xABKCeeNwu41ypoTXdr3hvyTAnxGts7jc/tsW6FdYa+WOTau5IpwgfaKnmsVDfQRYFJ8IrCQHnlpIEv973ypDiFUaslARSxPp9+M6Es+D+eJxQBXbzkVuZYfp5wb/g/A+ezkSAhsmGsO4V75vP9R1rm4wMhredxPRQrK0d54Jv0QpI+Mpo2Q/nscqK4h1syu0rvwVq7GN5zpt0br1UC91+O4H0XFKgm5gIouyQZapmH45AZVLVBnARHv6SJB+zE8w2ptZnkb2AGtvnInETelwc6w4HmbHH3uDVNn5WhppY+DUh+UqkZLn34D7ZJLp86bQXsf8m3tqmwuDCxQav84vbfZAW33+jIcsiRtVKhwbyJzZl3RLXWSaSw/m/93iv6pY1z433OmhW7bjytEgn47g6OciTvU9nMhrPXcOpS5hR03r/lgRUbTbFBsE1qGrVEmqgepuhfXm+99hQvI6HwdiUjdoJEr26VtYEXs8M7sWG5DO4Jc+SfFipiYYC6utv06MXRxavzR2GjPTdizG3p+2v/vtkx2vE2ynBzVc84syPugIOC2HVE45OVbldW2cOHJEEon0LZoO10dusXRgXoB5RGdl7Fd3kcp5UQ4BR2Yv7uAAf11XMG8cA1xfBKiVkU+28Mh5F5VCOk6WVb0eqsT/OlH2ifwNV10HxFvkEoFC0/3GcWpKdzRwbyJ0jDo7YxdqQ2hXLhaok4mtFegZXu9aGGuj4OFWTYYkoA/GQ/jZTyVXuAR5b7Q3iai23w11WXaY+tZ/9H65u9b/2fbr0bb+qCtHuppF9kDDmG3kJF/5moivpQk9pGwQ7hVGAa98jr4PNRTCDXM1ZhG/8YcYDx4fuKrRqnnU/J9Ci68+YCbhu28rztfogZYL/LFyEYoGc9fAVheKQFvv0zEeyV2ivYk3bVk6zv9zO0WUUuXbCbFRJwv4Y6yr9vUqa3PnG3I0bxYw0V5Y+NKxmMAL+nbNJ6LSiWE62zGMVDxrvh4z/5YPtfiVvNFvC40RdmrXJWs6KK2F1vOtKj6TjxG555oAZkrvhdDq/3b0A6LqiYd/WEa4QiwBjU17bGJTupQnabzD7X4qrHHypVE7Hoz0xfuWjB8nkQdpV2k0Awr6x8S12Xqnl0aDZn5wQgZzGfodTDi2bldxFrgG4zMLo2HGKg/jDK3ktgMXlXz7NJH27P5hWHc56P7Pu5nytTbifgjidhvOHG6n7mF/u4z6SE/Yn+9xDRvhnEcDcjRt2Wua51oIFqFs+bBXDFeu5dMu4ln+bORokAjvHu9FyNo8TFglcMyj8jRl8DnOxOaOVq7Aubq0+/rRiNqT4Gg8pq9FxStFYanifwD5tpUSjiGLwB/Nxek8JzA7BJ12MzTMsQ9HvJV5/FgbnVe6SkSGKEA8tT8gjDG4B8PUiYWIqXXhcj0q/l6wJgyVv7dfsK+26+6r3SlmZe62cE8Woke9z+BkrPfhFWTHdYHZpdODKOPyoAeatzKiFpG5cgLNQrTeVKs77NCuSq0aiHb+8URhEmKj0ZswpUw03+PqPh/QCC2j3AUzMfw/BHzYQTHQHlaQ0TV6/mQrugcBxTVSSxvDpSCTh4v/irB8RXdvk7Q0CUVITo4iS1WbksulzpH/NmOI7ieXpQ0A8R0eG0yYBX2Cn9wW49+IWz37hUMgS+EE16bsKww2248vnKyd4mtapF3mne5oBKJW1W53Ivzt1ZqFCpFUtno1ZXj+yLga193LtcTKeKPRYx8NGLqpFaQcZZ0dK+M3La3BaT0SpPiaVKRiR2I5TtbgaPZ8N4mWNMr8XYOetM1CbPC13tXXlROeocimRbnpLEWxtEWKAUapIyX+rJFDfz+aRIhHIsT+2D4xRZqOx+5H3hf19nSREuB869tWanrBlw2tLQQawtw/7UJkAOhExYKbQ8msS7ectMJRoAyQVIPkFwIE8rnDqy1BSYLOQFO2OxWH93hPdyvmssEToEcKgB7XIy0A1W1R5gsmBcH6fVVU+etulgkF6SHrlMv5kiuLrXHLNgD26RiJ+Og4dVOXbeqJgn8iPunzQ7CLV60pG7JTdTm8IEU68ST7IY6fN502XPRZc/6y56eujL/VB7G5fv94rBZhzdaN7X5pXBZG18/pw1v/XG8WypzqQYOqdiRl5qf8jcM/3kD8smD8bK2vZuv99xQa7Yy0w/3s2UuXmM7s2WLVOwdL25IXONx1B6WhDkcf6ifPGoQl4FuzhIfl1WIp8gm6MsCrxOvT5/uJ3QizOkszyyfIUDFO2IzPBh/mHYo8ZRUKcS4h1eivH8dt0M8SZwbv1J53x0ziTXJLPEqmbVNrnH4GLFM2iFNN02soeI+KR+eKSkPnh9JIP9B+qi4bHFFQq1g4ZSyxMYk0lI1k3BITwIxC6EY0jMgFEHIhyDNINxDQGsjlD0B8cd3E91jMOdbIN3UQnTXPEl0/Vszd9e3PkJ0JV9SHdOKZ/mkmML6ouJVEtmh8+hqXBcP5662ENGc3uNmT7kujMthgYN+n8icFi78G9H988M83SmAfYcdV6GRz++9ZMVM7kpFv5OtvLYeIElXucjA38g3HW7vI4r/4OtGrk/AeHLWE90ts/B+zB323wQ1Hk39UsnpYgYOMk+Afb9csPF4q8VcjXWw7uV74wsUnv5h4lvAQdtp8qhevkLAOxILJPZ6WJVWBs88EkS8UbYAr18FssMUwDvsHhllgx88OCuPJRFlxpenka6+zkBMt7h1LawOqyewP6YzPemeAt6qKfxYV2sj03WoMWOvMzG0JIkoSxmNS8QHXp/LfxVhut5pzPOej0RhPWcD7ESaDBaPehFU3CVZFL12DeDi7MKcFySkBNMudlc3UhsZNGoPracvV/AGcW6K8s7A3vsHAhbFSu2QzX14n37kBFdO53JgiTel0BNtlUCWKC0mp+hu4qAniP1CCLUuFVdJ2McGCfgg4l9rDrTHdM7H3SQMFoQQjaCuJ+IKyTSNTO+RfHMKuzIjWfk60vgRxXfxUZVwWPJZTnZovEjz1ofxln3rfayTirx0JoKyJEvMTTcHLnkS+lo7YLM6ibT+S3rspuwE8V7QZgNgVUwQt8i4KzdB3BBEXkW7XQPUusQ9n0mcnxQvk8qJLnAN315Ny7kZ0XDG2sVdApApM1Gfq0GHzQhkiUdSpi7bk7TM9giee+A8VnTmgHYsEr6E0kOp97suuxMaszuJ43CQGZShfuZNc4rYbI+owT4yQP39o3dBUVojLFxnLJTZAmahPe4XXVkg/UDuYZmu0xVg2grZFUFqY/xE/HMM8rrBNk9d2qeWOqd7WH6KcAkHYr82BK06iMN4mmmj8ws7oG0xth5uzPTNgaaNrp0aeNxiBh7/MjZWS2wEf05GDbAvJkfdKbVFC7oqS/xJEu+wop7Qh+ToVSlWuGcG9F5uDpJiOdosH0U9Ux4Dm8I+hln5B6OyWfMJ+i+5QK/3L5vFDH5Zl/DjQo1j9+PAv04ZRsc3DDDTybHRiqMwfcAXxF4RuuQHM23VoJUKO7a7mfB9lskwqvtjoNtijjb0Lhx+OTpJdih95pzKg3l9KHBm7SvurDDHl8Box8eI7UwjrlMxpeorFr6LkGLc1SRiVexihxzVyr8clSxy9C/JS7QvhLEVj+JjhFX01WWeuaOtgM3qgT7Z8ccy3rgcPZNW/PoZQ6dh5VyHe+fFHeciM/zfRsDufD1jHTcKE3nW2Qjrcl/1FwLIAcYdmAuSxMw7Rq1vM38h4gPbhBXUgONEwDKVNnfZvfv8CH3Owzskm/MZt3Sce3ize9zxVrfmyN6HtY7fB78w07LQfXvvm/MwjmyyHIlcyg9D/meRDAYIsSctdK0V9rp1oQHhWaCpcR6xObyvKD2w86QIh72Y2twXQ3sfLuxCeNWyGJnzcJt72nF2sJAQ6y732RMm8O9fdk8N0/lTg5+bcyd/8DD2cyryovmbh590twVNPJ07zbzL3f/wyEk63wyYcHxR8MjD56AWEd9PvxcBe8D6TYTO/VcEbw+8FpTPsx4iFAo73RQ48X+CyhcTCk9UCs+4DaFD8NSGjc72GAsr79Mggblq9fuqWedIBO+hZnlYaP2sexyfFbYoHvkZObN/vVmmsCLxXvwoj1WDP+09BP7Q480ntc7O7J56YY+bDrKMJvSh0AIpozorNKPLuHlXm9lL5+7yO7tJaTKsb3Hw2JcK1jSFWZOjnynwVB6mtgDGYAxm4HffS3RZHjdgsx3wfgeel/DOyI8xvMd4HucGbIdEReDvASvgbqzN7EadeUvvmSLUQ15WLY7oZNrK65TUJ+k5yk4L1loX9HX/8T6iQ1idEA9CMPAqntYijm+/hWW0BE959SFVyYRQU1dLM37H1eKTow/I+IVBS7NVeSfF0chEWPdzE6yy0sXIsmKUQ5M8k3jU1FfAKL2p7IDjzvneFwKXdtpUs3JCzKz8EJ2VHy690yLoK0tXk+KTyn1LAjaeHF2aQslkEUrvtJ6jqu8iVkG5q1h+fpQGGzsnehD6nJT9zsOVqGcPpjmX6tUqiR1Hdxd2AU4p9A2RH38sVRZp+KEQhdk1iCdjcxQfeLwE2tJ+NkSvwLcfSagvrVLfKPyKztaMHFXwPXUn4e4JWO9/zK0JM4P11NmlA0grYmwfxxcLgxGD6I2NydMK8EeZB2/tulxPGcSc2JhMUzk04UtlbK0YoY6hcGaP5ok3X51DuBfmYP8g14qRLw3iMzGuK6OZkALYg3xeUnjA5cxqNohbYzgSIXRpB3wH2MYah9yRGy5pZgeriEH8ecwL3t3e29cKZ24n0+9YjRJuUwL3sZ1AZ4xfEkqaAUJLBsLQnXkB8/1tIBePKHux8wOlwnLvGmGXl0z/KlIIcjFL9MTfD1TWGMRe8G7dEPeAb9occgiV3rVCq/fSGDVAMYO4bfRblk8jSsmV2Gc5tOoazSf2z8MVoLPfAT/iByHQchuPg8RfkCxp3iMQMT+t5aE34Y0AEaemiX1B6AHB7f2r0OItFd4BvFQrL42eHayB/pZJmTMevG91qWxyLY78zniGQrrw9zSxNSo0GYlnWmG52sGEWeXGJE3hu3Y+ddx48WevZfLeS6wEH9Kg+UekYfgP69maVHRhmgTH5m/jg0TnVPQd+j9ckgMpnplja3CdqCKmbjwLU/OzYMX9M3FMWr3nh1JNg+lK9eBi3Yyud+G9+6zUAGVvAFXbAf+tiNUchYP10gKI9eC4/zS+NbYVb7PzxyTXthzJmI02fYur9hx+M+NY3ShwDxLrzup3oVSO3p4eg5Np//X37XE8O1Mr+LcjM/uHFrA8+DS+8fwkfidg55NQwy4IzYE6beAN6k9UuTMr6GhCjs6LKSvfOasPc0Qo/+7kXH4BlGeJrwA/nD1Jfq3bnVd3jdJCgJzPTmbtsihvH0j4fBTaHDtp5ztjRrAJr4wRu/aEHM2KaWtZwQ5YhuT3IugLoD1mLH4X1mfWJqJD/yOvk332435SnsfjtyRy9Dk5cxP4Uq4Kcn+t5ErgOcjRgkROTW4dZ6FXMoo1QByMvxctKnGqujeo9d8szXPVd7mleV7VwLuq7f79m+Xo+ARKInrNV2E5qktktD0Jol+EtiHalLgSt/FTedy/0vD2N848YRMZ1W8ls5NRvl3q7zizhR10qSz3rbxvC+hK8A0fpTzDydE1IOXQP8wSHwWZ91FcU4vz4gHPDXKdcjQUz5xWkSCO99/7+jX0Zcr0xVSKlPnf93L1973cAr3sjKuVXszf9/Lb0V6wj7kePO+EGR956X5SogtOBi6o4c1WUjxONCUfkVYvqOHHiX9P8EWz37iOV5W/QJ6bjHNdFmvhcY+VDLC6gxLxY62uRC1oARefiq6S6VW66/iqMM/eeEtV/cKCMOFqJNb4riQ8lznbdF2g5h9JxYTYe0LjxGcTjrXUqan6nXviEVpetXAwvE7UkP5IrcSu+5HETqVP6QD+1kQrT59x8oZBakhFnfJtVbg3tZwcw3VJjkT4TzJ7EJckEe4ZsA4aUoH3i9/XvSQh7okxCcSh7M4CbX1UEnIoBzjlL5E4Lrfr1qad1Uwfde5xXwyjt3GbhDpC6jz0xET+hBo9MGsP3/WIMC+wtpmC1FgL9v3O6ru9uK6uk14UXuziu/YIzkClUkpG7vEZxGgKS8fF8JlMnHkCv684s0XqPvMEcg3UCznWGAI3qqZ6EeanYbC6VqnBb3tlayH7r2N4vrg5LuHdFHEwRgJ+Qdet8pgFHfheRpLxGUyK3zVR4pRVlvkqh4jLu3Sd6IEc7iBWM1iTaHtyvE4cL2f03uX0OrjGCfL2ZOLsGgKzT2wDq8a8LF2nt8vg2Q99seC7FyZQLqSjs2QiuNyaPmpXh9WeXQ+S0m9C6KfgvmEiUg7wqxRfhqm3CKoaYiVidjKm5Od1jqsfV0NsauvhfmLb6yXbG4Y/X6X3xGAFT0yTDmJXA/x0GuHjeqa2PZv3bsy0bYB5vsuP3yfJ0V/IbD0RF8eI1SLgrt5niWikSrEXcuvJtLnTD/fTH3zlne6Vo/kx8t/jPeNrsJ85aP2lSMc+txZ6+SjNgmWRG/O60YLI9CRH9bEDMFq0wRDeu9DfD6Ff3JFwXXh1cTp6KsXyZwPtXiJuTaqnaE5woMuqJGLb78X97cxZTzFJRd9JGcvxDIiDdfFmKrNrXZMg0waQa9VnI60gwZf70Oqs6NwCdn15oBHmnz1O5zf6iO0Vb2ZnLxnH52EJz5+yQZPjiq5Sduw2KM+fSLYHbAFbc6WoY2y+LyLKvQzpU2X/zy+scGaLKxOMxVCTLa5IqacYwtSSLd6bhDUB8fok8koF8MoP36Sns8UfJdeJE0lFN35LhXI0035BwgCe3H5hh8AM+rS+cjJtr1AYuH8yx2eLNQnTPOdMdtDEDoeVGyoAy/lmhidhjus09Wb+2dH9tZs21XilMO7Tj+29IN/2SC+oSZep28KbRA/MIa5crYMNq+5e+hidv7TFV61z0KDq7rzH0D7Oa0Fq/ds6545OpQ5TL3M3maYtVd9hCC5/rOAxvCGEwRhc3lLQsuAOHfhLYxyNEMbxLO/qmghyIB19P0UEMjMWZu3RMFJvMeiuofAgrDhnQI4ekkyBdPTPUEfXPRE8BVw3r66d0aWGOc58yTb9dY5fLHHzXwFPmpMy54FFEu6nPCP3g3+lX2Sa7hCYLl834o1eIWq7uckxa0gM5YvF8jfAb7h3QeyGkxoP2D4qZuAdGoixps1uVXipNJdkvhNHXdS6la3DHcqbpTJnYcEy97IFmfzMuKSAyVOoSAfcOzyAt1ED45T6xOKWykyqgUMM7ufu8jeuLQygJ6QT21I48jfSiPUNMspH3M9DmFKnZ0ragdpIczwNtvaYJyx1X7K1cM5UjvEhxvGPDmuYEQoffsY9+9QcgCukMlYW4b6OTABZhCX09Acdg+D9Lk+YAwmLCeyp38am3Ye8XALS5euQ6wKTMxQx1AGeNOv+D7T6YzDOxSVAs2Bi+n0ZH/3mxJHI9PtCozb8T2B97lD2oRFPOfqibOoCzbh4z324n/+fekHtyAr/bS1KgvtjZYp1UOYHiTe6F+HrlpSdtkt7K5k240bb/PSyNmcaf3YHUu+fo/s7Etjrvs6G4T2+fHFpWnMTGdlzDxnMV88B3NWJF912PhrGO/JPzEG6lnhKFpHiQ/2kyu659LzS0zB80PcupPAtX5ydJiMH7yODZi17L9Lg8/hb7gr+Yvggly9a0gU3kcGDrOpKKFdr78V+wvFXoZ+LYMP8VW4Y9gMm49M5gIn/HgK1TGrtRqz1VvxFpZYfoKRTeoDiV6CMlf9ptFzqRlx3QHgWwvc2b6fqT8TaKvASO/Ny32lGV4YOdCfKU8v9ToCkSRQLFyJXd6qngJd4emrJlN501JNmbU9KxNUEno+df1JSOZ+UqIvukKMr4mrgwNr0i+5xIJ8Tibvcam9mP9MJuuVH6mE801EPgpQbiYyuYlidtvTqO/MDtodecTPhdLQ0jZ5TsTASMXXqxG8SrsC4Gr34QLy9y1iDmlEv3vPXy3wWKLsznpl7e5cZ6HFfShcAS/FeU/fYuMHP+8W/+3l68Yr4/72fl47u/B4G8iYZrFHj2i+PL+5iBxcr6Vnxii4Y4dzD/SZYdXL0A5AEcvRvshjJtKhSahXG7V315Sj7J8bNyk3DVOwC1HtLGlb2OC5xK7efefCk1nIs31MkECu7f4vbJuSFCwPPCHsEWvWMtyUwvtYEcJIx24OEw2+OOa9t49i5v5Uv4r+MqIEmX8S+VU4BByN3W1Q1yehHMgkehHH8/P9iazEPHtfSY3L0Tdnx4C6t9tgoLWEeJ6dQktyqTfRoanEUrTF1XR6snjx/ps53sH7fB5ihOYrN2/BIu5ofz9OnUbI0iKYsuQN9lrm1LbxBWC6xDWR7O/84/2YXmXVDmNmnBxqwFox7YnS3eqAV1tmfNjL7iHhvjNpe2YhyJ3OH9KREiKVpzwA1rmxauTC3d4niFe2MPSe8HSC2PmGvF+u2VWO/mT7vFD6KkN1vF3ibVla1uSuCK5u8TQsK2hbag218sdAdQYhk954BxnDbwg+Pvz5Ist8L0d0vDRg0iAe/sAw8qwd89mAl/+rGZZXjQH93wljfhHE68TuSfcnoFeDbak7i6f9bco4HLDTvcq/JQ4qLvAXC8wGzMH4RnojPkPQeumuyoNq5tWC5MNmbW7DcS0rpoOxkTxoDICFyDbAySqtoMeUvRA4AfOyDfLhrvq4zGV2U6j6rAw31blA+r6rLE4Dyylk/1gH8lDvHBi/eNFbVVFZ6lJN7lzub+DqNnikCKVbjKDYQmxOtR9GVBG/OizlOnthksSLJeJ5PMLY1XjzFRJjYVurMBc7TwuwvSz4nhANP3HVnYNFdvwjY+Xzxg4SGF8A/LgWLyCGR4vf6J/wwHb05iX7XDPCQL6JlxKphJEYIGdmONoL/Lh2s8gv4PX7/hLLMF+h+IUvcK1t5aiFctjghZeU1Fgopk5LCsy5Diihfq+eA3tkfs3OklOUNpwseZh7e5dYeMdYScbZEFc8I62lrUa9Ml1Q2Z4CxQi5nFVqgbDCCNb6NjO3bV3RWCiy/tosRGGsr1KLTOJ4FebBeIgos5R8Ypg1HMrirHi7oWmbJhfXjSBuE/YGih3e4NUeWC6u6DvaTucu8Om9eXyHIR3wzeWtgBox9mfQyrxSpE0jpYBjey97uJwS/+iPBNlh/tDZLPB3M6BG0ra94XT6v65zctQbsvGT0YuopZc9jXNh1QbY9Jy1z3mPbLC13EttHt+t45AideN9fdQDrxU+U/wtqcHseacf7rk/xRUI6+lDikmbn+F6JgA2tSWlczK/ljm8DzL509MU07rCloyvT5q4vLeXQ55upmQEVf7PE3ujwLhXWejX3p6O+NK6qdHRVwsln1iHeRWhcjfdirg0d7yevgA0rbeb7VkmB4prPpJ0HTQMGVYNI6IKBgY0mfjJ/PqGnU+qQ11QJaruijuyg4KMS8RFJY0G9a5D61sjR11Nfr9ohLTMR29SSxtWTe13g6Q3LvgDkecnMN0O3SMsAq0bA6s8RbKcVv5O/jqSjf5fYjC1z1QC8vSsZbNFRnkO63Ai8jPx8/HGiw/UEdlydfpHhJlKMuvkdCM7JJby5PAv86wMjv14XBT9orrXAj/od5STKtZ5R2ea7TD7n1NvaWMc3HZrjpposcba8resRxerQiTuVfcqhML6jHpobx3M3lU3jZTZ+G7G10fk2P+5tMxu/AjxDo33oDoAfvyDr90Z+G6/mzQHVbHqKlKCPtuL7LxsUz3sBbfdVX3Z6AloCpfbnSf0r70qsf91Gul09aKLE+le37uSdAVrO1WYLP+1Cv/l/0rP6zMICiTXQuWzZtxFaDNqJvxakwFPCrWZ6LEeY0/WsO+dkjlDS9WVBbu2XEdAwvBhpE5iqTGpcXQnA2ZHW90GLgi8Lsgp/437KOxTW1iL8zWnHg696cW/DsXH0FiP3QiRDR1+nud4q3BzYLtD5xLHdqz41jQeNFtgtEAc57evG9k+krQLDFwSeEvyg457yFjy47EHct6b2go2GkOaoyv5V+DbhaD+b217dF7lVINzO6lMRkKdN26p7R/shNSAZCeohqVKrnIjgntiwrNykGz0fdl1c5iYWI9gShyWd/76AkzeK8xOVRXbHE8E9g1dSYrFb51SxFyaYjOLdic+k6zYDx28D322b2aoeeWk9O5gkRvDHOmNG79deWzOuhCUhjsdvlQ9Loo9Ipvk9VmhjSkZ3p2xN+L89ZBYfvgYkGDv/sHTW2TAc33hYOu+8ynNYGnbit3mHJclpa/6xtqKnp/862y4329sjSaZbC3a5mV70Cl3gFdqad2mvhvJrRsvPX1bOQTmOy8KznFYsSLdeUR6eWp8v0WzhDfxGVarUibe+rvwTmg/w8f058spaxMSx9q+RHkl0siO/W8+MzNmwd2Tuxl3uN0Mm5JNs9lopgv8bwo4cX3mptPuy0kS0Lf5RpMj597CFS0Rb4u/DPIx9C/fGJ5kYLLx6PO9KRHfE8DZ0IvpQDPWqUGkUC1MOXlOrrVNxjDgTfWQLemOJ6NouEtQRlvT3mnT/6jUpPua4mkR0YwyfvpgRnncpzzUxAzx/pjxXx8gM9cmG4fd9aLdpxdvfQll7E8BZBMEDoRbC9RBugIC88qYOz3fMAhkxKedRT1yF9+HMAqbbrsK9D1x5cjQo5wP88lgePOcoz1mxXHg6lKc9lgPPacrTGjPBc6ryLIplw3Oy8pwYGw/PPHii7E5Ex3epiJEwEFgINgjFEKZBwHFXUpZMIJRMgsBBqIPQAAHl/B9u+kwy7f1VO5nGiL+I76uZ5wWHW9ID/SvSL0IfL8dYfi/Ep5W8Wek9kP59rEHMyao652L38bP5V/iuQZrlEl/2H1r4frBKZNmG4cd8r7kxrWMT0YNSEbTslrZ79DOKvE+DHxvwj5/Bhpc307nLfU7rLh/dXiY8WfdftWQ7WJ88IzYoM2oUy5Lg/8WJmJem4l+kAtEB0k914hGQkQ+kiPhf6VawjTT7Pu7XVBLxdErDa/bhbYje1MMe1faP+wmdzzM75vIP1RCxKv2ghzgWhB5clP2x7tXsw/99liFbIOhe/nmNVjQkf16zSNwlgQXxxr0A3ZOy8BsgJwo5+eLXyXxnljgvpf6D64J6znhxWlI1g55S7z4ayBd7k/VQdmWK2ChPrbfX/Oym1YsWiYUx9TO3e+6ou6OGlJiDBWApZYmW1A3FV/NlzXv3E9Gj3FoojVFOIzalbqvnvMR+b5haVkDf41LrxFyW47MV7fhjoDanUH59ajHw+heSEMAdT0znK/m3K/mfSFyAXn1tRDdIdeBrzJsXWWS9OaKf8beQ/VRj0aFQvtiaJIP1FG3c5cl88SHlTc/hve6qGbbQ5FPuGVeEKmeUhq4HHD6CGmthZHrxycT8ZuLYG84XG4EKevHVOMs/Gxk3Y1eIm3E00jgjN7R6BhtaNeNMmNrm+/oi+WKDQpHfJTMUsfOLxB1ST8TO14sfyvg91yKxXvp7hBGKa/H7C05ghMImQ0BnyaRPCoYAA+l8GJmUVAF9jicLgT6vv6GyrIvgGsonKpIPvItrC9eb9l8mHa7rKyBG3fxVPdHthLLrV6t1p0BmzIL8REme7iqIt0D+MOTtcufpfgPvr8N7A7QtApgSvPt/vZO8CXlFAJ8Rpv4fMWQBt8eTkwA3XRdrscCIJvwf6wOm4k9j4xZRsJd14HVmRQg3TqwADoOZ47OA6qYkEwEKCVrx0Vj6a1L4F3IQcEGctkHcDHg+D4HWxKOTwM6r17OE2pkwAU8sHo2/hTImk0d5VRjzxMvyUOIZwhrIfVu2B4iFVbzeePTTtyy8FEG5hvV0nSaocTYtR59NjffsdBvDDcNtvnj0s7QR8k+lDfA8rjw/gTqPpbKgDhvKUmRQPPr3t9B+rMpiyXiSRXIgnglhNgQ9vM/KQviToe3raTM8O9OuCzea4tEAQLo9NQEg5Y32tg9KcqDkhTTKkXh0T3o81P9tevxoPzvfkqP1KQO0wP+0+Y0P77BWpXTwTsO6mvMRXbcV+roa+4N+L8cB8bIoeMjRLpkBqBvSGW+oJXgt5Nd7nnGbOvP5aSG2V11yd0hTwodM3TWQuzS04Cgte8YdDcvR8akq6IuB9VoJEK5P4z0VN+aEqGUB5JSnqcUFsTO9RaR0Up8cHUlWIKXC+H4VlNigzUBy3mibcsgpgDZlEE+EeC7EuVDjRHIG1HgL+pk1OltaGPk/k9NGey+GeumUHP1b0go5n4YQei/6/8mi0RqFUOMbqNGZLBjtC+n/ZQprvgc1X07mjtbMgfxeqLknmT1aE2n+zxS1jIP4I4iRA96DGr9KaqHGpuGNryGUQIRSYmIgjNEaaTx7lP44D0hvvMfUArWRd18EHrl2NK98lN7zQupeTcncEJ3/jLsKKD4b8lWhKUDxixFsNwPabYW+lyQdo9iVQo4fcmqSdsj5CkZwJeT8HPCcPkqr9d3UMgXy7oJa85JXQK2IQqHPYY0h/62E/JLkpFF4EyFnGeRwyXzI6VZm6lgkQ4V6yM9PGkdrIvdXQo4hqYecfdBzFuRcq9D0IN6dZImJhVB1Gd+P0WTm6LhxNd4KrcpS+HSmlsNzpvIsTRHLD3D+Ib4F4vEQL4VYD/HNEGtSS3D9K8/81GJ45kBJPcSxJLF4IB6BuA7iwSQ+ValaeMpJfCaTNaP1kG8/h9gN8WmIkWuPQ4xceywpR3+buBHGpgndMFrvOog/gPynEvMh3xq+VqlHLBUQdyfx+Q94Q87+c3Ie8onyPJxEzn4bSpwQvwzxbJx/iGdB/FwSnx3whrO7K4ka3ws23DWSjcd/XlBxKtDDGS5/PLmaM4ozJEw/k8Tnr5M2eG4HnKoTEwEnfZhT6uGzLTkVno9A2W9SmVP3Q8BzVp2KzIQwG8LVENQQNBC0EEwQciDkQ7gRAvLyLIgVeQFxFQQ3hIUQeAhoT6EdiXpHvUxHNBC0ENwQFkLgIWT+vUCKswrf2Kbijrxp9F4RwgUtT/CbCHziv2sagy4h84Y7LvJ5Uyd+jcHyheIdcbx1U3w8Y7fK0QsyBz5Gu4S5Sr0HoVZgs6AGHfIt5BaKv4qjfFH+ESrIKu00dZpahLUtofbYvJxy3wnbk2AulH94LkeH8Cs6NeBXXdtVDtTeIql5/AfDz+Vp+JVI8PBV6He5L1JNh9sQcl9UKXHHCPdTYxhvDnUl8U4Ypt5KxiIYH06ORPDOUaG4vwu/m3LWXPpyb5ynQBgHlvE2t7FGezzUT94sHPGX1w8S9cF+srDACzkLP1JuBO0xLxwktPuss40Ei1nq6gU83r8KfTJnjRztkXM89RcWzy0ScgeIoUHEfwCmxnsCPf2qhabBuaoFg4R5xa0LPu82Hrl9oS64YiE5spdXe6bGH79Q4Mf/q0DI2/mRSAhgfgqhHPqQlP2h+YFQv+pnRwHSawDhJbf2iKFWJ86TM182BYN5fIFQGjjyffnFI5Rn6szKiZdOtIOODl2V8R1Z8MOfuez0AOH+8JyWUYX0ANEin+7X2Q73szb97r0rDbvPrDzcr9qqnL3IY7dRpdZRWA0zPbNqC4RZngK/XghVPq3VeRcdK2hzeBy1hW1HCp7uILY5Uh7Z5q44aq9dgv8IPXcBPKffBLTRQzDI0WvlqwU//hPM7Fmhf/WrbM8A9tvc9qNz+ApeJ55IQ175NL6If6PpvX7VK4aA1LSz+l/9LF18jjKfZVoAJbctZI4WmxctgDoL8Tz6djkcoWU6RzCsr8tbQ8vyVuH/58yQFX/xV5m5M0E4NUrnB4Df+iDGcbkFTS0RQAIoX+gfnfR5gthwrwftF7TpcK4v312Wo73pLzuO9RMb7hj7C1YOMAqHmDoneibWkmIrfwOHJyWp6JeShVdZ0asySrl1uR6Vpcib773F+5TXVNuz0uit9/6PpWflLauXrGq4KK9/ahXgsD6nUV9LrXpvgfcGDuVHIvrP1zNz+fJviQ7/X5SFcRAIZgj5ED7rnMhPVf597ol01m5mu263ajuxEhv4ILaWyQsGtAzOZjzNtoe68btKmO+tLI9tTvfrl8vR9emWyR9D6mPIz9QG278a1t5bwCm2vEpjkHKZM+HLqaAB3mHS2M+7UOtd4J+x08wxvgO7KG2uPwyeELEV8J+bzWX4j1j6n8fChyWjzTwd+EGHX7DTK3sk41JmJnsa9z51ZchvmoS68hDw4aF+dqu9Ix3tjkGdMlqmTmhu1yQYt3fJpPUApexzkGe6qwkndmZ7tks6W0eAWs0WmlCV07nTNj3SVVf5jHnnYmol08mV+vVHoV/g7p8Bt/+Mzj0Eb2I3VxoJJyIZGLkKjC8ug/FiU2cA90bw34/+5DaF6yqJZacZoT2zGKHR9d/Du3YM3uej8IDWNRMW/TdAZPk4yLLuFLHiHXAzRxKqpZM3dQWeaXo5EIgZDx6IGU1PLMwO42o/CryeP6AxLBzQGt8YIOydA1QNlFgIc9JG53KlfeHY6JilznH1OwC6mm/BfwhNmacTG9Jm0qaGwG+a/gJwAXPfmwtV4XcAptSN/738bTiu4NbS9njbLjdz9InRucWdAZT7UztNVmIReIO4JCZHV6d09ejJWoQ5XU28BjzZQpnzsu2m7jU8A2+3yfgfrVuuJdwti3JAfuN+ZOWF68p6ljmEpV19Op2HOsHe8eaKIzKxg+cRJMWc8n/Aq385UVcD7fZdm9lPl6N9sjmwxT0jSLjMP7oy9XhL4ahE7PGwqXuZUs+g5H2g5GUppwfUkedVh7VKfreSr1IssFTU2bUD2myDkGmbpdR5Ramjxbb/i7E3j4+yuh6H7zPPbEkmySRhyUaYzCRhYAIMCWBY1DAJN5kJm4iKiu0gWp8xtsZi29TaMiwqiNhIQCOxNopaENQMmOoYMbFqXakzLG0AkVStj4jLEwjMM/vvnPtMkNrv5/O+f9xnucu595577rnn3OXcOXnuPL+mMR4qCo+kGfNfacb3pDUVCCt9+ibS/oJsIJuFdGGTR7UrXdqQ0DArK3oagfo/BHF/9RTuHejoNlBuD0eNLtWuj6VDMbcvy5XN7FGWh3H/ZKYrg/2VhDMGt8jqWoyljqspZ8qQYlFSeeGTb4Mmmg/4fX8X0fuOG/XvgDsFDu9gmHy6urFw4aTWqt7CpqLWot4CGIF88VE7D0M/3wxcdJ2j+PBoF7HkFq46w/Ht9AnKlRWdj7Tg+giOTZUtMMJxcenZJLGQNoPL4DTRPOneJO5vs288JVu70Zr8F+KfpQJcaielUC8TuFpw3g0l5NYXib4Mvgfb1aSlZ/QC3NVmS1qEq303wEh0o+ec3yJ0eHIlXdIk5EpqyMXizgLK3JnMACwLsrID+B9vdAg3ekhUY+xo4GZYhELhcc/zjuGBQZGUh8SHUrjX9+CuFZybEmL4hbNRq9gXzkX9JJbt5EwfS39L4J0R+W78fj2R2ZSV+v5rwtCUmfruTmQ05btRN0S4d4DDNk4AThfAO+OEUb8E3mPgvQzrC2/vbLTFdg9oO4++UQO6WnuixpfelOEqEnIEYiqox9MlNQfyZK6JmOsjqvPf6lRDnKqxj7PrJ10Ifi/+N13fncj3dTm4Y137jHhmrSUqysxfSDSCv+5YFtBYVtM4AXnk46hTQpz0we9WEBONkFBSpz26DXQkcuYt4t0HfbgKcrEOBbnqr0TMo/FiPisSxDqqz0SxJ+MOz9Bi8yIvtQub6MdSejIJ+uD4pgf2oa0TFYzEhoyXHJpDduFjSY+n+u42D95btC0aGa6sf2ZfRlR9tpYGl3Pt6dLhJNfZ78dZ4Sx2bvh96MdpJ7Ka/mYsEIik4zlTR+3mFfl1G5chrM8SppS9kL2OQIBY9/aV0wkUz2Agjkf6PFoweakPd03u7VPKnojn+wwmdx3X1L/ceADjKf7aBOY5J4HfJYmXIxuk2rQRa88y2x8yOWH1bfhtMpSdUEugBh5Q43wCCz8St/rUTQazKqqe3rVxBPcIG8cxkA/j7/lwd7oh0epTp/bgr7LqjuHXp8n6s7fwHQ4yUCYgv1I3GsrUUY1aP/1rUU1xH9YPZeyKN/pMzHYRZ00/dktN93nvYu4YSr/o60/eUhMW1aYQO7sfWnxKPrL25wt0dDOMvzsgfHN8QCbkY2lWoly41V9sypW88WLzRGpyp0ttCb25/7SqvP+0+ppyYb7f7VoJ3IOTkolKbOWZ9w6i5OOOr6XESqS9Xvx7No47Zn8SLBdekNUtW2QtIW2ThGaBq9rhmDsA/VMAjtpf6NHQDo9hiOM0UQMpcJNJVwY8tK3BJDib1gmc4PWkS7fGEN7v4wuohllPWgb1uzZQfVip4RsDNoHYfhasYXZxifWngVzJEre60ffG4CzXTFbS5xPPi+t9N5Jmd7OwwxEe2C3s8lxflyuNiu9aSayv4J5yezx0Pqq3fCtaBA/dIUB/D/eKpOwdXM+2f+GvFL5AG99lNvf9EsfvuYtMmRWEvpnC2vPx8Y0xoI8y32tolyGQDP05Zk9RIFf2hdj5Lbnnbv9ReJ76dsztv/nu3Xuk78R7hr/78p6h74yRj9jYp6b3QfjHotXdJdbQSiEZykteT1Vsjt8cXkD/Bi3eIJKKdxhveumEwpOR3w/AN/IUYJXTkWfg/mUv3SqbSDYdTWuZ5fGHEnhmFrRZygc5k7KTeLtsqtVUVgaMlZkBrrIe6vNcAmgnePR0OnBnaxRPEugzMwfR4qTdN9Flo6iPciBtnRRVe/fcXi+rLyflnGV2q3Jq7jD0/DlBMvkfASvNlRpjH4jb5VJ7ns9Gi13/Fmuh//8pomYxn0tscKgCNjrWdVTE/ycTtX4bHeXKYa11OI7tsVfMla6IqYGKhgIcxdR3RpYALINLx2L1x8sp5jMqJorlFNpqcij4mTgzNVYtBHcbuN+C23Yc9+wZmS1AnNswAYd4h1HVFQktvc/X6qthfGsaYNsK2G6WSTnG6QPdeULMSmU8QTnjvIh8Gc+dbJA4Leif0bl+3UJbq8WnhTEgT1oUq2zRNGkaS1pwfImFph/AcassNXZh+3AWYk6Gat9ADpsMzX0D599ujRNr5gm96y1jLvIxcmiFYslalboBRZ/SlZFfyYxffJGs8Sm8ulhA22eMV7NdZ1+uOEWImUZUsWKJy1YHdGdUhlvnnw2A7FOln3T2v3i1wvvbosgb1kexr16h8NWolubvL1k8B0bDtY4n+3YI9YUvR88O3+DZ2IeSQ1XvbCFPWFm82WE4dkjO798K8os6qpJy8ouLbq5bWe+uT5f6YxgH5Zpk6HTUAD3jxRiOv6Oj9wFv7IfRo0MgUbURVxjzhQ2O0GEoj6ilYkqGYbiCkS/nddQS1tIHKZnwxj6kkynRfL+iE3z/Gv6XxUmZly6brz6Bf9uT3GVfi9fLZUtwR00s5ijZs2KSTROcCNSTDlyBWL8LKN97Y+zUy/R/izU9OlxHE/J9udL3EZQUxvkwdU/M5MYdOhuhLDxo6HwTser7FLt06Gc5ruwPEBa8cD7j916AwD/ysbQDNLYtcpmdk96N7qQ6avXxdGWKWwox90IrBVxEkabDwZ8sSoaOR9AOfPpuDchfOeFq4FmuIH5PDGOcWqnTq9+hfbyWZkpSVN/Z4aiVtnrxzxTTDZKtTc5FLoQ8J4YtkwwFI42Aazma7eekzugJxplughbOhBIiJzILE+nhsQh/VvhV6ElXuuawkhXFPhVNQkw6FZ/3jTFjIsUYt4a/FWtc1Sw8I/YP8SlaLcBIW3l5kEx8IfCEh1Q+H+A783w7f0tsQ4ENsratC/TRFTENxfdfY+soYnF27ORpXZVqTlHhzjMufocj7ZhSm01R/Y51Dp4+ETwom1hKT4yzvh54IcXV3xxAvztjV1PSRsxKiVrCz4g7PE870gc6hWeAJs8Nc9MfcvQN3/aSOsqX/VUkE68cXvlSp0DKLogZLjUr+YvR1UBTKF89dUzhCyh3IY29Cf/HwJ0Hl8P4QzKUkURrM9pSHTVIVyc1JWnH54AErfCkTVHl3JF8QFOhWCkiSTV1+xRLNgZpIMFdcTY4h2pdGhYf7xsxSHMTuB/h9hSv3njCyPZnHw0nQlGQDEE35zKaDI1o/yKjqbg1FiqMLvOzOXlq9+ldeoCk3CLh6sU5KpR/S1P9A3nKg6k6oQSjeY3tdIde8+vID9ZwIn6UG/+c4EoN0tcJTYnxeBRkCl5Q2UoCKE9mo1ZAkacXRC+eqwodT6pZnU7GSeV5iLcmocNasXia6J0Sp/5a5Mq+Eiel6tVwQrHfhzolzvCQ8r37kJdcF9b7UYfGPWDpQZTdeMZj1sdrfaUwlnc34NmxZOiPYWL9PsjN+JzZOkuGFodJ+RSqwJgRNgFGbgkrpzPQ5xaQl/BdEdWxk4orol6AlS6po1WUgy+dtCeuZSGrmU8t+DwNPtyMoyD76HqaLJwZdMmqdAhTN4IGAnz3SESxVkn69gJeWZytqfB2CLcQ6a1UDAzP6+HKRk7XcKh/CmjTXbl/Qgn/4fTNSPjOS8JVTRzNB7+gPxWfxVOxeAdTfi1oX1YogfFb3VngUzSWM31VdCLFdXOTWzkbXetoOYBnKxV4B18bgY/wWA6vXZrfE/9Hfjv8P07znP+//5/90f98v1I+7SI8nWeGEtnBdza0NTc9JOJ+t/+O/+CP0j/wo/+N7N/YYxDu8PHCE6A/cm6LkOF2g+5WISsnNnKl0leNB1p6eAHt4mz2a6geJNSpstW9SljlKxJWwRt6kdtObxHSpX+F3e6WA/OFb0CWG2I0pRX+eZo0oPy4ESjlhfByfw3NkUJJq5AjDScr3Wr/HaCjIYUt882jboDRCTQpB6dR6zjQbZMS1Ot7Ud9jtBf6cD5SOXd+KBkRNS6Vm4B0zIHjwWnMf1uJY8TevBzo6/oFFmGO32RKl9xxns0ji0mL2yQQu3JfzEhbkzNr1Vl0p4fvbYS4LpCdjT48a1YTf3blOz6bYGVW+jTUC+NJliuLcZjacBR0D9wF3OUxAubQzhlaROnytBzQpbjQFIjzZdxg4d3ngA8Fc3P0MXAclA3pq60b8GgfAxS1NGmmONtCpNNhUqpoIS8nl/kbfR7wC4PmiKV5KWaixm7FnkRERItNjzAIydDCi+nfv5h+W7LYhzFzuu0HYLwLeNg5amIdDuBNbSZ6VpR6HunWAYUL7OxaCYQ/z1KjNPari6mli6l7WOoqdkZ9DUCQoAyd3YV70nfVybdMVu5Sag7jvmeQ4eK3OJTzuCZaBCXgd6fvMkjdSRxXzwc5in8rY5qS70+onneczVlpkA5ETX7VE6DbDd+SdosD+d9N0UFRT7Ff6eHv2l49zaGF8P974LVGaqAPbiwA/wfiuFt158b1Dm0gGpoa16R2limrHJC+NKfFcTYDcngIIDjOpsPXA+wrC77W9eJ8r57eUOc4a4D/e3pxLUNPR1Gzf/HwU3fhWnVn2HHWCGF3RC04O/zL/dGz5yxu44HnoS3tPfd1HzzN5WY18u24/yoUBS5/gnt+8XD+VTCKRXFdPRr6IsYLOTYSxD3lBmkowg0qmEHbWqTvzwAHbS490r0W+sefZHdLwROjIf9o6L2YCmqTOzjVVwR/b8bGWELiHb0WOonOo9jaL8tahu2XY792aN1Ke6HNJTJ1VJ+qlAOKMMAYTKznjhd2IqdAW6rPJfv9P0Bol6G9AUJ7DNvrpIgS2FfipekfhvSHYdxaF9NYXmW9+f7uk6cNrVDry0CibjfQPNBhldOPTyTrijU0LWgRSlzjnWiT5AXoq1qm7TgA49mAxfcjeLry1SGQkI+NdY0GjQa4YFIDVJC5ErHjj3jZ6PeTyKtDySvVQRv0OAPEGhBnsfMVgXAV1TyOX78Nc3ZNUA+yBsJoTb4vajpwr1ZpntLPZsB7Fbg/ghvfQyxNMO5wVaQ9nRYAHmhSmbtb06PdUyerJ6dCLVCTdgyfmdSx8FoB50N1PTzwOa49TyDteldaE55LzKN6V22pTnoheqX1oT489QeyamocG/Nojn7oXK7+dchb16PMwf843SP/H+mMPVq29uZt1vvSpTjIFQXSzpiyXrZrdE5q3uGbJO6m+YatzqFWYaRPN5NJdYGbm7du3OGYFzwo/LCzcpu8yGgT/nLHB/mPOXTHdt5x28/n1HcWrrp15x03FtrcO++YJLSDNpPh4+bY3IIPY69qnirs2PhKdOgcF81b/VSzKsrnREI7wjbh6TvaHXP7uGob6PTb5AUmy3ByNe7Zz6trdis7JVc1d2yUDxhpTLxTUpMwyPpZrD47m9t9+UKN77PmNhhtPl+lEgrdOZIU62rWCGTy98Ec6evY26ezrvlaxBpPirGZlzEj9f2E1ffuiHLLIBkyqlFDfyuuzA+39Iyj65txVaPat6q5c+MeR3EAc68d1Egzol6/iWlwO5vn+Fc1Q/1I58bldenStZGuVeohI4mGChI7m4nt30E8vVkx+MNa2VN3YOxVzTs2+qLSORLNy+tqBn01ypNIKA/kycPhnXe8fdrIcdVc6c5bNsgLjcqamUUw0RPNHQ2IC5QVlHNAyMcKpMy4ekd6kwX0HJBwSjcADjU7bl2FUHauYjDsG+RFprdPj6pW5sqxzVf38FA3PeV8FuAIr0aygD/kDC5ofsLBA/frjoyxgPQtkNI/3b5z464GPAMYDT0bGTmrYhjcCRjBmJ0RjeXfIq59JkMPJ4x+kAhgZOGFpzeO85QK1XRXA/J6vA9CA2PZ4mFxNfaxv8fxXh8cM+tHKX3M5CMWL5QUNTPFsh7jn01qipBXJuy+ShgbS4UiAeWI/IYUZ2YwlHkSA/1hT/d6aBdSrpzLsqbOW6+/I13Y4TgX2Cj0+5qEvGHvr0cF9fZEqCeCWrMY6BJ0TUtkvY20H5TV3mqaCP0uskrAk6yr3MdErvxf4pbXiP59KM27fS09HwoGekzQ0DFMjrMzWyaKTYoC6apexABXeqI5HzTcSN/qnrqfo7yzE+SGDxK3/jwL6rrqVoVONPFVzWQ7MRUJeP8FkWbFOYbBfBoV30nxn5aenBQeTsY1TCL+S+JleYkdz2g9A2+EdKuP2NJPRkMnYyubbUIaSBFWypkVyyr4jIYCr+9l8wUZoDVoQMIvCoIEn+gJL619wh8LNUSelZcSDStTb6zej2fcC6RtUbT/RCwQZked6U4pW/2NyNnKggaQb47DqGHaj/ZE1rv33MG7t8sL7PxdsltJ++uoIj90JUnlYIA3ZbgyoH7vx7oF5EKvynhyqkc+LFajbgFY+0kvnoxgFu3U74lVo0bqbkzV/aepuk9U6j7nh7pf42sCGnbHboaa5widgpVeWu9lr+9NzfdkgdZ+OPxyeKl9vUMfRNvIS+1ohUBptfre88A1LgR2CUYf0kV32MTadhcrr1tGPfgm+UuxDfrSgw5dAGnsQYdmIDmRH/ACh/th1esHutXEdzZX+6y+lc0qYZTnwY1pQpdysxWjW0xh75nfvGfjZsd93VC+AIwceTboKygb1p6trsa+YsdZATuznilsuZ2UQo/aB33qBHIl3K8WDR2TUVY5IxLTGfGjFM3U9BiaDK7MEn1fIQXd1KmmeP69QApFGKewbJCnLwHeWB0P7Ugip0DOgPLDH4E3/AbcOnDIK0EfdKJl83jo/uSR08bXtbT7TAbJZqdmVp4xcMQSk56NjIbxV7nT5FgUoN2WB9o2/h1i81JL4s81k3Lq6xbmwV9rYqZArPl9GnpeVPrA+ugMv5XqgP6BEoBGXumF9ybStz1FA6/DOzCKyTaLd1BiyXMbBLQn2UZPnjZ27vWnndnM39+saidTfh7452luBmnHUxhc9XvwnCM07y8UnndYA52esFgMsjmxRYP/EdOk3yXRLmKxmZSmSXx0rnv+YLmbdKRJb0dJJ1+fJ3Nz7XMsdzU35wtp0mvR4wBrvaOm7wOZkOaf7wR6/9w9U3hH7AVtuOAk6sRjArc35wrcVhdlNyR0qNv5rZqtaVIyqtqh7syh/A6sNWd50PFdkNgGA8UmUtkbSJMuS/LUysrBtaVJb0S4zp0riympfCWocWlB9mHWLxcTqbKXff2R9P07hRfEx+RvVZvV9I/do4G60/aTSeNPpgm3N6ZJ46ODPjLB06iVFiSxDR6OHZFrvIDvdNTic4K4y/bdyM2um521IAElItndB75RbWbz3BM+FzVURwfxLmi9fk/a87rdJgpyx60HT+s2HpTLvLjnAtP/JcJZDspW7xbZbo+Hfp3487dLHsSdGIslTQYxc6XpuzKkqUlizTrJmTOHijhiypCOJGt8ug5i/XtggycNNAHgKmIdlPfZeO8Ql/F5MB5amjh4Ws11n9GTlWfSuJg0KOu+a0vf+N2Ee07Kxd2Ib3MA5/Kv//mOO07IBvvhQgifLX932z0nZL39tu8euOfDwth34j0fnlblfvit5p6RUAxh/t+qIWZ+9zGxovGUvKtNK/Um0h4vA0y9ktA/bnGVNapmaSVfAnLzIq6KAwPyKKPOt9sHVGXqkNWDW+VF/UuaD8qG/gHZaMc+uy+8xES2qgT946tBNtZKWxMDcr73FDupHoxeikOQbROIu7TIydPqTR7xLLTleXDRVJuSsrudtZk8+dlnOXoD9EEbuJngbhyNvHBDcxYtp/eBFicAVU6OGH2ThZBYJiwAHzf4lIFMHAp2CXhmJAa5R8SR88IPRxV7UCeTGqr0uvfCeI4L5fBx9Onz+Venz9HSjwSdbcXAqa94SZ2b3+BcsHT5D3aO/glc4sS+d04Tjlk2Ks8bVFYLamPWlhCb/V8R/Ytwk3+8r4amSe/Fn3VrWT7bwswq9tqxvsvdeGrMakqTDsS90Pes5lkQc34YT5ogpvUBE/QC/ZCepEmzwzuFce4vmR2B4+IU999Fy29t7rfEiZTNIM1LhuYceEYw+CzCObHS/Yr4KMgO34m2VGi+9O83sHfsO5//0+3AWcfTWmmd9/Bp0t4mTze6qHoX0HAE78JaEvw9cP3fBDkL3469A9vmTbam/wdhkU+9K016PTxqT369ZsjOE3ne3Blu9a5jMulOkzYyS0VLAsuhPtdAfYj1+gBn4dp7gX/fQKupEzBSGa2l+dAHIKf9yJNqmRXzoqGc7PSgct/T6CRa/1xoJzZ9H+5nslOj9MckNwPpfDzrpcPycjqa9XyQd/3qoRqNwWSUtiet7s+bcc7k81WfN+OcyefNPwH3FuDyc/E/zd+IO5uHRL7zT44dhwGHGcdE5ZkvLUusp0fFyQI/+fyA2rJexByvTX4jJr/J6ylpzJE+io5rKhKIzR5AG8+Tg0XsPGvnvv3nI2vyvJnH8hdYWjt1Y46qTGNcY4FbD8qm1v5zXgI6mpwF6T+OpoM2Ryw5MAbk0xzpbmazJpvpXmgnR9OI8pixNkd6rTejqaiV2I4GPhL79cT0EYyJAXDdODcKY88t4Ga9RfQvw/+v4fsQW8fXQR73RGv9Wpe6Ma+Vq85rwT3POVJ7L67JIxwlXjrE+1m01Z/mymutBk0kr0XTqMT8Q6+GzasQaZ08LOoPjKR5OJUns/UKqRuiemYrUQPft0RRkq85oGocBzoGzsbLF8uM+kQaxJkaxdthtzk0AS38NUVRjoWxvkzVWAxp6iBN6GIafU+rD0s2oNMemeXHe8GJKa8lGboc9Fz1IJ6WusDOJmOdEB8wfvfgejyU2jRWagXZZKz0x7DUg7a2ca9WFo2EcpI50mk5o5O0g2bTORv09GjocFRdoj2pfn4adcjqm0z7cqTcWCSUnsQ5A+kAgf9FBwwv46zBX7otTVP2augyWb15E71aNhlNwBMnx5x0PLwnxkppLeW26aTvosXwXxrjJk88WbSoWqjeHw+1RguaVO0Ve8iEcfVbZEPLaLlt7hY5346cvIlmu9aUZg4VEK00N8Zts1D4VvcPreEc1FSvlVpiUDohvXGL/FhLInRTfALSeh3e0fgJ4Gre2Bx9Aziez9UfATxodWreuBB1uJwFFuHp7iLfqNLsxnDoWzkemhHVon7MGZxbYCTIHEoj4dDmqMrsgdZJhOSYyW3y69hsPN52bGbzuAjzDWjzb1AvBLgayKt8LNOZpZ+GAXfHc6SFUbRBt8Guk+6NEilXBh5F0ba5Gqj7SgjjWdgvojgTeA+k7QKHtmx0EHPxBY7RZ5qk683ryWzKdBYKpGxNFdnmtRxKQw303mSXI+0E2cZZsGz6RoPUFO4fi31GmZ8jffp1Y/T6e0bp3wW4B8EdYuUj0jsy2sTZEFaBNDehCmcyaqKW2zl2Jwy7M22hfpF+8V4HCcoHoFXn7HfIx3odFw51NAyLpvvH6HHPAd5Ti9/kvKUFb11EShpNl/oC8kaV3qeThsNH5A1VNvcReWNVsxtvC99w89vw3cLsNUOspTnSgcgC+30gUedIr8KXTjoe5jBeVc0BSKUSAEowjF866ZdoubUawxDSxqpvRYCuItZzJzjrUCADeOp3KZsHydDHSZuAMZsFjFmT2qXxdlKZSTZKsdcNFFdezyVRb49Gk99kvTy2B0pUpaY3+rTPax7HPLmtOunFCM84Dt5UpXEGIEedxMkAFXL+mq25fie+YcbxVUmNJyPrfFjjKtBgcA2mpVYn6fxKWq30eVJJ+y1L23IA0xp7Fg/XtURCV0bU9FUfzk9kNa0H9xY4fmVWUx04/mbwg/dbKzlLP9QsRzIBvhDWSAsaD5x8j+j/9S7Rz4J3GN4zwJ0GNwdc37toyxf3zOhx3F68id7XnUORBp6X+TbZt4rZ+NfBSOQJzHTyHUfkynVaqRNKW6nq8Jd7IqG3I0TQS7MS9ibS5qJTnXgvD9+BPBzirMPV8cbBU3J3N7i2U3JXF/rkSAfD2KrfywAPav9Nklg6HG/LdtUz8vQqw3GLpwR4z2MMsiFxI0XIaH2guwHim72luJKjlzt826CGO3TqIxZPrnM2o9FZ7F6pYrZq/WEAw0/o3j2i5HITlnodlm0raF7K2Wpl9Z70vQr4/gb6wP78HP0vNuToz8K3PDaH2UaJgKSraxrXitagcV/9DL+JqoHbK3ZsbunDteAB6POfQHy0xazvUTcapeWJkXVh5LdFADc3n8nX83TUQNN8Ga0Wv6kRJQu99NCBqTYuqAdejnsMi5waZl3mtrgedJhvxXynFf7cIA+g75Px+4tRsskI4ijbG9XSLp+ZGp1aqT21EoaxN8ft9UZpL4RafTijmgbh66EnzPHg2mEN3rVQgWvqWKax/8jVrxqbq//nQJ7+CLjx4CeC0/uM0urelgZuIs6GaOlY2nTyGsHKSlMQJ9bGQAX7zouraWNvGdT507hlpM6SGXRrvbQl6aWtvn/KRu+VQiT0Yhhb1BIvAlqZTQuddtqP+m3NaJ8V6nJ5dBRbvXsrWZuaX8lj8D+PqWmNPxm6OqmXQjEN1Uj5ySCT2pKh65J448YHIikrp+rGv4vQWmIc2mHFe7n6USmcJ0fa9U0F/6fkSi9azBhLubKXHTaP5gTa2cDzZ5jndXKZCe3zdTRw078XcYzQ5Ct0oPEkYTzknbjvBjRmtPbTt6QuD2AmG65oyhwypI2mqomFGztbX5ANJrSGs0lW2bmAeqIn+AvBDjXpj3HW3IHJQgX0GyvDxZ9i05qmOUnbJEbdMDpr7VSNdX/gUZmABDs5Oyvw6pAtOyOgpMpkqdbFAM+Qpsz5Od5elD5G5sbnSKeyTUGVhb+Sm1o9wFU/Sa6RLSBBfRzeU4DnDK+W1QajNC2uLTl4fLIwAWCJMsJaEctjsPKg577a0Cc2QjnHx1Cb6jqTRraFJ5jTI0Sq24elMPTl1Zm/5nnkLG+LnOU9kVQ8J+qm5uofNuTqHwI8LQOXka/gG21vLxFGQ8suh1wNqVz3slxLY2qWK89yxf1Q0oG0S9IB18wtbhy3SCvtSyLP1UrHEurzll/Bd64dtKG/pHz/kTDCtw7yeCapGxqlIkMLeG8p2k18MszZ9YGJjB+MCiuxX0l8KnIm+HbopcGoFkqgdaEFC63kT3ImLMNnBTn6YXBToByXpcpjsmoCaTVq60Ns369icxr3yeG4ZgReni658K4zfc5x5IdzWf180csAehWdyfghchlras/X4mHSYpROhXV0uR/3m9QkMFUpS/Vo1AapPhdJ+Sl5b1fJIPSfqJXBKWNwrIMTA7gb/XPhBjqLKjemTD8eCakgdblHbS0PVjE+qeSI+0dmgYSVIdXJUL6MweMg0ySVmEGImXuxbBaP0YnQsDxSvAaw+Zvwc6JeWhTNYLlrWMwj4tr6D+f3f3II5Ye4gps6cLW7cvWbChR56qlz2B9Ci7X0QYabDoDYm8Cb4HKOT/eEQy8ksZ7maAnAXUpLgAN0NSjrTQp2DJ2kfKNMlqwoaaB7qBlq2QgQPgeNfwyU/uGkSlBPGhtASBsZpHgki0HKuAgJ4z8c/6eoD2jqdfV6WdNdVghQbQPB74E7fH9J2bHcij1PI7vDaTxgygcjh9tPHi334J3dJupQMDR9xMIm2psdHVPR5T59J2pbr+Jc9HGMgSHuKO69xL3vN86Gsb9AWRfQS29HuBpTPTHzRcSmOsm3TrWRAEiKMjfxPNsJasHbUDIEP/L3FyPEbMnf6VAHwM+QDPUnavzsHFOoNwHyQaCYiiIvc5O/FYknQzrrv6xHBRK2WubGceZSagW/r8LEygO2Quxu+XMBtAKVh/damDOHdNygkC7NAXzyTNJAmVADcf+duod+WPyTrCPnoFT3d+cK6q06lwocv7VI0C3gtuG6PLcL71lJk7VM1u0MEP12cG+C4ybhniwN2+mh/QRP06yVSdcSdn/VemGS85T8TBtvBpotq6C4bt3RUFfM0YwgqawLEMuca56mXwE/GRK5iu/FZTDuzfTdaL0QVE0x9JEKVcV/RL2VC6yxGiD+mUAzpMfzw3sE3uxEiWpuB9BnkXUwkG5ND6qHuPT0UmKZdY1OTrdbaTNoyK+Jmdazga4hE/8TW99AzTUYB6Gopnc01M//+wmI6d4lrqPPiS6gjTb5sipy5i2+Xa6v2pHGT1IF8Q7TsYE2uaYqv75NnqVarzMeWZ+msvEB3qYPAPcY7D9HiFfigOdyeEYNnkAJJrTvrxG2y+UgBeb5agH7V8b2sNqrhwxatAq4x6H+RJkxzpZ6+66V1RnZ0iugrw+l7tLywkhloH6fHqjjz2EtO4PUGZ5XPK0ebQn2JzXASXDWCGX9WoBbrtwZtjaLnhaJZf01syB+RXhYbCtUxvWaHjJkUK0VQMoTOMkqK3Pge5NWZpsZam5WQ93/ptoql1V1pnE2wLjFK1dUwb9jLdTKfY6o18F3PkUrXmk/hKpWAgYgRDUkAp7Mqvqt8iwGge8biTNLBe9cbZ8Sc5aqyXEC8IM2kyroJNBzoVXU3Ikp7pYD18hlJFuqTs6Xy9xsp8biTd0P0tw/ke05UPKxtISqpEUySBsnRvVxpYqdyK5kGuMi2wDbvT7csYVSQrp0Twz5s/H4FcD7wqFmtEoI8ukNjLfdwHgbV/op2s+u2QZ1JjYirfda2H2HGrZv+THvElM49LuYlv1t8fafJsv7ZX0X4BFP1KV9ML/0E8zT4tvjIWZFelDvBi1eWhn7CqR+lH7Coaks32fkK5j0Mxfy7W9AGeb7hEIPr4vXyROJXrpPxrsom4AODoEuY4XyZATUHV1neD2M9cR0XCN9Ea2dv6uvlqrbNLs00nVRrhTfP42qd+N7VbSaVrg0uzOHsohRGhMRUiXQSz+TSyHvflEjvQMQXgUIJ8UDYYz1r4h6B9kK3/Zyz2yhgOGElC4TlVrt9Gien8fGm9lsfCFSZhJDNLTI97lHs1u5W/HL4zeKSk0wjNiuHF72Eo4o70YWiyM8twZo8OAhoqfwvqZQmW/u6Q6CrHNKHt7Kb0WpqZN2yMQ9n6KlBjKFSIZ102AU0ElHknjXzhVTMoPNrVfYNH2qGZe7X1j44sL8vnchvZXOYG1vmaIKXu7W0Auiecou166mtL75dCvdQXEmbBfV0jcp3ok3rxfStGHbTaVdTtQnepNjgVtdkY+7tCeyHWlHA06q3Jc3N6Gha9m9eh8G+M4iYazt3U/4Haoz61Vc9d9kdRu/I8/9huieqAreL3HagyKZ8mFwCcDEXed/D2yC2rxJ/y6+NuTOrpWWrsU58NXFCPt+KDfoEu3JUEbiKshB3aGTViZVbTX+e5vKPYX0XtYOv1v4pqjqnP7ieohN5e4teBb4N65WJw+0rZFeihKr6oS+U9O+32/xrHbdzUbyX+BpRr2TVrHyfxJX/Xkt5S5DveGBQC1wjQfi68V5tN5c9FL6Lp30QmIevcWMWNiVwB6gbc8cCqRjK+ra1Z0uee/lXMUGuWxdHd0gl9+s0EAyVJrEGVf8EuLv+XFnTmHipGzyFu3GVtcnUGtcHKiAHrcvSgSdNCG5CKivybXQibIuqVg0iDP9xDICL5xI31MnVxCjj5tpnHI2OH0Pf+Z+npgNU+rkXZXqkxZPrdPBqLDCQtqnUU1n+vOYbiiOtqShfFV/kovhXV6lZfuEDsfJlL+y/H/J8hcT0yB/m2syy1/fkS2p47eLJ+WWrvQhjsuWiuJaGgAcml0WhkN9R7p0EPScjOMTAMYSBuOdBPagQlcxk1sRxmexbuoSa5kcSCPIZ65l8WtY/BcSYyB+lsuYknOzpQ9ia0E+iIJsEAengj7wr/E5+oXQNwrg+zrwi4DTwncGuPwUzzYVKv2nH8KK4LscHPYplPEQ20uBCgpgHI9HeJCy1TZdcLZrNssTQ7XhN8Vw6PsIluiWxAzke64ZLPR7UVf/2nztGR13bIBYMlow9vfyWqDVsuyFQYWGkEqVfvBqbHXr72xr6bSgaubvS+1AL+mJfH+5x9Jkce36Ukd1Mre5l93fx1k+lIl9vBPj8AnZv02uWFfsGteEFGjoa6MdFHXzTp3mSBWto/nOCg+2iZM6WD4bYmtp9ZfcTExdkbgs/wi7mfWlRHYTzld6IfUpkbvM/OUMyn9J+hBHKH+iPIc4ir+fo68EvyXwTeC9FN5TCxW8Ir/xdWcO5etxTqbeTErtL+Eu0Mr4LfA9FvrChHiD3H0Ts0pXhbQ09vlZrEzPxxXu/7r3SadOejz+pHMdxfJti7/Gaox7sh8Eah6JvxX033ygpu2u7c7ywW1yzVb1mTSQJ5QRcVRgm3xZrvrMm0zCeOvc2jy+WrFrrTt2RK4EnntEtu9juDxu8VTR1kHtxPHHLJ71zirWA7ZBKl66EnoH2v/aIM80b4BxewP4vi03msfuSoaWxUzsHuYxoD2b6DTGG7GkJmroU1VwFcnQlig37f193JDaQCzqMx8ZAEIuQKp6Amr+sjzd/LNzD+RBCbkb6mHE5x8C3yl0rTx/65uQw09Zy45hJ3lqpZK1PB2p9xiGp1pps9fiudZ1rfOxwetYXIK7HHtHYvFxqH+VuloNMpaWtstluW+eW5vLV6kkXsVN4qGmLpfLuUmcJ/Vz6yGUWN8J4vyetarx3/MZvIEYD/k0BkcgHgep3OizeK5wURi1LlPx49RMfivL3ZLGT1YFLJ7LXEdFbJEZrpnOFeJ7uvKjh2VrLs4NaaQtCeznKB2sCGMvCcamXOQVIB1YEC9Y4kKA+jcVNwekndw7zz2QA9IO4Oyyqm4oKcdKekZkNUvJjpe27JUXbnkpH0Jrclflj9ABH7R4DMAd1NC+FVDrNFeGU2nfWVWgL0iX8zcD7jeANLUBfHLFlUDHt4H7eaGia1uAplvgOwnfz03N018B/6tTvAKx0hnBNob0uaX1nPkRgLGk9mZoV/e5efytAHkt5sPwiiNtp3cfw+0khttaaa833Qxh5lnQugjNmpKAHvDuhj4wNqa0/uPeH1p/bEw56fVH7ySq2a2T3opAetUo+wSrZkDT+fh8VQBXZ34DrdHhepzVdNeXHSxPKcrTbv8InHNRwJPZXK+lKEM+nsZNxBZ82OURVaUrofwgO1Y9LW5mKQ9Dyl0XU/4TU1ZZ6pGqZpkfSVOxlF7XAtEh9avWg9/94h9Yulcgnf0iRb4WRer5jevZLzHnnayFsPVUqdZTQeu0uCaKhUBBd7rudNpEbja2C9YP+9sTEVLm+lLJe6R11wxf9RL23ixxJJcHoojBL9le94Ogp/07cEre6NM+ypWjvqTZo8Q7KI/qSobuitphBLyPh9HPkL9f03nOt1wubzsoG9oKQILx+5ZDHVxRvhN3Q4Fs0MXNaKIF7KbJ5ZRv10lzlbCgcXKjXG4fDHIzsicfPKnAJBO4yQD33gWBO0vQ54G0uc7rIR/ghFGrn9n3rHLC/+VUNXnWyWeHVGkYaxNf7bwaUqGkkB/dyOKVVzGIGhO9Rt5bnAg9HK+YsA5kJUP22E8W0nGDViZdcdElvf9X7N/Ex0BsUdwN2vcOavGMS/G3f4tkwmsoaT52NYwJuLM9EVZThdMuoYmQL444/yz8yH8Mk/Hc8KegQZF2JebpsKLn3w/9YHOqn/wW3n8Atz7Vd7CfPAzvkXG4PzUWowZLLKfktjYv9HgN3QiaVxbdLs98Wjm9R0xTB585o+efladXOSlaxfxzxLLCnF/kS7dxAYtNE1TuEcJzSO+/PsemGuJ0acF10DrT2M6lvlirfy69gh4VzWwW+/ZIo1/bVOnROgshnM1g2FFfri++jJ6BOqBsgDLByQJFJ1VXK1ppmXkraKVpwXa53OwFKkSfO88RoO8yM2F3QfJO3pMLei9C1B/4EMfCi7uJ9D2klL+9A/fDvfyhoPakCxbfM1TtxDv+3A0WyjuV2/5I31/H5eibikaxMxyn5CVedpte+TWynujPaNJqoC9kpmbe8bRn9uAsqFNGxDgDqfxMUOe0eJRQJ6P+95LM2v160ofl2Quw7y3K0eP8srxYWSOpPfeg9wbnEuDAOIvx+wBnJpZrZfMSYvsd9OJrGMeweJal3len3ktT76tS7yWp9+LUe8GP3vNTb2fq3Zh6O34UPudH/lek3jX/Fb7Qp+yD+HnKkofKzFmeEWGccc5chOF3FRhnrC64WjbO3Qz4qnJWMV9SbqVq6aaoCjD1GdRtGsMTN+Mc2+FRnfxcVE0+FtTQ9SKZ/I9ghdOy+JT8RBs40JTautj5l6TFU8pKQCqgLsp8YPmeglIb6HvdugEbN49GlpuodsZAQ9nkszDSoJzNzexo0E7RDRl1XwRfEbcCzW8Htxvc3TW5+i/gLYGTweVA2xSAM4GbCm4GuCvALSxS2q25SKGNB55U5v7yG3P0txYpfeiULHQdArkR50gfYRSTTtLPaHR6f05TweA8oBJZNs4g1rPBOffsd+hBtjekZPuRHvA78OdB9tGB/1nxd4KLKvvqpAakS98gYfPN2G+xLKGeLKqhRuDrYwH2B7JmqEzd6p9DDS6QkO8CHUuyxonFRO+Tn1XsutbCGP8qeayaai7GGBv/Vrx0HcTYo3OqAdpOucaHM6A66UlZOVtjPMCZYiKum6TWFOpK6H7dlm6c+xpFVwdU+7mqZKgnqdntpWnS+uRaWkuzpIOJo6CHK/u65BCUB6j8TzIFOYO6qNOqrIVMN9FMtk9esxv3vNwKaT8XfTrH0StdVwlGQbWHfytn09Z7drQUeDWd/PCgY9958tPFwVvMW2S96bimvu+X8JVmytfW9/0GvtJN18NXK3xlmHZolVCDaSAVmmkq0CmhWaYbdEpotqlDp4QaTccw1LJFzrGrnjexEp7V2Tz8Ue2OcWzFxOaZvv+24tm0gP1ZWqd48iR99tgAO/OdVNM2/ygI6W7YJu477/0pF1xl3gNftfB1s/k59Fv8bOBK81OigcUiZV5xNk1nsH4HvA91nqU2RZbp3gvtsj1XbzMBLZoUensCaC/UM6p1lKRX43rOeGoJLCvGnmFO6nvNVOG4ZxM2T7ZTBZo/W+N5DNfLcQ02EeLiarrETx5Lb0pL+cgxPIOcJeG5fVwNIGW4Vl4F+Y37grCyPP4fkqLvBV1augmojZRx5Qvnk+O4doV0e51cbrQDrPSIl9b6qz2zhasAJqPr6dyM06KKzhIw/NOoGqgiEVoQwfM3orI2uHhL91WCmo4G/6/DqrYlwC8mCaucI/zVrtDGH7nSNMkYxVn13OMVnsmCHOJiRNBKv05ez1ZVrmcaLqZQdSRCRZHPxN0CWp7uD+uoAnPRRZiNQGUXwl+Lmt1p0pQE8m1XkFFW3X6grLnBGkj3REwQ1NJl4VnszHky1JjAuiGcuQwOxvkqfEzE9xfhBlpRinNvSL8HUCNOt5xQD5VloK56PcX8olG+ZHlg9nE59GyUF5BbqW0VwUlCJUAbaFgCMV4Ijx3cD/Rh6KsoVZWiHnpUrCiNiJMxdpcc2hTF+iYS41h9x0G6QAPqlv4A9rT8eLuIWPk1i3UmMfbiCtdAw8diIb2eLgEJKU26GqR+9Qm+s6iQ2M598qIoh266WJ5XAgjhGgbhg4QOIJwUS2h3qq1G5rNG9E5l3UNajLNMp+Rlj4B7anO3ms2F3wTdex47fXiP7CjW0pxgLzv16GgqEm4ofs1RClwO9wFeyXBppxmsje+Yog2snqILLJ2iD86X1JpPxPkSrzkGT07zT1FJcVWKY3IZB8Veh+FEIvSmrNgY/1DWURydMdYk5yFxuWwxnhW10poEV1NTT8xvXVyJGBvgGaexx0G3Pg7xveUeOXQsgvVelCiGejtoMdOCsHXPyy+KuG7xqchfpBFdwEaJWZFvfwva39ciricp4z7Zjusos1mZnEz2PRFs1h07SrZnQK9T/C+PfiHWphMT8vJL5zp+3O+KTYosh2s2V7F98onQdVDPgK/2bDIH79hSl2Qenykgl5VDrawG38b1bJZXx7gX1mCbPLKWgz0SbQO9WqLkh+03a9EpWQ+tJ3edktU+3KU8lmb/Y3O36oXsdx79KpvcB45UuCiuq2mlrexM0djgo/7KpgJBP5Ss3uyoDl4HuMZ6pTHL5FUw7s4WylnbWlNtO3tyfoBOLgyWNqWbSWk+lHNqrH+fUfo+G3g3+ThgsB4MmKwfBiypuViQCyreFi2Ml4TY+3p6Tpw3H7/29uU4c50fi6rdBunLiAYwcCVSMGAgFEYM3BHPYPPNGan55kQoT35NjIFciThHfD90OTHdmRpLcUx9J4UP00V8h+oUrhQP/Tk5wkEKLuFKbERdjzwmHno46U3FMF6MUQP+A8mvRTyDmyblRbRQStaT2+TQM6yUBXEt66M4zr7XgHei9YMEpPS1MtNI+4y0ezx0I5Sj35cmxaOXtvkfGKxzsf9uc9yP/uM2Ly/8X5jTUjDPRy6FuYzBfP9/YLb8D8x14xWYh06T3HhoOdstCjJJ65ZuowTy8iPuwFXFukdKq3Jkbo7NZ5+TZiNnz3sfdFwIGnYRS62svvx3TjwTr5bekXFON2MHmeQMVkJvzGVleCB2N5ThbtfdTtQU7l6g2fYUnUC76E76NLV5dDta2Mip6bzTCToinvxbP5s2gS5JuqZ4cHw1QywPiwP5lUF+CzG3nznV0ha5y8Gz/Gqldi/meExm/T92HeR4nWu5c0Q3yRxZw14NEpaWtC9xVrORUwM6V0ZHlnRjhFQu/K+S+U78sjiH5kKd021rAsQmB7XtGrPTiav4t8VA+xkykETo3vA6qu0kth0B7ZNfilqzg4VfF9voT2tTYjSHK0s1bVopGCXW04G0TuBCcxIhd3g9/QziX8biXxmzpuAtC3vpP8U0cxXzr461pPwbYQRU0RzKVWW0YguEj+Gs55tiunkii1nCIORCzOrwWtoj6s1lzD83RqwvBhUYFVDXXeIPOMhO4WA98CLEwbEwmZq8ILxkp1M9iVB2eJQTbYe82kBMPxWbirXtmOPvgV66gK5fAPdypjJviTaX/wr/veAGwH0Kbge4dnC/APcrcGvAPQgO952s7hkDMi8xc7tboK2yIjaPmlp93I67hEccXCC3dbavSlB2tigrvS0HVKDZ4X9XA97ZgH37MhOeEx3l4j2jnHhepKMhr4lvz2tSgePAkfZyT25TniuPjQAWTy776mBfuYruYSHtOa6cJvxDfqycG33zRA6ryyJw0wrz9MvgLd2Ro6+DtytVx+WperpT9RHgPeMbwvCxpkdDlwh862TbKDojWMfaatoAMfO7ObtW6ghraReEom/FAL+bmLXSw+FplOwLh26NDvhCod8meWGKh7cZAmNsowNlQgj6K1L0fyLIDc0gZaoHdwqk3SykNaUx6RNxpAYc2TzmFNZwX9gjKV54ekYeW89HnK3uGQ3SJOJdAIhLw4DzztuFHYDz4tZ6XzVwPo3TfgnWtRIFeTIs/m/a6f8/0jouprX3qOmmbn5XlvSibPHoGfY1nVy7rhNbSdvJ71Ar63amNNYG3wA+S0sV/eQBaFvVbmJ6BKSjNyPEmne83AN93B0KfZFAvFwfKWP8zXLJfhV2NmT9MVlt3CaXrdsml/8SW/gXSU3J6BO4upklPQHjTYUn7zhAWhIK9TFI0yOTKGkzNuWMyKAzcOVoA6Q+Kqo61Tv4jkOFms4Ox9/60pzv52se0XTqnTvPEP69Prx5bn906JwJRoHuhs/FlaUK7vEeka77OXKnUpfFuDtGfgqcbyfUahPw7l10KZ3GTkm8H60r1tFa6QHvTIFMrpXe894GUlbT/P6z77LzAETa7K2l/PM3O7XSPRHcYf+bwCm5+5Hr5XLCm+cBBFXE5ONmGCafx/0RM3K3czN+FuCfv9ZJTFppZQStSOGYrZWuletKSmzLB3La+OeXsNClEdy7r4Q2yGOtrgEjhDlZWH0Eb/9UwmbJc6xzB7IhzMHCZkLY9FSYTb7cOmUgC8JmszBrpGa/ElIid529o+U96/iBvLasXVrpiigp17RpdlupdnuW9OfwLkc+tGkoFItjK9wVrmTtaWPtaRhcPdXQdwJkO67cA/LDhNQsGxmcCiOyhfF0fjdKzvvDxKpncAYYnIVhlLCPg3bA77oQWhGv9WPYByzsyjDK1R+Jmj1jXEtKsUwRSF3u0R0PhfwsxpSwEWL0ilnPZ7NyNNB3Rb0TZ0T7QOdD3QplkNnQrpeDm5dqb6R1bPvF4NaAW16q8AeUT45U5TJ5pYPRAt4QnA184vLSMdByb8uk9CsfjAtFRrNGejWJcrGaoq3IFkEjdSdVU9dR40n874b/XaBZk4pF87Vn0vX6w8rMjZqup1/ijrq0IfFaOd1ucE71OBjvRoldF3hPJrUoUds8CodQvtXsWz0T70SRoVxas6Kf4k76cWxGQEtDoTuSk2h6J9o2IdKoqKZk3IlH5TKHdV8xaKr8bn5bluSPaUrGAu6KAHfpVnUwBDo0MeGe+ukerbRRzmRyXCbb6RQKLU3O//o/Ld+LfIemOL+PKz8v8ruzpIkxHrjBdCiTjc6mGPOEmGNW8Irr7cDrqcvzoVDuYbYBTDsKydYHBT7FNxTe/VMz7hHJAKnISOsv1C9td+QHNAP1Zx3mdkdOAOT2wYazv4JvdSDN1Q7SC0hGg/omNXCkSbSL7YvUNYVEXRPyzwcB1pKli+vWwxv3mj8G79+DazUre6N4wCSOJhrGzUqpYnU/TZrQS/oKIM4kcO8PEzZHiPfuok26yk846mhkMufiNCm3986p4wJ3T9UHZk+t9BQFq0AnRWmFK+MGj+PKpWsaXQ7U8XoYOcNXwbm9MxtVwg3zs0/YPFXCNOc4jNV2RsTvz0RS9hTILafkj7o+E68uvnH+tbLZyLsXf73O4Diuqnq5/ob5n8jqLpVbfxxTV7CWr0ntXUP+ciQw0WcF6TAjolgnu4rinzqyjtbs51AWayMWnOdKk9aFdRelzFCoFPR3jfRoMpf12lwmZVb6UJ6eG8GZ548CS+B7ZuQ9EXN5KvAgDYqk8rsg2lMfGlbmwq43KzL9spQsfzwlj2J/uVTOPRDGu8LxjOLxSzSmUOhUFMuwLKn7kaQbDf+3pHts/A/60inZsBPc/s3da9ku/6nCbmcN1UhpyVY/N6X2nGPtpHF3laBth6+S3REvs59hSmlBc2B0r5We9mK8KWufYOm+TdwhWP1lrSO2NnIGH2P+/06YwJdMRzt758RS4PXx0PVQDxlvAZy+WFLpuUoiZaztnv/x8Wtkq/1BJ9eeD+neSSz+eqOO68R1qnNeUlkrJb24r0R92XNn9NrL65+DXqOX9sXRskg8dH+YVP4zOFW4l+X5l0Stn39CPTxY//L52mX5zMbZ++KvWdjjCevFMO8ySbyL+T58iS9Z9h/x58x3fQJpYW/gdvZ376Up6w+LP2O+dyVq/Hxn3vDWNQaWDynbJrpZyC0QX/0Eqfyoj5RxZb8SVzDf6xP5GF/amv2lyJX9QVQBDh/y3iHgjIBGciVMvuvZ1/zEEv9uAVPUJtTIJ8pucSyWeP1tYpMTw2dAvkq4PaG0z3cicCiQszTSf2I2oagVZFo/2inkOwtbyaRwkN+9C6jkX7E9EAb1skm4I6aV2L4JHpXV3pnOWoCVDq01t0jB2LtiFfMjUI+/ONBnF9TkdXEK8z0fH/F9D3x94kTm+/VF3wHwfU4sZ76nLvq+Cr6doon5HomjZK7454P/H8UiJ7b8e/F8P6lcM6x/6e9fHpON9rGusc7G1DzcgS9vejJH/yz0l13g8LzkHni/aFbWi3zwfhncK+BeA3cA3Fvg/g7uA3D/AHcI3D/BHQf3KbjH38zV74Y+9zZ894NTV3GzkqFfvNHSww1567g5OA++VLaQNOdoKNs9cbt/0jhfibLrLxm64Q3Ul/kRfdnecuCjcTkMHspum7sV21kqaUGSWLXHVWWhUFpEuVd+7iCRrlJuQAvoXrBSHkZspLZvg5pdvFTHvsVg+u7VwjzZeDmG3xjGO3x8An5fD99LetWl+L0Avk29yF1GB6cJZ4WxvWgZhFtNtmv2ZIJGlCXNioJ+4Ee4hvCBcC5hvXj94uFDq3HlrYniLjReOoEniKwnA/gty7tF9WXHxeQ3apDC1jv+3sc38WcIO9dO+r4APH0F7rKe3IWVQqUvp5GXxodxH7b9QDZ8F4Rrz3J5Hrr4gq7lBZnYt8iqWm67VnpI5krUx50OHcTRhUFbhDcPPAq4d98neK5vMrQHuLfB8VMQftZCm2DzZ0K872UFPkC2kLL/hf0TWdNY6cZamOjXKXhXAIwV4LAOvPutIXI1f762OoPdCYl3by0e9k5bLHmXZEr9r9UK/EbL1ypVep3Ki/Ym5B7TQv72LQ5rXybd49BSa2C9sEK/11Fx7Al4lh/7BJ5lx4rT9josx1bA03zsCXiWHvsEnqZjxek1E2pxjwpFi1I15lnszMPBJDHXMr/3kn8/rV/Wcrt8gEz4WtRP+Eo0TvhSzJ/whWia8JlonTAo2id8Krqnz1UZe+oEfkivNm/cqosdfXwt++PSNx6Cv45NRZuMzP7Hggu9DjVdPDzvrmRoR5KU6y2W+8pvTnPizN6O5CpBZy5cN5FyZryt+Xzo2ySeWqgtVc7BrOvzFmqJ3NMmT7RvduBqXn6Anzhm4NRXnFSsGlOgmsBVYF0Q1h3J2VQ5q3obqwt+3ZzcIE9cIh/gJqgqAPMT+ApR5CeQii9EhGlNwRwb0E8cEzBOzAuSCaCB/2wEYt1FiFdchDgLIFoBIsS7jVScBjgltE4o2likwRM4o+mYI2OGkjPHHP7IV9rKTa9h5SKThwPWFtx7u8JXulHFfFcmM31Wr2oGxj53SEYrvXedFZOl/xHRnggZMqg9fhNIeM5o1mAoNFfGndTqQO3ZmfM0jedDH8QwDHUuKajYaRicgvLVD/ZbOOvoYOGCVVCy67UZRwoah0OvRvLh2cOe+yJYl2mpew7QpoLKagjmsvg3aM8dyYE4XREjPP8Ezy9FNYRms9AbtV8cyQT/RyL4fDhiaPwXyDcnRUkPkt4ld3IUpxHTOHiXgBsPrhH+L72n44fz2n+7s19+2ZhTx7tO7MtxY9mxD8yt5Go1TVpXoZuYb3BrXHmCRUryyp2pZRCWTGaTSniroNe3yRtJS4NXftXY0sDN4idmMvowqlSZ2Nd1znTBPJx0mKU1qrw67GG1F7i8c+Li4d7VkqgGGPlNBY2Fbl7ghlt+aRlOrtp33rvGIul4bSBvwDuJD/RPKg7UTuKCeIMfJ13JzRv2rsx0ZdTVnn1nXo6bZ3e17jvfv+a7gGpg3/muNafFfecH14iBfefJms/FOqmf/1zUQz4GcDXgIJ+7fJBHeWDsQO1EfYAfmLVfsSXjncgF+ifKwfnmOyVSZ2zkhBzHqEB20+LhtpsLWT4+yOd7yMcH+Xwt+iCfrwI+yOdTSKMZ5Ob8J3intBohmfmmT4HXTE/libpuOvCa63WZR/IkLtvQR0xoJ0jbhLUocJfNKRIQu5h6+JJ02SzN2P9Kk5FKc4NPSaWHOFezZ7tbB8/DKThfXwInH1wxOBM4jJknqbN1DI4CdTUpcOf6RkrxQzq01rFe3kTeOm3JRd6HMqeG4g2b4+kPdp4e1KYfHd2Ep7m5tkIYMxYPb2vhpAdkUtYLIcwaVXUhLaCZjZx0r5wBlDstTCz3yd6W+2S//aj8sv2b24rrtE33ya3eC/uK3WjNSZFOG1Sc3vpeGkF6VE6SbiCZVA5lRInZRG00h+KarHroFnYDfSh0lx95XiZFu3JoBdkAdZz9y0J3m/yavcgXkF8HHvdnGXdHddu3ya32cQ4NO0+k8Lt/9OH5L6z3VigX3vS4Dt74nSMZskf1GUvVpbyNA16lCqKV5Q/6cN+FkZpKk6FuZiXwEYBZpNNT1VE9+D3XhzgjlpaeQsBZAUV7vj9JPq3NOzJKac9Sb+lOHbZD8peNffOk+Vyh2wzaBbEoMkRjn6n0gojlAZ7EamRJoDVhtBc2O5nG0hW6jwBO5NC6yDZWxyOsjpNBi4U64rlyVh89DRbrezSuTfrzoTKZWA19d0qZhNkb7jMte4ooZ2ZYizKu0Ca3mow6/VEycW4AzxyXuJRcFsYRazu0GUeLoBXHhGt822SvvVPLHzEx/jwZ20JfC9yxStbQLj+G8lJSR2zDAZ6qKKfsXU5skP1LFKtdNSk95EJoUxy57CBw2atK1cBlx0b0E74BGr4mRQNDbNwPyA/Z1XS/D7iOqU3eZD+kyz2aJ6myMwOkfIO8aQmRfht3+8j2I6ctFvXQNs5KMyWaZOdlAOdnRPBnuwXstfnAszYZk6GjfYznm9Od80wXQhQke7dfj7hdmu+eZ6qT1ZXDIWfCWzrPNBxanlDsoe1Wc3qkyVDP6KbRC8csyqfcS3iLwWG525TrmyhsUnFHcLV5usBt4ycdlvca846lj3tL3msyuDGOevZb8BTFIzc9tIyrCsjdtU875BP9cnf/SZGYL4h3A7/GPugFB23T4AKtbPpaP71CQPsQJbV80K7g7YH5C6H/1E6vnUQXBbYDBVj8o4bJvDEBtGP5uUY4in7EthLCkKI5HnscfvO2qqC6dEYjjNeJaYNu9VdHT8lH+rldh+TuwTdAYhwMHIOc8oa91SeCbwzx2dnHDsl77fyQOv1v8t4utE334pCa/xv0I67zI4j5mci1r8Y7P+Ru43mxROa7eNy/Vg3crLS4Ee9rO3NnSe2TgTHS/OwMKE2r/XGd7uiYptGNwIUchW4V9JesRJV2y1EM69RtOprdlNWocF7c80oSXjEZakg+I3bpuKOjSp8SS+FtKP2T+LQ2dORz7fkjXZpzRz5K8TzEH9L93BQO9U1pMJaluZa7cSS7wNcNk1WIDU66wGXU/e+4Bu1Ks9n58ntjnKX/tG20F/D44j5Syk3hhjjeHEzjuOE1K610nqTi8BQ6SE1nJ01LhpbGDE2ZrhL3mWKyFftihnM27dQPh7QJ/NM7icVMh0PzE4SdTfy1voAeRTvY95U7sB9iWccBvRuZZb1k6PLY26dtxvWYrw3yVWWk8k2GHoUc688WQo4F7M6rG/U59BtxJF3pj9JlptIppW2FtI2stNHoSNqvxR/qrPo/62wCGFaq5H5d8kxxlkupYWaqhtvjhiaDswQ4GLGg/3DoUByxgmV8N/pDfUFi6XOn6or1xvrimSjNJZbZxjWVLDole73jXHgPfDW0Gc9Xu4uaprtxvq7YvcL9ycrim1fcXLhqxSqv7K31yq21b9/mlf21OEKEQtHkO6dt9e9Az7hPfhXcazjHZwfpos4irYHW712NVp+qhToGV7EAh1yoy1vuIEgHun6CMoOajTtjFhCQj2/RoO3n86EbI2gR+kJITMqhxyJvQ34rgDN8HXsb6mxoPBd6K47P/ngGPA+w52vxdHi+wp4vs/sjHkgqNvaQTpG3TQQ3CZwNXGW/nlTBG7CxTsEG8Dr7Sh/QK+eVNxoP7VM49EbTDoca+vmvDlggZEhsaVDu2DNB2VajfcITxgNvblTbDdNUks3f0rNe8J1fd+doWuyZGMQynE6O3r/TU/Tb5padHn11+1c8mTRuHTx3ek5sbPZ2ebRCMnQqWV2Id7hZIc6NvyW2UX0qC7Hk11lbSDnm449bacsBkJ40IfFOKR+eMuQzzjOW7c0xQC5/TXJTDQHV1MzAGtDdX+5Du213uxF/nYCJ9MHVQnH9WXEP5BkR0bctjrKYfMAIcIo9Jmbn3fL7pE0b4Kotv8I8/x9fXx/YVHk1/tyPJLdpoWlTMP0A8lGgbYCGtmD5kpC2F2jBgriJoFtK/UhBJSrTqoymgK4M5pDqhq1saudkqECK3WtFDFLd0M29CdCt0HZWQS5tRW6aQm7Tj/zOubcV9r6/3++P5N77fJ7nPOc5zznPxzlVsjf7zeJtZFCubXKFCnSoJKDdaLgq6q3Y5PqixpC811HjO5eiy00uNPP50GuV0iaXpXCT0wYl/GQYrdRxTcXe2GeLn8WzwPqCkif03mWuG+FVwzgruptYue57ohT07T8GXq8gplM1OhsrUsMNFWRqp7Oh4oDzjxWosa2M2qA9/eHjA1Nl+LKH8f/1IcSMAl+BK573ApSna3Y4plx41VANsJ1KQZij4WlyDQcGNrmOVuhyKbPj8Xm8AWC+Hp4Cc3h/eO/ATbjpYcW6XgobEdwynvE0lCo64+eXvNTCS40zftbR/A7001kvlvnkwGFogxp0wi2Px4lHhxHW8IjNaQRYHxxAXF8YMsq9x7Jh0CKuC2l8SLmfWFp7dDdP7cVT3zUeVrxzmMo3Z5C+7Z49ZvSb6FjxlUReYsXnhrCexQP4/8IAwKUiZtCc162XzM7fHMM1zuzOJ9M436GgXq0O6jXTRUZzTxEdpLjJHV/XvOhY5J/Po67Hij8e4oLRHPPjlz2I9T+MGJ1pFmaQE2N6CT29xCGxK4ALmQ2F18OvSQsLi3gHr8o61KvRfh4wmqlXJ5Uir6APsmL+8KTl+Nw/hDdSDzuoC2RG0gXE43fSnJ50VYYPb1Lq5bVK0zMvOT6GkTAV6HzTyPOODwKfCrk8fcho0h6kxYiEEKifxFNPS3jtwevhGVFqLsufQ3s7qg7gYV1om89O2z+F50cHEzk2W7FFYCyp4ZMrTd7NYqpKubVJTZvsTitJM1GDxLaz4oFjDS5ivRYQXCT7u8C3Na84DvomAAX3h+ukLP6hx5fIlrf6w1Oi39TclUqyVJ1ob3EebyxkxVODZBoLPfrQ4+hx/S9DiK1xgC3M/Zz0V4BNpfoUYHtkATF2yTYvxSV7pXRb6kp6AWXV8DX8DBdz/m4TaqEPD4fDk6JLeLxZFSeejiaBXpDqjRN/FVUX3Gjc5k240wiy02+l2a7KvNVevCGYJs1wGfnKvHHii1KeE1s204Xy1S8kVbCSks/KLSEi9yHxxc0ixnTABzuTGNF/ebWD87P5VPAcs1pirXaJzd7tGAiAvlhoEhmqJY1LQQ5vFBnCFhsKdzgIxKU42Vy8d33t4/f+nd9UsAn1DquX2bTbQfsTAJpj0qZNqc3oFdIccZW7Njm97EK28GSQpdJFDWsqfLc8sxxk+ijuXuC62qCw/SjubBf2rUggddsd1Fm0HkTVUnW/dDDnSR2VQ/b1CRQ8qX39MA64ppv+7seJ6gH0cV5pI2LtgNK++GLdcq4J7QzGFzski47KPW6NBEbCX4/0h1ul2JJYb3+4eYCI3oha1A+Gwgkw0lWicQjt/FDiv48jXrBtZDoxnl9N5Dn/EnpBAy7zj0jDpoaHLRVo4fZTachWKnqe/FQiszeLE+H7dRtqMIWzP5WWzRYtFx/WnZD9r8tWxt1LsVx3k27lDFec+PZIpXf8nYijY1Hsx+Xy3b78qNKPceKhaJ7TfQJ7MU78Q3SsF912Ik5txjZiWQiXfZPBeyP8Z9DaysuJxVKOa0tjtIWUhb4ASFty8zqZsuYP3Qa1h8PfD9/+lAcoOxz+ZNhTlOTXA4XFAoXdN5Igw1QRHaOtaPj7kTGYnNGbtBUn3hu9lbYufEB8C4CuELYx2pLXXXbqpuJayvbH5jenFCe6tjsmB5KhNktzzdIx/4AvPXRW2qkLPHSvK+HhszCPrn44cXkLhABuH7/fSQcrSQuEom51cOSS4JeGjKceOrWZftgvEZPjYU3xSQiBtE9UP/TZwychDG0mjOFotY7ibE36kjRXw2P/dTS1ea0J13D+PMgC7NTBBx+LhreNXHzMXGvZTNdu2GzZR0xvPvbGQ+2yr08jv3fpTUp78CHqIBHLJKXstdDWgk2a2SZRQ6330pt+6aj27di0PmV1yo7yHb4dD1PlbC56hUE9k12uKtG66P6uDbjO4guV/npEiLtKulgSUaE9oGvR6HfuJuyxiSvZBSz0GfKCO016gLRsEP0/YE99N1Tp1cm9Uzdyk2Km/NA7L43cpJjdI7dSTNwHCsxugBlxQvF4t5l85V6KNgZKRVp+x3Vjygxju1gPtHCXy7AUoU9aSNndwLPYElqOq4W4M/8rjlXyVUC+iv8Zxyn5IO7M/4rTKfk2Qr6N/xmHO5D6lUmlSXyWi9qHvmcYvKE8DfeZC4tQyxr16lQXG2FDKY5xfqvzHinP9g0p8M4vXM3f5cL9h7k9RnWGT81TeZeAJsbKjrGozLimEG/RmnGtAPe2pwDfimeodMT+Ln4vrz3wlZT+CRth+kt7WsZPb2OCE7VxveMJY50s21fMoSck376cMq+Qclf1F8aCpsXafnSMmFeBfBAcWcWHwkMjfL/nqewuyjxrefayHkF5XpafF4VZy7KXa61xwYzYhT6KV5njgquI1ac2l4rTtaVivnYtH4CU05dPX/alkMmvkmbbcpup2b8E3oxlfzRCdcG7n2T/HTARCv9YwpPueh9I+GYTzNypIM+2D3/wH2G3QVhgmGTfDNFDyOnhIi98p5v4BPj6ZFjZm8/ibwC+XkmgOC/8PICzL+FZA89ueJYlUlwF/J6Bd8QnB3iNgx8LPwI/rilOXClLa8ir0W4w6nZVBQUiAY0uRtb44o3EfD1834imRGPGL+S9ofCGj40wLj7RU1xSF+lavJcmOnjmNzEVLMww6yroMrrZUUbM68o2bDNuOxU6qTI2d7nIVmeohd7w1L3VF1zJPI7a8m0PhlqY8qfyT9wOPPKkS4seG1zvSz/RkZcOuEwwj09i0LI1c8GyFbVNyxZch8A1vBswv4hNzDZinRvQZcX62TYuK9ePkq+1y5iV5bdnSYFJPOmip66nmODrBWclsul2Vn/ufSZxRWLpMh8veh4q7KkuvN0+o2BhQYtESgq2nfKUhShmM0BU8BSzTbucCeroOBdlqbVbgB8AnzqB1qkngL7JTD0LeCceoiNSKJrGkVViE7uNzMj/AZY5MiwzAZYZMizTEJZpD1Bs8PWiVoksn87edq6B0QMkhaLngen2PSqEBt7XgGZdkFuwoOAzicz7T5i4YrItAeDZYUeNW4ZnWqswkT8rMNMCCI+UO4SwlDyjfebzSkcPYy7Y1q6mQD6gWqPhw75o+CEfs82xTcFIoqiLT/Ix13XlzHVbOd4xTXbR8039JIHK2u9bInpWJzsLtik148qtu4kCzU9eoTdVA599wdC/9W9exmrpoEyv2k32q41fe3drEs+VaPTnYjUTWxkTZ0nvYdj+LTivpFlKCu7yOnMNhe4TJv6KQJloyzWBNrGW7wR/bkjANNAiAefhk6Fx8l4YB21htpaFljDMFoQA6vYoPB79gM7zWkSa0Ttb5DkA43G9EccDC/m4JqDYYrtoJAZnsmuXmmql5kcCjDEUvjKIFK8jZBXaf8V0yN3Uxcmuz29J1TqorO2NpVNoexxf4EWcqlvJNg8VDf89aqlIbUYfQO3RAUG58bR1pF/QNd30t7tZfJRCPVCZRVHz4tBLK+hnBmOs+OAwWkc2gNTCiFtGFN/c7lv2QZitF9TjW3Hlu12jbY25M89VCOMg16kyposUGw3PHcxzKrsg6EdbwRm2ny1RwejFfYcCkR1dn9HFklUGwjkJPN1Nqm2PUiqZGnXzGBjxJOt2/19q7p6cV/j+4I1+fpu+QC0y6oKeTwuoWZyvoKfwyc8gJbutaJtMxYUqkVFRM88BlWoCCStnuq6q7vYVIP2KZI1F9BRgvSBxzWO2pTJMDlLcPh1z3bOGGEFy7PWwdIf7BJX+hZDuSnNSNlyzR9ilpnEVuBP1s+bYbT+M3EyHSDbAGM0sAX6xnSl5SjrRW5PaXLINdzRKnsra1VtT56DPlm1brp7fWp+yAbjC5tALiRueSuu8XPM7R3KHOmB9pl3DtJ5txBzlT5m2FVN08HVHKO2MZMjc19jY2xDPXZhQTFl0rt12BvD1pTCZ7xWsuzJdOXxyIfbrQ9FyqI+F3JZtlubntqrMG0Ia/XNbrLsmF86qVmBoBBgSRDt1OGDkFX/fP4M+yYN22Zq0Kxg+JeUlB+mwnTC7UtynQpqp9+N/0QE3mwvPDYxEzbiK41hHVpGM7Uc1narlxKKFeZXN3e+g6gY6UN5W4tF2ahxvrnii2XITT6lLRFIGeEot37YB8IR8NVCTLPtQmD18RbhYs25yQqF520uDoeBdcvtLCs5IutiCnk8KiOiEdp+SdAtuKc/qEFkHlGe92XJiPRfYtFUtt33Tln+AFn1bCQ2ce7fzJs2u2aYXOWZSIKmipGxhM36x6lPdbEKM38gzXasqlpStLjPwCtW6T+hFHZvAM/5omIraUH8OvxTtAT0snsi4ILuibEmKy9FPnkhxprgSNUOtiAOkcdBptrF8m3pB6y0wz0tmZ7fehOWWmExzP3E4xL3YosyxcOYGl6B14f7vWYmbh7KTUR7ZXw1PWW7cFuuizNvtlh6aiXXiOJb9cQ+Pjbf8EzfrQVtBY2VqjYi7W2qzhsLvDVi2aZcp8bS5ReKsHI7Nfk+53mnexrjooI6izL+U62Kcp4W00XG817vLe3Mdq2RbzLaWENEbCinLbvsnW2MLWracbVT2HHEFnuUTeKctGtaNlG9l5T4q36J4NgufwDV6XJtcG2X+A06H6HEAdhMVOO8dUP0AF/Y6B72OPAthkWeTc8DrfMxNrCYvgRkD8iYXyKmVueJW/pfpjYY/HVK4H1rs6ohK8h4xDfzU3FwgU2rBU7oT6I/m34PlMOMg5a7XXD9n4hX/ztFwzceiLGuKS3OL81aglEIxOANGw7HDXS4Deqzg2137l34lffT6V9KnnvGWi1ssPyPTtUF3TNq0bQVRy1vJuF6JfQjPHG2vmkTDE4ZfkZ4xwgxHP49PiIuRw2MgvNtG3Y5zH5v9PLxzQSN3ITCx5LZloAfnpDhBuk1c50wqjgXd1SGxC++SkhZa+kfKHfAs37o5xDDlWyxbsSWWLXYzbSEmyxPR8NVB3JnnlkXDbw4qt6FnyHjFthnguWohMSbB8yQ8uRiyCu8XszwJ+lWbRZ7KAGnIqYmGPxzK5/E7Gm4aehlgc/4c4dwJby9Lz9iU92dsWDuB2su3MjId6ERnfPkWlZ8NTpCpeOng5q43t5Vve1lK6/r65y9LBk9BD235ZtuSHi7D0TPe/LI0sSs+UiOlNk6J1Az9rvHjYFx8Vlt8HxdzrzRLJL7ZkykuZgrFLYdn2eiTMVLcvaO/Mvg9D7+mScrvDYg3bU3AXVM/naUK6ERPPO3/CCRf1j8m203rIuIUQmWs9hedpTNCAQbkDcZ6ra2lt4WpJznqFT5nrj/XUrhe5i+zA+VPE0vD07QZpEQKzyS8MnST6kFfHLJsbdckt+J+m0KtGbw8lyi0nonYQopFbEXDj4+MQRENlw2hz4qf2PBWNmX5m0BmvRf4BEbdJyE7taSngCp7+o9PfyrslCad3ClNPukTTFtLNa+1kqy6AMJPZ0wMYLuq+pcfUVqw+EbhEWzDfpKLbbD5bcbCaHi+7LMhfeQdgWRU9ece+ShIQZ7sI7H8hhCrt2y5Jpdbdd19hGRV9T96RCk7QS77jlHczG9Tys25pdwZI2cE93EsjQksEXWUacsXwkdBOj49MFGMxpsCc7XUHQ1b2VlJoB/BDB87Lj6BUIA1hmnYgjgwMicF2nxDYMz9AmvuE1RmUdj8QyxiqFeIBbjSj7Rd/qu6qt94hMyq6p8kQ5kCraiKX3xj4hGgO9DTaOvift0RK55+gNFR0EPpgatsNW+d7aVMZfIogRmGqRGUdz1fBiOmWjgJpV4//KfLlq33Qj3i4Rb4vnpYwWn3Yazt8mEKart4+LeQ5qeQ5t+HP4E07XJc22GEpPXwGKWfGUD8Dhw2QOuxbrWf/qFujmm5PAaJnn8Ixs7xyzDncDj2xNLnj769/O2SOFeq6+1ipocltD3NrnUu81uYuNaGkj8UT3IluibYZ8YVB1JdbxSnxkVNxLoo8CAT3/payWvFkyF2ov3PjWSWXfyNJ9VVV1zfiCns4i4PmaG78Nvi365UOFkGr3dSpgTxycErLiN6pgMdPBNt1qm0rS8uPy3zt9QKxrt/KTH9clmC+NPBLjUJbqn+mrUHj1VHca/CqFju/UpT6NO5EpzrOWPOB8JX0pD3K4nbR6bHBv3a7zULW7dR6uDr/D9h9sG9SbqH4QwiFZ/qpyx/kbgFt4lRUi8l2GYCdYmM0xoPOmw0nDVcD7wF5nBKE4iGz0YwRRmMsd3wNIh0fJqPlnMbRC4+1o+xmNtopQNrIfeBYU6OfZTTBCnNR4HNgkIXXwdwdZgc9cPYGxi6ILRplvkUuB8VyPQ+jT243bOqeHVJac9SQ6rrjGyXjIrlgq8vi41oBlN7YuLbJC7TgBInA+3QpuBeZO1if0GJY2VmT2zMTyO/GEqDeZbspQfj+ijLaZzdg04qs9DKu7YiLd0Do1UkqzISAxk8s49+JRr+JNLZTefoC2uBI2B7VdDe9ZFNW8tkWSdra606vjVz2TtbKRe0IY4S3cAN4hI2h4oScXxQzqwt72xJASyk+Ti5vhTQsLR+k7xurZndEHTC3PLriG40zhOv81P165tvKwZ4YTa77T/SPRfxyOmekvFW1f/UkUuXCchEdMaXAdyz2BT5XEgiKM+TVdohm4jzB8oMHMj2OHeMzSsoe+pumVvuLZnkUonxambWmg5Vv6g/dp1kP+I/dt2e/TP492QvC3wW0oLiWuhfVZJmpgfVOfv5M1KXm2QXBvZJV2x08IqWWOcHzkht7me30qJI67JyA/aZ7/AHfaWiPXZKZPfAcl4TnESo2mh4Z+St3lhozf5InUQZqfry0Hb6l/D23Na3pZ/spUcl6DF6QR7+/JC8a/DCb4DmcP58AZ6zQPu5oH7j3AuXseVPRK4K+btGaha45qYcdhz0zeKnRF6QDIXo82ZF5GAq8O/Igl37C9+WOM/XwuSS9VuxfJ21PTBJ1oZQsmkVDCs5kyo4AWDLibwyMMFGrNr2rKrebWtgFlT5N22lRiXck8KmrbRZEhrYquvSe+Plc1wM9NZd0tBC9FnlgOebN/pp5HBu0N1PrtE7L35LfEai4B/7CPUtEoPyauyKLifKKqmyd0qDl1guOtHC5BpjX/iDYUo+AbJHoi2WJ/D+O+aXmjS8LEtNe0GWMn8+qEhSsSsXuDL59S60Wo3xGIul7BhWvO1WSMR4xamklU4oZbmbpqy84kKvmueiN88eEVPyMpIeDa+S1hhnPNEX3jBs4s38GmN/uGw4qTgKEs4pkJiMOf/3Z1wJSkRpztJ+j/M+530bOpx1zmjYLkXDd0mbtj4A42LTFuWcivsEwoC0qZP1vB3LdpQGw1+O7FgWDH8xsh3+/zoSDb8XrS4p7X/9CWIy8LTYO0Lz25Y7JGcqwzuc482nttA/2/9Qi9RGaD6NJ8ZSMW08UF3cHfz4QbLktofOPfSS9MyqIlGnqobnZ43bpcpVD4pVqu3SA6swhgKaolRsBsbSwTT6Tan45NcBYk6bbp8aaNwhXdHtkM7pNIP0khbJ72yROuwvSd2EyoFchM2qhncmmMY0SB+uEiDX2uWIpX8MkYyTfXWeH5f8eOU9KzygQcziGeiJ9wetLmKl2qmF4QBlyXWWFpeWJLg+11Ct1AJcY+gLNwyugLbmJaY4k4wj4dWDy2XqIqBBe0ADzYGwpYNFJbh/33D9ZHlDX8eTZ6WO6eb+k3cBZNPx3SEyNL5jrfR1O8iktpwWqcuI/5fk/ytG7JmR8NPRkfCuaO5ob2FP1TltxR3OqEnMNbhIxvswejk7yKHOtLJXncbcWkcokFmStZyYo8Y0F+47Q3whwpJSth/id0O8ZXl6idaZPioTMy5zcYrdXKIvYJzmklhnYsn4ZdUAFzGNhM3RaNgYQfosGvKY1uDapb0vfNdHio587GPii32XIwdxXwKe2sMxBGllD3x3ggzJwRj6YR0GnnE4psYrdOSJUcaXJ1bhhSz85DHHtHDIF3X5cQTXFikT3uMgEdVk1YX+cH+EuOwOXEtEz59LHleJPx5AL5f9YSHCujJ4lRiWnI7vBWo/7tmRjL724XDGQIvLUrbDdXFDgWunlGHDVJdglLUL1DIimj4APV+L/kaGw/oB4iUu7gTq6CQdx3R/NL+5P9wcoRVfp7LfaKM5EyjcPUIywn4qr1dQ9LNl3v7w10Mq0HjNzjRnf7h7SNmrn0AGBdsiZS/ptJepPO6lRcsIMRkLdRK1MNtKgtEcjT8bOAgtukaItzBNPmeVSmUwnQluHd8rzLLQKyxuYil3B/GMz2hZXVDWWShrePg/y9KOluUYWevd6Yj3Ewvj/s8Sr0CJzA8lZlskYe4i5DGUWYWeZa9vcYfCDw2QdNX1Z57KTc43KyOaHs5KBgzMPiVd0ufnEdEovX+9q+r7gBtPDPCYqz/cMMRef/Zn7PWmh/BUwGtD5ySWzfCCRpKXqqHO9Yf1Q/lzmhxsMJ/FfDqokcXzirZQeNZA6Y3ok5YdwFfLdHKJ18MvRt4fMNh2OFS8xj9tEu7zPj9ka54Kkj3VdbGCyr1Y5j7RH+4dwLNz1/wPmKhlfeFnRz7NVu5iXQ8/Npqf8VeatBD3yAjkstKd1AKs42Z9xkn94TNDaHesxtQjYH5bk2YFVVjjoAI63nYCcLv+bOMm+92SxbajJxEk6zZIA+Mr3OuLfkfzGV6mhPmbzrlaPicbhyuuK9BfI5VJB5a4MWwi/IzeZG+si/nhG/rFGevSN3POZU730hKXwRkRIB7CmOZlTg7CGJ7jE1wJ3tWuVx10AM97futLcdFOA8TFumq9Nd4djphAikvrLHbVObQBYimBGD2f5U1xbXdEAgaeiLEfQDkuqxfz0c0OJ/pBwl0grYtxrfOu8WLOJF+yaxlQN6HjfLSTciop0GuhAo+++ZNuQtxL18pQ+btJTk5zrDO3udhJLCe7SS7U6QwL6+AXHbUnzzVleE1epia1EVffOeglw8DEUW/BYWFKJtekPt8fHv9DGHeCsjARKsi4YgvwVPONH9IMSf87jaWHYjDVdQFxiLBOyTzgI67TdrRSrdgEQw1cw+v4XfwEfj9Q78YhNW+w9YeJxPI1XsbCPM7VM2Unu+n9T6Rl8kk2WtwP2rkJUqYqdq92xBkHZd9gwA+ajc78EyqXVlwTyeDDP9R6exNJZ90qnvoTeqk5G33dwQIfapCIS+ZP9Ztg3MWKyVJpPyk/6H7E+Y7TyAcFSqaAWFeB/Kx2KvbNdMB3SAZyuB1SzA8tjn9f38S+s0ZiS6harVgXpepM/AobEf8ZVTxEsUfdS8e/b2t64WjMuxT6JVpPHdwsEgcRDw+hF2LqIHmZiH0RtXzqk5FTM03MIdn/3j7kkDR6w+3FmLj3q5q0/ONetIlOxBeHYg5xr5J9+H4mIvvn7ZXPDMD3y0Oi7J245ih6nfDI3o1/OYQ3FvDteIR+jcpDjJwbUPFuKM/MM5DrQTkFvh2KnJZA1h27g2cbEPAe5y+OTuK1/OrR+u8cyoLewLdaqB2wCW9rh/oF5MwrJidJ1BSqOf+EYnc9LGgt7ibvYKhPxTODiUmJXhwr16NWFxu0UWO+LhFiYmFlTxlpU6dFVMEEMZ7SBtY3s4uyJt0I7G5GG9k2k+wdbWlMpqrN4rLNlq2VWK4K8wotLu28sIAw436KRvU5B3OTPxqWohaXCuoxjtaDsZRq+f8jtiLTLfubm8yn+5PbNmTm+B/InOJfm2kI7NNoWqFGk2yPwFUpP9fOxFsgcb4l5jKzci76NZ87s9tPt23O1PrdJ36WSfkrM7uEMR+d0fCzvloN3cpAOfuX3gz9oy959O2oD/EwUfaIpTUTi42fx18XfzRALHgOR2vGrzsHaD6Wv6uHoWjZsuPlW9qAuMESDkgG5yQeLZeXigs5YjkdNJKDQSM9PcIFVREYhwVTI3RfQgHiOC6wqflgkOUMQTa+5/+L515h9i14ViCdBGNSo+njHD1FT/RyCJWCWRGg0twClbuJBryv50p7cuibqfr/B/6xzIpM7IHObvXD6f5U6IO80T5I/X/0AeDfUmZR1+bwCxSbbUtAmvf9LFMFuP/WvzmT8yO0t8auvKUXbg3/jQ+/lPe35Z6gMhGHk3j170oj26VcP52Z4k8Uq+MNPmrugVQyk+uQveNcsLhmmsZaCviTIaMWfS8MaOIAYqtJlG/SchcYSAcxc9+DvOoOhCuikQASqykkjLWMWqSkpuXU54Szmh45xX/D6KIyVTz7mjowCkNeWiqZQTpwpBlNsheZhTdGz8ntOtrZnbhr+Xe63YjNffz3onvY1nyffLtqxohiuR5jvxcfGKYycHZBy5Z2fjnPBfrFK8MGr9Km/UtXLb8k9ItfDRu9MUFS8CpfLHq0qndIrfqQ5p1MkMixFCJ6o53dqnLUvplaDW9xTfcruQlQMZZ6TiJH+8XGYWNzp2TwbHIUFKV2YnvblpKZdEeKSMe/77e4ZikYmPmBj5pKZr7TeRMnYSFFpOL/5beazgpM/Y3U3zk+8E3mEU9TO5RyxnKjZRfthZYg4Q4WHfQd5D+RbanHdrzVy6nIzOkdml41d7BXwxBrZsd7qX/7Ae8xwei8bmFepcX1uVeu8/YPghR3I6Cuv5FCZrEdY3Be+h9wKrryWUEp5RKUd5tEpeL730Ae/Co3gbuYe9PXqYrfBXx5Lz+7MrP5oCvmB6+lUzNnBkj60RJq7pt8A/8Gf3vlL47fXvnesnkwvl6UaPnE4z3V5Wp7cHy1OxtvH3NBDZchahgmyHFnu4nlgewvu2kLEU97SN/HnrXZtH9Dtl0842HFbew/uhRenFuptdKBTfI7NfcjYR4PsmMtLd4PsnhhYGY2Xb/Ab8te6M/K1gXQ3oBTwwVZqsBXKOrYGr6WLxQ59j5fDf8SDzQsvB2cTXNZ+jbb4icqbfP9jTEZ6iBFsW1aIxnUTB/PhwRWZGmSleQ7zjfz3wqzsulAociyXYJVfqPYdsGSfR7eaPafsm+hs/BPa/3C1GwoiWEDVtc82ZLeQeHJ7DkBgEVTUdIm+yqC0eTbz2/QTGpFawkp7ffydtlHA0gEe0t4Yl4t2+ObNNLAc8FovgFmpLJm8vLNmHtHPuB/LmCeGdIl2QvutU4FR7HB6ILLQnk2hxjQWV1QKyvbseEfFFZkMwCtnZ3M24RHsqv6Zx15ovKRLNpfKBrZfqFQdLL0XIuwOXtxf+GRSvhfcqQCMNmJ/ZL1ZJAw2gv4fpejvLeAwd7CvikUPawK5s8PJIybh15WLaqDZvQ0PKz5PfltCczQCsx/HsYUsysz5DSY4uHhW+OvDScJFdkAbyziaIZ/atuG7Fz/A9nT/Wuzs/1YxwtSAcwoZl51MBreNfSfpf9iuADesfRo+LmhW2Nahtt44fLm7M6z7uzY85XZbTJ/+ueFMehPw1j7bwG//i58B7QehV8b/ObxE5ZRsgfdxf2nD4/Ra+1Vslt1EKkWfRCa+XsBml9BWDTcAO2l67Bmpd47hs08xtwrf70st5WuqxG4vARuh4uuqHVozpxyBe7e4TrlonKJaYczcDee41KVME5VSYGTmo8SMD2bLot1497m1Nsprhp+OyD1DpTgIR0D6Yhlh7yPXzYar8h8SyYTI8PP7SrLMvm1bdYsi39t1h3+UHj74JjMO6PriSyt/+msOP+GrL7AOo3ot/d73AWijkntItbuAGX8t0Cs3wamGWlLIoR0BSYaWcu4LkbU0HTWeD+bleCnsloDpH+n2y4yBHdNEiQqm2R9GuBOKKHTSUhQ3m4j3wvrNB/77SJHcDehW75TwQFm/hSlJqvajUDbstQpOj9G3Vb2AirfpWUn0xdQX84/kcHjqWETz4rTQWPvbzdBHlZcJtsM+D6ANmKnD/QIEurXGbf7GRexzm5nX0yC8Wn1g6YvvjDA8qEwNah2ZbhYMWFAw6c1h8IDEbVrIZ89KR/iHh/O2JjhfUXKsaFOGSPuGsoDDTWfp0TvMPpOtDrTvaFwVwS1dbUTT41PnNYmkPSJ0/4tTJwWFBT5ayJIqr8dIBn0BeWGOp7x/Qi+w+1oKz/XlgPSsxEgKBugbJjC4EPf4W6A2wbweCNjMrr7BAW1E0i5YqAgTc3f8CMl/V6asXGF98rGnY4pvnc3vgLlkdRPDZyPpGPsUcmW+o2gaaJ5yjQuqCG0+D1wx7/70FcRlsmgtD1IMjVNOGOq20ktBVx3gqSEG2SfxSr+Xm/hDYrF8i5EKdv4jIG2dJC7WjTXW2WfxUs1fB1/QDLu3cunNJPp+bI1T5Ix4NcDzm+0k3RT83L5vsz56DUBZv021r0cOFw0HIheEVZOxrfDUW0G5R+XwQUUS9Vay4IfUXno2+hfQkEaHSAzpEBAUHwQXW6j8u5Iftehlqi4LtBEc93/AuqJ41cXpABm1dC+c4DBo4P9ou6E4jVwPJ/EOwCXsWO4nKOcGNe/WK+JOxcKRwfGwl+GvsYTQjvh+Z2g31jQjKcqsXcuoM32md9cuCro0FZnFHvxXahrOvbqHLTvFIl+L5zrjsmpTznmyPDl8jdSVk9W9TJcUVFMQF+4YWPDhjpHzPkinszqDVxN/VaYIFGxlETFfy/g6XzkHyTj2oV/CYt4qKPJ1awV/yURUQehID9fCIXfHXjAodgu0J1A+p0mBQVilIDC1fwVLyV2RfN49fWup8nU8gpijWt/Xyq01Wu4VsrEBpMIEcdLc3qMqgyfis/P+8jxXcAGdNwWzQCqVfF4xwNHCFoFWtTOAF7mt46EH4/O2DjkPbzxfYcmgHbadkXf3WjdeCkFKb1342uOaYG5qTmgO+H4KR4iGeMuvDKKv+fhGQqvGWBdDzgw5yPRSwJbODcl3ktmfdth3fjOhmmF7zvO+d/ZuC7t0AbQsawp7hswcq4Im2FW/ofMDZD6c8Z6BtrMbAx5R8LTo10bzRv3OvT+ho0vS7m61JRPu0G7MMNIMt6bQpnlO+0jeBoQ+8QW7RLwOQM07U7BwLcL9MYsL7aPbsX7bjt9yB9x7Y8+qIWxSiRqJYZfRPumHWP+1WwntDMiAWzbes0NyJeh3L/PEIEa3E0vyeFqyJ3Sih7JXk9NqaTyHN4sGHMGSHkCyqI7lBEMLV2otX4XUMoogjIuXwA9XVwF2Lvmp/gs2U7BH0bsPV1uYdT7agzo+6ihrrDh/VkijvvgPzVr1S2adZXMcSjQjpHrTJew7S+OZPI5EBINWwZVst3Qt0aAOx4FfmI66YqGaZ/il/xrF8L0DIxwxt8As0qDM/8E8ED5Vr7ox/MYGphjYjcWeGNfbFepzqnk2QbnJJx90I7jW4so7sAiZd6xeR0upmSNZNYVSGZCyXNS/iJipOMSWYZvbGZYnVEvVpWyvlSas+lFN75RLLzZ4a2e0DZiVbevJ0wrZYO8xiuC0YjrS3qYbyg+1n9BYzm3X7Pct56r5yhjrPM+X6wT78nvbzzYnBqHZUfjoUQtZ0vRwDOGtdXBs56jbRc09Ln1nNpP2fCevA59feGaGfxsTUyFtqI+JS6wjyTZkmbvNCQU3i2x96+W2JmvOBi/6ixlMfC2E687Qmcj6PUqNyzgeeO4CqaiweHhH2qnFlLBJA0JJqnvkdJX/VhKJ6U9O+OoOZreuBh1bxx9dPD6ddUx9FiQz/+ZP8uvktgFzKCqobRHX1zf+E4vE/tvidjWF5b2WEqqi+obQQZc8N2ZH0txNmszO/83Dj2fcfa0pLMjzzwI1DO5nRipObP5nfw9EmuNddGFurh9je/20rQey1jRDGUsgTKuQRnpRnXvTiarmV3wO0cKr5XLQT4o/TrVxc4n1jMBauGXQqKLXUCyRHjvBbxcAxrUlqjQAzWxeWlXgTTViH3O5OafoNLftTsneUiMOGHgZDd1d5+QL9tLkkpjK+iKOtBpGN7D7+I/Ahn7Vb5N0rnPSzpnm8TZ2iSWfJTcACkom3x3JJikUvXuHI/WcJ8sSjjLBZOYmGASxfT+QkP1vqD2OrRnyQy68ycSuyj1GFuGMBdAe68I0DPv4IyR5H8X6kBrx/dK7PEOkPZjB7VmR+FFvrQncVlp0b7GEkjPtP1dYj3snH8KHXyPQC08JyinZ0p7TIbpFXZXg2tp4S7+52nvOPLao+HtUWJR8wAbncwXFM1qN1UAH2Uyeq5UMr3VccliPEX31tAZ/k+CuvHoD8vgqrHv5T2N9p4YskxiY9fAr7zIGBk/kHQWfV2h5kb8J9KoRUZ+Tlk0/NiIYtOfsq0nnwnK3ZYvBAd/QWDnQ95Uh8ROea1ooO0y8GY8taWqmMgn2RgXlcMMUuWT415x1DfaoW+vd/zF2+A64NC1O12Iz2lRcwWdwwbjKA2/j8TZguH35BtMc0cW8mzv8ww15ydlU8uQhyeIDIMzJPIuGA8LDMV3ARTR8F+jav493TT/hNKFrvuaKWM0PDRCWex9j5tPdrM5uLKVjxYhpvfC7GKSORYb9SjPEZ5/VBfjN7oymk3ySdfwCCheTpa/Iig+dvNB3q2U6UQsXbfyjaO/umqI1ezNcMW9NHFfGr/M++OSVBdIu+Y6+3Yn+t8iFqszuY5kHfeZReIA6cSSvO99n8VpcXZKD3hWlOT2cMzEwMQ6R1/8k3qnod7SfDqkJ6hhPv9CVv1XkuGlVND1GSarTu9cxpvktYLObsPDZHRFKiT+Y9jpnVhHWfTOrHr0YPfgC7eXZNUxoEHrnd8KtHG6SIq+7J78MPDGkb+G9DFTXpk5zuBb3u/Rfym59+LZqyStwZdWe4xP+Q2ZNc+fAvrIO8Mp9auOpdXFZ5gjZCih82TQSNERKrirMbagvOz1oI65YN/X+Gm3egboiLHa3t3a+V2vNpaVnQzqRtMt6dEXNJRNiewJXSwjcnrzhlKRib0i1DWmxm0oayhLq8e3b8osG/qENKjz8eG0+viMdh+GlpdtKOvwNZTheQij7R/Am7cCzj3wA0Gg6qtZiRzq8qgd3sUfCrJalNTC/ljQUy1lZCYRX/S81ZdbZDXoa08G5zCnQ9ofJdZi+K88y8WqNQX9dv2X3SkPv9UXnZNaSyy31RLz2yWd3SlUSNQM1DegBh8SP4zg7dR4wHBJZP9o2NEIrvcpeO+XXpZDkUeExKtSPK+GZ+nwS3LoDh5lxJAYM7zMuxaemRFczwqJ4SGuGeE+HpwY/0Db7uVU798o6E9LoJtA7bphkrHej/HEklCbWH9/6qbJ6toi32fQMhogJZYVPnUtXYs68vJ2df2Xkv3o+kK0LMvVaurRrvCbHpX1Ux+7QAPfDUGa+buPTKWmMhDzhgfvivz6pfk7Xu/LKdC59LXR8P6h2CBNneyl9I8Ind2JOQcMKogzWg37W3wtQTvDRZiQqi9xWQtIrn/xGSOcaCjYbw+JjQNvBKUnAYcUtSgVZO77BcryRyFh71sCXd/QGwuw/g00bA7g0tU2QlxMLXpi3dDJ1lK1Kfydy4kl1mngWRPONr91TMb7NMzazmUlxDvZaYA5PX2YLzE4qfrx1mqe9FHV2HcjngNXDc9hy391dfxzv7qa8ty2zgXFsXjSBj2jXCXPlfZYJ/Sof3VV+9ydrbPlXujsHg9YbR34sttAqcR4FVpAm31nXpcC0fpCgCcXZDeeqgVebm4UiOVP8BMFaiqxaGpjXsE5EmFOhNEWV/um3JJ++FfacV1YTijja0KvJqa1s1tL/VOmkd9BbVoKbc09quPmkpnXAhAHkBgopCmEZFEX2q37UDgSIp6ygs3lb//izOLBZ36/Sl94dvGx087dGb/8y9jTV7D53Qcy1Ke1hEiLlwHvwTGAY0EH70Q86gE8q14tqbsTWkczvaeYm61eJ7d6ZgKxYG1oE/VXHmL9OJAgc4nfeBQusqdEoeamQeQ5uz2UHPsLDwtPeydQYu44GB07R1PZ5DLZA9g67A07j9iGdknYxpBoHHi2hJj7xIeibwRXAX2kUZNqO7vTHiYzywLEvKUEsdQn/iiKYwGx9KWMlVcG0Uqff3sOrwmSAkwTEh+Vwz7dfkDua8NzeoDnZN9vqo8Hx8eT0L7q+0qY3r/JvY6U9aur9HOevqRqGfqQrtou/nE7Ma8tWf3dbbHQ/xKOsBD6yzwwS/ZcVbV9tiUmSGl3gbQCXCP22W+uadStSv99LGHrKAv2XjmugXEPCl9KeUepA88Li6HWz5g13TQVI+Nppwf5AVrwD4l/H8BW9YmXR/CeI7T94S/kGV1pT8Fg0t4Q6DyYXsHCmZGkelsuYkErUQtu8pXxg8ZjBwCr2OoPZN9DWFYnQIDz0bFIoIjy2X6AHv0OEMvEul8qLWGUWWBxf/e7LRJ5/dtL2C/EqF/eJ9aN3KyjIyJj3HOoN4Y54HB3EnPsaA8vlogZ4deUKHDfLgEP5hDKOgHpT6Y7Ii4mJN1OSBr8kuDXtVjhbkbpy+4kCvs9plelXckrZXwW8QBeDka5oI272f67RlQStftHRVhbBlBHE9SIeQ0P94n8LbC+IMO6A+g1CVryDrRkzi2x90ZwReu7wymgmdis2mA0p6q/4sg+vDNmfqOkT/xXFGH/UF4lW9zfdhhxee6yvAporINeCyJtPPxlN0t9AXCx8pzaJ34UDYkbIyp4WxnFtH3isehYnaqgTd0nhoah1zZRvwcMqv/LgXFzA31ij7wqqPS/4eGQmBFZ24whCqwDAwhr2pGrmqrryUcA4hnzsgDiXE3g1aIJAZtljBpLeNDAclLcauH/TgdfC3X8V9C+Cmgf2lEjco0h8XMo/zU/fkPtFuGyQqNdHk09BaPilOc2+dvr0dczfbl27vedEueh65lCulYN/5RRDTPCwxG06sHmquX1/HGd8gp+Z0ERXXfQV8CfSaH3qesO9jLc2RR1LVff4lXqOOZ52KvYqJszaIJ5EM8UKt6F1w/M4Ln686mMvD82bZDlUR7Li+hAYlHxWBPJImLydtyHvG0QIVXxJPRrj+H3JBtPkSbXt4T0dHGzrXSK/XYvXU/lIrRUrrqWmq6rR+9Q1gpV7w7GUBENzx4AOYVR1+kL9TArbPG3BHU0m/VIZ0swjqHrUgoR9pTC/YXqfTTkZDuNso2k+yOsbIGe7cyQv38EkCOP/LFfuet0N2B1FWjjWtCr6yIx9Tg7o/1LIn5abZNDfx1BbqnmKzs09bT1Z51LuhLrW4JzyUr5bkfX6FjBMSNWUfU/nczVH3f4fKD4/XYgRVf/Z996w1epulqq/gMfmU6sJ3yd3SAnGht6aeAdFDdTUHoq5ndzBO7V9QKZvh1+O2AW2iXU+elgGrNXSOEjAvK+2TIEszqperaWrV/frJL19MURild6A1fPFoer34ur/4Lf3MOgD2MOU9RIZNbi/v9+7wP5rPrRItqPGtrPJezRZ6VT35Kps/hLAtLeLL7sW6XPBzxYi5yj08bjycQPBkDfyC71u2EGLxjIASlew6tBjkcpXgx/MUKZ8PTjWwNH+S9Bn1DzCn4/lpbw9F4StGnw64A0m1fvRZj2S8xka4ADmpw0QFmYMq6+oGw7fwF0SWJ9IKB4jn1BYvhVPKaZLnEA1bqABmTtewKGOr/m7nPzsh/xY89SnfTvZ99O1YOUoZ3ifgEleeG/fLm8Fff9zX/wzQa9bS1I8DH7sKTLUkwdV3/KuZ03VMS9mpTL9Hpobp+2AmSV8eN7t9Mx+9CGkxb0KtRy9hSCVpf6bi9FgRa2YlcjaD2pMa8+XiS2ca++6lC13QU633rvF5KOvCFg+rLCm+muClT+99CPBwQ1QK1qTwfoE48b6gKaKeeI9Y+dylnJcQOZsr0dXEmjO+oDEc2rrfOyXwlQ9VQdtmieRe9G7jdP5n7r/VSu3p0kUHUEfdBp2c552d1+ClpfLbB1wLO2Is+vc8z2a+XSZw8cLQINUtRSdl4diIYzBzwwfqF/Xs8WomHzgNakaEaToG9DAvb4F3K/jYS/iWKfQYnPsXVKmapOZZRoBlj+OwFpS2nBuxK2YCR8BDT+P3VQgUHNH8/dyq8/Poz8+qUiVWC2Bfkf8sFjl/fxtcJXUt7eaHhHM2pCM/bivPbzP8UEOSYafrpZU0dlVYV739P9XnUZx1+jTPtHOrdf/jfoB8o+n1TA/a5atsS9n09rVvyjSzse5LhB1c8y+WXoeyqj3w/ycjCap+rlNA9wvQJt1TVp/fs4aj7jinOBhlpCsnAN4kaH7gRdGFfJVBKJKqFgztanEOuNjhDot2hVUsNPxj3WDMSO9gKWrGrP5PPlOrTtC3nUWPE90jEW2t8+A3CqnMJX878EKElto0YXaNCMD0yfYvBR0z8MquPVvWxsRhs7qN14oSi2TTkDT08PCgt4M6+sQ/8xqu9q4xO7DvayMUugVaQe4YjrRMshaNHovESMp+H3Obyf5vminrMNhW1Cac86DvA/58OgJp4d5FzsoOrBmf4Pgxnxq86X9lyIYQdjBkp7ljMUSHAkR90bQzUakBJqop+DbE/XMnvp/aR+Cc/1xtCcIRreGqVfJfUentqfxVcYMlKi4SdhzlwC0DD70Ueeh198PBctkxlz0D6TrY3/E9LZUWI5WHRPG10Lo7DeLmOQrp/VERfwNQOFv5oq59DKOah6SyEF2sbrhd8KWTzzG7+MgyUyfaZH/zn6RUFtk6JXhJhAuNnqwrZnObHlfwLsUBb6wMEiYxsj1yZ7MkuF+mqZeuHC082IqywXYsrqpA98MYph5EXXR76SvzJlfH8/ck3A/mCOny3y9c89cj9/W5dSN6b9aiS+661elsO0Sk9ooSe+D1jllmTJLSniDzu+g174N4youlSYT2PXFR30rePRjssC/mAvTWGbPhyBcUUnpv6pV6U65MjwZY3GH4J4hOPQSEOR+vzxwf4gqTfLWDg/8paj6sbVw4d6Veqmwf7Ivy4/2TSOp/ZO5E968VxQ0gBVb6icmaEPgN5TS6Xj3g2e/5wsveY9GiSl484Hw23DZnnNmtjRD4U1g/VhWlzbvuG3O/oFktF3IRj+TE61GVL1ClVyHUm86xjW8Y2Ep7yImCmpJ2sg5dFh3KPDPS9csyXpwIcPzeYNlURcKrm8DHAxdlCdS+W85qD2aaH+/aP1R/PIzEt+qt7q/FpI4y8KLN8puKGmONf+ZkulzWoOlFcy4lfMWisbpNSTAjSvM71eiSe1PvDSeTrjDKf7hC4jJoBppR/ShgJ0XlDYMdlg/f48rml/J2iN3UIezxkvC9pMbUd2xpTO7NnVjrT214M2hjLSXrxXnJ6Z1IHfMdbQeWeGupMK/pjZ4WAhzT3Md4I9Q9U5F/LQ8H07c0lAWxvf4LguaDz2Vw3D39FKzaeyGIlKnXF+SQ819Xea9xpn++n5TJZFotdPOn+fpqhHtSLFVyCxf0uakiRrDct64tQP43mwXna8Jiup7Rtus6hRqwdpR57dUshk7ZRTs1AufR5LoefT3mQ32mU+DHLD6W7yMDf/G4HJ8rddE6isljZRqHHomqhemuHaHJNfdZCA7kQC8DFaokrDQrXhTMpZx3W/HvcP4CcJtEvx3WO0RvwxC1hr+DyugSs3com4ViqbnFEI+Rfrmxk3nu5Hrzw3BLrylw6GJ0GK0H6SFQ7oeTz955gMJS2G1LGGFHsj1wxcM+BeijubaEnuodQkwIzJi7LBVzBD3PDbgFPK54rFdImyacSiEZbXeTN5kCEGcedUW2xr+rmJpJcb1usSpdxVzzvYC/el7XHc6FQtU3VRnfdOBvh7W5i1LtsJMieBu7cwgWNApr43TdtsSHEvjeUlQdfE8FQhWglKqbxPDtedsMAsJDaR9DcdVIBYErvU9/8xWKZKnjnu/reCZZpcfr/vjyBfJmfv9xkXrU+lA1QemXUlYODFEzBjFBZOfgnzGTVdST+0Fr6B4nQQTxdS8xi+1qHxQ0wp0EIJmREO1Mr9gF8DgrKLAaM6SuVbDA0OA0+dIUa2i6485GBAS7geyD8hyTsquJP822h2pZr/rdcImgVaQWZ5pzca3hM96tCczRmVrN6P6rxU3lUBx54k7yWiVzMWeMFUfgY/AbAe8Npl3glYD2RWzuKpOfPkkFS5H3Bvchaf7b3DyXQlepNcZMY38p1vsToO5E082xQu/Uq69MYj+F+NHlkmQwt0lbiScNpDZjIdaM9PPlGTwfqNbiqHWkTlfS+sqdwAsgkd+1N/dtty61P++DaH9ad+ddtUkCoPeZZY7/QT4/6uAmuZf5l1IHDMVda1BmJe9mjaVlq3+VdZrwW8rlUlq4t/3nUvhO/xlFkvB45VqK0XO1biCrBtvtz+4bB18Gddj1jXQ/kuayaU/4D1Dv+DVn8g5HLwV4WN1oX+TdbPofyw4Lbe7de0PWpd4X/MejKgtVjclPGeri2Q9xnrbf4nrX8O2IAaq6W5xQzvF7Cu9zryik8LuRWx1oMd66DOT+X3Nzuyi08IT1Y8YK4d7AvSgwm5TNcTFQ9Y9g2GQlnFx4SQa1A45oozX5NT7+5wV1C1Yvi3EZjp0Ea/CWgpvDMSchmLmcLX5JRj5bwFOajcDuFJ1wXB60ouSS6OzWzz6aGd2NrhcFOENrKFM1PW8XcIua7TQozlNYAjoZjpe+TJp4WpllcEMvNTn9ENcwnJA73ksZ0JnGlmApe+KIHbD+MDbZNdguf78LtQlMB9Bb/nzyVw/4LnJfi5IHxoWC+fF7dXnOtmTKTvETcRDw686TLgLTeL07XQTA8yjNEF/0Sx/SQV7OK/kuKq7yghmW7gCI/5qYxHOvEsz/xSkkl1JldmNlMmWTrR5TuT3RMr58/KDFA5C13ElNSF6ajZGIdv90om+4xmYl7oTHGjb7nELlPlzMwbMAqhhBlX/VMrycxv/ZR3oXP+TOD6JVTeJOdC5+Jpyi7F4mnnhEx5F/+9YdyrLKicb2X8VN5Cp7ryqoAz/4OVty1flzbHi/v2cThLGxc4ReFeyWy/2/uyRE5+FJwZr/LTuXKcbZHzGwFXMRc4Y0qoymQ5/eegk6e48R4esTEli80pzkPCzkXEWAO/Qi0xoj8O9NPhblLzNUftx6g/0eLjQyxvOE794FMxPRAMrxlKXKYR80YSSkgG5zPIp48oM+pw4yF8xUgG+qYdpMyzeQ6+C0eC4WVDRp5DP1/pwbA0IO+y510XktLDwnfQd+jbthueU9DuZzPwlKO6E+iPhP6Ti6dqOXFmhGSELtD7dzqC5+kSpq7OcdpH2XqF6ANfTtI0ubxc8dHBvhA9qCektrT/2SfXFlB7icnFc6IuMnoCw2d3xBPFrmQwvHSINOtOBMPH5PsG1/2rTdSya2HHiAgwBMONHzEuYrY053gTnIhB99IUPtV1Q6CcYUE57zAOJOFEr/7Fdg13LhjeO7aHnm+XeY+OHwrvjN7Bvyzl2hjvg82WjcR6lx81ksclkGG4xaCrD4Vro4JALWhvxBMqIDUuqpXybGqYoy4K69Le3JBaie/UIr3/XLc2p9bRf9a0ccNGo+uulEOOT7u1CRPOZPGzeVpsAN1/ejvxqwvxZMUfezUc6rt/9+GNVrwnjOcs/irQ4q8hnb79O//FjUzhxQ1k5tnAZQFLgLEgVg+gJvBvKGNmCpkZCpwXbj2lgbAuigZBv2JceE5yD8g46E+FBU6wW1K4gg3en5H+0Nf45MbJ9r5HE6hBxry5/0Z5WiHd+wdaV+g+wfClN5gnamGG53i9v/SGBt4T4UnBc2ogFN4fwVMYk0Ea65ZunsIYDKsjfUJsJWVVBUrw3z/uLG3VoFUftltY7vJUUmJs5GuhxGVwUeKeCDFeQvudbLugEcs/1IhlHyJ9UkaNuOWHt80fyndcXDsqxqHfy2ajK5PfsXH0vDfwBL0cSx1q2bh/6VqQ8NXFKfb5XnNVS8heXh4qSjQ/jZaPaKRQH9cVHb69ybGH5RPZcfxKE564Mcp5V5qU3BrIXfy/cuOJB6tzUMD8XBNTpRdt8aoAwOTav/RkyE442YtzfhOulJ3sjrMwVY4qMpURB5kHQ8/TD4YIw/KOpz/byTyt2kAA/hbIZ6kyuh4MLWEsTzMVmbJHz/wT6AOAY5Hi/xFRKH6+pFB8af++x5HmTw/N5tHm/zg+85hiK/TbaDnAszA+xU9ZrG4LQO5h8PYDzvsekSIH3Q0bNzkv7nnHaamSbSs8TaayQY4EwxMHsc7NYqLqhqDYUtWN2h89HrU8Qy2wPK6ko2VrvWNx72Fc7lhcf0S2zdNEXC2P7F+qEw2Mxq8TufgkH1p3R9xxJwz8EMztTyq9CC1v0WS0GqvQk2WSP2nlaVmj/3d0lgul/Gg4O7qsGbmXuAa412ZVwFLlDLUA1Kg7HLvu3KwBvac+9dj1Z6sun8U6+hB2cg3+Ewna7f5oNjGKUNfuo9HwXOhdpUZ78Hx1OWB8c+h5pvxpDPsr8AJsu6VKvp//NHpUFU8ANZiYiv1LI8bvw49FiTlBWVEaGXtrHlnRt8r2fdgZLe1vfaK0n34cQw+PoISiribT3l6Z7eL7PROfNhH55M0bI08rKxYjuOYcV53D2/syEzDk5RGjS32oYBN+o05nF4c9Sk/SPrzji3DiWpOnL+j5CWFay6vwXGD500oaIn7naQntYOKspK+imjLTESa0pC+J1juIWFZNzKcUTxhQB32I2XTKhDdnSUYN6DT2vha5/rux/leYR9SHMESJr+qvPKKu1/c7S+3iR57UuPKdarlPHhxRYisgVumZk5vt4mGPpWrDHqV3EtnP5Roz5VYxmz43jZVYekRTb65Kji0LvQCjaUMV9+qp0A56gqYlxNjtwV97Ulmmf6u+oCehgMpdF9vOxpg+7Y7LWa/dKaXrCnpOrUGf6l/vbNgQU6ePLei5K9dcVR5isaQ9vzAlskb5ZOwvTIqNGaXGiUeMLkbuxcJl34d3j1j2cNbxfs68Sk7VNqw8L46mjh7mLJadRhdnbqmogHFodKWZdgAtb9jz9Gj5vmGlD78YzXH5MGLxySUY5h0eezsux672G10FwInOXpZ79xGkEOzdqv7gYXV9SyiWOXa9tWpcoLyKHe3jUtHDX7xsdbXLNB3t/+YwjBrVscs4Io9ett8YeoLu2UE7el564pPQKdBq6Vzsa7Sww0RI0FSO/iZAv6MaNgDGyDc7y8qrwhVHYvJ32Bs2oGfRiztjLBBj+8no2DC+oSEPmBQrGkp7th0m9W9WpWrLQwz95tPrNAtaL1a1a/LP3cTAHaMYWD7sOr7RlCWPhLzhjXLY4mHD8ZspM0dT5g2fbOZNtDwGpgzzcljWsLsZx9cY98MZC7kfC7SigZ768zCORRbC8i7jGcLZl3F85lwmPoQ5X+Y/qM88Ajin1xxwqP32PgaecX60Ac10YR00tEnhTG9LyN0wLBd6BsaBiXl0/1JRUOz5FA8rnEEnUvFGXuMHPjqM+fCMbTC864No2DA8lqcPODuzR/Eao/Vr+VUmtCKjUNFJkEym7gRtFfg/nvyM5yfy+3lifcyvcMuJw+pgdP6pwh8XUeeL+LguS9Wr6vvPXayq04w7h/FbALb9XjKz9IIC9QpJPon5C4DuUWK96v9mzzxeGUmCv1cor/p6D476VI2XX+t7WUrfa4SnOhIzgHwZU50PjNHvRcDwN3vQR8FEf8ujY6V8HigG2l0tU+yaobG3+4dUfL5XodwPhJYKTN0jKFSSINP1e4GLe6i5Uwrr8JTXnIPCJP6Q3F5s5US+TraC/foQtHVeoPBOaOuP+PFyf7iGSEZl4GLV/tH2Dg0p7V0vt1cMn4v+/9uLrU3WHFVa6/l6j9JeToqG54y292LVOs241v/d6sQAsxHLSupy8Ev61srtvDA49nZpEHNf9DcLzGNjNR4LIP1xQH8Xq9Zrxp9TZqaX8JxrxluA1wylBhkPe4SbpR75odRmudRv/C/KWPoV6P4a/vmj+cZxvFqMHQG5vJlMzeDRDyPe7AUMqEfCSVFK9st0Lbxx0MhPdQKOBqEngDa7noYncDG7F+W1xdHNYrzKCCX9Y7hDMLoMywseNcv8SpnhTPJshimzonO8E4L6+CuBMQpewI8v1oF8PRT+YtDCE3PscpDTxeNR1eQ/X0C434QaGSjlvwX8csot/legTagup7h0kDc4+NEZVICI9AfK+fnS/jNP0CbVMiL+F2j2bDt6W+TsYvjjZrT/99EZHVcIeUAar/ZLfyfLXS01f/OgPRaQ2Zb6pddttdJRG7GiP5AqIttJXCp78jKOxXoJk/Gyjxgp2YYi46p34Zms/UtxVeIzTwZgoRxHtTOjOVe2YoWebmfwaFccLbjb+9S2akdqxSb/xA7v9eqqBcApVBBihyelq3YkBXCPsM5zvibBk7xrtWf9rrMexlLrSe2y36BWVTsm+NUd9j4N5HgIeQvRQTgN4eP89hsMPPsh/7P+Wul9m95JdbVIJ42yP6Yst3+N9OcpCc5Xa17y1D9T+3hIIFkP+RNqzntW1yRXn6lZV90jyPYYZVuQx6R99mPSXl16Y0zjHoe2A98hzBbTmNr4t5RPGjHNPwQIgdC99mMDL0MMpE1dnyL+RylPQCnu0VJUHfgOYZC2HfI+Ae9uyLtFztv1H/kgHOKVfNyF0bSjtVMLPhZGS/ohN9asSFs1gse1F3pQ76VM18I1Pug5k8d1LbzDJ6/hFMg+XWoUSxl+6RzwtceiL0tN0OMVAaTic1KXbYEXPbzkFp+D+NOmvvD6yE8jNVIN5MgY9QL/rGvBLp1r4q73pb3G9wde1u1rNBTeSFmTVt/458bdjoM+YtnJvw/YiWl8t5eodjvea5wQSGz8A6T+P3y9e0BUZfo4/p4zV2CQQdQQEIc5iAPjZRQ10y444OutFi+1H29tA6O7Z0A21ErUNgfREt0tCiuV2iyqtWyLgazINSytbLt8Zry0yNSGkh1hEs94O2cYYH7Pcwas/X4+n98fDDPnvNfned7n8r7P+zzDPSZYT+mRQ/bxp+YC1d8euk2RWe+DdDitxGXx+v4hHLILJ6HthdjGeIDCX+wHW+C3EX9H/2qMp+U9xjSZWfGXe5elwRgWVjem0Dfs77bEUdD0hTsqMdr68wJq1O0xPmF8CaOXD23jh7h+iXHnCcWW3xL8Y0K89/lmG8imdqZXapFvrcTxuAZycclHdsuNNmbmNvi8LkSzjxX1i8KQd8khPH24LzLoz2w8BOuD/BInbpmnBuDKNTOcG/5HpLzIYMw4+G2UBdxRU7BRZcwitY8r+DjhZp77QNbWNAcdCdNbCkVHDPp8nJZby0c3PcbbeCi9k6lT8okBfMuPviuvMyX0/Ll3aGN8yu7Zf29M9sFTIz6NaRza+LQ9yxuF98P9D/Ts7NkJ9cYcJqYXZWJTYnEq+3VvzP7xLNRY+MqD4xsX38/IjBXrvxt6aCEzeWjjs/ZX4VdrC3w2fCqcll8wkYxnSjDWrU9QB1tJr7RC3i17TMyMbfhpvu6+tWjyWjz9mESHuvKgHLH81fupYulu4/W/gj7UBnjrsLaNyYXatijE3wvFAtQG7+iuaSk/ssyDkG2Qy00NsHqGwirAXNoR6XctyIFwl3SpZ5FHz+s9WjE+zPG4I+jnB+1Q4yFcD2p60AMrQW4wXpb6+k7Lx4mKXwF89bR84ua3r+Abahkr+OQ5GG0BR/zLePHmw2XpByVbx5kIRlQrhxEDXGw46lx+hYsDacBkDPaL+xvb+HhKxv3GG7XcJpt6pM9k6Ns4yYN33rBXjNt+3HZa9hqzPTyPe734xGvLAnq06fB04Ft5SmK2B0eH53GfyVMqDdM+sl/1wZP/p52vbL9EwQHo6pFunm+ORquBeUIPg6WPyyfKozPA8eNOSx4NS49EZvEku8OLMIlIiyMKZmYiZs4qvuPb+OPyW8YFMKcXHG6al4Hj7e+F0RJi+ZM3b8Exx2m512jli8QtTDrPmFXcF42YdR1mSGzNIAPV0TO1dRFn+zYoSxJ/KcveLHsCWrvo3eaw8rtldWI6T+Bd9M1X8MbvVV/f88gP8p792xzq6w0bPHiCEpeXEYXP+73lDrxB9bqsb9AWrecRUsdkw/5u3w8y36C+vuORQtEY68iIznA/lNY3YTko04C5ZnYO0KUNoPFh/y+UGc0Ho5/2m9ntYOOudKV58FbE/jm4244e3g+KceoagfkDoz/nYvT3lzJ6vKcxnOppCnUBPyLizB6Oz6GpvEvJyY27FoPx8huUrIdDqMqHGgjiIiK91k8mSF5mwlwf5pm5qJtJEynSbEQ6BZrBbX74bnvBQcwzKTswl8/h+Xh4fgKeo3/WJBqFCGoSGfD8K9sP8t3uFxxRukKa+lg2uKM0n+pCLau8GTmdYRqT+5EduR3e/NgG6wWpflWvR9E/lvX/XdmPeFPAeUb3fG/ZuGjjM7LWvZ1/Rla111Sckb2OOV3MWN/GuV2MJbEir2vIuETRoUY+lSdWupdUaGeO7vnzNQ3Yx18rfqqqL/NnrL77oyCbkOXFzFLj4JNJyBM/ck/hQRcIgV4UNLILZXVqPvzV2EM+dkeKe6gpb/aBljzKcKI7d+1ZWQ0zmURxLsQS00a49ZXadk3wImODNt4NgdbahnvDk+DX1JAkkOw88Un3Az1/DlqU3GndghuebHfn8s/KDaaUcsb03wKT/ajvWcxnZa3wnZF/tr1kZ71M7kv2tT4y7kElapmvD94b8dvICDG9J1RmO5UaxPrAf9S4D2os8eXyVTI56hNM4xb6FleYZqhy7m794SIrDmXH3f5yNh2oYYdy98nvTUxxvLljn/vNjfvW6kzVQkb2NN8HQV1CLpYyPW+f6Mv3jOQ/ld8z7t3xmvyhsW7jdvkftjPyUei7Gc9U5rwHddIG2kz24RuDqDJsl989SqwHvIzpErw3DLzX+6I1X/CypnOAYRPh4fN3ZLUQzfEnFj7VkGmuotVUcwDjHz0RUiueptpavD2s4vJu7LZ9LRvdX3fqZ3zdGVulxXwFY9V0Iaz6OE2z4tH2hUzyLDRBkTl5N3ZMvo2q3+6XikMJ3wCFa453TttwvHP6hm1yU0PCpwnfJHz63EUV2Q5/QelSX+E1e/6r8ns2PdjL/7AVXhux/lV5tw3W//rj8h743eN8VX4Ifv9xff0fhi04DnrL8c6xU4bCtx0zl9PEea/KH+x/Vf6wfJus2r9N/vOu43LNAh7W+M99GZQH+t7To0nX+tU3dkwxwdPakIa+KmDm5J8it9OXhEdBX14Ff/dSjIGzjY+Zt1tuMm1v0FBs4599qLF/G7LA95oQ1voyEs2xjuXLDxmo2mIFPBNxeIZq1Ggy/B68Zfb3EOFGWywto00j6R77sO/yCGs72qjiTOXOcm27ilObFpTHcPryXeUnysuPxNzzoxBzz3n4axfUgXy2e+Vz5b5yJvecovN14/4B9IW+MF/A/wbU7+eWz/kG/jMW46HhXtUp1pIBVJHQruF0Jn35gvIlLqe4RbWrXMV9WZ7Hxa0l3IK1sdyutcYjOk6TGVd+d/lJ185y1vzP8jxz7Fpinr92x9pkelkYfPuM60R5sbiF3XnzPWPeufaSsquPEjnqYUwy9ErMETfHmgvFmCH7y5kMMlSd1bF2WDAmoVDsUW2TSXtxeXu5eW3R2tfXcuvKva+v2ybHtJfyHeuAVxsIpzFljt0mDz+K/tyFotaw/6GfHt4mpxxtf2SbnO7m1hetf2X9+fUZDzkfEh7iHn754bGPFD8ydkPRhgf5bXIGKRR1hoQCAejKdPRB1zaZc/9B3KLbJpvLC8VYfR60nAlUMca2Tc5yb5PHtm+TLY4/Qs0c25CCbXK2Y5tsNW2Tx8G78VBmAvxNhD/b0W3yJNIN7U124G2+bfIUaGUqvJlm3CbfCm+nkwPwdobJAVbUNvk2+JsJJW6HEncY7zQhl1fiClO02P5n1ilRGi5H8xgQDm8Os/PYuZelax+SlnbE7Ryw+Vy1G5nc2rXYisujcoGlaootn1vetpEVGcBKCj/fUbdjl5L5EzOZgnW1ZK9d4zND2To+SYmvg/aTkiHMVb8Rz0/q1+Y3d2xcodOc2c9rRL4faXl1f/ROcxpVuYbTto0ndQlnUvg37QlnLSO32g2n9uyo49VhckUTJrZu6Zsek7JvbSBhoMwUIoPeF62JdYbQ+LPZI3faY0/tVWoxV2xUE2YmdSv5b8sHooLheDo24m5Tx9r6jdZmHItZGctoZSzIjyKYc9Q0JJp1VHo5rKYXPS/KFttRmbgRjsfWPuG20scdcYptHZbSetG21iu2dbysSWfbsD2pD+8WIi6QS8mCBeBqmIN7+Ia7RamtdzDOlsFrGnVZOon3LNsuS3f2Yqy16UfGVBETzjKW4H3Cmug9oVkpd3MVrNWNWYyp2ltUXuzuk56KtBfPoEwWaj9Z5UQcE9al66Glkb0anuW48jJ7VO4b5hGxJ4QR3VTcdMpBybSeoDCZkgzcg7OEo7G51FCDjLkw0Odb8Lf7Dsx5E5I0eL7oeVD8LzViQZQ29mIsNuM91go8p2Csw86qrMO90G+/FcYY4yvZ4aq4WBKR6pWb6pel1P7zwmUpuZ9k/hvnpfZj9ih1qzAwN9ARhuBeq5KfvMB+WWoOR0+XlrRHpNUR9HFrpOPoD/KBmh/k/e6p7VxFvDXLG2sd7/sQ5Hli6x9Sh3pnKH5VRFwH0IyDVtLm4qxUVWrbZamu/7TghDqJUDPWqvWx5nlK2ZVQttPP3HpHgb4dW2o764T3//IxU2KDkRnRT7xZ95mvOBWzt+rnEtEOdf7br/lV62uUO2ziE7/ALRdwvf4Q5mB13JxTYRj3h9SOUe3x41PBxgj1q9OZtlX2oBA7PqmFfYM1x84DG+n+5BbGjP0M6ddS3a96uQ00N8FvoXgmgu1jP9ifku9BGtdcfmg7r6UPe37m0zyreINn/xw15ncVz8mE+6yT5DY5cCWMo+GB+HmofT3bhydOlyUmHD1xmpvBzL0k1USmQvvlc3CPqlsa+SHewifBYWpy/f5HTNQ4JSJ9EXkXdKVopKfLkuMI+i7qgDPP9lbxxGr3gg7k1YrPgbTDGJonIsqOWUSbzvk/4tEHYqc8k+ccm/njncy0q3xSs4WOOSwfGQk2Qsi7rppVoikk+/yuDDpd8eXT0ktt+0G/2oz5dGEu9Y5H7MM9FpjB232XpVd6tAq1fA+SdcccASitvo+YvhVisqJxs9JoAqxnLdWK94QQJ+6IJqBOmjpO8z228BeMYjAlrt2Y28ovbcY3xzp1jmOdmgp8+1hf1FeFmfKT4lujFa0hqEmNrQRK+l1OD8aJh1rGYWCJ3xFBmF+WnH1RbqVX9wzUMiq1DK0RaZZSGs8MNbnHiixKPuDL0vwjeBKopnmey9JymatmcrlKtBgvSxs+UM7h6FF4c4/8bkhvi/MwM7lK/EasMd85q1N12jPQp4wjNeZpRP+H0ZrLoeZUiwx1E2hCq1b8RtZS3HPcp+z1hXxaGMcxl7UZn8X2wWg1Q9rzXTMdVa7NjmOuww5VSdgBo7zvaKfuPiwj9+I9+akg92NbMbMnsegVyj4fGjwLjskE/deEGQMNAG8iJsvoMU7EYTJDp3osnoP8zObL0j8Hz+KnIEW+bg97LQM2uf8jbB3gBaPdIM/1EAWu2O5l6R3oBW/6x2Wi31UVX+rxw98K1wqM9mzRKCN58T9GMjLzujDVMl3xq9WevSw9efMePeYhQW4je/FOeTQj85mW8kOP82oaB6X/6LnB/84zzfUbD3rYDlXafnCgbUM7M17tZcfHeEd5RmReEYr5pAJiDfmdDgdffmRpZqcQ7TEi7Y1YPL+0722J9gy9NJBMpkZDmQND6NedbMHXneoCjXg5tN8+0s/uITX51SpRp2KtY3zH+NSmFWtSmyZTzV6cpbpttp3swfukxnb8fxXzoLR3A025gO66QR5o4PN3ETL+SlsZjHl4SKOMWQs8QzvmnLB0zA/Clzr2zDG+jl/hSRRZRus9xvt5zLZJMkC6MnqK0tvA9AhD3i0/9EQD5tlWw0hhnLkwzlyNWBca5Gg/yVEfkSHt7IulOGaWyRmiWC9/g3HF7SXiS73q9C6/ieoaEL+4l5UkatiJvgBf2hS3F0t+gDvJ0JpFyaF9Wkii0ecccMdRfpwpsXzlDfBgrU9o85YOQMbgA91lfdw+zV7Ezzdt1I4cZn7/FNomNMy5LmgzvxWSM08LyBMNdATt85RWr9DFQ78rPHWuBUAx0ZaYmYyVac1qxowwIN3IVYHbVDygLznXEesVr4O/LD0a7hbw7c83MftW/68x+1UL8EA5KrsHY3XFBw36Z0AzqKS7QNIk0kvSwxGSRTLyYB2RvkJ6D82lTbPTlEgfsd5F389YsJiO5POAU4yRjcGHEkDP9ZFMMuZl+iY9SH87e74PbZ1b2oZ1Zaqnt9xNh7ZbwEZTu4mldF3AYfZPtSR/j/yGjP3Inu4r3YRaTuk6Mgb7q+kh4zQghYcMem1MtdBovDDGnE0x+nQtyGmmrt3PTDNObRJmMjEBFbNMVpGpFrYV425WRZhbTwrY1qM9xNLY1i1djGBUi7eF6TzYxNC78TtiRh/CP0Zu6zLFWFoq6eZNKg8z9XNZ3RAbZGKNt76AUS1irgp4HglrnK/ifwSNbxes4s2eOljJe+aoQT/plg5HBkY5BaOoAi2qrynxMIK/Wsvd0oHIr9fyj33/uZb/uyWKhyH02Qa3YjGYKlUVE615YlolySbiyMo45dfwSlUNGasC6lZv+LpTu0EjjpPV6UevPOFWvzhIa3h/iH0+wH8vp7n9a4i13KuH8vo/gDW6wfC8RkyCGvP838uZNffMfsBn+GsenUT7pAM9AT61jFjneFEq/iB7PR/C8zx4UwcQvB0oOv7N1LJJSiwsYpnij7/pu2Xx5dEeaX9vbgX7ElOrpjObx3qmg075tczUsbVZ1C8MO8DRPHnu3yfTZVDym/5blPdHZPYFMq7bhztGc9FHpJfd0+7RiB55ZDuMZU2SJ9pbdBRLe9CS6oJxTKb+NbOUN2p6HiCdqP4BqV2JdHOsl4xzX9nu7pbE/kGPn+EK5eifX6f44060hr1LmnHEc3pnzGOp/kCPtL1f/1cyYRrM+rsakhkP0Ipf9XVnQkHibrX4KKz3yf4he9ia7fYl3kFOh/Hj/9KLfev3vCoc4+M8+fyXnmHvYLupvd/Lpv1zZNs9KjqZzgONoEe6tz8aIWchzHuWjL19qcz7VcFG1eKTERZ44+rebulQL/uGDTiiCugDeGtdCb/cUVK9vLKLb3PkuFKK8qD0BqB9fduwoDFB48XaD0a6pSO9Hwokc40jBJAwqjEmSyPaw+pNIN0eA/3429Yk/Wn4s/0vHFItxg7ofN3Sff1RmGUDhyypDvBRzcbgc3rq1sQ1afZGsT9igP8Zei8Ix5pL+WPN3dLSXsxVmw36RLf0CGBBrYyQ8a6ydwpY9kaYmDBO59LMc8KwzB+E5ZnfC3EUZWeaEj+4TzovF1cv0qmo/gz2qslhgWfut6c40NI5z7d5nuGHegqvPbOOdZznT/IpnhTeLj7DpjiKqlN4RtQxbDbrs18jiy8ITLahxX4tb7H9mnvxvwWWt19TL7aLmWyrMDh/5oCB/jL/nf2D8z/TF53/qEEJAbgeAlx4lye1bLPHTAchEDMAgV3hH4UM5f7D3shVZZ5bB+aJub7iQaf4wOPxqCr8noR5fdINWU3nNjM02WwZ1SeVyPYrmUlWRcvNprYBjeLtliGZ3dLT0XFMEQUWNZQW9GX833E37ubYNwyMfdZN6cbmxPm6+PmeJOAC072DYx8PpWPbV+gmnYZ5NXVLm8OlfK6nW6oLL1eiT2WEW4XS6iSYexLM3O9K9UTrdfgRw9P7EcPbw2RcjIJhLWC4Q2CsIpStc11UYEBu4vpbkGynheGZJ9GW5V8F/hnVg1bA34KbehDo7H2/1oN+zTcNfTHKjQuGIN+cG/61HDujaChXoG2Wf0Y3DNqu9ywf0MYTfKht1Q1oW7FKLz/1/rqXEaBtoX6G+T/TwskePBuOSGdbopF10cpDv0qMD6xpiwGcfA61SWZh+9BmjXgfaKQfBKcmXPkOd/H7gENSrxskyxzvPLyZFEZeVeA7I+v3x15/6BFc0dMjNYenm9kwkWIDOs0Z+cdcYp3WpgMrZUoBnrOjR2RRRBdMJspJe8El6VDYZFKD9QZSUz23iQRNqk9l/ZRn5RFTPpUNapSXn8pG9Xbl949Vr8nDdmM/j0UU/f8JpJ5V9nrgAgzo9CiVJIGx6S1HfLdkYrmSyLOCITOkeJp0Sxt7ELfz+/D78z0ox9ATbggdBb9L4TfzRrfU3KNOj/Eze+dXf9ypWm0GKNtFhp1fSQA2f4IyaOfh7Q+weGuy7kG79y8NGMUrEyz25n7MuT6On0uZKeMc3ZI1kiluybdTYwYD/PdkWPMGcyAi/b4f96aZA73SZuAjtqbHRZZl6CdX89jp9CexqV+THu/PEm9Xcr/ow/ALpG9vWMObaJk9Ij3Yj3N4ps9C45WT2ahPGPr4dkudYVHAnQ0R1tJRsEHnxhITRZsRZrm0ScOPaRpc7cm+fN6vGw5r47CnruSghxmQeEbQ2ZC2nwlhLw/0dUst4agVF9vermRe2B4y8bD+lfeFfaihxWQFlFyWsG4zQXuuGdSdu6WPQ1M9EyqyPJPmWQDvXf2tzbYFo3gmi4y95MkzAT9XpN0iL8YF1DZZq9lca6XG8anDyaMfoBMgeDyEWqp4ZOKEmT7mQLe0uAej3A8b0y29H+qW1oahR8clgX1R81IWPS0Mzm6ET+MI8Kqm5SVXPDnVzOScyhUlLL1tYI6n2qzVzExr5Ww7zuFSL/ABjAxezU5OqVQ5jjlahABo3v/wQi+gmf8MEE3SfCYYxhwXkD8Zc3DvBce9xEt4SzPSxfgw2kCz2wflptHn5Nt08aePKVa3v4RY7/JmKH1PaKtKu+AtsP8oXODJ+HZvhlkTHMaog6NIr+TvJxy3IQBcakALto7yqeFJKR/XDJpC86BHTDfYDxd4K9/hSIJRMzDqbskWQqy9L0djY6mDacBHQB9v0XMs970Qk/mWEJ/55sAquCFHbdTjLXjzZNBiHaJYrHFn2nm1+PcI5vXoljShqO2qFv90GP8DHX6Ap6R4/totdfeu5vF8XC1ujliAJrwgoa/0IkUgV9nRQMbgft1eSp7VUcthNZ19T9GyiSPxDkovaIb6KXgv5VFefThpjLEdn7X16afWNLfJ6jwy7qK3RNEp1OKOMLEMAfuqW9rUo1hNU3/Xnnt39jJ1QBNLss/7DPSk0C39WSac6oDqOZQWoDGCxEiCevF+9R4G7LYVOuOZiGSREZPd0j6Z7Jl7+FuBUXSQj2ViYaD9K4KzlFineMkeo0cFdr6q0llq3Mu+iSdlBzykToH1jJTKMjtTR8wplaiTjAl3S+uhNb2nXwpFmD390o3ImwKzb0n1aQcHGESvuiWVbF1SUbf0wEC5CxELVWJ+PzFizFnM0w7r815ljYL9yQ2hpBZ3Ae71ft3JqFACqnI1tWrxLaD7u/3sC84BCrP7Ovg6GO+d3m6wHzp4k6uudDJFn0ltuqrtYYDWWHlU+3ifsxrH4ax08sc7Vb9f4OGqcY8iOpL9ERtFCxSjUR7tQQs1Xt7uGQ7SLt5bZkef+6ci0ZK7ALOHQ3gvQ+P4UYlZtzXynWAc86UwYkyXMGTMZYEdcykaD3nW4BrY0aBW9kQtvqM8aTpaKnr0gOOcPnVwmF5LEd+ZfYzNVlBpGfadYZ6dHhjZI40KdfAu6i/FE1NT8786yWRXdM1yB+/TD+zbLichkGeSgLqe7tDXnYRxUXauWgyHorcVFu1i9NMPgYW+MVWXdLqKH+WyUEac0Y+fe/txHyjNw4i0H3eCGJA7qFPLsMZHq68LeAMrYZcWOMXFncOg/Op+R5Fr51P24T5TUfbOi9WMuLJ/f1HA5XQ8J99nCrqGhpkrQxuTCsyVzExiqg1fudrhkI8QEyPO7b8AVmkSNSh6n4Ymw3wvhM9tigXNb/jpE7q7W1DHw51+zAn5hfbuFtTpQJMDTTCDplDLgOx/ryWqE4iH1K7nG0wUfRoZ8VQfyCpxcr+GtjbPoHjCzIify5r0Yf4jss32Wtmoghfl8bY6JSurbVSvdCBsv/JeUq5j8O7YrohGqXMMpMgtwF0Hn78euSKIhzSu+gaLEh+eEf/ah3Dr60N+d6tvMjW8gb+fBg3PffhF+X7gG6t9yW8nfKN9K+E4nt8dkR22bfD/jbISOrKACcapmGCqegRN5pfxu+lb8EafW28vpjd8yfxXMiGpG/8sq20zBtpdLVelqanei/cNUMPHZ2v7xlJbe/R9Yo8O+o1+PxlWp3fDfB2mg2VJBXG5k6n67WFU9dW79mTHMoeZqoJ61Q2fiU92mDemrGW47fIim1apeRAkvA93bMWXwEb8yo/P7uybTjmABNo6xwQ1/Rjjo7pMAAVGTFOgvblPQy3NeC8Hf4XCUQiaAT6Y+UPjsihltQq8MCeupZmlaNkxYkdYrfw39JmUslHfWUYUe7GFwj4tJYd3y0tsnTxrjfE+3Wwpqi8pLXq7CN9e6bVBnfqSXXatz1r0cgk+q+jjiy4L2cr7dX0sxxcdLLoo4C9/L67RCwoOn2+wKHfjGfEfvdh7KvSzQ6EW3H1uAFuI8yOVlHqG1oEkqeOKhtU5i4bX1Rdh6fegX6QMoCcFvm2bTmrjz+zbuWzXrC52FvCSRCyVC707ii4IWop3R5K052AFVfFpLi1FSmXELcoM/41+ps03QH+Z5GLERX2adIO/w7UsPbda1VWU9HLZDMoE8hU/+N/3R6G6QdnRxJ2CKNUjtJYpbX3Qq6VLm3MUmifiPZGqNO0v9KI1KeUa6Ob26JoIyW4lItB2NwO/T8tT9jNioF+X/pifmfjY97cpZXy9oP/GbfLj99Zebfp3/tfKjstTGs670PrulWJ7CkUmZrd8n23B7CWthaIp1+oodXwq62wTOGu5kQusAyrorWoMVAa2aoImVmWwbrVWVVErTaQYZW8W/NXaQ74JXGHXLfNaGrfLGTbQYmserKovGbpvn13fQsxJhoOPlzzBjNkmL1q4SBnVRzCS5/0rqNEcncmmHm36U7i6TfWADRN9oKoe2sDyjHh7RJteqYzfH84DrCk7SFxcIIbNVureA21Fbqx9JybIxOwDXJUKd1IX4CtV+3vhd3SVEKVeA5T8WxixqoXyI/3It0zAO3aGCm4ULOEczwLHC7iW5KN2YWSw3HToV+M/WNrh4FzOIhPndCg8NmxTqDx6z6m8iREfDYM+5+nSpZ9J2WgX9WzK2lTQi2TfGP4OD+g1nhV8nGJ7aT1THfvLjJ5zrlgxNow+yd1Sv4z6RSqejbbjXErCZDzeZ/kvgvl1B08Q5UO3UOCx6HGkQcpBvUv2pvIzm1eaLkk7+zBea1Qv3qPEhOgCKBAzlfUrEsEi/Vlar2QuY8SRQKk2D2oFn0C/KvGHyL+E2x34ZkL45E0fa6TGoWF8ujaMa5ffoKMYR6lQ1MdogoZYF5RhPGNByiSFoydQjPhtGPdXOlzL0w+6VF3FSSuYV8p8yadWpsK4GKDbi8IFa6r3n5uMOtWZZdoRZxJyhvmi2HtKrmi+WW9ofZkqYE9ixvo3+bX3tmyX09zwVxOlmbcxj5cXbFH6rXK+8ilvBRm4g04DKTjahZGh3+/BzxEwatthi0klPgH2x3SPDPCe3OMotjTjnFdHAFLaEe1Za0s3Otce3Fi/1lrNVQZA27S6uKJSwPRBVz3IwBOyIe94p27aZp5zPOrAdl/oiUZRBFmqDQFVHee5jSm6WTdlcEUPfv6rB2BmmeTjNq7QTTiToXDG3X3adIs/Qyk1K6xNN/u7XevTs6q1Xc6kt8u0gfwRVzfhjZur65yuq0X1rvVV74ZSbE1bgdP2iFuJwVbFbeTwtsIAn7coUbC1StuLemzKSfNobY8CFW8nOzXdZd2YJOrVOprqw7tZ63g3ne95057Is77M5rUOVfswGkuvCxkOvsToCQJ8PgH9WiX+CzT0sCN6UxE99S4rMToRzgl0pA54TfBJN5MzxcvmTPWSnDxxp7sVpNthe7YXI4umuzCq8fUQft6rWD7FPtwRYcRhfer0lf5S12G7uq1k41CRTdC3jKaEOwG133KBrmE7uPbdZjLR8F3pxn26e05jnQshkgkWBz+64Cuh1BUWMpSWHu1Vp9/qf6uoywu1aq66VBjnY/bPjpGnSjfW6bCM8QwjunrxxiDnj/c2lVbZbWdxlAsKsLe/BWJ0PwmMaAtfEgopPDfNwOem6Dgf77vqYmbOtB/2drmiT76C/t5tw28vKraCXIVtlbhq7R+3lBZZlVN969rXkduoA4qWFVB27C4q3rBIIbfQFIDcToDdN+5BSnGG8POTEENrDjth3HnB991OV9juFt9zd7iaPN0u7IW5Mz2PcExtHZ14GH8XQ68nWpyK/PptaBnVR32Xn3rZdVszPusO7y9qRz5mq1+boczNokh3Jv3bNvj2NCPODDF7O4T6jbXNGG+YEc+EmfSgn8n+0/cHS3fZN509N1Ab3x0KtcMqeD989QrJmeYlE+73MXv3ghzX1jw929LyNI1S9oreRXQBPa/MqjrEpGvaGC4xOCSBqf3U9wP0VB+IUdWv7XAtKOiA1hBbnAIzbi2MzxET0KoQK90u5s5/FnxZgNhJz3tCuPPwYbvmbHTOMwtq7aNPRXsTYbx7gctwxQGXo6Q+oI0pnJ3RUr8R7TzsZXJLM8V8YfPpImor+Fm6rPSmU30O1BMd44/QQnvbBtxJYR5Cjw5mLeKO+SPijrnvJtZG3MTa/ptY2yHjpyCraDJgzQ9Y+zNgDeH8UkqH6327peVWWvU/cPeSgpvH5BWgI0fxFZ3Lwl5V+kXESy0jPigzdZcBWrsG8HIuxFgY+gBgpcq+8my7Incuye1FUewoWLm6q+nxw8y+dQpG9gJG9g5g5Jkw4mOR8v3vsgoxYk5CjDxzwnfuf8XI/42J/cJ5V7TVuWFV+gF/wFX0/wv1SQULQdpMCZ1B+KpqcCWo/oKQVbmViCJVfDroO5WwsgxgOROQP7iy7pQZ4BUbfUvN6NnySZ8ZtB88rf8GeIj+MOpwxLrGh5r/+2WjC8KbzmpXn9aLBtaQs8qL+W0Zb5uuGJ6YVWZrss+lrNsG0IGHtmErH0fuaK9KC/mSRXXCDW+05Y396nTRP9iiBWToxRDeShJdMeKoCA+SArnhwl7c2/9O2C5r3OtLraA7Wis/3Ll5V34Xm3+wKOCI8q2wq7ToC9mwcD1vddjoww69OFRPxMcjHwSHJqi96E+raCxVxOxy4fnIb4EXXm3D9k29ImjibwF8hqnfUHb8X1d2+OoFEoxjCGeUGSsbWMKygWNJlXaVGFFd92FEElmJtUECdt2ECq2HmYqaYkrkaGODXeMb4WGn/M1+xceYSDsxyUfKB8tqsZQuwk553a6RmTjJh7sYcn5CWSVqRsEMPROcq80omwulRNCdh/jPymkLS9NXl2m6nMPLmL83npWX2paOXHG/ItEJcsIL1qHeY5tSdQmn48yz6AUxo3dh81l5iqljTbFzzOP1zj+sOu9c/Ti36qIwic4FnHwjE8vX3h+i2dYCszQmWngjspadQsQv+9+yS77p/zFajPCB7470v26PjlYsdNOXGvQw3mqgk4f74sfUhK9fv9SoCczWagOfRf8KRogRbVoLM5WZtpWi3jKBMdG0lkuNNxrD0lt9eCYXdOtS3wzoWGYGY1MHM1RsLcZEY/duk8cd/cNs1ICPgw7b2nILXeBobSmmH4MujBkaWlsqYbW2thgpeu0Vio/FFYqTYvfKxAaa5xDMG/2Z+x9BbYLeh7GeRtLHuEpoZxJ8mm0dpdxq55MZa86tWhHjXI0+QJoIV1ZclpzSKqfZViSqwsTkWK0OmlXM2CTA+2M5uiATmyf+6C4UbXFLzRlUfyAgPRFJrUupHVmXVqt/A7MhjaqNSGmRSuWk8Vu3MYhrgVge9eM51Pf9GWXaGuxJHwELIGatH+Ck0wSe0M0W81TxdzG1kUbse3m6syyqsdU1qmvV+1oBz5paVYCNiQmmsewzzL7FWnVAp4I5xsUEh8TmBS+4yQQinndrMpZSHYzglog2A/NQJ0XYDOw5IaKZkEstLRpOVZtCdXVLlciEiRFV3Y0UxE6e+IqbZGnq1PtG0heB5+y6N4GrluMUGFfLBtuLcrKtWo63MdwO0HXUwbkMzuIdZZ54VzijDH+/2I9ZXT9wM3dcaoy/K9LIPEvGP+ebS0dHY4zRRKE+aI15oKc61AwrUde6eF5GT0xopMgkqLwPcNr2Fdaw935ryPuoVd/yAMfsrQ8WxTQHRyYwYEVkFOxpMc1EXCIGR/qYu8hE9vtm+J3ge7mgWs5oqJS5/RgPMwmzqkvGdx6nqB0XinEGjA4YpFd/YmbgG9U7zcG4hGu+/p/+i+ombrmW+A7wxJiDQmwwgzUXLKEv2Q0+ZuJvvJvTzyc/ljG2YKucYZxkfkLOMI2mKiGxYjrmTStgJlXB85n0msDMJFZWZprPf3ftJ+2EJqoLahhLC9Bj3HKaAdz39UCcNiKt6Ec433Xt7ndYpUycUoZVyrB7omXm9d9ovF0YSZdSjTki2fs3jsL6Wvh+ez/WYM1YNiJN7c9GCRmzCM8gYn4jVNK7hTiiIbgea8CqZ62wHhvc9BZaWTLEd7xzaCIRn+8zrSacc/X0ioXNDIeeptFzf/SiGpqbsVoU8BmuPVWtqu4H2QJ0QjJw5WWUH6ZLHJi5WGfTm56kfwY9NTkrVWZWYBRlvnLi+ERfpWdEHqxVB1eBa26HO0O5g7EH1rb7ytDKyrQTvrnnXoO277eSK4srJ4zX+PQWrS+OY0ACnxXM0M6cyteCOSp/43CrtjW7R3XVn58kMioi3g7PV+DZ+5VplY9CuVz4PUs10praqrcYff+A9UXE7MosUa8Fe8hQaXdfMVc6kwE3C1V0bto3wkdKiWQoYcQSQy4JrwWLoH5nq+kOveVSox7aYKCErhLtRMCI4TvhI+VJv9suGvHJkFMCMZ+/twZqmtjf5ZArfe7Xgmb2ZOOoHHVrRg97xasjwatujdjC3p5DxG73ShhnwG2yEvGi+8K9TK6/HT2+f+qJz6oJ37hxo1EboCpV4Jjyl1xgFCNKzjmuTFub3HKjkYp5Wlhhqlvx1kmspja6ti6D/hy5sfyd/5c/sLWswh/2JTPPsPvqVmIkzVo3s+/kpgSwBp5xH7bniU+5mbqP7LVyfA3r/efsPPEJtw7kv7oWtIUZ8ZwqHDt/IYzvuR6mTlejMS+iS9Mi0nPQ3yqvro7J1Vjnt35kj/W1ylNsHc4jYFU4H+9Yw61Sv6Stc65iJi7xafbiCA8Atu/zRUe7RxmtCkdbDqMjm9P/UKbrct6yhWlpnF4QkZb2zp2dprTodHasGQuSiYzP85qfxJlEd36m/WrnZ2gitjmtl+VMq52rH6Bv/3Qr/SddJ+hqmTqtORbWmyo4hMAq6V3q0dXFWf92ltnDwvM4Js0WkSbBWP7qu5Uy7QzwpOhYF8NYv/eOUeTmpp98FONHJJGHf7LQ9T+R7C3X9rxNOP28wxSpfLhn4vgt15h3iHXLtTA858pxB+CBn0gLk0Em3UruInhvaQfV0KXy3C0GSiYu8AqrblP2vL4LR1cdV3FaXlgTjfCMtNAeiudqQGP0N6oC+aBNfKL8GRVaAEmZ629kcv/d2EgzyrCVYBj56jZ3wLVMwXyRgvk3yr5YGeO5kL3I99vZGp+r9Jzz3Brn48c7jSPRf9XQWlLKPY5yv96Jt5eWKneIDpZwq98TMErmAz1be2YpY/xK2Y36oi01mJYQ8JGJnd5za/B5TR8+P+/H79thBNS/TCm/Ltzl4p0k40BZWDokl5aCBuzQBlQxbwS0LEZ93fIOw72hjHt+GFv42M/cKQqN9HMh2t9upb/P/dG5VUHLI0CL/TVNv1l2cmWs50LOTzCr82uKnNzjrziPywU155zOx82rngdcqeOeE6robkE8FE+3NwR4trZ0R4yLeXpFjJqqaoloCrN1qn3JYANE5biq5kIWM5bda1JGRSzDlH0RVd3gvkhd47f3bpMXlZfw7N6n7Tpfzo59drUPS+vDeF87uvd3K1DSd203QG+OzDkG9Xe5Bke8tWyorNqfIuYlVIK2xAZUaiJWujs2JVj/5IsVR+s2pydZV7XqAnO0usDj2vg7d8vx7huNoyfoz2qCBgY1vJjeE01IjUvaNWYXdcAKDPRozfFA22qFtn/sYeFXHIPnbKBJ9GBfyb54jpj32b/zPj1ydPbZ77ILRsksmbuBmXxNSKFLmq8km3JOtHwWNKneHJlSQDIWbRCEePOS9FGyymjKvuRNopcE1ICJeLQHsXBW4S2Du0WgXZqYu+oabxEjOpxRjA/3Szf3uGcnYkQfoni1P3FuU0K25Du18rD9ms+5Of7O/Nk3Gj+kT3svCdOhdU1wFDNmMzFrgD/XrzRZPwmaiNE7tFkDEv4Cl+WpD84iIy0g2XM/CY4mzGR9DsZB7fRxm0zWW7wTuLhyfUHsKN0UZpJGNGp22OO9GAvPZI3xjsG62pETsC7W2Wm/7CMmfXmTUH4orgKjCtY3c9T05NtlS+SM0ZMWTk5exi9yjKxOrKzbVLtutzzOlrQ+unODp4cRaS9A4CdvSNmvSadxFRg1qobmH7Y++Y+ytAKT4kfQI90RsVLLk/+Slx7FVu+WidEQIOyvW35WabmpsWNrR+U0A0raOHdWVdZWYnoC+orevHNCXye98kA+tIj0Q9/cZiLeFsqmKmoyD95K/bAF9zSfaxgB8talROxNAPor9EWtr9/4Bndm2zb5dPNP7915/66T2tldzOzxZ8iE2Uqs6aRniVgXYrlhNcNrhym0/1WIWBIU2h9e9+s9wZnNBiXSy3/1o4/riIbyIxesrPdLsCS4M0OV6JvNPUj7QYFM6PQir/xZyFbWxDJYTT9hfjpxci/pai9vR52EfI8REGxtaDuRf6E1RU7D5zLiU+BbVdYk9yfOv3Gf+Wm7SqElhMvIzW2bPnfZuxjzh0BL+x5d+WhBF5u5X/5NHhm31KsLFAxlZqAEfyYsXXmusW3nJ06SU+hbXvKJ0yvffvQfQZJw1uuVTe7js8+cHPmntkexJXYVycnzpZSwq5g1JPsL747Zn5/6vnq/fPfCA7M/8ac86pbvNRnCbO/81FcCBvaZ1JrZ759atrkxHLzSeH3Lg275PuNWJ9dKzKzTLS8x2UuGF4B+ZZpdzOaoW/wlVcWrCwq7/pC0O3z1GmZ2GFeQ3LK9+Hhx/ipielbIoq/Tg5j5csjbyucRofCGuHanXaW0x5jPgJ5BErYAvxz5pL0ktoB1suYvBXsFqcjrwsxNxyq2VsyqsHepzKqK/C6GAxs3r3wOU/7xVV3GrPLyOfCfY8pjDJXKk/zyj8vxHt1gDKmf0bJqNh75WUoe8OjPu/JgIjO3S3o90jonUa+3/SwN/4gc+ksD8wYxsaK/P9lDTPHKeabqDQYsm52A8ete/b7CnCvfq+uWMpo6cq3Xkdd1zKSqO3a1QJWcr61bOEMFmkR+l53T7WMmL2bYa+K6pHzM+aPKaxXIoXyyq0El3qliao9enZ3E1jJQ+misuvbjq/lJqhqVh5k5L3bhJOaAplb7dI8UisQp/WNcuf2eGnmhbZeH8A7PMX6JJ9WV72HewAhgaJ8keV6UNTbOgxkDF9ow9hPGoJt+aBRdCDXyPMf5KZ5X+UzP/jkH7GDxWxg/lonGafnPUj/+H6WqStnb2Jm77FUtNfJ9tqMlTFhForecph+qQRuIpjYxnL20siwifYtefv7iUmfJPruqjZhAkkAr50rjCvbZpZO75XsXMuOvfl9c2lH6cllKQbGT4aJ3tYkl4MeMwMkUc5vll0ZjzBi8EenrCPrSMlwOfbkMyz4TwdGtdhLT9IG7SQynpm6YO+GHUItyChGFxaZ2PIm44U11EetVL0JMo+R/RKgRa5c3HSCnhW9lXtUetq69iCvWi2X9DN2/mlh+7yXm4uLo6JZFtOkJfiXGfj/fVHjt3Ia8K6zl9bKr9zubjbfOmR3yATS051z7y7A+4epXT6VHhOmjbKDdvdLPcCx1FEcjGUyBsV9QWmL68zwMSKzonCzQw9m274XdisWS7ssoVeRLREPbm+vLhs4fyT9tv8XHBiOLT8k/JrLXyWLT5KftQ3yn5N5Ew/yn7THw7WJG8apT8s+T6lf9cstqqLYJ+Y7mEcUvab1AWhYvLppFyH1vMtmYG9BA2VbE5F3tVQDx0Fm0mBjrbd6hp1jrFd+fyceue9LH5L0bDl6bVZIBs5mMWen8TWVLl5nE8rzMdiYwS3W/Pr/kc9ehsCSNLkBfZxOUOe2/4vKULUm35n29ksndZ9e2bkzDGMpD4d1nfsI1lnlXduhmdxHT3S0k5ujVOCIfuft/9BYGDvwO9rbiMsiHY65/8isSmcnMzCQ7RkAx+3bxTO4uxzx+UnOD/BtbrX0kzCWVlB8BKs075mJuX5HYCHplWl68LyI9EcE9y+6zuOMeOMs7cDS1/WZ6wNHlwNh7yIvVdAS0m+FhsmPOIjy0Z3cr8KBeNcBjicKdb23XBGarCruW6J0lguuDgVmblMx8xJIJ8uTlMmamqkuvGi4ymtEt/1zJigmsvUs79GSjvuVK4z/vPe9CiMS0ojxcZAslK7H20b8S4IISaLbns6u6EUPKo++Jcnfx1MrPrqqyODFBlZ4fFLDnMmKiAPPgSIDTH9Cjzc/cNTGvvuzfS84r7//+q/coyf4F7+/Ie6VsybIssZyqxPL89PzfLvpKkBUPPGYsM4E9W1/aZGdayZgR7VFqvdSvSTf6iTn66494s8XvXLM8LR20cueqbfLi8gn0vKCheOYXvU/T3Pz4mhFNVaV/tVtamKyptL6UmXrQzrYyE4xn2TFRL4dPUK56Y/yHQEvRtGMkbmJh/YCd73BHsB7wE269k7YLTBbeiiu3R2thdt3L/onNzjWvrVqeFuOz0ItCDo1CPiOCcbOhxkywwQBqi21IL3FPbgNtRUPrd/5+F+1SUViXW51VHUUmrmNdRNL3GS3tW0EWqaKxdUxVk2j07GpNaUR6CFrUga7+9qoMOngL590jGNsitsRA13niNuJtCJU1xsdw80oi0oo+jPyDp2CsiluLvsTQf0mtHVfYcMr64jb6dUNPR/OhfR9BzyjkZ0UlNiUWGMaw5DaOKVai7+EN0yNxG9Hix8ylscABj0eiJYiJU0qYio1KJMFo/K47+vjDUb6R7dsNc89tYuh54EU90pqe+jLj/BQH8o36sijXOCb/mFFfVrzmGPCL+rJX4P/P8F8//5jcm8GVOp1RqotGuyIKLI1HBnkGrpHHS/PXNKbXAnfeQVWtcY4ofQLfWPinpjklx1xkjLbpvGufXdcaxc1ImN0lP3sr4WCMxlfKmOxRvpPL2WZmKpvL3HlxIMLLB33uRtKMu6JIg9dacT6rV7FWdUsUnydksvALgc26LJxcinXVue0gJRa4avG2KE30H3M9E756BaXTFzwzMwWw9VqvsSB6IrEv5ZW1KCuQN4QFG0h5Nc00x1PVAZLRI7WFIhLbW1qhrVG9CZpbxl/k4TZWnCGr05P8qj3H+Dae5PyXIkHu9aJ/lzpd7cd4LnVKfA2QG+Ltcuweo0e3Vy8+GCbjCtoC0oWbtwLiG2xHXpQxX6Xg7XIxdWYPSMWzeAJ3TggUsXW62qbr7gc5r6a16TrZEutFf9rTAkZ7TPXCmwdu+AwcaY/hVG9Y6F/kJBsRb4GRHfPr9ujF5HBsDbEc8eI7Is7uUdP3hViuU4jjBGWfvkEgpo+UDAiqnbWKN1hSM0bBU221gQavPdAjrQw5d6Id/oybscbUxteSVpZLrC0Fe2OIN8eVsXNJetdGVWBW0qk867rzLn/jqZSYfXUpsbXa2t0y6/4gGEnQ+TpcONqHT8LqKi8UdXptnaoW7HiVuja2jqllczW1iXXKDnYMRi54cBOZ+JDXMHGd1zhxoq++gtTmuLKUfbLX3Jo92sBilnDGAIu5U5hZAZUhNRix3R2MTLokzpHjaho8TJ02bJxG6v6dF9hoeI6ZuScP9Mh1NXZtkFVZWoy0CnjNe6CtMq1fd8bt1delNhv2YXyrXW4ycYvPsG+f/bGzRq50naHuYFFcXWlRfJ1za6U5wJVUlmyyrq3hDq415VQssBYT8Wv37eaStSvMbeWlm5zlxPS6ktcsvtbElQmIGeYkWEyIKfjGcm58VsicVHGb8VnhlBY1p+EeBnnONmRVWF3qvXFBhsQFWUNVnjZA2dgeIsb2GHpTCrYV/LlgKMwSd5fzYabGgIHMChLmZ/GbiK7mgEdVR8IjpgU2MrlZPXE39uSpuIbwVbEB5qh/ztJSeG2Lg532uH1Hy9edur1k4l3X7ntnkUD2krq5acxMZu++POxpcgHh9AWLBeNEt9dgPlikg5mXrIupcwumia9XTPIJLrYuxxXbow1uSQmnkNqxFc8dJnt1gWcAGyfSSAZi5NfY+Fl0R/Y3kboJ83Rh462BjexM0qO6KuXtsuuCKtbSEkf32Y3Pq1oLb1xd/5J9dOvXcl4NM+1GI539evmWG31vPyiOIElRP5kJGh/2hHjfMeoLoTwNx9uUri8gMPYZyrg/EkyAMWPdp50aFe64jRGWAmY2AGZeqWC4WqTNasIxOdxW9mzRzqftpLWjsqMad6jM7zh3MtYtN9LfYWbWNWqtO1q0XEflCGFlLDGJkUgC3sfU0FhXu4tkhKQzEQ74Zq6sHp3orquoLW93zZunsnVJd/a2w1qIs0Wkz0NvVID05nblLVnf4SrZ2VbZ4cqpSHmo3ZW9MxHevx/qhLY819132U8xxR0u2bz84Q7XXeaUqg5XxLwcPktcbUWlFcUuk1UTVGk7XLnetq0drmxzlZxlane94RoLrewNnXNN5j+WraZ18DnRNLn6ZTnX1LipUp5qKq0wWA0tmfPGzOtwxfLH5Gmm+fA5A+oWV2eU3Amj/bSnw4XWZL3cn1F+pLoxCVosDX0gLIfxsOY2+GTMKY93uLqqlz8e7dmu9JwP5VYO9DxH6XmB0nOh0vMiU8y88644/hPgxQvg87e2aI/LbZ+CThkAG+oa/PXBn3Yu5oaRChGyEek3ERN/zgVauPnfPMM1zDG7tgKPbXeFpPQIk1W68692YxveWVK1LRw4fY6Wn0x/gPIfzMFTsoCAJbr9pRUm61Av4Q7JQxsY4ChyjLWCwRXtf3BnsesH+aFKNqzaQLJUU99sD1TPPGwewGtnf4fr3gEpCDC4KQVPd2pBl/xEvjgJIYNysMO1QJGD0THgiFNoA97PiH3H/8nADZwL/Sa+q/oYlIjOCN/u958QBntr7O9uxu+TaEh6q7+kosNlyIn3GnOAs08e601xLHd0uKpkfU2Hq16OcbetU7XXy8RdBfwUn5OaaN9+fjEdTREC2H7kRvk7zDSnq8keF9DGftHK1GHWkFP0MSHF0SGQrAfFLXMv3xzBWhgBnnhaaIf4t748D9Aon+LAO1451SmVb27at67DpTe3wed5HikYPoEGz1enRD+roiO4MvKUbKhhuBMDI5gII+A2/dX+pR934scKgzpBAuDbeMjbyU7Ju8IokQZ1vtRSq8fsKeLjCpKUe1UY9yJ806OTiK/14B7J3rCG6puv8rlF+OudHvTkRA2DyUGtySsb3MleNmekt625SfFwIGJ1D37+KawDKw89el6w7255yLHegU+f6lFyy1fm82kFPwn4Fu+jDNcpOYDyda7tDdMVXYyIv4eSRFwe1lK5Gc/y8VdbmFiyQa7ra1QvvC/HutPM6Dsakr7si1FuAiT67FfKkj7tJFMKCpjbX5P17t1h+drPDqy7uMdGlcxBVRjjYaSoTzC0FFzJTCqAGuibiTcYGG2nMOh5SsQxyvxHhrXpwxU/P8uokPRc35wrD3NWh7P6oKO+pLiaZDEzP+1U/z6poCl85WrAATzQgbVSFX+q6Qjxqamu1FKwvZstLr2HEecqfqaze4mp3YHZLP4vn7zppoB0NPQ/ffKImQQNWvTI65LeDI1RelvWo1EsXyJuh28a/+3K07MhMua0wJUmNTtKGdHQa6MBqVPxD9X2nhDEQ1rXEw02JZdJQwj9GV7t0VCxWfNOhiu7SX2Q1DLPqw6yb+Kbd6HVRL86OIrNcOHvf8PvGL+qjsOMmwrkzUU6n57jNuDbF0MW5TYKaz0Lejfef2U06DGtBuxGfbOJuCGEIyyFHisGfLOJGOhBjwG2LtpinK+Uqr4UHZMUulsfikYh1VBJuWlyTbEEd/FpLo3iRUvE3ygt2nu09IPmZNMZoEtGfBNot9WDnjT5StbqKgej9JTcg7e5YtBvRnSHqfLMHor65fU5nDzg14HjjtMGFV8ewOL0US6gZ1qNGarE5BDSsqFHhVEjfNCy8TH+ydTXwZrKolvpnc34NiW05KavzprqTTyOQh2MzEwqiOtSxTWFr115L3zt2m4PZnNN8HFKliUisiFVepq/tHpl/maeK3i5YLPjlYJpqWcGziEK4W28f011q2w0vhqIU78LPU6hZrqsYC7tlOoiPwroCUTE72Sm7iju+c9CP2M3xfWMa+ofsknBNka7mOHTiCoNM/52H0ONZh5WkaV38gAmsgC/1puYmOBlrRN9yUCPFbKW8k2quioHW8fsVYGdq3qYHYU1dkKNof5JSm1XCH2XT8gGgGQuUKLTQcRaefrAbkc0psIueSK9rux5ID6HaRDaGk1Q2f/oVnaZoyN2yk5+iYeMN1HFn1WDsTiJuEZGLvS/ecZypalA7bjOdveogwYSkMoVH9S/9JAxPw56Nt6KPoa4wqfISK+WkDr9Fv/z8jD3P/gN1cpKB2i8HNYrszfe5Cm3A0+ZWLk7LAFHIZlKTTkaX4O16nzJ/8FRflLu2v0s5JcuXUo+xGhCsGrVJliBM8K4xxmQXr8ZJ/+9tczcTmlK30bg0QZbQKo/DFZ6Kd4sGEXv9syqtlFVmLmiCzOzOqU3+tH6Jvxn/DTPe3yWp2FgH/Casg8YFEwUbepPSvKrPeGrNxqV3Tmtly21e1bY4/KSCvKdPxU7qpnpljwtaMqT6axSjHCC9+JIY/kR3GvC2yh5mdmKDdwWYdOZNiPmGVd+74nk61jvHSAtrguJo/DJUxHmdg0VfA+KK0hAiTDwBf+0fTjmIi+d5MmvBlmfxBVdgBoa6C/DFZGexrw6bdOPbDmk5a/ywBddeMMI9/w+UPZJVUBfzkq2zlmM+9MdxVf5Fa5SjzpoY0FyLcKStmaulPM4nReKLUo+LZiPeChELA4n+rfHaa4KSCUiwAHvlEQkvCM9wv/H0vh5erMNpK0IXNXdrFfyQk6MHCjWBo0khHRiM4kJhOEsxdZ1A3GX1D2gN5UrslNVaqBWD+G+dLClsUXJ1HgEx/elIw96fwR6NxVhbOA4QkxBYfQh1SY15TyEP8ZzzYTj1iF2hrSjfSopO5wA8YH9zcte3Bcm1oAP94Oj2ex30KdBr4hIKRGMyRTN2BfdX/lX/3yqpbNodDeSWIL+6PMv+7PEBC2B8Wvzs0fd6cBnH/fr6zRBPZOs/PqwP6YuGfDQqnho6/CGTNCoJ2M0AT2Dead+7Me7DhtLmQCJ2Ssn2MLNc2EVXEC//thtjdaRJuvxlk+DJtULjWY6rkAb0JB59LXGEy34vlO6v2/0eLYVNcBvvcRUfl/01imJNWaei9q2JXEOVckCB0gbjsmobdDS451s0nCa0kxMURsjqQIln7ViovUW70RlBS7vcdMDzfjtlR6T5UCLyTSWr6TxQVNsNM/qrn4mXdemp/8WNEFGP5u2C3mpXQK+KejXgfwCbMZhFkftQc2b0RoLlR0abd1g9AzN2QcomfgvH57/HBZiBko9iPtU/vk05g3Uzc7KKrDfu3wxB0LS73oqZ1/wafep9rIKb4hvAQt/7x8cxzsJgflkYGaU57yM9QPlvOkZ4dZD7MFhNF9Wj0pR9OzCfjzHZeqMmHlOiRSSjfGe4MmbJcbcWjtTqztZUmosOLoZ9785B8bDxIwUQIUDsaaP8V86ot8LrsxTfdxJbPrKE47yOTGeuIokgKVXiWzGECyBz5VoaoeG0bXw3unR0xvSgTDmYsTaxMQ5HA5TZbvDeAR53A3lHEwWWFHFMjm4awUyHWo8FUaotQ/oiNEYZliu4IqdI6Y40Hl2FJ0o+riTJR93qskC6NVzfdYW7FXrs3uO8jckPmz6lYaJ+7My8IqvebxPcUNaFmboQg8D2kOGGe94MlND0sUQ8gzcDWKgBs5i146GkIEwgXyWyfVW7nIjLFL5FXwdnzzwzc+rPMlzkulgBLfoU4zg/SWfUpHj2cenNLdVL3cr8DNHYapZgHtj/3MGCxcX5iM3+5RPVm54hKS9MvJ2zmFVekryFFx5D37hGNGXYtg9OmXV7qMw4jiSmbggtaLenvy9gVOF1Tes/Cy6Z9l58aGeGo+Vzy2YT1fAk1MyAW13CW2dUwVanpXv4dMLRjiiXg/MlO+F43cADgdijH3F7warI55iHJVVvt/v+NuOj+z5pxYuqIWnhQtS+eYCg1lKZcO6Wz2z1a0wBp2iZz/xL7Ba9MHI5Gi0C+JVHTZvNnvQ4yUkZYVkz6x5+O2wfFxe6P6k0bR+FtUABkAXCHGbrQXEvHzDzE3RG7IMZ93wezcZe1LIsaq8K6yM9y7rKR8zzXDrp4I6QFVNoSHlv8TQng6SrikyGB+bWA559VB/7PyZNCMDe7gh/buXmfatUA/67lTf6AXFO0by6GFg4JbnP7n0fPWSfBu10y+WhqRTMmorz/owIzktGD7PBuN1yllFpvWfNE4aGK1P5jZ3JSduyck2gOW5ZAO3+erKiTdH7dzB5DrdjwjMTG59l7CC11O/C2AzJ3kOaUH4IpzxzjLm/zrB426u3kPEh/pRQx+IXsWDzjHwW8npVVgDlItrLtB8r6lL+jmsVnT4OPRofeqX2MgMtcztknz90QjOWQu41SAL1tc78FYIMV0U9DCXKfIP8o79pt9UUjKmUDTE7ZOJ7aCd+Y5kBoRcPi6skTJoK9DOb0O5PO+ZWTALaMdEVyjxXD/3YTZRg2l0wfOOj4XWZfNpBrQ4AyC2o3kYjGu/Enug0ctwf29UlWsXzHZ/WumW42tURbr1TzgOC8zUz0G+PfEJo99nT9L/Qm/BwhEDdzJtVJbSIgYPV5HbjBEqcoHimegOALz5NvKDvLRmWOHWgbGjF+uLdtaPN48CwkwcvZxBl8h6cl68Ic/k53r2FEzCOwW2FXhHD9spTJ6zmEbLyMqe+5deZmrbTdovPzTk7iz+r823m4h4rM/kcHvi7lHThK8Tjg/+PXtRR3QLtsGnxpxSHo2FFIc8owXb+BFkN7aDcR3ORjB2JFhYpqVuPHeWD+kLtZRk/pecuRDsSF6WxkWSPcwU7bjrSsxh0LNa2ucl6qVDQyj7BsmcJavviTXLUkw/Uxf1X1aBRdJwnRTKJ38VD7sxIE0bwDixBLxpZjxPkKWN/cyLEyvGeuLnQcuS1G+6CU+/MBFkEJ/G1ESkQwABnzd/E2O97CtQ3pvolwMxP+RDn/JrdhzcUW/XKueBDDG3HwoZMbb6E9G+A1KoLxqTGeSHF3TjTaketbXTp19A2vULlsiZtuWbJm9YxmeYtchnp8jSlMgaN2qUDTDP4/MS9VFqR/q/1vuf9P9z7yD9S4cSEB4cwOMOhEdl36/hkVoR55lolXwIl2sntY2/RH5H+/ONvmi0d/RcQQot7FHTvCbmRWvFVc8wBTIl/Sc8UVhMjCQ3K3sOvV4hf1OqTnMafx3oRdn6hYARIuvd7Q70U+kF6gf5Ua7m6t3qBR1R2428PwC30woOo1JNR/V0iu/X2DT/x+hTKibmyD4mF0fP1F49qWn8JXa4BcY/ry8aN5xYLngZxT8a72n9ABjz6+LOjIMZ/RRa6NFUUocMmFNuMJCTijfJfytjwpO84/w4E+6vrOjVULeHoyxVBy06vPs7jKr+P9rePDCKInsc757pmUwmASYhQCAh9swkkINjICDhUMMkNMkEJIgHlzJcMlwSxVWMroRLEGVFExGILGhQOTWDRhkgBjWs7CruRCJyLlGQziRM7ISE7rl/71VPAHH38/3r90d11Xt1va7zvapXVbWazKNmAyfWxdtYawfeGRduz/KdUGu4TZUoGZzAG9jXqEplyqo8GpB0fP4SLg946Dhyiz3ue7Dy7RdvLIaWQI/Gm6WTV19u7C6oqTpqCG1Q/IU+TXdpNUVegB6ZL8Xdpx1OdXy4nCo9aTlZwAIPdlOM8p6CGYbmRnNDiQR60LceZIrsNuWqw1I/03EL7q+pc/HFSar0o2ZKe6zAYZFjtnjkmFPCMTf7mNyPzNlt10q2Ssnsp9AaDRBHnbsPYtkL9odjnb4r1l/Csb4rwfy6CwzIWAMNDxq6Czp06Qv13dtLVoLLWGg85aK7y+lRb+0o+Hs4xX0kRUxPp8cUJ4RTfB/oMJro0q1S/C063ip4KxzrjbvoGBKOtb4kM54pRVpetXxzY2x3jCX//YuWdeEye/pWXGY7xu1O4oLkfO6slA0hX7L8NRxypofZjmH3NauVQ3N7EPr8XiZ3SgPWCtRFsVwzuvsKoWfcE9AOZ6C14KmcRnF3SM9h3M6aafBizdx7Dmhjz0q2IXJ7V+dirWjrZof/y3irNGjuW34rN1ViHihwzICe5xJ3SLf89A7+sXAMrUcOjX6YzwEv+RtSXpfPdrY2asDXNUhrQu/v4Pv1tdutKhpa1ZrFVGmuJTf8179If2xTawjl586N7sOUnpVMpDZGFYwO5/8vaXSCnLscegnJfzX31blsKIWO4NACarMpHPYziSnHkBXNWqW6Wat4nQc6NEiHU9JszpM0QAvOUVRpiqVHmJrtSE0J0hJDyn8Moeatc9skGsIlWvqGw70ih0sY2ns2jCurLTGal8DkgnkNTByYN8FsBbMTzAEwn4ORcFwF+yyYf4O5AkapjNWceTtW0wHuJjBUQYwmCkwPMCyYe8EMBHO7DJn7UgrgD0roUu3w5AKqNNmSHKZqtNTZBuTWc8mD1K+8mfkJtlNNa4ka6x9PYT4qacZcsT8q6cbQpY9K0WOo0jhLDienEi9NCdew3GKPeJhyJlcJ5cyUYj2vvBn1CfJfh1vv7QbSsvpsnYKcTwxdmwx0Hrui05jBfgDM1AL5rT9NviSu892+4UoSPd7c8A1XhKsHyXodlA2OhvFkNKz3qLgiGA2VrfERDLkJwcApv8bRMA5GwztHQlzXOmHLsTHkZlSQcNVrHHEF8bYmodGvqzjtooxNwuOBGAveeqEDDqZD3BOyWZn9c2wgiQ2kSkdxOdxCcpMrB3L71zVzbQnxc63y6tQnN6gS/97WHyfOKXwA7/qzTuicEylhsUeeAeWeha8za7ioOi38qY78aTzrEvlgtr0x/I/R5K4lmsEVriimnfwv8vKXpSUluC5Dt2rwJYvIaJjl+jX85KKGjiSvIFBH59qiHMm2Nj4Len2yj2mN06o5HAGSfPJdIDEX1a0a6iF8bT23Q+wRSuOsNnwZclDuK9DOqdQGJ/L+eAuIN3zfG763+jqLa16sh+E22/EGV2q+8hmXuDoQUaCH8g6J9pAKRoG/B3CW7SArbLia4uU77/JxiUvAzyUag6qk92rm2Lq/Smd2X+US1wXklyAZoqMWEr0hpEYMybfiUMK/yR2wr1Qet+Mthr3r8P5QcmsZuf/IJfoCu8xdL1xyKRRKm9be3apoYLYb7FOslFFpVVfqqmlLO8hqHkKHjvBxNnulR5M9zG5+FU9AmFfhKXfgTMRqyJOUOSXecbsbvqXaeUdaSNwOHFafC4qtOeHbg6LrvrG9CLLhIvsFvEEoIvInlrzUHkFk766MV9zpF8lOvYfUZitI9T04el9I/CHEJKkv0FtRzsxw4CvtGA9ldtQ/uHme3uoVV/k7UE8unJeKi4TcZt6639grPu2X2wrkwxdV9YQZo4dtkxlaBaM8t7RPD3IfXJx1QsK75tSaROijBq6od6P4ob8N+AEtwHQeSCqHqZo4KJtO+L4wjKuK/urb7sFf/jFccWe4MIRuvF9HzdF76QP4UtZRqdv3w7luJ4zkVCLegtMZ3iWurb4zrQvhtIQqbS7d2k2VInRTfbVQudggdFO836yKnp371WyqeY0yjdP07ztnrKR5MXER/OWDtRLTcKBVxxywvt+qYSZZ351jljQvbV+035bT1FU5xapcTGcq50JrznaJv1XjLXqUnuG+mk3P7ckNM01q3/qMJH4vMa25Sqbj0DMVrTr6nDUHRjpcTRHrsLUuC8j3tsjaQZ/U9LbH2ifnuMT4avKKl/yae1qu0yWuDDwsMWOMApWTC/bDkMruVg39r/hCG67a/OhSWL+b+op1s617rsZ+xvYPa6wNwkTrcnPhO92mECizIme6tQ+HqXzXZyrEirlw2qWgN1i32SLtZ20nrb1JDE1uvHWyjRaosXTOZGtvDufe5wOy/pJLnFlNzlROopJRn5tqZaN2cf2497n3uNGLK8yRF30LT0i6khMuatQJl2IL6vVIb2RBCmxghsSMhvmC2mpWnUXMiIDmXnrYFR5GRD2VpjjfM7d7rsC/OQ5vNN2cm1XzJneTvF+zinsLRlK9IwZXHia5xHeOxTrwNZq4hl5Dof6i3oOacYmC/zFJM3P/uOizzI/TQWJDHfyPJdx3UAaOwOiEdDwmMYlMs0qjh39DKW92HyqjwHag5slpVD8q40BNnUQdx1OSy3vPzZ0x7rnT+5tVCtSCnuz8bBx9jho0qa5s3F9/fL85WjuHq3MplFutG0AW+c72jbVs3O5mBTAJUbbyPum5UVaDVWPLFqhsqxXzUUKd9cnBE/hIT53fyI1EiXLGB60aRTxwCV19uDI5xvkQF8GddSm6b8PdIJ2mWU3F2EF+Nn1n7ZG7xZxiTTl3qM+cybN7G20F1hybnKrZiml+5H+Vpwatd1Lp65xbzBd/fCvhEHeQN9r65s61pVhzIOTcW5RkICWmY7ycQkZOjnUxH8Et5DGdpf7JHNq/+UBmTn2gfe4nI7l0oLDaOxLwOTyVjrohuHL6Mi981sU2oXcUN9tGpam5PhfqoS3NmrbB+p6tf26kvQHaU7xt5rRt8SV92NythRZrH+sKW/lUCkolPmcF9FfhmEssOKaAPrHJHHl6W/zBPjtIqPKpMr0tvHAM5eDl0Kuyjt6W02wg5/Ty2mz032MLcE+60jzVypzX5dOj6NxpEH+6jdr2VgK0dNtDffpYowoSVnS3I0e6XgrLdize/ucSh/t7hm+5vcl/BnMp9a/to9vTKHYE9uLUIXWYzxUPk5RcR177MqyGuD3yqe0aW75NkUu9RW+HseStC4eQJl0B6hBoLnXLp7a+5Wu9EZ9L+7obgYsspWDcpctx1xVHXt95l+jxdd7B2064lA6YAzH/0D+3j0YaNFXKggTbVluz2OTBFYHoQeROX67B7hJ7BbsSP6tdD+3bALP5fXoRZlirPTfRJfbEG6urFckuMSboEk/gfXbJHXzP5JvEYDpSVVeYbVTkNnlcH8pw7LaT9XuYB6ccBv4g0A/S32k7uvTop2lkT1sI0FyWPdGBfiwnVSOODqZyotgf7z0E2xhicg8vVQzL+vTFpYm5elzfDig4q/3FpfG537p6mDOhBcXkd4gxPgooqw1c4F3iV4FocD8rv0Qw7EegT+QxzUBQTtMTZHIVw3BfID6AsriCO0fot01A/i0WaHzXhtzAG4FoB5Uc1yCfnNgewDP2N51EKg/Uu3ro8KWrPKD9AV90+FZ0l7iG3B+/a/6vUO6dZUu37Z7cIR71zLVtX/i+WV1HGfDUdp850+dsW7N9Nssp8pFX6BBfc1A19ffJ/Ea2jSXvnWXBqNilWgUcGAPl0g4SdFxBou1DW720ZLK6NTmC0mdxTeKgAGXMsN5YfNRRNbdjLmKyArRx8dOqVpZqEocGZr9sfPk1s+IcCz4fB+YurJds9NbxLjHZ39d6jfz7QNeN8XMnlnCT2r8uegtv5EuLr+kCZRDwyO+2fF5CCY9AaSnPR6dQxgprj4Ys4PhayG5qh5M2LLSx3A3xfm+RneoXnYIj8CE/vj+2ZAg16JoT785pEscHiho+XkENerqO3ksJTg9tUta5xF1ele0ajxxpby9tuumcwpkt9DYM392LbekvdfGGB/KZjg+LRHFGcK00b3KtZHsTa6EH0PPthSuvf+aJ3gw5PW0UrMqIVlZ9ZW06zHofATdogp6JbxlQqffXRbRGaxUwYxcC7nXA7TlKQ2uAdg2c34qjiHeJOnDnHU2GFtCblNg9p13i636kZQHSQmI0ic/7D5PXi/aAzPDiC1SGpqZnikt8xY+pfeHHdx6QA81YAfI1j3E7/NiabH5q4DmYaZ/xd8lngS8XJAy/0w90US6x3E/3U6XM4al+upRZfHTKBdx7g/b45llaswJs0r8GII+iA+p22FStyWqoGT3SM9ivJ/PoDz6as9lrX8i1IzTdh/u0TWKmH/ko2rjm6fBNr6Rd4i5zk/iMV83VQ8/vg++aUFRq1KUm8VF/tqPiZbyXsOK5v6WgH3LDWIOUcL+EZdle129NG98zpY3cQ3Ac4nt9FRsSDlEZzCUaeh5N+DpIsbBJHOtdZ26vk18pwRRGSwznBjrwLkBtQR/b6ddxFQU5UTIOkrcuf5SKYmjrhUNfS0U0jn9F42Was8i7fochv699FS9vj2B+Qvr+Rd5Fhz7at0nc55Ppq3i5PEIgL9ieCkFuKW5e9xn7KfacK+H8umN+q+Uxv14qGkLpo+xbzV3qlLanHbUIQ48+TUZfxvS4xBQ0iW8c7c0l2Jr5KKvA92QR10mXgoyalH2mqWi8PA72yu81Md0WZQO/fpMEZXR3R5S1wCpV32M7by+V4hviXv5wXJdzD9uWOL5xgUTATrGulpKtGdY1UvLxPtxo7hofa3Px6Ge0TkGs9Qa/Uq/M48WdAaoG5DgW81lNxqvIgmiY74folM21ShWX8MIFKJcmcVponZScnVXdIEQEPVDnZT/pQJZTF2yWklkGwg/VtYufhCjy1rSuWvYP/0fHs0Xyf2QR/rDOjrNCvP1TTzS72szUJbxsJLx+FsxyQW8qtKL7fKl2JcECP+RrxbNkwzzk20zGFjotqwp3xV3iPqnnrbvfNQ4YmTxNINfh/oFLfFdSGgUYveu9t2fEX183CFbFr2vleTDNhr1ptw+lsX97G3pdhDakqcpzaED+xXH4RUhBTl1T3SS2edv5468fvzFWB6OKTAeE66wz+SwFriZC3/Niuue92ZDGNEkLaUC/9GI6vRvW2XBN4Jo3yZ6xqMIxaA7dr5egiFBBn+0G/5PsU5N1mfNeatDhGvz/NV5ZK4Lq1wT/8rW3hPj/y4sjxu/nqUF1zsFz/s1fFx9wXBeXOpB+piDK3iR+G8Bbl5vFe0CW8LxKoX5ijqGghOtrexVobBL/Emqcg68Y3l6RzQbKr3oZjrWvdDSKAXKrv7w+27ioSTwBo2/zHDb8NmsMtPzdzZHMR+bu536SBmyG9KSRCcBBGKMseZD6syFMbbGXSTp3AWM/5T8H3MNy5gyR3i+ExwxcE+hxmYZ2dJtf0hyC+vea7NCuTKoMRd2z+ibxprfzVVP5fdlu+KJI6kin2da3YLt5+Nnb+wWXJVuJjTsL42i7+HEQXzWyATUTg43i2/A/UQPch1R1ZC+Blf9jpR31JSjhkAfimOiteBPPVvPrNcf7UOxIiDkggKEbxedCsm77FTL3I++DtEtVfQpU3D02jeMLT3QhttwGj5ozQek9EepsOVENLrHUc+P17gLDqJ05gk55Y61L3OrBFRiXWOaBmKb9ZgWRrvhQKoecUqakSmLON4qjQ0vNKusFHu9qk/tPzIQUG+bzUiDZZtxEZxrXKUiPS+UYfUjUB6twV1dPCbHQchEPYUYb1zHQ31RclD0knierC5gW9nm8Me922TWJqzzuQwx3Fsue7VYg9+kTAUoPKemwHIZySGVWCDVvLofKpH461AZS0ihrNYkljnVkpVxBFYX7P64tJUJd4coSzIWed+2zV7xvo1K05VRpFpcDuB8DeN60UfxHUGUDvsTTeYpLSU6j8gFV0o0Lym2T2qk5V/n4GlMJNaDZCSV0iBIue67x3asiJwAfr6MEjyfLYVxIlda7VLFXbLhi8lUId8kVlTgWXSf7cKHxq7kN0PYvuaIX9oXSSLCtcfS0Z64oV0fX42pdJjeKG8vhrSkVITzfI59vTshLnEAJWzxT8bWhUSr7QNtHsxV7KbbWpXi01sVsDYllAbwnvlGcB/+gA1l+kaeBp2Ae2SpRb3ctUGzrmjepvWQOyKIB6tAeswpCTiJ/u0Xi+XROuTck/gL/uacmxdYO/aJBS7FI78RfaM2OCWSNa2y0/AbZrZ76mk3VN8GOXGQ78ALq8rmzI6CGjbOBpvWIbRCG++SeS0aOGmyrI6rUO3BdLTKPejsk1ofknmwCbvCHL+lURR31NpMnv+6sJO8KDoM2khueI2/3ztdsBXa6L/CNosNPsXuscr+UNQskXudQ5YXEazV0Kl2nzPPw8nnJ22kNdJ3NM9soW9SD0VxU/ulev/goYyn3LpcAsiNIaRERFjwRMKE5gnYJL5D6q248u4GqecDcjUJZIxtsqcrp6vFwNy4l94BZ9+PLSdaknhI9WCfRD2w3e5xax30ZauCoRXEwcINM7nUeZxa8cwliTXmNnE3qmxt3dpM59pwGQiVCqLlJTG56ApXOXFy+NKHP8vm46xkn0RlKSLeNlyWu0HWcy8pta4i+CJkrbVNW0JlTcI90vLKYzlQ+Q+zRFw4pnzE6lCsSIuifGsWpNSgTFlVNan+rKChGggxis0fkRzzYLlb7UvoyHW89m8oN4aKHt4tVvg/MUl1R9fdQ98izw5xf0GsilQxzdm7Pgl3sCbDRHRSvBQvtVOsuNdWaGsE8nQZ18Y7vS3MWdxNfdYBczgStds2DVMeuZxX9IYwq4ukhEGYdpJ8KYVB6wjt+r0IeF8Fgfroq5QszHLdrOTq/XVzq6xxzFRnqutt+6nyBh7KpQwmjUWz8cjnhIl7yYFqY5sfhNV4Ys8TFoWx7o3jWj7p5N52f6mkIucCjq/4awoyoilqhFDQKGBeVyBXonAXA36Y7kJOfJhmh/Jif6H3vrUC9ngg/jtfQKtO9TnpvPOrS+dzkZaksuxL6L4TsSxmUID8856EGjHAaX1BkdHEqM3o66YxBdbtsHnGfl0pJtkXbqYGCE7lPlP49ot2LZ+hA1varbEvNLXy9SxnLtMZRHvEVH95p3SgWg8+v/Hu2v5n/4/SI27yoQdYoLgMsak6s9NYDL/gjn8LVE861CzcSxn5rp6Q+DHmaRrEsGA18wrP2ShjpK8xaJ46h3wdxlijw4yzRKL4Z5Pk0GBFmQftoFDcGb8l6n2UvZmy7l+7mkDu0jpfh5KduwVWKJeoCpXVKIsMpnKp8tTAIpEW1oAygZA38/sMxmncmyvUREhtD2C8sPvTDc+J3x9WRuL/55bhxEHflXXEHkLjUC8c1zeK4I7oqygjcupvS5ljXWL+xKmfnzF4z+5vZ54VHSLgRVYoDkYpkielLG2HMNqi4COGML5K9Jn7lo40GDjVDI4RTBHPYV41v60IdjwB5uf7Qq4cSc3Kb6OScplgjPQRPvx+U1CZ6L54eVnEHJSY7QqgkMct9iOvSqqYxtQ8J7k2fPIZRJaGQwnA/zIz1NSDncvi2IGoCHgqxTQyFp9QjFEM4eUUhJH5dg3WoSnlUj3PPrtBuqZDSOOj7btZNJZh3Qp9Jhaz+xdy2bOV2c2xdmv34jSjle7aovHax0aswwiz1zFAS8p/klbuvQ6jP1Nv+nk0JIX72ou7ZTf7zSTGaZjCZacgNs+eeTNOf+z7NcM7ecWrlsBqYKZ4FHh2kZumhe4lOZUVItqeGqHapcK1Z58x4cbl9ry0iD2X5dnH/EYgz7zd+Unv2s7/Cl3r2Mp8F/65+EHn5CEMUh+0yC8rg5VAWoS4zRAkR1DpzhNP4YgahTk7plSMYzwV17iW09QWavCvLajBNzAOpapiTFaZGtrsAVQ3WtdCqM178DqjqEk7LilQ9+xufHBvRstmy060pllr44v4t64vXufsX73SriheA+4S7XzHmmQq0Ttv1Wrb2Z+MYXZVXjy0Odx+Qp9kBpd6uIzc1hzQFtdIxE36PmyLge518BdOEtkLTNXGLF7XijlxVjYlaZ8pJyY+9nypx50apuJplTXThsiZd4Vc3oigcj1fibXetU1WvLEMtBK2vYdmHC9TCPcF6aRelFhLAdoLdKxhRoCitWEaV4q2RyrJJ7cXPUEaMcdqLmrJUTaQX36cWJvXRr69kyInmRL1qM9K6KpikX0N0SV8KsvrVxPV80KBfRVzPBJP1JcS1NNhPH0FctmCqniZx5wbT9QrieiI4QK/cLL+JPUjPENfDQZNeTWJMCqZOSLOogGNUsG5xcUBV3s8iu+cHZgA22YLuWYEp4DYQ97RAAbhZ4p4SyAF3EnFPDIwGdyJxjw/Q5X3C6YwNKMrjw+7RAWV5z7B7eIApjwu7BwcyIW4siZsWiLFkEHoiiDaSW2SrD6TFaMZB/c4DUwxmM5gPwRwD8yOYRjBBMHHQJ9LBZIN5dJI87jglhj4q1AbqJYk6KhwH2w/2MbApwB8GWwP2ZwGsNy2MYMsDDcsiwV4WwBrUgGtRoN4Va5xtm2F7yKbKwzmrXYx1vAdt/CCYw2C+noj9BPtIBIT/3KcuALnTgNrI8+fWuroajfNwFKdqNkA4HE+VNlp/YXH8+Ntx3v2fcZ6GODiOIh+8aWISp0StiuFRwP3i24Ib8yOEv0mvQtxcVhRXSyou3j6UwxXJL0IfzEPcCoLTbkfct6Hf5jGtUyOolDQORqZC1pDFUf1uiu2+NK7WlfRIvIFpLaFuitcRlrZaa6V3wewqRPxuwDfgm6OZ8YZa19BMDHEMfI+DqS2slZyFTGs9hPnBN89YK7WboGeBj2Cdm5/KHRVe8c7Jr4UaQHeJ1wpuP3EXe58AN0XT7FHhWe9McDM04p/y3mjpqq2FutnpnqplOl4pCokuP+J2uh8GeAvAv4ThQi2uw4XEc2F4AsCfA1wXhvMA/gfA/wzDuQCfAfirMJwN8DWAHWF4DMA3AbaH4SyAlQDv9eNt2dTb2W2ZQ2HW6oguUgvb/QihHgJihgHmTf8OyWRaKxVlZuRnw58M8T5irHi6YskcW630rDJl+XRrxZLHDNufvgKY6dYrSx4F9yTh5Sm1UgmU11ootw1gvw72ZrDLwN4N9h6wD4BdCfZnYB8Gux7ss2BfBLsB7KtgN5pYA65i34QRiQ3LQVQN8rxMYYzme2hHXcE2ghkBxgJmGhiKOml+uvB2u1xZpZ9gtKm50XbWwuYroVc+4aOAM3JIk9qfKLopPogrkvaEAro0oYAqVWzpU5BgwXH2YDDFetCeAdJluW3r+BIHre+RJ4mKkDpJe6G7BeaAyRKMR1Sq8gLq3ymC9TxrY+1K6Fn4VobRqmSjLEy+W+zvo1nUg9TcT7H5s2I02P8ZhtK9MiVG8ziYp8HkwD9tm4J9nNb3hFz+HWSSup3vYelB6FX7ePHLUHeL0hZD4KCXZnEdhTKY2xhaEhOC+HpKtIXnowldqDsZQ3CRFnz3VRI/DVAsvl2MeT3yeyyhoTu4B4XzNoMtVA10K16j9V9UVgIFf8NbH84fLPjY8jHJs9YLPG3oANCwj8DHCA29JFq/B0I/H4xIos9/WMDztP4DgJcF1QBXFFzm8wxdmhU0at59HMpLhRHCmWekSndYtuUryWi51Vtu2UJSLPWe4rdZSvMRu8l7CUapzfmnXJRRwb5tcYtrvfFbG4V8fynRu3iVhCr29gbcA/43CG4twRV5+wBuuP81gltJcE96qz0bTC/lbz9EvaVg10FqjwNmo2lFGLMaMA8D5nXT8jDmZcAUeHe479l42f3XYltL/+JeLZu1jUKk/xTwyfEtOnAr/c+TPJ4keQzzGrjkvdgSRsF/KrkI5zwLVTaL+PXzLrW8zqcDXS7fEhJnGsH38WYA7rLPRnAPE5zOOwBwP/nmEdwkglMDbU6T1TKBQCFPtedH0xOWPAJJANWbZljGEajVc8k9ZNFO97Timy1U8TXgKHoC3QHgNE65FcWNwl7fFJLuSBL6vCfLwOxFLZCGYBbQrHFmGai3hubfS+au7zz5liG8Bqj5m288iTWAxKrxRAJurS+H4PoTXJVHC7hi3wMEZyC4/UDZGNMYSxKBdgN0v2mkJYFAOwDKNo2w9CLQFk8UxJ7hG0ZixxLc654kwE32mQiuC8Gthlh/M2nDdZQOdfSCB6nP9WO5j8X3KsT7/SFxZhDb+duFMbfaeWdf2w24I2DqwTSA+R2ManKMJgHMEDB5YGaBWXnGed9zYL8D5hCYk2D+A6YdDPMQzGFgGgbNNyeDPR7MbDDPgXkNzC4wn4D5EswpMFfBBMFETtDbNFUjHUpWY9HAuJDgodlG8bmgOu+GODmA73l19ePJJxwnsii5j74K9GmqIkBayoJ4aosa4oUkjDc9GALJBfVW7gyvq4qcEBnmQ5olPRdBavIauNTgwtneLV4+TNVg2INQHq1gvFPkNZXL0p4Sw4MRqK+QYub0ZNz9tzcnsYvzoVR1nRa1tW0d4obQiUO/8+SFYKCiVxBk8vwE28OSMZuF8EclnQO54HGB7vkIfyppHCHxx4COQAcItCnQlUAfEOjZUBSB/k6gV0PI39JsHYxVr4PsnK2l2LkrYjTbvorVXB4do1n2Qqxm2CMxmun/hHHeoOSOuyjDaqtSTxuOg6Q6dTbyssh/DnSrX7tUidIYckwHpd2mUy5j5ilXCpj+mUeEVaGZ+ya1r5hikK7ex3JdjDEg58UEcM88q67as93ElFZ73jWp4Pt3kxq+u3XVnl2miFLkMmdBb9y8udrzVkm1p6yo2rPFWu3ZWriGnJ1IrMNV6N513zq+dFQ5mPIKh6q81KEuX+OIKF/uqJbeN81wFDqQSzsinAKumgF7fAjkIO3nvzSJB3yW/d9Aaz/lSgeTRcvc3NsekBi2o7Tw4P5TIDcAtBEhEtIdiTCRJU65BkCsMbR2f+Q+zd4yqUh5ULK9eVBatOqgtOTpU25t8TFheGCn+0TxJbdmUT1IGmVudnu927CxzJ28sV561/RY6ZMt6xdVSzrTQSl5yDstH27HtOrd+kVyauzstJZ+2y+5IxcdlAyTMaxm788tH26c+UmX1mcj693GRZvchdttgLnk1i465Z68EcNAOhtRtql3pwBuKtK7COlNbem3Mfw/0xHe5H5oI/7PJTdD/ifqoEzzBX+9e3DxDghZ707bV+bOAIoGbj/l5op/blm/rx4kn3GlZe704mopDuiuNy0C7A5Ip1qKB/iM6R2Aq6VEcJ81lbkHFOO/nHLfvy+9JQLCaSHfB/ZBSuRfL4EcVuYeRPJfCDik75JbDaNnNqkBzV6ZwggSIuZjmcKNQOHo4h3ERzu9zD0CSnfkIqDYUuYeNb3enWU5KD1lBzoWpYKk3s++0z0faP8AQg2f/nPL2ulYOiktERDzXssp91D4zzHF81rWW5JbIixPtqxbhFIilNKRU24TlPAQzBvG+EeKb7R0I2P8fEijX0sylO6g6Zvcg8F+FCjOLUZpysSdcFP71rnpfSfciu0hcV5w1N7nXcmE4wPeezb1tko4H8q0jS3tdXC5zVxawn1qyylNJdJUHrfOTW0/4aY3rnMrNs78GPp1cMLe52BmRu4QYr+JsY+G+pZPKU0qf7j0nvJHSufaxpdWLJlhm1Z6ZQllmGEbVjqEU3ENy1SCKoSvIKNkohJCQcqQvhdlEpXgCWKfYZxGwq+hhmIP+64lIfG0p2EJvpaJvtHOMinZVAA951nlEeH9wChIp1bXI69ZTPSPs6NfhqNiSWzetsVDQRqN9cuhq6W/mRLUqp+uLIkGn/R9zaLKL/e5TYFC7vHK6uvq18iNzzX3ev82ZlnsmlGunHfuc1riYB6I06Q+FKfB85J5/dXcZu5TnygO/nTNskyHk/zBm0E8y/fPwBkCZQYZ7qTjDMgER4RfgLPOi4z0MR0fmTXNKjrCSRnkUOagxk4Pa+XlE5d4ExFqE2opke+U7Y4Ifw8VNtFKBblZdHtApraM4KJraBbleTxrwocoUzzAmuo/UtgLKMxwHIfSHkvoeyEggPtqgOGOA3V+oO6tu6hTA3UYpj2AtLX9F9owh6w/lQHWXDeSx3goA4TsAbkMKKB4FuSS9acywFDHA/+rDEKioVpXlVLAcNnS1NFN4rfeXUt0YX664bZrWacLW9Jtt/MO9/fslESlE2cglTDIJ5dh0FdPasfrqyflcNNXTyht88mjcYsP27RKuB7AnqESGsnaX6ZHXvtDWePlws61vwMhnLEGeeR1w6KqQ5UMhvXiu0XGF6/Y37PNgjl9gadXQzx7U0zyqEFmzTMo9CqhS+DagiftiO3uUd3CKgIol/Z14KmgoZVF1eivJP5ZxL/NjxIpNbDFia/+4avvLtRwATlr1xKQtNiwpMWGJS02LGmxYUmLDUtabFjSYsOSFhuWtFiUtJQ2lHJUXCr8AZVxxPmebXDeu3zDkj/iPwZ8et5m3mhLz7+wBPtqrfQ9hW0115/Odd0r9+4f/CEj03pS0XWvHnqo0QsyNcU67gHpS8FeF3f6KQO7F0eEI/4PlyTmhYzq1jEKdm+z2NVbObdiSflioyMOJB8M+yqEXcjJ40SF/9qSmHDohdDLRU/l3CtL8P3Fle1zPkGeCmMU+Wfie46TYjSrwGyZJNcb9ul9k2R+8HbfFsaa2+heR8wo93TeCECt0l80tykijpgp4UqJ7uKhDmpWnhPCKd4GzI8l1dcVr6VzQ4jGpzBWJax1gAwGfiZnVQcz6/e6bYeC0G/fazC3RcRiDN2qWEhPRdw/lZjb1OC6WEe17lYcG/aQxCTkgHnf7KnbADEiSajWkuNtv0LILgB9W5fblk1hnij7hu2xQbGj+tmJ+yHsLyVPncW7uy6VPG0pNT/jXDaxynejo6qjeOWHy44DtTi37nQvhhllBuEZhBabdn1L/424plDZkqc9J2gkxKEb1xXOCdQd8Jmis4IUqnfnbEQY8bh2cVZoCd0OswXga3fAHwL8H4iz/I441wBXf0eYmwB/H8J1iE7cWaEW+MkPFtS6+hRSg16pw3ZeBTLrKv4++M9oJ94fuLlOaUtcPM8Y2TDV1CQelih214KnecRNai9ejmWzm9SJdfyaZQPzqAzUfsRbsmbx05PmphfIe+JE56E3J4/hTl/zIdYhn2aKogp4dNXyTqmdGseXupXFp9108fMwv5YCV4B2JchU7S3fFre26LzGS/Y7oMSfdg9TtsYrpkBt5oLBt+Z28k6Yr3e6u96SxfxQAyhH9uQ7azIkxpPX07pAmx0LcjiubVDJz+abwUYZpKgKWt6w980qbpqzF7ZL5n3zfc4I0iqHnpd1emFeOQxtEHzSnIc6omfdIG1wqv9+aFFqiJvvjIGYjGm1eRS0YxXYv9apWksUW4d3tr99QG1/CK2B0DnO4Reg7UGof5O2F9+QamMWp3K7SV7W8ViWRL9gbWdZ4myT4btyR0kWVZMzO6yXlKXIlwzvLJtx4bIReKTxYf91KKP+UEaRfyqji7ysUb3hGJbPT7gPDPIWKY9cLI/Zt8ojN1weI8PlwQhHauTyMEF56MLl4fRxWB7Zq80Py+UBLjOWR7ZcHvWK638oj8EQWgt+GRCmC9j3gh0B9vd1PwF31kll7/9SOsl/KB15piz3/l/lU/9fygfLvonsF/P8oY5VK3WfKetwj4sRCmpwz+vqrT2wP/qOIb7zbu2Iha7juiwD/QvfDjK+mACzkzqvTYwPot6D0caEx3F23k0oYxwz3wmv/zLCvrviBAP/LQ6OsfK+mLJAaWVgzp1Odsxsj3bOl20h1MbbEujcK1MKMUdD10dUsQV06VuHGI56K4pLsiTlq4Rp/iRcOU7BldlaFwvGACYZ12ddPR+pdcWD6QMm8ZEPFqyVXiqsdfV7hDUwrbuoDlGScByolU6aaGOty/TIWun7wrXSKTA/mHD+jDekcUxrNoS8IsnavFTNrldoagrQ+R3MC0jvPVWbpG4myrhJ6qLbJHVln0qmShmDcu8mKRr6WbYf79CITOt39nIjLag0Ud3ieiUksQbK2IfTNeCXhu8WQ0ivAPukIQb+/UxNyEgZOnjKGAIJ+iaPUBtfYvwNXNcAO9bA80Xj76mijEUGyIXFnOU8D0pdTSpB7Vd13gC9d5mRlpj7KCNVShtU+Pop8aHTlpOV9151m6WXrH8DKdoVyuSGcvKdmltCWE7U20ZObYG/p1O5gLg6JOtQU8YS6SWTBHXYO0KhMVVtlr43nQBepvTot3lN4htBrx64C6pJvBisBXg9gdcCXB/8CuCVBN4A8PfBLwF+nsCbAa4NHgV4GYFfB/hY8DDACwhcBvBnQbzP83tTGdRMzqdl0ikT3v14uaRe2spS6T0vMUY6HTgiU4xTAfZuUxenMh15mUjndjPwMyaVU5WOPE18DXA1JnyvZVAm1DlIgqht94MJZAPT+YjsVmcJSocJdors8hlDK4zYOtC3G+SXvQpvwGT3tIsXQnibfVdwnQnhfQwacNWFUsHVE1zfh6zgGgCub0M6cHVpVlDt4lehLq1akNCxfBKDOyStKcPeE6TREt0K+NfIIL5MUE9Kqwv4RoEvC75rdc+ArzegBE4JSy4U2CFFg19X8NugWwJ+1wNdWrtATCxHAXy7gK8GfDfr5oPvJfDtCr5Yqr+Ab1fwHQC+r+tmge8P4NsNfLGMfwTfbuDLgG+Zbir41oA0sdUElMZAb9Dhfflp5bWAQR3iWlNn2bxrog3KjLM15fFQkmw9lPC7JuhFbBm2ooGUsBfK9KSJKh1nMWJvomk2IE4PjoPeVLEU6+zKUqwx41NYX3OfwtqqeArr6spTWFfGZciDzl2Gu5YVy1J4hQHfa55uVggR5KavqTVTzKmZD0tGXQq/Q9rPKtK1ddibe8IoEA+mD5jEzIoFu8F3hWmKXf0nP9r4O09DLOWffN5f8CrEGsAOdeyQerNau8LYwEcYm3naAKGMnaF2SLmm94EP6Wk4DanPfXLuUxVPqtNQC8dwqWL+lfnGJ5+E/lKyOE4TNwDMHJAVU8GeDyY/ToP9aIc0wRRlV0HqO6SJ4FIaL4ArB9r4WafG+BN/0alKW9me+8k5ns7Ekp/MY+vsFszg0sMvQB8LPAp5hMR7vxzoujE2akVFq0kRmY53JzHnjAKrHDtalTHyLOocjQupU/E0V2bd4hWbJMak5/aDrc7WGeg9mySVqV2sDDSHfTJeQEwEh37t4u7A4hfCMQheZyjhEL8V32nF3bXAlUOzvBvaPIcQWh5QyLsvyZGTHpOSdZPtqdx/QIpmHb8Q/52BFh6lOtQNcgHt3z8SA+PJukoqeRN5K4s1wbgGdjLYUTDGdTVpDDukVIC0OhxxH0uhyowc7hQclDTZmyRNoUp41aOCVoUjI4THUOyE5M6RMdokj8jPe3BENlX15sw3Fd23m9dVqrguTvNNJbi7gU2D3b8u/1MV0ewKiY/V/PNQp3tctcsezfVm565YbNe/YFihePOXFfSb762g3kzlKD38U2iqQzXsdz7bgTrtqVxnvM9rerNIWU/Wx8OofGC6kZHo+xRkVI7i9DD/DSBUjaii9+KtPO4QapllvDjajjcy7ZBU7F6bAmbTx7zyLDSAzJNRE6LIum0ztAQ9F2lBlxZcGuJSBW+v4DaLwWqcr+57RF6/3QL2fjB0Kt4lh7qF6ot4Az+dHNZNfeOyVGvv0pdqpbWK5ElCJN7Bq3lEYkZPz6dL46EVNQRS7XT5Y/noPh/IcnxoVl3C9d5UW7u42V/CQdgxdOk0Dv3/RcJOJGFr7wpb7F/F0cMeHuese9nG5V+WCt8zQSh74DR3XqIKTUcH2sdazPn4PzsCn/D1bIe42cOAlGvhxkI5ib7vJCo72jHKch3kS5bsumkcVHI5f0Gibkn3lBFCmYZazvMTHQHxMQ/VupY2gbQ9wRMSZ4Z4flA+5vk8efs7w1a+lNbj3W0v8GkEvziAmtAZNporX9rGpxDcbMDtchgfNE56VGJm3WcPiAM8eKf4WtMNcYannQ+IySSXRMilt+dhntIn5IEQLjFJ9Pneli08/BultFH68qVbxxfboM3FoGbQZIlK3eXEdYKOkJ3fb4jR1EI9/wsMrmfjPiDW4c8As2A4fZzmV7BbwGz+pLvmJNTniYQ4TQfAyJ90fSxG0xYXo4m+X9YZVwlPSdBP7RpLJCnPDnIeAFftmn1GzsDJt5Ru9d2AvpgY5m+WV3XlqE8NE4w25dFJ7ROKOsQ6Cfm7pAJouVuSCpIsjJ4SevpSrD857t7JjLf0zm8Wv/bTrKahV0GibYy9lyUuXwk5H/ZTLC9298ZZbvKde6VU6n/qaL0WSmmxpE46e6Er2ZW8CfMnlVp3wQRlsjh0hdfBv6gYSvf81BjN62Bw//Mi0BkX3id9f6q8N6mrKrRHTmBteXdQhHme86gm3OBVFhUpgWf9qCuKaWL8qpWxJK3elj4FuioqNa5GB62X1ouiQZJ3VnsS6qf5r4kxnjiL0hZL4Mnwh7x4wCPvrN4kt93T57tYeL5LeGf1pjiP4LRkZ/WmqA7hzirS/ziYZVPlf/jz3urbBW8/uGUirjREJGlqkriygr2V0A9pE6ep6QvpnAkxSbrzb1gyuTcIJdFAWa20CSh7jcAMoWyWhyYn6mtC6iTF+QzuFaDslVuU9cL7x86vsawkMZp9l/g8A7MXW6Mg5aWquEiy9/qS5Xmy99osnvcVWxr5YstyUoKnfZdcjLEovOf6nKVZ/JdPu/Wa8EbgWbIHt5CEOu6LAty6QBHBzSO4z33RgHsxIO9tziK4A75qT6FpZniv7klIrQIwD5mmhjFzAbMdMA+bpoQxswDzpm+HO2bjZfcTt/ZcrwmTAp17rteE/MBUkgdH8ij2pXM99+J5sxJJ3nMdZ6HefoD4LfE9aCnmE4GuwYGJt/Y8m0Wrry/gUgL5BDeM4B71JQEuITCO4AYT3ASgbatprGUAgcb5cFfoAUsqge734e7QGEsKgUb4LrmNIMOO+q97rteE3/3yvmZvEpr16SCv3/zyvmYcwfWE9B41xdza12wWu/jSb9XqALKT39/SnbS3HwLYf74L4J16m4OPh/sO9iERxgjNHe0P9z9xPWHA1P9/9j079zWxjedOxTms0K6doLflO5RspEUL48U+L7ZZlaSBfqrJaxX/E2Rt5EwZeyPcV3HfsrPPv1r439LYAGlcE6+EOtM4RtKY+z/SSJ6G+6WFdvm8ipKNsGggjSdJGl+F1AUQR1gOccX/EvfOOXiit3MOzvN2zsE53jvn4DFHMF7VVHkOjprWuY8q5VD9LktXNw+eVAL82jDOAjxdNswy6f6cxBjnQ6ka59RUxkluxQSanodZ2s3j/JkF8+d56R+HrvH6AkN+gu0RyViIHF6sN94hS3L3BPrmIybSq3OwhCfrQ2A6DJ8K9CKwxyPDqwJxBG4Nw4NDMQR2heH8UFcC/xKG54ZC4l9DNPvpXXuvLvGP+69D4V9HgRn6t06dkVUT11V26nJFh3W5/prPCHsCLxFdrnbx3UCnLhct2L0fzGNaC4ne1lppAtHbaoeZFWX8RKK1tQLkqxgP1Q9XAXa6l25E7SHU0+pP9LTKrCC1FIKUUci07oGQfimstwXmZOFad+bGte5hG63wb4cFe2hWfq1UT6F7f+hxcJ+laPaw8EFoBrgvEvzO0DRwNxD3ttBj4L5K3KWhR8DdSNybQlPAfZ2414cmg1sg6ewNUXqmo2R5rdRO4StHUiGuZuLO7GV3vpbpWFsUENs9iLvsHgdwGcDXw/BYgHcDfDUM3wfwZwBfDMMjAa4FuN5z2X1veOW0HuDvPdTb2TdvPIQ6WleLGKHGQ8Oo3onpA5jPPTukYSC1aTJ7hbW11kp9p9RK7NxaKXnKbil1ylopfYqsvZUS1tj6cMGVBX/W2tpjRQkO5DcrSm8gu1lRcpO1strFByQWueLriteEapCJtmylJGgXu6ajDlZebgjcMeA2gBkEJgfMVDBPgVkD5mmiq5VnjqhS7KOMs4WVwPszJoXE9FUYYzhGOOsHXplSkjUOmMOJDqwrVJeqwFZDxdah3BoJElT3zLVSpHKt1F1ZK3XJ3C3FAK4X2AmZeIuqvHqlgJFjpx/1jTv4C0AX5AlSBQNShYql91IGRnjPL+eE+zldORUXB7ldD0XkU8bpMw+ZNTVN8cpWWsnUrJYic1ZL3XO0GW11RdV10/COmdt61NuIHvXxu/Soz9QEWo4Xa6pgPhtFZfzVWdVyXIurxpFnKeNx6XsTbexmyNbjfbh4XlyEWeSzFp6EUJ497s4sVhhbeKFFcxdWabzCt/4JyxjP8m1/wqqMp/gbLZF3YdXGr/nLbvYubITxC8Am3IXVGA8Attdd2Ejje4CNvQurNW4BbNe7sFHG13jmUmQB/nG0cR1Z21wPYw22AdTZAzsH7BxsO2Dn3llmDznvpF4D6Q0D6rsZzFBqD5BSu+xO+UN+w+A/Wv70d8PgP64ANvEubCSU2t1/Nwz+4xRgu9+FjSKl1vUubDSUmvx3TlMXo538HYyk/+PfwB6nqRppV6T1OcekJZ3TpBnO6dL6nd3pjiu+AfUfbYR8F73Ssn5RN8NY/YKWD4tL3MmLjsM/gmQexP8VINROdxS0Ahe0AnRHQi1fgbpHdwT85yVCA0jjFDVO25g4lqJKOHCDKYG8Z9v/mqY/501LITrtqfAtXpmB7mWDzl5294Y0ehdTQEX8IswdygZyH1L8D9REMOToj7tNQMnqoFzyMRA6BloeD+WiA7cOqPoF3N3A3Q1a7wVSXrgTQht/IlRdIfXuzc3MXDMW996HgwHYDDCUUXFOZqYSbC/Ya6DsiiGc0ox3GykMDLcI6vyeIAs9htxSHKSghMj6HuDMxJUEuBzi6h3UGSYTV1xQa5iil1daSgzyiQYthFtMXKogbSgiLiqoI7YptNOt15J3pYKT2r2z0TUPcIkEZw/GGF4m4c4HxrYx1BWxwdsjjKkLxOVdEc96o1KYtu6j6Pt6CCFVL+dlKbuEaYu8l+4fL9E7WS4fQq4O9JTojM1mxplPZvjPAlT/R8e11FGDrzjxPN1wfAVyPbaZAyNpyjkN11RQT79Qta4Sb8S412ddphQmBOul3ZRSyAtqCxSlxmXKspOjZQ39VE7W0G8UlT721vrFjBqq5hG9Asat/g9ulvpmMlzrzJA4JlAGbmNuqRRpXG02ONfAeFoPM+Fh4QV/mSSZYJb7S3c7hvE5Pg//6cxAo/iQx9ymgzxeiR/brIygjCdc1AKYbTLjjDAbmjC8Vk9nlvpa22hfbCb6SNW/xrfOfAvywTRGQRomT/bNw0NficdVNkwF0/gPj2Mr3hWKmhEXqcvSyRIwu8BUHhZy4J/rgbYHwD4L9miwG8AeEZRpzgS7EezBYF8HOwNsAez+wcR8LDM+kJAvl9qv+N/d42F+eMMD9TMc6mwk1NBKlsNX7Oz+HhI9eo1ZzTFOBWAKuVbxRc/i4k+hzoYCPBXg5Z6J436rq5dY5W+CJ6jg1HlR4btHW8X5DqqmU7c+F/5nMxisx0fBPDtN1rtTc7F5sZMuSxNKWsWJnuzkLinyC2HL/cCLwjzbKpo9vx465Ou4ofJ1N3YXQt0UddmAHeGhh+UNaKxj8nAnsVUcDHl9Bmn+Y5p8B5yuCusJZ80NfiX83z0e+caskFhbUyHnTfTkGO5UZaP4lIR8DN5utg1mu83m5NP1UOqHheu+140JUNubJJMpJKb5o/epiL4cCzN0hGcD4RzPB9PVMfWLI7rVy3H+45NLe6YP1/nTMyfe0rTZIWWxO6QRppwmhXG3lJzZtXyHNIbNudENoH6ZO6TRYZ/UTIrEZEk7a/Hp9SrSQ1wgKY2orPaM3FXtGV3UzfvajcgW3ahu3o03NDBPjD6kAajaM8R0UIozJRzSAq7akwlQPIHQbzhAiQBFgl9vwKiaqZSBh75xxAO8H766UaWOTY4+AC2Hr27UDEdvcOc45PZ1wyv/4VJfGS+3sCYv9A5rkp2+H9q79VWeF/8ZOuVKpU+5RtFynKpACYet8lXgHT8J6Jo1irHNkcrDLf/cLrU0bjzccnJj5N5TrgHAPd9vLJM0yoPSr7ui9mv3HZSuFm1yR24/5dZu3OSO2nhQaqg8IjzsqXcnE12zMnfS9no3u7HMbdj4Tsv67chtdmnN1pS57ylOa4nYjrptP7es39ildWrkhE/K3HqQqddv3AFzxjsEu0Fb7zYWV7bka1Nb+m/8WXhAQv50k3sQ8Jo27c/CCAn5003uwYT3/FkYLGVzm9wmbUA0+/LApQPKYoCy2I0BcaQvPaxVdpXoheEZAqXwsb9n+ZBS1EHoVT60NL4cePnizFLUXquXNpvuLb3RElFcL5WZhpei1DzXNqJU1uFLHSLr7qUPkVqaiO5erftk8eGWf+2TWlzbI/dq95VwB6UBQ7C0TuGMvP+gdK3wlDty3ya3dt8pd9T2I8JxqR7mKLmc0qGcBkA5DQqX02dQTkWRZe6MP5RTmXvgH0oItQ47S+eMUBlCbnyTO5uUzhlhTwi58U3AxWPpnBF2hbBMzFA6n3oLwZUIpdMXSicJSmefd8x+KJUKPFN9yZVKuHSlcI/fUJ5TaizPLU0uH1eKO1V5pbg3NR6+bCZXWrHkoDRo8gxbfimONKs4HLfm+oZyo/bKI9fjRDMu/Q69OdRAjXHuWgIyNrk/JaoO9eBQP2b3xxVLuuZtWzxqn0tcI717rVObrh3ap8+D2nRbdRF5LvEvEqZxpe61a2g/0L7h45+RfxiNOjOoQ3O3tplyWYYjG+jS+nDEOhMoAvdBr6xthuPzDM+ftc0wTLX3f2mbyZpw2Md6+29rwu0NyP2um/9/a8LJe82XQ1Rqbh3qg152G6D+vkU+jehojLyINX7ZnbToixZq0YgWLux7jfimX0Td0DvD6y9ii7g7XM+LqB96Z7guF7GlPN/yj2IBMO3hcN+HaaRZP/A63xweev/2bdvuv1ufUEl06bA2F3qxBIcHzhAoyivr0uHc5pD+mz4hhurj/d+6dLpbunSFo3lRH7qtS2e9Q4Nu9x1ac7uI1lzvfJZTgOwrl/dcSZ5nZ0nyPDtDkse0xyR5np0iyaPgJEmeZwskeeQfL8ltfJwXRwSlMBb3OoTXiQYAyod/1KW7IW4IyLp0QtUHlQyE3BRUcdlhzQNLniB+FUjlUiqF6nj2hvhcoFOfTinM9zy5gBokOBG/6A78NA+eNKIGXXFi6/nViyvSnRpz78uS7l1ac3vYsKTLhiVdFiVdWftNfUsLIhVoeTEwnPuCN9r63dKA20U04B4j79tgL33QQ/YvFm4dz7S+q8bV56BxrhF9++Q1iuXBWmkrxTpwTV3BNom9PLEggcp9egjEfH9J+UKog9YxalxJ74wbu7dr3kdLGsWXgofnVix5dzE1YGX7Xz6JIFpvTWKHlMItvUPv7U6dt4thnbc/6ruhxIpvDQkl/W/pu9WH9d0mEH23MsDUEn03AyfLssJYhRD9Jeq7lZmHOT8j+m7oH4HzLPgeblmgDYmvHkbdN4zdXCLrvqH7G6L7VmY+U0e1rlBs/oOuTRHqHpFQ50pQC67M/E3dbQ2p6C9vuwOOxRMqIJyzZCrRe/u+xGYpNT/ufPLBz303bn4OMszgZceFr1DvbdFO95zin9xmovdGJaPWmwpmyBPSyexOrbMzwqv+TrcK5r4zwqo74N0Av+D/yT19451xVDB7nBGW3hGuFuD5d8D1AD/uH7Tg5P0nXPHzepHzEEYvxXZreABo1znpYRXmD+tkvbW85dENhSZenByg2NQFnXp+Yb+5d+q0KYlOm9uJGm1NRKNt4h/0jHAUtkl3ahn9TPTZvuadIHsHwvpKp/6fem2GP+i1Jfy04k+6SduI9lpvTq6Rdw873Sl/0uA6SaS8Lfz/rdP2hDMhrMM1NqzDdW9Yh0shnD0m63ANDOu0yW2sKBvbWFBsrZF12x68pdv2QFi37T91qtY9iuN/aF+pqI0Jocc4ZR237+tk3bJrx/5fum04NiuEY6H/ob0FvEdnyd7g9/yppK7zvcP3go6HUsJzWeo/lNKvpJTOhHXb/nS3wV33ESiEk34cm3d03kcw4+67DG6IV73yONp5FlchnAn8r7O4FMTHNO48v6sQKv136nwJIuP7v/TE7tQ9UwjBo3/UTOukowfQ8VYgDuiIK5g/l0qpdfUeLmt4JYBEmFU4f/5v89dK1sKu+TT7hfCzv0u+dQG6fvRH5e9akMp9IZzyxxsaFqD+1hiqTVQG8Q8mz4zRVM6K0Zx6jaamgnsemOVoqqgUuh++BW8tLJGyrMeXKoQjQWqLkWMsEJ9O5XwiHSD6TzVPZyg0qAWVZaLAJx58+sG8GUf02FBvzbAM58QYMidG+huWds6Wu57S2BvFMyB/fyHU+XfB9wd/A3y/81sXd4bBON/K90PUIJ3rZ3bW1Q+krrqSusISooECq6kE4g8PWBeXSSN1Slu7YcbCsQJNo+51nh3TriL5XA0sExgV1glCaQEPj7dObKjEFGC2B1z3AC+u9+DuEsZ6LoS7Z9bFSpuoxxkpz4HYN/xI+ZeYFqWp1FXnrFCsIOd83MZF9e606cA/aS+779cm0CCPZa5ekdMU2x17oPKFr1fIOPMLMk436jCMFTjGjmh5srjebVh0rSUCWrppUT9o5ZfdgxctaOlHuK0yd+qiWvegRR+0rIc8+k8/5VYver7lAzwXNB3igH8/jAt5J5MwlRBnPdjIl9UD58a3qIs/anlFi2uTa90DtdaW/sWn3Az49Yb8FxSXtPTXXhZsAeRtcQ3VBCMFrk2xgN/kVmmNjkXce091hRlY4UOt8gZoF0cDt7lnLJFVfop9Dtp3/Wnz/RTlHX/q+wkj8Q6G2vSB3+YVxGmkqlmRKq4nN8yZs7TcTiX3ag2NiDyNb6M3QmoPBfCmRnYYe28bTw3A18K0DN61gy3whQDOA5qQzg5lztzg9y+d1F5cNDWnTQyF0CcxhLdACnUKTk5rAKQVX8Mm4+vnCcwFPnS9e9VmUsel9pCoCtW7egwt74PnYrJYi50qjST6WGNoivWJb/nwlifkSZzBMmzbGTedFUuv83J7B3m9BtshtpWdAWwN7wbmLo3JA3qenpYjiFGehqVdocc+Ajz3Z9RV4Y2ggoviomAsCAJ3dxgwrxBMBGA6pNlPqcktAoL4+2GqxgbjSQmYTWA+BHMMTFHV2oUqboy9vyU1H2+k2emn2d9Er2eNTfFX+iXqxa3jlbYLNjXUwFR7ps3EYd/JWJFkSQTOxiVugNGuV8Mx4O+KJdQVWWQbAv91OnBgNjWg1dmpJ5Jl37PwloYIu2c23qZos3WIGVIOjJ50XZTlOB9FdlTbxbUgIQA3er5dTA1FWD7j28XkEFDE3w999ArwStPAXjpL3tdcOwvphxp/kP00c8Uac6yTSs5cud/cyxl9VGGM52Issfku8V6/ko2xdAPXEPJvr3u0eSFxDdboQL5u+WIqg69DTHGIybl66Bf+04U4kzNcK0+xPN+updgTj8t5kzPgUfieTDeLkjM53lz4pp0yJrKUTwkSTsyKVeYOZ8zKbeZIp7y36RIlH+Y4xUNltNVNXkyltTlp4zWS5kdPyGniuunfKkPiTyFan21rF98LRSRFnJ9imUJq4yyJn+lhDeq9HeJFiU2lnQ9aBP5BSwEp/5M+7darwqZAwa19d5f4pS8KcGsC8qngsQT3mS8acC8E5FPBYwhun++SS20cGdYouM/iEt/zaQ0w49O4e3Q8qLGPtBzlFQasF8R8AZh7LYf4y1LjrstSZcll6fBmqL2USe3eOWmcYo/inU2SrrBdvBjaY6adAyw7eKQ6i+sQSwjdaZYy3sjhvfWY+2JCuSlg4QiVBDebUN4vEG+5jXuMUJ4Y6HMHbiKhfCwnU97NQg9ziTk+1YDDdUhndFDJ6ixKKP2RPoqdBf3qzZlyWf97przH/hvYHjBdoF5ZMEPBTABjA7MRTCWYH2/EanY+jnNCSIwI183pIAN109XSldSNltTN/PA5/3axP9EE0Fh+5zVh7YB2sS/BqSy/8fjiE+qfIB136p7oqrpMqFiYY1ewc21Rlmig+j/eXQuBlw7MXYxY4yI8V+wST3uti2HOw5sCoN9QNdiGnlp7qw2NRakBJNdKDfS/T4IyvS8GVUDvaMtoQu8hL9LbRRoZ7mn/DmjsI6At7XSP2BiXjFpnuB5N65k9zNubpPiSdlEM0lBvJst/oCblewLaxe0hrMsBlnr+kju6mB6TBZz7r3U73WlaxZbUFmojaoJcFXL9KaS++pKW9hevzPEbisHAqG/Q4ozwUct6Le4AsWRmmOFlWzTh2Cn+hFvnyl3io96d7ngtpj2pXTPZ33KyOJUDni69XXwK/iDW8gaPdMWAjPrGHXWN/OyRJ3APk6KwXn8Ed9TPFaN/A7s9UH80s/vmnO2mPcevLZs7WjMLwxXnps/C+tBN0BE9A5fY26vnulrQFQeuLsTVDVxRxKUFl5a4VGEtBBxpXWLQgflfelzWPUiD/ArALAWz8Qm5rgY/SG53T8a76bO4NrHZl5PYwzklNcapuZifGu0MicdCFHtVHBFSJF/np6b6nMtT2+uUydd4OvkqzyT/yrMFrKyFYDVxk5rWaNrEU2E9gecDCfkmSPNEGP53IJ7A1WH4nWAPAld58ET38WAsgT720FyJgx6svtjNoiOtpdxDs9X8uFytwWZrE2dKevLOpBZaN1XzpT1G89/OfjPWGE1Xq1z+91hxbN5QCSOE8Ejo9nrB+rzfxb0w22rISbo28Qmie8AaFHqFMNHz2/xxDjncyxDu7QC+QdEI0vxLnfztAuSVGoD7+ly/dby5TVfUJg7yI86pTwD+aSpqcBiftjxDWs5ID3JjJ/mH9dbFa2/xbTB/Ga2LK+YrbR0A6SAdjL9Bf2EhrhaUUMoNO91zFyE/hXzTjRZq+gLgg2rd+uJKj8J02f14cSdf1R94nrW4juVhTLdx/YGvegTwxuJvNtyJXetOLv56Q6VHY9rpfrB4Sk5nDni+eKe7AHJIIf5a091+48CvXzHex6Ym+GuLPgSKLruzF6119wd8V9Pt8K9A2FTA6QjO29IAcBrAsWH4B4DTAY67RTFyY3xLP8hnIPhlgF9PU8PSOymoBR5PIfAStp/nvFTqyvYpn1Tc4pCe8iH+NXJX9cp27hMFJ3Nv2yUsV5z/mdYlZJ1lnrGArLN0z+NFPrDrSQzv/TgGxjesrTlSBLSt08CTNM6Q+fHIcF+mqJIsMIMOnOjvOHDio4/A7AD4n9C17wUzCHm/1JnY3mR5VcXlO6OIxNoD10ooPFslS6608GL1oQ7NrEmIZ/G0EYzd4P97HcX2b0i3lJonObuepTImOOlRpeY+zv75dt+NVjy5Qnd4n0a3qsEIodrOrlpKpf3u/MnVI+c18/CzC+dTAy7VIaf4huccHxJ3eyjWNr+oevHSjE+xnHBdQCTrAvf88XQWlNPMP6wLXCXrAl/wFR3vDi0ZlX8ze+xGs+pszpMf87anzvDKvHoildbdkt1xHsE7HTdLS6ii8f9dW0Mh0Hdoa+xqzaNCYlMNhBVWKjZJDLtJUukURspA71UI1313hnLXKDhMDaRdaf49Eaj5Aamd9+kcTOuTFMhOrJ+XQzbfEXLCPb3DIU+QkBPvCtl5Fgl4ciKBbYWxAv3aUO+LyGAtIIO1iROIL/rc4DdLyeQuNFPVZSnr+LrKvrJG0xg8nUQZIvIxtQd86oK10pJCZatGwXIvZRqsFfNQF3wtpL8ZDNGBAX6xiMV7j9tE1odauvh+Uhrk+WOIgZykaoXQ95hMqbcmdF1t1FVFAA+0a3JU3iXB79EWxFutdm2BNp9KTizRFrBcYsnnwoSApgBf2tXden8w+36KjQeTCGbA7BhNEtjZD1EspDRFWcIUJGyIKlHCt7v8ImkNhkuS9dwK8AWkz4XXA5HkbZ5LwkVPnj2ioPcGfe6rh3qXqAv6bNhozqrpXYKyK6bZmY8cX10QzeHLLBiz0KuEeJEJctjOcHSqrir6nDI1uk4zgWZ/EVu9EQXgY/1FvE7upKOSb5BWhvdmR1RGVBamUtkMp6n6TSwCft8tLvYHyU7Ab+IWP1Ow1ax07krCVf7O9fSuVCQlvz6LBu9u1EB9/3+8vQtYlNXWOL7fuTEMIIOgIqAOM4CDgzXeKStxwFcYTDC7mJ1qFC8DWqF1OkpfiaJlmCcK7Bhk0tFMMYtROUc0wk50sounGS+lkoLXiXCmdxR9X2aYmf9a+x3U+r7v/3/+z/N7fvpsZr9r7732fe21915rbbT3US7Mgb086qV4+Sw/7sFjQzrcl+bdeVZyjZ9J99/4ejburaLML0Jq4AnGwl7HHJEnplPlZwlZk1EnyMMf8eOd5Byjhl2gu7hQtKOL+mM/AN6bQEMQ/6QmJpWWoTASKJDbZ1kUAb+/+jSLVPB7xUd09YuKlpHqsJD2DL7Rc6hP1EW7708hPZKMOGXXA7hPOwVjlcmB3b0p2q4WGIMyZW7WQK48uuBXkzS+tYI7KW3fy9yXwPY4XM54VrQFzU2V6v7aSIDbGqWsEsaXlgvjjSYWbeJJd8rS9giqLA9f5M+6KdVJkqM84WSPoEQtDAvaaJTu3ihEELy7G8tKdunx/EJADSS5IdyeRPdjv/CH6ZnBAKoNskWItER5osiy4UG+IThg9/CcwULGfZtNCjupGgirPMbf6b/ixFfcovIGNMTmRHkGSaSCbgbzdoswUHNWGGB86ODbVOo18aDC/Av/ln8dlFnD/gf6eHaoXRfA7/p5qN+gbAr72ZBvMGcA//AL/5Kf0UR3zrCm52lYD/8KrPLqQyNn6KyTYaepo3mXABdwif/KuxS4gCd6IdzGJAf58GCq5clbdr2MNo1V/TvJ8svOeIrxEcC4ojl25nhrRnMc7O4Q41S/m+omYOwJFrX5W6eaxp3iNzYr8xOtEbYoc5cT5cWZ/Ehzg3MilDtrvlgP5GVyYC6l9ooylYXeWOVdHw9U+sE/G+KkkzjlU/PRro3EYrKssYi0aLRLuSGK3dgonkeddElLNrkIOEnZSRdTluZOq13s/qiSc+fN/cn92lwr2+i2HvzRrajc4VYc/LP7Q+AsdtR63IvMNvf0uR9RiyayuYuAV+Dc1rkfusMOXnLvmHvZHQYYihsa3Ysb/uZOa8C1+oo7rOGKe3rtFfeOyu3uHQed7rC5kyCne9zhtSvdu2rL3A0N97rxtjVs7kaXqvKoK6Jyo0t68KhL3rDRpajd6FJCWHgtWgntPxvv4F72cu6sSpu7GPzDwJ8P8KxKvGXt4J7zdrgSgOdIKMkE3v3OO7f4k5y7BGKaIdafINZAyEmiOuoi8MtULmGl32ks8dZ6oI7zLFGNLVeVG4wtK2gdb9/HXT7pARw2wPEzjK326G+moL0P5N25po8a0z4hIxXCxpdl7Bg261knP86LOnvEkGsf0DDv2Vdh7mq8sbujvwvfs+6XaJLOKnYG+THBra7V1DrMRiGuFLmYtD39p8F4QoFWYvYIaoIht+FfA1wJ8AF/gB/yT72pLEoV3rh/jzCQhCXjvAryQT+BPW8cmcyGa1E3jOECAZI6hq1/FmZqoZPv6BXLOQXK+cGzT0E5v+/d4lID/ozCa25ZyUjoybRP+6AtlckoSXfWNbAM5bmeOIjnz3uENKMIjaPn0U8c3CPoKSQhcqMwClbtDGOCKutmuHSjYNBEeVLJSOGF+6mcEuzfRhMDq9LeQ0u1j5ZKEypVTahURVCq5GfvgVKtBkiVUWKYe7rDNalsiyv+1u3prJMDN+8RxheiJNBRIY3EbsZb0K2uu6Blh5fF1R0VRhHcNWJroa5gbE7i3i+vh2mx5Uy/SnV7hLHA7aaUifXQUm7yjzHuonUSoSLEaEz7ZIvwNlC+8UZ1cta1GB3WLo3Wbhqt3QSo3UDtGFq7nMDFZ0h1xC2NRy9/vndkIxei2SQriaW6gEC7RXm//dlbI/dNQxpeBesFWpk/+jnMZl5onQS8AcNVBWRsVrM8n1QlWuVmeQjnP3tFfTCkEUPvkSjtQhxD9Yqs8dNFP5PcfstP7vAzyfgKeT8c/UZ6i47frzfWQfjm6TXC8cJph1AHWrLTw8/3Xub/HMCT4WJWj6veI718kY9sjspjapEXfdt3/Zpojfxol0x3QhDUJ4TvjWG5impJgxP4aPxC7cXvjeF07UI+MX50nDJ49V9vdzRFz4zOl1aRkcAxVQPuxURLdOXGy/zhIEqoSWsQJqMvKaLm9mV+f1DWaG8p//IbBucjea1aev8UiTIPXGmTRvtqI8r+enilF7V06+M9vJT6UJfbw/t7Rb8F/HzIXw5+T8hfD/7u3gLuv2ajfvD8fNS4xL9HjBItapZmQhlOSdqEXzRQyuQ24ZQGLaMUcMGxbYJ6DNRQvVawg3OAOwbuOLgT4K6q27oeiGkTIsHFxbR13ad9MDde64Fd74zcK/xG73ZBxuSDbz34FEwe+CrAJ2FywfcK+AjDgm+lV+Y5LN8uKJl0dj+EXuEX9ck8bcx+SH2Ft4D/CPgV4J/bJ7vx6rL9kO4K/zD414NfCf6ZfSegnHOHS0cVnur4RcJJ7mfH6zUe/qJfQd8Zjw9C+eZ1oN0rl/HWrIs5ialkBsYuMUQ40vLaIEyiSYUV2N7bX5LFfcj3WKHl83uL2RFQ2qQgWj3V0Jf6NJCHzY+vTvzHTriX/d85UwCyk0K+AsiMwL+cGGcrhXwGkC/6mp0DgLPCtXtLb5NTlIs9MjUXxrtCDWtidIyyHVwc+Plo3JNpTKpRMcrkohglHVvz+23gxjH9K7Ykn2gTLCJ/Z3kI3wfEU6oqwW5cByvmtn1VgsO44VAijEZJtd01BqVaKxe715fJPBo50t1L3EyBaPEkiOg0wG0+F0CpIYwhhk4RTkCqKBi1CFPgqZAqmpXWXOLGCmPpueJkmD+X+dmB23Lwj8C4xbOeofCL5R1qE6Xunv8c58CfAjgmEXKZf/Tz2CZVPlMlY0k1zpEsCI8PKFAfr0ZhxtlhgdkRHRB5zVTANwZcVpSU4F2Awyhjv2seAOkhbTXRXea9fuzjDpcKaiBqT13kzgXD0Kopy9REAPXSAD6nX8T3+3Jiu9mFHqDaDdBysjOjoL//GkC9hhoY77DkOWqgVYnBZK/SKoCCTBUUDSfQDjXEezuwRdhs3L0PZ9TRLqmOaTjrGlC5xRVdKX+7RriqOQqrNKzYlabmNtfEyrWuSZUwf4y4p68L1rgmqU64JpYZgT/4i/uXMo2bqD5yf6Q6x30DfTEW1u/DdMQqTmH8imA/hlG0vbEeRxZT2YZssQYclPFdWoP/QMlGB1BTI34XvlDLCLM2onTKFT4HyhtdCPO4HOpkqREcpajZfna1CmrEqQ9DuvRAi/Cw8TtDFrepfAusjk2hUvzDTSo/bp3kVpZNcueWtcC6OsStvlfqCd73s4dIs7sjpbE2lHk8bjzbFclc5Kb6w6AXboRSf9z6FxhFf3Ef6V/3750zPNuUPRWtH1wtxzJCeaps07K4u1dDqYyHTFncKPAdo/YRDKunXls/8YQQOUY6mTFITok2DTC0yAZ9VFpAT9+uBYDSG4FWlUbYoBylaAXAZ7thI8nxWtlOjl8YxJqhDOQJoU+9BdanjUKycYvwOPwOL9+Ir2anZ3EPrZZqZbtWQUuM96N1Y1wTFDe8L77ju36zLJ+8k2gtM5flMZpeGM9DG0NyCxVZ144vrzbNdmwBLqO/xW66SQm2WBq9H/TTFqu6lzGMdmA7OYxbXDG34t6O19+yjw/PN+VPjbWhrsf3xrPA2dzZljugLa/cakvGoKI47cbHnfu8FdefCCeGH+xE992tryk9D+Lbh0qIUz6MzXX+x/Cg406co88inmR2qnBkikh1L/eKGKGk5WehpP0xI88i/YQdmSMZacK9U4XDU0Sq+X0v8lj98VbxcZ8ihmPGaCeMnTIs9WtQ6q9vlTqxWWyHH5xzk2abZsNY+NZOaJ7/dv5oSPtd+ZRn+3NrmyKuEJt67yzVKv7sJ2K5VvWc+uSPJVvVe/TKNBZP4b+j0n0SB46dJftOUD4BzyatNhxhiZ2k9een4pT1T8cpkaZOy5EokUaL8fAOmeh/pXJV9X4NfYtCOxPrcMKIYxPz3vMJwu/x77xyG/cK2+30uTakJeOaRSn4ZyiWMvgL9Elxmf/OZwSKesQXRekg0REtfr/h6x/577Vi+1w17nTKGuQwQhP7Pr1io/VacOXwv0cTpGdY9tgmO6SQQAoZm3rKfit3wXa7VEfonLmPlmAbzUFiiAuNIoT91IfWVsLN4Xk6Fkf75T5KO6lUcgzsbKUGWasY+1dnfzupm+LyZDQ28eOaUuQT6e7TPuRYLvNP+ES6/pgPORVYO3wiF1TgC6Oa1fSss0+U1fbwvmakcYgX+4I0vdmYSVdlji/3q/Jx7ZLovgOONsOI945SupYVszJol8d8V/h1vmh61ga7nCnYp7FNY8ywOqqN+bDmpCtbY1miuct8d56TP+EHiqMebb4rH3KhIRnmdIAf8WOrjDKn5aHO9Rf0a+5wZtTYUyeENnKBKw9ijjrzcBpu89/u5dI72hnfOR+UhzfasWyiGWO+BzEPQ3pLULyLG0DTvxVK/0Qx2ptQZ8VPxx4/AXkdgbjm4AAa94jzlDlW2ZIaq3wZeALkEVbpYpUvgn8juPfB7QRnrIhR/jMlVukA/0VwLfPxDEFoUvxsMBtobnP9TMqAzpnW9Lz0AiO06J/891tR7nKCLY2eIDj5PPpmZkHPG6Ue/t5eOXBUQb7Je79lWPMIcwLE+NmJJ7LfBrqdUc2J5htOvBnh+ExqZQBDegPnnEMo7K5bsPuDJ5yxFJZyCxYb/NYZTWEJfpQD2ENPejlfK+xVnyoS64jnB5bQ+cHlOPH8AM8R/CH9zHchXul08T+eijEa0Y88iIf/SUAuCc/upBZ8K1DGVpRTWzdGjn+CShQdgfSxEHdQ7mV+tB/iLK8y1ZcrHAPNscCzOfkv6dhndl3m44IovcO829YlGdfWJQOnGKfSKMe/5eOuEd/AgWRUlx38Hubeh1u1Fp1FNt4D9RgOfN32UF3UTXJ6PpvKrejThKRAcZxnLug/o8PzWQ//X7TUpU1Z136enXVt6Ys4MoezxKOUE49G9oggiyB6SfsYwJPR97HppqO0Bd+yqLDKqr+0SqulxZLq7GKmuqKYVH9ZLDXLaK8/3RdG58TVUFkym0L4pBkwG5jkhwWZgYz6eyvjlVxTZx/e+57phiOVk/SJuUnboSyzUrke34cAz6TvxmB5HwrK8nUWrMuT9K2TE7RGWB+Gnp1riHhO2V/vPp+oZSTWu+8P9Sa03nia119zORvNirVHDaB45TYrMajaO61EHxYq0W7fGLbemsp95FOOz5nmdtzdvEnQGCs4RroOfvG8DnUbpfh6bEqtlYySeSSKoe2nAMPgdkYn9RKuOis+Wzr+8N5UboOvoGfeskeEFJLKrfI9Avty/Mb7jVTuL4cUd41npR6ltN2BbSrVINzJ7ztEWncsCM3H/48+2OIT++BPofilwM9qjLttWde2L8QaY02HiTVVYE3ltKaS9nRouUlQv/2m69DX/2+p6iG+vP0ipBVTJd1KJbZzWYDKxQHt1lBKvyaAf5/7XX9IQ3JgT9J3ebcvvNOeGczooChrJzRFzpTjmJTBGArTWR8VdKSDX+stLoGRNNnmXe3JCxdhi7yfmdwOAfCvXYi60/Yuhe61RvL21BKV2d4le9jeJXkxPBfWPKiHBHYXsuVA3R+VmxW0zaTQZri/0EDaDHCTFopth/cNodwV0QXLbJgrMYS1F5c8BrmSMfGtTHIHr/fuMHkg79+HiqXr4Id690Pob861t+r4qz+ctk/RfCXQg1RYo1IYzdrL/GC6VnbTv2uC/e2iV2MfDmOlL8nYwWyibbU1JtfFXwlkXWNi3zcNtv/jxupV8jP/uFG+SmV/josnis5oO4Rlv2/iHRn4glgLmQDlTF0rpBTyzhoYdzecFut15/bFWD/EGs3qbCp2tXUA4D0YuP3yG0mtEUYbd5tUp3VLZgup6mSbznovm0jvcpkJnFN89Q3bXLkI6xYJfYr4sIwqwFUD/HKGMdZWX3Kd/9SrWaK0cXw27NHU5AK/ht4cyKwxyl8X97fLOdr3xoDY90Yo24bGSHYQxRcG+JYG0NIa2aRJlux08XUByc7rsPOPaDS2/AT5e2kZ+vNXQvyHA/UluTZ8Sah9uTzvPN/Sp6YcYQZ9MzQI8ausOFakL61rxLfahtCUakg5KVBkTS4btr6ojPk1TBKbXbR87Euj995rI28d7WL+rGVtFH9KoKhsso2Mlv9ssaIGIJd1gf97sxxGkgFwT1uE9hKkLyFOCcSOohqdpPXswt/DmRD8yB/gN/zPcY8RZcuLi38P7wrB9/8BfjYEX/cHuMMv4r+2UJRfkL5U2YgS6mKf41g67P/Rpi5ALUqSgu8SapJJDbbwr34DbbuprGTneX54n97GjJdluBwqekOhYb30ngntPeyDuh6OFdszk/ZBFG1LHFFvwXi+wh/3XtzIjKvbyxgurot26Kzp7BN0HOHNAYRMvrhOHBeSXpS/JKm8c8Di/45rCcW1B3C9ZGMm1+29uO75ZsRVF8Il4ugUEMdznFJ+00lS0XZNDR1jA/JXW0iy1LJmPvP8VEu5kKIuFzLAjVZ/sY4pAr5SqzZ28mf7pKzGJgNqilzKTaF/nLYBjjOLRTsU0pdwzcBSaaBUGv8mYXQW0b0HM2XUkodg7ku6Kxh1c7QFdUeYcdecOoXkJN4t3nRm7FtALu2tJxz/VR+e3ly3Q1pNpa3g1zXhf094m5Dk3ByOzxJOCsZytN1kZDuBP8+CebGjD2Ia7ypiBV3pOsxP84OTSTntXLwI6cPtdoqCEv3UBzNXjfqGEae1S6A0CiiVpsEkcRCN0VLawozzOCUarKOTXydgL/Y4KwBP/aL+OnJTh1OKsx7mX7ZtuHlE/mrriFxyl7I1gXXxH/VhP3T1ztz3lRBZrntJZzOxH1jjIefaPtHO2tKgAi0/We8uq1sylcXeWVKWCWugdbnaZrVe4AcIYl+pBCN9cVZlVtH2fkC45hQxbAIMKFc5DMqjA5cB7gFwT4b6AWgGXUMOW5GuDKF81gprPy3hKC1R9Ym0JCwfoYe7yJg1FsYn0XC8oq/I2mnRzdOwRfPEdKZiUhybMMc0Zypwdk3yYhm7sXmatah4tynGvs1aYqs16aHuacWdVqlPQTr5L7yp84D/aGHuv+pMYK85iUZwiu/yRrBZxcnF602j7DusA23vQLrBMDLjwhYW32g+IcjKs234IuBYlvjkMfHQv+95pWzr9SfefOwXcneDSeqY/gtZTdJ5B8JEfSyi77RjK8k9wcwOmhPWZ36xrrjWJLcTbQxtscPBG051C65ZeENOUu6luiVBfnNQwuqbGer/JMikXHPS1+oBQ7mVgf1LFLTUK75c20Vr6rxOy0LLwnmxtniAPeNjNJktxiaTVVY8rRhWUOO6RqB/haRmdjZSlu0+vJ+fY0XeGMvD8aJEgMoqsZitJkulFW/aiG50lzFXOh9W5GnZ8yvmVxR9WSRdIF2YvbBiIazMuoGJRd1yKb7M+UUX+Qwhh2HtbvnFuB5l3BPzGOzjLpRwgP1i6uFQuMbYy38cSJ2/cP6H82WeTNLLfxj4sOhyUSraP4Gv9wOpCxcu/HChzGOFr78FPlx0eVHqYtwV9vJVgS2C2tgmlBe2CWvBrS9cK2w2otz7eqgLnrNDPz442iXbAKVZXN+IkoqP/homlbEZW4jHqjwL3+GO/pKgDZogvy5INKPPHzIpW/eaDnN3ra6CWoUxF7jDwrv0NP4C5xHWsBvYuJ29fGGgxpVQdtJFqIZIjSux7Kgrjt45it9J8D0IviX0+3G2kD3qGlx2gTviU7rVqgTAcHcA75Xw3FSy8yjgOgvx8eumm1QeBXxnIT5+HwVcvXw8xE6A751l6SzaTToLMfArC76k8JVEv1DeO8gnB2vQbqVhuV0J+fj8W13FZSdcGnr3M2DnUfpSRDL9wtcaToRuhfCthl7+Er1/O+EaUCLqhqpLzrqkc7e4JJUvuj8qOeGKhngDSrBOqBd6FL4nusMgrqxsI8RNc39du8i9sHanW1Ebt3Ok+0il0z2y9kP3jspe/p/+BMg7rnajaxC4wQD5xH8CWgDPD51ufZlkF/bsFmiFNoCcgF+EboFWaAP/CfjF7zb4DfKNwIFoGBwzQb4hcAJKvCXU0lugNdpoDcLpN/ZzG/i3UEl4VRnOWoTDvkyHupJtAJvSI/30BIwCiLv4HwmLu6Vhb8IYeNUU7OE/wZZcsg/76zF/DcUbF+rhQWXYa/351EC5sNcwD/xO2IX9NnpzkJ8LvNBd7yKXzGg0jS1XZXgWuLGAIypwEaeuYE1+BRq5u2HUAxtdTfX8vxsfqLAybHyxxHqsWD293z+wRD3duB/2DfAltT5ZEst+zKrYZNb4meUO+Jb/BX72f4EPW/I/w5/8HRz3y+qmMJFWL4m3neIyAkR3sQgp1mVRTqS1rfgWbyzy/739/L8MKNkwoGdBfkRfdH5YrbivGG+k2jYvGaj8zwfWcKBGT/bqVjLa+dcl0oXXv5bqlqGec9Eyotu2DKmdmMffwDGZEv2WVml+tqBRE434anBGBH1TvaCW3dj45ZLB78vY19kqNr/ZaB4De7Ar/PU+RhfPRlGLj4OSkJuO3C33MBFkpLRbPkj30mQb0Igd2awZypIKZRnSizrC99l1K3XmdiUz+WiXYjOswEZZddFK1J8nuj3CYOOj+3QrE2n4tC7FDgyfJmjuK1qZKiTdx+hShYT75rKdS6RW2a5E6+bpUnrXM6S5RhivGdUM8GqJ9SFr1XRpHUIOmsI8DPPx6Wj2n05Ge9FJ7rI7oG7SbU5Lsbhevgi/Yj2vwxqFtqJPcZP8nUVZIZnNu6Hch4AXYBQjOlNXjp65bYlLydzfyD4qpGpqTcNOn+IK/dqV8EU+WIL9dwwljp9HqbpG3/Xr5K3k3A+ssP4jN6HoXEL0Y+2IH2OO7lQ1s0KqkUp3PNOv80kM3fYPrIMg13LhCrXTqvEqQm8hnIOQ6FyPU7uyfknRSsjnL40+nmOq5sAuRJVr8/GeY0ryFuY3H/gH0X5qo1Ws39fwK4W6xoFLL75zr/kJHVV/Krlzr/kbLwT735qQscNZ2RYYg94I2J+hZM1a4T6jok678sMiktzWpR4j0RVdl0gWXf9aAmNQrV22cNkHMLpKKU5x7c9aOoKVWqPYOmvy0sGo+bIUNTDQusd9avErsTjCpkS51aUfQN8yWqo3DPCx7HEhqTydncweDoURrahzgbUTsQ9mRwCXF95MRk2wd/MvCuVs7iHofTWTHmeXpOvsv+EbynTvhnjGUq5gX/Bp73pBzq4HKNU0XU1LAZgns+mhOB8E5SxCp7II73aKUnWakB7i263Qp/JO5/+fGqr/j9RQ/n+5hpOaspfKWF0zzo4ufn3QssCytH9+DM29yhuCMD/k6k6p9YMlT0DpN0/vH9O3ZaTVEG9IUE/lDTDnJqH/hY8eGNWq3N9gVCcvRd0hlC09prT5OI88F0fzVd4XuOBMKrk9fseViLZ+ZbvCdIzA9NsnB6w78XzTdlIoJ/u5R3vRAo2RjmG8qXujMXIPSUsVUp4Bivvcfu5AL1rQHcsaQnbLK/3y4cozJ2jaTNhvRdJbptKWFiHSiFY+LvKDAmg7A2WG9rudlaiRhHcgKK8QfpJwDMGbt62u2Erxnd31lagnhvgy3Ysr93O/+qLyVdVA85gPni2ybnSFV250KSsjqsfQ14QSm2UNitxLvCvYCWV7sZektqAdhPGizFBZ2wxjnHJSSB+r2wb9+CxqL4mlPQ+7sXYuUxClBbGFLz6zVrAQlUF5WjV5oJlUoxSJjhX4z4XfqDRZ+zP9L6xg36igb/ICjK7Ju47LCoeURhViIqRaGpJAIZpOWE9jBqqV+0tu0452bjDdB1Yt+T3tOBPSrY9tItWma+rnZewZbndQSk8rWVh58FQX05Q2DQ+9kznMPIyuKN/2FnDBCfrOtZrf+EN+Oew44/P/rEX9q9PBVMu0Zo21s3kcG2fGF/uu8Pt6nbcswKKk9m8OJnlArocv9hN9V7toP9UDO0qiv9COL47flrn72bngIdHm66NQjlngloMrWtJv/1U5Q2PV39Lu0ljULVK6L7zCr+wVX6PH9GjLEdPjHGWS/9o4CfI2wChSnZmQP8E8kdZoHo0vSi+i7pCHLwpo9HL73ea7aPisXrdzNL0duMLn9551RZQZzCPz8K6OaPA27Qqf1SvqK+lZD/90n9KWYj7v7BC2lw+fqS2A3Xky6ipJdko2bRTUag//mh/1W4aZf6CaSpjGAPnJ7CYY5Zjf0F4dizsgzC+2N2Lzee6UlxmPdxwxZhGq7JVnHHeIFnQxfSq03/v2CPMOJ7bTv0vENuvXO4pcIuoZbQ3pGiWH2nDiElHvCN8XVVNbeKhnFG2OprX+UcBWAR6H6hl5+Os+8e3Q35zhIT0jD99FYQqqZ9RF8366UWzvO3WNRncJBUxKh8BVgatHC5hpbM60+DOPCCmNeewcGI0NwuIkjW0W9W8XcpsPTAs7K+9eK0MbmBarm58DO+r72EvOpVZNHo7etwVNM+6+hQJYGz9PorD1QnyzCPF8PpRCVt2CkNZBFPLiLci61oEwQrEt5wsxZjX1PSkwumhzFPU/JgyAfT36HhIizUrqe1BAei+8+Uf7lz1LxPZGvZuEpUD3wN0Drt++c2ZTFCtjY2AX28HPhJ6Snul/9X4Ui7eGp4CQE/3NM9edsN9visqLyj3JTellUkhyJPhm9kbkR5oj80jNAs1JbncvSVYBNLtXlUuSMZ6GPc8/5T//TIxydeg+6Dfwy56NUUY/G3PrLki06yTZ0Dbjq4IOYUHF7sZ1wxmPUiHutH/jL/eakoY40D6ah6/zNXpIxJAzh4CyHIKxcJm3Bzv59X3NZqn1n/T7SBDlt3X+BXqJ45RAstqdQf7vwYG7TnE/BeTDB55pNOPbEh8DBbjM7w2iPayXvTp2t3knhewK6tidZodz+K45UPfPAy1CGawog2fpOEY6fOce+OrgD/qwnRDLVvMZJ4YO39nBfwrQnvbhDSQZU+4IEL3ijI79m/ltivfl4DfOTQXvPNghvPD2URhbjA5lFSeXEp2hVJL2LfuuQIwZK6oPvXEILYsxyeE7PfwXgPHaWdPNTkuUZ7zyNz7bO5WN02KJ5/Wp9AyrPyu5K9aOljNfMcjgdwL8ahxMimR8vCADf4JDMv4Dk/AzA3nIO5UNWSzhWv2C7a7SjBVMRha3ajXhpgWE5mXmYtpyhuDjTuauaAfU6CGsf5DnApK0Jbm/8QpvnHYqtR2W0rcLajzPJIZ3Bpg0t7PI/Hge6uBFBDWam/wKfxjQ0hP2p3M7XE9XbgX39IMk7RJ/uA/WrkWw2i1aw9rYRlb6ztz8xBUVNsJNDuDLnTn+gaG2UwYwp729eSgrVTrt/Fit2B73QHtcOstoo3ZheAd8nT0r1v60oz/OSIAeO3uRf9pLdCiFeZ571Q8pPBMYGS1/m0+5q5C9xNf1oY3/JbZ72VnseFg3X+9Ded92zuP/ySUvKzzUCGsuUMZSmLu9hBsQwNatMOBrEkWnBsNvVXnyKWLY4tjerZQuMLx7GnWDtrpGUi2+FW5r5Uh3uWoOux7+Eq4rUM9y7tzKV51bYc+vd4dBq4xAXb/Ko85Ew9P28YZVPSs/ldVdTDhiWHXzhU/nQD+9HpDVPAtrJs6TeTNjlKrQHEI7ycngfwHcJHBPg1sGa0kpuFefEe0n18Mv6v9Q2URyeJUVwpaDQ15g3Ljnpxz9fsb9aC/3n4aJ9shTmyD3ez+Vh3KfQHP/U0Bec7fzoGGq/d8Qavh0njnW+ngSMUhhFhxofcIUY4FYhicchHs3mOiUQtp9N8pWrbo5mKYeEpDWqJ2KEMZICpseUNQonGG3YjIUWhIIq/FdWZARddpglRtUpzp+kXLS2CGJI3QY+lzAYGXGGSzbu8Ol+254Vw09jdCc4Afs+Svo2xBwO/G3NfAr/d0TuEJ/Y4IX6O9R2BF3OLclYtpVN498grAxwTT2X1cIVxBsvSLJWNXz1Sfi3fpl/mP/7XH/AnAA0Wf6x+PhPhw5JcAfwXzVGPqlh94kXEIv0U/pefoTkpI4c2SnEWjVMiEuND7f9CobGDZqJ+HkfYR7uvdimOQEluDzXpW2xnftusQXmx3bjJBHvGN1Nb7rN6S+QdOGUcg/fBksM74WaAIxHLcTLqm39AppXQp9+K/QOEA9jljYcUvy4x8t31twM1haOv2RpSgvUAEUXfEz8g9Id6b6g0ALZ1jHwRrjhjn2S/PYGdoVEi7IJNiM5tEw70d13p1vyB1aejdKr2zKutaTbYW5dJln/LoVsTYCtPRl7xHgp2TCTedIiiXZ39msmaFbEdGcgjbl83UzU4BuW8sZmK26FYbmZPpK8mVe6u9wGiG+M3gv1XC+zHv73M5EiiPYl9scDfP/eeDQElcwBoVdelxikNsHmf/uHGTeC64R3CdOqWaQWZp3mT/bx2iaYT4UL729luC4XwnfOLZnLZSI695ScQ4M+c9AZfNScX3BuXED/F+B+wnclaWiLMKIpgH5G4Uw9ThBYtgjKDWJ6/GdjifTlfan0sMdEq0EuK3c0GtGEq10F+9EShLGoB3vBJiXjJbJ8/CTPhv+LPKi4nt8Qb4nKO4H7MGuvfj7ffCr62HJmpBdla9a8fy1oKd+GQO08l/emAdlrN7yi00NNOhub5uQwUTnZlgv8engNzJR1I/vEY5nIqh/GPgzmXDqHwL++xg8TSat66GOKNP9cFGcsu1BUbYb33xB3V2d9aLtOGC+xA/w6qzHAe8lPpz6xoNPRn2Z4Av2ou8+8Hl7Ndab/Ete5HXVLeupjJAhP8n6RiPW/wRN5+3dIoQZx9lknnIJQGJSoAZXesVwxPErDc+3SRrgO2YYhP4EkCTY/evHiLGwRD/RWAabloXvmEEQqy2EA0t55FYeRsjDGDMAwveHwrHEB26FH4HwzJgwCN/eG9kolhnbof/dG2wXbJNMupfLz9/qyq8cZt0EFFvjVqpwL7LC3+I+rEpJVsNeTcMm7A3yg4KbXHoa3s4V09DUO0IVEJoeCp1LQ9PuCOUDJ11GKjOnpnoMIvRqYBPaI3QfLtvrltF9nmjzI51qfLdzEyme5DvwHIcUklAuI2noPXeEtkGoTNXkzqJ2ffUnxHixNB7GStirp5JfjYFNgp4J8lf8kmQJHZUfAUSbvEnQjJF0r5FoWGm3SSJPDvJ1AaRuOFozYbT+9XOiPevEtkS5W5R/Bl4tHzV8dkIL7moYZj3ZFamLzV7TKGOzuH+Ud7g+rCVpk1hRN6cYdXQq4bf2ZNdYiJXFDVqN0owt7m8OathEqmv73cGEvXGQ79OBe9z5tR2ud8rS3SNrIX/3N7VJyWjvssX9Sy3WdWZgKE3xDXytcH8Da+gbtVb365Ua1u/+pTIWcNwfiA+1tB/22YkAGR+4F+aiDnx30zC0X5mwNxPWZw2rd4dXDkxugZhBXhOID7Vpi/vXygSIPySAJxxa8A28FRYDXxEBwX2krMXdVVkGvadhF7sry4Ym98tGYjm9/nhaziOQ00r3EahLsbuyloE4XbUohzA0VMZwwHbJv8kVBr2rgl7L7MNeg50vpJYlI6aT/mjv+mvxyaLOOv79N75qdFWJq8+GC7zLj62fc1OzaGC3QgktG5bdHRaeN03ZmjWtteeeTztcOWWbXPHQqtm12KonuwYsbnIfrsWxktva4ZpSdg9rZHNb74GwTlhX8fyBczsrocUhBPWgiXaF++tKorO6d1UaWadbVdnJNQROdqlfJ/o8NouNa509EhY+Lq0/LbQM7Dy1NK1uEqTNg3ZOr8xiP6Jp34DxOkh10hVHpaaJHuWm41ofS5uW9jM3SkA7OSddA2st7pENl69c4F/247iB+lkHdisjoH7h2d3hkfOgfnOgfmc+UZuJ7mTXeOY8VyNIdmcLsqh4WK0H9toFUv79FZEmijL7+A/Gb1YSi3arCCmlOi8LkiOm4FrxfFN8frx5qFXGEp2D4lt6B75fhWyrAjXNNXKW/VWapmEHQc+F+SfubeqN02jYwfBF/DhahoDP19fUSzRin92gkmJX+9ByE5YF88IXjzqEtsPgOsE1nhNIaZ1Aqt4TSCFJgX305x3C/s6/szrYh9azfzVFt0fY3oCwgyj/aid1FRA30sbUjbBkhd5Kko4eDHyTnJOohoxQC4rGQ55XoqMcjG4Yq+rs/5bbmZTTLBmJeCWpzMRjTsXd8T+vfXKAEJbFTGJSbjgrnnzFMNDR7AlEKx3vA98RW/q+wBhnw1+JsbqU0ZHUzewFJ6OTpnY48Qt10tZCncrBvQHueXD/83r6Mqynr9xaT+uF/3k9HfEs7kULevpgXbzBTwzeXhcv8tsCGguuihf59wMWywDqezdQb4mkvppApyWC+t4MaOaFU19lwDJPXBdrQusA0n+Uu8e1gK4JC/vXxnZbPKRYHdBZ58Dvy/C7GX5Xwu8p+P0z/MYXX+SXYTj8PhPQWG/w7oC4Mor4Y5syYG3EmmggxbMBcUWTeeIlydY0KP8TAQzrhDBLf9iN+uXnrRoIe5CGWSDsoVvpLJJ51gQIm0LD6iEs51ZYo+QDK1rrHkPDNFCiibdwHlieXDwAwnQiTgjT3wr7fvm8YmUunkGKuhT97dK/NmLb9LcL3mUMYCW71DpGkN8/hMWzUY7/MujZy3jUMrzvVgVl3XEpY1SzvGt7ojxKJX4hPBC4tDdXkL1MRg4RlOrIHBHOTNqxF/eSsrt79l5zeLK/2YtxfwmINwwoR7DVpSxLtB53PUTvPQt6ZMtCFHVUkD9Ay4rzOCwf4zyMa2coHrkj3nYa7zauwaE45XfEefsWLpRbSbRWu5JVx6m9FQI8AFKjdu6K/xrgx/UYV5bDgEE6D1OLOjHLWsW264BdIsYp6Fm/DGOJ+Oe3iuXsL8NjoTIcnne7DIW3ypDZFIs1Ej6eiraiO7nkXjwTVrM6jkxV0fvtTm51byf3WB/J+Lg1iyOmLC7LBLWepw+tz6NaP71Oyg8MX9c968AnUxAv3rP3490ZwntD+O94HwG8BsArYRHfAcBeburHGvyc/De8csBY0COZd1xoTFbpUNsO1rLPxbZQ5aNdf6xvTn//3aovGfVZq+RGpKl+LPAyofioazipKSk/CWhu0oPMDfsy1IN3oP037lN/P+X9iRsN+79tNmnx3KQvrYmSbC4ozf5Vkm0qXnAv/M4v6JFTG/c7YS4aLHhqbYeaJcrQHvcaK4ZiLNG+C6NzOcW8kQZXUX72f+3/vg7ovf+1/0N1IOR6jgwxCGuTgZufWg71KwqFKSj8WnK1wI1RJTM+ydhp1xjgvmaHwvHeNhFWG0gL0KRekScT8U8NxZH/NxzInY39HMOACi9D2dzSpoH5UkuV0GyUsc83qx/UW+fgyX7x5ukL0mDVtLj5Ub0Ga4SNeYB3WJYobW5+tBdl4NGn96KEOvp0Xrxr0y+PUb5Hyyajdh9wjzbYe/sOD3IhrzYSPeyqyxn4+0N5jXCA4Pfx8ufNL+ShbZ6IAMpBLs9bnn/BSvTK1ghqjeqZvOfMMo9aijG8/hNdSROW5j5jPiHUq4Oj46nUKBlbYi65JcVfbLbkXeIvQ8wBwDMS7nXIqaqwRnjbcoF/oReh5QnzuqVMB9cSnE1HcwfnDhpY1A19wjwrj7yDOX3l1z3DVF9c+piZVM/I27YUYYf8+L5pB7cqeLRLRl9C7eBWUmuDnc91cC8EHwxZB8O4H/o7n+3gSmhoPfgWBqeH3uTC0Hf8FoA9QUM14Hs0mEVDx9LQ1/y6Jdts8cUdnDk4mcIzKPwlgM8B6JTgJApNo9BSP7Rk4Z7mE8LHUJ4xwTE0bEQeWgKYDyVuBGhaMINCEyj0MUjRbDQ06/PjqSUA+oKdBnUcU80x0HbT/UanzhxNsU/1a/F8VnPdWSPojRJDmF0KDnVe0j9NMivydM4ksw8c2rXo2+U59uD8wina0hhlO+yx/c/FKPOOxCoXwLcSnAxcvx7Da+BvAucBF7EsRjkK3FRwc8AtB/cGuJ3LxDEVAXFqTbHKOPidCC4H3EOloben8OXkiUPYVLOESiRFTHidlS97FeUIC8uFNHD60mlFFny/B1/jLHfxT/ahbhW1fEzf6VwrHDDiy5xtQj2+rvxom7CzsE3YX7gW2qit6+6FbV1jHonT5lEpRhef418r6ApRjiDcXqpx8zuFUq2lCC0ip7Mu/u6+IVSWdaRRQy1Uk1acF6VNthuDC95oxPdMh9qjT8HX04PsthvvFAy0SzUGNs08Elr9jT6UeoiEXrDdOD9FDuHzpkjwb0G3s5httP7E/c3XApyVrufr2TouTLoH/C2CwqjjVoJfAX6ZkaTouDhpOmtl0VbNHkGSdY6vEKT05gMtrF3iH+/Dm4/vnBjnHP9nCMN7D85ZwibTPEp8CFGYnU4NewD6dNtzYl+2wO9xcF3Poay7jNXmXuCr+1CvYrMpzS7ZdYFfE5CzykOSOsYw3DEHWiZRQOvUc7TYLtt8bcIRC0LVgpxCSbKL3+wDGoLvWBUqbBOaxbuZS7yyTwZtgDH0kPJVH/qM4FvtU+pItbQhXwep1HLgRVb1tgmHidP5nEet/HGZWM7v70H+gy/YzNqFw0aUBx3M7t5n7xozvkNYWo/9Ft+aBH0ZTvcD7D5N2WFPgXSfSd86jk3A9y1ymOqzwCcyddqyhJxje2eOGpGjXb6jW6r45fQBykPP51ZJtMvP8zODbTCjtOxJ4bC6kL3IF/auFZRVJ50iV43l4JrswmdGZtw+2N2Oto/dQ3Ry4Yv7BxecED6D0QI8Ij19uEhPOD5TZwJkEUDUFkY3lo3yDGQ09H0l0V9v5XitD/8+Cq22n+qi7zdiemL40TGOysnH34t5jmBfa+w/S/o8OPbubVZJNb67eC8r2bmzdawW7+l+4/cFiX7o2S1CjLE9bMhJRQPRmYS4+7OuycfUW3/jlwTUzUzdbpP0DK4DLj4tMIpFXQuOzxFQJh/HkNdZ2hQJrTuMlevxfXDCSWOSUlO1EVbkzg4FFcPlZ4lubOhlzglBI64SLKPDd9kQutOKJ1oc/8+DejYmdLpV8jkB7v1pH0lzhux/NhvDZ0TYdCuKbPnQ+8STKSGe96TEs5mRwQioFxidrhQ50no8vwLeM4ymmd2Mse1CvYZ4tkPsnYwEYr8uiHaY9ufF9csTFoja0weM2GaHmolHLZcm453RawGir7cMOHOOLwtKraS60WzLM7A4Pg94w26d4O7J7RAu/f0iv1xogz7F/loWOM9PDURfeyP9dBd5Hd+mJam6lVIuyKBG64jVQKthR0WiJ9otWpR2c/GDvOeBz64zv5ffJuTWt3XF6vDOumghavBvW/i3/IsLpUBRqozv5OsWvZNfBG7boouLiI7adDeiTfdt4FtvRLrzllGla+sawKwV3qY6Hk8FN+S6gJ63ODVL+t83bROMjUjLpYY0el4ukT+1BNPqjVGe+IgwXb4gu38VzO7t3sfZC/zf+o5oXPyEQAVrtaHsjaQaVl4jUw1ll5LqF83nS3Qsw80MIFbIY5/UKvNEMnVUCoNhO5v7a/n3XsyTMUgcmiWEm+Pb6rJWapZIgc/yLmuHUuGtHHNWt7Jun/iCw0pHDVBRtHheUS6uPCth5VlJV57HPpXQ8j7kNELZnP4Klug/t2OJtCys39xF3z+dBT3qUhd/moY12rHMpFrLYpw8iHHAv8OZyDHRUqrV+V2AmYAxDLZETgIzHGHt0I9P+tckzusOk747TdlaNW3ksfP8w/5yhADvcJmeWIx0ry/D1z4E9+ISkvpvatfNUHbCNZra5/3a/VpJmyuj5Dyf6ccVRcFqlsB44C56sQ1+9Pa/VfES1ZhNMb7oJPT39vr0X06p7nWn2DvDcoc6h4VW5Rd7kYZc4Nkg6hQqbRf48CDq/8jaf+MnIoUft81yQtgMMfyBj65k5c+gJxg9IRqJdELoGiwvLxhIjn7//f1Hv58xpfbdd6csWrRoCuravwz09JtXJMqWSa9O0HwQRg46Y5Sdc+9Pim1CGfwR5hF5EijD+N7hecNymZTj3GNekpyUe5xb7CU1ifloN2mB5jjX5k3MJzXxZpK8EL5avFo2Pm8R+BrANyTvefB9CPEH5Q82D84rhq+PvegnNSS5VAxLjgWc93tj8/D3Hi/R4DwvzI6ldXBfF8/we54V74N/BHceXBBcGqxR+eAeB/ckuPng1j0n3he/9Zx4ph8L/PuA3Dh2gJlkoI4mcEdjftZmXTMXMcmX+G0Cvit7jv8vP7FmmTDfyGZ5frwFZbxJa8s6CS3DM/CbGQF8pzbI/9RKbVEVbGgkKWgTQMEc7VLCmvNfH8zOl72dyqaxH7Db2HpWXh2+m1QXmJW7z0Kc41y5Nztpln2RPsI+6OcF+jH2cT9P0afbc82zWGzjNYKuE2h3xCUnk3bBqWA7nUzqOack9WdnqT7Z/rx+sL1Y/4sjfOv9eZmwQv5ZQD3lydT/HPiv2CezmYAJqdaTApPyhRNwhX/uDK+TVx9yngVu6IAzfOsYGv8xiG+33039+JLz9/bR1J8P/naHNHWbM8VGUjRsBF3dZHV2TfYhF5/eh7qb1+yyuqMCQSn06lHsOFb+bpAfQ99quWJntFjPID89mDCzoOfIn7NutqldfMA7zkoMPzmY+286BpkH0XU/UvjB6eIJxfjtHzDia9lKqhuK/fwcuM3gSsrE/i0DfxW4GnDHWkWeseFZcayXNjFa2RgmEzUPZazFpnhQb0HJOJTDMVhEy1a49sRPL23BdNiXidCXTO4N/m8HSasQBfsl8O8P+WF/Q7F1BwfM0FiqbCIufJXl9y9Ih+WjRZUES5DvDKpb8M1mqeYiXxvEt+I3o+wOjBvdrTIG+a+DSfkJVmbscFbmIClB/qsg7qriYU+m3yfuyRB6MMiMF1fkJ71Bfk9wQcbA00arKSnaXpHE2C/yi4N6K8pfjLcQ/c/2/tIYLD86x1mZceccDqdYKhl7FMqBZcCyMPpSqp2gOjvDOjpPw17lC4MaWwb15Qc1zUQjrs7BFj2FTQ2SQ0H+2WAq7DGZcXJPcILCI1OE2bVmHa3lSNSWHR/RKeo5lAZkw+VndOwwcyINjQ8G+UeDYZ0JFFci4A/yr0DfYH0HU1hMcD3AHghGUfxh9hjYp2hC+xQZ2+EcYA4HKvitM8hnBCNzg/w+/3Xna+/HKLOeFWkC1is71LZz7pATwbrivd2/l6EuFtrWULagHLSxKWzGGgvRHu4iU9esJilES1Il80zzDncppqGtn5zlKEdEdBWrZex5/iFvG4xoNdWDRe4h+6WtrvhKGYvvcZ3ns70od96/wzzWh6sE3hrgSqF76QisEBivzSUvO4+76TvifnZn3MojEB+5jDaXrAzP25AWi/ocLr6E7qvV++1dTDajuf32AL7jibI4Jlssq89LN0ugtecFUKKN7YS4swt6Bpskmp1UVu06Smlkj7PEaFHqKMifCsbo5fbhVMf7Is8GLjrREizM8N547VAa4+tgvN7tEKHDe6O1gyj0s2C0XsFeCMEH9o5l1RTeSOE/huAKgEdQ+HaAf+dAaTjSiv3zLLTtX8HVg2sGdwzcBXDXluN5rgy4S+QXRc3V1Pm4Oq4VUo3b5m9bJ77pEPm8aO+7CqBqwxv0Hml3uUNgNKREpZubLZnnEOREW5KdPRt84eDrcM2DkOzs6nm6ksqXK4Q5GpswQqMrCXOrR+G9A94woRWxgp6ylRUuVZmupLbkzPzfx8HwCldkGb6CPbMsYcncIocQRcOrRuHKjxbHvnSpyxxCDECPChnlYoiz7GhX+Ho84/rSFQepzZD/XI1DGELwTcFG37XrimqJL1a6QLPPx12T5hDfwHGPDA/bpKx2CIma8fl7fddvRO6U+gbpxprlm/b5rt2QbZL4Bk1o8vXyWULKy1f5x4Oj8zebFGzu6Q7hs3qmKtw35BGVT35dUm1it1kXW5ldcs2B6bqSHT7V4i+7JIuTSxxdEl2XT677An5TgVe5IHyF9g1KiHbuwqKXmHFFz+vgr+75pM5Yg9IhLcG2TZiHv3LN3HkPOwdSaciLfIZfW0J0sfO0JbPnJZcMMFfOTy75dr62ZI0wxxiJq8ZrgFNDkiFX5lsnvjFwXDLpHrQfirIIxyTv5M1ZLs5ZvGuh52xChnFoTpUw2vjNXtQJHJqDWoGl0zOBx08xombdhmZ7usLBaGG3r1FrYWRomE5HOmMH+toiQmO1152MIdJxNh36lUgdEsph/easn1+/DnzkV6fE4HRUlGgMzKkg/+/gtpKTD28rYcZpDdvmt5+ugVzfFpKN75oigR8dTd4WtMbNprhW3P/ACNPhOPwRaaqRaplNP9K4ntWhFS7YXV/l9X3n+ckCyuNLfcrr/46f6iFhUZ6U8KOw8p6A+ejV5rEE5iPwvqqksyS1hB0qyNU4S/4Ku7Owsxq2mL55zmhyafsxEx6ZdtVxno8RRG2WM8cwZ86JK8JV/uGgx9lPIR4XblMIFbudJckSjUgl0G5QGOwQ17NxlE4MyhtM6cSD9FxgRGfszA6hsCr6P8ye6K/GWQ0W5pNHhRT1EYGo8f31H4OHrC9bP4RyM1DuD/WXHMx4eYYLaMn5MRj+72AYlrRCnNt+mJsacOOfvz2X8/xqmMuyOqJt61JOQN2xti6VDjlWXdFaYXxhQQ9Zjq+eTCBX+fW+7cLEh9YKmeDueahNuO8hcc5nvBBzx/4tcoMi/d3GCjbr+rF1xDNBOjSHpIxgYwXGkDFK2cqMf9ckOCI8mXKpdlWenv2Re9eLGp5ZXKBckZHF+crrhPuMGYYIz30EX1eS7/qROy3INz9+Vb0BTyf/U569IsNAPIyMcP8q17AqrXzXVf4Vr/y9MJZkIKwIwmUeBlLvLxdDn/PKWPlmTN1UblqRMQpSSwn3UXl8KPXTXnmdnN1gm5P0BKa1i9CHvfLNmbbsWxDGeJU3e2fSE8osNo89x9X5O7g8gVSROqSqc7LPcXo/nsyLoSd802jccvZ1+FoHcccJkipJ3QINxoy9I2arj9SpqlFfSVIXXv3htaV/Zu57nY3aVA5c8ICGo0JW/dGuiBc6uFghfne2kBUVD2N5tH8M0BU5++BpxNHBFXjPccPuwLnJ18FN86YXKDbV+8LGb2bDfEy2iX0X32N9fnZ2WPVDbDuMRQVQn/rp7TCiPvSFUYqDfqRA8d0SZV63NBxgr3fy9YHvulSMkUVLS5F0p41UGU9sJjnJSJOTpBQ4SeqTzknseHYCu9SZypY45azV2Y67pxCNaXeOzk7qvjAxYcpLcZ9MP1+2dsppGIdIZ5C2SLU76Wh4u3cNHQ0FqwfAaJixuk7IHIs79emrb48LhV2+6yT3n6DYp/vX3u7TM9CnGHY4KK977Kp6Ce5Xd6ytFpjyA56MaDzrlowTexn9GHM3YHnkqjofMf1tbZXAVDXTmF+UVySJMeWh8TADSoY5ZnHN5Vtdf4444JkdLXWEeUj2WHYE2+x5LJpp1bJy+I6DmfUs7Xsjew+70SWJgP7vE8fBmOA5blAfbZdqPI243WOfeYtomnPcc31j2ckAafLOC0EW9Z3j4oKkLp2NnzeHwjQQ/kRfNKuA3zDA2e2TUVxRLOYJ/e8tDKXN7dOyBoD81ftgCDIFsLkCW6BcUI7y/PwjQhwh2llX1VDOMRDWEQB4Vv28OiHSiPfU+O74BvBjqef9TLS4RmOMTr7Gj2du4AfaG7sAf2fTv9X073H6N3YhpmMg1eOYymg0z53f3hWui7E+kTB7IZN2/ApJIyPTncw4wtkrCrgpytEwnkjqBGd2EvQSQsLvcfb3sdzeP2vXCvI6tKh1z6diP0npqPgygH00peeuT3HmTukZ9SnO3JPcPwNpTsS01aWISHEe9MijlbBqSFUqj0QF9al/h74HLf7rH5+7G/CfdwrC7AOLpp6D8Uqy3szCPXqE9hjsx37k7hXK6Xhl1wyE8Zq9pk7I0jC6jFEbYNxGeLJgTJ5b3V9iA5R4NYtjsqTi97RmuCCO5acq+usps4sj+YkA1pJwsyqeCo3bA6uNNGQmhODI/Ue3VBnfitanhrPkLsI9UPGXFRl3A31bLZn4PKRQeBgV4T5cLd9VyJ7kxkGq2mkbXSSCsSs9jBJx71/91IoMSPnuask46GuVmM87oRQJkKLRnfUt57Z8WzvtdqpPV9/Z7mEBsQbbV9+ejStXi3Xo9VMMDYChAVNuW90/B5esxvAuv3wzhB+E8IOIo/YOHE+GcPwk4qiFOLWIo+x3uR/xi7k/d0fK7FDKg2LKM5DyDKZ89lbuE2juDWLulRBeaaT0HnHimNnin333nXP6sbvkjrNdJJmBb7wJyw/NxHQ638S5ONV/jkv1Ii+Es1Gciz8I2aGZt8YrzsUjQlYIshLo9kg/zIv6TAr5VlATyIM5xy0NYYwHjH29v5/dO4S7QukfD2HcKmSEIIWAMYAUpn5U/rehmZ0EMzsH4NcQnrXVlfpt/bxZV4fhfKf2ARG62P1G2ayr8RFtwEdDHW7BO1yJlVvBjXS/8e0BjzR6rSvqW6QMd1KFQa1EG+6RhiNlAFclUod1PqQOs64mRAzpxPvn/21eXQzNK+RB8S32D/ZKp5zjLtH916yriRGL3Tsrz3E/0298+xb3Y6e4//LjmMLv09zeXixFhUtdib9Wt6pM7yaqL10xZfg96+rQiArXQNU57iCtfzlHsjqRNhmB66/8PXX6F1CnOiHKyIzbAH8bLq9m068gNZp1hZlIuKrVU0Y+fGWrq+ml2UDXyUtPX2HGxdmnpBVdmc1udTV+txzCPtn9Bvzdc+hd+Lu7bif8/bj9X/C3YcMP8Pejuq2unRsa3Xkw2osPwm+DKFuXC+PTega+YZ4Vfzsl7QuI+17dH+Ntdb274VZciFF9K4bHudVVVefGvxu2XZFq34LV9CTX7Rd5q3fKlUCdqu/grSLovMnok282NmP9pl2Nz69nd7EFnX+kQAl9SIGu2u+cb+o+nG8X7H+MK6Nxf/xdXK8P435/K+7UUFy3j85LOu+I4b5Qmgk0TadPXJXr9+F8HBOajyd9yAXiGD0H/nQW9fxxHfzBJ579fkTH6063EkZEd18Wu9alUon8FR2P8+mqq02YH+RrD2115Wz4kq4z39O/5c5+juY/Tqk2m7beDNp6zzqk2iyg9Se5HH85ff/jpd0Mm6VV7uzmg/7bLZpAaXk3n+kPY8U1aPHu27xqZYhX7eb1fvl7sOOH/lhbrmM3dk5nu50oL7G+s4CThdd3zod2Av5VqgitdN18NFAwvQVpV335nTxJNy/xWy0i5au+xdneTncdemMnTbe2/E8hmld+qxyX+uTv/WL5SydJC/IDD+H87F//at+Ff71z6Dr3G8zNHnC9OEdhnYZ2i8CegT3RIeSApvQ8/PFW15SIIP/qIWzHra77dm913d/e6DbDuCyBkWsGml1SC78wsku+bXQ/CD3+TCXMnt1PXSYZU3pONJDUfp59Sk/Zp2LpNkHppCwZvYpva2gxTeG/aFjV89ynyE/IPcF71ghzjdu6Xw9vFzTGybY4bcJy8JV2Ao/2NeVHNGiRvOejBub+T4lyzxfTVvEfNOB7tbM+JSkQqkm3KrvDpAk5uJbNwrSaLmtCDkk/0Uo0jKbwLwhJyFFPWCM8rkb/I0JkUkLOGmEM/YrNeURQZlQI0zQO5//UbmgVbLxGykpHRYoWkaNG35NC98UVAN8mTITfCWqiielMSVeHoESL8H3CREnjDf+qiNME6Oh4AjBJacuodFmrhMZyO01J8TkYsxwwnHVCfG0hlAzjrQGIlMZyhODlexNypJ4Jsq+GY3hqDo3hmcgQ7S6T9FiMwCxZntXrjIlRpcty9rcaUyelPuJd7YkTJH/6Zu9GU4xDwkVLVKPG05A4gUkalfOWKb4Vz2T769HoJBoed9rZXzRGsnK2k98A+2tvUVG2GrgSmE2Kgl9zwmCfHT6e3W+KOZO1W5ejh71gXxLavmGGMz+Lb3AH+fMC0QtnGY2qk/nbSdiZeLXMLgJ7E8VwGWqwGafSfWwn/4Tw+jRla/m0nuMk5aSz/90Nu7DfKGMn2+KtSttVfruA7wZe5d8XRLsJB164892Nq6jRx6IFGHz1coyxXshVD2JlUPbR9GxgSbZ4MlADYYwhwtHJJwvNsL9vNMmPoRWldiva6fnNCeGE6CSZayFePD2BEFoq3pTmVAhmdcWbaMWp4rWsNzeb3qBjSpTvqXgzDOiBWa461fXw/xCnRWlQOKqEmUZTSZxB3xqni12eXbLmzcSyyBRlWpxPWlRrunhMee9eX891mS9WGzFq18Ptjoo3TSVVwgz1VtegMuXkfRCWkMNwDDPrLwifqcZx+7ga/QVqcQybShzxjb2Fmv4zsMWh12BRKmo1jGqMm6+OzXl8+cfORx+ZMCWzCV8oHW/Mfq3itS9fswuNRrRomuDAVn+pOVLTzbuCcrYN2ryg553Sbr47iDfiegt8La8tRz/RnqG/tesTVme2iLoVMWwCG+DD/SPo+YNuvryuaD5JRWureALR1qXWpbNrBWMhtC+4seDGFeKJxOVX6Yutr3342lrhAYBMKdwu5Bb+SSvzmEk3P9GHJ3f7If3dui1CPL6rXagBPB8XtnVlPNImHLCsFdqMaDdJQ888cWxUCQ/Qc60p9FzrAXquNUWN59CRrCWhfO8aU/hpGP8Rw1boc55ccXhvfKk+Z06px2mkth6HsQn5e4TIQnzRRlJFdINDsh4qNbNbpo3yqKjcwOngXTZm96iQbvmxoEIr2aWB+l/qU+gldqJBGQu2WQKjHqGn+yqGo42l604xRYC3960zdTvcziwob1gTviAgU28UFJqCnoplTAPe74t36f3nOq5gls3AHtFiOOa4PnA4+3B0Zsvorp9yGfre7Jd/zbomM1WbZKzabjiVdU0+sNpEuA3l+25UrIo6Joe1Yh3416xi7DLD/Y6iN58wpJ9+Qlf0WlrnvhvMqptoPQ9Sz8ZfbbUpw5H9ZpJhsqNGMALtfcBeI3xsjD2k7sy6qQK8c+2xkAMzv9qUifGXV5uS4VcF6dUO1PGXGlbSu+9XXnnkGdM1BlLcbZefmkox32OX6NSd2dcYSbVppD37JjO22nQDctMbhnRmv6njlNKHgdPAO/lM4ylnFeQf0Ux0PPg+hpL84OhwZr853mCDvwMN3aHytTlc8B1n2OHMKkH78SL0or1US5K7+TjvfghNMfwN/uYYLtvvM1xwFr0pMXwfSv2DY7uzgx8cOAFjNG4mGTmwWxGR3R0W+QZQpoppimMwdoHGnv8rtns63r0YYzov/nX+m+TtJw7W7UVbvhLNBf5PXo9TSd8Fu8A/6gUeQIOSKvb14lsG1hfEs9dXXxD1aWXsgZl4QlQuGOur2NdZfCc++j9vNfafC54QDhTapw1qTU5j0piRySPJ6CwuYjWzW8OiTcJvBKIO8K1U5yA+oLPGJYtUDL/VAT3UWgHczObe0wIxKqsLeqKWwN5YotgFu0rVRiFDc7Qrcp+K1esUyRp2oxBff1RIatwjpJTuEdIse4RM+L3XEuRXBpAT+bqc6I5oFVRi/kE/0R++9nl5fw6LexEvYkCsBT2DzYCzAeMixqOCpr4fK+R48DbmGRRz7R2YNX4s6+xpcvssOj9m+aGO9RAOtQdKIN8OVHS7YLZsF2aUKnSj2KybCjoP8QXLlXa0a9EP8fURfWm7KEuEp9FtRvHdhplATaJ75TrAYqwB6FphhhHDHzSOYlN0pmuKqZg6CDWcZWegXP2Q44Avt53RwjinM08POWbRGP1z8V8QY38r0aEcwcfGGjpOH4YYCSykoTiSApn7ikqIIa5VriVaRgejnxH76pSNxrupisFvZWCzjdB0KprugH+O7YCHiX7IjrhhrGrkncwE+Wh8g46OQ3pbzIwWHHrtLBZ75H1BpoP+MBb0lD8fVq1oiKN93N8LQf5NqN95+2y2v90X9M1wMjo51JahJfgawh39ZacxPgfIkX4IlehtAkgrhUwNxfkYIK86mqjtCXqXqt9x5hNn7gtoaxPWl0JmNL44Lq6pBFryxqwgv9ZPtDk3b8zC9K/4oY8VRDvt2g3aoi/6yUg9lUvr5icI2Od63Vh2+jUFLeNoyO2UHalhP4TpO2D6oV2vRX2Zbj4J+IXDsFLMN54QPoPfRTByZhTeiSESMPzzdxg6fQdMn7QbWLkWKNL/w9u7x0VVrf/je8+N4SaDIKKibmYAR1EbQRPDCw66hcG8pWXZBbN0xDTLUxqejmjeyyKhjlmWXU4pZjIaJ9EIT1mZZc0kJgoIlbJFhLNRce25/55n7RnBOuf3+bxe3+/r+8fae+211/36PGut5/2MQBezt0hkmWMHs8wfAF0iAg2YAeXYRk/AthQFZ1tGdK598NZse2kdzraxdLb997rgbPuU49FXFudCCZVM8q7ZCm6R5TcyWTLykeViFc69jHh2rTz7MqK4Vp5/73MoC+zSLHoSZJemcQ/Q9wPczvl26WGusW1ugTJwWjYlcFoWVmiXHuWUfzgjCy/EcPdy5+drChrJB+5v8OxpNa6/eOYUE5jPGfGpdcEZHXeK5DkduYvgrK4veL9A3uF7T5BndEY8tFYTmNMZUbGOSX5NkGd1RryxVp7XbzgYvXo7lMOkKrFDO4QlHnJ3XFeWFEtPmoqlZbp5DFI2SlGhDM/eJsWalHvxHFXF7ZlSKi0DqiRL/HZtqfRkPjM8S/xyLdVpmIzjF9sTZoR8jQFqVREc+YmeJlsaH2y/2R6YJa7J/WuaZ5VtCB/sbVM8WfAV7GtZHuSoS9biOe5IAefoB6Hfoiz2+EWZI4ulR0yKghgRd6CkomLpYROet6HrGyHmamWBiu6eyr7ejMYcNxWpDejHUCDvQhgKSqX5HJ5DGgpqpIXQovh+FFoU38ugRfFdAC1UIz3NPdI2sNBQAM9urTuItm6N9OytE9Kgazi4vvwnVy24brztNBVddeBa+CfXaHD9259ce4Lrum6uqP3jq7YYcN36p1PaWHDd/qez2dDCUmmOSQmrg3LIBMcDIePOfAoz+PvXnlihLSmVZpjYzBB4zzRp4DnLpIbnPdBHmJRSabZJWaLcc6oldGH4663kXWk/PReZcI4trgEuUVGSxte0sCvkc9aPcgwF/3AzLJ5HcFCLD+iwj7zqvt5hb1EY5sRnt/767LEWxb3J0PdTXPK5K+6qIUV66+yVw5EAI4IBipRR81uaFalrbnAHNIZ+ArajogDobVM/oet09SxQDwmTGG69ZGFeaFYCdT0bd8k4O7TfO20vFHYfg3gSrS1EP8/RPvBAczmMxsa2wlvjt+u0uxziCYYVAvUYWTixuVh6yDQPahBCBmoQtUBhDRZDzjTwfABqsFiaR2uwWHrwthpkpAdpDRpoDc76Qw3e+4canPVfarCRbHRCrbFssvNSV01cFyZDzT7nxJpVJF+9hDNUY1v2n+YmXSHOYX8scXQhznB/dO1ZiPPV7fXQ2HZHAfa/4Ax3e/+zw+hR/qn/KQtg9M3IXl0EfAabnr1i16XsV8amhtsnQevu3a8sKMfZdAG2zBru/IKXL3V3Wcl1Ar05gmGNa26s2/+pZOE+lXJMO81rbvz7E6QZRpiuNAf/P33b/8ZPlIZ2gakOnoPhHijOI+wYHQ8c+oR5NgWraM1SKCYpWo/1VLQyejD5c7NEYfkUqWLDK4OGITI18JSasNqVc95/JZ9ylTvM72+SeUqpyjgs0hFmQcykM35Vh5VVAO24h96NPeVHm3HcAH2FjF8wp0H4elfCWrp/Afx0GB+a2oPS5eqExEGmO/MWPvFcxRAl1U4x0sQ2nR7C2pnkMU3IBzKpTntoInCJunOb461TE+qLzLNF4dEhWeIbRQpDsxAN6eU5lYYvNzZR+2TnVy9nX1Hov9yoMpylLmOB1jJvclD7nc7sV/CveZOffOjE+zHPAAeC9JDGEEJTxxsr6DPRiStr2MQXzeF2pJJeNEfzYQ4/yZUY47y6A/YQwx4a42L/TcFP7pBQy+p4U4n5bofW8KaAPF+JWQP+B3nUlDPbIjkEJtkpYJmwJHcnNEBJgHflTm9WpiY7oq15q7as6qdQ3shaEZ4dsxa52v5b3txc0H+nOa5OM2r/QSNQFAW4A2Hqa43ezBZtX7VuuYbHnYlWch91H5CPz13IEevCtny/WZOGPeGBA3gHIdSqhNUMczJJmiHIdxi/Kn+RV/EXSINfvrsQfh13V3BXBbHHTaZMW6mUZkqFZ/ry3jaFQdG0v3IezwyK7Fxf6NJbJM84hoO4F8zky6doBoSeT7CgzvJfST+8YzAqpIkddFHQOu44BHMacMfp+UY+m9KJQFlKSh1bQmVffeybbPoh8+QrjPp6HXAbJrzFYaYaN71j/akaxx02vC2bBnRyuqlBuEA2+uWdmv0/f4937AL8DMqI4OnIqNw3+PhBLvKtS9WRoU3PM+Q/vuAuHvj/xCz+CrnHfRc/mD/eEjtH1TGXuULy3ExKat6CRVQrWstAfcqi9dIqikubkstyB0SfMzn3uLSZMfIHRMlpAPtL1H7NmQj2Ymq/6oQYpVKYtXfMWC+9AWZncYYeNZ9cIf3cC5Ycl2pn9HlO/9z86wqF/qm+zyU+97P20evfsolPzXtuwVOs4f2npot/uyd5xYeP//54ysIFCz9c+PtCzCXm1+0KypeErYzW5jwXrU1Pvz6hJ9gHgrkDzISVqJuVobpZV83IWuoiNjdrYEpUFFEtgzXy1wlxynpY/1Wp0CqXsrzBxnDaxzNGXCcJR2TdDTEBjEbRn780qIHstyfvSVDaI3M53kUk6F+bmQPiCWcN1MAB8Ti8i+F9DN6l8P7cib6qAvtimM81dwf3xux+DkqiCuA82tt6F7zTFld4o/3bApQvNzQ0wsx5o12gXwln7G19CoL/ejUE3XXg3u+Weyi4L6K22RSfGelj1Arigv7g86+ZwDJFE/CWzrA2zYtvl2PtqktCSkJLwksiS6JKlNbePKNXbdds124P2x6xvcf2hCXTbzCz0gwafjO/G3iG8faXLS/TnvxPF5ucbjUDhZ2wZCKv2meC/5xts2UT/fuRS0G5swz+KvnGy9lesKyl7m+6EG8slLofAfe/WVZT91dcD1WaoEae96t5k63Q8gx1Xe+iWHT8gPKqqxq8A7EJU9TQFJUGTFFrW275p4CuodSVDbguseyjrupuudPaFll2C115DqOuqN/lUUupEJaEnDciubGJVh41cGp3XyXv+ljjWl5jf8Ayk+Yo03U3/4KQodftxRJM8GcYQ+yzLRb6b5jrSVEV2i6wY2NFv+qc45226Vsb26aXgdkJ9rLp4uuh5e05OxHHSMaMC6Sju0qWQjrr+D523jKaxhXimsNPF9KGXnHAmmnBNXZT++bCbW1qeG+Bdwi898A7tHDsrdxIPszNaEsKjaEZtdSH1QmIx9zQFvfAyfaPChCNWWxvht7SQvvIEOgtJ6kt+cw7bUMKNgINKetgbaG6pfo2fNp+ktp6nfmmPTmgW7UloA3rRuBfyBl2ZEZ7ytYx7SE7V7V/tPXiwdAO/5g+oj/0bYdq6Nu1kA91SzNT3fFMtLYN5iPbs9HaE2AugvGAiQYzDMxkMA+CWQFm/bPRFHvp18JSvJc/fucb5yZsB7f3wTw1busEe1vc/zBW4v/LWOn7vxorDFP0KZiR2gol9MoTfpaPh/dwX4n0BpdbWe4qErNC15lDHPDNYDhtFTNEsuMJwhvMDWF0heLjrCUqiR2mtOr5/otZw54pOM9kVLB6RaKaanyRUTJfYj4Rv/Ljna7RFbF8zKqsJYoyhcSOU1obrBgKpZsMy5UUQxN6Qt932sZTuYqYCigFrX0VP/QM7hXXmjLyDIvWt/UHqr6Wm8UqxCaFzPkf9sfbamhKL/tRjzvGL//5+taftX4MhakdajUPjKX1gXf+UcvqrZRqWZoOl3dSUAwOqVXQrwF5ykUDYJ34SlAOVjsS4Atcdf3yOgXVYI2jb+B7urg2+6rwTlt8t9jUNHxs3vvgHtvNXUPddXl/F0KorQfE0SPvlPDJlPkTts+dcNfChR9OOL5m+V1hte/chXN+xI5v7mIYLiv0WmzmwoWvZ60NM2ampx/KitjBZ45a9XLmzjfYiXaoF9TFtrJr372vn9xbHVPRVSM4I4/1c4EakXy9mrA+sF6wTnrYcV7/RLzq+2P9av2M8aIDa2s0xpYIsfXHuOL8iJ4px+bwRTeVSudoDe8EugnXhk/Eb3zoJmsVuORjjJcd2NKjKyKBujynYGiOrvuCbXQAfZuYYUrRoxxwPhv43fXwjTHIusmO3/K50xfMB935xnAMpnysL+pTxzTiq7OBo78g3J5WlS8jEMNzPtT4jT4xzUu2BeIamhqTiOlhrNt8LNCIgoP210h0eRtK0OgIpvUV1VjQICgh5K+CvJ/6Wrkd1spPxM99F4jJjRIi8po5wLngyciSUy1a1vBkj5L8JQusOliLVGUNVmWiBkbBWn5zIF/DfDJe6hs5AqzmNTS2d305fC9KPSF6/i4penlIq3JQ9cEo1ybX1itXVrzfemXFoU7myf71KL21S+o1Q92qTN4P/zdIm69chv+X6f9I+N8T/sfka1qVKXce3HilGf4103+qBjn9Nu9xgTFElZQ6oS5SB58vlc6b8pc8kBCWul46z2WJXxfBu1hpVZadliLKRyQqDLVTcO/i/aJdUgSHetUb254oWC/VFStbFYZ+B0Mooo5QeKg9tPAj4Iq2tUUVLjUPO5i/ZL/E794vTZqxX8rJx/jmLTZfC58oS4lpq/fwJzoYLYTeqq1eY8YYtNVY3lNtDEpjlaELtLXhVBuL3wWyD8aA503bJIspdt9iPlvKGVYq7WTYsnLR4EF0/4Y2pgAx6VEq6yxwbjVAkSCv1tDGFiCSfg2MX9m9T8BdAe7h8N2XupdS/H5E3Y8ozKyskdbrmMET7JoyU04jMXs0n0T9CLSfOurrqB9l8/plJbMBDKPX7M1f6iTtPgPqO16C++QyVRUtHTvIGEc66L6+TyOUSnUmNr3uYFiqwg61aLIKuFNWV4x9ojf0iY9c8lgo8c0TaqTjpqiS+wSUNYyt9hseMyDOlmZvBOTmtBsoWYYxfupA/GObHZHaBbLZ9bFQBPzi6U/kXfsfm995hq5DY42zYrVHwP7rM7hfmpGi5nvzh9w3b75+SLn0TRuTFNfhvzP0NKMfw1uhHDkwEjrtGSMzRl8TmKHa6ifFMBVivWfBvyd9ePbq8uhsMMJU14WJN8O4K4RI6PqEj8oSORS8HE+SD7XnZSQ1CU+K/VQNVB5UuVTFX7cVS6tMrTY/ucc3N4AgHA/5NwJNLOvQ85N1RwxLgWJnQlJDz4VkRlME4gzWwF8jz1OdbljCzzxd+MMCCXUhl7nKZFjKpLYBF9dFKTPc77AmLoKyI52M+MN+cqTaDjTs5sCIfsYnj4+nfIlLR0BcvztR6r5OXOLX8MC5MFF8nfg4lfXHc+I68RE/3rdEefxBVH/57qV14hzUzLIMfc4IoALUiXm3/A0Af4edTeBvIvjLfxL9jfXXQK/9DOb1b4FywfkE9d/WiSaKTtAE4VNpTPlgS/EHdfdGQEwlTkRxqBP7+fGOF7b9Vqc2N3+pFs+DspzEAbT6D8A/NYNhoNx9wcwBUzQvWksqVItRqnqsbZBlUK6SayImL8vVkxddL1iZ1TumoJSOhkfNmulWE4/8wpBVzPbU1f0tCUCZNZE+XoaLbWqCVg93qmCFyOQLrLhXkOocOn+2DffnUcrHaDMu3lPJcMb5ynKxCmhS61XyhaQa0FQXQfF5r5K+wG9zfMj5VvKFX2upFGTe5JLQSv7pZ6HFxj8i01vq52Ss3qTnZJxkJilyWgjQ88n89Mr0Pv0W51VO5E19YMz41dltBxVN6Q8dNXfaY0eOHdru6FWJJRvgQpSZseEMJ1UwSWHTDPwgflQf4+Is6IGPOY2Lg3zRHfNZA4YTHS8ATYS6DTBMpCWjIjZRyTNJBhvrVom6B3eYlQ6wcerFcyrZkcqh12B8o3xYE3nRg+k1OzMCYT96WC4D8iw7yvFMd5IVV92rJEMKGaA7b+DnWubSNljmqSMpznstSuts+r2QxvQvZ4Y+bO9VUuDMMKrtMyx3039zPZeFaZRqbyKzPLoddWJvH/aYKLD1pBrSe4At0sdTxIgs6m+8p6ElzDAuF28hKrgsSxMZ5UFeJhx4mVYy24/SkmMto2j8Rs8xIaJ6TN5deXdZRtDQAz1h4FfBot/xfq1tlKVFkDGl0WUUuKRZmoRGqWZ3o1Ra1CjtLlbxbDLyCIN5zR4NcAncjKvkAWmPmbUbLd8LWCqk+X1ShpG1J1u2CwZ+FkWIbCItbizRJ95gifZ6gyX6wGuhY0D2d8aNJZrIyyWKsLAjm8j3bvXQLx1KLtqihNY47ma4B4XXVsptgLipQczpI+DGPRStrYX3NjBPD43Rjn0tWpv2kIxFjTjUiD398/WeFJc6o8JP3D657VrJA341bTudRUfrq9hdR3KkHtB2EfR7sxvb7ndpCG++pp3YSv7hw3ESAj0E8/2cG/d7JvmQan5zVVfe6lchX+0n3/rYxCxrKxnkVw2IOo+yORjnw5BGnKSDNHrQ73tpGjZJxr9uJSt8Mv61cAv/upUs9sn41w0Cw10WnpzblVZ3/GvEf/aTlwKpXvVhqj0okkMTMbjPkzp/JKQaTr/70VSfpSWLgJJlBFJArIlWct6LUjvd05mxEuV0Uc+K2apcpclltqtgpGAt3HRxi/1kHISoJ9Mk9P+XldEUj0tnSaTte8mVyPegfpvAFkltdWALp7ZfwBZGbQ6wacGG60YTOXkE41KtkvGuXWCmg30xmHWrEBsV0b7X8pF8bD3yRZh6lMQmzeIH8zl8C7F5shNS7LOMveyR9dnG/vZco2i/IiCeYTk/km+Ust4FYxOE2cZoe0TdXGO9QwGrG+KA10kM00LucT7iKpLOCsqkMwI76LTApjiEkXmjcvtZ50iGGUZIYb2rvHIipZjf8N5H9eY6fCbbMIrl3kSWuFiuQmCGH7TLtPkI/37BmIvhrK4gNviuqmTq8ohLRzUBO7x6+n1f4LvBN5B+T3exvOzSw9+PuvAQhxyv2h9PXca5OFsctWUEQhv9MfTb5JpRKeuYZIwHHFEWjdz+rseFSMseISuM4VBO84Pn5Lbujjf+GbhVg3nyuZ5UZlOVH639Br4bwLwFBnGH8T6PRGqAw8gIrOBROc3E6MM92niuhVzwIvJIBnCbTnLKufBxZngHlelf7TRY1bl1sqZEQ9Mi1C91Edb20/PkfSlSYb6mnnLEjLKwCTxbwogHijLrYYSEHDEz4qaiJLCzyp3m+XaYzeC9yH6wk3lkomN+3lvw//Micy1KBB0uYjPfMk+2P2Q56L5xAzGkVZ2uv3zqvnZDMzR1ada1PUVDH09vgpggpUcgJhW8n4CYdI8kOBTWWLrntHvKYPARmr3TvNKuhVRDwHaPfVqDnvcBp9EP/oWDy3L7E3UwksD2nN1Asc4lUuGLaJoA+amuDdErlyoez7QxnLLJR6J8sJo+jqupEeK45r0uKJaOzGGGdNplCZ1y93Xx38KCAQtS76vt0jWZyCPVVuG8fpCrxG/UllcvoO204CenpV8E5VLUl5GdnZjTICTiOi79ICC/GcDvCvtaYDrmKhHLbrak6pcNptTsdGAe7H4b/bd81D2SKnUSmH3w5yMai0faK/hItf9DQdaYGAHtm+G1ot6SW7zADuqzv7OU6jt8FdpxIsxJeKaBc9Nfn+nSE+EkW6kGtM8Lu+uJaCHfeII6LTeUo+6fCNM2qYcpLFFpxXMF4L/KWIOK3zMlJ9DL+kEuOj3IG6JeD4M1siNS0WANT2QNHPhijK0OdOsBbhG33H51IO+jMOQMwVOEEAdyQSNTlfDuYUpPPW9HCvyMHb50zKv4712rElL50oN72Msgv0WFKB/+UAI3TMNvLdfy0byuNuzjvrxK4iIjO0KZcyTHjfpHhqBeJyjpIndY+fIqzKNLGFih+lgFfDBTksjH8KzeSea6VUD92jrXrtFVhEDfCze/ag5zyNqrdVUxVpwFw3gmUSKvVsn6B2MqtJYBBsTYCueBU8nF2vS71FSXBhvQpVHUV8N8CPnE+s2oUPNZMAYTPCpeZxsc0B+aUeUkLx/tag+G1vzY1be3h88t6z6WS7uZljaqVnurtCyU1uFK5fWBsmZ5tLfKirpY2XQudXN5HB9dqy2bL05gFRLXPxr8DfUM4VU8hGdN/DlSDnxCIJzKKWBdqBwxVrnUcVU4st4wR1QHdVANrGiUhh5jtiuhDtixjD6cV9M6OORW3aoDrFMjlAXLc6z2IwbrIAfqYKcb97nUeqyFOloLeH8PQ7/uUfMzAr0qCdr7pBv3CY083sozWKEnMtATmQu0B4bBnFs+xQS+v6L6bpoh7ZgmufddCPS+cuhp7YHedyHQ+9DtIu19OUP+2O++o/3u+G39DjWob3QfgX4XC+UI9j3cu3itvIhnDrwI1Ob9ufff/cC0RqnoVTDvKrhGWGNYQ2o+kzRpMnd+nqTKbLXl8vH86vzLZLifHWmyrbbOhO/LQI8wxquO3ZMVDbDW5QsCohLkWHLzJsHK0AhrDMvVkcUeE39GNLs0A9Tnsy3j6R/W3yEwSTVipt+TPyHvtMQUVwJH+5AjpIPThnREsFl8jTjcf1aKKL/Cfz85wq5tDWVZPd6yedGXdfOwqYWccIZ2sKGiEN4RoqS4Wa3KyMX8A/QmToN74rXNpjPQ9yqcuCtd+HRIh44ZP3/Ms61E72aMPRv+xaNON1afC/6/lVTFe1u1Ya3kX+7VVuSstfawDlbpzt82NNKBObnm+1jot+r5VEzxouPvUmIWonc0An0aTTVpNpI3fG8KUZYQai/xYR4edjLc7NHG/CrUevTKO1D3nbAmfjCL4UrBbgOj/Gu09gd47wG3JngjHsuLfeF7NdIkIRURfEi9Ps9A0RcaidXHclFNd1sTYSW+TJb4NPyJyoF5/a3jbAoO5fsbyX2Qbh056O6Xl5DTP187sh8it5dOv1G04DE9ak4GzptrF3rT8Hm++MroPFbfN/+SEENdzL4ZleF5/aypNl2gHHf4moUeFklg83pYPof+g/nNelQuB13nAzrcMf83Ic/7v1HcwmS4B/zNTInRPvyo3Nd2lR+2NEqTDn02FZ7vN0pJJdj3FFwk/ynk3OU9lMtw+8XxnoOWQ7m6fIZzzd8vjvbY8my5iM6S+eh+0eQ5kPs90FPob4hnfy6Xj7Zkz8e5JwOuAz1lud8F7H08e/JWP5pZ0Cid+PLDXNfiH8D925aQTJb7Vorf/W0L+12jdOw9MNu1+UyKK/+5+fzkxPNzJNVRbP8EO+p4uUwOe2UNL5fJIS9XuSJhx2RlQ6p19aPsnYJQuHhDLmOIyVdyr+QVWxrJDi/29euuVQVnxB8kNfT1Fy3P05Z70dsh1IgvexmD+9FN0hDTmzyb8mjTtlRGfKvo5dQssbQopGMoG9KRxdQAf8ZZ94tJnufzzkpDi+Kt30o6O5PSQmZKNh58hGk7/Onlk1HPxNvmuOo4KYzTSGHFr04Ka9Ww0CcVRj6+eqBrizMzv5Xc9CzNi7e2kHSJvTPT+rtQAOMc2zXb26MyvIMNP9rxWFT/BvfieEixlfIfKglzv1TKLFDz6NrPi7mJ9x6lfmK9q6341nnvz8N3hJdJuQ96DJN6r+PevHELUHawr3WTlFE0EfJqYlrJE07G+FWDGb5SWYw/2pVZgCE/deflvd8RpYiBVez+5TvNLhhTqaaY5UWpNgerD+kYQn27nH+H2tqaGmWfcNN6oCi1pz2Tpvua+2Ghq8YY3+Pdvmy+h4VR4OtBQXvbvGDmMUaH8yzU5wRhuCWO1sQXHiN/hWzxr17MJPfPd9PSTXPLNWJxy3nl3VgH2W65Dia4j1Jfme4EmpfRUG9/Gd01xk/AWFCkRmtH49hGXVDwroH3PHg/AeZ5MC+Deeevsq6bj+Gf96/yfFAO77+GM1wRmNNgPw7/ysGsgu+v4G0Hg3NELbzrweA8gfMFji/WuKE8BOhbbf0TeU9YltJ+N92DPbLMCSvd9kbpBnApxoMRPNPBatlkWXv6ZDvO6sqSyyTbY7Qp37yfzunjPFmVB8x8A3IwnPUy9GkcYRBi7NxcZQn6GEp9z8lFewr1nXbLd71rRl58PvqeHvDdi/q+m/qOor4H3PL9tSsHfLOjJk+ucPzFyudy4MfrZo5Oykuw/sU2yXIXbacr7l5Nd+ZNtGwHvmmi5RUhPS/L8pKQlTcxJyFfe2cWznOvZ12rv0ee58qBw18njKVxnXXHV95J57nnhAzq8iPM/xMdQ2m/zbSPtOhzR04dNQ1T+cz9QYdOHQt90sRfIlf9/zBLjjvyTDl9rJfIJf+AvOHU1uSPzxtGbXX+obQPzPek0vdDniH0fb9nMH3P8Rjpe6ZnEH3f7Umh71zPJ0KS5VWYV5Msg2Fe9QbmVew3n+mjtTuel/tBFdiPgR37A863Hwfm2+fB7R9gfgSD/aMdwvf57va5F/tOC/zHvtMO79C/RWsNf5P7IvZL7EMnAv3oeKBvBefr5eB/BRi7dHmEXbqYWGK2S5z+y440xcf0tjEz5AQ9aYnnEZdCpv0k8k96G2D3+u6032XCBO4BrKiI44uluXo1cGCzbBgrux3iT2S263J1FgZqX3KdkS5Hn5EusmtRwqfverOxWsUfHqHnB08y8bXkmBf+jzBM+hqeuCOMlF4Yg+ea0VBvP61FPq83TQMlF+6yYZ6Z7XG5vWns37lqJC7tq4405T7zgDpVZ9SzJl4k273oquq8uXwIP4aPn1RLtlGX1EnH4VlPcnyqzrC/oPQp+n7bi3oGKUriKGcg3YHr5P3HwZYhuVgLLzgHI6YNopemo5zbdDFN+/4CM48yKCNnHG/RAXeaM+PSY+ulGfA1gOpIvkz89E7JpzNQ0kXVcRhcbjoxzHHp4szj0uWZmMPL5KoTcrMCcjZrvZQEJhlMCphBs75qYRapOiNW4DtBH0TWGMxDOSGc3blemjuLal9cuwXaB/ON7bSiInZqrCWSZ7hYWIMzXHqrGWiJnhYdfI3AWwomrOXpN+IhDg7oDa3ND3NlONUHg1RFPYw2dU5KfiMhTg1FUWsWLiKO82o5DdSDN+eCQts0C/dYUSdfZqWCQ518QP+55FvZ/YBy6TcdR58EXLwswxaeMo7PtLLpKjvLXSZHPIhTjBp/ett7WnrQ+eA38LtjyRXyMaLqMyIx+jnEx0pPzdd10673k8BwiId1MdC3MU//hn6C+XGvxX4aB3lKr+xFVwPkkRpJRWUs1bEGswikocstkTL0ujyGu0fSm6Jglf8HuPawnIbeEUp97YLvcEuJlGNS5zKBOEoqb0+zPjFWux7GYf2paO046C8z1iE/FQ0z3MhKnSWapp0B4VZWlkoZaTHwnDEj0hZh6RAUxvAGTr/FquqYCX3iGrTj8hl4njHDlFG1Xpo5QxK6pxOzDvVXwghIw9vikXyqLZzvbYmn+cx1Zl1TRuNqp/Eyxt0Lws6Xgj+DDfXIYY2OofoEezUt5n8Wp0vQDydaYczN9BYA/7R7yc+iRQL/CqON4TQWJbRfIlC3kcAtf/2C3NaX4e16AcuF6QdTD6P66BpJmBMpzHuglyv43UtayV5p9xJ1LqvHcreS9w4z1RGBeFav6UnXs03lLyxRlCDmXqMUAVxJxLvbJJ1J1rW+TQrJis3fzeNsr9hzhYyBEj3SIOsM2AO94gJ8Gxp2SSFcQmXkkAH2sCEJdhXQO2lzNK3hip4SmxA2ONbRU1IMjRyic2g7FIoHJo+zl09S6fW5WZDP4c6MykyrOJti3rzyPv8g/50Qoke9FjAOnPmHQvUzqb2v01rJGjZISWkbpOS016Dc/Ww9LTFQO9slqFMIE03j0zh323T6KGpnnCYYA5GWUPC1RlJxPwjfSkx5Lf+DoOa+EVjuuKDkvoQ+uwDasnCdXCcb4f0ymHfAWMEsB8PCOv6pomiEn1irxQpsbz/p9KuNaj7cnm+T2/YOi4nWfh7V4DkmDe/9w3wTotan5mZAXo5IGr444HeQBfcPG8kobOc0JvWSPZM3WDgaPlW6IJRKG0ymTJi7TPWkyo1+UDopHULnmPrC+DFB2N4Skwjp9DTqFXsE8pq/nuxxqw24T4+nWNukJNOvT6D/bVKyCWfZbdJg05jKNANbptgbltNAVnibHvtYUJSFgP0170eCLVD+H+FdA2YZzFlOeJ+4D7GAxexNtNSFtNSM+H7RjkBZHrQ8BPm+QH7yy2VhxO1F91tS+fuo63H/1iaoBU2Ifg7k+jIZLYXwywMhZ1mmQS1cIAcDIZ+xp/PTLL8Jmk9UHZsYXlJFhulH8AIp8Kl59Y4wPWsawauLBfKor/vXPF/RbX/vue3vVN/a2/5O8slpTbafamGLT0lMUSqfZhkKLXSBLPOrhoXVK4bFnd9vY4eNtaPPeYdS+VTLDoEbRhxyro2WRFqy+/zYztAeTbK7wdKPuudR96Q0WDHADIJ1rd6FqwVy3F/hDeoGnFNS0uReIiM9qYZFQ7rnzzPDau3ssI5ASjqLhsaopzEOSrsEufjc/hv017eL5LaywfsEGHuR3F6t8F4Oc+1MMP3AmMCcpvTB2z61Uckn2vH8mt2ON2OZ7VG5URaM/5qvnmx11cD6WNQP+HQlcvCIz3pe3OfV0vMrFc3HBZ+cZ0W5vUpej++GNJ+iNEhELqbyGZVVswK3WyoVmUypofbgPIZncxdIFfDEuiqW80AZ/gZ53RQoh65CTcP/nYbP8cm3o3RVH7ti4J88xxlskVTz5gWy00dvu/izKrGeFthCgYPGteAC2fZFCMXHW+FlaU7xvqQmsAYPgDdP8xqML4riwF4gT9P4qgLxrbaFw3whx/f4F6XQkpk2OdYcryIQqyr3prBlrRzv2/D+HMw3YMSKLXSU/D0QVz/bOMs4KPdEXyjOBp1RKzOAsunhhPGoz8hV7blE1rlUezHuvrTk33uVxhB7cE4YYRmOM4LApABF8gyG2b3koFnrYBLD+a3msIZeEruEHZE+SRK299vb5wqp8GomtQp9e26TIjjlXoV+mxRpukLKvBhfnm2XFAltvkuKMCXQVeoCuUnTfBX/63NseltvuhZfIFe8mMsL0geC3IohdtzhNmXqYH25QOq8/xb62npAnV8gZ7yIssulof9vJIrZnrYF2vadNXLdHIH3N2CawfjBDIX2frgI7z9gLc32qo0afqCdg5lPwUHPVF8gH3tH8Kk89s+EnP7TgP53PimuCZnQD11W99lpVmOp+yHHcNp5Q+iVc4n85MRSXPCZKmMovVJ1WYKW21xVKs1kVtlgLVen8pFUP+sF8rxXvim1wKOkLSlVaS1s7iVh3N/k/M6B9+hrPbVKZU/tbrCvB/PS3+j833nt6cM4/38u6/L2k39AinJLTbMbLYNzezQNpr1kFNU31Ixz2qwsGzNsgj2JzhiojfsCGQv5OqxDzQHKVtZQI12MfnngIXO4Q9VxJESR8m6HOuLTySF1vSU2lb1TBy2rPtTLYhfCBn4Y/7p0OP+frdwdakfipGMHX5UqdJvNCvsGaImfBEUi8BVAzwMFC2tCimKYLcyiypVTVFYhJcpUvx4oow3eR8CcB3MTTOwaGQcO5QdmmFT8izbGwECtFcEXzs8CuerBe1qPOQzWPMuuAi3dk8cy/sXz+5L3bfXkCQnnN5S4WYconMpe/ADebPl9yQPZp3uXmQ9N/Lwae0ZyGq5CTGpMQz25R0La+vYQd1oYwyGztrrMrPgZY78fZupBlD5LTvsKVoyUtK8q68mdEsrvdoVKovg5gXCncb1bchRDX/RiiEOHaoDrgVoesdNscgS1/w2oTqDlKoJycZUGa18o1WOGEqEPdX3GE18p5/cloY74/MA3sMGQ73+BucGb+4PSDPLZHFA/39FzsdPerwWUTZ8QwIk+MzxGe8caWQ/isW+GMb+JPbUZ+L2nZ0A2eEP5ZqCvCOnpYhKRdzgtPi41SsuB/lr+Lhgbk6JMnjy53/n7YAVH3j4XcpfiUb4J+Rs1nGdHiQLuCgskwcMYieMB3gy9/wIJ92Du56a1C/dWjofZB91Yjyz9oaY01n1SCsVH3O3S2kZb2gSOvzPXT865qP50d4ZtpOUOCEX9Tr9Afof6NMH/7+j/QjfukQ/LqSejPaqOsWw9Gez7fQlwD9Vhht8X4HhItf2+JMUykI63r93J05LvTpleCmkzqdUoNZ6mTNXIiOn9E5Mxxq+gncfo8c9Oc3+c+3rm2uZIepir5kgGU2TuXTzGtBuooDGwnmak1QoYaqz7d/o+6G6k75c8dYIJ6uIvvhMBXjEdaNwHwTwL5q9gXgUz5rpO+/oLst5O5BE+ekHe09kOxvACrg09pobx0CusfjLMj1xPCxnhC8uj/E5a3y5+x2DIV1MpcHmdmHlU5kGQ1xn+cU86zqSKu624R2Tk43MFYnEbK0fwGShvAP3IeTiW9rUJbnqiDC4plTrqcieedlTCPOPE214R1G0ouHE0tJ/sdF4TtIHZLM6NCMFXkH5d1YXPi2fANwJrnvhp1jX16CPm/rzGnnVNA7Zwu/g5IZMP22FM4I7Am31TgZMUP18+xR7g2G8KAytQepkpieYjO6KUhDR58Q6ZfGKHaAVSxfLkED6OP+Tu7NxlY5J6dfhH4c01yOEThLS68Oba8pHL77z95hreP3MFZGMy8vpZP4KVMrNytGV0rhLKUu5iufMkXCqWJpnCK9Mt14V0y4jc9LsbpWNF2IN3u+pIhg+x9+rISF8KHfXlrZpQoFPC7pmsrbZMHgs5CNvLQQ7KXJsP4XnDdDE2bBciC3SwoY+4XnTPm5x8LmVfmDs8M1N6bOw8aXZEaMk5MRM1IrPzpLkR58RRHrzxMk96EOx3eKguGykf7IM9oW8iHTSE3o+5QO53fc87hKnXZpgEkumtAM53EB1ZiCuz5vUddPxfhr6wd0O0NgHa4RS8fwcTspHer6B6hzIrlRze8bhA0qDs58g2P5Z9ni08l4EyHHQZloXRkwGg/1xINYXAjI5f/VxE6B73Vni/sUFOI6YiIo8t2X5QxTPbZX6QkO89TGJoniE/8bH10iRd4sJ4vaojhxHIX524ryOfO47eKMc1dSPGAaEhB2NdXZIuOSz0EbJOQv+v/a7QMgGXfYdRviUkIN9yw889ERwhHMxrT9Pzyakbg3tUV/wc9OZPvOiKfUxhiOCxlyn37QeKhZCPPUijIIWC2qMMRXgiOLAisqMHq6IrqoI/Vlkl9TAd6iybHuXA3LHQQyOVmNbLGJYpM8ZS+TkMabk5h3vBfDOIdTNxYzmjj4AwkfySSdH8qRalXr1dAyGfgpBRpl1Sj2O7JB2kHqPbJcVm7ZJ6L4cY8c5t09QryqGo48N8RanH+73ZV1jDLqmXbtIVNmmXFKebeCUkMaJVETJw0qBJUZOmXdEOXzk5xJ6+jE1PX4ijRkM1rO2+C2UXG9tiHninLabgHxJzDG/UPpa5qP0fhZr24ru+lu/ZWg6DK97Tl9qb6Z3bhe0bCwa1Jxcuat9Y+HWbomBDmxLeqsLTMO6LVz+R+eB70zKXV7xF6U6rP+NQHfnAg32VMWyTtKbY5IiUXfBWpfasxXnyPv9yoAS1ul5udv7iSVTXht9YiT7YdPR/WWD0i3kcRblOhkug+37xjIveG8UUTvpjb+sV/yYr/bIuO+wXCujZ4TY/aalePuUy1WMVOjWU3iW6QKqlRD7EgrYjYGMNaktw9jx4GPueeYN8X2jlBnmPb4xFzUdAf9nrYk2R9tF5jD6aj7c2kwX+In4kpLPPrK7zkx/9PRHbX9spzJYMM+7INU3HGbNEGs+PtXJHx9qGUe3KF0iRhGOszvsYJ0CL44nybD3i4S/0jcyPqEy2tArBW5OI/m+yMob0W7P9QEu9MLRyAPB3mPt50leCTD/kS3OBesjIn0dROeItMfQ/8P/cd0Ic9TFdQvrizaX4/7rQk7pNlnTgVrf0huAnT/ovCwVfyPdxgvd5sN4+DozHH+B9baN8tofz+8BN8p0enOMRbZ6QjbA2FFXGQ6k0Hryvs1yvSLxJOv3DHxtvw92SSSa8FdzLh7g5fZLcFOMA8dbvv7ux7f6tG8qVg1QwFthnmJJw/l6YLa64OX5OXpaUk8mkIKJGM/SpeJjZj7f0XajqWM4wyc3kEURHST/ekpx+XNo847j0Epji/OMtgxYdlz7I53NZbp+o803ORTlVE79PDPNlg/1jalf5JoK9nNp93kPtPbYiApHYnkMxAlUdnzPrEe2n7Q5wPzYDtRodl06A+QGMHUzNDJT4OymecHeFqWfWt40G/03w7yKYy2CughHB3AAjgf/ybv494H8C+GdmHpdUYLRgIsDowMSCiZ95UtxB5fyybl6fxRhUncXLCRkk4VqyXvrXCL3h/ac4HiXf1kvH5q+XTs5PXrRg0T8WUV0yKN+IdNZVxYtiFd5jYJjxk/ZAuxVvjtYegPdRMN+AObMJMYEYA1s2X1zDbqPIQGpTNK8wEPKse5ekZmRsIF1FFJWsaPFHJcp8b42RdSgNmib5u8F/1qihiNxfssdRQwusFfIfu/+0UZb7PTaiWcCZqEMIqVAYAmlx7F5GT0iWW05neUUc3u+gKEQaoMXfeHAvUNW/xiNipLZ6rfTlfG3qDcfyqhWbEPd/jM01uM85W6drTQI+nxxY+05bdGEjmHI9PAtQahvv9xe1GQqPtekLUfvvj36G01a90xYG/sIKi/RXhHfaQsEeWlisv0jvH/2byk25Jg1+8JVxiCnJMIXZgx+MgrcL3q+M1VasPTQw7w3zMPtjgyNri6FcKF38mOERwzHpLdNAPYe6k2kqJwaH3vp/wvAF/f+kvl2wdZ5YE37rz/QbJ1ZMv/HFCvx7QN8If3Nu+5sDf8fTv//W22kOHQLei5J1Fqj4IBLi56aT4hqXCL2rHHoZ9siT4spb39gXsNfhbHdSXHIE70rBGtuRo95QbgR6Zpm7adlNst6nzVOUvL9MWfp+Z9wKpgR6RgnuxDAG9DPejbelWq4qqI7z8GR2XC/Rr463qxNlPTtZIsd8czCNl78j/PL7J99GcwvwPVr9mESZg4moNqxOteH9KPy+SExHkGeZsqlLnjQKahHDEh+jT6S2az6tXk9tbb4ivYHaLsPfJGr73ZcVsF0At+HUds4ny1AM8k+/4aJoMs2+6+09wt5pU4Xh1yN+3Df4wITrBo6PjIqYu4ulkyNUfMuDwFcCR3ByhGFSifTliBfMOjvKAewTZ3rQNd32W3zLg9ulL2n8O3yxBtQ8h3/YdKUYooTROCKD9lFcQ4a1qaCV9pTbYSbaJ75HOfPvIO1TLSHpuEMaUtYMoyEBRl2oAamII85d0gBTv5CImhoa4jUPyhrsE2M8RhjRKpQfXVtHbkinWuJYOVe/+VDn0amWvqwSVtjGyzEwyn5gapk2Zpc0EDXjcUjL7Jd2mLRvZl+PAttOU5XTYNoPfarvwV3O/mB7G1x2QBn+xYa06yiVUOXcaULsA1z/t8Faj+4od2Pch67Z0uZhqr3qMpTl3C8uctXA+NoFvkrbEnbWtA3YWtrGbf17+6adOJsyKaVt/QsHt4fs3AW+z7Zv2soOMu4vbRtYaAX7rjZNIfjcWtOWWFjenhtmbB+09aR4rxN78La2BDpfnhSnObH3bmvrT3vzSZF3KhNPtUT2PtXSc/4zLT3ZsDLdvsiO/Iio7adaYlfQG15AfSp4nDe3tQ0I29YWtvNUW/jWbW0RW0+16BbeJFVe3ZsDS6Lf5Ep6vplYgrXwVYdRiZJMNdJmU1IJlrtGeslkKCniF1iblp2CEqbxg/nkkpvE60HUp0i7wTqGl+V8UNYotXIIXyMV6/oBZzrcVQN9C1sQ9bt9YNon2twDBO2btDVoG+wwYetgy9wpVDkHmmI6mel9q+eZ+x2cctO/Av9XORP/4JooBFsQ/w404VyVMzMW+LycZA2V5ensHHZo/bK3unFEY3gRRvajHuSIckbm/EGW5xj82+JBmeW9Pj0v+50KfiOqmaScpDYqsXMFqISdX8jy93bpAyhfv2mN0qrii+QeSe6j5zyos3KfeMYj90hHoM+e8vTMxXllG46baF3ORXKXpOr89RlV56VVcRK7hoMU/eQLTy+JzXzBrOCV9jF8Dn8R1rnJk9sdslz8cBhHT2+SZVYm3R+tvfd+5GvVfGROj2k9pl8k0RKTJGum2+kBKo9nR5ogBo1kCFE4MsDGShOHtjtUOcjj/k5c1fNx7YM4cH+N0aNe988+L25LgDVAH5AaFqgE55j6Yui1jW0DCj5rZwpGt/OBv8307xD4O+A2/4ngMrDwj/7iwJW7zV9kvR16+sr2bwJyyLK/H6isKsrtLp/CVC9c2Dwe5YVXVCRPNVgj+UxbkiUJaMgG8rCbARqyUoo/NP3G5eXN5G6/hjfaBuQNtDCvqaAss9wp+ZyVOSTr2GmqZBPjcy4TtV8zIK6uN5UIuEzm+xhjVB2ehKh9ZwU5nsF+RKxtsjOv9ciLsLCJ54TbtSApuVDg/RrIADfLfSFcxXsuj0RrTUBPsCpGl7pZliNgWUb3xj04j7OJr5dPg5RP+FQDdOfz8qZaptL8+1xnyT/9FovSmkO/b1K+c6Y0JZC3GB9KoEyyTKR/BZcg5Ohxd/oyuerPMbL2CZYOIWxHLcyj4+ipAMqZN5DTrnBw2+EZE9C9im7fuSLA7WXPKOo2jLpVuxradIVplsG5eKtZwcF8dlcD+dRV5ZxhGgY1jH72w9csUyrdD24gH8LXbJOR4l40kHfg615TiqUP/doBsUUXvAPUxc12prC5fVNhXHtxGMZ8qk1RWCvO8PSnafegvte6+gUkMi6T3V6Ul4i3vCjgl9mr5OJo7T4JXPZKGNNYn6/NkOsX5Sdw/27o3Gjt32dGaw+COQHmAphO6Ms34K2aFa2NBcOCf9RrnzRLbo9Jc2XZFWyPOGgNlkp1yHq6GkgGtIXoi4G2iKbfJmiLWvKiX5YluUwx+NjzERZBiLiV82yvLF/SQHN+ycNwlwL5RXmPYH6DciVR8B06NdEKtFqlksM9owbidWIqc/2anN9Jug93uX72Mlwn7VO/bpLj2DLjz+F+peHG0nC9aTjPrXAZTE8aLun+P4f7mobjaDi3F8OpfP8pnK4ifGo45RMbyD5nIh9qoe3vlKVKGsi7YNME+MUGsrMSw43eLPOL4ffLMiayHttGqaZ4yPQi4ByH8xY+kc/im8lmd3ZCtH2WUWufa1TZZZmTWnLGx6a0UbmRDOAqM6SvDzYLCXn9c/tZgZPM4iDccmd85WAe52enNz4XXRY5tZV+Ms3Xi37l068ofwz9up9+8X4d/ZpFv+b5e9CvPPq13K/kwi3hUC9joF6qoO26831B2Q3k79KgTHeBubxZbpO0l+n9iTwVj5zZeTLH17QsyJ3WSDs4xBKJgpQ6yc8+XBXKxPf8uCqUiW/7cVUoE3ciuiu8X/fjqnyTlDo5/iZp9MiYIsib/P0WpshJP+b5vCeod3p7uQr9elEWXUbT6FmOMiLN5AfKc+ZQnvOo1LyQGd4O63JcQDrkuLSDIhb9THeOR7txZwFXpPMS5bUX75ii6ijVMMbY6ucNeYY0fjGvzakjg3yI/cIYv6dytSfseKf6d1Lv+QrqC/OIa+7qAH1nvsaOliVNYnnUDcPVm68pqJzJ5qLIepQrybSDH0WpeZVdT2U78Eykk3xdBaMMXBHh+9POiEdERx/6B3iUSvM1TRr+2VYUjVIrYH8e4lDDu8HBdCxXbB41KyCDUWZ2OtKazNdC4F8h+NHC+3uHHE/p5xOnvm/+qz2plkl9DmbOEuBZxlsOuq9fP9RZuOaTZU+eRmrnnba7wvYtRGoHaP6nmaSvW+KSzrTdEVbUPigMV9XvnXGV+BacDNezyQQx1tcqrQlLkENZYEP+5AOa7/wpOabzxAJjcs9CpFGRa+kQXliWmMOk3rSjVMp14YEBC4aMRKmU9Tr9uuvRm/vwSH8USL93k0ppolIpJ4DmkJxfC3bpLeassHyUsiNecQ+UdzKYEijzYSFYW+7D9jbU3hV+axYOICOEHaXc0uFu8iRM0l9ycV7COTKIJzSW4gl1knd8iCd01214QpdIqr87ntAlYvAzKYgCgXvxCxbdjig0NJflysQz3tQAolCZ+JN3cABRqEz8zjsogChUJn7l/W+IQpeA05ERhT6Q6sH9wv8PspA6gCz0++MLFv6+EPGFUhZ+GEAWukR+9HkMiHUQAc/zpiwDypkHsYZ8W6K1V7dGazVgYsAYwYzbejvOUCd53n87zlA7+cor4wyNY5S34Qy1k8tV/xucoU5y3IMS8WViqRclrcvEYi/iUZSJL3kRS6JM3OxFX1sCcwLm8XacoWZiD+iix/sgiP+jtJaU9+JvR/jJOFRsKYZVt55842OTVBTDB+8jXXRythctW+mfSp+M4YPuteC+0bKeuu/3oRauZvIqzE4xQcSeF7oQeyIC2DyrLacE2edfnWGDUB/nLdSd17ZJ2uLLpNnFGlU8a3/aMqgJWncvprTFjeg2yyyLaVorEZ9C9YnATugt+kMuOBrbFu8MG1Tevngn6mx4l/9jjFU0RrU9n97rrif3+YqFYMwPulGGdp7FITS0aQvHtA/a2dAWWshOeK79I7CFFWIKhe0fldU4ZJyhgVAWA6wsh6Es0yy/CNNu5sNsGucMSxl0e7rLLwPtgunudATTSoG03nKw4+NEv+ay4522sWVhKWK7ZWs5mD+HfpSG/uBW6BAIXebAXN7VPqiM5nI8Iu5gLjHGDOAA66EuhhQOav9uJ8rFl0FprOCjHL4/bf92J1LMyCeuIY8cENu1BUBtU7c1nfcdaGkXtortl7feaP92K3Ujdx8AKlu2d045UAb/y9tPbAV6PPB/3IFPA36nAteDLXIpgPMzLjVae3GLjPHz3ZbbMX2COD6I+YP6Dv5f4V79v8IMWlGhpphBGspbFftfk94wqfiUStG2zxad19OiaXrRFmVB/VeodTfKIt/lwV4Z4b238lPXejErdIP0BvNaAFsIb5Yi3cWkdjoUeX35ZkjrFajTneYY7dtb5LrevwXnoP+OOqT/A+oQzBfu/w3qkHownhwMq5URhgx5ykU4hyMCzoJFMgaOvMv0rwCSUJn4oDuIqCP/+fHWn+nu/4wxFDY4JIAsFEHjX5f9o9BjsCaAL6QFN23e14KSfmmojxeykf4qnNhnTOHEN8a8fe7SGIbJmqi8s89dKHfZhe+zuzqmAk9SQkzF0gXTAwlpqThHX+DG2RW1rTZM+7HUqfbXU52OyI4QKImfrPQfruyO+nPVLs+yHa4u1J/ExN5N6B/3Kx8J4AWViU2uX4QuhB+7XZ6Vz7goXg6tiTv8jPG4XRAwLO6oToTvJkepdD4Q5p+BMEdd6GZIvEh9JiWijlekqEqluoDPdwM+P3ShW1LiT1QfRBBfp0yMcJ8jRf4gvk6ZuMz73/B1jIlaaO+QAL5Omfi8S5bImw9UGyvJK06HK0PG13kBz9F2SbqiXVLP/F1S7IxdUm+Kc5y/RNuqNO6SYkyInLNL6mVChJ1dUpzpP6PcRLk2S8oylGFFvBtY64CaRCwb9HPnwQCGDT0/G3YwgGDzgDIhiGnThWGzlmLYLObZMsSx2S9NKtov8fn7pZwZH4tHpP/biDbpFNGmw6YpSwBK97z0P+HZdJKNbqSV65awiTLu+2HfHAFvEkZUP2bwB9BoQiGulyQZjeYMpZp/plTzb9A/Tgnd8Wf+N9gznSTM/d+wZzrJCDfOSMQbxJ7JvlYDdFOl10j3f7tjz3TCGvw/Yc983Q175jdyxdeFPbPqqIw9E5kaei6yG/ZMO5ngDGLPfOrtwp75DfXPd8OeifyP2DNIOwWxZ4K4VRw9XXnLG5xj+juDGFk+ileVcj6O3livJw/TkRibM5j/jZT6ukblY7fC+qXgzCX/ecr7Z9yshOog7tZZYVxg7i2AdxcWTpn4b5ccX6sLsXB+Iw/5kIs7K15yB7FwzoqN7iAWzlnxnLsLC+c3wvt2Lz0r/uSWsXDOiifdMhbOWfFrdxcWzm8kzdcE/o66ZSycs+I/3f8JC+esWOaWsXDOiv9wy1g4Z8Xd7i4snN9IpA+xcM6Kr7llLJzfgM/vwsLpJHlH/jsWjnQLC2cUxT6pJ2XAHZ8lav/tWDhzb2HhpK4aakmlLfKaU8bBuUQ2ebvj4PzkHDp/6i0cHM5mXLyb4uBIFAUH72yoBvxal0B3VgTydw9j1J7HuwmZnnjL5wEUnGYhTS/vvAhko4ezydIQ9WSeMxrKV+pVBXQHCGQl/I2kt4HqyVRnOPzd4EX3WA/LfU0xdLCN73+kC0MH6ZvPtsr0zY9bsQ6ieDXfc1qtLX3VC+YQO5OU/vw+c6T9eCXWRJFvDB+e4ycFsPYywzocKwqY1A7HGD4E3PL9quyLB68I6YuZ1Fa7ihcFxMwpDQdO8D9i7fz2J6wdYzesHQynrYiyKHlTZfTiV22MIZZj3EpOWxW9aq250x79/BvmULuSC7Foc+vJLxLmboSPSb3mmFnADL5mZw3NQmkAcwfLHMTcORPA3BHI3zzdMXfqyafSL+QJbxBzp558TOMM8SE6jUDKvV2YO/XkbSmIuVNPdki6HWfFh1wyQs1Zca5LRqg5K97j6sLcqSfrpdsxd+rJaimIuSOQne4uzJ16sky6HXOnnjwuBTF3BLLefTvmjkBWu/83mDsC2e25HXNHIJO8f8TcqSd30BLdcAZL9G9nsERXnF2YO/Wkn/RHzJ16Ei11Ye7UkzAJMXdmbpXb4P8Uc4f4gm23290dc6eO/OL/hbzsCWLu1AGdhm032Ctj7gik1dWFuVNHqv14+2GrC2nGZ7vlLYi58xVFvxHIUncX5k4d+QDSeNATxNypI2/RNIhH3icVSKXrj5g7Ajng+iPmTjCt7pg7iImz5Q+YOHXkCT9i4ozxMpDKcQ+Gux0Tp47M88uYOHXkXr+MiVNHZvplTJw6MtUvY+LUkSn+LkycOpJVjXH9N0wcHCdMSqM08lUw7xbxkTzq5LUEdhOMzuyEgfZZxmh7WH22Md6eS3cxK/yYx6c9bNIV4R5juH2u8YZDkXSR7mielxjmIvnR++3BekGZdF5gU2qFwXlDbmHgXCQK/+bKMfQu9L+8zPBz9iAKZY090aKnNS34WO5HgctF360+vKcoTvGTX6oSqMtvvgCuja8P/T4f+O7rj6PfP/s4Wy9qOxX4M8Xfk35/7ZNRbRw+xnjC0YOi2tSRct/fhQjLv2Cd7o5rg3XWHdfmj3g2WS/ejmdzgzzh6Y5n8xs55pLxbC6RZ11BPJsb5HFfF55NiOt/wrPpxSO+TJUZ9V/1pYg2ZUUGutNYZf6bvUd9RSfzyBT7k/Beu4YRvyiK4UfwQ6Bub5BX3Y82VXTqHmHEtUXma2z2LjMjrgObSrnL3Orwk++cs5pgrFD3HUUREKcG7M/as65vKuqO/zIBfIVRXy8VHbu2sQjxNXaZTzpkXJcpUM6prvwlSAWzZTKuS0qTOW+n+Xl7bC0zpNDOZu4097EnLh2fd8h97Rpi1Sg6XU8fdF+/pn/8/krUxHPMF9KUASGu1iqXRuoVjzOp1+0y5s13PobjKOaNYunwHGaIsxvWzXWBzVyQasFdxQ0y1k00n7X0Bpnga/3TruJZoQuX5+wtxJu+Oecp0vtV6RTFsVF0xLOzJFV4NpitZidFbVwlVcoYNyNxF9IM5n34c0DwkaO+gzR0H/cnAtBh0j4hK4BuM5j/K92BfE9ADJvumDZBGdpOoqcytPUvdpehvUQednbHT/lPaDFnyAipCy2mk8yQ/jtaTCeZKAXRYvDGVgQfx2vsMj5KEDMmHXhtI8/QGxo3yMojFDNFRoKltGQY1eOmtEYlIm+NWDoU9aQyiK+KyJO/kTznTQGl8BSGcRQlp4Oik1y1412P38hYpxDAwtn/Is59f8SjuUE+88t4NOpueDTfgF+sHxmP5hKpkW7Ho+kk/OFhLWT6hKkGK+IBGmzjLePpbH/Co7xjkOMYhDkiqWHcmfkxuYzY5k/OH1eZAeutgurNEqfXkUOfp1qNgZt34+1pluE0/B4PZ+1+25r6fiX17kbpOKy1O8rVHfGhvW2pq46aEx17kP6TNLzJ9qhhcCFTUmDN5hlxsjslv0clZzkhIN2I8a+yKbjUwln8/XwdWfWH+CNG3T35Fwdn1VbGWg4ABdivAGaDRIGkSNkJap516CwHBR1dYZrJGrov00yS/Mzwg+fDLf8QxFkMd/ilaO00lI2GdyMYxbZo7Uh4J8H7WTBbtslrz054T9lG+9zU2/Ogq8J48Fzjvrx468vl+ZX3Wu6jtZHoUXJzLLNz60iCB9e/lc5gDpuBtlIPYM9PB8qEA55RIHFOzqi1T7Xk0JAqD+b0J98FIccyibq43WE7fhGPeSdTKmkCdetwN7RoDGNvUUl15LJbpnMwdIhfaxtr+QXonIi16dPumg40DsUeV+xRvLZN0ukEoF1YoGdGWY7TPOA6f1riwGWE5ShQOGaYDzGVL9y4y7irTXsLqXlYw6620FtfU4EzZwx3BXx/RPP5hDeR5lN220XzOSJA+8QB7VNHStzqof909LEEc1vuwx2qOMvfBMZQK6DLDJ+Si7GooPaed3P8IzAOsJ6nBtrr2B09adsEaaTHX5JpJKSHCl/qooleeEluvx0vddFHuore0FKmyjhL79zgSp93tKttQvwqaJtoy78FmV5ppuf/oecjLeG03ke58VRAl9VMfFVB+qWZTAc/14B+uSp0zyfmsTv9gndrE60jKrVUM52cduTRkJxfCe/nrEqKQvXm4vgpt8Ux4z+H6ziC4YbcClf3h3DyGW2PqT0CNNA5VyIfQamcGleQ8vnJJZ/b1pGTru6Uz1fA+2EceyD/6pe7aJ64l5Hu8cOayyQDpTuqUTK9C+bV8fT0tk+Kch9TMotX7MMz3JPiK57shDiggUKAzlECBZTsYJPbBEVyK6V3lDsukvuc3xxMB5ppDM9AHja7LgiKd1YnZE+OPT9bMhQPycW7LZtc+TYjta1zZdkGWQy0FZ524R5rZJMyecrkTPA9KCsxlwM/y10ZlSPoDuw2L+p6RO0BCfTPApeu0k8G+K4Lfej3PBee7+p9cfRrNv3b4bsoxNDvqfQ7218v6Oj3JJfRFkVtE4BSPQZ0QB//j0K45TMB62lqz57aZ6Fu7n1Zxv3pTv/guXCQBiqE/yPA3AmmaMnyKcHzo6dmHFt2gzzU7fb+bNbIt5H3pYCeit5KLQNuDNdGvj/sv5pREUfXw6x05XxcA7tOlh998p4EVYdOrbT3yEVNFx/4a6QiZq/4F6lGWg/v5XR3b6/4hIS7FXtFq2SEdQS4YZh9dRRbM6M4WjsAzO4OHeMnJ6vldfYbP5a9jMoByH+uV+P5Fd5wwviXu+T4n3DJ8VtdcvyPuTDmK16Wx9562tu0TJN7g/R3fSoVc+qcaDqSfiXfBnB3cW/ht5eRt34kVA2r7ig7I/7g3WFjknp3+EfL8iqXoaZKnLjbxY3k/iCvgv+OOHFtmgejWd7vukZlPi6SiR66ZoE77nh1OBS8HNdSJ+54cUkX6I5XnSCX7otqUoH6fvpDLhhxhXdIHltShdqOS3A3ZlAu1DFzgxB3Sh7iVCg7tApoM01Oevwgfb5h/l08asi7SD6QZJyL4y390y8tRGyC9dDWlxb1yWW5PeJcf3zucag9I79HnAU0OO4Gon2qPzZwIrpH5P2MHrVipRiU8DSo10u7IY53wbwHZpIpeSWeX2Jay4AyQooP5aT2hERrTdCGp16J1jaA6QQTAt8D6b54hG4bypWWKPTKvTrTDXLSLcsIMXpdBaXr8LygEmm9i+RDiky3okLzlgbqok/l0kojRRZBmhLpKQ2th73Ak3fYrwmzbYw+FWgvdNWU4r4gUkc7j0LfoVRWDI90FpvIvBrGI4bhaT/SWfRscmKYoe/0IiiRilckMx3vatL4ifJdVf/hylLpXdP7NlXHe4rp8l1VvxXc3jPdY0OZ0Ekmut9agOfb8VPY5F8FwxqU93vPBOG4dxdn8L+S1z0oo43UF5613/dKsH9/WY14ELu5DeWQruhXFh5V7Z1+o+jRREk1DGvIT9b61bxkw969R2zxGdYYbEP4dxdHQW9+wiP3+SNOmM8Mv4jtvpjsEAf2/z1ijU/O044pRh5vAdeSQ25oRZYITHKncOAVOo9OxPOP3VDigTnc3dy0xOm/ErNH7q1XXNhSPVDGxbQoFTWmJ9Wq9rF6pcRuQ+kaZjvWQ7ofcew220xQwmQP+lWKUcqoVLzJ9yvQHeiCMiI9TOeBzozijOAa7bkiaCD3kR7oS0V0hlzrflm+4xf5inzPT5Y3QMwEJgXH934pIn+PWO97BfIUblKgFI9euS+yI5xq9xN96gHKOsTbi9GMPFNLxrtroL/K8p5x/EA+28IYjpq11QfNCT8H628C5OAHt1yr431yPcYF6tHSrR5Nt+oR57E94oc+1M4o39RH9D68D9rv4Bt41tD3cPuirXgKiiedRys/lbZzbNr2g7FDPgBbtAOeJjmO9RS1fI+ouBW3mj8twP/8D6RiXS25QHeoOH5bm3YrI250o00Txojr3agf79cnt0lDTNA6bSFhoSX7JaOpj01VFplzjvzgYfSqvU3LrpMNfsNiRLTHWSKY81wfk7wb6Bgcn9ugnlH/mMeEOA0rc4qlp0x4u3y25jrM4zhHZR0yrAF+ePFAqKcMdy0pdXXVaQn/Ft8X6nTBZG31A5MVP6OE/1PQ158y3VOJJcK577JNDh8N4ePdadBi4U3gi8HZ2OBOMwrn0DbAnZbBFBtg5R8BK/BVssSLNPvyzSyN8XcB99+zIpUM7r/jGuQne6rFCqZDp0GZeROsHJyr64YRysvHcxfJm64QoOY44Nqvk60+YSFzR7vdsLgn8Osm1IQLa3/+Iuv/R92bh0dRbP3jPVsy2chkAQIEmMwkMJCgQwISNg0DNJNhSQQXxC0IwkAQgrjGqwQIiijeSIKyiIBBISCSALmXKDEowYtX0RkIENYMgkwiTOiEpXr27znVPVmUe9/3/ef3PL88T2XqnK6qrq6qrjpV/TnnsFdIV1+gtgLK6BbZ4UvVyltekyKq6CzxuG1zdVXCcyjgOQ5QS/V5+h/tuD5h23Vre48P1MDePvy58TiToMZhLMxW3a2409UI+Bm60x3AHoa7/Nt3ZZ+ubaeL4x/jjNppZ7gUl6qlW+RtK9raHE7nMZxVbpG3v8EdXqO4OvxYg6u3/4YEajUPZCVnEX6HxbWwnFFNxnkCz/h3cr/78OR/J3fZh6091xVqksFsLVWfI9GIQWdOcaf9QVRWFrjBPmG9R5nCAmU2FaG+CbxrLLMW9fdkJuyl9R5B+4OpeTReJur13SA1h1AuiKZywShRLlC3ywULA3JBKJUL1rvx68ROzuwRajjbg9zn3VjPcHreZ/6woxxwQpQDfqFywBfOznJAnvjsO7l/e+gJPn2nVolj8H5opdNOoUWMHuG+33uEMZMHM2M/ZyG/M7u2KVGCd7dC2YWO/vC+/eisc6jzt0AodPQLRf83jBa/yiE+/E7z4fwSmPlrHTq6Dynkd+kL+bLsiHrheWLF+3zgCawNeRlx6F1CJW8pCupRkcqGwQi75UKJQg1j4kuvdh6+rcJXOyFvnucr8RsU+hzF8ZZeKUlQQM5r5DbsMeVsqCVOo2jJgz3CUFecTs3Krb+TW34mEdvvd9LsD0t02mM/jKL5lJDrLM0VYgnsLIbw6Avvd1jPUljMg2kDso8OZJ8pTjnbWfrRQV1jvfeWfvDaSG9A+qHYOeB4RXS6OvEGlXCaxDH8k9hvXdiu0OpSZyrbh0o1t8g+dzxINeOoVBPXb1waSjSpLHpqNjJXyAhPQKaJm1bb1DMNMf6oZXaFDPKoNYjTWpUNbQx0kieMyjlXXaFUfwzlmUsuZSZqj2G83lULfYVabndgz5IDz66GoIcw4UM875CZ5fRJcFT8yGtZpkhmkoujvZsbzztw/PvJH53mpFsgq/91TnqYb5+TMjz97zUnzcE56Sd3xzkJR8bTHpyTzOKctM+Jkhmjs1q1S5nkXyzb5slgdM/l7z0nMZz8oBB3wfwkkaw24KnMELR9DfFh1Ip2urWvqdgw1NKtnklOtUhGFBt6WnpR1CFqEsnuuJbsd7feGpx8w6w9ez3nkSrs317zVLYYyPVHfa05VXskZ1QF7HVswhd1Rt2Yk14N+9l5qL94xPxkBUpywsmfzIyrXSM9Zbthlxr/+JPtaLlJmiM3GSAsz2E03+cgtp5Zi3idSaMZ5tiYvAlFDkko/pfC/8PmvAmqAxm5cvP2F7azMCNNzKGYNumCIJiFYL5hpRZF5i3yHLzRt8gwp4BRS/yoI0atEeaTK+StgC883qN3VxQ5UvMbHKpOWgCxdUWOIZ04YcB5oBNnUiedgOphbw+9t67eLbLV/9909TJ1oTWFvF6K0iLV4v6T/t0tUuAP5JXSvD/5MziV9MQ+NStN8BO7X0pLOgy/DEekgsZfV8r7hz+HW0pTdoWUJ8SUu2lKu1Q4WYDdFn03A7p9NffU7dM/J+j29SjBOSOWRURtX0i90q/+Q47esf8IlgroWbRVUF+DenjSAVH1MdoGR3z+Yf4gyDBbHD0pziFdc9hxfz4iYc5RTTz5gKD6/lpM0+CIyVdqQWIEzgiRE5mv0l62K4EzReSE58dp6+0q4HwicpT5au2vdJydwe8D55amhzbGj8k4508vv/LQcKCHw+8IZaUE6hReL9XGmA7zNqjRYf6qOikhB+TudWJNFPVyLV4LM6m1N+GuinolpZWmDK3dHg50OKUVphxtA73jFfuXR3ekf3m0/3D4HT5R4x6urHRWpA4IqU+FlLX6w9rDGnzW2fQO3w+Q139P+RnaVnvFncqlivqs25VLkFOgbbJntCrSNhgU6Ek8DXmMeJfLdhzBKCczd97PC2gV/sA96mvTKbzzSd4P3OQO9JdAj/eh9Irjyn9DWfnw/h4TNxj6W2ZD7WZDLQ7rc7Qc1YnsKupEyuuPUX4erd0xWrtjS5CDtUPtR+QYKadIa8M0i2iaWcjZqj1Da3uW6kAqK7dV9IA79YASG/Xh2ngN4oxsPrxTKtwplfJVcKfZQM2mVKz2Oi3BYRf2+35S6Nsi6hvu8TGafjS202cTNQpLfXJR8/BTiAmahxt8Kvpb7YOaUt/ey/2CbmEo1S2c4U+l15PF9+GWbzb93YE6h00Ppgk6h8ZxeP9s/Rmy14crzhmy28do6/j1TC0fn4o2jWr5xNRbpApkjU+o5uYtsr8K9TZXlvvJZT+mvEV20au3QIZRTZQW1/FFelkJk3RsJEhhQ+Ut2Yygv3mGPOsLoddL4DpeE/jCfR/2KaicNqyfTFnZX6YUdCHTUwVdyFovWkZBXUh9qqALqZTs4H7yIzegC6nXUJS9F3UhYwfjlYAuZHpqOn2nO+tCMpKdXDwv6EKWQI6RFZKRmLOOXunFd7Mdb1KmKXfZYaZSwyyHFn9ukRTvZj5B1I3EdMF8Ha+Cuqz0t+tGniFzQFZKSdUUCxqSSkj3sAsxK+GSSFilJ7qW9xhzPVhW7dSo9vDrVbjTOt7UU4u4rGpnovq4Q5Ev6D/20+/hN6qRj5qSxx1B+QEEmG43orcUZWP5wkElfJw0aFcZ97u3DuYc1HAsceg21jkGri5xpFAdyBLHAFH7MYhqP5Y4kkXNx2BR83EQSIUz6T6vzvFO/qvNP4q6YcKZdEZLeUGdYxXwG//E3w78d4F/7E/89QXlUMatZnnbWpJx6wPgNXag3wb6WBv91sUSXgd9Vgj/MTY7OegsttgO7gy1uKZLlcOsUOh4Z2OtY9XqQse7q1FX8wduuQdnhYCe5g9cvgdnhYCe5g/cix6mnywB9T3/d9qah+6prXmLXONRW7POcV9+QGMT5ec6/pA+kepn4rtw3KEVNTRhpPD/WUPzhirIWE+e9tbxvB61M3n9kWuMdhnM6ygXW0yCPmXAukzSfgtflLFd1KgMpVLrGbhbKznoZ3S3UafygZZOcit+00dpVUj1uT+gTclReRXmHfL6t2gDAZGO6SCpBe38jRDYP8mhtdfCrlq266iWWgd5FHbqfLg+VLuHj82+Rfa4zxDepTUjKmrTPHymaqdKVe2MVlc7Y2GssmrBZgeOV6NexB9Sz+ZreBMjIhDp+I2l43cPP07VjjyMk5ZxKzwljuEi2jA1H9+dNY4uIrIw7U+IwyEif+ifEIcPiPxhlI+IwzpHOvX2edwRkb+Te49vfxdX8sK7CO+6ttoZoceZDPWMUcP4djMz/1ZzSL4dSitdMJCtdbwHJUTmP2lWFQeVtZKR/nYve0Lfli4INm7IDdpVTxbBDODRY4ti/3r0O7hWb1f0mDI1FuRrQw1iHXCHx6v6G/tPaeAPFNmIwwV5VElGG2l04eyyg1voF/pkvl+Y8eb4hTfiOb8w6zzj75lZR/u4t79HJta9lcThrBjdDUo5ihYXX5bf6dJB07Wvu7Omq43sc6GmK8xX0lNcOo/4BkSvBUP+z2Efvqc4ShkHc+e/4PcyhJvFgg6su1jQg82rrC8PYrNul78Ynhk+2cyehL0nk9gbZDvUGGt0RVyXyyTsDJCwlUNs5G+uA3fKl960Tsfzzho9yMFdoGxBB/bO1+mVShPKZ8GZraSHNxhtGmtwX/T8rNqmLlrtbNzPFcF9t0FAmTePnqm9PKWwXJZE7Xc8hvY7XgT5ONS1GHKPU18hPqeCVVUkUN2Nz2fjrgRXJKbfb2SpV6DQmsdv5DUvWvdInFPb1I/aBtrK/EYWeqnND/5gTi1/CHbT+jnylmPAf84r7NZGQc/acqi1jaYRkPPBOY/C7mwH19XzCOzIGAnGIz1TIS6X6NkdXIgnG+JKGpd5pkA8nMa9bsECiErCUZkGZjk+dmahgwVe/MOwCkNIhKCDkAJBD2HIw1scD8Hs9i8nJ8pFhY4pkH4UXMuAMA6CEcIkCNkQHoH0aZB+L02/xaEPLXQ8thpnylr+KbieA2E2BDOEBRDyILz08A/cx86OFkAO5bWSfr7NvE5fyMelRmlLF5cueM4Mc/NzULOpsNI+NyOndIFUs1G0DFLLb83Gs4VaPI3gv4Tfcvg9oBetmehFayZ61Daq5S/o5fQcEscG2gyZBGOjAPr5Efh9HsIrEN6G8BGOGZBdMnLRBxVfmd6meT4ZZsqSTjPlcPY0fSu0XpwpEc3beaa00KuZ3vIFfnLGjydUQvowrzBnpidep3NmI8hqpHIo1YXuxo6sSDMNyZSpz5IzHkZ9iqS6lPuzbqvyrpAfYFesq7hv4n2iNvQeX/8ctZmrSjbpMqWQvsbzZ63mfqaEzLNkv0eiPmcXytgOZTC63yzMOvXEeBPMMHZBlxpR7qhN/Tt5hlf0OXde+Np7lXwN8/vJ86msoTU4CrFF+xDlfl6SEA0pM/mgPkHnkJvtx28ak/1f2MPEfJ9CupZz/7DfFnWp30qOUkrljOrauiilEwLqUUsljArlXHzvUIc3AcrsyyM2De1VYgs85qkjXZx9TDJzPKWnwJOcImVO4UTmKsn1Iw6tu8lu7y5+271KZlJeLNXhvUpkfqzrVXLLL+8Tck7wbnKWDPTgtTsgSZ8RUW1XyXjId+tciOk7O9YRMW1vJf9V3xfruh6u/7wObVNLEkrL50HptX4FtMSciXNNc2k9Xe5Qm1GjKvudME6jLtIyyzST8pvddeQLPgee52lKX3Pj84xxdltfx+30PknPFh+nNTzr7g68T72PU95UyvvVHQe8Eu80yptMeUfd1c4CfbYpk1LfArVcP9nEUuqfQBXqJ5oMlCp394bcL3uNNPdoyvvCLUkYD/WfTb+iGyZ+aheQm1fJt1RT/SFTGq3nWvcue3jNqImjJ46mlgvPoqaXRlqGp2F/59N1H1iDoOwJ3mG07H40xWvuYOCN9qZRXgLlLXQrgZfmvZ/y4ilvNtRyiD6Zap2fJU8D9YB+gKkrpR4DKl3fzxRNqSx3COSO9Wpp7gjKG+9OEHEJ8BTUT18fk9GOVJCP9r+P4uBqsE9R5xz7FHEI2K874F3/FsIpCDcgeCF0gXR91wn93BHDmQ68KRByILwIYevUKOVeCN9CKFzXro/eWT/7LLnjwh7O5oOMDbBfQv1svQf1hG6L+uBvJd9LHxz6n+YbQvNF0nyv/SUfYgaUlcET48zpkC/IFAT5qmm+OB72bB48I++Yvl0H/CwpE7EEZ8l2EUtwlmxxteuAnyXrv8Y8f9UB5yagDviNrRAKlrHhrLL/fexUNgHW+99IoWdsfLxlui7MMhPCVF2UFbED9TwDK1u68+i+P+ySfo32dt59zmDWBhIjzCrqOlLtj58Y36Yd/huZ6VJXCd9L/WSRt3sm8h6nOACDL5ZS2ZS67I2mVCalHvRHUspAqWn+CEqNpJTZL1Ojzb6zZIALkePtWMj/pBuObWD7SMA/qip7i/qfa3mUjNr1wz/pEL9NdcURl9BCDvm3Lmi/glLXO7wgda3gBalrKS9IXW+Ie71XeWElfNmlZlvJYfoFH9ept7IDZ3CH/Pg8h7wB3fGt5XJI+Z3PWDHMlE7fiW+cwmmqmuqQ/0Z2eRWiDnkr2eCs5ddnM4McFryymV5Jp1fehyufwBWbBdGKl6HmwsqggDVHaxLe3w+cJ6kt0FX8QHYeK8iE251fLIg3pmqDWkZJ57Egw/vKZ5Uu2JSrrepuiqW5lji15q4i/pPRdCmr5W8zgmT5trNdT53roKfepSzUeIac9NXyNxhGt8GqMH0LfZVQIvTHYPhFWXdMidAuuKcRddW7f20InJHv7aCr/ndRV/0hqqu+zvCWZSDsYKgHiTEtZNG3qKu+zoB21SvvyNt01X0kqAbWvWi8sqcgGkpT0PjKAkNrEMQuWJmWrdKDQwLa6p8ZnNahiDalqTZAqhCI/WgFSZwR7G2n27In74ZrGwu09WjH/aOCyaZig84yaXKl+9adyjuupXV8Uc5hbnUBtdTjYEMPNs8Nxf7Yijr72Yz62OjaprjsLyiidB68NZG2B6HELhbJ0N2G81bUXMfTpVCbj2T40WJxEf1iJvCPzQrossOeT3+/kUnmqOa6g2quZwkYU1Fz3UL7J9zZEWV6lqJMa+0+csL3nd3CH2Ys9mKHLP8k7L1ebX4nv9ihoL/lzUzbbj3xYkUHqveprUMCuu7jRF33T+yB1l5ZXQQ74AZH2PyDzROovjvujgL67hvpudbHHc7ADRCWnraMFvt+QnvfryvoI/b9yxah50eJPf98p55/sVro+dctiCFuaet3w7eoD73O8KaFWiiA2EK0UAC/DdDnx6S2Tn2uQ+wwXMulngrXGdTwG2wQet7GDLSlQQ/NtHSHHn/GMhj6O96ib7NTUMeXZE87iT1Voq9tUus30579G0gmXWz9IV9Tvcx84YXZ2kDP+cgjPpqa9itIpPre0I887cc7tB9T/tSP+I7q+I79eJn243Hox2bvv6EfG5l6+7G/9Et1W79Q+9bwG3wIe+B7e8dvEPvQR+MBmRW/J7SQfx/C7wtXO3xfSIc5q4VMhXlGV6U1y8RZQD1bB/st/K4wrHLTvgi2b6bkQznLFPfJjGH7mFqJxtUb9li9J86a3XtiIZ+RXTq7HZnz/JxC3pwt4HN+n9sNdkVfcKu9XUVszhdcobeQ2kwsZNBuYiG8NbVNSY/WNvWHMODRpCVxGvwCNom5TL70IQZHTzE4yRtg3YdwaAP9fvLg8Z9vZ6RC/MENKOetLJeXPayV8JLRDEVTKGDGDXLJ2eyKU3CfL7gD3uQ3tBUatswshfV6mFtNUSSIG/ETW42wl3y/PPwrJqkfn/i0gML6ggvzSSnGOY1Fm+mt5KIzqE/MOS2UlMpuM2uhpGiKucBnqqM5fF49Gy7uYxDBgZiKBkfPfMRVKOnJgnE1nrOdJtNcJXyGHrEPsxYEFSNConTB5UXBxRIt4iRC1gWQEGEwz06gSIichS2E6XDqINzxqJfpVwvvXEcMROCb5xDLkYVobbzjF08zlLLJd+8vnhlw7Xsfov0e8we0G1HPOQMkgUwn8qn+lYj2wpJe8Qlorwa6T7pgR7t+TOK75Qq2gM/LwPI2+hTQhjGmZFbRMkmiZv8gNk8Cq5oUp5HuvEy+8Uq0CeY1fBy0RA8IPfUgK6aidTq5dkAFeuY4Q465Q6CvpGVyiL/mVucQ+9MjZEoPyE2N02KVDJTKqP8g9kN4nh7bZoc3pxOGD/F7uN7XuoVWK/EI/VbkQdyAsuI3ctWJ2sAYa3BiX6/jhe9rON7wW2T79/rfyC9OYW2PqSzi8xBpkvygpYhfpYe3XX3yqQKYu8cu9pO6Ns1OHYwUr7Nds/OFmhJIDe8HU9eUFC1JO79vas9iA7wV+ssL0eabrgbiDH6rxFPyYndr64eGiItxJojdChvHFHejmEbhuYd78MstlldH7w7vk34W/Sbwkg+1QJIrSvgiNeqHNoDcISA+8B6Br6FY5inxu3ycx+/HtvWux/eiqCaAR/yC0/mE9kr0XV4oh5I+cuYslFEPES3kUnUAa5hX2Qv2yEFsWkVPU0/Yl9QT1itR97V9qUbpEr8i52klGtROrPMm5eypCKDeFexrVZKESNjncDyjCzkfIe74JgElPa9j60iBq/POOcj0C9SZF/euieLcgPMd7luVk9Qgq+s7eGaqI8+6ZGqZSZ5ZTzywR71r50X7S5gXZWZJwgflj0IN9vKonTdt4jTTI/QJfvecJJudU2FHmE3pi5C7jqS7EOV9lVx2qnUKy0TY3eG1Xz2N9ky6t6snP3pC15/kPvAJmnhjKK/Gg9jtB0WM+RhTPfmHJ6BLd4Wc8usqRpseoCXt8vxkb+Dl2xr4nwsaeObDdp066U7px2t4VfZVcpf6sR9s+p0iztHW3EYnIs7vM/2zTaeunqz0/G8Q5yYx9UJa6zRfH1NA266ezKa1DmjbxZgkQ+rJDI8ipdLa1RSo+6vUJkK0aQtFnKMWHrb0BNjFm6GfsG8mbxD6qaMuHuLM12zorHe3ZcNfMeaIQcfzh1jjFdJA/dHHmGJoO3WD3vmFj4LeiaR0F9o788Tzhyuwo8MdZ6jJbg8Vzx+ukATKCxZ147BueJYQqFtHfHnnPV89aXBj6SOcuOfryuOebyG15dVxLOFeEe0ISDToC/p4k1TbwF8oSslKmYQ6bQKm28RKd6Ne27+4z71j42NhHxZuFTDcl2FfgRhuDewC0ULXF+5r9hFsAu2HrW6bXbopPvNRuvu6TD5zq6pw5zXOh5a5LpONbtxBLaMI7MukmFJrfTGUep9ST/ujKLXSra6IzDSbL5MCyn8Pdl3htMcW0if8kWdqHtwotEnsxr9isAP46745UcoZPwp2xyxNzJCrPberPmRjazSsRLM9DnFj267LlENOHGgpyBp8ouSbJLbrdaUyruYsz+hP80xRXM0xiFWN33E9RCm3GNhMFhGVTteLZmWLXPa1IXncZ9eDlQpLHGtgh7NWQrwyVnZdGYza/1KLEdKG+BXXC+U/NDGPH8hB20KLuIxxW0FykPgV7DG055CFK/t75SjjvOhbzqYjjmVENhtG12jUp4lTXyZ/+BQimqUF9vV5WpRgcBZlBtktWvMzAZlIkzOXScBVK8cl4OqkZdNhTcrmbXPjqraZHzNeIqH+R41bHI+tvkwqvFlcnhLKKSjkFQU4H3/pZr6pa+q3ZIthhKU7zsr6kXmwy6LfgNbrhZXCCGU0+uqaBsRsMKxxSFa/YAmpWOZgVqM1Tzm15Kls8ac/61rFH2yZFfmrNU8r1HTklJETQZrSM1pcUXA1eezE0/ED2Z+e2mbWs5fIt75ktsWOX193XJeFVLX4H5Ja9cafuLNObMvYmskwv/S4rlBIT/Suuo9V2IT96WXytC+I7XY9JDK+BusbxIfgKlP0z+shYXLLDBZ9GV8mCS60vxbWIpHtux4cljYO+2sG9NdlEuvC/grr0F+DfUPHgbQ3F3eyK+2SXXjW7icNvmK78Pzh8PxmasXArE/uhAFC3CTDGMfugLXpn+sF/xVr4Pfc+ihqD/izO0y2XPdEfUMjw8lGGqY/y9wPkvx0SzxI9Y9SHJDOAuueemBmBUj2qPsHK+BiXAHXulta97tbbm002BZmXLgyp4jqZm5yd7GpoYSr9b8tFNfLxcJ62XLryhxm4A0LYoQw5bduRm2bk1d9ZaGbYoOKQNInVNLv0UnSR/ltiKujnH+Vyvnn7IJvFY64v5UZz4koj44yPHN9uZRRR8/rmZM3IZ3auBq7QJImZyMsiHheqg9NQpTzZfKqRzI6Z0GUldnXRM74Svi/6XtVyFueYq6CTBM0kdGo2Z45LUTnwW8pEv1VqwPm5rrNUUpmGp6dBGxcXSbPiGcXiMHsb4xgT5PvnWituBBk1e2w75SkfT5Xbslo7RWVYLSS7S6UrI5QrdM+pj50pTM5dVRyjzdeJikeLZt1+/yLPTOxLidIk1sPb0t36GnBR9Xf9GjnOXYiU3xdgz5VJQkRxnoS5GR0ObPPg7Q9smK7+QQ574VZkI6P6d4TID8ozC8Yfob6BztVSvcnUcr4x6KUVclRSvW2YKbIHKXUwnN9OFmmNG5Gv5PxE1EzpBuuYdN6msLYnpkt5LC7B+xhjmmEfYtKW9sUDb+xQzNaWwdn3B0iq21KjPn8+dqm+Ec/nwu1hJ3KmxDegrAUAlo5XwW/72fHgkSDT3aZzECsJb8oGxH9OD6rNwt1wjZWVR7mi1RytolsBJmzSC3NLNQL3ht/OPTKJ8L1Enp9tQclufbr/zj0zCc4xoNYZsBsy9gXls1lklnrihfcVU3kJQ/TUii5D9ajeZ79i+TJGuv+F85XJU9KmRx5PLJ2XWMkUwgBrwyzNpGnaep+kHqqh1Fn2CTJV4E7lXITjBfskuQma/wk9WSbPSg5BEqKqeoxqffks8C/aO02KX5ynV2ZXE/5MZN6TD4OfKsVJPnJx+xN5H5aSjdj+KRukxuIxvMtlKGA0rWUH22shby1QPeidKTxkB39P+ZV52+CNQbGHwfrjAfiuyFgvBxCHgQLhCIIF4CfDb99oC0ehKBvzgkd3JzT88XmmfkFzZJ8rnnmfHtz//ne5mt4GjEiDjHsoTzFJVymko7ilLf5cs8oei1vwu3m7ynXebG6+fuB0bA3u2XnKyOMEVMiWWnCFbLbzSQq2EOG0HNdNBNaJWN0IDnI3Tjf1bokQ1rtAhLsCin9mql5DvrXVixnUI5UsG+Xv8sWsWEVLWS4O1W7kh+ihxn1TvniZJbRHOHr1aV8o/pI0xDNkaZ0CCMhjNakpL1n4KzovZWRreFj9KPYr9ms8amW4JYBstzFMmFPuzuiJUaiY/fwsVvX8N22tpB1Lq5qMx+r/4G/oUd7QZv5buofeA7o22oZ55Gd5m1qPtnAFUjlLRK5EiS9H4BzdV94zQ+8BVJZGMmwlAf+bUesQqqliUx2a9gemQ28uaBQ30Dy3YoWSxDT/5AhqCUlqNvZJjLa/RivHCUrfowPHyWF/6pREvifMoopHsE+xsePGsNivmfckmFX7ev4t/Rjq+ScVyZPlluUKfE16IthqV7NUl8g73wAfbgLwtJKhur27uHD9ahZsYdX6lO0MrdEtvxWmLQLa1VJuWDpEb5OhW1XxBeoFWxo1ZGmoZpRpql8P3UQtFBKYsw4uTvokdzFdfBcJXyduo7nVWt4pZpJNlgjB9x3NqBjIS3TwVzldE6vQh8rtbTdIuCX0/thfrutV9rqeJtexi2VLh0INcZvvLQ2QdOw73g1jT/KqE9R7MZR+C/Hr9lQtlDyzzBrobWrP5fxG6y99fB8IXomObwGUmsiB8ScxX6Vlsl2Y869TtSD+3OtUONknx3PNHC/g++JgGOSvhfFLl/U4Oi7eguEZ5QfGXQ13djC8leZEaycNYOsNNOZxaUoGY11X4VB2iJRJJyQ75ZdHyNTuiWGNOi5z/hGfZ0jKf9g89yedY5EREiE4plmebN5INds7Cmca/rJRJ+UFbBkA9l6ezorD0hOy5gaxuYfh7bo9JUWWBveKWc0vZPxGz70pxpGqbrvWdkLh/lC9fJFkrRig+z5oBPw/rs0LwzNxHFigljpoo2G8JM4A2ufR5zPm/omEurCGWIQzFJ+2JNDSkdKPrZioV77Qk0zk7/boKwpb56b3+Donz+huX/+Fkc/eMcn0Lf5WA0Hsd0GeU0lpEQsJrSCTFmDZ5Qyt2KsrOa4Q5aPJzMwotSMJq4GR1KKRupWGE7A2FkL42wNH6t6oyoq82E+SaVoGSANHffc4llV9A0sw5XuHB8MK9sJGI1r+K7qP2jvSDUc9I8K5qghEPquzK1hCvxjGaZgnNBnDxkZbcKkwDhXsKfINGddm++3zhoomhOnyDgn+oDuNql7ptb8MK9VyWg95i/eRVtSmxNa30RecaoyNWZsyc+dCWY8ndni1Zp3QYuOqsE9snASJqPjsoBHzST9KqZGCfUp+Gg9o4JfrNtjm4T9L2Lj9txRvilnmaTDRmbdaZLi1i7YOhvlng/dt1pOk1fc3xgPTWlwHFp9mvRxH0uwzT5NFrizNQNY1U4bOe2ZrZXsUpVVGk+Tf7mybh97UT13AJsIV370JJZVAHejq3TBbwty5iqL1QvC10q0a3gdvBHp+q5cjWebuQxW9lwn078E5ggZ51cwyRncwGXz2AMgb5wir/mZTUzyD9SL3vt6YdWVJih3XiFL4L0JO/c5SAj/Rm+/5vVQzgTneqONcP56+2Z+gP5ccEZLYQHqfEnLti6AWaHgNLG50N8Pk/yqBSRQ6bYFhVC/n6muJaN7wSIzf7Zok3mLY9XGBggxZesnRBedIvn88SaVJGZP6aKx4588G71p7HgYjatD6tc5mPwDzcfo+Bt7aiVI6zE24IUe5yI9Et3Ns6cceL4uXG88/88Op+2X60voLCmk+JHyjDVQwsYSeBN+qiqBZ91fhWXhvKMcu8IxLLS8eR68n+aeUE5PfzND39HXPbBTp2/pdK+yRaKUD/3STpqZNnRdPbwVxvyjcJcfoEWG688HR5yS7rq8YAI89cMuXEF6VWzmu+tXUKtcBfpTRM5fbEoUR+cWeN8+MtTcTt1bDfuULY5xqyVp6AGgjrT4Sxet4TfqjzclSmTQn5v0W9nEPdDSIVmcJLR00cTxhrMhuIK9Xe8YmV8P79futxmNJBnRWH/MrOcvqJU19TAv/vHcQXgbV/LpW+c2r8pX1oz943vZUUcIxJIh52jIadNffxvXRsy5eya2zlGHcnVczcC3jzpC83tVZNKn/8aLLRZTgfHxvpAWSYiyJUWpH1plT9w1c5EKnvYz5y/Xti74jRzz2eD/UV9Xbpd7m1kFY2YQj7PQrNmM+gKZBfvfrbpYpRECypP49/6AWOWkobHKD2Gt/3SzYBOdvucwB6L9zfLN+K1XOjHO7CeP+2BupO/9rTEKNpZdz6I+hZ49QZRuRHc4rYa7IdpPDPMvGO4q4Xf6uQN3dM/i1yb2gqFVMu0TA8MdLwi6cOBOLHB/KFjExQWzNkOrlF75qcDQqoDYLWvW7YKZGayN2N2n+FV6SdGTVbFqG1nhR5tDChjXr2fWcsX8UX5Vxik6shnubIFk1xi2lvPzwWxjBZ6JS9kyc57xItnjxzTtthggl/4pm+GuHOqXbekCNZVAzGgx3JXBb6UVn6aXO52eaXLLDHcVwM2Dq0Ham3bD3WFA9YU8evgdes5wNwp+f6elqCD2kbUe9v3KZKb104KDvFyFc9ci1ynIF63FJ3y3wHA3RvsT0NlA++8u3Wu4+zjEtt8Z8MjQi/pRspSasy/ZUZ4o0H9th//MP+3JC/AsYb894+7zsvXjpWdhFxX8pX37Hd3D+uFUnpi2xZE+EGSvglOw6jU4HsAVruep9pVvtY492GwPRVvdUqrxvs/9vl01CtcG+SMHYLXcCeWvsO9e9G+70JoP3X5zr9Ba0FZ5r9ix7Y/65KyuYiyLrd8TWr8I9lNHub3Q2voKJuWAhWrDQI69WIZe6K/dvgKxvyIyj3Df+KG0ggQW73GEO+w3wX4wLHiCXWgxRX2gvezO0XAlKHg0rDtNsKwvwX2cuB7juQfsYtLeLYd9jBS/zEiUx5tkqZsmSouXsZG9d7OSdbtYlj02vqD1o4JR5o8yFR+rYRy97lJXlGRi7CWX+huYSWQbxve+eIaXby3KzAbuPFcQe7DiAxqf5UKPDdMs71HqKUpNsrxrejdTpj4Da7tEfYJ87n/HdNe+nH2blmlCm1SbCjNRDlWzkmIbGQOcoZZl9OpIiMOVpLcoNcT1ZiajU7PKGqh7mI2kQM3y6ZX+Ll2VULOeF98wS4tfptx4F857UnZr1XfjVReDy14z24jUGbxJVtTrtWkVL5j223FG+touSfrFnmv6EsIuu2LT/Mw4SOdzyodJofZLb7+697vxYZA7HbhX+OBNcsjNJD90O3fvTNNa+0xTkZ0Z9IilkVR5UUJ5BmaNr7yNZB+lngRqB1C7KfUEUFuB2k4pPBnaANRmSj0C1FqgPqLUw0C9B9TfKZUFVCFQqygVqr5EngVqGaUy4dorQOVTigVqEVBLKDUOz02AWkCpMUDN9I62Z0ySbNSamYEZ3MkCXE9/Kci6HZ5nIy9SVIF0oyzBTxbzSTnj99OT+BeUCXgWz+jMFrWZ0WVwnxYwWsyhzbHByiLkkUCexyHPyxWd8zDcewVCrnUFKH1oTM5raFt38KewV4MQ3yNW+dvRGGX2m9HK4Z8K++Jn4TfvTZhLF0YpV0L8/U8FX6Q734hSHoH4TxB2QLgMwQlBsiVK2R3C/RAyIJRC+AOCdivsJSDUQfBBCN0WpXwEwsxtwtnGNfgdRK3qnCFePpkdyCoT8PS2P8gO716UbcD4/byc/o7kteYjTV3nM0krYL+/gn+rnNH2FNNHOrO/kQyVwDu70y0d1Hox0cxoJRol1a2QOCWCnMwz6hBqqUeYG562R5ki6Z0Pd7jzHzyj+/7CHNHO4hy7POmkXWnKuRZWFWx6+ppEA/dW69inrzE1X24T2upH+A37LEqZ8pmgy4BydjeqofSzR9XSIzLYOpJNpd8p8VvwTXKK+jz+n/XJbpIRPjV7k0T6hO9dT33R0Q8C6pPZyGOiH4QIU3plXIKMZRK1FRK3nFM9td4gs0JMPX7eo1WSIbKUVquaRT/nZ0gmjzPAdm86fkMT7SHWJ6P+bcA+laE1PApWGr1gFRT1v2LotaixF8xos1ei3Yo2lBlpeeAsitG8nID2FEpz99/ZliVloyzjW62S9wyR8JsPv+E10VqzttjQxaJ9Y2Sbbai92jv29dpb9m3mPrDODfe02hlNOO2zf/l1OilbyGcwwZak+uz9Mp3s7NaWWNixJtYzSdo3CnmnBk8loyBfb8+6iq25qkyVCb/bjmnNe3knyEWhLLM2IhMt4J0mFqjXbsMRC6M+Yn9EJzs5Q3fhrE937oQk6SzM0d+VRikvQTgIYW+p0BY3Sv9qbzrhNjMmYHNaOL+WvyfRbisHCT6N0fSi+nG5fkYTVBRPn+F5iK9ge4l2HCL2Mlq0URya9q8mSRrIqxCiIcSmhRfPTsLTyV+JzoN20uJ3GVtHSC6ZVdryCREtLzLbuSe9eGKCvjfxixHiRHrvRKz9dm5Khyth9EpEyysM4u23cxkdroWL1/IZxN1v51I7XIug1/ruRBT+di6pw5UuYq63IFcXuNa9w7XIfMlovIqe3hB9v9lq0wjPOsufy/WVntgntMJTfrSF/yv52h14ykr3vZ+y0dNeuqrtKVVw3/MdrkR1eMoouHa8w7XoDk8ZDddqOlyLaXvKGLiyr8OV2A5PGQvXtne41rXTU3aFpwzdo/qqwbEtX/FxzG70ejyQXQvSe3/Y7X52Q5JfJMa/NmwF6kOR2gbxYjFeCvHfrYwmgrbONB+jWcZ2ofHJEC9gBd3MCRAPZgVdsjG+rD+aZIdvSaJlXLwsZizqPWX90QicZdIAJ0HvVoVwfUOQZjgZo+T6KoO5vsFxcC2xKKJlemhEy+yQLY6XYN/00mr4Xb2GTypYw/fLW8NrGBP7OIu7MOVu1NWJ42X64LWSkQzVCbGF5jS/G/oz188XslvdrKRXd9yQhArXtzieC8U0P3PdfA2OnPzgjerm/qG44h9skUVCi4TWWS86euZvcczYCGF1C+q29z8OnIMs15y58R83JPPvQHBBq0wzPtA8J79fs3L+q81zZ8xpXjX/+eZ3Z/RvVuYfbd6xejiLOxBvc+MMtDtYDfs01FvxNv+APpVm4Lkini+ugVZGDZaLJNrFNTfmtzaHr74Nv7jXkl8cBbNFkAtmH6VkmOz+w9bhU4ZlMUkxu2XXV8qgf+YrNjmhHregPn+tSRmtycrmHRsVxYirFGrz4/+qNuid4CL50XmguXGjUJN09iL5zklrMlQ2qNoatFF4d456Z7DCe3PYi6cu8jQ8AZRaI6HmZc4MNiGgzfZ3pgYxJe+uUo4eNGhQxhuxX4175MrKh5jySeMZ5piBYfLHHYH1qPof0Uo3/NZ/gz5ZA3q2a7330rN1PhdK9WwHlwo29eBtfem7ii4TN0CqBPaAu+X21X3HUqLqEZciSXyuT4+EE/t01LaNcBJx+/ZR/nBGenUC22g/lthM9TA3VCgGxJwNhRALYSCE5yAcglBxp2Dp+zXBGkbTE1aOCoi57EEa3q7Q3LXLNbftMk2rHc9uJJpme3spXSGkQJgF4Rwt5QSUAu+KpjeU8gHM+v+5FMEv5vJcWCGWbDTI2e7WIlgvYpNjTnZNlp59ZKQkuUu9UiO0/jx/n4m1sA/oTb/dBfRYlQMS6+UDdPXSARzs4SuamdXr8bxrdYOjK4b8VTUSzXrY0c8FPqM5wQhljfWjJvE7zTupHl+hQ5Nf6NCurrPvh/wNjpDVMk2TfR+NB6+Waq7YQxvjR4Y2wm6LYViGKWBRnxji0K8F4wXfNIokVf8pd3N0uJ8XfG2OsNy8FfX2O7eiVp0kt/yq60rpmOshstqmUdrchAKqgbneY2hVwex7l5dpckUfmsJ87OBL+DF69Cmqgt6YT681+e7uextthYhp/W6ZTmmp4y/APH3elXXbldNAIvyH7e22NU+Sf/ontOqnvh2HpwFjrsuC4e5zHftWdijlApTyuBXv2kCafXX8YRXV8/QJnN99AwW9dN9nYh/JLALHL6ao88WJa8wGkfOTryf00EF9D/h/SC/Ml2F+4Vq1T6JJp5zlYuoDPpVmGOW8LnJ2t91LbvlRE0Wv5YrXNvsYtfDlGm1nMjXGN98bMX1rmEFVWQTtJWdjKoz6OnKJty1kNLV8uHY7r9IqK26ipgL/CRNXgd+IbhL7NygjCbq5Kxf6ic1vW/j5nJvkPE11k5xxY+svqQj4Vz02sqN3VbREUUc+4BET58yTwTusn1zEy9L+eCpqoJwNty7D2r/4oSHYKkkLTSh2t7RK3NFpBZCiBELWbcbQ9JSa6pchjZq6ztQVhj7Qk3XQk3edJbB7jqnAa+6qArGXVrhPEqsPRgvcf2Uc9GQQ9ORjOBvJ0lCLt1GP6UMTJGmB++GVvGpB39dJR9tMKGOvL+PuwdSVgfFAS7kE7YjzS0DP7mdm8BREYWznEP9VC3U6DL/H4PcQ/Frg96BbqOsB+K2H33K3MAq/hF8b/O50J2TaFt4kZrc6U2jRWfisMX2MF4jKL291JslbZemoaYetIVgVXu/qrG13gbh948ffsNbxSpmVW+ZBTbtIyM/BGOUZK/ca5YQBxw6c6RIrt8jTrpF3gVz4Vg/PtA1k8z2TBT28IghLYN5d+1m7X8ooY/SU6KwL5KgvPJHRCJ4pp7nQM6UeavC1b3tLmCRC86G79ZbUHRMTU5UO3L0+yZAXUuyil8oLZMe3TE35Z+1+KpfCuJJoVUkogw5kmQQz20AuOVG+ms+OSLhkTmbLJyighu/51BT/Lqwp9MtITekTOM8Lmn03SYoz6J6afUzNHLgf7j3wzAxTl2T2gV1JrLMY0odsen5W6axx6gbSlSI1Uqm1szq/pP/vs2DsKpkktJSCONRCfkxeBtTu705EkdY29XwUdfwayDtO9JvlT4vToM9ualUlB+bcHMRsIxYBcQgN5CUn2vWt5Q/rX80UNf9ydOx2Lpl/CehaBuNJ/IsQP8akQ7wvnwfxnym/B78Q4hYaj+EXQLyOxiP4+RCvp/Fg3gzxCzQu4edA3EbL0fKCVbpR2lr+KiNo8ueEwjsA9eKZRpLnEnhPUv3ARmIW6cep7l8jyRHpadQmQiOZLtJZoair0EiyRXoi0D8DbXQJOn3MOvmdC3k3ycgA/bH8Tjeg01ybQfor5PnUWbnw1k2D3pxWyytnwfwzDeYfoKOnJS25l2ewz3IF32D7YH92JXcY3Z+tNoyg+7PVBp0lRvPZ4ufMM3Ku5CZoNi6elfvZ6xupD7F+c2fN/ULwHp6DX3pq+a05ou5gjqg7mIO6g6i1if27hVeLJ4/D2kpM15yyD2+jRmh+sY9so0Zp/gVzgnw77L9gjIXDby8IyRAegMBCeATC8xAWY8hGHcP8cTKKtY2bMKiJjB03r4hVsO/CjtvwtwUVQzKHTJSqmYHKmjA2zZSWeZpYYd9PLfSu+MHM/K0HvBFBbEbVwL8xawO+Gk6TGv6GqM2X0ebJQUiRZHLYs26zsB5s98hZfcXxJubjU00SLWIlX/EtmJlYFUj/kz3g0wG9qyKG6zGPvE+38wIW7zLZ52Z04ecNVB8QsRy7gJafx9gUt0S9x46xTLd5HqPbYQngI80zt9kbP49SNkBo+VzYmwZBOw35QsDCUZ2iRNWUYHj+tex6Nol9tSqtx5PzllTpe4xdNXZ8qHUsO5XNpPhgxVjHPqkt7elvDJwlbogxpcla6VrJZYRYyadePAdQVfrIeb+czZiX3nbWPGsmo7aSD7xSk4y2UzJ/1165NJrWA9Mf8aNd/MvkMrWLH2uKzZRBqjjeQiyeaJPMrKK0ipdAKbleAft3mQxyI84vzGQXdR7xybWUp6S6h5fJUZfgPxTxf/X3sI8v2O0rKw9mfWSZH21VYS0+daNP2Vzze6b34L6nYB6ykPc970I93qH0z36sR3+vJGEnpH7HHdRHem63eTnUY3lbPRpcqL231PQGzbHff1H0M3uZHPQYdQo2xGLUMsWvmZZkylgppPjM/4qp0f6KaVEmUpv8F5vk2gUijvRF0ymy1h+63so97syjuM3naapV/jDgTXYuoLwcynvLHw68sU4z5T1JeS/50f/s9MyN+5i1UvVzUFquH33QPiJyngXOc370Q5slcp4EzhP+zY4okCZn5Jthv4n6H1auO/XXENesgniU8xF6DwO9h8E/kO1WhugJIzyfjA22jDEx60bSa0P8JlO+PR7qRfhMmmco5ev8vYHn4AUrzXrK6+PvA7wr/BjKS6a8WD/6Dh9NdWxPgbyInsNHUm+6p0gQUJ/o06l21CmQ8C5SX40P3NNjrpX7J6+n5XalqRt9KrjXHj6F8lSUd8mHHngjxHboB+1wytevrVdvO3F0aU0xdHR95MTnLXamo28d3/Lt7WMM9RwDPnW3o0+KbAEPa4NwE4LiYZifIAx+GH19RimfhYB6NK88/FcfvB397wZ8716F4OvggxffoQTfmHlyFrGswabgzFMgm+IorXPjur3XlTPPD7INYlkRx1rfZifZRxR/yvc0zXeQ5ium+Wo75RN0Hn2kyQtvOORSmIIgl4Hm2uz2k7NuahmwJpAe057slDaFpn3H7SNLfZ3Tqip7T+pN9SNPkR6+BLaXifY/xHrSWCTE4mgsFGLdaUwBsa40xkAslsbc3gQ2msbuQiyKxlogFkljN7yCdwuUrE+R30E2wXvv2C7oWYbD/JgIYRSERyAsgLASwqefC/qXRz+neNgs1MHMqZg0ZTnMmar+ID+/lsIiYjKbvUS+84+NH2GZrgu1dLswVdfforyQqetj8ZO/+3EeDHVLE5vs03TdLY/oblNcsN58iczzFLCX7DOBK7swQ9doDUo8Y1+iC7bk636zyhOtdknir3ZF4nG7LPEneyBPlufovto2yugJZqvtuokDMnuZn+C1OYgLLfDqqsayI+i5MexpvNpM5L7sFfxVDPCqKf2CSL/q7U3p50V6sLcnpZ/2qiviaGy6eOUHX1dKZ4v0OV80pY0iLfdHUjpDpK/5/CBHS9RL7R39Ad8Lc4y6n0k7BP3PuB1Uxs8S7PocL0dJv5TT0/PN8F0XzXj2p9LunKDSzaReFIphJxKdJr8z9pUjVUGawWxESypzjKt0K9iCqjqat48H5f1S7hM3Ig2i03Ts5LazkIt8Ksgh4WnV/AP6/QUMvY4llHLfupaxETtLua9dy6HMB4BT6QpmuwCnwrUCOCOA86WrgI0Ezk5XEHAeBE6pS8EiMrab9Wv4H2P9uOob+I204llMuPWZquwq3JuUco+5hbpZ3LBHVFQikgioiW7cVWmp3aJGPZNUZu9xh8nqWfNjCyPrtW/CXf+SOEofa2GUka5VTuC8Hlx8knTnjzfpJMebRkiE0mU+1D3C3U8p5/XiuhLcXLQrOm7imB4soueCNx13hLRZblGxeCIMVD5SobuON6VAWQ9K9vC/6UPKwnaX8Lx0D381D8+G9/C2rZ9zG5x1Dk0+ahyUOOI31jn6rC5xqKldIpRtVXtLHL1F60Sh1DpRRMt0ZYmjr2ihKEy0UJSQj/Z+8GTje24Vj1LwGsd91ObP9xzsSqgNoPupzZ/vudf4dHaNQx/aSN5zZ0BMtfE4rFRrHNGrG8ly98Ddx5skK5iPLzbptCj9NhPe023T4OLum1KL4zalFdfxq/Sf5T5QjJjfocXwpF8LO/fYmgbHvPkY9vC6mXhuqwTOHHjKlIfjagKWYkLKQncFs7WO79t878FuL01swY1IDykWW3DGLPOwYuQIrSa02LXyPfzADz/nfDzaGhJarbM1J5Tw4/e023QSWk3zVbtVp7A2q06BNvuOa/YLto0yaJt9x13z405gjWMMbbPvuEt+HbSUAdqsxaWHWDy0WW9osz7QZo2uUdhms5h1Qpt1gzZ7xqPZNLZYu2lcceKm8dBWB/XGYrSGNKEYn5ctvpK7h7+v4klzZjGj0ZUpWNvCZvKZm9GMKMPdczP5xP3Q/nZNthcqbLl+2JVkVaElnd1VV3KjjBtyR+yqI//mu9iQNxHehaswQg0u3a46vkgVaqwjh3hm0DWr8G4YXG9eYwbxlnP2hneNI42rh45kmHAD+slG3WM8S4H9KDur6gT52FcH+yw8bSwyyE8GLAReqMaTNzz3MvYPYovY/W5Cuu9fsTC56jDUPN2NehYX/BzEz7vk7OGq07AbLOXedWZxxpAQt/zODoPyukISZGE0mOa6S1nRhhFdsYjrxbjsi7hQhtgFjSqs8QRP9h8SmZTOS3v9wlOMprxwandRVa2sRNuHwvcxZbXwPa7Bz+jGWWFM5DfAW9XRWuPwCzgmGhx95v+zmZk/rJkVr16jVwfC1YGd0idcwBHz53TdgJvSKV3EBRxJrzb/INr4EtL9LNZRovbA+vxG7H0Pbdyw4cHO7Xc/tF9alYX298cubMGR/tOUGg5teAza8Bg8s53v3IbB0IZCKiNtxZZ7tKKfdKtRVSZRXT8fme+z5QZwKx19wnfU+Rf8w6OnAgf5XmxttBGAvfgBX0drspoXZsS3eWE2XM4LM+1bPJ4FlXL5vLA2vMIL78BLLmH+yHNhqYv8wvdT3F+22wL4EriXyD9EPD1XKTOXlT/5gpzFb+b6Cu0b31RsMxcaz5Nmb7QNS/nAr6D+I+PUl8iWNqsAzeQD5+9zkqoWcWEKHTuA2mC9RP7e4fpbom0AB7UN0NeL3+HPFuA5y1vTNLC3/kzYW6vFvbVa3Furxb21GvfWs4wnyS/O5yZKi7Pu+l8sMvRmx1ikZSfJ127Edoy0StdbuH7uJ8Wdg549RR53XnRIQ7c4ngjFufw7bqlXoB+l5xTfca+K9MP0nOI7bpE3C+7xiRPKX7LeIFvX3Yo+WnAHlOq05QasGTC6IdRvz7uWbebxxjz7eNNDNI3a2WCXQX1edGOay1YZ1OeS60Fan2GZOqhPJNRHBvcbSs9BvuOGeQV6MD0H+Y67X6QH0XOQ77j+3iOwm75f1O+p5dcz+DY2egeyaHe8mQQ7sTW/4OUtJdT2gV87W5sK17TwFI+ivj+jrkowxdGdgZXvVsZohNntOv8bzGvSllFBPvIO356zW1l3oz33JBnmOzjrSu6mXCZ56e3ue6NArsYSynmVHVf4CDv63fqgRaVkGG7MSPFbMZ5HbAHeK0Avy4pSPg6/JaXt9hV2ZeFeIZaetTngnWj3ARYE4+tbD+pza83yNv3uu/DeYjn4rV/Y56J1hhXlXxvQ8mks9fFF2rT0Ge68aKGBpXr6JcD5dwG1iQx32+IdZkM9/RLDYMuBO/JnW609oN1U7s9taJ0B0xLROgPGf6XWGUqopn6edNXQgKb+LoPT+r4NbTJgqpsFh1ttkDIcqH9bA5iBBPRQZvORr9wy0Wp93qRSWrvF1F7DmYIXTMWGVy0LpvzDfevuP+7kL/1y4WHuZ7TWMP+U48HVWxxzqeSiY9+BddHT3Eh1BbbsGw71veDa1fZFYDg8l4/cdQVsjSro+I70tNF0fAd3oHF8+92nHI/RUnUslrthn49UtJdBx6TD3U7jmPy9A41j8qJ7HT9G/9WcXhXHHmS0Xz1//fnYKqxLlIdRF9rT4WmlFsmQUsMaazK1GZG/ZOuE1+w+Yod91c45S+wrFg4yImZp0V60OJBL9ZAmCjbbRT2kwwsdhPNf6aCHNJ3qIf1CLUZM/T9bjMgbGrBMMF60TACyKNQ435Vit9D9dnjbfjtgK6IvzOF/98RTXacebbpOTOJLmQGbEXmVMM6GfAajcYalO45C+WeG0ZZgOgZTz+moxpSDPHcIxh1cGWDZdyf82Vt03NU50VdcEOR9XLAOoV9uGInWIeD3Nyvi7A52GnNoHSIYUqdBGiX8WqxYtp+wh3Rmea6O3U7vlTMBW/K+Ti2Ja5uDmDq1ZV61YP3eRVuT2Lf+pXU4aJX7oVWC/tIqNtoeF+24j+9ot8FBmr/5s92GYaJP7m4Tj8xesQDxMBo8bZUWG4LxtBV+u1lVcC06kbGtT5RRRM1F88sJiC1hdF0uokfeUpBqBavMiDYJgtRm2HnuTbTjPMTctjPR+QxixZlBgyUBn3HNhHXhanZgR0efcZfIOMqtuLO/zcdbLLRneMwGg8KCnt8UFsGn21/9vTnI0m8YdQu1HdDADzm8srw3K9MGrHIKvtmaSV+X4JstRvv57NLFgr1YPM/FeuDY4SuD2QgW39+eFRsMXS1MYpRtg0EO996WpbLEsqE25ZRsWDVvOxEdm8ymUouI6IeHr5ZOabEH9btpl0sYlVzOqMLMveSTao4sgCeeHWbW3mbGhlHb3XgffeVT8SvLpSmSDyPrJWVo51qyCa1kxry2ho/Qy3Zp2SiobXcX1lD4psdVxrOoCxyZEsRKPuzOBjRdep3tykrK9BSHJNk0i1sqS84byGphL95MiDO7SrZ7syHIKhmlgf1ihCSd/YW8yqPdCq5aMkS257JoP7iZlLgCM70UZvof8Xs/o6qOfQPPVgQ/th9SP7bxnf3YLm33Y1tHXvRK1BZy3EX92OYG/NjKwwXcli1Z8K9SOE/BrmIXVOgzB09kBsbVhLF6E57L1ZGpAe9Qy2TzMt6Mglk6iFVVJb820NQsnngHQ6sHzrBb7Vm3jXmXyH1OtNBx3Swp3m1mio/zyoJcM/o+Y7gv3V92OPO2tJ15r6dn3jZygZf3iTgfQ0/ebCSdR6yo7HwDyOgS9df2BlLv3zmv3V7A7pkydYgpCJ7T58HnfMLF1OBZd6N43m3r4Jt4g2BDa0wki+f9MVM46o9Yif6Il+42RFoOuAq5jBALGeZCnWT0Sfwi9Ul807oE1vObVuQGAXcu9Upst++fxyQ3WeTsTfz+AO2pDsczcD8ZDLkKOpyBl85koGbhLuEMvI6UeYQzcFuy4Bu2Bz0Dt5Fn+fYz8DrykedXMsUZOAOvIx/Q52sS9d8byG7/n8/AG8g2f/sZeAMZ628/A7fd4ww8oG/0j/ICGKmnfZIEOYv16MWjJ9xZ5g9Mf6d3fhhqEuJcAzV5j9KZtCbbnZKErZBazgf3kZ4rNb8NNZEk2MwNxO0P6iM5d8V8RzwV10FdHvELp+L5tASd55TdqIm4LpXoWBtJcRp1cvFc/FXTi/RcvI5087wMJb5sWkjbLNJzsSlamyueiy821ZEgT9z6X7mfvIuolDibpvK4ewDvO28u5T1Lea3unsD7p3cu5c2gvEZ3tXOV/nHxrHcmlNYAnNX6aSLnGeCcBs77+ikiZwZwjrs3O/qubnA80XYu/iv3njdwLv4rt1K0DjiG3uMfbg2bWJYOz3eIF87FM0xMyQh6bac70/S6fSDUK1e0CTiE8j9xJwNvpncc5d1PeWvdKcB73JtBeQMpbxXUzaIfZepPqWVAndCPoP7e6kg+UHX6YSY1pZa4LzoGw4o09J7n4r9yyaI9wFia+il3H7hXgjeZ8iKF9x/K+0AfLrZDErRDpjtdI4fZzUay+HR4snGWdA2zVp6JluzqyAh3b1OYPXxn+5j7/+pMfAIEJfa/ZxCtf4rQ/64Q7H/PQMoTWqzRFQq8PZ5+lKehvEuuaucovcbUl1JngHpQrzb1opQFqAx9b7ofqCM/usIg9weenjR3DOXVuCKAV+jpRnldKK/SFds2/uu8+GZGmd66htQr3nT4v8Srh/953gx4+9xepiZZbLPR8Ju1s7Odw5lAv7yz47m/n3g9yzqc39eRN10S9a8wPyqM58h+39Z5DOfzBM7vbW3n/n5y+U/5ZtJ8h2i+j2m+PG/HfMK5v58c9RS0neXXgayAuWDG4d7xtp/l2zrZOqwjaaKtwzpyn2jrsI4M6GDrsI5ovsY8ldP/bOuQH4s+o8M/HJ6F1jUC/qIvEpXHEN/HMk0XYwm9kKnrYpmqU1mgbjDX/Upm+KWJf9in69yWJbrbVlniVbsk8Te7PNFGT8rTzRfJfv6HfWft0hSVRdv3WcOzYzQTtW1+oy+Sa0591Qhqo8xP/vBI+t+0oz/oi+ScUzjLVnl7UPqESD/j7Ubpf4t0nDeG0t+LdIpfRemvRTrDH0HpfSL9iB/tIkrU2/7r2XjAJuLanf8dYx3AV3RjP83sCXu3Wfzmic/PQnvJF8kceqKg3JjASrg0z+ezSoD3lBft9oRsQsyFhLN42jEX7YgLtQbb/BQvIC7QgnIec5Ec5wXMxb0RF4KdZXhqfoCGoi6a9NoA5uJ1eP5tXJ7/NYq0wPh8/ysUaZEO8dn+l0SkxTbuGf+LItJiGzfdnyciLbZxU/0LRaTFNm6SfwFFWmCc9SMa4yotx+xvR100MoX8jWwBJTGLnmZcI5VOgX6WnmZcI3uc7SiMT4D+3NmOwvgS6M3OdhTGIaDXOdtRGD8DvcbJrAvYUr6Q5yAFTubjAN0N6Necgm1lPrWbtnQxIi8ip9Xyqlm1fOy07XzctEK+539AXQiYi9JcxDqU5iZSZEWP10tze9KUPRFnkdvr9ajXzytnQeqoxXVNEdqpr89YfCVXQEfIxRxXOuT4rVOO53Kv5GKOdsTGLHqiVKjvN/cLitpQaxCzgf38V9RGBnuBStoCYoOp2VkWpUzfFaUsh9/vIJyEYIPQCkEK/K4QtLvacRj/TS9AVYlaAXLqZ3FrS55Mkiwg+qPr0WKFM7WW90JA2ynKtELeKS3k5bJangE6LC0OdiyC5CyDWS3Fg5LzHZijzj/x33H56B+G0QQ8xJRTDzHf7xsxtt0/DNqUE2wdog+Y4ImM+vun9hkUVvW4At45tYCXT8urlujDdLesiPlLLPu/YWGtHbCwtX/Cwg6uYqh/k2CKeD1Uoxggr1dQTpDmjj0UqFBKKTTN9ligYikl19jtA4AaQCmZxmZ/CqinKCXVnLUfBOogpSSaE3bXgJ/rXZRiND/ZO7fGgHu0xuvUt6lyAMqRcrZ/vXxA8j3QrbEY/oRuVbOIb/WT6f4GRxeKbmXUHfGteAakqt4v4lplmmsixlWxWgrPcG9sK5dVoJGz75TnQrnhfomIR+wPs8ECGtNQZOdFYnEiZrKBry/vjFqN9tfxtRRTmuQfQDnj/QHEqNzfnyJF+3dAii73BxCid9qQoZxPpulNY9d9siT5nTH5ktEN/EtFjn3yVmc/1NfrwUuWogVzTLPU142XJCuKlhuiLAKn3CddB7wUxSbJWqY43DSSfYKVqU+SD3yIsN83voF+RZRQ//XMIAv11BlMtZIC+NL3ygQ5QluGuEE528N4kTzubEfaWonU1dXEaN+O64yyxbs/7Vew6VWoB7M4WWa15Uq4KR4Fi9jgQN6rTlVLqHRMC0PRwQLKVwc7baamfI+EQdsoiG5FbKuV5H2Dvv/6Vgp2+2wLb5ACH56j3iB/813JrV9wg7zm+5/Qq1Zyvxt9nzI1Gz5E/OrAyUV8ZJqcFbCpfnLJWwI0RaZqlhuSLCtgFsDT/W3cDk8Jf4OiU+H6NwF0KuOTiKPB7bWSN533wqlGUpzqDT3mDOuEU438E071LJTxpPPeOFV891WVkuvLpXL2Q9iRP8zLRzLJToqChjXNg19Z8HsErGke/D6xjfsZdla37XmVRXxPtAHEMnfGv7KJfs/WsT9AT5irhHQHPfjNbBv3gAe/ZfdMK+F7yvKqk82wnqTtXoVfsG/Z0VdsSxZ+k7IwDbx8mWBzTl6xjbvfh19FtnHJPvxaso3r7xNqofUJ7dbXJ9Swlw+/imzjuvuEu8X4dJnYhye9/TOFXvzFeyU3KRP78UfshRgtzLWvOClm9s6Y1+M6YWZDvQJmNoiVW6Swk85mz5Ec5+78/Qa5BU9spgM93Tl5/BVrHa+S/cJd8gko2nNkshNRtL9wpygnHDjjnIii/YX7GTghxjBWguM/6xxJrwpgaA/eA0eL7wNiaV96Qtj7BrHRxuisBn5SwTnSy8lQTC2e2VR6EFObDvVROX/fF6GpFBC102I4f6TUmgF8uVMyZGnKNYqq5cacI56DUWWdMbWqJAFNe4EM83RG08qh/lepf6JqfzuOFu3KCViHX8utJJVv/5I57aTQ5/vcHbEPcbBeqSuEKxXuMdRa1WJfREsq9TN7yXf4G9Xu4sYgBt/gR3nEMsCIc+3h1UzEzm3cNIhpGMQzbOMmQzyR6QJcI8T6MYhp2MYZIK5jIoE7GmIDGcQ1bOOGuWSaPXwKoyzDu3zo01XhGyZ4WLqhzwrgKVZUO9XqaqdOX+3UMNXOgSq8bzTFLEw1RCOC4cUYSj1pEPAMUBs13EUP91RZyH7/8aaBkuNNoyTCuNziRb8u9UwkSHYbvKrrQcox14ND4B4qKB/yNaoC3mkydgd8LB1pYt4V/S518q+kKNvD/wF5buiDdgWLX+eD84833fduKTdYxDMo7olniP6qHc8geFuK2ztlTzueQfC4FNFSpOyIaTjM9RExDXr6ff4w103ENAymXwYOc114/CqfGnqNJLgR3RC98bgjZvUaWDOvkTh3StnLTYlUqjzeJFnMfHSDfOBBLEOPTUOKe24aSjEN6RTRMKwY/UptccyDZ9ZBywyEp2zWi889v8ExO3+WeXgxngBUO1OgpfVRiGaozT/ueCA/0H6KskD7Cb5+UhM6tl3Qrj38kMGBNgveXcqtF7EMintiGfp89b/xTxVoqRruXRHJYKAtVcMtE5EMY2lL1XCv+7GlxkFLve9C9EcfaKm+0FJqaKkVrgcF9MdHF5sGUqn7BnG6EcGQtIkt7rdpAkUymCiSIbO4mkcPXA8MhpkmzVhcmstonjRPLB7ABrE4v410M5pRZcIMN9R9fwc0w1sVW3MZrsz7LEUz4De+B78qze1i3JA7atcJMpN/4FoA0dAI4/asE31CFamCjSfINJ6576q13zXmvoduJ3513v5nHMO98Qk3SCP9us55OYi/J+ITcO4efk98wg2y6X/AJ+B8Qdzt+IQjXmEOcbj//4pP+OrB/4ZPuEEm0BbM8p6mVJNTwCfguvfxf8An3CC88z/jEwZCeySLtohXu6F/QUJ5yl+auz7XCrLs1na8wv8BuXCdPO8X+mEoL6zNg3lhbR7EC3PgAF5Ym5N4YW1O4IW1uTcvrM09eGHMd6fIhRskxoWlRlPkAu7H2nELW4F3gcy4J24hQ/za8JHxLFnrFfAIWI7eTz0RvMEk37ZsM//deNMep75ARrWhFG6QZOfvc7pSFMMVeu2+Dtd6iwiGmxZ6JuLSVRSYCv4fa18aGEWxLVw9M5lMNjIhAbIROpkkDAngQNhkkTBAk3TABHFBRR1kGwhCEO+9iPdqEFRAuUaDiiwadxaXJBg1IAY1grI5g2EJgUsUSZOE4IStevbvnOpJCC7vfe9934/TXV1d66mqU6eqTp2TizxtqvO89D+TZFiaY6fznUu7SDKYbaptdnoXk2QYbVdtOOL42qXIRc/LNQk/0cuyIqlgZWv/Gkd8QHJhNlv71zi6B74tbO1f4wj1Pgh5DO+UZIi13y/exUp7WC7rIskwlEkyjL268JO3rHfmzJXuFPNYqF3yfyQ1lCicyTI02tVQomWuKaxE43ONUKJtsiKrMIHtLtQ47B7lO5vtLtQ4fgh8j2a7CzWOrz3fSApHHmHvkKXQdsoAjIC2+tIzVOgbCBMKYYhjqU8baLF2aDFTzsU/kYb4zq1YYQeuXEZpCLuvQxrCZ5jFpCFSARNHvCgNYaxOYXp5f6KifLmpQx7iIp0lv90pD1HhuxEX5SE+gBHxifeLWe8E5CFOfHxaugX3BO6P0uUE1ihdZSH+Sg7iVXD/fdsf5SFu2J1QVp+K/QFHcXKnZENdsb6LZANahqgtxnXlDTsErXRgwA7BQBvan/jNHgeYSZdfaeywPtHWxfrEd12sTxSpVt9kieCfndYnGjqtTwT0qY3z07v33HAPrX6EWaKoK57NJBtsxQvEUvMimzVgiWL5U+8v2gt5oSQh9NPldW23rcX5l79JsgElEK77Oy2msr79ofuGBVXs2++6u1pYrXFsdtcFpBj4TimGOn9Xq6s1jrVd4mBvfNqNvbDDr8ax3P3eXMUWRs+CfWwXM9JJ+OjGUVAnFbOFsZHV2xCQYeiwnuCnV2TCl83t0DG3clH/HJJJmfWEqzdkGZ65IcvQStf6/2g74XvJJteShv+5LMMfrCy8I2FZOiwtbK5RJBpC/3B2/x47u3/7fy3L0Eo9u/8oy3DV9/9HlsH0fyXL0Ep/9f2VLEPt/4MsQ4fswEVqVGQHtneVHThN010d+vRV24lBJXNj1Na/JZ+24k5fQTWTVICRxGVo6zWiJlfFH6XxPtzRwB3ADdsVGvG/kTxopWYmedCn6qzcfy95OSB1kBImBOViac87NUzmAPdjcXcB9y2x7Ni+RVU6UTdZK+TwpJ+uJgZqsd+JsxnKRPnpcb9RKNpzQ55AK0ZfJflBebqaaOGPMgUoX/FU1YxElCroKShyBecDcgXq7VlMsiBKMECJWp24GuyQK+jN5Ap6Dfi9XEEMrFAxjW8DcgWGohQhU0iG+AedeCtNvWOzOci+IEmRKzhE82B1weQKhqo/7JAruEitXeQK6umWLnIFv9cq83udMq1U70aO4LwrYKN8x+91ypym/QM2FDruhrbSJM9f3Q0Nh/iYRsd9PIzTSmVXVxm3ejrZ+V/JuHWVp2mlwq7fy9Poq8wLozrroIfyfOxqXHiDT7PTf7oaF5U5/uHmF5c5HnNb4LnEXQbPRe5GeBayGi9kNV79YVeb7EdZfT9l9iSQAx3RlYMv3IQ8/MJWqvWWF/ppN9kB7m0ejfBFtQNym+7Od4z4PQcPIXZ5/oqDL6pSTncMufFQnsfcKYDT2uaIOYhVklbbHDlt1uzYFJKOpzc5Bedno0XMBkrd78/FU6syR5UrNrdxLrrKXT1z+Xno2uHqkWthrvdd0bllzPWWS7HxWGxSOLHVpllzzs2ZNTc8r3Ee2nV5Vy4pSJ/z/pz0ue/M5WEshANOEC+xABkAYwDuALACvL+pdmRRVbhA2l8I0graFLyN8p2jGfufdR+sWt9Z/b5cYiJ8EePnUU7olfJCYeUFLYlo5zjEcaN/i0xMporXgzV12BpfunqUm/ZsDFYdw3aqciENSYAvbK+PXT/S9f49Tg5WdxNM8ZWKtWU1s7Q8zXyHGTWEBjP7tIJpjzPIhP5o8/Ze+KPpXAUrNmzLCsfLoweQtI/kHL1mu3pbCax718liwduO3s71bfEwK/MLtrSpF9S1xSzvmxdROu9S+oJ3CtGq7fFL6ct/kvWGhsK6th4QRrMg8mW0WFvXlsws3GLIuraey/nFx5k9214QJmiBEiKF2bpVQsQuV/7Hddq7RQu1ZY5e3gzhcLOO025rhP7yq/tma7XIaS36RLv950IVcG+9nPMkArMW2uzCveBI6D+9BZLSN7m40EeXu6sqMpaVFc5K9kF/Ck8pK0wD12L3SKGsMB1cC9yCo1hVVtg3GXf7ffTh3S+kXJT0nxYXsjFm7RhjRVWJkC4xpAhB0GIH/XG8xk2g7yX6BgNFNgi5yX76q39rIeaL1NlHx+weXjWhcHI1Z8Bznx8q/fSMH09+8AzGEJBo4wU8lbkCK1foP5BCk7+sPUfNF003Tx+n3wMzyg6NoJa5AVyKn77kH8w30F+9mEMZ1CzCjTMI5rFODub7Vx+txDzO+2+k33HuwwuYh6mqTwpqWAhlJcW0vvJaCot34s7dGas+WY2ydSm8gP/r/GehzbitJAU1fvaWVaZ7k36o9PbjTxaP6tgrKb80acEHl95fwA1WZ5Rd5Ba02rlNOKJUm3BMqTfhqOJ4lCRTGxYE9PTM8B+WCH8V2qt4FFutN0fwd1QvSOYNPjrS/UBKKqtZmQtXv8TApyyAFhrophLKb6FFwBH5GiE0jWdjhksJY2k+6ddsI8x6kmI9HuaI3dyYLXKkibyC8kxqmHFnusoKVcCzY3pPuWbzB6jGTwacsqeJqbn4f6pLyQ1zvw5hCZTER2egHhyiSIadlR8rjstX8sY8bNVkwFkbNyZT6MjjFtdgQWVQ0pjC8jjKNAo831nSfv6zEhlQa+uZEsq+k/1zCgdUZwq6FMXSfZmP8Psl5AdegfliGcCeHR10+El/DnCimJKfBvk7bn4srdHvKar6d7lGaKE/+m+sbnvmnKQGn1Hoxmz0NdCTXm3AEl8rzPRNs48AberWaTPPMnu+gOPskhMtQ2Sr5gu6HBsd72+cRYyn7VoxmOGoxolr3zrJsUOZH3C84TpFka/rsJGmyF9PsPUJrFDuD1hIGxeQvB5uU+SukSNtoT9/pUheD7R9yiykzc5Emc4ehPDJyDma10N8xUbaevNkZiNtvfk/sDIpUFlv4hyDkXOEf0E2tJW23nzITnjSaOKx5WbzbklZldxXkzj5HfNgm+bkyp0JsB65aNsnxXfKJO9lMsk3bKEhl5l4s+wx4KjS2ZXHPBLg1wv+wFt+xTjIr35nT06x9aX0Vi6FlAbBLBflQeszx+Ri8qajxq/Y9hpeVSJbTBrhIMzgCYs2TBpRwQv7HKFMN8V0E47wc4+ski0kNFNXHzqqu0hKod04g3COlvh/Y/KGDY8EbCuy/hAK/SHByxmU2+wQ0xSKKRFSqmbWmLI5wjdCWaO663WfLsA+p/C8+xwXmGa9Oz/qyvM20A89HTwv2lUzX9Yv3ef4l+9sW4/QHsgFGWrbkkNx/KNmIFhbm5j9OXkDwGbc9zC92RYO67lV5CtHrYdJWcjvmmKZTeutQFMjZQFo1jtLVOxMbOPrr4/F/FFn09IqG4RE6xG4EtbYh0I/He6D2KQOYHziNJsqgF0bneLDeTOrAtJUwV99BoS91VfHduBu2BMaWVfR5SvrdMUlbefXwNPtl1QLOnblMuraL2kW/AO+jrcRWDXELpAu7Vuwj9l7798ZJ/501zVZT0hdA+u2/ctRz/LZtnCgmE3LnwE3WlnAVcdJyQfPYxK6L0p+eDZDO9jujIH6Pm1e3H3WWBzf3T4i6RPl/o9ohL2L33Qk+TUGUjoYuGJc47dShysoKeRUHetBb/gaIUScXxn7qCu8NCTCpoJ+os4MsSthXmBhgv3AcwW1SKitfYvcTa9uVRm+vRKhQsqpbuXALUZnX/Yved6sCcQr8p2XkPqfbTNC/Y3Llf10mANgrY08xzrgMNDvzbYU3EFdMPzSvOU0YGdRs/3NtiSm0xz33/003v8jNbmRM8G0yxxJTs0m4BFCw0tx3lf6xmX3+ra45Wcg/FuLZlkjSk2XJoUiLte1hYUilzGoArmBhGrtdqRX0V6s1WYfSSuW1HHfjyEk55uNPxyaUKzib+329xMTJ5tidEVVSczG16iK3mJvoGp2eqefWYtp3AtUcqIbpYVi84zMytdLvjTLxGre2lidJcQwG8F2OsYvSTfsfhHjb3YuOTznDL3iIsbmhnAmC3eG5sPXLw24hrph8+u0NGSaYu/rAtDL26A/P1qoyLrpq9Dil7GLvS/9HjWPa0U7UHq0M3GdxUXZswsBWov2vm6DfD+Hlg89NTpvtDiG1abNh+G7sRkL7Wqdob+50cbXMHEo+3/Gd0kaIg7OxZvaJ3yoD3GwODAXZSUJj7sldnrIp9j0QhmuVqeuIlP8WTor7y1Ou70vzL1cMtrxUm1VvbJO1uvP0Gg3Z+RsBvFHZsUL43zuRitefcR9kgFmxkEC5vQ2ywlzGcn2ZBTf13yoc7Gn+CX447+AJjj2lxtip8/5gvrvs0eKHaV510mML9nCxddhfCD+Tn+o4LLDHld44c22uAwfKfgdBv5ohwttcOlRF6ZLkxR8KlKMVNqfYQzoDJM5PkOXMC0IIeJvAcvdPOQ8j/lpxfPAuzRLmPdD5Upb3CxrLOdzqWdlRwlAGUr0pQsTJsaeuktOLc9lZ79G37xEvmIqc6f4cqq/mBh8Bi1AoeSexXqKHvdohdHCr9JCK5/L49msj6824Rop30/f/iqR+Wl9sdWKz7mv4piP19vhc/mrHsznaqfPMzXdoecithu9UaKeuRpgHogUI5j7mLebGMpcNm+4qGOug16m0+vF38vpffGRgm+UYYxfGKUzAZwFvx0pUbrau6N0tGrI7UOtwcJ7FVnMrredvu81dbF7l2UZJQwUB7Bx9LoXsD4kr9EGo26tUyMs29kvj5T+PQVnklth1rnHnZ53ti09lM0l/8U8gvPMm229A3PJG87a5oy7apv7AwwEMN01AWa5d02r5O8LhlhI/69sHZL4aAeyHMZuGPSHHtC62wNW+6D9ZWJ8pwEtdzpg7hkRGLNypjJer0N9X/g4SodzEiGfmv+78ZvmVcbviMD4lbuM37GQ9wkZxy/aPb+N4SXC+/vxG+nijWrbcHEY/M9sHCYOYeGcHhxRQ0QTG7uqwNi95LkxdiNkXcUA8RyM3e+L+97e70/G7lAnB5QhTezD2srm+bpzDB9zKmO4PTCGMce9nt+PYfSt8vzVGFaxMfyeJ6j/N51j+DT9xk+ML8IYRju7iEvVxwpufz+GN477r8fwKLnrGH7U03UMn0ZNFL8bw6fpM/6uYxjzxjsD8v94DAueG2M42/PHMXzVta+y6xge6LkxhhcFxnCqp2N8/hwYwwmdPo7AGO7uuXkMI7Z9bhzDrP3dyhhG9xU3jmF0XXLjGEZXs/vPx3BeAN9/NYY7bM5phBfLkdNodnVj/FQa41bR/ukuX5CQU6HwA1aXUYjstEXH7MEInBC0A8O978P5scWuWPaJ4RNU41tU49HGT/T4oAA/keMKSzsjrZff5SdkZDsOFqPusjp5K/B3IZnZlw8V3wljfyvBEVwn7937ZTuJbLLVybUWMvAXW13zQAPp+1n8vFZ18OFm1bxP5XKi2qR+41P5w8YyN5TFrc0iGUvbCac69dTg8e1EbQvJbhlvqY+CHjH+klvNlbnDDeFuLhBKfSovhySj5oj8ljumq17/VK7k1W+87eY4lVsbRYw5Ld8a81tm3bsEUlKd6mMaB3E+lT8uE0KElq/n5reI2flRg2PzW04NmtTKqb9oVWnnQ8nIwH9AeM0plAchhs9iHxrnCHNGZ7dMyj7syHdied9su2Ut6tL9VP6M3FzuvpdWr1WfSg+U6u4IoeXb9Id69LzmskyCv4cdtzjPtiWzuPMubV17hK7xdXBTbzr+4akDzmkZ8F/ITSmnJ6sI8kx7HJP8+A85qsNt4WtNl+aFRpQiR3WDmwoHbmqhjNzUNWeEdGfGU1fHflIr15oUaqqRoFVMQyW/vw9ZvsI0FnWsIm/152uWcvm/X7MMc/75muUE/dr3v1mz/JvtViKdvrFmOUXvYCsZU9WhNakOv/rgCmKIFe7TnwkeJHfnhZqjlQXZxS3deV0KuUomZpOIiuKr2QXcyO4Ov+qancvSZ16wH1qx94raZNqDcmeOcavLdZ8kGYLlHmNIGnklE9bmtwq4Du/nxXNJpR1OyEYhtjH7+hemUzTYWy5o2wvU95N1cpiJSzksk2JiQMmxFhrpVQkjAnH2yITXsRmA2X0S1Gw8+Tw4ntrsHXaZNdvQKnOy3NPEDdMNPMokHV7yb5GTTGpHpHqDuY99j9zd9K78oWmPHAPvj+HdE94oABwL70p4xwMk8u/Kn8L3Z/x93Ro4mDcHTzK8s4Tj90h4lwup67fOzdJjAbphgjb+3vRMeZBQWqHZVoJrsU6r1S2wKryxkr1PVlayqCf2Gfl7UuzgyATzVWk4k9F4F0Lsls8tshSSTNX28Jo7DRMMZlkzRm1VJ98/H3tBLGBjK4QaJtex0OWyYpOP4T4f6ZNNLgP/DfIRGu5Vej6Gd7mwx6Mc2RkrMQRtjxO2TgpKCjul/I2U61isNTKjXEC1flkUtAltDFwv/lQ26z+VJ5B3YO1TDPQhv8U2Y3LLuP6fylb9uMutBeHXXHNWmNPmPWb/VM62fCqPLn7WrZ7nAKoyyZLfohN6tpLQphfzW6So/JbYSUAFwj6VR7IwptDslmAI8/2wW7vnt0yf1CHfVXXNtbi2OWlHbTO/Zswp+AI6cn7p+Hb/cK07uP19t9YQlI5Wr952azmtWx31rC5Pn99iUgktK/6+Rs+99HwueXWdufup8OsfFpxpJndnjw9OzneEhX/tJlCDcC4XQ5MBsbePOwx/dwFNKmTSsEnzILQBaJQKaJQacjecW4R4gXV1prGGGM7NfcMh+0naQmncZalghfm3m2pcDjV+DmqT01njD6DGJ4d3rfENrDgZNv6sxrV/WmOs75hkoLvzOLf6H4NCxrUEL5l6O3mpBGhr3yjupfGtaq7KjDfSok5hLaDuM8Ld4Z7ItO+AnuPdOV0aylAqXyoDhOF2tRJS2MpB707izoDfCqmumVcBteXUblXUxIjbe0xs+TqtDv5mxM8F6m0Lg5kiu0PDeV1bIqxmBy3AFSiubvvCahZ3q1GKu7bNwHat1wFlPeT41cm/8xOU4JAj14XyfCUkUjjk+MGZEPC9zYUlMwm3gu/D7jfbeiWMu6gP2+8wu0nKVHDF5R1yPCZHB0L3dR1y9PYiTQ4ryaquk9fr4yq026NyfqRveLXbSIplUQu9R76xM54ItPCTK6TYs6396JSHC8Yu3fR02fL7vh+75eSaLdPfO7831eX3I60mxDE2J++GnfWJNvWiTRU3W1lvphf8f25l/du52ZBvNxlXwfcDvVYsrbdLqDn5FH3FpdjVAD7YeNneEYYYL9qV/890/tcwLRiKJfZmWuFXLLEfZpbYD0gd9w8ycuOFZlrkyxD65c2dZbBo2kcEqdr1Wr11qjVTUH+rG1xp7i1QoHV6oGFWk3InJsmAfbp3XlIunhmlDlXu8aQDxN61Sl5QUNuccBfHv+F4w9sztxb7Pbg3eGNycR/JKLzheNmLN0G2Erzlk0Pq6X7frMKUx+P+4ubKe0vwhIjUzC+P0lkqonSHn+dIEbj/CfB8OdrvROud3YRiyPk7wF4zXewnrxoEtQipc0bhF/qZF3eDuC/UOgI+hP+Fnt1zsz34Onkzk6R6awEP+NjrsXSRtyojbzie9yKVfMPxnBfp3BuOlV5Lp2wWxnjKo5xlYvlu2Eo9Rb8PnF33Abq+AOZuN8TB1plegRRUBbRYvX3DJDXbnd7kx1Pkc4sAg+T+CsMiZR5H+X2cjXO4X+gd3jY2j2Obj7gpBS75jIRy3AtgDsf7ulhXP60N2GjHGtztV0p+hz950VCY+WtdlkVDcptpNz/QXzJYzMoDGjx1tTm8JkqIE0wQYqcrefEt8P7EBaPZMBBc28GVZOgPrveYNbRDjgEyjrh+4LMZfF4An1TmkwY+pS60HPimYkOJ7Uzhyf8hRzQL0QdCPO1KfjEJ3k+6Zr7YG97LXW+9mAjvv7t+fjEB3o+6gC7q48D1iAtnj1hwWcE1Qd8TXLPAJeh75OBO/Qk6Y1eHnXld/yidA+ZTChD2SZSuD8BQgDyA9+E/jtGZ4H4c4DWAKoCfANoBIqE/DQDIK8d2/HoNSUkGXubbFdHCnfruDi7SJMdkx9f8Wjkre2VLjEGXiuf2+S3j1bE1K69mT9O0+4fE1iRUxjj8mk2VDjs3WJ/xi/3rFZwjkqtojR7bIRuJMnOa+c/BLB8pjK4wiv2AD7DRGi/HH6Lx7pVW7gnVVugV1k1WLdAdS+fNeFihLusj9s610W1eXgiGFXQ5f4pudKJVKfJaoVW1HffVonz9Z06u6FiJ8xXG+dOrCW+c2STh7fjTdIpzfKJGCLJHiN8ELMz8Frj/fZq+rdyVP3WaCnKwWCmdpmaZ43+QbntIwSveg38kcBd+1UPKWpukRtweLKwW0oT86qy4hPl51eMEU5yfruui7fWaLWZIQf9L9h7VWMetLsK7pdHhhI/IHVFFUtRCTKqhQuNWOXTMZgy49EFoM2awJuOyHW+LBkGdb2H4WevCM//RAd0DWCbUP/vvcrRvgnfgT9MzcnBS5Kl7xXsZVmO8B+kh5z2i2noX+w5nqcxz4Vr8NNW7cCU+VbwgTRWnwMrORj2e0A0HHV/7bmfSdjnM77InDPw+94kBCTz0u+AJB7+PfALzu435/cdzpllrGBW4YZ4t2ugxTyismVXcCKEBqIyxYrQ4hJXiB89uSdlLwD+SX1cxXGyXzsoXys7K5cVn5S9LNAKXhvsJ/QTVVtVr62R9wWka7txq5mwDxNNsJwF1c5eznYQMcbVkEO4QxglYik2sBhafKLCb5MzvJVaDu31x4g2/51gNJvt6dPH7F6vBOEGpgV7khtjoUk9Q/y/sWM7RfjX4qaEt5nsIfz/QmY3lShvgHe2OPYbz8HYCRDwQpeMBBj9w877h0SvdA3sNqFVfaTM101uA63DEzkjPQXpZhpys3dj3YA+22bqA3oIGmh/Yf5A69x8a6MTA/sMZifAXJNx76CjX7/UVhN0enn9WNhWT1KFxmfPHV6h41CsxTrDB+t8430/neLGvOuwE8pzmVPraolWdfY3pO9AKJeU6tKnJyt9A3/EHJUWcGieOY+U95T5IX5bHQvnHsO+j7tDGMaykDbTdN6JilDic+e9zY72SnW+2jVgbk4r3uvDOEpes2ap5ZZ0cW3yaRsu4/ztIbIIWV3QdnKafydjmA8TvJdwb4kaPuNR37S/2N9syQlWvGi+RtahJANrfq9xM78165ktu1HH0JnBTAKFnAZAmf3DpOXAnL0d7KftQduWSLhB7nDeRxY5gsR8FXiouFNPOv6qb6rn0vaLBKKOBrvXpKqLFlZIRWmAArP9e+12fwDO5XQ/i2RIh2P5HwR124p1R5+F91Vu3Oyu6ZPxG09a9TYtnjdI9pMhvZjyEfaPH5B7s/reNZrmThWgRXQPdimZWG+0HLj1zpboVzaw22gdcEcwVD65w5uoBrtDAPXEb7bYby3XmAWV/5iSU8xrAI1CWtQDRMHcPq1Du0XCGZ8pJKvC3Q87KMS8VA52G2fEu9ceqHeRVEfjLbKHGcdwzPtFou9PYI3CLfBqAn77tx34zXFalXuhyi/wXiUttlDSp/2G3yNUb6mmJE1KctsEcJNTZYBUALpuNGI/YzkiqTX1y72EaWOtpjSu2WtG+KjJtqvX0M5dy73uVtxf7/jjwPd0Xw77fd+mq/fR5plG1nr7p4oSy6i/auUjt6W5sN89Gn3ehpu+IvAQrlxWaAjkBB5brRJ35JT6deFHCPa2ud8c1lihdN4vSpni//FvA0ZcVaHMcR8LqcrRKPk4OEgoC+woFOcfpKz6joGM7V3g+Xk9zmGZ+PkWV3EyHu+bMnVithBUg7FM+PPduAs5mQseJeXqtvJk0zbUAL7cGZnmryVCN2EIOlEt/s23U2g4uiHHHQd8z7riear1s1gtwxx1hOrjjenrd0/E/KMAdzxcwjxRXt52QC495bDSH2/FErMMma8wZbB3M+fzcb3G9NnWtOdR+ti2e3VnpuGfwfQ2GwDQshRgeNYKOMdyGN7WtwaWKbKGmfQOTjJ5tyDMMhpxDc47Qcf5aeT1B64LzPglme4s2uttpYTreLgA8B3SUlL03EdcTxhlKG6C8qCpou1kj5NnC2Nl/Dzz7J0+bR9t4JsF5gZ7/qvKa7qGp6M8/bb4H3hr4/xvQtH6N/cVS8zRbzEmSWWDjRpaaE239civcV67grWH1NdfSne72KyGZKYvG1Rvmkozz9uDGFDzLP6leFJqimksyT9s5xaaM64Tkp3fDXM7PLdpjWDRqJ96MRVlcymRxk2+SxUW+vNbZVRb3V3a2XyW9c23z4OKRudezx601B5/cK5eYdki4tquT1DlH2Sn/j51ys8p5gLIP1Uz17AbC1squ+1D1tBvzHV4VI6i29xYI2/fQGKIg/P1eRV7UULRF1ppmwTPI1Fj0TpGy84H6pUx/0C+Fsp7N9DePIuv53mxFt9TLkCfmi7KZmn5FVVohXMh3TCah9np61IOnnMFiVsAOBZ5TwhqH7S/JtiyBEy9Lag3RqzmiD65SbUti5+kkhTM001Bvh6071YecQSNzvfFGYTP1efCsXtUP6m5T9wu39UxVN6KMDmqrOkBneDUWPO/BekdZ0f+y1Ex//TK4ihi47TMdT3EfyRrTOqjzOlmjVwMu/PQ3/x45iGTvKq5UcvRfRNku3Emrpw+7SRqXHtRewOUSXvhgId5S7yv3IGULTXIPEzeUZMbWkHTdgDa7ny50ZQfGsg7G8uvsljxpJPxtAWqgAd9/M1+835sDOLunUrH50UwF7w0ZzW4QbjnTQ4h9a2nnbZFrNkzZIaHvx0z/5UV2a6LZhvfyf0W7509E6eZDmssrb+xRQl9jK6+YnTf3DcLWaX2YdrQwk9oQIyiW3yPaw7hm6nHlVKNNdewfEax/hJveKWos0gRsDOryekCPQN4oTNCyfvFRQO9Y2mw16xfF8VpCIE/MF3vFBD4Ccv3BrWF2SfoxPbG4mlXkVJSWDzWUyEMK0Pq3ss+H6X7uWgV+2Nf6VGk+JKwnYAg8JcD+8IFLw/oD9ga1rSdfNMlPj9Vg20s1OH8FC8+UK235TxdJ5dLSoXeqQjSdu6OHZVKi3sGlYL1H4PrVtZXZvId687gbkSTsNMfaXzVDO6c9fCVYN+tKpHHUQoMcU8wN0fU/ZR8BfWKxM6eCDOjQERfErFsECYp2OLwrNm4Ju9/kZzSa6Fm74j6E03ZdCjXoq/6ejDXCMM3+WFihQI0h1D+SFekz3B1RNC4003d3qQwMP1hPtjfcAzi46cUagbRP15K0njI36i1rhnCuOlvghh6nd7s1A66yM5AtjlOw7l0F7+N+XLFucRz14zp1i+OIH2nMFscBP2FSTCOEn6Evpe+J0vXYg3sKL1cmCel5XCnkAXQgVUyDtfJnTl5IzcuWs0ehLM1JWujD/RDcA4k3bJFjTavkx03vypaCOXNXycssq+TlBavkJwrelf9Z0CuX47c4erL9kGKCbj3bD1nF3KHe7uBeTYzCFofGqwf3C8zt87w3B2/OnJ9zmIqu2uZEDrVk4F4I3pH/6asoXRrMB+Hw/hjKvBvgB4ATABf3oJ4X6NlQetKezalFwv9MBweoC6lpa8C9ENzh/5ney/ZCojr3QrrufSAGI7wKBkO8CgaDvAoGOa+CQa8Hd0DCmcQ2lkUZb8fZeMsJ7H+wM1nDhvJiebnpYGVwCnC3JmtWQ+U6OZ7PSBm/JDR1nZzIr3T0VWuYroh1ckL2OjmOXyf3NuU71Lot4Mb9fByp8cAFN9N0Z7Bg2Y1Yxz5rzdpoTrNDKFPs9ugJMIb5aHnS6I3mBPvACZzhWXmG6RV5ponLegae4Tn1tF0Og+clOQSerbIOnhdkYhghPAPli2VnA9xoXMV/Ywe6Ovy8hPguqtpQ/kPldqAcsXoot8k66C7DD1CDBBi345ZA+U0/jNcYgqDscUBne+tDU9XpWG7y6o1SH5SLq7uWOeRPyhxkU/JuxLyhNEVsv+D1cg5yQ/xh/sEG6yDMO94UxvJOMK1whHNqA0nvyD8R8h8uaA2sBKWYv3qHEdZ16n98JMdYmumzcqAcenW7VfWSOdOOJQjL6Isl4mO3hUKJovTd5Un9XzL3tvdncgU/0ke8KL2UKfZjX3O9Kn6LrDcZYXT8SB/Cf9nwTbJbNDwxIC7jyh17ksUkFjrfi1S1jxjPvnK8SGkTxV7saxxLN16MZl8jvZhqL3YW+yPN8nKjoSymGDGcfWd6ETtY+iCbnmnH/ZEme9dIKr4brE1/pAkw/9fAWP5gtzI+9sG7EcAFkPAl8LAAcwDWAnwCUAdw9UvUc/s6tC/H2hexi7jOZtiNB+xmc6ou2E3QxwF2g/4CuxfoCf/N2E1k2M3OiIV3JJ+REdMFy/oAlkPtKr6PyEMNdsHq+gb+EpkGsR/pJx7EX3wAY1s9iL9eYgz7esuD+OsRwNhGD2JMb+oewNjLnhsY6xbA2GrPm4CxMFED+T3Nzve/A5zdWqXgrADe8wGeBXgHYC/AGYBrVX+Op3GdeBr3P8LTeMSTHuvFAZ5KzTzD07gMxFck4YyxDE8R7ZbwhxFTexFT6ydG2ElJGKwNE8VEKL0B605u4Cs2gKFeDEM9A31KzzAUHcBQSABD+gCGuC4YCg9giLrfBgyFsj7V7uaFw4CfJV8o+FkD7/cAvgY4A+AE0Ff/OW7Mnbgx/wlutH+Jmyrfn41Q81+O0P6s1JvdWM+MwAh9xa2M0L5shP7b/VcjtDcL/aQbWyIpMEL/4VZGaE/2VcTSjQtgc75bGaGR7Othd8cIDWPf97m7jlAt8ytw4wiNYNgU3ThCQ3cpuDTCexzAfQDLAd4A+AagCSAUxuxAgCm7/xy34ztxO/5/hNvgP8Xt+P8Gt5dcXXErubrittH1X+PW5uqK2x9cXXH7jasrbne7uuL2U9fNuP3Q9Ufcvu26gdvNLsTt/472IfYU3HL8/CUrHBM4qAWZmj0B5uF4gjOchs/LJumAX/CJIzg7I541f4nnad6b8RzL8DzhJvoX2YX+JbARPdLVlf51jOdbGAY7xrORYbBjPCczLEV2juc41x/Hc6Rre+d4DnEhxTskGasVPE2E92yA5wC2AxwGaK3u2At6PcC3WG7iW94GvgUxsdLxjVqdclbmV2TfflZOfAn5Frwlg/iKS7sZN7xwgf7guRknZoYTS0aGgpOtKsQJQZyUmIfY+07IFFFjJ0n7kX7sfE6eUbAeOZlRq+CZnnOSvuBJhecajwGez3qS4bnSQwxGYRXDHvLkb2dE/UnKwfaOuWOlEyV0T0phAVm0H+lyJ+JWDHwtdSq3PcJF5bvQidZeFdzqAn4znWslrXhcQlwu+zRKh/zSi/Bu/RT1PkbpeIAKcB/5VNlDLZf/aVldXiyQgZPtXHLfnFNU5Q1KCm7gtqXmNNAJ8ogKI+rI8eRf9xcFZDU2PJdUU/n5tb0PtZ88SdO8GrYS5ATVRgzZ36fatMFsFIJsp2gzUJeTNMLbKJ2i59yqDRrDSrPu1C+xP8+4Y5kqy9zCpdydvanyqoShXJ5Rgk4MYXjwy1lCcGBEOeWtUMIv5H+SGukRGDvPBcbTq7sVGa73gBtTeLEcvVaIE3ZBDd7yBCfpGsK2fQ7uc348k0H9P2+7sac5fg7fsDJpU+VOKL+69DLUoFaRN4EahG/EcAe94VCDEawGq91GKNuHnp+hBk+7M5cFlRYu05aqN0W0l4SMzfr2ynPRwaVxcs4Ya9bSJZ8kBm88V1lq1pQWO+5ckQrrkoStJ2mSXAB0UjQhJVkn55ki2ieHjxKC2/lusdZ7rQ8L6m90WUsnrhco9Iwc6NHr5IUmA8TINXEGLis1M9i2RV4I/GiIXgQ+fCF/Vcp3kNB8R5zuJzbac1mPFjndDhPeI9v9kWwsu0BnuDG1LXJyoGePhtRT+IKMEXaMkcpGuyEw2gfaSekicVGugfWfcbJS8hP0a/9UVnIoqzqiPU+lbue5abImzAzwvNnZWd5CU0pneQ2Zt0F5CzvLW4g3oEqni/cEUu8OvG6yiZTeJd4R8AkBnxTwmSreHvAh4GMAn9vFXOaja/ePOEKv+TE/Uhrr8OsM0DaTRLRYdwRWrE8wyxPoPufv+3+FncOum7HTm2Fnakbcn2AnErAzUOzLSnKEVvo1m0jmbfZMGN3rXdyQ7OEaqJ9R7BP4/7ZfqV8azC6Kz+t+pX7JMMMoPiV+pX5JYlSX+j3zu/r1YpKOR+jj/o2Smu8Bo+EIXern+AP0CLPdjPdtcDx0+0wZD/3gLQDMA1gNsA1gH8Cvnyk0wA/vxM+jdGMAHgR4CmAzgInpTrsr0EdjWB9FirJOnmxSb1onF5CE7uvkKaYt7Nby7SY1fOWbOtp+qknH2r77Vmz9kEwttP5UPm4Gtv1U/ppE+g5O/eLPWmI1tETRBarDltAjzhSuM5W1xF0ZvNISjE4aAnSypz1M6M3m8CP0ki8RWuAnZwI8bU4co6dcqLHtWaAEHJ/G5J16MFnSI/SkD1ugO5vFj1C7D+cngymSzeJH6A8+ZX7KARoaxmjOEVrje08KYfq9j9Bqn/f8rs8VHCMej4H7OkAv4DNHANz5hUJHg5QdkFRcpeL5Ee6EzKpW7Pp+II+o1srcC6/IFrbytZiCBW6Ipv9F+wi8gbWi864UzGPJsmYAKVXB2vsCfdypSYqtWezorjkEc+Z3zfGcImmmyIW9Xn6Ialx1zYmGZ+Jntqq1TwvPC5U5JLnCrKvZan7yp/WQjzpz+cmP887KXz4da4XnywBva0s0nXs1JNNsx72EzY753qB2azC0PO+unLVkWjbOU/iMhyeualHmVZOi3qHdhjNnfycxinbkAt6y7jaPYvPmFgiFa3+ub4ZQIByj011Q539iKUZNQJlG5fQkymmspkU4c6LvTJOS+zAvN1QzoMo+G3JZ2SnzeE8jl4WnABlCDqRncnEGSHH0eoZFTLERd6f5bPiX4sIdkM2O9Z7jEu6JOKX18uMFZMAoG9Q16BaBpPeC2mZWuJclVONNIh99ws8N0wy8Yr/pX4WiLfgnj/KPpPdgf1o7/3zpVv4oOiRxp+xxEmO4u1PCs5FO9LC5/sX18jITybwL89cOFzCHJyCHQnaG5KOn/cUsvds8xRPVNsVvsB9x0GxH3OzYOVwgaTfKrIRIZiGu2Dv+sRQrFLwOdSkp9uhM0U8Xe5QUlbbOrLgC9VD+THcrKXXcxVwlLyMbAWcz+Y0VmvYZ2t4CxugIPY6FvsZCr2GhZ5KVEPoJU3Q1yro8YcpJ0W6zLJKo2UuMD9mQfqgzr55EPY7TAQu/2XBvRchsPYn7WJsdWch3FaCfdWhb5ZwlJMVe+bw5ql67LWoCN3jNsinZ16XiVUlk4c4oHe6PPbEnSjcdYBjAfYnI1eE+Tb4jVKeWhRn5DnVIYFeqRNnf4QWJNvj33rS/o8Y+atphRrv1JQRp7mbHv9xIbRvtSqmuujexvuOAmi037ayua443dEgShojEsBvGVaU59CjuwW122N1MB6lP+TrujjG81URCxhBVXoI1rMJPB3xVNGn0NMBVub5K/eGqC90IUlB1ZvTJb2JflqfzyyuwZBMzwk5as8YvwbOFbMDfrx7CTkg15UWTYNwTWdJXRU6OZOevQP89yrnqEbrIo5yrHqHzPSpDshArhIhH6CzwtRp0gVPWI/T+L0kN0q0iwOOVncpZ6z+egXWHwvvlbyu3Gt7If3OyvhR3+oByjRzJbqyeoBN85e3+sSuFGNtMo8b2sDHE5qe7/P9qJClRAm89Qa+79CUXpI6v31xPCz9L/84NtW43rxE0DX76LpupHnfeLadkr8ldk19KeCGq9ARN9JxAWWDjfUzvaZBtlbgqVw210HqapF2Qo64m36EKVQ3IPFNlfSoXS6L2aITy6n+Jyxk1vuwuE7jUDfwJ+qsfLXPhTqRB0G+cCqOjxTPGsq56qXhMWspiNrk1wojqJeJCFvOYG6nyz9IE4WznvbbsihFWfeetnVGWeeLnUkzqKGt0RSn06axqjudGn6DPshkCqAH/isRKbX8Q+BlMcwespGfk8pBXuftp4CHz7Orke3Pq6Uz/pMQggbPfI74o+ZNVsFbJKYdZkv9IFvUwr5bBrKrH+fEj+Q5w3wn/pgPcW/aRfB98zyhLSu2+3Xydm2oU6ukbPl2FIBZKky8XmE7Q+3wxnX9e8hFjux39sZRTWCl/sffs/L8C/hPH9eIR4mRpBCvlA25j9UmZmLLZyeurUhbzvcPNVwxmrinugt0kuR/UgPgFqMEbNr8BU4PymXpux5Oae01QRuADZpjq6VTUSgX5XPemsNgD3TnVo6wjLKhHa/4n8dZY4Q5ryaRZkklwNiWwEL3dxDjXrhkw+HSsqAL+xfpVlK6rrvTRgTtI2GcfgX/LAA49G6V7Ht4bAD4CmJoezc7Ecc+9FuBnAPqVcj7eO6k7uwNyBb4ja6J0MBdCXTb6NAJnGnt1xCfYX8uhv77mRFew4AD3S8wNfWn+Cfq802/AukL9iMqgYJIXsNbr5PuK1sn3F9TT415dxWbxnSbcU3/ce7Vpo9L+ruzdqgHc6Q3iq00kuRRyfcg3LlEjjL3q/bgj1xnObysjMoPqS8QS1udfcC1s8kPfmM6br6um9tyu5FRP3wMa+qNttbikaTVL+2kYXWXVHKT+jDiviRP+CambfGZon7FXj3x8h2C+rplaT9dCrF/tRmGn9C8Wa15nrOXiZIi1CGL18I1nsXayWMEQazHGsj0qjmp6lMWa3BlrsTgIYs2EWC7vJBZrA4sVBrHuhFg/2Kwi32RlsQZ1xpoj9oRY0yDWWa/AYv2LxQqCWLdCrI9tD4hBTQ+wWD07Y90nus9zggCxar0TWKyHWSwtxEqCWKW2aWLL+Wksltv5tLCVxSoQGyEWakzb5h3HYk1isXQQSw2xxl5d9kmOeOR8Dot3tjPeRLEW4mVAvHVeM2ujTBYvBOJJHowX9ckYsfL8GBbvWycnWHerId5Icev53hDrUe94Fkvf2bKLZaUPYX+aL+M4mWHq6En3B3pS6I2eBL1oJ8vnzMfp4pPn01k+LzKOCq1HyK4UUZerYRR/uZMX7juPfX049OcSgFyABTXKGHka3igb8iq8dwHsAPgG4DzAcYCLAN32Run88O4B71sBMgDGAiwGsAAsA3gf4DWATwAOAPwE4ARI/DpKlwqQyUp4mxOlI9wfYj83iinnew3gzvQVk85HbcqagPWfbj1OW/wPuYpdu9rVkVx9sqg/Xw/U5tt2n7r3hLZKkoo2Y89VbjF3q0d/wwRVFkm5G/j7KOE4PezXtWrU3JANRW0SYA7o4L0FcR9HHlkojLVG1kYeUeDVC8FkFcAGmE/RXneBR1ehE0//mikoMhtH6M9yxnmrM1o3DMq9BGAdwMcA332t4Ax1T0k0G2YVa3UszCN7PVqm2zA0WaKfyIvmplegFTfUdFW0Jy7VLeG+U2/h7WtDpnGjSss1QlgmuXzbirMXoh3hJJuEcVbyAtlCPiY1xEZ+JpQM4xYsWyer+O3w1PAcjO8gvmVZJnxpeZwJgvmMx9fJOp6kB6f4M9cBHtbJass6meOzHf5i5FZx3ke+c1QFSUGpGAhjkSjMmzw37HqlZqDDHs12k4JTMllOIZCqml/A8vNnAjekUlLFFI8XK7w+ptnz5jQLJPoRpgkcmGaAw14nLcwjpQvzz8rlKzKg72pMN8d8yPWMs7AiUxjJZBuP0AFy920khZNztiDft5qlhLxmuXRzPEOFwrv2cCshrtrf/IsQGzpD/PsvQgT7O0L86y9CaDwdIRb+RYi3OkPcL+EYJVjPYJKO4ZCnzgJuf/syZY0AFItHfv+yfeKNsH+SZoW3I81BUk5KP8Eq7Kd/c6GmI39mjP2vW6CJXvTfaIFoSZ0ZEeCZ8wKhmoCPJbyWyVxclDENImVCnk202uNu8quDQ1/Zo/RrfZWWnRtnFxIj11BPM10YSmZSFppvb8hj+GGMot/kb7r6NTK/rd90nBmf9CszOvp2aIxFn7QuPo3MJ9GtyHFohPGFpJRLnp1iBTqn09fT5TDbH6jZIoeYiEHt4NQcrBtGmVBaIkrIvhw8+CWz2hYP5a2n/XflXy1+ON6CUgX6qtC8RKu1WjeEF74HPrSg4nta4VZbNZnXbS8la3L202w5cYhDQhn/bOAXQr7B+9gl8sgCjdBT6CP0ruAG9LKRtFGNqkzNyfyrlUv6QJx0OXqZN7Ovfdqyl5cdDb6zJjwrLovjDc+tkkcStDdjeNFS2JBgeI7bDiUbVE/POblNu82JDcgPW6CED/iChPQX/10dkRdrTTR9Tx/1QUxLSKMvUwVp6rJOSkh/1Pxh+pbPyG5U404uyv9j+bCcPwH9Efv/sazJUNaoRh2UNfvytaiknH3U5lenoP32vY7R3hEVuA+P6f4tkO6jj+98HO/DhXQp/5w/lH8llP9Ns/5kR/m9Xiw/GXjaHhKoQRSrQZ2E5WwPlPM6lLGjnFhmbGedUCeTwTuvHX4qtQZvqJPB8N3962vk0eQJ9XQotPHbNRgiIRb/oeY0xziN0JvFKjXroJ7qk4uTu0G9ZvtVrUG68RO5o0XJ16UPYm8VMoDuH/d+B2m9nKBp1XEj4PuIF2Pen4Cp4d4IlgvTtMnZxVqhB2ANefCetg0TJwjGmkRh/EK8SRI3AbUFHqefeJcuNExYOjtrYUJC1mx19dLZTDPoihJ5VDbpL9twfj3iW1LoKPTTEr8maVCDo9AGs7cqY0z92+3q8NqJt9brofceTGyo5DJ17Zwm/aS3n/qBNDuB8q1Z9gP0HXV7uEbdHqfB+WqjOfmnD8xxR39NGCWYmVTRU368Sa6FMmEey/xDZo8WEOc6wPk93s+lMuGQpG7Xac6yG+cYY67/kkRSL0pKfx7QTPOxtEFCifC6QPqPtBHeTx/zzS+8AOkNgzL3b/itEGaDt3e16yJvqY/PI+nb20OCqsz96oNbtWHqlDhhusCV7nX0hjlOX8EN4zY5pE1ykGmTrC2Y2KJOCxn6UeXSuI0TdT9tmxj1E1pYHCeMYPY0+gu6QElVXtQLgPsYJPWqtNjxuAb7CPaPjn7RROM9KHGFN45mzcKbryNNOL476M2IqlARNdyF5KL26RDUlZN8flZtsx5vJT+Kt42O0xKPojewEdJtA0CaNKIqiMXT5KLuMZT1Oz8LQ7ngvwb+I43ijHKVFsJkX9lTbMm1At/h8KAl5aeLH5zc1zq84gHxQTZmGjxcakyjemC2Y1vxBJjrD8g4109IuRV6yh2edItQfZc4jYXc51Gk9uQ9+pRtVm27CUo3ycsBV6Nt15H99FWZt+JXomk/LZHzr3JFJ+g7kFpBBbgfJcnHaYYH60WSTZB2qsdgzb/avShp9gkIjXkarHEL/fRvfoM1m0+ynKDPdPF9FnxjrQ9aYmEleqQa16IG6/TOdSn8W4hcJc/aZbubZ6P3fTeuux+UUd/KZmlTII6iTTiZYWSex1EdP9lgbaiI7ZLW79MdE0j3yUC6y1m6g1m6epbOeOhF06t1eQlWQwXeuT9MTZ4FUpjoBMiDfjsb+gWu3bBfpDkV2nE+RrmL7wX44MdoXYErWjed9QldnkaItUYIJpM6+STwfP0Eyyycp7a6LIV7e40I0HRdFfaq8bOa6DcuwnSWK3Nb8SM3bno10bVMzunitx1z1kWYj47TOr8i58Qlcznf0aTdtxENkat6w2qvp3CALvTHGvY3x3Com3dLBUnt0e4fqtwE/OKRJnrOjbJusUNif3cTEG/quZi+TR3jzJvoZlewov2pOSKrtjky6505q4DnZ3KOL0Xp/gNlwnJhL71hqaU3lKfFlQhPyUVSEnIH8jC/OTUpJDkOqONCOU6My43PIQZNapgl2jLNorH0mjx+Zv7VFf/oa5llsaTeaZkNEJ1intldjLZ0z5uWEm/hUlFz9n2Wgfx4OWZyuGUf7edU7L88K8/IRjnPMUYdQRxM/U2tyx6hytbogG0FCAeIBcgBMKIfw9ezuzBsNMPndX8QcITcevNl42C03mIhB+lIGaVf/9amZjjPMR2gP/vDRGJ43qyredrc7ShqqTxAT/iDO/00P3VocKurwTm7sVRDxkaoiaMq6ureOc8BR91LSBI0tvGFHLQ43qQ6QF/3zSqsbe7OMRuJwnyh7JHDzaqhh5s185roNPdFCdohR5fHWeOtmlEkNcGqsWhzCPTsNZV++pOfadSr0UOdRgBMgP5UAm0TXa3J+Yl2q7E1RxpWFKrArat5Bdro62+Vs+XJ1pzc58qxBx1wXagWpmRYR1ZMFAVGHT53cfwPtLtcxh+nW30wJ1b4qdPX3xJePVZs67R5iqego8Xz0uhcTOUDV0H1EKCmsdW3Ql5HfWckP90NZTslDWP/X3OV7eaSh+ScpKIPV6GcfbC4XzpAE3zFgiln0JQ1wk/0c18yuyEb26rS5raqgw/QcF81YLXc3P1oLPCHeG76mD/WqLWrNp1p1iSjPvItvlYp/6rLcpxO8Daxk9V077fw7p17nD7g0sCKOxJK5acRfi45BnIPY3sCe20pAt7oOUnnevEeydOSUfhZ6i4+KeE92+y8yXhthOA4R3x+8UKUbgbyCLVRuntrlb2XhbXKXQXs/8XgfhWgqlZZn9a/EqU7WYt36p+B9j5Pf/PHAibV7CZCbIoquYledr43518VIXmhoqqUsLvNmvZiol6PUp0HaA8/4RU7vWEE7XAdu6TWYT8qqgqZkmnVCvdXNNHnZI1grH6VtbQR6jfOhys4vLHrkiaweRX19qGeviDob8Eoh6+tNCfaUAPeedq9hhu185rrqfijTAseG6+DgN400Vtc5yqNnZLyTNc107XshPaM9OHpjtVHmWw88KRVwZNTl02u4FrHcaSV05PWp1Xd5yNfixpbXNJk1I1TFQm07NtC1OwWbsOz6y9MoWm4i3ecFnq4Majx/TB9wqnNQw2V8ZbztKcf579zEKPVfkWasC9KlxOYgxU+/Xin/n+gk5O1bK/4MH3AmSxoAjvBh+nd1XOhvfjvonSjvsM1MC/yjI6NkPvgHH515qP5V3suBWpm0BpIGlDfYavkbNNgoG9RQ/sJTbOyUzTtM2BO/Fzem1Lb3Pfu2uZ+d62SPyxADUSr5C8KauUvC/oJZbHH6ftyeF6tXDwoDJ6r2HP1oFB4vjCotjl6bm1zj7nKHeJ+UA8sE9anzBij+xDgC4BaAEXXsLZf9smzFziHpvvYhNQBw0gfsU8ugZo55MGGWbNVqDHFhJYNAad74sVY9u8X9k9jcEg9xRjmU898dAZJihYjmY+N+YQb/iPhGSD67Gc+esMxKVzUMp+v5FDwIYZDrGWPQJ+zf6eUtwHe5wF+A3ABBEH532oPVe+8du2pjTXjZhOeabGehPp1bM39h5M0Q0twiEbo26IO3ouWE9ona9n9Mod/pM4V5E5oCYnU2I7LQ7iDdJLPZEloCYZvk/UgLfDtk0nZ3bImk2SENNTJm02aVnUUl3Vgzgp5djHqhcI152k7ar9RdEWgzSGStgXG2DOzX8o5Ky98+iDt7StAi3+kn6Dbegwos27bCzkH6VYvzG3BeAt83vj10ANJZrbjcnFdc//BG81aZtnhTX+dXG5CKw11zVHg28OWf3X5316BeVM14IsaVZoG6gF9IhTKF0aMqoZ+wkF6q+/uidftsxa+MxtKq4+rfjTnOOXcRyQMh/fpCoAaLQZOTXfqPet+4Ln6CSrrAqCO4z1fSrttkGIQSf/gWvYT+Y7wkLtkTQLpF96gadV2f1mew/8UHHQsxB1UeUw2AaYOeLlhd028aN8Aa2yS+XdbnfwlIcZHbWg1IShzc83d4tEZauvqGpKyyRq2bcOklUJoyQH6iBs1ZhTA3LRp4uYa3TaudSWnbufUG2oOWPSZV+0R7f1Dz7blrn2zLXfj3QJJq7lE1j4wMd0WummHOan+1TYS+o3D6eOMsfXH20jnvaSohs+76EEMPVl+KXf5B5e2LndcmrR8H4SDVhrWINW1RbDb19ekrLyEZfdXhO1Qtz6jQmzXtXVjf85d5JZfl/rD3/HKXzVJ2ThRZROhB7gk3XbU7Ngb2i7GG9EezOFteOgjXrxFgzvuiZ+oIESZPhpCjPLiSf5qwE1sHp6MxRf1ysOT3fginYRYxhO+u1i7cQ0HaaK3ykztSno9UStX1rlZvTusP72YA+PxhX4xTJf6G1uidPHf4d3AvU8R4hpPindPmAK06HYApG0cm1l2fZXD6C3aL+0BtJa063XZwn76oC9YIEan3Xw9yrDFTBzVxRNPm6+rmPu1Yh61qE5D93+KQ09XXYt5KBnvTDGf/cWLHbHBukbz5SD2rVlxvaHqmvGhKw2Y7oe+EQGLlebrWkjtqi0M0tWAq9A2+4zSI7Idm4v1hjmN5usR4D/LZr4eyf6brwfD+0c7MdwD/6aC+xaIWwDvW0+Zrw+Cdy/4NsE7Eb6j4T0f4vSAd5VdLQzqnX35dEGdvJXfaJ5fnyyrwrgsKpmvZ8H/905jzhzk/O/i7OtZ6jfMq1Hfa/B78P8e+B8B6d4Jb6YFqiE4c3m9OnNZPaQ3Lau4VHrvWr+7TGMiBzx9kktRuYKuDbWskR7KGyQgfr/3roQZ/vulWZanJKUMd5iUMvTtLAP6A1UvUvwTfue/POAf+Tt/l0XxV3f6D7ZMkdSZnF1n2C9xmeE1GoPK8I2kjLaxV7M/6Tg7QyuKtUAvhkkxMLP3dOGdoSxB075XNTh3l+Nnl1HY5SCeYFgv9a5gujICscpNiJMETNF0fzXGlZ1aga/AmKm51Q6dG+3M9hMwx2pHhBvfaqumvZxLmL9hkr8p/2rxTJNwjI70YQpciZLGcWdQII1oSKPJhbMTxuSrIUcC83jwL03c9kFCtSPfjX3yJ5taCBFDgdc7RL/2Ysgbp4JYs+1A/7FPN7erdZGBeavj/jFnfKG8WOgmaE776VgP1EYzpHHulMnWTCvJHGqbA7zeMfqWlxjH2GYx9yZwT7TNZO5X8JTC9hBzvwjuW20PMPcaL1qkuZ+5V3qxhNl2TpgO3NoQpyYp49TdOTWOD5woF8IL4R1ayVZAnyg6Tqc7gxl/GuG5xUJu+coOtdW0SiqDalRDZa5otNpn+Gm+x2hFDmS2jaSekXC21BouSSOF/KvGqSfpHBlpNfT6ZOQeH5TxqZHPAw85MvcY0BaU91tt/6I9KFJ9ejiU5GHnSgm1oZVb32wbsvYYvYA3nENRf0yKMO/S6uXJgsOKGtmP0YY//DHNRx2px+iRzj/J7E+KUDQfrZUdo193/pkvoJ6wxJx1bcFrYa50EeMmezzkn+LkUpdLytoXy7bepuJ7iD1yD8H639jlfDfTMi/QjhtwzgaoAFgA9OybfQrvijyJ6nB3XQ/wOwzuo/sUHRXIn6RGR+l67lfafngVYi9IUNtakrvDqol6z9NngLe2VXPJkXlcCSl9Rv5Qn305ZtrslPCcQ/QxmPMuzAo7tZ9OdoaIamswtOwh+oJnP67/rLPNvKDcWXsC8m2+rmZ5bPtO0adQImdbggaifgrcD4o6yaV+mh3jGBUZbvPTKV59e1xkhD2PaeZmmqYnnacfVqtFTS7efb7f0476oJ+rCfAuyl2qhM67VHFifO55qvfHAQ+4RU5EbsrEuD9Y0yZknYc1rXKDygp8Xu+7onI5fqPjcZc+t3GeUdjoeMylRS3oBHWgr5JXW9KWxqb0gzE/gRyj77g77kfhPbzlgLfVAEMOROlK4L1xf2AtsK2n4YZWrSBYGRC/BmgE6tXa6PjYlfmEoSJF2GbF1dqggJatT17E9f7q8p4GWBuURgmoN/48/dXHs7vXdX4drE8VuxtMt4fwQflgXGED73Ovu3HxRsc1V2IgZtwOHmLu9wUl6U8ZIKcMAW0/HaUefx3Lf5ELwzcD7eoLq9K4jyIPT7l9uBC5/5ULweQ5gB/oRP9nTpUJuIXlwDUs6NAW/5lTY0IdKyTlMMzsHb5Zqz+SpzP/nWsPt0UG/Octz3pynfyACbUsfebUmg63RS+/kY6OhT/cHM4dbtN38Q81rZdXE/zXbdvhtij254o1pjRrfo/SK2vxhB7DKeeQ6Tsw3Hj5hQGR2w+3dV++2fGurN/WfUfU9vVM8mqLPHPxrbvDt8UB37BFtsw704zapDSGnnna0p55waXRm3SlJA3nsrcWR+eskzNMXLpme8grH8lGy0F6RA7fliE0PnKePuc2WAcJin6mh6Xw7UGQXo18QloH7VUEY67X5/YRi7uvHPnl+BjUKXobIWXZHhPqZjKlBwm9hJ3u69ef3Dl+EcmMPkNSe7b7h+G+zK3CBUi7F9uXMQ0xDb95X2Yv/LvNjWuwkz5FO9MVCb/UfqQD1+1omRTjUxfqXDKl/sp0Lv0sFVWRtNXlXKpWKIa+jakkuLMEsj5K1LZP4IzCf+jDTuzLKug1t7nWybF4Aw4gPjt0crI1O4UwDPWrUG0PhlpOlnXQ01XbNDkHoO/wFiptIxrdnVDnC9NidARSJPx/aGE1rs/COu/2NXbuZWEv451Kn0t0Yp/M9Co6jHC8KOu8X/w4F8z13dBF7gd+yth5Y/cofYtp4H/WN71Tp+BR+ppPseWNuy/P1MxaREq1TLZuAvcf2i4rOsdRn+C8vwG9gTL76VGmp2gvlEjtVkrkd81cpIG0lvgaH1HnYlrnafUuUtOh4yd0iq7KaA3NI6mJRaZAjfpbeODLlvsVfTGHaC8Xx6ONlwLASX5AP+wKZQ7N55JLywtzTtD93uCkbqfm580XF7B52OvcR6t8VqCWc9n3Naep0ZSi3XaCun0mlEkSLbkq8G92zpw8U3yAuc85P4Xx+JB4L/s6DV8a0wzxbvZ1zHm/OC3XsBrdPzpDAxpfTtBLnhEVd4lTWB7fOjl+P03yR16OiatvJmsmTdEKsFYLQ+0v93Zofyk/QSN80ydytlzxnGRi2l9O0AooU5BtojiKpfOms0w6K494yyxmCdCLwOdV5y7gxseKyteLTsPq4QH3GlbmwYGvp1mZbwl8PQFfWlNW4Osx+NKZTIGvR+Ar1DQw8DXXec7aP+C2OMvW7of2w1lhv+Nxd1+mP0T5d4fTMD81EG6y0/BkSsAtOLlhuyC9PoHv25yhA1fY1XwirIcP0eFOwj8K7dehbw3p+QcAK7rom8ExjjpnLoC/6vsoXSLAkO9v6JpBPTNT4XsuwFMAGwAqAH4EuADQ7Yco3S0/KDppprP9DdyfOkF3e1AfTTSzV3eIXpb30e3eKOgVkey7RcYWm+hT9NGcoMEe1D0TKkpSaEAfzQnqdaNfcEAfDZYdddKs+BOdNCEwunVVt1aredznPUR3s9R7+rTQ/9s9PPDeRT7CX5MKuvThNcwWY8jkEDFZwDn3LTlZCBbRtRlcWlGR5ztEX/mC1GD4E1BHP0DMAaX/P5jXe9m68hUwv28UJlbMEGew3vok5BzBzl/unWywhlXcK16WOKA6wUPvyTsrF1dMuz0u+XCzelC+w6zT7SCl08TgHbcKOcJuR4HLnJhlm2nU2+YbedsdxkQ76jnRbaijiX5R/LYSdY5rSg/RKfIvkj7wZ5y/rN2sDs4sFk7W6zbdx26bHKKjZS7NJnXEvsU/WlSXlF1LnKYfVWquhXC3ii1SWoW6BM+81Bs+gPINFQfkroV+jrF7y2fl0yXavq/DTBm+Q90cTCLa+bD7ZU2foJfyEkfaXuCPUZVHK2RXaDZxpepNpNQsEEPQ6376oTvd0sQ0bSFH90UF38nDpVn+I3HJqJ+sHNo0oiGBtfEJGg5f2gbCQ95klmQAzrvVznfRx4079ViuOyVu7GVbZM4x+pmrEvoz0qLRPyh9oSAge4Yy3neD32sApoRI8nd4fw6A/cYc0H3xAHxn78dzKJQm6Sb0PzPZ2gt4ujr6od9Yrdj8QGtukTXRzPctP2qCWeDVs6+N7GuFtxv7KmVfq31h7OsFP18RylzPMf/PfH5q83F80Z7f6zfGPVc8XymqWsv2VE+4cM3DNPwLocwWyjF6hxtPmUwpquRfoY2b5pCBl2wGa2yH3a0UrdA4lySrttbRgz7t7tkGTXuRSrUtCuaxXZ6yebHVb1kjoec/5kYZX4spIucH+rJfsaR5yBa6TWsYJ6eOOUCfdHKbgP8zfSO9ZQ3KaQK8JpVE6XBu7wlzv04XpZu8H8upEd6+Rgo0xntPnr1AHOpR5ukPkVvEUvN0W+JJlJRGDShGW528is9gWlBU11yPdmhCqXS3X0ZtKBvNlkXZJ2fNLWHcXoKnWyMPKfx68uFFEM/UVW/KrLkk46IN+jqzpj3aQ3jLXMDiIncFrn9LOnWjxN2kG6XxkV/pMP8fdaOckhR9Lr9S7251zim2K3jiJl0onEG9pIjZJ0sTS+QX9Kl5wIP0QztyhE8RDbkH6XrfetQmUI1WnnkxCXyeB59bTUliQq6mdaWa8A2FB+kKH0qOh2d2AyypHcmG4OjIHlG94iISevchMXk9mGb7g3SRD/eUu+ddl7rnXQW4DOAAuARwEaAF4AJAE8CvAL9Iaw5DPweoBLAcjdLtgXcdwHcHo3RN8P4R3rsBJIB6gNfA70NY/2yG91sA7wPsAKiAf2XtQ4ifrq2Rq/oAPzM7SyOMn0Wulf2NXNv6d7z/oOwtqc8coJfcE2XNP6vM1+x18npygDYBV7EB3r/A+/8w9iZwUVXt4/i9s3FZlGFREVFnER0YtAFcSDRx0CszlGhqadY33GoUU9LqLe3NQTGXtDTITLNIq9cllUEpyQVSXHOZQSzXxFSuaPgOiNzLrP/nOXewrP/v+/vx+TycM+c+5zn7c55zznOe4wT3W3BbwN0Mbq3kFP8FuBfB3eAOdtpgJe5R4VrpFn8Awm9JPnOu8uCv1W6U/qjKQijH7Jr2/OyrFGWlvURWspPTQfHLg0p8z+1FZjLFpGqdQVJFErVbV6notfOetMMd9hUqgs1gU9ij/EYBVj+t/nfulBUagy6lCUqlCeb5YGeDhx7QwhnYg+QVN/8f0uyJCxlb7EKJbf27+DbgPuAdQjl9b7iMuifDXX9qDax38T2QdqtEHUHC7c52vRaZfbSRWtDtbYle7qD7SS9Kn5BV4srUz1/wZ9hCsze+q69oDw/O1ucC3YP+v9CZWIm7ildgjK3BcxgA3IvD0r1ifjVnBfuqSQb184znFVjRTU+dNi38HK7naEbWNERRKKSNKRSetIYfS7ek5uLJCu7zVzdEa6sbYrRoOaO6IU6Le/49U1GLqVCYCPiTrIXC27D+U08oFFatqW7o9Up1Q+9XZE0lVC1f6nkmu1q4Y1AS7D8Aa8iE6oanJlQL1JRCIWFsoZA4tlpIAtcAbn+ANIAhY2UPS/Jr+bUe3F25mlIt1KUMMVULGVOqhdxnvxaWP1strAT4EOBjgHUAGwC+gG/HwD0BcPrZQsEO4AB/LcDFZzPYz5x6t6x5M9C8JZE179LgOAfJbYpWkIQWGScVXFvc5tBCfpUpGvgfTf7HpKjhf1xKFb7I83Ar5Ir1ZBA/A/4MT7fsHCcliZ3/0vxN86/Nf+mNTW8gL7wF692bBtlDzTzZw67zoce8Dml022B0O/AOD5QgBXKn0c5Xkf5CVU6EPrrqlDjusM9SlLVyes0/zz2wPecTe7BBCVRziRVPPwpl+s7ZT/3P6ymwaq2ClqG1VcAhq4SkZKtgUFcLggEtnFAqstqO17OJLK2mPpGogp0Sn56lPsHfUvjl9orrgiHA0T8QRP9g8C8VxBaXoj1ZspI3JEObqSVaOycFrAJLCmDNE3CNHhugdSFAKwm+zAjED/pbfKm2NBC/F2A9G8AK/xuWTLspgNUNsIYFsIb9DUuhXQlYduhJiBkJmIlCCMEU8QAnWcQVDFTfYS1v7Q52fuyeR7g0yq1+ewQT4YhgegIkAwwDeAZgsgNlMD5Tzq5g17A9Wao31UvFBjufd6ftCb5LST+s6LZnvVFtB/lZ2ilwf+9nkD2QLtGOWUL3vs2Ns6Fl82BntDvX1pHcev4Z+Ngf3HASGuxmbMHmBxzdX5Fkd1D9btuPCoVrjjb0XEaprkLeHgT4cczZCCblrPgug11IU9uFIVOuC6tKqV6au4rgxWzvuxJFlZBrRD5L9wlyyYSYu8HhHewbhDBVok3DXhYYZecsB7/Jf0GwA0dVt+lyY+4qwjs+hjGRdYCMobPgdxj9KYm54jlLyLXLQq4m5J5ESadUCapIq6CbdwpC8JbaCXLCxEAe+9W02xm9LjxtLRGOGd8vlbPQ///1ShxqEUm2Ovi5fsnWk/x77n3GDnZ620l+rpfeSKXGVML86JK1lAvHUuIyv4GYin792ZsOBdm3rzrbbsPOLvRPXg40J+9Bm3/0iM6jv2zsvFJaTPfHt9RkQH+YXwb0R7tFOSTcPpM9yQ/1XgOuivuG9A58m0N6b4QUrSLCqExSJNU5NCy97YLQn97njBHabeHZIE0qI44la1AtFb+0FHUMQGYtBbD2yylgV7L9WCnI1i+wkh1jQbb+0bnZg5rfYfZhOoX9DQDcdcPW/o+Ljm/g6N4cR/Xt7+i4n1qXyvYw9zQZ2Gv80DZKZ7jSPXuuk5bE5saNzmk58WZGa7Wyln/Dm2rR76eH8o4uxNrmz/wSV1Q2tkpsbkRdFOpefJLR3GOcW0OrQ7J+xpf7dKHZzOW43KO8zi/uGxJbTx/F5NZwMpbnqF4POexL3/SWMSXAS1aFAYC7fU4E85JGxrz+b1h3gf96eRjRP7zK63zBG6VFzEZJEfTxVzWs1PS0oYYf65OV2mF+fRfqyM/fqRTPY1fY1sAYm18B45CeaAt2Tm2rbeipBblLiRLWZB9yRkMyyr5pGcHOoxVoaxltHq9XKrNmQSs5/Yh3nexTMP4wkCbzXIF32e2yh4NeP8lP8jAQmvuX0DQIHe1BndHxz0QwLW1K5lw46lDiu5cy9hSf5za2Rmq/wPe3C6gH263GVjn5lbD42avfP9S9TDm7FQy+iudIGPra4jAIjYbQrovnOmPksiYldYxf1SZqVuL5E2JZFuM50xfGRgeeLuhAFg911UK/FE8Xavn/eMkJxcOt806YfnD+4IOZbQp8p1EDbdFimONotKJo5/BsC+k5rVXNtyFnUvLrDyueTX1hPIS3zgy/1xlbwwJYYVfxNAr9HMS4AXjB8Gv7VSp+O4fnVfglpUB9Fc+w0K8oMLZ2BN9nDr1FoaeaP7PqulOajNZXFC/00VuKjBnNwQUGmJeSbeMom1E7IqPZZd0irJtKp/wX6CkJjc4FeBr3hXFRy79249yZ2B1mTnUqzJgaALzlfa0Oz7MQd2bBMEi7K/jftHcDXzQJzSyoah5QgGdi+IsFX2dCL2e3om8OyLCdgEkup1fSq+gP6dHUGhpP1QDzwagCPFf7wmhtRl8c+Ebbja0aEjd5d1DfZBL3DfodegX9Ab2a/oheSxdB7GcBo6ddCekPAF/Gg64FeF73hdHf2nn3tw8TxijTgp1Rgs46Dco4AcKV5JztCyNK1fQVhV5+Sa6XXsJfUn39ReDkcnc9xjOkyXXDWlt2BTsnCrrcEZxoWXGxbxix5m1PSeeoeJQ5btXXgvRB9V3UkrpbB/x9rHCl/uZcfa6e+30ujgU9uTFZ65Gz5+pxfCSwrRyuTRo5bKVjFx9vo4hL2EIJgRaSXtoirIT2aeImJRRXgn8eQGQrh7PciRRZ8zq1rHmlFlpHr7HVCic0NMhOJzSfgXT9Rz1+wdZb91jrKbS2AK11QGtdJEVonQZam4HWuke0ThNapzUfAK1j9fgFaW1+ROszoHWRlGBY64zdWIYXegMnexXLsKh1165H/ezhibnaEQoox+Z52M+oytvBMkbMweapAJEPAlSMu9tr4kQfkcoHu9rr4ngC1MXFLcIuoOHkbMZVEHsXxN4FdQH9k+Ttx8fKuZJLtCgSh7V22Z3QHcfiD06tdyqU40eCe+wx3Dc4bH2FflErtRt9cvC5d4k9YlFr666M1v7STcZhrU27vn2oG7OtzJDGOO/40utJD0rHvN/aRW9+VtA66c4yxttJhLYAPARYGC1jZNqWeqm2uV6iddbT2vv1FOlPSneXelrdxknUPCdTP+QU6gdckLqJE7/S7pv1KcSKHcp5INmMCUg2YwNynuGb2xJ1AydVcxD7NidX3wQKN4DCdU7kQMNa7uyUWqh43Pdol7g/uI1c62k3vtWiZ5FvaUz7nF08Bnafc6AXX1Lt8ciuOfaOtOT59cjvRG5ncAcFuF0n4HYZHqD6ejIr1vFID7pSi+zh56/jeexztxNYevsPzq+h9+OXoba/nqP2TwaJ8hEullfuGXob+wet21dJq07w2gpKd7EyRHWcP3AgrZx5huqVO0lpO8zn+KR1+q4TLZROcIT1/zwJ72KiruhsIr8JmdeF/mvwLW2qF90HeP3bIB090BsZOztS4QjTSt2yookWBujofXT/Dkloe1WUy9vjG5tD3hzX7SUj2qLuyL40HOmgDgrSSTUq7MFu2RLUnE1gD/MPvUij6TEa88tRMz0O5iOtsI70qG8e9n82zy7VU86l1pDEacDLJM6Xxb+nn0tMpqik5+w3LVOXq99RvU0VbbEEO/WCjFXAfHSUH+ELnJ0ljbDXNkgiVW8HO9cIMJaShthlTWESWRNDY9hU4Tb3+R68OayC+J8Kv3HT99Aannt6D1JlnBv8F7i4Peru6H/af477wzZlOfrv+05yB2xfxaH/O98RTqqX2+X6jg4a98l6HeAkWhcn1ysccjXahvihrQX6WxvK0rJd8D9GtoMLSXRdpLeMEzROqjIqRsYMAhgFMBdgIcAygCKA/wD8ADAZYCZASOJv/0/xdgP89Jd4+TDfx7FykCHm+799GDcuVN+D7I4olN0Df1264LnPbZ+MlZM63OxFLTPoC/NECwx/+Jq4FFb0K/z3SDkauPzyntndLC/EDbKH6FLJrtQTTyieSFFpE7r3TqIobVCvGHMnyyfC26rNxjB7uk1v6ZEHq+aWuGe7AqXSUSK93m2UtnMdrPx6gfynVfS6xaEO7w2YN+S9fgO/pNcV8Et7XQR/HHsBb1ykxhAduHb5DGXQH0qpeMVuqbo863iDbMIv/LA2fPdtj3kPSIan+LdQL+fJ8TcSyRn9L3yRgFpUO83fka+velELMEX4gwtqUkpABlLj7wKhgGVs35gxNFqC9z0x9C1BZfvK/IUpC3prtnfhTKoofeYX5g0mShXUlBVyih/ufRvWv2PY8/xPHviqz7DDKqQMtaEWztxhfPJS+sxS9oWujCB7Am+tGlmk+bSQa4vWBjVVSaRuefwqcyfhjSFLSc5ivTZu/Z1wKqhJF7YK3Pez06dNZa8IlGHhNPF27S98XyF6oKoCbTtED+k+4mfuT0pIZ4H5Ekf1puPfMb9uOjTFwC4TVGNgZf/2Kf4Pjzd38MzjAmPPuWsMDW1ipLi3g3s6ip2UdgPIj/FClJVObePcFlof64CVfGj6zMkjM5rbrKFNBnqA0E01HGoTd4vu+Smd4vIU82T2eZLvQ56IutAmOrSee4FNIGV80bNkJOW8ZaXWTGYnmkcTrB2eXyH1DI5pQn0+kbrqUmjTGBrKK2mnfdCvs01mnzY7OLQ6cJfDdNNXbwD+BDJ3SrppFKSK1Ao9v3KY5hUO632InR6Y0+Ka/737wUOpu9MMqm+qA1vAcClam5cZK0hV5j0h96SheG91oyBT/ThVxWKqC3Mv8IX+hRaDDWsxaoTBHAW1WMRdhf7xg5BhQFxZkXuWtCg9T1L0a0PHA5CLA/tn9SGS/3iBHvAzR8GKI6gphvqFXw/9rMc1WgOUaUr1C6xmPhV0ME9K7dP0tP11vdIRS3QoT/Hx0FuwNpbsxzL/4ctiqwfhfpnzIwxN5HAPBHUrcH3S+VwE0wdgOMDzAIsADiplzA5wfwV4CBAMa/ZBAM8CvAfwJUALAI4XqneOM5pZOHOP8cQlxq14GCvIDdOgvE9LX+gq9qoLvMQfgzUg7T7iSj098A6376Frrr8lcTeOPnduH/i9YNGiloG7aS1ayM1pGZx/nv/RT27MqH38c+SklSmXwtw3yDwI1vSn+L3ugaYBWRXOi54BpoHg3vHQmgGmN1QVzie9/eH3fQ+lTgX3qifFlErwRLcWwlPAtYObDO5pcA3gngD3CXCrwe0HbhW4fcE94Ekyobsv4O6FdJJMSeAb5hXdHRDSx6QD30BvgikR3M0eSpNgSgBfX6/ofuYR3U/gi474VF5KjXFWecS4yz14t2JMZhRpk/sPIpiSUxEMnjP8Dm7EzxHMcwC5AAUAHwCg3sx34H4PUAVwCqAW4HcAJ4D6dATTG8AIkAPwHsASgI0A3wG89WEEcxTcRgDvafEso9MZUddmGLjTzohnHGvnindHlGRPQKb7uDSMZa72y8L7T2jDK5Ks4VGnOoLNtXzZmLDyPL+zrV1PiNLgTkAEW2LBVwDP8yX/+FIHX0LhS9E/vqhm4htX5/n3H31RbEOto4is1Y0dVp7kwwRdhfgW5yn+O9c+7iQ/UgBpQTuTDc1aTSwkhWec4Nv8TAVjvgdfBwoq9j/c2bOP6xFhfaNe5c2zeEekgyWI7QgzyQzTeX6VS8ZurZCqp2Vd4J/yyXvIgSdNJam96QqqC9YYW0PUF/hirw513ry4Cz7ZhFr/+UT7SPJE1DXUxMq3nOfj2zQw38nZUvD3bKOB/k1+JNHdumnPMddyOVkgv2T4+dWHRhMKOUDBWkE/EfSIgqzNz6e4T3N4BvqcZ6Q5w6Rif+RGEOw0F96flgSwMY1Gwc+r3OVciOoYf83PcenkVYNg+2CCr3LlVtAqMcURB5LZNNbHG4mWxn37Ri6F4HR0TdyTTHzBrow9TxCfzKXb04/4/G3KPUnE52oTbHrie9hWZ0sgPmfbCZuO+O61ldp6E1992/oKMcWcA1JVFSdRHeIY1QFOrvqRC1Lt4xSq77lg1V7IcRnXjcQ406arSO7+dg8xVtWhzlmzOezTf+Vd2IfHQLthm2I/n3lW7N84lz8XGCv/2zjBPo/9/djrEQyddYV/6QBVKXSgVOhfEPDjO7t+3C957AxTFtgbQivdyoOrAvs7TLksmU7z85u8QWZlLnmb97X1o/zQBsxB1APDvvN8WyuH+No5Yt9rf/t0xzPbSmUgqQ9R14LUv8EYbMfbzIe8+KtaGJIsvkhcLKxS4buBR62wnp3/pTGtsieLZ1j7jd1QJ/yt7918K90PMPMzmm3W6f22Vk7vLXtY8jasGd6ZKGqHX0tmT/CJ/hMjWx2IR2lqhdxI3GO/ALJLUA9r82fWby3V/EFvMiuxLMuyQ9+m+uAahAIJenDB9cYlC4obf3h0ClJ6/9WV6deO80s9aP3KylpjV7BT7knpo85I/5eN74Tg2O1z3xpyvfFfGCcE41Q3xK2gmr6yXm+cD2GvhohvRQClkL3CrpS9wmbN9cY5C3DVgiltjMWXWNo1rqQW1KGaPNMKYetHFTfuC9l7/wShILsmroCuzEQb3f3pWkFQSS0dmtKCTeT0WgH1ecc10VwsJPwk/7hDUxyDJxNnGqTrJR/DKjsB1tiavcKxFPpjmkX7RSlsLrveWe7Oe5fSP2OHNb2G0u4xZtlTYGWsE6KUqJMr6Z3DyTUvccNa5uzGU7FPnR/42+vqayvV+7rQUgr1/04pOwhXewsmkR1e5TXZPSaqSEhIuRLEXFBU0IMMGolbsfmScJo6wWt8KMPMqdjx7mSbQZPMjmFr+J+A1743rlqYnSzVfgASG96Ev+hI5bDOpnP3FmbaMG+M/UlBooe8qTBvesj3A0exYEiebAOJKNg2MsieJnRVZrFBTtYf3EQHP+TCbUHO9f4x+IoORalr+NX+43yJ+0xDNN15XZftSDMW4kQpofZjUUOOTv39D3rBA048Z0MddIqi+h8c9P4A1CkL+XXLEIpyjcDzMFmTR5HdJ5WN3i5raqGpT0dkneDxnTjSQtAaSicdbmU72I/zFjf16ZmGEDqVDdkuezjw9fSsnbD2O8Hne8Uave/T7TrOT3CDPC+MGVrdEEPjmrcYaupT7yZhjGGhLRF/K/tBCoXeYsGeorXpF4ba7i6U2Ha8WygkJCcs7FpRK5xO2bh/27vFQmLyB0aZvVBIjMAR9rwXqa2nMD2kFmXDUIv3OB/nrm1I1C5Ge25S3KHt8sju1JBK8XVZGI2GybZiIY1o/at3JTx6lZhWn+IwXOr0U1E2P3/V6+TwXdUgc5BJy17hBe8dqEPU5Z89PJrMP3h23b5XjGenJypEOWigW8ZW2SiQg2raVCzl9ApjbFJVmDnMdJJP9pPXXCyo1RIzKjg7LvfR/b6DCsJv8NdJvnslVal6TuQ3yHvwTqiyHLV0ZSy+maeAXElVJ/lgvx/aCN8kEKnYDv4ZTzy9vVWZX+7nZ3rjsmMtdEoPVuagevnJmif/YMwzSZYhe6blyQATdxXwywuwQh/Rqso9zx9pQx3Z6UmRlwwWY1y4fUkcbT/Jn/HpLHjbt38upbts/1M7uJZLhRnrN8c5TuSzp7n29RnqeeAOeMi10ZZ+JgOMjX0+la0v8e3xqSpwLwD1PbgfE0jYNh+1388rvb3JHIhv0cmbZPIgu9bci5T5Ix+mH1qngrUF8Fu3DOZ5LduD3PQ/yVt9fl7wBNV1I7SWAH0//x6+LwLl7ULC3vEth7A6T0dCP8gemR1DZgrxtcnrXDh56f4U5+fPehK65/bw86fdzdD2y76IYDLmiDIeli0zMB9MnPPnfV0sL97XZaDOl8AcsghK/jvf2aOAuXqIQ2vp2f4ykK5a8FCyy3Hm7iTX8b6RzaFTumV96mx1406pQwKcfkwMjI+rbnxZpzP4fgXfeqoT+Grc+K5QVNZ656A27Pu1LvzPuZPY8GfwrAdtaNh5kwstaUz0KZJaHAZWRvSJ8by/9ayY77ibStKP8WzgKvRr5AG2s+IZFbYXjiAfX+dHLekejnQ2hRXtdfQhIZ0c7Tt6zMU/vznc+C3oETbeD/ydl+zHc6rO2fnl0tzOo2ktyErCbENI/JY50L52A8gOqwU8ycHfUnvJHKrsCn/X9efLlLlzP3X285TAf72nDv7rPPLA/b7f+d5ubNnSa6Lukf3R3b4TfhXQnU30GI7zP1ce509Won6J1DnAj5bNQsiNhZPAN2jVUf6IS9SA19nE8Qk9wXyfE/VIo8+DHA709edR3hxI7tcPMP3OP+kZIN7gH0hpKc2Maco+uPcYo/32leqGjhOqG5QTvple3RD1ZqEwfsw3MwqF2WPiX00w0apPnW+5dabcV9H3uruPqYT4ZrsT2OqGnvLqBvVz1Q1aoBEP0OeVQuHrMdUNiTPwrmB1Q78JYzSypiqqhl/rGQw1LHu4PL+G/8CDu+y9kjtlo9wRnV0oqMbG5RYK6rGFggZACxA/tlrQEX2CalGfYEqhkAbhGWPj54v6IO9dE8uJdbkCoAjg82vieTvWq9RiFcYrN1piRuEbO6WC1XBFhnVBNeUr+tRG7OmSHWOmic5OF3Myq4AyXXZBj887aKP7RlcGa4O0IH9rcK9236hSWzLb0SwBnBOuMPI+PUqNJ/mvDoRmX+ek2gYumQ02K0jop87vf8T8HboUwewHOAxw8ZKY19e3RTJ3Lj1a67DMfWUiAzPfcb6zAHUz73ADRX/ZqALJZK9SuH9npXD/xALL/WUrUSIpbsxZUN04akH5/SoiF33Z2GVBVmU1hNY25syqbmQJ1peNUQvqwS29L3t0S+1EJa1FvBOVUIfJyTacQ0LI+50n+FsVEWwQjNF1bRhaLeylsA+h7jauYb7O//ewt8dFM3i/qwsbyx6ZzWyazOwwotZCaI1kocZWYFFmJcLonSjgObl4MysjT2oZdZdWnxeUVj1bNWqrMcyuXZhuO9NAjcGRhq8T2flhAq7ubnOU6ia3CfrqmfPiHQi817im9Ege6u9Idrfv8lBabLsOTQzjfl2a0J3cFZXED8hs624XlsPcerjN/Q7KREXWoCZGAhKrMgtKBevEJiVVP/c4XyiIbxR/6pzkdr1TLMQnL94vtS3dg3nIr0Mqq4DKl4RKvr1WWKV8MgspneA/aKvn8Psa+P4R+Z5rF9NYo0zOuk++oaxQQL49G/hWrNRn1XHZtpEVBuhDEAZjINyNMtbCqbVCRsmXjfEbrjfGrwxqigmmevvvUxt+uE+tfG5kD3vFHzRInA1E4oyu3Xs/65H0mhViuB8corqvC6l0JroO3q8KUd5XDtaRt9JvcJX3qZD7IBNkJM+vuEtR6zJZiVOQpJKzhp7+NNyfEW/5LaNUPIc18B73d52ULj+MTcNz8rRySo1caZCfVsvJGVeKX0Io9fOLr+Ym+vHNqPnlLzFH8jYZdZV4QtuZ7V4xhzKQ/Wwr8L2BLsiNempFKkt9MpDEuuJTsMgXB7iofg32Bo7qzXP40lIvQTKUBulFCzgnfeK7T/+3PneO7+H//+tzYf/HPneOl/v/7HPDob+9Lva54R+WUppwbYEwQhXGUkUytWSHAnJyiLx7leFcaT0oMNZRbOQTusrIPj/MOMYP81XDSD0odDRsWbIOxtSS/X7ttCkHhRBDnylHHmSESZ0SidSplFL6MBh7KMtlGvDdeu0SfNG5UDBWTVsisYdUHANZ8xfgwfuagsOrGyTapIuyph4SlAIH2CXb6HuZNJ26YoUG1gMPOegxC36BUfwvGNX4oqQ42jWPRnno1YcBzkBfuN7YfQHqRlQ3yhfs4VCLjOf+0xQspYrCNR2aektlZLd/tJ/SHbPL2a51vwi6iOweEfroi78ISepfBAO92NjRLrs3nI6M/eCDrrHTtdmZRe7mB9P1sN7Tau/enD9tio7tSGr+zOmnn3pugtxIUSeMaDfAQHhtUekSp0x65IFVOhN6xmoov583Q30q9++FrzFBYRck2tXCCEOt8J3yUsVMVpl1nB/vrxa+oyLqLinoC1Ltf7kN4Mq097jJMvqCXMtxtVBTUZkQa8xNh46NKjUcnMVKIN5iEMaoyovp0YyzfFPp4bxxAc0/yW7kHJJd1MfQAzVS6Mkgt/pwH+IpxxgNzeKuZw0/ou0YyOjHGxT03bzBU4OaekmLYW08UIj+c03S/yZZk2T3Tu8OcSTyplKaWoc5zoHxQa1NZ4M1eDbwLdBeXpH+9pWgjheO8X296cvTFx9vkAAuxmMg3gEabVr1h7l+NoxH58F2+bxnOfb+Dk0dpX4iA0LPouTkzShYV2W0oV26nNWlxtlFVMhfSiZjJTsprV+Nu98jBa0Sd7+3AP3v257sDisC90ILpQ+6NnV2kfG3SmmTP5XSAJZqI2B8QzB+/gcGTTCKAaOYYPz4DwwJwVgFGEsIxrZ/YEgJxlLAmEcw1v8DQ0Yw/g0YUwjGsn9gyAnGW4AxhmC89Q8MBcGYAxjDCMaMf2AEEYxXAaMfwRj/D4zpBAPX0MVfAdhkQ23stNlfGK3OEis9MIWdZMIeco73eNA9zofAbMLQfj7Z/WujZIEHxlcKvsc6eCzpSfsLzvFcAPOhIGLG/Q1zEsF0A2ZNALMugBlEMIea/sTF7+mLz/EHA5g/BzCbXYjZ/y+YCxdPEGTD9i9GPFrrhjhbAnFsgTgXSZx2/mCsdK/MdEqk7sUK6HUvu1Y0BzWFSQcQDh3isbIZtq8s3YFbzvFksEmBfX2JRtSR2O7LlHeoxdu++XQnkIjWOYf5UtlI8jrISb6rcJsLblIET0bL/Mx1LkYewVyWRTDjwE0FeBL8jdIIpg1ADv6PAd65HMF8ArAJ4FuAw5dFWWkxuKsu4xspS0t7su3jQ5T0/bzTY8FRYtDeDZIcFHSGBDYqUwV8fieE+fkLHnmpE+YQQ/naUjnRShqcJdkO/d7LbJexF4TPlYOgX3wB6/FYw1KYCamkSY5NQrSKShzmoPSdYPUt0UrUlHqpoFFvErqoItG6dMbePZ8I6uGr9g93Wmlas1RQq/G+fRmE9lJv2D+8xfr6JqGzauWe4U6aToMYCeCnNcOdMnqpoFWXC4WqlUapo1x4X7XBmGD/RihUUmu/Ed430JoUtY682RcBPE3LStSHOSrR7sBb/FTiaQemSiWdsGc6rdIjXGaLdf4pLtNJS09zlLYrexL8MimkQJ+Bee0ah2uk6KnRTFB5BrlpSWlT1H7+RX/7e5P5yJ9V52WozRfG6i9EtKwZp3PktKx5lvqYVks0fp71y1qs4xTsN8Cpj/EnXXgXRUKvhpnrgrBPWf2ASl0tRBiqH2TIPhG0yathXlstRGWctEm2h0Ot7vcYWAVIAJEt1PxQB7GTRehiCbv6gWaGgj3PoUv1PsdJtiEHf95zVNhH/c5Fm6IZQ/myUuyXEo10B02kEJdbzr4NrR2mFG1VYLt/LSyGGbWz6iDwaQx9zqVjg6D22m1joHS9pXQ80C7yRKvxlT8Ya56x8PsDj1qNL/0d5y96RiMfI7/XwG+7Jxt+LyS/i+H3CU8W/J7vwXXsKPDN8eA6diT4ZnrQysYI8E334O5otbCVovQdrtQK6w2UXrTfQenl4JaAS1+hdJ0vP2keDGPkBL/MJ+rTDoIRdhAkJFVylG1AVi1/EfcJUre8ghZJGl0pppSsdc5RhHpYEVkvQQukgezwtUHWpAwZwx7hv/NSOheedOJ5ZDC00YovG3uvLIa1Klr4OLtY+9pCG63/vFKi1c7Qvoa296frC3H+nqF+7Tg/yUOBD+lIfNEwusO21vKfuuQshiwilKm+ustH+AZXpFlqCSV5T/Cd+4fM2N7fyLr8f6KZsMC6bB4A3rF+9xJN+X9XEv1LLYTlzl3nTPAe4ze1bRKeNFwJUrDhrOQCtmG16xr0sxGtqqnWGHzfYdLwj4xM5ftG9Xn8+oDoEtrdmp0in6K0ciFtKO6sJbDH+cNu3FvTVqD1gM+h7X50t++1+XmPF+rm1WJBk4z1krb4/SxKrbzHUMPvBdNiClXOvos1O2uhFeXCm0OR3gaIH2U4b4veDqHKBdDSy9wHhXcNaDco3HGtMZbIV8h9MyuuNXYjv1TIjWNhLS9gLkogF/8iVLQVxdBquDoRClAW/NrAEOsdrwDVF93FwnhDFLnhEuaZmnWM/9UrakT2tMu3+fg2v3wDldj1mmZHilorpPWF8fyxiu0Ao3RAW77tIJTxOTPyYuTEC9z4+1nzONJW47zPArXSALUwuwKo1fgVG0c2h04tMsocYcB1MNVhLpPJBH0two19LAvirPPKHha/7uP3+0fCr4/g1zr4tdefCb+Ww6/18GunPwN+FQSoR9mjgfoWf/TGWqE/yCMSB5RYZbShHtCVLhvLYgNpBbuo+G2oQ7zw97ztxthL8iaaMbJPmKK3nuNNbdFbj/ETvRNHhtmVQO1dv3IDlRJTKdrEMN2VS8NdS9pGsje4nq4VD8IDFOvaVM/gCLiZlzly6CWG0EtglUBP3aYEeoZADu/bg4DmeP+1xiCiO6wJ6A5nBXSHByZdQ5uMHaQU9mHsy/NgjkoO9GXce2rvxx/CPPYlwG6AO0Ewt8H3qbjvUERpOu2YTXL1qrASaqfZI6bdmaTd2X+98f0FmxqDYBXXB1ZxTMgh5yg3WcVpcB2Xot5YhnH/1fZviFv7WFzBh6cbj8dNIHEjHos7qW0uxP3+sbiXIa7lb3FDSdzIx+Kmt02BuOsfi3sA4k76W9xGsvKMeixu97ZxEHfBY3G/gLjmv8U9R+JGPxbXL2Ave/GxuFaIm/63uDYSt9NjcW8IgyDuU572Po79Jten3EjrsxzQHtpYVuwl19z9AC/xsTRGQxqav6WxiKTR9bE0dgsqiBv2WFwDxI36W9wpJG7MY3HXCqVsBYsc74Ar5bZEv9dOwfiVavdwyGVZd9stqnK4MoKsuweCmw2Q06hkBgJMBtBREUQHGnWhmXIJsbjzkYci+1v55cPV60q7Zp3nVX55jxwnLdNdyWlx5dOfrBbCMhx8ug+1xeit5/nvYJ0XfS18tPLpDI18G+o4jxEoXei1zjtiRlBaShgxJIWV70BLYif4NPcfHJ6OSnyUqjPM4irWDeOieGEEk1IrjgWcX+XsstKVrGT3GqjfYM1GKOkXbfdmv50blNq+XyP57t5saXp67htabf5r2mn5yM+35N+Mc+emWzJH6ioz0VaQfrI9llU0SYPHsoLlJ77G29VJh/es3NJV0SQLpjSX83PuTpKWjdh6T8Hsz81x9gjeb8FRpmX7q9Fu916fgt26J6P5GaWDr/ZWNNHB9x0SlduSYE4wneDPu1DimO1/ak8Ku83SO+ssr/Ab2OiAPLu/iQrv4FCb5cA7FcA7rwq4I09BDfzgmuvspGjgclqsf5FcDrgU7HVuoUWuP3OV1m7JR7u0nzlCtDfzCwWZtUdvfOdZS071KI2Yuxk+Kaw0T9nF/L3hpZ+679jfRIcuapm3G+S7ypbAPq0U6rVb7Z/ntJTmo9JwNoJFyeeBgJYyRH3RRkGiUQT8nCDVWAP+G0KopiDQz68IYZrFAf8FIZM900CX4M425ut81nXBvgVgz1m+wCfTiLEPC/JHKRwQFI9S+F4IepRCqcBACqJ/O6GKZ5cJbFVW1TM/jb4uWIsAlpzln/NRgVXCpwLN7ocaf8bXvm74UNhnqjBXZF8XXrwJcARP55jKRFbZYn2ZqQxllU5J+B4TUwm82ykLp9bawJ/M0muVToYOW7vLtHs0fpPAbyXdYe13ImaLNUe6dnsglgro9QM3A9wWcK3h1wXhd6ZyF+ItYipPgEstui7c+ZipdGDY3OtC3Wam8jKGg/9iGVO5A8qmOHumgVlxpkHW+UxDyI6CsqKs4tGB15QWn+VveaWBEsULWIYPzR9mf2S6Lnx9GOB3UiIoCVOpJ+UQc8YEcqYE97tATncFcrqV5DSm8hlIWQIpU5CqbGlB2UKovV1k7hLT8/F5vi15En2MQxH4fduvgJZLIf7rfqgbdi7EKfbS6iANhl3w02wehHzgzcvKG32WX+al4m/m7TCGXLpbJiGxqv10mYE9yy/w0gOauGlZ0wHrDe80iPP6X3ClBHcXUEPc6QRXnH1xxreyE6BflcL6uXTtcxB/vHcCxB8biB92qadr+QP98CioqbDKsayJ0DACjf9yT2d92fjMyrN8ulcZoPauPwL6nOh/yx/uWi5EPirhHH/Q/TUriY4OsRk0sAzm7ZAjzq0uCJ+F4VYS3peEr2CPODfilxfwC65e8BvVW4zzocuIfZjOZvtC3j+3nuXbPJRGRtIZ7F9alsDqoAz/9ewyzrGXda8pE7/0hRrIgNzf9NAD0T7yyl8imJ8BNhijmAUwfjv+GsG8CO5wgDEAMwHmI88EKAJYDrAaoDvgpVyIYEIBOgNoAUwQNhNgGcBagI0AUmkk8832CKbqRgQzpzCCKYGw091xrnCk7QX/RYA6oNcKcAqgCuArgM8AdgD8AtAIQAP9lwCeBRiGaQFsjYxgfj8axdRAORd6ZGqa9JgDvg4bC8oo/Qv2M6PPms9mU/jCvC66MoVNZU9m/QyjoBjGbvGRCDJ2FWwE6emF4DLQg/OR21RR6w5j+3vCNm60SQN1ugb4NM0ehPCRnoPZUrd8RkbrD6mbjJKrP0JYOtS9XGx/X0+XVRjOfg+tYig6y/fzUPHTZu8wdrqU5ZI/wD4E8qIi2N5cJuJP90GvL8uCNunqGcA2cCXmKHY7twli34GRGu4JIjzOx4+B9Dcj/wd635eVG0Nq7pYpyJdMn9imbW56QDP3UdZHz3wGpdy3GADG+74ygM1n+btuKtBD9T4c82vNa7M/Nv1vYx3HcUHZyqyVMCJ+dtOB2GG+ZdnLTcvN1wULcAvL72LsWBZpFmaLXFAWvtj0v3MNq8g1CE/bRngaU7md8LOYypcCXETxDXCRFWIu5kJ9UFASajPw3bVn+SVuSSA/1cDL2sfXIa8MeL/o3+ft/GgclnkzgdMjv/8fqMEZ7uBA3G+9NDsZQl50U/EJ7ESow+fdOXePMi/DqKV6a2fvgbHP3FNIaspSCf6HXrpsDGCNcNMD/8tlsfSAs/xTblnfOgf1xGj7daHaKo+nek+DeKMuJbIDSJw3vLN6BrE1ZeKv17yJPQse/XrFe7fH4ke/XvZu77Hk0a+J3lk9BqjD1tSU4a+x3pTsLlDDMZVdWQPU8nC2C9T7j2UxlT3ZsI1M5SisMwnUVxeorz3J7DjWzPbJUkD+7rvogY1le7n4rHhoR84l8rQXgScOIun08oo88bILeSKOV+QF82B85QG8A3APxmjwxQjGIPj9OnAXAHwOsAe+rQXYBLAN4D8QJgNecgL8NwAOAvwC4AT4Cb7dBuhwKYL5F+BYAfpdwnV1BOEPSy+IY7wYcAbDtxEA0wDGA3QC6AMQB7gJAJ2zukBJFrv+5O6vkZJUesSSvElKEhto470o885bUlZklNrHVQRj+7uCs8LbdVByzvIv/VhQJofwSa5mbmkgP+suibzrW3CjynNaFswvcjc10QkytsNV1HGmiiTaEFOoOQZW2bRPoqZU6hlonWh6Qtu1EC1VJDXJzdO1EtVxvtk7Xf1fDmWk8MvAtwD8fxz+mNzh1KEVFcnu5WzGg+Clz1i+MH35tI618ze9lC7TobWk2z43f26SAg27l1Id4fVuHz9JkLM5LV/nO/iDbXi7w8fnC1rL5Io/bRSuNX9E4nzvpVW3uIomSXiY/aLAjFllQtrl3hKbnl1pft+EefvaC7zF4uNPgyR9xq76i+U5be5i82WOhpwXkHifeZ0VaKWk3OHjuzzKw8JAHvoJKgul+8kuavLJ2ccpUX2/tO/j8gmdN6Fsb0LZ9lR4+Qf+djrPB+iECJjGJju+iIo5VzimEesyn3KwMgh5CPmBklDn+ZA2fOutgA1zwO+Mw7yrTQoy9STzWHLf+Tif5rVyVDzwHU1QUwydBSuBwa7SJophruGdX9xVPsv3EEaOULCNMIpr+Pt4osaUP8zPCalJYUVN8mVCDMypoQI9QME2cSqL1JLTKp3XPY9Sp7JboYw/guyscPy9pMNaEnenmfVsP1K/LZ4h3EBSbpibdW9BuSfbJKoUcx/Tcb7e83jcftnhP2OZIW1Z4Z1wKq4SymbYPyXHqQQ/pXVPcfBHoOYZG+18tw3vcdBOiUfG/tny0U0R4ZH2kKvRTW+ER9ujmzqHh9u7mrVsKPSHfdzmOIWdSqKcvy6Z1v2BI9p8rz7a3ADAAdyuR/0aXI8xv4nyfBdw9QCG30R72SPBfRpgAsAbACsBkq5HMF+CK4M1QD74L4D/B4BI8KcCfEJK/q5HtV9jCbEVmcvqsXxd7REstqKd7+veN8XLO/G8CeoBz6Qmz6TVaOdfDuVBjZ1lUJPLIPe36pTsHW6peW39UkLzWajNpx0V+GbT1cXmxnqtZWNFgfldUueDPV7+mK+9ZyUK2LO8/DUf9qxhLXm7UBtCTL/RFW/RQ6tK5vWAVl1ShvdjpFC/c809uT/b5qIQpqK0SpU293iDTOvgaUFG2uBHIahJSaugFYa5qaRhLf12tWux6Op7WzpWvGweXP8yya3bvb4CS97R/mfau13SHrJrXVm00HTOG14/waznJpjV9RNIjN/duRWplrg8Smts7aoBjs+WjMKbcp6do81v1Y8mOHa3lJ1YkWKh2eg8A2tsjdOIOHd3jjJPrx9FcA65M4AOzcbl5bTS82gt0rl0ezj5hu//GSrab9FVC1TJ6dtDyJct7qyKweSd+uN8kRvkdMhjVNvB22JPLoZ4AikP7Ug1P1FPsyEasUwjXb0sWsvRsh55OS2LjHp2LKuCGoV6ZBMh14nmaJOejM6Z7k9v9yG05rhLiOazHcLetvUivunuMTYt8b3s1tnUxPeCm9INd+jZnma+nqoshL71AcA318W++j24tQB1AExdBDOoTnxzzwzuGIApAFaADwC+BtgFcKzuT/2x0Lgo5pOkCOYchN0B8AKEg7zaGUALYABIAxgGsJ7kJ9KNJ+o7rWlTJOpPsmr4wz7kLsGXi8xFhPcKrp/4Uv9as9SSUd9+v6mGj/RJoOesNv/BGVsZdQbwnWASssJ8k8M7UhhC+Rjb++Yr3L4pdO+lZqtpmaDKxTo757outKAdoDcGz5xAyQM3h+6yuEvRoYkJFm8PJQhRGXh+mghrlAzgepNdW41BdmqNnp1vfo3kbIfLxtH9ujn2PnTN7V5D93ep7Gi7NT595g5jwiU5uQfEkHtAmJsKrxVmixnkbZLj/GpXEbf34YJFMjs95HfUOBx4naN7X+OeFDqp0ldsgJTwdtAkVs++YMY84zxc8+hmTg3/s4/SKcnNHIamVDV8vj99wZ/3cqSOZ8wjoM8tu3WBXcVlk3r+Hxe+UfmkwwTSn27tdSGr4Az/vk8ST/dG+3bJhJMfF2JKsJZq+I0+tJo2zPzerU8FtYpODHXgCMWU0v15PbpXPJl1hn/VN+lWd1ZrybNlsWf4XJ84/33tx/8VvgwIe853jjOYX7xlIDno7qJ0sxxib08yD7qFM6mefFG6cm2JxBfqshNNfjuvcO2D+uptHnlbqkXupAiM+DAYHd8LUhjtpYI1I7rFOl5u72FOvBWkvccFaxs4iUXNdspDTa2to4Jvob496oUtviH2b7T5th78x92RTNkN8b7RcXBbASJ+h34JkA0wDmAiwFSAY7+Ld1tugBt8E9Z1AOkAUQDDAWZBuDgjf9dG6aaTEj5vf80kjuTNbVjvOY5Z5lmEC6xpm2m2EN8HbdW81hvUpJPPaGDo8OZ8YnXwOZiNqvkBvhUjmUrryC7ncbamNOKJ8qEp0DolNfxpmPm7XHuWbeuOLTKP9AX3O+/oF7Ws3YGxO/vM5OUI8Q2OoJrRZj+/YT++G27n0zxnyQxsbO2iAa6oprUlo0bBzNXOI7sEeGSm+Vp9JinV8DaaXQPcLafF8Gwc8EeMgToTw1pe2JFuHkD6c3wb7oCM259GYuggRu5fYkgexRi+I9l8m0smWJ0CWMZWOuVxuv12JJhruASCJXmEJfkbVrcdGnMlpyFY/xXwDuH7Qkayn1fu70HCbgsxFRCCZ+n7Y6EGuu5XPTq9xncthgXetWh/32JgjygmdngU88JNsa98AO4+gMsAklvQBwD0AOkAIwEmAEwBeAPg3wCrATYC/OcW2jN5f878ODmrdVzn/wWzcn4F3pTRwewZ6ZfpYuzA43K2WeSODjCOjnj6E+3eUPAf9OD+o4oNNhc7N/oY8qrYcf4toZHbZlHA950eqhfqcf/nagRzAMBxVcyr/6q4X7ilVKJlipagXiors2c0j1X/mFXFf9tWkXWU3yOIO9YKlrFHb/Pyta7ojd1szDYDe5S/4VKx13mNT9RvkhRU87+40fIscMrFeJaI1sHtfKybvPkLpdiNXDpHzmY4WwrCtlbz1zxif71bU0JOnyhVsTPdt8l8/wZN1txefp1PrimZJvrX+BLZuoB/pY/RqKaL/kKfVFMS8L/nk6TVTVcEYv/LdzMvdzqdHq4PvrhltkqvuHhztjL9v3rJxcwePn3PS19ZlkDt9PAsfpS6x7sIeL5UdYz/1T+yOXRaR7KG8fJ2T2YrGxUS+HUSX34asKIuUldYGamdNv0NqKeeAp52efkRrnnwK0bA0y4vP9Q1F35FCDlOCYMnXl6+vwvfH+7Q1ENKB6jt8mD9TXUcFHoYpM5IaaQ+wzmoQIW6EaE+fqOQCyv9rQWToB8UO7/zvmieSPK3zD8ZKGd5g2DkdnN3aFoegvtTIULeS1jzY9k0aJ/J3k1Cd8PPtifZjttzANvkzcmq5k/5C9jR4B7zB2+zslmA90Nb2h6z2UjoTvbTqsP89x4c9/IiO5/uqubv4Ylq4IbBZ9Bia0bKN56pGWaexMZAnqZ6h5hTSdyhfjpex2qJfZmQbRlAeSWMQ8Y2wGzn0jR4Omfzoe5ibBHaot8pvGugtauFxYZq/kfXJqGXapOgM6wW3lPhvY7VglUVvU2q6ZO1WlgEoQWGo/w7nuvCmjVWVizdHx4sndbWcfuTbAyU7rIHX0QB2Q045Md/ybGS7UruRIh8zVDTCfKNba3wRpo3czdgPfgTA2MSxkLCFeDlV8Sx8dfzuZeuiHfvxrUqmZ4ANvhtBdh/RTyrfnV5D+oo+F/eFUL951RfapMwwpBZMZyN3o61+5znKwsL/eyuC8Mp/Zd2WhsK44cp8vJ920I3MBtRchBHVP821IhPzyp2vuYx2LAHhgV6yUduLUjUV+bhPdKf+AFthooBwEWP8UuIDR1VMqWli1KyqSK3Bt8DoNV4UvWsr+SVLXMofWVr/92oxfi15Sc+3q1mJZYEyM9mkJF6uOWW14y9OGrN99r2/jjLh2fJKjbb5uUpfxC71faVpQfgr3QNZcM5L3/VE8ROtOGIyWC7AseZ6ulijjJlsND+vkaO0kYHylYpRG9Yw8mA58bsUj4aYdmeDuQWxzG+t28yyJKtV8Rz0TUW8Zx/VIA3TXpKxmRtimA6wO9+ANIraP87jkXbPRuMS0thzDjrC6gHp4j9ng1Gyjl28bCrxubQ+RuM3cENAbfzZbTig99WFTBXy4gVn6cWa2EkXedT3W/eQJs9+HXg4rKHcS83O1APdNYNtMGDoa8VhEEctAf0fAHMNhB2w4EWzSRQU+NvoG0exJpSgLZ5NhjPO2QkNJSE3ip4+irImMQ/pADfllAQ/+gCtNezwXjAgbtnQ2+gvZ4NxEYPyB7gK3X0csqkUpDHgpN+gNSCiE4P8D7Xz1mwdhckj0KWuehH/gLXUfj6iqClM51S6cay9vA3XeKImCTIHuHmueQ30AYQpqoviL2KtoTQH1uANoI2GBe1zN2tZQ/nZQoy/eE86uNBakqD8Sa78GXwO1a0k36xDm0BbTDCd2e3AlmTTJrxIKJAk4v4swC/nit7mPDyC5fRWs8Go7UZ66grSeWJgj5X0e6PmGLUVXwfA/2hBWgbCFM37NZaDucVGanmLwvIKV332epaSK8LwQsGvBiCF7d7jaBO1uZ+UYeWgPBbWAHa7Ykl/hDA60bwmN1UUoZTWUAV57RQ8yVQdtUjDDXB4HdtKescqJ2rbbOAniQVMcyQ17KHiS/HQDnyAXPzw4Rx1uaoAiXMJ8Nar+46nAexW2/vulwmVXv54W6c24ZB7ams44EGnYq0T+7CFb+6gNHiOfLwOlgFzkfakQUhQNsAfat7QdnDRTmLWvZCLoI16YAhIRiCNadVOh9p/GeXbAelgfboK9FQH6eoQzVevrittEK6YbMxyq5fiKvqzbu07DbLCBilPwgb6yUktR31qOWBelte3upBO/jEZr42ln3ISTUYyrlUuZSqidtSJoPfi7gMLZ4SeflJbVvKJIEaGdeGYeizuzIV3AURB3+zba/Ut7fVSavYVoPgC1PXHnooEPoa0KSFg5zYQ16DHnIBYiLGzgDGLPXvXHusLYGwPPVN7q89MQ/i/Vj/15DZEGKrp/rHVNK9rIJ6+HpO5JjrQdZRfRVEZXSlqWXAO8SZfDU3pAJrIKfFOl/UlZuHp7Pzsa5aOewdbVyvdoxpjfhtmpMTR9nU+s0Pdc8aBo+3HclDu0N3d37d9AKd0Rom/cw4rPXmzk9AhqRAkp64e0tZTdlA9cV6Q/rlsiAo9wDc98pR5S5qMe/Orb+X9009pDRFxZ7jXW6pVkLsi/j4t4V+HOo7R7VYJyxq2b9zS1mI5ggXZlNqu3JUsVJ79DZVzGg1bAyEybQX66limZbn6CTaQRXX1EuS5JWkzTWUtmNlLIu6AR9yc50KSsrh67gySG1q4I1D1FMPYpcTyzfiK541/GwB33MLdtD9b5XNSHrgIHbzsk7za/10HZXEO8grEQVUpet2BCMzS/D2T0pVA/QuzeFctGV6+k4Es6ic7pVpoYrQtrEFSrVaYDIc/Md+Shd0DelZLDV8mkCp8EbWXOd8ysXh/bgPY2zGYPvw5uUpKvaZOD9/1U/Z8g8msA84SuXi0Ga9ToMvF+E64SzQ4u24xxtULtlBa6QC3T3D0hXyv9VF6xT2Kv4HP2XJMIoaihgfLS2HQRp7YWUcLdDd8AT+BlBptecfpFQeTlluIJqBv/plWYf4lX4VOZG1k9cA8V5Vx72p5fLvQrPGC7LJp/kQP9nzKz7Dn/MFQe1I/L/ym31PG87w1V68PWDIkJbmj2qoF/etB5V3YENYehvSf91fUpHIdmiSk3LM8lsqNgkykHbkhshE2qHUy+0qVmry88f9yF3Fdz123Ikgb5r5+Xf9vnjx1HyJnx7a5lAT/78DuX0H2lWnRvt5fv5oZT6xBKpRdyI6C01Ee8QSwJzul2kSyC0Mo19XIcbCG4jbK/PJO3DBJkxtqV9LsJ8JxDIBfZAFXxdvWhZXNteL9i9lrKAKh341zAcyZEWSiegr+dGKnU58BXZJF6dUgauJnyLisyr5Re7BbC+CNd6fAv2hxOLgC71y9pAxtuZgN6GvrlKIT4T+WGLx8zt9S40FbCS06Fmf1BJjSsSTsCIVmwqxB/ir+CM+lFoyIPU273GuD8nnQ18DKW2TD6mgjwqU4I4PbTyrSNx+I1DWrrbXcdFQvykALwG8eaddH2Vp6Qo2E1pC4sc1y1bIY4q3F9GqPepTEfcnn4644f6MCrw1bYV2DQv5aaTsItoBFW0rbrvHyGRJukpZLw3IqluhRCN8JcYgNgRKNANKpMHyzJ/EZhJbQKd91BN19n0jZJer+Od8aKPxMtded93VKqi7Gy4xzSW+tjJ0FwXystCHI6dDUyiNv56CFWOaTcoq7jGSaBOGfOkr52IFBfS0UAPe1Kc+DjfhaRp+W+tD60zfcPTAH4xXHCL9b8ithvV2BYlt9a1Du9z1Yj3pwB0JML3+UX2NkrPvl1K9/NoV7GDTakhDVuyH8qENCay5TzwytXw7UtoL+ZWRsmp8vWwGQn2sz1B3Xagq6c0+PTK2Zts9WZDsCaixPoNZ6TassR3eZUYrq4EaO+2VWgZjjS0Zy2oJlVQf6s2EOuQbtxi7XsLzAqgD6jT/0E33VwDvCIKatHlFa5fEWuiyFFamlm49zd9yjxihYI9yCaS8V7xiPf7qlWlk29BX7sW9Zca0k5NtKDNet6eyYl24vFhbvwbqYwXAtwBHAnXhLH8756tS1Cnvx6Id69yKN0lPv+7NhXqwusl7x7lznbRcW0erHXyeh9KV5CouA27Sk6SvnvLe4FIsFhKr2jvQQvW7ZpeqZ2Q5+AmAm5sbcnka+fa9t4of4cXer2PVpc6DzLZ9zi/80dtyLfucG/w5LTeSo7dW8p97ordTagz7xB8ej/EukxehKGeBFdd15/gxbnposyOH0FzlTWCZ7Yj9nh/zq3uUX5n8Z+4bi+SLvDjGIWK8RjC6uGfkfsqhXTFRh6UaxrGh4neLPLHHxXRCc6qX6A5BuG5PGgmZ5GUCecr249h/6EJKzS4xLQPw31OeYu4Jgpv5CHcASe96AKuQSya1VenFU5h4Uw130yLRY5j8op/v4UNr9irTcc7Pl/oEDjE7ejEsjlCN8Z7nupn2cTSsTxzAJ2iokY+gf33uSWGllk4ERwEpP8liyoIPU94cSDmT68BFMG5o757gDgQYDuACmAdwmBPv4a4B9xzAbwB/APQIi2Re4JCP68kbLtRMle0Qv8unmnmIN/lyya//gHuIN/q02VR899znVS/lbso9xI/2JrIJ7POqKv4Zb4+sg/x3/u7wf5s/kVWp46Cu5npkTQaqij/gkzXFgbvPlzu7yNnFVwL/o3118D/Cp3qtyNnRlwv/Q30l8J/x1cF/uU81p8gp8eXCf7+3BP57vEx2rGUzrI6754pva6fdjWDCoumM3quCqT4AI9IkGbWP7hiv96P0Mtj9pzwhZ/+tOsTv8+qmTAB3r1c/0zKF0j9lp3RD7CoNpe6R1TPnulBsPcRHebAcBT78/54vLru7ieo1JFeZHjflhEBldLPEZiOkaWKhJjQs8H/P80DxkofubWyOkwJObnquvMkQhDwmja3kb7nQ/YnPF9BSmxzqopK/7BLfb8c7ei4O8/7XsijB/8lsGSMDlwGIBqATxJcH5Y4oC62Ps8vOS/Tj7Rj/ubokk0KF6WCbObzYVme9OnOCKcqidVZJo3L7ZE/QMBZK4bkQm+viqPheOf1YrWWnoBiD91Y7NCkktDanxTdcxVaNomz0wOHNy1I3GbXAtZ5kkfIPLmy5V/zYctP82HK5fmy5l/zYci/4seWe92PLjfdjy431Y8uN9mPLZfupeHrAcY4hefzYhRa9seR3GyIYLBcFgOVsht+R0KadsvPLl+R2gr6IFt6pzOjeMnbJFPn8kblVDbIJqIsXZzgLXAt92L/O8pe8ISZaVeRc70GrDdUNEfLqhqgJ1Q2dALoAdJ2Ae5CxQBv7TB8AsZ/MVp3j+7rEV4+rieS5ZOaSCiY72NzNEuXUhfeoDMpm1N0sBVPa69FgqOJvHARpMtAmmO9ImxLfMaoU30gINrfjBmXL2G6WoGxqZqylm+UQL4d2QfnkEE8d/Gu5+zb4oVXH54zPzpg9fnQ3S7qlyBnuxZoO80INtJRMe5KlilLYEdrcmd9MUQ46xC/26FkNmzvTbDrEH/akW0zmTGeGND039e0386XOYVJJ6mTKGVPKlhpllzqDRPlMxoSXBFgpLJ+6XKDHPGmiPlbNHGw+xP+PB7WGu7LYa74AOnjnJj0XU77ikWxDq2iDfNINKdmppqgRHxilRfJrko10qqTIkB01Qlr0xGio/SDJtjT2R+cSl5zN379lZregjhewLwz1IF/G1sudvWVKkXOPR8fKSKuvB+m6mylu9HqBpjA3EpJf5l4mo2eXj5RdihDohQszHrwocBJnlSQjkbavN162575Wy1XxsS6p5Q19sAN5oJn0v2AP9ss070n4GupKBA6ZzEqhl73cVsbJAnV8EdpaPlPG1MIcaF23nvKf3JBuPe2trm0Q5amlpXHsTw+CtHSRKunnMjkr/VhSZLpINcUxGSzu5FXxczzTKKpI2meEMyMkuEkWCnKxYYUgMVAbNgmMQfrZCoEqmciuEKSGQ3y9X8POdU4Im6BSJSrswfeMNJ1SIMiqsl5vJS94MX4FW1LxmUAZpNBLrHqZ4w6U4xu0vK7IAF5S5qH6MZW9WUNASrsD5VvnpodVO/6LlioVzdxFYleRz+nOqvr+XKZgizD3iXTRUMxzcBbQ6OzpnpPjlDKYz6H5aFlQUuLOh/kbJKeY/elvQ8oSa2JHhxNStmDKMoz1pgdfIEtiVaJk/BH2pB1GuR2xJrjxDbJ73CyKMU1kD/Hz/bc5J+TM5N7XRDOnHL8RK5o3SN6ukrHVLbsbjKJIGEcdw9Gy+JKZk/f7+bmEr/dzM+p2qyjsoSuKHheWzLxZkQG98E23vWkEFWTvkN3tbbEnl97LDFfUIB+JciNfm+qu45C3hJFfk90q9SVOebB9LGH6TLk0O8aCY/qAH+3A4VgPJfYtQkdTxL7FdENIfLEwzaC30UOldtQF6uZvhZn4N/6KT3zD+dZdca4U55I6MpdEC+JcwpfHZ9NFH5fJ2FBYw2pNWrMYT5OdIWSkx8BMcpZf41aZcA+Z0lQ3dE7Fvc9pqkJhhqEQ0nYIVFWOpeOCr4VclXgLqlCYqpI1WaVoPUIanykoT2cKYe9KBWa2VlAkwQryRWXqEiNIQvh+oVBqQHpVBhWLeuaFwk8GtPFNVWJ+tydFMGch75j/8QA9y9dAqlLbZxWFWioB7bhFV0q1uJ/dwUBprcIMpUQDPXvbbyCLyB+tSHuWF2hgZaxaDP9DVEvgf5hqDeTR3thlwZrGzgvWCLmGyIg+9/vg+3yJwn1uVut9akHp/VdnfXt/2axuEZJtnvvHZuHvzvB9tRAMsaeoIiMUBLueYCEGflUQS1T1s0AyV6EtB4XGE7hrJOaRKvqNnxrI26LyOFa2oyPbiZWoKY1WkPWl1kZAqz3rWw9r1TDDkQcZkpT8y5kSJy3pRifma/M3AQ1mg9YZTkfkB2/oRkfl48p+UblMu0bon2sV+hs6NIVLaXLbEuphe4emDlJcqciJlRIZm1tBE1l+sn9MhWgT9Tm0V1OxFGKriN0Wuhe+x4hvPv6fKW2BOFWQw1Blx+xwc3gWvp4Ty26z/Myn+jcJ4Upq7SahowHyqtpmCc76mdf5xRch0b6RRHUU5nV8Y+6HXlGMYUkEswradQPAfoDt5M1OyXfh2hGCbKicDcs6wvd1q9kjvMpLb/yyMWQBrY+uXPJAJpUAf7vWSC9AHWG8TX8U2lJcwxc+UDIrli8faoC+Mt0gY1eUWufMr8AXlKv5hUKtUEqJ/jcFvM81zRCMsXTSy8OzqvnJQskr+Jo2pZc15csVl4dC2FgB68zmfFIomUPpoq4w2ygtLUQMreZfEaC0hnE22fav5qQA5nhBvOOoIitXXNvYnDqB1mkdmwSlgU4P0puJNVxZ/0FDhg3JZP1aGDMGzMVUgyjTf+TbJET8f6S9C1hU1fo/vvfcGIbbcFFRSTczoMNFHUXT1AoH3MKAgbeyss54H8vLdDnnS9Q5BwvLTBODSjNPml28noCixIRBpePdZpIKUZOyGgGxQcm15/5737UHxU6dc/7Pn+dZzF5r773u630/693rfV/9O52JN71Ocjy2rhFmaYBs9lcIB9UD8vhrO2KYlHhrLI8+lNAHrKwrk0Udf5ZjymONWv5b8o3wGnDIv2edcjC0lID2hAO/KX7hEEttpHe7aBqMRiKkqaEe6s8dqD9lmhinXFlSMgHXYP8n0N/gbKu6Jjw/nPpO+4JIAQGqjHjldyXyEq2SXgtwPUvb40ntC+KsxfF8BMa1a0a08v9WRSsXfoI8KjAlnIc+TDzVJom9KJhXymHlzwpFf0TSfxp45g3JbpybnzitHkNCnG0u+hDUhdrQpkNSK0oIpBtPkzXCSv6yoyf2ghDCf++QbN5t6GiZKWi3Tsy9KMStxDOr+1yT+WZAsLjHzrffF7QR+gV518UmcSIPf+nZhIH2o9xpst6HXriMsLMNkKd9w02P3vRtpq+63T8t+gwOt0qGskPxqoW+bQm+fReM4yx4O7J2kPGooycHRnfEdnse/Yx9cifwWJc5rn2O4bVxxmhas1mulx0xuVj3h1zA32rR2sNY/w5HJE0rdGFL/t5d9FHPGSbE8JtgPeFZNvSLhn2ONrwmdojngfCsD575MddHKxNmMtxY4AHfkQqvnN8I1IDKhui+cSn9n+lngbIDPnhdy8uMOK++IZUBXdDvLc4FlA8y5bCjfarWecqvztOanFeVKtECYaOwFkIZhAoIGyG8DWGrXtZVyjR2Jqre6ZSrqpxxPkbL8e8J7+lRrhh/Be3+HDVYatLztWYFP6EqzZhGe8JGrcwYW3dA7x704p5ySF6iZiTUsi6QbFpHTwBi30I7ErkcGymGXXtay+22GDP4AcZ4mttO4dte59swzzdpntF5GppnOeQ5rFZtDM+VwtOvCS2OnvwZ3WnbmaCfQhvZ5WF0J88xHPJVbqboi64Z+vwt6O8nH49Wvt8h+ilE25CcWddTF44zqeukHPRp7hdkPm0Z8OiZon/C5qCfajbx1cp7oSV9vPJBqpa78+423kPrnkefF212cBrFThvsUDmd1DbWeCfcT2u90ziaPjdWuNAZVjzaqM9FDUkJh3znC5IuSKgXTTxpkedRVg0zXnJcFI6WDL0vpUAGsx1PFUl2SF5fJ6jVNvKUl9XJbcnGwbQfIoWDDiwR342FMlnbYGOXQ8sbqO/BRuIPYIlY2nhqz0BMvQ6p4cV9jQcgHe+t62SKe+6yoxvJpYA8/ZA9ythTK8aDUoFw45swj7Efp3eIfYr+KtFXZTj0a/4j0MeTRB+V2r1iH9/5uOivEn1QqqHfnvGgLW7R7msjzFvsNbQ+iz4nbeSUG09KhRp/cYQGfU7ayGGapjCiXZk2B5aNPiex7N7+JtHXD5t0UXCWQdhawkfwQ/jsyfEts4Skylx+Nn+KlAYWJ3BV0+j13wI5tfsmh1yQd5TK8CSUyXyKjPL/q3oi/6NjqZnL5eCZpQEOVnbdZaEgQJ6vT6Bp8wLxtWLK9/X9acqDN1Oc9X1oSuHNlFXWGGNMLvb2xEC0UU2vxgZYbRS1cdVIRgYijSp6lR4INyrp1dAAtYa//rc+Cv8V7G+k0wOWRiv1EC5CH+/WRCsb74f1yVmmxNZIzQOXo03AzCrRwqGoC68ADj/Wg6e/5dRnbSa1P/2GD9c2+qyNjlGjPUEqi6l1qqjHXFzzIha9BtzyNDntxtTBNWExiOnQH3KEmloRACR3wiWiJXWNKjvAbTBE2mBPlWfKVCahPkVBeyYTby1xjmTYiQ3Vv9qvOg4PmG2YPUldZ6l5sVKxk0lSaPlnWCHi7uwntDxTgTp535FtruVPcNR79WvOAl9sK1ohPE1KXFnX+sxFVIT2pWcH79/rG2ocSufTaj/DoXUElOadJktcodBmDS+l3Oo78n8uXfCNIb4EmE+IgbAFmN+2ANJ/5O0SDeAqKjl+E9LqIC2OpsXQtHWQ9jGkxXCoe57VLtEOrJ6Y9j5QSti3pClscWn19kIt05qj3f1ErSNXi/qdV4Nj54Vf0RZgiZNlGqqV1IaGaE1hXWXDitec+T7FTV/cuDsY5EKfEk20zidhRxtBtQP0dVsEFdRJshP5QXYgswpRJ9YxjH5JmRBAz4j4TrU3LPkStFMJtQ0N1hZxyydQX0CHXMhVNbXKuu/qlGLEs0euvrRGfEoJdy52xsOdo2t0V4euOUSedp1qk7FivvMClVfNqlNtChb5xrpO1Zoq553ups7+xduWzzeHleuvLlYVXXWsWdcZqjrVqVwzsqpCSNIPrJXtkgFeRO/hrzl/8KIcXfXt9gn5+jjq03JtZR8+ks8yZuVeIBu8WcC3svIuLYDfhVl5pUJO4fyFokd1hmMSG4USfWPbELaxTZcxMTd5canwdOH78P+5QuBuhaVCBdrJm8Vyrzn/5RmTC3sYRse/5mzwyLpGS9EOWxxwlHhYrW5fqTClMCvRRtJdOwzog13Wkkq5WyOZ61vCY3s/cxZ562D3rXXKpHvhtw52uQXdfadpnXFSM78XYvVkuUs6SNaCWq74ZrYP75th3zqPpvc39qXp43yP8UyimOcML96JDdKFNB+TmPhUvEbWNZs5RXZ6OT6c2mhM74S1HwJ472p00Nc3Z3hxMsvcC+m5EO6H4IK5tRB+/wJhdSfF5zsXaOU8+oNnNTYozUbeBZ4B+0fb19D215wfeNAXvBToQpqLE5ED7CoGdKKPqlYryihk/PpKG/Taa3iWv2sjc4i85oroCg9FexKhmlzaLzZyziUfNPCmx/c7IT+pq4mW8GdPE337F8+8ZdOZM/1Ey6vsmRVOlVzHR9H9vmA7RHIFHMWUPEk5M2Qs0KaKMFlXmQpmlVKyu7+gYJjy6fzD/CSecf7Ny97J6JRWdmiNwXmeGXHWpn324SrJRqtzln9AnoR+CemfEwb1OEEahEMkQagQcvTrhFF6yWZV+aWlynKcr2ipY4danRNaziQrdoW9vlfQFx4mancqr9jJrbhAjnnxtPy5x/G8v9iCVz0fwDz97opo+zD3aKzylyuiT1ah5k+hcr4vP8r2wgrR13q/rsBY9LU+ktdBXnO96GudG83debuvdQburfbqqJ23Hl/r5mWnSHQA0zKpLe/rdgkv5nKPFz2uc0nfU4/r38Heb2wNk4xShecKMaf5XrTeI6OUfTbQqG/ITreIBV/+m0zJQBpSe/t+lBVG3fSZzq3owVlNwlZuRoLUFgrc6wLZ6xJb/Ve3OI7PuDG1mFrOxDmI/mhFvtAcQG53KNDjRx3mGe7KeHlLVuJo/ZfAb3E1VQjPQepkG9KlM351V1hUiB1PfaQF68twGa3NVQfJ5EDybadsm4Q9nCxV2rzNrMk5DmVBXM/xbEYj/Pb4YX/Wum3F/GVo1axnlwU7rGsbDEAFmPALfYy434o2hmVD70BJWuiZBDfyPKzLMn88cMYIyHtXAKUbz+nnL8McMCd8by+MOZ5r7TnPin35BYx7vDcQQJ4ZIC9SH6niGonxir0V6d22An3Xl0D/ih7eL5Cjnz93RfTvLtTcQfFzFJ9RNZBaqG0kIzwsl966jztFEgNy2J2M5xHpFvmSTXU30bOcL4R9QHTOl6TFz+giWnrwQ7TndiStMjYFMfCXRAdP/nJOxzeQOUJSEAMjnUB6kg3juCmInRABK2v0vTBwA8kSpBzaO28krdTbfFIQA7t6YeAHoTblfvkgdcsDeQ/Qs5eN5Ji7nqwM3G+UmmfS+EF4uwHWIaLTL8kXAQ5QawH1D99IPnZfdkw1Gmk79rpVsIqf9Bqpd/XJNG27+0KbQmvIhRSthJtsbCRvuXsw8pek1qermmQcT3N61X0CsHL8yrH33f1vWPlLcsHP6qJs44wjaK5F7juNPXm8SS34T7FlGFuC+PlL8hTUUcqH4NeZ17S5w4z4zqPuH3uh6QfcFzpVxVs6lTctAyZd2NIZejOWTy0Sjg8+nUlbJvcm0JaJaXfSlo3kxZZFGhFtp7vl6dvslQ5G+71DykXTvtfAyvuTA8drU5DG9/iHR7z9LaR1doqYu3itiLsp3oaxFSCduyr6f+93VcTecTBen/tu+X9vJNdc9WSXv8f/eyNpd7GcFdahiMW/JCG+3/p//5L4vL39v2PdEIu7/qv/90byOc29b0ABq6PLh5o7Jur/vffcQv/vML+yWM2qSgatYmkvCt0lI6eOzF8JuKD/UPQgaQBkNJLP4T92rvRkJcTZpuvCqVd26cZTZJpwpHoCP5RKQBrJ866fHal8Iu3z51ytDsmWxNz7heRMji9oX6U8BWmwqsZMnVxn5bPv4i3mgTk7rCgZSPeLyH6pC72Gr/D3o7GFNFbij6OxR2lsRiCGxh5wcVXqXAvsIabT9JUBKRdBxzCTtnqzn7He85bYT3FviTajo5b/vg/ywaZo5UPoLx1oyyuVE3IOoU/wnYfIEx52i3xYbvPFy3KnVDXizvGTtplH56DfIR0fBtR+FCClUYCURuXNX8jx58klf0ltPFCVG16kKpxGkniB/CQkL2aGjbD34JsuAbk4zAuPKOcF+p38rSMZckqGnKbciNE2OxIhpskjjsHwmwipBdeSsk45EiA2GGL51woz/uVA3p8AdZGjZ6Uxnzq05gE3/aKjJS/0i36K3CugV/T3JJKdsdCqEX5q1UtXZ99mVsO7Du8+Rz3gnDeu3I5z6q6I/Yb2chnm6CSGyQnawnQa3rsi8qMe/+i3/KI/IPpFvyvz/keY4cZyw/22gc1M2gzqF32Ibd6yf/eK/tpNr+hbV9zbvH3xamozyuiNoF7Rf2p+dwXlD0+I/KHr+vbFTGrnTZ/o+V6G27rYUrd9xX/2iY4IY4/wxz7Rz5On6n7fJzqpGcQPLIri43hFWpgoo4yI16aMyGBUOqmd1WZYkAPgbnpc69YuvTQ0TWiWQKrWLMzUmtkMp0NM7T47XMfapdouoDUZlp8dPc/KtJeD19ea5dofHBG6q3aFttOh0rXbtWYm+dTMcTy781Nnm3faFXWY1dnhVW6ON2G5Oj7ZJKX2AMfWbK6O4ONz2Q0of+qXi7afL5AX3X0ByfcFBJ9ZOH8Bk7x9Ac62Swsa2xJmNLYNGvP+IrSGHZXLchucTl9kLqIGHb/B2e5LfqpRKGXiNfjVtZA5SQYFRKxaMkDBnIG5cgFoW84vIi67DNfXr+K6WVUpo/JfxL547u4CedYt4wth51fKbHCm+NMArYro9zjZ4xHl3sDr14vYV/Sdu7Yy/J9M8hAh6RHk8CXw3t/9eJIwlc+glswvkGluxaBYinzR+i1ilBcB8WIJgq+JvvGkXw8YXvSQC3srDvdoF2GHhPsr3F3tu5pDd1YHyRG05AtINVWPO6z5S79foSjfvnQd7JtCykMBoeoK+1fJdoXBqjmAljR2bl1+nvw5AKOaeO5xXGVieeP9zJAvHOvWi2vldnwq/Td8ugPyiA78Pj4tgXvjKBadfROfXl56ihx0YdryXvgUc7nq/y0+Rfkj5tGXytnvDPywFPXUYQxZXHEM95rn+jXY6b8mMX5NZlApBGPdtBqxaiHgwa/Js/TcXfRNrLp1eQ9WbV2BvgdHeuet6EGs58lMr9j+JJ/Y/5wPx2eES7TXjvPjFmZtopjV7O7BrDLqw252lSgnCYdR3O5Gj4EivtxsvbRUlN0Xsj24UGZEO8pfE+IV6734z0DDV6P8vTmIB7EuqoBYF0UgkeLBIvfW5SIePE8a6k8+LeJBSxAPZlQlUDR4GFAbyw1rXQ10e4AbJZ+LtCyVfE73J5t+6oUHi2rZRMSDX7kUg0LPRQUx33D0j8yrWiBduB0ZKo2nHV+SI4KOt5KZHl0QD/5wVVxDSF8QD/47FrSSuz0iFjxMWnyIBXVBfo3v4lk3xIL3Q03WuUIAC87Mm2mcRVty2FcP624GoItpNP65j/J/j4gFrW7EgvmA//DeXt9lh9E4BXjSYfKhT7Wx3rk0MIUiJgNN2+JDxHRvEAsajIdJhU/EguMAk3ws6KruMY6lOa32IRZUbrso2EouCjKgQ2wy4sEUHhDhm4AIC78kTbDPZ22jjD9R1Ic5FLlRajrC+BngvOnoextymu/7Lc4b9js4zxh8Op/WOjowmNZaTDPQWk8K4rw4wHmHYf8vT6+x9zX21H2WIAPuHGt8B6hxs2Mcf5r8CthBTftbA/N4oQPHh/1FHKve+G8hYL51m0T8Z35ElLm+s0kcy41rRez3ThAbIv7ri/hPQPzXx9iH9tU1L+A/VyyMUDSNt3sp/nPfxH8CYr1wwH/hQfx3mvgConz2ggNj7wQY7ifYJ2EdEQf21PGPceBh8hktJcaNOLBTQBy4gOLA3vPq93Dg+bL0gvT7Svhwvn8y4kAjj9+gMvlq51/9t+PAk2Sq54vqNF5jHMmjdYq/eX92iHj8MCnyAg7cnJA7U9ACDjxJir3qWqRp4/3xuRh/0ov47Vl/Xxp7nMbW+mNpbAGNPRiIprFHvFxVFL2aTdNfCaBXFxw3nrZwm0vEfNieHsz33/DeusrsnIPkRa9050HyjF/6ljy1mHo7lYabFjz+5Dbz3dBnM/A7wxiUBOrrxufNXzA+b/sCRGqXFiAtLIbxuWqP504Sd6AH950nbZ5F2vcXzX+CGdZq05pH3MRmpsVMomwHtNqDyKxIItuZAjxmnqt1cXztNvNQKC2Bfi+dRTXxDtmbOmOLL3ZqHkN+h1JDVvvi1Q+LgXvrFwFvbOqMKa6D1SFa7lSPR8uPx4gnsMOhhnr2zdvliITfPlBfxJAfOMIgFgsxxJDvOKIhFgmxydfmxW50bDNH5hwjFwKrHSeCmLAH//XGe0zS07n7riL/v4UJ0bcC4sL/FQv+sPQ/YUFuxb3ntUEsWHETC2pWUL5wEwtqb8OCbwMW5AALav8LFkQu/oHnP2HBZft+HwuqVhdmlrQz6obqw8wL7Yz2hfYYCGq1ssQyRagJmxp2X3gBkyTr0rOpZr0ZdeZPE86vq9Ly43kFXevdbna0Or3TLtSlw7orCwf0CjQmdJjowxdmDn7ByEKeFltwUSgEWlpYxiTJO0oVH5sZGNta50D31qpq8zgznsfA8xNYGo64WFqbD0sz8Lk8llYHpSnTL9rRy2/vsvQ1h59Zm7auUsb3tX9RlDJMZ01JToE1zMKc1LlTefTOy+44QP7sY3cESHWggYzyS/IOA4WNoJht3EzR36t16peVyKcZ7ddwz+rMc6UvCSm7VK0EvIZ6RhtLOl5RlLPpmdd2lKStlZdLIK2m5PG1snIpXB0s2b1WWi6Dq5MlHWsl5XK4+qZEkV4j6CoZ58WSELhK3Yqe5JVwlV7GOK+WhMLV8BLG2V2igit9K+N0lYTB1agGxukr2f0qWx4OuTArI9Kvvgpzb2Vk+rD1jFO+Miq9cD16m1enb6C/0eln1j9kqxYyuVfz1xck/TW0InzPUFNB9/NTPiwJeadRUFjqhHjL4pV1QpzlQ/ivtjjgf7hl6PN1gtKy+Pn5q+oEmWWLwOnfL31PiKt8T+i79T0hvuw9YUDJe0JC63vCoIahpYtKW0sTV727qlQYrt8iJOlLhRF6PFWwF+J4UlI/LKJrOIs9YXokQGz+X+mZA6C7GYBHM/rz8fwd/CCeLX+b/we/kd/Ev8Vv5hXlaL1oO33y95/oeb/9vzwjKz/7X5449h/uS8r3/4e7e/7w3jt/cKf8d9NX/07q3/4t7c+/SVl2W3xRr5jp5vXDwasH6O9Mx1+4AIny18HIlAp6/cCYUmGkPjRvlCaRjzcDbgKeLDuvoKd0DpNoVwGVo2fCOvCnLmDehrUV7exZW+H56yrl/BKeM3/qjBfwm8WsqqzuzKfwCwRnxq8WnzqjBVxJWkhFn3D4vr5Gmri+cmjO0PzTZLuX0XGmZF7ZkmxMpnSjmX7ljoJ3JDtrnJ0B9MlR0D03Eb+MSHbshdgB0gZvhbegVy4Jx1TE5cUb+wJX/FzQmU/DHuk7Bz4vgVX9NTzXcU6yC2tT4zyJGlEtEk6ZF2FUwfPbARv87GCgN94KcFWhRjlt8UbIxep4GdqLda0O0pHT8HsJQjcENi8eypn+Od5H2vBGzpv5HZUHyb1+zhQgZQEmsSLnNLnTW57HlMO+xbQVWrc+b4NxA22fWXic9uj6/PU5WrOkHM+tqfUHyQFhbe5B8pGbrXglfy09KRhQoLXrzpIFGhZac5rs9KIX6ReNf6f1zBZKc06SFM9lB35RPBcy7Wt2cwmgTazbJF9lF6PKuTCW/5hX7P6hqK8gLSsVmMpnpqpSYym/VyjmLF/0l7+teWvPHqa2yx+V6TxSItH8YEH9sl8sqwRJWWqJpohNVdhTnpn7ROLLbO3clezIxJVtReuEzWpJauIzH1oynR+UpGTj2znFocVDLZPamcS9wka10oq77wIny26zRFu/t/xg+cWSVsLeWT15n53RDtnZLDDMOmEjtPmobwv8TqiaaYQ0NSKTGl+ATPFNy2kga735NzXHrd1/+ShADnufdAx9Iid3FbQmB7jgXq8MarzbkQUpMprynleq+dVxL8TlNP62V67pdEyAuILGK7wKzU+OsRAPofG13vYiVa1Sc84Rojnr0DwzLSE1O/GJ5wVl2fBcvP+cN/GZ9qINhr93P/NRh6P9mfQcXW7JnACxeFNXf1W9YXKcVaUJhTponknNxrcWOlSpUlvq6tqOmBGRNolGY2Hp3YG5qdlDdjwvhJYVdK9+8gC5x13oYDW/OALkrJ/ZjCOW5r7+M5N6b/fSj4bswHYsdmiKcoI+USpgnqF+NvK1M8G1h3Nvv1+tRN66fxasKfj93ime79wJ17hekXf5nShz2FMfWxOTjzIama2gu+4Jdc4B8rSAeuuRMEcDsM9xz2cTwwGZ3fDjegxpURnRXry4Sz1EIq3KPFYzwCLuRzdC2RmQr/0NmXIZ/JYG67QaypPT59Bb2gBLjwdU1FPE+uF9fFddE5ofakSp6SHyvT+RDzHi1Xm4UhglnFji1/WMFfN8wymeR/jCSc+MTYIdUTLQ6zEXhcslCkDq0o8ku5k3DXwirwecvlPIgj37Al2EXbrlGqDwIYjCTXr+BPnML+PVn0dUpRUNrMUzZGxSv1aW5zSDck6QJL8OnriMtij5ARDXBAbA+kur6m8ckIs1W+93wEg9GgieFFvZJxdzfBV1vmqj4Mmw2hhjmwNlsp0ONb1XQrW5jtuR0vQvisgDKkX9lIUDjTlEFvvPOhCrvxzsE3+X2H+I3blrol2m4XtilB9+GaucBPG59+H3VpR7DQ7KvQblxvKDjOeJynVHntZ0B+DaO6jsa/sC8et1Y9sdGQsXlQrmwp/gv6Xwp8V9c1muzPmkt09Q9lXmXOotFVYXovSrUVhbWCqUFTa2Jc9qbBsKIWVW8lOiTCyfOQE7YVEmhnMrDfZ/D0KdGiGg36BTJ7szF8D1ims9crGC7nezEgXZ3VRfXyOHHUOn0CMbK3Nu9t6SjR0jg9y3y8a+szqpbGxdZfg/JUMVQvJf8Sskyjv2CuGFZc6r3pF8Gs9qmNdxJ3JQYN6U7k6l0rLzZL9wu7TsGPnF1UTLnEulN2XOc1598HSD8z9KyxqI3tUjLZu/VFGOErPtS79fEYK0ulO5hsrL9KK87CBJ8qC8zLT8HLngu11eVoZ+voc0/q68bLTt8PLfysvMkMczvt+Xl2XCva0+3Efm35SXfS2sZTKZk2SogOnzqMysi8rMMKeZPlFmdpHKzM7T87xM0svAr0sESybmV+STa/GkaBov78pnOb6J1HsSeXV+vEay4wTZ5GW1ieZ1Qjz0Q38IA4ALM6NwryzTplRJdoVA2z9wh1I+LYPr+92ciTi2vS1TngR6dHlGnJKBXBmuiXzxOcra4m7K2kw3ZW2ijC0S9rjnyLtusc+e9IijttyDHhiUVSfJIQF9ueJVnYBPPhUQ5W44B2/J3U4HcKe8R+iRu5UJFj30SNo9tjJhtd4mVHBn5pQIZfqsJ1Dvs0cep4N5ck64JY9bZq2Ap2HNME1tyTFsxrnq6QPKDbBS9N8vbxLW6nVWuP7Nt+CIC/H0OzB+Be5LvzmL7e7nQXqJ+TXR0mGN6edTbdjH/OOg/LSqCqGM22ZWQR02CfiF2KLHMnp/I/7aIcr/8Jsw9q1vI66TsptywDKnwif2l8T3/XIZ5PS0YArKAc+RAwduyQEHBuWAA4CqSYGqJXlZbnDrHtjH9xVQDmgJygGP+5JNe38jB4zKOUV1wEPPRVA5zSmSCjHJOR1fTx513S4HVBhPQ52PzhLlf49eE+nFH8v/6sndLlH+d4i0eFD+h++inAbf7ZH/zYIarAug/G9G3gzjTNqCw5468qww3Sg1F9L45/B2PenrQpnbacCxKP/LM+bSe3sBJ+UaeUrPP/SoNtY5l/p4UZJG07Z4UJJ2T1D+N8l4iFR4euR/p8jHsLO923gnzWm1B+V/sm0XhZOwZ2V+R/53ijQFUP438qb87zQpElD+N7yX/O8Qme/53+V/h0g+rXW0b9BN+d8hYvD0lv/FGtnRh8g4D8r/+hh76j4L9WOqYoLyP/HL7yGS7OF4M4wTjs1fr4nj9P9H9heHtrD8t779HoL9/wGyJ9Dz7fcQueLG0ZkiiLK/UyTU/9tvv6dIwNf72y/WDWV+PXX7Y5nfIdz/Q+7xgiLnKPqZMQfIcirz6z2X/r/I/KqcL3hvl/mdIDNct2R+h0ipu0fmd4j8zd1b5gf83y3K/LKpzO8EKXLTb7ZU5neCPEFjr1GZ3wnyGI09QmV+J8h8tyjzO0EedfeW+cH4QwvryIcBUeaH7flfZH49PgleqZQB5Xzb9zw/rgoQwvhCPuymJ+p47gSJ8/fI8s4RqduiRfSA1IoZ5rBpzY/eJs9D7rDGNYrK8yQ7ZwNWLw6I8rz7ofdH+2flvNN5/5oT5Jy3wGlRQj4lpYK8BOneVQ/zeVPbkKfeMYy39UPqp59gQY9LeOZmY/AkKXr9jPE3taXEbjKs62TXLLOFVq3sZNY0od8keO49vbIrMA6tVO/rmh/1pd2iFWs64b4JeXjynNEi5Uaqff9XjySk8ifmbDPr+aPksi+N73IAJdZ/2CENre0K3Cux63NqnFJXbRcTFWedCuu4f4dcLvnqjtrhvLxVlIGeIC/5FHzfjtCoBCvWVyGEIjUv+6wjNExme4jawz9B8gBpbOTCulhpdUdIWEa23BbPP8TfBXfucUl5aUdYCJYhseVAysO+MdmAtBY3Cm8XrnKwu2RdW5k2WA3ljp4vREfJaz7kBmZ9mqO3LBJ92zBMTtaHwAM+2yhi/XXw27KxtyzyQVEWOcEw+0/MCGO5YbYtoZlJm0VlkTr0i8r9J2lk6/LM85cWlVFppMMTSaWRPzb/sDzIl27KIy8tYlKv3JRHqrwM17rIUndp+X+WRyJKetT1x/LIFpJc//vySMa5pp5x7qrHs0EKnuUY53ceGS+D3xYPYMQs2G0q46qUwyR2JokdOrhV6ZaToQaZTcczzsn+pPYQGTvmqiPELft1jCHKhl7S/+lR6yV2vBrjR41R1L1hnJ95h7TLFezoyCplusOO56SdK2U69SdhzVlsaP6l2ROqUOdhk0HZ/Iggy2OcWQdQWoHXlikrnImMC2hq2XLAPs4PPh9XI+fRMkUKz45G+yrydAFyHFdnqRFb8NdgC57xyGEWMc5H/OlZXKalTl0DiJKXJTLOBEDeaEMUuTnj7FOHsgqnlXHK6tHiPuMMrxNoGezQCKivzM5yeJaa4YQ6aOmN4cGW3nWzpQ0+bKmcttTgTW5XyNnR3zuEGsz3m4Ac6pLhYZLkvJgfY+/JJ8QW1KmF94YE34O9Tg2MbalaiyMoy8sS9GppR4P0IdOlakxR19lmoXykq2AT34cf8GyYOSn/rCBj6gT91umCtHI1f6FNtXg/YYQl7Lz4we5XrlcL8Q1lpl0dUun8yY3WXR1hqneF+K2fdkhV82bLOtjwxR2Xnj3ZJtvNjppX2Cww+uj8AUtqBZV+pjCmVdrtnBGbOch6XpBx7KiT8L8eVly47VSbSirr+EI2nTeZH4aR6OZZ3MMVmKbQ3/Xq+xkO64ljEgGtW+WW8ftqcTQ+dUt1yfY+OUyHQm0olhaz46WpHJWdSMJi+j3Mqo1nZm9ecvi6NDatBPUrH2bDelIyfnU8zCohdm7JVbiS06trMKvlsjYHYvefHfoVcUqcJ84UseScZsY5xY17VCy7CMo22DW0bGkx9PLz6sSV0KeTitm7pCkjRN/J0QOSB+Y+zJ6YvWlJotPJTmqXR79cvWnuV9W41rBGscG7B6+H4d2Rv0BdInOPzj68ROt0SrPo8wfn/gypoTT18PUwTB15ndaRrkL6Xy779mZ9e/qpyyXjL9N+0kBdR9oH3tZP6WI/RccPfpjtC60f+JjUqZJK0qQ2VVp/W0ctq02ziH0WSe9CybGdDrEHMRaixVqFBGPSDPTQ/ROtySVat9Ze9UGrR4xzJ9WIGmHH9X7WJdUV2KXDC6EWCme8JK4vkzgU6ifv6cvkVdBDmcXsOKluHKWWof006ZLEKw5VIpUkP+GA0hNyGmbLHyu48etTaZlhWdJ5t/r1YbYP3JM+trla69wKPcbGbq7GcY7qSe3m5kOq9jqkqWiatpuZ8bDs4XBIzbhMW/BtsF+xj5uAZvS0B7+NOFOxTf34TfwFgSvJbJam3AOzYxy0cHbt8lpWsyvzq2oprP4Ij4YX9TfH+5F+Ci9g6w0uXO14dcyDX0foGWB/Fq824js4xxidw34XTW+gcopW+0gae5DuIM8CFWHc8mtYBn6hgf7cj7U85Zj6vkyJ9CYKLVg5nbCr31qL5SRCf0fboWdfEOl8SE6hMIYbb2I6vmDOVRvMo0wv0J4T6rDNbgeuN6FGbCPjhLXK59B8fIJUp7AjpsLa2Hy33kBbF/jNKJzfAM99LITwttpfkMZQ2hN+n6Jjct8xfNSpqMbXL0cxaEEe+a3MxmnuAsp6nGT4EC+shmfH0X5irLjuKTbKy2SlHYxqhsCUNAtJ+lcqN1fLy61khKtZUJtahLjMZiG88ONqPNetLG+B3XBoudw5SF7QLusfunm7IfSrye3y5OGZN7IY7ii8EUapSv+8vOw/vXy3YYhN+Va/zH7OQVHxtj7QK6PV7MhM+B+L15UF7Y3h6MVKZZO/JXkNkHwM4PgYUzZaLso0N0/p1+38k9wWkiftaJQ+ZGZHPWRiR4d2qUMPBXkMzpkFDzCcGoJMZ6np1xxpzGKb4s/M3l4VnjdD4LhRtU1t8jg2eZtBdjYL4pDGWOrkbvbGqCx2JFr6Io54/tdgfoWQD3KCp6zIRyzWEJ26JqY5LJdhw+IfKn6sakBxaP509t3ZhirV7FFVD1PtR+TUaLMLfz295rG4J/8uMK5WljewSEv9B6E0I4pR120NZzi57i0rmxc/B3WKMM5qX8iUG89VM9zKOWEG4GR6hc5lp77d6X3k+/3zBj3zYuWdH8fR73fHSY6XSboozCxJ5uezMwSl5QHqK7I4oDcMtip2SztWSdkxWULcc+xoeXpnr/lp5gsF2YjU2nOUT1ErRSunLUGfr9Pmol8gLA/bINQMMcYVySbFOVmZAd9/SZxvrDa6iJv6QibPhmXFWnb3T+TfMs827yfzXLsfHGhMMGm7S+ZuMIzJVlphX2OYY+qX+7bpvClh3ttzz8+dM//t+efnJyyA2AKl9aEF7eZqwF7s+LfmDV/StiT7xuB5LfNYzUNzgbJqDpBwt57fT/q5A9Uv3VxBUbAeGOt7D4h1ZBg2EzGSUBPJo1a2xz/UGPvMtKK4ov5ZiVlsOyPVt7PsJPvFaiErIbOh+ufahIFosy/6EWWmepb6mZCsjHaG6fdElG1A3jL2wf4PPYjywzPzTpj75SIiZCeUz2O1M+YipthuiLPKkpikZaz49rSiqJyorAcsYcaZ/V/JirdeMk9/MN76scd5vdJzwxkveqzuCujjreXzbPPOOdTceUdP3zIxxRTbibYqTrWx2rxBcv4VXpbGXHu9BM8eviT920svMbkw+5lYSdIZQbaVHYp+IpE2VPsVQKmK7Xh9nF4/bc804rjszkxsl7LRlhghTB2WJRHC9HflScsL2uUDAYVL1MUBEheAkXxZnAnSzejJQmor5GthvyrdrDduzt4shKo3C0o92xUY/zBb0P5Q+Fezw7sU4SonGzldSNcXtJ+OhD4KC3NHeoDWt4dJle5IIatdKQ0fubnaAE8wWoOQqF/NxD42elxY4spMfIqVvpQ5OKt/HrvJWt1vXpYwBrDSF3LJ5sdNZ8wyt6o7IavJ9Cf3y9cpcmoNp61mh2KrJUn7+FIHkzSUL3Cale/yf3MwwytaeixpoPUMIbjuevoW6QH2a1Ul8uo4nkn8RCOF9VLpZoaHW6EPwwoAw8iHhTSz2t2Zsc6MKLk91hkeJaNWWGe24hPT82Y/wqRPs6cNPld9Ucg+eFGYuJItZxIBZ4cqq5QpPK6HF8X1wCTnFITt2cHPFNTp8z6OfWymwCVgi2cKCQmwQubZzDOFuAQO5uFMIT6czbKbHmOnCyFbJ12LjonNjLax2uNCnP49oGwPCrKo+KpaMtx9DOhx/uQb9hbAeVnOldLj8MuOkQ+TdSXJjttvVL+I5XIjaR9wmbsdmW72+rkQ/uuCdnZQZEe4JBTiXLuUiS2eWaz/KEkj8Uif/BPLTpwthFgMwnvPfciEukPc04VPnpvSrlJ9yBiET/YoaEolpoQY4FcyFNAvpOwIpux4brqw57kwSBPje577SxU7TGJj32JTQ5ulHYelCdl6oDulsjlCJJctbE1nR5p70RMcI6EmBM/a+WR8c+04tCvnYwfFXWCH1Gf+Wp3KH6N29BIDeOcvPrTfqMgbMEfTrlAMmjmgqE/WHRaRBvShNADzFfFPgKT4RCtvD/uW1rI6iU02jtWpmkNyQnJF3CN5FrHgN4WIXxB/uHvRatynBIgSciijUou7fD05hEMOyttysM0uqR5HLThyfO88AqT+wApnPCPaC1KINreWK6uOk0vAx8+SV4Iy25LrPfLaK5BynDRRTdBxNSyv5k8uk0HfvW3QWRN4umuks0vDhy7fT973dlavojRwXJ2yZpy+njDUDgqpQdtvqJvZQnYKQ/O0pqG5LPeq0xdgtI1t/TIa2/pnbF04ubtkDJvIuqXXUg3x1h+WSWGnnmBlR/2wkEu7br+0LDxNcZYpRw26cK2UO0jecLUu65e30VBhZTpKGORCx8lqH7doRxX662aHxvMhNC+VTbOc7VipYEeWz9IsH5VdaCmz2CzqJ9gMLq3Tjl9N0IbJCGjzjpRoJbb9LgiTIWzctKk/8rRkY2wRk5ZtZxOjLVpjUm60KSn/olBWwnY1TJtmKuhmWYOgnKg1wf+E2Hkz5pXP05q1TlaqNam44yTVqzVn3Yxpb4sleOvJSZpSkqU1oUZQQbf7aSYZd06bQ8Ka6kmd9/mBcztCpFsMSmuF4dpX2E6mVdzz7gEaEs6xmec+XSZVwi9w6Ewn9PWmSsB+iTkaxY7BMHovCZeWvdPZtzh+V3javLa4xTpruDaeV+xktC8Y4mzSjhfkQ5ZLOrLC/6//nx/ZI4wr/FZgC3t8+rEZaNPi+yts8WXHAtQu6zKz0t3SHCtZ5e9P+y0jY8b48ymwR6p5qXIwL0PUmajWSICS5QmAlBb/BGWnFKMNiS2GPliahFv+Yvzzc2Sp4fZvBJYL2nGBPROWdKpTAmW2OZgUjz3zRqiplhwW1gnRTP+cWlIvoLbsOiGW6Quxz4KxGCYOYpXBWBwTDbGdwVgfJgpi7wpzl4vxvkxK1WN8GNQ+wR8CtV/CK+H6pM+0iDgyMs6M5xiW6QOhH4QCCEYItplxSltNbL7W/FZIjlVrjjZmW7VOCYyfOi/eFEtHLtZUT9o8OHpaszhqP3jEUWPSlNaM1OtnYL9ikbTK8uLNJdW2OhwnHK/REPIhjKuJgJ4rWfaqs5Cetj4SEH0KyHmpfZtZhv6rvVvh7lS4i/bnEq6L+lcyvp7s9TDJWPKlZbsNEWflHauU2uUcHyso1QFyJqBdnpXNjjkssMxVxyh+ArUhcdUvXsEMmhQgWmvgymC61r8JhORJ0FrEk4xW1jWOkVagxBrWsA+t0iJdeKYGzzcfsg5rK8kZCz2yoTIE6Nr1WgvM5H95UDZZcCMB8gzxJ5vurtUb9blSroEcCrDcAXKHr+drhb7qlm2HFOMVBzti8gVdrsV8DO3T6u6FVZacc5IsQXvRqogWLbVu0EDeCXxOHvAmGqXmgTT+ZuCM46LwXCWEMgglo5LZjybCTqKQP0kqqHZSP2M9cGS5ttJz/cYHhjAb0C2peteAbNec6cKE9Nn8EVLlYUd3OXLgao8nE1bKLDd79zk7w30INHMHrK2mIE349boou0UaMb0uhsq5p4XFKOXdoi1btKUs2qK97JMPkp3Dvh2XeZYk120zS2D0/uq5NW49+vVnSZMXqWr4jd769cfJoKDdwHE1TKKMj4ae+NEtHxTVEkktJTSQgdAPZzwR1Fc8xmNp7y73avgp19hJJ4nejTzmJPnaFV4lM/4IHOAXx7wt0cq0YaJ8Pr4b9Q9luD/MkSSeJDU0d/F7QAO54v+cvOfp+R7QQH70Y+73Qk2PkdRAIm9IwLxLAM3h73ZXP0DzduBrzHC2RW48D3sVB/Rd7/Iiu7F96cb0XGzzLl8aUH+k+sOA6o/IaBTO63V52+fr8i5B0C7Q5c2HsB3CJQjahRCHsB3CJQjaRRCHsB3CJQjaxXAN4RIE1FoaCv9L6f/V+iFUzoz/y/TJeWjlBP9v1CfloaUT/L9Vr81DSTX+36HX5KFGKf6v1OMI9LQBx2cptGEThN0QPoNwEEIThIsQ2iBE/xqtTISgh2CAMAvCIggrIDwP4b67opVr4LccQr9/xSpHvx6j3AzX70HYC6EWwlEILRB+hnAdggBh+F1AHQfsu+pQXexUFStruKtDVZ86Nd6LnSHFL10tUaHtK/SM7b3agDY7VEq0c7Jx6d2TV4yfoq+xCY2FZcJJJiL/E8+v3Uyq0spqPvFcuxZfJdGF22AX2WpTKk1Ks3qAQRkLuwDZGXX2dKXLUaa87tDXMQn3RUIO+pAcWD9OPBnBJlZ6upxZypiuwCjJmfjsh+FZyxR8bhyUdV4vSUMuL7fH5MbkvOrc4oGxZZog/UStaFV5Y0Aa/lBCpeeaM8wYawrLY8exmnhTlhCfHmpU5cRSrhhrwpWzjzB1uF6ifwljLv2A/rmZzHQIHIQotZKRGmU5sZTDxpr2kfYDNJ2RMU/VMF2tcpz/kUAZD7llmiKYaSNH4XwbrS0VTupLhWa9Io8ph7m3iK1Ae+D4dfQZt4Tq2C+rkyk//pX5E8rp+/J38Hc024R9zOyqJuGAfqNBZsV8RmTYgW6gDZ19en3R7KoUXs9/7Cz0sjykMOPo7vZzoNOI4AbAbhvl54LDJjRwsUVcWqhte1coK0uRn93eNVfSP1V+Np63TGFHNcD9Kw5uAqE2uZkk1RDkAz8GRE0sZfPXQoNe4ZHJ2Iwv4Eo/8RcHYkRRdo1PfhkYrlPY8SnxCXb0dQeiMJTJkCyb0KSX8a9U4fkDJvllaD9b0SQ0cWm8rKuVqScuV6PQVChapYaa6mOrbNDitNqgPb6sAOGtNuGo6aKAVkPDQ9mh2MrXA7qPm2iJjfB/a9dEaXxaH6qRNjbu7ri4zeJfHPxFZK1NWwK/zzPUR3WgUTjKMLrz9sVAY/aTf1HrXs16vBcTqIArJo1x7i+BXlffqkG0Fe9bAgqdpLlRsDF1DgWMgU1f62iC/0xajY2dcINey9M+akY9N2opFzjKCRvWMl+HeBJrGmMLOW/Qxdh4Xb1dLPlNx306qW2G7lO7RAvYis6UdQ74b1kD/5stL9G8Gv34f0RATmfzJOoLmlpj8o/Og7lULuGRb2J/TnPNpm/0h/HjpBfT1kCNG5kFNC0qMFMn51c2mz7n+Cbo0wBJCIyEnM46MrOh9ia1MGkix4d6FHfC+PvTdIouVi61DdPpbFqd0o4tmTEMW7LRWpPQSG3xBchPQI+VtZgb+ncc+ZFo53sUL4XxbaKWQARfCq+gtU3xh9LajuI/dNwaPXbYausYvtnRCOPeKHyiF37GtWAC2vZgN55lOF8v1BimppmR33fUFnSXWI6RUwHRfqnal26aWDvBOJFyjBMe5BhDXGg94bf2uEZTbj/nwtPmjFzkKFaPuhZlWS979TT+mQdtz6uod6JjZLmb0Tntw81sctGdifz9gizsGPnAo4Tdz08Odox6WLc9uWjEsDS7Bt49QgZQG8tafjA9OdFAXvLsd0ggpyPE7NPB/Rd8+L0mmsfrP/lMCXbyswt7Lc74riONT+RZTbVzM+xHMmaxiWjHaxnleZUeiU52dip+sYI6XXeojK8Af6sEbGC6IfKHl27c+r67TxOtVO2KVW6BtE9vRNM921miQdtgn8fk7COvu1lNIo8IdbCgzos2FjhLJum5cFOCaY7pbcCSUkrRwgFXzjGx2lhTxbwZcytMYaa0ZwdW7TSH5PyLzA7gqkZalzlOkikL0sR4CEO7RUwYxbPPlvB9+ATEA/ySj1eaB8J7EwM1hhT7RiFcn1alQe+W6r6QOjIQlR7fPLH2aNuI7NVCc+ZR4RPYQ0S3boQ1MbCqGebB24YbNkxVwp4vk5/7eIBM9XXSL3+4/6g2fGfT8qn8XXwmRZNnSfy+kVAPA4Sn0BcN9S4j5xU20ZNMtA12n7KwVpvwtBQ17qVmJgnnxRfC01lfCEVZeMLHUof93u3+Wng6gy2bURvHHSMb/WivLZWPz93j3BmAp+fDXSlXC+9Igb7KfnDA+O3a64xBaXcVnl2T8DvNkdDCBj8+ecuWG7wL9LEoA3fnRxx4T2qW//roEwOXbJxidcj4OsfcBpnyqS2IWcKTZB42iYGWV3TyxQR47SewT8EzH1EXDncyxWXC3szsqjJhD6OrZVOkzdJUmTXEOMCEktZAr6dnW51XpxSjfhTDNPwdxyjDKONX8xm5ODdGIR5KlmvRW2GpMFGPJ/oKuo/+X6kwuvD9+Y1t6kXvL8Cvz8cAbY3nU4DLNE8DzjpN9qsT1uAmF6KXoyPx/8mRiF5s9H/TyAbIp1SwvNAoPD2jUSiC8NyMUqEEfkufAnw0Q/ZrKbz/jCuTniA8Cvk/5SqB6/eEtfDcqzNk19brj5Elrsa24Ysa2/SLInJlXXOksq63JVmCbGC5wQO0c/tC0ZL0XiFaWQ2hEcJWXZxyD4R9EBp1KPvENgsFNqFIaxOem39RWFvJJGnaFaHP80PaJYrS+UzXPjmLUhwhvj00KsL2lhDOpcIsbYFZ2g/G8Dvf14KarQfepTPFtyuiIm97Yjb/L3LKpzPjfTzJmmqaBfVjUlTnWoRxnKpDokbuelRdItgsxyGFHS1LP4oaKOsZq/IrwFhf4ZlIxdQwnuHmDPix+l2D7GwstVqlm3MDcNBDLlzHEXy0wBa8m/BVNWD8QHL2ZQt3R0P1OKrrzKTiNw/FuTLBklFuuOOcrZpxbvSL33x+CITnyXn0YhJvBiQvrDLI+FDbfnLNh/6A8fw++gPGs4zi6U2cly7HjnCGGxfsU2fNtkrJ3jge93hqoGc6WB3/EH6sZrSZ15Y+kXnt/czMax/kt1RXGCLPjhViuTUG6dlkIVbNZnQ7njestcI1B6HhhiMpf2gRt1vaMUXCJI4SiiZmdTdkaeA3omsAs0gD4y/4tW8IFi2eJpRo8SzhDAZPFTLas9VrDMqz3E62I4sdA/vvRGFhOJtx3TGeV+zUU18bmiJ4M4Md9VV1uUEJOEljUVq1FgY4Xej5/eRZ2lq5UU79qzaQWiGRyg5aH7jVTktNXN7WStgFa5ZAX50g1T5Gl3ChQnhVGxv/97R+5yuEdRlM4iMJndXa7D7Okqg7BNb0grB+PtvFsuHWNOC9qw2/2CXZpfAczF8tB5RkR/Ds/6rKDYJkK1sWDnQRZckptovCj5Vj8y4KrWXMUHbUo/w+XvLaZoFRa4pkKY/SL7fSgdphPKPJ/qrInyqxp1pYzSiLpghbGK2YbdVY3i3KsZYKTAk7lh2/f/K7lovnGe6eVnx+furdzY9ZCpwSyU8OjGemjmneZXkZni1wSiXnHJsEBvKdlKCDe4csjxUdq95ggLvqL89IIPcLbSwrLQ+QGr90c4FTJom3HIJc7EUDitYYou2rhMWctghPPMYrcqCftZbtReyE7RbU4Wc5Udr8IpS00/ED9O0lCN+LcuYpeL6oTCjJWA19LHUG5Gmfo5Z1A1CCXTn1xOgDevLE1gU74Drbp9YAlWFT+IgOCXOULA7Idm6H9HE+oDvsNrja4uMWbIXfTT5Wa1oAVCWjSXhO2wR0Fb1oUD8BfowBzcmg1ibhfun8Jvj92AC0JmSQraC7+M81nhu/ssPg7vycswuG7bAuSO6xH7UGVv0lj6xrn3I2cH08w5jCo938fZNv2PF5uWbb4+P4E+Q64IX0lvfN+4nRC2jM/Fd474hHtpNbWk+W+dCS68dVQDsliUufhto+5KsQ9nAVwmg9zFHbUzlBesYCPQvbBPQMKC6n7Dlv9ZIk+TPgcyrFoiyoB9oTV37wq2sRol+RvkSck3UoY8sFu/5ciPzrUI983tdCOFCpoT5lF6usM3TYKwTLfCxtDNDXOSFM2gOAQ5HvzQC+Nwqw0V38xilbF5bwdeSEG3q8LY5lEsUe/6e/iXKmc8CzZLv2CvG4j4o2QBsavMquftLsXFnHC1IDH5Uac/adTsOaixiE+A338Ezy5MmM8+WS7ct2G5TNgKzL2DGyO7sdSLPZUT873uhkVDXOSX5W5zxbIXwEuPkK1BOt6F62f9OJlpTNxR9eXV38Ilx/7/hgYR35qxtrhpbwTEvR5jva0b1eJds1dykH9an0XugMeeydTm3xRQgXhPgStKQs61gtPdzZj+5JP3euEbLw7COLuu0MZyX7/ReFpWX7+JCOF1WHJqvsCmiR2ogtihqe1oy+q9g7XY59V1io6RUfq7vSnCPI3m4D/rk2JU6ZPyZOuXRSHPU3GD47TrkQaMc/tkRTPsMwH2UxDQezmZKR2UxDRXZ5kLbgtWKYbOef7U2dA4p7rDw3QQ33why5FR8I8Zhe8f4Qj+sVj4d4317xBIjH34zvBYo5IS+kPJXibC210Vrhk12LMsh+FU8U1/rMH1cI0aOVaSnQ6zFJIanJzXqt1COZ9IkrTnZQ8LISjzRDm10hxCZtF35OlGpXCvGj8JRZx8hPhMsjS4X2aWzGe3BVR6pcsGKfPAT9OjinSWiOrifVsGIKJduWov+LPZ5nf5YNg12+dovhUxu5wva0OjUR+AHSbmzdH/dE/G9aPuC2nsFeQBz8gewDGY4HjgvKlJCTM11HFWgfeBZdudJz9eQNz2RB9lyN4Vf8UjwG1+Y6T/ICnE0vexYu2GaWwqq94sJdV0mGUFe5hfLbPKkJqZWMfxh2GPaAKhk99R0jpUIFpIZVsXffsKP+CscPMDWTER7RLwfij/MP9PjhOB9AJPkXV488rU++1hxbxSSjLK6ge73pGFnqQpmlOq+/OUAyPMmm93udqGZ0bTYprzKqctGqv8nH9bIIrDWdx329/Cz0AZa3D8IdRJxr6hp5/u1nrREPis/11sWrdk73/p4uXjV6gOyli7eD6uJlJa6vHJIzJP8EuSD06OIlGZNo3WJ8t3Txqp1DvaiLNzj3liZeLUly9WjiSW9q4lnJDa/OfJwcDFx0xOZKdtSSaHjqSlAPr9qp9KIenpRT5qFtUiu56OXMDqqH93aAq1JRPTwraYI8DjoOQNt2BPXwsA/KbFLmXuiPeeSWLt5xspa2xVLTN58FvgVrA/bmQ3hR9hg3NS4f27LHi7o/HH+UrA+4qGUaSx1+a8usDZsakZ9WxKR12/Hc8BtewYF1wHde8yIfbIe+qsEzFsE1/wlc49lL7PfBQjSVW4+tUecnmx9PQM9R906KhB1Zoy/CGJnDaGMtbHlE0DtofhabaCXZVOdR3qI0Kmgpf/KidRt93R5ow2oi5o/ljDwpo7pVEXmWGlYTcV/E1Mj8AZaMoqwqHbQiPaDhwyjVu9fb7QgQpz9AigIhPTpXMC8wH6w3nht9NjiH9vTSv8J3E72of4VXCV7UvxKtdltJnwOMFZ//J7zXAuEqEc8So/7VqsqNBlEHK2HDUetUM/CHbWhFCyW/zJCIrvAwye5TAlOJVrA5/p/O73xZCX1sC3ShtuW6ruBp6qNkj/sooBWHQ/oPPJ2b4kVJRSFczfdecCTlDTRra7V5A8zsqHhrvAl9Rh8lX3vQ4jxHdbMGGzk6Sw56QloHwdOxVZFVGVS3qyzAJrGtaBOmxydYP/r2px7U11JTfa0440UH2tbqdMTQezs84jmo0LwoY/+iqJv6WpEwQlay3nPWgWONfYf7cezTO1xif+L6xP35GJeot1XojqV6W/kQj4dwQMRIWUhxagAfDaxyJj4As6PGe4D4/Pff1HCUn2n4VcExv75qOkru9S+CPoroQn79jTvzhv8pJjFKE9ElZfYKjN5YYLzvKDnuBgwQu06QqhltC6A81dmWR7Y8EtEhZSTOKImhXR4jeYLN6HIAkn8K6S+jKeh+Yz5QB36vEKkHugcrUnuOGQo8JBdyyvBV7zbce3YBlDtwx1Gy2Z15za/dK5j1qbxcO2Anx68THtOvEx4vDJBP4E3FubAhwHmK2HvwzICMGUPle9RnndsY9AFncZdVIUdSpHUiRxq929Bmp61gZddiM6ud77vYsYyuwYbausWWo7BevnX4NesEM4eyFSiPe5hZAM8/Dq0+rV4nLNEfJQXusGT2bpWNznFqmXaZCz1dHyXv+645OL6ZbBL2OXANrVigZB6B8ZmF+H9Kj92ogUH9uQG5sfwAYzN5zNcf9sj9f2M36pb2XKmw5KYGXXQuy61z2gV1UINunfOEINWi/hygO/0tfbmjxOu6pS+32xOt3OxB/R3RhtSncG31/J4NqWbyoE/GZ1I9uXXOEJeoI/cFWevvrSN3871kePORVGiLDMYmUt9MxvskfEktyzOvo7cG7IuRvsxatD+8LU1Gvct8EcB8tM9mVG3TQjq3jeY/x48jiOeeFntwryTapuqtdwf5F65z6l1Sap1Kuhtl7s1E4lMMim5BXbuRkMtd/iZa793U3ts6Z7Lr9yxT6f5N1+4AKfahrp3GiNp2aB+4ojO6+MwctPSBunaoewfvqtd1KorzMqHW6jNzTnWGFG8yiFarwuyfXD2yBmUhigufXHWsCerNJDPJ36/A0UMtvfCcOjItIGrpNROV+3YtvXXOLwVmCH6XQz09tO3xkPt226sZv6ur10y2u/5IV6+ZHKd2rMJv6uohxjhKplOLrFPpOctrQU29ZvJ3l6ip10o19S44LDVM8upKNkmBmnqFmbSkDJ6piDEquvJZtJTeHsDZJoGV+i8B9tSZsJeGMCAzLD/R/FstvTpyxq+EHStq6dWRF/yopcdYT52RKS8/0FtPz0a6rLfbb/2tnh7awvqWnPZjr611/oPan1rrfCuAs2GnRzzfgfP8dvutR8kP3tt18s4B7jrhz6naZu4DMwfPuPdo3z1vvbQcde9GpYVeGDUh0oinAoClQ4ufCPRYVZ1Hraoq4c2AV9SZGwXzUnpT7+6yA/XlsH2iDdXGm7py65wWlzhLl7pQV+4L8p23R1eumQyp/SNdOSt5VUBdudXcUfTmy3NV+qCuXNPv6sodJ+O8t3TljpMKj6grt58c9f2ertyPD4i6cluDtOKPdeX2kw99oq4coAgBdeXwXdRvwnd7dOVyoAbEoxikbuHzeOMU2oJhQi35yTvZKDVn0XgyvL2flPhQP+04SfGhrtw9VM5uJf2Ey46Jxrsof40WVBv3O79x3UW1zkbTtBCBWhcN6sqNNtYTf0DUlcOztnd4dFV6YwrkVE+uBVBX7uTWi8LGkovC0bLbdOXeQF254+QeL+rKJQV15TAHmC861pbYS1eunpwKYD1ecxn5Hu23enI40Fv7LcbIjq4ntYFR6Sftscae2nxDPaGpjZ86pFwU9Fs92QFzcqUD+/mER+zz/6b39ludN9SDE3XejpMszy2dt3pSHKglo7w937jryZMB7OVTXlHn7ThZ7/6tzttxssrdW+cN64U6bz31+mOdt3qSRXP/h1cBM/kZD2LXNVTnrfec+EOdt3z0X9B/SI/OWwqfCUgt1HW7ztsRctb3r+oMXkPRYj1RBVDnLZH2viwg6rzNojpvR4gioKZeSkxU5+0I8ftRf20L1Xk7QgiN/ZPqvB0BrHpL5+0IafOjzpvZfIT86O+t81ZPvvJjC4d5RZ03bI/F+7/ZuXqlMiPnAIkJsDvriNzFviVNfUDUSVDlRW8zD4Mea0X/knq0a6rX4h66mUTASGTaRgZjCoh1wr7yuRnzF2jyti+Ih9W/0t2jJfctsfgXLmKGnbdpzQOD2nFy3rR4K9WcUntTeQlwm2/JBn+PnlwsUN+fPaKeXDSUv9Ut6ngx3AFHTw1OAif42K7Km79AlfeFAzWDgf+7dwGNEEKgbR7EEBZDb50w1MFnGNOk2+1R5Ys6YMPH5E1nUozlhjxb32YmLYfqgA20JVP9rx5tLjzlOzLth+V3nb206CFae6s3pPUOeKu9+dLyUZofFjFp129qerX9z5pe35Il/j/W9PqW6D+/penFWHvreo2rkSxDT4nTEmS8xBaX+y1Q0O2PsxnhNuyxMfqMZPTUcJTsBuwUbd/6eD353KdZdotD/dWzdVkdKfTgdQHdv+PbP9qvQDnpvt786TjlT68F9/EWepawLx+dG2P8ljzvjQZsiN9KqD+A5O3zG9viMkbyUIPCxra+s5IXxWlkXROZI0TlLxUKCpOfiqEIcAGkeLz4Df1nn2gLG8scW/MC1EHO4/5wbHRUzmfkEz+TFEm/lxd05zz1vYZNDMupJ3f6thp2zFe1hFKvHfVkmq+WhLpF39p64H94xt4Ga2DbeZny3mGi7Y074Tdw5dBrQk2BkwmX84NgH/bsgLcMV5alLY+5wI6OTl9tXcBvN1xZyPEye3R6nHV+AqNNW6TL7iewE9BznMOx3VBhPdzFSg93xUq12fI0yInRXZDwKf03CAss/hFauyw1/ewGYSGzQVjEbRAWWzYI5oYNwhL1C/ETsudnv2IYaC+pknSEcLXOvf4Iame91hkT2O9UuqMBGzFJelP6IpYT6lDOzU5kulgmxxqd9ILhlJ3hrjsYTbfj2bh/Tvm+uPReZ9BfRXmlNHGi/jjZIMgHyVrGG8fTHjnqRY9a33q4WtHvTT3MV1b7TueYNWMK2NfRc0iFMMbEDJ9pR7s5qCcQAauq2yZtGZ5zhGwI/OJALHoupOPrGODh8h1HSJI3RiPfqQNa/L4rZjejyRJyhsl3il/gZwUY3Tc2Dp5UwZNRsGvTCBc6mWKUvq4TDPruqzn0S9ypNhX7Tme/4r7nu69OoSk59NucVKvatW1ZTM6pzkjAs+EQItZEvbkXEG8dCXHvdOB5mysOHT0DFRu0TSF4xTGN8Il25y7UyKgPrn9O2XYPrnuUeQTIUusVoPM47pS+61ZVruRX89Lz9xvvh14paIVdBaX3MwtmTp2eL1L68UDpJ/E5/F5nnP+3lP5HN1J6Y5DS9/H2WLauh1YDpX9ncu5sYWghfuOO9iJ+vdc+aWqaOY3aSMenvJ5RrezYgskFziImtuUI6QCUq69C35qzBS2HaKnAn27SmU21Y4zDKXe85IluPYIe4NFuhW2k8YpDakYclfkbP1tskrxVBy1+hGorOe3Bff0LyblYm+Me1B8aNFV3E1mlmzodg40fOwbT+/vhvq32DmM08JNdnnA6MyMpduH4/oBdtnri81S5jEZM6Qspb3r6GuVASSocfYyz6bdVpuFXXdO9JT5xXJDHID/q0b/GcdgH+OAY3K/3ibwJ+S/ypSsQV/lxHHMzB8HvKAi8H2l1RaUc6NMkF3oONxgNtA8fAmoVB1hdmigHynKMxAXuBkyGpyvqSb6HGa6AVTCOPjnZwyZddigBL1U5H3bXCZxe231khtYZIt0L13XCEL3W+QxcD4FrTdCriAauk/ToqRq9iih37IXYZ4AipIPkLclGDc23v+crBz6h3PEZuRPusC2cscuh3IX2daqcaW5MSTBeduhhxtp9adQKt45qhusWJvJm6O+/uj8nZf7X6foYoI81xuXhXkSqRdyGMm1510zJAu0SPgr44aPCjoWMrtS+0xye00j6BSocG4Jz/134/dh7u88RpNu4h8b10MP/DpC+dQdIXJ2yJiI3Imev83sPkxgOv12e8Fz87fQwmjB6VeRlgMLudf7oUeWG5dRdVmbudX73+dXr0crCYeI4WgIipqiD358C4jhuWCHKdUQ9euUrq2DUwsxseTifZ2ZWo1dVe5tkv71TtmZDp3yNvVO1f0NnGMTDd23ojNhl74z8f5S9C1xU1RY/fs68GRAGREVEGx7iCGqD+KDUwkGPMFg+M81uoWAiWqKW2mSFiqmoXRQ1BblqliH2gHziI0zN7OG9M2plKmkvJ9KZZkw6h9fM/7v2DD663t/v95/PZ+3zPWuts2e/H+fsvVfpWkdIqa1etclWr5nvFd/zRnfNXcGsJ7o1fAXQv4CC+N+ANgPpeMNKr7gRKJzPBVoLFMFXABUBRfG/AS0D0vOGIq9YABTH5wK9AmTgK4roHaDC3Yv/DWiel05MNKxi5ym7+/G5QDOAUvgKoBygwfxvQM96+bLo3M2munpZ32dsU4Am23bkTh4+0fZzbunwJ2znHQrLVkeCZaHTbnGB2s6nSL983qEEd/o93CGXd8zIHP6w7ecZacMH2mLzDpv62bLz9piS4I8WWjOZVgLuAnGXye5icReEuzx2F4W7drgzs7sOuAvG3Qx2F4y7ENxlsLtwdkJG+3y0Bzc07CwDPla0Hx34Rv+2cw/2VAV+oBbCY1YIBoFW7PRp5B9NRYsXg9bc0Mg9mPrnRwXvZ1yQFOi1322knUR0qtku8y60FiWNuzJLflNzuve5WPmDhUARJZ1LIku62AYK46V43QVJg6eKGmVCfg0vXJCCcDdUUjuLtRG7ad25/PobclrNwffgB8j7/GobgbHtbg+NOpNvn72Qrv9cnMCsRHCuuiXljsjIOkdnbbkjQsu51N4ijGGrGtFbcCuAdgOZuOVAO4GGccuAtgMJXCHQFqB0bgnQW0BmbjHQOqCR3OtAa4Ae514DWgE0mlsEtBRoLPcK0GtA47mXgV4GmsAtpPPBgCZy84FmAz3FvQSUB/Q0Nw9oWuNRKVX/gfQMR+vJS03tbLPNT7NWXZK4XquttEaL2uLldi6uzH5UMulLTQ7rUWkYrvW4Crj+ims6rj/iasa1DteRuH6P6+O4foPraFxtuI7F9Qyu4/W+//sceAJ4J3CdiGstrk/hehjXp3E9YN1k2meNqIzZpavwinpPevpWR0bREfF5Tzo7oWxEJhfTNcvXQ3LxS4Q9wjDfmXsaOnPPtDiwjK7TFsfgKrtIJ3w+u7jc0cvSo7TzutNOtSW+NGJdXKl+XffS6HV8TPC6ckdvyxlHpIVk5Y4+wF0Y3up4EDjKUoerbxdCV2CjH3cDTvLjByyzqgPXB2+mN8Kc64sCzKv0tLKWTjagFRfyRO7mQbYzLmVh0S5qp4o9vrarENdpjTrNHNCToHTQa6B/gqJBD4IGgzqAPgd9B7oG2gb6EHQYtBN+kM3PH/v8arqF/swFagD1b3pz8GiUUUXLYsFQnbiZS4qo5aM5V2Zzuv6M1KsYM7vmxcLB6nTUqVPi614udqWkMa6UjKAkUF9QMijFuCvzC4kz0lj6i/qQ5Cw8bcTTF/B0OvxNKONKuKS6ekNfn//7WtBjSP2Kg0tesmfh/0/+D73tLRSKbDvVo4+hQ6v8fGF56P8QljfuCUudnWJYwp7+znonjt83We2LzK+iVB8V13iT7LFlM6v5xNHWl80LGW+pd6GZR+tz0M2FtLN1vLoCvuTDF111xC7e9W/pjDS4mPYhO21c7AvmmRnBJfRUrjePPTUD5W1mTcgm35hHLuTvec48lfn7pHcq08jO5OJGC1FZGHO2xgtPSHFc2whnuBSXxfeT97plC9mE0UxJ22hpYianj8j/z68FCEkii88Ra8QuziV5D9qDy2jt6+ICWm/wqRBcljY85vu+lU9IBs4kVZVTKIThDwjq2r7R1KZy0QdHpFdzxWnCMPZW6KgY5KXVBz/ZVWWxNcLwiNrJQpnQYBcwIzksbmpC3xG7JHLKdbl8JdrZAmGziezjaWqLTaFnKY6ThEsslobqJLOB+feL5007Qu/StKIOruR6DbS1c3fiRwtHxKMtBcy66YAPy6VORi7x0VtJH6oqxwixaHfebYGWzFer+7f45I9YBeFTpE/8XekTX0xtLkuf+OCNEX5+yEZB0F4LwzxgTeNndjrN4vkWznDcqmJtgkDnk2LcdspfrxpwpTpwGdcgjAeoTlDd6As83uurLzRnrRLO2WVmeYZROCq+7An+9bL/ed4g7gsW1Jcz2Bn0R8WZHrT/zcuvPpY7AiPTU2iL9NXDGcr1ZB0eNopsmHv5NIwGyd7nUXGch04PoT1kj458NDM6XzGA38iV5MTQNx0+uj/GTw94crqrhEELucQnbFyfJy4NvbnC+Ln4QCM/5JYtbmGhi1fkmOrsSew/BmD0vKkm4bGEhQk1fczd2T/EeP5tN2QmjqTY0xfQU1Z6H+OVJHsP9kwUnjEe7oqS2r46DqP9LjWx5k4ZnP5Hu0pIzL2Y+7FJ9f04pLtvPQk/4Jb9Qm5ETRdzcMZR8RZGhxEz9NURM+S5tAZys70jWemBu8DO9Vl7sYNZwVLlKn1j7leEtJ8x685YjNo3Smsl8oPy4LMfFWw81pfea2EuRGMyyg/63pYJ3pOkh+djcNXtU7N32Mdmko1n9HPN+lk+9Bp7S72F6Sjv0Znjf399hMnavvF/LhaydwM+zq+M8wrjUH5zCP1iPJODZyjcbbwFtJ/Jz6MnA1Buk5o5w9VsxcWDYgybzeuOKsGNB1efc+sSpydb2BNnhGviBN/eeRWknW4/o/E/Q/suudrLz5COtUoh5An8LDU0I5vr6h+OPYlxdl19Cq6qWFNZ7NTRVbqj5B99T7hQ1SHrxEyupKMgm6VYx8dqBYUgi84V1qCFpFV5X4iWxgqTEv91tpH+ayJZAbeR3XSy6nhRHfGNpvLHmXH4r1+ayqVhxkIpefTPNTGCTNI82jfLxxnGrFgbjXSecCFa23KpM+bZl79ZDwmfGIN5m6afV3zb2y/rrJ1P1LJvUrQuOntqSOaOqRgPy5Ozvkc/953tkFPx8BVHYEK5QwfSdil3BAVSbR3luU5zkVmUdtuaPvKnGcfpPyX7aRTXSLNuHxcrIys1feVzCxCaAoSmAKEpQNtfgLb/WH1ILB97rD4suUAapiuQhoMEnUJol35YbGrx7Y6TWxXudP6w+JtHA+4fd3FHglvnuVNWxv2l0zwAMu5bXhUkKIUI9D25qDlNzYfFdtKONR9IQUaa+axHSHrOWiOFGtcjPGukMONDNfKYGQLF5KtGQ466yng0T5DhrqWR9nNve9aXb+tZvtEpwbRvRFahFToLdF7wF+LbEmeg/GqSKL9o1thCtkU5nYvnRKsKuTUKvrVDbgn6HbNKTU/YyqUR+p+BRtvWs/wyIizDWW6tlwSWY0f9OXsmcYKtzqHzn7Nf/LAisS/bfSFXaZMGcvQWLtkYK8glzbPdr251DMQopp2l+wIax/CxJzFbILu/sXPpftqCk5gj1GEE/y6Tb8UYqm2mcLKWZhULcHfSobL48l/FvupO9HL6DfagTQddm1sp9doBrW+lUjH0hi7wiqMrSkUwiOtCpWJY61X714m/2igUtI7oDMbc5ejf6V+f6kaccSbijRtKZbQO8weSEn9St0xT5lCSFSIliDuxW5opDXqC8U071TMa/1wKyUi9FPJFKpWxtnajwN+iPOG3ARPEt7UbTrQSaNH9NgvV+9Jm8SXyWVzJiZn03Ybah+nNcmbL9vxdbQTV9wcaOcO2HKrvOunu+t7vkXB29i0XF56lFDYJS+Ebr0fN5ToKWoHHrPs06tE2k+riAfFPLz3pO6eW6m8jq7+X1I3fJOYq3Rp12QyTQGe/kD3rP6wDs/TCb/b8fQXSQzrUmCSue9Dji3NYDYlWlCmp/oxG/QH1BSWDUkarsgqkkbpj9eFPLJuWlpPvjzt3fYns3Ex+kCKxvb+kBASFcGsdam3+iLUODXMDmKtlbiDcrQ5eS2cDU7rSO6wNVbRXdfGsnunFgqLyiPiRxH9IJwVVC1yPhwUFKxlfefmB8gd33eC1DTaymUPrH41IBS52n5Oz3LzBW1w3+LwFzmv+OanvXdxpzBMPmf6w0UhNbmtfsx6zogvVXOwVhy6vUBpppJRRug3cX3iek8IH93DutLwHvF566Bgn8V/RLuW1eH6ZlGjk9R3Y2ydfvlDZQBz0tMYA4ybM0Lei7Bv3yee2Ezi3Ts7F8RKfeQ5zXSr9P8Of3aavX7xlQ2qmaoy6LE5vPEpljHxo6z+ePMTVGvg7ZeOUONTX4sTIKEf0yBFQX1AyKEWvMMuyChwh2mMOnbbAERpJaToYz/Pw09f/HBbdXvQ00xUoIT952vqfw+I1cLOmt/U/g58O14zPpvMA2mfSm/BUSTPIyMbSJY0YEcbE5mTn7Mj5OSd2Wva0n6fFPpf9HI2g383+KbsQc7BCaRLoKf3J+qjkt6cfEt9sPVkfydPb96dZ3QjwnQkwm+rNYbHGm+VHe73bZmuqD4sLWY0hXW7fqqoTz6tK5C+oS9Je0JRkxmLM717Iy3crKmUI9UveQFZ/ooaGa8i2sWpVlTO10uXMqqxyDi11OaeUcm6NclmVQahymoqChPdc51uNNesdii7rHbJAA+4jPVVOc6TLmRdZ5czQupwztHzlDIEkvT2kI6+U7SJ94sR5yh0yC73zLUd5pdaq3CG3GJ0jtHonp33P+Z52j+uI9zxaMJczVZvinI77sV56I6FaZTzqW0+xserEzDWSWkfn0Q60dlkoS+xni65p51bzqbMPi8O95ZLaOHmPrHLK7I6IX7L315lXHB0sGxyaorY1DYEXZbs2OFQJGxCqDQgh1YXFXsS76OeZuB8EfmK5Q4WeUhH4w4wK14+N8TmFjtCiQkeYtqN/HQblLcrrMePeT7PXSgaUnYl6LuZ4zlqpZ2qBNClVNm2tlAD0VKppWtBCvpdcUFg7n5P1am81HskfwbvDZanJmqRwIUziJ4+RFIG9qy9kbTfJ3Qp5g81hj8iS7Hy08QjZJJflmHKW5Pxsp28qvR3aVdb6yFhbPTdBIVREPnddzv+r6qAr3LvV8ZqF3pb0oHW97lQ5elfZn6gh5xyyPFrrW2pKc/CWBvRWE42JqLOTjFRznzLGVusqo2fnI6X+5alzRJSWOzocKnd0wrVjUU/nqkr+A4NwXnyn2eU0W3KdmqLvnRqL4kOj4HLmfnnJGVh03Rn45QLne5Zq9hZpRt4M54rKMw6NZZdTg1KUazFAx+4M+PKac5cF16IqZ96XLmf6IbszsHIXnv3eufLQLufKIsi/rHcGWOqdu4pS8D8PO7WVFmdl5WBn0JevOHcfOoNav8YRXHTGEQJSf7nGEQDS4r+CIGtXeV4cizDmaquc6SgzKR6Un6JqZx7whVaXc5aWchflFPcJniuO/hZQHsqXpQplcC9aOCoXPb9xOUdCcya0OkGrD/5JUbTGoQSptBt/U3NXHAl51M+C8pbhnnYSTqR2kwuV+MRD1b9HjHaoLWcd3FMLnL9ajqGc664udPbwt5++fzn/jRv/Uo1/+co+WorqJcuyQu+W8zkmldVRrfjR7uMJjKf4ZgFykHz7065IDkrk3ArulK0bSqJ2FfUZ9I6O2hv0q4/SmhvqA9r6WSqjbWeIHGNtQx5b8VzX6utrV9zua2+wvvZj/752+u67tiolph3GSVz0Z2KKd8fMyLw10gD9ZLgDjUerfbuFX/d8HfuB1M94SBzcnLgQs0+eS3zMNsr12rgfZ2tKuJ5mq6zSgNI1sPXn2VziECvtz/OKkZ5DYlyzbnd2vQ6tWmdw1nrq6n1vkM4w/3bMXO+IQOlVIqci836c3Sl9INJRVtnDGU9rmSBRWdY7OlmIS2ukffwASwnSn1JrOnqdMw6thcah5DPaz1hOH4qR4ShXQVqVXR4j20Xt356Wq9Or/fOAH/tMM/n6jSPioFquNv+ufgNhbpWxPfE/T6cU8qXb3en6SQvFLMmfrlV/S1eVP12Jt66qZ/Va9H4FUoHRK/5A51JGe8Xi1kNiaVMY0iTYnyZqpNLaph0zad13CeJL8SpBe8necdWreIpfCVKI1oFHpPukMiZVVVJ9obSgtPFJFEyicC/Cc0G455CG1CuTFehRrkx5BPvGxpXId6M+Id1ykW4KpBmlXBg7V4L2irWlz+5PML+/J32KWhT+9KExbYHxTjrQXrpiKSVfmUvj7tk1MzGDTa3BKNytkenn0vi3b1YhZhM0zuo14x22RzFrhCwWcw60wAVoiQscmoRjjoCEAof2YbSesfI5vrNx0Ac03MjiXXkepVnFwvWsh2xPlrvmeXzrub/F/zclhGp6ZiaYfWdxyLN85/ofq5f3X5KlnLNCYPbp6wOST9YHglR8oaQvKJSiR5+sb/fEyfqQJ6blRGXw+iLXyy09BYwpmf/eFkXDL/MV7gvcStePHsXNRSNoP2DvuUbhM/Ht1lG3Suf2FFKAt7QmCYqG/VlyV78mskmsQHhlrheaU+iM0lZ15o5patoTaPTt0EN9lIVpIt7oyMJ8tUTBkZ0sX/pFG9+ooj5vpI1r+GUOd3NRKu/aJCkF42Gf/wubVB/6fB/U8kCmIAUNofX9SULX9DP1ipeOuiJb6iRdwcHhYegD9Ma0GmUZV9LJ3CGzU4Yc6XaidbhgFI66ElsMgu8UN8XNWcPOo5RsxdyFSs6oW5oxNM43CrQ/4airdwtn+NUaYFaz53e0DhF+sHPdr6AuUfjtSPeb/rSnOOgQr4G0D96t4QPSj7rONd/IzY7S2hJn0P46ZaaK+VLQese6ve+snxkynx++vn9LFY2lCvLauR/A3HFUc7n0ANuFvrEgqHJ73kjU50HN9NXhzYI6RxhCnmHRbQ5Y2zZHGuXK4S/UbkBPrlhbh1pWVx9ELQ7a79GqgF0XaqudCgu31iiMcnHK87UpzhHoMaYXnakPj6WaFrih3NWv5ZB4WpIJgUircteVlnLpceMaR6Q2fZAm8ckLfIysSf5n6k15WHtTeC0f3RO5/c+pipsvpikaAqehV9Ci1mnXS/mKbxxcZDlGl+itEla6hrbscx7T+r5zb3V01UKqXePoSH1Z5ErMyO6WdvRLO2kxn2caRmeBdqVrzG0tqsukGajlSsIrNbvpy1RA+hpHBJ7qXHRYXNQU5R/D9BQ+tI800px/4wnqMzYl0LuQIkpjjKaO5WFM0ESjqbRqWeWPeQqk7uom2q2FumHUokUInxru/5anWlUs6UdXU/nsneraWnBI7C+dr1fFvkFvMdW+t5g1JtPNkHxNbZWpAPnTzl2oHRwzhmyGcUdd2ma1MDV9r7itRfHgUuG1uq2OrCJQ6RUQrhhJpBfRzltl7IHmP8Xd3FOdIyWZLqRnqquowLg7cthYadBgNVsJ+zl6ggD06PW+b2F15x1X8hqcx/LYtzDc/WB5LDOy5Dv0FjQSrnN0zjuD1pNKSkb6dGeRRbObRkvhlRhD8cj5lWfQfh4Wf2rk+39kOm47L+W+OPvwlLxH0zWVh0Vlk4jR0HqkRrkjJLJtdLm/6Y2/UKrmhX/wNfuiNj+ArGBnCtRWKDbwG9tGKStd5zyZbBWwejd9R0xE+n7YiPZnZRIb79IXLXnP47bEYcbK9sPGsRgWP6y4+XTaOQdXpGhYlU3fxagd/865vEhxM4f4GKO9V1Rhf3tmTDU/IKj2Kzen4uJlPS/aFA2rp67Dcz7fFDfHD13roJM6Bw3WOzVa3yri00XARSvtdLYS/eispTNff/0IaAjHWU4+99xzj1J5ob3D4b3CNep97TL5tVxJo9/mjRbz7kWofwGZiksRmI35Zua+PRQHxJFsHn4L9bqdV8HqdFUQp9fskwv66mBzcIaM6n9zu4yg9N2ud1roy/Nu194WPiYwI1e/26Vs5aIDwNndEpBB1/da6MQyrnZ0WnvmFz/I967zJNqce781e0dg3kj1vN8VKWtbh1EdHy8QVgrdBVrDMVaQ7c4QUoXdrr6taVFB1kcNKmsuyHcW/RExpZmP+93Od//NnlOT+pch/zMx3qsQdBj7eMVvW/w2bJZzcY32TS+EsnAMxZVPPyP+gbBJ7Tg94aBPfBj9VRKf4hX3eYNH6rOKq31ver2i3XvvSta2fSde8aoXc0u2f+aIeLOJ9tZJT3J6SrdY///l76NzqKLY7o5ugsLGxdHadFoxFfGYIdewx/e+mLiHvHw/Wuv1GbML9YE3p1fY98ZcU1SIdWkUbz0i1jYZcuntcb8sznDZemfFyLf25Fw++Qebze4LlUI4Q2crIAwUFt7gOzVPWzcyt3eGHj1eRZO+uhdDO5r0NbQHJj/VKwbWGhhvcxN3mL6hd8/sAl+Vbm9/lVuhUltjzLEslq/TSsJ+gVd959b+26PoprwYK3Q1d2HS/CavOMGrvhrJ/JoH/73ia8gRim9HxpvRtAK8R7ztmP9qa2hmBEtb+i6kEK7Yg80BGCd8afeKvbxB6V6x1vOnffm/QjWpL/jKD8UrzZ+2E/0236kcSf7346fmhGo0SPOlXs1R476VVe0EDdt50HkI2r6ZaBMkajHlNc/vUVRGz+yUfoidF+UVu6JEh6d/Ltpald3CL9H4WFMpL6HdtyYpYsioW86hn4vxrfrqIHM7VhOaG2m9zakWtBpKg7DK9WDLeUmT1L6a8JGWALaHgb6ZZM8M1fTx95HUFqMdNm5FOxyIVBjRQl/vgio+Eyc1RsTQnlUuGmOF5z4TxzRipDDNKMhcD3mCdhkE3rWvkY/2nRYzPf2KVLX4ivTOdlD1IdHi3TY1G/GY7706dSquc7367Cm4vuAN2pU11QA/Xmml8U8Qe6eUiBpL5wTLXBzkE6Hn8nCxWdmqXRPSNSUBJdqSQ6Ldo4vJyiHbB5+JQY0+m201YhR7O4m+NyD2ZS5xDkYpCwfSbtO+MeeknIGyErLb9rl4ppUzaC+elxYNbF9D4U5upJWTn4mZLT/bt80qci2VfDY9KVYyV59WX6jeb/FdLzdTn98+7QGrL9YHG4Mqp8wcLVCY6P7NRmrNMw+rmPS7Rt+1d5PvurhJVTll1kRoWz2kt7smV6jB+H3lcE1twfDgs6RzXaoRD7RQTIzCQwjBKi+Fapi03u4b5f/q4fzpk+9x2LflHRIveq7C/c6jn3lIPO/JArZ5soA3ekhraSud5vy59wG2+4qrpfaX+l3Ke2qHTz4Wrjk4NpydbRaWSasuMb5tUGeVu9KRxzJch+HahGsq7UTFdXAjypQKo9eXPjQprU9IriFdcukdpminvviIK4G1HjQOvWOD+zNxJ9t3cEhUHj4kyg/TeUWutCvSpvWgwnOjlqHEvdGNbFMmCBlCrnBcrG/JRTpJUoIQL8lChjLeFcZzSnQSSVUhcb5lnF/BOZGxU0rniPc1410Cb6c0i/skg3jHGc8mhfXeKRVzX9kOpR8adUj8QnpHOsjVoIydBDrEHQCqBTrC7Qc6BPQJtxdoH9Axbg9QFdBxrhpoN9BJrgpoJ9AF7kOg7UCnuA+AtgCd5nYDvQX0JVcJtA7oa64CaA3Qv7n3gFYAWbl3gZYCneXeAXoN6Dz3NtDLQN9y24FeBLrIbQWaDXSZ+xdQHtAP3BagaUBXuTKgLKCfuM1Ak4F+4TYBTZAU7t9U70jXOErfROFhQRdNafI0S5MRkrw3UjjQbXsTuql46ha3GmgQ0F/cKqABQBK3EigJqIlbAdQLqIV7A6gHkIdbBhQDxPFLgboCyfglQBFACr4AqD2Qin8dKBhIw78KFACk5RcBKYCCeEt6jej1viMF8y8DNQHp+AVADUBh/HwgF1A4/yLQdaCO/Dyga0B7uTlAPwLt5/KBLgNF8C8AfQcUyT8PdBYoip8JdAaoG58HdBpIz+cCnQCK4afT+ZNAcfw0oBqgeD4HaC+QgZ8K9BFQAj8FqBKoF/8s0LtAffhngLYBGfmngcqA+vKTgTZ6n4Jbwtxi7yS4a5hb5J0IdzlzC71Pwl3M3Ne8E+C+wtyF3ifgvsTcud7xcGczd5Z3HNwZzH3OOxZuNnOzvDuvcrU95GEaI+ghUIQSYwpcLypCNeOAk0E9gdeB1MAP4SqB7KB5IKs8VLMd1xzQFeA06DwBHIdrIa4O8BpBSuBQUFeQAJoL3uOgyaD50J0BWgyqwX0y6BngClwfAX0JXI5rLa6ncF0Deh20Vo1nQGWXdZrVoN51Oo0aNA/YCXoUssdBz4LyQUkg1w86je6KTuPF9Tn4sQn6g3F/8KpOM/BHnWY/qP9POs1J3KcBHwcNxf1+0GjgZ0AvgBaBVoNKQf8BhSPNuoJGIVX3ecj92PM45T9z3/c8RuePMnenZyTcHczd5smEW87cUo8Z7lvMXe/JgLuWuW960uGuYu4Kzwi4y5i7xCPAfZ25izzD4b7M3PmeYXDnMTffkwb3eebmeUxwpzM3xzMU7hTmPuNJhTuZuRM9j8J9grljPY/AHcXckZ4hcDOYK3gGw01jbqpnENwhzH3Y8zDcgczt53kIbhJz+3hS4CYy1+AZCLc7c2M8A+jEK+ZGeZT+7zJ1SEsHqBkUiDTvDHoc9DRoFsgCKgJtAp1Avp0F/Qy6CZIjz8JAQ0AjQf8AzQK9CloN6og8jwP1A5lAY0FZoBWgjaCdoL2gk6CzoD2aUE1HUHmfMM2buD7AhWoOoAy+ByL7nUEgDvRHK/Jfh7ER6G3ojQRNAj2naVt7qlh1RTry9lZHZSmtQQ0SlncLplm/ZpSLDxyI/opWWK9qUbnT+YOrveIbQMX8AfRPXrEA+ALwLGBLS7WgaiiecwB9kmKAV5zbshkzsI2O/kXfO+LYt9gUzA8/d/YoqsKcr9o1qYU3pN6cvNTgNBRdcay2tM0YOfeYpVccK+/c/5mx9JRjUhGtETroDgvZZyPLBgrbYvMSjIIPiw569zRnH/V94hCvofrVzNfMr2DUeFi8Csk1SA5BYoRkQeYC80tMcg6S3yA5AkksJPmZc8wvMAnGmA2/Q/IJJB0hycvMM+cySQ0kNyA5BkkAJNmZOeYpTPI+JE5IjkPS4jFU/yPzH+bJTLK1hU6o2Ye+tUb8A5IJmU+axzPJOkhuQnIKkp8gGZ052vw4kyyD5BYkpyH5BpKMTLN5BJMshOQvSL6E5DQkaZlp5qFMMhMSCZKvITkMyeDMIWzt/GHxGUiaIPk3JB9CMiBzgLkfk4yBpAUSKyTbIXkw02juzSTDIPFAcpajum6o7pnZ09yDSQZCwkFyHpLlkMRkxrLd8ofFBEgUkFyAxAJJVGYUs3F6GGN9RQMPybcc1XVDdYfMjub2TKKDRAbJRUiyIAnJDGHj/cOiHBI5JJchGec5WK3JDDCrmOSvZt1V33ddes9Pe5S+8I/3lWjfXiikfUtfD1E0KPH0DyiVvZsVDSrgq8A9gNXAPwFHA2uAfwHuAhwAfA24A7AW+DfgEOBA4N+BA4CDgG8Ay4HbAd8Cbm1SNAQD/wUsAocAS8B/Np13/NPS4Dx2l709+u5RKL3Y9yQkigYdNJug+QM0i++r+RI0i6EZCs0WaH4BzbX31ZwPzbXQDIOmB5p7obnuvpoLoLkOmu2hyfFecSs0S+6ruRCaJdAMh6YMmkXQXH9fzZehuR6aHaCpgOZL0NxwX00LNDdAsyM0VdDMgubG+2q+As2N0OwETQ00M6H51n01F0HzLWhGQFMLzQHQ3HRfzVehuQmanaEZBM1oaG6+r+Zr0NwMzUhoBkMzCJql99V8HZql0OwCTR00xcbzjrL7ahZAswyaUdAMg+ZP0NxyX83F0NwCzWhohkPzDDS3Ww44Ocu9O4BOgqtoiIFWR2gdgtbblgccxyzrHdvz2jQ596cFfzm5vFo8vdMZj1Z1+j0+vA0fLsCHvSg1mzEnip2vaLiI+/24X9uYJOzDyBN9fQutIt9aMCdzrnkuq4d9Udbj5pM8EvLFTL6tYAZayzwmj4G8O/yJgnRuC7WW2eYcJukASTx7shtkOezJ9QWTMyebn2ZyZROdvrWpr6KhB9PSQ2sM01pXMCZzrHks07rZSFpboGXAv8Qg/ikI/WXgOOC+wD8AxwP3Ab4KbAA2AP8EnAAcA9wTuBdwFHACcB/gcOBEYCOwDrgXcF9gbSNHZ5XdULB3kd86+rM1TBHOYi2d/77fNafZd2JUonmMQCHc3kjWLt5wTCrd/guldbr9vGPH7fx+veHZj+jMw9V929K4e8sT0HjnLo1nPupMJ0H3bUvl8Jbx0Nh5W+PRv57/KIzOh+7blprylmxovHeXxuyPtHR2dN+2lLzZPM3O1ba1ldRubkH7Sefhf3chZuiuofOH0qyZ666c/9kUPlpv3OL6vJGPfzcnu1tM1x+jaIeBXOJnrzKZJEVg15ckG82O8/dxsQrhpxmlJrmbV3a+oHCPV3Hdf35ht4nwO8B0FvFuUwTubrG7oKTdpk7f0+momOd4+P4N9vFSd7T1lzyJwkW7j/8N+Jf9+D8M5x+l8crKKt6tV6mLjcLqWSHCOmGL62ZToekZqxFI2awQjML6mi2u35tMUSorVzxOSDAnZuiFw+L3EmlcbjqYw+sD2PuDLa7vmtKilMJNa2xmnFm9mSsOd/Eh4bUlQpkQ7pKF6M2a2khBte4Bc7hLERJRWyx0BWcTZBporRU2A+lCOo+MNJ+Rggo0tVGCqoxv2DbnTD2/h9OPQ2lQrF/hOupRlXEbiEf34EK3HTufZ8iww7T/PzbxpWo7p9+LfPmX3NeXlZraa/bHtdcU4n5kbXvNKlzXgw7K6fuhOEojRDEbV5g7eQpNSiHgbHIu7feUCx3NHVn9mCp1F65I47ddkUZWcXFqtz7gXVNnq/p6oeaCpDByiaEXad9VjRjpOS0puPHV6UibJslYw61Pzh0rTBJoZJUq8f1+trdOYacZ//NXf9jCFPQuRCYoBHlsUIZXPOCl0+r0giJWi7sqL53npYdMjbtduHOxO2WG7xyGbbXpY8I1hrHhGqs5XJOeSd9YZru4tFVTvpr6VTadba0QPq3nYtHqeenLac7AQqlwIH29TNnX8bGOZoXQU+D09B5R4dZzW1xLGnsKYWbi1IOTD87L4AQzzlVwjoGTD04g43znVTSsyN/imo56vZid2i1z8Z9wtRSv0YjfP0AzQQtAmn2ZuXyyRlBbTTcVQw+7BnuqmgpcqQEatnaOvrcGmen0sNFoG/Z4ooUAM71T+9CD1ODVDFcAu3i9oDT74/6JDf5+B7oMusrykksvlnKNo5K56yfk5+q5I5N/D5J3qw3M3X1dLiuaUiwdNI69r+zLqcWSJmkCyTjr32XZR3/jVmx19NSC8q44ej5FNs642FG3Di20SrOuhqD0uJypeenR3HVNwL+GJ1uPR6yTcvRP7UFY9KWmHtbQZtmSrY7OFu56oVI2jG+Wb+Hij9zgn6JVcAucn1k2OFxPTXe+YeEH/OrsbpH3Ubo1ys8cTst7zvcsv9O5Kezbm8LNK9Jrq5wjtHwv1QU++Qt7VM3nDlke2Umrdo1qXe6QaSU7jeUwjhuSnDzv0a0OA8JsQJgNt8NchTBH/VeYkxDmsFfH7pG99v8W3r/uE95b/5fwfsXCK/eHV2xZ7pD/V3j/O41PIrxH/iu8fVka79WPRRofRBrH3yfM8r+FucUX5kcozL4QN7EQX/+fIf6ShVjhD/G/EGIFhbj27jDr9p118LQqJ28taB36LpoBrnXwpb69huqiHs6VpdOdFUUYL5QqhLXIsR7OFbhTQ0NlWYsU2el8r+ia840im0ODe2Xee5jV2Z2qojNiZWuhgys96eCLCh2yIuot6U1p2zyzvIprsGdrSriG37ID4NZna0u4m4PnBcIdNi+ohOvO3Rw574p0dfsVx7yiraB2JXTqMId+40HB12/M+b6duwtvzK0Rv20ul7qwfTA51vDKpFyytXW8ua4+PLZ92mRrnSPCsl46koyYWOhcn7KawN3ljkjtOKm7kSvR7FZXEqKv0ouzZK4aOjO71tfiKK4rA4M/KpMUSYNqHhKMucElmG81B5etAqdL2SnpnQEpQrmjc+kZMbl1RDTfrKzqXHZM2pQUCXdLkrosedps16M8hQMynscIglo0+BdKX9o78txb9J2d/nlF/hpHcOkaR0jRGoeuqMz1tGeUQGdfrrRzD461HhQ7N4bvpjPaA5lumWuGJ7yMSxx+KZ2sTpnOSluiT0vD9OslTaji+lLZWccYyyrTScd4i9p66eNCtA+F0tiBvjidlTYN3OrQW85LL/aYzlbAdavlY9C29jgpvTiQzrzc59J5Q9ge5n2ubO9WR0gXWhFd7Xpe4mLGAIVm7nNtbQ30a4z17nelN52WUrmut8dEXG1RjwktYwYUPjqvbMk2y1OnHy2/sLJ84ru/HqM1D1QGfeuxXI9Su99WJj5AmfiBlYkfWZn4hZWJlmwqE+EoE1ekYW9fcfyzlLvZa55CWCm0K/GNLVJvWgtG/b4sUHE9UE4rICY+XyOeaWpbA7GhALmo2SSNZndvFiivD1cJwyIr5zxPpeSjprr6SJQS2rW0ScoxDqoJ35X/fDjy+XxTeNkKcHoin1cMDK44Iw5tqauP4of1GP07L1c3K6fPsO53/dxEqwu/QF0Mryh3xJbWOeKKyh3db9ccqi9nxLiW8F3BFWsc4aVnHB2Qwx2LzokPtUaVfS4VJFHJ9JXI+NslMvieEhnfdKdEBlcqGvrOCWf7DcnPc2KH1mD482JSCNyFSTq4i5J8pS6SSt0CdUO3BZ8jpxA7HZW6bjyVuXS9ouHQHK5ZGcqtpd6yp1Dmimnl+0+wlzv0iEU0YhFTFI5Yn2p+Zth/h/5ii6qh2xwb/G2fprbRf33cYHklze0djBJ+5FtpYVhkmer6srDJkccRx9X2A+JBb2RbCcb/lbk0rZEowcbbJbgg+gvJgBKcqy8xqa0XUWpz9YXSmB5UNnN6yBvcc89L+Z3GSzH6taao2pNSfg8+epQrXRZRi7LbCX4MQ4lO+kKKMp5HOnwh6XFdhGucsfdd5ZKLezGDxht3l7lvWJm7wMrcJVbm9rIy93U2lble6644VqLM/ZJNZw+yMjeDytxnKFfLVFTe8tECbWhsK29rC7L/Qdc1BShjuekoY682tpWxpawsUgncJIUbhWGstOVSaStvpNIWzkpbBStt2mYqbVTWRrmGyeXNyuemobztbvx/KW83mv47x/iWKPg96/+hvL0n3a+8/dbiK291aP9OSVkob6ekHJS3U1JuEsVP1fD+/FOsnIX/rZxV3S5nelbOnM18/6epnBXVSYVVddKKbVTO1rWFueiMNL7qjDRx2znxvWb4+vdSZkEpG4RStvtbaWJ0ZFlZZAlK10rPndKlR+n6vplK14P+0iVreH/umBkvTzmLWRnqAh/zWolJhTIWM79QGn27hDWghC28q4QtvE8Jy0o6nHUe8W6Gm5s0aMrfyxaNaTX74mK46BNiQpM8Ri4cqw+IuTBVc9R7w2+3iGzzNdJqOa/4eCOdje8Vzbi6OK67VxzOZrOjk05KqWOQ8vl0vpmi4ZF8+t6oaDDjasV1Aq5f4zoV19PeSZjX5QygVQgnpdwBJ6VZoHzQQtAiUAGoELQaVAxaD9oEyopHiw9aEd9TiIg5KR2cVygdyQb/SaTHk4oGR9YJ8XSjLoZO7S8ArxA8N3ifMJ6i4U/gg37cAPyxH4vA7zeOulU8l+7ezz8hvtvITi5s6Aa8tVHPcBzwZj+/F3CJH+cDr/Hj+cDL/XgR8OLGYwyfxz+80qi4uXeqouHCFFo1gFnooCLTuJxxU85NOzd13PS/bIqbg+eGZ7TPUtwcNpf6TEIj52IeoGyfVeba1NQuw4CyuL6Jzigi9FYT1YzMak2GrwQtb1Jm+FqqJU104h6NnU4fp7WH9E2ZdoDJs9KylmadyJJPSZuydMqJKfKpvDtOJhfGSGSpXJG51tRo0zEbNr61YCfQ1vSdJy+xSgeT5ZsVQol0kF/pesETV0Hfv8+De8VhtZxz5Bedc8wuPeeYU0mrlmY43yul9+R5zvcqP3IN8vpWbOdqq1xzmoEhmwE8s9nF+DO0H7l6kk5llTMP/GeJX0r4I1dXb66Ts8xwGvLOOOJw/dLS06m1XHXGWx7cXO3MQFvR3ZLr3GUJqLjqVFvauWcFrnEkgBsPbk+MnHpY8vC8Hv9d79xp2eVcrs11GooMTm3RGYfBsgYj4DOORLQ2vYq84mzveelWWBhiluel2jBROCG+LQVUcrHdPqB14OscfN5ZjCcDr8v5sIquw6ow1rU5OIsdI9xijEQxhsRVabnmt9+3y+SwBSXHJcrcQbI62zNCyL+NH4R8FvLvkM+ScxOz5GXGD1I+TBDkX35sisialNVBkLs18r9sutyILHkp6s88RcML+TJ3nFJe2lkYKylmDgVVIn+MyZtMt2xo954zCrzrWvMV6fJa0HZfK9/le7TxcmPlJLTjB8XNngKhuCZBeHQz6R5t5QxozdUFNycs5jY8WjY1Y6xA9oAqpeXSuOV8f3nvOtsVaRN827TdN0657dvz5Nvce3yrvu1bX+bb437flsK3Cbd9Gw3fRm9ve28S5ffvnHRLRz5m+H0cyHzcedvHIPg4sOxhv49PwcdJzMdLNi6+WqgSkoV+5n4ZE4VjYmmLbw3wmfr2/cN2GTPDSiYKh1wrPe3L+ORU1/WCsAp+wCHXux55n19sp4eHnuW6Gx5/UEgQkoQuFca3jomWli4VB8WVEt/fuOugeLRJ3tt1+z8eMHdh/5HbYvrId9oV/UunzBHSsSEThYfwP0/4/2fV4hSB/mcO/ucn/I8R/6MbVSGYPqQVEoKUvqZLxTFxGPuvcfivJMR9Of7LaetylfY50Rz+rcdCNU3PhbI1w6MT22teGx2qeV8ZpqH2eZAijL1zKMSVxp//xlXhfkfNxdPbqT2m3O+NlU9Kii5r0w+KW5GK/6CTv5PrpN8KyqWbxVekWW9/LumWn6nXGosyA0qUQqKw0jxGoDA1NQfs6lJxyOVq1SImWiudiLt4TgA4MZ6C4UoroWaMshS9f0FuGt4GfYweQMN1TxB8Pnzf3KXigPibV4X0u9Q4SVAUJzD+mWZFGR+tXptWQ/ILXjXkXzXyUXSKgLrsqW7jTOOGaiR+ENeTc5Utpn/4xkb/9p9WfoCizzpb2u21kyid6o+uoVSpz8GdpG68liBQKMOY9rPCEuTnhIwU5FRJc4pwQHzbq8F/bWhMQFjGMP5yCos+oDithuTrvAGQL2vkjAiLPqBMjjHgZTcnT7seJM9+gjO8bNOUdavhEk/XBrj5gNLhc2y0f9VYcVws9SQIQ1iZeKZ5Inx63kulJgv/pBZSGH9sM/dgmo1kz3r7Qja2UU0x7oESl0GpYmoewdJjtLcfpGm3pYlMmuyXDvUmQdrvtjSOSeP80r7eZEi735Z2Y9IOzaOqozK5DVHmrhlyfY1Y6ym4xvc4bqcnOnv744mgRjq7z1hpuqlIorRLaqU301+groVm/myn+vX6rac+mnaNq6V3XFQOX0eZpLLYCeWwO6g/aDjoCdB00MuglAHtNauUvvdrO+mKMiz0aa/prYJM8OUUylALxg9aRfGz4HzI8uRoE+XF1x7Kq1opQVAW72L86iblXXl1xEN59ZHUlle+valaKjcGyz35pCgtNd3Jqc9aE4SNLF1WNlEKbPJQTq2SKKfWMv6rTdyDj9tIVuShnHpVakvPIiZ/vsmX2q94KKdeuC1dyqTP+KWzPJRTz96Wvsqko/zSf3gop0bfls5n0tSm95j0cQ/lylApt4byRBlKeTKdfS2QIU9mZcqv8j0O2GciT2eaZ7E8/aY1rOLLX305Nfkjyf6dpOuhKis1vX7r2Q8jYsIQ7wzEeyr7l3Ys3lGeMPxHCOJdIPyD8fkm2u+Z6nqjgORBmJMdEL1enZvTRLBTVRKE8UzP0Uh6WpZCja0doXXjHq1MpnXxLq1rre2h9f09WmlM6/O7tM61doDWqXu0HmZae+/SOtbaCVp77tHqy7S2N5K8qlUD+Q6vpozeocRYuUT1RS62S4WmBPWfyS55NZvQj84xxnIGebMqtMOlYx+vdOlY7E1WPVKV3jdTqia0Hv+V/mGxnU/+hU7RTr5ol5dFCnF9x0mKQPS7gSXod3+yc7XUHteAToG+Af0C+hOkQFnvAIoH/dnvTn14GPcZoImg6aCFoJWgUlCPo+01qrKwyoBdesEjxrfS2R6vf8BtkGd+bKf1Att/IVdlr1CFadrObUJfunhHFTtR3v9dYi7rUWlOd056hzsoVvrfIuRY0ZMGbJa2AT9jpfnb48PCK7+V3tGlou9Z0+R70zTGulnau40s9ASxcwfkzcG7oMOdkVK2HRTfbwouWyntNWo+NArljgjMfXIw98nd9rXYocUYS2mLOV5oX4HmQBrMgeIwBzJs84i9PMG7jMJZMdr3hmmtpuxTaUVSANzVSVq4xTTb5ygENMviG+LYOyaEROd/x7TR/47JfYwrdRnR+6yw7xfd3tvvkxh/aCu9T2p3eza+IvSh7LPS6tCX4RZHH8oulA4a5Q3iPMype4yXYo13vzVaNDD29llT1NalsDMuPWJ7r28vXIbku6axe4/Y2koj7R016zG/XFW9X9yNmcz5qWQLBPOrTu6aUKF9OvUDmImoOTYLXS8VMs2N0HT4NQs6zYBmADQzoVnANAsHphxVgLO68Se7HNcVjWSDotdohGkcnXVApZFynuu+1RFbdEyKC1UIXPSxei75WL3sCa5h/TzlFE5/Av7TToSbToVW0bAp/ytxTcud+wrcL7vr/iDuX20piL/DOQ3Oiy19BUrzCO64GN/sw5uA9c2UUnrMqCLGnJSiQPox+WxukW7y7aM+KD7WSLYbFBf3io9IbfuoD4omcLOy2vZRXxiE8Uu67xwPLpf6vqxc+rZwUHykhvZFUSytUlzSVkd20TnpfDT/cIH0kv6cdJqh+UBfM7QAyMrQQqDLDL0MdJUhC9AvDK0A+o2hV4BuMLQIyMXQa0C3GHoVSGJoJVALQ6uBuBhCRUAKhlYBaRhaAxTE0JtAOoZeBwpnqAAogqHFQFEMLQHSM7QUKI6hQiADQ8uAejH0BpCRoeV62hG3aeE5x9vaEsd2barwrkuFGUpcEvJzQRs3Bdxmj497cH4b1wiuy889/RJxSGIA91dPqkC5/q5rojfFj8Z5jX70uJeulNsGtnPvXdfw2rZzCP4coUSrk5pL+4kOigvY2vgue5TuTbIZuR2Q1zmS0r1MJY+b7ZIHKBtWWmajPe3YiF46MfjSRmmCcXJ1QLNi3DnpfY4zaC9h/NOkaVbM2yHd4vjBv9tkbPeF4rpCV3md4w6Inzb9Yaeywg9b2/gSWrAOl7jrSzkrOykvlX0dDjh/y5nlP8XABVTlnK7NH4GZo6XRfsXBW/5i3zrY8zquZ088v5grxvNkwXeEswf8OWZZV+1fvRDDxZytueW8anml+s56Bi4xvFaml+vzRxDva6Z13e7HkDvtdDoBnSbQFspIFsq//4v5b37yd/sJ3i2775yEtjqw1ZFQtKRKzb4cLFNx7vcVXHdfSg5hKXkOqa7jRSenrQV98XEK2qmZXrKlNNC5wrLX//VcdX6B8zT7f7rT19H+v/UOuaXQ0UX7nrPAQjvz29ZTaM6fdwTctp54ga2u0FwfLpftmoKU3CM5kSPGFhp1KNwKxUHKLV/buRhJ3K+tbyI7HsGo2e3c7fkD4nPecql9Pvcg53pnSUxldO7U9APiWPC+Gh2/iev9iK1c+nI01/thm9yQenNbAcpq9FnpQmh2BNezBGl5upZ3e5PPSilhp2snf8z1jK/jEuMukW1m2fWlMtottY7tqvbtBlR/085tDQq6nhY0WEr4esrwBZfXOeJuSzV1/Spl19PkyVLC07tM79dy3fnuYQZDbZh+CVo4g6ade6ea9irQigfb8DnWh1ZQzVE7dZHy6yvltBOL9qI9LLSlT3ot7Z1Uu2XqYbWdEKIekixqIOicIy6PQijdtUP8OHSvWdq0wlacc4RZShzp0NMlLHC+8dRBtmf9V6bbrW4g8mM+nh7oFCwLnKdovWHeaQeXt8nBoQYPsJA1ahrpVtzgtR+5Okm8YVNtuqQ4ssM+RNhgxxN5bfvfNd/Md07PG+BcbkH42bkf39pPS1zV9/52OL6sUHrR2APuP4119XHsbKSjZJ97Ou1jK5SKRyt3oyeQ0WmcduTcCA/tBqxdDN2VE38PkHOumsUpMT2FcIw4dZI3lo+m8qgXqESukZYa10iFujP1YSu9YjcPSapQL9c4Omhl0T4drxjG+Gsc4Vr5bZ7Gz+ukpV53q+M/4HlafbyOWu1tvVt+XoQ28Dbvdz+vszboNu+qnxepbXeb962f10UbfJv3tZ8XpQ25zTveSv3oGkdXLX2hfNdV2AJ+0V60j76VSWMX++yTTtf62iBqfyiG1NuWI1bvuma23NF+5L7a4awvLkd833WNv0s74b7anVg/XY6UeNc1pGWfM9Wv3fE+2ijBYyjNvpH69eUSu9XR7psS1PErjpfYPvsrjhdRTjR50M17zxmft9Uxx3LNqWargs6glShvDDIqMa9SxlJufuP4p3aD9GLfDdJLMRscxVoF2180pnWDNB/3a5HjC7n2jGcBbwF468CzcCrGywdvIXgl4L3CKRnvOfBeBm89eC9zasZ7GjwLeBvAW8QFMN5Y8F4BbyN4r3IaxksHbxF4b4H3GhfOeI+A9yp4m8B7nevEeP3Aew28zeAVcB0YLwG818ErBW8x15Hx9OAVgFcG3hIugvE6tm5wbEGcF8eskZZxnRkvqDUHqfEGx5WEVVLtCOK7o2YcaqGzDjTJVIvOoBZ1KNOWhJcFlnQqCyrpWNauJKIsuKRzWUhJZJmupEtZaElmrKqS7HfoeOXujumKhvUvYW7aYhD2i1ub97r+I2nZN8q9ruLmlOokNgb9s2W/OK/pM4zw+t8es370J1dA/VtBYZ+h1hHhmueee+PR3ZUJjzzynz8fofN3fHZgOY6doXGNSvTnzL107QGHSvvHtQOiisZcoxTCyqrj6fvFAC/tfdMXDJWihhygs0oNs208RtezrJhx7ACVvBelFOiNj6KiVrzapKjYL/7huSIN3pNScFDg4pMhq84g2Vkm+9GTLBgkWQjtISLu54z7rYf0JgkVkooj7hHG/Ypxd2RUSEGMW824x8CtkMK4BKGc+buTcfd56PzCCimC+8yWIGxiks1MUuFJEFIK1zNOMeNsBWdh4VrGWc44Gz3Uhx0sVLvj1ZtsqxDvNR6K9zvSi9xQKQIxfwUxz7fJEPPnEfOst0HrFO756jtxn8p8moO4j/z4TtxfZv8ynsmy/xb3DMad+Le4P8K4jzHuzNtxT2Zc0+24T2P+Ghh34D1xz2KSLkySwOL+NOOEMU40i/skxglgnIh74j4OcQ/xx/03xD18yH6x1UtvVOSI+wLEPX9x5qiRj1O8h7JYXGskXxpaE4R3pN+5hxjvMuNdZ7wbXBLjnWW8HxnPyQ1mITjNeN8xnotLYbxPGO8M493k+jHeXsY7wXi3OCPjVTJeDeP9xfVivG2M9xHjIcMYbyPjvct4TVwc461mvDLGa+H0jLeE8da2UmrQfimFu6NitY3zr6pLDAnVfKIO0/wKugniNGGaIFAE6NnAUE0fXJ8ATQXlgxaBVoB2BYVq/oVrBehj0BHQKZAVdBH0K8gNagXthb9fgS6A4nA/CJQOWq/xzfP/Q/ZiK7zig54Cdu5yj8XRwlGUj/1iL29sLp840nZFOvax/MPuXUdgjpa/Yr+o96rdvJYvJu3wxUp3Kp+/2iu28yjdw/iq1dSvKt3pvAtI7uFLVW5ZwINdH0IJ5dc9hPalsVWNtqwG5RJtDXAEcBCwAzgOOAzYDmwEjgD+sZUv5fvKE9RuhfqS7UlB/qDKHa9SukcqD9gU7t/4o2htqa6fl34z8oljEVodQqtw3yCbrujZ90vzIT/l8YX3PwUU3v3SRlr53Uoh3i9tAv6wlcK8XyoFrmjly1Tu+W2hLqFQ/+uuUG+6K9Tr7gr16rtC/Qb84JPlib5Qa5Feh9zykLaQ77HRnoqjKHX7xZcRcmsSnzgGIX967RVp/Hb5B4qG3+dzPWgd6u/QyPVQyJcVqNx63rcO/slWFf7Vt9J9DLCB961lz2xN6upbdy+AqwHXCZwKHATsAn4YWAd8k6MeS+UO531r8/sAR/C+tfkG4CjetzY/ppVOelO6OypV7l6qfbaEzJPS031PSlmgHPqaCsoHvQhaCFoEKgSt6EvrdWlFbqowipX1kcy29aeisZm+Rs7M3p19PbuTeRDaKJn+oLiNdvunhNjbtLrepRViHufXWsO0nrT3oreu0NIyrT+nmIVBwhimsYhpvGP3fYvshTI/Se17N7Yc17WYK9E6rLZZS+I3GANrOf1ah9JC67Xs7OsdZzmOUbjNoWDnX+kxTvHdy/927zsfy4f5PL0zXmv3P8vO2bv9L19fNuJfeP1Xdt2+tRiR2xy627IH/CGgfw3smuVU5+mSooTzGBOtd6jypmPspEi+Btlm03pHAEbWb4DP4X/jLT/d4C31Nt3RtY7Q275d8P/Td/gnOepuqG1Y7nZTkFXx/HaTwmqVthg3mwJssljdsAJpYt8IOmcnVrJzsY20Qz/5LzxlZbWovc0q3UjdbmqHZ1KG+p4tTLrz7Kz/8SyVY3r2/FDfs5zJ92yvvneeLbjPs7QeUJXL91FiFtqJ1gI+tVkYYEuLKJEmmry9kq0jY8Ob5beiu5oFfhhGbl5NWUq/XsPk7iDZXqTCDtB3SPVG/5mDJSZatWUH9w+b8voK5TeOtywvYaRJuwLuPiNfVveZ462nZPFGgdYAcvFNFJoBIgsN0iHr3vCksPDMQnj6+8ODNob3hag9QqRoKH7x/0+YtvzPMG35n2GyjuF709vYYgEznLxkmylinVQw1dvHaB3l6hUQ0KziIwW4At/w+xyvuMKz0bHIoildgnBcYKc2+eZmiuvLFRQa+m/M9yy0Y2L+3+wHyOoKHdvzZN0NvnB0Z+HoL9rpvYGYphBSzCkZHOrbycbY3IHm/gx/0kj9RSe0YxcKrkgnixUNHedz3Uf26Cjxg7yJGqu6WZ7GbZica8JIhfR3NlKv+IeNWu4e5jjmx5ZGXzseAV+K4csi+NLlLl8C/L6ck24Y2/xZwvxx2qgd7WgOY/4sbPS1quRPOvzpB3/08KfXf/lzPqnNn2f8/rA13Es/UPnajc9xVaLt6Ay6CExr/ldXdRCChTHmMRk2MUkakxmbNSbz5xxcp5lu6uYVSumjs6f5vhOzE6KkAuPJ+nj+ZL0hOSOj+3TMhUe/C3fRaLSPowul9aNP1ic8weuXuaZ5TRknpSrOICxzPUvWIuThMSelvRjrRKC129y4NLpQGjH6hPhVywxaccLtdumlo5LMb01EIc8VPsBdtRjVKu+muGg0GzOoTbwpkTxXqBZ1jN/LnMD41ySySnye+cNLJIlHLpDke4ksF8feGj4v1iWXp7lWycly8VGJA++zcbGuEDnZQD0qqfz2TVRGCkWsi5fT/7MzU5LPs/PBFBfDzCHMz48kLjp6XkSMwj2R+1TsLemFoCp6r0u2mX5Uh2pmBYRpSjdvfoTjUocGAHcAkd2RuN53bI9McPj2YSqEf1ZZkU7LXBVeemu8T0xpbecOClChbgTEZAgUpxPi4lZlty4X22zOD0j/RNzVch6puczVxXuePb3BO/X5sdy5TodNmtqPTfy52S6t0iCEsP5Ksu4T/2imfOuZKSvh4gcKCvf6QIUb81F3oUa2uzPGAnQOzGSMWDnXrBZ+AGfQ1PI99plcl7kHv7fGvjK5WrZpj6u5MTJTRrtdlnZOD0Q4PhGfa9knHm9eL6Ub10h9jTLM4H6epSmhc9linz8vVeh06QElXHdVZeCGDyTj6P3ifowoVbv0s23ibIksOlyayUeT1UyKQT/vTvR1P9zw2WTJON1e88eNe+1mJliXzv673UxMt0S1dH+7mRxkfaTc5z8VP2mik1RGeBXCxBqykmmYbRVveH1WMuuZlcxrdrKr+fM9tjIXjSYf2klttjIn8mRXabzHZyvzmGj0/t9sZe4Xh7S22crcLzpafLYyZ4xQariJbbYyJ/Kc/gtx8if32srUz247g/+8tE3fZovMKg5s9aWW2uPLf7mHuAp24h6Vu3ttZX4qjvSfuXd83T9ebY9+jZVkQXlxabQx/YQY1Ex1b720CNzhVpoz7/Po3IEhapsmlisxMBuYFL7kqxeq94lnmqLZHNtnYVh99rz0vl6RIL+wPfcBlMisZtwb9QKffBLXNgucT9Zun539PDgc2YYbdcsyt6T55s21JrQZXFBdmBl3fwabA4fRzH4iH4v0faeVLHPSisRFxuzn6Ql6kvT2Ie1o/p6aOZKdzRTyQqiG0vKzG2QP1+v1im/6bXNSCr3t9aXQv7zbZysQPl2zfrbPNqdVnFi76IbPNqe0ryuzzRkiJFd3MUdlyPUHxFoPr+919aD+U/qiLkRU00lIXjG3tXvW0btsc46u4YVQpGFeE2dod9G3h/WAuN1z7zlGWvN5v21GWj/HGf64ZBD2iDeaW/w2OqlNoHZjmDNUs9lvm/G/7XTuEc81++x0HhDzPWSns8Vvk5Gep/ffZKdzEkIT26Tsprv4ZOaT5oksLpM8H4uhzRPM8tzx7H4Mnt4jvt9MtjFPiE80k53OUebHmCzN85v9MbOZxWOIR4saL5PMzE7ncMZL9pB9TJPfTudw8wHMn312Og3CCTGj0cBsd5FP3TxkpzNi8cDHh6CF46PJRqesQrZhjaTTnRCfb+INIdYU84PMV41ngLnNjx6NZLlmhDXZfJFZ7ySeHGGUC2qrPoZbF5vR20zPOFt/sccKJnZC1QHMseowGi7HaLitz4+rK8eote3O9wXhYb+2tVW76WO0l1EsZj7eqVZmgdRv+TPYzPc7IB5pVfbabqvC2O5Hu1wfytL+Y9SzZ+2UX3EBvrS/29bnd+A7HD5bn5bVoZrSob78HIC8lcDXO302Pzs52+x9nhAzG+/Y+zwgLmn9WHy4qc3e5wHR0kq59U2Tz97nCfEt6e/2Pk+Ia6S77X1S2MjeZ1vY/re9zwOYY5HvO5tUqB2LG8neZxaz93l32bqfvc9bBUmPJY1cjHFD5x50gphJkO1OEtKFna5Q771W4I6JPzZ//vEgoQezAndADGttswJ3QAxqvWqXlUdnTJC6p+qFUb8v0xwDD7Wq/2PDj9YKwx4S8nO7pFfU0py1l6czWr9jYksL2fOc7enE7hrYXYEnnN052d04bxi7s7foq3UZ+bnHxJ8Yf7FXrm/H8tDaQrFObPLZAKU4ttldC3nh/8UOaO/0fWJwK79rn8h7+fLHqvnewVbqlQ1IxR8kGlvKr27P7Y677ySDQPZAYzGiivWPqLKnUXv9QtPCmgi0L4ulNvufVjG/pfv0l2oizV1YrXi1hXr+4+izmAVxare7f2ePzQ332wbVYzS1jaPzo46hNcmJVbjfkcl2BaOXudx4UqrgOMMPtu25ZAFyvUTfLr7HuIRsem4EtY1Njt7wxf9u+593bH4+6bP5+VDqhH9wfcwlpgnWLhe4xHHM5me8derzCczqp6yhaW6b5c91ze6bZP2z1LRt9qMXdkxfwax/Tmhpd1WP53+98PZs1p7P8bXn7j93TOcSHLctgVpaOP226flHd8z+P1sC1aPvzmn535ZArWJizR1LoHfbAXXti1oY0CsM8VK4wjvFxRsSevUxKicZ1DY+Liq/fe7p8e1zY4e1z+KvcjGR+bTrddDVSYYm2x/2SQaVTXZbh0++YeeiO+eHZt2wy+P+tCvi3HZl3B92VZzDro67btdgTPFYt3935eI6SPzrg4ftM/3ycaNtm+kXW3juVrRUnF7zxNcLVy7kryui2757KTfTPOZTzGEC4LMuy4XxpPa72MHUtssMRVUrhPbW1zMLzAWsXXih+fWM19J3ura1vJbxOq5v+6//auHjdFcfy7VkGFAHpjVTa9rP9vJjibntXUHo1Rea81EDyIaplp1v+lLmS+bILJl7WN/IrMTcS2rlN3PNuewfhjR/b0/MjXUFY8wskydmUY4cEyM9Pp/kthnmZ1DPLkAn1zyZPRHXfMzORxuE4+KPHlU3+UXacTrV7LLLd5E1tBNiN/SlKdXE/Yd5FHsisDn4qmLrgYaCUcF1o24VpHEl/Fskn8BsTB8Qm5uM8O1U63p7inBazEHfoKsZJIw2X7HzwsMCyRq8irJNpkDrSH+/8xN74oNWssLar3Ghne52tsbmyt1ZaXsauEcfvpANvBC4YFS/C4+aeyOdDoif/3+UvQl4E9X6Pz6TrdONpmmBQqGkSVtCW0qAAmUvLQxJyu6GuJVFLYKK4IKo17IoiKKFghYqyqasXVLWWkrBFa8XTVSU9dKrwoAspmwzmWQy//c9k4SW6/P931+e581Z5p0z5/Oe97xnnTMiflvoML8TrO9+r4Xd5vklUAscOhfVQk0fQE7l28/vEfs5Uu1oxWpEzbpUPCuleJtHDTlYXJDg6uXobEdu5PxYrOM3ejEP1wXKWAe5RP8VobtjArfNUxLIgHEEpvO2qKncWaA9Y3ZEk/Bi8TdO20JNi58/7ZGVBRpXFpsCFktlPM7R/f6EOnw4Unl/+8ce8YxUlsCch3BmlIHpDVRmNDCJQ1T5o8DPgDs4sxPzNPjLgTYD/QD0b6CrQEnRBsYG9DDQOqBaoINAi4F+BkqIMTD/icbxYao91WYaaxpjHvep52GfCTTsFZ/Jju5MH2XCtcZPPTd93exGiCkOx1z2dbV3hZgHIMbKdrF/6vnNl2zvAjHjSExniDnp62zvDDGjSEwniHH5kuydIGaID1OhTFiXP/V81UA1Ida+MH5N1BsYDdjo9eDWxRmYW0COQQamO4RtQBOAZgLNBaoByjmewHwHrheoZ7yB6QDUF+iVYQlk7EVbVtTq2Fg27uyYkkOk1fiX1+psJL5vvDhT+eUiVU6+5/1FMv+yPK1Z3WuY+7igKd1rzweOfV4VWwJ9wIvQxmyAcWnMRBXRya/8lOVFV5WDba4ifJu8c+pN0OYh3zsCttoKnxP4prk+cfRp/oTwvQtP/KebMsUTzpeEguu63grnh8A51rXe0bVZ1ave/aG9BK+TLzub2ILrTG/kWQ48z7ved7xPWo9HvTrcF0muvObXslbnSkeZ0v/z0mkPN2MPKNEH4xSaAV+cD3eN6cAX5VtGekVvkHox2BsNcRThiwSfT0S+CPDdFl8nfK8Qvu5e7J/Q5GmsnzIthFzRNIaGQ2gRhCLItTy/skd6MUHV2x9TRXUfJSS9Vso+DW3qDG8Pdi//AOZlp65ypoMqPyZoygrZPHYq2KxbAt5zGCxXLBnTTnM8TOrMJeEwF2UqJhJ8lPQe8z0tpTSbD9zr/bqUw9eFhepes9zPltjIHtnT0Fsa4lbKo4n/Uh5/UxMsj0s+3EdoriFY4jGm2dcay0mfgoUh1370tcbyne8OlmGAJSAglhZRVwkoAE8QiaOCs5BcVAgl9UpJN/GL5Ds6sRXycMh180Iq4XpDUJHvlh2upgnn0zJIMl7hXAWc24FT1ev1m7XVHYlOPC0g9/ZqRBBJcvk6cM1wJTviiVbcI6BW6MiVuT4tO2d3B8eNC1QT1iFbsO4UxCj1ZmqMUmdeiVHqyypwsQ4eBPcXIAkIzyhjY6GfCIR77vHcMmM7A7Mfwr8BoZb9xxvSsjPekJb96l1PtMfCfgglywioZce8IS076g1p2RfeNYRvlR1XeW/KvblVjvfs+/i/5GyOMZWRMp8hKGX+ZbDMN/uwzAOlSpkvAzk28f+RscxD8v5nYPxNfVDef4kosR5EYvQIjLkgti7zc2JQf8m1E2LrMneLd8r8WShzDSlz3tu2zGc6Prowk+TiI1nFFtcrJbkscKfMq0Qsc/H8VML1tqyU+ddVCue8AJTYCIWzQsQyF89jme+ruh/KHK4H+aurCq5HkVy+AVwDYEyHY7Z9/IMysQTkynxogRmnw+E9T+p/uGTiwiUT5e0fLJl+IOfBMqn/4ZLxCeH6L+QQvmxSMt3lR7l+jh5wh0l+EHpG20pQcpqUQafVOa/fnFr1dEkv4Gviu8rQuwcJlj5nxPovMvVUWocLPRzO8z3I9dggFltViKcbYLniMjk2nFflvM4PqTouMKVGe6QpH7iflF9K0RB+uUop+09EXUrT7eyqXSVO/gOfuoQq7+BQ282sGuRwPLDo/C9BHUbdlUA/cY8+6jyes3ejnaL3PYPtQxmE64F+bKe0MdPilDryFrj4vkkOpOHZS1uqbnV6LZqNOTPYPsT2ieeETJkG2wdj+yjQxli45mkcaJ9ccog3ChFsfr2TL/L1h9Fdbzvm6e3AFU4F46RD/Gwhjz3ELxVQRzUs+qcLqWy2rZHfKx7l7xPHWBv5LeLT7ExWx273vC3FHYvZFfdl3LG4L9dcjKOWAOGs5VMszpziehLOXW73vCrhF726ONqTp90b2MuB1s0dDOPxpG3bPQtEVUrU2aTtqBlXgdNzxgD9EOQcHsC4zoE8thHqTswOTHG75z5JGXv+CuPMlRy2yQ6Q5SPxSt/jgCmeeQr8i4EqgHbNjWfqwU0gZ1sbHUaSsiFAp3WDvsEnnkKZWt21KMWRYp9h/MTzqdyVfLk+//aBvljHFjw3G2KL5E5tYsWpJRCbL6OUqNUJRdMh9BaGgCuexe/el97zNMT1ktvZTexUozIH9YlnZhPVhP2myZlKv2l0e6Uf0ePreKYY/M8DvQX0T6Ab7ZW1ZDptbS2VvqFgIbuc1a5h1qwQLPm6M1tt+C1lI9uJtEHHLulGnROaFwHVQZ5fhBw+GQHj4SmsbudEGA9j7gq7qN1Uz2L3WltW89S8GMuDZFSVNTkqYvLkySxQbhfqrNCl9DeOMmm2R1Q0wTgoylTru35D5Uug8FvxdJ5GpDzawiT2RpinxK+pTJ6vZfELi0sgT2NkOm03R5k1ovo63VefNepPlVZwHwjzTyD8b9b1rf+0ZYq6si7/+oVJ5QXbTr5oaw7zDCM8S4Fna8tRwvPR3PKC908+Y/seSvxf3P4C+sfZtqPcbLB118WYHTRo6ky0e74x1ydYYewuxLbE0UawgVrfeiHOmuWc5phOSr2jVMNNBV0eD/0EOpXZ9jk/G3ov3c7SptiWdjRl/JyPh3quOfMg8Az1UmnjuPVCO6vac071YGa8S52ldk3Pol3PZdHuSbar3LjMmKaJtom2ixw+t4l3yT+BzSH1X6htoSJ1pwrZIsdI8uRT/rmcdkfBbW3qEd4L1iXfOcoxjFw55rexR/gKeRpXcJtJRf8luM44hzmuQS2xTMSYZlkDMYMd57nBkDOPMJAdBO4V4Sj047BGVsPYnI7CMxO1lYWj2p8IoZOgHe7TCt0mQJtyxgT3fi9guo/IZy9EicyNrAK9i2mx0oPYEcEnbpXznNQHhWyqI5HkcoF/J3mj4XsikdisoW2kkWQ7HpTBOLkBxgf1uQamq8HAnIV65wGiwG8FwjOSJ4CL+u8C96sE6N8DMYnQNwb3J088kwr+b3zQbgP1A38h0C6gb4GwnsTDfb3ZNMAwW8A3Pqju2sqGgs5hzIsBc3orzBbA/MZZJdcprXKd4E60LeAYMQLQR7twl0GfMHqLrHdS7w9mX+foAT8Ekf0n8C1oaMFtmpRRR5lxah1dOS3kwyJobPdxzYkKlmiot12w7ir1t/BsbVc2jnVfohNmfLSQ3XhZzVjYBLY3293RyI8QXinJcPTurGEtSY38ICGtKN2W7sC3YZimJLZ9LlXWO3lwiaVTI58taEaa2B7s4xWf8w/5NsCY7FmPhnqErKoVsp0ceEJ7I99JaCjp6Pi0pT2tbWlPNfLxQqZJuWeEL9Ny3t1Q0q5cte2YMKS0hh8aaOdQ4woEe5CX5IQgX09fgsXtpoxu7o2uBmYV0OtArxbFM1vArQf6DuhsVzyfKN4eD/ZzjV9xPwm6G4Puej9t0hOfRVLc1X7FLSMufqf+E8/yg2gHz4E+PNBJae9KwV0PtBnoA6AzQAmdDUxHoFlAc4FK9iQw1zorc2MqVmXXGQEP2NbRHeMZxinzt5rmjBbISfgJNjq1I5TXmYAmJebU6HoL+Y6hmY11xJK7TPKzHlqjb+7Djr+5aOoRPiugS4k8hVyn5T6slvDoZVyRwXWcf3QwMEuBaoFwJaPnpTmFOnZ5ra2kPRvDOgFzAlmXcHpUUilrLHkL4hb78X2XfNYO/hE+p+eYTG+nykrYGj5Jpnf2YRNTscdxGOSe2IRzSJQRZ0TmLMb1hTW/ZFyMzokf5tn7Vq16F64NtGc7sSY2GiztERn6PaP7spGOdhVHUw/yyXK7tRpWxeK8h0NcUoCpaSjcFeVpdCcbmN+TsZ8QPf90xFsw1oyBlJ49XlSS5ziaihrgD2SABmBrmy1mWNREu/DO6U/pys1Pact/n6kp3zwTz8hfZlXB/xIrXU5WI8stjt+fVdI4FXghmEaU+IIlgj3j/llYbdUBX5lVW26GFH4W3rGqy6fPUpWbZ9Hlvz9FlXd2bH5KubshMIhV7r7sfcFyCO6tsE6b+deNxIWAEzj0DkS5LTAg+IwT3gGWne7Ns6KDCCoDHYNXvvN2tHwEOvwRpzJ+yMV0MTC9gN4AOg0U0VVpV6tqK1nVqoKiAgdliYHapmepsgGV+Y5Y9uylPPog9HfziDwHV6DdXFLwlPuccLOMSsu/Pj0ptsUahe+gUWe7OI1sT9IGl5omsoMqjuAJ+5aJZ99kxru2XdYx3VlV5c4Czc527iQ2xWSHki4WB6ztatruOShk2NVsEsQ0eKOad45Kc+N1DI8Xu5oGrN3u2SmoWbp8itAdpNzFkRXMV3fIl7pMydf9XnUlPWBxQRKWtWZ/AX7B4evTTq7/uh0F0eEndg8+cbEAvSr2K7BiKwQ91HC8p5L8fwg2OwPkkoyyAZoK9AzQE0APd0W96comzH8oYmkt6mAi2/k49oI2PHcEWq+jqT9fGtIH+uMTI+30yp8FSHr+xM7USuirP6lucdKHb5TqZZ6VI0CbVEYfJyeH0qtsk17+9X9B/fuEpDewVXpX/iu9fEgvJZzeVaU8R8Sxy2rju2pZ9Y5Bti747a/AKyW76wMl+AWYFyPVO/uBnhhBT5ZKqWxpsJ7sE0pH6YiuM8p3RTP+5KicsS48sa+GF/36jD4wPkfOjcKbBX+6I1r8arq8AfrzaY6I6+0TlBQfhRR1wRRXAN8v7k88171dwLoq18e1uv4aXP/a3aEIRwQdi5Trw6QMk/KUZ4QMy363ocgQzGtvqWPwylSho2UH6PQOLobkbZe/Q0Yth/U6AigdaCzQS0BVQGuA3gLaB3QYqD8Qvh8XbTvCfyNrU4xs5CmZf0rKZBli4T72owzyGmW+WNKQmPf9+MYX2rtdSQbGlYRl9nYtbVJt15F949oUwykr2cm9s4vOnUbuedWPqwyexizoNZhIzDz/LU5d+Xa95sM94pKbMyJxF5rZF5FiJc/PlAaxnQjfY/7/cFTaXxzu5F4vMHpqZaMQZV0vRBrp1fGEY5z/+XrtDvX2OLB8IyV8crSk3RFDruX709kjHMatkPV/GrV5TelsPYd5DtnrCKDuQCivaeDO20uZcb4t2UaXR0CP7JgPWwdMoRkloW7v6EBSTiByMTavqdfgFzvoIzwtacA64np2k+jhMlmcITzCO3y4M5EuV7gw5i1ZY2l2o2+nSNXTFSqyL+MkPPu3DsF+febS2oXsMracXcdS12MXUib1dpnf4tel3Hf6qLGW3+qLYPE94tulUNPm1PIf+7QkfLkURx24Uy/OB1fm9iD+vX5NytBTNvwGoN/Mvuh4ieR/tw9rN37v/LqUB/9/Scg7DUanpdePlSJ3ib8P+zThXe97px7fIqU8/yRXuAByfUn89wHXDMK13IfhsRCeSsKLfFY2QvkaxgeanQXsI3a8vtWP4+Ex7oYWOm4wW+TGHcgo3dOSJmX/6cFsKOyDcA2E1Tt6QAsp88nQSm89je0AhrYBpg2nLfNHRkT/bJm/MKLjz8ozRpFnvADPWMkdNZPZudLBbL5D2+IJWptCKM/Fp/9odXUQXP0jaDtycTUi+8SpuVzoueckzO9Nd+jJs+DJ8u3pNZb5BREGePbiiG4/38n1fAmv3ltzJ+YD6XirZ6W0yklARN5hNWdaXe/YKi/XyPWcmh/ADkdrsoP/VPbwmwNrqBymKYNlcf1IVwR2afhNe81wUif/SFJ0ugP0jQYA/ev9BGadPp6JBX98p6B+WS7XRkA7rzsj8z18dLqFnUXKaVzJu3YrjOsrA8b6d6A2JQS0rId7m8StDCTVL4W4S9JNbimJWQZXa+tVvaJcNBtl2lByiB8qGZ20hXGVFiWX/MyVOhJKCj16dUKx/O/5qa/Zqvm98mvkzlkBZT6sfqGK1W6fC6n292lTGk7rKpPrI1rZg2SvLoU59RRc7+zrwz5LtOoBcSt3r/NxiNP74nbMInFjReipaSu5Eoe+ZGJJ3E71F2UlScWZO3TbkW8Q1A69E6SnXc5l7pzqSEk1bDvIrxS7QqlGpMZtO8Kf9sKYjJFvv1IzHvj/EON2PEjSTRWxFGmzHWL7AtrR4B4X71Hqv4jvTI1bqDKhXhyB9hbHdapTUCKads2ZrBJb5IUxAVjWHV4NWMVa/iNRUzKjoB+k4xQ3d6E8mQup7HxPr4X5JM1L3nQ27T/5ps7bj/CnxHyLkVW5YPwn/MYd4dcI64US6wph6wQ8yyt6YRqk8Z7YeUcfcue/vMz2zoDkkJ+2fudSp3bedlZI23CEfwYk+MXpzCJ1+YjrtLlK0FsZUz9z5nb8FvsRfpvIWCJcBkjpKVGxytu8H3ERpszt6m3bPONJTX3frWKTye7f8wINV9D3jkhDH66nq5bvT/BUN1NN2D/Hvvr6YN9cM5kyJl6lmhM7Kn1z1MnR4J8M9DjQS0BLgD4C+gzjQW+/APe+Mc8+eRLc9cI2q4kt9NBqfPoKCB3htwiDWCUHnJ+2NLnN3ZVv9BzhPxAY00ziGwaYFrNO91lyRtd97hDHm8Ik9qeOuHdiJjuFxHzlZyzr3Sqyt/mcYN14hH9eoMw4wmLPjr/94UvjR21rGs+OhR7RDuMKYad1EjuY9aXGtlRRB/m53oYuVIs2Wj1yhbCLmkJyVUXyuM6/eNTrN+fWyL1+bhoEI4fSuZnbUROuo35Edz2TCdLe7a3l13qnsOoSC4yga/irgvItLWbA4F5r3Cbg2OQ1kSvNAuqTlT3Mr5F/vzAliL6EPCO/Zuvl6Aiq1/bL0ZEw2lV/dWYDhyOWHy4kkrL8XMC555fluAsmVmkp64XvL8SRGrjDT7NJ9RHwpKX+mAvRJG6Dn6mnU29CS9vNC0/V3jiP5TkCyuUWlhe4K5KU8RWOrSxJOG9msVtsWzwbJcV1Bt2qoLs96H4ihfjotO7QvzGx9OpEszr1GeMWz04prSjNQa1Os8+D0E3JbE8DzneC7jLJDP/lErUaz/M326cDz2+Sicy4zTBDT9Mj955tRL4UiFOZ6dWUqRM7B2JeJzu0lHW53lnxzC3oC+KeCSYF7CBQIlBXoNQUZayYCy4LNAboEaA5QAuBlgFtBaoBcjXFM7+Ba+0G/SagR4FmAK3ppvSh6vh3ZWbsl5coukdJb+gXQN/Otgcsg6U4r9HEqm14qu8e/s16BupG8RBy5t9ovemdWtocAeNR5btf0LvtfYi/z7e5SFd+TvhjEdAqoE0q8wqhi1WTfmcvSx6L0isEK/Jm6TOWea52Z6ZberhmW6a7ZL4P7siwdmvWpl/gNOl/cOr037g5lpmueRaPW/2hHXomh/htPspyzTWR+DeB/0/XUjv6PwT/BUhDL9PGGPLmtvrDReTKe76kevwKWCdrA/cPEvOmj6lXm29xr5LQ6xBSma9xL5PQfAhpzBz3Egk9ByGtuZl7noSegpDOfJKbS0LTIRRh/pF7loQehuc3uRnzPznszagrDvHxIm1Wi5RnhZBE/SMcqxNXCMnUi+FwwAsSop7h1oOcVFlLmhSJqSobCipO3S+Y8x8kqff06cCqPeG+3/GA/ZxQtvD+8Xv5Tr7erN7EbDvErxVluMtiZbbh3dlW3Gs+3naI94DmZrBUuk7U3mC2IccKIbN4hdAjn+4n87ScDyn/W9L0vObGefGTkpKKOh3fPEb+zGJozwN47TuJhMtk/gIJfyHRQ6+6+9vo3EN8oxSZ/S93LjzvgNQ6H5mQjx8CvRyZdgu7l/9cXC90tspZKpdmm8x/EaCMWVwPgq1JVMqns/Uql05i9on6eghT5zkTCVeLWEJXOSMJbVWuTviF60rCH4tYKv/mOpNQBVl38lVHmI/DGFBmZPWroPvXhscz20Hfq4H2ADUAfQ50NFgfsI79CC7WuQ1v0lR+rJqcT3elm1LvugbrGxusV1inPoJrx7op9a00j6Y8e7Vs1W1NLH4FMYbtAHmxSjjOP8zrAhEpkafaw4hXbWxv38sPEWljLHB6Gtn6PrgiNvEw/4Ckd2ax7RxXcSVh2kzQ702eE17KojplZqMcv3FPAZ92Iq5dFkhKrJasF5ziWhCH0cBQQJ2A+hpxLks1X82anO3Ifoi9vFpsZ48Bm9Tdh1++3OIZ4KNM0STmc4iJBjcHYiLsEWQWa4tnf4Myr4/poi36/KqBmQj+N4A+AFK+yxjDqs90tOHZiR2ax5W0J/b4hFfFLqtX96TPGGwt3M+X8EsXc2WmnjLOaYxz4N67vfxBL23kuVjCf9g7AbgvnqVNCu/DMmW56IpwXOIibG5u5ux48uyP4Jn1RgUnPv97oPNGPDc9dkwsjEtTWUy3zGtko+2ASaRMUfYoQHWPL8oWZadMWzzjfJE2XLPY4vnmM6rpcyhnxIfY3LSBeTHVwGwBWgp0BCj/dq66okB3QgN9wsUF2U2UEc9UwDMRqKYuYAfVlnl7cbylOTMA8B8Em8M09ytKnj/YqTLmOvpBGTu8lBHHSGNK+hC9HONdVt+7KGlO76JtJV2Ko8jaFCXkFCUVb7g1dU7trQ6vJ57Mtp3gsgl3P29SfXoRbeo85wJnITHZXn19apHKdItLt33FUakXS9LGbPX0COBJwrWerIAmx1icOi7KhSlbZjbyP8pWqL2VsrG+i62Kwy+o9i3G8xZuBc+qoKHkNnIdi6JsVFqXOUw/HMHTa5DvHROdupf/RjCyH3FXQRZ6wEuZoL6AzOT+BsaAfSQglMNAiO8CVAp8qeDGQFwS0DjwTweKB3/8C1pmzt7ltTEs7jSnUo0mFdis4ULUDtpcIKSNVeXSfTcXqFwmIaHYyxXc1pM684PP4lT25e6FHhRtjCLjzVtGJR/83o5FHR3JJYaSHztHXCvLPICnH1wrG4T7vXQsvmGFpxHhm+Mdr5U5GgsSXdoWK20i8+HYL9ngs0Hq1OosNsIRAU+YB09Qw0if7ncR6pSX6xLEgfP0+Dzcu/dubaqtHbubTw2odtCApattN/SvcS79ED/Yh2eQ4P7j3ACeQjLY2dHRkeg6Cym3g7xDPb+N75kf5qf5cDUk3nGNrI9gzIMkJtZxnqyPYMwEEhPlOAM8nQjPaGhfTrl0jp+40JoD5qv12sIDqYbwebwrx62yvQ0tNJXad4525WH+Kxg/qt/XnnqnaIVjBeRrDy/KWvLNylXyOeHhTXonbV4uUNaPry6N0q79+Oqby89dfXPdOcFWt2i8kezvxy8J4Lvkxy4x5rjrzZ1OXqLeotLXwT1UVr7np9KzEJ9QaHYx2+r4Jf5azx4vfpW41nPBW+s544+8VhZVx0/xwd20DjjmAcfmIMdx4PgOOPRR6p7tT5y7qPVEdBq4vg7GvPi2w+/cjLGPO7JKBrIU5PpjObNEuxZz9EuATgdtLT7EvyY2cJ5r+L4etw41O/7slKKkklrPRC+uo08umgx6otxdKtfxSSRVVTq+ha6kdDJwiptQlDJ/TBF++fj9hnFFNntySWTJx1fHLnioc0irelxbugBPPsfzL/Bsg7xrGctDX9SKPIPPx1NGb177lsT8cLxd/f5r1PI6vlkcUDQEcoBPVXIxVFanN3F0jt597uqABTOvdV+wDziXXtsWde5q7gJ8N2+np7uXusYs/4lT5bjd+EVnCqSz0xPw4xku8Bx8KwufDnckB89HwW+JN3C3yakLihxWnKXNU1h8JpbsHmjvn8B3OE4raz6oU11F/P/Cq64EbZ8T3eoM3hVX927gv64dhnUf16hwHQv1LXTmONaPuFSlvqMtMKcqdgHrDEUtGDkQwqfjvs0HGo42YFxqaL1a+Z7GHv6zQHt7om2z599yor09uNdkOi2R9JAjgj3kp42bPTzoXRxZg54BveQ5RuSLsccC/y/EVdahN3t+CK5DH8tSbHqVSWnTj4NLm8EOmZXvNqeC+yjQ63v11/RTNKyqrI6PE9uNU68hO9ZLnnM+xUZDvY7zW0AzreRb7IwtlcVvlWugFmtgvKaG69/4rMVXoX9hBGwxkxOZJSacT8QTZ+7s5v74auHywvHnro5cjqsTZPcy9IIHQS8YvxSyxWMRCrvkkPf67zu9u+CeU/cK5uKBtt5sI98/QFnGu3qzA2yNvJXMOgwDXem3vN/Yj6/mkFNrUW/XyxZoFwJgp1GX8du6dC7utjzE3xSY7MtuKq1j89MWtWuOhXFRxnbNSo+zEUaQWraeC4U8/hkW5mQ3aMV6QQkYWS05z8HTiOdjg1Vdjl+T28T1ZpMgL39KGrbCSRllvpP8A/fx1ejlVFro6feHn74Xnn7D3cRRPf86jdeU94Pc5OyjbSAn3HuLZYHlgPulsZ+1LlhePS/JI7qy7YtK2aQSPOO5cCa9I/86PbVitAZ6UGY2zqEn1qtSCn4deyFdoVqnXntUoKiYykHFvYvrfJ7rTt+NlsxilY++EbUuoTh6XWFhQjG0o1BWS+CZcdnK+2HTitbUdp6vqdGxy9hXiic5H3MUk7SfllAOIwc04nlT7z1c1Hn+WpbKHOXG99P+8mpYpn4y9E7UJQ/Y8W0Vc0nyzAQn2nH0ny5JcKqD/nPCGOdDJbiuQPXGGCr9FPTqtnmc3u8gt5OdPZ2zuox2FJLa0Fc6BXGW+pGOgxzdT9vzT/dtrnDmcEf+dR1gNzqHOwYSvm4SbX4LavOQosHFnUui6gc7tnARLV3UdHlES5Ia5+OY0oiWRHVEi16F76JHtDCUzN8row6tdo//c5k6qq/ZE6GuuqyOjW3RRy+EdmxwyWczk0rs7FbPBXkRWySkU/n1DTMzHFR5EZtMJPKH/wXOmJrFmhzzkxr48d6JrAW4e4OWak5RZREtRnUXkEgdS5kAhR7C1FaP1U9Z8NvbyAGx1vaOE1zDTLrftlFrR37lNhQtKPlCoEppc8IcG9QjK5TN4xlK2aSB/2Xwl75fQa0CdzfQT0BYfpfB7dDdwBQC3QM0Byh7Mn77PLZoeW1yiao8ciddzuyk0qhy3Y6Indrtmm2Rq2X+p0AetPf4rfM9/Gt+3KOtb4ys8HF477o7OjF6Uy1+vV3G79qwgvOcsGwDlXGrbvso3YlkWwP/oUAZTWRsaWInC+n6CWAXVgl0Kvipw3wC1OcItrM73mEgUrP7aSPHlfYrNam2Y799jLfUwrs+KdC10LpIF/Y9IqHvgZy5/ksclf4nh7vU/IGvQR4dEXO6kq8r4O5JV9r2L4L5Wyrr2ItOqru/biPkrTfkbRzkrZDMh/aBvKXpe0LcSEENeUujmvivZPwuU67b4uhBnujzYd4oshbTxN8jbyjQtJRG0y4T9Eomsart2AMr85VaFrG0K8XxR5hzGHBecU9iTYTjd6HUogKOjtArMW1XbdvqKRMfZvXORMd3HJWGuJHLJWA6R117CiJa6IgIF/W+mY0JIt/v+4zDdBcG1nJTAHNaK9z5Gcpep6MT4pkx4L+iyGB0GTmHLN8kp5aArUz2nRNm42nCG6j0K3UbRtEnYBzU/ABIwMZ+xn8hg49SpTbxI0ECGraTG99VaQdasAAkoCdlmd8/34TjrcN8R18+lFBvFr/Y/alshHz1C9D9fuKoDLT1oXw9Afoy14x7uGnL8lo8o/H1s+NKJsBophF6chPqVdmdmjamaKHmpbJFYFe/Bav5cLODXLf7bG2uF9pwLHyNKyRXB911dQhc1cjnuKHkahb0AAe7B8Moo2/9IMdgIr+OPjotp3ng2Kw7mh/We5mfDE8W6vs4rIBX5dOs7W37jB8ka9da8bvNsm5tL3D7yD1KcsDNkaEHZ8gGXw/waRMeLHwrKhO/2yxjbZnTaCF5uCS2zWEC5LCf/C6Xau8IbbLgM9oN4DL+bjC23OzR+FOIS/m72qPB9fu62DsQvmT4V/thfGNHX6m/EuSL7wntiaGMTpDtZ2bl/SC0BUeC9RPr6gnwXwSSgTqkgT4AFQLNAlqYpoxVl4K7AcgJ9AXQaaBrQCOg/Janh/Y5eEbTltW17diYMza7HfKwzWcDD2Xa7BkI9TaRaAYLLX2mMOyT45eoURGskxelFQVM05KCTj+eE/wbzgmahThTkliVx2oF6/oe0PvvJ6wXjNZ5TtWOgaBFu3kzhBOtfaHNVPYTNfIZ0ilOnTqnpIn3SaiR7V1Y62kJ1922eopgxK8HizmvxOIwE4ufIaIetvhxZmw3lw9loJW+4hoFkzWTLfRo1TCeYqsgtNXTB+7VnZpX0tnRntwZKf4HxjJN/E+Ap4l3+VXwf8yP/E38aT9N3F/95PQz4KFSGXYP/y152mf+T4Pvgw5/KZm8D4py7QplgHv7asDm2mAMch5cPxDOl+TthbEwGwX6EhWgzPgeGmOr478P1PELvDjD+LI3lVWxGrguSpQxr3FuDwPz1UIts76H0uZrWQb6SHV8e5HqOcRtBJ8D2g8jm9g0P8OYUcebRcoykcTrRdzdkJVuTMeQ5I1g0S3ylxL3A+9gfNOwFM9SRy3/QsLYRJG2DHP1/WlGHr57MvoExkWJWnLHILEH5CwDeKukzs1Z8/UCnfWdk8oc6trcMlXXKacTW9G0ucVILy+g3XS/a1xmVoR71nwq65JLeZ9sD3+fV+mJUJmieyOXmV7HqbZjyh/7Dter1iZAyqXSVU5N4tb45tSrK2o8ah/2LGPh2lzpHIdXPvfSIL+LXCobaTsPT/nZ/QqUwdMWA1MDtBCo5YaBsYK8HED/hPBZC/Y536jFWdj2kMJz3vG35XkVBdBDcQ9mR5M3ffbwOq8F+nSexjp+pbfYSVuGuvBpb3tHOIbb1Sxy3BLo9CscTfI3yof7mKn0P7gosN5W9iBfLdOV6rKKgtPkvse8J+rRxbNVE5uMGVkZRIbe3iDDnoAmWqLXog2JkBS8j/nUa3tAWPY3cJkZF4NPMZCV3+/c+IRPPd9IOIdR4/lWWn+VXqAuw55n6GubG8hT07xJDeS+Nk+VBXyqHlJ3+WmQ6YMiyjQOwkf9ytONPpT1WBKPunnQPx9y0QxylYLynAiybA/UFag7UD+gET2U/RfYm19SW8Gihe8IqR0RFPnqWJ17gMPMDiDyvV/QN9dBS6hh80C6uS4rcJ4RejvU7DVAi6FK0erEHqUmfEKl9vLSCDotyqTefp+gica9SnQl7r6Jdy8G+0Kl1RR43FT2H268+1NBX4/uagH/3xBOcYsLjgLPFU5FUp8N9eEH98dXOyzHVJUUP/V0Dcq0m3T2qmpBBIweD5DzlPGr0coJHrbguZH4tN/d33AhiWPat7i4oHwywF3T9Etf3Pe3tDaGjTJpth/ktwS07DtOJ39ADmlcrDuL7QXtjNq4G78zCGjJGvpiJ79OvsLV8dPFYG3ubuxexw8RbKQ8M4XW5dlRUOrw4+JCcJ28Uz4GPcRjl+iyviyuY3eCEjztQ45sYTLIugPRjQyBZhPhyve+iObMDHxTUbu9jv8P9tOdVNpnnHYt1rIm397glZ/Jmywtbi1oRr4XNUMH12t8n3BsEPN0i1K/QnVt3l46VQNW0ezTpcScquY7+mMcuAMed79H2Xfz98k0mekDO4PvAwFnZ7Bi6lPUGuBwXAEb/Bd3qIeS9s/gDtirZeNtMYCwQp5J6mKczcmvkmnI3Rve1U7sadXxD4kMxC4lHAe9OvAvJBz7vJRRXWuFp40Wr3Kh75WH8ugWlTx+5WubR3U4j1/5lDwe9f5feaQtPJnfzb8xaeH4khX2PLAElwMwUmpQ9UxzbSkZf/P0XB1pOSrEiJRoeOI7viXBJy4mWvDPAJ0xtrk32hR8OxE434MnjjyF91yT8LkLcMzAd/GpoTzyXPMdL5D7qgO/cS+S5+0OQF+qp9a1oYSctZIv8+80gQ0Qee5Zcn3zf13PhOsquF5CrpdDfucDR1LThpI6/g9vHX/Ti+82wfPgOQsCVhZn/B4jvK8Bby3wGlxbSx4iMc8HbPXqnuM9NE25msNPePsgrmDxHM3e4iYRvuKACu7U9Iw9O95unHmQn4xftbw+KRJns0N3ZTfyLrtjKME3LDCXG03uLAyo2WJ4BnN2Q8mfKXh2Y4j/cONwB8cNJ1zWgAVn08/S5svcEMcZbgiJTYf8Kui3w50MVccXet8HaQ71lnO5hCMxQLPQV+vZpUnhCKd9qCe5rgnkw9V2Ljr1jvxiDnUn125LuM6q6tniTnNs5tJI3BUJV6AcblVPPZQ/1s8hAaX2q1iV28x2caRA25UMdSlSnMh1dizlboIehXTKC27HTAOZy88Btx/QEKDHgKpN8cy7MVDX6gzMDAhv6WlgPgL3ONDZTGXdJTHLwJiANL3ANoMbf1rPoI0aDv6HgEbYC2ybPAcCins0QJtG2EeA7x5ZcZsgZoh9KPgc8jD7cHD3QUyePQ98I+Qh9iHgVkHMYHsu+PLkQfbB4G6BmEH26cZNnluEeyDEZcqK+36ACt6fKtOmAcTXRVbcZXBtgL03+BLk/vb+4L4OMX3sPcEXJfclz3gRUuxr7ws+WlbcpyEmx94LfELASu6eAXdZ7Vbw/RVQ3IcgJsueDb4LgZ72HHAnQUxPkvLZwKgL2E9Dea/IUmS9N0t5h+RUliL3m+BiuURlK2WQAu692Uo5PAXuYqBGoK+BsEzOgSsDJfZUymdMT6V8lgHt6qmUkSpHKaPO4E4EmgmE5bUrRymvb8FtBrqYo5RhVC+l/IzgZvVCW5O3N+vs2JLOdtz1esCvAd1bCLI3snmNHUhcNcTl19PGhZ5Zga/4V4Qx1s/49fI1Tm/XA+7vJD2MLjZ5jklx9ihwv5Xawf/PEu5OOMPhXXlwVzG5a5FMpf0I7T/m9+OzylxhT+jX9oV8sEAlvdA+4zzlWMdY6N3t5p/wj7EXQXrLpSL7GHDXBd33g+6qoPuuRJmKCGengOK+ATGsfTT49AEcY1BpmzyvSLYiqryPafzNo/Po1TjLORe0a4lUaB8JfLODbknQnRF0i4Puw0F3ctC9VyqE/8ekQrI7IZUdf3PBdJwlpdM3eaZIw+DaRAnjqTVDilCLN0iDg5y40oNv9GzysNIAEhdlxtgnIWaolMn2tU8F3wKpD6TRS+pTRK3p4+hjnwFx/5DwqzEvgm+WZLVnso8b0XpY8zd5pjcqc7BjDMo47CLI8rE1BuYGuDcyEhjaaiDnPvQEdwRQEdAUoKlAC4HesyrviW0G91cgGSiit4F59WQ8kwJuWnvQWXBv/gX3git9FM9M7a3MG34C7mGgr4GS+sAz+tx57+jXPsq7R137Gtq8nzQKwvcCWfeqTG+TcTwNfYyD/EVfUkO8aWMX1baD/HWfapuT/9KnWLo4F73dye+W8G15ugLPn1Abs1icT9jNT4KeyS0uxqHaqbS4Dh9tvMpRJhwLHOSHiqrKZBg1/OHKYjWOq9xLkIdakAvK6itwz/W6s3ZzpJa2aMuWs/QZyriwmeqOJ2VFvHTsUsyAc0LibqDyHWM1H+DZFcPYA6yuPBbG/A42ZudEVluxySP5cW/FutKpee0t/z5Bb75HMHqoJnOZljn3rpbZ+Z6WWQG09D0l7A66d1Nk2R3/gKC/sKwtz0K4lzZryg9x+NZKA3dWyK1dYp8MaF/x4RvUD7GLHItIHfpSXAuSiN4eWwH12xtlolPvvIX1sYvOo0XKowu+haVwfeKNBnlF13ezRJ7EnXb9AtinHBFeoaDNEetwb4WqEGRjfi1831vkPmipsobfnFfzuA1GwGY6lQ6+u8X+qdIJ7ie4HmxshQx9ogi2mHvEjn4poCubwsVUateVFzTdLqyZIpjLNJW/O//tvN8x0Y79hWnivbZ6vjJwr4NKo9O1ouZG3wL8WrDWpYf6FLmqnl8RiFynz25xjwG+pQH8VtshPjKgTdGdsjseYvNJ6z9cXMe1I29NHeIfBT2yOgsdA8mVPuJIdgWXb7eB/PqLw+2RZejrDWOXvAZcJ8S5/lGSip3vHOjoSe7oJFbx7sAA6HX1IOF4kTZW87NlXENE7hyJcVodFzlNJUqjuCbH0Q30MuCdwvUkT1GL+JY9rgUhd0fghuY9yG2vyYAeSGTl2850wnvVi+fw6uBa1OnObMFtNblH8ic5UxwfcSbQfCpnmAvXOHXkisd/YHeSYyX3LdSvN4He6avo+gZwDwD9BHQGqIMtnhlw3cCo1XfelcJ6j3YD1zXxnJ3Qe1NoQ0LvIqGd4OD+TrnKO1Qvgp8hOb9STXUfxoJGRkasixR1NxIK4l26ljn0gB0jgnLZ5Lc6Nzr6shuJ1F70FnADKrsV0v2NOefdg8II3vNTluE3v6qu5CqIBGbD+Jyy2Nzt6tfY9l2Ig//dF4ymPLARp4R2lQPKB0CpxpM75/otzncdy0nqo72bLpwTnt90TkhaRaVBrqLbVW4uSDwZHdaf264BO9WXR6ofK0XJ/+WiPjCzk8hZg7t5i5eDvEXXv2p77QKmryfpF5AdjsNvvlStZl90VEJvGfPXBUpoFOTueduTkLt5thmQOyoV87c8nL8Ecr/JzzhnO6o58lVooXSlhv1/zdcZQcnXw7beJF8Gku5tn5KvLMjX/Y7x3P0kXy4Y4xW5qZw6F9WLPkWlJV/QuCc6CohdOCCE8pgXzmMcScsFaSU5bY48kOIWkOAQyOmJsv/XfC4L5nOA7ex5TLsdSXsTGXHUu/o4pAt9SB7/AXl8xY37kYtr4upzbF+fV/LVwF+RQ/mKJfcu8THO7g49yG5X2TlhZCmRXZSSp6j/M08OPAEQ+/8kT180dLSVn6eaBuUq9QLbtPvBPwvoTaA9QN/nKm3cQ+DOAboKlNwP2qt+Sls4Htw3gRqAjvdT2kkvuAn9oX0E+hD41RDeCJQDYUQRQ1CkBkvq/qq9jh0X9oIMGni/jCc7v0ikcLY6rt5pKzyvYRFZ3ElNywQ6DxGpQnWI8umdZna7o/w8nYujR6xvnzq22nPKVgiHy+r476Cfhfd2PBlJpBLv0oTfxsT7m8V8uP9Dxzoo3zp+D77tyfwD0sKVBjo1Z9shnoH6ZzlLm9K3U8ZD0ANcL6y23nnXMdkNVrg7PsFwMoI8ISYoc3zOumWh5+wS8eQPOvcSt8jxOthxx/n829f0B/npogfs/y7uNYL9H3IE2dl9qDSnfoEN97jT3YewX/+h4E/4G/ylotU502FmnyL5v1e+wNG5FznaTKXNcjxuXyF8aFUZ01fDGF3WGg/CmPWJorjvYlsORL99MY7axG5gHxLSyqY5HrKfuzpt+cdXp60rYvE0G6ucaK733bihKY+4VrZDuPbkgtpr9uVbr21bjvPMtPngtaPL261zjDKeVIuR1/sUdHLhrE4C/NNxSdf0mUlN429OnRsJElDyqS0/xGeJ2kqLs4gd4djG5V9PnPQXh1/rOE3knA5yvhfa6gyQcxciZ9GHbw8TS8Uo2Bki3di/la7kZaAU3QR7pqO7HTF8H5jKYX5i3JoKPNH6IF/l/awlMW7NSXzbFk/bLuPyPCq1yo3z4VfhXk326zdfqmG5VFIWB8g51lLpg2wKtKO/i3GgtSqitV/D0zo7Jp3XQ4yGxDRCTEeH/Xw8xESQmD1e2+4ER/75x/sr/UI1uPOAfv1B6Zdu+CueGf5bPOkrYr16A65tgL7XGXApKqaAKt00EvuomgEGRg/UB2gMUELYAiyGZ77iiDvfJWyrFkDMSw7d+diW1UwBG2oFnoXYeQ7fH1DqkQ42ZHtnQOwzDg/EnomaBLHtSeyDZLZqpuOPPz6+OnO5JmMx6N1Do+wno0HvDOF2i/VGt9ARlCXPPZBtFGzGx0A+95A9ptG++MrkP9VxnZr0ax+yxQHV86yYJ+is2vIuO9c9pFmVsLOvoKsd5NVZQ/tZnry2DPdGRVV5GmU8e2KgoNNTK89e0pgfZLEHkyEWwb9ZVPVvYPdzD7J2CHURebB8QxYCrTwn6DdSUAMbCl6/3WdnBLSwd3LaIujI6REZOw2VO50D2Xy2HvodaL0N66JJm4xroGoXnmxXz7d4jTnX3fgV+SteesBxrhfRgz2Sjr1Yr61UZdHubMcDf2TbTwkM1cBvk0rraVPB7c5EcgcFtGPXd8A1a5ojndTGFdJ3f/Rhr3Imkk4ZpHOApHPalRxM402pmKSRTNJYR9JwkTQ6OM5wfdgWDvc4+ASZ/+ozqulpKP9lQJuB6oF+AOq43513AVwByJBnYCx5Sh/m6TxlbFOep+wb3Zan2Hcc33wJ/vlAn+wInvtnfqMWv96q6ndOOFNK9lK3xETi6SZUGZ6/mMdu9HQgq5YZZJfIoNMNBXmnTPb7BTNgSJNs9XX809AXsDjVbFdHCsEeJ6kquwQ5EqSLwDEHOI46kxxqtj3hCPgNzdOyoSy037oSYfy80ZMVyGQN9mnGjZ5F4MN3nTd69geyWbIX5KJncQ+Whvs+9KtT6FPRjtMwom7gv5B9XNEgAzN0oIGJiTEwueAOHqiM+y4DRhX4ewGNA9pliidznrX8FEG1awboGkq9wm+EmGe9eAopZa72zPfhrCaOgQ6PPTLuyHjK/EEtbTp2SW/OmqM19y3GnYm49j0YfKVTYltGRutRUrUHHHbQr42ehQGUVLQb3/hSne1bQmXde6bOUUcwL/HnNM/IHuXqdWZadq6r2l5lo9M2emqkqiJ6tYmlyiHFiTuLUAJN0o5gnDYVcjZvLsTtlT4N84lTtxTNgLidMK7eZJ8HvotknsHIdiRr73Ozo13zso+5ach1NdljE1/RwMf4FrFbwyGtz1q8IRwKiHnFazmcT81IfQ/PQpAjYMSA+/QWk7xn+F3cBPYLfpWoY/Prlzn+QWKT/XiCyIXA51zUZUqlZtcmqwU6eV2B6M6aT5WXOp6330NalAj/PxzPEbus8r/qeJb4JN/HV2e8suJq1Cv4daljQl7t40XJJZWjzKcnsFWeLTAqaVcRC773JJwdN7I9wK8OUCYcIc8uOnspiq7y+Fpd6yaXkBNrHlDsv295cw3/uBzbMpkpuaShqbRzQt7KyNXpUEq1/EvCSYGyYplPKfyp49oCpqmsYOJP+LWwawHNSOR4QqjyvC8NJW+dV3m+kWDcS2O+JkulrAXKX7e6ylMghd5Ar/I0Q87sRVWeOkk5S0e1psrTR8KdhVWebZKS6+GQ6xjI9YZWuf4y8BCuFNKDHT1Ivuf6gMesoPvF164ycl3CyGMQalcOVjf6aa6G9wU67JwO2juJ1M248hhoXQNiXGVMWRLkO0qgzIir2pMgxlS+UZDXpGXXjXK40hzxpMQKfFYoxQ+8WG5RgUTbIX6WSKX9dkFZZ6WCv9C+uyGTKWMuUB5QM9Shi0BHs5X5qqngx3MXS8F9b6Cy/roVXC9QAtRJK9AEoHUFCcwLg7BdK8u/hm7+X8M3g/sBkLYoeX6yE+XeB+QeWUn3jSzP4agmfC6ujdfW4ux/Db8woNuBbzQv9FwXrHbauMXT4Kd79j5zTjhaFjqhQ7eTNlnZgcAjiNp07FfgiQxM6QpBv6GRT5MpSxw5vSKCpoyN/LdkL9IAN/lWX1aqK+eEOivFhZZ6rUQPPeeu4UcH8Ik/ccUl7e0NfK2oYcvq8Rn4RtRCz9ci2p+ZUg3fN4CxCz2NopG1kvV63PO90fOFL8quA/crH5XWwk2H/vdzWcc4Ou0y4LuVGM8kDlbs1LSu0M6DH/f6M3tr+B6yzhE6gVnzI37/ckuANjKNlNHPlS5JoX56TpmjKWXfri2ynROyYUzysPMt1skbBfzCbwSrgRHDT94a/oKELSqVwY7Sgm47+SQhmlgHlAGGTQKVM9ON7zxEWFEOVNaTrhr+O4nuj/f1Ab3OtfUb22/MAX56YCCr2TEB9CsgY9s8mT3APxjAnRsH+PsC64Uu+hwb1SOxqQebClfGQExXfWarmEKISdF3bxUzCGK66c2tYnpDjFFvbBVjgZhUfZdWMd0gxqTv1CqmA8SY9e1bxcQG3sR95nOg7faXc6ptuO8MW9ZXa17lcL/AdbuB4YCuAHV2QDs6DeQJ7mCge4HGAk0DehGoHOj3mYq8I9iVtVaQ989ly0AOT8lWkLWWyLoryNqqyDrtYIH2JwtcnybHh2WN4dkyld2/jaxzQdbtJToX7zPBqKwzpP1q7QG+SuoBsu5gq+VtRNb4LfjN5PRi/I7qR5IB/islpjq2JT/qfkETXeUxklV8LJP3pPtH3XRHA8dyqT4ohd7+r4kU3NCjrXHVcqtBBj0eBqxAsx9W+guI8cWH/w7n7cAdnNuFGv6gvy3Oa4G2OIXA3+Hc6P9vnAPDOH8OhHD2CuPMJDi7t8G5SwzhTA7j7BDG2ehTcD4SxIn70+On/q84F7XC2Q9w2u7CueAunEv+FmfPv8H5lT+EsziMs8EfwrnPjzh3+1vjzAvj3OoP4dzkD+G0B3FekhScuwDnsP8ZZ7swzs/4I3IN/7OvLU7dXTj1f4uz3vffOCeGcV6RQjhHh3EWEJzD2+D80hvC2TeMMyeM87io4HwhiPMA4Jz1P+NcJ93BORZwFt+Fc5XUFueH0t/hHPU3OM/6Qjjnh3H+5Avh/N6HOL/ztcY5IYyzyRfC+ZkvhHNqECcdxInfp6v4n3FmtMJ5MlDDXxHb4ky5C6flb3G6xf/GOTOMUxPG+VgY5xSC84E2OM8IIZxFYZxsGOdVr4JzhV/B6QKcY+b8rzjr/HdwPg4459+Fc4e/Lc49/r/D+cjf4LwlhnCW+UM4L4shnBdExPm72BpnSRjnr2II549iCOfLQZydgjjPAM5F/yfOtbW9IC8ugnOYf0IYZwv0LjR34ezv79QGZz7gzG2Fs3J3Df+nty3K+YByEUHZHlB2DaOcL+rWIsbnCcbnxAjA+DDBuMtzWw5hfDyMsVhsCGKM8B4lGPE0U6erjsvtkcg8Pd7AvA+0efz/H8Z/+e5gfB0wrvK2xfilry3G733/jXH+32DUhzHu9IUw6oIYVQSj7G2NcUkY4w1vCOM1bwjjGkHB2C+I8R3AuPJeA9MA9GJFwt9iHAA58RCMU1phjAWMxrswTroL48OAcWQbfS0AfdW2QpkKaVdsOMCv9yLKroAyL4yy3JsMeS/zUhmanX1HTmB3e/P0qv4H+KXepJxb7vZwZzHIp9SLknjNqwMZ2IIyUIVl8Jy3DmQQBRyzvTuDMkgQDhAZ7BYpy0bXJu4MyOCboQbm8lCljIWhigxw7SQoh9E69p3agfBEf+k5obnsnCBsiAN8P4rGsDze8NfwFYIijz1BefxTVN6WDsnjZ5HKLmwjjxEgj9eEkDxwNucA35HIwob2QURZTMD+n1dXscvzfgBxJQEarTcCwu+SMH6NWxIYCL9JwqgTt4RICP8joOzaO8BfFaIg/CIJx0D4vLCLSOMz/h25nkgjG6SxybUZ+vEVmYlM3hAD8wDQc0DvA+0D6jCkbb9xGMijy0rUi3HiHTtGgxwShbZ6wYpt7dgEkMOkNnKY4KrmvfIdvbBA2l9C6a4UUBZpoBfZYkgvlgrM2lTAsFhAe2YE3z+EbvD/ihAJOpAb1AEqENKBZwWsByi1p4RYkMINKSS1aUI7CF+WQlKbIsRB+HcpJLVJwvqglLyBHURKa72Updy1mtNkJTJzbQbm0ykGZi24u22K7vQvMDDf/xrP2GbeXY/Ka+8BTMtWnhNsMLZZ4iT236vITYf231fNz5ePkVF92P57E4Jyi1Psv5fKfonILc6KZ1VSWS+A3B4hctMQudnY/Twv92B1ZFyzyosSmgxxV2WmInfcLs8LBFtf237+Dxk15GkStkL4jIwa8jgJ94Twz3I0hB8h4UwI/0uOgfB9JNwdwl/KKMuxJJwG4YMyynIUCadCeI8ct9YIbq3crWi9kK/vZqPLcTzTCUb4+/lPZLpyvTBC39l2J65SXi8U6DvCPe+DrxDGP/v5lfL8YAnkBd7gcN/9CTKj+EzNM1xidiIZ7/wTxjNngHigyCIDkwY0GGgs0ENFyrhoFrgLgFYAVQJtajMGWlNbAGWTS3T5opAf1uVKsZqvDrTV5WahfRtd/lOgsh9so8sPQJmUB+7ocjakfaZ2P58loy5bQJe/FhRd3s+nylhC+F3hLnLMWpRjEr4rYDaBLwF8UWaUZTsi6w/I2YApENYRWb9HwskQDgQ6w78vEAf6Pyao/6V+Rf/3838FUP8TgOPPwHrvGH08+M4H3g/Vf2mzUv9Bru+4VkD9Pwhy3QYycgEtHQX2EOTEPGVgts42MOeL7ui6VNRGx0fj2YZYb3eBjfwQbOQ2YiPzyfhdkecNbzX0xdvayDwhqo2NLBC6NNyRZsLuav6q1No+7ueXBkL20SQo9nE//xr5xk8UIJsfYNZGgvt84FgQYbJ0EhAG+AYYMX/h+pJL6pkYxhY5JqwHxMYPgvwzC88Jf0D+NRvj2Bq+Wb5j48sh/59KrfNfw5+QW9v4Gv43GBOzbfRhJOjD23dhSA9iqOEPyyEMyTDqt+ixPDsEdGuxRA0Q00OfBL5Y8GWSusEE0PKvJKPjRAhTAbT8b5EwlqwgYb1eSMLtIOyRtgfl8IF/H5HDABl3hmzg/gA53LhXsWH/nmhg/OBvd5+ByQYqAvr23tayWVbbHWSzBcq2AmSzYQPKZpKsJ7LBc0o+4zUgnY53SccuM22kc4/sr78jmxvOaj7gbyuZCikkmb5hybwrrReS9AygeUtyB9FY/WcJGheMjL9xHQW9zc5JZI5DP23X+Lb5xvp3sFRZVT5A8n070Drf24RqGLu2zffVQNt884F7W2llEWjlprvyPSSc718DoXz3kbDVbhCVVnc/jP+x7HaTMOqoSfo6iOZb348EzUxAc9DVyJUAlr2DDcznQKsHt9XRTMCzB/BsATy1BM+7gTs6OgLQ3HsXmjcDbXW0LJDbCk0WoBl8F5rj/hCaOWE03/l1axHFN35EMSGMosn/zyCKJ3y/EBQ6QHHYdQTK5F+Ao90EA7PyGbAdbcplOSmXw8FyOUhwZAZCtqKePytX8x5fWxymQFQbHNmBh1vhuAdw/Opri+O5MI6YMI4nAQfWjOn+9V6jPhZ8jxJEnFd5l2E/f7//qyAiSXQTROthHNvgOshZeyl4JucrmPrmt8b0bm1fwNRcijO4YPMJpsOSJYxpHmB68y5MB6R2bTB9DmPZvDb2oz/Yj1l34dKGcW2QQrh8ZByLNuG2D23C696QTbjmQ5vwkjdkEy74sK1/loSjIfxv3/4g3jfELwnedMBb5armtgDe7GFt+zXMsLb62A8wXynFcdA54SLBzErGMGZvoJqPuQvzMKmtPtoA85A2mAcB5haxLea3fSHMGWHMCwnmDoDhVYJZSzBhW/c8wSyRUa0ewrMJ5luC8m7Qfn6GL5poc7FvdxB7hHiYYN/qx+8V7ODGWBMZ5kkDkwyUD3QEcH8MtvLkE23xDwH8emgzrgD+GNJmfO2/g/9lwP+O2Bb/IX9b/EdhvOtog98G+J+7C390GP+n/hB+2ocWZrkQ6gl4RdTkRYIyTtgPMkSpLBCUHu9+/pKIUpkrKD3e/fx/RGxzUEfOiNjWxIHvVxHbGtSTH8VPgrJ52VtHZIPj/0rXhxx+d8sO9eBRoHlA7wB9Uqy0JR+D3zihdf+qqnYrjiFXLYO85/k3gGx0RDaXJbD/yhgyvRFkY4XrVn/PcP8Kw4P8eKqeaWFr6VCebgur+f946X54L57IV4ajwbr9/Mtib5DROzYYg/hDfaxnxeVY/qJuF57Eey/0jnZ6WuRQ76hYvBd6R4vgfiPc/6C4EOu/GNsyJMh5JsxZRDjnA+dN535+pBhXsdNzjFx9Ae4ZIuoh/BUJz4VwrhgP4UYSfhbC2eIz8N9DNEBsHYmdBeFUMQHCO0j4SQh3Eoux/RcTIfZjEjsd+3/iNPiPFtsDgtnBfJWF8yV7MV+TbLhiAu2/dzLw3vImA+/8IO+CMO8lwjsaeK3A+5s3BZ4zi1wdA3ed8naD8HQStmP5e40QfoiEWQj/0zsK7b83FWInkNhBaP+9JgjbSLg/hPd7e2H/32uG2KEkdiCEd3nz4H+7Nw3y9WEwXznhfK33boJ8YV+3gty9xtsd7k6RQ6OJFV4LhDuQcFcIv+HFOr/Iiz3n17094BpDrmHsS95MCFNySMef9aKNm+09dkHR5QTh9AXUZRz/D7/5RfUXF6imXX0SmdnQ53n/PqVv+ym4dUBHgc4BXb9P6efK4BruNzAZQP2BJgDNAloEVA60A+hzoB/ub9vW5QZt5L/CNnKPeKete9JfzS8Q2tqIXWLbtm4fjJkHtrERA8BGPCa0tRFeIWQjVoshG/GX0OhNIqOpP8HXWY/W8Tz4uuhROs3gS9GjhTwNPiOxAL+Az0RaRrewj1iAehibfkEsQBJIbZerCtr22r6JzEmo5x4gPfQf+wKNB5oLVDuhNf6y2lGAfyTYSD2Mf/OJjcwNzxnU85yvihfltvizRX0b/P0B/8Nt8E9xVfHn5Lb4Xw7jTwzjf1ZYL+TpMwDNU4JuLWrME0IEGWtNExjQlMvhMesUIRLCyvgfx1mThCgIn5ZC1tUhREP4JylkXQuERsGqR50bCr4+RMZ54MslMu4Lvv5ExjlCeVCKxwMbiBRf8FKWt1zLuS9zE5kZ0K48D7QMaA3QdqBGoONAfwJRww1MPJAJKL9N23vxb/pQy7zjbx6dG5LsIJDs2Lsk+7q3pI1k3/KOadWLKtxdxee2keo+/ns5JNWZXkWq+2D83wh98ljbPr4JRuud9THg+wx8yfoo8O2VvwkifjjwE0Hsh/Flo+sQ6M2YfonMERhL3gd4ZgD1Ht66rfi29m3A9CFpK0yAZVkYy89iFc+1GY3X8J289laj8Rre7MXTUy+Vtm0tLpRW4Ttz4RH58/CEIXX7+GkE17PQWkjBEfk+frL8NOT/PhnnE+eTsfROz6ngWHofjGdwLP0EzgQ69/EFMtrP78jVaXDXIHkq/A+Qu8G9y4L3Hgzfm0XufQBLDO5NA1l1ib8f+LuBr2v8feDrDL6U+HvA117Gf4NsgpQuBlP6IJySTsZZzZHAQUMpJMbbwecPDFprA1cINAod4lnw3QgMhty9Su4qhPDlwBAIP698YQDCvwNnUvxw8P07MBSuPEmuDIHwL4FhEH7Mr9huKP/AcAg/4Fcs/D7+60A+hMf7lbmkffyhwAgIj/Yrc0n7+H2BAggP9ytzSfv46kAhhAf4lbmkffyn8OTO8RbwbQyMhCuZ5Eo6hNfiCnp8mgO/bYEzQ/FsJ8D7bkAX1KZ+UiJok8QfJ6vf/mo/2O7ZAxKZZrC3UQ8otjsB3DSgLKBBQGOAHgN6Gmgp0MdA+4F+BLoCxEw2MN2A+gONBZoB9ApQOdBOoK8n31lbPzH57jmPsv/q/1XzX8t3bNvL3ir+nTaj4mr+kNzatlXzR+X/7v9V8c9JbWthdHDOoJr/VA7VQprMe3TF8pdw3igZfLyEVqvUp1ipffxfElqt+T6lD7iP56QYCM/xKe3jPv6cFAvhEp8y67mP/1VCe4nfZP1R+iQo95f9dUTunWSl/3cFZN56XujfNgNzCehtiLsJ7n5bazu1isx9LgEZ2cD+lxIZ5cp5d+y/APbf31ZG2bKhjYz6g4xebCOj59H++9vK6GUpJKPEsIyehVH4To9Axqt9ANWTMArf6fGQcC8IPyZhK3CRhLMh/ICErUAzCfeA8HgizxMknAHh0USeLhI2Q3g4kedREjZi/SfyPCwqfZV9fC+pHYQPkHBnCHeXsOdYS8Idsf5LOD/awdGhqGMrnU+UXg7KvsH3JpH9QwHU+WdrngUbmjgwkdn1KLQTQD8A/Q4kAkU9BroM1A9oOtDix+7o7gbwlz7a2ta+XdvHpqxnfLkB5yiXgdxKgnMjOiiXZCiXHH/rOelqvjgQ3WpOupp/KryWHpqTzoVySfC3npPex1f5lTnpat4WUOak9/Gb/YnjEotwf0xiq7nhffwHftwhowfJrPLjzhi6sp3tztVlwbX0er6X72tOA3L5IbjG/M5AZT4Y8R6CPshxoD+B1kxsrYvratMA82poM98B3GUbUBevSZODuniA3yhX8Xt8bXXxgtS5jS56pJ9bzWJ956ziK31t9bCfX7OjB4t66JJCepjl/yWY8x/F30iJzoWc/8t1DOdJIO/fDmmdzz21GZDPDZDP1ZDPD0k+10mHw/kcC/ksviufq6TcNvn8UGo721bFj74rn//xherLq+F8/upTZtug/vvcofovnlXqv6TMtiUNSmQyJhkY6Y5sx5eD/tBlYyHXM1YqO7iKndV8vhRa4zgALVIVr/Mp+kRXfhjM9QApoY1GjZCo7KfaaFQJaNSfYluNWuILaVQ3KaRRC3xoA3vacsbnjNvHz/Ph/Dm2P8/4sIbyQqj9ecKHNfQvQVnL2Mc/6sMaygnKWsY+/n4f1tBzgtIv3MeP8+HY7ldB6Rfu41mQ0MjgHq6BRCuHQsyo4B4uJSYXYtjgHi4lJuv/o+7N46MotvjRmaxDSMhkEmUVsiEhCRAISNgDyJCFHRdQVBaVgKgoKBIVAVERxIsElIBsypINyWRBguaCu17l3kRRUVRwIyAmd1C0epnuft9T3T3pCd5733uf9/vjffI56apT1T11vuecqlPV1d3yGlP/4iZuuQ/y56AKDz3adHyo3p+avmr2q9Z1lxTwB4LGgqaD7LlWXy6uzDOQT+bIky+v9uXwuTZhPwjY50itvpyB8kL/ffdoO+XX+GzpdwUgPw/I92mD/AeYY+vIz/WZyNdLhHxaTtrEw+x1KaKYUK6W2hdT/3lI6g0vv8WZ4vfy3jhjr0R3gG51Jue08rZJFE9TH7pFoni6B1IbJYqnqR9dL+0QZgH1w+xpica5J6Wu+baeYWWp13dyN663FwUNQv8vJfexb7/cSOPcEmmdgXcX8SWO91HZlrKyYRX87dSwOEfUCB3rVBxHjNCxH4/jDNBdoBWgrSDPCP3+/zvG/eGLwwPXl/vT/R346XH46Snup+/LrevLR9gjykG2Xgz01HrZEeCpH8gvW2LwIsTgD4qBnhopmZ56QDY9NUgiT6UxXBF3CJ2dMRT/iRSN0zj+u0jROI3jLSLtZqQI/YJYb2CyUfiIe3QGPU/aUANM6P3jT2e7HJtBL09CnJSt3y+bE7DGuf8v+qVJ8lp/v2SHtHFtpHXL1wZIO0Vu2y/JQqC0W0RT2gy/tOtFs196WjT7pT6C3i+dkPR+yTkxxnES7T0U0ObNlRTxZ63G/Bv+MfAVavNlKdvf5gO+g+yoENjmX6W4gDb/KdHM4kibmUUtZhY72rR9sL/tn0pm2/uIYVvLvIf5PelpkKCnGI78azw/GflrRAfy+1V9JQbxv9gO+Z2qvhJzmEWJEcjr9/8ptg8V2yOv3/+n2F4RIpHX7/9TbP+HEIW8fv9/BPLNQgfk9fv/Q5H/WYhG/j6eH4z8twLFIBTbnxLovuxApD4T6H4sxff/FOh+bH+kPhKo56MY/12Bery+NP8TqKejfvYoUuOdaTT/QyrHSb1AJVK5Tor1y5HKc1J/u1/YIeY7Kd7fA94EJ/W5LyM10ZmI1EtITXJSv7tJGMz1fIQN0cZxPX8lUo/Z51Af2OvAkXEB/eOYxS7HR+g3vwT9BLoEUkHt73E5OoF6g4aDpoHuAj0Ceha0E3QIdAz0BagJ9CcoHP1vJ9DWhYG2dKX9/1NstaVVcgXbrAXa0vtioC01iIH2X8EebTPjvkowbajSP+Nuz/Ej+w8TGg1cDqq6/dM7o8j+nwMmZP8/ZAeuP9Geswa0+U20+RPe5qViJ3+be6HNQ9u0eZEYEdDmh8XNlh5qfXUFSwhocy17QzPbfJPR5lrm0cjuhyr6KnwtK9XI7gco+ip8LaItsvtURb/zUsuKtb8bkmWr/+CSnRVsKTUNtdB3yKg4xxnEsAzknO1yVN8R2A+nGff5Soz7fK+xINHaD9dIFewDNVBKUQjsh4PF6y1SDoOUr6mBUub4pfxRMKUcqe0Qu6N/rYWd1qOnbY/UQC2smCTK0D40JPpSOcklWibQl5OPNS2GPH8MczlmjnI5QjGmnBz2v+TZJljlmQB57mgjzwtt5NkutJXH3Uaes/5Z5aN+eb5QTXkaVVOeT1Rdng9VU577DXmiDXkeayPPLzP+lzwDAuT5SazA3DVQnt5t5Mm8Qp7vlEB5HvHLE+uX5z6/PAv88txpyDPbL084l8fHDmi6PGvbyNNvWmu8tdK9gc9pJyDWes7zrPsg+4TvEwjn/vQEJNkU8JzCQdovY3lO4SD7p2br+0jAfPbhhgq2zPKcwvCcERNHTKhl0cZzCgdZmfGcQi0LResHo/V2Nbz4OhwVpR7zqEFICUgloteuZb8rdG9ngP8pglr2i0L3ePpaON8rdK8nzcI5BU6a5amGWsyvdgjpRpymc94Hp4/lqYZaVg9OX0RprZwatCMZEXEtO4TUtc5OSJUpywysp/rWcKwv8TntvYfuhX9/mB3n6D+hNQaeifS9oBWgv4Gim2McO3EsB32L+KQOx39RfZB9osvReWLg3LYP7SHbuBa4qWprX+cRKti7AfvgD7I/1faWVcSDzKatsVjZo7Cycsse+E647uLKWjaWrzXE5Rxk3xl74OH/igtyXqfQ6mEyX7crM+7/k9ZS+Q5/srqeynEDiU/kTzgSi4DE4YbXgUO30XGOx2e5HCVX7qv9y30YB9nzqtWPsiHh9IDVlIPsqYD9DAfZ39S2I9BQX6AfnTTuMB9k96umH/3DV88jsFr2ns8cgRbJ3/L2R/r3YSxC+2di3ExZZPWXZ/k9gDj4y3DuLwN5m8N5m19n57QKJsqBHpOmtgvwmEGqrW/bOwDwf7nVY/rm9J3YDx7zsM/0mBjV9JhFPooeUywWOs9HMXNPC+cWH8XOCRbOVB/F0N0tnBwfxdJdLJxRPnoyqKOFc52PngyKtXD6+IoMvE5KuzleSxX9DoDt2PAxcY6F81vtvhjpCrrfDPoCdBFkK3A5ehQE3lOh56RmrzojpCCmnbWH7GCdf9/862wEEJ0iB1rBasUZYAXPYaY9PwDRu4DoIDnQEv4lm5awUDEt4T3Mboc702EJx2Ua4XNFfbWslh2RaYQfLeqrZbWsUqYRfoior5bVshKZItv+or5aVst2yxTZ9hb11bJatlWmyDZB1FfLatlGObKYepHn5Khi6kPWyvVClvNqpJ6U68WhmGHXshVozQjgXcuWy2sNnOOlLRzn43yOveLQiqY3x8Y53h/ncnwO+h0U43Y5+oLyQQWg1aCXQX8H/QASQLvHBY5hbWO/g6zB1+p7r7PVagXmroGof+AL9L1G32WL712E7z0mBSJ+tR9xj89EPFIOKybPc8ifGhIeEr/jEk6GhB82fNR0A+Y+I2e6HHEz//u+rYPwD2ubU9DmYW3afG+bNi/zte0vEtu0+U3JbPPN/jZXSTuM/uKgZPYXN4h6f3FZNvuLAnecYzriuV6zrf33v/na5DfG2uSpSurHu/gmX254UF/ReJ19olSwM6J1RQP+7rvfsqJxkHX1P0lgrmgMgIW/K1pXNGrZ7caKxkH0QfqKRi27QSJ7mirF+tcYYhbYi0IG1bLxUu0fHz5h3/57I0Ww2XzlgyKKYcaTBEfYD8KHTSGQcbWxy952zDE+zrF7lMv/Pp5SpB8LuO+1r3IE7UF4geTcL6/0+/FMSLlIDByvdso9A8arEtmWPjnAjydCyqmWffZkAx9izLrA56ZJGLPWyOaYdUbU91HX0v1//P9SpOdCCvjoVeqdpZmj18eivo8a4z9m4ou4D76F1DPcB99Eaq0zNi8uP86/io34X+xSHEP6F3eb+hcO6vrHjP3FhpeATQOwCR/tcqSDckbr+NCaTPatrX3iaoz300e33VO9r3Im31NNmEVyzMI4Zsd8FexTwbqv5CALsWBG+Q4y7St5us18/smVFZi7tu4roX3B6Z5azK9oX8lI4HZeMnEbKw4n/YthxcNwHC6GFw/BMUt08MhsoEhxWX/+v6/Yzr/3pNRbrZqIJvLdGOmGbrqK1J92Es29J6XG/J9qRvGaiXRnFDXDxETUDBajK+iZB73uWn9dJlDdjkaU4hVIY82CC3VvMOo+6K/7Pa9LkfE3wgKuodfZk9oyrqEkvj/ijkN3QEdrcuIcuehXlsxsteFVSD8L2gTaOTNQNzTe03Mj38B3hUoa74dL1vG+BTNOu7Hicr0x3mdKgeP9CMmWPjrAqkc1lCNSMK06F+NH/KSEiej/BXO87yyZ4/1SgfoefZzu7+4Nzj0CjfcdLZy5Ao33sRbOTIHGe6eFM0V4zcCFqW9wXF7CXHtvw76muNw4R+dhrTY6BOmbQHeDVgTM5Xb/xbhRIy72+/h8uZwVaoE9cIUYH9ADH26zZlDO5gTMv2uYrJk98IvG/LuGXdL0HriG/ao1GnIUqXoPnGmsGdRADprjDJpobfOLlbeizZWILwoQX1Tw+OIWMcff5ii0Ob5Nm6eJVwe0eRa/G/9MGx9bs7Kc3pkb0PYd/rZn+dtexPfGD0Pbn+d74ocg9awWsbXU61L0O9E1bJXWHvkI46mGGrZci0Q+yHiqoYY9oEUhLxl3omvYAq0D8r8Zd6JrgGE08r/49DsBNWym5kT+B59+J6CGTdVikNfv/ycgn6u5kP/U2Ilfw0Zr9eIUzHtq2HCkpjm7IjUYqRtgeTVsAFI3YeZTw/poscUdceytFRhaaFAe5lpYzJ9nuP3Q7U0NeXGOtPEuvufQuq51FjGICho5Xt+DOBXHO0FLQU+A1oG2jNf3JoaO/+97Mw+yR4R4vw7TpHI2Ug3U4WIhMkCHhcKVezPLWZIaqL961dTfDMHUX7XqAFbDffpO9RpWrrZDfqBP35Vaw15VSZfpvvbuIHcH5LfzO4NRSL2o0t7MGrZJrTbQGqLQ3kyZfaXpezNz8uMcz2M82DVax4QwI/kXjLbKv7XyPsgfsvqMUAMbtr0S7a5ggjbFL3+5WM7+HrDiUMG8WieL/BVM0siGD7ax4TLY8B4lEINhBgYV7AvNxKC/GgYZj8r6ui70r4YjXyXr67o1LIFjVCbr67o1rDPH6BVZX9etwfyFMNom6+u6NaydSva+SdbXdWsw/yd7Xyfr67o1TFTI3lfL+rou/F8hey/k+YHIX1DI3h/k+f7If6+QvS/k+b7If6WQvc/l+TTkGxWy91t4PgX5j5RY5KfJ+n6NGvaWEod8Hs8nIl+nXIX8GJ7vgbxHuRr5oTzfDflSpSPyA3i+M/J7lDGGhnN8U7iGz/MVgaxDWU0rJ8Q5Poc+fwL9DgqCT7hAiaABY+g9HS7HJNAs0GLQGtBW0EHQ26AvQb+AFFDlaGus9VLllBzq19aSvtXWPu1VoZwdDlgbqEB7OlpirQr2m2pLfyjAH5bAH7Zb1gfoGRKnh747RPZwXU4F+6exPgD9K6SFay3rA6XecmN9oIZ14esDFA80VNawWKVdMfVR0Qr9j1Ta45ws45wX/OfY+Dk9eGQA/fs6FBPuf/jo/28+p/+JoFLvMv8553y0f8hF+veR/hZK+q5p6N9H+psr6eu10L+v0NDPI/IzXD+duH4WH1rc9O7EOMeMaYgDpunxwHM4vgJ6HfQF6DxIm9Y2Zqut/ICeUS4i7Aeox42Y7TD7WStngmyN2SpYqjrIErNVsIEqxWzz2uwFnr2qnJ2WW2O2Soqjq2vYEh/FbBXAv4Mf/wW+Mkh1t4/2Aicb0dBF0cTlFh9FQ6/QnoiqGjbdtwd1p/haI7cv/DXH8Zpb6UkM1Bzpewk1h/kiK1pjt+P+uv143Q0UqaJuim8D6vb0WWO3Mn/dzj5zN/Is1HX5niT9+6yx22Z/3WBedxnt5UVdn7yc/F+mPcKzjbor/HWbZaq7iHpD1D0n34+6P8qd/PuJS70F/rpf8rpzUPcUrLhBvgt1T8it+4nh//66b8m0b/cmeuoLdY/Kt+bQd4e6o+4ao+5wf91yfl1atViJunvlqeT/cgLqbjTqXuuvu4VfNxt1b0Dd5+XxqLtebt07XOp1+us+wevSSJeCuo/I1C8+JPdC3RKjriSYdRfwuuRPd8qpsPRmQd8VVMNmyWnI/yzou4Jq2A1yOvLfCvquoBo2Qe6D/OeCvs5Rw66X+yJ/QtDXOTD+y/2Qf0/Q1zlq+P3/406KGfoh9ZYzHqlUpN52UtzQU37unO5Xn4jbzpFfLeLrFKtfW30ufUqc4xj85Rdj/U/Csd1tLkdnUAooCzQeNANUAFoOeha0DVQGOg76HHQRZLvd5bgalAYaD7rz9rbriVfGeRXwD7NPPIwRqZylS4Fj5O2+qwPGyALff4rzoqXAMbJUMsfI633mGLlLMuO8bZIZ522RaNzrLphx3gaJxr2rBTPOe0qica+DYMZ5j0s07oUJZpz3kNRha4lX1cw4714pGnn9+X+K8+6SnMi3aGacd5sUg/w5zYzzbpRcyH+nmXHeRMmM83IkM84bK5lx3kjJjPOGSHqcN0gy47xvhId5v/mYbMZ5OVP/78V5g8b+5zjPOTZwf91kelvAKnob2BlhKdfhGjnLr8PBSjnLEwN1+JjsCtDh07It/b6AcW0RxrV+YqD+PhJN/d0pm/o7xtcPSAtHRQdQG6uZWqgS2yE/zK+FMjEC+Uy/Fl4R2yOf5tfCNjES+SS/FjaJUch39WthnVgvDndSHPEUUiO5FlYile2kWOJRsUMx6WCZyJ8jzuuY38m/ElHDFomrDI3ECs9zjej7/5cdWob5bcq0uCv0cXqUjj/pwqoDwt+c8/2KOq+P+u/3WivY3/17/Q+zB3zlbI0QqIvDAXv9K9hxKfBeaznmroF6CPXrYbdk6kEWwoDWGtUcu38XwpF/TNXvtdawiwJpZ6mq32tF/y/o91oPs3XaPzgiqZJ5r/UI8DiJOf2foI6Qt2zmlc/uvWvsOz/OZZxgkVHD3NDVRsbr28g4SQp8orLM8vy/LmORYMrY1y/jswI9uwf9C+HFJNMqwcFnCo8L7Yrb0/xPeN+QKV77lMt0XNSfqLQdy5oe57gdsiwBPQPaDhp4y39/VrSCnbXcQz7MNsllbJ8WKNmXoiNAsu/FtpI910aya/2SveWf7Xbj2tun6M+K1rA4rr0div6UJeI/v2TVqi7ZdEOyRyAXPQN/CrK81irP5A18Px6twlyGNCd3nxG8lRXsEeO+vy5PKuQZoQXuyKtg94lRlh15dI4tfUTAKuqwhjLj/r+5ilrN7//TKmoFv/9Pq6jVzKN1mtxpEt2H7OTfCVfN9mt0HzLOwtmh0X3IGAtnM5/zR+VUs79pHkPy69RjTSGQ/AvMmQ80lEKn5yG76YtPTXQ5vh8b6xDmuhybkL5tYqDN0vsq4lfpaHTjfeRvQqvN7pPK2BE1ULO/CIE2exlz4UkBfeQE4LAjYC5cjfm/qd1PjblwNeb/pN3DPv0uRzXrqZF2X/Ppdzmq2TUa7YPtjFQnjXa/dkQqVqPdr1cj1UGj98HFIdUOqWRnLFIhSPUEYtVMU3cI1zqdSEnqHgOpPcpr3EZGA6mXGrY2NdwQ52hA3/UTSAS1y3E5uoH6gIaDJoLuAJW1WT9ou25Vgfl9vB+z9sCsexvMpgSsH1SwW4TAdasyFtoGr13+efNQP15bVP1OYzXbqDYaMg1WaN1KYl9q+rpVxo1xjjHTERdND1y3osj13VX09nX0TdBzOVO11njGI5axdwPm/OXsTy0wnrEJFM9sahPP/G1lGTugBLZ9tNH2cvaNZrZ9sEq6Ps7nuKMgQT+VdH1E1p+uqGa9VOqHK2X96Ypq1kOlUbJE1mOdatZRpVFyt6zHOtUsWqVRcqusxzrVLFylUXKjrI+y0L9Co+RaWR9lqxlTKPbR9//3Qv7fCsU++v7/ZOSbFIp99P3/CcifUSj20ff/d0f+S4Vin9my/tRTNfsX5vwl3hnG8wTV7ANlhzCFW+jbym2Gbhb47uG6acefy5h+aDp88/hNcY77EKesAm0H1YJOgM6CJFDH6zGPB+WD7gGtBVWA3rle33+YOzbw2eqx0Gs29Op4gd5ZT3p1aSl+vb4nlLFTvkC9RmjWZ6vLWZxmS785wH9vhP/W+wJ1erNi6vQ31dTpRL7HmNDLUfT3c1SzsXxfBCE4ku+H6IHUEL4PglAcqNSj1+tG+kcq1UlIpqK0H/fynkhlOAnNeKT6cy/vihQ9Q1bNrkYqk3t5jLLVQPiIvI8jPAPz7+cb/kb7JW6Oc8Tc6nL0ulV/9pbulwwB5YFmgBaC5oEeAq0E/Y3up7QZ79q+S6Dcv/9fHx+6ANU+bVC9I2AvQTlb0OZtAmUsrg2ir/lMRHP9iO7lbxOoZrt95B29jbcJVLOtxtsEDrNR/G0CEuxTf5sAfQs8wXjuXhn13+9xlrMQixy17LBWxj6SA+WQlUA5QtW2PVWlHChHnrGrv5z9rJhyZPM90NRTDfOZPdUPkt5TrVbMe5zZaLsPdv3l9YF7CXNohruK3qN0RpjCbbpEMfcS1rJb0er72rR6txIX0OoyxZY+N8CmZ8Omp7dpebNsamCtv+U/yhHFvcn/+T3PFKS+5vvnr0Xqc5n2g/ZEqkGm3memqK/wVbMPZep9por6Cl81Oy5T76Pf/ydrPyJT76Pf/ydLr5Rp1yL1FuVI5XNL3y/XC8P5eLYHqZHc0l+WNxjojZW2cfR+xIz4yYY1TRNmxjnWzW59D83Ls/V130M4HgOdBF0AyaDNN7scoXNcjttnB+6VoNUBr7EO/iu3j8v+d+/VsgNqGTsqBeL8q88ZgPOfvivXwcswdw3EeYgf55M+E2ea/1/L5ab5fy8ud0+5XtTH8XjwhvBxvCvXA43jV8s0Quwy3lWA8d94R8FhVise59jcaLyjIOSWOMcw+MNE0C2ge0CPgp4Dtbvvf2HwoAWDnsAgqw0GC9tgsPQvMbimDQavSyYG0/wYHOTvGSAMSiSSnDB4VaJ9YYTBTpQO5RgUSyYGmyXC4Bo/Bs9JJgaZBgafyToGbwIDU/4vCwIxOBCwZ+b9yr7A4BNgUAMMPuQYeOXJl9c8aKLwilIGjANRaJLdAShckpda+rt70N+9LAYicJ0fgUbZRCBd0vflY/yX9H351SxRoiiHesFrpB18XyLiP+ltQ85jwj+5nHdAziMNdU1Tbo1z7BuBMXOcyzFhnG7rUeP+Vz+4Urb2gwMg37g28i2TA/vBVXLbfjC9jXzvi6Z8c/zyvSmaEdvrotkP3i7o/aAqmf3gVshAbZ823boeX1RJbyTIfmEtrpjC1y3CuDZO+8pYS8B9/HL4S6xlTbgcPmXrMy/AJufAJj+z3MOn5zPOV1aze/g9/D455SzM2PtQzeaIYVsPeH9R9fsb1WymGI78D6p+f6OaTRUdyH+tmr1frkj/3fx+/kC+unjA+7FxN72aDeV36fU3N1bDTqn/yxCjLl1v1Dzsr9mTv++A7DxepB31ZBddxec4brXsba2Y4zYXuK1ueJL2iM2Kc+zB+P0x6FuQ99bW93DZZ7kcMbOufN9cK6YrpFZM+wPT69tg+rAUiOlK6a8w7f0XmL4lmJjOkkxMXxcI02w/pocEwjTLj+kBgTDN8GO6S6D/LwtWTBP8SG0UrJg+KxCmTwutmEb6az4qmJg+LJiYPiCYmHYyMD0impjmANPkB/7fYnpSbMX0GbmUbdMCMf1EDMT0C/FKTEvZE9qVmHb0Y1olmphGcUxfVExMQzmmzys6plVM0QjTpxUd0yr2h0b/f9OsmC5TdKSq2DmtFdMqdkbrjLrfaK2YzvXXbNR0TKvYJ5qOaRX7QDMxvU/VMe3gx/QGYHrg3v9nmBaQ3BzTVDHLPx59K5Uyb8DT/uUs0YIp5dP5/oJ9beZpr6wsZZ9ZnvafmkN7tKvYPXxePpH838C1is3RuP/zeXgOZJupcf/n+XHIT+W46vf/xyCfq7VDXr//Pwr50Rr9H6lF+O/NHfC+4zPRG8Cf+KcVGOeewZOqWKpGUdUgvsox1U3f703QOuB6ZcaT81Wss0ZP3/Sz1HDytyKmWTjh/O2IKRaOqpJuki2cP1R6OifBwvlVpad0rrFwflSj8duLfPq8roqdVvMMva5WZnC9JvK9CdmHspsqb4tzhN7vcmSB8kC3ge4DPXO/rltaf9mA9MugctC7oO9Af4IiFrsc14IGL27VPa3Z/IX+BYv+RehfaaN/oY3+hf+of+Uv9K/69S/49a9y/ct+/atc/7Jf/yrXv+zXv8r1L/v1r3L9qwH6l/36V9voX71C/yrXv+zXv3qF/tUr9K9eoX/lCv0rV+hfuUL/Cte/7Ne/4te/j/QvskTN1P9e6L9l8f9Z/ZfBPyz6F6D/gHvxZWiPVf+IS7T/qH/fX+hf0fVfxsI0v/4Vrn/Jr3+F61/y61/h+pf8+le4/iW//hWufyVA/5Jf/0ob/StX6F/h+pf8+leu0L9yhf6VK/Tvu0L/viv077tC/z6uf8mvf59f/7Khf9XU/1bo/8j/9/r3vxtio/FuiOcwBy5j16qmHdSwr7RS9mvAHJjWHK33rspYinrluyFKEXtbo1bo31iFgP6NVQjo3xdB+hf1u8DQv6896V/U7wJD/75I0r+o3wWG/n1RpH+R9iz1Jv379LlzFRvu0+fOVWywj3R63NjxXsX6+Wi2S+NxKnQw0hmPVE+kRjl7IBXvI5u4Joe+O0S674bU1T7SeRekYnyk6855nfO7+O9lVbEw33JDUwelp7mmJiqt74b45vY4x17E19Wgt0GNoLOgf4NUUNQNLkcXUB/QWNBNoEU3tN7TWoH0o9MD187p3deRq/R3RTi4jm5QOvl1FA4ddWmjowlKRICOblKufPd1KdOkQB0Vy6aOBiqmjv4m1/MnLqrYOpmeqyBbfUrulNcpn7620smCS6Gsv02iij0k0xvSq9gDMq2mu5BaJNNqOkUy8+UKA70OUh1H7zWf+e7r3XfEcXx+mxOIh4p8zNxW3N6bE/gs2BKaV+45I3SrehZt19//F86xWa6Wmu//M55sKWN/91mfBSuj9//1/atni0vZ/VLr0y235syaOGsC/F/Wd7uWsVd8+m5XxH98p/1N/idOqthliXa7TrNwLvIZ6GQL5wc+E823cL7i89AcC6dBoqdbrrdwPpBIC6MtnL9LpIkRFk6tRJoYauFUSKSJ6yycV6Ud/Em1Vs42ie5z9LNwXpDofke6hbNWovseKRbOExKtr/S0cB6WaJ0lwcK5l68/dLdw7pQGG1bQXhzHraBcbn22OG5unOPlua028A+kvwbZ5rkc14BGgm4DrQTtBr0DagKF3+ly9AVNBS0FvQR6E/TDnVZ7Ka68l9ZdYS+R3F5e879XvwYjUilbKrbujCbf2R/wXn1al/zrPYml7GaxdXf0jTk3Tb4Jo86/+Wyd7GWdbNrLz/wO3RR4w1mR+q1J1P+LEVv3e+/kd9vzkf9MbI+8vv+fxsaPRXr/wnikaP//bU4aH98SI1EnTzPHxzoxCvkxmjk+esQOyA/V9HsfVaxUjEZ+gPFWwCq2R3Qin2q8OxD+L8Ygn6jp9z6gf9GFfBfNHB+fFWORdxk7DKrYKjEO+Qhjh0EVWy5ehXyQscMA/o+W3u681n9fsYoViFejxiVVv/tRxWajxh3oiVtr3CzqexJrmKpN4ZaxUzL3JN4wL86xeFGrXVjfgbQHVA36J70nG/Q7yI65UPS9+rs7knDsBxoGGg+aDpoPWgEquve/2cdOqdU+pvpK2Z1CoH28KAXax27pP9nHeOFK+zgjmPZRKJn28blg2keDYNrHxwLZxw2qaR/vCGQfE1TTPt4QTPs4LJj24RHIPoaqpn2UCmQfA1TTPvYIZB+pqmkfxQLZR6Jq2scLAtlHF9W0j2cFsg+XatrHKoHsI0I17WO5QPYRpJr28YBA9iEppn0sEMg+flNM+5gjtLWPGQLZx/eKaR9ThLb2MV4w7aNF1e3jedG0j9mwjxcf+D9qHxiPX668h8bj1WeEEsRMjldoPH5OnO23kVFyCZumBY7Ha8RuAePx83zufKCNjexdWcIGBexW8LB/aeaYvNDYreBh72mO4vwcD3tLa1ech2O9FlGci2Od1r44B8dajfQ+UtHjaA87qJHer1N0O/CwfZjDFmAM8bDdGllAb14yEvmtGllAAs8PQ36jRhbQmeezkF+rkQXE8Pwg5FdqruKBOD6mxRZn4viIRhq3G08AeNhijTQuGk8AeFiBxv3feALAw2ZrHZG/YDwB4GEztE6kf+MJAA+bgpYucCbmJeUn+SMNDxun6c9MeVg2yhdiZPGwYVqOYRc/KDdxu1jN588jD41sirsrzjHwLpdjBMgNmgyaC1oO2nhXq+53Il0OOgL6B+h70CVQ8N0ux1WgXne32tZgpPNAd4DC7gp81nYY7fvfDRvxUP+xQmh99qaGZUglbKxqffamjD0ktAuISJ7AzDo3IFob31CCOLu190jOSZ7Uc6KHHVfNaORWQe89POww/3ped/9TNNA//3peVwtnL/96XkcLZzv/el6chbMJs/P93q4+/c10HrZO3W8g3F+pBsICa8QM9eWGHU1rCN+CVmzWIz0P9ADoKdBLBVZ8SivraVfMK2eErdXPuktZi7bRH6/tEUtYTcCz+6XsnNbbgg7mpRrFaxPb7EPOW1XCXrI8v78vZ//E/RM8rJ+BUCn7h2Yi1BOybnTu9scjHtYNnBecL1s4seBschZbOBHgFDm3WDi0/3+/sf9/IxCi/f/7jf3/G5Cn/f/7jf3/65C/oND/cwr52P2c+wzy3ynkY/N5/knkv1BW4/9nmGdudq5C6p8K+dzNvHwF8vT8/xbnY+T/CvW/+v7/5eT/CvW/+v7/h5H3KOSN+v7/JciXKuSN+v7/xcjvUej/ToV8spesv+/Yw15UyCd78PwdyD+v3I7/6/GrLzrvQupphXw0Wtbfu+lhK1DyknM2UsuVztT/85LbkH9A6UL9P5/j3oL8AqUr9f88fzPyc5RuyOvz/xuQn4krbXVOtyA8BZxiS9TsYeP5XoAJqD2G7wWg/m+EQu8aox4wS7kGV3xL0p/o8LAMpTvydZL+RIeHpSg9kPdI+hMdHn7/f5tzpOX6HZV41Ngt6WOgh0UrCchvlfQx0IP5fyLyGyV9DPQwzZeE/FrJ7PGY75VzupfslCvPkZeM5PP4ra9tPffh/DjHeYufdIFPpII60fvFFgTufxxszNVpfn8/vV8H9NIC/T2P3xnvepwGmgu6D/QU6EXQy7h+BY6vG+8sexvHRtAZejckKATjYRwoGZQFmrrwyrHvP/tqJ9X01Wr2sVbCvpMDfdWpBvpqF/U/+epb8pW+OtNn+uplxfTVyb62vur2tfXVEb62vjrQ19ZX03zkqzWi6atJPvLVCtH01a4+8tW9oumrsT767/SRrxaLpq86fOSrL4imr9p85KuKbPqqIJOvrhJNX/XKpq9elMlXl4qmr/4ok68uEk1fPS2Tr94pmr76mUy+Oks0ffVjmf5/KJOv6vf/yVePy+Sr+v1/8tUjMvlqrWz6aqVMvqo//0++WiKbvvqqTL6aLpq+ul0mX00WTV8tkslXu4mmr66XyVfjRNNXn5Tb+irN/wN99QHZ9NVFsumr82XTV+fK5KsXBdNXb5HJV38UTF+dJpOvnhZMX82T2/rqaJl89R+C6atDZPLVtwXTV/vL5KtHBdNXe8vkq1WC6asJsumrH4q6rxb4TF89CV+95YH/P/vqGF+rr/6hlDCHFOirQ32Bvnq97z/56kXxSl99UjJ9tbvP9NXlUltfXSy19dX5UltfvV1q66s3SpFb9xn7/8lXJ0pRyH+hmb46TuqA/D8101dHSPR/qBQN7jua6asDJCfyb2imr6ZK5Kt0/1/31UQpBuXlmumrXSTTV6+SXCjZqZm+GiXFIv+iZvpqqBSH/POa6asK5r37vE9rpq/+IdL/3zDX3ed9VDN99RexI/JLNNNXfxDJV8+Ipq9+LXZCuf7+f/LVT0XTV0+InVFyk2b66ntiF+Qnaaav1otdkXdrpq/Wit2QH6mZvnpQbOure8W2vrpdNH31RdH01RdE01efE6/BFa/STF9dI3ZHPkozffUxsQfyoZrpq0vFtr56jxiPGpdV01fniQnI/6qavnqrmIj8T6rpq9PFJOS/UU1fzRd1X61mv2m6r26STF89C189de//b3yVr+nSfqDzxn6gn3ZHw48W+vfwV7NrfCUsI2APfymbG7CHv5QtkmzpwwJmCUMwS7hKCJw/HjJ2u5eyPMmcP+4TwoBtX1V/NtjDcDby16r6s8EetkVwIN9d1b9Y42EbhHbIX63qX6zxsKeEmiZdF+naW3wm8Anm4GUN5fQu3YI4R+XtLsdbt+s40T2JgoX/S/ZfxVbZd8kHWJUWKPtPYqDsLeKVsh9gL7WZO/f3y/6Jf+7ci8teqZiy9+Cylyim7B257LsVU/ZoLvtWxZQ93C/7a6ou+yS/7Mf/QvZP7/tfst9nkT0Bsg9sI/vdbWRf/Jeydw6QvZJVa6bskwzZK1mpRrIPMGSvZHs0kj3VkL2SFWske6IheyV7QSPZuxiyV7JnNVP2DEP2BsGUveYvZN91X+Ae4rbf4cBcTkjxy/6qdABz10DZzwsdAmT/DTPjoQGyZ0H27Wqg7IP8sjcIpuxp2g5hoJO+5HqtFlFM0idq7YtjcezOVxNI/s78qQcnUnEajUA7fPr+t0oWqdUaklcrb3PJp0Py8oaKphkL4vh+6SfGuRwb23yv75Zx1vH5b/51xbgqGp8f5LLr43NPyJ6lBo7PC4XogPF5qUDj85XrigdYV7V1fL4x56aJN02A/v3z3knGygD0r9J6/hTIQ/P/ns5JSO3izy9MRGqbSuv2rfcjoH/+TbwclD3Hv4XnRuoZ/i28cTn0fXN6V91YS/3lKu3JzrZwFqu0N3u4hTNfpT3aQyyc21Xalz3IwrlRpf3ZAyycCSrt0+6LXx2v0j7tPpaykSrt1+6NsiEq6TjFUpYBziDL2/MqWS81rDgBdZPU8OJ4HHuojuIeOHZVxxgafps/C8/YXM3/LPw9cY6Sia3jSwPSZ0CXQHkjXA7bpNY93jFI9wQNAE0C3U22ASoC7QcdBX0B+gWkgZInuxy5f/HNPOt3RUrYLMu3/qpZB/EASwh4iqKETQ/41l8Ju00L/K7IAeZQAr3kFWOnfQkboZleslXRvytSyYoU/a3FlZj/1wtdnBHk/8oHpv/7PuMY0ff/9O+KCMDolbtdjirQh6CldweuidF3Gry76dn8Z/GLly3vn6tm+4UDrM5nXRNDzBnw/rkS9od65VcaDrCdvtY1sZ45PSddO7GSXafoll/CGlXT8tP5Nwx7+Fe3oH+F7tB1s3C6KHSHrpOFE6PQHbqrLBwHRyXGwtF8+wxM9stVHBO3qn+lwXasZFGcI9lyH2sq0nfP1W1iBY6DJ/33saGEzVZbx4ZYoHStL1DrMwK+yVfC5qp/NTa09wVqfp/P1Hy2amp+u4/GhmTJHBuKfDQ2dJPMsWG9j8aGOMkcG5700dgQKZljw6M+c2xIlN/iOLytmGNDt3vjHOsh/6ugo6BG0J3G+9PtKUJtqDvSHfrNIVxlhs+eHO8W6oNSujREQPLdBVXsazW4T5g7lufPIv+pGuqeX7A3d0BilruarRBC3Fl1vd0ZbsZ2KGeb7Nfaev67aUDijlwqvR+l8UapW20Efyvnz7PwX1PfA7+I82+28K/W6sB/nvPzLfwV2kHwn+X8URb+OW0P+Gs4P9PPR3wgbAH/Cc7vZeEfFp4Fv5Dzu1r43cXHwX+I86Mt/DXiA+Av5vxgC/8X8S7w7wG/ijGtlT9Xmgn+3Zx/0cL/TpoI/hzOP2PhL5RHgz+L8z+z8NN9g8C/mfM/sPDf9fUGfxrnv2Hhd1KuAX8i5x+y8LcpMeDncP6rFv4vSij4Yzn/JQvfrYrnBiSO5Pz1Fv5OtRn8IZz/hIXvU78HfyDnL7HKpX0Ofj/On2/FQfsI/FTOv9XPF9mdQj34PTl/soV/SvSAH8/5Y8G3pQxv1Evypb3nwh90ORaBHgVtAO0B1YI+An0LkkAdl7gcvUBZoHvhE2NxnAqaDYpIjXHcj+NK0EbQVlAJqAZ0DPQ56GfQn6CwpRhfEl/jLVHV1hZWS7PRwlLO/83Cj5FvAH8v55+z8G/z5YC/i/O/tvB/9A0Hfxvn/9PCf1XJAH8L579tvb6aDP5Gzj9s4c9UO4G/nvPLLPwDaiT4T3P+Tmt9zQb+Ks7f5OdLrJ1w+ecBiY9x/tMW/kPCefCXcX6hhf+O8A34D3L+fRb+t2ID+Pdy/lwLP016F/wCzr/Jwn9BOgL+PM7Ps/CbpQrwb+f8kRZ+rrwb/JmcP8DC3ydvBv8Gzr/Wwl/gWwv+ZM7vYuF/5HsM/DzO72Dhd1YWgz+O84Ms/FrlTvCzOf9PpZU/T50B/jDO/8XC96gTwL+O87+z8O1aNvj9Of9TC/9ebSD46Zz/voUvayng9+L8o36+zOqFbuAncv5rCnnKqEa95Dox+mfbsRjYbzdQH9Aw0CTQ7aD5oGWgp0D902IcnTvGOJ5Hej+oChTTI9bxHo5fgM6B/gCFP+Ry9AANAs2eGOMYg+ONlAYtAh07G+N4/CHylxrenrst7cwVP/xpQOIhzr/Fwu8hvQl+GedPsvCLpErw93H+GCtf3gv+bs6/zsIf59sK/nbOT7Xw7epz4L/I+d0t/C/VleC/wPkuC/8FbSn4z3F+mIXPtALwn+F8yWfyfRjFZoG/mvNbLPxqYQr4j3P+DxZ+H/F68B/h/C8s/DfELPCXcP4/LPx2Ujr493H+3y38C1I8+As4v8rCf0aOA/9Ozt9v4Z+RHeDfwfnbwE8x+P18GvO9YXrSBkvJFyj59xumL620lOQrGvsBJZP0/t9Schwln6MkV9e/pSRJ1diHb5hjz0xLyYMoeeMNc/SZYCmJ1jT2GkqyeMkoS0kFSvagJFP3f3+JwnIFjW1GSR9e0tNSMlzU2DMoSeElnSwl/SSNFb5helF7H3lRdqNeliBrbNEbtmPPwa6LQftAHtBboM9AZ0C/gGRQ5MMuxzWgdNAQUC7oRtDdoAdAj4M2gkpBx0GfgL4BNYMilrkciaDhoJmgh5eRHz2g9/9ya1vL0Z7kN8wYpNZS0hf66viGGYWUWEqGQCsRKJnNS7ZbSoYDe+XogMRbecnzlpJRQNiLkht5ySp/icrGAOEfUTKFlyy1lLyHki+Omr3pfEvJ80D4o6Nmf3qLpeRmtPpNlIziJRMtJfFo2yGUDOUl2ZaSF1DyylEz/si0lASh1VuOmhHItZaSJShZi5LevKSzpeQcSh5FSTIvifSXaKwZ8tyHku68RJNaS/JgS3NQ0lkf/y0l/0LJDUfjcg6xEtWWrLFJR23HnoYut4EOgT4AXQTZHnE5rgb1AU0BFYCeABWDqkFfgY6BToLOg/4EZdXa3Yk5SROTJhzC/D8pNylnq3eOrB8fMI73GscFcm93vHur9y45ITeB19Pzt8k9cnsgP9M43mgcpxrHicYxV7ZBbkqdlPVjNud0z6k/n5W91fsRfGJBHex5ucuxF6RsjHWM/TLWcSPSZ76IddyD483IL8XxOVAZ6AjoI1Aj6E3QP0GfU33Qj6Cho2Mdf+KYXOhypILWgV4CvQ36hHiP6vM3e8rzlWHuKHf278dWTSiwpdu8r68KwxgSD12kS6fqgvrGNpQXrPfsnxyUfKOQ7OTRsRhfZ8N8R1/jsg/cP+bSN/bkP5t25u3KDY4vZVtE1hSBmQxdI0LajWs4cY0lnn1skxaUHO42r7NetKV83UDn//HNd02b8s40hWAUobP+LYa5szzBiX/jufOol+19f+VTufSN5lcUW9L1v01ynbgQnBRadFDolHHiQnhSO6RSMvaxu7Rw9z7EzrZ+Ie7Q08PcK/M6JASXHGL1ii099HSS+zHkw5GvVfaxfC34EVqLemnlPjZOs7sfxtWXKMGlD+F4vxJeuhTHexRavSpeudU7VLK7HwBnrrLVu1h8t0pLn/yLc87x38PHgJKyvc+utG1ciPJpKO8g3SGthCWHd0BZDqg38ezueSgfoxy9pEUva7RtznePwcz2DvCycI4k2t1Ozyzk+uM3FzfemndrLuVSles8tuSQxFtyCzCLnCum1M3InQl+d4N/M+ffJM6o2+o9K4bALr8XE9xB7mmoE8nrhKN/oTrXi1PqOkP6nd4MIbx0Asp9PlvfEQ10lVxeg97uOqghJHE8z6UjN6bBlj7qsuPQ2LwUrtsDQlDT6NwFTXack81rdRb1XeRhiSN4Pgb53Q37m2zJzU0nLtiyh+TQt8qXUnqvLvEgcI75nkKNn5rikzqUbRDaZ9iSxgjdRgSXRl1qbwsu2uHVNFvK7K/TUbMMbVzYmJqfltcVbd/hfV4LL+0N/k7fm+dsx8bBxsfAlieAyGfykX8M6XTig15H+l3Qx6BToPOgR7q6HCKOQx9DHdCToM2gZ8F/EXQdzjuM4w7whiJdgWNPHI/hmIDjNaD3H4hxjMI1RiKdAeqGsrtAH4NGJcQ4Jj/uckwD7RDaxwcXR6C9bl/4Nlvq1gZwnOHIj/RtAgI5TaE5Gjui3H4uJEeib4zh/F9As3DuctDi8fTnrA2BH3wjx7ud9dqvPWrD8oNeAJ7BoXmh+WHQSwk7rYVW3iaEyHtXuByrQcVvuRxqegz5+OhRE/s0h6wPc0ef2FYZURH9bvQJnbacj7adaR6ybhdoDdK2ZGgiO2Rz1KUUx67mQdtsvU4Jtikpbg8TtCNjbvgquPz8bbaikDLoKDi09Cf2lBbq/rDuZN23zcGFu5pTC5e1fFB4uSWn8FKLU4o4eX3CtZCsVOvpTnF3qaz/NWQ9eotVmQvsmZlz7IMbm+zp0Y36md0Dzmw+2SVnfILGntN+aApKb8/rLGv5yF/+7cm8hNiclqbg9NNG2Xl/2b9OTkyIyjnbZB/oTHdcCnFsb7T3PNa0FThGfJk04n7Xk0P/9vYfw5EeforzXh1+GUcn8EoHEcpX5V2de3W+DYgO0OYV2DPnzU4qiHefLtg6Ph4j0gwtOn9lXXReFMc8QXsVNV7lNbou2Dp+d0GltNKb3c5Z78gLyaVrOLUfUePH2c1NU1fo+sjBcS7owRU0BsXFV7E/0E9keGxJxy/YM49fCM6Myw/mV9yO3wx17y445XHmxfDfu6D+WBCd14Ff+Uf11YKovPY8/a2atKB9noOnv1Sf8tptx6uyx2TVh+cF5/5Iz3bgt7zG78c+AVlB40BBT3CZ80Pc2ULlsP3sD25ftmNxK3UsELVo1P/ulnS7i8531gbPPi7sdU6+/OESW0KI+7hQknFcaHDGJ1ZmeFh3NemakEs3BGX/9s3UsUJI16IxcuPo39YCw9brDq61XaoMxRjv3s/qZVvSu0JDRmi+rci+efLlwgdtScR/XA6uzED9r7LCeDuCc3azdxTC/6xmi3fWT7aH2FhtA87sNDnWa8fVcM2weESZV6HmNuUkSm51hFx8MviWgpNoITxl6addbEkZuPZk+aSwN55q2AdUXZwe/dwxe6beiuBKb709IQRXWK7QGTgz/qcmagP9nsbeP+aa4KhNKghzZ3piDI3Eq/b4DmdPQYsuKRS9d3+0cZHWc/YgT1pBCtego24vu0eOL4j3BBfcirwtKWl2MEa67Bm2+Nw7Yhxd+8Q43oceHBPiCxy1WZZatvi9bJIcDEsKwi9dVP7k51SgLp2TVTu2e0warUCGfEX2QXW+UuZ2z/7zndhtY0K+isqL5Lx/KZH5nQpsF58KnjX73T+63RkycNZdDcLejPIxQcfAtZF+xt6VVb/auO5WHOl3gmA7dP4h6OFbo2xx7YQCihXi3Z1zPaxCcdaFx2tsqXY1RmkP26s46jS2HRYTi9IdmO811AX3DfvGxGqdYo+PPhvktrtLCjws35foDnMnuM8jPc5n5/HeFpy7l51EfHtcOw+7nfdIjOMCw1w60uWIX6m3YWVzSITeJ/6vP73PHCOS7enp4Zb0dZZ0hiWdakknW9LdLelOlrTLko60pMMsaZslLQmt6cuWdIslfd6S/sGS/safXua9Q0u6J8kT764/78xe5m08ZvIzA/hVfn54AL/oGPmzXlKpBufDJvN/nAurm0e/0Mke55hi9AHLvLvVMJSHoTwsz56U4A65lGF7xDtV0H16NurZbMef2DYm1ugzTmrhqG9LmjfPlrRGyMoIzaNzhsODvtT0c1binNWy07j+YjXeHZqfLaQPC+HXf8SbZFz7OOr98ovTuG6JFmpcN4RfMQtX/I5f8Szqmb+/zJuD6zn49RLc9qSwvGVeWbMnma1Y5r3Mz4lf5XL8+1encf2GZmcheuGWXhHXZzzifUZY05wc4aynsTNzwsDJSQUDjRHUljax8UzzgHX0PpBdzf23bffuEhwtzojt3u1COI5HMI4da7FFeFuyC4+0fLjuQEtKxPmWlMJnmm0R8eB/2GwrPNByIIK12AprWuZH0Jj1FMq+/rqmJZfnPj+5E/MJAeXxaM3nqL8Sx13e3tIppJMKXmx2FdJYOrulV+GLzR0i3rlkDz7Q8kxE0mwaXbfgWju9Q/7i/HbSl0h/13Q9fHsCKAdks6/MWvZJ2oApSBN2271ZwubmDoUn8Rvh+WEtGyNoXBZazi2c37K/8LNm28JnWvZHZLSEA5s3I3F+bUbOlsrX2Fdavzxbgr1EYyO1Xc19unzbHBvxOqTd7D0rZdWl5tC3yid7tYyreISyq7knakRHHOM1/iXZUpobdjXHgxcagSN474H3Y8MRlNtLlnmP45qdugBR44zDKD3ZUGmUelAaw0v1XzyA0vdwvQ689BWUtuOlOKJ0q0TfywpHi57ASHIYfcznq2HnotNR8V6vwfWHyZZttk/oWJuW8wJku0dLNWQrUXc1p/CW67/0IGTriSvdwmWLMWSzyjGHy2bKcX8bOaah9Du/HLPbyDEWpf/yyzG1jRwDJXq7FcnRFXIchxwznvxrOZy1I3I2Qo5wbTjkKIAfxUGOoVyOqpYQXKuDlFE3GFf6UyU5nJXO+l3NA1DeHr81AOUq4vmWBl2vIeD1Ae8yeD81nGlOQ75XlxPgV7bMBp9maqcaYN3gJ4Df3uB/I9I3q0nWAnioghZ0MaTphtITIt2NvTPZLG9W7cOFRsLjW34FwuMNkfYtmDW+UU089NIKkXb0t4MURfB+uocZBzyWR8cE4HHik09GfLeoZZSOS5/moPVTc3Y1T123CfgsU6dwPS/zpvgm5duLJuVtaI5cZ0+yl3Yo2dActW6Z95SyqzkPLYoxcHtQzK4bT/rnuLkQ4QatJ+xGo04k2pWDOrPRrl+B3XDwogzeTeD9AN5gbik6bwLH7UzzQCDSH7iFGrhlc9xgEYjR07pQi7yor58zQKQvDpI3Ufta+deCX+W3q8/Q6msMrLujtCNKXzWwpvJ3FB3rON5CsrfN3lDUecF/hSpcIdK4QhhK/xTovR3tIfm3iMlWA+vUJ3V87wDeu42+2MSdMI8ofm5kK+bTgfn0dduAeb0yzcD8PnkKMJ+SH1k0JY8wjwIvHr87KeLbZmfEBmDuKjnR7EIqdt2G5jjQVaCrQR1BnUCd1232PoszxnahM3QN7RGy60ahnc8qpKEufg0NtWjob4KuoUEWbTwlkIbQz0PifhZtLAf/C9IGWrPZ+w+FbB86iWj12gKBeh8TuddRo4eBHPUHMwXqfVqxP2Bgf7XRHrrCeIG+E2PWeBFX6GCx8yyUbmmIyqHvl8e7twD7+w3sydazV7WOxTbbh2OsOpj9ylrD7ifk7AT2mi/f6Nem+HY156IF1xgyhAkZdW78QouPUOteado09WqjI4q8f2p6fzCKt3CyrONJpcNQ2oTSM8BuCPIDgV0Hjl2R9zT4n0H2103ZfSS7mdvto77VxLHI+65Gb6k905yCqyRarnIE/Epc5Zhx3hp+FTP3OK7S0d/DFnn3oHZxQ6f8DkXm7yzymXjuwhhV5N2IGmsbqC/5Fr9B1l/kfVrTv/0WCQwW+eLdjzeNBsbz/6Ivufvuu0eBjlH6xCcTLDY+FzY+dx3hnO+bY/S7OfId+bPzbEUL3NG8R9nQ3GGdhrnOruZZfvSLvOO17LoZ+OV+BvqmzU7nvS/ZZ5F3kKbb7BTeFz4v7WrON/rmfJRei9JvjT54HLCLMrDrAn4jMB0L/igLph00slldM3S9X2RTM5T7USY9tmqGqbaU13CVzIjMfBoTooroKic4chdUWvnRtUPnvieb2qHc32UaE1q186lK3zKc7F05NorrJx56onplsqnFWl7v7/w5lIcO7Wp2cS3p3GrOXXiI+ibqufTWlaj616c6AMHnMZu9vanR8A/Sn23VlX2TqUObbSXXoz72kw6zcvbQ+C8PNvxko6T3EmQnA/FbD6o5dZnU/8ukqQSuKT0GSEetHrwPKvLegRZdhK5Suf0dEXc1Jxve0hOlU1D6jdG/d+9CFmH240XeMSj7ZwOl6cyPJL2f6GCUZqL0mL+fOCq12rUTpckq+Ylp15Ucmy7g7edjpF22xe9H37ET2Iwz7JowMjG52hExWschmcdAF6Qko5/eJiSgn07gfXQk8pMk6uEolqDRpch7Xsmquwa/0CBZY6KOhsSdUONLhWKiM81XR9D4bvatRd6Pwf++Qb9S+y67cFzcshv8Y+B/3kC+uF+yxX/e9AjitR00zlh0Sb5n9UvQyFY9js2phgzPSGMMP1wjZueP5n4YBa02ivakkXkL3KmQpgnpoUj3Rfp7Ue/X+qA9Q9COR5UcHiXN45JlWrSduY5GiW+b+xuauRstvkAaN3wyHbxZCvWKeuTb27DVaVwyOoesvlwgC2j18bEofR9ndIZVdLFYxWDwj3K9R5Wgdet2NPdHbGKTCvisw1ZI/kA2cB6zjCKMoTTa03gRDvToXRXbjXj3LPCbctnp6PtHTACGhB/h+GfKNxYM83JqgeHPYq6B4Q/C+PwcP4bBwG0ccEsHbuOQHo10BtKjRH3k6AcUstGar3w5dSPRlrdEwnCQBUOKhTJRKwu13vfpHjPAwI987U0fWYceg6YZnlUF3pfE4/i1B37XGmf0Rumr/PuWumfFt8Fwi0/HMCeC4oxuom6hXYzSp31mpEkI9wPCmUC4nRiIcIyB8P2ovbmB+hvEdfGbm5418F0JfKdtjrkCX1p7NO10piD4MQ5ZPz/nS2CcKd5t9DcZwp35d+XZiygCxTghzMuzl6YhNUGwJ81BOg9tfx7pWUhPQnot0rcgPQ3p1UBjJmSaCDRmoJXdgPzNaGMIR/5mvhqrIz8d+ExGzamG9OE+3Xop0r0RZ08AT5F16x1n+DHV+10m64Vewcs1NHIBvI/BGwZeqmHlZ8B7y+jFHvZmYR6T6Y+0irwNMsWqjGupD3qDLGipAGUFKHtb1iOhgog0SJQr6N6TZZRWyxQJ6brtatHtAZlGlQ4lpD/Ivw6SbVvmXSykgZO9jbg7mm+EPhMEU58XWp6lkb8LRQS6Tp/i7/SYfygaiN0j2OLvht8cNPR63PCbv9Itj3UN/Wanhoxq9Z/RiAdGrzsA/Y4Vsrl+VZatjURfOjJPn2M87C3BDM1e6kLJdk3Ha0Nzz3Uqq9Ssc4Ui73VyTt1AtKy7QLrsZfGivqjVM+Iwxz1J1r2oN3jxxojbWda9iEagZEM/0TJ5kT5HVVkhfqsbv4p+hk0mL6o0Su9B6VW8VD/3EmahdYZuVTYLpVGWFvwg0T7KiJyD7CPMUcuAobZa76MJx9nA8XZbTMB4THhlcLyyf/s0e0tlsfeyNgLnl2ojOGYPe29RhgGzYcb48zBiF3vSEKDmRNrhx2lX83X4/Vek7LpBOHudsfZAOGXU6yhFG/JtlPRIqrd/zQL+L1H0TxI9pAUhVs9eN+a3mIcof68W3rIxb3FLzsIjLU2FdMb7Lc8UYtRdl9XSa12Rt46vPdDVdRtdL9G81j6wYsyZRqqNkkIa9Za17C78E781HyOcrtMJqFmCOdVBlgmsSoDV68Z8Pn516zpV23H6Srxmcbxi/Hi97QvE62G1Fa/FaiBeEQZev6l/hZeOjSBa8dLjihbRxGu+eqY5eR0hFpRsYnabGt7iJMwKhZYPFtoHPtOyv7BiTFZL+LoMSN7UsnLdxUaKDFJaVkbs9B4W9CgnmuZU63Rs/s7nsxjTjN8kZGtEwisSrd2u6ng9beBlA15/Q3wwtU1c8/CbjVn++C4xaPaY2REFQbPzCsbMXjw+qzZ/0WlbeuaJTlvGhLh7HHMWfDhlSkHB7PWL7JlBaR8eC0paf2fjhZikz7oEXbIH5RwLzgxKXXvMlph3p/3iO/b0/nRn4nMt3p1Vr1958XhaW52Vs7/yIMtXb4UuYoG3T56ZH1vUHT34r1o8/l/QEvH/nGZLBt6Z9pITF5LH0ormZO+K6ej1yygyji2NKQkq0thrWkxpMGrTehbN1ezoxYKBQ4ZIc7WDrBPX2bX+uVoQyqlHjudrN6E4swrXXTU2tCi0bFh+WBFdV2NP4qrhOC7TKMbXrxqOs2j+/1mDHtXQlRzgyZh5ftTQDrU3aGn57YraoX2refsi0L7bcaX2KJumUYyvX6k9zjor0GxB71PoSpHgfcFnuBQ3FGhd8qOKoso6I/LXWzQU14nGsS+uE81tcwdsAeM/zlmH60SAFwYexbhV4K3kPlOMufBKeo7J6KNn49g6V9udbbOdBTlH22zxelybFAwdDa4NcUe5aaRl2pZmW+HJ5vaFy+DPBe6OLRuH/jhXYxc1Wj+d33KgENpBCnGPdrI5snAH0lST6iXNm3ePPXPePLpjlVUb5SZvDHGTD2jsY35+r5a1EeRL8e41zbaIrPrY2sbmKHjD/ELyKVqdDXGn96d2nNHs25Nmx7uDoEfdr5+qjHSHuini2qdR+6gtFNOc4O2NKjzSMj9igXst7581dkwLonmKFlwSVLoZcyK9rXbUyuYruVTvRHMQ5CjTgrenzU5xhxpeHgss6ArvamTL92v2ra94C6XRvzrb7/AWKlNxfMX7thJvtM1Ze33ORtj2t76xsO0g2Pbz0uj8oCLS6VSNopVJsOqgUntJ9GaNPaPpEYEd/czQiE3eL7SMuiHQ2t995noj1dRYvUZrX3q9DNR7G/PSXxqopJfuE6VBJXbYWpJGvGs08g+T11nTr0HrpPH8Gq+3OHCN3RqNX3rZBo2iaSqj8WmTd5NGUSCVnbgQdT21dICmrzna+Sxqk3cV/26ofvZ9mm59dr4Cu8m7RKOnJRyQ4xZfvHt70y+G7WUbtmf2O2RvjlqVLUBcFfQ1SeyoV1kDcsJplWUgPr+M4xEcvTjehznarzim4+rncTyF40+nNXYYtn4Wx+vgmd/guInWC3HMoLVwHL/DsQHHDzFef4LjLIp+cfTi+C6OtCZwHMca5XjHvzfhescctTbvdmmlca/YUa/fL6tkZcYeA2ft05UnLthc7V4O3Rw2IWSz4+WwvLDcExeCBga7g+P3s1e1sEq6R/PlUy5HGSgpFfPrxOMX7KDgRHteEDws/Wl9j1FlZQp/63HUpRxHl5JDLELrjny2+xAL1aIuZbSjZ2oc4Kv8qZEc8EWV3jGfDN5l1ZY8bOJkrz2ilztt+Qbh8Yy0wg1CbsZFpFdk3IN0SkY5/vfOyMy9B7zhGbbEchxHZpy4EOa6WHhCsG10lJ24EPzMiQv2ZR7EqcmlXUo2CDfvtnmZskWMjl89pkND9m/9Y2k/RVJuUn6yvUeObabGVmAkzuA7nDIX3NJtwJzej+4QHo9fNya8YfLl4iWoHZts75zfObepaRtKF6B0OC/N/i0zVi+NzY/LPdX0NUpLUTrSOHebcW6H/A65HzXZB4ZkdkvPnBN6yRn6fKM9/j367vszLsfKNd1tR9e4HDcvdTlO46iAYoBzOigLdMtT+jNKwybakrdXhrn7uXe7CeWoS872TuA2gz+pNANYTle7G/hOUtOWbxHCdm8RQjcCl8pgrz1og3Br/Du/Z+OYhuNKHHvjeDzond9tsRuEazPomZyU+A1Cz4yoS9FBjvKpbifQi165Qei00eZ9T9wihgPBKMh1geQK7pTbOf9mYSDdm8PI3JU/C5W5wJ4afMlu7z+HnmZq1zh1XAxQ+pyjNM1NOPzclDuOkPuS8/Lc7fIjck8Dm6DMzhwbR+hGYPMlfRMDNmXisgzHbaDSNRyL0c9VOrmdBUHWU/xNk/Sc1iH2qWJPDkNPsUFwZtu8s0T0qHWTL1+m9o4Nco/MH5k7KkdjT6spbv4VolWZCzYIvbJpn8pkr82hn5m8ks7eIMTgCsNwhWxcgRlX6JPfN7dfzrdNdF4yP08/p5flnAQx3D3DM/myROc8mehOzk/ITcav5qvj3G/zM3vZ7JmoazPPTs7W2xti/Jpi/Jor35XbMWf/lb+2GPVBMYtt3l8E+i0bnbEkEWiG5bbHb12ljnA/16TvwFkLLPuWuhy/Im4KBX6dQAPLXI5MHHNAs9bo939H5I3MHZlvg8eXKVfuh3Gqg/NtKRMbB+cNzKVeYasSuCOmb17f3P787PV/cfYuNRVnD27sldeTn728zdnd83rkJvKzF/3F2WFa13znG53yrubn3qr8p704sXlRuXSNPEXfi1PZ1CGvHeeMNjjvN0Xw/Tr7WZbBOc3361Cfdu9T+n6dZ3Dc9VTrvp1K1lkMcTs8GlujWHfrnPU485y8RS6Fduvovx2p0G6dCJ4OU2i3TjhP2/i5tOMjBdFjWF5Q7g/Qi9f47bZ7dT5+NLiu/WMRjw71JNUFF8Z6xhY+6bUHd3IvHm9PkpuctUEvR/aOPHXmvN3bLbyDq52rW+du3Tp2dNpOFW6s2778yToafTqenVHImt5ZwZq2Lrel/NHQtfC3plsLvU2nH7eltTQmFa5HHxW7OOHBvWyC8O4Fm90ej14+3tfEaru5ix5/cky0+yr32IZOHntKh4aEvNCzCXkJ7qD4pd43pB7QVhBkepGP6wlnpz9uT7N/FZLWszHoNVuSWwgZ0SlnL2vy9XfvZV+r9u1Fnqtwbli8PXmp92Wp4qG9LFZIdb+H3xzidubsY1dL8W7ak9PB+IV1Uvu8E03tjdyTUru895ts8c3Aa+Bm6KdIx+x5R4yjFml69vVnHF0oW1wb6u7udroX1C16PCg9otHuDsuLdy/1zpEy3bS/Jt69nw3z2ZMuPrS4/kHjOotrdwhx2TsE55Q1np3LO3i+W/50Xb3nvRWPe24rvNcTlBT80Lue2HyNNWr2+MX1txce9uwsfN5jixeaThe299iTWpqik35tuq3wLo8r6XxTu6RzTVFJPzU58n9usvU53XgZ/081ni60pf3e8M4KIN8QmfR50+wXXY5JL9Kc7qlK2NaOkD7hjUXLn6yOLVxSvUNIzkh6KOmsvU8weJnVIUmsKahPdOMLy+3VMYWXPCGltp52wX6brSjWHeEOTUBUq4Ym/dwUjPrTC5egFWeaQvuENkah5fak/KWhiFfD+gQ12pM+XiI0FS2P9cSiNT+jri3tfONnhWmeH1e090QmvYu2v422H2+KrQ1Ltm8Oedm2meYjFAfG1ob7Ofs4Z7QnNDWo0ZY0duni8WGpIcdsSe8sWTyexqlnK3u4dwgTMkKLdghTMsLwf0ZGcFHw4yFFHbe///hVO74V7txtSxv7+IfHNgrxlWvdL7hfvRQUjP436HTV2w/1d3fcFl4U4s52nzoGXnuN/UNzbdPYB1qx4IgP3x6ZOh527/JG2aJsabZJtv22b5G6zk75KHuindneuGSLDm6ARZ46kL/irH2oIzWKn3GTPdKm/7UDOW0dbBFJSQ/Fn7WRRyWJ0CJrMs/9/qugJG+TPU0+9eMK8jx7UZftsZe0zE7H7Em2oqHuNHd/N/VM36u0hhb/eMj2411QFq8/EbzwiaHAlPYb71kZid94mtqRFvLVZmj2Ho8j6Z0mexL666T+uM5Qfp16XOffDV83pT3R3hOaVN20GaOwLU1sdG23pcV8u1lIzBhWPZT/5lJY4nMq+EWp7nz3aH52hlaPM+Izyj1Us8gTvP3JutDtSzwL8oca7Vyidgw4o4O2tykM197TGJz0GM5NjrelVjUufMKW+kqjPa39V3SdV+t0NKgNT7CZh0KS5l/R7jlo9/mGFU1UJ/v3r1YG4/hLY2DrvlfH+9vRTy0wfu2Jy48eot974vLCQ/a0NafaXnkgrvzE5WmHlsEqb/OfM+cQ9TSxSYlXtKQbrz/0kNdfN5/XjUmKpP3IiVRPb0M4r9nz0CV/zetQM+JUYK3LCtVyHXIl/XruInrMggYgvPIIEJnaGOeX5wPlHuh5VMPRS6HRw08dvRQcHdJYvjzfk1Y4zNOl6ShqxyIP/C5/+dpF+Fv/hh9XZFZHJr19znZM2OJyqKDr0A+MAR29ZMfZVOtCgz3Jc+7opaDooMY1QtzKfyIdEh3Mr3S6obaJfu1LnjvZkAl8tp/Tf2Mf/42z8PxN5yL9bXxIWbgC5alNDZ22BaX+dOoQjvbUrxrPNHVIWnGOdDzqcsyhgnNLXtRjq7Cd0e5r3LF11Y8E1/3xyMDH19RVP0pf9LSlgvoMa0jOG4J+eYn3dS0xL5GPA5vEFxEnEjbRjeHbi4S0jFs9E6u7GfVe1brkdeL1VojXo2eIzzgd3u3zJcu7ejLRf1Yvr6772eMy6m7QnBhHqW6BaE+qXmxLjjhrT/5XUzf3iaZ098eg75qiPLZ0b8MazGcogkt3ixgXwoy+vD+OE4r0eJlm1Rsqu7nbb9ohLI5vt2nM4zuEOzNeGRPq/r/Ye/O4qKo2cPzOyjAssmkIZMMMIoLpAC645Qh4ncXCslXtDcVlHMtAWnSsHERTMXtNcINwLQXcwKVXKsN6rczifYfU0oy0VCa0GQcE7p2Fmd/znDuD6Fv9fr/v5/fn7487c++55zzneZ7zbGe555TQza0xy7DnTtlVK1a8Kd1YwYaBJKjsq0xfvEUl49nUG9g407Kj/CEPN0krZnzS3DogAnsZycs3sfFKXiL0MGYHlh91Ft/5AiJpauOMwEzgNvQ95mXQlH22E/KDfAoVgRUYfUPuPUW0tCKNHk0nQYtM8QroeuAWBfazguVBzSOaZg/4/ggvOfVizZtU8tCmK6xyz2eP/QQSHpnVRE9o8tdPyaEOefJy/kaenGCyUbrtLh51zqK2GYHURg1gg3gMwF4ffx3UIN2wh3nO/Q14XGlFeu7tO+ErpBvD5CvuhK+peZOXLGuKrvipEPMtfFOYQjUZXqUU/a9iRPymBfpjEqNlDzPGjdisiJl1SyAIo/vTW7WUYl2mpGFFZu25dP0FS/Q2Sn62sFRjePP0rdMULzuc5e9E+QcOF/GHqOzDi8TA1zFFh97EryxGFoG9sP/XFFS+kZUQyaHsZ01PG/HdGVMxSIOMLrS/7TFpi4jPnsVWkHNlVfa4ogo2ZANyT2U/bjL65KbAs0T7GpGbKayZPktDntwBR4/bTpXgSrsBzW02vvGYzUKeVG0VpmhbmHSX3eMw0WtpA4EB2r+20P6oB//nafMIrEQWeCCtpfdDfCNo4g2RNGDv1PCmECSl04RUXTdB+/nwbzI958M72fO0dhqBIGIDK8oDVG18woPgIo4jXpPM/kc3funSbdoz4PIRXkp0+TvgQXmKyMI88sw98YeUFr74qsouKNrDGF2UAtdN77Lv8kRXbM1FTJ6mF74ZaXf1EZkRLt8MLcLylZXQTy6Gli2Mi25CzPo24Z4NC998FvoQz7IKpVJLlXFc+6F74ZtUGaalaAcBvh8yB71KOoSMFKEfM9NZlqfpiZat9ATLEfpJyxWrooeLURc4Hs4kPHxQi3zjoO7HNdVr+2sjCMSV3n9AuQd6yi1nnj3MlZxASob3KvkuKRms/dVyKpiSqTL7UCKwSZPLON1eBP8b4AoGm9mwCcfF31d9Uob/B1TX4P/ZZynZz5DOG4KSu7wj4bAgWdIgTHjIgs9xQEGMJdXXQs91D9MOA8n6kBnuRQlPsfCGOJv8bdlpHuyTq0ndg7T9IQ6Y0BF7mDdkeUf0YciTSw1d3hEJdwIi4b+YK1g+KRfc5Ld5g7tjtA8Q+oVeMw2tojpCO1ow9/IO8WGImkfGW8w0ShdroRKziae4Y/47WUBJiC6nFKW5PLB3YzdxPMmD/w1wfcAk1tuP96VX14bSlDyno6hgr13bTSUk5eZ0eV+Xg23iVR1ggl28qj1MrPdEZqB5AcTmwY7o+mQ9VVGeKTbzht+CGBtHiQJwdbzMYUEbehlsl0gRClZ7Q6qw1FBdyZalBpSK6CawJJXszlRB6SltJfv+RL8tMNnLVlFDKXtzETXoY7V0yx7mukda/QHzI3uC/pjG0e+g0uPajzRZdD/A57QTOBCIqY2tfUaHVtfpQkv7Ve21H3H3qeClq+y/F3E+Bb9Vi1qRRddoBxPuGt1Z9D7tPsLfJz2f06FQ5lM32gQBkXhJwyiw8NI0SRtPUg54HaFPgP9saEIuhzYtrEN4tqKtPmjT3Ju1ZQTWUM8gugx6LjZXtNxEU/H9qg4x1d39aibS70Kqy8XWq4Brt13vqPcwSzyh1V4my1tpjTE2W0NRvsl3KSHNCP3zopU+6AnuIu2bBLq3exC2uOQtdSObYNrDPOMJBM5o2S8IX6SlS7X5wJdQ4EtGL74Ejw6qXqgLKkUaE93BhC9lvfgiAL686KvL5sqiF2hnkdrOdH9OB0EZ5f/wJfAevgju40tz0XM+aF+7ntE+RmDt9mH+JGCeBJg7u6XVexir9wtfi+ZoJ/pa9LLj3hYd52vRb1xci9b2wvznoix6oq+u9wDzR7TppLaF3VyLnnP9fYvej/lHRcN80AyuIVoZgTXJh/lgwHwIYF7ZHQSYb/Bm0YnaKA1ivMLhwzYjtDrch+1iVzM7DnyMd4LKvr4IYb8HuMb4oI8FXB/QSgj8vt0pV5evHEBV/RYmWf5ouMQ5L1wS/XY/yaAtnH5uhv8TT0RJqOthknq4/+2XMMlbU8Mlv8H9B1sjJJVXwyRboFwj3E/YFiGRXQmTrJ4ZLnkB7pEHj7uCKvz06yZR9pwi7FVMITj9Wlznw6jdeUh7mODT6B5ErwbP8IKzxIkj6TXq0NIPmLedd+V5ohvl+QOQ51InlUTZU4qO0CjVK53Iy+iGR2hRBdbxS9H7kGeBE08qWQHtcYhJcG+DlFxICfDBigVYo+lSSH3J+Wx9P7AtkxxX2FdWoAysnSRpME0y2ZcX4T7yw1ZQCkFp1a9BNWs1OGtQ3b21bkg95iMt7XywJYseTBdrkZp1zizapF1G6Jnrtln4dGa7dCLm+9WZDy19zYx5l5K8r0Le10BvMG+O+wdLHf2DZRfddWMUHdMyip7cIq3J1+BsVQHUF0XqC7p6V1+edqK+5JLSSjdqy7vOOS1YX2A4PlU7i+g1UONvZmoD1vkCqXOsE0eas+gZ2idIyUj395aACoyQ1fJ+1Vhug1OdlNRUaX1QWmmNA+swwIhfBOyzBUjxi4D37RnONvJVgIV8ByA+324L7XnqC/ajxjzJh6HImaXNILVcde2wUEMqzSrfG9YxXttmaWbjNuwGqncC1QFAcUpLUE0G4TDr7s1hufMpwuE0QsFPjixaSWL3D5ljLo7DklTMp+zF4SSS97QDdYXzZdtdfg4PhbqeaMESnY5a+gq7csO+lp30hy0U+MiGQ7vpUy0xYCNbXGgj69yV1uh7bOTIZpS1pCb0f6daVmzjdAX1ZGtylGSKMkpCD42UaEBHFsF1QBQhEYN+PAzXM3CthWtqSqTEDv/9oOzVa2ESjBWi3V6vXyMWOA77NCLb9S3EH4fIdw3++gNI/UJzNeQWQ+4nHPsA238SbKcDtv3vwTaQ5K4y7/Drv6NSa7Z02ah7YC5nZhz6mPSlnjm02Qc30fF4S2jN40RDfmaLaexRLjkUWrWbqfNy+uHtyD8kIPpWbWq2Rhl3WNca7QCxw/a1kYtVK034VW7uIb8/cbNF2qWEsh9BDoNrp4Lu7mUz4HcPK6oQlFMQ8wygxRV76irZrfHx0N8otId59cRCbjYV+qBcYgu087n2dybSwor0o4sAx8UsLz50QwCd0+GcHVq1nlWF1TJ8L5W0rBn1fC7kwHXRrzT1Awqmemf39AAWnhO+jxjMZoUV1BCsfybw0+JEW/uTO6iCn5LUZKjGmOGZnjIZDW/beUK0UdPARg1vuH6ESviASWVzOtYs9tuqWw60VTqodzzUS5t5g9BSDWOpYZIGXuLbZEZrBhlxGUxnEWl9iZ2oTSV0qZ1f3mi2xhqPgG715mh4M/J7eUfeYeTrsYOD6RGk5FQ2XasgJVOcT1pEFftuiLcvBo3baB7q49kEdog2huSIcVIJb1sq2fkFL9cF11ODjloGg45gnofZBPKF3oeMxNlukQMX5jhRqoa5Kq1P3CNVo0HPfzX7fUo4G02+wvuQ+cPxDq5B8ulE43dTJjTDvR1kvE95hOQRuFBH0tMLJ2yB+1a48OwIlP/dknCJafNW6sVRUZKXIf0kXKKKCEkyXDuh/GPwPwcwiiUYtTgrrVPvwUgCGG01P08wWmw/452uPW6ZDvkFJP9/IP/j/5PfZJ7my1/rnaqttEyF/LccmP8jyJ9znx4hx/WH1b4SW7y0dqWFhhLfkxKVzmbrQGOl9b72+rnZmkhSeuo932wddE9K4AWEPPbwcB9kgzdV+4wlFSB/SCDnA2T5n0JW/A/khD+BHHr4IR/k8d4HtckWkHLoEZw4NKX8JDsz9YmA8POYy3Uova6fL99gb5S2nyXK9yT3hmv7WCLtj4B1qDyEeW8carXwZDvBiupvnIK2eRHaphb+S+DfDP+H4H8F/H8H/+/Bfwf8x74fIRn3Ps4x8+zbuu/O50rXTFWZblJhp478myq+SSmKb0bAFRYmMfm/jTzEHHNzc70Y04v056gZ/QW5SQ1Z+ubahAZeelYu1ZYkkJZSbXqBEPpkD9Bf3vlSFFRKDaPstaYv21TizzKlFUkQG2joZ/un0SOytzP5LtXDddn7bokDbjVJK4JrLi0Jz9+25PH855a8lx/JCmOb8oO2bcvktwn5bU179LzSa3p+qWKBoDRvgbB0zwJR6bUF4lKFIaA0zyAppeRx+4OrH2flYVlw8dLCkpmmKYfKFz5I59xsn1h0c/HEaaywT9HNjfEGw8P65Oycm7WTVt209w3PXnXTTPGyt2deyrM0Nbfy5za3it8VVvC2NrOynaJtgaXgYYJzbrYpeDclQcU36yKH3uTxV9wM4hffLMiLzI6rEd8UBT3BDpFFZsu03P+07Ldvivg5N/PHlNyslfJVmBvupm/MDiwP3BTcxguOyf60TdVnWnYp3U73b+KVx2TzK3bnCrKv5Qoq0rMVs4QVKdl5s0QVM7L3zBJXBGVfmxVQkZWtmC2pKMzOm00NnGYZQX9Fi+k1dDT9HH3Y8jyxYFRDLrQt+d5/I86MirQiDc6/f8Bc833v/+uH3Pf+r1TifN3fzdl/wHzjm7PHMjhnz5Wh4gN0glwhfaqVF36qVRA+cRav2COPUR5kRvq+10zaGyHBlO2M6eMgmgcYehmmwftH4fGQJXPrVO0L06kEnJtMpuN18Rq52st8DCXDrwoWzIwTzpqyhDckxMxT5HTMWAy50mI1sbo4tRxg7PMm0fza/JPb48Sz3l1CA6SXIOampqXRfXV9Nf3UVosgXTDr27jI3DpWIBOsK8+UmlXti1MhT2ofdZguTONlVnmV9M8WwQJeGg/y8ou/ADv5y9AIycc7IiTfw+WA6yZcYTvB5sE1Dq6n4doBVyFca3biuKB3Yj9aUCMi3yC/oucNedXMB894DrzsoibB1i+WmJKlZpNC1T5mBNQ94iXNIt0ioHKyd8DVYQuWxaXMWqEfA9iPReyzFmgW6Azq25ZPID3duK7ujp6/tDyzD2D+CMF8jnqObi5gnuTFPVSEZMb5tuIPizMuedbKpVMAzoR0aiDyQU4/o8M9QH63jHkweVbqghg6WLnFvq+bT2fU5XRMJfPBT2ke0z2lPmERjRoGtVEpUQ18BU9RmKtfwLP/1y2klfWq9klpj2keA3wve76ypCyAN+kpsyg5peDbW5y8hE8tHIUSQqEWv5ZXjtCM0I1UH7D4qbsNb2/DWx2hIE09TjdMU0koROpujy3P5AN9j6W+a3FB2gZWTEY+AiEtxycbmXSCLkkzWJ1nGftgCtASrLydusU+0UfLk2RWfBBIhlxdALTwFcNmcTS85EYKnkp7UDMAKDB65txHwSrnTIvAR+8zbj6tAmjPFHJ1hmkCdJHqZCiB+ddaFu6BWBGupXCthwvlpAL+v4brAFyfYBpcHXCFfBAh0cD1D7heg2sLXNVwOeCSgg6E6b3Mtc+I7Zx8sFP55uMs/4VG9qupj+oD1x5k/xPGW9fInp36aNyJ90XFB9nTYevZM7KYuv708KrtTDNLDczpUE87yJ5Kdcl5itTqgflz80Pa/x0mbAsO8CSuZ79IPQiltzNn2PzqNDqD3s78m12kyFv84eIbi5PogfZ/OHjLwu18XhEd1SRYQKVMNT+4RGTniboVe/I9cmHnqsJIlhcSXc8bg+PHLMTUUong6t78HLtYkkb/lk9BrZsyrxVIGlJo+eLZBYqCbaxYuYf88tLX4v2S9axEeQ1+A5V7l15dKjfmGctY6anWuvWsNHc9G0StZ4Nl69kQpaTNOzKny1v40ZGD7EwlbyR//4DskLZA6ZFJ8eYHqmNYXpCXOeFmLCFg1dazobLfjPFLAUZY1s1gRdZNflZMxCx47qOMjQKowKdggB4C0MMAerjyv5YyVrATPKpSYfo4+xH66UnxtNDcj0BdD1CflHmZte5rS+RrnE/i79jsiIjp+dTD0Ds3XWLDwqjBlP0dU9CSywGqtjUm3ZKVbL/UplZ+Glqi0+wDqSdZofIDNhbTFBFtvMCsNko6Tjted2PJePX4xz5v5Zc3tvZXjNM1tsYKxsLvg3ljdQ+VCtpembanUyHY07UxC3tTMnlY6gNVstLG1ge2eZln3Jk0v/oBXA/pTqZH03j3qHtpf74c79TuAGihdQV4n+l+oBK8qtikmCzX0F+1vS4OaetLie0TxOvZKLDAr7pF+9Ozk6U/FSQHlxdEl8cUhEsv5YcHR4Q+uHhb/vT8h0PFbYF8EdT1fIGXnAU7X7mSfTC1kp0H/wPgfy78P5SKcxwrWRn8L4T/ePg3wL88NQQkF1c4UQ3zWwINqw7N/2TxnUXjlj8R+viYzpwP39GLKvZfKn4o/7i5VkgHHKQUMbSwWpBIbVrPRuZ6mSKPWzGYzl1w6xW+fRsrqBG2xfBwbumOW18n2HZ2SVFykLlIsQNH0ZURmkjQRS9z0E3JpoLNVyyYHiefJV3KSw4A37AzHu1KsDpEF6L5w1KOb5YJksXmXTiflxeokeqk6qvgDRSzroJ9Rz3+Eez2Lbi8cFVUcro7chf0/eCatAvn0BsBZ8FBapOXediDWPLtk9mp5X4cd7kfrVVC7KM8vrqWSuDvp0rltIIWVItokEUVrsXU1/GBBhPQYFK8SPALUgfrgsFy6yBuCoDSKUBDMtCQVvcS4pklBnsToIaeM1gbG+C51GdvFvpty1AOX/TTXgXKPNaLXBVUC8kaT65Ojm/FaMOG+/kWDnxD730v31YS3gZrgG9qP98C4E2AYhXBOFCNK6muEM5dsfTmG+KDfEN8kF8ndnL8ywfchH7cBlKlInmcTrSJw+8pb74Pv2DAT9U+OAxr76vpq+sHGJ5yJdHiXi3LB5/BB6+/qQAxCVX30fXR3LJsj0ucFbiMP1gCviEFV3spgtRBOikdpGkmWDYD36bv4njWu40LqjmcEdfU7RyuGLdSiVfY7Lp/Qlvn2IWBR+gZ7MipIJ0bkuhGNnrnQabCJTicGUdtSaG/PyKsxpZv9yypS6IDqmsZnVNE1mTtQe+zh0+n6dI16UDJDBclm3EV4tJtSMl7rAC8mQm8mQmo+YDEMCm6TDpFkwKemfB8qTAZV69pkJ7SQbpBmiT1ZctP8OasXrJ1BVn192Fhz/pCdaNFCJTiyrpI5TqwsBFKxC+ZRvxA76d6mZ0e/P5VQORPBJCfQ8jFIbrTFj93kwHvgwhzmkj3lQWsbrpgqGLW8o7lh7nd91HWXgAevbrrrgyiPBbt4viIPN0H9xvh+gqunzl+Tny7ln9YmEglUFuG6UAKcpVy1AlRmZd52hNdjzKI8QqnGVxMVEikIEEzUDcQeHfS+Qf4W5w9QZ+LKwXXLaG2ZGWD5VdyGpZE47o2LzPUg19Tc/IkAXnK6ficSEpfdV9duOaSxa9dPMLbYsKBME2YLlz9LXAd3ixDrud0fIFcyON04DOQoZRZB3ANpY9mv79HOfrxPrlHGcrwyRTK0r5H3yNyxJOCLAVdYClTYDXuOz7KIQY5wZm2s6T1t2t26Pj0DqCWdoaAnEi38qA9DzJ9PUV0Rn25plyd0/HtYi+jcFKyRb8qFuBbHlnverY7Ky6AFjbldHy3eKNmI+gslC7H9xp4K/RKK7Zm8mmkqpHwYp16ne4dzVkLByMD8hx316yRVpQTmfovybNKvUK3SnMC8qxnY2sxn4qWbD7IDHCKiORngeSLq7k5fyrpuFlUvvEeif7hVYxpXwWJflXzmrrMV5cIpDNWWQrSGQPSmU6n0QhDshl8GkDZaBaRmBFl8xPSMnN1VyyJCwrjFBAtZhJe/fIK2q8ndbM1s9ULLEfhzSZfXBhkllZgTBwINFwlNMxQz9DN1Dxtua1ot7SDfGtojHUFpVvsSlZQgVEdBZL2OZG0aZoJumlqlUU4MnGWZBu1JShbUopQU80CmqOTR841n3hYVPFTj2z9Tuqh1bRunEbup7ECaNxZwdGYeJfK9WwceLdfyJlaAw6LiKy/BpS2RYZezaIzfbX8h7wPPeznRE6HrZBXalJQpUt8nCjSSyq2ZYqhZHMEyk0S2LnXCSeQfi5qzumwF7xpuQNpmuxg5Wb7CS+fVkIf4FfC1Qc1Qt0aQil+44I6ijqNuo16vRvs4I9Ph0uOwv9TtyMkZ6aGS96H9E/h+TxcX2+/V/cx5r0/3nVs5+Jcv34kQF8pHS6/nRkDdsZBNCwAvJtEvbKFD5yDuxH7M5d3vHQo3NdP7e3fOnz6tOSxK2zGkWbQKXFbtPQH0KfgatSCf3pFRJ9U7WI58uVlTT7oUz7o03YW9SnEp08vuVGfFmoWgj7xQZ+WsZTsi6u99Unu5vRJ1S6V52nyiD6F9OjTzO6QHn0SkPafqZ6pe/4efQpxHVkT4tMnIcnztHqa7mmiT+JNnDYJiaWGaIwV9GgU50u+c1FJx8xj9T+R/pOqfYCCk4DJmsk6tXozwJisyV0gIXCOQpSboAypCCgLqGlslY6m7GJPHwJ5rD6kbYqkgniCZDqF+IFG4JZ4E+6BOhFiFx5+Wwn9HbwLdkvKBVCbAPg3gvj/YRqlTql+AWrLJXTJ6edoyv5jN88HveJPfcwi8pXj04dH61G+URIjCnf0+JdM0j4aEkXEqCW6GM0wiwS8zJFJ6GX6H/aPT/yfyGRvu3xjiViyEuTtZbgqdnDyg7L066tiiR1iM/4h4SDwRpsfRm+Uf9cb9XGFgTfCWenevmg2iZkUmgTwsh7mda/V1/cTkYgGPNFmXGN91xMhpJtOKulSLz+kai/wRaxRur7gx+/6IQlEXKr2xfF3xx++6+WJwBNiFFgYrAkGT9RAPNEhy/1+6K/i1l5+aLKq3RsOURj9uPow87wT142r2tcpuD4tn35U9yj05j2MxBsGujBFTWS03RsRHH+YKXdOigsE76JYPFmjhjy/eXwee7ViwaRHr7DC9zD3YWajQ9SWJIFeoXTh0uI6/OLC2o1WVtVe6qtnjCZdNwY8LacpQ/XAv51KWrTlAMRP/P2gBaXfH0kHHqIWaJz43S9/29ClZ5fY6vwjCXtIWyRrUnQp6n2W3vZkMFmXHqtL1AxSl0O0LBkxCaSqvqna4m+BfaQFYjUynUy91nI3ohSTiDKZ6Gms7heLoI0ffJoNO+WPKKvJ+r++6n5gaftpXoQ2MIPd/Ho3J59ol5RwfwOu8bs5+ZyzN0KyFe7rd9/bTv4Yyd9eGH/eF3tmYTuthnZSQzutdXCx5COF/nbK1mVrJkEbDPdgO2Xd005fOWhoJ1W7Q47fHniYUA/KMrRTsWLBuByujU6xOXaJZCj9FBuwAeMoNS3afIBJ7+G+zsf9EgeVdNW8rD9/Wykr3HB2Cc6PP2jmWiGnI4t44SRNkm6w+kSvVlC1h+BoVV6MLkGToN5PWiHpYcWsr5s+tvh9ZnY+tkJ/zYO6AdBO97aCqj2cjAVF/0krRCBkRaQ6ElohUvMmaYW/a4Nxe//f8R5Hrz/U7tXs1VGyPcw//uTbgCjHDh2upHqpaLv2fY0Acunu+z5gk3azZisp/8iflB/qeI+Uf7roXe07pHzKfeVXad/WrCXlB/xJ+XnsClJ+QtFb2jdI+aD7yr+qfU1jJOU97v8tP85RSMonFS3SvkjK33LfW36udp5mISn/y5+UX+yYQ8qHF/1DO5OU//a+8k9pn9bMJOU/+5PyTsdTpLzT9Jh2Cim//77yk7S05lFSfvuflH/WSZPy10yPaMeR8uvuKz9CO5J8V7KHeetPyvO7R5Hy35mGaoeQ8gvvKz9Qm6gZxrX/n5SHvigpf9w0QBvHtf995XGfVxnX/n/G/+7+pPx2U6g2mGv/+8qLtGJNONf+vcrHXn3cNxYf9yH33Ugi/I+CSwvX83Athms9XFvhOgTXx3CZ4fLXfK57LNRsaBqjHUvqve36q+9ahmvTNKT9Xdw3K++1DNMOJSkXfClVLSnawSTlO19KQ0uidiBJ+bcv5YcWuVZGUj72pVhbHgSeYUqdL0Vo6a99gKRU+VJiLVHaSJKyw5eSZgkjO9PuYTb7UjSWIPLFyx5mvS8l1xKgFZGUlb6UUovZxyfkGX5bIzkuBGu61ylQn/xdojrM/LueakBbgfYj/ziVKC4W0lNlB5jpXm6/Vcqe4Uii50LMI9RQ9ucduMNlPvQuLzdQDRhDZBzPXiCih9TJaPxuS0YfYEZ7k2jcd93LfNPg/SPjeE7HO/kHmDQvfs0DMYPr3q95+pCveaD9AeNQ8jXPHmYgtEmwj7aHXNCDI1/z7GH6u+79moen+c1i99F2/7c8fzc/9//VfNz7TFX3/z8f9//tfNy4feh/ouXBNBV/gPnQQckF9KlWsfxUqyRzxWwqnpL9uzWYV8xmyHLs3rSY3Gjfjq0qg6TuANPdvZP8O7pxZk1A5mtyOlblU7L8yQAlgpuZ3cm8251nOA1wYutvg6y3dufO3mNQ1Od0mEBSf+veOTvXEF2300Ap8euSsJPKY2eXCpOD6PCLPLkJaha0hQmlNNU2mvcEK5wxEa7dmY6mqDXBpo1LSvIpeUx+eb65VRyv/BSwm8zN//YBWtfVPq9RGUrp2/IDzCPOsUvzDbaUrQ2X++NXOGUNMYWrWacsoC2Yh++HOgsNlLyYtcnyDYeZGmcRPbW+0PAYWRu4hylziBNkdBDh2ad6aoioWU36WrxxVBLTRA2sZMZ7cAXeKejl4BvKJaSv1lcyaR6BvrDuEe14AqXAsaz/NDl/REzhzEI1Pb7gMJPtPGf5RB9URz0820wlYMmxzvEF31gES35gk3byUqLNkpR0M6UoYSlljn2apNZwgCl38JXZ/W8Pabm4rL+oLYQqZoNNdYYM0I6x3QPpegtvOFVWaJBrgbsFeO5kVTcvw5OkvCiorgXKRrPPfiKsoEpjtbUGBY15qpkt3Tl2WmIm3wXxm7KWDE350swbHqVB6xJPdmWMIPexcH8C+lWmxfH0VHgucxwlPPOCbGRLai3Qj7SIEyosm6oiJJurODtRA//nL0ZK6uH/gf9ESBZ9Hg79IIGeSllbi/sV9KMDLgtkcWCh9zC/siJZIPSAbstjoN0OMHMcKUtzSZvN6GmzVdBmIl+bPengVecaDjH/9SbV9cPvl8x82S8WfmlOx+XFqXSugb/jELPUTSXduXy6lQoQKiiZbHFVfkrB7dxvLQ0+/BDX/OPvLMF9oJ/8hNJTSYMur9UX6rdlis8JZBHaCMBrEyuW5Z+U04fAe1FJ4p9CyX7pe5i1LF/WbrktR3yU+kPMO92CAaKfJDinDW+N7G1LSoGM/tUilF2xXPPV1wH/HrjWLYmsQy4EXeYpBIvX6f+dSymyZgWuWfEKL5W3Ar+BFMpw342M4+uW4K7YFEpJ0kOXKfkuqGk/wSMEPBTWNAnwyDgpX5qkFwImh5jrXg4PMXk7EvAQyuUF13Ip2S3ApdXS4cPlqSr89hN3ZLgt70M4vp9VLNUTjsf2cHwlcFzo43gFu9CnJXrg+1ivpF5WkHGSL3Nb/HwU0aH0zHrko+TyIeYr3F0sPSV3yGIZPbwg/6QQcmaARaD0WXEhtNh8iDlOcuA+yIrFlCwJoBH9nfgeKzSdaLP12drAuyXhAy4CXltwQFlDZGER61QK6QxorwNMFGuaJKZFTZXMm+5+CkEuXzbw6m15pCYXaJnE3paPpvFOxeYZQjWon4C5CeV3J6SOYAviRmf7n4ayewwgyabzrYHAwc9Aai42JRXg2DDVsOl/+PTA/w2fAu7h0zfd9/LJDysMYO1n2rx/B2s/86vXDwv7ZwjvE+e98JBfwWDvkBa5xgQwvwaYtX8BE3PtZz7ygu4OBIqn8uJrAeYNZ8CA8Mv4DmwJSHqiu7aNkkh/qmTMLqEeU646KpmzLiHwuM/VZHoiXWuoZijniU7TchH9mxlz/NchVCgKboCc3eUb4maiJTQvvi8dB3nqnOIBoZcT45Pgfj/U2Q9q2AE1KOH5MNSwDWrA722HQh0X2aQwhPuGZ1Umz9xXG3Z1TmzC0WNQo5y8S2pAfLHkf12iARLzDdAI1MzdzKeeSuYVl4hAXelAGEUAe6FLlCuLQx+jykQMB9I2yyTAcZxPHxDXUPrdWmybbNI2Cm+6r20qevj4NvBR7GubSK/BQClWsDZlesFoHa8GPFXwA3S0/jl9FC04LUnPmySnmaZo/bY1FUt3mWS5ewoCqrEFX+s20er6gApBx9XMI52mnABzJRPn6kskmJxCUxRp39hHAHId7hqguGM5ppdUvJ8pMesN2fXy+ENMqJNKagX96uegZC2W9zNjL/EhVeAUDvjlcp0+k+aNPsRsA2st+EkGtAsc5yw8OdrwQ8wP3SIa/x0s7+Gr5q8tPFpBjyHfayV7qaSGpqN6g4H7fksOz/9qQt5N7qaSzprriKy9VcXtU4g+9mQtavsGyBvsDqCjP/lc+wXhfnd3Jeh1MFKT8BErUPLS98IvrpC+VHR0afpik+JoAaVYxWYoHyArNmcVvc3yTKmkVp77uV/vLL2dQrV/VrSJzVDh+4VFCKXmn7z00kyVfU5RkkFhP+Iw0Qp7pkOwbHuAqG10YAA99DyuHHjWHLskEnzBk2aeQtQ+qq8nsS9QGlPPe6TrCG8o29Qtx10gKMV6NgF3gchdzw5SfrwU94Qo065nhyjDlzyxZD2bLFsE+QaH4S4S69mHlYEDI6/mdHnyDrIJyuKlCGGNLmbJjCW4W8cigDVIhjt2UAmigZ7ET5by0j8p2H8E/FCXt/Agu0YpauMFBe6fkR3SNlBaPokqlZjlvnUEc5xURacljq62hLTZpSchbzL70/jAW2K+ji7NfJwWbAwwR0JOqtTLPAZ5BeV3yAoBtfMk20+Jc+qxEevZvkrkUqVp9AJcHXDSFIQcEFL2MpMOMFQqm1r5w3HUpLFVPJyqaGRTlc2tlIKXltVGCU6ycdRBdgT1eStf8aT2Kd1T6qenNLYmKJ7SNbYmCvA3KetJXfL9KwSkuEJAXpVS2tgqr/EyeD7QuvbAatwBSuLE86/xTuDky0UkzeMIkAeTO4dD/j7QGnT6zpcBuErgcfrrttcDQtomUkFs7fgA+4SA/cxs97j9Y7PlUgFbPUQeLGBrhijKBeyBIeGQcjAOVwsI2KopAvZQnIA9PCQhNKAtkP8c1Chg90/xMmcclWwp8GaUspLdCP8Z8P8e/I+G/w3wPwb+t8D/WPjfrMQdVkISBCNGZA/MHkyrQKYGsvzywGpeGt6LXUgL3vFcSAveuZ0JdXI6mNx3Obky/djxJDYMpi/hOQ8+e3I6mJL93TqEo0vb4vqkBF688rvArg0Ki+ovHzBEOU4lyxienRiQQA3KbUGNeNItpFkL3s12OyyUHO/edXaARuPdc67bllC5wyKWMyTPNpfFkkk06T8Qg04gEJpdzeRdoPsS+c9xXyD/q7ubyP+/3I3kf737G/L/o/tLiyDhMwuVMIge0FLJ/Jc9slSgT1tcJD9SEJ6SY+fx2wv4TZKEjsLYFv6QjkJhQ0dB+it9W/KPlxh1xqybfMVZ/M1alHKqVgyxywNNjUs8Dyc1eAZ65Ljf5n6mwJVMoy/S0xXMZ55KlqdMSxE2/bZ0ATk3o6lbVZvviwOyDKcgTgyqLzbsr8OTGnYyb7NpPeurg77HnsN+pt5LKfJm7yT3R+F+z+xBRmqY1kwl1tKKkoPEBv2qV6zI069nRSYT6LZYti0zx96Hv56VyBrZoLBR31Nymf4g4/FQSRE/8Qeq2osi+Q8fZMUgIX2misEST2EFUDoMngOmJi6mBkZApBHS1ocng3gMd92+fvkavA+gsE+Wt2A9Gwi9s7xZ4+k9b6wH+haQr5Q3OqiHP2pSEQsvHvgdyArui8P1kvYzT3r/n+xVtJt51MWtezxVw617/CAlXPLQ8QAdrzRAx3+PKhVD/53LmeHiVlVyeetruLWVmP/+vY2i93P7gOxn+nq5fUBs3j/bB2Q3E+ry7wOym5G4/PuA7Gb4Lv8+ILsZt/Ov9gHBuu8fO5Ac9zKfe++u9eW+axav2wX+RVJ1nHnOSSWGtE2VhFZJNgdulm4+zkx14m5ZKjqsNHRzH3hWO2Mg3yRInZAlqcF9yOJKY6pD9+OsU0BVzObYzTy71COk+22ttL/mbmwV8vrCXQE5xTsK7l5078IvNHm7oJ+2m6l01tFT6gvit6u9zDRoE9wLWUy+Ff3IRpXjFwxXrNvKUxbU2jTGfbZqI86nwH1Jt+1r3ENNO6dusYJb8QhPyf/U/VOzASBFeamEi5Zma1+jvxzOtfjKGJ+pI7MtWVgC579XQQmX5xTk79eT/6e7+ZPTkoPMaYoc+yuhUOqRZZplujegxG+ecfReizA9ZRbwoAZ58olDUhO6v9amlcZU3+XGemtcDc9e1M1xxOryc+R3l58j11zPE47MJByJcgbXL41/zYK030u3n+bsOiOZLULcntBN0zyn/tdf0jq5blkPrZN1Wk2Oeg2hE/KVczR+Q2g8kywxnwEa3wiG3OMyNbRusvodQh1S9pgjWxdX+mfU8exRPspMPZQt66HsNVcioSyRULbPEVxfFB/YQ5n6fsqSx9St8M0hPaiJ0yWp03x0qe+ny/BYXbEvJ5YL10VqBqhjfS2o/p8WPJOsBOpWDoL8o4I0fXRR6j9aqIagak5HFNURZM/7dPjPgGsCXFq4HodrFlwz4dLDVQjXW3CthetdUkam2oYw4DoMl59b/2KjDt+vHdSWgKpGVr8Bd5zl2Y1ujmctTj/PfnX6efaz8wjh2RHCsxDg2dr4l1v+kmcgDSVkpRvSuVe3V7NP/VbLX3GNrlvXIw0VukrNdnVRy1/xbGBygHmg4p1EyD9yk2aTbrP6iRY/hTSLlKE8xFQjZSDj0rvUBfmoe72HusU91L3kXEaoMxLqtrPB9e/FU39L3cYe6hbpXta8qu7zV9Qlp9WVEurma+boXlRH/SVlnwBlnyjK0GqM+IcmT5envnGDowwt3zHmR+8VdusulHGkECmNqb7beo1s/k6efZsrgNAo6qGR6qHR5cgkNE4kNA5hB9Vvi9eBxbjmvnHjrymdUlfey5Kl64ZrJqi33fjrlqzoackkXYpmhPr9G38t/QEg/e+TOVW5ZohuiPolH73HmFne+yUVrL2O02+kuJF9sZZnl7u4Fn3X4ad2rcNP7UqHmFArBmp3Mce9bxzdFd8XqH3RPe7GXR3z69bHPt360qdbZrh+gOtX3E8MLgaubrhQJyXgQyNrOH0bAP+Dazid+2v7kVa3m3AFbLrubXXkjb+WlD0k31tgy99Se6//FefS6j4g+V7TFOheU9+67ufaV5678s/xyq8BHL9KnGLCry7Wz6821s+vP9g5hF9zCL8e9Parq46frV5+/e+sYo3P1uVocnTPqvdd/2uruL+XVczW0ZpH1Rv+kro5IBdzFAfIfPl4TbYuWz2rh8KnPJQipjRqPycZFJEMlIgXazn57+/kJGJVD4WmHgqXsUMIhSmEwgOe4Lq6+M6Wv2u1I5wsa6J1CeqM63/dakcV3Nr8UF2sOuG6z4+VcDSd6SXrx8g6i0h1lC5AE0ZoSrpONaD8oRyOqeFkcFINJ4NT4d8vpyhjM+CaB1cBXK/BVQTXO3Bt8cli77MedzHjPP87B/ik6+5Zj7uYFM/fn/W4i4nx9D7rEfHYXXP3rMedTO6JjOOhOkFu8Yu8dCEdDP1tEztcmT4wu0uWu5+5xvLGBzTtfHEXc6dbpKPkMbm4n/AeyGtr6oJYUH0gQpLrO6fLy/wEUdZ+5ryDi3834N60NspwzDbPuKIWzxbDr9QarTwD7hP79Hn/d2tUs55+D1IgvwHfYn4uJ2Wc1CvXAvq47ZQB77/Dna0UUxp4ckpeERNgCxvTZKWm4ylndhutvWH7WjvKdmN6re0rw0rbKmOH7avpO6yRpCRI3HR1Q61tkmGQTWz01xQFtcwnd2fwnXG+LcDwuu2UscVmMg6yrZbya/Mn86oOWHjVJy0NQIfNQvYLP47RrZ3s354rFdJ228Qauy23ZItd5qol+0TrpVvsT3u5Hd4XwP1UL7d/NN6HYp6aWpsB7rO9HBS857v0UMMCW5LhtBX/zxoH26QEkzqbpvy0lWfUg+yutIrLLZDvtJUPz4PhX2A0kNPV9FK9LakkySYtaYF8+2yDpaetASUrrZISjH5PW4VQViT1fV+nxrH7HcxuVtjpniOm+9DnQbc+ukUFzb/FCw6A/lneJEnD9Eni75NpEdG4O+7TrdR8iKHXUA2qEAGF8oRx/joyC0AtCmkL4u1kvnJWskFKRZ24Jn7RF+qdzDHyHFmP3z8IV3D9EWHnz/O3Tha2X583mj7G7hZ7mXqPsLN5bio8fQBPRzyD4W4v3B304D7IeE6cv5Uk538gT5xkXGyw2yYbv4QUYfsfc7HUaSi1EUtJ19tz3cLOX+bhaXYI+SuxsL1jvpcphrquzMWaz0DeN0hdZ+HudV+pSW4sIag+xp6A1Bc9wvZxiwUVkbnCzt9nC6ojc4+xVZCeC+nZhYLymFzM+TGkPAMpT/py3vLlrBHjfprC9pk9OT+FlExIedGX0+bLeQDSR0L6Kz05PxPjdwLC9pW+nG2+nIcgPR7S3+nJWQuUxS31Mv08gopvWEqJaUcgVyhQej2PV8orRwiYegpyRi3zMjzI+a0v5xdiYec1g5dhugUVZ31p56H07W48y7YTdAE5rW64Ys0BLgcX/hu4jXl+gDzN/5OHNgo7f8v7N2mR4a8ib3+GfN90477ToIGgkZN9eXtartOinwj5foF8x7svAu+vWEcasS06fOcRUm23TNBvQ4tivGoLABi5PTDm4wmGUmHnd7nr7d/jrtnSi+TZDM9nveUA/7L1bq1nSK1nCQXCzhtzj7EfQa3Gbtx7Gmk6Bk+FBNdKoMtfStieUMjhS+iCfBfFO5jPu4UVp9kho8rY95VH66TVlGIiGzX+GPsTvDvaLaqYPmBa5rSJK1nlqICrTz4a3nMWDJXwikbY7l4o7LxqeA7o/g7qHN0tbBe++jg8/Qee0rqRb2Zs/+4KIpMu5zr4Lyf3nc4S+Odk9bbTL6vfQ+5+3cLOX/NQKi5B6ha87JlOXgWe9XgOrs0kZTTQE5X5Ntx/D1ZX2BmBrWUQtn+QdQ6p60qK5FrvyaxS8p+N/2CZvzZwPC/m2nbie4Sv/tQVpGxCRKweZLX9GCmLXzA/ZB3XS1OFXUOi0LZRMm4mFttvAPiSrl77TAgv4Dk7MptJmj9ZCe/Re7xuu0pOj7QTCRhETujJ5+aJJ3L7m1OdrrnCzjNLLoAVu9jqH11aWfuEuYzdpOSlBMD/+VFUirapjA1Po1Jo89SbPIGws2O+sNM5L9ss7IoWCLviKDPwBXCX8msW0Bn0OjvrFXby84BzJcidDNv8kjKrPrbMOi8I3zZ7zrN/pKbnIszIOp5iJdRxgeyGFgEQ4/gAlVdp5cdWWimS/4YHrdco25kSgDpnJUBFXL+ES+jfzapoh5VXguNKKC8b2JHKwjpKQXVSs01wTwGWEfqYXKorTkB1CSk+3OdP3sCOUmZBLhP8U4At1SXxv7EOMfg9Z9Z5SBecI972lnEDO175OtjUGXXAd/I+/cIoG22E8rkmyJM/meoU5eEJm52+8oqLVFcGlp9OgWzgmzbb3OmrbHun3wBPCy04fZ7tQ8M82yrDDfCtfqgSP9Q8lBuMMMYrEePrabF1G9gbckEyz7yBfTUV50u9f1yxpoAfP2UIO97hKw/YS8saKAVfgU9w156dCfVnRuiluRvYXYmz62bUw3M2BbKXoI8CzmQIqU7JbLw3sbtGXoa3RIKNkCPyHNknf/50qmtI2CrbTgO0tgFiBFKTtqHFttOIWKL8h52kUtxmH6XG90irzUcYYS221cZT8Gzl2mh4GDkrBynCOEBVjrtkxBVtYN9IrQAKW9KK67DVzOxOOdduZvYDuENOjFPiebQTlcOvlrHLUtcdLWMtaYVHMdITeM9b95fssBYDN37v2Qlg+MXz1gP37A2QcrGMlaRlQcmJysJ6IUiJ0Cchwi4hSF8cueeRWvB3nLKMfTOVSlGDNrSCFoDcQ8ucZ6vkXK7xBKNM5T8Ao9/TeCnBTcIutQD4USLsmiI4z9YiDQTOboskRdYk7AzPA95C/KKRbrbv9nCxjwaszEVnGeA636YyIoTfbWuMSbaAEuRslc1EoBWj9Ft0GqT3X65zljL2rdRIwgNXHaaVec5bDxp3WDORYoPf0sQCxYFp/64rAyyz6oVdEj5S4KcyU8lRUcbeTCusO89+mnaapVLxbKGwk0KQZ6yfIjnWQX23gAN283lrrbHMqpJW2/ZJ37F3sEgT0oFWIMOmgrSbkHY1j1jHdmEhsYpgZ/1tgJrwLLFueJIISG9PdNL3Z4Tt947CZpRlslvDeX9a3QV/2oHmlVZVSbXFBC1lAjrQRyPe3PnIXibkM5S1nP0Rkg1sYSrIVGdZ4TliaYLNG6yPGa9YxT31cjEyahTuGTtvXuKEUccxxhfRQrOqa93EPupyZqaDSgglp5yr2l8sdMp58UEQrf3i3ZlZNUf6U6BWCjHfTsbhrWDq3JRelYmnSchoF8j8bcDhzU6xZBPEfyvt4aRfIaBxNJqS8+NxRJofET0L6xbkZuUWgxWSHN9sj/PykkB7ZTyZ5GTY8Q3Wf0mx19DuVdaVwf1x4DNiLrgAscicMuB82En2ONV52kcj2Hf7XtMGq0HqZS56k46WWRfC3TkvBXcvwt1/vBfrQPpRkuOJ7IOsHoC78+CfeSkgJQKVfbWpjI2Q466ZK0znrW8Ap+YTTS+z5gOEg2DnBfOFXcPFwq4MEZWkMpdZCyB9l/ci1LEY7t731h49z55KHQtQT4PN52C/AP4kAuRoBsjRmwQmxjRlIGGueiFnQUFafkEtkaLmrga/hichbra/6kHPtolYpFOQJzJvPlgWlC6McQgUayHUm+uV1eHb8+x3QNEWEt1sy60DjuXbA1zCzkC0rMS3g6+eyqW7nMKuMtQwEicIO0/48t+G9K1CPPWDPQnaDPCWW86zZ1JTcj+02MGOSdZVYDTfJuBRL+1grrorWYHykzphm4kf/9J/1TuYRve1l5fVY8SDVu7zom911+Z/q97OTPLy4j+AyAf1ttOB5XOh/ClSPgXKV/FnvfQFlD/oxnc74d0R8g6hiIuEbSf4u176BN5Xus9bR4CHHVl+3ppeXmYdXtJoDSgXynEX3SBFaFXA/pDS9dCfabQGlqy3SstbGA/0mSTAdz30+eYbq6HfE3NY2Bk6F3pM0z+0VRlDDy2wrTV8aAs0XoJ3662hxlrwTr9DH2urLcn4mm2vYRRwu9EaboBYBDxXIFxV8L7KsN7aB2xWIPTB1oBNmwz90wjIozZUw7uLALMaLHOVbW1JK+QZaRMb8OwVP7wMm6RkMhs2fr01DMpFAqwoI54Qm0Kn0YKzH2dG5z6X248WtEkEXU1h+uhcXtVR5uvuUPg93b3JKpZia22xf+q6Yn3dsMP6OpTF0wfn3bfnkrDoAvQJL1j50MpCkCSRlFJgxJQP/dbQ0i32LhfuazMKJC60Gs/uCpPWM0c9aN8wRiwDO4JxUBn7B9jLMYPLM1HmRwPnx0ALZMA1qmYlO2b0Altg+WBbEkjvAuCLxFhjk6AEQ/+V+tgO/VaL7Vup0oaR5WeuJNsZKfCuvMYW6EubDmmBUsxXAzBae/JWufBENFXJUUbXfd6qAizXSMECSlE+roJ87Hb5ZKfz2OJfXxoFsvFPF5GrRTuYsp53ZYtnLUqFd0Xk3U549zZ5N+OosPP04l2LUuBdoQspPQceI2NwGRuSVp45oIHzeij/ZexoSA1Ow2//0Hf6LUicz4JgiZVsxmjMs5IdPZrgB/U8QepZCPWIF/+6KALqmeAqsx4CfV3TLalfyV7nl1lLgjbbZzp4STMv9rtKNeD+7x88HyW5HQ52c26UZNzMKMnlPt9MeDmieEzU7CjJ8EeiJGfmR0kS6CgJ+qg30rAu2cs7mLgeemcvjn85HuoKdMVCvChZZz/5EGgg3aK0JUJMfEoKUbqU2/X07yWj1YmSgSltLResEsgVAG3yi/MC9iqsofAsgOcfnL+1lFnfASocLC/p2KUyaxnQF92NJyjVWk6NiZLUAj1rMh9qCNILcnX6LLD1TVY+xJd86QaoHyP2JvjfB/84ItREzpofJMW4lCeF2Mu339w+uOeTU+i32D0fc+NJNi94AePXNrSCPOPpnnu+EcdBvvaNf+BYRj45l2hrbV96AK2ng2lOqmRutKw/EOv6NXCAZ2wkzzzfMx+eefDMJ896mjuF6Kj3inV7T0+EattnwpOOPvIGg2YyLu5Mpt4Qg+G5N8QQeOYgLqCDqxqBx17mNW9ElZ3g9APoI57eVGUU49nRxmYoi09gIeCebxxkqwLuR0mPMp+7KuH9Bd+pTpXwvhH8+wVSFz5HwXMAti95xpOoJcajzF4oJe7BsNKKdi2iB8NKyIM1+THEUlGA32jvMdBapHfeBRnYnSrQ7y32Mc4In34uc23uRfdmQvddqJsJ3ZG96PbDdXr8sY2kOZUesLWeedXNk0WTfk7+SeToY4Qf0D+Szof4UAb1IkeRKyiDmIawQoCy0YSyZnjL0c9R1gzvuOdQHw8lHD+qEYMvLeJqrHWMOwLqiv6T1ou4r/X+jIotPVQILgwmVEQQeHbn/xlXXr4Lz8eVmy5KVghxFZ7TeL9ebLG/Vs+d4Lai53S4Ev2KXFxvECeHqCheqKxm9pM9NBW5ilmK2WEnUeMQzgYCBzXQr3WS4zyQ5tte/I5hi11Tj2tTg8n5YCL6X8wdsMMSaRmxBJdYlNiyHk/0OguUSmtJGlqGb9gr1miIOaMN0CMGj/o16EwLt1vZBaAZoIikV6zhJVvsx1iIZEpWQZ8W2z2JXgVvM04usQ3y+TKu1B89pdqgZ491XrH4bSP2g+89x8zBlLHcOWggNTTaBtQM/6lmK4H2jJN4lpqEDsHTdb0YZ2HcNZicW3bJiys5HMwkFk/zUJ7MJ2O5KyHuCaX7wvta5xXrtB4bIL2AMc1ep903qiskKwnyTwrb52CvsuSKVVNyzDaf7Bkto3F8eX4Jru7BswT/ZaPKj9l+J3A+Ao8pJrBM8C5QKrNJS/BpKXmCuKImiTbbpDVeZojXX2Z4M54JmUrjGWpvefnVepplbgL2uMIn2JsPfrnD9nsNV3P8BS8zDf65c94ecy6wlZQv5WY7yMmFWFeWs8OmIZgqzx8DWvxjaKqS9yx2wPVHi5dJBRhLCIwhhAYZnWtLgqeBThx72QpyJKOV0MNbYzMBrjGQugC8irYkw6YvWWOTQlz7o+Mq0PaVBc9QnQty/aXMRNrRP1ZDdanFG2uprikiIbQH4ovfYQ/Ts0y1V9i1RIAzX+fg4m0Rdr0h4Fc9BG/ex+g8r5GVkDcCeDNcICRv/ukNrWpkw0yiLSyz1gu2xNjcY/8ERrTAaE9wtgnTTGBjQqvDQBf7gC6e94RVi6tYRuUVA4fzPTgWBvF6SYdvP/ahF8TVEnhzyYMtL6mWwv3HHjwDUlodDPfHPKFQ+jFfrX7b5K+Vs03+2lgmxBtWjfI3301VpOfyKlJyhZ0SMsIC8Um8v6/wOmjEapDr3+qEXQlRx339RLQzvAttPl2rhf7wMdtX5M3pBottjQFH8CJ6RpD8pYQXoEeQjWV/tQjbnyR3v1gebmWzsB02QC+e0ydsEWiPgHVHqa5oyVbQdGhvB+66O6QIIiHRJpISR1IURdjPwl7KRdIfHleIfC0l2rjaiD2vr+C+lOgk9nx+z+v9/mvSN3olNbJeRnuYWg/2k4DyudBDCzwK8Q1fz9XewmJdnaZtPfVk31MP18d6A+Bgf38kGdXg7kcpcSwF5EiysB5lBiSFH6s/w1JKlCYydqZIzx2bi6MNQfWUAlvhRt4lYstvGUpJa1xPew04jGPqtyBqvJEmSOnfhDHk0Xr/WJGq7ZBJ2N5BWgz9CraMPy5/Fm2AcRUZ//TnPmbCPqA/t7+ffjcn8mQs9KuylIr6WqJ1ICcefB57dBMZWR0eWUpG3CZDy7cQqNwc2Eo2SyZsL8tMhF4KjueesSWCDL1NeraI1d2ZEn9d2IP8oZeP2WzP9kArk7GxDp/k9LmwmZwTuRojLQO0qGGLj/NgR42r4f7SPZRz4+TSn4Wd1+ec/9P5mVRaRdczr7CcjLLF2AoJmrG5KAcnnB0t2BLxGnyqc4ZbcMQd6J1+ieD0JaF3AqM97OP59BE2evoo2w3wIXMBQ5G2xfaBscU2x5jRUxJL4eyHb4TGOIHJPOxrg78srbQc3R8hOb/ffy6HBPzN+lr0Ijiu52VecPt992BaWqW685XJy3zrllYLuy5K+GAJ4rpVeGpGT66JJNdHJtxtDHJBjqBuYTVa84fdKp+lHuFOQuhwp3RfsX6J431gf7gzCLrAgkJUXwM90xqfLylRtb9nIjJ1Z3cR+oG+HKSPvUyY+5jt1Mckbr2zkbwLcKOl5voFN6U+mUmkEvGdw+Uv1+Hylysj40aQl/gUVfvrRdTQ3CYqJbcJvAXB6HwDbxB/UBm7cyTYynlUyjgzNWxMU8/cQfsxMi7s9+qgfwaQ3EBhV1KsqlnY/komWjeU0m3cbIaRV7ratrfEv+v0ZrvXzatASL/byBxD1rdwH6tPz0W/8BNLybBn9obgErlDLAQpz5C1t/0Vb7zBMjPdGRaWec6ttmDtOXaeeO3PlGKzhT/oQ4tg0B7LIh3OeQnbo7LOW6hhBWY+2AugBOrBOtKuor0QV4GH2Yn+Bf43sNDmEKuz0Tsb2bgNXuYfLn/bisEbyJuh/V1S8BEsM8DNJ75C5fKPZQGv4iE+6zyTiy39kv0F98vQL9z5Goc31V5vQsyVb205wjJe12WL/xQQQTOH101LGasaSaW0mLG94l1XrBN6opKfm5GKPRbeMIR4oQkwn4084kZ+h/P9tu6MBfOV9vSE5k/H+Z1VtmrDuV4j38ILOF+Mdpt39W1itb/LRZv/jn2uE2fSUD4hYobn551S0itgmXNAtwp6TdKS9dYgkF43i7L/H+cx2zcEw6DmiTTyY6wL/SbLvEvye5nf2RDSc8XZH9DVLOD+5B85j1GSRGeQ6Gm/80efDBzzjbHjnFn5tv4T/qrERucWH41VNqrHEnPWZ6PF38IbLRJiYUwscqXTwktc2gIcJdI+oWv9IWrQey1Uw6Ye/Q8GHzlaebCWeMkaHKu6WLyBrQAbzXkd9DYIb4gLf8e5YqqOMNfdMvj91Q1e5Amc87YXC7uqxImQ9qM7XZ9YWqgfVFpm/SDoqD6pdJP9UQcvSdV+tLjMujdok50mTweKB9UkVkNKLOYTdnbklti/cWCNtBJHGDzMM91q8JVO4k8ghUQ7jdYkI44Behg1ObFlazEFekqTEbY9xbg38Q9kFP+AYAlYF+Qd7k4cXYX8Y5k/nNEQpURDW/YHbt5yXAGoPfNxP3uYAWQf3y+PKOnE6hPMe91D6fE0+N80hF5UjCMdsTUxgPM7sRy+BY67+JVBTBQj5XCMM3oY1o2+fV5xpTUWsG0jTy/AUxw83SRPzxbHVAs7g3NPMDO7y9gp6XiezpPF+PUXcjT1bfTJIqh5CNzdIiO6LxUHQB5DMY4klVlrjRab1Hga7nGsi8NCJcXRjhK7sBtL47xBpL27D1pA3kZhV3QA34wQ/rEKW4rvhjYTCbvOCKCHjZoynVdxxbqwHD0wRDVjQBe0jdbEMa/Zbmhfs30F9vm6tsPWqkVurbcOgndJBjtY0ZebcZzJH9Vx/Z1WIpmzm/1e/LsGiDMK0VOdIzPkEuJ1R9kCpq+2rR5zzDZnOubqfwn6D9MTbKugz6XVXrMFaAfZVoGPm6Tl1kSAx9ByNqcWSoCnn263TYIWvMmNFN5pXbHDOs5YYysmkRT6x7m2ZCj/NYG+BvVkeqdNNZ0b9RAUA7zpfg2aa/TjeqYBvf1qwGKUTWxYD1RCKy28TOTqNNrzkkLwUMKq4TY1yNQXDowUkapGq7AE+AbSJSrBCBGkUIxS6J9VFfuksNrxI8kt9uUOKMFxuN45Jb6cZQ5sxUarpISfst4aWCI1nyAnLVWvEF1Fe4H9jcbvpjyCFmgle8zW6vN+4BMCcXdMIaQvASuwkvgtv6Sr7lQVcSc2fVAkrI6GPD+z0cR6DXMEw+9zDkoRXBpC9vZKMaNONVtlJZXW+BLEsbc+ZTuiq4N7NMrDvOTB/sKEHkyCq/tBZPDUCrB1bD+oiWU8LJbwMM96wM9NvcxSuRGQKnNEbgIuzr3MxdMlEZuBfz28+wlSo3w1Bjmk1VE4xlCC48wexu2VEgpmA9x+AOk/LNbCspXWfoB1hK+v8gBwG888iCTP0dXQl7L2h77Kv1jQAJzrLcFxQn4p2g20GYJSjtI+xjBfvf9lL5M2C/O1WXhJb+wifLk+ZXEWMBp9a22jNYLM/623Rpagr2WZgyzi2sjm1jayc3Z6mO1eGYmJwB44QSPKxVUy6Ot6mB3cSNpZD1Pu9fuZsAsRwLWN0IOrJSXWwxvOj/ZubQ9T5BVDHZDnJ+xTe5gfvBxfMqHufvB+DvCLQP/Yw/zDS/rRUE8Nzj+fRWgIHXo7RqrtzaJOX7ykurO1SAxlp+E6E+hhy2wSwGAD+ECV7wSvFUX9qrB3e4HEEqNZpHKmqZF9Fp7SfG0R6uut+tuiD3mOJq3Z38gwbd4oqCPeC7Uvgb5QSS5Z41VVg2vmcaxus30Oi+vMPIzOSSXJaAnYAD08TXH6xxFUd/JWgHb7YsPZK9Bbje/x1H0u4PMI39iBh1E6t5LRfS1AHoWQQcKl2AszVFqDpEm2ANKr+xr6GTjulgQx6uu+eSuwicYz8L6S0LAangcZE6sz6BPMEvTPwHWnA33TnRWnwQ93M5+ineXhe70T9Zk/lpeiamdWoK/LUPIqoEdG4OI7tNbIF5U9obiMPUZOwXuouLaXt1fdeaAYx8FOs3GpD0OMEUxiDJxnH600gSdMuM75wwkdMw+gZYoFb4zWKBY8MqXIue6TccBynwP3IXsBcgXlcSnbHQH0M9f9z83ga9GbYGS94PpQeul1auiEjhqEOmv39TLrZ0HxNTLwhqeIN1xrv9l91xueAe7IfN5QDt6wgNT13gGwIlCPgTyVwJMcnvIcJnoVwDsM98+TN1sO+Oe037v+mm0uWPkb049BTwbpT2jGMQTkF44RQA3T0W6vspVM9/uZ7Cwht55Bi6s15tg+xF4SeSvGkQJ8M73GNtD4x3XsK7Zev2KdaaRuoAbNu8EwBz3VN1DXfu5uswl7bOZyZskhTG3q7q0DoQ6/Fi5n3jqE8iVyoCS93kLOE7SXmjDNxS61BRoxvcP2KKHhkUuoq/u7wTJrumzc+CX0AWvybYYe34lz7aoatMHPm4nUpDxnDq6RViPE/h7IfRYhjra9CP2l1nIsEXke351mcTzLaPuj5hSpVQ3+cB/QcaZn9efkEihRcsUqu9tjBmumB595Omu1rQT9v3SdfQToxLcfH/Pp008NGJNi23YRWfzGyNkei62kxA5+sMO2gPAh+Dz23vy9fn1J+40d4BUhx9lqC97dvDFkfwRZI4bjwOi/yrdtmwDwiPVZ3nn5IPKE6w9zEevTF5AH03w8yOnhwZbuMLRzNR4moPtSL+829vxS0lfnuDic8GQMizmUoOujbfPLw6pMtkBovVtuLnW+1G7TGq9CTIKc6LCdKeHshd62pmdVA3WnsEjc3GHTlvi5qAcuqmv8T9qSN2/g7xUL1sdnsYYwaON6N0qKnyfLmYUH9bakHqjLmbyDHD/n94L77A2/5R3VjHZ3i/sF65Qe+hIhDX1QpVUM1m+tey3YeXFVOZlhCCjH2YVTYJtet1WRSBhtlYd5jeRCe1ZKRkQkJWd8eXbe4FeghRBUoH2ouOH3A5EXIObpGclBPYbYR4Bj+zhics6X1mjta0SrTbu39mhFN1PcM9MivID2bxmuDy7BfGluf2QQ3RzloyIKqEgk+EX5qOj7p1RUWEIrEkv7VOy38FIymqD3R0bwoEe44JJvlAd8rxhHejbZc7pfsG7p4Rj6WPDEov7NmHO1zVSCWCnB+4FVl77NraWE9CrAfaAX03C1Ibf+p98NHMFJyWUsnA3/F/O2F0uHe3EsCVceiG5g9IY6002+yZzQITyI8TCX0klSXAf4N85bP+rV7ryDiVV1zESPP3bc0sNlbj2T3898j73VcvKGg0m8zfe+3IlV2B/yMN86EPpD1nNk7KrHZnX+5wCl+O66APxNwKXaXqtSJzC/HQjQNYMvUFPdzHYPRyuuF7pwHSUQ+4cUZWrwz3DenavhzszaZN/+qX++5ovc/Ml351e8zB3veRxdtAqN560S40jbagOOSo+0DTJAbF/iX6WX0jwSUjfZje4zNsqQC7r3JRmbFIHvCCBr0AaB510FdZ+3isl86N00PqQJyHwp8gBPffoSnrl5l4yT/hVUDzf719YlQV1fk/KjSJ2qXnXy/qROisxvlQHMUbZBverkQ5qYePzTFv/IX2LzKNu8XrAjesHm/wnufwYbcQiANJHRbHndZiK9qFG2rwHaLdddaIJeJXtD89fwv9AQU447fOPLFm5uSbwOZ53jvaB7NTjuZiARlkFaZh/lgv5eTbItqYZbza+FtIdd0DMsX2CrKq/1reovsytc3BwRlnkOV/XXcHmnebnV/pjnUa/BVmIYDHjPA3oG26TlFrB6qG/JJTiPlWvT4NoUElXhPHc1xHp6W0vJSiu/xELSBGQtf8bJu1LGn5U5a8WsL2bxZ6O83aXFhrSQOasy+wWn/6uEMnuQF+gpt/tW6pXZ/y/W3jwuqvJ7HL93ZhguA8rmWxFRZxhkEdFRXHAH1OvMoGHZYmYJroD1zmwzrMTcKUoFBVHf7oq4zbglmUulaSXFlJaZpGk6Gs40qHjvrPd7znPvIPq29+/zx29erzP3PMt5nuc8y3nOs592ielD3OsDviQ+kY8al6MZ/9uXaF9aWGBPktbcpgOWYMd5mvTCKnIOAc8nBBXi+YPp9h0F04HDm/aigpvQ4+RBbyieYZAV4PmFAii9h88myMFeAWEEFEr3x5Dzw8v493t+ZXqwr/Lzecv4IbpUstd1iI5q8k3Gcyk444+u5nll/FBdlhlb7VCdoslLXBV3br+Os2J6GNE/raxmqYSDt2mQQAc8TM0IXvHunsz7FiXInEAPzv+hJLnYLHN6w1h1VJAoXZRkzlu0T5ODrjVJtA8kUqdVo44h+imLa/Fm7oq7jC/s2Xc3pisf0mUjcyVT5p3jz+47x9fNOsefm5TImrmz7lr+gqlfedoqvIfgU+6aB7lJrkHqyBpxvIlydRro9uMtiAluKvEZSxl/CHTZrLpzfEj/uGp5ozoQ7yxpy8q/ZlKPZPYid5boclJgBPiXL25nSrVuR1ReJq8IHpe3LGd5ZkXemFx5Y4j8nkWuTdk7tDS9NPSH7mzGytCvQ38I/XpgXmpOJpvEplRd4zZ519sukVFKiS3lkZk1RVPr3EQ2pbrE1h3yoUfhNe5Dr8hFEXDxqS7SnA7pdbtxrUVLOMIVl9alwGG4oukS2TnaswYkX6W4Erne9mUllBbaVyvukBmRYtD1oUSR7+vOxBr8znXjHBHm6es9x9bgas1AskqjSJZbFE2XCTWmV1yZ+EbaK/X0vEZoW+LKHNPc35w9TidQCVRSumPMPEwfzjRlzaPiMcWKprBJKyAF+yH0OZrKmsu2Nc2vA+OKcvrd5fNwpW4g25nF+KaTEU9rqB035YSD+/fkeSyOeA9yI3wVNwMp+c758J/IlkBrLgEftbwC3Pr56qV1lFpbX7JaKeL9yJ6QJBZNKdCfpRV6OadQD61kna076Acp0NISivH8xXb4roOWUw9lgLgJdFrQrKRR0ZJ5ME5T+eet8R6m9MY7HzRCq73X7CcNcievOXdCSv3506qUOk8n0PGT/6BJizPcoEnbeu5GBLSYf7tgPPH6T0Q3UYrrf00Nk/27M37yrwnemfC62FLEHRpoF0V2Q5i50S5FU9Ak0GyJjx/9FE2Nk3D/okgV9cD+foUMz72I9u2b7TtBaNEQWrxLfMHRP7vRHnx1ap7dwBdwa22dC/HEIJrjgEoNVMEulBQiF52IC0qMdeCz1hYnaXSYJp+kZXTBWR8w109GeyyZ+MJOeWbO6qS00BpKu5f2WGXGu5aghPCdNnF0310q3S6SuYdUwvGSvphW6Lt+GerFxhtUwqEbOA5ITU0d+uaOL4fieKDt5zFD/e1EuL93z0TIY//M9dym7XsS2XpeZ2r1Hy83wIXvTIBEWeXlLvgm2sKatR7sAeZyy/eIvdJTHqyzCWRtyD9Sm7/nhJ2BUX4IWb3GXhN7yRIw4y4c1EHrpXJugtpD6sf51cQ28CHbp8kq04QbdPz4G/5VjZPHO9t6QX8QiGOJwqk3xJ1GVdCXB/AQY3U939uUSGYgIN1ObCN9oX1cMnm5N31L7DjmDiEpwF6ltjmFRSpMUYmtlapl/HObtu15OF0npJEjHY9aHMSH8p/MRRTN+96gZj0wEgDdnOQvtnYcoxmgd2KLZft9NVi7oY7kKu68jLW9AHfUJJE6YZ98Q9qP9IV4Bu21lu7o9gWZv3i/53zz3Bqs/VCPcvGUV759O44nyZ44K/Se6C+2RpRBlOPFeVHQvo7xneD/CB8H/4d5lKWTPZdtW1rMV+rmoe04TwqZ/TJzWzEvC0+DfpHIroMcqoU6iCZxh1R3gqOkNnPL+HpweyB1ureQOj0kqRNHpM6n3GpnmQ21BT3Um9uuRqIR6FWljmpfCtnZZubyeazJ623vF162vV8AsVaKexREjRNihpFKj4L0u5eL1tm6QA2LK4y3f12ZAKPtKsiHRHY6lMp2e3zxLfsiCC2TT2KjqqAGVJbY+gFlWvGn3HNOjMFfklHnse/sDrFGteChfQseoiUeoiQe+jmjqrycxQ2hjAfJUCC+h43SIg7wLsXx9qmV0+ynIT2BkB5FU9vpCTDevW7fXrwN0mXieCGJ7UTSBOGD9MY0tXIq7g+KiNrZqSpuR1t2LK/47kueOjGGfBUnniRf5kRIr/JMh0W8G4tz9l1zkmd69oP/kJ5p8B/Wsz/8t+mJclXdsycbAans7Y0AO14XCf8e3XpbV7K7BGvySdtlUvNF/Eqhv985afujcA33ufvkrUH0sOa7Ts6QuhkC7SSBzKRgS8Zagbvr0A7aTWHodbCB1pDC43jsnT3YV3i5eGKateeNG3GQnmge59XiS903MA8jiSm69HkrdbxwZwSDcxVH+y3qQ+YubsZkiPuKN1tSqs7x1GtU/EHua1fKjkS2R3nKqu6rBG63C3Itpgc7mW3VyLcewMq/nTUC90O3a7EfOpfkVs7/R25BHuVADuW8YsU9ozjOEuXHxz5scahDzQEdCtvUMDPWWBwJ+c9TfP8ZmjCcIbqwo+LeJDzF82bPFaK+WYzt8EiRhwslo8D+ujLbTpWHWy2g1DhURGlB54gN7JruKC1Cn8uKyvgbvc7xuz44x5tmidrmKCW67CnKY00giykt7j+TldaSvU1ersBFdj9VernZLr/ke92Fo+xvQLvw1/T0u8XQZihShnkgFbGXogvF0qNx7ySUf0Ih7l71ck+7xFlwE7fRt47smIW+vGod2ZuolOSAjGisohxgCk3cR6B9KAvqpbUnlFggNckpbdREbhCdhi4UT0RS5CSOCVr1Afu0ggfnKU9Ja68Y0+N9fE2k4J+9JkuaWgJoar9PwvlKcUcOjrBxdIL7XtoLmVf8p2B83ABnprXMtgty/hKZMRi2F08IpVvzQGZ/79tnPQW52S+nzhqQ/LsF6tW/EkEevuZOYnG9JZ0PIfWnFak/rUn9CW1RfxRN4ZMoLbY0bGcReSd5SnOSj+q5hmvnwpaEO6oUZEeVOB5RkPXgL6T6MZaMQvrrlvFpOq0Z9aO+OjyBp9ijYw9yo5y4J6nf7p/M52xPwKjTqzpkl0YPdxTD3rZvL+yQVws9Yq+qJLZfqYebxqtZ3PdYYlMCr209uLvpu/1lNqcR/Zvsw1Ud8vqVJoFkqpjp4bJBQpbYFCpFU+VMdPNwLF9iC1CtuimneoGWKafaQwu6z/3kxvyQu7kW5yuD69eBDok7qFFnrJXwWsCxH/watPUi0gfdKVLcbxPZOS+x6iB3nQfdBtpwYmlSaddygfuOTwHbi2ALYYH8DBiPfWSP0tpbKakp1cmsbsdPUBdwPhl3e0yFGhqSet2+CPjfVjjWRhdgvbp6my5cnvmXpdfelB1pkMoPXeWgHS8CkFXV822K6vmwZfe59W6sFzLy/khIUS3PLPNyOp8D7CBGFb0D0/ynG3pU6fRqDO6Tat6ReYbM4aKO8EDjx7VWXHMNxNWoooPc23wai2uN5FwJHwc2/+Yxh/zag5hLvZp113W2IDCnNutCeNdira03tL+urpWQeix35EILdX1j3/2u+XdfCILSzI0H84Zph1yL7r8F5oFqquuwugX8QDx7ASO52YAPyOluxrO5uA8R2wX40r2AZ9xoRZNsUlBeeM4Ccb/cZCU5vzFAtxPP/OUq7kfJ0FVxX0HjqVPR5yAdrrkpKnHsO0oeAF9/C8vzZvhr9icoo1tZqeQjdYr7cZHrxFKDnvyTgrfJ+EncZbjrPJ7q9u8ZwfGvf1+V8pyJnM4Td5JU1J+2Ly7A81aYYqjx5K4Fh/0GKXHUd7ZBzae1eFq4yPq4uUqcRStzuF24ojJ3L+QGi7lR2mIv/3pb3kPnYOY2zdiL59J/sj1YCwo4d695RnHCXozj4fC/c2FoRTBWwnlGFVmXxLUgXI/0cBWe0KpfeWrZBagftXyiqZbvBrYlnvZVtfygZbV8OvQKizy4Uoc7kDuRdbp60LTRhCMRD/e29Dq7qsXIA0ciwcQcWoXjEC/HOLUorys93EQPrpmdxtkTkNdh4FtLTDgC8XBjwFVLxhKrYMR8n+SqqJungEaSCL6SwNdg8JUIvnBWJghclxZivU4hep+H6+5BfQ9TiLW1F9H4xPSmgmtncO1FzLjqiPpTKu6nJnqOhwsD135kdFRvSyvAWbZ6SD+elsEZufliu8NTooUoVwfoNuH4pbfuoHjGFU/84plFfJfkJzPVReDGeaE/HbOA//OpBfy7T2HvaHCHZlGl+azifhVFl8pKD0GOLOAzwE/mGHzXkIJWQUmtgrozHE/7RsYCLnCxHjvZI3Rirr8Pp+5HtV1mSy/82X9mt0sRmPrkLOPTdQcgDSjb+sxD2Z2uo5rCJ3fIO8FTPcl+0CM4qsOT8mW2J1QoWfbz52xNhTgHcUC6i4DslwZ9iy0cW1Nma2xxswCOa2DEUCjORqU7GooUdzzTfyFzkaOLy2yjiqfbq4oTQR7RVfe5VCcNOU0X41yAl+vF/9Ji92Wr86ftRQXYFsVTIf5xGE36+bYgHRVFsvUHuGgf7k0bV9SuPGqlj/vKg+vY++BfXMfd7cE9g6BLFCdWHeAUvsQdMVV4t4144gRrSjsJTyKasHj6pCv0JV8Ll20VzXMd6Y3eIuiVKoNWMisDVyp3yCG0a956kIryNV9Le2uwD1UQbRXnafF8IO6+6QAST9ePSmb954RV/WC8ucSR6VZJespoVwwMAYNXgmZaeY2L4tfb5kSfsw2F/B+iiqlyc1leVXXMjrCqq9xLnsSqa1wgf9n2usps10fjDQCJ4GOAN6w6cUdb8DHa0xZ8HuIy3ets4dDGO/LYny6AkOptEdBbhIHdK/wCCD0GNFN+5jnQHEH6PXmAe8sbsyOxKqa846pOkI+cJ5FoDUlEa+hKtIbkFlpDGT+pJw3luxI0vj66VDPWjg41/pXnSs7pRd2hd7PusAzcqeS5977fswx6hqyaOtsTBZdtmbi2Je5rbfpiT8vzxQ/voPxjMq53TkOpXHDavq34nC27AGvDdsjnk7YMGE2PhBxd7Xr01PISxycuPIvsn+Npd+4c+P7vs8jBzWeR5za9t8dvO5d7ew+eR379Bq7CJZI5JRzx2aQ5br1qhWOnUG+LKUR9BWsRSAcVapb1to4gZxOJXYktSIVa5p835Mn0cWUW5g/mYR/dDGizwo3fujffiUEVHffrWAp2salGf9n2WfFlPmbzeltN5RruHUE99VP9Gu5NIWfqIfi+JmyYehC+rwhXph6Ab76gnrYfvlOFnGn74JsrbJhmhu+LwpVpJvg+L9Aa9XQ16+a2ebBdL3WJZ1I3gdtkYYeYsi6b/y0rLeHDxuBOM1z1LuN751Dd0x1L5rWJpTWyqiruB29gp7CL5VyCT55Hla41rjUMZGXqddxUJ8tmsztZE1vDvshetWIcz7l6shjjK55K7m/PuL+C5HjLDuVYUmRqYKjchiC6wvGOsN5WUhxoX6ZCaavNw5x9IV/N4u04bWahNiPqAQeg11fmle7HV5JBdqpBygIMBMgAyAQYDjBCjRqtf2ci7qHwr17hKAfn7RaAzEOtTtwnOpvycN2c6ZDWJCdItOJKbo0H6y62X+yTS6Fur9HNkfbVi/QYTl8SjoHFEA5xxaDpDlNDGk1l/MyeF2uOkBV+T9ERM3KvEqJqMDe28GnkfoxhOtzLnu0YmhmdMxXPST4VdAXnWoqsONuN7kjfaEHaMB9SunnQnjQRZhxXin4GSLcY9K8Du3AqqU+df8/8Kcjr/h5F07OzvrxF0dhDbXy1A+j1OanYQyE2JRXXCxHLS4XWD2PIl1NRT0KbmamoKSH2RipqWYjNTqWSsizh7Bh2DXfWu2G6/gqlgZwPo5JPWqiuX1qw36CSj1lEqf+ZRZzBOWR5sENULAcsM7EM/Plm52Ov4JlQbAMwhh7oPxOKZ0HxvpiW50HxrCW2kRuWSHLeHsfbU/LaMJiq77yYM6n7y/i3e3bY78+J2R689fgQd4THUsFdL+Y9ZTC6HWvGkcVAMjbWSvNNQ+9t3pP76pVXnzQrGh2yNdwmbyWZ500HKZ5RfNGK464Ve8CNXsMZvTnTP7zBGBWNo2ilusDB+PD2/81TAps1SpR16r1R1sRdEQydFZUncBHH8J6wmQdXmJSsj9vkCoJ+ar0raFdQlQdqXOjZV9jQU6FnQ09p85JzerEzWGZ3DCs/uyszLOfJHC0ra2Rk9y3qvLAcHRthmindLYtnwT4x/W68bLtcTGledqxy1mddm1Sfpc2hutDxmKaTtyL6nLzVFr5RANEAMX2S2C6TF/C9Qa/oA9AXtOR+AGk5oj4yAGAgwCDUswGGAAwFSM/x6yJQPwGGA4wAYHMSY0/e6vSMorGI2srd9KUlJLFhsSBZwPSHbwALo7XGw4D/JuEOwM/7ktj0WEVT2cyt3A+AqwE/APg3gC8D/CTgX0Ge6oKT2Ox7G2ZBuwebz3zjMYSmZwE/IOGTAN/jS2U17EbjxmxF079nvuz4wYXm9UZF0ywwnSGmtWB6C0xfEFMlmArB9BkxlYPpfTDtJ6aVYJqX87JjFzGtANN8MG0lpmVgWgim/xBTCZgWg6mcmD4E01IwLSOmJWD6EExLiWkRmErA9IErGUzzwfQJmOYQt3lgWg6mN4jpfTCVgukVYnoXTCvBNI3QvQOmcjBNdA0AE95/cI8LF/E7w8fc44Il+8NgH+DC/etUgl+KK5rOFOyzK4qhHJ+FcnzWAS3k21uypd/eUgAol+KoqAjGjCNzFueczgnMHZm7OPd07lLHTmnvu171Tz4qXUns57EL+A0Q7sZnFU2XcrZy1714JiqKbVW6l/vdi+sjUWwI4Be8OHscxQYD/iPubwJcBfhZ3Bs2CVcg2uUomtwgvc89B7JrqaLJMwm/UWwQ+Krx4jglimUA3+9FuRbFBgK+24trllGsEvDtXrLHkg0AfCPYK8FeAfgaL54MiGLlgK/04n0RUawM8E+8uMcT/DSF5NNgXuzF12sWgO0FYtt6OlXaxF12p7FXuSy34v6gKNBxnvoUV6H5xKTkK3134X4lfeaYoggG7wK87QpjBsC3Hr7b3GFME8ArgMcCtAWYANALIADgCYCl4P6EJ4zJgW8FmLcC/M2HMSf5bkmgcz0PGhdAFEAMgBogDkAH0Pt56E2eh/b6fDp5nwzbwwJbajHuttvKxXlbrZmppzRQvnQU9CJHvCEVbu6wNxj+D3pV8L/Py8D/Xm8g/O/yKuF/hzcA/rd5FfC/2SuH/w1eGfyv89LwXwk54+bKvRRogRfGJbEv5sTEKu7/Ca3Z7klnF0PNWGxTADAwVkp1BQHFPO+T+kruM+8WfpMyG7CDgG1RPgGYCbBtylGA7QSsSpkF2DbAqpUGwDYCtkupB2wtYHuULGDlgJmUIwBbAdg+5TDASgA7rMwEbAlgnynTAZsP2OfKoYC9D9gx5WDA3gHshHIQYG8A9qVyAGCvAnZA2R+wAsAOKfsBNhWwk8q+gOUA9rWyN2AvAHZGmQrYs4B9q+wJ2JOAnVXqABsF2PfK7oCNBKxOmQJYJmA/KpMBGwzYOWVXwNIA+1mZCFgqYBeUCYB1B+x3ZRfAkrw92S38JaWadXG/Cmo21H+G8RPq+IZFNKWDuhEH0BaAgrqSCdAGgAHoCaAG2AdufwKcATgCcB6gDGAP1KfPAQYB/i18Z8B3FAAHOAPfTKhrswHeBPNCgMEAc+XhTAkAnZh2UHkpwZhgkKnXcm956LjUK6PzuhgS2a3cOx5HjXZ0cl6wWWu0W7Pvtc3Zxk3gxRvXzZ5uOSE1nYyoAbq54R4Fe9icmBdmlufhTep4xi3KeM4aRcJ5BlzH1ISPTsxjatoYv7GKfrqRWzbDiQ+k19cwWR3yqGRbXSujgqSmh8dmDTaarTm7xDs9J88OJ/dwdnGGM9fbhDN1cyOYW1w4M8YVyXjhu/2HSKbpZXJXY0aFKRR6lco34w3LWLxTZ55bsXI1t0GovaWkFTvSQJsY74RKV1POHeI7GWR5+EZdkyuK3HYftZPSDOOf7kiXts9awMuKcmdSpa7Y9DuXxtKaf+nXcifcRezk2ZtrMMS3BUU1htmTxTALnWpzawOG9YPrAuRYIenFblpx/yJ9kTE0WnXga6IzJ+8bGBcUA19HAAyyQOY8fK8COHeJb7vsbmLee5gDNeFgaAsOnLwS8rWce6aZgzJXK6BDHuTAA6ZfvvxxHExswUHbhzhoDxy0Ihz8u5mDsf/FgY9HDv5X+pc8kv9fuDCuK74Hqa/kMf9XcfcFf+r7uBiS/wzJ/zb/mP9Ui9R/6muZ+s94f/6HNqf+nvfR1K/n/3f+04kzD+IbW7EWypHPU45AQcHm1ezmTvko0AW76DeDlrKbO+YbpdvMXfGq2ZlHd0M6qMYFdGdw2wVuJt8CcPvRC9pZb7s1oT7akJe3lbO4wo5QjnRe1l3BtqvbnfcvUve/dulq6NhIcjvYJp+C/dkqtonPXIlgH0rs7/vuWOnYVgQfI9y2hhhDDBS0kP+4XnX8S3EUeAndHcHEAfQHaH8wgmlzIII5PSCcYeDr2R/BsGA/IiWcwbvnmINBxsg8fHlGZQnUM4ZhM+fPHJYzP5fWRuYEGD9x/OCU6Zmj1PEp0NbysL1RgczwqZTar49Smt1NHd4LYPP06235xWu4BJ7SfMBOhxFmLGDz2KmAdeTbVhexT7IT9ejettpAsFjAMtgXiTuthfLJqeUTN+C7L7V82rIS0MNreX1RCT9Gt5Xr5qPiFWw/Vq7Jvueaparazi30reN76n4NnM8OOd+2+kkWew+nQCXgOCrr4irOQsaqI40jDS+wKD9CXXTfQ02Fc+stY9hK7pKgh/9fhXT4/1nYOZtKfqJuADvYIKvaxOl9g+C7mZvnVrIVRwYY+xH587ezDYzstkIZ4ytPrYBnv8xex2foLgYqzyNfSZCKQwKdcMS6jn9S91vgp+eRxzjs9wRZgskaVbWa+8A3ny13cAKOf4fz8aY0nGewXuaXLUvorLi/dvZzvKKHgdWxm7nT3sMjOAti49xi7Bu9l23tyMxElD1MVe542d2G3A4tU7cyrOXWOS/bIsgMFk3uDZwx8+xxHBNQ2hk5eXlbrFj2OO7C+oB1AcdVWA/eM0cwx2LDmXKzuK65yyze4a8aFkneuLD58O4MgQs4Lt49mTyq0hTIUl2ytLJq5Q41K1tZCdq+fOcwvgslW7Mzs1UdHTtgplxNlcYaYw3J7FpujBNzLZq0aLqPPOUPS0f9ZT6vaCuX7CmPp+LoITF1MjVoMZ7V3DlP9E55wwJ57S2GVlaP5SfEKMuwnH700b3L3E135Q3D5H9GX7eMuoM1I9hzxarSb+UCPbR24Ex5BeS/TwH/+30B8G/y6divrGrg9dt9Yp3H/hV5mi/xVA48tT6QejBg19O84oXd3K8ebLuh0Ha/99BluzmLh64EPQtacCvvbu5b4qpSb+Y2enZzX3nQ/robeZMBb7p0uWnmSOr4z/vFd6lXmtrsobQsP2ZwANsrtifbAepBP18gO66G1ibPXMXN9UaBtMM132PCv8ir09Say7x+GZ1KlXaOy3ZomMONNMPU9WL7s1hfn/RRa9DtrhXvqt7KlbjpQQ0Was3O3EDIgUVuDDUN/PXxqUFyUMfTgO8jUJZ+noMkns2P8DyRcNUaeH6a8PxcM8+lwOWYZp4TwGQgPM9wU+oHHF8V+R3Z2bDEhHt+LUJAI6MMaIxi+rFQm4MrudteBZtmlrGoAwjcSIHI9sUjR/xtucyP29CqMYwxs4I2k81nsXUe9I7jFQMNQLk5M6Aulg0mVN2Ea1a6t6LbX5ZnSZhfeo9lOi0BxK1COA/8RgKvCQDDAF4GcIjpyig26Q2tGhMZ3B86X6C0el49eLg+A2J6ySv2O595Mki/I3BOn4rUUhk7hEjYGQJqjwe8AZ0UIFW2efqDv7+sXdk0g2ovur8g0Fq88yyJHcD2AJ+fetXmVdwKT0/w97NVWSlbU5mpqOtBwvrOV2dt1RhIJ0LMu8FfV2J7wncKpEWgLticYLhvlWlB+yolb18LmWxPNhrCfMbLmGMNN5tpPwFzZ8MVkaqmk+E3K460w8DnbBL7WE80xF4uxU7XtTMctyJdrlcH//FeGWhtkYbFVrGfcfkWQt59v1fsG7C+WAH3AkSYIphYgD4AzwJMA3gXoDQynFkC3wqA3QAnAP4A8JjEeh/ArjOlGfpnU3HIc8CebjM1LNbL9l6Wj6Po3vJu9y0xO6m4YXzOaLpUl/WgR+8OvUE7YUOm8mI3Uq69fB1Ju7jMVxRR8VRC8my5Q5DNMGPbdnmU8M95AuH/nkdD/Jf5blhjiPTAF45Adqwt4UPV2HaaPOv4UB2VXF9nYJlqlCdXPaJO8Jez/paK/iSTOb4oM/inZ/8KlDN1KFN7sQPZViTUv71HoObJtWXuu5L0wTnNw9ZBkEcoWzrKA5mCvaK+UAjfrXvxTckhhmIT1jijT6bBsUilR9kp4OIAQy/yotIpb68rYbGURla1hWN9iCkBy/AJ2gJWtgPHGr08dLUa+mHZjm5gSvakGHJykTLWR1XKutJ1XQ0XrfQ6eYqsriubaDhnPQvSWJOv0ctKK7lBnkRzHCnd5V6VaebR7HsVr8uqc/OjiWuKhzF3NPxt7SiWv1dZ3ZONhDie92Dt6e1GqbQLas9ZiKWtYbs1iQ0B1wEeZTXNBgE2gvhTu8PAXwX429dUMfcvS2uD+G7219Y6qe0pQeZGAWgBegIMBcgGmAiQD1AEsBrAtE+sN+8adpIcM3vnQCwud0CnQGhzt12zpbaZ7O1wpeteCtrbhsHBsf3Z18DXJ6D/qaEF/+qaCb4amtuI142tI7VmBklVa28yqUdtq5PYKUD1pxs5OO6aCjQWa1uplU4ifnnPg5Z2EUPJaW1+EdrYi4bL/NPL0UeuV7ZqAJsBMpnuWwlyN6j7fZBjacvxtSeR7hiJPbKmFzvGsNGKsWId3OFuW7kvU1aXyo4yfGOl+wZ1v2HxU2wlMbU1B8eyhiVWFuK6uUzkuWVcY9ytIa7UJ3CGx0+5xC3KASN7hsSEbfwNiCmoUS6vzPzGEtRIB9U0Boc+iOtVEhfV/YwlBeIpIvFwHr9rjhieuRdb05zyURBeK6gNrbQbId3B3W9a0u/sTcV0hZEapXD7qTMkzvHV5SJCz0B+d3OLefyBBVvedVcYyemjnlTrkD0RTLcDorxB2fPUngcyB+XNNDAXA1QDXAXwAbQBv8l7Rdney7CW1JlyD47Ur7iUnYKgzvzo7C7VmXBPDJHnIG+6DOOnvEiXJoG86TIT5Y0yltbEg8T53VOVqbjYhaTJ6b5hpbWdshWrSvgonXb2wCOocdIaBeicWU58W1Ru0c6+VhNtsFoZiGmds71BnpdJ2vRv7jMgk9uD3nf1PFPdk8i8vS6mshrKPJkNM9y20n3OWzfnr8uU123KbwWa0TXoSUJIvP081VYO2kGalBfhikCmw35RpnT6LpJJBnwowIsAW/ajfMk2fEQ4j/ag9GjVIKO2cBqCMyBJYjyClq5W7MC5lFYu1rAhB2NReGTVtFaxIwNsZS668kpOV3M6if89dwjICdk6msiTQYZ71ulaRfXGvL56BZRvG5fanEb85bv/svYl2O/u77R/5HUHd0V1JSd30dCr9AQecf4jzsVUK1maJfMeLmxrQc5kKJFvrEzldKhHSYaTIFU6g2so+AwAnzGAtyc+7/Gx4PMA+PwOfKoNe63yHVinB7kYcyfD51Z5pQD2MYbNYI81Tgf20QYT2NNd71pQx8DUfcUz5raGrVakvO5Ef1edYn/3gXsp9HfTd4syCuXTXMBLdovyaaIko9aAeR/AdwBXAdwAcqh7IXvEfrINfBP3iO+XCNxZ94kaDLu3sIF8KW8R+b7hzhG/nnTy/cirrvHvxdtwDO9x5A8G6YNGq7I3ci6BiguJV7oVd59/PqiGYfmjaexG7m+B7n0P0jvrEJR5TQST1aENuafDbKLipkBN/gDkGV22kftNuMxfWt6FjWezHSHBwW6l+wU+aCbVI9PyImjaJ+dt5L4VxiSkQ4hfC/RQl2WcfiP3hYD/xwQq5R3Ls4DVCPh/SHgG/veTf5PwNPzvFkbBf7XwlD4W5925rYIezJuEf5mz4fsfiDlvuWwXxMscyyyw7OL6CaN0m7jnfYnkzdqe5M7774b/xjO66L/kob0t2Y4xTAZQzhNQv3VaegM+R+jPDobv28Iu0ACQvr/vN16hy2dpdcXIVo1McJ15F6cSBrB9DAvQFfzJBcS6+LL4+CK6z5iEbkD/HOFOA9hTkHN037et/WFUtpHLAv8NPgy3lY/WAoXuhjUO7IcK+D9I0MJ/f/LfV4iF/1QhFP51QiyL9XSB9Wk+QTejppORcQfejR6+Ii/6L1logCXa+OM4PRsOedJBoPvNhXIakBHJLICykssjGBnAj4DfAejxKeikADsAbgBoD0cwnaE8J5yJYNaC+wGArwAywH4ywFKAPQC/AFA1Ytl3bgpndPBVqAXOe0wG/65jdGLKLT57HlvMtq7Pzms3ioqXyp/vz4IWPWZETSTwcdYnuxIB3zM+Oi7sSiK7hVvuqqoZPlzVqKAn5wU1CrqKkUmsgk2sCQJfB31YR/lPAgHfiytdve+D1D9nxTQ0HAG9D+A8wJUjKIN1+tZZUXmts6LzPshsbQz89cdb1Ig2jVTwiEY65Mtb1OfE3IBmKiQqpyqW0o5jc2EEHOKE8cMSRRh1Zdk4Sr1knDinkGmMzBvmKHo9MieDYLSciovMobRd2KWmKfExbFjC33fDixffDV9SwR33TnQVu4rYpdCyjgjFYNemgVGMaAgKiIue2kAH0ENuWiitGkpwSmy5YwFf9NeVt7Y1XHkrlb3XrvaWoveULv7VkhLHXN8W7roHwp4fWBqmnQ9hge4kBLLK5RXch97ANQrI4d/2of2XHaiuh48/lVnagUo+fPyFzF/bVYx4p4EO+fx4BaRkf1Ph3Hb1gSt2wZih/pbi88BKqvyndvsagoMnN4SEjGcns7W3ZFrlGro0lh3LBpG6/JOXHnzUkslmsUrI8fveRDaItBmPjbpCQf50/TyCSf9c1JHWm6iEYZo39LLybdx0r6KT8uIsoLnkVbOdiYbzqn4LNw+kfPqdwJ5qdht32IMj9I8dO3nsu5iLGWwe+D/pRbexnuHsVatyT+j3EbtDT4V+H3pq1c1QaiFA9r22TyqrynD2P1EJNBOw/ePMR9pVq99tKbg1/qas7s9i+EUkfPnFp8DnSu8P1tGQjsGeMWD62LuL6+7FljfGM4BNvxMajnG/7DGCj25gk31vyWtoM9nDYvsH3+2I7/6eQeCjgyfTGJb3ZJ5ip/wr2ZohbMegvZljLX3BpbUnDfxPBP+CB/1rPFSsP/TBnl7gw+umYv2h9/b0AN968H2T+FZ5qC472L2Z/Syd9uIcyUj+5cGX+bIiqkv9LVmvysyQOkyrmIdtPXSfdGgz590HoXTtlohqSoM8KwnPC39DP7vdtTy1LJXtyspWt4WYIr1UXG8rE6uA3N/Ovc1TiWeO942i+61vtnuF2M0bTvc5AnJjIpRvwefiWP1D+H4KcA1gzboIZlmdnPq9ewTzHJiDj4r3NNGa5SaNfhs31aMAjUdtVBvk6jXcWp6OU7PhpPZc5mebADYALAsAzVTBDIrNYDGtZVByYb9RXQK0Jvdd7mhmuGUMSLDPPHrgcbIbW01r4GCfh+p2oQ79D3VTcT9ZAxoWysOqo4dH8fKwp/iB3cYBzQbImd+tPe6GM1mQLmNKOJMH34B74UT+OQwy6Y3YLVymR3wjq/NBZZZsOYyv5AHGgCwlSXUGL772uveY+M7rwmNiWGHkjuPLtn7F6wHu2CmyJqlgFznGuS/bUslZ/QN2Pdm7E3hOp4/WCNwPAqXGmbmwo9r8y7ZuqvUAdKo2d5FjiFsH1H7/snMxoPvdsKKvePCllXwlP+Kro6az/ifiKwZ8dZR8Rbkddqb4YZ+dNG31x4jPUPAZKfmUPxJeZ01r/U7wha60eoeVogZl4l4ggKFFR3Herfcwijrw5W4R/+p38j2QGQZ5kn7s4ffSKrktwn+/lzZFePBeWiVXKvzv99IquQ+Elu+lYb6/euzBe2n4tu4WbrpbwerMlPbELTr1xC15apsseU7LV3YvmMOM4SS+FwR8Zbc1CfkZAV/ZDSZ4toCv7DIENwgLpTdz044GGuWGa1D/b0OcDin+R9/ZFW5/uQJl31KTklXsXW4IY9uwm6FvLuPVYy7UMCkhdYz2IyNVmsx+RNLQXqDVbfodZVEelvGJOm3NYtCUFhsXZ9mti43zDZUcI9isi0Ab3My1EupqwlIUdWFa0KWMyWy99dwtlZZKZo7P6RpUN0dD6qr2LcO7Rgz5ts9inWOcZZCpL1kLCb3NV1cTAfQRQP8W0B8l9G/qKY34Fk9QHb7kh2FMNcwkYXzr22t91XjJ+iqhr/Wpj9BATwP9DKBfh/QjqNj8LOy3Vjo6CGM342sQGgeVscoxwT3OPDnrKQMVi70IhDoih4S5wbfQOtG4zzqRhLnZRyX2t8hSbrJBdTLtCyRnRpCc+ch3ip0JOnEetIbQRDkrrwuNpVaMNf4NWhLaxrkTzU8aBxC/b/luEp9JbsY82njPemROsHmU0WEdNSoNtMDN3ExflJkqG8gajHVWgzEF8uRPq57EP9lXxFKJQywBKbcgBQHaYSQFXUioWb5atgcJ1+syNRXNlbOKuux7RbOoFQONNmsZr9F1MONZkTTjDesJk2KXhqTrgivR3MfYhoTQ1VdP6OtB7+8J6UJqDdtDX+L43cOYuxsbrN2NKsNfVipl6D33Hi3bzagkdK19d29Qx8P/Spm3uvy1wVOOQ7s6Lta37jsimK6A966OYJ6B7/cABQClAMcB+p+IYH6CbyFFFXng2xXM2wCGnMC2qUgvgG85wO9fgM4G34sAoYD3ApgO8AnAfwB+APj7S9D/4BsG38EABQAfAnT6KoI5Bt8rAE0AuoNU7HpTOCuvynMUuNLN/YxphIudXpTwnU26o3RsbwO6rnONM6cadcR1rRdtFrgUnVIv9TBet84Bbas78bUNcqsb5E03KClKK9JRiU2W9bbOwUnEx4/gI9F40ZpoTCTmOy6cJ4w3Wqzx0HriDZDPr6N9BNSHOOPXVsQHusTvM64AlqnpbNxlpaAex8J4rmMWA/ZtnLhC3MG4wYqm/k4q0XUpkd3JbXCvhTa/9y5VRJGfIr3TSbEssFwGAG49KZbDhJNivveX8vy9k2J+Yl5vPCnmG+bpKcBlpyIYS9tAptMpHB/jrkrtqMs2LfQe2kr4Vi4yZd4JfyvQvsx42G4tTrQnFqeRO6mTVMscp9xH7SdUYfawAR33gY/xvN1K9gk/uOlb3FHatr6dfZlqpWOvD9/qxFUY2cqVjipfCFmHkauDQbr86qHVSrIzbOZRuveBzFMWSo1vRzouCEK7Ty1p7T59Mo1Kj2EHnBJ5xv48hC0xZeV9YPyASMjDHhWM43PyNnNz3GFayEPQOALV0x1RUGbJvxUatexsUt5bPOv4LrqA0nV8nE4B/1qdHP5jdTL41+ho+FfrZkLre8WgZUn797yS1SGvjZpyK3QrOYNnBpjo2OhncAXjiythWqaa0VAQz59QUrLftOwU47fWCi6Yz0kvcdzhKzglj+urE594PpvqsvAvRVCQI5AJi9WwTKOMYao2c3+4yUu/O+lYA8RXwmvGTHdUONNHkBnVCi37lNEIcqKS03s2WQPUB90OB9VQRB1soJjWlkSQdle9MjYYvps8Wlacg+3P4oyRzlPi2MPTfYr2beYihF4pJyzl3AmB6oLzsDvZahbSwmDqMyDW6Y6FTjqRuYAp0bJ9jd1JjKGefCvmxubMGAvjCJTLUudnqhpplaquhxF91t6idVpWS/w63WOtmH87MzHd9DAxpHiQksGNdDDdp1fK1xB/kYAjj3rID130qDtjeuEZ8+kNNL3KsZ68Y3y4QUnlNwTS6EZpVznKXMiTjP6XMQjKGLjbWcmddAe1KI95bkrdyiTuA3lHqhvl8HV/HcGUwfioAuAQmGkw/wzfcPgOAigEqPla0gsTPzQFs7p6rD/joP684FKwbdQ5w3ZyPqd+tCE7MYfW4Julvzi1bFoOa8SZxm7LATYCmLHuFbqp+G2gE4pjozYqdkRiXj/LTu5rZ1qejNVGlWYOslBxQ64o4n60tmqMYlIhkDBNOrsBdK/kvNpb8qo2aqTNZCm3Ukdravk2RaVcDyGDTcxbyR3xyHcC7/tdoJlTk2kNzhB1cqePUFyKN2pJnR7gpvses6rcjFM/fCX3nisxD7/TXUwjzRy2RvB0FtXt87qd3PvObkdoKG21M0yrrNaQkl/Cj6mhe/fq1mSJNEZcQUxpEd/cw1od7KTiHvidBfq3rU4l9Q6CC9vATas/n4ecFvO/oyuSvPf0JphfBPi8KoLJhu/uDoEgY6gui0x0nBK0fg0rq5KtLOHD0rdy/YSqzE71saw4J7qVuyTgnGiHZFld6AV5crhFfGeqkjvl0oF2vQH+t3IlXgpkxsyjk5P/rnst+baVVnPWc6cfyIetJsXewEY1bQadf78zALQxk9FEQtnkouOnXRkeu8cQ2DiIKuVmeY/mAib/LL9aP5aPTddAyZz1KRoXy7VQ76Fkgo/kbNWf5kPqNnAnfC+wm43/IeG871I0ZsgH5h7J290gb9WqMRv8D5W7cyntgPzSzAE/RbJsKoaArvGaVfqtXIJvlfETwwcsUk90lXMw4Mo/Da0WaJUvDI93DFVmO6Ywc3Jj2XfyxwCn95wLMmPqikHGIQXrmpO/JjCg7gV2kfF9YjPYRXf5BdLVHfr8BaL+9okzX94YLPv2aTr1iBXDCHKNAR03U6ASb9Xh7FEdtMQj3l9AQ/ogOrdBLm/PhhHJMcuYT8KMBP9bud89tKYAUvy9F1M0j41le7J6sA8VFmT2r8szvkT8ep3HrIX5jRN+nLAcWz5PmSYbnyMuDmeuEcokdW2m/ZIe4pdB/DtI/L9aMJw9nqegXEKd8ZoxEMsa73NGg6GI5MtPTogxKJZ15qdD6l+HHJDXGaD3pLQXrLiPrx50tQV1NY100G0L+ljtNID+hZSHnOkQ8jxI+UAI87VHUr7PtyBzE7ZR1dMjhlzClDRaBmYNMiYT2grnAGMSwUqd6PslCKUrhPKEd0D+PDaD7C4Idk7RzslVNgRDmcey/fPR32IIde69t/f+wodtoOJp7YHMZy9RyUV1c/LpgXNyGyztgcu1uFcH/Pb2UN3z6zTGHKsrvy2v0kXwKnUpkZhUL5UhxjiW8D/WmWvFHMsn51jD9qLM3Qp94bh2EcxVqX4vg2/rM+KcWX/4vgTwOs6LAewA+B7gDwAbQNQ3EUwGQCGA4UwkcxC+ZwGiv41glsPXlR/N0x1WvLg8M7xOtgLwQZ2MnQwocWTqVBZlSCUX5DzcqAodyv1rL6XVswNzBC6apO6LPXTfgXkLiJQ/0pgRinVx7r38PUdgtBaefCR37r2xe0IgBzjQavLMODLOg/7YZUHsiDOQ7FSr5C7y628EGHWga17/RuRPB2kbBDDjW1FGl5oorWxva5bWnL6ljMy+t+Gpy/yBDwbkBrDpcZVsYGNMUCaLswmBjVFyPEG/FHqUzJi2liP5y/W2aColsDGOPnv8WV475uPRW7ldwuxcKnEwSMQ5ZKW+GMbuMz1tr4xKTKqLvsQmausW6Tdw33nw/4xnIfyfIv9fehbA/3Hy/7mHhrowO3+41OomJ7auez3xqoWKDWf5/E1cgZCWe8BqdNAqM/zLVHusfpcXBQW73Tow/3U9zpRu4Mo92fd+m5WgQbnXzjMsRslOhJ79I0eN519XjuSh1EH5IdtRyu5skFFF+xZkhlyIZVECXoe22KbueXYSpOcN0KBWcqXeYIc8JLAxXb52+GlebYrh1WdpnjqB5XPZGu2gQ2V1SCkIUzQ17sY7tDtidXuHECq3PM8+CaE86cESxDIfzw4EGTbRtcT5+QUd68rZyp13ufIM+nBI8RBoG5jaE25TozC0iN1ed60jzgmirHuCPZLz5JVfoAdTNAYGJ4NNJthcsIqcTNEgL/vcjXdpd6Q2EmLGeWq5pSfbG2KP8MSyz7PYhi95FmRm1PWEMcoGLtCDNqtcmDLWKnfIaeCPoocPnNSBl6nDeXVMcaairj3bBfw2um+CzKnssGJfWeatC9EOWaiyjoZ+PZ2dAxwEuOfkYSi4vtcJ+NsP/C29Y77Qk20HtD+5MZ5JLuTsK18bsPnW3dqayv4itb3l34rtbyd8zwL8AnAXIPK7CKYvQA7AcoBdAJ8BnAE4D/A3QMjZCKY9wDjAxfmdzdxTbnF+J+zgIhO0toigtQFlylGKMmatEnpY0Ht6w2hTvZrLEpSmsKPUcQ3QVy8U2weO78MOyvNnGYpNTKo8V8G+TMa8sqoNoBOt4xm1umtwXR8tXaqG0UWBoSCLAYnyrUCpVSac53k+RpO7jg8KUycp6/riqFg7KUvFTjI0WCtjYsFFpdZ1Vdb1A3od0L9oeDHrd+tF4hKs7g4uaeDSHVzGGZ7PslijO6JLiLoPuPQHlz7g8rTh6ayT1uc7YjytwvpAPANIPCr2iaxsw6fWSkLTWp0KNAOBJhVojAZjVrX1InEJVfcGl0Hg0htcRhjYrHVWeSMjQ7cwdS/zYC0VR5dSZRlZGYZl1qBUbW4PQ0pzHgguMQ/ounTtu1Zt/niS9iB1SteAuhRthgZS0rN31qIW3NJ1mdrFLXik64ZpP2rBGV03XLu8BT903QjtqhZc0HWsdk2LtNN1I7UbWqRYZdZrt5J00upBVmkcl1N68I+h0vf4r+o2TDaUcRbAcwCTASYCvAowA2AOwNsA8wE+AfgQYA1AOcBmgCoA01mc7xLrhfKRevGmy18vXn6kXhzzPa5evPKP9eLf/1gvXv3HejHzH+vFa/9YL2b9Y714/R/rxRv/s17cdfrrxezH1It3HlsvCh+pF3MeqRfvPlIv3nukXrz/SL2Y+0i9KHqkXtw/8NVErBfS9//HeqFgk4xdDV2zKJAqau9/z4P+7NVmUYndLVoyN76aa+19eCY02hht6Eio6cdQf+Vrm3Wmpg2Z1VzNOTz/NIvaiozmVnOXPeIs6g/WIDKvupr7WbL5s3le9cBZcV71m7MP5lY3czX8/21udTW32+OfW13Nbff451ZXcxs9/rnV1dwaz3/Prd48+89zq2EHKU04aIYZvKJT4EW5OtQYZljNzfbgaCjsKO7iyL4X8+QWrkzw42p2C1ci4H8qSOAA4HY1l+Oh1Fbr+/XhjOesGE9ILcR5cKFxoaHchOnK9iwgcxurOaPnA2MRwUZ45hnfI1i6Z65xDsEGet4n6z3ynfKvwpe2L1pRWDlTrpFXbeEcgrJTyMW3ja+RvEggKdzCNeL6pK6dyXFUteMjR5r7KN9Vl31vVYbWoZCrqnaDqZTrDSM9+mKB8Q8ruqiqSrlksLn/m6qa0uhAN4l1o/tko8VKw6i04rW2e3XAXQchVxvIZw+mY/uzdBfUM8rcVFz2vcJZSayyqvZW4PCgMuWqEl49Zis3hE+sedpoJCm76O54pSuM/VQ00vzOY8ujVkC71I0yZhrU7GruG3dAFwyH1iirtnJqPq1GvpM1DiTUR9y0uhz3dzcGE/pjQB+so2OLkkUb5jjdeyu3n6cH11uobqPrArplWqgyLdsPNP9ECHuNu2+WqlremBiANyO2YeUnmdSdmbHkZsQO76hztK9l3Fmi28S96qPiVDvbt6djMZYEN90bd8Nt4ib7UrrdscQb25HSeMP9qoOWYZ5gjqzwYV6g/1C3P/1buBNCTk0HY5E1QEuXUaXtoT3IgPI592fWdsY3AQJISNluDAH0bHWiNbtWrCOvwXc/wE2A9t+DHPg8gomD72CAJQAnAf4EaPcDuAHEgj99HcgCgJ1gZuC7F4A5KNOv58ZDbWSOjrfg3J+SDWE76WWaLdx5H+7cjAF3I7jPPCrr3s6Sk4ezI5u4WtDjl9TI2JF36AxcE4/14WonvmraW0DzV97r1lA9Z6XjqFi/nzDwY/sttpmGAbOGPXBcqQ8EuijhKrS3SevCmX9DOj4B2A7wKYDFIur+3fWX+bOm7k+UmtZztKCKW8VN8FGaAKhRHzluOMexm7hN3lXcUz7cO8+A3SVn/S1mc/0t5eyA0lUc6wtYgyOD9A6441O+rPYWvVnHDmPXc7/5qrk5vlG6DXh6a9BPlrb6tk+0Hb2Jm+NtC+k665PHUQkU9k2puK9RVbWK+1jA/8NCnjkR6I8A/QuE/j2gvwVjmkgybyLWinHem8DXd5DXnYGP9MxQ6mn4ZlrE9UpRB9zEjfH51/gCs+jSwCzZcqpUaQw0iJrfEy5xlY86PvPHCGb9j+JaH9YDOYyv5NBjzBz5AJt5kIpdYsIU4zqHAkCpRVcqHvUAWpPHlvBUTglP50x3pEAbocZ0qUnXROsFqI+tr4jraz3ZPHa6oxO66gaaMzWR4GoW+sCIijHNPCqtwWnQTwgJoVXNcE29tDYn8n3Jk8dOc9wQRFeD5nvJFXztiGCSqrGu+dOp1ELL6kWR1FLx6fcPA/5wSpGXaY6fSWgp5uc0yZCefEhP2JXmOHOg/Emcu9BXTl9zrH68RuCeFVqmOfueC/x9TPxVkND+VfOipr3+L+sDvqc5NkmpztU0PsTTLEL3ruQ6RXNVcoUUg1yYTFxfQVddsHm6ZpfkegzKH/lFvlvyDGmZJJYSFS/y/yjPCuB5gsTzG5oU4Plv3wOexVgTSay9JJ7j9G8Dz5d8LXkW/bUh/jpJPBdqOjTznHknbBalRc7FXNZK/M3T3JZ8ZNwfByHcdWMIXp/ouqC5vEWp+CdxtftE7hdrtkuuNdbH8f5PHIs1dprjD5/IdRnh+g3gOvwhrne7kW6ao9Yn8q3VlwPfOY/hu0Lyedgncl4JpX3rodLeKXH0n+bSFinnuEX3NZL7Rs0fD7nPkNw/lHjeoqmS3I88hmfZ/+QbeZ5O4hlsNmn66XFv8cOtTYyzJ8nlgYTrePN+TTfwed0rlmQSq81F12Fies2HNBebS2gm1N5IQtuR0LY212iuWB+042mORInqqOb4Q1zyLnSVSVQnNKcecr1FXO96xbz9ShOkP/RQ3nq9Yt6c1pRJ9mXNeYOSb5lxuWE5aJIV3KXHrMcv8xZn4e153xctNS6GPr6C++aRNfki4zzDfEL/+WPo3/S+S+g/LXrH+Dah3/EI/UzQid4g9GsfQz/e+wqh31CUb5xO6Jc+Qp9jzDVMJfTvPob+Y+9LhH5p0fPG5wh9/iP0Y4xPGp4l9BMeQ3/Tmw30syxG40hCbXyEOsOYYdAT6sGPoR7pywDqCZYBZP2zgkt+hLqnsZehP6Hu9BjqTb5eQM1aknFNE/yE/ONuiCQYJWAobp+oteusXYwdiM0dyWakVU20ogrulmTzkjXGGEFsrkg2qO+0Jja/SDYfWiPJCKGC+16y2WhtTXSiCu6UZPMpyFb/GMFpEccIAdA/hgF0AOgOkAnw0o8Pxg2buHWu/9u4oYJb7vOPGyq4D33+cUMFt9DnHzdUcHN9/z1uOPHjP48b8Owg7r/Wjo7LxtMZ2icULN6ePZDF0Mb5Hi4LbDW9WGzblHogW8HpIUVR2ci7vyQe0A54DK02F7WWJOLeVcq1R8sQd3lTxzGt56R8ugZfzFdRO6FdqJ2IeSc4/695d9f7IO9s3gd5Z/U+yLs/vP+dd4qf/jnvUA8sN9Eaxd4P9Fu4BbirPEh1sQhGRRjjZ2SFf5Q0ExvYGEL2bW3halxUouIi7tF6m3/beNN6mac2UV0C4k3u+/cPZmb/tVDR0TJLr+q9njvvjHMEKij1q8aXDRXcCu9pXlEnT9ndoGilqIq6gCE8y+cbp5LY5kNsv4D7KWu34YGNerl2eBSvCBvLD+w2BrRCk5PuU2f9hW+l29/U49X0u/8pmmB40Zh+v4Nx7Ihzx4vZFewJntrwCx+RfoC4Ly962vAMuuuHg/sSdhm4K4p+4duFmZv+APcFRaOeGA3uqQE7Ms8cb8suynHl72vSz32n/jIf9QU7Ov1O1hOzRlw4PpU9lbOlqUfO5qYeUw40rZpbdpyKo+NMgC2B8c/Gpj9yzRK+qUk/a5+E6wz9jFge7b3p92OyBs6p5UM2ZN/rUQBa8k7gAUZhiYYexAfjnfNuLa/YAD3aYUg9uGgMScTF7cm+98ek9Pu96SPvyVcBpQZSD+7tDRri3gDu+lnpd0alu9+XrwR3tSufWhFhaE9cL3kOmKOgtmDO/uzBV3+G3huzV89u5tYJWVBiaRumwX/votetwU8UWVWjP7S2gvqiZq1kD91T0h66qJ/EtZAx8J3yk7jOcaJHBFMG+FqAPwCGnBP32fEwfo+HWpTL417QLqDr/8zDiLhPIssfxd2P6ic3c4cExtxZ30hGt+oncYfObiGApRLvWVTxdELn/VSz/UaBjs28T9OIrxGeuJ+j3gjjKnrIYgcd+JelF+v3V9LC32IhCGJdw5+yDmD9du8JYlwXrRG/hjETIK2vAMw9558v3sQN4FvsB1wB45LIAJCKOFKo4Pp7xJHCD78/GCPg+ULcDfgB+5EpzB6mKrFR0WH2ZcZSx19eKnZKVqljiC/jdlhwxu2o4BLH58Jzt8Nm4K1AeGfmx45xENvzt8M+LHX8BL7Hge+EFr63Cs/cDst64DuDXwehh5NYFMGljhqgyQKaVi1oPhQgBcEPaBL4WDYZxsb98Z57oOFw9y9qS3Q6a2BLHX+DGTUohsYdA6UOK5hRm1KBmQHzZbLzAU+ilTq0njLHDxDetzxFJbMi/Q8kPAXbisRR6jhNwsP9D7hPrNRxnISHOxJE909JeCKt013m2M6j/295BYUj+FLHduL/Af164l+kvQb+P+HR/VueocT0fkLiw/jF9C4m/kXab8D/2/y3fAgV4r/JYjFFXRnqf3N7ObkdXFGw3MYUvmWPLyxi8T7IENZ/Bxu+CIOvwbxzqcUrz12oLnRDQKT4UuF06bZBWZeARjpIrl3tvntf2cAqdzQolXtjyqVzeUI0UETQDcpI/736dENgpP8FbfwyDUuD+tmLVJ84RjjxLZWAhhEyCIde1j6rvaKhiFI0zJczDYtCBgxXNHwg6z8c31r5RnrhaBm5WTGhMLBhpBxvJ+w4/CMbXahoWBjwo/QuEroyDYspdO00vIi4LlIqGuYpfiY3BlLNL9ScAdz/JrSYHi/vf9vlzGNevlnymJdvljzm5ZszYP7Rin3cRq7E93/t4+a5HvRxc1wP+rg3XQ/6uFddj+njLv9zH+c4WG4KYGVVHPeyKxD+813ZjvefznYUDQupCixjSjkux3UsK6SsVelK7jfvyDu6p7EuhoPPp130IJdlJVfnLeqQ2xAIda2DZx+Z8y51jPLsI/us1KwZerYurpXc0Ydo+7rWkdv4mMISWzjUG/GWSnyXId2RNu+eVI/SHb3mJefTg+SNtDw59yrEVdkc13V3uRRXW89qKa5VENffzpXc4ofioqR0vttMe9q9RKLl3R9KtIuB1gK0+Q/RXnWKtC810+5wvyPRXnS/J9HOBtr9QJvlDVwjK2XWyEuRfiU3rJnqY/cMieq4+zWJagZQVQCV7qEYd0gxdmmmnemeINFudE+WaCcAbSHQRjxE+6FEG9hM+5R7tEQ73/2MRDsaaCcA7T0P3rcN5VCAr3RAWRRgOBgePaifXUluQ3ZaSsid3PLCldBn+kNNcKdJoY5zp0uh9oNQe0Ko3/zPUFnySlLLUM3NoXpcsVKoKe5uJNRY6HErOCWE+h+PmKOVzb6vu9r5y9+tIb7bEd9/81D+ku/5zb6/dwVLvgVXOynFwZDiCzytDrgSqW9jGB8rcCUeSo0z1Lge0umDo2tvv0MPxXvtbp8T286/zkN/DjAVYDnAXoBagAYA1c8RTBLAyJ/F8WbIedRnLTY5SFN6vMVGjV8OPK+w0QNACg3oYo834r7HqfZtXU324ZUrbLLirfbFlXh39yRjmp2JPm8PNKba5QVJdrpyqj2gcIt9UWUX+8KC6/bArg47W/yLPb7YYZ9uPG/fWphq3zz+un2rMc8+r9hsH9n1qn0hvldQgC/tXrUHQluaFg1f40b7tvFb7aeNN6Bk4yHsP+zbjNvtgeM32xcU4A2PDjtVuNm+pfKaPaB4mz2huJo7KyywUZUnbTR54wl3SorawJcrHAfXgdxQVFVznwkq+P9UALnxLMiN4ZQ2rEq1KrgspLSa2yUkZYWtiigLB+nxudtfV9uC//WCWFfN7ubyd8b4y9/VUSqjGAPuZYTyf4h2nlBvU+F7n+TlgVpb24J70n3uJdI7pUEWv0xRWPzSpF1dkF5leA3KebWbUn95VdzX2rKcp/0slrO//B7Inq8gpROaU7rd+aOU0gtOi5TSOkM5ZxZWcoaHUtpN4nJIM+1S51cS7WfOkxLtF0BbCrTJD9G2lmjVzbQznAck2rXOQxLtPqB9E2hbNdOqdiiqzFxrnh7kBGq6mXqUc4tE/Z6zSqLeDNTPArXd1TJmi0+M+ZrLT9vduVKineislGjLgDYNaOseot0v0Z5qpg1zLpJoM5wfSbQLgTYaaPe56skN7arx4gtBwePx3vJ1tpAWUuMtqPX97PgyzaJCzlIL/kvInedKkB4rmmOp51+RYmntfL1ZwpZzVt9Kbu7/KZZTEMtUiOXr/4plYnMs1fxYKZbf+BekWJ6CWA5ALKMeyoceUj5kNNN+xA+XaI/yoyXaYUC7Cmi7P0QbLtFqm2n/zfeRaNfzQyXa3kA7G2jDXC1bQ0uOtgFH+BrjdsKRCjgKJq/TrOTuO/0hZ/CdpZBn8UlSyB0h5CwI+ZrzcSHjven0oGn2ReT29OlSqbQM/XRz6BF8oBT6MD5SCl0Jocf41Fcebn+LpLa3F74/AwT9EsEkAIwAmAzwAcBGgCMA5wEcAFD+TlHSfyzFuMLxq+CvByr+5Rb14Jp3JTfH2TKXX/KKuTyzmfaI8BKhXeG4LUxs7mnLuVNA+2IzLb4zjHen++9rx7zB78eOv930oL8hxJHNIa4QDFKIXwmjpBD1EOJaCLG3lHZds+85whDJ9y4hQ/I9CHwvBN8dnao1D8pWXuqBeCKbKV8SekiUnwi9JcruQJkHlNRDlG0J5X3eT5khaCTKWUK8SAn9KJQ/UF7Dt1SeITJlJfT/zTQJQhuJZpwQTWgiCU1PoPmGV60U+TrZ7D9UYCT/6UJoi1rQ3kurOz7S3wZfEOtBEnz1ALkAHwBsBDgNYL2A64h4en4D975HoaFj5eyJW4qIilzmqHT+KOM/RKMVuAYhCP5vQs9UxFJxX2WrVgE/48KqoG8qx7cUBO6iEF4esSqyDG/NX8nN4P1l3A7ozkryN6eZj50+k8THJZ9J4mMv8HHQs5Ib3UzbqvFlBul3CUFr2pWq1kSVBq9pXxqyJro0qLrdzv236cI7AAeaddwX5g0bcdfyoK+5AnHGN8f5mq9UinOTb6UU5wqIcw7EGflQet+Q0ss00471LZBoF/gWS7TzgfZFTxnXJLSkfZbQlnF/CX7aPr43Jdppvnck2jeAdijQ/gKcyYAzOXCmAM4CiL5bxn3XTN3WN1WiHumbIVFPBWo1UB9+KOb2AqWV7TgTFbSj/XB8rxTGoIXtqqOHk1fNUsOSvwSz3UIPugmpW9Mc/g3vaCn8dr6nm/Xacs7hLuOWPBT+Ld8/hX/6v8Kf0Rz+IW8fKXyrd7AUfh8I/wSEP645fGV10E7Zbnx9BksVU3wdviszmyC8RghvWHN4H3v9rey4t6sUngbCq4DwdM3hBVXLduIIdt9tcaR4Db7rmkOLaQ5ture1FFqFV9RmW5P29xqEFiSIZRHQ7HuMVyb5nudtf6WlvtP6V+lcFXyfA3gf4DDAzwD3ACIuRjA9ARgpxYFY/m5a3Ync1BGgDzCsivVxd3yUusk65uLDuhOeA8Q3MnebcH28nnuHbwP/b/E0lEln32Xbi8XrbS9WqhPW2yYANqE6LP6ybVxltkPNmOz50f57bZmqJq7Cy+ygq3zQntQQwjM8vjpQDzr1Ohg/4Psu0+3bQfcbOcBknwba7dbx6t1tdpnt7IDN9sXjp9oXGTfbleNBS4b+ST3eZJ8y3mpfbCwHtzfsW4x97AHja21ao8M+zXjNrjSW2DTgHmhMsC8C2u2F1+yLC2ptcUaTfYQRtW3Q0Y2/gD/QosGfsvCGXVnQ264wYlhvQljY15bYYo21ti4A8ePx1d9aW2JBaG3oSYTkPG0OpW2zg6k+ExW8I3r42SiUBSapvMV3Q4yF4s33UfooQ/odbYSPy4AcTvG/mzX/Vz4sbFMm3UjT3wD2uyUkNS75vAV3lr9jX1o5997EvfSQNHtQ8dx7z/4/3t48LqrqfRy/d2ZghmFYRQUknWFRFDUEzF0R5DoMFmpZZhuovUPqXVpWRlm4lIqK4LiCiO0z4AKVJplJZWq9pZjSFpU0K0fCmWYQvXfW+3uec+8gAvX5/vXj9TrMveee5znPcpbnbM85QE9ZZl0HTzMO0OoW8/mQ7Mam0zMmnw/5+tjer4aM+aIlXLGl5ZauPqyTMTTafw5oJx+QG+jtku3S7TXs144giD3hGAS6m+oZbLjAbuYvWqpLIFSoB1fDE4Sa0IRqSwVqMKDOmt2pwcGgwY/dXWMGgS6veeiawcYowPS5K8oYZKhjDznpmkEQw7MLHUH2GEWUUQ6xtc6g2lDDVOY6SKi+VymtyM7tOPrsCq2X3e+h1KmdUopdtCpDYqclsdCe4q79cdahFR+Y6EljrUNLakz05GVWY8mbpmrL0mgISpt1KqFrj8dHhcYhUFDo7AO8ax3VlieLnszpsz3IPiMgQt93ez+jvOYeBm9lvym06IU4shVoE0Ye0jO5HceffSy7zhy3qDQD2/a4/KuQ48PRFy2zlNWWh0iOT3TmeJUTchzljIIcQxz35UTp78uJ1kcZ780ZoO8DX+KdffbJa25Afh/cJgttkXBmObfj1LMnILeDYm6tJrDVILcs5TGrguSW3JlbvZib04G5/cxNhNwmktwmirlZHHJjn9qekr+V2+lnN5ljF9WKcm4F3kZCbgOAt0EkN4fbl1uRmNuXJLc3uQTILcoYD/n1MQzYXsd+7HBAHof/IZ/mZx8CroxZPq5otbJHWT52Plxx5bzgNxHipuD5PWzj+lyAMfrp05Mqdu6cvCxwy5T3X5o+pfzVVVMA9rMdT0umfP/MsSlzDaOPbVa+caz/L/uPzVt4ZHLowZhYGUNpZMl72BnkPrm4vLj8uPnCvukKqCUFDA/jWfxC6YMNVBzeCiPVX2D9vcHA7UVejv2/S24INnrZmZ5qS1iRvLaQCTRc/4eyojiDY9P09glQ23VuSh1dF3pUAyUYa7km/3fg+IaZOoY8jYT66i/U2ak4Z/sW2DrYpj5PqKH1/YAapEUG1Bzz9DOgzz0F/H/c1c+oAJ0EADU60JIOtKRTYrs62B0C3+e4puco9NNzAvTVlulF03OUesUBJidQj/4IVMYMZvK/lvVA0JLh2Qnaidle9i8YXcf65pdXJC2qz/DZNUJpTCOlEXNudWHOka5kyDkZck6GXJMhT7pGsbfjH0t5evsD4V+bkxZ9JOLFchcPeOOBo3iC9yjBe82pAbwaXSxgVm4O1LP/UsIOPLsHML7fiZFWV4G8hfP+MyZj2dnQ8PKU3wL7TEYdrOn3y6TEV1WT8kRdYFmKujx2SsiuuGOb7l36Wf1vrZOwPGHZJGXxl5EYoGxNmKw4iLWU0lSzg3DGZDZ148Jz6dzwpB0ZLpPiKN6QHQElLzK2mg3hJRppbGOrf7iUiZyPs9JnxdteG8ksNd57R4vvNJlxPgtBeJeQG8fPQhDecfZZBu8y8R2f/TpvG28k91qXifd9+izTO014h7zJcstWHQwxEoiRdMbcYSoH3M0QfDERkEYGaWSdMYEQ4wcxfrfSHKPVlHrxdNw/xh30YyK0fXOr2HtcfnaV/3DmPk4WuNn2A4frFmOZKjbD9VFGhylIq7qnip3oCtBWseNckaOFVI2csBpSxd7p2gupZNqjV7n0KjbxyIlfwxVfQ/jicpji/z/OVCJnGLrqcqi3d12e7KbLk910ebKbLk920+XJbro8KepScTAxFsuYxaMUR0jK8MgFCvHu8qq6lWR8dI1PJJ4Nq9lfPFvYa2SEiytTIQfG4ok3cUxwyeG7EWazbRg3RrQlH+LGEKsQfYxtY9O8W9jTCH8/wufalMG5NjowyL5QJdkX0jSRaWqNahuwXbCBtl6VUqshTGAkNd1HQ2NNu7I6TOe40GR6MtbFb+CpBWjY3UlDue0q30+kIYqLJDT0zU4GGtqBhxIHrnxtYd9wUGD9+kFqEx8oppZwQSR1MhOQvY09T8aeuHIfoA3IrgE7ttSBdqzPPn5atGc3we8n527N6doOHquLBrslzBWNt5e70RoKdA2G5z/cEoORTfVgOyzR4wqKVE/FyfRb2CmdcweSmmhjiuE8y4BsOeArRRzBl9uW87mEznLbfv6ezhHNNnYNcDWISBY5izuQAvn94IyuHWxMqflBHM+8SG6vo4u+IOVcaBNwtvkLcl+epEiVijFHMr6AZ9quoiV2leQS2EA/AwV2ziepifxIkYL/8smipEYABQxQ8GvnSDNhpwIoWO0atTMMfotd8VCCUqAEHXYraqi4FOPofd9bqHmbLXTh9xZJYdS0MMMd09C+FW4STijCeoaWM9YcvHXvN/hmzLAQKxbpaoHRzmmg613OJxmbVyHSpeEDO0ci21inm1ZPqbMdvX0e6bKoNynYAkPO41yBr719wi1llLGNXJmmkdui+ZLbQWN7S9049ayMkTKUGvdiZ0KrUgstsT6DNSGcmtnE7ubR5z2ua++7If3vT6Dpszz+j/YE3ajO49lveeE33IN1KsPrq1N3wlg3o1NuiQktXEdEUPsWSHmcD64Msk9UQY7BuPt7PiP9QpH6XNYWhjUh9HMAHep+rpaKxRoEMPloN/i5JKEhRrTFbNADb8hC6bEmOkU5LBP03AZyawK5BXTK7T7v/aLcXvfeL8ptDsjtUbeevdk55hQoegpG4cBF/k8wLvltH+YYPS1q2h3Tbo1O1hTVZKCubpgSUz+8ceo1M+R3yaRnTbwvvxjveDG/u70TxfzGQX6DIb/POvPDE+coCeyh0/kWrqzfc/A0gQde27csCGr/NP+HyLBpoIf160EPiSkfQF52E6VBOqvZ16Fnp+JybYnB8D4fU0dPe24f3SYNQEpXQ2sb7KLnuUE+eBs3PUo5FKXUYdJlZYCM/Owyv79E+il7InUBeDgMPDzTycMnngCRhzaPSuRBATwch1FvEGifrJjfVt5yzou+eOB3+3lc85HESuMacfflfClD2yMlszhZDvCTU57hMIUetR3cPsOPCTn9cd3TTMiJLdAOyuwK+RvwG/Kd//6QE9vhSZ1G3k+r9gsp8G0REw5yaub9jQPI3JTKGA+/p/hw4wjDgBqeveyKhyeejXEnfvga2aG0jV3kGlATTmJ/cOH/bPfL2l1sBY+QmW4q3gd7XIR90q1teC77SqyC8bBynlKPgdpFx7eBZUSnYoqkfEytdws4za4d9cLuJPRFO6BGwLHajf8j3HmQ0+M80hwMOcWLOT0vwt7lDm2wxc7L/trcYgmHUfyAoqRFwl2UMUW4Ctxi6SPeTXkHvPeB9wjxfSC8R8B7X/F9ELz3LcKbA4V3Na4HkdsDadLqJeXHG8MNTfDOs6WuxfWTdeMIxeedSFuj6y6gM4xI5BMX0hlOOAttcMeOzi66jbqT3ag72Y26k92oO9mNupM9qDtZtIhJyh8hUnfZO4LkPgGo7K8LIVSuJVT+1xUEVH7mRck9AVQK6ba4IhvS2wPCg7IHEw0l5auZBPM7Z8IVky4IZTIffh+H8ByE7RDehfANhB8gcBeE/Xbv6t7Lfi+HgrxmO7vvy/SwNr6a7Cn974rdul2EoinO23dmbtVty95B4FN6wMM431FO4O9fUarbQOAHdYN/XfdG9joCH94LfKRnJYGfsuJV3SsEnnfcDv+87oXsIgLf7ui5r3St6zkCn7jiad1TBP5iN/jHdf/JfpLAf98LvMK9kMCHrXhU9zCBP9YNfo7u/uyHCfwHvcD/4Z5D4J3F9+hmEPjqbvBZOib7bgK/2dHbnlyGwP9ePFk3kcC/1g1+tO6u7MkE/llHT/lN9I4h8KeLR+qGE/jHusEn6AZn3ynovzf5cYkE/mDxQF2MoP9u8OjjTC3ovxf4vVwUgd9dHKxTCfrvBu+n888OE/TfBX7AJd8+W2+LsM9WCbZ8PwixEO6EMAnC3RAWQlgBYQeEegg+zrd6J0DOhabx5LzWNvZ37p92FKfpUrKJ/jlhv2r5lTt1I0nM12KM4UqSbiiJaRRjjl0ZrEsgMR+LMT9eiSU7k7ex+8UYy5U7QGYY864YIzNHkZ3J29hdYswAc4SuD4nRizEp5lCyw2cbWyLGZJsDdUoSs0KMyTPLyc7kbewyMUZvRt7nizLDPbXC/r1qdt4/+vPbxj4o+vP78Jqwf2/n5wI87kuqZqe6/9/2JW1jR3O+fUnb2Ds5376kbexQzrcvaRsbx/Xcl2S79s/7kmCspWwmtm0x2IoKJe6+Qp6oOGleZt6qvC/zpPmZ+avyv8yXzqft8RIpc3s/uzYj9KCiGXvg+G498OKDKsaf6cuw7F6nhhnGpDIyezyF9ulmCHhntmoU3hY8S9ivIcSkfAlPsyCEizErMr6E71K7SvqbKZlZ3AXril6wvtgD64s9sL74r1jv7xXryR5YT/bAerIH1rGA1Q9wDgecSYhRghjtMAb7UhxBCM80GRGrRuFbeSeOq6ZEsIdDD5bUKRkZQ5PZp2Ie7zrn2Wk8nui+/VuV+O0u8g3zxnkrPwbvg2XZvxxdacA7nm9xRN5SM+FpFpH6WqACbd1WE84uCVTg3fEyZg2UDrzPQtg5fnsODbfl8OJtObx4Ww4v9poD3tOLvqN/INgpe7y0mVBaXKRKTofR+ExCaXFROvzOJHTiM120I+Mv0+LpSB9ShzLxSWS5KJF9Xp+0fF/eFL/s6fHliPhFT77gOJ7NpeIucnPLAhcHMf3wviZ7vFxmVykTmd3sYe97bVSgXxulwHmScttwTke87aCfi13sd877stpMmO4dr0w3Kjpx2i72K+enGRdNUjIixj3Nv0LdxLHdbvZ/R8uhLoU2q+KkLpqWuiQSVUGfgsC8iLycgpkF2rx789YXlBWszdPnhULKxQcHNFNtK2RU20ppQsHAgsF5d+SdjvkhhmpbJaXaVsv8U/xHDSxIgHhIRUMq6o68wAJJgTJPmnerZF7kuuoMZ+t8JVN49pVMfOteMssslNKnpQ5r+q37r6E9ITMN4k3ZQoykM4ayqyghdlXGJdBcb3i0PfCc6hXPqS54cFX6keW+fdEb6ooZqYFln+akhhvsk84R7//USj1BxefaVEq8vVBaq3TJxlEJezNwRnyE6UXrKcIzerMrs2l5PF+Bmiy3pTmTG/CthbxFOWfWR2rT2yUang3wUOpbO3x/xtmU0XSqdMQpePrehPd6/M9Eqy3mW3hjuuBVOMd2wWtxUIktzentfhqJ1gRt9u7WcMXHELQHPq1o/6loctcWmbaH/ks7HNqtHeavLQZYPyaYUSXPi7JHHidrYbevNQj7jv0vbMmwkRmCv4Du6EvzoHdiuXmxWDfw3o+XvBpGARbyCMe8WPRDybOLIcYPYuIdaiaivpr9hcMzxZVQpvdew3NyA2fAWPT0O3W+u12hlkxIylvEBBjOs/1cdVZKGUBsbIMnnIy3vnQPMOJegjPukNPEB7N4Hyx+Pc96nNWWQKWQYisvY8Y25HY4lsi10B5C7xtft/hoKtjnqfkcyC/yYrgC55DT2vB8UBDU25tsAX+WzABS87ZCOdpqkfZc02R6W9FcDRC9rWget0g7VzRXW+geK5q4mnncIvt/XtFcbZFAej8I/oBbXnTcoijElvH/0rxfc2CBFFqJTGghVuXhjOhFS3QR1oKPrGaykxy1q7YqSqYeo+K+BEyZebhTH2e61tv8vb7bvNfbjjuAV+VZ0u4aIH9hvlR4RolJlHirN5b41RapcuxR4f5uoNAeIYWWMXZZciYXMTyTC4WggqCAIBsekbojo920MFbNlLK15Ex06EEptKPLJJRGao+UQZoBb4uzQcKuR6zHXCaeQiixfcbTiZN+CWlfHfBLK7VOQ+rxQDJ7gLvty20LuWUN6CtceBvN4c0CQxmsWWU2mRt5NJtD2ucS6HACHd4FOus26GG3QZtdAnQW0IE703E+InLEtPtcmoB04TdK/A1oVBDfzNgTrrcZnXRi/1+qLcFFFyF8ZJ1O5B94DkovxAR0xvidxbvOWPNY6xMlbWbUAEpWcfR8SHb6+ZCv03HtDWUbCTrH24FkORUgpd5mO1BafoyK6Q+l/IYH6+pZtwZtsuDhDJ6YmgD8RTMbGGpwOYOzNjtBw9je4qwNfZd0JM4I4gz53yZZamYWZZdRZpNq1JIs6Odkl6C1R+5vtzZOiP0k7xT6ycUHGVLXr/Va19WO3upzX0e84SZb5Yk3dLAV/ICaAOMCwLyTX0DmLo5CbU9RCrMdu/G+rIY7tbkd1iU8e7dTzTzVWdsDjHdBivecA8jvXr7akgBQ+LwKoCKhjbAtidX+bhZSz4McF3rmQY75PLY/80ieBa4FxikI4ZxSE8ZgzB7nAqMWV1SdCJFDILR8fSdELkDMgt9CoDJAOYukzRHzuw5tUq2YnxHaojyxLcqG9vwBCP9pJX5GbrOwaaLl27VabfFTYs2yXUMrB/e+OUwbbIsP49qrzy6ZWQahOHAx6t4P6pRKqQZ74ynn+2CXDI6cA1ZJme03l88qwRseV3sxxUPODGZctHpaJfuKd07WH6JFQh1DewTtksUHldBj+OGMrV1FX++xSij0GANaBqp3s396Bnb2ER/yGkaprWQHeAeKfUQNxMghJtyLfcRu9qQH+4idGWegj3GafX2F7eA0Un6a6mRdyonMGATlhOZow172Pbew8johR6LPNIzPker3srvcQZWZ+rDKafpqyxhl38osPW3MRO3xcigv6e3jNCnQO4x2jGXurrNBeam2JCvpVFlaan7I6X5d8gkyJuLarTPROAqtbMcg0Pks9yjjeHh7Cd46WJ2XThjOPJ6JvnDHGw+D1YH5POfMNOJujeHO8UYFQ6fx7FNe/+Ftpn6A5xz7Lj+qZhDB8Z1jPKEr04X/57suWkI67Rj/M+ntjCYQ6PyNo4YYxXKDPgENF3GdfU86RamnYvlphnKj/CluIt5JaCVlCPe2y5htdSiffu64RdJUsG0qbNDi10FrH5cvM2y00BVNFknJRou0ZC8rAxmuyJTpR+T4QfDXI0RcvhygWZfcqITUckitgNQBJR3sV54gkEOTC3enVltiC5ssQYUvWL/u3KmKZ0ps1iuFHVamUDhX0rco4EwUWEdGDe5FoNT9iNff0KNjrAVFcYsEv8FM0bwYTB2bLwXOazTB2qtmtL4qYoSSxRTd+lqrkWt/MUuJ/6SfzYIsGtO3HvsxVQv9ej6EojYsq7gC6M/sZbe4tpJTQKTfgt79JFnjw1YumTkhnjk6S1b9qEIcXQpfTxadAIit5EwRJX47SVYLEfIEpFl81Haw2pIbuEa4j8s9k/Qgs66FQu06w2ls1HRhn9w4oKLMNsAztkHYj4rnx8psvDu9PgekkhnmZf/mqYRERg6lUTjHW22ZEMiza90TumA0EozjumBsd49tGN0F44/uyPrcjreWjNGeNfvw3Al4Frqp2NQcAcsbBEtSFyzfAZYhXbB8CFjS27PChmg/ACzVliHERz+0wO4CkKXVKey7wBU2Wi81qKHe7WV/d2IJkuoXMXfkyPR4A8AdUJbQz9gVjx+TCK3fu0uitF72ZX69SNka8y2/1qHp4m9j8ry1hpuZknR7we9rD3J/TBbiFeluo/37u+fPnHLqt3BFwGUs/4r0GeS38TWKSk/HMiDsOWlMXwzxQhsZelsbud7269F/ayNDoY2sYs/xXdvIXEfXNrLdhSm+5n1t5F+u/6uNDP2XNjIR2sh7XYk92sh1EHd7G1nsEtrI0a7e2kjgJxP5mQb8TCP89CP8RMqR2mf5G1clcaOi0d+aepoOuNhEuPgP3ptIuFjjOprRKnCxyscD2sZoucjIKH4ve91xVpwfUDPHSW0QZgQEW1BSNMS6VrT/JGD/8deSDwonGiXKcjJalJL92mvq3rfKiX2JGllv6+dRi/i/dDxZEJd30TKgqLZgQR7ezdpW8HYeyinhPJ57LLYqlBqy7+cDfhGM4DrYlS4psTTWO4EypWCnbnAnQ1qw+10aSMOzu3ipsYDpYJ9yLSI3jz0PFoKcjMySO23Uh8W9RlVsP6+w1+jt/LgFby+M+0/o0dt7Y9oe0aMvRh1HSvDuZdkAtMLQyu46/8GzVl4YS0dK7FAKCqxDYMSMO0vZLnMcwshUBlZ3Dlcgwn2P+1PurQe+FjH+Bkov7HGS6f30PNvE+xPe3cCPMNL02c5lvdrOt0aBPS3E3utCJKkL93lv1YVNtq/5rnXhKSemyPT66sJC5/9VFyL/pS5MhLrQ5JjYoy5InRO71QWnQ6gLBxy91QWUWVf7Cecs3xB3jKXwQinIB8rRu6Zvdo9nY3jf7F4kZe+kEecDfydrrjhrh7bsCIsC9PpFXSTRUZ01r6IfY7NOrYkBHHfzmAfr9Ydy1+FVwX+7F8ewVu9H1q+JXU9dryyutsz65CNrNnlPt+8sXmYdVpTCdFi/JnK479hLVm2JzVpIxl03oc/WMBMN8FxjmG6wGmsmGjGPSB73cS5ihgH2MnhepBxmTIbnL7zJNRoGLdzNfApQqFPeZZxoMEyfaESaPF6E8jci1PNdoN7vhHqxGxTycNk71ppYgpAqknou70udR1JrO1Mjr//zou3sb4xEm4aPrFnEDET7l1jUworpWD6+ZiChIZ0PrxEomMAnWtcrk4ltnudFju+q4dlkfiIp4296/2NG33UZUM4V6xcfpdQOsIFqa4ZNTiZnZ0MBaqIX/9N8qFEGv0scoYZaGDlgWQg10oZQfZg+XN/BLnLIaqOYakvfaAjKvlqwh5Q05NSHV+J+Ai/+v+ittoQqlcZQEgNjNaWAs9IrI5ZjfpgSerFIt5rpX5d8VFj3w3kFtL2wb3l9mVyRFnb2M+yLiloFHxZYu6vrpPtlUI7p8iB7svIGO5JPhnYpyaFhZjJe9l53X8MNNp7va6i2LAELa5CDSgg5YGSGQ+nSljxjCwx8AFpQocacIiUl4azMTivGM4ft0pBBzX2YH8R5ug7x/gUcuWW1xDJTCf5fPfjU1+BlfyFPyRB3pvPpD88t7AJ00llKPcg3g7VJOjzArgrA1Xu5PVTeYAqy56n67lWpNTCyp1ySJ6g4Pe7c85vQTLmkmXpxtxcL40m0oZKYz+HNYkb/wu+b6bTw2vfalFSgS2bPmZY47V27KjjMHh9yunle1GyLtLA/UHICat4XkRnwFNwmleDst6SNVp2edgEsMJx3f9/6XtFbUC8rMtpNqnGq1F/N0hHDGNxZ87FJlrYw6wMTpVENGVjb1zAvkkqg4mozAHMRUOgf1Ey1rVLJXdI4pBLxIYWpDObVZp4JtuEawC0dOZrZYw+l+ltDx2dwqkktJtko1dAfTVRC39pHo+6MOnSNVpbYvoDR/Gs3nzzwWcZNk2p0/Aibqa+R3uGFfolW55lfPJ2UAu0FGbs01tH7uo59Q04ru4wxaGMfGBNUOmKgBMR5Y+CNZ//whjbEgLa8bqUxAb5ucCTUxBhHQswh10jjGPgd5sH/2Z6LYFv7RgzyM31gJHx0iZc95aTU6Z0j4TGA+SZJ/6N7DMEywIVx1zz4hvPgoQ349aSbVpN1IRhf4J7ejsvEtugxzx0pznNXQT/bdZ57k+2w+9Y8N95xJMxzV7HJLmGeu4Kdxfec5158UEvkdKguvFNOiUROOGeAOzBeh4BzA+dYuQN7Q559khtI2qcnuGrL+CL/mhCjqtZmnV4o9jCFeI5QKNEnSYked2F9hs0UUBNu7NkHXSEpEi/shBSpi4bcjTIbnDNIPzhHDSEWQpw+pCl+760zBDj7cI79HPIeoBwBdHnZB2GMn34kvX2YJgbaBwX0MHeB/Ceqq9j5XqFXU5HWU8P01VawO6CV8zdMjOXZXIgJw/t5vXhzPUjUm94eDWMfL3vFQcWfF0d9P5lt4lzBzEto8yZPBZsXwkwIeVPfAZvY1//9p/WWzhYXQyjr3qcXinMAiQWbbJdcGZ09egW7yovf54nfC+B7823fnyPfdU7F6HHROkYN2iz0zsk606PPtx0cP0MO+qyu66o/1JuX3cT7V6r08spgvaIyVB9QGaRXVoboFWmBlWF6YS6oU9/7Q76N3CvsV4QxSBHuWQyqjarpY7wXLMrZlq67oAUd97/wg+DPoscX5QVF6s4MiV0huWSaABKdAOPGQTDWQv1s9tzSz3zQRhBo45RHw0QS/TwIMXiX8zGPoJ+lHjmM2GZrvGw/sD8umJdeEvTik/+oLvLvblNFEPnXOLraVIO6zMHgXe2YYqdDsKkq2E88/5dNFfEvNlUKcBfnSelmU1VAWU25zaaqYGd60KaqYv16nYMRbPnX63BtSLBOb7CVTg3zJNhLoT2s2kWQl5f90JXI+ImWtjAfcdESWSRjAslKBO471WeYrfIihwl3UJ60DqlQMzhSqLdOL1oDb7h/Ep/hSwnuBBbjIedHnWQEUrHaQlcct0hKVlukJcJsAva/6NMUR/03oJxi/5+aR8U9l/dh3vU8YRzfOc9feJbM858kY/8/yUyAMOqfTvb7CqN/38wAzgJQIsQacQZAjvPehUJa+W0zBr7ZBAGG7jKjICerCz74W/mQ/caYlqTb2jkL4cNNETjhmRZhpEU+mxTHDlgeZNCmfwetxiiGtVIltKHJIivx2+K/Rb7lOtvmpuHrBw6hvzCT/gI1GXYWU8khld8WGd5CDbXgEV5hRB3+5hTGFouProXRHW3Eb9c54TRYs4sGuwjtPy/7g+s3M46lkg9S8VRCYyuV1dgqgSDLSj4q2D/B6/fduHe5jIkBu+xb50Vu7NsQ9BBWNXGL96QZmrilZU3csuIb7DOOupw0fV3OaH3dPXU5d8HTGH3It8XivZup0F8WG9cZfmGl3kbAZXBWW4zKJo56u9EYA1hk+iZOscrL7vXImZkNb2vv03jYDH4sEwS5H70WTKwZYfZhEECvcyKON5xAszHW0Lj1861fbL3O3u+utmxRxhrxBM1awBPaME+zWXuOzISUKunUQca4fAVIp4h8e0izQXtanNFIAGyPOROMiUDJlj1N3A7gaVfxdXYEYCxWxkC8l32MQC3QvKatF6GC7DbFWNBNO4frj2CTVtRZFRV2eB5rTGc2WsaWNFnGVWy0jK9oskwo8bL+zh1QPi5aFs+7y6otrLOeKPzI+jiZZ/M785S2ADj+2ksNWW3+GUpe3KIXrK2F82KE2TghVWy+5MwizXztX+YdxEtOdlFFjDAD93iR73uh5iHg+Gey5/1q0TlxBu7W9yc192m/McvQMyRIIptvNJwCetP33WA3cZlMY8110ia8X1SbcZm0CY1GTNfgaAQ+X+WYnEY9k/M5hC/01ZZxyqycL/VCivk8SmexJkMbK0pnLMgsSsQ/dv8N9jGusRZPweDaE5P1u4j9EKQqclRbBitHMfg8meBZohml9V4R8GDOUzlqSKMxmfl8+xfbv9y+0dII0nyG0JQGPXl/5efb8eutbwMIluc1au15EUuMEVPf4DCdl50FOSqVaeTZD9I2HnlJ00/71RXDpy9PKXlMNekd6Bu0ml8mbZMJ51b8/whXjIGggzAXwtExb4x+CX5LIbwN4TCETzrGT/6k45PJG8aopsDzlCaI6/NnuGIohOl/CmepfGdiEKePrs1AV4hjkMVPuQ6evWyYA2lfrvlSu1ykPQlKZ6gjDTgAG9WBMrvOBrsOGZPwJBBw8gmUUHwOdiPkCs3H2jwRMs1YCfEFkKYesOPzZQ7TvK45oL1HTPMO5H+cOwT/P+cQ82fOQ5CTh73iaTS+A7+sZx98+5DbB9/qoNZWK/dBvJc9SjCVaKq0Q0VM68Amvc5+Dmm2KQWb9ysXpinVbNX2F9MkwthpHr8O8NZ6DlobSWt2CGpOWkuyVQG2+V+ur4mXqICiKktZ0VfQfrZYSolHqBbLJuIV6nVoR6ss68W4DWIces4p6fQS9RWUfzydmEZawwivnMG9dFuLN2uWar//s8qyDlJvVLZYyqHuCH3uiBZoWwVrsmWMNV2JN68KFL3ZjSK6C0UlYu4UfNtAvGO1AGW3KNpE5iIOmn3t9mDgcnoX3M91wb0ecEsIl/+Mu6yLBEqLms247wZ5HgOSLLHN6IJtA5EBYrlddpQou57YkFJBdpKiPLEOP2N7UDmTKbVt9wrrs6U2t1duLavBuwY5q/kT+C6dei068Emr8RNKT+0ota309hFTmr0tkNthSIX+5JKsQyH1B4FU5bykAFNtm9Kvr/2jEOU5vxsfPY+nAGMvwZfUGFMgfLGbPxrR0fIufLHDmGZc1ey3mIvlUx76U7DXnoPfDRDehXAIwncQRjtLJ6K3w0eYAjy356aBkknekHbVvQItb3qbWgvoRGiTC9eX2pLhiy1T+LIFvjxFzwUeEyD2ghi7zjv1Wkzg04DrWTfOq9ishcqNlmf/t9HydO1Gy+L1a21uHj3n+b6ts+3gNlr8O73lrbVdg++Kzvd1trUces2rs86A96fg+wUevfX53tfZlnG4Zo2e59CvX6lN60XvdFOvDQxsam0kHvVKbZOBVhXt83pXarvLK+w9QQ97Mvg+0uvzsFdqW+wWvO99IX5Ti2mDRVyRgD+YeOcTcIV2gb3P7cPb1HqceO8rtVHeDAZlkgPxJ0ScNz0trSrAEU3j6kOpzSp6+IuGbyluAf8p8dslTwaDpxhyGCH/nzu98ZXaot2SytN6aaXUTmVimiY9poF8Af6bJ0ptX3iE52/pJhKPeR/2NLU203gL4VLQUrWryiIbUAUaWGf72AvW0TmbNe9cFUh8ne1eeL8n2mZ9Ovp2ib/trSUlFVJ/A6m/EeRwxqWxUZlh+tCyd8nXltZQyO06TyU+01xlUQ6YDtpZZ3vdW22pOO+DLDI0tb6wbqNl6fmNlmX/g7Giq6i2YL9EH3TjwrJBzM2rEvotsU484qnLMsN7h+mQAee6g27c9dLS/UE3OpblknQ7xHTZnemCblDLJLvxm+OqJE6yrdS2ilAYpY8s2yRSGAkUNgKFlC109UD1LtafF1Zvi6AF/talYZ7X7mQnwnjhkGFgLLbJGmYJxKTyOC7axV71NmieRq/yR54g+AQ5zCa59NGHly0QcwmHXJ6BXNY0Kysj9IFEW02tfe+Sw29/fZUlAuTfL3AxtByB9nmBdOoR+8GQuPzXOvz3Y83+KInSv9Zh3ae0z1N+AjX/tY4f9s3OCfnftH14G/tQRgs9wnNerXEG/D7rwTPe+Oxl74IeJLLhW40WKLz5idAqDWVmQqqHvTON98HvQ5B6phKfvewgkvp7zSRIfRFSX+TUKxDiaUMN+4wHbWv0aAL6sjxd8sy2Jq5xRQfbx03FFdVMhF61SN9kebnkFYjvWMGzHzsOoddG6At59iHodZdCXgmepca58KvxPGzoYG+64nMe1sfnPKJPq4nPeVQfxsTlPKbH9Duhx01SNhofBprOOpGmc5o7gKatQFNaDZ0KKfMx3euANw3w4dniQdBbYfqjTrRHLmjCIf3yT6hjlPgn7EtxTPGtp/nGeL9eDVecAntlyJVwxSQIrn7PTBkYUDLp3VVzJv9UXjb5Xoh7BYKvHeU+XxB94d0ZuG536fJd0VNwDc5njyzcF5efB5ytc+GaYCKzACSSV5IPElkLknoVYl+5Nykv1/bavbV50BOWWPMaIfWzrrxawXJ8wgo9a6flWACcbXAPskQqC0g/PJNI4g/NceAsVNQlyjjPiC2tESy5Y8qnScoJJOUVzRFI6WoQUuYRDSx0I8RSopUyTtBKIVjpdRCHkAMJZKtmP0D+2oCW/74SwRJCiO0AMREgZrlbLGnQ603scaZZesaieRNgx33SYhkNKSYVxZHzNfNiuqbCtWyrZgekS4B0d0G6yaT/rOiR6m/NJkgVDqnGQKopJNW5HqlsmjWQim+QEUqRQso9kVA8WaSYc/0TxfSZDs275n+nlj5zQ/O++d8opc/c1BjN/0YlfYbV1JKRQxHofBmMvUZBPSoqeXnrK1uXb61hj7lGGbFmjSpJ3ZqylYfxxCFIt9B50TILcBYVXbTMLGyyHCL2SJPl40Jh5CJgP7y1YavsTG5H8RKs5y83tFheJpxc6cGJ7Ex6Ox02BVIVQKpXOiVREeP7ntuxYslY+D4Xvi/v/H4u5ha8NGwUfNcSaWP5DXc2EsobS3Ac+eVWDzuV8DJqq8DJMA5T8cTy7ppqJOikCHg71OtZ+8CwHWbko8ryMeHlZA9eNEDrG0t2gI1TeUWwbb6GX+6KML4YYg5XZEFYAGEFhHRj3pRpL96YXA3PRyGch+CAgFKoshwmNHTXKtIRFPaiGSVRZWkgac71SJPbsWbJ82afNNY7qmCU12jcBWO8iYbPCacNzolk9GGH0jgKSuN+4HzUbRyjXPuElYFcdx1usaQQjq/2or3cjpIlayHVOkiV2ov20tv7hq2A7y8dlor0ZDqwBnSV+7MiNTUiNU/0oAZ52rjkY7NAie/LvC65DAgrgFyYXqlA6NIlR8gulWpLnjJ16yigIGXrKMh7vAtpcnDdy0KiswXqZm9lAXkuX5ILuYVAbpP+pTwgXXFhWVov6zzWAvX0n7SKGDcvmYgzzZBuyj9qFvElhKVCuu+PoXa97APHJJU7sl7r+LFWaFPnQr+Ivurooo2WBz/BG8EfNjxhNUL9nFt0645wfJ9XVMN+64A4IZURY1ECj8K3hz/ZaHnkkw52r+OQMc/Qzja6cEw+17gQdHOYr7ZEQAtfBM8fwHO4skiId1OJr3W01n5FZsxXHqOO+cp3f+jPhkGYBuGBq4JfkkL4XQPhHQifQ/ht5OMZWF/+ANsf99NR9mU0Fdv7TtWdGe0m0Zd/7nd10r1+jJqhy2MO8OxlHk/qneeHMmOZ0fs87GonzrX+xCdCbDN/0bKmUGNcy3zKULF11v8U4k3RiUwcM8vid9vqw4Nn74t5nPEbPqc5YvTZzrW8E+TbKy1bMrKblS7ZjZj9/m1+wUH21YFKl+SmvM0/oHYa7tn8FcJ+6C9/zWol69VB9quBFKSk/iWFOkAKKQZOu3vajxxV9ytHld3DyY7sz2I4WeUN0zuUtG1lAJUwMiqApEJ4TIdzohGjF474Fp5tpltcCJQOPUupc8lsNZ3iN0xlj1TR9khaYY9QvIE0qUbvi4hPxN0WLnoMFVuCnmv8U5plLsnszeLOU9+qYQrTSFYN6bSl5sh4uX2hP6Qa7d+20l/FfJTxXfMZCzUvDHL/CvqYN5krzFfwjCuF3mv0vJ1kjfDdohNZRsJrRFrE6D/MfiNH4Xw51WiSjX4864iJ0txzALShGm0oiqTiqbi3M2YDjs5VwmCVuEr4a5dVQr8uq4R+I9OYPfZIcZUwgqwSRgz9yUTFj669EvkEWSVcazvgxlXCpQc+zrgJdCwcbjPFMqON9I4NbApHqwvIOqFQ9jb8H2WPipXkZeStzPsiT5K/eDqWw303piwPZqiyFwx3MPRmD5vnWBZLaV4wVLL1bqoCuI2TgAZybZHBQTeuLaOqpW0KCvdDqaAsBrskL3WIO37pFP9hwjlt2ZgnstLJafbI1GVJqLvfTBVgP+zn0xh/+zKqogYlpgHMIJ2RdOosKCtQEsr8k26aItNWgz5lkr9B008FzoU6MMe7EG9XZyrZRW48NR4RrDZK2wIl0jY6oMKApw2OCyfGlbdOjPvfdmIcdxz/ZYpIXZiksEcqLgLm5gC8JTnRi+fYtQxdEWQvVknaFLSiLVBKtSkkx6fd8pi0pmhB1mVSArAEHrYvDLliymZmYxvCoa8AP6/EOBt++3ppsPYyGAlILsL9Ap6P5l8wpjLIayTISuWSDKRTZnKy9cBrsf8w4DX17QzaLqP/JtIZxFOaZbEVAH3DRe0U74MPrthbXaNok0mBuoAXiOehDYLcb3HbKfecrMxObgVal4Wg9C+Y0gx4D1QGyCkN8H/lEuQIclAE2RXKcSBPhQTP389kUJ7vCPIMxBwqiTz9epXnsiSZPUJ2Hqj3sLs9EfGRoCekf6uropaKTYxCaqG+rahljEwDPNsB34pOjwf+xOPBNdMLeyuMp3ZAK+fBfRoHvLgy+mTBgrzagrfz2gp+z0taFJeP8nnLW7EvQsxhoavakEQki3m8YCTS3Y/4dxOJ+IkSWUXOgSntMuVfptmGNnY5WICTio6gNiHtLyIt31TONuDJJA9b7CmDHGZDDqkwvohUUXH+baqA2fugnM5MYbDUnwDZqFz0MG9nWfPJRpaiE0s9neqfhPK/bMI2/X6CUw3lN4DIHbBWXIpEXCMFXCNv+ujuLLeylE8yfDWoLMnPHun3B5FysoeKxd1FFca3I8OmvR6J3GN7VUW8OrCmyJSyYTZThfHrHevZBC+lDoK6TVb9yH5F29R9N9TL5QyOGgM9a4GqB4HTz4iveI1h7pbHtvxny3+3LN3y8haerXBrIJXePd7gZh/gl0LaCZDW4By/ZeoW7ZbcLfdviZ0RctpvX8hXQfaJCmFHgp9RCTBr3a/sSwe+t7qx7/rJLYOy0NRK3yvbrKzV1Iw3NkHpnwv6/NwTcrpvl5XavntDTg/YH3JCWKlVKdFfwgAjYqI8MkbbkNuxe4lc6wYdqpkg4AP9UgmrsDfNP4vrpx/8Fq4Q/YeSuxD+JH61rrMVHhr4KHLjblOJfleOVC/sVK7I8YPgD0Gur7gn17YyU6HfmROgD/lWiev034YcT4XS2GcvrqkojWpmI4wzf2avwuiwvCjInqiIZbh/9KW1Tpvb8b8lbjbBSQ1OZh737YNZlbRoT5bPl9YKkGEM8BxyOuREXEFqXowxwfAzexjwv6KcyiDNMz3+TGLDS4DrW8DFO34xJ8E48nkl7hhKMGKKKR4YZdant1eFLdGeFH0I4E6pdMbNrgfrp1CZYMTnJMCE5wealxRof+mWbpPrY/HJAPbBmVc+vRpCjQS68DfkxAWOSk7NG2l8CGgrBNrmAG0PQc4SgjG9/d2w+7R1IkYfnhddSpJ+NqTPFtP/5RYoOLMkW7tDTD+VSYAvXzurLelK4fknMdWPS6ZqX4dUshtXlmLKkNNjRElhaUvNCzmd3kVySmM25DaAy4a22M0ucR4DOrKNmKsRcA9VPkTijSLuX5ckaR8QKZDEjmOy4dtqVzqk/4l18Ljv+CEjxpW7BQ6Pham1UzrTUxr89pTL9zTbNYZAXuBxp5cAuRQgtUdyO35bEq6NNfv2FuO+Yoq6lB5J9t6HTsWxVehf4YqJ4r6MVHjOgDAbwnwIb0B4C8IHEL6B0A5h+KIFMUn5hDpXMpnTbSTn/zbaYlyCR1/03rTRJveObQjtnEXbaGvzYCn5Mkyp/eiKNG14/mzDX+wNPmnRRsvsEuTrIXiP5vF/f/69K4J/lOi2cIVvD3XXerWu7qJlXQnuh/yLpXisHRLDRgtV0gT14y+W9VaRlQmqCM8GmK0FRXg+oOsZyI22E84XCG04x7rRVu8Z2/Bs597xjbatnpn1S7Tp7f/VuNnXOUod0Fl7hLGCDKg87m2xyLpgrHLO74JxLWB8tAvGpzy4pz1mySPas+aERS1ggz1JRihx+QL0q87ZXaAXAfQ9XaDvJrJborlHe8gsGZ2Qf/fdSQXn5X5nFjEztH+xs710XFJe9j0/kpPJXbm81zmpi0YmA9ZxXTQSS7C+oJmoXQ80/Qgyu52mNOeILtCDAHpoF2gpgX5RM0L7FNA0iknI9wepqLzoFX2M9VSJDSgR8IQ6B3ThzeUe29C/C28XyT79Ik2MVkskI+9Ghd2h6gJ9AaAVXaAbCfTLMHIaapaBZGh1opk61nXffeTv4YoUCFoIu+ZS6j0QHoXnFyGUQXgPwu1WKRkfZT49Q9j/HHLaSLzs3MetJbXeb79Q4xcx2NvMciihJuz0XLQsLMK1rFu1Yavj4S50FwPdc7vQvdA9t34utKr9l7jY+3gqXs0M7dJCh+zFGuFnxP5b7bhoyS1S1g5hYtGDaSHuktmVIVgO0LZ1jrGFXOc5JnfRWRbkOr6LzoYSaT0KGv+y09uLmx3viduPJ8yT8QR8Cc8u41OZiBr2mrA3fru4I+YjBlvjIUzISWiPL52E8A6JiTgQchJbOIxRMxFGDxvulUGfkQD1J1/jYv/0lkFecbmkDf0uCvq1CdCnRRkHEgsW9++k8wP3jiEe+zbanBzeurTW5nThOY+Ntgz3exnT4cvfJtzROorI/LJ4Ei1qSbD2W5GPR8k5DJ/esT9+bZYl/dXLwpiZoiSZNZeFNu5/8Lsa+unzl2/pXVkgydMVZOSVFKzMQ/3bDu6sw11CRvacgxqMfmylBmo7vU2yzciaHNIa3AUm3Sbb7rfNzd7p7Wswsicc1Za7lH239TX6G/pt67/dzTa5hb226zSjtC52vlfNRNXZxL22iKEvlJswL6Z3sxuciOMdB57u64qjFnCEAo71mgsin/7GAIOdfcIVYFTB7wLoX6OU+OwGe0dG+opSTT/tCXM/XdIi+TdE5rWrrsqpKOL5aQ2P+Sx2oPXRVx+c00+P5/uCcvrr+xrDAcdzIo5yTYD2HTHHt0SfoZ9CPTkHYcdvvnNbjelXf/ftq5Ix6+soe7wftsUacoZyFk8b2qFPoo1roS+UA/axvNwoA6oVLplRDr8yl7wyLk9RuSAvoPLtPFXa3ozfTIHibithT5BsvQH0MAgsKAc3CCBuOgcBBhc70EsDHyrH+BxaPz5HoqeNeGIuCNLZuNyOoqWymiBjP8jxsrOfcRCk9/cKcP299ESbCdc+qi13lqgG11kLKmS1/i7ZKDznxnkHAcWr+LHWRiWdVgf/pcPHQlqLKdIaqtxg28vjOp1GW21Rl+xgo5wy4rOCilcNvoXjR4Ijnx9nTe8VRwnBEabdwTqgXuOtRU+QXfQBZ4KhvvwI9eVuD6VOJCfLFoulhVbf7OZHFEt0TGu4om+rOD/aersfpnK21NPTD9Muj+CHaeRKwQ9TOfuyp3c/TOXs056efngGOgU/TP1XCn6YytmHPL37YSpn7+kB72ZPuwU/TNRKwQ9TOTvB07sfpnJ2ZC/0F3KCH6ZW0Q9TOTvA07sfpnI2uBf4Cofgh+l70Q9TOety9+6HqZy1unvyH+EU/DAdWSH4YSpnz7t798NUzn7r7sn/BYfgh+mdFYIfpnL2iLt3P0zl7P4e8C72BC/4Ydq4QvDDVM5Wunv3wwT67wX+klfww/TCCsEPE+jf3bsfJtC/u6f8Sh2CH6bHVgh+mED/7t79MIH+3b35YdK3Cf6F3oTffRAaIHwD4ScIFggeCH3QZwiEO6/5/DC52cec75Kck1a8o3uH5DywW857dLuz95Ccw3qhPMq5k8BHrNii20Lgva7b4ct0peRW33LW7uqpedYl3OrrKV6tW03gf3V1v9X31eyVBN7UC/zbzpdF+KW6pQT+M1f3W32fzn6OwNf3Av+x+ykCf6V4oW4hgd/t6n6r76PZCwl8uatnyXvQ+QiB/674Pt19BP5VV/dbfe/JnkPgl/SS/zjPPQT+cPE03TQC/6jrnzxhTYOyjXjudglepZr/TNeNITHTxBjznxN0qSRmghjj/XMM8ZZVzqaIMX2vpOiGkZihYszwKyOJt6xyVi3GZF4ZqtOQmP5izLwrCcRbFtR/MWbJFbUuksT4iTFrr8QQb1nlrNspxFRfQU95GHNdjPnhSh/iLauc/UuM+etKMJRtjPlNjKGhTcYy6vOXhWV8KrzPhPAwhEUQXoCw4ZpwP20YuT24nP28Ez5IF0RiDosxkWYFuT24nD0gxtxplulkJOY9MYYxPyvmR6kj815qkA8L+lmhRQ84VEFknr+WWqaulw6jTX666DwFs3g6njlaPH0v2LwGCHjONPQgFeufI8+WMY2tdGxjqzQ2nYuYsNy2SvBMdGyiPVxx44BcMfZgorqCzQdbTlHPs3/wt3vtCiG+BcvZeUAXtgZI433OtwtUIgf3OOMWKUWJabvcJuivo7N/N//bXblf12n3VjDTuI59lD3Cr4XTrqjiZo6S6+VMItPUqtAst03jYxnFzkRmuW0Pf9hOhUQ147OeT88Ka05v79/HT78gp6lVugr/09L5OZR+fs4C3QJCr8SZc0mYtZHEqfSJjDpuH5eYvNwWzatqlEbE8wIvr7y3Hp8KeVUlpb9fNycbPbuWs384VLueAvs5AXLIyZHpZ+VQCZBD5kzIQbo1N+e0WcCMsO3ewUzQlvuyZnx/b0VNm0xakZF4LJrxb5ME6JkAOy25MizwlytxlD5TF1A5iVB20EGps8mqg6IyKiq4dkfUPKaEXenW1krbAiS5Nkoq4a5O1NYEGzO4a1WYh4YP2l2fFdz8dH1wrbHNn05hoqZFMhXsIw5tbUWUD0Je+fA0KqmhuYmj9sQxiWKNedVRZ5ZXZhI+b3rjsD8gPD7rQInSJlp92IzfrnrTs7jmoEpSZ7YAtwuk6uBaqP8O/PoLfFU153bUPeen9ycy9ycy9wOJhOZME+Xxs3m8JVyxEMJzEGIg1Lwu6H8NPP86MlxxEn4PQvgewp3WcEUOhEIIn1pJmZgexOy7Qf9XZlzBbIZSkNtBzd/BvGo7zckMFezjDjmDNMubm1qpmbJa9CeHnAQ5/OOBFi3yPYHBXeE45/6t15+Z2RDHBOjkROpOGIEEAW70cUSnTR3+pwltrctWgT7/v8HWjVPE0tk8e+QYdUxmwXc/8v4hvC8j32XkvRbeN5N3f/L+Nrzv6wJfCe+n/hZ87g/PGaEbkf1WnZzI/DCXqK1iv3T4MY31eLs2NXg9W+Dxz8MzRyOdMuZww3o2zyMtoJLGNGt0g4T2n8OvLzr8Lt2hG0BitnLDGTUTS25VkS6jky6YMpeNTPqluTgWZ/Iq2FDHnXH5Mc/HygwbuZDkjdzqvArW30HFRTO0ET115/Ayhkr83ETXYr1FjE9xP5rJ+SgHHW8yJwHtY/4W5FJjgHYOnvP/vnU2kIp7v04RezC7GHAlkBuHKVtdsdLwmO0FV13ORUt9ERU7kAnem9uR/2KQXasEO31xkH1uYG6HM78OrOB4LnzxMC6cSuLCQ+kUxTAcdXaY3sml4yYsVtgjpAONkYy/frmtxa2sHbfMTz+wNsheoGhqlXxIxUmYFUwTF1ociadQdI/ZslxHuafVR7nJofLtOPYNP7Azq0+zNCmwOZnrc2kM16fxSlbA96XQ50vUZSzHz7tUkkE3b9DdNNOprVAv3rBQJdSQNyx0yRsWCQQpBBkEPwj+EOQlgxaXsi+48IbfyYziwFimlN3oXq6j4tZnKI6tzJj/gyJ2oNF/x3LbG255ZdQyZW1Tq2zVwFqpvl+tRB8Ob1Qm0kzF0erHbOiLgAoEbpS/ZKU2I64n3FTcjPbcFAFb+A/juQHJadwAtT5D1Uxtzs9eoJMC3buIt4UhnSccEVJ3G6Tf9wCpBsjkigzJD4F2OrDJPEc3C7S7ypzRHrq4gp3vpO9Sxh5ytV+XuPosoJJ2mN5i73HNSN7BLnZuNl+05JQ8Y5PJQV8BcmtZ0eScw1Yz6HHe4K7agy/DcCUcNJj3onVI0VDQIs4cdNXkNdPA/aMYlIgHRn2ouahl1BZlrYTx00MtrVwJmpMW0Goq7jHbf4g8Uph+xptWqjCdOZc1t3kU8DCOG9CIsx9vt6mkkOd43LGL+cIorvB965pCt/UEzoKMH+RcxSVDekObVEolHT72UIYkKbrlLRgNDoa2NEdK2VfLUrnkiVB2VmHMeum9nFq1wfYpN4+cYgohd4DyzmDdIjPK7DMz1nvsQ3EMhv3on2I94OB30wcKarQtXPEIBKr4yLQX4bcKAj3G/87XOhYeKAUZDz7wROtA+iJXtgI4C0A9veBal6U4VpyV1FlSlriEkoIlu2s5AVkFYglfiSW8LpJ5zPYj1NqKrIDmCVyf0DSuj7ocyu50XR8ou9dFrb7oOG0uZQc7sXwqDKXsFFd6Z9nkO/7cL+RZbZlYstw2ujPf6FqZ/p/K6C7HBww1pCHr3uZ+teE1qVz/5BSuv/oT0EZlNGipaAjelQyyR33YrNpCs3VIocLgtl7p1EgpnvPvpEL5Q3RtGmBATBUZU25+tH9HFt9Rvx+pvers35ku4PvoWkhTZ8CVUVGX9AV6TIMZNbeGaG697SIP1K7HkbVSOw7vnXOqRUm0c69Ce/4p6OPiqVAK9TPoTTmlhoB6OjYkgMJxc5munFj/ZWx7L+Ner1uw/r8tXqdbk40176Knu/W/InsVgf++F/gr7lcI/MfFL+leJPDHPN2t/yXZSwn8B73Af+v+L4HfU7xI9wSBr/Z0t/7zsx8n8Jt7gT/kfpTAryt+UPcAgX/N0936n5V9P4F/thf43e5cgH/WpNNNJ9B53aCn6qZmawn0vb1Ar3FPBeiHTeN1Ywn01G7Qo3Qp2eMIdFov0M3uFIBmTEm6RAId6/mnccdQ4jm3jA3zCJZysjkBekaMUYgx081q4jm3jOXdQsyj5hhilZexN8WY5839iQ/aMtYixqw39yE2bRn7hxjzpjmYeM4tg/G/EPMxlDHfGPecTRgT/Am/7dgmgD0dDGEghGF2YSwAZS5Hxgh2d5vjlt2NZZFnbWCJV7B7OMHnLvav79fJDsjtofQX2l1srSu5/nPdF0QalW46Pva3Roh9xyP0uPuLE5ldbB8v9uUOEz4/7mnQHYIWrYxd7aY1yriTrZI+B7WIbRf7uktu1/oXE8i3inM7zj87WLMfsI3i9uuM2bg7qIxd5P6pVRJXm50M9aqeo2LDwAKrZI/yycxO9n33KCYj5t17MB+3C/8nu0O+lduHy0KOb7sqp1ZDkNsTAz4pqMquytmtpYadOhbIRDMPcrJB29llXIV2O/s89xbbl5uRvJ1dyO1iQ91vscHcanh7BN4C3DPaZybvZEN4anCZ9iQna8Z49MMosSulM1NibXLJvjZJUJA9VxZvmyKjYisyGoETJjXOJpfua5PiF2mcbYp0sGaFdkJeJXuchx7ryWImbRpg2aNhZhNfprtdK7Mo23qon08Ruf7telvu15zKvKArIO9m10+Qt9a8MPs50vNedKH8FoKk/nDi3q2JB/Lh2d81xpypeVRbyZbz6bGjGD/AfJajEu9vAYlIT3LDi+V2hYTSL8iW21XSZGalrYE/UpCbTScdP0bHHclzFSjhSRnnylPG0nHQK6ZIt7kKKP2Rggd0WNrecX1SQA07fkxi51OP5B0u+LkBviZFttATXHk19bm6SdlQ/11vsk/zM5K3gYZ2sYvg7Ql+Nbwdgrf5rmk31Xk72QKvu4Aa/lpHnwOoyeneFKDd4FQzG8YcZdCOWMNpiz8wS+yB9Jv30SlzzEfQ8mxBOU11HYH+8LWO/AMYJ2lJ1W5jt/LD4P9m/k02heS7AnIaAfkmkXyL4G2wa5h2JzvCmw65hXppzSCQEIV6KFgF8h9XMBcxcyuzHgfrVkXkfaeLMccA1icAq5xgvR/wSAArRbDm8ofNc/uHKy6fFOpc8jfhiokQnsc61B6uGAlhJjw/A+EpCBPg/SkI/b8NVzx6KlyxC4IRwpMAsxW+vwPhOwiDboQp0oOk1G/wbXyB6eHLD5dnyJuTdNS2JGIp/u4cptsH/WxF1t/krrxq0xCQnRJsdNwf9JYnrR4lutsTq6swU3FtZrCtRmLJea1jz365fZp0Z9ZrHS/tf5Ot8iJP17y72B3ON9ltXuTpT3grdwoa2u5BPEWeMF1QdjrUwfch1SoC8z2kehXeXiEw/4O3F51CHVnuwZQLnZZTgkwivxZ4jQYeG4D3MQcTtaVgA+Xe5J/bkSFj/EwJugTC1TJn8KVSaLsV9bG6G2b0Y8k7pUx6vVp3B/le4KTj1Yy0LvmoZF+ujU/N4mST0I9kKVvvVtT3150398+hKyrACumnO2vOtb2bOhT3FepL2d/he7juf2YhdYUb5xJCdF+a6coP7e9OoZuDdEfNQToZyWW087T5nZAwxdl2gX4r/NLXwxVDINyT/ymVBb+PQlgOYTeEL6/7/JPvZJVeoa1cfHBtnR+jYOTGfpDffMhvR/3gOD99HxybSvvkSOCJ0lPx4Tn0Fqk6HNr+MtYB7a+iDufa58UMy5dXbMsIbB4SJ45n4wJxPLtACVDKnD/NEjIbbzbf0xGueGCpMHZN6rg1nr1zVLji4Zf6KJZ3oLwl+2QMyOqO4hLk/hH3UOZSSSn7IPyq15eyc+A3D35nuemKN0uIv2Y+tJ5Wo5zpit9IzHaeSrxhois06/GtDN6s8JZP3tbxrebkg37Muro40OtNh6DXYNPUOIl+UA4NgdIP0qlz1KRGveHAVWyfrxe5sZT9wbW2ngE+I4hsIkE2kUQ2oMst/WG0j1BPOn43++QiG6Zqng7pFUQuoZBeFkfrQwAmJOeKKJkm6Acngw5RPpeuC/7g8c4jlE13eaGsiqG+sdeFfi9Fw7OP86XsY25FrCCPSL6sITRWkEQ4n9cgiRXkoOKTG1AGstijV0PTeVZ2jFaHHu1zMEWDvWcmLzGE5aRDGaU1pewEd4qIze5F6UrQI7aI86oXpevD+psXpSuLFaR7ztsKvBwBXnx4+/N9dJuvSqknmVXwX6KJBJ2qOrF/0QN7A8GeImL/4DbstYD9Z+Dbh7vV2xU3TXD/6vLh3tID9/rbKF99G+7l3XAf8XaVx4edWBd1Yk0RsebdhvXB27DOJvKI7RB09bLulexXiM02j+tps33kfZ7Ym/uKl+qeJeVoerd7E56EfvZpAj++F3jO+wSB31a8UDefwA/pBv+Q7uHsxwh8dC/wTu9cgH/NNEc3m0ArukHP0M3IngXQm1gX3xNazusAepEpS5cJ0JvYVv526InQz2YQ6Au9QPfj8caIe0136VIJ9DfdoHHeJ41AH+0FOoEfAdCTTIN18QS6lv8nazee2Lab2ApesEBnmQcR23YT2B5CTIF5ALFtN7FrxZhXzf2IbbuJfU2M2WIOJ7btJvYFMaYG2mM/EvNfMaaxi21r7BBs24/g9ygEE4Q/IUhvCHbt2IMx6p3sdJeMaa5X50jzbt37gP1GY6tfaox2I7Rze1YOgN9d/KWV0fC7g1evioLfLXzeqttnmSN0fYkchgAtfURuNCCTMDJfv4kdwMctCiGzz5vYvvytWeZAnZzcDREPdGEdroMwBgK2Tf809zz24EDA84htnOeObBlDw1Ma2NSyenVDNFgisS5aPfboIzZ/6GkesZV78H8p+b+e/F/rCYNUIS583sYnwn+PJxhi/F34vJFXwTMFOB61Pc9hmrkejJ/jodQ/AJ1jgc5MCDMhPAXhdQi7bwhzawu1xrpSttAt1RQz88FyWuD0Hyg5lw/4fnbmwf+zTllNxk0/DXqzO+zA091PNGP9kIBM1nufuSSzz6SD7MGSqR2JszDNew4qUXpOA1b8NvZjJ50mq3w749rPs+6+yD1cfpEb+2ZIkx/xVxNC+e1bDf+peExB/6IYPtmk1TEE72Ne9OofZNgBI2EqVrazD7Mz436TpD6oPAhoCSa0POvoVzOVGQ19U7x7Atp/jiB7EJ0OLdtgdxUXlEwlzW3GFMMhRR+3bBcVuwUsCMWwsSaEdnN36pJIXkO94ZdkzIi7a8xzuPg6mT2Znsf4eEl3pNfj758clK8xY3EPDfrGYJo4qk7HzGIQPsBLp1WZg2okbZmSOVwcVVZMp9Kx75mhIzJRw95rDtK/Y+5XK23LkM7hYqnz66OiqaGHj2VnKIf6t1BloVA/EMsVzzdmOmUf1I5ZoK+fJ0Qohp4IU/wBOpLeDFdoIoQydRzeC+F9zxs0dRR+x0MowncIc24SfeZM19aBPle6VPuGMTQjYzKBf70rEyS0iwuyh9Bof211pevSSamu8UzRTSZP73qquBCQWkFzC5derLCHSGZTA+MGGvUZiSY6joq9yB0vG3WPbMtGLjJZsXkjl5hMDTkVK9HIDCAf0DnXUsVFUaFQR+5sHsZoGC3k84ArdGeQfRtFxZZnBJjWZg1tpsozmXhd30tX582dLUltNvuBXOo46tL59W+3Bas+tVMhh4+dtlPwFBES3BKtA0lf6kfq6BwPUj7YhStOyaiH9WpOMoFOMZk3sr9xeAJ6ZXR+m1RanaE4ti2j/nuVTkHgxnkum5XQ5uBzqueiGWWL8vvjpiDTUBbaFlaQ4y5WkGXzQY12Q10ElOD7HW+yN8noMRLqFa2pZH/gZAP9z2Gd1TqQFlVd89Gp7WuTd7DXeJlRHYs7oZVOdSLNSJuxzo52tJkVO0psR73+jHJHCFNiO+xtapXQARD3oTeFzAhOYBSQUu2Qw/87HDg638tTapP5Ow7GIBA0Dmg/IDznQNpStJsJbQqgzcCh1f4NL9D2OqEtCbA4scQmh3fSthtoG0to+9QxltAWC6nMnEDbM520FXbS9ngnbVFavHeoyhKgrLIoilosSuKlFH2Uon/SN2wnnDesVKe/HP8zNqui882vRakLJCX8efdBcwBg2schfxOBvwPm/zrDFa9B+AzCGQhOp6CTQBfyead2G+FzC/cmm8YJozSBzzDCZyJge4Pw2a+Tz2HAp5bwqXVoCZ+DINVzwKcSeHJ5/BkV4fOmB/kMhDi7x8dnP0j5KPAZCHwqiY/m2/mc7RQ80vs4U0HPgJwp3J+aAwE2nXD2nZdSH4I6vAt0dQDC3xD8gS/cV5Mi8jfNifxNFvmL5/awx8ko9IoX+atg3+SRvzGAs18nf2naHWBr+bj7hRO4S4Y0Mu4a4W5DJ3drOrlb2cndYO1W9m8eObtuDS60WU92nqoKu4A8485CX4ziAnJfZzUXfmS9InjNaemviyTclrsOmrvp39F+m/7bu+ifbgnUXQbpbGXryaxTOkhnu/ko1DMTK7Rj8VC+J0Eo5ATZbIbfdzlhHcufCdOGzbjIaYtDmK0wPtnDJhM5zfZSCfdxqgFhDehd37YiHb6ugK8a8jXTe1+rJG4ck8xAPz/tL9DFk1CeTqko9WqXgFeqKambqK1gLV6/gfJzE4C6+WSPpJKsbkkOqGPHgYyHcOpEGePfnAbfZ0OfW8H+5rlmHgVvOTxN+kSMG+mF0fmHaHehdCSuv8z+pEeUkB4RU9zhlQ2UnRtFNDCSP2cew/VLPspJ1KMYpDuBp++C8WrG7z9TsRn/H2NvAtXUtTWO35sECJMCQWVSM6AiQY2CilNF0GtyLziPRS2KVZwqCioGmRUBh0aCyFBa276vFWdK21dqLbb1vde+1r7EoXWs9LUQrYVeFb03ZLi/fU4C9X3f/631Z63NPjn7THefvc/ZZ34uxWlK0A7HpnD6usWTus/nFHZZRNRcd2rPHWiUO4D+u2UASMQHjmBIVSwkPLm7IPG5BsdudwSAn9U5t/vnNYnPx2K/OxCrwdLbp1Ta/rNfQf3IF+B3FyCBSSZYwP72IOnHNmS3BCu8tT4pRzmT8ziXiWcJKh3ohFoNl+VAr+9KILcvnej90Wi7q06n2dH9a0mKN85rgMuT4fs9bo+GUOcgVASMhSWNxWy5FfF+JDUS/N91ItkY56DaAhrlVDGbC7THd+Z2D5wvOVHG5cJIwRNCyiHkYSfow3iLpZe2BWiP70hOohMoxexaiCe+PQjC6Z03LAFu3+Xg230niA7ImJ8RpCdPib9aOywskxjurUSvMNSj28Civm6dEEJOe2ZG5eiyj4X2+Ci3zBlDvWf53BEo3fhZkPQAwF8BfgFYCt+XZkdjcFLho/VNRnfheVCk0v+xF4m47SM08F4BcqjdCcCzHxyIZ7y9y7Ib4sz7USYt+EikCAPOnHEgzoRCXkrggAQ4M4geNAeVcxAtgnISqlDK/7EncZz7wEYoLlo9iRL2nGPIMKnS/5GIRGXfZtVALmLI5V2cy9/spLyGO2Qnp/2Ov6XMHkOZcb6lANvsrjmqULMXXvdOUpSenwPl2OBA7U0KlOMnB7r1F61WJylooKxwnH9MSKW3UVpr7BSEuOJIoCq4350zmeUZIRkbKfGXC3lp/+UZklPiL6HEw+Z26/WN1BhqNCVVbgA7t54bav2zvKGY16NCemmBQJM0opk7P0wpmtlLkbhjoTsy10Atk/c8Zz6z9FKf8SgeKtUiTPOa+dzy6WPS57L5Pn/w+J8xZzldddsbehr+PT3kXCJpnjNLZEJxLGZSXsc9tSE6a0OxOm0jKX/41qUOHeUHeKFjEoXasLmOsZQP0n8HEbkR2pVXQBaQbCAZuQ+8/ZdbLghHkDQQQAmA5vvQfm8y6rvW5IyI5CRF+XmU0zm7xxAF5Xk7BNJTgbXujW8WH6i9z6cZjnJhjoPcTjsx3Iua/USzbBylo8gTRzmFg5wgoshGNHuXzVOznpgPcul2FXUp3FsHfN9usD154gXp2exICitsxLCrlh9eC5TGQjmWAJzf5kvsBLzR0Tu3VcO94X57j/uoH1iLg6h8dgmPZubz2S7+o0Q/8yeJ/dHOBy8vWkWJ5V661zkDT8jF59mL4LsE/OinFrSDtM7hakuuAf6/7/hB/+9+x08ZKvuPeZv4jyrpSp0HVakVYMyKdnYf0Y5QoJe9UYui3lBBH9Ad0qJZJYE7I6D9ylGKCm2XRb0B7ZUrd1OOY8pIRan2Z6Dk0fm6vW6KEVOiFUXa60DZpSt0+SsFrhRT1Io8fK5oj9sf2pexaI86osUocrQtKBamEcqtrEAK3EZMG6XI0p4C2nagQZxx6tWBMMJegWmjFa9pG4C25T/SnINpYxQbtK8DLQNogtIVawamaBRrtcVAWYtjoTQF4EMspo1VvKLNBtorulfcZRG44ZgyTrFCux4oy3SpfZRQTIlVLNW+DJTJ9GTdEjc3/DAlTrFQmwIUhl6gW+CmCE5EGa+Yq00Ayiya0c1xU55gygQFo40FCg0Uxk1px5SJCq0Wve4aDyOJ2W7KTUyJV8zUhgIliZ6pm+mmfIspkxQztH5AUdNjdQluyueYMhndKNOh3oDmQaa5KU2YMkUxWfsEKEPoSN0kN+UveCXqNfNUxXjtrx2CWEQK6aN8/ZxB0giAdICdAJcAbgGMFIKkUwFKAQ4BfAtwEyCCkEljALIADgLcBfgDYBIpk1IAFQANAASkbwH8BCBOJJNqAfwhXSNgAvK9BZgHmCOWSV8DuAThL4H/38B9E0ApkUlnAiSAfwL4N4C7GYDwkEkVAIXgXwj+u8F9GOA2QBeAekM1Xa075v7maMyNaYoq7SbghpGu0lW5KYMx5SXFEe0qoByiDdi/EKQoAFOmKw5p5wOlmD7okhWgiDElQVGmnQmUMrqsT6eQpRHQMgN0aiJQ0N7rUjflIaYkKkq00UApoAt0xW7KXUxJUhRoBwMlX1fgluXC7QL3PabNVORq+wNtu06PaZeU6KwkosxS7NSKgLJZt6OP8iGmUIrt2mft6g3bdNv7ZPx9TJkNmvYAKJt0W/oodZiiVWzU3gHKBnqlboO7dIcwRadYp/0eKOvAl3BrYCGm0Io12i+AsvoFShamMIqV2g+BsvIFyjpMSVYs174PlGUvUJZjSopikbYOKIteoCRjyhzFPO0hoMx9gTIdU+aClhUChXmBMg5T5ilma7OAItNRfV86DFPmKxK164CC9nvOcH9pCKYsULykXQ4UT7cmoTi+DqQxO8wLFZO0TDvRimQaye4kT5l0uWefDBLnwf0VgL+XTDoEYB3ATgCBIEhB5EleBPc/AS7B70vwu58UwgG8CrATgAC/zwHfAlB7y6QTAHIAigEIH0/yK8A3ASJ9QCcACC8pUQ/4QwCJr0zaH2A+QAbAxwBXAF7zk0nDAbYAlANE+IOuIj/AkQBrAbYBfATwLUBIP5l0ZD+kP706gjhQgU+9LAIt+fZX0BKdoY+ShymLFQe1nwNlP/Q8B938zMSUJYpybRNQCul9uv1uSjqmLFXs1f4FKHroeUrclCWYskxRqD0GlCzQkgI3RYcpyxV7tBVA2UJv0+W6KVMx5WXod/KAso7ertvppozBlFTodTKBkkZvcuuCwCkxZYViqzYdKMvpVW5dELgBmLISNGEJUDbqNr6gjV6Ytgp0QQu0dN2rL9CsNkR7RbFaOxloK3RpL9AeYVoa9DoxQFvs7nVctHuYthr6nSFAm+PudRBnTZiyBvqdQKDMdvc6iPIVpqQr5mglQJmhS+mjfGxDp4XWgh0qcNwF6Md02j7aCUx7VTELaA+BNpMe19fD1GHaOuhhBO4O0BLcPQyKdxDT1uNby64AbZJuSh8tH9MyFOhGo1agjdNN6KNl2pDWZJg34Dexzl9w6c02kK0DAHcBngEQ3hJyVn+ZdD3AJYBfAKYFyKRpAa7+4VPAPwCMDJRJkwHeA/gCQBYkk44CyAd4O8ilOzbAgTKZdBXADoCvAH4FmBosk64AaAa4DOA3APQAIB2gAOAqwB8DXPqUNFAmXTMQpSclPwH8LcCAQdB3AVQAvDEI6UaoLrTvO+09iAcbFQPhK6cBD4J0wX20LkzbpAgE2hig+er699HaMG2zwg9oCqCdziBjP+zZ261evdZb4MIQv6AM7ZCfOEQmXQawAaAJ4HsA9JbzMS5V+P/3lvNhbq6t9y3nw5zO1vuW82Euydb7lvNhbprt/77lvAJsz/82P08gKy0W2cSiTFcJJLHFq0VrJNqD3C6b5LGcPF5ykMtwIGv58r8DoMxJ8I0SytdEqsSZscPQyvox7jcHOc3LnJZxmOvpkTCEMiwNWbFoJabL/Nzy3TJCPhHH86DEpjRFP+1+bpKdiPRnCCNZNbf76/QsJanw1R7mLvQcT8xI87mN9hGL4Gt+6CnjDgtERkIiWr+VUzZLJnzL4p+9pD0jA6V72UBpANjcERlTm9A6D5prQWuXx7gzn6O9PyhfPJ+ykRx96byESmDPFi7THuK28uhOCy/qeJr0xDFuZA8xbJHW6+iVhx6LJccO8SFph7hVvHz1PG3KnHlzD3HL+JFU2up5yhgIK+uJV8IY6ZGIOMb59xzifedRKaocQr3bHAxfIDlRy91xopGjz+0ybpwgziCMCfQMXRKFviWz56GlgQ/V3PFqvyE9+XaGhjrEJfL+j31J+YZD3Gy+gffVqJpiTio2aKCM4zElDSiT3ZR+J1dviII4UTy6q3LBb2LyC9O9hzEkmXQRcD/ALTBiiVDde+ijuvJwiMqvPtJ47+FocMvBT6NCN1VdeahUNfBOzZXOYXpCoT5yrQnd6IbOusrqRxiD66OMA+pHGgfWRxsF1SH+tIZREcaIk+JTkschZDx1pXO4/iD3qbDPInQR+nb32+eHOXEPkqH0tAQ8j0S0howKli5KD5ZOXREs/SwmWNphluH6eg/qjmRCMgQuDtcNGcV/5Hk3HK+5HebarGRkv7a5GaCXKfHUMe7f1tEZEupSy4SmgbQMS8O/rHKKvxgJOvOFwxOfnzjuHJ02pKU/nmu9Z0GnXr91/m7p1+JHP7P46VAqrVbUgn1n1uD14J8s50JdZUnPCZSiMgyzBkrbgwOl83pk0odcIIwPM2fHxWfOBunehs6sSj8Sgxah8hmshFx68f1/yaSh0YF4vfYYtxvrxfHHccRzC9onIaFKzw+k/KlbTZKRg28RihBlBoTi+XcPneH9NGMzqniN5hAfqKnixwLuN+8QH6TZ0LQRRtcHOYngeT7zIin3YGf1/GxBOK/nnkUMI38RUC86NWldoMvHXwmWHuSOXzjIvXnhz/djyrkDzgs6GCPLi9nDzhYI73ASUPO+GlLlRR3i4zUfMeE5YlbwIdQJ7NBiNGomFX4gryUOyRAkrXfQTnjjGfqMToWlNdTabvnVFHByEvUepNblvMhv1qhYkeh89C1T87OvC34wDVRfN/1VfdX0TE2wbxdNvPlY/Z35LeY+/5fKN7XGTqKilicSGlIOcKcdxHBJVT3zRjJhRLeriqtER8lqdG9tLFVD1+hqtRauRiA18033OgfqHV0WPalSZaL9raQ6xRxwwvfkWAqde42iPNmP7QTQiKhs86G252oPKElPwRGz70lCEddWAmNfC3fNltHcmw6kQZMxfmZC4XsSvdkzRijQHuOqbGh+7DC3hs+2iGJ8+qhyYRdQ9wFVSv1hEcd491Fkwjag5NhIxWOL70mRAvl5C4stYvX07oXn0L2l5ex8hzhqenfyuXudYb15f3rhsbj/9O5E8BvU6wffJO37JoszivJiK4Uqy73OkBdCeJt7c/nBOTwTSUKOdQiECe0NU/HJY7L/OjNKBYX6yknTe/nwwpGUpzyVXeGOo7RO1R7gOu0z8a5fxZ7pDNr5G9dKKgnlyJZb+cRIgv2y0MhHHDfyijSoLc0ErXflV08LxVKjhN0uFFIxEP+K3btOWk8YP+4pfX7loagY7SGfy5LSnd6oLhdQsdQMvIP6Ci8pVGgfcIutQ5i0zCF9EgD1bx/MSKog7sIwxiUBEPY8qv8kKoQOgV4Y6t95tuOTx6L+f/JmOfBGylK8p4WMisa+aNQ2xynVerD97baO98LB/lgVLP11OSFvCXfpZNrLhFwLcBn8TgBOBnwJcHwqIQ8AQHO0P0BYIkhPfA00UZS0L2WFc67Wk/Wxft9x72Ew1OcGOxlPRklv9tIDnbO1UvY6/3nHBeC9d188D2ci2FlSdoutqQOdlwkw/5If2/QSPUWHagTVR5UDhUT19IcDSa8GZEiMf1vw734W4KfPVMuLUpsN+h1tR7NCMfRIHUplm+NARzQ9HNq5VHaTI4qOAtchjhKImE9a1yZ++ExfEHhbTlVzWwXXqSMUbqkD+awThtCDsc8hbrTge1KieLMDacVB7hC27qZ3v3IWndRDMV5yBNNm0IqCbsuZg9ysHjkVSHvrUtlxDrQfQA69j78wuyOequV+tL74ChTR2svzR8BfUYRMGhThqpPhgDUAMwGgDLQIl/u3z+cluejQvoL1I8pRNnnic22HuLtOD3w67+IDacIh7sbnROtrewNx2JWQRuZHs1Jm0Q/zZzFUcuV5YqS0VQZfhs5PHuJanQgbchfmgsyrpa0+VBJDVBJR0lZfagY9Fed8xpkAPVA5u42fTqMVognY9x3n8Y3l7HoeSefxDeXsGh7d+3z9oQTaUJHqOkCMDr2RKJKPow9BW5sGoefhMHJwMTxad2qDeBSvxqkqcKq7nEd5ZQDUFSOSu0o6gg6Dcm5yDmeG0+H6QTjUWqc6L5IOxu5VTiW0tkPt0pMk5UkNBfdY+6Y8T3V162B6SPICXpWA9geHWlVUONh7KMYsZxD0GkQrkm+fMJnUCv1bDtTDxDAXf5EOhIJ7CMBQgAQApCdbAZcCfAqg+1omvVgvk/4E7jII/whwD0DhpmDpdUgvEtxSqFdkS6H+ZgiDtHsIU3aeiApuFUWSkV5UuHZwTj/KQB3gPuwJZSRgTYnSyWEhbo1XUeRRpPED6AG6gaDvx+0nEiVUoDmYDmbQzVHEmBDgzlgqiEaybrOhvYNu2SpKiuDMUZSEfe58it5FhrIj3dW69RvJ3Is6/oUzQPo5AAvlDvgoSBeklSWnsmW2IF1bVpA2lS0Bl3wHcuXbAnXy7EBw7QZXGnZl2wJ0x7MDwLUVXG3YtdGWtiPgou5//AndLwGYnzclYmI5uOftFhHXwCYOXS4h/gBc0ygm+oP/nlskIcDv/TIxsQ5+j3rIz/VtaOCjEoqpA8CjWuCS2Br2SOrJPPL2akmUtp5P9L/qOrkS1UpEqnPeTRza6lcfk0kqwzIvPuBfJyK7LWjPOjeXNPrV3+9coDd2ivS97wl4UcHUlLvGTrH+fmdKn+93raidxnfhMddAJuf9RorqqGgzaqWiTQe4L/l/gm/inOCW2JykWUtMM6C1/8GamydSozc403C4cDP6Pc4kVkebJtMLcojol82TaPRqmrT1nUT5NU/FsDaUyxULCn3TTCgJFaSqumYBC2P3Ac7A335InKKp8498fFY/8vW9NigVvtI8ax519aqHwkMe2uahmNBGyiUsZ1e0kQoVcyePUD8xk/VGXq0hIVeRergpnAnTT26u302o/VrFchGEXuIoBakJSUa53jepMu54ia6jVL6zq2CUoUpzvYqEqG+b7vMJhhYLqT5hItS/mCQKUv6TxVN+1yKW38b3PyRP1/6sn54DslP4glyhPgLJkxbcBpOYkH3kBbLsR3kyXjSh6ODOColDFiYunKHKRHv9iFakN7i/WY7HHNguK4ExR0AD63oNsqKSqqfATt95gPPgj/LEJdROoJ0fUSa2S+IT1SWv+LDrQYXrvmUiZqn5HvDxH/hedILUMWNywjKAiwRwkbw2iBizyOQ6ySO+FtyEUgkxESp1JqkKrJNlBrX96I5XiPaGkD88JMpPN/WmHnDPJWmqa3FMeC6hnmKKhRr9O8QQ97XnmuTrUMI11LVBfjaym7CJZ562Qas2M+CRVDTjkbf4767046B8cXcsqNYbLZCLCvKdFRCa9MiDRKV37Ux5YHGV9B/XUDkvm4mYL2HsqM7EMcgy9geHL75LB0ldObuVJ6I+NntjH7S/uZzdCz5NJk/sc6rvXeDCvaNnILz3x2MziJ+feSD3Mn9Cngn8T0jsTyT7u+oBvXer1sXQMSn3+cvH0W4egEKA84Rq3/kvHrrk9RuAr1H6g688JGVKRlxNGL0oE/jc6SR8DJ3+PqQc2YGPEP3dcExHPD7W2d+HQy9FAlUieDz2FgPdGMxU8VBII4pb1RnhI66+DmEF7qnTZ3w/kKIqvpgQV0PIfcgfxa/qHOIjcL84PbDcpvm7vwG+RQ7yGAWgQW0cQAb6RoAcADmAmLmZH9KyrEDaImKW6TNnI5m9CeMa/qP1zHo6QxueK9v+Vf63LeKCEpYUL9xekrd8CJPIzDBuF+cRivlZMvXgm/cfiFm/6NjExBkzEhNnz41YvPq1warExERC1WEhVde2B2bBuEowwP+vBVNWYPb8HUd2BO4wZx/JNu/gL7pCGLOuZT22/OmWZT964Vdg9sIdxh2/vuCDfpcUBGajUsl2XMu+aZm/nVCQKvN2WVaXBeHemPN3/NwXz5zVanGFcdFcpZgPabW44xyBMH/6H9lxbccZy4g55u0f6gOzyBFZ+sf68blLs3bmLmoOb5rfvLK59DcvSVUW0xzYlNJcCmW5lkWoZNkDW0owv4zZHk3Wlr0Fv7fAL8l1+GXGrqodX7QUFlxCbiJgh0dTYwvm7o5dlqnUj5YI6obFj7oGJfrR4gtuIvJngF8thPyBRUp1WAjVQwvqt6KWu/qsB7jNuMn4URUc5+hPBenu8ysKzfiWq48fiXzXPxL7oROOP4Pe3pwluwpSu15F+cDoG9lsa3k0YvMEe+AQ91KPFxOSe/HBTUbCrroA+EAG5CODvhvZZ8geQPmic3qoL3mTOgvjta+Lw3POzPGg+lNVVHjLKQa1s8vNN109htjDhPS6FjTYkBhtquEnyKv5CZq6RK35E14jjz1cl5hkruHHg+948J0GvuPkWeAbD75x4BsHvuPMNdYp8mrrFHDHmG/yUzVPNi1MULEFSSpWEIdfeB3Gpr5NRGRY22EmXO+ttt5MeDI77m7Cr0nBwOsn5h/c2tmc8TUv1TyF/36a2A1f8wGaLPgfrEGnKJDe3Od/L8pP/gTdbnj5xf818B/tudxOrabQmeynDvQNpLqfeTtoo5fiNWY7HUV1cJftMyIk1I/mrTp0S/MEoRpG6aRaYUJfgUKvg9Dr6XRGokChz9hnQ+hL5ldx6KEC+r4VEejEl4dacQudHUT22Q60Wy7ujGXp3OU0cWwR44Hjvm5PhLjvmJfjuKQwhyGOzadd6RbZk4B22WS0LKDB4sskxgjPt52bPYeonslo6fv8vKb7vLToPh98xPoBCr8BxgmkZi7r6VPQrT+HVvand+88Jx4Tbk7CqV910hRRnUS5Ul8AOfuZ4zHlb06RAlFoClFmwdcPMEmopRaPMaR5nK7N4gs4VnfX4oN/37T4AR6ru26RjPnJJBoTZR6DU3nHmQTp0xSJ01dC6e+aozHlqNOVuhRTBgC//mVejl8bLHMSL+QshZy/NBMjjlvIMT+bpGPeMD+yVPMaDYyvn6edI98BLrBbH3tJW7u9pFsAOp96STNBjk3uvvobANT/Pljm6n8Hg7yPAZjkHhcOB/wd+OsALwFIA9gCsBugAqAe4OmmFLpXIn0vIGkm1YFmHXMrf3VzeMGUFqJyNjOb9sRfct62yUJUJjFJYAk8h5KOg7DPzS8xd/Kbm4jKacw02lvxG/i/BP6/gfSMDyBH/gR4HOAuwNMAk2CN3DURlWOZcbRUcQ1Cx2pi5iIpGw1yEsOIcE65NiQnBd2Hz47EHP3dMQwkZRjt4vVmWxKmFpxFsUm12KTAoW45iGPnLKEgMWFMGC3GYZfYkJQUdG84G4rD/MMhgRoIYoKw5M+2zcApvXy2H01U+7lzn+rOfe5ZKUNUS925jnXnOvMsUb3HUuZuw3ptn16eIl5nfuiV/J7egxrd9Ks+oimUyvxM4FIvRGHcCjYTsttRuyeBdi/X1p8K1KE3Mf9buxeA2z0lhXYOv8w+dCih1fPSHeQuC6Tc1eK1f4JaPKI1wz0HgOoetXVeH/kz5BHCeFCZ8HxZEtq7dJArFYgob0ZyJyQN7epAOzTQzoOwtP3cEjuab+4G2/DIcy8sPxH+qD/1oqbK+8F4ugQ4WdgUCHW/gs2xBjC/rIFRfPpePl7Tj1GlRcamp8upX7mTPX4pUUoCOHaU450zm8gxnvekusyMo9xOQdpCqk7tQHOZROsFGNPOKwySdg+D8QrwsRV+k9o3uVGfEq085IvctNsd8JFkLBkvcC1Cv2R5mqFJnFG/oWa2wFkEeYYcfqVm1MyGsqR5Ma5vEbg2IeCiB94FfJDTCOisiQl0BH2P6jXXmDrzI5AFIYIJyyDHDaEkZiIS2gVBTmVeDEmJyZjanL5J8jiOQKckEOUTgYxDM/7V3GOrwJ0S1sYE3dJkJEb0N5VEkKaDnM0ZlYHau7g0Iuq2qbdE6rTrlliwy38y/8viKtl3FlQGU+8cMPQ9qfdSMkbrELc6nBKqpjkGu9vAndEcjd23ncQFgdsmRDHhkJbnY2GC12OJl5cJnbdD33cJ7ZGL822bhF8v9RDQHjMVNZQegqlNTvReq1dbBE7rQ6e8ReCKBAmFaiEE+510GlrQnpQAnL7UFMyEZEQ1JW2K06CVGAn1kyUAr7d8YxG40QJ6U+CYgOYUici7wNf9bwZKE15zzSujb0ty83cZYDSv7ABA34vmmf++LVDq2ht19Dx6kVR8tw5S0wuz2+Zm1IAO2IvjoTxr4NvlF2p4QiNmBS91k5E2guQf5JKdA9oqmZHwlUMzBe4VdOIzs5obaUUhw1vIiX991rO124z+x8FYEp0xHID3WJXqUKoTnSichFrW4ttSTN+wFDCkEqUVBmlNEgro7yyxLfn0bpzTICcZed+yB8cLx/slnNx04QdLDvYJwntQaLNodJLpTEY25qHUqWnJ0nqyUQ4iagLI0iVLJva3O0Jatmgl7LieJ5Yt2Ocp+GRoPdgr1oeWDdjnN/BZC2G0QptlHfb52SFvWat7RevFfm79wZKO/X6EUC9DDv2FK5ZXaDU1B5f0S8cBy0r6XQBap6EOcp86tmak4lK24nX/OPMy7X3+RNGyucvmLE+p4Nb0oJkdCSkyKilSRenQ7CVxbKG2g/vDtpCepCOi/FpjKTWF0q5yzGV0WiNPGCo4qofE8cIosN7LiWPxOgri3LBp6d4YH1sonG+JI6NlJq3RkXInly6QUdO7c87NoFW4tJsc2yzTcahM9DJ0y2R6uM7JzRNQ+/zqucm0j2Uypq7GZd9tjmZS9eLmsXQETm0qhLtlileiV6KPcv+0axh0Ezd6vcxHNZrxM/ob+xn7GwOMA1Vn+JmaCu57PKsVwVS3jaDvdWzY7JJRtO6B5BPNnyL5jBkuk7YAjQKMZFWSFigdcdFlNz6Nk0njJ8ikK4H2er0M25BbtgRL0+H3HoBagNyXZNLesTOaTxr5zyDcnp0EGpqv+RzwK0eDpP8CfBfgKcBvAMdGyKQEwRegO7R64HfNctdczi7MgTawbY63xCtJ/K2L7FkvfOu2F751AP7WgyBbKNbfIFbGhd5Yk+yvvhArnemNk/D8k1gUazVzO/9xF6Enos93SfXSVrZrtv5Kp5/+5fxDPCWvz39Ze4ifrRErPRsPcD3WA1xUz+KOJTifI3ZUPztBA7aCBizA8rnfTkTNM83D7iJwJ5vmYHcuuLWmZOzeAe6ZJhq7t4I7waTF7g3gnmqisDsd3PGmmdi9EtxxpkTsXmova07ArgX2zObp2JViX9Y8Dbu09oTmqbqptEtyJ9r9FZPBZp1MT2FGaNu5RVjC4s7G07faFRSM1hR/WESKTotY8cgiUTy0eCgsFk9Fu8VL8YtFqvjZ4q24b/FR3LP4Ku5YYkBGkWb529W6DOjFZPDtphbRaNIcpT3eTlLxSsTrEluLapjuRAbi61GOtL/VqdITUSxw90++tnQM0e5v/6v8z3ofN8LV96H5fDMZJJ0Gv2cCMAALAF4B2ARwpDVQmg04D6AMoBLgrREuGw/JYpnbBkEy2DjCJZcThsikn4F78BDXnbXPNrva3vLz/agGXksEU/ceBiiIqFRzfMq53WheZaueGDPfNH5uZae//sdOom8+bfbdseDX7z/8pt29+lBUfhng6kMJYEk5Kd/LjyIqN7yzei8fQ4Rt/Pfqlzcq19RvTF/j/zjAj3wcLCYfR4pCMpZnrKfE/5DGGhM/ozizpJE88S632Cmuf3eNWi9rIeVi9oGNVKm3l3NdzsswFiNUe/nRmrEZbzcpqQC0rsOTctfe2So+Rq5vMfLlBBH1zJT62rurSQgbo/nZAi0EhDzMa9IewNjTYsHzCdA3RQJcmhzsvmPK84DxfBkVQY2o9zBW8aMDavhQTW1iMfBFOezew8idCawR8hijqeHDAmoTRSa0glhR8u6h79W7bn6r3np1pXqLSX1zgJpgl5b43BSp190KBvfEkqg6sUJOObls68q2eepU0wrwtRcPVD8xn0whjp5kTtGntD6KdnSSLIpgBxar9T4QIqj4ffp9bOHx/F/oyJ9bwM+neOLND9STTc3gHld8Xm02X+/01L+la2C8M653elVUdUor7FAjidSVTg99Ax9s+OZpQkA75+sMZcn+HhTB6orsXQ/0bipYygkwSisHzaigyxhCkUC1c393vAZjtyuFSRErE1fOeL2tVS0yiW9eVNebSbnsl0vq9aZv1LwFrXwSbGzRjJtP1R43H6vZqz+ou0x31Y8sz9Sl156rH9xqflZdUGTenRKdT0QT7B/FVZ2ePsXsp1YyKuFJTxH80gtdf8rPpSds0aaK3ht+en0THrcXrUb369GrGTEu3S4HqUlgW4vX0mmYNxv51XR1W/OzwVv7XU14/n2QMfHU1YQnQUpj4vumhCfXthsT38Vro29ZoJUbZ0x8wyR0Tzz37rPfksZOIWFUNfac0QKc09td600vD2BJD4JdVDQTcp1FJ8EIF+U6FeeqK5pNJ+Fcx/Cz6Fm4B/PpiaobSfW3iNQe5okQJ56ewJCKly1itY95ZN1YGGU7uQQn9EzGsbQGRhMpFolaZ7a77i6fLGMF76mm3nAxzsbHIrGnOgrPQw2Q+PQPH6EgFBBXSSugJGMsw5jwfNUFcthlSwT4DqbDYRQdaQkFdxgdwvgohlgGgnsQPYDxVYRY0F0EwXQQ46cIsoTjdZXl7FUhhB6ES37GetuC7h3wpX2At6TFA77AE80C0J6Mp8LaIVUPNovQzYO0iPFWPO54cV4XtVGbhrj6xOvoznPA/4Dff3Ovdf0bsBekdw7in6PPM1KFucNTHdrHkb86GoHSSDcyXorLHaGspH+LOZRNIKZ3f3E2lJX2L+hedy6UDej/k/l8ByH/uANJC7oFCt3+5V4ZrGt5TPYfcGtQV4DPfra/rQavNh3D35gmHN+wn/WwGbGfy1acYH2rQ3n4E9DoukRvliT6mw8znsqXdxymK8DiGATju1jzQXo/jp8glNObLTX8QM2mpiImNWdhSyldhCmxwl66AKfXz3qsDZXgJ3MNHywPiL59M5+5lnDL64cbecz9zny9sVPy5/rDPT29DceXCTn0TxYUT2kmo+Tmcm6vPZu5zz8oQnO6aIQX9Ejqm/TI2+8gjPRKZvW/epQfXYhm733Mw+uv8NJC+KKsaCqW8qidh+ZaHMSwzztQG/BX6LG7u/6B85vLkmLPe9eyXqEX4bJ+wj+yfAzc66X3v7cwe45uGY1oJ3kk/b0r7oT6h7sL6V8sxLDF2TeyFtAH+zjf+y397hEqkXF4vUdtb0lQOe7YC4Gnf/sgB8KL6s936XzYrg0+VZ2SU1WdPhVFbK6djCJvioZldPS+4lvEbgO/Z7fQWlgRew7swj9uVfNlGkI9vft1GMWXY1fF2XLuqW0fpPk3qMl9kB6p2get/z5o1ffxozT7Oj0rqjs9w6s7Jb6eJ3ayf7X35g35hEE+YR6PI0iPx3IRon5tr+4M9fGoR69K7Ov09gnNmNQUTYVqK7hvHV5g/YdtX2oZSQ2A37sdHvUhad2WF/tRPuLPuUMk/9sGy6SHAcIByL0kgeZg0P1t2sEu++884O8BOgGGgm6gfgaNwacwiKdh+slzvKJDWifrerkb0uqTiTgsu0cYx9OxlBdueYQeNKNFeHiYx+rQ2++ZjvE7ne2kKnbnl+1qOoEKzCGM0RC6nfuthwBfVbsKNGsYrWKGaz2gT7nfQ0ZJzZEwMvQE+bvmUILlTci7O1S0HEvkPx1y+nk7ajVC6IFMqNYX4vwN4niaw+kQHKfFEUr/agl1tx8fOAbSP7UPpAOxBZ5rRXbUxbMT22X4LORy9h1HAL0FdFZ2/uLvnngFpbfdKEz9c04K8W/6kD/5uRDchwAaAe4CPAFwv8cxF93SfuZJ90oDIzOQSoP25cxy7pygMRzWlsO4+yXDIcDvC9MNBwG/KyQYDgB+S5hhqABcLyQaygEfE5IMZYCNwkzDfsCvC7MMpYAPCJRhH+D9wmzDXsAlgtZQArhA0BmKAecKYw1FgHcJ4wyFgLME2lAAeKvAGPIBbxKSDXmA1wsphj2A04U5hlzAMBY16AGnCvMMuwEvFWINOYAXCnGGXYDnCvMNOwEzwnjDDsCzhQmGbMBJwgJDFuDpwkLDdsBThEWGbYAnCosNmYBjhSWGrYDHCEsNrwFWC8sMWwCPEJYbNgNWCS8bNgEeKqQaNgIOF1YYNgAeJKw0ZACWCasM6wH3F14xrAPsK6QZXgXsJaw2iNgvnfImdI+tSH6Ae9MpYu0OedNq+hX8u9r5ilaT8sqctLkVMPrwf/bGWrTWBfaYSkEJqgjDMhgbPIir4O7alFRE7SItEVnBLbNP3f77zlJekVDOBfQsYD4s9lf+A/SYHBGWWcrLM//YUcorM7t3nN5xeufmnaczf4eatVt1DE2Hpf0dwm3NOp31e1ZM9ubs09lOroE/tWem9vS2dxNDWkdQY6nft23efnr779u37qrg3rZNZ0LS0J0ehYXT6Fhc4mlOkXwKjDsPcPFoPkRj4E73IDnc9DxAuhBgKECuPUAa1B4gHQKgdwRImV8DpPXgXg54G8A6gHyAg+C3B6AF4AH8fgbwyx8B0imAReA3CiAG3BEAjeD2A1wB8A246wC/D/AhwBcA3wPcATj/S4D0EsBxABNAMcARgDYAFmAKxA0d6upPRwLOoIKx3vS2SWj9nyAKW/HeBOiDp0KYf+4JlIbAePhjbRWX6PhI9xG0ZTKbXLnGoKCawS/e8YHuA/DztmmU6eB3Xruhqoob5QiAOIYTG8E9whGgOnhSQXnIl7FSW0CUBzXQ3GB9adztD8ho4smCvRf5qcrJTYdrPeXQ/ivept/RLWdP2A42vg2p/tRTwQ2xEcPJYW+CNLy1+hD/5vwKbpptLBWgHGyog/x5ex2Ei7NNNNQC1mBKvKHqRBX3yH4UfEaAT4JyiMEIYf9tN2pRemOpoYYA5RHwuWUfS5098d5p/2che6BGX0ISuPncprNlVDKvaLuymOQ9C8mxkpG/PhSp2gCemvdq9yXvm1PB2XrmoTfKDA8gp4/txUyx9pnxubGC+6MHvV2mMPg/q0ir4hrteZBje088+E0yfAdhj9v14HO3ZzejBD0enFXB/dBDKFSGNKUdqEdAD0rWZDOyNP8nEYlZWllaBff3HjnEjjR8AvQi+1aIfbFnGOhqBdfSMxx0tYL7qEcDIUaAnlZxmfZN4HO6B+3CjTK8AXHW29eDz7vYZ7LhHfBZZV8LPnU41hTDJfBZbE8DnyM9acxU4AyhCKGqOMbusX0l+Jb2jDSsAFzck8pM66NOtZPKucxYHWFAt9WnCYtB5/0dY5HbtpCJTVs4ZxH4SLDPUtsCZoE2Ng100T5f5+Dm2uYzmprBmVsaHZzOtqVetVNOidg7toAWhH+xte2M0YrY+7b+hgZ+qka1i2LC96CR0aKSX/IJtZiStpKq/kZoc/gZc2ekEJGoBYinXqsq5yKtrzWOrXFAHW9tjKvZWuXgQm2ZjbE1meAKtmXWj6/ZVkWqg1slKhW1rVGd6QC5TW9Dcy7aqGApWjMMXhOM9/jsH+rqS/ZMD5YG64KlaD7964Rg6cFJwdK4l4KlqG+emhgsReuLaD8u0iO0Rk4Q+plfr3ftz937arAUrZkHAxaEgoJkTTDeV7coJVAaHBMsRXMxDxZCWouCpcch/xObg6VofXnzxGBpxmgAoDOgs2i9eh6kvRnchV99Q64AjNbga9z9oNa9b2dbfXROA/9JkZgVi2VJ6szTzJmUmrwSXlFIors8izdnitgi21rV9sZxNduNDu5Az/b6+53/U+Fr7B0l+ajWd53Q7zCil8KRBbfTSKiI4TnGIiN6JaWeudK5XV9xotiYVZ1dvat6d7W+Ord6T3VedX51QfWhzsKKsury6pLqvdVHuI+cMDoaW3Eij9U59jUiPMcxToVc+4xHuE+dsVQ5XdHo/8yc+Qa3xYHooxz7dKVaT/bjnisPA9bdexgQd+Wh77orD0MAwuLIyCZqYPWY6n7VA6qDqv2rR1c3U6OqB1UFV8dUy+qNfDyayRUR6kQ2pDijcXjNIf64ooKjrQ388bGyFiKGYDVFt08Or0V6M976GhOeu+nClkZNTTl3woHukpxZvJHeqBNDK0/bVoH0VfUg32nFqWDFvZxye2cUSGZ1DzE8aldp40s1pdUO7ndraf30mk079zfuh1/t1v31p3Y60Pl1FbRSY7MaE2qWpji4W9bsxiSQyBvWHY0zAZutOxtnAf7WLanfWJOY1+rG1UAtybeDPnxhHUnR4H/Bmt84H3CL9a3O2Xr0Mu32eqom2ri+a79+V+Pf4HdvnaEaQ3WF6sbBvW0tbJwN8eqtRY1awMesxY06wEbrnsYUwEesJY1zAB+y5jVOAFxujWsqqRvDjNEV28SqLx5KVHsb59aMSnZwe6w5jfMgxE7r7sYZgLOt+sZEwJlWpFsObrMVaZaDy7AivXJpFaHa1qgCrVpl3VavzInQMTUuWUR+C6yhumQIP8caolsIONk6SLcIsNY6ULcY8ExrdJtrrx2SaWT3Il16+99e0pGprjUnpDdIV//l7sM0oAM+P747FekH4daB3jkYtCZpQmNJgGbdEkg/2PqBbingAGuTbhlgP+t53XLAntZzupcBi6xndamAnfwZ3QrAPfxp3UrAz/lTulWAn/Anda8A7uIbdWmAf+NzG1cDfsAXNC4A/Cvv/+StwIiaCmiXGvi3xqY33T4ZUfsWtIIOoYHPjBWrxWa0//kAd82KQg4B2esRUEhV0zF6SO0xCPlAQJShQOl0UyrpobWVQLkjGJgjc2BMl7P0N6k4gZ1U9DQvvIVUPd2BpO1Acnp+c8t+tBcNn14IMDV05tTd7yxF44A617zHxCJSlb6zkEnNR21pTBERWXNmMR8JoyKP2woK2Zq1wiw+kqg5hcqwkI+cF0WVc424HISaYBcXoTW329BbvGS9fXIkhaxHg3DilPjRZU+0i0CWlMAOL7p96hr0k7Ikgh1TdPdEGZfqXN93M/IldljRWsbI++HxZwI7pGiNtoyjnav7Qlx5GE2+ot2fZ+AV8zadcu2nJseELU5gjXtF7A98MbUYYox1ftSz79mVh+KyKw9J/RZv175nolBNJVIzqHnaeSntXGsPo7sBpTJD3+DaYVHIdhTeg/SpvtwK2XuFpzLQt90qVGOu3ChMpBPA1lvGrhcSsOsAl2j9pm06PRn7rhCm0lOw70QrcfTgKSWF7JpD/EuJZ/ipiYerlrLbnAL39gVCdfbXEOrsHhG7hy+i4qky7kdHKUt6ftJT9hSX9qF4JpRdR1SnevevU2lJGCOt68nIJOWj2ocyW+rCdn7WPhhaoZW8vEnBhOsJdUH3p2dCGEL5STvRehNk+i5AG9qPBbI+E2AqgBYgHiAOIAogBgDZeKivQn0W6qtQn4X34BFE3NdLg6UFe4cQJ9x7u3v35SFdQ/MvXW49+wAw6pfKuCX2EODeZyHaR2KPRuDh8cTW7gtnn+ahkfWPZwmQxqydrvbvXx39UojhJ0KoR2KylDU573f6QosV4NPYNUJ/vmt2XRmnsZeyl53Qivn0ymgy9OuE6nQHGtMSkdk6DfBtiuOdF+4BN53ddCp8Jcrt27O3T4UVSKJFrfU0qQjMRFKHJJ80of1zZJwkpgBG/UiSI0GbKKdLmz45GVlrALmNcyLKZKBMcrrke7LpnZOTa9EIb7jzHZBbwV7Wl2/MtQb+jXH7aCQpm0veq+/dy4AkZm3JwqwC5i91YWl5TH1ufVMDX5u4t2UPvQfLy0xnrm43jeRlKK8H60xiU1CkvIK7KmxhwnIymbos/2f/yspOERnRTk/yKJLiTxpdUptJOzhDDyrnYChnu8NVzkTTpuRNc9L1g2s3aaONStDQ7x3NeVMuqPTq5nR9+IV1c6fkipuz8l7VitTL0V7iurVMeM5aY3DrXFbi8yVwtNK+tl5iXMQQx/ymuWSRLBEfRbMcCykltRy4/iuX75zPhOnXNKXqo+uMiVIT+vLHxWI5yW4QXPWLyjUVylXrLtdUU3LyrJSptYwWlWmvQ5W7aVcURbJ2JxE12qTS/5Zflzik9ZFbOk4WpOvR71O7XL8n0lMZU0Gtvgz8zLtIJfgpbuujmNCCI+AT5g41ihlD38k370H7wWrB/1q2y38II69Zkef/5O1AAn6/PbacmwOlenvsXpaUME0PTsprR0C9TnaUcc97hjFfoZ2R3OMeFW4tXfsoB1BDKHTTezPU98nE6a0+oGl1225vI2LmmwLm2qBtSDGNbbv091FEO7K5NC6bbbq/GO8jROMmufzPuYfCME9iGZqfAN1CdiPSKWRD9urZ1+51OKRTyOZD9uO8l137EonhtxtHgvWSkV4OI5gGPmPhviYYG2ckUiNrG+ErfrTn5qE59tHFZdzrYCmFkcgiQl+b1DS1qV89qqkDxcd7yz+8tFEBqYWsKecuQ2oh47IgtYpXoylFbQ2kdt4e545TXWxkVm1/czuq10lQr2fsLo357uSkWjQvUm8/zIRlIGkVGQ8ypLGBN8cRRkhr9bVBSFod3GTcqykh7ut2l0yMNpUkK2tLsETkwhhpcK5Hc2TuoPo30JsQYJF9VZxP5+s8QU/O23PpPB0BmnHAuZMZVZeaa0z0MTFNu+mdmH7cvpPegem5zteYsNzU3EGVo4wlb2zXDaxZneRDfTsooMVDWWQTqV7TXgIbZj3efUuwZ4rXuF0niomYhKf/U0wqlrGv2l8FnVA1raVfgTQd3Aw+nU5nAnOgnR2ZAJxYTcsy0bdMg28Z6ebDSnpa7Uo072FHlBFAiUCU1cToSab7/N63R9Qu1S5NXgBf6mkv4760LsbSRQwbhHbsSstmSVv3J0ZercP7yOf1zX2G36vj1QlkTAK7qXh0PWpP1hfHu0ucWkzRE3ErorDPpMeDq4Kzu63L0dWoFFFQils2VL7w5jdORtVOgfL9A34XBk1m3qxDZ5C6i2szfJLq0iYwDXyR8s2aWxlo5aSzmEy6ldbAFweFbUChHhSLksJWu1IOTFHnoNx/LiYiUR4qyON9m4sH9pOq2kjI46htB/ujFc2NHCyE8Wo6tDL6ocw199rdtDY0fkF60TsOQuOipctd+4fRmAjpQfYL+lIN7l4b7gS4e/ecLUL9F+gJGguh8VLhoVRC65qjiPsMwqGxE9YtSBPZfUinsK1zA0bPSahU5/tKhfzjbtihZQ/q2ccmCu/iPc+lbLtV23yPJyT7WIlwHPvtgzbuysO15D1eAr5WZ73bd5Vwj5fGvdX5RrR3V8DkT7q+qUPWysguEfRl/+Sh/Yxu6IwOb+hc67uD/dhmnNOMx6xfFlcy9/ioReG55LR3WyaPCrqZVVDS4nrHZRkbZztAH8I129/hDa3rB3ZSlbUL1UMDr40rniNSE0+Ki7MKUEoNxb20ImZlnmhUAltVXAj9TBS1jA2w5dG54Cr79x5mbaWRJ46T7HT7P58WehVTu8FiqrEii2ltHXpxxmUvkYorD0XvXHlIbFNT/esEbu0FUlX7KwlluOrwb9/CDM0d0VTGreJRC/Ov9jJuOX+zc7K+u+tr121uN252Tun7Bf32CGIEakeQlTIA44/P+D87ko647//kIK6Lew/D3K1tABVKzcZcdfWvo66t73pfb+ny0jd3efetKXzXSg4nhg+FUoRDKQKgzR7Ew6jwhTRm9vXQ/a4mgoUGI3D2QE8CfrWhgltn73d0QPW29tHUXQuh6mfkLejtTWjBdkzSTZ47mREde3BWfJQwItvV3En4NHQ+8yHldu57IQ7CkRPjGPFR0TEXHe0jr+7sj+mfCwvbRzNH+UJihA6nl62eE8OIqsVVhPGGO62jnRE+drCdR0C4YgJSmzCMEVeJql0hUGpHO4dAiBqBane9G92771577rO6Jz/qX0LjfOSHxjJbg0om957HOan8zzWD75SuPSBIL3r3508D3Uhz72Ff4N7njva2o73uaH/74uWuPe9onzva976fLsOtbKcV3cgipyq4r237mFJdWMbAo9cGoX38e3Xof8kL/9XthKJIu6w9dCg5suB5xhlfsMlePUOoVrfn0dlYtv9u1dPvtuuZulwiuqD7/TOimBx6qdm/lhhZ0H38TFDu9pYdMOKWg/Q2WbPoDJzvQZvbuqg+3L63TsmKJGRMmHkzTVR6KDbTm7W/cMedpMbHtInZRKfq/GsiMpexldYMejnU+H3LenoJ+C1jy62v0s8souhQ8yqI6atYSa+CmCUQ09u0gkmBMOjsz0p6GZttTaXbLKm0FsfbYl1O37Isp2fiX+usS+irFjHYkbozQbjUs6DUygsL8Gm3ZewS6xTdXBrp7ljbHK2RG+gMqpXCN/zak9nE4BljsP+sWnoc1u+h7i8Lqla0k3IjJzhslr11oslkdNjNOFzKODoOSqlxklE+5lhmCh2SqdQFQTmU1nhaAdy5a5lID8E+odbx8H3j6TD8K8g6ju6y1GYofhOJvNsVvxFkQLvyN0I0oF2enJ6HdDHsjJpRo1OjdWpmSM5+7ojgx4iMAyBXtOPKkxxOk0Y5es1oCbICI3Vg/1ldu1Odp22/Eq37Xmir0TwUkq0Xz0qgdrsNwvTKKKn4c78IklHUnkeCnxbgVQAjwIcAbQDoLjMfkGE1wDKAQqWs76zp1y+cMbWf2M+NFz58YSyQfSarwNg0eVTALQLaRRd3Y/VM02n6NOZ9Kd9In8K8X42t6InQkyXikbms+b2UibXvaaOhtx7Dq/NlTafykU35Dr1w2zv0o/xKflhAbWJ/UzE/TOOyRZmmBvoYTjWVr6eP4lQn4FTjIdVBvKt/rDoZX1sF/aMHX5Wihj58qamBXz6OUC8EvGxcePPrczTUfu6q83DfV4Re3c+ddqBQYjVanyDYvxZJoPf9okik9jXvYwjjPjqPydNKFL9wKgcZRZqLmZDMIhg7rGnKh3GhBPqF1qJ8GFPHacRqkam5p+TJAu/dTFimHiyc9KYdOm+9B9g054p26I7wYwPEI0Wmpp6ip6ne23W+mdt10hzUi79TRESjM4K+mfnQdq8x+cP/V8ybIAVCnWraCLl5Ry9F5wZiryXc8VpwY13KmjnQjpF/nl7Qmn7oFOlvdIo2pjG7ujr0qL1HL3z3tuXD7/4Als+NTvFGRGVf2I8Rev2HTglQJP+H4gcUD6B4/B9K4I3pwJnp9ARmolYEnKkG+2gM1MlS9qAwgx6Na2e9NR/bta8X+mO76kDhOOCXr1psEk8hoVctKRyfovlfX5HT9xVj/j+/Ysl//Qrdf/2Kqf/1K2bcGN1GtLbCmOLCC206GnejeeZkt+7cAhqac0Z6VYbO0VXXEL26VZzq2qdf5NYxZC+hffpoXixJJZO+AVx6g25gGjCXxHZwYy5ZnXV0PebSdb4OrOnJzXX0ggJlcyV9dY/PhZo55LCV2bE5aK1lYctR2oDj3Hcasc1SwX3Kj89cq7zgen+tmQFbZj8O8b3zAPQeKEQjXwi8bm4q0+7nUh1/jqP9rxam7JtzMiM2ow69UZJPygn1q2aSXWk9lRGblpVylA8//uljov9qUyZItMudAJb7luQqXq5BtcgW7eeC7YQK3bGwj50iZOH9GOtx/oed+8H27qWNEjZj2mpcojR+A30Vfm2g0f4tueZLcKP24h8/LwQeLaQXMYu0HsCjbTYyCu3JT2OYjjR6AY6byC+i5+IcVjoX0CnYL54nVZuyUQrxHYSS6iBUSzrE1KqOTTBSrIYv+oE/arnPxxXdxPNix0z7uRZbQ+dOsP2T9eu7RuiR5Tioy+Czj/UWUJjSkBmPxF5odsp1YrW1O//cKUgr3kyqTu1E+cQwW+uW5xHDDw0ho0t4eVrnB+MZidnIx6ftGpKfmD/DCFJ2v3N8n3RNvIH2i9zvHNfnA1aaHNrq6FfMo0Cz0Rjyn6WRc4/x8ZniMQns5VJy1OJbvpU72oKA94jbf4NSr7JFoHHM+sJw9DYn4uzqR17kPjbfORhz1xvshqWsGUYlpy0gixbXWc3e/Q1IfpEcvng+Csm3AfwjwH+zynWeGo2refC/ECnDc1XL3DL9DGQfzQOtW7cOvyWeAP6lEIcclX2TUL0FZVdc+uwx2X+LScgf2vLG3Om5xJj1poCWfi2EOt1USwfovaMk0G7NGPdlgslrzHUjHZS75kKV1s5tF3zryVhfYyVzv7NSj3jXy6UF91x8O/wi3xSEYmsdEU2Zy9FNH8C52NISBq05IC6OAs5Nu+lXubJte51vTXGi2Cyi/ACTNwn1t6Y8Jh/3vHmMaGRwqySSjBwKPbDJpmfERj16B15FGnf3neSWHEM98E56l2492AIXHBLqpIWMTmD5fevd+fnWh7QSqrcthOIjCzkq4UlnIaFaoTXwCgLt9OsoDG0Z2ILHb4Xb6/xqKxJFZt+6ikTiWmrTYiZM7x0tcbfjt7y2XF8FnOh0+gEn/IxzUxaArRovD8sk40RmkBT2d2EpHsPKkrzMNzBGc0ikD0iCD5oHgLH/mgeN0yCNFudspm53CkNGhWWKTUhrCfZ04UwmJJdgDwkoTjyUfiIe554tfIkJ2ZPQkkhP0S1lP7SjO3zE8nLudWc82i+TTQx771wMtflUxwoOzyOjF5yJ0QmsCDR/UM95NNssRjM4cbRap6KQ9FXaVdRYaP810Jtvdm4+Baks/q1NCS2QqmVPvVhNmqO1FRZZymt55OgycygThusjlImAevCzhUA9hOA7NMj0Qe56QHUgUqHz9FHULxxvJ6Mk1PTuTedCwcpTWUO16RbXOkWme5x6SuWSW5DT6b1y+qINg3Th8v86T38X4qC2Gp21Ko90zbN2A/YCQHdpxAFGNU/uG+iueT9c8yMtaH/M0nPobWbUJsns/ekAcJVzXQ4GW6urzvkz4XuYJn/8TsZSVmT3oaVgP5Zz9xxeDKFMtqAapNF5FaRrkf+pn3+B3/FgpRT07GXPCaid2lGzl90pmPB4bS97R0BvFqKWah87uwfdcKE5R4wm2LtFuG6kCRB3NcQ9guPugrjLhC/ccS/+R9xLTa7W0dekotAb6aguT9tUFNoBADzhSh1vQ89hzHRZYJtPjqdki13zuuzZN+hKXqkhRhFgu6ibCFUx/PpzXnJKTRmXYnPNQS0zXTo5pfYIjIEn2w4xqXhM/peig8wdPN//VtEB92xLXdG9zn/oGzoL+3p733v7mGvQo5fC2PReZ1Ffe+BxfQ/UCFo3IdiCorJTLh2JNJWBhfqrdR/7su2tzhyIUaxHa3Vozrs3ZtC916DckZqsFhJKHKlZr9tKozKjehxj20yvxfXo49io89X7qCPNG5LRzNr1Pvsk/Orb+d80vap7cU1jXtG7GeImVX5BHRm9Aix6tKcUlYwqWsCk0mLFfGhHPPkF8JVZLXOgnZBrFjYtoGX6KS00E6pXNBGVEsV8+t9cN155GgacO9+DOGdrun1yWG0y8O3Nno2nPI0bTnkYvzslQTN+6WLjg1MiI+UaTWdPQTs8q26fSqIn6GQ1Dq7YKm1CtwyNd3O2vnAMcwfzvbowDp9BxW3QuNsJV71GXR8JvFRq1M3DmdQCWXMUMy6FjFyRrUbWx4yFLRoY8SDuHO8ZhV/2QvOIMf9hfYygB+IQr/cMw/vJyrmN9jCcyyqci7JH/PSO17Ib/d292kKTH+REqOea/JnQF/K6cGEQftVL0+Yaj997QS96+zK8Ru/WX9QvhQ9zjXOOu8ffqN9D6/s5bj0/AuGiIUwl4DnDZNLeMX45F/K/vmIyXl9aysb0TKQn4a/wspdybwkTodSj5egMFwFtwZXCODowF0aLI7NMIfVTmgZhC/dcoSwXcfdU4WhmjBbPOiqCQ5IekR4XQUY+BBl5sxDtsPzuFAn1hnb+ympQLW5odHBR/Ott5LCFHWiUuOZsBNQY0zQU7+ZdynZYIzBvy7kvbOFQDhWM63xmlvDKgBJwA88CtR2lXIpQdgq1x8hqiATrYnr38bOEsgTcLn2sAdvofIcf40dLFJ90EK0Hhv3JV8SnE+55C6377LSX+6xe777gYzCCIUa+aQrKvdrcwJsiP4X/5sh3wFbdX3m70v/Z62uudhLRxk7vsGudUh9jp5eP/5PsxErw8392eM3txv0ngB6WzZ6z+T+5nITmoxo69+t3gU736vn0Z5nn/J/VpLtot/8Xbc253aCzMaCzDfytuFSQ7D85uaER8VFWY+f2CplMSF04nrV2tVexLXn1E2pkM/Ma84z7uc8cGboNyb65IcbceqlRX+9l3F3vacyu9zCuBZ5LjKugF0pnwgpElfX5pDGrnjCm0asZOfVvbofwS96YOmOiB+XvThnV+dqil+nluMWUWRcyd/LGGHGvax7Q5OJ6cJ9sqZoa4DeKc6fQxr0jpNDptSnaWclgAa8v43J4hkmiQzMYret3Jq8DK+EyuNE8cWxRqn4yvaZ2ljY9q4xbw4dieRtfNIlO1IZSaE4wAK8IV3LjQT/n58hyvJuSWJH4CMYS8dUcH8BS8XA6cDfyCRDPx1gurtyNKAliOR2oRz6F4vkIdxdmXdUDpZvICgVJxz7p8zEm0s25QXt8mmawIjKInrdHCi4JacBYSl7FlADSTyvKQy45WZxbmCdtSmRFIi/t5Tw/cElEknyEA0QJ+VHNiaxcpARdd62FFrb2ymJvv37c3bcjWT0HMtm7Nwjti0P74y659wzFjA6WvqHdi1NOEF1GuLtwO1EgRXhNtTbB5Vpw+4S4KLGoOKOyvg4sxAY+edyBxEATmdX/a8NpdH6+lDvhQGdRWrD1VF6opHTUfhg/vS8E4/FraeE+JiIXrZoUFZZAHQU1peoJtd7kCZbaW9bgqjyQI1VTHlASgRLbElyvakJW3KMeQhVszNFmJZeiM+OqnfSBxJh6921lw4hhB1qqePISuj3Ez7y1b6TmedUb4m6yuqQpxvhLzqnEIa2kqj0T/SbYN61EFHpnOvWeKMrLvAadpwDrbYVujdbGvWx/mWngjysG5w6sJyL/J1FDTaJCWgdTqJUVsw0CeuW4kiuwDzzq4JSfL6HrOuZpS7nZTt0LM8JxeCX4Usc83TzgwR1nqOGbDgWVBO4bziJqhyWBns1U5tbnLWgh1YGmJAbdaIPOS0ih1CHWHAup9jS9xLjuuSHNXvKnlinMzTwi6g8T4klDz3rLeCgzaIYijnnXEs9ctL5DkiDLYZl5bJRDTMmb4vCKSzmXZCUUKNVvrQQ7DeAOP6SmCsaZQ+G/2K6A/4RdDv8dNhX877ENhv+cbRj877ZFwf/Htkj432UbDv8f2UbA/wc2Jfxvt42E//+G8RWhDMv0f9K98uLvEry7mRxV8NzQiO40OddCjpr+vP9J5B79qatfQm9poD+8f3yTqz+69ML6PVov6b2v6W/u/gnJKDqLeHeYy85E+8bQvYoOLqfFSyvVQY+hFGcmZaJ7UkUqtH526aGnSkzvYeWfoLm9Zz97SWe+Cunni6I8TP7xoqiDrYSclGfORoBuGRO4x0JUS8j/Y+zNA6Kutgfwz2c2hmEbFhVcaGAAB1EbRRGXChGuzIzmWilZYZoOtJlW6pg6iKCSKDBWCo+0VylLKmT2NDOsfNlGjzHtqUnY5kg08x1M+3xm/51z54PZe73f7/fH/Xzuds7dzj33nLtuEGezQpj8JLMhNlt2K2b20ThD3AzAkYSjRayBSR1WFGPISU4n8aSWG8Ar9R8ViYlSryxIIh/3SFQg1RbULd7m/MK/1LhkqMwaoY8Mjv883n46knhAfo1fxKjkYBqhrMdwTB4fTt/J3ncigkGd8tGGaPlPwhk2tmCb84MPmHaMLyLTr7NT0effH6CbPzrIMGjGPF614hyV5WREYY2bOcL4NvTQsTRuDMT90B9+hbnzurWC+9pz7hal/vI1f5K5s9c6uuietgruE89HCVP7GDHuYr5O7+5xQT4xb/FCPjE95dGwGcGUIjoruLduwxZytn8PtEilPMmovDZW5ba1ItxRiSHeuIV7xScuwNvbtjkf+IDHedEHsTy5v4tYLM/TH/S7WepeTt1JhhVH4TsjaWaw9pm0gFq9cv/KtFUV3JMeSTLynSQyBHpXtm+wAVqkaDDARvqfoDUfT1/p2cp9QE+ujyWzbqjmaMg250Q/ngX/LMAm9/to/RKS3RZJ9+1v5fYH8Mz4Tza8v+fdwBWoByzHbiHPRVPi5Jj/mItKuUdoI6UG7xWTz/hhpXrVayuLVlZwiR6pAXOXTBKMkgK8f3YLl3gScfACDkY9GHLxU/uonvgCCangpB4FcDFlryhsaq84XG6QJolUUOb3A9wvgZS2KNXJa/EFAU7WDv+tRYcUDOapH9bm/l+wXwKsRIC99sFfwX72P2EPAaxUgP38L2Fb/idsNcCKBdi3/hK26r9g5QLsytvyvOMvYZ/+L1hWgJ1/W55X/CXsnP9OlwRhswBWLsDO/Q9Y59SwgvCZ4TMi7pUVAXVkM8PxXbdTPeyWdc5ffPICtMmK0A844dR1zisnkVaQ94SeVcrjKwbKsf8wyad6mORNgEEczoJd/JGYLFisMIqK9MbcokrjpqIV0zvtIfpOu7Sw2i4r6bRLTNV2OdjFpqWOn0tsjvKSZY7lpp9APxvuyDd12kX6Nx0VoK+9AfHYkquOEPgzJpsjzbTXrhNerTpDX61i+irMqBGWQninXVwCeCGutGS4Yxm4ZSX7AeaMY3jJhxAG6UK4DMLFQnjIbeGYL1aAF/1FOAvhIgGeEcLlt4VLIJyB8BCa5/9OP0SAl9wWLr0tXCTAS29LX3xbuFTIn/i29CU0nFEFY8hLVkzHcxArpjPtuJ/MeRRvZitIkXiYuF0Ad86O5+u2mPCkGOrC4WkyD5P1CfiesytK8JTYasd+k6UVw6TkEztr2mWPrDxnjzZlO4ZXDiIaR0hlSnKFXVTJJBkJ3vVWwzG+byA3L0PcEhLaEkzhqil8bC5Nj6X3LcePy7WLTPOh5Ksdn5pywbcut8caTYx4P5H/ynHQUzzSFeEt139lTUZoS0vuFbCdBRjcS3sK/mehVoJ2qanXGjx7JHrReZJVuWzB9+2xpExKd+vQoo6eZImUVBTId3X0SGP2kIN8CnCpXnpv80PVeHZC0djRk5KZZqnhXvOuBy47yCPWmEnMRXGKmJj0zK50IlLd7xztEamYXdPI8/rndVu5EB/KSTVcb+DZexUtKYfFFiblCMnLZ5wfm8UgBZ4y4yyO5JU5pBgwvu8uSM4uCqnGu1BruKe8IfVLCpTNCWQL1+6+ow7n23OcL5lx9Vy8B1dvWbWij1V05q+wMhnPWB/E2QzLg3o1Ceakxx30uV8/n95YvJU75Q3m5o0AmzJzFpOW3CLulckv8HI6R3/HtwXJwZTHeJXNcwjOH5W5MTXckRfeqWhiewmLsxYv5kbBKHeRZ7Rs5mfwBQyMhXskIMkKH33O+tDuLdwjbsmJvfaJlWkEYx3JTaDn+bp6pGOHN+F40+HH90Lndo7RB/Nqcd+pH0HHm6eEPM4NTCEq8sgf96dm3HPjicOZxi/aJPXKJhxDl7vVOmW9wmjJ/bA9SR9WlGmMLRLXyzMlE9hxkiyxxWDLhliDQXJ+3IZ1kqDHlB52q0nwLtetXLb3eZvE2QQxWEtyi4wwFpZEG+TNeJdmjEdCtPDf5y62sVn1MO6NnB0n79THyaeNCI5zGuBhK8GuuDZ06nH4q8CdAqYe7H1EDmOgGCSw0MxTj4oJnmifw0sM08DU5LqsypPaowNIQ6uEsI1fcVPc6UYF/LPdsY093Cn6xmkstMOTHraFSY5tGngQtNpCC/Tjr6GPR+cpGgfktQKtWyl3S8WeD3/kMFLTVeiF30NYU67dGj42ZYS4L1zcZY1twtvf34Wxf1ir9uQftM+Sgzcz1k8wTNDvtWdXdvPXzGCqweyTERnU1hmX1qDVj9UxKs7BVG7l9nqYlGD7bPKnkip7eGWHPaKyCvp7hz0K/kr4R1eqSS7oPYmNO7jzASYpsdHC5QdCEpO+ZUDGKH3Gwr3mD2/W8ylM7nVpdDaxcHv8UoL/u/3r27B1xlCa2OYSqdQkTh8D/WiJJ5jqdD87TjzyKyujlluYUTnOr0rlLY80p1GaGuQXaeKt+AqchkRAqfopB+/mGK4Jzttgu00H+4bZ0XL3smAb4tppc+l7oL1Ue0KbKrgyXwP0/TuhPTbwdzbhzgaGn7RnHriNLhO0j9M3r8XUvB5oMJeXhC0wVhfV5O42zl6MNX3DyqSYmiY3BjgmcJAfmlPFJ+bI61/Pzbl+vjStJTyJ9UjGxEBoqTemeXJTfGMHt8/7SEsK9Z/eiO8mzW0me0x4E7J/UnM5pAoSjz++Ptwyrz7CklAfaXmgPsoyuF5p2VnwYH20pYLL8lTpQAbwSYcqd8eDLljmfMmL969E7i5zVnvx1t1wsL3oVZPNdK1nsw53AJ9wR4OvmcaMAts6GjMCbM9DTIy3Tr+WxtzvXgs1I/YooGZ+9yr2sneutZ4C+jQBfQ5zrwKutZA3NbPETFaA/XEeZ46LeBNwFok8pGk3/67qxUVMxjxrN//pazvn7yFhhw0EfbfYmco5lEY+9ic2VnBn3RNJGUgkp72vAFUfp2uG18342iSOPRPJAnIG/Cs4tze0jw1lNPHt+U5WerxPHPUN4F7Rhmek3yNB3J8D7oUU90sU9xvuIL6z5oj6z4EfTYR0vvkvPFdAJ/jehTSN9Byk5QhK10jTyWSiDjE+QTGuc4dDfbzjTSbjdWaaUhH1f9odCf6N4K/VhVD/+dR/iVsJ/n8D/wxdKfUvoP4PuCPAvxr8F/7CiFMhhWB+dnDZNHy6OwrCzRDen9NhNBfpNDTbHQ2hz3jtbyeTeF1/DAxPoOEad6yO7d3MVnCPeBf8EiIGLmhVX7knJFr+w3dKOfKqVzVBXvYZ/B8Ji5Yjj/tEGiM/D+YnML+Bkchi5APAvAV27C+/YV9KByOk99iRMSQPeOt9ztYA9Hx9LuWtla6IK3K6hyzr0D20R9/n3Cfsu9/KrXMF+/Mj3rSreOo9vL3LHmnqsitNIbagO6o+ul5jGwO8B8vT5ksnyEeSfCGJyZdGG0YLGFcHMgwZ9M7vrdwcAed4L/IANRlD0miuHoNcqem881buHiGO2qu4Et6M/MfCFXqD3CfgYUb9aGXHpV09ejy+oIaL9sYb4iEdGeCYFhhgGAAakYZs5YYJOFhvDMTye878HGlQCPm5MxBmCKE3eP9ii0wP1u1zt/GbfPB7EMya9OCeGeRNb4P91PBQpv+uETMJtL5TMIzUkiigU+KSkLehB+a6ykgb/O92lZJW+E9yiZtk0CsquAyPpKkA/sM9UuCDFZzag3xF5e+244qHpLLLLq7rskubQUaqLHYcqGt1GBUljgPN651r/K305l2jYoPzkBvsEFYM9kZ38EbeYsV65zKM09zqKAH/v6F/HdrXOwv9RpAHix2akg57PPw/N6U7FKYrIFeKgGe2OXR1HfYEkMuaTFX2xLorIIvfewj7aId9MPimmzrsQ0wlgEEFqfeA/Njk2KIwOjSVGocC+ttQgBqm6LDfAf1QVVnBHXc38PKcFCjXOz4VSWl6wJnlu7NZvede4I+F3qivUt6KOh31VdTpTKPJqC4aVzvZ+J5Ra5EdinqLVWfX6khKsopU8Z9qq/gLYK5pP+lh9nzCy6uruROBe5unkoegRiP8a9pOJevIvY3VXCtovRvmPWZ53PKMZZnlCctKy3LLk5ZVFrwrepZTEbqj/ojH5co07qiz5Jqd+8y4pi5O0gKFPoG3Ff1WgXJdWGjTA3wGU8H9giOKqvLIlGZwK6dBWv/2ddlzSxrs06CF8kwngDtlWHeBRPy8Iw18H4X/JyWnwQ2ycEkW8L8u+5KSCSC7b6bStYjed9FgX0rl5NPgvp/PULFjCXxxPg9fVThl/TD/0FlWtfcK3safCNjFgLUCsBsF7GLALgGsaYC9WMAuAexSynEb7CUCdqnpX7ZdoJMEoZ8SoGUo+QvQTwvQIQAtF6BXCNByU6tN3sfKjTbkO/eCeQTMCjDj3Tum9MtUwXoNDwvzyH+T9IpDdSS0kbUEODsf2pzSNAXaPdw1pS609q46Re3ddWG1oc3iz9l6xHtl9jEordL4GS9RDiefgSR62Rrmkb5J92eW3M+rVSGO6hE86IlsJmp84oyQvvAQaV+B9AHQNVBnybfHmB6gWgPao8HOCnal6TvQGjbeurGAace3UQeQitY4IiP38XHrunmvWezc5MslYjKRcorRPi0RO9f6JswSgxQ0kTCqLZwkEOQY11w51x3qEUTSJ2cZyzn+V6abP2XOxPtN/Vpyjmeqw1PFzgd9Uo8sfxO5VlzmPExv0G8EWzO9Qd8Itjf5eYAZx2gdTfGmF1PM8ckoxMu3IGoEiAEzYfznMylEf45O+IM52utaYkwysplLQFsX94pjEV+Hd4kx6ArGfVOIu83FqIIvwDLtyNdGZsTKvwNZV5QRe+ueJAk52Pod0PcsL56V3gQ8u5pT+L81fKtPonnd672o/7fhog7xrhXwPuT6pqCcOwsawXn4f+WXkXPw/9zPqKVE1JRNJCDlHOfFlLcd5SVNGvi38RI6n74NJAQRaPef/WmH1/rzwPP+5DOjnUlNTI3oa0VKCy3g/9aQTaYCnq/5qQTx/osv536ku/JnaDv4+OoOfiiYvH3l3CkX0E/hXnubqc3QzV+uxbOaj0/bApptRw+0YnIC1muMQn3U89tNeWM594m769ZK7+Sz6HMSdMhC+T6PXC33sJkJREnKnBlePDG13LHVpCd46jOJ4C0rWEORXoR53f3n+LH/EX+rjt7KArX4jaBhvsdrSA3XwL9vS0yttJVzS11R168lXOxhtmE+u/mf2vbaNzUzqYj9WXfwfvNTzoTSpclsUjTwLaWb0dx12QTthOPYF541+qdhFNvC7RfwV/LFhmeF0Pc9ywzP6JfT8JeFcBOPbVXBjRBaKg1qdJJvkWG5APN3z0LDUn0hhXlBgCniWdWoW70rEXROHM90ngZ7CoxaqZUN9jQYudR1YY17ubn8AJC9x/JGhxxa1FjYCj26CUaXyEYYawrfBC2/2LGt5E1HqOkiHXMGmFqBJ12D8Wm3Q2N63rEfeFQIjDrxJU7H8pKfHaElVfaBEN5YogGYdMfWyp8BR6tjOoxnCRCnoKQJwi4CfJPjGqSkqeyBeIgjy4G8cH9JtkMOo9MQwDkM0hsEcIMB59DKVzlvoAtGrwb7UBgzf6BjaYN9iKLNkQNus7vLPkDRSv3iwX3WvcahBwpO/BO9TgIKHgQYBiu67QmVG5zt7ga7TKF1aBTs+CqwNdhDwCVXVMF/AOim9wjrCXhOA+8gHC7Idf38Fnkvzu2cnFAxHveWfxv12T0dgiyC+9IRFvvzGhjDb8/Hx7fy0ecooiV417ZUPVHozcfcS9VZ+izam2up3l7NPR9wj0q6iH0GcgzjQEgJ8l6caaqAMavbPhLqS1bS6rha8o7DRufioAym2K7hAp3scKfok4FKQq6ohVTK3UkgvWEaRd5Pr7Y6ztyClHUNEaBWuRP0P9qgrkzLHAdKhkNKsiZ8jUtWgtjLuW5/CFBlOfetv5z7P4/SoBRwg/xtiKCvqmzhxgglGBBgVEeugr6fEaxDfP8gEfgcA0YL5vvRj+ViHaPc1s/3Dt6MWC8hrcDztMDxajz5BqLv5kfWgHktmFKyO8cwVT+VpuT1BFO64mdS8XW5DfOmFGh3hddGWCJroyzK2miL/KUK7qBLe3hCNaOezkvuwVkoD/BoHVkE0vAIfhH04oneiVCilf6nhpaRU20ZZKRQF3bXCH0GGU572hkhpRa86WTyAtCLI9b397ftLbOc8eERfdrIcI9sygfXopi3br7zwlvwf/WamMkg2+E7F/SKRY1VXF9gIaRcyy0O4Ntto74tJKjJ13LvgyafXZR7XTImh9RyR/3iavwX+sX130KOFEKO3nBlkBD9UaBTvCOznzZx7M+BOka5GHXy2WB/ZWa0XDx6PCmztsMosswl1oSQ6Iti8r6eeTmIa4NLpGJenkyO6Y/ptnAPCOWb7Ee+Djrm37WHZpKTueM7xaMyO1GqmEpmA0+Jci0CHVW7GO0JrlXGx+vqchnnxFJtcQUX6mLUKElMz8ezzDiqJJZqQX8tl72mX2VkLEn0ltP7nFNd6BKpMki9fg+knSCk7fOJnVtcTFopYVIXNU/Ys6sg7KWOntD7KrifeJQo06HmqrktbmznxVSOfNRitDxlWWIptjxtGV83rn5gbVZdjGVwLavGGTh9I+a7ip8NkmoRmBXaas7o7uDDzTqi3S12LqRntlaXRvQNYSfsruBO8A38EK26DdN+DmqtiQ9KozHQXqkBlEbHlU69vnUCA+NfiqKQT9VKLFOvbxlryX3mAi2nOKQpvlgKo+zLgGmolsl4pFNa/0hBQnFicwW3iQduDDJeKpi0Epxz+dDcYH+4pMu+uHDcnvsKJjgI9PLskgOO1BJ9c4P9EeCF2SUo+6Ec22CfZDrgqADYIvCfBHzYBn5LwD2FzlR1wL+Cmw1pPAx+KaYg3GIqfyGuDvtsmraAT/AvAv85mB/Bfwn177DPNUnq2Uw9lBBLGdu2N1fTfgdhx4tHlVnd6n94fnOLPYNNONc5wLo0Feokc4Reu0emWj8NR+8Mcp9zFj8bWjtVnwTtm+4Otm+ET1x/Ije7fTIRW47dNG3Mub7TPAzgkCYm8EPo7potXIz7jSs4R3nm0P3QXx9vW9TkNFZwA/hF9YZ8UddYo7x2D+Sk7Sqr/vRqBkkikVQ3HcRnkDDgP4ihzxVM77z3F1vBnDj5wwL/2Q5/7CvIj1CXfCcD986mWEH+h1ZYXhhsgbtpCzTYH4N6vluofyO4c4T6Xwb+OUL9F4M7V6j/XNNSG8j6gOlJAVOegOlxgMgTMD0FbiJgegL8iYDpaXAXCJgKTPdQSf8Jm7gO67Yud+ON/Ye0LQnQL0Ibc37/eNAcXvKv2XyqCvcpzO18L3f2hQxyhtbkfGdtIIOc1p+mNfEErQk2qxrkyAGjN96Yd4i9Ejc6wvoB5SfznS8ERKoT+uPY/4U6m+wtICLn54Fxu2u5Id7x8I33ZsF3AM4FTG4rqOZGeFsNJ+gs0IHSw5T7z3cuCLQY3tIfoDx5rIBpoHfC7nIu4D8AMErvYz+j9vC1XU5HMXY81SBGifvixbinsAxkT/T5GsaZMtCd0F4Go16ltcueXddgnw3SyxyQZCZBv5gL4/2U5qBOncezGulF6BtgvxvssgvbhZJFBSr131yFmBAyBkKuX5zoKKY3QLQ6PqvrP2Fvu7zG8Uul03Gt8obDRl+s+e5ytkMPGvunle8IPucvs1mxo+/5/bHDWDN3Qc3stT9XWctt92DtbPNg7VR4ngFJe4BL3lTO3eth1CFD49vZ4QeBB1TxiVoW+MUphbQvMBF7U3AP4DKI7+NDIb7THfoqO1pH5wKRvw3iFzVf4ocqH4EYRv8i4CtSOv/3turFRUtO7JgfnyzySJsTSSZBv/t1VfaYykQYWU57E2Es+5qPaRJXl3P/BDknxiSuZ0abrJeonrvFFNMUDyN5DIziXjebhbNO051siHj0RWs5F8rHq7XNYo9UDW1RCW0ARlYJ45pcT+QeKX+XLrFx7KEqrsZL8jCdvfwYGDMvuPUkWyeuxvQ30/Qt/LimqXnl3BcQMlYnoSGraUgFn0VDPoCQUTrUaKq4Ehqylqfcky3nWt0GMlw/nM4EVnEPenHOu5b7wgNjZej0S+xwdrxk1MYbCw4zd95z4/ihJJKox7ZO8A+lL5RVcDcCQdq74D5wlR0d3n4JaOkS0NFGm1XgAeKRwfkiHD/754ucEKb4t3oKym4NV5TyjKjgmJoCcVOlMfLxYPLB9I+rOM6OgbCxBMfrWu47dxkpgNG6zI39IqqTVUcLVPilT6Ri1bhXo4LbL+St0l34i1zc1SMeG6z/2GnBf7VNKvSmNp/EINI/cHWNMO+FsiXmt19GiiNHWzeRSJW8xselB97VJxn32t+tBM3k7b32o82IodrXqj8CvbGCe1xIdZZ7Nkk1ipxW34/FB/WMJR30bIy5zjcbqPoT8G3U79cxFjFBqNkC1Dj3Zu4nd1rJkhJp8n6PaFt8LyMTecR7Xi3Q9bIh5Rzja3UU1EkJSPmVwZkHJvR3B1MHPQok32Lhhtn4Uqfjs9vcSnB/eptbXirfo4K81fhUbRqox26XKG3u95u5A+6doP1V5Jqdp83xDqVik/NLqpMnUPsnVCuPB21uk/MUb6Jz8s9TKujzr4E6wfoP9z1H7wWt4Gz+YIm+cLFpmMZB12Zutftcj1y9Bc+ayDt6FGtwpgl01tbNXIkbX7bt31P8VOnrxbI6S27O9WIhp1N8uOrWYpX0yaUaMplMJLOcbORsXvIFcuSwbxfiayqqSW3jmkW9bAw7Jpcv+FLE5/zKZkoyeq0oVSQDXXvcKFNMKd1rv5fW3oiS+3jJEGULkz6N16hOXT9ojmsuAC7wmJe5M8dZbe4tDrXkG/5ePMRY/LjxiYiaedMYevI6RxFe3WWPB76YAHxycN15fn71eudb3q0OprmrJ5ydTELrIi11uU93tv7KKtp+ZU0uMBE1EwEyG0YllYNRrAVd5YAjBDBFVR9wHACuud37juNUMz0DcjmyHvGwmZdsbBLmPq4x7qUqfoGyltsDZdjIhRxObk4HnbOci/Iu+CUUqDtZndD5dq+cWdIbynb0yNSbnPdTzbvBrgEZo9LUBX420P0b7OmQ7nDg8SPwX4kv1nVfZdJGgoy7YXRwrQl1LewHR8CN4/m/4e8EM2URo/p1zrG7NXPj5GZ8v2L4L8WPPy7u3SSOrxtcBPYn0J4QtD+J9sFg7y1mM3sX4/h6rE8StfFG3uFBR5T1rz8aXf/jozH16iWx9UuWvF4s7p0mfjC//Ybr0GKgJewpVz0P0/sRKrgPfUFaepNn07Rk/C29W1bfzT9bymbKLF3Ac+4zwEhXgjfHDjbimLdUjaPaEc/13/pvquq2zyzB00+77KzpmGM6vSF5uCPNJKPzbMtKcGZiiyOt5H3HJ6ZBDmVhRt4wcoFntL2DxRkHL86m81wi5zXPFD3zkpjoaH+2eLA/f+eZoB+nQ1+cSSgW8juTx/c0qjkd/ynPzN5uwxnObTZm9N+syBv22kdUipwfepAzpOtTZyK2Jyi2f3hS9SqdmM7vTBNwDeeX0NmuIEYVj3sNkoxD9cegpHg713CH3ITll6nOQImEu58nzXdO82DMlyBGtD5Mh/WCJcf5GC0549hS4nVcpTEruEia0k7uemAG0MJzgq5jpnfKfZo79M5YeT4YlOXGLep/B0/y4smZ3XxKWbqxm5e83tvqTH7b03d9fu1x/b3VI9RHPH2/3WeBXpNyv6WM3KN+pyDaMmvXA7s2c9m+6KbNXEZgZBG+aid2S7hBOfceYpzflWYm4O7tbFUGlDajiB0nG2m3zmqZ14T7PJjkabwk6sXcuiV1S+seG/woZx1pnF+/b1Y3v7V20bSHWt5gIiyyvhnySAuTqiKvcAM8kXVR1bkAoyKRta9wEZ7I+k0kfjGGhYA9/tGo+iFtdOdy54rjk8hCOoY0uydB2yIPK/cGa6Q4wKZG1k/LP2dlRj1oLQcO8bxbAvpdzEVJiphs0jO7gpBVbtxBMZms12+A8WeZAK0PrJsZcXPfGialibwPutvbpZKRjPNwKe6f6OCnmOeQFYBxiDsH9DygE+ZJcKW4M4x6qultLwUKZMq5WDdD90w8ALpeCdX1SkoX0l0Sj+nVQs5nuoM+RfqH6b6JCi5FyIMcSsCkZCbsNjIa9tsafIdlnHLk79as5m77/aao2rFNoxtHvJV2KPlwRN8a0KyNkRF9C+QxLTi+gPZXGFUHNV8PNVkfVTuw2ZJbALZ7wfwKfA20/BYCJg9MDvhNBXPVivrWAXM3f2PfPbNGktGkkE+jktg/Su9tiU/IavkxXmEZC99Qy+gWdZ7cMgLsIZY0sMssyWCXWhLhK7EMhq/YMhC+IksMfFnLUjVjKSsRPcU+udeermCeYJ29gRiAw1NVA+H/tZ2pBI2hbnDQr7LDPrUyEewRN8+9EG+ssudWJoPrjbwE4yLeub2DH1qa1oJh6DcY/K78Oq16xC2fIeDT+WVeTX4tsXTwqu87+JQPB19h2s3CO37v/qCUrwPZBHli9chgn0E+eRLsHV/OuHv2InrXFYN9Z1L15JoptXdZIm6a10Tc3LX2GIwOLzjr3KyGud5pziR79AtBGpjvLHZlkpf1r+jE0ILTPMEWHO4HqbZ+HtByhOUVrtoVUR9f/Aq3Hf8lr3BbXV09EaAX26Hex1u3QY+YXzuSHCMPAD3sZ4YcQQ1+suUuyz0WPVGTTbqcxu3c0gCTlNNYw53DV+0V5usDS9VAuUFK0rhMQFXB0V0k5OCqj03F80/nrM8WbOYe8Dyr28xt92nI4639O4fHJjzi3uzaxGdrUXKf78K1hYWUSzIu9DFQnzmUR/7bHcR6wrekYCd3zBd6FXXQtYcyjK+3RdXnNMUbUbZ+SJcj7JNZoA8ryjDGFsn7JHLIxfiFoI8+fxUp/z4qk/6LV5O5ej3NcZO77CqTspCXaMva7m/C8TN4o9Um56MuRj2/bpPzYVdmAkt2QxpNPPaEa1aRU+Ri1RKcE1/CkqmGRc0LIMdPuKQE7wR1849c/TB/4420w932yX/SaCIu367NyC7frskM6frtoW7+y2ow5tF6fOHUQKYJfXU1f+KhdHq6qN+/gpsp1MkY36SWu5t/g75103GKymzJFxDTZsC0GTT4P2OaC5jigbffjkkjYAr3sVmS0ZI+iWTjjbsPfXe1Lvdr600bM+oPOkXZ+nlwNwIdZy8KvqM9A/4/oSx+v1y+bNn+ezIg/F4wG0EWN4L/fDAnj0/CVeipNdwgH6N5vlNNzALtKPj1QDvraUv85Arm41Mvmzqb1HDNXgb0icuHkoG2kAaT/TmNm7kxbnmvjN3MFXuTyTM6GcGQATQkxT0JxomHwP8JnWwa+odS/3j3FPCfA/7LBX+fD/3D3XeDfz74Pyr491F/xj0Z/CeC/0OC/8/U/4brLvAfBf4LBP+L1P+a6x7wT/LO/kUmHtuJlIVlm+f8W0BNZulXXo1pycyb1DzEOAk4U2YeaCVThxinAK/KzJtNhhjvBg6WCZxjMvAz/N8F3A3/91hqOLMXzyyuPawmdws4VwLOyfpltrt3lzrjPChvTwFblAel7UlgU3jUZByVtrEvzXMWBjBmwN0f0+3uj3nTrQZJAmMm6nCtKVWo/VDvPRB6lULcBbbvKcRksF0GiMTbcI8MYEzrrZhf3op5xh3cXROjD6G4OT6I+1tPFPTfC56+n5n2eoGuCMiKk2Qxch2YBWCWg1kDZhuYSGEPwacQ97dRQd0QZQmW7GzdZqjUy2g+rvkrDFv0W6j095GQ0n5PcMa5TMfUyhpZi6hWbJHUSi0buRavDNos0lVMNnPTPZo2Wcs6/RrKPd/g1+pkjRu5OhrDx4ugVbNojJX6FTSGhV9JY2yjMX7lJRAjlcYo0S+nMTbxJbMeN3Tz514D00Zv+8070yPKG1qUTJYB7Hau3Tvrl82hCP8lHwLy92ZO4pGS1jY1eYTuwpjnNPsZlZo8qJ8HckGhUJ67PQug5iZ7NCSKvnBZxgWAEuYixwScL3nZJBlwZ6kX561HfzuCzlvXcEWeEWQ6H8rkXg+bmgM9aoGnwMBovqSnHK7ML0ENmfrPgBwwmvuAdqfSHR7znHf779ZnCnJBvJAHrxvjdruRr78CY8dRK+5Hi/YUtYk04zpTDZkCrMqfbNDSF65UV+6EXF9xL1WPFsoW41+qztDj22vl3K+BIN5ON8qpO7kv3XGGVCGe3xdtSNbH0HgXhHjv03hr8OW48attuZB7Oc293Y3vAgd31CHsFR/upxMD7D6QTfHtqv65+BPXlPJhQG+fw/8iGORpKJ8iDWpHB+cbcAzGefoHhb0rKMPiXMS80UGehjwQ94bLyO7WGTC2zfRJiQFK+aQ7ok/MaoCqlvkaeLF23fHpQn3s9uXR11LKuVX0lIGKxGMblspBK5sCGPJ8dxeUcf8MsEBNx1xTwN4eQNp72zUJ7McDYrC/5coG+5EAUtx+VxbYDwakYN/nGgf2AwEZ2OtcXfawkga7xNQFUnx6Ac5Xxr+F8noen3dXGbcrkAS5+wxiKSCW1IRryldBwzSTOwo67CGmMq6MxjgGMSJKcF0L15cRSwiJF2KspDEOuCQEb0VlrSHHjW1joLaxnCm+GDqy4LwirtJ+7tpiixLaZKAPfT50mW14tyfeOfjsncE2maqMlmeBMYCZZVfKs8A8CGYrhDeAWXEU9+DLiFS1k3vNlUGSSbBW7V60i1QyXTl3hs4fnLy2Imcn13Scacc3yR4U5mf+2AP6UutThqf1e+1PV0ponr70lhge1z8BfKOc2+8P0lilqxhaZImXSUXuEULSybKCKru0UvZSCPDj+9yyxEFdsuZZNxwwlrW58JWuR+hs0jznm16RapF+IeTGLOBa6tJCmae7QOb0lhFm1BRrvEM5Ke7g/IJ8XgXt8aU/Heqyncfdf3vts/+0IhlzfoaAd61XT1/dKefmC3iz8SXZ8bu+Z1O/suVB6zf6kRK6+KK2JMKqc2hbPOxl1XfTU2HlXLb/B9sUPcgV+7p5vjqI9V7vBHr3TDmXLmCNAEraySlcTNpCkGJY5x4Yez63BmcU5I3yV6p4jbKGWwF9bXxnePNEMhvybvN04UtKdqWpqydSjbOYuIcaX1eS9bGy6Z0d9H2EO2iOBngxTrSug54XGqyH/i/okJ38IKGsYqjDOL0c6vA7IewjHnf0+vzlNmzT2/e34r2WSx6PlrcAjZSG4Prll3d1gL0G7Dhu/Ap2PF81UBsrn64N6qKzU9/13OSlnngjUm+cddaNT5foCc7rPSesjcwDHTuHZBA9aYVc1Au52Mi/e/PTpzfeWHkY+o2i295iUjmGK4AuFOucVi+reesik7S/oIbLd0nrZRZp4sBbNLKXN7a9JpRul0ekelVfB3ifFvDOo7sZsnisxb323abdBbfTQEE7pAB97phP2lTG2QPIozfeiDiMsXfqu+07K7v5pX+/fV/FPOejtEW26Et16K+h/uXcBCG9IXwZtHE8v0nIkcFj1j9PqSBNiKHgm4jQ/h4zTe+zQ2wa0sAYIlBBUQ33pAvlkrGHkQ5WQH/50d1lj8aTJ6Z3HNeC84a/vWw+Ce5+mbQKOIm+axDQ/2N0HnWeM8KDMI/q76c5zRFy+gPVQXdwnwSWqhcJMXkYPxbqZ+hyYCw4K4S/G7jPcL8Qfs091zBPn0fDPxLC9we0xMt97Lu3YAe3L7AAynOnJ5tUc+YAq9rBrQ9o8C1MYee0uD5fwPQxLUeufsyf8rRbwPlCYIoQ77B7kl5D06sUwp4KpFM+UcZ978XWGii0VtYhMdBXuh6hdrkzyHD9YDqmPSXAzQ1s5r7it1+ddcO96rjnN17sid+NtDnYijmYS3MQTPM5mrcw3R/+mL5ewDOaltfgw92+x28OBFodenjxVewnin+rJ2E/WQV9YPWXGWOxf7yixX5UkIv9ow3s2Jd+FPoI9jMc7/A+2JAxsfLJYIrG3P4ejejFl1qZlPcNJ/VV/B05UrKNsDSHKe5/GHC9WgX58nuC+frBfxTo44QrJHHgpXcM79BzEPOcUe639a2GQ5TyeoSYHX7T0BTrNj4mB8fI167Igbb2A+xRV4M9DHij/NadFq2O5ZWxXX83vCZgu+YSqfYaGmjP+kjAth93AmSNI4OvsGrAqU0irxRUc88FZImmSy8bagXIL1wWw079dpqPNwXIbfT12Gzgbitcq4ZO72SSc38fmqQF2jnuX9O21bAVYLG0B12MarOhXP8CpLpFgH3cj7FZGvvvEHuDYb0Q+2WIvc6wVv8MxF4hxJ5PY4fS2C9C7GcNzwixN0LsFYan9I9B7IVC7Lv8GE/lZ2h5mJEbbzx++EGDUYBY5lKRBYaldPzJESBS/KrbqDyZ5P4uT6rm7veLSHbbg4Y5Qh3oXAsML9hm3dDMQfzTaeh8g14IneSaY3jSlvt7As1lNj0zea8hVwjNcBkMD9sMQh5SXAX6ibT1A+5gDn70beIsfi09K436AOgH6n2EzuT3SNSbuHJ/161bjfGOzC7w7b8jE3vBxhuTD48zDBdSu8GPMQy3jdE/SLptGKqxRvTdwWJLHeQb+Dvo6Z7ETqSbeKCbPcBVw27d+hnTtYm716+m2kswtx18DoxMEVBfjUJut/s6yYzrs7U7uC0+xP+ZtQvy2wQyZP/9lvjmab8siXe8WsYE5cRG+Kd/Ei3/DP7rx8bKXwJzBMwnY4OyYzf2HzBx4L4TjA4Mnvl9bCyeId3RyiRlJxvJDtAkw2bk/H488yA/UhtqSDIOWVOFbz0eLyYhMM4fCqiKIluVJ0uIGFx9Ad5mBFn12UXBezxG9WgLBswcsUY8Qnyh+5rIKUlKShGphl0JcF8FNnGdvihD4Vbg46vmTVP2isOm9v74At5zgacgww0iVYKRTRm5Yp4zlw/Rh9L+MMyNr2lrtzIqj+0JIZ0FYOLGAT9YFLwTQ2IYspbNEF8Q44qKNn66SLViOsYLH0fXw6aZybbWbSS5bYFhoS5+axmn8y4wDF4zlDzaJhoRcVE8Qm69j950psuXt+fks2fxdHnwLUt506yZjJrlE+7SGMu4k4EGPkSrbhM1pxv1UPYW6m5pO8nHqbC+6nKjrPmGBj5BNQTqrC5Xbm3gB2rZjFGdMV9LM7KsIrV6xSR6P5QBUsrN//LsZMNkfYJRpJrr/CwwUa+6MkEnqc/Wh1KfUwFJ/XhBdqpziQFWUpdpmDctvlcs0/X+uFqDt3Ivb7aNMIwWcBwIjNSn0/ibXAOvNPDxWnayJGMkfcdQKY4dombuAPwpAv5qwJ9Ed+qXcyUuBvBvtg0yDBNwlQaG6C/YYg2DBffaQLy+0xZlGCS4nwkM0H9qCzPECe7iQIz+FNDoUqGNnhDaaXMEo9r3SJx8BdixvW5kxsqvjg3SLs5FxoJ7LJjHwOwEcwLMj2D4o6oZ6jXqNnFGOOiJIhV/MsAd9G/iDnuH6IcY7kMaWlkyDe+A+2E11gObnLxiGDl/azdoxFk2Gc8Fqdewk9kM2QV8lXoH951nE7fD22sL+oZfwFKHGkKFMoQEQvQhtD5+4NVrPvwTvfXnHfMNSsJRCZEXJBSVcaNcIYZ4M/aL7X6ZIb5IZhhapDzJtGN5n/tRKcf6wPJjPRTdWoOQvXiktcs+zSSu7ehh2ZxkJimmcSg55lhehzPBXbyqVPeqvqGLH/laF6+tmbl3B5fIY6xkPG1CbxCRgS2ORx7GOZjmvHqLnSnJr8f7WAh+S+5wv/hbCF35OwMjlk5YRd1tZuu+sTN1l+xMYT0zOK8W4ovq6L9SXJeNI1oe7ktBPHsAi9GRXodnRVMdW5svgNvmSK3b79jS/G9q31+ncaRV7ncMbz7gkFWmO5oUuGbT7FAoDji2VDY65CCXrvPXQdzd4H8R/tPrO+yRzcsc6aaIvuxIm0NhkjV38MyVq46tpi0OM33LtsoeZXoZ/ukgxy93NEF6CtD+KusOQJzz9Aze1rotDqbkM4hfZVeWdIA8gvmd4DilYNTMHly7ZGpimthecXhy06fxkU19v7Ill4WzyRF9BZE78nENoFPwwXOsdutZ6mJMysycjB/A55IVV77m2jDHESVDjApLFWi1+F6woiXqC8h9+PZrUUxu/V57SyXeebncIS9h1DHNg/POCid4P4J/suCOy8RTu7Mz0O9Xa0yTnDzjTHZrj+MKUeattcFk6j8QdJvrnZiCojGmObnlKnFC/t/HUiVF9MWHvZj3LbZaLxtWDzXa51huEoPd5qgokYxRpqMf7hzqsVbk59jZknDQwUV9SpG4Tym+ZO22l9Yx6lZHcXPh0Pq3+9cYpbU3blFIFVAIjlgNUFJoBQVQyiTQwwuh9fV7KNVY40V1VkhFUiMCDo47kzA/4jrcuxSbN9xhViAtMha144Bpv+N1RZYjVf8GlB7aFv4pCjwx/qZDAm1abspyPFYCbVqCq8tXIde4uowry+ucj/i67AqTZA9qdTWIrx5yov86SEuFQEuF2N5dQCtZjuU0B/ugH2AeXqb3UkebMCfPO86U7Ic0UyAvbzpkplcAbr+jHPJQDu79kIdUurL9Eq21ECEPmP4dPjwjJa3DVGLJFQdT95gNX81c54zxmR2hdG/ROme4D09T33B8TmsP/BUjz98QdI3h53Npf3wbyoo75j7Gu9UdRoXJ6fGxmo2/s4eDsEFNZSPnOjS9TlF/GnpibFFeXVh9bFF+XTh8SV0EfBnVL1f7Mcd29a+6R3YF0xju2FqpOFgGsJFAnbgHuhyo84zthkNPIT5tdzr0le3An4NvBDHMH3tpDeu77N+amFrNoVk3/r5yE8jRWsIkDbvFjS79rXtvt/2tuirusg9jMElrG6u4b3x4blYCNqsP9yVE9C0Iu4J50V+mOfoRv4VdyJcqf6Lc6Tv86r/Hb/PPlEf9gPbCO9xb/4JTfWOuZxS9YrYGaasmtFcsmgCUjn1JVDvB8WklA7xH0RybZ3SkAvdJbWYtX9MenAI0cNqEfOmAY38z9ArKm0ZQnlRe2exoVgT50p3eH+vFezCPP9WL6jB/V+qRq2Ff/rn+MUel6XnHKeBxI4BjjIu8CrzuKsj+yKMwne/rq+wR9K7bH+pHOEKAlppNyJ9w18IZB1N4FeAw9DLyu0LbbZDI3bBMXfUTHMNNI4A+PwGug+l3AKVj+dj61UCFkuYSx/LCcoe5pMoeXRKsP8wt9CbgMxoHKfwnpNNhjylc7lAU4ko60oDN0Qz0PQL6naKyz/FYYZtjuqnNUVAJeAo/hXQwb1X2WICLAzPAtLbpA+Arn8bLgFdGNLXd4pMy08LbeKSM8sj/E3hkmikl88jNv29ELvmdFfdIiGxV9kGVHfZEKMNAKGG8vsOeoK+yD26usg+BdIZCmsNKBh6K+iqi74Vw3PMc9RV+dwG+vfa4ykzjlzyjDXJQzX9w0LWCW0M56JGb72xE316rpik0WU5WOCf4FlAuGgF03M9H+2l8rRAn1cdofu2849DARk3z2pZ3KD99V+Cnysgded8F+Wnkq3/w08ggP01Jf/UWP91M+amM8tMU4KcpwE/vgDIyajHUwR/c9A9euiVIw2FdUCvIlxvsg0xMHe7v77IP1TfYEwq77MMKgbZlyMO+oaVGHvo1jRtvYi1/xcMa7Il/ycMa7EP+g4eddON4GkxZBXTVZU/VB3EnQ8ppAge9w9SfOnK54A5UNWBLMv116sP/R+op/5H6Bpo6pjGNIG9+3BbkmSvdpxyhdUFe+oT7POWBPbf456Rb/HP8+XO3cc/Tt7jnIrxv+Hfp4fN/4p6+Q5frBtb/k3LPrrpBwDG/q4uH75W6BPh+XzcYvj/UDYHvj3VD4ftT3TD4/lyXSHlr9y3eOqALbHSVVNl1xyHMQdRX2LOQp24G7ANvnX1UF71r69+fhvy1uPKQjZ5Zm1XTWkcyDBGWwQ3B2dutpIZEWqIsTErkobdyh3Wm1IdZ1PUKS3J9qCWpXm5R1YdY7qiXWRLrpZZh9RLL0HqxZUg98zLIhq/rSUTLVJJNAtwPbnZct015aICB8OF34f7yKWFv5Sb+/8QGUlZrEF8mCeLze9nx39kYVTRdyfn8uu6Z/v0xTMabrXHtFwwXDN32i3XdvPlILWrLEjAi0JjHdfTIk/F1a0Xt78B30Peog6mMb8cZkbDa8NqI2io+RyslHXz2vlLuG//HtzRvc7zGIa9cOPVtoLQ+gMGVOtz5pQGKwPOoTEr/DkGU79mkyMadnCmArwrqSmOa55B3Qc528qXcW3683xG0dlY7eHkvy5qdE/HkmGK4o6kETyLiqcmEZnlTWMvQRuS2eGsJUjbIqiZ8N+M1cB8B8w6McfSudaCwAmhD3a3ZnfntYujp08Bsyu2y3q7D5/SdN6N09M4tdwe4I25z/9OM+9uyrS/SGYm5zm/5bfptOtCFuHepjl/F1flwb1ttwrqpOBfRSo7jOuVy1PO76I0fOPeQ3c6Oe+emaePG39ceXkfnHuY63+XX6FeDhrKZqxEwPeeTqVJv7WbAmYuYXrloWm+o+ARgeTv37Nkuu7xkr/0JGM/OwFggKQnO7X5C8+oEWZ/pazBnObaUtEKd9Z/1iTnfYA/9k08o+Cj+5MP0vWJ2Oq6W3BDcuee7ACYL+MX/F9ye/0rvr2Jt/RP22PO4XvSf2Fefw/O6rVRyCLbbinNjhbpS8XfqjbZ+DhF5Gdc3+vc8hJwDmfaWa+PNnMPYYvfcmHK4kATbjOULyVDaZpddwZo+5R1aUMWd9PZTaKqNHZdqgzIXOh0/F0KNFgZxLTwMOf0Pv1mHGVWGjVWl2/A+OrP+ISmOTzjvqfomljk5QZZ1emacfNK4P86w4z0nL44Lrv0tg79IFWYTq0JtElWITaqS2ljDPF7FrJi+dXysnC3YxM1sZ9px/mUTt6DdedTSyqYyNTISTpjkdGIkVbx89k7uPIyDc7uSiKQ5HSBmBBr4aTnMSF3nSX7Kir47x1tR4u5/g37VCaT5ftfkE1h7/S7xCay9ftcXx4GW2Y3OeP8+sMnBFutfc1xDPFy6W0nXHuc4CwPBu+g2c+NdKhLb6jw5mYQJYTMCIhXkQBuil+o2c6kuVuXhCtxMyi82LM9+oU4+Cs7lzNrTKiMiy66CBn67VmypBM66ifuXX5zIWuIu7TRUCziTA9sNVfSVoM2clw+23xUPm6IiCZTbMSlzCK4al+CJHafXLBkZd7HMYBagxQGzAffDIXSXAP0hQLO7d3Kvey7bQvsCmaF9UlEsz97BtrFaS67LKtPg+/CM84I5vkXMz34ogZeq5h6PJ0/pqrhm/indrOQ5fKryeee+gJiw42WjHFZJSzGkpyFznF/4JS3L9I9SantTSG+bB1eZq7hyz2Ih1jH/w/qFNI5FiLNaiLPKI65n64IlGuaT4T1J1vkANcf5qn+ufgbAsOM2c2sEqEUC1ALPC7YCQwKMC3iLH+5KV3ZKoe5j+MkEU8zXz3Fu8E8m0/STBQwP8F22ySRHyM8KCLtLP063gGzm9ALu0QLuEZ7JJEuItwjiZepH0HhZQrzBQryBnuQ6Uf0ckkN2T5fQlYqZh3GvtIbm/h6ATNUP1akAMkGA9LmDkC43xkuk8TIg3hB9DI0nFeL1uNnUYMyf3BJVKNC/m3szIFdlEHGyNMnDPcYrC16wiVLibCNJDIzb2P+ujYu9tV7rQroriJZj/woHMwwM9sMC+BvHB/eVYt9cMZ1Vi59ZMX3F9MCv8qNivRjqqoz7KMCo5CcP/CtW7hgZLcfZoiquxaMiypMTjjJqxqLUK3Ws6iVurp/RRH8bOXPWjU+fzfn9tLKKq3JnGOcdZ6dwVujteoWujPsbrtZrxa3akyGGp52saDDIK5ytZptcbl7EqF4A0/xUNE1nK75NdDTMIC6SEDzDyKRKnznVI8o81SMBIxvP9MlZlZZxpvpP8/xsvBOSaT81Hte2K1rDiZQMBL0vPtlItnM2fynndr9edZAP1+K4vYvXas/zvLKKj9bu4sdoq/jIoio+RpveVkJkwEscXlnripPi5GIiKsA5un/yPHPThvNe2qMfF18K2dkqJaPPs8WDC0qgv0b5TvIjtX0ZqVbcA418BEY+fNtB/2PiotxFUzc6r3v6eZFYA/4jQtpZlZioCaMSjwjvNLQxScmEcZZ5RST7eDFQWYBrCERBDbFJ122S5Ju2IC+UH2WJsi2uoJLL8sTq4gpWORP54H+08B/Bs8mxuuWqVc51YIvWLQbb82BT6h4F2zM8kxQJsQbxkTr8x/LYqkx78fEYOTs5WOfnoP6WrAE7/GOyYuUjwNwFZg6YHi5aXvN0tNzHBdf/txFL6yZyt+4izzDbuff8SPFPWScbhhlLhsqseJ+1GGjnDf9IsvAKmwqSwexungd+ZyYhRNzCWAqJqEVHZpNVzlJ+2tCYzkc1IZ3LwSzWhFjxLUwmtdfGpnls7HCXTVMQ4DYG2NQLtmyqp+NusxRdqiGshkkOr4mo6UsCKU59kJ+iPEZvQY5ou8PAJKMsFjjebR9mYka1gmwXDzLRdFMHtMUHx/eCRsKMwhUwOfUVJ0ua4gpAvzVt4t71bOJ+8iBnR+6KcX6y4fdXWzjkY3KASXFCm2D9II3uzgr2i91P4TnpUxsZhgcjz0E7ttvNJ6Ll72ThuPYS13eMaedx3z7YI48H7bFHxWslRK6tb4udwTh/8OA9lSqjqk1sfNC4ezqjVhdFGoD+xw4uCnA/BkStypOM0+3BFfxjfkmfimGcL3iToBdK9TKdmmA/xDlhph37EubvM6FvKY/KDEOMbKaESK1y6DfrKY5T0LeVJzGe8uisG2bgNR+5cD0qwE31Y/hPAQmdA5boJTq8h1KZU8a9dxJx/xwXpJkA92r7iqMBbmdgqGGwkR2bSCRWJiXAVdHbQuNnaoyaI2LjkGIoC/huCrDjgpxsIx/gngssHRlzUWvMHRrVWTaU7Szjtvk0RlwrHFfEaC539tdBRtE3tkzI+3dWqy1YFxLSgW+NRAR5BqtZAVwpgii67jWO1mmhz6/0qdpGUduTPtVxRoX7WALcQx+kU78lPuYE3lOZFqyRvsA4aZ9EGtKp1qdQqtX5MA9hV1QgPwW47T5JovQS7tMbSkMn+QJcYiDkyhCK6y7AH+A2BCQEyzuI+mX6toKfLBBJ8Yd0xhjiaYvWG3Fk6LZFAS9kVJ/bAtwNf/qwosQAd7//OpRny6vR8hygI+yDWLZpAi9cAH/sf9j3sLyz3bHADwJcWUAOPLgM0pASSWfOdUN0dMEL3CQ/k6I0MBZ219TrjUvcyWxSBGga73v35TYWRV0Kgxap4r7gFfow3cgiLM9Z7wau0sUYc3KRL6uIx+YBeo2olsvHT4iV74b0OjfG0HxkH5WCFFbKzePxTtZ045jjkuQkIgUuOdStKco+mQwc8+S17ByQx97Du1n717fbWpmUiL6CMC3GJvLDC4h815keNm87l+D9RwHejbEJxgqxRtMuVpkJm7YvP7wziRQAd53tVrPT+RTGwIuZB/PYcYkrnTbtoXg14d+6q7mglDvnHQP5OePXHjqgb9RJ63G8KvFKIbzxrjch/DSEaw+Vcu/6FeD3xl2vgd97FOagnwGOodQi58e3upZ1zrpxBugyl5cRY1uXPcR0zGEbjDydd9gUuAME3ArGOcwX9jIzeo4V17ix9jK9reTxdd+2zbqxA6DV/6/QrPMFF5782yqexu964uUjON/Usq63LZiyFGDX/CVsMplIgvB5vj/gP2lDeCYtom9kaGv+oM6FfBoT7Gls1u+23eSIDfloq+0x/WKa0+88n9oe1T9M7Rc8P9hKuS2eRwqQd5tBdtzgPOabS3XbDc5M70bn925lMmq0MGoAv833iNRVfJ4253pg2kHQhyObJGoNSOK5WqRhvAUxYy2eibhK7zNKIgvITk7CMxrJJZRgtnNb/Q6bvbNl3ePHu/lfq3eTffnyzgd4jTKxGVv5SReW5IYtqI08pcASkXzG+b55Ia9hgv1G2bciSkySrJn60bQEqz2sOuMZvHdlqjagRh1dQ6TqyKaDNE/NfpxTGCk/lAsjq3kBn8ooBY7Kjr9hU/Y9FcVak/UXbYwm6pKkOYaXqwqPS5rYZBZsYtVQ/QCQVYgHc/WerS6/sb2O8FibobOcCfI6D8+z9dPyh18KdYt/i2zCesgBOsqtDnBP+dl6NpO1OGy33nOcEyefIY+WT58QHCeWgX0hGOSfVywSZiP4nwDTB8bM7fej3iy8Tk62kfYb8w7PI1r9GCqJ+dw5REc2OH/0jhBa6mHPRmc43SN8N7TnXncpNyeAt5enCZzsJzerKuUe9InUJTYm9a1cKdR6KrOJe4tnx3O2YTNUxu3cP/0MlDhepyoq4750j6Gj3ntQQxXWQfpYXTe/aF83n9eK6Z90M4BtnDBHjm10ujPYQt9CzYoTJZdw9yym2+jGuoNaaO+vhwHZwfKvzg7ylFr4a8HMBMMCf4Rx7yT6rzoqpvfiyICfM6o4otRF68s4s1up2s49689pY9TiIvEzKBGWFclW5a/avEphiC9StYlagzx+9ckQkFsxD8ug7CKQ5Jh2TPdYVjBdrHflUbGRyZAQ8SUl8K6BvKpoCbjFlyLAFcUXFb1OXWHgkvP7in6kLjm4WP5KkboYXTLgI+6AarHyJO5ZwPdpcazHdwHwTnaUkRkjUP+3pRyHEm+muqhIcP8fdS8p2ie4bdT9etEVwd1N3T8WqYqD7n8H4RdTaTs1fzGMc30hrNlYyl2mK/ZD2pYUT3Oy4iWL0f+KsYoPmV3KfXVbmAjCsDeEsKriYGj7baESAVIlQLbdFiZHSDWGFmGotpT7+22hSggV0ztBlUc7+U6thCwoVjrljLQTb+uOgxoqDbCqcxBSWHxWJjsv6dOKFhqjwP+5W/5zQtDfKEooVoB/8S3/WuqfI7polIL/Q+CP69D9dY11bBbqGWUYVZuKoGzCOJccU9L8SIiZY3yne0ay5/gvlZK+VnF622CQ7jFWKef7QJKcQMSA+RRoD18yiBvHqxVHtckSokyNBN1hO4yRI+APuQb59p+8BiXPvhywtwv+RrAf56lE2rcG7EcE/1awH+Rxt2sg83TPGDCZ9wPfXMWmgU7Hn5q9mf8QzEdgPp79Bn9Mu5l/D2S7NwOb+feLNvMnZqMcsWJ6qAFlGnERc33kMib1HK/JasmVXryfl4SVch1+dvxNG8Zj2o9NjBXq4SpIXNu577yomWEdVLbGEQVhiahxGzfaJ2os5e5yJcHI9zzeT9vGVItaxFSqK+OsvIooQLK8IPRRjup1A2YNuHfgTJz1ZS1MShIpoTOtXwfQhtr5V9SmoXfAJxG2GaXj09SmAFs7tYUWsOMCuN965HdWcasT8vu/7ojE/d+dUEroORlTO5lUKLeR6VOGjCbBskdcVBsX8JKMB4sngqQFUqEm5KZo9YhvZXnseLvt4SN4392sG6KVIo94Gt7f9LfcqM5z9s2mXfayktWOT0ySm6Jnb4CkH9wFindA2W1n6P3ecjonL8wAKZZqGtuXqnAv+dPOpxm37SkVb8Pzl3h/G+7Ta3VMrXQ6Flduaq2yM2Hd/L5qGZGlIkcUj6pof7NPrJjlrnTj2cI3exUhIb3TJSPzZL2nJe/lv9EXLwm9fK5HxuYSA3BxM8/ecxpcfTbk6l2Un490D+gLjEfO/++z0TNlfftCmBRzVjLJIHN+jQ/b4Bzqxhe0VgO/3+As4hHmDEhiKKducEa6P8hFKdhmFfXvUNuC/Nd5D8phwbu5X2qt4V1zcC5NSfnIIKCHYz7s0xnHy50sM0C451rUPJEYoH/s8+E5wq3m6PrT/I0xuIocWr+kSL5XUT+86PWi03ax6WW76NbuWvY8q+qy7eL5MUNOmLkczwbnDtcEYaSa5cXXN85RCPEtiEWXWdVp+0bTabvZtBmG1W+gFfG28Kt0laTU9K5t120vcv2ra5cQ9zTvnINxJ9DZ0qvQyqU0Br05sB3feHSNwdbc4MxwTYWay4b6SXPhTdJOh1Ex9dfoMEmfkglwcYEi4wZnwn+EtEJISGAfhIT/OeRm44oA5/a/aGNUxbannU8yy+g43xmzZCreRaiFsYvpM4uYFCZV3Kdif7wmyn8x12O15HLW4N3J3CwJGWUw21nFKbtIYbaLB+fxqslSwtw8U4w0g3tgmDSkJslN58rh0OPYWuxzbF1In1m8bwJgbNkLGF/J7bOe5q8sPs3/tHgzfw1MD5hfwP1rKdQNmBulSPEz8i9ZYwzAvZZlFEUXKGeVche9Yk1lu1gNfjIwWVLkLynnwfZ6bsjFJEixFM++jCPAaX6zaYg4OMfYfgp4A/IaLKfy6Argk0ySXPsil+2Xgq6NL1ac7lGAiQOTqAaOCnRXk+s8GtWpY6fFM725MSqtPO9sD7Mc6CEfyrG8LPcHqJ+bVufJ/j2wtlYJkTVKagJcYUDWGOC+CDDJ+GJIWktE3zH51/HyXpEUINkWqAHVWPOI69YkQg6lNb7AFbj22ssrkSvdFcDvoUDaQdDTHQWV0pfxjdcNztUeXFMJrhd8KrwGv2zonUQyWtvJ9cghxrLbYgTn2Rd14cmINMhJXUB2GO3S3QFuVwBtyAt3BvbnRnf+zoT0nmYYdV3Ch/GTsIQtNXZmnSrTnLEJ/h+Cu88azMP4/0ph1HlGtfzWflI8BSTt00jlfSr569aIm39bS95KJbLDTBqjPpKLK7O5nSG9H7OS3mmx2KusFGsMH0ZEuFuMXe+c759G/gk2m43NqrFp0mRQc3yozCPJCu09HXonmZX/JS3tedon73DhfNgn4D5Bmkk95NZ9LbhqU2UXrVvv/Fl4r08EmIf7P8rvhbrvtaqyvrURqLeQPlWItE8lbbXKx83Ib7Yua2GGMxamPuLm9jXfJeCqApM6M//+HnlLbKe895+srDf/Vq7XO/9Bcc8GeXG90+VjxxPIhc22AKRf9NvgtPJS3HfdJ4laBiGNfRr5v63yCao7v7IyqaTFEX9nwru/isLWOFe7cAV10eEPcn+3qsabRzmtIwhpkux+gbubZ1Wzbbg/G+nrw1bQzIDvBbiRfhW0aLpfRe/+/tDPEtVxc3JEr4h5kbN6qY01khe4RDqGB/skcOLQn6DvRfTmx8v6zCGz8iM7Oagr/hrWzRxalvm0nl7y5cHfYcObW362sqqptP8E700H3jvmYGsEzk1mMM4mcw3vnsqMzHG+YS4CzTiu8UWuxhvXJKWc6c1AV0+8Gvf0dvUMVHfQ1bQ4dfA8OCPvoGuQsm2ZJF9PQEbXvtbNK9vwDe/B2zZxPd6hgAW52CbAohKwJApYhlJIxDBBl63PJAiVDFBfeVOapJTDLQcojQCVJkCl3IIaocsQoEYA1BEvqy7n3WOkN90rGfUYkloQZgGZzIMjYxzoqnnx4uGTyVgY4Zhd4SCJ9PBYZxuch10jm6bymyPCGzt65NFm7v+88j1mThPQtIW3BLWITVy5d1BfYEL3Wby5/YJVepNZOYZEgmxR45He9IMdJY4Xwc6CHWWOcg+Dt0JSfuUUZBkV8KzZYFLkMfKtYF4AswIMnlkzg/+qozLg2Uopk/IN5YHyi8kwmiJlpAXYcdKboueu20Rvseo8XnKXvMDM1XuTQLY855cQTZuYSPVSHeZUC1JXUNfAu7B3TAymjfPof8hxSwnKcUXj/pDjelx/yHELJt0ux72I2gWV4/rljh0wci++NXIPoiP3t64GfpA2k47ckbfGfBmM3Y/C2P2RC8fud83d9iJTg11RGQFj+KIxGsfwSlz/wvX/03b2v8bvSzB+F41Rn9j4/7D35vFRFdmj+L29pdNZ6CyEEELodCfQJCydBDSyhpBcsgAJm4MsGhahQdAACiEKBIkYI2ikMw4QkSjosIiTZnGImgkzBkVHZjoaFRUEx6UJ0NgBwq3e3zl1b3cWne/yvu/33j+//nyq65xTdWo9VXWqbi18iW+T/W3PNHH8fowI4zfbY/xmbldV4Aj+AIzK82AEL+k1gs8vPw4j+LyA/3/ACC74bSFz6Qh+mfxYg6O4arAwjs/vNY4vouP4JvsUD/ZVeCvOJvskD854sR3IR2xvfrNDHtC53qQ617PydfEDc2TXz8rfzX0D+tPgi1+0q6jWtcl+1sVOPAtYl9a1yb7GE9Phuwe1ri8/61sk63zrCWawrLP28XRurNj7lXiwhT9B4YMu5MJeFl8222Sf6XkrG7/gW1sfAr1gDNUL7g3oBXmF0UrUH3E87K6TV/FLfZJDFfw6F8rTW56eOvnTfJCrp04u6Mclo7r046V5fv0YZeq39OPTv9KPT/fSjx+EEl8o6sen/0f6MdV9OmvWCrqP4Td0H/s0GTe0l+6jprrPDmOX7sMMkXUooef6ygc1sA7qYi3qPHshJJAY0G8WgJ5TAmYRmMWAL13TQoxgVq3BHNTnXm6NAH2nZGlqiTqvD+g7i4hf3ymRgRklx3YI+k7JqC59ZyDp0ncgZzsvQPvF9oh1l3mq6A7kKvF5/gOHbBrTeWgdk3TlanjubkgRfnPy6zlqiyFp0eTJsTKXRKLJ+XeaTtf7Gcc6F22SccpDQaDtLPIpYUT6xFf8J0HfWXCM+f3n/fvm+HUdQ/rxzpott1sxtU/yn7l3g+8pvt2H9tt2VKOuwySP40bQO6na6NjK+nrrOmO+UID28Bp3ukPRZ5TF0R4Kvm56e2sjiy+lc5O4Ygj9ZV9YhyYYMYzrRR9CedA3VfsacqMtRdfOKRld8HU5I72ulPw1tiCg9RgyTkBK/XrPL61Cehp/FZMB9J4wKIHAGy11ytGGDMNwWUemjDHVge6TtHH3W0M4ZrDyqNylGOPXfziLHOQXeyQnHXlrXaj7fEVj+dIxmcPZUDu9S/A569nrZ6XKI1E5QR32YPYehelwTj13LvdjC762RmgJ7Hcr6rAn+QCwD7jXu2lAEtCAZKABLaXhX2qXge83HUzdXqoDXWtV1BkyFKavQA9SgB5kCDpKdaA3W5khYZ0l5UV2Q0hYZ2yZ6nqQQtCDYmyhT07LhRnjk4IuFOKSL+nShdJcgp6F8DoH6kKh7E9UFxJohW5BF1KALhQKulCm8gvQhQwjPwVdaHdAF9pg73CjLjST6kKG0aegJn4BbWj34aDdT/J/drGaXCvTjPqQuC4/RZBD9Sa/ZjTQmwe1HefNo5rREdCM9I0o/YJuNJmIMGhHT/Ivuvbb+j6PGpJBpeg8tPEg1OQjnMolz1R01mzoqR/91dmlH8kdfv1IMfxH0I/CIH7/yIX7SRjxJ+hLi9IONIRyfaHPK7W8BO2dGbGq1aBN42IOVfMuX8xhoa/Yg/ME0E9Q01GJmo7Sr+mAHSfqMrGiLhOjM+Aaoy45f3DBZXKoBkz9ZVLVkMo9zRcSHHUWp8k63wZ9ZiiXkBcG+ozWE/O2HPQYvEc3HPru7e67NGdTPWEdVco8MjssHPrynWQS9OUfOvXm8IAOoyOow3z/mazz5NqhVGNxu2WdxwFGjeUuwO8ArATY7mY0Oqq9YH9vhz6oFvQUD5gOMD+B0UGfhHpLd50F+7EunWUp1VlO99JZJhEcY8qd3XWWrfyXPr/Ocjg0QjlijF9nQS3kef5d16/Xkap4lRvHrP40vJnOnmPWVv6Y7//eOlL3ewrngFkOZiOYf7fOUcHn/Nt1jgp+2P/2OscW/lPnJnucuM6xyf6t6//FOgfMp4iwzrHJfpz0Xufw8vXeEuMm+xuk9zqHlzd568FlN+m9zuHlt//mOgd+z/B/15NxWNapdEzfbxvyfPc1jW0Ncg53NDGdHz3Se0XDy68MrGgcgHr476xoLMj9prVPYWoJrmnIbw1bjOfP5N/MIzp1NpENYDN4GMPB7WVp1/tfzd37FVzHGDVW2H/Vcz72RmA+Vi/Ox6r5jz3++dglIvQjCt1vzctwDjbqJTAwDws1Y9+iwb2pBVt5ndc/F3uf4C2BQgi/npONzvdzjQYupdc/F3sNuFJErl/PyfQBLj1w2Tw952JJdC6W4P31PKyKT3YKffN1Z/d52BY+1YvzsKWkax62lf+r57fnYR2ernnYdU/XPOwnT9c8jPYp0LfsB/MPMCeDIpWx0JeFgmGwf/uNPq3nPCzlN+ZhW/ivPNgHqUnPPm2Vx9+n4Z2mIWOFfghfqNWYQ+m7pFv5eZ6QfFVeqX2zV5UfAvYLYJdqWG2p/bKXSVTS11VL7dv+wjQXT45SfpYSobx5O0I5eJywNyZ7nLAX5l78xpM4KG/QtJ38bZgb1S8K/mZA4cCCgTQdeo9El1qKX0f+tSL7FrtmJ58jfkHQMNX8q24DhfMA3u2OhP6nzVm/PAJsi5PRXVnOmPoU6Djo9zQm/o8uKZcFaQ+i4brd9St28B/5/mlldf+wzv0sQlmPZ1XHCunEbyL4jeTho0qlBNJpOPVMA34v6sNWPFbBtzj3kT6GVDOkQfLaY6MhNrMT3a6A2zsBtzzJ94+NBLcDzloy2iBNHWuRpKa31pJ1Bib1XrDvBTu6eYJuoq6NVGpqSYU6apLUzkq/Of5SttJSSSo0be0KScaJ7FuqNTugRx84DfwZ9GVshjz1zPFzzYyO1bcAJbb1HIwN/Wg+Tfwolxx3PKUqLbLU0Ga9jtH90wpSb52g+7s1U/exNftWyJqvrP9aUb8CoR38Pl89pDrfiWnnnFgm430MlPi3Vn8ZYLlgOdhPsfpnG4K4ME56kdH4eIdXfWWqcVq+hqvmH3Iz+tLWwukZZVK7TzbWnE/vL9vK57tZzSb+oGNKwTESk6U2zjBGPic9Kv1AMjKuItUyOf+QsZqf5Abt6D2V9irAqa7sBHmKFO9ElUVcCE2szQq7zjJjCqr4l0mVZhf/kjNzWhCnLylrvLcgDerxvFWBO8gnjyq4bhxO61XtPmtlk65aq0AuqvkXXIzOvWhEAWO6D2agKAUHYaydC3KeUpBI/ROX3riLn+bEvTGHrMl51fxX3owyNpW1jCrtsGo46dHEgn75W+k+pj3WQTS3V11XGtVTdeArplWqi52uK9VhvuXzgYr3l+lhJvSpSwPhJjqTS/TcJqsBuI56r1sjCtZaI/JKrCj/WK7Jjggqb1NB7uaCmQ/mFaCbwF4G5q9HlMq3xwp7Cj8aK7SXEW9FKnHfCu6HQg0jrDC8IDwfvyfvctWvZPVKi0SvssxtVBUEQ7qrXLgvSUnfV+CtQQVOq/BVt8N6COL5O8i2LjVCeQHsn8HcASMbHyW2cwwXy2iZKyw/FNp3tTs0PwzsvW5GG0opyR4mEVv+S+4Q2gPsdAt74bC9Y7i4H86/F243hP3WuJ7733C/UTinoPJ01ie8G1jaNNV4Hy3nUa4a0JrDS6v5eB/uiiuxMPZboBkx9iaHPGHsNzqjhsOdCD9aR1D/8a488D8d/Muo/zzwX+v+2aqnrmHUdRm4dtI9dvdZWHsT+cqaSF29TjlX0Yg7t6r5n8C9+ATAoE9W86ucGGOMI7ZQV3LGGpt32BpbuMYYOy1EGwuuS1yM9m9r/Ts1q/nTnlRjBt2pqS6IoKX3kVPt36GZ/KI1HOQDqe87n4U5RCmURzmY7WA+AqOZEKV8Hmysm4PiHk4sxx1hwvd2Nm8Xv67Jv/dtF18jwrhvrKPXvrFffnPf2I/ivjFIuQfXBnruG9vKr3b+d/aNYboOivvG5Fw4p7o0Fdohluf9To15GIVmOLv2jX3+F6Eupjhx39huXzLd1yXv8I1WdMgUQRZtgY6WznCnsG8sjWqzN7zCvrGBBQOoa4LTx1f4gq7E0bASnd33jcVQWj8n7hsz+sLEfWMRvfaNhUPbEPaN3e/DMfdZ721r9z1jO8Q9Y1j23feMHRT3jH24JiKwbwxKf4rf+Pf90jkh3XHLJKu1uBaDO4jka54pGYp7cO8rsseq1DnV/ATHTBibW9qVe1qIvqKSGIorSVpxS3v48pZ2NZjI5ZWkGOgzKlraYwCPBRMHtFKgrQFaAuAaMFqg1QDtJaANBlwPJmU56qXVfKgQBzlX09I+Cuj3AP0K0BmHIj+Lm25v9lUSd3ELIQx++7c/a4D2HzWerqHSHFjAZbrdS1dR0S0I16c0TI20QNpxhd0Fs0dpw0Iic71xSkn3DOOXU2Yl3je2hR/pw9vG8G6ExJWRoGsMpLi08ZIZ2+63uMPq8ElyjtnCV0NP3UIsBhbmDW0GpH4C1C2utvZROnZPApd9jZVD+u9XUJ1k9jRhD52Mm0MMY79dCeGApEy3D/RhuAMoLusohnRHU8p8kVIKlBBKqRMpNUCR+HAnc5RZojuwOLOplhQbQsysjsC8pBQgme42QDUwWv9ikepsVv5UGCc5zCQpOJaw0/RcP24L/563pBHmREymeQzVtbbwh7wNzgp7VjDOsXAnYNd61bppzzb4S/WSb4TxbuNmvsi9bENLu4wdvOHNDT9vWAUlFeo4COWyEqAggD5hVgC0zKszliyevwJXJdlE3FU6xTeshKFQtg9qW7Jo5UN5uI5Fcwiliy6P+A6slJrmJexJ+KyDCTnQIWMKr0tCWjsYldZ4oEOqKLjOqiwdTHDkI/nXmeAvOxilhsu7rlDWTMEXkjbzrPt1o7QO12X/ZtZumZfbt3Xxlpm5ka3/2lKQ26f19S3ZuaGteFf1ftsk+kp091uiBl5iU6UW3ZYQM8rdZv5bV6EO88mYKkl8QyUZWF9JBtVUkoSKSpuiWn4U5lgSfJltJOT2a09b+z303WOtpZa8r3Y01hK3+nszSARbgbeysBX9FW9vnMQR2UCYHWtBOliIBbR1QaL+6MQdMChHclMa1Mh+0MPeN4CsG9po2af6dBth1GaWNEaD/hQN+pOMyrPJGxSY8fSBPvY96BG7dhGnloQUqvKEPnAXaJlXrdgnZN9RK2eCydNH0zeeKh+OVmJ7wL4Z+xIfzzTXEF1GjW26ik2VteIJObylq3SKJFUCGFPOW6WpfGsnQLeswr6bKCiD1Z4WksViyzEClMOqAVoC0FS2D0APApTHhgH0gEezOBTsOUApZkMAKgZoNhsMUCFAc1l107nl0cqlxmglvk9VD+nENlQxFXS8xYKeR/dadTastZCsiH74Pcgr6yRr20hORF/AKgGLBmxqRCRgmwBTApYXoQZsPWBawIojwgB7DLB7AJsdEQKYEbAJgM2NUNI9Qz7+IZgP9E5L93Rs4SsbhbRUr2kgXpjv3fXJOnesOUkY1seDetn5AsASFvd319qmqFbZL0IcNWsqAT5JZED/DvzsAj8KgC/g6jfASoA/A/hlgFUAfwrwboBDAf4Q4L0Ah7O4B6rWNq38si2kHO9XxxWBp+wXPdAbs7LOV8CPmsX2Jet8FeBIVsjRm81M0uP5madqoL/AdE99IqMR19HOwowS+hAmswm/EkdNJq2b+XlO/N5xm9axlPavPr7Ag33rqvH+71ao48DcxulfN8I99hbb1ECrknFJbXgCNtDKLjKd2nWf0zj6WWpsh1Q1tj8Cx2F6Btd/e8IG+xl3G4Ry8qZVJbzHx2pQN2Q0biuejc6kcb/u1nCFhVnEOzYGNOjnYCY8DGdYndWlz/FWD92JRbLSQBbB5IGZCqYYzGwwc9MMyTXUdwP4tnjoLq5OAvAnIqwEuMVDd3p1RgP8F08xhbUAn/ZoKHwPwMdF/xMAfsuDZSnrLFiD763LOqdSW5e3mS/3HgQ5SAToCYAYVgNQKUBeJgGgRwBSsgMBWgaQjB0A0CKAFGwcQAsAUrGxAP0OoFC2H0AzAQpn+wI0DSA1Gw1Qnjeq4CDUNO7KiNVFFKCt0amprdfhaRmsNym0/UQw6WAiwBhcamUMmKtOtfJft9XKW2DawHwCOO5VrbFIGcPv5IzY5kottO7YVqwPSK9TBuELe1c7P68l34O8MM2DXgtiBPn40ac015Ir0KYFfiLyx1ggvc7QAO8wWsO15Gb6fHOmudZWqVpvP+dm9bX0jlWsebs1lnOKYVtseeU1tnyQfXxTdDk9019jezFwhrKWhlY6Ze+ePRMyT+GJ4BroT2XcgEZWgydNM5sstiIYBTLRVPtl8wI9FQJtohTPS2/miSOtoM2WW+5PY/rntTYjjBmylctvvknPbNbalqswTpTdNtsyGgrK76fNbDKTvMG+EGZi+E5um42rRr1PyuWZcX+a/67q2uZnYBaNazk+/ve+msbnQft824prhPqbQXi2V/wyh+mqta2gcbZYT9400jO/yovM8JctyJvmq7CzzJnjNVZhfGX0HZavxbsyli1bNnFLZQJTQ2zp/nKz2ApWPmL+j0rOYiuEshFe1IFG+JVuHH6LlHEw/hMYm4pxjGWGL6OxY19VUMbosy0XRNk4184sB+kv3czf70gN1HED9AM85k3MzxT6jbHW9jLNl78WotpqbX/oQVEBZXcPylRavhj3SdBmFjYK8Ua10i95W7ENQgp0TagLMYz+Dk3lFh+u0eI68A1rFuQj2KEIpGwUzfUVK6v5zoplxUSWU/kNgjGJdbaQWFYBkNvRQjSsDCAeoHiQ6d0p0UocH3BMEOS7Fsak2IhgGE0muWSdB2E0iY8IAmwMYJ8CpomQiWNL2ntMM/IjL4ZhsZViiasMN5eD7P+jicmK57r63RdoD3uoR7/7HP8vqukKMVfSEWgzPxZGmO10BNrMjwa4io5Am/mRAFevwVEH49/MD/kL9teo5XVvG5Lnoa11fgo1t5FkBcqnAyT/CZDwx8vbbNXV+21jq4XeGnvq647L0I40N5XVh27+sRpXlNfbrztZfVVzJfitta2vvmxLg1p+vhxvacedCJdtI+grKILfL5xtMIrtt6VA2DtW1trmqlAq9tuG0HVyVo8xtdh2gOvvyjHM56uFeP8E8Q6CcHdS7QRPfEGYqlpbNfjMLq+07VT5Zbr/Fxh7m21yQMrVQMEQcwKUoC+wpfvHm4mdG//EaDZYsa958W+d427MKJuIbeBg6aaJ5z+dOj4jY93EGzMyJ+Bbj8JYtMCh44YUTCbeVCa5hXiLh3ILS9RaWWcljAqvOYWxKBbGnXgwmrShnAbcasHN5BzKFQN8EOCdzhrtUA7kBOBnnTjH0Ke3kGFgDGBGpauhj7/fhWNGOEAzXDiOhAE01YVjSwhAU1whBTh+CCMAtgOYi+mEc5IoOyegX28BYwJzEAzeTSnIU7xLDnL9PIERU4oSvh2gHCnukaYyGth3nQ1yPBPkOCtKDlL9T4escx7qXVFSUao/bPT7ryHbMkLMPv6HplhO+L7k41cAdxHIYKZUkMGf3vfdQF1k2ywZt/CEjz/hgnlS58zSTfwYX9+A9Gk+32+Lgtr6AsxPKwXpUItfUX4qhzaeUQgjxk/g+s9An3mumUnGvhXmmhl6zD+UZm3GVXH88NdhV/v6jvxar3mOT/cKek0ppbW4Igt1JcIeb2YwlBTUaU7GUO4gyZzVQsYtwTqdCXV32KGn9TgP4AMOSAG41i6RQf1scIJfqbD350eIC+tBmI37buy3saBjC2cnutK1i6YL11q6p+tnqoV1ndv1z38rHp1u30I5mOb6AI+d8nzq8etoMk5WIM9nNBVQf/XAscuJYzme9Z2TimvcmkImWcbJ12i0WUQ5dijwZjlitTj3V83BnfHP8ZkONeawIw/gdIcwo4nVReW/8TCrmWa/AbP0VcX1y1BevY6iu751u7MjLJLDk4hs4Wb+uoutO5oNI6QulQN/BtmlIHq7fQVf5dBwuHoupP0JMJ8pI5RbJwjpWneqVPMczDJk3AUzM9jHH/UxL+u4PgWQIpbV7OLDiDxBEVhn09MvAsrC+BKluKI1mrtjVdAV9Qp+Fr35+YaVPatUnoQ5UY24ZoXxbDnFHqrh632XbDJ6fgvvAMdbcSqgdwmiqwc4P7495TK5WL99Ja6aHFjJZpzILvx2XbbUPkiqsA+SF9ljg+Y2L8yuf1TuCtow3T6RPMn3IarrQVITkdU0djB9xlrmwRy8wREKc/WMSxv5Jhfg6gpOrWU731wj64iEkn3e8SQvIVhDqQR5hlpA06vYxL/g/mFlS7uExdnn3xsl2kjsF7xXFp/ufHlL3GfnCVMB/FLhvoIK/hJhR7+xWEJf4sZ9Cee4z60qTp7XH8bAdd4frZj6A4vZe+qgbRjmwFxLLG/lvXjX34U8S3vs+wmF86+FsjLu83aJTtp6Buq66eqFquPXQxQIL7keGrSJn+xuaY9k7+MM3JP2z73YYhUwI+Hp986PyjVciy263McX+2qhzittfVVRZhyV5/leW43fH4Y2RsBou5m/4ql/2GLFMfICYDqYf2E68G0sPAMirPWG0HXJCr6UqPKD8x6z1zqC81VgH3QwiYjXO5SU/ooDV3hxfXdOr/XdHuu6eS/xg97zr1O+xI97z39GF9vOZph5z2/E+z4ZUxidd6O0vcR/6cVTucFTffzlXid35YGTuxd8N6BMu8uYj2+j52bP9lr//OA31z9Pi+ufz/E/OFHee65/buFtvv/O+ifGf/I31j+rcE8AXf+s4lt9Xeuf+c16SvvIh+ufq/7N+ucW/piv+/rnsB7rn1v4V30+fra4/lnFv+brvf5Zxf/Bh+uf4/4L658pdP3T02v9s0Zc/5zTa/3z5G+sf6qqirMqrjHqM8c/YLZdY3TbrkWCUcNAWDplM/9qI657yY2fM/P7S0v0zZONlxqSmtmMySVMh16qMjEdRqmMe47rx529fVYeYmJGMvaGirMdWYq/ZKvq9M0TuHxubv90bnTORt7pyBpuzvnjdUXQ9VZVXeiRr8siSveUzSh9oOyl0igiG9BaGrJnT7akQybpaD1gZE0/GCUm3QqpackKmenACrnphxUKk25lkGnJSqWJ0cYfDT08g2jVk8Gw6eoUvnXq23sfGcgVXbs1aeu1tZPwhaKt13Ylrlw53JiSU3StIfeZa/a+ETnPXLMwbM6r2V8vseIdvA9fale8IKtjd18imnr5nmAT9AehRdc6dOw1Zci2a+aoEddYydPXQiTbrq1ZEpUTf0RxTR4ykwzTROVoCgR7Vs72a3JJ0bXSMdXXGlSSLPQN0LxdOcF7g38f2sGGxuW835HVZ1aOibvF9W9l98blSOpeL5Hm/FAircvI0S2S1aXmLFkkr5ufc2CRoi4k54dFQXWTc3SLlXXrcpYsZpJnWUdzH3IKroqL5R7g/mRdKH5TtkC/dO+psdPG5o/LY5Mete/xjc0fm/eo/bCPqU3hxhSOyV+qecyuIPcVsrWMqehOzMzMwqI7iyYt1jxqP+q7h1JV2tGFTOJaoLzuyyhkajMKRuWvBuy6T8ul5y8D6ALu889fD9DnAI3M3wDQPwAakV8G0Me+4fnDIc7HgDKMQk6fYC8T7cWi/SBNFZOUCvEtBc53fUMhPi2XyK0D7ITvsm2Iakg+aLlxWpghlqgwTY/7kvKT8/DshSHrUfv4ZqZZBvL8/eoI5U9/jVBaJgp91y+AP/R+pPKnicLdxzfBrnh5NzM0K0o5HczWhEjlJrBzMyKVx8G+BOYqmJcTopVRk6KU8wyRSi3Yo8FMAINtZSHYmvERyjqwz04S3gb4ntrOHBfYedlRSnZo2AULuZrGpsZeqCE5aXjGsAJsVneG3EgrnSIZGtqK7hlAZ5vRB9AjdKIvmFGSBsk0e977Umjn0LuaWUOd0WUtnXIa2ik5xSSvpxoMve9jjnyR/ImsW7rIoVxfQxXPeqD/3RBLdapXSqt4hztLK0+sJMUzKskMMDPBzAIzG8wcMPfPaCFz17SQBWCXgFkKxgj0VWBWg3kU8NIZss53S3fzYyDsRZNbyCtpeHN8CzmYhnuW8M7zFnIoTVjNuQBh7ZhxkNQA7y4wJjC1EMbuRS2kfo2s82oprvIwiS2kJaKFnAbX98H1DNjnwHw84wxdC7pRKth20WZKW8hV3OkyA/f7tJA7YAj1O/nuRWkLUUa2kFAw6siDJC5dr51890sploAS+KIXV5LYmQdJfHoVv9ZNdbHOSCiZVe54CscAvEyEBwJc4kYt7CCpT0/IB310JuijYHYvPkheBfM6mINg3lwMeZ6JGlyIq29+C3lLouem2eWuFqg5H6/zXSmR6iMuXL7K2CXK0HAsx0oybqaGI024J+nRNN4q0TmtUh2xSjSKAkX+Fn6/m9VU8tEOlNfMwijlZDBFYFCeZSAHOvM3xqezWUud0WHFWQLKgpJ+H1SaGahrZRNi13yMua9BgH/06cFlYCnu16jhJzcL1K97UOcDFecVisJ4o5wbZYbZlrGKX+JWmg8aeSvOhjAeOcSfaj5B4rRCCghNAdOMbnhrBqPVmbeRXSybjqk77nzanhXsdy89FUzDDudyzCezZZZEox5GsnR3LMQg7O1nNW6r4NdCdrOlU84YS6fUkEdZnAnVkJp0/PY0673JeZv41e6DZLckGyAjQHslWQAtAegVyUSAHgToVcl4gB4AqF4yDqDZAL0uGQNQEUAHJfcBVADQm5J7Acp1r+BOQog+/mU3fpvaC9BLbsVhRjeJqMefhHB9/HNuyZ42aKvPQ9pBCiNQE+vjlXWehrnZq+C+0Q2zqvR1jUzdvARPyivN2oKoUlaEBxXMKsX6rkmXQuj14HuxW1p3ElIUn7q7GSQoXXbYx891y4B2UMJkxNIdazPT5ECd5pZ1JkMcbwLXFLe8zu86K02Bd5w0z7qrVg4CkwmGA/MImMfBpIKJAPMgmJZQ0GEKY8uwLhA2QHnOTttJv+XpzIwGWhwbBrOIFRyW/Fr7RmcTkRmeME++k7VuJccktgH1GFDW2tc4GX17K7bQn606cP3Fit9CzZ0vP1TTgHdexHAzLCkXXx463dL3YuHQQkv4RWZoniV9KGeRanTc5oItIOEjXI/Z+zJqql0/OvQ+y/ahv1jNnTFbRllkF88NTbNAaFt+Bsr3j6UCHPOYHimPXQLKoolaS5+LQCtKsMjRfigO3Yr+iW5F0QB/P/FjhEeGU/fvR6osSwpfyW62LincA/W2GP5Z+O+09rll7P91O/Pc78nqNHmqqvUpfpP3uVxlc0Wu7HO8h7+K/8Bjt0oTcWfHbi+jPwslkP6N4HtE68y8yyTvtctk6dbNMP/HGUIQ9wXZncakDvxGfTiTY0navs18PcG9QrPMMvpizWb+BcDjDVFmvNlpizULpP8ljxDDci+Gf8maCfBqD4TEMnrf3Uf/xOiegXqSHV5rb3AEJYR8M7qA+UMGN4Jqic870V81P8fzpbWJRBpG5uvsMqmBOwZwFb/dGXtiWL4B4tjqtJsTOdmhMv73kA/pNxjC4IKLVoH2PNA6v5UdYRK/oDW/1cHo1d9kcIMKomEmtIWf6/y7laWpGFB4Fnp8GcDj0n+2/h4oSxrZRNRfL3g15r70ne0tfBZNldqKKf84jUB7nrhhAN1PeG+u0Ifh/XclP8QwOA7jXfD4Te0YuG10Ryr/BvY/folQ/gAG11n+CTi+88eDvMams2OZZDZVxrG/H/Y1eyTrVlCahZZAqqcW4nKZ2bohqfEXYdRY/6W4Xg7jzIZM7in+mLdr1TzkM9wF/2XgznipBfo6yMUTXnY3fs3NunWxGNfMMZ3klLZwQJmM68P15QacqCFz0qLMNeT+tOvmp/iHPRjThxAWjE9PXRRXcT+l92bFpj/SiGEe8B3KVn6GUJy7jdxJG5iDYxZpQh91jSncfRy2rOf5qY5nsq+3fknHuKv0+0cbsVPf9hlWnJEYblrfp3cTRXO4L1pj1nLC2tHbzeLZp6KmhniugnsJ3Ilb+uQ+Ejvj1aAgbnibbEWSOaks2s7KGAubpOOCr8slkYQNi21kx9uOs8NJq0e7E9881e0kSZqdJLl4JxlieHfjTqLX1BbsJKlqddnMsp1kKBOs2klSwMcw9U4y3BA8eMAV31D519vK2IxtpeOpxumFMJKzIBzDto0YZmUh8KnjyuYD/xBNMgdhGpgk+eD3NrIZ7605cVxiwjH2GKkyKDrYkOCj83PCOpJVe3MZk8KiPRxH2BAf3+xg6jqtYR12VRP4SyHfjMccFHKm7BmcdFeQJQp8MSaY64E/6d7bVmhjrI8/6GgiMYadJNowIHIn6WtghjH2fRX3rWCGMvb3KkLKorA87LUVhZAyg6G1XTLqfDsDRjGKqTtP0gx4colNn9zBSJtIPHOMjGb+CvP4GQUzC2fmzZp6vj1JN7PwfPtgKf7rJ88oTDFJOx6fdaBTJz1wd9dkPKWj0arTtIdSTefbtUdgLuh4yPn8reDD2kM+fpkDd8cjtMgh0copbYEjSBtKod85tK9AbkNabp8NqtBN0c7gPurYEBTWMYkJIQ3jg+wTg6r4SDLu6NgcrUpKDg/ThkrJkWG6vVLy1rAIoByLjwiNDJeSQ1Ol5O14KfnTsKTwoI5gyQMQo5Qchdn3YMc+YoKyudewj+wCOxPsl8C+D+wasMeA/Qewx4L9MtjjDGFJ0ntG5AzOSeOyQL6+cEn2Bh9m0xF+x4t5Qcjsxbwg9JY3CeQzlMJvegWeD122n0O5b63C+LP85+CVz7y9/L21tx8dt2Vm+IwxnUVv7DDK645+vW2QCne3sgrNVPuYv6hPqfA2S8AlgKd7tZwUehmU/C18yGmmGfsTA+7Cb8DXEcI6Yphn+UpfG+jW0uvbpGjqGLy7aKkOe8Vz8B9teNSucuBZFslR6d/PkwTmPMwPNZwExrgbM6BsnDG6r7UgC+m1oHnIjhTdeXmNjy/yCn1EP2cIjJLklIUsmISaTD9ulVnDBdn3kO0wriRRTSnIXktOZ5NW1PFiNVX82y4ZF2sew6WBy2qCqx1fkAVpAxrPQhg3rFFcnJFJcbXGl/xsxTXTofmHGhgtrqJ86lMdDrK/Sxh9joVJ5LQxh57lY3zTb/2SjSc4onWr7V/6YmtWw5yrf82j9s0kDv43kgHwv4sI+TNdlTIDjzwN/4Po/6P23xN8L1N2ZBdgiUe3wX94Ybwp6NA6+1PeS+3KRUxyLsxmM7jz7TG66brjgXIYp4s+Upvo4//u0dP9ObhW/dbgCOYyvRFXWP9XXtpvU+Fd44ETcKVTTt08I36Lpq9i4y6qZlyXwu/pw9vJZPwi5uMv+r4kJVCe407QfS149xCXyT3LJ/kquAuN41EX5ULsEpLL4bcqsg18J76eHdS6xPghnsAUVy/t1llGJpW3HMgebYnjiHWp8UsrM/wny2WyqmIu9EghJ+YHQua9W7nTjUg1cAPomslQTmVv9bUQWc2XGGYjhDxpIPehNZVbaGSGu1oXlJyxsqO+sY7l8P44iWYz/3d8q2n0KesS46yS90GudeL4dob201KuhhQnhnIPmMc0stoKgPfbglXB+bimgmURfIVJcVq2keJJ+21ylRToG3zCGjTD5E0OyxXmk6X0WxPeexeO30Srde+1kTNpOvOkW1Uwxq918FYD5OYzLwvYFmcaJ+fK+I3OStuaapxLCb4eciAPlEwrfqnCEizNquIXvYtYaVPmKeiPuTOkOPIMycs+Q6ZmK7kX+fPus2S2RAMyWizB1GY2aTjQzWHWWpwO/sBMTbeAjxf5+vfJKdztlCdpA9qAOHZsXy6nuY0Ua+tij2b34QZ/C/Die+JOZQ+61EZmp6dzsTllvNyB3xby0tuomS05NiAF6I39y3hCBFqxdmDO7123bktcUXPAJ8ywSBMz+Gcro3FaDdD+8rItZOrMJQOYVKUl+BKTFF0K6dECTSLJUZXEcoYmC6SVGXbgulza1swksUk2q4WmuljbP+clIeQIyEdk6RQC2oUpDUf5bebzZUxnzPrQ0fji1NsER2hs9zt9BpQ8mCd9dJoI4+2kpMLk6QONyUUyropjhk+05OamWQ6ULyqfdE2a+EP5axqwJ+E7sKGhUbFsxnxlqEvqvZ+EX1mTO+izuQk12bcvhOpmTbbH3p67J3tg6wcbpeYfFoQmsi7J4sjyavPrC6LM95XtASmPND9ZZgItJZGuFR72HTN+ZI3jrnx9ydquZVLtlutQL99u9H2HX3Fx7rQK5orYx0o5JWcipsRIc3/sh5thLmVbCW0yE0pvKeR2XWO0BqVDzinNKnu1B+f84xvxjlIpSPcCTxtZymY26aFdHPRIOUZ/1xJSEEzdpqPbjOFmdNvswVlcJq3PpWk/Qjv4kBPawfdg07igZedAL6myGz24dqkFv2fBbyb9RoT7DPbbFlZbSMmMy7YFe2X0dGbDzby9zPB7LKkwR8SV3evGM2YmNeoS4rjvDU9Jnr65vPwLm7R8yM2h9FvDRzeHrCy7+Wb1auP3VvvN/JWge6ZG/qccmTcHV/9E/TusbcSYhmvvA8wmWyG9ORz3LqBuia9UfHVzSHXVzaq9YxvBt+rPNxnV4/bbLtypUAsaMZua0lpLJmm1KTuaGS2rbbNtC7w/KOu88ISsU7k+/tI3jbW2p+n+AIhb9WW7jO4haoDwHrefd9lvZqn22+IBPuzCHReVWF9NjC6O+8qqO/EF1VplotbaBm7fWSDG9NhU2YXLtj7lJTf/qPrCqk2VABZWzlvTU//xNe5zwpSi2+P2V2gMH1ghj6oz9JwS9sP4XQ+/ye7ds3FiRsY2+m3WQmcgU6DtlkLPMdki5HBiqyb/GRgD5FzNiUF5z/LpPjz1t51PIAMAS4VxtzSRSRl0KY6+uzyN9AeqBvzEgp9Q0hew/oD1BUxOIgGL9KHUlKb559B4I+JT/Ht/GcqF5T3D3/Z9BzWyOy2EnkbZzEe5rVb8JvsXLcwNiiKZ29BHklxh73wQyFooGBaMWpQ/1ImPdco34VpV+J+Y5DMwe7lM3nodzPEzpH4GvqFeQVbPeK1DopR0KIPDTONLwo4yf9hZgPrMavsnnsnxCo6xV1XUdyxWxIwYdOHyVYU9NGF4wtoE+rsvISMhQZOQkbG+fDOjAv0j0/gs/65zc2ELeYWt74wp3p395ddjjU8WPEVbzQkXvpnq9/ems4XUs6rMubkt4OfxghvWsUZdCQPz+tj096xrCh6jPHtcP1onGPGO52f5fS7Q2MF9ddpR68p8pNS6lI0SXafVSLGdLkbPW5ZR+FlwkequWpdQrAIwme576yKKbQRMrvvG+iDF1gLXtlYFDVcO/+PSn7JiLKa0MmrvSnuc2nPSSqldm7bKOtrs5dvcBi4MShe1/jZSn5bR2AblG601Qc8KOUvLKwRq4t7sc82I4XwHT8UkG7EX8/IOr8GcVZDKjaa5HOy6YK2F+NPzFakvN48tGFeIL7pBeInn29mZGA6zi9HcW7CZj3C9yNu8Uw3P8H28WiP4iNBAaH/xMfoWkNjB39TS+Tlj/9t2nXFYwT+tbGp860kSF6kEX6951eYQTl/QQuPCmBILEmlMJ0k8aDpspBCTOl9TwECqvnXiDrWBpWvt4b5aKA8mdaIl69YUuht3qZvl6k/0o2epNvMfOtnBG6yyKSCLrw1n+k0R5G8E2LlgvngwSrlzQ4Qy85NI5QbAM1IilC9URtD1502An5wQpXSDzNYA/PjqCOVpsFvBhOVFKUvBXg/+cHVyrf0TL+Z2o5fRPpOPqXjPiTvPFTWM9ul8vGVEvRy0cCejlddsoXgk4IedbGJQDeiLyxV2m4vRllPOV52aI8qayMPy3Qr7AZdQHhEW7CnWUfc014mbMtUaCqe6moH+GIWTRb/MraMVl69G2YOYw4yabWMPM6skBinyL6P+IlwIL6VwCMBK1WIKy2m4JRT2Oc0AP0hhhxP9L6DwbQrPo7CNwnMpbHViOu6n8PcUnk3hb53vADyTwl9Q/8UU/ieFp1P4Y+pnKoU/cGJ6CijcRNOQR+E/U/8chc3UTw6Fj1I4m8JvOBvATxaF99MwJ1B4D+UdR2EThcdQeCeFMyn8LMTFqO6h8FZKH0XhJ50Z+ZgbugbhRBk0FGIryrr17UxT9u7mrFsXZ+HeyzYyNzH7lnrd3uyhBVXNSGF0B0qijHib6Omno0sa/yXsm0fdHO/g3jEhWqkBGUoBMxpMNphpYErArALzBJitYGrB7ANzGMw7YM6AsYD5HowTTEh+lDIRzGgweWAWg9kEZieYOjAr+kUoj4F9GswZMB/nC99WUBfB0n2O5lJJS/pZCkuc+23bVdsp7Mb7qFSCPN8FuEK1jcJ2B0rKVgpfcxwHeAuFf6TwJgp/58Bye5LCFyi8kcKfUXgDhT+l/p+g8IcUFiT8DIUFCX/X8eeAhJ+k9NUUfhvSs0D1CIUPQXrCVSso/Dr1s5zCr1D4YQq/7ECJWELhGkpfROFqCj9E4UoKL6TwZgrPp3AZhR+g8FoK/47Cq2ja5lB4GaXPonCJAyVxBoXn0fwWUXg2hadReDr1X5jf+jOW/RBKy6HhJVN4AuQpWDWYwpkO9CPQ06kfHYWHUTiRwoMpPIjCGgprKRxH4xH8RHeDw2l5CP6VNC6NUP807QlC/RMMZ2D+lp/98olvA5dQ+1w2yunl/P89Wf3P5BRl+TYYHxhlQZSyX4Egu4PBxjQJPdZbBNMq9Fhvkv22h8R6rCcoG0I97gX4AbEea0lXPb5ATgTqsYrCQj0+Tbrq8SnSHKjH9aSrHktJVz2uJEI90pGHwvkUfpDCUyg8l2D95VJ4JqVPpvBUCk+iMEdQhidSOIvSx1N4DK2DsRQeRen3UXgEwIzqXgrrCdblaAprIb8DVRkUjgc4TpVG4RiA+6lGUlhN8zucwioaZiqFZTRfQ/NxJPP6EB5CYeLDtCVT+JYP86LLf+Kn/TYd2Gt+6i0bveViYsF/Xzb8df8fyUh3mZgJBvcGLwI7ittLV21eKUHNJqoRU53oS+RknedKlfZq8uz05I14T8Lwp6HXZkF3gzn4W5JC+xeeJ/l851aYU1ZDWVQ4Ujj1YcVuuf17H95J5uWfd9J2CaMzjs1y+xe+evM+8rKa7fBN+K6DYSddD2fR3z99+8hrhgOguV7oYKSTryullWRGWtyR6MNBwPUufTuppmIf2WDA0eF5gNYbdpKbhn2kDOxfDPF140z7yEaA7wCtHOxOQ5H9xVCVrok8XowrPsfIjeLz7cy4sUekummJXv4f7pTDSgj7T/jVUJtyGL8Ev8xP8+IskZiD7WrfFZqDFPc8fb+vi+zPrGNAexsbxWnDOjpZ9BVsd3kvDinSQZwMhHwvxjL2yGYIu94NMy82z1xLVqWdOKGy76BnxYxplYC3kTMRDnOtbY0KQ//Jy+gLW9tsa8r32ww9TiKpLmJNHHhPZ2RMKQW44pHGbeIdHgzpDIRSMoMZPsOi5wq4WVyw/TvvauNdK5Nca826+4+ofdlsq8r+qQNSFIEpUdlbHdKEv34zL15miaWvw2zi2zyCywQxbcdBt7SgbpmO73pgfB9aMQVjGzEFoWIKJJr3wd/7oj8lpeJef9QP3zo75N79IEuPgmkG8z0YCczdBV2Tsb9QAVrfE3ruRWj/YR0jJX0OYwls9VVwSNtG8AWHJy9l3dINuJA7hTvU/BA3huuzZ+yhDfz9BH0UEVy78PKVICsjNa+bT3e+tCXiohCSl1/oG3s0uKbPngv9j14Pkmzgx5HgOg3XH/yv8iH3LNJEbhhwbRzXz9NASm4aoHxmeEGengF5+kWt55RpIIkEXXaSBeDjF7AXgn0L7AfBvg32Q2DfAbvEML5Oof3gdj9dP3oP+CKDl9/twnOTihDg1Ew4jPOCF10SbSiFql0jzWHasFuSRMS2uTDGB3IkafflIL6fyDqZJ2BGXGYsYHSf9ccWMCsXijF35Ge/u6aUplgarwcxK68r2Y32IS681y3oplqFJ35qbU+Vn8YTCzqc/bcQe1qtbVN5i+3plUjFO02QXmvbDLRtIo1QWoutciXM1vcKLdntYnW6J0J+3kfsmHN1lJ3tE9rMDAkbEiqmMfs3SsYulkyHWDK3aMkIJbVILKnFUFJYTnFQ7ksAX6oZEK3SCqX2MLRSVYiXdzmXWpnEk44adq39YQJSBX3MeoJfjUpYlHe92dLOjBb2dBKYRdNdHWyueYRRz8nt93n0MPN7kIzmOnGGzeKuD7xDu5bMTgtprOKHwUw+WsLo5d9W8YN9wj7s6HSUywzaxl0eYT5yhGCb0JhV9hMOoVWAhKTJ6Vn0TfxYN+44vXEav/E9FrltTLK4hwF30hXdGVEaDmnQEBmXZ/bwe7zpnLDCnoQr5E+UNkk1eFfOJj7W/Zg9hIG22nx/tsBvOPVcQyinsqc5VPZct4df45Xp5ZyyVcpFFUTBfGwT73WxmuAGQ5OEU+dLDlXyOaQP3cm0VJt1tyWKTZQc2sR/7Po4ycPP8h7KVrSy4xQWfCl6O/+x944VzzRouO+sz4vrCI1gt95QKnl6YkAlnsVRWJ6EcRxva1qSV8mzBPuOxXnbeLdP1qkUz2ox9vqKB4F2yyesn8gsMmjXuyrm5dVcmQf0n4E+PnIuQN8DNCHydwBdBGhS5ByAvgJoYuRsgD4DKCtyJkDnfSdJZuQMgM4BNCayCKAPfEUFRYW15OOIojxmaHRzBLTibfxp31RwOwU1qZSU2cfTW/nygfIWUEKBMopScoFyAChqoKRSSjZQ9gLlEFtm11LKBKC8BBTjjLPmL8gwoMd4GO2YwjL7So+C+4IksX24Mnso0EYDrcSTjjdGsWO5dOB7wpdemJ5fS2oT0/OYlOhmFRcHaVuJX2giRoD7wz78X+zDnpNNVVn6fS5J7WPBr7BDgX6/7yWrPs9pxRn8ELrHy561jS9sTg7Auc24SpBoTAxQxjUvAjnZDGYXmH6TYVwH+00wx8G0gGkF8x2YDtyfBe6GbRHKPydFKScBPBvMQjCrwVSAqZmMOscDWa+DrSyNUMrAtAB8E4wsJ0oZDvYIMHEAJ4EZmoPvKgUXBk8faGSSppkTOQPk95YXV24ve9lRx4x3rCedlbgrhu6neZIT7tfBVX78Zvhcw7aE8+3SI3JTceF5oqwP4tgOpWIO18qBplTNmuR1e3PnfXM/SanIz8/itsNcs+hatYzlTjc6E2bmRl8alaPqYFUlxsfsL/hm3FCHlNlrfEro+U7dzKoWTkWxyejjG+sYyr/OCVhIHuVWAPc33BIja2J1MtN1azr1sdiZSV1loqvE9J11OHWZ49xNXdQYqzbocIlxOz/WEVQ3oCy1cZCzwsHqvuGkpo+sbLIDzAfW8e+dunmGpkL7raROekJWF3VCWreukd3t4T/wVJjxZItkj5feTRocOKGLbRrH32in/ApbF1GgpliYk9XcsPYpCM3HM27SOp05j/PwDR5G/21rIacqwHd9cP/Un7URyufjIpTvgj0G6mZ8jtCm14H9EZjdOfimAquNKy2dgt/XhbVP7N/XQ9/WAPZaots03wx9/ZoM+rLYdv7Pbna8xKLbxKTebRW0oFccuD8Kv2clTtMWaPOHGbVF2AO+68D7nNjg9xuHGWebDxhTS7CHO+/TQOnt99yx5nAd1v4g5//yaLjYgmjo7V5zaOgXLmi1FZVEVoOxXLdkggxZPC/wpZ6phkp+l5u9B98K2c6vdb/TWb7lxtf4ZpgcuJ/GHfqG78Q9VFqx/+r3j0ilVBqpzAL8flwjFfcySy96+A4oR7yPA3ctb4e5pr4xjRO+EPn4wqYkSl0EVNy3jOU+w/EjvU9jO3+/I7ZR8LetOYFSpgUom/8SRyk5jtJGyXCVJTa/AWRjvIMxxDazdKe0h7/6PqtxWCOpP0OPeDf8JZxSkx2M/lhrKK2dtyBP/j3oZKaQr9HiPkzcozkwIZLuxcQ9l1iP/9GeZfwKKTXOXxE7xX6KSQotjS6NL6ncxA6TNEeX5dg1sujSnE2SceywVwFfat8CONJZRUxp0CYmOWrkqAuXrwbZVUlDx08uKpo/Z05UxpxFDw+KGzEnv2UzMyy0OSupOGnw5JhSViu9kmOfBPxy7eLb/XJjRUyp5a059hkABWlviZBEawPoAYCk2qsADQTozC1Z8sCSyZui7K4+rEWROrKV0YWU2psCrrm/dPkc3e6H78rkP3TR51zqgh/+qgt+otUqpOaoSFNo37JKUtlWme5TqxRsue4caK5sq1TXYpWn8q1BujNW3w0mr3QKrikFbPFejL5gWISBniK6o+0BmkekjxbpaE8F2lT/vRpAyxbd0GbFsFJFtxLRDe0VQENTILrpFwpuaMcBLU6krxJ50E4AGhq96IbzRr89CGhoholup0U3tAvEeDSi2z4xTLRjgYZmguh2W+RDWwI0ieiONJ/ohvZjQEMTL7odFsNE+y7Q7op5t7QrQX+Ibk7XCOec0M87ol+0eaDy3fwN6uYP56x+uxTvLOkVZmw3vx+LaUM761aQunSK8N/lP+tWiFrZ7K+nRNE/2olAS+xWrt+L6UN7GdCWdYtzWLc4R4thoK0Ry9cfxmqxPtHOAhoam+jmFMNHuwNoHd3qLUPkQ7saaGgMottOMT60bwHtlkifLvKgPR9oaO4R3ej3d9FeCDS/QdpiMTy0fwc0NBNFtzzRDe05QJvTzW2T6Ib2LKChSRPdnhDzhvYkoE0S6TPFukQ7F2i5It0i+kd7JdBWivQ6MQ60XUBzdauDhG51gOscftsLVG83f327+Tsmhoe2E6jObv5SuvkLEf2hPaFbu1CK6ae22N6Hi25nxDygXQm0SpE+TaSj3Qk0NOGiW63ohvZOoO2k6Qn9lYydEdODthWo1m7pHtXN33xRBtDOuhVM5R///X7ju/ldJOYF7WtAHSWmaZIYBtrrgLYuEJei1dKuouFMpeFMDYSFa1ZJIj+uXfnhPy/ogj/pBuP60w4RvrSgC77bDe6z8Lfh7n6683YP0x9XWq90pPVKox/3px9xvKcnVrOdH+OQcRrzUE5pj/OyhboS1ImqZkUp/e4pAXdVwN0+u8s9LuDu9PjdY+cI7hpwV4F7MXW/5pHhmVKtLL/e6OEzPfWL0G8JxIXfPtC/HvzfgrllKfX/mUdB/Suof41HOOOr1Al8DcCHb1L5+b4EvgbK945HRflUlE8GfPWLlBT2uhntlUVCeMStWYzhXBDjxzN3eM8JgfCMEN7bEJ7hBIb3goeehdVGUr6Lbvx6V7+I0fYBHNKz3MN/5m5pD11ev5jRhlA/n7j990S1tEcv998RVb8E95YxUHb4fi2ehZ9qENJfBvGth/iu0PTf7wmj8YXRsA66Mf1CuK+6sQyuLMJSwNdImMQ8LZ5SfYb/yYV50c8W3i/BO0z95VIQKM+UHuVZ5u5ZnsXAi/e++PlGBPjCe/At6MVXJvJhuVUBXyTBW9wmWJCzwz2IciZQzomBkhsQKLnRmLvFsRQPBXw44kv6UlwNeDLiSyMpHg34QMQfFko+FvC+UNLxy+uX+Us+zI03b9UvpyXdXC+mbfaSaHoHEN5p8xYYPLeNdSDk9RmYdfvzutvdPa8/u3rm9RyEF/1wF98rAb6nevB90osvC9rD1Ae6+CoCfCU9+N7uxWcEvh+Hd/EtDfDl9ODb1YuvBvhiu/HlBfj0PfjW9+I7DXzvi20gE/iG+fxtKtTdvU3Ncwk1iXXoD6vYJbQBLPkrEA6W+ZkxXWEpAmH97Ooe1qjfCCulW1jK+6OUV5ZDHS7oys8Vrz8/Z1zd8xPeKz8G4MX7Jvx8LQG+gz34bjl78s0FvlX3dvEdCvBV9eD7shdfRS++HQG+VT343u3Fdwj4ZKnRYp/5DF/q9feZxa7ufearTsG/Bfx3L9u5Xn/ZZvYo2+3OX5ftU86usiX3C33fjqFdYaUHworsEVbJb4R1f7ewNL/rCsufj9BAPm44u+djjJiPPOBJ4rrK647HX15tzu7lpe1VXqXAh/dUIZ8B+C54/Gk+7eyeZoWzq+9nAmFgz3mFhrMbwmlYGK381NiVhuOBNOzqkYYrjp5pOAO8F8Z28b0c4Fvfg6+lF99V4Bs1oYuvPMA3rwffoV586rnQNid38T0Y4JvQg29HL75M4Pt0RBdfdoBP24OvtBdfCfAZRnbxDQ7wKXrwze7FVwV8B0d2yYAK+CqE8d8RRPmChPHfgXUjp3C6Q6iPBuCNvg/6jfu7+K+5/TL0iaO7DMU6hPguzO2uPzwDY7E/nccd3dPJ9Eon80CU0m3okqF3gM9O+V52hFO+cMr3I8F0hlL4O4L6gyBbFwDWLBZk6zPC6EoW656hY/ADQnrwrjmUbbw/DdvWXIij0u3XKZY6uusUx8mvdYpDGO/i0MDIWE9wRKxfwmiFOHcTHBHrl2LbK35A6G+xr8N+Acc2f3sucPvbRoqje9soI79uz4+SrvZcBmHGrxbGTn/ZJgXKVtajbGeSnmVbj7yThDQU3aksfYYPcqNWsIlqBT+TCZR3gtD/B/I+NpD3FJr3zEDetYgvGR3QCuIQX5oe0AoiEX94ZEArUCG+bBjF4wGXIL58KMU1y92808doW0gVk0wpSUDpoJTdjJZS9EC5SimHmARKGQaUy5RymhG0FwNQvqSUc0w/ShkFlPO+lvbM5S3kAsNoo4Dq5luAMg4oVxlBJzkHZVMv6iDY96B+gnonyj2WNeoXWIcoP+eyhLpEefK3idNQDyUuGaemcpRF1LQs1TSuF3woq+EUrvL11hUzqa5Yyf/TS2936zAC/LGX6vOQpjxIR0m3uh4BcZQJ+h8R2i2+3AKhsa8vktEYfucTW1Jz7LyoQL+PvGqX0OaD7HYf5dUdWOSXEORltW4+U+TO6sV7y+nn/ew3eSXAGyfyGnvxtgV4T/4mrxR43V5RR+rF+45TyG+Q/WXfb+f3stef39PzhDr08+4O8Jb9G96/BnivAO9b3XjLA7zz/g3vgQCvcn6U8nQ33gUB3nH/hveZAK8BeFuA9//UvQ9P8F7y/9/78H/23oey+cJ3JeFMYDj3EofnAd38dSJ9su4/OhU4sP9/9VRgSYRwKlB9j2onGVYinAwUTwWO+C+cCiz5n5wK9PLh7v/KqUAv73R1nQr08rdd/9+cCpxRODNvZrdTgTP+i6cCF3q7TgX+zus/FTjT6z8VOM3rPxWY5/3PTgVWwtj4PzkV2M/7PzkV6OI/8flPBbr5o07hVKCbf9MpnAp08685/acC3XydU+B5zyecCvzPzgSWnmI6DBIY+Ts07K6GihVSe54HX8NWcLIOPXsF8CyPnAtvxDvhs2BMwq/+Fa5HzUtWQQ+xCnqIVdBDrA4yHXhEafrhkWCTbpXKNP5EW3s8u8H+ZxJS09aeANBx0mbTlIfW4Pm187aw8jab1n+WbUybTVd+DMqkC08CfEwAPwblUW908X/0Zelk9NzcukQJ1PA4L5us5yIbSpsMp3Y2YPplnOII5sDqlnPKE/ttkeWXbMryeiPe0cboztukgAeXS0yIn7fJAFOVC7C83MVv8MVp1fgmQnrWreAIjCHEq+fw7P6VEQ9nG079UYxDQuM4BXEw+lGWWCiTUCiTu07o2XT7bEEQqqIc337CsyiyOpWpWCuvg146MfIQ5ryS/96JtzZFHqlfKbXvcreJa6yxdcGFfUz1RkanNkWYXLzBt0Krp6mxJiohLWc9em4I3kbGnNliPyXjXmpgkiE9Qcoj93H1kJ7VbgXHnNgH5biTxBtUdVLTPpCvnWQgyNQYsBMMIXUyU2idHOIIq1NADD5vlG4GLU8+UQox1HpGc19Z9VxEA74R97ddCzfhWSz8fj7ljS/amdzLtuzq/WBeaVBw+JZO6BEFlEcDxD3SHQRl8Yglsk5iwneiL7WHs+vtSs96+zs+xKU1l9rVQPG519uP+S7Zosr329LKL9vSVu4jJZA2rWH5zUPlMiodpzmsjUu26PINN6to7eyz9S13g8uQm4OpPFyyxYB8xBrev/lROd582u+megxyHiNxBkFe4g3xR2eRPsPPE51mnnFAOfSpUAorIaZhYD9iwN60iSwwHINSaSIPGs5DX3mMaAwNIGWPewfrTtNSuUulLNhTbc3i4v1fzbcK7/iU53zbJz9rf+iJXOFdReFdIsOpF3vI4QEXyghnYXQyU9Gd8rWMDkY+aA2Jjn3QB0pqWPqyyX2Wy7aElftAUveRdNqDYk5RNuuN3fO4D2T3GAmlrlge6Ib0YyTcIJRLSDmeyHWL7QZ7YRfM7+dow6kcVdL8vObWc31AjnaSSMPfrHgmEt9N/LyHbE+h6Z5h8adZAmn+iFxql0E4kTpWF12zk5QZMC9J9MWp9fZIqNkzXg3F+kJtK7H+gfaON6zusi0OchdSji9+9jeF18WZ+tQNMGEu1HXxJsydqm6gqQlys4/kGGKoFOwkG6HN77T1K8dRstxw3hYLLfRNzzNan9hCgyIiITdjIDez6B19/nrpqgu99vcN+D4OvhxXyQ92qI7III/YVr5yyrmr5kvQ8vANo+gjke1BTNBR6QdxFRhbsiEcWkof2lLUtKWs9KRpE2i8TlqGPpee6wuxGk7Fand2i+MOUQTieAPiqDEraTvU01qtNwZDuC5+smeENpiG5qXt7oJL6GUMp14Sa0FJa6ESQmgwhx4J+gRbszyQvoEQUggNKcFzRBtJQ3LRkE64sPUamoJODdWdojKs4nYk+vD9HnpToOHUHjGGUBrDLIjBYk6EHkwKPdjvSWgdawqDNizVYUtRH5EejT08k8hCJoOpzna0Yi/8o5s9jO+l6bn+NM09Q0zpEeKqQIiS/yDE92iIb/ybENkeIU4OhMj+ByHuoiE+9W9CvOCAGVogxLhAiL8d1ioa1v2BsOrEsMJpWMcd2FJSLOFQQ32gTvaRpVDX9xhQbiLqgkyRdUpTVF2wKRrGgb51oeD+MNUDYkC6+sGoUG9sIouhHxoFLfVed7V2GK3NlbQ2P3XquQEN+G6p4dQfaKxysV/Z4MCZejH0G0Npv6EvxLY/ADSrGNo7YJvC9iSMoD17jn0kX3PI2CT2Hfugl8H+A12aAv2JWuxHI6G3LDQMYCdfe1qyj+QZoibvI1M1gEXtI9PAhvGOTEecnv538V+6bmtDaA5yaQ4ecWq4fnTMKs8R7sZ5Qyy9SJqPKFp6jP0iyDX2NZfaI6Hf2OWNqQuCHibHgHt1WyuayDLsnTVs6o7mJmLUgAa7VpJ6jGg1iK+kuBTwJIqvorgM8MEUf5TicsD1FC+luALwFIqvpXgQ4MMo/jjFlYCPoPh6igcDbqB4GcVVgKdTvJziIYCPovhTFA8F/B6Kb6Z4GOCZFK+geDjgYyj+NMX7AD6O4pUUVwM+geLbKR4BeBbFqyh+jGRrQsz7YAyDXpLkQtnHulJ062mbn5QYBGV/zBFfWG9EmYilM43+MNJpQNKUYGvBVoGdZECpaIJ5A8pAE/RTWPdNJMWAdd8E7QvrtYmMADsG4vjZ+VQi7W/SJEc46FeedOi5ZKhfTNFwq//+o309xpJEgnU8HMbAODoGnofxF0cUHDX2ebAVP2qQ1alN8roIk6Iu0hRU19+krIsyBddFm1R1fU0hdTGgtfSp6Uf1lljo9Q44d2gzqJTNSexzBM/X6LmBtNdL1n0n9np9dUmQvlSHv9/bL6ZJBWmS2L/yYZqKLExihFZ+aBsf670EmpmqjjHh2Im9X7Q4ooaX491MSK03CpQ+QFEExthLNnU5lmkXHlGOZduFR9KW14VH0fbWhUf3GLOx3F18unMF5+P/AH3OINrn9Ex9Wa/UN3q6p17y/zz1nzsw9Zn/JvX9e6V+Xo/Us//PU/84Tf3X3t9O/bteTP3UQOpd7u6p96ezK+X/99IdS9O9KZDu7mOexP4gpPuKORRGqTAYpSJg9ImEESoKRqhoGKH6wggVAyMUpB/GJBd/i6zWJtEWVg39uJd/NjD6fSuGGkNDzaClMdYSA1z9YHQrrgszzagLN82s62MqgjY9G9r0LGjT06A9T4f2TEe7tGNkNqT3DEnRHaCt9efEEIhjjg/vXlFmqCAlUghNZkqDVKZDKuuNGZBOmP+ReYka2vtIj3QkevlxkKr5NFUy7lgnu6noTtVaJnEc1IrBPU7UwyT27z2CDn4KxvtwcNO6x0H44yH8CRD+RAg/C0KfBKWQDaUwGUohB3KTC7nhIDfzjoQfXdJDJ9hH3Gn1xiAo933Ek0ZuLofZY79yAfeKeCzFBbg/6K0FpFn7vaC30vK8jPNKSDGm/U895KsaUms3+/VuFYyGIa5ISGsUpDUa0hoLae1fJ61RQqnEQXpdfDxp1MbTsDU0bDOEPbKHBAghL8RyONE95O+cfaAk1N3kIRRCB02Ihh4OoTt5m++ulpZ5+iDQfL38015BElAnkXF1DXlQqkoo1Q0uZaDE9R6Y30rk4vqBxK7xMMOnW4QRXmHC2RnOD2j/72xylBgu27QrJTVBoHngXRD1xp66CIxPjsUGv2tPNxizHEsNQllbqdbTtWagNpwkpXQcO0nW0nHsJHmcjmNO/mnfEW0MzVUczVU/r6BpbfnSMh7mvIVnQKfHnMVBzlQuXIkfBpDcpaHrH9t4xhUXyK3ZLegwb1Zcao97X7NnwHVWMfX69xvaQJdpzFY2N2Qz9lcqcJ9J0OC29mh2R66yeVuu1NLSHv0+Z89UJCOHEjg2trXHsPngmkVdY57j7lxZPxRdJeC6rq09lvXfqoa3m3N3LPcPO4IrCfUrJfZH3bKOLFZypP4Rid3o3mcbA7OtRHrPxj7bWJDCUMC1Ij6OrsBcsulE/F7AwwGPF/FMwPsAPlDE7wNcDXiCiI8HPALwwSI+AXBcaRlCcUa3zzaxvK/pPPRa+FrtJZue0vFVbEXdeei7YkwpdTiap8JofowsLXHy73oXaifQ+liRqIL6KPLouSxc33yeGbzUqjyF8rvHxeijm+M0eIe2QKmhlMHdKM9SSmY3ymZK6deN8gSl3NONsopS8rpRllCKthtlHqWM7kaZ8StK3q8oE3tSjEznu6Umfp6T0Yc2T6TUrreMFPYJ9LVr/M7Tdbf+Nj7T678n/3+x9zZgUVVb4/g5Zz4Yhq8RUBHNhhlQZNQG6ANTE0GPIJb4UZlZkVqOaDqCehErByNTvBQ56jUmrpbdAswCjXvFIiytvBXdofBmlq9WNyei4R4UOnu+f2vtM5jCfe//3ve5/9//ef7PC8+es8/a6+yPtdfee639sXY/XgrFOz0AL3EQ3jCKd2AAnmYQHkfxSgbgeX0D8brpnR+43+VavB8H4Z2jeJkD8DoG4X1I8fIHpHtiEN4Ripc8AO/1QXjSrU/MALx9g/AqKN6xAfkrH4S3keJVDcAzD8JbSvFwjftavCWD8O6ieA0D8HIG4d1O8bYPwLt5EN4YilcwAE87CC+a4mUMwAsfhOd30XsK778ej3gH4v1E8VQD8P42CO+vFA/X0q7Fsw/Ce5/iHRuA984gvDconmZAOWoH4VVTPNzDcS3e7kF42yjeiQF4lkF4RRRv3wC81YPwHqR45gF4iwbhzaZ4OQPwZgzCu5XiaQfgGQfh6Sge7hO6Fm/UILxIilc1gM6qQXhuemOHaQBer2cg3iWKlzkA7+IgvM8pXtwAvE8H4b1L8ewDynFsEF49xasdgPfKILy9FM8yAK9qEN5WirdoAN7jg/DWUDzVADzTILzFFM84AG/hIDye4l0c0L9kDsJLk+g3AG/8ILzRFA/3/V6LFzcIT03xTg/Akw/AUwi/UKt5BwbgCe6BeNKtTyUD8L4ZhPcZxcsfgHd6EN5xipc8AO+tQXivSlb9BuAdGIS3i+LhHuJr8X47CO9JitcwAK9kEF4hxds+AG/5ILx7KF7BALz8IB6urxibDjUoeJQvh9VuFc/48EZ2NfjsvmH1CpAva1eyQllAXQ+xgZxXW8gKpQF5dqwQkBfZR9H5y63icV8N6FNhzbhu1C/dD2M3CH/33kJn43HtJQ7epxOAuY0UJgdYPMBuA9gPbpT8LjjHFtY4dWpF1djg3GGlUwmynSYo442m0jWuU6AEjlI24rQ5Q4KziDeC/KctxTWUfzT/eJjogjOKicblwrsBtKJWa8J7st7pPqHWUIwxIJf/0WUK6jIJVJfJA041BOcPcZ3iAF1v6Z/frwvOiWpAv2EFJ72ZmhEqLZrq/c5ZhbJdNVCuIdXyXSCRkn3aNkhhbLeyFFfZY6sVu4ZWK3fhCsqw6pBdw6vbSIoWcppSA1LvBZB4zzvjC3HOEb94tPu1QsT0dl8qRByceRzWXZVy3jkSaBZX2kYmahFnbPdYikNjhfALIPm2kbRgvCPAf6sWcZBSiIM27DAMz222kdu1mo79kON+qwtftq7o3laKq/X9ev7ZVtuRGmeiWqLiSKBi9D+gYg2pNlaScUDNKFeaPi5B0pdH633iK8B/4+haibRmVTpj4bk3Zj/6V/0MpCvaC1TvfAc0H7yHMg44q9KbEeTH7V51UNNghUn+uHrU7VD7YYU0v5JXNTMT7rPXOIdUn3dGVwDPgIuqX9kdWs3ox3Unq9s6Q9JDrUL3StAH4vQ/dqtKcdWlvlul1oLuKXYz9QmgfzZ0M8eF7kK1DvRQR/cnamZiXOstvLGbUZuF/e6G7syPk7tPq3/srq2u7w5VS/BJbqE783gyvOOX9ZBWJ3wphT3txvWjUHWlM+TjNqfquFt8hmj1v6czDo+C1ucTRwWS+SkNLT+rd5qpPosrnXL+zQZJy9sqRnj7V4xY4V1fBz13ouDVdlpCtPrhVFRkN8/KU1lDreEXZ+YprPudMyt+cQBfQMtQlZZQ/T+09Ffa2XzSai/GNawV53EugKbWA3iK7Jhs55E2aHNh7TXkiJEx3AnpJNLWB6Wg8fX3Du95MMZM9sAqViii+ZK+zrB3dGog9pvt2CMwBqMdZ5oyuldUAA0qFEc3is2BHB3ar5XiqfHIe/JZdf2B1axwF8QTS9eh420xeQdMcqtL/HvgpqDuX0npVU5nFnAd1Niizgu1qqxNDqk8ocGUFTTlmEalLcT6oYPN89D1xRNbqD1EeJqbNInbGnS8kpcovMSzUVwbgF5rwwGPQq/wsOkNprZOud4lNgZ0mHI2V6/n1yb4RN7PavH+aqynZugzGaBoZL0FaNrjldP+Ueotf/JqszVCgHkYcpJk5AyL2ucB1fSQ1hiP7FBETxgX0aNm5bVe8Q33IdN+0F2/ILVpwwx3np0y+1xme0juGW5yrGFf6+2zoWYK94OD52J4Lt7d2r5ElTCkduwhRsckCj+zV1vqhPPPZ+1s/U33D1Bbl6Dve7oUW+5JJ1OKe6RkPXKZo32j6PHXkDBomd8Y2zr1LKOvhZImpbvEKUDleZTKDyTogcrt0J8nMU+NXpS1aPokaK2jCr52XHCOgLyMgLwMhbwMXTykHnKRwGgvX5OL2POycUMH5SK2FfPR5kwpZVM14zAvf2s/5ogrEB0M486WFyxi8kGOZyxvz1gbLZuMfQLakzA3/TFIYx2l8TRv+DU0zvBKY9AaoPFMoHFh+6+UDQfKspSysyllYw0FZ3OAsp+HLAHKRgNlZwJleSgND6XhoTR8kLJJtUDXMf10tTIRPZpwLNeyGVP/CX1VKT+0p4xJA34aDnV8s3ujOMsvt42wKmzxVqVtpDXENsqqst1gDbWNtqptN1rDbFqrVA/lUA/DaT1UkqeNLrHEPw1rYdnw+nT+fuC4CNCPbgWOG13wCdB/JOR4JOR4OOR4+OKkerxf5VrqDz0vMwy/mkd5LeYygvbgTNdTzAlaByGlbLrK8H37qw55LULZgl9o+8B6iGMe+Qf1YGzqhP44sg7Ht2UeBW9phPalLYTfe4xvN9eQBfk3NMr05STZKLsop8+hPFd3EbDnePD+0xoSm/9YI9qWHGeccLGG3JsfAW+XHJwOcLU38D86OBqm1Y3jlUC/3a5x/NzeA0XY+z/rUtYVQN2P9Vga4+q04NN5FkHKicZs+B2faoDfCakyg90uN3xmP2ByiV/6OP1W2r/2Jch7kjmfuMrLJrEXmQl/b0/mV9I5SZR31LQ8HndcnZz/EXy/uMObmeQ8e3yijpdkmnxXjTNc/YjwmqvSKVPXOCPA/xL45eCPBL/N1RIc8WCkUaPU8YjwvAt7uxpnfCmubp5Q46ipuUb2wF4ZR85+eUbaZXJjKa7S0vkp6Htd4gbfn2i/I4N+5w7gArWX1RrofCfKa+amiw1KXkPzb3Mr+O1H06/m+ReyUQz1SRLYBsFIUPKqJHcYz3dOZIdQqWu9sMWzXpjgj7wqgxnZ9cIGgOn9GTZFVYNJCb3uzb69V3NwL+Tgz55kvgD4UNrfIMk+ku3qBuCNZDpLuVX8E6FW2rs4ZqvYSHCkSATo6yS+DkevmW55nZJHvsh0J9YpeKzNye7RzRoYuRnhC0sEtfB+K3xrJRecK4A+ytJRtlArSis32NRWlFZG28Kg5RxDaeb2BhhTDhOjkUlhhJcsOPO3ont7ab+cYjtymKTRsL0QNq50v3Mh3cfTPzc78giud2P4Dgg3QPicq+G4R6vGFU5XNbOgVR723qh/nMowofUsUCPLE0fzehfkdSqB/DC4YoRr6o8a8XY5JvlhGPVSrqbV1jkEYPfZpXykDcrHUiOTfKddykXKoFxMqDnvHFNYSVbgHPPiYxAyC+SxDwHrMJljZBJAOtt4fclnQ781I7wya+mMpPPaowvK2FT1uN52bB053kR9NW0d1oQh0M+fd7NaY4NkKRylvOV4F0X6Ovq7xRHDv0R9h+nvccc9ZV85kvlLtL+QZGFz0yvX7DVihcfoWvpC+/lOpV79guL5tk4ZjMhzactUe8P1b9C0zcAjMg5PKeFe82G1ZWJ1QJvHQFgccF28Hm+bGm0dlXejVQvahHvZYegnlwOFnzHG5eFa8jajQvAHlDzGesEzrI7jjaBRHiaavBgrfDsf6A3xRKS3dUalR+TF0v1slSATuMTTnn0JCXT1JqJ+DtTkA+5kPhEt3ie5YSwiW1A+wPXjTxhmOfK3aueBa/YKsIKPgNSQnEb323GQ7zsCoYe5emmNgRW6Ce7nSObLxLTAr3sJ1gur/WiXTVX1dWPcoahPnv4xipHbImB0iITRAXfbjbJpoM2VeobpkugYvCBBBXUT5TbyWqgbFdRNjTO24o8goyZ3q+kNwWuEKT6QOql/rVAEPdXQ6nHd6uoGCsuF8PE+8B9H/1phKfRKw6pXdldUwzf1Dd0rIXwUhlejf60w32XqTik1de8sBDkenvUVdaA/JXeHVaDUlwwaworuP5fWgcyMNxpfhLC67mQIU4NUGFaB8/p7Hahzboe+QFbHaNs6FUxI1Q7xeGCj+L5b6o3WC52+iNyQKtk+eTXeHLnLc+XyF8O/9TD6AyCDKEDacrvD9Tsof3AJCij/cy5Wq2rQtKB9KXMT3j7E0T7vQQI9duMhUw2ZzFjJrlTt2/fDKHCblt1VA7oNs6sF2vWw2cNzS8Sf/ArhJ9ANaoFPPnFzlE8UwgsBhXAhCD3hZinvoI6nAT4oHhSTcrY8l9GWiKf8TOJ3jlH8RUfJEsk+yW544h5Ii+mlBpxTf15s8Cv4uEZmjJFPaBBaXjUp+9TBm2p67RvFqW70b41/uEsmG8bfyA+bzejfzlK1Hsn64YtMGPuw3ywTh/oPmNBqoBRjnR/57a92yYZfuDG6Lk0X0RMBeCEB7J3uyHeJD7rT9Qso3Xygr/rEK+RdR+uHExhjk4K3NiTTtbEysdOnqqtdyQhbAywf15ysQ9gFH5MoB6kpEqSmKFZVW0kiM+W7K0lUpkd82If0MbqRzpFaK6mNxruOKslII+5MiNNUkngt7vEMTwjVp+nkNZVkhIbqzLyiXrHHJzYQVhtDxyxN017gi3CoO0bIDpDgnqcy8YAP7+tINqL8th946ICJm8wa0D77dnoXujQW/t21T0dbbNocWrpyiHdYg3SPAsPgiCjpTIf7Fjyh4HHMuRniLvKh/qQB32N0PiMTfCYfapKLwLeMwuaA70GKFwe++3y41rYVfAupbzf45tIvHgXfbOpbD76ZPpwpeRV8mb4C8B0H32SfJkjlW31Iby34Un3aekXPRfYMnvARvvXffFV2ZYRzfk29PFuaTYGRz/+3I/Ls9YCdydauYoRP6Puj8J7P1q5mhJP0PRPeC9jaxxjhbfq+CN7NbO0aRjhK31+Fdwtbu5YRDtH34/BeBalvh9RfppA5ADkAkH0AeYFCVABpAEgtQKooBLTqnhMAOQaQZyhkK0DsADkNkCcpZDdABID8CJANFIJyOCMELFj2FCj7UW9Ez/tcCnBWDKut9YiTvavqwmu/Fx0kvE5RWyXGkhqnQr3fualiuUC80Keof5WklCBJvWVcLvw8AB4C8D8alwnf+ZcL/0XD3rkaVgJhxyCsA8LsNOx8Zy3bcnU+4jjw2B7QERSg7U6mUgKjxxFW1SrtUD1lXEiloWKhx79e2O+aR98MIBvVs8WCA2B7XGc6tdCO4yCG10vHVw1vxe8Zff8I/o7xTOcUahFuq6WGLEld0FjjnA+S3V6qO/861uOuihrnm5Dfd42YD7zH/dcdFW+UVpIPjHiT+1rhYzeWw0tnZzCsAcI+MqKW7ru6s/Y0lCsrvZL8GZ6Z8PwYnuNB5w5v5fQokZyE9+TUvMbzzlmlY7u3V3i7T0tSBfQk551WiPETur+9NrhjZChAPr264/2880F4b6M7PFqIGdr+X4LzZydgJNWTvcGd4T8lpNR7xWN+LR8BbVDSzBn9Dke/nCjt7f0B+m9sQ0bgj4N0NTsffL+nkpQafC94+lvsbo8x2Caf80gyZJlY4THW97eeyb78q3ORjHCzT03bktR2JviQHzVX20aSr5+rpbZ0A31PvNqWhvr6+XeRPVaHPTCTUCYu8NxSd0ftd+JzgTvquNrnxHf8Nc771Oedi0qjbQor1plURwS0ASVoA3L1MmGv74IzoRTnwX7lu0Sg/81GK/CCgUr5/XraWdq/7XcOo7LerztoxgAX4UzGUPs9tvPOxVAvIdYeOn+jKiViYSAW6Z2OstPsBK8YAN3wEehh77ja8t/w3mX7zvHtxEeyJNns99fMTTLCftybnzzePopqC6HY/7uHQnv8ThwZUNBy5vj75241ILUMcXMgdctA4pbbwq3RILHE2EKrIq21pliQWoioC4ylOkIo6AijIT9/8hn50TCGCk1K/rUGTJHzSjtE1XUN8DbTi1JuDbk7kxmfax9L29j5znBoYbf6ioW/BXQUMrwK9+0Xg/xSLJwL4FwkalRDQJNGWkXb4ujO7JFWWW2MDfe1MEmjrLH7nxP/5pPVKWtle+R7FL/7SnzEpwR9OwT0bRXo2w2mUNC4E/bo9uj3EPFD/xS9iY6XlxNu1g8H3l0MlBwLIzaT6L4q20q8q2kK15aJLf7kxqfyZAVP5WWDe6rgqTnaAoQ3ArwM4GUALwN4AYW+CtAnAfokQJ8E6AEKtQH0cYA+DtDHAXqRQqsAugmgmwC6CaDahxH6NEB/A9DfAPQ3GC+FlgJ0PUDXA3Q9xkuhawFaBNAigBZhvBS6HKBrAboWoGsx3qUIvQ+gjwH0MYA+hvFS6F0ALQRoIUALMV4KzQaoCaAmgJowXgrNAOgjAH0EoI9gvMsQOgGgywC6DKDLMF4K1QG0AKAFAC3AeCl0OEAfBOiDAH0Q46XQcIDeD9D7AXo/xrscoSxA7wPofQC9D+Ol0F98yY33APQegN6D8VJoF0AXAnQhQBdivBR6EaDzADoPoPMw3kcQegagcwE6F6BzMV4K/RigcwA6B6BzMF4KbfXhfP4LllwIyYWQXAh5/iLrUan29KpUNeDwPqiX3CpVE/hbwKVCWBs8z4BbCf5OePaAawa/ok+ligA3zqtSJeATXBn4J8FzOrhm8N8NzwfA9YB/HTw3gfuDT6WqhOcecO9BWnXwbAT3Lfg/gGcbuBa/SvX8LyrVC+DuDkD68DwPLhT8h+HZBK4S/D3wdIH7APwRoko1FJwP/OPgmQruFiZUNROed4JrVoaq2l0q1Vfg+sB/Hp4/gEsNCVV1wrMH3GPg74OnD9wj8O0D8N0j4C5S+t0IVN0JtNsJtNuJNfAoQmMBuh2g2wG6HWuAQkMBug2g2wC6DWuAQv3e61vfRQq94r2+7WlXIPRH7/Vtr4BCz3uvb3sHKPRz7/Vtb9OcixT+off61neKWBiEH/de3/5OkXIKfwPg6wC+DuDrKHw7hb8M8DUAXwPwNRT+WwrfC/BVAF8F8FUUXkXhFd7rW9wpspvCn/Re3+bw9DnCiwC+FOBLAb6Uwl+k8EcB/hDAHwL4QxR+gMIXA3wJwJcAfAmFv0Lhd3mvb2V4lh3hWd7r29kp8jqF3wrwBQBfAPAFFN5A4SkAzwd4PsDzKfwtCh8N8DsBfifA76TwYxQe7cWWVX1dy9p1kWltBB7aBPxThnwJ/j3wrAE3gQ1VNSJPIn+Bvw2eZ8A1gr8Tnj3gOsHPEuB5cAlcqGoEPsHVAY+y0FZC3VJ7/QHeI8A/FFyCCvDwCe4B8CfBcwK4++D7VPh2ErjnwX8fPB8G92fwl8FzBzhWFqqqg2cjuOngfw/Dwd0JbfEWaGNTwT0N/ofhuRLcOsA5D+E/YJ7A3wdPH7gIeahqCLSfEeDOQ1v/FtpzJ7ih8G0EfDcUXBngTILw6eBOkXcoDc2e5EYN0E8D9NNQ2p6g8OUAjwB4BMAjKPwUhS8CuBrgaoCrKfw0g7pUG8T9MMS7EpxCEaqqDKZzN7T5P8DzMDhjE5N4opOZPqN4rhBILS9mkpjEsgKu+ESnfKaxRUM1YSaZ/XqjyNFdPZkm8yxms3nWhM5AzszNIAlMmNK+QTzu7uiU6xu6uDDQg8NH3cWMXTFT1frgzImfH9x8qlPO6o8eNDEG+bmEzQWmjeIZ74GCiJ4Q9gD4O701JMQY1sjqlxUzepwt4vTLNi9o5uow9DtvcjOefYzJHtWKGI9sVlyU4jgPfNZhT+bluJdvO9N6wSpnzCCjROA9MAE5r2lmEvF26hT+r50su1E85MW70JgJV+zFJiahensybxFn+392FDfhLX0W00p+KL9RrPeCpq/D3cKMXrJsfSZQ0Ijnh+f/JGMVdtD1Zx4C7f7lLJn9Q4ByOMuk9dBYInh+c0AsDkDKWoT3l7AEUu5rx1LGNC/bfDTr78Gba2sDXY6yYvOsf2b1VLoj9j9xXn+dOMb1v+f1/7Pn9csfoOf1pytMuxoienJUUAchlJv0s+hMMsvgaW8VyaEnvS1itC/60OQZKWoZmT4+JVxGssYvNcnIDHrSe2bwpHfmEhnhR8nIrPET6Env6cArMpK9JCC6/d+XppsPlhabl5UeNetLr5i/35y+7uDm4nXRmJ8yiVcOXWM7wJ5PxLb/iO0A879sO8DwD20HFPyLtgMy/4HtAE3wRuFVfsl2QK26BfBSyK7/5kbhe/39tgM6mICY7x9oO+BuO1oOWG+X7AbcZf/3rAZg36BJnzB7Qt7EnIlz8MzqxLy2zljZBPgdlj0hL+462wFoN0BTOwJyNTJoM0BTGxCHUpsB6NNQmwHoC6M2A9Cn9Ef03Mair91/7Vl9Uey9elafiGeCZ/WJaA+e1SfiJ1fP6hPxA7f0zQ+BWxz/yll9TZOdmFLl/OTm/aD52skBVi6scp0iJlbTkp6ePg3tZGMfl0lUI5XCEv84Hi3IqIQ/BcDXV25WCEvIXCFOhW+vm5WCkWTxeBNbg9ki7vXMFTShuPdD3vcOvD/rmU3DODOTZBGfoXME8j4lhJR5TpGM+afIFHCZ4GbMx1tET5E54PLBLQS3CNwScAXgloMzgVsNzgxuPbgScI+Ds4ArB7cd3G/BVYHbDW4fuBfBHQD3CrhacK+DawD31vzUHJBkwPcOuBPgTs3fKG4AOpzmxudsRCtZY5ix8r6bi0+RT7mTncwKeV8G+M/ORz/epvBz2ji+nPw436iT902BEsVBWZEmOeCP9ozjMwA+B/zh4M8C+GLwKz3RVEs+1XlRL+9bWoxxSfc3VIHbvQDyvOAV8uKC8JwN4ieeV8jvZWHg+xB8B2Sh4HsPfC/LJBvk1S/gX+c0tDuFNg//9I1GVQ/uI3Aaaif9NLdRHOXqgPxvFONcWHdyYW9Aqs1LfnmPilEK0s5coekZXCOGkZFJiNOZ+BthzGxwrxdP+vGugA5yKhrPmh8m4eZKEgltbAj0CdH505tlupW8AqhVRoB+XAjo4IU8C++NhDjwjrOXLocksOOUZ3eB1BJX8lQ87kcwzwrJVZVszVK2zy6xZinsR91Pob19ansW7Roj/2qaqhpwb5qcD621iKvcI6Ds2R7sOfZlKe1c3QYxzcfZvhre1hmRytVDCaOjIdU3SGZQhhjdKre1dYYZ2zpDjevFguC8SLHwjCuqSmsSxVf8o/SpdA5hbm/5utD6gHiPT9Ogaan4m4bS0tz0cUlFgzolnE9uVeuYpPBUJc/WtnWydwMN8s3iBp9cqHHrS7/bxNbJhXOeOB3UPOR0mBvn7W6ENMf4OZvS2kLkRjyrUkOU1HoCygaVRGvEW55xFu+vQNlKkgDwCGrBoA4oKq/D2j8b+BAoit/lNSoMIXZd6fIUebtydkgup/2N+IBbDXKHvJ4FTA9IF0jrpgf77+/A+fS2kpcbxk+YK4znklvHJ2HdSrNjFvGUK4VX9oSzYbVmcYhvGsSw172S3yDu8GKPp02XzkoOt0bYRlsjbXHWKNsIq8YWbx1iG2mNto2yxthutNaQe4244wH3EOAuiBayEPxM/mGy1ag7hKtdjC6blE+IqxtRn8xXOm+o4IV7A/F1ow6NhHdemBfoIMujmXHp7cPqboQczA1AC+ekPVMWsdjVfxPBjecjqjvI6uhKp7ICV50WZHNWRi+zxuTJwSmsmZfZGFy5H6FH6u1oXg6tankRVxcBcc6COFdzuuDq6LB6BcAeCXzq4OqV4CsI9DiYVpVqCLW1B23pDoY5kIl24sxNbSUHgHb9dBuvw9k2i5gcpFso0G2DF2c2YwF6g2u9aPSFAV3CgW4RQLfraXYD0Gou0OgJqPNYqPO7jFjy6JpK8jhQbY5x5J7DpNQ4/e3Yujhs8/5+OpigBf6drAdZPCaPg7LKrNgS8QYZU7TCipYrRujleypJvHFTsNQreewrPoUYTJwWuCO2Xg7vP/u/dBTy6HP4rzgGllUAPn++QZmS3KrURfDMmBA+PNXEM3sPE3mBWeS8GbpUnqtlXrSIdaRBjyvuyN+3Uysz68W3QKJXGPtPqZ26EpKNM53974mRuG8N3mbXQCvA8+y4a6xr05ekIBqt1yCOobQNVyHJJCP2JVwd1tH9/o9IAYf2QzjK3zv9xIH2f7FeftsQCfUSSeslMkilJUSqFxNvFus8zAsXnEmFUnufnd3WqU7HvWDYDjuIOVo6ATartAXaFe4xxf2pCGshKqN0+k5tRIkF84btEyQfI+5DxfaJZcNvEQ+/RZxKZwjdnTcvWAfyuhDIsRrqwMyF0xYqg/cUKAHTqv5SP0XiL6l9VjTEQvuMhfYZmxTJ99t/2AJjv1QeBfDZdM/DQkhg0duKfUXCCHccHTuKhCfdSEklwKLcMUHYevd5yMt+Z2TKsW5HBfJKcjdXsV78ztPQnZNS42RG1jhBZxM+868Xz3pgXFt/CnDUwdaB+0Jwr1DOm+9UX/6y9A6cA366gTFFgVwR6ZUlzzrrLglNAYldltwaqguB3NHeMB3XNM1it/tm03rxMMSq2sDijcnsB9C/4V21NUDXcjIVnqHwvCMN6VtOpqfh7qlyMi0NaVxOMtOwfl4hGWlYL6+Q29M8m8pJVtrk0nKSnfZXsjs6F+hbCKMr5Q/fh2Q3pwD+SOGRPzb7iOP0vRJ/7GtIBP5IBHom0tFDVrtFnBOkpwzo+YLbGFwl2CJmBtaLCzwXnHeUgits6wxnGZCuYIzZkEq4aYeyNDzXw3JKez/POKDOexwtrhQjnnTD023ICXjPWY3rJuPQKjw9uJLHWW42Cc+24Xm3/lOFb8FIXkkW5Ut2gmJKzztl9IZrPPMGbdbF1r0FI/wG8SMXB76Xwfe+C0/sQr1dXXWIOIMrt/cDHy+Jbm8Or4uGsh/1goTExTXgDoNf95GxZzh9pwPq+yokpxW+zP/WEU57we+8Pzik9Vesc+RLtEtobvq0ZHfD3PHJrXMTI/m5QD8Fb+K3iK/7dVfbl8uFI5LaMJRquedChnQkm4j4qsvUCDWtjW+M6AllOaEjgKG2EI6GtrliIX8x0NPIeXmQh+S68FS2lrWaRbtLb/oCZc9G9gWZYPVyDRq6P/PTkh0NWsiLNjGCl/rDLeIKyIkimJO3XNF5MOJoR5Q8n8XYv2uuIaz2fpAnGPsR8HPGOw3R7VyCOmeruMMtHx3+dUQPtq2IADzZrFFafqu41I+/21x4ExXKHEtrhqiGTA9JMTaxAstqz+J9SFyiLPHpuE3NDeTF9Gw3d/mLkNAze8judDb96yMHs2JbnwY/uBiEQZ9jXpTNTmnw9ApMX6nZ2IIQ1sMwLofEm9HAm9HAm9GUN1ngTb9P4k0WeDPPhTvtkhpRPnG5n86a0Y7r2ErA6vKtF/0u1NYWG5EDsB+WJItbjdhi0O4V9mBo76oFWhjaulLqWmj/tUQLeg67HGQdFXuY3GFUJbSABIf6F/SN0S1EA/y0L/owyTLO7bVA+4s2hu86TGYYJzUr63Cc3Apy+j7KYcp6Dt5PebAvQ3u4/XadPoaShdF6DQFpKQxqVgZ9gyy9jcRA33CR1JBhmYmNGVCqZ93lWWvaW1waY4srvKDFFZnf4orOVEH7mmyyknlDjnWfrmDGrbD3l3stlHurS6lX6S44Z5fiTW37nbnqC+CW6/EkKOQ4ndqQstZ2j1Vz+r2eK7/s8Vzp2+250qu4/M3dysvf3CO//M1CpIBU/gzQdBdbgIYWoCG4WwuAZpmrhfe8F5y3qFcLX3txVTruMK7/JZHEqS0ktiCLT+Uz+IDY41f1sKpjPZFRSYSL6mn/Euj2Gnlx2Tyg1BigjNP9EaVUv40nZX0CQMd7+hyZOiyNCkoz0gU9QiGuimHrT+4OqaA9AuZPGjkXIzzDVOlUSyHBEVQ6mYzvYaWimO1K03NQtwsZ0JrruUMhfWPXqSAtxtMKdfO3jGenMUzODGkdzD0D6wrbOdoixj0l2K+HQ7+uc8mSDWe/u6Zflw/o1zkyJO+7TSNLqrOG27EnVxpi2sdDT3+MQE9Px49TMA6dudo/J/DIMTvdH9D+2dii45FjDrkJ1UmxjxagHTwDY/hcIVKO43gkj2uZISBjbBFLvFJb4GrXih8EwqF1x9LWHdW+uKQG9PnqLHU7ctGHxHl1V7c8wS9uCqDeIdkNQTu0yJOR/LijTMrpVpkpZu7p1pPkQAJIlGrsCT9uvQA9935nVMUz3ZaKe4l8bnnjQdO+WQ1ZpH2ZaQL6unPULJ8MFNL4GS3WJmnBe5tcQFu8u4hJXJ+LfeeWJhn0XAXTcSby5ka9Sct/DV/XZmna/2YyQj6LiFL/ENUxehO4em43ag5+UReQQ1tabvrBYYcecVtDOFIfaBHe325mKHavFWcG2Dq8IZyd8YwoeofnsdXVWfqz5ztlKyT9Udp3FP/5kNmM3shP4ouEeE/kbLaq/y3Gg9Ly4myMhdv1jFjj1TaGzFblyrQbxWleZYMd6JUv96y7kWWYz7m9ubhH65ug/oBn1yc45SCh7Hceqni5IRN6rUwqoWQG++GDnn6Ja60o+IvFhoBWp+SjeE0tjqu7PbjvFnc/ZAtTveedkRXnnWHqhm5TfEH3djXuWssW8rwdZBFI9dHVeCt6pTNGzYzLFAIWTd1zwDE5oIUv4piETF008MVqGKN3woipWFzjVBaClFPYQXKi25zDFid1v1aK30snjYbjuZrbx3SPLT1MLEbpZFFcEPZaKWomEmxUxa+7T8uNmO5pSLcY0g2HdHOupmv07HeuhRGYgzRlkOYcyO+wwke7Q2ia0g5PTLPq9kfpXk6LUYJh/Lj7Qk7THEtbbdw19gakNK2Q5iJI83PQnOdAmkaa5i/uGqcK0gstRJtKHSQf0oyFNFXXpDk0mOZ2iH81TRPyRXcgrAC8w2TNNTYPzZDW0nZN3R2QUg2klM+hjhcNOl4s6CpDrR1kYXQk6C235Q23YgrMuHzAvgWwtwH2QsjXKN1QyFe9OzUv2hpjRdnjprxY6015w4L4UwF/AuCvISiJdJCzaRdIrYVNPwU+eV/Gunbg1j92cWErumThwOmh385UtZ6dKf+c0b/XyaD95DTU0OTYY+7U1EdBTFbCOiTfsyQDfJHg20EeAx9qdeWkBnyoIW8hbwZDS0m/DTq0tYz9Ht6Lsannkyy8IyN5fqzqmb9GMzl5GJYxnWG04CytKPPgPejYJx28KjfKqeSIY7PR3T82rxWf8BWLU/0zKJf3y49aN2sLt3K2CKvMFmmV26KsCpsGNP44I4wlpb9qGvFG3AEN4xXweexVOO6RRXg0fDHKWOkc+usXrtH0i0pnfGm/xYoWlzYIG3kNTBeEjaIwVo/QSlJGbTLhXaoMQNucN4DWcgJGzSF0d8vDwlF3DRkDo/4M0MIsoLWPhdRHqyuBVyc1q+tUOevF7aA5z+D00KuqQYdcL34c6NdfvuBum4R2q3Hfnrkpkn+lQdqzh73CPldvyQMgsT2Q+AC1ZrlFfM4lSY7hQMFvvMXiiz7USzT71glHPZLesk6I86IuMwRgdZ7IICzSi/MjZ0htNNoTmdS8EsaV9eLUwAeklsPdvoUwrqwXt0CuUG/5+bZYVb/e0p+vashXJt2ZBPI/5GsM5GtM4phgTrNduqv9VxXkK9/HQM1BDbEs5OMRz5RgPj72oFbAAex+z21B2AnPeboDKx7G30Ugj4wvRRnqgtNQSOX5zkgWx+kQSvkhpVgjoI+WolyF+gPVNV2xRpT7UTeIP3TBeWPhAnLnhDZyX9DK5MPGY9SKYSK9axZjxVNIeNcstVtChhnR9g09HQm8Bn1nKdrDaCMPaA+Te4xnyOvR05vVOnVdKNCoyf8BeZ2LB5qpQfJfL/4AmijKAh1Qj19H5Z7AOsX7Svrph7R7FminDUpgb5DekhigXUxiTLBV/IHorraKy55i8YgXxml6DzFrU1lxnJZuI8aZ+DQjZwu1onQjs50hDdFqaCVhVpQsMS93Q94auEgqWbLw/jvIG96BgnrIfzX8EVL9YyLeg/jHYK2ZyK+11uQ5AdCJkJ8HCEr+oAlAeu8Z30qpbX1LhzJ+RM/7TCU5oV0r7vecISeAJkrdRJquAdI9wT0I6U6k6d4P6cbdjuleX3YjlD0achGdGB0s+9hryr4eyn6zF8uG5ZahfcVDspNnyFvRkn3FVFr2/rJe8H1A3rqmrAmQJt7VYGyK4Hc2yHncRSevfVL8JfDTNfKY4jp5bK14O6Tp9rDQJvrnDzvIsWicT+RsIZCWnKZV5ztFjnFhIH/JaVpdoB/j/Q5Yvl1QPmlH8ZPiiUBvyWgo3+jE0ZTCT4p/CvxKYTmkdcqDKyMoOaO0rYAyRl21HzkT0gy3niHvRMugB5RDDzipWUXTXwllfYdDi7oqmv4hSF+6J4LpW4q387I38Pk/sbJYXtbe8mNGZrFY9bY0X7NOWOHnRkzvUsg0/Ag+A/RAc9NnJXsbEidC3zwG1ySkvvlJcWkgjVcEa+JNt3Sm8Unx3oChNNKq5c93svqA+FEAW3Sx+LBHBn3z9dbhYqzYslW2DrI9OtYaCiMh9n3Yy6iBetu5YbTFYC8zx4d9H97Zgnz5SkPO+LlCDpfcmkN5UxoLnhTjg5SLhvyscGcEazMqcL4zWo93y5YFYoEbhtrQLpVk5SoOanEE1Fo8cE/iIWm2FLU0OcvsUvQlrpPT1If76OmGVrwTB3XI7xq+hXHqWzr/9S2kMg5S+cYvjVPjIO1x7qpg2u3+853j9Lj6nB3AOTu0EI3WotFytNVogByMh3qbAPU2EShyk+28c6o6xlrjvFltBNkA87FKuNW/WnjUV+nUqmucM0E7KgB/grpAeNdXSfYxBcJxH66PYL9YSV5g2vDMSN0N9araAuFtH8KqjTLrcj1jldfLDsn79OuwRG94l0KJ8J6fCZ32ucAR6+2dF1d0AFfs4m38OuE7ksZb+B38ZJ7RRuWahfwA3nGcyedCGOfCkHz+PvB/BniT4UlIf7hZmBJYJ7zhQ72k5Uf7cwwjTMPxAOTZ7M9KnmvQTJwraBTJrZoxUXwKrkrxSqDTVH8aj/NZSqBehSuFnil9UkwDqXYmnnwoPuCR7ZB52BfwRAzuDIhpP9+p0mtNbdTuq3rHL+KTbnrKdIG63sCvBX0k1RWFK6NPsSnFPQwr71u6wfA1fLOiKi67S8amxa/oYmXRXSpldldoiCuqKO4M5HdWDyO7XzP3pzQu/i4LnjBgmbGWEZumx772JUhJz4G0vy1r2Ocf0LMIcnv07GiQ5DeIi/3wrb6DvBKNc5zzmnHeG9o/aOyvcO84sO7vDDgdXD2O6T96jjqC9m0npLKov6Dssyco82cuwr7oaeiJuNoI/nFxsout42pXCF8F3tSjj7U+Ls50Zf4Sl4rQDwIGXjGbq8NbYHsDCHkroKBnwm94OhTq9cr0PTuj+GH8Pn4c/8WWXVvkvF90uzOb5frbS12bGKuB3nv/gXvpxaY+bou8XWv6RZwPulbqxczLIfqaLBmFfO/rczT1tW1Rtv+xm1FPz0XYrECXI/NyIKYmS9uebjpCLahBaOlvpDE3pdh0jcWAFJR/QA6OR0pcJmhFSa5ltJiHozuZqncg9sAWdXsqxhKP32h5xA6I0a5jECbfAvmAfDa7Gx262a5NMSU7s8LbM0rnl2zNUrUzu0bn3jibg1r4nY+jq/KZv3wG+RoBebeDvjn98jPp1Vnyb4bn/iKu9nHak47bS/3idFcHKYh+qVmmm84PwfHYfYoUcP/lyPzlL/Ct0E7nwhKYlC47q3uKrE5wOFQ5WTyNf/p6Ufk23pGJei7WWQ/U3aiHpLvxpPmlBOgbEpLCeSWfEOwnPwOdWh7sJ0eSjGA/edLL0pnEYvELgn2kYp9Z8PqxR1SCT/Sz0Fdy0FfKoGeQQ18ZAj2CZPcTV3l00IPcA089PO81fr8J5SA9yC33GSWZZbERpSD1IbYeb9cOiKI/jp65/sd80e0ayBfNrmv5gvcN5IsvvYP5YrL/f8YXfvFS4F/nCyW5li8Ou/45X+z0/j/xRYG3ny9uIdfzxVeuf4cv3M3/HV9I8jDyhh54Q095Qx/kjROeft5YI0YE+nmjySPxRpH4QaCfN77xxVPp1yxMv8oln/uGBmG3/Y/55Xo++TvlE6b1V1n005K/NdwCEsotiZH8LXQ+Gnvs5R5prFVCvhv9Gp3UY9/nwTMmHaLLwyQXtjPal/JqyGw6f8TamZSH2mtIHp0fxrdF7UzyPfYWkpMZK4TI4lqxxDHGWCEj6tQViwztH8cCjNHH9l7cgvtJpDfcUwLh8BwCzxN6tH1eJKYF2ugc2PpoZpypnasrx76WfEDWcwaTlSxIjTmKu8POkNPcetHkwnnx9EZFn7IIINGlgLvQtYckpW1ujO1lNuLu+hgjY8jFM9fwnGkvml2ci7z0iGc5neNXQQm3Qwmftdc4Q8G/Ffzbwa8G/+Pg3wr+MPBvBP+03sffxJmYDnEtfdvwJp6B7hBN9G3Nm3gKugOkI3xb8Saege7A+/7grQDeNPC2wHM/jB5zIZd/Jr9z4JluXPN8UjzoLhL/6EeKvIWrv6mxvZkPzRVYGa5wVpJRqXfb0X7sDalSaR5sR/qOTg2x3WpV2W4DaSvDKpXvbhpyY6raNskaZrvdGm6bDCFzcIU8FTUIxpBDMRJSpW+GAiSbQpJSI2zTrcytkbYsK9TfmChbtrWSjHm4Burm6NuIoUvV2KbCN9FGK33Xpw6x3QHyann0urdj60ZDmYZCLZVz8x3fgaop07/qOAhPuf5lR2yvZQZrV+hrHFCG6S86GJr7P9DnjalH6DMh9U/0mZT6AX3qUv9Mn/rUNkdsfQjEbiRJQVvGU7Kku8FyH5LGWrwrDNvk7xsM0CYNSZG8ga4HhKD8H1xjDgHezvb183aXCyXcaPBdckn1vs3NJAMXa2cCl8+8yuV3ApfzV7mcBy6fYceya3DHhhH5Ffm8kuprQ4F3O3zIux2UdxcD76bnFIsVoPuv55BnOyjPRhKJZ+XAswCJNgCOO7AbePZoY5F41Bd6qK0zmh1WP6RuAZGHZYHbmeVq7yAlEOct7dF1WsAvgDhLuNGUg5FTx0LuDwQ5NQH81XaJT0eCf7dd4tKhbonLkUej3BKXI4eGuiUuR/6UuZ8E/lRACpsCf3BEU9/6wMcD6H4geBfSBKdy56clLzWMhR5lbGIEPxbPC/LDgKqTXdK60jCg+nZvjXM4xH3GxSRnCq+XMdqPgcaPUxpzQNVMoaashjxBqSy97ynDfdC7APqkUSaEhJ28Yol+u4eJWnKkgiTrZUImC/2HjtHN/amjGL4Yz5wb0VhBUvQVZFw6C7+G9AoyHtyE9CIxzKfuyyl6HyTCc7RWMoXqsiH8ISjXu/6PoV7OgZ6LvQraNL+vLKLnXsA7zRWLkwO4IyO9UQ21BJDo/fDF2EA11BJiziirhrQYQ6YQUlYkfuVV980pZsafhFROXO6yDIfe3OcGHXRfBMjQxI1zNCMAdsWt5OP3RQGs262jMjmOz+Pg/Y6gXqhkUU8zC7d60njUEifzOPtsFiZ6snjkrLygXD7Gg7I66hTwHWsWRtNwNYRL8Q3zoAyPIwvalDUL97jw3SwsdJkFxo/fjuNV3VVqLcAY+m0kfCvFRdzStxoWzx2ZhduD394K337nQ1ld3a1R4y0TZiHFFbx9AvyJLtwpZBZ0gPeZL4vPg5yHQhpG+PYzN5YP5/qk/H1I00D9UyqfMpiGHL5tgDQi9aE0DQ3mh0hhvxCz8LLPIjCZZuEu9/SfNWGrhPmeefA007NmGaXgClXwXUb3itIGkE7e6r5E12oze16xTOo2qUu7x6lXCTP8F5w3VXzs/KyC0Vc4/1JR4bSrPyYz0oe/ru6bXzTysJ6XfXIoS1Mwr2AUz/WouF/akacK0qtJcnpM82jbx2RR+jnyeDTUeRHy0weWIfwo4I69vo/J41w1SQG+SG8vEj/zqPsWU85D3lW1j4Qvzemj4Hd9+g3wW3JNjI9DjBbKnS9DbKEQ21qIzcJFXby23X0d9edpONeEukb/3ZsJDS0/K3Gu97kaZxy0Mh3B8ebON2qcI7D90zce3uLhLZa+TYO30fAWQd8y4G0kvCnpWyq8jVJ/IQYC+JYCbzfAGwkkXZpA87TiUkn32FIBJLjeIG2n9c1/E+v9POUBHb2NxCxooa4+9ep4psoQrOHhwVqMgZBW73knowaZEWrjCcpRyE14et8syAjGtlbwBTCmtYIrYBZe8+KdIEwV8vJa4TLVX9cK3RBSfU1Mi3yxDuyvRvmmOOTwjPOZod9C2vXTCuelP2jQwhihpfq+lkpoT4h/C+r7auitUqm+rwXoV6Dvq1doeWwtfjE3EG5LtkbYxoEmr2UjbSnWDDqCPCF+QNsTyq+3BbAlyGqH1ETt1/z+t6LejSfwFHtkv5Pv/av4iktpGw6SXByM2SNgzI635iXhzittUJdn9igh1x95mT2yQ9H18r7EdTJ4b/XOpGtx/ff4BvXv6dj34nrSmYpjA9aTYiFPm4MlioUSnXYVidvdGjrTnlzLJDwhrva3kG1GXC/q302BN4rh6du2zsQVbc4xpb/abgaYc2wpcub7ZYl1xyFHOi+uJRnpnNcTIu8fVpdYCz3XiguixZ1oC7Mm2cKtY2wR1rG2SDoX00Eyo0faQq2jbGorxnOwTFlXB/H4QavO5G6GeAwQj85/w74LzlcqMAdmYQ55MSgLN4I+NYYdDb1nFvldEPYawbOjLS6LUZohTmbxnqIOkhGNFpWulsm1VSqTc/w1sPIgbMJV2FzBko2wVOtcoSy7zTmxNI3mcyGUtwzyWY/7arkbIAcs+U0wB4+S6T+PCBu9b60gBoqCsCVkN/kxbfrP8WHyvikbPM1oaULoXqnGvBJqQx9zWU5xhoSdcr5dmsw/JOxxy/tO0F2r5c6ltnLn8kMd5Oe0U+Sb1Ix6Rp9Fzk5t6J4dL3QXxvfHx9Yl8/K+d0pY60PCXvdp+BJTYG2nyL5UtIXSATFz8PZiqqPbRKnEJp1ymq6jSzkh87DMYXWnnKuvo045cdGQcuKed8r52NWwcuKZhyemE2vLnWsqLogVrsQ6We1vxT+BnjUlWgHpnU0tJ8z8csLOR+odt0zn04B6YUC9KRzmEPf17CaxOomvaiswn6hN9nY76M7EOVQnqM6KtpeT2LQicaJL3sfR/rODHKB94x7oG2+EOL8FHf8AXVUcA5yj8LW4KowXnPGluKKopGs5HxYiH42hazkphb+uFNqNLa7fGpW0TJcKcRWzzWkojLsozeP060k4h4/rXni/KPa3/ffDtn366VS8W7Sk55OsX+P8HOJ89qol9BU0zfHXWDzvMOrzjMBRk9oT63SQ+61uaX1ylG4c5P5V7+i8MdaxdB1wVF6ydVReihXzPuntxLp4wF7lxlXAjP5eviyxfhjypPuOS8r6WPD9wf3ApcT6GPAdcL9+KQt03WLR5uYdGnj+zr3akUhluF3uD8GH/Uul+6yDYU5Px3W86hdSr1u76y9zf3nL6X3tf8iLL1Hw4XxaM2faRR5LUKTIQfqKN79cuqwU75r5Dn+zC0Eqes+y+uxMeP5gGXU2DJ4nLWFnOXg6LHL4/ZOlqzmBT+Z94iOBuItTAfKRJRN+/2xJNWjapZB4b9jFOwH2O8uUs3nwfNbCXH7GwoPvhAW1v/xUa+P16RZB2BVLMfx2WVYZZDQev8gTip1we7OVzE/d2bghuOsivP36r9dd/eIPLoMJZwLuSchoWWgotD9qKLLPN5yioQHoP1sdVkjjgCX+bDk8t0PJ1hq22J8Ev83ymKEhmP9w7yHHTkO+vcqw2V5h+EMw7pneAw43YO6xqM/+Yii2i4aN9k7D3mCo0fO8ww+hZRblWY9hZxD6sGeb42hf2Raz/Wjfti2WYPwK32aHFP6mf2PQdyywziGF3ulaHfS96loR9P3dvzToO+J+IPiFJ7DIIZVruWtB0LfOe1cw9GZvbtC31juj/1vftKAv23d70JcTuCWIJ3qNQdhf3YYg7AXXmKDvoish6NvkHhXE+9wzPOh7zBsd9L3hjQji3eBRBX13eWTB/D3tHRrEO+vSwLjesoTRomyEeoiSP9wX8gRj6hUfChzP5fiptaXiyYBZbCFT6zie1a4UTlA7XFHQ3rrdRlMViUszNPfinhB9FL3RKN2EdnM4K+7J2UYKjEwiSuPym1lrumnkJpTzxz+l1rEQwxbxVZCNMq9c2orfxKUdbc7UxdRF7bOIs0hMMlsV+U266YKzuvAL5wra62+DPsZL+4oq9RNitB9HfFk1a7NmZV45vtUIeQ4JxBySVSurvlzSK9r8cl65r1es8p8swX1YCt5CGEuUYczZCz/GCMOZ4cwWZhdzkKljGpg/Me8yf2H+xhAmnL0X/p8FeV0+k7NxuNYw82WH7ybQQPUnzYz+e/NrZtlmvcDKDMW4419vMZSwBmX7wU2r1hl2yJpXlbHphrLvSyqJaOwq2UaWpRo2bSPLU1dtYtO3kUdSDTteJabUQyWvksJUw+ZtZHUqoz9kNpRwBrZ1NxmaAL16Krapw6TXaCipHs2mMJe1W7Ec6cHyJPufKvHdJOthZU+ZVa2cDtfjZObQ1vfNLOQO8xTbetKst8hsbPoah/+mY9flPBty/pLDYU4AasgtGbxXlHkNm78KUZwph/dyorAo9MxFmb7LvMsxXPBHjV2ntEsnqoDakMJl4Bz86kePXP+zY8U66e1bz/eO14L+rz1K/QWHI/jW4QnRn3WMLZLe2jwqfbtjrLAle1kRoz9Y9H0Q/p7HsPlcCHsmTP++I1R/wnF9z5L9U4j+5JUQ3bKikeHfF70c/OY1j1p/aDBmdj/my1dj3+X53CHbtHiUfgYHubqxGGHbPSmbvodebEvvjW+G659xlD8Yo9K+c8edB0sfLr1Avjk5/SdZwvcgz7wUCb7pjHauEK5axjNdkRybNl+l8nCuJSS0KnfmxM+5nsAd5pk9X4Tr8rNlXYxqCWjBL2QNa0We20fkTCafAOnle/Tbvz6yPyu2NVIfAdSFcXndMdBlpvVeeMOwaR9RaK1Zrb1fvSHvCWc+j2cS4mY8Id7hsl/S8J9/9RdHpEFm12//U1fMTUPsnN5g1m8qJ0PXfR0SfiYK4orQrypGDprWe/INBkKbLrFQN4aVhsaRq5Y1Y0im4LWwgJl5WR+dAG36MXGZ9+VLL5UuLc36idV9C9ITPKfvm8Ukd7VfcmRv/j7+KaJfl72Znfz1kexixrCl97dv2InmwHHIMSO8bmnr1Ke/Nvu1PDuJbXgt97Wcts4k/Wt5bZ1jY16F33GyV/MMA86fqXs0rL52vNUrnnN/V/LSKHWavha4w83p5H0V69D/mTsE/Dup/7RbVYfP3R755RuGKHWq2keFKwGWx1mPHRb55eGjpDO6av03hGHeIXJjNbTt3WTYt+qqw2S8EbXE9fb7eZXAqdIJjJvPtxBGE/J8RdaQr3aTkKpFJWUzQ9p3E1XVPvBx7XEl5pnZduYFNpV5PjT9R8fU9hBblGHBWayhqHbQXfQXyKdluEMorotjcrtk7DnQrKS7SjK/YGzfbQrZJ+s6Kbt/Bms8Z9aVxq97inAXD0HeGBvkUAthrCI1rIuV5RFWC/nVVltQA8NYdkIsW7PYzz/u5FgWai/FIZUNtDQbxqlIv39GnMm2PbwKd9ZijjogR+E7MFcvzIQczPz0C8PKkasWNP6j+jzTLtN3OBjgDfEw9tYzUr8O4Tq4hF7R7p5ahzPbb3mm1il7VIxceDuAPhOjELZ5sUfenapvBEhfuZkTnnCh73XwnQMso6kPev+2H1gbY1CeTzOxL3xOSGrYjPfhd50oelDflGyRRdC1zBeysi5rzEit1t75hyG1kAxeLnxEb05F33afgcd5c0x7fEBK29CIoVLqJpfkx/Rf9aWbuGocY6qzpvVOPLwVerSvj+BIM/YHRhsBoxdq8P/sjKHpoRiVpfJ+Bu8vn9tbaH5C9ARvmfeKf/GAxgpU2eRVgB7qFeu8Wv4J0eFJ5jNaZLPluTJtsegMJPFo1/SH2CF0zlTVxCWw2i3ie27Q4/j1IMdL954oc9Fe44lORifjmR4VJ/vz1h9lTBxvnsW09j6KNtNleBqdD/ma0eLZqWLxREBr2iLudBfQs+5bxG3UknrCCmluVmi6bfZtuc+g3VrIRX2Ag1Yh+o2Na8QHvXLT8iwtj3tN5QD9GcYKYyO3b4v4iFsGv0vdPzs426oChc1QILcdKpDZugpMwreurFEhvKx9jXgH/Z7VmoQvXdmjlBR2M4UxCbWQo4VuNuFHeOa7lzTH5bG7Gety3dxeZhmbMBTk4KxA8sOnhjMJGfwWcZqbNeLXQ+nXCEmEb43wTAuGqGgIQoa7Me5YN8Y8xL3f4X1UKucjT4eqYqDMDMD/691M+J32TkwTV88kZhH5nZmXFakIm+vWNLP7cEe+lvc4jE3K2VwBozvRySYwifLZ7xcwSZLtAKY1E+Kidv5mvVeAFgPIXHunfIWNv+enEJmc38WHta8Ta9zUPoBpPv/VSi1/P799FqNVXHx7Ju5klX2OO2xbfiTPyUwfmEauTPrphw37ZhU0H4BWsN7Vvy/6mW6L2idZ1Fq8p/Gg6QuyKEGtP+K5cpnryuKOdylVf+jiuFVdIaGgi84s7gqVfXHuuvSSP7EzExTnOyBvw7oU6lldP6DNgkPHHf/sZP5/6lz+Y+Li/z2X/x8+l1+wgp7Ln/t2QzWE7oRa6BVzXbLNNSEWfuagc/AhPQEukDTwJDyOOZVklLaS3JCPZzQryY1V++h5Ta1xa14l0TdIp9l19OxbghbtgmF4RM+PYWz6dvChRGggpqkhh0J72NDmHnVUhD2GhDKs9T4ez3aztssOScKbTPMNX4a2EItxHDk39W1+84j7Z+byrFVhH0lPvzcDfp8jH8cNfws9bRtOT7RHGJnxaMnoLNFomHGM0GSRzrUzwnOW9k5uB8jRO/JKWkgsgyfY4npYLreHkR0mE+hp9nmz5+XNz5k/p42MA9lCp58HUkSiLB9+x2TngyZ/rSwBFFHjeXZtLZ0/rMcbAdW6kDptbUAs8afwk3j0Ffs5nYzC1vhDdGrqW+nXvoilO3XlAxXaRpjHn+75jSqiZxITShqmqoRpqsfFcu/th7Jn6NQyUjdeFy4j9eMTqmXkdWob4XDQNkLtHBl5Y5SMvDk+MVLVE8rlQooycmhOQMzw15CdQJObjDWkgu47rCE7gnsOt9M9hzXkOXimw/NZeN5sjEhU9ISrDsyYzhuBO2YRLAn6xnmwJOhL9GBJ0HejB8/Vq6l/hEf6YhLRO8L5b/6Fc/WyOVp+jfiVh0l2t2tadj+A5xFwDwH2XXJ+RbelFM8mlDtzcRd8xX7nGHU5SUhgkrDvw9PmpzoZRTnRpY6Ffu4PRT8UQd+0opxo560ULriw3yt35tG95azhWCurP0WSU08R47yhOUXiCHdtlrYg5NwaUe2Kni0zRdNRdLYXrXZrU83ihQD2vWuFdW68NSOkW6P+TffYUnnfixtQ01srGDx4ag/POmh5Av25fcmpSfn3x6rKTdJ4weSfnIVnyjNNqsYi8bhLS0fPItEp3QYEaaQ3okwF44Ge0VswTew3Z2HI+/Rk+dFGjXGd2EzWCJ2+Z+kc5FqhnsQ1M9osbBPPcNqnZ2+D8VnwIDV6HTB+6GOylfaTpYxhlR0ttWDcY3lGj2uT95K4sEoSYiwS33VdIEIZuOcVPK5U4npXnYWZkCm8aukgxoQOoFJ1luXyfsvtfIIpky8Sba6OTiW94WA3tGRoQVHyniS12c6CtmQWZ1NKBcS4gP63+rIfinKgRgs9+t/iXZu76V6GcHjiXoYIeCakVhK10aWDEPCFGefxET2RzGrxEb9ez9VnXg4bgvLfGz7ISarWhLvijamY/yJxqUvBv+pAmtxEGP2cy/lpkpTa2rvxzYOleL4szXCw6PGzZpEN/PPUMb/96UNJWJdOyoP+ujys9uU6/t1ScP73IIa5vU+vszmAVzaaxbf9aAO3P6cJb2K5gMIJu525pdasd1p/naVmFC2twZ3QKTjTCLxbeqz1o+5nCpFnj7WecuYVrhXGuS441Vf5UeLFH1wfAi9evrRWKGaES9DHX8ODdN/a3OjpyJvYvjRNijn6kvRmVjeEl+WsFhv9rF5vBo6EMAzHtYdhc7DVVcH4gK0uCmiR4teZLjfP7T1gflx8068AOS6bv53Hcz+pEJrkTypocj/duzw0NGeNuNqd2KiiJ2eKxZfd2EKSeZzZZBKT+G5HbTCdfjk1oyn0zoDo9o03TWlEGfcRv5Z/XNzkB52xQJaDu13XiNnHmdb+76Q9dxG8WYyklhYeNkEN5U8K2lVYhzaJCnBnHe54LxKVBPei7oOy3wZtkX2+8khAPOVT5Y00TW5M2FGXJW9n9d8XYbpfBOQ5MmhXRkgv7Jr0/m/IOavFS97/lXP+s3LOKyZJzmlpwHX4K+KXXpRxQviJg2399CRwCWOCMs4dvxxhJw6y9lPwq7WfqtmVoMtL1n5StHN0aPOnkhgkaz9JMRezLvtjDl+17fN0niQJJRvn6NG6D94QxCQqkhKC1n0OXbXus92ouMa6zwJq3UcXtO7TErTuI6hxHS8FZKDQLiWXx1cPsO5TF7Tus08bEA8Osu3DCDUWtO7DCC1X5aDdln/Pws/82fPzFuQsmAOSkH4BSkKy+fCbnD0/L+UfykO6WgPIQ7p6lHMkGz86kHmW+dOA99H3ILXxg777qI0f9C3060AiEsJAIgqRJCK0FBXRM50JA4kIrUVtFj2BKYcmXycR6f+pRITWou6DFCWJSA8SkRVocxtIPLi7OwOeuNN7Ejxx1/ft8PwdtdhQQ/bCcwpIRLJbbpmRNGMcnwm89K6n39bQFXE/LQv6qv2SraEr4h5/v62hK+JzfumbNz1TKWeG81/9i3LRY+KdAUkueh36ITYvDq3LtZ4AP6NHSQF0+HS0hPNUgYI/q31c/NGj5O2NF8iMA0zP2RA5j3N9KKmDjLQDLdfgDtfN4oOBc4RhtMtPdYbvONUZuSPn5teynO0y/aoCRj+xwFBM++pnmNbfQ/thdRlNIXNUOUP41WKNR2e6vVkD6bzpUfCqxoD4TiCpIKMF84P5Mzc9ZeJNi0flJGwtuC97b1b4eZkpJzVsBsgtM8dny+xbC2SQB3MLmyY4GK3bgSXAVSezmOI508n8yIyZK+SENswccT7UoxQju0LCv6F7t6PaP4Ve3mCaPCOBV6XLe6Zw84K3Qj+f5WrHvLK3fu+YK7D0rBzEoVZ7Qi9fnBnZxckizqs94d993smsQOlpP4zBe7MyWr/lsd/pcpyk8cb8w3g/x/zNfYq3NYSDLh4Qbw3YYPw3NC7gX668OffmnE3iOs9uMpFaoNkNkjXoPMaDlWhXZTfI02jb6+BK6KVXQi9dKLN2dHLsskK5dY2Q5lVUgS7NrhEmeA8WKqvYunw+BFpuvQ9r8hOQNRZBavcFFHxVo71TvaMD8t4M+n7DzMvtd89g9E8Drw7LeUw87me0Iyk/sbxWF127WSzys29gHHHWqM/Ub0Z9FPVZ1EfppsnmDrrvKFYff6h6hpqolpjFIndb5zBWXYcpTQl8CeNjamGMago4rEd7J6u3ZoWc40w5CaxHpgduS0BKob09sWk0L9uMo+9wfnJj2PaKkiE5Q3Kh39i4Sex0Y5+DOThYoKV7mAsat+40bK/OEtuf2vJ2Vm/7yS1Hs3raMawtoKBjrZD5mHj3u0zrg5B2ajB9ab3n6YYo/gKRg5QqfwkccNsGGvfRAqxllM4+ovfOLbUbjWZxrGcH0Mgy8/Ln8p4MBupSsQUka42LHfl8VuI3jT2BaZx9Z1Ztaxhfm3Wl/YcRe1wZmuezRpzDmXjZroDY5d0DdJVVs+n3H0EKp25mxn1qf2nnDTlQtrFqfh6/SdzkPulQ8187TrRbs95t5wzq8+mb9Y0v7xyag6GFbszTw4FGuhIhgxp9D+PUsmkQn9YsHnNBe2PTNstsTMp+O6b/8s5FPMR+WxjE/heHIkeB9Jj7mNgGusQrK2NU366U6KF9KYRB2hB4/78jixwg/yuL/Gdlkd2F18siz5P/Xhbxc/7/oSyyZpAsMvcX/7J/JIusuU4W8f+/Koss/P+9LNLk+f9OFrkslgR+lUXuc/fLIgvd/bLIXPevskiuW/pmZeDfkUXidOE8Sg7TPbhmcKJTqTvRqcrauhRvwjsJvdpT0MPhmkJ8QRzeE41zHoWqxs3iC4ED9LmH3seqamIKr4hjyIkjKoqzVpwYWFaIveLI5r9rN4s7AgVLDxbqQce0mDeLWwMHlhYUxjUeKGSMca2sVtOS0fTJJrkhnNecZfUWoBLTM4kL4zWp0H/cnwUO91CP2D7EYiuxmhnQaA+amcLLYm4ggUcdMiBOe1eyARrFK/idDQW5mYVW/u+6zeI3nsmbTIXdhn2tX48ATuF2t8YXP0PcWjzhhuGfelYVMrqnSLfWVPikmOMt4wua5+UmQ1niQW5RsVfEYR5lopYPoxR9x8SMV5zP4Z8U67zsFCZZbGfGrBa/CqAsdoIwFgx50SvnSfNq8bOAzLSzMblwWu4VsdctxSW43x6xQMfdGl+8pDiH/z/svQtYU1fWMHxOboSbBAFFpPaQiEaiNoAXvEPQI4R2pLW2Vm0bQNtAUBGtIq0aFTuoZYoGnRbq1NZ2xkutRGWmjKU4Mzq92km8tKi10tqaUhsMKp6T+7/WPsHLzLzf+37//z7f/z//8z55dvY+Z9/XXnvttfbZe62py9Zyl7w2xzFjpJUaXWyjhmL+s96py/7uEFed49W7aU2iTa7JtFGqLTylneWaLd9b9iKX6RVpawZdH3m149ggWU80tZGPMu8ry5pu4s4GhrF/dNBjqAZTmVIPsF5WyFZxOUE6K6DWdoj37YU+nnbPPSZpoiyD9XvLVCymqeK00ANWDi3poWJE9tyq0ZqTNnpMXD7Dvsj92UOpP7LFkvBRCH9ggzyVKWwhPI/yHiDQCwKGTJc3O3LZ0w7Z0CbgORpMcfId4P4G7mxHnLx1b3/5wC/7y5eQb0r4DWozkfMHsGEXxUyyPjm/knvRI2XCm11t15VJMH4vcgGPZrWBjN38O2O3CcZOGhq7bg+9zwA9KnWrrQNctJi2iZhvHUDlbl2sTGcNZaI313BxAUp98yLwyGES4HWYyr0VmmXXDZ872qE9xOYRtK+i5ZUq1Fny+DHKSKmHX9xsXG58XSc7I2bwXmEl95BHxlS0Kdk13GY/pZZd6KePzhczlZzKI2JuOK6TW8la4xpuWFA8RHpBrpeS2HjPdYdmGcN+55Awlx1XQvXdAj8AbmtVnBWhEHmRVokrtxr/Bvx5blF47YYVdDq9Ab/XSRjkybJatpLTWxTiiPrBi5TyLahpBmlHtL4fqemyW8RktSlXq414e2ktt9YttENGYm3u6w6JUrnsioFirkFbuhy3Qm2ZA35WSxTMmOvKGALxGR5VaLYMvgPxGoC4JATxsZ57Z8s5Xt7KLMtqEzE+Rx8c8Q7wglaEo/ziGs7gQ65OYxhZybBjllW0SSBlFlAHypibHM3KbGu4WSSFCnqvqqQY9bIsci/OlbONl5g/6OmOea2dviYX4XkTuicqrKE9bvl63qOVABcWDfj3vts8Q8ZK7eXcwMAAldggYlI7ryvj8g3Ql8vu68oJLIYuuEvK+uXjHIWWmxF7d8Pbf7iXJU+Y3vf0iXtPGeCx+WxXOL2GmwtY02FXLyP7WgSX74eT1f2/htNb7rtwWsOVBO+HU19ZClLW1v+krBfvlJV9IxiL5c3x3V8ewgvvsWFflPlmKLMIymz+D8rEVC9yhe4jZVQq9LiQTmmGMtf5wobEXsQ4a1kWYPpxf3MPJY+4UM6V+SVGfFPtLecW+iUA45jONDaHbS6r4hq9H/Sa10nZ722YotQrUamW/Qh4dhdu2DYzK2fplAQ2GdIU+GRD+l0clqKG8AyocwDUMAFq0MJzPtSQCTXgfvdoqKODVyuygCIO4DfpaFuCXtG5cPDQI0ehRiWJU7djezFnqV86RG77EWaEMDOf4Mu5fn4pKXWIF9s2GMqW+qUGJhnXm2wdthD3K2fAHJgcmg/YVkHjwXXldDI2bXxmaGya7sDxZYCjLDQ2B/myMkq1ge/WZi6bUEDvF/coogayicanjPGs+IQ8s2SGkuXsicbXa5tWv2VmDHuWhe3DEVQEzWxea1iT+Fan7nCveVaYrZz7oy+BYHA/ckcyzrU9Rgx4fcA3RHXTcdQob3pDJ7cZy6a3KlPWcHu9lLoL5lezh2KuOt7QDT4vgre7vJIh3160GnUsPWENrBKUWnwBTxLs8pxx0Mr++RiuCOIZgzWcxUOP6rR97KBZFTuRnNBLC1LqdvsRY1nZBPKshOc/2RF238Fs+MxmJbi2FmDVqAvp/oa5Xg8pw3xhbOKxR/WPAuyXca8Fy7lCXxT2ZegfebGWzvw9/FMjq+1HVmdWmlVHlgly7kAr8ombzC/ztDmdJfsSOUHOe+zm6uuaZztQYltuxfz7X6UzLTq5XQ3r/aNeac8EWkjJ/vnI6p7kGE14x+WfxC59pCJ+kHLISO3kbCZrzPRhYUOp4e0O7MdRP6zHJPRXv9tBKTH0s/cWQARDrb7rjn5Kt0Om5Egat8/h0JH+j4Z8vyPvpvgvEb/Uf574h/zniO8I2Ik/MHCK+E7/p8QfHzjpEA/9yEENHc6ucZRzn3oPrxYbMyrXKw8vi9XMctGiG8tEdvnQW8tXO0Qjby2XtN9alrliuQPHvSSEixUtW6oLyCmzz8gpsyWa480yWAeS7KeqAqPU7YHUANFRUc0tCgi3Vo2siTvs1rK7eLoQ2uDdpJPYv19dSm6SqoPZzRVtuCeTW3Yc1t3I1o1lB6ySHi21lKvy5ur7vmBEnkau7EXugIdSlRTvJuF3IbyneHg19dASGwNjsN2nqpaxcdbm3k3rFp2hUvexs1xmuWrLQTLW3xlVG0qMdby0Pkb5uq6Ol5nreDlzio9UTD1NKRlYuxxuSp1wYZZLFJF9Y33cn3tEMQfJt+WY3TLA90yv2CjczwvbnVqJvP0IoOhozQ/zvgA4/d3FK5AijEK5raQ0cbqq2lBEaeKBFmxajpqVcmOiTufd/kD8mu7yefw+Ha5NrVxUdN4xyyWLOOmA58LbSX9m97xUx9PaUmKN4C8ePGO2y57dLOyNmWuGUP8nZHETd+F/ZPH/Zlm809Qni6MdALQHsItPfPQG9zHI5DcO/w6k8rR/Zw2AjuXp6MS7ZyBS7sjkij5rAK0okytezUcJXF6Vj9YAKJDLFXj2L3xYXOc/6/3fhHr/mUGC3n/Ff6z3v/Y+vf/3S+Mf/htpXPpvpPG9d/T+J9NB7q3/j8njz98jjxcR/f8YWnBHHn/yjjz+2H8qj1dzzv9H8njK/x15/I4dgh6u+Y48foPbFrJDcIN7JSSP3+B+fUcev8Gt9wh53vrfkMe1LZubo1l6Xzysu35PVmu0VdakMURZRU0qA81QnRSD2lnxXAGVUjGTMmZb/2akNRKbCCggxSwGmSGJyA0og4vz1nBiL/5TXiKjL46TM4uR/5QYpazwPfYaSO/VnDWI32NDvPcsauiZ5njDVjbZkJyfnLdg1zb2NZAix/tlbOExCVDM2cLO9JgMdneKaG8Vd94vP7Jnxm172iHqtwWsjn2UFe0tcW0PitW/2BdZn26iNOGXkmBNnQA1xfuebnpgOqWS8vRkeqgWylXDanqZV+z+2iFhbzs+UMbKsZ3B8ji0z5OKUiJlBPycIz4g2k8bg9z7QVGT1CJuklhURoMxyXiQT2Qa4T+JmW9EzfI93NRgP1UW0TO5MkUC+Mf5VcYzAK8tOuD9Mma5+lFR7ZcMSQaEJMKJgnWuivvBBzJIsSRf0jOUquKO+5jivr2JQH9cj2XGl7Eto6fZPquKSkP9lKgFn2ionCPdUcbd8rfBjDtstOhGX+g1KI2xW17XJdg28EMLlca4DYxRdsCszOUVT9Nb6O1Uz1ARBf/xIuBjgs1WBvr156DKKH799SJsq5Sp141pfyyJUl6AZ0nj+dJtutp2DIuUFwwyYS3PqQdaI2FRf8hGK1VWYX23tIq75BuRFGWjlQxw562+LCv6q0jPBK5cVTYROAI6BXmoEpfrowro/xvNRcMyiL31am6qhzH+pXTeCHX7vJRPD0f3xEELP4WW1fH9KSnbWGowDt4i3n4QVugebkvgZdTzUyLen8lWpQS5XL/SaCnVTLcUKY1nSucPPlP01CiVkT5/oTSiFXpiKGKSid6TipbEXwEkU1XGY60VbQm/UoEc7LFdNIo0nN1gvMEV8SKyLtcHNui6z7fofunAp/1B6fQux0XA9h9Jql+FUq2BVN9Aqgsk1Y8B6fTTDqo9GBRTy1sUwDENYB8AvHvdI1GLOgTrRJRSsEKUH0i0phmjChp1Nzskysh8LaQ76sHvDj/b6f3yfO0DJa6HArSabhcX0I2zczWGxHaGveQwP0pTPwN+/n5/rJxr6Qflx7PQQyazM64KezIoXwEl/c2jbk3Mx9n1kYdSX7fJG0cQXqwfqbU/1Dq4Q6yMJSlWe8Kg1ktQa7/8zuQS1y0/rf7KnmakmyaTrzQag7xxgqATBCT/T21icqd01404eeX5ODm255evhfYI31febVYAB1LPNgIV+dYjZWuPXObLm1HmesSbfURcRWt4O96cF1mmJ1MqySGxhWrIZeex5pQsdhU3IkBnrVU7OsQHKIuSFR0Qat4C8sAlG97upX4blp8HM7fFf8RIZx4xnHZgyVWe1L41uFzY80F+kxr+TrOZH1ohZVVAhz7klfC/wyNjDUdS8lPyqrgor5lNhNatqL/Mv7Qb5TUfjgC0UQ7YQI8pYB+DVlENkr3i367ivvGLDyhZyT7kshXQnqs28QHJ/hzCr28IXnZg/jGeoYSPw/BoTza0k/NI8mV5L3GLQY5x2d4zdKOdA6Ax16GdHwG9QZqI7VW0UCpYkyslLH57Pd4lyhRtON4lhVBYZhDkGqShy4nWbhlqpJOijQBiHWDHQV5SWMbd9KqMFuslQxtPMcOMbbxI25SE9EB2CeE3zo/45fOlGlTGSa3vMNWcxyd8af1bMNWQYtxirLZCTm2jrqNd1BPMjAQagmVsM+K3LRrezIacNMwjEbFJugfkgTXcdTeObtIsHIFnAXLZBHJxZA9PYctNpiwT2UyAoGjvKpBjcFylHSJYaS8HRXtf4gYEVYALnXbcMcwEOVBIN4KkO9eBKa4E7WR0N7tVBOcQTveuH5/7EH+3+XD9EOUJe7HWdqodYXu/BPPCJKkmishq4khpZFh4kHuqPcjNbgtyX4Pf8uH/2hrYfxfPXcYx3v/huf97ee6sxf+O5+7hor3/w3P//4HnXs1lBv7f5Llvu/t47h7ua5/Ac/dwp30Cz93DnfL18dw93Mc+IY/D/b/zDQwovmkpF+NjypdyZ72SnjxK5MolNh/DWiQqtE9NpdDMFNdOr0QdZpcWtPESZp5ZAr6MSTKLm5/mJV6q3fY0xXwJDvOg7RKxSM5Ocb0EeUTAQbSRG1j3ptW2JBQkPDKoCk88/qUV72RLGYWqDPIUe8VD4i/t4vtpNRX9IGcU1BJdIGpMImcvWoL4/0VQU1XDM1o8DXnThnd5xEwF8OJOxxdQ9gk86wHuE3CfLY8LncWElVUlrsg14/e8aBbPfhQXK0tOdPVTot56chtlZWx+ycorRVhyDcyekk17Nu15WbWwhp+uFeDyvm8Hvz29hp+r/XFRWN5SbqF3d4kMfIO3swTb1QCty2rb/TJNvTQtXv5JNurt+HXzQHYIi7veSzilWyHYuqQpSyxwF1Kmjh+QfZCPr5DsnOJq9yjUA+3xBZt4Jju5Iq5gZPmD5v4FQwyTW0X7YqEW4KoWAoSJLZwUNjoP9bLedkTpo0jv5/mvlc5LpjU/F4k7wvN/WtwDUgvuJl913AsPbNcvIZhErEA5Y4A+rnZTM53ZdDjOfBCgTiklqrrDlAVkqAOxLM2gpvoprmXAQ0rsUQUU87QZoR6hjyS1Pui/Qmr9HmoNy++EWn34VUP7C/AZX4bqvb8+GPEDdYclShUveRrkAKWEjWUVMO7ZpIYIqGEXqSFcH05q6PbdrUFGavg8VMM/l/0gjDFaJMutPb64jo8CShoN8I0Bbv0IL1G9TqSih1LEKjHQiFR/A4xigXUX4Be1HbFNrBfnU1DfH32SZkVb1hKhXG1LnL5/7RYd4mkkG3NecvD44lRe8kAPt5lPVopQBshIS0mDsff5SKtbqTSPDcpmlFYp+QpVwdX5pKTdS31O0ua3KoWyv67EtSOYI2ERQ2rZNl5duIRT8IiLndCDCHMdH1lxkJcboDeFPVwhL1VdIr0YmSJRiaAXf/VhL2ZDLyKgF2j1g94h0UtIPx7zERup66n2URVxoXtzubUijey8mJHqpfkVXI4P781J9Bl8HIW20setENKlvRT3L2k1/5Q2damQ1kbONQVzHmAl0IOBZG7u1WWfX8y9F3xubUkt9gL7E+pJIZ4171z8ldXFdQWlqhMp0Jt00X6JKhNkqPm+vjHp680A/QDSl1+8Ql9c3JeQ6yqBgToEg2ySi9I4bXfzRei/d0QQmLd4hdhvbRpWBiOM43HS+7WjNzQGKsCfR8CtXh7Czfek7FAY3+OLXcD1ilSRpK7RKUroWSTM/rnaTCvaUhGHoPymV9B1+tVKobzxyCPfY9cGLbvQllKuJJCm38XLFHFVr+sKiL2cx6oadWLbRxraRml0dhVIT2Pti7nYYApSy8Kk2h06pEvM6SH5Gnabm1IgfekgWJvdOvvIIH0SvBdOdVdwC45prBp2gD6B9G+ONwH6LsT1cGOOYR6MV5AvRBXcDG9MfrcD36qs0eQ0ewU3yRuV/4NDTPqCa4YtREclq4R+DQf/EXAV4PaA+wu4q+DWQX/Fof6KlfhVW7w3Kv0gsTbTT1vKOfyZ0O8o0u+pdrScdW+/x0K/M620Jhdi+jF7IGYqwOBVcm4f52SJmdYgFFQ2kSbVRg37/SaEgjVg2PTz6hp+DJNWXcOPZcQs9EVRXHvcOsJKbU/MT9Rr2QrutMdQS9WX1KVVd63GXPoA2trAkMV3nujD3ec756BGXLPFsZH5UfoKrtXzYwgqEaGZ2+yRAyQR9yoAkq/+WYANwuOl6jj5CXDxL8bJJ74ozOPPqqQhSEgJJEQACZEFMR7G378C4BBB4IC9jbwPDhPJ+Ge79ppNsxZzMYHf8pT5BLmfjPePw4GejGUa+DGAA2Qe5AS5zW2TKlDnd4mZAbohN6BN0Zd12PqB5wuIdCIPZLJU/Vz9U6QnBR6J6m4p+D2HUk2qEGYVe0xlLdTPykeojfeU1NKaBFvYGZFmoO1hfT7JPdIT0akvsAAWUiqrZ31PEpsfTnYpQPY54xBu8F7w8aFQtP+mY5L12mrKMlU/IT8TeJIKLtIDsjOjqti96RqOnFaDI6cdW/DcJihVe8Sz8eb8cFxzyRfxEmxDtB17M9g6Wq8G+nPNTTOTXfVBYyveYpqu3VP3rzA51lbGbQuo9GJjMmm13X3NIdIwgFHP+RGau+uwxMJWSnPZ9vNqgVIk6mOh9A/dXzk0VjHMIGGGHHXHh8bdldPDWVoFeq4IYcW77pj86yG9gqdgjjSH6GsP+AXLAC/g3fPgt4Czg/sRXD+gNzPBzQdXU4nydj1yFWyJFfu1MEioFAM9owZbkbZUcJVuitxeodr/tPzf0RbEMBowDKnLGF862tUj2DXTjnb47sWuqfafVwOkQLqeZk+rBrhBCDGO1qjtxbVIixp1IwFKZ3yE4rDv1gW5oG+TThgBlXWwPpnQuhFuJkRxgtyb7YmEvkrdAn3tsSUQPdQIcZm9eC1aBlNaI62UqmQloSoar41W8Y4okutnvi9XOKwuFNNHx/gPEKbTQ2vLGvDfBvczuEiA7fL7aI1AWw8Sa4IymGGHvdl3YLD6X2BQYR9WRY1+Bnpp8GHb+ijLSFsyYPpoW1CTbkvXZ5DxbeEFillS+5B+FOn5ezx1z+wREXoQ5D4+piZzAmdEJpsRmhMyL6X+Fvp61ZFOdtp+BTyaEFrv7XEMvpMjPxzz4HunJ52VklCWd24rNTaxnU4VZhJqZ41qVwMXdtZBp95yRBPoFZD2TQpRKaE1wP99gHsjCD/EQYTf3BUCLr4E/g5wgv7fbbxSiyd+4tkCq1gTZtOtpdIo1/D18x5E3Seq9dJJtOaNdlq1fKWmtHJtIkulPWMzub5znyb39Ewu1sMYigzGUpPra/ep0LvJnt2G7wwHSvcU74DSI61SzcN2xLOlN3PEOM8ppbKoa+vWw3M0ho7HNWbXN+YEDeV6w6zriNVU2eI0a2wKWANrQLKt4UcxGqOqyGQsKbpmvOxsJnZL8A7kfNfTPFriulKEuAz1MMU3xeIaEh7KYG3FNzeQ2jB+6U1ZHMZRTEOnydXg7mvzq+59DjFghExzlLQw1yUSH3Q8qCmyFWpesA3QPGFDChRqiXYnwYNrW1/VvwqQXsrtDYqZ8s6cG1syLLrYjpwbm8FfdfpTzVxbzo1aCHfal7pWiTF3nArz73Pk3HgF3i8/n3PjF/BtEB8n7nb09fSAcU/RVse9/cY314jG6t7u40RLIfbmC6IztPjmx6RPa+/kWHxf3uccGMI3mn8qYeydEigCIZPxc4eQpk/XF4EJU9G21DWOtJ8i7Z9doCrSlKqKTaUlxTi6OY63NmWC09ynU9sXKqPk5XQSpyoaBVRgpb1vHIU+XbmvpJ+3Wg5/qRnf8bkm/PQRzaiOwxrp6UKN3ibpiNesuzXl0NubHux8GmiGFZ7GHcL7ob8SQbsYbFWasYbPQAudaX6i3S1TC7Wnfb/JRFrV1xrVywg5kfLa1TbN17ZPNcm2P2nsjuwb9mVbdfKOI72epV+c/krzmS37Rv+UrboTjuzbJ2O36mQd2bdPgP/R6ewbZ5bdgLcfpF//J1iJNNNulx66H1KfOHaSNSKMnIBbylkCIuZJWCPGen4zma4K3VmksrMTIXxXpzXa5R02St0+LLUfO4zo/Y3YW8V5/H06HUu5mW4rULU8QtX6A1XLJ1RNBFSNss1u3cU/oi2utejCbNT2vfl79SKo+YmAEuiAqkqkiQVq1+Vug3Xm7ToL4SaHoGSioEY4If0b+bv0YuYqcjzM7FaltUn/W9LycYHXgcq4uMTABYfS+lv9dvJWE9iZf9MxjuhorOL2+eP3R+xDCvW1X8p2WhtCfPF0bZ3+ZZI+LrCFlNLrv3b4Xr5jlBv/zb6aAgpk/n2O52rp0U8gtzGach01m0mei/59nW38S8zbvW/MDp8k1lTg7Mls1JXbGtxqLdSioDSzAPoilrLEtwMFZOIPTHYx3nHqbNf7ZtTtjS0RWVUlwrpt0hcBFV/KferH98V1KOs26vZsynZdMguUVGWiLHPz41iKKdIv5Vr8yH9QrjfNx121ZtQC91fzAn0h6dcf/C9j27TxjeLtCY14K0ayfQ+0c0CjdHv4pIGNsu20Zkhj2PYxHW38Bu1BoIYiTXrHr/TZJHetX/j6Mp3PYHfxNdq/AQXDvbv+R6hhguwDPSQyzHStTp9J8izx0/dxbq/w1OhptxYcmkRgNcP/hCOx6RTUk8aecyBsBqsoC50uPoB8xU5Pc89gGerEpkZ/acdSETrLHPFNYktCk8QyoElqGdgkswxpCrPsIpabpyuENjHaBChHxEI56ZNdlVBOguyCgx52wKEyFddBKxWoNbQ+KKxbr3n7Wlh3TEPeTOCjHUV1mObL4C+Ou3zzYViHvgYX80KcfAy4x8BVg9sGDnmpr8B/EmSp1SsFXuojePaBmwTPQnnfBk84aNUXjnth8hFfc5Vqz12L/EbuyiD32EcQBk4Rww9/1LfujSHw3gCwime31H2/0XJ4G5Tx15tmoCxDGYhnRK4YkSgNV8dZ9ohSpUFfWmzYUvq24bPS7w0RZcoifVlx0Zayt4u+1PQHytUPKJcMKFfEaStIJ7gnUdHWphEDraGB1ty2U8xtpDeVlhC9uQ305hbSG6VFdx3pTX+LQG/A/wnpTSWhNxnXHVb3aG3f7WlCywyRv+mzpEworcHmAO7QUGLYY7hiyF0rN+YbS47MJKtxmeuFgMmlcjNFueR5r7HLWOYywbtBbkPRgbI9RTtgBYhziWKWr022fW6VAf1Sag/UzdFoYG0ecjpOM9UW36HQjLPFahrsQKsN8bCC5kJ5WJLJNdV90SFW/eCgNN/bpKpOxwDNGNuDmrG2BKDUaw5dK0ULV6hREu97Y1uvGKodwoopC62Yo07javlSaG18iKyNLzhgdTDA6mC4REJY7w4YsYvh9/a7g8R94cAeiF20+N44zFNi+MFh+s39bydBHq/ju9GLdHhf3Na/JAdtwEjYpmb8ekyljFNG7X2AreKmeQ21tHqZbegZkZpy/c68nMyvHd57Z1+AOxW4uxtlIilqQjsMj9qMBaV6lGYoixFlc4btXFhAnjUClRqnito/gp3s6uF394yTd/TAenANFgX1KVs5lwASwCDzZX7FNtwtEe2PAuqKst9LNtxfP8gPLazj1RV1/AjDeZ7Sdi5+avAjukdy6nhN4XVuenAY7kNlivanqvJTAtyfvH37KAItGaqdoc8lFDDPS27WbRysEu0vTZ7seo9vI/boFzIH+QXaS12izbt7BvfbxSsVewjt/RbaeIrovpJsLropFmVf60fRmjpI/1p7Gz9EK2usbb8E/oDtp7r6bW5oP8gXaxWWHY4EUj4FFOhFHmn3Lj6Z1AA1aYsJfVmItalQ6xbqrtrdkxD1Damrn0rWNMCSfS2KqnQEuaH/pufzBz+tezrU848Dw1QBskMzPCUV6gxwE0KjscV2t/cy/ToH0hXrEoEf/ja0t/cs+FvAfUL2sCpyX2mO2kcNA6mCT1l83PQ6W88u4Xbwu/gYtE5gMz3yncmUJ9m/hFvPoz2LNCPMa7LTpzEorYv0z4H8vJT7rSfs9ZKyrbpYG6V6XVdUrFopvrj5MGKOLRCSKsoW6OeT0VjvGVFLcMq/ix+tzbViW++lagcCuIpn2s8S7RcP2SQ9CqqcGxJ85M6ZxdTT98rBAW5iIAqlgY2owRx3rGnXs25KfdE2uYBhB9UGuNf8RWXUiDMXVWvDNbYOoV01AdVaOlO18hMHSoRRNtyJGE/2IzrsqGkD8BGcSGV3CO3oDrXjQkBzpx0/QDtmtwr7Lfe2p97/x9COSop+SD5yJ2Geuy2mJzUdZsiZ0T1QtgjK/psNb/OWc+8FogntEkr/4HQcmWn/cAsQVFUp9BEEgp2Em3iKjybchBnWmeyCh3GaUzimuP/+6IvCWK8FH+8bHgD/JLivXxTWmwpid/XefZt+rASkaokFv2cZuV/7DMB/9Sf8l9KONizu8l9nWm+E5GrUfZ4RkqyzQa5BSGa7NppRuo6Hd8ifzcqfRfizl914hqWcSwZuRFGI0JjL7BK4M3tR3T7d4PMTrTdXU5YZeh1QEezlYvce4Fn2bEKIZvo36fJP90EQ11pZSBptaHtqSJ0uwk6l/WzD/ONAmhXyP+L+zuG1Gupe06nP662nuug4jH9In0ao1FJuihtL/mMQS8SSaRU+z/UNB6gLpbu42FZib8Zyc7VKj7Z5BhPehIGSqbTLNnrbDYcw787bMG+nj86CWVmoYRP1XYTDLID8G2zC/opQ5lKOBq6zP9nlX8p5+dj8jx2xAv8X2h2YdqvsULT+R8e9vMMo4J+fBfc6uGmr4+TXwV8E/j5w36wW9ljiq+Pk48Hd5Qei2u/yA7J2xdGC6leq8cu8RIVf50eC7B/TodYMA+ljuOYh29O8pKBi5ghNkk2j4e34FOC2tj2k6WeTdozSXA+9+aA9UxNry9c4yHOQ+/sx4f3IdsH3fCi8/7Bd8D8Kvf+5TXjee2x8i+KRejej2OGmmG06CZtgqydzJVIfRbB7GS985QovwFEZXIvjQzFUPUL4ije0Vws4XFxxdy/+/8Q5AiPn8/zPOYL/3nME2pfi5K6WyNpNzVFsHaxz+CWd1u6p+rQqoJGyWXZ5+nXO5dlTVcdLtKjtVqrdsxr3vdCCUhixoCTX7jHKlH+7OVCFWtbx7Pd17iM/NUw2/PsqPCOvZq9zf/SLlKUshqz+0dZoov8Tn/b7v6uaMF2Unj4dnz72SJtdbarVqA0pqp0aFj0sCmKuc8331a8i9ZeQ+rEtctKWcNKWCGgLtiSpP2oQquOjmMHxEUqhXdHaiOHXuWX+I6iHIHcIG8kmsLoqMQ9rD7veaOOj6k/wtOJQ8+j9tWxx1+jN22sbzTZYHZ5Mzu2h5FP0Uwum5p/qGqCaWnC8S1R1qisxbvKsKQWnupKWTy5I/ueTAXKqR0Ezyvi9D1hOdcXX4om5DHYEG090l+3iv2HGvY7hykAW+CJlkFscSIHYMAgZA/G7Rh+CuSAzq3LYmcronnDq7z2rZGF88xSZa5psFTcsMPpA5vQ0cjIgjZwMSPjXkwEL+k4GxO8d1U/WEy6awIr5AwsE3WXztVeW7eLnaVWVu/intCXwP1e7B/6f1V6B/2e0quXRzEOEY7v3Gz5+v8fv+H3f8HFebyP3r69zdrf4xab/4P71INGg//L9a/19968H/Mv965zb9+qCmXbn/vWA++5fD7pz/1oSOn2i/af711KLzBYVOn3yll9KTp9kR7RBujR+yD33r2Xb5eT0idSCOiVe8V/qkmbccHzDBLmXYR1VEv18OGdStNE9TESNNavUaBWTkycRNljxyk7xVP2znq03w4GzDnJ/DUjYuzeNr3O5bknolMV1bqhPuGl8nXvQJ1I+SkJJd05ZXOfifUKeMe7Y0Nzt0+VtaU5mk5t2smY2ae1rtTHs+drZvHx+HT8deF8tdZDPUMR8Hrkj+uCmn2Ko6J6RUR+CDzNTNpaNOfnGT2GU+OQAVVoFlVpSWcGixrfr3M+86MX+LpFoAzvQLi6lNAtsg6vOhz11Ljp1louO9Kv2VKCOr0Gq0GmiSRcP4+nGWa6IcGlnAGJnuWThB9hBqisVNXyYeXgl3nGdYq/hJc2UqmRZI8zfPeSfztyC4SqEIs7uFO0fVneuTqneY9QfwXlcxyuBA1dRofNJ2gc9m3l5T3A8jmn74YMgAdDj5QcehDFNEb+pG0ZGKrpnCH2qS5IZ5Fp8kqabjgTWwr4Lkrtq2XGHErBGyWDJxRBSMYh3Sf0Hx0P5UE8q1DNMgViIePSJAyUNlflK1Xg2c/qbuhRWYpHaBhKMqYWSewkWbPRdqVLW3ngc/zOn9+8/rwL7qrBd4BUUYsLFsIhzV6qonTcSARsykO4VsPL9Qa7N31kl0mZPV0+PI6OJZ4tPN0ezovfCWNTZXs+Wc+KgjKXUE+zl3DO+3WY1vFkQ7CS+zK9Q0sTu6you1Y9vhvurWmXkq51q5df8a1TEhevcCj4FuNSRAS37GPneFq7qdkQUPFB1nXuef9ZT2yNiww9QDXiO85sA5rnOzefDAUs5348O0bArhP/hW6hU1HsTHBeDJzQXSStnrD9pMCtHsArtKu4774muoU+c4F+rQI19eKbHxjdQqJVvMaf0nOXrKbl1Mfcj0c+HY/a6jga5cnM7Tc7LV7SIq19plrFHWqcb37HGfLEY8DHmi5iTDYCfiKtf8fWKR1ulsHKE5S3mtrv/DuXRqszKqJD17cXccTfq55XMi5fzLbmbwzV4Wyu+I4up4mR8GCtlsbR7S6RUlZsnlSw30hmV6+NaVxn4tjg2yUSlee0PlvC4LuRsrdZX634WKz/Hf11CWiO5Mf00cGDxaZRLtz6JQHJgGlomyACO4cuq1NHq9tRhqcTa+CpurlewCRy193nu3UAd8PA6wsN/Dzx8LuHh8avQRXh63NDmzjZnHpZc2xgmviZOkPY8SSmUsfs+5hPNzPRV3ARfySC8g/o8E930YnFU06SSfk3ekpimYwsTe0QxkmsytBkI8Y8zJi6D6Av8zggSkgitfvxmfSy7FOBzle80vOv4rEoUkjNEyqh02d6DfKL2ee6JwKKCXXwisSkWBe0ZpJhbVaujbOmtKUZqxNH2mbeDy6iUFAPGb8R4Zm3atNvrDhGbY8Dtr7u1+pAJ1lyW0PGZQGuma2HEFVj/a+aofYVQ/+/5EzBmCx1fVg0EKA0chjatV3F/92Sw7K+kxHri81z/AErpmQCZNKjlAW0lhCib6phCiTOZhvRHvZQqVjklHyUjfH7Dm9gq3GAe76D3lnMveRG3XtOFsWPtY/Lp/VF7V3BPB6P2nSU4/bOnr/x1t5hDWMNazbTbgw9hPdAPzbpbCYfKsB8w62dqY5VYFtbcfy/2aBXef1OhtUiUlWWN4RqlHa1GKrbXOmT7yrnl/gk4OzJQHvxNYEA+tu+ih1KfsMuaKM1f7NAGRaxekS5iJrt+5GP0MSCNLuGOe4465Cos58xA3HsodkjyovYv5ubyX14V6HpNXrwc8Vq7Jk4+Gdzb8lj57DUCv/1lVTxAMz4EzQcBmg/fgaYJZPokc2ZV7ox1t/a9v4sfHIJnwbE2d2IF9dCiCwplTn4Y5HNDKx8G2rInGAb0Y5QH+z0p/yA/BrCwH/R9HPSd80hVCMU6Pk8b9dturiCAq5jYJ5S/GsuvWPvQtNsr3l9edQyh+dC6W0ve1yoFi9SrgCswcT/4BSxBy2poKx6hGqsM29d/L8C7YhV30kOB3Be1D2Ec5AYHiJ1cv/5q2D6FEmdUC8RHQdpsbTn3aw/CmmaFLwDHHFnQco/77rtTflodYY/In8giDswP9OHAT+53HSL1HvtEVpLfA7DOJ7QNYbsW3GvgEN6CbtFsq9hUYijZTE8qWb+K+9aPt+QVbS6I+67ZBqV1c58Hz/INICfKWMmFZ/PKuV3BE0D1onsiaXhPlXN/Cg4d/fB5PGtBafJsEfvhrWIOpHsrWGJsc09WHHHHg9wVAdiezVxc06iTEg1Ox8kJwxf84oNt/FTtAbNC2cZP1l4zR/fk0FKAQzrg8WNa7A/kqwjXJLRHNWlWagz9mvq1awwylWbllIIhVd3casBIETvwALWD3F3wniVtXuIfCCMX4aFSn+4kdz8uZuoTqkYdGTq69zzM9EqLbowNMGAVYyznZrhVxg90aHlCxqoMMbZyTu6TsniOP/0Orif6h0FKhftl3diLwly0O4RyTtlN3M++gffso5w4PShfGIc0t4ubF0zuLAcuVwZjd4NHrFMo+wPeGahBe3EfbxX3obsP61ZoB+7s5hSk7Z94cOdZzRaRM/F99qM/hDmCY/nhAor5O4wjjmlFC4yT1sInKqVsZauFfzwdd0JjhomHUUNxtRsUpMfIrUd1vL2iLWbYLYe2hVJSQ1GPODVjveGvBm0bkVnzbPB8+JoksuSaNGr+z1F0hA3kgec/nCFvPzJDcuY4nh7G+z21FOMlus1+r5ewm5qplCmuv3reKbhS/E6BykD06mae6OoHTgGuP7h4cAPAJYJLyhzBppbU8GMKT3QlzznRNQQcM+cEX1uYpZT01MP6/hA/gtVC+BMIj4AwA2EewioI54Ek9QrMoQcgXAjhZggP5BXDRrAGeOqAJwWPcoekVwLhCF49fARbDzFyeBLzE0nMyIqVnD+IqWbd2r1S0jsOnnuDQq6JEL4eCm8yrOS6QuGDEL4SFPKfg/ClYFk+zUxyvRGQ9HpNJ3ibDLil3osGiWudR3LbmJTC1vCfPFnDfwruM3Cfg/viSUj35NP6uSzt2ulJYRfoC1mR6yEoIbUkhX1KT1kSWbGrDfJnZaaA1CrpzSmdo6ctYtc0Xwo7W58HqQMBiJ0txBYbZ+lFFqlLDmX9Sp/NSly7gpLejU9Kbr+2PBF4KsX4fL3YAvB6QupSeBPHpbCsPouVut73prAz9FoI/cMv6X27MIWlVTp9onaKq8kr6d1Dnqfp5fBsufM8mcRvhed3yPMEEr/xzvM4Em+C53fJcyaJLyHPGlarhxaH4n8/e7S+0YA+w14gflJRzg1trrhxOi9uzrkxJhf83Tk3stCvz7kxGX0ztHN2kiHnxvRcUaOjMOdGXu738P9wLtWIfmEuTfzHc68WSkOygnRdnLzQ3F+uBT9uZKw8HPxocLHg5noVcs3gOHkChAeBGxMeK38AfCW4x/wK+WM+hTwB/CJwXRDeAX4Lr5CjDSyqt7mSLqeBumW0oQ0sqldeSS/G57Q2tIdF9XZU5pB4ZVv8Inx+pZJegs9JbSceQR2ywPPug5nE01MkrLm8HCgLngwSt46yAs6L3ioXQVqJH3edjk/85/THTeUcdU/6etF3Jkz/iw/Tx09Amk71jqyUsH9ZIoH3nT6FFc9xnczA801mE7ZHUvkX0r7TH6LtLjzL+5fF0rwyoE6f+lRGhm0yvjYTT+ZS7Y8/gmehNproTCkrsWXfuJ4Sk/c8l8ZTQ/sVUBa6Ydat70pKlXRKJHA+7wV26/aWRFwI18thxV/MfRwwcuu8lDFbhy1DSwZUu2ltnHwZH07Go8YVS85mHc2UsCbrX5ZSvRMrU6zSvLafFNnl3MMfxrLYr4C383lFG9rupQAT653SiIqZ9fznGRTgXVxrvZPG5763/W28bTzV6y0utTaiTfDe30MOUURL9/EIPJ1Bf9PeTUHKRp0nFCeOcDmE0n5fGGc1Q9qKmWZ4i7w6vJuN72nA1r8aKmaSsVeZob1m/mFwyWNQh9Rn40NpC21OSfWbTmn1re6PyVkQrOuT9ubu5yMwLzVG0UL0IUNtEqIRuam1nv8yY2NrvdbEdXki7lk9ZGcanCMjjnYfJxbv6LOoIRk1ICva0P7ctNC+O8BjtgV6HuROt2uhbMlWCbsD5ClXd05jc7eu0dVdvKW525Dm6s5OE+1rcM6LNEK9RVsanAsGP+WS82edz1SjJUjJ3qzu4VtWciv8Ju7X7uwbp3MjLCE7syrhy5EEpEu5agRLqcKVeGMDOZM6Z+SWU86oxjpndOMpZz/IPy8w6xa1/CCv10YopQWyvBiLBLhFrRdkOW9Cc9svkq3aNoqKTHr4qXgy7giHSCvFoB7zLzMojduOkFjokd/51uE60wDQpjS/2Br4lkyJ5id7A3+cugp4NE0XQ9FqlF7k3+j1BfkU4NurfnooQ3REzzLOzM/7VRa7Et41s2ONzLEHrDP0OYCV1xw5NzqyV3EVbgm5E7fL9wlPZSe3TtVPzBcz35Czqr8mOiHP2zp4ilJYxcb5MBsoFaTTjtNfc0S3jtX/3TE2H0s3+CWsulVjVLOYZoyh3aEl7x+H90yrlKwGtb6jjpHkbT5JnZYvvH/HvdehJu+n+LG+JruavexMTXsTHPhJ4Eek5gMOJXGAR0GuX/BNpzJJa7zsTIY0yZAmGdI8GPFgPow3xAcCl50JEJMAMYMhZnDE4Hyt8W7+7gDaOc0L0cKSqlh5x9MUk+qOlaMObdu6/vJCT5y8i4uV+8GtgnTrwf0OnGBL9qiOoj4B58k9AO8EBKyebiXhV3IpQxn7x3VxhJ+EMeRPdE2l31oKq7YoxxoGs3iRB8/uDEg/wUelK9qEmR3r2f38TWgTfjtStNBLAQq94+6hAAV/FtL53czzSItemSDgTVx6FNvUinMvLt3MfzE+TB/JUj0raBGsxgc9KhbPdIoYLGMxt+lDRduSmljSZ0EfkolLgNZR9A7+04waXqvdwX8GfrpWeB5NzhhlaPGk0546PEkQd0Y4VyA+v+f2iThaE9mxEFI8pD3H1yhyrEpWTm4jlnO3WrGkHodYmUI0oh91n+RrqCxo9zfPEDvYxBbre831znlb650Lmuqdz+y/zH+4/rLz+f0gb/fE0NlLyrk4j/ANlHJ9aE7eX7QkG2hy0N3cnZ/k6i5NQjrg6jZGSPdJ9l5yqtJ2OZmCXc4hk5q79WlzXa964V31xDtWjX8mVEhxdpcztXqXU1r29+6wslXwdpdzWPVVYlHzM5Li4XOXnBLAGhZihqbJ9lZ2/wFLHgwlR8r3zXXd9P9z/buc8vm7nDKom5kEqTSRe+e6GH/2sV38yIqHjl1yRoVs/wotSD4H5UY85XrTe9k5ujrnxtFcbffwiKtz0bICPRptysTaRKOH2NjW4fpTTqo6uuctcSpZQX7vRbgYAC6/dlc68D1DUkhCo/1HN7UD3w7WX3X05cQ4LTtQP8n1Bzc+J+hRKojNXwxrEfBTBjpF5PqdJ0s5gewlrQSZMF7Vbx/DHuQXgizmDJx0jLxjRRN4bsB3xHMg37m9a0J8BKxhk8EhHatoebkZsQpPNyQqjTCb7Z4y7ocAavFFTf9aYgEeNcw3AI6d480KtAaP0nUMnto3oA4akWWEtYyV4XrM4/dK1EGPeG/hT/Jmqtex+9k79nxn4QrS2ixhE/Y9nLeaYzx5rQX5+QUF+sWcwjszH/lPsWtVMA9yf8EzC2eC/wnPLGLBP8EbFs4A/zjPPDcd/A/5zpJc8D/gO5/TIb7ynQtzwG/mdy/MBv89fveiaeDv5Q2LpoL/Dt+5aEoe6nXd/dxk8N/gDc8htfzEi//nyH8l+V9F/l/yCudwaXK6dlPIf528/buXGsYsjt9JqzJSTnX1fy62vo5/WBtz4+HIi13UAWzjm87+W/F7L57U71cz61Z1JZ0Su7eK8wakQ3Jtky48zz0WFBspS5I+knxZXczVe9AOF65i3zvut9Mq0Cp+3foQ7WuEseuzXYr8GfJkyDchb4T8EPJctdPi5Xh/C/kfnL841lftcXI8BXghTHQOeyEGOdMmm+RaBXiWSxuAjxvD7+JzC6eQOwE+z1n+lfG0Rt4+msV4BuKH3hP/DYmn7sYDlsdjvDaOxP/gwbedi8u58HvejvCSt0tMXCB4961MeFtu4m7e8zZSeGsycT+Rt4Otwknnr0nJuyH1N/e9PyK8h7Jt5P1ya/L+t5b8Ls/EfRRs49/QtsNY/NpMKZPJacQNZNfC4keNkmf5cujJM7aGvDKuJmC5s37POX22K0MVlwt4uQgkNZC0OlY1OJ+IoFzFGxr4W9pIawPfq42yANfb76OfYqhf2PfgH0Po/w7cK+Amsqi3S+Iy8TK2jBvnry5ATdJlXDrILuPQJjKN9dfw32WoQXqaHKzhvxdRo7NdGVDHJ+Pp1Bq+87GS1qV6gWpMdDUFy/XlhL6sdKOMhv1o9+GpwBNK8URKpUijbny54fJP/V2JonWizaIa0buiY6Ljoi/gt5v8468Jwn8XHQeYHAPZZNOis3x9+rWSs13zVCe7JKqzXQvAl4FMX5V+oARkqNmSTIYdbDzJv6dFbtw3RgT/vWOC3DselIA2OdMjzhD+cSZQ4dSIe3jI6o52V/fM6pPOjOoS1yKeVr/Snto0teAk/44WKXSxa6CfVmeeB1oM4VgIjzp/qWvIZko5riCbzWeNrh3+rFYMPcbOh6dkL369OgkpLnUxkGpUKNWG+1KFh1Ixm2G1iChxjYB6Y84Pa4rpFJ5T4Dm+Q+jtkFBvGdLbk/xu0sNXxtTwt8bgarpgbNdVgY+7amtwdkArP/LR6s7zDc4LEP4AwhfOn+3qCJV0gZT0qUNYNzuBR8mOFlM31gpzF/loijq+jsp+NXuAZrkd5PL/AuTpFAHyYmjN2HECTtbwkwfgGd1b2osEC/9mTW1CmIKUniDA1QQtS+jY5ByydZOT2Tqsqa9nY8Zhr94Yt/bqWd6cgXnw+YuxVxzCGMyCfFdCY3AiBN0zvnuhO89z/xgcC6U6fl+qmZ6+MTjuaNMw0FevgXaV+fda0aZ82t4XuKbgrFs7l6Pt6KO8fkLfWbw0mJ+nnNrqIPeyd/jVd/XvElyn+JSrR3p3rksFHlqRjic+Hnx/l1MZUeyaFKTV624nvn/JqazuO8cevK14H093Y514tu/1w7Qr3E+p192SvL9dvw1KLOe+Dvp/PKwZZt/lVEW86fwNcBwfEylLfAln1OPurh9RAiL3MtyXnEPvyEVftL/prKmu0SPei3sU4s+IvZokw99gBf/Hj59qRLZCzbpbtoOS3nOL1NBTNfsCNyyIrcMWnXLGVO/iJ+M4jZNoMoimh8hI8UA1hdxP34n0E/zxcaiD4SShDrWK2CNprBEoWYr/dz/CyNCS3q9KkHIA/CH8NQlLes+XDGtMMnzvuL+kE+POO8gIjzvnGME+CaUc9Z3ga6nVP1Kq3T9iTCdwjp+Mv/BjDf/5eIAYYKRt/AFduA3jjmbWgLRYQ6TFGpAWcQdI0vs2uLfmKMYmjp/DSyIh/cDIpKd0T+VQrqnuQ7pbMEbJGRsBL09kxGqibGJNhE0KuVsyaVIiliuUiTWZWhug3tmttBLqH35vjVDf8Aaoc761jGsEOjORUEsckVyeIq1pAP5ZQ1YLJeHQvxiPa9pE16DAtB9Ib24bE37rEEJZc7Y7gINahE9qlnb1Aj5stkF/n89iKde3bkqd2D6FNQupe1MXvdiXb+zK0LviRctgXuPcPRKaz+fXElliDNpSR/l6bimswSTXay/Mh9o2zsEnxdg5EH6FhBPHziKl1fCfjqdS8x0MrGPP+ZjFJq7EZ4CwwcfACva0D9e9eT5cKZ/04cr4uA9XvEd9uyHlr3wG+C/wdcJ/ng9XvBk+mV4GUmQ5Vy5YHyiZ0IwSN+4k/dkhyA9oOyPITT6GclNWy5ACsQH3RSRslA1lkTHazNTptxnDSi7TTU9R23ebyrncQEIBtLuQUiZqk0Dmi/dCvyokLrUbYAGc2gd+gE6h2HU2CL5W5Poe3qcaRK4jPMBdQbsG+JCjE7l+Q+6674HaTtnPOXA/q4PYYJKwqM+JAa5TQqxpVszMNeH3s6OqipkVxG7YSo4jXyLxTn40O8l1PSgtuFIs1StRE27JopIaPkuLZeM+2Yl1ROcKWw/votn11pJWnWkD2mw24Te3L4aLjRdLX5sJOQqz2kAqLuMdImOkNa7slsNSesOB9f0GONMsoi/yBe4Rf/aNM8tRg4a0QGYpZWe51s42mOSWIDfJ3Y/sLeF4C218l7TRRuiyzFZPOIN6oMnEnqjK68DvpuS0oMsPvdUWZPNnJ6WwlOoh/WRXhhtDo2B1/4Ga7JpEnjTwdAuexpAnNVCaDRWTXaPI0zB42gJPA8iTCp62w1OMW5FKqVJYBp4b4XmgOw2tu/a+U/EC95NPCL8H4e/xPnzGCd6YcoIvT3mHr0zBWbciJU5/gjenoCW2Gr4ivYZ/AdxKcKvAVYHU+1LRCb4mpYavTWfYCuh7x4Y4+QleIT8DrgncXnCvgrsCbuEvCnkwuG5dRUu9+zmg1AjVqHYR7uWnHuUXph/QxZ4fF4Jyo2+cqoxFjU8TXC96xqnltkiiLaCck/vxjmMFLe9sgzFo08jsNHmGNj/aD6QMemwHzMUtG4R5mGuq5ytSLLAy6KzN0CsbXx67TfdBO6XCMYhjcQzItyJTgFsTKDE9mPf6YoBOpYlr9piPneUL04/yj6dQmpSLFt2DFwA+6SUEaxQpRSZKtR4k9SITntr/Cy+hi0yQln6Lj4AQQsTOU+lx0/8C/yUmxDNF21nIb9HRFykVUF7N+QseoL/v8I8DHAvTsWynA/nzesi7tbUeYE3DmiHSyGwVM20QS2ceh38Ml5NwOYS3luHdtm38WG1TmK4913TGmVWNUmjFzCyyKzfDJGF38J+LEo8c5RdpVa5scQKsuGf5HOosP0Nxlp/AnOWnaHN+iY3c4VwwaYdznib3F4XmSdcDXoMJ9/ICXFbgaPcnZP17uJ1mKAapB0j/jMdxfw1yUsPj/6XSuz19pYf/h6VrW7bzC7RN1u3809qNrae7RDOiDI8YTndJZrxiOGWIM20t3ha6HbgefG0b9B04pQhDgQFDC1RbDJ9jCLC0y1HRooCxwntW6/lR2gRWZxL1PlEZRTQNbCP3APziXJeElESpIotYk8mINxXSjDm/xEXm/tJfs9O5YPBO57zIJ10rfH03CPHmH03uwlW0yVuC3IRgrsnmnFxt4ZOVE61nnM9ErOreHdH2kzy72NX6ZxiZiNvQEgFmO8gu4eBWoccwc3om0CA7BXfwycUImd+Tve0V6Q38CppSX7MhbAdoNB3AF4mUHvHNi2HfnaNIim8davac85kteGI2qzsbOGxhd1V0CWKLvnUYoE0Ya78v9nSHUOLntsc1X9g/cTyu+dr2gQP1pY9yRmxthrg9PY+L6DQJu+Y83iex6FbbEibRmpXnETvFmkob9gF538VA15aCPDvPjtYRS0zbhtAjLM55ByzOBceKOyz850oqzYDtV2A523TzbBb+S3j3hN3iHLPV4hzX1NydP9HVXTqxuTsvzdVtTGvuLkhydZuSmrv1Ea7usognXV+5Cb58FuB6fEe7j3+GPRh16T/P9zsv2hMUa7T2y85BZF486VrgxfE7wc/RbnJeiYjoRMhLXVPcl539gdNzEFx8/ZIwyz8b3vZLBOCjJE1i2+Hs2LrDeaHpDw4L/8Uwcdptu7j3XIkFRtPilDS94cBSzzguxuRn47rP3xnnh2ElpQBeArSWQDmfAG/qdNNq4/kd/COZcS5/TIndYCK79ZpnAIqPaBucRVtwXgdgXb8MGIUj19e2R84eJaOTAKMz8/wczQzbg5pcWwlgum2guNdbvE03GcqYgrMPZmGOAWZiRc4vikgYj0kwLpqZv8SanoQ146zTUI31YH0GU1/pc8m+/lHAQHzCXf7sLTVOQ6g1Eb6+vXsJQI1hI84FuY/8m5zfR9yFl2gr3wYytx/6GSpb250Xyv+z96yzqKzBaSg75/wExuO5iFqQA692h4H7GCTB76svIB8F8MtqmW7Ce2EBzuxFGctiPeu8BlJkePUq4OSFXTiB6362vcZ5LcIUqj+rTcgv7EuKCCYnaOphpcl2vWqGsZahRcaF/mxTg7Owuh5mBn4NcUEr/tA9fAuVSg8/46Sra/jnCiu6h1fHqo52P7+lBspo4JdosbY8hM+WReRO8hJtIsGkIi1FpDEXwGqw8QT/qDbA7Qph2SMk51l+jHkRuVm8BJ4Xa58nN4sXa/FOt9RV55EDNRLCv+ZLTEo99GRVVbdxS5HJ3/1T9Yp05NdlzClo2QTX3iDdlKRPyseTYhvcDbAqTwLKWwnrR3k68igikJ+8/HEVWp7vXyC3IH+ClDjcgrTYYKpzRm05hfIknwPUeYZWtA+/hwS4b3yKPs5w/VlcYSadg7H4ZV2ffGpu17b8ullBbphiHZ/yUibL1RWAUbIO1w8na/NEt0Il2k+lYMzugEI93C5tUrnW6c7C6g5+bqMu0Y5lSxobdXE2qp5Sig7Espi6BFJH2IpMA/Qr0kXMBNfYYLy+P5HGFO6EVkxxKxDWrG1r4J+DFbeOH6BFjuEgH6+N1JMSLUK+QcEwsktezt3iFSrKcgr68PSXAp/7JvAErRtwL3+6iSa79tNN7/BRsTmmt/h+KcgTfjFeEdLhOpB9jbU0S1lYd5FnSF92hOp9pzqO/TMfRU2aLrZQarzbmX7kzWPS3qMrZ7kk4Zf5h60RQ9ONkEJLjRBdfF034mKszWjK01OWvn38Ca5PAyTekmnU6XWknbt5ilndSfW+V21zPNkq7f3jyh2EO4pvn+USh89yicLtDvH7txxYh/j9zx3jVJL9eWyWy+Ufp460lZoyQhB7I/CQfjQpcRWPtzgna62ayfY2Xqdt47OZRt3I8/9operpzIPwZiIrOZBuxFL+AKWEQSkpoVJWBx7UX3RgjnQj0dkebHNP1WYa6Mnb7KWmQaFUzwVEzAAYn3Iuh2fYpM6HWktN89gV6TKImxvINNKZPzok+3NZxcF4VvzFe7pEw1MGJSvukYtv2xljouHt2kYzzcSFvmdHmAUcmwb+fHBvgdtgFnTkD2HjWEoZxtZCWzKDErbKSqdmsmg/IYvo3M+yaoF7fi6gtcqaUAMY6tdFDKbHXnPoTMjt/ZWXxPZx+hLXlI90JiplA98/Voh9m5ffiQ1yv4FYWgWx6QI29HFR9cDvopwxuDXbFOQGeqjWuiMGoCDZW846pwMFyTFQrgsB/IIgIlZfgadeJun9qGKRSeSq4DfxCroEeMOFKXv4iJRi02ngCOnMvxK+UKjZAKX+4sbZB5w1zYRs8pj+LHBDcSH+dJS7xDQy7yngT9+rLOMMIKUipTek0Nux7AbEmu2p+cP0IsbEvRCEmHR8T2lUwLumXED6IOxV7wgWm7YDR6w6grYX4tKLkYNNRzgVYysBJhGxAkcf5EZ4BF0VCmhPcTvONIvu4hlK9bWjxBSln78Yb96YuKlB5GMXAg0yEDoURrQk4VnGb2D+4X4zjq8c5p4e3Asb8J5CFLsN5hfO7I99CpWSFajGJp9CnWpvcPfTXjhMp2V1vL2ZSn3X8Lb1gE6QFB5i92yG8PlxQGdQOshylfvGqWNtSfrB+dhvdwC1o6FmNBUpe7wP/7/yxTa72tqAIlo1UXaqXnQAddhq2YP8xIosVyqUQNui9Jcc9Nh/OEpNESEsv+lDWzRY6pcBSrVn+Z71ewz/gP78br2Arx+D7wKXa7LwJzNEmjDghKpiY634Lb0qXY4y3ggvkaGr0qkU5P0k7MvN2SbcPQpwWv45E57qcvGUeqqtgV/5KDVqsk22D9YgPvbp5sVl3GofnoYQ9rwPwtjX8fLCuYtF+8q4coiRh2JcAWGX+8NgoRXxDsOF5PzZlYABsEYOK4qF/3R4fyvypf2tglyH8lxtCsp8f+MlKfh1ZgSrUIr2ruAu+RFifi88A4wxfMwrjFOmTzEq2r4LaC+sj+morRnHXNKEI471xbmFliwKIHVdmf5XIlvh/Mk1XXZGpkWR0wHg0oAXGQy8SKQiHe/qPekazdc4o7cgtiNP+7QWpOihK/LxbgfmXlhwnDenW5opFWvC70s2vlMLPFXPhLDonhiprPeJKkqjt1E7JAcmsnQK9Btmhg4givKTFNaUOXqBMkUS6+UvpGcBxXjEhxT8sQ0Imy+U1VbkU4tbc268kzN/bq71KOEaRO1zVLj2Q28ZBvI868feDfEw1gaYHfgt8xWzwEVnu8Qb4N2jo1qxvM9FlDrbFb2BSv2yU2iVAJff+rFNePpuhr3AWmTaxic/tiKdGpVnG63H9h3zovXGBufkCGjltgks1pnuR/9l/mGLBGizjhXervDt5FsyX+aTG14fUqArNhXkbOA/HY91vOl/AdoghtUGRjtDdSRRj5j8G+8A/UCCyaX+Pk4trm+13ygiUFKEoFTlFalMjmjSokovpE7dyH/6pNURQUoq9cr154l+6HXrjgONvg5uWGg+fAPhcAg/Dm4SK9kv6SmNQlsuCaz4JNpySSO2XNSGptoD5gmAXQxLpx6EdQrGtDDIPQMYjtJrRffz1dD+cLTdjfjynOvrwDE9fmnMZ7FNau8AMiqIKc9pS1Dqo08Ar7vaAFIfhHKoEyB7nuHr05HH7+PQkAvrk/KQC6NUJ/h8rTB6MXYcT1oTaZ/TqiBl7y7AvKSGwr50j2uGh9Kp7AnHyDgrb+CcyrjYipCv4pe6ZooxdyRp2SzX+lzMCymdCyOQG6TUWGoOjGBiuzQ1yC0LCOX2J+VKNf3si0P1Y2ux7n9t7RzNBJL6yLGDx4CrPP4G7qceC0G7311oL78P2jv5oyqafJv9BmiR0grYo4po/YqvzeyDjQLowSIGIYSU4Tkm1xUFIaiVwfpFqULdyaRukSbR3iZgurKxFSGwsfX+vj9agO3Fcvt6IEtFXr4l+MERLCHSKtNk2OuO/WdYIrQZW19CJPl/13Jss0Ip1LOItBZvHGMfsA1Cy4V9D5E9jYyrMIdO+/pm0ymP4D/lAZr4KM4sSUh/EcrXJWTn8dPhmGKIB2ewCEoi2sq8WP/8MKrnd2ZKBbNxzNHOxzXrbonfF+jDuluBgwRKGS8Sab42PYLUf+NHYZRlBQJ+zdH+6aoAf4TdL44X1+Pe8fF1qOsFZRnoAQOyc2ajLg/hD+vEdHsfnZlmQ/hvbd0Fc+gFq2T/BCIz/Too9MgAfZTsw9B8jzi1gUju4fYZrfiG9+wE+TeHnLUe6Uf5HOMFGX2A/UArNWrdrbJDwijjDYGFh7Am7NWzh3YSWTaxXZI61yFlTzsk8PbxQ5jj0VDctFsPH1L0Uc9CAdIBoqHgLk4IWD3eIbT1JfezIOn2yaHrep84JJwYmXbrsUNCCrdX1ltRKfTnpruvnt8e3AkyNoa2H9zpPD5pp/MjzU7nhcE7nR2RT7ha3TXOooiaH4U93CB3zifs467gSj19+7ilrLjAYJJZ/Ny8ANnBBVknq0WHPFLOWStwiY/u0yXamvmFj9bp4s8fB67xNG97UtTrLSJ3pYGbfDgO+cWjcbmmjXxyfJB724d7z9RQrwPP9VSk4znAANfqF7N5rSCrxSLMvwwin6fIDnAH29Ay5HjULgur1989JSYRcAGvLaZ50dNl3EoedY3hWh/g9vsxbi7E0BBTyt/lD5wegbdr9RrvcAGPkDMJnR6Dyc9JfTiXwrSkrNa7+R7xIUYfOMKwYlfQV3tEoHAiG8Y96xHwW3IO6z7qD3LjSGoh52ge91ZUVolG9A2+HUwowhcZQksvBoQ1VGbH2lf4FCTPGF5MZLgX0ktaG8iu0VdkZ4vSnLYJ69Knw085zvIMtKHbjuXMD5504F65mf9BK+z8r+A8RLNwyEYH4DjDysjOuVSPO90TXTv8OP9/0BKbHRvjyN4zyhKET1OK0iRsLM4aZaVVmNm5JmnKRr4FRo8G/7OBUBex9dDA/2CgRrvts1y0XNz7+9kS4DigXLPFSUcIGFnsXmTC0Cb+TyWb+IdLJK4/eKQgywuxb/E7gJZs4v8v0t4FroljexzfTTYQAeWpolgNxEcg2gZBxVeLCCuE9oqv1lat4aUBfOCjLaW9NSpaRW1R0PqoVWsfqK2Cj1upWmiLrW31NlHs1SpXb1+RariLijsJJPmfM5sg2t7vvb/P/5PPZHdmZ2fPnDlz5pyZM2f65GzrC2N0kjRK41zwt6//HaTB5IIKKjcq+OegX9+NZ7RPm5mBJVAWzlvi+NU/TprVrG/6TC3NatY31amlWc16ooozRnGt5Zlc69OFOeLU9hL40kWQje5UF4Bu8uPoCtslrVfSelqIJ2Iz09G/Ahr/LI+PowR4Atok5hegZCFB7J1bQbvxiXd3L2Yice/9UvHM8cJTiNO78f7VIN3UusUna4OOSSloAekWN7izPbJxn1qpTaB3QVs26LzrOEvFUKd3HYcZIBdebuuerjZE8lq+hDRklJCLGSF6ruUSM0r4tF3LR/KBELsBsSM01lWP9vOjhI9ozE/PtZYUjhLeh5hSj1br6yH2Bu2LmhLQ+32ClT8ogpW/QZDDfStczaQ/O77v9KTp4wonmMjFILR59cqd8AzoEL32qi1lADOr7Xc5sYBpbTOArOvKLCis3kNlpgThn6539LvSGJXCK1ONLxCPHt9B9YgE4XvXNv1bVPraD7I4Mwho7qUKKC+3gB0NNOXjoy26dO1GqODLbGGC2Rj2NDtTtkPmnTHfbBsesdkW7z9NmOJmBgWpN9sSSitsKcUe3lp4EejDu0LdYBtZDLKQKrW2wTa2eInhIlAM2sCCRPSAJARSkmquZw5rCR2TsJeOd3jnrCTOjDkzC7zcGuet2KisOz6hzuYzxTh7dc4mL7aAxCbfka0vAqltaSx6N8N5KqY4QZjqyi6Ypb9Anyc0zy091XymdIONKZ2WlsAXiAMIcpwXXTr4f90VXoOzX3JhqyuW9hzOrvDMiMkFlyu82iuzduB3ZcfYAvWPV2OdsbbD1VgzrO1F2kOk2npr+keM7nc1ACa9fSLp4kUi6LzYOGnvPIP3Z3hAHDCDGuArgK1C9Fd0EWobqX/pIVw4m7+mK+4JwrdOzI25euoxP+Z00rX/+7kWWAE+gDMe4JwJcGK/HEW9FlZbH5SyfKmU9ZxVt1KSv9NXSnLDAriW0/vExAfwROXkRYintYAnE+CpDGGpAFpBH3ybbc93zKpOre0JX5TsBCQsLvRgcdytEP+0W6HrvNBNE3xdOHt9dihK64x2ltkp9rV7V3Wevoizjp1XhLwrKvff/87tnZFHvDMP4P2PWGcGId4R48Bxl3jxmVmwvAOjf477gA7cv/gfcV/1G1JAjRVpqsE2rvT/pqtdttxSL1a8lKOgM8F3gdalmWDEgYY/W8sOYgY5xU0ESi2Guqi89ihY10u112xTi7HGEr7TPFQrzRez6uw7PiFQZxWWmlWAbyFXDr6aWTBBzwwKViMP8rZygrC1fZw+CfpYvrjE9eRvUh/6e7u3PX5pzCwIVaNXA3yDbVnqq+JjgdfOMcmFE7iy5TdH6EfiqL41kkfeVtgulfGR52kQ0dKn0WmJ8I1xrt6/df+vfVHCDY5ND/dJDe8Ufcn/xneWxnbTY9sjTx3Q7k93Y6yzStAdcsFYUdjwa83KUI8tFcNc9/QLB1wDSiQb7kSg1D5DR1f7AswNOkkCc4s+pxoor/exIHd3ib8QZbVMbbNmwxg5shh5GPaPcugfwCtou8kbKshFkFtumln1Zav7Fh0fRiu0vtIJLb7y7gOiZZ6RjqPX8XSmgYm5Zy6nKz23LXJ1s9UM9ICrGt5+p2zYZfPtiLFXfdRXrQr1j1Zf9SWr3z/UJ9GeBGXKBp2vluO7mOVCf6KjstVnbqkuu0+ivYR3dM2x35eVZMK3IHMqqKzEeWSlQPqcqX0P8HNBkpPGSytXZTDOXKSWCyur8EubyV1dXPVm0qqLqL4ImMBxZTPajGkZYZNJ0frxnC02jZ9BMLWzmsTba02ZBRb6NiOsNG2Edxnta+aN8DajLTb/YNMgJulKEnNnhQnXVCC/7flSpHFM9W9M9YyeurYUPQ8tnS/6O6uajaUohV2zjffDedaRtO27gFQsnU4cshzv2C4rydm38AnfNqdAynPF6eORy+TCxbbV5MmVq8mn5aCzlWAdtEcA/tzNtmiAX9WemlJSe5G8p/uKrI/bbOvrbxDOE1bT9fJmmwruz8K97+WLTX3VXzVdUl9sUsH1R7UkF2n4JeLY9iw6h/zNiCzQCb4dIe8YszILGsh1BvqcT64w3xVKe1Es7WOfOZZZ7z+b7QrwPMP6VznwSS6Mpz40VU5xsap9jvWlkg7bQSYD7t2iqpZQ+St+OMdHVJ+6QYAeetTKhBA3qUZJLCTyxxqczwmZlF2Akgfg6RmcjZT6UFvb3ALpLtnp2zH+Pt5GJdZnSCeqGkmQalCmlubh2KiRkPOVdpBuPKWjzAylv44lrHRIrQBYnyIXenRqiSBoiT5TsfxvnpHkYpS7C49JfYXjcV7u71FZ1TjH82XTJTar4HzTTLj7kfVKBCqg6r2uM57a7f9D7aQ67IY2AWzCd2n7O6QaFXb0i8ddLEidWKeGktCOPvBmlQ8fzq/hN/L96MzlTmLIYIUi+5rqVTWxxiEe+rxuj9FraZucaNPwgR2tncCzwCuVANEdK9N/T4rDLNm2LBEHt6FtSySfyI8QutqHawItO6n9xpCLuVBuT0+5R+1h+u603DfbmAEWa6PNr7ioeVCxkT8Hd3Lhlp2NZzTnzXk8fqnawWjOWmKNXfRqXnq/wq7mfehaWL64oK2Rvn/d2u6hmahV0plDUj1NfO93dpJ5haV8Oa3pNp7pPzNlfgfEFxwSxBkA8VGC1jisOq6QGdCpvm/u9HiE5FpYrpe5poUJ7GExokyHJ2xVY/5LhAmafULNR3lqON6uAmhVFMJH2i5ZsQSEcofvgAbgA5QDnriIZbxox1nTY2ZvKWq+tjrUU4oK6hmk972uBt1ASulp7wrl+tFyWxwHrC81ryn+wdrF81RJ8fKllR2wy8rUJq+R8DEfriEQtqy53/7XSOXGXTZD6TUIuFbRjcdVQab/ySRGOGLCFYhIXgcY0RJciYs2PuP5wj/INP00+vXDjqTrp0i8Kiwm+dLk9AuJl30nN/SIyTD3i/mL+d2WqXJWq788KyYV7qvlMm3y5U9ikuH+lHzH4V7akZeiqZ3HyIZ3Wx3ZrHbY5XfpPp3Yy4m3Q9Tbk4aYpTmhaPgys4mNV/OjPN9/i+BKB3pvi09T87T9HYwquIMyu8ectCytQf8iCPWjnrdehXF9rxXnRLYnnbaw8euAYnw67GZ9GqqbuY5xqXsjSk7RRpUeJRbp/ZkE80fovR6OJdqNdXwO5eCIJrUnBy17g96d85QR1KmMUQTz+neUcdXKqt61MoyjHkLyoNeltmKZCGYi3N+C8BqEDyGwZrlMoHsFd9kGbn/T01pIy0KzoRTbbEwHNc+zS9Ss44cLT7mHazQWtCTroY22eClwp00BVDi99iWA+mjzN8WgOecjzC81/1Z8qRZGoQ5MBF6MNkrrRSOEK24llUnyxb/ZGVUg3RkonGLj66AWItAa7jdrWy3VQep7Puver2L6b+N3ErNOsUnBr+N9ynfz7/KD+IG8YsfbQGfngc6UQGfTAVbRhd6J3zGdIk+qTsV0s6B3tc9M0cZ5nu/vcOfr8+n3X7SXXu8ekyhUm2S8bxkT2aNyidhCfHdIp2pxLe6EHvvH0TLPQZlLLT0qZUI99VCDJ4rvtPmN3mlTanfawiN22nqAhN6DXLZ1Kd1pC9kvNCdu32bzg3GytO1laMmqZv32D5tN2y/b/AFrKhi/myheIN/+Zy4WN6d2UFDqRcAkHdtzG6ON4ySqa9aXjhCecD+uH0Ph7m0/0xwDXK6p9KXmSqQAv1zhkqPRpioebHwZ5HUfPpDH1HNNsrm5wneOpXgKGPsY6PpY/wg35sR8+Fx6u8ahoaNmf1r+74QZqOMHePdBvRltjPTgzunqpzdYo419PfFWVx/9dIhHeOI2Vy99BsTDPfFfXT30qdZ3eXYQGx9t9dkxvnpCTbQxxPP0B1egfqT1mepu1V+kfHU52tjVk/6ty08/xMoOPGldvEqig3fg+g0EAmEQ0MZ0CMshHIRwcTXyInH8TjI40be5TL+NJ81z/XYSjQ7xgCfHr3YxFQoez4yVzphscDFDlLXSWQjCSi8f8+4SRnsGHM2wV/TjfS7hrtL7q0DMwOqUVtpHuMrF4o9utDPAs8CGCyeojUC0UUtnO0YIc11M/39ZOaCZ/S6OhxFu+L+sWuNOm09EOWiu5aC57rRx/lOFNpfXWuiRRrFZWawBidGrh3zeiLvkomG0w1kELwcYIYx0yXeE6ENpa4USVj268COrlBPz4cyDfAdqbPCG3tvv+sE7TIUvXavNE4kb3/oY+tvfgJf/4OHvDomvT8A+58XHpk746Msn3l5nAihLd9n4HYZmTSk/8RpR7alqTgOaz9uPI3hxB3bSKXYiKXYGOyXuP9qDnUtORhXipbDXEUs9XThP77VKmy0caMN9LVAyxPMgvhfi2sv3rdn0MZAvBvEp4fGZDjz2bTzafIPCHtp4HyuIvVG8hIttTvmOUXiCMGBiiRvHSyjjAJS1g43f+R8x6aXPYidisovej2JyCn3/LeBeW6y478y73yxmbagScfvc2gd5mY9xo72bbgv5btOba9dWMVoFYhawZ9iu2EStWZQTBZkSJQPWsoWc3bQFNIwfqI6Qbd5C7iYyg2fDtVUnL9fx7eJSojGiRRXeaY0+t4N74/oDVw5lbgdp338KjxgdxePppRtIvyrc38xonjJzO6Q0txjRzmhSzJgvz8+b5oQ8o81Qy3LUH3xar2R7n3BtRUe6tvSTM+XnCFfFqvG591l+m/IIwj3AotjBlrNqphxtPWgJLWVyb65oV7/rCHlPgLxd7EWijd30bH+kCoAvcYTwXXuJwDJdOriPABTw4HfeaTdBjvrDv1tTVlF9NV1uAAl7vrJ6ibicWsJfXyfpsW5RAF1uibjUIel32AZ41nM+j2fnsarhwvU2ToOeorjaU0SmOkWYwmuE2TjmL/C/J6D2PXJL1Y/PzmUHHEoKuBKhZvdH8/jW6bYI6Ovx9BSTPHGyqwu10UFfP3tb356sHMXFZICGKxOmyuVDhjCnSG9dWzXqXur52iOG+ayuqsU0O762jkGb6CXio46VvKo6a37k/PNMtii3q2hN+jjqSUaVev66muzc3vpvrJP5WF6uYoflib1dn1hRc/iHValaIgY6VLk3rZnz5Tc/l02DUS+cUZNYBuUWX3MjfHmKgR2WPZ+Ny85924qQlJvw/5Hku1Y9LTFPvO1kh71hRRq9B7SK+8EHlYYqFaUSDrG+a9t01b70/CrUnvPEy/R0p+lulsaHCzUn7tuPFR7T6NFaP0E47h6Y/nPWQPQJE8WomQH1Td3U9U1Baka9N+fnHPQCMye7vilsGvp6mc4sFuOcOD8doeda1jAjhRQ7xnpBbCvEHqexHhCrhNgIGguD2HGI6WgsWI8eY0YKIyEWiPPaLZcgNhQ093pyIwNaMsMtul2S/X3DOsk3CNLJz/8OUtogRApBSgJX0EeUwUJQh9zvlY42V1UTzrTBJotg+nfllSAdDAQJ5MCavUl9L+etiVD77I9MRlx94ojQyPkwS96arvvH0ZSDkIL+xobqfLTyS3lRPyae9/VreEyvo9QT59Tx3Tv0g8Ym5YFA6HdB0IMyePS/8CyPunqucNrO1NTQlEYYqbH9c4UTkHacn+1Ya5/tWEM+T9GZgYe90tjUlZ1yq6d2g417JUcocE7mcSfZDHyXzRGynTLen8d9ZjlCd/f9Zww8m9bxLFeIJegvPEd4yjnlVrg2V1hlV1avFlif3TwbvxLGjRnrvHzNPB4lSi+eqprHbReaM7evh34WoVbsT1uDOBgMOPAz6/SxtM417YwqgEp+p26YV1I/Yx2YUTREUzvJPPGD9pvW6fEqfqrwNcmoeXgXOqZ3+cPeeNl+dh8+6WNvbPJd29ikmMvtl+9LuxW8bsKtoAJ8EmhvBM7eaGPzgecXN5IY3YvN1vxGm6z4JZBWJX/6HxYPota2H3RIsJLd/XtQ73sefo719/J05LbIwaHuwMkz968CnZhVVTUnlQ4X/B2+vK4apQhFB09jgf/I9yNedts5TVfL34DPnCLdqP/qBB5tHvPEQe0oq3zgXDI/ogZz+jquWrfYQot/kCywKVTdYKT7WrI0vuqdKeIuYm7BzvQ/bWUGVPJs/3G3140cd3v9qHG3145eMv9EEt84dH4bYwkfSkao9CmhFhghAIf5vb1jLVqK47dD3KhPBtSyWMqIf1knpwT9x7ztLtz/xfT/3YopD+fS8Wy5W3zaNXQ+u+PCczNSblhQ42+wKoD6LFaEd6u9ezXyLLmZGfzE3bxDc6zJfK411UNj6D3Ry4uiqSfyw070HOLdF/8JXbVudpelbUwtFLs7famMHrScGXiN5BweBj0oeFTXFoNyFF8UiWekHXHi8+MmRh1O5CpVjMzcBXi27BIbV6RttQzfH5ocSooGq2N+Me8khiC/6Otm5lGU+ZnIDeT5oO4bk2MAl7E9Ni6yhJKXBj8VMx+uL46Zos2zdDsgLw84ICv3O8CWKw8w5dx+nwPz0xL5GcJYtw+MGQX6AkrbCW3A+4e9d30y7Xs+0PcmOmdTHzDYH4ELQArfqaeWtkm9cXXbZD64LGQjvhUAeeKdkzq91Q1StJ3eWghv+cFbBW2hZWEboTe2sEqmnIkKPjCO4nI0idB8amlsClWfo3wlWJ2cBnqAmlFpgQrzxF8dKXyWNfRA8P5EWocrLpnmivlx/dtWruVJOdeSKhtD07+H9C2W6/NyhIp2PHN1N9y92T6c6hQ6/jGg5joHO3Cs9Z0jsiGxjZkFOo8UeJGwAyPUwSBBIzS9AZp+jlVEaWHKgg8wUbH0TNTnTMMEq5sdfiyp6UfOY7UYfACfJMOTHz3nouxvT4B2Hdau4UfQsbiXPpjiucSRWdDTI7e9Q8L0AVRmexm96g37yYr/v3r8BVw7ub3o6fihTxyPCqa+T8bD+De7VKK/arg+A6EUwlUIP0HoArQZAWEohODgjU9cA93ObBuWX2YbWWwmFbq7wFXoXPXVjtnwq/LR0hoq0jPOvyP9ou8e5TqPDLgfOMinwEE+xfVUoTlpu1u84EZarTahDddQNuN3VsYI+03l5K4KTxN7H+5aM5ghjLDbxO2rsI3cfsGWEHPNNrO0wjasFLQM0DSGpz+bPo5wY2WVsvKpwit2kI63IzyJd7aZkBfeBd1dim8ErTeRmSPucek7+SPqfx5zZRa8BPnYlqUK1BlzhF1tKdIKB0jRwG/cmAdzSE/L2sbSp2Mpvj+3zxGfdcLYz8K3KZca0cgMQJ7rnfF4vJFrSYAv57i0D31ZRr98ptOXs9o0nb58xC3x7jOeL09pi6RP+9Ivl8CX+8CXu7EN5AbTQOp1rG5rEkgEzFnQAFm6Fq1Ez0RDms0P74wBiTgGaSsAuMU1M6663ND9ZvXWYNfV36i87z0HQVpPMdW+5OFZH8B1o80nZqONi9hok/m7RT/cJ9IpLqv1tr9sXRhvJu+pzOSoblUV1QhKN52Iq/Gu5OI5gJdrd+flCOcdaoqfHGFEW44wxCUvM0Dq1w6VJ3VwG9ZdBWmnHBGetKi2nTY5aEpMBO5w0fCdS6377MGvHKzF8nY5Ajzvch3lbXb4etIcDuTxP3j6Tfu+lvNPZWU84fW3oTu63njO6GdMN67NT7kVnC5rDuqN+9l0J93i2s8kGZyJMpOpdauqevDd+Z58GB/KAz99fNzt0gTvWFWREt7IzmdvfuEfS4YGnQBdY1HK7GSZhY1jhwrWcSmshY23W9PwOqzVOilFWcsOb7HijAbAmyKdGZsnriKSN7iNnjEbd8iWk29G+NeYyNJYaUxZLOa2o3ZAxxfhLGgKgzw7TFn1AH2CENyOd/3pDtMEwdGGsUi6wzRBuENj/egO0wShvQ33lPahO0wThF9prDfdYZog/JPGetL9pQmClb7XHWLvQuw6jYVAbD/Evmlj1UHULuMwxL5oQ1+haGHnFve4cQ1q6wbQ19uDlMchfA1hH4RcCIUQnoPwJoSyd0KVb8MV6YtAvfgCVih3S+sO3zxTAaXJtLhClG+WaxnhoInVTrU0EIHJEd61z/a0sq9DshdtICgZbrE/60lvs3tsIxjv/h5DQQMJouu9kyWLULq6i/al0upuaIeFW5v4nr3BllDc2pzYsa6bWou+hx5e18XVX+/a5v21XVwrQgteVrjVsT7CCiaXZFfoXe0gpxqICmAeYx/sgXmP3VsXHaTr7AM96Zv/tC6JsQ10pTlT17ejPgixVCeEO8KIUIcX368dwu61g20TYztW57dapXWu7rFZIH3ibglWeMOJZ3rLVEZxmBtXe1aTo1NwhWeT9UG/NWjbyDAzNki0G3qsDNqN4+XasXT1VDZx4crxBWZiiCwnF4aWJ/VpZDY9kZaox3K7uDMLHqej3nBB7RyjH0m/5nJJsIR1giXVKVOHXjeTwsh3a+L0j9F8v7syC2I9b3POR/UxNPWaS7L0lFUFnYrRD6BpFyGnxpPz3+0D9f1o6reuBmt/fR96Xw85Ij05/tnel9pXG8Ual4yW9TA80h4KVnCelKuxh4Z68LQHSgn2lHKiPZDOYRnFLa5/WrvqZfS+zMWpD1EdlgDffWx9qHI6hFUQ3oJghtAbgh1CPOBzygbUbRk1x5toz5rk9q5xGz+T+ECAPYGuFyd3PJnxmbTD3ss/vJZ2i8UUh8Q/zJSypXlcjg9t7KXvRWFLAujDPdDPbO+uD6OpIyg+0dYrhPpINoqPuiT7csyX2t6Vzi8ZRTW0mozm9OIKMSVBxQrGk3Ue+vgRrjYIPd/w6O3CHKLifSkv89EDzwKN/IBd4ia/6NziduAmH0He87dA7/XwiOXO+zziF4bVII/oYZZpZpqxnw1tl/rbGdf9vvdF+8N9z1BgRls8MlL1isGMtnge+wZzJ5sQb2+L7MQvHuYVDvENN/IKyQ7kQX7R/Q/84j/xineh//mleXvgCuovzii+7Ozc78qs3r6GeHzpjfu0gXgK7aCAebWF0Ad/yWCHcLyvWXZBNiTKXHhKOhOIqZUNhPyGEH1Imo43iqlOpFgdvzR2OMgrOr4bSJ5GcawT11TDJtGd7s9guYXQhqtP4KysBt4a4pTTlr4AY+vgN6R2nQzXhZ42ZYQ6t0SXn3ZAFVmLdOm1F5Qosp1I810Jx5RPjSvg+BiAgwGqeqQthudALjaKhO7yaNAlnGrwfEcq/0m3HOdrPHYfON60w3OkjwlAH4tw7ToS6KNnBWkwsI8CfSgetxgKdtmii72tXuBp9ZQOG7pMT2ubqYXI18Vee6lH/tD6wd7WD3KIb7r+k4XTHI9VGV0Rn4tU+KsjmlLjK3RFXrpHL+avP0CZuOcVfbnVLfO2bwO07/wOTK6vRYsR/xq3mF0rYZIRlB583+7I9TLg+z4XCIv1rvcvprv8JDmCESpdKr5HhxwRph8h2Nx4F0rliBHCbzQWROWIEcI1GutG5YgRwiU3QNe6fjGjYiJL4AtfUK8t9UQFnOoLKgNcelPqt5o7QcpHW4OVW2zYfpL3jyfV6AFkJenTH315hLEyjZ8lq8D3gT7AQR8Q27yYCTqF7b/kTYnG8B1WE4r0rXnEHHQqsyAEuAdyJYRlOIz/3fTdPB4WjWLDicyCAL1MjfQlPb9pV9LTkputuMfUKH7ZhjQdFov7Yfq/KdHaRLh2Bbpi1EHHEIccnyumuaHOHR5q7tN3OUjJOuh3YZPYIW+BViQ3y4YYzD2rdKfQRl1ZuUjs2ZYrxrhxR9A50JunChltG2x+fhW2RL+pgr4NZZOQckYtL2f3+e1gy7nKDTZ/vw02md83os3J7ehWrtgRWA4SQ7DPjqBy3x3B5RtIRsa4I8r9vVLnikp7BVDtNVvPjjmXzxvRYnaOGEhyhFX2XbaQYuRS6MPItznIz5vrYGOAvivl3+Opfflk9/tW5T4OStxMoCXZC1a3ONDdAjipmhUm2WL1X5q2402vnIotsUgMd0v9uBDGlrEAhTb/k2YGdKYJ0loh9QxWZ/sL6J0pkDqHpq4H/WFMgzfPGY/3sLeKN9vSAB9fOC4SLnaVbaufXLumllWfJoNjL5LB47qn94+StXHxgWcX8IFfBZ4N/EptjDMoWnsvLuCVB/vw8rNHk4IMkwxqXtailOH+1CDDRaKLZbTcj75QqwpyGmQrPKdCADi+gnqdO3t2LFMWqrw1Av1fEo+tcEOiAiTbp1/CFaWRvDFK0TLSh2sdU4gaT6a4yom+3ljhrTbJ6xsrbLL7Us9HJeRv5SXkk5UXqQ+QV+MuUn8gJuoLqU88zv49L/xgZzUVVKsrISfkJbZfSi+ivVnHjvtTN8hK8zGAQYdrJAH8jCMM9XeB3i46n6EdhGdpZmI+uYc37cUY4xBTqFeLbOrVAs94vn8KdlSm19o1Xmc+FQn9dnAQnlZ8HjSSgYa56JFD/a7hZwOWehjaEK3lvPbIyA/P1r7UbKL2c3uzML4365gVdSUyEXfUMoKp/Sngy/WkIQP1iHRq7T1C+NKJsTRq7T1COEljPLX2HiG8T2PJ1Np7hHCQxsbpkXZHCB86UaLQxLLApwfHUn/t0JYThRXjmShmQD1JiOVady9CjTd+Etda+crnTciR3lskXY8WT+dfEWfYuda6lzPg7mm4O1uUCneT7OjjLxHunoS7X15MgLsJdh38J0NcKHxFTIRr7yXhwM2mT64nMyEYIORM7g99eZE41K4bII+qJ+shlEGokEm+d9oLF4n9PT55/OC+r306/7X4qT0D/j+xp8L/UXsi/FfbE+D/IHzxa/GAHTkIeXMr0OA8Z5DyNuhDTgi+cP88CVImHOuVXkemD9UNwPGRiWRoyS3k/hdvEsDCEniikvyDVRZ+LZoA/qNwfRVrD9cirDtcl2LN4VoIX2WEnW4Jv5KfhbplbvFMrXeu+HPgYVzlK+IJwqh16N+skitXlPuULxKPkFzxq/ZAPpF6+24Z68OjvjJHVLpxjw+2CMBVhJaEm1dYoCVCWtgu41sYP2iV7fU8PeOo1e+FwNN4h+ccSSfAxO+HUoK3p84Rf3RdgrdCx/tb4j8OPFdPvS0GnsP/zR5fi41N8eozkKfC9lZpOHCzbOEjh0jPHj9TbKI2BWv5bOFdR0OTSb2CX0dnGbOF247GpuF4LiqbwT8L8d8dOAOJKwrZwqP2hqYV6vomEyvlvQp5E+hspZS3weHPy+gpUNlCuL2BhA/lyuubVrANJGyoohzq/MJFCnOouQF6Tp9K7y6MyYK/k2v9+2LA/qIK24qICpvJv0/lZEHlxPzoV1MWUyeoVwDmynBNkhEiVgD2IL/fkvNNzFrQ/w4cv+nH5N30Z9G/KKPOFuLd2cLbLj+o9+1mDvn9fmlWjFlRYXsDvrCefuH79mu21O1c629Q1i8PfPun9vjKYvF7d35z9PYG2xIYF5bmV9gW57/evK8YqKUokf8K7r5qjs6vt2UV19sM+SW2zOKvxZy2e532nMxpREp+ri2oEnlisfih2+ODBEIWlLcDyn6n9OvmNfk9Kr9uVhavhjCoee32Ctt2eLqn9JwtuPiD5oEQfzv/nC0o/4Nm3+1zmytLK2w78zfAaDWoeU1pg2138W/NA0s/bP4A0nflN9jeRf8iEH8dvrjAHQ9jZHjpBlsPKOUvUGJPSM1274RRsBG03kZbj3xNs2+xsXlQ8RyAo8Q2H2ozD2q1oNj3OvJ7tOHx/8feMefOPjkWcZICo/M8wMccyuEqbHOLz9niIT7fEzdCfBjEF9B4fOU523DAyyVHS3O3DrzEV56txVUvXEctFvs8VOJ8T4lz/88SD0GJXEeJfpVPYoldcD9xsXjHVQFaP+IaZdQK27RitCBsALxL8ach7g/xLBoPghIDiovFS64/1izooZoFd8DRA94KgbdOuRoh1zFo9bke6HoAVoNp7BzFcojnPhxyfwC5exTvtPnlN9r883fCd4c3D4L7nsUvNn+Yjy0yAlpitm1WcT5ckR991TzoudXw7GvIN5vS2nPPxTQP2l9imwGtNBNa7Kn9X4saR+e9Tol3SkzYx4CiR3t7GVC2drIAehikl9i2+V2w5dCdx0DRfiW2LX6ThVRoh60gaUyAcub6SbbZHftsQPZILEb5o962pVjqx4Fm7C3Ya7DHRLcN3h+zD7AF0to8P0wZ3F4B5c4SBCer6XVZgmdbKX63qvlMKXq0qWpW+uFOmSnCTBemea0+kmsXgT4xfWgF8F25dgqdI9E8++5p5HmBt3f3ugy9/m83ZX5zb8r9L6coa80ptXe//9jSwS3cd898jJLanfYvf32elgTj0tC91jP8HivS3Of8TmsNXaFiKW+Pun6f00Re0OyvsI30awAcST5/3OK3IHmaqM+yBlIC16mxWLMGsgbup8eyUdJOxMVt4zpWBWXq81ZcA2PNjPqc9X7pty/A2Ev5YFVvgB64ahrwoBFU3pwLLV5he6pjnbLXFZy7qrA956G/GYB7pOppnvhMiE+D+NM0Xg/X003M3D9CX9CG0DJRB6w4RsVXFoo5TmwNzIN50db4XNNwFnfb4TvngKur+Pj9bvEvbUwUvhtM12VkVPrXxOKomEUYzevm+/VafqEBJI16UhW7GuTF16MHeqbR65Yh//DKwFvsXl2W4x3idpCIe4NeNXI0WhkVir2czADp7OS+EFQQotTSvriFGSWkMAPkiAzcDVcBEtFgaicQALH3IDbA7tkN13IUYn3tnt1wLfUQ62mnO1Nrz4Ds0Aaywr8hfBQUrKwJCvbYR0k+k/6uXQGjOXN7p+k7rUnYajqiZW6/YToM95tMwWjxv/LlSzhev7EyV7xMcgs2g9yJVmno13rscmlvZ6KQsPzbdNBxVUw5W76dx/03DWQc9EXcd/R8TIggCwyv3WxL8MN9QUqQDXGvUHhtYbOmdLNtZvpm23OjcX6d3YfnOxhjcK17srCmPZd6T5N2GyUKh6kPhiC4+9jktex6+UfceSmDtL2YRntRHdQlu2CnjS1G2Re9PHk1msSWMtMu217Kl3bamA6Kq7tdYmLUq6Akrz75yvXuWtY8TVtC91/3ydKhbxTJvuH1U1rOjD5eP9Euu/vCIXagYJX86ysvobf9e+d/0N41J94OiSpParYm3jsdgmfZJ96rh+uN84m3Lyy+bZX8rC27+/ShXPEx0gBtvqJ35k25vDvfl39Zz6iPJClr9yeZhAbqtQJPlkgU/r5CohGV+rRVw9vFfzoboWa6Zsbv/k7qlw9lFWC9xt3OGeeXfN6GUs+HHbVcJuYdQmwV1Mg8dfVPRq/CFXEsxE/GSbsYEMe5BT2g9lO1CgvgP+qLmh5aXL2D+xXYtxOFX01qQSYLjkkU/tmBddPtGpOXiqOvIwUoQc/AeY8dvjNrcTcWcjyEfLnT+46y8T7n+xvURAMhuyAB2vYC3aEmzUPKGpFbLdQhrUVUD+VH89hDJMpjhDErKkihrlzyUkAxtWo51qEfPHtlOb5ZqPPmHYh5TcepLKVa0QCQho6XW6QS+6olHxF9QEpL0+2yRRSjN2Iv7oIbdsFYhW8g7fytN8qRwMd8s4UDjjehtVYn1QnicqBX293Rm223tZttP0Zstl0CGW++o8I+H76OFm51tz9czvOXfsM1NjxfHHnE9m3bnvDqzl68rL2CeCp0em0ol18xFNjFX9sbJVqmabX3lh56wdpAJulmw6iLXteqAG+q5kF++G5Mx7vue/GH8O2vHnp72qFB1n7aCeZZgJdGE/pv0/BYil0McM62DerIiXBzF7EEjRPvsUXDfaMuoreLt6CdthSroNU+bP4QtNf59gabrrgfSDFevFHrDlpOl0akxbrmQSC5xRcXNX9Yamw2lXpr7L4XdAh3BL1u3Wz7KaafLaV4cbPxAe9v/BUvR/F6m0TOco4wu5FreLkIcg7kJOcIt3uyMNfh5RPIQ9z3/nlQwtesYkNBZ4zZxU3t9/H13UGs7aMP4Mt9r+7gadtPpV7+cPy3+5Af8ZS65A+tMLdTqbtpqfKHSt18EPHJRjX6AoWrlrWWHaT8Jmx5dTlQUjlQ0n1tYTD1NAf0bMI5x5d+gzvV0t+kvoFU7u0Z+b9hmZd9l7WaALJpOoRqlrDPjj6yXzro9fPwnBm9leBzpPMRAPVk4UuKJzy5Z4oQCC1/pqMPBjRU2DQgnx3o4KU+V/ArP/rKGrx9rFCHPiPSaI2uwNeTD8I7pbNtxzt2gLnvjTrYABB6ZYAJBMYCP0lL87VnC0+Q2bYvOmSCux1v9TsYnYbYy3T2+u2CzeBXbssE+arBvcsKo1EO8+gTd6cenCUk0BpOPIj9OBT4cz+AJvVg596IvRPGFQe2Fx1VADOmZg2UNdW92X4yjtEqWp9bpGidXrjL1i3mou3XmKHNiTH49tnahOakmIRmWYzUq79ta/0Fd/AvNEDdDf+Ge9svTK1iY6jySuA3T6AXXRO0iglxoq4DrlEHtS6csG5DD21YrX8ePIcvF04wbdjdEiTfcThYy13y0UvePhUNUxPQQz7OAXmsLGoLTDKm8JiCf6NKyaMv05/dPvz0E+s2nNJqYBR6zDJYPyRtLujtuqhY3sgXigLJEeVOdd4uaDNsXdxl0W0/zsnIbq6UZ+VBWgzqusjLLpKyoPGgJeAJHo+k5ootLvStm8f3hvs9rtOkjLlnzRGvtidEnW5SsVL5daSCDFFVkME6Vf7432Vq9K2hzvMpz87zLd+bpyz/Oa9LeZYgONCOxpCfJdx07M33K8dTmPJ4I7TjjvazVqFMmidcGCL/9LgGz4L14ZV8Vz4M6rfEjdZPC824Al/fJFN/ZyyFK6fe6Nl5tC4fa9W3dgnwIJyPHwRSYEDxd3nZ2d/lSdQ+lNyfR8tiDgAmRlFMdOYo/4T3vRJCvS2w+ADiZZR39etsLavGWaUSkqMryFPnFgLcjzlKbN398M4Idz38Dmzoro0y+1wK1iaaQ7WPm+9UM+pHrvfTqsyhl3poiWWJxw+FzEJ951TLqc8rbZ46B/vMTF0CT05N1fqCnPGThVMz1xX0uWCVqx1WhO2DyZsANhwLj3mg8mu8YEvIH9E8sKMfTq+VtJOAYpn6mmfvCe59PRoXV820Pr3IGMW0jik0iCNPFE4w0/12OG+orb4/b2g+FRwF9yq8p6sCg0qPlJOj6sVHLjRdmtvNMNFwoenHuW8YvjdcIGvi9mZ1nmfsl/5z5viC+3OMiYCbMMf/MsP4pRX9XUQZsj1efHFmEb0a07r6Ia1i7fZmfd04nrayrtnXz8uNTl3EL9TQNS88B7IHevtVYX2oFw3qP5iWSj0ISz42vsvEdyRfwlkeX8L3IV+XiTOm/pnS0xX06UaAUoJ3OdzpQH4XjvEFW8jZobjrKIDvye+t3kK+C1mL3sTG35leUJ0QZeQXirFu3K8l+ZvRpvuU62AkiGpj1N2jSgDLOKPKPDbavFDwZZcBU8gu3Fv4c6F6UfaiPYt+WqRenL147+KfF6uXZC/Zs+SnJQUAu2nozx24HCd/NwuxWdAJ59ijnrNLOGfUao+/Yq4D6/dxHlglnIISm+Ip3vFuOMU7fkXQfWdFPwLmY/cpI6ngfFM8pQC8Gz4XsKN6w5B9Z5wM8KP6nmL2um5dVmD6dx1UEMAjNpEOgv4nmMye+cWkgk221R103qvxPLR5aT62hw9wK+j18vBanCt4iY4Mv0lj0EX0nun1X7AuCzjqa7iWVTjBv+iIY+WdGV1MJOgJvTGkODQR7/6QXuRNVx7r/GTi3WuL04xmEhZoEHfalafYm+NY5iYbzN5cwTIqv7zeBvjSGulL3l+iEUrRSWHEMdlH/kZFQTLhHlHyEXlbJ2iNkfwOo4bfOgH94njfQe2wUHzd4V1zK/TY/kv3r3S6f6HT/cJO93md7rM73c/qdP+M515O9xjkCq/ReNEm7/4CXBcsFJMd3v3j3nz5NCXhoXy6P+R7mqaQjQ/m6/OHfEk05e5D5Sn/kO9RmhJf/mC+ux4P+4x6SBOTGtLC+o9vYQLqmpiTp24wa4LwbGnAfB20P1ONVOB7zJ+X7VNGsYTrGs5nCf9wyatmEa4tFNIn3nMv2pYUxsvwZFydsrYsaUwtzvfK9mXCaKPidVFZQq0LrUTYmCXUb3+QRV0E3H1AVNHNw9uTel1WJ8fy04vQqzijUbSwittXu16XF8n2hQom0HSXqeGrY32jdPDdHS5Gc/2qDP3VqyQf9FI9s4UutEYnH8Kbyf4gPrKFVvJn+ebZH8bbJpryy4oeD+Sb/od8r/1pvuQ/5Mv/03w6T74vNs36K/KK0MKAD//RxMwN43Ee6gToQoeT/C1mskY3vrq3cY1xk9Et6twsH86XTVAVmun5j30jpv39I1B6kHfLDHiKL5cmewF9VNY1yVLYzBWZulPbk/BMYI7ntnb5y0AD7rzgMuqblBm5hncN6pV7soIAQouzhDyasXsV7oj4COBUHpMbrxi3TgjSKXHP+kQF/3pVojGMwm5uGqVGGcKM/ioAUnNTghplC6MR5SlmgA/PtCi7cC3hvhOFcOUWclz3++HypIGX00DiyRYOOStIeN3JFlng27UBLWxACcQg5Xq3FveYxibuAJ42iXsTZjvWt/+WsrV2osAEKNsCXj0LXzgLcs/ZJp8D7LALVl9qy+eF00zMjBJ6pr+RAy6h5GlKkL/n/FLq1QpyIv8oI+EsrdM4PFvCB0YfRjvGvJFoMmRDEi59C7xK0G1PirP4F8u0Oov/XxntEHM6/MeY64wTX3WLV9x1h48nqS2panmbIlc7P7QmKDVX2OdsaFJSe1wfS3h+1zS5cUYewDcufMKFpoCUqb8rZEozruB/2RTAhuf70OfNVoxJZ8tVvx2qrIfwCwQR2qofSHDd+O6A71FuoAmK58D03YaIIvUS6HOLGZSoYrOX7F3x8ws/LY/MfPeFzTfkDOBcvhKuBTz+D8xS8b2g3xxxqng5jFdv5+I5IYihK0bEEKPONkjzDDK1Il1tQKpZKDDjVZn1TT5qyd5DA7Tg95q8aHuSr0X/2ni4yi1rXsMdV8AdVCgHBQCN3y+zC93f85MhLO6nTF/9XgMzkBnEqHdDidxcoDko1XyqAvrfceBdiUmBTNAxBbyvSOf4RKJ8Ikvo75a+i8+xn+5uUTK3QBYLOuYD+Xw68gVBvoXimzR357y/Q17cw7mqCttRVi5TbyABul7pvZ6MKNpAutJdoJ8bjYDXJhdSGjMg7KZMmXJT3mVbCnCvFME4BijOnQBhpFt81ZUPnKwez+xbmyMkt2VUy4tGF8qL2Di50E8uL6Teq24IKxcKMsZu3Qn4vX4miMH2a2gKV3fFfsyacD6KrSCv0m+PrzFAL3nPJTfK9kXkAY+cu3XCAeP46gvQBvVNfdS4gl2kw9bClmm1lhoTjsn5n6rxDIcvm8JTSo3fVuO5Dl829U5ZAyVpnCvJy0ypUVYdsmwleUWFaf2dqFkXMytJkQo96jED/mXF/1+AZy479jHhVPrDTAzHf3e4W+OsvulxOyEliIQatiR1sTw57BThdP1Jdx0HfNYfKHtMO3NzvBywGDSjCE8pvDL+yzt1oehjUm4EjKoijPJ9WyfgOXuplHax92/l2AF9B5mGNB3ua66ws6DN9ryiaEmX9SAhKpnQR9YnJtAsi5txuK82u9CvUQ3lKgrHC33gK5yO3Y47SA642WGy+EYrYmIE8Ea/lyGPDiAFmZKV61/OulMiL31ZwWfdmRB6xojvoTa3p53dztJdgevcWuMMkBQ0PO7r1SWGT5AXrbwTvAZ9lS071jUdpL1qBc8elKmZ/goiG63j2YqvmtjkGcK39rhZCsKOZuMDBtstjArxgGObw2rKxP6zkbylY7UBfDfLRmKIjUr1T0Y7m8xIC7QgtcK7nRk8T1z3mUwbTHN4nyvzMoWAdhwbe6RykEc61/Slz+TarjRfSEdJfn9lO57P/YzTSl/y73ie/lf/5O0vsC09ZJjvd9y3gD7iahdtC1WaILwJ4e1tyPO7/QX96IzUxUH/XFdTpvMTIpyKvvIrcUZdXD25OgapbaSOu33UkCl+atfwtKbD8BzWNbSu0ttdAFsF1eNu/yuKjdw2FSiJpjL0rV10DIO34u9Y8Z0Ezzt+8A7HLwHdqA6+4yPkuRR856+thK8leL6G76X3lWlxbPS7VAZ5ptRAGUHSF+6S6wVBpxYK3Zk260LBjyHUP2TZcI7fUb1VlyWsc8r7cj9K+2/niOX2BnI1ILVabuRaytgdRsRi+ATQEOQ2K+LoAOBFdQht2MxE8xfFYAX0Sd/LchXa58wRl9pZVab4vYu5yfVAr/0+985kLBSbCRv1FTnz19XEPGRv+GmieVzFo/1Yj46ycNYfYQ23c/dupHD3CEpD9DQvRiNvzBH7uFMI9+qxpFaLah6kXEEvMzliMGjVBMYlEzEEMa2XDd2EFAejwrGJTDST62PM5JdXr5GiMghV6t99/Xz4Qb/LfRn4AtMf1z6VDo6E/+4X6GdW86H6NB7rH2q/CCNhjnjBpTGE/+4b6A/PnuOlZwq7xpgj/kDPtNIaALoIJlrRiL2tyB3XayW51I2N5wZbLGgnMXqHVLdZO7B+TOuFHMk7hIp/STzWpmgNM6BNTjfhELXMIokviedOrEmSm0OLGOg7dqvkE/DOBGbANj4COHddk3yS347xcPWZVteknLwT9CL5Yo5PWbxq8enFjwHPiPdhWir8KqFUnnAz+Sb569AniXJ21xZf2Qbim6Eajv4/fUjYTB8SCiFk5tMpNyxov7omo4SsLSshpRloMSy8nryqB+VD3dJ5EjQave3cUDCDDib5m1PHRvNY3jiSuAx3QPsWAi92t1gV1JNNtnDTM1IytddhTKnskBMv0dFmerskr3VNR7+jiYQbvWdeljDYsXse1xKk8J4OLdvPqDX83hwZntDeksziHAyWqjtl7ijvn7Q83Z+Wx/3X8tI95QVterA85Z+Wd9X+38pTe8rLeKi8621/Vt7R/1pem0sqr+yh8o7/aXnr/2t5FzzlBZQ/WF7Zn5aX81/LO+Ap70laniRTGEe7xX/Y0bM6XD0yyPqO792S2r/Nqwm6xdM0ZSJN0R2zVCFXZKLwZHQF/zEJT9xAeif6VpxrkidvIGGJ04RnCOhPvLxygRjoDoqS7ZNXyioWiJxrJ+mt8y1TtN56Ac9F8tmHVNkbuNpxJ9Jp15bH2a4tjzIfk8FQom+iW3zK5V+5gTwOd2+3+0NuzDkJ6oJjJBMFvQvPEhnA8QrDKtOqRYrlihWrlqZkmogqw0QiM5iWoSzgYVaUDiQHF/adodB34iYhNiQfnhy/qqob1O8maI7q9GtktymRqEZzh2J5tItwi39xzG3i1vbVM3SPYCw/mpft51o0DJ5dygzola7OxXgFy7UYmDm57+fWk60Z6IPfLQrOkPRQvTr3wTd3MyhbucVVjvqmodPqm+KnoS2bW3zLPfGuaYmKf49c1UkyFlNbCLLo7tUsg/3ol42S/Mi8Xi5HDUru2cNhqJX2IemefYN5/ENVxZAmXSpIYSfPo0Z1U8bNuylXgKabAjLBGnyvH1IOyExX7HIjC7qCrHLrBK6lUCbbhzLidXcDyGSh4wPMvnss9IRIRl2WtOimXP4R3QHMoedj0EWZ2g83R9LVauHYOiPu1uvKyw7OOIEyHNaWazHKcL7XLX7irrC/rMPzJRqaemPJtSzIfJVGPIWxgrysqju8IqnLpUFUD0SbqdVJL91kZcyVgupouoIuOhTAn5Rx5SDfr4ZgsbLqa9ZKI1MtX1YB8t/2pGaLW3wEy9LVHV6ZZLVUgDzJaq9ZKo0XoUy32J2wPNdSzGQL6a6nf/eVdzGzGl8L1kyZykRKtZP9KMmh0rufW6RvlzvqrF+fDWK8dVVCXdXVM16TaVn45gq3kuq8a0DyrgvjaG1H2LnWt7LyeFkl6jG4W71Pxzd0PzaQ+mErq3u/0svojhlg6f2aO6a/pZz0V7lj+phlkQFRbJss6kJSHwvXuiOnAurqs38F/OfxXCXa4eMOWL+O0o7S9lBCe/jzDVYm8pqVjWy0MqpWaJtlG2Ywy0r6Mp3p5MnPJDr5aXzp6xntB0O86Yme9O4HJ/7uXqSr9KbHe9J/Xa068dgz/fPkRb19ZtaCHlAoK5rS9wrotxo8Hy/ZryipsHDCv+8ErwiKXA7ypqwQ57CQHp6tZitRe/7ZqDVkr/3VwI7OXo4pRxzY+3TRmEt9CVOuu381plRrjT9DPjZOyrXb4X89au3Pa7YniecxvtWhU70orm9T8EE1GsrNMPVLtxreUC8HaXzAHSuegYKpx91sZf81bvE1ei4J9UE3EffonwAZ7Vf01Fvzqf5TkJ5yxbvtXOuFOTr+RSjpk9RrJPkIhL0QyueJUfajpER1lKwOqk6dJ0bY0S+DWzznZvmDEA+FeCmDfJHlD0Dc347/Smh/SzZiEKQxxYeQ4iYa3iWa6RzCexAXafyMG+cQ9kD83zRe58a5hXcgbiXMIEz5xG0ySvr78aTYy+yIkfx0fp54iebeB898W9wJciP6PRhHNX65cQfkRWvCDB7PO8d8m91JODPBGoFrznMi/aTCs78RpMsS+FY1wV6wkp53Xm9tADmvgVwf3EB+6bMM0t4lr6U3kEt9XtO/lspEB9QGg249T3yLNJCyx6lVh+nl1F224tLiifPE9YRRQ/qjs/ogZQSdl7fmLeFurpTj+sjc5jXFCbzHW1fveeKLRMvfsM5PvWZbULrLtmD7NXJ1zzyxgMxLzREF+8S7ZxYv59EH1wJxf1s+SHJzIL3dngsQPUvw/2mC/nTLHncePpCUejmf1+G8hHqioFOW2/xKFW3KlQXJ3hXWZ9dk8Lj+llaKXiHniQmkgFe2KYaxIzT5BuEU3Ss+CcocTIwQP0bjT6XiWeW4smgQPqIpeKJ8BLkBOd6jcTxBPpQ05SGmA8m+PDw53p+MxPYn1dZUPkd8G6TyhpnXCLc8buIqoGwNbSOWT+QLxHtujM+A1kIfx/92zzfarEOB9q6aIIDse3V3gfiLm7uZIl/Yp9xuGc1oA69ATJHBbybm0V/eWcHKBblsOonUPUuiVCOhjHPuZY+N5X+1IB2vcOV6PEsIb6L+dn6LJNfehKv8rVDlQAhjIUyFkAdhJYSdED6BwG0NVfaAoIGQdiZU6fdVsDIb7hdvRX+pxckjboco5fIQ6ksyrnzN+CeHhSmXwbP1ED6GcLIyRPkFXC1Q1nUItyHsg/hRCMI7IFvsClU2bb0vg2SADGJxcFQWzRR2uegprjDm3Z+v/B2kjgVimPu+/5p+/NqqV2Gc7rMCR/0ePIxtIxSZoTyzeRSvAjliIZ6P4oe+f7hW05J6cslQ3zTymfqmMQfqmx4/8GUTc2BBej1RToooqicBk+pJEIRwCH0mlRBVbAmJnBRnjOW51opCbDGudeuScbfX6JhI5cEvqd8RpgvX+jbu01gbCdJE4iQ8JRVPefAhylnToeTKuKHw9iuLuNYFhfXko/H1pGpKPRGmuMUb9knpk/WYQ3mIUYNUoY4EmQBzv1Z4rslnrUt8xcW1rs7W6+XlOIr6qHnIrZqK99689aT/VOjbEAZPlW91iVmuJ/TyrSVk+lRcH/whPpbqnM9OLSHFkOfSVCwlU9C2jwDIrsfDt273B4jfMdSTX5LryQ0sa9oGEg7Syjb7Y+kxeszV+Xtc6wcGCbYhLg2UUTgMyzgKZVRBGdOn1ZOZEAwQciAYISxNqSdFcD3uKXe+PSI9TI9vPljucU+5LNS5Npt6qYG3bkEQINydhi1VQpinu3jO/zJUAJ3ifB7I2P0hoByEspEJxjmU43MgoPz9nmeeDXUxjnpA+zDtQ/1roo0wAz6Q5vyGz8kemBMeFc3jab5cSyqzQHzBPmdOEE0xQIoRUubZ304HiQBiZT71TZHDtkHtTbokkCRM8pH8r3PryfoMHdTjAkgYR1x94N0EoNRJdqSdy4auQs82vAuDu6tuHfDi79tLoYT6Z+vJmS71pG5kPTmbx7U+YuTuVcaMA74AGhrV/JQtqUrU/tyimXyR0mJB20ukum+B4oqhhOOjoAajMCd3rz2Su3dGBRS2v4Qcfa6enMyHkuHKzJBKOEQW0je4e+FxQPMzgOIhBM1A6uVah2bT6z1NHF5zIWfCaChbmQN3iaOlL5TEcq3DDCVEN6OExEJ7DIVr3LoSEg/lJBfUk1S4rvF8rYg8Td+MhbYsg/QKCFtncK2jDC5xjDMDnu0eDfBBaj2EM/BkbDZ37+9J/SJ7Fa4krEkWV55ktzADJkBO8xhsjXrgoUDFEK5D+GUmd+9G4gJxF6mDZ9w9AvfbSBC9P56xQCwnOI9poPEzEF9HMmgZmueht0DQvQFwP8/dSzAsEP9Kn3H31sD9SwRbagFA2dQejf3kcaT042Px/+TYQfBfR/+Z2fWEg6CEEDYbaaeEjMyoJ2NM9eQqwFc/FmngWUHmrExif3xePNkOPWVODD2f+HlxVzujuXsF7w0d56UJrzO1yJtX7ghVvg380cHcZZOBzlEXR91PBQF1MtTbDBCWQjDB8zIIuzVhyo8goP1DvSaM+uJBOZz7mBmoIMr5gXymgeWHpMsNqw2bgLpSF8bwQTqX+L57JNBwBuMSt7ejbyp5Sx+ZLi4qd2/uaOM1UmHaYUzgt06I1Nc39TOAFHNwDvRZkHz8kQZj+Dge5RCQ8KHn9m/ffsOXajNcS5V8JdxvAWk1ND2iqIRU6FbBfTTkzRRugaS0W47yO6ah7FGW8jJIsJW1w3hpDr+QzuFTD0G0r9+AelZWSH18K/R5qT//b/Ub1lG/mP+f9Tva9r/V79X/5/qFQd1uPVQ/JqrwGBOJs9ZM69YXpbUs2QtJL5jIW6q6Jk1KHakMMpGPVCbyMYTHIr+CHEzrey/WkcRgE0mm8ToyHe5nRpqIIbLQM17+Lzjb4fLirKzt/x/Oev+POPuJ/L/i7CTQhG7zwzThnoCzXQEK5vaTz3g5JdS1VVMczac0ydemEG6eBmfVFnZtCZRtIIEG1TCXqHYNIGHzpqXcspxKumHhbidPC0LONYxrrczsPlDD5wq/tcVAjRgYTf3SuNbDwBuCYZzSLGHK2S2sOob3gdR6SPUBmYWjPdm4qoeSyWESGSOTOMKjhyy1/2qcRfUa0FJGq0GvcYnx7Rr+BTEIxGGMDWmn81qedVO3+BOVdDQVnddrF4gVnnVuup6cnkz8Rktef163F9HduSvtPjS+zK6LyhjPlMXxPnof0G9yxBIXrg1879bwuIqMvKXcM88plf8DLT9HWq33zHqqQIocY1e0mBg3tTfHcyZfFJ+ukdZthWPyV9ZWSVbcaZZHn1Qbr/h2aRiS6hKH21n1YP3gtJhUteEZYa9Tk6aDlv6coBetWIvkjUX5UU6TUt2b3uP8Iwvl96KxbAFn0cI99610rQpnEnqlbyBhGVy57OPAcz2fDKxHj7zjSPjLmUIFlKypea8lnMXvHMYY36VKOCUf4AAdeNVvUzK2nela2fLVh5+bjcrAPa5BuSOcfGP97rtx39Rf9NPh3D2EZKClz5/xUw7ZCXIDxDvXb4wlylO/SKjfV4RVq/SqtL60fnHOPrR+k/C7J3p0qh2eSKRz4/8Qt7cWYZ1qEfJALWIfqMXEB2pB/cv033Dvm7HfrFHi+kQneNMA3nCIy4sm4ilk/0Evp3PS474r8qXWcTNO+K8JXb6uqHzxuiJWm3LJIKxwx6zZV2QQvqK+zsaYzZ6VV3meern8lb2LWfXPi1cbUZsNUKqX/LOafbwHYZ+4UA3SAZuI88k6PFPgrnVylDwW8jDPi2piEJ5x3yzSJjNRvRdFP2IQ1rjN1rDUbKHMVWR0ielE+4oPP6UmujRL2OAIr/65eLyglP+8mI6Hy1mtw4JPXvY8kcGT6FK0hVjiYDS3zJjGya3QvuVvh1L/Lp3bK6FTeznFZnfn9prRju1lEF52h58Ik1qr0gCtFeqhuJNOb1t1T+fK8RysMN3DrWUQnnOrPG2FJdF2UrXRdvo06/ULRdrVTbz6mUPjWiIWXTcwqhuG++31FIzvgoGuMcG73zvlvA5PWNOzkbhiYxC+O4Ue3ZhazPdwvUZb+nvqpYZ6rYB6Remj0lS0Xv9u60vr1RU9gXnpkNasu6dmEztq1qMTFYY9UK9m130qNAgB7gf7EtbvSGbElKn3vo7N2PtkveBTHVoGddnaqX55QI+7O+o3+w/1m+Gpn+JtyW9gGbmbsUqq35CnLQZhrGsI5DUI012MZpJZnvcVEXQ+LUGcl6ur5812rHLsremvH5DmmWM8wERlN3EhIEvtbzE6xavu+ia/tfVNAWtBNtvdP6eBJO7+tIUJlFl6AfVNcpaSgMIM4HkH3VUtjH/XK2zUdpKg20/CVN2TZQ75HfmQUtJDB/oAd8ay8Hd/+ZXAE/D2anJXJ7uCFDjLPt0zGqF2SawLBc6/1Yr1QT0Ex6Xq+3XT7YC6MdphZuWhFhg9u7ZkdPFpuaFwigPdMTBepgJ3iIF2CVOn3Xsi0TunB+VypturTW95xsXe+3BFaOpTLrEbYTTdrwhQywOuMnJc9fPh7UmLLqdGydrk2Y/Mn1UzAmp4vX14eq8iPNeV0Xz5YwSFFEvq2qJRKlo0fmvgfidQtbx8Mj+OD6hEeXcrpJXSETiA1egZ9YqkdePkO3RXLjYFHABpJOp0U0CIWg+anE7DbyKMyS0GQunmK11bjAE9D2TwWmHZuHnwbvdyX3WP8l7pYaC5ogeBVF1CVNCBTN630rdcXn6OJJYZhHiQgOU7fK8uFBTMIatXS//Oit9hy30OnGsKCmHKZVHj+TSgPoOwpZ162lRtsyJetwOdXTsTxKAOuH4zrvUy944P5HjUrTa3G6tBT2Oc4iqgY0xZ326oriCxo22HdyZ1OY8Ws/GjudY+Brf4mBskI/VtK6O+ax1vHF291RhhZDQOc5XDJCR2KZwQztutD/e/MQ/wlS+cnfnKYw6Jrzzl/LNxINGJ/2nO/zYOGIQhzs49MN358Djw/vp5jlM7YsI1sxmVbvb9fncN+l3C7AfHrSce4Bf5zs784h92iV+0tiv4xBPhD8F7ox3/W+i/o/2/Q32+vTPUQvsf+cY71c67i06f+J4BGJWd4NbhfNBDcCc9AHe3B+B+xQP3NvjG9D/AvZ5CvJn+v0P/V3ZAH9oJ+uAHoF/yAPQbH4C+5CvN+onh1d9fep5RXX/+PtxHAd83nv/PcoJTPNzemT762SX6GNv+p3IChXXk/4DpRx6AdXT7w/TxwqknRvk9NvBqFcB2vBO8doC37v+E97kH4P2aSPD+2vZn8F5qw/9/tf13eE+3dYb357aH4e325trnn5oYPmINwFbWCd4woIutD8GbYFF54O0H8MoA3r76vml9KLwLSW8K7wb4gvKBkd0lLv8f4Fz0AJxv/gHOVwZMmbr/eOVwA8Bk7ATnOsBr4fMof834P+UvaTz8h52l4yGrluul8fBCjTQeohwn5Tn9hzyfe/I07fDmOfKHPIc8eXD8vb/eky1MrfH49cxccueNbk/NCz3WhT7heBlgR6bGudVGjxT+uB1XSaT8exjtm8kLL3/5x/znO/IP7JS/T+HHW95vjgrp3F4ploGe9hoA7RXThv4D+6dFQXs9LbzlVtH2OuZQ8IUnej9AX27xI3om+T76/wH9P0H/j7v/e29e7+jckvsdD/IiW+TQlsnjLJ8kgoyS2kluWQD0lmF4kN6GWfp64H8E4P/Wwar76Puk9abwj3CHU/inOZgTIZ2ozS3O6YAx5AEJMugBKEc67kuQ0x1eCZKpHT3QqVw74Ku7N2YBLLPuw+cD7UogvnwepzMIC2qka77nOqcm4dg4I8f/q3pdXlcjG9fN4r/MrfW3pMO/0pJtDK1el+RryTXsNkpWo9F8kzWU721kYlrNpUl2yyOGFmvCqUHp4jHqQ771oMEpmtxc69twnQrX/EKnqHHjHDfO9zBRDeQXHVo4BqG9T2x59c68C4SpY4cpLI8scw+RWWbBv8L8ZZNsLjs0fOm2zG0rs/mb1t4wOl9nsF25Fo0vaP4KZuChpECzZqwmX1mdKbxEHs3C+UZFSx+WWqnA1ye5bFavbYqhQx/eD9QwXwxo8+6JjqV6syzSKT6DZ5bHdaW70xN0fgNw1n6+eMvOjjUUdLcwh18Qn2xXzcsSv283LMgSz7Y3EF23LPEMXBsCEqtB7xmGthManlhZ3XVLkzUiPdzAtV4wTBeS2tCC63mxh6uBXArwWlngjKFT1Nu5ewk6iqt7x1VO0c+NUoZTTHDh3G+AMNSJs8H+wik3yiduUQ9X1Kt7ExX/qjhFOgG4Fuf+JFs7rGMFreN2qpPLjdrq8UZtjcnIUAvUcF7a10XndsatqfJ5RFH2aPryeT7l0HqDdLziY9+3QNYmqPX/y62rWSiwij3zkNYmkcTrm2/4MlxLEZ2Xwfket1jlVPRtvtI3/f1555rkI8aeAK0G9LeNEF4gvfXR8F4Z8eUTjhiAfnA9ZC+1NDHxodWhqVnCh24DSKRZ9qlqpuUSew7kw1E8ntU3zt41XZ3ZP+f9HPmBgO+k78cQRd+aKxpeSfU8kJ0Vh63RxX5K5+4gqsuijIf7AP5TjdFW480q5EcbSJCuSMequ8JdMOifv4FEOtvcQEyGPQt/Xrg46J4ve1PGpNaWTo/mU2svTOf2b52wE3Iy2jTzASOjfdIc8RruoKoE2FmynMernAA+fDYQJYPWYSOcjEZzpesB//Ju+/qk+5XvhC+yZPBYZgAbhdK0zyFFZcCmcyTc5Lt5A1FlKN6aLZx2VSZ1a5TsH3zUsgNMOftWOh8DkraOny3o3JVJfj+qFjrF78gNXbtY424gJTo2rh7+A6m1hxzw6Xa51dXAC57EvYA7/k9cTNxVxfFrgYaWtKHm/tz/x9q3wEVVbQ+fM3PmwUtGQUVFHGaQRod0EDJMTRxwA0MlPur6Zsi0USzRXvRQ8ZFZ5g1FE0WLogeIKIPRXyovVtStW9ZMWanIzdvDI1k2Y8I5zOt8a+0ZfHRv3e6934/fYc7eZ5+9195n7bXXWnvttZwJB+tuU4kzo1A+T7Mr6zIIcu0B4Wepi+e6fiwdRzLhK3i9eQRjCBS5PgP88guDA4ifka5vQL7AnY6jF0eurcwtEj7wc90pRUXCGwBnys2M8TisaTizPhwbxOtPvIzh6MXYtbgDcmtRJEjPX4uzmmAuLftaNLyoPJRmMxGkN2k2kLXCqiAVdaoyBzCkXE7WWtbmybQLhbH+WwFbhlE5pTJnDpHTiCQLQS560NbBbxfLx34tqrcxxh+dha5RUqGLSLtERhPshSLhH+1c1xPAzz8aUCS0t99LNYwfp3NdlZB3K+Cas31p/nHxcH/u4v2zcwHKA0uVDfDFqo91qsYWuv5G9WIfBjR0hrzJ05nRdWQhnRldh6GOG3yKhIPtc7CO4UDTx1aSR94sdP0QKHTJAJazgVQy01LoYkPxkLaWHRfvVwTnCLxxA9fVuGg9zJJb4KvGBvCZT/hEUvTOk8Yx0HOf0CBNwV2lG9rExpdxx0wGswVhzgWM2Qb9krqXH+QucosnABS5A8IrcLSPLkHJ6ZiYVH5MTKkudC0KZOA+KUjNuxw7KfSfhnrxN+jFd16s5ZaD8P4dxzq5pxZBHzZBH6rh2hC4DmZ4oev5gIqUHToucspe+HM3cl3vLFpH8LT7Xic+8QnLpSwSgr76Jgr9bVIcQK8Z2yZmPtsG9XMU+twBiO9pFHrNQcSZ8rERvIKEobysUPI/74pRr9D0VXO7g3rIKlzn5gTpAPI5SAfw3ND8uUGdAp41MkBZtOVHXdaEW402FdlEZtjHW8ZTPOrnQ2vc0I7K2htzM26bK1i9N+bOFebT/3O8Y+H/n7xpts9bpl760rpMcEkcUdsDwte+dGtki8lyCmZIrZXRTQbe5gYfl6A8lWLRkyRa+7deJ7/Q9ZhURjK740qWARfEEYM91WYmbFdtUUD4qCfFyqScdmhBqpeEMQEuIeyUwda7SjB6o3Uw1HWCZ5IG5QNN2D710oCFXh2bGJk7yrZQ2Oo12koWzi2uMT93aoFwt9jXIrcpabuvehcIhSJnu8u8ldphZ4XGy1SpZjZAOhV+4yvDmAHw2zqur3oGPL8HLvuOcPWB94Lxdhj9kUZGh7Y4xzq1QJd0cCXpmcRjnQa4GwlXClyj4DLBNQaudLjQl1WGHinsFrFSswXolSS8QSMGPFX221RWS6nsOaCy9zmMQGUfDFFZow0oazhjLHGcWl21Gml3AVCmCK0kPOthDNPbJzQoD0bVTxFPr4qoyNMzyZEVQGEjxgLVHUk6OrWAb3GNqmeBylp9wiR/o3lcB+brWJ+QAakxNJUEqVRIGTv2ipUmPN0y1RUXhveFno1i1pT0kxPqw7zqtJFkRmcsK6/wCYOhP7Ed8irM6Qdv94N0ZMeEerU3rLIyeySZ1TkAclWQq3SzypOntct9wgU/Uu7TviuUeyKlXZEwx3U+Sf8EL+n+zPeuABxdAfaKEabZpABmxGgfYzh76hSf/u9pe2hdH/Grdb3QtdxnoHsEGJ0ouJYX0LV8WD6u3jXLxsPs3uUrdNnh2uEbYmETC12NPhXJ/RfrdyxA/Vev1eYT1vlV16zfPqHI3+dX6zddtScXunLeAnrJXF7DmR7+gSXh6iMwd1EPhnMXz+gFY34WmKLpuYQS+yv3DL9n4T0rNW6VguLMvlnjKM4EzwuxAMk67zu/PyY5mxoZd6SSK0/LZ+9R0FGhZ64aTEQJI/ONF0fma8mA9FwZgveJ4BjNomOUDGMku1F/Tz6MkQrGZxhccp+OjlGCrwyo+FjHmdAo6e/Bs1zrYJSGAGzp3jMwSj/7Lo9StZlkwCh94ovNrykCyld+3SJZvYlEfpR4T6Hrda8y4S/t0UAZnzb1sbSJmzLRj2C5aQRBLbqNQRuIQtf5wH6kh8o6vqMwOH5FofHDs4tPQl5mlJzpjcGDnPnndz/emEFkw+8X7vV9f3ctrNFzJO1dr8LvHZJ18SvwOx140E22NuBrC3RMYiZZJoT3IFcqCV/A6qA69ZzluTwDWSg80hPkka1CtJ9rWNQpA557oesLL5O801IJcHOTKKzA37aJzNQ2Ub0cZZpC19YA8rqSkCE9kz/ExlSkkjhyr9Dfj9pU9SmmarNlI6VcllD96Efwx5JC11+k2UQL4/UX4CVMCbfFcw5M/Z+0QUzvsx3LGTNdc9ZuF8eZ2ptkRpNDbhzjYI1yJ5YaIJ1ZCDJHynHxzITdZiV985yEqTbxuwkZ5H4h3CcHqcSQENzzX+pXEsw97cWSCyVmlObUK7b5QL9Sicy2MHcJ8HZtPD7TS076q5CO8Vy3mEV3Diu47nOW24hJP4eeFYjpeHHQNvHEKO68rN820Xm9QxX+BbP7lPgxw1bIvUpdkdAYYKvQhxo7lhv1nRP7Z4nPdzL67WKplhl5j6P3S0wR9cujjZoTx38aurTxAvOIBNfZC088Iu9aspI7v07Gpr2DngTE8psRjtYLzFMCXGjlVuh5svs5c5nrUBl3fqNS2b198bM/MeGzXF9LrKGydeNPzFNfUm9EH4R8ol7JORfygPo+5IS52bCvgKdKv5k7L4+pEJ0T21X1X8D3vHMgYM6tgB8vUbtZxvgy9CLzZo1xQ6sG8DbzZkjdy3VnFzUxXPd26zwhzQtQ3gtrA/UGNsyBMtEZWO3UuioblCiqzIHnfar4XEOsOnJWrDp9RKz6L6FzI7hny64JV196fID675D33N6+asb4OIwXSBr3AvdtKhL6BvbCb70dLYiL7h0F0AX8MGqPJC6/yruCjtFtgBEOylYpPSOIdlmRcMmPbzLGSZeOH0hcps3F+CxFwtf+7eJMTZ59u/gnTWfLdnGWaQj8L9WsdbEsfv/Dge3iXFOFnaHc7etnrcIG7wfo7xL6ghaNwTZu9uznmcSz/NXc8Fl+FuD/Cx6s5cGATKuwKPLuFD6SGO0CIdmPfccx+NtjfWnf1c2y/DibJPQPMK24nl9NI9f7/wiNdIlII+G92/7cuJmoyDayC9aVfSJLPrD3ORBZr9wfXkHElFtV+ogKQ35YRVgDo08lVSLDKHeoKmAFhdVrWw+sc1QDrzyDkRsyoIY/A+//91N9kGL+ub1T9hajHZy3fspj51n54db19JTz4danSU63tGLWlBXnI+VvQe7TNB/PQkf8wMgif2DlfeqKOsP1JmLSFbomQY0fdwyswv39AVUb4P90grxPPkELmUJXnfhXHnX4SUDvmDJJgj6RZxqfIhyNolzoyoQ+aQ9F1odXKKAvQ6EvjD7Yg1OdjF5K3GW+9ux1sO2wA8oGg05eq3xWvmOByy9d3dMoixbqHQRwfX6Kylsbe6HDfRYLQrdjPME40IWuOeJPIIO9BPD16t0YmxUwfAiuDITRZYlqoyG9xixzyEXW6OF/W0r/z/MX2mfbN5vlziE2ubUkBzU1g+1bzR5nuA39BqC9Q4PImbJt6EF0INlwqAY4rSwn51YrTooMnhasbrftFRXWXFKZ07tz9l4n9yQD3/q8dZ/156LHRZ2pFv5rqx8XE63aG3GHSFavcKs5tLcYREegyZNi7bVrOAEysdxmSsR1EWWdiw6QN90m2RRRnb/BCu/Jd5s5HIl8D59ka+ZTidrNMZKwSzoBkKZZPxA5ayOMZ+y6AdR3nJKUkTtEbuppe43tOMiD9S2JNCrpWiivLoGehHNuk2LfFA61Q5A/SRL58bZEkCbRBuUW8g2PUGHEU9kBFUkWuaHZtq2EGb7dDrWV9bcjVYpyvGCbbMcoi4M9WjuecWFvkITBUjY5z/e3Z1D/2sHop6bmxxvf/gVX9lIFnvjEE7Mwwhr45joDke+ShL9JaEn9g0djp/s5AQXarv/btw7Stz4NvTXiD761nb71WugtJX2rpDnLBiOelG+PI1W2AlFdHGNn09HmMI1c4mPtOEYzpJIjcfk3NqPdjtyK9ZvSOCJbtH6RIXR2CGQdv4Ge60K9j094CzU0Vsz/3H/t6aFEEjw/NFnMnYQniHx0bwWtVJhWtMlC26xqqON9vto9i3mXD+qsjkIby4RMejYSn/5Cn7r4oA3Su414VifKnRLe7wCTpAJpRKPfRIAmuMtZE0gDGZnHOiOyo7b7hT2+WfmTKp4QNVMl/c21N+/M3I4W7qjJ2CIOypQES6ASOLxIxU5RMwn5hh1lI8itsKrf0oMyIOLRowBJFuXLlfVRbhCQKoglZlcWQZl6TQ/qDTBOZYMYbzLVBoRAj61FVRWzy0JMtZIwFdbBCU7cP8z1L3fJFB/xGcA1RqQn7cl+c4Hrx8ACFyctcJ0LpFoSyQKXXFoP8+F2R0xlkGtM2tvffn1ukSs+IC+PqfQKX0oD9mMMUeQaVfo5MLO8wmvSsU79XUn5uh0DKnafi2SSdsXULnDtAWn5zVPb+aSqtBblLhM9q73cFabYzL8rmsr3ioNMqEsOShZqvbqerVCgdKHLAsqXDnB3+RQJ3Kngmx8HSnjs2Vag9GsuFR80X9SUFAs26RJIoPdSGdzKz/1TuHr6riD9jXpBQ/lOB3zX38ahtwKIK29T+eP1QBCHdou9ONTs+3c4tNTbi0No94b2b7+FQwniP+MQ2h0hHt1F9e1vN0Yd1DQwSUqCo7GJ3ETxyACpqOxowKEfvDPzNwIGHeucmD6hVtJPeBZwqOcKDqX71S1MUuEZZX3SAabCYum7K5/q6Epgdbh4GTtGwRj+LM4C7Oi7awwZBaOcCdLgzU6coRN9f+cnAmZEpev23AWY8bV/gUuAq91/I8WMbj9ixseOviHM6BA3BS0RHKmAH5F+eXlfwI/3A7GX8YMN4cdLgWOdiTMN+cfEsurYip2AIbpdfQFDNkPbLadqeN2emYAh+BVepPM5GcZsMsX2a7EkXB9en7ywF0/yibpuDPQg38dRPME31/kf47GPq0RtSxBH7gh080zKmksrDk4mYbk24UUJ59RHoX3c+wBncD3sxRcf4IuvMkbd64/jt3HnOboH/iqV0Cr9iDte4TGpF3eqvP8Od27x9OIO2v+99Zv0p1hgpF/jjqqZdanksjo5+nKZuMB10Rv05BKkS1LjOtKHDCVRXRsffsQud1er0JNntWlmQizVouYR1KJGpgaESE8X328/rqgWEg7YpiXHxMi1x0QNXLFr/YLFuwckp8bqts7rM35pUh2QV0j6p0TNM2klG0W27GYYe4UvEylXBO5mLZFmkTVBu8Znkw/uFSNNf7YUwfq2wDWK2qb82J62qQG4HVOtX2iQbC3qqiLbTZRCBbyMYYoTx03yAIWK+IovAzyMzDgu5lLflNc7F7gqfQtA6l/g2u4rtUyGOg/61lMd5fdlvVqAF5dx2/rZ7wNcfN+rKLfavEKZP8o9S60IYWPmxfti5pBMwMd5fq5Kf1dbZ99cW76+KJJqA5BiZfkQzqZTO/maZWktqTbs1f0+oFkRf+aHLUyvva8U59sC11wvS9SHSH12xRn9lIpZ+VkVxk3HxIzyyd3Syj4Hca80Bs9ZqqN04XVhtX8VubInRHVZ2M4G0QBvD/FmTolGHi5CBTzcFEs6tHyjF1v+4lSwzZt8d/A7xOc1YbXwnVlJUAHXd7YDckyHWnbAl2SMtzmwfrjXAhX4ZbeZnDRmh9VViC8AFkb4GIPazap/Pv0xzxojnF+AbI5zJ5NCA/PZwxjaT/+Fl4E0Wr8kvEKru8jLjZwzrM6wxiv86P2Z54wHIWWD1PfwZeo6itcwxnccS9cE2zpC26qEp196gy25T+/kd4ua0cxINXrdGC+cxfn6V6BqypC+KNLE6vII9nQA7elT7YgF+2Bl+sYZnKfrfF3U9ujk2c2h/cveOfkSzI23dgRjmDd0mVZxJLPBAJwijoBf+KSHSUbLdeY61CAz0MoGgKQY6M6xTu5u1I1vEeO1W8ShcD0PV7W2gVr8LA2wCRGnooAi7PIj3436jNhJUVA/cmLb6Ur8s2OHaGWxh4zhgmMEpWXfBD4G2jFuV8zlWMJMUkPXDauGEYzXCbQ7PXs/k/wk6Y/whWtJg6ixHhMNAEWKdYt4PVwH4Wq0+oUVPR+IsVO5+pHUU74kJAYazZ8TWft20Zo6vmUEWQmw5fsZPZSaNPsM1rFd3FmN9eHovuFmo3Gl+HW9M5zhulSY4TNd/wcy4rxU1qh0VB7AN97vRGlw3gvbxeyiynp2FN3ldbDJGyDNXMckR3X1e+zjTubucvO2AyvOyyO/hPvh7fTkamRi+17xoAkjsbDG+FbUoR40XYG8Deg4R+FG7uUJ4F6yAfafUINtioKx6Y2DfAxqHEFuhmdf+7bxb7hl0cQZhLXBP+1HTcR86lVoXqrMGNfaJs4C6TY7FX20x7Ui3KoL5eH4RKZHf4XxUCLTDrCnovS8/aeCp6Lae/UF6hMIbXi5DGCVUVhr+YEXNOHzXaM9SoJn4KLJfNcIzxi0hmbHg/w2GGDa4csFmOTRfZzjS1ONYY4a9/2yGeYZk+U6qAEwJ8X0OM/qBSjDRZc5Ia/6ITs7aSDQVJTOSw9GuaPZKPf1DPpU8Qmfedy8EmhRWQ+jfYzfvTtGrYN15jD8/gRXRdCmbjLiswJkHuQkM4GLRD3aJkiZiLIC8DQTcBeuoXA9D1d1pl+4Q3xPjF1eTHrjpiv91WZZ+7Mw9gtbxhE19CPVF8Tn967g81qMu+IVNsCadZFfu5u2ncUaHm8sI1FEcfply8t5Mm0R8NFzz8gMOkdNXq1tqdAuNXrKhDVh99qq80xkqfC59Hx+vI0x5DtP23fa9+YPsT2KNhuJXoELcAl9Tsm0elJpqcgrAn5QS1RnmOv+we+wPENrrpcY7XyAldvP6rNF9cTyXKvAionEKlzqkVWtMQ4+8ZGd2/90fjasZ5tzC4VfJHx2tgc5idV5sqonLFjLJkm+ay9IbgFhkTd4mnyd5SFa/6MSq/2Ej29ZY7kvT67dxV93aDWF+WEpt2UlQBrR8qjFzcsTcQY3+Fv4Uvp0qaS1P0TvFkmzWmz5D1gG2R7If+DyuVCbsNn7In8PLTETyi6jd1OluBbUjkzybOeLaQ6hOX7hQ3Ezb6M5EyVtC0tb+8W/lr+L5qVJa4m6hSW/8EU0bZSseYzBRGKBZsrDprpkYUuFREkDsp4sepbz7Sls+2zLTj5cxyTeLo5glgpOP0iZ9jWGPqdx190rPOI52tRoVjmwvNKZSm3lv/Ks5G+xPMZ/IarL8/NyoRUxoG0JPiv038Xn0LwLl/OqeubwWTTvu0BBy2HAbPZ0pmUeP3JJ8HlDwMJPpM+PB0ro8587DrsV0axznCWPx5UlWO5h/1j+XtsNtF+tQNWXOk0Uh1oCKF0XOfHNBR0sCdedg9xl/nCdCmMBLVkqLPZLo6eeaOwqm3TLZ+uaeppwzPb5+bNM66Tng/q1l+0x6oWlfaktAfqYYatj1HmFfdVrNX2p7m0m/CZB3ni4boMr5eu+6sXw6xf6qpc/3E89NDxWverLGPXjkLcHrsId/dS/JMeovx7fV+3+pZ+6BvJeg6sc2ro0op86vl2jboP0nyP7qT+D33/A1dfy2dm+FsfZvrSHtwVQCrnrwE67jH7jDT4F1QV/KDHXt3Y/dUCmRb/zapgJowMGsu6sHlZ15AIfO7vopr7q81BfJ8CmeCHYP1zXogjT1VqE/uLuiM9yM6q3kQ6LX6bLjfsaORJ3Qq4vzH1JnJWuEdnR3wBdnJ2eQO2zNsAdpGLzE9qbdpkrWxm9Pnu9OCfpB94hnuC09iBnJDf8/eRIqvfYID6S1GBnJ/aHel6Eeh5Jnx2q5xGo55Ff1fMo1GPOtboSpONQ26zLtSlPYFpu47o2F+F++HZxVtJ2gHa3+aPPua6NtkyYC90gd3wtHq9+p33kQXgeyx2IqM8R99yjGhFWMdX1KFoFK8IrDK2qxJH56oootzYsA7hPTbliR/CE5RZPrfmlDuzpyLphRkPrMD0rVk9U6DKAcj8SqDU/S589imORhB4Iw0/qs8eRCnEO5xGeCvkgdJ1ez2Mf19uZ4fB7TblHodyDl8stD+1wcXqgxBXss7tFxiTT4eo233UkYOWfei5Is+/fETyvGdRzNpqi0SYzsMl+XDxsPS42FhwXXzP9trbT6no4wLR+BOuAq1lBHm90ikfZSOIRRkgqgvceYaS0ReRKtogKRknYXSiVpUuMXkb9iahBEgqDZ+FW+XY8n4AeJEqaLzXK9kcRJcW/XOAW2MQ28WjqyNXFq7eIjMZk2yKy2iXwtszEwls10v2NoTNUl+Ef+B/AP+ga+HNtCP3fAiqSa/OAjP5r2N8M/GvYj1LYr4bhQ/8fh+Er/9UwfEBh2AQwfAAwPPVPMBz8XRhKmp9ujCLhWxVbmUTlVlhtNYo6xAR2a2QdcleogeVIho6tne+61a9MkHfgqS58gqfd0Y8BMyr8dI3NamPTaqweIUc6Z/IINwQwZprepq6rgplfmSPw6mamWBI+kNR/sEUDbTH2D7TYh7bo8/92i/c1yxqGU43iBHuy7SX4j/7UPIIgoUYOT1ClEzfIlB89ZnkMRk+LHtrYXaUmuidrimtltUHpEiXQ8/+y3Cd/sNwb/6IcRpHLtikJxo5jhj9mv84W1HZGOKptJvvRnF5NZ0B42TeBXOD721GTNcWPcd8oHue8u3wjxusA+Rxt+IL6YTas3f65yFRX2ertu1fvtg9ePXc1zoElRFaPkoHs7i2ipgyk3DKYJeU4R9gK1AHNIN/wBsLqlHmS0CSh1dcsEUcJZBWvMnS2dQbIJyiHHwU5QICxfXf5FJGLohAo8+27bMNsifbNq2OoDnN0YDy5xJtCNT4pmaCm0aEan/QG7QB76ztBfR5Kk99d3tsb9rp3sRdlVbYK6MW6UC8Yq6wO+K5nAaMBm8NgfMNNILc7JCE2kEW+vwz/dAl3vUUp2NptXqr5XnulvQ+CPhan/tQYScpg9HcDrbvgxX2X8ANR9fdZMy8+HKNsOGRdkJ9mZfTFVuNKrU5vG2Xl6uS18h1cxXzX696rdyNutyC1/MyL+y73UD2A/mE5UG65XqbDd9BKYr5rDzz/vqPoYdUIpP3y2oBQCVT4dMcLV+U8Azmfd2h0+idB2jFFnZexcpgNa+DNDzrkddrHPMIukHHfgXsr3FfA/VtwXw33W+D+9Y6FSziQarHN+a674K2GjuNou1CH9F1em6mb75oNuS/CO9tFLeMRVsJbVTSVCKliSG3v4Ny6CM49RiWvGyKyER7BCrlPdhRO6XZiuTFQ7k+QUwar0BhThR3PfMAdSOObfwmuMXKQxtOgVDaUinCzET+fXsqzOnkddzFN4xHmQe4a4c6DD9H9mgev2q+ZAXwRjuM67zz4Po9tjaFn+H7ProIjWrrf9hPaJCwdvnTh0t+jnhnex/b8/6xP87v1uZo7YW4qa6OAS9rqYfWcuxTko72pQfvGcb9j36ikljd7U42HjLasQ0Grm5FodcMMPvT56m0wDyK1MJr7QILrR72T6pT4fe+WhB3AnaFVokco8yFtvNd7xbZlCVom56KdtqT/gpf07TDGaLcS0xxJZDRCHzeRBfz4k4cxtLWin0p9CVqFlzRvbGT0USS7GH1UAv3oy1WgXpKtk9fb4LvhfoQRqNiQJejR+loKPZFCYQT6gRSavUyhXc1bcAch+VinIoa5LmJrFIms2yIaYJWKN8EqcLeiniMmWAeA9t/NwmyL8igT4nA1uJvRqi4xkwt+YOUqR2weoyU/MLIcSKFFA64W4XX0Lb0kVEhK8q/XjYtehOqMJwpG5Op1A32PS5K6ObMYz5Spj1w9MgoYmb/1XDsyVz9XwvM3fue5Gp7v+9VztH5jR+IZMSXIolyJxsnS1ZrLRFtfxpDePsaRVjrPeIODrcO9rybpAq/S9ZaBeQL16TqwvnlG/QnMSy+tgRk4ZMjpJnbCd01SypDQmzukbj7is+8GfxfKVzjGlDIjRQd705iSLj6rhdUGbe3iycAzSNNgLK47TNJKfU01ZtfJUItlkvAsQNXZkVa6xyz/nDHyjnkJ3zWlZyMEC0vYG8/yvT2eDD3WQo9TaY/ZKr311+Mhg6e63xkvOTzv9xvPE+G5Bp7L6HP09qovC2LqpkbkZNkYrpiraAAc3SIOMDWIcSbVVvSh24ew9VxdEGf3SQrAKAX1kXYI7vt1RLn7s5h6C1IRkBpAU82Q4jqUtFyrpCBoB0sx6vqrMepDD2LU//WoKZ5zV+H53kYmachWwM5YWT166mRrFXUAWSZABtdAuDSZuP5ulZQJCbRVPGf+TUCZMLADn0e55ZCzRZQDTnwFuZHt4Y694kBTgTHOgc+i3AMZn/B9zw88mzzelkFhY0dFOeptNoCtHmB7lMK2pGcoYDt8W+V53mhT1AX9z18K8Ur1gO1C80CCp4VlBxbDPAJ8JJk61J3Md2WCPDOkA1ckxqQJ5Y2FvL4dI0j1Ix6hAL5DBNyfgXsL3Cs6biIjCJ4e9giLeuRBfjcraLuIcxNtvlEf3CCONKFuqdf2e7XJLyyHeuf/Dm1UU9q42sQYcxz19zBGS6/t9z0eQd6zluCvoueK7bdPuA5oYnJ7Uv2EOl0Fd3C+nhmuB5lrgzouf7L43SpWp65NrADpq6xX+npUumL3zf3K7nu+K10M2n17hE97cFyPiL+yHlyPNFYuSvpDQE/uCtkGxjRjfZEhn/KZunmulyT0q9oROp2N2HtjM445445lkXtaAlCrO/SrDtlZoxLtAWhuu4T7JjJjlLN3lmFuNpS92AGzrOhnntX+RL3p/sAjdelDa9zJmkg5Ce6GhsOqvRNGb7GDNapovbjHeFAKzn+ZMeJyzZg/EN5w05ov8HKjAsrH0vLb/Gd5zrjIyQw/7GajOXd/1aIHkHrh3i9XgHtRjOGL9nTHwlVlxqlAgzJgDfyreIGX0fOvivmSsAJKtAHtkpvKjDcj7SpYtKoeaNfcIR1N7MSfmqTr+4Xeqxe7+XpzxGfnB7c3sePbmySjwnHnqiD1uvOBLh7riAAKtpfSrIWr0IuYcDIEC9CsCdDSMx0LV+01yz4fb5+f8FPTcEqx6h9gb+T5oUTgkeKtpqP2KC8AjUH/7yzwmQNpb4CHh0tZEPSJ0wXcy40dI0nQxuFW+IommLUKGmOQh2cj6DOlu5KRhJvhaSI8VdKn5+Dp4A541lVZIglqeBbTgafu8dkpH1qr4jP0PeUJBOcQphshfd4np/JaN420i/yE08/o2HrZNuQElgDPy9UyFffvYHdIwvO/uRY/JJ4z9QiLpAd/RaOC652D+j7EfdmS5nmuQkn+qILkvxl3i952ShV2fGCuB3h3Vj/AMjAvNldvneHa4+t3iwEgnOdqkWpbIuk+Lnph1+Tri9jkzIu3xyQ/UFOE0tY8V62kbQnefSBV2tW5ha77QJbu9eMwq4jRWq/yg4B2kx/viFHPc8VLqdBXkGIN3znnufpLskSvEAfj1gGpPlJWt7TCK5yD9BeQVlKIGeOnzmZ60kt9/LXcHuEL6TXLa3lNuckAcZavMQSxFd550/n8ZZgbAGaFXnsZXjxvXe8M3i+H+5eh/i8DXKJPGArU6TlIfRoItlbpfB5a+zuM0HPQ2nMSq6+0VOZV0RGK8O0KtWeAOtY7H7/c3nY6Rpz+yggNlFCrtvJgMHWDFNzpn+eqCkRAqzchx3xpIaQrQu2uuTTv4Hpo+QT0cx20XCQ9Ynkkr4z281Pv6lC7P1JdXc7BJZdbLoWWw6/qaTstMTbUbg9NjYZ2Ci+3Yzi4DNo5CT0shnauhx4WWqx5NtrD3d7FoZb+j77Z72DB5ZaKQnigzLrSy5doKelAMPUOTYkHYHwut+Y+MJNinPr4DGitO5BtmZJXQHt1l/e2UFtr6XunD9x4ua28UFvhV7V1Ly31Yaitp2nqHWjror+3rTcPTAhhynho62hghGVkXgZta5R3bKitfPreKwcSLreVGmpr1FVtZdBSFaG27qCpp6Gtty639fiBJPq1bj2uh7aeCvSxZJ1xDTRZximeu6P9nYpXB/S9TnvssyXn3xscM37ojh+/emLemsSZTd4XDxgO1t2eHrk5eWz1C4etjPboVeccce/eBukSuNBWOw5+tXChDYirkNGKcJ2GefQB/Drg8sF9NfzWwhX3bIy6FH7L4HoibxPt9SHPxlCvHX7sgfHAw5d7XRbq9eiren2ElooL9bqdpvpCrydf7nX4gfso7qiPr4ReRwdWWpblldC2VnnuDbW1m77X1WC93NYSbEuvv9zOk7TEdw3B1Ks01dEwzxXlN8HciBUx/QWkFf7rIX0XTR+DtN83CtKHafo9SHf5UiEdSa1ojkD6J99oSM+j6WZIf+8zQHo/TTdAusPX249XGqaE6GA29KPez+onWW7Km0znQJxnUqgnN1DIyhtGX+7JTXTUpl56YuGVUdPRUqtCvcmkqQehtVcut7a84foQXqZAa/f7kyzD8kbQUfum57pQWxKlCHMaBlxuSwdtRV81sy/QEnmhdiJpO2ZoZ6Vv6qW/rPAJJR7MGddQcmTdxNvNe6dZ7swc+oI2ee3IiOnz7e8E6p77y4nmmuS7ziwdhLiGeDIecKYAfmeFzvzPh3TGAkabCdcmuNfAbxxcjc+iXl/IwtNsA8gw4D806kwyV1jRg+faepzmblb/nHmyY8Bp80V2Bt4pTr/eFVt4k2O5K07R/4z5ogJyzY7XuwyFXU7cSfIIn4hhZ8zdg+A9haP/6Ve6DDPU41nj2RNYb2tPf/egaKUTvRDmES0phXVXEYqa4FqffZGVP2ee48i+GA6/x5yPbBpXiifewlyHxK95lnzKf7t8vPUUj1bPjOFLR9BmpddH3Sf81EtlRRlkiRDvgRIT2PK5LbHaJcJhv4Jo7Vy3aB6ad4vrgwCWxxq0LfBW5HJXhMLOs/vGkVtcqQBLpV1OYi2xeTKtVXip5+ozp7jzfmICvDNhuau/YieFAvcWbitCPv4ZXp0fZ2MMLodHeM3LGOJal7smKjYAX1kH3yT6/aAdMu4L4e5EXE5vjEC88C9Ze+XKaHaIGlZuG2qTucPlsaQ2R7s240gw7pSSnrkts+mHVprljl7Y0PJG+1KMOljfcpc8FC8FY8CU5DhEJnWX+aZW5vxaTdlyzC8XGfbaKFi/joSFsZoY4HBQyvh1zKbeCFhLBKW/10f5EoG56t7ju3J/6ar7C1fdn7vq/pur7k/7rvg9f0LSQs7nVz09dtX9X6+6f5veq0lfUiw89ZYa/le8GfQxriA7Qa57ErCNq0McB0khe4VAeowPG7OnXmpfOW/FgETb0GJhOVrVqIe1K6qOiVz51EuPrET9a4X34i+TEpmKSAtXpaxdLEQCNinrR5JBg/BkwU0iSgbXD2au57J/OY3+ZWd5B4b8h3/8KtovB32LLXBVU/jueuFq32JLhMW+a2M3LXA9TXNuqbm23PR/KldKc57+Vbmb/6ncXTSn8pVry40MlVM1KywoQ6CkozbNcy3wB3Xe6E+npFlNwko3NQ4gQ0nfQ2w2k3RLCWti64oFnVRtVpyaI3zi42zaJpSj2d2yStmlM+a3B6r1TV1M4fudDGsskTnD9caSn/imrrKpPzjD9CI/IOks/5uRwF7jbEm2lwi0n2/NuToumPSjulnTwgIven2P+gja2mia2XF9RXb0Uru8dFjIAwRXujChvWkP3RWUZ88pucBrjlwbS2yeyy6G+kcjjUW+pmrm6meInJGtWCzM99Fn52WNJTkY01JBBohsRF/LUXei6qhby0UQU3ZPkyR8J33XtME81cXIals5st2s7DCGYDCWsGO6eZAHTgFFy8M4FZKwrxVjd6wvwjOBIokoDXsO/aJug9VjgSNtE2Oc63CI6nLcSRjgNAG1KqIniqc7jPmZonr8P2w9wnzviHyjVZtWb31PNJS/TL0JIMU5Du+h3fke2/jS8dmsjhneEje/JJdU56gS8OtIXvw6AMXGkWQaYOYeWEWiIf8XyMf32m2nW8Zsmj4krpXVoU+kypwbys7yr4tMtbpqOpk9CP0jj/JxCd+37zvPhQ/P/s6BVpSu00wS0GLd9/AtP+X1Q2usrwON+xjw8Bxcpma5rT8ZbNvcGGtja8PJIICGapzsIHfJNOR43IvmvkTtCCs1jQsbIXOzsu6T+J0jz4QbPSfC98UAloXrEolc1N9iE/7uN1i1JILaYT/dGLmf0XNi0kS2XFZxWwLrjlbA9xmGEplBOmAWnbJ9idTv3xFJVpmVsNq4qZXWDNhZAlA91YhwsfsHgCSFcDVSuLTGMU5W/828F92T2UEj9rRqx3wzk01LNHY5Ed4o93C2n8iOr3GbmDCD7GTReIVx8Imt5kvOpQmMNjFOZsovfbJ0nPHp1j+NN4G0O24E3I0zjRvCtjd92BSRpTXIRHbSD05Gy55BWMLpnqa6+aOmvCZmhOy0PHeBq00am8acf5dRH/mqGf0qRZKnGvNK6X4bWiJL+lL5m3fa+tlk1qwVC0sX274QX5uCmlcmJcdRYxtuS7PH2fZCabltDMEzEjVLfp2TQs7xO8QnxzLGUQ75w2xae5N8BaSTd5uTTzB6rBX1bZyORW2cnt2n+puqnp5h3r8B/mN72+3YkpHWG6cJrjg1S65Np5DzPPbvxmam6+MHOMrJnBcLWrguB/WmH4wRNojmG700lmLzR6XBeGgmx+ZSuSteXuOOp5ZMi0oVrnhFREv89dHOxFKU3RdJ8dfH0tgFWStg5snlK2QOzP9A+lJ87fYd9nrbKJse4JHTaI2VOfVLrk7dQH7iWf3nfAldK5glanuJ0IdSQNzV27C0jMaa2W//1va8OcyZuMREbEKjX9syHfjKl21Wa/KZJNvP/AnRYNJbPxANmbnEzY8jJpgft/coEga2I5fxeA9HynF/JQzo2a6jnbI/fZBoItNd63zaIsZwxqkN2ckuEZb1GDCGzXqMkTfcdsxebMuyM9rprld9xbajg1UG9kSS7SKvt1XaEmzFgkkcbrue7tG9IBng7Vt7kq3fQk8MJkn4eyvGIOvhNc3rl+rte2wvmJWOIbYeXk3QO02x0O9wuJ3RzbFi2Q8k9FQjNkdjXDOiTSOiehJ665rnelHcv3Sevdp2nW2p0EP9vSyjcMb1TCAXeS6/3oqlnhENRDyCc7w39tkJGicN15TjtDwTOn+gZn7hXc2xpKGLXRVFGB1yhcXCUVgple1LEY4kLYmCZ64juPoq6VO7qEzggDa93INnri/w+JYB8l8WVQkDIH8XzUebllrpa54ZriNR5xUsfoGHgXfu067Ifuk8w7EOJsV9euolZuUSgtTr0x4uQeng4f2H6ftMisuRAXVslE7yGBN2mKWhS74KT2hrbNNsxUT+bhDWpQCNsf2Rg1gTasGKBdwNGOYIh5pmXoZkoYT9kEM/UDO4jFzqlLG7zHguSuWM/jj6ve3nohkm6XH4z/NvmX8++RW/3MVy/wj9Z1oPv9p7vqlEWExtp13NTwCVwggh8vI+wKmUCDdK1B8rjUSB58lwj5nZOc9VHZDTyA2sVtXoCsVSGUbyaSTUoLXc3DAmmTHmO04A73fIHHfSWPpLZoyLjcYT1Zcc6vMbY/YU47ee7rPaZOUlgkxKKsa4Ga9Lr3k2/DI37AzgO9c3wmajMwh7+NXl6HKsYYWbkStJfDujldUBl8SUCM/Bd4htB67pvle88rvlVQnZQ/Llz4IM0CGrYtNkFYPy07LlFbAWuyOZmS5eZJJSSpaV4A44QMhWmwefLC4N83Dd3U1pWWx6cYn6/IaY54vxtBDrK6UQ2gOTKISLJGb0dw5jaULWqJIzPNPUG69F+nD3eGbsojbcK97SqIBRVJbHks0E2ggvEbYFwj2cp9DzlEd9A+7DBSUtjqjKmUPlotZkflpR4eiUPTmLcNtE4f8Ciiput2wb59awxzqZmvB96nq16Vhn+JO4yzXPtS6gqgvSuA98TMqJ00qAa5AURXeTY5pZeLZIGIpWOx1sFWOUndaSOcJkL2qOxWbcWWCSvoDvUmOOPKmAfj63HGnZFu83TeOopvI5iU2/wCtgpPDMkEjn1Dd8SXPsbem2CS0ybYwlJq9QuN1LOaQjr/Xg+hqdF22RaQsFixfP/yaZmETIZ2a4tBIz/LhYJrvBKgq3BI6K3LReKy8DOUNjobU3hWIUwC+bitHKP25CL8h6Zb/jsS3hsEat9CnOw8frOXgj9OUUm/5dk4s3EVHYEjjaVG3udmAUz2A8Pjb1w6ZwZfhxS19Z14Y7WdcweYGo0wbjo7u+UJOQ75wcNVAHZlUsUSYiDVgK31aREHUq2ZKch30455ktVEs4z3CGMdTSOUhHlgp7AsqEhPavxdKyIVMxWllwtuN8PCFxQCssZBzBOt6HOlZLwVn/o8MAzzf7sdQm/3EeUxv8kZa/8hfRPj0cqUk4i/RmOvBI7CkzOc2voxTlU6AoaJ8+/VBwjJbB7x64Nh4K2lX/0riNRJcDn7zVJpz0rCcFsHJ84eHKC1D+8CrK0fL/wbURblYRv38kCdulJbOEaX4OZsRg4MlyasMrZgl5/oWD+lUoKosFlxfLz10rL01QdX+RE58BtR3wcFXy7IgKNq3WqKxQnayzMDtnkFo6TjM93/IR5xlFcXytMapCfpLZGVZVY3HxJH60fhxI2P0qOTHCNEuI8/evQ7pGegwt/avkl85kHQIePdKReVHqi2P6nN9kf9aiJxW01hGewzy3K7xyZX1E9midXNyfklM/BkY1Lm6W8Isvp7ZYSPaqyl122Q0LB/WtUAHc2ync3jJ56VCAm8Tj+jndowS4IyncfSrCT66xMM/m1D9CWxB7vuVz6h+1vM9HQZnC+NrRMoT+WT15yPITH7V7tH5KfM3MVDKS9K2cJbT4gtDz4r+GfhJAvxSgX0jr/ltPM6/cdQX2iKrK+ByQ11JJXPYsoYLC/76njGhacuoXWL7jUWZLB/gXO+SlJ1XCF1PiDQD9L9SnM6xLHnW5yc7qgXJVydK+jdNUxJzRk2mWXNrW9p7ISpkpLa7WmH/yVguzI6feTPM39Uw6Iy9Xw8iooOY0h6z0M6iZcbNhMeVjyAjgtae7bhTRo25M1dzSQmMfZy602dIzHmqKOIl+evTkJstoWtedPad4kGcqvuJH683xeURT+e3ts4TRPoRuo6gnqZbhtNxtPe/z2GKyRw4Up8mJ/dJ6RvNvDqo1wtju0JPrLAf5PlUrgcee6hodBmOzhx2LX3YEHRmlTwbYoiqXmTBHCzl+bw5w1NGVkpAcyLQDFczMqR9I4x4WCgN7PuGZ7Tn1sZbHecSA8z3PnUUM5nvuozQwuS44X7Lh9064tsP1GFxNcDng+gEu2b4YdQFcQ+EaD9dyuP4M1364+qNPNLdBJrdOSOOI2breqjXNcE3w4z7lHEEjcu5MFddV9gB6MtM4MifWFmtCZ4QPLAz6MksP+TIThfPSj5d9mc17GXkXjvmER5r6Uej80gew+tqEoIQe5F+wDJ5fwtNQeA6KgXVAFN6Xes8vXR0Dbq7rzn8TQ0+kPvWQ533shatjytkuy//X1nfTv61vbai+u2qure/mf1lfv39b3+xQfS/9qr4B/7K+H3r+XX2pofoaX7m2vgveINftyv2sk5nCpDwAfATGS4s8tdi86PwU1VtT1K2HpvT7DHdggY/WAy5tGnKeU95yXqG6G54tmMJ9hnGDMabkBR6eyOCJvJM/agsIZ1tLQGpXA+8jCYLE0pU0r2ckSAG7zRxRfsaC7AAzaQXm7+8x2vRWVl+zAuSHKRtAvkkOyQ8jqOesmiVXp9JBfig5kr9ERowtqFF7BzghDaxlwbhoyJsJvLw0+nc8UaqbEYPkREaAYxLZiKfMXidG/IwjdwvdAfUReelff9eP5Y2wKs+230JPxs2g/r8NIf/f30iXeJQjq0VD6Jxe6+sxfzAehSjMD8UeEIXp/1PsAVE47fkjsQfmul76j2MPzEO95kvXxh7QNG+1BzVAT9nlmw51vbRmAo5eGbdpYULVZR3Q7pKfeBmMTT9R8x+Oi9PfOy7ve/63cSn4g+MS91/FZPj45f8mTocoFF3u3x3/Y//O9PyR/s1x1Ur/TRwSzSv/Xf/cvt7+ne353/pX8gf7lyH9N3FIZv6X/Vt7uX8P/o/9Y/5g/z4I/Kf9c0HfuFev7Z8JbWswykqirOxoJzdlbZHsIfNDZeLz2jKxWms6cvU6M8f1euDfrTN+79WxVXvjeJym0nTsi1frvG1Co3hlX+EjmvPq5Zw5rvd+5TN/juvtkM/8+c8Gz76UU7laEngJT4zsKc9oj6gPq+inD6/Q56srjKVR7szwGFdZdFzrGn24mDGRSVIf5A6odNOIvJbbqdi+RYzLlD87x7XcX22O6yguRUt/lj6d41oEeX066ks32/eVonf5qJPGbHndidIAlas5N8tdpPbLmqBt9zVnQHbRMyDoYXKO603/T3zuq1fOfmxqxGhnKlE7kSObSH88T21CzxdbxD6mvsnszQNcklLhGEei3H1A1tzr6+JHEoVbw0S5o+XlZs7RT2SHyOES+ULPpouMfnhi9T1QR9k9JCBc5zsuntEYiCA8GtRSuDMoBsjrOPdRBuV0WUL4KetSuY1JHGr7fGBtjnapPA++5JLKHHXIxjvrddR5os0q2quiBT7aQMUpotxKOeM2KEcS+d+azHHW2db+RO5Wy7ud/TYNLtsrKrXaYkafkBgQvvOCtE0teK6n7X0+kEnUFqOv7OPiYUYWag9tWl8M0X+OPNmYu6QP9OCYl2t4p4nRJ9M3Wr2p9KRihC/YGw3tTckSxpDnCNbCGLIdqURWy7nVKuAxvDqYR/jGTm9HJ8finAjqf/p+xuj1DwZr+857vFMGz7j6N84zsuLzrFxbrAW4N3mbSmUuv5wzsg7NSIXzvtK0FuXIgQ7FyIEnGX1iYuQZNlG/usoeYYw5oTCqT8q0a4HTDSeMXkehtXmDsdlkied5eWInz2ov8HLtj/y7ADfyD6c/ZxIPxXPuuIimUtbNhn/Y9JRZfZJNHZQ9i9pUvuqdRpgqF8gWutXaYj1ANMmrX60xZjupfwKPbjXnHiQfnD2CoIeZGOBZWLhEHnsG2NFnqisjEvEwQWSj0achwzKV+93a8I/dWpbxRIqMJ7xH62Hd+93qyLwf2LB4tzra/INalvVDmPw7ZxLtg9J7ZumYUuSycHYHx+sWL47+E3D9mT+zNMjTl5E4Gmnnh8CP9PzTMPo279kgxpV9y2fZauzhpXGPlpsjHXGry80RjgoxiSk3y51xurihZXFK5xDbT/CeyEfqunm0+P5IjefVj85TTw5agaubP2xiuvqXIKVgDLGtMoztegRlADd/5dl3Eo2VnoX+LyXB3XMzYYaj/opJGjEoM6gFtY9BHdYvMVlpJWy6OuWiU31D2fWocfvRmUF1vmtGGFrXJJqajyEEHJv4QmbWn/Ka+tkjsrJuNx3R/8DKPTzO2z839tkP86ZCBW3gnsYbPZyYNH9gHvoeWOthQS6zwV2FF0fF6WEP4GmSMaU6j/qi4ryalblYmZbgeXAJZJbDMPKuy5B0OrkbGf0381Qia2TTNMYeJ6Ol3qfWFgbnR9andHcCPdxm/rK1TG6TVyQcYPRKMXeieqfMLWXI3NGKOJEdhudbij1TpohOddVkCzMccOCGxMQo9+3MFnFmQQA4n73iTJPWwIIcX9uqTXzKrDw1zPhcK+5AsMNxpyzKDiVNjCHKPVMtP2XKy4Qa+3nklXKbGTAileBpu8ocC8jueNrC6WEMU9rVVc+bc51cOmpXuQbUruLuFWLONAkla6QDzHUJeVtEUwlC+EMPtFEySFRpMgl7I9avGS04r7Rxpf4fPRjlYwQ9KR4hMfpBolwTJ8q1W80aJ45Ut5PR/zCPu2rcqPfc9eiTsYdaJHbzu3f1VeM4Bs98RRKmK/YhJ8WfAVDru4Haltda0Dr5M3EpwRPlkkAo1bJRKhkPVLI6x7A0LES18OSXHuieJnIZibPNtumI/B112sIpsURw/p0f/npQlg2dj5msIA6xQBZNYqHXd3tYEqFUHL+JjozHh9/3bNNdTUzKidZVyelkVYrqRCJ99kzAZkeNXhefToI5GwNaOzsh1iVx3U4paWETY/ya2jcqumJhFlwIyBJk7Zh28tdCjbQWz1vMXRKXg7CtgTHoQ7bBTF5G0AsZ8g4yqsmOgb7rCK4c6NOGA9qM/tTnuP7yBso5HInInyJqxkvCJal62W95JgERLyRjvnVZpj4DOXcLb1GZVb5pl9nUPODkh4OfbJraLT3Ajnuyqc481CHfJAUlrV/JCrGle0p+5KM+mx0svxLLbzUroDxjFB3seHlZF2+ittHAn+1nruNE+aq1ZEf8JjKATL1UtgL70yD20UjCO9JJUcPCiiqT29ht++KZbZ+LXLnarWZPgET7QY6pTG2HkiVHoLS9q2yN4mROt3RfWllIj63HmnCNhvUYZLtMW6a9XByljSjdbWadnKkkh7F18SU58tLrfkdixHWuisgflmczw+ev2CampcZkN3QVrlovpk/bJiaaZBXbRK2JrYhyz1PLunbfh5Qma+gAsjbxVksmuUvY5ctKWGXkiOJkcLemEHWwz2SSpYKhZ7RejV7QsteSRSXobwJPXVf0wLpteMAhL21XdaOmK3xCXgF8iyYRS0wmGbUN4pkCSdD3TIN7SRjWs1PcaGoQU6aPz1a5n2DXi08UbMY42/Acf6N7johnTBn7YrI379sLI5UyJiY7yv0NG3VxlC6D7C0JCJ94tLp1hElEm4zbJdyZfsOJ5TbDO8o6KKfFUlHeDQBXg1N5MPrTPg3R7+0EeoE0Y684w4R0aAv8ftmp1E//Qc6qHKlPjbB3dKrZzbCKrzNHORj9ZuCtUObG/euB7Cz4LgPhu0yG73IXwX4vF5fzbFIP/zbwXF9/31f973zIZTS/Z+PIrfYRJBLqOSehrw6M8Dbf9eLhDMSunHXk6cZMG1veh2wllWS5MNZzCijZ3YdUbrUi+phsf3Rb9LHoNlwjcU6Fu5OYiVsk4XMpDePbH4gl8o9fo/ySLsQvaW1xVt3Dg1co63H+qeufDM3E2CqMSMReN7QMI+G96ckgkZS3RL/+CqKCGZg0niP64iF077FG6uFx72muyyqi1/yMl3vn3Dk652S9ep2sJ8kzjaZEFSkn810pImLFDY7bSPQnHIx+9CfR7z0bkiCGAyczRVSP5+qjP7qX7BK1R1Xvp5UUk+iPVO+p9yHVMJaE7wP+hXJh2yhHpqX3L4mGsg3iyKNe28KWRKKiuyRZktemt/qsrDbozz0YZcHrjLd24Xqas5VsBXx3iExihfnpRhWJJBmfMefXxySTz8XS6gLiFz4JnBI5hi1fLqzqif5EdhW0MMbq4Lk3WR2uDU9LlS3wTUzr7ZgaIEV/TEvTHT8shWWDJR+ScGyjPAhjQPjFExxhpNmv8dKPjB6pnbzkX+l1eoRtftTrzHO9JvXqdfBcdwzVSK5fyLjTWSoFIfft742zLk1ev0zWwAEESmb8m3Nc08U5rqVw3SYOBKlmjmuJqCLaa70RK9EbcV9op0yy2gRhfM/V3ohNUPvgnnDqjfiVu3aci2ReWKYdSs9nTp7jYg6jD+Lgac2r/ef+uzmAO2BKcrvITd1v1z96nU0yRjv1qyVjpHO7mGTCyBnBdahdaqQ7+KiBm0DO8WJIdlN5M+xAsa3yFZJevlJL4yjieSNZPUfkIjc0wzSIWk7sFTmtdSmjNyX6Bac/FIl+8qdNa0YDD3YdSBdq3PnNpJ7Du9Hfip1JNhHsDcgpIZ602s4aOOcI6jviE+lnXmb40flDE9Y6Amp9xc9SuQvolvdHnk3+mse5c754s33wo4Ns0sihzsGrpZGcQ5MW/4j6TAS5yANnqpVG9jji07r44Noa1RHsrV1S23FmBVOVUjvPpX1LuYpLfEkzMyK2FVaZ+xh9LPmsSUEGZ2UCDH3ISIBioT/4zmop+Pu0lGE3QA90sMpWwYpckhmXg3YZEaWWUgVg/viWPBued9alYlQZilt6Y2LmUr9ws7+m9M5SfMbWKdwZDMpjkjAV+KLzIcsRzihf8f3JYBkm0UA6+JDGYj9AGl5GNgPVkgSjxImRDZnAI0iCCUZ2k31XiF5VAT1FGVT+scm6wqovTVt5I3BBQY1B0Nelgfq6BAoElMPtyBG5YpYQq3JlmRhZrSxSPlAmxlW/X1Qmaq1lYlJ10Nvl+wH0dmlEb5cF/9ySzfowtDR+5d+oP0QJ+CQ1Qenvex9Lx+tSYNYh5BQ7fNxB6LVaJaqjgljxGa5qbwbjRzP6d5oMiTYYpXof5rzvuwlPnDAszHQZyPaRmZLwsAQ8c8sXYiTbP8TBBWfHGJvettsc/hm+t4/WNJrWtBHu9SvSgHIZyGzXTPSe5VRbGD3ys3hGco7r2Z4vYHVKoaWX+77ilwNfpamUMTHNLOWHJosZk3rpwEPeXjrgmlpJ7s2XW59oVB6IS4M+DM+yqk3RhN0WEHbQWOkoRS3O3SBmFrRB/W2dkXD10TOJd+brF7d1hrNjSFunurSts38u536J5dwlTFvnoAfaxNoCQcjyzsmfY9EvDuogZlvaxMMFUe64cEa/FNK47zgD3k65HbUA3YKDRgQ+B3c90tT8NvGcST+0TVSntomRa7muTbBGr/ChzmrC2qDOCuNPm+CpgW0Tk6a1iekr2sSMaVxXNfCeG7CurqMl3YJXupmWC+q92sSyxDZxUyqeqUPsSQeYGlmu6/SjjB41XjiWIbjE/dNQ88U9KQkHPagBux5jTk/bDRiDGq+21I1w1yZ+Ny2VzMKo6NNmu/L9XNe5+3DN3Eg1X9xlzdcdBNcHrstxH65LQ6AmF0B+CSAWAWIGIL7OP5DmDsjXW5PSFlrZqjYxc3qbmA1XLlwFYziQDQLCz/DtVCG9WeaLMWrtCyoG94rKX7gS39AA+cjrOuBCfRrqvFDHdf+LvTHXXVPnUA0YM3x2/j+sjzeutyqK4ugZ6W99d+TXWMfBdxlw+/DF6Am9W0iV2jp1t0/Lr1ncJpYXcO5KOdf10cphWikxrmR2CcYD9zhxvD+G8R4i5UIP4mGkK1O5rtfvhLG9j0lOsCasWLDiuRXqtN1m0YlfURP6ihMxbvcNgBmKNvG1RW1iG+DOB4u4rjeskvAC7jl0vWPtFuKkdFqu9ytqktvEuLG9X3EUfMVMZZRbE8IsWNm6Piweif7KwmbA/GwTJywOajEl4cMe1GDqobaSxb3fcubYx+m3vH/xCPotSxfPdi3yQX8W/ist5u1BLWbX+wvXB7/pwrzuzEwm8d1OhkWLik1jgcOB3yfH9uo3fx0bPK4m+H2Ov/jPOt2b4LvQmIvA6W8imxvXlyH1Ql2XQTXfFQn0izHJyqtsmTB2pvyaO3HvE76SckLaWvLNnfqFXNf2R28g74sZ1UpY+U1EuS9z7BaghILwWM+hKRedrB5mTCrnzlXKAMNSUplEE5nmeizAudPDGV1fUkDuEIYGWKJpKSCzhFqvkXwt2s4MvJVJLNAeFw0gm19/cg/JTJshqlOOiykvsKn97BrgCh7wZnVGDdeLySlZnWEv6sV+KVmiJoU7v7ZfVqfmbJaYskcvGiKzOlWz9WJs5Dui9ehX/DmgUbjPGr9+QDCeCNzPd+32Yx+VJNhHZvjndP6uhe+SzgLvSr9n5jRmB9dVWzLHle9BCsV1qWEuqe8ErNjWJsZOfxu+19vogxSwoS0P6ML0sFLAgunBOYXz6ZbpG8SCfhvEadNTbTjrn7FxXQNKUsnhHK4r7kGMSsUkom0yfvnXbgMprmvwCvRhxHUlrNgglkzH2g8CZBvG4P/INK6r8pEGjBKzjuvKWtkmbk+bBribeB/gA7SkmbFBrIRr8Ez4PoDZZn8NlFXfiP8jb5wGPdL8CeB+lev6FmNfBp6D/NqJWMNcwP4V/iqaTkpT7sOyjRO5rvnWY53K29U7AkKCh+tadB/6pIdWFyCHahK57tqFbWJ1n6/FmevaxD0LADfv3oz062aM2oHzQrmP605awXUtt24QGxdsEE8tAFp2AOgY/BoK8cysICwUizuVT66m7yn3zSUIz33Y7t1Ao30PQ75tEtazfwXXXVrSJs4qbBPnwWWF6y64lh2EWQa/jaH6xov3hN6hdXUfLsG6kMZ2C06Yb/8AmF2TRkAPz8Bb38F1Dq4fC8t0XDdMV+FBcfLFUjmr+37m5IsPy0cQ/H0EaNGGArx7VD75omEs3j0mx/+r6P/V8m9manSLhVnwbrlcuQ/ztsqn0Xe3w7uPF3xfMPlipRxH8/sCHE+ZB0eZ69pc0DvCS0I5Wy/nOGDMd864yTK0ZPLFf+iDtX0DWFhJIRFwvXsS70T99zODcUbmwkzsFhb4Jl9MSfsmLluUV6fk326tAeq/a0Zc2l6Yt1XTlPviSGQqjlW38LIEfR2TlI8l9hTUxL1cMI2828nertyH1mVBKPwAxYsFCNuVvJoemBe/ygvzoG10kBbtfzmo80d643opRs3h/IMLz4SgbfZrQJNeg3u0FyiFC/f5D9cE1xbco28L7UMhhz3bNelXcQ5nu8aH4hyij49QjBQSDTLeUFhbvge+pW/7DmqhKNsP0KWp8hUVyIONR7+FG1idos4Etd7TE9T6l4KsnGn7sMlgl9nKbHF2+erNZsZZkqMhXcDpZtqiSC1qPDKVNimlj8NgKxfHpNaYwz5LJNV0v1vbYnx4j9nQGk9SVphALig5EozzONv1rfhruL8+HISbxjulZZz/VOZYqMzXe/8T2eUx+3ZxlAmll1555R/XyCsXQvIKzGSJyislkr5MHGnS0v0pzRF1cz61eY43ypwuE8or6iMqkGFcJpRhBlFtVtDa5D7g3NFO2tvCuF2KzcDFU09FQT8P2oBwISAHDvtOW9/Svi5/dB/ql0IS3pa+FM8xRaVy250g7UFJTWUO+lDCXNZ2mw2kI01jDmO45LzC82ONyPHXSJ1B3+FZVY2DGxi9Qpw3UUUc8CbWI4dvF28z4jkDNwiAhkccg+vQlp4VrROj3Da1FqMThElCmaQWTXu1ZDKMwZ6AktgORR/LJr36CxUjb8OIEbqyLeKdJjNJI3ENqL3Yf432InHTi6W7SwaVqdxqTgtf752ewy2qrrKH0G8+6i8mE8yV+yLPfCWKlz3lcySjRVw6OMSD01jM65VW5QqWlImjylXuSyAzhEtfiZdMemv0MUKi3weY3v+reCmTwvU+wjWmbApByKKPcelXw5wkyoz9InUlzTyeOpeEKOkTnmmNgDUPdZizXfMO41ef5dorXYtns1y7WoN4hrFL5aWbzbITQ+zs+JNNaBU5iHh51AYENQHjr9IECALbc4kPSmlYs7ykb4s8d66rVkLfNKh1Qb3Atc92S2g3is9a6f4a9VWQaCy9Lf7Dps1m5Uk2dUS2FiSG42Iq+YVH60381qgtrGlkkuatiCKTh7K1AwnqlUbQMxUdKE2bdPtispOpxWaUW8HIxfW32ITjPcqEQe2HyQskTmTn4kmUkWS9yJarz3Ms2gHW+a+ckPr5NOZ85cf/baKefhe0w454OCK7HloeQOatUBBFalgtei9JJfhbDS0nmVJKRkLbbGKUe3io3coeVcL17Yk63AlZJMz0a5PHkChoE20mP/dgm2MHM6PwVBbmbBHfskfnMbqhoswUPr69aYCx34lEtErNinGx8kjnyLrwbJlYOwEk4ZIlNArTJ34DMTa6jrBjtpu/dV6EbxzGZDKaZraUI2F2dtyHTfj1h0isSZuN2gfUTLgkeeloo9IhqxutZ0EqwzHWib2aBwXZhDsCIxY71ADxO342Y7XBemL00ES6D6CR8P+ntAa50/hwBOCGcQWeUWN0CvdGpcKtUM9ZMZlaNXkC+P89SZ+Hv98GUAa1CX/yccTQwl62kFRQC0l8ckDkyA5xownrWi8+od3TonA/oQ6+NeE336qAtxCmrRK28meJSVG0Yy1rjYbW5a5ImI+9kahYToTxmfZVcA7Mcp36i9A8DDhegByoxrUxS/cEY5amK5zxa6QUmXPeGvRw888xSxXuM4woTPUrgENWuKs5JvlVjFk6QbtUbZ/tGhpIpjFLOXc8q6V2ft2C4P2JN4Ts/PZf1k++AfNgsdAkBu3Y8DtsbNTny8rxFBbj/n/MfQtYVNX2+DkzZ4ZheDgKKvnAYQZwZNQGMSUfyUOPMFigoOKjGl+Jj4qyB1EpPirT/F0SzVeWZiVIKmh2pTSsqGu3uA1FXRUpy64TKXgGxXPmef5r7TMzoGl2v//v/31/vu8wZ52zz95r77322mvtvfZaKhX9sLws1ETFyQ4wm/O556FlHXyxU4uRrCjiSW3la13iWPXMwl2uJWzZb0oKd6smeCnDxabuWd1JrKm6Fv1diYFIUzL9DO4DB+ghT4HeAvLfZDf62VChjgKy0BMjQCOZZmC/DsSg8sedmnFSfRu/Vzmdfq9uE7dmFrfJ8+mOTtuIWdxs0hK/rurVxV6CI7zi7evOJj7ERwnXnyX021WMf/v6dMwf0p0k6U5dd+Zwga8U6cnfyROb+GdRVkkMvY7Ip/5WhXHmw0Da8PKPOSjD3U2MXSUzop1CaG+yL9aTlX+O+2IJLN/A2E8ErxG+LskAibmHiLYTBrW2aaE5HOaxBaA3ZLCgDXJzPIx9fvC8LPRWHVKWwTJ2C3r6VDcK5Zp6wbRLXpbPPU18/I8SJVog68p/k2KaSXYyeVmQWsuUgcQzavFH+dwOTz53GK4tnmwzHZPPHfJInt83lFge8cd2hPT2QnWP6onQM/9wK0otj3TwK71+z+899DNBU+vgLd6ULP1COWhyu0ygIexSktiO5ZoMwHwC8NOjTQCZKGOTlYbxPFQL2njhGqFupcgPQD/o0D6/yUHaTjSZ1WW4M3wn0NyvMUyHE6T531Y2Csk96ltCkvM5JdSQ6RCeEfmx0FLrpah2HZpl5PTXjvoWVbKqEik9A1reCtQrXnvuoIGNWdzBr/JKNhLS6vzdbKOQI3Pzg90arqTb54dgjDZ08Mu9Jw6Vp0Uir6Ao7QO2Dv5J7ygW7TK9/FcC9fu5wjz0pE5NBt6B6x01zdI4QHsb1BvxrOzh39Wqmovq62La2bx/he6j3FJMuz+X5/4s3i2l30x8IKl9PpBMpg3CsID/oyQTSmiUYfmf+D9SE/9HSdBTBdbvha/hd7HPAxJAlJvf4Cxhpbu/Oxl7ThB6QUKOuxXmr/FNPSo1ZSp997JBWd0CEZiaAZs/RmCK3L+gRaMPs48JVh4w6Aax8vJ6IapU/lo+dzfQw4Dm44A7eijUkHf53FAXib8IUtswKPthKC3s+ti5r6WzGH0hnytzST7qOvihJP5ijLPTg1JPnwelWdxcl6gvs2Xsvm1sxfQNVcr+ytKZWSuXBvliKyr3q7bkc5+Q+BTJvrFGztGs/mO85FDAlGvKuhd46/S9SyfCmPvZlc854Gp2TTTfDfgKLowluMJ63R5H0Eo2ojoF8Ax3WQo6+C/dX/r3OEoxlmAHX+6+m+xx7J0v80VczOdehZp/CCPpFWUSjHOrJniTCfANs8cGq8tCAOMCF3KNtSo8o04Z9li3kbFTIo0d+ynA9h/Aq7Y1gc44Hb7PuR+wXQeYvgXXi64BZuRCu10YHbJReIXy8weribFvVaxkKeO7Dfi8g3/c/a8Atrib3wHzSHcYz1uBM5wsqYOcpcivVg1iPcKF4+oBMq5mwbh68FMptivqPzim8Fy547xahboOnh2XYhVonu/q5ctP4UMT8UwTZVh0WwofmkgZpwCFNwKFTw1QeCPQVj/HSla6Yx1h9lA19KNqnUBRuGcyEtpncNOkg9mVz1qyr65apjzwkUWj02eNtlBxxwGXkRb0qKkof9Jy1+OK15B+87kGR3laD6DnBFPfw/BfW3loe1r0aXVlhPOFK4qKqGfcvNIh+Uq+fBap9jsXUu0XXfx+hUFtcRdODfSgdIr6cps/5sDdqK2+m8WmQDv2BkprOdNsM92epv/L+fhrhy+OXPbnxJ/pRnYHlPciaNxCNcZcO6cPKcvMCi7Tr8UoHVKMDiou+KDyQBjxFKrcIkW9lvtaJANapNO36WgzYj8f2uDUmQlkxtokvGmS6+RckNzv2xTGvwN9m+KbPTWbSJyOTCt6nt6lRc/T6T6voLuh1x4U/J6n60mMjkYSo4PRpxBc8rlgyKn5bC2J0bGHeDOVYnTIK7Qr3HyKgDE6qgCyAHQ35LWved4KylhnZez9g+euaDm0Lu3j02iz87RDC2WWQKp4wd9/m2zZxOvofTte9Mewe20Wezfpn4mOv9kw1gbG38CYfG9VhbFBxDdsPncONPxz1epKVdmD+uAyXYU2K6jMuDZGKBmL3k+DDjDvaXTycua1eiGyaoMQVSXflM+9I+RP6GzFnmbkfZ8AJk1ndCQyX2XRsup9RZLX1GCfbaaLt4qSz1T72Z9tRoJrAom3RzykbsolFj75nF04ayvfG6FCXyt/xhtfqHoxsHt7H3CLZY58bj1cjzruMCdCPuscJawpsHu7l+zermR7V/cAqtotIGeb7URfuJ28zQTcYpSzrqU7q84aOF8/x7+DS1aw0/O5ATXIJ/znJ4f44sCjHHgrPOnxa9Pk1ogiSqBHO9AKpSDoSHo17kShtwKyExUj8pd8KxddI85d8kWc+6hmzyJ/1DmTuzPqnIFEndMQH3mNN0SdO+eLOid5YMZ1JyqOOYy59azGuDt9rXsK0Dohq7pPweiC7WmKBow4Vy3iO7UV6NIeRSX53snIuz3iJLaZ+GgW+fdEv49mHm1DQTa/pJFV9GZTBSaM1gV3fGDZSs5unxbeX/BA9eGCiOrDi4w1tF5pVyl6XpT3HNIwoqDddlo4qvDvXq6COSjPGmZXhShYpSVEUDw8QVA9OpNlYhSApcjPFvFebddS/xSiLBsEuQW9IE9mg9vfzxH5d1xQ0l3/FCjTl8L77xjZUWy6oMoOshuURgvTsWYZnlXujxLvsENpRpB4e6xNKNkkqBLTq3+J2iioYu5MYGrldjFpDTxbIxwrAXmV8vLvA60GNSlh5jiVQmnrhLMwf5yjiN+dvz3KySiH7eFrRM5Kpzq25NK6PoUM+32VVSiRdfDbgDsxHW8XzuCecjWSJwMdjH2w/ITAJD6TyXQsKAT9UMATnNP4OueTZrRcNLJPZMq0s3iZ18BOJRSGMW1F3u1SRCshXZUTUy01G9nfbUszu5V7+Z2g6Y8xpZOY8NP4XeT9Q/D+jK0b6P5Mx/inMIrdWNrEziz08kVEKx0poL6saNgkaJIiQGNeA794rwdNl2nvftdqobueqTCwC/mTbkMN0+X0oD+VgcU0qPMu5Ps4FNGfNN2pxwgp6JGwm+kanyZgSotRdhoj3x2ypRNcJxJcl9RM4ycRPO8x350JeMuxxi97sAarCdZUPGLMdOgKHyjElcBNwtpheuJ1ZrXw8tyBMUz7y9qF/DBHVRrdtJAfJYTZ76EGZ+8Xxljc/Al3N+DX91k6+B+dW4DW4R1tZqWdhscc2Ip6aJ2+pJWzPVk2puN8gRTn5hXoC9kZI9vPfNm2SegzHLi+RT+euVY+dbXQdz7T3md8pEA/ek811pOBMrpZPPy/3VdBex5dxOxLxTgZXimHUPO/bHex/W3bqiNU5dXSmb7v4JeHa8ihCFUYXHlwbVtAaYvgtwyuA3Alg5Y3jf/YQcXQFhyZOdwIwJhpkqydRP6rj6fxBx0MUApD8L/sNrDJoLfX+84irzgy+F70jZhVbTQbSYoffXHm0Vowtf1kzgL+a4FhNdWJoE3c5xxsGVOjM8eQlF+6cUWixYbrMx+JDFBlf7OelWnvyJzFf+S+Pjr8DzZZ+Rz+Y5GukJXfy832prYXLpOX0RVFelk5XTaH/1zUVoebQ0i+O+HbUDN66WdMS/nHvWjb9IF1fJqeVZm/AVlrbZc48RgTXnE4QtUHro47Q1QjDt+ap/6/fo42D8wBjHU5vgAjdgYR//UYr/PhGilSZwc/QZD81ws866HjxhP/9cmswP/HI1kw3Dp6ppzEs6sX0Zqzl0Py4R7lwtiZyEvQ1r7KtJbsE3wPGmS+FfUcanM6O5jEXMvnnhCU0TEgZxcFG9fuF0JNGZBPu2CpkZOoaxmAQ7qnnEStacWYa8qQc9FZSqIPqSojWpQU9rLFrYy+cMbEEov41XuWzqsZVLS4qG9o6u+ymL7MHelacqb+US5Yeck2YJ508oLSqiqpmHktDC0DigdJHnjkRpcyuumMsWhRkZZN/52GmWy1+B3I0qFKq02aHzHW15CWKxMZdkU87rfRA6mOfxTAqB6B1jF9lHm1uFMM11PwbJqWHcS6+CBPqaAgEQjV1lJBSXz9MFa0M/byz7qiqhtY+p7mBjFuySHK2K9Zit7V6qb0om71Y/64BItZunIQjP2jFow3ih6GGoU6RZBvhZv4g30J83U04H79dO6o96rt/SMRql0AvQu4367/Wr3YfyN8Hv+TnTfrv92uP/bfdG6T+Mf+63Fd/81zS/0Xdsv+K3H97/TfIedf6b9l6HPDnqE8Adz9uFhEaqz3pEPrK1j1Wcti1AeGxLhAJ9dC/SK8uGui9Z1EoAy89fdDlH5ojGWxi38X9Ac8t4KnV/x9hLPSXOih89BDobT//MlZKH/VB+gf6c/7YRD0wzX+cVGKQfuDfxyBXPI56YdepCfOeHBd6XCJvy/m+friX94qO6XOC/RGFPTGNT5LLKhRBnoD4xpMbJBiQkJ/qMeew3WsjF0q6JPgMqRSY8N07i73dO5euBLdk8yTIedJJIrhc9bOGIbEN4a6RzWbMRP0f3mppeAq38/jj6i5kqxkXeVdbpkUwdA8FjRsFdGutf2nc79gdD314TM5rKSl3LzPC7DP1djneHYN+z3SlI/8nnyd0BTWsba4e6X6YLcys3D1+X/qNWWxWeG44hUcXjmZNRWpy+qFwaUbBFOpi3c6MiZ0a15WdLH6MZDjX76yLS3qdNL4yexWkOMvgRaDMdrtqAGou9LPQHE/0o96H2rU6r02f3xPEtlzSzpL68Ir8qF9RCditOXMOZu0v+OPCYhrpaV7cQ/GKlw1fUDif4CSYVxiLROGavsWiAmCVdTTvrgv9CYvv9yBu0+iUQMyzbCY4mqMtT4sRk5SaExySPEwpNBACtoKbxIhVeIGkBVnAf3e02xgFwE1/0dAH2IjrVT8ucVAZSBhhlmu8h+4UUoEmFpSDdJAe3D31ULwnDB7GOh53zgiM6W7Dx3GIiPILQ8ULuonPfnEIVH5ToECelVY6Er5PpDXQY495K1KY86cW6z0UfkIGCk4i0znityCLX83noOQfAUt/ws8qNKNtH/Vg7TP82aHn/bXV0nRd2QbkfZfcSPtb0baV1KbR7NZQPsm6IEcD/RA8HSkfRXSfqQpBXKr9xTUKID2hwG3Ffho0OrNDZh7XwfQfnDKuTFI+6US7deQCJ7Tub87p3PfwHXYOdyciaPKibT/QID2cbQA7QdLMWWHAP3/4pDo/3VX14iyGUD/z7qA9jPjQOpO2aWfowaOJ2lg07k5SDHBVWcyfHv4Nx8BC3AEBF+yRROupwGup/ZxPbqMIdFlR7Oybcj9BKgT5vjDdfxvgvgvpN/gr5B+g0/abowhe7s++dmFfZLgkfiRxnXzPtnnunmfvOi+WZ/Ir+uTPIfUJ17+Z+et+6TVMZ1TQJ+0OKQ+YW7bJ1G+PvnWeWOfVDtv1SdbHP+7feIFHfT2fYLrAv4+wT0T9AH3elVmkQLkgJFufZGSTaqeVxRrjgUpdCY/Uww+N6+gT9Hjh+cVaTOpjTLtAPNMPltMUiY1UrH9M/cLmpQwew9qg9AjxcPXC2jBouh4PefibOjblFlpuGqE4znUxOyTVyaywGv4XqI8OvxMN3MoKWGQ2I/I2IKucjadVJmnNs8rOmFTmxnyto942aYy435fbaUk63rhd/V7EaoNcKXC9Tlc3Hu3p63DTqQttwtp6xo/TfTT1gagLRHtNtVIYa+yvtjRu0R+sRPp7OUSZSWhtLIJQGejWaS0yaBVknlP5Y8gjZT2LxfGF/dT2gCBMrANWJZWxPjiY86NyHpnKXDzUU9+NJ07JkznGuE6KtxpHgQ5fidI8cVvoDCFRGGGjBmcTZQobLdDfl3kXgPQ2AoH0NgErY/GQrvQ2ALQzd4/Y2DDfBSGMccDc52iHagqEEtaGxqgK4WPrjJ9ks5PHkX02TPSl1kiehYLVTSS+OINthtj0hYeOQEtGs4WYCxIBxWHJ8/QQmq/QOXg+TM5aJLBxK/LTN7oTSF9j/ZYvxB7LIX5P3ly8q6/l7M9WC71+bZy5O1DzAz7WVU46FbGzJl8mBdp7fxsyphuNWSjJRVcU+RJ4/r2Hta9yBNVkdajuerRCIHu6+Q13hOH1qZdaRg8PrX9vD7aDF9t7kNK+d0Te05W7uZ/F5T2KPoBXUJ5Hn9U2CnsNVU96o/puteUwF7sjbsVTv6iB9cm3sqR7UNK/smLtQkxB5G86jzpVdxxqYwgUgbGxI09INWhf6soZsH9FrhOHrg9vc5yIL2+7ZTo9Zrn5rzQ5Lg5L6ScN+OFzzs7eSHP/8sr8cJr/D88t+KF07iF4jRuBVzzROSF07jl4p/zwhncRq9EqZMEP6UG+XihUbg5L5zGdRf/d3khz8/x3J4Xoj90P+1ayyRbs3B2bZWCzSrS+zjgafeygtcLyoQtJtoYVUvF/nootZ3XRQw21EbEVsye16/p0Pq05NoQtjJPcZFRQd8PXFakEoJM6LmF7HHRok7RUZ6D+GJMBuznx4rklcw+Py8MOqM2B5Oy9rglG4co+F5ppjZJI2Gr+wrQkWG/REeL4Hc3XOqihOqsIrlZSvPiMZHfVXvBl0ZzhNK9WCVZzKPFIoyb2SjxddUfZPvoSqpjPYzJRkLFKh8Oc9zKKs1xtG/EMclkMmZ8Oo3g8LlvPLrLcc0lq0Bd1LdoUhGVEIlnGjlaDl/JqBgFuzLPVa1n0W8cfpvsntddcXG1XN6xJpfWMdwAWuak7X0KdL/Tsj6WGBKDt49DrgxtxBMS0orNG7V6VuGrW5T7ki35+E97pbJ1hBdASUpKf2/R6qnditCDxcFqndnI6kh6yo3Yn5+dVSNpt5cEuVIOeSMFPU7iG2YV9C2OqDGyvc3/seH/SPLdr65uxGc62lJILYVtNIjYbEKLFYr8Zac8mj4Tav6nLdQ35v/povV7pn4BbXPwClUS3Xfqv96jKGrj+xKu38BvCMik0+F6hfhbTS8AWTk2qzqK3VGQI6iWRFTTw3n+M3cSe9UWWY1a8TxP4fHkI+FZcuJlA7mDKUm2YPUChlj9oV8jN/+mE+9PibhPeYX/mjzb5tSSNS2018cYgmdtGM3utE040luy0u9YU+ji3/Yy9gyKxCbU/bxEw4pxL1eHsLTdoMwVmL4DisU7o2ujLFGP9X9cbg+VR9XSw94AvnnJ1qeasSeDdJ7vYbL0Fi3wgY+9WhZ9DZNzAq8izQVBOXj+I93yG1D2Z4CdhXLxu51odSGdM8CzaL8H/HiiPdk8vp8o+cFiqCvoHwvyiCV54DkrfPOE7zsu8N0l8h11/XfwfB15ftXbafcxizy56JVS5hBPW/mQ063bdyhpy8sOA/HzK7VvP/KsxSG1b+NbN7ZvFGnffkknhK2JFFkz+UZsFN6fSsW/UF1ZcGeBvhrX4ekRXv5NF3qKVdijCLTVNZZttUVXMx0fWLz8LldQlnTe4evCaVw3wPkqP8AltXGU3w8qvPsi0A6fkto9J9UO3vjboZQ8L/xDrcVLUVkjj2Ct5Rap3gyLNce6HvLiusT3ZF/8Pa9U713eMNLXHv5L1/WeUW48HX2VL3RofecG0XcS+lDCkr8gJX9mW3bkDl+/rrZYhUtUcrWsgtalCsy9FKl7povSNYLGCvQYk1sNuqqlf4E4VG6lh0U9tloYqjGyVwgFcpSHf9IpaYPboJYMeq0eN40r8kgRO9Hm2O8vti7QTidIe/zm6fS3Jj0vIs/Pev6bdor24nyZRMZflK+dQn3tdI0f6LxdO50V/O2EvnjQJ0/XduqKb+l/hde3Huynp914/7VHwuuEx99/S9y3w6s0gBf60EFfOrfCa/x/hdeLHmyXN8l4KvHh9YTH315ljtvhNT6AF/qeQh9Ut8JLcP83eI0ieGURvIb78DIE8Bp3G7yu8ILoxwt9Rv32J3i9dxO8ko8koL0iyqxs36KIapXpPk7hwb2uK3y1i9LjThda4KvIqXyUN/FukohW/Hjn8jId2+DOxS8WcHYS+Xe9DJnLXxRR1hb5EfD7yALmWgHwfJOAM6wCz3PAm7u90vmQPR6m42eLgw8TpT2eVIC3Fnr4GS4cX07+SVHid3i+RqrP21L/+3z0WVup4qttC4vtbRpn9A9vtmoA+geBep99szUsAGka32wNCUCy5hL4TnnuzdagwLOOxsKJVK0orlgBl0idWzERrn/gevCQVtl6qmPr1L9VGdiqtpR107hBjp+E90vlbMbhsMqQMkYfWhafpS4LL49q04yi4lMEw9gwu0GlPFgvRJUEvbZB0FrkW0S+QtzZyqincVuE8Pc0ulghNkxeHgNz2M9CVVro2W5Vxy/J1uNacKQZ/UBP41ygu11pqrd1z1KUodTwMnyvgO+fFsIrNLoYwQTfT+M+hVTnApZM9S3UQsk3UiqLeQxxfGuzwFjC+Cf1X389Fs9LmI7guY6dVZ/N7mFkWPMp1HpfmL0z7ZVaKo6OUxdlgSyVah1iHgKyxQz+dfHN1sFqEkdexJT47VuzqY3nZw8kXjhn8OvFuw6jFkTF/SdPj7p4jk8Xz3HzQQ6UfvCZk89yi3rUW17P8WviGPU5DL2mgPzZ90xPc3eS3zyxP9A0HVdjMxf0KFbXaMw1Ng3R1WbwUwGbbuqfWrsVU0OiaqvaFqqrQQqSk3cTxV9sftmTok6mKXw6+nD4/XJfhAplV4oqHk9RzvEllZKcDVqfylulAak0rAj1RfQenVX0aRQ15O6GzIJXBUt30AeDBh3+7H7c6/hs6ipBGBde7uJ7Os/f/1jRfiHZFL4PaR3kWo3I9xHk0aFnGEGVk27+z9R0gpXb+2ZrGmm/097lkgcoSPvJ1I2CcCe1cVTmGDOmaoFUo9UXbZQeS4AyZZDKlJS5Om8EeX/ae85GDZnakH31p8czC8LLc/lyx06Yp58qQuoK3xcxPqx9W3eNLsweQ60W5kyeCxoyniOKH39+Nq4MvAa57heiTTuFb6DNE3Mwtp5Kj7Z9zS0aIqErz8mMvRuCybMeO5Rlqe2bFHNm1NTIKnpl5PNXXJbJeEKJIhrys7I9s+mkPXmv2eTG3xto8s1OYZKW0p+2yfapIX2c22YL9vXLs96fbYcPd/bLtcNSP4wEufTYzEjVI+9LtkGUjmGbq8Zn0tr7uMMuXFMNLl0CumWKOTUTY+x84kqBnKPcTOk4+I10K0rvgV+NG9o/Vw745kSMNv+ak9qeF4HrKL/AXX7ESDOeT0pt1+iBV03Dt5F61Qh8F6VP9L2zgnZSOBLfNer77cd3p/RG37vkdKWdUeG7MenK0l9ygAvmprCfCdSu2KyfZwy2fN5CjwKKnjGVOyMa2GC7KhjPpmOESLTkU9pziCVfn6z6ltBR52dQxkzQZWlhGneHMJXziD1hpE/josiqy3hroU+X/WWG0q5RO6vDM/K5O0WYC6HdeuD6Q3WE6uwDkSoG2izDEKlqiA9Rde8fotrcL0R1f68QleKOEGJLqvTZtASVFhaAXC4E+fTfh8j+xBW+UoB6DdsT9WXm7pzoeZ8JyVDPwsTQytCv5uSnsFO5/8Fxnv4ZaUt3OhWPtS7PPWGOtqS2H80FKgjCN8dyE1l8cyC3RIdvnpfjybYL5EzaBXJyDf8XyS9MvZA3l/e6pVNlW3Iu5EXqElm5aS5/1Y28ZOD4C3noA0HOiTLKmMKVr8RzaD/Ppg//kjdAy3Rcm8dcOyDzn8/dnuZsYDqmWphrp2BEbXeYYE6ZBRQQBqlOplK6PpY+j818bPtjqqRtaUIDpU9r1zwOM8pj4eW4gwHSpKDeF16BEdZHelCneh2k3B9g1DJnXja/TKg11hNm19GKrfm8wrVT0JmYjtXT+o2gjMOtSUVlH40uWv0R1ipSkJegpc2gBsW25zLC9+Xzvzp3CtmaeVFlMNIoI8V9snKncJ8pEmo0a2W/cifvFo87Jpko44l2duV+odCUwGJ6+VYvL3rk0SXtKSuXmBcRDM67k4oo41zraPh/T4OvtKqPoLSRAC0H7f5ZdSRwh0hBrUHrF+HOV9MSvrvfPIN8XefGvnhRoKpwVWqcFVJqcPS84pApezYCb6L0BMe+NaiLevnFXowwojbR+qRCzHWSeSLJZxdgIT88uuhKTdf69m7AtnuN8JYE9vxsYwmeS5Rv/Xm2l99B6vHoSii7ZLR5BMnleXeYXU8z0JoPQPvoTdgyW0sIjcymhqZwG0uAf25LhHE83nlcmG+6Au314MqdrZHFQ2B2udZGLR7ZFl8s03pglu7dVrquubVn8dNt7xans542W3E9zOIzYF7BGJ9U+2ignF8SkKZUHK2COpVcIOcW+2ZeyDtQGGZ/nBpa4uI/9kC7mRLZWWla1lji5Cmy02Mw0ay6MoHNYDcIg0AXCHJjXUJXhpn7nsM4Qj1hjH0ZF6Kq3CbxMRyDA+H3B1znqIpQZVRJY3N1lTTn1MHvOxL/d73Z+rbE/11MPBUTpTOwc/mnXAeWpbZvVWKdK1funrFTKDAteWKnsMhU+QQ1KIUbuFKuG8RugXbJcOyaHF6hhBY8Dhw/GVpw3NWFBxJY5bZSeFvhMD6LTx44cPFZjM0284DxOfyddmCd+QVS/jEXFbfWvCpzjRCbg/D7ruByBz8WuNX9ZI0rsmI8zGdJng8u0PrRhdivx4GT/5J37EJvY0YDUu6bXolyDU1ItzuFOZqdQrfE4EFxDTJjv1oZtF63xB47dGVIz1ndGf8aCzdAlg39oHLKuD4FsvQ+FvnWBKC3tdCy4rWXD7wEVPIPm1T6Vfd3NnoQzETaoAY55CkneW4QXtE22vzrn90S61u02q9tPTEC3QHEM9fMAFUi3SINyrQ/k5OyGZn4dAaf4pp1IeYjHIM9SXvgFxgV4ec8LQsUusvJywVpND0vk7M4Lu6GL2W7ZNp7zDP4GBeOG/9oXnF1xAEcK43uRNJKmy682TqC9OllZ09bOjvcnEDaWumSx4fZOoy0lYoPtjUDFQ81x2Z+0EYBzb5EqNhGqBiuUTPgW6RbvfWoXdZtxdX2A7hGRmvP5SnZTw6lQDuWUFTHmhyMJ6B0ytvlBRHpctALHPxecYWhtRkjAzj4T0RpFGd6P7fhuUAHf1SUK2sbSV7shTx8N9r72YUElgFqmSmcvkDV+ufhXQ9K88hCmFc+tHVXTYfnmw9KczMDzxLhkmXdUaCCet55TLL1kWx/ceXXww/yrq1uFI5aGoWqnEbhfdOtLYDzua9cVO1XO/w+4jIKQgHTtc4gNqPAwR92bhCYwg2CglKy9DYDYDzUiRZH0v7wBiEY3qkt8k2oyyikWM2paBO5lqXipBgupuoTEyVbHvqua/yDLozhgnaO13jRhRKX5APls0dxJ7pIQcXTAz+r/g7ob0dBWfX25auq+yyftXyDQFlkFVqWBnldBSUGa6FUU70QakUfHOnsf2wGVpmJOOBeR19ireDmaZ+tUO50tQr1qn/6/NL52+ig56+30d03aaNrDqmNYv7QRt8Kf95G/zf1faNLfTNIffd4sb4dvMPx5/U1/hf1/cTZtb4nSX2XQ31PQn0rHDfWd5/rNjQx8bNHX6zy15gaiGeA0FNlE9Z8146CSqj5dl/NZaZFrKxSi340Fm4QNCX1QmQJtEfpBoHWYqzz18Rc9hdf/U96sf56X/2fdJDzcS/56//pDfUvc//1+qdeV/8G4QSNLeARgli8d/AD/9AGVsfN2+DjwLjw45H+X+DhcVyPxxoK8agheKyhHPx54Xo8PHwv723wSH+nykd9SuIvVCU7+BX2Q+mOgh3QD+uq9ZulnlDlLGLxLGMwaFBUCbY/9g69Bb1BZbG/2kykD5ReE/TBHI805j53xBGbKX8ffHFDH/R1/PW6r7ih7mtJH4wmdV8LfbDgD3W/6vqzuhceuVAley+MxUgaV/gLMEZp4qUnYfkSHHEaUwHWcRFLarkJbbIfIvHR+COy/Z89OkFgwqRWy6reVjCgIKZ6/fII4ovuO3E0exVaQwGtscKDrXHGja3h5M968fSnvy3O3NAWqcJfbwuH8Me2EPgjotQWAv+TeGNb3Of+621h+X/SFg43tkWery2m/aEtgo589Zz5Ob9FIb2tyMTzE1yUKaqW1kr2+rgmdtF2s3SJfzFd/7+YLvgvputw/rV0P//FdPU3SSf5nw5jxy/BHSbgg92ZMtx/pyvklQUsVcbzds/N47S383scv5kE/jWvksRppwNx2rkjFVVU7MBX61vkkfJKjPgkK1dWoAfwDcIdcEWmyCDfzz3KaH0zPsHz/rLyDUJQCs9/CE+jmnpZ0Q5ghTHWupz4+YRUIG/eoUVfn9uJz1LDvojxO4UgrVx4cfCPNjoe/SZhXEh6aJi1sqAAMKwEDKcQDCd4BwE1PMoplBdtUBfAE+ty1RdPvlxUHeeOULEfVRF89ymWIKbh7N2vEkw3dsVuiScoOqQpGLCLMp009rbiOyVI0W94L9rogUkFJgmHO7vioCE4yL2jJRyCrscBeWRtFa7a3XPgoZYxeip2LLSbInItq6iob1Hp6VcVrAH0ZBowMEDb9UvJ45q8QdF9mtGLT5hdCMZUwYL1XimNCrCMAizVTSrA0gBYRlkTQZtx8JO8rYAj+iFK8WEZ3gXL4wJiWeUZ5/PqqwhqATxVPjyvQFtRvrYqPHK1y2j+2SON5hO3HM1PuJ8A+rjdWG7sMpYjXDiWHyG2Blf5k54bx3LEkVAW47bSAjM2SJfH5XopQ10t+mjQF6K/Ae7IBqC/kFvSXx8fDYr8GVEZHd0cZr8Depjnv3Epo3s34/uuff6YWxkd2qSG1uxj0kBr4rswex+YD9d4fr8l5fUk7anyhN2C8rA1K4lP7SupdALIKIySDWOZwh4NAe8XUHaSmzKMbLrLmlQ025hLSsaWkbsv2ZDb0oLsXtw3ogxxzTsFpWm2MfUUfje8aE9ayOm+fc8eosf8ekgc3CPw5QVXhy3k2/N9mg7Ro5sOiUaFdVgRlSBY6VHDCjtsmEffGlork1YnBx5lk4rch/akdZwO4FTC8y0uCrSOpKLX02Tfja6eHf3roeE4Ek3zCumRF2z9WN6GJ8nO2kYSzxs08XScAfWIbo7pj/foCSCqeQ65nwX3PZp3k/upcB/ajP0aA/2qAe04j3vIgz17HHt2pdxnld1apWRV5d1A5m/nR3kUlXSFqnzxFsUW5WYYHTkotX0qMtEpV74tCa2goVdfdSH0VUmYPZFG+GUCfwbwMAKvJPBHJWEk9RUCvV8iraPLYFZL0dHleVyMB5+Xl+Co00DK+pZwPc/PI6l3Ql6pJK9ZBN5cUg70SUYjtNdk8mx9iarSOJ6+a6eg0q4WdFrNkFboaTmNqaaAvCOHlGMg5VPQk3LQq6eYtqX1Ov3PPpQWPV7So749JCb0soqoA2MMU7s4PMyuDZ3tXHMVOfoaISnnki3425l9vj1EaaXUsQ2qasjblHoYJeBPWMzzQefajsq0Aad92JXyvAzKHNOM73ZCf66uvj+69ZCqsv94tMN9QUgyoR/1n22UsdGKFENrrbb+bJsNbTZyE/v7a5nD8z86GR/fzk3MMcZZs318OzcRnsR08m0V4dvYBsNjfrLRsYHRMzjcerigEEbPYYudf8qLo2eR62E/N2J+tyURbmTycSPk3IJXdVyiMsoeSSMN6YE2Vc365w9X00ZlA+iB5OlmN9KOzBjWgNSVCtSFT71OytDeTO/Qz7lso7WtxNvo7+htVPcusVVR6Sm9uozSxyIfiQhj4yvk+4CehVfHImcYDHKOiViqyTbyfLZTGR0GtKskMSSV0UHNGKeV1skqQuFJmFfJGmHkYz27zqB2Xkbq2eGMJzOoMjCDSvyhBviDeOnTjYVH8riLbvmzCjbro6hJ+oIzQcGNvTPs/EceWt/L3DszMkNvyeIMzh6TDGwMjJoJnvKaUGI7UofUmqWfQ8entE+NiH9yzxy0b8njhnu0NdJdnmdrtSpjOieCzmn/Yu8n1gJVt3zQ7y1wjV9AaT8Bvov+bb/eHKHK48rdicDzR8NI/bUhj9vtlsVc4d8GqBmg7e70a+JjuJ9KGb4HeCPBmDJ+03AEcG4KUjW+DzjP8bxvfj/zUEY8YPyNo8qH8SXI46OGNwM47wecFXptAN+z8L6yQbp3wf07kP9cNwOlo4edNwCa5Stta8ObUNqP0EJvQGkJ0EJbzVszd5AW2uLY5ivvfchjdcMLgfI2kTZi9J0ttAdSrLj6+EEJ+oRASw7mcQPdITFX+S8cCM8DeICv3BVXZx9cDSWfgnqugpJb3cXm4swSUs9ZjuW+cotIPhMPLgqUXAQlq7vUdCFJMcJX7gsEuhPKuejyl2M4uBTKOQ01XALl1Lhp/YNmS2YBqWG84yFfSenkyx4HcwIlzfHRgTK9s5Ymkko8IEH3EUg4AO0TKM1+II9QnKoxF0pb5R5vnpCZQ2rFCff5ygoj3509MDJQVqavLHWXspwuTPWlr6wo8s2nUNbyQFkfHRjjo5TRUNYk9yBzQmYyKetDYYSvrH+TXN49EB0oK9FX1tAuZdWRVGW+sn4h0CtQVkagrBcOxJLeurdRD2X1coeb089xvU3muxVvTGv6tGxvr+4DtfXfLrr4eZ+I0f03X/r3S7NXxOQdcr11wHCwYurw0PXxI3btPmqhtCcsneME7csLAC6ESwFjJgp+tXChXR/3IKUV4DoL4+gk/FrhcsP9LvgthyvqtQhVEfyWwPVS5lpS63HCi75azyY1MB54JlDrEl+t7+xS60ySKspX64UE6g61rnf6a60+sIzQjqrxcaj1Dtfj5qWZhaSsYOERX1nx5LuO/ZZAWYuwLL0+UE5PkuLX/RKURKDm/XncNqcJRuQuD8LfA/yqcwjAHIHrAX7ZORTg8V6EPwd4pTMR4K0EPg7wM847Af6NwEcAfsxpADhZRHg/wIsC9Xh3/wQfHxwP9RjpovXjzKMyU2EMmLm3xXG+mnzixC9L998ZqMko0mrZV1+a19lqB0iq5321+ZpAT0FpwwKlPbp/iI8uB0NplCvWPCBzELSamXtEHOgraz35bub+XoGydFBWty4ju5ikyPSVs5VAaVCO15F99WPgm25Sz7v3Fx5fNXZq2s7J5rkp/Xdr41cmhEy5v/pTb8UbH586sid+/rnFdyCtIZ2MBprJgd/8ByUaRN8xyQ9Q2hS4cJ9fA79RcKGNfeFEtJqYw7/nut5f0TTuW/JE+KCrv6I5/NbOdOuswtbudJJ8FaNn2M+eoOwqWUy1IgP9uk3j7zrenZVlTONt7jphK605PumuSFXW80FG0xHjqVXP0UllaUdrI9jVT6xfpD/8HbTKCbjWLzI/Lz/cvNykl7nkw5nxcpdMvmDlpILX575ScHau7GKajLoo03xdwMxTPx/UVpogtC0sPtEaVqxeNHOuuqDPXNNxlM5O28S4ZuI3TsV2So153CSBiVY0g8xI5XGRwgutlFqyjemscx63l1gBSnaCnXWO9tU5+Uholj8OVx7XLlxvfUPp98xn7ONl+9JkVoVAj3ba0DJF8/eucTjm8ILTb/dnFQplcdwWT6PwBPyWeZiO8EKc25mOS/D7JbEbjKnGmI4nhIJhhRPhf4/CiQkYd9VJ2yUI/uvwLCufzkBtv22hFoaxQGcv2/mfHd2ydln6FumXoYcxSo/RO2Lm4HpuHbyft+yXlXtWvfXk+SfrWpQL4+bOaZEtzOPmECsmye/B60A3oP3GMewLVeGsonBCYfbVk48PYlUmC2/wondntBweZYbenVwnvD4ZPQJT+pEZdUL5nHqgdCqGqZzXIqMlu/pThehRwITn7BPrhLNz0Ls003F1WZ2gncJ0BD2+HdpMLtCznDaDL41hSp0wGC7TFNSe0XskFY9emKiB6Nv2UY5KRT+vdUKGjOmIxDqaEIM+8HXysDsy64R8+HY2XBa4CqasEZZOobRx3P+4I+BdoQzv17oV+jXCscRGoXBYHfTB6Jowc3imXDudT/LS2lz+f1yqmhBzhw1jt3HH/f6msT9j4UqG6xm4NsJV+Xdpz+/s39GHYcRNIpBQF9OpagelTSvxxXrO3lyFel0uFyn+JLxXKmcxIi5GTosF2TKWRE6jYkGSVzEH6wVNiS9O2pZZh38SSqpSr4nFCSQimv604mK6PFx32CEzzZpwtHYWmzuhvDaX/exKmFxWIS/fD9J6LveJV4qW9qvPl0eYmY4xQdlNqB+f6Sl5S+0aPW2L30IIU/UTW0G3zoG64RyF9kHUOVHE9fQhrcx6hn27qido0sHVqgTV6UZC0xPcsVXHLzFoq/SSVSin5QUo4VoFqyakIMyuUqG3Y6CgpzCCuoz+oYXaXnUxWJba/pJpzkW1nIopTXvsolx+9szW3+RUjg79nFAxGpCtIzUW/nd3j81TebfwYFafgm+D6ls0tKLxfjO0yGPdLbSuj2Ve0U+ts4p/Eua/Shn5NmqdqpZrW7guzD5JRcVXtS3cfiBtkpXWN8K4OZwSkTLWuq2VWhd08UX5d61U8Ydtl9cFta1dd7Xt5Dq0+FI0S2Oz2VXVVrDuNKQQ2mzb4e128vZ76e2/4O2idZ62k8V0Re+20n0KaHVmF/FHqJe7lOl44uBo7T/tlHqPkLxrLZRHj1DZGVWNja4gaU0i/6sXnm9vB007MmeTsFS2JPrHQ1vTup09c2hfWvR31JDQ2kEwjmIPBl1MpRMdxf2qq+lhQNM6SDuM0lWmQS7a8NOz+jYfose2HhKHRFkxb5E/6r1m687+YqNH/9sW/u3FLvo9NcRhxbS0rsOmBn0wMkdRIY3TKm+j8Hr3mGrNvmDg35OdUbYsPb1PU6EESOeEsU53A3p4BfSAUrgo+HtlUOSf+XDJfqmK6mgrkpWOz7IK2h5y9HEVT3Vceka2H+jgtVzuXq9kM56PXi6USexo85hMGYzDR90mn/93yQebmviRGoHeBkc0CtphlDG1IZdb7M3lVsH1kNcEdJ3LrfRilIRsa6Nwlvaf/dDOBW7z7Cq2V7UhYxq32YPvOD5bjEff+4mnTOH6twUKuIBGVidcAu7Eobd6+HXvljxth76VDDMi7emb9bYQKVsj9JqL30keuLWHlrDoa0rbIwVGC+VVRu9s6gH5zh6G/g/z02DWFyzDBqEHRODwuHaQx93leBXPdijX2mLYEJXFxz/QNgdlP7TNeW9VLxXOva0TQog/4q4+lTL/gk+laZyO+Djkj8gOUANZgXk+lFWwWl0iqwUsvwApO7XZwNI7cDbDiBSoXyQ3x7CSLxYLQIkEwjgyMwBKaO5BvqW35HJ7AdaBhrxdnlb76O+rkx79vSyJLqN3GOdQA4NIKtwHyOXKIF14M66/GZ9UdHn+ktu/LrfkSTnZB3iFrDVD20SEvBpaUd+iSKpvCUoKLkPvW3giRVaZKgweyyyhdUjVm8WuK8/hAb2Z4x/yWltG6fP6pdspxYmWURNCif6sCOjPt6JSyQcmw2pJ+17C9l0ct3je4j9r38fdz0E/SXp4LjfQI+nhxUR7CG58JoPjedAyi8zPZD5F5M/5zieITAgUCnp4QUAefPwPenguV+jTw3O5Uo+mejGUNtqdy3WAlt3Or4XW6wC6bwMtu523A9QGkI1o2e38Jx6Ml5HL/eTTP881zPZJ9rMAowOePPPUzHwio/ZzTvPhczd883UDG8Bo8nVadi43CN4fa5DuM+D+A8j/IGjZ7fw1gA4CVO4rraIh3Sd/p0FpT0P9k813Z44j9f/VMdZXHg1fbWoYHCgv+Q8aaC53Geq1yldmONEUnjuYyz0R0KqfPDjYJ3sboaQ0TzTI3gZSrypHvK+ceqJLWg5GBEqK8WksqIH6S/qQpLr3oASdIhB7sPB457qHX/+7Ud+71XqIX/9Dve9W+p0kd1tAC7pe7s7lFnj+KINafPb/4iXipyEO5LGSmLkhBSqQjMKBsgeY1wh35WAd1fr+We+8hJEehptITPBr4rK35t1hPv+irGKNcI9JY8JUGj1IfHrtvDXCuBy0o353fi431xWQtHSYppcevwdJK72upY8+OEu/IDhL+1DfogULUIbsN/WdhVgGnmdAuQjlReRTUUelOByIew7MbGWihLeclZujFqYtpLRbF6IddVhuCPGz9wrIQS8jnTt/EjbtkrNcNUpBcpCCQt+LBjkIJRFGMIyl4iRpSKWLIZ4cQSbajN7j5cCPJjs7vb318Mk26L/x9BkptlSNIDOhJKQh3wK9wztbs1/igdlk+vYu8s7bzvN4Lh/qgbo3yjvoxzithBIMfWPYnOG4D4k8NMidXKMwo4ZB2hKemL24y0DVor951RGaNUD9N4iq43/uJ0/b6Sfvtjwn2Yk8B/nNZecf+U2tqyu/GSz4+U2m63b8Jtnl5zf5LonfyJ253HEn8pscp8RvPnAiv6lxSvzmoFPiNy+7JH6z13kzfvOUy89vMrlfRT+/oV1/zm/szk5+o3FJ/OZpJ/Kbj10Svyl03ozfjHN18ptM7j3Rz2++dN6c3wztwm/+7uzkNz84/fxmjPPm/Ebt8vObTK5I9PObzc5b85s7A/xmlbMrv9nlvDW/8a8n+fX+v8JvbrZuhOsBpiOU/pMlfdhtaUHWfvQLSwfPoAaX19LD6KQOm4Y1HUcf/vTS8Izw+7pl38+3uajYi0v2pHU/DaLf0oaob/OpBGXT+oJkqOf9/E8uevhlG3qru58/7RJsePbr6ZoI1SG41tQgfSrY7KtbC0OBb61xKVlN9SBWxn0tzitYZnnIkn21pNDCFwWeF7j8z3fB86W+5xS31C09LzyuycIc5RZt0gRBNQ6lx/NLdi09nBZyOon+NOqzfMrING0siFlqYB/l+3roEZdtqmoLP8GF8EU3enKnaq01kl9Phj2xhPjK029NG2btQ+9euiFqXf6HaXFWbIk7LQcsz+tB6pGlspalU/l97iC2wLK2JmaRMeN+fp5rD5TS9+FhbAbwXNTMP2+hRn7eIktCLlNZkFAQs0gH6bJdaeyiAstSeDpxKl91bJMwKYcacqlhFBuzqC+8H+c6t8TIbk3TB8qnEugmLH9PwcJljF0V3LQ0ZimWoYyWNZ1fcjjt0FmMtjPJFLMoFL4f0AUPLAN4g++tMgPh+/nwjzqAf6mhzp/A7xm4hsK9nNDlVK60VjoHGrZctXJ2yHEFd0T+7MskdgVlvLtBS+g8uHEA0PlrDlofbY7O7EdGlNzbJxM5ZIxD+1EkyUv13vwWlZ7E2xWlaHDNvpOpPbKYMrTKjDTJ9ner10zqVof0kipEPQPj36GtedseRWNeWkcwSIByrQt4btqs3Y3vdAtvNc2ltMlzO+k8DXBPmYvrEZ14jmuI9+EZh/M/4Im+IHQEz4MeLcGzXsj5KOoGPJ8neBbD/0hfawQHcO55Hc4R1+G8V+jE+QuhE2dsx4pR62NHXmUiM946/7H5zDuxKsBV0wX/2YB/FMDItyMEiW/v8u1GvAnYnxdo/RvmNzNfJ9jneLb7+MnDQnnNKwFesvUmfHu24Ofbzwma6tKMqdxAcQr3s5jI2vknROTbU7gzoizGzjeLyLencN+JEt/eLyDfnsJ9Jfr59irfLsVKwGi7UGx+NnM54W8qz3M+fOIE5NuLAxg9fQPf7il08u3hAvLtKdwOEfn2LwLy7SncJjGlPTYVY9NRhr0AvwLwQIDRJ/mbAK/xYbOtYY5vL8MC2ORC+0wzT8+8n7TPCfcsgs8UDuu0piEjgM80Xwu1JPlbCOvXuV8zhWsRpf2aKVy26Ofs8w9m+nYyMqCs/sIY0D5ZUvP17vG+ksrJd9kHO1eM7/GVxaR3lrWZpBrjK+swge6Csu4IlDX0YKJvFjFlXOZtYow5JnMoKWuqe7CvrMfJd3cc7Fwxjg/MIop0f1kPklRKX1nPi9J+TeFxpMcb55H2T0PYisa9v2w/ebzH8Lp/1D829/TT8xMGZv6V+eQcvP8NrhTgIUfh9wRcS+F+E/xuhWsz3FMZhROXHYtQWQUDfSL9RLfCiX7pdqUgrXZKsu1UrpzAkz68XrZ95AZf+VO5TeTJKzekmxlIx7ArF5UKg2NUwA23Co2CoTs1iDkjrT3fz//tKOO7W3f0bsDrEbjOpCH/750RyVK60rRHuW7yxy7KQ4/Vatg7MAbDsFfYbvpVacsuhtJHa19nV7NHa8vYUPQBUJnP4jpmnO4O0F+ncH09uEKqWRt0JISlrvShZBVarigFvaL21UXB+xCPZEWF78cZZBWG2nFaGt4qyVu32x+9JpzsTocq8kD/psu0OrrCBO9xv1PW/F7alQa0tsD4lNevYgMFu/2r2FO4anfnKjYfyJEaKOVGb5nCfQv5KUBTHw+lvJPW3oA2XlygP6Zwd4p/1DUe5N8Vpbi1vTOsQIGhbBmr51ZMklWAnHssWYetsNUttcL1a+JTuALPX1kTf/vDrmviD/KPiH9cX5/Cpf2lvObfkFeG6KcRNamjVRhOT+WjHYxdoER+lYhRG/GMKOSMMTJJ6pJj/jx+JXnEi/64GDeuq1/m7/L+t+vqU7gj7hvX1ZPNMvR1oJex6ZZwdrflRIsiYnhmmqAZ8EKVZtjqBZQ9j34V6ikj9Rxq1s0Zat7zUF1LVFJdS/95uoV1wlETYy+RMfb35VRcmZRyltMWnxVv1i+Mz6gTTubgnHb9Onxdi2kqY7dCvTeKXVfVS8iqujunc1VdRTMdawOr6hFZdYJgwv/9Emkdyj1QWyEqtU7QTsYIe2tgJNYJJoxLCffJk3G9HNsU+6YILuzvox92xmz8Gu7DCon+l14KPWSI2VlFJQxgMQ7rTqHUslPYVNogbDKVtB8vwfNAR0ualn8O5aw3v5Ip007j5zktOqhX+YP8eUcuf82j1oEeR1P6xhYVPYX7pwDzfala19iiBOgz4fxiddmexcGlIWXUUIp7u2QrjJlTrUzx1bYT5FxvPjkleqTthBqhlCsbSu7lCoUNreHqra2qLs/XwPP58LybelNraPGm1jA1+p5ZYd3SSs38dysDl2rx+23/mYmpv67l2iYUc20LoJQLxf9upYuPtlHmhW1rii3k96XigW1Bixe2lRQ/1Ra7+Ne2F4oba4PsGvlo9qG2dxdfaIsjmL0E96fguVbetyC0bENr2OINrb3U2jZK3dgaXrxJGGvaIBSY9rYFqTe09ize27ZXXd/au/herrvQ3NoTnkWqd0L6SdxeMea5Da1RapRtFplkg9AG5Y6yRphZhljlg3RWepCxYc5zmYcP2dVB6XYxecA5Uc/akqqblm9PG3c182B/KSaRnrfVQtmPkf/FtoSs8LJuZUU2Q1ZoWVhZtW3Oc6nVPezBkAOlKu5TYKcwzpz+QvVmIXnOv2qaW5QvR5spfQqbCfwjQ+hrlpX6oVQh+2rxspnpMuBa8o0L+a9AmntBSE7cJIyBGi426ZdqyrqXzddTZYqOrY/JKpl9YRnCXXl8mIhzH1o07Lfi3Um3ipwoncZPcbwNstnVD/1nSkuITh65IFIV/lHEbehuV+Kt6G6gw093e4Vc/kN3V7qbzP2P2El3k7mXxP+e7iZxw8Wb0d0kziD+/093k7jvvdfT3RLv/190N5kLFTvpbjKnEK+nu78J19Ndo9BoupHyQgnlWT1Ib0oXZXiPUN56V5CP8noKe2y3ojucY0CCcMhJDDTGTMeglDKF6+2LI4h6ws1ioBUeAVkncVMVxrtbXf0CObc3Fea76oeV9kiQA/Y7KP2LkAI58xdAr7FApbLyB/g8Ee9C4C5b3CSk5CiHUNwHJcwpGn63l1Bx75zrCXcXSmKHCA2MPUWBsavRNh9PltEx6UtlZQh/QGAZwHICHyCwEmCGwO8SOAhgBYHfILAKYCWBXyNwKMBBBP4fAocBrCLwiwQOBzi4TIrYjXBPgNUEforAvQAOIfAjBO4NcCiBHyJwX4DDCPwAgfsBHE7gaQTuD3A3At9H4BiANQRmCawDuDuB7yGwHuAeBB5B4PSlEWULbDD67Skwfw72PZOVKcvUZSFAjxFlMNtODamU7ZO8+Nd7IonfT3+rRtzQqiGBVpVaSU5geaDWLi/CTKDWVwisCNTiIoHpOMTrE+B10z/ynTsNlHjGe32J33qv78d/Bt5L/fip19+vUj9+6PX3q4ThocD3Uj/uC7yX+vEtAocE+nE7gbsFarSRwJpAjdYRuHugH1cF3kv9WEzgHoF+fJzAEYEWWBz4XurHuYH3Uj/OJHBkoB+neP39uPYCVZt8RF6k9+3Uh7F0EcauQwlwHEllLEi3JB8vhDTb0hRsL1Z9+ss+X/usprtbE30+rq7ZQr6d0efLQ/itOEhhNRZRRsFKjzYWdtgKj99urymnc6/pNnt5edwY8dM/j7eS/XRW36IS4awJ/URaTSL/pUcRHXxmmdnILiPc4kuP37siY49UPpq1+2HFJhOJGq3YryyrF/qVTuZehvkU5GKVyO+WYg4pjOwC8482KeaQhXgqmJu95+H6FvoZyjiiYTL3njiZq4OrXLwfuNlk7jNxJYnu9VaJZZG09/rOwyq7JmQV27N6GtTjlNey6DJfJuRl6eeeMmXr9S/tmr9gLsiQpXUtoTPrWjQzM9g87l7vvVlvC5OoNcJ9OXp4m1NSJ+RX0egn+WGM4HyfqIiubmLsT6jGZzUKRzWqTSksFac6EFym3jyZixdNUIvCYJFfGKjFaPOzNili3QlSC/jKVN8ifxLXuyZzmVCDOXBNEIeRWlhE3EFOs1oe9e8fH80BaRtqQQ3Z0WB59DI/TMCo2iWmU6Yf9W+TqEPlVJ2wJqdOWFtY1xILNTHMTIaa/OaJhpq8BzU5kIPp64SqUpDdq+QkOtFRTQrUxuZVRO9v6glzVCKLWgpaGE/hYp3xxHPlWPJ/pw33VNp9Y/yTpSEq9TFpvxjXxvz7xahXz1gQooqBdziXvOKTubvSW7P3r9Ab4yX0dpO5aEiLkC0vknMeGZ2AclOsVWk0N1Dx69iRQE2hISEuZSbalbMTgu1M8Mizd5OxckZUIK8ZmV6QKTBjxENoPX7ULu92sYEeIR+qtjPqXxr6naPi5eRU5gcu3k5fTJVf6bMtjbEzTPcGYxFtVNVSMV8eIj5SSW7pBaDVjqFHBA+90HD8N+FvAL3C20Jcqj19SSlf24KNQVbaHiuj9JvSWq2oAzttVLyd5PGqhNEIksvo4KFXGs7auCOvCuNzXhWWWjZjTMq7gtioWjoOtO8RoHdScB8v8ivEkArGvpTCNUTg+NMkjk/ikzl6gt5jOiJHLZymdNtAK0sXGCOUCRIWZTfIqFgqDi2dzv8mmwBP9SWCwWQitmBUDKXFtR6KrgNdTf/EvCdAf4R7FVzqJMY+hmbsJvl1eerPz1sjpABFNWrXCKdAGzxHSb6cNMeXHVGgp5pYY9HPh9an3XGanIlzkfoOTy+gy+hyF7/MtbOVVgPduzW6/QJFLWJxZL0HsvT5s7jyQGuxr7nsF6qwl3uzXp4XKQOeYZBsBLz8ZQJvKDE+xxwIMhpqg/RKQTVWTvb5J5M9/uXNlD6MwLj7Npl7Hp490bzkOTwNqPKlWwbPFjfr2O+hvl5+KOQ5j0AqgAYCNLs5hi1fjLFFKMM0uP8N7lPhPodYJ5gAjxkAZQK0WRgDUDpAac2bQUaVA05yvcxnd4Dlj4WyhsO7e0zd4F03PdPl3Z3wLp7kMg5y0YoYIQ6hFIAw3pfCnqLqBd+mmA7XMOUY1StFCB3r4r9xSu143IXtqKKkWqkgt+CzJIbQ32JI9JG7II9fznbY6Ds3Q2/lN+B/yjjHip5o4F77oHPdle1pM06fGPhgusJ+KjgI2jiGzRjv5Vu8lOF0c5A9SnVyfLldFQL8VOUCKpHWsYJwHUt+tJbS4irW0Vp4QgfpV6WtTz1Wi/p7UIyMpbluclzfTmRjdYhdDcitVc2fTWhqiGEprZevgBLKm00jY9g7hCCo726Agy8Gqd5oBti0vkZtp9Xv2agkGAF6ukubbYZ8tp9db6O1L9ukWn4KX9rOrpLiJE+0CsMTKeP+jvHPK9meZ+Zl5PFmgTLI2S+E4bTqTDZ/t/igWV7wIJmfnnH2OXe/eTa5X+ac/R7ygRj2B0i5RqBK8vhsEkknmx8gYmSZPPPkTCOLae93hkH+uP+iJ7OvRZfKqkDi/cGh2gdfd58ApQ6EUhn4lhYnQnlfkBgo470YNTBsa3Nrj+KfhNDduM4aul2tL3HJ6VUuOYxFlb7bjj1zw3ecn3vHDv28Pjvmzeu7Y8+8mP07hWLTGtAQFrbtLc7mZME7hSKAx5pwxCaAXrG0vL41pniNoCkFGcHV3BpRjCkTWHnM0vLPW6liHIvNrRrfU2Xg6UkXejVB/yXv+/yVKe1W5UnQ6CYWm9i61rsgzY8OyvBiU2zlEsuP+koLczAyy2ihdfIKPKnO5G8QokrQj5geLaX5ZQdxh/sfLZR+EMZwewn3uM1klCe55ttQJ9npm08Ow++ncDXB9euH0p73/9aedR73I9mzHtLy7wxKT+nwhB7ul8fpJnOrnZRB09zcQh2j4kM5TdC034PkjHUmu5QbIMe1q2ay/k3pce3MutZ/ug/P6fSFr+fD10HN9I6Z9PjadK4oHS2Q9Bbcge96DpCBlNnO688B4roeOVunYNi1rKJQ00DFpbJ0Ob3Zy7MeyqBtirbqi2KNI6xSNOsW52WbrCKFpQXF/Vf5BUBN3chprNhBcaf81lVadhj6CnXCc3JWTlrv0xc96HzBkTXh2mm0LaC3ePleHimSW1tzJvH0GuQgUviOdMtv5HzcL7aII9hv/nZKBvwvOzBys781pBqIWRidMAw4M8bD9vIicBxTM0Y/w5FjGI6SXawOTwPCyH95MlcPeWjxbOgxShvKqeic32lfW0u8Ac+vXfhNpn8/7bzvpOEVngOepSQnlkaxgwi2c0Xi3WG9CiTjkBpaf72V6wmdzCWnVKZjuvv4RS4V8QMNvZBQXYXzUW9WXti7oQByedhNARfBux1QgrppoRXnd8a6iMgKDeIl0hKJhHvSOpyZMJbDZG4J1OFKcwG7EziCyJvdg4t2TQg5XX6RYX4NnGiU8jgIsnnot29fVAXeXC+do6eiwYT3ZnMngrM5lWqzQFUBD766Z4L2NGLW1x1iF4dtSgutHcX6sR0P2B5uNhStSZN9l19NJ9cdusPFlBwDDA3j7+M5J/LJMzaGvQIc8U3bsiNocYfeV3rBt5Hwbe9mmDlpKT46Ur7CrqHxrOyvAAUHTjiGER7dAVRGk5lYYe9OUt0Nqa7BN1Ekh+kwxi8DpCVQDkC/AWQg0GKAfgZoMIHmAXQmMFteBJ79HbwbQ/IU4d3XAI0lUCmU8DlA95DvZsO7jwEaR979DtDfCS2Aqgx5oRY8C57tJzk3Qs4VkPO7zcNYhDHSJyW+aSs80gb6CFMeBvmtd1E6ulK2Eb1LL2JpHVNOlS3dTG8GfG9hz9fGL3deb8/3CLHnY244D/e1qDqO+pzqJvrcTmenPodnasMIZ1DiWCZR9Vo80ilZuSnYOObU8CJKtyeN3tgbNL7Oc7LdrbifgvGcrv3pKVl511OysUkw9tcI6RM6TmO0eBz7US7JDru1WYpYnu1UXjf2f7ZhFCWJaqiBWuLlX14oEiu7Ttq57OlKO7iTCrRzQKFTEi6UyOZw/4Z+DD0rxT+itU6SN2+TpNTnxXabn6I0GKc7QFFDId9fAxQ1EKDmAEWlAvRDgKJGAfQNQKYgoCMVjiJc86gXmF1e/l3gtZ8AV54IUvXRCe0NqeQ0+FdoNRigM6Ssg80SFXn5DU6UPvDMK+YdAyl3NxtQM1VRwvi/oW2qHuqzpbnGTndT2JcGvSAsLdna0FkiWnqtbVpn3SwshT5ca00k9eS9rUB9Yey+KioG5GstsfWi0c95fYsarlA6oQJjB28QYkATDE+qb9Ek9SjbL0wyUboNQh48fw6e07noiZKuTBXKx0ZuZMpp3aDNuPpzK3qNd1xPrwk3pdfDgfObk7kQnz2A2WfHlJnRxjcJtD7DnJnJZugtE7kMj7QLPZlbIJTXjAnsCqf9wR5gMpfnsweYzD0haKpHZeRyA8Qc7rSYyF7mlxJ7gBzuW1EWc5n/ntgD5HBfEXsAjn+H2APkgAbvtwfotHdq4zcKseY4Yu80kaM88T58+hN7gD7XWTt12gNM5sIC9gCTucHEHiCHKxOZGI4/Q+wBcsj+f2yqh/+Y2APkcGuIPYCHVxN7ALTbudl+9l/Zt8Y96YHHO2O853KLHagbnTjWda/zAd5EnmreT2tXjH8rbYh1wNlDHZoH+1hVZ9PaZcxbaT2tKtP9ApP1MP/Eh2ntNKSJs6a1M/Db3lBlktujZOiRPAWusjRHA6UNPpfWroa3Dmv3prT2ELj7sYHWYg6FEyl7leykaQqkBR2u7ypIfwHGZk/qsm0Xsbo+ViteKjyCszplj1Ka2Gw+GWZ1Z8MAjFRumsKvFM4X1AkcSJrDaLT4cZq+B8lxU+vg4qfb/gG/Q4pxhX9T69DiutYRxd+30r7nd/qem+D5SHgu8z1PJM9Rtkwuzuafcy9ZMrr69HLGflKGEQkLUzz8Q8fFmGu2hx56d9yNO9E53Nse/050DrfU0/U8Vdd93BzuAe9f2cc9dazrPu4D/PzAXn9QltyukhGvyJbVFrQp/UZEb9FXiYff5OOSH+3r/bU/QDwy+/1ojzSi1KpkI9m40z2zrS3D9P8GTXtbGsYKH/CtEjSrFGjrVS5sa6X9pKJbfbc6/4UR3TF67Q/wVQqL0nQ2b3Mla5HHP8r1pZC7qoG75s+ltFIvnqwtPDI0a6gZz05NsISzGAN2cObD/DWnEf02A59QgO4+KEs/f1DWvPk52vtBs7ZUS2sEFhq1uPQWJi69RabTEB+Vcp1umdass1B6w7C6lp7z3rL0N+sW7JqPFl+M3SLDqNeMfVOX/eJe5jqhHKjEkKRbgP4EMdbp/fy9rmTcvbKfhPuJGA9gWTa3PLdOeN9UJxyDq86ElnK7oB/6Qpsa4UKbuRX3dlcZpkSqUgDGPrp07E/XIScy7ItVKtPDJBbnHU2MPS8oOatR2KqRb0pmqXj5fqZM8VoOl+fBlcYclcifFnPIGl0CG7NoaMZMvlo0sJIHLWnVcRdZrxuUBbx4BOQDOnMy8IlCTw631oN0pzfTMTncSx4lSxlGWC0P+1fstub8H87eBSDKKv0ff4d5gQFBB8HCRBsYFBSrQTTxknLRNxhMENSUrAZRHMk2zNps1i1SvI1a5FApRFneuFiCl81rmE7m7uoGhmUlaVkh0TvfAR3ed2Bg/p/nnQGnWnf39xfPPOc85zn323Pe85znoG78X+EG1YZhFnzbQT503j04TZ13QzNYvQu7NrO4gVmctyfP3BI239yimk+yXQMcA9N2iZuZIvHVDHWeWSwuRP3ukEnf67Yp47G6Duj2Hrb3W2a49PqZ9/vod9P/0k8hur/HkZxM7/c4mmtcfeLZOs9vcE/+D998s6xJDveb2A+XSHpgtoiRqgst8oFbxBBVYFuon7yKNJj4mHxNClPw67KtgW2R/mHcTI5e7fQqcQoj6N07xcgmr7JUjMQGrMVSHJpe/7sk/8GSboZIrJyj6xVu3QyRGmA8dOqEVHm1rpF7lSaL0aOvNpO2rl7tDKSfMLhPu4mrhutbpvStgFOmh0htCQ5E8WNzjD6W+63emGJpJSw4jBZ06zF4wi339XgKLzzaLVMv0D6emi2tg2b7PGndybB+76g4OvMPUl+318EMa73DtQ5mWK0OZe1M1GZZV4Z1joPWwRtdrnVwpoPWwVkO1zr4sHR/4v8k/oPWwal99ycS3NJhU5Gj/t0kXzxZWgdX2Se687PdQevgbfnicb9ZBzOsGx2962CGtcLhWgcHOFikPrfbtQ4q+u5PRLmlGkcgta8cMnWYdmiqWir/NHu4O70cB8kzD+xLL6xPPqwlrjfN9L77ExnWPzlc8sx3Wk975cP+X+XBaI1t9A9R9NOfEkfHksxXr1zRIem2gvmk51r7uGD43V2HTOsOCcN+/Fu6PAkrHn7CbxA3qJ6JZGwbXrirzfmg3xdMxEhwd08Lq7ETtNWrxqrGtTczoxV1mINZeoMCMzLb6V5Nr2IeHsphFZeXJrHc8Ho/rOzMk/fWx3CkB5LWt2WC8eMDNsWTPljRZerSpLYGkmArOLnb9nZc4aTUjoQkU5LqMskJyJYqMTfldpvF6FmMim9+alhuTPDl/7sZtE6pXnMzaMNIDnkseFrYbL95QHWUMM9Y+zFfN5PNtcZ/gXli8se988GBOuL/7mspSGa5DTWB3CzB5Gjk0wzvYk2mtfkNrOsXeB/DVazlSyxRBtddBUbGjLjbovS/wLMG2rP7vplu3d3p0niQbhU7C7lG5H8jeOeVnaFuLN/pxfXj6Lw73RrkeJcfNCTxV2U/rbUNu7FZsN2Vlm5V24Pc1F92plvPd4/hvIuXcqxUogH2aj1xBfkcrblP2Onln4I1xBUwdY7KtouPLMyYuqJs9Q5D9rmp5Zc3ls/b/dOpONOGZP+v1JMZxvpv+IYN9tt8Q4b9znxDUuf/wjeEfezJNzwupDj+KEuWYQ37n+K6cvK3cUVIcVkPb6xh1F4muUnxIXaOpi1imMa7mhPDHmKfwp4iCDvKiljpXRffYWxTLCevIH2gvrc1uzxwe4fAC4O6frtDIElitd6rb4dQcHiD60UkxKuopFS9qxg1+xSzNREpqiL0nCsHGdYfRZ9hPthpeZmWSmlqnZ7aZDzT/PZ3u2iFtCvxTPPBtAd/w6+MTV0mvNMT58GvxIJfiXXzK+92/Td+Jfo3/Mrw/8KvDIP/sD6exdxyX65ZrFGRzBnbdsqLbbslY9S3qQdpXb5MrFlkYRSxqgivcOqty4QkZ/80kkijO5ejY3v5mdnoI4s/dvEz6xcEKVLSQhSr4Kb2tsJQH9LAXNgkY/7zd8+M2989/+v6vVD8b2e2LLcJvNIy4VuH97BlEq/0tMQrseCV6Psd+4G36YIYWpxhPSH28kv7nUqJX0q/5skf6WYSb4QZYimdaGZYr4kZVhHmipgt8UeC6DqX3Vv4Ow5JOpnNRG77ibqneeGsPQP80WWNjwd/ZBb1xeCQssEhZadgzn7JmfJHDqnGdQfWxSG9JHoPU3xDHN1UzJrnOqPdr6WxbYd8J6GEotLXXULfDxQoYSRKmCaVsEZB8hxM9JZ6143fwhWu01qRNBCibJNQtmdRLiPMn8SRUtk2isT7TahvFA8xvWUTUbZT4P6Y+4obCM8L8+2kG+CU5rKGRdkuo2w3GPC8GWbxnM7cMhb8X/x8ksAd4ByE0v2K0lkyiB77LZRP3OElcYCiVL7+KN9r4AC3ShygsTl2jUuv/jIP3o/WPuIJ7a/0U5CMNNs393v9hhf8v//hPDbTff5fcDjdetP5+3tfvHBGvH3vi7Nqup9z8wmPiP/53leGdbLYyyctEOneV6bV15lu/cQZy1mE2dL3gnTrMadXuEU4KX0vSLcedLr4pC3S94J0a7Xzj/e+eMEg9t774qw3HHPd+fEW/9O9r3SrzXmbTwqRvhekW//iJD7ptPS9IN36nPOP9754IVm8fe+Ls9Y4XPe+0q0XnP/+3tdtmf1063FnL5+Ubv3G6eKT0q0Jzn937wv8n9h774uzrnKMcKez3Xnne1+9Evvp1nXO2/e+0q27nHe+9/X/R07/TrL5AWngtjz2z4w0T25z0J7QKXAOelPIKegdpDc3rdv1Btpz7r56rW9PfUVaD0s99tQFh7fWEGexjJO1qXxC9fP1wzn5p4q4g0mjOaEhVB+N+d+vwk+SjiI5PZLZI1m6gH1PcTJuqB4r82OP69fqipLK9dNz6BW3Ww1y9ekWv7iLC/thpx704VBOfuFwEgqukzg2tqMhWq/SKbmBWL2Uh+nNnb9ZGKPKojCyXI0lxT/Vencnoy4CP5GrI/dOXapV20Nv5hTxcn+6hRAZEcAx4QuEc13yiFMtfhFy7vLCRl5mKOGZ7BLeK7+Rl+fTqVybhcuusSwx7LZ4w56n3W1ZZ7gE+y7LHkOh9MWF0ZbwcgPCToyyTIPbS7vTUmQYb/GFP8Unh78M/gz82d/5e7n9GXf43/vLDZQ2pfUT0t1j8TH8LKXLuvNJ8XppoyzTKZ7sXZa17nDeveWgeP+Nv4/kdvkz8Cd6WfYpXmG4TeNrcPFOZ8A5sFy/epla/mzc8GkdKt0CobhH9pBvwzV9lrCji02jlzSIZ7oOSktDR7NuIaMaL4Xz5uT134f3T5khXHUwkYFpjElWkn6rM7czQhbeLyVLyOnakXRD5/+Nn/Q2YZawqmumMFZk9AlJxAWquK5mEf3vvff7Kf42MkhRZA0CT/Y6WqcBNdaAFmpAri+i5rbyJNG6TktaSKIseybWWBaVbuW9jG9Y9pSynNWSPGqlRXEP6nDUcMtuQ5xlZ/ZIS3hprSVv1PuWtaU1loez91r2ZqOt4V6X/RbafQno3reMyCaNIT9bRiCmdRN3WbxL9Zb3jGMtbPaXlhGG6xZvI4VFGIn2J8se7R60zxLLTmqr7B8tkYYo9MkaCwPatca9lvXGPOHVTvTLUjMvMxYhh6QbRfp2JekozBNe7ozRq3VP6XN11fqdUq26fI4L1m5Pn1b9dclXefgiWhr1gPpgtKiLfNSPYSta93XUD9XHcMve0jxLc+kuqS5+tOwu3YtyUO0sRn4qLFxpsyWl9EfLBmMUzM+WdUb0AcDppejrxmbLp8Y9ls+Mx4WabjPyXcTLkHcv5F3el3fXCCwW58W+Si+9WhKMubX1fDB2MHcZCtB/rZbmvpezvC8V8cHG/tL7VcqTepSrqLuED/bXc/GWBH/XC3WNXks53wqSy/EtM4uNGgV+L2v88HtF44/fa5orzXd/1BCvBH/M0rmIMvwonRkwSzOFRJHOXpiYafVsFd3AzBTuF0lmRrVllrATM1yCTAfbO7BNk+2AbTtsKbJrsJU4FNKJMjjrV2cJWxwkyzHVarerJDlVr0odsKsdXmU7XnVJPxSJGRp55SxhpUNeds2NA98mKxJnaWYJTyPeeTLVa7MwnypqlCdnPxKksB52tZMX2khu6Kefq39Df7f+eA0b3mZZko3emF+L3nShZXwQy0VV+lVEmUabYk0Pmia8foGPzt7Cj8zfwo/KvsDHGLbw9wHen3+BfwA4DfaHY+AfB/xY4MYZjgtfO+hF3All/d4MeMP/rbs/kLclSDPzKE5+mmbmQZiZB5TJgFf+Ae9drYxgwkO5BcIEO4OZUcbdXdH2q8zAtHoNklXUwGb7VZa/Julny3qD0CAbw45KRLl+bRjMKdFqe3vurjiOelVW3V0dUknvWbQjBH1dfj3pOmxCgwqtvtFxd5laF1qWqxtctlN3Txn15kkuffDp2WlyXXZaso60wTvj6K1U72dPtcjjTrV4w/jGTV84EHv/aM0CoQVtuwA7AgV3PVe9KHfRzkXXF+UuRstkoBUydi+Wv54nfAma57yUnNfWPKEe9s3yUKwhu/rJTGzbCf884aw4D+PuDHwa/TJg+xg2qyIFeRzvSID7byJrK1rB2opfCOUYU57woRgPbDWwO/5MUgz0LtAprPUaYHeIReK8WUXifJjsWaNSZgkr7Kq1IwGfsevWRgM+Zd+xNgpwif3a2hGAuXbVuuGAT9p16yIBH7PvWKcGfNR+bV0EYJZdtT6eOyAE2zX4Vdrl2xWAAXavUiWgwi4rCwVk7fPwK7Nn4LdHVKJ2UtB62WIC3B0is+2AcFOkWKwixcKLpMdK0vRUt+/TqPH+X+2cnHhFqVgKkwYzH2Y4zBiY7m+VCn/Au2Fk0QWHfa6Mkt4vyRL2iLLICdce0UenRiOtSlFxfMQjMfp+tSO0lub0WzUFC4TNDpZT1DqFQc7RuoCj4dofJGmbdmBv1I7Wj64l1+fgNhYIK9BbY3SDtQ3Ng6XYVosspz86cOY4feDRu7RnmyUZZAf5POEYq6O9XJBE9yfQpRxVpA3RMzG/1AdKL7BnCfNFvrmftrp5Y12wtG7krgxS0Jo03B6k+CkkSFH/8kBFixCkyOgMVnQD7v08WGFbFqR4l/f2p72sFb10WxLdZbA3pFoLPia9Ri7ex4L/jGG9pdBfRdKxcnpRUGeJMlyTQggNypOuNwD9N32AXqvnFgtvORv5oZj5lkjvDzXyw9x2WrnvNeg5l8vLcECY0tUk8QPDjSV8pCHaEmVsAtVeQNUH0Vy5FFotuRcLy5xNcC+xbDD4VFzgVQaiJJc8iuSNKB6ay9GjFVv4CNDPdpaDisLTF6Vy0NAXpUak43JHwO0L93DJTXEqkCNbJ2LKLud988vhbkIIpAq7zDjCshhrymdYPXxLAyqiLOeMP1n2Yp0YgbSGOX0qB1ds4QNKL/CBxi18f+OFlpEvxLzhlObUwVXl/D3Hmvgh8FFVBUiU4ccuIJdO4a+OJv4e+A82lvND/rGFVxuXcoORl8iqLfzwf5CsCPDIw+BjiAOxjzhmsBgx50WV0os5W/hog819n+YjC+PfYWFKmZvnC29Z/lHlug8jG84MH10tb/UOzuIDsCI9LNGm1HkN926T+VWHbe8SOkxdguDTyvn4tj7sW9nq43N1iBRioLzVJzgYoTJhCOMbTDVFGIJs60a/8egVqdb53X+3FOZ7t06XbRhMdIUMYpMHttX0zx7cv3W114RpbOu6gP6tr8h0lpEGJcL/HfM1xToe/QipekWBsxg0rX/rWu/N/IOGWfAZ5PZlW9cz5HvXtHvhv86nf+t630LQzIX/3e6cLAH/QfJhAzEHf2WnlXUg5uSnO5O4gahrp9DcNVhaU++R1tQh0poaJq2pJLO3uaeEH+dfK3zfw0Sn1ZfwD8JOmuGmwz4e9kuwT4U9HvbPe+oPUphFPVf5MMMhS7N0R0nTlCDJ21/lQ/twIy7RajkvtkScJ7sPK7+/9HKlq74+cVA9TLDMKKVco+4MKy2txnhLmnGkJQrc1l4jjYQi/kH4jweMN77ezKi/ao6LWzE1L2/d1NcxDmgUUg84Bfg6RkK9dNpJbpmBuKF66ZST3F4GkrkvAL+i2MRyH9YwbY3egyusloTS40KCne74DDY1ol7uwe8VzRCTrKIRNRNmWiwc7MZKwxwQHrfvfJqJAY9TuqqpRMwOZ0YZ6mUxExqwoniN5AIrjgkF3U18oH853x+ls3Y9ZF3XE1xBPNFi4fVuRl2L3chILrhKVRFsCjFt4QeB53mjM6qihA8CRSHCqqSRHFV5gY9CXw+XXDKMgmi4IiTXBX6kge6v7nzaS0r5hDvlOI+UDyLl1L6UZ98h5Xl9KSf/P6Q8HSkPqUXpY5mYJUh/M9L3Rfo3MX59kb4C6a/oagQHqLEs8X/I6o3e0EC9QdKVh9o2JtwsfOVd/gLaWGFsx64Hfsa+e3DGwIrFQpeDcqxHjgOrgitoz0i33pyC066qaOSVyPEvDpc8ZYUhyj0Hhkgu1ww4yG2PMCwWLjn+W9lotgR/hTnoK0n/nAI86YOYh8cdQ7+vauTjq/SWFKNvRaulH1L+wJFvSTP8YtEipzcsozBX9zP+YqkyVlmMxhewd4hHqWg+3cIT9EOIEkcJn2GglcB12j4LOQuUVgOXOxPu/tKKQO5A5GsA5t8osbf9nsPMF4h5ekB+E++X/ZlFYVBVoJ0RKtgAV/46YEZYfqpyz9VINSQfc3PVEgtn9Jyd6Y7eYuERR1QFrQs0A5fwA0AdjjSSHP97D5iGFn2ir0XHXyrhBxqj0Goqx0jUZO9qBL6pwBWTV1+8FJNcqm8fzlXjwzDnDDJosBI+nM/ajCto9b1lWZJPMT9zpVf+NUWSfV2TlIC4+QZK6xf0sFDUXTLqbVp+CX93Ps2RjfxgQxH/kPTuXyOflG/mpxj+bFmXD57Ox8xPzqcXMJzCj92yqpGcCrZxGAHHhCRnVLWqKrJiMEe86lK04eqk7yVedRTW+R9l2GMZDv7qmlV+ADQm2Rqon9zqcs2XqY4bR+80r2q4WmGsg+qiVtA4GNX9mAEVmwpOYo0ybvzZaskzmJpdM+0IBxP9rXumVcF+yT3T3gP75/U/NFtWPTnV+s7WqXFxcVOw2wqPOFoszo8dAg7LfNwplJyk78nEP9NujOW+rUkG//iWXZeTBGiyX8tJBHzNrlqYALjJrsqZCrjeLgvfkUOc2Dy79CpwnMKUu9Rb0n0SpnFJRTL9hhuY+xKss1an3zI8Kwv3rnhCoO93ft8ktSsLHhM29tyvvR+cV6bwdldLs6xhtFZodsmI3m8fW5WzNFzie5noRxuaWsaqg5O96x8su754fJk6L74sN29iKekVK00KqZ9UlrtkctnOJQ+VXV8Cnp2pFfagn93Tt47IL4VqQ1Llqn80T3WHialPQB1v1iTit1iThN8SDeYjhNyIkAF9Ie++5K/9vtn8SIhi9oIQBRsDiP3Y7NwQxUNuHjEFkM6p5gAWwNCKNT+WUQe2DZRdW7pFHIg9XbC9HJCJSajnqr5fakKpGDt9b45vSKschL40ShxUGVbRI9T3+KF/lnaSTIWfiV4IiNq+Ia2fKRp+S3v8qqIrB1S8JdQ4BiC/uzTKMjrtCMLvPs3Op2UxQQ1cNX07DE72r+cq0oUqp0HLqDclKepWJ42uk41gRmBvkUM5C5ap8reIwcjZWex6g5GzKfVhVeH5zyBnB9E+4xvCka8e4TvnoEpKu0jK10yPfMVtX4h8cfAbinxxUr4WSfk6IeXrlJQvs4ZWGiVaL0zKVRhy9aRzjmeuwFnRjgd7zsodS0lqYJawSiRZgnf5R4xMTCJq7L2labTvQb4mNpRg7xxzsJzPMtx0zf7SGA+7ROUd40zqizn4i6YWrewR6wanvLipJQW2NeB85f6MRYl15Y3uKdaRnfRq4cfOEuy6sRN7nolZ2oCdGcaaoRN7NsA/d9KJ6aeStM7P3T5cTas/M4DLae0nm2l9TvS1FPuX8Iw/zU+3LAlSPhSNJdj7997NvizdzabePL0n/mAIdsbpFY8J++zUl7nKTxBvo2jVpIBjuKVJNdH5hNZEnESaxEnMkDiJR0zER8yUbg/7c9HVbFukzD8lQzjgPMAd59J/ZuqoX144f37Kve/5MtQ/T45fN47659SkAcxk+PX2ieL6dGFNt8s1rUOVN7DVh6QufZNbff1SpyvqEqbX3Xp5P9Vsm0fNvmx7fj+4r1h6/bNg/4CKJjH+9fR3M95ZLDxsv4SYMn+Ryy6Ik4uVbwW9ObOeq2xoYZYcRwscSHq4vuaeJa1y1Px3TqqrQRWoKawWMeAtUzCXD3CvYKlYGQYZ6C6Dy62F+y64gyR3WAXdCl+M/Ws5qD6zRBvCqrA7kUVjFbsLlGESrhw0F7BGkv0C1sYeQdETjf6XEDsSv9NiR+E3JdZVdmpP6qeqWOqnkbHUT6NjA5tVSzOE+5w6/I5y7sBvlPMafiOdqvwMIdz5WO+76a/J0kL1TkF/kvaFdAYnGbV8OUnmqWTh1jeOuuDrR+mNMcbW/wWWi+fus37YEzQz6JGB2oGpTHRIXRwXwzGY91T2eC7GeqarvzbgN/gQe2NLiNo3VdK+ofLVZgr97Iykd+XuT4IV9fXBiiGAWaOCFBpA7hP61j6WdJHU9cpFhFsnSlKJ5jryC2Ha+77DW5wq7jHhS4frO3wIc7P5dhjVfwxz4jdhVG7dKNHeitrHMCs1iirJVg1bqGTbA5tSsr0Hm0KyvQ0bI9negk1kybYVNqtk2wLbDcm2AbZrkm0NbJcl20uw1Uu2F6Wc3KjzPJtIzvVPI40op8T4MYykB/0DJ2u7Avi8k1ZRp7DJ6TqbuIH6SmFDpDr7rq+M30hl1LrLOFYqIyudyRN+ilsmgF7zCk7fVBPIjeDojsMcMZLZIvrqMgRVD71UZKr1qgKOzviEwB5623lwjKKBUak5X61vaiZ4MxXXD+0oG8uO/q6BblcJzQ5NiGK+uz0Vh+Wcqra/tr+0LirFwNSAlETrWDsTTnCaXRbRL/VZVaL1DWD8gJlk90slOB79Q4GyZSS74nk6xvX9gkW89M3i9WeCpG8WvocD02SvM6bOiMSOc8GycH/Mrcfo7kAa+y29KeHSLUQn8vfoZghGB31Tv4U6euhqPynekkBGJR5m1HLdmsI1y2WktX+5UvWY8FFXdC1hac4kPfwqXcZBRi2L2Fn4/nJmOOl53/tihP6JsG8PvJvk87VXqzz4TIuXbKgujmtvDn9Rpr6+nBnh1SoLZqKAXzJUl/ti+PJNSf4NP7yYdPS9F2Vxpq62dlnXwLjc5SSjw4C+k97TGS4bwXLeurWFa5eflfKxokuliz64u3DP8p0vqvR/CuMPVCf5fs20eivp22S28GvPOK6tebiUImHIJxv71twXhy+vvkN6Bf8hvUn/Jb1D/za9yv8pPfF36YUiPTnSS5DSC43yTNG3y5sJlVL8i0eK3q3T5UzrGbfPn/5jqr21qjgs3T3dmCE8ba/pLLQm+ClOag5vqpFkim3PL2craoXNXb4VS4VazMosuOV/ub8Gebu/Bn3udvsY6HtQI18vuX3pZSvez1ArPN0lK4vReZU9pZOXVev61ZDmSIr9Lm4p+EpGrdbl6nbqRnJq8NABvj5tAd4azp+j78fgsvNJyzp9Qa5IOgPbzQY27niSDDn+tYHKYPXom2eWU66jUWv6Tm8uunYpeFXSRr1UmG0frmPuW1SP+lXvLty5PBp16apJ1ddqfRhqS16BGh2XLTR265GryXY5yjvBTjeDTgj3dFIs8soTwqBOn7LqHN+y1pymFgXWFoV6HPd1M9W8Kw60vxQ+TAo/2H79xeEvxh3d+WJ+2NaumzZ516Dh/AG13rt1rY+89awP3VI6IbTa5ZUoM3NC+NnuU3YQsd+UYj8L42q/fg3XX0w7+v6LsnFvdLXf9OoKnrN4uWtWoRa0053bRM9aoBdrqe/8ZPfmFKiFSyKVPq0eK5h6B0qfbg1V+HA7X3w47NSBNUkDvx6u935T0cXM0XMXWuR5S4WToqvc74B3YdXx3Kf4bZZKqeeI95fHeZuWClXinUo33aN0q6Q4zsK4yhKAsmT9oSw+rvsvSEFsjpf6xglhoUj3VUjn1glhPtoxDPYw2LPAifirSXeWvzr+pCwlV0g9wtSJmKfInue2Fxx2Cm3OsLR79LIxwzi2gYl0Cv/npLEW+sho/diDuU+xmPMluSf4/OCUjaUTy8eE8aJTuORcNDroa40+Kax//ZowWf0sIbE7Wo85cuxYHRP9Tb1T+E76Dn2pOU4vi7vaUN/smj8vYN6k+XIR8QrRBdKNav+mGfr7UlVctjC6W1U7WrJFdauOMiqSJnQKzhPREm5oN3Oc3qcdnjaEzkPbnON82lgf3/oIrRo7mVmCvJvS73fNpUcihOTov1FzQ7VDJN9bDqdQ6PS9do8Ul+BQHZV0onBU3rskHO8oBE7vDJTi96kPAl8Tih3h7i6Wu9Y8QOuXyqj+2ewUHnUGpjiFQ46bKMv6d4IUCX9yrStUrmTYaU2YB0hrDK0vVFb6Pn52Oa1lTmGNUyHdTj8gaHto/6DWMWoa3XRuo/zdaCW9Exr009dFGq164RWnS3f8VedvR6vmN6M10mO0dnfpOb2w2EmybGanq9cmi67RelxIdNJIVZTFLKR7u5/C9I7WSPdobZLCT5fC73L+p/7sc5erP4eIrtF6XBjopJGqKIuTYj8L859Ga2DfaC34TR1sdtfBANRBCtojB3WgZPRCVw96PKDQQ3Uxs2/s7nyRk0btXRi1mggvjFomXI/2XdlFtw2TnGyFXmjq8cXvNz2ue42P9mi461KpNREu2oUS7WiJ9jOJ1tzjKrtnrt1lZ+StjHIp6ON6/lP5SGu+q3wkpfr4X13fF+jr6Qfttx4pTSlNzxAW2/2Kt2M3k2P3L94G+Li9X/FbgPPtAcVvAs6xBxa/ATjL3r+4BPAR+4BiE2CqXVm8FXC6Paj4dcBE+8DiYsCH7Mzw4OL7PyT53gxhip0ThzOycex9HQ1+ZWNM1HvojnPcnHFvbBHrNRXC1p6UiJHcarT795062Epgu9Kpgo2D7atODWx62C5KuJmwXeikM7JRFSSRVgzbPtjOdMbD9hxsH3dGw/YEbEc7Q2GbSPO/FHYubPs79WnZJjqZ9DEp3igR4zVyq9MHe1yr7xrX95ExFQvAq5aLDZpvfC2X6L45fSfJFmzdzc0/14dUBmzbImaA02zFDjlDM6lWrArYnoZyfw2eskKI6WHUq6v8tienbMGell5n3CJmaVz30ObAzIV5FGYezHyYbE2GcEIMbMuWBW3LED5BnNkade0TVUHbJyHO/fCZJfOHzyH4zIJPSZX/9vvh876Y2FEQd32e+mhgW6asHyh2ivTGo7qWq+q3fQQoXkfYLFkwfN6ETxZ85lYFb4+GT5E4qHIg8EbgZ2uGHG1qmYi96YwGwI0TqwZuH5Yy+d0p5RlCgTjvFz95Qj35b8futHj6xIuTy44n+dSHageDM54lrOmUqRWmKWXVSffVD9KGSLgXO+l1jBhrjlholTFnDihMEdfo2w3x13RXfdso1/ebE8khimtLXN90ioAvfCpEEZ8VIsl0Mrq/Tvurmxd/H1BRxsR80RDYNkcWiHzfj3zPQXn0VYHb96M8YaIP/O//4FT7v9bPEdVMYNtcWYYwBFRzNUMO+pTtTQFWObMqQ/AVm/hM8EQZfXtrn2/K+Vl98g0B35bYG8czMdV1iR1KOUbOPGqxXXVD9Jmmuyr7b0sXrOgZ85D2vqr+27empAvfOQPb5ssGwOc6fObD57mqAds3w6fBWSJO0KzeT/rnNq7/qoWp/gq82VV+vfEt3stAL14Nqaav3MOqouh0yNb/+S38EMNb0vfVKEM0twX76rfA2ZHU+Fvg6Ghv/RXvL4WUvpsDvwX77LfA3bns98LuZ7jQwo45lu/Sg2xYSqFp/5rJPcbRd/b7rGu7u/KfsTJJpqQEa/L63hcCVu/vesqFxUgodGFD1dTnmJj76reVdm7dXtq1tbTUsbVcrIjYIt5Sv1Pas1WsfrfUufXt0nsW7irNXri7tHThntJvFpbs31t6Ty7dzCoXK0EbElkuVgEOimQiSAtlaS5jIomzaOzIO7uo196sLRdNsd8eZW2fZxFn+S4/pa9NlE3lfKp/77dAv6YmPsWfqz5lUfnTl4RobrR1YDeNmn9KcSQfTeywDnx/nmyUf12J2LhkGNfhVyJeisq7+dnAIsAS8cuoNVaZPPdmolcR7NSTkg/aK8T9lYLc2YVZ18+RX/YXXbl4IXZSwbKycv4p/y7d02WTcv5U9pec9byXf0HZ8ZyHrTNFWbT+w35fvwnMw9aH4fL+mnnrSylH91kn2KnvTaqdWV3OZ/blc1k39Z01R6mfMDHx9f2u0RigcdE7Dui7EcMwY8UPNVgBzV1dWAHVjkNlcbrDZSt0fys7qHuxesA/A20ZqzbfGMDkcF0kq9HF2s5kKeP27R+iv5nD2sxZQ/RxCykl6nlfUs9TM29S+mJPYNujMiX66hbsiR/VrKgdVaXcfhF99S9wH9Kgvtx1Q3XVGBXNjbTuc/hK8sb5qxtbBkq6BhKstevNLQOrzS0hsoQK0oHB2vblhlfeo0/Ymq1P3BrNleq/1SdtTTaNtD7oTCjt3poo9ZQk9JRk9BT0gOrAdpZj2x0r2I6AAJJfGSPJr+ROv4sTGsqlE6AiQ6P4q7JEvDYe/Wfs7XPuTvitde9s1HB3wb1Ocl/gHQZmZIL1lfVi5Tso02vdZvFXhrWVrKAUWdu8Z1nbyRwROd5kFyvrK2qEXx1s+yr0N6+qJv6iwcQzgPXHvuBlpeV8w7ESPrO0hM8yRnMGS3PVaGtxN9XDvPUGy1MGM2YRqtF1Ei5z/YuWfwKXZYisjObM/OwqpzDSHllmFnWxw/G7KHYEfvWxrO3wQrY9JJfOI0zSqednGPdncs38Y4b5+lL9EL1ZXBVrFguDzGJROMU/tzu0tkQ8z9BMWiJe0BSJFTJqoSKxMpb8uT/4V7n9q2Prq1jb2RWhldSKO3tQD38uEmtkRWKt7HJtU0uo7Et6p8/1nfbi2RYvmeseVlPLRdkM60f2NLcE7ExZU0sjMB/azS0ZsoTKKIyQlzrpi94G5EBjndt1d2WReEBG9sKuEn422uNuqWQ0g5r5RYbr86isNJob+WxpRJPUREpdEfzM/GJDYNtjctb2L7TO+eWU1+s9LsxFYOolzEQna3Pm0tcjqqEFsSXi1fFF4gexbPuvKwizEpgmYPbHNorW8WZxNuAtQDqz/g74fXD/CHcB4A3A54C/AvyHsT1Cc3c0N8r6qZ3a0VhYIv6LTgisawtZ269Sv0Ev8KeziEY+y3+CJaG0xvL30t6Ts9Ar/a+57mGJn+Tec2X3jARax+h7L43hZwaumRhv0RlrLOeMvSekPk2s7RbKZV1eXzHJusjRyOcaqM5KkMciMXIM1Vsjeo1ZFJHXRbFmfpXBLDpiG/lHgdcDz4xpFJfRfYkxVIuNaAWzqBhj5v9qYNuj1KyNRexyqdYudTeKO+AbghC76IWrMSXiAaQyYgzNC461lHa5u63M/HrDVvoeO4ZqI81eJEZ50Ve7HuGx7gelHhTT3cSHj6JxiXE4sYlXTyznH9Q28eO15Xx8diM/Ovte/iG6uZzfyN+f/4LlB4NYdRrrHI3W03y/US9YzhhOoz5PY32jEbuaD5j4guU6/AInnsYq18RvBK6/9gWLGThvuI3I2Y+wk9zKJtg/hd0X9lcNPyHHpyWZltcMP1seht0P9mLYCe8PM0DbKDJBq3ll9mk+KHs1PzD/NB+cT7PD2rVB3D7MDoVdqEuZ+GEnSncW+RppXeEItG3KobLKugPbf0wkG1pIbBx/VrysOSSeG79H9IkNbL+SzJoCbWW5clNge2OyF+yluTLYzycHtpuTGLjLcwJt23Mp/Bc9jeK22LPiFU1g+y+JjeLbsF/TkM8jzsD2GVIaHY5GzKQzrIMc9IUePVdJvXCdOCAWq7zxLJ9gpHzfvzaWexn5jkS+bzHMA4x15Vqas8vFLctPij8vol77wFqvBxKso9cy99Nvk3hkbJmP76XGlmj3vD1wrbklurqxZZR66XsNffemZ15kbY2YBVmsunrwJ/p8ERzJesNFPjab5FGUcbcsP0njlrk5YO0ht31GnUzNqLfyY/JvWc66feXw5dznvTK1WHWRj4Nvs3QWPKQRM4Bku+tK9dGsp19/2izWaC4+beY12XRaR/eWDymLxJOaIj423yweURWJH2vMiF/2wOwG5v7MBsrl1NIh+tKkGbBfzGLj6k0EQ+IaAL+AGxTzL5JcoIJtq/H1a1P6sbZLmaGibFLWwa95Jv8rlPHPlr2GdTA0Bx92nxgxbZVFvfzgZemkuh68GpOfJY5gfLcWo8fuQYj1CEEy3T1CLHh831KFKJtMOu9821jf8w0ujmmUOvxD+hbQI4zseRArzXRR0lWI9RFcTbaJp+9mXvkmxHKVH4AV68HsyGq6F7OFH59/gY/P38JPMDxYPbFK6Z5XmP5RviS/VjgjRLFsPM0r55Jc9/EY5uCvsmxT0k8Wb4O9odbCoW4lCVTDp5a9pQkV6yxRpWcte43rLVHGWiG9JwEr3gU+oXQLn1h6gU8ybuGTjccFP5HWh3Dr1M4mPhIjO9S9sg5G3iIxplwSZZFV9ZUkpTEcZee7oyoTsHbOtCdUsjb/guPCXDGhmmbK0LIk0+CyZJNYjVlY+YVYr/pCbNRM2zrdRP3XsSah8gr6r9luFq1MffVFpHtGGne5nZelGebZzm8l+ErnFQmu6GyS4HOd31UST1XZfa2SVplM8abk3t/9veT/p85mCf658xcJru1sleALnb9KcGUnL9EXd/+fFH68aJPcb3ZbJf/7wIFuib3K/80gwxg6tqac32x8lz9oOGJJMQoWpjTa4ov5e4nR1VPK1xyyLJXs5+rotcgStBi4h6pGfixa4GHDi5jtb1nypb6kt+zJZ26uR4hfJPdshMjPr7E8nP+zRZFfzn9RakaoW5ZUrC7j8m+HWI4Qf+8LkeoRojHfDMpbGGWN/IN9IRRXDrnH4Gz0Xs5APbjZsiGf5q7EdtbrXf6VqnL+W38zwtyTZLMwhlA6Fa0yWPz9ayyn/Dnr3zsb+XiES/CPtuyFeyfc45HGRKT5laGIj/cnWS70sD65O8WV3vE8WxoxJAmBNI0jLX7+JOtVZakCX1xrJwkYkrJA/RhI7zTJZT5s3W3vQC56eXrmZtfqQ5YWVw3ftK0uQV4OWf5hcMv9RTARJfyDhiLxvKoGvbF3pDI3f1jdxDe65dNb3LjLqynnH1kUv5FbPy/NVsyoIvBIoXXBHN3/KqK1Hj3z89X1lRPQM18Qseoyq+l8cgnte+o/+BQ2Wiu/Wl1SuQjjm+bMGdaX7c9Yc70K6a2JOA03gZth/bM9YVr0K7STIGrzar0HtV6i9vagftIePe0DUSunHQLR166e6UGf8Qf6hyX6GXLaJxH9O6s5D/r4P9A/INHPlPtjDgl7WuJFmDfq5o49Msx76r4xIYrencHLq/d5xBPyh3j6SfFkyF27Fca6bPVzHvQO8ff0N0Wiz5Q3ig4l1et81OvllJnCP53gYJgeIbWOpEp6hPBOn2KnMO/II0JP92puE+cUVhyhveJnoYmt11c2Yi+6bbqi7q2kqbcOV0wtLRH1GuxPV46qxew+y09vxK71w0Ja7Q4U0rj1irm/nmgWxYz6mlYDJgq/GffmsJoe4fEuaV0gty4E7jlu9xeSP+J7tEdI65paNklH+Anctk0zhQMOBiuPnpmkr9JWp2YIAzvpqxBphr8LpW4QG/khpcSDlPBhyFthQQk/1PgiZlziRczwa2wZpp6AuZf4kSLQKFu9FPGYg33bZL6JrXI/5wFzy7CNEznSXF6E8EUIn4ra2yWytr2ZjWKRZqB+q/7MPaakQu7ljrEV4AnorVoDZqJ8WreojMjRKiZc3E9r9tdYqSn3F3jRQDvnry30pcBuID/mrctw7egKUAd0yeKiOdo9jaZX49VMBHKBEYEc0CuCYlHh9Tz1ktwlPUJX3WcxUzsy98viUAuaR5rpni61jrJVrkD7vNjYEur+FjTllnW/uSV0o6t+6F76DGui2NgSqaYyU1lLxG2aEj7C+BWvNMjivj3gayoXw7BH2abxLaM6GcwxEcGcuSVyoz+H2gAlxXGvuybe9qiJlzqO7W8C91fOZ5fS9w/Wtjv3nCWqCmm/cJVPMpC06RqeKWVtX9P3A+zbjP5LLZWlvbr3j9Sxtm+yrJalku77fXUmnq2i/R5nnSFihsJeb5N/ry9nTRJds9ZmD1y8SDFQrZJEK2v7Nqva4m8k/dxU6zuAq+jyVfuinmlmW0pfcIAj2VrK2wbMihrLKP8Yq8Vd+5FS7W+Tav/tQuym0D9T6p6TpCOcQtSRxhalev07JB+S3Mb4HWtlvJ5qlckPtCq8clv95OYW5UZ678YpTD5SExeiOOv+Vjb+RNlE/xthiWJVPkbevB6n8PIRcHQGp7AHMA9w3xFKMWyMU/A9lgsaDjSrjo3hcmBPgP3iMeIPB96Ti9QGtvp7Jbf2kxNf4xS+P8bcP/XWtSpX/kep2bY6GXgt+SaM1EtVclEWY2+Wgc52jH6Z41d5LdLLPp5QlYa4B/awP5J0aB795r8k/Zb8KIsI+kmmHvMT5ameNOBqSN8R6TbCbK+h2XrkT5NT6qtmCu3dsT/R9zSSgbnvA/o2UF9F+4nYo0HcA4h/m7Tbv/en0Sk3mh/ucK6IeeXBnwhipo1LddtmxC1w22bG/cVty4h71W3LjHvvp/qqCMR1ortHaD/ht20mdof++P2xux9+v+8OwO933YH4/ba7P34vdw/A76VuJX4vdgfh9/Pugfg93x2M3793M5H3f4D58UGSTpgpfNI9XYzUkcRBR0Ng+61HSI6QZFnc+8U+Ho/mbJqnqV1JAqJHiDzhukW2X7jeSbfHvNsCUPMBzDFhW1f10p05rUuv58Tkqxd6nsD9u/OM+cLeLjrTqRBe7abTmCWCqZPOMVL/cI4RQucYankXMydaeoFgnhDs1HMVwrPd8oolwspO1xnGIaeG+0k6w+ilYiSqJyWqxZ3//fTC5PzfTi+o/EEiO4nlGPzuF57s7K2D/cJ82ENgD0F9KLv+t3pQox4yallNheAn1USF4A0Yghrx7/xfTnbmCZt6ZBUVwi8OOX6bHd4oL2931Uql87cnO/OE5yXaRom2QaL9yv7f62bt/1g3vz29o/tWSpTwQCedMlcI2x1Unul95bl9whxEJ8ytzCA6X/bKqxCKHJT//UKtnTSI0vmyl/qGx/myVxza3/Hv8j1C79PqLZ3E7Re2SqHPwvyn3Hv3nbv9NvfrpTPy+UJWp6ufTnSQhuoK4UGpFAv6zh5D+84ew75W65VS76Ozx3lCXTf1wGEOL9T1EHeJUuwUi1flfiFZOvemk/NxXFNzrzQI9dydUjgvKZyz67+foe8Xhtq9Kn0Q734h9Hen6f++zL59ZSadymL6D9rraddTf5x5Vbx2hmR+vRaeXvi9Nin3e61ctzo3RH1N+y7/vfGM7nRu0qKrade0Z3LoveB0q6z/d2myRasXNaUW8qwx3boq81SL7KekxYW8t7GQ9zEmL1yzsJAPMH6ySL74lcWXUq4tTrcWPpxufSkj3eqreD/vh7zwPF3eiCVLluxcYm6JXptuNcwzi8WnzOK+wqvivDMwa8yiWWkWzyvPpn420yxug98h+I2GXwL8flWeTsWqBewGlVmsIP0equtLXFrxi2A264r44Uba39PrVmbxhM4snsIadw57+7HGIn4c3Qgxkoy1WbzGuPQ3WGG/hTR/zNiHuB3XzGJAbLp1dbJZZIPMojJ2ULgP1gjmE7OogDs01ixGhpvFEBnWsuVmUZXD2koKlggxWKVLAaPofh+gGnAPIPEU+wCHiChtFn2Rpe+xpjSzuCx2axp9GTRLX9I2x+5se3vFa8hBceyraa9pzeIqpFYSuyX1FVA9F07fZqnG11D5kb/ofqzt8opQziyuhF8RaLeFj+SywcvkG3eJO2aZxV2zMP4decJ3Ttb2XUGe8I0z3RrqR18XtdxILhSzQ56DGcFE5QkXQOFYkW7VKIr4VUZ6vYu1MYg7CXTzhCxHhXCwM92q9GdtcsTzN2cm8KwtoGCeMN3hsithn+pIkuwhsE9wsLZBBRXCW52s7W5AE+BghN2GlFQrktzpj0DuXgNGXdAt8ICjV2S6fQYjTTrN0/RhlMAUADO2L/e+wCwB5kHEn9s5DbVkHcPaprhjL+KPG4vEG5nzhJtd3fQejS0J6c8DnA44G1DbV8IfQEGygjPh8zDgLMBkp1YqzVyU5mKXy74A9vPg5BeuyHbn4dOuPOF+hFiMEKMAlxXUCH6Az8MdAbgScBjgqhWuWi3MLeKdyJeYVSTas+KxT6LvKiTHuKfMPIlhVImvnX5+clzcwSn0DZeR/l1JojvLDLMj4cL58w9dOD9jyivsuKml27dPKd0+eArCEB7wXOKpz/MZ1Xv02SYhgd4MunD+7amgfygvb0QC4pzKRD6XWiR2Iu2urCQOXKuRSvWKbp6Q0+Vqu/WwP4YSbsklX7Z9WTKV3GVflYDeOht9EWbl7HnCw11se0my5Gczuenfdrnb94F2B+h2zd4lVswuEqtm59FbLra3dHnCmz0Y4/A7B3N+NkaNrluI7GZtZTpwekj7bbjfgbsc8B9wvwPoj/70LuAUwB2gmwX4HtxXEef7gI+jjncC5gG/C/4HAHcDBiKeitwiUTOnSIyFGQMTBzMWZhzMgzDjYeLnuNqnMtcFq9yw2g33ueEHbvihG+53wxo3rHXB9pKsXWLxHFfdHJTqhuSH6cW7t+egZubQWxNMHWnqvaSllxuGWQO7G9OuL2xMw4gcTnprSbONS641QpebizkiYwTKEa8rEifoiAc3twyECYG5ayPthbBnAn5IXt4S2uVhd4WZr0hHOxzw+rC/DXs0KEfBjM7D7KjbhdmxSPwYeE0eabChV/3A+wJ3AeZfugrhiEgSO2xbmC/pDv0QI+xyBuZOmGswN7A7npQ3CdzOQwjvQBpMDsk97U6l85Jh1sldO9NIs1JIHL35F8sVR9BMOU+I6ZwkvZZZnkrf+YdZo7vKQHdEojsPugzQ/VrA2vq/ME8Y1Elf+vKEVd2kj/c9B82Y8WNiOU0E234FcXl3su0/0vjHLNuDHD8psu0OzCZnu9mOAPl67T3YX8ty1xHsCGG6hWPARzIY/+gXcvTFDLgnwz0DMAUwBXA24DT4+8A/Ae5l4ALiRLZjlbxIfE5fJD4P82eYF2BWwrwIY9APRUqKXLajiBmKfAwRi8RiPdtRgriGIS5/4IKAqwBuH3AhiPcIc0CYQRIL1Gc2srYBaN8biKsF5heYVphfYXgYi16i6RDlLlqlK0yHItjlDnK7Q93ugW53tNsd7HbHK/dKs31ILmu7S4c8d0wLxqrgT7YUN+0gN+08yZ0nfOxAHSgPCB12zOG6vTRTdmwLjuUozNvB6beUC8lWEVwk7lhaJL63lO04pKSQRWLN0nnCWIR6IyOTi+VCNPOE++B6MyOWy+QC4BphT2z/Uf1D6M8Zc3WJ7b9G7Azdk5HYLkacaZHlkZ0ga9uWxdq2ZzyuI1uYplyCTdLv0JzE9pA4Cp/YHhY3V/dzxg+hoM26C/PqD9iXZhQOVJCsN82H55aEKMyngqW7OzdOueS/nxkon0zftOfqKPbtWeXIxWh3fGMRnytnecJDmE1KMxSaPCGebMhPWcbjOWTLmkbtXprVlIP5H35lWcq4WC46gtaGj8Q8QUW4jDCEHOLwtW3K6BZeBKZcimugZAuBLRC2d7JQZ3nv6Khk7yCFHRlDc8iWMe1xCbpSegcpYSbMGqrztW1BCHYjwaxprpZ7V6JKbHfE/ZyBGLLIziZTaRT49bW96qbMExoxr76XwSLtz8mG9N6X0nsvK5N7XIJZ06iFE9snJys1P89ObH8o+WfM1e9TLpFmsZQ21n8xsV2fjLk3g2jykzOm/ZyZiFWDaHdmUYw7sx5H3byNVHZlndNSPe/KCudKJfiptkmCQ3N8baYsVxl2Z/naSh4dVkCUu7PKpd8m5KNGinM3YktsP5JMqR2Vfo9JvyeSqcR7pDgS2+uTP0PuCN8g+V6Uwu7JopLtcdfk3jkYcStidNFY9YJWMCZWI1MPs97liNG/p1XGRXOMKZyTqUM0w6xhwJVrQ+KwkmS4sCywQcBu02ZNu40lWh9gS7Qq0FZ60HZ1xehf00Z6YInWCuwmbRiwVR60PwG7ThvtgSXab4BdrdUAW+1B+zmwf9WO9cASrRnYF7XxwO7zoD0K7HPayR5Yov0Q2AJtArAfeNDuBPYp7TQPLNFuA3aJNgXYDz1otwC7UDvDA0u0q4F9QpsB7H4P2heAna9d5IEl2mXAztHqga3xoM0BNkO7zANLtHOBnaEtALbWgzYN2Ie1z3lgiTYB2GTtSmAPeNCOA3aKdpUHlmhHATtRuw/Ygx609wI7TrvBA0u0IcDGajcDe8iD1g/Y0doaDyzR9nTG6KO1h4A97EF7k3T1aI94YIn2RucU4gcTwritLUrFeJitPysVR5uVilOwh7QqFWvg5uBOuaFUTIB9PGA04eAfClMPmlMwtTAj4OcNsx/4WtC8D2ND2LuA2wj/xYCL4TcYuG/h9wtMjP4f2mLk6m8eeS1HXj/VlnhgKa9bgf1Euw3Yjzxo1wN7Qvu2B1ZqX2CPaHcAe8SzfYE9qN3lgSXaPGD3ayuAPepB+xiwVVq5bfWK23iingr8buBJy8oxD/pk4HcAv84DT/TjgS8DfgPwxz3oY4B/E3ijB57oBwD/OvCbgT/hQR8M/GbgX/XAE70v8OuBLwb+pOf4t8foMcMAR5hCLdF+D9xLWjo5/tiD8ktgDdpTHlii/RbY57X1wNZ50NYDu1xr9sAS7afALtOeA/aUB+0xYPXa8x5Yot0PbK72GrCfeNCWAPuk9ooHlmi3A5utvQzsaQ/aV4Gdq/3RA0u0a7DKn5HKmqGV2q/P/YhU9iyEStP+ilBmj7j0dhrFVg8s0T4ObJL2FrCfetBm2mkUix5YqX2BnaB1AHvWg3aynUax3Fa44jaeqDXAa4DfCvxnHvSRwMcAX+KBJ/pQ4EcA/+YKLcbpSIydRzGGHgXsxNh5DlABsxqmCmNq+S9KxUswR2AqYTbBbIc5C5MC+ucRNhbjcBWMGuZ9hEsA/BL+LOB1wJsw4xFXNMxsmBbQfAsTDvy/AO8HXIN4tsK8B8PaznmU45QYoz+H/G5bcRtP5TgE/BngS4H/uwd9BfAfA/+2B57o3wb+KPDvAP8PD/pi4A8Bv8MDT/RFIo1hue194P/pQb9SdI3iXR54aX4QXaN4D/DnPeh1omsUV3jgiX626BrFVcBf8KBPEV2jeJ8Hnugni65R/CHw//Kg14jkJpdR6pUKuD+X3OvRa4darU5aieW2mhWE95j/Ed8rwB8Avt4jPgXwq7Sz425jQxBLN2J5QTsP2IY+2qHWdmBXaBd4YIm22UknhuR6WspBXZ87X0v+HznpBJHcSyT//X3uRZL/W3A3Su4cyf/dPvcTbv8Y/QLk/BByfskjN9XAPwr83zzwIVL4GH0m8EeA/9KD3gT8I8Af88AT/XrgU4A/BfxXHvR/cdJKLLed9sAT/TNOGsVymxn4yx70uU5ykyteyvckuL+W3OOkcsX1ucdI/jFwfyO5H5D81X3u0ZL/ELi/zYjjRmrDOfKXO1Wc62Ubpu4cxtVXMD/DpGPcPQHzNIyA8eWN8RUMkwO/Z2D+CrMEY3cT4C7QvAVTCvt3PykVc4E/hTH4Ocx3MDUwdhgepj/8LKDpgRkCux/CfAL4L5oHYFKRxiSYR2EWwTz8q1JRcNiHS+xYqQnkHhVYJ8vNq+0Rmp2y+32bvFP1+keFwC7lUZJemiC9uMDUfRRBOg7ZWFm8U/jeGThDpSusdQjTnA7hz90qfSjsmzvpZp1vmutukkMo6Fae9NZ6p8pVM4UrnfT2Bd3doXs9ave9Hrq386SwryeC80kt0swRvu15Utjdw7QVyeQpc4TSHplKeZLum44+HayQRQuHfblAjr0SmSLdn4ocem2mPiJVg/x/1Mly546q0oasDK69V6tKVV9TpXk9EFqgqPPmhqUxptA6xTjZG8ng4km/45CUmcLyTtLnbT05WAr/FsLrjioRfkhtUJos4p6C/2sOlm7IzhRe7mxpDpKoikClOeoDqn61/bX/bO6n/XtzYMoRlGvpMtedJb1bl9cTMUGKpbBvvNZP8ZfTrvuxs0a4dHplLQySdHppDn9gq358fY2e6zej3yMy6xc9soiIgpiVQ47qOZnVv8vezAzXc8MLGOvpzmguELS+NRq0A6VBcRc83PtHtfioMKzHpfGQ7KEe9oEe9gAPu49kZ9pCZUOtgcdd0M8Nvd1Q5obdx1zQ7oY2N2xzQ94NW47R3fSh1mQ3nHqM9Oiz3FDrv7p80uhm1vWF6lxvrUyNcdI2lhlqfUnS5roD++jSJJdec2/McyqOtT6DX7n1iB0jyfpPai1rEmi9rXWw+1gLRXr9RZngYz15ol5cMD7YqpT3ry8WF2jSjhaLWzQkKVwsbmaYaEUdaR9h1EIzQdKxxHSkPHuxhZnOuL7CAVYvZDocy5mOc88xtprFs0X2qSSYWeLop77Mq0rqaAjQluYxEYXighE1ovmBQvFxwNOAT4xgbG8vZGx7dLOeOiNeUW7F7zWVU1jlxIhhVImMbXPmRV5uYGxbs0im9YxkJxzrgWPdOG8PnLcb5wNo+h3O1wNH/lsySeLvNs7XcJGXwV3S5wYNyYIDvpFJuNMS/ZaMeuTH5ZZJ+qd67+kPte6Q7ukXn6Z7+sree/rwwy6Vk+c4hV+km+6H3P7WvjvuvwL/qHDZfcdd6brj7hHuX1K4y3cId+KO4Q5I4Rx3CLfjjuHelMKpzvz7cEV3DGeQwk27Qzj9HcM9IYXT3yHcjDuGS5LCbb5DOM0dw42QwtXcIVzIHcP5S+Ea7xBO7LpTOIs0a4h3CHflt+GA/7KH8PUe+PGHfcqZN6iPWUSaE0Li1Dkq6c2fUGau8IjT9c4CU0dp3O6PrPhv9Ea485Xc1x/DzC7/3+eruMtTr4RnOFd/TLhDuOc8wkWmkY9cx9jO60jXNItR7xROAG7TdQnP9bC21YBGwIICp7AI+IWAOsDZgAsAOUA6HxoLGO+k785OIZQ4EUAR4cyAl+k2A+CRHtdbydsAiwFXAuoB5wHGA8ZL7bDjbO9bEDVSfsO6eud3utdJmODflFzOMbZzzzLh8rZoll732pnU1WCStEMybQFyWneZiGQxYHSyqIBhRwfEbcLsRysMvQyN0JHAppUilJyTATMLLsK8nmRvUJ503cMkHXbsJmMNi7Sm5+ildypYW1Ema1uLOUhu2Moz/hpLlP80q7IbdZZF8kgm3htuBdyvZLEdjmdpriJtbLdpOx1s+7IVJI/Ue9+ANN0NuGS1KOglWkkS6pZliZEkV5eUumRYSUMy23FuhQmx7BPMPXQPYmch23HejTkuYUoLWdtfc12YAxLmddA0umkqJcwGYC67MTvo3dp6tuOK270N7hfgTllB8k2sbd1i0gBTIp59hikt572NPliJzt5M8CkSa8YWiQdgahcViQcXjVooK81fyHYcSsLsXdooLohayyuNW30W1HmVVi2Ul1blsqW/5LKY3VPq2ixLDV5toV4pdZ/y/oa1fJBxoH5UXpF4ZOwh8fTUb31n15WIh6eS1NXRsazt+VyXHhov5OannLul2y4k2ZhqnSB+2sLKWNvPOeR2vaeSar0fWB9g/5Jba0kxDtE/lfcpf0/pWn6Ikfp0kXhs0Vo+rPRTfqixSzjpYNTVS1qX+NeQjmXiC3vvh1C7+2wiPcskRUVtz1bQ7Ty6q+cUvutZyjWhlct51t+rirX9qIu3Znb9vl808T6l1N7IS96bqJVp1p4udx+pcvWRji7PPlLzmz5yo8ujj1T1avT7bR85JPURq1vmWeotxnKe6Zdsfc0ui37i63LeC/aNsM/7eoJlaWmNJRVtvKebic6oL+d9qf1h19aTLsF9Qins02D3g70E9ike/eBtqR80uVuCJEdINsO3LGahouyphX5l1QtbF6J1s0Lj1qLUQ/QxuZ/ygca1fH9jo1gYW73oS5SDdOu5blJt033KBxnQq6aeuVno9W2yXLoJ9cC4IvH+4V1CRxejbs2NWUTaq33QKum3aJTPFfacID3p4G2eZyX5nZsYia9kkuxBjM6kQ81mBqVm5aDWnr0oaW0lGcyiTNIUSBwCWiaT7rSgT2fSXRXWtiFzFkJtzAzKYW1GtNzm2Q05O3XxJ+luH2lRYGzvZJC8B83nCs1cOi1tPy+1iCvud7LOgNNwQW8D235F8mNt785x+b+bpRhHFJTXcifbERZM96vYjtHBRBdl8TXQqcNad3xrKA7b+1lrpDh2Zp2R8ror64yU1z2utDomB99Of28WcVusrSKLuCLWVgXoBZoZlA7migVEa6TRL+XLPeZJSpK1Vc8m+e5p1sOdVxG/HvGRZKQefcuMfNDpa/xJOuuJl2bfaajpLRlhGqcwAbZXs9KtL82hs4bXsuikh84JXs9aGTFUx4QHoJ4udtHJjoqj84y3s4bqhmJl+r6TONz4BKeQWbchSXlYUf/v5tz7WsRkby6AuxtpDuimepM57+fAXdvOrfJti+6fbo1WTOJIuwkTqehiJ5B+k+1uzaSk40Q21n80aSe1NrBxK6YzbSzT0hAdmzPdpy3a54eGaORAXCMephecqVSkhcIbeZg3uCf0+1CvVnkA6UT8m1v/oG46aSa0NUTHHbSde9mlLQVrBuiZcFptaN3AfuVwAOfDDeJIW0Y4N4qLw04gmiEt3gfc8bwiaeO2NWiw7yRNI+/U+HJ67PyKuWHEUTijJdmzucL4Lm/bltnettLMp7iwsQFjFG3RATcRkl5zrQVE3vJzprt0gUePLUlKRn+wNPhXkHRfdERgqxdDYyQEsbwzB6Mt+01eBuNl8K9ix7lfXMjHuMhfbIkyBIyldw5Id+NsXpZPce5OIn2LvzT4Vy3lQipI3i+kks6QlzriuWGSdhGNpH1+Uw29lauXtM87hRdQ5qeoxF5UYj1i7tU97pKw0zqkd2jQm+itKXpXj+I4UfMM9wq3gQvh/D88hl4w2vvjpIH1I7kMhIh1fPSrDPPP7C4m+mZDODcGeYlyjKmk2K73/NK8jQ81XJbuWq83vMuHSZA0PI63bDBouM8s642kmSHC1Q6ydilXe/tyNVIqm7Mr3qL3D6kcBnuJc1hVLBcN2z3O6EpKzdrlSm1fD2n3dgo3ulK4yb36zNZ/O+DvCZrDTCQz/BT2WpqTt+3+ei+dVp+k05zs1Q15lY8xrq3xlupqIyeLxE4N+5SlT10Slff6DUmp84/1ie3X+onMq+KbFmYJvctI86pLD1yq9RtJZx7dH6c3jW9Zzkn3I+RXqI83NezgSON7762JjSJTGNZ0N+hTrHMdpP8lMI10YvmosGZNH2LdJTKSTZGm0PqnPiKs6iRNWt59WtoYlQhekeY9B3hH+afBimXYk9O+39Vm7KYPOuY97Y3ef0LO7mPazku67CPcuuxDOKEhsOMcx1YGdsRr0IsfXSQkdivHwxWr4fYJgU5vzK30RvBHQkhPwFi2UgPbju5DnJoL7LgxcyEn/8ez00N183UlnLxNIe9oUOpDdZfEBbJLoi5IVi0/c0lcJAvVUeyLhP7djLocvbZc0pktN1wQ4yddECfDJEwCxRg19wV6O93i6uvtcb29Pcvd24+7ezvl0Nv28iLK5bGeWIy0j4Qz3d4d4op3+auSlD6N4GiONCc5hZdFRcUbPIse1tVN2p7F7jD82kB/7oUR1HO61dxE7l3+ov9I6a1pBWJUAL++uwM9VFFJL6QE2hrAZ8/vibZElwZ2hIL3vdQNXC7sXoG2L3NuSjr8KwybpBxSvYZ6TUAtVSidwt+7AYOoFuiNbaq7+DG0ortSa+iO5ShXGd0DPVKK7HGl8v7/nMqbHqnk/yGVd5AKlXpoN6URVumKva3bM4bnPWJI7YshxR3DXxED1ZbDUYOVaGBloO1d5LMe+Xt3oaLSlevZ3eTXG/vpble+G3Jc8U/vHlF1O4Up3Vf5P2PskxQ/vagNbNwYLtD2oFRKmpN6SxnLaZAu0/mGePaBel+2kVFrTHGmWNNY0+u+C+oY9RhTlgQnmLxtL9E9wIlN/IPZV3kdOJfx+U18fP4Ky+5s744fV5y0/ET3wrXeHTdobdXebVFOZGKO1D2W5AvbEYzKsRaf/N77T+fqFlv2Zj9n2ZN/rm6tZX22pmoCakKa7TscK9m2MPak5azhXN3zltxsiulcHd03/G18vXF9UjfCEpV/1uKbPc5iNmzhxxtOWn42/DH92/R5mP8wL+b/2fKj4QIfj3682+F6r3uSIwlr6zeok2SHqxXm2Gn9gT0nYAzW2gAVuN+ALvkwWVyGyJb9S2SK/WM6pNVH1sbK/q+B2iyRc7VZOOJoWPiNu81mOCYi3kn2lVjdJlbMEc5hpYhAmd+ZzagS280TlWMD2274ebf6y+ldla0Ylxd5r3y/Vqb/2xzdhzpjC0skab7qqlFTSI6PZPFIM/B3GIk/YUzuTDJhbfsZPBQ4aWntt/xKGosDNCuxGAV4fd7AqOeZ5puyTY+ZFpgeNz1hetKkM+WYFppyTYtMi015piUmvWmpKd/0lGmZ6WnTn0zPmApMy03PmlaYnjM9b5pXFcb10yeJ7KQ0fdbCgFjwKZO/WLR5+q0GVx88JbpgbSejDrQN/f9YexewqKq1cXxvZoBhuCpeuKghAzgKKoK31BIRtjBYXusz1Bw1FUcrszIbO0cUNCUpdMAUIu1oOoAXSO0oVnQxNRMTxUqT5JxUJN27jQp7z4WZ3/uuvQdG83znnP/353k26zLrvt713ta71kLI7HoZerIdenIZenI6JCxlRhnSbeRFm7ho42bWB1wvcINJexEm1yazMn/h0+LncwXL7grjR0uQXQ60fMdUVYKER2EN21bI+GeNSGlWwFqZpL8bEpoSknJXhvQC+TZlqUy2bg77tBFgbNmKMnxpMs4H57RAkijkGztWlPvYFJHd9CvKYZ4HUZF+No8wOkE94Gngyc6IVFJbHZ2ojqVa4iic8ca6FeXjyCqeZRvCIF+exDDCQOsoxrMtahzG+9s92+4s9wQZFCUZxKCebRuS8H7yXvwxmz9QEZS0pL2EzjuUSytfiFT0pdpCls0QNgHl//Lu6zkge7yhE76y4q0Y2Ux22EZmLtDFNP7p9lNoUwO0TpO1g+2XN3NxP26DGl9VLBRnxXubqNipdfWiaigVq6uLePqauGGnsvWvK6noGQDBEB+lSx14vl70A7f/+TQmnL/q1B5KYxyCZ/tlkBvx/HXv89vF+AhqQBL/xprtYkJE6IBuWOLh4y1UYGBdIuOrOyGqCqmiKYxXRBjfZvfWUUWJjHf6DGai8IMDb1A6XYfngl30tDfQU6SlSFOpyd9MgNqhdZXnpTNWX41FXUk4v80JUvMITybEi2p5dg3eBl1PNMEeCop/ZQ3qT8L59U7vAimWhtisNahtCedXOVVyrBJi56xBXUw4v8zpU4DamXB+iTMQflcpVVXh/AKnGvx+xD/H6VuA5/xO2rOZo1XKNjOR9WC8F0k8SBq/zT6HHWgEnKJ2QczZGnyLGC0uNVkRDL49PKwKffgGIN7dO98CMtc0SQ5aNw3PT7tuFkdpNg0lVEJXUfZDKeayN5ac1OK1BtN41x8Wvx68xVtxSUMkwpNjUV5GWXk8r7djHuXdt17f4Y1vsCe12LJdcrCU70eSz0POtwnyeUC+FJIPc8z2Tmr5vSOPol4D44VpcQz6Q6q0N6jBk+ow9c/eGZfqxaWPU7ETQAbe1EPZ9lb3+KwJvNlZ2+xHa8G3y1nK+pF3XVH6H8FPsHbKyq/P/Yq4qxZfFilqAp8PuZQ05t8APg+SP8e5SoevyxrTEYbqbVLKlR0pX+1I+ZJzGUn5SvpIgK8d7cq20yuqGCr6GPDJFcKX7XjrSxL/drYhw6BblE4VYXn7bAszFgFUvkDyrGtXtq6eT0UyojL2EEgtczLm6maRerfZZmU8r8tMpyImCsvbsxrpAavv7zggwfzq+8UHAFII1K++X3ggkZkOcO/XAfdGG0L9JN3am6jjC+dHOnKgJWPv/w1yvTVEuqFo7P2SAyDj4v4ErWybscJ1NhFv38lIVdUkp469n3fgJKznDTe9TZtvqkzFN31Mu25KdynTB3FWPe63Lv+ktXX12PuWA+MBKu7ddJ1GXt3qd3A8zLdXU2dMKMQoFcFN9DD1wNX3XzyobLO/SUXH9VPeXqfwtnlOCDB5t9nfOMNQMdVk/CLa/Qqyjodn9NGFSNzys2G8vy1c1yOje7rfNgxPFG7Y6cgjyUPqfgIYcr18kvhzQEZXna+U55kw/p4VXZ8Mf503Gc3v7QhVZmf/RioS3/R73Y2nRpzwGYQvw5cO33X4FCeDVWh7HrAtU1T20moUNi+Fos3+aqieGnC5jh5+IHlPA/bJp0Xr834drrQEq6pkdBVqzLZ7RzBJLf/I9uCX2XG2vM9j7BUSezlbwdPtajnlTBJ3IZvmNzt95bhrXhj3PeReYPWW4/qQdCeyKf6Y00eOKyXpPofyfnAEynHPkbhPs5V8ie1oR81hJPYAxOY5C8XDYw9V4VhktuP/vVZl61m9Q3jWiuvsF2/VJVh3I4KP4WoLJumSHcrWFQsu4U1AbWkrMn/3VQC0bAw6f/S2mlp82xew0lNWxP74tsEc9qkODerMBnwVa4iltjloY70YtDqoQvG9snXxPK8RHrdP+SWLI6izojKoXuw2lk70iT1d46M5AX4IPwapxz4XpmihFSiT+cRuAB7Qa4gHSGYn4Bfkqf0s9WLuk9oIhY2iYP1NUMbD/1dGpjiE7YC1NzwJvw7qLBXDG/pMC4PSEukEbV+fAQob3QVKjcS3c3MHPZ7S1ewQPrP/KN+v3btDDvPgv2vv3aTgn7dGN9G8xR4H/xudifBfI46C+EHOcU1K/rgtDf77OSfL+n2gCzC2XhlJYtzoj4U0q7IlnvpYSAHOZP58sh+wtqsqHrXlLfEeKK3+dssjFbUXskw+6YpOybxdSfWNgZLmtv+c8ds8KvqnjOj5jNht9KT71uWxDLW1Ph019UBr7Bczds3vltif2fVCSCS+ZPmMcMWKKTBlbTrq9cP5LPv3GbsWklSLgiBVNqQ6RVKpI0+m4x5AOMipJzLwNQFMdULcGT8S0pkh3SE53RfpEs1Ltn+Wge87SOn4+HhIJ0K6HXK6T9Ml/DPIfpi8QyylGzkkLRJPFj0jvNPRuv3pEqUNte/LwFNEUsptQ6CFrech5QqS8oVItMhHuupp3w3pKuV0Xw7RQ7rrkG4eSdctEi3ykdK22D7AmhPkmhPQcj8I0j0tpytKl+hwg60Q0p2X0zUmQE9aRy1TtjLGZ4SRsC6mvynV/076ZFgHFyBm3kpqK615IfLtdORQvoOYZW9QWz0gZm16EsR8aaW2KjQgQXi9EPlXwPUO4e/WRChbnHZCtMNHTT8hKuFTwec3HS0ZXk9HLTj0zfYatCVoqNSWqKHY5vX6Z4T7lkRy2uDFdNTSQt+sS/ENXzld/VA8bfABpGuU0y1Ix50j6Jv1BUgXP0xKlzJs0v0Ny5Wt5ZDyeznl7PTZT+PaD+dPWWdBWv1wPMHw2vD+zE4cf0j5qaU/nlQAevqMUGmhNdPQ/qT1d8jxdTutmUJCdyD0PYSeJiEOQicgNJGEeAh9DqF0EroLoU8hNIGE7kPoIIRSSKgNQmYIJZOQCKGPIDSWhKwQKobQEyRkh5AJQqNIyAGhTe1oZ4MhCkLr2tHKBkM0hP4KoUQS8oDQGxCKJyEFhJZBaGZjxEnJzh73utK03VS454x3UeEeMp4vxj1hvGsO93jxLkbcs8U7GHEPFu9kxD1VvIMO90jx/QLc88R76R621yfnk4HO4PnkF8DFPUHxfpCqrTVI5dsWpDoI7kfwLYFvNnwL4bdX4Ft1X7Kh1UJcInxd4OsN3zrSDyX0ww/6kUNCnghH7WihiSEvCDnstOavJOQNIQFCq0hIBSEeQm+SkA+EmiG0goTUEPonhF4jIV8I/QKhV0jID+cXQi+TkD+EaiG0lIQCIHTSjrZeGAqEUI0dLb0wFAShoxBaQEJdIFQFoXkk1BVC5RDSk1AwhHZBaDYJdYPQBxCaSULdIVQEoRkk1APnF0LPklBPCL1td8FoCISy7RKEhurbhTsOAp9t9UHtwk0Hgc62kAinoG2XYDMa5OXIdobEb4D4Xu3jSXwcxPdoTyLxYgTAoRXWskHZFhU/X9hiU7Ym6ucL79pGAh82ZiamHwr1boA0SUuUbUshTbZN2bYS3LdsgyFN7kxSfnw4v8IahxhvtLLtKMiVFjuUmKFsuwX+e/Z+kDJkVl9mBmD/eYBhUhdoIG3UGC3kXQkYZZ39OYbWhOuuiW9VxkMaP7uWWZ888nySqDxubVoH8LIZvn8AjNyB7yJ838FXDXG/w3cavkvwXYNPB/FPwLcevm3w/QW+9+A7Bl8p/P4MuK/Dtx/8aD+TCzDrAbC6+wSeSflyNfQlNV+HbzmH8/7WTdijMf2hbd+KcZUbddC3JFj/trfJ6J0Gv82yDtKcHqNsu5+qbMtdqGW0wxxCb/uRZEsduUvjSbwTBem1kYz+YhjNf1jeRKr0pLJ16QJl6yuQRwV5vNoPyHmCxkp5uo0F7uR1mNVXQxg8mTxd+B+ngglKLE1uq0sXFtqoGNy5BOpOU9HfABeZDhIzcMB4rpEG/gYtdZ5VtmW9StzWN+TwSjm8Ug5vkMNvyuFtctgohVtXzUOpDf2UJlgPI7A8Vzw8J1c8MgdDny2HcVgVrJ/U5nx1N/BlueKX8NtXc3aLJ8A9OWcG9Hn1QodQaItn5gNVA155mUOYJoLsNNkv/oBQRHZ9ggCeplul/R+HkILnduFXh/AU+D6crIzfL2jh1x2TVRA3TKwX78TXi4V9AabGAi0cTGvqxaF9c8UIqD0JvvixSB+0gwGud2kjgUqZgErlApV6bQYzXTjiwDN//JwT4n34xDkOAe2jcsW0/9klTLOCjNuza9pX90C2Mn11LztYAf+Tgj3gPxVMw/8vFRTGeMBvCpqn6alCig1PcxPOCuBIL9tlnQB4ug5fFOBgSvPNPMX88fPRXmhgc3waBVIc1Zb1Sl0zlYrSXNfw+bc9FUETqejSZFVNYXLPC5XI4XoH14/nVYqd4KfIqv3FqdKp0j0iQnnO7kleWf78VnxahnDqC3A3UDV4vvT6yU4ZgOobdMQDd5MUfkyyqAw3AT9GtUz2cFkkBH0uQVXcF0Hk3P14fY7+Gz3dEuShYB7cM6MiPfTJ+rX6r/X4popKQbXMIHYPks2DKvGdZLGOvFc1Ae+Tplrznw0ajrux+G6j6zamwkols4HxasBdgW6V8n0Xb0t2Vp4ddzb9cZVqu2OkWv+yGPfcrsj3Yu5gf+jYh/i1/rx4diRw56MKxOghR0GyRz/eA+PSH9ReLQC+f6b3d5dwL8F7P9Vy1rvzXdzj5F1c+uBIgMcwSwOrNkgvreGtgfjyWkzxIm5vHs+lZ/7EvZ2p3K9leC6r+kfOK+8m51X9OvdxZj9uTzm+H15F3pp+u7iW9ctcyPUzQrrMG5x39XVuD7p5lZyumucWlf/ExZQ3cTHGPfDbHm5C+U1uTx6kqW7ivDNHQF2Pcz7Fozh1+WjOt9rIlZfXsoGZ+WzXvFo2GD7f6nzWH74AqCeoPJ/tUj5f+EKEutSo707md9twz76K04E/BfxL1LgXhNr0ZH6r7Rq7xgifYSSMj3Rf1k0yRkktjdk8lwFpDZBuLaR7E+pS5uWznvB5qYtueVOVUMfb4I7jnyV1YH3j+Mk2mJnyYhbvQstWP87pigELKC6SN03H5fXnqPJCNqkYbytcxG0sr2cZ41FuUd41dh65A8d1s9dYwXbAJVWNbW09gLqla+yM4mA+KZDiP8pGGlfIJqvD+VkWpHFou1LIjofwdMtK7ksYM0NxFpcH9amLvc3zASv4mmtZb2i7CsbJp3i+ECeiJYVvor+pgfXOLGVVmTjHqLPxLfdLxP0bk/tu5Z/2bw7J+zelrC++y2fs0L3AykXdSxZTyvoZT0O/8dfTuPsJ8KgiuvG0vN3CpzZfcz5Lga8KsPIdzUVineDa7ekJMHtCvDNqt/A3W4O82449UBp3kzt8B6N9DUCkkqSnIqT0/Kh68f4oGmjD/VGzbq4kMIf3mt2UX4bqc7AF5rQK5rRbUyW3GGZ3cfGiJjyX/kvgd2Nd59dRZ7iM7LTiKxRK824h36osQ3m/j8OLGVkl8Qi7272IzLjsc6xTHStchvgF/RkPSP+2rT+jMJeyHtC77234CmCoLiy9HdryOXc6D1/HDYFx8AJMtd0q5XjJLccnJIe/LuBPOeKZDEFvR/leA5gP6clh8YTsPzH2U5BFRTf8JlltlbZLbxj8ppfeAsqvxL1jPwZ7kEXs0vpDH51CfjvukxWT//90wsgarrHTjepS1Tbf7T7FVAm9oxLG0YVDUi7hWymwYnCHhdxsN7rB+0PPHZ5bFR8qTIlMAOP9fhfGY0ct62VIYAYx+TBTnkw8Q8eUssrMSu7bzpfQ6rGkUtbTgHB4ivM04P2MVYA/dnO4qxADax1rutGJv1gPA8BypvISFUHeJIipbxpUpS5SFfhu9tlCmej3GwCSES7RpmY3gYIJur9zCInRBqgBIF1t3M2h/QfBOup8CMdwu40RXLQa9zNglagXcR+D62vE91/G8ayV1p66jHY54/gm8H8FfjX4/wH+4+D3Bf8v4D9yOZJR7ffbF8sovt+VHKSfou/NeLQAC1VHR5hhft44G5vg0rnvv/vZbCWZ/dkWDwJfQLeIJnF0ThjMwkH75Mj+TJh5unDbKnBUnhLgvzfAgjbPKZy0K0mKUlahbiAWJ3eWo9UZrle0PEELk+EAOWhhksznWu5ynXZu1L0uOTwJSzZLRCMMmOeWfL+gZ45036CkoyW/qq+xjYAnGw07wC1k43T17CBdI9fPgPZGe8zX2KvGRrSlaTuNt9oab8Ev19ifjQu5DQZMdZHYyOSjFtkQw3kBN31VAS0zLII8uEt8nVNiDxQm4t9tjIY5WgCUZBG3DiAgGr49Rlz7+FbPbuGkeI39GspbPXcaE1Z+SH5j5x35jfZadg+0tNp4kYkqPy7/NlO22fBvXaevZfdCGbvFBkiH6w3WWh5gf3D3GveYV8IYOYW7tslA+ffAyA9CjmwF2jgpExKZPWVRB9HKojfMCr7ts4+5CuN9NNmzReuJNdyvUyaakvGF+Nt1leVKiO3H4H4P7g1Fmck+3it0m/0VtCPB13xxXwfz3a1Tjvg8ORnyNWMbF6Dtwy+2sHJKs4/xu/0NTSdOFZW+Kj1gmbooiG0OUZGYNP3kWLEuGSDhCxv+32sbX0FF7inbEAJY2pjLUH2htJcCbn8VYIcaP8Qah6j7SzWOl3bojSTN0k0p2KYPIE41ZDJJca8OcGqYNmHyAOBjwuvrEC+8Y0OMW8omA+b1JG+QNrDjcbUQytAAa72W8AkpctgbwmpwU0lY2Xp+vqoshw3I+4YNzMthexu/YfvAmAMNNzqFp2w4O07hOXTn7oHaytpDjklxowE7+uFepk3L7BJOAnbCF2L9iF3JHnMT0Bd8IfZbQhECSSzGfQu92S2sFS+BWwS/ueJ3sIkd3FLSvc1rAIcGBvEqz1DssZrh37BlMxuZWF2spFneGMKfdKIbo8P33zOEHRbEuuNlrIv+YMidxOvXYKud1rDyWIAU+oF5a6uLqqCi95QPSFENA+4+fIp+8kAJHp3CTesAaab004U20f9uXLrE/euYRGYqi9BG9e3WSNV8FeP3ZJN/1BPHhq49fjDsp+NDV60n77W/mjNu3FE3vO/fGvOW3+2v/FrJjLrPOUIY7oWGMlQ0ptqX0uKa9WGTB7rNeuK25GSY9Zq6QdCjraR9g2A17BX9Wz5TNbB+OhhvHcwCYNLAzPHl45l0pg7LBd6gH5drxHW7h4sy+rSofHD9Av41BEMtIwDfKiTOAiCinxHrQugqTv6VjEW7ENSOtljSWCwTwZ3v35o3N5nBVsNYIG4j86hKuMltILQfrYreSeYw/9LPbgVSQfsDv0U38NsPbimodfBJJf9mDyrH8qxudmFXUiW7MMwLuGs51PXSAmY+4O5XUxF3fyDj7mRzu7DRItlAJsM4aEQqEtZ1wKAK/9bcN0OgXT8D5gqweRRElW1CnGCcBXwz7vIuQCvBIUDFoI1YYyPZIcfdXVWLSnWtbg+UPEsueY95mtDmRPs6SrOn/HxIJIO2cOdg7FU2Os6vzf6W408zqkyoJu8EN3fsYWt9Guu0TLswxAKYoGJ7iFeLlqoIaYOSqkivTxkrZWs4bcInxKoO6D9InSmCr80fKJJLD4404f51fF2euoEwHua9unXjARev4anzgtURwj/uUOiU6VREhtBNfPMmVfOju3wFMlPH+ZhXqdaVcwl/yKClsHRnYnAa1Ve6V7vPBeRqgnklrELcPULeRtl2OILYxbcdBfdn5wnxs0xvkPCw3vZ2LaOENuALVDrhxxq0G0b5Lv1UZ/3uloImYimIchraiKHNINo49gBsstwh3UPXl0lAezUFrgiEj0uyPeM7yd+SN9u0zLLPlx0JYLozSsj1Pw6U34pkfhUkZvDh70oGU+wSJjiQnv/VCakMRYT3l0pzpZQs+c6LqqHX2JGwHnwAF6sAutV5I0ASaeW+NEi2xafyZtTgLdwYWkfes5t21WWH9vRV2rwL74psO9yXLlcAN03n4QuSipIT4uFRHvCb0iG9Tw0w2Ha0rwekAd4JcG0JSXMUuOXPCLf82ajOndOVZOcUx+Qxp0Szleok/oYd/bxsWZ/EN9iVdz97DXuFUg7eT0pFaIFHWQe8h6dsbYiSLNq0oQ2ra7zbhcdsuMK1zDQh29GXiXVZLpI38rbKoyTZCkpj7rwjjRVa8dFmPxjb7e34rvV5B9ocIvcs9buLUwE9fqcd38H62oE80Q6gEMD/G1x3LyO/6GrbBq4fcH0K6AnloLV3LytKNHo64o8mmT8bv//uRODNsMR57QrCm8U4Jd7sVDZSwjpHFPBmKlixvR1zM9QmpRm57C6mXYKuHTmzNQ60f9jBzoJ59e2gNik1yrv7ZEvg02+k1eDMjGJUZXlEsnEKhx0c1Ni/vZTNI2+H42rlyjzhVw5+3enIQ2tJB45fHtTc2K5E2yXgTfLKlAnjma4HkDcJAf4TMX8ug5jiSDKsAeph3oQDrDPT6t8S4cNVPCcqY2GFxJalWuq48rwytAtb5lCWx5R5gW+9A6m2Z3HYC17FVxZ5lWELZpFW/mjnSCjeGXSMM6OlHVfmDe5Tjhj49ZTdsyTG5FnuTdK86siD8jDVSzAzHMxMz44xGdwg0V+lTH9T+b87vZhAJlAXKNHfRSG8lx1dtc4P6K9OuNYu0V8lwUT+MFOAr3LwXrLsGpThzkT4jwt3wwOYOtPb/xLaGmTpFqdjLsQhv9gW6BYC7tIJn7bnwYhcsOSVqyqQOqM2KAPHA2JPWXC8ORhvbTvQ5alcmR+MdSEZ6zxzb/LGI473epn/1CYWk1Hm6rzLubKuBBa4A57lXUn/VzkCz/UCChV4LvDbrTJ9wloKLY8zvcq5CuBq9e6WyxtkXM0dGMUMY8SDiUCbjhO5oo9Mm2LMdmG0Q6IgMdDKS3Ztv67ABcYcuAet8rZ56FXEBspln52e2khKRBp0py4PcveScyNMfWoH+uMDeKBFG5DXQYMOAw3ysdH9cN8eOcn3H6JBy1PdaRBaeiMNsgt/tFOReUCDVIQGiW40KCn1UTRovPCds0fTKLe5k9Y+3nSJa/EDm7QW9e2TqyTqUGuXqMN3dtQMf0Ywmjo2/bKybUM0yrW7hK+Ad/QECSUyDyTPvF2Cwg68qxHP9Go5bR5aYKKEjZI2StgoaSNs1Fql3H8juaWcN22Ys4uu67/MibBUIMvnSjf5XIJUbxn34P15z59yt+916Tw3PKTz7PbxJQhLWs8QovUM5oOUwUAhg2S9Z7TeIcxpx3d6sdXLrRFAFT3TUe+pEzI+k/See93qSsqYSG7oc9Efv/8z/bkAEtJbbvTnRTvSlrcI/Tlh7aA/rdq5nfRnJkmTDbOVS+hPbif9gTFw0Z9rtk7687HlQfpTalHe/eC/oD+I0yWZ24XXV1glWDI6Eat/m11PxuIFGAvfjhdoEF9vwhMbeSpzWo2WU0H/6m348iJi/gjbc26YHzH6LiHDith/rU3C6vnEUvA7G+LLJ62PxupHbIghy2wurN5q/f+O1e3CMue/xurrbC6sXmL7M1Z/hbTytkXC6ql2Cav3tklYfZ4NsfpViztW32BzYfUcm4TVexgR3l2YPa4BoNWrJ4FWhH8Ju58mtvF+On/ZMj6E72khdvE6n/R4wO68lWB0iQvNkXRy2TWI0ze4wfEVr5QajVwu1vmL12/1iMt4x59xuF244XDhcMYKOHwKV+43BHH43YdweGUHDn+HSOOdOHyHrROHb7c9CofbhU8c/waHl4sHujPBgMEPJY/Uv6kPY7xbVN4SBs+0dWLw+5b/FoOPtnVi8EuW/z8xeIDtv8Xgt+x9YM3hyc2BzcvSJNvStytxxX0u4noffUwpnZan5T01WlqHn7Z7MuIxTKGODb+sbI1eOAQw7y4h1lJKXgIc2aH/69IwXDccoKcnb3Um6oYRnuCSJZ5xCFes3rIdz7INiFGgBnIukWBUInFEub3l43Whny6KlPOjM0p3pQnrvsZq8lz7JSj7ZOPZQcBv2JKNomcZru6rliEdNOGqiDShpy74X9IEbN16i0QTgtxoggS7e2CsXDgZ9dCfucH4T6eCyRs2LeCOPBIfrWRQDtemTBN+E9GnbNFT04QGESlfQfzIzzvpyMp/s3dWTPbOPCQa0rYh3in8IO+d9eQnOzv3znRC/2Ode2cTT7vrllG64j0edfK3ANbaNGHz0ZFHqJYCD8C2DBWhaAnxhFS+FXKqgsgIZrxwwRbBYLv58Z5MfmWdWED5Mal8kRXfO6Qieqan8ol2LyYLuMF2oPnKlnhVM6MfKt7y0OArGqm81boztfmWB91a59kS7xHL4Jvtv0EYd++WMHGM34EwRnHmk+QI/Vx9MEgaKmUbQLV/pYtf5MfiaTC85xxPg7ULg9pjmJcZrKcNS4V6UvmuFia1idRhYDSM3/5ujOLsvmQ8KRMpn5TxI2eziB3XOLx5flNlvCzhBALE/0yn8mOsg8jJ2FT+IyvuR9eLVyF2iLW/HLsVYj0gthFiY6zRcuw7VjxbC3TJI5UfaMUTtfViEPj7gV8F/m7g7wt+NY1rD60KtjmzoBffA090a8RLDIyJCvuAbx+k8i9Yzak3ST8Wk5MHa531YsgYpL4hY3DXG9bLa/XQNlyRVITUJ+ldpbSDnxXf/cn4pL2s5cJT8yaTMcOTuQViZIJn7E4YvdDLVNtERQH7lvGim2V7wFWqbRbE/uWBWMXVAjEiwSNW9bOSQN4WRwQ5Y4r1qYATXmpXEXwwA+gyW4dtVMeyyM8Nk06O3XKgW8p2K3EK/5T9PSpgVTqkNebhtsY8yBrTMg3NIYucwmxHofjlWCr2ZJ0EPRftdEyu+OXLqDfHFqq4IPUb3AaQzT57/VtiH502goqdB22Y5Q3yiWp2XSWnC+M5QxjuHuJrF8rW64vwLauRTG2zl6a2uZtmKK+043lwKE/tOinerdyrrIXTq6u4JPVIZijvtEPrw0tZL18M3bE9wmp5vjYrRJ8rHn45Vzzycio/yNIAZdeSU79Yj5LGc9DB6d10iL3eaNdmpfK9HpnGL91Xl8SkC6lOwEdAfX0s+axHBf6az1IlXkR3ky4Md44BPIRre85pyU5+5+ngB9Z4yENrXNpbUsvvY/82d9f8+Qs0i06Im+KDyNm7Pyo99nkyEQy92b9lm+qIcEHEOb3u7M8kMbr9eFpJyxwRTonI5112XmPfNlAa/5bKgHHMY0wlt9CAN7xqmUiiVXTfw3vu0lu9/BmvuGfOhwy71PGb9J7Tmw2fJaefVwNvE3PA67anH5Tnq7Z5t6lue/lUpOB+OWrm9gHVupraLOv9dq6iICX1r1MAN+UBKXqkPJXyo0hVXhWpgomi8vi+VEZUlrTW7aaoaI/bCp9BoT4kFebHdCdxx25YwcCz4Ofr6h5qacwlKuJlYhOhTAyJpVt60QEtIQEbsD1v6fbHIb60Uf2ovmuS6RbaK+G8wkZP2SxrkYQ7uP96yjiEaJLYJnroG00p+7+5/Y3SE9pBj+iW4s88lXpBGp9MzPUt0Ph9TACk9yJ3s7TdoTORi9zLfWxckbqP9DNk6PUmr0HxgPtClF/WKYctSD1eR/V96SDMg5/ObAyhoijNruSpUIICWuR/nrqdE+BnU2hQH/srS5EWJTLJ8PvtpsksbXib22P0GjSU2dnSi8KTUcliyBMNdcohIf1/qqOidBU3QxaFfnqHVo/lk9pp7eq2Nw7+PbkNWlEQx9dFMroyett44RuRjljywJ6Z1zv724b2VjLxgCdmWOMJnkiRre99chuahwL+vAV8dnwJnk9MqHCt0wBTIPDnn72KNsuuNYxcfWB5QBm5OYBblDeUn2ANMh8WRjoDSoJMDc3D6cCSLia0M0jlv7AGFzQ0j4TSj1m7gW8U+A5buxeYAR8Z7XciH2fKzFOFELLTOsZsNh0yfWH6zlRvumY6LDzjHAOpXrfj7c717FuowcZXACWNVFsvYhnwc81CzstQyP6F7KaehtAeg7ItToFpcIRr2TGGn2v6cXshdgyUYiS7ZrXseNRtGU/X4J6adF/FDeNZTEdOtlMajKuvWQDzjDJYvjgiHt+R9W8ZQSNeymd1hggmn51izGdnQB1zjHZhvhVP/szPKYW0wA/1+Q4tqIdoY2ib19y+KXTb2XH+rff1NuExh3/r1wvAP7eX2SaEOLTMYaHEEULo3lTBZAf+BNbzNj9zGfLYXjZFUK+yh09Q04leschl36nDMg8LqxyUJqjsdEhzCHK6CLkQPy8shdxXAOsEbxBAPf99oufvcSDwJGr418OHWORTG9WXj8Tap9uB91WZyXkrrbqMuRUSQ3jgdxkqUm3zWPqAJh14aJkHHs508MA8rEkt/Q/SLqewqh37SUrzg/UQYMZzWhFUZIDNI4ROmCwqK06L1E71gDbSIzyjxULOgqwkGJNnHUnQthU2zB0S4N9qmqu4rfKgbyvUWDaOzVng5AJstC9y5SVuXPn9uqmpODp4gv73upDEgljU7TfU6QFG8d30MTBSUN5SfRmWGJryATmBVinLHPPkk/OYr7lO2Vo3v0d5r4ipgMMRj+vLKJt3F3qET9b2+V6D79XpyWnrfjZpHuykvxgTRnbgcAy6429zcwGSu0FfYvVL9BX62/rYuUvmDgaZJ5bxb5nh85xc+maQuqSStrSHkN2c+/qpwkYsYT6+YoU4JdeMEpKfzYOCnKqjMmScdkFGgtcASaa9xnYHPIo4D/d5D8ry2Q62C5E0pRPogR26RAXv4dH7KjWA4r/IdlF/Fdkx6Mlft3iScyHpQo3tQCPy29ZVk59A/nqsG1+LJ852Zjew4eW4H1zKhoEbWlzKhhQ3sD3zgNPIM3Dl5QM4dfkZWFH4ahZKtSn87PYGdqfxDHk/HPgxzkeOnwLx243fQdpa4NmyOHOeFJ8K8VsgHtN70ahZkOIfb8f3W0+T9Epaihvcji/JniZpPeS46Paz5ETS94RnX2HB1mKLpF97PNAaKc7vgZZIcR4PtEKKE+1/bgFn/3MLrtsrSAv2QQvSAT4knaw05oAb9Ki/0UaDD1ZOSD9zuSdZMyDN9iJr5jZQxsaH1wxC2gngh+xv4FqW4OZFKxX9OCOtnvsG/1ZhHp5YBZrsg7Xg+eJNDFmLnStIXtP36zJSx3euoGH8QFzVv9RdByjebEMJ6jpg7SesZG36+be+8ObvsJZ8cHUG5JpxNT0DafxgbbZ2rE0veW1ufWBt8rHqlhB1Q52EGw84tB1QH2ANiUYsRmmwPBiDgh4deHBcBx5UEzxIRmBuDODTZTappI0OPOMSU44hZevqBb7kFoq78hovS26UuZj7gIktSweArDOPnOHvLksmgIWglDhZO4ChqcK3FnytQeuHGMq/tWieCuRDGM0AcxmOZRojnT/F9hWTsfSSx/JDMpY4U7/XaYcdIXuNIT6/1OEs2ASrvIf9NdRQaCG4Eubr63ku/cMJCctFe7bZX8d5KnpI//DJA7uYKsDf1+TRrLVSAAlfz98egvgjOMW7RUsJbnqIow/sZjaTMURNRLKwy+4P3IIsW7xH1fR0W+euPck3/oM9SZrsSdLynmRKhEPYYgGeHdx3LSfEifKeZA/+kLNzTzJd2HQM9yR3rqcpz+866x1xBLVfKsYhLLPgrTyx+gEgu6X0pc0O4byFLjkhpozKYv4m9BMvue6YaUuDXw0M6hIcwhckTdqoenEi0ZxOHIWWyw/KbnjbWaeNEeo7leaPBIdTsmH7Qt7Hem8NyIyvcmbkgz4S/nBKtnSnjSqyF+UQ9BYt2eGaKuwTv8xQmzyhjKtOT2hnsAXfEnfdgYN7V56QPo2kz4P0hSKuYJcGc/R/pcG0CYHtwHOruIoZsgbTLGswvaHmKAvqHlHTM8qCdyA4hB6WGGhXgTOmDEO/W4KOxYD7tYh6Tlg7bzoET4uO6GLRx0Fao1PSwyplPaw30cM6hBYRS1ri9C6JMXmXe5EcPS2ShtMhdLVIGs7VD2g4k+61Z1/21tRLGHGmFV/o9N4GOLIihZ9ufY3gx9cAP/bgP3a44tOsL5H4lwnefFOU8CZN8GYe9P89u7sGcxvRYNqEXLukwZwi3HC6NJij/yMNphfRYDqEJy3cAW+iwXQIIy2P0mDa8I2attPLe1VwZajDxLIPybhmbbLET3D7dYx4IJboMN2t2xBriaJLhzlF2OLUxhAd5n7UYXrZPCY/qMPc8JAO0yZcFl06zCnCq7IVxIM6zH2SJUSMV5t9BeKQrf+rDhNtshrJ2O0TJR0mV/HvsAdAYJmEO9a5a6Hfk/YWUQf9gxsOueK9ujXmoEaeO7yXFrFAZbsHkarThHecPZoEt/S8217WR8Jwh6T3bAP5ZVkV4pV2YaET8Uq7MM+JOr2JoyRtJv85rvYX0MK0LSQa96Ng5a74SJju8CxJ1Pcnq/tph2uf6hobDeu5wIFaU41Ok96P0xKd5OfQW9RJ5pMdrh78rHYp55COnB8JrztQm9ld1zP9UZrMkUya0NcpaVloNy2L1H88ZUrFflxHR+aKhwfnikfGKltXvZCYpdGXNElvRoV+96BtCNrTu9mHtG175d/j4giCiyNkXBwV7xSuOPFMDt7ihCdyvIkWswfP2tFCBbWYy5LShJNfIC7Gd6Y8zzysw1z5SB2mtD9WB3ymrAk24tvg68jNS7RZL+RbaOCZ61lfwIEbQHaiQTb3k/0e4PeX/QqjWZhk0zKuPSkJBjaTcpRQzmKLVMZefLMWLczlcvYavQlelUraaxwE+N8LQlJ7PFv8vDdwe/P0QrpFbW4gdzFtINaROH+SX4X2eLLfx6gXhkJNAcDResuvlquMaJtXD9yzFPYxoh1ePRtEwv5Qu19HffQ+qbauFv8yGupTy+X6Qx2uEQgAv2sEAqHX9VYtoxcs4nRR6Tuer3XiOf2xfK11CrgpfHcbA/F/T/6jTst0kaE8/oi0w4jj20DoX6FsX1ME4yuNMS2HPeRx9iBhugJHWvF9hD4ka65+p96zEm+FUjLrKpHWOoXTjnpRnxCrrxdfSFgC/7MSKnDdEPg54cT6Pu6gt3QZ1nSpY98yUY81XYIPw1iPUyh31otjRiP9HTMaTwQpW4Pc6K+nTH/LKtcywVD2G2JwGd6r9akzq0pN6sx2qAnMvgVy3Bkooz/RBV0Rx8R2KaAHCJfVbWLsc0wP4FOPO3psG88PIncePMeEQswnjjCIiYaYAIjBe4DKHH0gppcTrRYfMz8HNZ11PAYxwcSOIpLEfOPQQIzaieMbTWKqHf0ghgZqGLAqn/VYVcr6rZqlA+ywCmUGkBFSQSZYBDLAxv8heC3FJrVoOWnRDUdnixaTFl11dLZIT1p00YG1SS3KIS064+hskZG06CsHtlpq0SukRUcd7i3qUjJCJ7VHmRrCQKs2YquwlYnpacIVezXuZohpEzSAE8rBX00wEvpPjKXiHq8rFk8nULHDzl8Rd3uM5/McKNNcad5K9KRXmgs1EemoJfWKiND14C9apVRv/ClVCEkVwfTUpQk77cXs1vBittBX3Xpdn8j7WdTyfpa69XWyn1VMMOHq+90O0po88OcBLiwWv0tIrILyE9StqwxnRCpe2URpxKaRbjgxG/wdd321/vAi8m1z8H5XQifed0h8W0DOcBjhj9pfA25rBNDKBhtqnbzNw03jTBNNZYLG6W3+RFCA5LCU6JYK2X3GzptDUC8kcZVvKU7W5LPeso27N6Tbb/y5BnGAZJ+0ydOVC3h1dWfOSTylyBcD4/G1aNRcn4VSAsmax7fgiVarNYjos9VXpTtMUvjh1h3sr2rpxoBstX9LIB3B2ISBFtQ17VlbCqU9rGvyby1dIOmbtIxVuGXvD1BjFa7bf4S+a9rxRqMfoe9zbMrbXj7DzVRkIuPf+uzKccx7ITEM0vf1wCsobPTSf2E1Ofzp1AkSr5CwcgByotfqsJ6P7dp+/RmUXvz8hpd7E4kVpKE+RGKV7l4iEqtCllhDzWXCEkcojHdGO8kVEHqwV9mVUJAgfbTM3U65R213yVMd2h2dmwTplxgVK8s8LZWqJKZMSHJ4l49nvFuiaLzxYouMB9+HHHgP2gUZD24BrIR3Uv4Ert8IjHkvGe+fxNuXFC1+isa6ccx0aF2qbTm0tIdjedl08yHhJ0fQseUQ22JfXhYE7nCgT3OEKGIHmQgjgLq74URvByMQFPkIeVUh6+1CAT5Vjkvk5I6S3E0LNCfvcW5RMeLPfDa0GDWriDvz2bA8tK3Hd9XD8+YILLlZ0m5rYEMzS9kw+MKNAxj/u/fHBVX8+7NHePIoL/n3OpdlN/IhePdSM8Ao0oYm4HkUwCvsYJPdLL3fWFN7DDn18fx6O2Kd0boxsoV3D/6SiO4I3ch0LXA5B6wSVx7hZuEd4ZnET17zI0DhFptfv1jmxzJt9PD/Rauh6NBqlOqtwkpZq7EyEsNTBA8r3t+Deg2/AIR16HmyJImrfH40u2k1OiHnkVoNVYuf6mjLykDUbFypmw6tG29LBpibDqvjPMjhavkOpBW1c8ad+M7dRty88n/KkhncIwDqargk35cV9NB9WR7yfVmeHfdlFSSzAK8rY4EH8fxF7t0wWeOBPSuyuM8pxM3zb/3bgun/4awWwaxCnrlx0BPWKpXuhVqQZXFlEJoPcslSDyINVHXcEeqy4S5dGsz8g8GbDMuT3W8yXA5llVsl6WI5jEuKBa3frxvfKp/GoN32NmK/7WGYEhqbMrwcrTYuyv3fIt8XtkW+L0yyNWdl/QeO/ZU6hIhVRPuBGKmHrPv4sUNqqf+vNB/qFq26sS4NcNEUKxX5I0gtKLH43PZQuEstbz8ktaQT24txwgC7P9CNjtu9Bo69/9EBjQzFknzSndc7XfLJaMvmm3e++7NOxPgf6ESSCB+eJPPhS4Gn6WHFc+9OoasVT71LOpHufH83nUia4EF0Ikn+CirqjLuNXyends9SL/olIqcWlIicWrdEiVPDGv6w0oBvztv+BacGtf+ZU7tkBcpCOLXc0XhmW9k66iFOTbp/ReLV5ggf2SRe7Qjh1bDWcqDv2K89FuTVcjt4tdzYbgPEy+rWoUu6FEic0Q0LckYzrJ2c0VULckaTrJ2c0UULckaMtZNXa7MgZ/SEtZMzYi3IGQ21dvJq1y3IGcVa3TmjUY/k1YaRUX/JIbXoA9KiQLcWmUiLvNxalEda1G7p5NX2kxbdt3S2aDdp0W1LJ69WQlr0T8uDvFp3mVdTbURejbQoFVvZBXg1pVhNJMckNz4tifBpLn5p6kE6Enkl4JkGI5eE403FM02Pn3ngLtRJhD+6O+tFlKPnCKdlO76rMn90fC2eWeli6c+8FjnYPFl4ygn80bM+5kFbH9+asrVMMFl9gOa9alG2faBw6bDOmWuJ/OMPXxfjHOFD6zkoY7+oZc5VaKPxpNmgctQm3SM6XCrye8Z1suwdF02MV2gRKyP22r4A6elbMFvnOuz9Stkf5PNJSjl8npxPQnkNw/2ZbwFuvcx7hZF2rLtKRFpxDtrPOnAXa1CZpA05d/Dn0J0Er2ySdrPWPYBXOnazVC1KFU/0IbcAs6wk+1mN2DbApwki6uW3z5X4nEEyDevgcyrOdexmuWiYAbgHwWKAcftJlPgcw/4Xy7C0TOR11HQBcgufAaajt2FbAN9RBW547l4dvR05BuWQqan05luE3wG85v1LXVco+YzFp7xrhSfwOpfceJ2if8Hr4Pr2G4Yx+Q/xOmjT6FVcrO9anPmC8u6med7bu+iVrZfn9SDuhXkqdO+enRcGLhXZtSxzbp8FxXOfX3Bl7ocLcNbOmauESuCCyoQ1AD3ngFNKtgYd0zKfCLPE/kw4/PoR/FrKegGn4w2cjgr4mI0WLeMQtjmB7wF6R85REz6mflz4/4GPUfBJHk2cTwcvs4M96MbHTF4TdkzCvSfGnjNbBJ1TG3MO4MOv36Byr3/Lj2gZizDEidzISrJbO1n4rJ2Kod+XOJHtwInUJ78a6nHbS32O8CENovJLwonQdtepxQ5OZFoHJ9JcR5f4DQdIG0SbfqmbCK1yOhIAHiYCBG8C3njigUllCX/iNsL/Lbex1o3buCrDr8MicRvb9ZOF59vdRx7igNv4cO7E/2LsIQ/ZT456xLkxrO2UJaocfPMtbhadlzt4ju0LpHNjHy4tY1ArOj/VXStqgHF4UbauN8BIeLcj51FvfA04D/l+cMOPMucx6N9yHts7OA+vFj+vK3U49086kPNAPHHZLu1Qn+vgPJ6Vdq8I59H2CM4jOfVRnIdF6OagIs/9C87j6CM5jySBdfoDRpY5j/eoAWPvf3IA8fu+m1QN8p5BhLdAvoJqM792Al2Nrz5D/46+UoyIoxN2wv8QJsjNhtH8kA1jYIcNYw/ZEj5b2QV4kGwF5J2IlowunuMPYgXvRazgJwiniRU82i9WutGRx4DnoM3PC2VOmlCPg86gKkqzW4wYcxg+Orb7ZT+dHynttNVH5wv80gRhl2zZn+2m+8wmq1BZGQR8zYlH0qnpRI5/XnhNluON8v7L8jVxZofweTvSqTiYPwuR4z/VJW/xNg82jTKlm8zCEyDLVwm9gf/163xzoM2uQHndJalj3Fkzyt8OYStIxv2Zs1DaBVscnj/2Q1707ME3gWbgHkwPkOwCbIpsCuYMIaLggTPISDMaU8dJNGPYyoEeLVoPpBnbFiDO6NmujXHJxnEynvnfZWOz0ACycRX0UZaND/QqK3aTjT/7j2VjpBXX6iKhxMMgF0dWeAGt2EpoAyXTBolW/PgQrfgRacVwjHn3IVoRWaaDlh2zZUGZeY4sCIEM7ww6lgWxC9qzQC6uEsptZ2HetjkozVlTremc6Wy5Ngb3ReLKkBeQ7Vq6nGGqwYcn2NY+JB//Drj2eWGlo5Q960b3a2U+wFMOn5P5AC8SDq1APgBvF8mBDyjaPBPrkRe4fS0blFe3SMvgaxImli5+XpjoIDcXAn/sf/dssiQ1X5RPGy4mGO8mZyajgSdvb4FkfKNDvtq2wEVxrrHhBoTkxYTqZHshtUGqg+l3sN2N/SC/606UAQ1fHBsvQzzK0cn8Px+y5e/OD3Gz5Z8gqG3+AP8dWIHKJvsAAw1bnsh1WysvVeE6+lj3sXwyqzsfYPlIt4usuWbrWcByl23amLOEwsX9hxTuyw55GylchpWKkWVtGCvsf0LKq6GKLWfN/7v9gKIY6ZspWaJwfsOBugEfdbVOB216z4b0TQdrrZeV0ugOPPUI+vbfSdNI37bpLcK7sjS9DegbZwF3HkrEuo4Z3vIvZ7iTpm0jNC3yETQNa5jtiASatu0BmlbXQdO2yTSt9JE0LQv6rpAtCrKg96VEmj5vXP4Imhb3X0jTEk3D2a4n0jRisZcladrv7P+ZppWDNH32v6RpOfYdN//mBqeqIx4rFUxkFe4sIWyWWDx1CvB9fkuVNEEoPPZSbhdVQlwXVevZYFWq8M/j0vuSAYzH1UFp+GbV61kD0xEaN4KsNfJ4bEb4ytiqAbrYdA8o63VLeGP/pzwGa5d5NWjTK7MmCyssqmO0JnZZTEYkSN8eg0OXna7xalHRmgx6M2WyRo67KwbTfScIwyzSu5N9SNkzoeyCY92g7PFVobpupOwJlu7kBcrfm3roAknMkxYq6remYJIjGXJoj3lDDiqWOx+o+7QpEFq70UlHXXB7h3KZ/A4l9u8V8G8J66Jaju9RPuP3yLco0T54ZFqqsNgSkT0C3AUWffZwcOdadmYPA3e2pTF7KLjPWSLWJIL7jEW/JgHcKZada4aA+5SlcU08uOmWiLWDwU216NcOAnecZefageA+YWlcGwfu45aInFhwh1n0OQPAHWLZmdMf3IGWxhwtuP0tEbn9wI226HNjwO1r2ZkbDW5vS2NuFLihloh1GnC7W/TrIsHtYtm5ri+4/pbGdRHg+lgi1j8GrqdFv74PuLRl5/re4LaLjeupiKDP/7gbpGqHz+9ekGoAfOHw7YDwQfh+gO8afDnwFcBXA9+r8M2Hr6UF8sE3HPy94POHTwtf7G+QF+J/gK8Rvi/gS4X46fD1vBqkGknsR6gNTuGco39vPbhnHJ4AFTvB9y34/OhG8H0JviA6YiPuH3m2dKP14PsUfCH0TvBVga8X3bgR31fxbImgI/Kcwl4Hyl968P0NfFp6J/hKwRdHN+bhm3GeLfF0xDtOwQS+obQefO+CbyS9E3wbwTeGbgRfLviS6IhNTmE1+FJo/Sbc5/FsSaN3gu918E2kGzfh+WLPlsl0RH6qMMnq2TKd1uc7hYUQN4PeCb654JtFN+bjSWPPFj0d8W6qMBrSvUDrwTccfFn0znfxpLFny1K6EeLirFTESNnmJegdYOXb6p+ioifd77G8L+qU9TOLZhXNLnq+aE6RvuiZwknCeOek+3Pxt7aJQZOEMc6oyL7MXvMkYYQzHnzV5rmF8wrnF75QuKBwIaSOc6YIY221zQl0ijDaFhJZ2zyK7stsMS8uMhQtKVpa9GLRS0WThFBnCOTdBqV0I6WcNL9ctKzolaJFRVnwq5r8uh5+9XSmgc+/NUc/CWQkPfHvBL/FMRL8v0OK+44CElsNsZwDy7oAsc1y7FmI/Y3E/gqxvzomk9hNEPuzIwL8H0LsRQfWtgl85xy703Y/DXDcPqxgF8Jxe2rB3xCO25mCjxCO7YMLdoJrsU8o2AFuqz2t4ENwW+zpBaXgsnZdwQfgNtszCkrAvWFfsX9iQV8mnkkVmuypYhRFD1XGoaVZ9dzCtGts0ZVr4gt/uyZmfQJr3r4M6NikAv/WfdC6jQ7R7BTutS8vH7Z9NZT0sx3i52JckYOKGlzyViENdGSr3mhaVfiXwnyRnzKMf9K2JqP3shQh24qnLPB8BWqgikUqPvH4pPvG5XRfo3mqMMzm2cfzykrdM2VeEd143s41pQiLrJW3VV5zb/t4v6qjNMdBbvgk+c0Lr8hpfrU3NHcb2ofpxyQyYxgod+iEkmvswry/mqCevrQmyUxF/Z2jfs8XqYQvm6mutc1Pwjega39TMKNmatlBebXsQPiS4RsPX0pen8Kwwt6FXQsDC0MLexXGFXYpDC+sZZ8gtzXls0N/r23uoQkqrG2OSaltjoIvEr4I6NFIDc9lWSvhA/d3cK+AWw5u+WOF+eyY33nu6eJDnLI4uHA8YOgQExU7jtet6xZJ9/0r9Pyo1ZNJEVos1EC0PDJeGSH37yXoX48KqLPityZqYNL5UrFlyGXv1a3zDgLcLRjADN6OuK6n/VIztej2kpaQCbd/Wx7A9GRgVLq+D2P1bvLY+xMPuu6Pn3AwRaixnIrDsQ+4WsQGqT8WGEdE1SU2yPgXbu8VemgCMxpHUTOkyZsr0Ilck5HW1MIv+eKU4fnitOEZTZkM0iJGoB2PNeFdunhf7k5tN3L/Lt6xi/fu4p27eL8u3q2L9+qezZLu1EVbXaQ/9UCLvzw5kOLARdqDtCj0+2AVxV9e93v5hO0It/tt0SXDttGJJZ/MKIs2pQoHbaWifkhG1bDt29Iqy1OFUpsL6jLbZ5SlbksVPiQpNFUny1O3F0AJm2wzyhiI3yLHry9ntr8D8dkQPxji19v+KFsL0sFcy9qySnAdIqajYil+YzaM7sIEGN1sSJ9lw7vFjyxuaB65cnLo+Ns3XhmXqqo5mvzk+aUHt4L89hORV1SGrayPAc9c/wR8y3qIX8E1GXA/7yT8NpxbZKjcvx5STOIpv8UHLhH9Np15UqS+xBsVDzA3uY+NfsN+Bb4LOaybwMd8kXy7roFdYows3cHOMdJEUwZwRu//pBZjixrE6d2eCRl/+x8rYLbpd2G21yXXNsc/63/ev/UdvFWvXFPSADmf4M6U4ziO4haVa0xPTaKiVxx4VozOnlGWBGtfQUZnZtWH5eOYkRBusZaKWxJCY33PU5p8+AVf4GiqC2iUziTFa35tgnGf38D+zWhiwwi/WQt+KGMKNXDl+QbxxDAq9tXz+Hspu7ND17W4oZT9qCM071IpexQkljiDSyJ5rgEtwONKYJUZfY91KfE91r/knSpsfSnEROrwjiFcEbASjd3436x9dH0IFH5hb4AYTAP8Xzmmx9YZuabyiwDTldzvHTvmSffEteEldGK4SRGLO9+Bpi4lcSbABRXUvba1lKa/6RrrW96zEeEX4dodptW3eo1DOE9MTBwbC3CK8EoOemoCTTPK0gCW9FYX7GStCSxB94U1F8rTtl8B+Emzwmio8Ra1+/LLCkn3gnJKxdcTr7H1RukexdN52G68N/IisYI/Ld9daV8rjdT3bv24u7aBfR76fDizlD0E7ixDA1uZ2cDqDSjj4Y1NpWxV5g3gz/cAJJWyf4ffP828SW7I+9h4itsJ4TuZK7gbaKlULZ1mui3X9/raU1wE5GHJzLr/NrGG1lCa3qYrJV1MeK72KEB6A/ujsVfJDvbjK29zbxvmxzawP5HXkRqgrxBTHcP5GxZy+YZYzr866V46tHsglPuDESgAmwK5Bxl7md7g/gAIGm/8K3cL+mlCXGx0x6QuHN0A8RO31bJd1DhSM8pMbM8zF9keZ0Zzi6pThZ0WHP8G+DWxalP5xO1rcf1bMHwF6EF2JrYZx3kCjNl7UPMl+Y7QGwRepNM5AYaklgFr8VzV2zCGCzl/kJnxXrR34as3SGNxQx4nzdqTkAb6d2URlw+/FxhwPnjupgHSkBM8EVC+HvI8XxPHeZ1Zyq0/U8H5kdqerbnNLTXms2vJV8vmwHgfgTLwZawcGLu18B3KNLGB1TifI7mMvD2cJ/z2SaZrbm+S8CzDG9xJcCsNN7n1xlXc99W1LM7J8zDG0plnxCm1bJZxDD/cepqLNfYuQWjClfY2l30l/Ng1dpRxINfvyjX2cWNgSVfTKehLLTvGGFOC+CLGlFTxTTNV0SBWRidkFIO0vW8Rxf8MeEMHEN8kSmue4n8AbHkWsKVuO/LrdWJYSezx91kFzGY/4xDDzM0uyD1RE79UXxCZttxA6yPTDy1R62eZZm+5tyRC97zpkCFY/1j6Y7rTNXNMuK4vWHvLFJAVofSsn1lVdQM707iN9am+JuoLtrHqvFVQ7mV8RZbdZoxtRJpTe3bik2uys0fjOsU3rnCJIu0p3h76JL4Hgm9fJSg9KaRL+77tN+I1oD0r4XtLpkFTYW1nwJcNYdxrx/Ia2NkwtouMPwOFrWWLjYhjKsNWQgxaxNSyHxiT+QrxMdYPZm0WQMHzRumlwfW67yDHfe6kDvuOs5t0L2zNY2x3gysuqaXrmvfS39NtZinDexlfsVT1aO4knirT5bBU3nouKnML/LKBDcgczTGGkVyK7iTE5XJRhtNsYOYGNsgwjFuY+Tp3KhOpy1rIn89uz6xlSzLz2VJDv5KwIpzFfoChMmC+AuX5Gn7+1/KM7a+lpQh2Z4P45bBXj/cpWXXsVnHT9uaSmZtnb3kp/WWdNAdB1hflOYgVS2HsG9gmY1BJnyJJ2zUbIOVliLsla7/mQHgZhJuNdCLGlACVesUYBLWnb0sRzjtd0HJ9DXDJAC3p2/8H2lDtDC3ZyqqNiDH3Zd/jlB14zvfqVta3I6S8ulWcEe8RS929+raOtCqYb3RO0I0nVOC4BU8nbQEuebQF+UsqGnmysn8ghgccXQRcXwVi+nBTf1PMDcD1ReEmb3Dfv9HA9oK2D8zsSTAacDuJiNv2cp6GXibkfpq4wZnruX6Gb7m91nx2IMzvIEMT52U4ye01AGYCrJAB4UEY/r2BZcEfaFgPaRtYDvxajM/76EYp4MU3ZLyCdyo2Edyy3nj+BmJQ5BNOkl/GQ558wJjrjZegdV1NO9igKyNvtnALDVXcBHLis5bdbshnS8AtNfo3ucMv8lkIwy8D/GZ9L71vkI08FfzdBczjGsnVrYsPuo/s6ta5B6WxXd0262CNPLYJzs90n5Ox9beYmQYxyHMc/4X1EDnPPo7X2HAOx90J9122eBz/iXW/HN/TNu5OL99KiDNby+U4f9s4XuF4rATPZFOxGXUNMDPB4yne4230fZxG9e0akjFuJnBUU1Oz+fPZldzEMJ5bGlbJZajxjmdcb8uXztpCafBE90zTbNOhpc+bqs0gp8zPYZXHc1iv779hQ43fNHtUxPMD2vF09DjeSHbh39Vtgj7UNisX5bMe3+ez1HFG+Fh0D78t97fa8XC9OeVry6rN8XzfdnyLx+f82pKZJuj1/ExoS8nSnOLZW543BQPtWwm8z3Pdn++DmP0i251gV5BU56G9NUJVSKy5JkRDwf+2MGrQ0ZrQ4SH4HpFGuvV4LVk9JmIFuwXCOZLNbmv1vFq20HgB+jUCeAO8dRXtr6D+efns1jyqP8XPWm8id0B2kUtQQAkmCHeVw54QLoJwMAnXsu8bozQgJXeFumMCz+09GHgq8FzgqcSs0Xqcyx9ZtRpfiRzN93WCm3eaQ57WV13LDjXibdij+e7ODSBHPVYUVRJK8EqUqQG4QZQVkIuuFL6wIRddKcy0dS0JPybxQN3WJ1UgFMQ+MMu+F2J1MTAvqcI15wB5/K3tCO+hJd9U4RhjnijI0x24W9rrecj1DOTqqwshuU44H5NzXYNcoaYwqGs08LxnSb4eD+UbdKG7Tk3ymZ3Bcr5vIF+YqW/jw/chvC/zdrjHdBD8P30v3dtBnw1WWcGPdufdwR8Anxa+vvD1KTle9Svp5ed/avExXTWpeYnzmFzzeqi5jymwpKKqoXkAfRgk2uyQ58Y9B+knQ/oq3QGSfpqzUk7/UjvymCADwprZwe6rpvgX10GIrr5NUUtu0/Q4/sV2id68owY+DOZpjuMauxvcJxyHue/Ja/d4SzpiVqpl2jpY9SSOvqTifIrvyymoFt26+/Iviks7AG5ucd7FjxUjTAMkVeM5zCfWhRZL7g7giC6yNPDup6qls8qnDGdr6GgqWrJMRT6xh0nK601e1UToDCvJZ58meL4PlPAXgPUR5D6/BvZpg1spGumsc7xJ8vcpfoyRSvI5g7UrIe9LgLtOnZF4YXtug3h2WHGfacnTxoVsB3oWTQ1Q1YQyXUtCNmNdf+T2BuhI4rncdTzt1faJBJe/5xI5JTEE6nCNSBcT1fKPXJCx+X/mUoPwf3xJSDEV261mG1PASDLPUOi3VzX0/Uw/7p3qRVxFNb40/xJwiS9xcWdq2afw7i1Ya8ONT1b1Lh5QdZH1M8Zy/aqXcHure5SMBnlmq3Epubt2w5W93IZySrPWlGPKNdXCLyYYkS3AKfsal5AUMRAuNEg4fy34izripbgcY4+SVZDvKRjB941x3D4jvk0KNRg60+Qa91aArOMDrZ+H538Qv0CLDVO3LCK3+q41TDGhvv0i6wmULZfo8vGO6Fp2snG38LhjSsnU4smHlpZdYP2hlsnG9JTN5NbWGMNeyL8G/OGNuCaePCutmxHg8uke1DRwJ8KHPJT6p11jev59yuPgjkaeC3kq5MV8WpQ+x1r8Aj+pc41CSElJ1VKgVKXAV/SD9iN3XAo8heRHLvkVwK5Sv/xb49/U4cn01n1zP5F7hm+eTtvs6tlU0rMpWy48sm/ft08pnloybXtW1VJzndy7kJQCuXd7YCSz0XY60S/2B7l9f62SMDy+ooBcdha0ayG052YHF9+FrBeE0lM5F8lJjr1GA1ABbC9p6bxjcksvP2IOLj+ynW+04xxAKzvmIPRPc4CtrKtDLN3ALlHPMVP8eDvwY+rdwox28pphzoLyLbcU1JyKHPjf2cqcHBOrDKP6zjHzkBffR6D4Z+09Sm5LOBiwP96sP5ofbq8EuuhKx3NJxaXsVkibBLU8FVbKvq+m5d8oSPte1Rz2TTlnKKR4OgxzuHKXsh9AKo09BKT7OexaOZ2nXaK+7ulegXSBpB/+rV+8uVu4a6e0FJ+Qs52loWe3SSg2Zzv0aAHpF1Jpil+a08AuVs80V5LW1NikUTGoZ8OoHLUBFwt5a+04KlE5c8mozKyYX4750T+blBRwqIEdo8YbJ0ZDHhithcChhtF9B3J02Ex5rHAMFkENX9jwt1I2S42/0n1ny+PwiY0aOPZ8J2XFsrZAazJgHN3L2AJpP5DjZ8s9L4S4Lbat4nPx96pQ81QKdKUH0hXv40AnPkkNvlDJLYG6ZsrpTZDeaJPiXGUUQdwyW3zJN4euse/K9U+F/o94qP5tkG4WiS9li9VUR/unkvc0SgGTufjE4IZKboJbrdsh1VjIORxylqg7ez7MFlLyS9U19lW51p42nNsHa30Z0vWV410tXgZxPckMzTywW7DZcH6z1m4ls32fhOauBakDoKEaoOE2iZmxVoKG6yQ0ZS2egJxL5hDhYj7xfXjAv9XwJp4qyJmH0JDOoG56KL9RTBYedyKkUya8paq2mV4s/bLbkkL20CjelN3QnKBJfohH3YCxbhR4n2UHOyrP9YpiAxtkRMnhFHCruLeexA9tbwBJGOPQerMzXgvxMXK82i2+F8RHy/Eqt/ggiI+S473c4pUQr5HjlW7xeP4/Uo73cIu/Yw8k51YDCa/R24b6+ASQj2ISa5uj4ItMDDJ1J3gdcbWMs5/AvULkixCnz5XxveutDbxHJflu0PLsENSsufiZL+7v2hdcLEmOs1AvAfhttqFBzP5Hg/jWZuCR5yIn7BEM0i6x8fiGVRhyADN+I3Zr/EYMKoiKCYa5in8LuVYvmyKG7H+flP5fxZ0DfXAJnRgKnDWlCTaVilNiGtijAEl/V+eLk9cjPlDVUMAP9CjOF6euB38kygw9tpSKMyJygE5/wwbAF2jIF5+LyWF9oF5twTdiUmO+OOPZMfyLIPN+Sm56GsP7iw1sJXltppQ9BOE54hx2rOExdqxxJdAASTMk2/S1MGsa2E+gFUcgXYbY0Pyk5kgaSv9dcWzojHElqdCKBaqaLanDCYeDust1Yl78t8DJ4+iNrEHaPYCZtN2cVrHo9qJ1bIh6Hdur+Fu2d/GYmnVsmPFbNtz4bTNVMV74zVkkboinYp86XyRuBDcdMM6mhTPKny27xPqoi1iVutp8ElIO5sudDc3Pak6SO6VmgKvUVCxJnHd7yavzYpdeAimjCGTwQ/PuzYt9KXE+SlqnjPfmJ75QKh4eepL1Mq5n/YtPsgHF44EyvD/fdec7rTkJbV4vPh2P+ma8gSA8K1hPxSXxP2VDO+a+mTZeSHMqYWWNqnAIpcfxnIRTuHyU0phMRab3TU7h02Mgp1c4hUsgLzgF57Fr7Itqp1BSvYNdWuwUDlRfYw3g/r36sdJYBlJVh5Zam8JK4iHnvWpK4xS8jnf90Cl0P94b/nc9jmWEHMcXlZ1Cv+NmyBF1vBL+9z3usq4ywMiOuF7K6gFnnLHg+7rL9624Dv0J67LdRQV16lXX3emlpFl4WgggOoZt4POxUBrpffMd7Ljyr6G8WVDe30h5l/YhjtotlJDQOQg9D6FCEjq1r+76v6I5rlp+EV21/Ci6asG31UtuYC0SLfKVqRDdF6GT4t8SsRaMd2FhKX6ZmH1jJBeTVwkSJN7/Kkn7nx5wwafrJrPymzBb8/oy/jBf1Y5+TQG6AIIZgiz+RArpysc6/TKoiJBl/m31T31+J4jYACEuwD0dfCMRdQyIBwbt60rwwk3AD7jPE3REujVSelNJnzeaHyTS2t6XJYlSK16DFVgPGJzWbiMvl+DNi/hiCaQ1mgHC8JasW8APxQNexTuyclk6D0+Yoo0e1jnyCFrmKRmkKli+P9Q0Lm8Ub3PS2j6X8VWnUXwr+ENIjaP4P8Df9bIWSsMXjC+SO2d98lCvgDZnA4/VE+ubDcYT4KKt08jPqZYQuhv/zrHxwrVq552gI4oMhV7JdOP7WPAt2IKvg1U7W4Kou/LbsU6Bc0YwTwsL7fgr/nKvaeQRSvNlM5WYo1dE0hol82WzQqOfu5n1ImPvz4zmf/1/lP15YBRV1gcMV6eL0GkCWdkRsrBkYcnCEpZACFgmAWVXRNBOAqQTGA2Liq3jBIiIEcZgGoyBSBDUEFwSDcoikpEMImM00cbBhYf4iDRRqqdAmqr0+v3Ore4AOs/7ve8ft+p316q7nXvOXc51XxTji/aK8ZQ/ffEfKErfc1xsrOGcul8afZpHX+2GUM/r6R548FgeKqUJthJ9KfxJC2OSbTjacZMedc5WGyL//6SguCkFwhes50Azdord4Sq6S0VOfw5mp6iF/Rf3l1Y/vU87PMOoSeWFHq2aWG1x6rCZN6MM98ntDk163zaDcaYseS1KSUC49ILHopTi/RzeW/He6AmcxcXw9vDiAQbSC0h/m4+U/qftsnUr2gvp1ODsw9fUK4u1XvluL28fsaZRWQI8DTgOeCnwROB44IeBU4ETgA3Ao4ATgfOARwCPBF4OHA08Cngl8EDg0cBG4N7AY4CLgEOAk4BXAwcBJwM/CqwFTgEuBnZ7eHsq8FpgGXgs8Hrga8DjgJ8A/g14PPAG4F+A04CfAb4IPAHYBPydJ+AgFztd4dMblWe1M+T3OzW7G5US7RImxZYql1J4+6Q1tAuEt09GnE2IcxJ4CnAp8FHgdOAtwB8ATwXeCvwO8DTgMi3tAuHtGcDbgPcBTwf+O/Bu4Ezgci2t1vP2GcAvA78EPBPYrKVdILz9buBdWjrty9sF4Ergv3rM4j/1SdJZT6n4md4sngZuhn/2mlLxjL5RqUKYVbDnIPwe4BUI/znCvI/wnyP8WeC34T8L4c8i/GsIswD22Qhfo6VdILz9XuDXge8Bvg/4APB04DnAbwJPBp4LXAs8Dul/iTQ3If0vkf5XwM8AfwXcCvwEws7Dt1rxrTqEvwv2+Yj7NnBf4AXA7wKHeczKlJTEBt6+EC71qJEOhbcvWsPbt6xoVN6H/SfFLL6pj0O/D8Q332KoN1AtQxFABxkK88QJZvFtfaQUArc6/MNYD3994QxwOPinQ7CPhH01s/P2Zx43i++weD+4zeK7DP0K9B5DV4DqGbrsplQbkOoluL2PVILwHd7+0opI0A4zOBIK1QLUyNC/gA4z9DmL+SFifga3I4h5lW7bsFci5j/gcoyFqgc6ztC7QB8z9DaLeQIx6+D2CWJ+5Sb3N92qVho6a/X7dLq9kxvGC92K7y5u6tCkgrbBdIPpDhME02NRU0dPmJBFdy9PJK23O09lc+j/EZLb8+msZiUrJWoE3Vy8OGWSEE93vxbfKz/o/jhbg1Gnn+t4djPoSJwQLoW7jgKXMhzs4oY3g540K+V5zYo5L14oVbbNbwJdGY7Yk9zxwlLg+4HHunn7X9b1Q8pDY+6VR7m1Mc3K+dhm5UeYdm2zcim/WbkCczUftVEcKZ3y0L3NkVIh4r1k6C0FdSYNp5ube0tnlRT6v2tZ3L1ykHuOlKZT7Rtg17gz2b9vwxedLhXXAttdaphahPmPK16g254tcO8Azojhr52H+8/A/eAeAPcLLrUMmoH/DXe6SdsF3AYcB6wD/pdrQ1amvN99ABTySaDXgJZoHwd6FWipdj2QGehh7Vqgl4AM2jVAZUB52seAngNarn0UqARopXY10NNARu0qoCeAirSFQGuAVmuNQKuBHtWuBCoAKtauAMoDWqvNB1oGtF6bB7QY6AmtAWgB0AbtI0D3AT2jXQaUDWTSLgWaCfSsdgnQNKAS7YNAk4A2aR8AGgdUqr0fKAloi3YhUCLQVu0CoOFAZdp5QNFA27RzgQYB/V17H1BfoHLtvUDhQC9rZwH1BDJrc4B0QLu0WUBaoErtPUAe1wHQrbuBOoH2aGcC3QB6TZsJ9B+gGu10oF+BXtdOA/oF6IB2KlA70JvaKUA/ANVqJwN9C1SnnQjUBvS2Ng3oC6B3teOBPgN6X0tnB8rAIQQwzbyVCZG6tJYI3ZEvI3QnYc7AfCGG6jbDFMMUwHwCUw+zASbFFqoLhukElmA0wHEwbf9BOJjDMKdhvoO5CP/9eO+G2QrzN5hymEMwCVdDdWkwu34P1U0PDdONh5kFE4m0XkS8TJh4mDkw42EeguEQvhfMIJhSmPUwFrgvxDuC9jNe667himbI33VWK92TiKI2r40uCgBfebozoD70RGReZFe4ksIZ8j/94a6dD9hXSOHeZ+HGTr0Vrsk4Q27oSq927U9GCvcaC1e/7Fa4DKRX3RXOsjaXpVfGwhGP2vVd/N8LLNwphNOt3VcUgnBPdP68avNRGgeebgie9XN+8KzY5cGz8pcHo9auOg9gVGBnS5yUmg7+Ovjr4H/TWrIqUtdojNS1xkXqKvE/ueFhbL8T7R+54//w3Xu7/s+1NpeVyyT2f3RneVf5IR8Tu8qlNiCa5WO4Wn4jI3UTGO/VTeBbM65/Nz0kK13e5uKG9prFVWjMGdd/XOCM0UT3yJop93LWZBoN+u+DmB6dmXK8c6r8k5czZmQS/Y4SnOBZF6LdPb49WLcjIUxXKoXpNHHFhwN/TMtJYzFCnZqhY9vvNY7PjhPulSOcXNyUtrH3Jhp7NKTmiNY5N2oMoHEeXtA1eGXFNdIQfHR0zk9WKqd3IPUtbhhpHNlAtiuOKMT/0UPaJkfktFophYc2TD467L5EYypQbENsVg64sSih+MTs63OT7pWPu+n+gGDvIvltz+ykWfKX7g7rQPYXrQ5eMBwNv2+csefRfjl1VtI9cMRBPm97xhouWCNZqBMIlXU0aNZAI5f4W2toDs/yU+togWxTjny3oY9Rnmk/9FbffuhfIsN0rX8L1/X9Mlyn1YazvdBzHepe6Le+imB7odV9qTpIHKfqR2ddVC6VzJCnKzWGkaihdKXdkIj3RCUqLwHvcUp7bjzeyUpNbhzeoxRD7gi845WavOF4D1MMecPwjlaicqmUNjroWcpum3qQPYvYc79HPRNLTxHjUzjGs0hIwO937jf2rdDEbleWJ+UXD9tAKxcztixH7fetnSOXewIH32iN+X6qbPVojVwFnYFKFagUhjmuWGmPE7VN6o+014n6G/URasvUFqmdXW5Ty2gb7ddj3PzIzsyD7YUa5Z1lmfIVb7XyUNLkhtF1PxVaiO556f+GOKqVFUnfdc+4tmvzV/fuFVvLpsvPu891cLElA3J/02oypD6Kf55sumxyk6akRpux7KJ4mmY0NKrOkW1r9xlPZZ1hEmGmfNBrEWdDEpy1xCzei/d9RbRHjDToXrPdM6neJix5w/bGEh6yVYNt5aT9tueXtHQkxu63DV8y4hBG/ydW2N7M2S6OXlJvW77Eans+Z3TdqIqdtjeKUoXx7623Hch5BTF6Cy1ico5kE3J+tg3PGWfrhpDdEWsM3YC8hG5+Q7pF9ba7c1rEFIQryHkDKf0bYd+wfbZEvfH4TfzXiCVjbXwOpfo40niSNPVCqmsRE4q2i0mImwozdkmLOA7u44vMwseQ/D9meh7zmIYDe9uPCsf1M8yRtEGa2JaOwRXJwsBDcUIU6vsHJWn3XRXgVVKJSo1+dUzVwB2DXgYPEwEeJpZLfLjVosxN5RKXtLV0THh14k7e/ui6MXW8ff2zdCO0WXgb39Klrrs7T7jZ1s/4Bb5jURpTLeJ/iszidZSr3ZRUYVGaUlMraL+BRfkidXyFf9dBvBBdS7sdtovJJloR9spm5YJSWn5B2dp+QdnW1KKsLm9RittblPVNCexejOOZSYY1hgFC4DVdIH0vyWARc0wWJSoZf1xBaeKvf0ZuTjWLWcBxyZGVXjmL6RYPcNPz3y5GO9izJ3MZzJ4PsKfRbVZKk3s0mBVzslnZFV0KG5dgVianmJW90ZEnXxXmSJogLmFRa7MYXxbbQGXGJU67sepdszhFv1dMqNovf65wcQ+0mpWKZC5xQatFbDPVQ+5utH3O5O6cCzdtHMpmionWae6xjTCZxQO0iwPt4HIRQrFVyzkX7LYMhhaevGbLguSeZaLbNEsR1ixO1e+XdymLG+gbMxos4td3fGHsj/T3tDoZtOmiqDONbefAnx6Ieovtqy337UGiO2+ov6r3SvSfRnFebPjj3+oumJUtyUPYThrdSQn19pb1EbGn6YC1GX9y1KrmZepteXnjT3nJ+P38Rn9uFp9ssGWVTbDpykrFN8rMSmXyB/jmRMT75o7ZCd2PFjGNufjXCQLOcbGlyitUK2w/5D83m8UqlEO4QqsudRtpRsAsNlWFSS97LOJJpNgEs05/w5eT8/j7bNNnthFVdPOtRVxroptvJ0ndPUPEDBOLobyWXMBWyTLqGn07KheCWmTQuhntP6zjEle0mZWd+H5u23RZcIJveOI06AvkUaQwscgifsbW2UBBim7YVqo5sfhzsBB/UFBEN11CZoVJQ5wzpmbx/iKrTTA1wDTiO2ru/Xcm0/fp3nHBxMValCtRzYoBLX1DdPTBUvEBU5wQW9EiRqP/xJjekH/sHL27WTEmj8FzdXISnsXJyXiuT9ag5EqSZ8VyFSlC9CH+WpLGsDpTdrjMysZkSCimiIa5QoTUBHl1E+xbCiIa0mA/Avtm2F9amdqQBHu9h2SWCMjaZoVPSTxKveJptMGpKflHKX6Nh2JVeyhslS/sLtTF/eifSxtaxAgTnVqbUGsWFx8ziw+XzcZoYlEupY4GfbiSOgbPq6lEK6KSk/EcmpyCZ1xyKp6ulEl48qkXkMbkCjNaAVGLFsVSD3p3bLs4papFTK/arnA7totT61rEaXXUQmZsovXO12UNu7/pHyXUQsKkzejh21Kod/TfRH/9GP66VCzVR0hF+PNS8TmgFZD2t+iny4swagSs/RQ1/FNR+yraHbNmU6a80GUR+6DuPio6aePQYu8xqXsdXtt0w2ZkmLQBnmG9xSz2Q+7LU/avpLVfi3Ij6eeVFsWcEluAXCWVwje/YLoc7WjuCNdghHqcxrTmjsjY6XJfuA3WqPaoWGr1VOKvJEccpV7/YkPuqqjV9EcrN0F6DMiUg1z7VvGkqxBuKzbFYuzkXOcVLonGWE3qGSDKe59Lf6QWf5PFd6iP0417/j4+8HIz+vGYy5Cb6UQ2/rC1M2lAwW8azTRpoKJnO7CmSZ84aPZ5BihfVZXvPuiqrvugq6ZcVudSS0pHTz8Sp9IZzhZ67HV5oofipb0HyRXlP8MbL1C7+Q2ycWVhvJAkREpPOuKFLLynKxRitztN2C5OQL3sAv+2XUwD2uGm2NvFicAeD/XY1+WeaGufmnQNJtChZtQQzbm/Lgd42lnrnOemuUKUgYvqv6IBZROqj9nhvP57gDMiYsHRAbZQ/VSpzNvM1rCawdnNAL+o/pvBrX7hR7dFPNX1hb6+L7S5ubhlbRRuiO8b81xqG5vfeudXuMTsNuodKe65NHddFyGNQt6Q9rEIKQ5xF2u2i73xF/d4q/Fu6QjVhLK/msZ0+Q1keCLT9LdYmCqN9dL6XkTlVGmMl1b0+oMDmirFe2kVrz8LG+ullbsBzP0uL63Wqbns693OclnGcpmFHnEpJV6gPrO1hMY/QptLsvCnzV6aA39dfgQ5b0bOnyIaj/bXjJab2GAWJ7MVG7LRquzr8iy3cpT1fxfFfsWllsfnzv9e5upftnqK2N8UsL/RuGlO/XVI5FzcTIyiM1PozjW1ZWahBy1MbRb7m17Et1NMh21NrA3rL1wUlxb5bwBpPlnA/qm/SU1Jg5T+diPoXbVOpt3g3/1jrfzthuOdfmr9e3LYv8xU698l/kLtsZvytPWimGk6af1zzAvvUF086qHSpboo9ExmKaSyFKpcX/xiFr+k0YHt4OPtz+WfYjr3iPp/BbfP6N5zn1sr3Cb7wu1ibmofEd1qLexxmcVP9bqGiRjBqGWWin3Q/t91qb7b4Xuqy5doWV89/r1T9X0Wvs0+X9AdvVo261wXxWATF6djXHGp2L9s/S/UO//+TpiQKe/sbM/b+gt3cnuLyrO/iveqL9W9n7Tn+Qng52Fo7DOL/zJR/wMtT8pfSaMgRnC4fsH6IvUbugEE+SuinmMWW0zUoigctZ5FvxDdKWDf3v0OKJomU76/05Bv/iVM0IOWze2syX/lFzo1TqX6HyfNEOYbuNj84hn1J67qfDp4ic48Gx3J/lUzq5/RK88/SnIYrbaES5aPp8txn/jXWsIlo+v/XmuZLdd7b6213JoLyJRf6ZK1E9hcQKZc+qc5iIyiTHlzV7giJpNnysV/ksmbEO6xLpm8JOAnFm7pn+YqOHz3oa5wTUx2z5SzWLihQqSuVRxqIk6MegB3c2mE71YQ/QSMOfpz3M3Foa0iV0QrQFYmb6zUF9/D2fsYSNcyZKWiJ9GPJsD3LdvzetK3S+WQIX/roVHpp1U0vkQ3dMs6cSU0I1M+dyRMoK8/r7Tn03pZ5MRIprc48MXD9ZFCN8EYYxR6sTt6MsqmyNfdRjp9+FsAN0W+6ubGpLfuFUfpd4qNu3eKHx4aI7U6/LetJNl0CfzBgNqL4vAE/60soyW9e/DBQXQ3J9yyEhBnIOL2GC15XN2ul95diK8lCVPkk27NCMj8+caYLcrSYnxNEwXXRneiMTa/FC7j2P1R0glKf5fIT94lBiSaRX6gWQzosVcMzhktvcu+s1fU5/zRf7RU4z7D9BOPnUF7NrmSyXdzJS/M5DjTP0MPc9fNma1iU5GqZ+IyuDj+Dj72zEnueul0rfDpyValPUBn+BT18A24tb2gXv4wwy7QHu694miT1h6eF2Xrrqfz+1rEI7yD3cNTYuKiaE/WZqWSr1AssfMbKpRvYsOPVijfxsY0IGzmN0p7SoQh9MRe8a4i/y1CUeeeZPdfDDBpbw4NI7qyQ0050/+VGlDKTXjvFcPZ/3AxFA9fGfrFSU1UqHDGWoEvzj1Kf4MvZAazHGhiKMQxKxd1xPrSp4+nVyRunYb3CbxPVr364LRQtt52zJAhf+3pxbiFFzN1JzdlRnzD23fk8TfjIipu081hFo90cflmfJVOTXNRLpT533ZVMrbBf2u2V/7aW44etSMfaUR+c5v+3/dtvJ5uVBojvdX5HFp+8Qn+5urIWGOiodPqvao7XK/sSTmZqBH6tpUrjSn7G8qVbeChypXtyXxizzZNbImyISkwJyAqVPrJy7N5HTqzP0M+dlRHeqG/Ao0ATenqt4XT5Qov9ccZ+JtBa38q5LOmyyVsruJzbwDT9fLjw5G60MPlSn0KLyTiS1+Mo682pr6IGKcNydJM8JbHDaOl79wk1wwdT+uX/1xO3B4XG3oigLk5rOzUgf0wu/WLs3/E3uXKhiiO/nhcifIUjAnmaZhnxiVQjqIDEvqdpPwU3zPhcPi9ibSi2ppx/ak1oVlT5Ncd3NAQ35xe+DpHjCY6OGuGPLSzJjPOoP9en9OD0ddpnemy7L5zTq+yJxf1L5SD2BSsC26NYPN6VCYSWyvfWe+ffZ0uB3r9lI9bu69wBkrmd49Z3FJmEZ8vM4tbqyzic1W62q1ynsdo06HWjUtIxjloO2iKfJe/PvvJBlv2kjdstSbdO4W2+KI3bEGm7+C3HZIsKJfpii2uqNIWZ3rC9mbRBBvTclNEctUvtiCYWvjXQh4KohV4mPiyeshbLWIwwmQV1doOFp23vYA0D5pqbS+UdSDMeFtgEe2n96eXBtlUUELTt4t6xOuJtHrh2yFlk4UEdlPg7bdnhBr7GQJq75cTlYmCrtYjj1P468+s01UNMPB2KT+I3tdL1+t3xxp619O6v4R2QTK3un+BKOQOMUwfLLwuv6dEQZK6L6kH+JqwMhqb1f0IdEvmsr+mHW5VjBN54efjnH3D47RWtbCz/gNacStZ4Za/85L+XYz/SlwDf52fUcFsW5RSJbl7hvw7pFQr0zpMmjCIY+LtV9jJtM0+6s9fn7lOdwExM+lcUKOfdljAfxSZleQJpQo3Me0EIS7xZmuGfJal+E3X7NtUKczRg/XyqdLXLi7uUiu16OQJ7dbTKE8/V0by90q2H8Ji9csF/luc/DKUzvIys33m00UcJmgEnVB8TzErL4xjvTfVJxq5inKkznZnlGEUW3m8oVwsR457KuUovXLaW1CWJlW7J0r9PVttJXpaLdPQ3cN6r3zaS7OWvL1jOSiHHmMOfAu7fD/ylsM1gGkbL/bpfaSR7YX6wUK/6p3K0iRe2CrsAG3rKCAeeVNJuVKLUvlrG3d99rpvFK6es/+Wr60Fqtknf+jV1rYowfUtSmjN6/ICF2n6uyDyRa+KmrJdSOt5UPXTMN+hnFt8Gtq3I8xlptuOP0Qc2U4xYPeLH2CMnIQxchLGxQSMiwkYowZijOoxSkrxnAP/tguG9lZBptDzNxdHktxrQSlMlMa706R+buKcz+NLdh+/fP7kRTHS9BnKOsh/s+JL5xWemyrpSTuPBlwuMN/5x+9Wi9xA0tI+Srrppu8S5f7UysVONnzP6lS9Q1n/Ime/vrK3QHtMI2acqGf7dOokm6FMsk2vqrfl1tXbMvHOg33GsRDUY/4xoTUJHMdx51TpN2Wyry0N6pwqhbuCwZdnyOUONs+iNEIStuRvkjQB3OhlkA6+iTAr36bOO/7Q8QjBrOwZwSVMbeXtv+fR2FIPmfQqa4FXWK7pdrD0c2j9uTvYbZOq69hz/vZmIdkX/1RQNqh9r9j/7Ckrl2hppbmTPRMs1P/svxu/aeBvLo8YaCR5mrf3wVi2OIzu76ryaJkbtfwXJvx8lGJtnZCO0tWzW4qpz/1s5aKRVl8uOszwmzVC6LDSHNx28XCNfLp+6qdH3k8f5/j7x2bEi22gdDQTKQ2z8mPqI6B9XGI/4tHrHhH1pjeuabv1o9mkKs0o80lumGZYqeJeDJqD/9kTgT50lsZGi3LmwSm2grPcqIfbuNFLWweD5tY6ueg50rNzh+yI3fFJ9iezosrnSFxmTPnQHdpai7Kh7+CK4RXRLw97eav8nCv+1WDE2OjqXXtADuqkte7etbPkD93aQ/FC77p+79ANcxWipoh2/utnBtf2nFl/my6jcjEALbk73rd0Ge0kXUbJQ+NJw9aFNm1s73dbOlJTQ77sea02eIXQolia1BtHUjFu5wq9a93yNne12Ocsb9+SP7h2WeFrhd+I3c8uktdBVj4zcfDOIbtaxKizk4+iTaTGNlyzrT7bIg4+G7UT7SSVZniOQZptTImF//GUHnieSEG8cIvyRYxFvDDALH47wCIe0etnmJXdsWj3KbzduQIj0BOoLWOkek6kLlmoBE0Arb25rX+MtNDzKtOJtaaLY1l6YcpBLlaj/JIetWq6vNWZUBe9qghj3lNOLu6+tmpxtH6f3AQJNKsVMYGPAWe20hnlvWIeuz14ovRPJ2iAKQr4ovgwzaOwucelFkmdVdGrnCT16ji2spHN9tzNsciqf1mXf9lFcY5pIng6Okc6pY7GtURQwExlT3rwQbp/Xavfjn7rlTPdoL3HkLMEKgEaASaR5jD08hyMxoVLJNuqHIxCOZItG71/FqiAcUA9u9d0tj5ZiBNipTXOc+wW0QT0yPMTtIm9zl+8opX0s++by8XOstK/1uKZXXbYSuf9r6C36PP3rRpoHFnB31yoHWgchfc2vJPwXop3Mt61eI8Gde6WP9A4Bu8gvFPw7o53KvyvwH8s3lfxHg/3ELiPg/0G7BNgD4Q9DfblsE+s+K4hoS4YNfGMY9JlTezH1m6xx6yBsUes6l0to09M/gAka2zWrEgdN/evM1euXDmN+mPT/ZG6hIMBiNfHUZN/12Wyq+NAMOjau4XlwmCBTgcfrI+YwQshwtTqIa1ZoF3LQK2+cewVm7t2bGeAH/icUa1vUjdjdP92/7FrXEgPtPtSRTdxrhAP6hDMaO9e8aMyK8opU5goRAmlyuqUUuXRFG5nqgD+4SmvfNyFtlNFNIQkI9LwFlCRJo10GG0lVeSSJuV5QmphK9snP+2KJF1/VS1iKGzrXedFjalaDK2qFkPQbmvK4m0jqs6zGyMjy0Jq34KtRexd9rqs7cwgOl31uuxR4tFmXrBxaJl5nRfFHabGLv0Cb5aE7I6sCN3du8IMjpZWthtTVzFq98W4afIJL28/xngN4tEtSnvMAAOFiGD07ItxZuRbm8if5GJA3eLhE4P8zaIzI7u2YHStOcbOWpRvQcwU2tWLcnrhX0Rpr2+b8Z3CRVFqtRO6oaZ7kxShDTcOMJzrCAAH4lE2Cuc6eKBOZbPQv3afLDtLlcJNpUoRzKpNgzESLy9vUYz1++RfnTT6colzW79lcduVweXfsrg/KGiLkDB764eU72a3Xv3snNtwTuyNvjqvi0tRexp/s7T/TrGPnmpmn/wVC9cH4e6+M1zVTmVZyZFr3UKi25rFyrJmsRxmR9lH6Mfzf84A53ePIoEL9pfwNPuc92jWNrIC43HSLKuau5fwh5S7d6y0+zy3jbffWBl5qH/d4INJAlcxWYiR4jqT8ExVaNanXB8jzVXQjsSX2SwPRuoqr7zMCYmoD81j7gIdGi1FwL6n7yvIJW/vm59kyyqrYO7dnf8mt5sbSJ9kXbHNCPxMBMWB/7HRkuzIpHYyaTrG7WzQhVmQzIsSVPqQBUk+h529IUlIcb5oVXXLU7/6ISQ7g+aMmEDHNWYeuRYQkiFVlkTW7excnsS9THmaJPQ/uFMM0VNennMkCdHSWa+ao2jJ6lVztJPl5ksl7gO/LEkjToVPDjwKOdB/8u48K//R0msO0Dw9JHPkrtIRWxd8kLeHFkPqBcf3iUNrbFYyUsyQl3Y3+HkaSlU97XqLGxVOUhvekEQ1GCVQuXrlDxxUptRr1DItdPz3Ml3moDJFSzlG5Vrxh3Klch4tzXJwMVSuYYJKb4tQrjm3lWshO/cyHy2AR7ld3kR97lGMWIeN5xmfFdg2TXZDljyD3kf/OaDyEfGhs+lStIvNDVemS4NcNDM8BKivi2YrBwOFu6pF3WTi6arFwMRqMWDgKOmqY0AlcWzpkrYrrsdJcTcY06VOJ8VNA7rh/HPcL9W4x9KlX5z+uO1dcX/oivsti+uPp/KUXyjUOoeIW1FizZ1P235FPTRGqLMpTUxHINUD8bBHwPvksJOaAy+g5sadOnrDdlZdJfzRDJl4cwN6eBRvP8rOo+0rgdRRR+W1YdzjOdFCYFSIZPNSPLQ5Y+RB4uTNJaBEaynG12pL12eg9Wm99NzqyfC1wTc8FIta4f6GY6w9FXdS23qf4aLOO9tWeafatvibzeHgEyMsStOr4M2q1NtTNvRD/fc9ek0TglH4LNrMMaLMD7SiDZap9In0BX2L1v6U7Qpof30hncRCu2BnCbIEjfSxF/+8oILd+nwEcitbuSzzt9fgc/z1Pcz3mo2HZDscNOYq8/kLKyMusbAtDRKHWXlmnD8O9/vqjcQ3rd2o/kGG9MbGCbYrZYU/UekQtX3Iyu2YLBDloZIRPY9azUqfVN7+0aoFDRbxFNr9hzRvXTZN/sj1L7TEV60/sNYZApp12DBNPusOv20+iPK69WvUS/lz1sXCNPk42m/PHNWPUur2Nf50WPhRGvF+s9JzjfWiGFj1pFW9d94/P5T0VYRuWmYIw1RD1AMnN1BtDjTSXlCq+9XoKw15L7Nb258eR6XVlWvLboQdwGQG0I4ydZ2aaPxkNrI9Pe5lX6v5xvPHOhiKOmh+4N+MTqiyFVGDgHNUwrRSZxoX26CJvShurioFJrqRjZbxCsaZI0Q3jql0417YP0ZLzzir0ou7FfrHDbaDkJQyvucSH22lcHvFdXV7xTWgaOOY/2Tb7GNcIjiySUQ3gk9qY/gYLvqQTT8pChQ6K0GV2u4dQKcsSfMAncT0yqM61drPbqOdu6XijipGi+xHWL095Mvpwx7K+VPjICPSCJbEJwa0Rgke+SMP2bQ+20uebrsTG2hMjmAlVZhCIzy1G3upGi5D+q3UrAwdH5BoUfaM56SaUvKtLuXt/VjdGFI46Z2PQUUj2H3TVov4scnfl5suUK5HSZ946e9IrynR5vGotSdtcWVnbG9Cns1gIXtaPrptJVZdeTWwNaAdpmorrfvL1slHh/nyJrnpX5/x1YZHbvUSFd8Ajo36j/rNUi9RcFo5qWD2ZxCmNMJP6dFj61DndTQijpIe9f53yl2Iks8eoJ7+Meofv4RxsazZKnx1a/0kF3gtzJFr2pC/3bAfMiv1eQ8fpXnBUVKLk7f/M5fm/0qVoStp3o+VIKhCK6SaFeN5++mVscfBK6/reW1bMHhlth8nT9B+SrtxzILcFnswuPZBeQ7GUbP4YaJZbBxYLfbSj5EsnlvcWbRwKYfKZKWbzaraU9ZQfqlu3/EE7CbZwB+32NakjxbIN0kYI533JAuxtWOkr72Mhh6KPdi/jqvIECaDKvyvi8rOH/I97yjpggf0L5y/HszuBMUIXkYl+TL7Ekk9HrkX1UFfOs/zCivvZo9/pIR9AI2cZmX9Lhoxr4PWJrGTOaRnjsbOMdIqfOOQJ4DVQvb/UQtGxgtRzt5mVL3aSX93qYu2f8TsvRi/8TJK6TPQ+hcmgG4E7IfMn6X15+dTtktgB0LEe9HiA8htKFBRgFeOPL5XrNT/ZrUoUeM1iXyb2vKJy1Hnc8lONSiW/JGDi5bucRG/M9/p53cec1Ju6V/w5SqKiVItCEjsd5L6DrURKql+J8l3lKRzjpISPP6ZdaKrNCYcvkWT6jZgHEUZY9TZ0Cfj900lfvn1mXMk3/7AUgliK+lUrmjlx75jrdtLa49lNMKNkjrdjbYmVfaUAgJoviQDJZ01SRMNugiUjTKflSAxOTGH8SzUx4yo3+ueY7ZeSOG8Wx0vCX/tvn289MiKWx0vvXIxaruerdWufA+9YOU0jKXfds03TpG+845jo0i6VOUwNoxDvw5AG+ZdKTm06jpdvuieJj/ZeZrJIVuorFZWiN1Qe6OksQ56znKgNgInWFU+ziN/xfJYyVre825qm2or3MjW/cn9W7SzV1l5POm+s7dn+/jfHOS5cED3yyodRHuAWZVC3CKV5yjpodvKcVFXORKPmlGG9lTmle1H1XnR+6aXgibs8q05EO9MeqY4zjSTzsuqY9zxGLNy4nXibgo3qlLT+Y2axP6tJDndKTER/SgfW6rsGMvb++er3EIsKOPLZQVs7bXcpGHyKPWMHzqjmAyolkq5o5+tfFJcXaCQqaxPf1CgEJNYq6QbgUmuW4cxf6hpiDjct+Z1j+kRMc7UtQekzE/Xd7PW9b3LR1PrVJr6tcvXx4/5aGsdevMxbjQnuUrUcvqHi0qaqDQXkyyobSzrv7Qxj/ypm3I1RJxdpf7J575Ts/UlFnGY6U63N+FWirD337FS1w1j9o6x6ji2YyyluccR16CWnupG/tR7mzaa4fY0C1k+lmZ1UNqZm9jZG3Mub9+XR7Ef7+Tt+1fy9tcL0ZcmIxSo6IcDQUl7jJQecD4iru+S+XqAU9uWQTPPXCzFplQohYVIYSfNs2vSpb8D78oLKP+a2Z7v3CwMrq2Rn3MF7B5c8R3cWpRn6tOlpzs30qwrQjzRGQj6XAP5f+guojWThVhGa1oUrqRF2VYeLYUw+WpAp5/eTOhU5SuPHOWoaVB7q8Z1q7c6nf3v6K3RLr/ktGMslf3mhtt3FQV9b0a5q7rwVBfvzWuH/twWb2+HXrn9+AWxx6RAK7Xox1o1kzWJpSf9LTqgq5VuVW5vpemdt1pppK+VWjv/Wyttva2Vfv1/ttLnnXe20r85/1srtTWoLbTYSS30/6l1Uuulf1rjojxTSW2yXhBjJ12yqvNA/vyZlaS3KN+6NgqtdXjk9k6aJfDKi47Te45EMsWc41zi4lYamWgVkUtMa+VvzmRjU6PtjN7PuWZhdHrfWYqxCPxYf3BiUVz8ojZtwgo2Ih1qIE7iA8fm3x8K0sRo44Mh2WoljXZWQ2YDpcwl5rTSiEf82UzU78egxDPYmk7SBI+8/5O9Yqz+M2u3xMg2Oit913FtIrh7lLdFrLxDYl7M+LBmuB63Uj081EAj1zcsxJmuEFkm0UpfjaAbjrX/AX/fw2Sz8gnd2oj318TSXP/bVk3sAOGglYs9DHTMSqV4/jKf8FbbVau6PtxbXedUT46uSR1OJ0dz5FNuzdS+bXHG6fI3jp7shOhpwwDDGOkfnTR+jpT+DU5os8FNpw3sG4pd8mQHnRVI9J0cVdc8K/O4KPX8QnxOPBtd6h2aocPa7zWOyI4TcuQPHLrjw+5NMOobhuXYrB757k5e2Ho09j52GuGpdUfp5EGO/Kybbjv4yjNffswzOylL3uG2WQfmfGsdmHWP3Oyhr/ZnqW1j5xDC2DmEPjmn2TmEci/5GD1jDb9aw1mopxAq46jOdw6hV442e7q8wvGDNTjnHWt2qzpu0BmESt8ZBDp7QGcQ/u/zB/IcWrEPW/WgwN8MHlCvfBnkxhfBtfWZJzQqX8CWC46vUbkOtBTuSyP6C7y9T0GjciOIq3DL8z0T4XsTvvfC1xjWqDiCplGbv7ka2AX36XBf3x99K7dR8cA+0ZONGJzeLY8lXg+hAoBHAz8DzAPHoVb6IXQgcAzcS+GuAx4EvBV8zDbYg2GP9ExHSnqgEMTovwKyHGL1gb27Jx4+vYACPDtZb65kuwP4m+be5BMKH7tb9XnR51PJfMLhc8Xn86zPZw/ziYTPDz6fNT6fSPxJK/L0lZu/2Q/4a+DPgQcBW4BPgbsOxz99C3wC7mlw/1/gj4CnAF8CbkCYSIS5DHwI7jPhfgX4DeAs4F+B9wLPBr4K/CrC90Z4G3AF3BfCXQLeDjwU+Dzw88BxwN8DbwQeCfwj8NOIG4G4/wP8ONzHwr0d+DHgA8D9kMdC4FrgAcD5wG+zGh+4olEZpNegxh90U2kMhu9CN93KpdntX13MPPkN21GyXd3JdrMxLOvkP9ndVVEInY60jiDdGOAJwB8DDwVOxj8Nwj8N10+TF4HmNsM9Du7D3OBN6VwG0uaKRtiGmzCeQVbVmTaLelMVW41ZX7RZ7O7bN1e/gvaiXxSLi06JQabTcDsFivIqq69XFd7uyKf6YidlbwZrg4z9DVRnvF2Tr+JBYfxNXnVHnfE3db4waXDv53Pn888z3gq1F44YbB4atYeROyCf4Zszw3m714ezIPm41ql4NsIP9YW/NYeN2oN7pA+naVPYe4p2EnsPRVqcL62RCDfSFz8C39P63MfCfawv/oEIdeSKUagGUWd5VHuoE30bZClIXQPiBE4q8SQaYwt4e2N+lDDQ+PNKmi0aaMwvcMucm6hjpfwXJ9HLSrmQZoRNu26j7AMsNKfkX9mPsFwUe3dpXA7+kdv9DdtHcNmnYdMfrte5YMap95LGeAKignL0oFp6ZY7kTdKyGxO5KAdo7il73LTNna9P7T/y7xm03+o9Hx9MOyHUdZiAF7nhtP8vbRjdCtnUETy+qSMgtamDhwmE0cHoUwMNgWuENU0dvVYGLk8QkoWspGx5sTeZnZAt4bLl+cBzbtSs5a81wTbLS2FQzsXZ8t0+3At4mjdqhGobBFuad+6wScyWAFuyL1wKcCJSK8f4IgAPA6YztkXAQ4DpjO2jwP29qUKKwO1qzabRJlSqVb6c1ay0p9I5ZSlVTfdZhOvmC3cmm0anUMmsnEa4fmMpXNxY9ZtbDNnyNc8/sjUozXo3f710BjesWSnh7zKQHG8cgTckgEkCvc0zwHUtB9e1PJnsdrOhVKlcni23gaJPQlr7kNa/PLTeQjrdePu7tILzAnpSfqmyYUWp8hSMCeZpmGdW3GVYZqg2XDDclbsstzr3Qu5daIWHfTE+ZHIpfeMjn8uR/DnSs0voL5oXoN8WkN9RuJXMInQMX/hiBYUcKcXTfEc+zXVQqyO30ZLdTTtNwHcUlCrJBWqKV/L567OLKcWZ6xpsfNkphavh7R35dxm2yBNdtP9GE3MX23+zV1zfg8KVrtO+TC7XkdLWEaXKC76UfkectbNKlT1IvRrmtYKnDY/NSkfp1BY4c+dIf10wOc9tSM/9a+6J3OfFoLLPlLj6z5SRNSOlv3nojvop0in8sxO52TQ9DWmfLzBkvZpvyL4r71RHwAunOniYwBeW5Z1CvFOId0pJqt8s9iy7kH/X8mXLq5dfWH5KmVuzbEX1igsr+q9cvLJ65YWVdxUsK6guuFBwSimZe0ophdkKcyB0jvTMvFPKFbynTT+lXA3Nyj6lbINPOYwZphJmD0wNd0qpxfttmHqYRpgjMB/DNME0w5yB+QKmFcYCcx7mR5h2mEswEswNGAXGBcPhyzyMDiYYJhQmEqYfzCCYqDBtVanijlP52WShVHEZSxUPjBeGKyxVNDABhU0xoLih2fJOd7JgAP4C+CV3n6ypcoHnAHiM3kB5QF8GRQAtA7oeFA60GOhGUFS7ep6A44Zm+M82l8yO1PGgD5NbaU6tZjroBYwEk5FB+gH3Xg3V7bh660zyX5BaMlK7GbQaaCSQI6gIaASQK6gQKAbIE1QAdBcQp18J1A8oQL8cKAKI1+cD9QIK1OcCBQHp9QYgHkinfxjI6z4AzmQZkAOoj/4hIDtQL/0SIAkoVL8Y6DegcP0DQJeBIvWLgH4C6qdfCPQj0AD9fKB/Aw3SzwP6GihGPweoBWio/j6gM0CD9bOBTgFF6WcBfQI0XJ8NdBQoTp8F1AjUGiQAvQf0ddDdQHVAlqAZQG8AfRuUCVQDdD4oA2g30PdB04B2Af1vUDrQDqBLQVOAtgFdDpoE9DzQlaCJQJuAfg2aAPRXoKtB44E2ANmCxgKtA5KCUoEeBfoxKBmoEOh/gpKAlgO1B9HK4Ufgw7uxXVjqvm46S34P6m+/GKrbBTPEFqr7K8xamAdgtsJkw0yCybfdOmPuP3N+AnE1eJ/B+xLMOTpvDvvveA/E+228c/8TqpsBo4dxIV4lzHK4L4C9FXgN3m/iPQLv/+DdD+92vE/BHIYZ/5/bz6pPkzc7aBfkvyDzPLo2uqhX1jS52BG7+kW2V2VzQ49Zsct7IM90/l8JCgKi8/8JbN00zUE7SLshBI2HdHaWzn+/FhrGzoDT+Vr/OMgL++snIOVER41hPN4jHO2GcXjHOqJyx+I9xGHITcV7oKMmNwXvvo723GS8IxxReUl4hzgMeWPw7uGoyRuNd3dHe94ovLWOM9FR+YbCafJcQsjNbLwNeGc5IqNrjNPkmY45N0xrolZNk6ex88X/05nUEJUTBfkoQ45yaWJj1+w36isuKhklMOUD76PzxElJ+Wu4EcOeohPFrRvpRLG+drZcoNRf4/S/t8Z9P1k+odDuvLCcXtkLBErJ6bRa6fww6YOife60x572T9LeWv+ZYv85Y9rHMdAn+5AOKTpnHCW46Rw0njEOeo5h50BHemlcdck3vDEHa4o0Su6yafLbndXKiKTJDYPq9hV9jhKo6qSQ6+CanPRD9wPnLBhbe0n/dmC0X7vPmCFMozu67MLan4xZwJs7zcoHKac+oB1Gh/B8bYRZ6Z1alRnbSiOzRTzK5GI6v0l7LmnMqBCTTDQD/30BuXIxm2GvEJNNS5i9qmAzcIWYyk7XnMKbdjDNgHQemWpWqkdUZQ46qc6l0Hcwck0gH4xiEyiXV1heU/F0yWe99PzBa+lo1EyRVimbBEvHh0ArlW5CeO1eebmzb22LklUTsdOiXHndolydv1deglGtch1X0beOv3ZGG34wSmhRltb02wm5wUP6EC+VpMtnIGn1epzOVkNiilBnFcvZCjztQKPZHNVth4lK5kk2w7PD5ERv6M/W2QYdpLO6NJvUIg4yuWWHw79Wag6/3T/M5/8r85+ZYhbLyyzKzPctStbrg2ofkL93DzrYq3a7OKisRVlf36JsqNknL3b32t2szE0JwXNhSuhu0gIThudStg5oTDErh1lZfszOMB5PoXW6YympvhN1T7UmoEbzICncWBEn7BXv0Q+R6r2koYVmatPlQu9LmbqTWzLDvrGIAyDlZLC9VrfPJC64cNg3u3vfhVJxQFmcMERa6WWrCWKknkuc45tdyV9BPk9DuqdzPEMkE0N9gTahvu7TlIr99ZOlHd5uqLO5msnSNu8mYRDqrMwxVxi0E/mtmSylsDX9OGGyNMpFZ70iKidLcWx1Pxwo1lUtBvpW6Hm20p4o9WfzfP30LjnYq7bqDZ1jL3NxW1rjhanyHq8hf6OVi62HyV8TxDRcZ8gTHEGzwHGnDDDEdlFl6ncc55hBe6jozA31O5ovSTs850YsOMpITzemwWGYI3j2MMO4oz1ygtmu+rSMDDnkGM1r7HEPM45qoNuRhyDn2bTjPDbWkHaCO0nzFvdnqn05lO0vbxU1ZeWitopmSdNsL5TxQonIl42XklxbmYaybrQzTt9kizO9YNPpm8VA03gpo9OCN+27HmFr0lvEbqZSsTvTTVYq6vShJ0qQVpOo0ZeIAQOaRO0Ar/w5OwHk35tN3xoveZ0WyJpUx5TzEfha6An1n+pthqp623RayyrbK/bS88JIydiZZsseUG/7x4BGW9MAtqf5HK2A0F9ECXSCxiu3nCTbXjFAr+qba8wkrua/pdmXpTn1T2nedc6MnFDuzCiFJKSPFqdXZzT3inqmAY52Fo6T8rwWUWs6z3TfFbC/oBMiAfpOq/+7/03nWrY83KVJj2gzGDPk8Z10LrGn9BVay1K8/4W3Ae/PvPwsLmaAwa9r7X/bfrXuyaP6p5mkxjX1SqlmqlwMWvIh6RQDLgI+QjrFgJcDHyOdYsAPA39MOsWAFwN/QjrFgOcDn32ctzeRXjHYc5zUH/V6bXQvSY9aWTbALC4dYBEf0pvFJfo44SMbl0Dtq5ekO86dpHWT4sOqJqmk4aQf7w49UuNItxTtDI+DXDjbp4VpMSRBQUkbrupR2grbNJ/PGeCJKraXQEZLVaJiCO8BHqUMhxzWU7rqGZYNWoPe2FO67IkFXspwuydeaEaZlSrL5w2CLNiIOBFKvNAL+FPgnkocS+sscHeF+OGLygGUHvHD3wNt0RA/fA5oq4b44VagMk0o0L+AtmlCgE4D/V3TE+gfQOUaGr0mMc0nH2FMPAnzOcy8a6G6KTDxdGcgDOnleUIK1SVKxLsEsH2smnSUVeFUOdbjP8WxZ+1PhQFIOdRz65zbrbAZCNvTH/ba1oBcFtbhvnWG7VbYEuNU9HJ/uiUYSSnsJfcfde40IdzP/nDXFgf8xMK1uv+sq2bOjYY1IVkT0Upv11XjYLpqpslHvLfrqpkmf+OdJL/ouvNcyxMol55ng3Xv/xddNdPkY95bumqy5BPeP+qqaUed7XWqumrOeP5vXTWzPVGgcFuc/0+6agT5pNOvqyZbXuFIEgT5Q+c8+X7n7KR75A0OVVdNlmzy/llXzSAPUdD7nX5dNVlygffPumqmyfO9fl013yDf7/vmiff8f9BVQ/Mwkk//ZkX9cdTLVVeN4RjeV1xRuUepPl3tuUfwbnfV5H5EcozLkPsh3udd7QYqCxvTtPE70zzTzJ7/Zk/O+8Zb/+7gCvYX6itiCnu9rPKM25WMpPzi2A20byQRXGMAuMZZ8mxnt8E3WvXfT5L3O4ln3JuzNztRoBz+5LliVSkW5yHu7fvu3c8F1u0rrCC5h2n9eBctazq4uoxrn5RU3LtXrMCobnDc0iYzWfqPy7+HN11e4FB3Wav7gojjCf7xovh8l0s3C623jJNEtyZOc36vuKksuvCJLFCMgKnyk+x7z7LczWHPPPZ80WNWBHbK+o0Ss3IPUF4rf+1HbeA7/LWrwbSPI4Ht48i/u7cgtwUe1ILTWdUp2bJA8cYPuIDRzizO1BPF6CWdUyziTFM1RrcCdrYzo8xua2K6IyLO+WdkZ5+kE4a0o5E0NU+W+ip0H99kyenQNZA+DjUH25ADi/iwafJ3E5DzUjG0TNWtUpLcLIaxE9eD7zhxndU1A6i9oK7hhZnS5eOdlo6U2OaO4FjKWTOdUAd/NSN5ckN0EX8tLoCLn95KMmODc1IO1VMEenKEoac0zh1sbRZDTeroUu8yK8tRLidak2b1N95+4rqxjU5qT5IOexPZOeto1q4vu2uttMpnEUcUmcVHkIo5aX8+0wcjhpgoVxalMil/uXreONRUZw0T+uMvhjqj8o5Z++eEslROuW+dK45gnI50gvaZ9Rs1c6EzOiiDaBTJH7frN/LrNKK+VOvTrUK6rWn8oT0+pK+rBu50bpr4JPVc8sOfUJ9Ll9tPFh8Omx3LqBkbgdeqa1fo/4pmakhbFGStx91BGGm72ccWD4DUsrezmz2q+Jp80BUHWkExL7fZ0J/3gPeqR5q309DpTj+t5deqNHS0809nlUG/Rzlv0VqVfg9w/klfGsL17wpXGaCOCYFO/xlk4pzS5Y+V5g6dJtfIX4vqOjM8VT5+jM4MT5X/4jAY/GeG03w0hLOvBq/wq3avOKvMKz8B2WwVxvsrWq9cDPwX4KvARcCPAtuAlwM/BiwBPwxcDHxdm47xjrevAb4B9/nAa4FvAs8GXgesAAvA64EdwBnAjwO7tF4W9wlgD/BY4CeBOd4rjwbeABwAHAde6uodKxHN4i/gKa3gwn4zXRQHFZWKl0yqBpksvboK0a+oWbzMViF4+/zHm8UrpkTpfpcmulTs0BM3E6bvKR3wmMX/JFjEG+jd18HP/I7efU1PnMMBT6kYjp4YBhNRxsYRL7VKusuWeDf/PDm1NaLLso/fSWP8jsrrnMpt6uAWdVt791riXqKSsuRzTpW/WcxlyV8Bq7PglbCdcaocztXiLPlT59wRCA8ehYftuFPVIRkMfNipatzMy+bREntJM92GWc1KSQrNT5enqCkMR7h9vnBLEG4swiW5FyNcKwvX7tPLOQnhtjsXMP5pNqTrueualTQtF81F0SkClS+ajzBPY+RsVtYjZglMKcxWmG2pAlIsT6W52mbFnDoDtkrYSmZk5jQre4CehfsGxKyBdFy8oFR5ZsFeMaVHovSak2ZwJ0v/q5BMWIu0DmjjhSnI7Sp8baZzMPuyCXiqMykrXe7jOoA2ORooDOhX7SigYKCr2kSg7kA2bQJQAJCkjQNyOw+gVY4AUoBuaIcB/Q50UzsUyAakaGOAOoAc2migS0Au7RCgi0Ae7WCg74E4fhDQOaAA3j+G0H3et+ZDiSa5Pr01H/pwG7tfaDrH1WTQvKgR/N29MEthzsHUwVyCOQLzEsxmmN0wzTB3gS8Mg7EDTzjct+v8sD2sd1aavMkVmdOb0cpRTm5oxCy6Zzzj+oF8TbTGHAaOy+sIzYkzBLMQg5yJxv2Z+u97+rivSOdE+Ys7NAUSzfKAD5mG//0U9PPzb4N184DfHBNxGy+WkJPA4t/wrbvHMf5GduiOD2fr7sNzbFavfNBL6+5D1XV3k7rujlbspnuII7xz5Q88s5ME+ZzbZh2U8611UNbdso7xxwNYarfr/+vrW3dPcZPP22zdPULl/+7Q/xfi46lqHd9be+a8DRr8uC8fxFPV/79ee1fPmHL2uU+8LNzlOzW5v54XXhA46YGNpN9gjHey9IZyUfyxSr2T6WDVFLm7Rz0ROSiF+IiqjTuVL4q5MZy0cyPHWvS5jsGaSdJa72bhXEcU0F+8gYK+1qw8s/k1udARUtuixNX32PWanO/Q7w6p6LE7tGKnsjxpVgOdM5kk3e8NKT/XEQg0zxtaHvluklAlcmXfK3z9a3KOg/S5bRcjyzSJLcrC+gyp+0az+ADkUVvdOKmwUxOn/84iPmDaKzbcsSe3oI63J67reU0XzNvH/Gm36kXxTVPAocA6uk+oKtNq627qbKsWA0zP20bUBdZWQ4olrXGwlVWLPMOfMdzN715VI292BtTSP95+rrzOpjf5T5QX2YLYefLv4bad6Yf5b+fJB3WdJ98uDmDnyekseYJNV0bny9Xz5Hf5zpO/UFaH+HSmvM5mNNF5cjo/TunQuXJKc7sYVUZlt10cgm8ORNzBMNGm7xVdzf2yyRVYu10MKPOfE75fXuPiYi+IAUuQ4yWUU11FS0dgav+6wENBB78WNaaXmQYJrmiFbYQpOOUX2xbwdW+a5ouaIuJtfkbpvZj5axvtezWLJ8ErBmI0sZfR3m+ipD2lE06aKTGLN8saMUqpp67Nolzm3z+k7kjcqbQkdUsc3UZUt51068FcgeFS6ARSt1a0o1R1r1yPlDQhtusU8UVxfFX9ZbO4GF9QysZJeYom7jxaw2K0hjF/OEH1hbVHgzZxYBtvX/b4LEFfF3IwTuB2DZY+hSwzWGpx07cvJZeKG/Rkt9KubdGkL1WCU0rFkrJj1oDEI207Oy1J3C6kULxTTNTnCPqD3YQhUoFCMd52c8MpNlLJJfvp21JATvJetUIujUFfuSOP8I2hfHIjXraqd3WqZ5ZojL017/5G/XugyY952g3v4r3KE5X7Dt4FHkPu23jne2pyD+H9iOdMdHtuuzEdVCQyOqowXa5l/P9GZ1LDgZw3GPV4ASNQ7Nr9hYMg8+y7L4pJPRsg9WxNyl/LjYg1MU1lTO4ZVJsjt7pUuWeiPMJNcs+unAqf3LNCucLkTq+jWnmKST19IPW8gL8Yy755D3i3FyD1nDtnwQgbLK0BZxO8NrrwWYSIhTzyTApGyFQKeZ3N6GudNLpLchJppC92ystcdAOGRZkbblEWxoBzT+mzQxvV0tFf1+cdS8ffNX1f7lcxcOckaaKb5pjLQTnGujcKwbWvySkKuAttghDMZpKTalqUseVeebOb5pL3lUyRX8eXrrK55LBai9LeYFEu7bMoV3bcL//mCDuoA6WaWU9z1C3K7PIa0C7d7mZFSg7C80ayHk8luQeermSzchfyoNtEc7tD2dxuLJvbjUlJbYg2cvGPtSYIs5Db9W5wp5xZFMumYDy7NZsbijY680+zuXO6ZnNzLlBLpTna0LLB0l/RT3/OI5teP1iqdBEKBnqFoZ5Ae12WjpmaUjEE0sq7LprFFVAqB10lQlhttfyWN0MI24l8lUyS5nSqs7iTpJxOmsXtWTlJuruTZnGDgTI6/ziLGy+N99Asbi+9V57hUOtzp+fK5XghAvk75ooybKf527VhbM51qvyAN9Q3fzusa/6WyTD5kaqOVsgyxMPT+smnt62fkLzjn9/d45vb3WjIkoc71bndz/40tztVjj4Zx3TMqnO7XvmlTho5g5z+ud1639wufQdy99FWkVvi06O3ZFM9ydq+uwVBOTWgxpyJNCbGW27YrEvYaZ0LRqGcndRR9SsO7tKvSLosSMvEPUUrbW8umWA7raf9p2/Ytugn2NqLrDaDaaVteFGUbTibGw2oL75HU/ud1YtYl63eq/9tHjRLfr1Tkx7aZoAs9b7HotQuojyNlFZ7KU97HXfOgP7SJoIHaLxNBstAj/+byy+DmZm+qHR5teuPMlgTwq3yh7t2hclW6fJi1591VqfLD7huk8GMFG6m64/zZxzSm9EVrpXpi0qXk1g40iEdenhLvV9TVbo8moVc1RAaw0UH1N4j/9MdUJdbxCNGX9cJJTTpgJKRGsh02qyefru+a+KF/Xn7ce2+IvqGx+mfo+sKZyRe2P8vhoB97J9/ZeGIb+0Kt4p4YX96wWv3reqGcN86zZAVYlZXZKadzF9OcUbOva08EOerrjhT1v60itL+mKVNvPDtOq2nzgvJmiDHeG/NEx7IV3VaT5UPuG+fJ5wqn3RPlJ903DlPWIP+MM8RrNuSqM4Tqjpc2sSJjFqQBi3apVtgqzElYVzlhc9sJezESbFtq36s1EQ72fV7xSDgPS62f7lsnhzibgZn0CxqIN8FsBtoSOcYd5L2+WOsmU4rAuVKUvKZer+2kxUbIhrKlYrkiKMZQrX8ktsozJOvuvJXW8SSIrO40WQRN7ERI3KTWfw7+I/TcN1BN/+C5+CKLOJLRaTnyyK+zORX6mFmtm73Gd4VTHYtol1IazJrW8B7bZYveTIPGoUH5O/cF5i2pc98Yc+wnnkB8VX757DTHYQBJv760PlPMq12+7vOUlJa0UJmLcnugbXz5AoXf33PDNolWC1m+vbtmfOrxRlIJdCk3qoEt+sHZlSDIreI3Zkbf33kfDXsAXa66GuWss6X8gRvMFJeiZQv/SHlal/KwbelfNWXcs8ut3DkuJdpnny3q5qtXF703T9NNCgc9nafnW7UjYD9J2bvh1iRiJWAWOHIfyBLqxohWsR+sHf32SNh7w+7jtkHI9YAxApxmcVf4NrPpwfrMkINhr2/z053PA6BfQCzD0WsKMSic7f0h9/c9oc082W57Q+HwX6O2RMQazhifYdYQ5FWsO+PepL+aBPdCKfah8OeCHsvZk9CrJGI9QliJYDT1pnGgwdPRJgkZquGb4uYzHCLmIKQBxGS/j2J/Ws1/pvuK72AMKo9BfYJsEcx+xSkn4ZYf3fy110zKnwlrtZXDTsZQPfFU6mr9cUvMKPEW8T0rvqiFjoVKfyF7gpEulN835mAUJmwp/vsU2GfAXsas2ce5O2ri1tQ9w/Ij7l4+yNrePuDxQ/Iha5CtPsFQMtd6mxOXpeGj3sv7BUfqRKE8He4EWYlI5YbkyHtL/n09yZtuBQakiHVlRxv4GJpD6x/vnUx0zVMe14XNNzufr7L3Q4+fZeYZfpW5Nj5Bys7fWgEdfjcoYkL+e5b8T5ILQVdWmoCz/m12Jw5eRpxNBO0YwKv8YEftmXgv43rW8X7ikj7yjX07i5tSj/S3bd+zcP3mEj/UmlmBtqLtS2L6aOieyI0iQPazKLZRyteuY1W7PTRisrbaMUuX39/1XTllwAWs8oXs/q2mLt9MV+7LeYeX8y9pn/9QqHI9cwvmjF826e/Z0SESxkhD1q/CTIr02PDJU3IAivp1lz03iNWuivQt8df2AM6qKktlSd0xhv1eKd2RtTulY+7h2LkisDIZXRoDnExEQf73KGbJmymvrY3003TdptuGqstsEs3zU/wO0i6aVKGJvh10zR3BKVeyos4FCMMfPcuQdtyODPUMM8AXvuaLuBmW5wxFOP+oPriEyqdDoRMsKc+4GC98ii/V7xU5pV3OLUHG5Vi3itvc2qA4oCed1LvPAPpkPaFaNAW31zJXx+7iLe/VUD9uIDtVqad0gkIXXxb6D0IfWeIkQjxCHpP4wxN1QADfWE0XO6HyxddLklwufe2VC79KZUUhJjC+qA/zli4pDpJ3mZx7Dvy/xhnPELE3BbC/KcQaQgRBq7+lXx/qpPgooNLVZfLFJ7JKl2pVP8plakIYXMQPdAwjWr7cxuVDLhdcvDXB81rVDKB/wf+B+A+E/g83IfCXQD+Gu5vwD0L+Au4j4R7DvBpB317NtA/HLRD1v839/F03wONOH6XuXB5Dy4fd7nMh8ubcLF0uSyES7WDRhO/y/1wMTuIXrF/vh6J7y6GW5mDTk8sAXrOQSeIE6QFnby9Np/2odM++qXw2eDYyXyETv76zAXkQ2cqHobPKscrzGci4hxkcfypPexLbSR8Dt2R2jxfakOQ2lKWGn99yiLyNcA30+cbinhvs3j093nwGYc60cBH20k7gf0+y2n+2+dzU+Gvr1/g91kJn4E+H7rf6r189VvPIOdG+PVETdSjJoqAu6NkSuG+GljjII3zvP39FTR/dbaEtzcg1Fp+CtpwKNJdDzTPGbq7UXmC999gtm1cPCSKS8iRGalsQIgMZ1C2PquH9LEHfWRxqbKU4+0fIB0T/FLQ3hoLdO2Mn5p6ITaAm/RzqG6c4+9T6LzIM/iHk0jpwP1Uys9S/SPHzz5OJVsCW0NnvGBWKrv1lMxuvnaz3MPziBhiIj0e50Wuis6DGm1vlRXa3qoiul1ke6suVcqn87M+Ov6qQ709sBC4wqHeVFioT5XmsTO2NB8zVnreoZ5jK4L73R4jZJ9CWxzTBVdoO2uKt+lN7XTe4frQzJBXW0CrjLaDNJdV1Y4eE1q7XdRXEb9ktMUzHqnIRjqkjPoO25umg7bn9UZbXFmcTV9GPNJ2cJ4tYo+y7WIwaNOD7kQhtK7fO5GC9ou3mUbDGJ9GwyhjP8Mg/2zORipxWrEWwP/S3Ac3DFLkeM0Iuqdqez2tMYQ+3o1u6Fp52tDU0W1lU0d3mKCVtOu+qSN8UVNH5KLnVpQoS+fS7VWGJEF+xTtH6hfE7rK6VskJ8kveHIZbgV/wqusSV4A3I1ySTl1/MBcL8tNe9f6rA8CPe9V7qz4GfkyNb28FLvSF+RE4H2GyEOYG8DJgusUrGPgB71w2sz8FeJ4Xks2Cf2enCT2kXp5vs5uVmVrCNOOxYF2zkqXtJwRWzJWneMEjrOsndAMeD/wIMA+cBLwCWAucALwaOAB4KK09AWsqNssSeIxngTngX8Gblk7XCT12zJXDvWivmaGC/uW5crCXqDjSvP7FrKAKUOmcuXKAd7EwV/aiVbuy5wI5PFl40u2Atfn9hO74Ct0OeAgYvdSog73DkyEskuc7ery6Ml8nNHf0WFmqVKxphsy6B6WnrwoV9shPeoN298N7HVLfIxd75+L5F28WnkX4h8gF3IghoLNv5nevxPv62AVzpGfvJ5e38ocY9siLvbrKPfIipnWkWSle1Kysh9mwaLCBzo40K2bYKhdR+Mb8QJbCgQUUD+WHeBO93fAc79XimeoNqGxW3l63Rx7t1VS+SRrh8RzveSJrspyLWonjHwdaCpTArwN6AGgkvxZoPtBovhjoXqAk/jGgLKAU/i9AM4DG8quBpgKN54uAJgKl8YVAY4Em8QVAY4Cm8CuBEoCm8suBhlFr4POBooAy+VyggUAzeQNQHyCBfxgoDCiLXwYUDJTDPwTUHWg2vwQoAOg+fjGQ23MAY8gDQArQfH4R0O9AC/mFQDag+/n5QB1Ai/l5QJeAlvBzgC4CLeXvA/oe6GF+NtA5IAM/C6gVKI/PBvoX0HI+C+g00EpeAPoHkJG/G+hjoCJ+BtBHQKv5TKD3gR7lM4DeASrmpwHVAm3g04H2A4FyAr0G9Aw/CehVoGf5iUBmoBK2AvWcM0pAb8lrVpbCrIfJgjHAbICZDbMc5pm8xaC9JC+vmRumq5FDdS/DrIc5DPMAzAqYETD9YJSbobqpeH+H9xWYn4C/hvn/sfbucVFV3ePwOXOBYQDlpqKiDjOAg4M2yFVJxUGPMFbgo3axG6jYgGSkpTWV4SUz0udLgjfIxNQCTGNS+0lmmFH59OTzzCSVNx4py5FspsHbOXM971r7zCCWz/t+38/7/rHPWWefvde+773W2muv/QW4MC5C5oO3A9wLAM8ClwFuFbhh4EaDWwJuNfwPBqcD+AlwOwDP/4A7Cm41uH3g7oP/LeDGg/sHfE8JjpQ9AO5JcJXgwoWzSO39954msR976YQJ/r0nhm3z4t4T7jTh3lPhjY+LZ7BvOwUtoMVe1AKK1/9sxXO8n/ES5opfC8jHnvIpmBnsGifOqUP1FutQgm2TV8IY/HtPwplPH3vEp4aQS5zpxbhHFUnCrfTi7pNw6vM3czjZfZrElnlt1lD9PitniSayCdx7OvQnfZ677TvdlgFVld3LphApSo5J1LKrTJJ/LzvMje38lkuQ+6B8MKtPt/1edhAJ/dJBmIOXxpcPg/Ai94Knc47iip52cMjMBaVDZu4uHQJ9xoj3+UkGAfQ83ucniQGoEu/zI/2oxNXJrc94tK0O1pk8k0Ixg3VyKFnUOL704syF0hcZYJMBNs6vC3/cECO7oBbuQ/sjMlJW0+9etMrDm6BMBmYNm+QOaXqHPcAvZkJawppjDTpOEvqwoaa4WrfNUFSCNP6NPho/BGj8yP9K40f10fh4P9f+myNf8bFZvk7uuBZmsLTYpk6utaqTO1TZyR0p7uQ+LdrLvsvHNic1neKKq4ZuHbZl+Obf2Ae4UU3vP3P5mU6uqqiTe65qL1vDj2oe36TYGr9FufkU93LVb+y9nIFJ35n1zsQdRazYE9REbaW3iDard2reGQc+Lvek7UFbNzUFb5Ft5tk3eWGHKLh8B6ztXcBNoeQBaLDqJHtp/SL719VN9uD6dU2j7SerfwUq5T17UnURe8a9rmVTcxjwza8DHbAe3Lr61ex17w5buBzlAngvDt6JgzIAfKc7XnShBAPx7gD8avvo6i5ijXx09eQm5CpQnoGUDfqsYY3Om35Jee71sDUBuzfpjhvOqCakhYrYrcA1hBm/tquNm5oe3C/IIKLI9w5IE+UqCKNEpYhd5e6Cf0/Z3zBuaj5l22TEu1/wC/NfC18xxtH2N+QbbXXyB9lqjx4otIlO5AP1TQy70I0Sl17geU/ZZgLtcz+JjRKaU7b7yO08qBn0IGAqBGqrCELMMq5hhzn1+2Y3j2EECUOTMSwNLcbOhnKSr/E6gGYTDqXJuF2nA6jHMr9p/oE1rJdTAQ2TQI+HuNeMm/226DZDCMRw2nbd/y2Cbxq+bwBu9HlTdwL8pL1hUlFvmKjbMrdl7vYlTSw59f86Z9xvbHoBWnANe4pbsm/F/zJnb/pztg5qxMSta1m8bwuxCHNnnn4gkrvbefoB3mGZ6PPOn/L0Vsuk7ZuaeHYKN3n/pgNonTVgoVXflLQz+Z0U6J37XA82ddkmt+ywTf2kyzbtE/3WmVvu21zE7oT+MxPq/j7oP3qgVR9sGW2/2rKpaZ9dDdTzb9ADH/rkqv2N6mT7TPj78CctQE0XsWuBmwiWY4/usj0k32F7EN4Pl2+0bWpR26uAiq2tbrGPlneRlq2rLyY9Vg/8/GgIex/pk8DTQ09+A/rex5zBLqvHHRyFPZnsb260DZDn9spXGZv2sqe8k7avg7Jd8qa2vAWl9LHfwsjaBKNqC+CpN2YCHpTqagH3LXgHtKyp6ztXBWQr97XTiVTiO/vEV6XR0dC7b+9xihKlvbTswzixapv7+q2t7uvXg64yQeKreeKmq0FB/DASJ0p8NSh6NsSLsoXJ0Sc4GjXU0QffaKE63XGYO2mvKpdenU6/s2/9UPHVdWHiq1WU+Op6GWAUh98cuXLe0AFXV4smTBtwdRVdDGMoAuLn2xKMf4M3nigJvjpDhLKYQRDiNWmYTWWcBX8G+f8OuPo6hX8HTxsF/9cFwXcwBWEehP9D/LalUZ/plM0I9WLsk2e91Hz8Wt6qTU2H2A/c85uK2PedUHtGvJ+uzN4MfMd8CF1LvpfAWFsAX3XkK9tugL8LYZT/3SlIJNcb10GIJRAinHydsj1DZJGog7nRVgmz14sQcj7p4Zsg5Dr4u4B8wWwG8EKEAed6CLnQuYP8X+KXAD5jFOaP1/3fiB1nkEryLcyIdcYH2adcm6AM050om6kl0u0wv0TyLb9EcpM/fyiR3JAnzFm1t6XKN5+sxLmqzihlHmRzAdsOW3Z9l20C9P6JkK9YJ9LYgqxTY6zjclJHQyzk3pLtweUG++vlTxGp70Xo15vKs+xB5XW2bkyhfIU9qVyQf9aRE0FrbRfLO2zd4H4yohX4+UvRxnF6JN79VFdVx6UBlOv4nyqzbUV5DbEA+H8vFTyO0nVtje68BVbw+IkH67hTCuVB3DtNTxXDKv/BfODTFwTubOi0/URyKsgnF/VhvWwM3Fi2iNyYRqnWQv5QDwt66Cv+W1pWTd4//sD5X7FfpzkKeOzXxWT+3+7vXVuhRz4F721GQXb4Evyr8/tt9vu9DH61/XrlK8aDl9dBLywjLbiQ64L2xxk+0O4CjG2+3g/XGd+7bLY921c7z1hhjZ+B+y0SZltrDlApq3yNxUj/vuLrLkbq90WfoiQb6RhfcUkWvJ/1NZZkwvtpX3dJBrzLfIr56fAu9RXPT0M+xtc4fzy8t/pE6ogusUKx8J5CSW9KEJWoqtinCzuL9/fksA/66AwGaJMbVkpts9Aq1cKr1qT8i0BTXLQlVu+0JdbnsPf6GhckAKZsX/cCpCK/8uJOXVDTdNbBo7aAQitoR/+2ekGF5Ooa8ULl+fKgWhpC5LNHPNKRf5jTz2WxA4m+QLQ+mugLTGLv56LyGXa8u9sq3EmA+4dIR/XXbUV6C/f8cD8vf1aMDPfeUCfimShxDu6vnfXTnI3raOoI0Jx45rYTuGi5Q8fv4OKJjvXaVRNZk/tMn3Z1tiPXJ2hXN1VPZPe4D9n/Idiv7qFoqnfpqidhlb7TpvWCisP5WC7g5lecLZ8ItfZPokH+jgtro8CJz3nkvN5+4lNDfPaR56fkeYo8f3HWcdmpX5iQf+20TSIn1P585+C9d7lzMCu1DhxKqdau6uSaMrCu1asEa3I82ws07MtpHdwZvGkN3hfgjfqJ3fD+AN6/aCeyqe6OnnR6F7mv7fQq3JEtfjqH1XrruEz/XVsB23QSV53td/l4x1c+Wr2+HWjLtDqbTb6tHXVhHk4d7/jE738I/O1+/8fA/4Df/wj4X/X7F4P/u+C/oR1zgj4LUzu5Di3eCDiRtaLklNxe+COxk9a0DDUuO7m6jFpTnW15n6Z3aBeM/2XA0y8V5rnRRMeoXsdaICyUrwlwboP3B/B+G96tgLsNcJuJRkcd95j20bafKhqfxrIvWzUeWu+Qp5PLhz5yry+e+FauGsNMRj7UU8dNgfooNwv3Vy6y4IzawMbxVKLkZilAQ1DKUglpzW4APhxqZBaUHlwxuIWzJrKvYJnIfX39y4R5mN2Xhymrcthl/hy4vf+9DA9hGQguIZeaVcjFPOj5f27tia7brT24r7UneISR8bl39OWdNnF17WWqHceUZEqMDMcTtn4oF+Ar5E1+XqGxk3uh5vIze9kVzsimcOAV1I2nuJSasC17gTuE/qGNrIXeoI2C5xFtNDw/1cbU+tcZOfRWKcqcoB6fH+OI4jVMZEudTUP85c1jHCrwwdXjNMyEB/8Xu0f1ujyye/TaZVhjoIWWm8UHtMwcdgisbC9jivPQagT0E32rfbrcYV8ol/TeoLxsOI8jC63P4+yLVulj92OI6VzcJDXjZb0+Sa+H2miTyNEX7TGF96pD8pmNNql8DnuFQ0m0sCKLyUpbS/Y85Xibhv8b9zxD4ZucgiB7vduvBFOvgVsHDi3WH2Tn8Sj5e7JyLrsU+LeXYTycwRuIVZ0cB3V+AeC1qg7Sit0K5eXip/EusnEHoP3oHDbC3bhw9GU8V3s/3wmt3wG9oBNaH/WRO6H1USe5E1of40dfxphvHUiFvn7D1b3wzcvJTBTKfFyK0o3kX8eBSPh3Gf59djmSCYV/3fDP4k/zqj/NH1yNC3+5LJxIiA3s172O/UU4Q/Dep8jnT2Q/a7+b7grDTuPoSeGWYsO97By8l1AaYRIbHjVsm3Gn1soVi8N6vJ/OSlVFDpvYp1Oxbv6uChHkL+ov5waqynPYSPfte8dR/yOH9bn+qrOSw3pdgXB7yDmEHPY3Eg75+Nt6IjlsT1+4DeRsGNYBhjOr++u25LDf94X7fSnqtuSwJ0g4tAvRp3sD5fi8L1zl0hJSjgOuP+ud5EI59t9Od34JKUc9CYfnzm+f6c9ht/eFe2d+PAm3joRbaOivx5LDvtYXbsDSXYsx3FJX4JzE7bvfgIYIhOvtJne/5bBPkHB77rh/Pod93HX73vYSUl69UN7+Z+Yg3YK+dJ8gujA5bCYJh3cY3NY1ysE9Hn+46vk/EXxKV+BuuojDrVxCQu6tI2n1OpQQjbVQN1cTq20f2wUe0gurI47h41xVRg2nSb9kigV6xMBMZ5vcE9ij/CEuIX0/F6Y9ReZedfpPT2/kIrV1XHL6Ri5KO6FNrCxjpJDmC87uUpQvlTM0fDU7OWvjk/3yCe33kzNwx9bKpT9VSCDUv4R1vt8dWzVc6vg1phouJ6HcRGtquLWJMbD60SqlaWZbFbc2o4rTZMQylTPMkFuJxm6lVKw1+zCEy4B0mDfbQpkQPdU7hxYp5I5LTg0j1QcViBT3ssfcqN26NmMtxEe9NeV30bKHxkbKlpHzre+VtHLFUp7N9Umupc86xM0HeKKP7JQBlOGjGw5xi6SBfauUjDJmIvubFyXplH+n0ADh4iFcB3dvBn6Xw/dQ8p0LoQ9xFdKJrMWLO4EYA32WgM9JL+4ABnBUQhzei1o4HFp3vXbfbNw5xT9L4c+1239utpDbJCXX5jwoubmvFPe4ngNsu4gNr+UAve3dQixpxQGFPZpICwJ3EeeT2f9LP94XAO9XXiydUfrIyJm6mVC6xyD/PHsUfB8emafLA5/HSYlehrCt4Itzz+MjF+sWw58nMnAWGl6+bQalELVWQr3ivRvZ/nMruKMUnfGnk7rgQsCFggsHNxBcZBruOg2ae7xnCLihc4GWVlZqp7MGF0IwSqjp7Hw/3A3wYwBrlTC6K6ezD/rhPQAX+eFPAdb74U6Ap7mEnaffAZ7sIrtSNz0AZ7v8p2VuDoCvVJewx/QEwBohtZuVACf64ZUAj/JjWlc8nR0KMNqFqgY4GmC0F7UB4HB/yu8AHOwPswdg2u//HsBuZzIzEuAPAL7pFMM6VQU9c+3cwhvGZR3c+rl0YgenBR/13Jz8iWy7aw/0zokAfQLQfGk2QIcBWijNAqgVoEXSDID2AWSQpgP0HkDl0vEA7QKoQpoK0NsALZHeA9BWgCql4wDaBNBSaQpAGwF6TqoBaD1Ay6XJAK0B6AWpGqCVAL0sTQLoRYCMUuHcSif09UfbzIrprNQnZSJM8QzteMWN+cfViNaEWBzwj/VKGUp93RzPUI4L7j+sIo3cUnhjLdTmb+TPZTPG6+F/tiZW/mw9HRkp+xncq+D+J1KwkRKFb3Bp4BrB7QP3JTgV/FsDrgzc8iiUga/3y8CpxRPZFnJv3aMmUUv84hDI+TZe3Ra/JBm+g+DrEV4Gc46oWQxwCK9YxALfhLJoQZ9yfZ8sfSK7rg/PrjLE89wdeDL64fnVJ+A55MeDcuYNgOl+9jHvfdo8dqWnNb+10HS/6YGJ7AResbCVxO+e/yG8U/nikgPwHssrFuyHdzLfWPIBvBP54oX74B3PNy7cBe8RfPGCJngP5Rvnvw/vQXzx/PfgHckr5u+FdzjfuGCPUKaS3fCW8t0L34U3zXcvwPhe4G8b4e0EPngnvG8CX4yt+RKhKSiH00epTsEIDa29ZJDVIj+q9vOjbFVYc/FimoufNJH1+HZwA7U5JklLyeJsnAuJTvojXrQCI2uawS70tvZSsp/N4ecy2U8Ip/qafl1BHiOGmZjj1uZPZ7vcp624WzDcONwk1ujPSjQzzYhjN9mpOESeNDlvG0WeKvJMJ8+fyN/vCPwUeb5Anp8T/xY3lkRsaADaqI7LSYevRI0p2ijWxFmEkYbwcAuGRds2MMoySNkBSs6A2axs2wz8d8Y3vBvr4KB1t8FtlWh+Mos0P1m6AMolcQd70Ib7einGF2I+6o950efPQRnmYEo66q5PTkf5S076QdOupyW9lSIqOdOM424QcE2470Ilp5unYPv5di2BWWvp9oNaqNcg3wTW5Yb5Yz5yLiVLnj2oBl+3N8OK1nT/eQZT+4yU+t+wvgm5ScZ5I0NsDKxWYyBn5w111kgmAvDXehtLvwQ4Ace8V1H6NcCY0uvexkUnAUb8q7zFiyTWEfqhZOVUcALNGoY7aatQroDyhKaKGNkHQMchbYN0C44d7PeB87RIMyK9hbQU0klIy+H6jrQL0iVIKyIdiHrpuA6jzAH3fIwjA3f9Fn+GdGx/nd+r8QPzM1h1P9sA/8rzEJ3fHBjt/XV+c9gv+Uz2lT/ZBkiBNb9EGk7SC5xHC2MkF8bp7yFx9vGlhrEFamYa28pLmKKjmvs1Bo1Jox9N/r7Na7sLb3wEM/bf/RYC3vSkFKe3JehHkf8beDphVDe2xV6Ibe6zFRDrUgAtVUlsBQzTX7EOIym8CmFq2qIfyDBMahusH0gwLOapBNwfRD17r1MNsea604tvWgeSGIsghrotiOwX/moO1R+0huo/t5b56RjcJzz+v9gnFJeJltTPr5yhPXyiPK/8ux5qOvDU00+U19hijN8B/5VXLmhsSYzoNwj8pH1+UuI3GPyC+vyCjDXAP0k0eeXjLaLF35WdKzED/4pzv2hxjW3cHWElRtHiNX1pEhj8kIfEf6sr6MWbgPOzQDprylf4U8RQm8rqS9aUm7krimHztcdOlGMqZ614r7Fw9zNFdLAjjh2BuhDufL7GY51/7EJfGGNteB5AwuRCr/q3qw7yG3uUzhFr5OSOs+HDo0Ro6+6MdgJQCh092XQdKdHL5O+LK1dWvUzV2SYa8Tx6QJK07AxFYvRYxRorCSeSzFlAq85bFZCb83g6hGulKPV0y6XFnbbRhKMNxB10HqmYCWyKO8vxrmd3xU6b2ngauF+so2B7hDwQ7ltydy7KBNR5X350ySTkIbEPT3SXgEcGeFYSPIMBT8hf8NAXqLGbzSLVRiul+NHaaUsyIqbA37DzElKSDvBbbZWoaq1ilWpp9jGJym2lVU6rCOhrKuG5AnIHsKPOTSk7oB1SZqqKCx0v/41SUfEd3O+Qz0LHyr9h3a3lftAiPmXp/NJ3S9dyFVpl/gT2Cd8e7lNKAdAjAH1GjQJoDkDHqREAFQJ0gooDSA9QBzUMoOkAfUUNBSgXoJPUEIByAPqGGoz2QdDCIBUDENr/+xcVDRDa/zNTkQCh/b/vqAiA0P5fJxXoGx8DzXA6IlImB1phEDgevtEOW02EQGOkgd8z8EbbdFPhPQtc5eE1FU8YKFUsI0+gE9/RhXa95b5xTeKOikw10ROkLrpXlkenRTK91spjwhmC1ajV2twKuZrAnuHp7TgHXODLmA7uA+oQ1ALPfuzDfVfcibphzxfurOl9twrvmr7zzpMOm9KInMJnEOdtEidwQwrVu/Gu4VUk/HEIv9ZHAe9Ro8XvE/D9MvmuI98d8P0c+d5Gvr+C7wry/Tb5PgnfC8l3oxYp/2+gJMt45GX2kP/fwv85vjrIHd5vj+GatIGc5PflvBP6dR30/UPQKivs65Hf8Pe5/PYO8J/AFvDIeXxHrblOizugn0t6D9ET2Mk8ptEJaShJmdv73QUT0xmoMbwhJlDqcUbhjteIY2h/fIH1Ioy2F6xEykXsiTug777ZOogRJwfBWKUdItmU6Xjj8g/awhuuUkk37YdLnqfiE/NnsGVc0EjpOdVMlT6BzMs7PeWM7pY0Hi24fMbjrjTdNI0dCut/Y8VQZhjwEK6KGYatuqFdndwH2uip0Q56IN1c+JtOHDpN1EuLYtp3VO3mJMenGmjVb9Y1FSMMaP3+B+3XMNZcVrGJfotu0d2KIvj/zitMwYRnzWEXeNBnHB/a6jiW/BX0XVizcK7f7J/nKEetsxPaGEYk8OM/aFUmShnJYH9bx9dx92k1bTgbwQwAqd2nRTtXGGeMB21nBOLQGomZgjUUYy0WYpkwVo6L8sfif68kVrQkb1KO+zx1MKKFk6IVWpwnaU2hg5LmOmqq7szBdL7OlljdCbNKwDr88DM4X8EsWj2BPcBlORJcuG+Iewet9pPVqI2APQrvJ0SeFbWIV9ibjDgv4RyIu+gdthhwg1Ejsxwp0nNVlxbjzNprD+ubz6iuvaXoh70v4Bd6Hu2IZBGbKZfxnHH5cvs6wBxjXFDWUK5a1AnQ7ZHVXPXX24cwbCfMr7dDbb9LqM4eiQryZxT3ZtOzOUkoaqm8qXNaUNZXeUykmWzpJHWSZISaCFphv2LEm2+sUB9JUB9vO7Eu6mxjyhNLcc90p62wem9pkl1WrmW+tq+DPAu1MYEdCKFfc0JIo7DzIjOK47+2v16O55CEe+t32qaSdcAv2xnDs6/41sNa9YYFW0lE2lxE2vxZ3+2e4uaEnlIHbXRHy3UJLZdUnc1a+CzHDGc2tFj/lttJTqyoSJrryX2lX0NLTay+VN5Vklj6AIzIkcbHrCiPqLACLqmayWY/AExKJ65bg+px/cM1CzVCAq32Kqv9EMNtg3ADnHsrNtvk1d/D+obheu359c0QNtv+FKQfUo3nVqC39PWQKLJm4R0r5KzBjIjDZmgbf7vMhHaZie2C9iTEpXmla0rFZZRyDZehyDPUchLVatOJsu+M5W2rKzZxKRFDTbWcNFqcLDdv4sZGDG3bxI1T6NsijqGvKJm1iMtoEvemFXzSJJpey02gTdT64z1UvFgpWkorq7j7yPooKtWVri49UQp1v0i3aPUi+mbl0hPFNHADohK6t1ukg2eTaHUJfXPd/BPw3DNfNJ8G3kAHz86lq+G5Z+kJeG5Yaj4sWgDv+Tp4vjN/NTx/X3oCnk8spRKoJGq0aCF9sxpCvldSxd2fW8VV5B7viXuqinsB3oqndAtXLTQfo9qrTkfLKmfwvzsOU/FvtkqZuHyGveqVwNw3bOYw/XAyB8W7hLlPATNRrvdAhTD7ZRmmsdudlDKaedawXRfURbeIruaJ6LStVbTyplVkomtxRosgsRK9ClOIPphgcznR50vgul6Dfvbnee2mIkqm9eclFvKyl+Rl8MzB+iEk9nlnYO59FNJuqoiGmbfk2emGHf1y8NZdcvCL5/ac2kZysNYTClzBn9P+omy4MdqUVxH7UuUMWiHcUy57E33rYE3Hnb2nV+VVDH8J5x7DqhOG4AOi3hhxwni0fZDBiL+UpdXqxjGshd6vZv7GPufpssnLBa2uEKLHkmRPqn/K/n61w14w70f76/MkB3D8Gz75wR5U/Z496JPn7XvnPWV/r77Xvkhvss+Y97799fpTtrB5i2BEOeyGeXvtwZ/8Yn9v3q/2YMBR1oL3R2+1J7VY7Ul4N3PLZfuM+sv296r32N/7xGoPnpcFaU2wh9S/aG+uN9pbWiba5S2nbAPnbbRFVZ+yRVdvtIV+csoW3rLRNqB+oy0C/kXW/42N9QRu10p1+HyoD2aylwH8DsAz5YJGfAF8O3wXbStgvl5RDqPQfzeMoDPw3PeBO/VSHV0QqrJ6d8VGmxTSlECaQfKLtgqgiKXGLVeCqcBox70d3B0O71qwGGeDXqKNYPXboyopKDb42FDvuxWbgJ845J+XlnVdKnv0FUrzjBnv+6Q0jFlV0WkbCrPfg+WI/6JtbnmnbRjU4zqiabAW/p0GTgOtLKCmQYdtGORDTE4V4aknwF1+A96Ie3oXniQOlGjy98JsL+wsZ3Xlkvx84Rnf/QJpG9x1FkK+8X0vlN0EZa+yLlhcy61SlJveJSUCXqcc5+ZAqe5rp5WUspZbE/GiqdYWYfTbJRPOh3XV2iL7vjIu7K6otQX3WYWM6NphE1WPdgzlcP5tBd/A/VPirmEkZ8s9GEN2RwwaYlB3iTGQxHjcE9OKOh2Vx6gxX5tDC/4O/PL5gf+Y8kzUmomCXRoq/cJ3aIdmmg71AmiYOyaBmwduxGmkR9aUicokzJ/XPkqlKl1QurtUVYE3H3X2xKm262TtNbph3wn3r2LL5Zl2l3X2KGi8A0z4G3QaW3a4SWVQMOeJVEWwtZn5mdDSlyzk/k9tNrvY3QExz1t5Vv1ZgLcVG+kc7WGxRks4s8cfF2nv5HXzyqPKhpXg+29l88gbOUwSBvnXHvn4QNg1FcPLaE1s+4nyNeVD2zdBLEo5rGRAO3CjEApja4+JFt/GrSunVNEluvLZ4GpLyB/A+P+O0yWhIZbF2j/X/XP1/4VbD5QSufPBkDr2uizo19+RvdevCS5MK4AtgOtgP36bxxkVeKoPTvfnt6exPsJvY7gAH1TGtHKNwD3Mcf6Z43my87/zO+9CjBwn8hUbCL+xB77TnP35n7y7xk4gsd+D0HHO29xOE3zHOAVuB7mZFvgOcwrci9ZIE67nbtxLkhHt5iHHHaCD8tvXAv3Wn9fYCzQNbfzcKthuEupC5BkhcMezO7jjWuCQlcgjo57GSXDfagmvPLujZxzwyq0KYXQANa2IzM9mvwF+tZEaCNCXAL1LDQDoOEB7qDCAjgL0HhUK0McANVEhAJkAaqGEc+bYHh/7+Vjkc/vztkKbfG5AyXZMqqRpL+t0Sprppr+xSc5iA84nPnaqqw6lDUfFmsFmiSbMTGtoC+SRQl+JJo+Mppz8/CiGQnlJK4y+D5xYDrvV28+m4q/nRCrVUlU5rZy3NLlbrLnol48MGkSrLllRHpJ4hzxEfv6iMNcJ89EZCcHdQayfZHoo9S3LZ8AnKctVSynV7KXId8j8LSBRXbcqy9HeyuylN6x4LmxDu+OwcMq+QvsmlFS8/2CbuOxzw/Cy41D7MalqZi/7ijOZMcD63MJh23+rVQEPgO0T4GlatRdtZ6ppWOPfrJL0HgnC+zbT6rPZOa6LttPG0WUr7P8wItWe6fjC3WlTlu+0/ZvQ4YuAAjfAavC6/b3yi7Z/lk+wM/Wv28T1qrLTNjH0oUV+Sxgz6h/tBIx/6r1fQJi/1s09ZzptqfVaoIIHuW6S82Tv+9N+zY09WKD/Q+qFdN+AXpsKvTa5b7dP3snaJeW41gUwEosaRlVZhy0W0pRDmrj6mYTVrTxgr6MTNbUgJQOsmYMJ99MB8wHTjVojzVa8A7OlKsAr8myiW+AVVWU7bX+vFkorjJiE81CDFPRXZ6YjxX3R9np5HXAJSWWC3SuspyrC7V20vWJcB/W3wv6V8SuIH6gzAcu29jU2cbWqTAmzu0DhDyJU/p1827f/K77t07uGGgyhBvUL9cFdQw2CnGez4znUslKVfQFjRlXWyZ1UwKoQH6FUM3nsQI9ESatO9QSrVGUhm2ttkmFQDjm0qFzNvMvO5FRlwR/Epo1hxN+8S87pDfKf0wsl+iCOY2JNnSXAj/Fsmp9zv90Ld9rSgQcbCLX5mgu4NKi39PLRZQEuEGsUbROibaYJhH9+3XgEyvF1vxoVSjS+c6dt9F164E5oHexDqjJiNYDBHoI1nc1+z2U6ZrpQBirwaevh7+tEdzXGmM1+BX/vJX9Rwxfz8zWE+OUy4v0O5kiJcQI8xcYCMl8+4p8vcbwin/bUovfa09MOtpu//XbSFzebpiDd8e239x3DvWRhTh3lvF0rTc7+8gyePeG+3RO7nQGpxf9/8m30GwJ+wX1+wXfIsWu4K9rV5aqD4sWn/Wv8if+VNJuKr58PcRVrysVj5O2ixWbOo8CVWXsMaYhVFavL3zDMKlkNdAS4+T1WcRmGQPrm9jqscOLM//sd63AesRQdcSyb3f6XtRgle9f5OyWJA1Yd/K8r8TcQ/vyfwjurDv5XySNKBr/4U/hfqnDM332t/heE3/en8P++q2QzkYT/DsLX8n+Vnh65a55GkzhmiPPin9LYfZfwKKvsgFUfbetKehvpDttUoyCHnMdLevfQh7gfUO5JpJNnACrkd9goeZLjQZek9wN6rW2M/BB3DvzzeKQyLsCsd9aD8s3/9Mk3y3AH0x8rx1XGrLWNhTjdECf5jvw9+F+knJjyzxA66o7Qus6P7lL2e0joXyC0+y9S1JS74tdCqTuglJchzk++AJVz0RZuZC9ftIUZw2Dsyo3x8AwxZlqR+rkfb283zifj+wAZ3yeI1PVMP3rIxxr5TKCHcMxyWtRa9QAVRKV2cJJU3D1YC6NnLXd/H1V0Ly1QRJdKxwB1o3Oh7F8N0CQXyv5HA5TtQtl/IkBpLpT9JwA0zoWyfyVAyS6U/ccDlOBC2f8ogEYB9AM1EqBhAJ2h4vJxPd0DrTUcoAiALlBDAQoF6D9ULEBBAHVTgwGiAfqZQluZHuceqM9ogFiALvtprt9P395X+BlcXpRAcyHtVRQl6CjQ8F/p31fA+2u+gn9t4K6Bq3NHyByHg5k3WwcwI/Kp+OnsGL8EZjiRwExki50BCQy9fzq70oMyEFxrznKU8kgFrRrCPDJyAzPVUDJd3EuLJV2JXHQxrZxhuI5SkK1jGJQs425YiUdhkhEpyEQ204k+tCeU2B39s2w5YKtIwtS15hq8bIa3DlqJUuc69lZ90YYz7BUttlagpW63KoYTa6hr/6m6eCXacY66RP1K/USJNTEWVfk5I2pxQVwKe8IvVpES3/CtyGLXe1DfFVv/vJXWnDKLNGctPxnETTGpe9i9nou2EqN4X/B+1Gnd0WdLUoyS3Ho1E7AfiTYjA/YjBVuSQX02JhvYx13JTGjTKVtw/UabvHqjTVZ/yhZSvYcd4lmwWNx0msuuurh4ZMUsdrtb3BLarGZOcWFVkq3SLVdYsQvpxe3sQq+k10HB6K3OYh/wZjg6fDuJTRvVX3bcwi8g579aizdeL/8Q19MAJcPfWvKhUH9l1miHd2Aw4WOvaLPYYA+W/gmrWBNsQZ8A33ypdA7UyKs3/vYhSsFpzTDzX3cUI86htnGjD7VNJ38oVgnxsXaz2PPAH8fR462Y9yz2mifDYYB8D4B8J/8l3+e7usnuX0yfNRmJirXSqptWEVDafvu0sF4HzlZ81fq5YdIHQcBPKJg9rMUdz0Q07WGXuFPLFEwstNxJ8BkKPqXuCOA0trO9nuD9Q5up0RKAr3q+4jyVaqaLq2js4l6o6eLWVs1iz6EFkepTXFyjgkFL5qc4Rc0pLgH+nHLFM8qmjbYp1ZO2Tt7awB50jWGUzelNV4AzTG9WQPvUeer8OsI7bDI5nnTEE5C4byCcggwhpyC1jlve9faqagUzi93tP5mGZy5DCE2DtjQNdoUcbRFttE2C9xR5AKvWscL7g21MQDIl99u1q3bYDfW5vSerMFWtIxTvBa+HvAP8qhP/b4GVQet40Zltz5VvsWmqFXaZXMGsA8yz2Pku+f54Bm1AaJomb52yFdKsb2Cnu7Bevq3q4g5B3RyvmcU+4EJdaejR8lOctgpPkgU0xxMcHbyCWBObxea4MN14Jh3rSS7U0yiop/TmcKinnVw4qSeqr566bGHyHTa5PKNM6wjxvgaU6g5bKOS12ZNWhneOrAG6Na0saMdFw2lOVhXeNIuVuwZsRSyjmYGbT3HpVQ3sH86B/x66f+CXA/898Mscg6ZYwTSw73M7bEMB1wio13hjpT24/GNoheX298sDtuxzuzLtTZCS1nvSTpUXEwtUCmIPqss20n86aJT/dNBk+Dfc7xfn95sCfsP6nRjKNaaVTaqvL5lcf65kSv2w+bn18+b/AKECa2R++0WbHjiLKUamT/P6kP1r0oZjuwKtqe7S2mfIhXN6asjdT547cze5X+6G+XMyCf7FkVN3XZDL27kbRajvD62BsZXUlQU1KuBOBtwH++EeDrinkBL/d9yKfrUx0mi2rrA3w5/jcpJjx4Z+2OJIfSCWO+txkr8e/4oNcyrU4xTjPP84F/hoCfNGq4+d5eu8vXvSJ9nDuf6irZVwyk+sAk7YiDt+AbtWU86shbHaCTRU4HQhUmxFXTh7Jd0xezHnhblpjyvDMcyz07b9rnNTWr+YgJXs5qHM+WsoxwvkXgCBR+0g/OoQo7q7E0oTmHc/OSOksRTSuOJG/mSn7VXCq2C+A7tWkGPjXivOsyjhf6cKeJvqtcBrAg8Mbkg18oiqMtxz6rSNJeenDYzAme40/McwomwWa+TKGIn/rHc96+ZVZRLolVLolUHQK4OhV6rK0BYZ7hhpFXX99igHdwk5jIccbnXvtD1MdjD/XAvirsKCYliR1znv5H0fWPXfeN/+XO3kVXfnau/kkMet+m8c8pB+oUbeNdQQY4ifk4XSSNVMFtvmzHDc4xb2B//aqq/evP9DDPUehIpzQ4jqnbZYYhXbYH+jry+9yk4koWohVAhpvRfs1moB3xvQcu9DD5b15S2k87Afuk3d/gEUrNT4+2Wq3Qz0GpVwI1/YH6TSsa+LYH196EPk5Q8pzhWrykbZZNVCixqYIraG79+mkXdtU6E9O7lPqQzHSneG42NXCJSyE1b0DEerC3PcAznE2zoyHEvcHTAyUJs+iw3juvpk3orTBihjPJRxq+u2bEcGPfz1vrLd1/nXWq8Dyh3PcQFWI8oEnrRl9vWqif5edYvLcFT8hT8PYE3ovHvv6T+e6pB6B3rmiwOFN1wlyGvvIafzfnIKlMbHwOsbjEesT9rmGrut/anDn8BvnvH/XH7S9qjxa3g+bvwRnk8YrZcF/iDVibhnmwJ4XyB4D/vx1tk0RuRBAiWK6rxUNvyVl0wLDLWcJnFeG+7XDjMJO68Sc2Cf4MBR4S4uKl1Io9VN0mjLvfZxKqbBkDT+4RS4kohjeMs88tUhhK82cx3BMpOedTsbDTKTjq3jJTdvFIsca9wCzT/nQoDfvgxrr45dTfjtdLbwaIQpTqtnH/0McBHoRQJla8c57j9SOUN2GLX36LQgs3RmrEHQNKUUsmO0wmNtDKcUHfMphdggNp1dngvpihxXMfZhUTyeUMD0S9yKtjquNfj49VwK8gGx+N+jD4sZhWmcfhzQ9RNYvXtsQUo+naB2PO2h4jX5ascrHs1Mqk6j1xQ8rVA7znmUzJiCUoC+BkhdsAigEwCNLngOoGOeJKJXCS0xm1IW3tjw7FLwrfTEE1/dtYhlEmVY/HzwW+QZAX5Khq5bqBoQ/yz4PO7BPWOqjoqvhK/3PLEFQyH1yf73RMhNLLwzPUMK8D3eg+cFsC6L8qJlKzTAI+UIOoyzOqNlT4CbODVa9gy828CdBRf2fbQsDZwe3GJwZ8D9Ci5yZJQs/odo2YiRgr7jW89EEn3HiMNRpK4llsh8nq3gaUXEsTDDwAJsr89d6rZw/AujdrnimjWU+H7sUhBrLOBHXbEG5ws9qbCdase2+dePQlrYRpjWV89GyoIPh8+k36Jqb0JdlSyg4+X5E9hFLkodMlNyPrYY2rL1cU7iFiw1p7GZ5K4ElFOfnR1Oyox4tf519rVWOl5o5SWAYa65k2vMEpseLdtpG1N/0TYGx+zEI7DyZLLXvJ09I/2nbzMcqzgczagDgSfmJb1zxAo9VasokPRGiCnoEVNdJ+1qMvOkO8Qegz3EiHaohW+3ewi5cyemAEOmoPUWqpPbUJTusLsh/dGoWyQybTJAjPEYTsOE6UNI2MEu4Pl6VOQU6nqtlMz52mMUVTURzxN/c0Zo03Pw9pxBfpLLoxJHMTPI6JI+e7xHNHc98xaDJzEitLJ3dOwyGImUUoWcJJSto0ehEjDv4BKAQ6wDzlA1dwenBngz+KXAewu454rWcs+DW16EFsklN6/P31ESl1avc1vCcLfnIT0zlVnLvf2QMHonOpvITsyhFR3ckYc6uE8f2sMdh3fHQ2u5kxDGVaxj73FS8ZJbL4iF+0oKb/HL9nBV2Xu41eDWZsfmZ7FO4P1Xy4YAdAOgtbJBAP0BUJXsX6axjnyeSqxixjp0fJNOdvZhLrFSy0ww6Nj1TkMbpLoCuNwsTVsaEwL1KIZ6XOrEGYtbQ2f8YhXmlStBkbIN4P4NLvmCUI9oqw3qJ2Fj66keefoA1akeGX2qJyhPnJTIvMvsYgpv5D6Ue+uDR0P3UbVFevm+LvivdqS58+KeNT+tzjcPvTBfnWMOvzBF/Zi5QK8nM0WG88FuOulXqyjpklWc9JO1VC02L1L/YSl00HJwIWesz6pnmMUXKtW/WkLftliXqiXm59QXgV8Nqv3GKoeaDN2mg/UrayallrXHMumOj1wiJpQZt8sCNZfuKPRA//KuYQ75w05lb/EYkla8LmqxdnEpVWMKcmHUuTlK/YlZTeCbAH9sTiLwHwB/ZM5jVPqRpKa6ODrx7324zLyYIdhUwbVrrPvbcm+tp3TsCU8VU2MKbpDUBjVAfy2Afrt7IvMokwoz9TFfLiPYgsKb0TnrAL2M4DVxTUwv1D3eC4W0QNXacVPHw3yzbUkkqXu0nf6HJkr26+eRZE7KhX+oX80eDmeCmPXQthe4ewwSJhvy/COnmEZrW2+Knwk9W3hDvADyIFbqVQU5DNb4yxylmNiNspsstsJX1YbvTF/wyPBzYw1pfvv/Q/VDyHn+CWwpZ4VVlM/6gduWlasJh3pfx72dFUU0xSewD3Ivxf1ozgYMib7T1jjlvLyg3m30+tj/KaLTcL453kMrj/eIwUkTvwIMwv0y284L/akT3jfP47hkC6EMzCDosVe9UC+hwcxjTKEjLgSwycc6Lnofnj7y7EOcRkvXDjVgqyRwdMPDbZCn0TW6MHOIm7qROtTCtUa8qRNb5kwL7aVDL1lprcM6lNFCnT/NS5gfoMdTmth2KjHFpDBAm51PhlyH+RRxsdAXxKRFbHmJxbdgLXv1cBgTyTSWDYIQ571BjPqowvBa2/E8cU0y+Gax73sp9TQukQo/L94eYspie7y0QtJaeUzcnMVehX9XzeItPdbdZXFQn696sD4lekmBihErsvGuP8UVaOdp54Q6iDi8UClhSgt49mV+oXJhAVIFKwCaT6Cl/EllCYGe5scrnySQgYd1cenjBJ7PU8rHCPQ4QPMI9DBAjxBoNuB5iEAPAJ4HCVTAu5RzCDQN/GYTaArEmFUg3O14UllEoAyAHiCQFv7eTyANQDMJlAS50RMoHsLlEygOUptBoCHgN51AUSSveQQOA18dgYIBTy6BRPxI5RQCeX0LlZMIxPko5b0Fwl1+J5UTCWQHvwkE6gEoi0C/QIzMAuGcy0JlOoHO+UYq0wj0PcRNJZAZYmgJ9E+AxhHoK4DGEuhzCKch0Kc+BXNSmVwgrLeHP6PaNy6Nku0CN3pZlOzpp2NkefCeBa4YnHxMpKwG3t+D+xVc5HNRsjhwK8C9Bu7v4C6D+xJcxvNRsq1no2UmeP8GLmV5lKwA3FxwF8ApV0TJloP7ENxVcNQLUbLB4EwQxwDvs+DawcnhXxG8O8FdARdxmIK+MxD6zhNQngGkFI8AFEagOQCFFgh3BFLKEALpoYyUMthfxjx/GbF8mN9AXgx9uIMBtxZiBwntT2JL/LETPtsG8ZrAHVoWCD8SwsdC+BEkfDRAwwk0AKBhBAoBKJZAEoCGEIj3UspBBHIBFEOgmwBFEcgBUCSBYGwpBxLoshdzEu7PyUWYU2752wjbA+t7Ozisb/fzt+v0bL86FMYdlu+4d6G/fEcB68K+8h06tsGP5/TzgfByCN8E4YXa3A1QMIHeITGl/phbIT/94158vn99rvcG6nONt399vnws0N8w37jWrmL2tcqAOp7CjuXxhCJjvsi93QiuKqGQSgjvbQqlkkK5xqfHMEXxDzNT2H/wlQcfZqayP3pp9R9nd3AyrUpz1Txm3+CWPG7P07OYhxmN4yVnq+6nrsFNU9kOb65pzD46O3ZaBFd0b4pG1k5xRRV0/eDmfBz/XpmJTv/WOnifjplAZq5i75dWNaQiAS5D41/B+HS0n3dEKaxRHPRXH7garjWLzjn/kUhT3y7S/41TUaL8yhlUewSsWVOBlqg8HAQp/M4H3bxRKmai9FFAy2WzWi8NaxLtGO+FVcxEKQbowwqy2UQvzuCtLhH5l+DVmkL0QSR8rJdSVB6jUtwWqV5UcAvy8dgPwpxaCe/XwO0Ad/qwuUfxlISBNfAppGtpxxgvre0Eyi7eHJ03wizpraIy2RZn4Q3jUkqV7jjoTncMd1+0Rfv3l0cbkQemlJQKOT+kCAMnB5RGWhHeHZ0XbslkKzigV7WoAUanAf+EMFdDiVrNwB25rai7Nrbn+lQJM4BJPkj1RkiTZybrc+OxNkc7tfFpzGg93h0zld3jzb3GR+IpqyFAd9xrTmOfdIoNkZoss4YZpR9VgO3wtgfqXSsSTsFxRUWDCy9yFVWANaiOe04bfTQ3ntqcw+hg5ZvCchzi0zJ57B+8mmjLP6elM/Z/1GNNY8cTzCykMdaJaxTqxqaRll7sOWWlFKesf1REy14AfuNlcK/9KNTtfnjvAkcdfqOVbp7GPuludVU5ckNCCI+BtwU+/gr23SBmR+v0/HBmCKyhwS48hak5L2mZyuQCnTrElX2QTsiFP3IXlZJlphJEeIdPj2haAXvMI96W5uj2jt+NWnhov7iKEW17g0lzfOUNZURMAZML8Fqg6iKc42bSNdt0Q85QCn13V08QnebgvEn+eMm+dAfP7eAMWrqG1nx9VnVfow53+emEE9YfTRlsLb+aobe9CbjqvVXMG0wR8wjAZ7yD/fFDfEhF5kJ6aY6ZkNpZjq6hVB8DzS2qRXp8m05kFjVnwpxI14sa7o2Pa6LdYlUuVzEpmRnPRnGUFumKEWScbP4h6UrouMjJG22HG9mvWifHlMbILKItuH9RKGXeal3PbGKo+ARlMIzK8e7N3JaIZFNwM6XE83eP8DTzPdcxOrlwzExqTGz7KGbCweBm/PODT8JEmHAMDus+1SOmTvVIqeB98fqIeGnvnCAx4HrFI943Uk9tVcRrmcnsNZ7aIgVubLh+FpRrMvsbjONIkj/E9iFgo9Q/Wi5y97XSSYAhJI2JJHHzIWwnf4qjajD2PEaI/U8+F2J5fJT6vJnO/Pim8dXLliMwBut10bKFMAcsGRIlWwLvTuTBzqKcIgjGLaQB/SvHjZwQznq045GjVPv9Z4W+NeownvmFEVSzkZNFSPLFtWVMkOO4R0r6FtU+SBcuyz4Mo3ihlMGTIrQjzl1lgne8j32fV0Md8mwXlIqC7508cjTZkMLIo9nH+N+hrvP2t1LANchqgferyWA3+YDXKh3DYOsHO2indB9dGzoTxkGLaPMGFbZ8sGOAM1hPqWKvioKAG5MUXBUHd8A8MhZrbQ3VPhfyg3S5H3dieG9CCM40QXOlNbhjtJGLi8iAtRlKawhiBkK9YU7/xmNKkPbCYEhNz2xQAW/GiOqCHT9ywIkyPnYqL6SA+B2Hpcz+W9PCzVxj8JAHfEBR5d5KE1Hx2L5xLka1kRugHeso4qiEYKCe9VyjLgYo5QRtvYHaNNwwHngycUl470AK2t8nbt7PhVEn4rC9l3np9MvW7wGrj7X5wiEFx7FmmC8dh79onQpYRVr6qk4sZeKqN3JiBfT4yrU6uv0wdzx4Wtxe7viM2NXDq/dzEu2bZSMNWlhzdrhSGQmMz/DeICqVVXoBc9b7I8Tp+zkqV3rzxqKXTBdWakn5v/NNZMoYzEOqNx5mKR/7D18e8AXfc3tmUCm/m+u4iKk9Vg7KbSa52+77HjgHae82SdzoYLd4xqe6AWYqaQ6XpKU0kvPjmXiCazdPZ0rGXbfEpdtJqYCbzfWxVZ/hHnLuNfHgjtZggi+MqYEUn/GNZ4Q6NDoLoK2xFqeyOS6qTsqImQg9Hy9pmgy01EZuIHX8I8mIzOEHdOFnxfvGACcfOzSV/cgzZujpkeLmbAYtkvDst54fSV7zfdPIvEy1x3ViXQ5hvmwN8qc7AtJN892vyiapAeaiqawIUhQzUhhpfHx4byS00ihIMwLSnDai4+bqZfv8qU4gqa7wp6r1p/qW5weSarhvOuGrME0t8C6ft4qg3aueNcDomeVaYEg0yvJlBVQazEiqcoYaC/wqozDAmOfRUs+C4qmt2mMpwI8MApd9+ARwkUZTnkFqDC6Q5QuxbsfZ7I+DtkssMG5/OYtp4tmIt2AEwOhV4QgQz81gf/bAm+4kOfw/Xro5Qok0T5YnmUlWhvcOhtXuU06t2s/FaDVKnUoKK8BGbjCUKskjxHnXGwn5oqMy6Ln3PfMUzpXBUJtYlxe5D6rA1YBr9LFvwJopjhJas5YrIiOCSlQzmex5Tpipgxi5RWifF7zC+0XvdDLz0RmZbJ2bUlvNWgj/qlPCxJpotcLyBUN1n2bQb6bzUYaq0TNCjyjy0inYJwae6fhIvC9+xNBpGCbZvWCEpFcmut0fOtyZwGc36Y5eOAFzYuTHUbInoJ7GdBKdhn7lOATlOATlOATlSOxXjnsC5UhC/Cv85ZD2lSPGX45BgXJkZrJaUg4sd6hTfRDfQ6A86oO0eqTlNIPfv3JYFp2/LL95/lwWDPOF689leQLKMphr1bVdOG79J3MOyhMoC5YLy1PFbAQ6NRyolsecwZDSVHYLt4qh7pljxpKBa82Gfx1OSp1unhY3GmjfqWweh7Y4ZjEITwLYZkbIyIX0imh6mowRvzWVVXmCmNyD4u1UnYaZB2vOWx5pM9IyibziqLRBfKM77+BN6slhllQG16JPgMvHmYj2UClfmalulIVMY3/i4tpQS2UurG+KPskLn+6wIiY1/wtKN9J/Jk+87xrvVV3yeSRZt7Bse2HNWM20cmtlsr51Xwbr/j0uWUN02zMOKk9WCyU0hTU/zKQ4il1Q42RNVjCJJK2HIQ8WLriGUpeZ580Mql2QtIsZzTQyki0ox5bWBm+bxmY5kbrPMNMZMS1/K1AzYxxNblodaolpCKrfPv1I+3amXtfUPoyR9dKyoE2/WlG+FtIi35dPwm5yi9XnLSEN0vpaXXAvHSw+J6+XbAp9x2w1W+QNEvAVnQt9R1L7D+tJS2jDO4BpJPOFFdOdDbVNi2X133BFWtnVYHGtLupCV8+AGjlQu/J4yh3iaHX3OpKBAlL7NIwe3gm+yIY1Osk5vK1zpIW6Z4olsn5AQ6Ej/1mT+3pvtW7NuU3y2XkNcpVefu3TZ0UKqaPUG9mgKKiXD2hA/xF6kSKLzeHphCXWI9MV54MaqNph+keZ3PgY6JG73JENg/rCUrUiRcy+aH0Wq+Jjmoughf9BNEv0Hw4EzkAMeIbw7VZJA10rBSyiLY8ycr2A5xX3OSvffVOahG0IbodfDox0az7Aq8FlgkP6tvLwutYY6LuCramRTC77rC+DXevavfG2rSmtNtkg2JpKhXl7QHF/e1OZbK5HXRzUWknsTWWyz3oEe1O47kiYDjLORzHrmcEw+6e7AyM8l53sk+wvIGMcKKuqHCYUVgA19PFR7hMfzR6B41LcfKBIwcjGC6OwwSnMikPcwgqDY1B2WDSTZ7/hZTAX++eWv6Tpct1OU/Jf0vzVdfc0S/xpdrnunmYyWW+2tkqYJEcJf3+BiJy4ZTxJji0+vf/Lyic5UnkRzKuCbOgiDx2JQOM90/3QWIiRwU/zx0iCrzHA7yY5hkM8tUn8wnDTZBJuqCfRNIYRZEPRECqSn+iPcwhSieWz/F9S+DeIz/B/+dyDgZaeq5rK5Y9FSgjKqU1xvOal1OHn0XoMVavRSxpy44Og5xS7glqSCf5LbnV+Bsv4hDEfYZbCmM/gpA20Rm5R6ofHAyXZlOLweYJaFIJsyQ0cInAHQf5ZIsQcBDHiuKCGoQX3KuflYZjRfCdQ8sNMgqzjI/cQWN8+BJrrY3BfgtO9FCU7D++fwV0G9wc4N7gQ6Lcx4EaDywA3A9xscM6gSNlXEOdRgBeCe/ZH7M9AH5fW4Nl/aFvK8aY3iDmJu3VZ54MHfY/3DmSxL3lTmXuVdBO1JZd1eXKhH2N+jjiDGK1JpVeSsVXmjYA+vZhR6CUwkoNgJFe5kWqjHM96gROPpxyNhF/3sb8R22letyC7I3ZHXEI7Cqe5Y8jXEDdaS/Sxp51ikq9VXqFvHXJKHWP5DPafXEfPSBpDjnHhOZaf/PymA8t+BukSCbG72nQQ9RGBoi6lIJeDvYgLb9QWQY4e8udol/O27Z4PSY4eI3nocgs5+if5/y+XmnAK1U41I4bY2f4cLXYKnAPP/tqWfey1s7f3Pv7dinmo4Z/RVxaIGUz/Bw/WbFfwtM4KGPu1LuABavB2+vICarOyKcjxs9cwU1kboYxJS2bUTUm1uazOUwohV7pi4gfUZLLfulDO62NlvHgk01Wsn1eA0vh9HkoVU4uYtwUbv38Mwi9yrWY6gQqW9G4LiVOK3OJNyF/MZKjEel2FeXvZG+s36o60hzNxabesyPEX5evYW3xR2wMzH9BPhxZfTewSbfXQ6hbLwO7xbDrh/W+YmZkz9JNIez9LShLt8A3ssRQKNAX05ypZSt+ql9KcwR7ypTSkteXotQU4jz/koVUptSkNZ4JF32MptntSGrb7Ydab0jDPDxdArOF++CWALwYJ8E4I844f/hrgx4NW+8OvxPV44mtWaQbuVG0Ym92+IXG4qWH9DijlCOaSYZ8u6hzuiU9l5dyvxUhxhHONxbltg8l+VhYr9yibetit7u1W6CkLYpmQWsrxiZs6OlCPa/xTftk72iFGG0KGL4A/hXcV+P8CDu0D4drQAvAX4MLPR8vuBfcouI/ys9gF7jquThtNNP1n+BSwcgyD2XWue9B+tDqgZrRsC4/7K+PZTG8n2XdYZo4F2mqNs7WXCg0+N559jtulFxt2kbwecqN0CbhGFZQ5Q/Wi2MGLwjah5s+vq8J7H6DDt2Wy652Kozu4B4oHHExpCd9eBz3ieecO7kutKIfWrG+v45YX13HPaw/qIoF72qxd1raWe76YGjcdvk6ORl3Xk1nkXgyOyNK9n/TyU+43P9BMqWiuZ1IR5OxhGPuUOs+ygytE7QpzSsss5mVIRec8xl3Q5t76V1St7glLl238X6w1njaJVSktMc1E9uxRdndyh0YvKRBvFr0Fa6dqWFMGOx/tNuVsIOeo7iUn+09mHYMvvI/Ky57mqw4qGEkD4uDZbI8gI05nv/DhjcUh2yiHwo03Oievwv1QPLtZ9BstSjR39UieEu5YHnUaS0kpqHjcK33XRMEYhzSG8Gwah73pMj/HSqs+sObe+jeUwmJBvyN8GrPbKswGCg7iZ6W1YY/p5SJIq+IedGOwl32Ux1FHRlxtRC2lOsnIayMatk1/2nyGi1X8uP6lEaKs9o8ia3PkA2uppHcND3NJ1OwRobWUutBBiTdyrdpJ5+QNO3SplvHAOWLKFtcLJgHm2QIutB5iRAAuKpPdwEW00UqIo9gB7oTpXcMO7l7tkMp3DbPBFTqmiWsrZVcZ0S5DVPU3lfCMkj+7yxBZj1g3eGNNYTXIAX8KNB+dJq+V9cbJmq0psAaVc4iPGvOHuX9qc7l/WieMC5ctOX97LGC/HwJ+gZ4xAHreTK74KPaKmdDzBmx/BvpENhfe20blsntcnGm3IUS77qORlbsN46PmwfM+ZX3lDu6I9l2DNu10Zco+8T/fNbxVXFTcaKgCnq+NDtPmsl+7rsXtMmCuU70oh43Ow7qWWZA7EJd1cjWKel12O9qM8bKNvrCG4SahLXb6yuJyzNgedMYOXchp6AGq+/Kp+KjYmVMDo+co0KV55+l4lOamNJ3iWls3ckcidGyxTzwy+dxUvY6MOLdz5mUx8w9reVy0OS5pSV7I1SBZXWbStGDmQU4yhdJIzk30t5bLSWdJ7rlu+cLaBSlAivSb0OdW61LaMTUq8SvrlBtJB3Zwbdrzwa/ejD/wrgHGe/AjTAa7lx96eVDTeHYgcD0uS/RlxLbLN6wpHdZI9O/lsG9fdJL+lRTkFm/BXVYZ0OcDzSNGiXvDZHM5yUBKLTqfwa7g7ylumn7LImuIS5PV/m7FUorOPwyplEP//DRYYcpgx/KoqfBpVsw2GXwl8TjGReYiCPMwL81Hfa7nf8U5DuVVr/vbHNufzs9nZ3xKtXPhlALhhX648jDP9vJxM4cZ6PEjGYmFSuDZP3i0ChZ7v9qgPujXGgLfX3g6HS0D5wJvz7M/8gtTos5qDbq4geY1cbQ5i53qVBuQI0ovptQXzIKtYLRB9oM1zUCn/cdisQqaKRLmlFXQcUHdFrSJhpZU5V0PGMYVaIEuH+NUmMYSKNGpaKMUx65U5nrZL44lE7/hTuooz27jkwRtm14+XdorkQab0XYOtjntxDyEdiuYZMbLLvLh2QYVM1IfR/5e43i2ig/uHk5w3eQUbTy7kkeOsfLYEOJ3lVvfhnuvAwj+YHPUzFiDwiRY95MwF60D9fICSvGNlWcf5JNHFI/0siLfNSjP6+9AnS8RdIqwbHn+/fyH4Y16QqgjhOVF+2gyqPM1QFlHHJak0tledgY/4D5FcY0J7eZtm4GncxQkTaEGVcXB/tvXeVbJRxyT6qWkLBu4HkgXcWJ6Kn96Am9Qw4xivgnGuel4D5V2vEeUFs7EPzfw+4cVuexTwG1HmKYCPdXOJRW/V5zUFq4fQDAu4PYFR3xfeGNDZS47x4MWNidAqMHu0uJfixPbgvQSEqqIQ7oJZV+Nfn2R4xeQbgPe1tBqohwdHNqNG6AfSEJP4OTdagPleMopZrJNof51exyHlueyjxkMsjY6wWmlHNddKJfmLGL9z1bUd0C8BsC7QcBtkDB4dzrl2MqpoZVoT6lB+D7rwm+nG7GJIAeUiVo52xBtkrXVcpF05Qw6WWyhDPngWzlDlCyx5BpiTTXkD/T9GRTQFpTj2JEANKCtckau4PdJAPrlk8Df0fB3bA+bJ2WqDKhPpDZ19cifIjtOjjqnhLkCuFEHiHLMcVMpse0KhugbrIl00OLYdrFhTXGkQ0QPa88zfFH8eXHljOzD5EZEaB8qY+q1lOjtMN+sKl5TjHZsxXOnl0iXT1/+2vIvlzdyc4qSmTitxvGNG287zKaSHdOdQQW0QuKweKUF3QsR+tarKMVaoNqvd0XLxP+JlqFNEdQbxJjfu4V4Oc7uColD5lM8LXFIfaghQZ/XsemuYihhLvsQ0ThcdngAMzg/KV7HxrmlIyXnUtkIYtlwYDfuNb3NT1GHnc1VobbJANJz0oCymM4/4xhEoU3eaXFKBnkAHfuzb60OKHazjpW4Llh1LO1C+c+P1k+GRMmu+/vOMjL6efZLHvUKlYQryWRH8oU3zi8Nikcs5yCWojgccnHKjftXw/VDCzQMhgqFuVC1HNNcYKhtazTksj5XEFNcXNwWrY8geFxQQh37Jc4JaaripOVXrBomnOiUZbK/+2iIvWA51gvqgYnTFpTgbltlrsZx4Gh5l5C/vfD+GtxFcJRKvDwb6nLnUf73UZBvUdMk9kenpPle4DnDJuHXL87CG+tKRE3JjoWcignSi5olvXOofHYTh6GTHbNg7EiIHuLGeeHAw6EUlUpcs1xK8C6D1j3knENpHC+7xMCjickdbZijTHbzZ5XHLiT28ShTzT2i2bZhm3US4P+HMHHf5RrGMLHTtOwjTkp1qfiSodiwcvh48JFdldJa9gHnJcO7hpHTPnZfuy5yRy9Sll0unjhNWULGcaLVSqxSrxzADGKKDuIOm7Jst6FhGFJgYe2UUqocM61eN+oMfItjzCLVfo7SBjUVkt2DdJZyC3uq4x0hXqlyPyemBD7zA1hFxhBdqPd5wVoz7me6rGN7rs/4YqWEGchsYmD8vHHaRPXGSane7CDoUW/8jZlAYn/M58VFWdRMPqysWkbj+NWVe+sIUBVODv1+5q5Yyc4ozJa72gn0uvawuUec8ejwaQbZ968ZNNPipoUV0/GRlVWG48O0x1TTQospVXQlVcaRHEB5e7NDdq9E+vuNKgnkYPfKBW2I+xCXzORDiotdSSvx+98cNc5h3ruSGvucpYURHYCwslzmFCdpDOKk+/PZt7nxDE3o4s/41ptVTwYzId/t4MTatDbVShXMs4hruut3ay7gauaoewrMOAItnokMvR17Z6GXzghi0O+0Z8HYkC4cmSc8+OdFL8InPVQiNS743Aj9COgNmWyNF3v9LoLvCU5V1jBcVYLwS9yCsrRpC0pUUKZ9lv+ja7ZgLijNXovCsGA5pcYevg7G+mROGA3ZJjmMBMT4lNdoncz8bF1QFgw9LpN90rtUqN3Xqfah/nGghfeMLkEPeTy7zQU9k6EVGkcD4bgfhBaOOHaJ6ClTSlyBj3Oy+ONc2NQqLiK+iosEOCZy9dKIY4E5ycyF0Tj3ZLAeoMFlNFIz7X57HqMOmzlZpIR5pK3wxtqlMON4Ojngo/Pjgcp5xdUBoTu5sFTUtZXnZwBv3QG4yoFvDosMgu8LLkq1m5z/jEwVxlrRozGybeAo1ZqlkJdUtEGF+9eCnb50dhUHNbqsjotI7QDOItQE88IyyFMklZxjwZQ1JOVckjKGyjmI6QfVCrfnpAO/Ff/+j7AKoBQx/v7cWx1ReHuOjh0KNGFil3CTTfz3ohbMoRowvek6xkUoVG/U6wzMQEs6+6RT9QadplpVeOPVvAWrKAWeklQyA6Ask11fWdPZwv+LuTePa+rKAsffSwKEABIEFXELCUgkoGFRcSv7MyQubbWttVsQl4htpXaRpraiotW0VjTaKtSlY1sFuhCVqdRSbGu3mToNFae4MNBqTalNJlTsewlZfufcFxCn0/l+fr/vPz/43Lz77rv3nHPPOffcc9+7i4sfAbV+J5RJtGEgoVc8UMc1WMPVTpq6FphPeDBxPFky11/f6H/xsssiNjatqQpoH2XZZAyz+NkN/kpOelcWOZuwCjlF3iNGE3/LueEzo18latlk/GwN1RMRQk28YT1kPN3jCmrMU7ZMhh4umckqmMQq/IeNqoJLxzjV4TVHC96+HhTcfYGfj0Ypr1qRsnYbylpt0bDRnJwJKqpU38HmcSLwYNCuScGuTfiIn5P90c1ocWsK6FnjtoaVTKIm2fmeT8SUWfg9EUXOye546BtQW6Ue/r17aIO6OahaMOittPTigvxREXFk9y6Rc7Qbnw4rwrRhWix5o+8HW/TcCeXUhM7W+c6vivlSF0ipIeDXYSmalBKTUqGkVHsfrVCVfQE8Vv9tqDgLePpyCSVDWpdDfA/Et8MVNQq/D2/GnbwZsHe1s1mdZ5JuVDmlyrJOJNdMayp6leYUHV1dnVdw4bwlg833VzD03m1MmlPr5b8dF0F8q3c0mZ+Q5mzy4vwE/HKc5uzrS3du4+iqMVB+lGFmvCgwFyF8Vjwzif3Gz89FCCI+h3BvmjPNGxGA8irAFuyNBBgjBsE7D/CKAd5fbZTsCtSvf95C/zyGr8G37ILQDuE7watF38AV9YVK+LQhnpkpjz46dHc2WSm5Tq44Kof4lxAPPepnjX6s+dB3Rh2XHg+tT9XmwAg8m53goXardCnainj50ZnsAf8WuOayv/iCxiqYGReTyL7HImeOK0E7vkjBIO/j+sADIO+k5fPGzO/knqqgE1VMOoPwZrLP+yviqd04BwbhPeMX1Mqh1UnAX2htpSc33jSu/7k15zdbRow2ikCOduFdFPgsCPtXN47t/mEbAlYwGJ6KXAomTBsCvgF+y9OAXPf8Bn0+XPEb0Ynfbsn9LYhfgfC33/hvR7jjASXf3/BK0QZiE6M43NsyZOzp305UFP12eAF++6QSKhQvzsMvn4nMfOe9YnFfUPG9MFYeQU1i13vvlwfV4ozeIjc9eUaqqODfrc/PPWh/waQy3CUfXUDF43fUFD3AujebHebeqEA4AFWf6NzXlyOnmYieJCqbHdInlT9RhDCzWXEflbCAQN3Ojc8BT86tMsQWKPWF8ngGoWWzPa5N+FVWj7Ay2ZHuQ8w4d4X7MPP2sWOFD7WrDJ3c629AsOQXUAlZjEo/HuhTQ67tnDTnTmY2K/OOtaQx92oEzs3uTMs9IO9RTXcxC6Hl/sMnqguq1TACZzF49Zg31Uul5NzYVDFPR5tjDSLn3a4TN6n1YBH2HW2Z30utwbr/3UXXBDP4dL7rRJ6kZT/goRIqnbSImgjtUpR7MVuXU0TL48oEsmztFDbcjaVsriwml23zUDgH51cBrrTcoWYy2RI3zxfkxUa3Gqi+t2G7XWjKZCvcegutHGYV1pzl7lPPDnD+ZRedWVFQYRPVYulMD54NhGdfnLULjd02IUmd4LlqE1hVhowClR6/0Z3skUSKWrH0my6c5a0yXOIoWU3c8Z5D69f//tj7ME71yiyRWhr8Dqk2ukxl+Dt4TnpbBLEGB1vFurHl1MSaVjrhe9uLoEuNYEc80MYo6vR6/EbwM8RNoHNzIFRBeCmgf9gn6yF+FZ6zjWMZCvQhRB1toFRBYEFimJEXM9kn/VVN08ALz2QL/Og/h13C8wUy2fvI6QIKSzoTb8CnhXhP4XxtfB7L2G3RjITMsPmuRU328lDr1NqR5Wrdiw3UBHFLNLRL3L98CjvHNVE3STvKkEJaU6ELbFu5rilFq4T7kIAs1GDhs5qUuglzzXbK1GlXmpRzMtivPSqDyJykOzdwqlua8x7/SYfGhHPxOu1yo9KhNK0gu7ImkbUkac4OtwHPdg2sJQHb5VYYYslqknCCP8ilgrHBMK3CMAxas9A5xs/ToIb+/yvg0wcJ0WL1piix5wbfz6BNi+qNFq8DPib18nzPKUHeV0wvgOteCLi2JAOePd3Lt32071TCZ8T2BTO89ZvH3bJ+Go63fn2eFGL9FMdjwfolB6xfnQuoXZqkUwbs31gvb/9KPUFjwy4qGIVWATUROk/7FIxMG09qVQ3ebj6x52PB+i2tgFCFFnB6wAJ6PBXxCDWf0RIb2OtBG5jLbgWZfxuwgTZiA/FbKkLf6cO78IDnV4q+4ORvAvaOusHbu6gbt9u7uBu8vcP6P6qLK3+/YS9DJae10tAD+dlKj4Ho8zQrpZxqXa5boV2hyYmfyb7nUceL6pdpl2uy2RQXfq0o1uSyB/soZY5Vzdo8+GVihvVB3SPaRwgtCdzDJCZ0Zvse1C4maXHcJFJ7NfstyW9rpTNPQJ3EpE4LtT/YFs7VAmf27qQTVOVvH3uuKYf0CFqG0cxkH/Mg1gLAuhSwXm7FfhzLHcjrtN6hm63NJ5oi9hVoZ+juALs/mf3Rn6ejEkbrM9i1fbk6fM+co8vVjNbn6kbrZ7I/uIW1szRK53rXIwph7QyN0DyTve6WWaaT/fwns5/BqJUqngw5lrmm6KYWUXJaFlcmdPq9k3WTtbH6iUVw1cxmX3LJLJnEm5nM1voz2Ny+YCZNE4nfqsByiqBvVjMi5zteUb2c9NQi58f+5CIZo3SudsH40ZnvUpI7gysJeFvmzmBlfZhX5Kzz4+yKuW6Rc62LVmwFa/MwyBZ1HOXbP88TZYxzPaVwxfmeKONFN3h5J8F1N1y1N/g2ge0A20NFCd8+jJCONukAXNEm7X8kgtiprRA/AmkXL8B4Ga7dEGRvhFD4LT61uyw/E/SmroFK1lsztBma4YaMOVTimLLZrNeVrkvXoFVPdv7QlwrcGeHGUTBFJTtdbnwnkKJNIZyK8VOJKk1ihdL5Hpes8bNZ4B9msIfdOK9PxowvUjq7cHTtPMElEO5c4EqJNyVyhnhXMXIyo1TkHOmnZdnsR64MdotbzqyCFCnh2XFXLK6RdD7nHaGhnZP9Gcxw7XCiH5wng4kGrxs99+98fvYpbzK+JdjE8xV5grYY699vq9/o5XmKPLMDP87Ava2X5xfyqu+WPZmPO74+rXtmHpXw7s3Vz48uo5Oe0mWWne2OfGp02aaxQjPdIw4T7P4LA5q1KD0xoicn9H4G52hG1q/SCvcmOsu53NGG1hgLJfOD97Bi/goNfmX6EiwrjvKizBlse+Dbdpg1qjaT/ZKLqoEx7419FW5V7g3DZrciyhxVM+wXRVBWyxjmfk0Ge9rX/2XbBPnf50wk/+aKBTqU0t2Q4/1ADjHJcYDkKO+YS57PgecHA8+DyPNXOI3OVI1vL6PcW5uwRRZCi6yBsdESsANX3NiuH7JCO9PmEjnLfHTCzB+WKeVW6eViZa51iTLemq2c2joDfOcSVUrrdO1Uki8c8j1je0o51loOYY1yfCuu1rrAUdQdLOehlDEtQQyduMxGKwTmaqbYdutpt4dfGTb/lwrlPbapZQtso3Xjyu60He6RCR5O3t0i1yq039gUZLw9mW33/o3AyLGt7y19X6JYbhO1YG/+bOC62ZbLjASd2euFMdTxEVopKdXsrbH1tzsryHw1jG+wz+kIjhLXQMA+6S24oo+Na/DQtybtMzAOKpBQsjiIT4cw/ya/Pgx1Zx/EaUYpjzt6Byv16sGbK4BYmDcLYgkQC/ZKITYUYrR3fu9Xa+IZE8T7POiH5hDf71vqXe4b9XbuHzl3sP/GsVRGPPOa5iHzw+ZHzI+aHzPrzcXmJeYS81LzMvNy8wqzwbzSXGpeZV5tLjM/YV5jftL8lPlp8zPm58zrzM+bXzCvN1eYN5g3mjeZK82bzVvML5q3mreZ15rLzc+ajebHzclgteKZ9Zok53Xfhz1UZKw1o/ywpaD+0bp45jloxwf6DE1MPX7xUzvD/WvIiEXtnOVPc072gB7TfvYzzxrdGk2n/ck6evzYskz2nLsx7ySMQ+c73WE1fTdvUCpxSwZDyYVm/L4aDkGCaxbBK9Lr9VXDq6jxVcw+Zin0UqcsJfCL499G72LwVLWu+4Eui+8RkJ/KuwhPNiyTMRHQEgPnDe9IqHuodhFQ+VTfVksz95H6piqitcOe8ofvo7SqsNXPPu6Jq3u4di7kf7BvI1NlEdRssuznnldrtYIZl47RKmn5yy1UPB2/NU9kpVVRZep2P7vQg7yg4rOgVGxfCPOVJRtoPG7p58lGX2qAJ8d9ac76vmm6aVrsmfZzhjSBajc5rS66LFU3pnxZ05zf7oQR9gr/VptA1QT05Hn/avOz2d6zNjwpCVeDfMvht+ns3vL3wy6q2QSXwEDtEsgeYBJhzDWZXeJJ1PzLJqyhpxzIi760ATj4D3U62+M/y31LDdGc5c5JGTbBHybPqB0KHJvqOXkqTjulaz9XrL4Ysv7mvPdNdfp9Yk0mG+eePWg8qQ/YRZwPfwiuZ+bGiPE9Bfqz6wI2Eb9J4rdJbCvYZtoDY088rwfbA57Xg7b2A2204QMNnRGtZ1iBf2jdltpGDc5EQc1SWiWE4v3cnaDf38J1HVytapTAdq4Vruvh+p36iGY/twli59QM2+wTQ23egtpYyffnjsqDgOFgAEOrD+uG5xB3VJreS2f0+2qgdvWuf3ZT9cdXxoHnqrt+ZU00oysUt+QWnu0WDc1xtlR2gO7VFEpadhXSCkrxWym+5Yy7LqB01398QsJoC0UtOYVjmH01UF58tjsYYTxLpU6xigj1L8O45JJ6O/x2ql+B3yvqnfD7rXoX/J5Tm+H3e/Wr8GtTvwa/19V74fff6jUa0H2OVZ/lbkDog5rd6cuAmj0ONSshNXum0gA1MwRqttTXAS1lH9BdVTjOGkQwI4Rv1dUEz8OaGoKJYVN8kQDnQYCTTeDcU3kvwLk3ACfHBy1um6nukdp7QQ4/uKjjqoAM1Om8DNLSUQZa4HlGOkqBYYW+YICoAYjDCcRplXkAMS8AcYSPmjTHKiZQGFLz2YQi1PftQNG8minm+TVTzZqaLHNRzTSztuagPcsoNuOKdRyx3VMzw4z7ftxbM9N8X81Z+3TjLLPH8YtxUc0d5v1cKcDwqLHFvst51c2cJu1dzq9WaJq5ORCj0xj2hHcqUCcD6r50I3X2TXFAXVyAuq+8pvrH6uj40VDbXOjDHrJOH5Dat0RqSGlFOlK6GyjdA5S+ApTuAEqranAnrFuU1gQofR0o3U8ojewqCPgTKRNjiL3HtoJnX+HaImw/fF0OkLpsTL+9Lvp0rMsJqMvSdL4u80hdGqAuxaQu2za9B3WpD9Rlifcd4rkvtJrqHq+tgxrRUKO5VpDd3QftR0wZ78UpYlLnO6UCGN3S2HMoW2ISj5fdwZ5zvVy/aOSmvBznkk17NQwb540GPK8CnlSCx7BpN+DZGcAz0Qs1XpzxHudYYRylwNPHERaM7eoQ1rsuSl6Xd9p556bNAOmmByFVAiQxgXTXpo0AaX0AUqjXVLekdgNQ+g6nPy78A+dfITq7m7SgKtKCdpIWtIu0l8c0ZtJiGPZTjwKwlAKW8y7EItuEbWNZAMs/Paa6ktqVgOVZ7mfLkD9geUDzSqBtHPBg21gEcCwEjm8jto0FATjHPKb6pWDZ7wNIKk58PJxA2v4u1F6w5z0VI/z78Typ/i79GEbQIxb83loI9X+aUFYAELcSiN9vxLaRHYC4DSAuA+3LB4gCgJj+f4CYBhDnEIiTAOIjBGLDxlSAmByAqIe6Lq9VAzwhRx0PJfBeIXXdQepaRWo6TrOT8JRhE4l8RgO0LALtpY3YOkYEoE0DaCtqx2h87GUYgWZZJ/4JvLABeN4+hCcGeFICb9nGYIAnDMCL8gzvolr0gT4C2wb6TSeK+P6j/8z5lydAv6Lkz4cz1RlqTwH+1wH/M9Zggn8XwW8m+HcT/G8S7G8RDdlLNGQf0ZBqoh8d3a/QRwN9rsutdh7xvkXuwM5SHd1V0Cc7IPV1736uVn64Bq0ulbzfdTQdbC+F38sE8uj8/VydvFpDJeO9iNzXy/k7MblrCNxJyZ0lcCeDu+1gvfdzx0jbfhuge9VH4Bdb84q+acCrLcArI4e8at1QCbzaEODVc32mupW1FVD3sVD3dGvIn7SOHX/SOvi2sZv0Jo9q9tRgT8KwqX0qwLkScOYQnPs2rACcSwM4cwFnae1SwHnVRykLrFKCs6P7ZXpRgH/3A6dCvPcE+PcthbxVO+dBqsfD68IuQo+Z0LOb0PMaoWcvoWc/9wzw9RyFp2E8tKGmplCD9DEwFk8CuvI1lLPXT+zEhlyg644AXTfdprpnarOBrr0+w/GY/5ecSIG+agHwHy3Fu24Z4JkAeE4TPOM2JAGehACeTwDPqtrxgGcp1H8RWM7edLSnUQE+HKWHB/hw3qV2bvJED+JDHfDhb5Ba7jlGqDlOqNnP3QTMnepG6DP2cx5S9+3cVXWI5q/w/CegaKl7jHxYV//+EdahJbl47uHgNoJnIC4siRHHpPBnIWbULgP69YT+TypKgP6SAP3FQP/qWj3QL/Jpjo8kVO8gfKoifNr5JxJaQPTDBtSMcY8D/swF+GoC31yhA/i6APw0gF9WWwTw27z4dHeFuRrgynbD7/eyvfB7SbYPfjtl1fB7RbYDfm0ypaKqGikB+ct21eysnooylyFVvE5ecaFOqgHn7z7cJfTZzelayrm2Wa31s/GnVHga1KlUiG89lQK/tac6yHhAtO0smdslrvezR04lwpPPTyVoo64qtE9fNXN3SaM5ehL0U3H3jY2chL3z3pZdI7McSaa9LTvLtl0dqX31qql+XyydrjNGzYhUHWipGbmTu196oezQ1aHad69Gaf91VaqlforUJv00RDvvpwjtkz+Fa/f9FKZNvSbRLrsm0b1xTax991qItvNasHaWLUi7ytYvL5SdSBUj7gI5Bt5Btpjqnqg9AHzLAr6t710KnvWa2hq4V8P9RGskkdRO8Cmaubuhr/8NNHoK+BhTwcfIMu+qmW5+uSbTvL1mMujQPaBPvertoNMLiUfGsPmuCcA/E/DvXh9K5cfKrSCzzQGZ3ecy1T0JPbCPdXsqjofxFpz0MNX/pYfZzx0EqH7Q20q4Umn7uUNwpdOe0BwCDRGA1Qp3TSd+KLQdgu29ykcB28oANhlgewp6YjzdJPZ4xP9sqQ9q+LbKsD9yIwDm/QDzJtGrFyvvA5gLAzB/50x1W8EfxZnKscfv+J8wZw/APElgFgDMvxOY+srBPe83APPp2jyAudqDOldT2W9hVgCO/21hJg7g2MKhNVEBjn0ExwuVEwDH+ACOasDxAjz1sbMAxxRr7CCo+7lpwFe0D9PhehmuM+HaAddZ6ev3bef+pTbV7efuSB+tQeuRwd7f9zKhI1KzPeCraLgYwB0OuB8guPMrJYA7JID7QS5yvmheJxdTQSXGQZ+78MEY8Uf5t9sV62z+XNU5agiTeftiXRgjLl8QI/7qvhjx2jpTveD6ZsEEJovxscf6jh4P6kkQ8qOBwsBogEnnR2Sz0/kRmSYdR2TNXA5o8Tm45sH1PKQXEQ/6ZdBqNbMd9LqQ/dmP9OfguWEepP/apk+AfqRezRSyHj89WZTa3Gqqe672I+z/+9THhwVGIrkB3DkB3HkEN0roO/UxDcron+pC9qR/CMB/H+VP4J/cVAvw6wh/Ctlv/Ka6dbW1KH8yZjlZIeOlQ1rG3v/SMjrsbxprNJ7A+wG+jWRmYBtp5iZmoH++n5sC98K0QtbozwLcVYB7O8G9bpMJcL8UwP2KPz7gNfspxLn33VnsUM+b7yHmP+J9QVPI3u3PB3jrAN4yAu/eTc8AvLUBeMv9ckL7UUL7if9CezOXkoFjiWaOClA6mVC6AsYWakgRAc0yP7brEsCRQXCM3/QQ4Hg4gCPTr7iN5hNA88m+039C811AM+dDmucDvDACj9pUBPC0AXjhwH8QCPD/fTIuOFCR8a46MJKoK5vFmvperqMUQdc30XdzorBPOCFFZ1St+oQbRQWrbrTW1XzOZajr4XeqeormHbjOAIm3+LLlE5gMwPgdkenXxDOeGMB4zpc2yHt8Y6APPKf+y0BP+L36MOkP+d7wTeKxvEo8qLeI//Qa8Q5HatCP6wOMW8iYfDi2f4Jx10YpYIwKYKz2TSYY9xKMRwj8fQTjUYK9muAN1tQSnIXsI75RAC2MjBk96ltt9dGp4Aunx4g/RPkTPPqNJwHPyX75+0x1z9f+FXgZCrzMs479v/AUXyX13EPq+RqpJVLsJ3UQpr0OvY4BWlsI6IvYNxOo3QM0jSI0xW40A03mAE2jgaaK2l1AU4uLOj7uTyjaquFpKmR/ICPOjej/EX24saECoFUEoN2EceKG2vXo/7mslpRB0NZqeHiF7Gkvvsd6AiCcIxDaNqwGCKsDENoAwsbaMoCw1vWzJfUP9CwLjAEL2de9OAZ8BODwmnlsA7aDhwJwGgBOMTz1sQtgfPOYdb99Z/V++466Dvsu0357lUlAIK90hFbHOaTTJziUEsThdKw0xsL9zw6xEbHVOcSSkXD/gYP6ELE64RoLVgVPSLM5rkuQJ2oHJVE5H+KkkE/p+EqCUqtzhEp+dhytxmfJzpt+/lmoBMvVEVxX1N1Qni+bTcqihF8mEt5OJKwiNb0BNU3yot+VCDWdTmqavUEBNVUEajoDaloJT33sv2DUPJXUy0Q49hLh2MgBjgkJx6IBznACZ8yGqEGtYATA2VwbA3A+5AzHpxE4EtCjTGLFC9mrHhGUFkJplowYqQ20NrprsC+FZ36Pfgx8qUUxYlE2f0Z4bCp/Dni04dkAniswVn2x9hnAs4U7aZlF8KzR8DIuZC2eEMBSBljOECzfVjwONJYGyn4OZbcRr8XAcZZssHQRv6XHIwS0R2AjoRfrVM9iC90PgWV7yTMMYD0EsA4QWPUVDwCs+wKwDnoWQp5nPffA8y2uhpvUekHHPRqlc7FvHqRXeXBFAjUe32l3EB9WXA9+zUdagMAEILzg8bP//rAIPNrRp2bD752nGPhde6oAfg+cGiqD3k7aagTqwBJ/J5VuexfGH+p4YR8txXegOIdIcJ0KH1k6Zef9pVN3XliZtXNf6aXSjzhB13TzR5zodPTiaTtxL4K2rne5f55+l/sV+BPvkUOdsqA3znSVWZIG9cRTPfRkU91O4/Vj+/JOt/vZVafaOUpNZ3wFvw4blThyXtz8Tq684lfbaKCv4tQo+D11aqQ29mqslrk6Qrvx6nDt0avDtO1XY7S+q9HayT8N1T76U5T2wE9S7TXwr8OuDdEmX4vQzrkWrm25Fqb9AfzraFuodpJNrF1gw90XXv+Qf2dgCLxDQ71Q3wM+S+B7Hc5hopVVDVsZ4eU5Gi/7ruferrkGXZFuvpKZxf7C3VGOc9GntDIWjVZTJJBlsv/kZIyUzEMq1KSzk1zSWiohl8t6LJ0d1yeoAR9xhkD1eku29rsHs3Wjy7J1lHlrCyM/y4kqcn7XLKDjM9ld3PxeN/RT+/pmlI9qwq/Y7tU3W/E3k+xW8w9bRhFir+dEjKZpfJNam0ww7+NU5Lvax7YpTSnaRJK2g6MT/mpLJvnNkF/a5GUn+N+1CeTjSZob0hqaaCZLLjg6k/X6byre5TLVMp3YHGrGnXIl5jQ2xINzKQS1o6A+n3h3kFPiZ7GPQknDQMmuQMmoQMmK/B9sUZrltpWPBtY5lPDnv+P7+Y+Do8ST/xUtxnf6F1ZEkDUPd42PFjPxMWTtA+5liuMafM+P+5ni2fBZjVRCELNBf7qbKjijFxbhTi8rfcpinMWezkaLrd1Uek1cQctGQ01sLFM2m2v8zIB7Kw1jRjVVGArY53xd+i6DwdLWTX12+Hq4kJ5R0PIXyFufJ7ooW0k73/VRMq75iOHI9fCQ5rzYjulMGqMvSGW/dOOqCoWhy2AfhbOme0amss1uheEvhjEFe/gZ0vck6mlZl41Kum7DecVUYckoShVsDemgEmLKPjXkGAQFEn0so27eZKBSDl8PErYRKTpt+YaNhpEFO3koUbl6frbracOdlgI2zIfzzKmMK3rZSn5XnIKPpc2UAtdo4JzUYGVEu1i3gJOpX8oTXwjRhpD43ZyMgrZKlc3G+dO4v1YX8OYq2jq4co1UPO4M/AOMvqMvhevC557rppLCoWTCaUoxlikpDLNGxe7ICzp3D5cgHb6QzhAX9OJKHDVHdvSllvJwEKazMVIXWRRniJxHKcYx93KK01TCm4Xh1mHlwyz3lMuaUpsiDHRmMpSnU10XRpSxNjojREX3iOifWymZs3kwLNyDNX6OqEdMTWQ3+GTMdNbsxhUlV1bSM64Uj9ZMZJ2+1FPze61lBexr3iBGc5xWCJ8Zrunk7qyYyBp8QT2ZwUE3rWvnO6nQLVxslZrJZTKnTAeL+kHe761XVspLwzQhGea8K8VbWxRLJrJf+1LG0PGUXMaksp1uXBs4iV3FKclup4uQrqW41iluThDD0zTVh/vJTGej3QhrGFhScx5CulI8kT0MsKKAwoNA90RWDr+RcxwrJ4L8+LIjA2X9LiwbSsr207HZp2bKmqmWdYCvEoIUQj9+aaNwjgz0NgRncK+REn7h/jcjmLEgQcovGht7KQIklygTTT+WF3kuTDfG8IBhwsiX8sLPJT+UbDmWJ24XpWVBDZe7lA9xzaudwVQfL0sb8h3hoW0LJut//Oz3vqCxwa+PuSQFmOOlomlv5MWcGzIvzfCkQTNyU17UOUo+554Kjq7YWPZpWYJFjjNN1Klslotf34PQ3QQ6awN7GoDP1yEb12EN1MHZOHXu1DmbG0KYnN/oKCU8pciajVGXMnSjDA8bxIqI60IBFR8sa5gtVia1dnQLFEqyb+tLeZKWjXn0eGo8wuzhhluw9F1eXP2R81sIgXXRhbCGXFQZ+FlRGWykTwbSsXqRtqAGZzM9vtNGyacx2Wyx62RekBVh/Z1TGUZor9mGEDyieqm2BOzdUIM4nto5zIDrd4NlR4EaISOyDtGG4SoW9ooXS37sxRP+KFmrbdGD0ik0RVFzoI5Yz4UQ1gEfxrijxW9C+zsE8TMsPwc0CcbObx7a3ID6Sld9xcxhJjOLuQkNVNKpQrVBfYGSxwN9Ua5DeeNbBXJhrRow/dUtUI5r3c+Fy5KbYrV3cxNk9NSYgms2umY/FyGLPkUl37BiOeRCL3coL7SVkm+H3MJaWo5p6V5a+aN1vjMkFDiRFdpDhzb1BEd+1oHPHvDmMEH8+u7ky+3f2m5vm2w+FR+C+2N6RWNnXBqnk81dwCVVUeOPMpZC5QC1HwJOWSstp2sR4iMgU0XHfk6kVjUNA41KUtNTRgO1/RQe5ilU8Pm3Q75s9gcPrfzZivO1wQegslmpt39NFJVwk+zFgvv5dQV0Sx+wG2OYcWj5cq6MUThDhNT7714XRgwHald7G3qo0J8Z0UWUfDNp26KZ7+QpzsXMoeRFDEpPz2kKRdaJ7AcuXLH0qy15zEqSjhp545K4Bcbf1F6OyplpeSfvUrucEYP1UjMpbLNfxpy3oc5/N6gtcfOrGTnScqdjzHhnSDDSEhxhBlomIC3ij0q7B1OzQzTrrbykczgfk8rZztENuEIGxs1qbF13MfTRFHabH6yrPJdB+Uu4nEJRjygorDWZKSIpRZ7Ned+3Yuw5j4xps9GT+6zfEqr+MagNRjfGFsVq5M7jXjqBih8BsU+9w3XU7uFaKn65TO4c55MzMUVrIBYOseiilRAL8Q2FfB95o4rwWhe4vu2l4qPg+hevtChKg2s+pDlyZw3YL9wfHfUc+3kP4K2SDRWHctHiZAgzIRyC8DGEsxC6MQzaC70MbFoB+447Yp6IUesXNeE+3uGk5aZ7wqDl3ugjPVlzMkPF07Nmsu/0pRTQiqf0GdDqyLk/UMfpg9oZtq9d2uhyWrW5oYoJswpURqtAtkO7oyiDDfXwVgA1/WXddm2cfrt2+/xXoAeL1u+jwsd8df/2++9aRGcE9VFRwaqou3pbt843r9w6dyu0V/0xWk4lRDFZjLAnPPRz8EI+7xYUpLAtfhrsA2rFh/71updAlp91Bz31wvyH9bT8+Xmj9VFMCPQDn0He0cVfQqkU9m1SIhhSv4D7L7tDIO11v5z5AmJ0/BOa5fNS2N3+eGY11F7mzTBoGFxVe5H5ykIrAL6aSlip2Qp4JrIX3AbI80/3Uvg9B6MHsHPk96xbxrxkW6gr1m63FWvSWHufsDaN7fKinyqsKTmVQdaOPqgD3ZbRyROtguTp1vuxN905kZ3RVw04RjVlGOZragCvBnq1D9xazTToNXFvwT7ok/uKMXV8H5Wy2FryglC1gJyiKp+SP4dWBbWmG2KZ7wxVsxndP2yM7hubsJpK/tZaoAUPt2qogdqVWpSnpUC+eX1nbDg7LUerLML76X0f2VSG+FW7OaVsN/gxdIZKn2Ggdp7jqIbi0iul7bO7imVjJrK/uE/YVhmKS/k8qyDPOU7U0AZjnvbZdls9jC3qIa3GgM/3zr5quw4p1/VYZ2JFMq4UX7JhHSnVNmuGIWbOA+QM52m4S64yu/fO94UvUKrfrQWs1oX6dSfoV4qL1y+06acjKBn6U2iHsI1lQVob3CfA9STOUQn04dJAn459+ZtQ5hNxlDjUxetoHFxd0A6wr8iD+OMQwvn+ePY4JlInPjDKuJHZBj2z2RKuG1P+fJOffaxPbzndHfZM4TMVnOzQaS6hqoJTVvCr2mpPEatC1mBhewjAyh3DROhGGSuYSGY4s8kSphtVvgogafruBEihz9CKfIRV8fkSKJnrZ7f0Q9nQD0PaKIHyImaVJRTKLoCyyX1ZFoE8D8vl8DvUriKl+L4dy4gbw6GMgmALawpWBl9IZUP8wxVCPeYTNwejhaRwn6/mn8Wgw9uabtGM/Ptv5W2+Py9/6j/Kh0DpBRb4LZ8BpYPag0h+sWUi+48m9IcH5/1j/T50Z1mEt9Wv78Pb60f2u1ei/7KVEVz2s/O9UhgPPl70+DwlM5P90ZVhxPFgjnNDxQJLqXYVsWRnXfwqpEAfq4DRlLqT43YunQt+wBvCetzxUVCfC7YFrGxf/ujx1pVKuXWNMs66XHm2dQ/oP67ux33WhXtVZTPZr133af8GfZOQWVC0iMlg97su2xZo7yS4XnOdsKnKQYNbBQpVmdU2T/uRTauLK09vouVzNHFQus6l08XqKTkdr9WksI+AVdeAzbgO4xzaPBtGo4vl83tfLaHjZ2oy2LngT+VqYi6Cn8vlaqcSz2e5a7KRSn2tdfqcWdoMkvKQS2bIZ4/5E/Um20T2EJcJ8F7irtvCmqZoj9umFCFn7nGJmEVNmbqUuZlkBu9ENtilhFKv+VP0T9jUJE8+5JGemjh3olZlGA32Os21ypCixT2iM1iVq96QrB1B4omu6walNobEx7mSdEnaUaWUOQnGI6NKMW2YS2NLIBDjECLIVeLPtsWTlCgXymd9r/x9WoZr8bHPQtnuDrRxbO8WiH8NwQEhys23U2y39PYIcaUzSpwIadPdfD8WHmjr2JehHXgQ0g0QnoJQAQFtwctwRbvwcaD/e8eFax/pCan24JdEjNORU93g0BsbHLnVTkdendPxiSmitdP+iBFC6RpHkpFW4glYGxxH6kQXBMoHrAfti035XZ32xZBjscTgOGL80vGGqcFhkExw7uAO2u81QiDnJTsdK0q7HCGlWxzjIe3u0imO2aUH7XcZx0PaFw7JwJlneAZZYemDpzrtusUH7brStx1vlV5zbCFnIr3oMEGZ2cYJED/hoExJDgmU32q65njRVO7YYjpoz5UoHRWA+zVfI9Qly0FJmn8Nfok/0RnPapM2H7RPLL1sA2zkLLMDHRAjJ2rv6zhoT5dAAKgUPKMA0lbTBGcKp3RITJ3kJCvK9IGDqmtwfDVwzk5qR6ddCfzSSo46jgDeB3w3HCKj0WGrwzOCOyHUAU9wbchKx5FqNeRLckwwJuFpww4xnlENvJCYTji0BNrRFjwvdK3DZPzKccT0Gjkr9Fdbhnlr/tmXd+STRZLvfDT7145J2aLdxTOWlL2aL1nxav7JsW9lj/jgrhnOzUUz+ybunf6F25qN864uRRbljLPMl4wZKrnj+8M7c2OymVmvngt+rzFQd3EjnlEa1CFzJEnQgk1wepob4BneT3D+7kV+4T5qCA9PNv3ScUgiJmtr8By9g/ZQSZqDijtoF0vigVsyhwxKXfLiuX24gkXcfPab17P7ae+0jzWKG9McSXGd9jHGeLjieS6nHRuAs3HG3sCp5ggX9K86qA01SOn82Ecr6fZO+1BTlqNI0k93aAe+961wKCX8GXVI+UFCeX86yN+Lz/ga9NMw4oPWLKSJf7cxE3p5ft1uVmOGFlpivMCphjFkmu7KEipRrUssiWdyuMwZk7S0QuDsdMcztCJVK+opoATOdnKXrMVV8gLnJ+ROCXdL4e5v5C4R7p6Cu8/InQLuKuHuI3Ing7vdcNdI7sbC3Ztw9x65GwV3J+DuiDtOh6etn+G+IqfBfkNOEj3DWSGlDUI7hMtqnDOPuwl13Xmme7rCxEa68R1UPdqOiqHik3Ad1iEVey9Lxd9D2AQhHu6vwPXvEN6DcAoCvt8KY6SNajlyIZaZwWb7grWCYsB496fFgiXyx/OWUPIKTiWDfl4mxfNrWvjzkq32NNDfIab+s+s0LRX2NNAEsakKnnTaxcYjjiSTiGlwaECauO/71pZKe5qJPzNX8r1i5ptlz2f3w0r/A6z0AKz0P8CyBGClD8A6PFPzgzE7tbtd068nCFUE/sY4cu5jyHnk1mngE7/Gq32rtXv6Rw/8Ei6Msh67HkatuB5OT3Q+5jloD5G02TNIa8d1XTZop2fgHji84gfb8/F7MqXkLCKrPcFotUtL++kVMU9canAsNx6CNs2fNxYL9cmDdpJXfdLxJVC/QoKn0a11XCO27DTUps2eaTSAlbE5tpl4jS/0Au7S3fbRRrQEW8CuYT3P2DNNeEJnluMrk5KUmwzwsAzyQuXdbc+U0EqweBLkyWTSlrLbTgBEjLHkfLcGgn+ypBLy3oSc+ETd1ntbHifJMxrqO1nSXy+6Q+m87MHWVGmfAvZzg6XTPgQs1ydxfGsOJ625zS4zYu3fcKwwrreBTYi7Cb/Bks/BhgVJ2mz9sj77zTezJn5oyEZT9onFap9irLKrof1/SXCFt1VxXWqhSmytsqcMpAadFyioLqGiAp6VzRaoWHiqHHhKt9GqG+CP/NsmbcTTy0EmADOzdC30NyLmGvQ2L4I9Qzor7FMl/WdYCjrO2Kcaw7uUzpdhrI+1//3Cbkjpt+v/bpM2L1/+djauAUJpD3l9P6fUBzE4Iz8e+0m0UybsJ/1ssY/IjjnTTW3zs2t8RCow1jb78hgd0393DNKL4kCqEsy9n8uUYuoFXxrZH/pZv5896N9DWs2wASrGAZUC03mwA1f056G9K5ZU2kVw/5W6pPg82ITDxXuAJ5WcSn0eLMKVYv7Mpwnq8JpKoLaSS1bzFrJs0/LlwTn4zm44k7JOzLzcpDJQqpBLscwd7LcudVxsC/9mdbUhyVJvqM4TnaMVqqcwrdfWbaiJeynv93PTClTsFv/PBnXBz3oZ87OtrDF/Hf9We1UTZaCUIy7dwRZ6lAFY47oU6xRNtKKEQIntqkjTg4cl6qOUvdbDBr2+IuOwvq1bEP1L7M687nN6A+64EQsY7vF3GZQFXXo8OyGkUVBPy4UcPWYkcOhLP39OGO4KgLv5zmCPe2TK4Pa80ROY/h0RG1v6MWY1T2083R2koPV0IhUfrBDJc/X0U/Syz4sruBx1xHUBjW+fn/FLLYkkv7BB3RwNkDH+g+WSBXdUoGSypwRNEkNJsajmcDGtONMtkF0pFsmDFbJllQEo/L4BStx74Sn+3ANpM11DqdwdfzGY89iO32y4t/uNXCHwqqapCkodb/psZZiFnvFZcdfKiiZ+Twv+tAQ/O9EvG4DUa1M8Rs9QLFM8RqnmO2lBRI8QsP0Kfv4oP6W8TnbJQCpky0Q9suAZTZWcTF2y8o2V6cCNvbPP2yYzop6cEFqO3DlK3tNSSmvrXvymNTna8n5eT+vXtt1Qnp4RpTrTTv/lbk7hpFqmHogQ6yBM3c+HBYPi3v234v8tjOnPC1daztPrZ8/AWHZ3636XUM3v1V3JadR1NpG8n3sn4HllK119bsSZ7qGK/TaxXNSjIU+O+NA7Xvu+GXKLeu6kewNXfLaPPFv5/i08VSRF/z7Pl1x1OdgD5LqqSfCYH9/lD3CW6pItg17sMfJlIiMa9IRKoxQi5jN9/lMbYGyySS94SlALGsOJZiFkky/W0q9XKN+NeuFTDltWY+66IGYCePT1uHcz5FiFOTJFuG+UkobWcJP0xvnQDoTQ2uiLpw3930Lw/kRLjgH3crrVjlRN4ng/W0ko5bGFdaWRXWU2Q916W1cew/hTEHe0luEOGPnjmPx1/M4Nw6EVzv/lx2ebCsUtu/LGtEoB0iO+HAstu0U7v8PCBALxQYDibBWRWoY/RnZA9fH7MFyzDYWyufC8q5XPy0D8IuQt7hasEMt/tqkHfEAn2MD8dZsIBaomGsolDqJ+SBdffjyhXlAbD6XEZJf1H/AUqlZhYKUzSzgQCRxY0CSFdv2lWxDPjCZ743pvQRvWxe+w4/fy0Ih8COUfEmjpDI/tONxdbcWV4WzjGIaHPByoCwLq/jkI3qgAvO8Hw3sIU3YReE8QbjdD/KfWZEa8j8gB7v5FYE9tFLyD2lMAOhLBqNkN4L2p2ac8yiZ6b/6oRXmLctGi4OkqgnLcz2zJjUhFXvmSGyHC2GPof+aVC8vBzjLh1lj1JPZDn6I83wL2MHDGaQKMBRVl0mY8T/gm6nH5SyRvPl6tuWWT2E3eM93BdP85nt+35JdxtvAT6kZzQzgzfP9+y07Ldi6PmsSu9o6oxy+myUw67rthzmLX+eINuRZBXYhGzZb6oxtwtbugoWx2kFxQK4A0pV+mv2F7+Y4YMe5xFwSaGWsVnhMoY61UQlQXHR8ry2PdfhhBW4Ke2KIXa/LZtR4ZE1KUxZ7zBMGd2YO70tFMluwXGx2fI7PZLkdQskOBb0ZRmiFMPvuwR6obbShoGgL5n/NgD4jnIfjZL1rSmEOGGWylKwRG6IpngzX1ecLWfHYlwOSa89llnpmMy5Zg+GEAJnryZRakIjNAxVseEdzd6eF5k8e+04J76fTnT+22zhcx2KPHWoTPqiwCVZiV7yOtO6zA7TtH5/dQ9JluEX3DNom1ekAC9Yt/CRPiat0pVnz3IW75sIeOPGhPNE2ztnVLoNmfvE4Fr7xOhxzIK1mV1TK+5EDe1pblJbgaOtVZ6G+zD6nGU27vZ+6E+1l+p2Ol6QJ4tXgeJZ7J22aPNE6FMWEleFX7wNe0OZTgf0Ua6a4z3eJtcT10sK6HCjnTLdkGVK04ajtc+lkcvxJnBfik4Rl4HjuMEKD0lRKbDdf+83vXCJ+lVcLWSezjHtQUKTljpF3H151SLrTi87tard3Biuj8udZJ7GKoa7BiI+5rIHydoZLX9VBCM5NzCTiwoq1brBjeQ4tn91ChQ8FXzgdf+XDpA4VAEVAlpqn2sKYznLLhSmmnfbipprCYAZ+VS2lYBDX+xtdmDyccwJXMqc6PwA9aadrnUJrQH0cu4G4JQKNitz3CiOd1nwFf7QJw4QjUrBLSePm0v4R1A/nl99ehwEo/S0/IbaWSnwSZzboE8lvRT+VpoMwKlG2Jzb0uDHmjdGce0LmCaqeb/rLkB0KlCaT045KRjBRoMv4HjaX/H2m0bkIa+3nPjzeCFWWzZccxRWwVnBOooqxls/knInhCKSg5xjDfaeAypksy/pgOqeRZeAbu5cfv3bKB2dGwlZlgCQPYUmswwF5ojRzYTaQVSuMetyaDpijB+Z6rxwYpmdE9fnVBjz8t1cl599ojJFi3CvCPlU6ft71bVLjwlyBhOyduaAduoYVXWlUMv5o/1fm0T8iYmE7w2SPMhsAOF6nOR11noRW0cynSiBpKfrZbPLSdU0o1eM7M0LPdoulgfXCHqcLFjBLoKHW9a1Mwdcyl/6DGAtREDqLmA6Rmxb2/hCA1h5CSZGt7t6QQ6ProBGjgMtDAdGYGUJXsC2LCgSqp8RZNchee/dnOZcrCi/i9i9s5tQxpQp4IFuLeh3czCU6Fazn4STOZTtvjfXje9VNF6+H6bR+uVZZC3+lni1pu8XsT8HsInoWUTDnfqYgGrg9Hy6h60ErJxF3fBfh9l/YiJ1Znsaa+4wWUIoyjZ96SyXe31Xmqt/o2CczyXgQJYOlwM8rhYre4HGs+gcggi8mF2h73CsESddqn3SaDOg5lcHGQDC6CDBb1y2Aa1LkcZRBeo9KmMVnszL4GkEItc9F2O0UOT/VtUuj1AEXbFv0SKgSqypCWFCtQpbgIkpAysriRzLLrNI2jnFTnci8vh6GD5PAwh3K4CHLgpXARpJA2WArbZjBi7SKg6IZ7ha2QmcP8yyZlltuoFqubl0cXXCeBPJSkTQVZRcBvgRV3Uy6bDe2dxvkn2EuJSb+S7gqBfiWhKUiDuw/ms3ObZDCuODo7wYDnCff3AVkkfz47yiUeyJ0Fuac08Wf1zPclGG7YBvcZztzIIul86bwK0JlQLlI3ZiuV8Fae5HLp2Pu4RPUUbqgsrCgHZx/kKpyulvu4BNkULkYaosli73LTmbjfaaQnWtw1hZIZL0jF5RCmwn2iB9+9hgMl/+TCgJKlTaEQv8GF6iTaUVvjmTwuQUpnHs5zX5Q2o/dx2Ztg+HUQXQgHYVIKuqzCTks26T/TC4vzizcVf1YsXJK/BHfqxPe6QTBe1Vfz73SLYcyaByGnLskZSd6hbLYL6sDaSXa30AlUQpJTRFI/twuhRJFkL6QmOd0ePqeoGseufJrTw+cLJm8h+LRrgXwhJnzrimnoAUsb+bfLgLXayY+aIRQDBf+A/KJ2zLvbHiqRNiP0JOdnkNp7AaEmOZsh7riA71eTnB/gV/kLinJaNc1hqH6ytQ3qzD953NNmF4MdFlc/C73ii44KE1/6gKfTng0j6uxqWrkX34CY2uwiI/8GRUDeoLTZhcZeRzcZbad0tNmDTL84Qk08HesB3254PvpCmz2kFHKR99OSNnwz87PjRaMTRum9DhufeqnNHlzqdPwMKdcItL0tZwAaQAQ8LwbouRcgvojQBnBGdPQ6viKxxLYeoL0XYPOnyyO1lfZQ02qbQCUdVFeuD+va4zCYyvHEP7vYhPXdYhOqwlssDo3poF1oWm/D0p02crY7hX0SrRCW8b2OQIFtBucIoE3r6JYWjWP2wahwyH7cSU+oSiJfUMcKsh6RHr8AuaPz0YvQcV+DFxnaIwafssRFKeb8Nj+d32s68jtKsQ3K45krya2UoqhLbRGQlEmsmpTCJ2NaEYdQNTMw0rxZHyHGsO8dGG9CwHPaeOiZriVaSsHD/uE7IYHUwc2swp2qfndQpobCOGvTr3SAo+/20Upje3hNBherToCA+1vZbZTyhPUzW3h1OhctS4BAZxzPY1t5K8zt4PFQrrzfpM8e6gutD+2jT+H5eoWAN9Up6NMUKls0DOA8tIm5hbXT+uEA1jV94TW0EnGK2m9hjQB8sZTOsilP2SJkTseF9VHOhj6XM7ag4thst/jGxZDJkPfwdUoQ4pAmCwvm/1Ii5M8r/5Ls2ZUE/oSGyBDfOfavwKg5tikPcQi+g1/qaxvAoDblfX6BtSHMSyERNZAiA1qkguu0sB/mXyAOWP4L7J8dIcaI6lvQETbQLTPnEQyyhxAD3K3//f73f7eNeyOEwv1w+D5Q9FII8TmwB3x6w0eaSWyQh98zJaoVpRxqPamdxgig32xy/VX71yKBLI3d3deomc4+66PHx3SF1k5if/SG1lCqiMuYv9c6jXlfi/nfcL2rrSP51/WBvRzfaa8DTa4zUQl4cje0x2o684juaJHYLGdCj263i0zboXVtB+uzHazNVPZ9f+jRSezHfSLAYPHKmQNFoUensm+S1ON9wZD6NqRWk9R9JPVoXxCk1kDqHpL6Cknd3xcCqVWQupOkbiKpu/rEkLrZi7ur9UIbxxaa0/N7BdYh0jq/1/20gtmipfbwdZ/hovYomI3aZ0h9Yvqehvq7vHRip/0F436wB/1v90Z20JPtxxBGlDXn9zOjFMxa7VmOauChxLowrmDWaJcSOE53CcA5DzQEAxTRwPvPpPP9UMZZcVePZkg/a6eMCmapdrudNvLQejikXa+9qwjzKJiz8AQh4Z1AhvnT2Ba3DjC8GcAQdAtDx59hmDsIw2nAEGTUaKf9DwyvuNMBw5OAQQzQvw5wgecAcPE5BTNtEAde43gOZJK9NNPY1W4FlF7oRWpqCyIskh5aMjRlfe9v7+EuGolWgWw6q/IitNFWpW7CnAnaJhipvdySyIxhcMy2t2U0+LE6gH22m36T2uNnl3N8TMeM1YYRHLPcEsAh94ZeD6bQbxMRv20489drVOJYsKf5QVHifOi3l0PAvT2ehStFuflvc5SxIEY4VDwGQhIENYRpEN7EPDmjCz+GazsEDwSZN1qMZ1GenxgtngZxIRNUtIAThYm0tDK2RcIIixTOtlP8eZXHfdHi/O9xj1EYFSRQiZ+CJ/dptyDjU/B/PoWxnaBHBuEQlcuJZmzI6wMb/Cl3SK1u7m+zLQ3DmHmvC5ixTBgDIzbFZt05sOtnu8Pps90xChj10WRPDfLmYeJ3EC/PjjNcp8X8/si837mWS3F2+tEz/IB8u0wyPq17Wosj9zN2pTHE/KQuGEIQBBEEIQQBBNocq6DMa3RTWaFv7t45NbgvPPpuy+afAfrxHWsTs5eJ6CmXQE9D8/hSnbmcllNS/E6FssjQntjQf7d22pdUH7QvMcHVhHMVU9iHuRnrcRfkLypSQI6hPaLQpp6KyJCe2BBnK743wXrxdapwbqugFKoypOCg/a7qvbPbAHOKc61/t11pmq/FWk1RCMxXDLQ5ybEVv7TAGK/beNhAmbE/nqbjv0dhn5rGnOPCM5TMWsdXYHX2eufUzN27d/ZKxzbi8aY4f3IbII5ng/D3uP9f6MD+fynO8+5Msvsfcm4qW+7luRJbF9HzMD3iqIaNcFPKyEvNnF5G72rmHpY1cw+qqV1pTJIW8+sD+Tu6Y4D+VncUWZedAn0WYgDJQeoX7rBAKuseNQhXXoBW5A2OZLMHtLt/vxvxVEqWrYsSV4I+psVFi4/C9TiEjyF8DkEvixJ/cilKzOv6V3mo7xTo5nQIj0EwQ/iei6046QpXS82xchhzqSPN4ptvPxF7dDp425iOEquuSGZ1ffN7ZzwZVRVpPrXSzClkQ3eZuYSKuBdqDNG7cM389goqXnhz0ZqwnftWR1nC9tFpYTulGdXQi6vY1f6TPeLI8HbwaaAHzPmtZ2h03jOt0c4hkQLrYQOdcVgvuh4qGFsbXXo/R0uH7KRUq6wv5a387o3rQsmdzJCa6CVUPHJhI/MSc0tLWno73kMvIMW5ytcGOi2t6T9hmVLNtbbhaTHXBRLddWEY6G09vnUZWiM2N4N1i66Jqg4xc44vSyNrgs34fa8mboXjqDHIPKRGYEb7F1uPLQFPlNkO/iRlTmOkNTFEoms9WJe9LVG6sOrdLQs4pVqqo3bRzBNxytgh2qnsCg8v8Veu5TDJ7BvuqKrltjDzOhvoasYVvclGyV61OR0rqv8KtuksyghCfUWU+Hcvzounk2sbgsnemmMYYWtokZRROGtdylqxLpermhtUB9ZvGGVWMy8rpuFZaN4J5JzO5T9GiVMtEbhntk6oFzHUyknsXC9+K6dawv38Xtp+1unH2fF7B76hC1cGMRImx1BiGclMYmd5t1pWGSK0owwRRUKZmt3ph3FXcz1+deoI6gkXTGJFXqVFWUzL8D3bZQ9nW2UQQm4b1OMq6JFnaJS4F66nu+mh+CZEKN9YLNIK9DHpecXRlsWGjcWL9DiH6kwL0iMmdJ42TGLTvGpLiSEIIAURvPf4ebr1QHeun4fL03+V0J81QL+IGcZEag/rxfgdL/4wqYXA26W/AjQHXywxhALMUAJT5R9jmcB0AbaZXhzfTGKveX6x8TgyAjiiGwW1+E2B5uhZSBfruZ2uULJ/qYDs860IlOHftuKaCBFjsKQz3QaDAd9BZgEnRVBSREr+6sMzKHCufkygHNIu2u9n9/spRUlxkE6hj8lQFA+DUiXFj+r5sxWqPsXzO4YUDdGMc97wU/ERGplTyEUURcC9389f+/y0PLyoWCZzzuFoeVhRmAbnVsic609SLT88FkVw4RwlA+DFOUbr4bpkzFDxQbieh9ALgVZyjSFQi6DL+MVutXOYCN/czjXgCp9p7F6ct3kqYa7KoLIkkF5dzVb67KABUd6spnitjNTwOd9qZ5joR9tYXTwTCxwY4VXqZU0qdkKfyLA07582NXvGd84WSyCu9uHKH6ku1hBroePV7Cr3F7ah2iFFFMC5DzjVYpOSfA+Q86NPtAZBTjzN4cOxwT1iWs3G971nwzodxfmC/+LrKKFixO9M5+dRJUAc61g2u/8ftWc6O5rs+c7Hhw+KSwfFJYPiosAe8TD+iqfkguJQLY7FghRibb7+dHeIIkQrbQyZI4J4qALs3ap8vbgEdSMH8N8JQQ8hi46BNv2lYTu06XDQ1tlNGwwyJqVgGvuYT8TR6yKg9Qpqs8jZ9ccNY8uZJnyazAhqp7EPYo5HYWRkFmoF9filZCo7zf2TLeYGnslXWWoCmGWJSy30rPBWpXwlg6faf+1fxQRrQ4hMLF5JQ1mzAvDhiTJLDfhO42Wg6T0IUH4lll/+H+VrB5XfeXv5lVj+2kB5Uel/K79tUPknbiv/Jin/caA81fhSw0pGKfezZVBCpOXbySJvWOBcbsMAHhzxBjNb7CKJaBW+zVqeWAkYg8nIUM3gOyM/296CWB5YSd5qQE3tNnxa1gxUruqnUdTan/uTlls86bH9Wa73SK5L/4dcNSQXzrAO5LpN465wt7SpY1D8+0HxVhIXN1I94TS1bSKb4m9wVzhzQsWQ9okBUxSDUvpzjfxDLulACr77GsdQiny9AmwsjvWGM682iBjhhgjgeG1TGiM4Oo1N9QqOTmT9gbGgbENQq6A+VhtL5LDbI2OGk+/b4eRc+AO+VzmKjJwkIOnwWiwf4d3OTaqoLy3Rv7Pkgi3bQr0aXi/RKuMFMAK7xv1mU8p5PC4P5CtDW7sI2sIJmpcr6jBv04/6RWD98CQRfF/2XMD2Pwr5+Od7b3v+QuB5xcDzreS5oIZ/vizwfPfA8/LbnhsCz48GnqN27eay1KhZM9VPWtrsEcYyxwrjbtC3Fx0VEsq5hau0RwRmLB20B0HK8+TEuSz1QTstcQbe11SBn4CzWDrt4aU4Uwg97iOOtyEtHEJYaYU9TFIGfgl6Gl86Xiw9DfkaHMsl2B9eivw6B+fBIIQIYxeM9UUMUrQCcGUidom0mZ9vVQXPrZDvdwdVihSrIS/O7ayyD5GImCOOJMlMNeWMG6C4EtKlzVb7UGP/HBrxZat9yMDdohanI8eImMpmD04XX+bfa/GzidoH5eLpIO8FTVVQp/HguwKvyBcxrPdBoDBQf8laR0UprXwR6NvbUmkPM7XZw4xqx2wyV/GoI0TCUxgmQXkgD7IGvlEjZDwBdq+bVop6CoKC2/kZOaOd//ZjCcAGIYpgW+voCrzV40e+oo7ddinJW+zvL7XX348L+1UQV6a0MVixKD9L22nPMkbHDl2MbztDHVXJi7fWbBXDlXMYTKEO6XSD44iJc6ysPukoIu9RwxmcEzrBkVQ93vkJx899NAAXWA++n8V3suOdPR5+rhHG3+ecJL0I4j95+Lm6GD/MGUBDSh3K0jMwyl7p+MWY7EgG2Y83WhzaujMwDjc4ao2V9uA61IczdgHcT4CrEMpUGGWA0+BQmpSOZFM38LfW8aLkjD3EVGkXk7e4Z0AilaCr0uZvQM8nu1+ZSWdJG8cp57R3/ix1yqg0aio1h7qHWk6tpl6gNlOvU29QDVQj9RXVSv1I2SgfFUbLaRU9k9bQy+jH6fvpp2kjvZ420afoH+lWoHiXnSrttFtLpzq2gAS+MCYB5RshHbVxRFeY4TuIow5924W54a70oP1zyH0Ncr8NuYNJ7oP2T4i2fAJxaXNroMwnfAljTBf+tpKyH0DZt0nruVXWYuyyRRuwVJgey30KsUu2W9TVlk6B1LVAYT9179v66cK8UV238h4A+F/clhdrgpScC5QY9YPYEGMI10v1NwmUnaRc1R848KOtvx6dtlt13wK02P6j7htJ3b+x7eJrCZKfbdwA1/cGlXv2v9T7ScARZUC6Ruo32uBaKjXEAgeWk1ph2f4ynXZDKdbjU1Kf8UYt5jZibgvQh9DCDFjHaH32n8Dh5dVpv3cATqd9oTGBcGCkAWv5GXJSP46kIIz+NMhbOhjGSVLPc4F6buJzAP7r1/68JF+LFgI7dgCbVI9PxXoR4VPcQLpEf/kawpcY4og+nLsWawg3jNaL9d9fExtGg+xi9d9dkxr40uYAJciFIYQvB+1jA9owZjFqXRJI521HItQ4bvHbjrfgOnLxBpIv1njr2XDyjJfMiIANHGq8Bq32IFioa3CPtO249p9SHmmIAmpuiCZnQ2iZPW5Vy2TrR3e0lg+949PJD7TQm//28b0RdR93j2+64+t3Hm+ZqZZ9jP3MuAvrWiBkI73j7MGLgTOLH7GHlKI2PmIXa5Mcm41vAd/ediQQLA2OZcbXyD2vneOgj0Iaf4K0a44gYwOeNdMogVEahGIqgZJTieDvFuYVbyzGecR5SzYu+XSJoCSvZGMJnm/wuiBGjPNBKcVnS/CbBM7xHeg1OpyOW3c4F1hE+jfMXwHWqGx2hT2Y/IaQXzH5DYVf6NfI7xAJzq3C91/AKWJZcZZSojPch9+h9kB/m+gM9t2yujPdSuhn9pC+JcIInphDLJnA1OLceDL3dYgE/Tz01GKBVmljUBF6BC/2exQliqXoDZyEOlkhZDXuBMoQ4w52JpfVpNROIKOdCG430JfVvMdOSXawkzhK2WNFWnawEyB+HeJDIK6A+E+YbjxvD4H+UAStN650LfRK2AO22UNLcc5Br+ML8u3pfAf2mHBH+qx/dDQG+trQjhOBb1HY686G3iGitMWG2tz/Bhr77NnQE0QYj4PsjgLdH0PAubro92E/BrpAavEKe8Hf4qCqDzXttkskJ6DfwfJUj6UC35adgP584KsVWXGB/h7W6xW2mZyqtAfk9wr7AcT/BfEgiFsg3g7xMIjXQ/w7iIdD/C2IfwPxCIgfhPgXEI+E+D5/BYzgWqy4lj2Vjffge41U1u8+0y2gcY7Neeinpmr2cBo1Fd+UJ25pyHvWYTNlteQzZ+zhplOndkP/B5ypI/OeOw7aU03niZ+x1YizG5IcR00q5+NeqJ0R3weeCLydxm/ZIef750IPudxplxnDuqDOpf28FXX0P3We3w1eSR2UAO8AvD6xEb0UaKOSfv6IL/dzfiHhVAM8g9oZ8SshfmPEt0345gj7YfTAKoHXGhvwXbIQ5IPfYfBbHrbdMtAvWoJf3Mc7OznEC1phVBm6QJ74Fftz8MD6tRV8U6KraT4h6Crvs3r8UeKrAT0NDkj4Z5+06ZZ2vsJ2+Sjl78B9CrQwmGjhIA0EazUkoIU8H34AbVtx69ulkff6vrylf0TPcD3w7fpFB7DX+v6bftX/T/0SApXbfbx+oU696OP1C3Vqg4/XL9Sp53y8fqFOPe3j9Qt1arUPderzgE6xbl6nzrtu6ZTw/1qnCjz//9OpeUSnFv+HTuEYhKxLhD/UC3HAYvZ5aKWgvV8zBGA3f4OU3y+cB09yD+RSA9Y4Z4wPv61jf4VzR1BDcLTRrwGdHbdW7/RbdX4sgFph7bdKg0YSv5E1A1wjryVBAVoaATPqSXT77Xqy90/0hAOKpUDxPij304U99iiImyHeeYGXudfFy/wSx8s8AmQeZJr+HzL/GWROK1DmN26T+dSO89AHAua6XvC6MWUiaEEKaEHUf2hBbt//1oJw0IJxxtCuEwE4tzTgt9s0oM0uLsV79Kx6oU3xGgBcLuU1ANuZE56B9EuhtsafiZf4ogTnHNQ6jsB4KYRoQDHRgMdsg+XfbyfGeG7ZCSfYCErY/+5kJ+lJNQFZHPbxYxMN8LSYrN3ie9UHSE8K+gJ8kAz0pEdBuv3jyFs9qbQxhOC80hcMOHGN05USSqFYSilKSH9KU0PFCwfjJzbvFXaXR9aE0LBNlzXvJj3NVg+uLsCZJK+wGyHusKKOvMKu8+Dp8TbrQfsioIoyjXJKYYT1lelEYOVf+fmD9gWSUc4gD7+u7S6I+/va7ESfTANtTDLQxnD+jIka3wZWEUeL4P+CVDWSfln8P7S9eXhURdY/3p2+ZGkStrCEsIWEQAggSxLAFhUSaLBBQUDF1hlDOkBoURFQfFtGgSQsUQQhjhrJsEMSQEFhBhkdHCEDIpkBCYpLBAFJINyiE+h0kwD5fc6p6iQwzvvM+32e3x/dtdyqU6dOferUqbp1q4409Eb61mOG+eKnse4n2NLIZfl8fSMXM3noF/rGyLxOH5xDLUlSkrYOtSH6kCsbPeMdXge4p2HEDgfiwlx+TSvTkhXYqHsppphzkra7XUe74p0fdbV1g/3R31tSZ4h51jG1nGrnR1gkMNsRdc6uk/XvAP/rd9R/+W/Un77yCUNKp8rV3Hye1y/2JBsM67/EL/mgp/MI6sMDTNKukO+MElPwOwj/l0P3pszSrF/vNvbpdLzNw3HohYN98e7p6va/Pu5evuG7w/jWu/7eF+v6ekPqiy8ZjFIPye89rv+Nvtbyqnsk5bnCk0bsou+jG8o0GOhsDrIDG9Ezt65eGHLWf/oO65AMpUNO/aYOoXdkvkyJsCfqaKzJZVvm0Toaa3J53BlbR2ONRNuoOhprcnncoZsHjh3P5Za4t45smVwedxLqgtiWaQYd1Nf713raXdzX+/7tYuigsbZcvUVOrm8MrEq6nyF5FOFo6IEHwHeHOqJriHvgBNmoA6Bna8AxrYGAD/S+Fnn3ijE52dBThnusJzBq56GN8/hrMNiIoXz7B1ns/tWYxFN001Afd7WPMEbvuzJ4tOgF9JghCbnToWWDlmoPLRXrCoeWOqI0OPH2Rflvj10VpzASk9YBkpvDhgh2nuKxa3oDWqm3lDsbcMVfkNFIDqvXSTYt9Y8ZyF8oemKUCeLVnmxIuQdrrwF3jV+G6kSHwXM4tVNG81RTxlh6P+RZOKltgsGTOYHiMmeO5XOtDNVXJlLaNWptAHmQ729pZN1gZmWmeFpbMlRfnxCFclbptP62zRxq3QYeerpn8nmDMalyT/XsMXQX0tu7jDs12F1Wb+gtrfqnSSd1kxN08AvAfNTo6il65qEmOW7xkP07sdSufTiAdrXs/1YE5mwVgftfElvsmBWjrabb0J/t28TSvBI92D4dbeEWGfYtImj/BbHV/qsIAo2ZRZBW0buiZ1E55mKYHxZdFKPzLoqtOZvF1v3lIsg+BGXdK0Ly/kcU5rlEUZFFmItK9Ob2FcBWid6Sds3sL9FDilbo5rwVeiieheVZvR/eRFlmqdFz66Hd9+8WM+FPrKeTF6W2fwjhJfVn9CHQS0OcQ6GX5BzqsMuPgIdPuYWTd6vFul9Eyv77KUWJrqFEuWfnjxVBhlzfnwdnw9WqE6drnsPTDH0ePK55KuZqnjYv0tlHpAPaRDoqjaZuYwzd1e6Ek8RbD3d8fam+KkervjJJrqhk5FSIhS7N87d0ev4PxMW6J7MGo/hiWlXYJW/Gmb3sFeBJrvFJbj8+VQVud4PbbeWGmITUPqkV5byGyN9Q8zxZ7n8a3U9v9cZxvV8e9bnrYgb3q52eiOfoTubIrCqhNcTyl5R5ufrbRXJOO6NIapjmWdVI5Q+zhikynp0+ffqDqdGG7sEFQ72LfVr19UlATh5qkwa5OE7KdSWuLclqKPQv4nK+RfwrsEbR9/bHiQJzAcaPQhECmXes3yMquX8Ov3Yx82uSTE1oeK6vaHK229gMtPdrNbPCe4sczPCXuxAGCoKQ5thc0I3UPItQvonC4XgWSTt8NE9r4sOmeTpQr7Frnj+Q66S0tJtyDSw/zdPFESeCaPUFKAtAOBN0msFdSO7RFUxzcjieX9Zq9pD7g1bTNmYNuUh7Ug90xgHNlH4F6K3B6KrVTCEeLq8gOjX7KI9Zq4mIgXsUeSlcpNXMIzdPqymdi7Txkn9KXxpOK67AG613Um+0lOmB+Jlqc32rknoLk6VCFDljRC8LEBT/ssh07hZjXOfEYmcPodnKRYwT8ql1i5GWq6Kn5VUR6nSJ/rXTRQHSzaitEP2dU0UIbJ1m9nLxkfM5+DNElPkq4st0Y+05scFZDv800DgnPoS/nxPWGMrXnC+Jnk7KU6Y3q50nPgKtj5yzkI7y5usBSL/E+bL4l/OceAvuWeTradkjztvkN/KOWkP15cUvXBsV/rXY5MxCXQz9hrtvL9Y81Q6t+s05qKkNes2iVZdSi8bHoTZzxTmEc+cWiE02IGkO4i0zRYxF89Q5tiGOwttEDFr4toPy9hA9bVrNuIAVerCN6Gk1iaY7aV1nWg10aoaa7qTTrIFOhuhhW6GHKDq5d9KpmWxinmp2BDTSeu8uWs0d94nn9xOtCvGGzSmWk96yNdSz5jrTLBdFoLPHpNX0jbaI54qIPpVTIHLsGSLWPlA8HElllYsWiu/leRVikV2r8Zmo3G2i0E7lpout/LxED0XZMY4kkWkhVANphDzbSyLVjB7JNJNEOuITYypENtw3o6l39AYitJpXYsoRR2FZh96OcsRvE30t06DHqS6pYqs5Bi27Qm9ug/41QzejzJZ2Kms1l1fK5TWWk6vKudKknNMN5RB9zdPfQXmpDLTfoBK9lV3ynphwJ63rTKuRztCEO+kkNaGzA3RaKzq5d9GZnHAnnffuonNfEzqhySV6G0Xn+l109txFx3cXnRFN6MwCnXBFZ3LKnXTaptxJZ0rKnXRGN6FzDHTaKjp77qIz7y46++6i83ATOn0nlujtFJ22k+6kU3oXnYhJd9KZ1ITOm6DTXtGZdxedxEl30nnlLjpPNqFzBXQ6KDqld9HJvYvO6bvoPNMUP2kleoQfP4678HMXnaGOO+lMa4of0Onox89ddCY77sLPXXSebYqfOSV6pB8/d9HZcxcd3110XmyKH9Dp5MfP3LvwM/cu/My9k878Bjolemc/du6iMe8uGvvuoBGLOfkKvYurz1myEuq9lX8lO6Dee+uvKe4oE+nzKOsfdtd7T9RGWQ3uvJtLbEsfMkXd4716MwzWxudXWr3B52u5g24c8iU+vsj2UqooD97etcjQPcWndVqTXHciTgS6XhTHIqNFSHyB2IAxdcnj+E3K15s5t4nFrtDBsBpgMVhd+bBT6W3TCr0r/EbXEI4LcBaIpc5d7A909oQduQ2WQq6+Ko9ml7T7eIB4KI/s5SUYeWG3OjN1rTZX72su0bs5e7i31pHd3Bv5UkVLOv3b9ZWIcWH8SaH1oINss7XCKFyQqJWluBeizgWJq8pfuHY4nHyap8BB1p/mKZv6d7jBBYbo8e7UUK3m6Q7uK0aUH4SZwTYn5irOqMJesJBD6wLaVQkrLOfpkPZNjACfvViFlNeuGO3psPf+mnxRxMIy6WC/KLbA7Y92iHWdQPhXuL8iZfkJ46CI+H+dIMtAq14wn0ZXHlljjdH7rOPd6SFR20PqmiW8q947+efjbU89U5tdO8k60TrCGmUNco+83eifcJuo+dvUEG1MiugXVJUe9P0JQ/yD1zt+hBaZsLP66bmYL8zpPKBTp41Vqcb8CHqvsxcckXR/gZuT7DmROmhV8tUThIZ2N/4IGyi4MMoa7C67VXMxVc1z/wRXfpeN2c5E+ibcUL1gbudBhu6mqlQD4SITuKD9k6V6hIvmVEbQoD3aJbDV6LbwILfndq4eaT6jO2BhF9dSC5LdmIny3ILsuQ4O8tMcjGwr8ufqnZD+CaTfWZuKVoYWiKHW1WrWspvry08Kd2styf7XPAOmmY+f0cci10DkyOUSsoni2U5Bw6uyFmJ+gWed8WxJbam+9H9dffGKYP6OJ04EY75ryMnV22M+ksRY1mrSE3rRzgdPxZxM5uZIgnT7ppBbyu/WtuL5Qw6SBHPsWT1Jcn49pTFsJAt0UmM4wPUNncrqueCgmyxL9R4sSaBNpUlzSBpZyq1Q7ri58vmrHC7VO8p8sHRh+U4+CGv1EKzUZup7+DN6AOTQxTxLrZW/0MY0zADJ0hzWAMkaPAMwxx2LOe4bNMdFG/ETtI+hprRV4xP/d4tAwpxFhAikbGel3vgNr/4Md8lZyd8X+lcS5epRB7EqMtmXDk1y+cQ6/Udq1eiTd+TY/hs5Uhpy/ItaYNCdOd75DznykCPcipaYTnw1zfNa6b/liEeOPn9KrjwRGtPbSmcmB7pb1jsyngwKLB1RnRjT1mfifUXpx1vGhPG5F0HuBTcb/ctu5vrWJuUFGqpSF7WLaaVin73Z6J9/kxBL92a+s0jjtYM7a5G1aJ3+rutOvmTLZk6KuCvti0j75m+kbR/dIYZKM/q/Ch0f6N7xtzN6jiu5/Iy+3DUF/0tdz+N/iSsL/wtcu62EsCFWOkHt3Sa6x3Dtm4V7xHS1EjjebQxOH/LXZB0tMBu9cra5l1hoxhzA3sP9s+8Hfqc8i1d/CHvvM53RcuXr2u6G1uFd7pB1K8tDvvT7Ph11mb/raXcc/WIM+sIT0D45p32GXd/RXc4Nkv2xDuNAzhHEH0a8Vj0Zs/iD/Fb8OH55NFOsbuvQPJenUvkneF3EwO+zNc+XmLOMm6PWYpy5vreTZPy5DIwDM3L1p3i3wjr9ASe5mLk7/avdU8o0T9bE1eil9Abd/9bz4VMyVuO6+teikk/JcebtpNPoud81rC30blhbsHyDOmL+MOVJzKxzwHPO96gP1Y/qGeR+oq7R76j7B57n4PcVyQLUjuBHvLe3dXhIjmNvJwVgzG5349BFavmB5dBaronl/mf+PH8p90sx0F1468OL9M3rM7OXD6B+P/9Yn0Hmis4jaH3gi385DT81WdMEIiaSfrm7N/ct/U99ufIEED2x7aC7+1n70v/UMytP+HtGoPupWy9efEbv5vq2/Bk9ynUF/9GuRYiJceVepBQdYtpDLsW15N6J7iD3sf2GA0P3Qgu9pFlNMQY8D3Lvgm3j938GvywpyL25tl1MlLWVSvN/0bDQrunkpz1QQ3nfoiyxt5XeIEn+Xqqlvtc+mjC7qJZWoCATWEaZj7UdHJFE3x38ceFvr0GNbsDJF+4spDk84ztek0nMOI3yMkRBTrnYxjsJerifvI04M3oq/FW3SvV+vO7qlzLt7Xq6dDevFjWVe67+ds46vT/1Sh71Hi79mNeKZIjWikbn8BegYllODLCSIYLzdvEeMBvKKbuxTu+OEbC70y1m2itohRH6CyOsszdG2QxYaLHQBvQtSia974W+yqR3ahgRqOdtFUtofE/vzZbeNrLqXKXcQ5e7LuEZraD537oSrwXlxM1fyul9Da2Yufk7QcLpP+fc+Aw/er+bQutlBl4LNeSs0ufkrdKfv7xKf6HouD778nH9xf0Gz2e8urWz5tDDhuoLk0owBlK4BPbdcegqg+dzWmWqJSvFUK05juvP0WrVfrJYDJ6/07OjZ/QP8CyU6Bw1QJcgLgd2Q54B+oZWhVi/eQ46NCutFRmqri48o68iyyKvYQUuj9beThcM9h6C/dPSuU5fbt8rhrOGmSlC7NRfDFXfQtOOdja0hLNUb9XQg2LFEqeh6kiDDqXVcGrT6a5pYpu9VP89rN9etUhdK0eGP1PK2jtOXavVPG8/pnlOz54vXqhdoQdjbtHMvkLXnLRqttKb5TulB5lfEOvNMW7fLc3z8+xshFd6X0F8oIq/cisb/lL9d7RnxAm7nux0WmGy54PeTFjJ/rX2sJ9K9addFOO3q7SfRlS/F3P+aUMf53EaSc8//eqnZAlhXE7tmGHIICsoMoNsoIjUJ1PJzUuldMboc5NpTM0PHFXVciH1TtJLtP/qG9VLabcWheXOrwSnf9V1VFWnhbTr0i/D8Q1aCPK2kUxGQqsvt3HPrqlIo9W7b5QNNV9kEg4s5PrpDSs9o3dyjjtL7dke6Bzl7Iexs73rfvy3qx1fTtyC78fKn4639sF4en046vQo2R3aoOCE8bv7ZSSltskI4HcHlNYQ/Xb54Ix7Ug0ZrVJpD9h1Potzb/kLbTLvw28Y6WDai1RybO3wUr1NQz20qqVL/x0HM8RyJ1kWp4NGVmUvJfuPdDH1wtV6M8tJPTCetFyCiEadtlGrWCj/yKoXkDa8CW3H0iZSshDtFKLtOld0evsmzHXyYOP3FIHOXD0M6DnH65jT0feJ+gr9PNB0wQlsYwa6hZGwQn8Ucb/idxG/cvwqbCv0S/hdtpXolc4S/Qp+On4CvfKqS6uKX4p+YL/jVEE7vcmkeW5jf8Cct6pjU15dUscRyrrpD7sIaREcYxFjIqkGr4lLFuJyqmiZVwJNdl4U5GEeNte9swzagGZ8ZXp326viclEM9Cx9V7qBToOs6Rvd33pZlOf9WohZ1MuUNl5sKyqDhpgvjtHeZvsMseWH18Qs1wLxz6O94C/TaW71tWuW2LIfzy5T+D4xYz/lGSZmHCXafUXsZaQ9SvSQ5ig4i6R4uPEU10usdFIYs1DzLmGIn83vqVbyLj+3SHV9y/Ola+g3Q3v3xwy4BJbgDLEZ+jQAM+QVrrliKuT5lnm+OId6xBVViALXsyIWmi7YlYp0/UUstNxKzOEPuorEyhxKt0n8i9PFiS1om1Uu4oPO2x2KGRBQgzgzyk43fysWY76WDvpvw021QW7mdLHeliFWouzVttnw09ugchFgo7dDJfo8GzSQ7aJYbJsruiPfSwin2VCWbZ4ot70kRiFuDef7Dnn2or4l+sugG2ijOpXow1wvoL5DRQH4vw/++KJEsbmW+DsvVhaBN8tuMbL2F+EoShBTI6tEhmWTKIh8UUTz3JPKjBEBliHiHGRsdtGz+eKiZYXeLHKu2OSaLawW+nJO+g9bBqNX0XyVwkNElItGh5dhGZbozdGuQXBDXETnZbHN+TK0DsmFRhXgY24JrBb21wwzlcB2kf618PfwxyeU6LH+ePg7sj8fbokeibibCXKE6oQyIoEhmsW5HVcEYTQa5S+F28lVyeEY11UO93AJDscifiny9nSlicUuujedy/HcdJTovZRfgz9O+c3wt1T+RPhbKb8F/q6Kr66g0wVxwx2Sr87gq4vkqzprruSrl+Krs+IrTvHVUvHVSvHVW8npAuTUWslgJGQTpvyb4W/jj4dsWvjj4Z+o+JkIOvGI01IkP+3BT7ySU5WSU2vFT3vFT5jip43ip4Xip4+q7y3UN1zRD0d8W9AfY5JlF4CndoqPMdQ2wHgoxSes4XdFwYqPDuBhIeq2GTKJUuV3UOW3VeW3U+WHqvL7Kroayuin/Onw36P8h+Dv74+HDAb44+GfpPidBDoRiOuh+OgGeUQoeXiUPPopfropfu5R/PRX/AxQ/ExW9INR7kDlz4B/kPIfgT/BHw8eEv3x8D+m+HkMdEYjLk7xEwV+Riu87FB4Gaj4iVL8DFL8JCh+EhU/jyv6oSg3SflnwT9Y+Y/BP8QfDx6G+uPhH6P4GQM6D/HKjOTnCfDzkOLnTcVPkuLnCcXPYMXPEMXPUOYnH/gt0adgBFkMGlOgI+6F28f1POwcmb6notNXpZ/skvQfh0vhKYq+xfUru/cqtydcE9vA01ivBjLd50BXqHL9dIWiR3R2Y8yht/NUzlWE00UsrLJAFdcL9Oh8hJZN6MQpOq0Unc4oKwf5NLhjkbYr7+PDeMT8luglSNOF9BDodnL+yHlymEaJno74jhgryuHGgJ+eGIln8TnqtPJJukoo3aQr3STLbI+8NuRpw3yV6PfTtzrQy61dH/IYGOaiU3/L0Ec/ZHci7Ipc+to5Pk1sice4oWQZj7zfuiRP4eBpEcLTQLedovuAKr+tqnOoKr8DnqVgDJT1LNEfVPRS4B8FegZVv+mgNYQxAbxgLB5t6yd6wU0iPuEOdg3m8FDiE+4YjOlLWX7bQHeFnuySO6fGcnvQNxcl+nDQSiD+kH4g+CE6g3gcKQPmaW8KaCHNY0QHcVGu6bCjruA52Xg/ih541s1G/PUVmyOLIfcy9GH0d9tzLKt+RBPuPRjXyR2AMMWTjhgRqXjD+DgWvI2wlIvNljLdhnE2Hek2g840m85lTLcJuKf0GFslh4fbruD5XPEL0t9ruyBigNcehBsb4Zb8xcBCGdtQPUFvcuQ0MQNlWhHuDbtjGzBA9PuAd3L72mR5U0C3B3AzFjQ3IPw48t4XeZXLHMZxwDT4t6rnD9mKMZ6XQbYkC/r+JV8f7SzWmQbkvMRJ+AHGMC4fdhJGGvtJoBoXzrn6CM0psXG/wkYLhQ0b+KTwdMbOO6Ar+2869+ck2CmVqPsFtKekR7ZbgE32uR6M7WKM2YRt/ziE8Qo8dbRJumFKL7Rg+oSNEv0dHr9mNODxjwi/o+j/kcZ63hNdos9le0D2N+IrkPKjv/Vo6G+yjBhVRqzCP/XxJ1kP+MdqXemCygZdsNRFb2JK9Hd5bMeY72zk5z3Evav4eY/fGcg+NIP72hW2h5Lhb0v9xQJ963yWbdhwlENuMmyojXgWSv0G/WKkK0rEgTbxPJJn4tR228R6xs98xs18+J8A7V4W6m+gY6H+VsnuUMK4hXT4LuEgudlk/iXAyha0RX/IK53HkmLYjWX8LqKA7obgfvCs0jnoR64d3A/7uXZy/7vHtZ3dAap/j+Z8Jfr73B9lvjwX9ckd3EcHUj4X9d98PS9+O/sTuY5lyLNC/4D6Gur/pGuQGB2fj/aT6We4ZNr5nPYUeJT07nf9AnmTntjOYYtrM2zeLfCTft4iaLb9uGULP+vtyka5/ZhOT9CluL6Qcy8eNz7i+Mmguw2yHQc+MqmvUbtZPkKaZ5neDJZNNuzcD6Aj8rn9RqBsA3QHjR3RpM9V3gdBm9KHq/o9QGXVyjYl10Y8wJ1GZdeSPsmHnb6T/cPBR89aGps2c5pAOq2slmz+d1DGZlX3HYjLB1ay9U61g8UMpx8TG8SvTvlGMAjPLM454nC81OVL4T4JeW1EP5hZK8eYGQrbc9V4PAYYWkI6AHomwDVPnAc+hiE+0nmB+w2Nk6Sj7nNKfzjqncBYRZ+F3l2vxq62im47prsbMqX5jINxTGNSOmgZuM/t4K/AzpHcnbTmVaK/AVqdMI8q53GhDHWW7RWj8NCD22uFnsF9kcZgjH3oRxHOHfy8l0ofp9K3VO3bGXnWYp5YwH2Jxo4SPZ/6L7C7VtWNwvGsP4jnEv0VF42nV7j/tEadqH+Fqf7VBnUjl8bnP2GmXGBxcP9fhzx/UvTIP8k5BHMk6j9SFw0Ava1c38axv5+S2z1Kbv1ZbsUom/qP7Ffr2S4ke7FMX++cxf1rA/chOR4PVDQGKRoJDW1aom9k/SDpbFL2HOWnMWWoyp+k8g9W+Yeo/BlIR+3wBj9/h+VB8a+odBtc9IXcVcb9RtSV7IBNTqk7N/OzMn0Lx1/4TVtuLLvFcOVc58pcshOlLXovz8m0mnFqbrHDRPNZ6R9H8wk7zXURT37IZAnZvilXRDO1wrWUy6vkPWw1Dlmf+9TYNUzZzFvVnMboID0n/UEOsoekP8xBcybpH+KgeYv03+8oUTxTHcgu0jwpas5nZx0gbeY9ymb2j512ZdM+oOTbvsHOkvzMVPVrayL7R/rnmWjOIv2lJv8cGPEJNAdW8fCPU/wQdkcgLlHZ8E+xrpJzHK+a4wxX/Dyl+IlQ/HRU/EQqfpyKfoSJxi3pf8VE821Z1kwbzXG1mtMm3qtY80qCTHMa/Dyt0jwNOg/TW0vFz+/Az8OSn5rQcMlPsuLnd4qfToqfzoqfnojfgLzP8lpCFY97gazbaYf0ZU6zVdHog/BSPjGtHLqbdlHk606b9PfF71nbVU4fyM9h78BO0ngMqRS0hlSsbJZYxqBQuNEVboRqzxKd9Er7JvOFBxrmsTKNXc0vx94xT8gHNkr0fypbvJvKMwJx/8NzhH5sgw5X9n2Esu8jlX0/DnqsIBJ6DP6nXN1h70HvRcI+VfQK8Py7SEkzGTRdrPsaeezE5QleV6K55tOsE8sgd2oPqrO0s44h7cNKZlH4/Y9N2lWFZPfSmp6LxrEi1rXb1FhKJ2tmucpY3i6b9Ke7CvjZKKILu5TwkAJah+AW2gqZjlnluw9jVmfIqKdK2wxt8Q+070Wnvy30hj69VLXFUjVHKkJ+e4NtsFONu9J26KDG4Qchm+1NxgCyp3ZQ/4UdvV1hZYdL6n+SwasukjH6BMb7cbYdql12qnbZzm6kaqcRoL2T22UqaJfoHyLvTkXzQ7LdbNIW/B2eLWD8S338EbeBtJd2cVv5+4PesHZF7keoK+F/N9LsUtjcrezLJxH/MeKLVD+Y4aoQco12u4hC24x0XVLjvL9f5Ouvos6Rlsb+sUC1tRm/j22yX4yDXk6kuQV4ylY27b2ui6zTH3TqSp/rqn9cVdgv0T9hzMvx+H41Hj+g2qS9Go/tkNeehraQ4+1exO9RY+deV+M4/AcX4V6Ow8PVOByhxuGOahx+Cun+3GQc/gvy/Jn0nrJVKPwHp5QX6aPXGPOyDfYpfURt8ClslamqnyarPt9J1bGzquM+pNuPPJ+qdtiv2uETxP8V8RmqX7zC2JdzcJonX3BJvDfD80w+QaSM1xxec0q/Gb+/sp/0ZDbqrNXMSinRP/Ov08D/uvL3nVSiL1T69XWUu4jplukL+YQSag9qa63m6ZR85Jf6wKhkS3pzkZLLvQozFoWZYbw2UqJ/rsr5DGUuVuXQGmkm4jrzLv8yPdNZomdxuTPU2oUs86aJ3mE2LVPztHLIcrNUudGq3BhVbqwqN5ttN+h0M9lyl+HK8dbqmC22meX4MQvpZ3G5mmecg76mk/y1xLPfI26iQ/L3e/D3nIu+XZR8xU26UwbPKV5acdnzYb+W6H9Tbzyf5zlanOjFczO0Z7xWExyu1vJSBiEs09GcekmDDLSaI5DXAUXjBRfZixmM19ZUF4tWozGNuTz2pSPtFyotyWppEzqH8OzvSu5/h53zDK1ZTpLhZ5A+lefNRWKbXfOEOwhHmCfY5UmhqcrfAn2tF9wvMBfvZZflfMl9MY7ncvdTvZy066oM8S8z/g8qfqaCztRGfjzjYe8cUrbPY/CnKd5I985GukP4pTmlnBPD75TzbCXnDi457h5Ua0bLVFnFPLeSchqu5JSbUoZ4klOJ/g+V7kXkfbGJjK5DRoebvA94hL5nUNh8BG3vgHtYtf2UhrYv0x1N1v0iFU//YJ6qhBP5livsDw0v0cerso+oeUkvnqNfZjy8Bx6PuOZg3i7TzAGdORKXNb4U8GiTvNGawgTWA9/z3s9q9IUJtouqf2A+RHrYInXveNt37P8b/MswZpC9fsBSon/lckIHy77S1K5ZrvT257RmZ5N9Lpv71i6R7Hof4yrmYbat7Boxn3sh8oIwUlnwPx9ZCv8QEcPjA42H+fpXit5L+L1so117mznczCbd7rYLbK+nKyzcdtD6oKwnrQmOdNGXBvJZcwetEUp/Eu0EiKQ1LtqBTl8KzAJPtIv8ijBSGovkfSSvGdH3LVLXjlK2lFWNgz1RxlHIJETZgEE8hycbUI5xRxvWfqV+CSDbzynHLloTeFb5e5Pt6pRtEMRjG+xAZzHrUOKBTiX/O8a6GLJllP2RouyNUWpcsCreHgYfXyPfMWWDRSl8H2NbKY7HApvS/V8rW2m6GiMCeC2mjHk75pT+EoyNUbyWLNes/OvIh5l2EdP5p0rzoOuisiPxTI1vIfRduZNsrmzMb6+gDpKOEbwc4vUqf330BpkvVfUhdxevZZc12BcfQT7TlJ3xEfPntyckHucrWb8He4Nk+65T7loe65T2xg4Vv13Fh6g6UdssaNI2HzllO5DdkYRyrBg3F6Ftzys7JcV1HmO7lD1htYtTV+0hsfKpWpPzj8f7FN8ZDetyku83wLdJ8ZwPO4XKX6t4e1DxvFfF7/kNnl9rwvN77C8GBiTORwPza5X/YQetscu+MY3XJOnrAqkrcpqMm6NIllJ3ejpAN6xtMnYGsg5F+6syU/B7wXlZyaBC4VDqsHage4r0hbLzmuZ/XuUPJZ3hlOknoJzFah2kM/Jss5VxnqU2OY6MZz/V+arobpsnNiLtdqTNhy7qhbKbuRrlsF3RP+Xy66BLar30e4zPNDbnYzzO19Ps+fohy0WOozEr0Cz13nPOd9nfgcYH5/tiqZPGlq3sUrpmSj/Ots8WC83vInwZ4/VgYXIS3qGr7LL8NQjP4x2K+foq51ZBtm531XYrSK8pPueizRraxknzAOqLM5roA9hO4fk8P8hRawkml78NLjW022Knvw38bSJ1Sqay5++kuYbLy7qDHuyAcLKHYEc4Lyk7ym8T+W2ki6xPdvOYL/VJa9YnJ/kkJQq3YH0C2yScdCPZ1mRPyLJfULb1b/Hy/J28eNo7aF3vklq/g7xV/UIVL21V/XopuzkOWNjGdjOttfn1MO1ZPck2YC/GwGXe/d0RtJ9TtrOJeSFbiewRScNvexzieUKcmssVsq2UG042hqxrB6U7TajnP9HWS5wy37/UOzayHYfz6QoYo5HvX/xlNs3VkM+8Qj9uLmPMvAjb6BE6VQm4C7CTnXiK30uYEO+w/cr+CPhprM6G/7h9PrvJsMdOKF6/4b5D9aav+S7x829Uujn2yzzPPsnj1YyGclKblDNeldMJ/mdUOSdV/gCUU4q8e5ukT1Xpw+wy7R6Vdpcdcw3QHsX5UB767SzbbjEK/eZT+2aRhbjfI26qbZPoAf8BG30ZA12p3BDbZaZzUKVNU+lC8NxqTxKj7RcUT2X6CcUD8VOq/Lvhn2eT9d+HelO/e9NOO482i814FmCTLtkP2eh7f1Drfdfn0n4JaW9NNvn3UdBXg7R2ouJpfS+e1ivoqzT6shC6H3qkN+blMzFv20jrZSm0Zi3tCOKhq53tiJq24Vc53M0umKcoxGfTOXx22gNUxjd3zIC+o+/gye2rMLyI+I+cz27PyMvsapG/cB/oo9YunWpN81m4S/m9WTHbu10xnkYDh19GlrP90MX1C4+3/xMp1L4CXdkJ0n6YznsryEagflChypD9UkO/NPI7tXz928hLDe/BevJ7sG28JpHrGsjva3qin1Ha7yLl8xHqeQHbTTJNc8RRXQoj5XuCYKZPNIt5Lb2bi+yFOHEOvAc08E5jsBxruypbIUrZChN5X4Z8J/0k2SaR9M6mkN0/qrW8d9R4PJ/6H69VyTq+GtlYv3G0ThK5XQQhbid4HQ23uXoWTGsSkZJPsg0G87r4FYxd5SKaeTzPaxLrLFKuXZVd063JGrZNjYmvKN0WT+ss6Bt/whzjsIVsgsuC3g//wSJ5I75ieF2uTP+LRab9s0rbXD0Lpvm6hfzFmHuoNdkU/94b+tLwJOOWvoBJVHO3nryvp3Hs76bmJ/PCSZaN4360mjv1RnnPQBZ/j/djqUxfZrms6lmhcCTH87+pd4H5Texhfz0o/guL//0txmRLPp9kRy6Nr8Z4Ob6mRr7Lfuozj0TOFYvx/HC8lM0/LFKGkSp/x7vyOyKJhszf3EV5ZdmrkXeN8q+E/2Xk6a7q8xLCX+FZgEVikeLSIM/pLjWHt9D+JTl2beRvyOX7WbKblzrlXsSpyn+QxzZ6H0b28cs89vR0yr0XT6qxO55s/7vG8y78hd0l1R5+mfplLMe7A7BFSAazwGeQcyvz+Sm9P7dI+3A/7MRAJXMTnQDjJBuyiOdvz1g2cd5Ui6SxB3lobpqu2tHfRhGIW2UpYtvoEdcmEQT3OMo1mun0C4k7A9u1ksfdCtMrXY1ynqfk3ImemcnGO890xtM8Ae5J2rNnJltoNj8nmUcxLov119SYRu9wNIXPLhKfnm4O0lPzlQ64AHxeUnpA8tKbdSDJT+rGqfzOW9LLaELvfoX36+HULyW9NKVHH1A0OyiasxXN9ormI2r/WjBoLeI9ZKTPJN0I9Z66I9um/nckJYom5uPhJSzfSO4bJbzvYLiyO4ardQWaYzyj1s/Gu2iNQ5a1lG1luZ7gL6+TWvforMrrrMqbp8o7FE5rASW8ZsB7OHkfhiwvuYk8miP8Muf9ju2vzg6p71KVndqG7DhnI06svE/iourHFazDw1T/n0HyBSYjLEXKTpJ7PoY76T055Kzcjs7BwuGk9V/pdrLIdM2B615s88H+UXmTVZ6XldtZ5X2J88o0wSrfLKesF8X1As9LyMZUaX7vvMC27hHIJc55ieNawbYMZNv/AodbOn/l8BKnnCv7aYXfResFResz0GqraIWiv22NlPSeV/TaKXqLnfIdhJ9e9F30MiU9zzXIPkbRi1W8ZSlaPRSt9s4ixZucq79Fe5BhT76NtiE3mN2N6FNks2RjDNQ89TTni9dqptA7MotWs4/WR+FOSZDvzPY1eX8ZATumu0uuny6mPQVmGkMRDztmI8Zc2q+SiTE5BGP0L5HF0He0rkTvrc7y+tVYs7Q1tsHWWIxxMAZ5TCr9P5C+G9I7+B1DHMbks2KDsk2KInWkr+QyJP1ifYiL9rNfQZoqMQ62j/999SegG4DfRuBuE+IoLa+TRcp3C0a0xeuwvV/h9329eF5yOoV0Ie0HHYL6aTVDJ22VMoqkL5qh42itG+35OeQb4CqAfvkIfG8VZKcvdGYztgPUvI70r4HbL19fBHqB/HXFNmFwosxwWtNGGnMhzx3vAy36+mIYdDG5FjWnJFpRrvXgbQ3zRHrVZF7PfBwLL4QsCiC7IuZho+LjdfDxOvdDyce94FXiaAiHFzo3My5PgwcLMEy4GQbs0bNFeEbh+5xbOKw5p8uygcXF/J0uYfECeKI2v4QyaY3iAttqRyN/BS9Szu/y12Vyv9pniFseqXli0qQtvZZPF9Gqb86V+HraxGfC1HzGuLvEcn+aMVesf0T9h+3qWVx+5ya4o3G2czjhjt7rC/BbibZrxFww46IS7XQn5r4G5jYCF4GMU5n+S6SPQnrrb2CuJJIwVMllbFKYG6rw6cfcYoUrYzxhT6tZkJIPGeiC9m9lgr8lLBfCXTF0dCPefkqhtmnE27BJGxvxFr+R23kB2ulUfBFoFUDWH4HnQtQpm/eWBDCGSD6EEzpLZz3rOBPoBbjWs126Cxjb6KL2LULereBnPfMyzZytL1Q44XVRc5FY2ARnc82b+dvsn1D+SNCgtFZzAT/LwTMKjzJv4bBmTuX32xupLvGybYbFNOIkEziJYZyQfpIYea8JRtYqjPRmjEgMrI0p1ndxmkG8nr2Dbl6EfkqMlutW16W+8hgcjCNPoDpbiL/qAo7oW4rBDomjI/APczTgyJPs8OOI5k8kL+bZ08bxn/EU8h/w1Oc/4Kn7f8BT39/A073/O548YxxyH+Nv4enRRjx5HnHcgSfPZMe/4ckTAVrz/w1PsI0wDsxkmazg9bcngROSYVekj4et3JMxBbyBDsmtSzzpH9hS8QUcHxVfxG7X+K0cHxAfLaLMMn0vuKHxA0QAXBPxAVdD/o3mNPANbJoJO8CnGfg0bxMhfJpaNvTmfLbrejgIS4SjfL2/pYLt02YWP55gUzgvsjxCncX6+01wNVHiqiY3ugFXnnhHMWxSSjOYcRWvcHVdpaE6D0CarziNfx2cTrKIt8oUNNL1oDdk8cX6L7wrT6vJSilWX4w4xDZotQspl0WmRWp/o2Wu2Ii4kZPOi0CLRF2gBRYv4rLQu/rBwjbBYr8HNSN3AFnv8VfhJ2QX604LZhIWh1hCdMPPiV4WkuJc0D/HM75+8Zd4BtQ/voJnKAMwEyL3nviLHK+Bz8WWNNYM/egtkEVq85Ex9ObmAkvwHmVRDGCL4oLa4SUt2jygLI/rdg5S0Go2o2d+zOHzkLpWoyUU60dVmJ7HhRfr52hXGfLV0g5guM3hfgBpHuadlNvEr2jd+2g3Fu/OIllSi+brCVx3ORNfzyvjWs0yyHZSE9lW/IZsx/yGbJdBtgOVbAcp2SZaGuX6bBO5VvyGXAcquSYouSYquQ5qItdMJdeBTeQ6polcBym5JjaRa4LaTfaBWtndrORaEIOZImh+0kS2wQn5+hDw+nWDfMNqQk3F+nnewVqs1/GOu4M8C52CMO1y3KJWMjYp+fUlrIIG4fTNFFlmMzUCXUmht/x0Hg3JcgivRo2btAlaR8o3ELNCshbehCyTLEW8Y3WwpYDdoRayfkiW2fy2m6wVGv2uhG9k69MUPwTPN7IFmkS9nXYTx5PVVKYPZQ1Upg+O38rxGqyWLNd0zpfE3/lfprM2asZBJkN5JnwBtKXFQatGQ9ji/VXQjHBtE+ztADb3NJFfKLB5jMOkMcM8RvTsCy7a2V+s3+RdhlJ2T+BZEH8Vfnr7J1eM3Pep1PeT6Qa+ZF9682sn6MwIY9WxxfJbV0OfEe5/LC6DzszXv+SzU8v0/4EbC/dVuDTP+wNc2gu5DO5zvM+omPcOtIeOiQUn+Q2caZ4+0LOH8Hxvk7iBDpp/FusljTWoaYvW/5X3rhTrt3i/kKyBHc/mmaTf6aKTvMt0F1yS1gK1XvEA7eOA+zjc5XBp/8AJuEt4njm/Yf/8YV4/8e8Tk+EIFe7IYa1mcky+Xoy8f2rkt2YP4v6FuD83iWubQHPmYv2fTeoQgTpc5P0yxfptXgOUfD+FZ6+oOrwI/2nlf5bmdkjbkt9fFuukkz+C+yDc9+DS9xzb4dJehlK4S3keK/mdrfh/SYUdKtyp4fs2WZ8p4P0I8q5rwvs+xH2DuL80iYtIoHc3xahnY306oz7lvEeqWK/nfTqS79+B/qN4vkDVYw78Pyn/BPiHhUv/VOYlrKZUPXtEhYeq5+NVeG24PB+HziMZXrVsiVb9GVnR1Hcxk+lskudKLSAXFvVPyrJekCBndD8lNLzRrhmWcoX7On93baPVaLqngb4MwbPw7UKDlbEFlst5i+CvgMbGV/LOZ9JPrdQu8s28u5HOtdwEXRInDlk+BB2yPnbyeTprU8ji+pD1x82UKjEzMluP413NO1DOLjG1diP0JCyeeJn/gmUn8pfAUtiOsj9Eedn6cP6KYQfSbQTfNE5sYr31NJ12ifS0i2Ft+E6k/wj6Ipt3xJtpZYtneSv0sMheGNGL8GwIz6SiXRukzoos4rw3wwugVzagrCrhBH+z+c10id4icjevZgWARktzL+Rbz9YNWdZG+Gn1zAarOBvWS0/Qpy+Lt7DVlo3eLq3qAOIzpohX9pvb22SQTbZbjLJvAbUVemt7IXLIeVewc7ewYr5I74paOdeDYjZGP9KC61mrfRaTre/j8AbGYOeEbP04h8M8PtJaljBPAJ2zZAvzBFMYbgsKx4d52lIYbiSFkS7KsQE0I1M1jy+NziTL1iugaQLS6B6PMliJmieY/LCkW9BzuEPT+LxEzwMUtvXlHREj03YAP4i3DeEdkOct2wk7nrZpH3Hb9XRt5/ZrzbgiPG3kr4OC4ptihXBC+MjWezfgYiOvRobegYlGPIy4Aw+UhjDQ2P5PEk/mfN4hYcSMwkY8x3NbeCakEQ7wPH4Iz5YeT9uA8WQ1n/AZFrkB46DmiUwr01tGrvbjwxOVRvj4iHl8UY1xhCH6WtAUSVjYwLvKW0TejYVvGAvLG7Hg6ZkmsdDaTkggFDQioBW3vmz5DcSTbHlP37Rs/VMOc8t7BiF8gsNh1YfmfEktWtMjYDG1eE1WwJfsXqBwfFjNyDZfsru5DcKWDUzv6bTWGdn6JegSLbo1MJCWRm3eOoOkFVaTTnGgK8+R7BHwDbtZAYwH0GU81GQNkudnXhjUgIeakcm/iQfwQO1BmIDdmLya9QHpBm2ixEeb/xIf8f8lPpLvwMc3DfoifeLqBn2xuQ21707mSYuWuLErm6hRV2xgu0TigjBBeGjEwpz/ByzkNNEL6dH/HRY2NmKh5lB0tr6/EQs1PQZlY3RiLHhupEksxCksLFNYqFBYGKOwUMBYAK2JhIfWGWE1waB62YV2r+mhsBBWk0E4qMlKI/8RxsmNNImJOIWJZQoTFQoTyxQmKppgYsx/wMSYNnfqiPD/EgN97sDAb7d/SkP7E0YIe4TsjcxPAeNP4iF4ImFD4iFDYYPwUMDY+IhtT5LMU/9HXMz9f8DFG01wkfFf4mJTE1wcAZ9/bYKLOODipNIRx5SO6Mu42MDzhzcVNq4obIxT2NjRJluvdEl8HJnYVC+EMh7iGA+z2L+M/cfYX8H+voNIdxxTuqOvwsmbCidXFE7eVDi50gQn4/4DTsY10R07muiOUKU72v6XuOn7X+qOkf9Bd8xqojt2NNEdoUp3PP2/YuROfMxjfBBu/m8YebMJRmb9lxjZ3AQjx4CRz5pgpC8wUqp0R63UHR5TGusOT0ga48PTMo3x4WmXxvjwdEqT2Djm1x2e7hiNrrDu6EsY8PRKI/+b7O/H/ivsT2D/uDnkv5f8KJPxgTIJF4Q1Wu3Kh1w0lL+aV/haKjvkXrY7NM+DFIb9uhm2yKi0K0KzENbmii0WavNK0Qzx7ShN5FWa03vGpgnM4yvFVsx921ncwgp/D8ztsy2ElfOY7xMGBPLrSAc7F+n6Id1oyxXQOieyLIQVma4YabYg/xKkI3qjkG460mUh3WY6Y4jTaZ5H0+itOeFFF7EIP5E2g1cHl/Bb6atiqWW+2IBZwu+Qz0Rta8nXw+LP8W7STmyrXOYVv+5ptF5wlee3L6k3y/TGg964myLprcsv/Aa1ReQltD29ibyMtL8gz2pe8Vyh3iTRqmavtMu886C1fT6vmGXy6VxyHt3KeRF4P8vrEYw10CA7oV9asf45h8+x3ZGA8CkOh1WXzpFjTKLSI7mkR+xhNdcDpB6ZzGNMWM0e0iuQwe/SaJWTdETb6GJdJ7x4HKwz5vHYMpP9pex/gf2JpEs8L7E/l/2vpoH+wDYZ5tSKIlH48RWj2rm11PU2z9BTeIbuP4fx9cXqFHNa0XHSKeT+U8TXyFOATSdlWL3but7kHcNkfscg17E38fkHtE+GzqCPE7+gRbLoXDYL7dOphNYpxlyeTp2ideGLkDZmSs5ytGyc+JLXd3WkE/wt/T38TTSdM0L7n66A5kW53qvSn0PaTaCTxd/tF+tW/s6XzlGhb1Fpbfgi7yUx8fsyHemu8h6l36t3uoH8bUY+n3+/h2Ze5ireY0B7OOgs/7aTLqvZWeP+DdqrNI9mUpEXgQw6X3+3mMl7TOgEtQpoVjprv5z5f5n3h+3mb4YJjev5Pf98sdJ1kfe8OJ2XwD/tt7yM9BeRt1h/q+FktiphU2fsBPM7XKDTPk0stNO857LYxKeko1daXoKf9kxfFFH2SyLLXiF6IGyzlYtFtLcLM91Ae7G+lU9Q/lWE8GnnxfrfOHyVw4kJxfq3HA7z1NHcB+PXUBPPhWreM/FcqMZHYXNYzRSaT8PdR+fSRtKp1+fFcnskUBcBqsKOWVJNomO3mGWmuFdiKJzrIP9p9l9n/9AE8k+eS/732L9nLsoY1CkjPFXdYxBJJ+bLWfhQhcX3FBZ9CovvKSz6/FjkU8iBRapLPMkFODMDixQfDryZgUX7WRFtBhYhl1Daq7ofmIR8OtgzxC+QT6Y5Q3xpBw7hnssBFpG2h7lY728GBs3AoPms6E5r7WZKS6eVA2t24BDPNtiBRaTfjPSjYUWFIe1i4sVcITL5RHJgK2cNa7oYPlk8Q6xHGVl24CwH2LS/IhbmFOvPgI6J7p6gU5Rz6D4Gt8hAm8c4q8TMHGDMWSE2Aw8BSDvfmSEyKS36RFQO3dkwlL85MuUUQINhhp5TCIwVCPo2qQdcXhHIydZXqtGR8PxKDL3DnS/iLDSTvyhMFuDIAhxZyqHB6T1LuaD3JnJf6lkeDU+jteX3MBd5tBwKDH3H4QqymKp/mlusX3VJLA1TWFqrsHTTJDH0dDjPr2s+I0zxCen5unBFwoK6SitEMRjjIwkbQxkzCxg/77H/J/b72D+M8TOFsbSW/fuApZsNWIpIQEnJMiRvvwCKU+icvEzm7rMU/0nKtDrwvdKR6zAv8t+pFlum1XTuHuY5NivZqoGPOOujPq1yHH5vJE/0pVZ+4et81lCVarh2IsxzeqpWvXaOVvNT1CSf9vUI/N6jNF8f9kV9EVSVGnTtxCCrFjPe3TE0tM50u6O1vTUjIijDWL1gdtTI1IFvjQpKtfq0V6+f0BJS+wRUpQZUnjDEmKoXzLkUET0yPSEko3XqJ572L3hORFlrvQfrwmoOPazOKc88o3dw1Xlf27dOb2cD7p11Xte+M5gt1nk3wm0Fdz2etbDXeX9EOBThK/v8J60GuNf6/OejBrgLfLe90/+2TjfZar3XDhgOGIZ3tvK9P559Djq3b5VvW1L47NmjDdV7JsnwFg4P2GuoPjTJUF06GXV/CnV/alPyjROrfAV4OuDz474dSc1TW+097tuVNBZ5NiO2FWL3qdjPOHYrx9J9P3QPDN1avcr6vlVzh98KsmrVVyac8UbXa54DqWe8Xeu1ag1uJMJfwm2PcGe4bRAuhtuinu4HMsSOd79mp/PbD/mG4nf2sUO+C/hVPKZ5Hpl90GdYf8Z74zaskNlnvJ7bdB6q5rHNHuidc0vzLJ8QPOCM9/Jt8kXA9yt8ORM0+M6Sb5KhZ9ep5P6e/w9eClyued6YRDR/n0q+P/H/z6kjqjNisny+SVm+Wvzq8Bv2+K+Tc/VEvtOtq/sTcLxmUqZuMsvwC3UyrNGpwpNCbYd8a8Hx+sdoBertSZt9qx7b7CuY/KepFNI8qyf8PPWM993bdA7sUCudWE/nWL++N8za1hpoNRYM98735fLdkgZet83ls8jpxlOjCgfw+XCn+Cy/wy5j4QArnfu2zJtQO8Cq7Zr9uTzvPHtXqLUZ6NGp4MO9D/tK+X7iZUhP1Erxo1CclWiV8oxumXkF6rTM27I2zuo/c7spX32a8LX0Lr6W3sXX0iZ8ld+QfLXaS2cjEm9LoTezdmlM1eCjE9f93DXl7W7O1nj/5dN2yVvih6p75YOtYdbl3oW3z+idG07tpBqHnKIzWOWd9ptSHaks7c/jrPXez+ppPZfOSJetd6zhtr6u7pxaql2WTqcWFrjoTsdDqoZRIo7jssAH3RT+bbnhQP3FH++R9++t09uaqT6BVkNVK1Mzq4dO40+mu7FunOjmLuMzITOsVOvl3qG3n7XWXDHy/rcPk8/D5z0xE/14tddRL2s3W96fbnDL++h99w8upFPKPb9Od3y6ylebMHa3wbOY3vU3H2g1um21RqD1/sHoXVO7FSzzDrjRrUjznH4xA3UtBe6/5NhYjv35RVNBvfer21p14vz2Be13Lvf2qL8PPahyarw1IiPZpzWfkrEqNTQB+iB0wtT3k6+f6FawHD20W1G49VSTW71JItJv5PYOTaLQ9uQv4Q+oCg2ogNbsVhha8K0361bLglx9Ts6D3tB6OqGE2rVNQQm/5wjjEHr9YyV8hkgLFb7yOJ2z96D32u18TmdQ7zNaueicvTLVD2j/HZ1/V6b6QZvCDCudgbcaLdwGJQ+un2mlmhf4uhW2Qa0v3m5T1Bsxud5edd0K4yDv7bcJD13rB1oDkS7XF2/tbm1fEOCedKt9YbeC1d4vkW4o0p2sMxXdi5zfervc6lYYgrSvoSfQV0SVDq88Nbrhi6+tYpsrBMjnc/WrnyYL3Unr9RRPcWe8m2/RTVal+lynvA87jncRDrSGFtC4tsw7wRdaFFjYEhyPuI1SzC0L28Pf7jZscjPxVe9tebtbodSpr92KAgLuBzdz0FPmcr/z32W3DrLxnzQaWboO0rvzXOV1kD/01WT0PKdMb2ZO6Jzo3oxD9+eU7nI5nbXtP9+Vzt/ePPsPD8oz9DXo+093ZUDTlz75oLcT+HXyiFyqn3MupfsQqjUHIbB/AXTylOCq4GDNkwa52V7WPLPmy10uf3eUiy/4fWipfh4tSmeihyJuOL+fzdUvsE7YirDmueLI1a85V7B1vgQap5pPbynVr/OXrWvUboZMlusPiK/gmmnV6XOXqvN2z2CO52+Leq/zVn/0imncKx64NcKaYT3jLb3ZCy3d4fZMa/+Cpd7l9f0Le+Hp4Vs/XAqO0TyTX6SbN/oX9CoaaM31BtT2R1uv9i65NQBIunFrEBDUHwgadLM/I+fPtYSc/qBnQEwg6E2tz9Uv8RzhjL6HuS5h/8cNp9e7xYyc0LK/oLUDC/sXLBRB5npv+1v90eKvzF7tfQQ9+pGXeltDQOu++kDg+Iz31Zv5fP/tT9z+IYWH4OuD533q+wDx/cF951so1Qxk5NBtmv3RM+u9V26GFspx9KmbpXoZ72OVevwSMFAGej9z+BBcSBLokbcedmbe6C7bR63dQefITc2TO7d7UXdrD9Q8s64HatwHNV5a16eQJFhxm3h/Cby7b+X6fAl0mrhxca6vQ1Kur+1j932a62uf5Oy8uu6ax1TXLlb/uNTXKqlZ5SiDqdLQaqD1W++LN3N97ZKykHZ78nD3jEWU09BnuDsNvvaxxqR36qqvBdSFP5bla/dYrq8bqHZmql3vohpBVIM0z9MLTJWHgz6raGloeXhthcmwFL9cXxeU0Bkl4Pn84e6hi4gSlZIAX9c7SunyGJ1o364dLIQE4lXzPOAyVo4wmiqNrSeA347gt8tjKMuEMuEebNayRPM8vmAHSnwHZb2JH3Teo32giXb4JlpJSrneMh+10+mbLQse9M6/Sefj+U/o34X+7MNv3wH5pcgAtRPKOWcFf803kO7zmEtx31wybKeT2Vegr9MJRPsrAwx0Z+WzlSYjadQYd059qe7km0zpxl2605DuQujqtvsyxLKcloXLEOoBPn6u61E4HPjtAKsq+cUeaMVmt3sUQTM/Spq0EPbOKI6tvdWjKOxsybFx9yckzH2Q9ESHv5wYSvdOlhx780E6Bxp6amo75FlZ1xIjyY5azfMmLKUAcxuEtqiQydwOoT+pkGZ+n3XBkw23Yc77qRpzqOvqRgd5cjS0S16pbm9IM+030hymk5Cha9GC7QzRxqr6B8a7I4KlpvkWv++cmucLxxD1jRxhYL646HpG78/9kkb74x/PHkWteO8PpipjqKkyxbS2ruqGsa7jV2hX0zO1y28G14U8FvdpU83zDv8CnEPQd3qKYGe2vBkH4Z504yV9A+k0DnJYi+H/Z7kBY3eHpI0Xye2WdILvRFhVzvq5HEhOojIlhloeJvTAQgX+WiURag/5XkmIs7YpPON11dL9k20Ku0LShrre1t4ixEx9s7aW0nfTHebuhdSu1bWdk3oUdS2MgL9NXTvWHk/X0un87TjvuVq6MbE39+ufarvpL6p839ZSrk7weWvHuwcEUw9oHwv0N3um848f5yW3/D64zuSJGxlR2ArWdkItPYkb2amwM0J9a++zlqMubdtRLzGglwxAL1lSe+8ueYeseyWNJXRzssGT9vIHu6CPXQOszapCm6/2flf3pHUCj8DbZ8KiTqjE/+aEU9DE/2BtnPN4q8Hv6IGub5VNipgpdMtlcFXb4Hf0INdpFR9ScAS+b71968KgmXpDQq2B3g9uti4MQ52+rw0rCilsXbCG5yZvPNkaY/xq79rakKKHrBTbsr514RhwsaZ2DLR8YF0Icq3x/vN2a6A2q7aM96GE2eW3ta3oTHHM+0dbdonp9i1iix08PaEN2S2slk1iqd1ibV04TSyxbRKB9sCCU2KLk96T7xLpdvrG912kmCc225JEMztsGcwLp9vOi0DbCr0NngfZeokl9mkYvc7zLVSjbCU8d5xh24K83yEdfauwRRy2XxSBTjoxPVFoNqL3EtOjbzM6orxw5Gtvo5vQvvXu8QWiNku97W6G8YjVtW4iOMxAC23zzbSa8CT4pqnoUVhIGN9u/JlHJZJZyQ1Kf8Z7/w2M1mTlYAzr5/wj7zksd+4R/+B+OO5HOnHsjN6Le9Q6vWeDDTIMFkmP37gF5iGUhHZQXB2tC2NL7WTtvdYpcP9Vm5Cxfeppn2FA5VQ5y/vZW10/1Pqz92q9AbP01yYmpB7B0698hii05ERj1Ema003Eb/IazAI67SK8UVlHyg1RdD8yzb3kXUKZfyUbx3830CpfadvjvuOJBs/Kp4yVi4ya1VT5d2NzoPLdXaEDp6DmX/hyfRd70G1cFQugV1p8/3FOctr3ub4Lk0t9Z9P1yDEHdka0qGvmfWDkT5cMy7+9pBmXjwo+sHCU7eS+SoNhZqXReMZ3aPF4tyFExj9wEvbNKwOtpHefqkX6mCP4gV5ifnK7A1RWlu/XycYkY0yLA1m+8kT/iITSEiMO0LNuIw3RhpjDyDWi+li45rn+4rkphniDe9FCurPDmBJ+3Djo3IRc3/qBxgTqtQtOjIDtv3LCam9MbbOzub5f265Ihp4zvX8i19ci1l+zAVyz4dVZC3N9oSgteNq/182s6uZsUreKRY11+z3qFqXqpt8IrAo1ap4YWASXfdfQo9cOSnCidw8CHdTZjDqHJsk6t4jN8oU95q9zy6TGOgcnUZ3DHvPX2Yw6H0ed41Wd31N17nyA6hx7lkITLhsD3j5ujD434a3yFd+j5o+t08dD2xmB52m+dfrDZsgD/mcwIw0r0IrqvQt9hL/nob3C2knZvH79lY9GVB8KPzdlRHVWjPnTjRnnJpyfEtDHUL0NloKYd8bnXoh6t4DsXFT/Z2rfurYueT5wceVQqa8i/bPKFs3GHNA7BlY2a/8DePr2UkCMvD/lmZOLI6dWmkzvQ2KrRk05+UfYCztGaR7fa2/BF36ApJDlu4p2914D5YCIA0F14U/AZwqFJPRD+M37B6iBu9aa5+YcxxSytAYvglUw4/HLQQFJx9Hy3Y2DjAnffLwm2TFhuPu+RZDBpFKfu/sPU3uelfJaddzY/ZcJVLfzU0x9lvP7hrRrI0xp1w7it9j048cp7uGmLMS+Wk73mtAYv26J0UB3Auf6dGC1RZWxReYJktG0jHNTCG3t3BHNxl9OMQUeRxu1njZle3LiAUOsMTYPqGqxCFhts3HKmuSF7uBFdF9rs0VkBxh6/owe/tYkWkPqmvqzt/4WzXh+9tbdolWkn73eW7SK9LP32i1aRUL/v0WrSD97K2/5146mWJd5591+Rm+8zWP4tdMLKXbm7SnW29599R9gnt/VPbGWpHCSbn2BS2sHa2CDVIlU824xHM/X1hoLaIWA5qkPeAvrCRuYkeRgFpJj+uMyb1w9YeRtb1a9XIt62/t6Pc0ktQKj+57bGlK/7c2HdsWcG892wlpe+SjptqehQWn1Lu8G7XZLhYyz4DoyTO4ppjF9Ak7Qs7M+kr89aHjVMvS+Kz2AoMRRD5kqA8INUXTvyMpJP5CUJtL60zeYFdH9vg/YZrAVn9CwHnqatSvZOjRLJy3by/vYzSjrDe8cH91hNLaeVrw0z49Tz0723zH4d75n8PRU6X6v3B+Uu+ZR6f7EYZqDtqk3xsad9WPtwev1H4Lz2GR3QIDj2kH8FgcQevNjHROqLr5e4/6wVF+A8aCti+pA/J7Ug5zr1Bd1BzFy/3zR1CfwuCE2ztrBf2PSSurh1O/Q+yb88+JTgfmnqGRr7fvQ43T/k1lrG0x4JFy22rvKN2ywZr3vE5pzPLU7Ci3+RD3V+QHU3OxedJvuOuqJ+td73/fRyiO9I+jibl1njAv/Plc/Cn9z+MPQc9c2M7hNhoNdpyRPGRF4tt6r38zyDQs0xJ04YYiitc9We01jTama9ZT3Ym2UtdXnY8BHq70aKFejxAHe1fUUO3tvM2uotb11T7L5tFY50kC36zSrHN7KmDjAG1534ePq8tmfj6jWYmbvPfi0wbP8Mc2qJTl2G6o7OwyeQ+kn+VZBwuvkG3Q34OzPj/vWDwh3G1saPJ9MDztO60KTkDp3MqWiFOHuFLp9zHypPFePRSi6jmJLfbkDElLPlLv3jnenhxp6pvai9YJVHTOTI04G1Rlgoy3UQusMrbKTtapULfQ4rfpM1iP4nhpqJ7oTciQsCVFuHHy+3P35AboFiNZtq69MBMrsdLfLNaTxj+yGqn8uvNMqX5Ocgvn8lRNn9BfQ4i+4DJ4DaTLHdJVj31134jXmSEeOdLrz6K4cG+/KkadyGKr5lldYIFOQc4qTbuSkcyrCYWt+mfaJ5NMp73rLbLjJiO56s4KGiWms0p/imlNL0PvGj5vkevanO++HW5McgDz6CYOnOI1ud5FcTuMUU0p/q1ZIW52YehtS+3NDelmrh+5Kn6nSH+fVjUZLqn/pGT3mrpnPF3zDXGMrRMHairzL2voCz2ePrkepSeX0fmEs/08tp50kC/n/3XJ6WsSzkVN4GuK6UA5OXZ+W0/qk6xB+Iw095n1Fd7Md3vfx3/B7wGA48iV+ya32hvL67KNXWjWPdg+uN4hW5mD8OrtP15/RzS66LRNzHiDSkUprr13cwTepn5/RNX6WhTliq88NB+L194bit8/gyZzQeYChKsI0waf1GYHfe8k3TswebfBkTziY0TzVNHNsqgylzGyemonQwZl8C6RnCT+XPnpGvqUNcVkT2v4m1SUTTEiRkjE2NTPDT8c0008ns4GOjBtRPSjmoL35QnrH8tMkeevkZw66cZLu7+oECnRnV6eMrxG+MikywzzVnmGb+kHGG1OBfkdkxlGEzWkfZIxNo/u8IjNy0uwZRxFu7qC7uyIzbA57Ro7jg4yvHYRC5E9H/nTkTwfSHIQg0ECceRpoTDNlvDEtJePracSNxD9RoTnoEswJ6AawrF0Gz8FUM33t46R77CneuP04hwI4RPdrmb5ulRqR8WjqqlRtVxNa4LCBlufvRKs69P9Ma8FsY1UqpJ7OUn+fpT5gr8GzYvKWmWGpv858GBJbitotmvqoT3sqGb8NSGPAWNcmIzIV2s404HOD580JmZD1QbrZk1v7uO9QYvPU474jiWPxfyyR4vjd1Iiu1l0YXTtYR1SHBkQmyzdVy6yBJ44j1nQ9OOYTT3D/h2Ht1CYY+jx0nG729L9hXE1aU693DRBBZlrR7+L23NY8C9XZagMc0mIwqGflt1uJVvZcX1Hiyd17QBsaHeW1Pa55siA92iObhZHGZKY7XmWOf97eI46wfTLlANGKEK0sNIe5n99ZEKWE2XS/3DrYG3hmP15O7wb+2zqlqDo92FCnk6pOdBZPF/fK203r0MW99P/M//P/v/L/quJ/PvgPbUPnct3Jf//bdBaFu4H/Xg38G/o8epwsq05Bvz9VCmtonT6gwSLSPKsnkj0kLaPVuolyu4aK0TmaZ+mk6+KIy1+fGTkn+XzLpah1YJNaX7sVJww5d0qI3lYHKQkZmqQtu3WnhPaIihwZcosxkMmq35TXGb0ZPbO/V06S+wo6l2wbkh1JLeb6644Yt8n0o/ZjaHCf2XtbWNthTFs+uTP6yOpJBs8XadRK3/DY1xWymmE+ro9oeDdAGraz+5nbRtbA0RmDUvvMnv35KtANdwebuh3/dxph/4HG/bfl7cQG+Ifclhr92/IAW3TqSW5ng+GL12fv7YKWLkhsvhD9l95bQYfMS5G3Rc+ADlnpaDIq8tNZfB+23OHjt1+RVoXQKmYNllQX9wBY/wtSyMpZw71xleyV1VkpRNmf/4jKL2cBPFKjVdpgxvC2g2wimedN3lHkL8Wfqv6m9gHtpAFiHBJhNTebyZjq3BQZo98MVGnWqDQXbgZ9oFWvHZmprLYu7h9vBnOa2XwDJ0nahNYz9TEd2OVblfRJbea1p0JoBcPQzHHN0GwX4yo0sOtw6hFB1CNiA64HR3+MHjHcnbtwj29V7Me1i6snhsDKfqmD+5GgzgcQ99Jfapd6MVtrFnHg9ZAZ1xY364k+vGran2uX1LwcQjgNH96V0qnypl87iNK0djEZUdaTsCbfGz3j2qh2qdeWtMt2B5gOXhtuclw73I4kTNKlN130jmL6teBYktCMaw/FTviJZL6myd27xw4Yow3RJNmmsQ/8pOTbNF0MzSDemvp2k9jIU1r1vBFNY1qfwgzhjjTBSDPrzjSlhhjHtZxYeVej49rXsQU+wwTqQ4MwdzdG/6XcGIP+Ex9xINx6uXw2v9Hu+ht2eH/v+FvSDqc2errz5siWQNlmA+1JiAgOrmuWGm01dA+qXGgwJvX33nsrot/1E3zz594g0Ht/F9ENt6ZHfQLKhjrToxFFAZWZASEZyb7UzrTiUl1O74foneONGwnWaOtQa2/4v6pPj95maFsXcNMQ80vEVx+/lRxyMqgy0xBQZ/p7xsjeIw0ZwanGhKryjrvcn/uYd9KUkVYqk6iRRqn3Hr8RbU0AvaGguB4U9yQHng6o0yYZE4G6nAsf15STdvF9HryXZgoJu00ZJ31r0eIL3UbDwY8jrMFU57Em6GLN8AnQ1mp4v+MmT0EaZnTLTZ7T5M7YVxloPOlbOIJQOrMyKOCd5OADbyY/843J80PD88b4SYj/3h9vQLxxBeKzkvseMEYZotb41rZr7Q42hlMpU02enzjliUuGURs6TQMNlDPV0Otd5HiLcnQ3dF+D2WMbtzGgt5+vz0yeMubvr5XBGqUHX0GzKkOafYRcW5PbnTR5fua57F8rA7RZlSYV35eRN/zTkE8zUXe03xvGqL+UG2I8vCIo1//k/azUl9VdrPvJjtsrviA9c5RsOcId4n9YvmvfAVonCLT+7UCVeHb/bjHuaJV47odQaKevbwzAGFEjDHlxojf047u3l9H6afWFuYHVC14K9LifDazOcgV6qmYGVv/0SqDn5gzjGmha17Ni4f6+wnD0ObHwhz5iu72vCC16Tuy0JwlzjgczhaEiFmNIeY5c0/AuCjhrOEB3I5MdXYJ5dIkeaIfNZe/iXl8bJXrnoefm0PuBzu7HwcEyJzR2EaWFfebs4n6rdplYWCufm2u9Itgsb88dg7DlJr0RMqGHxFnpnDk6nylXN/5Qyl8UUSnN7NNEb5dTrLxMb2T7iDdR0vP7+4idrkLRa3+GiHeh7jnxotgWJwJzZsC/WRgQvyQnVw+wlYBmb4yB6aJ37TaxMGemyECaeNcLYmdtOcLPgfYLoqh2hngT7kq4RaD3EcaflS6Uc5nOk3GIQtcs0c82Q2x3ucXzRylNvDhqoTTbMQo4QWOFOnMGPF2ehvSbhIH5jRe/Wi6JXkfTkSddFNrOQ+rpYomtt0jPAz95GSLO1U+E/NBDhNjuEQ//sEls+2GHOPRDvTfCJ29ppve+FbdKedeKwZYPeZQpOZXxbbOay/gBnUxEp+2hxvZfRSxzMoNvH3nESdzSj25Re0PdLgwJI77Q1VP0dlKteopQTtdTxDupVj1FSyftlLgk+rvo/fdRzhfA+ZDf/hxs7r4i0Pms2GKX+UI43xZR4JwFnZkhgu2CeSh0fUV7Dprkx2hlj+PT4HuBdixatDmfuBMnltsPK/6Q1kZpaQdLT0E3J83g+l0ULZAuxHmwsR42Sku3caaLChulC/Tcclzg78R3uA420DPaiBdqAapvunjTNoNbpKiI+I7nll/mCqwZZpJ1XunP65R7hY6g3J45KMvZB2gK9GiOrSIbaApxbhNv5dwjWlwmLSjraLDTN9iBNSNNv4Jn5EebvMX0AmvG0M7HH4gm2spMPAXWrDX1Em8elfuTCvP6ipC8mWL7fpoHF4jteWQFpYp+QMVOxN9zGXQuUxuU8h6FCsh6Sw6V0Udk7A/0mB1bxJL928SO/bPEjqMoa39gzeaGMsEXtZ+rXPRyBtYUmIhGudhB8nSG7FL7BlcaYvqkfg178ah8zzGAbEfKZcwjTFEbhadCymn4rxkWQH4NfimnrVRv2sNOdaVnNWs5xf/H2d/HNXVkDeD4DQkk3KCg+BpQA+E1qEUBX7CtCHJV2q2tL12Xdrf4hhj7PNW2W91sd4uCVaNUqrG1say2Wg3YF2h1t8VaqKXVumWfqKFaleJaa0C8swGN9/Ka7zlzbyDS7u/3+X7/SO7M3Jk5M2fOnHNm7pkzLM19KADzBcj57PSk7inQO0vFsrQs0AiU7jvK5+68Gl4I8bVzpFQVpHp+kaqB1I5fpGbIeTcppVR6F7mn+SXGc2Pl97ifyDW0MArpXvGkd3A/WtoZf+Q87vk2Cj2doIusx33fRkHoDDXoOTZ6Osy/hO7Q6GkcG9Ur/KbXyo8w443H8fQczYoU9Jyt0BfJ9z1Kz/FZRZR6RtKeot91vGFXsiq9K1uXLqH3qmOrvqY7nbvQcm8Rpn0FmEQLMJT8jL5L/ob0yht7GXldQ+1iSsWrKxzipdSgVi5I2Ro0AjEAGvVKpv3uknC3avD2ShVaVFn2wg9Ww+tXOByiO7VUvFunbA2JZKRdWMXVlgBDIX4VUGzkLNzJuUzUE9mamrnZte4VG1Ue6zq1/W2esW0WpvSqK1SeA+sU9h7hcpeiQtWeCu+cwted6nKVfbMQ14s7xLCSobfzbqG93rkwOHoI6AsXIGUqQTvi05QL9QoVPcEGHTedw71Rc5eTnyTdNQ/rROls9u1hTrE5Br9zB7Qqhp7v+/a6cyHu3D54LdwdEMK4TxU6xGbo0e3/Hz3a5tej3kKoYcEuqOE8tAhrfFu2/AqOxnZhW3uFp/3aNh7aNua+ts13K4KDoqWcc3qC+nKO7LLStY0qFFaLIxn32UJ5n1uB35yk9mzitnP50J7fQXseh/Z8WvjCapxb3/Ma8z+I5H8OYeEM+6yNCZX2RtfDWk7l+RShW6zikTRFSjH8S9+dz+C9Q4/XUpy9R9+8l4Ylgx1Ywspf6LMLKIawlXdQP71MVB2EkmMhTz5+Zf/nx7bM9T+sycKSrMMphsXiV1bd7PN8MMXSKXhiainO/NkXZNwpJn0FoR9dsJ4LnuhgftFbxL6xD/sPXqDfWgD/qKP78P+GbFnnj/+3u/vx/2zn95DTfTPcnTF4rKNUDMEv/EqHqBnuEB0KRatyiFO0T7aYhuoidIzx05oFmUzSpzVPZdoyj9VsL3CKWycn5cW78CtZjKuNiwYdDPEd9MiMvMdc2j7rAKbmFV0QMzMzFGaXftba4yrOUsm0316M3+02C59148g+pTbCOkG5LoErFU52WfmtbJAB19+qaOAY67CtyzoV5WrI/063yq6uSOR6BK4zOY7Ro/VRdmTtx0WZuh/Qmieoi0kOS1aVN4JGncD9xyWt8DXMqIw4RwLXKJwQgwz9tQZ0XnChXTLm/7RD1f7+QpUNrX7/vjwQn+3HFgbB0yoeoqN/KK2fDhR6tlJaZ+A+qWZ7IPeQ8OdO+TuEBTRNi7RP8flSVfuNBSrQOGvbqwph1WPbBVID6KYCpLispb3Z/Q/CVNwlZ22S/VgGUGR3gerebLXqnj0oo+1QoZmsrpY0uzVshHu+90+Q1w0SbAspN1kATwkkwYL3ZR8gGhPmSSRB8J6zRbpf6YH3udCu5/HW8V2UrtV0lY72MSqPe9kqkKLn6XkGPGfwYMBeagujxnuv2XjQn/JIYG48CQStNjHnMPoYApjoRQX9DW2W9nLkk05q05vwzActBcvnk80mLA+r+edd5JAJ60Beg14ZVCC3VJ62FVjPYYhvBp7sqwfLYjnMj74BJduQI3jHDYtyUk8CWUhn9SSWRb/nm0HSn7yt2Z6AttgbEcN4Bg9tD6tAl6gi82xVZEV1G+Eqsl04r6vk/Q+cExd5X1hB4UhhtA5ee3w4F8kFwaiWduyhdszUjhj0MMmCG79zJXPfyPZCTsluWn7L0LffQIk9kl6JNtfyO4X8LsCM9tRIOed5RTX03XKeDwDaUNrWkKMWFbdFmNrhJgXmZuBceg7PPLlAD24j80x4/iOJlFejnSfmuAQ51pBtsCJYZcI8iRBuIWjJus1UR33MPQIwt4LuXE5tSop5lamO3pdhAg10K8UtykPM1wJ1SXElxHPMrcADpXggze/qex8kv99qRtxLaWozfiXDlZe0Fwiz/MlBdH3LcqOoZyr89uIic81oNf23TM+5HmFmRwO05w1qmzyX3uWj8nyx/FWKs0BqVXpEOjmCPq4XNvBBNO0wtIumeWqWN4Cefn++bsinuT/NUwv5gu8v266CNHZAvi8hTTugvhBICxkA9xSkDRqQbxikDR5Q31eQFjoAbiSkhQ2orw7ShgzIFwNpQwfk+xrSwgfAHQ9pwwbA/QbShveVBX1iRRHF6QhcIdB8xTQ+EteDclxhlqzXxx1nORWn4Aq414V13WjbvlPweFWVYSfdx3dWBsK4Xn2Ctb8uTOgO9Dz8PFseBOHfdweB7rJEDPRkrmOBT9d3sBWB7befKOC6hXXeQE82TT2FqZ6apUp7t5DvZWKS4/cA/86PvPHxwcyIHxrEsMCXs4LK9bO9wkkvxvSze4SJohRazYUlXxV+7pViyvJIiP3Ym8o1ukIr3cCJ12Yh1R2uZDyGdSouBNrU2AV8b0FIeRiEB3WHQfs0YgH3oHDEW8aHsU38ZuTTdLewtr2lMNJ9ga73fbu7GXfuFP6d8lYGeO5bvQLlt4UsWku/uBJvEMBTi/XU+024HFbQ247QJhPW5uyrwrBeqE22XSgrxN2D1dwY6Ptg75jyApB1c8REiIP+1zGmAq21uoUrvUr7q4LY08T/oW/Hc3wjwl3NBcP7tt4x9gcFzqvy/N/yMeXD7Giz3tB3SxRr9nmBpxpd+8vL0RM8esf1paE3+M1CrziMwleLqEepPA35F6gdEGP4tDWAWQ36RZR7Ued+/mEL2pnGk60WtBk+DjMZ27PaeUwOnaH74ckgxRK5IPs3UEe3cKAXpZrUWhtt7X96JR/cwXIr1bSVeBZ0fZ/v3rHUphrj2CuplUehlQlAe8e8EpYOimNgLLuFf/eGVURxw+xe4Q89w8rH2HcK9V1jylUeR95OGPM42d5gbRHu60S6m0X/UdU09o/pRz34fXSYaz8fyIbDv8rylkuyff3uoT01T6biekA6i/OOTFVI6R+jlF8QVI4z4HonC+1p7EWqehl6ybI+iroHMPOuRLrLKXSQzwBvfQ/29TT1TRhCKUcKD6KUg2E8MVPAwfh3N/FT+sZfsl55ceXvGyXMIp3wPRI92i2DAcMP9w4uH2mXboPAczeD5bPVGA6VvaRjOAywyogjKVaDvSxgcTBg8UQ3lt4pGLtGylhM74qSzw9Bi1kJj7P9ejK0B8+CoDUKUCY9CVIiny6R4oPNJfIJE4zjd8TdrgTuqtDdVeeS9rpAc4L5GoL7dIs/grXUYE5tT4RWVfUkclpoywc9UdSu67EutMWJhFBBN556iSyPhbcNMAaPbogtn8apPLdW74Rx2CufJWzij4NWdRqkk6tvfzmjbcXGRC4U8FTZEwm0NcT2qrAVehBqQcvZCPdzYiU9QYTh97qBN9ikE0XzIL4U31VI4Te7G/khFdLumgniC0V3X3hbN+5TFZBgUz29x2KbOa8gEaRiHvUemWEOc4cxzXQnawxI6MPmBMJa7IAb1E9KgPqNBDWbOOAb4yB/C1tALBa8qaGEj4K0aFs9b7CU8DEWxt0Iax/DOsTCZ9CHWLaMT4DRSRRDATMl/BDgOjXdseWIw4geLYxwLODubFdseTikTO+czIWXR9ovCHu7EJPFeBav/eWXYsvRCmun4O0ZHh0WlQza9dbe4Yaw6Ekc2t0s6XbyMdI67d7ndF2t8ixbLq2zi+Vns/x89AXp/Z+luKf5hQt0/V36xJewcoy1q8tfF4Z0aCtiy0Nh/mR2hAItP9SjgrG52o03n/w3q/kwyWreXkK9iw+hsRLqJXko3evC0+WvCk934Uh+TAazQ9yWjmOyFp5xJ3mTFmhe1V735E6htDu0PBkobUe3j7JmdElUVdGBFLVTONHhb8XlFXp6lhdcAT38zsYmfhxr5e0w3u+IuD7BU216TlHeK3zVnRzvvxrJaL+5Edcjkzg1rEi8wuJuXI04xUPJyiTmTgus/m8/j1AvCBc6cWyKhVQ897gQZAmM6DB2N6+wRLgf9k6DuTfEJZ0nQztXpOI53SqPCz0xsKr22Wi7S2dohDvei57A3uKRt53uLQEZt5fmWeSXZ7gXOIINsYS0onO39fp2k6F8F+DZUtkXH4fYrMawzt3YG44nEWHmtHZFgoRq7oqMZqLG2CcKe0SQDRbsi4loodZI+Okpre4UFB0S3Q3tQO2xmbTArACKP4vnvp6l+87bq/HMl6RLltNZYiTbLtfzw6luewvSVpOcs/XUh8Ea82U6g0bCjIm4LNtDny3hddV/cfjmxAPd6Ae2kU+U+1vWizgByrpcSf4H4sc7pTn7P9CnF3oLoEWJhLHdgpkYa8+DVRS2bA1ABciWW3ROrmHHk8SzFSSRrac3Q42Avo1ifa0o4Yed9bXiVcHYWUbHbyS95W49YUwoB9aTwyaga2pxNLtxCtkK7fik9wwpNAFE6sewnvpkHCXfdz7ajLtfJXwcvTtIShshp8XTu4NwVY97X/V8gllz00dVXxQiVYVTqrID5iOBqoJ7JKqKhFaNYS/wCluEO7x3Okip513H5Lk2oeGuHEpowBsS8EtxMqw2I9x5A1oZ59fKYXKLYunNApIX2uF+rRxNpflRl++bfVzDVBiR/ron+9WNeI2nPf/vdev8sDLK7HCtB4k2FfqBLY5wa/1qG0HxgrXcj89YGZ+/rG093Rs6TFuR97OEz5nC0A+f4RthvhvYoJsqT84fjdwk4Kalgqs3lkrQNZ1W0U73A+Bf/wBIzBB6MrxvD5EvZh18kRk5xf5KtCVQcRHuv/e0EZX/WVcbjJo5404VcJfLsELcSmVGv+x6byN+wUX9DeeZz7Yh+Krva7kvJeNO5Ear+Pbir+8UBjr5Imh3MeBlTA+up1TUui/Dcl760g7pQ3o2AHfEk7SVpJlCQ94Odf6W7lu0p/4JJMIagLxBsVvdplFn3PlPITOBcd8utIobpmKfN0z9KKdyXoA+Rgj1ot3jT0/vrqLvkgb/YBX/lparZp3lOUdojt5eTMHd5mJ4gv705CROA7O1uiOKC7D3Ck958csqnmr7oxhSPtz+mnCjd3j5XO41wdM7iQsEnnehA2Fcf5oxZrhvFeJ9JYro9aD9XF9Uz6stgVDmVSGrYzjl7Pshb7JhMvfzIqnOR+Q6q+U6/9mLtsZXhOPeBdw8yHFBGEJzFAvPdw0vXwI1/LnTZ62yS7ZNcMK4+CyIItzO7kISjPowK9kvVhceAy6JYdTKzlDbgwh3YDeOfEC5ngOpxfYKVR0oXTNAuv7QidJ1FpWu5SJKV8U+lK+a8v8v0jXEfhr+S4WVPSDhFk/msC+lgrVnOKXSUR0+ycRRyZRP98kSZbkU3JHMuV1M7M83kXaGuwMCZ94N/0jCy3lhs1fCy81OCS//6evBBtoDPTcLejDXrwf/L9v/orMFrf8ZQ9I1tJRGmkXavaLWNgANLpesQk5TOsf7VpIpXj/pKuHVrAo09qHsIy48jTqZS+Swz7oeiQL+JvrPzHF9e5FP0H3PLzs9Lttbox+ODBymQbvjLHhKuv42WN2q7CHcZiHbi+fPVbsD219cyhgU9sDdQbvVu4uFpZ2KchXoLPtF1T5DXuC+5XlB+w7mqff9lBdcmXxSOk2u4oorVZ6afFwpdi/+i5DflVLA7E4qUOzGU2Jrp+COZ656SINTZCan5DlF1eSkPCv/KrU40hjU8u5kj9Ds1V6LUE9vYAwpeeropDxM1xjwzWEvnqr+nmcse+C3gbgseKp6GlllCbD/RZjYBesIkFJKC2NIxpGP/R095RWNIx+blYV7z3hPr918Cp6YhvvOuPraCuOnMWu5Gy4YjUCUxnqHUyykrSymrTzCHnU5+XPmgKM4+5z8eXMdf86i/KdVPJxWJ34aOBXWioB3/rylTvx8eDGkKvS+U/E+HxOlYkcR2v+M45AnfdrGhDLuysJScfJiPD9wFEIHXi8VSeoj2Y+ed4jNKk3VROG8OP9WcNhEoUE8UKXg5ruZEDylgWdHQtoUIeWtIWw11KNoC1OorswSw27PAm2zzVUHpa9VIdaJ9ZB4OxXLMXomyiqSmN9TnAT/gN9CAlqV4V+1BCi+EpnaJNDTpJMa2dxmtyKwGNqVXYU9SMlJnafUAx3NiRH2fK7yHF3ZAJT799YAzapWZTBIDQUTNS9bU5ORPff8dC6Z07s/7rTyQZYmkCpqEsbifiR+8R4JYb3b1PV1C7NKnsOrKj3mgllt3unzs63if2Ks0FZNDZf9YA3HzefSP4P2DlOk7O5qa1d0DU258rHc5qGnWgJWnaJfLviYYihjyww9h+WXDShRLPKpshX+Fob2Dc9OfS3TP9oBT2gRs6TvXr6xQcnkJnny+LwGo5JKx2ebPD69MD6TYXxEOj4B8vgEinWQUlvF6IvFXsB5t8oKOSWdGHEtpoaB3ohngycIG7oSZFx7+3CdSnGt2v5ATjLFtZgVIzSdUHk++K+4zpBx3d1h5TWAa8Ov4PpYJ+LaKnoBs92pPlwjXnsXIZY87YEyXkUfXrdt4hnbKdDCrWIP4LZbxq2X4rb3Ptz2pEr8RSxiaF8Qt0OCBuL21+l+K2AzheK1SMbrPRmvbsDrBOFJL+J1gvA7bx2kSHi9B3i9C3i954dXtx9ev+v04VXow2uKTMPjcyb04TUF8Pr+f8VruozXxwGvLOBV/yt41ch4FQCvd1MRn/cG4NPtw6dColMP4PKujEuB4vLefbj0yHQq4VKguHT50Sn6DXGIDoqbM71O8ZKKia0THYswXgvxa6o68RKNfQaxZvr2Go1XQdwNb5tprAJiIn3rpvF3Ic4EAu3S2D6IaQLxLbMY47t78URsnaihsR0QG0XfhtF4McT18HYUjf0FYgn0rZ7G/9hbJyYsnnZSc9zfZqv2Yw31gTII9JHZvYF4oq4thHlNeLj36OqDS1tX/7QUT8nquTr4n0a/MwVxTMGOylAO63ykV906h2EUE4Tf9H7KBXKFVSpuVJt3WsgFPXdeeKtH1RbGzBBS4BkJzwd6klP/40rLY2JKPvnHumOFyfGf/Gkl3XON+SGlIBnopgC0AVXqBOGjjgIo/ydYj88QhvWo4X9ID+7/gh7WrSrHWl8TeFqruvw1obmnsYU11MFvPNfgUujd60LwfObGBK7TNbDF7T2+Ft/twRbnyS3WQItnCD92Y+/PCw9CS+/Qlv7PgJbqoaUxSOF2qaW50NIZwqluJWgpUXIbD/RgLUpo2d+6QSIv1ewzLOtv4Q8DWkjtyufhvBzHlVTC3EwZUYaz80RVqTgl7eBnMBuHlIqD07Znhp9nPO/keYU9XmnkisUpgXOrHs55GGZSjFDaMch3wmmbyvNhwSVpPmlhPoVI82kpzKcl2a3nscWraYvPdOPcGud+12vltTC3JvzK3MoVk0ya3fUtrKJ1tXo3UogSdNhJ3YlcAfTV2HOGzrzQNDzVif4SBg/wl6BBfwnUdmE1wHoNRlJZHkRpLBSwcwewk0Kx8w09sTkorRjqOZoZcg7rfATru89rwqDF2+lZ99C0La6p9/E295xS0BkcfFDfWX7JXreUV/0iJeQXKdpfpAT/IkX9ixTW3H9uR0oJHJDSDSuacdxIUppe9vH8Ww0ahoTlatoUmmc6t4qF4jsbLZUnyH+oFfJod2LvSVhHOoGrhJGw9KTZ+z7+uQB42B20+czKTqjJ4orFA5OQind2a1q3MrXMBOH17kBua5WmzZu+kWPhX9cWEBrsmAsjvKErGLA8Q3gRngnBbhdyJ1w57S9E3v198SHRqZrvTgi2it+nMtAi5ODDgIM7FuGOSnAXs1hpHy/c8iK1LOhSwhyc37WaWp26ejK4nyhfv5hqFd8ZovK8C1TZ1hPIMQnPOZAnQepGbOcMaOdc2s6HuuuQVyU840DoYzcfEiMD57tHBaN/DR90lB+j0kZJ0JPHC+97MzhC4YxLYwx1on1SnXgGft9NYqJQX6kTK4fUicfg9yn8PodfLfzqhjDRX1GN5uW1jKGW7vrZ84rFjnApXJ4nPSvk51H5+b78/EB+fiQ/P1wRVVwHoQSOxTm7JTAnEOabQbjkRR2+q5uJbQPZ8JpMi3heT5X8slBJecDLwvvwHAajUEVP9NG5Ttfke3CmL2wUtxZKkpiZsNRRKqbtQeuMp8/BnH+nVAxKW5j9FEhgJhBxuaeLbc2hnOvNriJuA2iTydEBXcpKRUpFq1LBJCp2MbtVV7zCF97GFmYy6pzM8RNQWyLFeNB7h0QVYDyZtUK9gPFgxPhIwDiTlhzNdjEzmCgNjHd7b7D9ZeGJHi38P9YzCEZ9UacG1lxOIUycy12jo6FOK+e2uRXBz3Ruu1MspqU9UlWUU0Rx8ph3eN8aBzC4+geJBwFNH/oS+JBWsopxAg+6BPP0U1gnNPEvUR9aalJ6VqTxF8wF5IjlGCmge6aF7TWFlaTA5vtushet1MTuyoArT2UzV8Z8Zu14O5YxfnVFY2d2e4UMr8TP0nusfLDlkjhK38TnUZ62QOPjaoEfDGrToN8Sowhzcz3MaPSKOs59swfq1peIen19y1BFAlD9xY5LvJJ+PaiHeX0J+IgUDoJwoDmRw9jjHPrsLBLe6nqCGwR88d1OZt9T2QuvPM69LHzYfUn++oDfUy7BTworzbZmJbMZfuh/p0j4Z0cZvRMF7/kOs+Ge2rdAv/XAk8roFxTWbAWcW0XVYnyHflGRzwb58UXks0yftxtN+QVhutcqBgIvVQEvHX0Oy38yoEyxGLg43tXfw2C/HrLm45TLqtNGuPbyAewl6rmMQT91Ntx50Lnf7C4kGlgjzzL79uzer1HEMrFGmAsr5LmA37BOTgVqk/jzfJ/uWVIp0Txqnk8B1U8CvfO35ySt8yZonU8CzV+jmlVEZ3DrPMo/xnRu4tZWFXGwBk4pb1UGMEbF7qArS2CUVB3atlFaxb52oPhrh3D1FU8p/iZopzeAw43SbuSsUC/QPOvjcdcW1YvjS7XA44Ls9S3Bb80Q/i2iD6TXhFMdKIse575uURkkHufq010nLf5N1dScaZTSf+jpk7ZA6RWovSr+3sqA9qpA7TWKMTwClJ4JlB4Ec+hjUaJL0mXlA4HGE34hZ8e5D3fDemAZrAdSUJcd9ZYSWsYaXhfsvSAvgbL+2GGFtqBfCBz9m6n3S9lrqZKU/SYoqByl7B86JJmKnh9+Ti2GUpJMdaWiTL0Z408HPy/aS0cbancdum8tJo3Zm8iriqLL+kdtOYxaclrAbibpDzKv+jF1YfbvYdwu0XGb2eHjVbM6irjSqo0cE62YXNEaAHwqcBd7ZS7MjnGyfIoRg9uSgwNtBMbv0rETfeP346FD4lWVxLF+TPVxLBy9S6kJMscKAY71VjcLvErsHGRPF3q9LPCqC0J6z1xZQjWl1ouawoB9RX38Khn41aqcVXQU73X3nwpfXnBZHeg8WKCYcaGN0cxtVWpAVvRxMORekhYl2fVdP494aHIk/SUg6eoP2IJ/0Bac9CIljHN3wIpbDSM9/1dGuqrr2/4VtwFG3QSjPuMpqHcBrLQXcE9xgW0JCjWM/zAc/x51OXKWP4p7xNTkYrErpQHmaZJpPz/dPHQ38rCjq8N2o8VQ6+ohuw0FyB+YPRfEHWGTuRmgj26dwxiYhBxHcwHuHI11T+6NPYhwx7rf7K2H9ZC9YKw7oVcvp5X0qitm3Q7TlvEBEUHlKs/GvMFuQQzax+5W79PutgI+reJVSoE/xtzPfy6l+vgPC/znT91WsRHo7irQ3eBzWO6pAWWKxcZFM13s7guU9ppSp7vmfvS5rf2i+eGlfjSI/iD6bWE7wvfJvCPxM0XBtoKtc3CMO1JAwtP1Y6UOxgmwn965n//WAj8z2g3gN+f+c+S5G/fzdQPOMD95S63EWad17Oe/MDt5k+zJ7nPZk53JHAZj+3+94fD/Xe/4t5r4f1jQsuNyN1p1lAhHvBPewvh5iIdDfD/I4ARox70OH/zGFqMCvx6Nc9/uqG8ZhdrJ+ovQYnz/eGRWG6NA6wZV+/vZSVxYxWmgoShOaVe113El/EhLD+gZSvsbPGPbz79lKRbG96D/tUSunCSwQXY8t1YkLBFDoHV/kW0cwmTfhmoqLxr5IXJcQ/1ko9UIxkPKg+34lb5ImC4Glyuh5ZneMOCDJcLDXpXnrZVK+x6AWSzc7UZ4QXaEt5meUHtzZSJXJIylMLNkmOEDYA4bAHP4fTA3CV6vBFPjDacwVV5V+3fZPpjVFGZYOcLUcwjVAOvWUli3wnougXEv2Wil+qeTUuP3A6jRAdS4Gaixlgkr9wqviVaxAajRCdT49DksxyQtOXd/qWKxYZHkAwZkDHDNhmGSZzZHKvrtQa89Ks+ltV6hQESfaTh7ZT9p26zigXXVrRpG3eadPP/W9RfWtAbD2L/WsbygDjjGvqDVDVZxKsi4lQAxLu1EZv55XKdrqsYLR3unKcYLH/UWcnbgkfPdDMuClDrSyiqZpBDKJXcAdwwLvkPPzh+l3r0uph4FTqnfjPxnEuWUcX88JMYEqjms3adL64FP6hcHtjLDQ4CPDF7/srBKDAEsbxKssFoebMgACRdg+JnamaCvNfbiwQfrv3v0YfjNRL+M+I0X51Z8WhqVfjysNqeC/Hs85wnKOX/XGdGn6Vn5ShuOvlVsXuDkqyzTSbwNR78Y0jeALqdIw9LNC+rgncozeQOsTFc1toxSjGhlgue0KlhYQdpgxTDJyp+w4C3XsEZKR38v0yS9MP1TksEinyuG9+gvcJTb6u0GrQOtVcpEVXJg0rSaQENZ5vEL3xKN2Qg6wlzuCa6OrzSfgZkHUGHWnRYBisIK/bGKMXSdGjdgnapfqfIkr0d/OiirNwlMz0XAEHrCsYqxoEnFyJpUPNWk4u7TpGIX48g0T4YVyGQm+s95jAGgGXDNcnuyifK3+DTeBfSkXA760SaZvwFf+80Ent2Op/7ZvzTx39gGcQHGL5/eUQPSMnrZHUbx5aI9YpreIY4aYsn88un35fRZkO7g55j3wCw69bTfScgoWOPf2RRwCt5mmffQlbD/u/MfL73zFX0727yHrmYHvlUNxbfZ8FbzK2+z4e0m9CBrsBcwuxUgS0K63pDlxrquWbcjtM0gSwK6VJ4t+aVy+soutOYKz5p1O1ILXBr4XkkB4z6ysZI8qnOTZ3WV5BHWTdawigrcHRjk/rIH8wNnPIpeB9Hj4Fj3Qu9+vpBt4v8Kv1dkS7BCdrTbILYTFTwfEn21PcUt4PDrOdoOJHO+uge5J8J6YK6lDHjIx0RlSyDBQEcw1cjcCjcxAT31et1kLtQ0Cq1sqvGOOEzHPKPcbvkdS+0L0KcQeseZBuuTBKI228l2cxE92b0DfYxTb7zNpNCMVvOwNkljkmrbZ2+MB535CFFDLV29Tn6uGUfcpzdff/pReeReHXp9Ecr2vfQ737xcpPlYso2e4cIvyKcJi7ef9XkN0TiPkZs0tKgG/Wygt5Ez9EvVDnqCvID6d3z9yWaQYUOn4JkKqUUIvbbdW4i2SXeJK/f609THmtyK09AKaKNtD8+yq8k2WxVZDVjKAUysAUyshudmL8bRXmMPr4X4M3L6n0BmlAB2FGYJMxWAGbxHt4Se+PdhBnHxFcQlfLxA8fHCBh82HqXnfoH2lcHXfPoA6gA+e7gX1gJmoG0hLNrh4ve4RGhjMj1tPQ/aMBrags8UrwRX8tBsJ4UWPLlVSc7gl2tq3/7CBh+sWUrIu+CFtWGTz0vevZRIf4pzp+AfcfXT0z+opzn3q5UNTlEz5F/qyc7fy+Ft6vHOcXL4MXWcszFICger9c79cvhfQTrn7+XwtqBhzggpPOmZoMHOWe0pUPuPcg2DggKdb6kD6dsrgYoGhA8tMsBMCIKZoB6ZwxhOZGpqPs5MpWdfA4ADs8iBS2bdHqL1UTtqFTiTjnUhLSENIf0gXTxxE3tz/enngNK+vYlPHOsXNjwH2F4AfKnwjb2M9/apXahv4cnyLZW6IBUXVhbYUCp2GoZWPaVm2v5WmEi/Xb7TY4U0JYffwa2FKI/fKERNUtmxQJ75BR1BXHNBKDfW3SH+Rk77QwdolGsKuW0c8ALTZUibd3vI9jm3w9YsgRY/1SWdkkAvDqMdaD99geoaNfQ0vKrC50sroBxz7+3G8mW8KgJ0VS2mzKA9buInoj/OZZ9Cz8/TU3BxZulUSskTGRx+70W51plymXqnCjLMgxay3dM5RWkyhAK7G2H2o5eZwe6RnYPdR3tV7daFeOIePUd2p6DHjlurdXmSZzNF0thz4Tnh8xh9tODoxS/HSnePEs+t4ek09G6Gp5mYaNtS9D5hqMLVgrUG9YtRnJr6EAzMUdHSVb28C+n8fXnt3AxPH/2jfxifNxrZ6wzElKZHfH5p/GKQswByFmAs7HgTb2BL+YdY6WvwKLelB704oNWVlX8YZsmmHic/04yYauJH93F8tB2IuWQVH5+8nx9uCgIJLJJ80xTgOi+R06ZXyavm4yRDPjHfvyOKfotQv0PefAQ0N1xX4Z5B2Mn9uK9A/U48+hDD/DWLYV7Jks+4QYu3/hZ1+8ipb0q+AWzHSAvwx7DRWOsOlDatwUGoGWkbGcNsMTj5hbxP8k6LzIEQn/6xxcG/Dbr6cgvu5Ug8TbJEudnQxD+DFrc01tTYzGVw6cJtEU9bbCNHbMGgu/4sBn0QDHqRdOpiG90H+Z6ecdxG90G+p+cYMawFjfVw555mNbMVfoPaQjRY29eiE6D7avtCxLqc/Ft9dTl5W19dTn6fX12FtC6VZ+tCrE+VIvmXSjWV0TvKD5vQihbxKfkbmdPny2lu37oFzynYIZ8it4je/rR1oSblQl9pFZT+2c+7E5Zs4nW5vtIraWlfyZAU6bbjAOrbCi1115Nv+kqH09Lo2bt/zeSC0niiNIXqpp+5mkDioXcn31h/95DPxzeET/rOwxdxH9yb/ZsmfiHQZQpQ4KxuredznN8V2vYbON9tSzit5yRaWlhQwniFt3u17VcX1UYzUdr220u0ni9WadvvPrnWXiL5xLCBtKyGEa2G1dHZJGFXNxNVG33AniSUQM27FmqBEyAX2M0rLWiXMN8O1FHh86FishQJp73yqetcKz3Xq/yF59Uldp/XVZ/HVcnf6vz/4m91gZ+/1cf/i7/Vhff5W0Vfq+hzFf2t+vtaXU+9Hj0B+RfBbzHU/SRQz29NRcKz3vlHl1Q8VY5n9hHX/V73X8/cW/D4UmVbiPLuuSUfhNY73g+tC60PrWsQmdo6+Dkgbb6cpvVY12HaEvsmYVqHwz5d+L23jF9ivsIvlNduvwN4DogvkuO5ED8H8cU07ijPgrXceaDm0R1ZR7We0c//juPs3cKhHg7GM3Xdo3aHcKTn0XKsX0Prn+DdK9/ALdncS/Vf7Ds5INXv88PrKJ8n198izquYX+6A+l7pcZQ/CvVdE6/AzNvHvwmlfnsZvcRrgY738XvRO/LZ0yS+AuOoeZjJkYq1ZPxZI6lg3yfvg9YxrfOK385lxp0Tm7eSQWatZwvQy8bH4fcE/BZA+d+qkodNCpvcyP/GhFzxNLTpVbKFbeQfNRWQozCX8oEfbjH9EahkNdlh/JTgWaiVpuuQtppoOwvIjluoma0mR2HcmXQj0d76iBSZHyaHc6uAGtPI4Nx4WLMg3awmIZdfIqYKtAVMJNtNCSTQbCRJl0v4VPNDwHNNJISdSn4D+sx2HZ5NSybPsmh9bCLsWbR0TCR46+OzOWvJFl05Cc5ZR77UVZGCs+vIO7r/kKLcAhKVs5okVNfzafAszzGSRGMqWZHTAnnfJwk518lXkEeV/jwJMNbzU9JfJLdz/kw2pc8gp4y34X082Zw7Gd6V8Mm50UST+wI5mJ5IEjuNUGciYW2rid1Swk/KjSFHcpeTrekl/OTc6SQBaHZq+ivkkfSXgK9MAfrGtmN/QWtGSyMjYh3rAo25gpAik7b95Rc+gOcBwFMsic/Fm+xL+Awj3vVUwqfkaj3dy6cRe+4MooW+TIN3iUY3WYY31Ru1954OJ0RpeodkmT8gWaZWUpReTpS5V0iRcT9RVuMdTCW80Qgc5YV4SJPiAVAOT+f74kqId/vFVRD/PLw/HmgEStJhfBXgVnvvQWUJP0tXzz+gK+GDaDu1nhHI09LjySYIu5eX8Gpjf3kNpLHL++PBEA/zi7MQj/SLayGu8ouHQHtW+LVnEPSn2K8/gyF+wy8eCvkP+fUnDOIqv/JDaNu092ZDP4ZK7b9XFy69S4JwgV/ecGhLm19bhkllPT3Qx1ij1Gesyw51DZfr0sh1jYfwGb+6RkB8rl+7RkL8Wb/3o6AfO/z6MRrit/3iOsj/vl/5CLkfIeElfKQM+zsZ9gQIP+qXd4zc7pHQ7rHymLUvd5NHOiFcXcJPhHgvHUOtR+vX33GQPsQvrpfrGQP1RNG0Mj5Rp/UESjLt3ot+/YmG9lvRBr6Pdkp4g7ERdLSV5J1bINXwhnLjT+TALe29Y9DWTekoD0v4mPSbpAjShoXHko23ynijDvLZymCc0ZNEPtl4uYxP0rlIIuRxhscRBcRjdehtJh7WRlBGd4MEw7tFMCYJujJ+PL6reIAcZVcRxdkyfoKumTC3gOOB/hBDUybqVpGKiuVkowUkn+7fxHgrnnyU3kaeY/8XWlLGh6bHwswCqdZ5EFpZBhR1mD6HGI+QAHgONR6iz3CjnQyCfNurD9D3jPE/RAl1WSqeJ/8L9QQbY2m6xijVw0L5D9JXkqRqqR6tXE+IUSo/yPgOjSuNcWRTJ2grWA6eKij3WqeBxKVDOYgHYjl4BmE5eKqxHDyHGd8jO6F8QqdUbjiUe7/zMA2PkMuMlMuMksvoIA/2F9NGy/AiIG2HXC7SKMEcI5cbK5cbB/WFpkvt1APc7Z2gb3VKeaNkWNFymWAow0KbdqZHE1enC3D8D5AW9bziVhGZmJ5PNgGuYoEytt+qIlnpLvLaLRcJuIVtu0GfocZrQEH/hvBEoKwSfroR4RtoOSXAxif29YNby4nl8hFaJgLbAM8YbMMtHMN3aHkllE83Is5+JpsuI85v0ucoI8C8jP0DmJebyaDL10jF5QkU3gwj9tFA86kQ3mVpLN+/fJiGIxHWZaSPA6T8MsCBcgjnQSPiYjnZdBbH7Gf61AKcHWdv0vAIhHkW6eka2XYW+nd2PIX3kBFpJo7mCUB4Z3FsAb9n28hKyxFaZjTChKcB+3cWZ8s7tDzCfdiIuAe4LNLIz/QZgv3EMxPwjjkLcPGkAvaVRTqGGQJrz2UstAGkFs5eLVvCz4S8iRBGPBqhPfhMMubTPo9H2obZNtG4gsKfYIym6dEAD+scB317n40i8bqbNB4F8C3sNRrWA7xNLEhS47tEfxbbtJKmxxqldg03SmVGyW0eBu3E5wjjWvIlrSOWuOSyOmwf7YsEN0IuO1YuO1ouGwkwB7HNNBxs/AjKSuVC5HKDAPZrrFRGI5fRGqX2skapHM5Lad69R59qGJMPO/PIq+xheb4eos9AGJMAOm/tNB4KdYeCNoNp4XLZMKRXmGMYHiyXGyqXGyKXi4E+7GQlmAbIH9W5kkTpjpCjUK6i85A8tw6Q4E7os85OymFufaj7GWAhzCPkwFnQ6thasgP7pZPm03Yd9AnCCcZ15JQOYSwFjhwLmg/ePwww4BkGz9eA570D4XG6Q/QZoTtA3w0HOBgfpIsm+uoyKvkDIC++GwvlPoD+GaE/FqOUfxTND3krEB9vUtgs5MfnEMibqDtM26aHvIEAC8ORiAcd4h/6bowierldQ3XvkWCgySCb1LYouW0jAMYgSA+wSG3T6PIBTwAT8K6BegwWoEXAC4YHW26SrfAcbblG48MszTQeYokjGgvgAmAFW2CcbIBny2GyDcLRtkP0OcZ2gL4byeKOWwLRA57xzOt31HZj0A9LuDvC053Ka1l3meVHRXvqIFgL+vwRgR64qJhXn9XeS4iB1ZhFe298DKzvLCtBr4wmWy1oFaL1RD/rgrD2XmSc9l5q7NvwHr+KYcu092Jiyoka8iQ8q733chx+RSongZBujbXScBy8M6zAMLZWe29rDJa9SOu7GpdADlgQLp4c097b8UvY94pjEDbCpPA8E59FeP1w7vrBSfSD0+wH58Ep/XBGQ/z2r8C5MQBO6gA4i9L64TzgB2duaj+ct/3gBEP80dRfwpmdej+c9AFwjvnBSfODY09FGFg/6KoUBsIFXexXYBxKlcare0o/nIwBcIZl98OZ4QdHM7u/P09z/f3RQjxk9i9hqWbf3x9uAJwX/eDM8oNT4Afncz84IRB/9lfgrBgA59EBcJx+cOb4wTnjByfyyX44gyD+3a/AqRsAZ8EAOKmL++H8xg9OwqL+8RnsNz7jF/0SRswiaXxefrIfzpIBcKx+cBb6z59FfvPHrz+hOH9+BVbxovv784eB88cPzu/8548fnAfz++GE4fz5FTg3BsBZMXD+rOyH84z//FnhN3/84AzF+bPiV+bPivvhmAbOHz84K/3nz4r+8Qn3nz+/AuPQCnn+5PfDWTtw/vyxH84a//nzot/8eam/P0Nw/rz4K/Pnxfv789LA+eMHZ53//PGD87kfnGE4f34FzooBcF4eOH/84Kz3nz99cPphjMC58ysw6u6DcV/9no1+dPaX/vo9G/3mjR49OQMMJYQjQJvaallG7Eb8lqT1FC46Qt61NMBqxsmrLfW8DqRptBHXq81ki/EcbddIWFNtNpbyDPq2rPiZxBl30bCm+gakg9aR8ybUUc+rb4GUhPThufv4jNxj5EauzzfxitxYgl4g43NiSQjocRm59fy4nM0kBNIeyIFVa24ZnwJpYyAcBOHJkM5AWAXhSdRvZxkfB88AeCbDO4XxLrmeg7XPvDfj/dN0dRyDkhaeqfjMwV48Rw7lLAO9EyTtKhc5ZKSS1mNYeRHeA/ZBtz2UgxL6OonNAUm7Spa0xuvEAPFEpHgIq3Nk6Y36cw5KTix7kdZ3Ne57WAEvI0U5KA3roV6EDVyGtiWfxOQ8R94FnflIDkpoF3k35yJNfxfaNHEVwDXK8CD+gA+eUZbYCM+IEtRK+3U35iKURx0J644m8UasGyUyjKCxv97UVf8m7xlhRGGtexDiaSudNLzFiBIawzdAv0KJCfV2YvuBi6S+Set6ewrWHUdCO7HuB0h8J0piqL+zv/70AfXP8Kv/0dT++g+lrgC8QL2d0rgco++kcXlHR8cFpK8LdDioW/cGffeODiQq1B+rQykLuNFB+2CdYoD0WStRclopLLVOltAAS6FDaWml/Rg2+yLUFwdpCAvXI8/RXS3N7CPwvNgHg1t1jbyngz7A+uIgxOdgHyC8RYfSGMM3QA9F6YizEdsAHGP2m7Suz/FeXmwvi7MR66czCSQvwKDS8KLUbosE61EKC6VSP7zf+MF71g9e3exoWNMBHOQIEHfSd6jfPkcOsEvJER1KXhforRdp+gEWJCnUH8vuofUZIL4Q6QjCalaWxFA3tj+G3oIC8wM4wwFdHEEP/uiRPZ7FulHSwhqC7a93yapm8h6L/hibyUGI/w7bDOEtLEpfDN8gCSxKQuQ631Mt17roTVrX1SedFD/BNqw7kcTbUMJC/bb++v8woP5n/Orf4Vf/DQzL9d/F+m0oObF+GIOKfJJIYawmR2woXV30/dv5COd7+h5hraCwUPL0w1vpB++2H7zZKySNfRFItgO2fJKAY8EiJ5bwNBek2AFLfz9Mq25J+K+4RfG/BvEPYcQ/lbQVNwjLovSz0l20Y1gvcHK2Aus1kvgKqV77CsBPRX+9a6Feih+oC9u7DtsLYWzv+9hGqNfIoqSDequB9l8E3FTEEW011ptE4qulejUvQr3VPnxc4TNuNfIPAQ9+8LIE5yUKB6VqP6z1frBCXuyHtQLD1d9Lu4EIrxqlpDwWZ/NJEoW5hhypRknqkuEinAeIsvP+/vzFD8azfjDqaBho/0XAU3U+MVI8mcgRGU9nsN6Kq3K9wHuNtyX8n70N+LfSJ6V9xMvZGySEjSJKHdRV4YAyZfzDZ+OI3nSO0me8idbp2fg44MgE0vAJh1QvvFfDHHrPdB4kXSM/k/2ZHMS7iXN/JltMCoOOK+WV5htEbXqL+xto2UrLm+Swycbt5fDLyl3iuuXz0b/q1v+SD2/hSeL/JUfgOcvcyM+4XManQ3haehk/NaeRnwIQ0kxlfLx5KSnS6YkSZozStpoU2QpIkcVIlBVJRFm9hhRVm0hRxWnyYefb3FhuHDeGi+RGcXFEmd7IT79VxqeamKQ/ORr5MeYS/nmQpmsB1jhzPb+O3gddz79gxu+w9fyL1JNRPf9HM3o+redfMjdSO8cD1F9UPf8u9W5Uzx8yowVbPX+Yeqio5+3Ux0M9X0E9cdTz78MzEp4fUn8Q9Xwltfuv5z+mdv71/DF4oh+qv5sbqW+mT6lXo3q+mnozquc/N6N3mnr+C2rjWc/XUlvOev4Utb+s5+uorWc9/w21v6znz1CfHfX8WXjq4fkdtcOs5/9lHlXVyOOtwVvNIVUl/DaTIioYnhbzoKp6frspFP535EppJTmDIfZa+ud4stlRz79z61MaKuEP3qqW0967/IWcduTyZ3Ja+VkWSh89i7XU8x+wiqjRVXhevJ7/yCylVeVIED4xSs/jnVL6P+T4ZzrpecIipZ+U4zWs9PzSJqV/JT+/tkjppyu08P9ttRHS/lldz9dXlPD/B5Qz1nyiw57qu4EA6c1ZY7hbuDwLfkCBnQ01uCuBP7xXDt9j/oeFIx8Z5B0LZsJf7x766IP2t7MOtmqVaz8c5NH/SbF7ScUQjjEEt37FKFKYglmiSjsqSTgHc970Bq8wfQ862Bugj33Pq0CHCsz5ng9KZwx58dr2q2vbbyvM2vaXNzjK48lhXTx5lY0n71lWkc0QPmRcRYqN8eSgWd2lHDKbO3Zbke7kH0CPwyxaUxVnXiN687+J0mzl56T/mxTB85n06zS+Hp4Y35nugvi/AUrTOUXKqKRvzu0TS9Oeu3M6fDs894mvpwH059ECaDuEmXiFgdm1ItpRHtClHrqX+nDtx9WIhmc6t3Qu5BZwzFtLuA7hr97+sMXLTMikdWe5C5VYN2NQTB31gKZtheb7c2s+0XpeXRA5WfHWobY8ZdRstDWoui3dv44+GN/O9JzLS303k5xbwrULCzu1rZuVSnpXSiC7pHwJ1ymM9GrlG+W08m1xaMvERCeJSn3elOA2VTCOzMUPFbHTXNirLLeC9uiEi6lxHy8V78agX2R6453k9X/VhZaA7EkRq1oDA8Y95rshQH+B8exesAtmsoOf0dfv4Y2Mp3Yp+tg9J9sTMZ5dC04BX3DIPo0h/ngt+mjXu0+WUhu7IVfw3hMHn0L9iaKvFznfQsxbBGUxP6O/Ce2bOUjJoMcG1XZG8q5sLgXofXfMcM8B/F1PQn3LgYpsaBlRyu+wNPFp7J9IgQXrdJEzFpVn1+KQKWFpX/GBkJZMbaZGuF/vsvJpZvS9nABroATQvo6AVN4Amgx6bJhG9JDnlS70S13EB6FNH3r5B4kwGdJf6FpNCs3oxR1tevBWEvQNhx74fF/O0ZpKf+kMSTQ38UNYO3FRS7xXQfdA2+0R7gVQs30Z2m6jZR36jv6KWuGWpz53Z5YS7XeKIbz2JKagZ3CPfKcPM3dWe0G0kit8urlqVvuG6L1Pn4GnLdr2dPVneGuDEu8phJqQHiQ/xEXcDk5NfX1Lp1yl2yFONjNbJd/aH91hCmc+8qh0lQyMgO/erl19d3ntkm/jwjN6yXPRYorxnEAsWpBiGM/7y/GuCIQIo7RYxZ1oDWCeBciRbmWn7J2QRc6C/prRuraJD2GPgKY4ws13bgbJiPeeoU2Uz+MO9MsgWSBeX3SyOXkrU4P3nzExd+fieWzofyy2wSt86l3++5TP0OZuX2/eYqxh2kkryCUn8HErP8ykar+NdjO56F8nngSZ0CZAulNq18KwFLRlwdjPIJdvkiAz+jHHMw0e2YLrIed+kAu/vD/XKn4y5SvEueGnpw9S6B/2WvlUC3rhGuF+sgfHEm/cluJDO6S4CvTjFHobNno5p7dhA6Wj7WpI6jFyk8KYXYN3AKLX2L2uJpCxp11MRiSHw9IEkg1WzGzYcdSwVdxw97+8Vurfr//WHrR5Pc1KnBuo1YztRS83eMfbK987HgIdg9W6/3qiFKh57Rzp7roMc/99P2vnlAJPWTtH8pAiWQYx7KuVyfQuoOGgI4S4qzoboBxwbrRAwn0DFi2HQtzvdY5wl4noszHEvb9TgX7ILK8IpFPP+e7xfEVwdcI4g16ioPpDPL3/+7BZz6GXU/R2GyT7IFn7P6dyptE5r+LQu8UgTus2UK9xxdCDYmg9+gHUukd3oec1rXt4VwLUoWIlmEu8bmrDp2XPwAxlDIbnGcPypcmEsSEMxCPgi+65D3fiTSC+GLXSk8fwxe4Css1SQAotMBYWnIvTTuLb/7iuhH5bA7+Z56CuUl7BllJvx/HsOeqxNR6whxSK+NNwg7hXhCFePSe1q6BzD/Umib6C66hPYgWNYZ+xZZIHgQl8EPT6QOXjBePLmviLNjzPs5WLcAtd9S0qRXJBhLu9C08mbYAQDyFGMQ1CzV1lvGqGfDYpqYxnIrTuU52IlSD2FeH/eo+Rlj4vlU48zQj0sdqC3qVTOISdyUVxartXCPCq7a8I/+htAp3KNxeDG1K4dHiPN5O390bsU++O3KfZjfkO9uJ5FuR7M7hM6htKOs+ilv1kasxe4YdeTGukZ17U1L8ynufEWRZiR4/FrwiFveryELt0w84i7wxuMoVVSe3bqnsjyocA3MVe1OQAmg39CiaSVTbULNXlgHEbvp+GY86iB8gR7peozZrv7hb0kLK+UdZqLH20brEA5pv4jX1ybGVDSPkIqEnvjYCe7epAzRBGCL/XUCtp9N8aYT8CJV8Riuhb6TRoBNVpI8oxlsChX0mvQP31ybP/AWj5CEqZ+OXHZ6U7wm3wNvHLzUjPPvpj2j4pbOKf+VV6HN9VQD35sNQ7NdA63cljDGcAj4bnUQLhnWB6mD9B26V74B6DeXhFdJNv+yy5khuwZ7EdqANjz/bI9t+IWV/PRtC3/T0bOqBnxX49O9ULeWnPsFdl/FD2dRfyBhglue5Vlr5RsuDZ+JV+pZF2BtF1AtCGTBcaShdWOktHm9DW1TdeaL+fYdkCa7sm0Nx9/G4kzN/hfTHJo9cIdyS0S03v15lGGMA6ytpne5NJMJvtwhw8/lsWyHaYaDu/UZVW45vXeK8mxGdKc1GzfT9fDJqMGua6xvJGpYqbWxBTVsqhBd1YLhRndkWEO7ET5ybOw5hOnJuXRBUT4R7bibPzkshAeFTnL+dnu+ibn97uJv7Z+zzJ0pUenak4R7PoHE2X52hyTwiM4ywRZ+D1bn8fxNOIpjrjzruFajpnTvQM2Reye+i+QbsB07Y91JO0gmI7nswzh5QfBp0Lb7aaY/MKe3va6MhIHlVHuJ09Tfy8Psyi5mMGXHN+uIb22SrJasj7Y4c/bSJdqu1IlwlECxymEKhqZ7eahJnWkpxckZzOqQAdPoZsQ3/lucdl2sQ7jPbzD+QGNdwlX/fdp5yN9+CZjFRu44mcb/rv9zOdhlToFwv9YV+Cnqwih3CdTGeOooGZGHTVF9M3MhPHXvaQWrp7PLqRMSBPNzxfx6ts/fPxqR6ciyMq0VM6ziA14E6zL8+F/bS4FFgGZhrMvNwbKAMy5HsCU/vpBnUzcb4ktUZy+6hvJgtXJk7LKxMffBzlmJvMApwttYwRrnc6WwIM27jRXHhWIRfGzXH47nSPcJsA95n0ZCz6TP0HXf9L2m7qVcZwgq4fg6qWV9Xx44AD/PET9DtfDKu35avwLFXiJGhrS8C2Yj7eViwalwZ+0kZWg+Qba8P8OLrD3U/0KhICfrCKCZMunMBzWHuTraJxkvYzLC17SdqpMDTx0aB/HFx13uXkNSYrPw5+Y8zTyDe5+eRw7kqyGZ7v5eBNAW6iydlDDoF0xvdqkL1jQRZupa1ikk6dyyeHTIfJZkjbYiqGek64LvNBpov0jl2Wzvn91Bo8Tj5ZqpZPlsaZP6Zn8PD8HdscOQtt5FNSXpjpoBJWtV32fgW/WYDTaYBTlSGIK9SFcqj1Rri/7t7Pz+3zji3Rr0QTLzsliYA+FWb12+gDFY+GVo+34axLJAmAswRo1yhIM9I0pPg6PtE83P1RjyJBSXFIT0tCOafso9J3d2MdH2/GFoVnOfl4U4ADcZzyWT7UgjgvTK7jo6BMFMyaYNTSTG8Qu6kJsBNH1Ka7sj4IOqs5qME3Sy7V7AcYTl4P+UbmuojGVNeiWmUFPNVB2mESa8Z7TpphruAoVoKEu/92coToOLkf1kAWF7TO9hHwQMQvnq1AHOfncxlIxxtVx2eGyfoX8gSk3eHuKdDj/fzDNvYHJ58snyX4VvbmUswnU0k13G3owbdWnjU5+bm5ioSiGjypiD4sUdbUwQp9K+R+AGjkAbrygpLmfBJrQj3YpwVPaJS04AfoDetIh7CyN+FsqOMn0bsVnPwIUx0/Gfp7mt4Og7pkHeQ9DTVZQSY0A6X5zn/V8ammoQ3F8I9YCTvpBA64khw2VZH83GMytznbsB5gfw2ULnnMBt4h31INpc3XZVmBd56XirGTIj6DlZUYM2ntHLxd3QH0gONdCtj1aRMhDfv5wfBmmvwmov/N5VJ+HLyZ3JdyqaEU6mKSnA6F4YILYSCN7wd5i7lK+Yl0VgAGc2v5ByFtAl0tryLvwSr5IYinUhi1/MMQjsJ3JtyHhLlpKuRnmmr5WSaAaHLwYyllxUHeQj4D3mVC3XHUL3Mtn2WGVV4NzjFJ7qEviriNxSDvcDcr4By2MKIKfa7WifZkVZs9UNV2KEjVdkCdzk3i0Gv4hW4rPwXGZSqMWZRFWYD5kHsjBeNdbKDpmqS8W6iXcwW9ufiq8I9uB10JjYTxm0DXh4oK7E9AudKO3kCuCoe7sbZPk1U+bwQbfbK5lPb/QTrrSvkMumNSCvNZes6Efs2G9w+bN1VijoAP8/HEHce0XQoYBP9XFcmUuq8Kf4S2Z0JO/KaZBfT2vMkK/Z0GteCZG6RMJ59N1yogp00uSmvZ5hTgwBG2gD6JsQdWIChh9/MrbJI/kHkV6A9khHtn5zHguzjWVj7czLQdLDwGfMTHdVaz36JnY07VdkOtarumyeSmc4BHoOPptvWgA7lg3jgBt7DmMR/v8yeyBcZ4C4mDWTbNcqxmOpkLnBfvAblpPkw58GBKFVZo57fkSIWTn21z8mEwa1eb8OYzmKuQrwJ9LqRni8/OxBFs73LyOmh9mllZ8FM+zG/gQqfpLICZXD2i0crHmDeQb+lteaA1AL9xmSZzqzlJjyiRb6a+KvyrC8s7QY+08hHVVjF+UjEfU72aHLVtIBYLfldxwoyeTh6xtUALNpB/WqaTHFs9/TKsAI4bbT4KmI22UPlUhXmnku3VxVAXYgZbWkYhzHKhNMtzmYCqVG1bmavC611IKVuT/+2C3BaXC89rS+e2pfM2QNNRSMlDT7wAa+DZMJoj+mZhbKODzogsSk0+D+e6/zqP2ctr56R8hqeFfXlVDYyBuaYAzhAHnIFh5mbhXA6ja+lS4BO+c2G4pmVMw2Ctnt8nefLNQHFDEFfQ6yjFZ1lVeHZwX+F+fplZdW0/n2cmLsYoOJz8zFwnULSVfzDXCrMY5AeM9aAcJ5+WjufPVtKzMochz0PmVdTD/sqcn4Ferfys3J9BLlj59NybCI3PBP7JgZzNh7JZwFO35ICsBLqek1NAimHkv07PBx5qpasBlENbzE82ppHlubEkLnczUZmOy76yl4BMmg689pu+25w5qN1gwjPFduA3N0AqYVoxTQuF+KvmiCorPwNgxplVbc0BqrbbCryTS9XmZLbQO07SgIqOAtUNxR0PKjecfCykR5rPkIT7JEWCLCki6Sra8FydaE0OO4l+6Ve7EMZd8k065jveMIUsB94XZ3qVqFDrzPXJU7ZPBuA6I9t8wAVyoa8/F6hc+JfPtzvwRxxPXKE7+Lm2UpDojpYgxabKx28pAkroyehZeAtHRbDDd1OU6ir0VkyMYoxPgJYQb9nPT6OaWDTRWJikEJDL82CU8qB3Y2ygL8FPD78oC84DwBnkjWF9WFLYrwrjOrFmpHMr8GJnMsKY72aUIP2gzGT4TYJfMuhiSfCbYCkGei8Giizms21BV5tghoNsoy0LaBj5SJ2on6SgWmMAXTuGnUQaZJLuAqVNA14QZsY21/EzdNBeI/JV1J6nQ8tSdMX8ZPhNgl+SESAZfZC+p/uUPp0C591+6nuONUvaXRDw5SkQ18pya2qf7IHfl8jbUbsL2V5K934qyTLQ77KqK8nyy24y+3IlWQFp2WeBss/ieXRZp65wk8yKQVykkNbjbAny0wJ17lNe9N1Xx0+77NOpi/npl+sotaefLeZnnC0W4zcCLzG6yRodcFkdnmnHE8O4s6f2ot628BN4r8Nz75Ukh6af7MT/XV6vcK/LK5zv8QrLut2kgEV+jm+e6cL/yO5EDvUir/BeN8bFHpQsdS1Bq5KqFAbDWtkb+UYr4E1bFWDwuCT8tzmUhv9Q3RdPqqq4BCG6R/KRlnx8eE5A3ux7+hVMdG2LIqa2hYVnSPSm5bUtodGZK2pbhkYHrKxtGR59Cv5HRW/Kr22JiM5cxUQzMUzsplVBOadW1baosmtbguCnya4VC8OSTzI1kWr0KXMmE9cwgdSLTAPgcWibQpPVxgQjzTe2DFV83RK0raFFs21btqamMPuoafZ55eyDrRrl0WVft2gUw/Y1ihkHmvjZFfADSp9ta10W2JasCmx7UNtANeHkc7j2uiwyyT/l1fFBlsv0NL+Scgb02YOzTZXqpueytwF3UsMYDTZ33lbI8S30FqxcUfXgT8sOZjvPIc1+DTowrliYpM8bFTM+c0G7t9kk+yS856tiHpfB4R6lzn2ydwNIGlwPgEw0j2rzJs9r806ywhp8PbFQz8y4yrOTRHmPMQPKHOzF/FtJPOi2R3uL+WDWRtscQrUMSQu+JZ0/rWmA9c7X/FjkAFSKzK2BmHkHHUff3RB45hP30B0wBm9zi24FKtXnsgrwi8x+PoHNysPd7qERz7YGKosLmNiyTE2NNVN5HnOolLyrFOpzgP7ok0LKRnwToLzmcrRoDExsZnvYi/5lNMoLLpx5+4GXirSt0nogkJYLU2blrTAULZNysPJ5+C33rTmB27LHQLJl5VXJd82fycR+4JlVBx1TvG1Kfc6QEzOP0Yfiue35Y4VLNfr5DIw80/ZgkH6Nzr23YxN3rWA7p3Pv7jjAob9M3BfRuXd0qFLrW0IUepPO/WoHnn2PFBZ1BXBa6ktxjTcMZqzO/aeOMj7kzyW86s9lPPvneqC0ehhj0B8hzBxV50znGP1Y4W/eY5lnztEW7GRqYtSyHxF4TjuufkSZp+LyCpKrlAUOsfDxpwr2zlmZd8+l56YB7d9WS74JvcItrx7m2rNd0lwb+ghyI2XefLc3pbZFmYIecGDeAJ7xxvjsvMBlE7nsbNaxVZ8gPNml5sKqJkEdE3sVaQ9z7a5PCvLzDubp6Y13EoxpxwM5zJvRBTO6anWBVxjVe7TgWZpr2smsgoiqt/IuwMqw07Uxb+0coDtdVoEI0s5Q9RWMOb7pcK2d4z7WCPxjGNco6mtVtoyCMRxj2FC1PTP4nGpXPaQBblZFc0mc+3Oo/wvoLaNIIS735/QuWLo/UVQJeDOA1NBAz6ZmA0ZCKptE/ev7+SxbE/xUHMd5CWOp5tCrBzNhmqOR+nj0Cu/2XsqGVZ9FVdMgjj9QKd8wpWo4Rr6l+mz45bvyfS4BDa2mt7K1jWtBa5VmibSbN4ims5d9dzB9iTWVTuTmUH/LDTA26AG0zvVTwYlMzbkmWNH49nFGNTAPjLhS3eadOcZxNjviMnoZQXmGfit86/owoNQX8q4XMMZBl+OXuvLC9o3L+6YqqC2PUfZ55FEY0JtaWCWTRBwGkyLFsAwlRniW6xz2Eniz4bormcNvj6i/Ia3jPg89R9zt9SJFJD0SYFKsTpqf9BsVlzR3ayVj1NQogaoVk5nXfypIyEmYh/T4ZO+KAiaOGT/DIe0CPOBYXmDIMcyLmesUx9eGuxWhw2q+4D7kwt0BoZoaI4c3p2pqEuGpgWcCPMNCR59jkuzcqEdG1SRB/cqw+pbAIoBzndHXi0xtCheeM2jeWCGqF2XLlF6nWJihmPK1q0mcVpgEPdBUSrSnWjtE8/eYcI0tM1yjgfBf5blRrByqWQPhdfCbeyZccwKe61EOmNbOST6eVcBEram6AHwKuFSAypFbMLQqYLUlM9CBlKiY5HYB9UwO45JP/npe1eodmaq+vDoOc+L3Q2E+47GvLBXLvkavZJHugBAVh/TIuG8VMp7iJxz8CvPrsD7E8Ov4Hdiz+XEVhHFle45X5zqo14H3zLCapWuyePnp41gZbd8U+rTTjDu1hSpP87pz1FtpNz4VH7cymuWtiuAjjzHx87PRg3ut+wPIxdK30s3I78xloqR7kWvd+wsbaWkrvR1JETWrfe/EYeJgprQK0zSTsBTm2HnkYguzSiq/H8q+kTmeeo1RiYPDVJ4r6HOY5tvyi3xhF7CmcyDH8P2uiOWtaqVTtCp8bSh0f7jxc+qJ/FahVbxa5xQvDbOKt1XrHwtpfTRE0RoS6RSbhylamSHnWgKOYh0ft7IBy1u1yqvAaV/nbBymSRCZeAnmjAtv470CsH7p+5LfMKt9Yxy25PDvpV7lf9Zf7rd+d0XXuvcU/jaHMSwE7OUA9l4D7FkXMtG6tXpOFGydC3IWzguAGdDQrYgbfK0feyoDE/WMa15fyZ/OM3FWsSx2iDqjrdLXs1To2Q0rPwbWNmNN2D+82Rj70UD7xbDjOGiPFnqcqmwdPHYE9yOMisqz83d/1/0AuuVb0KtVrUo1fmedCrLsgny/8d/o3RZvG1AuSzcuBpnzyWET8ibcPfJRz2MNUX2eZGrdHtozxFTEBsSV4TOfT485DaMgn+SXcNYFwJwBv1Vj/5M7h+WE0/4vhv5nXcMaFHFj1/rnGdsZksPSPFndf3Hlc392+e62zpC/w/vu453HSnN1Fzxj4ZfbB7Xu/BK/lh4pxPoVcTcX+Y+FswN9kiGc0G7E9AJ1SoNVvKtyiu5h8x5DigGs2oBqFJ+1MgEmP/r4/XmkMD+66sshvX8K+rzpF/De7piSk0bhXexCeAuDHgN4IcPRU/sEgDdLwbQqZJjsL2Cm/P+BabzgDyu/IzJHR2G904Xxux1IIehbbMQ1bJsP17/vCM8Jo/lKuhRxn7iYuCoXpq/qGJzzo4uZeO2ckuoMqj7M1twd+RETl+9C/OM4/K88BsfhyWiHaX6Ap0FLfZTNcog3MgK5wRwznnG/Xoi2L2iLIt3wrJR3oqaamcTHHD4KW9SQVHBBPJC8d46KOy779An07FoCv9/qMjVtwzTqtlHqfMdxtBNKWnYuULJhMAd6vqB2K7i3hPtKw93LOxpglfbSJ77vPyq3gllSw+gb+HT0GmHaS/22HOnjkAy8P03iTbJNobx+R0sQ90aQpPQ+dx83eP9qCPeRi4n5wIV7nKgVQu1BPkhQKu6/QQmSoTTBrPFB+Sfg+aaD0SPmT7tSUlJmSvsxn0wBHD5y8BPGM/gFxtO0DG/ZON/CZP+9VaVd1RoY0iRaC/Hu6n/DuFzKfui8ZD80/fKsdluMwqBczCA9ePY8EZlyDlqCWJ9CTpvkr72SH7DGU1An0EweY2DzlIuhr9sd/A7asiY+hObB3YS5NV/S2xEBi04fDhSNaO2Be72fTLnuwnqaXKgHoC8oXCfhjd+Mp3GlikPLlwZqvVP2NfIo5FCRIOEjHE2infbgB+iBIzv8vMrzY/73UFMpcnmFtI7SnM8vGOHWqwNq8rlVd5igYrFspVX829eRoAmwDh3IqWcg35PZD9cs5Z6785WiWPzbcKv49xFRn1g73h7OJOovQ+7hg9VP18xya+S3ZcPPqEOds9wKiJcNB6hLv4Y26jm0DiPCddBz3cL/w9m7wEVVrf3je2Y2MzAgIKAiUiEjouMNuaiNZgg46WivBeox8hQCCo52UjG1yRJQ1DBOJnQR5OQFFfCSlp23PBaeMivfOK8onsrkaKXiba8GdJjhovyeZ+01sxeczu////z4fIa9bvv5rrX2Ws961u15DrSjdOqa9ZvzH5/gDKpnuf4llyvHXa6/QrlyPOUSHU30xJmsVfSy6w1aSrk8fufk0nqfy8oNtkeo1XVZZtRahjqfnjI/Yx5od3XjLgHOx911HdmE+q0M9x4kG+zrNNNa89WlSaENqDXqIpQD50eyxqimLNRFGmFGLebE+RotxxOsHF72pM+UctifOCL3Lr/wWxqQMZ5uOAt+zT1vw0cO7zGWs4Lj+1zUjYrj8gXPODfpv9zcyHK+zDV53Ecf4frI4+PcvAXtAmnsBZqCEWJrysJnGxqlQfoyKVwfYre6ZO2fdQtExxW0/GdrYGMPSC9pqNVNbBVXiK1dT7vjIi1KrAae32ahHfPJ45I/LQPEEfA/cVww/J8y7tmP6DziCa39Ql1/Tw6PnkM9YGjFKCx3HJTlStbDGYCRF5aBetpOue58dcplh9+9rza45p0uP+tt8aF80Ke9DGS3tWkjMvY3o46oxD4aOq/LB173Bx+3/kUX0yu7o59eK5p9G/HMnuDYmhaUixq+RJgLrZ+d71ozHr9RhVZoURWWuY6+8ymVUzoL0JYYSLRq77Nyjf2mefHu1OAN4G65gvsIwUc1IxLtxwpEoIin9nC8Ro0OZa7F40XH7QxhhGDXFLzq3Hm/UTJ6dri/q1MZcJdzMaAu3oR7Ez5nZb1oojosKaRull3ljfOaMlfueEi1CWS/l8qkEcXw9Q4IgPdzvtiajVomeujC0jfhN84F3DtZyClEB8mC9nUAqQR/iiias5jPL2+KELajn4p+f5U9QpVov5mPNs9CXJp8mpuGNeRmsZPuvDUzu5Y/5OO7gXHnOW11x7mR+5t8Ybhg/w7pRGJd7Z6fCTX104froed8cTcxKPOuSOsNaw1qNUozQl+HtSsYvrybqMm6K6jRcif0+ihZalPa8l84mW1Kq5dhJDtRh29f1o1qLHPtTviXbvgFsXXtS2gpDLXXOZ2DOxT3qI7/V6uiWJL3tIktN/Kf0YkXGl07I1JByvs5P9meqMHSyK0iUh1pTLT/mB9hVtsvujDsWXjnUj7O1eQ+rbI/9/mrzsoubAWo8an9On6l83Tv2Mq+IjsL6iCZmiZhMGoGHJiBWkCYfkCqKXOg/XNqr5np06c7wkfIt+XHmMZDd8vKHa9pFoanNmBecIVkSjN+11ENja4dUbNmlCY/0oCywxVqTW9Ka8zQK7P3/HHiUayrbOBF7c6z7aJLmy/bwUMaOLsLrbOYUZMiltu3GfK/HGk81YWprsy+0YzWXd2WXJ3OBe2K+4V2bDui463U0Dj4Ak8Hxqa5RN8prmzf8qT2hmvX3bEYFxoXGPs0xCRDCoxFdHefe7dZNULrKRO2r0evq0esuzf2cIk2oNGdI11XKHCbHV4n7yYKmDaD5dndg5PtEZqHrr94d2PwQ80ae5AmCGgqX0q0P/65+/SAUOc+T7puw8NCe8D0x1HXfb6gpuNLcu524Cg5F+TRHGaCCVkXL+r0lMvng484t3W5R6ZnPt/qGhp12XVsJ54tvbEWerfvjx8WJ037EXXVomZaKWxa3aHQMarJKZeofWw1G1XHnnefqdgC/sKpw0F6HLlmrDnRDFylHdIBP0f9tUMSKpP61aHWWtRVq0pQGfrXofZa1EuLGmwBIyG0DuMeSZF1IKsNcu509nmflLmi+pUkaVpUmo8asOR4WhzL4GoW6t7fqKLlvewauWura3QUaoeFMrw2yx7q5y5HYutGmPmMBJRhrCR+nV7OySn/omURWVmW9ipLNpQl/uWx5mlm0TFuzavOCe3aFm8VliwOSiYavqW67Ueyko2Gko3qUbIxrGTDaMlGeUomGhQtk4+exf4weRyOfhtgDNoAoxHyyaRxaKmyTDpGz7/LI1gRG8E+p/rkyqSPuXDRNsUsts7MeNV5zSW2zs6CnjQ4LEOuQa39hRNlrlGsBtfdW/UB1qFcb/YpKB8WHxHNwSAfli3XVb/qXNmhqxUdO5erqh3OUJeqVmyNh/D/cWq6dTUixGd3iOyUeJOktW4EftEIst5qum78hm0PjveL9vxtSuv2qAjzgj92wzwsYw7q5wwrwDO9OOb0K8C5w6/zcbQIKMA++FinitZDmWtXFI51X9zNV395N19TnhRw1pAbYWayvOPNtNA4pHUN+P22VL9YHCf35KpHxDYoFF+nFEM6Ee33aQ46i3pogdocYYRXS6jXydbnCmTNtPmtOTBalqbiSHlO8rKWQYmQD+Kq+Ffw3JurGhUHWNujI8w/Q9mOtF+hZXvNU7aXubLl0Zz8b4c7B5Cbuf9fJbMUKCWDd+bU6lJgDPkQaCfC+PgryoPAZ/Wd70tf2GQeu8mz6ym0VBewMzecTkzURYr0QSKC+f5aKI8OpPJj6eFxq8lG4PAfWnFHAM8P3CMLGZ1NBfeI2XMi24z741TXouj4aQGOd//0jH97PKs4A84t0fW7gPVQ+qlcm74/Nbq+iznliokFGWGFfALfPw9P4Mtfm9qzwfp+GvPYwOr7HKtvHOECm+WyP3sWZ6WD1ggj5jZMOIoYhk/d9fzkWazlvh0yTfg2Bnn8dX/1RDWO4eVJD9cpulD/ktCkXef45bDoOILlWYPlOQezBW9NoHmgOdQe8iCXaowdaL/gOvIpjAC0RZSy+yjY78qkSM+ouM752WG5xHVtnxxG6i9SeeIvCUeuYx5CdescByH8yFDB+Pi9/YentBZE7p4vGNfd23VYNRhy3R9yPfjLuyc1mTTfX9w9qS5PevzetsNYL9voXkgh6pBNxV62zcMR3kxDLc+vXVfakTDs8Xvlh/HkvV/coNwRGfuu4xfoYLX4+L1/HnbX47p7Zw9jvb3U3rvn/Xt9rb/+f/tGB6CMR4D61LO4OkJbfkMM/UaD2Df68iNEmtv+n77QSTWWHUu88f9XiVdcl+9T4Nh3NihrCtPN/BmdN4J8jX/Yd2qg3hccdpd9F1f2isOqSMjLUMhL5B7MScJXrNylkIs3DrtL/tj1R2Bm/sfrqK107XXZbifK60fmlqFm2FGC/VxBMsy/VBrBfroAdRY/p3u6sUk3g2osFoxPwAyoJBXXYs/dFF8HqTHnr7e9VTm3fdQBrace/RHGn7dgrNk8Ne7cdp0PSP93ljudbd295YJyneEC7k09osOQCLPQUlLgcj55P5TKRBc7hn0qyyGFnjee0+kvnJt+ziJEPOQ81XGB9ryaLPnuy46EebqsC6j/WHT8gFYrXkdNxPV05c9bnXXbR9PoWvt3uVeXTd1q3m4eCjPqH+mMWlk7lWMHQszF343xg5hLvxujPS8YZt2aqZbt0zx8DqW+GpD61FTqu9aBZVrWge5LXWi/GNvK+9N3WdRQluc6LtKVzot0pv13Nld8BqTe7vxGaQXdVdsE0qc8n3SPqH2r451j7/etUVfDWPZSo7TUlkPPR/WFVvYCcweB+0/MHWxb62x5AK1led/qtc47D/rCeFi+3Kv6nnNrl9cBde1gs3e107mi07t2uLkvjIyrOvvWoL2q7x8gUldXpeQL1NYzjaV+DGkD8/dhaEXU37dGdGiWIeYm56n7Xozik0DRHygeftAo5RfjzcsyqaC4Ugq0XZYyYC48SC/bug2AMTef6pXF/rIB0sjjcKEt2N7oks9uJtK5c7D9O1ejtBHHBiqLe19yz/dQdzueM04sh9l21nqcH0ph+suSGd750IUrYSBZYDjMu8/IT5BNZBlkPeuX69NQu7sim2zg5uQwX2m9B7JMESfL1GV+KamY/0Yxm7sXw0yb0h1Pb5NtwPs9xWXSI3irCfKy1IWz9/VU624EC8tEaScbz+WHeLQxu5wnO1+6Dn0xKutuoTofnhvQl5Cuu3NBcNTA/Lp6Ad6/w3Esf9CC2zqVH8z234S2uTHpp3MLWS/ytqinY4uLam9oxrn6PV2IN8rW/t4h3riuhusf8eB2ryUzveUz5HN9x+a+wfjDVMof1MAfHkX+sFBr99GoQDZozEeuIABfhXy8foHrfZddJwpxnWc79I+tU0/a6/L/6uENN+735g3vQds/nI+70Bgi9/RLtKe/Z3lvOu3/LrmPCC3l+exmVOp5ymHjirdJGj2eqMDbR0H2v3W7Jbt86ENCFHznP8A3XXRZ2mRbQ3KLlfn22fwyaQe0xULFPvvd0/m55njnq52N0ns2jFW/nQNzf03112QTyB3vQqsXrHhrFP14NjHemdNpNaN06QMtvrHdp0YLLT7hvrZGU73JOblLUzExQ6yIQ2vPq7wMIp2ttTk3dIw1ow/dW4FLdDi/a8dbhWKbXzDejMK2JbfVAXJboePyJzCWXVmAKzmf1fnk9sUVnBX9Mo7XoZT1UIYu0tsgU58DFNHy9FhwL6CcSN8JaRdgzm50aYEP/LBcA3zgjQ4f6Om6TtGx+anAmEp6E1M+j4C6rEvpTWwfm6wDWw6rpGF6G9powDCfGtTCvcl5BmlQawllwL9W0zFVR2f2YboBF5SRffNRLOu+dvy/vQNLiWtRmH9cjYKSzY4Et5/7/OaWxzISMhY0y73gS9oLytGXMIj2Alx7/IBKcuc9kpyeW8m4eM7P4jN9mDncuZeORgvvfknb1z+acdx1t/kX2TpW+fbtaLflsRLwP7JLJyjj5Mdzy1k/8CpMztXY52mmjVA1OJ0HO7JyQ3WjLsjrkeuyDHY/zU/iT36aEYYGGJmgjR7ulbtvPHJm0HmUGr6aftqC82xcsRQiwp1Pd7tHgvJ85P7zxmXlXtQmttTlyxjdaQb7w5oKscIPe9+x/N9H+YDbk9ydL7ZemjPcrIXWeKtdW4OtO6SD7bQk4D6L5raqr99YPcRfbNdDq413ih1eFerS4WZ/CDvbvtjcv/o159r2/jXDzJucP7Rflspt/geCPvjojsr2flIz0dnaG9DC3tckurw/2lqaO8se410JXP0oeQLHsXLk+OiGFMV4K4uFF7/mfNllNPevmWCul/qXl0gDyuulUKrRbbMz/AHaj9kE82/Z2v0T1DZyP7R5Pse7U5iDNuL7V292ej+Q8/VG+wTzLbpbM6Qd+8CHDxagLfmXjOaxNN29+3K6Ne1oSx53nBZNly3Ky2sdao3G/r+aJHuEGlct4HtEYUvJsOBX2fhgT65mRBhdY35W27/x92v9aU+te53HHMzswv+f425awvPalDpZVvuXdvkFeVzHkbl/NVpw6w898uByLfTIL11aOlPtX33Gebi7fw1aRAvoLKP6EfSo08AKI7EVcyyfNd4Fo+VOehaqUdptPQX+VeS09Y+6U+DTNOKaeqJGOCu3pDL44QowWrHHOd6f88tcyyAkAka2+YtFR32u2Lo0RxhhacDcqaht+6fN06DOfmqPy/3GJcSMyJ1IbcZfhpE4yK67z0ZaGMkm0ZEsyH6/yzO6gYwcTFenZ0Cf97L/uYtfI8DcVCZs16ovRJg19gn3wzzjnlCH+2jYHw/44DkzQbjoI49V081YW5s7/Kv71z5tvucc5crKnaftc8Efau/sAqyxflBjQZBmVUdQDbbdde244/RPNl5jG+XX2N+l95zccQE2foW9sBm1DoxjIesh9ds0ZY4nha0ZV6MuancBHzr8O6Oxnu7dy+PxmzAe40yqMkFt0VB+9Mf7Rc0i2yt08yE8c4PWsHcknHTtTNhyxOGsg7a6Y04/u8pLdNyxxTTgra4258H78j1JHeWz70unPTO4Ry7IbVlFudzTdF0wtqOMjrGVMEvZ2Vd4C0fdILtakEfeXWMF+3Pr/2r5K81V0H33rupH/3XZ1ViI7dy9vyqWnqfytbrX6QBoxXNkOyrDlrF9+at+t2eq/IGr4M5tk+cNRRqAGdZg+Z2M2e49ZjeOkl6mj3OveM9q9L/KfG77adSlaDcMV++9SoHX+D7fsfnu9qmJrcHrT9z29kqpU1fsgadvp5fTq8L/tk6LOf8n5GULUCwEnugqlBFe4fgkgdIKdM3vFee+7o9yT7m8Y7Voxxvk2k3OdNdHi0+5QmPvwv/w2DjrKVdELFA0fEOtLV+Kl1fP/jUErfHxq2eX4+XVsx/icfWsabZ79UxPbaNdh/RHoAfeWItnrEL95VW+TwvROmWj60q2vMrnT1f5LvVY5Ttpf7/Qvc532TWkQNlRO2nfVjjW/BT0WsGF63tn6PreVZZDRLzWI4fNLIdXaA6vzVbW95ADHIXcdaGlMZit/Pqnf9CZCllJ7QYv+58P34fcLoHc3oGvfiP7xG2V17Q6aSDa/jp7UziA66YVkKdtkKenC4/fVquX3NaAXLhmK9ohKYeYtyAmpfCdGwHCwamiw/Xy6+AKrsPcbXD9Fv92p/MupFSH1uk6g/+AJ5f9IIfSKfitRHtimOrDcbgn9y+P/gLcX4dczvW7ItTNLY+bON1b7mPIU3CtEPfpUToEeXtNKcg1P1C5fuYKDMOd63N0b1hDVwUgbL5fS4ifMPg7ukvRtlIpNe5a3bsK7Tb78/9LqX8uUEodXsaXurEAS30YSu3Xo9TO/1Bqx1X40VLvoDLvRN6uGN2N+GhchPmBc4kLrdPi18L17xjWog4VoNXbRpewsFeLOkB7BV0nPmkvhdwKwhLaopaVYm6LIaYAYjYWjDWLjn7L+rrEiRtcT8W+4uz3QO4bA5a94gwAdwi4By7b6Dz9APvGMto3REfI8r/T/iEmXJb+bpNboDYKLeZiaf3r0DKu2/obWt7FFug1R+kj73FaU+Ryoh3zy66zuze4jnn6TYy/skI+pQDtp4Nks/Df+47e03eiC3qukZ+0P1wA4yDt/Rud2axsBijPgvvY43fQHr+T6/F+bL3cPwptqfP9KYCtl3vT0vSZ07PHP1h52RVSuMH18TjIsz+UwIY99/mOP9/FVnUbRuQu6Esu6Ev+nlZ1ka5Uqg1uTtWQX4htXeOeWX2b7+5Bga/9mWtL3f+hLd2HHnTf04P+Cu3mvnN6F7aesHY8HdjtQvedBxi+qxvdehoyvhP/T6MpF7ow5Z860L2nU6xodOWjXceF5+VZYM4nt7VqwFMtZuslW5New9WXhe44JXwFrr38TvgiXHn5nfB41t5r433pWZwge6KX+qzRMmL6X64G2b0F1dnhlnevpupUF4ZZ7jUPs0RN10S8dRWtqFYm4XnRdfduHBQMidfKXNdC3HsJyYcEw2YIkSCNqkWlWnfvrUMC5S43INThCVUdFgzTr5e5vDy7ELMg5BiE9PGE/A1C9M1lrvvwln+Lyn/dvcAPBIOlWTBUNQt1eF+8kPGkj+F5E36PgHzD9jGSqfaa1nDctdS/L3XYBMcpdpJnpyWDCLZDbdkPrSYbLKIZxnyLvMo9vVBoOwGzNSFdcGTim/Ccj0+r0BZOV3sjQEbPIPmmaBKBdnNM+8geq4MIpv1kj8lOUozvkvXUrkozWW88QhaadkP4ZemSrYpoIPy0BfqgRZ4dBxfe87j7FMq2XKqKBYcrU2g9kXeKbMRVTtSUYhlKMqx4P7KK5FsFhzoT8qKRw6MhX2s1eAsM02I6weGdiemU+EsQr+Li/XvFTwoukdRcfEiv+B0Qr+Hiw3rFd0G8yMVH9IqfbyiRvLj4ob3iT0C8losf2Ss+PK5E0nHxsb3i10K8Nxc/oXf5Id6Hi59M4zPIdXpjcy+5YiuR9Fa+rgVHCk0DdZPM1UNyCcwZFDqW3vUA8X5c/FM94q8RbEPz00qkPlyauTQN6seRb4/ut5ZI/jS+BOZ2giOXrnwjjXopEMtK22I0yYC4P2XuQ00rbZdYWDS4J+WVSEF0dVxOs5KmUeJ3QHwwF2/rFd8F8SFcfH4qxmNemQ4fyFc/T7zcHtenCo7CNDldNE1XIgVAuv42Oe86mt8IMqwc02SQ6mK8DVQvDbAF2Z+9LzpeR/uMxTFkWvEDdjtc7ouv57dxfvmm+GKzYMgYKrZdmtMCM+bQ6uEkxzqMnpNYm6rt1AgiyCpoOxbX/1vvqKznAAXRapPw3tsVeOcu1Tl2GeafWxNwHUnel9maIESpIo+YZ9mzfUIP+HR6xb0j17tnzAy+8NuHE80m8xSYCTiclnbFPbe9jOoYw5UHoBOpSggdpW3J1l5s0H8kOjY+dah1bZ7YemlFeMygQbtbMlSVoXgK6WOmawz1oL2V5GhQtWSotyaRhgiz5AzvwttLi+n601VXH+BTbEa3HutgLfA+t+0ywXECv/6Zy9IY/VZpiF6QLZbVCo7PkFudEVovzUG+d6jN7zG0/gJztONC6xB65gd4Y45o7mv/9j7M3o4bSXHxCFJcjpzRSrYUHyTDi4ebp1cfJDXleCP4NqkpXkr8bAdp3AwIE20jyJbjVlJru0POFNdLXraRRF/7CvG1TSDe4B9qsxG9bQ1873op2vYo8Snf6JTaR5KDF63VS8iBi68609qn11oPvFCjuoJztsBcPEPxVO57GduTtubOW6Bu8VPfa7DWFFYXHi5yLn4Q8I/phwK+CvhHwFdxuSMyTObpEPOt8+/dhTXm6leckZ2i4yvaW5okM53NlUmr6F441nJInLzqPHLBWzTFEyzFaveOeeoXkhaep1n8NBa/hovX2SrpDre8gjeCvGFbSmqtaAtrJNSB6FAvKZESaLgIPHg8GXq8AmhptwF3oj1BdPjnAieitlRFR2YmcB0aHgUpdDa0QSVCfy+RkmhoiTQM6L5hW0IxkoEuYsxfXCKl0PDtMJKNJ4sslZCuSYq2yu+74P0p9H0rfDfgV5DnoZDfodZHSQ2+h/YSIdxPptd6asV4Yq59lYwy4Tt5pBltN0H6erpLIbZtyFxNFllXE4nSrKcnjk7hiry+RBqO8epzNGyIGu1ny+6r4A5g7iGZwLeou56dJMKeUC89zuInqXEnRHbvUOMuiOxeixhG3AOBvp6KZTtH6yQR6IyQ6bRNAtqTGe2RjPZaoP2YTMPRBfEhzC2Cux9z6zPR6rnsnoctJgx5keh4LlOmNUqm5ciGdJMY/dEszA5hE+V3WzcAVijLbwqED2TuDan10hia/hylbcJ4uZ5ar8I7YSxdlRq1/bA6S0VNPzJWDMO6DzQfZfHTIO1DzF0N7oeZe3Mq5N9ULz2CJ8JS5ffHsvqZBu9PYDRjGc0WCBvP8n8C8hLhrm8IH8zcJyAvcTQ90L5VL43DePadwwE7kqW7BG4Dc4djPcL3GmJbQdRYHqA3lcovTfCty4nOCnnNgDwuaCEzbh2GcU5s+yYV9YhupRq80L6jYNsJ4bizVU2fAcB3p1mqqDsQ3NPT94Ib2wLyz6vY3tuGqbZR/YcGrAs1uo+S3HTRYcX8dFyjaaoz36I7SAHQpid1HIAn5ENVKU3sqKJh/Tqq6XNARw19hnbsIQXIu8D/Jvj7d+yFcKR3g9Kr4uhNYPR2LKiUxjN6DzF6jzB6EUBvvU2m9TCldRPobKP75WOwHjMrJZO1nGgh/lHrYZD7KqWB1n30KcBzMDzDrNXUP8haRZ/hILfgc5z1BtsNx/dFR3tmLFEzGoM5Gv7wjGQ0DIzGEEZDsF6X82OVy4X5mGw9QOn9CfL2GKTHsL7wPj6DrTX0GWLdQ3bb7ES4VUPpBAE9DE+y3qR2E6fYhgBdpIO0ZbrelAZ8N6CrZ3R8gU6+bR8ZDm4fSmMbXS/UWmH0TN1PRlsr6fgj75Lg+twX7Mw4jLtRJ1tLClDPbSXwZXiaUDcJ8GPgWU/aXrwrqFeTQ7ZlZKceLbMvAb4JY3TUeHKaWiMdT36tBT6y3EZesE0m/rdWkxJIcxD6kxpoJUC/SUANc3ojeYPaLPwn8deLbd/NEdtmLssjbxxvkuJr66X4sGVECINvoR9LVB1HyZKwn3HXqW3kgnMfQi3rb5J8faWk1v9CBGpTCbX3yfadIpnNIoNxNbllQ5tGMZAGeoSxSVLV7if5RrH1u2XwVfQ7idEott1RoVts61oAuardh/GOZQu2Um48zhhDjPoVZDe8+1htpaQy7ie7MRfCKqI9c4DU6pukkNoaSNMk9a2tpv4geKJ/RG0tzUewUaZbCO+Jy6FExhoiGGX6Iyj9Jmkio/0mpHlDiCMak0w7lNHux2j3Z7RHMdoDONrey9EmVTXkvyfteEYb3zfVynQHMrqDGN0wRjeG0Q2H8qopXZmmYISeCPV1EPH0/yQavehYueBnWvePsG8xVn8FaEDPhO+A/of1V+nzIfAL+hqyk707GPKaAnmdYv2ZaNGmFLTEhLDrZDi4ddBrkIYvSPYb0T4V6lhAO1Tgx7SJ1hFko7UWaO0nBdizwtCK8ziiQv1ZYTXwhPoDrhEQVg3xlZI/PDHOGLYLZpaVUmDYPvYetKow6AlP7yOjw8SxuregN0DvLDDGEq3xGDltxJ5QAG0m7GKSXa3G9o0yZGL7xxbdlSS7yhMyvv1Dy4cwgx/kPNXeB+RBt5WjSikZ8FKML96dQtOKMCtYRdS1k0hWGPZE6NHGPPKdqYVY9aWkEHpl1gLR8QpIOC8Ax94FPbsPcAFzGNYB5NcIkjbktwPKNgw5SxjWyU2iRRtSWEdoI8qKVjuhnij9XcCxRIeGjiBi2/wV8NTvRZy23BVILxa+qYk8Cd97N7T3gAUmMgr1DsB3nmz8GeigrbEbpNAo20RD/0jjL0RvRNtcN2l4X7SnhtYuoH3sBrpVK+D7GldAmOhYvOAWzNTjyJ4zR0imqUmaYNxFIuEZgWnh+Qg80R9r3E2K4fkw9AkMf8i4F57nKE0N5H8VjgqmOJo2wQh5NYlt2cth9GP0+jB6gYzecEbPn9ELoPSapEnwLp1tm0qRhsMnE/qSaSd507QLpLd9ZA+kGQ3PTaZKWaIBLqoDrB0rUGdiFQ0Pte2FMJmbDwVOFg/tELV/Pwp1jf6BwIXRHw5P9I8BesWoFRxoYfggeGqAE+9j9DdB+f4IHHuqbTBw9FryZ0Z3MKMzhNGJY3QiGR2DhwZaWkVu3gzc3DvWexty9FpqfVVnPcb03RRCutCL7jukA5vkWZVIZ1UR5jvO77tFy1+uC3VHfUO8X/OV132uwhNHgRfvFtK2WwYzDSfMtN2aSmQthrPsKn00lY//vFAzeK75I5gZnpfU6UNhjMkhUenaDpV9IzyFD1Vj995RpR9rrx4CFKi2km/r1MmFyVWu6iG4ivtDHbq0w5saxNalyXhrAbWNP37vD4dRXsJzfrijv5KItp908n6/l+0xknMRR5t5dXgbAH3z6n6dD73aBnK3bXbdejwrZrCRWpg7HTiONmQ1pSi5C0PrQT4CmRZvTtwCuRltcd6C8QrXfi7CF9eA/+LdD8XS/yZChzA60f5+0VORY81zqw3Oed2yjvbUcqh1XM8Cd6ZNU4Ga3UukNJhR51rrpWwInQ2zizkwI8g6XiIt7PhfqCXcz1xWBHODPJxP4BoY2olBG+BaoNaO80rgP17wPe3oTq+m7hbqrkF364k83JWuIYetMAMCqe03qnN/P4mCuA1YmvR9ZC/0wyFYknRcNQCJQFMiWa0K7S6O9n2Fdlu4Zht1/xnCQzJ70r7K0d7A0d4MtJdwtEWFdts0jUJ7reY96j5k7UG3LUWj0L3K0b0BdJdydPUc3WqO7iVNDSnpRbNK465ZmW5KsOgIy1RoTwsukV7gaAdytKn1Wka7i+EUgXtS8DZW36IjIlPBEoOV/FcFKxjVgPEnDqM/h5HLYcwPVjB2cBhDOYxsDkM0KBjehhLpRQ4jnMP4hsM4wWF0cRgjOYxTHEY2h5ELGMs4jEgOY5iBazsGBWO+QcGI5TCGGBSMUxzGN4CxnMMYxmFs5jDWchgnOIwJHMYGDmNIHNcH4kqkFRzGaA7jBodxicMIj1MwJnMYVzmMDRzGZsDI4zDi+b4Qp2BMilMw1sb16g9xXH+IQ7ol0kqruz1DXuMU+qYs0ZGSyfULDmMHh3GJK4eFK0cVh5WSzPWP5BLpJa4ciXz/SOb6B4cxKVnBeIrvH8lc/+AwqgFjFYdh5vsHhzE/mesfHMZcvn9wGGIa1z/SSqTVHMZMvn9wGCc4jC4PBtc3OPrZHP1coL+Go5/K9400rm+kcX0jrSftIWke2o58cKtk2uAupRbEXgb6akZ/LZ//PC7/eVz+83rlXeHbjvUc/fWMfj5HvyDNTR/CZNo0HzqZtqOQ5V0n04b0qAetVFLR2bC8Ol2As15cQUuPKgd0WVd92zdpMGrR28yAhGtD7pLg2oK7pnAtxF1T9HYejqSAaFO4eRSuAaXhWh4rFa6D0b0kRIdazyqRbDYF5zkO5waHc4nDCc9iX5zOyc97cK6mKRgbOIzNgPEKh5HNYUzLUjAmZSkYazmMlRxGSpaCcZXDuAEYazkMK4dRzWHs4DAucRg2DqOKw0jJUzCm5ZVIr3IYyzgM7zwFo4vDmJTnxlDoi3kK/SqOfjXQf42jv4qjn8vRn5+n0N+R15N2dp61ppSudM0GKWlOepOUaamUsixNUjbI4gtBXl8Ec5AcI7Y/IXKWPcOvUkqjelVBpltdL60DKTHVhuvnaH8EJUaIu5VD1LbCA9FEC66oi9HEC35DOqKJqM8hBpBmNWE5JDLMr1MdYyc5VrxLii3TARTwhs9deL4ICB8kEbLJ9jbMDAhIdm9LY2wS9T8BTx2Ue4DtCn2OgSdq6HjC9jP1Pw9P9K+mpzdw36ShQRUbajxE90009i6NfLeA7qHkCdFepdmGV5I1rWtXFNZEpvimbOu1exLqsdPitT3CfNdZ26W4/9oljJ5ibyiQ5X0VpYqyNtpqOd+A8nXkWZz/HmptTAsfO2jQ3pYM9byBuO54hO2h/ALPt9FeS0JN0m8NEebbzle6xdsbNRpHEbXXYq2JMN9zPt6lGqcZve7e3Npu57pPrLW2GsGQ5BInvpXU2ZBfWlB675pYoRoxy/4U3W2fW51o/8cGg/OjdrTohJr0dRUlIE/LJ9zQSlFaMbpl2XoOPVOoqUApG61ElUizi+ulLIjJBrl6kUeurtiA0jGuuytyNd5Q/y5P5tBFVKrG9XS5vY2mEnMLWQwzrCIrL22jhL2X3LH2kCIdrixck1c4azgnrY7kJOwij4RdQ/yp5NyT/n3WT+/gCK9WRpa1mp8YbYXuG5x0XeSRrmvIKCo596AL0rZCNyUIaWgrkLKS40tcju9w8nWRR76uIX2o/NyTcrXGXRtyTicF/8BqhskRQQrdmZxsXcTJ0LycXUTlZl7mVnIuRirjVUiWkvcdnGx9kJOtizgZmpezi6jczMvcCkY2hxHGYXRxGH6cbF3EydC8nF1E5WZe5lYwTnEYERzGfE7uXcrJ1kWcDM3L2UVUbuZlbgVjSKyCMZTDOMFhfMfJ1kWcDM3L2UVUbuZlbgVjA4cxksMI5+TekZxsXcTJ0LycXUTlZl7m5noBhxHLYazlMN7gZOsiTobm5ewiKj/zMnePduuYwNG+9Duy9Z04hf6OOKCVpGCYOIyqOF7mVspRlaRgTeawJnFy70xOti7iZGhezqb9I5mXubn+kapgpPD9g8M4yMnWRZwMzcvZtH8k8zI31z84DAvfPzgMP062LuJkaF7Opv0jmZe53RgK/af4vsHJ1ks52bqIk6F5OZv2jTRe5u5Jey6f9zwPbSrTqphsrXHnX5GnPXI2zX8eL3P3pJ+f5qEPsjHKxYpsrWKyNaPvkaN5ORt5rIqNCgUs72qPrG4nZlr+ZqK1DiX7mWytppKxLFWfSoX+DVLyE7immS5LWlTaTMPdYY+E5ZG2i6j0zEveR2H0A9xeEnY4jnSZPzKpTpHoRnLSdREnRfOSdhGVnHmpm31zunPpkezYCTBZalzLSb5vcNJ1ESdF85J2EZWcealbwUhZoWDkchiXOIw7nHRdxEnRvKRdRCVnXupWMKo4jD9xGJM46XcmJ10XcVI0L2kXUemZl7rdGAr9lRz9HRz9g5x0XcRJ0bykXUQlaF7qdtOGGUIW0u92zjr+79La/1yPdF7r8q5A25R4LgllryzbUTIdVz2LS6Q0XNssL5HmgByWWVsiZcMvB+SwoVQO27qBykqtJ1Zg6z1H0TroOapbtGW3ZOFeN+biBjlMZbAbTOa5ifGt8oz1Fu1V9ix8/zqZiaOB2t0bRIcmqwLceKarHuQuhfb9LJnun6nc1YMuWxGV6XZxdC9RutoKpFzKqIoOn6x6kLw8lEG6kikfopJXT8obOMoiR3lSkJLjgKz3PDleytGtZnRLqNzVk+5Vjq4+C2kq9EKyZFqyrCXXcj+llkHugvYSJNPeS2Us2a2sWd5ka6MKRiCX9y4u72FZSr0Mgnr5E5f/+cEKRi6Hkc1hVHEY/TmM+ZEKRgSHMRgwXuQwTnAY33AYpzgMeV1UxgjnME5wGEM5jGjAWMZhhBsUjGEGBUNes7zJrYvKGJEcRnisgjGSwxgFGMs5jLUcxmYOYwOHcYrDGMa3fg4jlsOIA4wVHMYlDuMGh3GVw5DXRWWM0XxP4DAmcBiPAkYehzEpTsGYFqdgyGuXN7l1URkjvlfbnczRfhxor6TtV6GPstekJAWjmsOo4jCuchgmrhw7khSsFA5rKmC9xJWjiyuHdzLXP5K5/pGsYCTy/YPDsHAYMwBjFd8/krn+wWFkcxhVHIaZ7x+pCsZTHMbTgLGa7x8cxjccxikOQ14XlTFm8uVYoWDM5TD+ABhr+P6RxvWPNK5/pHH9g8NIVTAchVw56Lom44MvA33RXYY8rgx5XBnyPPTZ+qhMfy3Q16X3bFfrOdr5Cm36nk6mDXIWylg32Pol0rvJrY3eYuE8XbfsJTr+mIUnuM4xWWs7xNfK8ksantI6T8fZvVSukt3yauV5Oi5juLwaWkvH9XlZLWS6dR+ZiWO4NariHB3lN9LzYqXszLDoyPJIXDLSpTQF5QaHcpVDkddDZZTnsmS6M+lZqFJ6XmkjlYwUjMUeiUvGmJSlYEzLUjDk2UYNtx4qY2RzGJNWKBh/4jBe9EhcMsYODqOaw6jiMK5yGFYOYweHsZLDeCnLLXHJGF0chneegiGvV9Zw66EyxjIPhkLfxtF/Jcstccn05+cp9HM5+tkc/SqO/qospP3A+c5n/y5xnb2O62O4SudXh3d8cW/+gXPY5/JZZG/3WeTyQ23fPYTnkNFOrWjGk8iqQ6hrUGi9NE9snblqmFl03MoBSaM8xvli5zuA/S7k/33pH6ZcUp0+nNTYjpCv0o+Q09Zc4m18iWyyHCOn6V78cOJjWUyG2RaTzdaVZLclseVAYTzRGVeQTFMcuZYeRbzSj5Ev0+U7Fb+s/28iWE8TrzC0VnKUCOmyBaci2y7ofajDCDEgPdNZfWZ9AdlvmmIWq1dCXQwnw62ryW48y5yOZ8rWkGpbFNGmrySn6Hn+/WQY1OUQ6ydEgHCcVemsw4m3LZYsNI4nuuIVJNI4jAwrziN701E/625SU3yNvE7PRuNZgSiigXc0VrQ6n0PWQ+/tk45n/0ukgGI8MxvjbKa3TZskbfGP2sSW/oWCIbZaW2pzfoJWDcvRCo+//f37buuBAfYL7U2SF9XagdYw/O1v3beTxFp0B9i/bq+UtMftNG4GxK3H92rRHWD/tN1Kim25UF48J7qYDKe6BozQnjLgV00SbcH2iICwwzeIHnIZZzOCDD2MGItrCJ7CW1yOJ6CNJN8WQYbq8QR0DbHohxNjOZ4cLZHG6+ulCZDmUfiZigX7GwWi486K2Jq+1V87f3X1rYkxr3GmdL1zQycUwQ9vA1yQ0BK0So+3AgLslvsT0K4s5OgHqIVfCy9LU/VlkgHK8MID0bHpWdRG0ueQ2Lp2tW9LoO8W+XycMNFsRCtTtlrzJ+Y+LSl+l6UJttHmgRCWU9t2R2U9Cr9FU/FOgLMB7wlkxK1P2g9f6VbDMXLStkU5X5hwsvXDwhfvfqnJiBQG48o0tKnysOo+Lbk+3xJd+WDnngfADeebzNPNI8yB5velh2277qhqcf3dDnT/koR2mpwN0VCrGbFlU1WSCjDwBvE53bAL79PzzSeWG82YB7zRUM7SD6d3JvNTL0tY5zG28Fi8L4CpKpNwRd7ZkAP9BM/6el2RbfVRffkC3htY71zaCTUzdwI5qfcbtxFqZL0zqxOfjdJQj/U4PCWD9ukWwXeTNQnDbEVPrWq3Lk1GS7JCJKb9ktXFKdeyIadcK+G3ZkiZqzo+8e6EQlmrZHU8atQoTTrZOrwwwN7Y9Q59I9FjwRn1ynzN9MqgPTy0kXwa0lyEXl8uqawXYawrlzTpgiEjQmy9tLwdShpbG032WaLJRlMO2WuMhj4rdGoiHzM77qgsF6QxtgvSAFMm5Lkm6VdisF0lQyDkCUszPHEv4Da943GR7lW8SPVU0B0FH1XkLHu2PvaAvtMn7t1eOxQhF57veL3zWXM6vdXR6nzGpbgXuuS9CW92w8OnReXzaUtogK4lW/d9g2AU7AcL5B2KkLz/vENRm+RoULdkeNXQWx63nMOR9+nDahChpbv4Z9Hx1QJd9RrnZx0x5hjnL65Kqil+FbtT703rrJHdWKiUfMCvAr98Q2Gs+bSktunh7b906GtnUR1j5dBfMgoapSpItcdaJu2FfrMPv7Q+B3rrdbJPf4Uk6rE1NZMn9OMhPMBeSu09P3F9JYk05ZGvkata8ZSUwiXHF6ClpWLghKgpAbiqVeaqG4GbWqx7gTP+O2d9qKCIRJtER3Om2JqSBxybcddMyl1XU6sCU4HLLrTthxHARTlqNPgjKZdEjovccQLEITeNImZcS9Ljvb79xNuKlkSRIy8G7oscFUpSvIh8BTzqG8pxa0gV5bjIeZHTIsdFTotcFrltgD20E61gQIuAGvgE7a7WvkN1Gs3GkZFaKg2wazuRB/2kxfpJbCnO71v9svNudxj8t3fHHg4H7jCoerBzR1cYcLQSKay2RHoYfpG1hU6/+9gr/e1e3TJvRveXHTLftoK7/YHMl9H93x1oARaRSqR+wEWjobdMAwlvsfV9bS69NdXXelmaAnkPLc8gQ63VZDHqjoI6nw6paqw3gc8MI0JxBJkO/DfYijcg8CYW6gNBXSC6C8h9+9aEVZ92DnkQVvP4NXerK2yPMY9x7u/+f2t1We362vPN2OoqtVEXGqW9rM1VcW3upKfNnboua6wIvHBZCoAU1foB17B3RZixf91ylrn0Ft/pmohQ54tdfUCaYLb+3syk2kSq43++JtvEEfKR703zdetOlu9E4V0n0Yz82gpf5DzwQiqXHG8EviEyuaReSgH+Su9IlaO1erwrJcqa3mvF1nvoPy62xi8WHV9TmeZHCDd/sJZYa01kcS1qgZlghnGqeIzTv/triNskqeCnPj4d2sONB2iPEGLT36a6LjTYQ6AnPGE6Qhal74UWnFrdx7FtzVFiNu0hm9IXko2WPdCfLoCMXyJNB8knO70ZpJ53IW4lqbIkgFRTL820AK+2/Eq00BcsEK9D7gjv7rf9SjbhTVRLvfQkpMmx7IV3v4d0e6lVOi3UutYaT0QL0noJaK2mc4UZkP6/4DcLaD8Fbehp68vOLQ9SD8ypSTIrN7G2cDex+jiq1p64ESAUHk4wB3yFroCvLrmEK1/B75gZ/Xg/Sw5PrcbQMc51DwTD91TCU8FPbUstTSudXTqnNvXAD1BH78l3Lq0LoWV7t/h5XwMugrLaPBgVkC/9SkfEmw2ph94G2WAT/ICO/nt6C1fQbwQ/auT/Hujup9zrnfYW4ufRWp1417wpl7yevoRsttiIHqVL2whyIH0EeT1sGIQlkCroK94w5hkAtci6nKSUv0J8jSBlWleRk9YakP5QA8xl6UkTnp89AvzwGPmVWrZLbA3dNB7GyhFkiymGTNXXkmEmwfBMbQwx643Ak/A2by05YM2tCTVvgu84jPgYrcQH8rAFJKoDxlryrekWqYbfZuBPvlY8/ZlA9pavBCkWT6ouJLUw/5th+oVEwnxvie0WSK941r6IbDqO3w9vRywkGj3wyWID8YVRcostj+wxLSK+tdfgm9tJsvEomWo9TzYa8bsvIlusL5Ps4hayKOwrSWO0kwXG62SYMZJ4Gb+SROPLZIgxnkyxZJItxiMkKewAEcOOkEyrgWyp3Uq8rNfIMOsVMtW4jJwBPmy1jSUqy1fwXYvgK34F9V8keVmLJC2E9bd+JQ0wqq8Idc8vez0G5w/FMH8Q274LgvHweJmrtkpsO4g3dVBn3Iq9xGACCegVkN/WQLwJrfmJrW+sqJfUeLYaxoyC1HpJA24NpFsaVC+JcnibH7i9qHsRlHsl+dYCGPCelsXPVF8jQ8JQnii2q/S4Zl0v6UwoU5VI3unbJC+QvovSxbbZQSWSD9tbOwZuvex2rId0vjSd2Nq4okTyY2ni1TgWye4ycPsz9z1wBzB3SOR2qEdwHy+RAoHWq5kyzb6ZJVJfRn8AuIOoeyj0SSxniRQMfhHcrRAXwtI9AHc/5vYCd3/m9gX3AOZ+COmfKZFCATs00gTj3jnkY20utZyfCZC3gSxtJ7wXxpVxELi1ch7aPoHyh7MyzAP3Qywd1tnDNJ3Y9h7QeoSGl0gR6RU0bReEDWbvzYf3Irn3DODWQdoh6Xi2NorW+SRIH5X+FqUxlL23A8KimfsEthUozzCgsZbVXSDkezij2x/cRubGehvB3HYIH8ncXeAeRd3RtH5F8I9mcXpwj2Hu8Ey53cXgXtUKGV+EMoxleckGdyyHFQduVTre/sMbYTD3ScdbfefoiewUtYyHZayC8iQwGqeCbCQD2yBIBOPwpFnQNhx32qppegPN333I03iG04JlvlUiTaCY20A+htk75ONRRs8b3Cbm/gba5kTqbpIGg1wzKR1vC8px2G4fc7dJeGcyc68E9+NcmRJZOy/DcgDuFHDfw/JBmWYzWsegPEnsuyenV0L9DyZF+kr4JvvgCVhBlfAd4P3yfcRLj2f9K+Fb7KZpRsGoh8/R6TEQVwl1vx/8cWQPzNSTLbtoWEx6FU0TiXTTI4hOvw/kvSbJULwPZtpN0pDi3dQfVZxA/UOLm6TxHfupO7oY5ca15GDxLuofVlxF044tlnFTGG4spS3TjWN04xndBEj7JuRrVDrSh/GC0RpHabWQnGLM86PEJ/0X4gXS24sQN6GjmoyB56MdO8mfgS66TR27yQfwnNixjz4ndeyiz8cgLT4nd+yheXmc5QXDEjvkd6ewd5M69pLDkJc+8Psg/WVSAzQwPrmjCvyvkAPwRBqqdJSPd9M4dccHZDM8NfDcCU9tRwIN92FPHbTVqfDd9OnrSFFHJbgxX3KYL8SLHe5wOS9eLL2fJ72ctz6QN3z6Q91juoCO/TRPviyP3qycgTSvTVK/jn30GwSny+/1Z+8NoO+tJX70PROpDdtNVIA30FgpPRS2h6jBHWasps9Bxp2kMB3veiVQf4gxlqiMu2nYw8YmqS+9y1MpPWLcR3YD7SDq30XdocYq+qT3edL30XpLSS+UtPpj5CsqJxyh6wt4kzB8PYzbxhfvbgwqJPnpeJ8ET58l2mPWi47ITGjHYdD+wpqJKqxS6hd2nT77gP/NsKNkEYynBeDXhF0lo8NaiNn4C40fBP4/h+XAOPcLjR8atoAUhV2jtwytQG80uDG8P6PnD/QOgdvPJNNTw/uIUWyS6U0AP4aHhcn0oim96yCH1EtLgF4CozeG5XMAoxsQJtNLgvfR7x0m03uM0Ytg9IZRelfJcKC3FOjFQN4HQ9wIk0w3lNEbB/TRH8joJjO6KkZ3fNhy8nd4DmR0Ixnd14HuC0DXyOjWMrpBjG4so6tndB9ndLWM3kSW34cZXQOlm0WKgO6fgG5wWL20jNEcEYa8HetBbAuPrJTiGG1fRjuR0fZieTYx2g9R2vjNkHa99CLSgXrdBfKDAccLeH8wyBhDItHdjOFtKyPlcHTHU/dVmmYkdf9C3cNYOKZZw8KR5rBMOf/LmeyylsYhvugYnom4CuYGDrORwyzjMN/gMDdzmD9wmKMZ5gqGeYnDHNML8yqHGR+rYN7jMO9wmDc4zAmxCmY8w8xjmJNiFcyEXpgpsQpmGYc5O1bBnBmrYE6LVTDf4zBNDHMlw9zBYU7shVnFYd7jMI9xmAc5zGoO08VhJjLMlxhmF4c5pRemmKRgzk5SMEOSFEy/JAXTO0nBnJekYJoZ5iqGOT9JwXyiF2Y2h3mMw1zJYS7lMHM5zE84zJkMczXDPMFhPtkL8xSHGZKqYDZymN9xmN9wmKGpCmYqw1zDMMNTFcy0XphDUrn+yWHGp3L9M5Xrn6lc/6TuMteOKMRV23eqdxpl5JdNgv2/822lr5SuLX219LXSdaVRV5LsieyeLY4YAWdvOO+0R5hvOj/u/C/Lf03XRAxw6rv4O7c3nZGuU674fdMs37rEnVKz9UB+rWxBprMB5DgY03xMqreu0RugG5/xaQnxwRujzfTmaF8YafA5Fvx4Y3Sy8Sr164wwu7NcZbdIj5Jk0680/BFIn2lCnaJy/vMhbKQJZ70gVZn2kj3wDKEneSqleOt+mIPjKi3q/7jO7vGjrgW8X3+V+h+1/Ur94XQNCGbkNpR4v6f6OQrSUS/tt5JQXCaN1vexV3TgTB1m3sURMNNGXezfkHyb2LojWbUdb/J/6Vlpr4lPvLukQD7/XROf2yzUDfCT13WehyfuRZ6XeSPuIrLv/UwWfu/zCm+kcYw3pp1XeCN1M95I3Yw3snDKG1k4trHnsuSasplkzEsc5vO9MK9ymPFZCuY9DvMOh3mDw6RnPRlmNsN8hWHSHU6GubAXJt3ldPNGDnN2loI5M0vBnJalYL7HYVoZ5lqGuYPDXNILs4rDvMdhHuMwD3KY1Rymi8NcxjBfZZhdHObyXph0F9TNG/MUzJA8BdMvT8H0zlMw5+UpmKsY5msMk+6KMszVvTCzOcxjHOZKDnMph0lviaAeB+SNeXaSZUGMX8geSzYpstRL6yz9r79IrfDVxKMO2PNU/+e/Mi5IgvVtSWW9ALO7tyVN+gVJtLwteVkuSFrT21J/0wVpgPEktRed4WetFgz2O9jP9pXnkI3F0WQv/Ir0OaRKH002QEn2wG99eTTZbfvC7NepyUk3T8U9JdQyZVxM90luElyLHIA35fEeCN6Ux3sgxiv0+Tw8MXw13qiH55vwLLRtg/TN4G8GSt/TPZW/sT2VjbLOrGhVZLZB06nLKv+d3ZRNnt0Uu/NDzv15p7ybkujWlzU+dIy+JVv/YwPaQll6COeO+1ovrQqPHYc7KZrlA5HyUbaTgmuClfSux9v0rscNZ9ED1IWEdzxanE92zrgmrwOrtwhRuBM93CyaQyO9q8W3D7lCntLC//CnIpzfuIZDqH91hPNLcGVEhoHrcxeesNC0xGtDDoXHheY+k2s0a77wjvsoqZ/ZCeVOXDXg0zJX0rhfj6oMJa6+MSWuwJhZn6KGKbSsElKKrkBw9StF6wiDcr1L0TrCoFyfUrS/NCjXvzSgFK0K4vuXpc/0aFOhxBUU08fu7WqUNgO3FF1owy6CRFMN0Mg5SyQ9tW3gZ2/rLpEC9WWuxxf9heKHAH5wDGqNPk81GX2bhfswg3JRh3w98O6+pUGANnmuMGrOWbobpEtsSSrAN/vFMMs1xWj7p1F6qPiyVK5H+yYTgHefp1Yb0J1TjJrp8XmE5Opx98DP/lE35spJc9YHcvYw5KymG++9l0jB+h+0gy44gMfnkv14w9ym2Acvkwbb1pBNxUdp6Nc09J26CWRYMepNQtqoC3pgedgCsXXtFLwlle0nHqiYP+ijUsGvU53YpyXCX2jzC/xLCmrV/xf0ndVkn1XVFpp4Etwh1aEpqEfIv1qTcr6XXVS0ifp3SKOK1RpVLaLqfAMg4JkjtAxS7LZFKLQuQJuItC6VsD8UiK0bkvmwMqo9WXS8RVOWuEIj3DElroERJa6wCJ8fxNY3eryT2JpQQPeOkjUwuomObai9Bd4dFONOsbkO7RuWuMJjNtZ9m6yyqwQV0HpIiMb21h/tFPYvwF3G/pDHatSU/rrouJj5BTzLXNVDUMvNBngKkRtcSUM3uBKH4glX74J3jpa55vV38xxheKK9M190/LBAtpFSHf8itRlRHY/vPT4ULU3dzX/hKENQiY6fmHWY6vhMeterOj72AyFqf+ulPLRaBZxbD5x0oKZUPPDsHw1HtQduzReMifZ/5qsStKP0LRl6n5YMH3uDvH9DLRC8KdThfs1A3RMXlHZ4nloHKbQ9L+moFRPR8ec0t7VobIfyHSst7fvYVvzsyx/gjN1txcTPvvhBo7TJoyewlxWTYkyLvQotEGJ7RcsQrP1Ce57xANvtyevpuikX0MrXOckLcjPRowV8XFOZ9AbgxFmfl8bgvqlVZbhHTlu5XsSsIL6ZhrvpeBpeax1PzLQNopaMRinBCu2bno4ok8baZDvCOj32cj+77wOlL8Xq/9r8rHadw3a4d+3shtqZpUdt8UotkPs9e+Ik/bvNQuTR6ypD/XW0I+U6jG0D9b/Yr4uOHxdomvFL4rkdkblETUjzAUFdqoGeFxJnoD1nM4m21QjQgvN8U8JqvM0PmzPi/kl7lHwLcBNwXnlMQn4MI82qp8w4MuFtxoKp18HlpOPEb9jL1ghD611iPo4Q2rz3eo0Qf4ARYiMdFVTbcVTY5VLch1xlrrcSiv6Gud0ALhgjxoWO9m7J9v6BjhH/OKxBvRZPo06M8LH9B+1pyVDbQ3vvt5fiKBG3hY0SKzrVFSG1wSmlbM+9xTneVXNdNUrdgDXxP81q6vLWnG7WUFeg5u/N4ig86RShwbHqeDPmKerThbTXvJXwcTO+i7cgnfRdPGfQSt9FjZISfRftQOJYeb1Z2ZucP6qQ7k1Orn7EWXT/svSzvlw6AS1Be/+ilNnDRrTQMntjuZTlqTGhZebGr4Hr6R0nsoZ/oG+9NHuCOeFwn5YjPl/LFtePl0sLoK0Jer28y3kG9aLqHZ9RDZH1kt6ql3c6a+uhP+kdn2M49AnhuL6VSqvl+lYqwV7UO77Gln3RRl64OIHUXxztrHB9Df5Nkuri15K6fGT1GudLMGbhTrCQXiapoY3Ku5xH5V1Oy16y1xJjPkrMxj1EZ1lINpp2E61F3uEcaTkCUlIz2WR6l2yy4K4V7k7WS2NMdrIIJCetqUQaBfE6mKNstMg7nDor6tatl2IgTY7pGtlk/B7S7SVfW9w7nKj5Ko/uBIl0h7NeGg3px4LUF5uO+uzqYW6zxhnmqoT6iTNPqLGYf1/fZII5oL6P4+CaFHPAqYD6gFMXXMLJU/CbCuEjD2IY1nDAqRgzho52+rs8O5wW3OFE+h9lnL4pxE2ojTP/CHW0ne1yZkMf8Wnx83Hvcj7Ta5dzCakJG0GGhx0hC8oPEd9yPBN1hEypHUUOWg+RN2r1jrIs39IXyAjro8RcbiKLah8lqGFGC+OnyvYCGak3Eb1NIt9ZBUOfUols0R9q3ZC157Zek0FvvXtR3ZSHyAzrZqAMo58RdRG2kBmmLyB+E0V7omMV+bt1DznYcYRk3DpIFt+qp9p7FlhHET8Yq9XWdSTAupT4wbv+1teIv/VzIljr4euj5UfU/3eIHCheRDZetJPM4heAX94mvsVLyAGofwOk0VvRShWeXIBw21IyEtpiALhH1H4BYUvIweOryS/w7hLbT8QP56G36inv3w/+kbdQrsF7tvVSlPUgqSk+QEbajpKlJhupTb9Ehut/JW8chzZz8Vcyshh+F+sln/QXoEe9Rg6nryHeHag7sF4ScSfwOOoxtJOM8qGluFeJduL0bY0rB5TpHWuzB8L/gtlR5tAyfduplRHw/5uVg2mYvrUxzTte73gVT9La9BDzXZ7ekf90nx0hpUHbIEUa/J7SO9bPg9A/wDM1dCyEPAO+uXrHF0v94gJj0NZ8yPjQWJzV69tOvBI+Tkzo/5YwMtG+aMMOaEn9thWBzBK8tW/pRekgfLdAKP9p2xEY1VBHJGqIa5KiqJTYx/5QB+pJhHFJ/4g0FrjIrx14fzykAq3EBL/Xr7z/9neh31ZA/4c2YMVbzNEkH2cotr4VeP4FXUEVqIMTXQMqMmQtv3rUxHmW8v1oqOHEdDwxBF8zDDVy/kBvPMuaNXPoKcEIeqIoh+Aeaz+qnRHpRBC/M6hp80e6Xx8d9k8Wjto2B1agPkHkWaEVTZIO51+2CAgTTHjyYjCEaY2YNge4BmrZRNsiUCYrho0iG604BtIvUJEN5cEZGHyJ4CuQupTpDtS3LQ0eSgyIYdoPT32bH97EMOlhbDtE9tBw5BfAE/MOs3TU3zZTU93Df1Czp4c/xFADfsAxNUkhJtyVx5mkvu2e5hey3iSHq40Yrm8r84RRf2tj3i14evxts4NvQnwE8T0ukRJ4qo2rgBaW4SwxWPRtx4KxtC+QncDz5LJF07LFa671KOtszVDibW0mKpoONa7tIlW0tkAmoemAFt5yNmF6xB5KYDxoawzeTdazsmjlPLeW5Slh7nKEBNdAWAYZcRzqmOYP86VvWxl8jflpvlrv5bn9cr5SaL4wDHVaXoUyvUC2mJpZGn1b1e/k6dTv5GmDJ09yfkSaH2wvPfOT3Ss/V3vmx/FQljs/pVTv5R6L3jEgC1vgOHqKnmsvjr50xUnvaM3q0V4cD7J6tBeHV1aP9uLwzerZXt7T1DC/vs2lcddrE/RJjMfyZJFiiAs1KO2HldvRmaWECexbzKNtJpqoTdhWKqV+qD8T+nYwlCHLitri3Pl9geJ/EryX4cvtdIJmb4/8fROcRTbDO/tNGN4kBYH7VyvWCYxUtO2A7GCRv2durz7lLfcpR0uvOrrfs47apvXqU9Wa3Xz6thPBNRRbZ9pK28oAkCa0RqUdze+F26WR+/LaXn35Uq++PKkX7g7NQS69RN4w6h3hWYh9FvAqpVDENcnaPHRnoM7lcjv6Q7sZie+d2Q9PvSOQylR6hx3KfZCGryUHwd8F5R7J+UVoG7xfn1XF0sM4ZsEwiRyA+tqUVgPpztKya6xZ5AOQgzaCW2X9lYZ5W69A34GZB7UX8CXIGkLL1AKIh3ahMeKpRnjPdIdoQK7bmAacEtrVkxcr4VuOIqMuglQJ/aSPbT3whNvkA+DoZuAVGtRnbbpNknGtF+K/RF230DfRH2LCE5310mwYb/vC+INxwRB2yLaTRIMMhmkG4PqyTc6Dl/EXSi8UwsagTl2T/M5A8GdS+j/DO0izjsoLqC9juM1BTlLJ9hOcOdGSR1GNfHg+7RFwjwFp8SEr1gKEh40iReAfBD3bC54PW1GjbQ7ThlsKsud6SWddBNLgR8QHZK2NFpSXNkGJ18PX9K1AnX+yJWRZuvYtFVp350+uEQwZ0dBuXsIT4U3SI7ZFMK42SQ+hLnvoo4PQj1ofbXNrF5GhxqHAYSHEMoTgmZnBIGmvXRUFnEfXqYmIh/kLrrkdu6M6jpx3b9IVsgUk4wHHfwFZp0waA0/0P3H8V+p/Hp7oX338Kn2+efwahG+D9NfhecWz5na0AXXTo2Z6QFsz162d3spmU7Q0fT3a6Z8yo17x35zt7SbzROr/zenVUQlhimb6Sw2RH0E7SQ2PHbq9qiVDMziFrbBZUdJAeXQPzJ00LRni7iSpQabY7Gzo8q3QtE3Au/L6yTUw73O+0450+1SMONoH5jXuvQ0VSJ/dznl/2yGp0oOpLBO4tR/IMofgq0b/jiwzxCbPhf/7fhPIoyjLvC+59L72Vx+gJpXA94Iq+m8PLm8hiUY88T2a5J9Bfdco56A/l+Sno25s6Aco24StBbkxk3xgRd3auWS3DXVlo9bDSLLfgieLl4IkcpZKMLL0E1IhyyR9PXKLWws5yjqYoh9LEcJkJJRxUKbBGRLKN3iuKbTin1RC8afSDaYbWIFyC3KSiIoLcmqQa5jcotdXvCvLOsafcP4l3xilci7yzhxSS20+oGSVQXJsevkGrgl19CDPRe1VeKoPeVg2zKHwxj0B/qDw35YsAmObwvdyg5tZ/AqSRfnxDYhvkryB5hCKhfRwfMwmmy04zvxCqmwGMhr6bTSVzth4aME8YlrMI46dv7H3UeJcCfMxHC9vwLtymJxPHDNv9sDxyrrVw+8L73B+GKNuMho4ZiK/xHDkl1heHAMJGYnlOYNll3lrJ5T5oMXDa2Hca/akCYa6XXoGv88NSINjbZMknlkNNGG8o6sbaEsR0iPvs12VbWKwvLynySa1FgMRaJ0o4d8FY12h7IbhTZK/5RqMoZ7vCHIl1lEEcDT8hhGkz8VmT11BfYJc+e/l8vv3coG82rNcS7ly9aPlQpkVy3UEeGyP7wmyKuYR5bZfPPU5G9saPRWKc2YsG8qZv5FIpGlcQb4yopx6g+xm/t1GlDdveuLRX6a51cN/D/B5/ymQUXZb7DDH3An5WU10UOaBUL+7LXfIEJPqCs635NzQe960lWCtybnJhtxEW84ze4J6evt+P/Wjblu5dq/m3fSkAT9Imrd6+PGeOueHUf6mTMOIulhx1oCj+G1IgznGdJmk1iin7Q+tOtrowYdRHvCNMn5/Rq8L6LnToF+EFs379fAO5wdJG/BRojmD+Jkk34hS9XVIMwnmSZhuJDGekdOuDP6ARJ9Ryl+WV032n1Fa1r28Gk88pp+tqe3hPwZSD+9H6Wo/xUUdwSOJcOYQi2eSFMXF1kV7NUhbv0FPkFvc12dQyoLWZZNbnMha5SWof3cabJWToP55/w6of84PEs5NoIHzxNu0t6lYr/Ox3SGyZY1fwH8VpJMrdMT1tn0pqU33SDM9b/244x8H8YYdvgfc3HiAbLIiTey144gGR3bLAZAXTpE9tmqIQ7qQV5BkdVR7/E7ytRV79n6Cuq6DIM3X1KIS3htB7lAizQa5IteKPQrP20cDB8T3osjo9EiiM+J3308i05HLwahkBIx0rEs5LBRHIyO6kUtgS98J0jmec6uUDLatxMu0D8JR8jHQshkBb44JpR+UdbB8cl2E26gkZCmDUJRicqBmskAOBAnGtgnkVn1rVTJqI0OJptv59t+EOtWMUtcwYdkTJ7OFiK3UhVan//jq2Y9xB0w0Fx7pb37E/PSdQN+Be3AXoEQSBgXar94HDjQohIZMuRPqe+qmWvX0nb6+gfbv6V0VtP986qao0tud3Rskra87TG+f0a0yCBEbJG94R8jZ4BoWo6b2hc9+JtShHeD121N3my+/9bja7GtWTet2/q1OqMO8BX6M1rjkdfuM4iNkSrmdLCgXzUHO0O4jZHqYnSwOc6OgrRt8P8L82Y3AxG7n9rruO+49vU1HoJQxXm+JZixJPzPudHybj+Wz0tIE2lfRsi3ylE0u1xJPuQrNW8x6+5buZ0BaUcp1+UHjTdHwlPkZpAvpKzqnAE29/fyDppuCKu1O4IhA+/T7jTe1aLVTlWiebg60TwG/t0FrDjA3QVig/dH7mOsY86MQ92qnEJk0A+MC7Z91T/tUiEycIce81x1xVBg6aZbqimmWMPSJO4FLfO3L7v8BnkLkhBmBJFCPqQ51T4B34tk727qFYalnMa3eProbw+QcGR8gAuZCzpGrC3OYb36d5cjehTmS42I7w1kNXeuKBckw0P5zF3zvbq+K0Ax32QPtj7Bydz7oS1Nj6UskNdTIGfbW6S4YmXxl/JNA4a/dwzKECN0Rzx7PUHHWx82z7N0x95qFOrykc/jJeVMEwf44/MB/ZJK7jTD76LPklvr6kTL4svUgG2Ed6N6Sv+2X+YH2hK6FLOebu2BGps83B5Kt+tchL8O6nmMxr3QlmfHLzmClzetKNWPdPGuWy7WkS/k2H3QE2p/tFgDFz/6qC9GwXQbaVV34hlzLrzzAdiC7G+5fllI8e5lYGyualDqf3NVEc2Bi9ZPBWomokr/BaIrcBP5A+4oOrF1fe2NXmSS+4u4NSAvTlkBYoL0/oxNEvyXmSMbRMxwtV5JpHU2yHVmVXEpXJ3ybQTLGgy7ElL/TuA7aEmldPQ19ItD+a6euAnf3fGmYTO3Hzq8gRIjw8XzLMvgy0DZyfqbfsxW+p+vvWWGX9s5MFIT8qN/mnno7qm/RZPyOyz4OfvJt+H5as5/5wNHEoxcgT37s2xzqPA10l0KYqNKxsD2dpyjWss+QcmdzhLmd2hF3MPoyz9DN3ADjdbfzh/uBn6oMhuWBnwnwH99oh7x8AmnEGaEvBx4VKRcU7Crgf3K4/L4PhseEmIM/xXcCP+t2HoCe5GoQRrrOamYMyjVkYBvFtPgO3x6Ro2w6ksp4pjgIWsNE+PJQl2as4xGiuY/ZwuozCOpzYmekeQRtgdD324XIJ2YE2seyvjQHOdLEx1nqYF/s64H2SKAjDsK+OoHFIJ8a0Kn02GeATgLQ6cPojL2PX3PqncAZaDlYby/qmgPuGXcCD+jt67rQ1m+geSDjX3dhxiewXip1YN4C7Tc7Ys2Y74ms9fzcIXPZ4eCOascYpO1rL7iP6YWIAdPdLTTQHtwut6o8vDcO3DrDw6197d926lkJAgH5r9C7Dt7H3sXxhLpHK+U+L/ODXOAHV5AfPC7Xt7hFZ950xN/8nKeOjpCkYtxBgNLMgHqH+heB9ma8+e6LOU3jEF+l5ZtyZyC461xC5FNQZ3kdcp29i9xq0DRPDT8LtRVoz8bamYF1P4XFhMC7z3QodV8BdCYDnVmMTl5Xz7r/uhPrHu/dw8gF40ddZ8/6j+PqfxSr/+EdqbT+3TxpMFf/C11K/f+9S67/R7D+y3GPItCe5pLr/6Mupf5lbF+7T2cQVxtt7YH2O1064JAT4OvATNu2CfdFQdagd+aotaX99NtQi3KzfO2dn/3n7zOByhEx5IviZWRBGO6dL4evsovsKvaCno5twNf+0/0i4Mpye7gBklW1Hr/7KUD67MaERF/7/3zWfceb0sH2pLfXP1ANC/7xMkhh78PPy+DmrP4XL0sBENaHC/NtRLpIz/sz1cQJ5Ini5ob3JW3x3Wb06YpvNTibfwqYnvhTwLfwm35SEE6uU/qxlvXjmb/TjzPbsR9jq0nh+vEf2rGvTrkT5qv010D7zHbsq/iFHuX66pR29/cLsK/vxu+D8obe/sdO7OFHiAXqwwpt42hHz7ZS04G5csfXUzkruRPbijuN3MYe7cTWqsgoJR3YxpCry21M1Z5qxjb8LGtD/4ezd49votgewHfz3KZNkz6A9AGkTR8pAUwpj1JQSmi3bQoCgspFvYR3KHitcvVi9GoAFYyg1aJCawVFoQ+BFuhVqlhUriLaa6ugFChUERcouyY83G3SNL9zNklF7/f+Pp/f74/Zmdmdx5kzZ86cMztzplf4neauC2Fa1rjHBZDfizRVMRHGPsh/gtZ92odzKY7TSPfWPqQHhUgPAT4LZLbwHJ3bTBiItFFsNPSdpR5GZD3omC1ubnGLrHyabb0Nb0B1c0vzGrmCEW5uyQg5Wl04DvR5HGS80yDjnYYvQMNLqiDlFUh5JcDPgPnUPHBKE2liDvRyCeRfMaKRuxPK+xuUNwOo/EGg8unQ+lWqAD848Oc0bvEEdSmkW5kYxmaAl4inrM2AsQB/tP88O9h1kLsk1qQ4ux00gLAtAvlJ0mAqJ/SHr0a/kHs40j1e0AN1N3NHxK/PsqTrvdaJUMpEzgglbe9/lpWoGHEevMgE/xcCzU0B13orbS/wk0YN0LYWaBjtMIfpWHVaboCy/0+aXu7qAZqW/Ymmv8xHWg7TMf4HBmzWP9sYpCULjLdFrvW0iw7wrQE3d8wxBEY8yDIujbsmME+kUo3bHbh3QA4O0ikTotMEoNMIb5BOw/T1QC/S1e90endvkE6D31HKULl/7UVJBWlM4/4kIAMKU0OpS24pNa+3KyRRoKSkce8NoLzoFCXW50Oj5Z3A79R5yR/kbFYhPNu88Aco/tX7R0l9b69ZLGsi5HUGgrIVQWrcn/otdBuESkN1PBJAPSBY9hphUGjcJkZiGzXuxYHwWNG4d/uPYwliijNiWXMDX4EfnNVOi29KA5hGHh4lL4Vln/A4Ccstuc3n2RTgtkcHdm0Eey/Ix8O9CGPChdxEcRLLAxknEjhoUu7h8N3Ag84E+DdhprUCbZeBKwaazx8RxgnmyRK1o1zQjriPA/xGGFEyh5nLBEr9oP+noNw9FvnidnbRAMWbm9HyBuF537md/evAW+L6PojfhzuexLibK7ISnnfh3b1lN7jPQ2lqID53PjirjZOX6blnHX7ul7JrnGy+AP5h7gvHMu7dsg/Av8EdFVekM7l0x3m2ZP7qEze4pWXb2SJr8BZXN1dQ9hj37vyD3M+Opdyzoq2ePu7i/EFcxQjbiYMcDblunx++8XUp3kdXlleSAbWm6z/iPi8jfJJBgzlt3tV7JD5CAvzLqiq4PxltUYy6N+be7+5B+z4yrmK+nKtIVEC6m9Bm8R8DjGyB+9kqQF0fQDmjTqAFlBvcMkcYrmWOcsCBjXtWBXnEdg878b64H6dIFU5TpBoLM+luTq8ax32Oftl4Lr9sF2DefBhb9jKznaUc7zDn2WjHD/BUq36BN5GqX8U+OfgpOAt0zWfgpiEPIYhyeFcO74rBjZi2OyqeEu9CbZaXSm0y2rlS2yS132ffWqSnQfptPRodT2mbZTDquYCeHsp/G8D3gau5zTFWGU2kXOCP+TWlFxaBnLw4utRgA36Vs3ix2koaUmiZZzJxgV8SqNAP5VsCclrblEITblWvnn538Uq+p19P5x5+H8qf5YylsJ7S61qqHOoiPLlywjNZ0WyRt98tyCKl9qQVW4t4Jlh2+eGgjLB+FWnCEazuCKWXvWtRhtLj6K2GNtxkkOvlArzaZkwvoxM6pq0kTLGnnSul9jOQYmMTYZDoI6wRJfH8wz7CsGPl4sVSO64DnLHriqJzZgkG4jcGZHvAxUaA8W1wWFKEWE59a3SOcyWmAZyt0BWVF1UIxagTGKRLpi0hDE6h2Cy+M0tMutYKNlVVDmlkueVFiNOhvEnE5g6PDOpAGMNrKLlmnGti+G6YSe/pPc/mOJQwb2ZymfDug/4tUN7Ry9GkqYk0WdqD6yHawyfYwbiTS+T4o7tOwIywhU10rOEyB/YWHoV3DHwZNvAfLLoLb5EvNiMv17gP9SVakaMllEj08fwVbwejsw6GMKQgJCHZWpsfz3e1GKBH9PTv73RFJ9gYqG/Yn+qLcezroqxysbxPvRKxrl0M2g/qC+FyiiaeWg0ut1lODystFGSTAC9WI32Bf6MvudSwOLlU6qFIYw6RmmJbDHo/SAcp2PZFiw1LFi+B8vRZNGmIt8o804HW7ujHGFCm536ITRBjGoitgpi5nzSorVlAlU9CLKs/ho/rx5KQConWnwGW1zVBWnwD/KMZ8dRDP2upZUCT569qqc+eIJ+Q9kyTfqr7ZO7UJ2aXr39CmUW1SnvWS+8jKssr10Qe6jdUlmO/kktkdAx/0X/0ciyJdBNcS3qhUbWXMCiEmNtl9EaaWHVgZjYdxw8TZrolETXCEHPSoS3CrFnEqPvaFfUpq3Lhm0JYRzd+mE7PdPdH1gh68zSv6vopZcbJK09IR0xorxHSzJWW0d/OJzp0M6+otGRBjZDSLRPI7hohtVvWQ0bVCAbtJojHFXzsUWqoVrJnLSktKCEMBZsEibZqjerQekHSqPKQqhaPTCP3aOVfdRDQQ7PM2bR+VSzfHtjPSDtlPSptgHcGoHSzaTWUbV4JT4O5YTVCIDFtae1Z/aygqTjNxPAr/Ug9MDsuPwFtH5+4vIdULkkNa/sbhWXJw71Obw69lx5BG6FdgUi1Rxex7XFJlqajc40kK7ojAZ6Eu85JZEonyrJmnDp/iXRnj1amKAlJ5k2GzLzOzLzhePKAEKGdXfD8/oWFhIckJnQqe4rk8p7oQW/1RJHpBTvha92a/qzBHc9C+8gxQ7qD6fE9hppuOhaoO9+66Zh9k5l6bePkH5iC3/SrTjCBLFnHQ26SrCsn07Xd5MQv99eVZ4MeL4l6ViCPYO5rzJdK98mTDIbJMSXC6PJoDxn9MWBP6tFKqzqopgrL0C68SSITWieNnEP3PiHNUrf/RRihl1a6LKdan1ibS59qJdMD/A/90uoNgmYA/0qPVsl0oCQDdGMgUolR/2h/RpitByxFqeDpjZ55w7kC75WD8qVUjyWSEmLNLwBkTYC/2A4PYC6mIxue5nbCQE5UZI0UsRdpmjt3btx4AsqZ8C4jMXgY0vArg5Qs7ZHEXbgfSxnS/S9o0cu+fs/wrGOtn3jySfxeMg1TfNJDprzs6/VATdpgaoBqBzlGNkLh0So+6CD1kY0on9gmx1OQiyR7JDEpBS8D5j/0uT2EL6bpy/3yrC2tRAqZEq5V1iONrIYUSW5S09lBZP3Q3sJk0b8yRvoUY24u52wO5INukGducJ+InGR9YyPIaYO6cO1M417qldE6CKEkuAB0XaQ6Ey0vTuS/7iP0UpErmQ+TelyzydDGU2aRrx7kulW3lHU6WNaUW8qa+Ieydv1XWeT/KqszWFbCLWXF/aEs53+VdRZ4zHlWIv6JxjWk8d4XJ6MeSTWjDCwLydPF4moAdYu+fGue7tFLLcBbimJ9kpt7CCeMqXg6GmaViL4RtBLm5mR+c+B2+i0iH6iRiFrg3XT9DUtaJ2hlqQu86/r/XpjQqehZF70Wv1ILvBu9cwvVnW+Gdk33Xg3uFaU8JPViAZ6aYxno9ZwfmSgPGaUuoAq+Z3JBInRvCPI3gOF6ZWM1oaB1NFkZT2tfHsr/2yerILcO5T/xSUT/sI+sklYQKbKtyXx+gKySbEUYJ0FIKobGB7qEqO7tbJ3jXWI1QIm7JwDSviWFeacWJ2sq5R4ZdZAm9F/s/8hS1PkjjfsP4n1SD1mgAN62DWDsEFcevnAg7RwEbSgoRcXR5Jhv92+x1BWALm/JaJdui/PJrpPAu/8BWFrgXdtrLUzq/EEgKr4TiB1FgqyBzJ4myKo9jA6+fwO1RXR+VBiP0lgZ3n3TDbghs68BPkwFexnSvLfgaMFBJpXOpqVbA9AK01BVpaxaUUFV4rmSp2Z17N9kGXuqS6C6FycTqRGVD9OV9ALvC/xHlsWdiq2yamcikSGvqE6kaOVrNULykSWFszqXF+q/lb/5vUAc+QwcjJqITQP9dG8h9tCETuyjN8Rbnb8Q++m9UD+ptuls5JjIgk8ZsQTnEXBQgmojlhCxwPv8bwehp3F/PO5L8Io9/YUDbczVFhwRS1heeKRT+SY5Xvma/M3RBaYC+WvGgiYGT8Fs4Hbh3yDHr4yqOtJDRsqy3yyQ5b3OKKrjmnRAe0e92NPHvHKxxyFWpYAel0OPF/XLq+VvqraYCiIrH3JLpVKfzBdR3SaYG41Dq4noylrocbSfGVOxxTK7i6qmtuFZh885pWNOsroyplraQ0Z3XVZ9NjtZ+TLaCFNu22TRnFVVq6sMBarKyGoplEvBk6qMqr6vQFFQWxBV2cnItkX1SJRkzwZlE/0Krdw2u1DdtS1E43yo5ciD60TccUzUNhwB0h5KqSn4Adqr3PY5jAIyW/ly9LZ3Cl4EXHwB348wKDND20S6Pe2/MK2aeGsY9LrHOU3mI39TbI3YTk7KKSCAxqhKTfWiYXOmYbiRiKyI9JHuqIqIrcrKWdOchKYCcEGsmaaukGx9HNKsJaNfxtGKmJidPLtds02yVVm9sIAswNtVqa2Ij9nDIgCaiO1RPST1LxrhfiJZ26HaRlUpq1UF1CuRVfMLIl+JqoosGFEQ9cr4JGXlpoKIqh+Y6B4JKanuEpIryGwp1PQKfW+h+vS2EB08zIaxEcjrFOngVyayGqnkE11UdUIBjK0ydbWIjSlbC/b2yKLnFXwi4kKGPd4rgee/e1NBO5aDxHDAn0pLt60DvWGvH6nOSStomYHMnF4Y3w6jb9EBurJQ9oqq/cOrpEpSGeH29ZHGra1EpqRaVuVhkBZHF1xiyCrt1qm0mn9SyAfaeq0XzzpL2mdBuKJXCvVt7lXA09Urh+eGXpCaxLkIzz20sxGOCjZ6RAUrB19V1s4qIaxJrGAjre2sApw6sZ2NykvlMk9ncor5i7jNZUu4ovkXObLstcY0Lm3+Qi6z/kfuWdAtl5y+yK0rW8alzme5+rImbmHVZS69bBG309XOyuZXsNT8NsDdEi69ahlnVLWxirKfuCzVIsjbxFmucFyGKo17tj6N25nXBHp4E7dUdYmTqkDbdu3iCNdCblfZjxylughlZ3IG3POu+pmjcA+k6jKXVback8NcM/X4VW4H/kH2/srVwrv1LtwDj3vil3Ep8J6uusjtcjGcE/KoXBUsCf5GVxonyfuJ00NcAull4GIBZqkrhautX8htrF/GqSBvvqqbk0LdtXlLOWMLB2GAM+8CNwLebcxL5yjvLk6fBzSi+hG+ZXD6llTOlNfGKsve4iLzFnMboe36K+9wGXkGrvb4Xm40vHPmvce9BHnR5u+mvM1sZF4m+G9xe/M8XMGVOsi/F/Dh5gqvbGblgBdbHsOtv4L7A9+C/B7OBu81eSlQxg5uM3xfdHoXZ8irg/pSuLSWvZw8bx+3C8qNg3KN0ItSSBcJ/o6Wt7n6vEWcs34vNyJvOUfVvwfxpdDePZwL4NlYv5ml8tIAlqWcc/7bkAfTQV8A/Huv7IE2LIe2vMVFQ51FAEMU1FcP7zLKEK5Gbmni2wA3wvEe9y7kjQIYtCL8uzlpYhq3I+9Hbn0Z9EEZy+0EGnGiFRW0GDmijY2HfqsFXO2CcWaAsDHvMqRZDjhmxTgFbTE58GTvbu4Fx3LOBWEDpB3taBNv+37WsQz65FduPbyXQh3vOn7iXirjOI1jH1fvwF1iuOMC6nB1gZQAtODC/WyXuRfKGG6Haw8nF/esecS+dZW9w5GQZqOL5RrKzoOmthlcI3dpYB2pjVWXxeGahWMDV+tQNJCefMn1q8FdFD+C77LwIP0NbsRdeCCNgFRjJJzEzdB6prb5CFpco0d1bmeHONC6aya3QxXhlvefBzzgKkc5l4HnLeYDnPNtYnwZzC7vluEOlF2c0xGyOjf/GaDzZ1i5+O0LLt3xDIy5Z2C8HYU2ag/jmtN1WfOUoO6MfCys28pwZdiV1dkOOIARX1bBKtESrOsX0JHbRfwEz5lGuA97kfe4uWLXFvE0ntJ1glU4jrIKl5FTwjsZhJWO3dwGCEvBN7rC66nawxXwFUaUA08QIq9B3wk6sBNKcEKuAL+/ldCXFwnN8hUaejBNpD3QdNAS8a3JPiZJ2fMMaaRxneJBu6zgGqOnhcOhNYAVCPvkJoNdT59ZgbVtLVpi/40J1gm68goi7fYmk91I4xqGbNo7+x+Er6jJ5jbLVqjpsWLOpBVZNObjmdz/o9z7/qtcXJMg3am9klKDjTAYFuLaxFyQeaUrCI9WEteUOPQ+u4+JsZXaUM8lUqUrJAtzmkBSTdPRd9krigw0z2jFtRapuJYU4K8GwmUE15CuQTyZb+wPriEJ4h6N8+wQl3zFdnZwFThXND0EcORv+sgy9NvxvfFmgtPm4UqaHjjrQe5LkbbUJw4C5OEVu2IV4qF6RRCLPzLbWZkK131kLyA+h7zfkdv29fSPwd0B7dDHNd1nJ80+prxo1OXrU78FyUhGa+hBqI2ON9mfOFDbIyUdusfvJytnZA1ul50qzhreTk4y2dzMXVnx7fOzhA6yTgtYMvUeayJpPbSpPEBWm2xExnmGbDhxWUIS7s6AeyD8g/fKQPi88DNjxlWTS+61uA6EdCHTYyjSjnYoIm3BdaFkfriIIaFZmoqruVEghSqgzgW4Yu34mPtGtII7BDCz/rpEAjK89DugvO+Axh/jmDIlpx2xjHuurAXSdaO9aQ5vHPjCEeDwDPNuoNCLrhvcMnGdaM0J95/WJJe6KlmV6zs2EtIdE/dP7+DQ2tkXrn5xL3PwzOuCE7/dEjsmnnslUmNoM0AZJZCpRIqZRhuzpFsujMNxWP/zVdJFZJqf/MBS0PkqqxGtiVPuNYGTrNYVtBpeAiPxPZ8duB70qaMeICUn2Lk6F9oG6ebsDvy/9yrwKOQ/wXCsONqC4TjHSeArAxagT9wI3cd+AmFz4J3s7wDP0o07zLih7ZsYhPhdBle2SbMgrmfK6KE04d4JFCorzRe0kzalZtFR/JS+4PrQEW3Y3qvkhWS6uXEQTRhS7fLKtbSLJvOIEbFnGu4nTL3tqkln9g82yU49Zk31Sq+fUSpOEGl6etzAn2lFg7y+vMRIy925ftLo7pBXSyeRpqunUu2K6irLpTMpoMUB1QQI40/tc1NxvfTjgJwmjGfaDfZI06nOyAZJpaqBrFTui2ggKvNoquGvJXJ3rF9uPN6xnb3fEVtPGBq5Ite9gkGr5CoSBWg9mYM4k5vwjOq1jmANu6CGpvZZYg2bxRrqxRp2d2qhBg3UoPaYqWiow0KrG4qgju4+uXFrxxAof95A2YxY9sY/lb0Gyl7fPnYPyPvCptvPsxNdREaNUGA+YJnbOUescW5gPdQ45cbD+7DOp397cJ+mQVoZDTWrG0BrXo/tGgl17upTGJ++8dd9XcBJsSUpNMxujnn0v4E+cccevtONQwj+DfwWT5shTMG40oE30v8ep3DH7C1xPMmouSWuchDupABClbGPHL+LeUOfzC/ok4lwDtsX03AXXQKjvad/CBNB5BN/B3p4EhzylxfBR/19R5BGpmno7Y3ZJRV0Iv9dr5wuPnSb1Vwi0cfxUwX8mzccx/96IuOO8hH0mhQ7vVkgbIn8g16saWq7HUb/4wJQRmeNQJinTkow9ZyqEUhznonpWEXHC+Sk6kOYZrkgo3PBXyzoC0hzfuHw74JrtXF8tGCEmg/0HmP0pl86UumX6VjIpTd52+MOyQRy8lnmrcLTncWQt1AooS3JME/wnwQ6mBVQXhJ/LnCAwfyVvXq6Dve8pMZQn5+LobqhbT3gnCylKi86UlZe5GQjVLdyLmIz7gUE/iXy/vyVVFMyaPwiH9OF+b87yP994X8IIB/ADDCUDtqjtlW5uakwty50Aa/0JwRnoUWLFw0pPcrKquYI6cTg0u5FjcB5gJc5LqFmKKSbDYtjSkE+qNpqwRkbZ+otrU5c7zIn88/4TkD8pzLbYj/08yvEEKDaJF4SCM4OOK4Rti2D46lZMfFUfyAw3N2soDc3amjcWREvcoSMft0hIt1Iqxvdh+VApeERiONPUU81pJToYTTP9smNPR0j7HIYxcwZ/FtGuG/4CeOP7YkziLS7hTStojaJtwZ0TeTYQSN/6zjJ5AJ93ebDkdfejqca8F6xD7gvEnEnqcB9oaoR6ZtJhHcqtMpvoBdyuxNTuMxEG7dbPM2fR2cDTu8PNEI/nYJ29IXoUdvsOCBZKekh0arpgDz0QFeFYMwvcFMyJ/jfglQU/nJP6Is+9EUy8GUmftFb3E4JfNFXCFkQlkA4S//EAelK0MhjOm6pIR9Tm/EkO6Q2d9xSw8TQl/zQl99rGANfssxIQ1CqORiWhcLG0HujWXt418kgjFrZdmZPKJwv28VYWoNQkSJUe5jPTgbzUdKPmOOhsF76mZgOw06xvON4Pn4qkYqaopqOoWHsuRv7TrCyehs3or5VtNNRXB+6tcDlgNnEXh+eIe31OL9h/77eB/LicTx1CvLIcfxuB8nEfjyUzyHOi8clodROSK2o13Oq+oOhsudi6vo/pK6XhlKv6GsO/RPEf7nb2Sst+Zha9YfUVYRhO3vBYXh2NJ1F49sTwkjn1sLRnanQ+1LofRLt1petAu2FzPkFdIdXQJZ+jHu+DOWD8Kx/EPzg30iMFbfiXAnyfdkpmCmL6zcygI3jb+CzvhFmzdKqo0y47w6CtpDv+WWt2PKTa7gvQM9Z7jrI/RKUEU6BjFC2AuoOv8m/FrVuIsQfD87Irs+5zJYtYq/IpLizF8sTd0p0Bd9KxLfn2Ybj4K5sB/c4R53O5Y55icwPCgn3T04D0KAy7juWrPpOPPEiOb2KywIu8qCK4eqrWE6lWsE1wDcpaBd1Khw3Yf0k3/Om0821OW5w/wnZTPnA+Ti3pwrvF3me21xPTmhjwvAQ1w+sDYfzPU+tzQ3u5ca/1aH7Bv6+dgJnL/sX0MovoLnf5PLF9ytOZHHUAD7mIWZd0AKx/Z9zu1ucA5jM6ML84bNVxLXCtefZ8jDuxHeqU1Ar2hFpCed5+uaqfQuYJrHMZWVrIN0ErqTsc+65FpbZfWJgTF7PXvsPKDts4yH/ehbEa8u2s/Ncj0E7AGaRGoxcCdJ8WVB6gtyQYoYI9ykR7jXcl0A5x8q+Bvm6yFXN3AjtcXmaL9tXDuFG7m8gz3nxXgMIr4Lw975b8Qvvjys6nwbslnMljse53VWlUNLYeiszkVtVdZ4dczyXiwAJ0cMRVRfKPrSUdQ70rWiZZdXAzQQjsJ9Be1OVIaXu5hocz4o3BkQM8BR91z+4S3grQxmMIcdz3HNVa6D1mRBfBrp3BpclthLeq+a2fiHeH7GqzMxlgPy51zuRI1TPijeXKPEMeFkuzBsw0sp2cRsAh/TA/SKXysIjUbTC4rgI8g854S1xXbBqW8IduB/i66+/vuOd8n9OCd+VAvGPh4Mmu4CVzyfSu8tqLfnXNjtfE0/VfR7kt1eeVY46i3XjHRVEalgXn95KGgjDCZgRwm3UdNlW5qJtImjnsoE/rrEn0c4DmYrrowtX3iPIIicWULYsUU+50UeOO8oQBjL1NFDN8vkHuS/EXQ+ftj6GcpwB8/zMiGcf+AN7kdKGs6NdY38J1zjl5j/3dv4SHgdT+P+E0kxwJQ+kuQD1bygbzk5yIT2GaQtHQZi2ptx8am8Wp0A7SGW/U9fqX7As4eJAXfw/9hb+8gxLtYTO+K2VriD161mpKqg1lTcTBl0GmS5ZEb/mDUtEJ5mj8ElvxD4g90puqOyp01Q2D1N+OCyLECuoJgN/uhelji0Jt8oiSXxZaD8Dzgco20tXrGtEjXD9AeuB7azORaTjusBMt47Sr5CuabAM7qR8coJssDxFPtXGkq5d9m47Oa6xSL+ihiVV8O26LEdXQLhf6c0FbvAzg/qpzEy4Xb1k6gbcaz7w19y9NhH0ZaSLsO6xVNS80xeiZIJwlje7GnHPQzw9M1VNyyoJ9we9Clon7i1WNZYfNoHsLHTKQCaJAJmEQq0AZBJ5vaIhqUTmpgJy4+WOLNDJCPe+XsJ4oR1PMG5nB4kyL6EP61FozyMoBWMcT7sob4lLQnJ2OC4Vzzb+Hpc5DjH3JATlDndzPP1S4xyAdRjUuahXGYJVA5KTya4BWNUNssqoP8lQSpChhgG8jf1KIwPw5kLee3tRcsKaoA8cyuqccqwxvpqqSizHegl9EHLVnyCP/BPkUX+CXP0HyPeD3LQyBPuoy4Ei3NsYlPuG0UPthDurlzpEpBV3Sxsk9ekg5cncf+0njTc7skXpTg4w/treJVA7dHqVjyAM/CeCEqS5i+0S2myXCLKG9IJs2pgY4JMCtYeUnmSVjJZU77TEdZph0pdKicq76HqPTBpMszBAjlV5dCrCeLU9lzbw64VPmHh9Ej+sH/WCm+1WeirqTYIMKCQTKESGWsQGonU9wI+0gqsZCqB06Rq9KeMUUlw5aAinDslppN3sFZFAu/FIuzHv261Pue0RT5ENHxTtOPRQMuVTXjevCFLtPYK5SZUm88ll+tA6xe10N/OQm5T9Bk+J7DoTXreIbSIMkTYyVUuHRqS4cpHEf+oPjidts3S6zEakHblMTv3Upj38EcAY1/yM/YidbNhRhGNF0qg9HN79OL0VralViCt1yNsxLFOFd2xSJypg5IdjyDGWq1DXqIC054Gew1wy+ex5Ng5nTDE2BHOV4frcQXG+1nq1Z8OzKa4gBfN83SrXI/wkOAk4aWhN5t965xRwrebmSDvuG1J1pq951YL7DSQd8jV5o6Tt5KRIm5tB7d58uLw5yh5Np9LqFDlQSSBgPJRKq1KMEO4N6JsKk8jJS5LG2khz+WEobRJhos58ej8xorddNYJsV4+42YG1IxSoE+E+Z9AzA7VNWHNcp2nNfJO2Y+WaPJO6QwsUMchvBNwDXnM+syF/M9glkww20GX0fUDPPyPfCPVFX1+wL8qbx4t7tX7kr3nHll5YNBY1q1TcaRANs4phSXbpziVkOpEh80yXSlKPXh6UfmFpCm2iMxY/I4y1PSOMA1dgO3o5bpnRKvPYiB95R5+JTqHTIVYOsdVizAAxJ8SeFGN6iFVA7FExNgxiOyD2NzGWBLFGiC0XYwkQOwIxmxgbDLF2iP2lLwdiuK+nG2J3QSzWijvK3BArhXat4L8CLbL8cEFicM/OXPCdzwwjnlPEULeDKwe3GNw/wdHg7gY3CtyIq1pqCTgzzCBk+rONTlarcgpjzU5h3CzxjJcJd/9reLm4jx/3B0HbZ+H+a7X7cTxXYepegju31e5H/Pql8kYz4HdCcwWUgPsrpSbNqfOXpG6JNsOSa9bwhP/tVYThBQvVus4i+Rb3Wo01SyFPOzsJKHyCyIluhOa8ayclhkQrwpJFK3C3wCVz/nm+6ON21oD7ulTBs0CE6VyX1ICpPnvovkNBuEb9Aa4MgCvCepZpZ6cM5DvahXvRCswyMafE2sZQgK9UcCPBAfSExLipldAjHWJbSJP0VAVrUvn5Pa1ITfhOYgruTsMV5NROqSmpo4LNEe+q8vNVAVxZ3wJxP78lAHP9gGW8YwP3sBW7gvun7besnm+HGTQ4B372kOlQsJatwAu0KqwV6wti1tBEmpLaQ6vfgNe5fWr3cf8JNtaxhc104SoQ7o/bADoxWv0N1zpPXB2+wFSwmapuBltJ/qGVUlPEqYOcbWCvJUquNqjZzU1V9TLAX8Q0qlPt7G0wD8kG7pc7FuJA4n7K1COX8S+/JIqEkORTKa1beHyVxKZ60IJrIoDvcWbEeWiV11ZqX297wf6ZzckqxTYSBhiZgmxSGv+vfsJwYeFM99ppF2w7bYttA3JJEe6GR20adO35LwPPexn42nb2qgvc8T/f9PR94zA6fM+T1FBUGb7rqbjyjga0hlZSqfasicCbOcK3PsXZh1XizU9KWqb//fanqQO3P22k24SKCrzzCe+Awns8wvdAtbEW8f6nsEU0vBMqfA8U3gmFq82vALxtbCE4uuxbmINRJ8U7ocL3Q5GpHtBemkTMLne0XU6VWOn0WlwP2szmW9vYaeAKAJ7hZZtZPZSS4viYP+Sz02kwM3axRpjTM+bXsOllXWwmWqJzpXO756dz71ahzYxG0DQAppZdAJ+idheX0QJtzsvgdllf5XblfQAa7QSuwGHiVC1QN2Bst2MnR7W8ximqdoOfwaU7LkJaN1fk+p7b7cJ7EqFETJe3C7Bt51yuiVxB1c/cRlcmRzlWc7K8d8HfDbrNBXjnDq5T1b/OZUJbSPyvW5/Gf+bHua9LtF1NVRk5p2ozq2jZzb2g6hIxpXTt5p5Hu9VV4b8dzmuR6w5yV4Ja6zVqHeUuFG+PW8N9fTyqNo2v8ru5q0CbdpE2t7N2KDnKJa5UDOgFaHuyjY2u13eBNDcf7ZvUsMqWGlFGEiVA0IqWnl7GfdHSwClPW2szua9aLoKGijhL41f4ocTTbay6ZTMb3VJSPbJe6tHL0V5tPC09SuU0WFJpvkNn19vGNWxmx7k2s+PBTQCXC26iC+/h3Aw6wWZ2MrjbXSPrc+uq/sedX3fTmjbre0FLeCa7wYYyWw1b2gKyHMBsLUOLCl3snQD7bMD6Cy3LuQYRyll0DTsdtDRs1Qz8b+3qYmcBVT4HX3e7atiZQCF3gWSBuM50pfGBPryL1M2tBPxHtYTa5qLcpb7zbAKM9oSWgVu9PLPXQj+eNnNRaP0SaOjBK6GzRKcncfktoGtCWCveZKl03+szcpshbYTqPEifm4EGTFykaw/Qtqkb+Rz+r3zv35kT8BwHnudYWfX+HaYN37duGJx1ZMrFzLwfdjZOebrMeWR9b+qUrPsXTIldT+V3/udpdEceio070vZWwe1fPjY6//F5xz5ef8Saj2UuAJwMZ6NV4E7jHqXhrMZh5JRQs/p0A+jNCwDaDJhpENLnROvpCKnEt4Ad4kBI7UDZoyDtBs4JaZOgrCRojfr0ZM5+vJbbfZrnohygQUNe4nQw789etD6Syf3nyvdQHry/0gqUj7MZlodWe4azJvHmvgXsSNDddx//Gsq+KlrIbWhZwJpF66gL2GwHwOcycitdz7ES6CXaFT6zkn/9fSdo766gHcom50GuxPWHtS/XpDWEKd+923mAi4ZZ5y994VM35EnSMKkcvy7oKKEttLX2Y35HbxdrdZRWZ1Sihjm9OrMSU86obmPTHcbKjLr86y85Y2s38r/5dTCiPL7XRW0iaKfjdXFc4on7uJAFgXjRIuoPwM0wbq1Fq4Zp/Pe+LkiFf+3boK4uSBEMlzrQykwm56rfzE6v72KnO6zVObYbXBnAs9oWbN8zzhvAqzAsWqwXby3Fmw5/AF1sBfCT7yF8icsS393TiCeIUPrHOdV30c1NdwkXw5I0dRJnZKDXFsDU6UZu5ZVa0Nm/CsnR+H4yfAe6Pw01XakS9W6MXWaGs5WuuUwTJwNs7vcdHFjfmb+PMNzDjATsLPfPAr67KISdkbdgZxzER4Wwg7sVxv8BOxMAO0WAnXGOoJ1MxM74UBixMyEUnu54iMGV/bUgx6I+DjNjOu55IzyUAvewyR+WeXRKM23kN/Xn0o/wq/qDUqxW3DObS79ruwja81Eh3vkEP9U/0/3UnJ0Ldy7auRhPrrjXCs2o1w+GfLP69fQTvNkflUIYHtGZadInLVT2rI9CW65oOeesaKltg6PCgqs61zvIHKmppwP/JhOpEpvFts6G//Nl9CA6GiT1mwGQoWG+3mkbQRtAQo2SKzxRAGUMvQkt1Yo79L4Td+ltcGywkJ4oEndsuTtkwDclHpnkslhyuSj3D4a2DQM5wGRbaWuwoQwO5REeKAVLeC1UylrLBREuI8i/blFKCjQ+ukdGx2cbRelsMLSuvT+Ljq19gn+wfwy9kr5LSNbMtks/k+6rsOtsq/bmQj1X/GV0bJ2ZbuXn9YEOSpfzhwLhWw9xFsFbDvH/alLtUVbueIRv9idBea/2AV7vVdQmv65/3cgf8xMG5etptTIPpVRUUpWP8G/Dmzw6CcpNqzRWtvIj+oxQ10F/F7tK/M+WRbexj0KfPyjGIoA6HoPY38SYbmwb+w9HOf+oeCfoXBbtY6lEThZRh+3OhbwqxzG+ri8VahgF0DwUGF/7CG/3JzWMr59Yp7NbYEaZZ6+wvWzZap+1UOqJkt7oGF+fQk+BtH8JTKkfVVcMoS+9UbVGvsy/HeQ6XP1AOtXUBm19KsUYzAfiukcwHO3AU36Kak2lslpbqamnqmMqo+pm1wb4k/2z64vr5kOZ271p9fPrFkOoymsGGhvmX1yfQwctVm50RI3BPr8LMCrGcqbhzZSiRZKNjv2WabhLB3ozBfrtCa8J9Mh/7kmmpV+/Z9HaZtsMtMRDSX7r0Nu1tqfFtSP3YaJVdSl56sO3q+4I000Z/7WAdJNCj0GakSLN7A/RM+LuBcu/IRSkmdxmNS2DHAcE/F/7Oa/2EYf0Nlx1EuXNaUhROxu7Lo+8V0b/cJkgtYmLe0gSV0cOFBMpJYVUa37h5FY8GQ9fDScua8ltoOFUWIAKFE53q3P0tqja+Own+Bf9UXVSwPSHfYraH1iZK8Av6N9Zqqi0Q92PCjWg0yvc/8DTk8D5ZRB+OGDkCBWMcQp3e1hoRZ22Fm3fBvji/gQo5+U+RXUC9EFiZQL0QVKlto6EPngqsJ19CW2kiNRKQp42CH/Of9GrrUuA7xsDCdVk5RixtAC/PJBQW8aPF4J2VYL2bhLqJLXI0T/n9/RqoZ4HoB4t1BNTqYV6Yiun0gm1rfy/vWR9Ql0ElJHVvwVyQovE3Mixg3vVg7LW4JOS+gix5kH9CTAOjvGzfQp4g7Uf9iNMFujnWPiWD36E93Uo5zxrG1jFUJw8zz4wsIqhObvlFhvW+Z5253n2nt/j1485yVA/IB+ctMJgOyn2SWyoT/7x7avCPNCqVnci5Nv9yEGRM0pqVZUr+P2BnlWSyjw6CN2rfsTyOV8EYFklYjlSxLIUvn3Vv52dKO4fQyxLRSxLAWPxISyf7E+olgKWgyUdhP5awa8PBLEsCWFZEcKyV0As10M9WqgHsRwJWJ4oYjnWKwUsR0EZj/kV9VFi2Q/7g3jc442AN1h+gj+Pxnqf4P8G33IBj0t7T4bOTkwA+o+niPT3r5JAU98EcG8Xmf5B4W8dMk+aUuYpjtjtiaKiuonWHc+ReKVv60d/j5tMEHoLymUW29LbPxBz7r8lJwUcfWbhTx0PNBGGnTbAIbHadsD2BB/tlZfuXAxzzEJDeFV3PWEYHzqvi2tyRLqS3iPIZm0WFLMS+U1CII3wBCbn0bkFJjqL7p9WYVF2kFnmDokptyMwkmol0sZ2xwrkfaNGkR1k9q/MaPRzephHRik7mnXvFf7SOWjN4lFU65G0H5nyUdr2v4+iOg7q3ilUd8aveXxkfKszjUg7wTw26tuO7y06KO0/TH7a14wz7TgjySKhljZGCr7M9CUjy/K14+xK496ncbl0In+7kF845BQxaswZSUNOATleKsjul44m2xWjTR01gpyoEWRmQpZ/RWqrERRm8PX6acO7JaPVp4YIlNk86fT+iBGqU2XJ0Ip0ec+zcmlPoXzUftyZ/g1DjHqrVdJQnRAsFWu8xhCjv+kg9MF1RrTds7yVaF2VGFzLJNKdNPEqYi6B9wQCaUXDLHS+iLOHrlCK/29Y22f5v7G22/L/D2tE5h0izvLpBH5n4ANLEuCMOiMBTMlHyzrCuKPuV4y+DfAmA7xJB/AmD+Et2Gr56OhTOkGpf9tjlnbuj8iK+C/skRO+YrB06IeOUSMi2n8vHSH4lcH3evoHhtCfZBCHC0M4JIrLi6oscVQMrm3C+0MfE61vh97Xh/w3Qv53If9MyF8NPvkW3slQXnR8r2fOS/GHZ4Xj9nua3uo5t1xB6IkUXK+kmklaWjyE1/ikxYcvUflDeNWHs5PiqUfBkTQJXyQfroWwiibp2CZM6W2RwJNvIVonwfuSgXRcS3US/pupEaLMkqooSD+tSQnvf/Km0IpiPGU4hD/bIguFfoD8LKSXJsdTKeCUzXiT7ytNWE8U5PrCi3q2VrS5M0OQ0FRxJC1tfECQ9QzhD7VgKnlxON4UKqstKVhWqlgKwvqOmJIs7mXegm/vJ+E5xUF0Il0jaM0I4X1NWNfL3n82FTSlAm2qivGM9BB+YwtVfI2hirPoYNzZEt+UAjXiTsxgXRNCcC8E99Qf6iwbqDMZ0o0ERxjKm+NsUXT6mmWJBpocO6PpWYvQkV1QsiYPqJJMibHp1pQfnqLvE63+b2hMtpMjiX3r6Y30K/RQ+sGO9YQqx+BWSr8QqPY9PVL1SjqDfov+qlDZNfPK85J5QhbhtVkKHDbtoZluMmJct2TNqBFDO5SeeMlsOn/NJFuA/zgwxTim3WufZF+zYp4g0U8TMvTSnufIR5KNTQ77XXarDXfs70/G52C6gxlD9zJYimGgFB+UUg2lpLU7VvjsqiZMie6rQmkXQkAYf+nYWag5S6T9AFC+0WSykzkm2xR98oTDKL2/BDUS5PiLzBwhTV8MjhzLMDL6EpO3ymSPtc8TDGbVobxVcbag5Z0LDJ4U6G1PBBh+65i3JghFgJ8fMNmnGKUeUmqydQAkxIj/tGNezEmYfmwP1nqUieY/aQ1cleqpZqlVVqLll/hJfRTf6iVa34C+upIVQ5U34585Il1GH7lMjjtyWZojL8+ic1N15gT+275ZqVn0Dp05I4H/um8MjWdOdxAJ/Odi+KjQPkvmOQXxj/tkNzc+jDrMMwI1+xPxnqZND6Ovy1CXHhX02WLem1vKE/jaYDk3d0D47b5nhHmztakYb4R4Vd9RoXw2robjme9NltzmadAOGR3ZThqk5TnpBb/pbQn8lQB5u7LDZtfy3j5ZKZGaKEp8iyEl1/Eb415C6CeI+eS0tL0rJbo4gp/YT6SpS4lKckv+tbNzVqeSKZHFWpDmdljsNtXpCKuyRKLX8t/3RfIv9hL2fAuubOtpH7NxKIylzzUinp5xx1AVwrxsiVUqpm79iGh9f2gQh/iXIpqfJRy9PJ48IbRrASuSlCZKHOEa/s6WGBgxGp7wAsaIRq/TnR+Rb8Fz2B8YcRxqSo8Il8woyxwRrpqJmxsfRQkgbpqMlnZE8+kC2pZShmB8pg//gH8RkIvjM4Ff0orz/uchOPRvKYlc6M+n7oIS9VDSaqUVytQTaUT6Z5eJwgBfH5CGcha1EmJezAPzVJEM+mDjo2qeDQRrxzN/kg6sbW8g6c7zwpNOcDuITDwDY4TW8sJLIJc9Z9F+Z4eYW3gepGlnYcR306/NAsrRBe6iNSLEpj60/fHUnKOC26yG8QeUsRrtZ2HJiwNK8Uy1ltf1yYsTeH+/OJtsGA4wYXuegHblWzTE088MI8ogTDUrAFduc4CnAzIxJ3JqLd/7YbAtn4VoetTl8pkvbC66ln1XpeW5Rvyfkd9edG0MxAj3i05cbTngfBn0peDe3/AdIZQipetl0JvCb2K6Arw5gHA+FLjbmk1L9Of4n3vvss6BehUAZ/lMLf/RhwF+WGBm6OvJ3hnWXxm0lYW58gLW0Psve4utF5gOqPFfHCHKnVgb7uQbwlXk5TSRpontuMJOZU+xKrvRvyOU873eSdYJIoY2+FaW4Ug6eVny/NHL1udPXpY1HL08vYE01ML7XBJGUnake7K/7bKkAS3jQP89PwpKUUApz/duYacnbWGtkTh+g7B7+W9bsab0UE3/6DVYvxRhDO9diDtJGNqF8hhM5YTSkU8cEezZbzURNxsf0RUHy9Hw5z4ItyrcItIkD7VHTPNStBXD0GZSEcLcOX7KIaL1u1B/3TMsnloHbij08Xl4Zwa/H/yNU+KpWUPD+5W1LyDWPmv8wHqePe46z77fkg3aH7YvobcZxleL0G07CP6/hAOl+oVEenQlwFXfVLq/WFO5WcictZlV10fz03xr6b3F0fwU3zp6D/iTfOvp98Cf4JNWNICf43PS9eDf5ouqU9LzoB8f8EfWzQL/L35VXTH4d/ul1Zo6HYRm+dWg+wT46f5okN1Bu/PXQP2PCTPdWsoCXE5J62oT+Nu8W+HtSmF8qrQii86ANxneLHp86lgIpXhfKTVVTqy8YE+ulKWSBj29WWjTbxbkKZuFNeY9wlHnHqHPGeDX9SNFxfTjrj2DuF44Yv0Y4GPJtUn8qf5GD0GpTqv42wJSO1H5tPXpkmk00syD3ktMjfC4+YxSdRK10R/tK4sttAbk46niTpqV/WpPJpkLb+4QaoRMs6lJ5pklmUivBHhNwonL8cAHvmhX8xeAqgaT29mVLY3cStcWoAXC9GE75tWv0PB6Ma+hSV+fsmIu5IwWwqXG/aHUe5AHit+kWzW8XPy2vklXL902C/B9PRDE7q6+ILbf7ouqQ+y/2Yc5uu3R/NUA5pjTFGxJLrQkmj8VCLZE0V/DGlRdbGrolqjdKqV7JJ4yOL6FHao6wSbf8l4vYAu2sImnT7B3Hhdtb1Tldm5h75q0hZ1l2sLqYKQMjvTxrwmQT+XmjriwDIX7bdACx0/CPzo17FhTDWtMqmEzIN0y70TuiMrHj/DOT232Xbsu8cXNwZMAqw/18Zt6+7hLjo/gO44LXANIFMdkF98aQCjISVITcW3p2vOX4twTiKfJY+RwCdHaATR/4d2kyWf/Gk8lPxhPHbROn/Sb8f4pt3dpqafAPQxuOrh7wC0CN3dxPDV3RgyFtlB+6YgTxxSuqzBDgzZR2r6efnvVtgRx/1Y29d7t+O4Em+iF9juGsxGuBWyEdThLeYeLd5wzXjdXcqWRe6iskSu+4uaK54M73ciVAmdcUhb8C6Oc38YqrHd1MZzmdA2rUrHcS/M5TnNlCnexrI2Vz39OvF1LVqZwvyTg2hdi7XZulWov95LLyWUCNtcLWdwmxwZIV86NrlrB1TlYbg/uUFOBu6JwzwBsa8Sd7jVQWw2rttZAeV1QdhfUjOtZSziiDG3WLOdedDzI7c7D2xrXi/fWOcsmif/hlkH5z1zZySxg7wDYj4v7Weu4TBdwQUp2851H7mlFilnAFlRt4DZVgUzycD49H94ZoIxNVfjvKoujjmdxG11Ba1rFKi8/rX8LW+xAzCHHw3dHRVv/keLaL6a7DFRmrM+og5pU+bSXH9GPX08Is7LNlfhvEPNguvH1Y+sYrg7S4J8yLz+4H9PcUTneAJJKakYDkSLTn+U7/OONsvbt1u3B+V8YbyBTicoYemwDfv1U/Pq6dav49VFBYjgBHPsdYVU2YTgKvBrkqkeIrJL2l2GEqfqRfv9Iu1TvdvYFl5mjxH/ZffxY4VZ6fdaKFIvzA8RcXfzS/mCqFAFTTMNdBqonrY+LdU8Q0CrKvGzLtWTQdHW+wbVq/mJfpPu+/u3soy60qof/stR4dn4ccpMzF2OAz0Tzj/pB5iObmDBs4fHn5b/vvxH6h6Lq+r012L4HIN9O/5fMdnaBC/fkXeNkA2d48CRcsfhfRe4eFyCN/+q8wR0TvzSdPMDJYJzWBtzclYHdCrtOIv+Y7JMaZlgR/uDodPurmC04Z5lea0dqCUMVU6+twz6d2wc8wYF8pYuNUdWwWhXDUar4+ti63dxGsddv84c5Sg0bD9iOhRY9KN6/hxDK3Uw/aYzsxJ1dN0I7EWVdYUi1J/4bGzMHsPE0P2PfYwxCbfDJRJwPt+5kQHorV/Mj+4Zaw/s0Wm9M3IfrInoa0qwFyXxtgP+rD/Ox3kEhLvSkH2d1xC3QzNo7GYleA3KVhp8VEG0U2Qi0d+NTDQvO0zgf438/E8TR9s2yZYr8OyG8aFhwz4oD/ONPxoCcJinV2QG+PqIV5XHSKDSTZwP8h70z7JNLbr/TSOv4rMAEeqzd+eHkpjxrXolUr+EHB0h9JP9w38wbH4EuoPDJaKopwO/rnWyLOpRjvSq2ONabe2CyfWQTht29ejqB57yEYaR1RMkkG5Zxo1/Fv+fLskrt6WKZV/tPMFGHMqxtTEYJ1sr1K+n8Q5i7Q8z9jXcCtFE4rBe/nu/Xid8ivTeYZPHN96E3f/P2MAnim7bQG4P3J2aQ+OZo6I3F28nEim8+7CeMG0TZeZf3G4ZoXbwmhkI8pPfGiHi8GB9DtT8dS8XNiaFmeeOoy3wM5Qc3jo+jKH8M9SLgsTQvFvAoo1N4uzeVVpY8Yx7Cv+5N4RfiXzZSBvr1PV7EV6ePaJ01LY76aFhwP6ikWM139OudaLFnuAL7gtgYzX8sEHrqMGlc3xxFS84OLYb2B2bYg21c0n/qUNKd49aMa0q0JsFY1vCz+wm9pjuhdEjx0HJqrE7UnGbeIBb3gMSh4Yf3k4acciMdyVf7gu2dBhhQl5KpieU3mGjxTV6/8ZCiNAkklRMdkdbvmMjifwMeVqyKoRAXNwAXu7+Jo5pGxlA3Ifz4l5oBHMzOiKNuQrqgfRLC8FJj3MI5C+V0fLaiNp528Md6FXV2OpO/Kcg9OlJVW8NKXA7+cK+qTlqbyV8RcG9oRGku8NnvQrcvHgWZtqHswkI1/3Qv2s7VhOyXEK0C1B0+C3decL4C7u09N9X/VNIbaTKdSDtsiTk9T0i3ldBmaFO7P79pthj6yk8YqVYyjRzHMmSaj1lbvJ1d5wrwUwJrS54C3BYGclOJlLRaHZ/tx9AYCI30z4LQXyGU6c+H0J0QSvUbIRQNoaF+O4QegZDOr4WQDkJxYt782s1ssmszOxTcMHDDwenBpYBLBWdw6fj+Pl3dYuCJ33jl9CLwx/kU9ELws0HGtYE/yqekF4CfBbLuX8FPBxkXeWiKjzSspRUVmwW9WfXaZsFs/ovYZw92zLzhfUSSgid96noJo/z0XOtckTIK/CxztR1tKJ1WUidLaEl9KZQzyDetJB/a/WV/jZAN0uaZk2qPgpwF8lmsT+1RkvkQUvskICNH8xG+tPpseiLk8nprBCXIjfn1U8X4Na+uPq0uvzbAkyDpUfDlzvqJtBm+XPRG1/+Fvg1C3d4akMnk7uI+0ljbWQNymdxtgfDbEB4G4ckQfgPCwyE8HsKvderqs+hkyPmClxj5UnuatYpJs6aIbTnXl1qKuCXSksv/3/Cr5hcLuvq2yzoS18WiQd5L4d8UppsH80dAz1MDvYTPRP4G9ISyFdLVDtDtJ98fL8pmY+8A/rgynmp8ICinIc1fd8eI9L9gfyz1JoxdHBOvJMZQW4bFh8b9KiE87quFFH6pEB738wUc9129wXEfowcZz6Mnz/EnPiJgRJzjHzkc9P8W8stC/rKQvyjk//Vw+HzzOX6HuMPyaGsctcMTT6C96t9t5SXwk4Wgdbd44jpDGpUiD0kuRj13hj1JHO+WvmOHEkuHAg9JsCaK2L2tj9Cru3Wlg0UeMiTEQ3bMuSnyEL8P+ccTvUH+Yej7M/9I7DOL/COyKdL6PRNpPQEc5HMmzD/6QryUAfz5MfzN7/xjzqLfeUhw33x8joyWLvyEP+vFVrw3PB7aqCXcA23Es906/njIgp0W2vjHfEfEfBv/R769/zPfO2K+Jf8j3yv/M99GMV/+/8j32P/Mt0rMl/w/8s3/n/lmifmEYf93vjtuyRdfil+kNuLmovIA390vu3kX+NMDsps0+EvAHwn+k+DrwN8Cvqz8ExgvMs8HRADkLtxJ+wm/H+K5EP9ILLl9ePgcQ7tYnyIwsO86dPb+qPjGPRxtVk2zTispmLHnWt8MpDG/12IlUuw04b6jN790qpWoXEH/VnuOv9BHpN1ROsXaJsjm/lanvhaV3yZQBb9VnuO/78srbROixqpvblxEGOJs8G3qBEiXO1d9rQBSTS44xx/ty4E0BWNzrDkzSAO8n6q++aLtHP93mPfMVijvZgXEHoRYhhh7BWLL+kdYVwAv2ALhd/qMkH/H2BQr5L65ZaH62tf55/i7+9uEnwvahEsFuE7aJnQXqG++uXD4dFwlJVM3VLcJZ8duFn5OSy03rUk6JLZJ6GV04rqfBmiCSLfT6YDV1QEjrYb24/y1/YngGMB9wxTwAcRRFPjda2OpWTe0VDe8x38nR8C/ckUrjpXRN0EmUMZQOyANjiOU14L4p0X80yGbBm7RpgHeLrAERixx7Wx+Ir8T5JpHz8huvrk0iu/04zqhgnYmauiFPVIy0r1M2M5OVgUlfacqdGOYuPfm35eJ5X85G7TVsLUIqeAcL/fpROsNaDVCtA4BPkr5R0AaPQruGLivwbWDO5Ej2yO7qVktuxn32J9vl5fVkbUZPIe7nF14f3glS1SJZ1WuvTFNBj2PN/We46OAVqvFO6dPsJsdW4S/iyfJ5w+7xEU4JCMucU5x12bkqaMsB/LCr46g1YmtRRGitW/3YY3J006YrnegbUrD344KH+Rg+sswVlAO5gF/GcBFd/tsaEE0fUFp+mJaiJ8Un2qiidceKEF6P8d/6r2vdOfi+JydS7Lo/FSZZxah41N6McXMG45H7i4J4mWfd27pUaHCHA/t3mHOorWQshZSRokp41NnlOBoOsdXe6dDug/EdMcgHfDWR3DHuY7nhWDKwhIcf+f457zTIKV2TG4mptWPyRPX31XlOv6nUMrJJThiz/EPeydBStsYTFceSjcM0v0nlG5sCY7wc/wD3hxI1yimOzImi56VKrs5BtK1hNKNLEGOcI4v8ZognS4H0xlzsmgdpJsO6XaF0qWVIAc5x4/zGiBdsZhuHqQzQrp5kO4VQeZJloImMiYZUi6ClC/2JkLKjWLKN3LM4p+DMkj5T5ihpI24nwTHAvIUnHORp+F8a/8sjkqj4ynkjTgn930aJ87FyGNxfkYe/bU9nkIej/O0OEfA/D1PL649FuVZJ5WcF65WnBf6duTeWd8I0jHfKkwASdvZfyxFSav5//SjrKYCqS1XUNVlw5eIfiKNNLRdVhY46YgtitdRxpKnY0+TIFcl8v4+6TBNhxH0MNRTtgrk7e4OI51u1YP29bJgpEeIK+HRpyNGyrvGpGzxea6RvlhL6qGhoRxPC+TYnxmUxM4ou0/qQFIqBjhm9adsVbknenEFWA+hsV60Pj0cQrd57xLt+GXTCL1NGF6tqdTjvoX6lGp5cUwlWqfq9X/I/B3aXA085eiMIK6ehngLE0NVg/8xOKFZY9WUaKdrZ8TcqZ6JvClPIFORa01qUlsjRG6VDdqGvlw4PIaeSGM8S1DpdfwN71UYL3NS4qlHoPx+vDcC3DKIPwqONK5uVtNRZ1NLDVaDWEq0kBqS1CIEMi25+0778BKUvqMEGX3k0FCQDkxNQ606SBHNC4Go7qRSapyuPBEljVdBfl2MfEsH8toXATwDVH54MOQewrMBGa07pBWljWugr+G7C/DOfChClDeirSeZaNBYoktbRHkDZSyE9zy0HWUPhDsZ4EXY605oqLEQDssekyBcCA5lj/D9DMXFJTPOC8aXi2dWNw7iu336VHWPhCBShvCGgNFuejyqgkij6izFm4Wx5jZhXP5mYWK+mr/Sp0tNodfRktohvCbwL46oGmGQ1E2AVDrzZlZepeY7+4yQwklrIUV//92CSjOkAv+zxFfOdDunDaps5ChXw8ZRxZvZwS5t3R7BBqUvgpIP9xlnKGjccRnF86A7I0UiXajcyf3Au60fcIxrPa2qoOpnA0VtZiNB/mX77MgnQU7HnWtyR5ugbVTzP4n3qqzhKMdmNt5l5IyutsuxhmxaW2+k0YYT1qzmv+lTW9ViH2UEyLFRxTpe5V0y8kgHoU8K36Tw0huAs43gzLfBOBwdT70Dfj3Enx8Z/KeF8rCe/zmkBw/m43x6viukBw/mvwU9WMXf3ReUhxNTg/KEojiKnxHQO+XglwRsThn4hYEdol58pkdL3QDHgMMzi2qa2KjmR/ZmDbWBb+yVeyhyB4QMvYQ+tJds5nlhI+iHG0E/nPN/6odD+CP9Qf1wiKj/36ofrrOuFzHwbv86kJobQUt0gv+pqCUaof+GidxjPIQS+nUQkkEovh/1xbnY//2oLxZASNWP+mIshOT9qC/aIUT0o76YDCGfnzAk160s1lemVKZWGirTKtMrMyozK9X8Zz5ZnZxeBlzpYx9ZsRT8tD4FvQR8fd86ejH4yX1K0BzVvK5vPWiOaj6+zwmao5rX9iWnrqWJlEgo/ys/8DPBWIF6YjRoi/nmeaK2+I+QtqgCrvaKF7XFOdYisb2j+oPaYnZIW1wH2qKa7/dNFbVFC2h5U0Paohq0RTXvA20xGrRFNf8bhDRkLoQ8PiPoi7mQ7ydfjRBtLm1ah3QI8dM+e+qbdfZaiu8QagQN6IsFwAVvgy9tvhoWJAD3OH8s6I0j4c1Rn6ye3JYOoQ3wTQ/fMv2k8U3QFFMgnALhrRBOhXAShF/pxL8JMvcgCG/qTAYNcjDkLPMRI59tH2qtYIYWD+J9vUNLtcWgO6J+WU4Y/hvrdwGVunpRT3xPQD1xzj+R1o8AXS8aATLXUkIvWxrUE3Hu+bOuiPMVzl3k0qCuiHriz5CXWPq7nhhez0Fd7MH+oC42hH/SD7rYnePWpDclAJy7e3EtR1eq+z/WcqL5if7gWo6Kb/bGirkf8OsORd2iiw3h5/oHdLFi0MWK/6iLITzTYcwhnNiumh9+18UegfdbUn/nh3+xzi+pbETK0PvnWe8VaSTJf6+4thDND/bfbb1LDMX451pniqEovxmoWwHUt6lPUTcTeuEBL44QOW0HyNb1RfGvCjjLEuQKugS4Y7R5sxBlVvNWbxlN0gWQ/iXvNHi+J8bzIdTqRSqadAB35xgO3G4dV3L7necF4i2s7SToDURmFL9SwD2iUfxyobGHkizsiZBut1Ctr1nivzXQY6xZABk5Npr/uC9t5CXgY0FbjVL9KGtqSTR/oA+5UbR3RPF5obEb+Kv7ybuIlJnuKdNxR7jao4uUj6wuiD37FStzyHIo082OKD5HUNS3XVaQWfQQgHC813JNWz4ENL3DjGqk5OxXgrb7MqMJho78zMQHQ8R5JiEY0p5mho080QqhHeD03zHvA87/AX3BgB8AN9wQTxUYgjJNMbjVEJ5i0RBV4K8DV7Vt28fg7sjJyWnF8656OoLf5iOM3jPaw/HR4n1Q0w32M1LVCao0yU6Y5KeVpUprok3i2Tgm0aY9TLj7BA7m9qjJknwtOBk4A7m8kCyO4H/9kGjFMqhmXHOc6SYsRIq0WMkrevHffYBnW0HfhPRDjNrmqFNUCZ5BIxZXWMgOHeghs4XUfHKMoeA30Wb+TajjHYAX08po7akA/3OAKsWdNIRBUhDOQ64JZOlayRzSfJN5yK0mbjLBPMjpzZDnxUCAfy2A1kx0xQkzlPwnQlTqweB/O8sZctqVTyVCSixA2CzMvOEcQ6RoILxPGGGPhZi6I7JYkqLkdwsBvkL8y38oUHxIhIHIBTysEa6IdQrwlBEIL7YN8YIwfKdEaRJvFIun551o9BAPGVsJzxr6gO7ATWL4XQBbPsBWHEC7LJlAPzucSv4RhOKRmTfyHzYAHCuFLzzE4tvpYQWTEmosVMewYgLGsZJfIGA+PT2427Rx9RxFj1xVR58CKQxhju6AkDnOrZVGtccWY+piSJ0deMg9lBDPXruHCpeYFkh9SCC0L1vkHon8m3ZlcSKNaccIeO4bW3MJ2jSIuCi27ycm3C6JNc5O5sThGcFWHfAA3LMDNJI+1Il+DTxl9Cm7gp/mW2zXrVDwU8Cft0LJnxQW27eC3wH+CNA05q2I4L8JhbdC+EsIS4tR11PwbtB5cb9Zfi7Q18F42mLX2hNpqiCFfkCQlQL1fQg4Wg1uEZES4LlW4G8DMaY1cNUMMCXbUze+sj/VTUqr9xuc8aXbLDOvTJXFlQ4+dcB343r1fpkpt1VmMKUV2kfZG9Yj7MnP4BPKKUhei6FEJ7nEfDiqIJieMMEMb5h2g5imTvuZCe7BdZ5zSoTmOfZ4OtH+qmvRqj37yTGj6YtL5G6S0HZsEcbpy5pshwpvOAsvLlls/39oexPoKKosYPhVV29ZIE02shE66QRCwtLsm5pOp1PZ0CCgsujYEMVOAIniOIgzQ1hkFVmiDBAVBBcWlTSLQ0AMCo64MNOtMIaEDBGQkoTE6ixUdXc6/d9bVZ2A43zfOf/5/z6nuqpu3ffevffdd999e5yNGCpWYutm3lOrhbHGrMZ5C6lRkYinW2/fu+BvNrb4R9szT/1oWy0UllETf1z3rpBX9vURwNUF2XWj9haTtIccxQtJhqmBGGKhBUjmiWMVfihDHeXF/cSR8Wf8x4Q8/RuaP9TsW7BznQL4n2ebWZPdlEWH22bUAB+GiJW4nrfAGN3xZNFRZ/FCanQ00mCsrN5XjFRWrDN0NBbHK+NDK8pfF9fUqp1Kl54E8ZR4EsIYI46giONFT0kpK5Mw5XT/JTaKU1B9ILYC/TS7hIHUQ2o6xMjwn2ORunCOUkxxkCF/cSAmSX/JQQZhPIBnHcVIsdF+oCwjEeIqBArinKOZkT0cd3bjm57BPIf87y6G3ErciDzkNKlxj4OM8w6wNN2b2OKFiox+YhyKjD5O3OkP60KM44du9IXL58WKUvtOjgPDPw9crAwj3Lflsba+G4Em/byFJB2/BDVcW/Bwwk/F8bbwpXErgb7JxU/NYfHr8o6ZhzG/48SRob93c+zeBd+vC7Y7NKpL8di3sMEP3uDPbD/18s7swyiZn9hStcm1sxx0ID0UKdRT6VonaN2G6wtmQRpxZYg1DHREka4SvyvSKedizcFLCBkkQ5Kdz2r0l5BzPfOt3c8vEfnojUOi8Xdh4v8q1s9bu28AD3R6cIMUp/ry3dhNIEMaNECSoeKyTbO8s+Qwwvo6SzShlyS49rKkkeVi/qQCFVdE2feGK4VwDx5GWH/nAk2UHK7fZYn26XZcdfAbOm1/YnEOTDsr65oBS0060Bpvo0YpxfJF0jM7Ug4nbgxgYC4h1pabaJeUzGxbch74E/xXvmJbUt4uGz5/Ds+JeTttJFnNn4JntFZpAkkLqpcsVjI8F9tUdQhvFHe+S2pMZsLzZ5Zo+ReBRl3+jpJkRsuXdaNlU/PLutGyqcVvwfnxtvRkkrqrXM+kPuXnT/qQJ/CuytGioT3Tw/X11TAt2o9ht4QiNUNcoUF5EF+tH3fhcDuNzL8F0x4/P833vG1sYeTLUX9OyB6QrWdU/CWwiyr+ez+VhPeTULuGatPAXm4VrEeJCKvyB+vVfJQP9+JS8QfEt74+SnzbK75pfFLoSvGN+DD8IvBX1XypYBTn6I1euCsnyIEtGz8/26dsPOGitElOPIcBqfT7cfd8YfMpFxXS4cA4/tOFoYtAah0OKd1FYtzfA5xKUvHzxbdvuw5APoaG/ILn+4QogXe+CE8U2Yr8ayZAzDPF3RzdTrBXheG2GJvCFamOtR0RyJmEDrL8nWZCqR2fiG/lRZQzaAh3mQzavlKyCzumod7d6jp3q++a+WhztkAdqDMs3GlWOPDLna6Ahlx/Ct+vdv3a3m+NzrCqvd+6YttVoaM8Dv+3VKy7KnB7sjtMSyrKpV0PSvB8QX6qQFXS4BsW5FDblA1k13QLNYpsoypKGLSMCm5Pl7gvpPN1cSeAG8ADEUP3s21Yl9zROC9cGR66ofzOkTWQXmXOyLp5tnCwCls3hG+MFan38xu7jglTjIu5JaoIsMs6R51q8MW3VQMvzlTpL8aqki7WKZMvRgDnoTWLOVq1mLtfRQzFT10vRsmNBb2gRa9Uy6d20TZlxknHaRbjq4XaO1h1C/5Vqpvoo6iuwz+jamQ/HUn05dt3EP/XuyaXf+c7h2P2KQ5FWoozYgrIZq0km/dsCxL2Wd+qprDnzaVX46o+DR/rxVrbyGj4SC/eg/g9Ako1p9t/ZC2EwnWBiin1LElxs0vBF0zri37CKpuKqbdD3Kt0ySsBa7WNum+1tf5Iih1Twv1IJpzGJz9/yauCdLT8/d0qkK6Wnwj2FPJvTAurOw7hV0u00esMTRQVnK0ov34E33Wnce0lzahEf2t2/Emzsl6/VJp/268xbmkm2NGkpWTIdAf4imNa2Tnpw8T3QkfM0ifSxju01biyYebSFWbaRSk0zgjcfzL+iSEs1FSC8wa7x/7o0mHDaZeCvulcYVbA/doP25ZuMF/9IU7G/B4wHY4I5g4bwVxk09MTnbOXpoN11zMQShvN3+re36xSqZnl8WS4to7o/8EG5+M3Cr69i3VG7EQG5xdW+tOqqQdus0lLt5r3O5pYSm9ni/uHi2dM9WX+DGUsGqwN7tCJT591j2Io8ZSzMvCv/1JDxY8S67Slfm31wgQWQped1tuJgbZmW2OYstxofVlumt3eSZYr6rOsuHsLQvT2WDu9NKTnHfdz0VVHi7mC9aaGTxR3+ux0Ukwa6NwHfherPa6za/lSH7FH67WnMYVCW7Y1xBZRrbXmgYdYaIuxeti+x+jj9MFpgjKe2kY4laAQVy/QVWW5xuOvVIUyUUA9jn8YPelMEjxF8nN8uD+JPk3lCJqg7Nn5ghL3mQn0s+1ueWvjB1X9GXoLUDUoZGlhNci0BndDNjKDe3qagpl+AjUZ527Wiju33nGmZpi4QyumJ1wVpqwkFSqG2kIqKwSypdpFwp515jPr86L5875ywCVc/xVkmInrLKcqHxOUh/CU5V/KvxHIVMUbOCeTcJ+VG5gdDDV6h0CIHySiFFMglfFLZ06uP6LPIG1rVrxYEO6mt7xYcPHxU5CCxvlCvgny7CPf8rS0muX6VcxsJotR74/m47oHHaq04Bk5IUL5fVo+y+MQSBWUAQ/KlQwl3InyAkZ1AHGzulS71B/uNa9g1jm0/FCPwpacvsqhqkyIh/LvsVjOQEgy7FknVYlU7kWat1Dj5jfmM5j2LF/VqWpXethwRxB3lZ6SMdRxwDUyqNqlDRtY2wCYO6H1YJwclBEEpSDuMqk80EwHT2NiRSq/8g06tMsSjG02GtvpwUBrNO/2Brn8o0G+FaSSGk0qHmG3MvUslcqzlIGq6GCrXUvChjkfPPUj7lo9fh1I0LDUa3+HocbsFCUX7CdpvHN4fh5Qp/edEs9KmJmzv2YmI0lJydxfrWAk6tf4tIJyKjVuioXspEYqWJzx9COkUBy2vEN/+KPqyTbl+AFlyUtJeqsDY0KdoELur54NuhUD4ef7iBAC4R+3/IclBihblSAd4wVBu2cXEwEQRYWHpVKKuOCgIWxA3qe8DKuoPAuymSPu+YK/yhRoY8P1NFxr4NoEVz4zHbTnQBdJW+ggw6Y7Rb2BPMh1rG8hG/czqDX7HAYmAXRGvxRapt14xjJSqXTm5GNZfgfqkT6umGCkdiq8h4G856BWKGihfOjjFjJslVPLj3ZLujHCTVWqrKoDUxmvnXDlblVl4PzE6TmZHS9/rOUT3bQtOSOz44/wHONGvQBKKoWbxPA1cH2eaRCUW46ynzN2lnAFHlXl9ByMIbPjCcAnctjH4NkjYNh1LWRX3c1q17Mga9NhMmx5x/2H6cprccDl5DjrOBataWbH5I8jwRpqocwlivxtNC/vGPnxwwlDbyKnmR1TDwd0fk+XpPPBQaDzU7T8V4LE11lBaV13k9S8I8v2bgvi57t9vRZk/HHFR0pGJVADsIZqtMXy27xUmtK5D9qo+6y4rkPLvylgjdjq4FkcYaYLs624C5ViZFlubkuYdsV4Sqs7Hso8nB0H8m4Gii+CvanydnC600vA3ibye/zENQWsdhoTwb/QjWdmRvJb/MrEqAbF/mADEaj708HPieQfgbAhDduFvxrnaJQuSqm5hJ5WJP8fgFN1WH8l8sv8U4wR/HPd0ggFroFO5MvAbmj5fIHYwJZDzUozdL7StZqgPY/k36ghNQdBBtBuMRFOe4IqjBHb3glPB87hFopiCq8Ktj0JtrC2qUGXb5H1KqaSiSx8PPuY18MFe3UmkhZZo2SoFC2n8JmZQkbLLfUhP2Hw5O45JV3LLfIFcdnCK+bGy98KxIReHqkZ9FCf6bXnqx7A9FwZGrLRFAa+m79wPVjOSMZmpyAfo7zUAdTexz04M11dp+Gv+aPRaqWQ1KGNDIN3vj94UAezmJil0fyfPLV2LdTxSq+m336v8tNXLfTO+GZoEzb/tITaechMuShKW7PXTG0N/17Df+pPhrhQfrhysFq0DlQl6i/mhbif3Ebc8fifLPqU1FbcSQ48aRdF3I59riCFMr3zckaG0jEsYzCuGw1RNOI/Nf6ESBfYblzFCPYvKGx/s4ZmGK2LCo66PDw910EGkwzGqeFfFilAbODBnmjF06clfwtty2WWJE8vRFq03HddOLoAfjL3hHg2tZbr43WIZ1l/A1j5MlZ1D1aBjOXxICTYRam3g5U5INNzEDzOg0DTEabx8mPmE+wXTAsrWUeVi2QPYEYvpcGC52SEO5cszchIAA4HOJYkED32qQWHxi41Tgwakoj+BR1xeb+9Jk7T5htlavMt2WXWXdbwOpmr1AcrWKI/mnAdPAUvG+pVhP/E9rf8wq5tYpddFV7YcrCZXYZWFlemRWE7YFSszIez22RH+qW3T0DPl3c8e1jDX+/GmG1sHEeFBTnICNQ5xOlbp+We9iGnCMFTbbXc6K6iptJg7H/9J6vlhnZJ53+mmAjhlvv9vy4XxHmBfRjMVUVvrlLKIZirNPCcCvlENcI1anfLlA065kirchm19B2XkQ7K2NOsCMVzOSl15OXh4glznwIXRsjTrd27W7I2IJ0q+1BrYGcv4TQ1uI7VtG6ZhPstGhncqxvnFv+bDewbH4C8kJAkyvf9ZkK/D6kMYlouzzH/i1WL6f/KhtntrXkbkpcquKuKnPR+znlLM9JjHcPS4xzzEsggkhQ8WLfUOCEoLZJRQD3b7/Lb9jlxtOsvCl865o1ZlODultgNh1kyaG/CTZYa5GU1Xoq6zoZYmthVTdef39t8/XmcCb2yGk9RDpyfrKw9Ju9its0BPpsYzybWqVFdIhnHataJu9YM3jBN90zrB8t+ks6/xbXkIOvly3XHFZavj2wx0wzlJAZlY8LSV8WdAzvFflbceW6XGb7ojae/fPy7x98zK39A3eq4TOk7xfOe21jjcWqiJRHs/4i9rrkkNg28r7A9rrmqCGZHzV6Xno4dtqNGPyEmDmJJb3bi/oNqBj3AaH6O22iZm6iy7IcWG4TKjK8Gv6fMiGsDwYNrZxEzmp/qBjtmHMDboK2YZseTy9T8N15iyHgE94cgxzdVleAOl8KZ7DNhfbCW8AYzpjaqXwyv/DS2uqhjxXMxvP/UYu4xUpYbAdYdW3eJ/Fz3hGpSabCKo/WVFd629mIr7vLYizHVra8mO5R2vQhHXj2s/zaVr+a9n5IaPdhGJolwT36G64rNSVSemufdpOYI2O0Q8G5jgCZyAj1r7XE1v6Vr/HHcu5s6SHHL3MrEkHqqUpNf1FH/fBp42RO8ykRFHbWD4v7uxjkOOO/nuxTcU1VZAu1prsbzupBixbbpYOOj1QjZ51YlauqULh20lIyCKAfwvMYybpDZKltCCfCfvdMcxUQ5EXu35492iMHozwiGdtBqeBpqJalS6H5i6MVclOoOq7edtc0pibBjLRSTu5iLUXGsAPENKOnPYN0RCnG95KFGqCBkiEMxItSxtpoMPQat0yjlC1YN3+zXMyGNS2wJlnb20i1qlMJLW1pZDX/Vj73KwukJIm1I0aMeiZ74GvAdUxdz/VVIFVKk4c+LPcGCiPu6MMioYvCclUqR70meUttIZjKDz2+51Ylf1JTavo8ttUohD/mN0ApdzIWqPTLdSiYaarw0wB7gmWebyIwWnxPdGgg5z7Ytdp5VJYZ8zT9B3NdmlS2xBM8FUXvw/4p7u5Ay9Q07dX/LkTXw9Er1dmGwKcWO364JysTgOrUYerFfL8pQqbwD7d8Odii0BrXHC+whywqW0RxNR2QXPh9hz7Np+Nl+nKONWmE8hvoQx9AlMTaLLcGewbzLGD+15qKeGj/F3fbm2ukSKpnog8vyyjaUxW24YpuXXWCdY9to1WF+ES+rO2ZqUxRDXs94x6ytiRXjyob8wx7zGDEmfMLTY/giZUk0k7xB4fJP/sJFgtTNISpVU5DqY3MYtGaK6vQ2h6Dco24KCkKLH+woLslnHLmGDavMGgeOC0g1H8bYwe70ci69jYYWH767WCp5Ry5Ja6l/r1kdrG4KCZlvs5Y4ctTekPb0mvdtaq+2rS2O2hZjoXZNhJLb4tbbQMpMhb24JHlDPlMlpvKd05GTVrOnOYRQlUNr9jeTIFyDOtBCN2IaLexOoH1rjvJ79AQGOE3MJ6Crb3jbXLQNV6lJFHxYr7clb1hje9Q+GeodKd49TpXlAMS2z4a9Iki93sbY+h4tLglgbHa+IfOD60CkmNbWzwMeFN6gNqT4daAYY0V6A6FOO5aI8TWI/52stB/qcrBXMfo+UKLXQd1ea1dZF5QU2xUDIIfmpjE7clWJ2jo8l7q5Kw18GNSYx6DUvWdLA5i7yzo3rRq/XulazIWoWthiW3DBcW97py4pdeVoaCNH8Lc8BoYkq/NtTAxf161KrK+zlgzgz3VdBJuePThcextshvHY9MTVr31ZGmIpzn46+5A5qM5xK2h6hbejfagt1pLGGEDLUDdUopaVHVvz2rnSRxL7WF7Ifs+sQVzT0zbK8iGUsDJRG1Wk7H/gvfc7eNwxprTT9p7dIRjPrH1tRmKoV8OHWu6zUPe97uU7vir91Bx8pbyUeEP7GZkPGU7Wdw5CYgwedjxYX9Bp6wqwXREOUxsNTwPgTsE92Zl81LAgwrrvteQF07MXWK+XHrLiSaXG01/YraXUwewSzLs7zn2lSQuoXZSXNmRYf2WtpddKads7r71X+obX5dqRexMg2SUecZyrEfLN0pYS8fktYtSuOG/FPFRwtIJKx7HHIKdWr+H3uU12VWG8LdvaaMV5JWBdoORBDhGBzRPHws7ZtGKev+Y22g022loMuL9YcVYJYnlZqf/iH7YltrVV0HoHWwb1nF4jlqghBeG2CjPjTCvAXqAIXnAPKvjAFUZpXWEkgne5o1OvCluqlthmltLAH+oR8ni1vuEWHfG87ajX1f79reBwbbMqmGzb6m1vjyl4KX4qxHMR6sy0mBNm7fdLbHNKJ8bFl85mTJYI/rxbaUmLPWEOA3jlgiVWFUMy/uUkaV/UXBaUxviYr+Ef2oWpZ6FVvAG87TQG5wojn9rUSG0MXHq4CuKl+TdnbAP4V7xE3wgWCXN+bMn/+5zHvZxeqerDbGWyS6iDyGk5g7zSdUSvEk+habhFjfvE237nhcShlgctx7x3+OPeOx0fmFvr6Mol2W+am67cB/kFrZi0nx3R0OqLhlZfdOEqa60QaowqIBkxNRHMWWtEYfbcWkFnDC84I6SUS1B6rq5gzRq1V9O+ah54+8URthvx5+aFVOusn4MHv7J414Lg6h3Fp9gIqF+fFsK0FXCdgus6XAZ3mLbBE6ZFGZUdt5QabCom3oa97zjntd4WYafl53iwzFr5eciCSpvUexeTC5YnKd4Wk1t2PHtB/Mt0BvrKKqcJtPbzdk0WnhVmhecv2zVJgedbRypLpLC4o3Vgd7eBDO59gd+p5Dk2aDuOlLBpMdxIsX/wgvh9EvOfEpKUAbYM31Q98b4nPum45WH4hj0QUjzaGuxFRhyc4Z3GYE2+RRgy9aDpgEkppkrSztW8LgwxxmRNOI2t0z6g5UpmJ3z7o1/VrNHiWdA5OdZSlRPjWCOPJ9A2CAM1GpXcS626hxpyDxf38qTyqL2VJYqkHbmzRL7m+qUQPwgJVflMsEfdXvt/j0NM6alBvZyf1SguRbv84zq/vzcsGU41UGPfZsng3SzYpOKd5v5gk9Rwj0LbVIwjDuAtgX+5yw5y0VEG2kO5+lm3CGm6jabp1uxNFWIfq7Lw4cSdZqpWUcyL9gfb9P5Z8xTCcRUzQa/mF4m9iU86xoH2jgPtHQfaO67wLFw587LnZvRQhHWJuEdE939ztVvkhKT2ctWnWpkGreex6mEdzl5o75OG6X1WM7+Vmp8/3N2/sLi4eMEA2yV73EsnzVHO2S8dMYc7g5JWA3+7bKuB429M817ZZfvGdG1efImhODQf95zfIuCYQOToRhZrtefc6BWRmuldYdpv4WLhegyuL31h2qlgU2yDIrW/tcb32mI139D9v23x1LtssZo/3/2/bXF77pc2NWOzrQcd1R/tD/HtMBuc0QU4uzacH+8PTbkqTN1TagtqVmoj/hpeSrZNjJ8G1jmcH+LXW9B2LrDVlyzAsxoymkXbucQWH7PEKu1rQVKugu1cJ/ZUoO1EunSDI7UDBvfazGZBspm648EF1LyIpfSLjydElmkLiOHs3AhbPNgd5C6CqSsh6V5n7Vwe4pkC8YhxQRzaPA1/ym2t1hSgpim5CJuhidARVoW4G4mGH3xSd/p8X6Kf+bQ0BjOgBGfv4PzXNwSzMR7+c4ifr/NjPz/aXQ3zStXEvFCow7a4SVpm/fiCCBsZRCVRHrUQ00SrBjrzmmj6qnBxS4RVlzSaMRbYQBp7uy8Dl/A9rL8jHSi67VYk4Yytmz6SttQ6uc5iRj9lmWeTPb2RGqcf/qNTD1iX3f1TQhpRP5YKKqasOh5g/3KHpuDI41a/mq/pVmK/j1Gy+eVCjpVmsJ0UCV6Pmt/XpWQm2PvizB33U2Y8v2258BOLdGQ3aWnsH6pmKZGKfUDFBKsSqFhq68/v7zoBdT36SQG5pEJ+jIFrBjwXasqgdUZcU9R5NRTXpSKuGcpHBWXGBnvEsoeXZXOhdIYpJJvmgqngIdoaA6egpz8/fVmEfSp49M+5j5l/cYrnd4Al0vC/CqRad1rNz+nGHshOhw1ahiq+yTNjMM6r1jAz9AN4GvKCHJ2RTJKi+HC3dEKTirf5lK5ItXQyoYqfC29pKnzDkdvZPjylUMPf9OCYr4a/5nlXMJVJZ3Aq4X2vAGGhJfI23NPgvkvA2kVnSuCP1ywRW1Iq0U5+6H8dNICaXH9kNdw3Hs2wva2JvPS6kC3Dso0LqpEK6oARcvjHLl01jifE1mvF+RkL/Bm2Wk1fwLfI+Bbj5OrXBcZ4WUNflOZwzPKjFG4KCY1I7zXhMovf6zT0pb2br2/eZf7VuWdhAl/qJ4Z9T10vfheowFgQp1Lzk7hOe7sf91krO82LdKtFqVpAV4x2NV/lU9kWmdPEdQDASdni6n0L51QfE0wkgZ/p3/MUetA4cws96GaWGg9clo227dIkXxxtq9eMu6jmvxXp2y6MtmHLjMoIdyL3L1dL1IU4JTmGCpjaS5CakVlk9vNPgGZ+6v+CFSU1uv4IlYGyuojYGurABJBVVhdJ+04cffm6bgKk8LTQxopyGo38fYH9lNnl4p6uJP0PDqkdrOZroeZ8sB5iCZLST3GQ1CHM9c174TnMsXfhD4+//Mj1zcCfnhpdeWSXWeWiVNfX7qj5ae1xczOknibnlELOqWH1CjEXtneHNuKMsDlq1SXkN1HAMeG4RqB/6gBRRlFCRKOat4jSCBPygJZtfhX85/vJMGU90rYBaDuKfdhj5ZHmVUaAuv1fslFM5138rDwa4OY5CDGvniRH4a6GQceE+84A5bpQF0XvNNfWEMNPm3eaBzreWUiNXZpw3Jy5lBJCy/atzf0BsFXUgTTg422vxIe2HucR+PlR3RhvjX8sk9CIsxZO+pvYN8whDdQBtNVrZezwekrkOr5b4rnvJTJMz6DXEqxS83sCI+WrkMud/kYW6weMt8KPpcXPJ3Wr+Qvi7isJ3ekM5B6zB/u2xl4Te1MGlERCGcTdc/t0k6GTHM0L59gzFmXbiaHdupgLUyJdz4o9AGCNXeEKVfNKRcRoVfMq+lFru/XQ5qbNFeb7ao6DJObE4H9lXOURauJG87EaRRJJOmrP4ijqDdD/eo324hugKxnVWZySSmPwXHKqkQxxO0nKd2y7LcHaYT3PvgF6RzJuOrM4LXVd7u3RA3VRDO7YaWrTjH7bPMTxSad5uaruk86s5TFXsG9H15h1h6LfNgtOLGnD7HhW3Wp4Iql0o0F+RokE+7E36NrmfUDz/TWYexviKmMq4zKst9h3Nl/bvNWcilDjnLjpAKcmt+E6wxKMUzoBjTGifRldvWchnqj4J5+4t5QPazMOfJxXqobqsS9HzQviuPJ9DgWDu/km8J4uVWJGPfY/UQdwTZYqMaUed3D02sdVoxddb6OP4j6OzXa0ltjbo+IdHkXlPiu9w4r1xejr1tXCIGsC/4hvzzyb/T4rnoKoAiuxmAtX4TmOI314KkyoCmdthqg6WamNjadFpBiVzMZqwv0s6G0J/IWuPaVIe6wPU1HznT4MHe6T/I0w8CFwfqeGWY+nIGXMdKywZduOQKvEbp52OcKrFvY2axUDPSuFEy4SlusYCTXU18KfbdWl0Eaj95lfrXm3WascyiQzWZY8sOvz3ads1LijZkWtuO/z2ncsw+Jfth0yD6iFlr9wyjbBpob4dpnX1exrVmvP2kYxPwjaPflMNuOAttHP9S/bGAvt1QLmUbPFcuXy55b3mrUqMuxHSBnPJtoopDPVpZjSSPdQy3eshfkX1INfizyogIdE4KHYIXLAR3g1wiob0n/KjBzMuow8THNMhHieERba9gMP6h4exgAP+dCmVPFKN2UYaHlFSDUesp26i5Nx8QuAqoRaaLMJh2xpNk0PJxrgZBJwEnoXJwtsB225yEv7SXMCcLLTciduvn2ieEZrmjAK0tpfquL/KVAGTGmMBeGhgq5JTybU6JkvgbOv2Bjmc8jXOPIZi/OAtwipJM+ut10DrXqntMFGGfbn4gydVCP2Lp61bTRjS6uvQ23z86xf0qF2wNxtS2cog5E5kfuzVRBPqtEdJy6dEssH8Um1+0KPVLtPg9pdyXu7SY0N6vexadrjylqShLOeCZd6Qs3P9ARJ41hGLZ52zZTb+oAXpuan9MAnnO7Pq4UM5uItEr7HFs0fBBvaUafmJ3tiAGMP+C5KoYnF0cr+/AuC3p4k1ut+vhbnPRh1eJoPs6ZKDaXpQQfOa6GXkowCx6D8SL7Up2Js1RSuyHNpSSTf0JV/Z89zesO5WyQCbBbUsNR2aj8ZdOGWYv6FW8r5CbzdQ9LU4DGp+S432j+ltYlVvLVgPc1paJxL2Ww7aq9fsM+OOzFj2zwMcNOYaP6o/2c2JnkkI6VzANN5XkzHgF/f9ZPUf7B9U35gFSlOcU6LcJwapPbQ7U8kqixzzJaYAabtpqfiXzSPMV00KV0DiSmINpYTtBM3BJ1dU2YpfwVyAtuVoYyKEexkSIGDcGeF4UuPC4pySl9loiboLXqPuu0Llx7XEt5XxOn7fmgb6qG7+nrU3URfdMf/kilHVY9a8zF439j6zOqnal5BfWt7MkHhfMGiN7ayTkG3hwz+PLafJSvnTu2shA7HziP5OdGOy0f8Q1IcNBdGhQ1JhjtN0UP0jgTwfAeKO2ETLlHAmFeA1+Vkdeg3ex+3hFk+d+lDgj0h3m9NA0cUgged7qE8/2r4mtUmtbDKpGZWkXQLvFWWNR5fbaOXBsVfNlHcQGV+0DmXXkWaV5A3zJ/bUC9Dvn8k/kuAKUrA2+9oNoVmR2Sfs9JzjaeBX1WzaR94p2etPCuI65z6AyVjhUFL94DGp8UdNXEmanJWUF0s4QaSNtMZkNAuc1HTCgpzOPJykuX7OJSaykO4f9pSIVf6lAxqIupUoPef1pC5WJrBveIiTiRZAE+R6lG0XbApADu1iZDz1la2d3YX/VxZLv0SzsvCPmcuKx3aVuVQN+0GP7nYbcrJd2hcKSrJg/V6cKWZmt8FNYG12gQQk5ekpTGhNXRKdIqG7/ZIO+Gr+TaP4aXXBU05NdrwHFqkcEdfe/GC0VY13w5f0A81PBdfnSTGpvZg3I0ebIXhUz2kIs1fO+uRQuHcPWhxyH70CU89Oyzla1zXMJzosR2uO+q2912qhjr5H+1ZatCbJSMGZKyikicwSv5v0D7X2XHupNI2Ukwv0YfvT8M77mdOGQ69iD45NegaG53iFq1Q3lE1v9VzzB1DSNqAeg1/waO361LU/BsebH1h/KkDDKtw1gD4I16cNWAx/8oCPniOTU6EHvPEVJOUn1n9AAE8lxGQ1lWI/SpbJu6Mrj8ae9TujrFq+CPCGvNAp5qf7cFYM1ZhvXqwG09jRx8v24NzpdQM2iTkPYH/a7eSeahaV63h3xDSVqH/Ep3iZSmgewzDszgOpquO1uPYF3WgH+/sxvk66G111mF8wz0udjzI6zzwn+RB760ftt2YpaJHpqxX8ykeaSwL5dzfQ1XiLp9Uxa9AOyde0v7tQwtfqRpg0zDY+hzi/2UeSZvi6J2niTLe4blzJK8aZ1H+Uqrhl3cR/S/zpNbhPFti4S6zsTaJoQ8SPeH+BO2qxuoGIbQc9WRQwyVh6BYNPwjqDLIlsiAL2vcaPtWPcSaApVPUqfh1fqUNY03oIkMvOAJpPNhFDM3zVPxLfqkt+pVI7wsprWxoSrusKziHMuoqpQ07tuS4+tB0QbmAqng+kUofVDvTpnkz6CC1bU91dOEA27CjY45Sw1Wd75f1c+J6z0h+oJdAHfbUSGk36TKTsqoslxzR8GfcKoZlKaZ/sh6wQgHr+h9vQ8oqfqxMx02WTuHBknbKNOBcuj5MCRMJuen2cNUZNrKrwqz+ocRGvfVOs4pS15IhSvTgRxusOLuuMo4MobcqKpR16jxqstZCb1FUJDGK/QN4o7uVjdbj2l3yza7JpXjCW15Z7hVxXZB0DhfUd0z9oh250moAnCez7UgiE1NIVYAnty2EUe+Kzk/hW7uixJOwSWrxfEov7jt1K37suVsDxq0WZk5dLcwiPz+9WrBOfW9+aP5l/jEhNL/xmTTmMj9NSF1yTignMeKcUxPUImvc0nwZnDOdtyhSWw7Xw3DNWYT7J9MMjoyRbasEK1EW0C4TNYB/VRD3SPaSmn7hOi0BGIG29tETuM9EqLzPRId/3uLpCbQjKF/PGPg3/I2LL/PzhYuQ8mV+HljvFP45cZcUUoPp2RbhfhRbgPItwizjIfPaKiUT68C1aThjcSz4PUmLNwk64yahn1GXTAybhPCpUJsa8u2ljCYviM/G/f+gfTvLqAHplzAKXCvVrX8GdeiX6dgfhFKtXIS9eVKtfr7GeHw9pJLCt3epGO0pg61ffv1Cqc/Y+kz9InzSg4ww/U6heHFI3lnXU7TStVBRwgTx17v3zNdXS/vIhvBWdxoTBOminXezyMsUY6Q2De7jFuHYsrlNqToIPtBMR8iVI53kySiHuY0iK82MQ+qZNvAbPzvS2VqU48hto8pWmtud856Ns+LOs7OtwxqTCirMkx3xtSRjgoOaVGEe5EgsAC+yfe/ixkVFHcueozs9SxSdnudxjOKI19VWYU754frT68S1EgP9fRojIPzPtV8sWrU4gI2YZ58m6S0Ooqcbcc9Vom98uuz09UXT7YBTVuVt53g23pY9v1XsPXWxVN6vbJY5jOD+sdlwKaG+gXwWewhp+F9lLcvVLfMPjIQrBi4ch4ES41IGlYPnm8dsYCoYXF/WbTeCPCPdGoakDmUONispbbOSzAJPcTZYteE+pSXTrhimciB0JGDuFe6zUGPpYbec8tjE5vHMT2DP1JBm/EnaqhLv2SIl8SdXWUOhPMXIdOgkOrJfqaI+1jBGZh1QcB08pKtCypahzJIn9kPqE2ILGGpsP97VFTpM6VIo2516RrJ4pGbVXNw3a2Rhgs0Qeq49RHmsc9XiTEfoFVNbeM6H5jEOU1sk3Ec5jnWuXBzkTJsS2Xisc83ioQ4VYMTClzBHypTgRlNbPjyrAPthuHc69VNIo35KqJUkKRoHwn1gflYbrdxnTnNE1B7tLH8ywZHVRsF7oiPTQJdh/RLV2H/KTbb/lBtwXYOrkc1q0wBGP9QiuDc5RydRZSSJasxKUZYp7P2sMYzx9OwUgZ2VcocdmdKBtkavbJz6bKR2DVxD4dLDNQGuG6CfZrj/Aa4FcC19FvdLCoPSc9LXtzDGivs9H+95qvL1gac+8HSo5+l9Xyg8hcLTO+KT9nTk0EjtOh3RRz4dqX0d7mcmRWp3wB33QFgN9x3pkdpX4T5lbKR2iw576xWGlVUh1rw75dPpcrBE0jzkrBtV6j+v3pj7ly1CdPmXG4s6zj+P1iCCH+7X8lleTeuWUjzh72irdN4GZcBTYAA6+0Qri/cCPPUzYspHQrARZxYpxHWtm4QJxtwm7eBgw+DWQcueaX1/WZJtU4t22cvZmooLLUHLRsr2JN73lLgTfwmjhLdvuvTWOyye3WB9WqLbePx4FXrIeWChkvdH8De6JxZOzIu1JR8M4seKq2yjAXq5e2zhOIBGAzTdN8xgsGbAlz6udBLBf9vd0DJapn7tsrw7fy7uAipxdtMF8RylmGUfCWlG3FelEaxdhhHb6LhKHLFUk3e3JC3bJGQZcV/JhpZR8MwYMR59Mn4nSQivPLJJMBsV++PDNwnZxgh+W3dUYRRQowBqrnc1tCiX7W6JWJZswzSCD2C4NCYQ7mEjhppm/AukPd2o5L9yjxXnyqyW81HM36G4H6on+1U5T+fPn28yHndVoa8k5VYoyOCx7jGFYyHVUEh1f9cw8N0kGShABvkgg+geGeAJWiCH6UhJW6uy9COBGDGXHEADLXL6KeRzA+6FADVBpAHrAszB/q26SRgG6U4U6R4oyyUCOOwvnu1beQS53CQkiPJDnAHGAK9RYphokdcMYzKzgAn+H+fsGF6KeO45UQ5bZP1FnZDmiXJZj9zWFWI/HZ4uMISJZtRcive8QIiaUws4CxTn6Km4I90kWVeo5uYLKCc1F+6dYFVxnf5ejHe61ft+wN2AuBmCmlN4jVbURFJzuJ2Ui9PJ1p01EfKQSU5X3G/vK9DGPHEldwLI/C1fZeGbIPMEkHmr1wrw4QDd5ttRuAOgwzH/vb3aGA45sdoHkje8JeiSPgLZ7gFJRIDGhY/cJKQbFS4jXX9EkY7S2SRMNJraOsp3t6zd0NBiBvmuWTZqB55X1CXvVt3Q8sAylCbKOwBDKfcXpRxjVHHL/c+L/Km4G37cvQlX8Kq5qR6bnTJMBDu9SYg1qrk14DeeqDGZVdwzfsTIva1bQB9UiGf75PmpytE76OZVNFwKRSXdvJLGNOLENOKNdCXmtJTLKi7X/6ic3odiejgbUs3FiOnhrHfUGjX3UE96I/yIIaWVf1u30c/rIL2GljHLrrZMKb0qmOxwvVMPORugAC2OovJqS84ypIQFnUVqBooU6EVqknr0LrlH71KNfVw0hbBBxiA+xYvngZyyo+3QQW6d6oIUdCPzdJBbod6GW+HUiELc6b3hViQ1XHyixHkDu7Af9uhV4d2qq8Kbe/JvR2zMvR2+oLKFxO9qISGdfJ0Xd5dFOOilmK7BiBjx4QGcTUKKsZM/6NO3ajd82np+QwzgnW1n6E3CUCgTybZNwmSjElodNH/Onxs4z2azpI95hz/d1fbjsgcCduF12e7/NPxpM9qDxeGrJqGNwDrAhuP2cGFd8Lg4hk8n7apSMdH8SkGZqK5LL8hg0vNpfTB/oqtvo+KAj3d41YmR0AaK4v/iTy0g2zOYZPH7/i4V+FxJBbQtUXzf00Xp1bzX3feAnvHxx72nhUnGoo7tWQZOSffd/xG8KXm7gD0uGNdjfowpoqCWRZy++5X8Pvjmqu97EEeHfPwuL+66gZhmfwYTXHCMxVHzHc8hBFepx4GvXLU4UnsGrn/ChfuO1sGdKgN7ePzh27qQoQVJHMmuML9SpW9IB+8rqAFknx4CZftoVxZ8V4nes41RcN/6CEcTKq2/Q5E2wpF2lNLj+cJvQa4oudMejOsmu7slOp7m5vvwrTd0L94Bz/Tbugy0OrSLZP03Bs3liWE/Z3shmb4bbI89gZ836VYmzgdGvJEcMYcwQY6EfN2xfZ3lka+ao2qVeml+W5mdcvmzo/PpzkZ6oznm8pHO8oGxP0RA2zDBQQJnZQNGHxnjmoih/iEYMDSAUc8qxdO0f2TxRG1p9ZiTle7iGL3/6nKcm/xbOQ7+jRzDfiPHwbIcB4IcjSDHXk6/6fp96RD97pbweCUX7Pl9udLcR1345Rv27jxpdyPszD2wW+4L7G/lOOE4pDg7lSOWY653irhW07KQ+mMuf9HMK1dbisBqFgWTYdKJ5RNOTyl80zznyjGX5ckp9diOw7N7r7bkxcGVvlu6JsHzJLiDT5NXAPfZcJ8N92C4SgdBHTg7gW1NSv+gVTHpWuvaSftaNQXXW9cWvNuqmX2jde3s91o1we+1ri3Vw/391kHB+tbBweMdk/InF1SSWMvWFrLM2JobHGExAj24zysZNh5shr0Oz4yccNrYSuB/d8tIwNIs41tJzylkHzTgLg273RnAQfiVfZ0O+k2z4QqecFsD157WwcuIwQhpfQVvFSzGOeF0EuCGXOFbteIJaYijMGC6ZyDuFSyGQ2za8DKLe97Bl2UYA2VA6HNs4HxU0JMHfix55b5ZdYX3J+2NOr3A9ezpsQvW3f/G2rdOPzv85P0TXrt+OjU//IEL30357NDBgw+kQdmMgeubtvzn/P6/Qfh4E+pSMkeyvu2zfHJ0RsIVImpJUn1sfmxWMOjzVfDByoC+nhMcGki6sqGogyjMHro9xqJvomgCtrIs1w45q/wB5VSWu7slFP6vgi95d9hOCOuqJ0OQp5jASfX+5QTpwQniBPVlkr7AIOr7qqrYhqMYZ70RcoCWtZzmIj2SlvcDLR/oOGGn9A0tVDBoYbCSi/M1sVdb+sHTArcUovdbqA9zso7thcxy/3DX2zQ3fv8G2gm1YfmZqMfoV6A0XqmC/wIV93fvufbgaWGMqS09a4NZzcytvSpYVhiZ2lsFUGerOL+39lbeIayn0Y+ZyswCWKZnGjNHXJ2h4sZ7AutgVNxIj5IbqIDWe462+QvVpVskp/bWVNELAA89R8Vd9pLkMYUqbqCn9tYUw0pmoxzuAqTxENTiEZ5RDNbQk2X4516MG9c7qLhTXsWbmKqKI57rdAPER5LfjXkiC9dRQP3vVXF7uyHPgqW2ZGQnCUtxHOn0L074Hs/31QCvgfNK4qGkRvWcXhJ3EVoTPW/ll+TWaJGS+/g0tjXGt34QfBEsdUiwk+399v7p3ufXT4Ndy+z/vN18zPWvL/712j+/QDlPAJ3EnMd8l3SJ1Py+XibKejn4v/QyEfWy7n/pZZisl1dbQu4JRUMoRf3uFjV8I0P8v6+XRCuuD6lqtYqntBNutKCvDqzm0J7GJ8INEfT2wF7rXAPuxy59/W3YqN8JG3J32Eu9YVEmozli6uvY00noo67uopAfNIXmxF3moMt7XH5ToMbA+kaqUcpyu4FuHG1bWYU76ZPKo66/PjnTsa+TKI5A+Jnf0y5TjqrzQdV9U37pc0b1ZfvZgpg4ZXNwnIrL89SJ/uGbHpI8DjSvUfTXUSNV3DbPxVsW0WeUtG0DvDOA6xAu3jKLbUpJ8/7qaRDjOCfg6hsV96KnnPklaj08aSCECb4sglQUcD8qjALdVXGHZcxDgop7zIdaKc1rgvpefppNohxoB8IcJCO6/ohreVHE97ga5S1xL+7Bom+9zzWheCuL5fgq1EpiuFwlt/hThATeln1a/hy21bhMuZoqlE4EE+W0QwdtZpAytYDYQU7wdhJq8FFf55dzV8o3mEnbAyuIga4gLhOj7nxQfW4K38ev+kf7WUbZrI4+E6/iDrj/LXLuc5Pk0yC9LFF6KDEV1JcrGSFqIzytBizkfgzILU8s7ZLcrrl7LcMgASXVK9OLbpSxiosTpom5MUe2LOfvCvOFG/OnN76Tbil/iCDZgSNuzBclJ/hR6kquwy+tzVNxD94Vy243Sf0mhBi2Hclr+0z5lllb87oZ4/zjD1eFMXvrbpnWG8VVVRMhhh/8+KSEp+/8gRiU3D/8aNWCm78IvXKLrK8DGmSLtl7FlYFk/lSo5D7x14k6o6SkVJ9y1wHtSu6g/16LNtPda9GmAf1KwNnhpyuBk/U3YkhyTLNCW9R0bnR+Mx0k6VCmW8WN7UIdkmY7bzDPq80msxM3mG21JM1YjzlYBdaupiP+8NWWR+7WoGA9lLM9rgnWPmye3E7aDx7wRCdJnlIo0fOqN+1UtvhNel8G3zM7nj9M79DI1i3j1JftX03/a0b/hu0ZyVeo5LOu7bQCrNHsxHRzH2eGKaamqKN8NF2BaZ1ke8MFnUI9DbwNOtX7RXsKab7JTj5V3lFOzyERQH1c7d/xJBQWT2glaYPB5j5ST/QkI19c5buiLhCWO7mxozykqKmQxlA3LiM+2PbZ41vXBj/LVoFdaHWYSBWUJ1ftUfhvdVaB5jsc+L+4KSRkjLgmvqip/uWZORMcaNWns1J757lLTr/f/6R4vjrZM+9Mt9/fvef5nrJVSM7MOxOw60hTzZ3xh7HOX9taHjySBRlN2+taTvUfsq/2C9d2QiXj6F5W4hBzpTPNtMuBtbCO2Y6r4WYjdzEs2jIqmNr5OUh3n2u5Ijo99ApJ19Xr8nRZlFnrAKnSEVkhFpyVGNJYnt7HgecbYh8aNYqCOoVyZnN/nY61AcLwNFysqfAZfW1wtUW/I6nH74j7Hb9DwdXK3nUE+B168DsCngPNjRU9i1tQ50m+x4/Cvb4HzaX46ti7/ZR/CN/f8/6ZgDGcv8v3kGiK6KEp5ndpes2HixgV5IyLIr2xXZXTp4Ae5V301MlxG8V9mPHcEA7qpUFTNlZBvdT1upsYA2u7qdHDHdNvx2Q8fDsmRMUN86gY4ymsqziom5RcBfgmsYXYBlBxUZ7z9v6FMXnaN6hkKOeGTRDzJqjxlJxejFGRsalFHRLmsIF1iOiaaddWLql+q0VdWdWaD7GVBIeI+ygYTyt5jzvJQFtbWSXf6dZW0tZm9k0d7n3PZZ5fEqm9uCRS+3t0p3b/b7qd7nvpHn8X3dXu/0X3Oe9v6f679/9E99s9dO/8Dd0OmW6Kiztxdz/VVSFl38aqx27rFjxyu18hxf0q7HKT8gBfJ1z+zNGOwJpXFfesexUz89SoHrs4372CIWnznfiGPTkqLsOtP4pPEn6KG3eh+AuU2PdfppIPFl4Q9FvINvA0nwGbmwNcvUxV4HjlHwBj98aAdEJ6+jR65XXAI+1RsbIc1+biCimUq2RrXQJJa3Rgf5SSe8ND0uocuGJZyW2G54sO4Mf4agG1TZlEkhUZgbQv3FKvJ1u122hRqqFe3Skl7xdw9eiAxl76z0HMR4G2pRup5JeR+qoTLkXYPRxspCr2inE0QWpLHdrKeLuSrxNQ+pBHG19nJVry4etrjt6Y34GY1zjmFyB1GC+V1EsZCcfZVdZ8okd61dSjTuwtwZzVVpKMHxz/ZCVeB3rQ6v/psJRCjPhWdhh1LgbqnVhIZTvm5haStthJG64KQz/XbhmC+4VV4NrsC4LyjJSe4hklx4rrlHGNWarzqhC5tYiz5iG1mLMoK/DJhAmnkM8XIZ2TQJFNlNZx0LVikbYV4G0PfRnzFLGKAesD516AZbwciAe/gU4IVdXVIMUGx4+ybGZ5UMOkshACXw2FSDVQYIaUDb/IWEwPFvoOMdUxhSQZvyPuv1kqOQLzp7w3b6gK5OaYKHMdEws07e7GdFGimR2PHj50T3+L9Av4Y9zy2iViHeInpBH7D77CcgT33MC56xursHeZ4hq6BxcGSkuFm1iXJIT3lBcl92+/hplaHdBYhImeCrfXb6r+L21fRSVHFWr/hhyIuQIcbLcHVo4rOVO3YjjSHuyk+YN+SRumox3YeJnFHEKp73eTtHZnK0vzO/2ogb+K5f/KEhxvRarTpmyoQmoprtCPloUajS2BMY7AGuoR/0aq/Pxf3Xfvb5/SQBniCkgFahUxUNu0FUruT+I+CtF5QKsBx32VYBt6bVU/sUTMddvAVq2qbgCqoV3m14Jvgy2KYJFj3WmaZ0Q+bgO9WSK9t0R6b8i26l6aFVyY8H+iOeX/SvOA/6I58r9o1txD84zfofl2d4BmtruX5tsyzQrukxMOke4NVZx4GpYVKC91pxWCdpiKEyb20D3m3x2tNpmD44CJT+lOyjBQpHpLD9VfeNFvRT6kknrSi/7qd/ZevR7tUwxFzegHmvFWt6QZlTIH7WLrWqLecRqwnkEuXwfr84sDrUmzg+ZXiXzcFPno6JF7QOqtnhSZ9qAe2pVAsXRaF30xIBnKEP8beT/txRKKZ3UqKGL41C5Re6Wrl1pGpnajTO2bd1GrQ2oNSO39QO1tJwsSHy5SinuqIa1dS3D/eqEIS+KF/FTwTjaa+zRAqzKb7iyPMGSbuNPlZJipvWjF7paDITjv7cv8jWbNlXMFFWbS/lk51EoilAw70/bKCmzlZzBE/1m+WI6g5aTkHveiVcwRS/ovXVh+K0Wve9ZtHdTOD3p3iW9Kbpsby7ySs3j/JkPWypDJ3jdkSLkMGeXdJkP+KEOGeLfIkGdliN67SYRgX4tkSfp7N8o4s2Wcvt51MmS6DFF518iQPBnSBe3nDcCH2R3oBVJyCV2SDWr1kEEY/yh4M4oW5mdPYMxLyQ12jxJ7igLWJ8nd+83r7Y0tyj1KjK2f+F3J9XFjzy1KVZKnFILIX//jvfsr9qJkiN/3e3KkETbQdCX3jsci83FTkNqIOzxZMqRehmz2ZMqQizJkjec+GfK1DPmLZ5IM+UKGvOAZL0ICvQdKboFnrIzzsYwzzzNKhnwgQ2Z5jDLkTRky1YM9YkqoXwPtQiVX5pVkbhalmCqew67kVgm9cvuL+Bwkf3lRCMhid0tCyAvsXeOJ8IsZZpnhTXJnBvG+Pj/dr8hcd4T6Y+Ov+ZmTN9uOp618N/MRy7q+j3z+deZfFjfT4f++mPmI+Psyc+W24fYvTxzNnEVtil+ovpl5fsOsN39OJ6bCYRsSBk+iTZrHI0cPen/rfVL8QSao07DvFuo9631S/deYKY2XkuTHgcNUgSTPgfuPbjkHQCeUnMMdkH6UIHH9lft+GRIsQz5zB6RPy5Dj7gkihIb6W4J86B4rQ1wyZJ87Rxy1Xc9Q3AivJHeU3mOix/O6e5iM/6OMv9GdIUMcMmSlO02GfClDXoLSPKSQ5mr8vbm10yPl5AL3QBn7Y7E/guY+FLFobr94jxVzi+Z2+zG33rn5/3d+BPIA/XO0a38vBLuWu9u8tqp/g8ZlysWWmKazvP/k7AxHbwmjuSK/VMKGeZBOqc/hQOFu83Bm9JW/u156srxtxgrJXki5S3MT/CR5L+TsMq/uKMbRGw4xlou4qLV1wl97yqakx04h0MtCc1H+3nDiPkHcN11EjyM8G/NpTumX7M8JYfFd2mMXnpVlfqdbyqH9wgIZ0ixDdgslMuSGDNkuzJchl2XIJuEpGfK9DFktzBUhF8QTuJHWl4UnZZzPZJznhcdlyN9lSIkwW4Z8KEOswhzwLmnu/e6ANkIdtp7ibrofA5nOua07RNoNKwI2bA5YQprb0t1wSyH2JTWI5dsm2rwGeFdyEwT0AZEqMzMHNBAt5/Aey0BzZd1m0dpK/Wk0V9rdazUsbkkfrSIsXtbHx7ql2PH54Z7QJjF0ofhtsIxp7u5N5z7pWf4ytpsMz+TZjykXyY5lrt1E+/PmH8m6+26M/2vA/gT08/9rvZfiF8fmZPsj6f2o0b9m3l030Nwuf2GP/tFchb9Azqtan1ReN/hzZcgFGbLCnyND/iFDlvrNMuSUDFnsN8mQYzJkvv/+e+oGmnvCP1nG2SPjzPAHLNhOGVLoHydDXpMhZtD5RCgH63y91maeaAFpboxfui/z9ZYarI0ljSkSe0hpLskv3Z/xSTlf7FPLaTwuQpRy/j3iS2TvtR9uUY7/X+cV9hc8fLtfSLYZe/Pp7CSOPLSg6KGmH5acMqONSqwtNhuywU4VFIiwA0xULSV7YXT2/Y7X+qs5hXp2k5Jmmi69GOZUDJ/moIff58yT+GiUZMJ1SfUht/YPTYQe5PgsZ4TjZE6y42Bz375FTcP/8JnrvrBJV8iQ++oS4WliHdGTJGr4ww7FcLODDG90jJdl9E1XIEe+7LrEYn87zV08gW3BiPpRYorfsJIN/AfbljMWwocANScc1HAoo2S8gySdZNNFvE/YFPF+RL5/xfaWpJdEu0dz0z00956ArdITbLSc7nqxnREl59LKrm2sVMJeYxXDwyGtUEhL7YgQv6/GHR2zVrD9xLe/yPeX5PsfWbleOCPl8zs99UQgv+V7TaA8yfea75NGL//zZcUZ+S7tLyb3+2BeQh7mPAJyrqjSOdCbXVQ4hCOWN80P4Wypg30alC6TRdlZHjmjKZh+1PlMPtEjv9JZEGFMv1bdN3mOt8zNV54sfMv8JMgfbduT9bjTHO441tc5C+DZDvwn3Kvlf3eVFxHu7fJHwXoS7sQqnMVDgz+AcsNdd9ROMnS248HCQZzJvMv8iONOmNrlnzQH0l7iKIA4TO07y2mXcgk+TVjNFL5pfr6BjHi+4QGpRoN2Bc2t8X3EYl+SypGZJ9JZRHMpJ98z81c+ZJWyNk6HGHc4xkF4U/vyVWTEw/VY8raySPObjtXsKEhr5JV9rhmQ0o6GjKh9bf7RkRmm9ndWnXWNoYd66DbsQy/O2eBUcJTiC5ciZC1LRqjqML+JfgDUeIvAptbcKTncK78QmnCTVp9yUWHLO544LGnCTMh1RUgJhD3TZlmFNqKIRTsgcVLilcp9brcFMF7FHvWkTDbQE0Bz/XwT2ICdFudmyLYTriy0p9gO9fszs491lg8sb7OuIskOsEd3uhZzY9ShjCHqQsG59ggl8mbhlj/yduzr5j7bczpMUab2+1d9JcqGWr275aOXN7Vo4dK9vLvlQ7FfhxrXZ/t7neVRWJdBew28AzVQE+7F5wu3gimjWDJCvZI0PgFp3PTRTCjUnX3HSLVVMJSHI10LdNkcmU53EkMwM4KhGBrX7WGLPFxRAXXoepICtWh4BpMs87uzqzd0vSeQmlQOf/D0+iIXPCgjsP934Z8F/L5QJv/U1SD1+lGB3hnIq66lPV4J2P+uF+Xye8gjWaQnul6QIXtlyIyu5wL2X4YUdi2WIVtkiLlroQxZCxCstQLpje3qpXVEl1luX6GHQHPPiXzRnKFLiqUEeMGwgTzv30WS5xVeEHma45Fqmsc8ih04ZxFDSFhKwML6a2ahlKIFYg2GWE13SWmSB8evaK7VG6AO296QV95enHRPYOaAFG8ypDTxLlk5vGYGPZ1CmTPdXfEHy60lmjst++8BzxHq2rvSENwNt3SA1eFWM312YN0+2RsYdZNkwgKGFjCuu6V8vepW7JBG+pCGf8tfvxfH4yY03tt+CvTn/fpQTkHaX7/JfLr+64qCNRcyqawBB6wvODMfHLT54UceuZTpP7S4/pNF9Zn0aPxdx/6/xqCvWjN99KQreO+k5kQ2jnjgM0JM2a/toMlLn4TI/YRaEw3tkRCQEs6RhPrfHeLyj0YLg5Ih3JMrdrd8D+VG8TLYmEPE8CjzJI4+PkNAx8kzUxnMQ/TWnndLOT7IO03kfo7MfaK3V/7z3AHJoBwh/vU0tP8x7cA4K81NdTsKd4rrOjcwpvbUFZQrMxvnfNHZJq57hV3MCSnmyffERnMj3b0pLfGRNBN3c8V+pqgpbfq+tu5RRR3lERFZ0y1n24OnVT+4t80/KirrLNgPQ5OKIvovXJEhlo7ySLTiGIvFE+LF/D1R860L52zRbqRwlMgT6qxPKGoKmd2HISmbe9p20Nby3EvRL0LAd6a5a8IaWZ/e8Kz5jT69epfeOYR7dfa80KsrZ+5qsZwEXwzTCpTKUs/zd/mXxZ5ACX9fkErZbE+gtbJbhjzsCZTw12VInifQWtkkQzI9vb7Cih7KZHl7sF+MUHiSnURTmdDrzU/xBkq+hB0nWzXrXTzMlP3JGYJka2eArX1I2GA5CRYfIWfajCseZrA9QnMed9INMtx/J+dDrHWlmpFwK06RETV3vv8Q0hwTwyhdJKvvDUwH6nmIK9irubG7Zbyovbtv3l8I3kLejhxT+y/lkwtDLHR2sFPiMlKQbMlDXTj2cPNjSJEKtMc/62mHV7v9fOMprGNNnKP8rCuSzpFr0kPgDVwvv874+aZTu1sG3lXjKF/GWgZrna9vkEHv3giU5+6VGU/nRv3tPnzLHn4z89eJnm4z3Ccu3B8693H9Z453P3u+ZPz8B1wLvv8y6/SpB4b+J/Vw6aP9MitOfxa98PP5mQ/IPq8cX82sduGLgc++RwUsht+/2eT3h4lp+b/dYiJjFmc+DnXicn7Sh3PgnsmfPUSSZxUquO1+5i6LmOvO6Wk9SPn2gBtzWUEVybZ4nFjK7hf9OgX3J7klkOGWcpDJV3CL/PfWFwPcvTne3z1Slma43K5UQCwz/IF5MajzCu4hP9EH9ps9/DN+8/OXTiGuQQ7dLiTJT62Cn486lVa4IyeTD/oY52RsYyqYUTfRh/PzwyE/YsX8kO468Q62IA3zxM/7T81ksqGVr+AU3ejFnb8Z8Ij8vPKUuM+qNTeKz7RcfUII+XiGJHawt1L+8Zm9/gsx0SeuZaod/8pu9k15QMoFIbMb/BjJzjoC/SG52KtQk2/gSO5m85YqU3tF+en8zeYEZiUz5AoZGivO8/9I5M7UvqVcwX3Z/Qn4m+L5h9ySFQfELwrupNgG/ka2PQruSPde+ctH3VTqNyCrNEYnzvb5AGI3tW8ofx/upF2/4v6o99qiczCVD5pVD0eL9sLrUXBXxfnpZrEfFUfLgtcruLXdJHkneF2ThfVgbaAuA7xv/ZItnCzm1oVboc8ouCWAtxnwBgviucm3+oIFWO/Bkc6nV0ijZtgPUe7BPa0pg8LwSgG1TZGUzpCtwfsfZijuGYEMVTGRdXWCUl8nhBoVLmKmwcfMMX8DkG8Aom4sbyEhJJWknLmlyMG9ISTuFNz47md75KNbMVeWwtAe+eBYoYJL7p4tfxnYjevpUEJXWAX3by+2G1AaM8TvqH/noO37Bygbwd0096xHBZCH/flyj4wa9PVYTw+cgrvjs/SUGPRAsIdFwe3zDxyGODhGY2o/Xo72RdL1//gQMzPq6/bg6d44HXjlR8snyLUaxr1GzIXesvEPX+D5AvgJCu4zcS9wyH/f0HvSVXAlfunLRz4xXUoBcC3A3/N9Dmn540aOQFzS/nb5W1AeQDLr0S5K7XZMaasPqVRwm3xkKEqn5s6Dh4NcxIK+/iIz4K8GKG0WW52xkM5LPiLqGXyhxvf0+5rE9tzI4nlxc4857l91/utFxidvYL+s+L6kjB6+IXbfZGzjvQztOcT1Jk1Efx/8/7Ks1S/geGVjZpacV7k+6Qn9QwVn8t2bpxN8E2W80T5J59tvSrmS4ZtYWJpYzkwXko2nzCDvDuYwcryWzZBDJPjS74o56jcxh/gMMp7WF9CWL2/Shr03B96VV1XdgRpRkjTX1Zt3WlkTbnZhSVFw17rCe+pnKfTWbunLpa6ANl0Q5X9BjOUDeVz3XrmBURHvn+frU3etenmi8gXx7OOseQXYs3wym3BvlJMRk9GGxI1hZjRkRhHucDn4OfQHbf7x2eADXQtzaxTN2XRRk0VFX2oJU8Hze4QMWq47xkTjLn79QpspssNc1HTphaKmHBV9JT6ONFOhfS3UJKUY7mGqxaljtjP6FDwnMKhxmmMOoe6jmy8tKWqapsAw4xzFOYrmvpSrgQyhmhV9g+sbmX3NofQB87oaGrzLRXE6yznmOvsZ1KWu+lAXpf2VHQxxjcpOd5AR+c5vgqMm56tIuscR3lGuoxxTG/XMNHJJQVyU0n0J91agPMqOW6aBcVlNCnozm5E9xGnRPqdr11Cu5Q9TnaRfXo2FA81t1kxPFu07rnQ6YD5YK9HzRf0OhhhOoSani7IKngj58LVPyo+wQA/OCnNCdI05gRo3Q+sQcdGOKTif6NEquPpuxHOycRDqIBvK6FNxhfdRFtuy2uPybNtsnC2K45D5jqwrR11/fnJq3VFX6JOm9j3l+lay7GrLkji40uGatBvucE2C59lwL4B7Adxnw70U7qVwX/Y7s/Fn42z8n1vXFvD/D2NvAtbUmTWOv3dJcgkBoqiNCBqICwJqFBfcSkjgomILattptQvWtkbaGWntYlFLFK1bncFiOwq1WrWtS61ES6eM0li1rU6nM4lLR0Eq08VIUtIbQHMJwv2fcxPQzjff//s9PJeb+67nPee8Z3lXH8FV+UU/w/dw3/qSr33Diqp9fMlu3zPyOnxcJ880FftMJet9H4bXw+L/XS2Pq6+1PF5CUkI7B7g6kjKvAUrblAE5PoU37uAJravNu32tJbdkV0suQJsLEOYC5PJvgDIXoM0FKHMB+tyS/b4RU274kgBKDqDcMGufj5uPo/7v+7giQ3vpIoMQw/zk2zAfT23/wMeV/OzbsEnwzZjv9rnnj4D6jL4RRYLPVLTBl1yCUK7zva7+wLdejav2ceUxV7erZZy6yv0XeTW/Sn0L3oW+EYDRIQDTEMDiEIBnCMA2BOAcAjANARiHACblZ5Pbt2fKh74ygO1DgG0EYO7D+e9DnT/7Piz6AMr5wPchwJMrn7uOWCHCt51nfcmQdwDUMQCwOrxE8JGiSQBLE2AY0zzg5n7tk8GW5k/h+wytG/3VzukL042O/er77x31O8pUXv3B55NdA08eOphyrzVxT3p9zDnZfmuImWnCvQcQdqweft+9xwN5h91sdRZe/QR4J6r+E/+MJ/5Qf63lKXnNNba93fe1vO563tWugLIDQyb5TL1Uu9YyH7AxH7AwHzAyHzAyH7AxH7AhP0At+SlBSu33Mb2UQsr8DJR637cBsLGh5DpQCDmg2pdbuRgoRQS+8z7cX9J41rcRcDIb97AhTtSIE8TNJN/XalzPhftRQvs97nAeuzmj7lpLFvBRpkwzDGkKndAP6QrlfpEGcKcBzKMA5lSAPw3gToOa0oCKaQC7/LsEqYi5kYpITaBiEVLzepia7/s+lHeWXIffuC51ve8DgFIFtcir48N8iDxo9y1Gum96xWcrgTbN3wCl7GrRleCqeGzT+3IvIoCBxfM/8A2fX+4bBm3MkXvVJjeua++hPdId6f+/0X7HjlczR9dNTUeaw/sY0D9TW7Om+ltckVkFdqH5qF+S9/borqJs0gskC1fc97mKsmS68517WIFmsz3OF5+vpdNmOXe1ZKuZtNAqe6Zpp7wWc4QaT/0w1+5quRf69r0luAcR49vcWLbeieUZnZvizvefljLhKkmdWD9t3Pj6XS0T1FSa2UmnTXKStEbntZZxQKNxMq8hPS+6ceW31nQ7cLwOSxgPKdVOJm06pBwJKYdBbk6ux+He1TJUfcJ9rWUwhA9Wk+T9cvgxCI9T/92Nq0lx7ertwEfS7cC2rtOQ8h55V22orsXqd1HiTkEbEFeZ/tlNp2mhpkgnrlPf1aLtrWkTlMiq17txf8xaeafEarBFAKcnEb+4rwf72Oi64+nYz3BPDLwxPvOnbwachMekBeqnA46nO4VPcFfK0DAFxtRjG9OubjKPbmAFwo9z3jtjjXlio7N/aYb9Jol5vD6GXiqsUpQShV+a0HlJ638tJr/hTNsA2txO6P7wZWk43TaAsbQTyjSIburrnE+ojHlxop2kivVziegu9OnVNt9uNZ6h3PO7OHfYrLYY2lvGVLQQtd/dn57ohFrI7wkZRfySMXj1pDvdY2CSHbE8Sb3hHDirwsxeXUAqzAhFsBHr7VcPOegHB6VmpcvY+4cbvpkFg3aY/oq/2KFxe0wfu7/tXzp9n3vvTcKkW0onWDxfyut5P3OvNrONGIe1/hnTk01uXNP7xkt45gRS5W1cQ5u9zfx6tYJf0lgxa5sZQovigI+GCjHstZbykvJZTzVuMxf7FpcQ4Z+2XS1/xL30RZT+Fd/1ki9bSBHurP8SOBXPsFoP+Rc24i42W6vd9kP/16fs856ah32yzueG/re66DNIjTm2tDDy3noMvxPGymE3ob+gHMSb703C17aa8LdG9jeKZ1Jb6USyldk/EryEDRIZ3bf+rRZScglgsPtyIeXiEpN5HYQgVGwTSYLfanMh0SOE2JIR0JKN0JIFuKe8CDX9nbasl3M1u28HcrqvtfwOJGoByI45JaiTmkAWdoX2K6tFn7toSLLd9wxImmHqZyDf3EbciYY7zX/qf7rt63k/xnGpcxvDOhbkjgkk2Yj5Rt/ToPtGqFEmfAe5Jsjl4W7ar+f9FDcwbc5VhLwaUqGeJ6Nx39s66GG767FtKH0xHkNM5rfdKIeJHiEG6Ev+CD0vFWRpagm2Byn0ddF/Umml2zx4aB7a0kMFia40I8z7nFjmV5A7HnLHQ+4PSkJYWV/0n5h51M0YpkPf7Aet6je/Wm6NSv2S7yToFRW0aJ28H++78FrtH6FP2qDvOuGxZE+YZIuZaYFua+n3cj9ubUdSJoEwbu+60duAHwm8x43dMtQOUhjXnuO8EFrCoR1CWaDBF24Cy3Jmrf/VJ8qqX6jvsfXKOtE3bbH1rAGmhb+JK3vHQWjhtLhC/qIETh7hAH9LXB4O6eoOhdjFl8Mht8Ih+8Vl4RBvOGSX+Hw45KdwyNsirlYiSc/nhfz2P4o946Wh79dFXPmKUITgeq13fp0STnb3eApU2P8n+sKZlPCJbIkyveuNe2aep8olPCbyd7XsITE7DFFVGKL7RHM4pDwcki1mhkM2hkOmitPDIa+FQ8aJU8Ihr3TjHActjBTvzduRg637U+M0+JV9lSQduEliiX7SzHJ+B8Bc2I3jhSRpXLjtWnlskxIe6P4tDtjf4IASbkt3cHDvXTjI6F09QAnj/gMHu1r6/+YrNjwSR1ZcEx8uPxH2Vy9mbPi8Obi/7oz9k7p3fYn3Hp77ji3/tTfvLe//zcDdVPDeV+Z8MeC5Lx7KnC2P+7yf+dv1te7wfJWQOS79Aryb4Tmf2TM/efjmwFVfzN7z7hf3PSAOL1RVXBy8rpN96ad7znjfZ4d6fnoxgV8UvxfkPDWd9p5mFBXLBrJvR2yj3mLKI7fu8ypUcRenZuPtVY/HR/ltXKP4xptc0yPiCEIJaoma9BfzjRs0xYG/1F5PTULchEJuufDuOlVVvuc0Q1ekNDCV+gO0l+EoLxPBVr1wEOqKjLrZVIJnfAFGlPCo+jQw79zHv9RMG9qhBErI7t1/RAkburJz0Gf91eW5QS+uz4nwcxFNrsZmmmV36LM3kzV85P69fo4+reMqNIdis9UVm/nthxjvNwzuU5nXnJwzsrEYv7kovzGCJJXmhejYV6KFkx2UsK+bJK3Iwxqwr92h86wu8K87luNZTCIbiXMTlGDuKj60PQf5ot7VKPYrx1UtMyB86G2cv8f7s0rnhebEKeEHmR8oIRgkSTiytyiPEi533yk/rivk+b/WYYOvhd04CzFSvpUmqisPNKs8GtnWZIv0S+M0B875dcwcMakgJ8j4qSDTptnvjTOBPDznv0exIdsSVNwko9Ia5ZsLwZs1tb2+RvMOSTMJH9hwxlTt1BygkuaIbP68eAzdaavKieNvuRRAg+hGKpUIl210aoRLruuQ5gBK2tNt/ZkseNOjiPCxrWftOS18L6LkengNWwWpJ+flaK9G+m0WzUFqKrcdrQaSNE9kB5aZzR6K7nCRFJNQY2OrMH6uaDCSVJOw26aupAxzIRWVTkYGnQuyI/1UxI4cZUXe1YhK1Y4ILw3cEqng/LYZwDmRe6s4v5TBeDdwSMdzEXur9AcY72aG8n6poCseFtkYSviiK5KndtA8Ganwc5Ffglzo4a1BwFuRTcWv9uMOHTyYQkjxvTjOQ4jedIffNN13+K3g9gNhfqOrtuc0A889xv8dqK2rvnCdMpAkzYEzftuLVTmAG1N04xzRoKe8mwkFLV8qlGaRpjjrpjiLyKaWmTtc1ND73ErEarrmILS+oKV/qpskvZZHC4+IOD90YLWCn+NGHUD0JSBHtbexZpKW2Z57RLF9V0sx8M+tIMKFY7aUQOT4DDdleMr9W1oNkGmV7NYcUlTOw1sUpnzbrFynePPZ2gigDjUV6A8QImUigGq6KWSk6FS8iXX8Duo4E8R1HcjDJ1vPrc73nGOKD2KfxR7FeDcqr4kFdsClmvNzKnbiQyIbBX2lC+UwJfyhawG/uJmm5ob5+pkuzaF35dFQj2vGIaaCqvgWekqEn2IaRW05XXGax5KwPpxduSaKtsf40PgjGU5GkKFM0wPAU+IN2nBTps29XXdos6aTGv+eTJ1f6qmqH4E2VAVdpfZT6sqcQ0D3C649VdgvmdTJl6/diBWuESX8zSMIB9aIK1PgoSIamJ0K7zmWG/8i8AAlPNT5PlBLVYXcOWJ1ZBWeQhLJM8BPLlm2Z3dibk3jrMPUUGo8wAV5pnW+lyPWh/IkyHloSlnFCCoSBXIXZf6deVRZXptC64qawuPxxfdmAE/2QGZqG7maqfwWMITYpyou6AAjhyL8ZB41lfae4+iKrTzIosW4oimsk+S7/+7gplXelU4JQvCLnD38If4swHO2meT86EK814IUMLUFbFQVU0nviM0+R6D8xZSfU1Nb38yOurltRUkzvbFnTJ0Svu0tPfR9Wp4rh34WvJAznB/Dh8ddoXTqHaZKOx7XVsRnM36tIoTRw0HEKPOO6t2LQNmLOGI+mghbbOBP5eJ4buSOL5pZRlk1nN/GK/wkG/H2RTP5+otm+qke/HHvMDs5ueS07FCpa4IhOsXaQ+s/QpT6LdZ7ZODLjfSwlT8jTzVfJ0M3/iz3h52448dqpoS8DrTSSFJGXsgiQ9uDHCNJE/JC2GRuU4K9m4Vf2zpJ0hiQ3cHOnjlqoH2QEvZ0o9TSHNJNsIipRPGWRRxpeuh6KPe2bs2hKzyG33c98h2E9UwzYe7mqEFyj8sMfBdeNfj99ch3v8LR2aqv5NlaFfkKcNbTpj1VTGrmLefH1B6QIkL/J7XcpCdCjwsexNCLYSmiBCnS0kEPwz4y9GeMmeYOyTuUe0Lveti77dNh8igh2qdreFV9j/4a141y/o+2nnUelPBq593zr5TwfGfub1b6UYK1s8e2O9QR4pcnOntsu33hkIc6e2y7HeGQ+zp7bLs3O9A+wzlw8P+TRufh3jRKmN7ZGF7DH+LFCb3r5sH2C5eR2okWGyUsDa9D7pnLo8Lz/yH4nuy4A/38jt/aa3dSKTqjw/DM6AjZh7eDIVln/o884Rs9w1/Y32f2zos2Za689M/5U678PN37Tuqm6z/Pv3dVt/13PyZ8fe+lhV+AbZeS+YGo7dOnz+rMnnMSjvlnPJFW3wVeCe5/J6kLnKER2rGzdrWMnQ9v8OnGgm83FsOKPvQNne/2KeZ/6BtW5PYpS9y+EUXg0RUVhsZMIWy4Gnfy/MunVE/yNYF3EiotAUpLgNISoLQEKC0Bw4oSZmF5FWYcu8UTVdAvcsMbS7zUeA/4+PdcZfylFvSK/wKlT/QtlmsCD3M+1vQv3zDwwJpKJsonLfxFPpnhU5+q6KaPLvGArXv/v3IP33oxZuzK1opPqCjnpIWRn/710MGU6Tt27AC+nJHZcz/3v6oZ0E90xYXBMxyxCUdnP7VTsbVBa/D8uOwBcVghU4G3nu/xnuUGeCPo1/m93ghmwMW47F0tB0qe3j4nPu4gSd3nKBANJjy7Am+Z/MiBp6QJ4IVuNv/wC1XiA61ORud7yth8z+vqhIa4Q7qBloPL+IEDaa9aZT7cLu/du9byVklEA80v4tt+oYrGgQe52XwdfMmA62coo85M/CzxuA76OUZ52KtjK3a1bK681rJxE3lbcegY/2J2Zbb5yMt8vmcz9dChyGyUSLEt/dQDGlVgtaTwhb4I8JVNsle+rIUqQgiPmz/03SiZ5PtAXQc+7x6oxesy8dRWItgk3D/0CWA0GZ7OwKPdrfL5Mos34So9akeX72yl6GsuyYAQU9sZtBennQXIHhTT9OYgIxCwFi/E5YhpxoG+8r+tzT7rV9ER8MsSpFtJythGCJ2CECK2IHwKaKI1yVa0Tl6XbcdI58egsSnN42Bn4T0MJHmlqyrnHbAesf7oxs8gDRHGrcYdnSq0dcY+KCYaGSGTyYE3nUKEvqt79mWZcHYI7cZpi3Ki0W7MoibjCdpED7bp5Dk5Jg9DwGaEumNXkypq6oNhi5GsZqsQBrBfRgIMGpLS4byKVmP09RzjVaaKroz2MtT8bMariYw7REG5jHcN/XQVNZmB0lXeP0aDvRgJdWTuahlc0nNPq1amdRPgOqIhnaeaXgA6I733mj/AUVvXIzkfQxzN/+D6kdeBzQWWg+bkTVtxVQ5gk2gaAToyMhtvaSBNOutJv0TA7ovcbBZdlL7YHSPbfZBG37fvLPdHr+K8onxnKo4lTCXkXOat0D47GTO21od7sYS3ZmW2P3sEx7vP+gnZypN3ibCye4h8X+vX8r68k5D+iZZYefQa8MAgL4F1xmG7PoQ0+F0H/RM98RwxVQ8SBd4GvYnHvkkqCPi8BGyXk615q7cT80HgaM2QlhEl2mwqQeHV0IgLLOugebHPVoLnKy1E7Lii/J9FD2kxFin4V/CGYA78w9EnWxWr35txrWVPyUge53tIEtO0x8xdrQbs+QGf1Li35d4DfuL47Bw3hL7vZxU/uJ6qZFLmgZ1GC3/79NMFCJfRN2MTroBxfwy8/yYR6G6qMgOw8v11pL7CfYe7SmXu+uf1rTzyOXl3Eb8fWk9S/ujS+G1magreoCF7GFPlcLB2V7tn8ddaXi1Bj+SUbWfL6BJFJUk91UJAbi0u0TSOAQ/JDrBR4yrMOG4k1qMXZhI+symqTkPbsZ+gXv6dvEtcPikuFfvbdvLQQTob8cIA381tSS6iJkd7y2QMQn8ueTsHR7HWyPV8gJKo6BTE/OqiIPf7tocO6bI3ksiEAsi3LHvMwWXhXJVmzFV2V67Tci5u7LWWGSXRXoqJ9nPR6RD2bg5C2+HK4xtbRhftbBlTkmr3+54p6hlVROhJURmkPN1Cl1S5Sap0q+TIaPQH6GstE0rYcSjftppDpcziSQrufjY2XQMMtWdPg7jrvTVE2ntLLHnZ/Z+SY1IjnfTvn6+16EvupnNpu+/jCDfRu39GflzA93Bk7XWEV1FpxzHa1JeB1xBHmYGpR7CObDdyR+at7CPUe+D3ChHPajlLUejZskTLXWtRlnwqn6Q1yXd2E530LdRLl6x0rw33s7t1KturUw3HcG5nV0t/0H/9Qf/1B/3XvwjeoOvWzdf7RoDu+1Ceq0EJUGwf4cvBMdSi3UCDay1RRf/yjVD/DNrO6CsMnYVVhDryA986eezvwrnRY8aP+dfRQb9mTKSiCmo3buCm4XwLPJ/L87FTQnMr/BMh68tU0qcHsriI45b4WAsR9tqo5FVOtCgk+XSN9WqurmDmJnOfRpKKJ6zBU3TC4Yf67ZB/EvDIy6B1r7XkgY5fX7IYNO6ulplqeFLg2XStZWYcvKdcC33PgvcUeEPrZ4IVMBNaPxOwMDMuY+Yz0MJNoINsKW7fhrg9vhFT/u37MGWvb8SsH3wfTsEZLZzhwhktnKcUoJf/DDlG+IYXCb5CsABenw/f6us+CuDQq4dcpZLjnJJ85pmtaCza2ClxJiX8HwByKNaE4/xIu+vwTAQ+LQaJ1eTTg+T6IDwvrAqPVgO95hfjuZP3rAPKMALNnAZuwzQCxLwMeEBpPslXKEsrt+/pouG+DwFnnYGTwZ7zSS6B/ZH5XlomnpVhTUxKR/544uOqv+S0781YO+/KpJKTb2WcHR43pXbS6skDljw7dcb3n0/ZN+LYtCGT+kwDGt7rinpsOp61RgRJ0obPfjJtYnkS2CT2nPvEFmrrjNA7TIATmzpJLwU8DuGurx8dxLGrhVJLgV9wPkgb+n0dfuvjQr+bMLyYJCPW/iJzqULNOdByWR8u4wtH6N5tHD//xGdSrwceRV1Q7ctV098lQopqh3z+iTz+F9rPew73vfHvmg/y2sav8941k7YaGxGqbX+Vfc4O2/vyOrqeHZQn5RSnbXv93y9712xqO2DLF6SpPR4AEZZ39ZyARIQXurb3WtpEeLYrtGMXyu6UPRHhya5t4ZAPwyGPdL0ZDnk3HFLQ9adwyFvhkNyuLeGQNzrldZTg/2/6jZdBhAldG8JplodzpXWtC4csDYcYusrCIc+EQ+K6bOGQx8IhfXp3FhHhQXnXKRFUXcf9UiaG/8G5Ku+1+/M930QuyA7lywqnmd55LBtTNOBYsjCxE3EZUx/y43owiWM49x25g7lhvTt2F961e5AIA8G7fDqPCAsk1HszjvTsIJTLEM6KTwBFkI5jru69WWB41/zw1bt3dRGhI0iSHoT8bfBGSuBa2FCNv/Su6SXCV124GhE9ep3bIlP8L+5Qqn8Fe2rjoaYEeb6XJGXnYdy5cJmmvFDaV2+TpClQl+Ouknd04Q4MLNl7PVWW7UQ/YSZ4+hDOyOHXrofKTJPL3BUuMzlc5o67yloGeSg5z5fXe/bl9KlP+nHK4fJMb9TLQ/NWHMicM925+5koe+Yf9LO//DbnL5lSGXlz6MxTmVHhdZFjnitKy/5kj6Oy6/u5o74/nPn7yhePtFYfy3x+gKH7q+dPZJ7xbgeX41zmf+zPc0hSTLa8t0dqyLwMOuSzV0NnH0lSa6ZUyphwLSWuc8WRXGwlnt+J63pC59qVT7EIxERu2rQnY/CUb9znpY3EVW+4NmpvqzQhdpQmdIJyUcJVMmp6w+Q8S1AhUh6OYSwDnePDnNk3iOOsaJs5j5E0PPvOFotju2OyR3g4lgwf05Q+StlYc9O21OjsWSO0tzXWAr00IznIiDoPiWl16sOleTtCpY3q3m4nackNwz2cchof1aQLxzeE4xO6dRAf00CGj+cN/Lje9UqhM0mJ8LXs9Z51D4U2a2YNtpDROkc/ngy/4e43inNShi/94xUMQPnxwGSHpPvGTU0617uvJrwG2BG63frUmyDrIhFn4fWppUJNGFMPvt8qjYtNKauOBL/J9TLOg4+5SlJmNUy+r38W5VGoVBaD8/fcSJPGosHToRJjUwwehSIrSLdZPApG4wAOzyZDR8+ivV8p9fx3zSQnNJ5OhMXyqEKSvEMDe+xjYS9eqEtPUTUeBWzecsmcK8zt8Lvfb43NAXyO85i0Zo9zLqc1X3RCr8oa6qHpLGil2aNgv3ED/c20pd75RVssTVseMGvv62cZGqnwfkXyNWw7SXRC/aUslprlUTEhXjfIcOBcVQiOgR0yF3m+ev5TN+JJBJ7LqMGR3tNt6jnxvIIfeRzX0eFcd6JlsHMgT5Im502ZLfcn4WjwfTP2nYkNGh7wN2fi5JHZptbu4tXmCVfJyH6NQwUpe2h7E5vtoeYhRTPqTK0SxHpdofWTQH9553xGXR//hJjB9bNbC8ZuMVt+6ZOa3Ig76YlwSIyTOQUpRISSYCj1PWHueSH8jTmuu3tqmzgW68P9V3gaOBGeCKfa1RIBZawRVXeVOCccd/d+2TvryAss1dMkiZDyaSHbKR0wjrq3jxPXRvQ5f/QmeNUXzkfR2d0p8cApKY0GQQJsnpJXEdxZXRZaq5WQhytBtpvxhFhtgzY0dz134JRr7l0tA/EcR3VofVmmqPdx6mvua+Cv68GSqXf39Q+IiUbspG8337i6qyX6rtTJcuqz7oHjeuq+1qIqwfqxHpzjC7WBzMb1OYXmPVHwOx0p3AfsG6BrFgG5keUhzB1Zop0C8iQFbVcaWhwbPj1zNaSlm4ijDMKNNfmeLDbfY1Fs8yhiOEe5h44Z4njAQzQPemhNqeepR0s9Tz9KhB9s+Z4HHrjoffDBzxy/N2sa07JtwMOrPQyzxkNImYeier4njtrgMNb1EUh+vocaC70rfranz1jaaTIv9GZRsXI4kz7bE5tOO+eaF3ktDNYMmt22z0+xl/z66KgGOhh9OymoaLXpsvyEYoLR8AtkV9sjWdFN7/v1imhIRaVA+O1kx2yB1mDcSd0c74/PUwLJUV2C/ht91U80r3kJ+YOXouw3bUMGXbDfJEM0F2ZyT3iMJN8zTcNCffme7Ll9b9pibEKl7YSf5HOOJzwFmgLwlLO87Jwsj4Iy1j3hma0xZWVBOX3abUMQymbXVoHEsA6KJ3p7cHUb59Cn7/VHMsf8elpTrxnHNdL+fppTfg1NBTVCYpD2a5oghL7sOOXXayj41gc1t686sjwaqtz0U9weBwW1jbQY65Z6WHbItPh6zfjoq6y/H3sGStQHWQHytOGIRmKQbcvxMADVGb8mHEtDLCvHjuSNdZBCwPc2gLAMZL7Ssbrd1ocaT02/34301DmQoiOdd+itcCK9WcdAXgv5tnqYmMEOkkj02PIHHlW4TGRmVrIjC7jGWNfvpo2d5qBu2voY6xDXOUJ3VlZ7MYWzIcY6LD9OLgfriHfgKHeBhxqvdMz1MBOw5CyQZ/LdADL+SGJxLnBgu+0p1j+OhTIUOKNS4P7v8Vqob4bDZMY090IaM1DxByrfMxYeuniIo69QaqkQSvNXC4VzinPHCaVmDmxYDGEdWG+orMIXEW6QllnxeB+yh6IxFcRA7eqmO9/AwTn0pRDX9kDwhGfro5ntlz8Ge4R+wnNVo3Mw43retPcqjTeXkSBzO0QTptvkiSZI/X7ZddeJoxjqkDSz25uei/f0eSDBEe+JfXCbRxPzFjxE+F5My4b+o0z0zJ5j8MyeB5BM0Ml4ywL64WrnDOfuTvofCOe/O+mfldCjmzqZn3Fu8t+dzEPvAMZ0jvsFKnqfX2I/vUlKn7ppepE9/4Tn/ujfZ/FepdLs+Soxy/PgnHzPl3qT5/GCfM8/Rn/i79JscJy42bR08OXPe/g/uof/i+ugFp6H3m3y0ASgoz7xPsqeclz0ahRZHoxH2LC3UdNI2yFbP//EmO/xXEjAbjFwKGH10yYALw/q4WUFgZ4a4mdFK5YJKc1IC633QjFw7i2zV0k97rFEQ4/yXCgu7uFyyMdCPgVyek8+OQ/Kh9+ml+tovd9DR0M9bViPxUMz2CswD7xb9ZCfQN6782FviXFBCt5Eeno656CmBZxZHiX1lozb4lwG4ucSi5dhYkPx0wNOi0fJFOciHTVAT50DqalxFniylEg9i9LlQrxh3dhHiuswRulArYaxA52Yk3YBtSfGujCvwgU0nxgvp1D35s26q58B1uWv5VRx3f8/T30o7vMqWCgjGvkI5TERNthQ/oIV8mCOJzbW4um7CHpPUo6nT/8cj/bpfA8ZHg314emub5uz/V0sC1xEn1/A5XvG0Z/GPe1lFKHf0Ce0+e0k7VMvHf2Sl4lOcnwa9xJv8mhIOO1/hD/6v4S/87+EXyUPepTROme+RwGQDXgp36McgOtALJ65y/I9p6D/xcefdCGdIl2g9ajwfOzsT90YBrLZQvR3uDvz1pGPa7wMSDmoR3O3jC+ug/befz/oqH7/K2+XX88BWLZc14Sxy8lUzmyfegS/1Ei98aXt449gaGn7sCNIuzQ3fimRmhMy27s+xrAk9x2+KG3/8mP4Ykvbo47At6K03ftxX7znd5oSdDOOUdLh930i+y1oadDGzz0KmlqDEvy5Rwc5qWrIr9FgaRqUrbQszdE61oIXiSEPO3YAHcvNaY7L9yz1/FhsEihSnNtTlsx101QuLBO/v0NYp11wPiaysl29FuT4k/wbAPcingAsVI0U+Av4ljMcWD5Vd5/IteAdZhoHpSf6x0SukzhCYR5p/P8Ia5K2/Y+wf/yXsDO/yftbWNW9sNIyrLRL7g+5+T3tovveJH37n+9zaWn78mXHvE/O7Xsl3/OFwSLbxgXz0CoxgGzWgRbBXJgXyjUqXBBjwhuaiaknnDhmkT7nsbw+56N6y4u+eHd5WNbd5SA8krEnBOE56m+yDHUcu0nir/q7H426An15dr7nJD3bU1B8FOStyVtGQAbJ8PcRbPmJrlh/xgsnHJQMicyBnrlzT/l1qFs02qCmTR+CH3IgJPmeCwYGbAnsdwBNG+CH+Tvo+SfnqRBj6YOBg7pNpnYTlI9lmuSvUPts8I08hvagmQwByZ/FvAlcU+pJeq7UY3iuCPpe3yfPe2MXfeE4r8syzTBlmT5zLDAPTN0AshC0cT6WpBdKTYhPxC1oWSpRKM3SOWaasaRM5x4/BZ4Oc1vr1ZDToB1BK/oJ2qOXZpoLvSZSLVve1X5bqfKCiUNdTkOO7pQ55+0ydk4VhLCD1k1x7kxiAotO205isNwWV3XQdvsjP6c56tXQBCytgw4COeaadZYTDqdJZynOfRMk92qASumwAazUOGpqjRvowmAbsR8Znkt0IqSsE1NyDo4vzi33UDHxspfZF20HsH+SAd9Ij75+8sI0B7kp4w95oBebUN6TAyA3lLiI4s20ErFpwJJM7TaZQwnDAq4Baxa0YZ4AiwvtDIvwtoXCVSwkvtf2wLTqpju2SR8ZXyFL5AkPyAXomWh5WoRPLZxjr982D9c9nwi+0cpN2es9NU/bANbi7UXZBP7jHalo1wLXtFq8dC+vgQVKU+H4As9stFJ64j1Xi4tzV9S+UEtGfg5YwLNQlE2cgyTHY//IQg4nwqC/Hga8/76Z/QcZGdFAUuMa0MdrFNkm3OGMd0iG4CWpgyDm3btiQuEhy784N/Qmwpb/keJOXOldcT355tXOAvhCUAFEY0NQOWt7oRKe+g00GTU4PoHjQVLgcFdyLXrRdTcyTEQY/ZkeV41k4Rn9oZozwD51gqz7Z5AkRcmr+aRAYqcUCHThnY17IDQiTwroetcCSIH5HVLgRhdJMvBay0DeWYdjEsJ0eLKcNXfKkIJS4JJchi1cxq3gnTIyoIyv/msZuM+We5flN/AkNc+1ydyfX3zlaHBN6yw7UE+FnoE+qAq8Zcr1MNw2U76n//0GzWed3YEhwXW3ozvv2WDxcBZVp8a/wxxxxatT+SWjTRi0eofZ1KpbTWemZi+I23f0WGe3EN2pTc/2MNmkU3N7X07ElbSBxC+l2wTV6n05plZ2NZ2Rlm3yqEz7vBqWjBhsv2gihq+aiWWyfMP2Zigd1+V4bWQEhFIZfCj8WLAsQMbkujab6QtrzKQ1aFsbtxAsKEq/ncczgiDtjEY3XSt9j23CGbU/2WYOwlYA/CI1wt7Zfdugie6M72PxUBZObocK2qGBdtDnd0CJ39rW8o/E7T1qD7Whn8XDZoPuEHfnqMJtoM/vziGtn9p0PN4VDrLStMv9NcjT46akoKb7frCPqKCqHXyym4kgYfM9g2cMsxzrFDvSNFznwPQhwT8GAS+WiE51+ztmOqhqJUGVP/LKYGhFhIzN9bZ3AJtrbQf8dMSy7EGDDgM+RYEDfObI+FQH9+RwkJ5lEZpnz+/JWXKFzngRsBlhApt+4z6vmp2dc4rP4x+4MMdJRi9x2r1qxVNehmVBtneZbptmexQKwNQDZESuG70MfZABigPtwbtk2hBbGRZKcyxEdRGonp7lYbJUnVzbZjMbpNtVV5Yg5aeNOb/ZPOoKnTky+5u41b1Ux7RETovpAMZp90C6/gDjyOxzcUDz3KnuScCnEW4V776u4zuvZ+UcOv+Zl1Yv8UbTVEYsv89dyDe7dfxb7sW8y72aX+lGbsl1f+SnNanZY9wZPAclNF8Pj0vgPiALnlgecSH3lrSMc+S3ixaiIe1EltqReXgTB2NS+bRTeu5wuNbClTA3bfOO+Zcv3eDAkNNt+ek/4b2NAh7SblPBExM961pLTAntMY2DvCmYl2FxvvqafO+hNqXndpL9DrMgmRlZj4M3ABABZE04wGh7BZ7ceSrjJ0rnJe4Bc95jrKBi95ryHiRW4wlGeOkzkCXWKL4fzwjHRJIc0bhIpXL+wD1lPvQoprQE2faPHgAZsoQy6sCSKc4VaxJ4ZgneNxzN38PHuIhwQwTt0UGEn8Sx/BQe4BcpPtmeIu/WvdRF9GLdUoElne5RzW0zWJ4rYqyDlkTx23OdolMbabXyVdbtuZealRRJft5P8AaXE9H1PMou1YkcznEsp9/50KnWeOe5fL/FhkFeopztpVSLIf7xHPY8jkriPUq/uCGGhhjG7cZ1MxurG5v7fqrg8612UW3bCnqmkld+xO7HudkBTinwqfT2DYashadKJMYtogYebve3zWQme8gMPT4ZWlDaFSGfSSUFdsmp2UOY3sz3pAylmtXtdUu/TKrBMQKSeFaP45kX4DmLbaI+cgzkl/DMuTLIiaHcbDJsrRnvvnkJvLOeWN04jF8DD97sTNZXMBk1Cl7D77AT687ApI5EXGXYmQy/x8q/T8q/UzsSZdlPCXXHM+oCNfRHbLOGqHAkNSeaP2CXAlelDEh3T8ezWppvVumyZzguPDyWn+GIf2R3LknWgB5UguGDo75LhQgSdBfncjXcrFhrrEAxES7lDNVMZtnJZiqdMsQWKmbdCtzbRc3g6pY/TfQr4cnbqOWy4c2siKylDMwy5BDkjE12aqTGxRpZ61N21s8ppvBjZUy5upNrh1rb3RG1nFFw42kBYl1GjRraSSUqeLSsgXtqkyAttkoKXHZk1FEjQ2X+t/Jq/0t5jHWR/RH7ZjPjwjtri3Nj+ThrnH2rOehSW+MKQxB22JkVDbWRq6jUfi5FApaFd8WmWfX8G/YCkVsxbsnYVbRQ0q2zJ8pxl6RpvOA21BKo2+1mgKtp/W23KFMoopaGb8rPEVrIx7u8nakrFhw3QNnRLnbCaOuHS162H1ty3GxwFiQlLjEu0QSOd92wT7S2uUnqv13chBZ3qI69Uqo11l655K9m9oqhMK2Q6C+4Efa+9q1Las0dV5IK4wvboe6zbkr/ldtk1do3mDtxTU0uWFBLWKMUuOnIs9J8up1LrwjzkpZHG0wyol1xCnjvFvSMQP7v+a0At41nx2K9P0tXmsliHHv/k/mi3Cs5x+vmZMcBgKrKinHbczG2FvyvanPs+U+9RM3e3PbCYi8VeR7CC3Ke90YyqvqRvInfF7hy28Qzcp85CzlFtwA4corjxzpFI0WNW1et4UFLUHQn04f+WHGz/BU8w2Qc9DYr5D1++6K8h59QIV9PfX4btGE9PK/DMxZsGy2hhLMdCuDWO1ReEKby/DCVZ1nnFyIXI1Y4I3pwXN2oZilPwW/kK/jn+JiEKD/HNUCfvyKyhVXWR/jRtckgkZJ5FuHejDdBfwdQ4erKzQDHGjMrw7EOnl/ceDu9FDgpYUi6tcq6Ad5ZoE9AiqHUyS0XM8bi/ju0cCa7KIMNvtmPlvLEr43YDmmTeJQgI+VSJkt/DkugRB73S+wTlYN1DQCd+pLo1I9MKEAbTaqE+HF8KBXS6yHpsowlOoylCxfw1vOMsUZeKZ+8sVTglKK7tAYhYfm22hAMWiPID1ExWNvwBx6orE9MMEJZy2SpRh9C2ZMC3jHeIT1cIoa1kAPxUQxSgVN0AKereNYYzbua6RwpkCWtsKbaLwAEWwCCtWbm/LLC1wrFOqRBiv18b/it8y8UPl7Y6s6owT0dUmCC9BbKUD/HYH36JYlQZqif/9NhrGFAL1yQ+W9ddZWVBY7YnpsCspHevy/wcSd9AGGrl/C2dVUNZSh72bSEPkCBblgIdjHS+e9S6O4PbQ0TvpO8qxtvHD+xNZbT1uB3q6TnNYEXJQzFO4el3AT+2tEFR3FXiQb6RKNotLFXl4JXIXPCeugJ/KAl24GmurHHza3ODSIpCCwhYyY525ZsEaMKBi2hKygDag6DNfH+QUv0/6HXkIPIiAFeOiLXy6grQV9tzWFQX02GZ4oBpE0DpCri6QMXjaAPKimhb+dZO7N8g0gZmeVUOiMMYZhiov+LWwqM75ICs+Exds2Sbey8LmEh3pSA2vVD91KBJvvQfgC9Ae2a4WxWnoji0cdheWczvfgNnLszco6ynH5O1H8rQdcm1Df4CXnOOxv6Pfb4JFnTLgEewFtCpMBQ6RL0RIO1wfqtfMoJWYxx23Nl3GwY4I0kuV5NWCrc0cLfgxZWghZWMVfck2rwzmTg827sLQq/Tqb7szz+HyjzMiuhtuNqYqF/XKZMrev66vjbtzZ0cXWTQJdFWhXPZotsQogKqdZEwCr2VMyDd8+H6Ix77pCipjUDfkNnmxyqAq2sSqYPJDtUekpko5gkHaR4qTPEK8tq6MOMNUdkp2t4JY/3vyOXPdNJkvWN6a8yqckOxkDLoVtElLCPQExsYyJf/KoUOC+R5Cj4Xf0q8h5JVjWmbzwMqbThUiydNPQfrgYtHuChDh3YOH+XbxpCeSQAZWzPMdbyaowNcY364yorSpKLzRz0b/Xyz+KsXnAuZl0T37AhRSpF1p+sOCNeJoi78Z0Mf9YedSiyQmXQVGgP3JOnrlAeIiOyxLTprP8yYSqUb6v+vEXUF0uBzdJnZqZKA7ytIMqm6FlUIpagg9Z8Xy+f17Ma18R/K5+TQ5bRSdtBOoa04vxOH/AV3gP/xlux3MJ3YrmdoO8Rz7bnpEC59LB87/yfJbxtdfdzzEzGijvRFyzR5WrB7ysAmmBb89uDT74Osl8+h9FwUV63MmgG1kiocvPz4H185DDwz/IVYXmIKY7eDC5dBnyKMfQhjGEPrw3LYdQ1IDW6Id3ifuE9WFJALabHgVZiOX8ykc+xG49YUobaJ7fBJjZqUTeUi5HjDLVzk0hrpP72rYLbXN2QmmrxhnFZbbnoMS6odYq/GC21zuZphlgL7SD+G2zMubU3YkAuaOuKa76qJgakdBxPfRSfTaVrU/cUd7i2iAP0eGt3uSjqK82DXOViB3wrjJXm/i7iDzJRfgVNbq57MVakFvQVqaUfmyNc75gDkE491lBrao3tKxpv31Lf5oFrQnxsCVK8EfALltUsxKoUyPwr4B7wOmpnLOI1H9uxvpoFXYO7SGzieC1S5ctu1v+Aar89J++iuF1Lb8vAUZkI+mOmAnfSAOcGjTzrL+DeC2RKtlqQdwq2Can4Sbdi8E/1GTzmkgKOIIYtuP1o09s3VCC1z0LvxfduIgWOSIrBnobRWH4B0HAyGZXhkgI/BKVAEJ7vg8mzRkLejiDe32NxFv6esaI8xNSsvzByDd/fnjiDFqKDGIMycHCe4ZkbxjPiBvL0M2dEa/mZ5vj5+8TlBWea9fNngJ23uuOevH3iG2St+McCA6Qot50Rt1c/y2u+QVhRl64OKga/1xA9ixjGyhKMhv5yqjuZD52CvFRQKUSQkqziT27Hn7Rc124thzi0Az9/BDyKsgP5o7hGCpQGmRUKwOg4V9KspNkhS7iPC/uHodDwEsq4MyAP9y6Mn5m4EK3iQTPjZ+n5mwG7dM9M7DH/DO6v7SPP50M6w4A8w0JquKn1wdiYmcNfSub3LpQCnwf1tRo57fdBrT0aMLGxA6k9ln838F0HSb7pKq4L7YP1f/XhF04rF/PwQqIvhKfSHMt98Tu1bHNjX/w79EmuRltLQRmLO7g6bA/yDscnWhPtIdwSg6FQW1cu6o0VZtqlNdLCg7VvyOPSxbllS+bHxzuo9LKF2CtM1kg+ww6WCqUDnJs7bKAJTx5FaRWwAI9ZB/NIxxjQlNtzwaqD8tF6KAKtzdnqxGQjWpwzQWqcBM+Ca2S9qn4Xm/WG/jqLnyiBkg/JdmEZ+hkd6A9mOUVyMnr5fcs1/FWRaF1iPxv28qX8VH69bO0UyiW95zAsH2xatHx48UFHgmmpwJCni2VPcDXqcCGX23mymcQOAQ3CMUr4b9O8ycfzRB/H655k/PHRL+TQTlqkIoPu5PRFOW0upb+a7rkz53Qz2Xi6md6oTa8wi64eff+6WE2oDDqZvjIQ8HpcfLC2HuRhgRz3tlhdQE2o7rx5k5qQf0sqNvDrzH1m4zxuskPBQ6x+k7lfo45PTp8ncmlqe+SMRrelOWKoRYz/yCDqHjWIA9IszYoXLCKnocZedxvlkSUb8F982QCZH7FNZGi5WG1T8sOg5yZH5AuU+sej23OirkR0sot2FWXImnOFdZBdHWTbEiwtR6nxPneyXBKucAT6Wxnw66usffhyoJXWjrsQ1FdQv58J8+WZZha8alzhBjSFdiUbmE5u3hqgZXL5DH4z1HCh+4qoM8Z5GaXCy8VeaE4Cn1ZvyPMTVbgMCspYfNX9f/lbGWAFRFgV/Ew7atAbksLPUfqwf3fg84w61MEWWQeDLq9Ktw+2hvTnjxL19i23nkctKtRkLUG7UAltovezR7bnLrPmiprp1HabHeybHBwbDd3iyJ1nrWjZvtmNGuELidr2ixv9BaEmeZiik1Ksrz5SxIL1HQ2xT3YjJl0SN4HmmfKzwPkcxZxjZWt4zhtkK9gP48ZCitJudrCqcVQR9tgZ3cwBfG8DG0MF5bJ8UB5t+FM1UgztQSbItVFTG47iGMlWnqlQH8ZRcD1/WIw34t3yO+WRhngjMXzZTNK3iAnkUGEl0jnSmRPTGNmptlQVsRVopfTtZqvAu7Fr03PEFCPu52xx7wDYuLC9rpJt4vngc9L12C+ym3AP6RPBTf6snMjzO8UEoyWobrusoi9hutckLOFXtxLsMLZC6dcymFpRAek7T+eMhvTxcvp61bBLeuCfR2QbVoReTleSNxusY/kheGbquM+gT/Zzvi7qq2Ma6apBGxpU3EXWq4a+nmR4MD7U15MeipHl7jFX0I21/t290BppTZZLvCJ7L+qw9yK1Fx8hehyxkXKj+Kwlg/lI6z082v/0/u25//qNp6O4gO14vytknYMfwSUnmuTzF1DPzHJFgY+1yDoT+aKqQvZPLohkN/JGOP95zL+ua6as674V2d0ed6iEXVBCwXGMfbnrosiW4w6Yb5yQonyHqNdT2yNAJkqBx7o4O4ZdEYmcQnCNwz1z26VAQRdJPuaiZHqs7w6V+ZIM1X4ntuEcwEASz4GUewusCChNtR7edaLRuFHUF87kD4hJRn0C2JfdC60jaxdZISVoQ7Z8o1sLfhglrOzGm7eesiZax9pDIcu6udqh1ltuQzgtKV8m8+HW6sH8TvE5o7KiTiw2KiqAK41MBTVsp2mnaDVS07fyOPqeYELPHe9xDWFmmgOoQuFYNzGwFZojZNQ0Zw/XDgWurekihq+BW5MtW8Rh5HhhFc9ULcgZ1IhSI9ICMmM3+qp/vZ0TjGx1qthLWTx+f3dbb68HiygWOJg0WfhcMdUY6acim9yoN9QyF0/hI2SsBW6jBQlcDLzJbu8jcw/yJ1OF/FmVkwn8OUzmzyuqIZdyZD4dfQnrx/6ikvtLyW1VVRaPv3bcttViT1FUrZfH60jFI/LpvxhDkjVXkSdd7kfkkFag3Y1GtopKZyta3dh/1W3DPIziZjj+B4j/9erPMgdnyBz8ncyVml4Oth4hw7H/MpVtRyvNu67kBJVtDaq+lyI7lb24Sbt9B54pAE8Wr6zC8LJuauIPbmJgCplldALxa6itZllfTcWxOGONlHTqeSaJfiFiFo7h4LkTJ5uZviSJfsn80pqXTjYrc042czk2MVmPa5GIJJEM0ONRvBHkIhk/UoZXzwfcGXXEarSXgS+y2Uw5TVbRjSNHy2pQTzzHz7OjZ/64Fe1rHY/ji4ViOt/mRtmLY8QavhDKo+b9APkrzQoXA74Y2hbJfKv79pWMOmPNlmr08a3YP6WR8CbC18H99phZO8W+xr7LK82Mc5vIJVaaI107Rc5IpUY4NRfoVNa1BCxRgaAHFQVeHX61k4Ab3yJpc6OvcXfZr4TL3hHU2zHNbci5Xs7pFFlKa0f7RJdbLN+jR4b+qVoBMngE36Pt2f2HRSV4QzNCox4H0V6J8isZ9gDoJPJtM7cRT1fdIhohTX+gOlvPAgfIkqwsylknKo0NKt0lVpb/n0jwrQ/9/kK6JJ4E/43df4c72DB3nLnQ6MZUFPgiz0k/YR/NIkP/CJDt5nEXtgyTTQp0dyMk9MFeWBYDLIsBFhveyyYFvgW+HdDQLwyFOgzF83dB8Zp0ubemSVIraM5o2UoSagbwCfysleUiN7bSvAW8hRiecaIVFgX6i9svBU52cwcyAKtrwfZsdcrj3DJukCeUci+tE2dr6a07xRlaCv4XaMlWkL6EOwC+RleDe1mNko+Sd3A/Fx6nUvrPECJ0Bt/qHd9SylT+uvvukHYI+fw3ISKE1HTLGh+kzgef00lnjES4VNsOX7s+LxcjxqbL41lcHxv81vHFuWjF/r+MBdqs5KYN6NosccDR60C/ULxCDmkC6pGxiwq/FElWxv/DuCJC9ouE950jVG75lwi/foBfxYCJ/rwGbB0cq0oHC63S2nfJW2bmyqLC8YXFdZH8I9aB9k1ymHhlYeGjhe1ubc1ma/wKKk3hEoxxS6RAozw+RfS33Rk1b1jNtYw1aUmqfad1FORROhdAz02CVH+TKH2GnGqzNW5FXxlDbnmmn6vBkJRaUS7tUwnHGzCdKiXZoUoy1jD8Ft0WM+vsI1J5DDyi+/xR+kVcL5lRo1jF8gn2slWRdgKlP7lyzlEysqNh78pYwRZz0xVhrzC3OhNL6JG/Xj4WLGsLrZZZEFFmdrvG1ZJRPzkXrSKp/3bSI6+5DCtVqVcv/2ylhMlB29F15u8uN706JPkNefzD5TZ+Egl+1cn8bBdJNderV1BTVCn3XjYIhdlJ0aeeH6ZkhFLa/GK+p59hwKUzbSfH4c7GM22qbPqFshfPFEauQPtKncC8yPKx2RVmrRP86QUsPKKbHsq+EDN76PK1L/a1Vx09XXjDzYBOCbojVwzM/mZ5fQT90uk2W18z/Df1xfG1NS+dftF4AvxHgMx4Auf0UOaINaH59ZclkvyY84dX+yppQZzz5Eoa4RKIJcvD0CmFw0t+tNKjh7hGzKQ8jCHWklpoWPXDyki7WbDRi1bh20Tvld962rAyddnwlSMTDPzw7Bj+XXM/Z6xIfaOCR3S/t3IQy7SXMhE01d6dZRFsTKTl+cH3m+/Psni+Sj/vTl3h01HpDUfHPZ+67MmVB2s190dmg+/xwmZzhEzFtZ6+QyeK/UxrPXTSm0fb3KnWU21RtMWzJimlUKxDnWAE3yI0n4Sjtwxfbb8IEgpXZcQ6WbBtmHMKv45eI4/O6uQvvfy1DayfdaBbdDzwmqETNBINWrDSHOGiX418FTWB6dW8VwfFPWx+OCvUF8Gvy11r3cjfA1JXmgiPehj/hv1BUbeZvI2ye4vIFm4RFbuxfzxcu3fJjhzOZSg9DiUlx+Mco+zZrc/mfwTuzwbdlG1HiFC+nZL0OPdDMur0/G33UKv///Q8Qrfe2/hN/ADI/y+p0E4MJOkkjsoamBfQk2cWlq0xgdf9o/gcwjtVMiTyJv5bkVQDnPAooFcdl1bzu+1vg72GI0CVskxkmhkS8/f7+Jgve2YG8sGnCI01XBY5wlj1iagLFLwKbEC/fEtsrshVUfxJsARtorb8pKir3i3GV3N+FmRepXQZ7KTUwrMiW/Dfapp+V01/c5fWKBKSQbP141GnZNgZHuNQTjOAn6gmbKV80zNAUsSHxvFeBaqTZI8Lx/RxDijbuhrwgnaLNAEe7hd7IlBnjqhbQd6CthdA20ErcdLy2osAcX0zOfFODueoyFFdCHmRtIGaqH/x/YXvl03jm9wD7DMAiyYxNPOjqnHhbO0BHJlHn+/r8Mi89As7SzFDMZMYkAbsrPbAPQ7isK0dTMqhzy3ZG5pLJMvPHeXiZjj0xuLciDxtUlxxRJ4O/nN5g+X/FPxX5Q2R/xP4j332Hci3HZ4d8FTCUwUP9uPimr/Z2Y1vmAde+Vb3kTnDsSgu2/qdTpP9Nsi/OzLDvHFg9sajWyG+D5+1GrRKHc4BdLqJvsNtrKm0Z0MJsXIJJqtchm5gNpX9HpTRT6QicWxBdOtAft7JhaO+RpkDODvadlzdfx+VEWoU75KhE6xb7AnWt8zchSjr0viYQtXAzFfHFE+wUtMnFCZYqfHUhLS0hEKvC73YaH59dTz/g53aZMfV40zclQkDDwDkbwz6tpkZ/6VV8SZ75EE7c4j8eRyvkO2CbyW2KtI+ytrmDnmsCGUQ4JXn5v5L7WOWKwaOef6/1S79klETGlfQJbL89twCaJtiFl0IPG2RkiyFzJqcNfRLlpcy6ratQXmDY0ZR/Axo8SCrPH4PLcfxe2x7Rh3g0q5ezqyqNHe4zKvywEa86SrO3dpBjCSVapACvzp+q9v/1z4OvQzHlrfzJGW207JpM+KFZF/Jyt4MeNnrZTnADOcDzMg24JF/1Cr8GvUknq2yHNtvlQIjJSWvO4b+nM4JvhRRFbKHSEUSzxxSHDDKPczOgxYBjCbxoZBFgNF5djs/0XrZTcmezkeS15pe6Cv8t5vdnrppv5cQNnvf0Xeg/ng+bU3PvBxFOtyBmsgNZWuUPHDFGvrwQ6ImMzzysWOm3cjHADyvS+9ZkW7Xu6k/t7lxZl76JbZGmccU0gdAPsmppUCDhCMjOBa8rXfe4xcIiwywQbQf/i87JgCWCtbP/qb+fCvaMaH6h0hYv55HCGLl8odLFE+VG+3oqf4TUlFgO2okWh4TD9EN7e1+DWgVHdiIuHV3s3yBneKTE9ASeda6qHAs/1whelUrANbiOjIUdQrSGe3R4lzLa3Qq4zj5WnXQJpgiMNxYs8deLg419fRAUvT/1gOLwQtgigYm6ACK3Q7ET2TglQ7ETOj38/Jv2RoviuKpBGIdwA8BuBzdJuDXd6y4F3Ykvw/H1LIKZejkWQTUHvDQ8LBJ+e0lz+cLJ58EL6xvyOdwgT/mAtt9K+jMraKqfKvI2baKsU1bxT4n6VfwhgTIt5ibZRN15TZxoM0mxjXZxEEn6ULqSfVKmzhUj74GcdwOzZtAeWRxhahqqhC5k40rwWffOH9lhZhsZF7hgB9UVVBOE5S6GErdCOWdXPfyqZeZJ0NlnIEyltXgKBR4glTPrJuWxzOiFbzOPpbfDbjpKyXLI2zyWKrlmlhgW7cFZ+nvAd0w1ToWx3bLi3itIYM/m0sNZuqJXiH7Q9HO6GxiSBAZ/RpP/yQqPUPsS3aYbR6Fft3RNte/3YsGoU2Adymj7QFlz9Tw5fxW8Hvi+Czwqgbj3uNOKnm4k71AJ/dxyh7/xsNFuDPx/c5Lzazh5NEBOhxXtXgp1ZeAtRb3gSIXaJSHcIxJ9QW0Wrk/C2dJpFSr8sAgWbI0hNP09VORkEoDqU6MTTBCOy900aD/vnEu3Iy8vRHsui+dqDXpI9rx6JNv6/V6LLjr9m0l8Pa9UHIyPwhK356L3//qPgT+m3FGuThav6ma4dfY1xSdB5r2g9pyoLZTUBt6qcHuOOsSvq9Vx5fnqqFdxg0mqxW4OFkfCVJO6Zq1vFwcaaw0Uy4OdByxCu7/W87hWhMl/6DI5m+zbwMOGGGVUiNd26AcS21oXcD3UrW1xy+fxnvdInK3ZXN1thWkDZ6Bz0X59RE/9eam5dwVdoS4opuacFjU24p4bnwsz3yTl6MvXFgYBx42x95yDdpgsE3j/+3ub0fp91cpUuYAlO+qvGwxfqpCHic5K+H/LyWQrmDR/LMrGWzGj0J8nLsJoFDI+7CJugeStGMISSIvpc4Rk58NQfONnRufJK+N2NO9XYaM78axGoTtFz6JXyTDpi2cU/gOT/s5GmGLtY3nL7vlG6KciIciSS3L2yGyFbJEns0mfg0Tb6QrpMBnkkK2RUJQ2cJW1BhJwX8m1xcNfniyRjKkidz0pXwqP4Vn/vZkjq7wkcJ7eLCumFuuvhvibDj7OFFC63YJ2IuHRQL2bBTYiU32mL//XrbVYsBWiyHqw+kbhkFJz/F5AD3zt4NmLKnfXSWh3RiCN2Q3Gn9jN6LNiNg43TWSBzt89zpxZHnIYnR337EY/3udU/hn+Xie+ftHZsSXIYwvA+DrS3dxTd7K+UdJyqZq9AlGNhJ/vFJdgnPcFGg4sP30UuD97oJaw6pv7DRwflkXfZAK6z6bfafIyjObW0SNHqhN0Vu3iFFGiqcPJcmcyHWrQaKQ1E5XJPiDojMP/t90bl5JUltdUuDx7l/dsm3w7B3bINmOY/6hOQG7IwM4VzcDR+Od8vm4zDkcH5jrYSiD8yJYogs8GmqwM2SPxl047qXJc16GAmn8AjF0BVQd4NcwWicxhHwkXMFDncc9K4bNqqQfO2nqJKcvq7uh2wDea2K7u6w0tNKi7JXTpUvbCHP6FWIoKyvO1dacLkU5froti91m1rjUq/5qn7Vqbq16JZWiuny67QxNjXuy7WtMr+/ftGkVSWl3rdmcYr875nTpG6sYgaK3ma+7zq1cU7rV/IOL0qO+jFylWakAaXzcTqVRl0HT1UUuf7Zs1nKLhzY8W8ZY6WnfWzfFG/gDm6tz15p9rkOb47M/KqP0HnesVc1/bzXwfnksKXIV6txyfqoddI8BvQvQP/BmDbl8+qrfyWe0LrMvW7XILgXibyN15kj4f61EoB5aL8+jBbI7ab68djJ/GewfKaC7TfMP14bGl7yl0B6KGrsQ2uN9Rctfd4f8iXcllrf15vi1U14rEEodbr33FT3/T7e3tN7yJGDV+0rxKpL8tdxDtTIEFonSO9yod8gM6KknnM00ddxLaOWM57wUUy7vjcSVAZ/Iowx1N8iG0Bw+enWo1aC96MEy66r784wrrJf+dLF3TPvmhYu9I/+/XsBZjwp5vI/jQmu29PLInbuUKv+6LYvxryQVrH8wUQnKiLehp01aBZKuo23le6XgRRnL5PUGRzuwxLX8d1CzDVd+U7V+ZUwk/4mosxmd1I6Bx9Ei2N9JbSQ75uTEuibZT/ipGN1VW86r0I4+DWPlOi90k+QPnSl86CtB2uMOxf9aT8a0OI/7Y2I8V1tX7i0FTeH88S58/vjKyIRk0GSTOwE+/Y+lT7aZIeyH0raVe18BvqV/eIUk7Sl7soyM+ZsrxNF7X1nmPl0axy9t+5o+9cplDm0UMmO11dU85S4NOeUE4lZbY14WuYRZiF4KEc51NK0OrZFCXG/g37NurR7AV/JJS8CiGRv1JknaImbot4iTQQZMh/e9+gVHk1bsFJ8jO8Xi4p3ii+A/jtHjScYUvUU0ki3ilOIt4lQInaaPuPrjKlyvcNBGJ5uED22q0aRtn83VPLEXJtXoL5onnhhzeRxYCur93aALXjdzTsTWLgksMUUyH5ofkD1kWWfH7Xh/0wdWysCcA3iMOzsmgy0amiV7b9VlR45AK75tpuYsXEG2Gnn1ge7AS10KvsH948YJ93FepSqL/5M532PQcziakmo2TRD7glXDGKqOtrq3iHpoYyIhBtRZEV6G1omMdmsxla5MDbi4pJkyhHO6qWQFz1xFGO+TPnavH0yGRfl1kQhhXNVm+I+8t3fVRrQ4KvZuoioWrSAV80ErqA/stnYHRnUxg5X1el4BGmqUpKhK4N9w74SWUBNI6noXYM24U7zX2DqoTKAYzqui1PsB58buQP9uVfbn5m+uAp4ZbPlX7qWCWvEHd9jmylfwW6o382/y9JIp96vfRDtwO79TLIQW4TPKyOiyvBSbyOvAKtN8FMk/BXIDx69Da3L2O4bjiREUrjckyTvFR8u3iGnleBsSrtWOrMd7qUJrtY9DLztq1sgryKKaIHwxxk3U5Wftkndfpl3A7766vKz9VrwvS30giT8D8FdK+mPMcuBVume12/beMecBO0JyH7UMwAxcxuHK6plz+UdkCWTvjgrPEoVWnrnkVXDtbhxL4GolXBebjDP0ut5TNh5bBTiZgWdQRCpJ0hoPG1nmUWg071+CEC7xcX6QNzJyMT/bq9GQ0a9AC084NkOaNyANNflXF1j+J3DlG67LqJjoOeD9t2DGlRE70L4er+T/bblsoQ8/DVKsnCdDz/j1qn1+PUkOsv6IoCowMkiEyRbKcu5oMthYaEWZ0n5x4QpBp+WKBWfeQqsjnDVQ2mJWnpceJ89Z1d1wglb8m0Ooibkf4l4iSdiqU349u8evp0YE6TZFkG03WIYFKX+kpeFomUdr4MZNFGONppQyD9Hbjt4A3z1kh3M1DPACWSEF/iDZjq4xKy9vt+rsZDmR1/eHxolxNR69YpOZcxUkDeRt1gjQ+SF/LBTPrNhsZl1kSdldo36WjfTGSrPiCpVuWW2y/n+kvQlgVNX1P35nsvAIIAmgIkh9IURACMlMwhYBmT1DJplhZrJSOpnMvGQGZmMWSHADccG1rnVr1dbar9paBaVCFaOgVlutLO5oXapFRDEgkkCA/M65920Tafv/fv+BO+d87r6ce++59937HnsKQ29vwjyPGHXSwPUjNmkuDqxnKzC0xfMUJdffY5zWM966bjPMitR/Qd/DdAXLbTlx7NcnCrcMB5+vjX7q4N4rcX+4uLfNOGIXmbG157cjyfStPbePvNOo3cXuWRZuv9OYt/ul79cldn6/LrXBeGz3ncaZdMeZzZW4N58MfTNJ2ztMO8688akvOO73uYcH53FP3gNrGa5/3IJh/eMWctZhB3NHzrfeZNHu0tDncOT2i60XWUkx6fX269euCuET/IrQWNMoM579PLt3WM74nvEQujKZE6qGFdPIda9zJfTsSu6+h4wX9mTaMHccfRqDOvloqwG0YRLSHh7GaXqH5eaEzObrITe41jrHWmLNefx17jUIfS6EHr932MH3c6qthL/DKJ1jCYfIrXprzqP4htdhGtI7vH9FSG9eAanQ2wobCE/PJJiGPVhgdh69sv42Y+muYb00reEvWeqs83os1lcOc3neCY9A3Zda3+CcX783Mnf5rBN5x45tzj0x/Kj1BHfMfII7OhbKUrV42tf5+VWmnP6Ri6eby83v7afrP2hdLe1Xmun39WhrPThG8rgX95AgtXxB3wvH2VlbQLXQ5v25F2t6D9DWJT2ha6R9i15YORT0PUr9fvd90VWFxeu/L9qoTcCqqGsDcAnbWRfhvjLOROdYyZGb1uHOw9eDk8N7+oneBGPfDqAMlRy9zKMg09G2AKKScPWSnf3jJk8Ok5Id/bngGu/tMuzoHznmzv7r+fuM43rOKj7P+q9tJWHN4RqtqV/fVhLOObgj52dtk8P4RFhzeEf/+WPEFMT0MA9PDhJxxxpG4OF/Hf+AcfgJ7em3+wsf0n/c3F/5IndwJ8Evk9pCmn2kfMo+59dvkFNkcW8uOb93nVMLaeH9Vy1Z0q8nfJiUb4W5KjePHNyhvZLU0HmroY0P7+o/f3L911rti0A1lWfN+OvubfudXztcl+ft2/8h2E3++iztX4H27tfUPLv/8ccfLyg8OTjYB3WLeWwc/Gfo7QP5Fs2j/xoPq9Rhg33eQfrVz6d66cmuUdbhoaJe4h2G57qsyd0zLuVmxN/HkPMHF4WfDrVqgm8/HZqoCbz9TGhc7zpv4y5t8d39Gytwd22E9TrgZoQ0h8drsU/uI86vtWOe6TH15uYsy3vaNSNUsHkslPSCnvyD2sJd/et0pl5tzotAEc+49MX+q4HTnPP70Kv9N+lWwu9GHfOlob6GHTQUaQ5Py8Vn58MOGs/F+WDY4Yqc6VZYd2iXgnaL7xa9zXh8d0HXhIRmCgfhXvt+MXddv6Hiun7juuv6Fy/Gkuw7zbNbCRuKrQ/t1xQ/sF/j+GE/6RkH9bQhJJ6Bg1V2AurM0k1C5KClkKvQHB6ZB2msBLld+RikMbxLk8BzE0L35JD2oGUM3qjwU94wZuyGQPfkbnxKc4cxsGpKDykJrPonxbDO3/vPVYntn69iq+SHRX/3GR9e9Uvw9/AqWP9vebnb/PQ13bmh3IOWcXjDZVwVrPVXGsDgu71ndo1MXN2tCWkOmotAV7ZAypb13Vqa8pgbJ6zb0K0V49xA49ywame35uKdq3Cvf9CgfSIfZsxx0HsuAN1uFH3iSiZjXZISzaPsrKTp9NG1VduwrixQV/SEzfqC+y8CDaxiEso5usw7jWdpNPxfYNb6lj3Jnl6z68Laqc5nBw4fvdd4Z09hyfCS5vOfGeg9SQbOX+w7seH0+E3aGXM+0Fz8/f6Rhwfn/OmHdfHyPTsP7sz99PwXC3du/uPBnLxvN2sqQG/uwnuO08z3DPT2PvWD/8qXemBkrtwJei/z03weGRj5xrMDJ0/eZCncjc//Rs8Y+X74J69vHjadg/XTOetuTexNFK3CfOfWDOzPrTmO7zfEM7//WKc9B9r5bDCJLbhagtTSM8LLQrAyy3naOGwX4MTwvuWnNQu+3427khqY5dgJ7Y1Phayj6dOjp09NDo8NlYD0jm1DDiV0LIwSpHS5H/cNHj+lKcb2/fvgYhhFnEeJcUJb/OilCTbq4xOZl+mX5UmJkHwk+WXyy7bS9tzD087S3nVz/zjXDOuog3lazWyubGwKTxKPB+3sPDATKvDtuqBJciusZx0cmQMrnTctdDfiInEPYeRhfuT0jY933Zd4/nDb6PPWfb2blF7dv9F1df8NrhXQy3kre54z2Dd1kEyDUe1DlrfN+/2TJ7T9ql8LmmUOPzF/TK72aGJyTu/i1FjT9n7C7/h+uHasCVf6Y/I0s7RHP9XSd4kZSPFY0+TwCNNef0l47ORWP6sVrAt2aq9+sEIu/0NHDlVcsR9GWEKmVe/+d6N1Se9ZOWcasWG81uJvLvzCaG3c2T9yMuLF1NZMf5+iv8/Ar/mIRrsTx8KsMfqS/dOsC/cXbrm1/4YKuwbWBD1jrebx6wDdCSOEZ9OSTXf2L66o3FSh05g1JdrH8WnVqVN4/2VxBc5biS3a8B3hsb2J0RfsIiV3+HfBOOo/H0ZR7SgH7vpOsmqtt/cvLmzZdHu/sdCwSRP29pe03dJ2Vf9il2aFRqdpB712Bt5QP0jP9FbAnLd3ywXWnDCspkJ7huVah79zX0hTfG/bju8Xa+n324sH+/5nsCR8X2h33ghwcx5dt4q64hO9TiZjd1P3PTmiu466443CTi11v26wbQV+TQufEDDt8f4eOgdD78+lXzXFvZScXWMOD+pN0Mty7Uv7p5Dxm9gZ8yd7CrfjHI47ndc+lcv2z8Jk+qrdO0MERsT7hoV3zQjtyx/2Dswq8poNpPt5erq/MvcOkOgKclAzFkzR3v6nisf05o5Gek7PHs49yojviLsd8d7+Z3Q5vaNz0P/u/q061KaQTizA/STKjby5/yzGnXVz/2jgngdfhZSiryLGjbx92M39Yyhf06O9z/n12EBNj7F3nfFm0IKdvfNywPZ27WMz2lZYSQk+vRhxSlPStgL6SAXpPXoa66xgMJ/u1JLDhXk54Zv2Y9vj3hjpXTlw5horJfwmvH2ZgDoL9yRonTmncVtyd2t4PGMEGt921zTQlIsRvz94bP/SaZrdmuK+/YuPXGXQ1Bw/dtOJdSAPJTQMAT+zaJgpNAziFyBMqRxmJQ2TpGHKDuw15cPsPtp6tmOwTxggJXrrA1QSH9u050DB9e/BzHS9hetZZxm1R4cySTaiTH6KOxeFhzWc4TAZ/uqB/Osl6fxsN47vNQNUXjYwOe3bkhP+ZSi391PvM4c/9eG9/wm7ntmE/soG8g9X5N06Z8ZlJdv42VuMJ3ZrpuR/yu60TT0BUjbtexofP8CeHmmmnNg/VtRGRg98sRbpmIFnTlx9NDicPcXq20IOu3Lz8bSVFc/ozA/h2fNXNm/bxNMd51zrp3Nw9/GjQW4bakXdIR3di35isHCTuVeb+8Vmy9e59BbrSOuB/ey5v/bJfOt9kKcRXZo7brWOst7Wr3mK9N5yAu/c5f4h/7BruHTzbrCvie5dv3QC+TwqDzuov/zDn6p8mamvP1JfR04h/+QJvPuH+xKa+8nmF78fNnm8cVpiRWLC7r2bJ36dM/qc3R+yE6y/33ywQBs4OCKnGOZTXEGT3vgpFnb9INk8LQFh+VBCw7MzBNhXXTAWBQfnbco9/CkZ7PMNstP4hXR2mruloq7CgfXYeWIa7qonSXH/sYGTvMz/ADx+eYms6j/23Un0s64d7Q9QP4z/50n0sc7PW3/i6D/20UmMz3qiGMKV8CeO/c+pEr7/2OZTiKcAfvDUFMCPUzzWUQo2vzhVCja/pjZOwLeccgK+l2IX4GtPuQDfdopMLrYuBXzFqaWArz9Fbzj3LJ6nXcyD2b6jkLseTP+WotpzrRO6cG9vwjZ8yo/3lkbV5R52EXrft22wr+oknnUmJTPa+rdjvaB9COyngf3zoPesbDuy/1Hoh9gXccWf2HKy7+7j0n2OJUuW/If7HGbxPofJbl7CW4/0vX76Evs068m+/ccf3TZXvs+xSL7PcWHmYf8c6uPd4/y2KsodO164aU7NYN+v+0/2LTuus97fd6gf73Oc7PMe1xbf39d0nEw7BKjuuOnY4Kr7obeQaf8CbBHz+OnuaUumiXkspHnEvJW0TbKznBb7z2l72H/+kgl2zGHX6Uk01V9ArDt3F8p5PA/ymFfCQ/7Opu7XHsfTyWMo/wjwT0CKI4/nQn48kP7vYGaS7pn0nluxZH7eA43/6b7J1jbCvwjmwP1jOVz/lR0YXXNuLfsKu7bknCVjN96/WXPH2bV4Mvzsd8ZuHLsE8djaMaGJIegJz4814079HQNHvs/5YV3lxIM5xHHwn6vwjqHmHtQvxxwkdEZptvqpHor7vuM7CD9lJFlcCOYo5KWXrjHZKnN4340nxGe5pgtqeTuZPGEdPvkZ88O6Kogn7/zaiV0vgb7sefqT/vSLExwT6j8C/aYkhDtbE8xXff15pvCHdfMeOfh5BkfFLT+svfLVA+T6N8DPqH2Q0zW3D/T9MP5gHrEf/HIV7tMMGzh7MrqSGbkfay4uaSP0me3ALk1l/37MHw95HQcG84n57hXvy5FQUV+1uB6euwX72vX942vP73I8pymdbD3XPilhhD7yzQAHvWVcTf+xcZQbC9zogcnWohoOemzBQGEtPtWY0OaZXNKfOzMXfmfOHLnEyI9bd9e6yf25PwX80/5j7w1g/G392NMeh/TzXivkpP42U6zHHKiXEZsG+y7oQTlL2DDPV27Jp+dsF/SPlVu0SGzRQtqiBe8whKfyod70UGc56EtzP9iMCVnfGG+EOh/sm9xfYYXasuB5I9LDq9qPrfn/Sk857t0yEnKRa03ReUXTD/Mk/XY7Qy+DRoPzw67tuK+IZ4b6cM3WweoTT26K7e7EN6DiPbira3JuLeoL9r99gFRNQM2lar29xEouSh0m5Ear9kP2zp3dBzjNrUa8LYC7nJ/0k990ObvrP+k/ub7G+uKR29bd149nGUjvTes+6f/m1w9+m7phsC85CCO5he5iTgwczMvBJ+kDfXcM4BvZcXV6Axi8uT710MYbBvquG3jvW7J237ekdV7bsEOFBfjVgmcPkdbrDm1c0Va771vt2lcOTV3xLvjpOPQ/a786lL923qELV/zl0LUrNh/KXbHv25y1r35LVjxz6NUbnjrU0Ypv+bj7UCnQztZpH4N8t90Brs7a2YfyVxw99Cp1f7+n95C19eihL+k7QfAt9s1gI6ztPHQt/aIKfpvgHlou964cqN0/nR4mf6Hn/m81K6Ydyr8BY8XvgB+FmDCW13qeOiQgonHW4Hd9V2wAPz37T/fNGMTSftK/60X65g7NR9A6/7JO+hBt2buH2JO3cXvwjvYb4FpjPd137qCmpGTJDZiPko3wOzakqRzbRkoubqtse3o/vrXit+OXG/4OdP/+U4f+BTWRuxbfjU8u2trjNuYD1w+2Rw/tX4E5OuudU1Cv+0CnOVf2s/fcq4w3Gp7p0ZSwFDbu7wf5fxHMU2C+ArN97rWzvxFY/4yP2WD8g8D662NAt4p9dtiWnNfZiQm8TfD309L5tbFbCkBeV27T/mF4jbk/d1Qh6GyDfeNP59cOWzKBnmspOJ1Tw87lYL/DtKdBfJ+CPsXmo4E+52lpPvrZkp/9h/moWZyPmuzNdD5aP+CBEXyg78HTj26rlcd6d9Z8tIT6uOU0v62Gcn88XbhpSc3pvpZTA31jT+us9/X97hTORwN9I09ri+/rG30a56MB0HlwPrqv75PTOB8NwBpImo8WLFlwhvlIlzUfVSyZReejigEdTbX+NM5HU+Q8lsnz0XTqvug0zkcXUn75aZyPBvpePpUL+RkxqAHt8ZHdxTXf9305WFxTXJvTtqGtuLZ4yc42fIe7sS3HD2NyO44G+dDCxiOFyRcPcCUT7KOXHOnrPXFezQS7NFYULEHd/Ejfl38mPf/X+U2SnYL3ShYQ8gtTwXsPL/jhL4Ucykn3X/AbYwlxnxvPGPC53v7cGZO3cZWL+0sKC2Fs0lRyM47ujveOIDA3gI7Lawl+4bH2JmPebq6STAZ/vOTvCPg7G/zhzsM66zjrd98XXVs4+arvizYWW5/ehOf48qxt297vX0ymrh3sO3QisHbe4vGmtmThprbQiWMfnji2+VrwS28Brsd9pjzrD/sLn7k6NNZaYNVY+TBIcO1g366eeVtIKejiwXX9Ztf4ydOtXAXXd9kJvPv+0Hiub80JrrakjasNgHkY6npfssRabM2Hlcftp7hN/cfeB+143vbuvxdyl4M57y3Q28R9XG3NCJAAtrfbT9cP0q2Nt0/imwTkN/yUDP9Q/dRo+B68BzH803PG40kf9rxo4t5rxxsO5gwrLMXwz5zEUMz3hD1QLxuugZLe2W8m+zY3byKTr+4387hPjPq/eOp47mf70QZ3dri+xKl9+wmPpw7w7oC5guCbVQ8vzm2A1lqxaezapWtxJ2iEyZOs3OQK5WycuJnM0Hx04ljFiUeM3+yeR/cBBvpSJ/9veuQjxy+hkr7z5H/WIwf6Np9keuRA356TqEee7rt8YKBv7knst38dYP224iT228qTrN9OP8n6bc4p1m+LT/5f9Ejv8Uk01eTJ/6RHDvS1n5T0yIG+9SdZv/1qAPtt+an/f3rkPPqmiMJt55Q83DZve01oeAmZdmObZl9BX9dJfFdBQV8IUmhr6/3w+LFlp3NCB/ezZ0hgfxKf/2F+NSX4ZCkPRgxTCN9QpdnFTkSiPI6/VnrWcAhsuL7kKfrGCAj/4PP4e9ULg98Qol1McsFwYEaCKQQzDsx4MOeD4bWLX6ol3O4lhHvJTrhfgxm0Ee5NMHYwpQ7CPQnUAyYOxieal7Uw9+QQ/pe50A6EGrIxj/CQIP++hvDlQWF1eSAeS8UjAqEgne72dJFAKJwoT6WjlfqOqoquri5fMOqfFSCZhC+V9gdWBjPRBIK0PyXzSaEznEoLSQkjBc9pAYE/lRKSaVKaquYNlA3HY3yHPxwRgrw/zXcAU12a4iPhmFDNlwZ5jBiYVAENkkpU8/hXWjGvi9nY3Ut5mpNqhnm+3Z/CoLIPnk+F1w6xyaSEoNqmAXKSFY27gjn/f/gRA8z7XwbocnncYhCjwWNxue0iMjnrvW6nQ509S7PJ57Z4G9z1alvk/peJonHZzQuhYj1YWix4cGFpJMPHO3ggBdhEIX8y2OHPRFgruQz1dlNxcTFfA9Y8tZcy4U9GV88ti5arw4BsTAnBspeQC8jFpJV0kbvJFvI2+Z4UaSo09ZqoZvCbu9sJt0Yg3EQ/4c7uIPSbUD8ECHe5j/HQGGF/pJwRiHDVCsLdVcdMC/DhWDwolHekfJQBD9GoLyT4E+VAU0IULOzBiMB7QXSI9JdbRngN0JGzYB2iov0zWV+YMou5z5zF8DgRny/ScCycLo+nfO3JcKwzk4A0wslV5WB8mZjQlRACaSEYTiXBHnLgT4TiSQEKEPWt8YfTP7JMxFPUMtwZw3KGO30QNuFPB0JguyAWj/mjwiISSqyJJ1eSCCOpQEgIltNfKGQ6kQzHk+F0NwRYE4x3lq8J+gL+WEDA+lJ79QeDolfoBMHsRNPhqBAUM1gnROPJbn5NOAEdsYzHPsvH4mk+5V8tBIvJYC5+HU/DzGLgBwfptxMIb84IfDrO1wrdvCsppKCjNkJfqugq1TXz0C2E1XwpSGCKmOsMvD8SiQd4q8HusJgJNGB5e3uSLGuPx9PLeW9ISAp8OMX7+ZAsaXwk3tkJ2eZr4pEgH4yvifHpkMB7XAaTBbqNeya/JgQjBo9RQLtgRkJ+CIaeUt0wCEWLC7ITWIM/IP5JAW1TUOB0SCXaEBJGIeoJSx+IR6PhNDQtxgxttBKqxkPjpemAPY5MBZYYDHe8ERxN8RhkJCPnSHQyoVNE8CdpzuSiia5mcDVjhSsOBZcskvLNqgszgDIIPQIaEmrAzifiyTQURS6glY2iQzya7U4+FYn/G5/t4ViQ+QGAeaurM5V7zHwwGV4tJKtpIGhVIQ2VHxNmYs1FU4S5pny+9jjUHNBEV1VHNFO2Wg9DBg+5ra7GLBSwiQSSqpD74V33E+4xMNvBZMBcCmY9mJ8jdmu5l8BsWqrlXgfzGZjpvyTcfK+WOw58sUvLlQJdD+ZeMEXgdzvYcaDWaUkeKSDjiJ4EyVc5CX/SH6WyK80t00rD0wlk05cKZdIoSD4QxZXTpme702BroLMIvJBMxpNY3tIgMXqc9bw/kRBiQcl/BzhOLU1NJZlYUgjEO2PYvXgagYBtmu5OCD+Oj5QLQiIZj5bLHlNEGT9oIBpzaZZ1KtOudmn3B+mUpuRBmj+xe/lpRxjqFIgnutE+6E/7Fccg5DwImcXGEgtGovFgJiJAm7L+Ewm3Q/NiblktsGqhATE+VTko64NMg1iKoAOkS2Q7BckShInEoSppFmhekoKfRibmgCUhWSop8B1Qc1mlApmlMbF6proDVpDiyqpeFQXYncGbWHECD4UPd4TBcrU/khFgLEom/d1n8qg0dCodT/o7BWLwen0Gk8lncta5KDDaDR5fnaGZAkuz11djtvnqKKoz2Hxmi8mRBXwGCpswFpETQ4nI1uJ20lhFDAGJ0QCp+lwWt6+R8iYDDI12bwsD9V5fo8/U4HarYKPT4WXQbff6vDXMzVJncdss9TJ2OJtkvt5nsjgcHsq7ffZ6r8Vdb3BQ6HE2uE0WykJCNQaIwywis71R5Cx1LjFDjRCvwewzu50uETutVo+YQ7PP5gIHi9trt3gQOo1LfCazxNUZPLKtp8FtNWC6Zp/LbTHZPXZnPQLUkNwGs73BQ0wGB1Zkhc9Sr/B2s8I3Q9Iq5AHWouCWLNeWIa6tWa6tWa46VYo6VYq6rBR1Q1LUZaWoG5KiLitF3ZAU9aoU9aoU9Vkp6oekqM9KUT8kRX1WivohKUKt2+tEZHf7THVOs8UhQ2+D0WL21dVlWTjEPMKk7VQFR5mW24gBsQAMyCUQoZINZtGS7d4y1L012701212nTlmnTlmXnbJuaMq67JR1Q1PWZaesG5qyXp2yXp2yPjtl/dCU9dkp64emrM9OWT80ZVXlwwAi1z3lxWxQ3u30KkDOEkNKjBS3ZLm2DHFtzXJtzXLVqZLXqZLXqZPXZSWvG5K8Lit53ZDkdVnJ64Ykr1clr1clr1cnr89KXj8keX1W8vohyeuzktcPSb5SlXylKvlKdfKVWclXDkm+Miv5yiHJV2YlXzkk+WxJ8HnsZguOm3U+q9FgqvVhpyYmo7sW+7DHZYbxvZZhY0Nrq8XNeEu9zV5vQR2VYavDbqvxwhRRx7DN5VEc7U6fx2C1wGxAYb3T18jGbgrdBq/FZ/K6Rc+eBpfL0aKk2uAxKqDR4nA5PRaYN2C+9RncYBq8NTKw1Fp9BmMWtGXDGps3C0NsWbgRBzQVbjE0ydhe10AnaTWGriVjnJhl3u6BpftSGXua7B6jt17GTU6sIgrNdg/aOAz1ZoYdMF16PD6vhNwWmwgsVp9JL7MwUTsVQNsUeNYSvoYGu1nEXmxSnRro1aBSDarUYLYazKGgxlln8dWI2aGgUQSoOlC1xMSw0+jI4t0mBVrVJYQmMHkdvnpDo0PCPtAOYGoxtKgtbAZ7vRqD1sDaFmOGCqxp8XglbK8X5ZhBVWqAnI0gQHbF1eO1g9w7Gyn2Gmot0HloXkEA9CBPqNDZ6+0ypnOhw16nYJCCLJwFvIYGEcAMagTpt3ssioUa2s2o7tSKqN4G2VQnDL2RKmcMYddENVNCYoVRSGfbodgG/UwFVQkbTU6QoGY1kAJavAZ1QISqgFR/9ba4JOiG8UTlbIGKU8NGQzZ0ZUN1jgEpyQLANm/OQi1ZqJUha4PHQnPJoG1I20GXg7HEYqpVoCpNhKp0JDjEtVUFVXlkWFUetGgc4qExy0OLO1sc0EIFcd2gBK+xgAatdrV5mYhThEORKusSbMmGYtZhnGL1Ys7GzdmwJRuqAvtqVXyj22KVYVbPQJxVQHn9o0Jy7SO0DPWtlL8uW7QQKoKHCEZqJWXo/04jNK5Xwe56GwP1TuxoqrhgOFLlA5CSKoB6pZcxBKOQhFRVLqKWLNQqo6XqYG45RhfrefVZyKVGLWogxgcTi8/iqlGDRgXYzE6XgmrMbrvVq+B6j8HrUaAHJzQZNao919twRFIBX42cb4btSkUxi8YsD6pKRZjtWVX/CF12r6lGBZWKlWBLNmxVoMcqRuQ1eFSpwLhLp3cZ4NzOAA6sNlgxqqAqP032elk+mq1NUIWYJuNpPiXgdjocwFtx7Q4jajOVFAm1ZKFWGTGlCsVBQV7QyCjEIZ72aiubTKnihuoiYJOjzuhs8IK+ALodYKvDAKtmZz14ckjYIwGHzmc21LnsIPQMgVe700wBlE5M12OSLUSPwEI8Dq8CfC4x5zJkWUdYUwPKi+y3ptHuloFXHQuMylDJiOoM9TBMijEywDKBvFvt4FY5tIi8y+1jZQfGLlExDLC0KVxQhU7RF07EUpwiYJl30T7oq7fYVAiFhSIvTcyN2y2gXCIL7ex14hAjpu92K4xdomJCbjEjbiUjbqoRUMYt+RJTgQndBzUltRtCk7sBZU9EdrND5rEuxfAI1SwrF7Ieh6VJdqJSoyCcNUBpsxlESHVvlkcJuRjA/R4b07kodqHco0gxCDWiR12EAo+9vlZJgyEpHIhZkwU1UhmqM+BRJ4n6rM/krPd4ZaxKERVctSsocXTnDVGT1BxNYnM0Kc3RJDZHk9iNmuQmaJFCtYihWpRQLWKoFubbRhVCXLIgxxRiZE3OhnovMig/NU63j/YHEUMOZSzumNmgAbP6NVrYaFd0sVEALVSdV4I0GsaLPdlGZUHsGwg8LovF7DOreLuap8WQYTZyqXgqQuoY5WxBFnGZxgYotFAJqwSptEpASkQSUOShOcwSA7UvcnaZkcLQZhMZL8uO2HJUa2uoc+GWax1FDcZmn7mlnm1Hias0i8NnavBi/xOXaU4Zw0qDzU10CcYgrMGgmzhNBhezsOJyBmsdpqEhFi0qi1oVv5SWkWJcy6Fnlwp61Tz0HIbsZoPbh+tZNfR41VDOcxNbQeBOsIix8Ji2hKEAPpcEmluy3JpbmI46BDeqsNuSjWGVnuUfsezeSpcRCsqKvDU77lZWFAWKMXuMZkjUYIbBhjgMDfXQtRw+6GSUN+FiUmHrsHFlRCclGUFoEFS3jY50RpiEYKBUzbXolVqABmDPhlisbItWCdeZ6MCsIKsVs4dtl4Whf4gWsBxXeUepd+MqTsRYgRaHykOrGkvrdhiG7dnY4SQOl4W2fXOLzLZSDppA5EAfZFFRvlHmrbCe9TnddhvIJsW0K9S4GHA0oXiJUSCieqoE3AqnsGwviaIGuomDrLKSklBjs4pvlVmVLbOk/UHyTIFk72XU7FZlEZHIiSm76n1GiXFJjFdiGinjqVfHgYhxtLWoIsgK1Gg3iXGgfCrlQdSssCww5NnnamBpN/scLFwrtaoDKTe6nQazyQBdGRE+HcL1FvLWJrOl2QtjAwIXyIwTZwqK8CGGU/LnafFIrBeGBJ/LwDzRZQ8yoFXV2B04hqGoopZpaXY5ZcDULAm5s5CnwZXlt0VyzZqcAFN9l07S5mwIg1IWtmdDMTrFwiVDNQsjO/L08RLVkbAXiXoX7VAOh5K4jFjaMrRnITFlGbskpOJYsu6sZL0uAzSaxVDLElOgPRu6JKhkTEb2LER9gs6oeJQAK4CE7GogZl+CShwweakclShEL6qygIhKKgrydNLSNbkU0IQiA8DhdePKGBV1hM56o9PgNtOWByjvhInOkJYcJ6aLs5bEe+vAT63RQfUDlFZSB7kxg6B5DUbKU12fLvIkhC0hA9xnZTzrLCj4IoR+ICFIHoqp8LAcosBphPFA2rsWLeqduA0rW0BBlOQRyckjkJKn47XKI8OyVwapZxjqZUW7zmWiY7LZ2VSfZQEaoZrPcmtwKdAh7uUgYAqVb34FRWYLC+nBmRwtapwOUC1aFR6HMBicsjBzXmJx18ppMICVB4COs5CqLgvpFUQ1PwqhcSRVTg3FiLDpvHZxlpQsWmSEXmucdHQTkdpFigQjwFzDdJ2FYRZkuBaGL9CHYViXoJI/mELNOPqKPGagweCgEAZoUTsVEWaODXsMuyQGA5rVwK4GUp5FyEK1ZsfWKlsrcbWqopLnep+5fohFgzqki6CKhPKB2xOUr6E9UGRxWpRYmAGp7upgG+0yj9vzEjDVeGpVQI5KhFJ0ElRFaVJHw6ytTljD+BqZtRX6t0dmrR6Jc4tcExVrqRT4PMgnpk15l8K6FdbLeIfT7rW45cCiJiZDGLMgoRoWm9ukFB95MRGv24BjV6MTxg5XEz4nasbBT6cGejWoVIMqNZitBnPUwOCusyjRo5zIPMi2xLstjTo10KtBpRpUqcFsNVCSxeWYLgvps1BlFqrKQrOzEIszqxh1sN5XqklC+ixUmYWqstDsLDQnC83NQvMUJNePhPRZqDILVWWh2VloThaam4VU6Sk1KEN9NqzMhlXZcHY2nJMN52ZDli7O5ZTxGBs8bKx3m3QVOJBTiqLDGJAbykCWGUOX38DpRM86ybNO8qyTPOtkz3rRs17yrJc86yXPetlzpei5UvJcKXmulDxXyp6rRM9VkucqyXOV5LlK9jxb9Dxb8jxb8jxb8jxb9jxH9DxH8jxH8jxH8jxH9jxX9DxX8jxX8jxX8jxX9jxP9DxP8jxP8jxP8jxP9iz6lbxKPiWPkj+xhqUKlupXql65dsXKlepWqlqpZuWKFetVqlapVqVKletUrFKpRqUKlepTrk6xNqXKlOpSqkq5JsWKlOpRqkapFuVKFOtQqkKpBqUKlOtvPvM3X/Q3X/Q3X/Q3X/LH1h2g5rOnt54mth5g2ONBNVUEqPgy1lQDU66p3os8ni7w0MU4ApgdxN0dEXlAXaCdDrDNAqtkFkOt3eHISkqcaRig2ozIucSFUpMM6VN8GTU061S8XsVXqvgqFT9b4mnWDVaLjHHjXgFecXigkOZdSRbzr4Ji7hULLIEKoY6sQKgeowrCetJQp8tC+iwkF4TpwxJgj+uVeOh6TQXphQW1BWrPIo/LAZUTPcHgdcilhUm73qNyR00bH9hjxlnDiKkzIK0U3dI1CQmA/PhwtEWBybJgQqnCVDhZtlhYlgXkIRmzxWOyMOWYYravR/cFZEiX44jq2MTGfIr5oQEbxWWauwkkWX7y4mAYz3lShj6BYBUtQVZzEqKyjoDqfxgxApdHjBjUYhB/j9nhtEE23OwMKoOWZq/IgZJFD4owRAWNsS633ekzOp0er2zhtNodkjPtSoxt8NIG8Vgkn/Skicdi8y3VN1LqrdE3gtqrsCwrEnQBC1VMDyEsra8REV154nkWFWyme58qi5ahFq2KhdmF25fQeCY1lp0t9T6Ho6rC4ZFhnVGnb26WocdaoQY6lZPXCm1rV2CNxV0HawwZ02Whm2G6FUzL0eKhYxfIlpsh8RSlxSEjuoMqAdyYk4HXrPLmpfUnA5BZCmCZbKjHHThE1roGfP5ZS0GN3ctCQ/vQnAELSjTuItncTlhwoAXt43TrCRFUFmaUiTNaeLwmPOZFeTxVYXcSaHkDPS3IGJBhX4WK16l4vcjTrEssZFxk8cwAY5sr5DiA1SmsFEOzTvGgUzzoFA96xYNe8aBXPFQqHioVD5WiB51UIp2qRDpViXSqEumUEumUEumUEumUEumUEumUEumUEumUEumUEumUEumUEumUEumUEumUEumUEumlEulVJdKrSqRXlUivlEivlEivlEivlEivlEivlEivlEivlEivlEivlEivlEivlEivlEivlEivlAgE0WCE0Qh4oySBRippIieVwajImVGRMyNKlMToJEYvMZUSUyUxsykjSYZRJ6ektL9RaX+j0v5GnZSSTkpJJ6Wkk1LSSSnppJSkFjPq5ZSUdjEq7WJU2sWol1LSSynppZT0Ukp6KSW9lJKqJm1STdpUfdmm6ss2VV+2KXVsU+rYptSxTenLNqUv25S+bFP6sk3pyzalL9uUvmxT+rJN6cs2pS/blL5sU/qyTWoxm6ov21R92abqyzalLW1KW9qUtrQpfdmm9GWb0pdtSl+2KX3ZpvRlm9KXbUpftil92ab0ZZvSl21KX7ZJkmFT9WWbqi/bVH3ZpsiMTZEZmyIzNqUv25S+bFP6sk3pyzalL9uUvmxT+rJN6cs2pS/blL5sU/qyTenLNlkCcTrSMaJnxCwSWCowBnf2KFcjUrtIqEpBWcmHbFFnAaWPcXaREb3QGc/DeFyiNUusxNG1Cd2aNDtATTcRsMAzbez0AUOo4hnqTSKi12LopRQFNoJuQBHVryjnstd7RM7pMLjxpg6mJSp8lKXKHuVQ620wNJpAlzfavVT1EqFYcxLymPB5u1fC9XR73EwavewgEXitVxBVbBEZ6aZynUcEbnbwUgG4qU4BU4XNDW41xI1YNUatFKC5Sdzep+0AFhaHhW7c4b48YmsTfezd4MHnS8yCburhUwSGzHYrVj2oHFlY9i09qhCRk+7cs+LiqR0Lrs/waYOI2SIPG5RZLMVnezLLEs0uIkKfEzUsRHiSga0RaAYwPXbaA4DTBVJjMTkbxdzSLXBrk8yyIJSVq50lhYVg8TPs0kupZ1WnCEDoxNagahnQpkZ6CIgli8DrVgDujMsAHxrRyaQ83r6i3Ac/PjJrVjn8TyUD5eJ1v/KM022kP3X+mL9TSM4KJBLELt0j9dNr+vEO3iysDgeEOj/e78+6OpmJJ9uJ9ccX5dQB8HKoP7gaL/2npIuZBML5ZEtfNBNJh6t55cYdXj1dlREyAr3ySG9whuOBdISHrNqdJpvBjOd/7B6LWww0i+8I8gvx1ibGnMi0R8KpkJQYvl+B/RVvJty3YMqfJtwqMOWlKfgPoeg1+TBZhnVRXc2yXx8PCtXViWQ8IKRSvqQQEMKrhaAvCgjqalppcPpyC15arF5WmlrOu0V33uxP+x1CrDMdWlYaXM4XL+Qt4pVOsEUrYoL4q6vpHUYxh2dKl5WBJlPN04R4jxCjtyNpgul4IhxgVzvjUJH01rIvEPLHYkKEeNLQeKl0OJCaCVUYCwh8BBqDj2fSiUwa246PpqZXE6/TZTfN5OvdvANWKnydx+Yh9XE+Ege/YjlTJCpExTvcYm7L/GTiMv2SAhKDJg+kodQsMymwrs0kIEtCNa+DlGOZqOiCtVvAkuPrDTCYgs/Si8pSPIyMXr7E02DkSyB1voTmo2Spx95qKZA9lerDfGmVaGaHaVwo0VEmYOyGqQjYJdtydnvVp2r7omcJpwNz2KX90R3kSc8R7uznCWcCd8tWQu8gl73E7iAv/zOhd5ADQIfeQZbi/gzCFW89c9xnut88bMd/v9/spnfV+Xpn0yySiPjTHfFkNOXzYTPHY8QjXmim7rwtHg/yxm5hFsnEovhGAZBDqPx2EAvovlkXoDMx8Qp0ANo0pRoT5DTKE/FUuKscQ0X83UKScfFOfPuBfMU8yKPI0pv6IJHqy7JyVwc3qbOoCxDLpNNd9PI4i56Uls1O8YTKNLR4RRR+KvX0t5L+6qLEXm91ErPF2GAjTQZ3PaGvpyAweTjd1Xx7JgzDR8ynuv/OssMusou+YqmQT3zTSdQfjkEFJIV0JhmTvCXj0Y4UKRfSAXZ/HaSngsJyjHdWsDwZ8JAO7LSkIy1EIiQSjyfIFSQQCobpGAdVD8OWEFtNyonTYXY14TMVM8F0O4U0eEr40yGCF5zxNSfUPgW1A0MsidLuheLeNoVcQnToyF7b4U92ZqJCLM2HY6uhaJBP2YleVsYejU2c9Mc6BZVjNAwxw0iRFFZlwkm8JS5GNC01XeUNsi1XVUplj0LmjwXp2xA64pmYOl0xxSh9dYTKHv3SPEJe+XQonIJYYmmhK632I6TENzbE+aAgJFROdnwpQswfYXfNs+LlqUhjuKxMgkMqEwiJBRkaVTKTwFv07d08e/eFyj3VHUv7u36UEGYKSt0t1xXEObnk4gJSUA8i6wlBo/PT6j01rAIX8YQsIosWkQrCDy8g5eloAqSg3FvnKg3OgiGQtLURoUsIEHwJDsgGNPpKMuVSwkNaCzG77E0dIBowUkVJIh1C0fAF4DctoDzBVFENs0UBoS+7gBjS4QgJd5BgnHSkBGElSYdAFoVISiAdYRKDiYOUBcmFZAopW00gm3Ij0n5XXQApL0Nf/LKyIL8AOWiN1KJFy5fzCwLR4CJ+2SJ+AV6TX3TZIolbzi+7cHkBBg13MF/IY8JIIcIUyJeA00tcdF+ODpgppB1hGpa9rUMOHoyz35hAXWnBJNcm+roOlh+QIPADMePbecp0+hQpMLKuzhsSCSzR4Ob3irj5JwiXO5KQnklF3C2xcdzyzwin0bBxee+WMdw1nyr47+Bn1L8IpwX/e4D/Dsypv4K7lpAjwOf/pIgTwD0nh5DhwB99YAx3/WFwx9fVA74ETMMPSnxGwK//DTDEZwN+4oQi7q5DED/4jwBeC+YtVfpVj4/hXlfhK8H9ml4FX/dAEcs/hL8a3G4Ds+o7lp9fAO+eUcSVfgXueYT8DvBWMDcfgPQg/y8A/wqYLxHnEvIm8B9eUMStx/wOI+Qg4KmAT33N4rsI+MVg7vqe5dcE/DOjxnAfH1LykwQ7zRsKbrsL6vMgS281uF0F5gMRPwHx3zJyDDfpDZb+RnDb21PElX3D3P8A+BCYUb0M/xn4e18aw+mg/XKg/l4E/GD3GG676P4m4FmPjeFeUdXXB2D30jElvU8Bz36T4X8B/y0Yuxj+KPDS/CyFh26VwfmomnZDOmosELoSSTYOL+KXE1BfyQIcqaE/DKGzZs1aDh5AW1sAo3kZtbys7LIrLgN7EkiQBal4JhkQmAO/IAhjHePJMtBhJtfV1fFmM19TU11XV+3x8C3wN3k5CXYQIRCKQ6SpNL5l6LIp9D1A/BDMEl8QErrK/MEgZngRDC/hNOlICgIksBq6KuuAZGUYZqeyBWzYg4wkwkHMQsQNE6yScxJdiRPXAgl0wASdAm9W6Pr+NKrd0PsXtKOyUMbe/IKRpME1ha8lgQyWxfkF8QSuEVI4UEh+qQ6LYaMwcUANxMOxNOQquposiEeCUu3EhDVSPtZkF2vZQgrp9LZo+TKeovbutFAWwAghqsSaIKHjkxhDMoolWXbpjMvKLr9UuKzrsi7hMqHrcswTq8sFYmTQRIFkOCE1y4KUEFiUJQBk8gJx1Fw0mWRoAdi0TlhMJJOKwLRFFmRo0EEtGeSVP/KjP6hzUm2thlkfg5PSeUFSTt/JVUBMMOfTKQ0mQZfTYTe1EJfbTiyNFlhk1ruaicduo9dB8Zw7Xg4ux5UIsUb8nalq4hJfBFVNPDiNwGIuCWy4sw5fnEa1f5BxL7RTNaFLnHKchTIp4k8lQKjSHaQUda7SSugDZfPwZy78KGg+OiIrhgbBokoLr/5Lx9MwXbM/fLWayKJAIo3ANApdoABfMoVvXyvV6YJqA2P/cPhfTQIoN/iCGHwzFemMIvElYd5MdlAb5t4puheURjKzSiuqIhlYJQagMv0z+dJ2+sqemurSuupSD1/aAmr/jteKi7g3wOwC8zaY98F8BOZTMF+A+QrMN2B6wRwFs8IPmp3QDspYkvgTSaDdZEUmBiZC/JlOkoJ2hzUoLHpW4yt0cARJwJKzogtfi0b4skUSi+/Wgj4HHoyYc56vp5o4znUeVE5F+xStLXwVG29YDUqYvx0myToUObCJwwRbHa9OQ/PNiUDR5kk/IgsD12ropqQ9HINei5IBpEH1UiI2wNEXCKHnshgpW0vK2klZgJSBotBBypKkLEXK1pCFC0nxQrBcRcpAUS/rTJMyUDfKIkChxcviWJcRkOVHpxdxQfpSNUIu35LL/UHETwG+5nsN9ycVfueOEdzfVP7tw7XcHgkXErKwPo/7SOX/zUIt90+V/6U6Lfe1yv3jV0dzx1R4erWWO6Hy7/9sGFdwkeIeXaLlzrtISW95/zCu5CLF/2MN+Vylyv2upXlctcr9EXCfdGKsHJ//tlHcEpX/D5ryOI+IXx4O+f/9CK5Z5b6pJY9rXKkqX0DLtavyN/vD0dwaEe+CufkzwG17FPct03K59Sr/v1qh5W5TYc2VI7mHVPilJ0dym1X4iVdGcjtUeP5bI7k9qvKF/8Bx+1Tu11yn5T6R3GHWPNCZx32rct/Wo+V+UIWve03LaWcouPsNWLeq8K//oeXOV+GP/6nlKjYq8RUd0XIlMxTcvYnjdDOU+sxE87iFKvc383M4i4g5qK8DU/K5elX8r4zO4RrU8b3KcT8TsfkcyP8nI7g1gD8DfA+Ub7dnFHeFyv/ZFTncly8peOkRjkv/agzFG8dCfKl8bsq9Snr3LszhrlWF33JgJHeXCs8+mc/9VpU/4cF87jV+jCwf3avyuG0q9/NcOdwOdf6TedybMxR5urkrj3tfxF2g+90bzuE+VfnXrM/hvlLh3Y/mcP0qfNcfcjhupkoeenK40TNV/fmKPG6siMdB/Jqvh3OTAFsBfwR4/ro8rlTl/66PcrjD34+R26vlujyubKbSPq/cmMfpVemd5x7JLVHhpQdzuJ+q4vv1dzmcY4wS35u35HEdKv/vHM/hkiqseWc0t16FP8jL5TZ8zPB4SN9vz+Wun6n0r93g/34VvnfvaG7kSJYeD7rvtvvyuMdV+RFW5XKbVPELr43mXpupyOfu+/O43TOZPNHybBjFva8u7+pcbv9Mpb0ee2M0d0jEKH+GGznuBPSnE2J9v0PyuOOq9D9bn8udVuGyufnc54cUfODGXG54mUoe787lfnZE1d8ezOU296vk681c7qEBlXy8m8tNLFONr/PzuSUiLpwK8Y8exk1Rxf/Skjxuhgqv2p7LtU9i9ffbfEIaHszj+CfZeLkOdPnwIwXcHJX/TR/lcifHMFwF5f/h2VGcpUwZb+yD+ZzpvbGy/yd0+ZxLFd7+VS7XVKbI5+t5o7iQKvzyAcLFVXj7AOGG6mL+YABMOKWbU1U1j/hBm0hngoIPdySi/nQ86VtF2nGRHgXiY7uYpD0a1s2pAJLQzwMST6cjgi+YjCdIeyoNa4WokPT7OgQh2O4PrJQwqO2dnUKSiJqkmvOlIbkU4FhHuBNJOhmP4Mv20J7g6zdRrSXCyg49EVIBX8APjqDn+zrCXUJwDeiLPjEQWobW0GAdydTKboghIkSFdLKbdKzxQelkjwAT8ZQEfREd6YwFs3wgVnkhnYlw3IcbvZ2JFJHf8YpbgCQUDcyeN6+ShKAqQGWLpeLJFANK+uFkOBjORFPtQWBR0yERKLwvKKSFANQzgZjlpCLhVCXolkjTQgyqKhKpqoikSCTuD/pwnxMfKEQwd2FcaCitReg7QoGkopUVlUESDWQVCaC6RNlQbIXoyvZIIJ0E1zg2f9IfTYgsrdZoIjOnoqIC6Xz9bKCpqtn62T5/OJlKCPjKxNTsoXiOTkei6SCJ+VeHO2kuY6lQWkhGSTwpxLFGE0Kyg/y4NL4wBEE1Lh0PQP5SiQi+fzQJK50oOCUyacrFM1Dn4Sh9HBL0C1A9Pn8igbAjEl9DraP+1SjDUNntoLLSjd9wNAFCix6Tne2YhyQ+LvBBfQtJtUClgr52IRYIAQN1qweSqOxSipcSOteARgxtHvQJqwVYGKU6Krroj1ifqZg/EUz6OyFbSajvNVGC9r5EApiOaDgWJul4DHISwf2uDMoEJp/0B0HhxgdJYjSr2bJrdRoqQt2kKSEJLBLoxCKqrubF7V1DBLfPunHPMUYfthRIXni3+GZqXG2ZzKZyg6mOZ28ZFl94qngVI1OeaLHtOPqO1KFB6TqX7R1LwT2ZAD4r6shEIt289EJsjOgMwZWUoThyyvX09bPqIlBXczilsh385rzThBt+N+HmnyTc9FOEuxyM/x7CvQT4lVNs7EM/wj3ZfjJn8NM9xE/03mw/yrvAQS7DswJZFsFwHGwGHxyu4XoKNNwrQAWgTUC/4zScBvhJYFTvjKa7BPh+bwinsk4KyguLk+lktmMq3BkUIlhh2faZmDo2WKd8dzakP1HDNZyj4VrOBR7oKjBYjnvBbf0EDXcJ2M8Hkwf8RKATz9dwUajfchyHcfhlL5Om7zn+RcWwNTP9Zx3689Lh9573cnTYz4+uSMx+JHDg4buCD+g37jvrt1s/6v7JgXc+3fjBnrtnOP40fPtlm64YVrZ1/22Tem4NFj476Qj/1IqaVdu+/4fhhasvf/vDCQe/+Di6dMvbR/9yzd4NjfdExr746Mrg2uPtp755XbjB+VPNuA8i+YHAwtEnfhjF3fwaH7v4Z4VhxxeGtneSqzp/s/uLnAW2t3NrT10zas/KLQWPnHh0y+zIPZuN777+3L7Fx5//wz8j7+szP/3E8taodz9qWbj793+o+ODCavKPpeuWvvfaOf5dPVuOPlNc8vLTjffe9ee3Rj+yfesDW7XTuI15vs0fjHx1yoERm667LF5e5Ag1/36S/6WFZR1/utXw0er8Vfs0z/N77rmo8J3vrr9m06oLtvwp/5Eveh6sfHvrV795fVhX1XEy+pZHh/9i/D1nffbcqBVXli2McndHgrdpfhr419GlK1e2+yPnv18hXFNP2o98e1d+5NJHNBNfOspd1fTy6B9e/eApwXXg2TFfb33hxss2bjv5yaSP2+1lH579/WV7bxIcbw80+zfX/X3pluo0ef7hzyuee9vwyCdL3rvr/YXRl3f/duDou3tXHAibTn4Qq7Ju7Hxi19a2D1NlueYvJ+VU+hwFj79+2aiPF6zKcz1u0E4tLBzxwrX8yNdLt4Sanr4mzg9/u2Pbg1/4/37W8X/87J7XP5g++Z5dTz3z6Ht/OXfh0y3rRz0z6+Kfbn/2icifX+Q3bP32T0/33Dfy8z/l3LdnU3q+7Z2vn1yz51dnX7gvd8M5H6XGjAj88+qLg3cuWhEd9WjrirUj3jrri18NDr9j6h9JwaYHhl1uvmN0756HuetCRzQ/Ob0jP7y8qb3vb53CulVzIuftz18ZWz3x7dOfzth7fevaDwvfWPJxZ/yTbcePf/fCLaYXnj33nVueavvq4XffveKO3b9+ecf789xHPnEe7nxud2fT87/7OH/LJbVzNtd8OGPU+46JBU8eW5Izp21trmHnd22fNHzS+eh3t8R03S+ErTc97f/bhA0dzz+0J1465/OQ+641I9/IsY14bts52snlF+Y1vHDxn1+ZNmL75ttbn5mRu+Lpn/7P4Hs7dG/t2nLjAx/MnPTHfyx7akfw/guPBL755cMrMgV3RLWP5Q//5SVzzjp4Teew5NgmknfVkp67xq3d+vkfZ2y6dN7EP428/5Y9t4964Z0vn/3uo8uKP9k34u09e681fv724f6nPw7FNnx4wZvnvLB+2YXbjn225qn4Gtuz4//Vym1MrBg9+NeL8zt+OkJTNPiA8PPwH9v79w6u9FveipzT9XnBQ4f2jHrPuyG3fsfTOfP9F3b+T985bbvqbGH7vjWxRUtW7P7jR63vftAx4pPFvRe/P9fzx+cfe+WB5/5x5VubbQcGt1Scf2T79ht2/PmvFXc87fndw89MyZuz68935L/35vSmf3h7Oj8ombW24+mtS/wvayeGlt85I37R3BdGPPPrW0bunPhJXuvN32nLpsVgGJ9O6v31xA7qWiyc7iag13Q1J+LtgqWj0xZxpAKlshWhdvi8ed2nc7t3GkznxvK2bNl6h/WH45ccyHHOq9NPqjhes+aq1gU9qSs/dp6dwffQnwfmcnyv+jc7bmdaau8ljE5ZzGgLo4t/zujGnYyu6Kd03dWzDEh3jQlQevV7d1MqvPkmUt73kNYI9KvVNXOR/ubOCVGgi7/8ZcVvgN76k5effxdo1YU/rBxpkvJNHnr/mqaq1SbyWn1n9KXfm8jC29q+aP7MtPimLV2Tnjzb7Pru83e/mFBrvv2duvy3eteZcWu9d14Rp0XVe34RB8spMhkovjteDxTLuQQoLBOIFygsv0gMKA7K64DCcorcDrQAMwh0BNAtQGEZQXqAjgL6JtCzgH4CdDTQg0ALcV+/uogrwnoEOgb394HCcp3MBToOqBXo2UAbgZ6D9QL0XKCrgY4HegNQbIMHgE4A+iTQiUBfAHo+pgt0EtAvgf4E6BGgF2A5Ly7icLv3XKDFQEuATgZqA1qC6QCdguUDWgr0DqAXYvxAYXlFXgM6Deh7QKdj/EAvAnoa6AygExcUcTOBzgFaBtQCdBbOxUD1KDNAK4HeArQK6GNAZwN9FugcoC8CnQv0HaDzgH4OdD7GD3QB0LELi7iFQKcCXQR0PlAUPBtQFKw2oChAVwBFwbkTqAnoI0DNQJ8DagH6t4Vsj+ADoDb8ngPQJbhkW1TE1WL9AHVgOkDrgFYDdQKtA+oCGge6FNsBqBvo/wD1YP0D9WK9AG0AWnBJEdcI9CKgTUBbgTZj/QJtwbkdaCuGB7oM8wf0p/i8D6gP2w1oG3aIxUVcCOgioGGgTUBXAF0FFL8acR9Q3OvcBjQK9H2gMaDfAY0DnWQo4hJAK4CuwvoCmgQaAprC53lA00B/DjSDa2Ogq4FuAroG6A6gXbinArQb6wvoWqBjjEXcpShHQC/DegKK44IX6BVA00CvBPoQ0HUoP0DXA/0G6FVAR5uKuA3YjkCvBloD9BosH9BrgUaBXgf0UqAbgd4I9Hrc0wV6A9A3gN6IcgL0JpRvcxF3M34HA+gt2I+B/hz7E1AnrGHYyTB84g+AfSsBzw3Rx/GoQvH4tvhwkq73umUX8SgVUT+fZ++bp4dRiL3cKb4wXwrBlGyMTXw6RAzJTh4Xi/RpfSQe6ySWLiFAn3H702Jooz/IcsGOwGBsoLNGglIGhBTxJrt5f6c/HCNO9XEG4sLi0GdBkHYsDMXCyKTE2X6+mCnpaAUxy5kET/QRIN+eSXUTK2ZB6ArjosaUjKdS4rMxnh4FyC4iQcXfr6ozeyobsuMf8tEEFnmaPjPA5RxdAHqlAwzsaBmqsmK8+ByAvhU/SbxCF/vgjiqTtC7xcQ3NVcKPeRQ6oF5iUvbskYjQCcsWevDADSutsngM1jg0HtaESupYPKirZHwlvqQ/nBBInT8dUo6yiAdIgnE8h4NcRyYWYH6gAvFbGChYuCAAVTxGy4j5Eo8S0aBCih5qoZ9bsENDpfH9/Vj/UaiMIDGxU3DyESjVGRnigMVrhNezz5x0w3o3GWcPTJhDpfiJDxnS72AQB5TpjNG5xDW7uKCj0cKq1Y9P5TDXJo+dT6WTmUA6kxR4v/SgR86GmJpbkpwgng9CKVsTz4DExgOBDBVgfLKTDPLswZESjSQXQhee/OtULFA6YTmNVUUfeUK3sIh+eFyfYpx+/JDOj0IE1Jb4DREmI5gy/ZaElEFVX4MVOhMF1g2lHkHrAksv+KOYHj2rqOTdG45ChQldCdqLxH7IfKfkrpQCwcCzP/QjMRhhnH0MJiak6QdyXP7ASpQKdArHUmkYRzCy9hXQcTAIikRaYO0X8qf4dgGEMgWVj2ka5LNqrDCeJN17EJEpHo1mYuEAG+zY9yniGDgWVJqdea3DA6yheAKbXojiwAY1CPWoyoHb6oGuJQRAUgPyKEf7PNaKdE7OHvMnYJSCtTBuO9A6pc/wIGmxbuv9UVZayNoqPAAWk+uCtpPS4HgOi341hH6Fy02zIQ1lPBMF6Cp+No776c4FZCcmCEEcl0N+7GGwJk76YfwxUGdsfz8IiDx4Z3uaBQw+lKX1BYn7Z2FXkb0TA6sc8ZM9OEzQo2LSuJEVWxhaHvKGWcNTVChHWYmJY2MERjAYPeTpiG524SjDeh+M6YI4EJqlsZT6w3yIgx8+mVdmE3kUS3VH2+MRaCs6nPFCjJ4+oGKTPQOmMgn8+Al9aMunYVRI0U/0gJTQow+KqHT4o+FId3YYEDK6rYORsS/utHfDnMomrfZMRwd+a4QOyEq/MYhNeKb4aHAxQSXlNTDGdSrfmUlB94UxzUMJThZiaWiBYmWisxyaioecutgo2At4fwf96M2PysxLp02zi9eBpwTk7PvFHTsQAbCH3HSk10ALgypADxMElJD+dvy4TD2TcuxS+PUdGBXYzKBYD02RfukKh2tSgweaJR84moIl/YBVCByy2nMN5gdqsJNO+GIV+YduLsIIhwcZWSCpS8kKQZ04U8lClVWVStuLsdN2GSIVrJL9KTzEI43MgqKISIXGRxGJ7MpqF2gF0hmKTl3eHzdPOHWGIp3ZX0y9Ian0DmhM6AoxGBSqocGYRCQiqCk4wqAPirNXO+o/ATaggGDKgyNK4UolMshuMkWWZuIwEEr+8QwLdM56GDXpKAjDVTDC1CSlmqhWgM8a2CFVWafCVsUhUxwYeXryFjs77etMJWPfAAuGO2hBoJD+lKLm4HEjXjrbSBrpSVtZSaJ9KCh0wKQUZKM31UMUKWKfZIuwQqQFUZ0JoJ5GRdaVhPkxnknxII0CKsrUJ5v3UF8Sp4eG2MoYnvBmaLDRAmscMD8D0w5mEpgOMCvAxMAkwawGsxbMFWCeA9MDZieYv4D5G5i3wOwFQ8BwYIrAnCvGVQzmQjAzwOjBLABjBlMH5iow14O5Fcw9YH4D5vdgNoNZ4o9lcPS3Cu1JytT5k4EQMcAcFgG+myzJxAT4gaHakOnMQH/zCCAEVDN3wojMNPTVzMIsBBgDsWKMGBlGhZFgHBgFhseQGAoDEA+0PaRTF6fEC30FaZMQjDHOG8okKWNNhpF4/KCMUQYihVAYBL2jR/SDHoihjpRW6IPwU4k/VUHpULe8VyyqKmy3+Jsd236m4X4FZl9Aw/0tqOEswM8PsL1neqI8Gg2kgqVBQilD0gb6pDUa7gcw+K3D5V0aTvoUp8FUV4r3VyZFNZwzouF0cQ03Guh7IQ33FzA5nRruXDDngTl7lYbzd7L0LlnB6CQR37uS0WLAlWbeHW+P490Q4mqu4q11Dfxq/awuYsxEVpIxGoKHJxf/4cIiotFotDka6flpPK3hUmmN/Fx1TVpVNtwrg3w+AXZ9YBoyGm4imG3AfwzmuoxYpqQ/CgUaVSB/zJFOzrPEM/fpaKK0Yk6ki3RNhnWsDeT23CLu/BrlHOflYH8r4A1Aebtif/M9Gu7wHVC2uzXc5XdpONOdGu6DGzXccrDbd7uG8/wc8C1ifgFngH/9Ng23DMwwMHbAD4KfSUDPvlnD/f4mDdfhT9MM+tOV+kw6jJ9YrG/wepvxoJ/V4NXpJWaOyFRSG/V5wMFtz2m4i7dpuME/s7THboV0n2X83WD3t+c1nE10ew/8fQduy4GmwP67rZofPcPuBLuyZDyq60iVsRsLmEXKiFkc/ObwSxruGjDXv6SEr9zB+JvB7i4wj4huTWD/LPDbwWwA/rwdP07zJXBLQ117l7D6vkLkcb8Pz5B8deE4DoXkd1PGcNNKGX8N+JnnKKJ88U4o/8sa7l6I+2Ex/qdFug3ocTBFr2i4b8HPevC7E/Arr0J7Af34DPk5DH6XVZTNX35R+UUXEcYRUDDxcOAXfBGHRgsJn6gt4tDkQgxfAL375iIuH+y3Qt5+C+ZbsDvVV8Tlgd08KM9NYMcBvQcofjMYDT4BG+omhc+H8hWBmQBmOhgiGuwxl0HcV4O5A8zl747l7gX6GzDPgNkJ5m0xbTR4NrkTcARMGgyGfeU1qLO/QBu+zsrvBFoEdt+iHZi3oH40QHExUM0Ox+MpP3bgUzz9KZ4UZY4B/FegOjbKrPEaX3B6wRkPkTIf9JOveLIxUUDox2ON+KFd5qiyxYONUpBIULTEs42K1wp9Fz0LCqO7nC3waTWTgtIy+egplMJpdRhsHlJaKZ17rKiCkPS7ruItCVIrUnGZSpr8YVxWzGygl5voBgXumbDLabKrR/ocq2JDz0jLsG6puDBQWdDFcicojInyjqDIiIdpKSD0A8LEY6qxmH1Wu9Upsm63yHhcTnyxq0mETnx/CM4XRW9BG4K57e+sjZf//ceyrgO7Ul3FLH0HnhpeWJqCgEEUGPC5QKyMRVlffoUldaeQYPcEYTjAR6M+WECsiflAqe3qJlF6rbI8usoXTXXiUV3RU7niE++j4JCcARVwTpUvTfVoKGU0cTFazfOl2QIa5EiyWKbTz13O42Wfi8l55+Ie40byAfSFfxNFpR6sgploVImgajnvS4B6C9muuJi01eH+/khyPlD5o4vSoRwDvqEOD/H4ov5OcWoFRrHu7E7GmT3lcGkbYddJCVqILIQRObOl0W6y8HZzdQF9QUv1cBBMfB8LZeoMNkqJfFlKuqFqh5kT5q80Psc/o2PKj8tRHtRC4Qw+aF7Ei1u4tI7g2ocub6kWye53YQtXk2b62man1covrOb54aXzZlV1DSctZ7RtPaNtM36a5ccxnNG29Yy2zVAR9b4auyk7hjPatp7RlsXgOWMMnjPGMNQW6hC/gQu1l0mItUkrllal6num1BIbOMuO3Rqmn9ZFd1lg6MqQnk6CxgEp4NloNZP30LMaEqaRqj7QajfLDnJUygkzHxU7Hx2mFEvM6FA7yOdQqyGw3R/00VV2By6U8MySLwIyFQt0MzGnSdGLZgK/mN4ogJyq7xcnBfx8d3AmL2UeEQlHcfWEgSACKmmSf1EcaTaw64rfX49EgtibeL5LapOO4dHy1M/0zLb7jLZrz2jLYggOT/rX0FrsUkfxI+u1Z7SmfQdKgnHzNG6YzijonK4qHOtnqtJRC8jA8FJ+/qzZHRArjJ7MtvuMtmvPaEtjoHlShVXhtUNwVnZpPDj7guR1lqfU+UW5VWcXsSq3nbC8T1HL7jNZrj2TpSqrckAFrs2GWflkceC6XWlGyDEPApcKZ1Qu6sbBuRqX2dhL6DIblrCx+EK8ti1uk7O9LrGAol0iHomgQ9qflJ2YeGd1n6F2TPiHWOKEIEabFZ90L1Y8kVnNp5Pd/FTqZepMfiqeQEMajnXEJYqHMJGnWZ46s4CId56qqapf5uaT8TQdsVV3za//l4bbBOYuzb+/D74Q3KX74Abw99/ug0tx10G4DBj/f4i7TBV3yf8i7lEnNNwTYF4Co457J6Ypxv2rfiXu7pOa/xr3r/ZruEuOw9pqUMP9GmgZ0XJSvf639mCPlujAhhBaMN7RQbkwNBR9Lsiz7W62jXup2DaXk+Fl7XxZWXsmxYf1ASTTKqeDpR8t6Slf3ErjVey0+dPJ4NSmIm4mmAowC8BYwbjBLAcTArMazAYw14O5A8wDYJ4A0wPmNTBvg/kMzDdNbK1k15uyPrONOgDuVPFGTLgOtIdklG564ofVcdJnajoVZpY35Rvqr0M7fgxGNyK73b9DOTjDOwZM3H9v9w/AjyEH5AVriqirhsSENfJsoLQCYU1ARX9BKB2NQMtFcKeNPhpbVEAC/tjUNJt7xDKKTxAbPKD2um1G0lRjx3fgOwyeGuK2mEXO5rZY6kXe6GiQPJhaDJItKASWeq9BRC0WB75qTwpgMNWSGghlajE5LKTO6TT76Ac0CH6UqsHg8JkM9fhtmiYDfbO0xeqw0A/6eHBXx1dvcdYT0Mt9HovBg5bemoZ6s8Xt8TrddQR+XWJsdU63Bz9DZLaIbUTPh7NhKXvK5adRSWYe2Bg0dTphw16a7ntm/BE65OHrE2T7oEDPWssO6lTYQCdG/6P0faB8/9g7ta2PK7frUX0yef5bv5PGP2k8TKXjCRj6pDEQB8NOPK0u+aFblFPZgIgbJPw0SJclCIKF5abeReVEREQOSWDpElgJqxdQrlBRyVA/POpW1fjDp0LSfjLTt7Jd1+BzPX9QdMMZCXdiM0mcxGbpYOnEnt2J5/JREzTW2bFZpCO6sOhUYiNkscFoWuppXJnI1vfWhOL+aFjW+VgcJKu2qcKkbhS1hZrP1uhUlnKW5Gji8TN4pQ0Bv2n6oEy0DGZwCx56KS4Td0jjRksxjAFgRk3W/tsx/YkLlHEjXPLfx43ScVruW17LHS7VcqweWB+Q/s6bCuMKmOun/vs5avhUJc3tU/97mlQ9CKMcr0adHKSEh2EdZYE+tGBLORfv8ldn3VIFEagEEfCe0bbO4+Dp5V98OM9CovBBu+M7en60omCDW6eQFo+L0CcBLH0QoXAQH7p0xzMwr/hxPUKfnkirB9UrUsRD5ez6hI/6pW/7YU+aQbBc9LYJvXQiSQ3lo4IfcypB7LwpHxXulNj1IS5yplEI/YujEL7KAZ+gi+qR+IwnmYnFYEBQ66FqHVSqJFqLuCNR1UH8EXaFRrTToV1255tHreT1g7SEONN7noJCIh0a4qKvWSsqhTjzyE/z+DVsd4Y9y6SVSB/D4OWKcDwYzl7KZFuWZtRZ5GulTKKGwHQH6ZQH1Etp8H87TiLVq5TF/0feuwfIlZSF4pXMZOk07oXlIY9l9YRlyAzMTGZ6kmzSJMHOTE8yZHp6trsnj43heKb79EyTfm2f7nlksyICwspzUcgCFxW5qHhFREVALyovFXHRBV9cRVRcBGUVxAW5grnfo6pOnUfPzAK/+88vu2e6Tr2rTtVX3/fV97D2K4rejYeOiCBg26X8TH6Ec8xRjlqzf45isA4E6QRlKdELFteJWAdsGbqpw+674e/gz7ScU3MWHby7WnEr/m7hRXB50bGcLlTcgJO/Xu4hWVqxAttKZxRo73YuP12EZLTOW1wqZM2JV1eSqnvNlpb/alrcfRO9oH0jkQs5EtIhJxkV/xTlIRnw8N5hgF3wHE/1h03vfJYPm955cHvYpL+yXjBqc4ieoZStltFoH7KDVw2itbyy1HlOu91r18wzXsehjAGDDBs+Nust4L+lw7sTd8Lz1cP94b6JL34sv/04335od+Id8LwLnr+CZxfU/Wx43nf9OrVbg/CL4bkHnq/D8ynI8w14boVwDp5Kw7HZ1hGb4bCWPbkcrzJP9SpiGv6Xl+iymC5M8zVo2lqBBczcmSBSIORawYlLW6i1Roi1YuccOT/qY9sq8iBEymJIPqAZIDm9XnfCXDPZI7sTDXgeOrEz3Pu5R7afy9zR3YnnYL1BEJOEPqDUEMPj2OWDWdokJSFIhI4ZP9R7ijYjGiiFRLbt1NGJb+OpqnWx4V0SQDB38bbaj7wk1Rhh86wDGKRKiI/uaJmKQA09eUstS1ErVRRYwZap4RLjXfrslnIR6wS/F8/l/DKjegcDTDo4YTU8tU6CqpXWXWrNtNpq4eAeusoKZ9jxu5PCf2ELcZa2xenbtTJodvvM7oQDTw6ePDy3w1OEZwmeC/Bcggd7q/pAMzu8glqLtfLIqNWuNVFMCG/4KzBDaOkv7tE40sNQ303zsDfm/fZun/fbe9F8XHtF11npAVTLZRZTI9bOW0U5PchrseppT/KYxyyzPiXB4lkpzOe55R4Z96M28GNJVbxxPYaHoI97c7sTexZ2J26G3+fA75/B799B/IPwNCCMnlPPZu3TQEAJGUZvVqcW5/KBse14LKMI1x28fuDVCft0QQyKHDxn4JmD5zg8J1BxWP57I/TrnfBk8v5cf2PBn+sPQlgifel0ud7yXBvtJWpMkK012gBAApF4vtiwlmrVzfhYizQlPbRMObERn8VGO1iYYmU5b7XiHR9qYwH/qRhlYdF3XJtqQERIXj5wGgvABhPxJU30UVXJAhr5mdqwyzBczwbQR2wUvIXTeRACxeXCLHAi63yILIcmDBUYuz0k9AAco+iVTl3EkznQDHcTBj92og2YKU4ZXS6iBB/lPkfj4WNg3ByCE5gd171svNK3NN7JiqjxTkLR0Ew2Z80tzPHdQBotAyLyxxiyZ9sSy9Clfhh/kgbsaAA8fwc8O7X/uJOzdsjbO9Q7MFTvWcP42yPieSSp1/RnoPzDJZ93Vzu7O3EZnocvwLl8B9B78AzBcxyeJXgad3DewD0UUTiAYtKU8OAROnsKPCPadetQD2ly68zpK/q4bDgbKm6EyrY7rWU3QCtVYggoADkKnx2qIOLItJE1DDF+G8HKsUDFFyjGdcWcNEUUE00w1MYpQuE9ClFrUDKdxuK0qI+jQRy1wo/T4tO40j0wN++E54k/uLPzfSff76V3EEwJzTWgaGomJGouZ4Lu4tWY1b89l3YnngLPpP3dxeHwdoxpSWUFMZZ75XY9rQC+E+pRoDid5dOKMKa2E4msYmSQ9lAIO6HQhIGZTUvmvnybEAYNo0mDip6zjAPrHZ6hxz12R9/yVZBvuzl7z2Mfm3j/D+1OfBS+w1fwWzBWEpgfZW7xouRBX4rhQQ9VRpQxiLTYayAxhPkzDoMIrHjck7735qc+7WlPu+WWxwNq/eQnPPEpt3xfCFEM233Q9JP6GP3SscE2zCoaJkAZVrcyLmSZtFWcziwsoOtxP2YxXyj5rzNkizoOLRVspBiXEXYTuSJ0PmcLBYAq5RUXzp5uh6x1sllWaYMUVlu5CsOv0TyOWvTSopcRnQ9WZNnjGiCyTJi/AgfYiB+jjVBLlR5PGk2e7RQvb1rFBsz5IjKMfIMVwRwzLJDrJ5dNPQBRhPhyV14NS0PXbI0uDav0hFCie8XD4tKJS8eff/fz775kwgDEt7vEX2mRkoIYW+X7svDno0jz8opNblfSbrrq1dLttEa9Nf5M091b3hCN7uXgJ6rWnRVSuJAcFLLIafJRWJaE9iM26Q9jSuRpPZPyTxlFLGEpnVosKtJ71rnsWg7FsMVBaxhIkGqvztWywdcRkSW0zuRzkbaHg6Z04Qgmsg29ufuDEUDcXu1hXzBai1APS1hx3OkR8MCvMYKDvgqDvup4q4Is3FlMFnC9tIbUbC07vUqHTFQD0ODVFVyBI6HYVjjWX4liIV+y8mfEhWwRgiKH1Bh6ZC6aM6XtesBemsstzWdK2RkjbunkeeMtVzpjvGWKp0vZ6dNC7aXRQO9H5SDps8NUStoXszVbNU/meYHTaDBTpKuu/j1tgoTUemRd6lt4/E4Gw5U1b+KSNTzLWWmJuiOFCepo8wIDTp1ixJpbZ9KwcQD6EA6I1Uqrzemj1poOC7e9KkuNWm57TYYFjtJS/Uxbe/cOHUai8/QVToG2WmUUZYukGGssHU4rlKaR3nwBC8un/VRNxirgGjFqX7HoCoM4jfBVTXP1BISkYQ/1qfBgTZvn0j0buxOfgecr8NzzQjhjNnZH5L0+/dXHJPB51csAX+te9hctSoyTqWhYH7Bkmr7CR55NuueQOgRi+xmLkCOVmhhNTUw8KzV9Y1JQPUz2WYTuKp7eMxZPTedmRicPj06o/551OAMlqI6pyanRyWelsvp9YnI0Zb4fvQ3yp6ZuNPHgoy8HGhCeC/D8xSt20zh+BBWg3wAPKgSjwawP7YIaYGUXRxfzi9DPG5PydSGXHb1jJjN6cjS/MDoViD51iqJnZ4OxxVJc5sV8kaMnxicOhQqcDRcoLs6MZkaPBN5Pjh6FYWFXBDbM3S1QvQLbFFiPeMapRSE36JafxOAjXXzl7sQleO6GJ/Nmnp/3LMvEN/D80Hyd4XkCsGY1vBUF1zHMjKsNZRDcquP516PUmmFCe5JiiBBE20YI2yHW7MsHoP0H4Xnrz+xOvOWXoC9vi71j6dbKlwFVlp4D4AzCDaP/wFncqiKQ9GJSPGSLAuQJp1iTB0jGxMYMLidwxIpDb4FLPBmDJAX0Tmq5+FhrLnMKPUJkz5eyhYXMPFIAxBRTBnYQ6YctK2U2LTUTsnSl5jnL1EmzRQACsKM9AiFJFhXTkmNJgX+zMwDMswvFfAEZ2ovS27x1aAJAiUrnnhXJPZyVGj9knXJCadnzxVIhs2hNhuJPARY2n41EF1W0NBYkHYT4EYVsZiaanAokp+IrTcV3e3L8aP9uT/hTgXWI07lpNg7GRsL46kq9wJziVZWf2FwJvCOEogi6Ce/zMbQ8G+NIEvsnYnF4CC3bt5rLLadTiSdnZFP6Nl6SQKguiIfO4apl/DVOALzwA7KH5AmRcqMmkEuvrmAe6TWRvh1SCeFbomktCUqXH4ySyfsjUrw2r9fVtRElaBiACTuYha3pOX8OmC2nrttMOVXk3cXd1UBzKI4OoRHDRQyLbpoXMwoeveOXdyd2vQvg4gf781A+8D6fbnvjB7endc/PFQvp6ZIw+yuXEC4xlGSh32Ygh6fNeH07tzfGx6REakYHm5HrHbUB9N2OisCLnUAEIMT4SclPAEpA4EiY0THDGmuwDMlVAmwGvCHRf2BjyL1pz6WmjTmvfRjOInge/sjuRA2eSXheBM93wve498PEX0DuRoD9o3qAl1Tq3zegrRs/ujvxLXiW4Pl+eF4Fz3fK39DUy4Sgz4RreUyaX9CbVQuW47oco1uVvNotoyS+iDL0Wg1PLn28OwKsLmAAUbIDzLjorRb7XVDm0QWuK1Kr9JS2UMelzUrSDCqGFD89rVC0XENUsF2vuRwnUOTejBE+wshxAvX1AznkXlRk+ulWqWQtZQolc8jwSjc9ZOqgaZXOHyicp46FbT2aI/c5DduM3SI78qr+BlmPH+tYx+hsrrh1B1VCKXLdOsYoqx8rxoBkHpOF+3zLLn7LsTGsb4xK9snX4XzUxJYZ1zHjEAoHJQl0qb7jP7zjgkEgox0IJrO7lNJTKcbo/JRiPpctnZ5bOGWdyxStuQXr5NLsbLZA/ujgvC4uzZeYxJrPLpwqnUbOyUymlElDf5KFzDmLXzg7dJF+Z/ILWUFnffEkntn5mWzOQkIV4y7sE5nSsyGhcLJPHsBmFmagR/uM9HOFPHQRG5MdiU+bPp2dPlNcyhmpxaXp6WyxSAOgjXMZFv6VhtvRgf+vfvfRP3TLu/VEnDt5HLoVn82fCz9dDZJMzpsFCcuyzp0GlAgmZa40p6allOdK9z2izMwt9EtQKmYtZRd0LjmGmQkxPZ/NFCBSriDZgoBEQFSLxbn8QmwUrzEcCNYzdz4dTOaPm1konoMqBdRelOsxVzKD8uNS+Pal7FKWgWSgKrkSgpFYo1ohOamaEciwkLcWsqVz+cIZqzh3aiETSmYEVE4VejDGeTRyhFuLXQFz5zM6REs3jQOi8RTOE8sHoB98BxoTcU8RSo6Pk6cNoh2QVVdtdcoumf4U3M7JpSI0gV8s61dYOq++IdUGr8u9KkGNrtvkSWMu2p09QCOQvQFR+TM3Sj9W8It7F0YJoVPZkiXfqNsXIO50pjBzLlPI0syggE04Yp9YWpxBWoWnEz5XZn6udEEtjmdPF29P98sSXA3hVOioWsmZkiXdVhDpCpjlcstjkQALPgpgi9JIsOUtVyi6QWcQH37tTmutVnEr+0SIxaKz4Jd75pkJwSVZv94D5ArZuJCUnSA/W77EAU7rOXQJScujhGObLeRzyKaBnQQ9VKdhfLdoENS4gU7v82MAnaQZo9oDs9JvJuNWIsz8TuC+D+RhNeXzZ0imzsoVGVeUAzBwvIc/sTux94+3vpu8BdJf9MeMYw19lnGsBz7RH8eSx75v6bmfRMbddPIjF1deolpXrbG1S2rtECzdVgmAhI9DVBQTPcuBmxVTEjRtCZ/U99JD9Z40Rq3olHiCRyJ5MnbVderdVbwgQJMGilXOfHsKTk5IprgnvNpKGiDFRnro4PhU1dqUv+u1SndVhlfd2spql1/U18Iu+TL+9/zd7sQ74dn1YP97yLs++8jw4YuQ//1/Cw/8ykGjISR13cAGkSISgT7X0xB15eIieKUpXe7xtI5aCj6qzHLW1aWTVsbyDIFceV8rgTnsyJm5Irq65Zvp+alTM6mAsPZjrH1Pv/UZ40cD16tBqVpqx+AEq2pEfWqlkpJitTKMXAcZlCLY6rXSa7vCsOwll0lSqj2h1tO0EUYNKtY2RSyxw0K0hqITfXOu+ttmGfji9kRIKkF8/y77K/8GtNRXgZ77av8743u+5K+hXf++/Rr64uehrkdMCoeGEddr9OaYRqYAkL9lwJzJQFzTXXFI8ChgFIeEScxszJIA5M0qN7v1yeMTG0MbzHR0NXdUcifVO+m3lfEqi7mB0goWgHeAq/EMsFSU/yWTDmLK/FxxKjczrwzZy3UlXwIC2joHcTpDkYr7hXGxXBuZUfOudpBpa9ZOQOQX9w/yLmmOmRdLIngwwqTJM77p67Cu4LkpMdD3LDl63dAlgHzbra1va135PBZrf4ifoqZU81NUBPJTYNrkFyOJKCLmSZtDxob4I0eTA4kcPC999EDiGvza8LwLnu+EP/J3UB5tZ3zo1WwfA59PvprtaaDvXXKAoD6a+lpBViUaBLAagpf4UC+SOoWp8RIWPudNthCWuuYpo06QDf/Z2Lvr+VrF6czDTlw8l4s/DwI5tqkEJ33rSlCKhzmLzV7jOAwZZkonSlHOoPhBtSI0EMa6vy0sIwLKAtDLugjYx1WYpEtKJ5ROSRQ7EtnxlXH1LfkSH/KituiEmDuPyLMUdKVBQK01tHTJErYtRFcVH0fdBY8CrGohDg3NYSegNvHtQ+QgEDY/ub9r+B03jRISRl5uuWEN8w3USFI664ioUZ0/b4m4o1nVI3lkEpEat2ZgFW+2enKeevnO8nMjMmXW6rotlSSPS6ExLxyTpFKs7IWLmpZBp9WQOEFayVHC3KXTWnpMuQGmVDXqVFlCcv89CMzNfHj9ZcZccUnzi6Kl1SME+dUaOYNR/+ZuGki8B56PPmkgcenJA4mbIHwcngfgufGJ8MDv658wkHgHhH/68QOJkccNJJ4C71+WsvbvhPTfh2fpyQN9ccW3QxkFmz785O1h8aug/n53gOYyAAjTCNpiw3s3lFZGokkqsMJKrTUnhA9LAlOq3kMzitHm/Pmw2HnKQOID8Fx42kDiK/AcgvASPJ+BcT0Az8fh+TS8f/CpA4lvwDN0sz9X74H4P4bni0/rf2697GZ/rh5+2sCOdabNu/tvQTl1h9/vQfvln38Dw/t/fQPbJ//mG9gu+N5rbB/9cdfYzvjN19jO+NA1tjN+4BrbGT96je2MT19jO+O5a2xn/Nw1tjPuXGO765evsd31zjW2j755je2jv+Qa2zd/9TW2b/6ma2zf/OeusV3yX73Gdsl/6xrbJf/INbZLfv81tkv+59fYLvlnr7Fd8i/A7wG0sw2/SM38J/xOwu/AfWyv/NH3sb3yx9/H9spvvo/tld96H9srf/Z9bK986j62V/6c+9heeRZ+02j/CH6fg7qM97H98sp9bL/8zvvYfvnd97H98pfCL0MvdgtEdgDmizkIz1CYsfM4+kNZXfACioKYosqQmp/Mx+GQqileU0vYNKSplKFnhm5CUJE58C4vl7OFguqq8mqEWqVy0/jjCUZogsV4h30bqIGoGB6FYUdCG+OA6M346Cvx0RthamczHHElHBE11UETKWlxttPE+iphYxdRSxdRMxdxZisY1ddSgXCQMKdm1L87xRwNJMkxVarTrGxJuvmT6mti+xgNnef8BfFsM2DXg7cAPP++gUT2cH/486lbfPgzdHjn8OemyYHEvfC8fXKgL7336SG/7nemtq/79dDXgWfD2XNwIAHYipMW507n7UzOnkNxbHs6v1Aq5OcnzZcU8l9LS0U7owI5MV0qzNuF7KkJHZrUoZQOTenQQR06pEOHdeg2UcrmFu15/jkt5hZKNqXlKFgsTNt48zCbLWQXprP2eSN8wQjfIcjIk31+XgVOy8AFFXNBxdyhYu44LdC2F7XHIWhOzJ2yp2dhTPALr/RbOl2k35mlwqRMT8n0lExPyXSYgfm56TOYRYawTg5BNoHyG/b8XG6uJIOZEgzgAr+cm1uYyZ9DhRrKi79QpVgjG8fptJ1DMIE8HMDgPLdDlI/XajpkSV9K4/P7kLTRoszYDlWMLAvS5HmVM3u+LViNTQUEyXUbsiqJCjSWJ1MbGyJ3kn74jeGYDCvpkFiylvPsiKoNKxvH0UbGvrzp6ECiAc++5/bHoZ5yxN87ezPb753sbQMJhd1r9TqF8UbwfHW7zATEPqNv/f7tZpeI4r8kbvOt6/xP+zqX6Sr8TUjbZYRVHbtlHbtkHWYb6MNF1TlgxP8nxJll/ytUjmTclF+9S1YOvekhBWKNWbcO1dJ7vXat2Wsn4/Ogjx1v1a2Mj48HcmSL09Y8i3TLalY6LioXmbXULndal2ESYUlgfrmY8Z7Gmu2QbuezH2mB84ECaCo1lDGQTqmo6XV7D1Y/kGxt0r4ychxWOU67G05M+hGVjlZxY9I7ZTj+N1B1pRaJB+w7Ek8z680ibZwOp/HvxaHaJSvN5PPxodpeRU5BsNzroFlkDEKjgJVjyMB3yJjT+PgB+N/rlA9IVakDqgUdGC+32yS7hySgVIzG0xcFm1ikkHEAAiXdsMh72gchvu/ACYI6tQ34cugmUsEKAmISJimhDyYjkaBh6KSTmUetoJPsq8+Hfxj2ee7kwLb6QA+fGiC48I3iwI70gRyoc2yscZlkpkhe69lIim8Q36BKEgeoe+BTVft8hXLlPgOzcg3WsKxqRIyNrbr1NvygkelOreKOofYm6kiOkW0VT9dDsJOmnBShhscqUJqXkECWGPIX8MpsWEaO6JJskNCPH+MFGVPK2YgvRfFystMW9jiNXtEvymFYdz37wMbdKPdB9zr2cs+z2RrDJbpG8ruN732Hiomr1gGL5+RSMin2WoEWrL17rRJ5VajypI/ioWJCBHIDCl+mwicM4objVE3Fuot7gSbFrWeSZtndUN00czj8xY0Twjm5YN/eYmdmSAoVi5OSBSVbMnnY6ZD4PqoWNfVpjJBiZJy9x8NBQvBTGu3jbW+53fK4NTyDnOqCtW/fvhHqRqeMoOKu9npzjD4M9h0OKwtxp7kFiyydj6ucAGzic2bO65wafMOXnEX1WOLkrDprrtYlsdQnH6XFh+llp2mhk4aOAf5JXBo3MdSkSqAojyit1tBaO84NajD32lYLj1Q0QbopvxT6kaGPhZ58MEZC6fAMGBDQQ7P1dOWbKk+FjxwzcZISDW4qjQlHkjszdnJ+Grsp77rCERGdnkgGA3cZty5EZg6JRJzUcZFbXEJvtLZh0bTc67aqVUtajmIzsRby8Onuq2+qrMnk2hGOe3GoB+eC47n1WpNuVagVDKACH/5Wu51aAwOwko8jKEVLo5Fi2PqWpb7n8gue8tSbn3bktptixyEVMuZySzbj3tNLJbRFyjr86iIHk8nQaWxq3AzIerFN8kYipd32hax6AqGTyc2ZJj8NO59x1j+RapVzSj6DL/tUO7/6hqD43QhqM1DGO1LzsqA2/aRLokMHDhvGnuKRZnZf7As7f/csflUdcqRiGr0JGgALm7dREsphozbKnE3YlI2yZBO2YsPxd+j8k8GEK7pAKphQsnAqrqYmDk8cob8prUZGKdJ0jmMZzAq0oYN2RLNKxluZUFNGaINuUeTcazTHt4NhqFFbw1AQ5aEj4tJmonHfdqg0kLgEzxO7/fkGt5Z8+uQz6zvnG3yrPZB4y50DiXff2b/u21t+3XPd7et+CPpyL9T7mbWBRCl9fq7o3XGF2AfGkpE4Fy9P03qnivKNfAYy+VcTZkY/tlZu0Ac2q9RxVKehr78xkHgRPLuuDCR+fhPGD89PwPt3Inf8LZj7+J3o78Egc+tUhLl1KsLcOhXD3JJx0vRq1CYrznshrecKvZeH5pmiAvNMMb49bbNUYOJ1yWgs8iYxEoAhvpsHTO9ynWD+LUduQ5UdmSFoMyAr4bHUqTWuj7qoYqpvBVkNV9p3Nnl0SVFAs4AVwNhQEsc7sIw/JbSQBwHVLWGMTYNif1SBmMBLAFbrGAmtuYIAvJY1SIhNb8SIVf/ecu9AYul1A4na6/rvv6+8xuAJvn77/bfnpQOJSaj3HdcGEubs7sNbYgOuvOO+gcQH4LnwpoHE9TcOJO6H58Y3fmfr/wGoT86x2m66vXugnXfD84039R/r5pv8sY69efuxZs4cOXp4ii2b4DU4SrmTOURkq6jEuFvlUan1hSJ80XwkNeZUXtDzukRuofLYuFXwqzYWcMTCuBo/biRzW9DFQiBG3nqZUUQh9JrRSHTuGIw1LT1qu8AwZ2+FZ+6t/ef4197sz/H9bx3YgQ2SOHjmOo/QLETwnqRiTfMdcgrIQYYg3sFDqUMGfH7L22C9wPPdtuFwC9T58M8OJEbePqBkGIOjiTHiEGulQfX7EPY7fpYo7ZHNk+pSqGi0U2gPTSn7mPvs9l8ZSLi/8t2ftwfeNZB4z7sHEq9/50ACend44jZpbs2/LCP/I9nconl9htg+akkG4uroHwRQ9uA9G8UubmukM63NTyYVTmGzSln41q48aatCJG8QSk35qVJEzEydsnHJ2uWWW61SRlUFpR6MpMoqKPWQrZ2jUb5gu4fNsmYyprIKuQ3f2i53yuER5YqHDk9OCpz/yUl5NnFY2QWVr4qZHrsoIcPODIFuYa4ybKkyNrWEf7G5q7hefIQbo8wsE9YwmnJg8wTKEPaID9f2vXcgsQmP87v94dqL3uPDtU9/cHu49nVYy0d/VeGoviCN9+3aaJQzH7DRaMRpVT4ZF37HMsQkLZvWktoou4I8IRSISLLqn4nuqCy4FFAbSZ9CtFDYGqQPGz79oYHEQ/C85SNw5sMvzuOnPjzwHevaydZIcE7zT6GNvR+Fb/J7A4mbP8ptfe6j35nc3Fugrl9cEo/UhL9UvlTiXT49u7JsTU2glcFDE/jecMqdlnUQgyuwd2HaMYhqlZ51DKa12WucsG6zjlqH94vlVquLrGe3o3rhyW4s15GvTCXrsJQ54LTbZhi+MofRdHqP9N4qJ6xjdKlxglOqdcdb5SC2tV/Tp2SpHgVdR8Ry3cI0K3+GhZxQdHqopqOZ4W2kpGF7W9C8zsEqE55rWZmZmQJZxNyISbSmczP9E8/noyVhJugqPNghCYiA4PUTSFA8OgCKRpnb2IR+/Q4lBvsdTFzIL0xn+5cMDEomRgZF8XGDoo8HYYdGBh8hLolH1ydRdyU4wJgMwUHGZQiMxcwQGZCfuNWolvuPanmrUS1vN6rl7Ua1vN2olrca1XL8qGpwcKED6Ogi1En91ltMhlDHYzIEO+5niPZbpcV1G89ro7t096fi+3U3mBbsaSjtbLZ/ucAAOC3Sd+peTLfx8JJALzrfRmLc1jeS+40wNktwoPFZAmMCEOlniQzNSI0bISYrXx7RIZqpDW852KZKqPdLiJsVM73ftMTnCc5LbB5YBtbpHeSZ37atyAT7eWJnWCVHpviA2y0fUHacD7Q6bgvSx5drTVFdR1M4K91V3gzwyhdovYbeHfTtVGT819HJkc+jU+p9U/p9IJ1hqy8Ukyn6iaKZYr5RfKb57ZuLbgM/U/xGUOmR74QkMXwcC02HnszMJAMR+TP6HUsN9azWZWuM3NVrxKpfDmjWV+lSlaJ5g02l6icpKTbp5zDKPD4+TndANSGrROdDdf2yEngjxpmf0RT7VpHUoIo0cOyxPwBaBZ5XfW5gR/T3Bz63Pa1yP+C9n4bHSS+nBVJK0g2iH1Q2k4VTX3c2PZVuvOgc4WtMeXG5xNZdlJ4tkSZyrBPCYI7J2gB3NmNRft7CqzZsYYl5GOrTIZodQHCtY8v1nnsipJ6CNYZKMkJ+jH5QDOCEUEpdnCIvw4fMQQHxyqmRbhAfNhQp8exQeY6LZMWlGcpJUZGM7aDhHMrIkZGsQWVKNDNkUBYSBkZLMTkRU9AEnbHFgPLoVwyTFEUSLRtHqYS+INVEi6qnTkhPSEoKtyP6TWm6HaduUUy4CU1n0aeGRQIRk/I3JX+nTliodZ9zNvCePzUhS6EwwTKJ2HXRPZVaGI2eR4K9y253HXVcJ6wftqYCnW76pkupg0OyH2gu3lOmppWD0TX0ZgVt029KnDghTX12um1PFPBPVBpKKe/YHgAt5JJEY0g+StPNL/38QOJ34InT1d770EBiEp7MFwEW/CPLHd30jww/PgdltrvveyPkeWCbusf+aSBx4xceed0u5HnnNnWbcG8ndW+n3aTtyZjkPet17ic50I7p7ARODyyK/C5mEWhnCmg6FgXdeha7isEQaW0fx4OElFh828IwDgeevV+J8qIuQBzxoh7yeVEv/cr28F2LipDCtWGhSvHlDFUBQ2pEjitp6NYR7JZGjoqrrXU8ANkFLSumHVLK6kkRHSqvdltNRnJH2mWKyWIwxVg7f+CGgcE9uwdvSIjH9q0HHSiiUBbq/IzKUKvTTeH7kXDEZCoSczhux6037Fava3u1hhmmXRYrXUjGpBGv0NpLZL3DTqHaIoUO6tARHZr0kycP6+ACGt7pK5iolaJsFnycMO47bvy3gcQSPA/858CO7Mcf/eb260pNrQjNrAhPrFA5YUarzmVXGBNnYQTA/Va9DkC4XeuWV+F301mHv93VDoDYE9YwyYd51tjkxAQAaGsSBSri5KXMeiXiAbjTLilPjPLGQ8yDbndqDTSey4IYyrIACVxUoFS35vnCm+2Ng3g/NiEWzx+cRccSGMHccQptKVkuC+/ocqYNH7ZuY3Z7Axm47koH9eMApzRSNoMpJF1IW8qM74WOzsmJgKMro1C31ZUl6HJ6w8YMwSYoYbNfwpWYBPmCoMYmv9xtOEAv9rxL3FAHpYFtQ9lPahuT5xeY+LLLpoFZ0l9ihLJ4TUizNZbRiCWdR1mBDPTCa0NJydVI3XUF72WEk66lC2mN8qHyrFJQ2D8EAF4lADxTxKK29kIZlAg+dzMqeK9F/OSthYSRUmZzXN3FqRUi7ZuQhXa+BiTYdzdxZi+OOSSwKnt4SUbWKFJ165Kx3/eKwcRxeC7dMNiXTrjlun+O7HnU4Lb7/fZvDSRe8qc3JX4Snnvg+eYnb0q8Gn6Lev8RABxGcIS3BU5zkw3ywGBGUcSVYlq8BQgkPMsqNyreiCgACut4kA+F7LqyHlR7wqtyWWC91bksffBlYCGHqpFMcinFqTtUbfRwzxm7TK0Fhkkr7VpL5FFMutKyCuhKFeAmAgIC1gxG2cWR3SnXtG12vDLRklnsVQa6j2BaQzodOqhDPhyc8kNlp+3nTcFbChoBvNGxZoo5a7nmo5DWMGTrQXsK79QXaZhLzLTQVa1yrIa7fli7ZpMmS5hGmSELcbTZ0JStp/FXLoUtddwxoucQKh1reCdEwWUMHM2S4sneXkVE2xN+WFY+Lb3/uLTqy2SZhWBOse2W0V8NfhVyWADjOXF8YoTbc8hAO0pPHkOZ7BoSARh5QpRQcpc+i0dZ1TfJdBr0Tkg2gBen3O05Xd+FkKcx72mOsOQhggYOCepfxONkFA+TS2LL80c4rDggYGsbqxC+12EBH+wg/jmEfw6j2B0eiAW51lBwE2gJRdSyofMaDhPWGsIHdpdDeom44HLs0cpjU+IIKNvImmjgdhjaIEEUFNcASgtezUz04eoaiwulqItR5W1XAi7/C2kn7mZuXCFiNreUtqadNhvKXXWaKPFEOlBkFIq7P8TdQjCWxht5GIqdWTpvlwpzOQCE6rWQPSvRIbfZ6q2sao0DAMby1NXMaGUtWMt40YUcegdS+CfQT2uw5DuKN2SwGJDu5GQ65EiPnDCwshwIYWEl9hyAE0yZeX3BG602ldcL1auqQBpz2SlfZrdVMDHEFfLzetvmXaSzBvX9xqYJsS3vJ7tIy4A4jcvhUd/0h+MbNzTlhv3GBcO5UIJoFOJb8NWhBDmwU7mVmQI/Nx5NMkCp1DPKPMpFAVNXMshwXIemFT64FxwHLZGib+4mjRVUVtjKP5/k/oLhgz28akicru7AOdYsb6ZpIpE8pqkgcSiFMKemM4vJQIz/NgVvk4H0qUD6wcDb4cAbItZJ9vO1SyxI7bYchHMyfAbCZ2R4DsJzMnwcwsdl+ASETZ9gCSM8vYvDTyQtOf73JCNsGeHnGeG8EUa9ot4yeiNfpu+hQJ6tQJ4ttY96TT8fcYvjc2rsttET5W7drjvdMAnh2x5IDCZqewcTHxge3JJ+eDHkQXzizpHt8Ym9+wcTDwHe8UdSx8+BsnfB8wC0dRTSHoS04lJuBr/Lrz94U+J+eP7hQfZ7jriVcsViePTwhaJDTtFrKHi5YsMSZv9TDURFtPwoOkYir1BoSzoZzD88tLraG+U/vZE0bbagspfM6z3Cur1o3X61iLh4pFH69CHv6b4+Gh13fraLc/lLMqXX1iShmMtb0/mFYn4+S6eJlV8qLS6VinamkMvOCKuYmc2WLtj52Vkdxh/IdzZbKMzNQKgwbefP0A9ZzLQWF3MCMRIoUEodhL8nl4rCgq1P2fCX8xUy52yE94uZYrF0upBfOnVaWLm589kCZeQQZ4XO2MULC9McWsjLF/SSRnkpwFnxL/fw7MlMqUTu/SyUBcsWMiW0QWkVs4WzqKpRKGQXSlDj9LT/gr2bzxdLNBwOYBfZHKV1lovOZpbmSzTEyUn+mYCShUwua88U8osC/Rcuzi2coq4Vx2H4kzZMqwynOFwoFudw+DKUmZnm1uW8YxANz/HbXB7jeagcnMkuzGFKLrOAHuXV1+ApllMAwyqW8jmcnswcOpono6SUJTN/LnOhSNOfXUDrdsKaz0+fmcmfW4Dy+cJ01vYnspSFBv1X3dZcDjo3lylBHFcC/YGDO1soGj5l8IzQDlAhbDCV8a1XrVLoJMkbsTEffGD193z8DMIKLtFL4cC0QvQwqenUWytGRAfRVo+qYK5steO6SSHtrFEjqxtoZq3ff0lByp198ybFmj50G2ct+SI9SMCRtNbxvJq01yG7Layh1RqgTUgguho3TVsXBTqebECoo0Tq2yqwKQMwklUYlbNuDFxgED0peeloL5OINBL0GYbdyHqFeCM5gscsmnpGU3doINQKB/ZZpOEGxTtu2SXWQ6XletqZ1brlOVVX1shickDGjqPJEjSpaH4Z2SuB12xDq2haRPe96pL8bWR+Yb5YwXCLb5QklNVTrkcUCorrgH88NvmfFBV3ubdShxmvs7ijv5rS+DUqgrE3/Iboqg/WG6sBEhqNMNhCe+VXWk1auIBP1laa8gJQWtgyuslaeTg5Ioki3R10b8V0hEjO5ZbQfmeXlAKrgXfZv4oYOw//H2EwjVQaTgPAFgDnhfNCRfApNc65sLEuUsnVUab+pIl2+H0B4WTCoCbouFmtrayOWvVao+brBbETXFwYDTJdCiTHyHikJHx5o2A0f2F6qIdamxxAbF5GZc5zYOYO/gUAQcKDZeUGyDiMXGKAUyyijZhfjwV2MsC+OC7rxsFai/8SZxUONAV79OW8lk8eVTgzeXChlkwnLDStZjyb35dlCtlphH24XchgL8BoAK1jAFstCVsN/jfymbVkTK055tSI1iZ2w/DkiKxULBZyVvFCcW6GQtO5RQjtsJKUroSEMcf0NTPQOeUG4xuSRPI9y8DGBry7UieeJUwVvEe/g1Cbyuds+B7WtB017YmONWXh6wRmF76wdgFBTq83+KcuFRnzFnO7YTR1JUEKkYqBJr8IxOCBMpdfAISgmMuUpk+PWovz2Uwxay0tnipkZrJWMT9bQqvS+2QVZEIAwD0jtrRVh70RheEFNPD1pg0uw1FrtphmWEkkaS4zt0A0ac9/JYqVXM5K5U0fS661RE3dT2OI7PBjAD3SA9ni37F9DHDfyWcBvlzaGld+aJxx5Sde2B5Xfrg4mFBcTDppK8K81lHz0Gx1ytqynyKvCQdksC5IoAKvYn3uIwxBxVroZRA1zlmyu1W19HKjqwzKZ6FugBHJ3UHHrV1H2jBGjWJkl+N3U7sVqzbcYvPHoukk8pQyj3FPrO6qE7ipJi5iTbtuRnPfyEuSG2GMpUeItSS/T9d3RGi4IDRqHGPv42PlzTKqxQOcJQeWK06taerg6iVVq5JSBpAd+9FVD+mTr68aho27DKO1pT+DFMFBq0mSy0qQLXfZ2cCnMBLIGOy0/004g7w0kO2iOWRkeTpdFPWnkfbaKx1oDNASUyp2jD4VwnrN2dY+CiMWIIYPTUCBQxMTeA4IPpJQBcG4VpAaTvK80nmaMR59OIcEe5vB4dJxbs0DgjkvitkSoMAnl06Zq8uPRDIJXSF2NuyK15A/9uTEMgxJvUzKF0QX8LfdbgiN85DlC5g+lGsBEFZDtsym9lo4KhEAYu5jtorbhqJO0Gq1eQMaFHQwGU6GletOQ3KXdsa9qW/Pvun5vKFY9s2qyb9Z7RmsFEDoWkAWtzri5oup5zHQpKMBX2++eFokk8mLaPKB7q301zm2cGI/GwVBV9l8dIxbp4G+Pka41Qny7ekSl8ejDw+L3JJN8d69lDRvlsOboem6FU+vPr4qgM+ZGsW/G8gbw98jAuPwz4ZvvFQ7UUGflP3KeZtAiTeYby5NtREqpzDmNNCLpaVMKV8oWufm5uetk1lrfu5sFt2lnJ6b32ctFvLT2ezMcyXPbv/mfn99j/KtBgCfjnXZ3TRYeNI92j4rczJfKGVnoO7SafSXNn0aTUYUx+PaR0cKC/lzgfZFNBmpNpk8LnC1TyLHRhAxaq1NalYvpKTMlJTm9cKWt5nIEkisKoLLTCZWNqbh6tNerbyuXW30bFo4+q11mb4i8ljjL/JD8hOGHoVcKBiU643Q5xNsHICBBiYS8JLXAqS5ANgxWWqWhxfVrsCQ+YL6Gcn9BmDFRD+kZ0+9pNSLMUfSoK2cFawvMBFqPHIu9rMYqbvR7TgSmR1bS5EU6YGqd6BRK3daXoUT+kRTbEfef2maF+eYqRWpipqUZyGKLQ0BxGTgETz1SOJIJUqTEhpC8LtQ/obMguhUaEwetd5ms2y4QGY8Wh3tXu2KKyo1lUTglrAEJb5J6oQA4dC9s0yvsPcJ1Q+C9RcJC7hkAexzPBeH1GwZCAThDSFQjG4rPYlzyGyIVg95vn/hg2Fnzj67cNaUIegisjPG3DdsykQXlHdU6ian9gx/nDE55egYwNF4NK6KN9COvrYI4DLBQ9tUAwq5IJkmRER7olZ1Mutla4LKZqxYSobJkg15E0KLBWdez2dkDTpEXSu04oTFhleadLGAN1S4VOSyGpWry7+Xnnv+YOIMPOJR/23v025+3BOPPPfw5DNufdZYe/2HN+uXl93T+dlMqXjHpb/9x3/54jf/898e/svP/vkDH/nwH97/2ms/9cZXvuJHX/oL7/q5t/76r/3mB37/dz/2ib/66z/75PX/+MrXPvcPD/3Te3/l/b/9P3/p7T/7mpe/6Md+4iff8qb91sj4c44dSn3/k2/63oHBG5PnFi88/8x89mRr1al63buv3PPql/3I61/35v/+7t/4nfe98xff9j++8V9f//KDf//PX/rg7/3xH3zmf3/qT2E6fqjXuevq7Wft87nnTc885fue9Ng9ux/9PfueeWD4eHrq4MLcD5wqLP3gxbU7N174gkalfOLoxG1PHxp99g27Eo956i1PePwvv+Nnfv5X3/O/fusN99730z/+qpe8+G8+/Sd/8aGP/tHHP/93X/jX//Otf/+qgWN2UK+zcgDXHSGRE0lxHP6xyaVJK61mm3grmCLzpZKMYtus1AmkiN3daBr62ve7g4nXVwcT74Bn8/Jg4oMvGEw0VgaJDkGBGPp/W6PlClwTAJemz/jKUioM4t7tAe6BMpscRPlblpIOab1rO6edlWWS/NV9fUcdaCF4HuwM7kiueSf6fO9tDiZgWRZOnbSk7DgbQunjvNOrtKc2Hpk6NY2FyonizOLUeQCfnk8BsxF6qL6QyY0otDfUSlTzWvFKGAIQZkksSBlhyIJfWIfvCc93Uxf7gxuDiVugzqfA8wCEI7a6K8pfr/ZtS5bL8FpDkhWnzxHOh/wvZCEC4iWlo8LeddEmTVL5m1TerCmCDL1VAUp1RyS3dBQ5pex5nFrR6893OO1b8jOtoU8IrzohTYFSSIlrIe87jfeRyIohP+3W9OwpYhDMFRdnAhF5iCD/WOQdHWMypVKhzzKCRna0eAJ2QwNCUGk2LKqZVa5/sK8hZ6I9jrCWkm8NO2fQ3hnImfxMdtZCv8FCGQNS3TXX0fG7BxMvheeLP9qfX/Gqq4N6Hd3yku35Fc5dg2jbYXioAodxBajIiAlYydDhLVSd3NgQ9Fd9qcntbLZSlh1NtPr3xZdBv18+mPj0K/vDmLGX+eMcefX247z0Y4MJ5B7xJRIQq+QnKoSk9EgRgr7APlpFkM86mVmagUXMa15FTucXZmll69sVkg1TxLaEAbJ6xRtEphxLjVtAgCGYiUEAvKbTrnSclVbT7pQRh43GED4QibXR2XVUtHWn3i6UvDTpFysLi5KPojC4SJuGRU2RunqPeOjTq+sI8NSX/POf/utfePKTfvG1097+r71/9aF//5s/3ftfn3/a017ymS88+o0j+xc+IsRj2Kjsz793/XfWfvKJ4qtXhXjmE37qvtdA3Asmv/c1r9zzBvGP733u4QNc37uqP/UnRy79eN16f+npv3z1ocH5HznS/bGHPv5/zn38r5/y9+O3fHbphgc/vuvDjV94z4HTL36hWHnTr/6B+C7/e1vt2q1v4OAdq0v2j77v9sQfTf7iKNCI0ckJ2/yL5gh74onLoFBkr1OdSAn6K/ceBbfee5jlEe29pTcPJt4Nz/0/03/vXXqTv/fe87Pb773NNxKMYQF05TFVQhSnUp4Q8MeW4umIKuG9Bd7J2kh/L2Tni9hZvAfxGoBIp2sElpjCQnNOGjfJvHsw4cBz72/0h4/eu/2+H313tO+59wwm3grxqu9EkgRQeJxDvE2Tcst8sWbIMBCaZVmiTdJ7gD+KUn4hiyDHzsxnCjl1kG5KGYNyt46yZkN1PmODmTl676PF7sE9j8LKFGs+N1tKHZyYP2LlDzr5Q5Vy5Hd+8nClzP+J3MlSamLCOYL/LTqOs0jFJyZcjNFhV4fKR9Qjcgul2w7NT+ZTp6CWhdIkVkOh1KFDXGH//6i+Q4fmD2YymfnJ2Vv1+7Fjx05mFtXr5GFnhf9TMUcqlcqtlVtdt1rVZVaqt1ZdiMUI2QsKzB88cerWw5lbD5+89aCQWkfoZreGjgRE0+0BaV8XHopkLzvI8QPiHwMrbc8GwE2Ln+89bYm8o9KPU17tdV3YZ3U4s13hXq7qzMtOp+W/uG5brLYaaFmma57V74c1eD88b//tre8WLvymvFv4ne33UfxaLLWabgYvzNWK9CPMdWmI80k/fvyzI+0OeUig+CZVrMzPdsjs7SgGHHlxgFfTyuiyxCWs/Qf2x3t16jpt2/XKgH7URsJaZIDAscsmZOzL47dbhiSn29Uq15wICVyRjR2NOVRlsvqlA1Ti+aoLfGbCyaf5ESlrrGkdmxw7ckJI2zt+XmglEofnZ8C/lR4mugcdjypCyM6g61eScUGeS1eyW5BQJyaG2KX+GxzYvedRCEjZJhky8ZQsrbyHCFwp99ATtRIhZeO4AGbI/ulkXXqdlF0w6P7PfAzoij8cTNz+icEd6Z+8dQfrtpJuptUXihyKKj5sKMyPhgNQ/OPIJwrvueu//4/pV73gazd99si7Tv+Y862n/unUo7/09I9e+O32tfc//7Xr//w9Hxq65f8c/FT+F6ov+t6vPPcvZ97W+PFfXXrz1b991MfGX9/5Xxd/3/qXvZN//uTr5Zc8753pzzz+31dfk/m5n9p87+IfPfvB3aMf3/P3P/zGc7/y8tZbZ//38a8+4cWVX8w9cPg/vn//7/63L/Ze94O/df+z/mHgpzd+4/baq3/g55/z1497ePmlZ35p4i+e8l+/t+9fEz/pfeCO7k9c+s1nfvAxX/iT277xfT/q/s/5vzr2b0+8p/kzp15439l3j/3h4OfO/86db0g+dOtHvnnzn6V+ee5lP/T1x/7N0beffOXl4q9fecuuzw//8d/d8AcHfq30pruzP1t/xZO+fOLTC+9Y+ZGn/eehT/7TjR9+xvvse9f+/86FgUUvLWMz3al8kBCnK3jTje7AVomPuOxa2hsYr3a34xDJCTAyW8iQ78aC6HakCS0MbIlN+eV3hFJpvORbnxxMZD81mPjgX/THqfZ+0sdL3v+X2++pt/zJoPYt0delxBqMOnAItB2P5J9waMgSDRNAzKFSyH8UjvbqDpEyOsCkCJcil7uKeUvnjROq0DgfX/TpwcSD8Lh/szM4sxM+UpzEOl42MT+HYO5F7omNRtsvsYvaUQv1dyyfD50SEX91zCYqk534glNxOkJNgNXBV2ZmZ1y8G2w2HYEiTdrjxxAzDFCqKRwXUDjga9zgeWyMA/Uktx/FN6/flHjf7ickdonHsb4Pixoxk5LE6X0mO/KsGngP6l/Peft8RSuSz6JbwaGakDhDVDdVZZeSKip/7HFv5gkd+dJLN4mE1axhPggDOZiBJKug0qRygvuPI9OsXQF4yAbOHJnAJy/NgDU7G7A5h9d4tOb9otbNUXoviONgZkeqq1A1+DldZJx6AhVQrpL6ydVNZ906RhlOULSACMFN9LH6HkIBgplN2DHXpAEtQN9FXo6OXmSC1D63hgv5uZFI5HRuxs7llxZKI5qu++AXBxO7/mkwsec/gBaD3wfgycGj/VJB+uNl+lH4vedLg4kXwa+sujBtDaPOQNOto7AkDPb4UG3UonmgEAz9OH4T9e+Wf4F6/oXry8Hv6+G5E57ev+o68fPp/JNfHky8Cp6j8GzCMwVP78uDEd9690Oc8p+nJkaOW+d56cOAd8ODed8Pv+/+2qDOm1k6r/N9BuK/9TXOd9PXYU7gYR05VHGam+f9kjEYzYDhSWvKSAVM4LUXBvhmm6+b8EZJeiG/s7nKF3tOpxV0QIbEgr5TDuK9zEQ+YLEhSVbh8HndBOmxWSQ7q9Khi2xOnzeNgT2JD8BzCea+sWtPYgl+6ZKPFEFYKsVpoodudJ6Ld31DR8YPI+vWXSOcU8ulWoaMqh9OJqG26cz83MlCpoTCYei9vphZyO6Dk5ZM3ywi6Tqfz8yg2GFFiSZWtGhiRYkmVkgkkQIkowjxizaUzqA+EtnuV7POBtnVG9rbVWGaXvViFUsZFKgmrjAKlWNgZqFYohsRPii9dVy2DLNvZRM18EPfIW35sq77RIZMZZ9CE8Y5oE5PQkNiRoqh4EzqKgE8L+OlLEr4kDMXlHAIaPc6lQozxAlfx48qOwN1SBVdMuONFBgcnx7DWISd5gJBVrmyFz83QxdO5PNCnSo1OU3fjZpoWr8bFcFKIQcNQz07u2C+nUfFBuP9Quj9jtD7+eI0fluzRCTmDo6RSmmZxcX5C7h6YZYhnrjwNNVUJDONMrFzM8aL7CC/6P7x64Xg6x3BV6NzMns4QnaNvxDF5zKn/Db5RbfJrxeCr3cEX402ZfZwxB3hiEK+RJsHDk9tidmaNj4wbCGcobSS4SPtbMviy3vjO9foOwPmUSsHvjZ7TggVx7UUjCIwgd+MrEBnCGRkGGZYY9ZSET/aTJaUPYqcmVyA7Dj3yczOqi5N26cA+MAikKHzUzaAHvWSMl8mzZcJ46U4PW+8lQrZWR1G0KfDAPMgnNHtZcz2MmZ7GbO9jNleJtBexmgvY7SXMdo7qdvD0PlDOnRQh6Z0KKVDkzo0oULQrgqqRk8ajZ5UjXargADXJFXF4a0JK8rziPjUI7N7EnfC87Eze/rSD5nsHt/X5fye7e1kyJuSgCgsMbRa2rwrWhNQAojLtS6J0fWapJyLnZ6dzxRPW8N0BkgZIBgOoBOYQ+IQLup5w8bpipO+2Mgy5MHmhFk39kF7ZUfc1iMtg1oH8G6ZT+pVaDU21RmJnZu1IdIReu/6ag3P8YUUWblDyFsfLaImJW+0rl6aOX6koAB0CqD0JPnFogXEmsLjNHDLphmXvnIQnoZqvqVUTFCkhW+Xag20GyFPUJJJ7Dj0sXzRG5ZDQgrAEMehclKuhy+zna6UiBdk3wuJWCioBHMCeTaOSKkfmSkozszyNUqomUm5UWsmT+gQyweZgkGS1sPDtA44RGh6maKhSxCmKilrCGXUDmkjKawpH4lmDMqtV5n+41NxnzVNwtuI/C13JNCXvViRa4ILIioqJCKats7D17SOAqJoXdChO1RIUGY0yr51NvbH5LcsbQOoHubPCD59knvlWVOrpPfCtzi/d9gsVTNtdKCNAswyktwr75iIoN5L6jHJvbSKgjHkQwXfKm1PYZbfxizJkjRN0oPVViOTJ+P/o6GdYiT52xgWlaNBkefkrYYEGf7fDcgRvXzhpNXuLSvDj15wyS8zlN0uW6+pMpYAZB9DKJaG3p3w5erxvnGzLQXPkX/QqvK9wF24OkfpQ47C2O+uiZMEbiUyz+iQ0TLaCPH8wROEX+Lm+5eR/aOjRpEsJmDQYCKmdv5EATAi7XX4w5QWO4zqjdalFZD4isP5ZN1GTYaMC5vv6FcVJy66HVgbDT1MWFtjtLaGqblODT9Gs9oaEbN81ljoeixs6YwqJQBKuVDMNa1t+CV9MQzJLu2SjXy8RqoB1eZ6ATaU10Xh+Wgekph0uzbZ+CDVQoESHyhxrXzNoYJfIKKSLqcbaTgGV9NIsysGCgRaMGAqLy/5sShqPiCJTtWgSDeJo5NaaAZ63u1VXH3cS2US8pY+bi3SLSXg1+R+GRkJq6g0RrpFkE0WqrsdL53c2yjbMCzbr6nVTu6trkcjRTJTKmUXkMIftdrcBHzZ1hrhQ9XaBkqztl2qF7ZVledNshwNALAvmcyh7TDsXHIvmt9DrSHElsjLLR70ZOoL9Xzcip9DaljC7KBF0eHuOo4LecyoTHfZGwnWZQySqiTPrlBdcqZFjibXnWbXv3sz4VOztZ62Nuky87lJgZ59zVRTQzGchmLDeCOhXDdLq0ThbKRm4Ep7KyyAdCpbsqeRQye5e55UdEieVmvI46vAZHKa/WwDDYVWIjexu7SBVmtdC75OtmA51S6tHTmhJJgIe4rsKpEjTrMzgCS2k2ZXpCzUKC9q4v/Ej1PMy/Wuu3Zad4FUrJTb5kD1rEevh6m0cyNt6MLKdlNU/VG1z45k0QGoJ/R8mZEe16D3G/K/V4kZ3Ehbk6mpg9bwJPRkBbrfdjsq36g1eZzma0R1QVewVnMQZ6a9P+yujMMRNjtqTY2YdqZUZgM4Tddhn1uzpM0531ohNh2aaVTvxLInkLVAOr3zbLYahe5It1zdZ0kzLEbRFVdxGsfQAWsNBfSq3oHl5c7BMHD0myMweXHIu6Q7YupF+fkqLqtuwo7gjLLqifiqpSg8aVRF2vDvkFi5B+2IHUChOdJxteutleDbeBmtAK1KPWfPWXOTAZ0LMXTBHmoA9WsPnbaHcvZQUXDZIW8cVWSKzhq5jAgOGkUEZvAc9+KS9QCnRAZgBt/rQOtLmIH0+aVyF0WsuoTOK5XpaWnghAqy5hXp/qvywwD4FS+37la7MCewUjrkcNsfebvuSDWS4RFfq642St66iz3ANzyv2kNshBvij4ANJGG+uKVuS/Wi2zI/ro6UHYJzMhlQc7ak3v8WC9WzMrhrg+UAMPZfXHOF20mjLVBiDIVHos2oDOfoiieczggrcwU67n68mgEUDulxhEr+JIoZOI76JkJ3Ow1xiiwPo39mPwmOFrS6oCS8y0ArrqJ+HEAMqZCWHhGndW7UTkxbE8crtbUanMjLmxYaJzue8Ty0jAWbUvk3Oj4xIiauTgoeVVyncMzm4pYruTbe3ZAYEPWamcuVFor+kOmvEcF10cKkjpp70O2McoDH4LuK5kx4nPabJbp4Y81Yh0uTimAZL+ykIT9JKI9IU3PRxkWRJ40rzJfJfzxCKxYFJ3/baZxO/tAywp8+yV+wJEMkPUSaLOhTmHA6ZR4QBV1ljbPnLADlY6vw3Tjmeb0mevRJTUweFdbJXg1Qf6S9pci2R3kmD6WnjqYnDwvkSNQBIeuqrL0OXQNYSYA1Y0ONsaHK2NDp9FAuDbCGFvjYGFdirNSxsSS7he302oC5tIW12GnhpiXVUGlhKM1XDsx9gH53JtJSN78zqUJWJ+UHp/zgQT94SJc6rEO3pf1aj+jYo379RlOTftBvy2urYL2jQu2yX+tG29Px6OMZUHP1KjEvP6+74UoNax0HB7lXo0UkUCasxm47+U4Z56fVxGtsZD61WyTFBB/cpTmm2KQ4BpMuLJK7Wm51u62GMM0abOAXpXNQ6DJAlwoLS5ArOd05HKnlx/AKknWmzWxERJgF0fc7eZ2jd9LWhQ9NJjGZHm4ThtYUJbSCj9cPLTNcrcotg28wfS307Q7kI97YYtQC6+UKwm7Fgt61jO0SjUVBImHwNpBkGa82Aalx6ldRwFFwmAwp1pq9Vs+rI7MKph3rh/30TESoxDLKNKy6ogQINVYhW2Dl+lWXDfiT5F6VbJo0y2QMdBIIvRJhUWiJxlRD98gXw6Zk8ClAAVjvmusb/HQ30Ns2cQJYozQt0DZ8BwBz5SoqIl0lxaSrmy5Wf7Xd6wDJcdXBWbha3nSaV9dX0Y7DudVaeZXGQ1YweOURBB61UqNoFd6Hv9CZEbGoZrqcrqebaS/dTgtsTlBzgpsT3Jyg5gQ2R5Mr2FB9V/m7kB8YWYGITQSl45PylY0zkq0vj3E0mUAmLtgGGAE2TPEpTz/V06qReRP9ZcQzbDqa7XL6tQbofAyeEHz+az0ApWHS8Q0WxPXC5NpK3IaiFa2j+OEh4holX6ThHRWFJC5EE2Wh6UOS6EQhGM8tk60Uif6PKs1WQQQcBgKkis32sQzLaHAYta/CyNyr3p09p0P2Pk1qYFSbUMWmjkFPULIerYZC9Anr4rGGs0Exl/wreRKXlEZqsX6r16a7zh4arcW9t09Ppy86I6iUTflDgh9JgR2UdAl6tMADFdFG5hPgpCENIy2QM2sE5YUikVQ5jUcZl13psCkjYh1MCCnoWTGd3SeFmg7ZHO6BIgn/QGa0ztIlm7QkAVMrK6qLmRw5qhB9exBbZgIW/22jtM+lvV5ZzK3AXkMSnvOQ6e9iFxEyyMrzKea6EvnSUT7DgPhW8pOzyI6maklnX9S4sMhKxj/uOAzjVXy9p3g9jW5l7AQL1RvGKYKUzoqLEhudTcK3yVxIZ51+cqUZK2pYX8yS47BTshQaqyf+nDohyGlpD08IumaIRjcpnsuk/eiF1jiunm6NWJSsh2lZiypGsbF6FrEYyT4hj3IE85Xypcy8VZy7I0t5ztROJvmaAyFesysFIojE7DSYr5hTsl6ySc19I1SeZsCMGWOJK4qnifaLwpqhs0BDd19UXM0phdfZwQJ+2/3Uuf2Aa64hA1DeoaHYoNpAaeGPHcGSJyEeIsjdik35vBG2HiERc2UqSS5FwE0RJ6+IY7qnNtY0ids8GJUiDyKXhLLbQZaEUNHX1K+OuFTQdYTpIJ0A9DjbZj2gKtGrjLwd8ZRgc13frK1szHNdfXHXQFK5rbXN13UFMBUaupD4WMDsibxe89o11KGlzMoUQUXZnqE7Swg75dV4MT0sJXUJQjL5sKAY9ZgNS0gWMrlSIb9Alhgt3EdKJkDIbyenR9pQkyTxcdy5zO32MCxdrHQrFIUq/N26bfQsaOVoubwK2W199RlMDa4b/brubBKK6QnpXR6NRRNSEfBQAGcRACn/yO12NzPTOYBpKE9E9oVZ/ddUDPTM6CSuZm3zxDCodEzZRDkQME1ARm+GKidI+6Th55fiNBUXbeIJGcARlul/D2juyuhQ5ZKVtsSzYF80lltSBoksBvI9JR7fLTxrnQ4M1Ot2yGA4/PbKXdUywRtr6ErvRNLvo+oVREk3om6XbUcZFl3qWCR+tOOCOgl9QzIQ9WUBQx87AYtynV6SKv7g+MGqkXKQDC9uM1VJIDVxuFD9hnWc8PNR69kQQrYRBJ+FkU16SYokbjT/sLbIocIoRmK58STfx5JNIfNGttbARumaHJGySDrWLgByyEywhiJZaGaoTzE1S5zARw38edXWwJmDJbxVQvGjMs7jyRK5sOB2YBGSwIu9kMllrSnrIjZ6af/2JfFmGjnnZun9QuIX2xdXiEiwOGHDdrPF8q60fG2ccLwP4cWsgfYsLXeujIl+udprye1bJzE0v+n9Yr7lyMokPi0VlIbRTg2fbEQfzGqtpWEySxQ8UVYACjZHxBx9q5jqkN/oqnjCojiW2cLmFww3dKzTanVPHHBddNx8wFiYwZbRe4+xJiRqTbG0yZHrvKKWjYeNYLblTTmP3B7gsZUyclwkKJCQYdRC8AZHqf2sEaIb0EYUIYZ+gzQmxgT9HU614qHOeCWfDnToOg06XQG7pqQTYq6qP/CoVXfVXQ2z2sgaAIyX+1ozoeS0XIyOTJSaZFTrOAqsUQXsRQLZoyxo46JPkS07Khf5t1m/7mgA68Yh8RQxge8vB7kA0OeDtAuDWLdjglCv7+eBbwJEc71XYfxFhlNAp/RphvmEl2FJoVVLO7NUypNhTJoBFYOa63OnjHXFEsa83njHiTn8m0YsjZy3wDhPHAfa4hilnuCyuIn7VkA5ePcis5HzCX9JyrWi/FXwJSVxDz2Jvp6GbrPrLmm20VqFQ55Yj5zDo1JtxldJ+FDVwDvI4E5Qz8T1L/3Jo4R4+eOFsBaEWPwwPCQXSPCahAPJhrURSTAMhXlm80sLM+IkZCGHMujSQppdn6HrLPXGXSeGZ1OhAj15v4XzELglQjNX1qyygEmi5mT6iqw+ENsIS7HN2lbzKv5wmZKL7HquNVi+K1O4Dt/FB5KRZLeXnFcU9MU9kGpwROabLhwtsHqIzlpH5w6HJnBZHZyYQLOCfj0y52TqkDXM1/+eojMBM2pxKgEQ3S99NUfRM8o2bzA6Byheo9cIxzobMbGSJxKkWHl7w+cHeLL/zv3KSwP9dDv1MQi30Z4FnDLIrztEt6ASkNNQgVwdEhQZomuUiVKyeiZ7T8bQak32Fb8hyRumdKR4nnQixjeqwr+eJHxykmjjYDMdaeNMziEGd9CyMs7GPaDu70dJ8xqTVvVN3R8E0YZjF32xSWBPCrh0A8w97c4+chkKhwu7LOGbUGa9jRNZtp/EGdAdEkshABSgrEwueq6JgAV4hn5rZ93OMt6ayi2VxfsH6uWk6WhowlLGaUQlveaW0ysoaNFOd6R6hrKjInFR5nugCIcchc0j4GWFG1uLdpzNzNMHO8tnntwvYlorv4T4UUuLM5lS1kbjLagi40o/Oizi7wDpsjkSKlHMzmenAwVDggEYdaqQX1oEin9EEOvMlB7Bs1ZF+ktLo1G+MJfJjJP9J9JBspukSdFQ7eF6oow9yzSdQs04G7HNMAOLm3E2dH81CAy3oKvhFhRpHjTojV//ittpjRp2lSsGWDE7FjYFzhow0DWzAPVPRWzbyVCV/lzgVtWl4z6GNnYcM1VVA1ymTcvI0f7gYmU9OblS/YVDfVEujSSMG/dty+cMpuaya9XR+F+tafiCZKOZaCXTtI+JAifjogiVyXaHNcQcGiHPMExEEaNU7ju+hguuailyv8W675+y7ZbRXhdwBYTalY4cYpJycwtxsZnzMbGoukTRZfXdemkeuLCGHUSd8Uhe096jUHpR6LuIYKz/dVHX3197ZPN6VDHLOYwbR4bRVQG8HBpPVUcENk9WA5K6R8oPVdpfLYAEWYpTfZGxiEtKOUbLfyusA4nMUFrXwDX0IoVsBb7yBXSnZUhbi5Jz2T0gjWZINkqvS3JoJPE4TCojzPcawYvXy1dZXF0EpNaZPg6aRaYoKWuJfAqsyXXKq8R+O8A2vv07sw6Q/WLGRL3I+zK5URPTeOBUyfoh85ipHpbJ9O+ONNOEW+kBLbYMx0sl7WmVV4VhBgRUlgFZXW04ncvjXdgO0/4NkU7QBP1sVC5eXomy/OcSC7j7g0b39cwsHCXrjceHato7VpGu6pBRJsUoisiow6sqfuXD0rIQ/xlK1UjnL1WvWmdOHuBlJhVs5SV5jRwMHB+6TWcaGeVJk4lQVWZtxbKsQE2CRTbpGono0xayAJOl/OLcdFpL9Gl1IbSLhsbi2QAs6+XZ2mEfQxHfOiy/I8TpAHAN59PxvpoRxKqmy+0edSrSNsZqTx9Iv0p9cRmjytMmIvW3UHkU9gHUxSZTd5KfBd/B9tw7OULVoJU4I1WgewmyX63NDdoN29Nd6HZ67k5Sek0m4UOZIN3u+spedhngQq3npxOZUnHZw2dw0GgjB+Vto11WOehEsDvlaA66zIapadvoSsxG9x2kD1LHyw+FhRHJxjcfaLKXJ6xTtg0A6VFEveV1Ay82OUEJVFBmJ6mxKe12Q8bXScaOE7j3XqvXKUs7mADQ/Q9WKdsdlxg/kdGpAeBX1y9SgFJXQFaS7TVEnreYHvoUNCuqHBqy6dcwpgE1W2l1uMP4TlvbGC+Vbzd4NqlAq941FzXGyXUaiDOWSSAeTgPimcdG2mzwUbYrDQf6EdKlhB+hzJKGBqzvq2IGHBpbmSVioVaWxTKrupMY9zB9d8aAGeJ7wweCQJ1soAamXTrfRJ2HSFG2VLni6Bmoeba7QYd+PQhoyLo038JGauELYhbICnZbLhV5TRuFD0FQAtBNi2pHARrufxaOIr87dbVUoF2bRT2CbddbK7a0RxgzZ+gzCYiYYBFpxtBmz099YANsO0MCd2vwoGyFmtABaS3es5VOq20ugtAXI03lSAtE8JsrGZA0EqKPgDlVTc2J6Si7W9Zl2Mly8PWK3wQqhhi5+X0z9O7nh7Vm5Ma3zcDblWBDG9THUF9i4q4E42Sv4iI34yJDxamT0ajNaFSoYGh+SfWrz87qOBU7WrDrlr2+gEF9zmI78oVtdRDqlGq9trLaXXS6qxm012GUCaWYxyYdq2b16qSNVK9SZmCvrBEZEFPMT/QPcDywsk23s7KZRSDuA1iKm6l5rH8CoC6YbhRE9sR2haN5uqudVrdblw7BdTQZ9AjF6a8BW9bme9vo1+B4uxk5zHoIXqAnLjLOw6VI3F4BH1k3b3GPJc9C0H3NXa2VodOdVi0GujKKJjGvHhqF6wDh7b+rWlD0oOywn/Y4iEerlcBRL9nX2buar3iH74FNG3a8Hti9WyRe6ZcYdMxuN/xTKcahu5wL/Hjks13iY+gM3WadVGkC3EebzIxIX7V68qtQt4JYAsyYdOQeC5tZLTLmSOMx2ZWuWjBXogNl2ADIbEpHmSZL8H1Doh9Q56YfvOIHTdRXR+pOkhiJTapH0U5KtOnQWXtNtyfjps5OmZFTa1P6CIOh9LxlhaS4Mmq5UytfDucxXslVjBnBHrttaDw/zTGrNeqnGaVR1W4XBuEB3lF22lsdtoZTB5r0Ow10lXm/Nu+amNnwj6a1DQMT7NrQZrA7ZBCTbXDGkUyb9BlkVThiGwA3Y1H8ugpl+R0oK1hcNlYYRLPWASmykfRtBOxzqSYwmWF1E9DoVd2cH+86XtfoRadGWymYW0cHMpeA6gLave75hK3228u8wehZhdG0I+2GxL7aJNqvyFSS5wH6BSsIjByJf2SgcCSxakLUUa1Jli8NXSq7Id2Tw7JqVbtkFDM4e1KXrO/ZKld5dN3ro89IUhSvE4nRmf0kAFqo/rJCSKo/0x0XrVebG1vqk6saEalXGCA7KtS7C4fJ+1hTch7OL8v98mxLe63BZVoGgNdxbOX9eysarVtWOyYEfI0ReL16NwheZANwDK+sxAGYEHPB5jrioKWE9AYODKcawubyqiuJA4zwiTqZg/CE8BTgQpLitnL6ug6eXqGFxZiRbbAA5YLDqa607Bf0YGak/IGRImPsGl8iE51tljA/tXlewD6uwzGC51211X+u0LEgf+34fIj2S1967IWQM0tKMYCaKGyi3y5oOmsmtSqtBBsxq7W6+RpsqkdEImBZDmy0dT3zELfWbUmiEUN2dd0GYA/7ndhGXWdZ7+suHIAMRI0tHYwHkFFd15wR5rIEuSXM5JDle8ywsiX1prIF42x5ky4p7uZKrekq48gSOMkFG4hsNZdbTkdTprY0jWX7X6TXP5PPtNsi06oLB8Vq6OhToLdS68RyWpp838KlVNjfonzxCMcqfcgYrBIWaxzPgin2y+5mP6rdhx6NEMGtETep9R6DyTajAAbF1CORCtJGE1rq8NJRhn3QEPvlcjVl6+7G0cBtzzZxiDpDHBOPjksPjTMuiyapYtLYP5PGI7bI4kj1+LgsmpfptqpIUPQFsjrDWq2FMicSpulop+zPHCE4yhRP8GjFuao10W2uTXqgMfyZ0PSr1d6XxRxCqWHJLteacWgGoecd5GdzMIhl9yR970qDhRKxDkVGygBh33S7MhU5YGwBHXaizWLban1RNKLbyGIumyxmTUE63mWblLP6AG9OQ4fhwSkyiEgblcT6TpEC6UrCLHo8oADCpE+/4Wsq+DoVfD0YfD0UfD0cfL3N2IDS3YZJidIBEYhCebRW0z+zCYMJZJRRoYxSyd/YzSjM0ocnqWGkdHweAyS1S/QAggQUQU1iJvHsaK9TlsNZRYk4mzwCGhQnHE8NFu6xKy5gkFFWTXzyKgCrKwD9YR3GZwjArlqz2VqTll6iuCwQ6EgbUSZYvcioUuFVFjFQ72E+TzB62YVDMhhFkE9X5qzUQ+mBtuGg6Jjty/dAHzguth+BJL8vgWi/P6py3adAPv7aiEeUUZ+QbxAgOzof0ePxX2RlPrueyK5Wpy/mROclHrPy6PRBwVptGa9Img4gD2TjgOEpHexmjPQSYkb5RxrWjHCWxG0ICQnmY6wBUR4znqkRm5WsjXj8QLTekFnRgynxCV1MWnM73WiKv+RUL/wK8QvTNQCRY4HFEBONbcREr65046IBhMbmxu8cE0/rJCbea9WJMSi/YHjmba9e8xmYgMBBhq6tDKQaR1e1usOzSwt+2dpXQfgitddohHhIeHGnyzXiOBsscixJDUUzMpY3oQI2yVOoMMpThE9UGCATOzGUO3HEa01YVB5qmTTLm3hu2iGOezBDkJvNG95MX3H68chZDSB2Jrkn0vK34hLRmRuKow6F4rAPoSi/5c5aq+NIUiZuN5M31bUY7nzdJY24vgVhW3e6y3gu+N7SkCNXRyrJiEGrQuhtha+AMWKDIJLeuBuKMpA5m62aJ1GE7sZyrxqgv9QA9YkZGbLCEhTeGDNkOPkI9gY548GoTWc9GEFHlI10OfGxkTHa5ZcgSRU5lyXI2vKejM2l6TsypfosqG1/SZNOmG36AoiuJIUuuz3A+2yH7z2iaGan028t0hKTLP8JhW3S7vNfZfJkMHkylJwKJmt81KydI/zqAxkmQxkmwxlSoQwphcH6LZgIrG7GjPTbimadjM2aistqsLGluo8toYem3npGmoI9sYlUbTBNM3LXCelAyecteRu4yHWPMILWeCAGNm/H5MpJrDUcvd4mCtTnyhNmodAKVbbXiSFrpR8F28D4vHqr7WLOdt0pS3eJodychVYuEzyhdDjPOoash8SnUJzRllmCB5kyirbVlOF0GTcyoTuzmASAD3HR+kgkbv5yr9uV53AMHAJ0OnzpTcwfdC8Mhfuh5XPTmXxQFEPj2z53SiKeJs4NyE69VWauqUJaYiLdRg35x0ZdXa8uCQFUwl+/vA2csyf6YwrRzJOPJHPqkWSe2jElGU92aqZvT4VtTWCGolJBdgRx/rZjQFKmGlBf6wb/T0XSOgjHG5zBIDM3OiwfSY65lwV00DauJ+hd0Za2vJrQAnety0YueQgjazQgiEeJulWuoX8GpweUY/9kjXf2z0L6Llu1oA/BrarYNg/fyGzRDDNXmFLon01tsS2yaD7YFo3Vt+1vuV5rLDNU6p/JYPlvNXREy+zVykq8xKVaaUio9b8LrDvyzqTOTtsJUumAjVcCba+lhCs9W1/JmSKOZT/aPAyggya4q7R8kmbNfCFsEnnwzKmFdl7AjtZtKZnZkh6PkYIz28X3ZiTGjcQEBTLLrZVAN6kWvFHz/SUTDdbrllFVVt886RsSz2ZTREN97zKYnosRW0Sv9Ia5iXKtU+7V4DzvuM5lV+HbpAdmkoQ+4xrtc7OUsa3kq2IOLTz29V0V9T22JN7HA3A07gbjMulLxHaUatJwYGtwVltptqCm7mqnp248ZJTa4YHI5VZls6N9p8tItYQDkcbJaNRpbnmCD8FkWNarrXqf3YLYCVBq0sdIFDB3XLfq1CUZLu8icfBwtql7481lrkZtSOLUOhuRyes5a2WnaVDYfS4ymMaOEb/TfUYLalvs8TV7Y9Nc3Wv2FfOVqaaNTWQ5UdCXersCU9GprYUIrDXKC3/jaCuZxa9j7UpcNscQyvPzQpUr9day4p9eCbx13Kp/weCTrlWbYZi6BoZ3WiX+O0M0ff8N201aG4vG2XLdRROMCYtIQ9FRp+Rxt7hm5lPXv1XrVwC2ftsQCuxtTJovKfNlynw5aL74jHJixLFwv8KLiBYIROmz1oyFNVXu1gNR9RYaAgpEOWWksIwIDRbMyMu1erAmwG8C7wbuZEavAK0TiODh1FvymKK7U1OGHK9wgwWcYI36ewByWOuQTDBLBpP/hDh2KoovOQa/Ln4f8mLdYiPy3jCXYx159ix5ENkh9VjeBZ1WwfMueNYFGJuV0AZ226tG2IhfM+LX/Hi0qIgXsGafjThzV+gDI7DdgMZBoafLrWaE5lPTFrpE3J4kCF1M9i8QgbBkT8+L2XFKBNJHV5q4yrQwmMnm9GGyIWnQ7Cr1A4BLRJk4WiEhBPer6zCCDrrn2DnkKD/iImEe2xZFiLDGQzdEUgeikJiORHhtG+2RB6HmnbgG8W8Ao1JnvwTLRMvT6jakDj1NzMekEDUfEw/TqSAqC7Z5BLgRI7Zh3rCYZtbRcYx6z7YCsZ7Ps0BAE/lYUZpVfYjq+iOhdFWpRrl/KWNh7OCrxayNR1AqsjwYl+l2et3V7UsFMY5HVjYEJbcufM4hA7mobZhSerKkjk7eASy5bcetUzWyK91rj8POddnoEmpBdi00W69NUaSltwe0gTFuXdQ20HwbvbJGMutBunSXjGyqe5fwzDMlDkXkg4sYnktM3GRMXCombkpstRDFVutNhCR0RPg2WviKViIgyCqCYooiKK8nwrfTIiTLI6TOnwiJ6ghD2Ub4Olrx5EdYiEWEL5xFSHpG+NpbwtdrEuE7UxGQthVRlq0ICawIpYwnQhImIiBtK5RGnuiD7QlDd0dE2Z4ifKUnQuIpIiisKCL3DaIPWiNiibWAEJGIskSFr9AlDIUiEb4aFEH5QWGKnwtDT0gYyj4iJFAjIjcfwlBdEb5+mAjfG4rw9Z0I36qJoNyiMCXPRUguRhh6LyJ8yyZ8BTNhaGSIKFtY9EM/RDzlJwwpGxGSuBFheC22AuCiD2ol+iIFYqtTRGx1MIkQo1bEMG5FHNdT9DkQxA4OChHH3BKxNLyIP7PE9keZ6INvini6T/RF0kRfjE8YCjUijoUkYvjUIiB7L6wSHWmVGvtXYk/sZESCLQhiKmA5PTQ8W+6JRnUFg069LpZREED0OjWxUi6LlVpXrK7D/2WAcavriNtiCC3FkzM4NF1YwzlFqJybXiI7M1jKkiqmAVunWJtv+Z1tW8NukW2i9a9anUSysQ5oPQfQsupQ5R1raWluRnWUK1kqzFFH2cITGhCQjXraktiq6qjqjrSl77GxGpqXETk8PSjfIpnlrDh4vrNVncXzB2dzS/bZgyPjVqZp5QsyW81jh1pkfatWZRISvWiRyxtliVccW11Hk2Gr62gtLNJBsp/Yp3eRaafM/bp5NvVt9w/r5T5iCPu5kBFq2Cl0AhLjy528RaLFEZpGPUup/dvnlwOz7jqbuno2lbt6dmoCnsm794vT52htMTJO5t7PY5wkriAOXnwtZn7vuLwpOWLWyFCQ1i+GeuP0P5rtHQlm0UlDGzI1X+SK8sVtKzKz+BUZqUFXCNLNwW1C+TaocXyp1arDYUqWRmCiMCo3ewrWPScvLZxZyJ9bsGCfJXGzcS4Y9bg1VAac2vcKHQntSxbk5KCBUugJGuqq1WtlttgEGEs6CU2sdrtAAB040K5trDrrl8dbnZUDcNK3D3CeZFIMnReyPxZaeu60OqPSAo1vnnBhaX5+XCUaRiJ9O1Pj4vrzX/i4hAtPHR4Pnr8Zf1ziSZ/g3+f9/eMSd0HcwAC/X5HhZfi9+4X8S2y4hjVmTYxPTE7Av6p1DMMTk1VhpqW2SJvaIu1gKM2rTmyQc/TC0gLNbSlbLJG5eAxIR37++2KmWJTvYS8aafYQRB7CvTSaB/L98bCFX+8AtkZ/SE7MO1CcnTiPrY+X223fp/jSoRsS5+D5wOEbErfDbxGffC5LfSvKPonM/LyM4E6hnWqsFL4HGl+zlF3sik6Q5l3CCeSARI7Fs8gkEk7+jUn8SfHPFP8chJ+pGzF0WFvCqRlmv8aV9fNAHGFR7XbD96/K/sKMFGkNWBlkllZ0tFwvwRZl9hpDrTYaZIOjdX/Sn7d333ZD4mPw3H7khsQSWxYxGnC7lnVMdtq3man+3ZO+IfEKeNT7CoQ/C8873n9j4ovwjPzmjQnHSK9B+J/h+Ynn3JC4C54yPPdCHpV+GdK+vkX5BoR/a4v0FoR/f4v674S0T22R7kHau7aovwfhgef0T1+H8HOf07/+TUjfv0X6XZD+mC3qvxvCU1uUfyGk37xF+osg/dwW9b8Ywme2SH8phK9tMT8vg/DbYtJxw7CR+MW9e/emLWFEzERi5qIxkUwzbt3ZDEfOIxkXjiwCSuiFI9lGY7h4a30R9nQoFv23xUTPSRZbXBeKm434qlOh6ALs01NOL1K5r4gfU2CpWUMssk9/Sh2nTUk1QKKdqjv8TDZPNGo9kxgxIwJNYkrDbV3p1E9HoTYmIVVKq5PsGss0to2EZj79/H6cn7HZUvF8p6B1gELsj3Ffc4lg2tiJbivwSgoDZgQbwEdlHP8mRFL5oQzcgKkQJ5g2CMb1K4UMK/wrw7HZTI1YmTscBQ3h8nNLurt0auK44+JrXhHmjYIKJQ6ckvKIDP8aRyaQjb266x3QM+2H5OFJfbcbDhr4dW3EZ2QSn6Zf+pDay+9fAlgLz/0X/PP0D17+ONrrX4DfXeKGXd9zD77fsOsg/t4gduXh98liYNdP4++A2PWv8PtYMbhr5Mfhd1DsKv84pu/Z9S783SN2/Sf87ha7dg29AnAa+L0KvzfB76fgd/cusetRr8Tyu3edhd9B+H07/kKBL78S2x24nnoV/g5e9+h3z/U/hN8E/N7yaiy35zrWL8Su6+1XY393Xf/Eq/F993U1jl27eKzPeI1+p/9/wH8fHISfZf99zx74ufs1VJ8qv+uN/jvl/23/nfL/9WtwPLt0/d/w3wcG4Oepr4Xx7/LLT78Wx+u3twLvN3B9u6Hcrlf475T+K5x/l6r/M69V7e+i/N9zb/D92L3YHo8Xy63fq8e3G36u/6TOL7B713/zXt1f+Aq7rv+F/74H37/m17cbfq8/9XX6fQ++P/d1ejy74fe6679j+9dfBe97ZPr/Ze/d4ySrqoPRM4wwp2tEmAFiENDTQjvd0FVd1Y95tMxgdXV1TzndXT1V1TOMw6RSXXWqu5h6TZ2qfuDwRaKYEIOKCSohxBBFxXxGiB/JJWbQ0SiikoSbkIQoMSQhke9Tc4miouLc9dj7nH2qTlV3j7m/+4c27Kl99l577dfaa7/WXgt+z/zP92D9OB5+zzz5Hrs8SBZngMM4HGDUQOVgdEbHhigtTY2cDs/MhadwgxiOJOJoDZ0evHaGIV3YrXAUC1AM3w7FXCqeno4lk7H4DBrboEMaw76Lo+VdP2kgaAp0Z6VisbM8e3xN5ZuKx9Aqaht0rSUR8GsWpFOeidTUT9keiOG/ty2mUhEqVZsO94BkqP6WvO2lez/ZOCkaUtZtfQVoh9YbpaMy2NVGjExtoQ0UZTae5KJwGq+KbaTL26Frg8q7RgJJa43WQseomvjEuseoU5jOGNqOovUi8B4SSou7Sfn/I7Rnj/KsS3n2o2kd2M+Ckr3JDw37CKs75dz8aqc4ob7UC4L1xLqiZCJh1qhdXHvcCpAHelby0qbgdiR7WnEr4esrhA3qUZRCGfWK2mbrZbZrwHRosuZyAfUV0J5Qu+ah7PpbNyWdwV2wtL9ZbwsZ4g4LVXKL1m9ergi64IZoimwuimj2Jii7D4l62kWKVvSMtgvvWYomGG9ELT3SsULNrdUMJ7Qpt0PTSiNrtK5NHk1dWdbCiWk8sxyPzsTwVHKiuIrHZqTCfy45Jo/hMFkz6FT8sDEWTgHPP9IcxQqX5StTqXlBs81MKBLoZCUCrZ3sj/HcFjTYkrJsACGcY2B8QItySkNeePgLZX990fQXK5WqYRVKjSK/outF8L5AC/ZQE3YuiUCOtxLcMsI4FKVaRiOrvKW1zWlSBO+a0eIIVx9maFLJ7m5jUprX7QKLsDokflJk8DY14IIIL0ElCllLgBQrKKm0Ew1wHqrA/j4CsxBM1mcNt1hYWHQBztpPaoVNBNOqFMkql2iqeTNfsU2Pt4DzxhyB8w1LtB3u+tdEK26qiiY2JJncwcNdtN1ZXB01kqxIhikQOrJRNcRlf3FVSyXCM8kYVi8tyU6cnsPG/bb3btfvBvcAuM+B+xq474Pb+r7tOgyRRAQHykLVok0c7c1490r/bpK/HMpObI4xHYpxkNVfthVPUhLod0+wlIN7YtUoa6JANSl3ejqZQm35sZlYyh0C/86Mjx1xB5KOfI+gNCmZ90TgFZWIjsXjqeYSpMOxBEQlU/FEVJtNRCemYpP7+SZj1JiJw+Ji0khGZ5LxhHFlT6MFAqMh3JibiYSnYmOo/3+8LVAyOjWh3JNoh6Xeq9laoQSrIb6ptFRjU16ouDhJIzYTiQNZJFPRmZRX0cORSHSqU+EZYM3iO2DuS55cG0gg1skorg2LOBOiTYdK2R5N3imiYY/WcGl/6dAmUNXJI7A/71BTil+zojbUmh1FCmM7lmgs7C6RreOsKlCgyI9Ts0pVPMtAI2FebeTubhj7kf3RyAEjgpY2bPjw+KFYJLqRFE7FN5TBuhOIGsQSydlodFw2CG3AZibXhEum5iIHWqA4HxsWMsRb/tlYCkY3sBxF3aCLZbfWejYJlBeJxg5F2xcpemAC6gkT/wxkQzknPWH2T6bY6IVn7CEg8vax++OJ2Jtw89IB5kj4cCcM8G3EpufEeBqLhZOd4YjUPcGwVQ7CfiqWOgJFapMfzt9z2F4IDnPQ+wd+Y+yO8V0n/upHn3novq8+9NzRzx7a8/y254986Feve8+Tv3T5H77/Y1v+YdPRt25/5NbQVZ+7+eVz9WOP1H7y4D+95SPnfe3u+vN3nz5duPvf3j75yH9+4Z7TF3zl3pdfVel/zv+xt9Xf+LX7H7jhH3/9xaXEwX3vL30h9NEv7tj8wKO/cuTT39n6z1+YvOMjTx7Mfum8hb6+i2/1/emO3d2XBX5c6p++6PzdyZTlMz/lu3Ep8Nhnb7m1v/aee7/x6T84kH/VR6vvOPDZDx4sPnrpN97zxFXn3fV3t4684rvV37/xwl84/aFL9eKuV08t79/x0J8/MPzJl1++540f+4eZ+Jd+9+h3KoHFb//qu+qV7H0rF6988W36OY/+5g/PPPLu/1Oc/dD3P/jiI/+1cuILA2Y9O9CABShrNMFZc0BKM9Lxu1Ds3ssXCrA2qFbKltlnXGOEtJMYCf83RaL5lVqfliBhGFgGsowq2uBwLLDC4lheThgyneZGw28ktFhZLCcUiV4HIx6jQgKjJjLTprnwE6nZ0dHj0VoNl7PwU65o42iodxUlZk9OUGUHh3YHsMJd4LGD9sigPTJoOCiChoPaeM5cOjkObXZyPG+dHK/M36iR7RCjey8Ur1is1mtaPodf/hDHkLJfUTN+O89XYFmUQyFtZmi6xCJhHhSAxtrhipWNFffWzGpx1b8PAfulmRL7VoctV2vVzCrK5AaE1KJXytcR6FE35LFWVPMNVB7NNy72mo8DUawroMQrHSMVS6vC1lq+jlr6Fvz7hH6DsllfrtSOaynWhSs+gSTKfrQ9pWWLKO6aJBnOWK4lOQt3ytTCVjXvX0jQSqSPSAUlHihs5SUSix3gQpR2bs3ME8KygNZ7tWi7Pv8+JTgpay5o00bSTIZiTyKMYLqjE1Z1JnNcGy/k0LANFgw+YZrNHlfaWGRPRmtasMfYes449HUS45W+Pxo8pmDhLW0WRTUH8pUK3TCK0YtkCIRi1fsoVM49mF8l39solOtDg2mIdLxWPUBWSCDDq3vtYOPqvte58xcGYcncTkEWBXiv/sHt+rdhIf/VD2/X/xNW71s/sl3/f2D1PjpaOg6jtDeNfIlFc9kQEI7dfiOZjiUOXz9nnBS+SdsX79MopSx7LwzFvcboKNoK8sDGNY6nI7CKSwGSeDp6fWSqcwZ9YmyPjjbK2AVt0PZpHC1LolozQrJUOG6h1jl2gCzdrsmnB1wsrR2FJE0WOG+mvzDQmui0SpXIQ6FGiGRqlBDMZ+JSbb3sUTczkdBEH7MK9SopBAhzlSZ+Iz8VcE+eaDMnJuF0GyZJJIiyymS+lN8laGlsbRQrN2v+fcRloHy9OHUJfbqG0LJfheqbkE5ILGl54PVpDhS19ea6noU72pLagxOH0RKryNVarDRgS7KIdpHnTbMMDBe5GIphU+dr6flMLs0dpwRgIbBCIghHAYZTQZQg28KpCHS+AdhighFROJep3hYArrCEwHdk9lTtCnXK0CoJIMi6ibzlF/aYcvkv7/7vs87TPwLO/I3z9GPvPE+/A9y7P8x3xMhn8PfRP+DfZ/8A72b5F78l3Cc+3Aonv/FogcbgfGWhYbmtk2GIDF9zmNqLkPUPaV6SrBterFe0Mz/ra9tsdZTOqjT0wBiq1dkem8ZW2dg8X87LZNx8A9mDu5sD9VqjnCULdMxMyAKdkLXssUjdvDL39FhdiBsYrBFXAP1ykSfGDb2B5wesVXzaFo1PaDC6eeIgnHY5hZLdnsBgvl/5V4bj2hqNl6HUJgX2BvuEbikjbAQpJKSEhABwhAEHleBB6R2DNLY3pA0iVvvbhoo4UBGAsr02wLgDME55Du3KOwE2WNQBiwJYKLDbAYs6YBMO2IST3QQAKK2QJzsCIm7SSTHppJh0UO53APZTzk499ztQMQcq5qCJAQBSh5W2qosmasdCESXia7AhgRnXi71l+VkaP5tp+pTMziPQLTts/t55+gK4+z/qyDqFG/XKqDErLwjtB6PUJnjJYNpH41LJhn2+CVNjpZYjtm+Q1RItRa97vbFY9MwDp1J5EwlMvrJQhskmp0UyDVb7yBcMWBEL1UwaK3Soutoe4KYNNxdO09QwR0vV7DEpcKxNz0a0Q9Gpcae9rrj/PD1zf6ucqbBM6EZrvJlkkE8iupMshHez5m/6M6bCqehM5AifLfpb/rRKbT6dyaGqUzT/rdrcbGCUsMFOT/sCRrUxH8TXNGQ8FIe+gC9mgOnwTUfGOq4ZxtFGPDGGO8hjRlcXSoT7mgPxsIO0EJBeTCJGISVN+RIxGUfV+GMaCl7TuxI/P6a1GlV67saFK+SCbHFYfIXoy2rMG1cGgXCqq47Qnx0MfRuwt0NORMgbPuQBj9YmABP9KgEhWTUS+raPyKAlXDWgektDnlBvA5hsA5duQlcqPsWSdxZCQF7cifDsYKGAAL0ThPUimvz0SNcvAYyegrZQwemlAjhkIJlCR4utmLVp9CJET6FfLufmTYOIQcHbjNMpFyoGw+ecWBIntIFikjKYmkCtqYRSm2WQW62Xi+TcxQmi5I0Mwre2aPukKflSlxoG1uswb+EyuRvIvVhsGPv2kmaXPiIzjCiaTXQG5F8sWIuwxC3nYGqlF0Mr9L4zWyvMm030IgNz+I30BBObCiKDVHJyjpsQAE9XnUSaVW0AbTUsgzsjR71BpRUFEykG+5qfLrgSUL6DrUUZ7FAUbPVGuZlPoEFY7gFXc7mIWknVBgtzG4cw7af4vSoJ9uP9MQJSfipWdfnDvMnqaQTqK3V+HUQrIGJYkFk3KtzISC0maMLZo065dozGkL1K1nn5GlM0PVIyxCLfGcT1HKmIcZA7XGnQxaOGlC9irsRV7e8Qf4s8TMGGBr2501A7bjbUAt8yampo7BGLOdnSDd0OJxilfpiHpSH1hRfjMnqrFdgTvg7HWCG/qg5YGpEaRfMBTy/awEY5aypeW9pzDlTRmIi4dGdjVo7SBJkaiIb1Zhb6DcXklaSbDiXtN5jzOWeDOF2JQ3n2AySqyz3zzesfQjnoC7U8/L5T+N8Hv+P/C/znXHhOEn/he1ab1Qz4/eH/Yv+H4fffFP87FL/dTkVctWmQXxrn7PRUODEZHcW1DXTv6xdRJfk8vsBlg82vR5tKR0dCg8eMGxvl46/XHP4Im9pGiVs9jVV1UE5Hx2Nz0+npualUbA3MO4c7Im4JZa7cFNqc84byJIzEUhALlZlexbXFYeduZ9sB9sYCzLWwikrPZxo5NmAkvlExHntRgXelaGqLeJwLK/gCcA1YxObMbFHoStTmLfgH4JZQ17w5iOr4M3UNssMMpBVeSwMSXSwW5vG3VljR0DYxSpvQsRXpDdDqlbIogB1BX0DV+KCcnn8irwlLE9jEba1Rn+ZLNMrE5/CNMq/FAwEfrbt6LFxxJVPhREo+KlTCeSVmf8rVGvylYFOThH/hL2nMGdPwX9hIGEcIa5r+CE78NHmNFhj2QuKBG+gD/kXvDQJa8fKXCjNgDIjEBMUx6L2Bs1C8hvhifAz+Wn+AEhMUO5mgyWu0RLCjNrlhID2Ajr341+RtiWBwSByW3SKfRAL7Q6YGDNDVnK3tCj92m0FBWhtPNpzTODe0tJLdQk4jGC2t4WoJu8KyVkrNXbUGwCSuQ+vqu05X7eThBZMqBBCtwSq2Ml+HvZGRM+soz9VvVPnlc8301xplEh3zdRlla3GfQN5jQeoz3/y139um33/+Fn0LnsOHL9L/9YIt9K7hz4DXPi38H+3bpj990RZ6D/Gf12zXH38Nh3/pf2/Tn3v9Fjoz++HV2/TGX7L/A6vb9YcuZPhHAM/IX7P/L8H/5DZO+xT4Dz7B/ksh7f1z/Ebvk9rF+n3C/+zpbfqqxf47r9mmmx9g/4v923T/Lvb/ePs2PXaG/f+OZd7FZfiisV2fe4DzfR7CY7/A4Zv+ZLt++lL2nwf+TZex/4ofXqS/cAWXZyuE33Ulp90G/vuuYZijX96m9/UzzDlQnluF/5UAc+cA+4f/eJt+6R6GvwzC7wE/PljpBf9L13F4EOFz7P/H10DbforTPv+d7XrPZzj8O/94oX7bF9jvh/pGH+XyGP5t+rcCDL8L8Dz1KON/R327fv9jHD4O4Y//Jfu/Dfhf+itO+0YsQ4BxxsH/pGj/Y+AP/w37F8Cf+act9ntJ+ccEJ8/DeWeAGpgMv7GDCQofau0gLU8ZA9ZYdOhFMT6txxJvmcnLoio+iRKFI/mCtIiUvaPH2rEupIu0xzCy/JMTOtumMyto6ca4kbRrU2AD3+IDwx40rjwzkDOXBur11WRIIxkFe0lLAP0GqTeHb+D3AmDBrPNGEU/JK5ZBRoMWqEiUhnXJMaz13wjro9lqMM1Hk3RRgcu55Uyhjr8cWaa9a7A5IOTkgwYU8V6HDi/D4xGDLVhoXfRBDW81sllYqOUbxQBqakRFp2jowp6Se4d3BYL9xu5AsA86JhTYyc/sQ3lPYP+eIEKHdgcZHhOvJ4F//SmaEwytC94TvGn1wXZoNCVE3BzBsphkemFZgwmhFRdqJixDnPMrvqHOlnJ8LC8O55vwu8/0brt4i/4OcE9dssU+0+NFMiSBZLVRY75SKYZYfwgu8dXFvCckP9PvsVRQixbszaDN6WFht76MCFDkAyPPDduUE8J6pB9cb0aDbTKCT4+sBpsx5Cqw3TPXVy0JKzLMq8D55swEcDMONBZeXlhffhKWZURoaONmUU1zU9tEyi60I4hUKGSuLGbwcBcXtHRX1CYRwgb99oUgbN8XYX9aQPUjtA1ok4zbDDm3Unz8bG43kaCl7aFI6+wlgrTbzNVaDW9g2LivH3OHhlUA1tusMonzULqFkBCiOVmjbJcTNZjyPEvN+bP+xw2FW8S0WabWSuMNBU6SIk4EjxqZKsx4OeJ17g5thsAdbUcAHuydYZiw18BDwl8qhKsiUAc0ttIuSqEvihPU4tQf98xCaxYbGSM9P+J8rp+ub/C5RIHVvJK0vzC8gQBaEm9AsA6YUQmmOVob4CUEziA9ObpZNTJl+xoHDRLbl58e0ahoV8Yzmtyo4dzE4nsDhsGy2CPaAe2Babqnx/m270bxloTBsYgOlg2A9sM6qsx8QBxWKampn6ApC3m0W+AoAlpXctqS4oOvOkXiepk8hQodk3DRcP4qWQHRGuJLs2/5sfWl7LpA2y+uqI2e4OBK2380eXAB5cCErOjQkki1hMnqeOi9id+umB1eKPvFyxARceabKDeB795xQ3A+uAtxDwKuG9wbcESCewvqXdH4jUY/JoANyTW4KYFNx9cgMck/0soaX+vAep/OmJPjsDSt5djYFrauXHvT8TLPN7699GdMQGNIDU4NFos0souN8nHLYAgfX9cBJy4slOk2BdMr0HxF5zrgBgAStao75+uY2sxxv+CzFbGJxkV3IKAdTsRSUZZt7kb5H5RHRT1tMl0/Z29Yi4U8n1pzB9crleO8S2lYGr4gkDgi8enZcCKWjM8YYrGOhaXubsYUHovzkdPEXCK1P5owlLTjc9A4cSF0LWvTuS5GbySVmPqlCElBYLv3keyBHP8yNVS6bRmpcbv3wr8aF5ZI22YqJOigYLRbqRPOlnormczNTMVmDlATIDWIBw9Kj2qOlDBuFek4/bjRO5GUJCYOvDM5PO3r0xiDMRVLUsNOxyKJOBBlIh5PGeOxRDSSiieOeJLMIArcaHwdiZ9SvbB1zDiKAThhH/NpXSJ0FLx+y0jG3hSlAyCUostLCUmMyxqR/XMzB2RcLM7EbcdPOGd5eWu1nMVnKnjNsMq9iyBTDkiR5ElsEKywT8uOWqMTU4vORUMZH2bRi0LCkaYc90Jr8ydmvZdM3iscGzUyszCg4URV8hYAnu/64r63o1R+7EaBkn4NaiWOQHjmqG4cPpKPix/wrbnjovNi2mftMHZoFrBNlIil39AxbUdQhA2CPyD8Q+AfEf5hATsCYUMibCf4h4V/F/hvkEh2w4cf/HRlNwvERyr7SCmbxquGpkBHfq3wui36cXDPXO3s/SZnY/FRR8xIw++WLbp28p3aPxPLbfn7LvDeS/F8qbEilHFt319JpYyUVH9L98hGgl9+sjJtzW8kYJRW6OUTDI8oKt+tFbJGuFALGNOVHEb02gp0Df8+YdvQYD29fQHEwNdDNcecpUGXfCVcHM+jRKcSg3pjMZF8b+nELBf42axzSGP0ziXxMARyEYSLF9/idYfrSpJuldUIeb6CtxGosNUY8DpqySIlFsgCZT9/VOjjLFDVswCXqddrIm2ErvrK4v0k37ghJwyIPUCSqIYrLZ7eBvBxZR1VWrqu5npW1kJpxCxjtdKoGdTfNdkd1WJjYYFM4PB4v05knbAx56R4Gvh43UacuIpmkx15BjdWPkGC6TCcmGmHS8ECAcuLhSxvcc2a0PCxFnKusI1c2RLRZnPNwsmK8tMSbiogrbYJ6MVtZsGUV7TlyjJ6l43BwMghWRxhUNneRnp1pXgZDXG0pvLTqq93sQarT8vMDqAxqj7YiJZzbWJ4rhFa8qtQwNBAKCjU5vu0niJqKS02BsABcOunT6uUTT+DQ3mzx8kSVva4T5udnSbSYZJt1Ew0UsM8WQ4iHniAIJ0pZmqloA2QLbKxSoPCLeTG8Gvre7Th5EghMC5OWHqNXvloHGedUXENgbkZwT6fxhsZFuVjPwk3pvGtSBofz2hpvlRMZ/JkNxE1Eaedi0QRm2sCk8pzUV2zpaXrmeOmBKArwbWmEycDmlOUTxIfx4cxvX0KXy8Ft+gVcIURh6/jXeXO4flCnScB/Bwa3Dk8jbbfpuGjeW7I7N6in79ni27udnDwKS5PpEj5dJRL2kcDxkSlhlPmjkwuy/o2d0gNm9eJc17l0SYaV6jwkUUeOQafvQuV8EZGXoYqR+Fakq3mSs2go4JZkFmUnNGLUrTLKEFAinBpDScCyGBWrk/ZalpQoDfGJg15j8vZ80oswHdfdlmWUcJS8hSJs4ZdFzAi9FwShUmKqzaygNaKWp05u2hHZc+vPhFQqGTrRRli4JKQ20S8R2DNHGxLOeBj/XNvuY63P28A9xZwvw/uM2/gsLdIfxh2SuDeEGY4DLtQfFfBvTsMM6AFRI5LVuMQrVyvHdzX24db35152CosDcHuxlgKad6Ats9J4Q1IS6Kjx9YF1m/QjwNrxxt7HViP2Gs6xvo7p+2M2t85+uqOsT09HtEeDTCktrx3vO1bC3A9DT7kbvB27T6ktPvQPo/YazrG+jun7Yza3zn6ai6yR8xA25ir97ZP1D7q6o7lcHrYM9o2YOwdYaCx3RqJNjUDSMFM5LprRIsXqh2gaHu0VnwzGg+6GV6DTodtOh3etxbgeuh02JNO25HrsEKuw/s8Yq/pGOvvnLYzan/n6Ks9Yj3qGwqu0cAI4HjXBG1p42mSWLp2qN9oQ9kugGsM9bMdkk4wIbz7DCpZwUc7GDs3EdAeVxu4fGbeyvcuUUbpWm8B71vF1wn46jOuhRVfUTvYyKAdZNz2w9ZvEXaZO1DNWt3cgfO9VcjhPhDtf5azphsnLgrbohWFGnS3HH/yCrVb697r00ohiC0N4uxaGnKn8nunKg1BjEgRaspnb5skIU/8naFDaAVoQVT5BL3rOlo4BnmfoJrLgA7tSBqJc9lSb59HW3a3TWE2AKRNGi5NgoomS3D0RixVQvlcR5kAe83YUa8If2tOuPBiKh1U/EOKf1jxh4L0we05tDKkfIWCK67YGRicqyU8ZihkKThRYUtLHO2UmSKdT1lyr2BqsqYIQmtqRw2tJzCU71pzeyHEGN1yAXddu0W/G9zNv+ys/9uvOf9ZrDVxbdlu/fnL4N5Ca06BR/mT3+pvW5hPN8F0KI8R/r0333LdA9VPXrvwBy/be89Vg3v/7/96+3Vv/vate6/uv3vvC0f/eO/nnr9d5tMRz+Nf+cojj39l6tO/c9el16E/n3/7G8D/GfweGhr6DIRd1y5tK/6gaBOEmZVt06YubxF4NRHG6/hvPlC57thTv/nIwfel9x1842/vm/iH+nXX/vIrT71YOfDIa+a/uPdzH1r1aB+vPDQB9xkRZ7yhqc07tIva781lluneIPck13Hc7wtcRCsCRzMNGWGn3hcKuvmiK4+CFYU1U7E33G+Mo7J2/sqt9Bu5FZag6dNGR5Fr9C7XMtV0tdA7zKI3+As/gzCBDAVCw6GRPYM7R4ZGdu/ZtWdocGj38E5i5SHTP9KMwC8xoAe491mgGBIY8FfADNmlz8C2tY84Xe9SKFCu1ICBAvCuwHBoZ2jP7uHdu4J7RnbuHMrb2CVsrlLvXRok0aghfIppA0jUS8Dpl4achloKwfdwoFpZ7g0GRvr6tN5wOgbJ4V/RegFE3ReA/XMvYjOrPLH2ZoweY55ksIJN5cj2Ut2CzaEhj9BcL0zaLMvVHBESEU0pzF4vcLMZu6xgtl8sNYbylBUsEfqc6qO6GOcrr8AO9xsj/cZOFRZZLDeKijMQgmRBehEbBDbrRm7SkZE7qAVjpboKwQ520fUnlIrarX6C6znYFEhdPtQUOEQCbDJQZnqi38Apgkq+e3Bk13BoDxd950hoePfQLvoYGd61a3BwZCd97BoKDu7ZuWtYrduJYABfg/f29Rsn+lpxh6ilqWtdsSdkDe2Bmi1BF2RLzeFmqKlJlAQhzxQQBLQdU1AMtkFxYtCjILQ07q1lcoM5c6HvakqYt7WxiC1GUzwavMwreNM0FS/hiGoJhWqWXKHVWiUnqUmUBthIS7k8AdVoK4sHnHi26AApYTXU57AR6MGNgQ9JamUAplkkXTcxpu1Xb9cYSMOesYMcO+gdO8SxQ02xMZElr8aDLbEhJTbUEjuoxA62xA4psU35whahOTMMCvUpLNEVM+gF3DRiO9WkY0U61qNNNWQvC5oG4mOidmi+OQbIHa/mcULiM0jYapk+DbxNKMPpVD9MIalmak24BmjCPV7H+o2x5gTAGHsrZdO6Vmz0dwL7hi3x1Ut9guzCvYV+40Z1QtjVHBG0I+ziBXKFzALyLvyVefaaYYA2w2vMe842qERX75nePrEJUlsAhzuMpG71W5l2kVWp32LbkCfs6VKh3LDSoT7G4QnTFFcacn/7S8PIb6Dnev3qfIfB7ryylWI6OJi2ljPVjnC1yrICRy1RGg5ASXvds7GyHgur01m+t+Se6mWDYkQIZ+XmaQ0joJncU5s0F8rXFPlCEfY67GfbLOwXBr3r9l13gcTRTPvOAyoWtiwhnqOGTjeKru8kMTsn1DLrMTKfUV8VAcVCVuDlwztuNg4RNlxlxnxKoPoH1Y8h9aO5eDC9JWjk8SdJfGJD+1bI+p62yj/r2ONB6WiL19WzOzC4oNqwOZLboh8Fd+7HnL0eKX4pFVbQslwsnkaJMuj1FX6TrNq5JhADFS2ZubWLgdBUClv1ECvcowgymloNUEhvn0Zaa6TMGWYwKrJBeRzOt58MVKKATis0h6TJi9dceM20UpcnrvJtO12boyAMXgzRHfbs9cNQ4enw9enp2PXRRHoqOoPqHOuVimGVMsXidUYvWmpCRHSzxL1dwrceOb574lLyU2yUaEEJQM/ia1MVki7hT1vEr5ih6zBIyeYa3Rk0+tWKcADeBnIzdOwfKDli7dNkCX2v7bFe6zN6ZQPgA168/KrB4oHbjDRoiZtVktRxpIIwO4VMbLEevNYT2Rbwxr9Fc414yS2lxLjyPZaKbABonLU+EdWpMWjJNtQ+atA7im/SVpzITBYNhxn0ThOYDHA0rb4Is3O9SPd9aJ6ye68RNHpJ/JybFQZBg5TGL5ooIEXahwl/dx8agmR18IyRxdFdr6CXLNKogyoLvGC0LpY1o6fs1ZqZK2RtiiJ4frnDrbVUqBRJB4ANaAg76J2KQf0ei6ONNfLCoj1HdrTw41AqPhVyfQ3aXxFuPfs7XCyyiS4sDPlsO4mf2qI/Bm7vww4vMYSc5luEfCbKZl4P7oGXadpM3JhIHpmJuGTc2BY5cQzkIPT635a8xP/LWqwubpOBtk2U07sSWniA/mXpjwFsrd4eIGSfkZyLRKLJ5MTc1NQR8QqMc90BHpKoTPYbkfhMKjYzR3J4h2Op/fG5lCjaBCpqR1ljoScXMrDFQ32yYCR8ovnWIS2KhbJFRhtlVryOJCUVTJaEiHRx1ejFMVfA9z4jkIgUziMk2oU1eq/sM3CyINluGLI+p1GMHKyepC51klhiSUHH4KqjjlkMbopCRmLWm2Hp6YLzJJ9F4/pkQjJ8kOHnoE4izUneRINOMiGZ6k6nYvVvBLFBwhZC25ZSeEyNfa6d+dQF2/Rd4GbDifB0OjZzKDwVG8dRTtDCvCh0rtTrqjRBrmJajlls6vN0InI155NGtUzyPQYnVsq71pyomLjFiZFLgbMS9wjmjGIXXMecmc+gyike7MkCDsuJQpnEp806DEvbE13JFmHBZMXLZktYarnSEjaGxJCprZJUQ0vs4UIxh5LS9jh/8TNb9B+BK/2FM855wNJ8Tl6zmKmiFgpYn+VHDYqApiSFZ2Im8Ik4Xg0wCPbAcLuIUFNEBudBnC7ryxWZg4UCEshbLj5X04pbNO1D57EM+L9AGD4yXgG/l9RRdblEihkrPi1J3BPJDyV0+h0xMiH5JSS0XJ1i2SJIUuhYmrElKVPpJwklpG9U6EHZULmF5hbb+Da/n0hERl2PhgiqKZdERJhTpucZKGI1FY/PjoUjBwzFrrCLCXZDB3NiBBd18uNkAjMa2Xw3V22xbC2FMyCNowVY6eKrA9MaNUJBY/9NQheNQeboSUhloYjGLQBdr6wxo++jWBnGHcpCUFZAcwc7syauhLgBymTAIqelYtNR4Mz4WgOKSm8h1YJYWhcp9R4VkjcoieSzw+w1CLDGRtm4tlRt7AwGgwy2Dy+Gri1apaHgkBoyX8qEdtswZLQj4KDETmC9LvhGvk9GsDr+UWNllObzrlXxexP/GqUB65cGfZoCKzm36AwhckSiRt0CDk9gTN6Bd2td8QPSIIDQQGBrilAEjoqrUCLUrt/UIBzU0h7WyM5QyNUcVWtoKNRSeU7uaAoUVSc1/kREjZoplzKl+UytK2M/8jFKXcAEq/ILzxkiPq4NJ1+jMqiLvakyHNRcmeLQQm7Q1bdN3W3XhtO31Ia0vhNht+/HWiY3AOOeQFu7h4LXqtB0eLKpPhTSXJ3FUnZk9+6h9rRqV4eSt9QGbWEwbbWtjU9DoNZqYOgatSD+SXQcVPwh9qP9h6DjFaGlzELQfixkCYMujk4JEcSvOATHm28Uj/ubmStXyqf1NMTy0CckZWcPT6eT0cShOPybQiMo6fiBligI1sK5pUw5q+IMkkWgkWDQ5xEZosjdGIlLduA/wRK0R9E0qxYGJdHn8axdvP/XfOozeVrTJ8PTs7Bc9Emh83BkOtikG0CNChjjFRS1NsqmWCk1UPNiLYvTBlLBdUZY0SEQic/NpIwrfeLXQ+nAiFvpAJZvRC2fKDDRlB0woga04qTdpIr1MKAT2u5EvF3xKxHFYdh8mVJum7eOMMFaKDVuwx8mXVZLZjkH9C9eGuL7tAXevMLKdBT1uK2oEyZ+i4TiYdlGEi6FQoHhkcCePf5QYDAwpPGuBBKi/WKBSChm731tE/Br+wFHcGxwfOfQxAT5Q8HBIPj7FLTBUCA4GAiuG7OE74Q8CNBBAA8iPCbAFGtm0SbVejNaT/u0wHdsovU0uINEJCQ//RGSwZGRgHBroFIgCeGE+GuP0B8KrR8nACtog0EHbTDYhPasyuzvVH7pb8ooGID/NpAFwXdqHAJYF1oF8rUqEk+E62+QFvgW5EpTEPFAv4TWQ2QIpxBaSwdKIP9CZp7/WydWJ0EH9B1RnQXXIchadsi/y7+wyxzcPZgf2bUh3taUVslUFF1UoyVT/0+Tq/+ss61lhzdYv2EFeURBHmlFnilWFzNnX6vW5OuvF6Ud3nh2au2GlSyGW7OYN+s/ReVaUq+/bph0eMOZqTXbrWSwuzUDWFNtDD8mWH/5Afrs2605cYdsgxtstGCbJgt6NRlz1PWjdkMr7LcD4rX7oQn4tSp3bO6DwM7AIICuPQcpkJL17gwO2kxTzkEKWC07uH6cAKygtVkI/EWayunfEF7/xhBvYEJqk07JLKhkprT2esvvWfKgu+S1bGg9uABsLVQhoJhg0L+we08wOxwaWQfWphROBmGP+Z7A97j+NphXm8RrZTsI66bdgV3+ncAeQrkRc8+uPetq/ZZUrR2Lw3QXZlTLwB6rhBeNnVE7cK1j0i61A4TXGZw0NLhexGqaDpmEBr2SrLFy8kzTIZM1sAVCQOMbw7jUPtVanXo22XVEGQgE/OA6lVaArFG0dSDi9VyuUKuvrmuhTJAdF+DuleK6MHsk6Ti9y43ABsptQ29s87ChHJqTrS8rwQQ2mJMrVeeMhgPem4V15tg5ucx6OLjHo5/stP6fMm//T5M5rbSV1BvN3Dt9x8w9VvpnMRTUhJ0HhF1WXO79NA3tnX79daXl5llUVUm3oZX92eTlJFtnozZvAjbaqN7pO1Ovun5dZ36tSdZeMjrrzA3m4T+rTDbKWDumXmfGP1W+Z5XtxpqzQ0M2LThhsb1+vDbwutAqy9GNZdGScM3s/Gedn/8sM2xZcW8gyzZpO6zZIeHuwOBGmH4zvES+27NGDvDGa9Qh7ZqZboC1N4GvE/VZVadN0jWzXP/c4YZeH+Kzqop3yg4ZriXT5Ji2ECYzbVnjJ/9mi/734I79rSM31GqALZspmbVMOm+aJH/T/E1IoysFVg0jzKk1waj21G72ae9973b9o+BO/+RC/a/h9zlwL3vfdv0XwfVYxvwqCqDaz3ONUoUMgeQrtWXWD0mfR2fixzTjaPzAMbzwHDXmZg7MxA/PGMlUOBXVUEyO1MtYmbxZX4Xo5JjUqsXXjCzqRwp7WAMVgWeWsKmyllEjkZ8eGPx545C2WCmZKAFTN/YaPQF8n1WslG1/psjh+P5sNYOyMWiWkdOs2FCrtu8mAW1oKCWE9jspb7RlxwUi6ZpyZkn5yqAKZroh1RLRN0YjeAerxScmxuLhxLgWnkvFjURqij3741PjWsmwipW6LVvNMdOxZDIWn+GPqfCMSJkKH4gCLv6YiE9NxQ9rs/FkLAWwJIuZiANqNA8zNx61A6Clx2JTsTdFxzWhXsispSGrNNppc4JGDcUwEdsl0iLhqVFjnNQ/Camp2AwHJkw/dZMTLHRI2XLtrm+h5FJojeyxnFgLjeVSplqlzCYOHek+IVspqVUW1cPu38ksdNA8Sp6cJLnjk9ARJ1mw9yQqj6rk8yeLkPgkCYaT4cWTqNHuZrzrn9b8/sUCygHeaGbpwr1mVqV5RpGrNlcWNrBQpKNRr5BCPFcoikuMx5Lww1VAAhvKa2EiCWM8OhNDZUmzNVPcqVNBLTYXzNIagWbg6Uy5kSkatpS1tMIeQEIb4Pop5tFlWQUWlK2EelgF1N6FyvxQKI2NwsMoJQGNYiV7PIeWJnthvFZIXi/fZ8diqXBkoiZB1i1OduSoV0iuBcvDtVEAnGSiPJaWs2nIjkNVeTJ3aHmUABWiDmxLUYQ5AUbOLBeAsFLcneKz3xCtwKr3/PXaqjYFfpKqhxZp1GrYMrI77TiZGonCKFEzF1e16QJZe2X5IJlhyRUo29gLlOT1WE+eSKShXipUiybl+McaN91EVjmdIDEqmuxQorQ/WSZbMhcLWdSERoRuW5dBs2IoxoySLNhy1/UFfNpRmFWOGbJoKNnNo7EfxXwOzwI/xQYZZTO1LBOk1M5WGCqFh6QRjbK5LCWtkWNrs0UU67EryZ3K9AwEzgprG1Ua+JkFNP2pIV+Hjsqy8kh6MWcLWmuRBLAwYCvGTPhQbDJM7AyFjuYSUcNvRPZHIweMZHQmGU8YABUbSxCI0pV1wqlQhgiYqJlmnrS8yxAauYJioODY+xqwUWMsnEpFE0f6jUQ0NZeYMQTfNcLjh2JJ4JwuGMGHDRjskfhcIjwJAHYdbKjk/rmUkTySTEWnjXGY8jxAODOySCX4vAdMakoqzW2NxDSYPJwyInOJRHQmZcgJoQN0W3Rq5edmIvtl9bu18fDMZDQRn0tOHTFcbdFSS9sfTRozcYibm52NJ1IESAA2KonEmIoeik45xYtNo5E0WB5MHVkbWNRlTTi7JpOzSXoCkEHuVbBWKSBfWAGCRFJFC4AioFih5xpM4lmg+AppRbUVzGkTzMdV1jdvZjMNi0TiF4AWTVSEMyk84gUKiVHlW5JqaBa4WqDFQD7f70jUS2O3QLgU7ZUtv8zRpsMzc9CfYuaH7pwMx2aAAbGYPyss12ZITzJOU9Auo8YMmQIVLJAmNRSUxIEBea+a9QAlkNDJZRRVJjlnVxKWpHSB2tVGCq6x8lpLcEdcdLmAW2ZFwYg4PzEx0PxF2eHzIubsxVXXNCeb4EBsaspIHo6lgIijM5M0RD2icDXV1GhT8WTK6IWpo76XG6yPln8Grv+AoxYcOnEHE7WEAfV4OBU2UOd1knBp0fICgJMFsEbN1ManaKpCIsMknqTQmbBgvSUIGBBYNra8yACi185AzsLUmmLB3RQqNaJqN1YKZdV2pvz7/jNb9Cv+ZUuLrebV83T9K2fOkF6cFwGmD2DOBXfLkK6/BN/OOi5TxFlo1bYH3eVEkelenFohuGgumUVY8Sw02OAu6m63l10BTS79VJX/ptzpSMtXMrXWRGm0GoUwWkjZAaIc2LumWNNLiqzRItHMiVlEfLPlZ5p+aBFgLx9xiUPDSM6LNdSZjI+L7IWoxgNJg/1Jtl7UICn+4Ew1KlcR9FGs4Hsq9tcAQtoER42184UiGfWuyVe/DCaKJNLjZEddy48IZI3ogWy50lhYtFvJ6rdNhh2tlPuRIx0TSxfYJ6wMpxVtnKSME1YK+9kmMAeG6TFli57Oo9BXxwy1w0QfjxqD2O6t8ZLu6HET2V0Weqx7Gh2g5eKGYTV6tWXrL8+hNDdpPoPdnvTcxB4BygLdnSFTkXS4p5G+PpiGooiPZGQq3bFgUA0sg7PFUesjfPbDKSBi4Cntka3VYBlSs6pEdm48fADHu2tBQwa+Ni1lUDMePdMSgud+8bRTrAhxGafSUAnIvCH0lNOYKGvmCop0GzXcYGZQ57IMqdJswkHjYo2GS1UShbfY0u5yAVLZ2ztYtUGdoPxhBAHO2zB6Y+P4uA6HHb2BIaMQaK0WdUTnFEAAYLXRRkHarXCsrTntAP6ssJktdqbcVvsrRbQYA8XpF5Ukmx2wpSrAeGMY8WVrzj3Kbx6Uf48JyGqtskBvh67taeyDfSSbMhVUjuvcND6FAJqKjbuaBp8DdG6ZSYBYT8PYcB3aRXIBnOsc6kE2wvRE3IxfS4oU0xUmJm4dpV1xjEzaA0ZAO08XsdZihNLoYBOztOIRVnBgxqO1GWrTQQ4vguT2iV//sH0PV4uVMgudG2w6s7Ce9pJgHZorQQrxVWLqtaqkD3kmM9OPqfu0wxna6eJIw6LxE3EyeSzqb3mD4F6bpxV8g40MSubasImH2DKmEAW80qul8eml3BerRb3S5golUVMoD718wUOwVf65iX8mM02gVCBvYK3RRNw23/Ki+unwJBM9gySPF3BpIDhyR17GSvzkfhnmMmLl+PZXbv9gZVuAWjM5cqIIrK4L5QaMWKFZkHbe0O5YJ9SOYVtiUn+0CcFl6Z2f2oj2QlfiCzRxBgV4tIkJuAHFe2SuFC242aYhdhtxHKBDesSoPBrRUonYNKym8bUubJlTtD2CpUahhPkSSpELPs5EiwlyzOGpklwQMMRMxQESTc2vnzk6WkYuL2MK4qmvzRaXCzZkuAlLwaLzNTYaxAq6URt+EcaG6BOaXsgwwnKhppiaZ17DZwpt6iEeV7pqEucofuQ+m0FSEjFjqM4igy/oyTIBP5iFSQltwMOYQ55SrzSIE4gUs3IEOm/24gfI1u9sRpZ/BnYILhi757IKLbrTJJczVTqDKWRp+Z5bLWdK4Md2srplw8C6BioHdbZRd4vH5bZxq1FjJEh4k415K1srzBPxzGfwhA74on0GI4MoN+Ra3KoRx+zo7OFpaXbUGajSGAAf2BsW7c+UeLIvQAsDJRDPE+0kuB61x56rJOXKspYSthrQ3hGtuoFgZOFFnwlo+yxJS6pl4RlayUUdncsOY+X3ypYAJwUQnohyJm2uyaxiGM8ZG6hBBDbri8BMYMnNJ3XAZMqoYQS5BhuBUIBTZgm6MVMrFNGsD28flOhxcXa4nFmtVtCsHewm6VA4Y1tl47frzUnwCkbatoAtWkaWqeYBKbaPNFwyWdpBQxIIag8LQ2E+g8Y/MlC9VpxKwAwxcDLZoZ355rdqun5fVdedeDRdIzWdiEIybwxI7miPihppLhC7p35j0V5zecDKRYgbSMx3sulaWb57rQdjEg0Y21s+Psn1WL+QrpgZtLjD1xS0RtVE+5M9ZHnlxes7k04nR+3JjkopJydBpNBpEtBrFSn3x86Rkx2vVMs53TzzzR/+/nb9QyMX6R8D9wlwLx3Ypn/7nRfpM3u26cTgNFT9odVwA6zeMd55q64/DO5ecPeAex84Mi1IpI2XgwtiOs1Yx/EJqoEvkvEBNrI3tUVhSsOlvabEp9VVoLP8Qsy4mm0K4nZ1h83DZG70FvK4CCLChECLiHgB+GyZbFfw6m7eKY2Z69OaSq7uY7TM/IJjPrFddShVL5Vpb0+hn0pCHiw5eNSLXXkVay7h3megTQsMIEq6jm0BgIWfw/WACwhzxer0gXePPI0qqYFrKzyughycryX8EhgHMtpNAiKH5XNW3dysmVZtGlTptAjE40ol5lxg+lX7egJbJuImC1rpwCgq9PQA8yXU07Re4K2icq5qL1XzhXLBWvSiL87BgaR7RN44cJS46+7YsY7uZvm37bd1/anvXGC71qUrY0/Q/s7gvSVM5GHYqhtBulIO5lv/9YYPbRB+sD08nT/k0teDg91Zc6kxNh2dCY9NRbn4dr27f0vXp8FhvW/7XRj74D9xp95iRz70AXe7iPLRuMQX5N7Fai7iGBfRq3xj3uV7Dsp0yT26jvnvvU/Xn4XvPvgW+dMWdv3N7wIPbQy8c+NPdmz8SVflbH3hUJ+77+O23/YxqBv4j3wY5s256w3UpBQCGH9Vk5+E2rltrpLZHiBHZYVgGWiwuCfnRx1rzoaP1MfgCOXNcbcSBfMy7H2WK7XjdLRLIx81xJFtNs5BW6gWKmna7ZBlO7G1RDVoqlEeB6oddp+WKZcb5WxBqIQqG7JqkJM2h+a+qma2kMfpV4mRmtl6hc6YUSMElUMjTMvIxclSVLZSxaNRVGYGjXS8jDfadD+fJGt39rRLt5d22pNK2pOY9mRjYUmTx1ykCCvJkh0TRdx4yK8puhyx48Qlo/wW+Wt43JrmqblSS2dXIf9WfvPSx3X99gd1/V0PuscXulsg7FZwt4k4mebhP9X1x8GpaZ98SNdjfwK/4G6DuFOf0vXGn+n6M+C//yFnPIdO6Xr0lDvtx/9c158GdxjC7wCn5nvFKSftHZ+Bdd1n3Gnv/DTkBe5H4C6BuG992jvfvtMwfk+7015y2nGvbHJXgOtB2ZFlgw+Js8e7cfQITQe4iOnTKJg1Z7JfHEzK+wxVXyPgOwHuVnBz4OLg+pIX6UFwu8BdBy4CLgZuFtz7B35j7I7xXSf+6kefeei+rz703NHPHtrz/Lbnj3zoV697z5O/dPkfvv9jW/5h09G3bn/k1tBVn7v55XP1Y4/UfvLgP73lI+d97e7683efPl24+9/ePvnIf37hntMXfOXel19V6X/O/7G31d/4tfsfuOEff/3FpcTBfe8vfSH00S/u2PzAo79y5NPf2frPX5i84yNPHsx+6byFvr6Lb/X96Y7d3ZcFflzqn77o/N3JlOUzP+W7cSnw2GdvubW/9p57v/HpPziQf9VHq+848NkPHiw+euk33vPEVefd9Xe3jrziu9Xfv/HCXzj9oUv14q5XTy3v3/HQnz8w/MmXX77njR/7h5n4l3736HcqgcVv/+q76pXsfSsXr3zxbfo5j/7mD8888u7/U5z90Pc/+OIj/7Vy4gu89svQzX+hDI2LF5ljwpCiNp1ZKZQaJVwgOJZiabEGw3VswKKlWpA0TarWFweDfdo0jMpRPOyzbMVcVh1WuSW+yCLdMVq2YdUrpZMsnnZSLLhPVqzcyVJmoZA9ybbwThZqhVyhUdKizHFLsCxAU4BCAk1cGlZw82JMZ5bopk7WxaKlFp87lmHv1SjDgpxvMW080pCjxD+RmgV+Qrow5iuWuCXDlRouPiXXcDLgVANiwwzcoVIlSAcCr738yDlma7jtkwIeAqMDF5Gm/1jlnWh0PsLMQydxA3LCloJIFtjcAsZSIWPAHriQKcKGjnb5EkTgq1cco4NaQvTu/puM3qCx1yDZHBIWEq0ji0VnsNSAVsDonWZTon249CIzshar6qS1YkFc/zSqBp5UVOsBDS8T0nIlqOEMEJ8wpqPTWtdkJGksmgA9D/vR0S5hl9nILFR8WldJlBwvtlCvYQPCSLawq0sbGk8YifB4LA5hNcsqQBjORV01mAxRDRcFcYqV+UYeo/EDhQPMJlgRRvG1FXF2Jb5pVhGJUdolMh7xaZPRmWgiFqHrYCPulAM2i2Q/VfQ5qiAizarirh9QolocVqREBWNZMuP4GKpOgm+TpHiUoFoTCFFHia33QTCEzE1VmGgwJJTv6aGuyqyIL4DAXU6VFs1ScItlMIHwVaFM0ox0aArb21YL01PAYrEOX7RUXqsAe4GKGNrc+Cwte3ywTJr1ofo2pDiYXI03UKi/oQkT15BoCXe9ZoGGbEauNNAss0G0XTbruJhgq7Gyz5HsBSQgFQeRco+nAsnUuInAQvYsNprBhaRhyT0QjvpzIodj4G9IRGnEcszwWxLOX6P21fbHptLhSGounIon0kKuIKkJoB5LUSSpig9KRklLpS4n3FwhO45ACF17dqJUcWgPCRcP7R7Gn5FdENjlC4VGINQ3OBSEUN/wziAqWxoh2WPfnsEQwPjEywfSPGRMRlMo8jAB5eG1maItKaQtAv9cxrWkSpV8Jy/LpV1zzTU+LZxKDrGd59TrJujfw/DPmzReGJKCT3EUqx7o2ayNGDBwQc3F8Gx5ADKcyztSwTxLzXw8oPlsjgbjHkaLnJwkjdrRtkbEHlIECGuFXEASSLqQ71E3nvaSGbjrogksWtlp0tRIobyenxMLvvnR2mhutDFaGS2N1kfzS8srmjyEwr5lhr2jx9phBzvzJgXjUBG2x91tjSRLwi/VYqYODVgSM6RG06EGJCVPimy6p2kWB6+dBylcxcmZbYi/AT7HNB4IOTt9JZttVEnosTOCRq7qDCLBHeW3VrIWUKu0orZS2x8NJ1Jj0XAKxZFTc8lU9PoUSt5Oh2fG01PxmUmUG0tznAZx0Znx6HhahkVhSE3uT0ST6dj0HNAXSzhriUg6sj88MxOF0cWqyWDCmJ1LpRPhw+mgLQmNl4YUFJtJaeHx5Fj6UHR/LDIVhQJMTcVI0no8BvnMRKJpljPU4rMkGpeemIofhrTj2iGCS0vpunQ0mYpNY8mEB0a6KP1M+JAc9FPRhCiSNjkVHwN8dnosy1Q8ogbNRMdtce50KpyAIZpmEK8YgZDqJBpERGn749NRGy2UZxqa8lB4ai6K1YEuGI+OzU1CI0RS2qGJRHr/3Lh2OAb9EIkf0iIAnQhDO4cno+lIeDY1l4DM7RwOAlOLJmYQLwv6pVG7JKmYJL2/IrlIKD9TidjkZDShNTNFUeBga++FhFiWhCQCSE9B5jORIzZXbxRhShN81XXx088shLdxhT6F99JxqZwsbBEnVzwOQzkuvCEcDA4rb4vCARFCSY6O04LNfsyi7YXJXbN5VmwcpyhVsyXvIQe7eF+DqqFPvob954C77eXsfxm4b71i88vPh99zwT11+SYKPw/c4maG2QJu2WD/VtwjnbcJk2kXg/u7izefg2CXgPsA+DD1L4D72qUM/0pwH33l5pch7l9E92oOx+hXmux/FbiP/QL7LwP37lex/3JwkQvZfwU46xXsRxQ7Lmc/Vul7omz487AI78byC/9rsY4C/5Xgviv8V4H7p0vY3wPub8/jcr4OXJfw7wD3k57NBuLrBffvL+P64unM5cJ/NfrPYTzXgHubaId+cE8LGD+4b4jwALajgB/A853NHB5EvOdvop7BM50doo8Gwc30bN5+EfwOgfsLgXMnuAsu2/yL2Ja7wG0Wbb4X3Ef2s38fuD8V7YmGw5Yfsg2maZ9+hv1oLGzpavaPgfvt8xh/BPv1ZRweBfedreyfQFravvnCbfAbw/YS7fNGpImLGeYAuN+7cvOrsX+mwL2/m/3T4N61ebOOZHkQ3I2iLxJY5x2br8J+SCIN9XB4CuFHNg9ivefA/eYQhx9CehXhh8G9V4QfAfcfot/fhHXfzf6jWH9Rxxuw7brZfwz74CD7UWLxE6KtkDTzgq7yWBfhXwD316KOi+B2i/AC4trH/hvB/UY/+4+DKwqrb0Wk0ZSwI460KsZmGev5k82bkCQqSK+C5qvg/kjQwAls86vYX0N6FvgtHMMCP2qKnxLt2UCd8IKGl7CcYuwsI9zLN/uwK1fAvT3D4auIU9DnTeC+LPxvBvfDE+w/iW19JcPfjDDnsf9/4HiPs/9XcGwLGNRJ/y/CfwvSvSjbr+J4Pp/9bwX3dXHa9TbsY1HOW5EHbWf/28E9ew37fw3zFadFv458TeC8DdznRNrfwPYVbfUO5D/XbO7Drv9NcA+JY9Xbsd9F370T3P7vsP9dWCaB591Yn2Psfw/2vRBp/S1wvyPw/za4P75W3I2B+6Lgb/8O7oOC3v4D6aOX/d8A9z5hFfE55Ed/wv7/jTQsYJ5H2hVl+y+ks2H2YxHnRjbR13fBpUX7v4BtKvjJ98D9X68Tcrc4xi5i/w/A6T/ZvBmH84vgviLK/0Mcd6LMP0I+LNr8x8i/hP8lHJNifP0E+1HQLRLF5NU8ljeB/60i/Bzwf8pgmtkM/9zwf8RcA/73nMv+c8H/ycvYfx74Xy7y2gL+WwU96OAPibHcBf5XiXHhA//pM8yjtoL/SuF/OfhfIXjj+eAf/R7DvwL83/j+5ldcgPwZ/Bf9Mof3g/8pQT87wX/5NvbvAn9amF14A/i/I+a48Ca0rcD1GsPwOxkmAv6Z3+Lwcfjnbe/h8DeC/zGB39kpwgalgGda1ZqJG4ccn37JIx7ahcAKW5uB1XumqEV4/R7noy0tnhxH8TJYy/NZjxYTR1vyb663Sy+Au/27un4vuPvB3Qdu7ju6fmR3l33O6geYMLiPQ9xpcAchvmR0EdypXQ7cuQBzKbjPA8xTAu5pga9HgXt6R5f+PLhnIO4FAfeigHt40IF7CGAeA/cSxG17geEueYHhLnm1A3c7wNwL7lKI8wu4i0T59l7hwJkAswouBDBRARcT+I7sc+D2AsxBcNMQlxFwpoB7+nIH7hKA6QNXgLibBdwtAu7Zax24b72uS98EcLdC3F0C7h4Bd6rPgfs8wD0F7l6Ie0jAPSzgHtvpwN0DMA+COwVxTwi4JwXcCb8DN93dpWfAPQVx3wL3PLgXBFz3BQ5cD8DsAXfu93T90u8xviu+J/rjFUp9Xwv1BeeHuDC4KLiYgDs1rNQXcG0CuCMQVwHXALcq4Lq2OXANqMNt6CDuHpHvvQLull6lfACzB9x9EPewgDsl4M6/RqkvwGTAPQ5xzwi4ZwXcW5V+e6mnS98GcM9B3EsCbtP3Ge7Ryxy4JwHuOXDnQtyl3xftIuBCCtzHAeY0uG6IGxFwewTcV1/lwN0KMHeB24swAm6ToNMnFPo7dVWX/gS4OYApCLiSwHfpgAN3J8DcD+4ExN0q4G4TcA8pdFACmFvA3Q5x9wq4+2Q9lPEWBZgjiBPiTgm40wJu7pUO3BUAEwL3eYh7SsA9LeDuGnHgXriyS+8CuGcg7gUB95+v4fqeuMSBexzgngH3IsCc/wOBT8Ddf7EDdx/APAxuG8D0CLgvC7ghBe5poL3nkVYBZq+AC/+Ay/eu7Qp/AZjHwB2EOFPAFQRcWIG7HWDuBbcKcbcLuDsE3NMKPZsIg7AQ95CAe1jWN6TwF8wT3MMA87iAe0Lge0bhu5/HsQvuSYh7TsB9ROA7eKHCDwDmQXDfAphNLzLcuS8yvnuDyngDmNvAdUHcFQKuW8Cd36+MD6DJbQAXgriogIsJOL/CD54EuOfAHYG4ioBrCLjHzlfGB8CcBncrxN0p4O4ScOE9yvgAmLvA3QNxDwq4hwTcuQq+YzCGToC744eA54eCn/6Q4a5UxtsIwMTA3QJxtwm42wWceakDdz6OXcQJcasC7mYB95FfdOCeBVp+EVwG4goCriTgnlPGx81Ao3eAm4O4YwLuqBjn/3GRAzcHMAVwMYQRcDEBd6cC5weYMLi9ABMVcLsEXESBOxdgLgUXApg9Aq5HwD0P9Pwy3f47j/49B0I8An/W7ynlrZOU3uvJsZmYgR5+16TcBXqBtJw7DbYGDbU7tgq1ixhsFzGkJSPhqei4PMbEQ7r0dDwSntUmE/G5mfF0KjGX2k8XCPa9wTTaIEjHE7HoTEo8fG45N6Sju591WpAHaLXsEh/nH0XhTGu1nD1m7EeJTaF0QoiKB7RJIBAUqZEGJ8SrHbq0qFVKQj2KlJaRqbP4pE8rLJQrJCEamR7n9xkWXlMljyQHIvFpvPJCAuszYuPajPM2ah4IcLmQq9MLWr5SM5wzTDy4F6LSZp1Fgd1XLme++fOzv5+f/f387O/nZ38/P/v7+dnfz8/+/v89+zsj/uw3BPZhIEkMyOUIfyXlfaQbqPlPyn7ifgB/58Tvz/rarlwxUL6TlmWwYFpAeWB8wlR31B9pqEDJsh+9qQ8RqJu++bPehj2Wugey8B1pL+2RUOqRn3IXTJIGGsDnhOKWmgx2+zR34lyNBHSagxnnuvBlSwSeM2uIA8VMBR6SMultyXwRtUuwajZ7jS4etIjMe4k4enKjlOTMNz/7s97f2kRqFjUb2A86qxnYeJDhcqm7IVup1RpV2FrA8CHoYsGqk/aMXKFma5T5eVt+QRjRtlCA0bJclreBHWkyujkCZafIFLcafhVEXEWhP+dJh2enR40k8AGp8zKNNnjJejY0KGySSSWD1goWQ9mj2EwKmMiJdYC2gDnq+yo1kvlUdRFkxAEA9VhyvB1OqTuE7BqzIetMTuZECLD/gT9RngVGkxZiiCzSM4+CQfimDBVDYLTaDPEDLAgOI9Ui3tovnyazGGId5YOmopyQtKtiIdxJDP8+BUjFLkrfmsQ7F7RxvJxZRbWmAePwLJ57jOKDu3oZ1RnmHGPlXhmNYgu4IVzNyXY2lf7pt3ULIi3slY03A/OEjHAe0gvlX6ukRVXRktAs8t5nzKGQGB6zuArJuYv2wBeOJbTnLJ9jW2QOtt85hqGXUh4IgjDHFc0Mqz+wExNHxSkKyrDKgvmiVVFANTZzIA2oWMoxTR2lVtwgdSN1nv1Mz1wlqYlmI9VO9JxY6o1ozWYympqKJVMaHmSRSC4rJhC0SoTgxCnLqLVyN3pJh0Bfh9adb1ir/Y60Kr2wYEVNJ+zBSxRG5DUG0Gsi44pKColNzriBVSxumhMKEwUyMWxd41K+JV/Gtwo5c6UpthVnInpwDu3cr48xCegWSJHrYakPgPNGlUlmThBUNlPNZAv11Q5Y3fXyTt0oy362tRVKrWL2OFNUlSpkwMsKenXr0iDaibGydVxUnavy1enw9aJb2/HEyFQ0nEijbj1UtSGySwvG0Of0O8E1U46TGEDiCdRINm9HzpWl7VoXv8G8jRaWrPJ80arLGRYBxXc5NibZ117p8OEHvpIADqWppIowpEfBjm2LoonqW7G0jhqPkksRdBzt2gT2PLO+PHBY0kGLD48S4gWUYb+pVBpJaJ0JtM+KdUkvCyPGDpW7Z8Vm+qiUmT4Mm0A85nH7bVYrxIKY0LCSyMr6pbKjNKTdu14e6cyZrcuORDQc2R8dl48I0irzkoBoP1tyGMo3B8S7JgirySYonGIhksk5Si0pbyBi4+tDxJM7zDc46D2wzjTHeiFUqM4ZaS40RG/qSxZnU+YKzqPOu5a5U7Qo8axeZJx9rhWUwjs3ksJ7KvJI6R4VCoKGzRpgLcKv2FAlAylm+O/G2jzvJcwTtMZC9uKk2GCuKjc1jiLd9zSOrRdHuRMn8k6CFGL0Cr6U6ws0V2rNtWJ71FJpTr+NpGU52TwD4wIHRhwpvrZnMlri2m8+PVeYbfDgSJJqaN2pC5Zhlqr11Y3gU8cUDic5ZWOkyr+RlUmsfO7Rz0clDkMbtYdHO2AASgtO5axcsSlQXTrWReoQ0uKkKIOqIEIIdgofbFbsOO7ivagoD8FySGgb4Kl/veU6bcvP/F11en84uT9Nqs21o9XSMXuGlZYDLC02Ez7kFikNGHOkmGFqNipUOrMSdQ8MMECIMihGLN5QHzvpdSAAYkpikSahD4dJG/moVOg9Fo+njNgMXmhPRVPRgNDFju8GY5MBLZUIT0zEIvRKbDG3wNQVFgrN7ThUw78o9LH2SI37hRJQTgEqVVzVwofisfGmNGqCmm0cgNRGt+rbKWeWCguoptTxpdFKBynZmRK1lgtcrji0b7VJiX1RqJOnDfESNBk92wbWlbanxVQ4kZLvGVu1euPLLw1gtal4TEsdmNASkSltfGoK359NaJBW3N/TXdsPuvRNL3a16E4WD1DteniZuqBs8RTvZs32ug6YzHp2QFaXzpnymeNmGvh5Pl/IalPXB4O74N+REfhnMOjopHgNlKfbo0wXQdgl4C4SDvWgCvMKPbkSrgJhEyBaL2Cv/4nDtO6a+jlslHq2lCEPTBVyq+OcpcybdJwS0Mbjxhvnpmcd9WguGFwz1s2yA1Yzq2a9wI8obZVCTjSqa1zN4klyP+qOIhWf1YAWXTGzjTpvz1mvqKQLNc4OkpVk/UTSjgTm4xFDapupbWaarEM4dIZUnme1K0Jnc2doBam0eoBCTYEQvr4n0yncLThiAlrTCZU6H0pFZ2xpxQF07exaASOeGAOtu0d+lgczj1j0pwu5vXQbgKdg7FNX57l2GOyHfXwUQrzG1s1PWj/EuJSbCz7FEyfYkTa71YAWK7vbWATLv3cBvX/eY0w8tcWnz13g0++AuO/Dr60/aptPvwxcyxiCsI9v99H4OQW/idTUqFCz08R/NI6yN0X4isATBIi4NM+ibEaJtEmWlE7vYyDmnTxU20PlTCtLC4HOyOzhpNAfx/An0Z8lQpDLI+dHlu3wvf+Auj+3vbV9vg5hRy7l9ul+FbStaJoyPeUWQwItOJFiajbdZJS0sDhIQpVkJqphzJRbgO2+jADeyVe15h2FsD2Xc957L3f68i7w33N5K/zdEHa/gN90BeCUM4GHkQPH8EzrfEEXWI7SxxwJiq2aPKRWKVZ0fKtKeYfRyLXxqFEiFanYBKgkryjOHHGH3gqbyd2Iuw8552Wq1VoFlogAin1OFoGwM0u43ylhUL5RY60MUGAy/YWxXphtlGJasOp2Hb3A7fqjDF3BmYXzxUzN9EpQRmWvHuVuAaS6W1K9MjRGp2I4rSV7MecFJk9NOjduqokC6WClWFnu9oCNsF2RDMkgGslxI4vvgTxyRhbcUxhVTR8Y2RIv6cPZeoPVtLOqLBi+zqthcZwWDARGHEBSF+YJ5589PJ0ej06E56ZS6enw9YFAU8A6mhr5QisUzGdySPTj7hZyB+aGyoCL2FSO1uu1AFtRH3ZGESwKUGcF8R0bY5t4PlaRxgKaZ56ANkH6gGwSzWeY/umKmqfZFhg6Q2uF6ydvZiWAGnj5afe8WV82zbJyVbCEam0hsQt/B3iRl2c2kt2gahYg22yxwYwEvswV8YUW31YXYKHU3wkoW6hlYZVNofVKHVZG9vlgrpS2p1mYemcZHdNB0AYLsBJv0q9SFjcZBh05Knf+BW18Omn0FPNeTktmM2Va4cDeBeZDBLXX85gNLDKlBbUm0HZgTvtQY46KrQlQSGCkmMcZDbXaoF/rgTLklQRoR7BEuvFIITh8pnkhi4rBbTZfKAmhXSchBwm1m02AIhRIvGm/ok3QsRnfBhWaBIKlrhOb0zhztjjxZy3BvDC0wXOSpmgv1A56csLZG3T1+vTu3ta5sEcoMaF7NjRHg4QCC5NCHTkLtmm+uEoKVQq1fMEsCtM/9iXb+JSdyhNQBCKdWKRBl/WR2NnxOtJkk2YtwJokPCXMWK4GhD4/aAfYWdc75OsK7FexWKyXnvT/YlUbVXkmby3S2pg0OM/jgGVrK46VOWxiVHVNZgbIhJJQsNPv2OiBsZJDa4xlfsbAF7Ksf4bTjNI8hcqSPcz7OOutkWGfHh1u7bddEBbezWuYI/CbiFBz9hvxsQgpNpNLPK2WFTHKkq8V2CoWqgLCqYXpJFYrpjYZtAFgY5NKbigI5u0FW1tyRwJHorYB/AyUxatftvzStlXst1VQ31t3t7bJMoQdG+U2eR5+heEmsYcIGFOyAWh95IyN81/v01/5+lZ8F0DY3msZXwZ+J4uVeehsex0nEI8apDoM3wYcl40OzYKWLkS9Vl2VF1XTFJtPHauNcK5Gkvf74jiT9JYLROIOz6Gfd0C5b7+2tW43Q9jn93LdvrUX18xvuQ7cp4WU8HXs1D813g77tAeMRzovGBmOONqneXqfT//6vtbyf3zMp39rH5f/wTFnzf9MzKf/a8y35hnIeJwuSeixkG0SUtX8CotS+xBLLG3loar8e/GwT7/0ep9+9MMX6peCk+E/gvAej/CXIDzkEX4Gwvd6hKs6Q73kTDcaVsrBvgfcEw867bX8Jz79FOT9BLjQJy7smP4UpH0R3NN/4qQ/8HGffiekvX8d6c83fXoM3PO/7qR/CupegrS3rCP9MUh7F7jud/o82+gHwmaZV9w2KPcRcKEblLT/06c/C/m+uI68Pw75Pgfunnc76SMP+fTzj0B5jqyd/iVIezzv00/f6aR/AdJ1vQlwvOtC/RalTw5DmxwBtwfgj+Sd8NU/g7YG+PvBPbhGfrd9EvgfwB1ZB+xdfwx9AHC3rAP28WWf/gy40zdCW4A7dVipD4SHV7zjpt8O/Q7ucQh7AtyT4F74qBP/ZfjedL3zfQWUJSTaJqS0zbbf8em3gfND370ZaC/0Rz79AdHv98D3zRB3N7iPirC3gv9ecPf/kYNj7nehHODu/0Of/kFIs+kTDo7Pw/dpiPv67zo4HgX/s+AKn3Bw3PF70HcfAJr4mE//MqR5UCnHt+D7JYi/7AMOjs3g7wb3olKOz0Gdz/cY95+H8JhH+KMQPucR/hiEZ5TwFC41Yd6Vy/pGZgnW1AHcFldRVXvAtLKBRGY5ItmeV3ySzqpb41CzIO/C2yZ3QNxIpFLJgLCNki7D0iNdyAXCrKwPJ7sWZAXYjXJcYMw0q02Z2ihN2DmLCy6Ag3lfU9RC9ouTARJshl1OpSj1A1ZqQoMnaumMCKkaAyswYFXyuKtoDPQ0jHk8skG9mQnTMmtLuE4x1GBRAbqgc4Lnwoci4RkDa6nkEpPn02LKRgHrYhE1kKbEha3US2oYMiZxvX2bS8FOTKpdDOSMtkzsbPcfttGKpLF4cwhkQ3f8SpGaQ6LJCBorpUMIy1YsiRYaqgBjNeapBQZwPSN8edJCKpKWYKVUYx2k+AmzaRVtb9BHUpY1nMvVug51hbvQ7kpX0qxX612J2eku2O37tJ5cl9YzFBjMd0kbBKh6EVLFy2jskVrbMnpnsNFj4/3GfhP2Vov9Buot7sOG6DGGckaPPxS0+F+fohqSFb6XWXVizieoTJEpJBPrUCPbQKWSeEFaPuO0XqYNaI/P0agUlfS/Q7u6PmETqn6qcVhT+CR6QsXqwtZ7oUW5Ja5U0vhwNm0VIXMlnuTIeyytUlsIVAsri5nl4/JXEyZySV5Mmp2oFXILrN2SpCg1j3CCrxy3z3Kl1U+k/VytsOS2lo3Fpc5pCvNux6bewQcJsi05NqYa2MEjV7a5JiQz5JELtjHJcHJjrzMRmvyjRNQlEy5Ld0oRLNVOkxwbaTE0rLRQ+28/a8EduycUKXBlihsADizZx1Q0fCCJKpTjiSM0pMam4hEIQRG3sSOpaLKPzdQmG/NGtjh/XEvWlvBugazDyW/kWvzVzDiBo2F/YZe0xPGGBy06JYGWWqKpDQJ8u2bGq1lEgXh4IE9XoIOBVDAkNt6S2AG0uwOptkaKptHqixau1TKro6MsuFCp7e2FxkLZR+DOV/dpU5mbViMYUGugfv5rU/s0d3GnMxZeaZBdNOSSlnd8FZutUoZ9V7becVaJ2RNRazuZ1H6xcr7iFTeeqWdwTm4Xn5Jql7E9WmdLvB7mOW2iUCuhVl+Sgja9ATE/OhWp1FajQFyrnrkSaAL1WXnGHEZBPu+ocZM0e7fL2zO3nDnfWAhMVRamWbF4G0qC5MDsBd0re9hzfw3Wi+Cenz1Hb9yt6W8Gdwu4d4FrJM7RT4N78OA5+mPgngH3+Gdg7Zw6R38R/N2Qpgd+bwF3F7htAHsKwowPXKS/973b9R3w6wf3zvLFthuG79gXL9Irr9ym7//tbfoofMdno4lwSpsOo77W5OH03Oy4Fp+YmGIz7VLvtK+LayZu/Y2j+eVj8tafNIwdBeI+SYGLtUL5+MlMrXSS7RCflNekyyd9XYb4Y0mPo8BwTgJXPImCfidxNjlmXIuzgL+Q2wc+mB7gh5jZvpM8hdnRCjJ7WUYM7FpKK3a++27WJG2hSnlk2Q67Y1MCdL1FcyqJqc8X6qT3uKdhD187uqCh4VpppEhVz52XmVicSZP27uYy4AkkMlhqKzFr5Oz7HXfGBSgfnrPasYeIudufdu3tZE57yP1/pzaAzoMmsPeXZz7r06/7XOtafBOEDSnhA4oNi8jrt+p9fwF7/b9Ye7+46W8BDtzqj539wlv3bdU/D99P/XjtfdrzV2zVh16zVX9uZKv+0M6tegGc3J/8PfhDr96qRyFe7k92wfcB+P44xNk6r74KeyRwJ844ZdgLcN0Ah/uyUxds1ZvfvcrvHwu8qj2U5vJGoA3v+BfYQwHOLsA5Cd9/9XXYJ0GYTH8Awp6FsNsgbBPAXPaa1jzjAHPws74W/AcBts/Yqj89DA7qdWzEaYMz8H0HxL/ecNrgffAdhu97R5w8oo/59Pc9CftZiNsGcS+dv1Vf/AnDd8H3lQa3xf2vcNL8ze6t+kHoY3Md/XwQ+vh2cM8obfzCnq36KqS9fR3p74W0T4N77Bwn/wa0xWagwbvA3QtuWWmbh78E+9YvAzzU613gfwzyeCv8yrOTTRB32Zd5333bl5x0zwLcyBd8ehJwHQZ3FNwquOznHJjHoN7fAtrc9NLa9BmDdjvYvVV/Zmirfu4u6Kdhp292wPdDEJ/tdvrmU/BdgO87h516Pvs9KAu4yPe4/08DzB6ACW3fatcnBN8HurmP/Bc5ae+Hcj8JaRpK+adf9OlP/MCn/w2E36KE3/tvPv1uCLsL3BPgblfinv53n37uf0A5vgIO/B+A+PvA3a+0eeZvoJ3BfQLC9mI5ke4B/uOQ7vV/6dD6KYB5Btzebzj98Tn4/iq4yl86+Lp/BHmA+3vA81VwXwf3r0p+9752q37plVv1I9C2N0Nbjow6bfsB+D4f4q650mnbi8AfArc66rTPHvh+EHEMbtXvgzT3DDo4HoXv+yDucwqOPwT/Y+C2DTk4TkC7PweuENqq+yHNx0MOjjh8Pw1xP1L6+F/BvwnKvm3QwZG9DsYj0N5D6xgLz8M48MNY7XqZk/5xyOcSoMe+ddBkF+R9C7hocKs+B+lOBZ3yLsN3A+J+67VOed8M/rvAdYec/B6FfrjMY154DMeNR/iXIfwCj/DHIXyHR/hfQfgBJTw8Ow57hWBQ67F6rIGeXAAmqZ4i/AR3FnNdsFnmHY/YS0jBft6+jZKxTikyQbcPZCkeZtOexcWGIy5kxA8Ezg6FvK1tkzjr2IdAHPYemW8F6U6wTUpL6mzgJRLBr50Lyki59isds8AdlHt3Azs0CK9l6SH2Dmxw2P+ycAhe+GFszqp3iLWLkmVLwGQ2wh1DO3QKX8Kjkra5UWzb3CjWMzd3jJNbA89PjneM8s5KxqIVCXxrREmylepqh8JzdNvSczSdLvj38W9eGOzuyXnFkg4wvP6WnYkHSsrubZQPYbyJ1Dbp2y6tMxAIHi2QwG8HcJXeaOdm5yzspbgT9HQoNhLhmijaJp93pXRX2xb+D5xVckd4p2NjdELhZjDAx9IkW3w2DbvBRuxU3EZZDSIbv8UinysGzoa8PNnoGnVry6S86+YCpzthO/deFuFGf9/ZlH4dVLJAh4b26Ug7MPloWAYCWoTBHSNmlLGEtDkKnZB2vo4jUm0tPjhYu5kYzrt9cn3iVAJ24MC3ljSSwpcbVnEut74ZprU4bWcvpI1KGcrmF6Yzs2JCozd9a6VeEAIJdgqW3LIr1764kiKVpK5u75j1WaRzN5CSeu22ki9FjaZ4pJtcP2dN/nUSC547owWztuyjuQDyXY4r4zVLK1/mrCuV0OZCRuztqwWUMQq43oXkl+0jikNsuC2CkvPigJ1F4MxarVyh6oxlrEJ2AmZNeZriAaNiF4dyuXnv0IF6LZM1A6gthZBy/cYykL9o1WbkCBZFU9opTOldgAhE1zLFwk1mrqmYmjxSTYhjfyXKfRCaqhVIoZQdPVXJHne+nHsJNkpmWxbigW7UF+mdSiDQci/BJnXFo12L5LeEhWpxs1rltGleX/X2Na9SJpab11Ow5GkTA2ul1hjE3hpK76w3wovk2w9lsdyJ4pv5A2s8cQ300Y7DXeTK91Otea8nWduhspGpagOJ5XLmbNKqM3y/3BHR25519ZFyBbPmfkS9rmkdIMpFBN2jeICI6xjvEURpvKPi8WmPwSq5XCaX08b5Vl9erYtnrDC9WaZGZukoLF1Cu+1YivGCxQJtjLwpqKUqHujna5VMLpuBIdV0V3RN02WRc5fwxJWwx79KOeeY2ap/PrpVfwrcWucLz0xs1S+d3Kofm3bSPwxhj0+I89AZJ/whwPen4OQ+HSclYR/Waswr957MX9O8+KWDafitNupqhIV278sLaR4Y8lLaJiLb1mEaqp/PluuemDomcOegnFnvPbhVP3iQ6xdKOvXzQ9jAQad+LXIbmcWaFZjOLJTNOs5CZjGXrNfM8kJ9sVXGI1OopUnTFl6AFbKzQDYWvvpaCxDlA7DDERbfqeZyLutsyNNJ95x4IJEtZizLsTxJUeHxQ9FEKpaMGhPh2FR0nDXi2Ria0mBI5bgLJ4NavtbCLpQtKzBRWGkfM4hbf3m779OcbEeZuRRIL54fNrktxXBD0wN2n9pvzWfk98xt1U/NOeei9pnZOu/UHoufs+admsR55SqMkxu26v4b1h5T4V/aqq+C6ys4tGUtbdXDkHZuHelfOAb5QPq7jitnuxB26hjT7LMnnPCtgO/8GxyanZxJJuWCrSYXksSBKSaeGPPvE7xYyDuIJUQ/bBOzGXzYh0+qgPuBYzPVlLDamC/i29GaxYiwp22j1FLrVb8wTUhLC34PQLMKaqJB+XRIJNPYxSHWQWsntZBsptX5FDbUa/SMSI2gpx7u5HksWtXFkGR4E59ywN3hiesdKSKymUQvcbgCo+L5t9rCBSBXbWYg7NNwFNh9ejv04SlwLx4FegBa2AT9VLhhq96OnpvvlPxv2arfedNW/f6b1qaZrpNAX+Cu+JWtaKM+3yQ8I7aBLMskDesKuYxSZkEyZvQ688oc4LsF3O2Q/6b/sdUeb3f9v+y9CXiTVdYAfNN0SUtLCy3KKiml2kJami5QCpKmadMWWlragkDFNE3TJpA2IUsXHMcqOuL6qYyfOuoMin4zOs43gtaRUSzjOIvj1qrMoLigjJZFIcjSsvY/5953y9ukgOP3/M//PH/hvLn33HPve967nHvudi7gXt0gtrsu8G8GmADvDtXuFDeNEdrdghvHXHK7K7kd3n0rpH3rxfPg3tug3wP47GdiHv8L/OkQ99pLiK8H2i6kv5PmIdqpaPXAUJQT3XTDlzTjGs1ufl+Aibolsuqhu8eodgMcuwXa8h1i3lUBHw/cKubdu0AzAJB8Z+i8u/NWMe9SN14870YaIzB72VEc6HlBoaS7dNYHRYomCqqrKio40z/UibepVi2vE80xNFlbrG10zoMeFHQkBw2CGpXM7yQI9sIgtgRuCiXzv5XJ+Yu1o/834HdPjVFtA/hP0xHWPbdCfQF4FdLkv/9O8G/dKtZxPbjXAPxZQrMc/E6AErb93211Ocxd9FwM6bJSS3rSUx9VS3D/XIvsLAjD0pMxeJSmgG0583mIkZrvoTe/ok2BJpCDdJJG0pcTWiewt+dOGmnYRkRmK6pyubrRboY3drmdF6MBfYvfuVdeLJxbwlPhdlKyxJgt7l/QPg1tCGDEufjfgT4LefMOlzetQHMHwHzInzv/MkbVA2FcFaX5YuJzQKyowaqpuj7DpV6IChrS8nNWnkVrYmKIwyXGDVpP/SHq8vz9Y1SrAOK/HCPQLAP/uv2SNUhwPwBwpYTmTvBvldA8C+63AKZLaP4E/r0Smi/Brfj3GNU1EprTgEv8t0gzCdzzAeZIaLTgXyKhWQbu9QDzJDR28G+U0NwJ7mcBdBKaJ8H/qoTmT+D+EqBUQvMx+I9LaE6De9LXIEclNOPAP/trkUYL7mUA10loysFvkdC8Be6DAKYvxTbzJfjPSmgU34BcBmiR0EwCf843knT2jVF9CPDsjjjVQYB0qG/mgkhxLRTCvhgl/F0IU34ZOvx9CD88Svx+CBsMEl7vcFnXqEGpb7JCw7dyJyJBh4FWnI9nQlM9xc6ONryHKKPZbKEWfOxNZrdowZS2aLb1aSRtLVT44LTsxZwoccJA285Za0wTVkLT1QXsVOtcNJjgwKvfqQvPsKbmsXOeqR63lUbr1Kg7cZcuu7IaUVZJoOikt9vgUePglNJgawsMtNqtpKK6hGO3GfXeFhen7zU7nB3M1W73oDAQPV3mjgLBYBBzgaZpMrc4TBvEyCaUayIdDkJBeuAeYNS9hHY/H+pR/zcj5RXHE54IbzZTk1m4f9eMeZPdTCShVUukPu4ol1qKYxOG630wEvZ2UWvoXqo/MxIHLfGQ72DBwkuYV/YWhmSvabWCionjS7Th1ASKEvNwlB5aZUK+jAXLUmdItnkbGF+ER5xHBoWOFMhRADtQ2owZdWpOSzDg6PCkopAF6JG9LVhNh7QvpY6LjNBol0aOiiafi26Wg+pWzcj8pHQC49Qn45zi6JupZRV5BkF1Z8fxOW2Am3umL5Q+uZgj8aNkEEv70vNIzgv3/SM+Wk4nfL88QJYVrdDtu4Ijg32/JuBHmgPyEL6V4Jxn6HaGoWIzM4vW79RSHDJA6u1t5vY17MwGm4rmWONDhAljdYeZLbngCNzMSttjxkldZsWNJsEf/+QiV5QX69HQIox88PgLvJRdS8aHryhHm2NqTrWxMpsyfCC9M471MwF4bDQeewtqSA6nxxsE3YyvIrRquK3NtFJcm5o5rxnPd7dxLqgU17Kei4svkjMC7iklMVZUXSf/REkTln2VDMs+J1gGCUi2vdmjxpFOARsFWd1OttvnWmqxYI5Hw3Je9GJ7F338mEiCooJb9HJVV0Swesn7ec74lSBOkR2pwpqQLoQe274mRjLuT/bGqq4FSATg9ac8cFcBjBxbNneY4CP4Ux8yrzieBI/D5GP2KFx40pvzaNTYqZosXrcjE3pIU5PVg3ubTW62+MSZs7C7PS60sRPo5ad4OTR9hcfF+dhLBK+Jho7+GhOLMxoRFhgkmklTa3Q2dbEvwk/gPs5rczu9XoeVfzVZ6mzLYOqIeIUex2pBMF5Jc4fZ1OSlP23mNjvvcPJlG5jFwUfQwpzIvbGqZwFuuVcsyyfB/SpAhWgViR5u4vwa4Yw4NVchYKkFDXo+n/tCMQgNI+FmdwGBRsscTpdVMASHCye+NrTVX2H2tVlsnO5oZ3i6U17PF7J4rIy3bUSCVjuo40I9c2jnGNFiQQekVM3VfQMLo9WPJ4eiBVpCP5mzDOr2+lzqJh/dY8Km/TKBXO3Q8kcBJfke+MqgWT+S1Za2poAmUkpFaw0uCum55i9lFchp+dNfWgF4l1ADZCleBh+SD5DyESzLhCukGrvUrWa3xUmEBCAXoUHj/KfQPcrySvauS+Sw1RKQUYFeUZa0WrAZqpGNAmlXyDR8noXA2EE50GM1oIZNR/LS7oVXSrmRI0R+uBfKCYK+UnZxZ6u5kx3Z84ht9s6oONUTAD0Ax2LjVLcD7AD4S2ScaifApJg41TKfuclg82G/U8kZpBPs7TRylnWJhIjapXFKDNBJw3BsIkZn62W8WR4qmtTmthaHaI9HCEQxJg8T+xH5vNyL8XGqCRPiqHtbfFzAPNfpK+JUcVfCN0+Eb58Up2qdFqe6E+BJoH8UIBnC6JmyAP1NzLNbropTPQTw5Yw41ddpcaryjDjV7wCegTQ6AP87gKOzx6u+/tM4VYE+UYWLqPWpG3xrsPB9IJJzsk1e4i5oLLB6m1sL1he4CohgYJ4tYnsIvzGETqPh6bCfcBen/QQXc0uEq1OpzWE3NXrCTOJyk/BtXrtDzY5GqdPo4kqH3YPG5R1d6g6btY1tlkknFc4WjtgDJUQN36XZQXOzg66RYU0nyz30ZgzrHDo3R9ft6UWt9NrWJu6kHBJTtRP49NAk6YQs6OBlGzTqLDo2QkveVKxbm2goJWv04V0loJttoNRL7EXEh0st631WEJIUTc0AcheZ0MyoxoqAuwpBiLrsFjoTiCszUOM48c7mCJhVGcpImsASVXi5aJBb0Bw8dPmJ2zCntjdDl4MXq+FVMN50spASm+gZMcKyls90KC8NvXHFbUfDU26aK2nc5Wz8YViOo3S6a+YHRq3hvsouqR64N0hdwSXHERD+vhc5Hu0qcq8mqZ4CiA6vNnk6uB+TG3RJs8dKve1Q6ZwjsLYOUr0yl3i6PDQrqMPJublEGqHFWGx8CCAlTiEtRHmdTgc0CRhdB/hoFLSk7La2Z6pTLTS01eKjvz6fnZmagpSaTT6vhbBZZogwh6SuykhtzUD7V0ze0d1ENJthbAFVlGYYEOLNValZOb7R6NgNH1xJSM/W1XIWEFir4ygKJItfOOWCbYKS0IypZ0RrKIoyQTloIqlNGfQ/MpWalevLSM3KZg9CN4HLm1cXMsa9ghq59LjMFqjVDmszDFR8IJWL0iXnq5voEVMxtsiIpCIsQFuLZkerE3fj+BwOejQaEqLNkmd4DvB8HShgVnVqLo4xIVydZm5v4Yac0FzneNJJrR3n4amlS85eAr0fD2QmzmZt8KnTsOdxWKnFuJxmtSedWj5Gm4ZNnARgdHPos4jeFSm0eXq9GB5kJCZW5tYmelgj0+egxYAlyvlYGUkjCkMTXhs2ed123GsEtdZmt4DmLJuF5+kI7uyAyukyuaDGMYNTIgoyjcMhZz5J3pubePmCFrYxAmegTZ6OgBbTCri/0dQKI3i7WlxflVZMfhtpGsqDa1OhDOTmr7lSnsMimChLHmoLGyuW2wkVAW+4YxvvmmjllLcKKSEl4KVXKveJHul1lNJXLHUKks7ldrL79qBOWiQm3JusbEIMB/xiG6Iba4SlflY1CN2tF2ADQWpLQDAMQPOH2ZeQZBiaqRMKRIOdCQxQ8bpxKlCZCUmqk0hqKh6b3eBLF9p4qkcd/FrNkUJAKP5MdR1v84KL66ImuSWs42qWWFc8uLvM7JCuR34MOkVEJuhjBaCjLIlTfQh+8VXcmRQud9hGSsZWq3Dtl5hj0KrpoXQ37Tgke8Dk4XwfMpIEvtbE3maiFteXV0ilnXD4BHigtjIX4d1EMSTwDhxeQHJoC6iKAWhEUEv9LejVwHAA5zw4G+e0iALsWbTYqQ0CkRPA4gYQPJrM6hczt+lmGWMQr4IUJDUyK9lOa5Yc93EICgreDNHG+BKFOVfvPU0sVyT+ZjQdQvSWdbzumKkecf0tSqembcP1jQ5Q9BqdnWvQFCB3LxS1gSvd4MJ33oHUrBeAAqpk0QQRLiGT06jZegOjC5utr6sjzcIft+TXoVnfqVnfpVm/QVMD7UlTjWq5ZpW5g3prIGsYiroAjb8SFVyZoq+rrQ5MkxCMWlvNIsIvRINnnc0Nyg44JO8MseAenlNeuVzCK0tZb7Gs1MBjFT5Wa0q73M6V9LmKPldrKs0tK/GxCh+rNV69xluq8VbyqV6BqWp/7FSvxFSzf+xUI+JrS5bWSrKUXW5vdjtxw58GHXqHl/7ixj5yaX+z4vXlNdqAouJTNQem2erSFNubm+nLeIcxRKqR8yuqq2r5r6+oaC4qgvRXalZpVmvQoC991GhWrNSsWKVZsVpTU2H2wsPZpqnB91UbHS2aUnyUVJcBrOAu0p5dUS3WLJ5hlipWTyE5PWQ0ZPPqS8oB1bzS6lqyrIjyiX9FZWVlaDUSLZ1ojPZOngkNMok8IosrrI6l+CjBR7HG4GzRtNVCeO3SGs1SzWJSMK8YkvixU41OhBZrkBUWkbVS1qrIpf9lQqoG7Y+daowKb70pwj8JthJUfdx9atUsNbczh97dWqtBse4xN1s15Z4ap/c6lHZB/2ZHrqirwvokTZTo3R6XpqYDjVRp6NCduvg0L87rnOmGuloiE1lkRaepUbOiCx8b8GFva9ZUa5Zpai4xB8YU1BhIgMwCtisMWRqDVmPI1hhyNIZcjSFPY5irMczTGPI1hvkQhMFaTU1tbbnGsLQOqgY2F9Cn+VRjU6qW12XJ5WuVz5ulgYcWH9n4yMFHLj7y8DEXH/NC8pqNqWp/7FTjrgTpUiuXLuX6Wk0dAzfWLJBWUNXbmmEwjAafL/o3Nl5fQ+UAkddX7Ir4XoZzcx1UbfXFUo1PxzWcIl5kldloDSsv1tSYO1biY5WmBn7hycmwulqXuU1T7KUbFDRGd6uhzasprdMsc3i7hFQTrikFScjJAIHjUdo8Lxbq9BV1IXkdNw0kSTWmWtTcKGSDNFXaZPGWQrTaW0OfxXY35kylvS1EquNnlNQaSBlU0rKy5mYQ8WXUhACOVDRtEISF1KZBZt0afZNbs8IJL9JD4dVUV7JSrLV6q+mjRn8dn2pifOmKkaXFy2ryA/+S1EUgCvlmJaSqWQEKrlcDrNJfPBBhQ/W+SVNjxTlUXDGohRGfVcPZxg9MdcLY4vJalFmB9bWJZWWVG62CUaVYw5ulhzxpN7vt5tEq7sykupKKrCKar0XLhPqKLRy4or9LnXaPFX2cY2WJ262hqwyaupVFvmZNWSN2HNJUUzFV7Y+d6tWYavaPneo1mGrOj52qOr+kVpSETL6WFXmyNB6txpOt8eRoPLkaT57GM1fjmafx5Gs88yEIg7Ua2glpmpeal2qajXS1vLmuihonTjZAqgE6If55tJCgFlLUQpJaSFMLiWohVS0kq4V0syHdbHwv0GUDXTbQZQNdNtBlzyMzCiDVAJ0QcqKsOktTrdVUZ2uqczTVuZrqPE31XE31PE11vqZ6PgRhsFZTaihbojHU1VRomjlzjOUG7qgA8poj57UaeK0GXquB12rgtRp4rQZeq4HXauC1Gnitzsb3Ah3wWg28VgOv1cBrNfCapYNUc2WJQm9YDp0hwIZyTTW4q8FdDW7Ar8CAFRiyAoNWYNgKDFyhsWo11myNNYcQbQ6kmifXiivNkFSluQsfG/CB0dG/giJWaMqs5QgrNHp7OcIKTRFgAJhSmDcFUp0r67iJERI1QppGTM2IiZXpSyvK2XPFxaXLxKTq62oI67BFTaPaCsN4W94KDZ7ecsIvrbjLPY1V6zRFbrtlHfzSIPhltFUGTZnd1eGuouU1aXpllaFarmUs85m912nwuZI+V9Hnag3Vay9BEqbNXlFeuzS4VixoxCFeEjrVyYmltVn6ItnfpbUtWVuRpDoFUy36sVOdCqlqf3Rep2GqPzqvVy2sKzHUBjatIqIHRUVv1Bjhx6jRe9DnQUcxdYFSUKIpqQEoRgBHNeg35aiSQ4uhV9clXle+tFiuwWMdgO5pJT5W/YA+Nn1KyVJD8frm9QGpWtpAJ2y3OrI04NKiS3tZqWrG1NWuWrpMhkXZXsU2AP2gv4z4Sr1hxOi4psYOuks1fa7C52WmOi/eoK+sW1YeiMVZHej9Qd/xWNf/AF7nh1folxYXybAV9AY98oP/ro2qqNIXN8uNxFUvJ//J36Iri6trapfJMpbtXdBAUAlV4alDc+nTDroJtXWGJUvLZHXA7FkHerTV+gN5vWUMnhyR1yy6KiBXHS7j79baFSU1ZKlMVurdMC42dpTaf2B93Vhara+pXC0rLjTBqKGWF39Yqp4mh7Mlm5umJallptRKU2ptpqszl1u0wtUS3iuZJhTO3XukWLwxw91EL5AKDCipqSmgSzh0wRcnTnFNQ3gdrgHQxSMTtwhC34pYei95E+7k8NhxAbvJ7vagvQaPlzdvIn1N4Eu5KWPp8gRE5z5ZmIQPZm4AaLgz/yPTCJg/J9UlNcaqmkr9UkOJ2lC1fGldSU2tGup2hrGivLSsLiaGxGAjC0RZO71WbLr8NG0Bf5SlgNvn7QOuLM62Jg81qs5P5nawhTWHT93qacEpc+kSm5UeC0/Nw/Uytsym4a/cEaJIM0ee2Aha9uVrnXQINOLD6QVUwT++qrZuxNcH4KSzzWxjoDoNX4trgJ504qQLH+qMVIt4P6AZtx+0+PAwr7DzgaNrAMJr5Egcw5ktyG7D9Z2pndewzRNmbyehNTHYyhW/aGUxB5zYFuf0RRPk3JYaVpGCXTjrbPuJs7kZNy+61Qsd3FaCRWvA36heKNnCAKgMqzrDrM7wqjM6Y6Iz3NGXthcCSBujg++H0AhLZXaPOh8IrdGyzR+NXQJJmr0ZF601ajyA2WgV1gmBhLOGkA4pmOmrZDtB1GlCHDvur+A2J7TJ4nqjL39DCETrjC6RNRJsk1hDJDepCoWEl9TRhR8n3ubaikvYk1DJASiQQBJOhmEXJ6TATITgrmDg14wrpdwaj4TGY7WuC07DrSzxa1VolcLM7HwMf4ubhwoB+qJEUBAGnCkXtoKF2VOjr1Q3cvt30pZW1aldaG3GAxngZRtqjBX62jKehNThkWW2PKjOaNaooZZh3mXY6c6UVp+X3ZrF3UjXbs1UlzcL97HjRhVm+gjPtJnZx1zDXQJ7Db1mygNaBWf3gr+FVp1Gd6h3WHFPNy6bgsvZxlneGEkMVZGtUacTextz8bTLuZbK+6u5RAVEOR9XwAj3+vJ5BDI7k279GFkszDodbQ4eoV6MpMUcH0HFs88bzhKsKBe47UIgtzqNVq2ovLiUAiDwujlGh9ljEz6Bs8Qs3pstXZDn3iW8k7tNI/C+3g6ne524kCvdekIXZj14MwWWo7nJo2Zug8Nqdgt47g7KVLpjTr0M91u0eG0emi47LQSKFbVrpK8T97I9+t9xqscARtxrx91YobaiASLM8QC/hnp80Hc7zC4P1jzOb25v0eDJGd6PSgLnpJ0Z/LpbQyf3w6LH/MjsxfyH/MWQRh9UC6+63udZoy4QuOQMiafm2tWYvB0wizgPuGsMpkp9tamuRr+01lR7nRr0Q31lCXTCanr/+tLSTMLtFzWZmMErh72RSDYqslvN1PJ0mNCDFlZjYIesC5AktclUWb5UvRC0kyAh+pXqRUFD6mrKKyESRk1LbZqT2pQegmaRGhMJSVO8mnsBHgPCqf8Wpt/hfhe6uxavxeNMdKR6Msn7/0hU/eFCouo1gDcA/grwDsAHAHsAPgdIzYVSmJUBj3yAuQBaLT7oTSV58Mj2kOqa8qq0In1tCQji2pLiObV1esMSHCSlpabTn1ZQWVJzm/iEwJGN1mDxzpM83xwAdWqOD74rx5euJny6oDi6nXiBLb3opYldE0rvIhVu0MHzcA6r1UU9WG2MxR625aB6uZrTQPBS59RUtReGQVjlmI8qsoLP3gSypbhSr66k/aLsbXRHFerXVvM6stzFdFDcc+URiKiHpjKlfgmofEuLSU2JvngVqVm+FIQ7aFmko8BjbcWnHZTUgtb1VvrEY5y8aQ4qu5jJGLxWlHkFmfKnnjjVxz0oQ9RoeosXdNQwjOSi8lSpKR/0BVzzwbBCmvaX41SPAlS72SWzuGsGtTPoVe0WD+Evy2ABlEvehBKemiEuGg1HH5LdolQD4m5fBxf3bexWQNzLROhPmied3TqJbUvcGmtOJwuh7wCdVLtIXc85sxetIT6nu1Hol9iGJv4eKQyRmezn/3a/EqeK2hEn2kAH/9lXRH8/uI8CCNeUYhWy2OyOJuCeNhl6axLtwgJoeINrARQgOEz8znEUIoExxNzzjJZywL4mGaFQbu8Dz/96ZWT/IpxJhrD9AKHOHAeznVH6apyqHKDrVTGdEnAvB/iVBGcAtxngXglOD+5WgBcB2JAIt2EJ9tUo85JJJfpkI/876PMldpqdLUOi8kcWKF4SQjLoczV93sHhXqL0L1H6lyj9aiHVDPpcTZ93cOnhM4M+V9PnHQIH6GPwEkeLb1rNpVFMUhVjubSjAS/ujZfaesC6JxQ8fjV2Gaw+WC2SNnz+zTjVRoCdfxHz7pm/xanWAEz7e5wKBg5Wh+QdO9+KU20DKPlHnIq/JJxZrOMH5MbrTKsMVSbo0cqqivEQExsXeazslJLkILVwNuy9ONW7b8ep7oTfkiVG8WRWM7uYudHchA0YBta0/4OADHUHbqqzCEtyzMgDudTYuBE2eGz+m5ipCTQWAeSiBQkxDqVmVnwCjFbYrFQHzqCDKWsbPdkOKba00UGwkO/9lWNVXwPszh+rssJv3rKxqkqAeoBWgA6AWwDuBtgK0APQC/AWwGcA6/ug3AAeBlDWjlW1fBGnqgQYfHis6iBA4iNjVREAlTvHqgwA5UBTDzAJYD1ASR2ELx+r0q8Yq1r132NV40rGqqLNY1U3rR6rehjg49fGquZDvI+7xqrW1YxV/QHgQ3ivHfjtAtgJ8GuAOwGOQRrD142lZQe5rcYytzjdbnaOn+URHpG0OH1uD8s4j7hNDi2fcecbfVwoEnMj5JHbE5GgCcZho1O0XoyAnqAclSKgWEelFKrcqFQ4fUQvtONOX45KjONENKdCD26O/iEhApOFrKS9MfTpZg+qDWnXldZm5Ofyh6ehZmskZcSqb/olx5XaDHzrg7GqtwGi25x01Eai2/H+Znp8VqN2uDgnO0FPjbkzf01lLe9EFZG3JqGuQ9tA6hLDUnwWL62tI7Rt4sFTNEDt4YykutzWdom3mdsMxO3y51V74Uq2FLyWB/QEzpgCvQi4ADea8//ETS3/HKvS/pPVa0lrpvcRU9ki5BInavgT1pzEQHUCt5zxVHQky5+ppfUG5QIqfWmCPSiW/xpmqsaHeWHH66dreU+6LGLJisuOIhbzpcdhbeFyY/Gze5cWT5AJbeZ2ewuzkY144cxgFdcmjNgmlnOyIgCJN4ixLbhcDkuKTd78xIP/YlmOQo5CTUJZwgevYMEj3kzli63FO1qlGI2GGv9CIjzb/R/Q8O9y49nbiyQzCg0XxARZ+0VTCk3CQgQZLWarmpqipmXJFLaM4D00xFp5+VFWXX6U1ZcZxdPV5rWhFU+1x95kpRfF/yAF5vLSCa7KzMnQzE5Pu3pm8tQrE2LCh88Ofv/dN1/8q++tP+/c8XLPK38+eGV65pw5V+HftGnTplw5fozy/OCJY0cPf7Pv4w/efetvf3/noy+/V8RNmDztqiu4vwnj4yLOnzz67eFDBwf2f7bnow8/+vjLwyfPK6PHjk+6ImEc/CUkJMSDEjl49NCBgQOHvj18YP+XX/77oH/wPAmPiomLT4iNw7/Y2DHRynPHvzt44MDhoycGT31/9Ij/xNB5olBGqGJiY2PYX7Qqgpw+9u2hQ98dO3X2wvC500NDZ84ToggLj1RBKP1TqaKUFwaPffft0eODZy8QBblw/tz5CzhXGxYRpYJgFRJFRSjOnzp29Oj3p5AmLIwM81aylECFNOxtZ08e8x87efr8MAlTKhXs7rILkJwyUgWvHINsA0snjh07fuoMchsergxTKMjw+bNnzp4HqgjVmLix8XExEcOD3/v9lChMGQF/4UoF8D84dOaCIkKpio2HjIqNOH/iyLffwXefI2HhwGtMdJRy+MypEycHzxKlUhWXkJiUODb89JED3xw47D955kJYJGTguIS4KHL6+LHvT54ZVrJzNnQ6np59BwXK5qRmeKiOz5DCeXhSoYdRv7DN7aZ4lRUg1FgtlO27gFP2uIpopQsU3DBDIxgHod23hzttSuun5HR/0CRanfSa3DRqWIpNsALf7XhkKX1kHNplB8QkBulc54s/jVftAHgX4AGAhwGeAeDvj+oB919+OvL76XvVC69VN6ozFsVEm6Fr0mZn5jfHRDcKTsKIFl2cyIoWkkahEfWmh/4rXvUswn3xqpMA48CdDvAMuPsBynBpMbWN1NElRsl/Ul3AbJcK/0mtQCNBSs4a/eV+SBPgM4CdAH8D2AHwJ4BXAWjtobcPE3pNsHDVDKTxTsx41cRJSaopAFcBJAOkAqQDaADmAOQCzAMoALgWQDljnKoQfg0ARoDFAJUA1QC1AHWJSaokgJ9PSFJ9BKC6EvxXAB7g54D/O/jDx0O6SRAO/qfHAR78SUD7c8CVQfgBoG0C3MSJSapOgL4X1/Q+a//9IkK6exc9NEcn8evQD9nQ/Uf7nF4MR5zEr0MAep0svi4wPsbDv24hDnokbhpHkn4v8iAJ7+XCpfQCP8xNdNw7uLREP/cungdd1NE/v9680SG8D/yLwC+kh27E8e/j6Hsl/kVcfB1HT2lk/kWy9F7n/YPheb0AOomf4mR+IX2Ovlfml4brZOE6Wfq9svR7vwnvWcSXAdKC/3VpfC6cSOhfl+Z39IXhRUH8fPmQSRdultYX3i/UF1l8nSw+Xzd6A8tPjI91YmT5B4RL/b1S+hD5F6w8dCHyL1j5BMtvXbDyDfJ9fNsIxV9viPINWv6yNPn21y3zkyD0F8t/6v/XU+dfx3dOPGzQcf5F0vdzfgyX0gvx+w/f3PvR98dp+acZG3XPznl74YqbNb07Nv3+dS5cx4XruPDXuPBFfH4se3q6LqXlY96vA39A/nDhr0vohfeH47G5USACD2rJQCWDMFSIJOHs+/i/bq58RP9oeZaxfdqoeYbhSbpvXpeWOfgXSevcP8/tEtLb3jgR/UJ89Evo+fivy+K/Lou/SBr/1cbFvQBCfHQjTuYX0uPoewPruJgh/9d9Qog6LmkDQvo6Wfq9svR7ZelT+hrQG+Z5pFoDKBwSveGBh0A/AZj/SLzqbvi9BWA9QAfAjQC5NpI7m+R2kNwmC8lt95JcD8ntIrmdWheZ20nmziZzLWSul+TPJvkW+N9BsjNITheZ20rmmkmVXI9Rw9uDqTJ02ZtThwR9b9ov41V5AOUAx5+IVw0+wXSag08wnWY0vRbp8FdKt/5J+EaALoDbAe58ktH5nmR0HvhN4Y1QCXN/vIGcFIPD3tqIhmRSlnITGXSlCdTjLmZyoOa6uipp3k7YGq+6cutIfbRdmzkvM4fkZTU2aXPzm/NymrVmq8U8t1nb2JRr1lrM5kaLRZtvzW3Ozs/PbyRLfV7vStI+LzM7OzOLNGrzs/Jy8ublNjbnaudpsy3W5vk51hxtY7N2Xn6eNr85N09rzsnLIqVLl6tLDQYC8TK16uws7bys+Vm56jTOlke6ul5fUznH2tpobWqyNmXMy2AWQNB+B5v7yM7Ly87KXcOWvetTM+Z71tB7GtgieAZdnAVvDPPlSHzwu5xbEvWIl2yr6/lNY57MzMw1kJCBhXgKpPRyqhjxpfUZqZY1/H3eAha3pqlHYKV/3P6qAmoHT5IWvTV80ZqLxrJL3kSjhHwTs89UQI+li/FHpxz11XizBsuaRmYqDjddBbUWxR/G5221UEIWieAVddTPz47hxWFqs8vldgIfI4Pp/hkhmC4EaZFj/jIwGoPZqRUmgqU/JMXsa8KpWCFlITHeyDBue3M63cmUTxdnVUdiW8vaSQ1QeuZIvlvqpta0aNJsqhdFCNs/5sSRY72EdA2/kY7RN9l50+M+0X4dZxXMR7htDhZxwxlefORsa3Sa3U3q66oFmyRsip1+F0gIPiEUYsLXIz90i5+5S8C5zF0Op5ltnsNJRR7PFx/SUjMKJCOj3epuRBe301EjzqXiUjgbI2fy9YMaWTN5vFYrGscYzbBYTIwgM1vfi1fdC9D6jmhn/Hbw/+o9UW7mgXs5gFVCUwn+FgnN+XfjVdPAv0ZCMwH8cyQ0fwGarwGWS2g+A//gu5J7GcD9O4BKCc0z4O+V0CwHtw+gRELTCv47JDTPwHvPvxd6LmTc+/Gqm/pGhteWlJK6suwVwqZSawvI98s16S7OAfiAxwcArn1HvJPgTnBvBSizOhxOde26rmRS6sQVVLaSgMav7Ggei206ZhUSWrXX525jUoPZbUFbKWnp7Io3qTnRgmjaBKVP/muazNZWqLiX+TVcLNk2PB5PogVENG0urKnFkHoWvka4rzGGsC9m+GQJBVe/M2NIu9XRyXIOXDnF1MViFVsbfS0QiV4D5myzMktKND8yM0k9Jy6Y1bAOtqZLG4DY+IHGJASbhOBRG5cgfYPFDdG2gpKOyL3ooGR2z8UoAvK4uEqN+1ONVTWlJXXquip1bV1VtbqurERdXGLUL6+oUxuqltbVVFWo9dXVtckkDRIXOmR2f5lrkSadpGGns1BmBZEGYk/Ah8uMibJwNFjlVHuc6XxO2bxeV8GcOa7O3Ey7k96BIohyumfdBDoUXsult3h99L4Eun+Z6JkVNTOHFe4YZJfvpdpBLyzkNvHyQHfvhoWGy6WvQyo1HkwlExeryCSAOeDLomexMIwlNBnwUwDw2FQ2pvp1vCri3/GqhBj+LyxG8qfiHQlEwf+JLsEDT6KOjomLHUOa7KBndlo81uaWtlTS5Gzs9BGzvtloLWkpZVsbQStw2Bs7O02WTrPLhxqbGze5Zlo6O8mw4mS86kmAVoAMgJ4TILsBvgO3Fn6jT8Wr9g7Gq+LgtwsgA2DZKSY71WxZDou71r7BippJZR3eCjYPdPR5TeSZ0/Gqd8/Eq06fZvS7T4/UwzcDznV1kiqZsHwPo1tdGsM6EacKxN0CuBncSIvH3Yk4VSDuQcQpAnGPAS6F3b4g4LYiThGIex5wMyldGB0LI+4lxCkCcTsBl0q/JlzA/RVwV1OcSsD1Ae4apRi3sPMmxSeAi4hm/PG4YAd8QKhC22kjxsrsvBVZWv5Xzzmy+V8OsVTA5PEIzqHN4hC8IztLTwyrtHlF2qzcZaSyKD+vplZbWce5svPmFuHYRDscr1KQBNXtw6zczMMjyy8ZcEt9rWoQue12ixUKPyOvCascbcwuu8vK5p7nKBNUPkjrPPy+G87uS6qNTFC9GJGg2g2/SOmh9CaUOM62TAtptNjmAOB0tMfaCgi0pzk318TWFOmhvAW8iU0mGEzUbGCrZ0GjE8UoopjTBQJV9FHpavI6TYBjGNzMhvYwmQ8EHjQQUyCy2em2WE38zgKGs7M7B9FadKObu7LR2cQFepzNXhPKPcpkvslbn7tGbXKxm/eyFpBhh3u8aiJJIl3XJKlCfFogysTsrC9oBqXQW5+/hu+2IK0bIa0skD51aUmqeyXuJyXuHon7LYn7M4n7jMQ9Wna3sSEJx4p27hpujBLqW6/0jFdVkwpy4GLpMoEvTZhhQiR8DZduYXrQdLlUstfw+4tNlM0FQKmdawoMsTcBn/k0vWryyCjp8Rd4Q30TLIa3mjiW1V63z3pxvK+N7SINIMErG73iPY0mUNQ8dh8fahGspoTIi9bWJJWaTCUH0i+1PvE3MIv5D5nA8gySXs+9uJP77eJ+N0A+GTysnjw9a5R8anc6vNDNm9plfuHT+QBuY67JLPMLhHxAk2Djw9RqtnFIN2/tg/Oj9XZaxPSLIBMdzAIja5aQjW10EZFrpXR3vcnj9LnFjKV7g0D/6BIQHcyCSKjq/e0ymh8akjD7UvPe57UsaHL66Okus1dwOtvEwvBY+SIwO7yci92fYOLHpdLS4lh1Wz0+h9hecgI4bQA+C8m1RK25HD4DOAqVBW/EzBpH5dnfNaO3cb6O0TAUw63M0rQJhvtes/jF7FK3YIE2KJwNIPtASAcG88XlcVsEt5kufwteeujGa3JYYdAgfEue/FuckE9qMoXMzAj5LZgYVjwTnVMQkpoXkFQ3pJNAook/Y5R2gmN8vi6bW01UNwYu7qdxE0h+5uj5KZZVKy8rmJSjxqi1WWvU66xCTa6fG8DfI/Q7JxPvD30HlxEgEkPkwPC3v/FgPzeO7Mm85DrnCSl6hG9CQ5TCK7Pl5fcSvDONXE0Wzhn9nXQqhxMPvIjBvZQgfexoK5bbk2dymzvgBaOSCMJKoJPIcjEnm6iixHqbb9/opfmvJi/MGaV+QB2XNXjclC9H8UJTjhb2BYlNoMsleuxCweGWTt7mUaiWsZtrFyuzRulvURuwUkO7Jntbm5OT8iiJWs0tUhQ/ERaAE/pIKRIvtwlILJvdRBWYGt6XJSWSMwK9vzsIMyI6kCEJPpApSYDImCTxAOakqQsMBnLCVByT1222rBOulhbTwq3O8o8XcTSpUEL5ayivLeRxotIGLS9OD8LNgyapWuAQQrhNyCb6PcFJ+ApnYrtrQ1AJORg8mK0jiMaZR6USbvwMpAqRCac8TM9+JXt0GYeqPM15Jg6kaLerlStC9HF6jATDtT0JRtr2RSxvcpq+lH6RFItSJjAEPgLFSyCyHU8Yc01UTEPaCXFkaN09hFSO9KK+kk5eywmZJzRpznR1QMIsewIxVKcCpqSiJbAcaDZa8e5mHLmAj8q/ccDH/Yr7FX25o8iT7Nw1bOKe7xa4PtcjtqB2e6NVQi0KPY9YvsL9GjBEg/psbuGTQ/lAVQqT2QIlabZ0SQLw0Jscj5IDXo8FBh/N94cgaUYgMYURSFuLdyTSaw5GiQJjBJbKnJEJoDaFW0XF0sNmTXfv03Er981CKOuwTHT1SB5GJQsb0XIJBIZ7nA4fM6JOpzIlwVgn2sxtMoyN2jKTIbmtwRyWH6iD10v5xQoyFepHgiJBsTIvaP0IrkDLdeZ2vtzaeX2ifYOk/nphAO8K0U4yuHbSOW+U/rnN3E6vgZJ46Vkrib/RSm8yEsoaV8NkyA4X7bp5zYd2BtKeQI2T+vLenb8HUqIR0wuSkM7lMFusraJY4mkZAb1eBSpQkywU71yymtiJcm4eBW+zMXHhIfJpAeRTPtGSoeD5RNNpsTqbcfhqarc7HTh8FspACOF0dUpuc9IrIKgZkaZQ+shSrB9kDFHPH1VPh88RGZ+/hi6eUPlzA8RfSVaSRy45vjqgDtdr87P55FogrV1kF9kz/z+oqyM1Xs4PXQPNFnr+xYQRJF4byJmAuSvMPJHHwDzroHV6DplZcKn6ON73YGKX6knEKTdvEthbuj0euygm3BYT3s1nasabtyQdBx9ITyqHDHW5Wrkwrjr6hHmbfGHCic3oWWQzc9yLRS23DRWswFG+bGg8fDvkSxkpIe8UXKQu4OSDZ52AsDgdYj9Lr20RBSGMTNGs+zpPyKkFORffvqGdPQ7qdBz594JRZE6oesILi2a0hsDXLl+nVnRmi84c0ZkrOvMCvsXETA0IOLa4OAIrqGSyAKiYFq9DjnU46d0CMqzZ4nbKcc7mZrqaLsevsztGpGp2t8pRXsFkgjykBYQvjwv4XIdTrDbYsOVzQ1AKjfLEoNXJULJGd58X5110xLFwtLpVnwcDW6+1U2SAXhUhrS0y+fc/NN0FpHDRKHWF3gqIJ3BNeBES39+wywFHoPHKQQkyhE693ct06kcWhRpXMBnBjUn5eSNRp1wgyWHMPXEYKhdX346bngjtIZ4k6JJUf6Hynrn/KXGPOt/EXR8vk1TAk4nbsCXRawDJK/MBSCqpJPoRThpyl8ab8HhopyysyWla66PjEn5yUhTXzMlPKbLVBaDx2PhJSZRlOHBgM5Recxe8QibgmJ0d0AJxKdQs9poBL+cYDJGz33hxLD+d/Fw3iu4N0klo2lafAxotVRxC1YuTXL34qHD0cYUHR0ZmiQYZYn4qyodlHEPS9KH1Cnafl8lLjdYHoHjOA5B4uyZW8AAkP+4MQIJG77Rg4wtIk+2fYLzTRaHAYFBe8X7LEHk+3cfqbKd+lPbqsndauRF3J2uGbrNjZFiXPAyvB4cYYuuVBXWFDtoQPChwstnUKm1UlFIcq7vMbYHThaAwYBymO6DZdBO711YyABH7fSkxLs/BsECcnEAG5XNpTDjS+QbJDBZ3I3noecE8H+o+maSs6LJ1tFA9rjio6BJHF3K1DtU3wUXnQYS5X9oTgh4urvQwyQztmk/G1Cm4ugSX8BKokC5WPgGpWNw+u4fq+5LXCUj+OJZULAXMD7LhGD8dI5FbfKswBUYS0LRUuZEDNAZJTOxaAr1sRojhAlUDZl1OaJEBrU6SRgDe7uEaZPC21/txospGWsjfDUHLfsS9YPRUud0JGToyiO8jRoa0YfdNHoZ3FSoKFW+WjKpL0nPpoSbOi3xs7SDLeOlz2EILdPkcHqupw97Eqc0MCbqEk048X6/BtZqJxHuRtD1eN459uATqtVlZa7gbtRaQ5cDfFsUWRZ/xssYRrPS4ldl8Yf1VMlHD5AJuepTNNY0YctA2Dj1Gs68tcJWHDkNY90mHLQGjAVlGN8B3dJMuklQ6mi6DPSHd6MZ190L3yJYbxZkoHJZkyfxiY5agzJ2UQw4DeULXNvK0wnuaQnSKIMcclOcN5NPS0P0iKgvQHpleahLM1QUEgnrN/LwRSDmdgGdnLZtCdPy9+3DMEkvuLxu1vgcUZ302VqZ2yWciAu1aBSCgfbcHrkkg1rzB3urz2gLTanOHGlXdBPnlIq1EXT56XeU7QFOTd7RFolB9wYjuekQfvUGOGDlRTA0t4LaAbMmCNj/1IltD4vvITjp3zPu6AnwbAnzSDQaIJ8P3+HDcW0Z2lV/uWhm/9iVbs73E5a9HfWzt69PFo+hCTKcJ0GIC9BZJJ+gQu0nq6wrwbZDM3XZK3NI53Q2BihSa/gnUn+SYDVIMx8NIVNdIVEBEypIc0SVHcFHI8DM+tkelbsnoejvlECf4hMynGGkVF3ZPSTcFB66qQNNrl4i3QEpaSX3BUwn2Hqmpn1FfE0DYYhYSQOsSISOyUFQ6aDwpEusi7qexoH4EAnQbV+fvqbiEPHRSW/WmLBmaCv4RWI5YG5RYG5w4OyhxtizXg/DB8CMYCSDXBifXhiDPDk6eLc3NQEYYLoCJADLtSDJtELLskWTZElWf3Slq4qowNwk+IpixHDqcJi4PFvK91Uw3dUvxLMEgATQlOX7Enpg/+XBO+DXSV/n/lX4HBIawIe3/tuP5kGuD+dWX2++EnPykX9BilrF/Sd3RpX8QG+57TLx5oFBzc1/4cE0kh9QtG6V/4yusxdnGzEZbulCqmgK6mcBgaQmxPQzS0BZzqNp4yMfmZnJrRp8vYyyJOeMLEL5B8JTHIHhkTtLfn6Xvn0jerLmMPYOoyIMH21JsO9sPVVx7kTGLr5Hb1ScZyKJNHH4LIK/KMgV3Xajym9aO/CaS22ovzm/eCvkux5wVOYASRsc57TmyAbPP02gSNyPy2Ea8WygIZSDGgzcPyXAueguRCTipMojrrnZq7zsQKxsXa+h3XklO1F5kzs6LK5JoWlpMCAYmaMLWFLAbSzZamd/O9ph9WjdaO+B0x1o5QthXJSxs4MRntdlr0+NEpEAvw8v27YjJ8ttQZMny+GLIxXaqU4yIIgbxEgXnhEvarO6WrhLJOq2VYvDSOLe9ka6SS0MlkfCuwtEjyin4WZsgE/kB0/UBq1DyeYXydpS7erJw+ejtyGY1u72NuFkSAyXjeehMW0UcW63rZNfESHcXdFqbgm85E9YI2XpSq9MLPYIU14bXwskpApHezkZfs9geWHuXtAa06O9sw7UHe6gx6/J23CM4k7yzYnR5SI93mdp8rY2CTsn2PoJQauZk0kfXjZ6XnI7Thsrnei7OxJWXMQcpcFNu0FcJ+4KCjru4PWziXllxIpvfqSJBiQUm2+Gx3mfuEBc5heZIS5LOVMxfo4YO1oETLOKEVite3+02BZS31+OwhCiDm9px/WohqVgZau6FV4+4nfv8lm+zbCt/wNyM0ArY7fKB3LThKh8/26KdN3K2hUMEbGWST8Dc347zyLPIylU/Nt8SZODk1w/iW76x+VnK92ySsPoist663ic9aqCWrMDTTRAgE3GYxfKX1e4QOySyc/kNFyFm5XcBTypFpOLvl8mTvFDeaWdrRdfXX2QtVDohToWnFBE4Py85B4FOusvchOuG0u+FluJlKJNsv9yIxf1P21EnzCNPA4/fSdwxHaJ79HVcXL4KEPwSBE6wy7wel6nV2W6lyzuSTzI1iT2KzyPfIYRr40w7AkLpdDtbSaZfKgwnmH7FFpODhND15CD45g7+cKhJ2NvSZPegZmZqtSCOD+dm+l0uR5eJbWsIrsesonk4jzRcn6RaKHHPkLhDy1vaePICfHP5fKY2DaSebKknR+rJlXrmSRe96TlaUSayLWCs45Jjhc5L7ODoHgQ5OYcdSU7PCrlbJevCeAx85IhlxHi1neZVLnltzajr+uyMiYnLi5AfyR1FCc1AQELaH5g5ciH3sw6mtx+4IfTcOIook+RIIPXz3Jm4TVTC3DeMEUQqTtew2R2mgIEEDRT2mLIUQhOYfV7nKMHCtpfQJPS2g9HeICzbj5bERWnYucdRXiNdgQtNJiwPhiYR1tJGeZnjovxa0PQOW80OTSTZNjHap6MKa7I1tYxY/JAfcXnjFx04xplEnjf9B3v/WO8i2bcKw/A2idsqcTdJNhg3wSgbhiYjlpqtLpvg4kOt7QKuvV2YGXG78SCT+GbhUItZPEmG3JuA7eA9HV3rDQyhGSpJW9qRNIGOiscP1znpHhjy+w42p61uTFL9TeK+2LoiHk8z+TxWiyCaMI8Ft7NNnOJ2eKVuk9XhsLs8TuEwmsfEbxmXnMi0iEhxp2ywbLU1OYUZAXSK51lh0GJy4VS5R0CuNbe2skMm9BypMLrDchXfTUtf5rfK/NLToxZnC2Vy5JEtmlHCVLmownVKJkjo24S1eKGDgWYE+YSCJmBdbsR5ucNQZg2knjgso4/xhVVPqmsIrc5ttTbDUILbJ8x2nWArNFu8/LbWrkariYuDNlM62RhKbR29jritzaYRzRCRkqZIvRfb5kHP3ND22dkV0FwvYRvIBmn7FBNql6UkbhsR1rGEJawNIxo3ci0RHXZQx9GMkbN1JEai/F2CTKD53dklba0bAvZ/mAID200bZLUGwoPLiA0h8O0hY7RvCCZUgLzF4WzkVckNAT7phwfwJa+1V0Adup/cTe6HOpQhcVdL3Je9/1YsoNH2BVks0rVK6UqlaQNtT9s+TqTnq79tuch4QDoUGMECp9xDgo92srlXly1JdbPEbZO4L38uotXu8bDNL+sle7845S3g8HLQeSnZ4OjFTpyPSSV7bKPPx3D2tYRumm0D85j4Od6LEkp781EJ2akVybGWdtk5KzM1RCNDombIMMJmTrpvUzZZFTApcZEJLH7Jwe2E3O0ydQj7RgHX7uWHSOgywbgKuhvQP+m+W6+5UTBVIdkLLVqpCMSDTtrcIeygD7J1BtFsL72YBN0kjZvcAykD0YEN2NrWYm9j1jSEfa58ZeKRIffwfdzJzvY22S92do0zki+Z1XJ6bXjkKeAYksXutvjsIDPcVvM6q9sTqn720j4njtyzLvS4ghYB5Km7Q5JBPJJm9KXkPY0gCZJt/R1RwsEZ/ojjN9wxigzBOwjYhHib0+21jcBazcLsgKAKSSkFJCUkBzh58hK+s6qmiDc/pSNN0ANC5poEGxhEzzvMHlcT3fXJXBYcKLrdzISMQC3aSeP/UscnqHyPEdWNALcAHFWEqXw1Yao/AWxbFqZ6C+BLgHuBbn5dmOo0uJOrw1Sp8HsLwKMA44B2J+B6EhIC7NzX2ewebnGQXrBL74/zee0OvHgU7yLtRKsDeLOctrIIRw0eG91S5ehKJrV1lTnZxnm5nZ2dvHuu6M7N5l3azk51hbND4quE7xR9ZXaJZ2WFxGNwtnE+nQ7NuCoKi/PDCqkRoQ3KmNlc/qBtofPPhauIihQWQng4vbxLEZEpsQms/G24ivwf/y2dqKJAwhMS0CpWJbgRiFKlWgj+JeBGIGHh4fl4NwG4EfCqhly87D5NRUHBhS8CN4KCi3+xP3pvNG9eMdUj1kQbKAksNJXdzyhxq9MsOKdpp5VPo6YeJ/Wk82TqNK8FsDCGduMVSG/kW75b9El8ue6GR27UfRL/ls4+73mtLXlGzkvxSTm25KdyGDd+nff2CR++8PFRXfydpx0re47qltWP71NsPqq7cdlNC19xH9U9t8OmvaPuqC6/0de2If+o7svPp5984qqjugl/0MZciDyqe/vZgnm/PnZENyN3fMX/fH5El3GnuUH13hHdNbPm7v6k94ju1qonVsx+6Yguva7ss6jfHtHdvrzghZ8+fUT37oKbm3+55YjOa/r2gO9XR3R3KA57kp48okt8r+LRO585otu7ZVbR188f0X39l3dfmPeHI7r7/VtvfeDNI7o1qYu2K3cf0f3uw9WP/urAEV3pDWe/bx8+onu85vbPHpt0VGe//+in6nlHdXc8ffbTiSuP6kyP3Zjz8E+O6j65/+mnfv/0UV1hSVt9e99Rzl7ygaKfpzywZGjt87rjb56pfq/3Pd0/a2KHizK/4cLzDRdunW0tnVBayOheW8ToMjm6/9a9fnyo61vzKd3nz93TPXjj7t5rN/1+8XfrT+r2tu76tf/1D3pfSPD75z90QtdSsOzm/72qr/d25SsvPPTWcd3Bmbf+zx7t273PNG2KnRR3XLeyY1dM1XV/7d1y35gbZ9zwvY7c8vjfZj/3p15d7uTFi189prth7D3vtS/9Y+8fv77LvzLlmO6dqebVCx/e1vtr8qhe95Bfd1Xsl/knap7q5cuVr2/Pl/7i/D0NR3S3rfp+zXPPPKfbsjZs+otPf6t7KXPuc7U3vKb75tza6+aqD+tUe9UdX1/9F13Gc09a+t84qHOVzoj72Rtv677Tdyq/+dkB3Zc/3fL3uyP6dY1ltSc/bRnQRR95+bqs8I90R+efuYD5lbvxlbKtY/t6147ZN6b+ut26FH3M9xeGv+jl82dS1n/X//XC50L+PH3uo2zbmL1C/tz4h+kxd+v/JeTPje+3Tj74xIdC/mhf/v74Y9P6hPzxb1gwZdpP3hLy51cLf795/+k3hPy5/t7O3rcbdgj5856p9OUnnM+FzJ9rT8781T/yXxTy548P5Nc92/6mkD8f/PvNxWNue0/In6nWv/pLIj8S8mfoV1M0j9+3R8ifd27ctvTpfZ/qxrSVv3VF+we6DX/1bbFP+lfvZ3/8tSPmb5/r/n7q9bLSCQO9s1+ZBfVrUGe2OD3Ybs0eO7Vz7QJZ7Fnv9lIchDWDA8Pwtxl6bfzF8Gb4hrPJp3Vnk6MLf/Lx+MKzyZMKN6ydDu4Zha+eTwV/emGBUQO4OYXXl2oBn134+LpcCMsr3Ptf8yB8fuGUlwqAZmHh6j3XAp2usOKnhUCrL3QkFAF9UeE9TxkgTnHh87klEK+k8O2/GiFuaeHhlWUQv7xw4+mnSPHSNnIufQLpv+4a8lnuSdK4dxdZ+OhDRH+/gViWXSCvfv5b8gfzX0hB20zyQWURKY/cR6IPZZKpD/aTw9MukPRtU8mBRb8mJ/NuJcWvZpLHD95GXrraRfQ/NZF/PjCf1G6cTx4/MZ/cbbqNpJ3eSYamLyCfDz9M4h+JIOPmHCUxq+8mrdNbyfs/nUui376GGKv+QH7ZrCMZh0zkj9f4yNeH/0auvfEYGZwfRR6suYucXXeITN9mIqo195Is5Qpy4zkj8f92HVG/9j6Ze+IXZP+z08gN5geIaso35PZHrWRLkoncW2gj3XuGyTWeShIZqSX/WDGBvPUbD7nxqway7p5dou11kLckvryQvP3fheAuJLVnwX2Fnnw3Rw94PdE26kntjXpScJceaPTk+q0Q9ns9+elrEP6WnmzZDTRf6ckbR4DurJ58rywiBTFFZGNCEaRTRJKmFZHrU4rIM+lFkGYRmTu3iPx0YRH5W1ERpF/0FDBxGmAjQBv2eQBokXQCQDrAOYBrAK7Dex8BTgJg3/YZAH7FXoBGvAcG7+kGwH7NAHA/3mMKgHcaLQOwAPwW4HOAV9FOLtrlA/gDwEzu3QUARdjPAnwAsI+z518OgH3/IXprKOPjQYCpXPrTAA5z/m0c37/G/halNsCtaN+X4z2Tez9+420ABwEeB3ABXM3dhGoC+CnH/3y0Hw/wT86N+VTLuU9wcW/j4tyNagqXn2l4iyrAdIAhgIfxTibu+1F/eQQgHuAoANrfHMfFx7tR0XJxKxcXf+dy/LzPlcXbXD5g3lUBGLkLVrB9/5Lj5RB3M6yPi/NHgL9x+fQ1wDGAG1FHAYjivmcQ4C6AGi5/MY11KDO4NLdxPN0LsIa7e2EFp69lcXyc49Jdx5W3n+P7NcKsjv6Cy7e5XLk9C7Cfy2OsDzcAfAMwhUvfytWr2zkekgC2ANg4c6f3cvm6h5mlpHXHw32zVnInxASO139w4b/BOx8BGgC+4njG+nwPxzuIUsyCQpSX9JbdYi+9o+UR4xBW8YZl73Ri8XZvnOLHrCtUp25AFa97xq3751K7/sftefy9FOEcD/BGSAvpP5lHCOpVt0F1rAa19w1gt28GIW9C9v4VPr34ynCuXLCcq141R7Q8/5luYkZx3dnkg7rHTt3ywRjPUc5/WveVdc6Mm2dvWBh1fVLO1f9zy8Kdb/s3bIpycf4HOFUzy8D9/jnD7WzVNnsySFhU96nXVxxdWltW3mb3rnA6xGu2uOIi/cPDD2eOVE0bhPD+4e7MEQSfP8sVB5mf+LzVijYhPAEEW7g0MH0SJP1dkvTVI9MnnHHvz147NjhW6+rMtTsz2rMzG+0oRsjj44h61TiiWjL5/4dLhTtVY/rUfiVZcupo47unftf45DGFgqQXDoXPPt1f5SdjFf53Xlf1EH/6EPGXnCb+h4dIcuySuMWbi+I+jF0ctySu/O6iMR8S/8dnw/xPnq060W2OLBse/GjYMBQ+5duBmqHweHCN+XYgK4yot8QR9T2HafNWp4N/sIfMzFwyZ+nUhusbklIyyzLL5yzOaQhviG1ItGVUGvwKZWKDZsl027WF0xom2FL9t/lST3TnTUD3ie7UCQ3T4PcnE6Y1zKzUNCTZZp7onll8ojs3qSG5QvHzXKPiCZJx9aeKX2zfNtk2w+8Pm9wAvycaatjvvkb661eGFfkVNCzMHxsWPutM/4SUlAalzXDiNoPBf61S2TAG3LtSxjQoX/DvnGD7nXL3R4onFNcqHnpvIDYhrDAJYCLAVAACEEuG/eHwqwIojFMSyEO3YsnkBlcp6Q2HcW/GQb9h1/GwJKXmuj0ZS4g/PqJ2aGZCVMYdvYpj4bHPHFNFZhrvMYKoLDp6fNx9CSkbj4/b9OkQyfpkx67jf0qPv+ZlEnUmcijlkEr15xilP1ZpOBStfLHQcEilfAeoTGfuO754R2n4VbsxHlHvPODfCBxEfzVgjIjf/cVQ2S4CX/m/pGYodl+kPzbyD4WZh6KiXipcaCgaii0kJ3YVbT/ZXbWvPyyyCnKlojdBm6RV2Z4rDDPENOwecPonkN0DpPcn7xEVjGYLif9mUnhCXTg8+PNe+KZE5ey4PVGLSXrNUIoa4iuTehOSk5LhG4nyDPFvqsY8wLgSWggD6qxf2BQpSJNQlNQ70UjUQAmAtMrFibYpked2hy2ZSPOQ5CsKwwFUPVcsLjkVTRJtKf6FUE+GB2uGF38fQ4YHlw4nLB5XDvgTN9UmNkANXJhy4tXaFP9UZRG4xwB+nyUFuBvT0JesWjKJUhhOkFoD5CZSqHZiOSXAO5LwPQAJPcUOxc++silO9HlmnOhzJxr2NxQ5FH6FotaOKU0yLDMn7EzogRK7jZXY8ODXw//efhu4AvH6bUWOD201diWkFAY5nGgY002Shwffk1C/sXbzujrHSlWi40vbi2f9x1dGK/3TlYqcLxvqVYZDJLHasbEh+cQLtQ8O5SYo0qf2Q+20PDiUR6LTwvpUaWH90dsMJ7prlznebljmeHBoLhljTzlRWKvaht84xlzjqEW/pxY4DktX9QKt5YuBP69d7ai2rb6v8FBYUUwDmbFr++qfuUoTenatFXlX3jd/m8GvVgwP3iVwm3Li/vXJkA8nIIV6x0TbruOFCa7SP6/dOHQ9/a13rGpgvxi2C3D5PRHGwFSXQardkKppOM2o8N9+mqWdvzOFYuuGTw0k9Ly5dksr8T93NqVt1zE1eaQoqq+xre96RY56tqqXpKQ0J+wk6nMDrp6Ntm0nb7n5KvsE44m1C/q2nXzk5qv6Cr9XJD5aVNdPZi3ve3JdAqjw+Rd+PpSbteRFxewqf0JYEqSgTkk0/HxortrgVyrJrNheMiN8RqLht92x+ywOxawb7Fsc0f2FJ3ZBTZ9+wehXRVocN5ihhu5UA67wRDfgEy9cDfjvByYbPx6IeXHzJiVIFuWsqf2J8IbEvkS/Oj62NyxFkXIbvPm3m9KMfz7erbxtaG4W8R89v8WSZRweDBvePQCh6qPQziaSPtra3qXf/nNUPfwNZ8gMdI0z7jyQUKjw73otH8LIDHMrYhX+V85FGCfuYLTXn0kz5u/M7wk3gkT2NToSbY9tfzTS8rMrdifftykycbcaclp1WpHSeN+4yMjdM+4bH6mkuL8OKVJAtvWR2f/uJ+r8nYn+scqpvbU2knJwgBAFSPbdvXiHG1Gj+31w93Hut8ANupmaL6uPzrCy2jV5Yq9CnbDzwaHrsxJ6koyGbQnwrd8Oq7epue948xUoPYL1Ar4mWQ2hzRcOr01aXO/YXDS1L+ykqwh/nzrphd+I/qoTRDu2jMwg/qtON0JbSoFanQIt98OGLY7hwZfP73PsPJAP5bFtZ0QZfHvywYFw/NV/DXKLlBEqp1FeI5/Dg28OI68/OYPPsjMkZauV8fLm2uTFFkeEcXPRXI6DuVIOsqeUEZBrnw3hO6+Ad0L5n290QA1KSLSj3ImmrS3R3OhIMyKPr3s+bGikLY/Jnlrz8GDMBaLGL+Blz4cN6p/l76Tcznh/QIm/RW8PSHme1/PnzjfX7t+mBm7/dbrqxO21JNXs2GIlmxvb1CnhWuI/CHmS2lxrV5Ub/IXwli2tipQZUOMHT6cZlS9k7RwefGCYpH3eNzTwxJVEldATXcFy/HfnSXIUlOKz5yPLUB49c56VzvBgF1feWLZY1jf3jC8fX0b8LcMJ5ePg1zI8FuJtH44vt8F7Gs+RmYqUuMrl0KeVb/tHZ8GOG6bajFk59w5FQ02vHM4xKnKVmqP94S+4drJ0h0DGR7wPvAB8+x7yJMqGqMX3tyZsQ372XYgQ3J9c4KUP4XhKhHoedyxSEQ2clJ2P0YT1x6mHB786t2/78OAX53YORSYoIWQOfFPYCwnce6XvUdpSDikUMYawhv3bN9KUjx6P6L7KHx4f1nf0ePQt9xrXGsOOqcMgxsaMg+eq3C/bjQ7jTH9U2EPwzavPJBs3FUX3kWMaxbYD/niFLfmgP/6FA+eqFPu2wRPTie295bhq0y3Hozdh+o0vu0rj0xJ6Ej5LyC8epzx8m1J5rMGgPGk2jGlQpBD/dNpfJjQAlzvjloSnge4Bta47J7Hh5EAESHiogTlDA5HU1Z1yfCA+TdkfvgTjfjdQ5R/O2g91feZ3ZF/CPrIvvwcwOZMWQy411DZMXDxxyaSKyQ1V/u6ciYsTG1IanjqVVPPG0NRrx9sU2R+QW4uS+knq+CWzjOPLx6inNSj8956ZZUwoV6oV/k1nUqCvvdmQ0nA7/Yb8neRYwzLFyaZldxJ4d9a+ge4vYeieALoBvHsqwESAPUqivn06US0DSOzpTlE8ZzeGQ427eTh/x2cHiTZe86/eybZJDXcZJjdg6ST2EIGmVUYTw9G4Sotsm4GXeOXmhrDOzSR+xi8KDdDKbvakgPxejXoCmZIfmebqGb8nvkKp+PL6fRPvJfHJRbZnC2ecuNmNWt8VNm3hsobbbXk7UI4Xfq8dBzXf//Oh/de/YXuMfFz41vbflB6DfMxXEPUUqJuunriKuKXhx1wRihnYZoh/D8hjrTFpSBGr8J85veWq4cGXhhNyk4bGxQ4PPj78fNGhfqzjBRA/bipR5ffEVBBF6sSwrPBilLTmM6odKKMV/pjTSlv47BN9h5PDgIPaIfGdYVkK/44/ZvWU2J63zfQrwp9vKLYlm/W2xeYi24cNepvysbtoLsw4MVxUHz7D7wqrj0003N2QtXPXwbDxetsmWyHoGN2RUR+R2RN7Y1NUvTEpGA75A/6xKacGhgdX9xpse2yu0ixoQ7e/8MLp2GoYqJ62rCUPvXtQoQxfHH4Mamc5jMn8952JAAmiw7baT1TdPQ5j/dJNL+TY6hfflvPuQZKoNK6idBvO/HOIdL9yOjaLzL4Ja6i1DnT4cF2KsXZxHaWwn1lgrF5cQ92WM7ONlYurqXvNmULI1zND5YuVxgqKqTvzWlHYnpumPF+0Zk/x4jKKW3ymtGKGjczS9X24dty66nUPrXvY9sFQ7K4PhhL21djfPaj8ybsHI74C7iPIA4sWL6Jxss7MsG2299sT1i5f+691HwwRoC7cV+NAKqQmD2C87MW5lHoSUjtqbEePJ91C1PBtyZrFmeXEHwctIH3xY2s1lCryDEmeXabwrz6dYpuyI8f2InzxkldRRjCpcmFgz5DGtWdoZvUtAzMqvxja1D3TPz3810W/+ni/fZYxavNWu94YudliJ+qIzSn28M37bcrNW21hmy02xeYUG9mcAnnx0Wl17tcDCmh9q86S3roIkMOQ/26ALiiDevh9BuBVgH6AAYDzANjmlsCvo4+ongB4D+AMwLXTiCob8PPBPdQTZYwzRlZcbUsG3XnFhXxjOtTK14bUtqsbhqDeYhqqHvFrIpZElk+xRS7GL7/z9G+Tw0Ginr9AejXQxg3Ay1yARoC31yb0KGbHGqP7lB+GzY7pQxlWMUO1DrSuoaGBmHXhMBY6McAwc4Ya150aYO8yrPVs616rzFEWw2g0DNvxY5Mjyh9TJdg2FZH+xB2PkYlGV2l4tmLByYGjr/8Op9PIxC82ffFu5LvtP/kw9sOPb/14vIZExMQnTboqJY30/v446SY9ipeIP3xI8RrZyfzhsxr2Er9yrPn4xrEblnx4YKwf8TyMG1IsIABPHVOEhXLD+G162qyovdsODE3fAvDUsbSwtFmDn3wx9PiXVYceHPP5gTH+ZUPhC2AEveBqkP8TyRaAZHDlgyufTAVXJ7g6yZXgGgLXEBmPLgW4FHHoUoJLqUJXFLiilOiKB1c8jOamh0HukFmg9e7kuVIUhPax776c70ublbcXvxG/Tz0UtqDqUKKh6fh0Q9WhpGLr8enFVYcmlDQfn15SdegKY8vx6caqQ1eW2o5PL606NLHMfnx6WdWhSeVrj08vrzo0efG649MXVx2assRxfPoS5L/q0NQKSPNtlmfvfoLfEz7r4b2YX/y78PepY+Fhfxy4FG7DZw2f6vw9xkcMxE/h02EU4WHfgd4KHaoK6q1K1ZO1bftJUqX8YPz2sG6o3zuJf8mFK1KUDdhrDg6oerClPX266Cp8R9iQQkdmn+53lUb1RC1RPDilU6lPBN1N2ad4jvgfP6s0TgSdas1Q+NnfgLwe+5KyR/kcjCWnKB4cHvxmOAxDDitfcJXuWusq/VMjjmdRH48zYt/ROEx2QP/pj72Asl/Zd38yaijLz5OMo31Ov5L4Bx6BtpRxcMhAjiVEhRsVyfnQH34xHHHVrL3QJn/G2iRJhVF2dPixWFXjXVvvGr99yvZfFI3v27r2tiHF/fVrFdBLPVKqSC6EmG8MRxi3gnZdvxZxJOObT05t/xmmkBH9ST7w8zMYe+08MLSx6sQZV7i/eGgr0O1dC5RpJ/uO0HHVWONUGFVtXTvF/khpwrFJ8T/tL/w+IueXRTP6oj59+eRdN6+GcdaExF8WtfZhbxoJITmAiYLfU/3A8S2MY5HPgk+23tV415Tt47c/NlmxIH6fSDPjnv13M5qYT/ffPeMeRvOP7bfSGY3ZDe8NzLhn390vnZ6RNX472T5+sn9AjPvUXRYufeWnlruegvT3DTx1V8NdSPnS6SuyBgYa79oi+MZP3jVAJdwMTFuR8QiM+yKODec93vvVxhm3Mf/e7Y/3Nt761K2Y+gMDqBW7QCvO7iVpd/XjyPKXRTF9L8OYc2O/b9vsTVu7123a3314U8otNw7kbdu6aXb3/k3rulPuPNztoeM51wCUaVXJXS/A2zO2K/LCjfHG+42/LdrTi2WZEA3lGbMVuP5tkQokJ3yBfcr2jO3/qrPeCqXzX68cI/GpfVj+dwI3jG5yPy3vLWJ5Q30gMB67sHXtRmM9HVE9UspK+1WI//4nWL/+BXoiGXMceIoh/cDTYNVGWzeU8Fhj+LGpUVjbHoBa8+sLEVdF76W1LAa4G1NZEvkh1hbnBRxNQOv9r5R7vrp7EpTPXUVX9TWuVeTUXA/lkjBl+6P4RSkpt23dlOifFR/RFzMrqh/HwBN742ZkuxR5irl7BuJmnQZcGOBiZpwYIBn9/XuGSPUEf2HELPimdONjduT8q7tT7mElOgnr0UbF5ruxnKF+PmhXJN9fettQ2Bb85rHwzVUXFI/tpRo8SfsNfmfErwe2Qr6wlH6FXxvxS/hav36jTZE81R5+LEaFrSPnQtRVk/amdiryJviHI3L7FBlZ/WIr2995avu6HdgiptgeKY26KuoTzEvUVA6fz4f64L8Fwx6jYU+tVX5Sa8O3fTtAUiy3bu3eeuv+jSm37e9UbotI2d+92c5KCVNIdX0KHF0Z9TFtX5GQ+wS+IyYiDTg6dD6lUzE78mPFghRXGrzp5fOopZLkrWuTXexrQO+KDPsIx27fnhd5pe0WONnfOYVyXG/jy57QekH8fzlPaG4R/67zmG8J4HqVuqYSfM/fMH9KN9qijJuMVwBPSv87F7K27e8c8yrIyDyUEv47iP/UuVuMJO14P8SPUSRXAxcPnI+46ujerWvLjShjdLZtwOMd/sKovx3vvnIH1LvJ/XnG2fvEMZfqcGTUKyXh/Wwsl2fsH5g4pKiPyWBjtytOYy4knv5uYP8mwE/ZE6XcHZc+uX9y1OSPCoz41fVQN5M/2Vai+OB/DkdHiHIlvA9LnMm5asi5SeefHohJ/zfUtJnxiv6Y5C8GCoxxdMxbACl8tfdkX/Sx4fm/o7Ui1hhlRO0ec2V48MA55p5KcCzJ3Di/+Ok5MgPyMnKcEWdtdlPf2IhxRuT4vXMkOcuo9C8ZJsnQRvylwylGWkf0VSf2uhWgQ55+hfR2g2zf2Dl7G0kZm0WGYhcS/19fc5UaKAa05qExgNkJmKEekhpunGMUv+5/t4/pF33T+65+ESXSEEikfb20FlKZ/V3f1ruetD+1FiTn2reuVxvvL916F8g7tSIHY229NeKYImJP769v/WBA7BM+HhjamXHwuP7Nu18AyTpzuyI3yrgVW/FMkjr9zO1Dr67NN+4F2V+4A6VQWB/2R09AL4f1f9E9r66du73erng2H1L6n6IDfWfv3gBv76tL2X524x8gPUUuS0uRt2cgqycWRhoTjGU7FL8h/muHZtmSjYrfKP3QR8H4AnEThk4MxKWz3jKqD+v/3CFFlrJvq02Rs7UB+03XGeg3c471DQ0olygblEsMDSRlI50ffjedqLQOHG9hbIybKYtbEzJu3CwW1/X/MPYm4E1c1+L4nUWLLYFly4C8BGSNAdmCIDAQsyQI2Qy2ZWO2JCxJK2zyOkDSuFl4TkKDjNNUBNpHcNoCzuLEeS0JSbAMbnGJIxrIa9o0rQS4NRiKszExTvLGxqCRZFn/c0Zylvf6f9/v83d1l7nLueeee+45dzmGsoy0MqapsvpswkYhwfVNy0G3icKKGLQJOQJwLP8bsO5TrhzIYVqOYVzjTT7GZXJjSOH3SvrDUN94/haApVAG3e81qEdmJ2t6AR+HVu1+t5+5L0/SUKsaiHSHjHsUMNOJoUNbmdA046HWaPXN+MO1HsK1ehiXzsdKqRHcx7gEcjP1IMJLpKWx8S4VfyxMm3P5XbB6TAbqhL5Hizsp7j5Pq4fuO+Sl5hzyQN1SUNE4vwo8BxpnPJQdxnqOA01qytrCrJ2y0ZepRY2euuXYagm02ugh0qMnE+0ZEDe8UaZshZ0kx2Qn0l9lc6eha1ZhKGDiQWMezGSoxaAVz8roJJbsukFxVmEkwEB+wBiHpx860Nl/2jarMI1fFkQdkzoMuleRqolId8vEesfFy/3MWurFK/IOD/bgdpmpb4C+nPPFQ3+ImzsflHREg1TXOA/GhnFb3WTqCp7lPxdzfbUQd7tvgt5F7Iz7fRkYGmi4v44T6yeBmcncxTA2//w6b0hUubIF2m1yDynrcxB+DeSvMLafQl8ZPpvPAO5j4mf7ZhWogiaerqeKsD91y428JMod0wHnuQIjZNfPKlwazK438bMKmUGKCQdI4eIAmXYbXwkQU4yFf6+fsO/109sLN5l4uYsdNFIlKGX+DTA5622YUWnBVN+swolB3JNk6o/5anczkoahbcZArTCNJ/mpfRb4TgdqlrE9H5/FOkn+OZETpvO5/F9Emv8rOMJ9gL1gPoTfu5k/i9gHiqfKiESf+BzCxR3jAKNameVNvkKe5DGSJ27mi7vqOtQ8KbgjQA0a2XwpTUUkt9wBcvLsszh/3pD1HBMl7qe25B+zeGuF153Tz70irHHXCjrfK8Iht8W7JkdnG3+hub12zaasN9urPJbSqZ6VXjJMHEzJGmUUfyjXetm5D14rKXnw2pqSfJlejKlVQO11XTrzX8VcPiDq+ZAIuiPyWaD5gsgYzde6DcpONpH+Fj0epu0qvtHJBkE6ghldCzMa5enRsEmh81oYfZTlr4uJEr/9uoQ+OJafgH6WkLpfy1OVjYYOxbGGg2FiHQze56G4L8T3gqgrOAWqEGbCQqdb2wWwPOT0EIvTTSQpjFLxxTwKyu6IY17cu9Z69VDLRMDVOpDZM+nCUlXpkS2cL8ub7jN7vU5Vz1r3mX5qDuN7HmDIhpVZEtsAx5qzTAqMko301C2n7Bu1YVGHp19E28FIaTB7WZdJMPsan2RsVHCuXdtFlY2IuA+wl4VSHMhmANnSFVfkxQ1FdQ5XYwdQ/cr3ZXblLe573be77qhO+pUJ38yjv9h1u+eQ51DDQu8CL55C3eJ+wV0iz3EwA+8yBz17LQXA/R4eXeRlprc2zHGxg0/RZ/rZIjXX2mh3LeXPyE/ZZ0FNp/vJ1DPyXvtvtjNSZ9QMZV6K0Bz1msAX1TFSc/hyP6FY6eXwVNdtdTofkRZHORf6D41YwEd9lJF2xBnp/gjL5e2cUFZUR6ThiBGolYniDnMkQllaBdqcDbX9fFTF4fcZMpEOyXbggD+GESfSDpmVngwz0g/DQzBnFwJeFoO7B1wxODu4FsDTPnClEB68lWjLN99/3wGIZ80n2p8VK2fRBPFp7CD5Whd5zjGUuXpzngba/3W4xclecgyNS2dhpH86mtg9XroQaOMs0Y4DV2nFmaPnJ/aAXPOThFyT1Tka2hOz8NrKFFeJPM2R7XsEahsN/WD0y3bcNzUAxSOFRgHebjvRboa2pyh1/dJPuxjXGtlsJxbTckzH79/eg1mq0Jxz1H4Web5hWkoV8LTOui6UqlDGQ4njYiQhURGrFGClmzLov37sPw10ROx4FlO3HOMyQJ7GfwO3qtIsEF/b8hZB61vAty1PQCt3Id5YWOM4n0loi3gkRwrQKdSBOKvrmOK6RfhGpiPWmQHGm9NObCmXGS+1KKedAS3bWpuAqK7r1m2TfXvyjNCHvtjYd2ttPLR7VJWndiP0e+V4aJeiE+sD8dCPR4nwiBWxZfITcy/w8ke+1tbPi4n9sLKzeGaQAVz8fd+3dvT/FxSG2rFTg3ho1aguWcsw1FnxdZ1Ssk5Dh/3YN3UthxmG9TU5meD2PANA34DQF2G9iXZSL+kBQ4t82dt2OSNBGD0+uxZ4a/IkE3fA4qFJ39pnuBdgvkfBn4pHrnE5/I0Eb/Nmsynnbd4cdnx3UnKXesOK9D/j+mUrTy2Oh47G89uviTM8X4mEoMzG8vvM4/lJ/AHgm5qYCiTzpYHZyF+BU6VeLHXOVuSgZ8Lx0PkYq8Bwax+mbIPv/907h1/KI+6nwer7eS/5pbY5o2KBUmI2pFzpTTmUp8SekvF3FpTp7rXyHWG9g0gfQw7NxXjocExdzgpYy6nwH0WcKSgX6vPfE++cR7R2ZX6xz3/YT+Ya+VQeT3Fa48pZDJFhTZrET+aRW68PTyufVqFTcEtsOk+Pn+IYiSKrZfupHr/Og+tkRuB/f8dvkMeQ58M7Ktg/ucsp2x30wCm6yfNle2sD7mlP3X7fdjK1dY+Z5ySGfkE22YGrAe9iGGNJa+N/QmgJcJdJYU058rKVYZZr3U6kW0AT+QeeA6gSPAT7gvoyYDnf7iKDT6WQAq0/C/pQxrMWRjKP/ET2OsqgBs0Inzvr5GKenvsqeTkLcXOXvAvGxhkgA6z2lEw8mGs4qubLeQc/GjozGuSp+drFfCm7ZG1p5bJsWOPKZFb/nry3JaFtO4Yo091yPiHW8wFG+kd021bKri590TnxLDW3dNlg8EFJTfrFcpl98G6ZnaLlqWcZ6Uy0kacO2nndIKUbDe0f/V4pyjgbCN7m0JGz4kNnv3vmxkj58jd0i3IoZYZ2MzVA4efkvYZVstmc0bkRNAGmj7K3OG8GKTORUmWcN8hjtL62sJ4k+IO2Q+U6054j4IzIg/F9CaVbaXM8McdY3gua3tGowdeinHQhPFGRsjQKxLyhDtdAQ4dHYO2M9NwIk5dSxkifxdjJ2iAFcsvzMToPR+lAzMwbuqjLjNQQe1CayIZEPE/UJsvVjyh7fIRwbAVb7pQ5A1VUZYsEUdYf468IxymE2b7GR8y6CqAnxikXEXrgNINr6yFP61ajD+G+X5ETtsj4+7iMEJcq/VC5coUZPloqjhs6P9lDFX3SiN+wj8Ud6cCXcoVP4WtB/P3Ob7jt8fBkO7Gd8TODccifiKkvEe6TRhXgWQf5s+IJDoyn8GuT65qho3EPy/eqtOdRikM4LHLrnpJhz8OtjXhzBOeQSk6c3BKp7ATKJd/izlvtPpR9rFuJ9LRMOFvN2E2L4o6nBBU/11dbT9nYC9Si2jrCHUHJ6hZYT6LYDi3fEBNn9LR0ZtT9LU6bUm6FtPr4WF2M1BYj1q+CSO+/i+FZPCO92ZVYg6DUrkSpxidVNnWQ2paYyzqQ8pjac8rODY57ccc3mDIfY57o1eR1E0sm4Jk99pSTE4zBHN9BoUWgSg+6d/nGlxsAAiFOzNwTZjeernMPJ3BX3GUB6fhTUVVGSyviXykS/qD4Q9B6RkMvRYj/gJqYnzibkN++NQOeuKChuuOht+O2Jw5pNN2JnlmVM0scjY2a6Hm10uvYqKri03Yj9MHowTz/DXyiBeo8rEbeDvJEVUoFyP2l74LTrLBnFfCmubT08ei+GXJQbWFd2aCNYX6E441kOW1Hyc0XSSw0MFJy8yXwRfBfAP8T8PeAf2WkYmgC+L0jS2++Cf4/RiqH/gP8c5CuB/9vI2VDKvA/AJ8F/4+QngP+acifDb5/hMpbevM5CE2LJfzfQg4t+O3wpXr41MpYKCuW8F9T8lLwzRBL+C1KiglCmljC/5WSkgWh0ZGE/3MlRQ2hGyMJ/ydKigZCX4wk/B1KikHpV8J/GPx0QuXFQhdHuj7XOjAWCwlvjz9e1DHOtfGZA870HmuevlJfNrVefUR1iIqqCNVES8dGuXrCaSu4OiPI90Y3rjx2B+67E/950L29GpAHwT2lQb5tKkPNvmuUdRkGWN3SQaIHKfbtrs9N3hblu1QdNze3sVKHTEuWERPoIieA73wJUuYqmVh+W/m7qrUyu4jNm3B4ArQ9EHvDSfM3gu1Vje0Du9pdtL6wkeRXDz/+EN1EuKNlsN5xzHOs9Kj8ZrnaPBr6MkrlJUZVGMEQjnOtEsIR/t5IHp8Y4/Vfj9HaEeCto5S0OkJJgTCRHonrDjNS+si4Fw+62tuzPQfL05rn8Fi3P/qrMgp0td/emLgz9+IvyhlI64g+V7XDR5Jt3vp1mwUjSL3/NvKURLFfiWMwTYb2QaKQrsWIhXAf9mvBqcGxXGP1FTmznZHyRi9D6q7sTQMMk8UbeK10KLYAfi/HdqywuwGu0b/LZB+UpB4rL4P0B0Hzrg/8l0za8NRwRxx/v4zT0hMyhoaV+GdxSrJFMPRFHPntkZ/XrjjkFILHvPdV4O5w9VB+id6/D2QbRvoodhkgwvuMCRgOLtP69y3Tn2Wk87F7XQAtlVXfgLc56xL97Ige8/awdPc270GN6Twj/SF2Rd788m7+IoxLogaS5+FXlh10Qj1OzdkJgNvaaJe82f7nfrK7yHPMe5G1QelmjbUbsYRjsye6bMXfobyxhEhNoMH8KoaxPVDDLqdHesZDS9tHrsikoQykKq2kBwx4EAOeH4vOoTTo3SHnDD+VR/LeFK/IfS3g9l0EbMwuf7Qwv2fztAsysWM76igj64QT0SH5eyXbud9Gr9/UDlJaan7bsuf8JA9nyfIolLO3LcPdhj9D6FgPlqWK/gS/b4qTKyDNYRQg5rjd5vVnujOEKYXP+Y38u4N3MBtLeg069wQXNSfb/SvgWe8D7eO9DUIoLc6Z97KI9jCk7QXe2Afa6Yvg74P4CfQDDOm67el5pRCf9LtgcRn45pc1BOdPG5R1gL8SXOo/WhcvxjrA5VdMdRmELMHrTA+gnwGhbLcuYM0zrzC75tRrzFSUnjOlfDR0T6Sofi7oe1+MXAa6G6M0whl4U0UCx/7hk29NdP3wGcPhYzLrgXm6r0MmLYz000hG82/bp0S88pTI7vCUyDORD/up1jl8Ca8vp8wfAl3GQxdijOQfAYqmDlxFfrAO3O4kf3j5b0TrcKYR7O9fzuLZm7Rcw+/m9/Fk2hXZ3TKxiuSjxBEbPeHTXCPMis5m3wHsT8U5L961OufBnfEnfL+XtQbM97dRk29A+TLgoeZqZ/QFp3VS0y6Jv5fVhq9E1vWSp1VW72uVtZ6PRWwT8X6bFU+H1LyXf5afwm8PpPTMtcKM8cy3rgwUWVOChGsvz+vbBmn/6dH3bAX/KY92QMPEbdSF9wfjGpgZqa9XXe+7H74c9jxglaAEZf5NpePmv6k2TPtN3wLZSKiiPDmDaAcYOtA+xUr1nHReDzLS3JEXXacBL3hjWP4PyAeSUoPT5M+XMwyYN9iuKcC8g5B38kiT67kKzN0E/fMwOAvqRj8SCQfzt+7nlVdFLJ/lW18wvscsZ7i3wvrolLT0Vs9YTR/0vOT8Ivi++LJzrx9yOMAZBqC8pwwgZTdMe6yqX6kjz+e78f6DqRfg+0qqaKz0G1D6v4OviesLnvu6NKy83ENlG4D3vn/ftWT7LzuVko5vSv4HlJSCe8U/JkquHCuJrdaWvT9VKfkdDGmsS24+evQl51DwR5BvY/l1pe5nOxEv39RL9WCOyoo13n0+TjIzOWyOfo1nHUDI9EBOkG4/F1+DvkJ4JZa8KZZArjWeMnE9MeD+fTUlvfT2vFuJZG3Yeas5uKvzoxLkyXjDOBZaHdb20YWmAFPIBue7LnjzrrHsJU/qIJWqHUilf7/sbPuSYe7onFsXyNmOSYHeHupWMYA6UJZY6Moc9uw85NUGnMMekGSbvZdUH3dT0m2xK+J+1Tr/854bYnbh5z1U6xrZIhF/91KiTXcS7RJwLnC14HRLE+43yfCPwd+TDP8N/E/AdYALgYv+Hw7zo68pgTbADWkSNN8GtI/8B+fAHC0xnwL/DKQfB9cC4UyJSdMrHDOxIn4gZ4KEp/WzUhpzQFPq56RxTHO7UdKmmfxaboOSooMUm+cB8cz1VLJZvdT/WPkzXsBAzTOebd6tXmaYPMyU7FM5/Vu9NODFWNLcvs1zl9jvLdyNNwbp0ZXi8Rvv7wSt1w/09KOsgsPeYn9WXuFuSVzswy9K+iNZMyA1/7DXwvd7PxHv37X1GXc5AY3m11G7eK+rGdaOJTdmHC25yRufd+4cnn50Q1k89E7UAlAx6QA9UUvpco64bEhXi9+nHV1Z0eTlhj1rkHqaPOO//pJ1tBy+4J3u66Jj6JWaV4f2cM3tTc4lN2Nv3d8YufpFo3zVzE8FSldJ7vjQVYpzVNz/tLHuy6tvPD1w9Yr8edtJmbX3AjSfvaU2t+ON8hJI7Uu3vTJA6PEDDmrJTfEtn5x6ii3US5T+ZQhVXFAV7hz+8C0oaWYlWo/YOwLhrd5PNRbJQVdfo53V1zKcWz2Ye+eNE2/dIRv6HDfPGN65Edk5109ZiGWv9ylnmdfrp+Y8vewp+D3b/pTzfe9iJdQGubS7E6lx68SAxmq6sBl8jFNF6Qoe6SjCDRipRYxA6/anrsLMdDRcJYVLhne+dU0khZ8HK5MQb79K/EhDo8C7W56myDCE9eeI1gs0NQf5agny1QmgD+C6PaGHAR75tEfdQ1mtga0Xqlw2t5bb0qeC1AbPE+fU1sUAk0uZR3V9t0Fqo0fTM8/6WGBHT5H1etDpMroXAid+LMAAHx4ILnH9U7zf+kjgAetnwdtdPSIL8sziGO5gH3Dm+p1Db9SuKymuzvWfup5mP9Gggq8zk1+n+B03Py1ZV4Jf5IZZ7lRuWt+t1Q6QPItBRmuLYk2TYsUeLGOM1Xtmuc3chD78PhW0mpYomX5F3ruvGFactmiBPIlQt2lnhYLvwXp3TbwFoEzhOHeua3JdrqsRpBBOOLDsubPEbBOYgTLG5uaE1gEtw7nx7scE1w5xApTI4j4TM8HvFI3wm8P9U8wA/37uopju2gZuC7gfgLtP/BjmLc7jM8l5jPh3g/sCxuAjnNPgAhB3whg8ok3Md2U8kvN8bI4bOlCnGQldHy2uLHYtqCDWjYGD3j+xi89v8r6vWdCdLqQUmHuo2enuZq9x2PP9Wm9VAGXDZUMrUUf/Ee6/zKhEKZoTspb+qWRDLnJOi3skdHyUE9JsT+FdBLehK7Xgn8GD3gPepcOeVQ1OXUC5N2L2gOZ2wPundsewZ+UBTwPE0oX3RWzfpLT87oXUgneVcrvb85SSX2FJjyEP8x70YloKm6I/6PlD+xWR5B0RmzWa87XeZUN3rjJKFPAlJu+oWD38+tI3xIROgnjKTSVmEzid66A3fdiziQkixx8JbXwH+ig5oBSxqFysP7t+lyLRKpIt9YUiK5ih3JQO0C2aNC5NBeoaGkXXQM0DUqXbIyrlXlLnssRckFP+7/xTk/k7eKIt+5wi1lQ8szRWGleArl3FSaeAQjJcOUIR/KW7TAJobREr/PZFqoeda2bzpMkqlHL6CtAYI4TTlWfz+LUrwgko/3BuPNHMLCUOFtxxqJuAfwL8cnCdy1HWii/lVyyvsgu4F8pXkLxM3iZckc0fYds2t6F+v0ydItIS5qXcVXX0wHLNr5y6nr3LDIHFuKstVYcdHFcX51rrPqkz9WXI1J6Ga1pqskwZgEdIp4jDOjc4p+Kj+pb6eKgqavfZlVJzwx4oRfrMdfGQN04sXP30cgbaoIs2koLqmro+k9e5qKembp9lWiXZbxbMFVPLY6Fi6KFZyOaz+FioMmITUAKyuRHyvWFW2fXs6aSPMK8nWns3Rqx/7KWbmYNmoEIzRzdx9fQhbKXJWeynm+iX9GWPw6r2enR63UlxrBej3CG8/fbBrmt6+vf3nBTbAE+IP8TXc+CqwL0BbjbwN8Qj4rW4w4r7I0WZ0vi0HOGWwFSlj+/KZg3TzSnht+VNEM5Twr+VX4HwFCXcJk+uMAqJ13aUJdeVXfeJWt2d7bqlfqYPT3DjofAo7ntMqjTDqH4eDgyWEk0g05VTn8BW20BJGns2XanrGVkUDUroJzLm/lu4kKfzzEI8NC5+ScRxPwDwHgb3KrjnwekhrQz840l62AeuJTWxf2J2qc25brPLXIW/eSty3Xmuf+1ioeqw2WVyq8yxUEV4MoSW3aRhNpWNVAwx4JeOGCzZrhluw6LcTXPdOYLJZSrH3/nmbLeFHw1lR+dDyT/IFFfkdg7lwogm7nnteAdxfyAJ5+HkODyfhL8lCe8byXE5keyHIUnrsTKi1YKP+8V45so8xvnwTmxiNzcAGs7K3JJBQp0BWXpYpKUfjZ6HtA8V7dIDusfCwGUIE5vWTxU6Auf7Uylu24kBotoyQKlfcNZuK/ZPrX3B6fXfV2vlZ/Ma6VxscrlGmjh6Xi5uaeRXQYo6puLxHE4jvRejeCuknBzF9JERim+pXQehGyMFGIevfds0kjTSV0v1nenX7oZSP6DmLx8kmjP9qbsBwh+0ii1bDw8QcqZfTzTSnhgDbfXFCNdS+0mtKKJOiDuQduglZWOCtJQ6egY0ctxDRq2G5Yl1XQC/3RkMgBZvLFkVoCU5dh7CSW2eJ4WPDRJmH1/aC3j4wfl+LTcRpFyAQZcxoCUlAylU61aA5EjJMoCQIj26zjOy1fPJ1nL+wDKv/4w8w+OAvqyLGQGypth52e5pAC1cIzWOrOdV/EoIOZNYKB7F9McAC+baMgg9pGDhMfjqBiw8MII7IAA9565FfQj7RnHEwtQR7lQ/zeEeJe4V/aTtEGA34z5bvR40tsuyA1gB13Plc0bKoWeXSL5uyGssQVw8FXuvn6ZUg1pCS6Y44SqHquck9FndWcLZ6macJJy9z+qjIUxLDyi5L3Xa6hnb9B7qldUyJ3VVEi26mVVEmwKOWD8OJOqTRgn3/aR2/OlZBmog+dXSjrtf6SPWQKBXHH9ojmw0TwNHFbmWhYIqhfoSZc+OOocM/94S1SzTRKk7CVfAV1WYARMT4yecDMi/i3gylWqqWvZpIL15jTy1bR2vlirl8c2UtUieYGZ6psEvNe8rMa0Z4o4K3ytOq9/CU82vZt9TcjwaGs4sfbW9IqIaOgtyuW6QlDTzxVDCkMPs10g/HAEoV2mkd2B0gC5HmEP0PkOWw6CRNo3QzRRvgtTDUY3UNuppb3FCS4Q+C7+O/xKhDvsBoHuI2f1iRYS93qtJay6WM9uK5Ex7mV81SJYdGWAI1aSRFo0sgHr2KuO7e4RqVvE6+OLQaqRbRxK0sB3aeHI0rdnTPk3OJFjDAWfGuWLFH99Dza1ctmT4vqPY//yVVl4l/SVOWc/0jG/GnFDC/qU45WXcQNAQYjF05LhyK7NBrko1KzvRbkpqj2CsJBk7AjEKYlol9irEcjR0N8qZhi5O2AxfWOXLryJmwSCxZDCY4kqpyHbTgz2rN0C9JcMEvquBw61zH3B/Kr4N/EabTzn04Hp/+wCZAX6ow1Sp4ZHrzgfamFg1cYXNXSRMdE2smOI2CvTRBK+npQUjPwA6swkgr3QTbr5gc5uF34IGNH1U14fS5+kYnm3dZ/3yHNaVOwqy1nY7j++giR/bJdBWJbi54BAG5Nkkj5gnuUCy2J7rmehyDF268zTwn9PQTmaZStoVNrryeJPbWMZKlniGEq4ejmyebKYsBldWAzU7o2Cy517P854ez4YGZlDPDAcJl1phdI85fFOD8iTqjPhuTE/DOnieaA10QrY8A3D9Bdz7qYn93F+7nm3L9h7gM0BDdEjuBjK1tbJ1Ra3XLhglQ5rWT6bGQ60xO/SvBXjZz+TZ9gxYpdOOUE3NZeMGZzOkycKPG5zDsIN6iggq6Vzkw36V2u17QZ5jrvWSQiJtbsAxq/XUevHVQq2HTKuWNqfexqubxw06UkwgxzgApz+OFcjaB16A+l9ynpKqGuYfe0Gea885eUIm9hfkopUcUATqOYch3iUX2znPDtchkC5B83I+k5BVd41JnCC/Lj3oSZyXfN3qdGhV93se2yyQ1T/Glg4tOyXZGqYf65IX2oUKztPkfRb0SFKyxzk+8M2d6Sbv2L0c0Co9Hyi11nhfkG8zWIBOmttJAZEs0EcaWlE1N/nuSsAlGej/BZdkoMbg+qWv8v8J/qM+Z8X/O1zq5ivycItJwHuXF2VC4qH3RjK4WyuoptllaUdIEw2j5OKJwEq+eAO/8pgtCav5X8Bq/hrWF+TFybFs98yx4Oyo9bwgLzRAGvT9TU+i7zhSWZp1/l+0Y8tX5LqWeGh/EopdI1D3ngTcBtDLpo0QLi3Jk1fxpyRXg96V482wkQsZHOdJrSDcnr6ELuBM0izSMcr2SMcH9MS8ZBxD9oK/GdwK7Tc0rQLNOG00oTuq+CXDv3prH8hlGul0+D9g1TNF1ApPezu8F2LpEYq3Q0wV1kjjRkDPdJrddJRcd9yM122eim/Lt5Uciw5dP+I84H+h/aGrHNDxoatpzT+Ti1p67s3gxr0OssixcYNFgFNWKoxQtxGr1s9LlDqRa16bUU4l4wZvY+imDI5qqnONG5xPk6Zxg/OUEjOjuEuFZZZLlKbjKr67q/FcusopGN5sqRQ5wOwqEdanU+xACWmR9aeoouMyaVmzjDqrtw3B3AcJdJCkmvx4B3192SmQh9YDJj/xfD+yJ4o3wX8/SNImBu6EcT7gxV3GXWPjnNTrHJKWHPgfc0UL9NMR5bz/6ckAqRxHRNVc0om3lFVBrI8Oju8ks6oCeNJAS78Of8BX87e77liBnOxckptxXqTElKYFAI22KaV547JHe7AGJjDP1SWbzdkewlF5RWVUhBla6AA+M1DC4l691l/j0dquB61JymT/BWWyX1NmfgU7a433l37kDiWSCZyBWeO5xTXFkwVUdh10kdwklWW6PNJxD9ZpkYrp/ex+/TPOcd+p92x7nlRM7WZ3g6aqvHcwP9+HO8brxVNAV1/t2LnkwQxmEdIa0t8+fYIekc8iXw2kJnR4pFe0a/Hwbk1Tr2ZRd+qAi3l+d5H3Ue/zoNHk8qqmY94hCFshrG46YnreOfOyO8eTrYMV/1FZ3aw7lLpvHcRh/ZdTk6v8j8KPA7X+XtZIz0VIu6b5BU3R7lK/wwlhm7OHsk0JYvihCgvuzlroCHN9SgneZ9DPd4pHsp93pjbpL7pzDKUaqVRWHUqFNf4A1H+HjOv730Ri7hYZ25XgCTnbvL+dFF4MqA694mQuYPw5p/qcGmKpZ5OxC7+XabNTounXwX9PxJgFYiFxs432N7Zrm/DFzSmos7pilXevJrP7oPd53BeQaOrlBL6f+npfANIS+wIftTcot6NuDSR3ESQ11ZDI/c0uAqSN7SJgyipvcVke8NNVHpJHedI9F7w9Cs/67r5FD+5bSGbSo+xbnJBpQ5lmAcBUrpnfvdr7K03ReUgz36Wedf6Qt1s1o/uQNwMoThOwVLSHiTnjRuT7b/iJhbIc9FaqNeeV8iqmG/3dKtL9ii9Bo/S/oFH6axpNV+RJzLm/3aLkvZGAUHlVc8iLaRlshv4Q8PCrInHk8tu13+wJBZR1Wi4BStQyBeOVHbrTMvGQoXbPxupF9awtQ5Go32Ccb7iIZiYZ+rXnrgrVwB+YOWEjUUuu+NpytfR83OxeVE/b6ACWmBz8qnO6QGY6glfklc92ytMIaVdL8+PlkPOn8QUgwz4F+TV8p2xWvhTES+DL48qXB0fN7mrpybvPy2TfAh51g8IwsZYEprvL+hZiu5TRq1t6QVPTvS23S4Q4Pa9c5zUu7QV9elvubIDpuKiZuaZnpqsonEHeEqmZ6QDF+/s6ZavS1vVRK7RVqrS1NAmFhZwU6ZmnIV8L5CtU8l0ZnQz57Eq+mcl8+eQ3YnZ1GY8S7R9kYj0eNIEWTtsmudhAdr3TN7Eio76wk7qV6WFmakEfIh7U0eNkjc/gSoaSX6mg3pXY9UPJMwL0LIvE/7kusZ+H53o4NoR4/HjudxXST+gwfmonrll45yxnhb0e7/tlKzvdTHeWayOek543JVrS5pycVDmpmhPo150ye/sCfgLwq1kxqtkiNDkNgbPZGeW0eTRkkKkXlvnyhEK+PGdBaTFPSUvCGlnlmeomZntd4hYZZQb4/J/pEvwI2+/HMLizQDtvg7/pfOK8zlGl5o940/iLrLr7DgUeuptCGzg/PeJ93dvczg17Hm4a44rKWn0Ed9wfVvaXk9Q8OwE/S2wfBRfyswDKWKgrTs+ieoj5gvhLmfbg+wc2cGKQStMFzMBfpit5jsSnQQ+FkakupN4r8r59C3nazJXHQi/GL4CM8JtBJpUMpGqeyL1qm3Dh2/Cc/T/hOS0aq2bUkxmHgDoqPav5wVxH6Uhof2QhPx7a/ZNM6rSyxhELbYtToPm9IX4bR4sBL8vBvZ3EVxWEEY93g4+4M3SoK4lFXY63m25EE/eGmAq2nJL+dgLLdN5NtF+A/6NGvG+qW0Hxx72Zw55HxgUoTlultWjLUFvdH2V5NfT9rSjh6nbZ6vBOd2IvHmHAevBtzdxKb1utN1uz6XwRUEyv6t5u88+RzrfF7EDnb8eqpZWr1NIjce2xma6Z5SZBLbXHZrjUvMk7wzX15zneN9tPZaultTENb4VSK2MWKPUy6OvFMD9eiKGco5aqRik+DyBpjOZV2eprfW6lhYWxSZB3D+TJhm/VUdS3BT4e+mWc5Hv4SVWmatOK0mWaIN4w0sxI7+HkTDM1NyzeC/MNZ98PY7Pht3YEYI1PBQ2RmiuKWoUyx/Zycb7geTghkVLc08b9cOw3nkHgPjchE0uJ52Qp6iNlVU1t8dD3Rrv7Wc5Ywlc6g63e9Wqmu7ScAiryjrZ6X0HKkBzMdym11YtpSBmtScr4xPuxF+WBpgRvTr5i/Njb246y+cce5S4TN6t6UV2rN1tNd7d6N6pd51u9L2ocg2sbWr0HNbWQtkG97DzNrf1INWgglPRn0BfzkxJF+zmEpUSBxBJUwsNkzXdbewVbGyarX1Fam1gOvfpBEGS0k1BDu9N/lrJkuLLrsK9/gNTfif+jpOSgEyX/JuJLQZpJC7Dc+I/GzgO3AJ0iT0Ldugf8ALhFdXtdeyuYQQO1RmZ1e5zAXXRhgM5bZRz21E4KtOIJwRpjAG9tMNC/f6rI4OeeVq9JTQY/9WyDVrQMC7kaoV+nr3uMT6woqlPK1KqTZXP9rd7T1wm3vcJYt82r3m+UzEzyW23im8dYp3zT7DcOk51ZsOYwtonBovpWH2CVTe/GU8YSZW5/G1dbFVx5Htqq9Hib96Kq1M9wi+qwdCvIqb/yKBiu/ZcYrkngSWtZXb4GqPiuCJZySG0ePP+p9JVVXJHLngX3MrgGlyulaZE8iVjAtQxdWqndr5Z+Fy0HKtaOrILfWGQp/NIjrBQZVUsXYynNXPLkSHvoI+gH8m9Xp7o5wcm5Tk1zE/C070e88jbvvGqj5EmD1oPIB4lU3XCuE19NN4xSHFIaUgzF/Is+SFRyrKeV4y6tMbao3uUrqjcq7XC++72ZkoclUp9nUT2BnkU8RkWuaPXeq9554/Bbrd4e1c4br76FrWhEirOIze2vALdEfC0Zfvjod2YKpI7NlFpYO/C8KZDki7iO4Xom6hJnTzhP8RzrU/D/HegN5+v4Ry4unPS7VcUoqyA0S4YfPdoKPGvnjR8d3eadol5y44Gj1p/jnSjkL6nR7cBfNkYTHMwYuyKTV7THHnI9rHCx6ujvQW/08CdhDZj1c+RhQxF/ewNfDCW/jAhQ8o4oBXIG8CnwHeBfA/8+GGNzeDPIP7U+QeFi/4jcC3mt8O178O0LmQAeUo/iK7w5sQZe3byhwl5/RX6kIat+YI9q/7qKD/uZerL/w37qSAU/GjocA604j1g0NlWPVTYalsucmSoK4Stg7RV5rQ/cy5Wuu0FGWc9rm9TSF2Gkk8EIK/XH1NKfRrRAISaCd5BODGrTrgVR01kyfO0thyu7Hk9jP3sLTwoo6f7YlauLV8yXMw1mnppLSWkx7YxQ0AY8R91t4eeVz3eZBEbqGDWINm+PZueNcUdnuyywymJq4ahK1CRojtWd3ObNgnGPvTV1hbU6WZ/0+QiE7NPB4Y2a61DvRY2qOw9qyFVqSBm1wazfeePjt7SWSeXviyT/ioij9+e3HFDaHvspUPEYf6X+BX+lvsNf9eWvXyX+b/P2MZ6OMhGedyLdIE8KJPX2nwD9jPH/MfqROzSVmirtCm31G04SlLvw/uAxp3zhpPPm2QPLh8WnBojWizYRDUSLYcaVIzDu04NmTqe8SUQ7H8n95qWNT06spBdRNnybO01gLqzNM5ZFQwtjlKQPL+VVPMpPT4TToIYcHyU5w6qSL9urfPoq9WAxKRBm+4iUKXNCcRGebkgNeQK+Sy2eTaQNnYl3D88B/HjPGO1xNDi1AbaYGqxkVsmsbY/TIbOz0BYCVZonMdTpXG026tJoOZKtMJU2Qt/qlme72aIwzDe0z1Hc0bgVXzfYfCVb9zjpQDpPpA/kI1tzOvE+8bvxwzWHt7p97GK29NQgS+VLGjav9IuaLTVoCw9Pm5JvZLhdbaSJHNrlpM7RbdB6E3Wo/UbkQeYcOUTNIfsHRQp8av91kVh2tbXdeHxnSg+xbLZmwG+qNQt+tSeVcvup5mNQju5tufF43TWRaqaKqKZhEdP/aKMuby7+NJl2U0kzQlpq8eXvpFGQRhX//es0fKP1zdscShqR8f57sZ1Ib8oJfELrHVpXtjsaWhzVuHS+aOhSlEhvydHQPRG844o35/PeTtg/uTc3cRe9Ek/+oY5j0U+2ttZyin3BT35QLXkePiN77A9Kaob7N4n7pBbPVb79pgfrABmtaoZAScvkMl/KChZGfbZQ4IuHsuI2GPUid11XgYDnWjjm7hMJGHuSbzo9W02+WGh8mHCtNYSrrTF0NW7VzMZ3qRt9zq3POJ/1E+701o3Zq7Ib/KdrGmuX1rBFikWWcpUrVaCH+2qMJTq3/3r1f4yK+i9JH0siqrqOxicNVSxQrJqfAfS6Im880OvHUUpaLOP7v5/Fy3yp34LzvdH/Dac+CeeR8wm7NhQPGjghV+qWp/IYppWwtoOSzDLe9td26Cv05UYhzYy2qkokUmJ0L7vpX43jQCwjoakxjUXtSjNnu3EEoqE//p74zQBv9D6izexL2Myyw5ylSr1OKmjg7V2go2w8177NsVbm7I3XMixD4hmAhXBoGdTYqXWXwTx1CSZ3RNQJmMZ0lrm1kKYTmnxeX6MzJZgtpLorhEPO1CDhXG58O1royxbwrZAJsKA7UbecEWw+fIdKdzoBymw3YjZVYITVPpcPSwKfpif4s4QyN+Wm3YnvhCtxJ1o0doJ0ReqWr1PaDfSTOXM6de6izgo3nleRImjRHRI3gNNONnRoA1QvbVVfnpg/EvpLNPEeyNC1Lj8kph3XdLCKDRO1mdofDTXGFPsmA2wb2ofK5H/adgufyq/yUTy+0nZECvk8JfSZrEm+3K6IDIupnC96fQjfNjHRjMwMXzqsUTeAAtlBO2VNvqRGbkY4fBU9ic+dOi2iGkyX0qjU4MZO9vbCW24G93Ryyqtraak9z7Q8pUDVwwn22Yp9C+5LcUEpJ6QuCInIxepg5DWqP2lZngrEQ3KcE1TQztiLbfxKqcr/f75uKahTXolP5vMDWT01BXMCmwumBNYVmIL7NZpuaFGx1cAJ9Yq/buZsPlFS719q2WSJh5731xX0B+ieBwtSA3VdjxZQgfqCPnEsVzz0uL8JNFAG6jmw/JvUX/uzkqE2P+KBKmABC7fw6herI7vkogBdkB3IkBrSYF7PfyGHzNReQklLd3Fm3hhOTACTOWHt4/avxLBGD7Da8iQR82khHyPAl/lvQln1JcRRRCMDFLa86+JYn6jbE7npi4wwM++8eE5zTcnxN7SDUK0GnDzL724rqM/qbBNSFDlsasFdQZL/Cs/x0/kP+Cvy5v3UvF+gnS+oZW0QQ/vLlgI1bw8TK5F+A+lb0nSDbEov3v6WtA1kaATSakBiHNdwYnAz+KMQXwe+qkEFlDMTVrCNvIVXHY6HiuKX5VzPIoitAr3uQ6g7Htoax68F9WhzgYv/HrTvScFMBUsolfxmQKshs8ZfLgK82LF/S0JikYAhW32qjQ4+rIQBYnEpyFpME5EsYaaZWMtBip2Z5gBt3q78FqYZggCx2a0B2Knl/j28kd8Do1PpL5UMbKmkZal5jeLhwdm0ttDYc3jQrt1avyXXvjDQnmJle1LN43gS1VqHRVZiaVKY6S/hl/OfAaZvTaODpRLLXoGwTQlT7AUIc2l/hzDNnhNxfzsAv3Tqh5A+NU01SNGqYJGwlEfIL/AtkPpw2oLgggqAz4OYVUbbv4+vwdcxtim9WTzaJDkvszzZt4gnllWKfYq/jrby2sF4sUmmpuzuRLztHH7i6JIcMmtn6N+PfoOvmyKWflO+IqKVmGuXE9jTDcYXfQQt16ZpABZo2YAvydgUmA2QWpnGAPQOdgI/evXE4P1Qc/StbfX32+hAqWRmr4ulkpul50nw7cG0+LD+6InBurRxF04M1qcxSiv+m/RRVnoS8OphPxgkushVjIWu/rOHaM+A+wBco0BvaXJqzr4rBNeSvEbhXYEqanQH16JMpHJRCxm3ykVvKlE4HT1bh+/G/N3bEnYcGpW8wF3/h52H9PsT39FKA8PTpU2K9MLIVE5Y9DoNHdQAzWh7nJMPQroBbWm5aJmqDokNprPZ55w3AkaZqqLAySJdz/DPOMkgRegAKQwFjTxyZufkDJlaAuV0pmxHu7aT2G5i/Xx2/frc1E5TNqwNvCwyPLRUirJRdv09Srqhi+NvKul0KbUAeh2AOqoBLhcBKbpJgQZjYVHH4845kcgJ7ANtpYL4xh/D2o7q4bMP0XmqMsVmt5XtxXWOgXW3/R1tF/Hj+7jPe/DN00ho+oiuUsUfD6vtjU59wHzLSGhiBEpcHAmdkongcBZ3feYh5qhiJQj3B6XkXk52pYfn6sfxtG0SzwY21dV4GEkfb9lETVvIFwAVTqsjUlpEM1kLNTXLNKcSuLoHnIrtmAZ9OZF2hVWTVRcZrpjnIOer4UFxDo/2R6OhW5VX/594WI5M5eo+S7Ypo9ytw/d08dBPoniT5kHpbhYtF4yE3osSayhgqLLVs7YbAcqWeYGxTQiMhIpGbPW0LSW41bul/vAWfG/KTqYBnnkjH4sjoTkjJP+f2C+2F35VbI+I7TwMa1Y89Jc4saovljpHQrfLaPOGdd/SN25mDqwf90Ed1MXNzkExdabRT79GW1LLgQ7uBU5t0QK+L4URejWvLjvtYe0jod4wuVXstSoWPYYB59gPbAfHKRoa/05dx08ENf+o7wsh17dZ0PtalrPKS9tu0O7+C9btY27cS5vBgxxMUEYz8yOhZWHSaeiKhv47jq+kbwTK8qiySKg4frMH9QS0nhAN7enE1Ze9hQw+pTbzhrnx0J/jx53hYGL1JdKvTsodaOuGWBcGGgViuy1ACuYFiNQVUfFakMP+FEerI21x9eSc3ncElNR2yosEzv2EcKafmn8d5A0r/2Gn3JUDZcMBXE/Uk29cbBGIVC/jvRlS1Ore7pzgswK868PR0MG4WpEyPgPMrwoT80diyrTrisWdXMX+lRpbiCDu98ZVA6xRM0N1Gcsuwre8c/V9hqI1Mqtf14nfTveDdtRP1eN3W1hZDxuouZ8l7T3cE4GyfFpPPsVk9QoboS+1cfMt1tJ4qDyOuB0JpYeRbh4ETh5JlnEqZfQ98VBVnHDQhuFUP1V02o3YKnaMhOQTxcrbSgfI7xUxbjdVxDXgTmk09IOuxKvLU/Dl9tjxsNau81GLuAYMEVvKpdrdOaD3RkNrYmNvMlM7EyUroKTGKneg/a+0HpjHETVw65HQXTK+3g4H1QDFacHWiWknZIBWNb6vRFjkbhSecJ8WTrqZLVE3QHnnqX7mTszza9nKy1CjoSMV+vEYULAWKBj0jdEx+S4F5Dtijoh1MPKIbxO0hJpYpkzx83xW3xFhUWc0dGY0JfFKfS5S3q+d0YA1KatcfQdrZ3k1QPtauMxHAEJWqTcaeg1awRMEXb4sfgASz2mhGXCfLtGUOnBa6AUqyfSTvAclPaXl0S6OnoqI448Trq7jp23UPrT/Qhd92M8W4etaYtUpkO9MQD7fzqO1lzrlRR/9wrbdRklDc8EBQXdMdxDfZP4xjhyr1InhBfGPRSOfSA+Mqien98ZDr8L3i4EBAWm1J4DWkbohN66MJP6pqM7/WDTl94nQM+FVTVp3o7DNh3TTK7h8mFelwLLgO1jUWIsBhxN49YVoaIaCrwdBIynuiod+GLf6UCZOWKDu9mOZIYXKoqGZI2b4vTqimvyyv0YwAhUZG6IhfgRtwCJeV/qIEA9F4m74DcXH6GWiYhsbNR204rIWdCG040IBp9ze9U34tbGwkmuTYusFLVPM459uo16j3mAh9VU57S9p79l5kBTdauBHY/mjIZIID6YxqaVoTbZBsEhptHS8O7ugFNZUIzsti68eJpV5Mrvtj4L29t/I9KkXPBOmrPCoNllk9v5mL71l7KbGGo/0djT07111aGkmj+Ub3BP5TPs+kJVdI+ygmWEHX6VbB/XUQXeJrF2sL2pyhoKIFyY2B1aOMQm505+0jFCwPBANZcfmyvTivCmnr49n0HLMXJld/GdTexg0P+uE3vc3nO2nar/nXiMYSnW+XwovujO8mMNY2tyeD77TSw8Tp7GE5ks8WM8H2ceUkhm95/opqsy9XkjxHRC8biijz/JSpbvbs5K2a6iSVZ4s4BnRUFosMQuioeG367oUq4z5Gn4a/zLfApJyNPSnkX/0M7MPOsf1FEPs45GTAjv/vX6y4D1Z63mvn9msvKpqxHazvcRKX5xYaiwVxX3LUgaplMzSYpDhboq0K0c4IBAfa0+8nTd0pLlYPkc4Fp5sJoWpl7OfZJ485FSfTS3HdZ3iiLl1u6ELz26IlAdrrNnHWF7ZbhGatl8XW7cPimNvxos7SgSW39jJWKipjHBou5lny+OhL4FPW/nW7cVdZOoNMdEe/WR257q8DFhN0kd0wjFf7pPPQXsbhJpO0CHnoG5p7MsRhkSMGUDrJWZ9XyK8zi2LFQIpHAyitom6KFp8J37NBbQzS8z0tGqJ0WdWZZYXCqit6twut9w1Rfizr0k29WU++etl+gtrhc2dlPl0P8lf4/7ldpu7Uc4+lc0v4kUxQ7gmYjrnXuN+cfuwuDOPARj9SXu42Mf8CyjPwIrmUvFr5NkGZuAMk/MYnsjGQ03xN7bjq/QiOSL2BIlW5dr1pKFjjTzHgFaGgN9wiEfi71Fs/rBJyzQoMxGp9oRiK5yg3VDGm8NS5ykObYmo+qKhWSNj9jy0XcUdhsqpAnKdsng++J/sYfPQDgANdaNt9I6wnlB5REqXGUj5ZI+KpxZ90sgqL/0VrsF/88a/rmP8t6yyEOlO+ct2lj/s2/XkOBdCHQ+lySTv5e34vt3MzwF6G47n7UzMHEpiqGjol3789qBEk7pkv+o6TJUWYbWvSaAWEVuTW3VpKvABo68ZeCK5XNdl5UdD78QtAkiovmcFj0CVPuvOfmLdExaJoilr9sO6gPocbf0seK6fzfie0La8T9woEPOB5ZfEDULWln3Le8TEW3rg3b1qF4FSzMC7lC/MGhqcdBCgJon/51Gq2M6wl31zx2ucK1sY5zIJ+5z6Ms2FQD95O+eGZ27lIFEBJS3LdkPKssTNrxbTskFCdX1u9xJ//gzKYdYDzeoT9eH/m0l3VQ6tnJMrEC5jgOhKBij9I77z/fQyw+AceukgYY44tf5XnPqz9y3T+u9ZRs628mrXlMieoWyPyoV7QXZvE38D+mGCOqeBK4Y25I50xa5LoJ/+wTmo6yjU8WvQRXTlo6GUeMLunt9v5LOFQt/Zr7/fPEvxTIVJsctHS/3vJOpErsGCrHPwW6OL9d51TcPQgVSoUVReV5/pZ7nU5jP99O7WTbpmM//JpnjoZNIWBHKRZF3VW1xbqwE2zxbXZGGoJNvtGKK5yc7pgX+r+EGlUWiUaMbovs81cZg8dIvgkH7hcdyMkjzvm+3bspvbG52PXrgiv/qHlwX8zzIHnfcE7qm4p8woHHRWB1gu3c2AptTqpjju4amehzWOwYOeu1wLvTneO8vPZhNuf/ts2Uj2OU9Juzyry1fhScKcpcp/fCGpaFV0xYp4SB+/TcAb7GRWfeAf/TSXeGH90LnZfDHQ2kOjkDZ3Kp/Ln9zyx376iM4nbzmw/B/9LLXyGsVcSZRQ3nYz5/JNVUshzzI86bgtHhQZAWWsN8W/gC5qdL8usgWHLxj5OWVzKuyy8ZQFHFV00CkHQeYdvdWFN7YOiJYnEu8nxwWowl8E31907Mb7O3U9rd7pFR9kb/IYPS97aM4rJtLDFwhnqeAeNrobxFrvfZ4BwFfrjbKH2m8cfXCw5xXBWPiSf1Xuy+4J5Xlyhp3h7hepIq1t5/CjR9MqjFthVa95XIyHjo8mXtImaDUfaRVpFtxaCM8FvxL8lUlacwD/soKPY9uSvPM3dgdrb5LGv22hIh66Z7S7n3AJyxQevD2vzAxDB8k3uSy8qdyGnLQ0Gnorkodrd82EsnDo6bg6L9OVWTGhLNON/3HpIIywsVwPo13qZsxa9yTz3hqvG9/wvu+uHn68zrtpqaxfbDMb3ZHQXBnlkdIhLwmHXjyJcPbXEy3+TwoW+kLAmZL9w3sYQMe7Wf5yf+qGifwUGDfV6K6sDyH2IaQvHdAwitS+PB569B0iVZ1EPUDN4174ezLL43u3P8iKzVktW5Lp086kgySfmj6lTxtRhaY7WcUeZGo0/5qGxZvnmgh7Y54zLYDr4C9kg50OYigSwdt32YqE2xKedk2lpuaO92lniEHlfyI1EMJaDcdTe1IqS6hP1hX5nEOGhw861T2Gt4lU2KnIem+jpJpH8O7J3qtES6Sfn0CZCuH8URLOB0CGRu1oXHRGidlRl7DAYmGB038VTkpwFuT7Yie2V9cxqWd8RQl13nRuXatPj5a+zHM6z/erMqmpLzvZCyUQhzTg2qoIdXNOCTX7OkjsIdGk8CWE4X19QncccyiRZ/ToygmlM214fKsv+/GUytXUK+ucvtR1c3zAo216P9o8SVjXmUDQ5tgMkWixLoQ1HvpnHC3M5dRzaNk6TQu504ihK5OGNc56yE+5TPdgOxinuEYHpFb0tjfco3OyQcqutuJ/CIvbE99xFLNcT7dNfmz+MZKfCXoodXg0tDI+lb8ir/XUUmtkbd3dPtQrH4/bnVP86iPMwE+YEjlzBzWPmqua8WXwm/NigV8ps7MKOxO2fNXKXYtVW5ZKFLVqE/5PBmwP+yB3TKvIrGeXZkoUW4Llf5o8i+HS6xsd5ipdCU8Z645kHRLWCXl8GOjwyPqcilx3k/Me9/PuS+7cmuc3Xdp0T+3ztZdqczdDbDMToG+Qmian8j82nBs2zyu9JhjKb93SHh0cohYeqim9OaXmYg1l6d+yYROMvCUaisl2qPnV0Xj7T5UVWQZMp4FueUmfgBHnBtoVkGFdRw03OmqtMD62qj6zPqskr4S6Rhj7NYpyBq+0yyW5jlPtVztzc0x+Kj/9Xq3DcKfhMU1J0TVCJv0oLZDjeoBan7VhPf4/j3M1Hwim8mPRwevUoqYalAbXbJK7Wp2ZfjafQNkHKCy9qt5QllZyd52+Yk8JPaBiTf5PhNXrTX68+dsWvSmZFPtDZBDtqzXVBGouigZz77fwSzIeJwi7azLO6l28l2dt/67cxnuA2f7AA4SaSqYvcDEDxHhOZvehFeDfjuI7H3dwpbLziOENQYqbXcFEUq+n1+ddY6j0ugxZa9CV0LLWfkU+7Km+lpqtHUhlTI/HQ5Pi39hB61SszJYBbv8tHCg9IKecOiBrYY2Ja6eU6wHi1dTudSBpjHdo1Xa0SVV97a/jtZHx8v52yzUtrYmMDy0s2d++FL4Qi86sH9Trl8ozINdepnVwLq3bus/R3M4B9n/hsJU0t+tqErbWVH1kqjD9Nf6ASGYcvajwqZ/CzGHDIs6bMbyM7ZH72jJByzluYYDSe2PkVr0f179qidapZmp6KO6IwygVpamCRkmfxgZxBq7FG7e61a5195IZq4IkD2+T2qb0tl+RHX+4Ihc3UE1an7aAD37bxvthfnm17o21smFGzTHj1rWyOZeDVXKtnJurKzHWBIS1cmauGWhorWzSUyVB91ZqtaxpWTqUnmF0pAco7tVBQ8qf5Uz7eplNM/nCoXfkP8nEU7nsZhAtiJRIDYr9EGqeaiY7mM/+OZi0Omeerez7mx1HREeEut6r4burr1GTxw/o6RSIr33cfI0hxsfzLfajdJR56PvUOllTRy12yq/u+A1JiWgiq+XjO5ZfS039DXHKx99QKyltmKJxgk9PB84NKYeTKYd3rJbf2KGDtET8jR3bfdRMOkAdogpTepiB00xu6T3yeLMd+MZTbKncMoOaLXyLVnF88H9axEOPxFi+pxPlhf+MUZMzL1PT3nHcaC/k/9SO3Ccvjl8OxIhVc1ntyr7Hck2tnrw2u35CyS11idk7gY0k60UtdDzkdsVYxbrzj2P3d1JWGs/Frak9mjJNORlQGZjH6Sc2Uh+s+/tK3DN5UGKV8mN8Nh6iu5CHyh1p/ESe5Ku23Os77kw5axPm5GgGnqKsiuXwBwS2dEjE9tFGK7tlrg/Penq3FPAHlm8WQiLa6MKyt/tsoF+ghW+25NX2B4Sboln5P1/flMn5Tplv0jd+Kx15PyUdCtMuM8+BrMdtMnStAxmE2UIGDbTRl33LRiEqprvxrBLfNDFb6E1FvnOgg5n41cK+5Rxaau1K7EnSLsat/D8vPlFHYl0ZiuOdwqkjmJp4/7eb36/0/oq8si2jGn49X/rWLss5uyCcSVhJCK/nWakzvIBXg78mKnTiuQcr3R8lPp7HPjdvmc0n8PSxeAesiIrda5CvPvxL5Tt4RwP8OxK2ENP4CTzuHJ0FKrcJTxw7DNLR46bH7qGaqgomBtiesoIpAWqRzS2JqwsyAxsK5CD1mgHwsSP8vo9SbIs/EaeayTSb+4pIHQEdgqKkfbKUDBPpqci1r8MZ4U9Fe9LaYd3yxKrMmjGkU17U4h0OBUvSS9ExXISqGYse97uhzY/laqlh6S7o6aIwK02Ieq7TWs2AV/13OXNf25ZySJ+q5GAlW1jFOyB+DuKPr2IlLlzAe/iVkDI5jPmM8lK+AaiUlSaG8T4RK2llCn41kP/JVQ0QIvKachX4f4nYO1eVY85jETyre9ZTLXmWYomOiNYHue/8u2zdJ20t5xnpajzR+hcySD5Ka6KM6Zfi2BqO0BUZW2OkIORcshRH73moH8P4dRe0UBPAd34Y+4lS/467iKWYT4fe18qUhexDSweUdK+Mry1KZXbj7Ty1r3hH2TLXhW55cQvukawE/G2JNvLoTx/plh2eXTx1ELHRIiPdvCDPBgj2x8nBRgVHv5BXwe9+gGwdpONd7y33s9Izstn92v2M9CTEu+XKNg+/nu+WV7awUknE3LleKVkYsfpWKaFZkTLfOR7gOWma9ztRVfWICH3iXxZP88MiZU+84MX70bi7h5a9rwPFs669FodsWFQAq9YfRnBmEv+ZC4n1IpcnXAP/DP+7tgm8RdA0UQtJoaH3yD24g566qLd9oo3teajCEmGA07Ln0dbQbUob2iOa1x9QrM1tDVPWoaCmmVlE2b7qsQja5kPOa70J25yROLF+GlhrQSuLH8fVsO5eDnCCznbxwrgjdJP+CNU0bjBfqztCmpx86pEN5bRUElZZPwiSqVfkzT7jkXWyinw/i5Fa4usBYzfi7LzMmfXuoWCeIt9+ALV3BFYqtR+L47nBW0rtRy5kQO3pUPv4twxQ9xw+7Ugp1D0B6n5BqVsLddtK69armhhpu1L3H6FuVXPmzAObBqF2/G8Sz0PtTwfIdE3z/BU/kyvtxjdfgN+TzuoLa5QWH483Qot4Bw/b3HnzR0fTjzBNhiOJV3rjk32yQrsXZLV15/CmoykHGGlRfGo5I+2Lf16TCrG5caSQ3XFr7XiIzVZiu+JCbRrECpXYE/HDtQaIcUrskfjntekQy1ViD8QBy5vXASx83DQPYZl1lLrtiPi8mZZ+F2YV6KYfNR5ZzZcD97g5agb+n0IcpB7G3gNuPzjkUa+CPz/y88VUTeK/wiyt+TafID9L2LxkXSzPuB3btD5aejqMXKPvozG+Kil89bFwgpfUJWmvYzTLpTnIudlmLc9tUjXXblI3t27C+3A49xmJGQUeX1NbY3D1bVojTyVprr4a8O1c7XjXAedzfg9BOZ6W7gp/vFXNu2v7tvwCePJf5UIe71WPhh4IJ+90Axw7rhBt8UWiHY3Hp0igD/2sLY038Fl8pgLJB6OmTjLVyo9rk7pUMEq6/4+7L4GLqloDP/feAQYYNjEFRL2AJojLsIi4JLPAlRF0ENDcChBQSIVJsLCNUetlWS+N6qlY2fYyrQTNklzGbLV1RltEJWnRyaH3mkGUO8My/++7c0FAsNd7vf///f6jH/fs5zvfdr5z77nnApe8gEuewCX33dI94cJeczfeLbLJNLbIDSTYfDZKWKVt6ySRPxjJqBDh24Hu4FEtsQfVUvE3jbtq+sacCJSm7fhsxGj0Br5kdAYAd1/oZDYjdzWdvhDb3klvRs6rOr0gVtVJbZaiHHR6QOyxzgiObJ7KxQjzeL7zDfMxGMvPIl9w7eLaB/LofnqFN/hPjJ6EKbjvgsDu8iQyx/gUHynHd3YfhOt3vETIlViHQ94SMY8V8gxFaM0kVn/IWSTm6IWcp/goOb5H+CBcH9gfsWI8dXvwbQtdX4mwgwZkiKX9hdJrilw5v0LOHDFHIeQcEHPOQ0660dUqJbTqCkvEcKSYHikX1ruAL2N9Feo8390P+LhCKurfi919VJtxBIwVvxP5cq/2nzW7en7QifrfRZFXxVR85lTTTYvXxNQSSN3Xiw57zISQcLSI67lHapgtuC8wp+MM7+/PWOs63tBQm1EX2brdGgq4t9SpwBlpLoaXOVkMZ5HGl9KoKnzSid/3UELdwVC3uuM5DQ11b4O61RoayieLdTGc2l33qTS6ihbrRkDdIKh7f8cTGgJ1k6DuYxoC5W8W6xLBPnTVfSiNVJEwJhzrunWQMDcY4Wio4xqrTKyDYX9nkDCTElhP4PvARIrvFO3mI3PP8OPk+1VuVZH1Z3g5G0eZFlBbvw4COe3IK1rHIa4JHa4ZdWw7nsM+pv2HIsY6DjxQfNeBsf7USWrHcGEccs4A4Z0cU43njFMJJpFzbwlajzP78fVY6nXQrFuMSvCJHshgrB1tHjaSjH4OY30NcuTC7Iw4O9rXca70ZyFdYbWt1wjnQl9sm8JJhND5Nlf+to508NO2C1yVMI/CFXvEvp7qxH5b9a48Wsj7rbEr9yGh3U/Wd8VzhNLr1nfhtrcHbqVCXll32RfaEE+Q4fYpENveRsLc4bqsU17n+uLKbKH8c/qu0VS1x3B41ud4oc8qfTy3udFFHxWkJBm72l0jjA7svlA/br2PBmuXt7uLtBjaubW2C78cwOGB+WDvhXYI1HjUeC9+Vxb8gM8//3xGjECl9DZKKO8OY2GsKW1RQCvsSdGG1hTp7M41iLz6HtYhlS137+3CpgXis42uvH92IEad67ry2DYc+U9C6mUhFUsNbVPC30EidYLal2jcBSwC2wn0Hyb0eKqDrXOF3u2IrHXRy9BxsC6eixJH1uwI43aZyagwoe4/HOiHC7x3uHDeCTi7Q/5FEe/1HUgJMgqxb3uT4Jmc3pIqPLOxSnWvMZBC2aa2mhbQTYwnY/2irZ6X+HsI0v1xm0uODzlwZj3WFgZeLPa031HPS3Xum8k2QYbb3LeBfDpwbH+HHBlo6W7g+TqIJ3fsqh1jJQrcb89YZwI9ppnctyGFtjhgzAqkUmo72SyppuIkVW+ZkVKoTxyUbDF2xdbCyAalUlZTJ3qJlLWuE9vbwGHLMO93bASKuWhTIGCR50B/G/3JJQ5K4OcixwkziSBVn5qR99u3Bc9Y6OK/Q6CHJ9Re0MDLajw2S6pQ6yXbq1SK5m36a9T5BvQ+qa24yEWZqSJlJgiUiWt7DdLR/kxo89jmJshimIMSehjucJUMdnzGE3KGH5Xhwbl09et2lG3Xee5SwNhtM4bcHG7Cm7aM9XAbpiH2dlglgAyjdApl2hzo6TPWVoe7WPbv+MaIcLLY/vbIOo3Q43ZoP84YJYSfAXzdAb9v7bCWBCq6Qdhod2EUqlNwyIeP7LhnjIE1B8begxnchfmj7Wydq5Xl7ZG1LnzvalfUTeQk1Wm85F7kXIFZw31pnol3P0cB/chOoN4+PVO9WJPFj9JrLQ964jgWA0ZTTbdqoE8C/p4deaO1Um6MVd5O6sBjGPOPfWfA83dJfXL7rtozfLxcwWXxnjXoj66x6zmXjAe1f1K7UAitslNj0KqOIkx1GJQcxWKdDE7Ne7LR3FTwIC62UfFvmcloaozRDHquQAkZAphcNMYIMjLLzlRTo7GFBjNiKW1HTTG84dKa5RdcWnS+DVMr3vC52K3/QopTLDdbLPdZG/pGSoFeI+2UKJdBdpfOj3AEiTof7JCIYznTJhc1/r029E4D3+yyix7dZY623XkB+wkRe3lb6LvsjYkXSMSnPCt37ft8WXd/ktd3EdNBxo8yxRRbn+ta5eoOkIigm6nRdPHgih0qz3oqzr2NaRl0m5uDbvEqCld75drMru8YufxZUiyt7Wh9U7hP8OCPPf1Zyhog3CeA1ftMpljCPcKt2K/aT24mo/fBSIOkbDFTsUcVVC/FE5/3qB6gHviCl+x8taixiJp0cCakXmaLJXHUtqBkYlXZXWN7DNarP5phBpATa6KdCj8BUunvWqc/HMLZwQfBu6i6A4O5R2u04T6cpAp8e7s7FyTc+/eq0R2JhrUGXy8BH9YTfFgp+LAe4MO67XbfE6TBc1vcIi+ZooTV0XQ7fl8Ipd/NPgh8zfl2Nhf1opNHr1Rrz831gFgr7w2xVPvOXPRKrTx6pUp7Yy56rJd4CcSm2tk8wh6D+ST5R5dfagX8nqjJCkfPlFiv8h4ifn7gXUcX+QF+PnsksLrr7Wd7gJ8dosEzoz0izaYoYY1l4VGCPKql2+N0g6s9t+I3Vd7k0Yd2gm6gD/2qgC3P5+aif72TRx/axu/MlUFsm4CthW/M9YHYkzwDsZ94xLbOvPDHLh/aOROf+LnWAiO44UXE+gEvrSOjUhuZPfTu0Rrhm/MOKvKKKcb1XAZw+s0YxDbw0p1ebYR0tL7TiWvLC0aakxeNTqZ5yR6YUUOcrVHOXXUSzsMW6kVXv6QKrJcX7bYxDKnK5HbbJIyrTLGTiveyBXmRyF+NiVxH69rO98yDWcpqduD67IpxFoe7k1lekjYmLyIX1uqCLBDDnYA/ymPX3ZtBtSSCCvfO9edEOZ/pultmcLjWXP4HmPTjuZJcMurYJUrpf+T1H/G71g8WUXuOFe2cSW0Vvk99QMa5cX8pIsI3Cn6119RGFWFIw8fA6meGc1xxl3fxvV1e92tRjBC+aicwI+NKq7jIbJYf8C6CfqM960dXUPKnVbTJrWLqeMZITfMGzcL7A3Lsp8iXC+d8wBOlrBGOyLpwzgt8UQpmCLY2ZRg1vWBYfC4l1x3xFp78S88eX0LG2o1eYymjz9grJkp8jpQo7LbBu3i7aqFkdGB9dMWiaH/Tioqp0T4mf6BisgP8hgjXvjhJGpMbUURPi8BvKbHteKYh0u9A8gjCUlNO7HNGBRqlEfrwwTyVw+1TkGP7yISDBr3Vg9ykChKu+KXWTNpqMptxN411ZuWcrVxchRv3KLeFO8KPUrhF+wlPGRivQcMiYuaB/9akp1gYBnBsXiRjoiPidBTbCrOvw6yKbDtNwnVpW3W6NJDqCJt5VdqqWad1gRVUXKBOEnHJfIemaJZ3hTHoSUg5u4+aWqX6UOet+97kFnHWnJ+Wpw2ueJhPJlTMiX0HQ4N1ztbtzl0qfLOyrYKKXoA7H6JlBjeWZgn0esR8cC1tDXDO19CwNoH1if1RsCxta2XjHuGJPIKLNMgibuHwDB+wtwuYJjUj3XGel2/RWvK9moZtT5HYJBJ8k/y0OfoeZtIwCnco7Vqrtvj709aLnRqQjslOJfwd18lY4+3kSoYOSsh+WTuKp2W71w6i6RbdUn81bTUKZcOEskOg7AixLC37TMDwWOd4DeLJWANEDIO6MQwC7+S+hYjjQa4Lw8d23ua/q8mDeVaFGL5Zv5WXyqU2RurCcCvvTlw4PtU5F3q8IPR+poPB77+IOG7lPQj2D2Xlw2imRZcfBHjeJ5T/Qih/HMp/ynfh+bFZws4zM+xgkJ8GGWEX+BD2e7ie+OSTGXt2754hjVA2h9F6C8X6txCt1qIgQYYMBTVNvw/3UrvOX1s15+EapiquQsLRW57k/J8/widv9oi+GWQn0Col0WQ20ZHniZXsJ++RfO3UikG1+antrY917hqnsG5ZR40mbG5aGBeqy0kbDhAkAH4r9/a0Sbog/e1pobppFd51FHv3D0ugnq7Tbl4XSRmpyJDTmWlLdJlpkrpQ3bCKstrM2eA3b3S2vuKM1KNspqYNqyDRPxrBg0z90Zw+K7AiIjlQB1oLed+ZN4wYEW0/rQSJVUK5PbXq2ZRQ+y9Qe8Ysl9wyUHKy0IrBGA6rvRnQv7yzzjwF8hloy2KOS4vRDq/Yyt0TbNRNnDWo4njtef6DzRRXJ5xHlOt8Da7Foe9WnNg3Oq22SeW3EfywYRVe50j0M9AiPWVs6jfm0d2tScJjdST6EePN0E97x0PmkLQNvJoMAQziaoelUVzIRjZ1kFd76z878NxH71q3iG1m94i/mf2hXDKRQVp0bQCWqxgKLZzt8Ih4xOwJeSnETRjFRSN62+2tX3b8APw+D3y+CMCD3UC+h+DZRxC/APAjwM8AQ34i0qkAtwFsANgFcBKgE2Dsz0S6MG2RJqjCq2Ijt3C2pAokuBbXRQ/rH+KTFWNr5wFfQyqyocenOzLTnubV/iEbn+aT5UwTFbEdbCkVsQnkv5on7Fa4krH3GwNrZ0HpBzok2zFlUAUZWwppHKSVd2CKupYOV6clpwZXUFO2tDU3t7cWdWyHdHo7FQcaJi+ICNStqEhIf8m2js5SZSkHbT/Pt+8M1O2pYLanpXxieIinN2utEs89FYH63WubQOfpiLP+0/Rj71lxjyt8r37s2hVi+iH97nuaxPQxvHvSnoq0lJh6xAPvh2fVht+bfy/4oxY67IT/F5dIgIZrb2U7MJWO76pFJ/1kfojnFEFpsbUhFWHc0FS3qvZWnw636qd5jh1WcY+ZRG8xDkp93BxYi7whHRKWNBLBzglfWHyCYR1m5M1FUT+RN/OA9m8CvAuAPLPAFfmlh+tJgPALRIp8dIOr/IBkxOM1Plz42WKYez2dAZoijm9d6zjCS+R3cGrrYAZnyDd49NKcneNrqXBty9Y70TeIdpJRHsK5nmbwDd0g5FMjPyKeVWIQzrSFPn6Rub5pqA7raP3OHsWhR/mhk0TKDCw+AZInHnHZiU01Qzi8v9fReqw9MW2KNqSIRHx3iTxS0yT1ymvy9F6cIjVkpuSe/PgSoYLDSRizC88ixv1MfhHUmMd5mWDNszhFs/Pe8/yuzfNTqKrk+ndt/n5K4yQ+hOApVzub75DTVkk7Wrp57WiXZ7XR1sxO/b4FKZEGWGFWn5EOTT7epBrk3Iff2fPabQoO4EPHnd1HHEy7yiKjKYh57V4bGpAM6Z+/b5PSCgfd3J3z2ruhXsnv2/wpqXIQPvuNk6ppPlR2dt875uBw5jUWRrfP7i3wLRR4ZgXafPH550nO1gcM+MxpCAdrcW8SDjZy56OpiLtko5EbCv5apEFr9Zf+RfPwbM+i21PAz9SPjoo1BkfJjYPHEWu93v30Y7USCB3Ve3OEjW0EKkTsUHkYFVedZTtU440QD9yhsprSQidXBEWXZiuaa/RjK/zGhhvLNF5FVKxXLhX+2pJdQX5RePI2FVulaj0NdcsJe08jNYZETOViKvyiFNY39VQ4tDVqKBfIRemohGDuHbM3ZzWPe2DwOMaYeFoGWNSb3oMV3cGUxHpZOGGXpFGb6TaP2Cd5+hh+G8zXGFixQPMkTzUuXhLh8L0MnmqjzMLIZA7fdoVFRqhqSSwVx0RTVRdMtHVs2xyYIyuFOye0tcxBW+/tkFUT4KPrNITPzKPGUcb4cc+bAKvBx83v2gL8bqo/CJQbBCkX4xTNX66+dL/WOsgzwEr5yQxBQMsA4XvWgZzs+cQH733Qp/olnmxuuh9mI1pqpFjf6iCdHwAVjuMGvbNKGHyblTb6VuOXUn23B+r8AP5pJmHbQx5VBXI316uXrMimYnhzXMWK7LTQsLoooBVrpMaUmOnotvqoCibqtDFYg/TsorVVLEuifjEOjb4EZQKjfjVjiWxzF4VDzCEozYPPmP1qpWnBuV61oGN6/+phte5p/tuHFQXmik+4DCzIEi/qP+qbHPR6oQ++D88m4ddcn65ZJ3x5zhfkL6AtOBz1LJXzwG/cdpDIQQ1H+HI5WKjlblXSNI/dkqrQ6ijui0v0BkZ40rqv8ybhW65EOOMH24+NTDTEsjVXnhFO2X9GR6ftb7Na6bQgWHfiXhSUbfwiYVBuT9DNTAecMgCyARJ9XO80P1aD39F5g7S21vBkHAtWCG3Lh+3alh9i0BLF4ze0RrmsUYRgjVy2qK7dZXtec7gLOwidrR/BOlUGnr3LAqVC+3KkQUQw5zErMFcEPYDOA08p86fiBonfGUNcRgGwAJEA7bgX8IBnekQRiWbOKMPaW+9xsrnO1nonnrH5slNaxxb5i2+/j6LRvg1P8+Hw7YX4s5LIWPBtCPjFgcETCAnD9wxc41Mc7BrpNN719sEqg/LqowTDV1s/NJBRr6sGn6lg21tX8PglhUeh5M08xvN5SoyP4Kn4JvOsZi/ykznxyCjXni7tQzWbwCdP9V/PDYqKNAwKI6NPBW1PZ7bQVXR1lYpYh66LKAqKlhpI2DNpEkNYbrAurMg/SgLxYF0VT45JIe2wcGLSYRvlF2Iko4c0kjHK5o0JmzQmoO27TUS6oony1IIN5lKkJymo91BaWC5ozrGAigfTgnVU7AlzWNGQChDQVL/oiFwu+0p9ZdopV103qOtOwu5LrVVJDbtU92qYk97Crup/dHoWkSiNScr5cdqrzgrQM1l52nn+2A8jisrSYHXa5Ou5jafl23hms8bCRKhTvIzvX94wRubwaJ2hpsa8f/n9CJmDuTxcTct9YR09srYwbURuYdrw3MJUpoiKk0QzuYrmTfocaHPzeyOKbk8bCbNKELeEZzMo+QHAhoo5gn/jPCJbTFT0KhOJutPkHZYJ2kZupti3EKu12pZ7HlA0v1w0GzDapaASN+yjqri0kRu5NFvQpooTFUrALC0l3Kh2uNmYrZTVj9qoGlZPbX1CxVgIs8OgDcVxeY2XGhaTl67o833bmMtVbfxlKoppPpc1w5h0io4CHMKmpLJ8gJxO8J1gMk1IQ34Q40h98Ma4OT7AK1lYsP4Vmzc1WzVb6b/NRzdGM3zje5fIHhL2uCq8PoEPIDuvDNHVXPmhNLge+KoPyyWjQ9JGa4brYLUY55073gz9mQLrhqV5hT1hdrZOxOeNub+CFTtupsOOmamYM+D7UqMjcoPMAWBjhqQFCDZmdq13mt/24I2+WwP0IRv9NZkghaM7IjkJat0e1znFqaLeyEUdQjukQABbgLrVU+9Rt1DXrBdc54H9pWa9sOMaZ/73ef90/OIpGx7G4fOb6DYSObjBtzqcQ5s8hQvNPcIr0FItkFS5p4GFqmKE92fv73R33SnAd6dEXWY4KRdQFFA7t2gb+JIBXFsrb3B9RRrfymdy04rU150NwEa6GT0TJZGPGWCVzLq+oYr6NZRbz+HzoddqJJu9wVMm1rR1PlwAT00Lgt5/duLdi6um0dEKa9w6d24dJ7x1XYNvz95pWsjtBr/tiLCLQ7KOTFBYrfpbeck0qqpOOJvnJ/2IXPoZ9FKx3UP6LG47BzFCxTlb3xGeql81ja1YMPXkPnYsaQ5a97e0rZpAO12zaQlTNb3uGQ3SKcBRGRlpqGQlwtvYUvCM9jpIeOSe0GQJrx/n9iTfurtNUsS3vtrmtp2ppnOxp7f1i2AGkO7Cr2d6VEt3V6k2cMyTiA/fWtXGFIVDmQa9RzWzvTpkezLf+kibJJdMuMPkwvpZPVX9PowR3+vObVzIrYExpjkqDh2yjfUbY/S2nmfSo0cb99hivA/ZpH4hp/dw4MfLvW0ULZ/mGT24fk+TmyScixJwXeggYYirV7h0F+Ab6no/2tvmnERNWmSu4n4wUzfb8d1rz6vmQ7Yyv/GmOYe+gzlbMhlWy7lIubbaU9i+4OM5W0OdSDOtBvcCPGgfXLtTtQt8TReF1nNcHc0thNmvvXW4A7H35L1yzyQXhw7Cc3Y8v4Me8v0qW0bt/XvdtCLJ5BG67fgdtLH/NJJxoKOjZtQhhYOgdqcda7vPezG5EfSmySzQY/MXl6iqIDN+mY2KG2ymYBXv5c1URZu7aL2NTzXT1XnmhVwUUGyfXVdLJhwzoTzUCfYXz/8BvRr0thlPmNgP2JT41ZjIhDdNkurdTQyNJUNyXzUjVqraEJ6K9sdvz3eSSN5Upao2ut43h5kpUcFFubyDcYeMXVLxsl2UicN86wsOlIjnHMeAi4hl60ViyL9IpDLcOwkwB2AeQDGA71vMAUY4c4J60tl6VyctnDiBb/uVgWdPbR7CHavFkyWO81R1UMX4yEATNQrPX8H3xaitxDqC31FbYyNan3q+tdARLryTQxT4xm10pMSAJcmoX8xXjQpVi5lENp/hWzOFUqVQqslcKfQxmCvaj31s5qnX0EOI4t1HeEDJWxxDIsgoRrhbqDtCRlHVzO4YLqiCWDm+qJapprZL2tzjqNgdKupJL+h/NLSM704yuWT8z0aqOjr3B3Mo95NZwjWY8Y04WdHmuogKeXSYKb9iWSgDkrwgeriJ5vzDdkKbofzBWn+Wjh+XqzviH+lpwpI8lHSVu2yi423mDSOCov9Zj97Br2Yv9pI5npOyF81eUV7nJkaObJgYs04VenanTc5QLF0bCLZnVNTgcxj3jL5cnxvp3kDZ5jMbVBIocysDPmGkW0MC1KEhPpn52Yzz149mfPv8xL7NKoajTGDNGkMrKPljqqsm8G+P0EUB3CCwTWy0w+g5TRLdWk/l4t5GN7CsEm7ZsME8NSysNhFkeDUPmmKUCzsa3SCu5yl5e+tHbRLOvzaKa22d3Yb7o7zAC6UCiDXuYHCdtmXdncQ64WCp9VaC77GrwqjU1tbPeGJYDXLS3rr5UHvrXw/hacIU+C0vdId2HPI/4Hpvc0Xt4uLF3e9t8q232Xu+txk86kqPdzf51jl28V1XOb5HvhmsKG/s+fYmvhO6oehnD79vNkHb99ZWQ/tbZ0pGuIFkyO0FKon4nizurZdJWsz4TrGtVw/De/WQ06eHrwzkQOgs1krUYB9rghr225xat7MUR1mj24VzV9pw1XyLHfw9mhrra8R3WJ6ENTK1jYDcD3fi/Eqslx2usq7UQU58Anre7IpdcJwRQ43Ck9FT4GOf9tOg366Efme2+1ROHzLOjQs6R8bpOfZskHaMMlE12DhUQ1mb2kgYZX29s6iWjJec0bYQRu2QtOxMjrR4ENxR8g5gS590vdOPOJ9qw5An1PxSqPlEJ97dJ+Ops4QFTCdeMjKpv0D/Tmcl+bRZc6dr7xzeJyfWCB68XpAG1L3hfGQtPoWmrCXQwmVjpLC/1VXOr0c5z+5y07vLyUGnfY07rxBmv61T633KI001YrvKs36nzano+nY5Le7QZAA6ARdyYHg3D4J78KC47RoP7uWBB4SK9DfSkcHGzbUumiYING0Ca4p8mNfZkw+RDuCByKnUzvrusKoT65hEPlgPbKrBN9CP2CPS3LkqO8lYEeplDOPwSYm9w4PDnSUY/qzDv07OeddYj1DhwWksh18Ikf6Nsi7kSTh+zfAL3Isa8UYtPnvB74TS4/FbmH6m1tZzzjCQQGn1vXUNkEJZdwvvmWNL+G3PIugb91n803TJ3AprHGk1k2sB3CLB93/d7Nq3uBupk/yU6pGa0oZds9y5p1Q+XOg5EjnK6id5RbOqgbJ+7XgZsN8Ba4FL+peA/58Lewaicinrx47nIf6BgxpTlJvIuZ4nVs96SlXU8BbQWd/8qd5801+SXm76OBtH+UwHZS1ow3VhMOdWRVl3ObTWh5WU9c02PeQ+DLnzwHooQH/cn6Ks28Tc50HaPDZT1onCvoizepANkL5IiA02UBF0BM3qNVORYlQUh+fMjHSQCR6czxl8f4q2ERVjI+qZqrG5K3KZRuDkGGnurG5cKWuRY5U4tmr9ShhLbvfYFjqKIL4AsHBOLsq9YCbWzzuWaRDT+cIdBco6y0FZx3XgLl+7Y7FmA1w1wgl/lHWaY6FmnbDrQNE2cuJ6Dvf7LAFKTnTouR9v+uTyx1mnQqTRtzdkgZ/BPElZxyMFoAxlHQH9S4RQsEMJf4dAjTQNtjSsDeO+kL9ekB9PB7P9GLR0MiR4rJ7LOPcCF5mrFGq22+ciTnYyoSj3kTNSG0lFmfyQJ/qi3EqV3ozSb7ET4Flk7lpzLIzyJ3usBp+BnbfjUysc/Rn7eEj/zo6cXW6mrCftY9PuGZHFh8tHWZ30dpWe227EFj80h0O5D+3hQv33uuu/ax8O6XV2F/U4MxMx1jxMGMc7Dr3wbAz4D6XXCaGX7Di2nXYJFyiUecURBn+32nGsOKIqu577WNSpnz4botD7nUgyAqiTJ03W+2nU8b8Q6YP28CQCcelLD014C2SbwDU25vFRIN2qfSCNeBbD1JPH95NIhrvl7L4rxE9raczwOjm4hdCUcVqjF7eYhNK0jaLs3+hDyM3vXx7CVCaqIfc9D61FxWitwZJUQxWJAW9ev3qm/+NBz6roc4uHvRY0JJmarrWoGXzmddkUWEsl3Gyl3HX+xHZfBmn6OIM/QgkygWOS212xsXb8e8HB452A2I9gbPj+KOCacsCWmoPrGM0ZytrRhjK/TR8DMklZQxwSbo4GZWI2/PW2Y3v+jjQIM0LYy6GBsJPHsMQxE8KtQrjTngLhy0KYB0qi9CLVm4UzBTH0DzvukcI+frG7eHNGOFudsn7Lu3YjUFYTj2+nItbfAp/GaVAmouHvx0K7n9ujIGwQwh/Zx0D4kBA+Zh8N4f1C+F17BIT3CuG37GFpeu5Z1cEGNu1ZVfQ5N1tlSpTY0w5+XTeOO+1RyH++C9Ot3ZhWiZg+JGK6jndp0P2869TrBzLwep4ft9lz9ndA3znfzXzjarlfzH3NVfGUj3FynvfbU/fsHnvLtm3bZhCSmkTIZrgmJrn2cjfUeG/JG0Ft8ahatu1jsBBZfJhcUnVqRKohcPhZ/wjLT3emhb7Y9D7jViXZTlV7bvkq5FRQ0NfTksnoJaE+Nr20gd+xRdq4kB9DQNd4avKrqlRe4u1hJBNbzgC2YrwVPHMSfay5Yz2uHzyqY0dWE8m2b4KYJ9ndjxD3qm+DNHvoLUwTJU3dSwkln1+3j/uMY3Ys4iXDs3mJH2X1s7v2NzH867AKazbN5CWHZqa42yTuF0zu25it9HYq2Yfzscm9XrRJmaxkryrvPYHJkh3SqpfIkt10FRkXmJzFZxwOb7iV87myuULa9KC71loyF9v8gQc+gpV7hEdbDGtT62lhzz2xfuoEu+2YD1hAf96pkPK+k0vZwP1gcnt+ATcF4lPASlbMdYc6R3ln69sQWw/W/CBPCXsqdjsx53EHWs1FYtpOJ5nozikuf6XPG7EI6P2xTSpVO6TNtEPK41cMP7Z5SGdBelUypPK4WolqIOPwOwGKyynrz/BERybiKbvUOC8jWMDwubykMisU057Q71CFcFdNbkBD7wYKVqd/W0dHu5uWQj/hcvzK2Sy4HrTRsDr9To87iUB3hHPOXtBLqpePOKTyO0fCJTa9mpom3erVtIHJ4iXBG1QqC0XbTWSswnoOylHTFvERcjzb9oQe3271qoZSUbjSw2fy0iYJI7FRnttS3KumnPPc7rHNs4l2x3v27jY9t7yamsE0/cU9dQ/T9Ijn8mpZMtO0iWFfo5oelNBVQGfA7CPnGI6qRnqT6JCzuPMM7ytIplONIAmei3nJSEp4JwTP+Wrv3JOiB2mgqzW8ZNNzquncOZP7DjfhPNhraSdNLWb87tXHV/R371ABDXS+DfQ2GAU7N/kRDsdJGkOKjtuctJqXRKel8CZqzBKzhyl/BI5Ua4mInGauaMK9rzgf3mfHnZhr1+k5FwXn23G/Uc5et2o5t1D1BS/Vg/cvzOq4m6FQoO+KdShr+IbDHpCoh8AXznJiCTzB5kUnJbz78FQnZa2wz+JHEWy1zO5WvTxUGudWNQu0K64xRrAaxLquE+pMTGph97ptc6XwdpdclUPOYLwHIJ1u/oy7ph+VLfPeXHXRbfsifoxcOhXxc3tycZ2HwOUuHlNJ0qkkym50e7Kr1S/sZKKEO9Y8DjGfr7U8LE3dLbVJmM3J7lVeTYwnhN0W8hIfYv1nJ77dkOSM4VIgjj7tFKcpRcL9ZorfQ27ezt0T2sD7b2aqdtkkUurJL/jBNZK/4Ur+WPM3+sdnv889nkrGwOq08S2Vz7l5IAHIYWId6qSEHT/enVT8Cyke3G9nqGoq4TngnuRebKnB1HBJcu+yaiZ6pLDHYvvDD0fT1YRFuTyk98a9f7nx4Kle6iATZQ3UqPg3qPh5Qss/dryq4s9AWShZCyUX5HpbPchtgqfUpSmVgqbAun6i4vKH+iNkyZ5osB47H4vfs51jqpYEgyTuQC+EWA91uAs+DbG+1YE7c/Z3sLnJvGTViyk1XJOJgvqv6JnqSXtvD47nluwZnjwPWrlWe0eHm1j7aaH2U67at72q2gW1Ccs8K0mQTkL7Q6x/6TigspvobfHbJ1VH1Xb5fOjzeG/bKIzBKzct1zUOMtF5tWIvYePfcGt6WCKJzxZaKOx4BVuoxrOES/aOaXQHeoVyzLPjkl3588R871qh1eqgHpQhY2aYXVYorkFrpaXvXiBjPr2AM9IIfgyHUvvDRe/tUE9NcYEC5ccB5ZNaVXuxrTRz3EimyqO6Gqy9BP7SVaMuIO+Srir3ur4L53aISNXvumBTHZ5p9665S+Y9OrBHd+6VC4R9AOa4dDxnmJxIEn0J9X7wJSTCCVzMGWL91olf6AsTnpG0CPTF0G8dUcLuQmK1dIzREGtDexSEf+4YDeF6Ifx9RwSETUL4dEcYhL9oX8eh/Q0X9pajNH7eoeH0grZ93OGyQHVC+WMdOBfsb79J43qT/mCHS6dfb3f1/vd2l1eBabs7vKHtZ9tjIPxyB+rONiFXeBNww6kTEybGT/wudthviQmUT8aURzZKp8P8PQP3N8FYFfgsxh/WkbBGVDKcv7EWfD7fk7Xg5/mdorlPfNjkzsgRuK5pCLc6wXIfy/AHT4xYl7fj05itSmK9oyNoFgPrH4+zNAeedUZw4s/mm1KBX3wg4LW4w/9IMDcI4qN4f4hnQdzfNsTP+wyeS/KUKpj7pcELcm/iPSE3GXKxn2A59qS1ps8l1qkdeA5NzXSnM1f1og+ukSnAFXGXqnUz10GYbiSGDcA3+QGtRSkBn9LtKYsbngFpof1GGrItRDbPQssqLQVLKi2FS0Bj9VpLdvbXTfPmHTSsUskaxiXrLTS9zsIw6y2EbLBQVFc8YfxGg/xIgBV32lAx2hZ9aLolIIY2KlR5TUoqUEhn4tItgXG0MVOV36RmsGc85/NlGyX5xsb6+pylHb7t4Q63Zn2Q0kYoxuELIbXD7fJCpW/jKzbWzRdKUWMhvT3SkG6lZZh3LGhu0084zhSPb2Du8T1nI7IHmggpaaKo2iv6kcNOAYdGyk5ppDkWOdFapstgjoSRJ2cOuqL301u36w/biFZqyLFkyDJshCibJHOVFjdKfiTHki5TKJXQTkCLfiRiecm0xUr8JAbgKlvrWHdZamDjXrJ5M/ttLC07I4uVNtC2wbLjNhlNOWTWMAdtkzVCCn3acNzGyiiIsw5Z+zmD0iKjNit+DnnRQEFvUWr5kVKLRDJyeugZWbzvOYltsOQDaJF1SKxQ57LCwpAwh+RyioUBrD6wycRcGnIlQm4UJz8CJax4fQow3NCiD3Q3rGvRB1Dx1C1zzMjPIANyNMp4jd9uRuS3xBDM4RnFWyyM3wgDfnsPR569xM2kIBplpEEJUiM/MviKXjLdQF3RB8iPIK1TrJ1KZYuOAooT+RFsP0RoB/sINXhzNJdhoeLdDZkWZhK2rGyBGRtkc7NAPxKGpwGDjBRIbLESaMMNgMow95/vD/2lGhR4gjEFltCgAi7+SGktMQC0bqRhkLVSXWWt1K6z5s7VzYy1VqqkBt1MTJEYsF9XW7nliHcYjCYU2gDsaCwFOdC7V+O1OEhwCv2NS2q7MMixbFmS1HL6Ta2VoXMs52RBBia260o3naOBuwzuwXDxhOlUWHwJcn9w8pGLxKCDPpyy9JbGlaGWgOzhhlBL4LynLDK/pwHA9vHjkkF/3MMs6XMjLOlZgMmkIIFuSuCfGjiZaNzZRn+JeP7QRl9wh9VmYxtzAeLuP7Qx83cAxYIMc6yU78s2p+TtK6Sy4IqiXHIyxzLHd5WSa3J3V1k+ClNa5s3VWj5kFZbbM7SWLye8ZeuQbTQcvtJYOuL00S759+2Sf90R6IXjQLsVFpoAdtRbTUskxw1fN8nclBbMR9xQ26jp5PIe/WBbgt/3+FQKqKsDCSUSdvokkOVhXbLsRkBTXfLs1oxtQkkV8sK/6ZQOJPeqqsmdut2i9gWNspzS6bqkHOpJoJ4bSnpXPaEO2ofe5YU+mudYaF/o5zL2o7bQDGoF1oFrMwv1CdTtWQ+1xc8EJTgF6dJ0qYGa3mpUWtyppwXa6mYykJ9J1E0ME+jKv6XVqLa4M7qZyEcZ8DPIgNyUGTMsSnfkntrdZEK6Yd+oI7ojmONuwPtrmBtsxJq0CbidEGjCum4m4HlCqFDCq7uusoeeAdWFWAWlO3JjmXqVf7nJTQJt+KIcoT0m1o16tL9aq35eiiUwUG0ZlA/aE55iCbgpxeJfqLWQm32hv2dBd55RJds6JBKQIvrkYqnWEku/HVLYxLi5wqAT/toWMu7tJtp3TRPjG254O2QNh3tjxLJ90pcMkL5jgPRzZJ7F3TfIqLW4AWZD1mgt7kO0lvcZtSWzTGs5DvoXGnrMhHzyNiktRKAMQPrbZkwD26wm7DXpTrq6980DTQxYOehH1tPG647AeOfMgTlq8ICyvfliCuDy+EWZSF2pwOWklml7MeaF3IuvbInfi6mVLaP3Iu/GmTHmjtyclNTS8SamhZuvyUVly4dvQkxS2eKzF+JulS1Nbw4yw2xM77M1qkcZ9l8hoedsnUt86oH/6VrLMTrdkqHbBzqqaNpAQG6tFNHNDLDqtWGmQFvi6sMGSvBNBKwtmZnHbUFoj2T+DtlltEdBBgXU0Frei9BaTkUwMP8gryJgXsE7Sp/D3LA0ywNHEjfCoLV2KhQtCmgf21QIMTwVnhj0+EQMfAf0IVRkJFgLJfMk2PVKS/jKSkvEyjuAX4OWnmwKzH/PcDJIqUhVKBUHDYtVwdEbQX/AgmuxJdZaqQB8VOglgGWmwqyVyiCDRoUtJRlftFG0Eqyof5OMvA8WFSypjYCvQn+jUeU2KUgNeFqBp2ps+kr3Uwop2n8aanSOnXuyVqDO8QwXdXBG1M3UEAV4Af4txA/b/YepxqFvf90mle1rktEEZufdBgI1MlVB6sMGoyII/KMnQdvXAVbuBj3gSsVS0w4gXxgcI86eESvDjIipxIglpQY8iXSzhfILNQi7/nG+gTkzEuiN/BhkI6unG8gVgX4wCnU3NaG9pUOgNrSYT3Eq2h2pGYEtKVr0kA+yx0iA1kA1Nc57OTBL49yktj6jxntlhIR2z1dY1qvx2nwWINDLNXvlWCgZbXiQQ29FbX1bLTW8ZNNnvXSFMIcdjzVLp77UdDzL/yx4GO35yQT+gtTQ6AuB1DSrm+huWQOvhabE/AxLOs5sXfmWczrEwSkLtRgzR4AVMmU9CdJfBVBqDAFfkZIp6CAcX9gI/BZmvtqS4a+2zA3Y2UbFyIBO6D3PMGiI0nLqzsXAOYostVXSHWOHn97fi6dAaaA51EiXGjSoETCTzWUrpx43nLQ5GYXleIZuJlIX6UFNve3cIFuw3zkDEThx3EZopTAf4whwpDmWGKIAO5BlSWe6RoE8hfLptEEhSA011W5ETamCdEpI15AATJ9mN6L/9oRZJo42yIDj9TLCuiA9yBADf0+bYOTE1TviPRT9Gq2UQ+8RQDvYiPUok4r2M2FdxpQGVJJy0u5613RP0a2T/dO52PhiE4O73GUaWmtRsJOBzvostSUgQG3xD0Qab1IlGhYTle1+sN1Etkk1yrA4BEe2v2mu3yjDS01zGbTS+5u2CLEtDNrm/U0mIWZi0CIPo5CHoaGNpo6xSVcz9m5S9eQMcgU5UhnbPzcmm/8obZ/upq0UaFTZcv/eKsHC6vZKubvMGJYAxZJa0iFeYr5G909NEFZVtizZCzF1Zcv0vTng6wHdprs34hX0QbzO5iVfALXo3vodYKRqMi1Z4NehNi4w7GtiyEbDJ0MTDaWWH3QuSyro70ralGNRjHMzYa2fIawc94PxNl7ijbbyQU7K5XFOs98BPAebRKYa/GEl63dkNi/9h7O1xSkzUCxhb+OlbcTgSrM4469La3Q+dV3ayX7SPulVt+eYXDhKBRxpAUfaJPgRM7XCOLDsPlun1u+U1vocs79p0FKfevADIvCLJ2ixI1yzh0qwMgQtWp4gs24mf1xRGkoF+XblqYjvyX3CE9Outjy/7moL2+nbBi2e++ZKJYasull1+KVwEhmK/IrBXGItr3sDLPaqS5IvidWdb+AljQ2X6Aj8lgjuzXqMk3DS50h0mulR1U3c8vp9jvXNs2pBxz1w1cQ6PFqfVsy0MLKnFFrLTXMOt3W2jnQ8xPu2DX3fo01qD5MpLYx6W4pnfVOQh80Zo7eGrtuWomgOXkcnRSe/1OTJ7G/rtPq2+ceRNqnt5X3JFib5BZVn/bhgYnPG6a0e615QKZol6+jEcckKi4eCjCkIGVFLIr5WfHSJqKcI535tgvJkArH+qidjIJVK5Fzp+x0bWsnEVNMmFX1qvYo0t+kfxBMYGYrdwZEJjUYom95gpuuc3+OY8O7vE3pqjGYYjCMVxmCvbeM7pW0jAjzbfK1ay2DQPkq9VeUBI/GFkdAnt0KbX+j/yg0L2d/GW6UwBs82YhfHkOIhjoE++UIKaX5bH8S93OQpgTWL4jnzx+BHH1LAGrw9HSgX5nBr0VpC57zV1mkf6XgMaBecDN745TqFZ5vUEaz2lqktkuQXU2iHRzNxeFz2rg9tkkg8bU65HvzNF4GaD+lfs9GeBckvN3lJ3nLRMxno6Xhkn1KoKRVqADYxK06+mFJcTycWADU9FbDieQTrpKcouS+57FNzjWRCsXFRSEGTr0TicLsSDr21K4argVLZZMxM89MKXIOFORgr0qimjUde26VtQ8koB3N5i8KjzbPdWx0MPCfKx1IkDrrFo74Y+S6POflYysR6Oikq+YUmGVXrolcoafPs3AY4ypR/TcGSSK+gk39NGQIYYklfWBl5zJxqnszJOanZj7t4MYhru6hO2XPyYBNNFYOPQSU+w71sDuJ+MUu5p80e3Ffmddy9ZpSWmeY3bbRvdPJEcyLnAS38gmtE0AEipRREBuAPMJhS/BBEpOPxk2lDiPQbAAqg/iYifQTgoaFEugWurwBsE0EDZY8M7V1+GqTPBbj/puvLE3DIigCMABMLCu+amF9aUla6spAIkfLytVnya8EKkl9UrJtYVr4qLnZZjLyioiKnYFXehHyyRpdTVp6Xv6JgzSodRsrzyrrDqwuXF5eVF67uiuMVCpcXYiSvrKxwdTkZXTaVVQrB4tISdlle8crCAjavnF0Ggamjy9iVxSWFU9nRBSw2DIEyL6FKmW4q2/UbLU+sEFMRE3ZpXhlW6ZNaVnxPP6lrygoLeqamZGZqM6eyWUKmrrS4BNBni8vYktJy9u7i8qLiEra8qJDNW7myNB8GUuBqxlUXW3H9/Rf+uKpkyv9ohcQ/WKEiIytTrKJSZqVkZGrEmFo7JztTm95r8AvUOZkp2fMy5/RMRcjQJN8CPHCRZR7Q7JbRK9ewpctYuHghN4vyVhcsy1uz0sXQDOUcjTosLIxNhWRWSO9qMW/1qrsmj181sWcdEKOdAfhCABlzM5HWAUwZTaQzxwgyShZGECnIR3HeyomuCxS3BxMpwrqxRFpcUlpQOHFZWY4QgMxVq3KKCvN0E+FaVrgKEq798Hxs8LAInpXt1uMqdxO6J0vE/OKS4nLhz8TSspylq4tLlq/RQUPFq++cCJCTVw6EKOqRsKaksEJXmA8CUVy2GtKh3zxdUenqQkB5Vc7decXl1yXqSsswcXpJaUneqsIZ5O6C0uUT7y7Iyc8ryS/EMXplLIjXaAVBBeUoWe5FZqfMnsouW11YyI5eM45dmbd6eWFZOYS9CIjtVEFGC0tK1ywvYqEkKZg6eg1bdou8YnQFm+e6LHNdVt0yeg0hEkIThiiAyFIyCMIEECxnCwqXrlne1SaqArAdDMOy4uVs4erVpasjy6LYZaWr2Uz16IIJXoR4+HqGDht0U2JSQsyoiLHjdXc/sHbliqWFqVpOmZ216LZG8z8vtbc1Xzl9/lvTB+9/+sXmvz237bFN6x/atffvL7y1/90jHx878eXZc9+cdPK2qz/9/A/LOzV1R/e8/sqLT2xc95eqp57dPoaNmjBt+qTYkUEBQxiJj9etGQtvT0tPUZUW5S0rK7//nkf++rD+6Serd9S+bTj4xu6XXrZ3tlov/Nj063sfffVJw5lTXwPdctesvve+ufNzFsyepU4OHjHU3432loXdPDHylqlx8XM0ipmZ85YsvuvOiso7VhXkz5ginxw+ely0OyX1Cxk+OPDN13a+uu/A4UPPbNn6/KOPP7jh+3rjd8c//Pyziz/88pujo+Vyt4GMJauKK9jyCuQHWV0IpCR5Ol1hSQEQkCxds2xlYQnmoL3BqzKDzVzAlhevKixdU05msBm3zgbe5S0F6yfGQJJc0R4asxSszgo0hCAePZLXlPTMwN8zco+7x+X5/vPduZ7bgj9Y5fFEyx26Sa/kX3rp6YLnYjee9X354Lm1Iy5907ix/uTfotPf9jxyX+0DHuMPmrcMN2wu8H9neDNbc0fqnXWXv1ceffD+r8+ENP3csGruga9bPn7o1Ib5W1cGHtu1ouAe+9KOX08UPqpdQg2uX+men3+Ln+OKj/TxT9iSabf7F6f/rMz9ZvWdy180/cxMn/m1JK3jIZ+TKw54veLYdWDSyq37VN+eOHRWYT/8+k8rT8euWXI+5Sufb88tvMW053V5/c1Tyfdz9XO/+2RIntFwoOWtsIgP9s/f9vS7X/m9cuTgcwfpSOlGt5x99bKPRl3yrn34vtKJAelFC/YMz3vvlvHL3t6sPHeX+51nqcPsya1j/b/57ZGHau8ceeBt91d+Njwf9/XBX1484VERbyd+f93l+UzQVt8fDvncUTn+llXSv60s2EItyb/YMnfFiqV5K0NPywsfmkOWNv/jafeV975CDXuvRbr+1g/8rnxUX1OYcemdQZaDRzfdt7Gu/fzwhqWa8WduunzfqccK079uW5C3b/aXcw9MLSeHX/pRfuhr5SvnZ3339OlbVn1germt5dtTd1wqVrfXl8RzG5e/YTyYe6ZsvCT5wnAmLifda/eJ+3wapt/plrFbSY/x9/c++hdWdmL0gaJb9z9Uynp+vazu+Z/zvvS1f3/71hP1UeFbjTVv7fru46G37F+4zuetCdOWHHnnjZXvHmM3HPzH2/sN22U/vs1sP1lbPmXmN5a9d5989qabz0o2DDlXNsg7/6cHpxU8NeOOVT67Ft1xj/dXvj8/6/SsGvMm8ap9zuP+5Co/68mXpA8XNVMjOo+7F99269LWz5YX6u9MWBlsdl9Rctewrzsbo089suieM/6fz2pYXnq+zm7/7ehf1UffGfrNX2tyf3np228fqDK98MHx04mZzee1tuWHTMtvPfz3BvcDSWkJ+1LPRPucTh/mtffqLCYh9x6J8v3fcs/PO798129/LYlZe7SYe2x/3mchG5Yd3nmydHTCj0WZT98t+5yZ6X2obggdPvFmt3lHp737YaT3kX1PLnorWnLH/iWvOr87HvOV8cCm5+rHDX/z+8U1xwuqb27O/3XHS3es8apaRb/m7rkjKcG36aHlHqsDbyVu62cZnh58z8Ef34yuvTdx2Nuy6r+efNLn6DcX3vnt3H1h5896f33y1F9UP35t4/c3FJVsODPyiyFH1y2+ue7qD3fXlN49852gi4ukG3V3+Dk/nea+bIk3FeB8rvCJ4jeX8qecK/JSvlo5pOJHr53/POnzXfYGyZzj+5kpeTcvf7V1SK5x9sxizdm7S2bMusP05rlF39Yv8z6vsE47PTnrzcOvffjcoe8rv9o385LzgDy0+ciRR4+/+6m8an/W3196a5RbgvHdKvfvvoi69ftsw/L6iAn3LNt/cFbeB/Swotueii4dO/mo91sv/FX2/rDzbose/40eH1myZuXKKFJQvKZiga50aWHKsuUzV6aX5Y/uTiJEWeKaP1+Dq49X9wyKTlcZzlT5RYUFE4W/OXkFBbrVxaWri8vBgSrok7mqEOYgtHJgZ9H0UDCPuBEvMpjEkgLyC9M17+L33x8CeHY9kTYA2AECIL4Nrh8CpMI8s2Z0CcnGa8//JEOYgXr8J1ndZXok9vhtepBI/wbwCsAGgMcBKgEeBlgHQH4kUgbAHcATQIZnyQAMxnNIAEIARgKEA4wGiASIBpgAEAMQD5AIMA1gBoASYPo5Im0/S6T3fU+khwGs5yEO1+lwvQ/yahqJ9NczRBraAPkQfwzC90H5dojfByCHfCOUTYc08gOR5gIY999meK147wzc5zzj6YlJPeJJGIeh6t8tniicHYZpPeJJCFA+qU/9pN719QYXxfTddTDSIyzU6dG+AXHokW8Q83uW78bHFSZJYh9iW9fiYl9dOCR5/Pb+0WUbVnb3B/EZEO9uD8OY1tWfWN7QIz5DrJ8klhfK9InP6NPe0a54q2SSASCpR1xI6xPvbl8sb+gT75mf1Cc/qU/7hj7tGy5KDszo4gGWhfjRnvXFfNKj/NGe9PbsdM7oJ97FHxLcWdlTXrri3fLSp35Sn/pdsmHozb9r9VEmrud/r/yecUPP8gPQrz9+JA1Av/740x+9k/rjbz/j69KNgfAzDMDffvnfp80u/dP3iZN+yv8e/YX4dy92HMU+g5rUSWJ8Rs/+xTjm9yzfXd/UVGn4uvmywP9IbmnSaxM/mz6/cpyhbuPeo2J+kpifJOYfFvNndNFj7ssjkyKW13fFkyDeiz5i/tEe5bv7lxBckwwMuE5z7wPSPoCrGKZHvmt8XT+9yJ9r8RvRbPy+4TekGeYPTrp4tCfPIT6jp8x9236su719S4Mw3l0f4z3Kd9U/2qf+0T71Z/Ssf2jpLANAd30MY1qfeHd7YnlDbxm/RpD/9pwwgIz30IHu9pP6tG/o076hT/tCeVyvTi7r6RmAU9Hj9+FG8D8AXttEpAa4HsAwwBsAtQDxFSS+iMRHk/i7SXxBPom/q5zEl5H4tSS+IkZHEipIQjRJyCcJ5SSxgiRGk8R8+H83iR1P4taShFUkIY9o+3osLODQn9OCfsts0fHp8Xu6CvABMAAUA6yqcvkveVWi/9Ln98UeIu0CLIfXnuVueYZIbwVIAZgLMO8ZVznlM65ySXBls+bNTs5JTlFrk1NysrKV2Sk58+ZkLZyjTklmvUg/uTO12TmpKcrkFKR4xcBlhNCNi6SnzBEKRI4uiBq4VLIyW7l4dMFtWPSGhdjx49llxSXFZUUQGrCkOlMdk7A4RmiOZdnFoytu+52ysf9SWUhNzclOSU+ZnZKdufCGyEKzfRq9UdFEoek+pSGdHc9q05BsM0vL2bvyVhYXCG2wGXn5KwrL+6anXkvPXOAifAE0py7KK8E7fQW3sdBsfhESmhX6gv+LXX1iydu6+8QbtdArIU7w+T0EWaOYkWB/k9BME9qdATvspCWE8pJQlWC7/Tww3U3iB3a5Es05cfeAmsRJSQnjKaWTiCcZiSabeLp5wArCKawdvKF9mdi+DNr3Edv3gfZ9oX0/aN8P2vcX2/eH9gPE9gOg/UHQfiC0HwjtDxbbHwzt3yS2jwakUhgFAEWEVOdIAMjw9+r60V49ftKugD+hun7XQt0R+EtYTy8fmTcsu5aWrqnILytctrwEFmGlSyvWkDzlMq4wZflMsrJ4aUVFTn5Fnm7N6sK7ileXr8EbnBUVguoqQv1pBd6PJAkl1DhRnzF+4T7Qb4krnxbzx4vzJBLi0n3CbT0hXyLmT+gxP/7jvuvtyB/+LQDYiQjRdDxeIE5hnJZIEuESBPEgiNOMVDodfU2IB2Nc4u+vQP5D3B3ilFjfA+IeGBfr+0PcH+Ni/QCIB2BcrF925+ryZYiH34kk4qdRkM+eUUBYQbLaIDxESf4xUQnpShKzVEmy7lWSqY8qoYySLHkJ8vYqyQOHIf+Ekuz8Bsr8qCTH/wnl2pSkmVGRqV4qssFfBe2oyODhKrIkQkVeiVJBmyqSkKAiD0xXkY9VKmhf9SKgYAfYAICGfA5AMsBNAFEA7XhfG+BWABPAFQAcbwPAMYCzAEvR7gNsw3vUAGqAzQBKgE6AuQB4Z28PwPcAh3AuA8gDeAdglNj3VAAVwGyAkwCNoh+kAUD+W1C/RDyeBAgV2x8O0CTGa0W8XwXAxcYvAOsBJom4TxD7xzE+iLIGsANAB3AzwFsAOQAPiPhPAdgC8K0YRjplieEWse6DYp1NAEdEekYCTAMAdSQ8wN9EPf1e9AW3IusBfgOYiPIh1l8EgJZplVgXrwkiPl+JvPhMpAPSTgvAibYA5ek5ERekFerUGrHOuwAfi3S6AGADuBfnV1HncDytAI8CZIr0xTZWALSJbdaKOD0OcJvos84XdVIu4tEutrtC5LdVxPswPrAD2C7SLUHk22sAP4k0Rnm4HeAiwDCx/UJRrh4ScRgsqm0RGhgRF6TraZcjJshOmTjmmB6+9E0irp+K+bsATgDkAvwo4ozy/JiIO74nANgDWc5MJuTFOOAyiE5GNCHHoWljOCEfACk+AjSTh3bZLeRJzGLwRxqdldQ1c9fnF0k2067nNTgCOX6/6UvX80whCUPHKUFe0e6RRErhCbbDa6fLPuYN7W37dN1t9f0pCN+jn4MQPgz9FPXpJ6Grn2SioKEfZqerxtqh/6qNVZCtzLV+EhnXeIx9+pnc1U8qUYRAP8N2uuz5qj79VGBbw4RZWNGVRoUi36/F6eFIxWtxZgTanWtxCXAmo0fcDTAp6BF3D4N+esRRfnaZiPQuuBo9ev/7hen9TyqwIZZ8gjZ+zEA08R+D/1K72nciiD9RLBRAeKefK71bSKj36sBCoBiSorFXA/ER3oRedwe/B5P4vcAhU6dKP+G6fs+TLjkymdjGCdcV+OGMSMGtn/7daI+Ry+U5q/Nzlt2dU5hXthYf1U0oKl7ZXRqc0ImF5fkTXXhMXJ0/AUoWFApPPcu8ipeBczVKOS9bq57Dsbfcwq4tLAMfq7yosMRLl7c6bxWLT+RUyuycOTnqlPT0LDauRzp3a45Sk5mVkZwzW7mAjZX3n6WZw8bE9puVnamZzcbE987LzMlWs/IJffrJ6Dc1PQYc7tkZmjkzIW9y/HWZGSmZGm0yG5PQJ2dOco4S6sRMuj6dS1emZ7P9ZKSmJmuysvutkzpfkwk5cdfnZPfXWnZqppCJROtDs4zMHI7DcU66Ll0DyTHXpwqNTIi/LiMDUvtQPVNsPOG65H7azuxu+/pWMvpwIvPWbG1OdpoWWo/xWlbcIydrYVZOqiY7HdIxOluzICWTVaZkZntdk+ef3hUV5/XZU6MiQZ5jJuWULy3LKSguyy+9q3D12l7Sf708r8r/o/I8W52TqU1Ph3EkTJh0fXomLnoy+pCkZx6SSz5QxWTMlMdM7p2doclWp/bXoZBxrcf4gXI11+NzLdPVZ2yfphcqQRLY2AmJ1yV39xc7QF4/vXVlCX0hl68x9M41eQU5dwsJGbfOztHOA2WIjYsXeXzhU5G/lsPPpqUgfxNy4gpW5xSvLi77s/k5eYL8Rvyc9O8zNL5/fl7XYR9+TroRP+WTbszQ+P75OekG/Jw0MD8HynMxtLe1n5+TrJkPTJwQO3nSpCl9MpVoV3Mge9KEuCkx8rh+hKEgfyBpIMQszl/U2bjT4xehPEzOKSsvzCsoLlhdWlKYc+ea+IL/lr7/jnzE/V+Xjyl/unzE9+2xl3z8m+p+XT/CRDJpAB8h/o+YB2IJEf0Zv4zJsWtQHhIF+19YUrBmNW5F+tPtf09cE66T/JTZGdkL2bj+ZobflSB54o0kKPaGEhT370lQ3A0lKPbGEvRvzBj/uQRlqHMWLMyZn5Lucht7ZKF4CP6iPPFfn2Is94iiIZ9E2xwoP+gPCxUqernC/clPPBZ3le3fbYH2LWJV7sDToadjhA6KCivycvJLK35PHq8NoKvGdUOYlDA50asnhk2Luvqr+8tNd8TEYn+l+eWlf6y/rhq/398/xRh9/9WP34vF/mJ72eNVeXetLl7xJ9vjLumOv7F0x97QH5JPuaF0D6waKHcxifL+VLk/nHpPEgk3UvHJN1TxKQPkDoCPSx3j/t8YdFTTVG26sEwBfb3OgYBsXMiguvb1cyBrUZd+5yTPAYMi/9dmii6h7UfTr4ntb1NFUWx+ePltm2LicAG8vLCkcHVxfs5d5aUrcTd4SUHe6oIB5FUo8wcldn52TvbCjJRexgrSZuOTEe28Odn9TnnX6153AnKCBdtzrUqOct4CVkBNKayPukoq1bjuhCVkd8I8oKkmS5k5OyWZnTJJbEI5X0Qw1qvv/QKbQ9TvR51DY15DesXk5OcV68D/LinKE0h2w/n136FXzxXWDZUp9kbK9McmzO5cQZTlA9mbG66/bjyZ/t5sOmDt/jDqUu7Ef0UX+yj9DbReHvtH1L5/7HpJdh+R1ySnAxI4T6tZ1zx9vZb06qdLMsHV7aUifURw4PXCFVHfmZtqTF6vo/zG5iwrXl24bOXahD9fXn9nhTDlP5DXSf+GvP6e9xf/Hwls/B8X2Ph/bfL4vy6w2Zr0bJTJPj54V052pnJOVh8ku/K4WyFjykDyn9A7g7tVyNNynCaZjYsfWDkG0I2Y3lrQJcj9z3e/M130qnxtCojpPQVcvaPrMUbH2JtfQf2Jc3m85XnFK8uKy8sLV//p9r/P3PgfWRBIS0lPmQ/Fc9K16rS+FHRNtQPYkO5FhXB/WiTg9RTtJp0cSOcQ50tJzmhNnA/Sa1LOtYlZIN1/g16/51/0LozijP4X3vfuI9PKzKwMUd5jYvvJUqWnzElmE/6d2Xryf2D94v8N65fwH909+S9Yv9j/xem6Rx7KeXx/eSB/12f2eODQ//MGeewfe+DQy/T+7hMH+R985CDv5zmKOnOeJiulHy34l8zPANYn9n/Kme8U758zzz7+0cE0tEcJvdc5YGxWluf9b9qjf/lRyw1vzcf86euA33sOc+P79jH/hXXApH/DsPxJi/9/yaxMupFZie3nBh9imNj/fb/rHq5BllKN9xsyXc0NvBz5f6rNgqL11ea4P7Y0p2jx/h4zNyIx8hDq8+Qu/2L+/P91/+LPedT2X1jY/95CKfb/9sr+/y9X4X9pRgUt+RNvj1Ee4vpI0vjRzndnoD4m5swFBDPzSpb3Whr9L+pj15AzU+bHsDH9Z8SyMX+2Bsf86a7+f/QgPeZPd/QHno8nD6y9CTdQ3vj/gvJOuLH6XvfUbeAp9rpb9jHXPQvITtPmZGWkgFZdn5eunJMsZvae83t76QmTJsj/pXXDAKuSAdYB/a0yZmuyBJZlzwbTIh94gTxpgnzAJXJi3zyVqIfJ8zL73Af7/2jBQfmK6w2PyB+HD2fRHk4R1xu68pzVfY3i/xt72IumMYn93nCGX2zsgJxn++F9T/5ez2BX3mzNHBAqdlL/uWih4ddbFq/lamanIDPhFyefIB9wJyUiPmHg3ZSAevwA2cKOSjYmoW/2tb2Q2PiAapjQNz0nE+3BnJSZUC3+OpTF7AxtVr/ZLr0UyBHfvyJft/Uz0zX8ePnAs0Eye2ObrmHZG9R2tc8myG803aAjFtP/NHWDh8PJLHvD2U8j5sfe4CFwgvwGczLbzwNxcSpnB972o3FxYCDvUSBIvHzgZ8xC7ZjEP157oIkILHO2Mi1Fy3E5uDm2z362HnY79sYzWMx1ub0fVw/4MHsR209ujymsn5ZnK+d0Pey+bl+WKztnoShbMf2gfe1Bee8NApilSc9GpECB2bhJ19cUs9NhPuqv4e5JuT+shUW4wL+4gfff9N1f0HOVzvY72kWC8vb/xL/vyn4OWGNkWqYyuU9HvTxXRH8g53XgvLgb5MW78v73nspTg8X9j24n8zbffx7m15jYnPzSkrvwIJO+u93+K89j4m70ROvfeKA18Bwa03eWhL6SNRyqQ8qcvjWv5WWp+z5scGXDFDYb30lV9X0+xPXuNPb63BxtOk7b/U3r4iPA65HteqQ4wMPGLj8CZrdJN/AUrkPHlZsRK2Ab088rDV1vLUzunYNGJlO8FXfd9K/O1OYs+D/tfQl8VEXy8EyC8AwggX/WWxkjqwgG5s6EK5lcEElCTEIAr3EyMwkjM5lhZgJBRcX7wmPX9UZxvY9dXW/FW1jFY0VddV0vwAsQ5JYbvu73+r2qd828hMRjP/n5nEq9qurq7uru6u7qfqLzUKj1dlrat6eIvZdHc4PAYtHcI9D03YmLRU8CWNRehq+6qkYcgR3aL3n3xlLgSOeIuNO5IW59J8Th0PRCbIptiGmIQ/WmLkNYbvrVIt610JzK0lfujK6FI61vYHPp+AbudNNIOmClHfvthZozYYvymIo0d6ZGlm6Ry6E/9Mobi3yEs4/QDzKbrAyTKyutnyg6xWUTJhKX2G6zKyyVnw3UTCqXTzsaKkjrLJ3krS8nBdho8ciHEL7zRb210cFEb3OejAdHs/jVA2c/d+N5HB0PHMJCM78S/EuvNyk66fIptcxgqe14VF30ycSeLS6XFr5ehZf1kx79cUTBNqWJPz6lHkHoi0btoaWcZmZyQyMdW+z6g4ct3fBndxmxH1kfbndpL2wUah/v8mj2sMojZ+wsnEu731UujtB+1eLQWTIp0t6Y9Wh3lMqVHR9aRVPuzfrKqmtKeSNxKN80VNVOTPemSl5//JsmGnpBHEmLO80esFtj6amhumKKMF1Qj6Z1gha6w5Rdd4wqUFUsDFBOl+7w5HRpTnhlW2vEtEl/6aWuB3lVRP6pXiLv3aZ6KXWK6rVKYzux7p9nJ1Y27/X0yDatqxs3deRLCJ7f6CauvYc3cZFlOju1+CzzAbSm1/XqtqqcHzt0/QMNmTLfId1rzcVwwysN8pcZvRKeoIp4PN7KisZpZN5olXlfFRMr7b7xdQ20M/FNtRQo9jX511U1k9O9bvROpllTKEYPvJRNqqG3Zk+qtbgK3VbF+RvJITHg8CjO83jJ+E6mxi6LzaX70p3uZaGlSPedh38nn6/H/cmkbGIuxVR2ZZfQfDSLBzSVP//QxBtt/ImhVCLsm+Ob4589PPP+oPb5HJCgH/kspD9YPN9U/txDE/No+nZIv2C/0y/IlH7+rez8wK6PLzkvSOvJRjxgf4dveigSNpwe5TDorOI1I3lPUd9Yza6H55cOFYvo9G15RUNZBT3eX033fVQLTlDnaoviz52pNlf53qPIZe3KSFrY9eOk6WLFuzZUFu7PUOlKN1RqRj90fiC0dfdAKPZgom1nXulT9Rw8ncuq2ZuwZmL+4xrxBpNXrmq/0OYWzgdGwoFYPGUkfkDVXsRuyImaT3PEHwyRuWGnzzO40p9XTWeh6Qw0naOnt8CRwUKtaQ00rX2mdeRsrk6fqktjitbOn6pL5/gW2jN4mhoE8iAA1Wt+PY+5S27tt3Wab3V6QcUGhlt/a0Tx1ttIpvFV3gY2GbFm8nNIc6Xt6ThxvGsYdfyexXab1QqRrvGIvy3TeXB8vw2+dKSxvnK8vANQNGwRp1ifGTqMAZf0P7P8caKPyxf1n+Xvxvt1FJflpNnaVS4FpLl+Bya4LpfuQrLmYoESO4UtFthV6CptrFDfHtWLOuUkfIow/9UdpenlRnI/lN+GmVIp69ddshoznyDeL3HpLRcvuYXUl9vnjzT7U4lYMvl7ff3s9dXUROorTYWZh4v3wzzxn7/O6Gvn/etgLBgKsBP2ivGTrsxVTKgqq64QRslo4Jd3K437jjoTJZoGPwUur6j2TpO7LlLX5LRadSYwVq2NVR2l+FeiYmiCJ5R4KhaXbg0Av4i9bI6lUrGo/q0CmnMut7I/PVG832CKd+5Zy2XHt2eH21oz+ktG26v8nN1sWSJ4fjeC+W9Z0xZcOa3JYXVYfeGYL+CPtkTmGPHf9qv/oBXh6lrX4vj93jRD96Z104GltCeTnOmtDbcWmITIu03JHm2sfWTV7l396jRijzZffLq/jbS8HvI3HF0bv1zdZX8uXfvT2T3RPZVm165kh94Cv0t/gV/9ivrt/A13mhbj6qTFeDRHcqvm/oBVe3tyGr/fU6i8jY0Zi1GjMzuYv21ee+plZ/Yj9mb3JWfMme2PzAglfB2unu3/qP259O3Prh8k6bT+3v9l7P/0+zMj3ZZgFi7mn2VZ7/jq1W3EPhz8WzZWd/f9ovbfx8lfs51It3kgsxGtwViPY3Y/xLqSRc7pRxFvy+H0tXQUFnVj/0I9/epJVY3Ee6XOvs2l34s4rF0dF2Utp3JqYZG4HugW9wtG9PnuRAfJn8s3KxwXPUmj6xVNlIXvn4tYeWVd0ufH55xEntsXD7eGYm2/rv7YrohpoKs/PTD263t4OoO/S2/wd7p0B3+NLXzNwV+71xAbk6OTLoFDyyVwWjOHDGj3aipPwWZTxnugQBXrfroRMJ8acxKz19Drf/xkNrHXQh9JNBFLCTf6+qKxYI/6E8R0LMdaxlrsRZYZbTEiJI0184SOdIR8iJy9kCd02bUIcSFajm0n+UjS7xJHQ6lQItkJ20fhkZ0yTb7inT00H+qCDTqNOsg6Z7mkRpLONxkR9YfbRkTDHZ23zxJ233SvMSOP3fwXB11fpteNwn1UPTzft6fxY+wj0nS+NvkGChni5YLdqpdNFdVVqmAM6RWN1lCGYcFLISLYZaSKtW1QFprlcnXLKJDZs/J0q2eldCzTuVZGwsYcVs32pTPWOTvbevVORjo7Ozu1OXTD2wr1o68LtfsJGVoeaWITQk00Yjs0DzSLb+yqN1J711qa1QofIdVks6Y7lyTr3RQepcOqcZedThyF2Xu4+JGNPnvuykMXznYqXkPv7AqRz+ZnpvOPu2bYFD48hN2JFY21t6W6GB+S7qwMLAzzKeit+2rvrZlLRf//8aW1x99D9HX6Jjh9bo81GtW8n1eenU4si9tcdvkbYaqoRPItliBbEskZc3ypUCREhu7EHOGr95aCoEX6wro7pzUejvkioaD4Mm5xq+K5K9h9hVn+Ucf/9LSTHp+d6Z9ld1kz3T/czVdrOtPs7dsdaaNP7K4uHdK3O9Kf0i/synXmBs8RKO6637+7b7t7JzxDWF+ajXKiYWOd11daX+GdqD52J7yUCsTFttDl9ljJ5qPmBV9kr1rgtNqsvuBZYV8LmZp2rz323McXHL/Axxccv8DV6JLd2YURhq+2Cc9D/X37X1J/NqH+nK7f669b68/RM/V3EoufND99z+3HveSkxz3ZgBbwt/2M9ef+2evP/duoP63rREnV8EjiztRNbhRO+bT7ZxG0L5QMyOIXJor9q/3BE+5d5qT7dfTzNuwer24d711dHe9tXfl2iXu/7h4u6tJgrx7AzLXsfqas8bt+upu0H6fVlwj5xQXVn/V7UP8TRfzzRcTYNOddNu1wFVk4vrpJTtcN3dOZmnQllpe3t5PFePc997+W8DitLohPEZ14Y98T6azxebp+9Xh643PpuPOe/bleN8OdWy7Xr+jjRL/mqNtOevi/tnBdk7lBvF/8jtHNf2hyWt3C/CLqT5EmE/KRTqCH2kv6ztq6H/6qrWsB7Pvlr9q61DCsxr/ppvXFK3BYraLDam4Q15NKeu/5LOiSKmh459ePtM42mRvF77eUH9h7wadu6XNKnVsPE1gyf92IpCeuN5VzvdeEC6X0hnc+veFG0pssrveVb993xx6P9PmmzuVPYDGU3pVietv2/TC/SEpveOfTM5S/ELOP3CPuXjLnQyLQ356K8ethFEsasWBegViUACF+wZe26YZGL11qp/YkNGmFZoqDZdQaM8jiQ4U1ZSmDiA0I48/taCumONFjQFihnixkfUZ0sunqJPsKmQFRurlD7c+IRvTrYNoa6Xw3zIDQIj3dkC0b1M2mqxt8Q82AKI+eJNSaDYjRtXXUqRoQQ6c8mmLQXMhI+dAv62qXj/qbuwbluXXlwTdeDYoq1BWl/jyoQZEeXZGKL0waqgSdusQejCExdj0xio0OQ8KcesJgU8WYoCI9QeLuhSExNj1DRYvOxgTpFTZa/TQmSK+4ZctwhkQ59HRCKz6GBLn0Skk+1TQky60nS+2GG2w1uo1G/llNI9J0G43yFL1BYXZdYfhIvAFh9NSJpizVcRRDwhx6wuRnSYzJsunJks4BGJNj15Mjj+82JsyhJwyCgY0JcuoJEqJAjQlx6QlhoZbGpLj1pIgBlsbEFOqJUce9GRFo07NMdaCSER/ZZtXOpvxcpLGuwarXNVhp19Ay2xfyJ+fQmYDB/sGul1eNQ7/GxLn0xAlndo1kU7drSPOlUYNyXbpyVV8YMyjRrStR8xtBBqUW6kpVfanEoESPrkT8rQWDwop0hakuKjcm0ebQk4iv4jOonU1XO9VnVw1K1NVO/SE/gxLtuhLh05oGi05XlPxWW9jYMbeI6wl9T3njvgvp+kFH2B9J+ANkDPH5O4in6I/Hk+JyQ2hGi12ItpH42flu050rW0a9qMUvLm9onhdub51lcKVRHkfq0r4xxq69x+Gxys7w6u5ZkPy0iucFtty7tM8YIcAUSkCzCmrKfBUNjb7x9ZPo5VWC3qHA9Jglv6K+flK95VRaDadbKpKpMPH/YglLNcl4WyxlSbbH47FEKhS0xNosLeEOAvDRtJbJSfLD3xCVrwjWk6UlrUT6Z/FVimqHap1K0TonI0oEkPFYUkT6IjaGJz067ZJSoQDVTgim4tVRHM6l9X0Wu38ha8Do1quukwfgatRvy2yD1Vs2qYa/KKuygZ26dmm/rKufVCqLN0TvxnvpOrryji3hMwMT6hUbLPy7yskNFb7SikavTCT/qsY7nm7H0YhQq9a7ad4pyneKfTqbNf02XZoj5wV6t3bblEGS1Y319MpO/u52V7qL3V1a595lYZX0KrPJpVN95dNq6Q57teK21S7t45nPZeuvA99+dsnZnxF7CbeRnrHFL1ytzZt1eRk9FcGnQerX2zjBMrIlOTIaDhBfKMj3Y1FijAlx/1hYIT1mLGlCbSFLgR9hkjPCcdG0EDGv+VjEQGu9apLCFuUZHXIOD89lHe+ploIWglPrOnekSCkFwasFVlZVVxjlzglFkiHDSXY5NTEhBRsqbg3VWsJScQzBsRikIKMzmiOBVCKC1WEk5RVNQtSmSGOFpJUk8dlRX6w9FW9PWXWTgsiPdIkJVCNpfIieoJQ/nkkKI2Ei+IKxRGL+IClfIJ0rWgtfhnPxCFBVWznJIo4ANZR9lJyYdv0yWflC4eABROSvJJ4FGSNo+nR8iGqIy+8yo2XcOMuQ6knj+T9zUnRxzx/xJ6KErHFybYWPSOQbQ3ub3GSQvWo3RC2F+JKwtLeRkSPcFgrmGyIyqqFedbdE2y0FMRU6HJN3GaJHIPYwqpd8l6d4S+zWkvCnSPcSIOowEXMtBQn2F+WBvmSIzJnREEXmqCRjpMoU4uLsL5FXIZL6QBrSouE2PUGEQymDOExaMvwdujK8U8VyV+puo1TxUfiOSJuKyK4msquIHGoih4rIqSZyqohcaiKXisitJnKriArVRIUqIo+ayMOKu9JbVU038bXKu4XOIvwtIRryruxrRD5k7cSzt0yfHYjGScusLa+b6muya41qNBUVR1m995RpldVVFYY5yMR4UmWZr8lmmKNuqrOyZrKvydlpDlcGDtkgj70C/jgBbeOK0pVJEkY9Xhzq/vkIKPWQZDM2LFP2uSP87R3aw7OUqnEhcp9AY4w2mmQmVln3qeBV94e0Q43GgiHfkHPEwibmSWvNWz++QSJTz5gmVDVWizMlaVgls6xQm97AKmpheHCVGJhc0hhTsc6OtAKrxpApSc/fT3b5mIZKvyAkDVSiNVKjxmMXqZDp4QiqDy33hDF3S0liV0WU22V3xVgRZmRWFaDkWuLZiNTAxa5T1osoczDKUhZrjwSFOTqdDY8CUye9gTFHpHMqwPgr0uu6H9KsK6MLwkQhN0TknSsbVsS6VCtixKGAVOIIQx0Lo4kY8Dh0EiGeh24i8nSET0SNVQ8F6K08KbWiKo+NtkjEb8iRE2gVGZH8Od3cpPGsmACbNm8ab4sx2o0xOlSMDmOMThWj0xijS8XoMsboVjG6tRnlfpjMhcjki6GOVemPSbMk5iujv2jjQ38KxoAQpNngv7xTMbFgmAqMUiKyJgVaLpu1H4bBRaBAsT9h4JQjWDmI68HnivFvVUff1riYrvfE0PJhvMNJpluJEAtr4XWZ6qyaRA9eV/GRD7zDwFNFwtFwirYRIJgr3SUorUeeJ57nWf3cm+sXCgF1nVmvtRpYr62q9TZZgqE40Zv0r8Eur88aXj0mhP5UKpxqJwNOSFTDN5Mt1/IkkVjAH6HLueFUONYGVIxGNSjrLkL7ZxHr9jdHQl3OlqGcsekIXqIO59C6Uq1SEyRapU6zRB1tj6TEKEDJHs5n90eaj5vUOutxeYDl/2/3le7/8QuT+Wq2v9PvraeeW3w2Kc9kqC0ZS0D70p0VinMW3YkmT0Adq7Cdjmd055ru0zCEXUKkn0pSekEnXyJEsyOE6kSTLreNDIkNolWxv5Ps7+Yk8+1y/MEAWKQspdqpdROqqxorfE1s0y8ajzhsNpefjJhVIk9HLOkptFoDM8VT6H465a+ntdDhT9K9c3tAfFVvUWfHO5lY1lQ7K7Tp0YDL4yEDa5mloNFSMFXUPt7uJmVBJdjpC7vVbfWkeWeHd0V2F3unnUmxONF6gXBNEcE2OYjCOipFwklHNBgBhIKuiibqVOooV11SJDUnHqLKNImxO3Q2I/I0YEmaStqtkrVJOTbAZYPxWq2JveYX04R0R/gt8Uis6g6Jv1CqotbXOKGivsZbTSoq4mgN2q20QlB6kWTUYXUEGdYNBa9IhPR7dikVZFI2p3b18pnyyGxKQ6INSRQNUZIozrzE1PRsQqwJkZgXJIlguZbnVnqrYe2+Bm9NRaF1al21t6q2olzqr/SbntEm5EwrSNVgmqNxu8cKXUlzNGqTJ0RS0Sp2O7Yl0dwk8Vrvm6Nhq4s4z+OVJZOu85CJT9cDqdPxaqSjLEUZl81t1a80xZKmTvlq9T82u7IDSmK7lbSSYaUmQ/glw2JtS26+6UY3bPGiFpF40u6arsOvGD7FAavRYtXUVt0wxYIIJ1MeB9GcFkQznShCb+APJWItxOmShrxIxGmNsDGRDrv6tl1XP0nVOezvWIRs1qpdi1MzNDmXSicPXz6qpNHrs9lrT5HU8ESrxVUObQZjdfRTlrkW1q6JdaUxh7JJ9RXM6JEB2vU6O6EPPgc7uHP5ja/Z/L6X+gUNe0ILTHIXXvl5NBiZk8G4o8PnDyeS8ZB4+w5qzlqv+fwbGSeSLpfdpcksdP9a78U+JunUeIeGDq33WLFQKqnPrX7J17Rs4FbMgdgIXV3ttFY3oLkd3VEIt8XbU7IJHW6JhMKgVLsGN7RjgbU1ESLz1oTE2lBpnSpWZ7LF2iErRT0W21TEY+swwlRTarMDV7TZZjfERj8AO76iXuQjr/xC/KAR3koyWFRJrC1RMu0FtvZkJBSKk7Zv5W+p4icysnA2k3k+uy/TNOmpJ2deT+Y77a2zYEEBTV9byYRUPXmlWGOzVxr5RtK75krxw3aNJx2Uw9KTJqz7ES9HJ6zl1dVk0tposRqayNI39A7D6kYWamRNE2yk/PqoItyIf90SzvB9Qtd+f/LLfB2bn2Yd98wi/7PiB5nFCvt9/edXvf4j1JXWCpDBZaH9DnPkA3/xesef2PcezKXF035apPzAd8bv3/DyDB6dV0boKVsbvTyhsUZx7WWnPt6q+Oaw7APuthHWNJ+LVb1M8wlW3KM4DH5GR1rFUpaoiWFGeubfPvelRKBBVd7DyUhOj+RZCsg4mYgFWpKWkfSXyE6QOs+hLpQ/EhF6FrpPKp2I5lHiDp2lpnrMmLI6J/6PJxA39mRRiM2xWCoSax2R6uBnZZICs1r8KRbcFg0kg1bMJLXl6f5EkLcfHxFhCUwPBWaw8Qm2DkOJRCyhQRyLRsOsycvf8ItdWEIyFYtLc2oZHk+20YuaUu/4Oj43M0guaDFCPmDtw3hONbaSA0RlS0ssQbqcFB/mpdMtCST8Rgslw0rWlo5XVAvVoa09EpHt9mq/ZhZXWV+miiklTZtVphDRQWlOl8Ln6Z9gQYH2JDvoxbZGyEsWI8GCyCQbE2W0xxLNFrC6Om+9t0ZtVnxj4QNbo6mgcoVIyZMK+hg93Q9kzSxCejPLECCFrphuncvn8AKeGQ7bSBE670Rrc0TD5yVvmiPhthlR/EbEzEmmQlGCT4mDgCCE7pDD8oX2gYWySbWVVePF0Q6p5WtjpVhfNswiXCNcNX5Co6/RN4wvErFPJR0qVL2IbIupU8RXbVjTfenCgcxF1qNL+/ZCcKP8T9jDV15PJiFF70eG4Ls/YYOS379THXAQ3kkbeXirgMWSVdXm4J0CMcJsqn7ggcynkmOF/WsVpUId2d6i8ipXIMGqifv76C1TUR0GwZfqREXx0Vk+j6FTIqG2p8oRYryRJT9f/CpGdVXtRF+lhY3aMqx02zHdtKwqq4D7ZO3yb2qo4jUAw8LHib2xnofMVnylkystNmfahUG5T0XfNHobJgpzyAyLLp1mdWXgM1YmDmUO3fjGsoZy2uvylWHPtByW4fCSVUtddLJa/K447gA0VgoVa2jGEtWQq6uHtdCaeZtoPwvdqetRM8NDYZcMw9TWZELpS2zQZgpS+QbOllnx8o7qDhtwsCA+nBiFWmhNrdA7+ujt6zatwUlFSXswq1YIqHQtgzjGs0FFOc4Tl7Al3KoY6xmtLEK9jB/kaYwZez03X/AEhL/Q6M8Q6dx8Y92A3k1eavNjCltBC5Yun3cioq6+oqGitpENgqfqnHGRhZCGOlIJf3IkH21RMMs+ojnchgOjiFCIGdWghUgN3qMNJGiEE2OaKxMj6iaN2ti/q6522MvqPDWlIA85G4Dzt4RSc3zEvwerEakFv5dZMY8j/mQg1B4P0nA4m9PttqtUY0tB/B6zgZwIJsKHopCercwyaaLF30IXnvhEyLRZPyiQ5NBTVl6hWxhYNFOZ+cFGDzx0kxgcucRyz2wJqc1H0MkbjpAmXUtoIW1y/89pqMMedc9rYc5wTHWsiMe3RNvTpUZqnYbxoSwekzYZecRm5hNFkgOTCISlz6CWexu99EPCk+oaqduSKbgekxeEM20VqBKgDZ5NIIhd+KP+NrHPZ3+yxZAhiEuaIAj2gN9kDOlWFhm9f0C22mopmJ5DZ7b+tqC4qmspKKBk6qCRNDu2rfGkxncB2E6B9JIvc9WYxfRRqiFUUFvQF5oVahPX5+lMyheNtSmnNeLi82RvUxkpm4pab2l1hcWuXQjovmLjmwVKD9ipcoGdmsvhjfVVzDGz6nhCPEVdVW2DxeU2npbUwCRCySmWCMUGEvBHQwk/vQmmFdbu0dhHJ6yl3jLm8NtE+pZQKNjsD8xQbmspIt/VnUTGU4KqMpDXm8oFlb92ZOpEYgZVUA5xatsUezLcvbJT2Zl6dLGDzXQOTusQh1SniiMcSBfyojs10To0WjOxtLqssb6aKsD6RrrOImJF1g59noLoDJohS0c+Osui5B+emX+4yC+pOQQTosLRyzfzhTETwvpEJ1ldMPJzHewEki8ZjkqHEMTL3tKmL2VfPoArHUJl25KdiPxZ7RWdJVXopGe054hWOzeD2arIu6ah7ICUtNJACpUtNsjMSnqfX5DgL6cgvnd+5oNxGmxofLPl50T9s+ginDj4JYQdTbofXWSnF2TK6K2Gju+lT9ORb+jUoCREHAPEosrvgMLK55sv7r+F3XlZnoacI9HjU8ciTtsHQV+yYp257leEQL5yHj5XdzoM4u3ijHROEnRW1gorvuZEONga4iuH/7yWpSBqIXNTWmtOFN+aLjmhUjUmlhrLHYlYKhbgb92J8HfQqMpTnV9hd15TeRGLLIto39Yco+v6JAcu3uw6cvgJdyIVT/oCkbDkOEli6BssI0Jm/zRMh5qtVu2nryBdbTxCK+ggrQyCC3tAcOYaEz6kpl2wGRQAI1EVM0s+Q9pOt9XT1cQF3v1J3dYtWRfah81Y87B3R5JRf2s40OncOmxF9q4mzbOK2TSYnMPj7GpyPGsnk9v/gu1Ucjb6jbiulibP27kEnaj2wqSbDrdHk81BzSmldvfImFBtRi0SjmpipMHg3r2rvRXzAAy1T+FURdcKWWBW9A82ee8oH6qVcjLNnmGYE2ZPyk1RvBeRg0noVVMqZ1hrwUn/JImBTw5mCE3uigjFAQzib7dEYrMZ63GZlDZMDltJGTgUWcpErnXqR+WfepjdQEF4y2p4OxKW56kPoWe7Qo1LmwDBSKzVDpJtVKyfbwuWgpQsHoDaibgxqJYMe1c2lXWxrZGQztYI3vbSYW3JN+J1y3noIMSXG89LstkKi2PNxJbB9OfSgAwJQdnnsmYHNHIEPy2SJi6yDW4hQFh9a5bWYWnhBb0XUzYLkgSp6MV3Nvm2hoTnOxwhIFlrYineFZaj+eFnGuWnn6lowECmhPmh6jqijJlTiBQuYubXgOS44ZqlYVdcsiGRz9YQEQx0TsZ0w+RwSbM8WbgJWrsuXRqyhI8WyOUIn1bQluHQkxGIdRjnEC7/l6cqfKJAW4ZTTwZNVS2FYH2zjUuin8vQpHYolw00bUqjebC17AwNR3OBO13bYWek9duO4mBA+tbT1Dipmt09sh9NSHEbq3apF2mUunhFqrbZ2/SaSYcv3p6cHkrop2a3G6o2oRAmt81oi81uk7jztSqN6N8j9SnFPOvXaHvrrE718TQMnd2u3Nmu3trtfb0Yg6+fPRo4npqeiLW3St0fOCGxeAENCMVbPbE4v7CrDDQmaHHfK+0h2TZ/PJjwt8ba6FXbUsCbfJkuB6+cZroPy4BAew6+hMaJljvZ9SBwTUWAj4+nl2DwX/dTXh2ieEdeoMtj/GxlSnHXH7j1fJnL74DgF7Lb/LPCrSgEXbui1C2nNoaiJ6vK2SayIlKc33OqmNpY721QRXgIsQmKCA9GK0vJGwzG2pKWZCARjqf4QA+BSgz0EP5CgR4MkfEQe7rdWLSkLcWoknKQwlRFFVWxwNJiMx+1XFFT5yvzVleVpnFp6UTPW+0bP61eFiOk4iXTIjmK+JOtypB/SVKaWaWXHi8pq6judGp+rdQEUemTK/V2IW/NWqnxkqx4hVrBmE+3HfI78qGTk7aFU6FoPESaS3si5Av4I+FmAof527GUiYMxKd50LjhqlhCGjebCingNaZdC7PVowLqPio6EUiEcZX+gyfzqMgpYjlnymnAVHD7/8OoG8jxGwfd3n3vmCNX3y1/Lpaz8+2Vjl41QEpiXsO+RZc/5143/mcJfoT+lUrpBVimuZhRxcSaNsvD/hHUE8Yf+I1M7jMxpGEVQVsOUbiOUPa0CQxakV8EmqSCJzCTaZpGwhoUb1NpusOA6LdghvhN3rOSF8yvU2Nkzgu3GbKgrgg0VhdRel7LvhWbHJy9941n+UxJTKnUb7O/ttasqkFopKBQaa2Hmdu0RKD2/nAoWlrbnt9L+O9vPGm//TGO2M9RdGoPgAhdiUDRT89tsPM0a9eAdSwd4KxrrK8dD6zQwcui0B0PEXRSvOzIZEY8YdMQ7LAorUqW2X+LtBonl4i0ug+KdXRMvvMsk3mFxGSQW+/932fd/zbZjF/9rZHPEHwzZHFa9/n8CSSKncRS0CYeQhBt3FkICdaNYqVB9hB+78OMQfpwuQWdRlla7kbpAj1UitjkplcPqchogttsNEfeYy6Hyn//F2rO5+czLh93IL3qhwu7i4Ja5s5a69SKBpKi7x1fjKhQIaRfoq3DKqJ4bXJT1sWyYeF/g81e+OEGxCKlqBvWkcApkzUv4P6+zoLYdNdpCwdKlXw21bRarVm+pSWnT6oTT1l9PqJCZEpfvB+w+xqw7Hxjcd2pZWV0NLtSuGJvDMKXNoD/p6Pzky2Fs8iU1OzbGS7/pWpLF43bLfn8LShcwZQvSKv2rmtcZ6SzM/2bzI7Nv4piIKRDxhxMh8bZ8k6nzKdsMzyjtnRXMO/YuK/yk7UgYiT6lvCPJ2O+IKkiJF6TtcmxGKGn5P8R6ksNPnfaUh5W/1IOQ/tjZodkfi/3Px+L9Oi9ctmlbnO7QKfqfTltOD667WHtqAmzv9hlal2afRjsf4yO5+T+Hi/5U68VHl/Kfh+wGf4q5ta7MfaQrE2VXVWASHZmNUaBM00n/nP7Uf0V/6v3sQfc1S5/r1JlQ6LffrnaAGVdOpN7HyAJHz6pgaJmn0+NLD62x2OjynFxwUUZzIPZwNoMO27T7+TXBWDAU8PuaY6lULErDK2AoFe3B7deyB5D3lijvypnrKpm8VCzOC1MZGZUXTSvv8+cZ8OzH06Zki7EECrXw+mdXxvue6FE7O953ztx7ZrxniUsGv/9W6TC2aAz2+IUIH3701dNjUn3rrHdQ+wmk9S++FL8/EDx8xbpn6ZY8DUUQRfWkE9AVx6VnBPfkdlEnl1jMy8X1rOYls18xtcyWPhHOf1lXWc1dHJwNdfGCf+CWLZB1n39gXIUCIe0C96/CP1ghrX/dm3Pw0sqphUX7ux7A92pC1+NxZV7/EkiKXN2+/mVUhQIh7QJ9FX7O+lgp9YfhW69bLkRsyuZX7uFp+7+Vp4j8x97SskKM4Ox6f7ryVkmfmuvqhKhSuT7p53vfMv6sN5+LJA6vmsS6Y/34g9/75x7un39Fu+5Wuj3SM4LdPSW4sHP+zffi/Cs4wvbhcXzYEHJmuxJPYPvfjIDoiuAu+COrxfWJFz95++PL+frwRUKtSe0Zxq+qGG2/sfrh20rPhBcUGh1azavZerHpqGdG954YC8RjAZ8Qb641COmtf9gckjxp/bP59vl24WyDbDz0pB+fV+8U+Y+8LeAQTzWkGZ896cfnNeL96EdkrTvqMDgloS2Rlzc7jUDzmiul/E26ul44zyHPX/rxfq3YvoL2d18ZzA/2qGV1ZULZQ0OEo6eGCIexIaIrgp2d7+/WiespzedPiTXHp/vbUrFod8d/Zp7SwPxL8LLd3e3vG1ehQEi7wP2r8Pd/FPuTd8688tarhDNq8v2U4Xrrsb+xliTkd4Nojx8MHtz/UiG/2nv7Yn88vDvXow1S2jq98dOJBTpjlIZ29jMEhP28gu2djEXgzWCjiDniz5NnB9gBS93+idpDMN2AaN64U2pPNTeNFg5gytvT9P+p9rRJym/zt875fH6TdpfVP1O3PSX/p/K/eY1U3+P+MlE4tCuv79n/U/nd8l8pv2NvOFXpyabdv/tN5nfrMNEf3fue6xR2UjTgb9P1bzPEH/zEys+cPPqDPkuYvLTjT4defFkXhyBhX9iVcQDKRNfV4UexQ647Rii2sTs3QnQ9Xk4xPmwT9xdf6HN54uNkyh+Nh4IhvQFC6bkZDsWyG6Ptumdo1N63i/uzyXdGDHgWTv7r2rtjTje19y5F0Jp3DJP0PXEABzcY/Dz6GjhkoNB35+GiPeVtX1OPTlVrKvzbt6fdbH6RFQ2ev+XppnA8lOiGeJyMwWqdOrbSsypk3pnryfne/zcriJmLmbfHveL+/Is7sjcN4y9K4A+ldtf6q8EwjK7MbwwFV3RF4x6qFltPncKyGV/qyDKz/f+s0NbsH99n9d3UpF/fPTird/dgpK9hFXrkPKPN8GFCW0+dZ+ykCj1xntHW+SW4rGxxf/qEoqdnLeHtMxBrmxVKELcgoPIz9f2XLs4HpGC0ArtV99Sh5FH0SIikoXi4nlWhJyPnekIFY2Mdb1YHiOdtBn784T997OOVNCi6O/u/36Nsf8Yo2+4RbHB1xaT3PU5z8+7r67fQIDrNQLrf93N+mf2cX/oflyWB/a/J5Y4hz/r5uZySrP+1udynmwdI+A/J31vJc+B1uZzt0VyuNhYMNaT8qfakJd7ezC7lN+1bK9K/2JbDrSAPlTPzekLfHrWE6WVhSdM+kWbFA7mc+cFcbvV9udyu+0EHnC5NS4T/76FcroA8ReR5nfAdQn5fflCb7x+I7w+E7hjyfPagwPcieZYivjeeIX+TZx55biHPo8/Qd8fklloC1otL7q3755nfx7l5J1x/0l0z/nH1q397/18r1m+0DcrNStrr85+qv6F0W+Lj5qI/H3rROU+ccveLH97++r7NX37dPKTMaellzvsu+EbqnvJLGs+6d+JTQy858C8/fvve1keWzP+owZ04buDB1t6fzPqp5S9NT1ae+szZ9x92k+eyr7bt/X7BJy+8sXjCt1MvnX5/RwnnPzRr6LGed5au+/Sa1Y/umHBF+JacB4c/t/WUf5/0zNk3njXz8Locx6hBw/Z89vnbL++644c5t029avSiwx++L3LZud9ULzkt/8TsMWf28x7593XX7ln77rtfDPtb3xenz69acNN5T7d9dMaW2v8bZx9x8tHxg+7c99L6L77a/d4RL496dNqdHddefv2D8976xw939Xu/4NXajbEVF+TeZXrN+rWlV90fSyrjrWc+d9HNf95193+fGPv6kR+e//UZm/+Rdd2gzfkf2F2lefWzm5sSa556+94H/nLFJW1bJ3174kf9l6x0vj5kYd68Xi2p8cEhjQeUf3b/zmduuezZm3zfn7ftqDfGfPLhcZvc1/d+7OApLbNm/aHS2VT9aXTpQTtGrn7zltVXXPncww+WTw1N6N1x/PRXDl3BXei5e+jct0/7rPiHo3ftuOo/ty16+NZF7Sc1nlJ41sFnb8xZdvgTw/40asSeAesiX9S8+9CLV/1t1YKl8487t08keFpF9V/HXHTi8iNf7Td4/bh9p7937le3Pfr8y59eu/3OQ9rc502uTZ3x5xGPj3v/oA1HX0ANA/7H/7v+uVzuz+QpWpTLHfFiLreCwEny/GER2NJd5O/nyDOXPGNfy+Fmk98Bi3O5ESNGkv+SicDIaCzYHgklRwpXIY+MhJuVkC+YCBP/MjkymYo67COFv3je9oCPx/Hr24F4HNrStjdyuR3k+dvSXG4jeU5+J5fbfsnBHH9rGUuguT3J34ZFmulr0uVSH+RyfyTPFQ6O21rIcQuKD+SueD6Hm1ncl9tR25cLN/TljpnWl7PN6csVXdCX81/Rl6u6IZd78F7SP5DnsH8SmKTlX5bL7flMKAczHYQ+J22b/L77TvXYQz6H8vkjw9N/9s+B3gv04yZK8DtjpyE4jOCkJOeCl89H8NUIvg3BDzH4hNOuHfsM0u0NBt96y2HjPkR6foV4f0T4HRL9vJI+XwDNwC9E/LSSoyT4lnEFX0B+xzL42te2jqn+AvLSJNEfVtzM4CdOqh49U+Ld4D0P4NKrv4Byu/kL0O0elNbjoFvxawi/DOGXI/yPCL8Xyc/5EuQf/CXQD/kS6J0IX4rw9Qh/JsLHvwT55yL5lyP6GxH9fQj/JMIvRvgPEH4lkrkBwfskmleKc78Ce7N8BTQjvwLdxiB81VeQ1tSvIK0wwncg/BUIfzPCP4jkP43kv47oP0D0XyP8JoTPXg74QcsBf+xykG9dDvLHIvpqRH86wkcQfi7CX43wC5DMR1BazyL8YgbvI//eR3K+QnLWI/wehO+/AvBHrAD88BWQVuEKSKtsBaRVh3jPQLxtCH8uwl+N8Lci/EMoradRWq+htN5DvF8g3nUIvwvh+64E/GErAX/CSkjLtRLS8q6EtGoR72mIN4LwZyP8lQh/M8I/gOQ/zeBiWl8I/yGCv0bwegYfNq2XaR+Dz/3UbBrwNdAcieDhCB6F4CoET0NwC4LbGZyzKtt04deC/vVVR42+nsFP5wZHLfwa8vWYBJuKX0HwMgQvZ7DD4SjeALzjTN9A/9/vG5QXBJ/4DdTRaISfyGDq4k9D+JZvRPkLS2Z+AzqcJ8EW75WI/tZvoK7vR/CTCH4Vwf9C8GcIXoXS3YrSyvoW0hqE4KMRXPAt2MxohJ/4LeT9tG8hvxEGH03tgMGkukxXI97bQGbxgwj/nIQv8S5F+E+/hT55tUTzpncH0Jcc+J00bo47+DuQfyyD77utfLTzO7GunxhX9h3ofzLwjm0GXlNcghd6z5PgN0vnI5oFQFPyCOBLXgB671IEf4zov/0O/IGtTJ8+5On1vVRHJXnfSzoXH/s9+Cd2BHsl+pFlk74H+ad9D3qeheAOBF/6PZTzX76HcriX4f9Ax1aJ/vPS1xHvBwhegeANSAfTKqiLgasAfwzC2xkcG3TRqLJVoi/UPqaewS0tx5WcuQrKKr4KdD4P5JjmI/h2BD+M6Bch/FsI/hTBq1aBvW1h8IuFlzqzV4PO/8fgQ5553zNkNfJdEexdDfmqXw22euZqqLvYatBt7mrof+YzfB61sdVQLw+thva7aDWU51Ik/2Ok5zeroR/bhHQzrQH4IAQfuQbaxQlrwA7diKYcwfUI9iE4sgZ0mwN476VI5g1roE7vYen2pj7uGujDXwXe4vfXQFl9ieT/iOj3IXjAD0BzNIJP/AHKc/QPoPNJCJ6G4OkInv0D1N3FP0CZ/+kHqLs7EfwI8BYvQjq8jXT4DMHf/4BsD8GmtSLvk6UHIfhICXaW3rgZ+qtha8FOPBIc945fC2XYiOAgok+thfxevBbK83oJLim+cy2k9chasZ3eV/wi4EveBDnej5AO30BaJZsR3rwOdDhoHcyhjlgHep6wDvLrBpriUoSfhPCnIrh1HdRFnME5n9w9pmMdjB0XAX7sVevQvAPJvxvg1x6T4HjpSwh+B8n8twRXF3+FZG5A+uyQ0j12jPlHqPd+AI/N+xF4B0vwhNKhEnx1qf1HSHcUoq/6EeaSUwAeF/gRyieB4LmI93IE3/wj1O99P4L9PwV6Fr+OdF4G+oxdjuSs/xHqfTeSmbMextBD14M+xyO8ez3UXRngvQ0AF/vXI19LgpeXnL8eyvby9aDbdSit25Ccu9eD7T0MeNNT66Hvegnh/4nkvw/w2E8RzdfroY9dh+RvXw8+m3kD0A9E8DEbkC+N4DEbQP+aDdBOT9sA5TB9A7SvWYj+IiT/2g1QJrchmocQ77NAX7IY0XwE6ZZ8swHyuBXJ7LUR5WsjlOFRCH8Cgu0IHoPgCgSfvBF0OGUj2H9wI/STsY1onN0IvtY1G2Et5U4EP7oR6vEllNZ7CF6O4I0S/SPFe1C++m+C+cWRm6B8hm4C+W4EV2wCmY0IDgDN2OQmKM+LNkG9XAc0xXdugjJ5FOSUvAxw8XuboF18hdJaj2j2bJLa2uh+m9EcfDPkZRiMOyVFm2EuULkZyrx+M5Tt6UjODISfsxmNrYx3AHn+DPTeexD8BEp38WYoh39vhrFjJdCXbNoM9ZK9BcavgVugPI/ZAmtB9i1QDqVbUF4Q3LxFml+MiW6Bfmn2FiifeQieD+mW3ILkPLgFfMWnIV3TYkZzI72nfwvU12cI/m4LjL9bGP31tB9h+BVn3zCu/1bwSQ5D8BCAi0duBT2LtkJdVG6F9cmTGXzSTWNLp20FPVsRzUwGv/o8552zFfJ14VYo56sQ/gaEX4BkPox0eArpuQTxvod4v0DwKpBTvGkr1PverVD+fX4CmQN/groY/BP0XcMR7EE0lQhuQDRnIHgGg+nOWgrRX8jS/eRua/G1kg7O8gUIfvgn6DcWSfg+5UuRnE9/grntqp+g3Lb/BOXWZ5uIP63s0G0w7h8v4ZeV2LdB/zNuG5RVNeCLp2yDtELbIK0U0Iy9EKX1J5TWQpTWQyitp1Bar2+DuvgAwSsQvAGluxfB/bYDfDiCj0ewazvYRqmEn1B28nbQ54zt4OO1AW9xx3apLkrmbQedr90OdX2bRO8vfwDBT22Hvmgxov9wO/jAXyP8+u2wBrIL8fbZgfYtEXwMgkcieAyCJzCYBixN2QFphXaAvzET0Z+3A/kDO0CHhQj/dwQvQvAbEvxk2ScI/g7BWxC9eSf024N2ovkawo9A8NidoOdJO6G/mop4wzuhrtt3gg1fshN84Bt2gg537QQb+ztK6wUk862d0B4/3Sn2ty3Fq3bCfGGbRN+vlNsFNnbwLrClIbuA17pL6jPHjtkFtle9C2zgtF3gz8zYBWPTnF2g2yW7QOcbEP6vu9C+zy5R/2Txol0w13hzF4xZH6F0v2Hw2pOfHbsRyTHthrLidgM+bzfIsSAa226oo9Ld0NZqd4POp0jwweWh3UL97j3n+A1xBn9QPe+Uc3ZDvV+2G/a8bkD4u5Ccxxj+zQFDNrzM4AsXzzvlX4j3s93QP3+7G9rFJsiXdw/C99mD1rL2gP4WwJtORHDhHpjjlCJ87R6Yu52+B+wzAjTes/eAbpfuAZ2v3wP63LUH2u/fEbwIwW8i+CMEr0TwegZ/fgAteAFeRpzjfnth/fbQvWivFsF2BBcjuBrB0xDcsheNHQi+EMHXIfgOBD+C4OeZzIuJbm/sRXlE8NcI3ojgfQjuvw/gIxB8AoIL94H+FQhuQLAfwTEEz0XwVQi+BcH374N8PY3gJQj+N4K/RvAmBJtNAyU4F8H3HzBQqtNnGEzrdLBJgK8jhEMZTP+5Ee84Cd5ZPl6Czy6vk+ALiqeJ8AWLygOIdwbiTSHeuYj3UsR7HeK9GfHehXgfQrxPIN4XEe8SxPsvxPsJ4l2OeNcg3k2Idxfi7WUG3v5m4D3EDLyDzcA71Ay8NsQ7CvGWI95qxDsZ8Z6BeFsR70zEOwfxXoh4r0K8NyDeOxDvfYj3UcT7LOJ9FfG+LeEt3g8Q738R70rEuwbxbka8OxFvVhbw5mQB76As4D0iC3jzs4B3GOK1I95RiLcM8Z6EeOsR7ymItxnxzkC8CcR7NuK9EPFeiXj/jHhvRbx/RbwPId7HEe8ixPsa4n0L8X6AeP+LeL9GvGsQ7ybEuxPxZmUDb99ssI1B2cB7eDbw5mcD7zDE6wDe4nFAM64WwadKcElxSzb0OQkEn58N+s+X4AmlC5CcBxD8HEr3nwhehmR+heB1CN6B4AN6ATwQwUch+AQEFyG4EsGTERxEcBLBFyP4Twi+C8GPIfglBL+D4P8i+HsEb0dwnwMAPhTBQxDsQHAZghsQfMYBULZhBM9C8DwEX4N470TjzqNoPHoZ0b91ANTpxxK8wfsd4F/eimRm9x4o+bq5EhwvHcxg6v8PZTBdG/H0Bl4v8HrrJPhN7xm9wbZnIPkdvaFdzENyrkbwbQymPsO9DOZjthDNSwymft17DM6msSKIdxWi34Hk9OoDuvXrA/ocguDj+kDbsYlw3dzy4j4gsxbR+xAcR/A8BF+P4IVIzqMIfgnBbyP4UwSv6gN53I7wHDdQ2vtbMGIQxJVxyFYRbEdwMYKrGXwo9TkZTNchWxhM3dskgxe2ZpnmId5rEHwTB2X+Vw7q6wmEfxXhP0D4LxG8GsncxEHd7UVwzoEAHyzBb5YecyCU+YmA9xYifCmCaxA8FcEBBLcheA6CL0bwtQi+FcH3IvgxBC86EPK4GOVlGYI/R/AqlMfNSM5elMcDcwCfh+DBCB6GYBeCSxA8EcFNCPYjOILg2Qi+EMHzcyCPN+ZAXv6K4L8j+PkcyOMSJGcZ4L2fIfx3CN6I4N0I7tMXjcsIPgrBQxHsQPA4BFchuBHBvr6QxxkITvWFfJ0nwTeWXtEX+sYbJNhSeieS+QCC/4Hg5xH8OoLfQfBHSIcvkQ6rkA6bkQ57kQ4H9kNlheAjEDwEwQUIdiO4uB/oMKEf6FDfD3Q4vR/oML0f6JBEcs5F8CUIvgbBNyF4IYIfRDo8heCXkD5vIfhjBK/sB3a4DsncDnhvdn/AH4TgwxA8BMEjETwKwRUIrkPwqQhuQfBMBJ+L4Mv6Qx6v6w95uR3BDyD4yf6Qx5eRnLcA7/0I4Zcj+AcE/4Rg80EA90PwIQjOR3ABgj0ILkNwLYKnHQR5bD4I8tKG4LMRfOlBkMfrkZzbAe+9H+EfR/CLCH4TwR8i+EsEr0bwFgTvQ3DOAID/gGALgocPgDwWDoCxchyDe1GbYfR0HbIaeEsmDwAfxofg1gHg17UNgPKZg2jmIfyVCL4B4JcXSHKqx93D9Kn1v2B6jMH0w9iLGEz/twR0K34P5fEzSLd09QCoi20oj71zgSYvF8rkaAZ7aL+N8O5ckO9F8EQENzL6ktIBpgDinZkLvsc8BF8HvN47QB/vI4AveQ7J/yeCP5TgC0pWSnBJySZEYx4IfeCggaBP/kA0HiHYi2hOHgh16kc0MURzPoKvRTQLEf5hBD+N9Fkiwa+UfMho6JrhSkS/HsH7BiLfbBCycwbTfZ9jAV/iALi4TKI5rLhOwse9/kEgP4zgWQi+CMHXgZxxFcSIer2143yz6Zf5dyJJuHqQ8J14vfemgSbL9A/49Uw5nZijFSZTOS3RLy/IMlWbSkxXH2gyk0f8l6eUydIz/wJ5XZyXPq8d/yfkdW2avDaLee0wlUwg+RyP8nqUQuY9adLr6byOOSR9Xjf8Qcjrf8z6eQ2IeT3XVOIl+SxBeXUpZB55yC+TV5ood5h+2hfQGM9DhbwuztLJ62tmIT8vmg8w5ZpL+HHwXMhrRCFz1aG/TF6rSX+x8Aj9tKeSQXjoYUJeH8tW5dVsZvXqFuu13FTiIvl0k8cZ50wO8pyoLL8jfpm80rx4jklvw2sHC3m9vZd+XgvFvE4wlXhIPovIM4bkczR5+ilkHnrML9dePx+SPq/XHSvk9fID9NvrFNGG88wlx5G2ejxqr5MVMl+g6R2hnV7umVklImw+srcmzVBEk3VUriZNCaLJPvpg7XpGNL0Ga+sTRzQHWLT1uRzR9D5GW5+FiKZPsbY+zyIaYjPa5RNE5VOlUz6IJusknfJBNNkTdcoH0fSq1ikfRHNAo075IJrek3XKB9H0adIpH0RDDyJP/SiXa7KLe5Tqf/v2mU3BQwZyYfLEyPPwBQO5FPlNjSA+kZX0tdReM/y7mdJ6TCV8O87w7wVK6zQmd34fM1exz8RVkWcSeSaTp38vM3cF+f2ot5lbQJ6/ZZm5HeTvmSYzdy95drBnJnsoHCY0/bPNXDbh/aPZzK0jfx9FeAcS+T3ddzw41CzNBYp16uCgwS+Zzn0k/5VU36YnD1rUx/Ru7hk/bLB/8+7B7x72w97G6eGkhfzXFktZ/JbmWCzlb46ELMFwcsYIi6UuEvInQ5ZwWzKUkL1vicTi8TkWf1uwf048EUomCTjHMiM0x5KKWVIJ8qbVH26zjBgxon+Onm3QOdRpZw7k3ndncRTO7kVGX7E98O1eeEdx2WaTZLQLLzVLD11vpkYx+uyB3BeLs9B+ORkvGS4LyTyd4FYsAbpH+hN5A4hd9zWZHrhxEOe6ZCD3p3kDudwduTzfVVcN5KJ9s2Vyb2c4kBs/xHb/QK6cPP3nAO0BBN9EcFGG72UW6S+ou4jgblLQU/1ueWAg9wh5XiLP3FvIOzOU1XsE9x15dovvesE70+Okjb2ezfVCsvIYDus+lODmLQHd6a+H4aT1AK1/Gu+uOX4Qt4A8pr37Kikv1dWzaxDnIM/kd/tw5eS3mMF15Hciedrf6cOdSn6bGNxCfv3kmf92H26teRD3PXk2vtWHk/chNPmFJXReS2O0aNwS3UdyXvBMUWxQ9mhm+tJDDe6C15ea+7N5tMnAb2+9fKN/BZf35764rD931KX9uTB5/nF1f24p+XtJ0sTNuao/t+7K/tzJ5LnrCvIQ2vmXC+/S9Y3p3mnhxwzJ43qRp7v6DyrP0o3ytHR+ZXoeN2FiHhcvzuOeJHD1tDzu5tPzuBuG5nGXE9z0yjzuSG8et6ohj3vhlDwut2Ygd/UJedwy8n6xM4/rN5XwuMhjzeM+J3gPoZs+grwfn8ddUJ3HbZ9B8GcQ3hPzuHcI/uZhedxCwvsIeZ6lMsiTV5XHHVqQxz1G0n1zSh4XIemdS9JedlIeZx2ZxzUG8rgOIncCoV3oy+POJH8PIXpFCglvM6GZTNIi6SxrJPJqSDokH/9uJXpH87hXmvK4E+tI+mXkHeF5tiKP+4akdeYYUlckjUfs5JfkKy+Ux108gaRF81eUx405jeCHEzzR+2LyroTk880SUkZE1wcieRxH8vcmScM5Lo8LkvSWE/iVUYSe8D5bT/JD4LVEv5tPJXqfTHQgea8j8OckD4858rh7SL52kzIbU0r0JTxXEzlOUn6NJN3/jM7jpoYJH4GHEln3kHLRs3vz/wOTJ/z0", + "parameter_xml_size": 421705, + "parameter_xml": "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", + "build_time": 1561880428, + "summary": "PX4FMUv3", + "version": "0.1", + "image_maxsize": 2080768, + "image_size": 1477193, + "mav_autopilot": 12, + "git_identity": "v1.7.3", + "board_revision": 0 +} diff --git a/e0/2.PSPOfficialExps/qgc_tune_parameter/px4_simulink_app_params.c b/e0/2.PSPOfficialExps/qgc_tune_parameter/px4_simulink_app_params.c new file mode 100644 index 0000000..91a9f4e --- /dev/null +++ b/e0/2.PSPOfficialExps/qgc_tune_parameter/px4_simulink_app_params.c @@ -0,0 +1,30 @@ +#include + +/** + * Sample Simulink Param + * + * + * + * @unit number + * @min 0 + * @max 100 + * @decimal 0 + * @increment 1 + * @reboot_required false + * @group simulink + */ +PARAM_DEFINE_INT32(SL_MSG, 10); +/** + * Sample Simulink Param + * + * + * + * @unit number + * @min 0 + * @max 10000 + * @decimal 0.01 + * @increment 1.0 + * @reboot_required false + * @group simulink + */ +PARAM_DEFINE_FLOAT(SL_TEST, 14.7); \ No newline at end of file diff --git a/e0/2.PSPOfficialExps/qgc_tune_parameter/px4demo_QGC_tune.slx b/e0/2.PSPOfficialExps/qgc_tune_parameter/px4demo_QGC_tune.slx new file mode 100644 index 0000000..a905bfb Binary files /dev/null and b/e0/2.PSPOfficialExps/qgc_tune_parameter/px4demo_QGC_tune.slx differ diff --git a/e0/2.PSPOfficialExps/qgc_tune_parameter/readme.txt b/e0/2.PSPOfficialExps/qgc_tune_parameter/readme.txt new file mode 100644 index 0000000..f2693cc --- /dev/null +++ b/e0/2.PSPOfficialExps/qgc_tune_parameter/readme.txt @@ -0,0 +1,8 @@ +px4demo_ParameterUpdate_CSC_example.slx +This model is used to update the parameters with QGC. Note, that you may need to delete the parameters.xml +file to properly update the list of parameters. This file is located : +C:\px4_firmware_test\Firmware\build_\parameters.xml +Where could be px4fmu-v3_default or px4fmu-v2_default, etc + + +Use the 'px4_simulink_app_params.c' file to define the new parameters that will show up in QGC diff --git a/e0/3.DesignExps/Exp1_AttitudeController.slx b/e0/3.DesignExps/Exp1_AttitudeController.slx new file mode 100644 index 0000000..4f0f13a Binary files /dev/null and b/e0/3.DesignExps/Exp1_AttitudeController.slx differ diff --git a/e0/3.DesignExps/Exp2_ControlSystemDemo.slx b/e0/3.DesignExps/Exp2_ControlSystemDemo.slx new file mode 100644 index 0000000..48ce309 Binary files /dev/null and b/e0/3.DesignExps/Exp2_ControlSystemDemo.slx differ diff --git a/e0/3.DesignExps/Exp3_BlankTemp.slx b/e0/3.DesignExps/Exp3_BlankTemp.slx new file mode 100644 index 0000000..af74434 Binary files /dev/null and b/e0/3.DesignExps/Exp3_BlankTemp.slx differ diff --git a/e0/3.DesignExps/Exp4_AttitudeSystemCodeGen.slx b/e0/3.DesignExps/Exp4_AttitudeSystemCodeGen.slx new file mode 100644 index 0000000..f71edc6 Binary files /dev/null and b/e0/3.DesignExps/Exp4_AttitudeSystemCodeGen.slx differ diff --git a/e0/3.DesignExps/Exp5_AttitudeSystemCodeGenRealFlight.slx b/e0/3.DesignExps/Exp5_AttitudeSystemCodeGenRealFlight.slx new file mode 100644 index 0000000..4bc1eb2 Binary files /dev/null and b/e0/3.DesignExps/Exp5_AttitudeSystemCodeGenRealFlight.slx differ diff --git a/e0/3.DesignExps/Init_control.m b/e0/3.DesignExps/Init_control.m new file mode 100644 index 0000000..74d07c5 --- /dev/null +++ b/e0/3.DesignExps/Init_control.m @@ -0,0 +1,24 @@ +path(path, './icon/'); + +%ģ�Ͳ��� ����ģ�ͳ�ʼ���ļ�icon/init.m +Init; + + +kFactor = 1.2; + +KpRollAttitude = 0.630138625117681 / kFactor; +KiRollAttitude = 0.0552303199591522 / kFactor; + +KpPitchAttitude = 0.630138625117681 / kFactor; +KiPitchAttitude = 0.0552303199591522 / kFactor; + +KpRollRate = 1.31533836563383 / kFactor; +KiRollRate = 0.460338699849681 / kFactor; + +KpPitchRate = 1.31533836563383 / kFactor; +KiPitchRate = 0.460338699849681 / kFactor; + +KpYawRate = 1.31533836563383 / kFactor; +KiYawRate = 0.460338699849681 / kFactor; + + diff --git a/e0/3.DesignExps/icon/Battery_sf.mexw64 b/e0/3.DesignExps/icon/Battery_sf.mexw64 new file mode 100644 index 0000000..1bbdd22 Binary files /dev/null and b/e0/3.DesignExps/icon/Battery_sf.mexw64 differ diff --git a/e0/3.DesignExps/icon/Environment_sf.mexw64 b/e0/3.DesignExps/icon/Environment_sf.mexw64 new file mode 100644 index 0000000..ca15ae0 Binary files /dev/null and b/e0/3.DesignExps/icon/Environment_sf.mexw64 differ diff --git a/e0/3.DesignExps/icon/F450.png b/e0/3.DesignExps/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e0/3.DesignExps/icon/F450.png differ diff --git a/e0/3.DesignExps/icon/Fail_sf.mexw64 b/e0/3.DesignExps/icon/Fail_sf.mexw64 new file mode 100644 index 0000000..72486af Binary files /dev/null and b/e0/3.DesignExps/icon/Fail_sf.mexw64 differ diff --git a/e0/3.DesignExps/icon/FlightGear.png b/e0/3.DesignExps/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e0/3.DesignExps/icon/FlightGear.png differ diff --git a/e0/3.DesignExps/icon/Force_sf.mexw64 b/e0/3.DesignExps/icon/Force_sf.mexw64 new file mode 100644 index 0000000..8767223 Binary files /dev/null and b/e0/3.DesignExps/icon/Force_sf.mexw64 differ diff --git a/e0/3.DesignExps/icon/Init.m b/e0/3.DesignExps/icon/Init.m new file mode 100644 index 0000000..af3e616 --- /dev/null +++ b/e0/3.DesignExps/icon/Init.m @@ -0,0 +1,70 @@ +load MavLinkStruct.mat; +%PID Parameters +Kp_RP_ANGLE =6.5; +Kp_RP_AgngleRate = 0.10; +Ki_RP_AgngleRate = 0.02; +Kd_RP_AgngleRate = 0.001; + +Kp_YAW_AngleRate = 0.3; +Ki_YAW_AngleRate = 0.1; +Kd_YAW_AngleRate = 0.00; +%integral saturation +Saturation_I_RP_Max=0.3; +Saturation_I_RP_Min=-0.3; +Saturation_I_Y_Max=0.2; +Saturation_I_Y_Min=-0.2; +%thrust when UAV hover +THR_HOVER=0.609; +%max control angle +%default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%max control angle rate +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; + +%Initial condition +ModelInit_PosE = [0,0,0]; +ModelInit_VelB = [0,0,0]; +ModelInit_AngEuler = [0,0,0]; +ModelInit_RateB = [0,0,0]; +ModelInit_RPM = 0; %Initial motor speed(rad/s) + +%UAV model parameter +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx,0,0;... + 0,ModelParam_uavJyy,0;... + 0,0,ModelParam_uavJzz]; +ModelParam_uavType = int8(3); %X-type quadrotor��refer to "���Ͷ����ĵ�.docx" for specific definitions +ModelParam_uavMotNumbs = int8(4); %Number of motors +ModelParam_uavR = 0.225; %Body radius(m) + +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb =-141.4; %Motor speed-throttle curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) +%M=Cm*w^2 +ModelParam_rotorCm = 1.779e-07; %Rotor torque coefficient(kg.m^2) +%T=Ct**w^2 +ModelParam_rotorCt = 1.105e-05; %Rotor thrust coefficient(kg.m^2) +ModelParam_motorMinThr = 0.05; %Motor throttle dead zone(kg.m^2) + +ModelParam_uavCd = 0.073; %Damping coefficient(N/(m/s)^2) +ModelParam_uavCCm = [0.01 0.01 0.0055]; %Damping moment coefficient vector(N/(m/s)^2) +ModelParam_uavDearo = 0.12; %Vertical position difference of Aerodynamic center and gravity center(m) + +ModelParam_GlobalNoiseGainSwitch =1; %Noise level gain + +%Environment Parameter +ModelParam_envGravityAcc = 9.8; %Gravity acceleration(m/s^2) +ModelParam_envLongitude = 116.259368300000; +ModelParam_envLatitude = 40.1540302; +ModelParam_GPSLatLong = [ModelParam_envLatitude ModelParam_envLongitude]; %Latitude and longitude +ModelParam_envAltitude = -41.5260009765625; %Reference height, down is positive +ModelParam_BusSampleRate = 0.001; %Model sampling rate + diff --git a/e0/3.DesignExps/icon/MavLinkStruct.mat b/e0/3.DesignExps/icon/MavLinkStruct.mat new file mode 100644 index 0000000..3e1d05f Binary files /dev/null and b/e0/3.DesignExps/icon/MavLinkStruct.mat differ diff --git a/e0/3.DesignExps/icon/Motor_sf.mexw64 b/e0/3.DesignExps/icon/Motor_sf.mexw64 new file mode 100644 index 0000000..6be8fa7 Binary files /dev/null and b/e0/3.DesignExps/icon/Motor_sf.mexw64 differ diff --git a/e0/3.DesignExps/icon/OutputPort_sf.mexw64 b/e0/3.DesignExps/icon/OutputPort_sf.mexw64 new file mode 100644 index 0000000..f2ec536 Binary files /dev/null and b/e0/3.DesignExps/icon/OutputPort_sf.mexw64 differ diff --git a/e0/3.DesignExps/icon/pixhawk.png b/e0/3.DesignExps/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e0/3.DesignExps/icon/pixhawk.png differ diff --git a/e1/README.txt b/e1/README.txt new file mode 100644 index 0000000..15fb761 --- /dev/null +++ b/e1/README.txt @@ -0,0 +1 @@ +The multicopter performance evaluation website: https://flyeval.com/paper/. \ No newline at end of file diff --git a/e2/README.txt b/e2/README.txt new file mode 100644 index 0000000..3dd6d98 --- /dev/null +++ b/e2/README.txt @@ -0,0 +1,10 @@ + The instruction package for the basic experiment is e2/e2.1. We copy some system parameters in +'e2/e2.1/icon/Init.m' to 'e2/e2.1/Init_control.m' for your easy modification. + + 'e2/e2.3/dynamics.slx' is a quadcopter dynamic model we have established. You can design your own +multicopter dynamic model according to our design style. + The quadcopter parameters in 'e2/e2.3/Init.m' are obtained by using the system identification method +for real aircraft, which are also used in the subsequent models. + 'e2/e2.3/myownUAV' is a simple quadcopter model we provide, which includes a 3D model and two xml +configuration files. The model path and parameters in the xml file shoule be consistent with the path +and parameters of quadcopter model. \ No newline at end of file diff --git a/e2/e2.1/Init_control.m b/e2/e2.1/Init_control.m new file mode 100644 index 0000000..6508f69 --- /dev/null +++ b/e2/e2.1/Init_control.m @@ -0,0 +1,36 @@ +clear +path('./icon/',path); +Init; + +%Constant parameters +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%Initial condition +ModelInit_PosE = [0, 0, -100]; %Initial position +ModelInit_VelB = [0, 0, 0]; %Initial velocity +ModelInit_AngEuler = [0, 0, 0]; %Initial Euler angle +ModelInit_RateB = [0, 0, 0]; %Initial angular velocity +ModelInit_Rads = 557.1420; %Initial motor speed(rad/s) + +%UAV model parameter +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx, 0, 0;... + 0, ModelParam_uavJyy, 0;... + 0, 0, ModelParam_uavJzz]; +ModelParam_uavR = 0.225; %Body radius(m) + +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb = -141.4; %Motor speed-throttle curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) +%M=Cm*w^2 +ModelParam_rotorCm = 1.779e-07; %Rotor torque coefficient(kg.m^2) +%T=Ct**w^2 +ModelParam_rotorCt = 1.105e-05; %Rotor thrust coefficient(kg.m^2) + +%Calculation formula for hovering throttle +%THR = (sqrt(ModelParam_uavMass*9.8/4/ModelParam_rotorCt) - ModelParam_motorWb)/ModelParam_motorCr; diff --git a/e2/e2.1/e2_1.slx b/e2/e2.1/e2_1.slx new file mode 100644 index 0000000..2c9287b Binary files /dev/null and b/e2/e2.1/e2_1.slx differ diff --git a/e2/e2.1/icon/F450.png b/e2/e2.1/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e2/e2.1/icon/F450.png differ diff --git a/e2/e2.1/icon/FlightGear.png b/e2/e2.1/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e2/e2.1/icon/FlightGear.png differ diff --git a/e2/e2.1/icon/Init.m b/e2/e2.1/icon/Init.m new file mode 100644 index 0000000..4782901 --- /dev/null +++ b/e2/e2.1/icon/Init.m @@ -0,0 +1,65 @@ + +%PID Parameters +Kp_RP_ANGLE = 6.5; +Kp_RP_AgngleRate = 0.10; +Ki_RP_AgngleRate = 0.02; +Kd_RP_AgngleRate = 0.001; + +Kp_YAW_AngleRate = 0.3; +Ki_YAW_AngleRate = 0.1; +Kd_YAW_AngleRate = 0.00; +%integral saturation +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +%thrust when UAV hover +THR_HOVER=0.609; +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; + +%Initial condition +ModelInit_PosE = [0, 0, 0]; %Initial position +ModelInit_VelB = [0, 0, 0]; %Initial velocity +ModelInit_AngEuler = [0, 0, 0]; %Initial Euler angle +ModelInit_RateB = [0, 0, 0]; %Initial angular velocity +ModelInit_Rads = 0; %Initial motor speed(rad/s) + +%UAV model parameter +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx, 0, 0;... + 0, ModelParam_uavJyy, 0;... + 0, 0, ModelParam_uavJzz]; +ModelParam_uavType = int8(3); %X-type quadrotor��refer to "SupportedVehicleTypes.pdf" for specific definitions +ModelParam_uavMotNumbs = int8(4); %Number of motors +ModelParam_uavR = 0.225; %Body radius(m) +ModelParam_uavCd = 0.073; %Damping coefficient(N/(m/s)^2) +ModelParam_uavCCm = [0.01 0.01 0.0055]; %Damping moment coefficient vector(N/(m/s)^2) + +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb = -141.4; %Motor speed-throttle curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) +ModelParam_motorMinThr = 0.05; %Motor throttle dead zone(kg.m^2) +%M=Cm*w^2 +ModelParam_rotorCm = 1.779e-07; %Rotor torque coefficient(kg.m^2) +%T=Ct**w^2 +ModelParam_rotorCt = 1.105e-05; %Rotor thrust coefficient(kg.m^2) + +%Environment Parameter +ModelParam_envGravityAcc = 9.8; %Gravity acceleration(m/s^2) +ModelParam_envLongitude = 116.259368300000; +ModelParam_envLatitude = 40.1540302; +ModelParam_GPSLatLong = [ModelParam_envLatitude ModelParam_envLongitude]; %Latitude and longitude +ModelParam_envAltitude = -41.5260009765625; %Reference height, down is positive +ModelParam_BusSampleRate = 0.001; %Model sampling rate + diff --git a/e2/e2.1/icon/SupportedVehicleTypes.pdf b/e2/e2.1/icon/SupportedVehicleTypes.pdf new file mode 100644 index 0000000..594b76a Binary files /dev/null and b/e2/e2.1/icon/SupportedVehicleTypes.pdf differ diff --git a/e2/e2.1/icon/pixhawk.png b/e2/e2.1/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e2/e2.1/icon/pixhawk.png differ diff --git a/e2/e2.3/Init.m b/e2/e2.3/Init.m new file mode 100644 index 0000000..022b764 --- /dev/null +++ b/e2/e2.3/Init.m @@ -0,0 +1,31 @@ +clear; +%Initial condition +ModelInit_Rads = 557.1420; %Initial motor speed(rad/s) + +%Motor parameters +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb = -141.4; %Motor throttle-speed curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) + +%Propeller parameters +%Rotor torque coefficient��N.m/(rad/s)^2�� +%Definition: Torque M (N.m), propeller speed w (rad/s), M = Cm*w^2 +ModelParam_rotorCm = 1.779e-07; +%Rotor thrust coefficient��N/(rad/s)^2�� +%Definition: Tensile force T (N), T = Ct**w^2 +ModelParam_rotorCt = 1.105e-05; + +ModelParam_uavCd = 0.055; %Damping coefficient(N/(m/s)^2) +ModelParam_uavCCm = [0.0035 0.0039 0.0034]; %Damping moment coefficient vector(N/(m/s)^2) +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavR = 0.225; %Body radius(m) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx, 0, 0;... + 0, ModelParam_uavJyy, 0;... + 0, 0, ModelParam_uavJzz]; + +ModelParam_envGravityAcc = 9.8; %Gravity acceleration(m/s^2) diff --git a/e2/e2.3/dynamics.slx b/e2/e2.3/dynamics.slx new file mode 100644 index 0000000..fba08d3 Binary files /dev/null and b/e2/e2.3/dynamics.slx differ diff --git a/e2/e2.3/icon/F450.png b/e2/e2.3/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e2/e2.3/icon/F450.png differ diff --git a/e2/e2.3/icon/FlightGear.png b/e2/e2.3/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e2/e2.3/icon/FlightGear.png differ diff --git a/e2/e2.3/icon/SupportedVehicleTypes.pdf b/e2/e2.3/icon/SupportedVehicleTypes.pdf new file mode 100644 index 0000000..594b76a Binary files /dev/null and b/e2/e2.3/icon/SupportedVehicleTypes.pdf differ diff --git a/e2/e2.3/icon/pixhawk.png b/e2/e2.3/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e2/e2.3/icon/pixhawk.png differ diff --git a/e2/e2.3/myownUAV/Models/myownUAV.ac b/e2/e2.3/myownUAV/Models/myownUAV.ac new file mode 100644 index 0000000..73847f2 --- /dev/null +++ b/e2/e2.3/myownUAV/Models/myownUAV.ac @@ -0,0 +1,1259 @@ +AC3Db +MATERIAL "ac3dmat1" rgb 1 1 1 amb 0.2 0.2 0.2 emis 0 0 0 spec 0.2 0.2 0.2 shi 128 trans 0 +MATERIAL "ac3dmat13" rgb 0.533333 0.533333 0.533333 amb 0.2 0.2 0.2 emis 0 0 0 spec 0.2 0.2 0.2 shi 128 trans 0 +OBJECT world +kids 5 +OBJECT poly +name "propeller1" +loc -7.08529 0 -6.06618 +crease 45.000000 +numvert 4 +7.14677 1 -1.10735 +3.3353 1 -1.48235 +7.20825 1 -1.85735 +10.8353 1 -1.44485 +numsurf 1 +SURF 0x30 +mat 1 +refs 4 +3 0.55 1 +2 0 0.516393 +1 0.5 0 +0 1 0.508197 +kids 0 +OBJECT poly +name "propeller3" +loc -7.49779 0 -5.11985 +crease 45.000000 +numvert 6 +11.2478 1 12.4963 +7.40633 1 12.1963 +3.74779 1 12.4963 +3.80877 1 12.6763 +7.40633 1 12.9463 +11.2478 1 12.7063 +numsurf 1 +SURF 0x30 +mat 1 +refs 6 +0 0.4 1 +1 0 0.487805 +2 0.4 0 +3 0.64 0.00813007 +4 1 0.487805 +5 0.68 1 +kids 0 +OBJECT poly +name "propeller4" +loc -7.49779 0 -5.11985 +crease 45.000000 +numvert 6 +0.132794 1 1.32132 +0.372794 1 5.16279 +0.102794 1 8.76035 +-0.0772057 1 8.82132 +-0.377206 1 5.16279 +-0.0772057 1 1.32132 +numsurf 1 +SURF 0x30 +mat 1 +refs 6 +5 0.4 1 +4 0 0.487805 +3 0.4 0 +2 0.64 0.00813007 +1 1 0.487805 +0 0.68 1 +kids 0 +OBJECT group +name "group" +loc 1.40625 0 -0.0485296 +kids 4 +OBJECT poly +name "cylinder" +loc -1.40625 0 -7.5 +crease 45.000000 +numvert 26 +0.649519 0.75 0.375 +0.375 0.75 0.649519 +0 0.75 0.75 +-0.375 0.75 0.649519 +-0.649519 0.75 0.375 +-0.75 0.75 0 +-0.649519 0.75 -0.375 +-0.375 0.75 -0.649519 +0 0.75 -0.75 +0.375 0.75 -0.649519 +0.649519 0.75 -0.375 +0.75 0.75 0 +0.649519 -0.75 0.375 +0.375 -0.75 0.649519 +0 -0.75 0.75 +-0.375 -0.75 0.649519 +-0.649519 -0.75 0.375 +-0.75 -0.75 0 +-0.649519 -0.75 -0.375 +-0.375 -0.75 -0.649519 +0 -0.75 -0.75 +0.375 -0.75 -0.649519 +0.649519 -0.75 -0.375 +0.75 -0.75 0 +0 0.75 0 +0 -0.75 0 +numsurf 36 +SURF 0x10 +mat 0 +refs 4 +1 0.916667 1 +13 0.916667 0 +12 1 0 +0 1 1 +SURF 0x10 +mat 0 +refs 4 +2 0.833333 1 +14 0.833333 0 +13 0.916667 0 +1 0.916667 1 +SURF 0x10 +mat 0 +refs 4 +3 0.75 1 +15 0.75 0 +14 0.833333 0 +2 0.833333 1 +SURF 0x10 +mat 0 +refs 4 +4 0.666667 1 +16 0.666667 0 +15 0.75 0 +3 0.75 1 +SURF 0x10 +mat 0 +refs 4 +5 0.583333 1 +17 0.583333 0 +16 0.666667 0 +4 0.666667 1 +SURF 0x10 +mat 0 +refs 4 +6 0.5 1 +18 0.5 0 +17 0.583333 0 +5 0.583333 1 +SURF 0x10 +mat 0 +refs 4 +7 0.416667 1 +19 0.416667 0 +18 0.5 0 +6 0.5 1 +SURF 0x10 +mat 0 +refs 4 +8 0.333333 1 +20 0.333333 0 +19 0.416667 0 +7 0.416667 1 +SURF 0x10 +mat 0 +refs 4 +9 0.25 1 +21 0.25 0 +20 0.333333 0 +8 0.333333 1 +SURF 0x10 +mat 0 +refs 4 +10 0.166667 1 +22 0.166667 0 +21 0.25 0 +9 0.25 1 +SURF 0x10 +mat 0 +refs 4 +11 0.0833333 1 +23 0.0833333 0 +22 0.166667 0 +10 0.166667 1 +SURF 0x10 +mat 0 +refs 4 +0 0 1 +12 0 0 +23 0.0833333 0 +11 0.0833333 1 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +1 0 0 +0 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +2 0 0 +1 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +3 0 0 +2 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +4 0 0 +3 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +5 0 0 +4 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +6 0 0 +5 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +7 0 0 +6 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +8 0 0 +7 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +9 0 0 +8 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +10 0 0 +9 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +11 0 0 +10 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +0 0 0 +11 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +12 0 0 +13 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +13 0 0 +14 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +14 0 0 +15 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +15 0 0 +16 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +16 0 0 +17 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +17 0 0 +18 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +18 0 0 +19 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +19 0 0 +20 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +20 0 0 +21 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +21 0 0 +22 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +22 0 0 +23 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +23 0 0 +12 0 0 +kids 0 +OBJECT poly +name "cylinder" +loc -1.40625 0 7.5 +crease 45.000000 +numvert 26 +0 -0.75 0 +0 0.75 0 +0.75 -0.75 0 +0.649519 -0.75 -0.375 +0.375 -0.75 -0.649519 +0 -0.75 -0.75 +-0.375 -0.75 -0.649519 +-0.649519 -0.75 -0.375 +-0.75 -0.75 0 +-0.649519 -0.75 0.375 +-0.375 -0.75 0.649519 +0 -0.75 0.75 +0.375 -0.75 0.649519 +0.649519 -0.75 0.375 +0.75 0.75 0 +0.649519 0.75 -0.375 +0.375 0.75 -0.649519 +0 0.75 -0.75 +-0.375 0.75 -0.649519 +-0.649519 0.75 -0.375 +-0.75 0.75 0 +-0.649519 0.75 0.375 +-0.375 0.75 0.649519 +0 0.75 0.75 +0.375 0.75 0.649519 +0.649519 0.75 0.375 +numsurf 36 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +2 0 0 +13 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +3 0 0 +2 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +4 0 0 +3 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +5 0 0 +4 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +6 0 0 +5 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +7 0 0 +6 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +8 0 0 +7 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +9 0 0 +8 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +10 0 0 +9 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +11 0 0 +10 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +12 0 0 +11 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +13 0 0 +12 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +25 0 0 +14 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +14 0 0 +15 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +15 0 0 +16 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +16 0 0 +17 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +17 0 0 +18 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +18 0 0 +19 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +19 0 0 +20 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +20 0 0 +21 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +21 0 0 +22 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +22 0 0 +23 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +23 0 0 +24 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +24 0 0 +25 0 0 +SURF 0x10 +mat 0 +refs 4 +25 0 1 +13 0 0 +2 0.0833333 0 +14 0.0833333 1 +SURF 0x10 +mat 0 +refs 4 +14 0.0833333 1 +2 0.0833333 0 +3 0.166667 0 +15 0.166667 1 +SURF 0x10 +mat 0 +refs 4 +15 0.166667 1 +3 0.166667 0 +4 0.25 0 +16 0.25 1 +SURF 0x10 +mat 0 +refs 4 +16 0.25 1 +4 0.25 0 +5 0.333333 0 +17 0.333333 1 +SURF 0x10 +mat 0 +refs 4 +17 0.333333 1 +5 0.333333 0 +6 0.416667 0 +18 0.416667 1 +SURF 0x10 +mat 0 +refs 4 +18 0.416667 1 +6 0.416667 0 +7 0.5 0 +19 0.5 1 +SURF 0x10 +mat 0 +refs 4 +19 0.5 1 +7 0.5 0 +8 0.583333 0 +20 0.583333 1 +SURF 0x10 +mat 0 +refs 4 +20 0.583333 1 +8 0.583333 0 +9 0.666667 0 +21 0.666667 1 +SURF 0x10 +mat 0 +refs 4 +21 0.666667 1 +9 0.666667 0 +10 0.75 0 +22 0.75 1 +SURF 0x10 +mat 0 +refs 4 +22 0.75 1 +10 0.75 0 +11 0.833333 0 +23 0.833333 1 +SURF 0x10 +mat 0 +refs 4 +23 0.833333 1 +11 0.833333 0 +12 0.916667 0 +24 0.916667 1 +SURF 0x10 +mat 0 +refs 4 +24 0.916667 1 +12 0.916667 0 +13 1 0 +25 1 1 +kids 0 +OBJECT poly +name "cylinder" +loc 6.09375 0 0 +crease 45.000000 +numvert 26 +0.64952 0.75 0.375 +0.375 0.75 0.649519 +0 0.75 0.75 +-0.375 0.75 0.649519 +-0.649518 0.75 0.375 +-0.75 0.75 0 +-0.649518 0.75 -0.375 +-0.375 0.75 -0.649519 +0 0.75 -0.75 +0.375 0.75 -0.649519 +0.649519 0.75 -0.375 +0.75 0.75 -4.76837e-007 +0.64952 -0.75 0.375 +0.375 -0.75 0.649519 +0 -0.75 0.75 +-0.375 -0.75 0.649519 +-0.649518 -0.75 0.375 +-0.75 -0.75 0 +-0.649518 -0.75 -0.375 +-0.375 -0.75 -0.649519 +0 -0.75 -0.75 +0.375 -0.75 -0.649519 +0.649519 -0.75 -0.375 +0.75 -0.75 -4.76837e-007 +0 0.75 0 +0 -0.75 0 +numsurf 36 +SURF 0x10 +mat 0 +refs 4 +1 0.916667 1 +13 0.916667 0 +12 1 0 +0 1 1 +SURF 0x10 +mat 0 +refs 4 +2 0.833333 1 +14 0.833333 0 +13 0.916667 0 +1 0.916667 1 +SURF 0x10 +mat 0 +refs 4 +3 0.75 1 +15 0.75 0 +14 0.833333 0 +2 0.833333 1 +SURF 0x10 +mat 0 +refs 4 +4 0.666667 1 +16 0.666667 0 +15 0.75 0 +3 0.75 1 +SURF 0x10 +mat 0 +refs 4 +5 0.583333 1 +17 0.583333 0 +16 0.666667 0 +4 0.666667 1 +SURF 0x10 +mat 0 +refs 4 +6 0.5 1 +18 0.5 0 +17 0.583333 0 +5 0.583333 1 +SURF 0x10 +mat 0 +refs 4 +7 0.416667 1 +19 0.416667 0 +18 0.5 0 +6 0.5 1 +SURF 0x10 +mat 0 +refs 4 +8 0.333333 1 +20 0.333333 0 +19 0.416667 0 +7 0.416667 1 +SURF 0x10 +mat 0 +refs 4 +9 0.25 1 +21 0.25 0 +20 0.333333 0 +8 0.333333 1 +SURF 0x10 +mat 0 +refs 4 +10 0.166667 1 +22 0.166667 0 +21 0.25 0 +9 0.25 1 +SURF 0x10 +mat 0 +refs 4 +11 0.0833333 1 +23 0.0833333 0 +22 0.166667 0 +10 0.166667 1 +SURF 0x10 +mat 0 +refs 4 +0 0 1 +12 0 0 +23 0.0833333 0 +11 0.0833333 1 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +1 0 0 +0 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +2 0 0 +1 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +3 0 0 +2 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +4 0 0 +3 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +5 0 0 +4 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +6 0 0 +5 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +7 0 0 +6 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +8 0 0 +7 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +9 0 0 +8 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +10 0 0 +9 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +11 0 0 +10 0 0 +SURF 0x10 +mat 0 +refs 3 +24 0 0 +0 0 0 +11 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +12 0 0 +13 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +13 0 0 +14 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +14 0 0 +15 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +15 0 0 +16 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +16 0 0 +17 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +17 0 0 +18 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +18 0 0 +19 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +19 0 0 +20 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +20 0 0 +21 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +21 0 0 +22 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +22 0 0 +23 0 0 +SURF 0x10 +mat 0 +refs 3 +25 0 0 +23 0 0 +12 0 0 +kids 0 +OBJECT group +name "group" +loc -3.28125 0 0 +kids 2 +OBJECT poly +name "box" +loc 1.875 0 0 +crease 45.000000 +numvert 8 +-0.25 -0.25 -7.5 +0.25 -0.25 -7.5 +0.25 -0.25 7.5 +-0.25 -0.25 7.5 +-0.25 0.25 7.5 +0.25 0.25 7.5 +0.25 0.25 -7.5 +-0.25 0.25 -7.5 +numsurf 6 +SURF 0x30 +mat 0 +refs 4 +5 0 0 +2 1 0 +1 1 1 +6 0 1 +SURF 0x30 +mat 0 +refs 4 +7 0 0 +0 1 0 +3 1 1 +4 0 1 +SURF 0x30 +mat 0 +refs 4 +6 0 0 +1 1 0 +0 1 1 +7 0 1 +SURF 0x30 +mat 0 +refs 4 +4 0 0 +3 1 0 +2 1 1 +5 0 1 +SURF 0x30 +mat 0 +refs 4 +7 0 0 +4 1 0 +5 1 1 +6 0 1 +SURF 0x30 +mat 0 +refs 4 +0 0 0 +1 1 0 +2 1 1 +3 0 1 +kids 0 +OBJECT group +name "group" +loc -1.875 0 0 +kids 2 +OBJECT poly +name "box" +loc 3.75 0 0 +crease 45.000000 +numvert 8 +-7.5 -0.25 -0.25 +7.5 -0.25 -0.25 +7.5 -0.25 0.25 +-7.5 -0.25 0.25 +-7.5 0.25 0.25 +7.5 0.25 0.25 +7.5 0.25 -0.25 +-7.5 0.25 -0.25 +numsurf 6 +SURF 0x30 +mat 0 +refs 4 +5 0 0 +2 1 0 +1 1 1 +6 0 1 +SURF 0x30 +mat 0 +refs 4 +7 0 0 +0 1 0 +3 1 1 +4 0 1 +SURF 0x30 +mat 0 +refs 4 +6 0 0 +1 1 0 +0 1 1 +7 0 1 +SURF 0x30 +mat 0 +refs 4 +4 0 0 +3 1 0 +2 1 1 +5 0 1 +SURF 0x30 +mat 0 +refs 4 +7 0 0 +4 1 0 +5 1 1 +6 0 1 +SURF 0x30 +mat 0 +refs 4 +0 0 0 +1 1 0 +2 1 1 +3 0 1 +kids 0 +OBJECT poly +name "cylinder" +loc -3.75 0 0 +crease 45.000000 +numvert 26 +0 -0.75 0 +0 0.75 0 +0.75 -0.75 -5.92321e-007 +0.649519 -0.75 -0.375 +0.375 -0.75 -0.649519 +0 -0.75 -0.75 +-0.375 -0.75 -0.649519 +-0.649519 -0.75 -0.375 +-0.75 -0.75 1.19209e-007 +-0.649519 -0.75 0.375 +-0.375 -0.75 0.649519 +0 -0.75 0.75 +0.375 -0.75 0.649519 +0.649519 -0.75 0.375 +0.75 0.75 -5.92321e-007 +0.649519 0.75 -0.375 +0.375 0.75 -0.649519 +0 0.75 -0.75 +-0.375 0.75 -0.649519 +-0.649519 0.75 -0.375 +-0.75 0.75 1.19209e-007 +-0.649519 0.75 0.375 +-0.375 0.75 0.649519 +0 0.75 0.75 +0.375 0.75 0.649519 +0.649519 0.75 0.375 +numsurf 36 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +2 0 0 +13 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +3 0 0 +2 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +4 0 0 +3 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +5 0 0 +4 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +6 0 0 +5 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +7 0 0 +6 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +8 0 0 +7 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +9 0 0 +8 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +10 0 0 +9 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +11 0 0 +10 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +12 0 0 +11 0 0 +SURF 0x10 +mat 0 +refs 3 +0 0 0 +13 0 0 +12 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +25 0 0 +14 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +14 0 0 +15 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +15 0 0 +16 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +16 0 0 +17 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +17 0 0 +18 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +18 0 0 +19 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +19 0 0 +20 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +20 0 0 +21 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +21 0 0 +22 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +22 0 0 +23 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +23 0 0 +24 0 0 +SURF 0x10 +mat 0 +refs 3 +1 0 0 +24 0 0 +25 0 0 +SURF 0x10 +mat 0 +refs 4 +25 0 1 +13 0 0 +2 0.0833333 0 +14 0.0833333 1 +SURF 0x10 +mat 0 +refs 4 +14 0.0833333 1 +2 0.0833333 0 +3 0.166667 0 +15 0.166667 1 +SURF 0x10 +mat 0 +refs 4 +15 0.166667 1 +3 0.166667 0 +4 0.25 0 +16 0.25 1 +SURF 0x10 +mat 0 +refs 4 +16 0.25 1 +4 0.25 0 +5 0.333333 0 +17 0.333333 1 +SURF 0x10 +mat 0 +refs 4 +17 0.333333 1 +5 0.333333 0 +6 0.416667 0 +18 0.416667 1 +SURF 0x10 +mat 0 +refs 4 +18 0.416667 1 +6 0.416667 0 +7 0.5 0 +19 0.5 1 +SURF 0x10 +mat 0 +refs 4 +19 0.5 1 +7 0.5 0 +8 0.583333 0 +20 0.583333 1 +SURF 0x10 +mat 0 +refs 4 +20 0.583333 1 +8 0.583333 0 +9 0.666667 0 +21 0.666667 1 +SURF 0x10 +mat 0 +refs 4 +21 0.666667 1 +9 0.666667 0 +10 0.75 0 +22 0.75 1 +SURF 0x10 +mat 0 +refs 4 +22 0.75 1 +10 0.75 0 +11 0.833333 0 +23 0.833333 1 +SURF 0x10 +mat 0 +refs 4 +23 0.833333 1 +11 0.833333 0 +12 0.916667 0 +24 0.916667 1 +SURF 0x10 +mat 0 +refs 4 +24 0.916667 1 +12 0.916667 0 +13 1 0 +25 1 1 +kids 0 +OBJECT poly +name "propeller2" +loc -7.49779 0 -5.11985 +crease 45.000000 +numvert 6 +14.9228 1 1.32132 +14.6228 1 5.16279 +14.9228 1 8.82132 +15.1028 1 8.76035 +15.3728 1 5.16279 +15.1328 1 1.32132 +numsurf 1 +SURF 0x30 +mat 1 +refs 6 +0 0.4 1 +1 0 0.487805 +2 0.4 0 +3 0.64 0.00813007 +4 1 0.487805 +5 0.68 1 +kids 0 diff --git a/e2/e2.3/myownUAV/Models/myownUAV.xml b/e2/e2.3/myownUAV/Models/myownUAV.xml new file mode 100644 index 0000000..6f35545 --- /dev/null +++ b/e2/e2.3/myownUAV/Models/myownUAV.xml @@ -0,0 +1,87 @@ + + + + + + myownUAV.ac + + + + spin + propeller1 + /engines/engine[0]/rpm + -1 +
+ 0 + 7.5 + 1 +
+ + 0.0 + 0.0 + 1.0 + + + + + + spin + propeller2 + /engines/engine[1]/rpm + 1 +
+ 7.5 + 0 + 1 +
+ + 0.0 + 0.0 + 1.0 + + + + + + spin + propeller3 + /engines/engine[2]/rpm + -1 +
+ 0 + -7.5 + 1 +
+ + 0.0 + 0.0 + 1.0 + + + + + + + spin + propeller4 + /engines/engine[3]/rpm + 1 +
+ -7.5 + 0 + 1 +
+ + 0.0 + 0.0 + 1.0 + + + + + + diff --git a/e2/e2.3/myownUAV/myownUAV-set.xml b/e2/e2.3/myownUAV/myownUAV-set.xml new file mode 100644 index 0000000..5276989 --- /dev/null +++ b/e2/e2.3/myownUAV/myownUAV-set.xml @@ -0,0 +1,26 @@ + + + + + + + myownUAV + + network + + + Aircraft/myownUAV/Models/myownUAV.xml + + + + -40 + + 2 + + + + diff --git a/e3/README.txt b/e3/README.txt new file mode 100644 index 0000000..5861b76 --- /dev/null +++ b/e3/README.txt @@ -0,0 +1,12 @@ + As for basic experiment, if you don't have hardware, you can use the 'e3\e3.1\AccRaw.mat' data directly, +and the corresponding calibration function is 'e3\e3.1\calLM.m'; if you have hardware, you will get a file similar +to 'e3\e3.1\rawdataFile\e_acc1_A.bin', and the corresponding calibration function is 'e3\e3.1\calLMRaw.m'. + + The data in 'e3\e3.1\rawdataFile\e_acc1_A.bin' are obtained by the 'e3\e3.1\acquire_dataag.slx' acceleration +data acquisition model and they have been calibrated by PX4 before logged.So before using them for calibration, you +should withdraw the uncalibrated data using 'Sensor Calibration' parameters which can be found in QGC as we do in +fourteenth and fifteenth lines of 'e3\e3.1\calLMRaw.m'. + The data in 'e3\e3.1\AccRaw.mat' are the uncalibrated data which can be directly used for calibration. + + The data in 'e3\e3.2\accdata.mat' are used for computing pitch.You can get the similar data by +'e3\e3.1\acquire_dataag.slx',and you should slowly rotate the Pixhawk. \ No newline at end of file diff --git a/e3/e3.1/AccRaw.mat b/e3/e3.1/AccRaw.mat new file mode 100644 index 0000000..ced2a1a Binary files /dev/null and b/e3/e3.1/AccRaw.mat differ diff --git a/e3/e3.1/acquire_data_ag.slx b/e3/e3.1/acquire_data_ag.slx new file mode 100644 index 0000000..d880d5b Binary files /dev/null and b/e3/e3.1/acquire_data_ag.slx differ diff --git a/e3/e3.1/calFunc.m b/e3/e3.1/calFunc.m new file mode 100644 index 0000000..b23890b --- /dev/null +++ b/e3/e3.1/calFunc.m @@ -0,0 +1,24 @@ +function Y = calFunc(x, p) +%Function description: +% Accelerometer error model, Y(i) = norm(Ka*(x(:,i) - ba)) +%Input: +% x:Accelerometer original value, dimension 3*m +% p:Model parameter, dimension 6*1 +%Output: +% Y:Corrected gravitational acceleration value. + + kx = p(1); + ky = p(2); + kz = p(3); + bx = p(4); + by = p(5); + bz = p(6); + + Ka = [kx 0 0;0 ky 0;0 0 kz]; + ba = [bx by bz]'; + m = length(x); + Y = zeros(1, m); + for i = 1:m + Y(i) = norm(Ka*(x(1:3, i) + ba)); + end +end \ No newline at end of file diff --git a/e3/e3.1/calLM.m b/e3/e3.1/calLM.m new file mode 100644 index 0000000..62eacf0 --- /dev/null +++ b/e3/e3.1/calLM.m @@ -0,0 +1,48 @@ +%File Description: +% According to the accelerometer error model, the accelerometer error model parameters are calculated using the lm optimization algorithm. +close all +clc +clear + +load AccRaw %Load uncalibrated accelerometer value +g = 9.8; +m = length(AccRaw); + +y_dat = g*ones(m, 1); %Expected gravitational acceleration value +p0 = [1 1 1 0 0 0]'; +p_init = [1.0 1.0 1.0 0.1 0.1 0.1]'; %Accelerometer error model parameter initial value + +y_raw = calFunc(AccRaw, p0); %2-norm of uncalibrated accelerometer value +y_raw = y_raw(:); +%The difference between the uncalibrated gravitational acceleration measured by the accelerometer +%and the standard gravitational acceleration +r_raw = y_dat - y_raw; +p_fit = lm('calFunc', p_init, AccRaw, y_dat); +y_lm = calFunc(AccRaw, p_fit); %2-norm of calibrated accelerometer value +y_lm = y_lm(:); +r_lm = y_dat - y_lm; + +kx = p_fit(1); +ky = p_fit(2); +kz = p_fit(3); +bx = p_fit(4); +by = p_fit(5); +bz = p_fit(6); + +Ka9_8 = [kx 0 0; 0 ky 0; 0 0 kz] +ba9_8 = [bx by bz]' +save('calP9_8', 'Ka9_8', 'ba9_8') + +figure +bar([r_raw'*r_raw, r_lm'*r_lm]) +grid on; +set(gca, 'XTickLabel', {'raw', 'lm'}); +ylabel('fa'); + +t=1:m; +figure +title('Accelerometer Calibration') +plot(t, r_raw, t, r_lm) +legend('Uncalibrated', 'Calibrated-LM') +xlabel('Measurement sampling number') +ylabel('Residual') diff --git a/e3/e3.1/calLMRaw.m b/e3/e3.1/calLMRaw.m new file mode 100644 index 0000000..00ee617 --- /dev/null +++ b/e3/e3.1/calLMRaw.m @@ -0,0 +1,93 @@ +%File Description: +% According to the accelerometer error model, the accelerometer error model +% parameters are calculated using the lm optimization algorithm. +close all +clc +clear + +%% Decode the binary data +%@ [datapoints, numpoints] = px4_read_binary_file(' '); + +%% Get raw uncalibrated data + %Accelerometer calibration parameters in the Pixhawk autopilot + %which can be obtained from QGC + %@ CAL_ACC_SCALE= ; %3*1 + %@ CAL_ACC_OFF= ; %3*1 + +acc_acq = find(datapoints(4, :)); +g = 9.8; +AccPX4 = datapoints(4:6, acc_acq); +datapoints(1:3, :) = (datapoints(1:3, :) + CAL_ACC_OFF) ./CAL_ACC_SCALE; +datapoints(4:6, acc_acq) = (datapoints(4:6, acc_acq) + CAL_ACC_OFF) ./CAL_ACC_SCALE; +plot_data(datapoints, acc_acq); + +AccRaw = datapoints(4:6, acc_acq); %Raw data +m=length(AccRaw); + +%% Parameter calibration +y_dat = g*ones(m, 1); %Expected gravitational acceleration value +p0 = [1 1 1 0 0 0]'; +p_init = [1.0 1.0 1.0 0.1 0.1 0.1]'; %Accelerometer error model parameter initial value + +y_raw = calFunc(AccRaw, p0); %2-norm of uncalibrated accelerometer value +y_raw = y_raw(:); +%The difference between the uncalibrated gravitational acceleration measured by the accelerometer +%and the standard gravitational acceleration +r_raw = y_dat - y_raw; +p_fit = lm('calFunc', p_init, AccRaw, y_dat); +y_lm = calFunc(AccRaw, p_fit); %2-norm of calibrated accelerometer value +y_lm = y_lm(:); +r_lm = y_dat - y_lm; + +kx = p_fit(1); +ky = p_fit(2); +kz = p_fit(3); +bx = p_fit(4); +by = p_fit(5); +bz = p_fit(6); + +%% print and save the parameters +Ka9_8=[kx 0 0;0 ky 0;0 0 kz] +ba9_8=[bx by bz]' +save('calP9_8', 'Ka9_8', 'ba9_8') + +figure +bar([r_raw'*r_raw,r_lm'*r_lm]) +grid on; +set(gca,'XTickLabel', {'raw','lm'}); +ylabel('fa'); + +t = 1:m; +figure +title('Accelerometer Calibration') +plot(t, r_raw, t, r_lm) +legend('Uncalibrated','Calibrated-LM') +xlabel('Measurement sampling number') +ylabel('Residual') + +function plot_data(datapoints, acc_acq) + fprintf('***Accelerometer data collected***��\n') + fprintf('***The collected data are averaged from the previous 100 data points***\n') + + figure + plot(1:length(datapoints), datapoints(1,:)) + hold on + plot(acc_acq, datapoints(4,acc_acq), '*') + legend('Accelerometer data(ax)','Feature point') + title('Accelerometer X-axis sampling') + hold off + figure + plot(1:length(datapoints), datapoints(2,:)) + hold on + plot(acc_acq, datapoints(5, acc_acq), '*') + legend('Accelerometer data(ay)', 'Feature point') + title('Accelerometer Y-axis sampling') + hold off + figure + plot(1:length(datapoints), datapoints(3,:)) + hold on + plot(acc_acq, datapoints(6,acc_acq), '*') + legend('Accelerometer data(az)', 'Feature point') + title('Accelerometer Z-axis sampling') + hold off +end diff --git a/e3/e3.1/lm.m b/e3/e3.1/lm.m new file mode 100644 index 0000000..ca318e4 --- /dev/null +++ b/e3/e3.1/lm.m @@ -0,0 +1,182 @@ +function p = lm(func, p, x, y_dat, dp, p_min, p_max) +%Function description: +%Input: +% func: Function name y_hat = func(x, p) +% p: Initialization value of the parameter to be estimated +% x: Original value +% y_dat: func(x, p)'s expected value, m-dimensional vector +% dp: Related to the solution of the Jocobian matrix. +% p_min: The minimum value of the parameter to be estimated, default is -10*abs(p) +% p_max: The maximum value of the parameter to be estimated, default is 10*abs(p) +%Output: +% p: Estimated parameter + + p = p(:); y_dat = y_dat(:); %Convert to column vector + Npar = length(p); % Number of parameters to be estimated + + if length(x) ~= length(y_dat) + disp('lm.m err: The length of x must be equal to the length of y_dat!'); + end + + %parameter + MaxIter = 200000*Npar; %The maximum number of iterations + epsilon_1 = 1e-6; %Gradient convergence tolerance of cost function + epsilon_2 = 1e-6; %Convergence tolerance of the parameters to be fitted + epsilon_4 = 1e-6; %Parameters in the LM algorithm, determining the transformation step size of the parameters + lambda_0 = 1e-5; %lambda initial parameter + + Fx_hst = []; + %If no parameters are specified, then the default parameters are used. + if nargin < 5, dp = 0.001; end + if nargin < 6, p_min = -100*abs(p); end + if nargin < 7, p_max = 100*abs(p); end + + p_min=p_min(:); p_max=p_max(:); + + if length(dp) == 1 + dp = dp*ones(Npar,1); + end + + stop = 0; + + [alpha, beta, delta_y] = lm_matx(func, x, p, y_dat, dp); + Fx_old = delta_y' * delta_y; + Fx_hst(1) = Fx_old; + if ( max(abs(beta)) < epsilon_1 ) + fprintf(' *** The initial estimate is close to optimal and the Fx derivative tends to zero. ***\n') + fprintf(' *** epsilon_1 = %e\n', epsilon_1); + fprintf('***Fx = %e\n', Fx_old); + stop = 1; + end + + %lambda initial value + lambda = lambda_0 * max(diag(alpha)); % Nielsen method + nu = 2; + + iteration = 0; + while ( ~stop && iteration <= MaxIter ) + + iteration = iteration + 1; + % update mode of the parameter change step size + delta_p = ( alpha + lambda*diag(diag(alpha)) ) \ beta; + + p_try = p + delta_p; % Update parameter + p_try = min(max(p_min,p_try), p_max); % Parameter clipping + + delta_y = y_dat - (feval(func, x, p_try))'; % Residual + Fx = delta_y' * delta_y; + Fx_hst(iteration+1) = Fx; + rho = (Fx_old - Fx) / ( delta_p' * (lambda * delta_p + beta) ); % Nielsen + + if ( rho > epsilon_4 ) % The approximation is good, the lamda is reduced, and the step size is close to the step size of the Gauss-Newton method. + p = p_try(:); + + [alpha, beta, delta_y] = lm_matx(func, x, p, y_dat, dp); + Fx = delta_y' * delta_y; + Fx_old = Fx; + + lambda = lambda*max( 1/3, 1-(2*rho-1)^3 ); nu = 2; + else %Poor approximation, using small steps + lambda = lambda * nu; nu = 2*nu; % Nielsen + end + %Determine if iteration can be ended + if ( max(abs(delta_p./p)) < epsilon_2 && iteration > 2 ) + fprintf(' **** The parameters to be sought tend to be stable during the iteration **** \n') + fprintf(' **** epsilon_2 = %e\n', epsilon_2); + fprintf('***The number of iterations is %e\n', iteration); + figure + plot(1:iteration+1, Fx_hst(1:iteration+1)) + title('Fx changes with the number of iterations') + xlabel('Number of iterations') + ylabel('Fx') + stop = 1; + end + if ( max(abs(beta)) < epsilon_1 && iteration > 2 ) + fprintf(' **** The first derivative of Fx tends to zero **** \n') + fprintf(' **** epsilon_1 = %e\n', epsilon_1); + fprintf('***Number of iterations��%e\n',iteration); + figure + plot(1:iteration+1,Fx_hst(1:iteration+1)) + title('Fx changes with the number of iterations') + xlabel('Number of iterations') + ylabel('Fx') + stop = 1; + end + if ( iteration == MaxIter ) + disp(' !! Reach the maximum number of iterations %e��not yet fitted successfully !!',MaxIter) + stop = 1; + end + end + +function dydp = lm_dydp(func, x ,p, y, dp) +%Function description: +% alculate the first derivative of func to p, the Jocobian matrix +%Input: +% func : y_hat = func(x,p) +% x: m-dimensional vector +% p: n-dimensional vector +% y = func(t,p),m-dimensional vector +% dp: The magnitude of the disturbance when deriving the number. Derivation method: +% dp(j)>0 f'(x)=(f(x,p+dp*p)-f(x,p-dp*p))/(2*dp*p) +% dp(j)<0 f'(x)=(f(x,p+dp*p)-f(x,p))/(dp*p) +% default:0.001; +%Output: +% dydp = Jacobian Matrix dydp(i,j)=dy(i)/dp(j) i=1:m; j=1:n + + m=length(y); + n=length(p); + + if nargin < 5 + dp = 0.001*ones(1, n); + end + + ps = p; dydp = zeros(m, n); del = zeros(n, 1); + + for j = 1:n + del(j) = dp(j) * p(j); + p(j) = ps(j) + del(j); + + if del(j) ~= 0 + y1 = feval(func, x, p); + if (dp(j) < 0) + dydp(:, j) = (y1 - y)./del(j); + else + p(j) = ps(j) - del(j); + dydp(:, j) = (y1 - feval(func, x, p)) ./ (2 .* del(j)); + end + end + p(j) = ps(j); + end + +function [alpha, beta, delta_y] = lm_matx(func, x, p, y_dat, dp) +%Function description: +% Calculate key data in the lm algorithm:alpha, beta�� +%Input: +% func: y_hat = func(x,p) +% x: m-dimensional vector +% p: n-dimensional vector +% y_dat��func(x,p)'s desired value,m-dimensional vector +% dp: The magnitude of the disturbance when deriving the number. Derivation method: +% dp(j)>0 f'(x)=(f(x,p+dp*p)-f(x,p-dp*p))/(2*dp*p) +% dp(j)<0 f'(x)=(f(x,p+dp*p)-f(x,p))/(dp*p) +% default:0.001; +%Output: +% alpha:J'J +% beta:J'delta_y +% delta_y:residual. + + Npar = length(p); + if nargin < 5 + dp = 0.001; + end + + alpha = zeros(Npar); + beta = zeros(Npar,1); + + y_hat = feval(func,x,p); + delta_y = y_dat - y_hat'; + + dydp = lm_dydp(func, x, p, y_hat, dp); + alpha = dydp'* dydp; %J'J + beta = dydp'* delta_y; %J'delta_y + diff --git a/e3/e3.1/px4_read_binary_file.m b/e3/e3.1/px4_read_binary_file.m new file mode 100644 index 0000000..cec614a --- /dev/null +++ b/e3/e3.1/px4_read_binary_file.m @@ -0,0 +1,61 @@ +%% Load the data into MATLAB from a binary log file +% Usage: >> [datapoints, numpoints] = readdata('datafile.log') +% Header information format: +% String "MWLOGV##" +% Time/Date 4 bytes (time()) +% Number of Signals per record Logged 1 bytes (256 max) +% Data Type of Signals Logged 1 bytes (1-10) +% Number of bytes per record 2 (65535 max) +% Plot Data Example: plot([1:numpoints], datapoints(1,:), [1:numpoints], datapoints(2,:)) +% MathWorks Pilot Engineering 2015 +% Steve Kuznicki +function [datapts, numpts] = readdata(dataFile) +%% +datapts = 0; +numpts = 0; + +if nargin == 0 + dataFile = 'data.bin'; +end + +fid = fopen(dataFile, 'r'); +% load the header information +hdrToken = fread(fid, 8, 'char'); +if strncmp(char(hdrToken),'MWLOGV',6) == true + logTime = uint32(fread(fid, 1, 'uint32')); + numflds = double(fread(fid, 1, 'uint8')); + typefld = uint8(fread(fid, 1, 'uint8')); + recSize = uint16(fread(fid, 1, 'uint16')); + fieldTypeStr = get_elem_type(typefld); + datapts = fread(fid, double([numflds, Inf]), fieldTypeStr); + fclose(fid); + numpts = size(datapts,2); +end + +end + +%% get the element type string +function [dtypeStr] = get_elem_type(dtype) + switch(dtype) + case 1 + dtypeStr = 'double'; + case 2 + dtypeStr = 'single'; + case 3 + dtypeStr = 'int32'; + case 4 + dtypeStr = 'uint32'; + case 5 + dtypeStr = 'int16'; + case 6 + dtypeStr = 'uint16'; + case 7 + dtypeStr = 'int8'; + case 8 + dtypeStr = 'uint8'; + case 9 + dtypeStr = 'logical'; + case 10 + dtypeStr = 'embedded.fi'; + end +end \ No newline at end of file diff --git a/e3/e3.1/rawdataFile/e_acc1_A.bin b/e3/e3.1/rawdataFile/e_acc1_A.bin new file mode 100644 index 0000000..807ba6e Binary files /dev/null and b/e3/e3.1/rawdataFile/e_acc1_A.bin differ diff --git a/e3/e3.2/AccRaw.mat b/e3/e3.2/AccRaw.mat new file mode 100644 index 0000000..ced2a1a Binary files /dev/null and b/e3/e3.2/AccRaw.mat differ diff --git a/e3/e3.2/accdata.mat b/e3/e3.2/accdata.mat new file mode 100644 index 0000000..45fbdcb Binary files /dev/null and b/e3/e3.2/accdata.mat differ diff --git a/e3/e3.2/calFunc.m b/e3/e3.2/calFunc.m new file mode 100644 index 0000000..fd5c639 --- /dev/null +++ b/e3/e3.2/calFunc.m @@ -0,0 +1,23 @@ +function Y = calFunc(x,p) +%Function description: +% Accelerometer error model, Y(i) = norm(Ka*(x(:,i) - ba)) +%Input: +% x:Accelerometer original value, dimension 3*m +% p:Model parameter, dimension 6*1 +%Output: +% Y:Corrected gravitational acceleration value. +kx = p(1); +ky = p(2); +kz = p(3); +bx = p(4); +by = p(5); +bz = p(6); + +Ka=[kx 0 0;0 ky 0;0 0 kz]; +ba=[bx by bz]'; +m = length(x); +Y=zeros(1,m); +for i=1:m + Y(i)=norm(Ka*(x(1:3,i)+ba)); +end +end \ No newline at end of file diff --git a/e3/e3.2/calLM.m b/e3/e3.2/calLM.m new file mode 100644 index 0000000..7006532 --- /dev/null +++ b/e3/e3.2/calLM.m @@ -0,0 +1,48 @@ +%File Description: +% According to the accelerometer error model, the accelerometer error model parameters are calculated using the lm optimization algorithm. +close all +clc +clear + +load AccRaw +%@ g = 9.8; +m = length(AccRaw); + +y_dat = g*ones(m,1); %Expected gravitational acceleration value +p0 = [1 1 1 0 0 0]'; +p_init = [1.0 1.0 1.0 0.1 0.1 0.1]'; %Initial value of the parameter to be estimated + + +y_raw = calFunc(AccRaw, p0); %2-norm of uncalibrated accelerometer value +y_raw = y_raw(:); +r_raw = y_dat - y_raw; +p_fit = lm('calFunc', p_init, AccRaw, y_dat); +y_lm = calFunc(AccRaw,p_fit); %2-norm of calibrated accelerometer value +y_lm = y_lm(:); +r_lm = y_dat - y_lm; + +kx = p_fit(1); +ky = p_fit(2); +kz = p_fit(3); +bx = p_fit(4); +by = p_fit(5); +bz = p_fit(6); + +Ka1=[kx 0 0;0 ky 0;0 0 kz] +ba1=[bx by bz]' +save('calP1','Ka1','ba1') + + +figure +bar([r_raw'*r_raw, r_lm'*r_lm]) +grid on; +set(gca,'XTickLabel', {'raw','lm'}); +ylabel('fa'); + +t=1:m; +figure +title('Accelerometer Calibration') +plot(t, r_raw, t, r_lm) +legend('Uncalibrated', 'Calibrated-LM') +xlabel('Measurement sampling number') +ylabel('Residual') diff --git a/e3/e3.2/differentG_effect.m b/e3/e3.2/differentG_effect.m new file mode 100644 index 0000000..0574ef3 --- /dev/null +++ b/e3/e3.2/differentG_effect.m @@ -0,0 +1,29 @@ +close all +clear +load accdata.mat %Raw accelerometer data collected +%% Load calibration parameters +%@ load calP1.mat +%@ load ../e3.1/calP9_8.mat + +acc_1 = Ka1*(acc - ba1); %Calibrated acceleration value +acc_9_8 = Ka9_8*(acc - ba9_8); %Calibrated acceleration value + +n = length(acc); +roll_1 = zeros(1, 100); +pitch_1 = zeros(1, 100); +roll_9_8 = zeros(1, 100); +pitch_9_8 = zeros(1, 100); +for k = 1:100 + g = normest(acc_1(:, k)); + roll_1(k) = asin(acc_1(1, k)./g); + pitch_1(k) = -asin(acc_1(2,k)./(g.*cos(roll_1(k)))); + g = normest(acc_9_8(:, k)); + roll_9_8(k) = asin(acc_9_8(1, k)./g); + pitch_9_8(k) = -asin(acc_9_8(2, k)./(g.*cos(roll_9_8(k)))); +end +t = 1:100; +figure(1) +plot(t, pitch_9_8, '*-', t, pitch_1, '^-'); +title('pitch') +legend('g=9.8', 'g=1.0') +xlabel('Number of samples');ylabel('angle/rad/s'); diff --git a/e3/e3.2/lm.m b/e3/e3.2/lm.m new file mode 100644 index 0000000..ca318e4 --- /dev/null +++ b/e3/e3.2/lm.m @@ -0,0 +1,182 @@ +function p = lm(func, p, x, y_dat, dp, p_min, p_max) +%Function description: +%Input: +% func: Function name y_hat = func(x, p) +% p: Initialization value of the parameter to be estimated +% x: Original value +% y_dat: func(x, p)'s expected value, m-dimensional vector +% dp: Related to the solution of the Jocobian matrix. +% p_min: The minimum value of the parameter to be estimated, default is -10*abs(p) +% p_max: The maximum value of the parameter to be estimated, default is 10*abs(p) +%Output: +% p: Estimated parameter + + p = p(:); y_dat = y_dat(:); %Convert to column vector + Npar = length(p); % Number of parameters to be estimated + + if length(x) ~= length(y_dat) + disp('lm.m err: The length of x must be equal to the length of y_dat!'); + end + + %parameter + MaxIter = 200000*Npar; %The maximum number of iterations + epsilon_1 = 1e-6; %Gradient convergence tolerance of cost function + epsilon_2 = 1e-6; %Convergence tolerance of the parameters to be fitted + epsilon_4 = 1e-6; %Parameters in the LM algorithm, determining the transformation step size of the parameters + lambda_0 = 1e-5; %lambda initial parameter + + Fx_hst = []; + %If no parameters are specified, then the default parameters are used. + if nargin < 5, dp = 0.001; end + if nargin < 6, p_min = -100*abs(p); end + if nargin < 7, p_max = 100*abs(p); end + + p_min=p_min(:); p_max=p_max(:); + + if length(dp) == 1 + dp = dp*ones(Npar,1); + end + + stop = 0; + + [alpha, beta, delta_y] = lm_matx(func, x, p, y_dat, dp); + Fx_old = delta_y' * delta_y; + Fx_hst(1) = Fx_old; + if ( max(abs(beta)) < epsilon_1 ) + fprintf(' *** The initial estimate is close to optimal and the Fx derivative tends to zero. ***\n') + fprintf(' *** epsilon_1 = %e\n', epsilon_1); + fprintf('***Fx = %e\n', Fx_old); + stop = 1; + end + + %lambda initial value + lambda = lambda_0 * max(diag(alpha)); % Nielsen method + nu = 2; + + iteration = 0; + while ( ~stop && iteration <= MaxIter ) + + iteration = iteration + 1; + % update mode of the parameter change step size + delta_p = ( alpha + lambda*diag(diag(alpha)) ) \ beta; + + p_try = p + delta_p; % Update parameter + p_try = min(max(p_min,p_try), p_max); % Parameter clipping + + delta_y = y_dat - (feval(func, x, p_try))'; % Residual + Fx = delta_y' * delta_y; + Fx_hst(iteration+1) = Fx; + rho = (Fx_old - Fx) / ( delta_p' * (lambda * delta_p + beta) ); % Nielsen + + if ( rho > epsilon_4 ) % The approximation is good, the lamda is reduced, and the step size is close to the step size of the Gauss-Newton method. + p = p_try(:); + + [alpha, beta, delta_y] = lm_matx(func, x, p, y_dat, dp); + Fx = delta_y' * delta_y; + Fx_old = Fx; + + lambda = lambda*max( 1/3, 1-(2*rho-1)^3 ); nu = 2; + else %Poor approximation, using small steps + lambda = lambda * nu; nu = 2*nu; % Nielsen + end + %Determine if iteration can be ended + if ( max(abs(delta_p./p)) < epsilon_2 && iteration > 2 ) + fprintf(' **** The parameters to be sought tend to be stable during the iteration **** \n') + fprintf(' **** epsilon_2 = %e\n', epsilon_2); + fprintf('***The number of iterations is %e\n', iteration); + figure + plot(1:iteration+1, Fx_hst(1:iteration+1)) + title('Fx changes with the number of iterations') + xlabel('Number of iterations') + ylabel('Fx') + stop = 1; + end + if ( max(abs(beta)) < epsilon_1 && iteration > 2 ) + fprintf(' **** The first derivative of Fx tends to zero **** \n') + fprintf(' **** epsilon_1 = %e\n', epsilon_1); + fprintf('***Number of iterations��%e\n',iteration); + figure + plot(1:iteration+1,Fx_hst(1:iteration+1)) + title('Fx changes with the number of iterations') + xlabel('Number of iterations') + ylabel('Fx') + stop = 1; + end + if ( iteration == MaxIter ) + disp(' !! Reach the maximum number of iterations %e��not yet fitted successfully !!',MaxIter) + stop = 1; + end + end + +function dydp = lm_dydp(func, x ,p, y, dp) +%Function description: +% alculate the first derivative of func to p, the Jocobian matrix +%Input: +% func : y_hat = func(x,p) +% x: m-dimensional vector +% p: n-dimensional vector +% y = func(t,p),m-dimensional vector +% dp: The magnitude of the disturbance when deriving the number. Derivation method: +% dp(j)>0 f'(x)=(f(x,p+dp*p)-f(x,p-dp*p))/(2*dp*p) +% dp(j)<0 f'(x)=(f(x,p+dp*p)-f(x,p))/(dp*p) +% default:0.001; +%Output: +% dydp = Jacobian Matrix dydp(i,j)=dy(i)/dp(j) i=1:m; j=1:n + + m=length(y); + n=length(p); + + if nargin < 5 + dp = 0.001*ones(1, n); + end + + ps = p; dydp = zeros(m, n); del = zeros(n, 1); + + for j = 1:n + del(j) = dp(j) * p(j); + p(j) = ps(j) + del(j); + + if del(j) ~= 0 + y1 = feval(func, x, p); + if (dp(j) < 0) + dydp(:, j) = (y1 - y)./del(j); + else + p(j) = ps(j) - del(j); + dydp(:, j) = (y1 - feval(func, x, p)) ./ (2 .* del(j)); + end + end + p(j) = ps(j); + end + +function [alpha, beta, delta_y] = lm_matx(func, x, p, y_dat, dp) +%Function description: +% Calculate key data in the lm algorithm:alpha, beta�� +%Input: +% func: y_hat = func(x,p) +% x: m-dimensional vector +% p: n-dimensional vector +% y_dat��func(x,p)'s desired value,m-dimensional vector +% dp: The magnitude of the disturbance when deriving the number. Derivation method: +% dp(j)>0 f'(x)=(f(x,p+dp*p)-f(x,p-dp*p))/(2*dp*p) +% dp(j)<0 f'(x)=(f(x,p+dp*p)-f(x,p))/(dp*p) +% default:0.001; +%Output: +% alpha:J'J +% beta:J'delta_y +% delta_y:residual. + + Npar = length(p); + if nargin < 5 + dp = 0.001; + end + + alpha = zeros(Npar); + beta = zeros(Npar,1); + + y_hat = feval(func,x,p); + delta_y = y_dat - y_hat'; + + dydp = lm_dydp(func, x, p, y_hat, dp); + alpha = dydp'* dydp; %J'J + beta = dydp'* delta_y; %J'delta_y + diff --git a/e3/e3.3/MagRaw.mat b/e3/e3.3/MagRaw.mat new file mode 100644 index 0000000..0038018 Binary files /dev/null and b/e3/e3.3/MagRaw.mat differ diff --git a/e4/README.txt b/e4/README.txt new file mode 100644 index 0000000..fb69f56 --- /dev/null +++ b/e4/README.txt @@ -0,0 +1,9 @@ + As for basic experiment, if you don't have hardware, you can use the 'e4\e4.1\logdata.mat' data directly, +and the corresponding filter code is 'e4\e4.1\Attitude_estimator0_fly.m'; if you have hardware, you will get +a file similar to 'e4\e4.1\e4_A.bin', and the corresponding filter code is 'e4\e4.1\Attitude_estimator0.m'. + + The data in 'e4\e4.1\e4_A.bin' and 'e4\e4.1\logdata.mat' are obtained by the 'e4\e4.1\log_data.slx' and +they both include three-axis gyroscope data, three-axis acceleration data and the attitude estimated by self-contained +filter in PX4 software.The file 'e4\e4.1\e4_A.bin' stores the data directly from Pixhawk autopilot rotating by hands and +the other file 'e4\e4.1\logdata.mat' stores the data from a practical flight of a quadcopter. + \ No newline at end of file diff --git a/e4/e4.1/Attitude_estimator0.m b/e4/e4.1/Attitude_estimator0.m new file mode 100644 index 0000000..8fd1f56 --- /dev/null +++ b/e4/e4.1/Attitude_estimator0.m @@ -0,0 +1,66 @@ +clear; + +%@ [datapoints, numpoints] = px4_read_binary_file('e4_A.bin'); +ax = datapoints(1, :); %m/s2 +ay = datapoints(2, :); +az = datapoints(3, :); +gx = datapoints(4, :); %rad/s +gy = datapoints(5, :); +gz = datapoints(6, :); +phi_px4 = datapoints(7, :); %Roll calculated in PX4, unit: rad +theta_px4 = datapoints(8, :); %Pitch calculated in PX4, unit: rad +timestamp=datapoints(9, :); %us + +n = length(ax); %Number of data collected +Ts = zeros(1,n); %time interval +Ts(1) = 0.004; + +for k = 1 : n-1 + Ts(k+1) = (timestamp(k + 1) - timestamp(k))*0.000001; +end + +theta_am = zeros(1, n); %roll calculated from acceleration, unit: rad +phi_am = zeros(1, n); %pitch calculated from acceleration, unit: rad +theta_gm = zeros(1, n); %roll from the gyroscope, unit: rad +phi_gm = zeros(1, n); %pitch from the gyroscope, unit: rad +theta_cf = zeros(1, n); %roll obtained from complementary filtering, unit: rad +phi_cf = zeros(1, n); %pitch obtained from complementary filtering, unit: rad +tao = 0.1; +for k = 2 : n + %Calculate Euler angles using accelerometer data + %@ + + %Calculate Euler angles using gyroscope data + %@ + + %Complementary filtering + %@ + +end + +t = timestamp*0.000001; +rad2deg = 180/pi; +figure(1) +subplot(2, 1, 1) +plot(t, theta_gm*rad2deg, 'g', t, theta_am*rad2deg, 'b', t, theta_cf*rad2deg, 'r') +legend('gyro', 'acc', 'cf'); +ylabel('theta(deg)') +title('pitch') +subplot(2, 1, 2) +plot(t, theta_cf*rad2deg, 'r', t, theta_px4*rad2deg, 'k') +legend('cf', 'px4'); +xlabel('t(s)') +ylabel('theta(deg)') + + +figure(2) +subplot(2, 1, 1) +plot(t, phi_gm*rad2deg, 'g', t, phi_am*rad2deg, 'b', t, phi_cf*rad2deg, 'r') +legend('gyro', 'acc', 'cf'); +ylabel('theta(deg)') +title('roll') +subplot(2, 1, 2) +plot(t, phi_cf*rad2deg, 'r', t, phi_px4*rad2deg, 'k') +legend('cf', 'px4'); +xlabel('t(s)') +ylabel('theta(deg)') diff --git a/e4/e4.1/Attitude_estimator0_fly.m b/e4/e4.1/Attitude_estimator0_fly.m new file mode 100644 index 0000000..442289a --- /dev/null +++ b/e4/e4.1/Attitude_estimator0_fly.m @@ -0,0 +1,55 @@ +clear; +load logdata +n = length(ax); %Number of data collected +Ts = zeros(1,n); %time interval +Ts(1) = 0.004; + +for k = 1:n-1 + Ts(k+1) = (timestamp(k+1) - timestamp(k))*0.000001; +end + +theta_am = zeros(1, n); %roll calculated from acceleration, unit: rad +phi_am = zeros(1, n); %pitch calculated from acceleration, unit: rad +theta_gm = zeros(1, n); %roll calculated from the gyroscope, unit: rad +phi_gm = zeros(1, n); %pitch calculated from the gyroscope, unit: rad +theta_cf = zeros(1, n); %roll calculated from complementary filtering, unit: rad +phi_cf = zeros(1, n); %pitch calculated from complementary filtering, unit: rad +tao = 0.1; +for k = 2:n + %Calculate Euler angles using accelerometer data + %@ + + %Calculate Euler angles using gyroscope data + %@ + + %Complementary filtering + %@ + +end + +t = timestamp*0.000001; +rad2deg = 180/pi; +figure(1) +subplot(2, 1, 1) +plot(t, theta_gm*rad2deg, 'g', t, theta_am*rad2deg, 'b', t, theta_cf*rad2deg, 'r') +legend('gyro', 'acc', 'cf'); +ylabel('theta(deg)') +title('pitch') +subplot(2, 1, 2) +plot(t, theta_cf*rad2deg, 'r', t, theta_px4*rad2deg, 'k') +legend('cf', 'px4'); +xlabel('t(s)') +ylabel('theta(deg)') + + +figure(2) +subplot(2, 1, 1) +plot(t, phi_gm*rad2deg, 'g', t, phi_am*rad2deg, 'b', t, phi_cf*rad2deg, 'r') +legend('gyro', 'acc', 'cf'); +ylabel('theta(deg)') +title('roll') +subplot(2, 1, 2) +plot(t, phi_cf*rad2deg, 'r', t, phi_px4*rad2deg, 'k') +legend('cf', 'px4'); +xlabel('t(s)') +ylabel('theta(deg)') \ No newline at end of file diff --git a/e4/e4.1/log_data.slx b/e4/e4.1/log_data.slx new file mode 100644 index 0000000..9e35053 Binary files /dev/null and b/e4/e4.1/log_data.slx differ diff --git a/e4/e4.1/logdata.mat b/e4/e4.1/logdata.mat new file mode 100644 index 0000000..f364494 Binary files /dev/null and b/e4/e4.1/logdata.mat differ diff --git a/e4/e4.1/px4_read_binary_file.m b/e4/e4.1/px4_read_binary_file.m new file mode 100644 index 0000000..cec614a --- /dev/null +++ b/e4/e4.1/px4_read_binary_file.m @@ -0,0 +1,61 @@ +%% Load the data into MATLAB from a binary log file +% Usage: >> [datapoints, numpoints] = readdata('datafile.log') +% Header information format: +% String "MWLOGV##" +% Time/Date 4 bytes (time()) +% Number of Signals per record Logged 1 bytes (256 max) +% Data Type of Signals Logged 1 bytes (1-10) +% Number of bytes per record 2 (65535 max) +% Plot Data Example: plot([1:numpoints], datapoints(1,:), [1:numpoints], datapoints(2,:)) +% MathWorks Pilot Engineering 2015 +% Steve Kuznicki +function [datapts, numpts] = readdata(dataFile) +%% +datapts = 0; +numpts = 0; + +if nargin == 0 + dataFile = 'data.bin'; +end + +fid = fopen(dataFile, 'r'); +% load the header information +hdrToken = fread(fid, 8, 'char'); +if strncmp(char(hdrToken),'MWLOGV',6) == true + logTime = uint32(fread(fid, 1, 'uint32')); + numflds = double(fread(fid, 1, 'uint8')); + typefld = uint8(fread(fid, 1, 'uint8')); + recSize = uint16(fread(fid, 1, 'uint16')); + fieldTypeStr = get_elem_type(typefld); + datapts = fread(fid, double([numflds, Inf]), fieldTypeStr); + fclose(fid); + numpts = size(datapts,2); +end + +end + +%% get the element type string +function [dtypeStr] = get_elem_type(dtype) + switch(dtype) + case 1 + dtypeStr = 'double'; + case 2 + dtypeStr = 'single'; + case 3 + dtypeStr = 'int32'; + case 4 + dtypeStr = 'uint32'; + case 5 + dtypeStr = 'int16'; + case 6 + dtypeStr = 'uint16'; + case 7 + dtypeStr = 'int8'; + case 8 + dtypeStr = 'uint8'; + case 9 + dtypeStr = 'logical'; + case 10 + dtypeStr = 'embedded.fi'; + end +end \ No newline at end of file diff --git a/e4/e4.2/Attitude_cf_tao.m b/e4/e4.2/Attitude_cf_tao.m new file mode 100644 index 0000000..b824861 --- /dev/null +++ b/e4/e4.2/Attitude_cf_tao.m @@ -0,0 +1,26 @@ +%The influence of the parameter tao on the filtering effect +clear; +load logdata +n = length(ax); %Number of data collected +Ts = zeros(1,n); %time interval +Ts(1) = 0.004; + +for k =1:n-1 + Ts(k+1) = (timestamp(k + 1) - timestamp(k))*0.000001; +end + +theta_cf = zeros(3, n); %roll calculated from complementary filtering, unit: rad +phi_cf = zeros(3, n); %pitch calculated from complementary filtering, unit: rad +tao = 0.001; +%@ + + +t = timestamp*0.000001; +rad2deg = 180/pi; +figure(1) +plot(t, theta_cf(1, :)*rad2deg, 'g', t, theta_cf(2, :)*rad2deg, 'b', t, theta_cf(3, :)*rad2deg, 'r') +legend('0.01', '0.1', '1'); +xlabel('t(s)') +ylabel('theta(deg)') +title('Parameter tao effect') + diff --git a/e4/e4.2/logdata.mat b/e4/e4.2/logdata.mat new file mode 100644 index 0000000..7f48769 Binary files /dev/null and b/e4/e4.2/logdata.mat differ diff --git a/e4/e4.3/HardInloop/ekf_cf.slx b/e4/e4.3/HardInloop/ekf_cf.slx new file mode 100644 index 0000000..865cd24 Binary files /dev/null and b/e4/e4.3/HardInloop/ekf_cf.slx differ diff --git a/e4/e4.3/HardInloop/px4_read_binary_file.m b/e4/e4.3/HardInloop/px4_read_binary_file.m new file mode 100644 index 0000000..cec614a --- /dev/null +++ b/e4/e4.3/HardInloop/px4_read_binary_file.m @@ -0,0 +1,61 @@ +%% Load the data into MATLAB from a binary log file +% Usage: >> [datapoints, numpoints] = readdata('datafile.log') +% Header information format: +% String "MWLOGV##" +% Time/Date 4 bytes (time()) +% Number of Signals per record Logged 1 bytes (256 max) +% Data Type of Signals Logged 1 bytes (1-10) +% Number of bytes per record 2 (65535 max) +% Plot Data Example: plot([1:numpoints], datapoints(1,:), [1:numpoints], datapoints(2,:)) +% MathWorks Pilot Engineering 2015 +% Steve Kuznicki +function [datapts, numpts] = readdata(dataFile) +%% +datapts = 0; +numpts = 0; + +if nargin == 0 + dataFile = 'data.bin'; +end + +fid = fopen(dataFile, 'r'); +% load the header information +hdrToken = fread(fid, 8, 'char'); +if strncmp(char(hdrToken),'MWLOGV',6) == true + logTime = uint32(fread(fid, 1, 'uint32')); + numflds = double(fread(fid, 1, 'uint8')); + typefld = uint8(fread(fid, 1, 'uint8')); + recSize = uint16(fread(fid, 1, 'uint16')); + fieldTypeStr = get_elem_type(typefld); + datapts = fread(fid, double([numflds, Inf]), fieldTypeStr); + fclose(fid); + numpts = size(datapts,2); +end + +end + +%% get the element type string +function [dtypeStr] = get_elem_type(dtype) + switch(dtype) + case 1 + dtypeStr = 'double'; + case 2 + dtypeStr = 'single'; + case 3 + dtypeStr = 'int32'; + case 4 + dtypeStr = 'uint32'; + case 5 + dtypeStr = 'int16'; + case 6 + dtypeStr = 'uint16'; + case 7 + dtypeStr = 'int8'; + case 8 + dtypeStr = 'uint8'; + case 9 + dtypeStr = 'logical'; + case 10 + dtypeStr = 'embedded.fi'; + end +end \ No newline at end of file diff --git a/e4/e4.3/logdata.mat b/e4/e4.3/logdata.mat new file mode 100644 index 0000000..7f48769 Binary files /dev/null and b/e4/e4.3/logdata.mat differ diff --git a/e5/README.txt b/e5/README.txt new file mode 100644 index 0000000..fcabd25 --- /dev/null +++ b/e5/README.txt @@ -0,0 +1,22 @@ + You can do basic experiment using the models in 'e5\e5.1'. + 'e5\e5.1\Sim' is used for Simulink simulation of a quadcopter and analyze the function of control allocation. + 'e5\e5.1\tune' is used for analyzing the performance of the control system. + 'e5\e5.1\HIL' is used for performing the HIL simulation. + + The Simulink model in 'e5\e5.2' is similar to that in 'e5\e5.1\tune', which is uesd for adjusting and analyzing +the performance of the control system. + + 'e5\e5.3' contains the attitude control model we design in analysis experiment. + + 'e5\e5.4' contains the file for flight test and flight data analysis.Before you open the file +'e4\e4.4\AttitudeControl_FLY.slx', you'd better add custom logger data as follows: + (1) Create customized message."costom_attctrl_e5.msg" is the customized message, which should be put in "Firmware/msg/"; + (2) Modify "Firmware/msg/CmakeLists.txt". Add the follow words in the 'set()'': + costom_attctrl_e5.msg.msg + (3) Modify "Firmware/src/modules/logger/logger.cpp". Add the follow words in add_common_topics(): + add_topic( "costom_attctrl_e5", 4); + Where "costom_attctrl_e5" is the name of message, "4" is logging cycle. That is, the system records the + data with a sampling period of 4ms. + All the modified files are put in 'e5\e5.4\PSPfile' as an example. + + \ No newline at end of file diff --git a/e5/e5.1/HIL/AttitudeControl_HIL.slx b/e5/e5.1/HIL/AttitudeControl_HIL.slx new file mode 100644 index 0000000..66b8c58 Binary files /dev/null and b/e5/e5.1/HIL/AttitudeControl_HIL.slx differ diff --git a/e5/e5.1/HIL/Init_control.m b/e5/e5.1/HIL/Init_control.m new file mode 100644 index 0000000..35da171 --- /dev/null +++ b/e5/e5.1/HIL/Init_control.m @@ -0,0 +1,41 @@ +%%% AttitudeControl_HIL +clear +path('./icon/',path); + +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; + +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE = 6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE = 6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; + +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; +%integral saturation +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +%Throttle amplitude +MAX_MAN_THR = 0.9; +MIN_MAN_THR = 0.05; +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 15; +MAX_CONTROL_ANGLE_PITCH = 15; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%% run simulink model +AttitudeControl_HIL \ No newline at end of file diff --git a/e5/e5.1/HIL/icon/F450.png b/e5/e5.1/HIL/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e5/e5.1/HIL/icon/F450.png differ diff --git a/e5/e5.1/HIL/icon/FlightGear.png b/e5/e5.1/HIL/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e5/e5.1/HIL/icon/FlightGear.png differ diff --git a/e5/e5.1/HIL/icon/pixhawk.png b/e5/e5.1/HIL/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e5/e5.1/HIL/icon/pixhawk.png differ diff --git a/e5/e5.1/Sim/AttitudeControl_Sim.slx b/e5/e5.1/Sim/AttitudeControl_Sim.slx new file mode 100644 index 0000000..edfbc97 Binary files /dev/null and b/e5/e5.1/Sim/AttitudeControl_Sim.slx differ diff --git a/e5/e5.1/Sim/FlightGear-Start.bat b/e5/e5.1/Sim/FlightGear-Start.bat new file mode 100644 index 0000000..25175da --- /dev/null +++ b/e5/e5.1/Sim/FlightGear-Start.bat @@ -0,0 +1,5 @@ +C: +cd C:\Program Files\FlightGear 2016.1.2 + +SET FG_ROOT=C:\Program Files\FlightGear 2016.1.2\data +.\\bin\fgfs --aircraft=F450 --fdm=null --native-fdm=socket,in,30,127.0.0.1,5502,udp --native-ctrls=socket,out,30,127.0.0.1,5505,udp --fog-fastest --disable-clouds --start-date-lat=2017:06:01:21:00:00 --disable-sound --in-air --disable-freeze --airport=KSF0 --runway=10L --altitude=0 --heading=0 --offset-distance=0 --offset-azimuth=0 --timeofday=noon diff --git a/e5/e5.1/Sim/Init_control.m b/e5/e5.1/Sim/Init_control.m new file mode 100644 index 0000000..276d5f4 --- /dev/null +++ b/e5/e5.1/Sim/Init_control.m @@ -0,0 +1,46 @@ +%%% AttitudeControl_Sim +clear +path('./icon/',path); +%Run the model initialization file icon/init.m +Init; + +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; + +%% Initial condition +ModelInit_PosE = [0, 0, 0]; +ModelInit_VelB = [0, 0, 0]; +ModelInit_AngEuler = [0, 0, 0]; +ModelInit_RateB = [0, 0, 0]; +ModelInit_Rads = 0; +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE = 6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE = 6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; + +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; +%integral saturation +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 15; +MAX_CONTROL_ANGLE_PITCH = 15; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%% run simulink model +AttitudeControl_Sim \ No newline at end of file diff --git a/e5/e5.1/Sim/icon/F450.png b/e5/e5.1/Sim/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e5/e5.1/Sim/icon/F450.png differ diff --git a/e5/e5.1/Sim/icon/FlightGear.png b/e5/e5.1/Sim/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e5/e5.1/Sim/icon/FlightGear.png differ diff --git a/e5/e5.1/Sim/icon/Init.m b/e5/e5.1/Sim/icon/Init.m new file mode 100644 index 0000000..a6c5799 --- /dev/null +++ b/e5/e5.1/Sim/icon/Init.m @@ -0,0 +1,39 @@ +%Initial condition +ModelInit_PosE = [0, 0, 0]; %Initial position +ModelInit_VelB = [0, 0, 0]; %Initial velocity +ModelInit_AngEuler = [0, 0, 0]; %Initial Euler angle +ModelInit_RateB = [0, 0, 0]; %Initial angular velocity +ModelInit_Rads = 0; %Initial motor speed(rad/s) + +%UAV model parameter +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx, 0, 0;... + 0, ModelParam_uavJyy, 0;... + 0, 0, ModelParam_uavJzz]; +ModelParam_uavType = int8(3); %X-type quadrotor��refer to "SupportedVehicleTypes.pdf" for specific definitions +ModelParam_uavMotNumbs = int8(4); %Number of motors +ModelParam_uavR = 0.225; %Body radius(m) +ModelParam_uavCd = 0.055; %Damping coefficient(N/(m/s)^2) +ModelParam_uavCCm = [0.0035 0.0039 0.0034]; %Damping moment coefficient vector(N/(m/s)^2) + +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb = -141.4; %Motor speed-throttle curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) +ModelParam_motorMinThr = 0.05; %Motor throttle dead zone(kg.m^2) +%M=Cm*w^2 +ModelParam_rotorCm = 1.779e-07; %Rotor torque coefficient(kg.m^2) +%T=Ct**w^2 +ModelParam_rotorCt = 1.105e-05; %Rotor thrust coefficient(kg.m^2) + +%Environment Parameter +ModelParam_envGravityAcc = 9.8; %Gravity acceleration(m/s^2) +ModelParam_envLongitude = 116.259368300000; +ModelParam_envLatitude = 40.1540302; +ModelParam_GPSLatLong = [ModelParam_envLatitude ModelParam_envLongitude]; %Latitude and longitude +ModelParam_envAltitude = -41.5260009765625; %Reference height, down is positive +ModelParam_BusSampleRate = 0.001; %Model sampling rate \ No newline at end of file diff --git a/e5/e5.1/Sim/icon/SupportedVehicleTypes.pdf b/e5/e5.1/Sim/icon/SupportedVehicleTypes.pdf new file mode 100644 index 0000000..594b76a Binary files /dev/null and b/e5/e5.1/Sim/icon/SupportedVehicleTypes.pdf differ diff --git a/e5/e5.1/Sim/icon/pixhawk.png b/e5/e5.1/Sim/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e5/e5.1/Sim/icon/pixhawk.png differ diff --git a/e5/e5.1/tune/AttitudeControl_tune.slx b/e5/e5.1/tune/AttitudeControl_tune.slx new file mode 100644 index 0000000..874a01e Binary files /dev/null and b/e5/e5.1/tune/AttitudeControl_tune.slx differ diff --git a/e5/e5.1/tune/Init_control.m b/e5/e5.1/tune/Init_control.m new file mode 100644 index 0000000..f36767b --- /dev/null +++ b/e5/e5.1/tune/Init_control.m @@ -0,0 +1,46 @@ +%%% AttitudeControl_tune +clear +path('./icon/',path); +%Run the model initialization file icon/init.m +Init; + +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; + +%% Initial condition +ModelInit_PosE = [0, 0, -100]; +ModelInit_VelB = [0, 0, 0]; +ModelInit_AngEuler = [0, 0, 0]; +ModelInit_RateB = [0, 0, 0]; +ModelInit_Rads = 557.142; +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE = 6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE = 6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; + +Kp_YAW_AngleRate = 0.3; +Ki_YAW_AngleRate = 0.1; +Kd_YAW_AngleRate = 0.00; +%integral saturation +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%% run simulink model +AttitudeControl_tune \ No newline at end of file diff --git a/e5/e5.1/tune/icon/F450.png b/e5/e5.1/tune/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e5/e5.1/tune/icon/F450.png differ diff --git a/e5/e5.1/tune/icon/FlightGear.png b/e5/e5.1/tune/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e5/e5.1/tune/icon/FlightGear.png differ diff --git a/e5/e5.1/tune/icon/Init.m b/e5/e5.1/tune/icon/Init.m new file mode 100644 index 0000000..a6c5799 --- /dev/null +++ b/e5/e5.1/tune/icon/Init.m @@ -0,0 +1,39 @@ +%Initial condition +ModelInit_PosE = [0, 0, 0]; %Initial position +ModelInit_VelB = [0, 0, 0]; %Initial velocity +ModelInit_AngEuler = [0, 0, 0]; %Initial Euler angle +ModelInit_RateB = [0, 0, 0]; %Initial angular velocity +ModelInit_Rads = 0; %Initial motor speed(rad/s) + +%UAV model parameter +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx, 0, 0;... + 0, ModelParam_uavJyy, 0;... + 0, 0, ModelParam_uavJzz]; +ModelParam_uavType = int8(3); %X-type quadrotor��refer to "SupportedVehicleTypes.pdf" for specific definitions +ModelParam_uavMotNumbs = int8(4); %Number of motors +ModelParam_uavR = 0.225; %Body radius(m) +ModelParam_uavCd = 0.055; %Damping coefficient(N/(m/s)^2) +ModelParam_uavCCm = [0.0035 0.0039 0.0034]; %Damping moment coefficient vector(N/(m/s)^2) + +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb = -141.4; %Motor speed-throttle curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) +ModelParam_motorMinThr = 0.05; %Motor throttle dead zone(kg.m^2) +%M=Cm*w^2 +ModelParam_rotorCm = 1.779e-07; %Rotor torque coefficient(kg.m^2) +%T=Ct**w^2 +ModelParam_rotorCt = 1.105e-05; %Rotor thrust coefficient(kg.m^2) + +%Environment Parameter +ModelParam_envGravityAcc = 9.8; %Gravity acceleration(m/s^2) +ModelParam_envLongitude = 116.259368300000; +ModelParam_envLatitude = 40.1540302; +ModelParam_GPSLatLong = [ModelParam_envLatitude ModelParam_envLongitude]; %Latitude and longitude +ModelParam_envAltitude = -41.5260009765625; %Reference height, down is positive +ModelParam_BusSampleRate = 0.001; %Model sampling rate \ No newline at end of file diff --git a/e5/e5.1/tune/icon/SupportedVehicleTypes.pdf b/e5/e5.1/tune/icon/SupportedVehicleTypes.pdf new file mode 100644 index 0000000..594b76a Binary files /dev/null and b/e5/e5.1/tune/icon/SupportedVehicleTypes.pdf differ diff --git a/e5/e5.1/tune/icon/pixhawk.png b/e5/e5.1/tune/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e5/e5.1/tune/icon/pixhawk.png differ diff --git a/e5/e5.2/AttitudeControl_tune.slx b/e5/e5.2/AttitudeControl_tune.slx new file mode 100644 index 0000000..bdd4fd7 Binary files /dev/null and b/e5/e5.2/AttitudeControl_tune.slx differ diff --git a/e5/e5.2/Init_control.m b/e5/e5.2/Init_control.m new file mode 100644 index 0000000..f36767b --- /dev/null +++ b/e5/e5.2/Init_control.m @@ -0,0 +1,46 @@ +%%% AttitudeControl_tune +clear +path('./icon/',path); +%Run the model initialization file icon/init.m +Init; + +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; + +%% Initial condition +ModelInit_PosE = [0, 0, -100]; +ModelInit_VelB = [0, 0, 0]; +ModelInit_AngEuler = [0, 0, 0]; +ModelInit_RateB = [0, 0, 0]; +ModelInit_Rads = 557.142; +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE = 6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE = 6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; + +Kp_YAW_AngleRate = 0.3; +Ki_YAW_AngleRate = 0.1; +Kd_YAW_AngleRate = 0.00; +%integral saturation +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%% run simulink model +AttitudeControl_tune \ No newline at end of file diff --git a/e5/e5.2/icon/F450.png b/e5/e5.2/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e5/e5.2/icon/F450.png differ diff --git a/e5/e5.2/icon/FlightGear.png b/e5/e5.2/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e5/e5.2/icon/FlightGear.png differ diff --git a/e5/e5.2/icon/Init.m b/e5/e5.2/icon/Init.m new file mode 100644 index 0000000..a6c5799 --- /dev/null +++ b/e5/e5.2/icon/Init.m @@ -0,0 +1,39 @@ +%Initial condition +ModelInit_PosE = [0, 0, 0]; %Initial position +ModelInit_VelB = [0, 0, 0]; %Initial velocity +ModelInit_AngEuler = [0, 0, 0]; %Initial Euler angle +ModelInit_RateB = [0, 0, 0]; %Initial angular velocity +ModelInit_Rads = 0; %Initial motor speed(rad/s) + +%UAV model parameter +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx, 0, 0;... + 0, ModelParam_uavJyy, 0;... + 0, 0, ModelParam_uavJzz]; +ModelParam_uavType = int8(3); %X-type quadrotor��refer to "SupportedVehicleTypes.pdf" for specific definitions +ModelParam_uavMotNumbs = int8(4); %Number of motors +ModelParam_uavR = 0.225; %Body radius(m) +ModelParam_uavCd = 0.055; %Damping coefficient(N/(m/s)^2) +ModelParam_uavCCm = [0.0035 0.0039 0.0034]; %Damping moment coefficient vector(N/(m/s)^2) + +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb = -141.4; %Motor speed-throttle curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) +ModelParam_motorMinThr = 0.05; %Motor throttle dead zone(kg.m^2) +%M=Cm*w^2 +ModelParam_rotorCm = 1.779e-07; %Rotor torque coefficient(kg.m^2) +%T=Ct**w^2 +ModelParam_rotorCt = 1.105e-05; %Rotor thrust coefficient(kg.m^2) + +%Environment Parameter +ModelParam_envGravityAcc = 9.8; %Gravity acceleration(m/s^2) +ModelParam_envLongitude = 116.259368300000; +ModelParam_envLatitude = 40.1540302; +ModelParam_GPSLatLong = [ModelParam_envLatitude ModelParam_envLongitude]; %Latitude and longitude +ModelParam_envAltitude = -41.5260009765625; %Reference height, down is positive +ModelParam_BusSampleRate = 0.001; %Model sampling rate \ No newline at end of file diff --git a/e5/e5.2/icon/SupportedVehicleTypes.pdf b/e5/e5.2/icon/SupportedVehicleTypes.pdf new file mode 100644 index 0000000..594b76a Binary files /dev/null and b/e5/e5.2/icon/SupportedVehicleTypes.pdf differ diff --git a/e5/e5.2/icon/pixhawk.png b/e5/e5.2/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e5/e5.2/icon/pixhawk.png differ diff --git a/e5/e5.4/AttitudeControl_FLY.slx b/e5/e5.4/AttitudeControl_FLY.slx new file mode 100644 index 0000000..fce3ebb Binary files /dev/null and b/e5/e5.4/AttitudeControl_FLY.slx differ diff --git a/e5/e5.4/Init_control.m b/e5/e5.4/Init_control.m new file mode 100644 index 0000000..57248fc --- /dev/null +++ b/e5/e5.4/Init_control.m @@ -0,0 +1,41 @@ +%%% AttitudeControl_FLY +clear +path('./icon/',path); + +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; + +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE = 6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE = 6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; + +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; +%integral saturation +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +%Throttle amplitude +MAX_MAN_THR = 0.9; +MIN_MAN_THR = 0.05; +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%% run simulink model +AttitudeControl_FLY \ No newline at end of file diff --git a/e5/e5.4/PSPfile/CMakeLists.txt b/e5/e5.4/PSPfile/CMakeLists.txt new file mode 100644 index 0000000..ea3dc8b --- /dev/null +++ b/e5/e5.4/PSPfile/CMakeLists.txt @@ -0,0 +1,253 @@ +############################################################################ +# +# Copyright (c) 2016 PX4 Development Team. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# 3. Neither the name PX4 nor the names of its contributors may be +# used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED +# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +############################################################################ + +set(msg_files + actuator_armed.msg + actuator_controls.msg + actuator_direct.msg + actuator_outputs.msg + adc_report.msg + airspeed.msg + att_pos_mocap.msg + battery_status.msg + camera_capture.msg + camera_trigger.msg + collision_report.msg + commander_state.msg + cpuload.msg + debug_key_value.msg + debug_value.msg + debug_vect.msg + differential_pressure.msg + distance_sensor.msg + ekf2_innovations.msg + ekf2_timestamps.msg + esc_report.msg + esc_status.msg + estimator_status.msg + filtered_bottom_flow.msg + follow_target.msg + fw_pos_ctrl_status.msg + geofence_result.msg + gps_dump.msg + gps_inject_data.msg + hil_sensor.msg + home_position.msg + input_rc.msg + led_control.msg + log_message.msg + manual_control_setpoint.msg + mavlink_log.msg + mc_att_ctrl_status.msg + mission.msg + mission_result.msg + mount_orientation.msg + multirotor_motor_limits.msg + offboard_control_mode.msg + optical_flow.msg + output_pwm.msg + parameter_update.msg + position_setpoint.msg + position_setpoint_triplet.msg + power_button_state.msg + pwm_input.msg + qshell_req.msg + rc_channels.msg + rc_parameter_map.msg + safety.msg + satellite_info.msg + sensor_accel.msg + sensor_baro.msg + sensor_bias.msg + sensor_combined.msg + sensor_correction.msg + sensor_gyro.msg + sensor_mag.msg + sensor_preflight.msg + sensor_selection.msg + servorail_status.msg + subsystem_info.msg + system_power.msg + task_stack_info.msg + tecs_status.msg + telemetry_status.msg + test_motor.msg + time_offset.msg + transponder_report.msg + uavcan_parameter_request.msg + uavcan_parameter_value.msg + ulog_stream.msg + ulog_stream_ack.msg + vehicle_attitude.msg + vehicle_attitude_setpoint.msg + vehicle_command.msg + vehicle_command_ack.msg + vehicle_control_mode.msg + vehicle_force_setpoint.msg + vehicle_global_position.msg + vehicle_gps_position.msg + vehicle_land_detected.msg + vehicle_local_position.msg + vehicle_local_position_setpoint.msg + vehicle_rates_setpoint.msg + vehicle_roi.msg + vehicle_status.msg + vehicle_status_flags.msg + vtol_vehicle_status.msg + wind_estimate.msg + costom_attctrl_e5.msg + ) + +px4_add_git_submodule(TARGET git_gencpp PATH tools/gencpp) +px4_add_git_submodule(TARGET git_genmsg PATH tools/genmsg) + +# headers +set(msg_out_path ${PX4_BINARY_DIR}/uORB/topics) +set(msg_source_out_path ${CMAKE_CURRENT_BINARY_DIR}/topics_sources) + +set(uorb_headers) +set(uorb_sources ${msg_source_out_path}/uORBTopics.cpp) +foreach(msg_file ${msg_files}) + get_filename_component(msg ${msg_file} NAME_WE) + list(APPEND uorb_headers ${msg_out_path}/${msg}.h) + list(APPEND uorb_sources ${msg_source_out_path}/${msg}.cpp) +endforeach() + +# Generate uORB headers +add_custom_command(OUTPUT ${uorb_headers} + COMMAND ${PYTHON_EXECUTABLE} tools/px_generate_uorb_topic_files.py + --headers + -f ${msg_files} + -i ${CMAKE_CURRENT_SOURCE_DIR} + -o ${msg_out_path} + -e templates/uorb + -t ${CMAKE_CURRENT_BINARY_DIR}/tmp/headers + -q + DEPENDS ${msg_files} + COMMENT "Generating uORB topic headers" + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + VERBATIM + ) +add_custom_target(uorb_headers DEPENDS ${uorb_headers}) + +# Generate uORB sources +add_custom_command(OUTPUT ${uorb_sources} + COMMAND ${PYTHON_EXECUTABLE} tools/px_generate_uorb_topic_files.py + --sources + -f ${msg_files} + -i ${CMAKE_CURRENT_SOURCE_DIR} + -o ${msg_source_out_path} + -e templates/uorb + -t ${CMAKE_CURRENT_BINARY_DIR}/tmp/sources + -q + DEPENDS ${msg_files} + COMMENT "Generating uORB topic sources" + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + VERBATIM + ) + +px4_add_library(uorb_msgs ${uorb_sources}) +add_dependencies(uorb_msgs uorb_headers) + +############################################################################### +# micro-cdr serialization +############################################################################### +# if RTPS is enabled generate serialization code for each uORB message +if (GENERATE_RTPS_BRIDGE) + + set(msg_out_path_microcdr ${PX4_BINARY_DIR}/uORB_microcdr/topics) + set(msg_source_out_path_microcdr ${CMAKE_CURRENT_BINARY_DIR}/topics_microcdr_sources) + + set(uorb_headers_microcdr) + set(uorb_sources_microcdr) + + # send topic files + set(send_topic_files) + foreach(topic ${config_rtps_send_topics}) + list(APPEND send_topic_files ${PX4_SOURCE_DIR}/msg/${topic}.msg) + list(APPEND uorb_headers_microcdr ${msg_out_path_microcdr}/${topic}.h) + list(APPEND uorb_sources_microcdr ${msg_source_out_path_microcdr}/${topic}.cpp) + endforeach() + + # receive topic files + set(receive_topic_files) + foreach(topic ${config_rtps_receive_topics}) + list(APPEND receive_topic_files ${PX4_SOURCE_DIR}/msg/${topic}.msg) + list(APPEND uorb_headers_microcdr ${msg_out_path_microcdr}/${topic}.h) + list(APPEND uorb_sources_microcdr ${msg_source_out_path_microcdr}/${topic}.cpp) + endforeach() + + list(REMOVE_DUPLICATES uorb_headers_microcdr) + list(REMOVE_DUPLICATES uorb_sources_microcdr) + + # Generate uORB serialization headers + add_custom_command(OUTPUT ${uorb_headers_microcdr} + COMMAND ${PYTHON_EXECUTABLE} tools/px_generate_uorb_topic_files.py + --headers + -f ${send_topic_files} ${receive_topic_files} + -i ${CMAKE_CURRENT_SOURCE_DIR} + -o ${msg_out_path_microcdr} + -e templates/uorb_microcdr + -t ${CMAKE_CURRENT_BINARY_DIR}/tmp/headers_microcdr + -q + DEPENDS ${msg_files} + COMMENT "Generating uORB microcdr topic headers" + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + VERBATIM + ) + add_custom_target(uorb_headers_microcdr DEPENDS ${uorb_headers_microcdr}) + + # Generate uORB serialization sources + add_custom_command(OUTPUT ${uorb_sources_microcdr} + COMMAND ${PYTHON_EXECUTABLE} tools/px_generate_uorb_topic_files.py + --sources + -f ${send_topic_files} ${receive_topic_files} + -i ${CMAKE_CURRENT_SOURCE_DIR} + -o ${msg_source_out_path_microcdr} + -e templates/uorb_microcdr + -t ${CMAKE_CURRENT_BINARY_DIR}/tmp/sources_microcdr + -q + DEPENDS ${msg_files} + COMMENT "Generating uORB microcdr topic sources" + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + VERBATIM + ) + px4_add_library(uorb_msgs_microcdr ${uorb_sources_microcdr}) + add_dependencies(uorb_msgs_microcdr uorb_headers_microcdr uorb_headers) + + # microCDR + target_include_directories(uorb_msgs_microcdr + PRIVATE ${PX4_SOURCE_DIR}/src/lib/micro-CDR/include + PRIVATE ${PX4_BINARY_DIR}/src/lib/micro-CDR/include/microcdr + ) +endif() diff --git a/e5/e5.4/PSPfile/costom_attctrl_e5.msg b/e5/e5.4/PSPfile/costom_attctrl_e5.msg new file mode 100644 index 0000000..dc954eb --- /dev/null +++ b/e5/e5.4/PSPfile/costom_attctrl_e5.msg @@ -0,0 +1,7 @@ +#attitude data +float32[2] euler_rp +float32 yawrate +#desired attitude data +float32[2] euler_rp_d +float32 yawrate_d + diff --git a/e5/e5.4/PSPfile/logger.cpp b/e5/e5.4/PSPfile/logger.cpp new file mode 100644 index 0000000..db2437c --- /dev/null +++ b/e5/e5.4/PSPfile/logger.cpp @@ -0,0 +1,2039 @@ +/**************************************************************************** + * + * Copyright (c) 2016 PX4 Development Team. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name PX4 nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +#include +#include "logger.h" +#include "messages.h" + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __PX4_DARWIN +#include +#include +#else +#include +#endif + +#define GPS_EPOCH_SECS ((time_t)1234567890ULL) + +//#define DBGPRINT //write status output every few seconds + +#if defined(DBGPRINT) +// needed for mallinfo +#if defined(__PX4_POSIX) && !defined(__PX4_DARWIN) +#include +#endif /* __PX4_POSIX */ + +// struct mallinfo not available on OSX? +#if defined(__PX4_DARWIN) +#undef DBGPRINT +#endif /* defined(__PX4_DARWIN) */ +#endif /* defined(DBGPRINT) */ + +using namespace px4::logger; + +/* This is used to schedule work for the logger (periodic scan for updated topics) */ +static void timer_callback(void *arg) +{ + px4_sem_t *semaphore = (px4_sem_t *)arg; + px4_sem_post(semaphore); +} + + +int logger_main(int argc, char *argv[]) +{ + // logger currently assumes little endian + int num = 1; + + if (*(char *)&num != 1) { + PX4_ERR("Logger only works on little endian!\n"); + return 1; + } + + return Logger::main(argc, argv); +} + +namespace px4 +{ +namespace logger +{ + +int Logger::custom_command(int argc, char *argv[]) +{ + if (!is_running()) { + print_usage("logger not running"); + return 1; + } + + if (!strcmp(argv[0], "on")) { + get_instance()->set_arm_override(true); + return 0; + } + + if (!strcmp(argv[0], "off")) { + get_instance()->set_arm_override(false); + return 0; + } + + return print_usage("unknown command"); +} + +int Logger::print_usage(const char *reason) +{ + if (reason) { + PX4_WARN("%s\n", reason); + } + + PRINT_MODULE_DESCRIPTION( + R"DESCR_STR( +### Description +System logger which logs a configurable set of uORB topics and system printf messages +(`PX4_WARN` and `PX4_ERR`) to ULog files. These can be used for system and flight performance evaluation, +tuning, replay and crash analysis. + +It supports 2 backends: +- Files: write ULog files to the file system (SD card) +- MAVLink: stream ULog data via MAVLink to a client (the client must support this) + +Both backends can be enabled and used at the same time. + +### Implementation +The implementation uses two threads: +- The main thread, running at a fixed rate (or polling on a topic if started with -p) and checking for + data updates +- The writer thread, writing data to the file + +In between there is a write buffer with configurable size. It should be large to avoid dropouts. + +### Examples +Typical usage to start logging immediately: +$ logger start -e -t + +Or if already running: +$ logger on +)DESCR_STR"); + + PRINT_MODULE_USAGE_NAME("logger", "system"); + PRINT_MODULE_USAGE_COMMAND("start"); + PRINT_MODULE_USAGE_PARAM_STRING('m', "all", "file|mavlink|all", "Backend mode", true); + PRINT_MODULE_USAGE_PARAM_FLAG('e', "Enable logging right after start until disarm (otherwise only when armed)", true); + PRINT_MODULE_USAGE_PARAM_FLAG('f', "Log until shutdown (implies -e)", true); + PRINT_MODULE_USAGE_PARAM_FLAG('t', "Use date/time for naming log directories and files", true); + PRINT_MODULE_USAGE_PARAM_INT('r', 280, 0, 8000, "Log rate in Hz, 0 means unlimited rate", true); + PRINT_MODULE_USAGE_PARAM_INT('b', 12, 4, 10000, "Log buffer size in KiB", true); + PRINT_MODULE_USAGE_PARAM_INT('q', 14, 1, 100, "uORB queue size for mavlink mode", true); + PRINT_MODULE_USAGE_PARAM_STRING('p', nullptr, "", + "Poll on a topic instead of running with fixed rate (Log rate and topic intervals are ignored if this is set)", true); + PRINT_MODULE_USAGE_COMMAND_DESCR("on", "start logging now, override arming (logger must be running)"); + PRINT_MODULE_USAGE_COMMAND_DESCR("off", "stop logging now, override arming (logger must be running)"); + PRINT_MODULE_USAGE_DEFAULT_COMMANDS(); + + return 0; +} + +int Logger::task_spawn(int argc, char *argv[]) +{ + _task_id = px4_task_spawn_cmd("logger", + SCHED_DEFAULT, + SCHED_PRIORITY_LOG_CAPTURE, + 3600, + (px4_main_t)&run_trampoline, + (char *const *)argv); + + if (_task_id < 0) { + _task_id = -1; + return -errno; + } + + return 0; +} + +int Logger::print_status() +{ + PX4_INFO("Running in mode: %s", configured_backend_mode()); + + if (_writer.is_started(LogWriter::BackendFile)) { + PX4_INFO("File Logging Running"); + print_statistics(); + } + + if (_writer.is_started(LogWriter::BackendMavlink)) { + PX4_INFO("Mavlink Logging Running"); + } + + return 0; +} + +void Logger::print_statistics() +{ + if (!_writer.is_started(LogWriter::BackendFile)) { //currently only statistics for file logging + return; + } + + /* this is only for the file backend */ + float kibibytes = _writer.get_total_written_file() / 1024.0f; + float mebibytes = kibibytes / 1024.0f; + float seconds = ((float)(hrt_absolute_time() - _start_time_file)) / 1000000.0f; + + PX4_INFO("Log file: %s/%s", _log_dir, _log_file_name); + PX4_INFO("Wrote %4.2f MiB (avg %5.2f KiB/s)", (double)mebibytes, (double)(kibibytes / seconds)); + PX4_INFO("Since last status: dropouts: %zu (max len: %.3f s), max used buffer: %zu / %zu B", + _write_dropouts, (double)_max_dropout_duration, _high_water, _writer.get_buffer_size_file()); + _high_water = 0; + _write_dropouts = 0; + _max_dropout_duration = 0.f; +} + +Logger *Logger::instantiate(int argc, char *argv[]) +{ + uint32_t log_interval = 3500; + int log_buffer_size = 12 * 1024; + bool log_on_start = false; + bool log_until_shutdown = false; + bool error_flag = false; + bool log_name_timestamp = false; + unsigned int queue_size = 14; //TODO: we might be able to reduce this if mavlink polled on the topic and/or + // topic sizes get reduced + LogWriter::Backend backend = LogWriter::BackendAll; + const char *poll_topic = nullptr; + + int myoptind = 1; + int ch; + const char *myoptarg = nullptr; + + while ((ch = px4_getopt(argc, argv, "r:b:etfm:q:p:", &myoptind, &myoptarg)) != EOF) { + switch (ch) { + case 'r': { + unsigned long r = strtoul(myoptarg, nullptr, 10); + + if (r <= 0) { + r = 1e6; + } + + log_interval = 1e6 / r; + } + break; + + case 'e': + log_on_start = true; + break; + + case 'b': { + unsigned long s = strtoul(myoptarg, nullptr, 10); + + if (s < 1) { + s = 1; + } + + log_buffer_size = 1024 * s; + } + break; + + case 't': + log_name_timestamp = true; + break; + + case 'f': + log_on_start = true; + log_until_shutdown = true; + break; + + case 'm': + if (!strcmp(myoptarg, "file")) { + backend = LogWriter::BackendFile; + + } else if (!strcmp(myoptarg, "mavlink")) { + backend = LogWriter::BackendMavlink; + + } else if (!strcmp(myoptarg, "all")) { + backend = LogWriter::BackendAll; + + } else { + PX4_ERR("unknown mode: %s", myoptarg); + error_flag = true; + } + + break; + + case 'p': + poll_topic = myoptarg; + break; + + case 'q': + queue_size = strtoul(myoptarg, nullptr, 10); + + if (queue_size == 0) { + queue_size = 1; + } + + break; + + case '?': + error_flag = true; + break; + + default: + PX4_WARN("unrecognized flag"); + error_flag = true; + break; + } + } + + if (error_flag) { + return nullptr; + } + + Logger *logger = new Logger(backend, log_buffer_size, log_interval, poll_topic, log_on_start, + log_until_shutdown, log_name_timestamp, queue_size); + +#if defined(DBGPRINT) && defined(__PX4_NUTTX) + struct mallinfo alloc_info = mallinfo(); + PX4_INFO("largest free chunk: %d bytes", alloc_info.mxordblk); + PX4_INFO("remaining free heap: %d bytes", alloc_info.fordblks); +#endif /* DBGPRINT */ + + if (logger == nullptr) { + PX4_ERR("alloc failed"); + + } else { +#ifndef __PX4_NUTTX + //check for replay mode + const char *logfile = getenv(px4::replay::ENV_FILENAME); + + if (logfile) { + logger->setReplayFile(logfile); + } + +#endif /* __PX4_NUTTX */ + + } + + return logger; +} + + +Logger::Logger(LogWriter::Backend backend, size_t buffer_size, uint32_t log_interval, const char *poll_topic_name, + bool log_on_start, bool log_until_shutdown, bool log_name_timestamp, unsigned int queue_size) : + _arm_override(false), + _log_on_start(log_on_start), + _log_until_shutdown(log_until_shutdown), + _log_name_timestamp(log_name_timestamp), + _writer(backend, buffer_size, queue_size), + _log_interval(log_interval) +{ + _log_utc_offset = param_find("SDLOG_UTC_OFFSET"); + _log_dirs_max = param_find("SDLOG_DIRS_MAX"); + _sdlog_profile_handle = param_find("SDLOG_PROFILE"); + + if (poll_topic_name) { + const orb_metadata **topics = orb_get_topics(); + + for (size_t i = 0; i < orb_topics_count(); i++) { + if (strcmp(poll_topic_name, topics[i]->o_name) == 0) { + _polling_topic_meta = topics[i]; + break; + } + } + + if (!_polling_topic_meta) { + PX4_ERR("Failed to find topic %s", poll_topic_name); + } + } +} + +Logger::~Logger() +{ + if (_replay_file_name) { + free(_replay_file_name); + } + + if (_msg_buffer) { + delete[](_msg_buffer); + } +} + +bool Logger::request_stop_static() +{ + if (is_running()) { + get_instance()->request_stop(); + return false; + } + + return true; +} + +int Logger::add_topic(const orb_metadata *topic) +{ + int fd = -1; + size_t fields_len = strlen(topic->o_fields) + strlen(topic->o_name) + 1; //1 for ':' + + if (fields_len > sizeof(ulog_message_format_s::format)) { + PX4_WARN("skip topic %s, format string is too large: %zu (max is %zu)", topic->o_name, fields_len, + sizeof(ulog_message_format_s::format)); + + return -1; + } + + fd = orb_subscribe(topic); + + if (fd < 0) { + PX4_WARN("logger: %s subscribe failed (%i)", topic->o_name, errno); + return -1; + } + + if (!_subscriptions.push_back(LoggerSubscription(fd, topic))) { + PX4_WARN("logger: failed to add topic. Too many subscriptions"); + orb_unsubscribe(fd); + fd = -1; + } + + return fd; +} + +int Logger::add_topic(const char *name, unsigned interval = 0) +{ + const orb_metadata **topics = orb_get_topics(); + int fd = -1; + + for (size_t i = 0; i < orb_topics_count(); i++) { + if (strcmp(name, topics[i]->o_name) == 0) { + bool already_added = false; + + // check if already added: if so, only update the interval + for (size_t j = 0; j < _subscriptions.size(); ++j) { + if (_subscriptions[j].metadata == topics[i]) { + PX4_DEBUG("logging topic %s, interval: %i, already added, only setting interval", + topics[i]->o_name, interval); + fd = _subscriptions[j].fd[0]; + already_added = true; + break; + } + } + + if (!already_added) { + fd = add_topic(topics[i]); + PX4_DEBUG("logging topic: %s, interval: %i", topics[i]->o_name, interval); + break; + } + } + } + + // if we poll on a topic, we don't set the interval and let the polled topic define the maximum interval + if (!_polling_topic_meta && fd >= 0) { + orb_set_interval(fd, interval); + } + + return fd; +} + +bool Logger::copy_if_updated_multi(LoggerSubscription &sub, int multi_instance, void *buffer, bool try_to_subscribe) +{ + bool updated = false; + int &handle = sub.fd[multi_instance]; + + if (handle < 0 && try_to_subscribe) { + + if (OK == orb_exists(sub.metadata, multi_instance)) { + handle = orb_subscribe_multi(sub.metadata, multi_instance); + + //PX4_INFO("subscribed to instance %d of topic %s", multi_instance, sub.metadata->o_name); + + /* copy first data */ + if (handle >= 0) { + write_add_logged_msg(sub, multi_instance); + + /* set to the same interval as the first instance */ + unsigned int interval; + + if (orb_get_interval(sub.fd[0], &interval) == 0 && interval > 0) { + orb_set_interval(handle, interval); + } + + /* It can happen that orb_exists returns true, even if there is no publisher (but another subscriber). + * We catch this here, because orb_copy will fail in this case. */ + if (orb_copy(sub.metadata, handle, buffer) == PX4_OK) { + updated = true; + } + } + } + + } else if (handle >= 0) { + orb_check(handle, &updated); + + if (updated) { + orb_copy(sub.metadata, handle, buffer); + } + } + + return updated; +} + +void Logger::add_common_topics() +{ +#ifdef CONFIG_ARCH_BOARD_SITL + add_topic("vehicle_attitude_groundtruth", 10); + add_topic("vehicle_global_position_groundtruth", 100); + add_topic("vehicle_local_position_groundtruth", 100); +#endif + + // Note: try to avoid setting the interval where possible, as it increases RAM usage + add_topic("actuator_controls_0", 100); + add_topic("actuator_controls_1", 100); + add_topic("actuator_outputs", 100); + add_topic("airspeed", 200); + add_topic("att_pos_mocap", 50); + add_topic("battery_status", 500); + add_topic("camera_capture"); + add_topic("camera_trigger"); + add_topic("commander_state", 200); + add_topic("cpuload"); + add_topic("distance_sensor", 100); + add_topic("ekf2_innovations", 200); + add_topic("esc_status", 250); + add_topic("estimator_status", 200); + add_topic("input_rc", 200); + add_topic("manual_control_setpoint", 200); + add_topic("optical_flow", 50); + add_topic("position_setpoint_triplet", 200); + add_topic("rc_channels", 200); + add_topic("sensor_combined", 100); + add_topic("sensor_preflight", 200); + add_topic("system_power", 500); + add_topic("tecs_status", 200); + add_topic("telemetry_status"); + add_topic("vehicle_attitude", 30); + add_topic("vehicle_attitude_setpoint", 100); + add_topic("vehicle_command"); + add_topic("vehicle_global_position", 200); + add_topic("vehicle_gps_position"); + add_topic("vehicle_land_detected"); + add_topic("vehicle_local_position", 100); + add_topic("vehicle_local_position_setpoint", 100); + add_topic("vehicle_rates_setpoint", 30); + add_topic("vehicle_status", 200); + add_topic("vehicle_vision_attitude"); + add_topic("vehicle_vision_position"); + add_topic("vtol_vehicle_status", 200); + add_topic("wind_estimate", 200); + add_topic("costom_attctrl_e5",250); +} + +void Logger::add_estimator_replay_topics() +{ + // for estimator replay (need to be at full rate) + add_topic("ekf2_timestamps"); + + // current EKF2 subscriptions + add_topic("airspeed"); + add_topic("distance_sensor"); + add_topic("optical_flow"); + add_topic("sensor_baro"); + add_topic("sensor_combined"); + add_topic("sensor_selection"); + add_topic("vehicle_gps_position"); + add_topic("vehicle_land_detected"); + add_topic("vehicle_status"); + add_topic("vehicle_vision_attitude"); + add_topic("vehicle_vision_position"); +} + +void Logger::add_thermal_calibration_topics() +{ + // Note: try to avoid setting the interval where possible, as it increases RAM usage + add_topic("sensor_accel", 100); + add_topic("sensor_baro", 100); + add_topic("sensor_gyro", 100); +} + +void Logger::add_system_identification_topics() +{ + // for system id need to log imu and controls at full rate + add_topic("actuator_controls_0"); + add_topic("actuator_controls_1"); + add_topic("sensor_combined"); +} + +int Logger::add_topics_from_file(const char *fname) +{ + FILE *fp; + char line[80]; + char topic_name[80]; + unsigned interval; + int ntopics = 0; + + /* open the topic list file */ + fp = fopen(fname, "r"); + + if (fp == nullptr) { + return -1; + } + + /* call add_topic for each topic line in the file */ + for (;;) { + + /* get a line, bail on error/EOF */ + line[0] = '\0'; + + if (fgets(line, sizeof(line), fp) == nullptr) { + break; + } + + /* skip comment lines */ + if ((strlen(line) < 2) || (line[0] == '#')) { + continue; + } + + // read line with format: [, ] + interval = 0; + int nfields = sscanf(line, "%s %u", topic_name, &interval); + + if (nfields > 0) { + int name_len = strlen(topic_name); + + if (name_len > 0 && topic_name[name_len - 1] == ',') { + topic_name[name_len - 1] = '\0'; + } + + /* add topic with specified interval */ + if (add_topic(topic_name, interval) >= 0) { + ntopics++; + + } else { + PX4_ERR("Failed to add topic %s", topic_name); + } + } + } + + fclose(fp); + return ntopics; +} + +const char *Logger::configured_backend_mode() const +{ + switch (_writer.backend()) { + case LogWriter::BackendFile: return "file"; + + case LogWriter::BackendMavlink: return "mavlink"; + + case LogWriter::BackendAll: return "all"; + + default: return "several"; + } +} + +void Logger::run() +{ +#ifdef DBGPRINT + struct mallinfo alloc_info = {}; +#endif /* DBGPRINT */ + + PX4_INFO("logger started (mode=%s)", configured_backend_mode()); + + if (_writer.backend() & LogWriter::BackendFile) { + int mkdir_ret = mkdir(LOG_ROOT, S_IRWXU | S_IRWXG | S_IRWXO); + + if (mkdir_ret == 0) { + PX4_INFO("log root dir created: %s", LOG_ROOT); + + } else if (errno != EEXIST) { + PX4_ERR("failed creating log root dir: %s", LOG_ROOT); + + if ((_writer.backend() & ~LogWriter::BackendFile) == 0) { + return; + } + } + + if (check_free_space() == 1) { + return; + } + } + + int vehicle_status_sub = orb_subscribe(ORB_ID(vehicle_status)); + uORB::Subscription parameter_update_sub(ORB_ID(parameter_update)); + int log_message_sub = orb_subscribe(ORB_ID(log_message)); + orb_set_interval(log_message_sub, 20); + + int ntopics = add_topics_from_file(PX4_ROOTFSDIR "/fs/microsd/etc/logging/logger_topics.txt"); + + if (ntopics > 0) { + PX4_INFO("logging %d topics from logger_topics.txt", ntopics); + + } else { + + // get the logging profile + SDLogProfile sdlog_profile = SDLogProfile::DEFAULT; + + if (_sdlog_profile_handle != PARAM_INVALID) { + param_get(_sdlog_profile_handle, &sdlog_profile); + } + + // load appropriate topics for profile + if (sdlog_profile == SDLogProfile::DEFAULT) { + add_common_topics(); + add_estimator_replay_topics(); + + } else if (sdlog_profile == SDLogProfile::THERMAL_CALIBRATION) { + add_thermal_calibration_topics(); + + } else if (sdlog_profile == SDLogProfile::SYSTEM_IDENTIFICATION) { + add_common_topics(); + add_system_identification_topics(); + + } else { + add_common_topics(); + add_estimator_replay_topics(); + } + } + + int vehicle_command_sub = -1; + orb_advert_t vehicle_command_ack_pub = nullptr; + + if (_writer.backend() & LogWriter::BackendMavlink) { + vehicle_command_sub = orb_subscribe(ORB_ID(vehicle_command)); + } + + //all topics added. Get required message buffer size + int max_msg_size = 0, ret; + + for (const auto &subscription : _subscriptions) { + //use o_size, because that's what orb_copy will use + if (subscription.metadata->o_size > max_msg_size) { + max_msg_size = subscription.metadata->o_size; + } + } + + max_msg_size += sizeof(ulog_message_data_header_s); + + if (sizeof(ulog_message_logging_s) > max_msg_size) { + max_msg_size = sizeof(ulog_message_logging_s); + } + + if (_polling_topic_meta && _polling_topic_meta->o_size > max_msg_size) { + max_msg_size = _polling_topic_meta->o_size; + } + + if (max_msg_size > _msg_buffer_len) { + if (_msg_buffer) { + delete[](_msg_buffer); + } + + _msg_buffer_len = max_msg_size; + _msg_buffer = new uint8_t[_msg_buffer_len]; + + if (!_msg_buffer) { + PX4_ERR("failed to alloc message buffer"); + return; + } + } + + + if (!_writer.init()) { + PX4_ERR("writer init failed"); + return; + } + +#ifdef DBGPRINT + hrt_abstime timer_start = 0; + uint32_t total_bytes = 0; +#endif /* DBGPRINT */ + + px4_register_shutdown_hook(&Logger::request_stop_static); + + // we start logging immediately + // the case where we wait with logging until vehicle is armed is handled below + if (_log_on_start) { + start_log_file(); + } + + /* init the update timer */ + struct hrt_call timer_call; + memset(&timer_call, 0, sizeof(hrt_call)); + px4_sem_t timer_semaphore; + px4_sem_init(&timer_semaphore, 0, 0); + /* timer_semaphore use case is a signal */ + px4_sem_setprotocol(&timer_semaphore, SEM_PRIO_NONE); + + int polling_topic_sub = -1; + + if (_polling_topic_meta) { + polling_topic_sub = orb_subscribe(_polling_topic_meta); + + if (polling_topic_sub < 0) { + PX4_ERR("Failed to subscribe (%i)", errno); + } + + } else { + hrt_call_every(&timer_call, _log_interval, _log_interval, timer_callback, &timer_semaphore); + } + + // check for new subscription data + hrt_abstime next_subscribe_check = 0; + int next_subscribe_topic_index = -1; // this is used to distribute the checks over time + + while (!should_exit()) { + + // Start/stop logging when system arm/disarm + bool vehicle_status_updated; + ret = orb_check(vehicle_status_sub, &vehicle_status_updated); + + if (ret == 0 && vehicle_status_updated) { + vehicle_status_s vehicle_status; + orb_copy(ORB_ID(vehicle_status), vehicle_status_sub, &vehicle_status); + bool armed = (vehicle_status.arming_state == vehicle_status_s::ARMING_STATE_ARMED) || + (vehicle_status.arming_state == vehicle_status_s::ARMING_STATE_ARMED_ERROR) || + _arm_override; + + if (_was_armed != armed && !_log_until_shutdown) { + _was_armed = armed; + + if (armed) { + + if (_should_stop_file_log) { // happens on quick arming after disarm + _should_stop_file_log = false; + stop_log_file(); + } + + start_log_file(); + +#ifdef DBGPRINT + timer_start = hrt_absolute_time(); + total_bytes = 0; +#endif /* DBGPRINT */ + + } else { + // delayed stop: we measure the process loads and then stop + initialize_load_output(); + _should_stop_file_log = true; + } + } + } + + /* check for logging command from MAVLink */ + if (vehicle_command_sub != -1) { + bool command_updated = false; + ret = orb_check(vehicle_command_sub, &command_updated); + + if (ret == 0 && command_updated) { + vehicle_command_s command; + orb_copy(ORB_ID(vehicle_command), vehicle_command_sub, &command); + + if (command.command == vehicle_command_s::VEHICLE_CMD_LOGGING_START) { + if ((int)(command.param1 + 0.5f) != 0) { + ack_vehicle_command(vehicle_command_ack_pub, &command, + vehicle_command_s::VEHICLE_CMD_RESULT_UNSUPPORTED); + + } else if (can_start_mavlink_log()) { + ack_vehicle_command(vehicle_command_ack_pub, &command, + vehicle_command_s::VEHICLE_CMD_RESULT_ACCEPTED); + start_log_mavlink(); + + } else { + ack_vehicle_command(vehicle_command_ack_pub, &command, + vehicle_command_s::VEHICLE_CMD_RESULT_TEMPORARILY_REJECTED); + } + + } else if (command.command == vehicle_command_s::VEHICLE_CMD_LOGGING_STOP) { + stop_log_mavlink(); + ack_vehicle_command(vehicle_command_ack_pub, &command, + vehicle_command_s::VEHICLE_CMD_RESULT_ACCEPTED); + } + } + } + + + if (_writer.is_started()) { + + hrt_abstime loop_time = hrt_absolute_time(); + + /* check if we need to output the process load */ + if (_next_load_print != 0 && loop_time >= _next_load_print) { + _next_load_print = 0; + + if (_should_stop_file_log) { + _should_stop_file_log = false; + write_load_output(false); + stop_log_file(); + continue; // skip to next loop iteration + + } else { + write_load_output(true); + } + } + + bool data_written = false; + + /* Check if parameters have changed */ + // this needs to change to a timestamped record to record a history of parameter changes + if (parameter_update_sub.update()) { + write_changed_parameters(); + } + + /* wait for lock on log buffer */ + _writer.lock(); + + int sub_idx = 0; + + for (LoggerSubscription &sub : _subscriptions) { + /* each message consists of a header followed by an orb data object + */ + size_t msg_size = sizeof(ulog_message_data_header_s) + sub.metadata->o_size_no_padding; + + /* if this topic has been updated, copy the new data into the message buffer + * and write a message to the log + */ + for (uint8_t instance = 0; instance < ORB_MULTI_MAX_INSTANCES; instance++) { + if (copy_if_updated_multi(sub, instance, _msg_buffer + sizeof(ulog_message_data_header_s), + sub_idx == next_subscribe_topic_index)) { + + uint16_t write_msg_size = static_cast(msg_size - ULOG_MSG_HEADER_LEN); + //write one byte after another (necessary because of alignment) + _msg_buffer[0] = (uint8_t)write_msg_size; + _msg_buffer[1] = (uint8_t)(write_msg_size >> 8); + _msg_buffer[2] = static_cast(ULogMessageType::DATA); + uint16_t write_msg_id = sub.msg_ids[instance]; + _msg_buffer[3] = (uint8_t)write_msg_id; + _msg_buffer[4] = (uint8_t)(write_msg_id >> 8); + + //PX4_INFO("topic: %s, size = %zu, out_size = %zu", sub.metadata->o_name, sub.metadata->o_size, msg_size); + + if (write_message(_msg_buffer, msg_size)) { + +#ifdef DBGPRINT + total_bytes += msg_size; +#endif /* DBGPRINT */ + + data_written = true; + + } else { + break; // Write buffer overflow, skip this record + } + } + } + + ++sub_idx; + } + + //check for new logging message(s) + bool log_message_updated = false; + ret = orb_check(log_message_sub, &log_message_updated); + + if (ret == 0 && log_message_updated) { + log_message_s log_message; + orb_copy(ORB_ID(log_message), log_message_sub, &log_message); + const char *message = (const char *)log_message.text; + int message_len = strlen(message); + + if (message_len > 0) { + uint16_t write_msg_size = sizeof(ulog_message_logging_s) - sizeof(ulog_message_logging_s::message) + - ULOG_MSG_HEADER_LEN + message_len; + _msg_buffer[0] = (uint8_t)write_msg_size; + _msg_buffer[1] = (uint8_t)(write_msg_size >> 8); + _msg_buffer[2] = static_cast(ULogMessageType::LOGGING); + _msg_buffer[3] = log_message.severity + '0'; + memcpy(_msg_buffer + 4, &log_message.timestamp, sizeof(ulog_message_logging_s::timestamp)); + strncpy((char *)(_msg_buffer + 12), message, sizeof(ulog_message_logging_s::message)); + + write_message(_msg_buffer, write_msg_size + ULOG_MSG_HEADER_LEN); + } + } + + if (!_dropout_start && _writer.get_buffer_fill_count_file() > _high_water) { + _high_water = _writer.get_buffer_fill_count_file(); + } + + /* release the log buffer */ + _writer.unlock(); + + /* notify the writer thread if data is available */ + if (data_written) { + _writer.notify(); + } + + /* subscription update */ + if (next_subscribe_topic_index != -1) { + if (++next_subscribe_topic_index >= _subscriptions.size()) { + next_subscribe_topic_index = -1; + next_subscribe_check = loop_time + TRY_SUBSCRIBE_INTERVAL; + } + + } else if (loop_time > next_subscribe_check) { + next_subscribe_topic_index = 0; + } + +#ifdef DBGPRINT + double deltat = (double)(hrt_absolute_time() - timer_start) * 1e-6; + + if (deltat > 4.0) { + alloc_info = mallinfo(); + double throughput = total_bytes / deltat; + PX4_INFO("%8.1f kB/s, %zu highWater, %d dropouts, %5.3f sec max, free heap: %d", + throughput / 1.e3, _high_water, _write_dropouts, (double)_max_dropout_duration, + alloc_info.fordblks); + + _high_water = 0; + _max_dropout_duration = 0.f; + total_bytes = 0; + timer_start = hrt_absolute_time(); + } + +#endif /* DBGPRINT */ + + } + + // wait for next loop iteration... + if (polling_topic_sub >= 0) { + px4_pollfd_struct_t fds[1]; + fds[0].fd = polling_topic_sub; + fds[0].events = POLLIN; + int pret = px4_poll(fds, 1, 1000); + + if (pret < 0) { + PX4_ERR("poll failed (%i)", pret); + + } else if (pret != 0) { + if (fds[0].revents & POLLIN) { + // need to to an orb_copy so that poll will not return immediately + orb_copy(_polling_topic_meta, polling_topic_sub, _msg_buffer); + } + } + + } else { + /* + * We wait on the semaphore, which periodically gets updated by a high-resolution timer. + * The simpler alternative would be: + * usleep(max(300, _log_interval - elapsed_time_since_loop_start)); + * And on linux this is quite accurate as well, but under NuttX it is not accurate, + * because usleep() has only a granularity of CONFIG_MSEC_PER_TICK (=1ms). + */ + while (px4_sem_wait(&timer_semaphore) != 0); + } + } + + stop_log_file(); + + hrt_cancel(&timer_call); + px4_sem_destroy(&timer_semaphore); + + // stop the writer thread + _writer.thread_stop(); + + //unsubscribe + for (LoggerSubscription &sub : _subscriptions) { + for (uint8_t instance = 0; instance < ORB_MULTI_MAX_INSTANCES; instance++) { + if (sub.fd[instance] != -1) { + orb_unsubscribe(sub.fd[instance]); + sub.fd[instance] = -1; + } + } + } + + if (polling_topic_sub >= 0) { + orb_unsubscribe(polling_topic_sub); + } + + if (_mavlink_log_pub) { + orb_unadvertise(_mavlink_log_pub); + _mavlink_log_pub = nullptr; + } + + if (vehicle_command_ack_pub) { + orb_unadvertise(vehicle_command_ack_pub); + } + + if (vehicle_command_sub != -1) { + orb_unsubscribe(vehicle_command_sub); + } + + px4_unregister_shutdown_hook(&Logger::request_stop_static); +} + +bool Logger::write_message(void *ptr, size_t size) +{ + if (_writer.write_message(ptr, size, _dropout_start) != -1) { + + if (_dropout_start) { + float dropout_duration = (float)(hrt_elapsed_time(&_dropout_start) / 1000) / 1.e3f; + + if (dropout_duration > _max_dropout_duration) { + _max_dropout_duration = dropout_duration; + } + + _dropout_start = 0; + } + + return true; + } + + if (!_dropout_start) { + _dropout_start = hrt_absolute_time(); + ++_write_dropouts; + _high_water = 0; + } + + return false; +} + +int Logger::create_log_dir(tm *tt) +{ + /* create dir on sdcard if needed */ + int mkdir_ret; + + if (tt) { + int n = snprintf(_log_dir, sizeof(_log_dir), "%s/", LOG_ROOT); + + if (n >= sizeof(_log_dir)) { + PX4_ERR("log path too long"); + return -1; + } + + strftime(_log_dir + n, sizeof(_log_dir) - n, "%Y-%m-%d", tt); + mkdir_ret = mkdir(_log_dir, S_IRWXU | S_IRWXG | S_IRWXO); + + if (mkdir_ret != OK && errno != EEXIST) { + PX4_ERR("failed creating new dir: %s", _log_dir); + return -1; + } + + } else { + uint16_t dir_number = _sess_dir_index; + + /* look for the next dir that does not exist */ + while (!_has_log_dir) { + /* format log dir: e.g. /fs/microsd/sess001 */ + int n = snprintf(_log_dir, sizeof(_log_dir), "%s/sess%03u", LOG_ROOT, dir_number); + + if (n >= sizeof(_log_dir)) { + PX4_ERR("log path too long (%i)", n); + return -1; + } + + mkdir_ret = mkdir(_log_dir, S_IRWXU | S_IRWXG | S_IRWXO); + + if (mkdir_ret == 0) { + PX4_DEBUG("log dir created: %s", _log_dir); + _has_log_dir = true; + + } else if (errno != EEXIST) { + PX4_ERR("failed creating new dir: %s (%i)", _log_dir, errno); + return -1; + } + + /* dir exists already */ + dir_number++; + } + + _has_log_dir = true; + } + + return 0; +} + +bool Logger::file_exist(const char *filename) +{ + struct stat buffer; + return stat(filename, &buffer) == 0; +} + +int Logger::get_log_file_name(char *file_name, size_t file_name_size) +{ + tm tt = {}; + bool time_ok = false; + + if (_log_name_timestamp) { + /* use RTC time for log file naming, e.g. /fs/microsd/2014-01-19/19_37_52.ulg */ + time_ok = get_log_time(&tt, false); + } + + const char *replay_suffix = ""; + + if (_replay_file_name) { + replay_suffix = "_replayed"; + } + + + if (time_ok) { + if (create_log_dir(&tt)) { + return -1; + } + + char log_file_name_time[16] = ""; + strftime(log_file_name_time, sizeof(log_file_name_time), "%H_%M_%S", &tt); + snprintf(_log_file_name, sizeof(_log_file_name), "%s%s.ulg", log_file_name_time, replay_suffix); + snprintf(file_name, file_name_size, "%s/%s", _log_dir, _log_file_name); + + } else { + if (create_log_dir(nullptr)) { + return -1; + } + + uint16_t file_number = 1; // start with file log001 + + /* look for the next file that does not exist */ + while (file_number <= MAX_NO_LOGFILE) { + /* format log file path: e.g. /fs/microsd/sess001/log001.ulg */ + snprintf(_log_file_name, sizeof(_log_file_name), "log%03u%s.ulg", file_number, replay_suffix); + snprintf(file_name, file_name_size, "%s/%s", _log_dir, _log_file_name); + + if (!file_exist(file_name)) { + break; + } + + file_number++; + } + + if (file_number > MAX_NO_LOGFILE) { + /* we should not end up here, either we have more than MAX_NO_LOGFILE on the SD card, or another problem */ + return -1; + } + } + + + return 0; +} + +void Logger::setReplayFile(const char *file_name) +{ + if (_replay_file_name) { + free(_replay_file_name); + } + + _replay_file_name = strdup(file_name); +} + +bool Logger::get_log_time(struct tm *tt, bool boot_time) +{ + int vehicle_gps_position_sub = orb_subscribe(ORB_ID(vehicle_gps_position)); + + if (vehicle_gps_position_sub < 0) { + return false; + } + + /* Get the latest GPS publication */ + vehicle_gps_position_s gps_pos; + time_t utc_time_sec; + bool use_clock_time = true; + + if (orb_copy(ORB_ID(vehicle_gps_position), vehicle_gps_position_sub, &gps_pos) == 0) { + utc_time_sec = gps_pos.time_utc_usec / 1e6; + + if (gps_pos.fix_type >= 2 && utc_time_sec >= GPS_EPOCH_SECS) { + use_clock_time = false; + } + } + + orb_unsubscribe(vehicle_gps_position_sub); + + if (use_clock_time) { + /* take clock time if there's no fix (yet) */ + struct timespec ts = {}; + px4_clock_gettime(CLOCK_REALTIME, &ts); + utc_time_sec = ts.tv_sec + (ts.tv_nsec / 1e9); + + if (utc_time_sec < GPS_EPOCH_SECS) { + return false; + } + } + + /* strip the time elapsed since boot */ + if (boot_time) { + utc_time_sec -= hrt_absolute_time() / 1e6; + } + + int32_t utc_offset = 0; + + if (_log_utc_offset != PARAM_INVALID) { + param_get(_log_utc_offset, &utc_offset); + } + + /* apply utc offset */ + utc_time_sec += utc_offset * 60; + + return gmtime_r(&utc_time_sec, tt) != nullptr; +} + +void Logger::start_log_file() +{ + if (_writer.is_started(LogWriter::BackendFile) || (_writer.backend() & LogWriter::BackendFile) == 0) { + return; + } + + PX4_INFO("Start file log"); + + char file_name[LOG_DIR_LEN] = ""; + + if (get_log_file_name(file_name, sizeof(file_name))) { + PX4_ERR("logger: failed to get log file name"); + return; + } + + /* print logging path, important to find log file later */ + mavlink_log_info(&_mavlink_log_pub, "[logger] file: %s", file_name); + + _writer.start_log_file(file_name); + _writer.select_write_backend(LogWriter::BackendFile); + _writer.set_need_reliable_transfer(true); + write_header(); + write_version(); + write_formats(); + write_parameters(); + write_perf_data(true); + write_all_add_logged_msg(); + _writer.set_need_reliable_transfer(false); + _writer.unselect_write_backend(); + _writer.notify(); + + /* reset performance counters to get in-flight min and max values in post flight log */ + perf_reset_all(); + + _start_time_file = hrt_absolute_time(); + + initialize_load_output(); +} + +void Logger::stop_log_file() +{ + if (!_writer.is_started(LogWriter::BackendFile)) { + return; + } + + _writer.set_need_reliable_transfer(true); + write_perf_data(false); + _writer.set_need_reliable_transfer(false); + _writer.stop_log_file(); +} + +void Logger::start_log_mavlink() +{ + if (!can_start_mavlink_log()) { + return; + } + + PX4_INFO("Start mavlink log"); + + _writer.start_log_mavlink(); + _writer.select_write_backend(LogWriter::BackendMavlink); + _writer.set_need_reliable_transfer(true); + write_header(); + write_version(); + write_formats(); + write_parameters(); + write_perf_data(true); + write_all_add_logged_msg(); + _writer.set_need_reliable_transfer(false); + _writer.unselect_write_backend(); + _writer.notify(); + + initialize_load_output(); +} + +void Logger::stop_log_mavlink() +{ + // don't write perf data since a client does not expect more data after a stop command + PX4_INFO("Stop mavlink log"); + _writer.stop_log_mavlink(); +} + +struct perf_callback_data_t { + Logger *logger; + int counter; + bool preflight; + char *buffer; +}; + +void Logger::perf_iterate_callback(perf_counter_t handle, void *user) +{ + perf_callback_data_t *callback_data = (perf_callback_data_t *)user; + const int buffer_length = 256; + char buffer[buffer_length]; + const char *perf_name; + + perf_print_counter_buffer(buffer, buffer_length, handle); + + if (callback_data->preflight) { + perf_name = "perf_counter_preflight"; + + } else { + perf_name = "perf_counter_postflight"; + } + + callback_data->logger->write_info_multiple(perf_name, buffer, callback_data->counter != 0); + ++callback_data->counter; +} + +void Logger::write_perf_data(bool preflight) +{ + perf_callback_data_t callback_data = {}; + callback_data.logger = this; + callback_data.counter = 0; + callback_data.preflight = preflight; + + // write the perf counters + perf_iterate_all(perf_iterate_callback, &callback_data); +} + + +void Logger::print_load_callback(void *user) +{ + perf_callback_data_t *callback_data = (perf_callback_data_t *)user; + const char *perf_name; + + if (!callback_data->buffer) { + return; + } + + if (callback_data->preflight) { + perf_name = "perf_top_preflight"; + + } else { + perf_name = "perf_top_postflight"; + } + + callback_data->logger->write_info_multiple(perf_name, callback_data->buffer, callback_data->counter != 0); + ++callback_data->counter; +} + +void Logger::initialize_load_output() +{ + perf_callback_data_t callback_data; + callback_data.logger = this; + callback_data.counter = 0; + callback_data.buffer = nullptr; + char buffer[140]; + hrt_abstime curr_time = hrt_absolute_time(); + init_print_load_s(curr_time, &_load); + // this will not yet print anything + print_load_buffer(curr_time, buffer, sizeof(buffer), print_load_callback, &callback_data, &_load); + _next_load_print = curr_time + 1000000; +} + +void Logger::write_load_output(bool preflight) +{ + perf_callback_data_t callback_data = {}; + char buffer[140]; + callback_data.logger = this; + callback_data.counter = 0; + callback_data.buffer = buffer; + callback_data.preflight = preflight; + hrt_abstime curr_time = hrt_absolute_time(); + _writer.set_need_reliable_transfer(true); + // TODO: maybe we should restrict the output to a selected backend (eg. when file logging is running + // and mavlink log is started, this will be added to the file as well) + print_load_buffer(curr_time, buffer, sizeof(buffer), print_load_callback, &callback_data, &_load); + _writer.set_need_reliable_transfer(false); +} + +void Logger::write_formats() +{ + _writer.lock(); + ulog_message_format_s msg = {}; + const orb_metadata **topics = orb_get_topics(); + + //write all known formats + for (size_t i = 0; i < orb_topics_count(); i++) { + int format_len = snprintf(msg.format, sizeof(msg.format), "%s:%s", topics[i]->o_name, topics[i]->o_fields); + size_t msg_size = sizeof(msg) - sizeof(msg.format) + format_len; + msg.msg_size = msg_size - ULOG_MSG_HEADER_LEN; + + write_message(&msg, msg_size); + } + + _writer.unlock(); +} + +void Logger::write_all_add_logged_msg() +{ + _writer.lock(); + + for (LoggerSubscription &sub : _subscriptions) { + for (int instance = 0; instance < ORB_MULTI_MAX_INSTANCES; ++instance) { + if (sub.fd[instance] >= 0) { + write_add_logged_msg(sub, instance); + } + } + } + + _writer.unlock(); +} + +void Logger::write_add_logged_msg(LoggerSubscription &subscription, int instance) +{ + ulog_message_add_logged_s msg; + + if (subscription.msg_ids[instance] == (uint16_t) - 1) { + subscription.msg_ids[instance] = _next_topic_id++; + } + + msg.msg_id = subscription.msg_ids[instance]; + msg.multi_id = instance; + + int message_name_len = strlen(subscription.metadata->o_name); + + memcpy(msg.message_name, subscription.metadata->o_name, message_name_len); + + size_t msg_size = sizeof(msg) - sizeof(msg.message_name) + message_name_len; + msg.msg_size = msg_size - ULOG_MSG_HEADER_LEN; + + bool prev_reliable = _writer.need_reliable_transfer(); + _writer.set_need_reliable_transfer(true); + write_message(&msg, msg_size); + _writer.set_need_reliable_transfer(prev_reliable); +} + +/* write info message */ +void Logger::write_info(const char *name, const char *value) +{ + _writer.lock(); + ulog_message_info_header_s msg = {}; + uint8_t *buffer = reinterpret_cast(&msg); + msg.msg_type = static_cast(ULogMessageType::INFO); + + /* construct format key (type and name) */ + size_t vlen = strlen(value); + msg.key_len = snprintf(msg.key, sizeof(msg.key), "char[%zu] %s", vlen, name); + size_t msg_size = sizeof(msg) - sizeof(msg.key) + msg.key_len; + + /* copy string value directly to buffer */ + if (vlen < (sizeof(msg) - msg_size)) { + memcpy(&buffer[msg_size], value, vlen); + msg_size += vlen; + + msg.msg_size = msg_size - ULOG_MSG_HEADER_LEN; + + write_message(buffer, msg_size); + } + + _writer.unlock(); +} + +void Logger::write_info_multiple(const char *name, const char *value, bool is_continued) +{ + _writer.lock(); + ulog_message_info_multiple_header_s msg; + uint8_t *buffer = reinterpret_cast(&msg); + msg.msg_type = static_cast(ULogMessageType::INFO_MULTIPLE); + msg.is_continued = is_continued; + + /* construct format key (type and name) */ + size_t vlen = strlen(value); + msg.key_len = snprintf(msg.key, sizeof(msg.key), "char[%zu] %s", vlen, name); + size_t msg_size = sizeof(msg) - sizeof(msg.key) + msg.key_len; + + /* copy string value directly to buffer */ + if (vlen < (sizeof(msg) - msg_size)) { + memcpy(&buffer[msg_size], value, vlen); + msg_size += vlen; + + msg.msg_size = msg_size - ULOG_MSG_HEADER_LEN; + + write_message(buffer, msg_size); + } + + _writer.unlock(); +} + +void Logger::write_info(const char *name, int32_t value) +{ + write_info_template(name, value, "int32_t"); +} + +void Logger::write_info(const char *name, uint32_t value) +{ + write_info_template(name, value, "uint32_t"); +} + + +template +void Logger::write_info_template(const char *name, T value, const char *type_str) +{ + _writer.lock(); + ulog_message_info_header_s msg = {}; + uint8_t *buffer = reinterpret_cast(&msg); + msg.msg_type = static_cast(ULogMessageType::INFO); + + /* construct format key (type and name) */ + msg.key_len = snprintf(msg.key, sizeof(msg.key), "%s %s", type_str, name); + size_t msg_size = sizeof(msg) - sizeof(msg.key) + msg.key_len; + + /* copy string value directly to buffer */ + memcpy(&buffer[msg_size], &value, sizeof(T)); + msg_size += sizeof(T); + + msg.msg_size = msg_size - ULOG_MSG_HEADER_LEN; + + write_message(buffer, msg_size); + + _writer.unlock(); +} + +void Logger::write_header() +{ + ulog_file_header_s header = {}; + header.magic[0] = 'U'; + header.magic[1] = 'L'; + header.magic[2] = 'o'; + header.magic[3] = 'g'; + header.magic[4] = 0x01; + header.magic[5] = 0x12; + header.magic[6] = 0x35; + header.magic[7] = 0x01; //file version 1 + header.timestamp = hrt_absolute_time(); + _writer.lock(); + write_message(&header, sizeof(header)); + + // write the Flags message: this MUST be written right after the ulog header + ulog_message_flag_bits_s flag_bits; + + memset(&flag_bits, 0, sizeof(flag_bits)); + flag_bits.msg_size = sizeof(flag_bits) - ULOG_MSG_HEADER_LEN; + flag_bits.msg_type = static_cast(ULogMessageType::FLAG_BITS); + + write_message(&flag_bits, sizeof(flag_bits)); + + _writer.unlock(); +} + +/* write version info messages */ +void Logger::write_version() +{ + write_info("ver_sw", px4_firmware_version_string()); + write_info("ver_sw_release", px4_firmware_version()); + uint32_t vendor_version = px4_firmware_vendor_version(); + + if (vendor_version > 0) { + write_info("ver_vendor_sw_release", vendor_version); + } + + write_info("ver_hw", px4_board_name()); + write_info("sys_name", "PX4"); + write_info("sys_os_name", px4_os_name()); + const char *os_version = px4_os_version_string(); + + const char *git_branch = px4_firmware_git_branch(); + + if (git_branch && git_branch[0]) { + write_info("ver_sw_branch", git_branch); + } + + if (os_version) { + write_info("sys_os_ver", os_version); + } + + write_info("sys_os_ver_release", px4_os_version()); + write_info("sys_toolchain", px4_toolchain_name()); + write_info("sys_toolchain_ver", px4_toolchain_version()); + + char revision = 'U'; + const char *chip_name = nullptr; + + if (board_mcu_version(&revision, &chip_name, nullptr) >= 0) { + char mcu_ver[64]; + snprintf(mcu_ver, sizeof(mcu_ver), "%s, rev. %c", chip_name, revision); + write_info("sys_mcu", mcu_ver); + } + +#ifndef BOARD_HAS_NO_UUID + /* write the UUID if enabled */ + param_t write_uuid_param = param_find("SDLOG_UUID"); + + if (write_uuid_param != PARAM_INVALID) { + uint32_t write_uuid; + param_get(write_uuid_param, &write_uuid); + + if (write_uuid == 1) { + char uuid_string[PX4_CPU_UUID_WORD32_FORMAT_SIZE]; + board_get_uuid32_formated(uuid_string, sizeof(uuid_string), "%08X", NULL); + write_info("sys_uuid", uuid_string); + } + } +#endif /* BOARD_HAS_NO_UUID */ + + int32_t utc_offset = 0; + + if (_log_utc_offset != PARAM_INVALID) { + param_get(_log_utc_offset, &utc_offset); + write_info("time_ref_utc", utc_offset * 60); + } + + if (_replay_file_name) { + write_info("replay", _replay_file_name); + } +} + +void Logger::write_parameters() +{ + _writer.lock(); + ulog_message_parameter_header_s msg = {}; + uint8_t *buffer = reinterpret_cast(&msg); + + msg.msg_type = static_cast(ULogMessageType::PARAMETER); + int param_idx = 0; + param_t param = 0; + + do { + // get next parameter which is invalid OR used + do { + param = param_for_index(param_idx); + ++param_idx; + } while (param != PARAM_INVALID && !param_used(param)); + + // save parameters which are valid AND used + if (param != PARAM_INVALID) { + /* get parameter type and size */ + const char *type_str; + param_type_t type = param_type(param); + size_t value_size = 0; + + switch (type) { + case PARAM_TYPE_INT32: + type_str = "int32_t"; + value_size = sizeof(int32_t); + break; + + case PARAM_TYPE_FLOAT: + type_str = "float"; + value_size = sizeof(float); + break; + + default: + continue; + } + + /* format parameter key (type and name) */ + msg.key_len = snprintf(msg.key, sizeof(msg.key), "%s %s", type_str, param_name(param)); + size_t msg_size = sizeof(msg) - sizeof(msg.key) + msg.key_len; + + /* copy parameter value directly to buffer */ + param_get(param, &buffer[msg_size]); + msg_size += value_size; + + msg.msg_size = msg_size - ULOG_MSG_HEADER_LEN; + + write_message(buffer, msg_size); + } + } while ((param != PARAM_INVALID) && (param_idx < (int) param_count())); + + _writer.unlock(); + _writer.notify(); +} + +void Logger::write_changed_parameters() +{ + _writer.lock(); + ulog_message_parameter_header_s msg = {}; + uint8_t *buffer = reinterpret_cast(&msg); + + msg.msg_type = static_cast(ULogMessageType::PARAMETER); + int param_idx = 0; + param_t param = 0; + + do { + // get next parameter which is invalid OR used + do { + param = param_for_index(param_idx); + ++param_idx; + } while (param != PARAM_INVALID && !param_used(param)); + + // log parameters which are valid AND used AND unsaved + if ((param != PARAM_INVALID) && param_value_unsaved(param)) { + + /* get parameter type and size */ + const char *type_str; + param_type_t type = param_type(param); + size_t value_size = 0; + + switch (type) { + case PARAM_TYPE_INT32: + type_str = "int32_t"; + value_size = sizeof(int32_t); + break; + + case PARAM_TYPE_FLOAT: + type_str = "float"; + value_size = sizeof(float); + break; + + default: + continue; + } + + /* format parameter key (type and name) */ + msg.key_len = snprintf(msg.key, sizeof(msg.key), "%s %s", type_str, param_name(param)); + size_t msg_size = sizeof(msg) - sizeof(msg.key) + msg.key_len; + + /* copy parameter value directly to buffer */ + param_get(param, &buffer[msg_size]); + msg_size += value_size; + + /* msg_size is now 1 (msg_type) + 2 (msg_size) + 1 (key_len) + key_len + value_size */ + msg.msg_size = msg_size - ULOG_MSG_HEADER_LEN; + + write_message(buffer, msg_size); + } + } while ((param != PARAM_INVALID) && (param_idx < (int) param_count())); + + _writer.unlock(); + _writer.notify(); +} + +int Logger::check_free_space() +{ + struct statfs statfs_buf; + + int32_t max_log_dirs_to_keep = 0; + + if (_log_dirs_max != PARAM_INVALID) { + param_get(_log_dirs_max, &max_log_dirs_to_keep); + } + + if (max_log_dirs_to_keep == 0) { + max_log_dirs_to_keep = INT32_MAX; + } + + /* remove old logs if the free space falls below a threshold */ + do { + if (statfs(LOG_ROOT, &statfs_buf) != 0) { + return PX4_ERROR; + } + + DIR *dp = opendir(LOG_ROOT); + + if (dp == nullptr) { + break; // ignore if we cannot access the log directory + } + + struct dirent *result = nullptr; + + int num_sess = 0, num_dates = 0; + + // There are 2 directory naming schemes: sess or --. + // For both we find the oldest and then remove the one which has more directories. + int year_min = 10000, month_min = 99, day_min = 99, sess_idx_min = 99999999, sess_idx_max = 0; + + while ((result = readdir(dp))) { + int year, month, day, sess_idx; + + if (sscanf(result->d_name, "sess%d", &sess_idx) == 1) { + ++num_sess; + + if (sess_idx > sess_idx_max) { + sess_idx_max = sess_idx; + } + + if (sess_idx < sess_idx_min) { + sess_idx_min = sess_idx; + } + + } else if (sscanf(result->d_name, "%d-%d-%d", &year, &month, &day) == 3) { + ++num_dates; + + if (year < year_min) { + year_min = year; + month_min = month; + day_min = day; + + } else if (year == year_min) { + if (month < month_min) { + month_min = month; + day_min = day; + + } else if (month == month_min) { + if (day < day_min) { + day_min = day; + } + } + } + } + } + + closedir(dp); + + _sess_dir_index = sess_idx_max + 1; + + + uint64_t min_free_bytes = 300ULL * 1024ULL * 1024ULL; + uint64_t total_bytes = statfs_buf.f_blocks * statfs_buf.f_bsize / 10; + + if (total_bytes / 10 < min_free_bytes) { // reduce the minimum if it's larger than 10% of the disk size + min_free_bytes = total_bytes / 10; + } + + if (num_sess + num_dates <= max_log_dirs_to_keep && + statfs_buf.f_bavail >= (px4_statfs_buf_f_bavail_t)(min_free_bytes / statfs_buf.f_bsize)) { + break; // enough free space and limit not reached + } + + if (num_sess == 0 && num_dates == 0) { + break; // nothing to delete + } + + char directory_to_delete[LOG_DIR_LEN]; + int n; + + if (num_sess >= num_dates) { + n = snprintf(directory_to_delete, sizeof(directory_to_delete), "%s/sess%03u", LOG_ROOT, sess_idx_min); + + } else { + n = snprintf(directory_to_delete, sizeof(directory_to_delete), "%s/%04u-%02u-%02u", LOG_ROOT, year_min, month_min, + day_min); + } + + if (n >= sizeof(directory_to_delete)) { + PX4_ERR("log path too long (%i)", n); + break; + } + + PX4_WARN("removing log directory %s to get more space (left=%u MiB)", directory_to_delete, + (unsigned int)(statfs_buf.f_bavail / 1024U * statfs_buf.f_bsize / 1024U)); + + if (remove_directory(directory_to_delete)) { + PX4_ERR("Failed to delete directory"); + break; + } + + } while (true); + + + /* use a threshold of 50 MiB: if below, do not start logging */ + if (statfs_buf.f_bavail < (px4_statfs_buf_f_bavail_t)(50 * 1024 * 1024 / statfs_buf.f_bsize)) { + mavlink_log_critical(&_mavlink_log_pub, + "[logger] Not logging; SD almost full: %u MiB", + (unsigned int)(statfs_buf.f_bavail / 1024U * statfs_buf.f_bsize / 1024U)); + return 1; + } + + return PX4_OK; +} + +int Logger::remove_directory(const char *dir) +{ + DIR *d = opendir(dir); + size_t dir_len = strlen(dir); + struct dirent *p; + int ret = 0; + + if (!d) { + return -1; + } + + while (!ret && (p = readdir(d))) { + int ret2 = -1; + char *buf; + size_t len; + + if (!strcmp(p->d_name, ".") || !strcmp(p->d_name, "..")) { + continue; + } + + len = dir_len + strlen(p->d_name) + 2; + buf = new char[len]; + + if (buf) { + struct stat statbuf; + + snprintf(buf, len, "%s/%s", dir, p->d_name); + + if (!stat(buf, &statbuf)) { + if (S_ISDIR(statbuf.st_mode)) { + ret2 = remove_directory(buf); + + } else { + ret2 = unlink(buf); + } + } + + delete[] buf; + } + + ret = ret2; + } + + closedir(d); + + if (!ret) { + ret = rmdir(dir); + } + + return ret; +} + +void Logger::ack_vehicle_command(orb_advert_t &vehicle_command_ack_pub, vehicle_command_s *cmd, uint32_t result) +{ + vehicle_command_ack_s vehicle_command_ack = { + .timestamp = hrt_absolute_time(), + .result_param2 = 0, + .command = cmd->command, + .result = (uint8_t)result, + .from_external = false, + .result_param1 = 0, + .target_system = cmd->source_system, + .target_component = cmd->source_component + }; + + if (vehicle_command_ack_pub == nullptr) { + vehicle_command_ack_pub = orb_advertise_queue(ORB_ID(vehicle_command_ack), &vehicle_command_ack, + vehicle_command_ack_s::ORB_QUEUE_LENGTH); + + } else { + orb_publish(ORB_ID(vehicle_command_ack), vehicle_command_ack_pub, &vehicle_command_ack); + } + +} + +} // namespace logger +} // namespace px4 diff --git a/e5/e5.4/dataprocess.m b/e5/e5.4/dataprocess.m new file mode 100644 index 0000000..475f7dd --- /dev/null +++ b/e5/e5.4/dataprocess.m @@ -0,0 +1,14 @@ +clear +close all +%@ filename = 'log001'; +if ~exist(filename,'file') + ulog2csv([filename,'.ulg'],filename); +end +csvname = ['./',filename,'/',filename,'_costom_attctrl_e5_0.csv']; +M = xlsread(csvname); +interval = 305:434; +timestamp = M(:,1)*1e-6;%s +pitch = M(:,3); + +figure +plot(timestamp(interval)-timestamp(interval(1)),pitch(interval)) \ No newline at end of file diff --git a/e5/e5.4/icon/F450.png b/e5/e5.4/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e5/e5.4/icon/F450.png differ diff --git a/e5/e5.4/icon/FlightGear.png b/e5/e5.4/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e5/e5.4/icon/FlightGear.png differ diff --git a/e5/e5.4/icon/pixhawk.png b/e5/e5.4/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e5/e5.4/icon/pixhawk.png differ diff --git a/e5/e5.4/ulog2csv.m b/e5/e5.4/ulog2csv.m new file mode 100644 index 0000000..671f487 --- /dev/null +++ b/e5/e5.4/ulog2csv.m @@ -0,0 +1,23 @@ +function ulog2csv(ulogfile, outputFileName) +%ulogfile : .ulg data file +%outputFileName +%usage��ulog2csv('log001.ulg','log001') +if exist(ulogfile,'file') + mkdir(outputFileName); + pathstr = pwd; + pathstr=strrep(pathstr,':',''); + pathstr=strrep(pathstr,'\','/'); + pathstr(1)=lower(pathstr(1)); + pathstr1=['/mnt/',pathstr]; + + command = ['C:\Windows\system32\bash.exe -c ','cd ~; ulog2csv ','-o ',pathstr1,'/',outputFileName,'/ ',pathstr1,'/',ulogfile,'']; + + status = system(command); + if status + error('Make sure this code executes in the same workspace as the data file!'); + else + disp('*******The conversion is complete!*******'); + end +else + error('file does not exist!'); +end diff --git a/e6/README.txt b/e6/README.txt new file mode 100644 index 0000000..0761b44 --- /dev/null +++ b/e6/README.txt @@ -0,0 +1,15 @@ + You can do basic experiment using the models in 'e6\e6.1'. + 'e6\e6.1\Sim' is used for Simulink simulation of a quadcopter and analyzing the channel decopling between the +control along obxb and obyb axes. + 'e6\e6.1\tune' is used for analyzing the performance of the control system. + 'e6\e6.1\HIL' is used for performing the HIL simulation. + + The Simulink model in 'e6\e6.2' is similar to that in 'e6\e6.1\tune', which is uesd for adjusting and analyzing +the performance of the position control system based on attitude contorl system. + + 'e6\e6.3' contains the position control model we design in analysis experiment. + + 'e6\e6.4' contains the file for flight test and flight data analysis.Before you open the file +'e6\e6.4\PosControl_FLY.slx', you'd better add custom logger data. + + \ No newline at end of file diff --git a/e6/e6.1/HIL/Init_control.m b/e6/e6.1/HIL/Init_control.m new file mode 100644 index 0000000..d906bc6 --- /dev/null +++ b/e6/e6.1/HIL/Init_control.m @@ -0,0 +1,57 @@ +%%% PosControl_HIL +clear +path( './icon/',path); +load vehicle_local_position.mat; +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; + +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE = 6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE = 6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; + +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; +%Position PID parameters +Kpxp = 1.0; +Kpyp = 1.0; +Kpzp = 4.0; +Kvxp = 2.5; Kvxi = 0.4; Kvxd = 0.01; +Kvyp = 2.5; Kvyi = 0.4; Kvyd = 0.01; +Kvzp = 0.45; Kvzi = 0.01; Kvzd = 0.005; +%integral saturation +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +Saturation_I_ah = 3.43; +Saturation_I_az = 5; + +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%Maximum control speed, m/s +MAX_CONTROL_VELOCITY_XY = 5; +MAX_CONTROL_VELOCITY_Z = 3; +%Throttle amplitude +MAX_MAN_THR = 0.9; +MIN_MAN_THR = 0.05; +%% run simulink model +PosControl_HIL + + + diff --git a/e6/e6.1/HIL/PosControl_HIL.slx b/e6/e6.1/HIL/PosControl_HIL.slx new file mode 100644 index 0000000..c39141e Binary files /dev/null and b/e6/e6.1/HIL/PosControl_HIL.slx differ diff --git a/e6/e6.1/HIL/icon/F450.png b/e6/e6.1/HIL/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e6/e6.1/HIL/icon/F450.png differ diff --git a/e6/e6.1/HIL/icon/FlightGear.png b/e6/e6.1/HIL/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e6/e6.1/HIL/icon/FlightGear.png differ diff --git a/e6/e6.1/HIL/icon/pixhawk.png b/e6/e6.1/HIL/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e6/e6.1/HIL/icon/pixhawk.png differ diff --git a/e6/e6.1/HIL/icon/vehicle_local_position.mat b/e6/e6.1/HIL/icon/vehicle_local_position.mat new file mode 100644 index 0000000..f1c34c0 Binary files /dev/null and b/e6/e6.1/HIL/icon/vehicle_local_position.mat differ diff --git a/e6/e6.1/Sim/FlightGear-Start.bat b/e6/e6.1/Sim/FlightGear-Start.bat new file mode 100644 index 0000000..25175da --- /dev/null +++ b/e6/e6.1/Sim/FlightGear-Start.bat @@ -0,0 +1,5 @@ +C: +cd C:\Program Files\FlightGear 2016.1.2 + +SET FG_ROOT=C:\Program Files\FlightGear 2016.1.2\data +.\\bin\fgfs --aircraft=F450 --fdm=null --native-fdm=socket,in,30,127.0.0.1,5502,udp --native-ctrls=socket,out,30,127.0.0.1,5505,udp --fog-fastest --disable-clouds --start-date-lat=2017:06:01:21:00:00 --disable-sound --in-air --disable-freeze --airport=KSF0 --runway=10L --altitude=0 --heading=0 --offset-distance=0 --offset-azimuth=0 --timeofday=noon diff --git a/e6/e6.1/Sim/Init_control.m b/e6/e6.1/Sim/Init_control.m new file mode 100644 index 0000000..b235de0 --- /dev/null +++ b/e6/e6.1/Sim/Init_control.m @@ -0,0 +1,55 @@ +%%% PosControl_Sim +clear +path('./icon/',path); +%Run the model initialization file icon/init.m +Init; + +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; + +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE = 6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE = 6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; +%Position PID parameters +Kpxp = 1.0; +Kpyp = 1.0; +Kpzp = 4.0; +Kvxp = 2.5; Kvxi = 0.4; Kvxd = 0.01; +Kvyp = 2.5; Kvyi = 0.4; Kvyd = 0.01; +Kvzp = 0.45; Kvzi = 0.01; Kvzd = 0.005; +%integral saturation +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +Saturation_I_ah = 3.43; +Saturation_I_az = 5; + +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%Maximum control speed, m/s +MAX_CONTROL_VELOCITY_XY = 5; +MAX_CONTROL_VELOCITY_Z = 3; +%Throttle amplitude +MAX_MAN_THR = 0.9; +MIN_MAN_THR = 0.05; +%% run simulink model +PosControl_Sim \ No newline at end of file diff --git a/e6/e6.1/Sim/PosControl_Sim.slx b/e6/e6.1/Sim/PosControl_Sim.slx new file mode 100644 index 0000000..79ed0ee Binary files /dev/null and b/e6/e6.1/Sim/PosControl_Sim.slx differ diff --git a/e6/e6.1/Sim/icon/F450.png b/e6/e6.1/Sim/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e6/e6.1/Sim/icon/F450.png differ diff --git a/e6/e6.1/Sim/icon/FlightGear.png b/e6/e6.1/Sim/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e6/e6.1/Sim/icon/FlightGear.png differ diff --git a/e6/e6.1/Sim/icon/Init.m b/e6/e6.1/Sim/icon/Init.m new file mode 100644 index 0000000..a6c5799 --- /dev/null +++ b/e6/e6.1/Sim/icon/Init.m @@ -0,0 +1,39 @@ +%Initial condition +ModelInit_PosE = [0, 0, 0]; %Initial position +ModelInit_VelB = [0, 0, 0]; %Initial velocity +ModelInit_AngEuler = [0, 0, 0]; %Initial Euler angle +ModelInit_RateB = [0, 0, 0]; %Initial angular velocity +ModelInit_Rads = 0; %Initial motor speed(rad/s) + +%UAV model parameter +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx, 0, 0;... + 0, ModelParam_uavJyy, 0;... + 0, 0, ModelParam_uavJzz]; +ModelParam_uavType = int8(3); %X-type quadrotor��refer to "SupportedVehicleTypes.pdf" for specific definitions +ModelParam_uavMotNumbs = int8(4); %Number of motors +ModelParam_uavR = 0.225; %Body radius(m) +ModelParam_uavCd = 0.055; %Damping coefficient(N/(m/s)^2) +ModelParam_uavCCm = [0.0035 0.0039 0.0034]; %Damping moment coefficient vector(N/(m/s)^2) + +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb = -141.4; %Motor speed-throttle curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) +ModelParam_motorMinThr = 0.05; %Motor throttle dead zone(kg.m^2) +%M=Cm*w^2 +ModelParam_rotorCm = 1.779e-07; %Rotor torque coefficient(kg.m^2) +%T=Ct**w^2 +ModelParam_rotorCt = 1.105e-05; %Rotor thrust coefficient(kg.m^2) + +%Environment Parameter +ModelParam_envGravityAcc = 9.8; %Gravity acceleration(m/s^2) +ModelParam_envLongitude = 116.259368300000; +ModelParam_envLatitude = 40.1540302; +ModelParam_GPSLatLong = [ModelParam_envLatitude ModelParam_envLongitude]; %Latitude and longitude +ModelParam_envAltitude = -41.5260009765625; %Reference height, down is positive +ModelParam_BusSampleRate = 0.001; %Model sampling rate \ No newline at end of file diff --git a/e6/e6.1/Sim/icon/SupportedVehicleTypes.pdf b/e6/e6.1/Sim/icon/SupportedVehicleTypes.pdf new file mode 100644 index 0000000..594b76a Binary files /dev/null and b/e6/e6.1/Sim/icon/SupportedVehicleTypes.pdf differ diff --git a/e6/e6.1/Sim/icon/pixhawk.png b/e6/e6.1/Sim/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e6/e6.1/Sim/icon/pixhawk.png differ diff --git a/e6/e6.1/tune/Init_control.m b/e6/e6.1/tune/Init_control.m new file mode 100644 index 0000000..ce78da2 --- /dev/null +++ b/e6/e6.1/tune/Init_control.m @@ -0,0 +1,62 @@ +%%% PosCtrl_tune +clear +path('./icon/',path); +%Run the model initialization file icon/init.m +Init; + +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; +%% Initial condition +ModelInit_PosE = [0, 0, -1000]; +ModelInit_VelB = [0, 0, 0]; +ModelInit_AngEuler = [0, 0, 0]; +ModelInit_RateB = [0, 0, 0]; +ModelInit_Rads = 557.142; + +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE = 6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE = 6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; +%Position PID parameters +Kpxp = 1.0; +Kpyp = 1.0; +Kpzp = 4.0; +Kvxp = 2.5; Kvxi = 0.4; Kvxd = 0.01; +Kvyp = 2.5; Kvyi = 0.4; Kvyd = 0.01; +Kvzp = 0.45; Kvzi = 0.01; Kvzd = 0.005; +%integral saturation +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +Saturation_I_ah = 3.43; +Saturation_I_az = 5; + +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%Maximum control speed, m/s +MAX_CONTROL_VELOCITY_XY = 5; +MAX_CONTROL_VELOCITY_Z = 3; +%Throttle amplitude +MAX_MAN_THR = 0.9; +MIN_MAN_THR = 0.05; +%% run simulink model +PosCtrl_tune + diff --git a/e6/e6.1/tune/PosCtrl_tune.slx b/e6/e6.1/tune/PosCtrl_tune.slx new file mode 100644 index 0000000..509868b Binary files /dev/null and b/e6/e6.1/tune/PosCtrl_tune.slx differ diff --git a/e6/e6.1/tune/icon/F450.png b/e6/e6.1/tune/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e6/e6.1/tune/icon/F450.png differ diff --git a/e6/e6.1/tune/icon/FlightGear.png b/e6/e6.1/tune/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e6/e6.1/tune/icon/FlightGear.png differ diff --git a/e6/e6.1/tune/icon/Init.m b/e6/e6.1/tune/icon/Init.m new file mode 100644 index 0000000..a6c5799 --- /dev/null +++ b/e6/e6.1/tune/icon/Init.m @@ -0,0 +1,39 @@ +%Initial condition +ModelInit_PosE = [0, 0, 0]; %Initial position +ModelInit_VelB = [0, 0, 0]; %Initial velocity +ModelInit_AngEuler = [0, 0, 0]; %Initial Euler angle +ModelInit_RateB = [0, 0, 0]; %Initial angular velocity +ModelInit_Rads = 0; %Initial motor speed(rad/s) + +%UAV model parameter +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx, 0, 0;... + 0, ModelParam_uavJyy, 0;... + 0, 0, ModelParam_uavJzz]; +ModelParam_uavType = int8(3); %X-type quadrotor��refer to "SupportedVehicleTypes.pdf" for specific definitions +ModelParam_uavMotNumbs = int8(4); %Number of motors +ModelParam_uavR = 0.225; %Body radius(m) +ModelParam_uavCd = 0.055; %Damping coefficient(N/(m/s)^2) +ModelParam_uavCCm = [0.0035 0.0039 0.0034]; %Damping moment coefficient vector(N/(m/s)^2) + +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb = -141.4; %Motor speed-throttle curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) +ModelParam_motorMinThr = 0.05; %Motor throttle dead zone(kg.m^2) +%M=Cm*w^2 +ModelParam_rotorCm = 1.779e-07; %Rotor torque coefficient(kg.m^2) +%T=Ct**w^2 +ModelParam_rotorCt = 1.105e-05; %Rotor thrust coefficient(kg.m^2) + +%Environment Parameter +ModelParam_envGravityAcc = 9.8; %Gravity acceleration(m/s^2) +ModelParam_envLongitude = 116.259368300000; +ModelParam_envLatitude = 40.1540302; +ModelParam_GPSLatLong = [ModelParam_envLatitude ModelParam_envLongitude]; %Latitude and longitude +ModelParam_envAltitude = -41.5260009765625; %Reference height, down is positive +ModelParam_BusSampleRate = 0.001; %Model sampling rate \ No newline at end of file diff --git a/e6/e6.1/tune/icon/SupportedVehicleTypes.pdf b/e6/e6.1/tune/icon/SupportedVehicleTypes.pdf new file mode 100644 index 0000000..594b76a Binary files /dev/null and b/e6/e6.1/tune/icon/SupportedVehicleTypes.pdf differ diff --git a/e6/e6.1/tune/icon/pixhawk.png b/e6/e6.1/tune/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e6/e6.1/tune/icon/pixhawk.png differ diff --git a/e6/e6.2/tune/Init_control.m b/e6/e6.2/tune/Init_control.m new file mode 100644 index 0000000..ce78da2 --- /dev/null +++ b/e6/e6.2/tune/Init_control.m @@ -0,0 +1,62 @@ +%%% PosCtrl_tune +clear +path('./icon/',path); +%Run the model initialization file icon/init.m +Init; + +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; +%% Initial condition +ModelInit_PosE = [0, 0, -1000]; +ModelInit_VelB = [0, 0, 0]; +ModelInit_AngEuler = [0, 0, 0]; +ModelInit_RateB = [0, 0, 0]; +ModelInit_Rads = 557.142; + +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE = 6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE = 6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; +%Position PID parameters +Kpxp = 1.0; +Kpyp = 1.0; +Kpzp = 4.0; +Kvxp = 2.5; Kvxi = 0.4; Kvxd = 0.01; +Kvyp = 2.5; Kvyi = 0.4; Kvyd = 0.01; +Kvzp = 0.45; Kvzi = 0.01; Kvzd = 0.005; +%integral saturation +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +Saturation_I_ah = 3.43; +Saturation_I_az = 5; + +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%Maximum control speed, m/s +MAX_CONTROL_VELOCITY_XY = 5; +MAX_CONTROL_VELOCITY_Z = 3; +%Throttle amplitude +MAX_MAN_THR = 0.9; +MIN_MAN_THR = 0.05; +%% run simulink model +PosCtrl_tune + diff --git a/e6/e6.2/tune/PosCtrl_tune.slx b/e6/e6.2/tune/PosCtrl_tune.slx new file mode 100644 index 0000000..2e0b959 Binary files /dev/null and b/e6/e6.2/tune/PosCtrl_tune.slx differ diff --git a/e6/e6.2/tune/icon/F450.png b/e6/e6.2/tune/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e6/e6.2/tune/icon/F450.png differ diff --git a/e6/e6.2/tune/icon/FlightGear.png b/e6/e6.2/tune/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e6/e6.2/tune/icon/FlightGear.png differ diff --git a/e6/e6.2/tune/icon/Init.m b/e6/e6.2/tune/icon/Init.m new file mode 100644 index 0000000..a6c5799 --- /dev/null +++ b/e6/e6.2/tune/icon/Init.m @@ -0,0 +1,39 @@ +%Initial condition +ModelInit_PosE = [0, 0, 0]; %Initial position +ModelInit_VelB = [0, 0, 0]; %Initial velocity +ModelInit_AngEuler = [0, 0, 0]; %Initial Euler angle +ModelInit_RateB = [0, 0, 0]; %Initial angular velocity +ModelInit_Rads = 0; %Initial motor speed(rad/s) + +%UAV model parameter +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx, 0, 0;... + 0, ModelParam_uavJyy, 0;... + 0, 0, ModelParam_uavJzz]; +ModelParam_uavType = int8(3); %X-type quadrotor��refer to "SupportedVehicleTypes.pdf" for specific definitions +ModelParam_uavMotNumbs = int8(4); %Number of motors +ModelParam_uavR = 0.225; %Body radius(m) +ModelParam_uavCd = 0.055; %Damping coefficient(N/(m/s)^2) +ModelParam_uavCCm = [0.0035 0.0039 0.0034]; %Damping moment coefficient vector(N/(m/s)^2) + +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb = -141.4; %Motor speed-throttle curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) +ModelParam_motorMinThr = 0.05; %Motor throttle dead zone(kg.m^2) +%M=Cm*w^2 +ModelParam_rotorCm = 1.779e-07; %Rotor torque coefficient(kg.m^2) +%T=Ct**w^2 +ModelParam_rotorCt = 1.105e-05; %Rotor thrust coefficient(kg.m^2) + +%Environment Parameter +ModelParam_envGravityAcc = 9.8; %Gravity acceleration(m/s^2) +ModelParam_envLongitude = 116.259368300000; +ModelParam_envLatitude = 40.1540302; +ModelParam_GPSLatLong = [ModelParam_envLatitude ModelParam_envLongitude]; %Latitude and longitude +ModelParam_envAltitude = -41.5260009765625; %Reference height, down is positive +ModelParam_BusSampleRate = 0.001; %Model sampling rate \ No newline at end of file diff --git a/e6/e6.2/tune/icon/SupportedVehicleTypes.pdf b/e6/e6.2/tune/icon/SupportedVehicleTypes.pdf new file mode 100644 index 0000000..594b76a Binary files /dev/null and b/e6/e6.2/tune/icon/SupportedVehicleTypes.pdf differ diff --git a/e6/e6.2/tune/icon/pixhawk.png b/e6/e6.2/tune/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e6/e6.2/tune/icon/pixhawk.png differ diff --git a/e7/README.txt b/e7/README.txt new file mode 100644 index 0000000..d4b249a --- /dev/null +++ b/e7/README.txt @@ -0,0 +1,9 @@ + This instruction package is used for Semi-Autonomous Control(SAC).The SAC is based on the attitude controller +in 'e5' and position control in 'e6'.The SAC involves three modes, that is stabilize mode, altitude hold mode and +loiter mode. + 'e7\e7.1' is used for Simulink simulation of a quadcopter and analyzing the characteristics of stabilize mode. + 'e7\e7.2' is used for analyzing the characteristics of the altitude hold mode. + 'e7\e7.3' is used for analyzing the characteristics of the loiter mode.And it contains a mode switch model in 'e7\e7.3\HIL'. + 'e7\e7.4' is uesd for flight test on mode switch. + + \ No newline at end of file diff --git a/e7/e7.1/HIL/Init_control.m b/e7/e7.1/HIL/Init_control.m new file mode 100644 index 0000000..f1b9d35 --- /dev/null +++ b/e7/e7.1/HIL/Init_control.m @@ -0,0 +1,55 @@ +%%% StabilizeControl_HIL +clear +path( './icon/',path); +load vehicle_local_position.mat; +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; + +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE = 6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE = 6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; + +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; +%Position PID parameters +Kpxp = 1.0; +Kpyp = 1.0; +Kpzp = 4.0; +Kvxp = 2.5; Kvxi = 0.4; Kvxd = 0.01; +Kvyp = 2.5; Kvyi = 0.4; Kvyd = 0.01; +Kvzp = 0.45; Kvzi = 0.01; Kvzd = 0.005; +%integral saturation +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +Saturation_I_ah = 3.43; +Saturation_I_az = 5; + +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%Maximum control speed, m/s +MAX_CONTROL_VELOCITY_XY = 5; +MAX_CONTROL_VELOCITY_Z = 3; +%Throttle amplitude +MAX_MAN_THR = 0.9; +MIN_MAN_THR = 0.05; +%% run simulink model +Stabilize_HIL + diff --git a/e7/e7.1/HIL/Stabilize_HIL.slx b/e7/e7.1/HIL/Stabilize_HIL.slx new file mode 100644 index 0000000..64e4264 Binary files /dev/null and b/e7/e7.1/HIL/Stabilize_HIL.slx differ diff --git a/e7/e7.1/HIL/icon/F450.png b/e7/e7.1/HIL/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e7/e7.1/HIL/icon/F450.png differ diff --git a/e7/e7.1/HIL/icon/FlightGear.png b/e7/e7.1/HIL/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e7/e7.1/HIL/icon/FlightGear.png differ diff --git a/e7/e7.1/HIL/icon/pixhawk.png b/e7/e7.1/HIL/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e7/e7.1/HIL/icon/pixhawk.png differ diff --git a/e7/e7.1/HIL/icon/vehicle_local_position.mat b/e7/e7.1/HIL/icon/vehicle_local_position.mat new file mode 100644 index 0000000..f1c34c0 Binary files /dev/null and b/e7/e7.1/HIL/icon/vehicle_local_position.mat differ diff --git a/e7/e7.1/Sim/FlightGear-Start.bat b/e7/e7.1/Sim/FlightGear-Start.bat new file mode 100644 index 0000000..25175da --- /dev/null +++ b/e7/e7.1/Sim/FlightGear-Start.bat @@ -0,0 +1,5 @@ +C: +cd C:\Program Files\FlightGear 2016.1.2 + +SET FG_ROOT=C:\Program Files\FlightGear 2016.1.2\data +.\\bin\fgfs --aircraft=F450 --fdm=null --native-fdm=socket,in,30,127.0.0.1,5502,udp --native-ctrls=socket,out,30,127.0.0.1,5505,udp --fog-fastest --disable-clouds --start-date-lat=2017:06:01:21:00:00 --disable-sound --in-air --disable-freeze --airport=KSF0 --runway=10L --altitude=0 --heading=0 --offset-distance=0 --offset-azimuth=0 --timeofday=noon diff --git a/e7/e7.1/Sim/Init_control.m b/e7/e7.1/Sim/Init_control.m new file mode 100644 index 0000000..2d14dc8 --- /dev/null +++ b/e7/e7.1/Sim/Init_control.m @@ -0,0 +1,61 @@ +%%% StabilizeControl_Sim +clear +path('./icon/',path); +%Run the model initialization file icon/init.m +Init; + +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; +%% Initial condition +ModelInit_PosE = [0, 0, -100]; +ModelInit_VelB = [0, 0, 0]; +ModelInit_AngEuler = [0, 0, 0]; +ModelInit_RateB = [0, 0, 0]; +ModelInit_Rads = 0; +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE = 6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE = 6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; + +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; +%Position PID parameters +Kpxp = 1.0; +Kpyp = 1.0; +Kpzp = 4.0; +Kvxp = 2.5; Kvxi = 0.4; Kvxd = 0.01; +Kvyp = 2.5; Kvyi = 0.4; Kvyd = 0.01; +Kvzp = 0.45; Kvzi = 0.01; Kvzd = 0.005; +%integral saturation +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +Saturation_I_ah = 3.43; +Saturation_I_az = 5; + +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%Maximum control speed, m/s +MAX_CONTROL_VELOCITY_XY = 5; +MAX_CONTROL_VELOCITY_Z = 3; +%Throttle amplitude +MAX_MAN_THR = 0.9; +MIN_MAN_THR = 0.05; +%% run simulink model +StabilizeControl_Sim \ No newline at end of file diff --git a/e7/e7.1/Sim/StabilizeControl_Sim.slx b/e7/e7.1/Sim/StabilizeControl_Sim.slx new file mode 100644 index 0000000..07f300b Binary files /dev/null and b/e7/e7.1/Sim/StabilizeControl_Sim.slx differ diff --git a/e7/e7.1/Sim/icon/F450.png b/e7/e7.1/Sim/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e7/e7.1/Sim/icon/F450.png differ diff --git a/e7/e7.1/Sim/icon/FlightGear.png b/e7/e7.1/Sim/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e7/e7.1/Sim/icon/FlightGear.png differ diff --git a/e7/e7.1/Sim/icon/Init.m b/e7/e7.1/Sim/icon/Init.m new file mode 100644 index 0000000..a6c5799 --- /dev/null +++ b/e7/e7.1/Sim/icon/Init.m @@ -0,0 +1,39 @@ +%Initial condition +ModelInit_PosE = [0, 0, 0]; %Initial position +ModelInit_VelB = [0, 0, 0]; %Initial velocity +ModelInit_AngEuler = [0, 0, 0]; %Initial Euler angle +ModelInit_RateB = [0, 0, 0]; %Initial angular velocity +ModelInit_Rads = 0; %Initial motor speed(rad/s) + +%UAV model parameter +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx, 0, 0;... + 0, ModelParam_uavJyy, 0;... + 0, 0, ModelParam_uavJzz]; +ModelParam_uavType = int8(3); %X-type quadrotor��refer to "SupportedVehicleTypes.pdf" for specific definitions +ModelParam_uavMotNumbs = int8(4); %Number of motors +ModelParam_uavR = 0.225; %Body radius(m) +ModelParam_uavCd = 0.055; %Damping coefficient(N/(m/s)^2) +ModelParam_uavCCm = [0.0035 0.0039 0.0034]; %Damping moment coefficient vector(N/(m/s)^2) + +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb = -141.4; %Motor speed-throttle curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) +ModelParam_motorMinThr = 0.05; %Motor throttle dead zone(kg.m^2) +%M=Cm*w^2 +ModelParam_rotorCm = 1.779e-07; %Rotor torque coefficient(kg.m^2) +%T=Ct**w^2 +ModelParam_rotorCt = 1.105e-05; %Rotor thrust coefficient(kg.m^2) + +%Environment Parameter +ModelParam_envGravityAcc = 9.8; %Gravity acceleration(m/s^2) +ModelParam_envLongitude = 116.259368300000; +ModelParam_envLatitude = 40.1540302; +ModelParam_GPSLatLong = [ModelParam_envLatitude ModelParam_envLongitude]; %Latitude and longitude +ModelParam_envAltitude = -41.5260009765625; %Reference height, down is positive +ModelParam_BusSampleRate = 0.001; %Model sampling rate \ No newline at end of file diff --git a/e7/e7.1/Sim/icon/SupportedVehicleTypes.pdf b/e7/e7.1/Sim/icon/SupportedVehicleTypes.pdf new file mode 100644 index 0000000..594b76a Binary files /dev/null and b/e7/e7.1/Sim/icon/SupportedVehicleTypes.pdf differ diff --git a/e7/e7.1/Sim/icon/pixhawk.png b/e7/e7.1/Sim/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e7/e7.1/Sim/icon/pixhawk.png differ diff --git a/e7/e7.2/HIL/HeightControl_HIL.slx b/e7/e7.2/HIL/HeightControl_HIL.slx new file mode 100644 index 0000000..83b5b3e Binary files /dev/null and b/e7/e7.2/HIL/HeightControl_HIL.slx differ diff --git a/e7/e7.2/HIL/Init_control.m b/e7/e7.2/HIL/Init_control.m new file mode 100644 index 0000000..dff4afb --- /dev/null +++ b/e7/e7.2/HIL/Init_control.m @@ -0,0 +1,55 @@ +%%% HeightControl_HIL +clear +path( './icon/',path); +load vehicle_local_position.mat; +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; + +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE = 6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE = 6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; + +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; +%Position PID parameters +Kpxp = 1.0; +Kpyp = 1.0; +Kpzp = 4.0; +Kvxp = 2.5; Kvxi = 0.4; Kvxd = 0.01; +Kvyp = 2.5; Kvyi = 0.4; Kvyd = 0.01; +Kvzp = 0.45; Kvzi = 0.01; Kvzd = 0.005; +%integral saturation +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +Saturation_I_ah = 3.43; +Saturation_I_az = 5; + +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%Maximum control speed, m/s +MAX_CONTROL_VELOCITY_XY = 5; +MAX_CONTROL_VELOCITY_Z = 3; +%Throttle amplitude +MAX_MAN_THR = 0.9; +MIN_MAN_THR = 0.05; +%% run simulink model +HeightControl_HIL + diff --git a/e7/e7.2/HIL/icon/F450.png b/e7/e7.2/HIL/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e7/e7.2/HIL/icon/F450.png differ diff --git a/e7/e7.2/HIL/icon/FlightGear.png b/e7/e7.2/HIL/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e7/e7.2/HIL/icon/FlightGear.png differ diff --git a/e7/e7.2/HIL/icon/pixhawk.png b/e7/e7.2/HIL/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e7/e7.2/HIL/icon/pixhawk.png differ diff --git a/e7/e7.2/HIL/icon/vehicle_local_position.mat b/e7/e7.2/HIL/icon/vehicle_local_position.mat new file mode 100644 index 0000000..f1c34c0 Binary files /dev/null and b/e7/e7.2/HIL/icon/vehicle_local_position.mat differ diff --git a/e7/e7.2/Sim/FlightGear-Start.bat b/e7/e7.2/Sim/FlightGear-Start.bat new file mode 100644 index 0000000..25175da --- /dev/null +++ b/e7/e7.2/Sim/FlightGear-Start.bat @@ -0,0 +1,5 @@ +C: +cd C:\Program Files\FlightGear 2016.1.2 + +SET FG_ROOT=C:\Program Files\FlightGear 2016.1.2\data +.\\bin\fgfs --aircraft=F450 --fdm=null --native-fdm=socket,in,30,127.0.0.1,5502,udp --native-ctrls=socket,out,30,127.0.0.1,5505,udp --fog-fastest --disable-clouds --start-date-lat=2017:06:01:21:00:00 --disable-sound --in-air --disable-freeze --airport=KSF0 --runway=10L --altitude=0 --heading=0 --offset-distance=0 --offset-azimuth=0 --timeofday=noon diff --git a/e7/e7.2/Sim/HeightControl_Sim.slx b/e7/e7.2/Sim/HeightControl_Sim.slx new file mode 100644 index 0000000..07df09d Binary files /dev/null and b/e7/e7.2/Sim/HeightControl_Sim.slx differ diff --git a/e7/e7.2/Sim/Init_control.m b/e7/e7.2/Sim/Init_control.m new file mode 100644 index 0000000..f4fa19c --- /dev/null +++ b/e7/e7.2/Sim/Init_control.m @@ -0,0 +1,61 @@ +%%% HeightControl_Sim +clear +path('./icon/',path); +%Run the model initialization file icon/init.m +Init; + +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; +%% Initial condition +ModelInit_PosE = [0, 0, -100]; +ModelInit_VelB = [0, 0, 0]; +ModelInit_AngEuler = [0, 0, 0]; +ModelInit_RateB = [0, 0, 0]; +ModelInit_Rads = 0; +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE = 6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE = 6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; + +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; +%Position PID parameters +Kpxp = 1.0; +Kpyp = 1.0; +Kpzp = 4.0; +Kvxp = 2.5; Kvxi = 0.4; Kvxd = 0.01; +Kvyp = 2.5; Kvyi = 0.4; Kvyd = 0.01; +Kvzp = 0.45; Kvzi = 0.01; Kvzd = 0.005; +%integral saturation +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +Saturation_I_ah = 3.43; +Saturation_I_az = 5; + +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%Maximum control speed, m/s +MAX_CONTROL_VELOCITY_XY = 5; +MAX_CONTROL_VELOCITY_Z = 3; +%Throttle amplitude +MAX_MAN_THR = 0.9; +MIN_MAN_THR = 0.05; +%% run simulink model +HeightControl_Sim \ No newline at end of file diff --git a/e7/e7.2/Sim/icon/F450.png b/e7/e7.2/Sim/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e7/e7.2/Sim/icon/F450.png differ diff --git a/e7/e7.2/Sim/icon/FlightGear.png b/e7/e7.2/Sim/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e7/e7.2/Sim/icon/FlightGear.png differ diff --git a/e7/e7.2/Sim/icon/Init.m b/e7/e7.2/Sim/icon/Init.m new file mode 100644 index 0000000..a6c5799 --- /dev/null +++ b/e7/e7.2/Sim/icon/Init.m @@ -0,0 +1,39 @@ +%Initial condition +ModelInit_PosE = [0, 0, 0]; %Initial position +ModelInit_VelB = [0, 0, 0]; %Initial velocity +ModelInit_AngEuler = [0, 0, 0]; %Initial Euler angle +ModelInit_RateB = [0, 0, 0]; %Initial angular velocity +ModelInit_Rads = 0; %Initial motor speed(rad/s) + +%UAV model parameter +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx, 0, 0;... + 0, ModelParam_uavJyy, 0;... + 0, 0, ModelParam_uavJzz]; +ModelParam_uavType = int8(3); %X-type quadrotor��refer to "SupportedVehicleTypes.pdf" for specific definitions +ModelParam_uavMotNumbs = int8(4); %Number of motors +ModelParam_uavR = 0.225; %Body radius(m) +ModelParam_uavCd = 0.055; %Damping coefficient(N/(m/s)^2) +ModelParam_uavCCm = [0.0035 0.0039 0.0034]; %Damping moment coefficient vector(N/(m/s)^2) + +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb = -141.4; %Motor speed-throttle curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) +ModelParam_motorMinThr = 0.05; %Motor throttle dead zone(kg.m^2) +%M=Cm*w^2 +ModelParam_rotorCm = 1.779e-07; %Rotor torque coefficient(kg.m^2) +%T=Ct**w^2 +ModelParam_rotorCt = 1.105e-05; %Rotor thrust coefficient(kg.m^2) + +%Environment Parameter +ModelParam_envGravityAcc = 9.8; %Gravity acceleration(m/s^2) +ModelParam_envLongitude = 116.259368300000; +ModelParam_envLatitude = 40.1540302; +ModelParam_GPSLatLong = [ModelParam_envLatitude ModelParam_envLongitude]; %Latitude and longitude +ModelParam_envAltitude = -41.5260009765625; %Reference height, down is positive +ModelParam_BusSampleRate = 0.001; %Model sampling rate \ No newline at end of file diff --git a/e7/e7.2/Sim/icon/SupportedVehicleTypes.pdf b/e7/e7.2/Sim/icon/SupportedVehicleTypes.pdf new file mode 100644 index 0000000..594b76a Binary files /dev/null and b/e7/e7.2/Sim/icon/SupportedVehicleTypes.pdf differ diff --git a/e7/e7.2/Sim/icon/pixhawk.png b/e7/e7.2/Sim/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e7/e7.2/Sim/icon/pixhawk.png differ diff --git a/e8/README.txt b/e8/README.txt new file mode 100644 index 0000000..290c615 --- /dev/null +++ b/e8/README.txt @@ -0,0 +1,12 @@ + This instruction package is used for failsafe logic design experiment.There are many types of failure for +multicopters, including communication breakdown, sensor failure, and propulsion system anomalies.Here we only +consider the loss of Radio Control which is the one of communication breakdown. + First, we realize the basic mode switch between the mannual mode and Return-to-Launch(RTL) as well as switch +between the mannual flight mode and the auto-landing mode in 'e8\e8.1'. + Next, an design example that a multicopter can switch between the RTL mode and auto-landing mode mannually is presented +in 'e8\e8.2'. + Finally, we design a logic to realize a multicoper that can return and land automatically under conditions where the +connection to the Radio Control transmitter is abnormal and the sim & HIL model is put in 'e8\e8.3', flight test model is +put in 'e8\e8.4'. + + \ No newline at end of file diff --git a/e8/e8.1/HIL/Init_control.m b/e8/e8.1/HIL/Init_control.m new file mode 100644 index 0000000..a013904 --- /dev/null +++ b/e8/e8.1/HIL/Init_control.m @@ -0,0 +1,60 @@ +%%% e8_1_HIL +clear +path( './icon/',path); +load vehicle_local_position.mat; + +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; + +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE =6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE =6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; + +Kp_YAW_ANGLE = 3; +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; + +%Position PID parameters +Kpxp = 1.0; +Kpyp = 1.0; +Kpzp = 4.0; +Kvxp = 3.0; Kvxi = 0.1; Kvxd = 0.01; +Kvyp = 3.0; Kvyi = 0.1; Kvyd = 0.01; +Kvzp = 0.45; Kvzi = 0.01; Kvzd = 0.005; + +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +Saturation_I_ah = 3.43; +Saturation_I_az = 5; + +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%Maximum navigation angle, used in position control to avoid large attitude angles +MAX_CONTROL_ANGLE_NAV_ROLL = 15; +MAX_CONTROL_ANGLE_NAV_PITCH = 15; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%Maximum control speed, m/s +MAX_CONTROL_VELOCITY_XY = 5; +MAX_CONTROL_VELOCITY_Z = 3; +%Throttle amplitude +MAX_MAN_THR = 0.9; +MIN_MAN_THR = 0.05; +%% run simulink model +e8_1_HIL \ No newline at end of file diff --git a/e8/e8.1/HIL/e8_1_HIL.slx b/e8/e8.1/HIL/e8_1_HIL.slx new file mode 100644 index 0000000..ab20d3e Binary files /dev/null and b/e8/e8.1/HIL/e8_1_HIL.slx differ diff --git a/e8/e8.1/HIL/icon/F450.png b/e8/e8.1/HIL/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e8/e8.1/HIL/icon/F450.png differ diff --git a/e8/e8.1/HIL/icon/FlightGear.png b/e8/e8.1/HIL/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e8/e8.1/HIL/icon/FlightGear.png differ diff --git a/e8/e8.1/HIL/icon/pixhawk.png b/e8/e8.1/HIL/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e8/e8.1/HIL/icon/pixhawk.png differ diff --git a/e8/e8.1/HIL/icon/vehicle_local_position.mat b/e8/e8.1/HIL/icon/vehicle_local_position.mat new file mode 100644 index 0000000..f1c34c0 Binary files /dev/null and b/e8/e8.1/HIL/icon/vehicle_local_position.mat differ diff --git a/e8/e8.1/Sim/FlightGear-Start.bat b/e8/e8.1/Sim/FlightGear-Start.bat new file mode 100644 index 0000000..25175da --- /dev/null +++ b/e8/e8.1/Sim/FlightGear-Start.bat @@ -0,0 +1,5 @@ +C: +cd C:\Program Files\FlightGear 2016.1.2 + +SET FG_ROOT=C:\Program Files\FlightGear 2016.1.2\data +.\\bin\fgfs --aircraft=F450 --fdm=null --native-fdm=socket,in,30,127.0.0.1,5502,udp --native-ctrls=socket,out,30,127.0.0.1,5505,udp --fog-fastest --disable-clouds --start-date-lat=2017:06:01:21:00:00 --disable-sound --in-air --disable-freeze --airport=KSF0 --runway=10L --altitude=0 --heading=0 --offset-distance=0 --offset-azimuth=0 --timeofday=noon diff --git a/e8/e8.1/Sim/Init_control.m b/e8/e8.1/Sim/Init_control.m new file mode 100644 index 0000000..76469f9 --- /dev/null +++ b/e8/e8.1/Sim/Init_control.m @@ -0,0 +1,61 @@ +%%% e8.1_Sim +clear +path('./icon/',path); +%Run the model initialization file icon/init.m +Init; + +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; + +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE =6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE =6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; + +Kp_YAW_ANGLE = 3; +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; + +%Position PID parameters +Kpxp = 1.0; +Kpyp = 1.0; +Kpzp = 4.0; +Kvxp = 3.0; Kvxi = 0.1; Kvxd = 0.01; +Kvyp = 3.0; Kvyi = 0.1; Kvyd = 0.01; +Kvzp = 0.45; Kvzi = 0.01; Kvzd = 0.005; + +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +Saturation_I_ah = 3.43; +Saturation_I_az = 5; + +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%Maximum navigation angle, used in position control to avoid large attitude angles +MAX_CONTROL_ANGLE_NAV_ROLL = 15; +MAX_CONTROL_ANGLE_NAV_PITCH = 15; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%Maximum control speed, m/s +MAX_CONTROL_VELOCITY_XY = 5; +MAX_CONTROL_VELOCITY_Z = 3; +%Throttle amplitude +MAX_MAN_THR = 0.9; +MIN_MAN_THR = 0.05; +%% run simulink model +e8_1_sim diff --git a/e8/e8.1/Sim/e8_1_sim.slx b/e8/e8.1/Sim/e8_1_sim.slx new file mode 100644 index 0000000..6d773e0 Binary files /dev/null and b/e8/e8.1/Sim/e8_1_sim.slx differ diff --git a/e8/e8.1/Sim/icon/F450.png b/e8/e8.1/Sim/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e8/e8.1/Sim/icon/F450.png differ diff --git a/e8/e8.1/Sim/icon/FlightGear.png b/e8/e8.1/Sim/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e8/e8.1/Sim/icon/FlightGear.png differ diff --git a/e8/e8.1/Sim/icon/Init.m b/e8/e8.1/Sim/icon/Init.m new file mode 100644 index 0000000..a6c5799 --- /dev/null +++ b/e8/e8.1/Sim/icon/Init.m @@ -0,0 +1,39 @@ +%Initial condition +ModelInit_PosE = [0, 0, 0]; %Initial position +ModelInit_VelB = [0, 0, 0]; %Initial velocity +ModelInit_AngEuler = [0, 0, 0]; %Initial Euler angle +ModelInit_RateB = [0, 0, 0]; %Initial angular velocity +ModelInit_Rads = 0; %Initial motor speed(rad/s) + +%UAV model parameter +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx, 0, 0;... + 0, ModelParam_uavJyy, 0;... + 0, 0, ModelParam_uavJzz]; +ModelParam_uavType = int8(3); %X-type quadrotor��refer to "SupportedVehicleTypes.pdf" for specific definitions +ModelParam_uavMotNumbs = int8(4); %Number of motors +ModelParam_uavR = 0.225; %Body radius(m) +ModelParam_uavCd = 0.055; %Damping coefficient(N/(m/s)^2) +ModelParam_uavCCm = [0.0035 0.0039 0.0034]; %Damping moment coefficient vector(N/(m/s)^2) + +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb = -141.4; %Motor speed-throttle curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) +ModelParam_motorMinThr = 0.05; %Motor throttle dead zone(kg.m^2) +%M=Cm*w^2 +ModelParam_rotorCm = 1.779e-07; %Rotor torque coefficient(kg.m^2) +%T=Ct**w^2 +ModelParam_rotorCt = 1.105e-05; %Rotor thrust coefficient(kg.m^2) + +%Environment Parameter +ModelParam_envGravityAcc = 9.8; %Gravity acceleration(m/s^2) +ModelParam_envLongitude = 116.259368300000; +ModelParam_envLatitude = 40.1540302; +ModelParam_GPSLatLong = [ModelParam_envLatitude ModelParam_envLongitude]; %Latitude and longitude +ModelParam_envAltitude = -41.5260009765625; %Reference height, down is positive +ModelParam_BusSampleRate = 0.001; %Model sampling rate \ No newline at end of file diff --git a/e8/e8.1/Sim/icon/SupportedVehicleTypes.pdf b/e8/e8.1/Sim/icon/SupportedVehicleTypes.pdf new file mode 100644 index 0000000..594b76a Binary files /dev/null and b/e8/e8.1/Sim/icon/SupportedVehicleTypes.pdf differ diff --git a/e8/e8.1/Sim/icon/pixhawk.png b/e8/e8.1/Sim/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e8/e8.1/Sim/icon/pixhawk.png differ diff --git a/e8/e8.2/HIL/Init_control.m b/e8/e8.2/HIL/Init_control.m new file mode 100644 index 0000000..889d38c --- /dev/null +++ b/e8/e8.2/HIL/Init_control.m @@ -0,0 +1,60 @@ +%%% e8_2_HIL +clear +path( './icon/',path); +load vehicle_local_position.mat; + +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; + +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE =6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE =6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; + +Kp_YAW_ANGLE = 3; +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; + +%Position PID parameters +Kpxp = 1.0; +Kpyp = 1.0; +Kpzp = 4.0; +Kvxp = 3.0; Kvxi = 0.1; Kvxd = 0.01; +Kvyp = 3.0; Kvyi = 0.1; Kvyd = 0.01; +Kvzp = 0.45; Kvzi = 0.01; Kvzd = 0.005; + +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +Saturation_I_ah = 3.43; +Saturation_I_az = 5; + +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%Maximum navigation angle, used in position control to avoid large attitude angles +MAX_CONTROL_ANGLE_NAV_ROLL = 15; +MAX_CONTROL_ANGLE_NAV_PITCH = 15; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%Maximum control speed, m/s +MAX_CONTROL_VELOCITY_XY = 5; +MAX_CONTROL_VELOCITY_Z = 3; +%Throttle amplitude +MAX_MAN_THR = 0.9; +MIN_MAN_THR = 0.05; +%% run simulink model +e8_2_HIL \ No newline at end of file diff --git a/e8/e8.2/HIL/e8_2_HIL.slx b/e8/e8.2/HIL/e8_2_HIL.slx new file mode 100644 index 0000000..cb6eaba Binary files /dev/null and b/e8/e8.2/HIL/e8_2_HIL.slx differ diff --git a/e8/e8.2/HIL/icon/F450.png b/e8/e8.2/HIL/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e8/e8.2/HIL/icon/F450.png differ diff --git a/e8/e8.2/HIL/icon/FlightGear.png b/e8/e8.2/HIL/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e8/e8.2/HIL/icon/FlightGear.png differ diff --git a/e8/e8.2/HIL/icon/pixhawk.png b/e8/e8.2/HIL/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e8/e8.2/HIL/icon/pixhawk.png differ diff --git a/e8/e8.2/HIL/icon/vehicle_local_position.mat b/e8/e8.2/HIL/icon/vehicle_local_position.mat new file mode 100644 index 0000000..f1c34c0 Binary files /dev/null and b/e8/e8.2/HIL/icon/vehicle_local_position.mat differ diff --git a/e8/e8.2/Sim/FlightGear-Start.bat b/e8/e8.2/Sim/FlightGear-Start.bat new file mode 100644 index 0000000..25175da --- /dev/null +++ b/e8/e8.2/Sim/FlightGear-Start.bat @@ -0,0 +1,5 @@ +C: +cd C:\Program Files\FlightGear 2016.1.2 + +SET FG_ROOT=C:\Program Files\FlightGear 2016.1.2\data +.\\bin\fgfs --aircraft=F450 --fdm=null --native-fdm=socket,in,30,127.0.0.1,5502,udp --native-ctrls=socket,out,30,127.0.0.1,5505,udp --fog-fastest --disable-clouds --start-date-lat=2017:06:01:21:00:00 --disable-sound --in-air --disable-freeze --airport=KSF0 --runway=10L --altitude=0 --heading=0 --offset-distance=0 --offset-azimuth=0 --timeofday=noon diff --git a/e8/e8.2/Sim/Init_control.m b/e8/e8.2/Sim/Init_control.m new file mode 100644 index 0000000..a9a0e8f --- /dev/null +++ b/e8/e8.2/Sim/Init_control.m @@ -0,0 +1,61 @@ +%%% e8.2_Sim +clear +path('./icon/',path); +%Run the model initialization file icon/init.m +Init; + +%Constant value +RAD2DEG = 57.2957795; +DEG2RAD = 0.0174533; +%throttle when UAV hover +THR_HOVER = 0.609; + +%% control parameter +%Attitude PID parameters +Kp_PITCH_ANGLE =6.5; +Kp_PITCH_AngleRate = 0.1; +Ki_PITCH_AngleRate = 0.02; +Kd_PITCH_AngleRate = 0.001; +Kp_ROLL_ANGLE =6.5; +Kp_ROLL_AngleRate = 0.1; +Ki_ROLL_AngleRate = 0.02; +Kd_ROLL_AngleRate = 0.001; + +Kp_YAW_ANGLE = 3; +Kp_YAW_AngleRate = 0.5; +Ki_YAW_AngleRate = 0.01; +Kd_YAW_AngleRate = 0.00; + +%Position PID parameters +Kpxp = 1.0; +Kpyp = 1.0; +Kpzp = 4.0; +Kvxp = 3.0; Kvxi = 0.1; Kvxd = 0.01; +Kvyp = 3.0; Kvyi = 0.1; Kvyd = 0.01; +Kvzp = 0.45; Kvzi = 0.01; Kvzd = 0.005; + +Saturation_I_RP_Max = 0.3; +Saturation_I_RP_Min = -0.3; +Saturation_I_Y_Max = 0.2; +Saturation_I_Y_Min = -0.2; +Saturation_I_ah = 3.43; +Saturation_I_az = 5; + +%max control angle,default 35deg +MAX_CONTROL_ANGLE_ROLL = 35; +MAX_CONTROL_ANGLE_PITCH = 35; +%Maximum navigation angle, used in position control to avoid large attitude angles +MAX_CONTROL_ANGLE_NAV_ROLL = 15; +MAX_CONTROL_ANGLE_NAV_PITCH = 15; +%max control angle rate,rad/s +MAX_CONTROL_ANGLE_RATE_PITCH = 220; +MAX_CONTROL_ANGLE_RATE_ROLL = 220; +MAX_CONTROL_ANGLE_RATE_Y = 200; +%Maximum control speed, m/s +MAX_CONTROL_VELOCITY_XY = 5; +MAX_CONTROL_VELOCITY_Z = 3; +%Throttle amplitude +MAX_MAN_THR = 0.9; +MIN_MAN_THR = 0.05; +%% run simulink model +e8_2_sim \ No newline at end of file diff --git a/e8/e8.2/Sim/e8_2_sim.slx b/e8/e8.2/Sim/e8_2_sim.slx new file mode 100644 index 0000000..72c5fd4 Binary files /dev/null and b/e8/e8.2/Sim/e8_2_sim.slx differ diff --git a/e8/e8.2/Sim/icon/F450.png b/e8/e8.2/Sim/icon/F450.png new file mode 100644 index 0000000..8ce3ace Binary files /dev/null and b/e8/e8.2/Sim/icon/F450.png differ diff --git a/e8/e8.2/Sim/icon/FlightGear.png b/e8/e8.2/Sim/icon/FlightGear.png new file mode 100644 index 0000000..faa3c1c Binary files /dev/null and b/e8/e8.2/Sim/icon/FlightGear.png differ diff --git a/e8/e8.2/Sim/icon/Init.m b/e8/e8.2/Sim/icon/Init.m new file mode 100644 index 0000000..a6c5799 --- /dev/null +++ b/e8/e8.2/Sim/icon/Init.m @@ -0,0 +1,39 @@ +%Initial condition +ModelInit_PosE = [0, 0, 0]; %Initial position +ModelInit_VelB = [0, 0, 0]; %Initial velocity +ModelInit_AngEuler = [0, 0, 0]; %Initial Euler angle +ModelInit_RateB = [0, 0, 0]; %Initial angular velocity +ModelInit_Rads = 0; %Initial motor speed(rad/s) + +%UAV model parameter +ModelParam_uavMass = 1.4; %Mass of UAV(kg) +ModelParam_uavJxx = 0.0211; +ModelParam_uavJyy = 0.0219; +ModelParam_uavJzz = 0.0366; +%Moment of inertia matrix +ModelParam_uavJ= [ModelParam_uavJxx, 0, 0;... + 0, ModelParam_uavJyy, 0;... + 0, 0, ModelParam_uavJzz]; +ModelParam_uavType = int8(3); %X-type quadrotor��refer to "SupportedVehicleTypes.pdf" for specific definitions +ModelParam_uavMotNumbs = int8(4); %Number of motors +ModelParam_uavR = 0.225; %Body radius(m) +ModelParam_uavCd = 0.055; %Damping coefficient(N/(m/s)^2) +ModelParam_uavCCm = [0.0035 0.0039 0.0034]; %Damping moment coefficient vector(N/(m/s)^2) + +ModelParam_motorCr = 1148; %Motor throttle-speed curve slope(rad/s) +ModelParam_motorWb = -141.4; %Motor speed-throttle curve constant term(rad/s) +ModelParam_motorT = 0.02; %Motor inertia time constant(s) +ModelParam_motorJm = 0.0001287; %Moment of inertia of motor rotor + propeller(kg.m^2) +ModelParam_motorMinThr = 0.05; %Motor throttle dead zone(kg.m^2) +%M=Cm*w^2 +ModelParam_rotorCm = 1.779e-07; %Rotor torque coefficient(kg.m^2) +%T=Ct**w^2 +ModelParam_rotorCt = 1.105e-05; %Rotor thrust coefficient(kg.m^2) + +%Environment Parameter +ModelParam_envGravityAcc = 9.8; %Gravity acceleration(m/s^2) +ModelParam_envLongitude = 116.259368300000; +ModelParam_envLatitude = 40.1540302; +ModelParam_GPSLatLong = [ModelParam_envLatitude ModelParam_envLongitude]; %Latitude and longitude +ModelParam_envAltitude = -41.5260009765625; %Reference height, down is positive +ModelParam_BusSampleRate = 0.001; %Model sampling rate \ No newline at end of file diff --git a/e8/e8.2/Sim/icon/SupportedVehicleTypes.pdf b/e8/e8.2/Sim/icon/SupportedVehicleTypes.pdf new file mode 100644 index 0000000..594b76a Binary files /dev/null and b/e8/e8.2/Sim/icon/SupportedVehicleTypes.pdf differ diff --git a/e8/e8.2/Sim/icon/pixhawk.png b/e8/e8.2/Sim/icon/pixhawk.png new file mode 100644 index 0000000..cb7ac80 Binary files /dev/null and b/e8/e8.2/Sim/icon/pixhawk.png differ