# HG changeset patch # User Emanuel Schuetze # Date 1409310611 -7200 # Node ID d92b1594e974babb7dafdccb077a2f196403919b # Parent 9ad1f18799fba8fa024937215a2ee07c736db770# Parent b3695a3399de9f9a0e51f5650a3b55fb1e9dea54 Merged. diff -r 9ad1f18799fb -r d92b1594e974 CMakeLists.txt --- a/CMakeLists.txt Fri Aug 29 13:09:40 2014 +0200 +++ b/CMakeLists.txt Fri Aug 29 13:10:11 2014 +0200 @@ -10,7 +10,7 @@ option(DO_RELEASE_BUILD "Build for a public release." OFF) option(ENABLE_PROFILING "Set to enable profiling." OFF) -option(USE_CURL "Use libcurl to download updates and certificate lists." UNIX) +option(USE_CURL "Use libcurl to download updates and certificate lists." ON) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/") diff -r 9ad1f18799fb -r d92b1594e974 INSTALL --- a/INSTALL Fri Aug 29 13:09:40 2014 +0200 +++ b/INSTALL Fri Aug 29 13:10:11 2014 +0200 @@ -62,19 +62,24 @@ make && make test && make install Libcurl: - wget http://curl.haxx.se/download/curl-7.37.1.tar.{gz,gz.asc} - gpg2 --verify curl-7.37.1.tar.gz.asc + wget http://curl.haxx.se/download/curl-7.37.1.tar.gz + a32492a38c10a097344892f5fd2041e54698cb909696852311b1161e4aa979f3 curl-7.37.1.tar.gz + tar -xf curl-7.37.1.tar.gz cd curl-7.37.1/ + mkdir build + cd build - ./configure --prefix=$YOURPREFIX \ + ../configure --prefix=$YOURPREFIX \ --without-nghttp2 --without-libidn --without-winidn --without-libssh2 \ --without-librtmp --without-libmetalink --without-axtls --without-nss \ --without-cyassl --without-ssl --without-gnutls --disable-gopher --disable-smtp \ --disable-imap --disable-pop3 --disable-tftp --disable-telnet --disable-dict \ - --disable-proxy --disable-rtsp --disable-ldaps --disable-ldap --disable-file \ + --disable-rtsp --disable-ldaps --disable-ldap --disable-file \ --disable-ftp --enable-http --enable-shared=no -enable-static=yes \ - --with-polarssl=$YOURPREFIX --without-ca-bundle --without-ca-path + --with-polarssl=$YOURPREFIX --without-ca-bundle --without-ca-path \ + --without-zlib + make && make install To compile the software you can use plain cmake. An out of source build is highly suggested. For build options see CMakeList.txt @@ -127,6 +132,21 @@ nice make -j`nproc` && \ make install +Change to the curl directory + cd ../../curl-7.37.1/ + mkdir build-i386 + cd build-i386 + CFLAGS="-fpic -m32" CPPFLAGS="-fpic -m32" ../configure --prefix=$YOURPREFIX/i386 \ + --without-nghttp2 --without-libidn --without-winidn --without-libssh2 \ + --without-librtmp --without-libmetalink --without-axtls --without-nss \ + --without-cyassl --without-ssl --without-gnutls --disable-gopher --disable-smtp \ + --disable-imap --disable-pop3 --disable-tftp --disable-telnet --disable-dict \ + --disable-rtsp --disable-ldaps --disable-ldap --disable-file \ + --disable-ftp --enable-http --enable-shared=no -enable-static=yes \ + --with-polarssl=$YOURPREFIX/i386 --without-ca-bundle --without-ca-path \ + --without-zlib + make && make install + Now for Trustbridge itself cd ../../trustbridge mkdir build-i386 @@ -190,11 +210,13 @@ Build the windows binaries: MXEPATH=$YOURPREFIX/win - git clone https://github.com/mxe/mxe.git $MXEPATH + git clone https://github.com/Intevation/mxe.git $MXEPATH cd $MXEPATH + git checkout trustbridge echo "MXE_TARGETS := i686-w64-mingw32.static" > settings.mk make polarssl make qtbase +(optional) make curl Workaround Qt CMake Bugs: find $MXEPATH/usr/i686-w64-mingw32.static/qt5/lib/cmake -name \*.cmake | \ @@ -202,10 +224,6 @@ sed -i 's/^_qt5gui_find_extra_libs.*//' \ $MXEPATH/usr/i686-w64-mingw32.static/qt5/lib/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake -Make an NSS build available in the MXE prefix: - # TODO -> Document how to build NSS,.. - cp -r $MXEPATH/usr/i686-w64-mingw32.static/ - Compile the software: cd trustbridge mkdir build-windows diff -r 9ad1f18799fb -r d92b1594e974 cinst/README --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/cinst/README Fri Aug 29 13:10:11 2014 +0200 @@ -0,0 +1,16 @@ +Tests +===== +Unit tests for this part are also done using the qttest library. +The related unit tests can be found in ui/tests + + +Manual Invocation of the certificate installation parts +======================================================= +There is a test list in ui/tests that you can use to manually +invoke the command. e.g.: + +./cinst list=/ui/tests/data/list-valid-signed.txt choices=uninstall + +A choices file lies next to it. +./cinst list=/ui/tests/data/list-valid-signed.txt \ + choices=/ui/tests/data/choices-example.txt diff -r 9ad1f18799fb -r d92b1594e974 cinst/main.c --- a/cinst/main.c Fri Aug 29 13:09:40 2014 +0200 +++ b/cinst/main.c Fri Aug 29 13:10:11 2014 +0200 @@ -261,6 +261,7 @@ } all_valid_certs = get_certs_from_list (certificate_list, list_len); + free (certificate_list); if (!all_valid_certs) { @@ -280,6 +281,7 @@ } #endif ret = write_stores_nss (NULL, all_valid_certs); + strv_free (all_valid_certs); return ret; } @@ -319,6 +321,8 @@ } } + strv_free (all_valid_certs); + #ifdef WIN32 ret = write_stores_win (to_install, to_remove); if (ret != 0) @@ -335,7 +339,6 @@ /* Make valgrind happy */ strv_free (to_install); strv_free (to_remove); - free (certificate_list); return 0; } diff -r 9ad1f18799fb -r d92b1594e974 cinst/mozilla.c --- a/cinst/mozilla.c Fri Aug 29 13:09:40 2014 +0200 +++ b/cinst/mozilla.c Fri Aug 29 13:10:11 2014 +0200 @@ -26,6 +26,10 @@ * This tool tries to find all NSS databases the user has * access to and to execute the instructions on all of them. * + * If the tool is executed with a UID of 0 or with admin privileges under + * windows it will not look into the user directories but instead try + * to write the system wide defaults. + * * If there are other processes accessing the databases the caller * has to ensure that those are terminated before this process is * executed. @@ -44,7 +48,7 @@ */ /** - * @brief Needs to eb defined to get strnlen() + * @brief Needs to be defined to get strnlen() */ #define _POSIX_C_SOURCE 200809L @@ -71,12 +75,17 @@ #include "portpath.h" #include "strhelp.h" #include "nss-secitemlist.h" +#include "util.h" #ifndef _WIN32 #define CONFDIRS ".mozilla", ".thunderbird" +/* Default installation directory of ubuntu 14.4 is respected */ +#define MOZILLA_DEFAULTS "/etc/thunderbird", "/etc/firefox" #define NSSSHARED ".pki/nssdb" +#define NSSSHARED_GLOBAL "/etc/pki/nssdb" #define TARGET_LINUX 1 #else +#define MOZILLA_DEFAULTS 0 #define CONFDIRS "Mozilla", "Thunderbird" #define NSSSHARED "" #define TARGET_LINUX 0 @@ -199,7 +208,7 @@ if (relative_path) xasprintf(&path, "%s/%s", inifile_dirname, value); else - xasprintf(&path, "%s", value); /* FIXME: LOOKS STUPID! */ + xasprintf(&path, "%s", value); if ((fqpath = port_realpath(path)) != NULL) { DEBUGPRINTF("Found profile path: '%s'\n", fqpath); @@ -294,6 +303,71 @@ } /** + * @brief Collect the default profile directories for mozilla software + * + * If the default directory is found but not the profiles subdirectory + * this will create the profiles subdirectory. + * + * @return NULL terminated array of strings containing the absolute path + * to the default profile directories. Needs to be freed by the caller. + */ +static char** +get_default_profile_dirs() +{ + char **retval = NULL; + + const char *confdirs[] = { MOZILLA_DEFAULTS, NULL }; + + for (int i=0; confdirs[i] != NULL; i++) + { + char * realpath = port_realpath(confdirs[i]); + char * profile_dir = NULL; + if (realpath == NULL) + { + DEBUGPRINTF ("Did not find directory: '%s'\n", confdirs[i]); + continue; + } + xasprintf(&profile_dir, "%s/profile", realpath); + if (port_isdir(profile_dir)) + { + DEBUGPRINTF("Found default directory: '%s'\n", profile_dir); + /* All is well */ + strv_append (&retval, profile_dir, strlen(profile_dir)); + xfree(profile_dir); + profile_dir = NULL; + continue; + } + else + { + /* Create the directory */ + if (port_fileexits(profile_dir)) + { + DEBUGPRINTF ("Path: '%s' is not a directory but it exists. Skipping.\n", + profile_dir); + xfree(profile_dir); + profile_dir = NULL; + continue; + } + else + { + /* Lets create it */ + if (!port_mkdir(profile_dir)) + { + ERRORPRINTF ("Failed to create directory: '%s'\n", profile_dir); + xfree(profile_dir); + profile_dir = NULL; + continue; + } + strv_append (&retval, profile_dir, strlen(profile_dir)); + xfree(profile_dir); + profile_dir = NULL; + } + } + } + return retval; +} + +/** * @brief Collect all mozilla profile directories of current user. * @return NULL terminated array of strings containing the absolute * path of the profile directories. The array needs to be freed by the @@ -304,6 +378,24 @@ { char **mozinis, **pdirs; char **alldirs = NULL; + + if (is_elevated()) + { +#ifndef _WIN32 + /* NSS Shared db does not exist under windows. */ + strv_append(&alldirs, NSSSHARED_GLOBAL, strlen(NSSSHARED_GLOBAL)); +#endif + pdirs = get_default_profile_dirs(); + if (pdirs != NULL) + { + for (int i=0; pdirs[i] != NULL; i++) + { + strv_append(&alldirs, pdirs[i], strlen(pdirs[i])); + } + strv_free(pdirs); + } + return alldirs; + } /* Search Mozilla/Firefox/Thunderbird profiles */ if ((mozinis = get_profile_inis()) != NULL) { @@ -363,6 +455,9 @@ DEBUGPRINTF("Found certificate \"%s\"\n", name); } + /* According to valgrind this leaks memory in the list. + We could not find API documentation to better free this + so we accept the leakage here in case of debug. */ CERT_DestroyCertList(list); NSS_Shutdown(); } diff -r 9ad1f18799fb -r d92b1594e974 cinst/nss-secitemlist.c --- a/cinst/nss-secitemlist.c Fri Aug 29 13:09:40 2014 +0200 +++ b/cinst/nss-secitemlist.c Fri Aug 29 13:10:11 2014 +0200 @@ -29,6 +29,8 @@ { oldlelt = *list; *list = oldlelt->next; + if (oldlelt->item->data) + free(oldlelt->item->data); free(oldlelt->item); free(oldlelt); } diff -r 9ad1f18799fb -r d92b1594e974 cinst/nssstore_linux.c --- a/cinst/nssstore_linux.c Fri Aug 29 13:09:40 2014 +0200 +++ b/cinst/nssstore_linux.c Fri Aug 29 13:10:11 2014 +0200 @@ -93,6 +93,7 @@ argv[0] = xmalloc (exe_path_len + 1); ret = snprintf(argv[0], exe_path_len + 1, "%s%s", inst_dir, NSS_PROCESS_NAME); + xfree (inst_dir); if (ret < 0 || (size_t) ret != exe_path_len) { ERRORPRINTF ("Error setting executable variable.\n"); @@ -200,18 +201,19 @@ { struct passwd *usr_it = NULL; uid_t my_uid = geteuid(); + pid_t childprocess = -1; + int status = -1; if (my_uid != 0) { /* Running as a user */ char *homedir = getenv ("HOME"); - pid_t childprocess = -1; /* Only one child for single user installation */ - int status = -1; if (!homedir) { ERRORPRINTF ("Failed to find home directory\n"); } + /* Only one child for single user installation */ childprocess = start_procces_for_user (to_install, to_remove, my_uid, getgid(), homedir); @@ -231,6 +233,23 @@ return 0; } + /* Start once as root to install in the system default directories. */ + childprocess = start_procces_for_user (to_install, to_remove, + my_uid, getgid(), getenv ("HOME")); + if (childprocess == -1) + { + ERRORPRINTF ("Failed to start default profile installation!\n"); + return -1; + } + + /* Wait until the default profile directories are done. */ + childprocess = waitpid (childprocess, &status, 0); + if (childprocess == -1 || !WIFEXITED(status)) + { + ERRORPRINTF ("Child process did not finish.\n"); + return -1; + } + setpwent(); while ((usr_it = getpwent ()) != NULL) diff -r 9ad1f18799fb -r d92b1594e974 common/portpath.c --- a/common/portpath.c Fri Aug 29 13:09:40 2014 +0200 +++ b/common/portpath.c Fri Aug 29 13:10:11 2014 +0200 @@ -36,8 +36,20 @@ #endif } +bool +port_mkdir(const char *path) +{ +#ifndef _WIN32 + return mkdir(path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) == 0; +#else + /* TODO */ + printf("Should make path: %s\n", path); + return false; +#endif +} + char * -port_realpath(char *path) +port_realpath(const char *path) { #ifndef _WIN32 return realpath(path, NULL); diff -r 9ad1f18799fb -r d92b1594e974 common/portpath.h --- a/common/portpath.h Fri Aug 29 13:09:40 2014 +0200 +++ b/common/portpath.h Fri Aug 29 13:10:11 2014 +0200 @@ -35,7 +35,7 @@ * @param[in] path the original pathname * @returns a pointer to the resolved path or NULL on error */ -char *port_realpath(char *path); +char *port_realpath(const char *path); /** * @brief test if a file exists @@ -55,4 +55,14 @@ */ bool port_isdir(char *path); +/** + * @brief create a directory + * @details uses a platform specific mkdir / access rights setup + * to create a directory that is world readable and + * writable by the current user / group + * @param[in] path the path to the directory + * @returns true if the directory was created + */ +bool port_mkdir(const char *path); + #endif diff -r 9ad1f18799fb -r d92b1594e974 packaging/create-dist-package.sh.in --- a/packaging/create-dist-package.sh.in Fri Aug 29 13:09:40 2014 +0200 +++ b/packaging/create-dist-package.sh.in Fri Aug 29 13:10:11 2014 +0200 @@ -27,10 +27,10 @@ cd @CMAKE_SOURCE_DIR@/build-i386 echo "Building x86 package" make -j`nproc` -/bin/bash packaging/linux-createpackage.sh +/bin/bash packaging/linux-createpackage.sh i386 cd @CMAKE_BINARY_DIR@ echo "Building amd64 package" -/bin/bash packaging/linux-createpackage.sh +/bin/bash packaging/linux-createpackage.sh x86_64 mkdir -p $TMPDIR/linux mkdir -p $TMPDIR/windows mv @CMAKE_BINARY_DIR@/TrustBridge-@PROJECT_VERSION@.sh \ @@ -40,6 +40,8 @@ cp @CMAKE_SOURCE_DIR@/build-windows/ui/trustbridge.exe $TMPDIR/windows cp @CMAKE_SOURCE_DIR@/build-windows/cinst/cinst.exe $TMPDIR/windows cp @CMAKE_SOURCE_DIR@/build-windows/cinst/mozilla.exe $TMPDIR/windows +cp -r @CMAKE_BINARY_DIR@/manuals/help-manual/html $TMPDIR/windows/doc + cp @CMAKE_SOURCE_DIR@/packaging/filelist.nsh $TMPDIR cp @CMAKE_SOURCE_DIR@/packaging/trustbridge.nsi $TMPDIR cp -r @CMAKE_SOURCE_DIR@/packaging/resources $TMPDIR/resources diff -r 9ad1f18799fb -r d92b1594e974 packaging/filelist.nsh --- a/packaging/filelist.nsh Fri Aug 29 13:09:40 2014 +0200 +++ b/packaging/filelist.nsh Fri Aug 29 13:10:11 2014 +0200 @@ -11,3 +11,4 @@ File "${files_dir}${path_sep}cinst.exe" File "${files_dir}${path_sep}trustbridge.exe" File "${files_dir}${path_sep}mozilla.exe" +File /r /x .buildinfo "${files_dir}${path_sep}doc" diff -r 9ad1f18799fb -r d92b1594e974 packaging/linux-createpackage.sh.in --- a/packaging/linux-createpackage.sh.in Fri Aug 29 13:09:40 2014 +0200 +++ b/packaging/linux-createpackage.sh.in Fri Aug 29 13:10:11 2014 +0200 @@ -9,12 +9,20 @@ TMPDIR=$(mktemp -d) TMPSHAR=$(mktemp "@CMAKE_BINARY_DIR@/shar.XXXXXXXXXX") +ARCH="$1" + +if [ "$ARCH" != "i386" -a "$ARCH" != "x86_64" ]; then + echo "Usage $0 " + echo "with archtiecture either i386 or x86_64" +fi + INSTALLER="@CMAKE_BINARY_DIR@/TrustBridge-@PROJECT_VERSION@.sh" EXEFILES=("@CMAKE_BINARY_DIR@/cinst/cinst" "@CMAKE_BINARY_DIR@/cinst/mozilla" "@CMAKE_BINARY_DIR@/ui/trustbridge" "@CMAKE_BINARY_DIR@/ui/trustbridge-tray-starter.sh") + ICON="@CMAKE_SOURCE_DIR@/ui/img/logo-128.png" HELPFILES=$(find @CMAKE_BINARY_DIR@/manuals/help-manual/html \ -maxdepth 1 -type f -printf "%p \n") @@ -74,6 +82,7 @@ sed -i "s/###HELPNAMES_SOURCES###/${helpnames_sources}/" "$INSTALLER" sed -i "s/###HELPNAMES_STATIC###/${helpnames_static}/" "$INSTALLER" sed -i "s/###HELPNAMES_IMG###/${helpnames_img}/" $INSTALLER +sed -i "s/###ARCH###/${ARCH}/" $INSTALLER chmod +x "$INSTALLER" echo "Signing" diff -r 9ad1f18799fb -r d92b1594e974 packaging/linux-installer.inc.in --- a/packaging/linux-installer.inc.in Fri Aug 29 13:09:40 2014 +0200 +++ b/packaging/linux-installer.inc.in Fri Aug 29 13:10:11 2014 +0200 @@ -20,6 +20,7 @@ HELPNAMES_SOURCES="###HELPNAMES_SOURCES###" HELPNAMES_STATIC="###HELPNAMES_STATIC###" HELPNAMES_IMG="###HELPNAMES_IMG###" +ARCH="###ARCH###" declare -A instcfg oldinstcfg declare inst_default_prefix instdata_path instcfg_path instcfg_file @@ -177,6 +178,7 @@ fi instcfg_file="${instcfg_path}/${INSTCFGNAME}" extra_bin_path=`mktemp --tmpdir -d tmpbin.XXXXXXXXXX` + HOST_ARCH=$(uname -m) } cleanup() @@ -501,11 +503,27 @@ ------------------------------------------------------------------------ TrustBridge - Installer - Version ${instcfg[VERSION]} (Testversion) + Version ${instcfg[VERSION]} - ${ARCH} (Testversion) ------------------------------------------------------------------------ EOF +if [ "$ARCH" == "x86_64" -a "$ARCH" != "$HOST_ARCH" ]; then + getxt "It appears your system architecture is %s.\n" "$HOST_ARCH" + getxt "This installer is for 64 bit systems.\n" + getxt "Really install TrustBridge for '%s' systems? [y/n]\n" "${ARCH}" + yorn || exit 0 +fi + +if [ "$ARCH" == "i386" ]; then + if [[ "$HOST_ARCH" != *86 ]]; then + getxt "It appears your system architecture is %s.\n" "$HOST_ARCH" + getxt "This installer is for 32 bit systems.\n" + getxt "Really install TrustBridge for '%s' systems? [y/n]\n" "${ARCH}" + yorn || exit 0 + fi +fi + if [ $DEINSTALL -eq 1 ] ; then deinstall # Stop after deinstallation: diff -r 9ad1f18799fb -r d92b1594e974 packaging/linux-installer.l10n-de --- a/packaging/linux-installer.l10n-de Fri Aug 29 13:09:40 2014 +0200 +++ b/packaging/linux-installer.l10n-de Fri Aug 29 13:10:11 2014 +0200 @@ -52,4 +52,8 @@ ["creating installation directory ...\n"]="lege das Installations-Verzeichnis an ...\n" ["to update the current installation.\n"]="um die vorhandene Installation zu aktualisieren.\n" ["unpacking files ...\n"]="Entpacke Dateien ...\n" + ["It appears your system architecture is %s.\n"]="Dieses System scheint eine %s Architektur zu besitzen.\n" + ["This installer is for 64 bit systems.\n"]="Dieses Installationspaket ist für 64 bit Systeme.\n" + ["This installer is for 32 bit systems.\n"]="Dieses Installationspaket ist für 32 bit Systeme.\n" + ["Really install TrustBridge for '%s' systems? [y/n]\n"]="Soll TrustBridge für '%s' wirklich installiert werden? [j/n]\n" ) diff -r 9ad1f18799fb -r d92b1594e974 packaging/win-createpackage.sh.in --- a/packaging/win-createpackage.sh.in Fri Aug 29 13:09:40 2014 +0200 +++ b/packaging/win-createpackage.sh.in Fri Aug 29 13:10:11 2014 +0200 @@ -14,8 +14,10 @@ TMPINST=$(mktemp) EXEFILES=$(find . -name cinst.exe -o -name trustbridge.exe -o -name mozilla.exe) +HELPDIR=@CMAKE_BINARY_DIR@/manuals/help-manual/html cp $EXEFILES $TMPDIR +cp -r $HELPDIR $TMPDIR/doc EST_SIZE=$(du -s $TMPDIR | cut -f 1) diff -r 9ad1f18799fb -r d92b1594e974 ui/CMakeLists.txt --- a/ui/CMakeLists.txt Fri Aug 29 13:09:40 2014 +0200 +++ b/ui/CMakeLists.txt Fri Aug 29 13:10:11 2014 +0200 @@ -28,7 +28,7 @@ if (${CURL_FOUND} AND ${USE_CURL}) set(UICOMMON_SOURCES ${UICOMMON_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/sslconnection_curl.cpp) - add_definitions(-DUSE_CURL) + add_definitions(-DUSE_CURL -DCURL_STATICLIB) elseif (${USE_CURL}) MESSAGE(FATAL_ERROR "libcurl not found but usage of curl is requested.") endif() @@ -52,6 +52,7 @@ ${CMAKE_CURRENT_SOURCE_DIR}/textoverlaybutton.cpp ${CMAKE_CURRENT_SOURCE_DIR}/taskscheduler.cpp ${CMAKE_CURRENT_SOURCE_DIR}/trayicon.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/proxysettingsdlg.cpp ${CERTIFICATELIST_SOURCES} ${DOWNLOADER_SOURCES} ) @@ -101,10 +102,10 @@ get_filename_component(_qtpath ${_loc} PATH) set(WINDOWS_EXTRA_LIBS -L${_qtpath} - -lwinspool -lshlwapi -lfreetype -lbz2 -lpng16 + -lwinspool -lshlwapi -lQt5PlatformSupport -lQt5Gui -lcomdlg32 -loleaut32 -limm32 -lwinmm - -lglu32 -lopengl32 -lgdi32 -ljpeg -lpng -lQt5Core -lole32 -lmstask -luuid -lws2_32 - -ladvapi32 -lshell32 -luser32 -lkernel32 -lz -lsicuin -lsicuuc -lsicudt -lpcre16) + -lglu32 -lopengl32 -lgdi32 -lQt5Core -lole32 -lmstask -luuid -lws2_32 + -ladvapi32 -lshell32 -luser32 -lkernel32 -lpcre16) set(EXTRA_STATIC_LIBS Qt5::QWindowsIntegrationPlugin ${WINDOWS_EXTRA_LIBS} -lwinhttp -lcrypt32) @@ -205,7 +206,6 @@ ui_common trustbridge_common ${CURL_LIBRARIES} - z ${POLARSSL_LIBRARIES} ${EXTRA_STATIC_LIBS} ${PROFILING_LIBS}) diff -r 9ad1f18799fb -r d92b1594e974 ui/certificates/geotrust.der Binary file ui/certificates/geotrust.der has changed diff -r 9ad1f18799fb -r d92b1594e974 ui/certs.qrc --- a/ui/certs.qrc Fri Aug 29 13:09:40 2014 +0200 +++ b/ui/certs.qrc Fri Aug 29 13:10:11 2014 +0200 @@ -1,5 +1,6 @@ certificates/intevation.de.der + certificates/geotrust.der diff -r 9ad1f18799fb -r d92b1594e974 ui/downloader.cpp --- a/ui/downloader.cpp Fri Aug 29 13:09:40 2014 +0200 +++ b/ui/downloader.cpp Fri Aug 29 13:10:11 2014 +0200 @@ -17,6 +17,7 @@ #include #include #include +#include #include #include @@ -50,6 +51,18 @@ { #ifdef USE_CURL mSSLConnection = new SSLConnectionCurl(url, certificate); +/* Set up Proxy support. */ + QSettings settings; + QString settingsProxy = settings.value("ProxyURL").toString(); + if (settingsProxy.isEmpty()) { + QByteArray envProxy = qgetenv("http_proxy"); + if (envProxy.size()) { + settingsProxy = QString::fromLocal8Bit(envProxy); + } + } + if (!settingsProxy.isEmpty()) { + mSSLConnection->setProxy(QUrl(settingsProxy)); + } #else mSSLConnection = new SSLConnectionBare(url, certificate); #endif diff -r 9ad1f18799fb -r d92b1594e974 ui/icons.qrc --- a/ui/icons.qrc Fri Aug 29 13:09:40 2014 +0200 +++ b/ui/icons.qrc Fri Aug 29 13:10:11 2014 +0200 @@ -1,6 +1,7 @@ img/tray_22.png + img/tray_48.png img/logo.png img/list-add.png img/list-remove.png @@ -22,5 +23,8 @@ img/trash-empty.png img/update-list.png img/red-circle.png + img/preferences-network_16.png + img/preferences-network_64.png + img/show-help_16.png diff -r 9ad1f18799fb -r d92b1594e974 ui/img/preferences-network_16.png Binary file ui/img/preferences-network_16.png has changed diff -r 9ad1f18799fb -r d92b1594e974 ui/img/preferences-network_64.png Binary file ui/img/preferences-network_64.png has changed diff -r 9ad1f18799fb -r d92b1594e974 ui/img/show-help_16.png Binary file ui/img/show-help_16.png has changed diff -r 9ad1f18799fb -r d92b1594e974 ui/img/tray_48.png Binary file ui/img/tray_48.png has changed diff -r 9ad1f18799fb -r d92b1594e974 ui/l10n/trustbridge_de_DE.ts --- a/ui/l10n/trustbridge_de_DE.ts Fri Aug 29 13:09:40 2014 +0200 +++ b/ui/l10n/trustbridge_de_DE.ts Fri Aug 29 13:10:11 2014 +0200 @@ -106,276 +106,296 @@ MainWindow - - + + An updated certificate list is available. - + Click here to install. - - + + An update for %1 is available. - + Click here to download and install the update. - - + + Check for Updates - - + + Quit - + TrustBridge - + Version: - + TrustBridge is a root certificate installer for Windows and GNU/Linux.<br/> - + The root certificate lists are managed by the German <a href="https://www.bsi.bund.de">Federal Office for Information Security (BSI)</a>.<br/><br/> - + The software was developed by the companies <a href="http://www.intevation.de">Intevation GmbH</a> and <a href="http://www.dn-systems.de">DN-Systems GmbH</a>, <br> contracted by the German Federal Office for Information Security (BSI).<br/><br/> - + TrustBridge is Free Software licensed under GNU GPL v2+.<br/><br/>Copyright (C) 2014 by Bundesamt für Sicherheit in der Informationstechnik - - + + Show Help + + + + + Proxy settings + + + + + Certificates unchanged - + Installed certificates from: - + TrustBridge Version: - - + + Last successful update check: - + No connection with the updateserver. - + Update - - + + There are currently no changes for your certificate stores. - - - Quit without saving - - - - - - Install certificates again - - - - + + Quit without saving + + + + + + Install certificates again + + + + + Install new trusted certificates (%1/%2) - - - + + + Details - - - - - - - - - + + + + + + + + + Show details - - + + Remove revoked certificates (%1/%2) - - - - + + + + Manually changed certificates (%1) - + Trusted certificates - + The following list of trusted root certificates is managed by the BSI. The BSI validates independently the authenticity, security and actuality of these certificates. - + Please choose the certificates you want to trust or untrust. TrustBridge will install these certificates for your secure communication for email and internet. - + Revoked certificates - + Certificates can be corrupted or stolen and misused in many ways. Therefore the BSI recommends to remove all revoked certificates from your system. - + The following unsecure certificates were revoked by the BSI. Already uninstalled certificates cannot be reinstalled. It is recommended that you select all certificates to uninstall if you still have revoked certificates installed. - + Trust in your digital communication - + Updates - + Trusted certificates - + Revoked certificates - + Information and help - + You should apply the following, recommended changes to your certificate stores. - + You can apply the following, changes to your certificate stores. - + Changes to certificate stores (%1) - + Apply changes - + install - + ignore - + Error executing update - - Installation with standard user account. + + Installation with standard user account - - Windows will now ask you to confirm each root certificate modification because TrustBridge does not have the necessary privileges to install root certificates into the Windows certificate store silently. + + Windows will now ask you to confirm qeach root certificate modification because TrustBridge does not have the necessary privileges to install root certificates into the Windows certificate store silently. - + + Error! + + + + + Failed to find the manual + + + + Installing certificates... - - - + + + Hide details - + Sucessfully checked for updates. @@ -394,6 +414,44 @@ + ProxySettingsDlg + + + Proxy server settings + + + + + Please enter the proxy server to use in the field below. + + + + + The URL can follow the scheme: + + + + + &lt;username&gt;:&lt;password&gt;@&lt;hostname&gt;:&lt;port&gt; + + + + + Proxy Server: + + + + + &Save + + + + + &Cancel + + + + QObject @@ -404,12 +462,12 @@ TrayIcon - + Install update - + Remind me later diff -r 9ad1f18799fb -r d92b1594e974 ui/mainwindow.cpp --- a/ui/mainwindow.cpp Fri Aug 29 13:09:40 2014 +0200 +++ b/ui/mainwindow.cpp Fri Aug 29 13:10:11 2014 +0200 @@ -43,6 +43,7 @@ #include "processhelp.h" #include "processwaitdialog.h" #include "trayicon.h" +#include "proxysettingsdlg.h" // The amount of time in minutes stay silent if we have // something to say @@ -133,10 +134,6 @@ void MainWindow::messageClicked() { - if (mCurState == NewListAvailable) { - show(); - } - if (mCurState == NewSoftwareAvailable) { hide(); verifySWData(); @@ -148,6 +145,8 @@ } installNewSW(swFileName, mSettings.value("Software/availableDate").toDateTime()); + } else { + show(); } } @@ -156,7 +155,15 @@ if (mCurMessage.isEmpty()) { return; } - if (mCurState == NewSoftwareAvailable || !isVisible()) { + + if (!mTrayIcon->isVisible() && !mTrayIcon->isAlternative()) { + mTrayIcon->show(); + /* When the message is shown before the tray icon is fully visble + * and becoming visible may be delayed on some desktop environments + * the message will pop up somehere on the screen and not over + * the trayicon. So we delay here.*/ + QTimer::singleShot(2000, this, SLOT(showMessage())); + } else if (mCurState == NewSoftwareAvailable || !isVisible()) { mTrayIcon->showMessage(QApplication::applicationName(), mCurMessage, QSystemTrayIcon::Information, 10000); mMessageTimer->start(); // Restart the timer so that we don't spam @@ -445,6 +452,7 @@ /* TODO logging and handle error according to a plan */ syslog_error_printf ("Failed to check for updates: %s", message.toUtf8().constData()); mCurMessage = message; + mTrayIcon->show(); showMessage(); setState(TransferError); } @@ -460,6 +468,7 @@ void MainWindow::createTrayIcon() { QIcon trayImg(":/img/tray_22.png"); + trayImg.addFile(":/img/tray_48.png", QSize(48,48)); mTrayMenu = new QMenu(this); mTrayMenu->addAction(mCheckUpdates); @@ -470,7 +479,6 @@ mTrayIcon->setIcon(trayImg); setWindowIcon(trayImg); - mTrayIcon->show(); mTrayIcon->setToolTip(tr("TrustBridge")); connect(mTrayIcon, SIGNAL(messageClicked()), this, SLOT(messageClicked())); @@ -526,8 +534,15 @@ QHBoxLayout *helpButtonLayout = new QHBoxLayout(); QPushButton *helpButton = new QPushButton(tr("Show Help")); + helpButton->setIcon(QIcon(":/img/show-help_16.png")); connect(helpButton, SIGNAL(clicked()), this, SLOT(showHelp())); helpButtonLayout->addWidget(helpButton); +#ifdef USE_CURL + QPushButton *proxySettingsButton = new QPushButton(tr("Proxy settings")); + proxySettingsButton->setIcon(QIcon(":/img/preferences-network_16.png")); + connect(proxySettingsButton, SIGNAL(clicked()), this, SLOT(showProxySettings())); + helpButtonLayout->addWidget(proxySettingsButton); +#endif helpButtonLayout->addStretch(); infoCenterLayout->addLayout(helpButtonLayout); @@ -1363,6 +1378,7 @@ if (getState() == NewListAvailable) { /* Only minimize to tray if there is a new list */ QMainWindow::closeEvent(event); + mTrayIcon->show(); return; } return closeApp(); @@ -1378,6 +1394,12 @@ mLastUpdateCheck->show(); syslog_info_printf(tr("Sucessfully checked for updates.").toUtf8().constData()); } + if (getState() != NewSoftwareAvailable && getState() != NewListAvailable && mTrayMode) { + qDebug() << "Shutting down as no list or Software is available."; + closeApp(); + } else { + mTrayIcon->show(); + } } int MainWindow::changeCount() @@ -1393,6 +1415,12 @@ } } +void MainWindow::showProxySettings() +{ + ProxySettingsDlg *dlg = new ProxySettingsDlg(this); + dlg->exec(); +} + void MainWindow::showHelp() { char *inst_dir = get_install_dir(); @@ -1408,7 +1436,11 @@ QMessageBox::warning(this, tr("Error!"), tr ("Failed to find the manual")); return; } +#ifdef Q_OS_WIN + QDesktopServices::openUrl(QUrl("file:///" + fiHelp.absoluteFilePath())); +#else QDesktopServices::openUrl(QUrl(fiHelp.absoluteFilePath())); +#endif free (inst_dir); return; } diff -r 9ad1f18799fb -r d92b1594e974 ui/mainwindow.h --- a/ui/mainwindow.h Fri Aug 29 13:09:40 2014 +0200 +++ b/ui/mainwindow.h Fri Aug 29 13:10:11 2014 +0200 @@ -150,6 +150,9 @@ */ void showHelp(); + /** @brief open the proxy settings dialog */ + void showProxySettings(); + protected: virtual void closeEvent(QCloseEvent *event); diff -r 9ad1f18799fb -r d92b1594e974 ui/proxysettingsdlg.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ui/proxysettingsdlg.cpp Fri Aug 29 13:10:11 2014 +0200 @@ -0,0 +1,80 @@ +/* Copyright (C) 2014 by Bundesamt für Sicherheit in der Informationstechnik + * Software engineering by Intevation GmbH + * + * This file is Free Software under the GNU GPL (v>=2) + * and comes with ABSOLUTELY NO WARRANTY! + * See LICENSE.txt for details. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "proxysettingsdlg.h" + +ProxySettingsDlg::ProxySettingsDlg(QWidget *parent) : + QDialog (parent) { + setWindowIcon(QIcon(":/img/preferences-network_16.png")); + setWindowTitle(tr("Proxy server settings")); + QVBoxLayout *mainLayout = new QVBoxLayout(); + QHBoxLayout *iconTextLayout = new QHBoxLayout(); + QHBoxLayout *labelLineLayout = new QHBoxLayout(); + QHBoxLayout *okCancelLayout = new QHBoxLayout(); + + QSettings settings; + + QLabel *iconLabel = new QLabel(); + iconLabel->setPixmap(QPixmap(":/img/preferences-network_64.png")); + iconTextLayout->addWidget(iconLabel); + + QLabel *explanation = new QLabel(tr("Please enter the proxy server to use in the field below.") + + "
" + tr("The URL can follow the scheme:") + " " + + tr("<username>:<password>@<hostname>:<port>") + + "

"); + explanation->setTextFormat(Qt::RichText); + explanation->setWordWrap(true); + + iconTextLayout->addWidget(explanation); + mainLayout->addLayout(iconTextLayout); + + mProxyURL = new QLineEdit(settings.value("ProxyURL").toString()); + QLabel *proxyLabel = new QLabel(tr("Proxy Server:")); + proxyLabel->setBuddy(mProxyURL); + + labelLineLayout->addWidget(proxyLabel); + labelLineLayout->addWidget(mProxyURL); + + mSaveButton = new QPushButton (tr("&Save")); + QPushButton * cancelButton = new QPushButton (tr("&Cancel")); + okCancelLayout->addStretch(10); + okCancelLayout->addWidget(mSaveButton); + okCancelLayout->addWidget(cancelButton); + + connect(cancelButton, SIGNAL(clicked()), this, SLOT(reject())); + connect(mSaveButton, SIGNAL(clicked()), this, SLOT(save())); + connect(mProxyURL, SIGNAL(textChanged(const QString &)), + this, SLOT(checkCanSave(const QString&))); + + mainLayout->addLayout(labelLineLayout); + mainLayout->addLayout(okCancelLayout); + + setLayout(mainLayout); +} + +void ProxySettingsDlg::checkCanSave(const QString &val) { + mSaveButton->setEnabled(val.isEmpty() || QUrl(val).isValid()); +} + +void ProxySettingsDlg::save() { + QSettings settings; + settings.setValue("ProxyURL", mProxyURL->text()); + settings.sync(); + accept(); +} diff -r 9ad1f18799fb -r d92b1594e974 ui/proxysettingsdlg.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ui/proxysettingsdlg.h Fri Aug 29 13:10:11 2014 +0200 @@ -0,0 +1,37 @@ +/* Copyright (C) 2014 by Bundesamt für Sicherheit in der Informationstechnik + * Software engineering by Intevation GmbH + * + * This file is Free Software under the GNU GPL (v>=2) + * and comes with ABSOLUTELY NO WARRANTY! + * See LICENSE.txt for details. + */ +#ifndef PROXYSETTINGSDLG_H +#define PROXYSETTINGSDLG_H + +#include + +class QLineEdit; +class QPushButton; + +/** @file Small dialog for proxy settings. */ + +class ProxySettingsDlg : public QDialog { + + Q_OBJECT + +public: + ProxySettingsDlg(QWidget *parent); + +private slots: + /** @brief activate the save button depending on the input.*/ + void checkCanSave(const QString& val); + + /** @brief save the contents of mProxyURL in the settings. */ + void save(); + +private: + QLineEdit *mProxyURL; + QPushButton *mSaveButton; +}; + +#endif // PROXYSETTINGSDLG_H diff -r 9ad1f18799fb -r d92b1594e974 ui/sslconnection.h --- a/ui/sslconnection.h Fri Aug 29 13:09:40 2014 +0200 +++ b/ui/sslconnection.h Fri Aug 29 13:10:11 2014 +0200 @@ -86,6 +86,15 @@ */ virtual bool downloadFile(const QString &resource, const QString &filename, size_t maxSize) = 0; + + /** @brief Set a proxy server to use. + * + * @param [in] proxyUrl theo URL of the proxy to use. + */ + virtual void setProxy(const QUrl &proxyUrl) { + qWarning() << "Set proxy not supported"; + } + protected: QUrl mUrl; QByteArray mPinnedCert; diff -r 9ad1f18799fb -r d92b1594e974 ui/sslconnection_curl.cpp --- a/ui/sslconnection_curl.cpp Fri Aug 29 13:09:40 2014 +0200 +++ b/ui/sslconnection_curl.cpp Fri Aug 29 13:10:11 2014 +0200 @@ -17,7 +17,19 @@ mCurl (NULL) { if (certificate.isEmpty()) { - QFile certResource(":certs/intevation.de"); + /* Security: curl does not support leaf certificate pinning. So + * while the bare connection pins the certificate directly the + * curl implementation pins the issuer of the peer certificate + * + * CURLINFO_TLS_SESSION is also not implmented for polarssl + * so there is no way to obtain / verify peer certificate manually + * at this point. + **/ +#ifdef RELEASE_BUILD +#error "Curl release build is not supported at this moment." +#else + QFile certResource(":certs/geotrust"); +#endif certResource.open(QFile::ReadOnly); mPinnedCert = certResource.readAll(); certResource.close(); @@ -37,12 +49,6 @@ return; } - if (curl_easy_setopt(mCurl, CURLOPT_SSL_VERIFYHOST, 0L) != CURLE_OK) { - /* There are no limitiations for the pinned certificate */ - qDebug() << "Setting verifyhost failed"; - return; - } - if (curl_easy_setopt(mCurl, CURLOPT_ERRORBUFFER, mErrBuf) != CURLE_OK) { qDebug() << "Setting errorbuf failed"; return; @@ -229,3 +235,11 @@ } return QDateTime::fromTime_t(filetime); } + +void SSLConnectionCurl::setProxy(const QUrl& proxyUrl) { + if (curl_easy_setopt(mCurl, CURLOPT_PROXY, proxyUrl.toEncoded().constData()) != CURLE_OK) { + qDebug() << "Failed to set proxy"; + return; + } + qDebug() << "Set proxy to: " << proxyUrl; +} diff -r 9ad1f18799fb -r d92b1594e974 ui/sslconnection_curl.h --- a/ui/sslconnection_curl.h Fri Aug 29 13:09:40 2014 +0200 +++ b/ui/sslconnection_curl.h Fri Aug 29 13:10:11 2014 +0200 @@ -14,6 +14,7 @@ */ #include "sslconnection.h" + #include #include @@ -35,6 +36,9 @@ bool downloadFile(const QString &resource, const QString &filename, size_t maxSize); + + void setProxy(const QUrl &proxyUrl); + private: CURL *mCurl; QTemporaryFile mCertFile; diff -r 9ad1f18799fb -r d92b1594e974 ui/tests/CMakeLists.txt --- a/ui/tests/CMakeLists.txt Fri Aug 29 13:09:40 2014 +0200 +++ b/ui/tests/CMakeLists.txt Fri Aug 29 13:10:11 2014 +0200 @@ -48,7 +48,6 @@ Qt5::Test Qt5::Widgets trustbridge_common ${CURL_LIBRARIES} - z ${POLARSSL_LIBRARIES} ${EXTRA_STATIC_LIBS}) endmacro() @@ -78,6 +77,11 @@ if (WIN32) add_custom_test(windowsstoretest.cpp "${CMAKE_SOURCE_DIR}/cinst/windowsstore.c") + if (NOT "${CMAKE_STRIP}") + message(STATUS "WARNING CMAKE_STRIP not set. Please set this in your toolchain file. Falling back to: i686-w64-mingw32-strip") + set (CMAKE_STRIP "i686-w64-mingw32-strip") + endif() + if (OSSLSIGNCODE_EXECUTABLE) add_custom_test (binverifytest.cpp "") add_custom_command( diff -r 9ad1f18799fb -r d92b1594e974 ui/tests/data/choices-example.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ui/tests/data/choices-example.txt Fri Aug 29 13:10:11 2014 +0200 @@ -0,0 +1,38 @@ +I:MIIEKjCCAxKgAwIBAgIBATANBgkqhkiG9w0BAQUFADBGMQswCQYDVQQGEwJERTEZMBcGA1UEChMQUEtJLTEtVmVyd2FsdHVuZzEcMBoGA1UEAxMTUENBLTEtVmVyd2FsdHVuZy0wODAeFw0wODEyMTAwOTI5MjVaFw0xNDEyMDkwOTI1MTBaMEYxCzAJBgNVBAYTAkRFMRkwFwYDVQQKExBQS0ktMS1WZXJ3YWx0dW5nMRwwGgYDVQQDExNQQ0EtMS1WZXJ3YWx0dW5nLTA4MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyprRwzyBTxbdAvEJovpeGdrHbdbhQLD85mlqo6M1Gq8XneZXM2BkCrCwPNmdZD3fFKyDxOKZRxRO7Ci6/hdmJ93dEed1Zl+3hxc4Vuh26tmanKDOQc29MG2tQ78lC9KZUJ6LxsptJyQqxohddgL35eGhmOHMZeLe6amuGKfN+xf3bmNTS1LMccGzGUPDQPyyuSR6rOOEnmAj1GBkmIp7Ej7o3EaevBrzzgCFk+Ud0Sa7/YfZaEoCGgwNj3xkGuKO9z0/8tMVvm8prcO3UrMpT1mCS+XpbPgsLXbup1UztiLLQqPCKT4j/alh4UPreF2QqPEC0Ozsff6NLXpTgJp7xwIDAQABo4IBITCCAR0wDwYDVR0TAQH/BAUwAwEB/zCBwgYDVR0fBIG6MIG3MGigZqBkhmJsZGFwOi8veDUwMC5idW5kLmRlL2NuJTNkUENBLTEtVmVyd2FsdHVuZy0wOCxvJTNkUEtJLTEtVmVyd2FsdHVuZyxjJTNkREU/Y2VydGlmaWNhdGVSZXZvY2F0aW9uTGlzdDBLoEmgR4ZFaHR0cDovL3g1MDAuYnVuZC5kZS9jZ2ktYmluL3Nob3dfYXR0cj9jbj1QQ0EtMS1WZXJ3YWx0dW5nLTA4JmF0dHI9Y3JsMBYGA1UdIAQPMA0wCwYJKwYBBAG9dAEBMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUGqSv7SEV7MtOoKdAGE/HDa74OogwDQYJKoZIhvcNAQEFBQADggEBAHXHRdVvlLmBWw+iSBA1FQ3V21bYY7yqqGErieGS6bQfUZU70noOI/ZOQeM/DAFsa5xYDNc5FGIBomCMOQzFhLkUaSsojamSswrmVf4XMrenjCFxjOXg8aHiWMmHRCzSNgXn0FCT0j2FgELVDywgrZVZn6e07VkFI1vAEYtCdZHKVQV+0Y/m7XfI6JAT8USe/ikEuVdk7tzTS/78w7RnFQdDnPDfrjQh2dl6vWrD8QhGuw84Xxf/3zGlNfiPugD/ATswayWMJf5BrwMK2kYOzn+Rz3WJO98HEhtsvETlUvNt0MrJvolJGJz4sVVwfHb3LYEhsYu9krWoTznJk7UF2Jo= +I:MIIFTDCCAzSgAwIBAgIBATANBgkqhkiG9w0BAQUFADA/MRQwEgYDVQQDEwtUZXN0Um9vdENBNDEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMB4XDTEzMDEwMTAwMDAwMFoXDTE1MTIzMTIzNTk1OVowPzEUMBIGA1UEAxMLVGVzdFJvb3RDQTQxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAO+6fqWQDSwmfPU27NMtTFMh0zD8CY4Ci1HB6xxsEz4W6UMD1YhHujduhG3J01+HYlxrsYHdoNyAm2eU5WO9GO5ZmrloxqpMRyWC2vYHJaV4Wu/zZL1+R3n8EpZutscopk8kPX9vpP6uGrFir5VP1/SeQu+v8C4w0dPKiPvayDb+EZOjL2yTiJfQxuWJYhC6oPn9Zu73IudEQZ62l5HzaYdQlTr6QTqoXzgxcdJH1/zTv7ueL1FcSOJOPlmuYnJOd3mEehQ5hH5in3AimsN3HWMiHTgL1BYpe57T/UKSmEWdTvogF6u9qKk1xAtYITm+/V+4hwcBU7+FywWkFpFHbKJgvc1BGfjnTm9oPd9EP1ABi/JV8KvTFiUGElH996BBtTR2/U5o31ETSRz/6HIeiVFG1jBbajr+hacOs88hfzNFcaICkq2f2IJHyFJWj8IrqCWONRIqqgVTu9ENqrOrZSjDqI/ecTp76tvVg6P5yV/hDnNhPWGXTkES5mZsMwb/IdmMm5OMIehDZkktvmnIS2KleXgawH3/80y6RY20+N1khIscYHYpeVTAP7d7st5hdLQsq/31074M4Abqn0SYu/MQwhZlOvmurWDDgetjjoBVugMmOJZmy6kI3lnp4C+sDTEgjL1fFkzHQdyc3k0KA7SqEiyY6h3f4xqpfthDvX1JAgMBAAGjUzBRMA8GA1UdEwQIMAYBAQECAQAwHQYDVR0OBBYEFEUTDV8dg1d9hPUrfqoTZyqW1bxJMB8GA1UdIwQYMBaAFEUTDV8dg1d9hPUrfqoTZyqW1bxJMA0GCSqGSIb3DQEBBQUAA4ICAQDiGn9tZBPHMlwggjtkWGyn3HzGUzQUM0hxvmjiGV1CekjiFbXIOdaIxaOhzibKXGooe+FKQyb26b03UqE4XTIhwddwqmy4g1bg+qwmIgUwPn+V2qMfoMwP4K9TNzd/0ATX6O6BaZcG82hjxgbwJrIaekeSSwgdB4NrMTkfZS+MTqA4EFlQ/zZ7G6AYPhJEqGO+OkO+Wiohgkr6zckZqQgfEEhh/Avu+VW++8BHg+U+E0RH8P4g0OqXXjxpUhsmrHBF2X4PrKYv+MzkXR/36zLXRiUcEYsS2I/DPscreR80WeBFsKaxGL7Pi1Do8zDdvzfTMRe3ANPawj51aX7QIEKiLl5rwJmI41runEwi03G+8mX5L/25xh3HL8BkxCStTz9OZiMO/nK+NsagR0JhxcWimnh+GfdHbRz9/I1C+jI619Pl85hHLp/v3zlNuW6hA7J8xv6JOkVcMnChWB0lISQ0fyQ0znJ70bav0m+4IzaToANnVRoKL9J4GbgT7/Hb3F/e3P+ywq2phH5wwl+od11KzvIVz7JmR4U0UUBvar/VhUx2hbZ7SfW1CCguKrilEKXXJTFbrDQ3Y/O0OzNhwS3PpDlAVrpsfGYYz70lEV/6yKn0yKJY6ipbL1zF/8f6Vpf2Yw7cZtg4TjR4fGXrlVrBiiWHYccbO9VRjEssSBQCsg== +I:MIIFTDCCAzSgAwIBAgIBATANBgkqhkiG9w0BAQUFADA/MRQwEgYDVQQDEwtUZXN0Um9vdENBNTEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMB4XDTEzMDEwMTAwMDAwMFoXDTE1MTIzMTIzNTk1OVowPzEUMBIGA1UEAxMLVGVzdFJvb3RDQTUxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMx+RXNDSZwTGPhq27xhG2ujkTL7FKn+fZRHRh4KCHQ0WRFg3tmtVJwvdz1cXLsBXeOzVjyBH4AQ+EhrI1v4XpT10lK4tu8JT1eOGad1oLAMKiUFWoToIfCwZy9oTuqs+weVwzIePS9hVv/EEc+ER2bNO9MwL/H3pakIvGACapjTfOqme+7qRSFrngEj4vXlgY/S2QKC5pxNZVN0ZoTsiMEHEzBW5Rq/ERFTjYYzEPYC5NA4+UWycM94i8AmfLvJfrldY7poUJhMDN6usmoSzPb6fnulPalerp7uhlUbp6ihI88GL5nOuMGUda75yb4Ydqgh3QmA3C36iA3pyCZdm47xfXtHIJR+jhldk4B1GgLDqCSuOmorRj/SyHsvUme3laij9EOlVOBfHCxpM/kbcBtIkAmZLZRn3o3Zs8T55ATj1+jwDMZ8zZiDft/qItdS5a/eDe//Tdla24ZvK273D0M5Nofog/z0Jbdmj+xVxFIj65YddDctDRanDtQ3kntU71gW/r8lXh/s2acdYYK/XKSN9mHT0z4XR+H5CT+4e1SK+RhlIgylhfWl5otjvBuMiZNmUy5wElhv27lAhrFwBuI6EIn4lxMWdCszffTr+tv0LkoOYn7W4l5BO66Tl3d+dQHaMXrdUOvGjIwzl1pb2hXgxaJDmHERoW4PbMrd4UR9AgMBAAGjUzBRMA8GA1UdEwQIMAYBAQECAQAwHQYDVR0OBBYEFDSMlJPfzxHI6gWRbLSAW9ca77REMB8GA1UdIwQYMBaAFDSMlJPfzxHI6gWRbLSAW9ca77REMA0GCSqGSIb3DQEBBQUAA4ICAQAcVF0zeuZ2robnx/Bfglyz0gFu+5rSyC9zPH8Q5uE/QiO7q5HxVU7/5AENK9h8bZxoF+xcS71cm09UkWW/1TNmVErC4cd6qlhbVmMVO/XBh6nzVWSDNE9jqYKcR1WCClumzziYeON7uNXs5CGfwddo2kY6Os9TPAUSNS14x7HQvUC6ItA7Eu1hxaRkiELt1PAnEplUt9Ne1vGJ62H3ubmD5rQFnZ6QvHKEsRFhtn/QKdStiPL4lKo5O6hXbYNduweJr8IuymEIW6CPl7CNcbrxICbJMiUt998NX8ExlRXV1HfhZsj7mOCD3vRExge1jjmuoLxk+4oCQncR/oTykuo9QtqGo2sLdQ/znsKYR5ExSmCF8llm6ZrwWmRwXBgiqjQg4Vp2CRukVcxaUdDDwhe7Z9r/6+9hIqNvbiHwmDKALjpQmb7lmIJwNq593KMvdqlaqqfmWZaXzTjApEy7l2rABWT+Dn8+wTBzi82tnHybWU2cGD4ZKRY8w1tQpQk5AlTd3LUKlrRayjuijKclCly+Pjqn/oktShPOGQ9gnhJWfVc/jWoyTdEQT4Qf0eHw0OebFz6UIj77OeGC5sOc0IwF20Uq7RtxdKgELvVnScgqUlTGeIGrrvICgxx/qBDthw+c/TN77NdywS4I/NX4UXic+wQP37HA8Vvrfd3/QyHuog== +I:MIIFTDCCAzSgAwIBAgIBATANBgkqhkiG9w0BAQUFADA/MRQwEgYDVQQDEwtUZXN0Um9vdENBODEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMB4XDTEzMDEwMTAwMDAwMFoXDTE1MTIzMTIzNTk1OVowPzEUMBIGA1UEAxMLVGVzdFJvb3RDQTgxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAM1DBI99FnEuHehO2NRbrRWbNh4QXHQCZVTwYl9YRT0a2AGdZ3cnc8NUf5Dfzd33BZAmA7dioseaIWe4gSmo2Va/p2Rjd3ufeHWNpLTlMPKjDK7cBIyE57a5ax1BCkQr05mG0JDv1ClbvQDWzXzTCTAMn4OfwnNlNuqGDO/WpBucTgStUa7ZPo8XLHv/TGPV9l5PsMOm8nWTQpZDupb+Pe/DUWHriOECMpXWJsO3EgPzpbz+YKftK821lJsRRIKSKNk2z0KtBcB4ydn7xfU9p6kTQqA8cVH56ZGtK9ttfjuFMAiUw2uhQWqzRZG84O7hMmckKuxwcZFHSJGRWiU3MDmHYBXeMW+Xg5/HqxBgpG0X5O9k1MOLoCOou5pw2gLV+xg33sqb67+Rw/DvwOo1hYqJf8as5IkWXRXjw9jVYA2PF8U1kIHsmjbiXukU9Rk8GQ6U0kSJSLp4CMCpAnlqwdnvBmxFYdOcChPAugtVvju//9juPauPTwTSyRYcDPLjb9Gq94ufVatMpDYgZIs29iE03CGysT5jr0rXNK28i6qn2qOIvQZ4DeI/kKkCN4Ei2l8AcOVB87jUwpTy2NdLoOp5rr0N7On1yw9537OmX5Zsc0Hec7Ao7XUfKXD9WmuGWyOtWuMvqiCIH/GwaKBW7t4K2g1+Qo0e3ycafK7NtzZrAgMBAAGjUzBRMA8GA1UdEwQIMAYBAQECAQAwHQYDVR0OBBYEFLFMUxukqDO9f5leBBnfmOJAf0mOMB8GA1UdIwQYMBaAFLFMUxukqDO9f5leBBnfmOJAf0mOMA0GCSqGSIb3DQEBBQUAA4ICAQDGyzpPWR5xQOXXhp9qF/DZDGoly//D1RUpNNhmXKY63e3IwNVg91Ty5I9No4Mq5K3UOnxBPYhOTAOTReRSwU5mcWZj7/9AxpZymCvsWo3AcMXzYdBdm6AliQT4kkhx7KyedXs4xjA2jyUkqukbO0fq1JSCdrF7Ka9B7f8TX8nNNuXwQPBkqR8FkvCZ2+CqrEalm+lTmKRwPjqEiLZ+383GhwfyMZmBc60VnXodQa3HRvU+wU3z2DBxXDaGUjfb5706gc59b31PkrxTqe3PaFqSSY76ooZn6kIWVqpvHzeulJMbhlv8TpREHitwg3QylIiPiJe3UB970/MdYloNMHCl/Qm+1YK+xzjRcKutrWqXlWDH1rfUAdZdGcY+ETzIP2MjcVfjA7fwXP1GtVMK03JLzjCvCMw0PVhpXh7bSe7p4aw11UuAfnFZc81FSMsPbzdDMXN9nsOm8KSMjwcRdhw6xA0Ufkq/fPFCzcCNV1cUTv2RRcdAt+/cUZ6Du2rVTwUuFZjiqnBlSL3VRuC5AET5yefo2V9mbldX5CCpK3zSRwli6JgKmqMz/SGYxcFLgshjswPf8D/FXQVF/VNxm5n7+UhUs2bGG8Lq9ewKniwu4iLqB20XV9Ne9je/8o51O0iSnx3aVe9r+6AQr3dz4OLRJR8qt10o2NNFcuu2/dhteA== +I:MIIFTDCCAzSgAwIBAgIBATANBgkqhkiG9w0BAQUFADA/MRQwEgYDVQQDEwtUZXN0Um9vdENBOTEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMB4XDTEzMDEwMTAwMDAwMFoXDTE1MTIzMTIzNTk1OVowPzEUMBIGA1UEAxMLVGVzdFJvb3RDQTkxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAJ3I9OTFXsQlsRmiGrjFXiDLhNCup2g/sQVj2xAVva/PCqKXjPx+BFLeMKF3Jq3lvCX0VMTOGxIcQSdqo4Tk/46wrvjotDXs34jvhpz8RWiu2hK8aU75VFQnfduECZhLsNMRqJelJ3Und3A3gX/RwBTkov5kYK6tGnS9Pawj/VzPaZTOAKKMhAd9hLwDK3XtHaptdygFOolcpGOj1fGkDx0h26TyRibL7Xnw5dliC/wB32aNYHcVpfbJKYKUviLQX79PIqNfnu2M/a2poHp+twWTwH6/EQ+nTVjny9hlVEZ5SUcrjNXt8aKxJu9hPuoQJqmRBe8MwFWwcTdbSnP3naU4mxkGQev1xCOAou9KdMk9P2SEDMygRoZ328DdhiSSAy8fpLJKvdVQ2xcpvPGk26lltpNO3m4E90dtE4kARjfDxfGZL070/P5a5dJaj5A2oNV5goopITSSpV5JYj+fEvX+ikYIUn3GneA51RuaHTWiPkCPSEVwovyryJ9npUoVmdYcuJUcCM8QFAYP1OKyKK/gDwMSllr9mQy8RNx1EuwHnwzXaw0KnJCTV5a21qz1czGZDbtLG6QSBIsveOcoFe4yzkp6jR0w1yAFk2cCe5aQKWIwtVEmi1NM4k6VNioyfIFDXf0OY3sXRrhqp6fTLzWvvR2EXaC/O2lcJFqlX1ZNAgMBAAGjUzBRMA8GA1UdEwQIMAYBAQECAQAwHQYDVR0OBBYEFOIqiRGwzRfwdiLCXotpHl6TcGNKMB8GA1UdIwQYMBaAFOIqiRGwzRfwdiLCXotpHl6TcGNKMA0GCSqGSIb3DQEBBQUAA4ICAQAflGRZhwkL3PIgPwl1yqcNKg6NNa39reqKqqKgcbEnXsYvPlJAPzHkr/q6qF50lCEATRBoV9Xm6KtBcn4sxmWrNH8UxZ+A/zn3yOIMWwRDhrybQ66Tw8SJbO01LEbClHKLwDQKtEv6y9h3wyPqGAFNu4Nztkj/byPO5STyJprq67y4qiwWIw7zguh6kPjg2cUVFcKB64VAjx1Upls2lcuZ9A9J7rdo+97aXTSIFf6SAhgPf00ECXwBN2msyKcbPe03Sx+7yHjrS6bbBHrPRdVH7kI8SXZCWuFrm89CumtaM5Rp5FHmuiZLuyswnqe1iR7lSRutI7C4K7WrUPpa0jcR4z/spnsXYTbVehjzHS90OFWiF9W7qresOF5rN/xggjWWYT/EG5emZI2TFDpgyNrkj5xMYCEucOWwt0JBW7e5AoQaS8jY82+j7ZZ2A8pENBQVm+lEVZNQN5/8IN3ECNVK5LEFzAA9uvslMvfyzcwfMKDjIBKYPJlqBwYUPl8lLVmWeX8BjjtAna/+YzWgSwANOBPkGQVN57iEWoj2MlZfJI5JW/6/DJlIRKwAL0Utz2qjJku4nSC7Inzhy/oEwCgytDcxndNTMClHmRN8NwBWQTwGfL5r980zN1cqGoL+kydyYAR8/5euS1G5KpCaIrMD99+FJbyjBv0fjN9huiVkOg== +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMTAxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0ExMDEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvPUOBeyszZIkHKxSSPEaicjYxAxE3sEtR1FAQZzP+++IJZEYnTfT0tVQ8gzCJSQVn4BMcSjBiwqaYb8zLtNE13IqAKADfbLa9p+fyWFwHADaLeXHQeou8lG1l+iiGxvMJ9b2cvYaSR9fuu8cZlp/j3hmtCNfUNmmTFqjs1s2r+zZeOySIvYQZeIOwpKyxznmnlZZn4Enx1oMZoY4PkxPY/x1saXJmk5Txvr5mhmJQqGj6smfX5frdmzHdqqgA9ef2BFSUGWhNY2SXhvNpCj2CzO84cZuCSuAQ+6jjz/yQy7adBdJIPcH/Sge+YYsJdfhJy+QBWZ46uj4R8XlDK+RM/US743/t816q2qFx58V68cdDIHzisLcucq7sz1rBs2xxIUfxLegLdPOSoL8jHxBusCIfT26r1bvINV0fNcCmNVb8PwtXbsFX4e/Zj/4sOEEacSeLtppQV4x5IAmFmER4XnggzG0poQlzcdz9duZtDoh7RICXhBNAlfTCdCfm2qSNEHD6uqf9BCIZ+Zw7Ijh5TNngV6aXkvdG2h8qhjBFiLahvsnpE4uVFZEK7RRnp2pMFMmDQ5LHJtNBLzyFQROO+pvdUYGh3p8M0btriYFR+l87A1u8eOQBWW8qpJWZziWWcgZRSZf7z4IvsHATTOItjXDstymAtqdTxbN/+qtAu8CAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQU9Dh8Q4Xda42+sYbV73ryswISOKgwHwYDVR0jBBgwFoAU9Dh8Q4Xda42+sYbV73ryswISOKgwDQYJKoZIhvcNAQEFBQADggIBAGysPhGsFeHHnSg5gG1DxeuUyO9rZomftZz3IpbsGaatRM7fJIOrlTfku/XPMNWqJbT05QVxK+6ZMHgDXhhLDT16YQZhyzQ07hCmxP1sxiatupa0mxM00caOA7Uss+eNEav27P3nZ2c0ki68YBI7wOsHergDFIq6fPYgAOjyDg4zFeaSzRdoHAj07QclK/GxLN59Qyd7ksKGMZbAiPq2Pfmm1XW+yGSMKqF9Oqu+6F7prPG1NoPBAX8OXFte17msfcA4pyHDGQlG96Dh6SuX/y7VoX3cfKf7R37T+Q+kAzzfGOZO7cFYhxI2dnToaUm5FqNq2wX4sMPB/smamKIGGQeqrKlVcdrKLk7mwDggNcuxLsEwNShtxKVZLGiAGqwrb/SijpRVZ2hQceq80i5fXmUNoplyybSb8HrjayZo1CopTyhj0gEkVZidt+bHzxtt63k/tFjkcLRIerk9GV7a4Cv1E/O046fzEILs2ITXY3hZ25DhdGb8frqy8vJidSy65VyC8Ep0mGEo/QD+E+hXihWQ9RDCHwwwXBrjZAmwLpt2dT/Gsa2KlYWseH3aQBeRYZJKJEGV1VBpy42tPx/CNA7DnmhvV4Y9QV7p3SQq1wy7fwwoo9+ZltiFnXk98saMnbx5efAV0w/R7sd3plf78FWPeRIRUlkdhKEAdx+jq0k5 +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMTExGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0ExMTEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAhSp/Wrjg0UleHgi6yVhKY0cT/zf1nsMv20K1BivTzBow030vRprcvoHLmBuH/9ekJXG66f1g9hcra0k/albX9k1+SgA5/2DYJZeJPY0OLphDjtzF+yJjZ4RfjjdOCsxRK6xVagKOd5PVQN565uZaotLWvAuiGhZOeCMBob20kdmieZN44P0EoWiVGWLpjPtXt+Rgzhwju4XNnFZ/ryPL9Co1tQuQWFLIGNA5/eJxDC612YtRXDIJjhUlBKBIHxWmCN7TliJG1w3jOYlYv+Jy4wokfT9ikcnJSvUFtvgwRj/AWlXnyyqfbbEtotZ+6RmWXpaTUhkvdlky2/FLFu/d04OKYgOmIDTwR/HxJXsBaxQn9yQAUC1LOgTe7E8LHnxzuDEXX4OiJFvii4KcyOJEp8Pja63YCVskcMS2DHa0Tu/ph6PfnewTlYyhcZV8pAtKP2hWXfPFtI1gL7GUNGnGOXXYByBjemW8tYwpLShaTS4ntyMl9JFKmJgiYOTr9eU067QeAB7+Si3E1kE6ToEijFoOvpqYMtYLvLqJlRfdKSQITIM9f5GX8yW2TkPfht5DAta8eagjprZfdQg7Q7ThBDt7FQbS7SXKRWhmSzK2pvxgEOX11VRVk5uy2QqADmx8cQmE4FPn6S2QiDXvrO5Hqha1cnXxmorn+BMvEPA1CkECAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUyG37BsH1G/gPrEaUDsSwfCDGV2MwHwYDVR0jBBgwFoAUyG37BsH1G/gPrEaUDsSwfCDGV2MwDQYJKoZIhvcNAQEFBQADggIBADRAVbTZX1RMSYpzemyz2wffvVqKXSffn60ik9fFJUVCtN8QYOVJA/8yip6SWMGvjtA1NEfk0e6M1XQ3PHAdEqznIca4bU+5Wr3BXe40QfuE/o+85GBqPkSptxo+8oW348IgvtE4HTs0zWyEHERwpdv6ksDkTQuqADtEoqIJ1oKuzUPtPiL897RjbuvlCWS8R7t3WennJUmoayGFmAjtKxuqDZ73txjwds4l1Y6H6yxRfsGaMZ6Sfzrf5OmcqGeRSL69X1j5EXWwv0YFdBv4iAEfRTjsUegZ1DdBmTyGYb2+E4ATIM9AsYR8ubNxYvqHB77PyeyGJ062KmywTrw5aFv7BSbt/CNjraiteYlYfAzb5AEbkmGBG9iU/WPaRI6kNCLR5jUgVP6PjjXuWGN1Is8ebDmlvdKnNngiWrQEzen7W8u7/N9a+EGdtCcrhEIuWxkChwS1UytvMnVwD50c0dFCvNcaKJhEtcp35Sop3kPWaj29jNnDUMLWS40hAH7YOC9IClPlCdB8fQgc7G/WpqJbo5N/AVm9HBSESjClWFExI0wa+o++Vo1hhNKzVhvabWUMViBOEOFUVJROHnxusXDfQggxB5gz7Fm7Xa5+RnZaHHreegMkL0So+fIvNu664fCVZYlF1n4Rr+aEVyu3vk7XLXBekhzGcLcvNOJKOERs +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMTIxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0ExMjEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAzq3ET+B7IfTJTNvuwxJNIWJmsXtiHymNM7e0/Xayy5rPpU8ac0E0pziug9rfDgcnkqwcnmk9frBEDaNHcLKRlG8MX5uPihqoWQdauWlsTFEnMDaPSh5DqMmuWtPDEWXIuvrurZviITysP4dUjqOyP++/aRkpy0QrCom5cPO+jPiQbnWeiP0XIaTTM5ShUdtaHgivK26ZtWI3nUmltuSllKvwri+HVr7s/qaRlETxlwgoNdip9SjYNS3/obJ0SaAtyGo6WesqbyXPKjCSPgnStL2iTAYSNnw8ztSwbQxM2m6rUZ5dO6LAE3ls3HL8d1TSleMd9N6NVZQ2k551I28ZwsUSsAkjI7SVPskMrdN5PmneACNSNpTOdnb8OK1U6tVal9N3DhtmKnk0FqqVs5rnFQ+zLSj7lF6nCjuAPMHnHbnG9oF4V2YcG/yLxh4ZHSVb3/jy6xm8xrh+9wiuQDg7ofBvw0dli/btG0xwDMPRb74Hz1c6dkTtJ5E+vYF7uuZJbDSvtKWldNdUmZsrEQSMOAue2/iORxeKNJM8uROy928qQOwdkvmdHRtFMs8lcCIA1alfdOxV2gTUKPc8VoH0JCaO1o/4y6feCvV6bSNcCLtsd/uqMgDZ33quLOTFPhqyOtDCkDlZSm9f+Je9OLLi0HwbT+OuLU7mBiXmwHdBN+UCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQULqi6odKQPmYVohguFVSii7Ao2GEwHwYDVR0jBBgwFoAULqi6odKQPmYVohguFVSii7Ao2GEwDQYJKoZIhvcNAQEFBQADggIBAGV19CV0P6ANQRxhzdvgkTdMbHibfBIO4+aR/WXD/nGNS8eKQo1YzDLlqMoZ03UG43w919j+/PoZROqahwCM8OcdBiBTlDlA5T9sN8GMJtiELl+8Y5RiPmVNT7GIGJqpLoLNnxRf4b9fZfQ4eimljAC+cNCs2y2n0sZk61dx/jBm5tkkq9upOiBnZ0YzTAQg+fPQYNCAFqneLZl3+I0EVwnG2vL0/Vqr1cnPmd8IiebPKrt93CoipU0X2N2uJo2q93Hdt+dorZdS5S0WxgM0W4sC+GWMYUpyI4HEKFtcXmggDM+pDgDS3u4ZoFUlJLCw1mkd9t71nll/kOJ2yx8LdCy+8EceDXxSGDCtAzZjvu0bNcrw4b+SxLM+wb0HVRCkzFrL8pUPraaQilROgsftGmyCy1HxuYV+NUEjCn/hOYpYnMhar9AhdhiCJ2dTeKgxTT6aVk+KEzOFYCtbB8OL5CBustk5lra2vtBdPqriDqzhsNhWs1fytaFuSLsZ6QyJoKBQLOD+8RcNDjGCzeuw88Sc59rki4jYpfN1/sjEk0s5hj6QBmfwDslQ37wEmNHcFY7NAU9AcC4o3CoUbvwLTysz2Afb+1cis/eYevaMvvRYXCMgBGRIK6ghp6rNrss5W7KroJWRnHOdiicSEXt/TAgWlsmgewRXI+U6I24k2mUC +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMTMxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0ExMzEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAgzGskzfje89wAyFdGGIYK05nhXgSoj5rk7pmvwKTPOoSVr1fjtbaXgXyNF4F8/tjgjbVU6sRBkOCnO3O73vzfLcnoBFeswnosq++RERqR30Vsqd788Ew9Ff8tYUrXYLJuz7pLvyMk6B69z9Z8pNlxwMwalZJ5pAtqr/FjdKQcaoKyVmFBjU7VVIHTHE084A3F2d9yVYqYqFhCIlW6e5sHcG3QNwGS+1nowSy+2CXzbBFB0AiFAOquqvk/nvM5AiANjfGNQdJKOmrKTms1QQacJHeeHZ0IGxkiIPyqYxARjjhJwQN6VsOoqvHDpSGhoNix+aK49ZqCiAklJJub3EaJU/GSrLWkh/1nS2z6OVkj/h3P1vRicsKRa3bRzmbaICoMDgJJ4VciOi+r449KjdpgAmhw9QSkYp3L9AmJvOwu9TgUaSULHJcc5NL51suhrhIvNTkjVjcMD+C89CoqK2KaWNlWjZdSLMhM3GQQdCf/QDnaT6PAS59d74SsZ6MKwPtzI0cGx9GAsQGI8Gfpzhdtr9vY50GB4NIBQwaM/zBZngHkjp9GBVgfunhOGI3xpu3ndSUR1MOYtd/wCXtm8B+aUCKhoAWo4TJzBvXY7lf6u4H2BA0J9AkHaSK+S5OUMSNuVqNi7JyeBHAD8jrlktJKeZ/N2HTG5Eb/mFAhIK2J3MCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUcs5Zx+frXa14VQgk7pwHmQfK7zcwHwYDVR0jBBgwFoAUcs5Zx+frXa14VQgk7pwHmQfK7zcwDQYJKoZIhvcNAQEFBQADggIBAIFpvMeHqgy1wxJ+9mpyo8dDc5XxYWFKV/giz65rnFdXjOQm8zf1jc4TWTPPy8qYZuy4NDUSd56GilV1biA/CQbm4NhfIxzJ2v8otRpdj3wu3wPlvVoTsUagUXeo/V3IKrq2GAJ6CBZ0cCQP0MRcXnKnXU/dOiKyXcyVimw7vBVWA+Zn+ysPnH1K8Zg0Mb3CtQHzBEyvU+W2Mb8yVWL/w9ZmDyPiKKqn3n+FJoBLpaN74Qv3/690n9zSwym0JVrp+TMXmJyAEvk6S7JJpgAqLyZLY/6w56SbVDGP42UU+q4wHoyo72kqfFRYvu6fzk3iRuOYJwxx8jRZSpGrPIgK4Yg6sbry5ljuCHM7w6qB3MOj2jA8b4BmsXoy8MpG68//dEOu2UN9gYZ/aBGKHF1o7ww0pORnn50sXPPIJBJZhK+HnuEKEzCAdZ+q3g8IkMjp7mZpH3zANIUq20ukLpybforJYo/CvuMACG0SKqg7Dyid8O+JlPx+a+RgdBzdTsvpsLcXOs3DEC2MGeC8iiAnC+UDKLxsAz321VMwJASvq9KnAYRzBQE9QVdkieeHG2r7fVkzW++KX6N/rqQrIBo+fkk7vveoRcNMisvUTcC/q/yA6Mv5dOPk9kHK3vfKcFAKzVqdMR2Z6MKIAAoLVrmOqzyJYmhFeD8X92Urh54rxeuR +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMTQxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0ExNDEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAkxweJ3rZdAZpKO/N/K4OjCrioKIkkVAqDmWjCepsRwyJAmbvEthpmUBSC4JHPTOnQyQA1sPtuqaRfE0s3de9yIgU4JgJokmiEv1GSbOjsuyAN64lON4tAoFNoSPSuS7W9djADQaHJlyJtdGmt21Jm/7tF9hmxf5ynvd6m8hds5o5mNlzJP+wewTvHagamdb0wFLXjRxLvko3ScIGx3soridC7EBdJdzcU4/ZgeapTwYBaN7zUgwjHor8qNtBjUsvG3Rys4js6CAYZXr8gLoRC1jcBGHZsPrXlQ9KhjqL/ygFmOF4DhhimEdAMWr6hoLKg3hswWVE2RCymge6VpTMwj2LhnfnKJwXw6/gtaSnV8NZNJhUNX2qo/WQXFTPcnJ/sQoNW01jFjtdIf807Z+MvIrpYdytWk7y5zMPkY4IkWHIuu3kdZ8hgvtNeu/ZM0jNP4hY2JbIc66DhBlw7cLNi9BEImTGywD62kJNWNIRRDXyQMUZYMM0G1kPWl23fsJkitORI5FiZkmSA0+8tVMMggJkKHc2B8arvpMZYSL5oZqbBPbBtePzwoWAbcs2Fq18yhIxcNxOXTA0G31IE+JJYbefZZBQ4goQgNM18r4GqHtllX5T8ltkNA09CaLC37b6wDoyx8k1OSKLw0git/A/fqIKcg4ILed4quPbCFr/IHkCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUR/52EZ0cNzX53ybAvvQeux4cE2MwHwYDVR0jBBgwFoAUR/52EZ0cNzX53ybAvvQeux4cE2MwDQYJKoZIhvcNAQEFBQADggIBAE/VJup4hoq81EItvSyDlQiohKIQ1hPbN7Ukazg4D9LiATDqbdImxbLvNOmcxa+BTdjk0b0JK3KQfuQjPqKblcsVck07ETRT79PNMnrd09cd5d6mVJ7iV2rV4D5nxQEQV/s+SG5u0/EOVt8enkyFQH8UdnyvIlWtslH63KosFLY0YwZaZo1MsITq01VshfWJK2DqLxyRZHQFECgzNiAyAVhJHYN+dLIim8AxF+kDqZ0juDV5xi5Sql911EUZTRH92D0oQxktv83jTB5URcKZ3POp+TiK1kMF3KI3nWDk/B91CYwHU5a/SMfT5izkq2x/6yCQPIibq7MrrRCu5Gu0os+owKNabjeXCgeWEpJ/8wOrjrn1t3EfNYZ9rRl9FcLJeyjQFAVCmtIJVygL7UB2lJtq9UDA2G31dpcoGnId5r7HsC/rhv7bYmU+NTNn1/t1yDZx1ylf/RqbX/q4rNqJpOCWuAqL3Bd5x5ZtWdQuuXFa5bIO/YK0fF8neqY+ROYea2csJUoYRUF4CJPmgIK1PTJuTjktavdiWelQ66Va0mOYIorNyfjq1rUbbEQZTfQDreP/yCDBqL5XLaVMG4OJSo7UpZYvg0RTs8LwutXsxyRYAuCDHhfZJTdMk73kiXCM8TfBDpgOrvUTTnlqVh5hJPgYc+t5V4OUVhmSRaaZgD+z +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMTcxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0ExNzEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAzACCOVKqSevHBXIpZD8qAnvaYuM+MYYniRRQBtFtFsfZae0nYW8h6bhmTGecZhl3cP0QgOoNr+spChdCc6Y4aR4diXLA/TdTcGDEpfk/MDW21ekzmqp0Qm8NumpZMJ08favIc1MPt+YtPb4XLORbYPASAKzc78VVp18UtLdzV66kX64MN2oO3QSAWIH6uvY9puu6n0jGjH7K6HIxwnskRlhWSSD9O2zor7jCMR4idF7NtBoJi76qsg/wrWZIoplQIyM0tLghYGMh1fJ30TwmhibIe8Rzfa54zoPhBbE6cLEYwEsBNl8aWyEcfugVM9QV9Oj2TQbR6OuO32J9DoAwIrTBFOqhxiVc1xFZtDa47MNqNI8JxsznwRZaf+itDSFnE7kJnDToxZD8Om99l34QsMOrU6WyqNEkUpb0O81ZACIbHTCGtcB+pjCtYwvEnjsFxUSvrpjE303R6EXHpxZWB0Cjp/WlQOLgysvMhwQaXdQ0ku55w0ERArTJUiLIh+by2A23AmujhObcuUubIjFZIflK/vGdqhFYHeI9YqXnUphD35ZHOUsW31GLVressZjngllfAaURL6V4TsXY7z2OeOleWd2o6gkXXp7erUm+YLQQzgU7bt0KJmvsGW5yKqsguh/HhVlUMW4A0eYMuf38ZRa4ZES9DjKyVs74cXOb81MCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUNITBnbWRVy+GDYKZjIMBum39FVswHwYDVR0jBBgwFoAUNITBnbWRVy+GDYKZjIMBum39FVswDQYJKoZIhvcNAQEFBQADggIBAB+WtEQogrKD0H/ciqUM9+lZvaoGyRPTOCWUXQ4co3CP6BP0eTFsS1kEMq7tN/+/rQiWuTsLKS3SVlPcIEpQhkg9vRIy50kV3jGvXjJfNOQAqMXDMYEX/HZ9cdYOS4DsKDOmcMeVHrm9Wxv5N7j8xeQnqfFknQ2IwBU7f92NlAGb0KsogTl7kgNZz79ukuX0TWn4gpEK9ZmuqWZ+1NJJPKMzmEz18N682slL+CC9lSg8zc7/MrXIUW3FnfY24Cuq5VEoGwSJdLqg7xH2npDBQYBXkHpzzM61cPUWSvFmrisqN6TA70iGgYa2bA7Xaj7zQiPqPtAOE6oYCxNkPgEtkO7ub7iwMQXdhG6FFojI8w+LMR13726LfTvwq49ydVTXxEoZQYGLz6FK48kB9mLkSHHMbPxDfpU25h/r+nSDCvSBRq2a06Op0G67fNsKQyHlHklDmiDNWd6l3HMPQ4LnsFKJ5pIqsvwWzw5Mrkp9aptCBBtqZtglFipn4SVaoXsMPWF092y8VoycOiTUznmcEuAi/pUMP80+bUHcwChKoxFuduMU9lBSDJoWKB6USd/GoYyqWRUDyTvNX4Xry4+7IZW+PL0aX2MFIALo81Gdaok1lMEqFN2Xzv5wdDusdS+twMCTBB+kGVbBd+cxThbDmXNZ4DwObFLqbUlF5qo1+3FT +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMTgxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0ExODEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxKcKVEAHp9/Y+BFxBEUn7oJSW8FdrzLVYcCC2xpxS6yZg8zulvTYjlBfqwPDfGUHe0Upn4mV9ic21V7ExwjtadAzp7rjsOfpY8lBoYiBxJ3P3CpSXNMai4/Wm6OJTc3iiaOpJYBFlRSLC85l/FMYrUMw11LKO1A3F34SUlZNFQ+TwP/Rwn/GXnrkSB6bIguOYJcIeRSw1x4mplIG7bpPXkCQ24VHgIRWDXAcRTIB2+ZzktVHMb4Wo0IBXPzCn+/5PjW8MJaw1R9zhwJ854CATm9tum+yUU5ZppcUnvxEPVcwqOA2pR5xS+CxrP0VzaHoYQOSnEJDy7KW2Pe8GS6lLdtAg6Qbm8qM3qhlPNGSHLXZEnkAHwqJP6zBlSheTfRh+5NmIKFKd2tR4QYsm5z0yHYBOvqLf+8Kba521qmQb8LYLb1ueHBOxn6J4/X+HmEoSq3gYxqrWc4DyDRxZFDEMDjZWSs7/xsYmJbgaf0Z31IjMQbjhgoudW94CxpNfDL5RxDl9wJNSc2hbrqBZdNTmF6YtOx5re0KuV1zRJgzySk8Yzy1G+e5T9dZxRbnT09g712PpBbw4KMB8OuNtuzswvGhLZ1In72N05B4mPdeJv4pfFB4op05YPVNqNycpFKo/1JYpxOOtGbH8FYTjklzpWywFcF2fcXnfZmM4+eIF/UCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUOfM2aofLikC+TMXPxtC2HVOK2NkwHwYDVR0jBBgwFoAUOfM2aofLikC+TMXPxtC2HVOK2NkwDQYJKoZIhvcNAQEFBQADggIBADVKDPEMHMFI5Mj/HU/Y0tVjiugf5zha0yK7PdpRhNoctSKm4gQ1PPcquyRkNPudA2CjwAESZU/tUo0L9KjhNISSJHHriMX0F1Q4o8vOKO74K55vIIG41LyATb0aYBGemmN6dYtJnHPen0VOgThJcfoda4m3G9c/2uAoSFGSdY+Xtc0x82eoq6oVM8iYgK+2kCdzp+FCOcpMFUK+MwUJF3v2ndSD/E8jadZF1+a0rjsQQGj6DxQNCSuW8FBdDN3EPilbQ3YqCWIBtJrhio5l/nTaz44lI2NP/8oed5jSPMxb1NoERh/OuWU9sVmxY9QrCi/+5mMgDsrRGQvyJd8Sz/OyimpTb6rId7ZDRJZyBgx/ApYfGEXjhUZ1kZ78s6YklKW9I/qwQcyDx9EH+hNKqEqbuXdCzrn+RKRcCXD9v+kUXsaBdXWGw3Vt4vyTvF6MPlVieFznK8j99XHDyAIr8gYJwgRRUyISrkNr8uBznMmTCeKZnZxuWj3/BBUcRRWa1bQEOqtfVv5ggl0VeZGgmhVs91+xbdOsYQ4fn0WEGq+mUVWe56/VLokWUYBY4FLGuoh2SGHPJbj6LZSRqO2kWBJzNr2fK25EYxTUj46c/LwYhASZTbqaXLWmBBugFuE4l9UEnMwm46kI9Kt/1dn2b1PE79NLquvZd8wDYxRwvD/O +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMTkxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0ExOTEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAsSTatCgSqYIlojraDjbYvfoAm/adINx2OmC6wrr41KYGTyXxYNCuQaFYerXfvIPDAUajELo0edCfMYkIiZi+2G36c3p6TPBHwq/gUjwmCxrZjKAf8wubwgB/cJp7y6FbfN+U+AJqXxOmAVV6rv7LvUX/4MmCPsFemMVzJZCAGrTdRs/l+I9JQ1gvYxHLfkBfMMyELGH1qKh8h1SuFNt2JPS0S+O2cjC/0Q9iI4iHywKdIp2QZR9pnFm/KBBV6YnrpnyMxOs6BrDHyEHh8EWegeaB7uQX+SE/mfIPPsD0u+mbqW5IJNDbEsnY25k90DhkWyljpxxRwJS4xkMSmRC907UMyHbD+kYrwdbMzD0BdSRHp9z3FoHn+U9IQJCcxz4H9/u0ZiMlK3f/CPLzBggGUzcPs88bqi2USfVp1BjxL3cWFWeEyFkEV9l52uVMNly72+imqhmlcIM6Q27V3uycQBH4pSo0POgmX4+a2fK/75B6Sz7sPIOHagT6Q1N43+ca06VtrNhnoE4XXCdIUQAtRQ+BQv+JBH1xuHnIkUEApFwOgjFVYaKhayyyXcLOP/8WKU1T7kco7hRzm6HI88Ugqwo0khkkklmZY/IFZEOVTcQJjR0p4FpxujldH+CDPLzqi6pVdStZ52BylykCXT6OOSBPIjNYfk5KSBeC8fPh0PMCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUsVLBD0nC5MDAEZ/J/Kvu0Df8e18wHwYDVR0jBBgwFoAUsVLBD0nC5MDAEZ/J/Kvu0Df8e18wDQYJKoZIhvcNAQEFBQADggIBAFZGG3LI2yT8CQg193mfxKq5JupXXvme6L1HL1HtWVW4oASxBnvu4GNk5MSRjMYMq1tCQmdLUrA0vZAYfYTnrNloJoFGklMgmPFlt5oQvwvmt59Cv9Q5Kcmcl6Jl+Z9WJuRRFAat7YsTdTRDTnhuUORHi5ZqD/GxmFbsmfmEdeXf3b+tErYgqMspznFrtzCQumXGGgIQWD6g2asfsYKj+v2LC6lXzvZbSEeIG/HkoMaJ9V8y9e5eE2xIRMHt/f5nKjAJddfZZOagXkVFq3AlJt5F+8lf23CSie3Zen+421MQmfyL0z1EnXze/RYAaCAXvpjhvxCt3qYr+8wyvYpCGW2GRvAFgSu3Ql3YVHZC0Qth66ifXny9FZCoOHutmsWVTV2vUmM90QI18yheTAwxtAq5B4j1fWkY2w3pVuF2gs3RtwoNRJPXH83jC+pZw5s/AejTVJP2jbfseENPisgxQE0PgLUwqBi2ZqPqMPAX9EgHjeuE5cDabbI9uZjV0dDmfpibp/6JJFQbVBzUJu2kYMAA9RJT++xV+VFtwVeLhqd7jjT/oCRI1lOpOunJDmDtMuyJ/VuHUlTd+w8PQXoTOlQpr2PdodVcNuXbC1GZaZHtgXzaZU7oSIVq+59sjdpLp8aaOhMPeePAI+gouIBMuiksZU0SFOaG6eLjtHBgsFT2 +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMjAxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0EyMDEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAkQB6FFYCjCqWnPw1c4M2TmnY6VYFyapXNeP3sLEruBfrD2q8eCvnFxHTaGxS2SUXesVmHJTk2ig4IJn3obtsBn+NxUJxlgStUikrHaCBum1bDAXjF3Zfo8XzchgBZe/oF+hBMG2oX9FtbhFQsf6NWDSwoSJddqyslDT49ORAJFyQEKljolpP4xsJLO1WcuOT8PK/yPk18+B1bqClqzWnSw07x86wGVBzqfD25+2FzsY8clIT+8hlIf11LzgajrAarjy+/xtTVssXVDhmrSOTkNfacQSpNzwUDHFYZBQquvzQw4T6McDaEdgh/iqoMeeLBvY+bTKEI2nkV8W7WHhwj+W/ZRVK9UuCF2ZH282+3pjASnutXh4NwrwUA/7f6YUesiyKyK99Cm+B0q4OUqNHR/AA5RqOPGjax8Ahjqo4qZ6Tim+tUS+IntwSzZ2gZn+OCgYmT0FtVgFoONus/0H45fCpHZXRu8n5SeEM5Yp3fhab5PzDvEk4fivwNcLQRaxw736GHBVdLFGIwXt+Xe52df1G0zA3Vs2TqLNXX2zJfm3NrcGUMENXiVGOSAbCWexGkDAwLvsex0cMZ57q1jOQZ9B2h3quCRnNDiO3ETFcc+E2NApC0Jd4xh4ubIbiBHQzZb7dknedUqgf17FaSguudlNk+jUqeeA3lXDm4wpbXkECAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUVvvIdkTv4zO35H5VDisaEe0ta04wHwYDVR0jBBgwFoAUVvvIdkTv4zO35H5VDisaEe0ta04wDQYJKoZIhvcNAQEFBQADggIBAAeCA+CON6+MaAoGDvCDfeh5UFk05ObMe8gHBb2w7bWxNX07PyEn44r6ZRLP4ySuGXFb/zGBmw6emJMzGrmxFMYHPKnt4HJojP3nt6uKGaRLKevgygfZv0bpi3yrM2fjdqmoFNbpQXewRAyfnMMPSx2xuIGD+sjnLeVAHSOrdezGYOyOT34Gg4W0KwfC0kyQLGqT8vCiFKxiXCu7f782YVb0H6Wn2wUSDZnK0VoKWhiLcJotRv2zcD21CDzLIb9G/vdctDnAVU1EcHC5ky/sIBHcxMQMxAb9FAITd1i3rW4MuL5abCGU/8E/462dWRH7y5Z/A24JElKONPVAmYQaaSn4zaO6HW6p/VFGyRMr+VqWM9SBBK8lLZqe5Sh/CJ0O6Zg8mKETUSkrgKtVTJ7cWoyIR9H9QukrVyflqX0E9E18f2udLCZapwa/6/wAP5ZjguLp9HhaYbdoJH+n+2Dqtv2nRNmNuKvSQru8qfbtnvyvmQWHMJVkF2Hn9u3ncvDcOdNiDyAvhbv5wv4GJRu/hUCtaYF9kHyUHO3tgYnycoPhCfaPZrMIRzrfPYjQ6BnFMOYXlqywn+JIv13DwarpNxyh59k8CuwRFOQWdWUbtIMbv05D6UNGX+UD+OKzzOVw2wkQUly1J/PobP2NxIxDOmP+XamNE45h1UI0PR6Etevu +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMjExGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0EyMTEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA57SV538jQ7UjfQ8QBzk1yAdm/nWyKJZmuC/7slFQIxoXoRSBTT9GOxqiKd9MRS7CimIR21sJOXnbUqnoOaGI8YoddziTM6AUvMsCgJWof4OkPZZq2yf3D6o/H/Zkd/KG/9eI8r0FXtlfN5xmlWc/taJyO0up52D6bXln1XmgRLZx/395SSLCriHQNXgwfQxIbOzuorqSmfwWh49DNv30wIoDT7+4yC666E4gy48aKvKvzTL8lEVhbpCQu6TcExzLo+SXlayETXZLHu+FKNseoTi38d8gvHCqO7Qn3tjXx+0KwSbfLHKRz10wvKP5Xlpax/EWEG6wf8gniJyCdBKLymmtB+ZkSQKlMygc1HggZet2cQWakJOillOUKiXRTLFgGpXFg4vYX1KjY5ZwrYUSiwuAdqrPOGM/8ceEty2BF8B67EqVJ/nqpvq2JHCxs/w2dj+a2irPPEc2402ZCUX8Zjluw2u2PNN5RDAP3kqh8U18r72SS+Z1cL94tsRYbxK+x9hkNaJ9nnMESzVkm4PxTUwUAtt0Y+IPgvustyOxHMMTg1u3mdWi3xT3oQ8oLcYogdhsO8H9a4IQ4VbgFV7M6lON4Nuw5FFDHRMQFcRJtMyGTRCiExLUDu/fGQD79nCArl2tknTqMTbftQYWhAeQMrTW/HPIgoAC2RWjV1NgXIMCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUbc3UblH1PTLHxuIQpAJEesAbqOAwHwYDVR0jBBgwFoAUbc3UblH1PTLHxuIQpAJEesAbqOAwDQYJKoZIhvcNAQEFBQADggIBAAt6PDOK8eoFE2+CcEGOoYG4M48IxgEEWp8GP7l49XJXnyVEEwXH/VFEB+C9b3dRUIcRjnUrTCqDTgDyuNVRsiiyT3evtXc2M/7ep2bK32AW6eEHa2e2ILE3RMmhcrmPriqyBN/9dF7bxDUv7OznafzEtSLVwx0elcfN1ZnOEMNpuDFIohMEpe4lgvnkdwYJYFJyBnpJU25y3Pjr4HLFXtbanklqChFArtknpROov/zDpEsvjvukFFWPvVT+glxwQhawM09y6T/b98+rvRQN4nf6xLSIjLhWa1GRVe0z/6JWnoThO2f5cB316+IF4pmSurZk1n0z62Hxb/QE2Cz7PWbii7CCwGqFfgqIQCkSpwpBJZj5MN3QbUlUIbi8pvP9+ghLdK3IIzU97ncie0opJ59KfdYXTFKaQfqBsA77t+p/4fkrrl1ZU+tIYy/QQOv9sAFHV1Yad0I1nQwb6YDwo8Q3HaFYo4gafNp5EhHVAwUGki67xe1HLL2cVS6QcT9E5pTp14K9d/Pc2fVx0Ne3q1SZRae1lpbwhByumI4fXZpZyl73ffg7uk2kMrOQXAD34c5GYOjmxk2fzobjqcRW8RZLCn2hiQAgJ0qi3DCLF/M/zT8fSms0kl0OLBeQkRAZ2WI+OPMVvHcF3fBybBOO6EMqp8HWf/d1ic3R8uZrtLuQ +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMjIxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0EyMjEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAofzxOTTd2EhMc76QsyuWasbk6pyrdQnCuK11gbhl7pBHz8SXF5+jm0kZW4gSN5jOJXvLjrEyIRonpiRo1gvvu3yVNbo5132/QQ6VLpwVCGkJgoaziMVcN6lziHReVbcMx7Eo5+BXqKd97Cgd8CSPjFsKJ+c2CDk/lIbkU6JZTDX3SQbI3oux3dKCzWLkOpwRU5zWCPsptbz3E/mIoCh8otQD+GA03ZryDeiJRylVRwn2uGCIhnsLM4mqQW3S3XrIvfHXkaDfKHEhJrCWrvgVoX24d+PNGBc+r9jYwQgXY1hDklCYrr331tLaraVVLUmefy1HTHzdqe4pVTmS+LiBmV1Fv/Wukp55SeuCCzDulXpmRjIIDfFIhEBjB+ihK7faQkiXPNyDvn9vtB1eNAaO75CLpVIQzeMIvfb92Oi7yR00DRrE0/WhJcfGfNjEYlxXdcLDJZsOOf2hMvj3/PCu2kgw87TzbdHzqqgBZZEE79lWeSzatWVMoZsUvxlYJYcdLf9KOn1Tu+M+e3jQG8vecTlX8I3LEchHWCxiUzhP4x1LxdE7UrSaltlhNCNVrXGv16YvDD4S5/BWzCZXtC0HFfdRBwdOr6bhzOWcGWphO+iyydqcMrztnZnEAdkZEGJeQK2eojbJHJgy3bAVGZAiC9LQmA+Yy9dMJTf2z3DnyZ8CAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUClD0cDGR3tAc09jajGwwFhWCK/AwHwYDVR0jBBgwFoAUClD0cDGR3tAc09jajGwwFhWCK/AwDQYJKoZIhvcNAQEFBQADggIBADGVliEzwaSNvVyIqGZp+yw8fWZLKdfusaTGy7EltSPfMPkpI23QUxP8s57PesZCPN9vKOndUe9jKyqUg2qkzN6psy4Ytgfr2QBhaNivpr1ObQp38hwgJpqvm7DLVdvbPz3LwgjyFPf9j4jnTwVo4F3IxhgHyqhkiKGu21JoiNBUgdt7AFYRnaBCP3HmSbxrYOX7mp/hMZBTkKl6Uu7rGfsDVmRdfP+24E9lW5LfyYZ02vxXVjKac9xd/2US4XtEOnOOhtxDtq9K1szT0fM57wur11hntA7WEy1LtRxGB9XB1jId8dtcIsvAnvGq9kwbpBmIrO10kdvuxcjwIloi16OM1cNqVhz/euCQMZj4jKn87KVWGMGU7HqDcERZlOIzOpITYGWG2JQRkV0800a7JdFx3NDIT//Vu9IRTU8V0IAzkyZVM0RLmXVbj3+W+aOwNvRz1qfn9m6DtySP/YmGpf93vz8MoGM57pASpIwfUdcoX/yx9ZQI6mziKLHQ7XD36oTUh5jdZP3BZeW/jCuZ/HX3UlWVIq3XM1V9vvUgCzq2VPDVKPomDBt/yLcDrA5GdGvLaqUs90gWKB3NYLvaCTVvxsYYviZHLGKHn3FaYjcOjcGwYhOVte5ZxqNQU9/Mb86uTXplV/xXIcbut3RrGpmr8GovrYZDpPLPL56M17ZH +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMjMxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0EyMzEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAycSyx39s8Y+eHDuzNSU+TPn66GpqPiI0bv8uhRRIITy083bmIOePj9JTuXKQ7kgmH95ZiV+41uEvkNoHE5KBk2pwYwicjCJziVTLzDApDhi+UI1zwXr6ZhDsx/Z7rK2M1wt2/UVyrtA/S0WudiJGwG8YKLWObojvfbyby/cCE2CizeD/iNu+1ZSaWqkAnL/GbMSaeHBTSklwVcjSuZtWMkjXrWxgbsd+sl5T3X31i7toH32zoryNFMTD/WqCWUnI+pMRW/8WShA+c05cL4uOON4Xc+dItTbs/gpJk0faf2ZNOnkKLed8cdGnw3iuT3u+8RxRTZ9lSOvy/rj2dzCfj7Z8Lghz8axLQ/M2uusA1I0Raxx9gspnpjUA8pYSCgQ6RnTt1I3VEjMVQPw3qut+t3KOFb8ZuA2fXxw3g6ZZC6kkjihq3QHe7FpM/hOsZ5xy+kj0aGCNYvBl3l3SO5KXvzIQKldTvSkW7TzoaWLzGTYBaGdgh6ttg/OXsgweFZGKFUI+t38hV4VJn/tP5oY2vDDay9GFxgOxgut95DJ4e4psrzbh0SItDdTlQuGWZPp/4ifgA/arJZ01tUAiMtL+Ciqst7j7YmwFXes6M3aHp+tLYQa2hTfqDcL3p9NpqAlttJfu9WUMzZRgYkH6aBks1gStw+tXOxSIEYdRFH3yE+UCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUzpbxDSNV+AB2w5diChUp+pKPyfIwHwYDVR0jBBgwFoAUzpbxDSNV+AB2w5diChUp+pKPyfIwDQYJKoZIhvcNAQEFBQADggIBAGBnM37IzPWjt13P58C4/kEYPIHTR/E6uvmie+mb5Wh6iFrxA4SGxOHZCm7LhnxfgUhtqoa1nE0CbinV5jBCOOnGlLVYptsKo8XwbF1XDEkqgLhKah3yTxOK/Q8CxNmYTg4Vq4JRhMNy3cSP15e3xz1SkpjbO2r/gdM+7O50tJuwOoCcfrogzdpDk4OOH4rSxC/j+2LoTCLZ0ZkFfFPl4jyF779VALE/nuVaZt+p8eiwrgVvuaiYiKXSUXv+xuXuxgOj01rbSt/wSfxMM844u+UaI5MXr6XwfpEjw5txq9EoVBhQn52tIamQO1S0/G2eFO1nrONqTrlhLIC7lTQ1k1it8NIIYF05jPcw4NtctdIxtFOGjhK417B2LTftv3Toe+VTLL1gp79nKY3anhDhxbCaIRhNQJovdowlSte3ZFkCricWbmCMH7bVZgHhG9glhpc7SIi2h+ErkafZy6CgdlAzc+BHw9K57cL+eAYCN2n6qBLfoUd2s+365sJfwqGZmKAcFxCSYgoyxIBNoD04/AUpJaVZXUWmTAi3LtiotKqvCHrz8bDF5BkK972gS8y8QBovBn3GIc+N5l+oHBeQ7QP6+D92Mtq7a9V07b95WiiCIWiiCN85SflRcW9bBVvK31hSNpT3CBF6a1Chy6L7lHONL0hjfIFngMm3cZVp3PoY +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMjQxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0EyNDEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA34pTDnkysXgRWnAfY5EIzESc2Tu9XtI1n8V4AHx5bXMB/YTRqXIaMW18KLXg7KnBfpT7/ZY/pOWfrvhlTUjyaPTvcUu3/TGXmyxe4Ds1BBmNQBGeFaLNTwnTTN28srTrdjcbxSM5uzPXE8VFrFc0gi3RaQQNf/hZ/gXoRsqU6xX/N/MJFREUVYOh2KdGd1ktUp145atUSECf/TXVOAtIV+G2RDP3mjlKIUvEoCR9nX1NDkMTalSHNEfA6gAk1IoBoFE5j+upsESO7M5zoHsSLsxZpBcD0IcZUAQf7/Fbtp15STZMQ2GTG3k7xG4SN/2yuUFxM8TWnB5TG1yNhZBslXWM6mkd9go91Y4tBwUxJZMSLTRFG2JJ4n9VB7+pc6v2qxvVPOVXTZrelHBrTv4YXAPpMQ1Jg7F0GuYYARV4b20saxsR560Lz1xxg4MTx69fAem8++ALeV+c97UCWBsspeV+RouFbcgoTyRfjeUgMsVt3iiA7CpGvvEjDlXKmLb00YqEeiB1HsVmK9w8i0lMIe3z5FR8KsJ3SaiV08gnVqgC0oPm0R8wS+2Y0qk6e9NJ/KsQ5v0vV54IFnE33JUEa2UL1+f5RGwCzUYAG8WMeYXEkd+bv0pHkUi7VKTR01nRWpbGzaY5qkkyjEQ+6lvn0mnDptWobCt0QbNIKkwKILsCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUsElTKhwdL/O28MBZ0uFI4AX4dUYwHwYDVR0jBBgwFoAUsElTKhwdL/O28MBZ0uFI4AX4dUYwDQYJKoZIhvcNAQEFBQADggIBAIsJzIht7Ui17542TLQ1sZsWD2AWNShMwYpr9YH2/t7fcSfgOZ2tpgqgwNnVSYvcIgYcNjXKeN+t2gUzY9q4dNM9qx1kD58Lfgvgu2jOtdVJ7+4t9S0rxkF8jyC66/wD7dP4YuPfrjIUJ+KBft3DVvQ0o+WD5wVHFvx46Yokf8vmjZ656K/XTnGsTEQOBo1yMody2ys83B8+FwWUs0bpMZYBy7VjKd9Teqpru15Vdzm3Bp0fGldUD9Rpb1l1R6HppfSzNzlP619SbA/zT9qXSiNswMOmP53PI6sUGzWzZjChT43BlPk/ERv1wBIMc3Nl0Wod8e3Ce3nMt+mezyH56LT0pFU4oXqPl2z6jqotyloyMHQr9yzLAq9e0CU6OCzgp/DyugS9raLUEAerjrlmMQdUoC7WkG2NYelg3AGPNGFaC+58a4vJlBm+Z/yPd+VQUgEXk27SUdkMkOBjgB65lQSz98/umASL1xYVL91hzmEqcxG01ggBPBylx6HHoRuRORII8I/NgGpFaA1PGgE4sa4FIHTUjEIcrucjkvb/HGtXfxZWpTe3lUWnh58PacXW5LEiaRWux8gxuGKr+h3uZOEhlLtt7AgzpUSlIUeCLvgjI5TgLNkfowMAdW63N5yuT6Kc8aNoEytoCiaROU4OssDwEJ/wmYXf9FvNgpinpia8 +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMjUxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0EyNTEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAhjhfdHBfe7Zbsjh76854Dv2XLmQ7UhJWO36gJY84gMlNJxGd5ZL5PAsCRzfUmok4z/CPevqNe8ddwnzhq+DMNSJX1IjQgmnH3+40HD3X3PRkyMhV6M0fu+RRjMk0fBkjikbISKShsTnbhn1ZYmhblqPgCjnnFjqEElvRTIpjZwveqCLYweDSf0KDTo2kSjjAn8lsMaIFIxT/visgrhZzQqWTeHkAbQTPTZClaNOASFOFGo2OUrm0r9/40PlU8i7f3VDZ9+bR0kcvzXskMmRvLlz0ovoyD14YU6zb4v6qUY85MHD5s7doSiwpEMBBXTxtWgeUTCPt/Fa7MmGEHgwjXoB5EQTLY8oHsXd4FEkiD2VM2YN/uM/GReFa6IVPkofquwk1levGOVzlxF6kTS0cNt8xSbTRC6YhURKinhNwrZVEBfQdnwiTtQUmmizxSfk/x7FexaKAb/DLEC1TMVdndKBWfB3/z790k95rChAy8wWK9raAJuwExWWfdIiJoAF/2sI9y3BlZVjpIzIQXU3dadlrMt8E8jXfDpV2L8nQTUhJ0mzTMgNp4a3eHSnrjdnxKub7YaQfN2jBehFo3w1c53Wxu351pE27uR8y/o7WbjNBjodMufn3u+3JZQHs9Vbl+9ziy85zWe0L0MifTBPPgKQAvkecemXlbCH9By38ENsCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQU6juOWU+ZZHE8n/KshVQGysdfuUUwHwYDVR0jBBgwFoAU6juOWU+ZZHE8n/KshVQGysdfuUUwDQYJKoZIhvcNAQEFBQADggIBABoGgRmrCrNP2JCjxfo5XIH+0sFjm3P77uqmCGKthUVp0UeQ1fbhHyEV+UUjlbmkf35jQzP2nX6W+vxOXJP2mNpFcD/3+VMSiRVa73dGfo3aXjpsmWIjMLX7iF2T8ekMvz8AIh1ej3Oezf2IwtX3SyqiI3RrxcnHYiNv54r0cekjx8YDPt9ZtQk+W7Pg1IOFKCS8rDO+ow34gzpimEn3IZRBGw4ajzIF9M7AA9efPzSUogJAK4cu8KLT3Cge82eoJprEvV8xROBlUxatOPgNW6SMIXHGktPP5e23Z+qMsJwsp/Qteadjupjs0jXYxGeO7XJLZ0WrlTm+diNYn3k3mzN8x6gZwiru/u9u2AFsajaWB7/3TigDMR+34oehSnqZjxpuThQW3mqwmlxQfxc6MiO5nBM7GNY/z4mkGxLFBBkLnyKP3ybAVvmN8vLm/9GAfSf85UQLRAXpEe08eDIPWpWwNR9dUNZDa/DhQyp4W9k9k0b8CRB8xJ+mE4rAJQx9gKVqDJryeu4pSw7nZ/zGR/9Pk++MkaSkq1/hI0CwUfJhkLhjwL2ab2IF7iMECFN14iBhtBBIQMFvOdm+lGTm8oad89wyX/w+7PdgCACTFsZKCO8WhhJMpLaApIQuiWtO/Lh4wM9hEW1eoGqeqqFPsv28thG1E3zN0jvZjZmi0jt8 +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMjYxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0EyNjEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAoNoBMZA7+bya3kPiYK2tYN9gjl17jlMSZuOBvfDvVfnv0c0jmxL65dNzCtnUMPEppOgQtqLhn0n7oDsOGfQ5QifBwVI9XvelXzw/6QyzMmGqNV2o1W390/F9OSkhGeR6xiSUq7M3ryiyaaUo5SwVZbRg1PRepBlF23BbE1Dj3OPkerJBZBtlEyVm0lTMuai4LKlxLhpGCW2d01YmrK7D3/vG53ibEPRQjbwhaDJPJK4z+/aEoJICJh5AeVgoNR6ibvG1QOabJuL7dmmW6RyDYy5HQrN2b/qQ5KE79dT2NBTe1eGQAZamgBBmCDYssKsms4SKkyUdWCXk7SQk/7NgFCAvVF6/twDALXT0DwRCn3YlpFLidgKnhCV2ysuLM6aE7p+CfjuK7xNhR5wtNmIduvtRNWFc3DksEG46Px0cDoPdpzbZDm0KIhaYhBy/UE0mZnHG+2MgYYhBEVjqk8ov/YX6apn5XAemPbnEa0uSDMJ+GLl027HO1TR0ZCS7GdcOhBvPTPx3dcfNZworQmWkiuT/vJP8sTgVevLhWIJrzfspBJuC8UlQauAp643Q8Q7hABY6pc62d3BfHpyPs7M4Nf6ElgdLo+XK5LupClg2Zw8TyRj/PbYc1OK6Ec4Asa4z1CoezoioXWw8GKpnkt/cw1/j52dgVVbo5fwZFpmJkkUCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUVOYnx3/4FAIM55RUYonR/yQjKB0wHwYDVR0jBBgwFoAUVOYnx3/4FAIM55RUYonR/yQjKB0wDQYJKoZIhvcNAQEFBQADggIBADMX/0N0TyeUurCwwUl4BwQAjheU9oT7AUQOoN2ZPAX6Pulw+/YJJ0UN9ZU2KNKItD7XG/4eqbr87yIeM9C+0g4dPvM8EoQu8qZ+0h+xJnHpPNU4MLdx73DbFs+KoqV+KIEI0KysTCYN8cNMx5EIGCCKyfXximjXdtfrREBmB9+fauP9pXB1vAq/5fjI7EjIPKcd1yMrwbKTWRNx86ykTAhBNybRTHr0LJUHUiZ30AG/7grPBQLO7e5WBzkYTunYbRjDoYKW7q6wfiv5w2Fj3fCwRoKoT61SA4/dT274LIeBzKZ3K4GPCtB/rvBNIJf37g3yiuM9oeKkrVhtoHfGyoWETsUTMbfIkxy0UXuNDbpDRjQNUUOL9bO8R0wXUm87leob75Jv/zHBaE09KfcQL6G2h7H73L2xU32xKWCA20vO0E1wULznpogvYZQq18rupnBq6DHsdc8hj9icnIei58ivJaUQh/+6FnTLJKzG4qstv3gov6KrY4NPLgN1TqM+1B8jSTQ2rOS0ofmzvcCQx/oD1eboPWhoeaieIFnF2wEOjesME8RdsCigFodCPO99Y3flBu23vSrcgDMk255uz+IUNJs5DyhafO0DzyIJ6si70gY+nosfnLvMRitF1DxFWQEYeZU7obXCr3UxUSe6bZxfGTJnGaFpQ2KI4H7erBkn +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMjcxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0EyNzEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA17CN/UlEP/MUUpu7zIJjoedvPl2tGjNgKJDblF4dWrqrZ8DDjI5WDwB1jTE97Nno+xvY6+bk6iIleXBrauzj/Zz+stCxl1a/OcTXEexJqzii9mKSpbtfL3XVROVhZvYHZBgTl3a/Jkf9Eb5cvaevpqsWj+ZKxId1mL7k4SaGi6VXyuiPj73qMXDbT8e9AZ6HpI+hrBSHIbj6ix79g5GlNSuu0ufDgjCoagFRnZZHuVjInvdiZhjloFAGGNQ1cEe/0Ct1GqionmvKwbihqyA2Znwu4/olUgVN0XnXMYIcio9CfF1dd86Ltf4MnWSlo9Ladi609T3NVRL3XcY0Oxcd9wBg9rxJnGbXxjBWzaOnHLn28VxKm/lyuqiBKPvfy/d44aLnfuuALLFNaxfwXlq812X0nFTsQ0M01kId7EwTMKs1cdR3RDOYrqxI0H7fSP4iHer9nYj3pAZH4kXDsA1hilHktCvUQMSyGCZWe+G56tu7CwKY2nD2D7mnXEFpaOLNyshxD2VTDEgv9MJk1N3fHhSSMMxvsPex0n5A+H4l8l0CrD5I4eHy+kf1+nVHoEMjFkZdyKy2j12wCmJHVyLFD0/2CV9i6Wdc4gLPqQUl25aR2kF9aLPFMC+8tFH6H0GjXbQ0S6O09i2ZdosZFwu2m8nLngYYqh8WFmByEmpgxl0CAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUifQmgLfjENchuQGKrLTE4QV77/YwHwYDVR0jBBgwFoAUifQmgLfjENchuQGKrLTE4QV77/YwDQYJKoZIhvcNAQEFBQADggIBAGAnHNvwlSF4/2+N6quBqtypA2roJbPZatYsCRGLoSgfepVu3Ig39H5VV6gt7OVWYErttmnfwjWuTFE/mXGAdf05yFRIIj0wW5IhtIiVY4mnF47klppQ7nKs0aVsoEPLD1kyrQLC04faYy9JmhYyqgpwrt82/+gl0eVhbZzF+tpERTlnSh/df5LzcM4x3IIHzgSxQ+AQMI1Uw3YG6/rZ77mH5k/K3pRRMUB/JNssD4wNm9nCyPQ6UQiCQkz89snNjMGLvfWYDmwon4n4+KZEw67Ii67dE4cwAcnjlx1uq6ClzXC7xRz086vL58dIhnLRbAm4Awpv4so+P5RMiXFmslNIFZSttE11W7F8bfuVBxK/TPdM2p6kWJ6dG4Wa/5pVgLBPtnYA6TKXAZBW+WTT+cEPuO/q0EVlaVfdLtnI8V9BUaQZ3uKl8Z50VCz6WSvEDzmjMqoNQ2eOtAL39upVedpkCcIIolsy40m8zzXGA4cjVnr2chREmwAuZPVCpHMmooOFz8muFCGiHf8K7gX6oIP07u2V6zM39pJsjkrIDAyEqQREnCt2iit9VGt8cLbxvUkhRI1rnhp6YVekSv70qNYYR+Y2NNRDScMDVkiQDhdv6pRSvR+h6nr5a0tYSX2Nc1LM6kLVpS867L8X8st4AdD4ujSK4qwxykNbzBthAroC +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMjgxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0EyODEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEArHlyW/XzSgqzVQeXsipnUiX2WHSZlZo+8bwWI8k8JAxZQN/9Z1/WceZATzk7uGQjS1jML2rLVybLWYjOjuxDLroBxtt4hM/mtdioZUFVnQGhm8aafeHoNPcStrBrySFHs9QHheQRuTDt8jqS1DsZ37ET71oCZhtfhBBghkQ2jWP/6anhaCuHoadRbOCo9/uhNotxjzFXgBE0KGVa2nZmZLvYU0n+EEO8Rau3pdpqAeFDJN/1M1JRfKU128nWRpr2Eb5jRtYx6F22i+lhc9cSyf+X+UI6cAQVzNTW8CEKDhTeJIbeOAOnxkg3chCc9rMDmoUQ7cMXQ7y3+zIHY8HIhvnp959bGLFDnBiHV+E2uoEPz4iqohNAP5bHmYg6MRFw8KLgcUFXI1KOpR0knHxmdYIIEYLVAd1KIAs+iyH5Ev8hJi/Tq32OViK5NlhjsFlQ9ACAiT+PNdNWs/KhKXgyLYdn3qSqc2ZVPy+mTJYcSyTgjP9veUdubU3g0udjGh2F4IKfsolPS//QA/72uB0KAb/e++u8xLBIEa6sivsx4No7AUZqH4RChumaejgT2RRrwfM8KVZ3NdXW4tiLuVsMuJ8i80bE657M2A3MMstcb0sSaaM//AsTXJG8kPVxdFt/xfTb3uLUliG/8XsBt4WGGa0ya1FYRL3+Ih5FEbKflJUCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUFhsSXvQ0x07or0Y4jjHModzr1gUwHwYDVR0jBBgwFoAUFhsSXvQ0x07or0Y4jjHModzr1gUwDQYJKoZIhvcNAQEFBQADggIBACYUfyKrGFO6WstwudfHGijC2uuEdyoJt9h2NNP9qHwczZ1v3zecckqyJVijadSGdo5cYkcoihcR4XAXHvpP4pbFXgLbczRMsElQNlRYYvsc/oN2iShh5q9KAU9OVRomLKveKVV/8WqJjA1xK2zWgLD3bg9RJUAfovRxYtT5rp2O6g5qT5sakLVNB14PU8JOWOfzKF9QmvmUs2TAh8cm7njQenV4hvngOyKoPn6MhHO4TScxurNwn2sTO1nRe4yjPNHambqoSVqePvQpvJw9oa+BWKfOxxoeQXIJAM85oURGWJ0Mz8JXj/LitakO7uKrgME3Y3Yr1pB2dmQpKY7ZH26+V5iNSgGihjZZecNlkn9M6XzSMDxD54jF7rEeKgtmxg1zZDwb/gCTH/0GvEuV8gsLK8LhcgMhGCsjInP1E/4Qd+Zuea7lQypWk93Ef6vpIXLuSVY1vhs9D8Y0qChQ/J0b94aecrBcUc1R/p9EyHFDJ1+C33LebeUpQ/nML+WB+U4ORd/jO2DPSzjTmFMhYFuKApQSNY5v5rKGzF2e2lJe4PxpLkYshgZH6MtQGgItGD8UkLpaC/oO3zmCLbtvZe+MVy8A/dhrmPEdCFj6Ko5UpD3WosKM/rcuw7NS+MQbUG8DdQ7M8MxN01iOIdZZHpyJ5xIAgakxvPUIBw++sa8R +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMjkxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0EyOTEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAnDFMdmdoKhsL0LuDcFr5cR3x0vtbf99tlI57wplLuAGEnjF9v/1ENWnQCdIblUep0JmbavoUFvxR9HNauBtJamVZ+WQe2wJV//j7q5xnu5CJWzUzsyzxQBIzu4GbUtTSSddwJh6Ip6CcTaBYXuDbSui5Jvy7l94+O/A3y83NYrbglEdyftkvZbipOeeIBhuc1xqdO1TM0+4IeOJu40/iqQ61ByD+7Rlt7RQqUSF6tLfX7L9CbSQm26hKAHvALOvSbGigM5fTtzWs95iNuU9nfUuNK5jvraRqP0HLct91ScytJfYLk+VJOIP1tJuUTHdG/N6fGZWVy+QPZ3pwuXflj4ZGt1DH0exK/mzlFqpMgnCNkm0pIqwDwm7qy1DEvQQnC5RPHm+wWEyGnYBvC3vF7O+ldpmlyvERf+4lUnoxNDgyXZTs+8OHZPnzY9eYNNpzpWvwwPYkk9/plK3fHDr1Y7RTZtGX+9Gbe5+trKB/PUo4F0typFLCMAGubnPRVeC/HkdxY/WNY5BE/1GD4/hvciivY9zulgDXB2EKH5Ng1nUYllu3um3r+IzfWX5/XRKTUTY5kUXo/cjq1udxVtdY+8Ilx6jvpX3aIekjEbMf/KvTBTPOn+OZaDQcL5etb5grFZU5r69xHH8JbDELkm8C4wdmKZB4d5d+aZQbkExtYbECAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQU+RjVp2OnJtCakcARnvbk+ckdn7owHwYDVR0jBBgwFoAU+RjVp2OnJtCakcARnvbk+ckdn7owDQYJKoZIhvcNAQEFBQADggIBAEknjecHABK0WW3Wz7La2AIJ/500BgSjqXquIgjnGU21x/9sKhvnmN40lMrVIAKOLuEBPz4pC+g31Fzxri8ibnUAv/aeL0AAx3F+SyK6mKuD5gDZTk6zl+YszDxjcXO4Jokyjh9LyuPRxJocvRjj5eWBi3BIam1KZqzoDJh/fdqIeTkRpLWUkM8WVsLsCC8zQtrRgoAvgZhkLZik+tm3LhogTe8c0c4ZaQlT0Mcib/auKw6klbxnhnyd+SCq2OEYSJSLCLsnoqjhz6CsJkZLHZjDxatL9xuPiKbfJQq+q58D51H4zBoUu06W2yhTNsE5Nduxuc9WoimKvSTfhrMZpXvYviTlWtld4sMTzCRpQTlN84hntjx+9aouDSo2ZhVUNDkTWnjaDqW4WyB9J7UHa8Dr1ohYvlGQmls6zkv0jQrjaA1JUB6MwOKQO0IfReBsCGC1v0mdo+d1qRizxJhcs+zezPZF8BRFVQnMQtHeKc1h8Mn8R0Jym1Xg3L/nCm1YU7vSKvPFhkHwAUcToU84i9yuB3pVx451EmPnfFj4+XjoGlBjWtPTKLnHO0VqW69hMgOY/Lh3Bk/B3DOGXFLnV0WaoS3C9q56JfL9FcK8s7xZpwnNG/iD0Is/BeITpQvCi5SFjcFtMQQ1qsgjs9BSGzR3r3odn9PoxP3dbJt4IYJi +I:MIIFTjCCAzagAwIBAgIBATANBgkqhkiG9w0BAQUFADBAMRUwEwYDVQQDEwxUZXN0Um9vdENBMzAxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEAxFTATBgNVBAMTDFRlc3RSb290Q0EzMDEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0DRGCA8fPfE5AntISCHezAIGJCR1Qc4LBNZmbw6ZSA1xav8TuBMN9NH7kCtSxUpTYeUaOsfzGJlsDWoGMMoTsxny0BEyHHXEtXkcmt8iCjJqrZgoc6LWYWHQ9rm8tTKwFit9ZUn9X3TjRUIOF0Cir0BWXlZ27S51HuYN90QI8KFMaADiAg605WSvzPWffjB9oQC+a2DItXhrFaMIiXq/dJMeJ0ES8Rc6n1kkwJQtfcwUIe10ahcwycgxG528c4uzPvUH86i9uEtbBjy2S1dbn4svtceggxId/g7K/jIyyXMJlImhVT144UwPgWmi765jTskSiHnncqOXf1Xg52u7pKxguTNfGVRAN1Lv4X4yQ0pjhVDBwd3oO3vlVN3mvsbYqI70Axy9PjOHVA+tgiP3QHclykKXm2ikT2WnqjfsQvcIkvMqrMQnqLIWZ+Hk9zX2cZpamavNydcRt3440caNqdBcREr9bTW4fDcVXGEKCpvaFHF2tnpcIxLI/HY3joD8HYmGrxnUImTT34jJpdF+jNiHfSXXGqduFk4lfX8UZ1U3LOzA0srdWXopzrTRxqFrHeRWxX7WTTFyYM0uIe7ar9aqWoyJ0QecSw0OafdY3P1VvoCmGg0GtV0nv9pciRmsneRxm8DTw7Sl4z6B9e1qik0OLkQ8u2mq+Ht13koPPhUCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQU29UpW87FN1IziF5j7Jbpyuzq1AgwHwYDVR0jBBgwFoAU29UpW87FN1IziF5j7Jbpyuzq1AgwDQYJKoZIhvcNAQEFBQADggIBAHmQVHoTvBlqjh8kF5XEzSazcqK+Aq7Y1cICMI6A6xxAr6ykuZr4LPQOSYQKkotqA4TniJx/5b066V+O74XBX2sWXP7EQ9ne+whUXisY8vCGZnevgxksAGEvV37HnPU1YNLeUgxnnc6JCkyPmDW2C5AcYDDFWlGIL+Dlq+SnUkozDoV/Ct/eadE8mzIF4zF/rXAITn4olSaax/MJQCRtUQU0TikjTAaLLXEsas9xHcl5XdvCvd7i67TY5ecOU/wkQTliyUTgestPzWRaCoqoJ+BsD29izeEs2NNLnrskpidx8+l5Cv9e5Jfe5Kvb5qeSfqSuL2dO5JcAqeBlkQDYSHJSZWlvV9tLCYIDSOaSJsLDUfGY34FaPZg7f5j7EYjaPJekE6ykmJZMw0/CDZPhhBPhrAqXodJgUvYK1/BHwRaPJ1WLrbwR6uo4BWaSK+2zrsUshvmim8lxOqJ32s6SQqX7ei9ogTWlnPdIZ6mTRnmphGgpMIfcZxSjKLoa3h/YGn81+nbBxLBvaC6M5y9lGyv+5IODA8RMrz2Vm9GA+BncyYazgtCvUCKFoMonakBpwzT/6PCdFyb8ajnjnJtCVRFWhQneHcTa8mHtTG95kSXEZXusMy0M/nhb/2iq7jqLcMPQ+jY5Y8wudFAhYPE5K7lawEpESxXpP90PW+c5KHtc +R:MIIFWDCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMRowGAYDVQQDExFUZXN0Um9vdENBRGVsZXRlMTEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMB4XDTEzMDEwMTAwMDAwMFoXDTE1MTIzMTIzNTk1OVowRTEaMBgGA1UEAxMRVGVzdFJvb3RDQURlbGV0ZTExGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAIym7awQRDVJYBuxApp1zX3/KAx0MrSrHrloeZbio+akq13ZMI62SGEmokRMLtZtRlJuGMKNgnSrfOcgNOeevVOR6QIba+bfkMQunxmK65UcJct+ybOYMkbtcTDikATPY010dGAtXHVb8EQFoJn2kvcGpjO4xorbOqjdkQkYQ/IreSy0a/ZhtCh1vkb0jIWrPzH9tsAUpZfB5sbHAxRbGEOCrm91JVOvA6eWxB8LtNeewGlKolfSfDVVuoG/CJlstT/b0kYaMdyRUxZPrLz9B2vQGboJS/i17ACKVXs53Iwq1sKyzXl6tKt1HWUhbXczxVWBrWcsbTSZwRy4sn7fpiM8gIhGLXESR5Uxj9NKERxkjyswuMxyBBDVllmfYO3KVYVNlFMxMYMZtBqod9uZrslLmq7AEHBl8CjIOwl3W9sDuQzhdZ67gnurCiB0BlmOGIG93Fa50bHSmNaI0YDARRI8yURezSlD3RvYV+WhVg7NNrFcGReeYN6CVvmIjQglwAvu2oHVNP5xlSluRHJBY1IT6y51GFhhUPLfuY+Iz881gD/QBvD1hFlGPwr9OrNW+O0NrTYo+fRgwfus8i6g6+EgE3m4SdvLWjA191o3ZUWIMNTLplE2HxxHOZB/etpyeYy5yGa+NJmhCxEVDH0hyJRmXCS1TxQjUIxsEsLg7IFfAgMBAAGjUzBRMA8GA1UdEwQIMAYBAQECAQAwHQYDVR0OBBYEFCsXXhq+QrpDNDiE54U4bmGSHfubMB8GA1UdIwQYMBaAFCsXXhq+QrpDNDiE54U4bmGSHfubMA0GCSqGSIb3DQEBBQUAA4ICAQBRwXUK3ggDbeFJqSwB+jt7kJZhJGcA8weL7b+VpJIh+jB+SdxkIOaZ1BVVUa0f6yJptvPjlRN5h8mfjZ9o9y7dxLPzL72hYPmPSbrk2AxAVakWlfNbx0bGT5ZUKMfSw0FUH1km+8ysjtkyMlFrrZ+pg9gmX+2VlKU/LrtlQMJqBTfqXv++tcDyYgh7jedSceLpDDAFmLctd9Gy6GBQQ+XXvGKtnTqP1WfDrsE4XfcJghTUOrccCNtip2Kj3Q0Vd3xoJfp3zzMadaaCHnx7WVLtD3dmBufXFr8HpQJzbxyXnxcGAKSaF+TW03cRicaxJQ1S/w6r3cJ6G0bHXUY/12TxyCFW8qiPKPVWwjsJiuarVQkrZc1QEMwRgE8ixXHQzG2vt3xn2U4MYS/zrfpSjRfq3RnSIriuuuaG3nDYDezCl6kDqHQcoXk/qo2VR6Cmwz4hGzlRnXR3Z0TusP8P5Mf2FrsFCt27MqI3pseRzaxRDi7cTSaZ8fhD9Ie6F0IUHmhJ45/U+2AhlIl2Ch4FgsfaPHoAPA7hnCUOIH26zpTf+sJPfYtu+buV0k5PVJCotK3geOPScCGvMvMAaUmYYFhS7j9pDc4f+/EHMxs1/BHcnmIWZzwhKEgowyG1n1yhndft/FWmHg01lalFaMfwhEA28fSWT4jx5rnVHlh45pvUPw== +R:MIIFWDCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMRowGAYDVQQDExFUZXN0Um9vdENBRGVsZXRlMjEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMB4XDTEzMDEwMTAwMDAwMFoXDTE1MTIzMTIzNTk1OVowRTEaMBgGA1UEAxMRVGVzdFJvb3RDQURlbGV0ZTIxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK/U13UGnUuin5zlPfYo0jMNJfxmkK9fz3AAHg2aqrh0rg3469QRVVy5ioY4fDU17GCcN/gf2eqRrJE34TRW5IN/VKEEb11i6fqvnz/lWeVG9LJXaG5+ufvlk+GHdFIN8ua/bDCsM+kePGg7tydFgfYrWmXNvRDYyuyNynJDv8t7s84YCLyAwA78VyO2Vs6P3zidC3P6czfj+lYTPcvTUKhM7X7/u/rzb27fjZS5LfeMuMH3y3EBrM/Dqk8wQz8Cdnj4w4f7nbp0METvPoIHtxRNZ9GqBb4vd3D2pWDBs+xSqDt5vtG97ZEJkfJT5of/HXfRgs4xhIvsLxav7sB0Vg8jVsyVLl0C133vfS+FSlWXq2/Z1ICXhx9Jr/82f9eQe0aiLYIqGC3jcbTPcP9mQeX/cbyTjFrESZwNcmsaIE+DU2dIvTQ4dkbg0xrIQO91lffRUedoEpjP6EPOQwcMZGuKq7rbWxaLJxeNV7WSs9SZz8PpkBvVSMRa17PtXYkTGjqveL4sArc2SaYsKrkuWOuj63/DfhSZsknaE89hybuT9fJl9WlmWFZ3gcUIqvAB75tKc3UGRPJDgM1ZVQ1Vs75lga366kzZIO+mz1XkyhWRI7NF9/WrL4TBlq0ulftVw8dD1x/UXcHJU+kg/2lEeKeH5VB7RhE68iF3GfFGovibAgMBAAGjUzBRMA8GA1UdEwQIMAYBAQECAQAwHQYDVR0OBBYEFGOz8oc+n7i0fnxWxIFXrfxWWjTEMB8GA1UdIwQYMBaAFGOz8oc+n7i0fnxWxIFXrfxWWjTEMA0GCSqGSIb3DQEBBQUAA4ICAQBOSXsuW4CaqxbX25WYGSEfx23mM+RMFEZ/n1gPA+XazWlP+7kxW7SOWRzZ9hINrC7sdpAEOveC2Whnh8j3ytRNBlonqKUTM+F0h27ugje8uKbPeuTr7ih+NUrnzPw+kOrAslDWSV9l9bAEtHE6Smg290ZkK2TuzZbA3y8FwNXoUXniuSviUfMkV/rX6ipAji9zqXj20FihlgPz5GXa4GRHbZJmPZhiSQ09fYhtZ6CrC9Tqorlk2oSiNcrXgTnnOFXM7Krv5xd+nHrpMDhQwJkP1t6TEPIMovMzmEWMQZ3G9CVnOrh2dL2EukFXwAFNZ6IWHYxje4bn2tOivWD4wOkCQOsWYg7fJjW/Y8py2iXTy9+aLoircDshPnKcHeGj7CTE3KPnC6aSQWXewLtb0C16EgVtDZ5jAUxaJHLvBs89S83fmevgznxG7dXMQ+Z/tO8nYrx46WXcw9LDF26er/sxks6Di/pZgJroSmkYLyvEG+qiKfMConeNu45Ftn0URIqrTGuDjp2mXRXvdCsZak+grumqRfa6ynPBNGnqHB6SSHkbsa4i0SMRGWsQApPezs3tJDFdn6kFkd6Y9EeS5OFApkXwwqneEZb9/sEBJUKAHBAIHCCFfBbPqg96OYtwvlRHJ9RybV0B0VbnYgKWSLcEj1VA4VFkRJE1opOzhYq/pQ== +R:MIIFWDCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMRowGAYDVQQDExFUZXN0Um9vdENBRGVsZXRlMzEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMB4XDTEzMDEwMTAwMDAwMFoXDTE1MTIzMTIzNTk1OVowRTEaMBgGA1UEAxMRVGVzdFJvb3RDQURlbGV0ZTMxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAKzYYB8QsuJCF/QV/pzy7Whw9WnhrOp6NRk3nDRnm+c86Zz2zywowJsFTv41a5eqEL3XehAX4jTo/dPvOpyIj7WSKJY7PmGI+xCIqzw/iC8o5Pii/PsNuFFlE7ErN0pBZnN2qx/ozfz2p5Jz4vNettlD2pzt5P2t1vp1rcSiVVuU7cBBnBREe9gcTWO6HBR1cO+gQE7QEVebK4cpad0OLQBIKCe/sveccHvxBrkKtAEOO4rJWVVS2Px/7eD7UBN9CJIGSeMyxae4RHJOcoRxmQUd1SQ+V7L3Q/VOysgpsARLlZILMaE3GR8i7s9pUe8Z2khYt3PyWJPpCYKGruvnY5it7xznO9Xl/gHHHxQsjZLMc1/HLmxOaD6dfb3rLCI/Vh7XPWNIJquH4KIBPZfpf6TvNxQTud1xB4+4hyvxKewfneSnwKNwnuzQtO6X0xn2+2sawMTCZxv/4IT3z9RzuvA+sIuOln3kV4OHG8b1a5PtkCX6B1ZQi8Wc6/6KkbvSrvqh6K6GSqjFDJNkqNe4HAhPVczMm0VwRz2+l5cFTsQ1W48ca9vldqJbTomVK13Rbbrm/ImEklvjW/w2yqtrmT5EkWLqc6OzKjZ35/+YK2MNBy/OkNpWwA0oR1A0QEAZJhWqGu/+0EhqpVNLigkWgSZM7hB/fiUAmED5GAAf5pZ7AgMBAAGjUzBRMA8GA1UdEwQIMAYBAQECAQAwHQYDVR0OBBYEFM6edz2I8vjUMuVAc+ujB/Dqg2oNMB8GA1UdIwQYMBaAFM6edz2I8vjUMuVAc+ujB/Dqg2oNMA0GCSqGSIb3DQEBBQUAA4ICAQAB7ISt/CFQ+ZEdePYbb+Tr4ngYwJoTuKiN91L2+r75Lr8+iAVmeZ11w81bN+8diIVAdhxtMIY+zqJpC0lwkimNOhbnv+WU+/44JwMC5RwKXrrGbz/eIWE+CVyUwbjL+wc5qcliFt8vmYLfyAAhTlaTnaHEWiMMsMr7Qespn5LlcdngG4YO11SMD5YFaMDyrRWimMkBWKBpVHgvmbNHvlGDnHvBwqBal1qCuoRHkAFxMR0tL0K0Tc/TYzY1TGorkxr1U+rLZg3RZdn8N6nGvL6keXl/e3w6lyPR0YtkTmq8XQROdjYh/QSK+ZspcPKJIZQ4ViKDhh9JqI8ehn3pfbQWtG7eJSCRTwuFeghxcLofHEhglb4BvflYRZhwzAfZy1ZoHV8eGYBuGjaK+Yr6IwkU3bNvOsQ4FzAdc00Gs6XxF2jVbz2dieWBhwW57dxlVxKO/Ke5mjor588rKMxcPmKcV4Tdrz0Ec1L8a98uozs+PRWy/CfbpSaT/4HGMfL14yxlW1RPqkvnWuSFVVNxtltuS9YCL1GMnkbgeaN3bG1ulpyp5PAmUmfybeMsyvk7KEbP8mZ0g/olrJxtBbLP8tr3BLPAt6/c3oLDe1YsqA7UnzMtoiRUDUdpQTKs3RuVbo8loCfqTwKUWWxpl/RFlHJqGeZSSIamQbAUoApXhlQZ/A== +R:MIIFWDCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMRowGAYDVQQDExFUZXN0Um9vdENBRGVsZXRlNDEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMB4XDTEzMDEwMTAwMDAwMFoXDTE1MTIzMTIzNTk1OVowRTEaMBgGA1UEAxMRVGVzdFJvb3RDQURlbGV0ZTQxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAINbMMscRCI4/Uy93Wv72xk3z+UQyoGxHGpbOBhiDWYDE4Ss1DokTapYK2oAsDd2b7TrbOyvBCHQL+mt7kcAMGU4dsHxia/6TCVmp76TugrLS0MZZ1ddLvpHhr/CoA08X2X7NDYXxPTM9NRokpyS7f5u66KDX/oCsL7r1JDwi/j2QwqA+7YxA+3OyQD+/dChQ50mSxbE+7j9ZBFAu3Kn5ZS7r1by2Kw3LjGlmODknUpoZCwKQrtu11a/QwJqrL4EDBMKnaeabV1x3a0yUtb4L8zTT0tdFVkLTP14uodiJ4zvqlNX/DeYghrUXNN0lQgGvyMWQuw8ziFp4nrDkajXzZTnVtaBiFUZZUfua0jcSxahp2uKxZcJO4BiIuuk7M6a4FyDBSro0B4BrOw/1DEiNFBwh2D3PoHgYQLwsrxekvUGkJLgFlQR8H+udliybc2bYRNxaW4VER2du6twNyqjea+TqqXBhaUbnc6qwN67PyDOecVujLkycunpa1SJTHaRuqcstggrDT5iEABsHAZ3G2tZu4D6XV9j0dVHJ00Mz5roVZJzpgyIloq2jVMxjSfyC9GdMZkz/5VoR5Jm4qs+iC77JrxP90w49oXIYCCfU9EcEXVzNkEsVjoKOcsBpqTYR494Gi/sE71ffdRN6oN2XGFe5ZiCiGM1qlLDAO7fhSRxAgMBAAGjUzBRMA8GA1UdEwQIMAYBAQECAQAwHQYDVR0OBBYEFFQrZVaYoEIhJ50BI7RlJrXhOgf0MB8GA1UdIwQYMBaAFFQrZVaYoEIhJ50BI7RlJrXhOgf0MA0GCSqGSIb3DQEBBQUAA4ICAQBlEVZUUDMS5Zju28rafriVQtoGwDnQon7a9cQO6RSScgzUvRSMzh0gZ41CpNZ+1t6eqvwT67KP/367tbIwccDPJ3eF3Q5w5e2QeiXecuAKRdkaHQCpDwvwWv+NsQ/daK3+RUq0Q8w8Ois4D9t7N35BB4r4j0god7krh1edrusf52Wla5GGVTX+geIYV7Dw0w648LoGpwJ8tK4GhmxS6EDuAIccB3wu/wlE3LZpIKgzhSRQ8BvejT11Bt5U1O+zJ/7NMyZ2s5Ksw57DNcgvkyyvpr+KqfxrB0YOYRMLV/1QiakInHbhKGPjloPh5fYXwklkJZEup20dTm+TP8CodW6YEYsuvHz2hO8gRa6wJ2Zt/t88m3a9AYNp8q3GXVvEC5QwEIbIhj0pvgmRsyjkU7yDj11kYYwU0weFRQisgDNCQR3tp5bw2Pz44RKqfpmLST4z2504AB8+o2IHy27qsDygbLUBx0fvUWbQIW9v5x0nzo6fN66KHS7yGJoVKdpoJpU+eifF7d+tA30WMehVeOZwjeHhVXRzhwEIIFWCkR9qgEwrnQ9q/0gXWmETnpDBTXiwn/jATGjMCHFYytBJOG+/ZUwER/H6iuLsvAamZ4dq3jNBL0rdA2PAcOLvwawJ6TQN8HNcqDWZfM90fXD5cRfms201KZYxJC9s+Mtqn/Cz/Q== +R:MIIFWDCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMRowGAYDVQQDExFUZXN0Um9vdENBRGVsZXRlNTEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMB4XDTEzMDEwMTAwMDAwMFoXDTE1MTIzMTIzNTk1OVowRTEaMBgGA1UEAxMRVGVzdFJvb3RDQURlbGV0ZTUxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAKsIiWv0EVwd1i9loj2QOiJ6LYMEqotQACw2C+1IkiR4eZkU3AbQJTmcXt++xD0BEyMMsIazU8i5Bw4ZrlflqNV2OZE2o5318BPoQAZMyyioxJqFj+jkM+qBXQBcx/M9w2QNZ0ES6lPKDuM1OG6WMa3Selms5P3+OBn33qzuYlayLYLns0NjNyNCY6qr/nt3MVmKK+/uIcsWLmnmW6jr9gfO3/OSQWwNJDdZCpLBPJ9z4Cl3S1w6hTccOdENFlAk2nDV71VsxLOgHWb8NpfZ7w4NyYygAPhZRtYOM+gOo1pwjt2FigS9wxVEc2JtcntZFt72YsjsAMQLGuiQ/lIh8aR2LT67DmpGsNNWO2J4vOVS5CkS54b13U7fun8cRz2hHTAp6ca46v31i94yGlflPIsZo8WhS9hKIioUuQa7FofrcAOas2emJ1F0VQ/t9TxC83H0pgtX4YTfn7/OBaU+wmnKrvhJ9/jaBLL8oalMxDU1KB51KSOUgIt+oP9LzNj+29AYLrZrSK8WVmTeQMGFK4PcAsa4MEg4jmuF+dVeRtNE1Iv8bIKA91jtzZm8eXs4sbe2ODZf/qCGZ/zVPXa2CMPD7kCi+S4qhRSvRToBvTxpXwvUOsYw+AoS1hIQl0TBu28RzOrQZRodfnT3C4QCDznUy5R1xPlsAbMuSKOJ2eMhAgMBAAGjUzBRMA8GA1UdEwQIMAYBAQECAQAwHQYDVR0OBBYEFEqX09A+Z3kXgv2k0SLtYe3+rhQBMB8GA1UdIwQYMBaAFEqX09A+Z3kXgv2k0SLtYe3+rhQBMA0GCSqGSIb3DQEBBQUAA4ICAQCdRaUaaf5fCB9FTlkApeDkSB4xhNFF6Ztw6ABjrIQQFfIRygCUX8Hj1H08UcEnEBEtKY651g9nB/wDGFQaCO2YnoWQEaLTU2Eod48Um1IVas5zg2XwydofxJzhRqS/hhY447DeFMPWEiALs++V6voEAPxbVTQVEv5TzFonTZIijI5PzOsSMn81n/rGRRb4Fho+udeFHELzmQcfzSSpaf8HQoLkH6qYlh/QIFJi74Ciey+nq2mzG90a4KHZhLthpFI70+N9djYTnt/fuKi+w5kQ5I6tPuR5tc8iMgwaW9jir+41o3a4+aEFADzCquZtG0UIPFLEN122T6DCqEEN9Ivn1KZ7SZHbx/grF0OPx8AHSoRlAVETOLjJeNldWGgzqYJ3wqHjqGiFuhOXxwv2aSbkuwN1Et66EyIVmiSIjUzC68c7hhEQBZX69ul3u4iopWecxe+Zw+USL4oejqeXQNrArV35QCoqTppQHGaJeNR/UswTN6XVYI9fMyviM7dn7dtG0vacM+1NFY9Fws88CAFF7cRg3/zthW1F3RSZV+EBSAUMheP3a/iJhQ7Wsd1wXAafqRJcxEKPNHgOF9Iy0WGtOaEw1bXN1lf9PeRNm4Qw+4zqu+HIvg8p2vKnlNvTlZKNBGXbE/18pFMm+gU918LMoJzNdgHgzQL/ybL5LxN5DA== +R:MIIFWDCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMRowGAYDVQQDExFUZXN0Um9vdENBRGVsZXRlNjEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMB4XDTEzMDEwMTAwMDAwMFoXDTE1MTIzMTIzNTk1OVowRTEaMBgGA1UEAxMRVGVzdFJvb3RDQURlbGV0ZTYxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMtsj2661WrKBhIWV9kwVs59QOqWNZT6UGDiaQIUQZLQGZlSv2HKIIcHnAIONmRUu3BfKFTNpKpjWZ2EDxd3t2Na7NlhWF6l817Ppy2erIpNcCDc/vINUoxmuuyTpm4kYiPbAqELj6OoBcevgXwb4hLk+88Ts0tMIBSnu23eEyBcW3h7465WOGVFKVynha14zGI0zgXkMPRj+w3moVKRNP3lAEOkvfm2tq+TvMEqS3QbAvft1EssyeYwoDt7DqIA+yNlAMFHi8wpJrutpAFqRl9VS4nQkB8Xc8wtB4WnfZXPlAevFhoi/GY2kfSqiuRGJPW4Na9E60GGou34xz9s8CSwOFm54uWyX9Xcv485eMPOo9vonduabRcS6t2RGWb/JnhjrtamjqCsTs7UIAUarD90oKv4/q4SCxnn/sZXOrdgxL70ouT1cJKRJioxPRZ97ohf/ycpdgEI/TxQoJMmu6uDfex+tqn2jdfmMzqVW88qLTW09vnMdpO3j4gYhjk+ImzgPfvNGpzGLwU5TI+KhGWy+C12HyCOJqcAM012wf/VJWna6T1hNHo2e2NNFigUzB4ymFcJ+KodZF19501nl8k9id10VsMkpYjFdD1HOxz4e2rTU/UtSJNA64k/sV6EZ3BTm1z7+0hPuLcHYQviLEUdUUGnERO06Jy/+Qsjv7aNAgMBAAGjUzBRMA8GA1UdEwQIMAYBAQECAQAwHQYDVR0OBBYEFCBhwbo+ct2gSuGkP01I2BTXFZk4MB8GA1UdIwQYMBaAFCBhwbo+ct2gSuGkP01I2BTXFZk4MA0GCSqGSIb3DQEBBQUAA4ICAQAoHZ7SR0x09a8ExgZhoYGk26QnnFteqHpXHUkhvP4kdit+5MlxAALGakSb+WNxYaiocyJ1CWohBAsvoxBnE+CQrCcuUGyFxhXzWGpoangkyEo+laXf5l0GO2LKLjF5rYtLx3sy5M61/gf9BvNTmY7Qwv7/xiXziFw66y7BartZgxyXnQbV3E7lTLhBm2nsjndEGChKC9TQMLrbq3KO+qGI5riC48kx4pMa0ZqWCe7mOCkAazPnFdv00op3q7X00JBp5non/mOi0eaPpJCax8lBJX6dxx5N2twEp1rEJy1ziTg8K1azstYOiY6PjOrTigR01LVd349zDDc3ougGXPTKQ8xIxlhDhCs/0oQPNUEr1b/7Qp/wwFWMsueuoDHvL3oRsUbdjMm67d6b4b8kQwOq+eTBzrEs29kYgJj6GPTwc7Vw2ZKv/YAEGTO4aE1EwbY1N5aeJW5USKN7anQRs/8CBZulujpiwXKccYpgfojoK01UPysEniiVxentujLBw3Yz+z8CVLwuZRlQC8VhYO+RFLlYYM60zW7qY3ddJ5pwtvKxTSEv1dL68fSqrAaC1f4Te2SlO0hDuDTRs2nbSs6ixAN2+4iwd26j4c5JxmSTWFIvGLTbzgst1bdGQ6hiHso3jjpUE9wxB8uxOetsCBvrDNk+wYqQ0YVxF71Q7MaNJA== +R:MIIFWDCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMRowGAYDVQQDExFUZXN0Um9vdENBRGVsZXRlNzEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMB4XDTEzMDEwMTAwMDAwMFoXDTE1MTIzMTIzNTk1OVowRTEaMBgGA1UEAxMRVGVzdFJvb3RDQURlbGV0ZTcxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAIraGAucKYZJQkHXeYQ0Ccc0vAkWEDaECzEN4OO1yDM3Ihavg577F9AwkRlrMkTBC8KoH22ek93lNO4vsoMiG55eZaZL52WU4snZHL9m/ne+qOJAUcdVpoo9d46xhA2cAjHOPxAhqm4xtrt9iG3HyBKtMzREc9rww8yclWrTPcuRXZ+LkgrGKR2cKzr7cQgPqLPgGjL8yhAsRQZzuhkISbqbO8m82soogyiHWnq80lLvc+2KIipqQc6SHKOcsZUClV5FfamThX12oQhLKXy+i7lXzeC9J/eAr2Gyu62j8EQBPK99ODL8D+fk6MRZ38VEKdLFLprgNMkjThUp2AwOdnb7h53JlKoFmkZI+3KEunMMFm4JMqSrmnVrZ8fhvgBBe4xFzEVX4lxlbQKXhafB1/5jJEOCdmJ0nPGjQb9Hq8rRGVm0AFomzuLmoaDkDyk+CInBV3sER+Ntd7uz/xLWBES5AL7TFbj7rz5wPQhcNvBiGLgAsoZBkStttr8WmJQoNWxlhcoN58EjLUsDKFt3xVH6LIwc9EkC0mbSmzXvG3Eqe59C7xnTuOummpBXZtzNe2ZkYDGVQkXRP56lSF7/2+nEivKEJDCpWOaeTglYvq8xz5mu1jUzr1tA3+pgLMpYXDHKYn9SZpolbS3bMKM9AjlIjJZVu1XXCJPNELgRZOkJAgMBAAGjUzBRMA8GA1UdEwQIMAYBAQECAQAwHQYDVR0OBBYEFOoSNoJbaiXel2Bgafwhi0epvZIxMB8GA1UdIwQYMBaAFOoSNoJbaiXel2Bgafwhi0epvZIxMA0GCSqGSIb3DQEBBQUAA4ICAQAICFmiGUbMmeDMJnZURVwhvRLzj/kyff0D5XL0DVk0Fhh3Z0hD7d9hu+vpr6+oF+z1yI9sxofFfiFtiwjCRY0YQIbbig91OpVH/kBvxeftZoZbxpbZ8exbvf7v855e2pu3pX7OCHXYf8OTST1MMHSIoS0PiiS8SP0eC5P6cjie5VNCy2mVzzxcwxbKgJYTNvB5SNhMqXSCLdb/udzGz3rAXECgu3llYK0hRMSTMY3YnGkeNXrerDfEFF0X4WRIdJctCv7c8yFA9oxZiBIkzGLYsghcJW4vx7MdfXjrR4MTXwj6/0JiwjajzsvSijzIVEzPvKhdnNjdyGOVtZrympX3A7+Sm+ssjtal+vWH5h/UWcEsW/cgOGYSJES2hg/HQSr4MN0YcYX5N76xep+yvtZ4BrOci9vL6rx2WPBSj5XkOs/q4pxABwAIQyQwHkE5AHBRehKtj7OvLHSZqbk+hnYFcbPrgibscPwrnD84TV7FNxqTaCShmyUHseDNPUFOT/NDHdfgUb3ZZ35tPrNGb80VFyvqMwWgPVeXg5g/foRCf15FHTq6TP4kdaV1OCFHrBzgnstHAGy2eAX3LfxPNI51rmHrqGsc9tN4LXhv7BEfDx0FSnfT7SvRilgh+BJXKI2kSxkNPTLBsTAbHyyhSb7hcu+SdQn4vZ7STLs0+0LJng== +R:MIIFWDCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMRowGAYDVQQDExFUZXN0Um9vdENBRGVsZXRlODEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMB4XDTEzMDEwMTAwMDAwMFoXDTE1MTIzMTIzNTk1OVowRTEaMBgGA1UEAxMRVGVzdFJvb3RDQURlbGV0ZTgxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAKZyWcOfadkPfgRizkMCbYk7X+ycBQ/2MlEWjg8ZUoQOixyG/OJlxLyDtTxoVouMB8vO8hiqUUIFsmX7+NpRgrf+s4eK1fd3qyeprUe5qJQqoLFHIb3H0Yc+EHwE7PULrlbstCoPnka3d/uiYEiWMrhaVSDp7hpAoaLjvzt/HVR3+HFVdP6SN0w4R+LEcMSACeSORYsCivnw8QN4V4BvyW1tVIvOoh5LDNmkRkATdXgZbyR1S5TPPbRns6f7Hi2omVCC3OA2FvLYz4j1AxWThyRMjT3x97rm0wU7my7XoQxCr+QBFzbygHN2h4ZFWuZ15XPsMJMZv6roXbdLq2K+gi1VyO4sJJzFARY/p7ueoBNeyykktWAYVlLT/bGBtmPwide/JsnyeDQ4gu8VbNv09Xs2z1v6ihzLVCYY9CtujSPu60ncTQjQOtMx7suoj/lh0E/phQ4hxTy4P6JRlnBap2UP252vqZiwV+tXnjYLjSlUjV6hFepABgbu3h62kY9XCuTCOy0s9lVBQ2uYGtK1Nf6KkYHUGdlV3mhh2sgU0l6/Q+ojRdylR5jnY/MP6ZdEHiudhO/E/5CC3uyzZyoSyQTp1hVm7YkpiMpOzyWhP/v3damtYZPuH1XnI6WEYLPNgPZPx/IvurrBFCe+PXWs44ilGMNx50OH/iWrkSc31nADAgMBAAGjUzBRMA8GA1UdEwQIMAYBAQECAQAwHQYDVR0OBBYEFCOf5Vd1NTybbcCcnuMJMKHHAY2nMB8GA1UdIwQYMBaAFCOf5Vd1NTybbcCcnuMJMKHHAY2nMA0GCSqGSIb3DQEBBQUAA4ICAQBt5cX3WnzFXUQAyn+kuAkRc5kpUT6D2ULRVqIUceQIs0E5eoMTVD9bz6Ey8auZ/S3Z1wTXRcEPCLZkbnkzgJDCoPADYFKziE7f0QW0PB4HHig551uivPv4Ehh7VYkLlsXHzjDSjSE7ismQk2AUnoWp3/z2WZMIgSVt50fd0KHNRs99FODXjngejjz9VA+nX9JMWveNDGcolguwh2j4SWQ9PdR7psZoX8m4lhDbv8dFhKVEvgUW9sUKr++SNKzmCvK/EEnl2aOG/XdO0xUhmc2DCt4PfbhWvpZJG3iwi9E9VK8FZOBBzkjSjMFP+2Vu0rlUbxqr6rYcmFbl8YpaK4mexLOq1p2AzmbDcz55a18v1ScLQh3e269HTsSd4eFxCg5mjXgYHqLDpiqHGHNQQHhYSWIz1fV/pxiVqD7r2YEzSg6+Hem2VNS8hcaAhDCLEjXHopA8EgVN+XAXUwjNhZag5JIMDuaRSWCHrErRVxAKDMie7Zs12MFFKsMqHt02eHAtIiH891mAeAUdDVoXTkH7gDONqTdNBBSo8sEzsDjxp6RZB8QaQITjGHkKtChvZdlptXubg1ADjNqMtvQFAUEb0Jwr8frG9z6+CttDXPj8Db/zICuk0AiqVYTxuSC21bBq53o071BeGUHPV9nqzElbuCNpxs8lv95pZIN2hCfwxw== +R:MIIFWDCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMRowGAYDVQQDExFUZXN0Um9vdENBRGVsZXRlOTEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMB4XDTEzMDEwMTAwMDAwMFoXDTE1MTIzMTIzNTk1OVowRTEaMBgGA1UEAxMRVGVzdFJvb3RDQURlbGV0ZTkxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAIaEcc2JiV/sezOnGhAE95terRHCQOPqaX317RjTv2oNJWMjq93pRbut4KYx1CMGq6LkW5DAktZSFg/WLbWXOtbRMGStzixeVeQD0xCStKGHrUXnTsj5+BwBPe/1i4foXpvaGsk0CKXSx1tyQO7yDnQYeiMR0iszHW8rcv4JekCl+Juj59+ZIE/cbfX93mG6cJzwkbbaOhsaoER0jEV/GO8ffjrsq4uUXXa4tiHYqoPGcrgbt7Fy8DqrqaFEpQ9QVuIU7ER0ulN11cjI87NREVtxjt6IHZQd5PsNB3tS9QvUg3/ScqoOqWgXmDK5lnO+CFu4eDpRy7me9/MP5J+vHXaT+XkpA12WfDpkBUKLcjkNKwgU0cwqUukU5ghZKi57+g1FQVNW0+X6wfcUx2DvjkQ4sA3/0G0PT4P6b6O/Wccg/EVel7ZJPqovlpOIokpvoX5HH0nurHdmIN20JnSQhmTY2kXTCkjNXbET0l600dxYcHyk/vYl8MbGxGJiwOQTD099gL05RL6aS2fspC0A1pKqhb9Vlirh3XJnLLAy5cGkBfrdAWYYv1XY/p3YpkNhbFxesdom6/+EVhEHXqhxogcLqfG4otDpIBCX5KokuXl5sJkkqdiSotmuoXtY5UJAINZfwwLvW6OwAhBOys3gssvNlsifHFy7pI1uYlJb3iHJAgMBAAGjUzBRMA8GA1UdEwQIMAYBAQECAQAwHQYDVR0OBBYEFHlT5RpeiZCJ1riEsbVHdmmsGvCGMB8GA1UdIwQYMBaAFHlT5RpeiZCJ1riEsbVHdmmsGvCGMA0GCSqGSIb3DQEBBQUAA4ICAQAjl7g87zp45lwamBQPkTip94LP/YTGicl2YX+ErkztlgBlnrfGRxoZSc5hkXPX4SupNq+TV7xFIZzJ7gJQ07N0bmeuTYQe83FKuIlk0LWhCH2IvDQuGsLprNbISnLhDqeQfHZ3KlnCDHyM35nSRJZ2EXdzbgHViv3EpFZL9diA23z8hKJvADg7wMZ+qOEfkWjkssopRe3a2HEM+m5avaYlvYJtV1MuV7d0NTzviC+IwYrsz1c791mdP7v5OP92Xr0QOskA3svaVFWAvriC+8jh1R+XSV50diIEZJvqfEfs4NqTpuXFvKer3lA7delVyu1D1B1wqwFb+A5sDJCQuaTcsosPyYJihnnwPJ1o3Od8A6ghJ9BOGTogqyPaaxYYT6f1xDmE4iZtNMTBgLYlcjqsarVh+KZygMlTvbVFPWBfV3AHxfMz8iZF1jY+qgSl+FKJuHxNNl6PHUgu1iMAfFp/xpPrQBh6G4Krj8Kf1d9XkIGjh/grUbqA/ikbKwTdhS7IRahpPRctkvC0K0M4ToSzbU+Vl2gNmTwZn2E7UbZvciN10tDFoqSWKY1HFSyD4O/OTGwzuaYJifz6EIUNstr4VqV018bC/cGdvF1NJd1pBDUUwrD5x6GBIt8SKUzEhNbSkwEYIkYCTM/UQwyp88UhlOaYMhRnjbTC4uyC5+awVA== +R:MIIFWjCCA0KgAwIBAgIBATANBgkqhkiG9w0BAQUFADBGMRswGQYDVQQDExJUZXN0Um9vdENBRGVsZXRlMTAxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEYxGzAZBgNVBAMTElRlc3RSb290Q0FEZWxldGUxMDEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAhp3WyCx1cAHdzIz5CZgCLSw4WdlVJvdn/1ohGn8isZk5aleOb0LLtP49yY8fmDH//2FhUbYBbLUINlbe0U2OtGdHk4v8A47HmzNKMcCiZ4699QONFW5i6rzMw1foa38hHSKfUJLkzTG+bM0I4AV4Hmh2oimkNqBaKAryfaUZYj8S3vWoOIp1oXFe1wxyRni5NBjva2XRQjv1GM92xgaH8t2uN+joEdNEwp8KlGodhlBTDuTRHBjTH60yxb6HFPoM0Fuw3/HUdOOUOiLpom3hNKGvMdV97zM9RAti2OgwHxxXDkfDqQsuXsYxSqGj40NQ9U1C5r39SpP1jrteopDDOuR4jmzOKT6R5I3JkB73LvRvEZ5BiwoRVAKM/tjo7LFjWALQNqMpAp3ggR07JeZN61qWWtMnj1MVrxe6/A8e32xC0JBZHMda+wGTJJQbnQqkjvCh3eS+eINejyrFaIckLxG1BYQbybRLVSsuFlnUewCZPznxCmlxDMyCWYEn8FTuaqbdR1uUremX/butWJyy0YqMvQRVTm0uQ3UWndsiByCglayQRefZWhHhL8u9J/1MCIdk2Z08hAKGCzU01KIYpNH3PivT41hdAmeFwwoA5unwpR22q3FJSM1HmDliONBFtw3uxRiUfT2DmSOpkUVx5w5f6dH21zqr2BjYX1edSF8CAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQUznuQO1rO2j9clcoqhKAZqLT+AdIwHwYDVR0jBBgwFoAUznuQO1rO2j9clcoqhKAZqLT+AdIwDQYJKoZIhvcNAQEFBQADggIBAFi1IxVf4/4v5JJ++6bHEiw+ZaEQW31MmpMdkAWS5ySm9mlFQsVDCc78OFzwJ1KUcgi9Pz285H7dEKXtSg4SB0RbAYnrNgTokyYrBu80hG26R0seyA9kmfa3UaekiAOdbDTYP+uni41J1iDuvtGjjc5vq/MnCcxE8YLvUu29s86iawBdCBgMZlMtypiLqfsg4x0DhSyI4L1Ad2iYBfQSkoGbvgWUha1uEEWqRa3kIDUW8tAPic7KRWpE3rAdOxdUKHpBhKn7uayje5Yb6YhUJb5PPeNQm4OgbDB76sqL5icXxUvh5XGolAxc3XI7Pl7kYtv8CJ+4VmZJbPnjoNZlI1WJEwQeqROtMHyKXI08qj+k6v67VflUYxzg6sAwrk41EDjB5ZmJftelHPb5FGyCtLw/AY84mW1cKd3VZd0wuv5jVekIlw0SugsSD//5ZGEOSeFXMh3/bzHzisYvQVco0vDlqGJL9T/5OGtGWKxHZfS7I+ifknp2imyGqzn66DISpTTKcAxxfohytwskXwzbyL6fFZSK527Pl+7U6UT5J8JfcIFjM693mndOtVWo0yBGRv8NOaHlkWAxknleqZtGoGg2s406AnaOvZogBNnEmGmXW7bVCgNx5cx0KgMWrR6tNMvbLoVWIpnpQSeeM2y8NVIKwHiM1yqSsSzEyImfwC6f +R:MIIFWjCCA0KgAwIBAgIBATANBgkqhkiG9w0BAQUFADBGMRswGQYDVQQDExJUZXN0Um9vdENBRGVsZXRlMTExGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEYxGzAZBgNVBAMTElRlc3RSb290Q0FEZWxldGUxMTEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA34wSPKEz0hO5bpbmamathiaSdQgEUDZgXpfHZbjJKx1N2gx9+W8QKTurJuOtPvExni7UxnXlaFnKrjKX1t8p807NCjobN8vXi9K8XHhmh1yi3sVjHtxFOHvmFAaEN+CXmJJsSZHoA5WzpG5V2Ek2s9QZSdCDJ0xBQSaxHDQRTidMo5XK6Yh7N2hCHhUHrWLD6W1NchWBrH/fm/7bnsK5rNCH6GZZbkhOnFOoh7MpW/IyeOHEziqDPUXo8b+GwGOtKC2QxTfA2Yl0dmThEcaPoyFUnPnNf7Dd1KOKUQ68cq10GPp489Rn97DFZQx9zAdvjONkaVEgFrQSPBl7eFbWTJhwHmL0ZnLQuQN5VwAdJjPs2FQPFt3on/icwDO3DuFzeiycb+WmgaHqL/3yKF6lHPTd0iYrTRNpTC/bGcpKp5sTSxb2X14TjACYhRV1wcOOLj+9VGX0uZZiqPWBwMxaLMxHk6yDlmtx2kOOB40ZBK6icqHenFL2Zfm1tNVcS4JIIetcy6k4Cg1UKXRN+QVreqs//M45A4kMBcUnyZFG2ohZM6jtCLad6RlexAO9wEhVYnpGAlTulcoDiD4UaLkveylEbP4XG0MjpkRDvETUBkV7xNEBLlubdXIEQSKISyGyuXopwp+ItmVajTkchNUZx2uzHOYv0EdKHxnMWMdqa40CAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQU55rV6FgxFLMWKiaXFwsZkvUlLfMwHwYDVR0jBBgwFoAU55rV6FgxFLMWKiaXFwsZkvUlLfMwDQYJKoZIhvcNAQEFBQADggIBAIiYdldupp4LkLeY01zdacsv0lMSPsK0Ous4vVGek5Z/1c+gDZhUIec83XT/Rty80tv9/tDseGFw4dQ67ksNix2AXLrDCKu3iuyHY+aJti8J7y//N79R01PrvsYS8x272rRW2SDVgEzn+Qm3+5vpp7jbKv2PvjZ+azCTCRz5pO8g/Aab2yZcyTVLjRRaY4ll+hx8nc9l9u/Sboa6m8FaaJwcPEJex74t08wtDbyvUEfdI/KuW9UCFfmPlL9/AZpzvTEyhjQhEI/S3wkcupw6AjMpuLF6nTtlj2x7hPi2gAi1pblIae8l/68QHGF2P4/QM9Q95pTaHbqiEboXjQ6QEi+gt+99TTRbUXioeQqh5OT51v4MZX+kRnHO28F1eJ9a+6S2yw8vN/Y0UWctomHqMqGXKj2AaA1WhP8sVkQ3vhbG3FCuT3Bh3GViVo7vAZh1iHLSmFw3fPFyHsjJJaT1HONHg/eIgo59UtfrDpTPH0ekQ1tambv17HtsN2hq4UmTNZMzG9bT4HSsp5LbhGyymGNElyWX5WCcbIr1Epie2MnFSMBl7g+BY2ZwCx2jCkz95sfyVkKxwhQRdHMxUGya23GChbv6VofIFEUWTFe3hebNwb/R2q9nr9VdPCYwT2MXYHnWxZT+gN8ZiYMT6qqJcv+VSGOtGjOaWwxW55zTjn3j +R:MIIFWjCCA0KgAwIBAgIBATANBgkqhkiG9w0BAQUFADBGMRswGQYDVQQDExJUZXN0Um9vdENBRGVsZXRlMTIxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEYxGzAZBgNVBAMTElRlc3RSb290Q0FEZWxldGUxMjEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAmKT2vpQL3mnTuLOsH+lbICsn16M6Ac9d7FPn+Fi108ipunJCJeKHvXyTIMjHtBEpYQc2sWUjCNFHBwITW7Y3bsTCPaVHYHH84wb8vkM2jCdeTZq5+QzGGmdpkooRoFc5Ma/MZUY9ZtoQ1Z+YHKfCQARwlqrFPKeQUQgSAxMsPy4sKm+P2ddzlLJdi3YRdgSYddvLAl4lN0jUHA1nmpIFtNyXNxBZxoNC5e4JnbR6YuM6kkFXXmYFbyfttYSr8VHNdVVD/NHq/ADTJOAL0bXeuVpqV+cFjYzdvlNZrLLklEYY2cz63N1nj0xxpnyglkL7JKmSJiJioXWjyQVcmSArQctwhMEOD1YKCjrTT6mfX7toDvvhGQt3h8CW7DfArzevUOd3E/iKkXwYrYdUkMRDKZBIB6VVGVY/QZX49GhrzoFTUsoARh6kERk7yHJ6tphsbsTZVdz2GqKiYYoAK/B42yR3N6c8C7WQEJfcXcgchNvR8oX3KKbC2ruscupIThX5XuofY/DXNiMezNrxvkvrRPZg1p0VPgLum2Vv322BZDhqSr7KtFfkCLfRRt5J7Bk1KqQ2qHwHbFaWWUQbZkcfcrbudyQTQagfOvbLMF46NvCQWavekmp9M02WJeQ2aYsU+DONs7Efx3mKhKgWlWFfjZJ5UyV4UgFEW5CC5ev/3xcCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQU1XqayIMU98hdrAogOoQbZlTrRiUwHwYDVR0jBBgwFoAU1XqayIMU98hdrAogOoQbZlTrRiUwDQYJKoZIhvcNAQEFBQADggIBACzvVHEW5aGQQnrka/8l4h5R+uMsAlLSBmr50zC8JHs/P14wD2CadMBgje6ApoNaHvnQJ2PQUQT5/8DI4so/9Kif/qp8xQ37c/YetYj4AHQJtMZpLTKxtbCNZWBwvkfirLMN417SvHdbG96UZk7dbxH1dSOCOKjcxXyEnpNEiEl22Q/XTaNekEsgbTdhweQHb+MP1jvWvJiWsxzcsxxsr0GLQb1XQjfEctDqS6K2GbZ+Eh4Uuniv3hE24GipcnhSH2I3bF09W99yys6dD7qIdrzgmGwAUHpuxdZDT8EMrWIHlJR/f+8vhbO/ZFrAXkciB8dHyPMrvr1k+y6X28CwGyZjyLxA0o2kcyOMcjkBZjnt05+1CfoLVaOjIGqJQhgWY23GcJPxZEO37eox+eI6aotctwcm2kfiuJfwIHlDVjcC+BQSzyfOyAE8Ji+qx29Z1bUYtjinoHPsnxdzWWfGh4GarS5Z3cHwPU15S3BviJVKB3su2iU7Sa7wYn4zIOoRpoAAxvsMsEq0BhVIeUUF7vvw0biIZQ4pOciDVM7GhNpLOQEq1QUhb3Qe5ba7Fdzqtws8Q/a4k3V3pGWCZpd/S9qSfLZBDDCg1LX1wRdNPnVgCoBBHSuhKWwCABokVDQsGQKPFFCJwbgfSFgoVc8jplk2vgQrCFbCjxrF59QmEeY6 +R:MIIFWjCCA0KgAwIBAgIBATANBgkqhkiG9w0BAQUFADBGMRswGQYDVQQDExJUZXN0Um9vdENBRGVsZXRlMTMxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEYxGzAZBgNVBAMTElRlc3RSb290Q0FEZWxldGUxMzEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAuC1w4soeo8FdjfYavLfLR78kEpgtUsTu4IcVMIE4toly2p4hoVUxCDhUjgAgEbImlrWY2Y4mSKFJ2jnL4CaLgJ2BEiGJO7EMsaMKgY/32Bznj0h+B1QoYdFnKRB1ZboRcyUgD9gvMWla5UNnCFKWgiYUpKkrapfCoItyLLrAAUDGymucwyRSwbIPk7+5RXo5zqfgP0oPIJIQKp30H8CCSwrSBfRXqyuLUyXDBouMAcUmqdfievwPRdXfUrSYQ9NIv8NQmzTSAh8g5LAFhz9vb25QsYJwIbxyH9Qu8tanFjYtlgO3ffXXTrNUPYhTacpfGotoYfSf1yAfBO80VTt/7VOa+lLKvsqySuOEoMSElVUo/VaBgCHLpboznx20rgTzXq8w5dy4/br3aT7wyj4ONq+Vm1AlbIjUlfDNeov1QX6Cipo3qd7VSTUS7ly3e8pJoAmc+THZHn7ozWglhM92K8a/YwsT6nSRCyBPxmWxtmKVZb2/le5EHynnYkSK+15P9Zz7xNPo1SYe9XKROLT7E3JzkrVNgmpWOqYiRCE2/0O7Lvk7XTQI2DKHKPXpFOCkMGOZtDoVmZKahLZs8AhKEThkpeomEIDbQUl0MkTIqKO/afxWDafMUtAcWzwFqcPio9PI2C7kYRS8w5l++DPpEEyU0egH58Snm0WmaTSZ6TUCAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQULTYsRvBi3uXkH7LU+vDhX8IGC8swHwYDVR0jBBgwFoAULTYsRvBi3uXkH7LU+vDhX8IGC8swDQYJKoZIhvcNAQEFBQADggIBAFztUfP9s8N/S+fsD6OukJSZ5kE99NpseJKk0Y5INRP/wecBOz0ITchxVSjywFHaspwaVE+pymozjiDzTeYYV8ODfU/tVMdECEoK/zjJjqzGN1wovO2cS86xhnTzF2dwttug+Vmz/pSAMH+BO2p5/VASuutF9UfP0WAWgX1mTm5VRkDX2BW6sXbUq/NSkL9jddCrXQLrJgYdwKiWpod4I69YkaMXIwELOou2o524dBKoIO4o5BCUWfC4+AamULKjc5GGPoPb0lXK46NiH434CA8f37PU5bkRzV3ST3R2a5qEFmDJa5L97svdL1NdKuIzo8vW6bq4PFsfDHYlHqk/W+HP5chACZU3V2RlLkdii+wAcToW01i7bT1XgaGh1zExPjvYFiIZoBpwukeah5BgMeqtWgt7Uo7jcwTN7Fm9DeFIJO7E7zNi7k4HK2MNN6c7AIdE6eHDnQhTJqRBJgjrwF9RI6KwEhVHPrNLHzZ6LesQhKSBo+Xal74UcC4GlGI9i/FkeWA6Cf0Zyv0vmKVCLCvXmzS1lh2lFqTgjhrXFrX4LkFn9KI6tDQUZ7XxUMIjzpQFDqknHZAyTdZsquktkfw/laZenByaHvzYpAcSLnQVUrjnHncvT51cse2FnZhA8+sotE2KbG8XSbVMlb9IEOn2xg/FCpQzITdF+S2igykz +R:MIIFWjCCA0KgAwIBAgIBATANBgkqhkiG9w0BAQUFADBGMRswGQYDVQQDExJUZXN0Um9vdENBRGVsZXRlMTQxGjAYBgNVBAoTEURvX05vdF9UcnVzdF9UZXN0MQswCQYDVQQGEwJERTAeFw0xMzAxMDEwMDAwMDBaFw0xNTEyMzEyMzU5NTlaMEYxGzAZBgNVBAMTElRlc3RSb290Q0FEZWxldGUxNDEaMBgGA1UEChMRRG9fTm90X1RydXN0X1Rlc3QxCzAJBgNVBAYTAkRFMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0kKDDpp/8Bh23Y68D+I9RY+KfvBkgd9QJH3aqgDt5M2AmV+naiyGtOvut4kaJJfyUs+U04HSjKpXp9bHQyuoccFkuiEZ5PSY0l+27o51tqUe/1PYkBBag0l2Oh5cgk4drUNpcvGuIzkEbZv11gxGMeyjkCLFX+O+IJ35x/plvSBTi5cWaqqDEK1sAI0+XEB3+hmOLj17b5d390CT0o1ZWsbRKQRTZiuEHZf7ILtob1igIrKlpO02I9jbvvpfnB87yxSX2dUC21XqbZT/DdkFK+0x0uv9UDdsQ3zmnbOTzGk0ppZ/h8zc9vrancgTZOwdClQ/lzkIsBhgefcK8Xlz0vVpUZM3CWiS8yo//U3keEAFl6YP61NuXZyrAHOmtQTkF0I42+h8i/O3WnQZtEn8C6yxRP+2391WHRq2vYkdoAWnyjtaeiMA6w/ZPbh3ifotBZpHSRzC/jU3bmSn+eYW0iTFonaUOP1fF73lwQR/GfuaTZeWfwY7ECXW4HBj+gJe9BDtsr0bRxXhDxty7kXxxTgF2rj31FItTZiCbuYFIT0gXL+yiOE/dZafzmW64/uesSIpEEBwY62T4xe/W5/tCgABF58sUJ5Smzj2pMOTwdVilefDFuVzdAWgUKGWkH5GRE8cvCSkgkYuK/JZ9sgwYtkecNBpFxa7/CFpCYh7Ut8CAwEAAaNTMFEwDwYDVR0TBAgwBgEBAQIBADAdBgNVHQ4EFgQU7s+W5MlsCJQHRmF9YI0bThLk2vUwHwYDVR0jBBgwFoAU7s+W5MlsCJQHRmF9YI0bThLk2vUwDQYJKoZIhvcNAQEFBQADggIBAJu+OKcvjn6ejf7hQ4iXnGGXroP3RPG7K+zE9HCCp8q61PLiCUkMNbqiZZJ/C2/OUG7ExbbSdNbMBon7YU1iTC60H+D8q1khSaKBBORJaUwybU57CdmdkKLBGnr90VsPhBAptqv1nkJNLZPtkp2qv6J+8hZSSv69KSiDh00ziJis92PYNzvQApg66anW21pA7Md9EMPI2y4rxn30qEH1lmiLR+AOBgfsqlQZA3j9qkwb2FlUDXi1uMzkNv/lI8RiZ+lzhMAFbUKLMmtBEbfDk4/oCMxYsGj1lTtLlzfthodJ4x9VLm9nAArH3UrhM9O/pC6qD3Esob2GO2yxWokii6a02V7bi5LvGcdyE+RIWsQdaeoRDpwTR8d0bV7Ac01nAZ4+vCTRZMvlp8hIOkMKDMAs/41o/LiesBF8iahypSS9g3hVk4gjsqbCIvOwASwCZ2BajJNvWk5bybc8r25Xo//8NCl/rah0llTiQLgZYw7T46yeKODR4w6FOzO4xuGhBcyAJ4f8nlK8ram5iwTRxr+htC2mTElvty3Ylh1r8DZjZYKbtyuCPSfA8GOQT1/dB8LvzHhrooDnoxbqocIUCYj8tjr7tmafrnXOEAk2ZRp15B0GPH9CLWZ6jvacCrxgzME7UuWIQ8OqvXKfapITXBbsR831dFhQi8uUshCjruYp diff -r 9ad1f18799fb -r d92b1594e974 ui/trayicon.cpp --- a/ui/trayicon.cpp Fri Aug 29 13:09:40 2014 +0200 +++ b/ui/trayicon.cpp Fri Aug 29 13:10:11 2014 +0200 @@ -16,7 +16,8 @@ TrayIcon::TrayIcon (QObject *parent) : QSystemTrayIcon (parent), - useAlt(false) + useAlt(false), + mMessageBox(NULL) { if (QSystemTrayIcon::isSystemTrayAvailable() && qgetenv("XDG_CURRENT_DESKTOP") != "Unity") { @@ -41,11 +42,20 @@ QSystemTrayIcon::showMessage(title, msg, msg_icon, msecs); return; } - QMessageBox *theMessage = new QMessageBox (QMessageBox::Information, - title, msg, QMessageBox::Ok | QMessageBox::No, qobject_cast(parent())); - theMessage->setIconPixmap (icon().pixmap(theMessage->iconPixmap().size())); - theMessage->button(QMessageBox::Ok)->setText (tr("Install update")); - theMessage->button(QMessageBox::No)->setText (tr("Remind me later")); - connect(theMessage->button(QMessageBox::Ok), SIGNAL(clicked()), this, SIGNAL(messageClicked())); - theMessage->show(); + if (!mMessageBox) { + mMessageBox = new QMessageBox (QMessageBox::Information, + title, msg, QMessageBox::Ok | QMessageBox::No, + qobject_cast(parent())); + connect(mMessageBox->button(QMessageBox::Ok), SIGNAL(clicked()), this, SIGNAL(messageClicked())); + connect(mMessageBox, SIGNAL(destroyed()), this, SLOT(messageDestroyed())); + } + mMessageBox->setIconPixmap(icon().pixmap(mMessageBox->iconPixmap().size())); + mMessageBox->setWindowIcon(icon()); + mMessageBox->button(QMessageBox::Ok)->setText (tr("Install update")); + mMessageBox->button(QMessageBox::No)->setText (tr("Remind me later")); + mMessageBox->show(); } + +void TrayIcon::messageDestroyed() { + mMessageBox = NULL; +} diff -r 9ad1f18799fb -r d92b1594e974 ui/trayicon.h --- a/ui/trayicon.h Fri Aug 29 13:09:40 2014 +0200 +++ b/ui/trayicon.h Fri Aug 29 13:10:11 2014 +0200 @@ -20,6 +20,9 @@ * This class should become obsolete once Qt improves the support for * StatusNotifier icons that are used in Plasma 5 and Unity. */ + +class QMessageBox; + class TrayIcon : public QSystemTrayIcon { Q_OBJECT @@ -32,8 +35,12 @@ public Q_SLOTS: void showMessage(const QString &title, const QString &msg, QSystemTrayIcon::MessageIcon icon = QSystemTrayIcon::Information, int msecs = 10000); +private Q_SLOTS: + void messageDestroyed(); + private: bool useAlt; + QMessageBox *mMessageBox; }; #endif // TRAYICON_H