# Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: rousskov@measurement-factory.com-20080405052442-\ # sgaebbznnyje4s8m # target_branch: file:///home/rousskov/programs/bazaar/repos/squid\ # /trunk/ # testament_sha1: 4efb37ede0f699c8f05f50a82578b6294c93dc22 # timestamp: 2008-04-04 23:38:47 -0600 # base_revision_id: squid3@treenet.co.nz-20080405020045-\ # lhsxi0sldbnb2t9g # # Begin patch === modified file '.bzrignore' --- .bzrignore 2008-04-03 10:32:04 +0000 +++ .bzrignore 2008-04-05 05:16:03 +0000 @@ -1,31 +1,72 @@ -autom4te.cache -config.log -autom4te* -libtool -configure.lineno +*.la +*.lo +*.loT *.patch -icons/*.gif -tags -tmp +*/*/*/Makefile +*/Makefile +*/globals.cc .deps +.dirstamp .libs -.dirstamp -*.la -*.lo -*/globals.cc +Makefile Makefile.in -configure -config.h.in -cfgaux -stamp-h.in aclocal.m4 autoconf.h.in -testHeaders +autom4te* +autom4te.cache +cfgaux +config.h.in +config.log +config.status +configure +configure.lineno +depcomp +doc/*.8 doc/Programming-Guide/html +helpers/**/*_auth +helpers/*/*/Makefile helpers/*/Makefile -helpers/*/*/Makefile +helpers/basic_auth/**/Makefile +helpers/digest_auth/**/Makefile +helpers/external_acl/**/Makefile +helpers/external_acl/ip_user/ip_user_check +helpers/external_acl/session/squid_session +helpers/external_acl/unix_group/squid_unix_group +helpers/negotiate_auth/Makefile +helpers/ntlm_auth/**/Makefile +icons/*.gif +include/autoconf.h +include/stamp-h1 +install-sh +lib/**/Makefile +lib/**/config.h +lib/libLtdl +libtool +missing +scr/**/Makefile scripts/Makefile +scripts/RunAccel +scripts/RunCache snmplib/Makefile src/*/Makefile +src/DiskIO/DiskDaemon/diskd +src/cf.data +src/cf_gen +src/cf_gen_defines.h +src/cf_parser.h +src/globals.cc +src/repl_modules.cc +src/squid +src/squid.conf.default +src/string_arrays.c +src/ufsdump +src/unlinkd +stamp-h.in +stamp-h1 +tags test-suite/Makefile +testHeaders +tmp tools/Makefile +tools/cachemgr.cgi +tools/squidclient === modified file 'SPONSORS' --- SPONSORS 2008-02-12 05:46:09 +0000 +++ SPONSORS 2008-04-05 05:16:03 +0000 @@ -66,7 +66,7 @@ Barefruit - http://www.barefruit.com/ Barefruit has funded Squid3 development and maintenance, - with a focus on the ICAP client support. + with a focus on content adaptation (ICAP and eCAP) support. Palisade Systems - http://www.palisadesys.com/ === modified file 'bootstrap.sh' --- bootstrap.sh 2007-10-13 18:54:10 +0000 +++ bootstrap.sh 2008-04-03 21:42:46 +0000 @@ -52,6 +52,48 @@ fi } +bootstrap_libtoolize() { + ltver=$1 + + # TODO: when we have libtool2, tell libtoolize where to put its files + # instead of manualy moving files from ltdl to lib/libLtdl + if egrep -q '^[[:space:]]*AC_LIBLTDL_' configure.in + then + extras="--ltdl" + else + extras="" + fi + + bootstrap libtoolize$ltver $extras --force --copy --automake + + # customize generated libltdl, if any + if test -d libltdl + then + src=libltdl + + # do not bundle with the huge standard license text + rm -fv $src/COPYING.LIB + makefile=$src/Makefile.in + sed 's/COPYING.LIB/ /g' $makefile > $makefile.new; + chmod u+w $makefile + mv $makefile.new $makefile + chmod u-w $makefile + + dest=lib/libLtdl + # move $src to $dest + if test -d $dest # already exists + then + echo "Updating $dest from $src." + chmod u+w $dest/* + mv $src/* $dest/ + rmdir $src + else + echo "Creating $dest from $src." + mv $src $dest + fi + fi +} + # Adjust paths of required autool packages amver=`find_version automake ${amversions}` acver=`find_version autoconf ${acversions}` @@ -81,7 +123,7 @@ # Bootstrap the autotool subsystems bootstrap aclocal$amver bootstrap autoheader$acver - bootstrap libtoolize$ltver --force --copy --automake + bootstrap_libtoolize $ltver bootstrap automake$amver --foreign --add-missing --copy -f bootstrap autoconf$acver --force fi ); then === modified file 'configure.in' --- configure.in 2008-04-03 21:04:37 +0000 +++ configure.in 2008-04-04 23:06:03 +0000 @@ -29,9 +29,59 @@ AC_LANG_C AC_PROG_CXX AC_CANONICAL_HOST -AC_DISABLE_SHARED + + +use_loadable_modules=1 +AC_MSG_CHECKING(whether to use loadable modules) +AC_ARG_ENABLE(loadable-modules, + [ + AC_HELP_STRING( + [--disable-loadable-modules], + [do not support loadable modules]) + ], + [ + case "${enableval}" in + yes) use_loadable_modules=yes ;; + no) use_loadable_modules=no ;; + *) AC_MSG_ERROR(bad value ${enableval} for --disable-loadable-modules) ;; + esac + AC_MSG_RESULT([$use_loadable_modules, explicitly]) + ], + [ + use_loadable_modules=yes; + AC_MSG_RESULT([$use_loadable_modules, implicitly]) + ] +) + +AM_CONDITIONAL(USE_LOADABLE_MODULES, test $use_loadable_modules = yes) + +if test $use_loadable_modules = yes; +then + AC_DEFINE(USE_LOADABLE_MODULES, 1, [Support Loadable Modules]) + AC_ENABLE_SHARED +else + AC_DISABLE_SHARED +fi + +AC_LIBTOOL_DLOPEN +if test $use_loadable_modules = yes; +then + AC_LIBLTDL_CONVENIENCE(lib/libLtdl) +fi AC_PROG_LIBTOOL AC_LTDL_DLLIB + +# Do we need these unconditionally for "make distcheck" to work? +AC_SUBST(INCLTDL) +AC_SUBST(LIBLTDL) + +if test $use_loadable_modules = yes; +then + # Why is this needed? Should not libtool's AC_LIBTOOL_DLOPEN do that? + LIBADD_DL=${lt_cv_dlopen_libs} + AC_SUBST([LIBADD_DL]) +fi + AC_PROG_RANLIB @@ -681,6 +731,9 @@ fi ]) +dnl disable generic/common adaptation support by default +use_adaptation=no + AM_CONDITIONAL(USE_ESI, false) AC_ARG_ENABLE(esi, AC_HELP_STRING([--enable-esi],[Enable ESI for accelerators. Requires libexpat. Enabling ESI will cause squid to follow the Edge Acceleration Specification (www.esi.org). This causes squid to IGNORE client Cache-Control headers. DO NOT use this in a squid configured as a web proxy, ONLY use it in a squid configured for webserver acceleration.]), @@ -700,13 +753,74 @@ if test "$use_icap_client" = "yes" ; then AC_DEFINE(ICAP_CLIENT,1,[Enable ICAP client features in Squid]) AM_CONDITIONAL(USE_ICAP_CLIENT, true) - ICAP_LIBS="ICAP/libicap.a" + ICAP_LIBS="ICAP/libicap.la" + use_adaptation=yes else AC_DEFINE(ICAP_CLIENT,0,[Enable ICAP client features in Squid]) ICAP_LIBS="" fi AC_SUBST(ICAP_LIBS) +use_ecap=1 +AC_MSG_CHECKING(whether to support eCAP) +AC_ARG_ENABLE(ecap, + [ + AC_HELP_STRING( + [--enable-ecap], + [support loadable content adaptation modules]) + ], + [ + case "${enableval}" in + yes) use_ecap=yes ;; + no) use_ecap=no ;; + *) AC_MSG_ERROR(bad value ${enableval} for --enable-ecap) ;; + esac + AC_MSG_RESULT([$use_ecap, explicitly]) + ], + [ + use_ecap=no; + AC_MSG_RESULT([$use_ecap, implicitly]) + ] +) + +dnl Perform configuration consistency checks for eCAP +if test $use_ecap = yes; +then + dnl eCAP support requires loadable modules, which are enabled by default + if test "$use_loadable_modules" != "yes" + then + AC_MSG_ERROR([ + eCAP support requires loadable modules. Please do not use + --disable-loadable-modules with --enable-ecap.]); + fi +fi + +AM_CONDITIONAL(USE_ECAP, test $use_ecap = yes) +if test $use_ecap = yes; +then + AC_DEFINE(USE_ECAP,1,[Enable eCAP support]) + ECAP_LIBS="eCAP/libeCAP.la" + use_adaptation=yes +else + AC_DEFINE(USE_ECAP,0,[Disable eCAP support]) + ECAP_LIBS="" +fi +AC_SUBST(ECAP_LIBS) + + +dnl enable adaptation if requested by specific adaptation mechanisms +AM_CONDITIONAL(USE_ADAPTATION, test $use_adaptation = yes) +if test $use_adaptation = yes +then + AC_DEFINE(USE_ADAPTATION,1,[common adaptation support]) + ADAPTATION_LIBS="adaptation/libadaptation.la" +else + AC_DEFINE(USE_ADAPTATION,0,[common adaptation support]) + ADAPTATION_LIBS="" +fi +AC_SUBST(ADAPTATION_LIBS) + + dnl This is a developer only option. Developers know how to set defines dnl dnl AC_ARG_ENABLE(mem-gen-trace, @@ -3448,6 +3562,9 @@ src/fs/Makefile \ src/repl/Makefile \ src/auth/Makefile \ + src/adaptation/Makefile \ + src/ICAP/Makefile \ + src/eCAP/Makefile \ contrib/Makefile \ snmplib/Makefile \ icons/Makefile \ @@ -3494,4 +3611,8 @@ AC_CONFIG_SUBDIRS(lib/libTrie) +# must configure libltdl subdir unconditionally for "make distcheck" to work +AC_CONFIG_SUBDIRS(lib/libLtdl) + + AC_OUTPUT === modified file 'lib/Makefile.am' --- lib/Makefile.am 2008-03-20 11:30:19 +0000 +++ lib/Makefile.am 2008-03-20 17:48:37 +0000 @@ -3,8 +3,16 @@ # $Id: Makefile.am,v 1.33 2007/12/14 23:11:44 amosjeffries Exp $ # -DIST_SUBDIRS = libTrie -SUBDIRS= libTrie +if USE_LOADABLE_MODULES +DIST_SUBDIRS = libLtdl +SUBDIRS = libLtdl +else +DIST_SUBDIRS = +SUBDIRS = +endif + +DIST_SUBDIRS += libTrie +SUBDIRS += libTrie install: all install-strip: all === modified file 'src/ClientRequestContext.h' --- src/ClientRequestContext.h 2008-03-20 11:30:19 +0000 +++ src/ClientRequestContext.h 2008-03-30 18:20:14 +0000 @@ -10,8 +10,8 @@ /* for CBDATA_CLASS() */ #include "cbdata.h" -#if ICAP_CLIENT -#include "ICAP/ICAPServiceRep.h" +#if USE_ADAPTATION +#include "adaptation/forward.h" #endif class ClientRequestContext : public RefCountable @@ -31,10 +31,10 @@ void clientRedirectDone(char *result); void checkNoCache(); void checkNoCacheDone(int answer); -#if ICAP_CLIENT +#if USE_ADAPTATION - void icapAccessCheck(); - void icapAclCheckDone(ICAPServiceRep::Pointer service); + void adaptationAccessCheck(); + void adaptationAclCheckDone(Adaptation::ServicePointer service); #endif ClientHttpRequest *http; @@ -42,9 +42,9 @@ int redirect_state; bool http_access_done; -#if ICAP_CLIENT +#if USE_ADAPTATION - bool icap_acl_check_done; + bool adaptation_acl_check_done; #endif bool redirect_done; === modified file 'src/ICAP/ICAPConfig.cc' --- src/ICAP/ICAPConfig.cc 2008-02-13 06:12:45 +0000 +++ src/ICAP/ICAPConfig.cc 2008-04-03 05:31:29 +0000 @@ -47,400 +47,31 @@ ICAPConfig TheICAPConfig; -ICAPServiceRep::Pointer -ICAPConfig::findService(const String& key) -{ - Vector::iterator iter = services.begin(); - - while (iter != services.end()) { - if ((*iter)->key == key) - return *iter; - - ++iter; - } - - return NULL; -} - -ICAPClass * -ICAPConfig::findClass(const String& key) -{ - if (!key.size()) - return NULL; - - Vector::iterator iter = classes.begin(); - - while (iter != classes.end()) { - if ((*iter)->key == key) - return *iter; - - ++iter; - } - - return NULL; -} - -int -ICAPClass::prepare() -{ - int found = 0; - wordlist *service_names = NULL; - wordlist *iter; - - ConfigParser::ParseString(&key); - ConfigParser::ParseWordList(&service_names); - - if (service_names && service_names->next) { - debugs(3,0, "WARNING: Multiple ICAP services per icap_class are " << - "not yet supported. See Squid bug #2087."); - } - - for (iter = service_names; iter; iter = iter->next) { - ICAPServiceRep::Pointer match = TheICAPConfig.findService(iter->key); - - if (match != NULL) { - found = 1; - services += match; - } - } - - return found; -}; - -// ================================================================================ // - -CBDATA_CLASS_INIT(ICAPAccessCheck); - -ICAPAccessCheck::ICAPAccessCheck(ICAP::Method aMethod, - ICAP::VectPoint aPoint, - HttpRequest *aReq, - HttpReply *aRep, - ICAPAccessCheckCallback *aCallback, - void *aCallbackData): AsyncJob("ICAPAccessCheck"), done(FALSE) -{ - method = aMethod; - point = aPoint; - - req = HTTPMSGLOCK(aReq); - rep = aRep ? HTTPMSGLOCK(aRep) : NULL; - - callback = aCallback; - - callback_data = cbdataReference(aCallbackData); - - candidateClasses.clean(); - - matchedClass.clean(); - - acl_checklist = NULL; - - debugs(93, 5, "ICAPAccessCheck constructed for " << ICAP::methodStr(method) << " " << ICAP::vectPointStr(point)); -} - -ICAPAccessCheck::~ICAPAccessCheck() -{ - HTTPMSGUNLOCK(req); - HTTPMSGUNLOCK(rep); -} - -/* - * Walk the ICAPAccess list and find all classes that have at least - * one service with matching method and vectoring point. - */ -void -ICAPAccessCheck::check() -{ - debugs(93, 3, "ICAPAccessCheck::check"); - Vector::iterator ci; - - for (ci = TheICAPConfig.classes.begin(); ci != TheICAPConfig.classes.end(); ++ci) { - - /* - * We only find the first matching service because we only need - * one matching service to justify ACL-checking a class. We might - * use other services belonging to the class if the first service - * turns out to be unusable for some reason. - */ - ICAPClass *c = *ci; - ICAPServiceRep::Pointer service = findBestService(c, false); - if (service != NULL) { - debugs(93, 3, "ICAPAccessCheck::check: class '" << c->key.buf() << "' has candidate service '" << service->key.buf() << "'"); - candidateClasses += c->key; - } - } - - checkCandidates(); -} - -void -ICAPAccessCheck::checkCandidates() -{ - while (!candidateClasses.empty()) { - // It didn't really match yet, but we use the name anyway. - matchedClass = candidateClasses.shift(); - ICAPClass *theClass = TheICAPConfig.findClass(matchedClass); - - if (theClass == NULL) - // class apparently went away (reconfigure) - continue; - - // XXX we don't have access to conn->rfc931 here. - acl_checklist = aclChecklistCreate(theClass->accessList, req, dash_str); - - acl_checklist->nonBlockingCheck(ICAPAccessCheckCallbackWrapper, this); - - return; - } - - /* - * when there are no canidates, set matchedClass to NULL string - * and call the wrapper with answer = 1 - */ - debugs(93, 3, "ICAPAccessCheck::check: NO candidates or matches found"); - - matchedClass.clean(); - - ICAPAccessCheckCallbackWrapper(1, this); - - return; -} - -void -ICAPAccessCheck::ICAPAccessCheckCallbackWrapper(int answer, void *data) -{ - debugs(93, 5, "ICAPAccessCheckCallbackWrapper: answer=" << answer); - ICAPAccessCheck *ac = (ICAPAccessCheck*)data; - - if (ac->matchedClass.size()) { - debugs(93, 5, "ICAPAccessCheckCallbackWrapper matchedClass = " << ac->matchedClass.buf()); - } - - if (!answer) { - ac->checkCandidates(); - return; - } - - /* - * We use an event here to break deep function call sequences - */ - CallJobHere(93, 5, ac, ICAPAccessCheck::do_callback); -} - -#if 0 -void -ICAPAccessCheck::ICAPAccessCheckCallbackEvent(void *data) -{ - debugs(93, 5, "ICAPAccessCheckCallbackEvent"); - ICAPAccessCheck *ac = (ICAPAccessCheck*)data; - ac->do_callback(); - delete ac; -} -#endif - -void -ICAPAccessCheck::do_callback() -{ - debugs(93, 3, "ICAPAccessCheck::do_callback"); - - if (matchedClass.size()) { - debugs(93, 3, "ICAPAccessCheck::do_callback matchedClass = " << matchedClass.buf()); - } - - void *validated_cbdata; - if (!cbdataReferenceValidDone(callback_data, &validated_cbdata)) { - debugs(93,3,HERE << "do_callback: callback_data became invalid, skipping"); - return; - } - - ICAPServiceRep::Pointer service = NULL; - if (ICAPClass *c = TheICAPConfig.findClass(matchedClass)) { - service = findBestService(c, true); - if (service != NULL) - debugs(93,3,HERE << "do_callback: with service " << service->uri); - else - debugs(93,3,HERE << "do_callback: no " << matchedClass << " service"); - } else { - debugs(93,3,HERE << "do_callback: no " << matchedClass << " class"); - } - - callback(service, validated_cbdata); - done = TRUE; -} - -ICAPServiceRep::Pointer -ICAPAccessCheck::findBestService(ICAPClass *c, bool preferUp) { - - const char *what = preferUp ? "up " : ""; - debugs(93,7,HERE << "looking for the first matching " << - what << "service in class " << c->key); - - ICAPServiceRep::Pointer secondBest; - - Vector::iterator si; - for (si = c->services.begin(); si != c->services.end(); ++si) { - ICAPServiceRep::Pointer service = *si; - - if (method != service->method) - continue; - - if (point != service->point) - continue; - - // sending a message to a broken service is likely to cause errors - if (service->bypass && service->broken()) - continue; - - if (service->up()) { - // sending a message to a service that does not want it is useless - // note that we cannot check wantsUrl for service that is not "up" - // note that even essential services are skipped on unwanted URLs! - if (!service->wantsUrl(req->urlpath)) - continue; - } else { - if (!secondBest) - secondBest = service; - if (preferUp) { - // the caller asked for an "up" service and we can bypass this one - if (service->bypass) - continue; - debugs(93,5,HERE << "cannot skip an essential down service"); - what = "down-but-essential "; - } - } - - debugs(93,5,HERE << "found first matching " << - what << "service in class " << c->key << - ": " << service->key); - - return service; - } - - if (secondBest != NULL) { - what = "down "; - debugs(93,5,HERE << "found first matching " << - what << "service in class " << c->key << - ": " << secondBest->key); - return secondBest; - } - - debugs(93,5,HERE << "found no matching " << - what << "services in class " << c->key); - return ICAPServiceRep::Pointer(); -} - -// ================================================================================ // - -void -ICAPConfig::parseICAPService() -{ - ICAPServiceRep::Pointer S = new ICAPServiceRep(); - - if (S->configure(S)) - services += S; - else - S->invalidate(); -}; - -void -ICAPConfig::freeICAPService() -{ - services.clean(); -}; - -void -ICAPConfig::dumpICAPService(StoreEntry *entry, const char *name) const -{ - typedef Vector::const_iterator VI; - - for (VI i = services.begin(); i != services.end(); ++i) { - const ICAPServiceRep::Pointer &r = *i; - storeAppendPrintf(entry, "%s %s_%s %s %d %s\n", name, r->key.buf(), - r->methodStr(), r->vectPointStr(), r->bypass, r->uri.buf()); - } -}; - -void -ICAPConfig::parseICAPClass() -{ - ICAPClass *C = new ICAPClass(); - - if (C->prepare()) { - classes.push_back(C); - } else { - delete C; - } -}; - -void -ICAPConfig::freeICAPClass() -{ - classes.clean(); -}; - -void -ICAPConfig::dumpICAPClass(StoreEntry *entry, const char *name) const -{ - Vector::const_iterator i = classes.begin(); - - while (i != classes.end()) { - storeAppendPrintf(entry, "%s %s\n", name, (*i)->key.buf()); - ++i; - } -}; - -void -ICAPConfig::parseICAPAccess(ConfigParser &parser) -{ - String aKey; - ConfigParser::ParseString(&aKey); - ICAPClass *theClass = TheICAPConfig.findClass(aKey); - - if (theClass == NULL) - fatalf("Did not find ICAP class '%s' referenced on line %d\n", - aKey.buf(), config_lineno); - - aclParseAccessLine(parser, &theClass->accessList); -}; - -void -ICAPConfig::freeICAPAccess() -{ - (void) 0; -}; - -void -ICAPConfig::dumpICAPAccess(StoreEntry *entry, const char *name) const -{ - LOCAL_ARRAY(char, nom, 64); - - Vector::const_iterator i = classes.begin(); - - while (i != classes.end()) { - snprintf(nom, 64, "%s %s", name, (*i)->key.buf()); - dump_acl_access(entry, nom, (*i)->accessList); - ++i; - } -}; +ICAPConfig::ICAPConfig(): preview_enable(0), preview_size(0), + connect_timeout_raw(0), io_timeout_raw(0), reuse_connections(0), + client_username_header(NULL), client_username_encode(0) +{ +} ICAPConfig::~ICAPConfig() { - - // invalidate each service so that it can be deleted when refcount=0 - Vector::iterator si; - - for (si = services.begin(); si != services.end(); ++si) - (*si)->invalidate(); - - classes.clean(); - -}; + // TODO: delete client_username_header? +} + +Adaptation::ServicePointer +ICAPConfig::createService(const Adaptation::ServiceConfig &cfg) +{ + ICAPServiceRep::Pointer s = new ICAPServiceRep(cfg); + s->setSelf(s); + return s.getRaw(); +} time_t ICAPConfig::connect_timeout(bool bypassable) const { if (connect_timeout_raw > 0) return connect_timeout_raw; // explicitly configured - return bypassable ? Config.Timeout.peer_connect : Config.Timeout.connect; + return bypassable ? ::Config.Timeout.peer_connect : ::Config.Timeout.connect; } time_t ICAPConfig::io_timeout(bool) const @@ -449,16 +80,5 @@ return io_timeout_raw; // explicitly configured // TODO: provide a different default for an ICAP transaction that // can still be bypassed - return Config.Timeout.read; -} - -ICAPConfig::ICAPConfig(const ICAPConfig &) -{ - assert(false); // unsupported -} - -ICAPConfig &ICAPConfig::operator =(const ICAPConfig &) -{ - assert(false); // unsupported - return *this; + return ::Config.Timeout.read; } === modified file 'src/ICAP/ICAPConfig.h' --- src/ICAP/ICAPConfig.h 2008-02-13 06:12:45 +0000 +++ src/ICAP/ICAPConfig.h 2008-03-30 19:13:51 +0000 @@ -38,108 +38,37 @@ #include "event.h" #include "AsyncCall.h" +#include "adaptation/Config.h" #include "ICAPServiceRep.h" class acl_access; class ConfigParser; -class ICAPClass -{ - -public: - String key; - acl_access *accessList; - - Vector services; - - ICAPClass() : key(NULL), accessList(NULL) {}; - - int prepare(); -}; - -class ICAPAccessCheck: public virtual AsyncJob -{ - -public: - typedef void ICAPAccessCheckCallback(ICAPServiceRep::Pointer match, void *data); - ICAPAccessCheck(ICAP::Method, ICAP::VectPoint, HttpRequest *, HttpReply *, ICAPAccessCheckCallback *, void *); - ~ICAPAccessCheck(); - -private: - ICAP::Method method; - ICAP::VectPoint point; - HttpRequest *req; - HttpReply *rep; - ICAPAccessCheckCallback *callback; - void *callback_data; - ACLChecklist *acl_checklist; - Vector candidateClasses; - String matchedClass; - void do_callback(); - ICAPServiceRep::Pointer findBestService(ICAPClass *c, bool preferUp); - bool done; - -public: - void check(); - void checkCandidates(); - static void ICAPAccessCheckCallbackWrapper(int, void*); -#if 0 - static EVH ICAPAccessCheckCallbackEvent; -#endif -//AsyncJob virtual methods - virtual bool doneAll() const { return AsyncJob::doneAll() && done;} - -private: - CBDATA_CLASS2(ICAPAccessCheck); -}; - -class ICAPConfig -{ - -public: - - int onoff; +class ICAPConfig: public Adaptation::Config +{ + +public: + int default_options_ttl; int preview_enable; int preview_size; time_t connect_timeout_raw; time_t io_timeout_raw; - int default_options_ttl; - int send_client_ip; - int send_client_username; int reuse_connections; - int service_failure_limit; - int service_revival_delay; char* client_username_header; int client_username_encode; - Vector services; - Vector classes; - - ICAPConfig() {}; - + ICAPConfig(); ~ICAPConfig(); time_t connect_timeout(bool bypassable) const; time_t io_timeout(bool bypassable) const; - void parseICAPService(void); - void freeICAPService(void); - void dumpICAPService(StoreEntry *, const char *) const; - ICAPServiceRep::Pointer findService(const String&); - ICAPClass * findClass(const String& key); - - void parseICAPClass(void); - void freeICAPClass(void); - void dumpICAPClass(StoreEntry *, const char *) const; - - void parseICAPAccess(ConfigParser &parser); - void freeICAPAccess(void); - void dumpICAPAccess(StoreEntry *, const char *) const; - private: - ICAPConfig(const ICAPConfig &); // unsupported - ICAPConfig &operator =(const ICAPConfig &); // unsupported + ICAPConfig(const ICAPConfig &); // not implemented + ICAPConfig &operator =(const ICAPConfig &); // not implemented + + virtual Adaptation::ServicePointer createService(const Adaptation::ServiceConfig &cfg); }; extern ICAPConfig TheICAPConfig; === modified file 'src/ICAP/ICAPElements.cc' --- src/ICAP/ICAPElements.cc 2005-11-22 06:32:59 +0000 +++ src/ICAP/ICAPElements.cc 2008-04-05 05:16:03 +0000 @@ -1,52 +1,4 @@ #include "squid.h" #include "ICAPElements.h" -const char *ICAP::crlf = "\r\n"; - - -const char * -ICAP::methodStr(ICAP::Method method) -{ - switch(method) { - - case ICAP::methodReqmod: - return "REQMOD"; - break; - - case ICAP::methodRespmod: - return "RESPMOD"; - break; - - case ICAP::methodOptions: - return "OPTIONS"; - break; - - default: - break; - } - - return "NONE"; -} - - -const char * -ICAP::vectPointStr(ICAP::VectPoint point) -{ - switch(point) { - - case ICAP::pointPreCache: - return "PRECACHE"; - break; - - case ICAP::pointPostCache: - return "POSTCACHE"; - break; - - default: - break; - } - - return "NONE"; -} - - +// TODO: remove this file? === modified file 'src/ICAP/ICAPElements.h' --- src/ICAP/ICAPElements.h 2007-04-06 10:50:04 +0000 +++ src/ICAP/ICAPElements.h 2008-03-24 04:40:39 +0000 @@ -34,19 +34,25 @@ #ifndef SQUID_ICAPELEMENTS_H #define SQUID_ICAPELEMENTS_H +#include "adaptation/Elements.h" + // ICAP-related things shared by many ICAP classes -// A "fake" class to encapsulate ICAP-related declarations without -// adding namespaces to Squid. Eventually, namespaces should be added. - -struct ICAP +namespace ICAP { - typedef enum { methodNone, methodReqmod, methodRespmod, methodOptions } Method; - typedef enum { pointNone, pointPreCache, pointPostCache } VectPoint; - - static const char *crlf; - static const char *methodStr(ICAP::Method); - static const char *vectPointStr(ICAP::VectPoint); -}; + using Adaptation::Method; + using Adaptation::methodNone; + using Adaptation::methodRespmod; + using Adaptation::methodReqmod; + + using Adaptation::VectPoint; + using Adaptation::pointNone; + using Adaptation::pointPreCache; + using Adaptation::pointPostCache; + + using Adaptation::crlf; + using Adaptation::methodStr; + using Adaptation::vectPointStr; +} #endif /* SQUID_ICAPCLIENT_H */ === modified file 'src/ICAP/ICAPLauncher.cc' --- src/ICAP/ICAPLauncher.cc 2008-02-13 06:12:45 +0000 +++ src/ICAP/ICAPLauncher.cc 2008-03-30 19:40:57 +0000 @@ -7,10 +7,13 @@ #include "HttpMsg.h" #include "ICAPLauncher.h" #include "ICAPXaction.h" - - -ICAPLauncher::ICAPLauncher(const char *aTypeName, ICAPInitiator *anInitiator, ICAPServiceRep::Pointer &aService):AsyncJob(aTypeName), - ICAPInitiate(aTypeName, anInitiator, aService), +#include "ICAPServiceRep.h" + + +ICAPLauncher::ICAPLauncher(const char *aTypeName, + Adaptation::Initiator *anInitiator, Adaptation::ServicePointer &aService): + AsyncJob(aTypeName), + Adaptation::Initiate(aTypeName, anInitiator, aService), theXaction(0), theLaunches(0) { } @@ -22,7 +25,7 @@ void ICAPLauncher::start() { - ICAPInitiate::start(); + Adaptation::Initiate::start(); Must(theInitiator); launchXaction(false); @@ -36,16 +39,16 @@ ICAPXaction *x = createXaction(); if (final) x->disableRetries(); - theXaction = initiateIcap(x); + theXaction = initiateAdaptation(x); Must(theXaction); } -void ICAPLauncher::noteIcapAnswer(HttpMsg *message) +void ICAPLauncher::noteAdaptationAnswer(HttpMsg *message) { sendAnswer(message); - clearIcap(theXaction); + clearAdaptation(theXaction); Must(done()); - debugs(93,3, HERE << "ICAPLauncher::noteIcapAnswer exiting "); + debugs(93,3, HERE << "ICAPLauncher::noteAdaptationAnswer exiting "); } void ICAPLauncher::noteInitiatorAborted() @@ -57,9 +60,9 @@ } -void ICAPLauncher::noteIcapQueryAbort(bool final) +void ICAPLauncher::noteAdaptationQueryAbort(bool final) { - clearIcap(theXaction); + clearAdaptation(theXaction); // TODO: add more checks from FwdState::checkRetry()? if (!final && theLaunches < 2 && !shutting_down) { @@ -73,16 +76,16 @@ } bool ICAPLauncher::doneAll() const { - return (!theInitiator || !theXaction) && ICAPInitiate::doneAll(); + return (!theInitiator || !theXaction) && Adaptation::Initiate::doneAll(); } void ICAPLauncher::swanSong() { if (theInitiator) - tellQueryAborted(!service().bypass); + tellQueryAborted(!service().cfg().bypass); if (theXaction) - clearIcap(theXaction); + clearAdaptation(theXaction); - ICAPInitiate::swanSong(); + Adaptation::Initiate::swanSong(); } === modified file 'src/ICAP/ICAPLauncher.h' --- src/ICAP/ICAPLauncher.h 2008-02-13 06:12:45 +0000 +++ src/ICAP/ICAPLauncher.h 2008-03-30 19:40:57 +0000 @@ -34,8 +34,9 @@ #ifndef SQUID_ICAPLAUNCHER_H #define SQUID_ICAPLAUNCHER_H -#include "ICAP/ICAPInitiator.h" -#include "ICAP/ICAPInitiate.h" +#include "adaptation/Initiator.h" +#include "adaptation/Initiate.h" +#include "ICAP/ICAPServiceRep.h" /* * The ICAP Launcher starts an ICAP transaction. If the transaction fails @@ -62,21 +63,21 @@ // Note: ICAPInitiate must be the first parent for cbdata to work. We use // a temporary ICAPInitaitorHolder/toCbdata hacks and do not call cbdata // operations on the initiator directly. -class ICAPLauncher: public ICAPInitiate, public ICAPInitiator +class ICAPLauncher: public Adaptation::Initiate, public Adaptation::Initiator { public: - ICAPLauncher(const char *aTypeName, ICAPInitiator *anInitiator, ICAPServiceRep::Pointer &aService); + ICAPLauncher(const char *aTypeName, Adaptation::Initiator *anInitiator, Adaptation::ServicePointer &aService); virtual ~ICAPLauncher(); - // ICAPInitiate: asynchronous communication with the initiator + // Adaptation::Initiate: asynchronous communication with the initiator void noteInitiatorAborted(); - // ICAPInitiator: asynchronous communication with the current transaction - virtual void noteIcapAnswer(HttpMsg *message); - virtual void noteIcapQueryAbort(bool final); + // Adaptation::Initiator: asynchronous communication with the current transaction + virtual void noteAdaptationAnswer(HttpMsg *message); + virtual void noteAdaptationQueryAbort(bool final); protected: - // ICAPInitiate API implementation + // Adaptation::Initiate API implementation virtual void start(); virtual bool doneAll() const; virtual void swanSong(); @@ -86,7 +87,7 @@ void launchXaction(bool final); - ICAPInitiate *theXaction; // current ICAP transaction + Adaptation::Initiate *theXaction; // current ICAP transaction int theLaunches; // the number of transaction launches }; === modified file 'src/ICAP/ICAPModXact.cc' --- src/ICAP/ICAPModXact.cc 2008-02-13 06:12:45 +0000 +++ src/ICAP/ICAPModXact.cc 2008-03-30 19:40:57 +0000 @@ -7,8 +7,8 @@ #include "HttpMsg.h" #include "HttpRequest.h" #include "HttpReply.h" +#include "adaptation/Initiator.h" #include "ICAPServiceRep.h" -#include "ICAPInitiator.h" #include "ICAPLauncher.h" #include "ICAPModXact.h" #include "ICAPClient.h" @@ -37,7 +37,7 @@ memset(this, 0, sizeof(*this)); } -ICAPModXact::ICAPModXact(ICAPInitiator *anInitiator, HttpMsg *virginHeader, +ICAPModXact::ICAPModXact(Adaptation::Initiator *anInitiator, HttpMsg *virginHeader, HttpRequest *virginCause, ICAPServiceRep::Pointer &aService): AsyncJob("ICAPModXact"), ICAPXaction("ICAPModXact", anInitiator, aService), @@ -72,7 +72,7 @@ estimateVirginBody(); // before virgin disappears! - canStartBypass = service().bypass; + canStartBypass = service().cfg().bypass; // it is an ICAP violation to send request to a service w/o known OPTIONS @@ -716,14 +716,14 @@ bool ICAPModXact::validate200Ok() { - if (ICAP::methodRespmod == service().method) { + if (ICAP::methodRespmod == service().cfg().method) { if (!gotEncapsulated("res-hdr")) return false; return true; } - if (ICAP::methodReqmod == service().method) { + if (ICAP::methodReqmod == service().cfg().method) { if (!gotEncapsulated("res-hdr") && !gotEncapsulated("req-hdr")) return false; @@ -1047,7 +1047,7 @@ /* * XXX These should use HttpHdr interfaces instead of Printfs */ - const ICAPServiceRep &s = service(); + const Adaptation::ServiceConfig &s = service().cfg(); buf.Printf("%s %s ICAP/1.0\r\n", s.methodStr(), s.uri.buf()); buf.Printf("Host: %s:%d\r\n", s.host.buf(), s.port); buf.Printf("Date: %s\r\n", mkrfc1123(squid_curtime)); @@ -1540,7 +1540,7 @@ /* ICAPModXactLauncher */ -ICAPModXactLauncher::ICAPModXactLauncher(ICAPInitiator *anInitiator, HttpMsg *virginHeader, HttpRequest *virginCause, ICAPServiceRep::Pointer &aService): +ICAPModXactLauncher::ICAPModXactLauncher(Adaptation::Initiator *anInitiator, HttpMsg *virginHeader, HttpRequest *virginCause, Adaptation::ServicePointer aService): AsyncJob("ICAPModXactLauncher"), ICAPLauncher("ICAPModXactLauncher", anInitiator, aService) { @@ -1550,5 +1550,8 @@ ICAPXaction *ICAPModXactLauncher::createXaction() { - return new ICAPModXact(this, virgin.header, virgin.cause, theService); + ICAPServiceRep::Pointer s = + dynamic_cast(theService.getRaw()); + Must(s != NULL); + return new ICAPModXact(this, virgin.header, virgin.cause, s); } === modified file 'src/ICAP/ICAPModXact.h' --- src/ICAP/ICAPModXact.h 2008-03-16 22:10:18 +0000 +++ src/ICAP/ICAPModXact.h 2008-03-31 01:06:13 +0000 @@ -127,13 +127,11 @@ enum State { stDisabled, stWriting, stIeof, stDone } theState; }; -class ICAPInitiator; - class ICAPModXact: public ICAPXaction, public BodyProducer, public BodyConsumer { public: - ICAPModXact(ICAPInitiator *anInitiator, HttpMsg *virginHeader, HttpRequest *virginCause, ICAPServiceRep::Pointer &s); + ICAPModXact(Adaptation::Initiator *anInitiator, HttpMsg *virginHeader, HttpRequest *virginCause, ICAPServiceRep::Pointer &s); // BodyProducer methods virtual void noteMoreBodySpaceAvailable(BodyPipe::Pointer); @@ -310,7 +308,7 @@ class ICAPModXactLauncher: public ICAPLauncher { public: - ICAPModXactLauncher(ICAPInitiator *anInitiator, HttpMsg *virginHeader, HttpRequest *virginCause, ICAPServiceRep::Pointer &s); + ICAPModXactLauncher(Adaptation::Initiator *anInitiator, HttpMsg *virginHeader, HttpRequest *virginCause, Adaptation::ServicePointer s); protected: virtual ICAPXaction *createXaction(); === modified file 'src/ICAP/ICAPOptXact.cc' --- src/ICAP/ICAPOptXact.cc 2008-02-13 06:12:45 +0000 +++ src/ICAP/ICAPOptXact.cc 2008-03-30 19:40:57 +0000 @@ -14,7 +14,7 @@ CBDATA_CLASS_INIT(ICAPOptXactLauncher); -ICAPOptXact::ICAPOptXact(ICAPInitiator *anInitiator, ICAPServiceRep::Pointer &aService): +ICAPOptXact::ICAPOptXact(Adaptation::Initiator *anInitiator, ICAPServiceRep::Pointer &aService): AsyncJob("ICAPOptXact"), ICAPXaction("ICAPOptXact", anInitiator, aService) { @@ -42,9 +42,9 @@ void ICAPOptXact::makeRequest(MemBuf &buf) { - const ICAPServiceRep &s = service(); - buf.Printf("OPTIONS %s ICAP/1.0\r\n", s.uri.buf()); - buf.Printf("Host: %s:%d\r\n", s.host.buf(), s.port); + const Adaptation::Service &s = service(); + buf.Printf("OPTIONS %s ICAP/1.0\r\n", s.cfg().uri.buf()); + buf.Printf("Host: %s:%d\r\n", s.cfg().host.buf(), s.cfg().port); buf.append(ICAP::crlf, 2); } @@ -88,7 +88,7 @@ /* ICAPOptXactLauncher */ -ICAPOptXactLauncher::ICAPOptXactLauncher(ICAPInitiator *anInitiator, ICAPServiceRep::Pointer &aService): +ICAPOptXactLauncher::ICAPOptXactLauncher(Adaptation::Initiator *anInitiator, Adaptation::ServicePointer aService): AsyncJob("ICAPOptXactLauncher"), ICAPLauncher("ICAPOptXactLauncher", anInitiator, aService) { @@ -96,5 +96,8 @@ ICAPXaction *ICAPOptXactLauncher::createXaction() { - return new ICAPOptXact(this, theService); + ICAPServiceRep::Pointer s = + dynamic_cast(theService.getRaw()); + Must(s != NULL); + return new ICAPOptXact(this, s); } === modified file 'src/ICAP/ICAPOptXact.h' --- src/ICAP/ICAPOptXact.h 2007-05-08 22:32:11 +0000 +++ src/ICAP/ICAPOptXact.h 2008-03-30 19:40:57 +0000 @@ -48,7 +48,7 @@ { public: - ICAPOptXact(ICAPInitiator *anInitiator, ICAPServiceRep::Pointer &aService); + ICAPOptXact(Adaptation::Initiator *anInitiator, ICAPServiceRep::Pointer &aService); protected: virtual void start(); @@ -70,7 +70,7 @@ class ICAPOptXactLauncher: public ICAPLauncher { public: - ICAPOptXactLauncher(ICAPInitiator *anInitiator, ICAPServiceRep::Pointer &aService); + ICAPOptXactLauncher(Adaptation::Initiator *anInitiator, Adaptation::ServicePointer aService); protected: virtual ICAPXaction *createXaction(); === modified file 'src/ICAP/ICAPServiceRep.cc' --- src/ICAP/ICAPServiceRep.cc 2008-02-13 06:12:45 +0000 +++ src/ICAP/ICAPServiceRep.cc 2008-04-05 05:16:03 +0000 @@ -10,12 +10,13 @@ #include "ICAPOptXact.h" #include "ConfigParser.h" #include "ICAPConfig.h" +#include "ICAPModXact.h" #include "SquidTime.h" CBDATA_CLASS_INIT(ICAPServiceRep); -ICAPServiceRep::ICAPServiceRep(): AsyncJob("ICAPServiceRep"), method(ICAP::methodNone), - point(ICAP::pointNone), port(-1), bypass(false), +ICAPServiceRep::ICAPServiceRep(const Adaptation::ServiceConfig &cfg): + AsyncJob("ICAPServiceRep"), Adaptation::Service(cfg), theOptions(NULL), theOptionsFetcher(0), theLastUpdate(0), theSessionFailures(0), isSuspended(0), notifying(false), updateScheduled(false), self(NULL), @@ -28,137 +29,31 @@ changeOptions(0); } -const char * -ICAPServiceRep::methodStr() const -{ - return ICAP::methodStr(method); -} - -ICAP::Method -ICAPServiceRep::parseMethod(const char *str) const -{ - if (!strncasecmp(str, "REQMOD", 6)) - return ICAP::methodReqmod; - - if (!strncasecmp(str, "RESPMOD", 7)) - return ICAP::methodRespmod; - - return ICAP::methodNone; -} - - -const char * -ICAPServiceRep::vectPointStr() const -{ - return ICAP::vectPointStr(point); -} - -ICAP::VectPoint -ICAPServiceRep::parseVectPoint(const char *service) const -{ - const char *t = service; - const char *q = strchr(t, '_'); - - if (q) - t = q + 1; - - if (!strcasecmp(t, "precache")) - return ICAP::pointPreCache; - - if (!strcasecmp(t, "postcache")) - return ICAP::pointPostCache; - - return ICAP::pointNone; -} - -bool -ICAPServiceRep::configure(Pointer &aSelf) +void +ICAPServiceRep::setSelf(Pointer &aSelf) { assert(!self && aSelf != NULL); self = aSelf; - - char *service_type = NULL; - - ConfigParser::ParseString(&key); - ConfigParser::ParseString(&service_type); - ConfigParser::ParseBool(&bypass); - ConfigParser::ParseString(&uri); - - debugs(3, 5, "ICAPService::parseConfigLine (line " << config_lineno << "): " << key.buf() << " " << service_type << " " << bypass); - - method = parseMethod(service_type); - point = parseVectPoint(service_type); - - debugs(3, 5, "ICAPService::parseConfigLine (line " << config_lineno << "): service is " << methodStr() << "_" << vectPointStr()); - - if (uri.cmp("icap://", 7) != 0) { - debugs(3, 0, "ICAPService::parseConfigLine (line " << config_lineno << "): wrong uri: " << uri.buf()); - return false; - } - - const char *s = uri.buf() + 7; - - const char *e; - - bool have_port = false; - - if ((e = strchr(s, ':')) != NULL) { - have_port = true; - } else if ((e = strchr(s, '/')) != NULL) { - have_port = false; - } else { - return false; - } - - int len = e - s; - host.limitInit(s, len); - s = e; - - if (have_port) { - s++; - - if ((e = strchr(s, '/')) != NULL) { - char *t; - port = strtoul(s, &t, 0) % 65536; - - if (t != e) { - return false; - } - - s = e; - - if (s[0] != '/') { - return false; - } - } - } else { - +} + +void +ICAPServiceRep::finalize() +{ + Adaptation::Service::finalize(); + assert(self != NULL); + + // use /etc/services or default port if needed + const bool have_port = cfg().port >= 0; + if (!have_port) { struct servent *serv = getservbyname("icap", "tcp"); if (serv) { - port = htons(serv->s_port); + writeableCfg().port = htons(serv->s_port); } else { - port = 1344; + writeableCfg().port = 1344; } } - - s++; - e = strchr(s, '\0'); - len = e - s; - - if (len > 1024) { - debugs(3, 0, "icap_service_process (line " << config_lineno << "): long resource name (>1024), probably wrong"); - } - - resource.limitInit(s, len + 1); - - if ((bypass != 0) && (bypass != 1)) { - return false; - } - - return true; - -}; +} void ICAPServiceRep::invalidate() { @@ -357,7 +252,7 @@ if (!theOptions->valid()) { debugs(93,1, "WARNING: Squid got an invalid ICAP OPTIONS response " << - "from service " << uri << "; error: " << theOptions->error); + "from service " << cfg().uri << "; error: " << theOptions->error); return; } @@ -373,7 +268,7 @@ while (iter != theOptions->methods.end()) { - if (*iter == method) { + if (*iter == cfg().method) { method_found = true; break; } @@ -385,8 +280,8 @@ if (!method_found) { debugs(93,1, "WARNING: Squid is configured to use ICAP method " << - ICAP::methodStr(method) << - " for service " << uri.buf() << + cfg().methodStr() << + " for service " << cfg().uri.buf() << " but OPTIONS response declares the methods are " << method_list.buf()); } } @@ -400,7 +295,7 @@ // TODO: If skew is negative, the option will be considered down // because of stale options. We should probably change this. debugs(93, 1, "ICAP service's clock is skewed by " << skew << - " seconds: " << uri.buf()); + " seconds: " << cfg().uri.buf()); } } @@ -409,20 +304,20 @@ if (wasAnnouncedUp == up()) // no significant changes to announce return; - const char *what = bypass ? "optional" : "essential"; + const char *what = cfg().bypass ? "optional" : "essential"; const char *state = wasAnnouncedUp ? downPhrase : "up"; const int level = important ? 1 : 2; - debugs(93,level, what << " ICAP service is " << state << ": " << uri << - ' ' << status()); + debugs(93,level, what << " ICAP service is " << state << ": " << + cfg().uri << ' ' << status()); wasAnnouncedUp = !wasAnnouncedUp; } // we are receiving ICAP OPTIONS response headers here or NULL on failures -void ICAPServiceRep::noteIcapAnswer(HttpMsg *msg) +void ICAPServiceRep::noteAdaptationAnswer(HttpMsg *msg) { Must(theOptionsFetcher); - clearIcap(theOptionsFetcher); + clearAdaptation(theOptionsFetcher); Must(msg); @@ -439,9 +334,9 @@ handleNewOptions(newOptions); } -void ICAPServiceRep::noteIcapQueryAbort(bool) { +void ICAPServiceRep::noteAdaptationQueryAbort(bool) { Must(theOptionsFetcher); - clearIcap(theOptionsFetcher); + clearAdaptation(theOptionsFetcher); debugs(93,3, "ICAPService failed to fetch options " << status()); handleNewOptions(0); @@ -463,7 +358,8 @@ Must(!theOptionsFetcher); debugs(93,6, "ICAPService will get new options " << status()); - theOptionsFetcher = initiateIcap(new ICAPOptXactLauncher(this, self)); + // XXX: second "this" is "self"; this works but may stop if API changes + theOptionsFetcher = initiateAdaptation(new ICAPOptXactLauncher(this, this)); Must(theOptionsFetcher); // TODO: timeout in case ICAPOptXact never calls us back? // Such a timeout should probably be a generic AsyncStart feature. @@ -530,6 +426,13 @@ return squid_curtime + TheICAPConfig.service_revival_delay; } +Adaptation::Initiate * +ICAPServiceRep::makeXactLauncher(Adaptation::Initiator *initiator, + HttpMsg *virgin, HttpRequest *cause) +{ + return new ICAPModXactLauncher(initiator, virgin, cause, this); +} + // returns a temporary string depicting service status, for debugging const char *ICAPServiceRep::status() const { === modified file 'src/ICAP/ICAPServiceRep.h' --- src/ICAP/ICAPServiceRep.h 2008-02-13 06:12:45 +0000 +++ src/ICAP/ICAPServiceRep.h 2008-04-03 05:31:29 +0000 @@ -35,7 +35,9 @@ #define SQUID_ICAPSERVICEREP_H #include "cbdata.h" -#include "ICAPInitiator.h" +#include "adaptation/Service.h" +#include "adaptation/forward.h" +#include "adaptation/Initiator.h" #include "ICAPElements.h" class ICAPOptions; @@ -70,26 +72,28 @@ */ -class ICAPServiceRep : public RefCountable, public ICAPInitiator +class ICAPServiceRep : public RefCountable, public Adaptation::Service, + public Adaptation::Initiator { public: typedef RefCount Pointer; public: - ICAPServiceRep(); + ICAPServiceRep(const Adaptation::ServiceConfig &config); virtual ~ICAPServiceRep(); - bool configure(Pointer &aSelf); // needs self pointer for ICAPOptXact + void setSelf(Pointer &aSelf); // needs self pointer for ICAPOptXact + virtual void finalize(); + void invalidate(); // call when the service is no longer needed or valid - const char *methodStr() const; - const char *vectPointStr() const; - bool probed() const; // see comments above bool broken() const; // see comments above bool up() const; // see comments above + virtual Adaptation::Initiate *makeXactLauncher(Adaptation::Initiator *, HttpMsg *virginHeader, HttpRequest *virginCause); + void callWhenReady(AsyncCall::Pointer &cb); // the methods below can only be called on an up() service @@ -100,29 +104,15 @@ void noteFailure(); // called by transactions to report service failure //AsyncJob virtual methods - virtual bool doneAll() const { return ICAPInitiator::doneAll() && false;} - -public: - String key; - ICAP::Method method; - ICAP::VectPoint point; - String uri; // service URI - - // URI components - String host; - int port; - String resource; - - // XXX: use it when selecting a service and handling ICAP errors! - bool bypass; + virtual bool doneAll() const { return Adaptation::Initiator::doneAll() && false;} public: // treat these as private, they are for callbacks only void noteTimeToUpdate(); void noteTimeToNotify(); // receive either an ICAP OPTIONS response header or an abort message - virtual void noteIcapAnswer(HttpMsg *msg); - virtual void noteIcapQueryAbort(bool); + virtual void noteAdaptationAnswer(HttpMsg *msg); + virtual void noteAdaptationQueryAbort(bool); private: // stores Prepare() callback info @@ -137,7 +127,7 @@ Clients theClients; // all clients waiting for a call back ICAPOptions *theOptions; - ICAPInitiate *theOptionsFetcher; // pending ICAP OPTIONS transaction + Adaptation::Initiate *theOptionsFetcher; // pending ICAP OPTIONS transaction time_t theLastUpdate; // time the options were last updated static const int TheSessionFailureLimit; @@ -174,5 +164,4 @@ CBDATA_CLASS2(ICAPServiceRep); }; - #endif /* SQUID_ICAPSERVICEREP_H */ === modified file 'src/ICAP/ICAPXaction.cc' --- src/ICAP/ICAPXaction.cc 2008-02-13 06:12:45 +0000 +++ src/ICAP/ICAPXaction.cc 2008-03-30 19:40:57 +0000 @@ -17,9 +17,9 @@ //CBDATA_CLASS_INIT(ICAPXaction); -ICAPXaction::ICAPXaction(const char *aTypeName, ICAPInitiator *anInitiator, ICAPServiceRep::Pointer &aService): +ICAPXaction::ICAPXaction(const char *aTypeName, Adaptation::Initiator *anInitiator, ICAPServiceRep::Pointer &aService): AsyncJob(aTypeName), - ICAPInitiate(aTypeName, anInitiator, aService), + Adaptation::Initiate(aTypeName, anInitiator, aService.getRaw()), connection(-1), commBuf(NULL), commBufSize(0), commEof(false), @@ -38,6 +38,14 @@ " [icapx" << id << ']'); // we should not call virtual status() here } +ICAPServiceRep & +ICAPXaction::service() +{ + ICAPServiceRep *s = dynamic_cast(&Initiate::service()); + Must(s); + return *s; +} + void ICAPXaction::disableRetries() { debugs(93,5, typeName << (isRetriable ? " becomes" : " remains") << " final" << status()); @@ -46,7 +54,7 @@ void ICAPXaction::start() { - ICAPInitiate::start(); + Adaptation::Initiate::start(); readBuf.init(SQUID_TCP_SO_RCVBUF, SQUID_TCP_SO_RCVBUF); commBuf = (char*)memAllocBuf(SQUID_TCP_SO_RCVBUF, &commBufSize); @@ -61,13 +69,13 @@ Must(connection < 0); - const ICAPServiceRep &s = service(); + const Adaptation::Service &s = service(); if (!TheICAPConfig.reuse_connections) disableRetries(); // this will also safely drain pconn pool // TODO: check whether NULL domain is appropriate here - connection = icapPconnPool->pop(s.host.buf(), s.port, NULL, client_addr, isRetriable); + connection = icapPconnPool->pop(s.cfg().host.buf(), s.cfg().port, NULL, client_addr, isRetriable); if (connection >= 0) { debugs(93,3, HERE << "reused pconn FD " << connection); @@ -86,19 +94,20 @@ IPAddress outgoing; connection = comm_open(SOCK_STREAM, 0, outgoing, - COMM_NONBLOCKING, s.uri.buf()); + COMM_NONBLOCKING, s.cfg().uri.buf()); if (connection < 0) dieOnConnectionFailure(); // throws - debugs(93,3, typeName << " opens connection to " << s.host.buf() << ":" << s.port); + debugs(93,3, typeName << " opens connection to " << s.cfg().host.buf() << ":" << s.cfg().port); // TODO: service bypass status may differ from that of a transaction typedef CommCbMemFunT TimeoutDialer; AsyncCall::Pointer timeoutCall = asyncCall(93, 5, "ICAPXaction::noteCommTimedout", TimeoutDialer(this,&ICAPXaction::noteCommTimedout)); - commSetTimeout(connection, TheICAPConfig.connect_timeout(service().bypass), timeoutCall); + commSetTimeout(connection, TheICAPConfig.connect_timeout( + service().cfg().bypass), timeoutCall); typedef CommCbMemFunT CloseDialer; closer = asyncCall(93, 5, "ICAPXaction::noteCommClosed", @@ -108,7 +117,7 @@ typedef CommCbMemFunT ConnectDialer; connector = asyncCall(93,3, "ICAPXaction::noteCommConnected", ConnectDialer(this, &ICAPXaction::noteCommConnected)); - commConnectStart(connection, s.host.buf(), s.port, connector); + commConnectStart(connection, s.cfg().host.buf(), s.cfg().port, connector); } /* @@ -146,7 +155,8 @@ debugs(93,3, HERE << "pushing pconn" << status()); AsyncCall::Pointer call = NULL; commSetTimeout(connection, -1, call); - icapPconnPool->push(connection, theService->host.buf(), theService->port, NULL, client_addr); + icapPconnPool->push(connection, theService->cfg().host.buf(), + theService->cfg().port, NULL, client_addr); disableRetries(); } else { debugs(93,3, HERE << "closing pconn" << status()); @@ -177,7 +187,7 @@ void ICAPXaction::dieOnConnectionFailure() { debugs(93, 2, HERE << typeName << - " failed to connect to " << service().uri); + " failed to connect to " << service().cfg().uri); theService->noteFailure(); throw TexcHere("cannot connect to the ICAP service"); } @@ -218,7 +228,8 @@ void ICAPXaction::handleCommTimedout() { debugs(93, 2, HERE << typeName << " failed: timeout with " << - theService->methodStr() << " " << theService->uri.buf() << status()); + theService->cfg().methodStr() << " " << + theService->cfg().uri.buf() << status()); reuseConnection = false; service().noteFailure(); @@ -245,12 +256,12 @@ debugs(93, 5, HERE << typeName << " done with I/O" << status()); closeConnection(); } - ICAPInitiate::callEnd(); // may destroy us + Adaptation::Initiate::callEnd(); // may destroy us } bool ICAPXaction::doneAll() const { - return !connector && !reader && !writer && ICAPInitiate::doneAll(); + return !connector && !reader && !writer && Adaptation::Initiate::doneAll(); } void ICAPXaction::updateTimeout() { @@ -262,7 +273,8 @@ AsyncCall::Pointer call = asyncCall(93, 5, "ICAPXaction::noteCommTimedout", TimeoutDialer(this,&ICAPXaction::noteCommTimedout)); - commSetTimeout(connection, TheICAPConfig.io_timeout(service().bypass), call); + commSetTimeout(connection, + TheICAPConfig.io_timeout(service().cfg().bypass), call); } else { // clear timeout when there is no I/O // Do we need a lifetime timeout? @@ -396,7 +408,7 @@ if (theInitiator) tellQueryAborted(!isRetriable); - ICAPInitiate::swanSong(); + Adaptation::Initiate::swanSong(); } // returns a temporary string depicting transaction status, for debugging === modified file 'src/ICAP/ICAPXaction.h' --- src/ICAP/ICAPXaction.h 2008-02-13 06:12:45 +0000 +++ src/ICAP/ICAPXaction.h 2008-03-30 19:40:57 +0000 @@ -38,7 +38,7 @@ #include "CommCalls.h" #include "MemBuf.h" #include "ICAPServiceRep.h" -#include "ICAPInitiate.h" +#include "adaptation/Initiate.h" class HttpMsg; class CommConnectCbParams; @@ -53,11 +53,11 @@ // Note: ICAPXaction must be the first parent for object-unaware cbdata to work -class ICAPXaction: public ICAPInitiate +class ICAPXaction: public Adaptation::Initiate { public: - ICAPXaction(const char *aTypeName, ICAPInitiator *anInitiator, ICAPServiceRep::Pointer &aService); + ICAPXaction(const char *aTypeName, Adaptation::Initiator *anInitiator, ICAPServiceRep::Pointer &aService); virtual ~ICAPXaction(); void disableRetries(); @@ -71,7 +71,7 @@ protected: virtual void start(); - virtual void noteInitiatorAborted(); // TODO: move to ICAPInitiate + virtual void noteInitiatorAborted(); // TODO: move to Adaptation::Initiate // comm hanndlers; called by comm handler wrappers virtual void handleCommConnected() = 0; @@ -112,6 +112,8 @@ // custom end-of-call checks virtual void callEnd(); + ICAPServiceRep &service(); + protected: int connection; // FD of the ICAP server connection === added file 'src/ICAP/Makefile.am' --- src/ICAP/Makefile.am 1970-01-01 00:00:00 +0000 +++ src/ICAP/Makefile.am 2008-03-30 19:06:02 +0000 @@ -0,0 +1,37 @@ +AM_CFLAGS = @SQUID_CFLAGS@ +AM_CXXFLAGS = @SQUID_CXXFLAGS@ + +INCLUDES = \ + -I$(top_builddir)/include \ + -I$(top_srcdir)/include \ + -I$(top_srcdir)/src + +noinst_LTLIBRARIES = libicap.la + +libicap_la_SOURCES = \ + ICAPClient.cc \ + ICAPClient.h \ + ICAPInOut.h \ + ICAPConfig.cc \ + ICAPConfig.h \ + ICAPElements.cc \ + ICAPElements.h \ + ICAPOptions.cc \ + ICAPOptions.h \ + ICAPServiceRep.cc \ + ICAPServiceRep.h \ + ICAPLauncher.cc \ + ICAPLauncher.h \ + ICAPOptXact.cc \ + ICAPOptXact.h \ + ICAPXaction.cc \ + ICAPXaction.h \ + ICAPModXact.cc \ + ICAPModXact.h + + +check_PROGRAMS = testHeaders + +## test .h correctness +testHeaders: *.h + $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "." || exit 1 === added file 'src/LoadableModule.cc' --- src/LoadableModule.cc 1970-01-01 00:00:00 +0000 +++ src/LoadableModule.cc 2008-03-31 04:31:48 +0000 @@ -0,0 +1,86 @@ +#include "squid.h" + +/* The original code has this constant ./configure-able. + * The "#else" branches use raw dlopen interface and have not been tested. + * We can remove that code if we are going to rely on libtool's ltdl in + * all environments. */ +#define XSTD_USE_LIBLTDL 1 + +#if XSTD_USE_LIBLTDL + #include "libLtdl/ltdl.h" /* generated file */ +#else + #include +#endif + +#include "TextException.h" +#include "LoadableModule.h" + +// Note: We must use preprocessor instead of C ifs because if dlopen() +// is seen by the static linker, the linker will complain. + +LoadableModule::LoadableModule(const String &aName): theName(aName), theHandle(0) { +# if XSTD_USE_LIBLTDL + // Initialise preloaded symbol lookup table. + LTDL_SET_PRELOADED_SYMBOLS(); + if (lt_dlinit() != 0) + throw TexcHere("internal error: cannot initialize libtool module loader"); +# endif +} + +LoadableModule::~LoadableModule() { + if (loaded()) + unload(); +# if XSTD_USE_LIBLTDL + assert(lt_dlexit() == 0); // XXX: replace with a warning +# endif +} + +bool LoadableModule::loaded() const { + return theHandle != 0; +} + +void LoadableModule::load(int mode) { + if (loaded()) + throw TexcHere("internal error: reusing LoadableModule object"); + + theHandle = openModule(mode); + + if (!loaded()) + throw TexcHere(errorMsg()); +} + +void LoadableModule::unload() { + if (!loaded()) + throw TexcHere("internal error: unloading not loaded module"); + + if (!closeModule()) + throw TexcHere(errorMsg()); + + theHandle = 0; +} + +void *LoadableModule::openModule(int mode) { +# if XSTD_USE_LIBLTDL + return lt_dlopen(theName.buf()); +# else + return dlopen(theName.c_str(), + mode == lmNow ? RTLD_NOW : RTLD_LAZY); +# endif +} + +bool LoadableModule::closeModule() { +# if XSTD_USE_LIBLTDL + // we cast to avoid including ltdl.h in LoadableModule.h + return lt_dlclose(static_cast(theHandle)) == 0; +# else + return dlclose(theHandle) == 0; +# endif +} + +const char *LoadableModule::errorMsg() { +# if XSTD_USE_LIBLTDL + return lt_dlerror(); +# else + return dlerror(); +# endif +} === added file 'src/LoadableModule.h' --- src/LoadableModule.h 1970-01-01 00:00:00 +0000 +++ src/LoadableModule.h 2008-03-31 04:31:48 +0000 @@ -0,0 +1,33 @@ +#ifndef SQUID_LOADABLE_MODULE_H +#define SQUID_LOADABLE_MODULE_H + +#include "SquidString.h" + +// wrapper for dlopen(3), libltdl, and friends +class LoadableModule { +public: + enum LoadMode { lmNow, lmLazy }; + +public: + LoadableModule(const String &aName); + ~LoadableModule(); // unloads if loaded + + bool loaded() const; + const String &name() const { return theName; } + const String &error() const { return theError; } + + void load(int mode = lmNow); // throws Texc + void unload(); // throws Texc + +protected: + String theName; + String theError; + void *theHandle; + +private: + void *openModule(int mode); + bool closeModule(); + const char *errorMsg(); +}; + +#endif === added file 'src/LoadableModules.cc' --- src/LoadableModules.cc 1970-01-01 00:00:00 +0000 +++ src/LoadableModules.cc 2008-03-31 04:31:48 +0000 @@ -0,0 +1,25 @@ +#include "squid.h" +#include "wordlist.h" +#include "LoadableModule.h" +#include "LoadableModules.h" + +static void +LoadModule(const char *fname) +{ + debugs(1, 1, "loading Squid module from '" << fname << "'"); + + LoadableModule *m = new LoadableModule(fname); + m->load(); + debugs(1, 2, "loaded Squid module from '" << fname << "'"); + + //TODO: TheModules.push_back(m); +} + +void +LoadableModulesConfigure(const wordlist *names) +{ + int count = 0; + for (const wordlist *i = names; i; i = i->next, ++count) + LoadModule(i->key); + debugs(1, 1, "loaded " << count << " Squid modules"); +} === added file 'src/LoadableModules.h' --- src/LoadableModules.h 1970-01-01 00:00:00 +0000 +++ src/LoadableModules.h 2008-03-31 04:31:48 +0000 @@ -0,0 +1,10 @@ +#ifndef SQUID_LOADABLE_MODULES_H +#define SQUID_LOADABLE_MODULES_H + +// TODO: add reporting for cachemgr +// TODO: add reconfiguration support + +class wordlist; +extern void LoadableModulesConfigure(const wordlist *names); + +#endif /* SQUID_LOADABLE_MODULES_H */ === modified file 'src/Makefile.am' --- src/Makefile.am 2008-03-20 11:30:19 +0000 +++ src/Makefile.am 2008-03-31 04:31:48 +0000 @@ -25,11 +25,31 @@ SNMP_SOURCE = endif +LOADABLE_MODULES_SOURCES = \ + LoadableModule.h \ + LoadableModule.cc \ + LoadableModules.h \ + LoadableModules.cc + TESTS=$(check_PROGRAMS) check_PROGRAMS= SUBDIRS = fs repl auth +if USE_ADAPTATION +SUBDIRS += adaptation +endif + +if USE_ICAP_CLIENT +SUBDIRS += ICAP +endif + +if USE_ECAP +SUBDIRS += eCAP +endif + +ADAPTATION_LIBS = @ECAP_LIBS@ @ICAP_LIBS@ @ADAPTATION_LIBS@ + DELAY_POOL_ALL_SOURCE = \ CommonPool.h \ CompositePoolNode.h \ @@ -202,11 +222,12 @@ AM_CFLAGS = @SQUID_CFLAGS@ AM_CXXFLAGS = @SQUID_CXXFLAGS@ -EXTRA_LIBRARIES = libAIO.a libBlocking.a libDiskDaemon.a libDiskThreads.a ICAP/libicap.a -noinst_LIBRARIES = @DISK_LIBS@ @ICAP_LIBS@ +EXTRA_LIBRARIES = libAIO.a libBlocking.a libDiskDaemon.a libDiskThreads.a +noinst_LIBRARIES = @DISK_LIBS@ noinst_LTLIBRARIES = libsquid.la libauth.la INCLUDES = -I. -I$(srcdir) -I$(top_builddir)/include -I$(top_srcdir)/include -I$(top_srcdir)/lib/libTrie/include +INCLUDES += -I$(top_builddir)/lib INCLUDES += @SQUID_CPPUNIT_INC@ EXTRA_PROGRAMS = \ @@ -301,6 +322,7 @@ $(UNLINKDSOURCE) \ $(SSL_ALL_SOURCE) \ $(WIN32_ALL_SOURCE) \ + $(LOADABLE_MODULES_SOURCES) \ DiskIO/DiskThreads/aiops.cc \ DiskIO/DiskThreads/aiops_win32.cc @@ -413,6 +435,7 @@ TextException.cc \ TextException.h + # authentication framework libauth_la_SOURCES = \ AuthConfig.cc \ @@ -683,7 +706,7 @@ @CRYPTLIB@ \ @REGEXLIB@ \ @SNMPLIB@ \ - @ICAP_LIBS@ \ + ${ADAPTATION_LIBS} \ @SSLLIB@ \ -lmiscutil \ @XTRA_LIBS@ \ @@ -697,32 +720,19 @@ @REPL_OBJS@ \ @AUTH_LINKOBJS@ \ @AUTH_OBJS@ \ - @ICAP_LIBS@ + ${ADAPTATION_LIBS} -ICAP_libicap_a_SOURCES = \ - ICAP/ICAPClient.cc \ - ICAP/ICAPClient.h \ - ICAP/ICAPInitiator.cc \ - ICAP/ICAPInitiator.h \ - ICAP/ICAPInitiate.cc \ - ICAP/ICAPInitiate.h \ - ICAP/ICAPInOut.h \ - ICAP/ICAPLauncher.cc \ - ICAP/ICAPLauncher.h \ - ICAP/ICAPConfig.cc \ - ICAP/ICAPConfig.h \ - ICAP/ICAPElements.cc \ - ICAP/ICAPElements.h \ - ICAP/ICAPModXact.cc \ - ICAP/ICAPModXact.h \ - ICAP/ICAPOptions.cc \ - ICAP/ICAPOptions.h \ - ICAP/ICAPOptXact.cc \ - ICAP/ICAPOptXact.h \ - ICAP/ICAPServiceRep.cc \ - ICAP/ICAPServiceRep.h \ - ICAP/ICAPXaction.cc \ - ICAP/ICAPXaction.h +if USE_LOADABLE_MODULES +squid_SOURCES += $(LOADABLE_MODULES_SOURCES) +squid_LDADD += \ + @LIBLTDL@ +squid_LDFLAGS = \ + -export-dynamic -dlopen force +# when static module linking is supported and enabled: +# squid_LDFLAGS = \ +# -all-static -dlopen self +# +endif unlinkd_SOURCES = unlinkd_daemon.cc SquidNew.cc @@ -931,7 +941,7 @@ @CRYPTLIB@ \ @REGEXLIB@ \ @SNMPLIB@ \ - @ICAP_LIBS@ \ + ${ADAPTATION_LIBS} \ @SSLLIB@ \ -lmiscutil \ @XTRA_LIBS@ \ @@ -945,7 +955,7 @@ @REPL_OBJS@ \ @AUTH_LINKOBJS@ \ @AUTH_OBJS@ \ - @ICAP_LIBS@ + ${ADAPTATION_LIBS} nodist_ufsdump_SOURCES = \ repl_modules.cc \ @@ -1179,10 +1189,9 @@ ## Special Universal .h dependency test script ## aborts if error encountered -testHeaders: *.h DiskIO/*.h ICAP/*.h +testHeaders: *.h DiskIO/*.h ../test-suite/testheaders.sh "$(CXXCOMPILE)" "." || exit 1 ../test-suite/testheaders.sh "$(CXXCOMPILE)" "DiskIO" || exit 1 - ../test-suite/testheaders.sh "$(CXXCOMPILE)" "ICAP" || exit 1 ## src/repl/ has no .h files and its own makefile. @@ -1473,7 +1482,7 @@ libsquid.la \ libauth.la \ @REPL_OBJS@ \ - @ICAP_LIBS@ \ + ${ADAPTATION_LIBS} \ @REGEXLIB@ \ @SNMPLIB@ \ -L../lib -lmiscutil \ @@ -1485,7 +1494,7 @@ tests_testCacheManager_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ @REPL_OBJS@ \ @SQUID_CPPUNIT_LA@ \ - @ICAP_LIBS@ + ${ADAPTATION_LIBS} tests_testDiskIO_SOURCES= \ $(SWAP_TEST_SOURCES) \ @@ -1643,7 +1652,7 @@ libsquid.la \ libauth.la \ @REPL_OBJS@ \ - @ICAP_LIBS@ \ + ${ADAPTATION_LIBS} \ @REGEXLIB@ \ @SNMPLIB@ \ -L../lib -lmiscutil \ @@ -1655,7 +1664,7 @@ tests_testEvent_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ @REPL_OBJS@ \ @SQUID_CPPUNIT_LA@ \ - @ICAP_LIBS@ + ${ADAPTATION_LIBS} ## Tests of the EventLoop module. tests_testEventLoop_SOURCES = \ @@ -1799,7 +1808,7 @@ libsquid.la \ libauth.la \ @REPL_OBJS@ \ - @ICAP_LIBS@ \ + ${ADAPTATION_LIBS} \ @REGEXLIB@ \ @SNMPLIB@ \ -L../lib -lmiscutil \ @@ -1811,7 +1820,7 @@ tests_testEventLoop_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ @REPL_OBJS@ \ @SQUID_CPPUNIT_LA@ \ - @ICAP_LIBS@ + ${ADAPTATION_LIBS} tests_test_http_range_SOURCES = \ tests/test_http_range.cc \ @@ -1951,7 +1960,7 @@ libauth.la \ @REPL_OBJS@ \ @STORE_OBJS@ \ - @ICAP_LIBS@ \ + ${ADAPTATION_LIBS} \ @REGEXLIB@ \ @SNMPLIB@ \ -L../lib -lmiscutil \ @@ -2106,7 +2115,7 @@ libsquid.la \ libauth.la \ @REPL_OBJS@ \ - @ICAP_LIBS@ \ + ${ADAPTATION_LIBS} \ @REGEXLIB@ \ @SNMPLIB@ \ -L../lib -lmiscutil \ @@ -2118,7 +2127,7 @@ tests_testHttpRequest_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ @REPL_OBJS@ \ @SQUID_CPPUNIT_LA@ \ - @ICAP_LIBS@ + ${ADAPTATION_LIBS} ## Tests of the ICMP base module. # Its used by pinger so SHOULD NOT require more dependancies! :-( @@ -2465,7 +2474,7 @@ libauth.la \ @REGEXLIB@ \ @REPL_OBJS@ \ - @ICAP_LIBS@ \ + ${ADAPTATION_LIBS} \ @SNMPLIB@ \ -L../lib -lmiscutil \ @SQUID_CPPUNIT_LIBS@ \ @@ -2476,4 +2485,4 @@ tests_testURL_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ @REPL_OBJS@ \ @SQUID_CPPUNIT_LA@ \ - @ICAP_LIBS@ + ${ADAPTATION_LIBS} === modified file 'src/Server.cc' --- src/Server.cc 2008-02-19 05:51:21 +0000 +++ src/Server.cc 2008-04-04 16:26:01 +0000 @@ -39,17 +39,16 @@ #include "HttpReply.h" #include "errorpage.h" -#if ICAP_CLIENT -#include "ICAP/ICAPModXact.h" -#include "ICAP/ICAPConfig.h" -extern ICAPConfig TheICAPConfig; +#if USE_ADAPTATION +#include "adaptation/AccessCheck.h" +#include "adaptation/Service.h" #endif ServerStateData::ServerStateData(FwdState *theFwdState): AsyncJob("ServerStateData"),requestSender(NULL) -#if ICAP_CLIENT +#if USE_ADAPTATION , adaptedHeadSource(NULL) - , icapAccessCheckPending(false) - , startedIcap(false) + , adaptationAccessCheckPending(false) + , startedAdaptation(false) #endif { fwd = theFwdState; @@ -73,8 +72,8 @@ if (requestBodySource != NULL) requestBodySource->clearConsumer(); -#if ICAP_CLIENT - cleanIcap(); +#if USE_ADAPTATION + cleanAdaptation(); #endif if (responseBodyBuffer != NULL) { @@ -151,11 +150,11 @@ { debugs(11,5,HERE << "serverComplete2 " << this); -#if ICAP_CLIENT +#if USE_ADAPTATION if (virginBodyDestination != NULL) stopProducingFor(virginBodyDestination, true); - if (!doneWithIcap()) + if (!doneWithAdaptation()) return; #endif @@ -167,8 +166,8 @@ // to the ICAP service. And vice versa. Here, we quit only if we are done // talking to both. void ServerStateData::quitIfAllDone() { -#if ICAP_CLIENT - if (!doneWithIcap()) { +#if USE_ADAPTATION + if (!doneWithAdaptation()) { debugs(11,5, HERE << "transaction not done: still talking to ICAP"); return; } @@ -226,7 +225,7 @@ void ServerStateData::noteMoreBodyDataAvailable(BodyPipe::Pointer bp) { -#if ICAP_CLIENT +#if USE_ADAPTATION if (adaptedBodySource == bp) { handleMoreAdaptedBodyAvailable(); return; @@ -239,7 +238,7 @@ void ServerStateData::noteBodyProductionEnded(BodyPipe::Pointer bp) { -#if ICAP_CLIENT +#if USE_ADAPTATION if (adaptedBodySource == bp) { handleAdaptedBodyProductionEnded(); return; @@ -252,7 +251,7 @@ void ServerStateData::noteBodyProducerAborted(BodyPipe::Pointer bp) { -#if ICAP_CLIENT +#if USE_ADAPTATION if (adaptedBodySource == bp) { handleAdaptedBodyProducerAborted(); return; @@ -367,7 +366,7 @@ } } -// called by noteIcapAnswer(), HTTP server overwrites this +// called by noteAdaptationAnswer(), HTTP server overwrites this void ServerStateData::haveParsedReplyHeaders() { @@ -380,22 +379,22 @@ return request; } -#if ICAP_CLIENT +#if USE_ADAPTATION /* * Initiate an ICAP transaction. Return true on success. * Caller will handle error condition by generating a Squid error message * or take other action. */ bool -ServerStateData::startIcap(ICAPServiceRep::Pointer service, HttpRequest *cause) +ServerStateData::startAdaptation(Adaptation::ServicePointer service, HttpRequest *cause) { - debugs(11, 5, "ServerStateData::startIcap() called"); + debugs(11, 5, "ServerStateData::startAdaptation() called"); if (!service) { - debugs(11, 3, "ServerStateData::startIcap fails: lack of service"); + debugs(11, 3, "ServerStateData::startAdaptation fails: lack of service"); return false; } if (service->broken()) { - debugs(11, 3, "ServerStateData::startIcap fails: broken service"); + debugs(11, 3, "ServerStateData::startAdaptation fails: broken service"); return false; } @@ -414,15 +413,15 @@ virginBodyDestination->setBodySize(size); } - adaptedHeadSource = initiateIcap( - new ICAPModXactLauncher(this, vrep, cause, service)); + adaptedHeadSource = initiateAdaptation(service->makeXactLauncher( + this, vrep, cause)); return adaptedHeadSource != NULL; } // properly cleans up ICAP-related state // may be called multiple times -void ServerStateData::cleanIcap() { - debugs(11,5, HERE << "cleaning ICAP; ACL: " << icapAccessCheckPending); +void ServerStateData::cleanAdaptation() { + debugs(11,5, HERE << "cleaning ICAP; ACL: " << adaptationAccessCheckPending); if (virginBodyDestination != NULL) stopProducingFor(virginBodyDestination, false); @@ -432,13 +431,13 @@ if (adaptedBodySource != NULL) stopConsumingFrom(adaptedBodySource); - if (!icapAccessCheckPending) // we cannot cancel a pending callback - assert(doneWithIcap()); // make sure the two methods are in sync + if (!adaptationAccessCheckPending) // we cannot cancel a pending callback + assert(doneWithAdaptation()); // make sure the two methods are in sync } bool -ServerStateData::doneWithIcap() const { - return !icapAccessCheckPending && +ServerStateData::doneWithAdaptation() const { + return !adaptationAccessCheckPending && !virginBodyDestination && !adaptedHeadSource && !adaptedBodySource; } @@ -446,7 +445,7 @@ void ServerStateData::adaptVirginReplyBody(const char *data, ssize_t len) { - assert(startedIcap); + assert(startedAdaptation); if (!virginBodyDestination) { debugs(11,3, HERE << "ICAP does not want more virgin body"); @@ -504,17 +503,17 @@ { stopProducingFor(virginBodyDestination, false); - // do not force closeServer here in case we need to bypass IcapQueryAbort + // do not force closeServer here in case we need to bypass AdaptationQueryAbort - if (doneWithIcap()) // we may still be receiving adapted response - handleIcapCompleted(); + if (doneWithAdaptation()) // we may still be receiving adapted response + handleAdaptationCompleted(); } // received adapted response headers (body may follow) void -ServerStateData::noteIcapAnswer(HttpMsg *msg) +ServerStateData::noteAdaptationAnswer(HttpMsg *msg) { - clearIcap(adaptedHeadSource); // we do not expect more messages + clearAdaptation(adaptedHeadSource); // we do not expect more messages if (abortOnBadEntry("entry went bad while waiting for adapted headers")) return; @@ -532,17 +531,17 @@ assert(adaptedBodySource->setConsumerIfNotLate(this)); } else { // no body - if (doneWithIcap()) // we may still be sending virgin response - handleIcapCompleted(); + if (doneWithAdaptation()) // we may still be sending virgin response + handleAdaptationCompleted(); } } // will not receive adapted response headers (and, hence, body) void -ServerStateData::noteIcapQueryAbort(bool final) +ServerStateData::noteAdaptationQueryAbort(bool final) { - clearIcap(adaptedHeadSource); - handleIcapAborted(!final); + clearAdaptation(adaptedHeadSource); + handleAdaptationAborted(!final); } // more adapted response body is available @@ -574,22 +573,22 @@ if (abortOnBadEntry("entry went bad while waiting for adapted body eof")) return; - handleIcapCompleted(); + handleAdaptationCompleted(); } // premature end of the adapted response body void ServerStateData::handleAdaptedBodyProducerAborted() { stopConsumingFrom(adaptedBodySource); - handleIcapAborted(); + handleAdaptationAborted(); } -// common part of noteIcapAnswer and handleAdaptedBodyProductionEnded +// common part of noteAdaptationAnswer and handleAdaptedBodyProductionEnded void -ServerStateData::handleIcapCompleted() +ServerStateData::handleAdaptationCompleted() { - debugs(11,5, HERE << "handleIcapCompleted"); - cleanIcap(); + debugs(11,5, HERE << "handleAdaptationCompleted"); + cleanAdaptation(); // We stop reading origin response because we have no place to put it and // cannot use it. If some origin servers do not like that or if we want to @@ -604,11 +603,11 @@ } -// common part of noteIcap*Aborted and noteBodyConsumerAborted methods +// common part of noteAdaptation*Aborted and noteBodyConsumerAborted methods void -ServerStateData::handleIcapAborted(bool bypassable) +ServerStateData::handleAdaptationAborted(bool bypassable) { - debugs(11,5, HERE << "handleIcapAborted; bypassable: " << bypassable << + debugs(11,5, HERE << "handleAdaptationAborted; bypassable: " << bypassable << ", entry empty: " << entry->isEmpty()); if (abortOnBadEntry("entry went bad while ICAP aborted")) @@ -629,9 +628,9 @@ } void -ServerStateData::icapAclCheckDone(ICAPServiceRep::Pointer service) +ServerStateData::adaptationAclCheckDone(Adaptation::ServicePointer service) { - icapAccessCheckPending = false; + adaptationAccessCheckPending = false; if (abortOnBadEntry("entry went bad while waiting for ICAP ACL check")) return; @@ -642,11 +641,11 @@ sendBodyIsTooLargeError(); return; } - // TODO: Should we check received5CBodyTooLarge on the server-side as well? - - startedIcap = startIcap(service, originalRequest()); - - if (!startedIcap && (!service || service->bypass)) { + // TODO: Should we check receivedBodyTooLarge on the server-side as well? + + startedAdaptation = startAdaptation(service, originalRequest()); + + if (!startedAdaptation && (!service || service->cfg().bypass)) { // handle ICAP start failure when no service was selected // or where the selected service was optional setFinalReply(virginReply()); @@ -654,7 +653,7 @@ return; } - if (!startedIcap) { + if (!startedAdaptation) { // handle start failure for an essential ICAP service ErrorState *err = errorCon(ERR_ICAP_FAILURE, HTTP_INTERNAL_SERVER_ERROR, originalRequest()); @@ -668,10 +667,10 @@ } void -ServerStateData::icapAclCheckDoneWrapper(ICAPServiceRep::Pointer service, void *data) +ServerStateData::adaptationAclCheckDoneWrapper(Adaptation::ServicePointer service, void *data) { ServerStateData *state = (ServerStateData *)data; - state->icapAclCheckDone(service); + state->adaptationAclCheckDone(service); } #endif @@ -690,18 +689,14 @@ void ServerStateData::adaptOrFinalizeReply() { -#if ICAP_CLIENT - - if (TheICAPConfig.onoff) { - ICAPAccessCheck *icap_access_check = - new ICAPAccessCheck(ICAP::methodRespmod, ICAP::pointPreCache, - request, virginReply(), icapAclCheckDoneWrapper, this); - - icapAccessCheckPending = true; - icap_access_check->check(); // will eventually delete self +#if USE_ADAPTATION + // TODO: merge with client side and return void to hide the on/off logic? + // The callback can be called with a NULL service if adaptation is off. + adaptationAccessCheckPending = Adaptation::AccessCheck::Start( + Adaptation::methodRespmod, Adaptation::pointPreCache, + request, virginReply(), adaptationAclCheckDoneWrapper, this); + if (adaptationAccessCheckPending) return; - } - #endif setFinalReply(virginReply()); @@ -710,9 +705,9 @@ void ServerStateData::addVirginReplyBody(const char *data, ssize_t len) { -#if ICAP_CLIENT - assert(!icapAccessCheckPending); // or would need to buffer while waiting - if (startedIcap) { +#if USE_ADAPTATION + assert(!adaptationAccessCheckPending); // or would need to buffer while waiting + if (startedAdaptation) { adaptVirginReplyBody(data, len); return; } @@ -732,7 +727,7 @@ size_t ServerStateData::replyBodySpace(size_t space) { -#if ICAP_CLIENT +#if USE_ADAPTATION if (responseBodyBuffer) { return 0; // Stop reading if already overflowed waiting for ICAP to catch up } @@ -750,13 +745,14 @@ * The BodyPipe will call our noteMoreBodySpaceAvailable() method * when it has free space again. */ - size_t icap_space = virginBodyDestination->buf().potentialSpaceSize(); - - debugs(11,9, "ServerStateData may read up to min(" << icap_space << - ", " << space << ") bytes"); - - if (icap_space < space) - space = icap_space; + size_t adaptation_space = + virginBodyDestination->buf().potentialSpaceSize(); + + debugs(11,9, "ServerStateData may read up to min(" << + adaptation_space << ", " << space << ") bytes"); + + if (adaptation_space < space) + space = adaptation_space; } #endif === modified file 'src/Server.h' --- src/Server.h 2008-02-13 06:55:26 +0000 +++ src/Server.h 2008-03-30 18:20:14 +0000 @@ -52,16 +52,14 @@ #include "ICAP/AsyncJob.h" #include "CommCalls.h" -#if ICAP_CLIENT -#include "ICAP/ICAPServiceRep.h" -#include "ICAP/ICAPInitiator.h" - -class ICAPAccessCheck; +#if USE_ADAPTATION +#include "adaptation/forward.h" +#include "adaptation/Initiator.h" #endif class ServerStateData: -#if ICAP_CLIENT - public ICAPInitiator, +#if USE_ADAPTATION + public Adaptation::Initiator, public BodyProducer, #endif public BodyConsumer @@ -90,13 +88,13 @@ // a hack to reach HttpStateData::orignal_request virtual HttpRequest *originalRequest(); -#if ICAP_CLIENT - void icapAclCheckDone(ICAPServiceRep::Pointer); - static void icapAclCheckDoneWrapper(ICAPServiceRep::Pointer service, void *data); +#if USE_ADAPTATION + void adaptationAclCheckDone(Adaptation::ServicePointer service); + static void adaptationAclCheckDoneWrapper(Adaptation::ServicePointer service, void *data); // ICAPInitiator: start an ICAP transaction and receive adapted headers. - virtual void noteIcapAnswer(HttpMsg *message); - virtual void noteIcapQueryAbort(bool final); + virtual void noteAdaptationAnswer(HttpMsg *message); + virtual void noteAdaptationQueryAbort(bool final); // BodyProducer: provide virgin response body to ICAP. virtual void noteMoreBodySpaceAvailable(BodyPipe::Pointer ); @@ -106,8 +104,8 @@ //AsyncJob virtual methods virtual bool doneAll() const { return -#if ICAP_CLIENT - ICAPInitiator::doneAll() && +#if USE_ADAPTATION + Adaptation::Initiator::doneAll() && BodyProducer::doneAll() && #endif BodyConsumer::doneAll() && false;} @@ -142,19 +140,19 @@ // Entry-dependent callbacks use this check to quit if the entry went bad bool abortOnBadEntry(const char *abortReason); -#if ICAP_CLIENT - bool startIcap(ICAPServiceRep::Pointer, HttpRequest *cause); +#if USE_ADAPTATION + bool startAdaptation(Adaptation::ServicePointer service, HttpRequest *cause); void adaptVirginReplyBody(const char *buf, ssize_t len); - void cleanIcap(); - virtual bool doneWithIcap() const; // did we end ICAP communication? + void cleanAdaptation(); + virtual bool doneWithAdaptation() const; // did we end ICAP communication? // BodyConsumer for ICAP: consume adapted response body. void handleMoreAdaptedBodyAvailable(); void handleAdaptedBodyProductionEnded(); void handleAdaptedBodyProducerAborted(); - void handleIcapCompleted(); - void handleIcapAborted(bool bypassable = false); + void handleAdaptationCompleted(); + void handleAdaptationAborted(bool bypassable = false); #endif protected: @@ -184,13 +182,13 @@ BodyPipe::Pointer requestBodySource; // to consume request body AsyncCall::Pointer requestSender; // set if we are expecting comm_write to call us back -#if ICAP_CLIENT +#if USE_ADAPTATION BodyPipe::Pointer virginBodyDestination; // to provide virgin response body - ICAPInitiate *adaptedHeadSource; // to get adapted response headers + Adaptation::Initiate *adaptedHeadSource; // to get adapted response headers BodyPipe::Pointer adaptedBodySource; // to consume adated response body - bool icapAccessCheckPending; - bool startedIcap; + bool adaptationAccessCheckPending; + bool startedAdaptation; #endif private: === added directory 'src/adaptation' === added file 'src/adaptation/AccessCheck.cc' --- src/adaptation/AccessCheck.cc 1970-01-01 00:00:00 +0000 +++ src/adaptation/AccessCheck.cc 2008-04-04 17:14:29 +0000 @@ -0,0 +1,252 @@ +#include "squid.h" +#include "structs.h" + +#include "ConfigParser.h" +#include "ACL.h" +#include "HttpRequest.h" +#include "HttpReply.h" +#include "ACLChecklist.h" +#include "adaptation/Service.h" +#include "adaptation/ServiceGroups.h" +#include "adaptation/AccessRule.h" +#include "adaptation/Config.h" +#include "adaptation/AccessCheck.h" + + +cbdata_type Adaptation::AccessCheck::CBDATA_AccessCheck = CBDATA_UNKNOWN; + +bool +Adaptation::AccessCheck::Start(Method method, VectPoint vp, + HttpRequest *req, HttpReply *rep, AccessCheckCallback *cb, void *cbdata) { + + if (Config::Enabled) { + // the new check will call the callback and delete self, eventually + AccessCheck *check = new AccessCheck(method, vp, req, rep, cb, cbdata); + check->check(); + return true; + } + + debugs(83, 3, HERE << "adaptation off, skipping"); + return false; +} + +Adaptation::AccessCheck::AccessCheck(Method aMethod, + VectPoint aPoint, + HttpRequest *aReq, + HttpReply *aRep, + AccessCheckCallback *aCallback, + void *aCallbackData): AsyncJob("AccessCheck"), done(FALSE) +{ + // TODO: assign these at creation time + + method = aMethod; + point = aPoint; + + req = HTTPMSGLOCK(aReq); + rep = aRep ? HTTPMSGLOCK(aRep) : NULL; + + callback = aCallback; + + callback_data = cbdataReference(aCallbackData); + + acl_checklist = NULL; + + debugs(93, 5, "AccessCheck constructed for " << methodStr(method) << " " << vectPointStr(point)); +} + +Adaptation::AccessCheck::~AccessCheck() +{ + HTTPMSGUNLOCK(req); + HTTPMSGUNLOCK(rep); + if (callback_data) + cbdataReferenceDone(callback_data); +} + +/* + * Walk the access rules list and find all classes that have at least + * one service with matching method and vectoring point. + */ +void +Adaptation::AccessCheck::check() +{ + debugs(93, 4, "Adaptation::AccessCheck::check"); + + typedef AccessRules::iterator ARI; + for (ARI i = AllRules().begin(); i != AllRules().end(); ++i) { + + /* + * We only find the first matching service because we only need + * one matching service to justify ACL-checking a class. We might + * use other services belonging to the class if the first service + * turns out to be unusable for some reason. + */ + AccessRule *r = *i; + ServicePointer service = findBestService(*r, false); + if (service != NULL) { + debugs(93, 5, "Adaptation::AccessCheck::check: rule '" << r->id << "' has candidate service '" << service->cfg().key << "'"); + candidates += r->id; + } + } + + checkCandidates(); +} + +// XXX: Here and everywhere we call FindRule(topCandidate()): +// Once we identified the candidate, we should not just ignore it +// if reconfigure changes rules. We should either lock the rule to +// prevent reconfigure from stealing it or restart the check with +// new rules. Throwing an exception may also be appropriate. +void +Adaptation::AccessCheck::checkCandidates() +{ + debugs(93, 3, "Adaptation::AccessCheck checks " << candidates.size()); + + while (!candidates.empty()) { + if (AccessRule *r = FindRule(topCandidate())) { + // XXX: we do not have access to conn->rfc931 here. + acl_checklist = aclChecklistCreate(r->acl, req, dash_str); + acl_checklist->nonBlockingCheck(AccessCheckCallbackWrapper, this); + return; + } + + candidates.shift(); // the rule apparently went away (reconfigure) + } + + // when there are no canidates, fake answer 1 + debugs(93, 3, "Adaptation::AccessCheck::check: NO candidates left"); + noteAnswer(1); +} + +void +Adaptation::AccessCheck::AccessCheckCallbackWrapper(int answer, void *data) +{ + debugs(93, 8, "AccessCheckCallbackWrapper: answer=" << answer); + AccessCheck *ac = (AccessCheck*)data; + ac->noteAnswer(answer); +} + +void +Adaptation::AccessCheck::noteAnswer(int answer) +{ + debugs(93, 5, HERE << "AccessCheck::noteAnswer " << answer); + if (candidates.size()) + debugs(93, 5, HERE << "was checking " << topCandidate()); + + if (!answer) { + checkCandidates(); + return; + } + + /* + * We use an event here to break deep function call sequences + */ + // XXX: use AsyncCall for callback and remove + CallJobHere(93, 5, this, Adaptation::AccessCheck::do_callback); +} + +void +Adaptation::AccessCheck::do_callback() +{ + debugs(93, 3, "Adaptation::AccessCheck::do_callback"); + + if (candidates.size()) + debugs(93, 3, HERE << "was checking rule" << topCandidate()); + + void *validated_cbdata; + if (!cbdataReferenceValidDone(callback_data, &validated_cbdata)) { + debugs(93,3,HERE << "do_callback: callback_data became invalid, skipping"); + return; + } + + ServicePointer service = NULL; + if (candidates.size()) { + if (AccessRule *r = FindRule(topCandidate())) { + service = findBestService(*r, true); + if (service != NULL) + debugs(93,3,HERE << "do_callback: with service " << service->cfg().uri); + else + debugs(93,3,HERE << "do_callback: no service for rule" << r->id); + } else { + debugs(93,3,HERE << "do_callback: no rule" << topCandidate()); + } + candidates.shift(); // done with topCandidate() + } else { + debugs(93,3,HERE << "do_callback: no candidate rules"); + } + + callback(service, validated_cbdata); + done = TRUE; +} + +Adaptation::ServicePointer +Adaptation::AccessCheck::findBestService(AccessRule &r, bool preferUp) { + + const char *what = preferUp ? "up " : ""; + debugs(93,7,HERE << "looking for the first matching " << + what << "service in group " << r.groupId); + + ServicePointer secondBest; + + ServiceGroup *g = FindGroup(r.groupId); + + if (!g) { + debugs(93,5,HERE << "lost " << r.groupId << " group in rule" << r.id); + return ServicePointer(); + } + + ServiceGroup::Loop loop(g->initialServices()); + typedef ServiceGroup::iterator SGI; + for (SGI i = loop.begin; i != loop.end; ++i) { + + ServicePointer service = FindService(*i); + + if (!service) + continue; + + if (method != service->cfg().method) + continue; + + if (point != service->cfg().point) + continue; + + // sending a message to a broken service is likely to cause errors + if (service->cfg().bypass && service->broken()) + continue; + + if (service->up()) { + // sending a message to a service that does not want it is useless + // note that we cannot check wantsUrl for service that is not "up" + // note that even essential services are skipped on unwanted URLs! + if (!service->wantsUrl(req->urlpath)) + continue; + } else { + if (!secondBest) + secondBest = service; + if (preferUp) { + // the caller asked for an "up" service and we can bypass this one + if (service->cfg().bypass) + continue; + debugs(93,5,HERE << "cannot skip an essential down service"); + what = "down-but-essential "; + } + } + + debugs(93,5,HERE << "found first matching " << + what << "service for " << r.groupId << " group in rule" << r.id << + ": " << service->cfg().key); + + return service; + } + + if (secondBest != NULL) { + what = "down "; + debugs(93,5,HERE << "found first matching " << + what << "service for " << r.groupId << " group in rule" << r.id << + ": " << secondBest->cfg().key); + return secondBest; + } + + debugs(93,5,HERE << "found no matching " << + what << "services for " << r.groupId << " group in rule" << r.id); + return ServicePointer(); +} === added file 'src/adaptation/AccessCheck.h' --- src/adaptation/AccessCheck.h 1970-01-01 00:00:00 +0000 +++ src/adaptation/AccessCheck.h 2008-04-04 16:26:01 +0000 @@ -0,0 +1,66 @@ +#ifndef SQUID_ADAPTATION__ACCESS_CHECK_H +#define SQUID_ADAPTATION__ACCESS_CHECK_H + +#include "ICAP/AsyncJob.h" +#include "adaptation/Elements.h" +#include "adaptation/forward.h" + +class HttpRequest; +class HttpReply; + +namespace Adaptation { + +class AccessRule; + +// checks adaptation_access rules to find a matching adaptation service +class AccessCheck: public virtual AsyncJob +{ +public: + typedef void AccessCheckCallback(ServicePointer match, void *data); + + // use this to start async ACL checks; returns true if started + static bool Start(Method method, VectPoint vp, HttpRequest *req, + HttpReply *rep, AccessCheckCallback *cb, void *cbdata); + +protected: + // use Start to start adaptation checks + AccessCheck(Method, VectPoint, HttpRequest *, HttpReply *, AccessCheckCallback *, void *); + ~AccessCheck(); + +private: + Method method; + VectPoint point; + HttpRequest *req; + HttpReply *rep; + AccessCheckCallback *callback; + void *callback_data; + ACLChecklist *acl_checklist; + + typedef int Candidate; + typedef Vector Candidates; + Candidates candidates; + Candidate topCandidate() { return *candidates.begin(); } + + void do_callback(); + ServicePointer findBestService(AccessRule &r, bool preferUp); + bool done; + +public: + void check(); + void checkCandidates(); + static void AccessCheckCallbackWrapper(int, void*); +#if 0 + static EVH AccessCheckCallbackEvent; +#endif + void noteAnswer(int answer); + +//AsyncJob virtual methods + virtual bool doneAll() const { return AsyncJob::doneAll() && done;} + +private: + CBDATA_CLASS2(AccessCheck); +}; + +} // namespace Adaptation + +#endif /* SQUID_ADAPTATION__ACCESS_CHECK_H */ === added file 'src/adaptation/AccessRule.cc' --- src/adaptation/AccessRule.cc 1970-01-01 00:00:00 +0000 +++ src/adaptation/AccessRule.cc 2008-04-03 23:11:40 +0000 @@ -0,0 +1,73 @@ +#include "squid.h" +#include "structs.h" + +#include "ConfigParser.h" +#include "ACL.h" +#include "adaptation/AccessRule.h" +#include "adaptation/Service.h" +#include "adaptation/ServiceGroups.h" + + +int Adaptation::AccessRule::LastId = 0; + +Adaptation::AccessRule::AccessRule(): id(++LastId), acl(NULL) +{ +} + +Adaptation::AccessRule::~AccessRule() +{ + // XXX: leaking acls here? +} + +void +Adaptation::AccessRule::parse(ConfigParser &parser) +{ + ConfigParser::ParseString(&groupId); + aclParseAccessLine(parser, &acl); +} + +void +Adaptation::AccessRule::finalize() +{ + if (!group()) { // no explicit group + debugs(93,7, HERE << "no service group: " << groupId); + // try to add a one-service group + if (FindService(groupId) != NULL) { + ServiceGroup *g = new SingleService(groupId); + g->finalize(); // explicit groups were finalized before rules + AllGroups().push_back(g); + } + } + + if (!group()) { + debugs(93,0, "ERROR: Unknown adaptation service or group name: '" << + groupId << "'"); // TODO: fail on failures + } +} + +Adaptation::ServiceGroup * +Adaptation::AccessRule::group() +{ + return FindGroup(groupId); +} + + +Adaptation::AccessRules & +Adaptation::AllRules() +{ + static AccessRules TheRules; + return TheRules; +} + +// TODO: make AccessRules::find work +Adaptation::AccessRule * +Adaptation::FindRule(const AccessRule::Id &id) +{ + typedef AccessRules::iterator ARI; + for (ARI i = AllRules().begin(); i != AllRules().end(); ++i) { + if ((*i)->id == id) + return *i; + } + + return NULL; +} === added file 'src/adaptation/AccessRule.h' --- src/adaptation/AccessRule.h 1970-01-01 00:00:00 +0000 +++ src/adaptation/AccessRule.h 2008-04-05 04:40:38 +0000 @@ -0,0 +1,41 @@ +#ifndef SQUID_ADAPTATION__ACCESS_RULE_H +#define SQUID_ADAPTATION__ACCESS_RULE_H + +#include "SquidString.h" +#include "adaptation/forward.h" + +class acl_access; +class ConfigParser; + +namespace Adaptation { + +// manages adaptation_access configuration by associating an acl with +// an adaptation service group +class AccessRule { +public: + AccessRule(); + ~AccessRule(); + + void parse(ConfigParser &parser); + void finalize(); + + // service group consisting of one or more services + ServiceGroup *group(); + +public: + typedef int Id; + const Id id; + String groupId; + acl_access *acl; + +private: + static Id LastId; +}; + +typedef Vector AccessRules; +extern AccessRules &AllRules(); +extern AccessRule *FindRule(const AccessRule::Id &id); + +} // namespace Adaptation + +#endif /* SQUID_ADAPTATION__ACCESS_RULE_H */ === added file 'src/adaptation/Config.cc' --- src/adaptation/Config.cc 1970-01-01 00:00:00 +0000 +++ src/adaptation/Config.cc 2008-04-04 05:31:40 +0000 @@ -0,0 +1,189 @@ + +/* + * $Id: ICAPConfig.cc,v 1.21 2008/02/12 23:12:45 rousskov Exp $ + * + * SQUID Web Proxy Cache http://www.squid-cache.org/ + * ---------------------------------------------------------- + * + * Squid is the result of efforts by numerous individuals from + * the Internet community; see the CONTRIBUTORS file for full + * details. Many organizations have provided support for Squid's + * development; see the SPONSORS file for full details. Squid is + * Copyrighted (C) 2001 by the Regents of the University of + * California; see the COPYRIGHT file for full details. Squid + * incorporates software developed and/or copyrighted by other + * sources; see the CREDITS file for full details. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. + * + */ + +#include "squid.h" +#include "structs.h" + +#include "ConfigParser.h" +#include "ACL.h" +#include "Store.h" +#include "Array.h" // really Vector +#include "adaptation/Config.h" +#include "adaptation/Service.h" +#include "adaptation/AccessRule.h" +#include "adaptation/ServiceGroups.h" + + +bool Adaptation::Config::Enabled = false; + +void +Adaptation::Config::parseService() +{ + ServiceConfig *cfg = new ServiceConfig; + cfg->parse(); + serviceConfigs.push_back(cfg); +} + +void +Adaptation::Config::freeService() +{ + while (!serviceConfigs.empty()) { + delete serviceConfigs.back(); + serviceConfigs.pop_back(); + } +} + +void +Adaptation::Config::dumpService(StoreEntry *entry, const char *name) const +{ + typedef Services::iterator SCI; + for (SCI i = AllServices().begin(); i != AllServices().end(); ++i) { + const ServiceConfig &cfg = (*i)->cfg(); + storeAppendPrintf(entry, "%s %s_%s %s %d %s\n", name, cfg.key.buf(), + cfg.methodStr(), cfg.vectPointStr(), cfg.bypass, cfg.uri.buf()); + } +} + +void +Adaptation::Config::finalize() +{ + // create service reps from service configs + typedef Vector::const_iterator VISCI; + const Vector &configs = serviceConfigs; + debugs(93,3, "Found " << configs.size() << " service configs."); + for (VISCI i = configs.begin(); i != configs.end(); ++i) { + ServicePointer s = createService(**i); + if (s != NULL) + AllServices().push_back(s); + } + + debugs(93,3, "Created " << configs.size() << + " message adaptation services."); +} + +// poor man for_each +template +static void +FinalizeEach(Collection &collection, const char *label) +{ + typedef typename Collection::iterator CI; + for (CI i = collection.begin(); i != collection.end(); ++i) + (*i)->finalize(); + + debugs(93,2, "Initialized " << collection.size() << ' ' << label); +} + +void +Adaptation::Config::Finalize(bool enabled) +{ + Enabled = enabled; + debugs(93,1, "Adaptation support is " << (Enabled ? "on" : "off.")); + + FinalizeEach(AllServices(), "message adaptation services"); + FinalizeEach(AllGroups(), "message adaptation service groups"); + FinalizeEach(AllRules(), "message adaptation access rules"); +} + +void +Adaptation::Config::ParseServiceSet() +{ + ServiceSet *g = new ServiceSet(); + g->parse(); + AllGroups().push_back(g); +} + +void +Adaptation::Config::FreeServiceSet() +{ + while (!AllGroups().empty()) { + delete AllGroups().back(); + AllGroups().pop_back(); + } +} + +void +Adaptation::Config::DumpServiceSet(StoreEntry *entry, const char *name) +{ + typedef Groups::iterator GI; + for (GI i = AllGroups().begin(); i != AllGroups().end(); ++i) + storeAppendPrintf(entry, "%s %s\n", name, (*i)->id.buf()); +} + +void +Adaptation::Config::ParseAccess(ConfigParser &parser) +{ + AccessRule *r = new AccessRule; + r->parse(parser); + AllRules().push_back(r); +} + +void +Adaptation::Config::FreeAccess() +{ + while (!AllRules().empty()) { + delete AllRules().back(); + AllRules().pop_back(); + } +} + +void +Adaptation::Config::DumpAccess(StoreEntry *entry, const char *name) +{ + LOCAL_ARRAY(char, nom, 64); + + typedef AccessRules::iterator CI; + for (CI i = AllRules().begin(); i != AllRules().end(); ++i) { + snprintf(nom, 64, "%s %s", name, (*i)->groupId.buf()); + dump_acl_access(entry, nom, (*i)->acl); + } +} + +Adaptation::Config::Config() +{ + // XXX: should we init members? +} + +// XXX: this is called for ICAP and eCAP configs, but deals mostly +// with global arrays shared by those individual configs +Adaptation::Config::~Config() +{ + FreeAccess(); + FreeServiceSet(); + + // invalidate each service so that it can be deleted when refcount=0 + while (!AllServices().empty()) { + AllServices().back()->invalidate(); + AllServices().pop_back(); + } + + freeService(); +} === added file 'src/adaptation/Config.h' --- src/adaptation/Config.h 1970-01-01 00:00:00 +0000 +++ src/adaptation/Config.h 2008-04-04 05:31:40 +0000 @@ -0,0 +1,71 @@ +#ifndef SQUID_ADAPTATION__CONFIG_H +#define SQUID_ADAPTATION__CONFIG_H + +#include "event.h" +#include "AsyncCall.h" +#include "adaptation/Elements.h" + +class acl_access; +class ConfigParser; + +template +class RefCount; + +namespace Adaptation { + +class Service; +class ServiceConfig; +class Class; + +typedef RefCount ServicePointer; + +class ServiceGroup; +class AccessRule; + +class Config +{ +public: + static void Finalize(bool enable); + + static void ParseServiceSet(void); + static void FreeServiceSet(void); + static void DumpServiceSet(StoreEntry *, const char *); + + static void ParseAccess(ConfigParser &parser); + static void FreeAccess(void); + static void DumpAccess(StoreEntry *, const char *); + + friend class AccessCheck; + +public: + static bool Enabled; // true if at least one adaptation mechanism is + + int onoff; + int send_client_ip; + int send_client_username; + int service_failure_limit; + int service_revival_delay; + + Vector serviceConfigs; + + Config(); + virtual ~Config(); + + void parseService(void); + void freeService(void); + void dumpService(StoreEntry *, const char *) const; + ServicePointer findService(const String&); + Class * findClass(const String& key); + + void finalize(); + +private: + Config(const Config &); // unsupported + Config &operator =(const Config &); // unsupported + + virtual ServicePointer createService(const ServiceConfig &cfg) = 0; +}; + +} // namespace Adaptation + +#endif /* SQUID_ADAPTATION__CONFIG_H */ === added file 'src/adaptation/Elements.cc' --- src/adaptation/Elements.cc 1970-01-01 00:00:00 +0000 +++ src/adaptation/Elements.cc 2008-03-24 04:40:39 +0000 @@ -0,0 +1,51 @@ +#include "squid.h" +#include "adaptation/Elements.h" + +const char *Adaptation::crlf = "\r\n"; + +const char * +Adaptation::methodStr(Adaptation::Method method) +{ + switch(method) { + + case Adaptation::methodReqmod: + return "REQMOD"; + break; + + case Adaptation::methodRespmod: + return "RESPMOD"; + break; + + case Adaptation::methodOptions: + return "OPTIONS"; + break; + + default: + break; + } + + return "NONE"; +} + + +const char * +Adaptation::vectPointStr(Adaptation::VectPoint point) +{ + switch(point) { + + case Adaptation::pointPreCache: + return "PRECACHE"; + break; + + case Adaptation::pointPostCache: + return "POSTCACHE"; + break; + + default: + break; + } + + return "NONE"; +} + + === added file 'src/adaptation/Elements.h' --- src/adaptation/Elements.h 1970-01-01 00:00:00 +0000 +++ src/adaptation/Elements.h 2008-03-24 04:40:39 +0000 @@ -0,0 +1,18 @@ +#ifndef SQUID_ADAPTATION__ELEMENTS_H +#define SQUID_ADAPTATION__ELEMENTS_H + +// widely used adaptation primitives + +namespace Adaptation +{ + +typedef enum { methodNone, methodReqmod, methodRespmod, methodOptions } Method; +typedef enum { pointNone, pointPreCache, pointPostCache } VectPoint; + +extern const char *crlf; +extern const char *methodStr(Method); // TODO: make into a stream operator? +extern const char *vectPointStr(VectPoint); // TODO: make into a stream op? + +} // namespace Adaptation + +#endif /* SQUID_ADAPTATION_ELEMENTS_H */ === renamed file 'src/ICAP/ICAPInitiate.cc' => 'src/adaptation/Initiate.cc' --- src/ICAP/ICAPInitiate.cc 2008-02-13 06:12:45 +0000 +++ src/adaptation/Initiate.cc 2008-04-05 05:16:03 +0000 @@ -4,41 +4,46 @@ #include "squid.h" #include "HttpMsg.h" -#include "ICAPInitiator.h" -#include "ICAPInitiate.h" - -// ICAPInitiator::noteIcapAnswer Dialer locks/unlocks the message in transit +#include "adaptation/Service.h" +#include "adaptation/Initiator.h" +#include "adaptation/Initiate.h" + +namespace Adaptation { + +// AdaptInitiator::noteAdaptionAnswer Dialer locks/unlocks the message in transit // TODO: replace HTTPMSGLOCK with general RefCounting and delete this class -class IcapAnswerDialer: public UnaryMemFunT +class AnswerDialer: public UnaryMemFunT { public: - typedef UnaryMemFunT Parent; + typedef UnaryMemFunT Parent; - IcapAnswerDialer(ICAPInitiator *obj, Parent::Method meth, HttpMsg *msg): + AnswerDialer(Initiator *obj, Parent::Method meth, HttpMsg *msg): Parent(obj, meth, msg) { HTTPMSGLOCK(arg1); } - IcapAnswerDialer(const IcapAnswerDialer &d): + AnswerDialer(const AnswerDialer &d): Parent(d) { HTTPMSGLOCK(arg1); } - virtual ~IcapAnswerDialer() { HTTPMSGUNLOCK(arg1); } + virtual ~AnswerDialer() { HTTPMSGUNLOCK(arg1); } }; - -/* ICAPInitiate */ - -ICAPInitiate::ICAPInitiate(const char *aTypeName, - ICAPInitiator *anInitiator, ICAPServiceRep::Pointer &aService): +} // namespace Adaptation + + +/* Initiate */ + +Adaptation::Initiate::Initiate(const char *aTypeName, + Initiator *anInitiator, ServicePointer aService): AsyncJob(aTypeName), theInitiator(anInitiator), theService(aService) { assert(theService != NULL); assert(theInitiator); } -ICAPInitiate::~ICAPInitiate() +Adaptation::Initiate::~Initiate() { assert(!theInitiator); } // internal cleanup -void ICAPInitiate::swanSong() +void Adaptation::Initiate::swanSong() { debugs(93, 5, HERE << "swan sings" << status()); @@ -50,72 +55,90 @@ debugs(93, 5, HERE << "swan sang" << status()); } -void ICAPInitiate::clearInitiator() +void Adaptation::Initiate::clearInitiator() { if (theInitiator) theInitiator.clear(); } -void ICAPInitiate::sendAnswer(HttpMsg *msg) +void Adaptation::Initiate::sendAnswer(HttpMsg *msg) { assert(msg); - CallJob(93, 5, __FILE__, __LINE__, "ICAPInitiator::noteIcapAnswer", - IcapAnswerDialer(theInitiator.ptr, &ICAPInitiator::noteIcapAnswer, msg)); + if (theInitiator.isThere()) { + CallJob(93, 5, __FILE__, __LINE__, "Initiator::noteAdaptAnswer", + AnswerDialer(theInitiator.ptr(), &Initiator::noteAdaptationAnswer, msg)); + } clearInitiator(); } -void ICAPInitiate::tellQueryAborted(bool final) +void Adaptation::Initiate::tellQueryAborted(bool final) { - CallJobHere1(93, 5, theInitiator.ptr, ICAPInitiator::noteIcapQueryAbort, final); + if (theInitiator.isThere()) { + CallJobHere1(93, 5, theInitiator.ptr(), + Initiator::noteAdaptationQueryAbort, final); + } clearInitiator(); } -ICAPServiceRep &ICAPInitiate::service() +Adaptation::Service & +Adaptation::Initiate::service() { assert(theService != NULL); return *theService; } -const char *ICAPInitiate::status() const { +const char *Adaptation::Initiate::status() const { return ""; // for now } -/* ICAPInitiatorHolder */ +/* InitiatorHolder */ -ICAPInitiatorHolder::ICAPInitiatorHolder(ICAPInitiator *anInitiator): - ptr(0), cbdata(0) +Adaptation::InitiatorHolder::InitiatorHolder(Initiator *anInitiator): + prime(0), cbdata(0) { if (anInitiator) { cbdata = cbdataReference(anInitiator->toCbdata()); - ptr = anInitiator; + prime = anInitiator; } } -ICAPInitiatorHolder::ICAPInitiatorHolder(const ICAPInitiatorHolder &anInitiator): - ptr(0), cbdata(0) +Adaptation::InitiatorHolder::InitiatorHolder(const InitiatorHolder &anInitiator): + prime(0), cbdata(0) { if (anInitiator != NULL && cbdataReferenceValid(anInitiator.cbdata)) { cbdata = cbdataReference(anInitiator.cbdata); - ptr = anInitiator.ptr; + prime = anInitiator.prime; } } -ICAPInitiatorHolder::~ICAPInitiatorHolder() +Adaptation::InitiatorHolder::~InitiatorHolder() { clear(); } -void ICAPInitiatorHolder::clear() { - if (ptr) { - ptr = NULL; +void Adaptation::InitiatorHolder::clear() { + if (prime) { + prime = NULL; cbdataReferenceDone(cbdata); } } +Adaptation::Initiator *Adaptation::InitiatorHolder::ptr() +{ + assert(isThere()); + return prime; +} + +bool +Adaptation::InitiatorHolder::isThere() { + return prime && cbdataReferenceValid(cbdata); +} + // should not be used -ICAPInitiatorHolder &ICAPInitiatorHolder::operator =(const ICAPInitiatorHolder &anInitiator) +Adaptation::InitiatorHolder & +Adaptation::InitiatorHolder::operator =(const InitiatorHolder &anInitiator) { assert(false); return *this; === renamed file 'src/ICAP/ICAPInitiate.h' => 'src/adaptation/Initiate.h' --- src/ICAP/ICAPInitiate.h 2008-02-13 06:12:45 +0000 +++ src/adaptation/Initiate.h 2008-04-03 23:20:33 +0000 @@ -1,95 +1,66 @@ - -/* - * $Id: ICAPInitiate.h,v 1.2 2008/02/12 23:12:45 rousskov Exp $ - * - * - * SQUID Web Proxy Cache http://www.squid-cache.org/ - * ---------------------------------------------------------- - * - * Squid is the result of efforts by numerous individuals from - * the Internet community; see the CONTRIBUTORS file for full - * details. Many organizations have provided support for Squid's - * development; see the SPONSORS file for full details. Squid is - * Copyrighted (C) 2001 by the Regents of the University of - * California; see the COPYRIGHT file for full details. Squid - * incorporates software developed and/or copyrighted by other - * sources; see the CREDITS file for full details. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. - * - */ - -#ifndef SQUID_ICAPINITIATE_H -#define SQUID_ICAPINITIATE_H - -#include "comm.h" -#include "MemBuf.h" -#include "ICAPServiceRep.h" +#ifndef SQUID_ADAPTATION__INITIATE_H +#define SQUID_ADAPTATION__INITIATE_H + #include "AsyncCall.h" +#include "ICAP/AsyncJob.h" +#include "adaptation/forward.h" class HttpMsg; -class ICAPInitiator; + +namespace Adaptation { /* Initiator holder associtates an initiator with its cbdata. It is used as - * a temporary hack to make cbdata work with multiple inheritance */ -// TODO: since ICAPInitiator is now an AsyncJob, we do not need this class. -class ICAPInitiatorHolder { + * a temporary hack to make cbdata work with multiple inheritance. We need + * this hack because we cannot know whether the initiator pointer is still + * valid without dereferencing it to call toCbdata() + * TODO: JobDialer uses the same trick. Factor out or move this code. */ +class InitiatorHolder { public: - ICAPInitiatorHolder(ICAPInitiator *anInitiator); - ICAPInitiatorHolder(const ICAPInitiatorHolder &anInitiator); - ~ICAPInitiatorHolder(); - + InitiatorHolder(Initiator *anInitiator); + InitiatorHolder(const InitiatorHolder &anInitiator); + ~InitiatorHolder(); void clear(); // to make comparison with NULL possible - operator void*() { return ptr; } - bool operator == (void *) const { return ptr == NULL; } - bool operator != (void *) const { return ptr != NULL; } - bool operator !() const { return !ptr; } - - ICAPInitiator *ptr; + operator void*() { return prime; } + bool operator == (void *) const { return prime == NULL; } + bool operator != (void *) const { return prime != NULL; } + bool operator !() const { return !prime; } + + bool isThere(); // we have a valid initiator pointer + Initiator *ptr(); // asserts isThere() + +private: + InitiatorHolder &operator =(const InitiatorHolder &anInitiator); + + Initiator *prime; void *cbdata; - -private: - ICAPInitiatorHolder &operator =(const ICAPInitiatorHolder &anInitiator); }; /* - * The ICAP Initiate is a common base for ICAP queries or transactions - * initiated by an ICAPInitiator. This interface exists to allow an ICAP + * The Initiate is a common base for queries or transactions + * initiated by an Initiator. This interface exists to allow an * initiator to signal its "initiatees" that it is aborting and no longer * expecting an answer. The class is also handy for implementing common * initiate actions such as maintaining and notifying the initiator. * - * ICAPInitiate implementations must cbdata-protect themselves. + * Initiate implementations must cbdata-protect themselves. * - * This class could have been named ICAPInitiatee. + * This class could have been named Initiatee. */ -class ICAPInitiate: virtual public AsyncJob +class Initiate: virtual public AsyncJob { public: - ICAPInitiate(const char *aTypeName, ICAPInitiator *anInitiator, ICAPServiceRep::Pointer &aService); - virtual ~ICAPInitiate(); + Initiate(const char *aTypeName, Initiator *anInitiator, ServicePointer aService); + virtual ~Initiate(); // communication with the initiator virtual void noteInitiatorAborted() = 0; protected: - ICAPServiceRep &service(); + Service &service(); void sendAnswer(HttpMsg *msg); // send to the initiator void tellQueryAborted(bool final); // tell initiator @@ -99,8 +70,10 @@ virtual const char *status() const; // for debugging - ICAPInitiatorHolder theInitiator; - ICAPServiceRep::Pointer theService; + InitiatorHolder theInitiator; + ServicePointer theService; }; -#endif /* SQUID_ICAPINITIATE_H */ +} // namespace Adaptation + +#endif /* SQUID_ADAPTATION__INITIATE_H */ === renamed file 'src/ICAP/ICAPInitiator.cc' => 'src/adaptation/Initiator.cc' --- src/ICAP/ICAPInitiator.cc 2008-02-13 06:12:45 +0000 +++ src/adaptation/Initiator.cc 2008-03-30 19:00:57 +0000 @@ -3,24 +3,29 @@ */ #include "squid.h" -#include "ICAPXaction.h" -#include "ICAPInitiator.h" +#include "adaptation/Initiate.h" +#include "adaptation/Initiator.h" -ICAPInitiate *ICAPInitiator::initiateIcap(ICAPInitiate *x) { - if ((x = dynamic_cast(ICAPInitiate::AsyncStart(x)))) +Adaptation::Initiate * +Adaptation::Initiator::initiateAdaptation(Adaptation::Initiate *x) +{ + if ((x = dynamic_cast(Initiate::AsyncStart(x)))) x = cbdataReference(x); - return x; + return x; } -void ICAPInitiator::clearIcap(ICAPInitiate *&x) { +void +Adaptation::Initiator::clearAdaptation(Initiate *&x) +{ assert(x); cbdataReferenceDone(x); } -void ICAPInitiator::announceInitiatorAbort(ICAPInitiate *&x) +void +Adaptation::Initiator::announceInitiatorAbort(Initiate *&x) { if (x) { - CallJobHere(93, 5, x, ICAPInitiate::noteInitiatorAborted); - clearIcap(x); + CallJobHere(93, 5, x, Initiate::noteInitiatorAborted); + clearAdaptation(x); } } === renamed file 'src/ICAP/ICAPInitiator.h' => 'src/adaptation/Initiator.h' --- src/ICAP/ICAPInitiator.h 2008-02-13 06:12:45 +0000 +++ src/adaptation/Initiator.h 2008-03-30 19:00:57 +0000 @@ -1,38 +1,8 @@ - -/* - * $Id: ICAPInitiator.h,v 1.3 2008/02/12 23:12:45 rousskov Exp $ - * - * - * SQUID Web Proxy Cache http://www.squid-cache.org/ - * ---------------------------------------------------------- - * - * Squid is the result of efforts by numerous individuals from - * the Internet community; see the CONTRIBUTORS file for full - * details. Many organizations have provided support for Squid's - * development; see the SPONSORS file for full details. Squid is - * Copyrighted (C) 2001 by the Regents of the University of - * California; see the COPYRIGHT file for full details. Squid - * incorporates software developed and/or copyrighted by other - * sources; see the CREDITS file for full details. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. - * - */ - -#ifndef SQUID_ICAPINITIATOR_H -#define SQUID_ICAPINITIATOR_H +#ifndef SQUID_ADAPTATION__INITIATOR_H +#define SQUID_ADAPTATION__INITIATOR_H + +#include "ICAP/AsyncJob.h" +#include "adaptation/forward.h" /* * The ICAP Initiator is an ICAP vectoring point that initates ICAP @@ -43,32 +13,33 @@ * or aborting an ICAP transaction. */ -#include "AsyncJob.h" - class HttpMsg; -class ICAPInitiate; - -class ICAPInitiator: virtual public AsyncJob + +namespace Adaptation { + +class Initiator: virtual public AsyncJob { public: - ICAPInitiator():AsyncJob("ICAPInitiator"){} - virtual ~ICAPInitiator() {} + Initiator(): AsyncJob("Initiator") {} + virtual ~Initiator() {} // called when ICAP response headers are successfully interpreted - virtual void noteIcapAnswer(HttpMsg *message) = 0; + virtual void noteAdaptationAnswer(HttpMsg *message) = 0; // called when valid ICAP response headers are no longer expected // the final parameter is set to disable bypass or retries - virtual void noteIcapQueryAbort(bool final) = 0; + virtual void noteAdaptationQueryAbort(bool final) = 0; protected: - ICAPInitiate *initiateIcap(ICAPInitiate *x); // locks and returns x + Initiate *initiateAdaptation(Initiate *x); // locks and returns x // done with x (and not calling announceInitiatorAbort) - void clearIcap(ICAPInitiate *&x); // unlocks x + void clearAdaptation(Initiate *&x); // unlocks x // inform the transaction about abnormal termination and clear it - void announceInitiatorAbort(ICAPInitiate *&x); // unlocks x + void announceInitiatorAbort(Initiate *&x); // unlocks x }; -#endif /* SQUID_ICAPINITIATOR_H */ +} // namespace Adaptation + +#endif /* SQUID_ADAPTATION__INITIATOR_H */ === added file 'src/adaptation/Makefile.am' --- src/adaptation/Makefile.am 1970-01-01 00:00:00 +0000 +++ src/adaptation/Makefile.am 2008-04-03 05:31:29 +0000 @@ -0,0 +1,36 @@ +AM_CFLAGS = @SQUID_CFLAGS@ +AM_CXXFLAGS = @SQUID_CXXFLAGS@ + +INCLUDES = \ + -I$(top_builddir)/include \ + -I$(top_srcdir)/include \ + -I$(top_srcdir)/src + +noinst_LTLIBRARIES = libadaptation.la + +libadaptation_la_SOURCES = \ + AccessCheck.cc \ + AccessCheck.h \ + AccessRule.cc \ + AccessRule.h \ + Config.cc \ + Config.h \ + Elements.cc \ + Elements.h \ + forward.h \ + Initiate.cc \ + Initiate.h \ + Initiator.cc \ + Initiator.h \ + Service.cc \ + Service.h \ + ServiceConfig.cc \ + ServiceConfig.h \ + ServiceGroups.cc \ + ServiceGroups.h + +check_PROGRAMS = testHeaders + +## test .h correctness +testHeaders: *.h + $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "." || exit 1 === added file 'src/adaptation/Service.cc' --- src/adaptation/Service.cc 1970-01-01 00:00:00 +0000 +++ src/adaptation/Service.cc 2008-04-03 23:10:04 +0000 @@ -0,0 +1,37 @@ +/* + * DEBUG: section XXX + */ + +#include "squid.h" +#include "adaptation/Service.h" + +Adaptation::Service::Service(const ServiceConfig &aConfig): theConfig(aConfig) +{ + debugs(93,3, HERE << "creating adaptation service " << theConfig.key); +} + +Adaptation::Service::~Service() +{} + +void +Adaptation::Service::finalize() +{ +} + +Adaptation::Services & +Adaptation::AllServices() +{ + static Services TheServices; + return TheServices; +} + +Adaptation::ServicePointer +Adaptation::FindService(const Service::Id& key) +{ + typedef Services::iterator SI; + for (SI i = AllServices().begin(); i != AllServices().end(); ++i) { + if ((*i)->cfg().key == key) + return *i; + } + return NULL; +} === added file 'src/adaptation/Service.h' --- src/adaptation/Service.h 1970-01-01 00:00:00 +0000 +++ src/adaptation/Service.h 2008-04-03 05:31:29 +0000 @@ -0,0 +1,66 @@ +#ifndef SQUID_ADAPTATION__SERVICE_H +#define SQUID_ADAPTATION__SERVICE_H + +#include "SquidString.h" +#include "RefCount.h" +#include "adaptation/forward.h" +#include "adaptation/Elements.h" +#include "adaptation/ServiceConfig.h" + +// TODO: Move src/ICAP/ICAPServiceRep.h API comments here and update them + +class HttpMsg; +class HttpRequest; + +namespace Adaptation { + +// manages adaptation service configuration in squid.conf +// specific adaptation mechanisms extend this class +class Service: public RefCountable +{ +public: + typedef RefCount Pointer; + typedef String Id; + +public: + Service(const ServiceConfig &aConfig); + virtual ~Service(); + + // call when the service is no longer needed or valid + virtual void invalidate() = 0; + + virtual bool probed() const = 0; // see comments above + virtual bool broken() const = 0; // see comments above + virtual bool up() const = 0; // see comments above + + virtual Initiate *makeXactLauncher(Initiator *, HttpMsg *virginHeader, HttpRequest *virginCause) = 0; + + typedef void Callback(void *data, Pointer &service); + void callWhenReady(Callback *cb, void *data); + + // the methods below can only be called on an up() service + virtual bool wantsUrl(const String &urlPath) const = 0; + + // called by transactions to report service failure + virtual void noteFailure() = 0; + + const ServiceConfig &cfg() const { return theConfig; } + + virtual void finalize(); // called after creation + +protected: + ServiceConfig &writeableCfg() { return theConfig; } + +private: + ServiceConfig theConfig; +}; + +typedef Service::Pointer ServicePointer; + +typedef Vector Services; +extern Services &AllServices(); +extern ServicePointer FindService(const Service::Id &key); + +} // namespace Adaptation + +#endif /* SQUID_ADAPTATION__SERVICE_H */ === added file 'src/adaptation/ServiceConfig.cc' --- src/adaptation/ServiceConfig.cc 1970-01-01 00:00:00 +0000 +++ src/adaptation/ServiceConfig.cc 2008-03-30 18:47:14 +0000 @@ -0,0 +1,147 @@ +/* + * DEBUG: section XXX + */ + +#include "squid.h" +#include "ConfigParser.h" +#include "adaptation/ServiceConfig.h" + +Adaptation::ServiceConfig::ServiceConfig(): + port(-1), method(methodNone), point(pointNone), bypass(false) +{} + +const char * +Adaptation::ServiceConfig::methodStr() const +{ + return Adaptation::methodStr(method); +} + +const char * +Adaptation::ServiceConfig::vectPointStr() const +{ + return Adaptation::vectPointStr(point); +} + +Adaptation::Method +Adaptation::ServiceConfig::parseMethod(const char *str) const +{ + if (!strncasecmp(str, "REQMOD", 6)) + return Adaptation::methodReqmod; + + if (!strncasecmp(str, "RESPMOD", 7)) + return Adaptation::methodRespmod; + + return Adaptation::methodNone; +} + +Adaptation::VectPoint +Adaptation::ServiceConfig::parseVectPoint(const char *service_configConfig) const +{ + const char *t = service_configConfig; + const char *q = strchr(t, '_'); + + if (q) + t = q + 1; + + if (!strcasecmp(t, "precache")) + return Adaptation::pointPreCache; + + if (!strcasecmp(t, "postcache")) + return Adaptation::pointPostCache; + + return Adaptation::pointNone; +} + +bool +Adaptation::ServiceConfig::parse() +{ + char *method_point = NULL; + + ConfigParser::ParseString(&key); + ConfigParser::ParseString(&method_point); + ConfigParser::ParseBool(&bypass); + ConfigParser::ParseString(&uri); + + debugs(3, 5, HERE << cfg_filename << ':' << config_lineno << ": " << + key.buf() << " " << method_point << " " << bypass); + + method = parseMethod(method_point); + point = parseVectPoint(method_point); + + debugs(3, 5, HERE << cfg_filename << ':' << config_lineno << ": " << + "service_configConfig is " << methodStr() << "_" << vectPointStr()); + + // TODO: find core code that parses URLs and extracts various parts + + // extract scheme and use it as the service_configConfig protocol + const char *schemeSuffix = "://"; + if (const char *schemeEnd = uri.pos(schemeSuffix)) + protocol.limitInit(uri.buf(), schemeEnd - uri.buf()); + debugs(3, 5, HERE << cfg_filename << ':' << config_lineno << ": " << + "service protocol is " << protocol); + if (!protocol.size()) + return false; + + // skip scheme + const char *s = uri.buf() + protocol.size() + strlen(schemeSuffix); + + const char *e; + + bool have_port = false; + + if ((e = strchr(s, ':')) != NULL) { + have_port = true; + } else if ((e = strchr(s, '/')) != NULL) { + have_port = false; + } else { + return false; + } + + int len = e - s; + host.limitInit(s, len); + s = e; + + port = -1; + if (have_port) { + s++; + + if ((e = strchr(s, '/')) != NULL) { + char *t; + const unsigned long p = strtoul(s, &t, 0); + + if (p > 65535) // port value is too high + return false; + + port = static_cast(p); + + if (t != e) // extras after the port + return false; + + s = e; + + if (s[0] != '/') + return false; + } + } + + // if no port, the caller may use service_configConfigs or supply the default if neeeded + + s++; + e = strchr(s, '\0'); + len = e - s; + + if (len > 1024) { + debugs(3, 0, HERE << cfg_filename << ':' << config_lineno << ": " << + "long resource name (>1024), probably wrong"); + } + + resource.limitInit(s, len + 1); + + if ((bypass != 0) && (bypass != 1)) { + debugs(3, 0, HERE << cfg_filename << ':' << config_lineno << ": " << + "wrong bypass value; 0 or 1 expected: " << bypass); + return false; + } + + return true; +} === added file 'src/adaptation/ServiceConfig.h' --- src/adaptation/ServiceConfig.h 1970-01-01 00:00:00 +0000 +++ src/adaptation/ServiceConfig.h 2008-03-30 18:47:14 +0000 @@ -0,0 +1,42 @@ +#ifndef SQUID_ADAPTATION__SERVICE_CONFIG_H +#define SQUID_ADAPTATION__SERVICE_CONFIG_H + +#include "SquidString.h" +#include "RefCount.h" +#include "adaptation/Elements.h" + +namespace Adaptation { + +// manages adaptation service configuration in squid.conf +class ServiceConfig +{ +public: + ServiceConfig(); + + const char *methodStr() const; + const char *vectPointStr() const; + + bool parse(); + +public: + String key; // service_configConfig name in the configuration file + String uri; // service_configConfig URI + + // service_configConfig URI components + String protocol; + String host; + String resource; + int port; + + Method method; // what is being adapted (REQMOD vs RESPMOD) + VectPoint point; // where the adaptation happens (pre- or post-cache) + bool bypass; + +protected: + Method parseMethod(const char *buf) const; + VectPoint parseVectPoint(const char *buf) const; +}; + +} // namespace Adaptation + +#endif /* SQUID_ADAPTATION__SERVICE_CONFIG_H */ === added file 'src/adaptation/ServiceGroups.cc' --- src/adaptation/ServiceGroups.cc 1970-01-01 00:00:00 +0000 +++ src/adaptation/ServiceGroups.cc 2008-04-03 23:11:40 +0000 @@ -0,0 +1,104 @@ +#include "squid.h" + +#include "ConfigParser.h" +#include "Array.h" // really Vector +#include "adaptation/Config.h" +#include "adaptation/AccessRule.h" +#include "adaptation/Service.h" +#include "adaptation/ServiceGroups.h" + + +Adaptation::ServiceGroup::ServiceGroup(const String &aKind): kind(aKind) +{ +} + +Adaptation::ServiceGroup::~ServiceGroup() +{ +} + +void +Adaptation::ServiceGroup::parse() +{ + ConfigParser::ParseString(&id); + + wordlist *names = NULL; + ConfigParser::ParseWordList(&names); + for (wordlist *i = names; i; i = i->next) + services.push_back(i->key); + wordlistDestroy(&names); +} + +void +Adaptation::ServiceGroup::finalize() +{ + for (iterator i = services.begin(); i != services.end(); ++i) { + const String &id = *i; + // TODO: fail on failures + if (!FindService(id)) + debugs(93,0, "ERROR: Unknown adaptation name: " << id); + } + debugs(93,7, HERE << "finalized " << kind << ": " << id); +} + +/* ServiceSet */ + +Adaptation::ServiceSet::ServiceSet(): ServiceGroup("adaptation set") +{ +} + +Adaptation::ServiceGroup::Loop Adaptation::ServiceSet::initialServices() +{ + return Loop(services.begin(), services.end()); +} + +#if FUTURE_OPTIMIZATION +void +Adaptation::ServiceSet::finalize() +{ + ServiceGroup::finalize(); + + for (wordlist *iter = service_names; iter; iter = iter->next) { + ServicePointer match = Config::FindService(iter->id); + if (match != NULL) + services += match; + } +} +#endif + + +/* SingleService */ + +Adaptation::SingleService::SingleService(const String &aServiceId): + ServiceGroup("single-service group") +{ + id = aServiceId; + services.push_back(aServiceId); +} + +Adaptation::ServiceGroup::Loop +Adaptation::SingleService::initialServices() +{ + return Loop(services.begin(), services.end()); // there should be only one +} + + +/* globals */ + +Adaptation::Groups & +Adaptation::AllGroups() +{ + static Groups TheGroups; + return TheGroups; +} + +Adaptation::ServiceGroup * +Adaptation::FindGroup(const ServiceGroup::Id &id) +{ + typedef Groups::iterator GI; + for (GI i = AllGroups().begin(); i != AllGroups().end(); ++i) { + if ((*i)->id == id) + return *i; + } + + return NULL; +} === added file 'src/adaptation/ServiceGroups.h' --- src/adaptation/ServiceGroups.h 1970-01-01 00:00:00 +0000 +++ src/adaptation/ServiceGroups.h 2008-04-05 04:40:38 +0000 @@ -0,0 +1,72 @@ +#ifndef SQUID_ADAPTATION__SERVICE_GROUPS_H +#define SQUID_ADAPTATION__SERVICE_GROUPS_H + +#include "SquidString.h" +#include "Array.h" +#include "adaptation/forward.h" + +namespace Adaptation { + +// Interface for grouping adaptation services together. +// Specific groups differ in how the first and the next services are selected +class ServiceGroup +{ +public: + typedef Vector Store; + typedef Store::iterator iterator; + typedef String Id; + + // Information sufficient to iterate services stored in the group, + // grouped together to simplify initial/sequentialServices interfaces. + // The iterators point back to + struct Loop { + Loop(const iterator &b, const iterator &e): begin(b), end(e) {} + iterator begin; + iterator end; + }; + +public: + ServiceGroup(const String &aKind); + virtual ~ServiceGroup(); + + virtual void parse(); + virtual void finalize(); // called after all are parsed + + virtual Loop initialServices() = 0; + // TODO: virtual Loop sequentialServices() = 0; + +public: + String kind; + Id id; + Store services; +}; + +// a group of equivalent services; one service per set is usually used +class ServiceSet: public ServiceGroup +{ +public: + ServiceSet(); + virtual Loop initialServices(); +}; + +// corner case: a group consisting of one service +class SingleService: public ServiceGroup +{ +public: + SingleService(const String &aServiceKey); + virtual Loop initialServices(); +}; + +// TODO: a group of services that must be used one after another +// class ServiceChain: public ServiceGroup + + +typedef Vector Groups; +extern Groups &AllGroups(); +extern ServiceGroup *FindGroup(const ServiceGroup::Id &id); + + +} // namespace Adaptation + +#endif /* SQUID_ADAPTATION__SERVICE_GROUPS_H */ + === added file 'src/adaptation/forward.h' --- src/adaptation/forward.h 1970-01-01 00:00:00 +0000 +++ src/adaptation/forward.h 2008-04-03 05:31:29 +0000 @@ -0,0 +1,29 @@ +#ifndef SQUID_ADAPTATION__FORWARD_H +#define SQUID_ADAPTATION__FORWARD_H + +// forward-declarations for commonly used adaptation classes + +template +class RefCount; + +// For various collections such as AllServices +// TODO: use std::hash_map<> instead +template +class Vector; + +namespace Adaptation { + +class Service; +class ServiceConfig; +class Class; +class Initiate; +class Initiator; +class AccessCheck; +class AccessRule; +class ServiceGroup; + +typedef RefCount ServicePointer; + +} // namespace Adaptation + +#endif /* SQUID_ADAPTATION__FORWARD_H */ === modified file 'src/cache_cf.cc' --- src/cache_cf.cc 2008-03-20 23:20:58 +0000 +++ src/cache_cf.cc 2008-04-03 05:31:29 +0000 @@ -59,6 +59,17 @@ #include "ESIParser.h" #endif +#if USE_ADAPTATION +#include "adaptation/Config.h" + +static void parse_adaptation_service_set_type(); + +static void parse_adaptation_access_type(); +static void dump_adaptation_access_type(StoreEntry *, const char *); +static void free_adaptation_access_type(); + +#endif + #if ICAP_CLIENT #include "ICAP/ICAPConfig.h" @@ -3421,60 +3432,93 @@ } } +#if USE_ADAPTATION + +static void +parse_adaptation_service_set_type() +{ + Adaptation::Config::ParseServiceSet(); +} + +static void +parse_adaptation_access_type() +{ + Adaptation::Config::ParseAccess(LegacyParser); +} + +static void +free_adaptation_access_type() +{ + Adaptation::Config::FreeAccess(); +} + +static void +dump_adaptation_access_type(StoreEntry * entry, const char *name) +{ + Adaptation::Config::DumpAccess(entry, name); +} + +#endif /* USE_ADAPTATION */ + + #if ICAP_CLIENT static void parse_icap_service_type(ICAPConfig * cfg) { - cfg->parseICAPService(); + cfg->parseService(); } static void free_icap_service_type(ICAPConfig * cfg) { - cfg->freeICAPService(); + cfg->freeService(); } static void dump_icap_service_type(StoreEntry * entry, const char *name, const ICAPConfig &cfg) { - cfg.dumpICAPService(entry, name); -} - -static void -parse_icap_class_type(ICAPConfig * cfg) -{ - cfg->parseICAPClass(); -} - -static void -free_icap_class_type(ICAPConfig * cfg) -{ - cfg->freeICAPClass(); -} - -static void -dump_icap_class_type(StoreEntry * entry, const char *name, const ICAPConfig &cfg) -{ - cfg.dumpICAPClass(entry, name); -} - -static void -parse_icap_access_type(ICAPConfig * cfg) -{ - cfg->parseICAPAccess(LegacyParser); -} - -static void -free_icap_access_type(ICAPConfig * cfg) -{ - cfg->freeICAPAccess(); -} - -static void -dump_icap_access_type(StoreEntry * entry, const char *name, const ICAPConfig &cfg) -{ - cfg.dumpICAPAccess(entry, name); + cfg.dumpService(entry, name); +} + +static void +parse_icap_class_type(ICAPConfig *) +{ + debugs(93, 0, "WARNING: 'icap_class' is depricated. " << + "Use 'adaptation_service_set' instead"); + Adaptation::Config::ParseServiceSet(); +} + +static void +free_icap_class_type(ICAPConfig *) +{ + Adaptation::Config::FreeServiceSet(); +} + +static void +dump_icap_class_type(StoreEntry * entry, const char *name, const ICAPConfig &) +{ + Adaptation::Config::DumpServiceSet(entry, name); +} + +static void +parse_icap_access_type(ICAPConfig *) +{ + debugs(93, 0, "WARNING: 'icap_access' is depricated. " << + "Use 'adaptation_access' instead"); + parse_adaptation_access_type(); +} + +static void +free_icap_access_type(ICAPConfig *) +{ + free_adaptation_access_type(); +} + +static void +dump_icap_access_type(StoreEntry * entry, const char *name, const ICAPConfig &) +{ + dump_adaptation_access_type(entry, name); } #endif === modified file 'src/cf.data.depend' --- src/cf.data.depend 2007-12-15 06:11:41 +0000 +++ src/cf.data.depend 2008-04-03 05:31:29 +0000 @@ -25,6 +25,8 @@ http_header_replace http_port_list https_port_list +adaptation_access_type adaptation_service_set acl icap_service icap_class +adaptation_service_set_type icap_service icap_access_type icap_class acl icap_class_type icap_service icap_service_type === modified file 'src/cf.data.pre' --- src/cf.data.pre 2008-02-12 07:05:11 +0000 +++ src/cf.data.pre 2008-04-03 05:31:29 +0000 @@ -5007,16 +5007,15 @@ LOC: TheICAPConfig DEFAULT: none DOC_START - Defines an ICAP service chain. Eventually, multiple services per - vectoring point will be supported. For now, please specify a single - service per class: - - icap_class classname servicename - -Example: -icap_class class_1 service_1 -icap class class_2 service_1 -icap class class_3 service_3 + This depricated option was documented to define an ICAP service + chain, even though it actually defined a set of similar, redundant + services, and the chains were not supported. + + To define a set of redundant services, please use the + adaptation_service_set directive. + + If you need adaptation service chains, patches or sponsorship + is welcome. DOC_END NAME: icap_access @@ -5025,21 +5024,95 @@ LOC: TheICAPConfig DEFAULT: none DOC_START - Redirects a request through an ICAP service class, depending - on given acls - - icap_access classname allow|deny [!]aclname... - - The icap_access statements are processed in the order they appear in - this configuration file. If an access list matches, the processing stops. - For an "allow" rule, the specified class is used for the request. A "deny" - rule simply stops processing without using the class. You can also use the - special classname "None". - - For backward compatibility, it is also possible to use services - directly here. -Example: -icap_access class_1 allow all + This option is depricated. Please use adaptation_access, which + has the same ICAP functionality, but comes with better + documentation, and eCAP support. +DOC_END + +COMMENT_START + eCAP OPTIONS + ----------------------------------------------------------------------------- +COMMENT_END + +NAME: loadable_modules +TYPE: wordlist +IFDEF: USE_LOADABLE_MODULES +LOC: Config.loadable_module_names +DEFAULT: none +DOC_START + Instructs Squid to load the specified dynamic module(s) or activate + preloaded module(s). +Example: +loadable_modules @DEFAULT_PREFIX@/lib/MinimalAdapter.so +DOC_END + +COMMENT_START + MESSAGE ADAPTATION OPTIONS + ----------------------------------------------------------------------------- +COMMENT_END + +NAME: adaptation_service_set +TYPE: adaptation_service_set_type +IFDEF: USE_ADAPTATION +LOC: none +DEFAULT: none +DOC_START + + Defines a named adaptation service set. The set is populated in + the order of adaptation_service_set directives in this file. + When adaptation ACLs are processed, the first and only the first + applicable adaptation service from the set will be used. Thus, + the set should group similar, redundant services, rather than a + chain of complementary services. + + If you have a single adaptation service, you do not need to + define a set containing it because adaptation_access accepts + service names. + + See also: adaptation_access + +Example: +adaptation_service_set svcBlocker urlFilterPrimary urlFilterBackup +adaptation service_set svcLogger loggerLocal loggerRemote +DOC_END + +NAME: adaptation_access +TYPE: adaptation_access_type +IFDEF: USE_ADAPTATION +LOC: none +DEFAULT: none +DOC_START + Sends an HTTP transaction to an ICAP or eCAP adaptation service. + + adaptation_access service_name allow|deny [!]aclname... + adaptation_access set_name allow|deny [!]aclname... + + At each supported vectoring point, the adaptation_access + statements are processed in the order they appear in this + configuration file. Statements pointing to the following services + are ignored (i.e., skipped without checking their ACL): + + - services serving different vectoring points + - "broken-but-bypassable" services + - "up" services configured to ignore such transactions + (e.g., based on the ICAP Transfer-Ignore header). + + When a set_name is used, all services in the set are checked + using the same rules, to find the first applicable one. See + adaptation_service_set for details. + + If an access list is checked and there is a match, the + processing stops: For an "allow" rule, the corresponding + adaptation service is used for the transaction. For a "deny" + rule, no adaptation service is activated. + + It is currently not possible to apply more than one adaptation + service at the same vectoring point to the same HTTP transaction. + + See also: icap_service and ecap_service + +Example: +adaptation_access service_1 allow all DOC_END COMMENT_START === modified file 'src/client_side_request.cc' --- src/client_side_request.cc 2008-03-16 21:48:45 +0000 +++ src/client_side_request.cc 2008-04-04 17:11:00 +0000 @@ -59,12 +59,10 @@ #include "SquidTime.h" #include "wordlist.h" -#if ICAP_CLIENT -#include "ICAP/ICAPModXact.h" -#include "ICAP/ICAPElements.h" -#include "ICAP/ICAPConfig.h" -static void icapAclCheckDoneWrapper(ICAPServiceRep::Pointer service, void *data); -extern ICAPConfig TheICAPConfig; +#if USE_ADAPTATION +#include "adaptation/AccessCheck.h" +#include "adaptation/Service.h" +static void adaptationAclCheckDoneWrapper(Adaptation::ServicePointer service, void *data); #endif #if LINGERING_CLOSE @@ -144,7 +142,7 @@ } ClientHttpRequest::ClientHttpRequest(ConnStateData * aConn) : -#if ICAP_CLIENT +#if USE_ADAPTATION AsyncJob("ClientHttpRequest"), #endif loggingEntry_(NULL) @@ -152,7 +150,7 @@ start_time = current_time; setConn(aConn); dlinkAdd(this, &active, &ClientActiveRequests); -#if ICAP_CLIENT +#if USE_ADAPTATION request_satisfaction_mode = false; #endif } @@ -255,11 +253,11 @@ freeResources(); -#if ICAP_CLIENT - announceInitiatorAbort(icapHeadSource); +#if USE_ADAPTATION + announceInitiatorAbort(virginHeadSource); - if (icapBodySource != NULL) - stopConsumingFrom(icapBodySource); + if (adaptedBodySource != NULL) + stopConsumingFrom(adaptedBodySource); #endif if (calloutContext) @@ -483,43 +481,28 @@ http->doCallouts(); } -#if ICAP_CLIENT -void -ClientRequestContext::icapAccessCheck() -{ - ICAPAccessCheck *icap_access_check; - - icap_access_check = new ICAPAccessCheck(ICAP::methodReqmod, ICAP::pointPreCache, http->request, NULL, icapAclCheckDoneWrapper, this); - - if (icap_access_check != NULL) { - icap_access_check->check(); - return; - } - - http->doCallouts(); -} - +#if USE_ADAPTATION static void -icapAclCheckDoneWrapper(ICAPServiceRep::Pointer service, void *data) +adaptationAclCheckDoneWrapper(Adaptation::ServicePointer service, void *data) { ClientRequestContext *calloutContext = (ClientRequestContext *)data; if (!calloutContext->httpStateIsValid()) return; - calloutContext->icapAclCheckDone(service); + calloutContext->adaptationAclCheckDone(service); } void -ClientRequestContext::icapAclCheckDone(ICAPServiceRep::Pointer service) +ClientRequestContext::adaptationAclCheckDone(Adaptation::ServicePointer service) { - debugs(93,3,HERE << this << " icapAclCheckDone called"); + debugs(93,3,HERE << this << " adaptationAclCheckDone called"); assert(http); - if (http->startIcap(service)) + if (http->startAdaptation(service)) return; - if (!service || service->bypass) { + if (!service || service->cfg().bypass) { // handle ICAP start failure when no service was selected // or where the selected service was optional http->doCallouts(); @@ -527,7 +510,7 @@ } // handle start failure for an essential ICAP service - http->handleIcapFailure(); + http->handleAdaptationFailure(); } #endif @@ -1069,14 +1052,14 @@ return; } -#if ICAP_CLIENT - if (TheICAPConfig.onoff && !calloutContext->icap_acl_check_done) { - debugs(83, 3, HERE << "Doing calloutContext->icapAccessCheck()"); - calloutContext->icap_acl_check_done = true; - calloutContext->icapAccessCheck(); - return; +#if USE_ADAPTATION + if (!calloutContext->adaptation_acl_check_done) { + calloutContext->adaptation_acl_check_done = true; + if (Adaptation::AccessCheck::Start( + Adaptation::methodReqmod, Adaptation::pointPreCache, + request, NULL, adaptationAclCheckDoneWrapper, calloutContext)) + return; // will call callback } - #endif if (!calloutContext->redirect_done) { @@ -1136,33 +1119,34 @@ #include "client_side_request.cci" #endif -#if ICAP_CLIENT +#if USE_ADAPTATION /* * Initiate an ICAP transaction. Return false on errors. * The caller must handle errors. */ bool -ClientHttpRequest::startIcap(ICAPServiceRep::Pointer service) +ClientHttpRequest::startAdaptation(Adaptation::ServicePointer service) { - debugs(85, 3, HERE << this << " ClientHttpRequest::startIcap() called"); + debugs(85, 3, HERE << this << " ClientHttpRequest::startAdaptation() called"); if (!service) { - debugs(85, 3, "ClientHttpRequest::startIcap fails: lack of service"); + debugs(85, 3, "ClientHttpRequest::startAdaptation fails: lack of service"); return false; } if (service->broken()) { - debugs(85, 3, "ClientHttpRequest::startIcap fails: broken service"); + debugs(85, 3, "ClientHttpRequest::startAdaptation fails: broken service"); return false; } - assert(!icapHeadSource); - assert(!icapBodySource); - icapHeadSource = initiateIcap( - new ICAPModXactLauncher(this, request, NULL, service)); - return icapHeadSource != NULL; + assert(!virginHeadSource); + assert(!adaptedBodySource); + virginHeadSource = initiateAdaptation(service->makeXactLauncher( + this, request, NULL)); + + return virginHeadSource != NULL; } void -ClientHttpRequest::noteIcapAnswer(HttpMsg *msg) +ClientHttpRequest::noteAdaptationAnswer(HttpMsg *msg) { assert(cbdataReferenceValid(this)); // indicates bug assert(msg); @@ -1185,8 +1169,8 @@ // subscribe to receive reply body if (new_rep->body_pipe != NULL) { - icapBodySource = new_rep->body_pipe; - assert(icapBodySource->setConsumerIfNotLate(this)); + adaptedBodySource = new_rep->body_pipe; + assert(adaptedBodySource->setConsumerIfNotLate(this)); } clientStreamNode *node = (clientStreamNode *)client_stream.tail->prev->data; @@ -1198,34 +1182,34 @@ request_satisfaction_offset = 0; storeEntry()->replaceHttpReply(new_rep); - if (!icapBodySource) // no body + if (!adaptedBodySource) // no body storeEntry()->complete(); clientGetMoreData(node, this); } // we are done with getting headers (but may be receiving body) - clearIcap(icapHeadSource); + clearAdaptation(virginHeadSource); if (!request_satisfaction_mode) doCallouts(); } void -ClientHttpRequest::noteIcapQueryAbort(bool final) +ClientHttpRequest::noteAdaptationQueryAbort(bool final) { - clearIcap(icapHeadSource); - assert(!icapBodySource); - handleIcapFailure(!final); + clearAdaptation(virginHeadSource); + assert(!adaptedBodySource); + handleAdaptationFailure(!final); } void ClientHttpRequest::noteMoreBodyDataAvailable(BodyPipe::Pointer) { assert(request_satisfaction_mode); - assert(icapBodySource != NULL); + assert(adaptedBodySource != NULL); - if (const size_t contentSize = icapBodySource->buf().contentSize()) { - BodyPipeCheckout bpc(*icapBodySource); + if (const size_t contentSize = adaptedBodySource->buf().contentSize()) { + BodyPipeCheckout bpc(*adaptedBodySource); const StoreIOBuffer ioBuf(&bpc.buf, request_satisfaction_offset); storeEntry()->write(ioBuf); // assume can write everything @@ -1234,7 +1218,7 @@ bpc.checkIn(); } - if (icapBodySource->exhausted()) + if (adaptedBodySource->exhausted()) endRequestSatisfaction(); // else wait for more body data } @@ -1242,12 +1226,12 @@ void ClientHttpRequest::noteBodyProductionEnded(BodyPipe::Pointer) { - assert(!icapHeadSource); - if (icapBodySource != NULL) { // did not end request satisfaction yet + assert(!virginHeadSource); + if (adaptedBodySource != NULL) { // did not end request satisfaction yet // We do not expect more because noteMoreBodyDataAvailable always // consumes everything. We do not even have a mechanism to consume // leftovers after noteMoreBodyDataAvailable notifications seize. - assert(icapBodySource->exhausted()); + assert(adaptedBodySource->exhausted()); endRequestSatisfaction(); } } @@ -1256,7 +1240,7 @@ ClientHttpRequest::endRequestSatisfaction() { debugs(85,4, HERE << this << " ends request satisfaction"); assert(request_satisfaction_mode); - stopConsumingFrom(icapBodySource); + stopConsumingFrom(adaptedBodySource); // TODO: anything else needed to end store entry formation correctly? storeEntry()->complete(); @@ -1265,15 +1249,15 @@ void ClientHttpRequest::noteBodyProducerAborted(BodyPipe::Pointer) { - assert(!icapHeadSource); - stopConsumingFrom(icapBodySource); - handleIcapFailure(); + assert(!virginHeadSource); + stopConsumingFrom(adaptedBodySource); + handleAdaptationFailure(); } void -ClientHttpRequest::handleIcapFailure(bool bypassable) +ClientHttpRequest::handleAdaptationFailure(bool bypassable) { - debugs(85,3, HERE << "handleIcapFailure(" << bypassable << ")"); + debugs(85,3, HERE << "handleAdaptationFailure(" << bypassable << ")"); const bool usedStore = storeEntry() && !storeEntry()->isEmpty(); const bool usedPipe = request->body_pipe != NULL && === modified file 'src/client_side_request.h' --- src/client_side_request.h 2008-03-16 21:48:45 +0000 +++ src/client_side_request.h 2008-04-04 04:27:13 +0000 @@ -43,9 +43,9 @@ #include "dlink.h" #include "ICAP/AsyncJob.h" -#if ICAP_CLIENT -#include "ICAP/ICAPServiceRep.h" -#include "ICAP/ICAPInitiator.h" +#if USE_ADAPTATION +#include "adaptation/forward.h" +#include "adaptation/Initiator.h" class HttpMsg; #endif @@ -60,8 +60,8 @@ class ClientRequestContext; class ClientHttpRequest -#if ICAP_CLIENT - : public ICAPInitiator, // to start ICAP transactions +#if USE_ADAPTATION + : public Adaptation::Initiator, // to start adaptation transactions public BodyConsumer // to receive reply bodies in request satisf. mode #endif { @@ -69,7 +69,7 @@ public: void *operator new (size_t); void operator delete (void *); -#if ICAP_CLIENT +#if USE_ADAPTATION void *toCbdata() { return this; } #endif ClientHttpRequest(ConnStateData *); @@ -136,9 +136,9 @@ ClientRequestContext *calloutContext; void doCallouts(); -#if ICAP_CLIENT -//AsyncJob virtual methods - virtual bool doneAll() const { return ICAPInitiator::doneAll() && +#if USE_ADAPTATION + // AsyncJob virtual methods + virtual bool doneAll() const { return Initiator::doneAll() && BodyConsumer::doneAll() && false;} #endif @@ -156,18 +156,18 @@ void sslBumpEstablish(comm_err_t errflag); #endif -#if ICAP_CLIENT +#if USE_ADAPTATION public: - bool startIcap(ICAPServiceRep::Pointer); + bool startAdaptation(Adaptation::ServicePointer); // private but exposed for ClientRequestContext - void handleIcapFailure(bool bypassable = false); + void handleAdaptationFailure(bool bypassable = false); private: - // ICAPInitiator API, called by ICAPXaction - virtual void noteIcapAnswer(HttpMsg *message); - virtual void noteIcapQueryAbort(bool final); + // Adaptation::Initiator API + virtual void noteAdaptationAnswer(HttpMsg *message); + virtual void noteAdaptationQueryAbort(bool final); // BodyConsumer API, called by BodyPipe virtual void noteMoreBodyDataAvailable(BodyPipe::Pointer); @@ -177,8 +177,8 @@ void endRequestSatisfaction(); private: - ICAPInitiate *icapHeadSource; - BodyPipe::Pointer icapBodySource; + Adaptation::Initiate *virginHeadSource; + BodyPipe::Pointer adaptedBodySource; bool request_satisfaction_mode; int64_t request_satisfaction_offset; === added directory 'src/eCAP' === added file 'src/eCAP/Makefile.am' --- src/eCAP/Makefile.am 1970-01-01 00:00:00 +0000 +++ src/eCAP/Makefile.am 2008-04-05 05:24:42 +0000 @@ -0,0 +1,26 @@ +# Makefile for the eCAP library +# +# $Id$ +# + +AM_CFLAGS = @SQUID_CFLAGS@ +AM_CXXFLAGS = @SQUID_CXXFLAGS@ + +noinst_LTLIBRARIES = libeCAP.la + +libeCAP_la_SOURCES = \ + Registry.h + +INCLUDES = -I. -I$(top_builddir)/include -I$(top_srcdir)/include \ + -I$(top_srcdir)/src + + +# Sample adapter section. + +EXTRA_DIST = \ + MinimalAdapter.cc + +lib_LTLIBRARIES = MinimalAdapter.la +MinimalAdapter_la_SOURCES = MinimalAdapter.cc +MinimalAdapter_la_LDFLAGS = -module -avoid-version +MinimalAdapter_la_LIBADD = ./libeCAP.la === modified file 'src/ftp.cc' --- src/ftp.cc 2008-03-16 22:10:18 +0000 +++ src/ftp.cc 2008-03-31 01:06:13 +0000 @@ -1378,10 +1378,10 @@ return; } -#if ICAP_CLIENT +#if USE_ADAPTATION - if (icapAccessCheckPending) { - debugs(9,3, HERE << "returning from FtpStateData::processReplyBody due to icapAccessCheckPending"); + if (adaptationAccessCheckPending) { + debugs(9,3, HERE << "returning from FtpStateData::processReplyBody due to adaptationAccessCheckPending"); return; } @@ -2585,9 +2585,9 @@ return; } -#if ICAP_CLIENT - if (icapAccessCheckPending) { - debugs(9,3, HERE << "returning due to icapAccessCheckPending"); +#if USE_ADAPTATION + if (adaptationAccessCheckPending) { + debugs(9,3, HERE << "returning due to adaptationAccessCheckPending"); return; } #endif === modified file 'src/http.cc' --- src/http.cc 2008-02-13 06:55:26 +0000 +++ src/http.cc 2008-03-30 18:20:14 +0000 @@ -1175,8 +1175,8 @@ return; } -#if ICAP_CLIENT - if (icapAccessCheckPending) +#if USE_ADAPTATION + if (adaptationAccessCheckPending) return; #endif === modified file 'src/main.cc' --- src/main.cc 2008-02-27 04:49:32 +0000 +++ src/main.cc 2008-04-04 05:31:40 +0000 @@ -70,6 +70,17 @@ #include "MemPool.h" #include "ICMPSquid.h" +#if USE_LOADABLE_MODULES +#include "LoadableModules.h" +#endif + +#if ICAP_CLIENT +#include "ICAP/ICAPConfig.h" +#endif +#if USE_ADAPTATION +#include "adaptation/Config.h" +#endif + #if USE_WIN32_SERVICE #include "squid_windows.h" @@ -1078,6 +1089,26 @@ memCheckInit(); +#if USE_LOADABLE_MODULES + LoadableModulesConfigure(Config.loadable_module_names); +#endif + +#if USE_ADAPTATION + bool enableAdaptation = false; + + // We can remove this dependency on specific adaptation mechanisms + // if we create a generic Registry of such mechanisms. Should we? +#if ICAP_CLIENT + TheICAPConfig.finalize(); // must be after we load modules + enableAdaptation = TheICAPConfig.onoff; +#endif + // same for eCAP + + // must be the last adaptation-related finalize + Adaptation::Config::Finalize(enableAdaptation); +#endif + + debugs(1, 1, "Ready to serve requests."); if (!configured_once) { === modified file 'src/structs.h' --- src/structs.h 2008-03-20 23:20:58 +0000 +++ src/structs.h 2008-03-31 04:31:48 +0000 @@ -629,6 +629,10 @@ #endif char *accept_filter; + +#if USE_LOADABLE_MODULES + wordlist *loadable_module_names; +#endif }; SQUIDCEXTERN SquidConfig Config; # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWQSskgUCa8X/gH////v///// //////////9jar8eA+20+7aHS7LZLW7p9vXvcbs97K9vfB9KC7HEXO46iHQqh99vJBe+9ynQdsfe fcAnPfb18i30A9UH19DrtmqkK0ap7u5Lb28OXt2Khcu7Wy299Wvu5ofb6d9gPe8I2tGqhfZkQgJP vbny5323bAfb5rrva+9y6ADL233PveAH1eDH15VPeq4fdt98HOBt9APuukAHA+g2x9Nr1Zr7YRUt gVXRrqQSMPe3ezJtbVN25IAC26dKd9vsrz2Z22LrKu9l12oHEgJBIBBexQPcucAejVDQ8gG9e7IH opX2+mnKhQbF9uq8D3t67d996wAD77uJ3tx9vuyp0aCgAUbF3vr3Xz3vvChT0SD4qiFsMh9AM+3p 6HX3fbn3nLg7fdfMB8+zbzh23jd3p959ym3c9QAVSdA0CqvuuA7tx2U6T73PQl3zAH0FfQF993ve cCgAO23XOPWffbjvdcPXz2kFpqH169ejo++9yi+YA0bYFAQRppgTW+mctZmDQfT3Yp60p2MdgMhA VbO5h0pbBJT0OnrR5MQUoAFU0o9x9dPH0AoABz7uOoJ66AcVQFvd0U9YBezJAdV32rr7ve93u3rt 3vth9vs4HQAHLEAtwtZjgTsHOy675eve9cWJCh9AO7ADoMcr7ru+vfffOlAAAr6aB9Bo2sABY+4A eq8gd8DQUAXMNbe7bvrlm9b500pee+drvn153lu+303td97x6610ezfFALs++3ebT0x33OuVReno A0B5PQNB92dUiEpF9xePd9Y+sPtok+j12wo9d6u1bjvvb2Ievc9PHX0+jwGno4+87gA+gkAAbrN7 AbqGFG73z3xRcZgPX3avX06VXvsve7rfYNe127RKlKEmgAr1leeTulu3fbgu+vXLu476ujdhvS3e 7x971cZKJfXj1FEc7d33Dvs98dwA3uYI3t4erPZ7t6vs31u+3APRqW+e++H3KhjT6fPaKAFXduvr fIbxNUD17ugcB2oZ57z72+NCk97dPYN9NKRKB9e4Pc7tE5sUoVAO2BJXYYUiqu7uSX0wiKUJX0AD 3t5e993fPvL3Zvnfd9e3vjOe93p91N3fdp1ela+1tt6dX3nTQ27K25t9902HR3vNznPR7aq9Vep9 mokga0hVQ1e7hoevvBtPRq8wCgqtmTjb7avs99Ptvve9nSu3uaVXswKUfR07sadd7CX1QdXfA4r7 b6nuxm4PWmtLXddm+++F913x326D2toCijBsVvWu9956D09945p7r329SuWu7nB4t97ugHo53Ran G7t1XYD0d7e4zTWlOxnntRdqq5uu9vs3ptg9bMrbOMrFDpnO6WvFe30Gn1Wkq6vu97uHr2+de98e u7uFbYTN207fbru3pwFV65btL3uxudPQ12vbgoABg6AAe7AAqtboHdvID1r6Gh9957z1pQ+hJR5F NB73XN3cGTrvtvWAUBoADQACPWBrQKBQAJOmvPfdT1167lvp9740aT7x2+5LbZZenO9uvbSnmb5s vdh3s9uu7zneD26Vw7fbi5vWiNEKzuc7C0w1uD63rdD3198T2der4zr33yl23pdRjeuROh9O3kOH 3zsBwLnqdSjOazfXmW63ewd73V93g97u6rdX3PbDoFXsXuHO17mr2ezd29ZX1r7c7qgOqyNMtdsJ d3eNeOffYV7Z57veu4utvYxbaFt3Hedm+NV67z33bfevrXW0bH19drDL4FsbiW7mAmagaCts0K0D bDodADoAZBpTRJQKO2C8Gmtkry8Z106RPe5897e51k8Rta+usDk0NDYPvvtdstz73vJtHr5dTSWh Wec5x87d6y673lSkii89PL7i772+zRfeHoBWhncMvIMTu0hp04QFAw3d3VlNi0ffQPvZvtc+m9j0 eqoPTZqNHkdrEu206LqspQ2srs1tbaVvbVyq9xdbAKbLa6dzBrG3Xd6209c8SUUqvMvX3vKu8Ae5 5yrlp23pdqtZSTXp3Xtndb30Keh283rTs+M7q6xoJTDAPauuRVqbTfbr7e5TqT29dWjfb6rrt6k5 sBvmt3PuUKurPeLNPanebT2zcbHrpVTs66A1dmh0UC+3tveeXKHcMprok6CD6wp3u4XlW+n3Debt 973hu2X1gj09x73uLsOvXW6m7HrjrbG5qqlmk33UFsAFOuh2g6l233d3Tvb3dTO9tex1061VF2lY 7vt3D27j64egLU9czM5boUMSoRrAmsGqffYHql9mK2pm2bV9d2ZbaNKzTFaRtrdabdYe3Xpe7Ln1 fW69Rvtu0tPvbrzpn3brPh9rPV76+vrxu6nPvYdL192ezFsPVve71Ze33e7J7IXxt4HifY10bZSh ohpvdpuyXFS60F1Naa77Z3ut2N3evHPTapF1bdGtO9vEuntzm2VHamafKG3Tin0eRyACtXrDrKqA 1H3veD30Ls4U7u9bvp93gmz5D77tX3k+ge9e9de7faz473OcfcfRXq6PuKadZ7aRKefbQ6U1Rvsd 946vVCd93R6+7a7wOct3DAAHNgKBoSK1abGsa0z7mcq9UUK3b7zV2rrOkS7sqlNg2dudtptB73jt qBr7vup6rT3ZS5fPjPC9mr7tTqRaXuzZuxrp3dnS5ndnXV3e93vsV0fT1cxLbN22+9715evV2pRU 8++91W22z10a4PUVLaa+O+4d9ZpXVuAKOhRc3Q968DPbaAJQgIAEABAAJoACZABMg1MAmmSaDSaZ NTyTU21PRNQSmgQQgggQCGpgTEaTAEaNAU/SNIn6NRN6QQAGBAAJBJCE0JoE0yYmmhNMIJsoaJ6T DUwyAKnspjU8gmyiepsp6ZTwpoEKSEEEymEwjQTEyKp/6m0EZM0mBqNFT/U1MxT0xKeU80p+in6S eKGgD1AhSSBAJoNEeQTJT9SeyEwmFVP9Go2Kp+Kb1Uewm1I8Kan6UepoNAABoCokhBAIAIAAQ0AA QAAIaAJpkm1MNTJGjSA0yfHE+y9odsH4n5M/Im8khMVBKokVYDeof81QifyLIfbRDSpHTiIwAtkE lqBLLEmiyJIboQA1IHDKimQJQih+WBUckRAoBChUClBGgKFKBKVf+xK5CiFIqhIkiDEIAxAqu2A4 iBTcAYoahDCVHUAUADQKNI0o0okAn9+AAJokUENSLMiIBECqpEpSqCTN1RxRTRIilApxgEQNpUT7 wlwgRmETHY0aZUirK0wQZEgOUH6OxkJ//FyVQGP+WABgwD+mXk/+uGzbYGDxJQH/1qBOLIHIgfyr u5s0cMw1YRZVh/8pOJGjeFyWhoApyyU6GGMEjMBUCdT/ZH+y/dtn9M8H/H+0/ruF2QXvhQQeOh40 f8/Jn/jxR6ZZ/7L/hheR0X+0iDoP/65+bzPl1f/Pm3XxvZOx2SR/Qpt6HIxbVrlsQk1KHXGwc/9C xEoOxJAyGYaKCCfdbQb0UVbKw7ZXWJLdoAjAQ2ArRrMtWGQm9RqQzDKRoiCl9Vl19omBxK+1d5jB QpKVT/ZmDMjz8c0yCHmPP/29Gz/8/HEORCg9pKRApkKWYqeCGdhmnYgSigIigKWSRdoMJRpI28NJ q8hDjCEFRxg5FUkrEib2a7eXlOw0dvJUOCU5FSpEoNxz9JG81uvTWKGXB9GGJLSEHGw8PWdWg553 EAUJEU2Y4ObImWBipFVVCqqwjKlIUItJOYUKnb7cETaBCIF2ICIEiBIilYgiEiFSlpMVEssJaCYo MsS0LY0sQGEKc8GofoIQyQClKGlR+OBMamduXf0Ms3zPKaTgldsMApTiBLMAhu3/l7O/Y1/nxpUD zsI1lQrEpSMRGGAnXoxXRZCxBFokKUyE642I2IHCUxk2hUNSmVC0ht/YYLvKBtKkQMQRVmLH9/rY Gxdn+XU6SN47c414eGojnTyoTuhA6a9WsOcctJqopIjlBkFNRJTMtJRQjQNBUSeqywjPB3pDsarb Yw0P/z3w+cWB7yn9zJ0EfZ6tuBrlY5EVUIKsEotlSkQq1Lx99oeXJ6vTP+mavYzjUc1VqRKSPbaz PJV9H3+l4b29u+9+9fk2z/xnDzq7zSSGfLEH3yo8wZ/z0sBoEAeUwPJj64ZTojft5mJSfeIQ89tV RT2n2Xssdi4wyx20yO4xkHy3CrbV2hsMUgj/x7dV7UlO0ojd4fuspgIFWCJVR9f/nvrrXjQ8PNk3 r7sSJHYpVCJaxl1CZIJMc0YSRCPbq0RRdImOsliMyIB8othqtDaaGPDB5aNaVNaTEesZJREVQOQu MiZAhkhECUI1QwS0KRAehlRkxOusCUA5xhCRCiZKLjIMxMKuQIuSHA5vbaNiALSFs2xwaZKtGFTL LTqsSalIhzRiRPKcksJwKQpLMwq5pmNNAgRJv2HNSRimDWZtoVCET8HIg0nBHSCcW/VvmkjjiZk1 GlOlEjcXDmFdNlK2W2oTYzrAU5MiR0kDUjk10jC2hMABY3JUc7My54BgzTQSdkDwbmO2rCloA1By lCs8iYlXWAG0IlIiLZpb4yAGSIwLWYqSsIJhZFINAgxQkpBCoZZFlgnaZgD4k/6z/7dml9Ucjr9G epz04cT/rrY23wuXryPCfD/ZmelfZEkbGCNy6pnjrUkPZ+DOiz9J/ymVsw+RTp1xwaknlY2f1W/+ 39of6KFixnqdf/8KybY2vVRaNDyMBWC57kp9n/o5HC0DUfKx3Cr//nME0rWhX2V0TyekSgmDpHP/ pDV6eqdVP+tPAKw9V127SFREpRVmzKr2ysuvoilFU3f+AX/jIDfHPg/wtP/wLGPkmho0fUfP3Xap +r8KOpX392s3S/+o+2+Dc+p0Xz/+rPfEfHz0TfSLVY98HTsi+1Y//b/PLc4xdG27bCUmiZOnW4Y6 HY9Lm381T/7o3vHnzb/pRM9s+LriOvXKKcPZNaqTaupTG+ihpUXWo2rQ/C2+8b//LVXTYyA7CeNE X3aHvwyhmhNXU31YfRBxGzHMvrzShmCzNi4qwcUaGiO3UGF9b/V5u1xfFQeUksrjjEJJJPrGvh3p owdvSlB7KMtLFoPZzmZlaElKR13M5y1bKr81CaFdlO7PDTE11X2ZXY3uolnWnsJsKopu6pADudUY 6w58O4X/7gULnUbC7/nCCGpUBDQKAImSiAmdvgZsuh2I5JFtmbONngMrORVXg7q5rAdDyw2JmRk4 Z9HVQYL/+N6ZWO8zJrlfjhqjP1Qc+QRVB686oOd+HQhVwiHcSTTzDzkL4Dk0qlCC0g6TfqVCKFE3 RP8UfraApRR4j+RNiHKFvECc+lNNLbLfbIxNfQ1x4zW3f4dptuvVNX5OIHSd8HkxZLfcjYgKQokD ksWpUE2a2xRc/cPdXG+56EysYE6+hijcog/rHrF4ievyfQ/45jznOFIblA3Ap80BWRDUczMvfZeZ s6nGzbxxDAcoL6UTuPZDaW7Nfdx7pNKru1mlel8z0MJ7GY+ZTwbMJ6pOKjDk53rc9J+6uHY5ODkx MY0fjbt3uV62mGPnfc/A2SfnK4cMcmldGI5erJdYP8xkOH9cRRxSXv/6saeUUH1MryThmq61WpEd ZGo5YyfSSCYpYnKy56SQaTUKKUBwWpsweUqMFx29lF6op/15acigpLKnPVabJX45/tou5f8KrXgi VFI/VVqLS2GavrPDHW+sczo3cHT8Hp9/Hw9OiEdbRpZZJuAXBsQD6YyBkR/yKCjOXZ1UQl+TdNCJ 65jFMfZ9Y4uZpteRzH6Y9vlTQW/GekHsaPK0Ng2X9HcU7WG7QbPY8k1qLka0WKpcPs+aR0aWB9Zg aCNZUOJFgoooowYhwCkrjEuIgdkXVqkbPITLBTASuwkJacSB7AeSWAm8mOHmJSTKB4SGPOMGg/7F ReB8nqhadNOm4bqd9beZEy4d19G3tbqq221XwZw5nKxuon16BPWeIwhqFNhcMRM4whNAIgtY8GHN 6N3fxZ4rJnzMVWfoc5kfF7x0dpuVhMVMU9LTTxadrSbK8G7TSehyXGnemOFbqnN8L0PkT4n0uDHa w5OxuxpSER44gRLOwNGKWvGMyKCijnniSKPg15CJIqMTAqH+UaArgYkmsVM2l45OAtiKKO0IqYnD EOG4k4e7XQknoqW0CXDIhAqLToe/eKR1FRxOjWchgFyVcxlWV7Tsiw5kRFVUUmOIvPo3+iU4Fisi nl1lLmCrEQHGz4A56iMrWAQ7/mJJhpnEc6jCk1D7WE13WUEjgWI6hQk0Qm9pBUbShwSIqkBFidM2 OYNAfEOkO8cXEaFwrMIIlZBlR/KqGJcMcqLgOwNKClp+kgd3zHMdRuEmM5wm4qCYPFPgo4UrkESM oE0Q3HzY/XiBnOmxgmMCb702xvuIqRB9Abmz4EDWUSfd6wiXnOCBDiKVnuGLwU9BtYwUTnUKVMah rRT67rDAR4x4E3935ZnsjlnsFCdo1p4DeB0SfmitjDj/QoKyioNgpIlUqjW9x8jASgp17+Ig4q8m uQnyEPX3pJwheUpmOWATPRZF+YQgO5Jg5CBLPCLNlsKflRHiUkBP/NYJpOg0O6Okdww9Aw5Gv/a4 uW8qHs7uaKFpXZ5E4inxOLjRakOVv1Kv/38GgnuD3Ur3OOvzdMURJHjv8p7wplkBShRsmOQwd9Mm uMMIoLu361KnvPn8jx4Y5bkOFcsHLQRxl5/u8pK9h1tBIXUSMTyn7T2icBbzyAx5XuHAoo4MdH5G O+UbJyfWVkNPiedpp0U3epw3Ozhi7K7GzZyfuY072zDoVWzGKiTevYxrFXaiJsrcYrCGdnqqwUoe waNeTzEgBy1lS/Wo3RkJGXo5z4OSugTh8JsC29pmch5QQUbI2BE2Ow2ae5jZsqt39zg0r6Vr4m7h sqtK0OeJjgUxjmmzZjoYk3WI0qPcvNp4t0pX7mN3pXB/B+dz2Dmror5yTqb/i9/hI5Pjni4Ojmwx h5jFVyVsOxzUnDZpT1eK7urInjXTpLlfZxYvbCpURD0DERwxMpGJH10K2OKc5SY/Gski+pc+B2Gg jf3RrmG+ov+fQYTJHnA7DiZkLuKUNtHJD/VnQnxFSxtHTl3eI855OxZ+fKKtNvs76CxnuzNsujkf s+G8+mVM5sSmrWGdHZpE75frhLFRIqKqCK1rkBwqI9Q6jAyGwv22E4d1i/OfHP56pqcoMaejzdID tJidLx6noEgTzXrqPI+kREHqiJXo/P5A+8PYiPA8WAr7Y1KP29/q676N5kh2SBw50Iu1Kgw/i4q0 ZnJOH0Lpk9YHKvFbKo8lir0yoSkG5Zfg9402qwZlGY9ivWU6HKKOey3U/J99UHHRfYjAkr+q+1v7 Y91F9jOV39e3tMv8KnW9Q4/xicr3XdSWrM/F7LAgzE2Zagsdmy8idB1Gg7ebmcJOQi3qnSQi7AUW 4nK2zJYaNMItssaOkStPzLBi8UhXd5dJih0roOzqHApdMcHoFg4YE3AKk1O9UE8DP0UvrXxGbBFK u96OuizmJRB8eU2T0qF4/c7Rouch5xQjqMTOilZAxOIkMXFcqCSI+OOwygorkPnzvM7MMPnKU423 Z9z0M0C/HIlo62+VqDXmGC8YMM16+ksJMeToYcf4u21KGNiORFu7B8M2X1wI4KmpXMD3j3oUGYZD ARUpvY02m0xKs3KeSmFoUl1IwOVBDFRisFC7XDS80KVJAsXvz5zm+44GJemAtlbA4zjH34REciDK b5esyKCgiHkzA6qpX+CHISgGjrB9/X19w9stNCd1S5KhVCVQVkLlkPMPlK78RMJaSgaA6CTIeiDm lNXPeYUvb4nye38e7zeXD5Cm3Yv0NJmouNlKqp8accR5Dk3OKKGOf4VDhEewwRGJj1TYQLOUc94p kIhTIUd6PB+p4QZV/91c9me5tTf/J7T0lB/8Aww8+R/8kRhT4HvGJih/4P3lJEeSNZYf+CJ/5P/6 f+T4FYQWdDn1/n+bn/eWEi8zH6h4xEYpVOQVw1g8oMxiVlo8xLS8uKRiweKmo17FRdjJi5gVFByj 1G9GDgHHxGgsXjjpzdMfpkN0FE40HqVwrdOadBfKKqvLdVGmb/DodOBFUcedXr1imdgdDEw8Xh5M h+gzvcPP0RIkVHkcYIBT3MmsVELHsoKmCp71E8H+O1/5/92N/rzPl72p5PNhusPz3Kq/K9DEOLDZ Zs9Tc8q8VfmcOS8r7+MNszzLE1ZVauE3Xg07R+OTeR7NjNQf09+L1l6wnyTwTtJk58nQ6BHB28jk j0gDJSgmCJhB48g4MGkw0IlJUhu2j56Dg8H+uCDOTsjmxjTTTGNpHM6krv2nZuaNPeEwcPlkm8xZ RUlfkNB2H6NzejlgZVfon4vIF8HulEAZSQopazKHU/ByH6IMiK9hlK/ma8s85Wdp6DvNz+0jrsd5 9v1h7Dc4ODx705z4TVVRVFUhT7JMJqovOcjDTBQNDNDXIv8NGRRVLQ85zHwOg4B1nsLg8agKTtk9 ZOq+zHCKGgpaCq2lyCmqKpfrPOdp1Ol2PAco6niYdptjvOUVRJFCQREQ12WJBARQ3eZkTJERURRu OJsaP8vedh6x5z9h9Ir5BRFFEPnFRET1KAnwzErjx64v9TfcrkaLqCZrMWhpu2bcnyf1OnT/m5z8 31o7PnWT8jd3K96opSBbwPbUZLFSxUYXBkZSkpKxyG86Bj8czxziR1GOBCkxGIlnQOSwiMuPNCP2 H5lBM0HmKT0yIHyFB5T7MHhYWYyPSe0Y7yRkaQY25ysgOqxIaRfIVGg5RiAx5x1JWLrYRjUTKnne dAYDOIECRaRHlJELpDHaTPQc8DAlIbeUnTtDrkEpFRQcC0hrNBELx4RNe8NpEoO05iYhbMZVuMGH o8E+cUEJHWJ0VGQopAbxEJiJt2lUDUbzHGGd2v26ep8btZ66X0KuXmVpCjbRHOBQrVGeUj1eyXlt cjDXD+vb6NIN9PfhQy9hY6aK3d17hsgqvQUn87tNITMl6ir19uwccgCn9c/s9mr+mn9N6Yl61MvK z0P0ZNgetsvuyMdJkum/5Z6c2PiuHbr6tpj6OT6vqKOxd04rU1Fh8vrWF8OaKMiorNBUGdp5M52d g3mUKhTvSLCIQHnmPOPENZUPPIdBDugXpnVVTPmatUeoOFtG2O+dx/Cr1JB/cwz2YoZh03DrP2Tr t7KLk/aXhCpvOrFajvi8kRQaChP3e42VwEp4aXFxr7So4ig4YiRHlohaCCh8/avm8jvU5y7YQdB3 y8YrKMmeXf+p4iViyf33CqNTMakqtPYlOTSVTnEk4wOJdfj/XZaiXZsHPVudXuTJzPXw6WB78/0v OlU2qkVVUfXP5I1Jzgy3n/RrMvn1hRtfi9mf+P7OX5ufTg+0VOFBVBVDPok5OKwXnVl7tLfjpzOp 1shLuwjeVEUqoe9oft8WsnGzFnaqCkye3+DnwqrWzNblVislWuntYe5SlXGaw9nQ6OHkndoj11+a xlhIZ0vxv7o/b6MoaGvp/JkmLp12ztYyWUFgqNpZ6rrboo88o90ZuaUm16/ncXcXwej1vWuhk5uT mbEz3UkZtmWduFry+S+zK74mviu/3sj9WdXvW8t1RsI6Wb3UPdFXLp1MTmX/B8lg+9yPFEsOhdzt L6X4mR+uJ81+SHw3HpB6rSalaPzr/dwzsUvb3ckfy2jj7rE/h6wvr9sVOGpIvh+2Y+6RjfO2o7M9 T3q4aLmVWw5HGx0XL96yNr3FVTnw3cLnS3Rkr20ZH+miEJrdze6iuEqvX6Hmr8eh0h62dGEHrzTZ ynQqKvIo3Ve4+d+8ELK7LtbvrfYknT+UZVox9ev75PzIwmOy5QyxWpaFNK7llhczkJqZKVRd15pf L8J3Q9dT0tW5Y0MnO7hCCU0P/ZD4n57prox8vC/lORzR7ceZ+PvOxxe3242dC0XWJSoV14BPZ2L8 va2p4/yud6VbU6MIs9/gr3yc0SnwWfTNWOsqHzh8ZmB9ZnGLgsiIjNNFTSmJeslU+HzOEtZdYlpu a4G8M37vz+3weR3/c38Zn/ZrBRDwNx6HBuloyXRQ7QZPZnq5c2iDSIQXRGNHX18y6eO45hwqCrtV 7h4/nHQUNOwY+43pp8RmXm2KJzqJvcIeuhnoEPrV88CJQ/0WXR57CZuWIqBBQmKIUYStHiPr7HAq pXRmVwlz2+pzIvupGVBXMKq934v7/3FFsm/nvE4TCTNQgaV/f9o/tTiFtDcd9VLMo/0bHCJrxxUW Y8XJqnXZrDj3kjymswDJURHipUwI0kUyn2tdjYjyL62vEn1+X5dzHt4/HmTR5CP85tKSIx7Dsqkc x5x6VDHzH0moqKz+RfIcMZu8Ys1Pd7x4yrpYpHKe1/lF7xbTrzDjIMSs7LSJWHNc/cNSoVi8SGcz jwCIPBk/zgO/qpULBElJCBEj68/Mw00zjLATIXgLO59H/guD5XAjLiiqlJjWPJQIBgSO4iaBi0jg TTiOFNBIyc+DB0fnNn9J7HEFlnQ5ogjgjgocJLs/aX9IJWIRtjpDhXXJhjzx29RAiQIFJgMNCsZh 5GEiwjSXuJlxXIoJQkUNcdNLzR5jafOURJEfoOvtnrXklTEoqxasrlU/uU02TErng/axFYIYxY1z n2W+J5z990Gb9lHkMwhBfsQ7MQmDCq23/CSKcr+x8fv7RzgfL9ocUL3XxUmmZTvX61Xi3SodQuea IZrsu0edgMMcD0l44+YaBachPxJqco7nJyLcHX95AibyokUTKRlHM5iJYTfBk0ZQgsQOOPBY8FZI 9iTAZHlVJDOWsUVU7N0WEFlElwOOj+MQYMUIMDOWGRXIVAsiJHVdyaMtpvVIzJsyOFEJvpO4UhiJ x63Th6akHEhrc+O1n4OkVPaRs2/JnHTSh4e/wMSkxQyHR8AOSMY3B6jGEfsPhAn5lDl+XknU78eV dxFOGS7WtYBQHIvtSMz4tyXIEt8klc5w/m1DZmIbEg4GAdioaY6L1T4z53Jorz+xjq5ORwUqcKYc 1dzRvHotzmVpuXFc38HyOrjkxyOrZLNJp8Z86ncpu7HI4TDxY0VwVHRuxpSapN/O8jd6HH/g5seP FZ5e3mBJRnAlyDoFBIhB9zurBNCOP06+7iaTucrfPj5dVgd0LmIEuj5DtQkJJKHYcaRX1OjhsxVS lJdfEnzt2zY3Y7VaY2KzSNAYcPHoHaSO4/XItw97MhUhzDss+QZ4kvMYpX3e048+HmMqIZCFP6oj QqTfhP8PlnZJYOMgyG/D6YiFB7wrYxbRZJSyS0dGGGc5w5YKO4Cklcnn1lzVuHlMZQ5sdnA2ihQS wDYssxE7zPR4R4ETApJjhCAo9HB5HDxLGHtjYWi0PQQTEVEAeCjJoSk0DpVkyoUrqHV3HqNxn2Gl qqHlGM4J8bO0pho4rPQGFNykTkORi7lvKS7U2m40ZmGRE0LM3shB3zGYzP3ETYUoQvobzgVKMqN+ 4bOwwW5ogwNnSoxoS6ZwM5H2jnVhy3H7rWqmHAwZ4yBGY8NStzYmTKNaULyd4M2/g300NjGNv2zw Z6Rn2GiCbb8Xcvi7O01BjWilFSlPf5R+QpEkRHZzm9bgohCIPPaKXGVMatQagwgmhZS5Yrtdccct Gx+CzKt+h/Qx6n3t3NzbnZ2T6He2KrdwpTEqn9ivIfOcNFaKH0ikjyl5QKRIHwJloKKC/XqHTKIF 9Se/UOtY+s+fzGPcQfueERaQ46ENWNqCT9GKP9BTOdTY5DMYdCJaTrh5A2BmFMhjF8Z9GJF8jQED QQC0ou6FLczEU32gyKGMVRxMAeObkjaaqLClbbba6OVMk1qZuv2p4vMdp4yTB4fRDDr+t2bIm9qM n3CHEV+aDoo2WGBiATS4UoKhJAOS4h51zqnmaHRFtdTIlIlhWGG8cbAxSCLmkITKmEIBiegt0TgQ CihJq5TeG7f64PwowaX17+EMivi7tlfX8bVJ2lJkHQ8r9kub7l+kmHg9bcOUN+Xw5nezRdWWQ+C/ Q1j6lcvXZAWhTAxGM5oOA491FFR0sGQkSpUVRFVVRSWKIKUYihpaWkCgYkKaa5/5w2+/469PZyC5 ctJoj0QBQGQ0BMpTSFCUlLSeaciJCjzhBke8kMkoAmGloT0449JznoHBKjMKdYVmB9onC4i6ogkT 3X8H+UyLRUq7oGxg8Dn4eGfL4/1xzj2JMkEZOVFIxDFEslstUWWfP5+T5H1tOHD1cJt27fc1t6Cu u/OaNc+PcPIcJxNJSVAFCRQDt3SVYNFe8uJJVspERy3CugONp86d1U621WU1xjdPbbgdhjUCzDkN hUGJpKDaKYjzOKegJAwKOGGFcV2HJNj4WN3obNOid+72t06K6MMBIEB+X3lI8iNId3dRASYUFjDh xZIcFm8GYgYClZmGPQcmIjw2CQpJGcH2FhaRFLCZQDx5B5tHiMMao0DrxRsCUkeKMXjPOgeaSJef WXqQ6+k8OXpLztDP3868snj0Q1CgHFRE+KpiebEHYc3Td3WkJyBkmQJuquYTH60wWlKqreWRyU1V tX5vhFexjzDTDTSnUhhYMYyDjbGNdQmN4YMpop8pZWmjds3UrZVTFY4Vu8zdTFTGm7Dhw0aVpumj 8jvczZzKlcn1KB48encPHOHlBSMQTE8BTgTYE+IpeZKZXhwHgef6+I7geHl48u7bRtRTYYUrtAF3 W2WqzXJ3uG52vnSdY7eHmVzYbPM+M3fzqeTk4lVJuqdr2HQxv0c2zFc3saaVdObTzd7m4cDg9zQx TmpuutOjZ7H+hXYro5uGmHNTms0qt3DSaUnDRVGKqzorG7JjDMXFOqc3Dq+RpxyTm72Gzk+petl0 2KqmGjH8GxM0WDCsVjHhXYd7uY38j4Oevuet2uGfPI2jgd/f5073FE8nuQddCNBbhsZz2ILJIGKE Kc0ujfvIbVcy1VkNDRWlXoXXpJCW8p3Gt9mELA5dGKYvCQfQTNoolJnA1CiWCiUPGEpkbR5mIC0F A45BFRMDXiOJENYWGFyqo7NrkKqK2vj7ef6BpSBQRDXrKSR4lpUbi8cU3ENJ9JkbdhsHGRFGPIx9 ZyDziPLSg3DDCouilIAxU49RgjcYYfqT4GU4IQ8PQvCeqWE8QneGARPITXkS06dsIcj0C3Ga31w4 4eaR/5fp1eG2NkGa4LmBPVNYo8IR+WUwRLQQnLkeG649Sw0x5HD7xBgEI7jkjl4pEHmJrNIkC+Ah mPezFFVI8tmMX4DzFh3QmIIcwaWAQZHGnS9E/ukahZNaNGyQ+MgQXkNENt+J0kweaFSmB0UiYzT6 nUQjkcRBpDhWONFHkycEBdX9s8r837f23+4o14JNk+h7njE8ph/bUwpKcWW8HofERUlHofjZ/T8t 8nBgjaNlBwf3iK6sTiF956kkBRk9TgcOdAJsdwpYe7a43VEwW9FYM1Kqq5yJWFgWOIRefQZ0y8Zs jsPAkIwZMZEH8x/DsWQVe/sFMhUqAx5A1gpZm9SQcVnpFGLzoL3FRdAyIQhCJ6G5OjJ7FnjYfHdf lf9xk7HAc0tYLCkFKxLiJTcx1GLu2iAnOfcWqien0bj3FzFpdep4wRHWQLxfcWeyj0mrC6gwjYMM lC6Sw/jdxHmZ0B2EY6J2uJXM5w1nf2G40oho6sf5lGAq6GfobgslivYlv0UPPeoYSSGTVE0vLzMH 8zOayJEri+vDXXlwm+kZUk720frXtIWKPsswtJ15S4+ztoqkKz8q8jaOIGwjwudXnuktxWZfgnmb cG9rD5TxP3br7T2cAZrUEz/JezX7FVPF5LTX4YL9/IchdNdAbchY46SKkhpDlMmDf9W6MRYIihQM mwoKiO2XHEpFP6GckOP6V8MnHxjo6oNeoqiXAdMoEk3cUZQ7Qgea5DmKDCmp/inGMI/D7Pde+m4N AtA6bR4Hb7zrfseLoFwtCZx/MFhAxzC6b1WhVVCDGgUQPEcPPL3/A5zQbDSdByiKT2l2YLAjvXiy uEcDFTBgc4YBKmYe54Xc1AStmc4oKPBhEoBBddw58l7HeFAx/PiDThfXhYEGhyQkPu/ZT2cOwkHM 6x0ckH3FZwfbs5PgfHnr8H2zI1zxB7wUAhLaEnUjxiJP/6MfdIkkL6k8b02lKX7b1J+HQaIwGmQe AcHwpWniD7ofab9Vf6f2aLnGPoBUALqgQeXqww6GaCNAUTpdZTgkFXP1xJtRj82ZRoTQTnDgGwId Qw84h08x7DkC0gXheGm4OkErgcQhZlQt71Ns8TEZNxmKuiwMKaouGXygoZHj65FENALgVLfHkNZA 198HWCbNJIrwTlf53NuLyIPnUcsNy9X2603IPOcn7Rxa5vXorn/Lsvunp2WPNVBKor8mGWPSbjIV jNHBFh6cV1oQ6ioWF0pHfRgvNGJQXFBoGKnEBT9Aw8UU3KGmI8cRO1jVAgEoiDxXFQxb6OYejVlm P0FElklmXnBSLPqckgwyK/2FjioosmSCLHKHcVOdojmSChY+BiT2EH2C6SOtiUx0z2mBwomtx+l4 6gnzESrQeQg7sJpaKfAW8qLzEtPJwKiJNRRk8GbRogPF4mYjUPIXCnWWPk9Z5fPw3p/Ocj95yPn+ f77iSdpIRJ9cugkM+c0Uf5NvP4/D3ZJwrAxERjQj8LF+8wPztOXurYBzKwqHMe0uObh392gc9V+4 6wgcBRSAPLLHKpoVEkmCCx6SZy3+1FCayihGhEBk/JjOnIzogyUGSTY5cepkdogwe5g9zm5H1MPu dGOx2uxp2t3NppiYqZOzhwTw1T5cx6FY087TkqdXJu2bMHljm5vAiwv3sg/o+kF/G+CB4VGSEByU HkxtfxHW9kkY+crK4MjgvW41G2DyIK6yHrka0NuWKFsi4P5uh36+QWw0d7SS8y7fRsTv+HX7hoDM cowWijjzDiweA8LjIkaSIXkSQhMgg8efC+DHOjVlYa85mxsbegtgqGCG3HEmNMNWelcGU2PFurei h4yHjKUp6RiscffJ5UdhmLSkgcg4kMOHgSM447CscQPmZOo+7z7Jl7f4wEIZkkJJHJZnisW7Jk7g bO9XuNm4wgxwim0Cn4c4vlD1elpHrNQZmJVmY1lgwylA8CmZ0kgHYdnkmVnvNZz2WA3USFklxksg IFBF0JGJySI6xaSKIg8UC8Tymgp1KkNWscCAeGkZ/3Dr+3pKZQMiIYmGgV7ON1Bs8DRRM2C9QptF HCnIfMVm0mE3UOLiY88pIHik4DCqcBROW8dgcCvKuiw4jyw9Zp1LIDUO2zUgKL5ikj1C0vMHJaPJ kh422j6VtVMBQ4ihEUcyYEzcUm4zDhUGJokubcUhQD0gZxRjwsNZQeyp1ROfNtraHGLDCzIqyN3L I1JDHHZGyDJFEOhIDBtKmszKaazL82nsGPVPI8Hadj7WR8HRwPMVsxVNMVbpnN5fc6ns9LtdGc31 1p7m/rdoyOR2+S8k5FMXGz7s20YVV6TMKaGpZtuw76dFe7nu7ux2K/rYV8jDCmLE5zQMQK6goPOQ PAeWljEw0FusdYKiAxQWo0pp+N1cmmN2mMMexp63p7e7JlW3KsjGeKKM5EIZDLG1fkNFuRg2mt+Z 4EEbO5k/UdGTScRHdzidC+iI4CShI8nIe71K9jJJyY8Hg5I3WSclPO6urzq6u3ElEzGyWgQehI7N 2DDg4uRw++vXeWP79ZhqOi8gopopGgt8AMikZig1IDToHFaISwe5eJJPIKWacCJwRA0lJkMCiojs VHoehjdw7EeSxbGzoqdSweO7dkrJXiRw6nRXY/lvk9Dudyu/5V7UbO0XTYsl0FJQWD+4041kCKWM XFaAFYomJAoVFRpCVmg0NOEWyPZvw/E0fNCQkyNudv3dvx9C7U3l88U/sqrDp7qHnR0RpG6+RVd1 0RosoX3UGuvuF/JmedQrKiqi22uo1mmL/W8ZxwhxVVVvaZAxmOQTiqJ88IDuRfsSmOoPfWVGciJy L0CqX7w8gyI8WwFQUX5LvU4LSrKgJzCgeJSwcm8/E+o3/rdB/+fmdu7aG/UjEudlXO49ekk9S9yk K6tZspiTrVwfB7/UZiopWpi1hZHz0UpQkRYseUedXiw8uDcu48Bi8+by85LVjoYgnMH325s0ncDb uY1PzTbb91G2v+VBvnr6ed3Wr+43asTkuPmK0zfznM22NnXUKU1D+rutWJp7MniqtPPc5Nq8uIWa 9Fg4w4IQVPqURy8hpiJeYnlKSw1EwUUkZgzHM/05dYdYH18gSduP6HScP6Crv6iBtD9kjtP2n9Sf +RQlRVIkSIHLE9ZznPsLC4tHf16BkqIEi0kNUUxWakSHY/sctO1jOG7mrmqbOx/Tg7GZLrDkqSes +d/U+2fY+6/B9pPxlI+dFBOtR21+F/+5gQ6lUF6fkM7/4U8h/7FuXwk8w/+ZvB34jF5/+z/3PuP+ 8PQPkD/4/9j/yf8l/pP7Tb/f/ygAfCwXOREbf8D8dijLVotap+960x/+X/PIP6X8efZ1wqz6/98+ h7yh//CMT5+ekohD949kQewf1XL60RflEefQjSFO0VEyW/f9/xNGw8T89GiaPqwMP2/DDR/eHtMD 4kmuqPYQPDA4puecxeV/1/+IC+Bi/6s5fzEh+uf9yip/13tf/diPUwXj6k/8MA38sOGkUkR+yX/j T/ZBqD/OQ4IDWU5+MzDVJkjkWM/gKMeOGKbJaufdkS1H8s2Y+H4+GpE/m3GcKgCf1k4Y9XKL/GvS N9QwlWY8g/6HdH7TWC/sil5MKSzQXuP9/U5kJ3szvqP0/u8lEf4/xdl94sHH8TgZ8sxt/7oeRcjl /Qcoms9reVKThbgS/L4MrbzxP/AMUGhJnse0/i4EOnL/ybaQ1/pPUH0mvh9/q7sqTk/3ZsbSOIM9 xtP9ul3ADnod4TTi4GKkkL8/NDbBhtFo4SuAgqgb1VQVF5w3n/0FdIF6ZtHRX0qIR1W5ZrqXPrQ/ zLBcSEPKKhtB+0h7BOdOFxfm8vpbMuZSkre7MMWFoMM8iyIDyMNtpE3HJ1f8+Lj2WomZ6qvP9b4H 6uQT3pxuzpiJgjxKHbyQ5I/3oo938/wk89rB7mUcOVUcx7how4iy/m36/83xQI/0csJ/dU1angaX dr7mHRPz5mzrD1Mp2o0fnSRY8ZaVUY+r/2SfnJVcH77i0dv+ixlJkiRwRGYJ2j+hRbeylTD/yWu4 x81tcYuHKzOdZiM2DVKh0PZyymML6f/zHJff4X+r/sTx32eRD87hj4cLI7ygSbSA07j4gYw49c65 N+kFyaMkE3Guz6NXokvs44c+mDhbNHem+cPT2wbL6BxXidGecs12HdmfK+GN1Qyh+Jm3+qba83LM 98v/vDtOCG5uTaDE2x/6pWl4/Qeeea6b9Iu5xNL9WHjvNhdT5rydG8GeibcYGzWPTmmfDUG+2qvq aeen8cUeL4lPEz2+r11lTOgpoUeKORTep5PWx/w2wTM/2in5BV3HrCRUodh0ExROkiDgMT+Aes9h 1FwnxBjWfAmEQsLCoUrm7y90Q2xZTHFhJbRXqnYp3fDqcH/0iqAlDD3k+6FzWH7ZfrkPohyFOfhm ofq7s7LrzDwUrgx4L1K9YKwqZ11cGwWU+LhJC9CCrtNz5z9Dbnc+3x7mlLKjhlYUyn+1TFltqqXL nxvM3fI+RzRsquj+1hpFf0MPU+t/G0IHIKfgVH8z8B5H9NX7LGyqb/j+ynMGBIqP7jhtCvX+zgyf 77MeKzlr+F5Fner/Ln11P/FXN0Kqqf8R48xP3jFJqOgcJ2HES4Tk+RYjhE/0P+Y8+0oIgpwxJP6F Rjo2Uxmvoaex0cYuhxx/l2sfUoqcjNb44K5f0WGVFkn/Vvmiv+Q7FiIEx4pzzIDlEf4Odv1FlnD/ y9THst+aqVOzs/W3/+lt27zhhw/2tqfykg1u44fYt2L3Dp/8snzdyBx25/43AShhQvX/O+MFl+zb qrlVV7iQgaG/5Wv2+I+JzfSZ482n7VNbZvu80lXJb+5bxLxmLFj/PD27Sr1iDRF3dXGbST+7j1Ub MKT/DLlSzjCmpYE5T2lUDNvDnDSMf8DgJDFYfHk+bTAOjzshZ06gGpogS52rj9tL5iqKCnCRE/Sf aMOHAodQ4OUd/0PrGFMS2vWs+iiySs8gPv5z/idx+ol/87GTWKp0L01NY3i6Lu5uZeiF6xwmqDtc jcLpGMTIkaBUeXU4zR9EBrVzP6fWmTk0RhjWRkGR+87Qw0fKb+w93ho6D/i2o+BNKg6UZhSAz/0I 9OH7fVr1G5UJVnlVEwFOn8VVV50vvHDIQPzEE/wCEDsgAvmxUO6rtsqr6qhDJ6F++BOYlP++U1D7 iPOeaf97fP4ZtB6W8x7zN6ec42ehw5G7hy08GE3NjCqfQ0NP1tnCtGMf8Whk+DGSrU+dzcObede5 9LSe90dX1sPFN36lc2zFdjyTbpviUewaeKnef6j6DdsaO4bI5PJs0UpK0wrdhop9ZiNPSbH1qnNs qehGP1oo+rauoOdAYQwE5+S60QpO0YYpPi7uy1FYf/jj0ufhRehErZl1M5wsPO8tLqRx6U47WebV JBV3MmdUA9EG3YXBQ3Q97PmOFBOUgfRL+WdT92Ey2hQ+qVO2A7ocgd5cjlbwcpPltc8BOUcrUvKd SJxDykU3jiV/DOp5x67lKGp2kXlA9ZHldbeCnpKGQnKRYk5wu8A3PA3kpXJDrClInKFOkK7SBvBv BylecvKHpPWXilsk5UG9It1SFsbctufxvPwf5r7fOy8dhEUcdZpN44kKCh4VOo/yIDg8+1ydZ4mf pzX/lwLXDvr1/uvepUfsFCjqplf97vKWZlm3O+4gP+0YhJeu1kSthjzC00arB4CInR8xDqNJal4p Izqdqo7BhM2+Dnm58RNp9I1RMec70YUfvYgUlEOwPpFD9Z37j/v5iHl+w67eXhBNCMKyK38teheO YiawpZ1LhjAqIm4bSDKWmlwXDaD/qREKR5V6uZxUXGwefWKVp31HD7th5PgO1/PyWdq7kEKhRBNy htDTt1Hao0XuBwkQcverwzGq4pzeYs0hzKSJHcbSPvarLGpYnxUoq8B004/aOKlB5aMGgmdI8eBA U3jFA4YpKibig/nE+wu0nrJw5zt+B71D3ip82oZBynqetarQM2tZs4ZExkaswMIfsRZRQYJ73V3P k/hbXpaVTyWfqV9O82xNPvdGk0EGIh8/wDozcZnzDR+z2+PoeSWjni05kl8uB7jw+K93WPfSVLMv nU1CVyazWAe3Hl2CJgqRdRbtLfiJsNPZlybPZijA0w22tFZlRwzTENqtLNQWpAzOMretF4NXSe2I mMQ83l4wZ1T6jWcaM3OZulMPnObJzcLVqbzQXL28afNaWbeJnNTWXjU5jFVlVdmafSzTlK4ippPD 0sRmKzFqTLGLgjGdKErfVsQmUyKKVqSZpPpGlTq3qLmMWFF075SfSl9zS0rxN6zD27Q141Nm4ttT WCrdFmE85plWYy9YukquL1TmaoxRWpqrSiIkxU1px7bJl3wiGowruayttZU4rcusXgqIh9qiM5mU yIV6l1KM0ZmbU7uB0TtUEF1Dw84xjVPZt94KoktVvc7xFZUFZjG8bdYHvO5lTKus06nY+6vdwlVv bzrL3SW4QoS3p4bG4iMwoNG5WZzLPjRtb28U06qtFObHiXi82GdYT2z2k5ZTHURB142e9VGH0tZN j+u8Y9exGPaKMUncV9A4tInaKOpulMgJgyMRR5SDhjceYZOc5hiHiproeLrucExYiqHnFSswHjgm YFWdxv2RGj1OOlV9bcFd3S0wbj3SLVE8wqCqh8T6tKfAzwKkZjLqGDrFNVdxEMON5UnNR6+3cRIQ dQTGGJaBgoS5hpOcFxZ2Fvm7CCchabzoOIKZjSSO++LO8ioo89PVs6LYJ0SbnXknvN74wOg/2nOf mdR7rzzEiqhzKyiqKtFfQ20rjyNv62RPyFkLz6HHH2kHGkU2FyRr0805nG4KShUn5WoVErO6ThwZ xslDrVCwecrGOjum0gpIiJaOFP9w6KoQOcKioeZ6A5dIx1iiXRKTOTSBRALSI4qHhHnQo1MUBoIM h3HzsKqiqqKcjKsvoO8tKxdpZzEb3phdVQfMX5h5q5efsOAyIRVBgR8ySD9edc4+itIX+z+1yASK BoPjOI2YL8+jANERCMShhIh9SjlJblv/9yrM+JJdCmAUZbGZmZmGag4A972ZspBcKKKCkCD3+fyb hCoFDRAqKj6hjUbjmKTieUxLx59h6jmBxeUlN+FH1RuZ5OJiaM81Xlc/SEeqdU4ThjYX52O+8eMf p7sIi9Rhh9B7HFQ9gEj7WPw9b4vxCLImdRNyPGQNOiDOdcyVrJBSlTIPJ/8FBVCZ3nA1lhxPgRLJ mg+F1AKilnZu0gHbBMpECRVTRRLE0ERUUv4rho/RA7QaJoSgAoQrMMp+Bm/538TTluA5ofnvRAnx IaErzS/UGKtfga3kSrW32wLh8JURiQijFwSBxsg9EndBzbYFJVcwTh48f5u4PVaPXGwfIoyH7GYg upBh/eC5IR/0Nf+XGxjAZEVshsKQhCQEsEk0DJKRESMBJM0EQRAQkkgAqAY/eF3ayA777v+0xF2I IIopmE83ubar84sG8TB5oA6M19UeTX+j+D4j8Xx/N/150zn0cvQyrDy/pxJEEHhBLItqKEkj5SBQ UQME7ZJWh5QGL4ycYTtIxgSJIZJgWCRImIIaCSIGkmmQggmiiAAqKlQoiKShKVkkSIBoSSJKJj+f 59OvSYYyRhYxNUtEhAJR2wuQlKpBJlmFhQvrhTKJFfplckKamZQCFFI7CcoEGhS9ZgI9pIFAOvH/ pnvfbvZwqu0IzAzKhQBRBAkSd4JCGBMRBCxEEoBEqRCsEEIwQJDAkqkMoEEoEVFKBIQQQLEikEi0 RIES0HpkB68xP/xGQOzKp98klTFBVKWduGTMYUpDUhMhIx0dDgNCCRDQ2nDEkRKKAWlWCAGCUGkQ pKIlWkMCyYhSJQomVMQgIhV9MCOiCGEIIWkSKXhjCnDMUGkKVoBIhgmOeDhDEJTQkSBSES0AhjcU WrKLSrS2wiqFVaCmigaEGmiiJGYWqoRtP1UEyioLBCvkmDFqRbVQpAGoIKVSolX1QHUgP3wZzUCM HxEKJpdF5iFQz6/5/t+95ppLYZufMb6NihpoYgYSOmKL5ZQNHUwyAppAoHtMwoKKUQyHKIqkHICg zMyKHz/TpNNNeJIYSK8yyEZYqiHoURVSR5qP8bCBtI0QXMkMaSQK/PhgRCFCvh/00DoEF2yxVDJU ZN0OAxNKQQoQwqAQQxCMQhEovbFIuMClDFEhMUKdIEHVIfukHaVmVQ2IA9RgYB2xsVDJCLQtKgxF IUrQ0okyxCUjQG8qZDElAKUlGwSThgIVSjEAUi0hSBEpEobkPZKBlokYhU1GQJELSHrslWJCRamo haRoD4/jzUskJ6sHgc2DtfNgmHs5Y6KClBpClPSwJSPqIDT8cRHJOuHxwf4Sj/lKJvI1ewMEU74E PKEptI1SGH74xA1ANILYYC4VKAGpFPnvjlN9sF7oOCVPikT0nfgPEC+uJHFg5xmRqk3rSkdlidOz HZvg6WN7qxDspMofuqdKkNWD7aPV//P06Tb34Px2J/tojl24lfFjzrOeN8s0jw/x7urztz3dm7pd iqVYsKssdfn00T78PR87W0D0ULXoXLzcrHNLFUxsCkE7GBnooi7twfg7fhA7Jd/JyIA2LU8XGI0e woOkANEQP5SItJ1rxt7ckcNzKVVMWbaMiZT6FdTsQ0mMhSHEE5o0ZtjhJ6r4idBbiTAhgggiCWk6 ZxoZO7oxhSaVVYYxisWSqjLDCwtlWKlIymKxRSqwySsMMIwjCMnGGgwlcGDGTCfXd5oxIC2l1Lon 6CVwhDaEwhiCKVKszDIYq1KtWRcMMUYUwrEyx+dV/orNZsahTTMLlYYMQ8CDSDqcT6/t8V49gOnv 4ujjhIOGKkGYUNtg4R51/tlXtkOJQ80tCeXbEd/AifyDlxKtbGnhDiaVpsT1U5V6Zn591p8cbkzz rHmTqe4aHZxtqDUhSUhQtX8+IYfanE7TgNJoyCciRkxaUJLU+hQP++jaudy/LrJ7Ltv6L/7HQV5j Ie02xBPyR5loNxMNt9aIpt8K7pmMaj34xvG21NLJaqjf/Of2pacq2PM3zhzZlTriMpZIcqLUdgwM NBopj3lgQlAxBSjJDSbGNNAu/X0HtPi4Nzc5758xIlontoEGJpasVxkrsjWgcrH31HFj+ayGKjsQ p5Oe3lr9Zu7SrxgHRq+dORhBIFjGOiAgk7sMVgIIXULQmEVUlSlKUpVJVGVLWKlUqilSopKpSpVV hVKgjCCRIx+g11NY7GJC8rIq+3VYuXO9cCOoeMMTB7YGxzXLRqRIgghGdYDgxEMMuDRABhLhH3dO nSpkRNMMJxOidXQENZwRmzmXYQZGiUZJUzEhMjBwiMSQwocGVjfRokMhNEqZAhhi0GGgigkqUhqx 1INiREawhgaIIEcsCIJaIgnCULEcnFkQiIhUpTEKssxwEpHCR8NOtCGYRGLKxUSJkR3YjhowkihZ IGlpKqkoKCkaDeyRtDiZJS1VUNKUFLBEExIEZpDSmiCk0ViwYrFJlMlW1VUTFRmpFBoZVBBvP1TU 0kCjQEgMyqgyjEHJSzGAkQwO0xRwlYloNQZAuQnvJTQQpSHAsnYiLAsC+Mh0RQglaITLCoqiJCYg kLAwiCc79OiaHMxjSYuMlphlzKWySrMZkBbMZMTMwawnMXHIsw9OaA0NAqUZxjoJV6fJmiKKZ3DF pUcGaIzEgZxktZlJjZWimmIVlmTGBOlhpmhNQmLmA4T+kXN4/ojeoN0IIcizPFT3Eg2fET4f1X1f tPnPS4eUDBTr5f3pU+c+71b/EwPofHugBRqk+FnYJYSQ6I4TPJ92X4zDrAewnCmoT9gNg9qAI/kI hmJPBG/fsKHqE88eeeu537hFqbaw1bylMp96o5M/2gQBksEyOkqkxXlLGcFXiGNzB0Re4vvngcsK WiMJwdv3/39imnTv0caKNcRDe/ioMGhCIMa+r83HDRP/fGCHnn57N+XyIgr4DdCD1TCfQG0ZCUGA lyZjBGQUtJDEgCt1GnMuVwfbCjTW0PBHtj/WdpMs+e5KfMxNat2Hb3QN2+Wa66PPG0N4pyVjiRFV IyTFCuWMV6+3WlSiqrg//nlxTdTdSViV5d/RzGhUKflO3Bm6IjhCPh3pOAxL7jQzCGEDhQwgwHbA TYjg06ZJCznE/j3PqpnSVL0Z4Ly6efdJLOIE1thQNycjciBxg/tOB3qlQc6jzNmq1bt1bG53G5xh pjHOThS2W2repyaeZTZPRfcfDydjt/kdDgPM5SGcrLSGJ9gRGB14potHDkS9xNw40hJskjSZIxv6 /rOBsMC4Gufn7WFVoObUHyIthwkncT8ylUnY2j9+Md5UtXhli+hUVh//SJAN+CKQBQ+ZJjzK4cME jMfpFHsfuFGQ+ocFoMOawM+8tOxRhKggO3eOYiiGCKaxKBOomeH5lMrhD3DVHSYFkSRcKStVweFh FURNHVuLDxRpHPeZF8uBXLWS9L6nCZYhrTQaYMq9u2AVG/sYENvgejGootJlEwVMSUMKViYmRxMT TbAMCH0naCdggVk0MkGAoytcgKfqcV98hLEuFOcQuNhTARAfHNZlmrvEoOopYU/mD0blC0Zy8vGx yhumbJT2Huent//Fac8qeH2PS9OxglbW1ikWdUB1hyPu8sxEkGkH5o4ippa7suDGkeef8m6K6G/7 rHe82vmeCSfUWJFpGCpiFvydaA1bBvrLWqyfDzM9iTy18HHhhFMMzwcgftB857B7SUgkdiD+lvwE vSV+slGj9zEif7FTZYmyvpKaecyBixH22TdyZBl3LIMo77FWJwsGFplKANieCH3CeRC/WXMgHsIB S0Q6LhhygJyb2LUSS/i/W/i2FIXIhBkhhwX3yESO+Z9Rz/Vu861n5ZPD3MPf4566T+a30YmzMCPn CgklvCUcdA2O0/wlv6stkTHJZlJvx/8xWeEGCNJ6qujv8g5tSLEuR62eebQjJaKGdbllWhJe0dS7 1/UPbUnEzpjwGufnOlhdvc7B9a5bd8l5tpgQ4drymMBFRLqOhPeQJWJ5eBJAOWnRcEvAEARBM+og RMgsKjBjxKzbvZLVNl/ILsPOVbUEcdQFw8yEQUZCYGcQ2kNRFX4H6Q3iJ+kU/aGWc1kTlD9oZy0r O4uBBgmaawpLiwFMTpB5NOQKQY/xJicopoLkE0iiAh+k0aCwl9BVwXtKABg5jYDaVmtQuBm4PJcj qwidZQdww301HATlCYf0vgH/hwq2qvxqqqaGdfr/O7fh6nhyfCe7I8JJRDebWTqnDaPO9bSet6Ds MhBhYSO1SKTb8nX4b16Pb+Dl0gPBSqggiRQ2uok5HdPi4+goBuIhm+dFUY5q08StsLS65AkGnQic 4LyrAkrWngCdRWBrE7TUHvBDrDAHcR+Yw+D3PM7HwPYTJAcTifQaedsYyJJO9KiUqSfWKhu4YTFS KWQxurJGKxTFVX+D8zH/A6P6X0pPJIdX5DSmY9T5j435zX975DyeCqo+4pKpj8z5WzSu14E7Riik 0s+59KWKlnmNmk2FfYyJJ6zZWzGohp5CRSVQ+V6zYp6zTeQmib+LqnUyO47ASIG9HoSRDcI87DnL iJxFLDsBTOdgxR9od4avq54OmjZJVTUmZth90jRpE9lAWGAxYPcJPNP5HoSdY2kd9HccGPle92oe gbJJ3jd1VzY4OSqr6RhGEmFH6X3OZ3H5joh7FhWnh1EjZ4FfM7nnmNGlK0VpX5xppZpyV2KkdCuT N+1j4XD4T3Jik+JhuT0p8j/T0O6jYeR4j956TyFIoIKIhTtwKuME2kDMXygd0x/FXqKopcUiHIb8 RGBLOmy4plLfzH2kbEQ+grERgKAVET8B+NkHqKirI2XgoYJ8b6z6vufr8Xx1z/qKcngOHr49ViJb EW36T6tHefjc1iFUU2WdXB7iKcj+s+MORocG4eo9IwqUqqnZNkxCqSh60nwnQmkfQ5KVSnxMYYxj Qdyqr2pVKbv41VVVW5j7HedT4xSo4Ym78jCaNGDDDCOTmSqwY5IfvTSSOxVVG47CWLV6piDhNgm8 RQHAHmHqdxoAvp+qLaDxVjeolPYMEd2h1nIuPOL8q+d0FHvM4OQJMQ8w8Zcgoa2iPfAihsBv2LGZ YVA69+Eq3BWaVmOKXaoKkXCcilGtOfSOLEg9kYSCAqcqhpCsz6Mlk8gTYJVrpUEj9iMWS/8dMXlc OS4edOZSBrm2iu8BymAo5XKI1TVHmd2tS0/rYw4PXg7Vbe90a11Z26F23qtfPdmvQM1wiEhoHRI/ 0MS5mjmEKCgWNivBoq4He38ONRfRQuYLjbURCgPe4CChCVCjigh84XJ3HI3+EaXTLNKtpV5iEnJn HiMEVDnvQSiA9zCtD6bKgfrxVKjXYc/42Hm+17IN2pSCKQg0n7RRFNSfmmmDZfhUF42sT8Zr6YYY A8VNUgrPecg40FSdOb7UpkBa9FBSm1PUCom4OgHgQzqhWRozqrdS4waRgUfA7QUbUXmzVd9Q85cA nmKB1iZ0oifBnoPBVUvA9QhgUbEe4FsBNaEyLk1RGMBLBiSielCsRLCNzqtoWIJcIoFwFF47f51m auYxLJ2paXAMKGBgHxFRPtWslQgODyl6e3UQIPLTean16S4R9AeYceWQTFgjHHU2I5nUxJkIuDDF CqRzMUwgmSqLEZS1kjGIxZDsJpXe/xePE4kdXWe6dyn830ylfxVyKGKn000pC2xXaRHJ1A5AZCem OakNCTR3VKI/FnH2rZOzd03PoNuAPvMCP9xkOychj/Yim0jFhLedXOxnyg2DDw7psdemp7r3XSgM Vf9BFUQRIKEYQO6sfqFDSczmCw7yavrHO9nzcq3E0vWwWyq1wOi4FYPnbU6BN2TiyneDpTB+0VyI fSoiHCoeH2zyB0b2CpD3/eq/SfJf4tor9rv7WB2isVn9R1qXp2cufNmERHKCQeIdRMRoPCZJfbAO PO9wnUSoPrNtIVCkCc0RPpEdZ5gZ6IiCkiArhMW+kd4/4KWo5SaB4//j0SaWwOZzyR6/KBeAWhGY oOFRDcdQ8Q+ZNI0KduwSFp3F19+3wBqEWtDAucWJ3VhGS1wm/GCShl31ygLGAoM9IRehuzLxVHKw gUOE8e0ZCEHuJnmfa8VVRavUyZCmu7RL0FFHq5r4Xfrq0cY7Z97t8DunPxlnE3Y5Z71i4toIj1k5 zjTu9DnmtsVoSqq54Mtwu00aXBrBRQ9UsH/BPIMHzKFaKazVkK4bHTlkThAZVHvjlamwkFxSZFc6 1yM8n3VxGGTU7WLoU7ZTn1GL2cnqgxgC/Fy4ZXN7a/LIRlyeRPyoGNHKn4Pn/7fObj83fwXQe3Ii tA7uuKF1qGf38NsUIZ5Jao0RyoQgsEUFPLOw7UsS8yXlj1u18rD3+BfZAy7JRK2BsbLChUVUzCsr AEBOsF5FToD1MhZZkXZUhfKCqdbY+b5j4gZjIO46iZV1sV5H3HQfaiZzdYhNNH5K0EyRCFioowDS bhacU7haIBlNyOpXlxrdCpRiXS4HQUGfBhhZnmZL+Us76IJymDJgTbCdI5Q50StxYoa9U0iZNHpy 8piT8Bz0TDR+0b062cW3QYzPFGAplO97OWLQFUfiwaBUCwXpTnrcZFV1wPRU/2AyBJUQtVPCCzQt LMCuSGKjLi4zuDQpfTmWFgURy7EvNYRgnmlC00H15x3hQJFMoU99ub9J9Go6GNchhHmc9xomfeWl 5zH8j6w+snx0lh/JA0oHBURgFfA9vx9+xbxmfHfso5pbEWknZ19g5H0u+xVSyJ+2pJw4c5lus456 NV5ydxn/UwvwiJeoCR/oIaHWLWp0/a3xxEoPbYvo+UAgCii0qwp1ZAkGLIFR6nOn9LMqbrHcn8/g v7vN9/nh9j+TsBlZRPOoH7p10WwQp5N78P05X5f5e/y19vS3YJ9vpqwvuvy3LoAVeDtDWUkpsKnK UDKL/FF+SpEiNyKRUU7fk4hNWgzIo2M5OaOfnmJNUI23zekFK1RhUQsUkoOXT5X7Wm69houVyhBU l0Ge4l5uekynQi3NnhDhxJ2S1KJTeqY8zJUaImiQxAFgMjKqAv0KMocUWGp/Yp0dqHmeCOrJLWHm s8j3rvpJ+BWg4CCKIMHiRJYaxjDFN1HJ9hQBn3dtsmSb+kTMzoyzavtNK9lvB24/xnLkfHwIYHdP SSh3JfiOzOxjadjoOfWIweGIgSEmteT9TgWJhieP7j4c0Pm7ZdHt1VNw7dTQyjCBtEu8atiZrxKg cnERQSBijERZ5mSgU5S5ch1ioqzPz1HGAzydgEf6XAzKYq28qBjJT2wsiawg7kfFob2g9sOGRMze hTOxwmGS4VJhjIm+XI5HoapE+1IRYRwVjhXp+Hk7f1ejmHcfzoKVFnscq0AfmVn9EXRlKif1jmr9 ZAawe5YjER6nFN4BFhENig4VNrGghP0HAzMMq4DMgEV5/eJI+RJFLx0QgbxLATwRe1D85JPIT8FQ 7jLeilxIX9DDj6hc7kaCTue6g74xF0xBXLIk9ukCYCXoqoh91HT508U50N6wDqRMFOYuffEuqfI4 YYSPKfP6Wud3qvvX4+2DiP/2yisQX7yT6UhFo/R+D+U8fP/EfcrNOTZVMPznrRQURHcwbfIcTvTf yCB1FFR1eP4ViqWhArAgdPJehjs61cgT+sKjIyMwKlNpJLi7rcNILXH0TedlJtZRY6qLR56btxvB kHI4Gb68Rj8wN6IXCinoHn/t+M930vS/3joetXRI8WerZ6dyNklKKCgocx74JkKnGfjt2L5Dgecz bvUUH6Bwxz5jbychWHuOZHBr+HSKctQ45g3AikT057SoLQULxLQsT7XV2nhOFGj5nyGppDDd8h8b wc0yBMNYFoMc4LaAbzPyTrZ+4FTPAVh7v2sO0c528+xA3Nsh/TFNPiOOtCe6H2x5yerlnonYfb3v heTNo8UnU9b6FI+0J5496GpZNtzS60Q4QkpMgSQwEuFSOsRUmI0sbEsTFbqquUn4vcx+zzff+69q dDoPOn4ipX4lMjR7c1pcStlabbBGjCSjMGJwCBiISu1k9k1Y+p9U3TrznyqVOZo2fhT4Gz2nWedf Xk5PSr7z7VR8rdo4aWaRenl3Js4bExPscic4OExcXETSMKPCRIifkKDiR7jh5h5SUBSGQRONgeAo bRLkppXJsBEHCQUvkHaCwEqO8sPJPufha29sInVWI+hKh3JpxCsKSccRhDzJqLxx1huJAgop5BQM AgJxl4wvN3vJE9B6TyNKFqOyVNLJO5UnNpjZU4aYxjE+Ir0OZVFGJ3lU9rBiOFGKVVymlVrGGSYq TTH/N3NOwpzOjHerzEp0HzHyFnoSwC8rNYMNuU0IBbHgoWfmrhyDBzijDMZN1jifVFfG5PgfGdj1 kvB39fW3J4pUs7e9j89an2m0h0Pk3bumx6doTZ3XE8lcLrTHe/C2OZ62KTO8h71ESuJiYUqp7Tb5 q8E94wa9mtPH8f+ht3tm59HlLyeQ4TeHyhTzyV73kPR/UfAicHi9W7wnaHNrvcT6/cVi/Qbx+2Ji +ox+UDd0WkFDmQNIKHUJxLD95J2m0oNh7Q+QbTzVC5/zEqennPMfxKX/hn3I5s/Jl1tzgZt/7tRM efp/EHHMWDAo4Ys8qooor0sgRJikSMc5MxT7QPy8w9JCbFAX1drnIBASMykhKTeT/s+3u23MnCda w+sIMGi/AVBw+JB+naiPxpMwyEaR7GoxjEdjiAobs3oiIVH1VqqrznC8Os607nUn2/qQ6T1DI+Yr 6lkR82f3LOj/H5fTPJD297+RX2PiMdqvcIeaz/IOoKwge8mTO46SJ0BNDI/IkJ9QpuIMfzbfx+/Y ehScldxjqafmUbvSxp0d8jhbYmJcQLCgUzk2AVVZkaaHWhs7HlwiIHggn5YUDBKAKWhaCkRoQaoC IFIgKGhKRpShoApAYkWGKQoQiASSShpIlIkQoKaAoYgUmUClSgCJmAoaCqFaRKQYkClWgoQpWJKB KR+z+DqdIQB9fx10Eqe2Ap+6cmg+qH2SGQa0YaIhrCr9LFGFY8i0MZUEYiNn1xDBrX+Ht9X03xn9 YV8r+4Py79FIJqjtzFMigcpClQtsozM8VhmskMoylqDIG1GSGsMZ8vswHxLzRW0p72Bhx4nQH8NB 6g/3/u6QOT8RaCJBUpKFI/H3Y1BPw1MWSR3UZQKsB89J/D6P3/XZ9OgS185m39lmkfazmNfp0v09 OJ0Oms0z8FyzXQfLc6uzD1V1SuCE2oFoh7MaLzcutXNQQTRCZNVhJoKzibqRAKvlsF9HjWqVbzyK puf40hzaqTT3hPo6vp/Ymg12MMzqyrcTtUasjo+jn+mo9Xh+qSER6+KwSaaRNOpeDbOHHgS/8ZyF AfB+ZFsKIHFYQcL70/Ux+GCsT+w8PHh6mItKn1m3gMIKtY1MqXdhU9otNTvhZW1pFU+bzBKYwmtB +ljy27yjiC9Ihafi74seX/l8eY3bjrsnRyjSlNqXa0OI5kmL5xkuuVhkTbxFwWjGnpVTg4h4cpPl 4UJsI0rQkFKs4vr4JrijeInKOIvdUYvMBwkhW5MOVl2FlO3CGlUkm0mzOYhNi3xlPlBvL2ilSxby pUIy7lrycGo44S0Pxt4rhwTkzMDy7u8U6+sDj69bvSjD52ORD0jaJvUCiKLm7i7jKYpMUsdO6qM8 pTu3l30gxmEkYbNzjG90QZtzWXM28J8uU7lqEVuoq3DcPtFyVhrprw54N41OE3ExCw4kaTapza1n Kt9GZzOp1y2diWBGx+YNUjcG6VvueOCyMaWIiMQSm2rTqETDkbeBYzFzetw6mdxalLQ/H6RuhkgS P8kzfNAQpiPSziBFEfPAGBIRFCRw+8edmE/HmTlGVUqe2f8B9n2/J9Z2vpTr2p9Z1S9DYcy3CgnE VBBNuthDWwxq17dzncJtvo4U0UUS/vJMzve9p07u+961rWpiIS1WnxicYiIjF4xlZxlYxjV3esEL GLm7u7zjF3d5iLvOKp5fDxhPNZkrOZ0KZysNnD6vNLOIZ3KfNTjWnd7WnWlcxzUPk98pxcsmnUJY MkBUkIrB8gMTMidBpRNCiO7Orp/gdZvGE6TibxyRsKxHhETtBXDHgPCZzTz+rzec9Nk3wH9J5w8x LEIfPKxITAFFI30YGQNAFCBklUpkD3SnTj2OTlhv6Ak990b3MIq8VSC8jmTkWM+WXM0HxbatKlU7 RXDxKfWZxjgmBYFilmTKlSsqEcPasnEafMtjDmh8QRr/VnVaWsuVipnSauXpEI9MPx7B6HPFG7fC l67TajkduUf2AfUPtMdkX31BDIzhvVoadZHlcSuoPlNdLda4dCMx9kHOVXxYy76y7SM3XpFRE9AK ms8Q8A8/Of1JiI4Ju0Ymk5GkaaNJOJTZursfxK/a/Hhb/QKDY6QkLcH6DIc/p1bYGn9KMBkr97vz 3ICsjKmSM8jH6BmcKhmP2fv/ePAShMwyIjhZvPnHDGgzjiB6kq8A7EHoognUpzc/M3T1x6ndMyEu qEaJanUp6eLWcmScvj88PmoqIfWHIVPlaxnOw/mjR+QYhznb4IB0H7A4/aImbNVWzX/e/O5nmaQy SzNmU7v7XJlJLTsOoSRpJGltMYzi5KTfuXCI38L3RK0sQ5aPnxHGNXihzAfvOowqy5lZ25hYSjW7 r2bG8h2bnZY95DwB9d4jWoNpdGFW5mGN3ikTi5h1xxUNwm0ptyo3APDlV+jM9hNkTWazAGVSMIpW treU7VVx2Zv3h9fZj6xMN/0TNrnMEc8c9iZmI7ZmM0pRJL4Hesh/m7tISb3bTmNm8T1BxNvuDX9a QDz35X58XZ87QZTOqby+mmqYwrUPjPxptgfHXN0ZfOviXaRuH0h8jpUnv7lE5uAwe8vD9OOjjZ9h MznUby5aFDkJnXWuoEtaxiOKpLeIa8vmaglEowajes2fVDhhWhRXJLBnmt74s3DhtNBmN1Tfkb8Q +GDsmautca647zjtiFKl6fsVV1WVjVRUXsrRv1PYY+oBNQvTo3BkazmFFFIg7C7DFyF77sz8Veub kEbOq+B0NDfC4OJblJOm4RZJmBtqEkTLjZh6SU8PaEksp1aIT31Blci7Cyhs53GUJcQ8V2jZm4hX Rxc4WTUQ6PmsIpD6etVHYFpEzj4B2GO7NpYN87fM9Yvdq+O16WNRqM63JFt0x8Pt+XoedYbwgXHP UpdLpUl4c8JvCaVKHTGE9DwuUOqzuLlxn+L5p2S35b0G/p/ibizuvusePLmla48TMt4XnzPn6qwm 3iFieEy4d0Rl5nzMxEQxj2B6RpaRx4zxVYTod3mXV7i/iaPkg56zZx3jluLV83BziDGd7u03Hsx9 R/J9D3998aOU3ns/lQh0qdvKuXPHl2wi/LmKdtYmNIeIuWl7jSCteheYrWHZZmBkLOHrFRK3dw2e fzxKNVEaW0FbE55G4fpe8fyxinlGUZUIjjsodcKF9nkPgybMlzMtdD62qdGQtdFxeaPO4NOYYMJt QmKlb2tFvWEPHmfKvL/0H9Bdc0F8Q8G16iwjaEn4nONLODwaxGo1DQsG+o2mSf6OQmnjEGfbjqJN qH5zqYKLL+RPVCWLcaUQjKleQTXDu7s1099LcYre966z1mU4e/MnGoTi3xn6wM6/ZYdBRKgsaIeI 7NUOOH9OBD1huQSe+0YTnD8D0befljTqyb05qX5Uqxm2xHIbcEYMF+Jd+g5TS1VZ4tMpZiThRjxB RwOGMQcdhYUF3qpvohxv/SPREo6SnbkPR7UB9Wx5zuhr0fIJeAz8UISB1prpBYmPfu5ctCGM3GTh Yzzd2oHhJDnYk1YRNERw48OXsewfMcg6zgjzShzw8gkO42xaEKGgKVOCcJTC5Hdx9s+4bhykoF5w ZUs3AYchoaeWYcjmJjrO7o6zY44ec3+/bdMefvLSA94aB0SI8YpGMB8RxL0MIwoiZy7B0qehWOME 8t7dpyeYpzs+37PA2OFURDo5c49DXf+2hvRYND0yNB2Kf2BcO5h8xY2At8h/AnD985QHfflKGC2Q y9suwp1IhOf9IooMA7t1xGEWhW5FnzBISaXk5P94OJmYOAIzntuno5Hca8MfACBOiQ4kmSmSqU3K zIA0TMJzHGPVCvH0/Dj27tfJ18B7EdaS0GaD+UwKzx7eKgY0ijSg/q9Wrx/l+J54jpmSKqDB5gbf RHQ9EAvDqYA4Pr+39KvB/z5RLlGFF/f/L84Qgp87vh+sMQHCZ6zu++kTEziiIuejTyN19CbOemHZ JkvFSlXRmMo4lxX6PzrglH5K792sOeg7pn7V510Louk7V4cH6IF/iznya9mezK3Z4U53xScmRy5l 7nQftk6/D3tZ3yZmj7Hcifq8RWWSTsUPXtfRy0s2WwdvJVpGczEDOEo0BekxMccLalg2fQk0hJub tRN/ObhvzZ3b6Ggp/FvQznfYsloX/Sfd40L88ZeNR5YrCCiqlM4RVf6LTX/F1EmhCiy6Vs6FoDXo Xamx3P86vOl456vToUNqxmx/FSK+jqRD4lbdRUUMxGcyHZ4Duq3yEZdcXE4xn1wn4/o00r9G7N9z vO+XzTb7KQ65I4NDz44FHlETlIqoV++p1P+DazWWky1zimxDOmmhLkel2TTyudo81/lSRKnqucV1 Do2IYjWUuMCqeJqGODwZIRB/GuVWFwfXEQJyJNCZmv7D6oMrsWOoXc/kTT2rCNIglZnnMUwvEJBT ArFqlBR2tivZ54Madcx2UC1WV1oncqqjGnWaqbK7VO23WLZpESwUpFBBRQvgZRz1STcqQLdEnTZk GRVTQzpjFE6ihGM8jbitsOyWj0+rA8n0izmIb4VLQzeB3/C6gR29L/K+/XnWuyzvHv5gqOSjj4uR 6l9/Y9EMzNpAhMwwa901LsD5gE04ipUxvsRZLiqITfc5hQ+GeqU4xJWM6WLiNTTFLpME7T3/1FfS VlUQ2g91ZQmAdyVkFxaRExn9h+w9/E1cQYFBQGEK1DlCoEGBynYikuQYYSAoJpBQTYSV6dmI4iLt v1ypLYNUqCKB7RyCVuJ8Bc2eGaJW/9Q2xCoCq0LEE/jVqWb0e0pyU8zud9ZttTV/tsfFfDHv0q/W az0N4/r+a9pdTsnaVT5zKrS+Ptj33HB8v0+Z62zmiet+1h8qmik6uCu35W0moHCMZFMSCPq3UnAd oMHH0LN8EX9SdxMqFCkU/r/61EthVDwoj56ifjfn0ZIo/zUQOQDo3H68KP2BeCUAqJ5pOBx/NVVG BEwJ7li9vUUqHnUO9pgqlWRD+H+GSRon+xfYsiet+LceHV+Q4bPerFR9f24tbKdFbp8n6tmnpS+d 1E5NVzs7EqMN/MnfoDODiIHKDymgPaobj166bbKVr2KtiI5YqiRUPlCpeTs94hk76lxrN30h4DuJ XxJPXB7hRipX9oo7XWUBiEEN0SkeLoeTTL6FsfxWKupP29lQvrrESYp3WG4h3LbgqOID2Wx9xCDI yGUBGRS+1C1U9iicMnq0Tx8R/sxhac6mnNui/7fMnh2bw7SvKKESC8cOaSTMHZMPSDyMobt9Zzvj 8Q6wZ7kQYoOg9p+Q/QQKth0ojnQOOiyM9FEH8JmkIfht0ztg0hHUwwEVISb0LFSQbMik7aklcqd4 ewwM5Rv6+RNF94V0MGYNEQRyqPFMQl+vUC8xiBpFMBRj8MjcVnX+hg2TNA2oqHFmGcgTIH8hD6Sk UoLDHVpso8yT3myp9ScnyvS9PQ5N2zE5vSrefJwqvAidjqTzJp4t3I07z4mufJPhVDnENoJujYCn YWEv85CrENgZmCqggJSinKF4n9mkEQgSTz6CInlCQU+6Hn9FVy5FIzkUu5G8Rd3BfS7LTNwyiqi6 iQ5PE45UhIOhSlTsVdHnZyViUjAGsUEkoIkF4ccbcwQOgPmZBDGVY4QCmR7g8uH9AhKcfAdkGaPv vh7XR1mmtEqoKCCqMqDFVYPeV6E02nj7UClywjqVqfJUhL2Vga8qv0aUg7WqZwK3XVaz7YYeiKWB JIQxzcbRweTZIzmsifYHOdJanzFQp+osErIIGHt2jjJLDiEvMkGMcaM0w+SoD4sgJ6LdI4hvYnFj zH+QxQofMoH50MgklQpFKqgt6D6C2RmJnMINIX7g9Im5SIQHJ5rOry6yP0AdkzSZIfG+8SoOFxoy VQVVUFUFRUshyMmqNTQPiz0tUQZIIMh+CojoBLky89FF62QohNz1s0FaiE0GFUQAvDcgnOruuXs+ wfnsU0b7cOPxKe54GO08HjqHJ6dVO27NKbUfInubTR+HGJY+jjT1HsOprbzpJMWxywfL+ZMFdfuP q/wNGfxP8NLyggJzDgh4vOaX55fq6uJIRRTcEiZM9ZQZGzoGKECkU1CkTaQKiyANWE7FCGoJmEYD A1EiOAwflKLKJHIljSHvQI2tonMJCPNLTDd89yx+jbe4ZmOmgtGP2LkGZOYtD2IIotKqMMhBya1u 5mDOCgld/WaxPc+f0n5+7D8Ppvy/2mxM+E0UhQUYTlSqjCiqHEQC432MZ/4ibgcXvE4iMfeJ8kPi Ve42H+S0iYcDQ7xVDCwQYEeq9LRqQOpRVEF5R8VwPoGHC8mmlerQFIoigeYtDGm+RLVNUeqfUKFz zmpExUozX82tYkZp79StcMejEa+yxbp1ImBXZFh3qg8wRRS0Jhcf5d3FPJeUD7xCPKej2/AlfQoS 6igs5syifbpMIkZUv/hnyzrbtx5g0jnoKiqi4RiphBYxg0ZBHotYVwYMZGEbR7NZBDEyaNw0Zp0W oJnzALtvWzPc916tnKOVI35YmJwx5vbOxpOanOTm4D6SMg8yIwbOIvUeIiDY6Q6CYtw22u7PJ6Ak Jww1VKscSJcHIbiAxeEQvDQF5x21y41hMsFS3WJEkH6SCJxKBQU9v7jAsQP3qdR2FgflPBg/yEcw HsHY8L8fv9iUoUqGITKyDgt2pzc24Ed0MPN10pyI4Y4CgpRoQ9c5KNoJ5NkH82C7xOkxNvhxXRyI /TfAubZVbCNsTTnxXjr08vuXs8Mn5IfPrge5+SDNGbdYtsodPr7l3GDMif76UF3eT7dwiGz6GRu2 3PPaLm7Tlhnl9X1DKweZR2XyGwYEFuYYadY/2aNe3rtVSlKBURyKqkYDIUiGnbaG4i6R+CMXp6Uz E6kMD8e7jnLAFMuQr7qnfSZ4GotPAxLTpO+wmKWE0clpoGCgsNRmx79qUoKqJmUgN59Qql1eRBkb pzuajGzRALIFEAdxHnTdmciTIizHOGC9zKPBaO4HmBoMe45jlMTusOe9Z7u82f4GAZsg0efZJJLh 3Kv08fgXaSTjvIj5DlkDi+K9f4jVve/6eOSh3Sz7TpinHM3D0EGQsZZ4nKdsNuwNhNhg2CDVfdhS /CfnlNoYpyPTt367/P06vZ0Weveuddd9ndyNc0zhLmX0VNylnWab4BPvS/gobQvpD04PhZ3mB3B+ 85jl1I8284ScSk/PmtGWn0p72p4ft3VG71UrZHxPS7PT0dGitnNpNIVzU5I/Cetp5+++b7vsezsP MspQsUiGw6zE7cNRdXV15qo2cj8L0Eh6sBLjLOXG3QR1XtqimKuMTZKp6IYFQ8c9mQm6uoejz+tq IiOeZ3FB0HKaS4sO6vAKx/lzY5k1Cc6p8KNZSJTpZJy4yeN9QUnk0QSkVClUvUZlZVNDzMXhYDxe dXaB8gjd2cp5TNI6SubTC5x8xE7kphHAW9mZmZmZVZmZmZmZmaqX6TZm83Lno+gq0HA5tWMNd7Mz Mysys3Y9dOmvtlWi56hFUC9hkRwCqp3L0cxs8rO50bRzRLX5QTu689cvDhdvVIPmgdSoanfbOdwj SfKKiGw8wkgrXUYW/GTDFNNHnGj1MR9ma6Rvj4PL2H46zuYPHt2G+AEIwFYrkgX5D4qBgsEHSLyz 1qVA5o6OIjywxVzvN5/HzP7KQ1IgOURceNW/IUy158iZQbjJkT/EFE5ANZqcIDKheoB4VM9RT2ht VTaCJSA2JjINjfIhR1SR8+9r0Om8/Z/WeuMa0JJAyENt2EdEDnScdOmk+3DKKHWAOEFAUEMlDQZJ 1E6Id5GxozMxaaDCrAo+ghNvtwR6IfmHLqXoeWFLCgqGU4uYPWnYC7VRWVI41ERwHXqNYpvQQLEV E6TzeowO6GCGPs7j6QebV3qBiqCqFNrIDs12QVhmG6fKEyh6e7ilOKcqkAkSH+YUGcHJt1+gQn+6 nJTE3kfGxCtFKJDrBQFA5E+APeQM9EWmJtBYQY4oZrMeRQJGzYTBQ6MX46MAiQiAe7z+P5Dxeg+x iJIKaGEvFhuVxHlca+4RhTmsY/LOJB9RZnAW2pyeVRs28Mj1R0fRUYn6t2ClJVH54WdnsfvaifL0 ZJ/g5mVU/Ewy1Uz/NmW3R/ZCzvXsfxo/wj3o5fj+Y5feo2lHppcGYhIOucoQw8hpOo2D/PWSUJJs Exr9PNfgPxw0+P314m+kJ69Yy4/ctLNB5f3vb+aiiTYoiHYxc9ft/qepLIwW9Upb2mbFGkkQq/lJ qF/Uy7J/cu0os+zBrtJ+VdgkHaXYIQJLTumjpz5TZFNTCd8/G57qU7lFw3qysytZC43M/xICJMU1 rZC/8JwTUZmdGtxNFTHdqX7lFcxctCjKnl/Nk0ixmwa1r993VVVVVVVVRb57YzjPRb3KPg9maqKP L249ltcoPXeOf4nNFFUW/DOjXNw3vhDcOF3nrw18h0+B08fiQGiI7zBMJUiJUqqoedj+9s0+Fs0q q3+XsnHx5v5/o6cYB7AgErGTn+dczj1HtKhjcZgP5B7ysEtLyw+weDgKgx84Ulocp1kiRMLRx3xP 2BgDwxgPNPtHMfc5NnvHzPn6tNI8vZmJww2StukDILhFRLhKwzBQnAenmRQJnvPqoSQxnOVyEk3I d5sr73anTKoR9CInMn9yW3Y4QD+4CcQcGnr96dPjxPmkPJ3mxoBPxITsVDCR9RCroqaVEmlNKkFL FVR4fzXj4WPkjaYh2bwR9KpCcafpJzRsbGy7xyMGAPnvao+w/xJEgg4ZTNFR2sM9p9PKQA1aRgTg CgZxROUadWaRWAoodJNNhgwQHMgPu+0QQ36F8CLkxTM37Dq9U9RQh5k/SSdEUbDuQGV0b4kjYCkg flS8JCEj7hilxVblK+iK1D4TeGYXNu251AB8RAyWr4OODIHG2b1bhzn+ofiMpj15HhdAbfZDOxgX B/YDmzRRSN0S+9SYrFv8a4NcEM45GTuZ4CmDdGTKCexEWO0ssF0XVAJCOSH5DmiLWKhhEobW9My1 njJiK4OcQa2NqdkUVrT0e/9yXJWn5Bxy1O5Cih3mkUOw4GSSJOnNlJ5HK41KO2w0ZNiDYh8aNwSo lyCChwUaIEexlstnjQsZ/rIHGNs2qMmjQ4fKPGwc55M9L3F7qeCzuQ5kjo8HcR48I6EA44DdzfJP LHCJ7Iig6NH3wBzx2MGzHHQjN773KOyB26OFzAjlw9pcs9DsPwy5TMCKgyf5Wd0DpaOhSdZ7KcYY nUbQcI83GVgw8UILmKwVsUzq8mdz/hoWxw7HxM1Hu0DO1idkxsytwPIt7JpV/tl3qTIiXCXjDDAx rDVVUKw2oyppULbWLzlGfIuM6IvkyWecbnheomWmR2dmkONFrr8PkuIxcJ0W2NHHt7ahjkxjTv67 LCTZoI00dxzubyRaUJZmmDh5gjF1RaQqGQyj0qXRICiWFwPOmNHOxK+yA+aQbR2CU/Y8jywBhwUy ycWq5R9WZ0c1e30cnoh8LxKUqGYq931Hbx1vTjXfM6gqXbvvcXFCEiv9A0NS0ixSI6o0DSIRyYRw qcuaGA+VxRu0rp+CFtV9NRmwsSJYKSXg8CrbOAPKR31l9Q82MhY7aUAqIKqB6qOMCKGceNO4i6IL iu4kyOnhHw/7hLHmKMXPmz9BRSYVHz2FRQYBNsqDQM+C/14V7adQcFJN9DtagWqTRRXEfAWtLdDt N+OI/QMo5w+XkbS8jDBJALRK8eup5ylBOsmWTIFWgICDjly3OisA6wPZ0UVucPcT2v3b9B5Dk7Fs PcL5Ft+wrJhbBBxRcxz8gXHIFXoE9/kPpr7xPOVnwAXXniH6j97X/v/V6jxN54nA9P69HV7uIZY0 U/jWib+o0Kc3rf3HEypOcKC0ca1TvZ72UOh3cPToWCG85mzlUJt6E7X0QYkW7J9gxLISP8iThwiE /IGlucmVfEsnFPPUIxIIQ4q/qX7KjYfyiBfANQ3gtQ4ribDOxoKv4cgbvGoNxmaisoyTW8GviOHE jWyDj4kXL6hmiOzaWVkPrhHfBHk49v3dyoNjiGqXMHuIiZgdeIgwlZSz7IWRj0VTgxc4+SKe4jwj 0MjFiLbJ1uTNx2xvzEBnuP5EFsP4CQ+RRyC6EPkHw4IcxJ5HXF2YIFZg+u6qb4mBUe1Ox5Fu0kdw ZGJBjZiBiQJoNtJ7B7/Mc0etGRjoZ5Dp2JUQZr8ovFUYNsWMj8Q0tW0O2m4+xrD8WM/Era9dsV5Z lclmCz1KdVkdmyY+6iREKyC6+a0472+CjOUFtTp5+8ukzR1Xv5wrK2KRB7CU5/mRU9x3/ireyLAt 03Ne5zu1wySSX0C0o8VCQwKC0SlQz+JmFAvyJjc28ScIBD+OfkxzhNxo1ZNRxjwyGRLTwzeggTsK IA4wGC+KWi5XAJ4+guKTTWxYPQMFRwoHYUWWiHJ+DXky8kVB8ICIQQKB5RVJGOJvB5peTXvIAiEF F6tOaEI3SsUrlcPC0KwGnfUe6ra+eOu2okDIrVDhhyF55X3hD0n93Ff+AVFJIJweJtg+ogpoDKVs DoC034rXVeSz5beufyVC490ZC6w/0OAs/H0OrcxyM9m+2/c97SvbTFPJwodvdrs+hTq0dFeYS7nK 4g5KUYD7LevIRHaFzlac5hXSKKWLVruu2U5zxwMlC+ETOyCRMGTNYVXDClGZHjenZkBMxtYGoQKW HYUlm1vjhvTRpYYUpYoTTDN9Ht2ShQy2rRTN8zjFstUOSEDkVmAYuUIqBzAxy74QmrsL13vvaj7V TG1ISWoWCOD5B9NCvsIowKkzLloiqWhDByMkjQKeYefHVGj26wmOfJHaRzXwGEw0D8S1USinTfjk 0fgIsOBvbkyzSNQ9wA4yhOJg6oGZ7bxZyyCGwIIYg4Cpa5PTgSoSdLggJ2BVSjtnto4wa4wOM7w2 UoQNCql5KZeLmjBStpcw4ekfBmvh+zzLHpLH8093J4KZxsUKn99zTZ5fINeAxYGcMiARUBliQGTc OLi2vMmRmHFr1XoGqsrFo1u2kUimApEStsHFHzMAPkqOFtLwkVX4VdTocOfnTRybGVzdzjTyV5ST /fR7eretCkvmpMdhh2KzbBlTFHBsYO4JTY/aUd+IHPJT1EdpI9MaTxjIDGSwXrDIj6Rseds2HeIc mH4HwamzCKoSA6KnRIlVh8UL04fSTy4/Meou5Os3uyMD+pchmRcwUKAoETrmfze1C0rKW7VF+fva Wsvzx1VQexQZcenJv510vrXxP4jL11R2d3fotiZTWKkWj8iHdzW1wofaEWA+ad0RkuYr0DzqULyD Zm6fmeGl5YVik6vUDkeqRUkKCqGHtGNalN+gSb4CYgUOGcw5FEzCphW0RV/YNaKh4iWbSkfx7jkf AgHmVE4qqi4FpiPeke9xsOPqtI54njoBlLi0ccpvsNoZgP8hNwDIC/opvZqW3MwH6RSeiFv8hI3y Fkl+Q/WyYD7xBfpew56NWWCsHPYwcQdgpIVk2xjEiXHURPYi2peKnqwlNSqmtN6WgqHuw2DwJeMe Szjf1xmv6vL16iogqoKm7rAKJocmqD/gHYYkyXubm+w5bk42+sENEjQDkI6hF2ldiT0BhS4Kyg6j FNR3EM/3fEpDPzB5OV5YcRga4bpcKdBa8iXRjg7XoFxz7Y3Z6woFurH+xTLSc3LsTdOA673MVZwV bImaulOKddQaZZFaYClR0zJ6DRDrU7s1iUnxITP5IRARVGtq2bjjoMDalGuObC/e+HEUswhbYkh1 ISRC1YSL3SPie4UNR8h4ywqvLKfeDDJ1SoPiYBtqCSilwb8ioCQUBico4ieB4Wv/HjTWJZbmHm0d ePGpV+zhPazFGKX9TX04KTekZ8dvl0F8A8BFB4uRiNbRQayJBEtUVUEtOt7h1ZCT2y+e7MPChp7Y D8LCQesqEICF9lAxvIazKADiQoUsDEcWPz+9weBOzed3LhrHDtVTQ8FhObyMDvGJRIYgTQcdIwD+ ccMQB4jHOOl8jvOjyzCJNLhais7MHGwsJzGG1Kdq8S+2WbWkSkeO0s6l6bjLCZfIOIUfol4cg/nj VSjl5CumT339KB03Q7lpCCNuMEpXWD86lSHOGcUQjCAhD4PsFESQQQ1K41S3Zs/X5NG0mYpQx9k6 3BJ6dEEzGYLhSZSmR+JbieQ5yKnCmOsI6K/1z97qlRPlegTkFE1iToqu5mcldVIWkxNIjDBAiG9W 880mOOpuUh6ymg5LvPwGHnxRd5tgWcZHo+z3HNmWBhMMlsHnQIibxDb7UtUHVsMKMr80IQQVIKhz M6IsGRoOYckgS95cek129BygwcpMkCglt5vK9JNAeopQw6we5cRMw7zh8AUGsKdIJFLCsptuTuQc X/TeV2TiFMlqw0IqIgyBOI99F1xDsVpR21wEUPBd0W1gooQcpWCl50qz1W7VoN2oU05CnndmJZyG ay5kC3WIyPuJGkWUENEg5B0hSAqdBTjIZBJ+OnqXTZ4rQPDdSlJ7jHK5V4FJExMPXr4FrIMkiUZ8 fkqR293QzO/r2HMUMQyAMSPPYb7Di2FYOSRc+IAchmQfAsNfm/iN4RR38uwtc+d5c7UBJFEF6ZsT HJ4+TNTctEzIpONBk9JWSc5DFGg43BDJznlP6ZnKOELV5lO5XzKT41iWkdlR1Pji4l9b/GNJ3geT z3wuwboYeMcGKQiN35Bip7uRUqNAquQ+Z8Uze6dMJO7gncKN6PY8RPgfDDYSZCTIQmZNb3TMU/J3 9Z5A8gfTn8vgrg9c0rLasV/Lk0ZSCAdmOFlOkXAyM+gmSNDqnGOXsNA+kEUv9FU3Cix5d6ziUxkj /MFdRoSUVqg2NMHOQXWYm4jlamgFCkIrAoUmPKSakTa1YKWo/frazKKSVDWxQlVLNCmhvpzlCa3m Be0qqen/yNlFDoJaQ7bTiaRSs1UvqUwrNJWTbqHdRQGQkysWJHJ0B0SnsLcBTecSUVkwbBTJT9Cs bojqsWnWwUrlURciiY3pm/Akx01ZxUqDc1LTkCUl3/am+GXPT1f2jSUlNhdgZ4iiYprGlQd1T34G jPh/taffIY5WOaUxao1KJPVdEBPibENOVAhYJWSU6LOclv965ykTdC8R2y2AinV/kyI4qUwL9E97 isFCSmctOOt8dxi7jlTqMzlwqlzH0AIVKiqIJcIoiWClIRF682cTEe+xj0ithI/AkWUZE6VrCktA YE6HDg0joC0lxbSEL4EfQl44hMyBmNfpOQI1io4gzHxGQ9SiPCliPz/Q6oEpKnIF15kdxd+vaGUi YVCbDgHlseJuNgutXXAqZgReU7BnH0wctms187kgJTeghYoEJnbyvTlJC/SiTE3KI4QTscFTOG0J 15+d5rMR+JSf5Y3HYvs+c7hA2WVnQbELY+QNU0y8bMnlRnFlmNTj4H2FRMLaSyzz/48mY1GbHBP5 m4iJ4npKCiRByMXbjSiIaWA6rWlGYpbQO2y1017FjeaKJ6r4uKSxVolVI2mkZNXy/eDguFEZ4yOR uceKq3htInOLAh85qeNO7nPNNK5k5uaRsYsMypO9WhJywHP2m9GwkybEtEexQeTASZ5Yez2PgUEx QsFFMRiZT6IaRaDAtBxoAkhpfATPJ78/9XLw4495PD4UjhgefzJntqEtSGu7JJUceIpbuRFXuGC2 0SoDybB0PEg8LfGUXe15/W8EebxdyvWxSqpVV7Sq8SmECICAHIO4OUfQx3O3P29DSBO5zLxnmRuh Hfjzf6yt/GoY4Ni43j+qOUMyTJMx/GfywNo2KYG6m8wJA7FKqHFCLrw91POe+jlpwyDMokEdUarI ZyB5N5gmgsbT6AZDXfbkPc8oVNt27G91n+nl3VPkxG3BxajxTKN8Nosp4TfgtIDcxR1ijyFYlZU/ Wn7+mFZbhZzpvX3POK99vTrhDkQi6P8zy8TlsEJZm3nu2l1RWwdKj84XlViClgtuId4WmTgJDh/d XkzKK2WYBGcWY/EbXoT8wMujG2aKMkGy/QMHyMjOcgI4Nn4nBYQL2W2AQeun37td3XWjsOsF6Xz+ TGkaW0aExnQxHnmKqCiGkXrqjIyIXO9Oly+rmHU/MdRm/M1O5F/iv9X+bzn6a5vEQ3PZkcA0kw56 HjDiDY1BMFTIePcVjGuvdQVhIEKzJuxeKnVFitT+eI9wx7fJhDVmH5CcDAzEglCio3J4HIQBwbKR Zpalqp0pJ5jVGwkST3GqmcZnXGaJU+ALbq1vQtgPUMp9xtru0evSFEcyYIqSSZ2+Lx6efuHR08u2 HPuO34bcerDenFH1QDEe0ZQTCRZEIafWxjH3hJmqY/6mfdoCwd3ymZWLCGyu6Q3iT0Hrtd7HuPFz 1zEqcefA1Hcbem+S9PGkoLqRKeJCYo5/LjBB4QN46ky1DkgSrp2FOG4aW8eZjUbVuXetv7PhkIhV DxWyXalT7Zx9wGmZfn++wRDaaCNBrY3ZzpJgj1BF3EijaJPwGLU2G8p3lwpdKhmiRT2opQXH0hEj edjBpUeiLKdEjUY2wMhRnI5GI665uia9C3Je8dFRczysXae73GHBokWnaVgXikTDO+7514QRKAUM FLzInBaYFFg6jdu3X8b0ub6j8ilVy/ibPg3PS04fKaTxV5U+Vp14eA58Yx4fyvSba2SPgzhfapRM 5yUOYD1BxHGizaHbB4E6rRCpMNAo8ZDcbmMx4kdtsxxHU3NXIOKKJIcfaGVNJmICHJ2/xGo4EaJP fBH4DfYFjRRsgRAnGviCJhzim9o3+WR6upO4VBX/JUaEjhWGH+3v+cIG4qK9LymkqHV7sBB5+7zh AjKjinHORgFUgcC8uaY4SwgGJXRaXikA8oTMB0sRKyuklsCwqKxSURFi4+kqQOdHiSXAsEoGHHLA aRadHA0lxdEkX0uOWpi/QBcOpnjSiFXgWSJUEyogTAnJE82bRrJSzBL6qRxHNqjiTGq1AjYFFKlw aj8usKkm4LP7y39Fx8ecEBKKs9/0VW8dGB2oEmQisfidPxN3I8/APX8G234Pd3R0VFUo6o6UtGXN koPxD6MT3PifmsPJWj2dSSSSBg7kQeND2jooHcUcDxJP1di+cYRZ+HnX7TIN3NGkCgyM9gRMDBEo QzF5Ci/qLoRhQo5FNEIK66a8/OvyauLJx18TnDQrPJBwGvi/zHEIxwEHDcDjF+krCoflR+J1FYSD hE2Eh+oNVIMZ3MUikax6EnHTODkYyczDjRs/ofB9RbaUFjxQTQRcLVfgL7NjvsK9ZNirDM9Bja5O QY2GhEDG81mnb+w32egEU3bCui7EStZJzKOLctpjBEkIm1B7zWImkURFCVKiVIhAiP6blBdMOmu2 9PpCMI3dN2mDywN0Ks2AdCFwZg3i7i+8RSsz+fVRnffiH0M6ZDn4t17cXi1I+3CJHwyDniOk/yPB 4iIa50khBSWBRDhySpKAZUPXQxdVqMzMpVWuLnPwLC53aU870K8Wydh3ORp2G8h2vaVOTE5FZYdZ SRCifIbTsnyG6v2vL6lPIbXW3tn4p3FAeqGjHH5D5UeD+M1fTiVH+R5LhiyLTkChB8QxAEB00TQc KSBnIkgc5h7eTWHDh1wlxiFb7Fd1MOEHlaC63wNRTIKSU1XXoIJR2cxE3eogcxTA+gUYSgwZv8zY MZ9ZElnD8axCbyJWPQifkUjpBDZjnJ55T5zmu0R5WL4wfRIYdpIb/mhqZQKmApp78u556Li7gHgg hpBFXfmVAttEqpVnFiKByaGRDwgV2ZVRCBWhb4jIGAoe6gLglAFmOERGUxpy5tdFsykwFPyLitZr yF9vvNzPQrpE472cpBVQpb7nEgJwikpUoSIKaRaFxhyVimBodcsV9P18tbh5zy/CaKY/w6KCL+yJ 7embdoMN+fmS25pgcQWekmjohXCdbFWtjdYQLGeFY5GeWjWi9/H+dEhKQKEsldUPRkERD6RFEOqd UJmjNW65IElB4n14HVGB+kzflG44vcAqbUjZBxcI9wQfV7QXsHTDuimTF02BFVICfijDOZDnDjc+ Vwl3QV06iyTekHb6DEFQ8t5KmWY9BC0vovA73lBbTUm/kwHDxCJyvwHnVgwPIo0s7f3+xRwnqEZv mkVy5yI5wgyiKoRoPyi9yaEyP60NPMnAw5gr1RwXovYfQsDK5fonJw7Bv1YbK7Csrd5J1Zs5HliR wlTkKwdq/w4MODcf4ne5bvffWrkVHDHtKCguiFCgahS+0GLhSQqJ5zI5uGgxI7ywwLwb+JiRBJER ggX2l33bhohQfckc4jKmV4SAvqYym1X7gSQjrzwPiTHlxQfuBMiYOV4t79o8NPUyEgUqyoA/upQR i5qEi5KQY4lEUuM2YN4FBVKu2Y4PKkLYmU3gKBmzEELVRYqRK9Es4JBpcdpOkqidGhMk5apSJgoK p/IrNSoHg/5NZMiDEAQm9SxJ0pCEHfLqzHp3GHETWfvSgpVK6PTNyII4s4UPJzqG1reDhM0TzxMN 06KpNxeVFJVcPUmXcCkdP9025UQzqIot5RaGRIDpcSFRLVoBoHY4k+XUeNgf7LyHayp0+e09fGbz XdtfDRGjD3MVsw4fuSyuMfMi2vKXWDlN79NogJkSvu78OfbKxDMZru3aWFrWjfSzVK3ewzR0UsaV rxqIhEUSnVVzV3G7UBZWHo1uiWqby1GuoZztUqhf1GQ9SpHoHTsf2tvJ7WdzpN2nb17nq28skeCi 2fLAoxnnGok+OzKgZnR/eP/lDiZIyqbB299uqA7k+LMZPemhKggespHXURIj3HSSk4p9fMOGcMim grBx/GYjuClVdTuBS4ZRUoHZa+h6DLYpI96JoURQUQFmdkGCwkDk+lSxbQhpdoVM3FqSKW3aw5jY R1kzzqIe7vvryCB8XW3lUFSg+nssJRixnHhD7Uj/gW/vF5X5B0FF5m12kZXPGfFWYRde1wlHnYxF RIlA5fi8YWp8tt8wjGFY59hqB+1DYKm817RRKPxzwDvyeUdHgySSN0mZujp0ykp+/jEkiybj2ODk oynUHmFmPtIfNoOj9Ty6j7KUQNVkRIvGFob7uYN/SWkuNDGYXhWGortNXeDhzyezTyvqkVish59A WOEQZ6lkiTzuHkCctjc7pHapuq7Xc52W9NA8OAEekjcFv0CiaQeD6Ipe4LR/UtI6jU7iISsBB482 Cj1WYqmxzgXScdcawYvdGEhk2HdXtqgUVUkyFYROhSpY+ege85QUYLk63KlaV+HKQQkl3rdKy5yO oHIpHVGZBgC2eY9j/KKXgOzWSIGT3JN3umBdvspuKasy8NA4TySH1B9hMFrozvPu5s7HI3g7hWzj ZAhI1iM2+y+cnA5RzOF07yGe22fBtsGBCTNzwHkhqQgoYk3EmT9aJ9K+6hw750YFpmCno6kNuHn2 JRZus/6z19xzWcmrU9iZ4NUM41kPzAepBR8Ph2DoD5d+gnIVVYN9jiN8OI4eSM1xrHA9xYiBAYct YNK8YhLf96asA/IxHqOsDaL2wle9Ets+5EW3BhHqKm32D9CYwyN3eFBdcR/YTKtISEyUIqqnA2Ma c8XuZmi8+PkFeLtxjpNnsjo7HaPfwP7jzlMdxiJWe8cQUSsUQ0ih608obYEwhNV4imisyICSDvEM 5iA8uTbpFNhSAmJPsJXgoLCYaWHF8l/dY34ghBV1heOTy3QiR8AjQT3qDlWFAwRIPAdLUMSvYFGB TAp6i8FJhM6LRJuKU+rGBdXGJ6lEc8io5bFarBrgexz6ditRdIWLHD/JXwq0rscnqHI2diq/wf83 +DwNntc3pTR71RpYX6WG6pPMrDtYb+phtUer0pGCaeT6XyNnRe9eCk6zYMnrVjGY+xhkVurh1bfL 1bxO97TyOHb72OXmcp5OHROI7WMd22lr1ISt2+F8HmNGlSubElYqsVisLUc/JrGpO9jUiCHeQIIG w2GoKzlM2YWQuJoHlJgUES8kKEMTMDFAo8rcQkDFQZGtd6KPCguq2TLyz4HgEZ0Hb7yfKmoIDr8K 9QraBcl5HYOxaNgS5yk8ki6gzne7UqyLyWRUJaYG88M4WhAkDE9DTnzK849DtOc5ynoGnJjZp1ex piOWHdTDR61ooHUhoZQ0aGfepoKaqUdXVy2la/uOTZ3G7HqOEjZo2nJMwp3pMmLON3JNk4bsMPB5 3Ns8WnyetaqolSyLjIYmSmMIwrGIlojnw+Z3lBNQCWN9lIQCkYRCCTu5kNpFBoCRts5Z381b3i0E wpNEYzdh01P+69WW/I/xyPyn4P1psrTMN3Z/C8LOk5+ZBuEgO9uQH0BHxNS2rPSiZ044fP7rmO7p gTGKFvKwg/AtgSSwcXjsxfIchhHowHoVgvlPO8d54vzaec3+A1/bUetZB9yKwpVkLRRGFDWOHDhC wUJD22XW7q9a0UTSQok/sZB9sDiO3JzMpIZOzagTrT7XH5LI+8MWZWIr6kaVWzZRwhwdHpaVs0Gf 95gg/1nIX29KbwzfHidbKp07WzbZc3Jo+VY5o862bNKt5mcqpZCq5qr4WRsjyenj0Zn1X7PE8aIv MaqHnFTYRBwFoQOJy3FZeHUA1bjF4eheCgigIoPFGQLmooRAvOerNnwMHy4ILj2yLhSmQyeCoyKC uVpVH2GbRFhKmkEkPiHFhKEVM+OyjVtlUXG0fQUikFEQ7ahpxmLmeInElQ5Bq49eqMlQxPLRs7l9 zFuGld679EdJlZbKdJnNUKI43NXReOZioHwd9+7TkTc2eIdCDlFfcL+kX2zH9h0V9tDaKi8cRCJk sCTxMcWOUjdhRtxrT4imlIFRVeKh70R5CIF8GUWyJel5nMAiVTowErLLXeUJhkCx/Z5XRNho4zzI 5I9Q65FWYWwk+vdvfz1002jFC4goMU6GcxcV/ngRzcS23VMxXxenIGdalg44W2bKYRhhqWgcUUBd QyYqHcOYxU3Wj/WaCZpKyQXCgjg5Fdn9Z37joBjIpVzMMYV47zv9/yZrpPLz9C47Us+i2w+fDAKm yHJsULZrqcqOzWVBEJR8txgQ1Vlqjy1zT6cijm1DqEAoFVQg1CF4KpwyThcLSva3hhOn+b77szw3 uZ87WG+itps7tvk7EvHrKk92SSzN0NGsqHjuU7OwYd2ifE+Qqgc+Xpg5Nk5FBNGXEw93AgOeayQ+ 00SHCLjS58kmWZOOJhxLzE2mRUWWQGDtxYEYdiOIaRUBgUptAwPUA8YUUmYgLjzdMbl2qWoihRid xePSTCvd8FyCGPB7cfXkcyW4xHhm2cFSZ++DFlQVkMGrwgZnlqdmEKjSNuVKSwc148zfoUnG7WiR CAoFQqUChdWIvENkN1xIU0sIOFScCmrmgXBR5Tuejc6lOxxkT5leMg5PFjvWQfI1PXOKihk10QOQ xIHNkPlIaFLlnWiZwKyGWA4mnA0gk+mdoISExjmPTsOYDtr820HQIH8mEzLvGotMJoQiQq0DvICk jAUGO46wgJylJA+nBO8VBTA7DEQKwsDs0QpNAzEEQ3COc7UGQw6wb3WxFnFxnI4hD8ONyaDwfQcG gymYDJ9hF97IEA+YH3TS2QbCuokMFJEusc82ERQQp3GVYVjSFUoFJqMKxYyb1LHm4cVALA4scDSG dvHJD5GjQyR4QZUoJzlErg4d0yQUj4Gx5kc8ibKSCBDwMqpdKiUPeSZEyJETqYBeHOBEJCb6bHgQ Isb5tcSy4Hg08iYpHojIafBEkIEh0cHzJY0UJFEtC0HQJlbIZFoE3QNRJTxzNIorRCqh80ucIg9a rn59EY0V+QCiRXRd21AWJqJllTMOdl0vCC1TnvsrTuGJoPLxLqxQgIh3AmsEkLE2xM9Tjxxxt9rP 4FOBWljHabtPJsxPlPh9vr9VqbiKwwRHao7y11gLIhlI8Fx9tBQIo38o2IyLiMck53gSDgU2Oikz IpyWh4EJDDmEeLwNThZOCPnSeV+NA+UCMPW3CSsn9uCShVENQHgmMuTROTBgRTaNtowML7Aog0T0 9lBQmbPBBYzjIR3EY/0M1Qyvb0yb3l8rRTiGaE4/t3Lk0yS8itMsl0YU9ioR48Dj8AS5klxHyP5l fBWHOBSIbgQ43sbxYI6wHOSIox2wNhqN6FRxIk0CY+AxnGbQBoGgf4eoNDiELmRwUuYShTI1Glw6 IsXGBH8BzUe1E/OhDxWBEDct/CYFligucNk2UEngkvKdvkdGDBQ9feUBJ/FVFlBlvUo4otbEOIk0 8TVd+1En2n0Iyevg/RZxRZvKPv5KRXhEED8xmMDKj7HKIsr2JlS9ZR+KZo7PBR2wvGMR8AHDAwnO 5KOJx49OYpV6kVO6I9AUQU6Xadc7QWEjcU5i+Su3Kut11qXDiZHROZQEbWAUNgp7B73BNQLAzYVm 01i7baap6Q1EtNiQkem4eFDy3MdVUYc4TFEUxZVRP49H1DvwBPT4UfNDsAXK2F+ED7gWIpqUNoY0 kkfjw0OY8T7CznNRbZO9Haieo8g49ZiFFIJQgojqS0Hi95mH2BMUZjwjAPRnj4CIObuTN3B3W3Ca kZaWCd1GD5ORC104b9HDZIGcQIQMyMlbyd587tvCcYvng1OhZRXw6qIwKhLlgxNRMgWrk6yjNJVG pWkHHf3YpVVgTQMTh/tMFFn4H958iTo0aPc2dXQ1wNX+seRN1SPZwx3qxWytkc+jufP4a/CdPW73 VkbiyIkFH1DA9V0/xuDc6AG01IbwZHkXw3raoNSOHC6jkUyPYRNQcoYteSorRAySkvB8sttYbjS8 xxvNs0oNNXDApYV7HyFXiPG53eLoEHqZHmD4vJspqZhKDAPBguCCj9NnmqYsZ8GBzYj4ekx1+k9T Y06drBI1ECPRUYy3yLIS0U5mMtEiooNAiliN0ZDxMxBLDo0tO4aoyIYCIPjMkuGJWIYx3FR6ikCQ sgeJq1FK0CFoySXeio0IuofFAUxFRTWUg7AWGNiDfQ5sDH6HktZfpU9ivainy6qpbGJ5vaOfqrIi qpNc+eRAp0ZXBglPS4nY4PSdi9w7GZFlqVVp2Pg793J6yikfWMYl6O7T8zjt+h4dlpuKi7nMHCOh ncopcmqAwfY+gFs62TUoqYiIQhJiamkh2nNFF1khShOPhyWxPpPS9/YfPXqmDx7Gppr3n5286lkn kY5zs7+LCjy8aRjscNypYwn0lZjvO4xRMJHQOAccXg7/MrgZgpPUBfmnqkmsCg0CIV4JWUmQpF1n BLonIsdG7ayp6GZtjUn0q8HsdP0iZsGj2NGzRxNH7unMFD4MhkYGfQydoPq6uh9fdm3xgtBVUP1j PBX5bHbzmMDUqOdziuplFVzsiV8iNQQpAzhELQO4qquK9NDViFESaIViiJ5UFKEcF5a142LBmML9 h6SkxDIvCAxqLVQKCgUI2FB8Q6VKggkRSo5JO6NJ3+SMN0i62u+9yLntF20heoHRBtSphZoo7E05 EkY3igWDjE+IcAcevk6+BQ4UB+xG/+XekJHxnHVBREsNot/ZRa1gDLpD+v1yUaJtvYc6LpsiP/Lv PNfLx2053mD5qBNkKZSVGEmRNJc4cZioLh486jmHnKUiMF903k7hazi+8iUZym9w235LJ8zAw5XQ IsVFSWiO0DnjPzydY1g8nRkTG+b/qHMnLUueJODRr0t2cTFOh+smPipnbdMvKiXAGYuZkqwa2nzh YGcileG4+dYlKIWc0RNmCcLcMPQ+joqE2dFFYVBA6geSg9Pmzp8ebg/l7eb5NqUNmyOuW7cVDjKe EvuFSxX0DUIrp01nd9mkG38k+XNlaidIIrrSxhwLpuIxTR3lbw6nwRHiwMlYEpHucMKMHVPULcMH Kc1H1ZdGJrIY97cHRFsrRFSyIP0hZGrSMRbsXiZyKepxsm/CmpxRAHjBUDFYOTTypKKZFIx1IoEl OT5Gjtdp2HN1Po0fRfG3LLS22fV2R8SevqpvDuRuuy4ib2uSAYojygYQq6WAiKSGvNQhYNIaIOdl +MrSdqJSY0UwlmDPznMRDvKOWbaERMBpI9R28wfI8EQ+nDB3iFqh3nrynGifAYIVcs1RhVAfGUhK AdCAoqFzRkl1BfA6k5+BgXGxu73dyj+12Ob0x3LELZEnqsTT8ztV3n6zE4jpjtRLcai9QTpE07B4 k2GqzJXcprrSLpC/xG5EhU1sSSLrUUFg6C1ji8gaD32Npuc7EpExMSRI3XiA3p86WLlSK5xxjYMz xROCYHAnF8zW/SvxxRBtuN/ErkgiifqwlyiG+bfekm0zftPvJCQR9HwI2kl9eILn2+hs5+dduJSw PrgVzn+nlCXz4o0+gp476WdAXyD3FYUiSHEnqDDWupUkqCR425678bA46lKUqR9rFYx79hGsEB/H FKgIYDhSBQ8D9anDwcODFFbuxO5zcnJs0edvNyq6z7HDhW0MOvatVXRRh8TH5W7ETzD8rsbnbHNo rf3DznPZXSdrvO9u2LUKqK1ErKeO2/UffWejBNJiVoIKKiIhITWfAnDAyGTGo+r2djg/iins+eoo mzD2qFcLrEUdm6AHDuEdjh6OVP1vZHKRUGUXid8Akm41CR3DurRHlfIeHbOjkRhkYs2PDAQcUCjC HQIVOm/jyaLCI9yexhg2lZ7nnwhelwpQCpc1jNz9zZUiZxBfIqMYLGnqTZ/gqzGLLtvpNRPbY6sH g/i6c+7z+4jk6LipFdiDFRrcUA8gWktotSoKWMFtdjuKgRFFAUE0RouPwIaS1u2Q8KBLgTgUyB5W xGKfiqe3+TPbuTJ6/LZ+ze2vEHZJ8qb+BSR0hgXwYngOTSZ7AglPPRJFmPL5A6rTKNhATocVJb4h SGjeWnQZkRE4GcELSFSBLWlwIT4wKFvdJHniEDVUNWGxEFEAvmiPOQFz+Uyg8rkUuYUZgVpLeaDL QGUWJjqoQx61XnFdRtRSpSBnMBLyl9kbCFNz13PNy1Mj0mKFOhGExTXZRfCZEU2GGQ+CGN4xA0QE eoj2DeZlzNSlZahKgtJZFZCq4vL0AlBYpvc7zMar9GdCI/AY0a6ihPrcab/mi4oB5uCuUIGKtSSV Zw3lst6rrGU7MMjUKb7CKBsky2PZYoQgO2nsUxTcouQpTQDb3g2zPoSpQTnMjE9RiRtpNRj9mdlw ma6hUgiUi6O/MTRy5xyIoI5RfLz59lOpTrDNmdmZubXs/UvzjMz5rvjWMm4YKikQfUvaWiXGV5UP sHh45qx08B7FhapMVCxepEae57HkaQcqH+TtafuzmU/Lw05NjzdncUTmMmCqlesJk1GPpUOUzpYV kVC0ZGYUqGfiJptbKlPByrH873Dk2fd5O3mU5/NidXFaIgKgppMJuIXMPSBvIhruGKxxIdnGRgUU WpqCRUZ0il30kjEsQCodHHa4cOUqHJYCA6+qBq6A+ssI0NyFweU1M3hN4NgxPrrwRK80hpWXyRVF VFXpU0GgmgJ1LGHQoypJLdvbWbpAxtVLlTDveOgVsmgpBPN+j+MAjrYz14q1dNaH2pjkjWT6jCax 7/uX+epPUNTgm0ZP+ZsnXyPoxCGGQUQp9kMOJI9gHM50lQ8mwxSpRj8DpMAlfiMUgKChgJKt4lRT YOLwZiRp/TcZ+SyCOkhd9nTHEROrNpuwtEwwsmp0FxUJqETB0DAciNXhY69evUe1wHiXiPX7/Xdu giSMxViUCsg6yDQoUpooj2osab4bVJpKk/jf1mNFbK2YjJBbEqyOq3bJyUrzsG9W7XawaWTGsiYp V1jBl3pecLogXdjIeppTGITUFKkbBk1Y0pjGmmLqyMpsa8J5zkjH1mNMTQKLORANxkd57j0GwcMM M5VUkaqtBXUQa+vR3D0U+FTmfi3e6ei4j0IrucZ8CvW/yM8/g06utPGWOFWxelm3drRu7Fwo04/v p5PihwklzSCT1dqFhT2PysbKJKeQwOZFJ3dvybJLOxVLlDei/5c9yGYRoccZh3RCa02joXayfDMv 7eZzso8Ik4l3EzEIpFBkILxFxPuhPeaBbUxt+Y7Sq+YYbDVxQ5DJI+RDM4x757Iukddjx7ya71fu V2R6wOWJsaMw1RovTaBzUBm0xRkIkbZlxD5D0ttijzxdTwMWaBHN6jAY5A+4ZjZ49WLDDHJ3BssI ERog8CP3k0Zc7FHitn87tRygyYZuDZ8ZIZHHrbjftPDxjDmg9n8lO9vpjqfMF/6Pf1vevU2cdLpx xBY1e+c84LbXEQjJ51PsI8edanj+Xsa7HR3ljXAdzRs1Q/y9zLXrxkaDnkY+bl8EjZIbwUeh086y T7iGHDPJFmwyH9+Brnz22qJuHqFDAojs3MEZgpxAJvRUEfx++0ex9LL4c8Y3lxDzZ34IfwGKbaaP k7FlJ3tvhfDVue+ToutAsGWjoh9YsI27x2PXk45PBByZN9RcM3ty4f1YIIbIOOn7uJYkYkj0UDGw fCjVb8qe06DHcXnfSjwB4fsTyeSW2B0MzjIsfUFYYbEDnqYDhEHIZHHhtCN+dY7Z4755Mcv48GC+ jRjdcHOChyRdK1WSIzGW5xI89r1icvUalGcCLGKROvnJo12fIjPDWZGQSS/mu0coEei0ZyFDcOPg 8oCpsajwGwQN3MFHHV+ktkjY4g2dyMQUJxH+0OwXlr0u60f1HYO5RRr2jmDpm00wcmJ9t2vbeBtG MuYcljJXpTglQxo4IIusobwUc7Bw9a8GxpPKFD8knTtBP6q7Vgs2SRDdex6tJ4JMws9b6CaIC4of pAYKO5yNjByU3UPlzeuDV8Ywb0HqYMYJvdKtJgq0dDo9iDrycAUkaWhQM6l3JAbx85ViaXPXjwi5 H96o75nFtCRUxL6yE13CF4owmEGJZyKPgjOICj9Qo5x0IgnElVSJQWJFF6L2y802jClhwYxNYz8J Yhs2fB0KQhz6k9TFrgnYOndWaxYka+syFfHkzmh+c0bCS/BxsE0FRGFp+FALINcWj6ycYzcoT/P/ V/2kGNGG38ArTbO34AdpyW3ckkGwcFnohoTNzmCpNg/cxV34agadRgS6791ZMiUNcRpV9hMjcSGu LuR19EBEIXA5uTjmwL4NYGxk8DrbeOjWrbbc0BQ/GTDnGnRLUqIFqhcFFc1MWgUldktlNuCQSkJ0 lWZaZAUmIww68gd5fVW5AWgqNjgCIrhe+SA/pGCFFzLqm4zYjsM1GgkaF/nQceVKYu85ME6BRKsU 7wxNYua4rjEcphLMxtocYKSjTpqJJUVDye+BrCY3vgbxR1wU2BXd2xq9Uxld9PjecxvsJhNLFMgV u/6xS0Do8DCZujNBrTkoPdDizbUfHJIp+PGDgQ5r82DAJv5BjQM+U2RBgs/rgOqnZW14e5W5HwZ1 03hTTRVNH+3bx6tlaPXuS3H0RQYdpP39vAzHO7sDbodxzqCG4OGvdFORpR7GdSkDAMDnOv9UPJ4/ 1KcjkfFJSDcqFyxmiAR4B+QRyFH8RjDJq7Rqd8Gg8heU2OAfSk/Xu5r4fMCSWqD9JzrkswehJ725 fXcIZmOBvyMRG5+o4jZKxYdyzIpzO8sO31IvZr0MNMyMVCxmf14JBrbAuBdIIlGNujsPAdiwyazy FnxEcKR9Rme4YEAij3r44KYyu8aDjjciBupN9FOqEfFEASzIpt+5jNUQYPBJ92X9R/wBCCz62o42 PyIJ4sye1BlSIlHiNNuwo/aGsR29epNBXBhsHBOx8NUm4QkIWlEJHeKTnLREzRNRXtX6Ci5S+lvF LmCsOxNfigFsD8aoGGKQOgKcDs+tpLycheRoyFwTDTJ9bMjKt8i48qFtBkkOREUgAqFBIkBvFOnr g7crdJ+8l8Hax8o4LbHT0cdF/tfTGW5wdP6lN+LIims5D42OcsIkZ6nk5E4G/AUVKoUcmcoR5Wzy wlpuYhHxMV7P4h+71GPwcc2Eldp++/ejm7+mh8mDljpEmxYKElQ7SsHBogKQR6hScI+HB+PBeJjS FoRdmETZk0Bu1yIEaC/MJSPNpeeD6hJRBCCZBp5H1bLKC+JoHyMxWWCbKQjQWPwCI58tg9+8yckD CBYXijMKmwHO7m5iXeSpkxFWTMpEeK+4Uc+tyivQ1jg5SYvrUa2rcq0DVAThlp2HOkphatAUg34h UG11W5QeRJ54yrGI5EUeOE6ZvcHU4d4Imli6wKUc85yja8jUTLFtgEhcasHVjmFpNEIoxoMT833J 896GpvhX02dfI/e58C83Ixsf31pi8WxdIR3GlzKfPRcFX9FXd3GB7GVpIwo8oTyNZ0HjtHfCbEm6 pHxFtAeUjxeHacGM0Y0fqrA6jMfEjU4evRQQzlQgyihgkCADhnJ8zWnIEB4n7F37GgQH5sDHDBpG EuZ/Fhz5Gba7U4c1pdAQlTMpeBzwYZMD91oZFp0VBTkUl7oi1vO0PO8HRCBUOEH1U9wqGkgSLuEn 0wcOyEKffeGk0nAPjYUVr9juYqeIg6tlsEpMiFGgz9Be2g9K4ocfJHDxuAiNjfUQXQH2diPgMB2i gkSkUvC8+krMK0tD7WHKKeeggPMU5AeP5WNZszplpY3+H0FzKVWaNaST7qilESBCFShQvpGDJSa4 5K7+bszbFFetaPyZr6+3TzuE+JqDQCiGcQ9Gx70zVMwuA5w6K4aIZnsu6lyKUjJxT9fEdqx3gG+o nZR7i8/EdHshMoKnSmhObKJPJr9lEiEFOH+cDZgorZJMk6JIKJPfg0Zv8JKOLIDnPiuCed4BNhi/ seIptJob+eM9BRwXzq5MDXyU2ZvJHkjq8P2NGtuK8SYRGOx2MBIhc96izaFsRIffBBWeIEIGc12q UcbCORx6ggaj6YCjZJk7Y/vHwaBZOOQ0dy8Ynh53Ot6ktmPYj3bjkMjmjZI/IzGyqqhc2NEmhmO2 P5Pj+jGsObOXZzZLkFaRRR8Buq3dDRSX7ZnF6GENPdF2FxsZxipBrC4Qf0+6wiKGnF51sMPIJ/CY Q5kIk02+jv28sojkV+MTzA4dDuBKz04XgXJAIWHHJjvQ90WfiAfKjK77ijdKfC+2T0wOhHtXuQfq EQu2yDx/Bgzi/MJ11glD64tQgQV5WYQyFOw63SgTKAKYz9iJhXTfQrRnqU1EDIkjjXWxEcmQwXXS cI0A9O7VBQLIhaEfP9/O+2ExvfqaOMN9BeRrZx+7HZGDbIyecc8WDYh9k5LPbR+7HtB3g0H8WYaT 2uKcUwRAt4QxPSPdXwGKFB51ZrUHA0uce8cjLpk9msHWHp01peokKf3MUOKBtp3jz57RKvIKkzBL jnqcV7AJgKXUIgVypGNZ1gYkxQwIVV1u2h2HuHYEZKdtlwOBosiqMKgusiO9chqioppzhMqHpImb 2HA/ybzSTuJSBdBx0DudUJGYr1qql+djjKk1yyIky4Z4t8J5mENFAD13rjfTkOdUpyPIOTyoDChQ gH91REYJFEKUSsW+Ug9zJH8dZBJymKmRRUjrSPlUep2IxO1L3vkJgwOARBwW2GmozD508BHVDE6l AY7IcoG+5uet2MhxvJzhqtGxxJt7Fqet7zXEgBQ4Lh4U8LR0AqNuoEwRbAiaeoPjEcMuhE+8PIVc 34toBwmkWKb/VIxgwOJNNw3qaQ9eYtAkSUhMEVDEpVQobEIWKG4wGdAM5Rzou1+14NVAsveYC/JM mDj+rh5Ee6QZ+F9x5nNO8hPFpnjtTs7OrHr0f0iiJJPbmPZa2ggir1mf+4ofP3fh6f3IiCkEM4kw 2ifxjzo3fQvD8HCaaHwzI8wrolI3JpUd52mlQQzq6ypyJwoD6DsHgHUCyVCIobBdkPEh+F80/D6M A5QG0nkg2nqk6IN8DWglfdJeU/WR28YHkkT+cn2QbS+WekB2DF/T5Ij2nfN39oidt6ZEfmf4H70/ 3rD+U9G9EDWUz9lj5W05+3Y2aD0JmpSv5HkxC3wulcoquW9XRZzb3GWzksekxQoXTufSUEgP4fxO SjBTvqrgzWk6l0+j2aE6XogO8z3NtjV+uaArslyDkT2EHeYb9dF6TcdRDH7+L59gPfA408VZyMTD xbYVop/GkdNPp3Nnd2vuvkD9OYc/9mGZnHn31ashTKqA/NeMA/J8+K/xNsXnEwXr+D4/qzo/XZe/ 12u2l7Rn45PjkSD3v3riqq6XzeXO2+q7aull3XZe29N8fc+W0B24fLpB4zsQ+hPlOB0bKb+NgoeW +m3bjPjVqU63/e+W3bTqPx6k8JG2206NAsGC25xZd7GSHy8rOpT6ccPn67buIcKybKfZ/y4+jlE3 0TcPGEdMmd6KBk87vtjuKhBi/WudcBR5vG69zEjjxckFCHO1jeQY+JTYWHc+Aj8oq/PtPHyFTv+T DZY6KUsjletjrfm7e/2exp8lPqKcJlWwyBOLxAq9UhxhwbU/uM70mowpWutmcKhdBu0tJly78ygx JKc8E3HM48lABNHSGQDpINAqFF6EeuFmpoojiJJEEmDzoIIXBF4XGtbTQLmLGN4EgZQwOrU4EyHs FxnLnPFlAm4kd350+UNWZDNIQZiGH8gZiUEyvXrkjVj5x/FhbOY+vDwcfu1JOK9Z1Px2fL8Xn6zr fk39Cpsn9hgn9x/EzcGsN0Ki4spM00xQhUS0P/H/+6dB+rEMCiilIqQmBpqgIhpD7JMYAKEBRmRk Ne7ws1ez5tv0QzyPdyej9PwoCNh2FJ7w1Hy/qZH4Ap3t5TqJlZYKIpVYeBzTHStGM5B48mXFokHi SDGR/I/uPMCJ5zAYoLyJ19/eyretJuJFxcZOOccRPyMx3FlVxZgXomZdq6R4xQLYuQupQrKWPBUN GjQ5fgyMKkWJRNH20lYp46x489BaMCmc5148SkekHQOcfgWnsNprPaMVHEUO68tLylBTqad7GO/x fOnmVXDSuadjm+hv2OlcNMeseAm47yiRCbivfafHBdB8wYnzDDz1hAjQewsHDH3GgoLzrNh0ndyl hidV1qUhFOPKdpRWSNpE6TebB5ukYmY5Q4jBI4HSWkz/c873jzx5uw5FLunwcCIaxUT9h2G5hHlJ sGOQHgf4H3n6D4aU518lZI4G43FusZM5rOAYnJCzq0mYrH71YvKCJpPJPL+zasAt+ocBrInWXB95 uGE+AGcNIpkZ4AN8NJyBCB2jHYDFB0hnKdAGqw7yaht/uePYru8UIPLCgpD4sUdxzhBEeKR8gfAe ek6itT49HJ8xYdAWn9jvDYc53wB48UY8hQfIcMe7YeIp/MPETeKdXVz75YqjGAkBETUGufcLyZHp A2lQKdDZJ4niVeTsK6s1wmfvLc3k6ARjzmg6xOwBDQFwfeMKGiRccg7s5BvQmdjzFCajOClN6RQ8 vkHvTSZjGhD4/vH3VxVUU8kisvLTsI5e8+/5znX8mU/JoNwPA7D2mNpAs1HMZ3nyOcE8BfxkD8ST IP54Q+kkDOjEgg9NQaihfXf6XYZgHIuBJ/tJ8PVt7H22fz8jyinwDYaj5iYeoQr9jiYQEPw2ieo9 JEIWtdUIJYHirsPU4HBR9rdir+Pd1LObxns/Gs7P5j87t7naj1J/AV0aTm2bGJiSq0aY4VpLsbMV VaYxTT+r40elXQ7nvfI/Sd2QBIC+jav1cRRTi6qMkYYYxD0hJwinNqPyDEQ7hCRwHDiAbgvQrE0l KHFTs/AgSFoi31C6j13G2pwK8rY2EmX/jgO5xUzmQrfWuC4irESZ0eRIIb9H1mV6dai75A5GY2az Iv6Y/N8dQh0GoCOdgEiOGEzaCiVpQC8q/ZSwn/U2oxQo+q8VHbz7TGszUPciWcgXIdKYDIaTkDOK J9JkeYcRLTxwDJ6OoC0JB3rSqeg8hwTD2kKejEqTVNLASRAUcGew77mniEQ5hDlMDmFqX08Jh60B UFGQVhK3f8T8h0htP+yjk5PgYTGsshbbZVUj8FMU0SuEhQhEnCyCIlY/gazQGiVwd8MAiUSiJUhS EhCBgIK/uwwJkYhiICU1ZLQhERwRgRBNDLDxg4EESRBEmwEA8QaCeCDDgxyFMJyWYDAbJIhmAfwG FDIWOA4AY3yJGEoVqNXWW1u2EwqjZg8RBoiIkYiVSGIUhgD/KPrl1PADKmQsYZgxxgYgUhEkjFAk sJyzA2CeshelqDYOgbGK0WJhUCmSWTFORhlUkVkwrBlRUvK9mzImyubDJDop+dPkexPIfOsqz5Ul H1nufR7n7OyGU+psidH+NdQROhwsxbF9fueDjZzoiRYmJzhMkdHWtWc4GggoJ/Go8LC6BQ62Ionw Bh8u0D0gR03hUewBSkDzAuP6l9RK5bj7DeGa0Pw9x681EWkuKvrMHMMyuN2kc4WcC503Ywk6CsS/ H6oSfTEd5B53fPutoVINKtWdiHJHnPOo3kVAO09uwqFELKo2LksO/0dschE89OH1Z/mq5083lXM2 rVXHFeGfuPNrdc83T+j5/53mqAnNKnhpjFVP1bGv7Nny/L0dPhfUU/U/8dptpP2T7R8iGJZKkxFY pXZx9Xf+DcOeck/27Jiwq7Z9TdWBtCszf/fDF/eEPn8V7PtPV/bvDRHqAPq7vThzOhEf7yFOZpNr 9RuOykrzgJ9gWm7cjxStSH6DqT1mioE/Z61sPBRM/EMwwkTpieUcaYjCpeelxxHN65yM2YqHHwCo mdZyFTymWRrJxHN7IsKUE4q9hR6VEyw878xL937SRz6akpo1Gb0h1lpZoJf79BI56AkOJ1/iUQ9F kUuzh+pO1xMURTrE8v8wE0iOTyiojxUFaKQKT9wuJiUNAMVBWR+DWxpMwwHJ5BARJqfwkqr9IQrv 3HxtA/mSuRanBMP7NJNFRU1VFBk9AA4BwgfsHjAjko7jSe7lObkF6vMZEofvomKaR7CrGjdEeQ87 i1ENapgKXhilJLgVnLX/6GWj41StuN2PUT0evvT8MrSztSfynI/tO3/pODxkr44UMVsJO8vKawDb HHGDJXFf3fNmmZgpVSbKxUZUcOMbt2Hukv1kHBIvLeaKajMyGMMjBuWl/JAlSDOMqoQgLdiNJgMM hjQ2ZTAq00lGVkYEGCSTEmlf5oUMgiutqTYnaOUZLUMdC5yCfIHJwQ+c9h6zlcfc39TsP4nSRP2H 7UAwzIgqJmLR6g4ZAQ/K//w8xoF3JRKtyMpBKViOC5EmiKFDJGgwlHJHCBb+OaHSt60P+7/FMRNm 68saVUmGHGtlEwYYUQJEMMwoQ3DAZTQaGpFg0VuurNRsYxPrVKqqqqqqqIiIiIiIGIiIiIiIiIiI iIiIiIiIiIIiIiIiI2IwiIiIiqqqqqqq21VUqqqqqqpbpqNkxjTRoiQaGaMITDVMMIQwPhGUFogc UWw9h/4GxsNYIxENEFDqKBBmKyGiaDRoVZSU/+NsNjSGSBpNJMGkYYRpZssZaskYYbI2Y2kYdH/9 OHDcnWxjljaodFJZphtzYOeODc33BsShDDmQ0YaExgW2aP0BuXbDY2IcBrTaAxQaiwIBQS0CpsUp RaWgY0Ga42NINJODSDcgrslgxlpZRSkKEKDKMKblQYsIk97yMNmMTa1XFM2acfGpu0srbFbzGylL hgsIMWFBmBC5DAzcZhhi0oEMwwFwURMFozA0DGDRRanBhVUs2MoUiNtZoZi0GSoImQhgsGGMf/zm jRjNIxvIYyKVgm6mLDAwhiqxRSNYijNQ1jiGaDkwUaccFhzAmaCxCMN3jZxrashiVHrF0JipqGik Rg0GDKVkxrBiKpApegsMZTV1sRYDSHsODMNhjGbFKUhCZCEQQZTAmECkxjwIUIKsWghi1yNJaGU0 EDYezJmOhgiHAqaHnBCsEYmloWywZdhjapCAmNJYNKjDMMMZhcDJylYZDC1QyAaZhgRapQwipkIo EAg5MMCmUaUGRy4MYy0BYYOjWGGL3kNZBhERERERERKqqqqqqqmm7Zs2KqrGKTsUMIFRqUyJOGFk GH3y4MbMHjQykRSlKQpDRSmBAZkeUwgyQiVBmDMMIMozI+JdGMZShIEZEJmiw9syp6ZDRm2JBhRG FKM0rI0U5UhQpDhmbKPSRSQYqbD2NGkUwqo6aEYYUzFRHYMJkDB2kKDB0RoiK8CJtIISqGEMwhRn YZgx6y2wJAZpY8rA8WlgVQMCKaLTCjlysLRtyBBtELIS2nFpRjGM0FiZCESYaEUhSGc2IweaIpsW 4tqmyx6IHCUWSEDiHEONAinKJI9DNHUmV6LZoiuYN4VpuBsMgzGhseaKQde9If9v++5iQPx8FARs DbwaLxBDIY8LjeTCVj4JBjXLNmaxGyaM2QyAzaGhNBhgbG2KjZS1BSkuMTqphQpTIuyb4tjRNjdb FNGIhIQrTMaLYppG7G6b5eSsrdTksmikcK25bGmLJ3P6WH9azqlk4WMKxmRLYvVckmkUYPf5T1+Z H1EfhmnPkI7TonYEKwSEELBowaHvaCUdQYtSImgIEMCETqSd8rxC2RJtswyWFsilgbsZGFkZAhhK oah1KaLIiDCcqcNjJKIPFRHjArFQ3ezFHkGA7RB+8Vfm8K0n9BNu2KCNviIjwk+mgtFCQiYRNJdt Cub3IZGjNQUIPiaHK3nBwlNZeB+goEPWe0g5KDVqViWg64xlyme/Wo7fHdO5S27PG5asajxSFwl2 l5EsQVQ/PBB58/ZczrhvY4bOMTog7Yegg2nZDnDEOiH278HYJ7pv/TKqIX4t8DoeJxJpO4tpNsc2 awgHiGJdvZA2a2k2asiP8SmSVGwztfCF07G0Rhz+ZMZrMNlLFex9pyBY30D4lM37xf4Gw+dyE0MW Y/7l5SiA4Q6xYKtui3WqYKjzoZkPnU2880kexN9lSeqofM4xyVVhDmFShLEE+tUilhIiWKQRMYJC jBDQQ/4f0ZuTl0w6pkRkIoNH+awZYRpZyxkzUndNj/cfP/BrkeR+VjmqTzN3krReTHVU15bNCqU0 9u49hd8hXg0GLdBFA/+xbJhCoTFoSIeIbtxRochWFUqRwwj5CpwThjmYwnCsSqo0bDU1LLFUYnDE jhTYsI4UmKntUNmmQ2UWw6YPVUconUro0pZzlvpZmzOSsVEqL2FYfyKVhhS4KUwyTCn9bTxVs2OF kRpdK0ol7NNaoVspUO2JOip3KTHa2UqcBsdkNcmzuNDClV9mJilK4VN2mDGMGjhjVpoinJWpNSm7 c2aqf5lbc0YrEbf1n0d/sHwRzd3L7+48TtRsHEh9r3qwg0qeRTHtZGjeybJpSf8GeTTnqZ9X92ml Q2MPnGObqfz2Ik8vodidFf0N3VparGPerRVVRoxhzY4TTZVVoppRdX59NXW19PJMRsqx1y5hSdHD IaUU/RFf2J/I097zNn55CcOS2XJDFVUVh1YphPOrRCj9Sg/Dr8OnldVbe/WPS2w2YxVl+pXrNGxo wsRhurUoUPkqNwoIDyFBEXSB89RA39XzYsWzzMbJrBkHMlkInyrJKlFFGg+0H8TyhLJsCe0IA3RF P09+vXba0rjzs2iENKRTwZIr4dm314Nzd6DG6qjwzHNHuKVTjZHm3z7LPT6Mja7fTznM5a2STGgl i9uW1lTFVIgY0DEeho/SNZEyxounc3fWhu8DHpdp3t0bI6NycJo0TuK947CUk83pO1VTZhuxlNKH cYpsTTl9g0mH4EP7T4DdjKm4jc3Nm67G6hiw6p6KLKc9MUxVc1YSujq/0fB8WXns5I5THzNJOxQ2 H1oqJuo1JJNlSMklPgQ9oc3zdpi8HgPBDEHsM6zsQ0qCczzsSSTsVyVXmMIm4+Futmn9jg2cbtLJ W5TZtuaN1N2aVW8NkYjGNjZZHpFMTpJMk9JXgqQpjBQwxkNMJBKJSd8i47iIwbRhj4mxilUp/8FG NmPM0UpSEGIoMYhihBQgol7ilQqe5pu2VWKxjHmYjZpVaK0joVw0xGMYjEUsVQVKmFIxwqaaVUrZ TFVF5d59awNFGEq4voveeByAnlmZc5fP8WGvjxOC11MGXwP0FKMyIFFvCgxAzsAixMYjcQvaa3IX tHDCbcY94IdC9o+hxOwIkr3vt8tg5XrUHdKiHsPnMSD0q71HtOZhjFNkqZNm0klYbJ8La/NbtjRJ GFkSLN5csqvTK/vdx/pNzxFT6BVORMfapzdjsNI2KNpKPFSlTtVqF9JYmx1MGHa03NicMVjKzq0n zPgCc0KPONE0s5GGlVVKUqVWMYYh+FhUraIqpobitJKTExUhnOmU5RTWsj01W2JnodzZspa4/o/T mz6j5lPJSvmdrpyKhjkY9qsUoqu2MssudoVDi7fdOBtNtjsZw0xthDTU5dcT5bxNk4jT9Jo0dlN2 7Eko8klJ86ow5rCTc0bpJ3vuxNQHnWYkpI3wweYUp7phuG+9VeAQfIlpCaC6lKcw301CAQYkG/+e 7YPYKA/iyNvqsP94YKANZ4wRE05uYQPFlpIQYGNQTP5mhBBr5zq/9/4kKbfu6mf28s1n5bvtJeJV p/JYTwVGl4JxYcZguBaR/MQ2Oi/4yQCYHPh3pn/TbXK+TzaTvPjY/+TxHNVV1NDHcaPA7nJ9/Pt0 9TuPe00/0kbufIfCqCrJYRVglUoqyfIIqVh+RGiTm4WdyaMSctNFVSlKnZsxVaFFQhip86v+ayAx UoqlVSqpVFVZUf/dzHaO4dpP7Dk+cbDsElFkQ7Ck4ShUVEVFEolCpJRUpUpSiipKKCWQVIiiyRUo pKRO1HcyNVHg/M87do0/arfdz9r9b5OibTsbwOB9XfnrPT39Zt9HMhjqfl7dnSc8M/iopg0kkWg/ LmEkT8SyQOw0gPulgvjlV+MJMgr/ZAhkCn6YF++UTVkn77JvdpX+7zEftIfEoFWEO8pXcPdOuJ/y /iza/6+d/+HUDfdQ/TJkDEDQRehzMrHGiDIxNBmRHlMcoaGVF2rJVn80fs/I3f0s+VX/E0zZh9Tm 3NJp9r5U4JsbmKx+N/+iv8j50064tcOG7Tybv2NJ1dWT6bdMR8DG7TzO5hs6mIqdp2mmpsfqV+hs 5JzbOiv3ebhFiqrydphzcOTT8roPBThsOEtVJU7kq1lYGPE8Dq72Gyu5p4H3DXP8LOvNY+Dg+BYd qMh/QWYJCzkcosco2OWIZ4cAYefTMxB5/qDggMGhIaR5+Ax/z+n/XeSmq/7mZ9H/V5QuCnGBcLB/ +f/TIibRT+BpM59JBL4humbPmzmJMwGJg4TeWDukeHuDnCv9ioqnYQE0FZdSKpzDx5WfgZA4ITOc +JSbnpAP+hcbSo5wgaC8/SKYFIoGIoxmOwgd5kUmceMRDeb+BgeclMY1lBEhI9wqODEUUiUEy88A oImoxLxw98TZmx8atSNPkNHwLOG5H3NMcnyqrQJUYFgh0lxmNHVEqMCwBQRx4HOaykoiVHISIkyB QMKKUDgpHjhjtcRM5pNpkbSZSWF50ExP2HYRIBYHIVDFNeBcZhzi8zEgmOMB48CoHjhgIEDIIhsi fVvwLSJ/jeONmRcp9Y2IqOCYdYgc88HmQVFh+NJUVhz2FqiuBi04Zx0e9VU+7o+5Vef4W6TZZ4KK 8HmNzgFFQTr9vl7jx0nHn7Z+mJ5DvPTSXWn58Ru6jmvNhlyG2kpN5WY23pAFz+Byg7qPOIHXTSHF QQ3gn6WMyc9J/Re4Xhp7m7HPT2iXglgpy6TiLQ42UmQXn7P0HNqKTVkIaBMVBLwRROjEmKfjsPi4 9QXnE3DA8zHpuC0XFFxFFAuQwC3t0f7DqP+YonyHjDhS4YcMWeQRTEP3uSB7v1+vAnMTUYc8KawG MTT2nW83G7T6DyKdUZN5/hvwT1az8NAc6/O8Jno9/+Niz2B0pww4FVW5kkbvWr/MYeSVf+087naQ 9KY2UGcCQxvNBWew5JVv2m/xNVaLZhtoUzF+R5of7kYEOVPninnNvJ76BE5D1FYN8S9j6hnYm8jH 5udaDs5M6LEtqW2i8Riv2EKq4SKfagcYBWCCCBQ2CFUyR93D4yJE4/L/7f6Nt4XbkYKjhPnq0blF WsVzlM+i4RMcCVMlUzC9J4DVLwGZZecd9FGbh3uGX5bDmP5Dxg1a0DnO00HX8ch3m3Rf5i0zuoke shbqLQ4iIoiIJgKiAiHh9S3+TTWeNIV9pGVl/fpH0CMIeklQZVWk7ECZUU8gaMkTL+LIwioiL8uM VDeFMM9TJqyLFP/j4WiXQ+XSJLnWrqfTmclSdZ9jgP/R5tPKWUhzFhW484p7jDlcJ85Johg0SLiJ uazQjXBcn6QIHaSU+Ef0PQbt5E4d2ROjMc7Icz63x6dHpD2EH+Xd/V7vKcRD/l0nijKkknJQ/G8t 2awR6uP+iyiPRGHAxG9j0gsSAxNF5yOk1DiT/gOb2n8fg67CuWtZ2ZVXqj2cHNLR8bYx2CSEF+0I wZX2kGJAEShSbEHAGjvIDS0kPtA7/eemzupAzSxf5FpkBjFT8HT4mfyH5yL2jND3/Q/8uuLpH8X+ qB9EdTj9/U57t0MTsJ/f3j6DMQwkIYBYPMmQVYeiiGRJZB+4RGSJkU+5MjcUx/af/rGvR1dq5r7v u/qP0J/Bu9SlOdEPZIZIJ5fLilAOpaAoEG01PFk/F02KVojP3D9OFW8Pj0Y/twpiNzliZmYgHQiR 92ZkxtDgifpEfyC/YA/QfOHaPnD/3HD/V5+xPB7+XY+kr/EnN4SVhlSYMGwU/ubMq/5eePaKm1Uc FzDYeRwTVzh71HnSpiVH8XzzCqNL8ooxJyZgtCnYMFjVeMUBKNEEq+6hNGJaNwIPSCv/oLe+Oeo6 /GPM4v8vMbqtfgQ6SdGyXWuKxD0Vw/4KprIYKVDy6YpNGxjHavXHLpP9RnDuC5FFYRgYZiknUt/z pu/uvz4Wqky3xsgt9wL90sL6FEoWQSy5+yefT5xnA6xz6w3UWQ/fcEiTZfpHS3X+2y0V8Tm5jNOm RLnh4aME/Eg/7l58eOwWVUGWDb5zH1nBqZGmyA2RxyKaZx1r4MKZzkRGsuNYvGe86YDbNgTJmfCA IBiEOwgIcB2hM3/iAu/HFxf2d+j6OYMyEXyuxdZVzpanzlyTYEHTjDwvBmcm1vHbOWctOFxDw6dK NMK3JTNA8pbUWLSe2Ao1ckO6LHiH77eLePG+CxubN1lgErmLlnHhxcmhB+QO7yG2Ci7gpIl62hs/ ncckM/rh4MXwSH35eIKS/rrFDkXZ4YB2+GJ8yif9GBOpag+g7Wp0QfuM7CWPN2ddlHXYBlHWx8Vi rv44vCMHpL//ZZDSKsD9HZ3RpVdk/t++cP0nwdKn4H6TdhrfUFP+Oz0nMY9vW9kTZsWN7Xu3v33W EonZhmpJkuw6r5VSYeaKCY6/PReDKMPA3J786d/a7SaJ917KhufI+zNCztXf1to1j153urJOHmZM FhwbmBwJtJi8qXyuHgx+eneZsPnFyYWw0lVce6V9/mbr43AHJ7YSJHR+OLMAEiHqGNY8Av84PvFU eyZYFCi7jAZtlBTkFIZypDBV6aazU21WW1ZHptKyu1zefJpGNSizMBE+ENSsGUI+cDY7OYKYlDWm Zezt7af00iKUpQICTrUuH2wMKxtJ7Sj1YDCIPpGMrYoYshYtpHG9l+/RajUT0LGxOuRNQfadX1Gc JNLK5KnRpjTGMYxjDpomECERMRARE1VVVVVFU2GECHjaWmKJqJhTCBgzCEKMpCIwGMKQCGS4MZnL H154YNNiG6KoaaqouRwaMIwjkYYcvX7h7DqbbmYyFl2Obm5tnRSqkVTg5dX6ngYFYp7S0u0lJgiI DKGQp6brhTBQoUHGJiYmgiGIIhiIIZYA6p48O3o3yZ4HmbO7T/5kXq3mbzw04VVWqpZb3sjtyCEO DiIkkuwjQO+pI2S1s4IHwbOs0xxPUOc2cxynN1nluaVp2lqyVYWcH/mjwTqHzD+gf5GybHvvn+Pu 9DeTdXy4ZVBMhMUzNRv/DDH0+vdrsD2Ybw6KEvZ+RzD2GL5wAfjBTEO2NCopN8Z1vnVbInzueR9N bSjtd96MseGy03I8nDkyO/Gf+Yf79+LbUclpZ/RjgJ+eTn532RlQHgYZSgUbqLTHkr7IP3FuviX0 nCGv3+K/hP7u0vHlXgqxZ5bV3ZEdpSC6szYm1AX3I+sNaD5Jffb/qwPunUlHrccyDUJvBSj7X8Dj SHhc5YyPDJ/607fgDHKp51PP75j1teOnNZ2VMOjxamyziwbJXyLHsukkKn2N/z9nXt1rg/lXwcMn bSMsLUdYsnyezD8pI+EHfHM7MH/2SxI/4ynUFQe1w6Fg7Hq7vi2jOy9+k/j/7Y3p8KdqWGe3B5aU HrpzgUG1L5kzu20ibRbDRkZA5CSFU6RFqFT31HGwMEZ/+Mk/CmyTNkdJxSpIJCl9UJ0gNtxBQw3B YLKU/MyZh05NnrXlRzk9Hfte/e2O8mYleFnl9WGii6wEuo0HWFtMXNJ29Rjyfrfoek5knhHnackP Oln2cI8Gt2oJkNWG9k+h4YKe76db6j2ak81QvNcRyq2D4bHI26yI0VIqT4Tw+loc6nv69ujXTs6b Z+0PJqWPzCoVnio4nh4z3ZqD2OigO+Xz+jFHx3BkNoMducxznNgwnXhyNIdNSHCMDjnkG+t3f0aN kW5bWcotY8oYLrLJ1oWK9ymGKxOXhatvPS9rHNZs9nBMzOBQUPKKIVaWCF4ycioxTAd3EnyXUI6A JaqD2ZyYIgl4GAGgC+FkkC9epdNLDPkMIOP7h/vOqw/NCBeukURLHK2rG/PGNF0/tUDY9BjLJ6ki WQ5bXldPnvufyvsnqYn+fR/pNPH8bSA7lUCkU/xz3ASav/JXUsFIctDvyhF7TxPji+CCH3n9qnF+ ahxdQZUjLOA2hsP8Ppdm/Q1VLUKla96/pqREk5+nyOSn8VZCEV8FuXVZjpoNn50/xrutY2dHB0re ldaPgxl+vZXHMpPD7FG2V5+zbhhTr41OHLmXVHC1gw2NnppnlDXev122n999zvfQ1tM9ua/nu0rT Tji79j7q8oOZ79ELbmlyZf8FnRpg4c6nsg9yjDaqaYSVdjD1OTjDExXTmbGrRdXWnIxjyygalpjh g/Kji4um/Iy3Y8mkox2MS1q0lMexlkNm/hQ7M3M6pmKlLl4nOMgStk5+hqdrZ+i6KPlQyaXyirxG vVtN+I+qrD/CzreV8/wPsvv5hbIlUP/JW3j3aPj04Y3oUII+oclv9juGEP7vkgyBkQD4Fye8VQSk ZGEDrNYwZ6WAoOlj6Yf93FZ6crqubGSBeKiIB9n1BmngjjIiCihrVLXkqPscK75yJ0MIuR06VFGC XoGX6eyoXVgHU7O0dSF/N8eIny1L6ID34PVLvNAh8cqdYuvbpN+LIh+g9B/2HfdswPMc3bpX+7ct AbtQwm809+zuR2idNzM7gR85e06VOS8QIe48U4v1fmtLVemsazTR/RX675j7L0+r4868nd15fQH9 91T3LFWUKlWpVUqVUqj61GOVxVRT13nOP2fjbSOBBRRFBO9bBTmFDdoopuv9a+e+igXS04/6a1f3 w0uIWf71/Oo5RUv3y/EYe5aU6/lRKziIpXjqJROHtViQdOUeucO7EoIYIfJnGpRBTa4/zP34Jpr6 V8cwxSoiJm4jIXKgg9bVQ92CTr4bpBIPb0dQ4gQYRLWB8ns6UFjEfGM6bmmLjr3yH2PNycoJfUyM E5BxImPE7juGPQLrKhkOzpsMO9tWWXqfF0F687Q2G4sA7Y6XHkP9Cfz06nIXqO46nOTLZ2q+cF28 mdHjxYK/4VIS+ntNCv4ox8c1fv8Yxzf395XFv8t9eh8/oc4nbrT85lafLxjFzajyjq5x/Evtm/tP 3FHyPW3hP56XrX4Y2C+Elz9vmEXRlvtL9FmU3G3GMJmHZkzUb8mmYOxQ/KqSeqvJ4+bGgs7WHz0/ eSrEK8TWL7SA4S6ju8pmiEeUvvGkvHHRuGC9kpM20gmJeIVjhQUCQo28Yjv8KPLVELZjifLfFDnW +tpCEvgtmyzGL8B0z6TC8ju1dWD3BDMfMQIdy+V7P6LxycdhQS2F9kKomvTX7rPPaFoUFG+onQd4 TLgVBzUDCgjjJgPAU6Kceby/dXypuYqq9DqYVVU2fViPtbIyemsWMphSMsjFH1/d9ft1/6/v1y5J PtFAyFCYoFKoiooiR3SQz7tiabtfv2R01eGazyHr5v2L5LT/Grn5tJ81G1R4qcLD9zz+Xb3fXPnc lyRM+BLR98NGky097M/LT0b6oRo6/64ps8uld7aKNGeRMRCt+5n/aotSfh+UJkk+hQ6/sYhq/+T8 f49v6u6cPkzs0d9jiy7MMT3pg9qyaof+CyTl+Dlq+/t8i9dyfEfS9jUj1X+Cp4qngqqd1hPKKJbX c5OUuGRRFRA9/f/2cb42Mdy+RU2qnLZ7mcnwTBz9i8ngMDbeJFV+meLIPh/d2RHw9YujT+H9lnJS oJfRF0F0HpryGIfk2k8wrL3sKv3+ZhF+zwcnAD1bJ31M4l9Fu75tWweK0ldWpbVS7NQPQia7vcqa DFAoO7dfog71Z54PpOJ7tIcC4Ev5BcPMeG/bskVQKO+ED+omQXDsQ8pyqbN+31GxRRzkE9tm0Dsi dLaJ8cFpqLd8j6rr6TRS1L5CjHlBw+OfYmjk/7d9S+FSnuVB9Io1twGbhsIgXx4jEDo9P9dD3Pe6 nWSgGYTVCikgoqi6xjkKYEwK8KE49+ljaPzMUCormZVzPUYTrRBDUPDMH+BqG/Tonx7zcdPrr4vd hs40WBQCoFddjxCa7GNpP0WDGkG0hsWwU8wKhwFoUC0OQiqGtQUVLBQSrdWjzKBaO+yMvMPLGUKh 1qk6eDhSQ3JXS7XG/7sizSKcPYGmmJOHgu/Kwu1L/YT0hvT9Pxx0/CExOJiqpkMqo78Rkq92KrH1 b0pTRMZfRFfzYomVH3WfHs0IC+sYuQG4dBaDfu3BXokq+V+gKMwLl1sWxQwWmzn20OQU3xaETuH4 KgMokBQP5OG63+Td49eCHMVXI4YbV0PqUNYuQoooprNAwwoo6rYaXHtyZPdF33oaoDjRQGXfknjP 4EQzOvun+Gwh+Gs8NImI4FFERRA1qJ2mrTnjo5ZFI7m1PVzHUKHTfpI80ChS9NKdVTwXXRfhQJyd QTPZAtKxTlOCERKX4FtlUS/fI5JkCvTQOCNqVVrjWej8UdGOxp7bHdI8qtYZPzHsHEokU4E3IWLB ke6xhxEfoHrH6iApGfsl4P6Q0OcGcxpUWSQzrhzPUnqRfY39m51VhlzkcD4EZbT1+dvfs1YAHEGW c9BNTBLHAHt+T2/IwOjjlxgQKyhEipaXC5gZhFJsIn4ijhFDkDf61PtVfC3oc9Xmbbo411iFvYl6 INp4PoRt/BwGRPXUn1R+pj4XsPb+I/ue78ZXKRu8CZ0ORCOe1DxNCrFPne7E1S6+/R98ByobpVYL o9PhWbqYm+iUbHGubCzVmqod4qYXI9M9NvPIk6Kuok/zfqgFIfHlzjMw4vUMaig7qqQwUagyZUGA oR4LCDrVSBBChRDoUKxQZ0HHirfTIDt53lRs2mzHqYqPVZNHiVhfhsJnCf30q/evPh/xV/Iop9hI +1Zwba63FVTDO9BPQqGjD4qq1HJopZmbfMFcw6koorYpInA/yW9DNw3p4UEn6fiBSV/1Kfpx3sgw WtkbEIrC7tjpTVRKokqZJSzbHOS97Bm7Vc5SGh2Yzue8UXXNiRXkKjlTSkxK7FfCYtGvDmJxG7LJ gbSupFukOCSJeJX9mminlouk6lYsc0zsOakutJExaRfBn2LLpJSRFU7A+J7hN4ShTWvQFXGrEEOu HLSnzIcqcEZwqKi2KjITIeUceYUCN3R48kcR6niKDZqozoeceb+4OM7x9vL4IRD5khTgmAlIE2h3 ooiwdq8Fn0cDyfVrC7Na+ff4+/tam6z1kHK9cGppgi21eP/Pyz3lWjbz0T0O1d1xGbVX/XxdKWro WSiiwWGQ6Kqh5dFU3hiRChWcyw7HYJIaDeERs3VM6/GzP2Veiq6Xtg+HX2TttT+yOtBTpmiHxPyR GVZFvxcjSHry/ZCz0NdF7Jbnz02NMjXaprfVmnEfHC+WRC1Y/7fznOj01jtjca3oUQ48d3In8V6Q Sklu/rXy9M7pSbvrbFa/0MU3RoXDlnDNnIy28amju/F5HK/GY8nVJ2MWwfo5mKoFNTOTb0uIljWc tboWMqsysGLrXYKlam9NiXAh8ysFYzx+imL8Pxk7Pi/g18V6vCzXPL5dV8tYz99xeVd5Ssf7OMG1 er/R17nFByLKITfYsvRpFVq83OE0jByZ62rt/hWnNCwX/mHvv50ct/JWm2NOhaBYaJu1Lvs99gz5 i9Dori+oGWS07zNLQ0I5iezRpozFZuU2CuqS6b2djZtfCmNhvk6iQxgzWtCCzgs6Oit46EXzl18I uztDsoBuhR7ibjkN8B9UB19bElhLmyfSbdF5j82r2XzFzsIUqqKK6EnA9HMu+5q7FKNOz+8X1uBQ jYsy4Hg5+t44n5osHfXvfa/rg/k/P3+2/081uvLaxLvnA/qjsVjqSfxeKH1mM4NR8uFx5mAvTtmS gu6eVTnMtFva81YRZmFRztdCI0H7FmYznbhgnP4Zg684mHOD8J4qZ0T9eMfoEd7c+xG4ccSd1rT9 1VJR/O/QfuPoOHyy43qW7ZZI++tszFCGEY5uXZTqPD0zfkU0qJWsCFtzxWi5VIvujTBIuqx0Qs1R qbrtczM+NLMjK5eVUGWHbTJ+5cK3jjHt7yl4gSzMZlThBkImGLnqkDFztwpiiEWTA7UegH8FHH/I uxmy2LNMDoK/XeewSoDwDW8ITFAzAqe19Z6/Nzifcs7zBP/Wc2wbTEG693+mO19swsfnbD9j8r/Y 9DiHIofLY7CjZyxJ0UNauOFT3cs9d9bzHi0+9ZE+ej3JUR7FgehSTn2nt+J2S9m2tKn6W8Nj+r3w 8UgeB/T/0AwIg85I7GkmZ2I90dUnWTwJC/g8N9Uh/ukDn0UMLwIM+f+o/to4NwXfoGdr9gGfKDCG 6wMkUIf3/Viod0DqHaEKUpTRAZD3ERBkgTFYcArIdwsBUId/m8mhy7dLvKv3wR6nwvh69ehBJN+n LUPU9SPDDHjKvnrx83h6BsnvYyVTzMGxcAmhceI4JV13D9Nhxlj8TF+9+abDP1Sx07XuZO3pucis s61vD1t2j77PFX4dlwUj1Hg6nnLzKAc6e4X9gkDwKw/ebjpQ36BBgY8CW4y8Q+asec0f6HIQ6VjR V3G6zHqkSsKOhyc2wj0+UkVVL2uIjpJ4GYxthbKWwr0Osa2zBUMInU7Co7cGS0kc44F7pnh3t6Ht Zlsx5XSkyeXhJkJu/pWeffuU0WTbYblNSetgrQ94KDCEKpYTSjnO4QJCJMVvTIs5Pcmep1PS159o 86p6DaeThmzsMnZ7LhXxJwNaLPV4OqteE7bf5kPZJNndM86Y97NNuywvIMQ2cJnrHNRyaGz5Zyen 0J2uSepJ3odE8HpPMakdZ1t61KomA65HZ5w7FOQShuV2kPEQ/gnac64kHolhBAkGlB6EFRKyw1+B 5gzh/qIH9il6nhBkltsuKMfjj8wV+B/k3Zq0nJ69vO+J+0+83mnQDGkNJu4riwyqHJx6XdSwRZYn FaNcYLHwc+zszRdo8sumBS5lOpU9S2Ch0QYyFEZM/rc5b6UdezxzTbopgSlpqvXS1WnyudYua19c 1azfA0U8DLdZskBI4FVHxyH/Js0jT4F+XGR2PM3dGFav5G+v83B873nMlKr+DyY7VfQ3Ls72P9KM dF55zyRFiRByZEhGGFYTxURoQLxwbysU5TlYkQAkEwcJKbAWlQxImRKz4FKTOoiOFOw6H1dUA53W 9FkrR8EIfPrAH44Q+CVtFTuWoDgMZDjYKOKutup2xdTYuctdbQe971zs+tWW7dZvIWBo5qh6dRrN IpvFOUiYjJiaiB6TzlhnWZymh5UXSLnkSw3DyQ4iSv0+gptJERULi8RyXo8n3lEkjnHsWfeR3Fy/ rOqzR0ScjkGyBSPkKbolQ4mQOIxSFJeaDiWBTeqwMxkXupTzHR4p61He+wxSuxww2c2zHe7B2IFP g85PYgMCDA4jsbKJMn5CSDf3x2C0UiVCSFIMWHcVFRA1kiwtP1gUPxOY3GJyB2ptOVTUWFDzqNJz jhK4kz/MJCZAClAZjaVG8iGs1GMqxmrE9QxScpQUCjxSodnKhpjzTcWBPUPKyYXFw0hSg6Ch71Uk OKys5BTlHKPuPBgMmijyCEfYIgpijtPQ5RZ4DJn1mfXvP8esZGVjaF5BKZDOOZyJ8FqCzgco5y4O LBwZjy/OFB4Pbs/I0f6uqPnLpWF4zgX9/hZ/X+kEJ/GlT5x48UEU8DsHA70Rds1GsiXxVeXr7R44 oDecBg/enY+wjWX3vbp22CPQIOPOIPT69F7sEPMoqpgohm7WTnUDR1KCGkEPKJI0oCfHvbrtwP9T tMWJWun6VSWV97u7kcnkquyac9vnxl2NhNH0bb93Gt7BzE9T5qCFpWlxNj8bmK/lTDidi+LUfPwY ZmMybWOecKT+Xve/UXFBHSVoAfWyZAlKmEES+2RT95Cg7Qq8LxhmWI5YVQQh/lLMinVfevVw2fHt H8d/6t3gnzOeX/P+ORNI7mkW49P3iH+WtaUMyMaH9ftx3Evxk32+j/L/Xi1lDavycfNdE6c/q0Za uWPz0dtUNT13xoipX5bsLINQG+ft++fh58a+PD6PoZusYaLOXDP+nxSgz+eRJFCTtdbCrwerOV8D N9TABnSihKFPGZ765bZrJlahk8V1qePPL8Z2OLP8KL6clDzdLdM2vXNzuS1f6wwc51DoRXR62fFO NznbVttZdFzuSTCqQtgfbfkdPVlk+mNenW45XfnINJyCPtPsDE8Yj+Q3FNw8FxU6x/0/UQYYMNsY m9TNMlBkjiZO7TsSivxTZm+xr/vxJipSpRRSkwpISPaYYMG4/Fw+BscAT84U9004K/lVnxkP1QB1 PxYci6hHMlH7a5V4Ozm1D0UWvOrkobuGKsSct8jehxZJs4GHNY45ZDou6TpcSWdqYciUyQU52LZz U3dMat63ZpcuVNBI7cHmHXYczFd4OsBqORLdph6YNLPEP92uzRlzTMMaAk1bQjp6b5RGMiaAKzHN YWD0jaeOWJwQvdOpDnKco5SHaSnL+ywA58+RoWg6zqFnahBwBNUCwt9/Z0VIPO1OalETPQIQFCXL Uh+kDRDEHdpcKDWAuAULQJP1V9XotbaMGoOJAQgQjEhQy0FUxsmJazCf100ldSPEdqNE+wj6ipVS f7lkB+WppGP+JowqNHKeqfj6Pfmnw62Ele89WFoTUuaFN+sKTnGHY6k8Kfq+JGG89i1kM+yyOliO /bE/nTSaNGp/0RNJE1GImQmSsGGR+MqamcecM5YMf09AchQBOhAoEYrRKPKvvX/L5/pe9i3QnoDx XuRlP8jkf/Twvc/0DiJMpifKasr2GRRpqyMvQqc3aUn6kKIfmLb+0k6zTbqwVpjCKqCdooigqIDP AiS8XzaNLR8hDRsCNdJBt1ruNL3HzaHum2UyQwgfiKIgn+1R8fpcGjQ6BYUGwvLQ6aUA+rB4Prk2 HZAkw4y/7EQ88ucxf+Km8QMkGTzlRcayB+j+mXJeO5K9o8UYmCbRURBTCwcElOJgpuL/4GbPh6/e O5pFYVXOPoyPYUYIgWPMESagTPumID5YUoFDCR+wnCNiXaXuO4Zn8HjhSrdw06ayImDMhyf1f2Zz NPyW6DYjcyDdn8EPy8PnmoPVKlTirQi6B+sVV/WzcxH+ngHTMjtK5J4ZufmBzSImcxXLrTlCqk2n OHUKKecRgGGMhTgcCQ8+51cxyK8nzvS07G7EqjFdnR2tNKbu3XBnDdu6MMdquqtOSoYbMYKGnPsc 3a4ODqrtabq5NkxUpo0xzUK2Sq2aOxpMNjGFKNGxo6tmI3Tk07TtNmm6LJ0YqsaMScxjtRpMI2UM SQMKiUiMFkFFSk6NGkdZoxBKIEhU2DBF0SvAHIweFUh0IFdWObYnCobtmEpTFSqTKps0Y1FVRSrY bKwxkxWxsYECBFcGhRYYUOgxU7DBUIUGUYrhybps6KpOZimzhybKuOGRRpjGnNs0bRTTTEqlVomL JVjYxpVYphpo3VsbsOjT9LyfF5eBc+XmCq1z2/nocGd7FijKlXMoj5+JAHItbElMRthAOvBWpHAl gowW+nVQSxnebKgT14pcfvTObjILLA8JWCOGbFKReUziUDHlhPBTtoPINOnHUJYi9ebbb9k6d7u4 HvHYfav6g+db6FD6AD4I0xH9x2Idvx9T7qvKpifKo+1oXvSqKSIkpndTUpXeRUM0USUPZ3qd0a8d xs5sM7sssmqk6H9aeCm8e6U3aiBn6wPANQaRuiR2v3GGtlF6UVy9ecIGpQUtVINyWh23AwP1ZLqZ l3MMrbnjnvUGVUqG2OW/lu0KIvNY7Do1OQ0PGQUyI5Hi6YCGoRRD4sGscE0yFTovYezEXvEGrfX5 E0sqiRdr3bbZmH2sN4MhWvtx5rEhXwS9ClDSnyD20SRA+AonBU+YBURNyiBc0aR7VMiAdIonioJ6 DUMgnvUEkh0+z+h83Lytt27Enn5PsVGPEOfaxLeU7mrPZjBH0sFPy+JzFsMPmzKO7Ks6QgO8b1yk TlabQp4wpEj4ucVldUyCSiLmKjyV50+GpRFoKREJKU+80qRPKS77OqG00IhGq4ZrBWDZisVQdGZB 6dBEiu6YKJo2pl5CiZ7eascUiiWWtQepWrwIgbQmQt3OM6jy6ibqKM1gvrLBoGhZm+pQYW+Xsyxt 6wP+BeivcTx8tSR9pBFe7H3x2o84cIODazz0mI7FkGRVpBc14wdgGfPzEmgKTYPSqZLtpcaVlfHU K5FUrEbA79rthnK2nae0pMhR8JpaWMMLswNbpFa7inDUTHEDdobTZUe5EURmo1Tb/Cd0z4nIMWJe YYDn7eKDZvkbLJQgY7QVMKoBFD58p6rKnGWFCcmkGQ3CUXSoz7mnMYUVLkbYLzj98sgNAX+6G0Si RIl+IBZdyCBCsglvjJ9XOBqGR5KhQJzyWSDh5KoYxZ/6uvbv2wo9Rmgo1Aed2pC5uuNHvIFwlwlZ GMA8At2kNxARCtCYvzqGpULkPMxDgQTieijScni7oHlE6VvJjwdKzWC19C9vnREofVVpG0KnMoWS pe/kIjSIMmq3/MykU5S8bK6MrEItlRSn2Oc4c8a6Ur1l1rkSSehc2kKQvunjWZzwVRYqUkdKGhzy Ip5RzdmyOYFtIpuN5YPM+cM4pykj5hwmRT9Lgp8B/rdUnCcHi9DBDqzwHp7dRgekMtSx301me1BO VRRQu1syqzNgzOZma/Xr5SY/0GBbdnDAqDSDszqFQipEuU1d7hqMd0TprLCZWRqLxJsVRi5Vmx5v U9DYayg5yiFFC4rtVBnsirmXM6gtYVeYWruN2jhS5ywLrD6As6uys4+anAMAhIqwzPPMYDriGoiO 51WIr34wrn0kxR3GyAcwaQp3q+jQMFD1CoajBqhdQhLTzQvD6SRSGiAVhR3j3RoN80diPBnAR6sN IlQ5CsYuLzuA2B8AEP9gIZyFATRES85jD0PxARxaaURC0HgwCcKxnYbKJgCXqcRk6z82H4gxX8v4 J7slB4CE/9qiuHQng8zvn9rpzTVXwYbE+12ipZ/sYPhwDgdG0G19ogCl0yJXMdjEIfsLH5nZI/rs qjkKk5WEmKJ7Q8DYBOYEP+IOA3K8kNxNg2WhTwVO/pjtAxNhWXdnV7gnTE3uLnEAP+HjKnHo5AP2 oIYCCoC9eEHI9BFfQTRP+g/jNCugoGJ2UnBiIIiQiSCiJqGalipgpm/JhgU/JkGVFFABVoLThuXz nQfYRJnP6cmAzfLvr2CGvidaH6zceY3pv49bsSo+KexNrw/2KqN/IHI3FiPKebu8Tb0dUM3wX8HH 0lDZ2U/RpESW+MdVU90GPip7fS+VNGNl+jKbra5rW+EZtQ2DI0GHSLIWSsSv9iqbvoqiPWtzLQMX e0ock1H/ct1jwjXddQSXPRo99syBAWvbzW7CqP6NFlGm6wNajeYbVqGMxIiy0m38tBAzF5RlNBWu 0FQ8eOr4s2njQ53vKaaR2OmVYsCiVMVfYsMIcg7+pPfzfxH9Z5j5VP1t/8tZ/Z/f/l/+P8//HHom Peh8CQPzuxmhoVK86shYp4K28iSFjvZBlRf6TFDAkJBgI19Bo+9AqGyoykyRFSfTKeb09d/7Tpib bmT8pU/QLMVFqqrEZCdzxMR/4evBOiz/rmZLyHT+rRObZHbJWzaD7WiYdKR0WTrrE0pa86xu5yVH c1KfbDfvkax+2FH9b+h0r3nt8vc928rdHt9L3Oe/r9ysrLU3j3evN8RQ+g4pxcdEyROy/7coDvOJ nTPgkBUFM7ehD1e3d8AEz6DMIcBVWkxQMNSW7NunbRjuW46TOqJkDH7QNAOBVUFQWEmT5leot3ti QcgiqxwD8CkHHwL6CkU+203Q+UIm8kOlidlHLfEN8ZDCxFzEyYlKjAgnKJiIaRdDByOOQTb692hl VKLDZGnxBx0Kh/I7g+TpCbG4HpYqh2LWvFVrV2UqEzDHa4iM9EBwILko9JeqOITDE/3hkECqczdM qBIWxibwY44FdTQvrgSD7YuKsSL6xNj2C80/aHw9ZdHU/NPe/Np75E3xbjBM9bxHfokthmywkIUw 2SRaYiZoJaShONf5bukJOhNtEHklym42frZKOaEueBDB8loIDTai95dYobSHL1OkpypxhCYOLaKY 26Ue+IVJDvHfhQOKo3lVKTgtAjTEcn1jAx7P3+ps5yT4Rx+t+tSkaiTEhU+k5Z/6vxP1fY5J/x4b lJHQlUX/wOH/NoibOSlVT+1/rPaN5JsV39B9nnbN0Sv3mMOH9qVWgQcGIojgVKwK4R0BB+UHfyUI BkfwyDCBnvW16fl2buw9TmweKbzxNIYaPymJvxb6j8R/Nv6lcH8j/xf8Z8xZB/6Kz0TXIjwetiYq lURR5LIninnUmHa51/T8r8T/eiJeh6fiHS3c22sNojkGPlV9CbfYdbhIxZD/IHHp/4Llv6d10fzC P5/74F/hP+z+bV+ye8QhRjMF2ru85zVTMZJts5eZDjfkpx0hEi59jMnoS8Snd6G9hmY/mbOZDBlB Oq3JTwtaBtZfV/3d4E7jMfJHcUpXM5B+k7ezyfzOOQ7ubjXJZ3dTBT6Dnow9L3pyRfCyqqrbYqq5 EgBVmmWCKHQXn4BUSRE+J2qqgv3sJxoyIOY+jg92jcNyxNYbt5czVgEyoY8qoB7hUEXzF6HDHmtl ZXknqHn9g0NSys4WR8kT6XQhYWCTEJx5hs4dJ7gF0CKnSChLLlDXRdmds6Dp56XD3vVw5nLXmHpI X6m5fpfT1tCEYvrlbboHGOJ28+cmETmURBOUU7a+l0TWJzWZC8cVziyMmCGgg5y462bj6hOI65kv GrwxXV9RC9n1pK0+/hzoioBQneCoejhFyTpscb1Lg7kQwHY7NGkUH+EApdwubriq/sM8nNm4POYK HZAgdaZABRdNk4IyNua9byk2AO5FBUKzgJoeXaJigJ+tJX0h9QmB2Cgm6r2J1fW+EGp17BzOhSfn dI8pZsbQ7/D5/9fm7KvKT5Re3tqBKt8MHodKHmVBNyAomDIiJBwMqj6ma4xNnPns81zap7nixCor 00elZoIdaI8DhTOJnzhBLVclaa6wQNAeV9FN5qMl7XwhfKuFfezsfkhkzJoIr8rd23AtOmTOOXxM S34+/9mVXwVbKzOFNlQ4/DqOcNEkWKP79tkRKNPc129U2s46b62eHkIG9La6Ra/hSQfGB3AdQIgf zib96MiQkesiDxFBRwJWCO3FgYFiRNS9DYnGGyKw4OvVN5sNY5IyYNyCKmwWu4EORHJzqAH8DUY/ QQvj3/8mk9k8ltYdCjSeos+ppMD0UnLkw9pHgKIj1QkMi8y2ulePFBbQGTr5LkQjGsapByeRUDuU 71RESCnFdp4iaAkBTLNLDutban5lPMvwfQPnPS2bMYxjGPmpzcddxVcFfObF0EAcqgw3qJMhIXUI zLBioq5fB84R8OndsucdMuzvND6lfdN2cu9kCPIruGhDlBLWc9kGFZLBuTwzVykKCpe5PFy0wHLl Ij4/BwaG9AEyJB6H532i7j2e/ejlt/PiKbG0eG/Nuvd0cfnNfgazvuHNFFyxURPdCnyl808/0ox1 mKNdQynyMwiOCy7DQ/nF2wIR/2Ogig5U6Bzs1JMi+CqbAPvRhDuRUEM7xk1qB19KC8/QgcNzHpPm wxaCiikkfRyXgngewSPeHl5e04HcIi76gT9XmFYCk83zW0xX4PYaZ7fjVDtTE8Tj8p1ses3J6lkc LOx8Pb4RzFedn9nIxCkQPQKBIHogVizFLK3Ewe9BO4z6y2F4HQHQRBCaCXCFx57rHDNh9+CuoBOs 7mNCZ2uIpWMjLgmpExiLDrlmThkrpOcI9wJ5lKk58az2SdXDYIVZD0J8zE0fLy5/D28HI2QcXnvO SqErbyd8vJ8AMjgyBmbO9vcyxrsOsVihgCfUjFamACk6o8Vsb0zSkF3mpD1KiKpjQuOpnOZmavpf DTpiSVVkXnpWGoQUe6CNoH1qRg0HbAkAGYBDO8E1wNtEJD1zP6CmqlArjCVrQmqBVWsVKnRW2MmR LK7EOKicRTNqLU6SjMpTcdryNFYRQcilAkjILoSZGdc95Pu8iNCrVIfUqT7PtHtmuyWdL0XWe8Pr nkcbp3HK4o2+UNl2Y6vVstvgdGja82u89V2dKVVqVeLR759uOwUKFs5xeLvyv8sW3hlWvD3VF27u +N4drsZWOd1wO7tno6Zvk+57fZ7KHBPzp7ee/hOPC86pUD2xFPSCGuaizpsupty1yrE7UQ8GDPuJ 8X1z09iFLMwhj4kznUAlzbB59vT2T8ZyMzewHPHFUaN2+vQKRD0JLH4osT4D7jE2J6DsUbh4dB0l W26QFJ4H7Dd9S0T6W0rra5uMjlzyTVSfaEzgP4LXsWRHQhwc/d9g5JIZHdEBxAxkmrHJSR/zmS7G bkk4Wmvr6Ht5/VLJSZQWiVGo0kAiYgoopiL1zKqDswmubQPoGqP2Y6+b/jWbT4Z9jxCnQcmHtyh7 ZYE/w0ESjQSecjI7/QoI7VSiODuOtmVF2QdYKgzq6bhjsbg1/6e/yOxZwaOabt14j5oL9YiOkjXC T9o+H11eD/PvisnOyPwJPxNGYLPA7I7TAvLnRJEcRFE3GuuQY0kTmJsUlhWNpHuJ/2ID0w7gc4Fa ElJRybPzEemDod7+w9XPRlS2YNn8xRSFgpG4p24haRFKhRig5LBxAY5RxIkED7jSF4ZgoNRIiRNJ 0ibzMRtNAxnS+srB4Mpk/SUQBmXPofdtEWZLIcg9Y+M8FTOj20QV0Dyt+gdCAxUlRTAhwYeL+cP1 9H6nWkaPc40CmzaWhMcKfItKQcj73GgDYQQ7lz6SgvCRAn0LpHBRAnY45yEEGy6iUSI/jKPrPFwH c1BCEvZQ1XDKI6ScVhMITsbOUa75rD2PxQChRQohwW4B9Fj7SB2CjnLrclrpy4nwOmQYGy92OB5o 1wFXQSHNY9aC3N1QIk0vCg4jWLzy56ed1Jq9WAjzrFGBFRMCurhZCF2/K6NpDqWedkYpNY4OQTeM 10Stsg2qdLIg7ecnIiTsOZMEnJoowd+5B9SKAgcGck98FEmiwHEcB9v6SA8Huf8YN8jU+048pcx1 KZhQcWGk3kxxka6QmTGIjhhGCopeQiotJG01FpTQGs1lRI+wO4cBfzc95iKQruVO1SYU8BWGlY9i jHFnhppp/C03OiVSzf8aIrosdHqo7OfNjT48/tnBc7VVPnveWarnR/blTKrmm98sOqpxVJeSVJXy ODTGjVYzszMY91g5Velsl2beGL8PIt5RVYFV1iTdEdMmSeFD4EFjvD6GNRCv1uo8qlqkQtr89gTA iVSxrBxyUA7Ce8MaiAUG2oesIEio0KQCOYUKXy9L0ukssJeauJ1+RxU4CMLgqqFIjYEC3GUjaSlP op88jPEjIjSttkxVDtFiSuYM86RI0KXckKBxpKBCITg3HptpedKh1zYrEO49QxZQih1axHGTmwZq HyMFxIV5E4LMhvNKrGMPIqOxaSrQ1VCUzU8p/gVskVJXGuzWFdO0wHGFYZHnCod7iEaOXMYDl8MP gEykclCmuZniGcqjt58aprR03emlsc5QbzpN0Uw0FYoHXj9UGGFYH8W8iogIwp5LIxjxaH8R62A4 UlJ27NSs/j9td6jCKjEidcfwAeIKaj8QT5z8kEwS6LpR4MUB+wi+71cDJfJBfYGLGx+8/p/1BOn/ I7TY0eUDqqQkn6APeCzH+wNXlc5VfQt51Liyrg5yqK4t0AvZLOSinon8r+GJHb5iMknrT9jJ/xel 5J1T19vm859qOPnHdIYpajinjR8S6f74d4QcXnkM1foqEganeoJCeMyKqt1BJQ9ir1VFyLZhMrxf ZdDZ+viY0i3zK8z8P2vkr2NvqgrLR4U+eRk0ZptMaeiQ1Sh8iPh432SRubbRA5Re1bDHfm2/iKG7 HDaoRd69NGEGIY4EMvhYQ01UcwcG3Gv/WKyGaRXCBCYw1ZRypLKEwOwBodqIJKBFFSIYMhtUG7GJ jrlCnGjSG0VibMGHYbJ0oZbth4zcZBKrBHPWAwwGEJoPg0J+js1qfV7Tj+v+HnZOVD1In7nDurlR Np6E3mc0JsF5D0j94qHD2kyOD4zdHN76x8EbHONjYchNE+znY292R3OQ6fkeeEG8G8oiTP3AdMim w/E9xSJrIiUDFxx4WuPmIlYp1lIHOREHjk8bv1g4RLekFvafQ0nqju/NZi1G+H9D/M7jkyTZWvum dLhW0Y+hySPG/nWyXdsTxgxPzRBW6Njo/S3/DqFvnpeO/XHjOXLayiAiwsiLYj/a2DwyKpateVzr 1eCQjaYnZ+iTursdDpWijqVHMUghWGIKCJhWiDjmE2QPoeUhfILktNUUkXuYGVJeXdQe04DB9AsO 5gNVKR2FIpiDUnkPN2t0+d19CbhAS8I/ZnfefiJJCR45PjntPGueeaNjq+7rj+nr4L+P+PFxWejw i0b6VbS5zM12fSd3cujtL3GtGDRiInBkx/JWNCnNRmMeMmiylUu1XV/VxEGYI6/p9ujWGOzHRgqt i7t2Z2rjpQ1un8i4x3+dHLVftTnApxu8/9PTjnvhNfBMKsVnUUY47GvpCBFdw7O9VL7Cri5hWVa+ RmfZ6ve7dvMzo0976DkuVFVRJNVmxFFVVT9bsm8LQyJHNqaiAXGJlzqbI7HmOHdryad3LDtSDdLB De7yLt3eoPIHYu1DehaUlyIUiapFx5jaHAUHODGYOahLzC46jaMvEk+VehET5Dwkpopt/LrvdsqJ MMBMOJIuv+4qHIXIhyGlOcHBYa7kgrlQUfY96dh8SfEnxGj7Vbt55vcYclWHJicN6yMWHnFPAnn9 3mQ91OdHh5va87KtKyTFC4LJxAvVKClMhRPP5w9wdrhGd6WHCVlD1/sH+zzGuYIiEPbAqdV6bdBQ PzwvphQ88IhxKKf7he48w6/pT+P/im78jAe1fw93e2lDpYJ+OyQ7FR9lIT7neVyn9Oz6lTxaf1vE n+3hw9/4X0D3p4TjeT7FlscG0enEnpe0wh+YrXGJJpCpIqUaed9KOAQmfaagUb5xLyZ8BhzHkwHi GgbEgQfAu/9NGkjOcOb/jWAu0Zff9QeRoeb/TAP0vQNL/WwwwGP0qjxdB9jFHpO0z5gLuKJ/I+AH SIC4QNQ5CWf54f2cPHjhWZkINvGNwLLSDJGVhYhkzjhmUYVjRWYYMlth/bouQzVI25LSyjMyiMwy xNobAayEQNsIZUssbGZn+DVMg8FCR2yuOSVjpAcr/3ZRssMYPpksME/d8p3KU7P83E5f8z9dRfqr FUoPCtPOJ1DweJzhyOPQAvJtCAORxYM8rfQ7G33Sdnjjo3Rp655Fvsy3PXmqHSAzKQg3Ry2KRxyR p2Ff+vK2zByPLCyXIFdeRjY2W2uOQjZBuMUaWmSw0FirHM9G2Yx6KtihX/zMqDTMRJu0rYD+k7AO fZRm4tPxm40xtGGYQlioDoC6RXGOWkcPRavuM4F3WWoMh+35/6J+ju+P8IfYZef/M/P/DbOtDtRg wsevkegg2T7x9A7OE1pl9/9TqElkfqLg6qT8iQZs3qd4FKAdJ7h6B84eBEPsCfTUSzlypeT/ohv+ dTdmyKioEyQ/huf9ncB/yN5y+JJ7UlPQSHn/rMDiQr7iE9XoPgRkVY0mMg0w9AqsD6yoGoFtI2QF N2mjdRs2P9w2n48ZUsVJ2KwbQ90S2DuH7GE0rkEQ/fNzF0yGxodGjWVUOKwQfpCHluLnDrTYgT3/ t7v+Xt0zdzT+yMWcw37fqpOUT9hGWktPxU85MPcqb/4QHCBpBU0fOKHSOEPEcKKn/ouOxArdVWJv PjSEXkS0Q0+TW2XrIHQpSIn7Tf6k/Akfgr99T38ilPMcUm3+N/ErrrySzLuPVVzB4N5MZBOdMN2B iB2JZqNQfkbPpvzH+oqpYnr+87u3t5X/YHCyJZUVIIilCJCCBmBdwlwYiIKUqrKqiqWKoVVskn/3 UiclfQnb/V/qPDqJ5tzDmL3iaNQ0LQ6s+a/N5qBO3EqPkPf9IJ+ch6HWBBk8FTYF6ZvoS3If7HCH 9ziaen+aqajZ9zTUiu2UYwhBajYB9loeVRuPTV9cwLTkQMKD7ikgOEuFOA86yw3DC7WHDCkWKqm7 m0xNKV/Uxhoxoxpuptsv4GlVipW7TT4lHCuDdg/5P5OjmKQEMPYONgoHElQGQPK0BiGn3ZgkIJUP 1Yszwoj5X8FI67t8nwKqD+RUg9aPwg5EN5pIiCCD/Z0jd+hBifyP5Cn4D5Zb4NNilaPancbjKg+Q 0C3WiIgkQ9YHjtUuOUD3ZInxJijDCpd7aLxF7u/Rj/F2/6GzOoErO4FO4ciHkACPTjqOjieGgB6m 4KQTSvss9Q9LggCDDf/raUAnya6gSwYm8rfG+msxpNlRtdvhYj0KSqpTdTHJVYViq2NJsVB+/9md FpUiKBt32uLjEc/kTUYh786qqqvm+Fgo7cCHuQQ/B9H4fuZ4MLqRkof1mf2P+R4tNEW7p6sfDPqJ Rwqmz6zBRwp7RSn311o3uYv/N7iyV1qQITahyRvYy77U3RpRBWyL6OBv9ofGdyziZ8PqX/gwF2cB IzMwVxOOYfnHZZYviLnPZ22gCkGENqnYtMBlG1V7hmLTQglaTM0oGMxGNzVIQ6w7whkpq1PEaigO JN4OUh0jSGZ0aRSGwmZikwZTNtNTm6q3dTjMxJy69F66xOsjk6haDpKag1PWTUG0ZJxBkLznW+Lk xBvG0DtD0kOcptA8oDlO3XA1viOEDzuLLpCnE8Sw+N7xosLdwYdOmBhIwhhILQ1Izo5ctg5wanJD nJ0il6wc4E1B1kDpG8u8DxGdcwgd5yXiByF6Si7SDvB0ktb6OW+A5AtviZKcsw6Qp0hgBkcMGor+ FF5eGRYcEYQSkhhCZrencjfDZ6pgdAkaW1zjhqDAzaORxgdj/bnbj9A41HYH0XjGuXOmhxuyZ+sR lmDKAF+ciSDjJWHcyjF3NBjQwWbaqMBpsbbQNoGmm0YVHdvwTmQUIGWwhUcBF70mI/HPZ7SBX3DI jKUCIkEVGHCzFALcjoyN5ykaTrxFQ61I+H7EAq7wOvGfNgep/9LMH8DA+oCQf3SifYSqZ3By8MLt NTdgNRHeNtpWdiaHNg6gjDbVvbpQO3Y4uVUeM2Ns742Hbzxq0wwQfOPyhwReRW0bVy/HaqI9qqop 6Vgocd1TvUkQ/e4O+Ki+72SlSbCPfb5WBZcjFCpmZoZbTbt5d9QRCQS9KZZndwCUzBmMbYRhay9P W8PUuAEKMKBMhocHxtg/tDRSDAIPhuc6/BzeXI6m4g9CFekqGQjsW7KmtWIhuVaHb+TA/LviEk5P Dt7J4dL/txljey8u3rU/rfcLiM9RER/tjSkVOJcwdKa05zc7xMpWy/NrCGZtBkZZINAIZlogr2/Q fWd5bC339SdzgEUKB26vvD7e67JJLxw7sAPu6qJI2Ep5exBEziJX6qJynoqDDO2IssYyfRLSoIeB 4vCCgK8QivrOQCCIkK7RKxEePHTsL3xUTEI6neUCjKT4aKnT/xpQjqcktM31QSihYPZG0XPr0xHm A0WbMaVEOsfl679YjMU7swI1FFFJnaHYYbjt9K87eayQgPfvX+NcY7XmjmyCa7y4M3kZuTDMzNhM yMNkvBLBi37X5R4Q09k3ihwM8GojHqm5bv4GvtkXeNcRD/zFaYNI2Q4M7XJMk6dnTMyJRTNyCqZ1 YMeNsZoLYYyayuKb0U0zbCC0Fb2u2c9988Nwg1fBKeOesTCHzkC5G+mTimwLJJvBmRiQNIphieHg blHlaWU9XOZMou+JiNy7xhJ6rjrJIW3q2GwzlZENlZIHhd7l6fhEn7/o1IJXLlc9+2OIj+lvw8ZN 6ynO/A6PDU4mAZm74h3oOvamZqBG4VeqngXYX1Uozftla51yAsunTC55pZ7Ph+O0RibFCElCucDU pBSdIDA/O0moupvt0ghj2u8UQxtPD4XbHGvJh5DvMMRM5KGJqFyFc48fl1zs6LG14I5liM2vsSQe 1Ug6csSaWfVLBvR6fjYzifVk73deHjKePhe/ZaIKhaJMCCrr1Uvz6bd0PUDMfeghflTNtF2Gxmsg u6ct07977c1PsrOoNFzoNQ9aa4Z9EbLsawphXniuRAri6iiLPep8q7MLXGUZ5UzGwsoosi1/9XAP gtko313zeUy+KD0gaS8pOc0THjAwyGcRJmJCpV2FKI8T/x/L2//v9fODkP5/04D/+CiFN3w4lsAM FbpShXCOFE/6Kgoqe3Rcgf10tIhzVJlknFOfs+Pu9vf7OPn5tn1RF467EkeEoclkjVRH4rA4otfr UjeyLY3VMvb8umj5l8GsSTWsXfg/NJkv0w8JNI7wG3PNpoKblgXIGPJFpkaOGKtKrIa1DWq6GMMf DHmseSzaonc+z9TyjLJ62/+6n+bfzOC7Ve7vv4+nooq/gsVVYrv60JGq167iynm5rUUTjElWY3Dz ut3Rh7I2Z3S1mNblmp6Jd9k6xNbd0sVh8RUSb3rG8PNrUXqrvSxin1nN7zjCzFap4zA73ei6etQ+ nrFzq3vMZgU1i8EZeM/Hg6ZM5YOEp03EMYBeZICiNR62KYmb1MUFbh3/tRgTR95p6E0tJp9nH7LI GZj+BglQFsAhheU2m+3MxHvBUiKPsYMCDMHduKK+73eW5qCkUEEOxTHvm2jwcuNBPJUfzjjEVKkG xUVzuNKHIskMVtWZtmULTGmP15AEVMhaDmd89pDEfxH1+u5B0n8dDH1ieoz3vVDjQIiVI5LxnBdu jQGbqVGgJTC2opUBkVgUCAm/Xr1rFhULROQROJ0a0VIhGMr0Ey5GlV72dGrTxHzZO3R8+YeQRPmD 5YFGNCM/g+B92v471lOXiybWcbnY6P2n8rj7A4xMT/yFBwoF718MPJakE0KAXqUbmNsGbSquSEFS euatX+/4DfYmMFiG6+vpS2kzf6Q4O+iAfTX0aXSpohIOZSQCiPPvIOKiQjYacnIZCgaVwW5T+B6B m6XSQmxpzSaqfoXQCPOHGyj7hMeBBSNXKTkMnMx68wo2hpMjINhZPjv20Iyl/7f9I6TkQ5MCuhCJ UVTHoA5RFUWG8lg6GQq4vg+/8yk35t5HcgnYlzmB5oejXBQSJMHjUOSkLGdukzeUb9HpIEevydik 1gxbtH8+nxIegg6wcW/nw83VMU2hc1j2pLsW4sdI7INopMEIwpRCZuhsG880egm90wx0C56SGZSN Fq9cGtjyUE9NdEYVMgKqIMqHqXJSxUysGLQS659JHNL2+J/Eu8iU2pg45W+mHmEdYIedt6I4U3E1 t1hvtBfG0ec7idIhG2ZmjfZpK32ZOharXRsdzX1pEoqXJqJUT1Q1WUxoV0LXVxrte+LmdnL88na+ eiejSffpzFaS7LsrzXZ5z0axZ12rjrnZBHfXffk+owHugEIDfXi/RAgQxuX7rvLtN+lYw9wp4PSz A2rS1r5jSTsGhn903ns5vGoWjQ3p6bLwLwm+WKAINpmLTYE6ZUe/qTyqWUgQM4m5vPnvce3PnpGv PDGU3Sfh8ZLsXtbDgX2EYWDLt0uhl0zMw0lwOkxl9qON3PHu5bfB83ghwEI6fKwqZUmgSTWnVs0j lS43jj1gaUzWidcw9PQoW9uvBj3xODPjOw1lB2XLVm6R496g4b1vz09dYu00HjZHCA79Pt5ntu/R kzG514ecqXxov8v5MH/YPDnzDR2yxj4ezlJoTcguehopjqvkQ9MsQzperj4WreRDSj28yRv9p17/ H1b8Ma+AbhmDvLx6Z3JCObe0gSiSZ5BC24yxodTMRHSYezSZCvUtSIiJAfu53ndM2MUBzerKbhOc Pv6+PpfHlvtiEZTAh1n0eMVFeNnLsxJk10IpUoj9LMBiqMD0UGQaNTzJ7LY9i2UYvHGrTS/RCjDN 9ZSyiSsZLcysraZpfCoQggZq8akEY5g0N2rYjbjXFWzHm5VX7xdI2/Xs9hxtb7WoUfIMA0Km3Lx7 Nen8H4z6v9sft9/u7O6PYpHl4P0O3bW1h4U1KW3nqaumTjM4q/tZOTbUO5ZtD8aFjTw5NIezvN9H kFmLEbi9n2i6I4fi2CNVH3lBYRQaDIhflhA2EY+CwhvHrWh9Hh6fUeY7fZnp/k47+I/jRup7R14i OWqvB/IUPtk5rK6eaEIQtayS7PrvhffOmx8CmyuNRyETGmdzVOXB1dIXvxufHGt05XYNOWBpHioF Ad4EBLq8h9gFgHDSB6wUT2C+UPsyQQtj3b/Jp4Uuyj0YuVzhnKWvZ7pJJVVfYGTAOJySS1EGbhWB 19L+z6eZI+qKPsz9U4riCBSEqavfgOQaUxGvYEO4wjpA7mi/OToD3mfKYB1YaYu7aXu1KkOZI6Mm 9H60gUMQwSS04wPKxA8pmKw+Sgt49MZxmrTJUg8IYpebdudi3YbNZDekZLBQXRhDkea+fYHA8Bhv tuL612m0p7FZzntUVOSMxUPen6ZGXt4i0z3owO+3NazpSbzopVeNjY0TrE2+H3d3VPrGDSjebudx tXqM2VGa1NRW7zuh1OpxsrOndREb1c5NbypysrWcPb0srRW8DzNdjyL+0BvVm97A8UvxcXAdhkh7 8SEDUDFCQYYUeiRIA4ZGNjvum1gp7pjgqHgYH+YoVO3ieV+f3Ff7Zdq8VT2q+1OxFcnfgiN2ICie iKEd6Rf87D+mQFfUwjJ+9EW6w/AQWJhCxpoXnKUoMwgwZ6t/xXdSo0ek7RGRAgDxReQ0c1HKuJys lB0bvSg9BM6opmTQOQiRsLyy5wX7kRzerr3oExUJqhCIiFuwZNQzB7eceNoMhio3EhN3xB0Okg6c nmIoRBUi3ewQBTLvWWYwgMo+UHxlHwg9zw3qFWqsxhUCGrKxqFpugeZxruYREtep0uRBIqShSKik PyKifj1kQ01ojUlsZhklhbBJPDua6PR+MZEh+rf/TrV42wIc58lfRSv5nxDrYMZp4kr6v/bL4obQ HOOw0Y+0Roey+Ab112sKpUpvm25YLCwdtltIOItBOJpX0Qot3DwM6Cg5pplFNQ3b4X17MYjINyzZ KptXoY0iYJTsureNfyeQKmlFeuu3Xso/N/Owx2v4hx6Jm4RqI8Havg4PbgxMM/IpGnt8rjIMetDS hKtCYiVPZXiyFZFMl3FNeWWApqhdbYJZgmKFPTcK0RfPe7ZPyrnms5rxN8YwZVV1EJCQ3u9CUAbx gKKQoE/PDtQzYKG19Tt4QOgLEihtnt9KrpemR2kSXxThAzb6378YPXPHs2PS27pF9lCSRFOe2syE 2nLBnIZLKe2d2FL+qlnmHnd0zHPODqXEiXfEPfT33OQTY+B3LIL2Q7kM5oO/ayvbvDXh+2n8eXbx OYCe/B2nrDjXbkYq+qY6WgYTR6edLPg1gwhXFrNDrCitdnsTCammGsZ+zZYJorsdQwz1n1qr9vMa GS3iI5cJRN1GJ/QdtX29x560Nz4oOpa+61de2rw1CWXpOjPmIOXcqiokRpN3xGvXXjnv97cevsde U8xYabXWxk/mtkBN+GdgyodjKBjEbMSYfllK9qvbx02g4N8RW7uXObiPLGU7DEek9oOfXfOKY76d jOoMqrFmkz8LaTz+/q53oHsj6jjz/27Bd10jWMAInuecLtPpi4O3zmB6jQnCqr+YlQ8nk/uzknr7 m7hv/lsx94/1N0+fdzfXe6NLEuKh+idqQPME07todbcvRndPp0y6bToe/5JOZfVXvqp4OZxbW5/B 0sZuZzsZuN9+1Ywvzzq5xZ4Z4x124r8WZg47a4XZ89nXFFsrptdTil19V8zyPfyiqX5Y10c1MMYZ UyKHMt9/7E7zxAPge/mKpoHz3F+HaPeD39x+L8DpHoTmN4KgZlMwlS9AghTwN0RDoAxcvIIqjJOr ZSMnl/RgJRzixI+h8NY9GtJkkFeY71kbCafDjV+Yc44iDPXlvHBxg2tmlgzRBZRRvpNM1drs0G2T WosHNb1Ewg2tMbWmDYseMPWC4I1NvGs5cpaqdxhVdfg8znJlYEOnd9ZdTUwaqbgtRGNXFYrMupk1 WpzjT4w61qSryZiH0+FjVmnisSjKzeBXxFtKw+873eMkxeKi8y9vq9Rajelgzc6t8JYWtJSaxjkg 4DKDkNnAcWPQLFL9fzAVA8KryXCryakp5+fWLj5wwz+7pPlVJ2dNTSp5lrGGFSrtt1du3p4PVI6S u080PQgo9yo0sso2by2VTNVPWKRNSK9Ho7ej6nrn2h3bR8KbJ8A2eYIXFZj1qCuB/I5HKgiYnAOp 5G3JiBrBS+IJrODG8wx1uY5HjZ1H758XRB+16wrqQWFNTTHEOdoqpmCdfb/X+XDdaMwuxwg9H4AI EwxMOJr5nxGB6rLkEHDwTGxw5MlaitkK5tYfR3x6eOE25bCypDGYwjqpFq37J42xB7fJGBmhsZGa +ZleBHswhB2qmqyFkZkxdeDDh6Ja5PTmYxQW+TXkcHBa9hRKPN5s+WZjl5vmtVBmpt1H/ALX3Miq dZAUFF6A6g2ZbqBZucrUKqrXpkRpLjnK3BaeBhmjVEPvMSJoz1j6pT/Nw8ICxZIKgI4eDAc1Fcax xl1CXBanDmJGs0z0WaQBDhqQIrEpYIA7bsrcciu74oBQA+pRwI6LpQYIcCwEHGepieI1yly5sftN Qd6QpC7z5vkMB8h8nl12Hr8vtKolNjgm4I3hUJnwNlSMxssZz22OIK7TBnOujsAeBUKyIgbE3dEp q492sfnyK+qGz+HIj3G17+z1HZ3+VwvrPaADirgivBe7fPc/mE29fLTnCEApd0jhXdCfBLbbWjlo PN07ablBvIkaGTd5bt+AHwGyWhsvrh/HaYmrd34rzKgrNhz8cxRj47Rx8bugOPV3h0pSVOEfxR27 N2MnWQOtP6vmO2ohhxZlZwEgjwOHx7Zg4Ub8dfZ2sXK+EYgyeN18uu86o0htJl5h4fu9xPnNiZmD rFL+YbLz4fvee8nK6zeJOV77655/mGbfscA603A66hpzVfA+h8B2nC7v7du0T7uxwygivaUin+SP 4kGkwB+hWf3ue3MlFDy0lkyWanlykFm5+DXthrHkqVVaGzrsemdmCcU6kVBJjRAhOTJyoJnWTxkS ku22TeobLRkLpMUMxSohqpN2FFV2AP87tLV2ZjOFhD/P1FnN5sUFFI7s/rtUvFUAukGvVt3bKOh1 66zZbCsiq5ziOjuNtFr51Qb/lnQnGiOV9l9dlHysGdU0YznVjAquNrt0Xz88KnWxssdZb6aKEgk7 WgEnZ7tF9RRZWttFfdkfeFPrKvgiMmikWo0nOW79lSGilFRN9AvDo84jlFRSkM6lTquhzlfrgR4Y jZ9e7zx54o/C+TJH8gORKOez4d9ufIbHcQdL+5WvTlOGNO0p6cPqRzIA4c9uqJbLj2kGy90Cmpht DB7vGsYaa7T4wZTugf4/6boDpkUaQpN9dnruQQnhE4JiZwdr7Xl77xVVdCxrCw9O+Cs4i9VExGlC xnGc1URiBKMVvFTATvO4ytbbWn0+M7WrzmrpD3vNZvawLC1ckpG7itav/69DHHLn9B0O3kJHHDZ5 gGzkBshUNqkBFRDzTBi5TqCbI5czto44sze7eOtjqsDNqjkwyEmHujHEQHBxEBQ3PqciCWl30fV3 bt1FKqKa3/Nbmr5p0I1JPO82PD9/vk3kjY7d3uaOKTlZI5cvh2H6U03E73jbNCzEeS4Iy9p48OXi Tq9np0+WVPaPPr6Dzn9mfrnMXCYWHwIN8UEmFdiGmdKuDDYEVHVfB/GEKeCGp8RaE9eVGMPKEXet jPnzFo6efoa3n+C6CzCBsJjildAda+P18uFo3ImUXzGYSArDk9TdcGQO0iiIgnbZWue1qKqEJk93 Ksp3cY9pJPInNb+wO0wekTs5dMtmR6L3TPyl6G22cwThB+0/d2OG+Tbsnso525tX734qsZvzL5Mg wsAL3y5rf5JzWEVafXt75Nf2Hnvru+ceDh0uXKuY9vNTqHohBEuv/Z+4j5BjzlvTLjXz3d7GJZ9N l0EmrihMnMX+ucZQhZUZ7Arm8s0NZcjAQIxG5ze1HjOGl25GHiGuXbAMS+vjweevctn7v48d438E 52Hvq58f1jlbnOEYiMz5rvHoiZxv0zn0cY7mlw+hmS311sIoo6cxr06mxpd0/zI/QJhMy10cb9Zm tU7uvCrjiCPNVWV9XpjPdb2z7056Y+GJKsrYNCGIBAxzlOT782OV1cZV3YtAcsXEKHM58mR6xSr0 z7cerHHtjv2ZctC32evZ4o545rV139up7L8odDbNhz44jXmKWia51MZUYGuGeHbC4TdtszA5RIYT 3qLPsZB740sXK+WNkccuiU0FQi18mwZqYFcZOlEffJw+YzUsjlTQuKzVKbbYPM7NfVdKiu7K0j2m 32nnOh0p3/8sAXxqo8vk0K/YEHxI+qPm6DxPB8mgxgldUMpuOxBIESLD3gusrjlofpiKLp0xcz9B GjTGc2ElIzbImuppbJz7bm7PZr07c+ONceB1rXb6jZwu+Ncc6qrfzwDYS6zVYt40w5UzCYGyYhND f6gHBsFQIqJ9wjmDQUGux4IcSjTmFVVFVYAa4htv30r7m1FEtEcY1CWk80oH6DBj3S+DNWI4I9OE Ka0hKE8fZUtNN78jtEOOgdzMM6SB8TGVM5u93lGAbRz+79sbNutsvu31fE8q7S5nNaImyKrNU+oz WDHSTvOdIWSLxMU6FmtWpnJGrUqzNYen1jUXrE1c1cxWqJ0m3kwZ3q9FRTTW9Q+rzU6zdXiXtY1V xCUTqK1O7xOK8uYK7DciQGUOfq/V5OyN1RUFXrxvgVpuBCgQDE4lmqAPHjCiiikBTErTRiaYxjhP zlN5O2R6JrYtsnXZhyprg5AyyinAziFgppC2u9mLW7ehCYSwTA0oQYM4oqoiUHcxqW9k0l92ycIv wfosCDRpZOsyD+tyyvS1jn9H4TY2D9GXYzKpe/pIglwoLf3qZHdQX2R60XLPMo3FQjV0NajzPApo ZXsqAwiOF0OQkghJDH5j/iQSK4tRlTXdYV0FisqEr2HoTYpjL39Kzf6q1z1xj25ZgbbLE8wROZzM nBjPqRP6awKCBVbS//3k0rGSQKDhSDr3v0k8PiY66yvGWGULXPFjmsIREamhBBwo7VvZsVK3U1DV qwoY5mUtwqfcU8v2Xxz+4xzkQz9dT8grqCuHlLzvTyR6/GpK65zPx25hevXjrzdMTr1HxxMJtQLd kl2FqWtLqX3h/Dv0kyZbdsEue8uGhZ66iOedIfQ/qN/cw00JpKmNaj7SyyN0SbWY8qwBkbl9bipJ 1tRk4njqchgq3Cei1cMIj6XY6JwMr5oRmy0JJzpXxuxg5ENEoydueByWG672+nVQ9wPjqfO9L+ga vXjBtunOostnrYRUVjy+zbZGFGTF9WjGMtjlBJF6o4ug4z+lMuThnhLPdrqzNWQvynN971jQwNMU K3Ahf0hVriC11Oo0RWdDoTZnHLUX0v8DHt5vm9HrcZzK0OcQsEc8qAUSYgoCoHoNWfPzO069S8lk M2dz3zoi1jbZZdQFO2q015q78EEpdhZEkttV1z799r1fVdN9lSXWWYrGp1lN1DqBBaIPc8ldKuMa 6b8LbPpEITshXThGm6rC9vWIYV1ojoj+POO0j1ieM+QTt+pE6z4qHZ8ih+pQ+YedJdJ6CPr3GpC1 U9L3GnLbHa24piu1mQVWqhQQi0aCHEOWrmSXh8R8rKTDlEY9OMN+63axeZmGnq3zi4B5eJ2i5W7I 2H4H8R+7Q4fzuP0B27LNdPNO5xcP11FOLtiJx2fVth6e6y+83uMxD5y7lbq7qcy8XV6rYpVVpS+d 51hXcaMwQhNFzJCIy87uVmTecay8U61o1sl5UrWnhXZjW43idQh86W02fxQ4EjhggELlj+r1PhZX 86DCtOmD0lrbz7tvM86z06nM7AsjOn0abKKOHHtyRAwQwLS+0qS9R6iDuXKeyAM5tQKGpBUS9REQ ZFgJk1uhgchoCwFnVPTpKSZXWw9rz31M1r4JrGsfZxWo2OQUGJw8yF+gN1q/w8vIy00epe4Q1c/g 7sZyR83/GOEWrZ6NeCMUBEg1WslhrOi7qlGqqtSwzWYtOmECUBSLqIyhO2gcXbUQMLx6HfjrHKjX Gxp3tdbTnbI51rv6dZxgLUeII69Oz3Kz4jS/fixjRv0chcVMeM+MYoaRW/E4vtiM/mrtXfmeuSaH TzyervR6Q8LygthjrMMr2R6rBsoDUzYivquuqWlzmTMGk9RzA4PqN5XZZgpmVBloE7goPinrHgPY UfYu36VGsLS4+kYYpdJy5vNx/R5ns8/o83gT9KlKqwqld7E7NSTZsd5vO3yzv513t82aTClUvNHQ eYUElLA7qPBo6k639zO7e6G5f7Y8oTJla+MFa2swqa5VVWtzedEQSAiJVfeqMZhP9AoLBLayi/CA j97RuSSqicJ6JiqJAIJIURGBDUHNnFvzW1DaMiTLyt6EdXGib0xfbN4bRXZNNdNbUKlWLFsrOSLP 0eYfBgol4XnkjxMnMTVXG/FV32u307nw1442jaWxcFtsDDCSeQ7feIknlhNqFc2TgwhXY+T4idC0 NAdaOFZhFbPLKVMMcS8uGtayskyQwwVJejY20q9J7T5u3Cb+j1cAgExKCPjcFKF48+1Enuh/mqXo MwyJtre/uU+stzPjGkzKhHBmcwqoAEHKxm0Y1rQNgt7bNL2FpWapLV1OSixk4KGuMKRA5VAsAOIA iMSUO0PR5MA30eo8VKkoBEvscW53UZ8X4Tc42adMCfGrn11tKxkouCKVysV9Nb6q5U3S42wosWqE rq7I511jnqas9xu/XbrWDxrXGdVhR5q+55eu27vGPM692EKPpREDARNt1gpaR3rBe85AGTSooopx Q4FHzBWon6H3fEIL9a+de1fPX1C+1MnsrG4CaFBta3vade1aaqVZc3jU5pM0J7qGgdPaxVxlY4fM PhK5fM0plTCdyIghNzkPtPvczxs556fjrrp7zjChZHm6VViDD6zG8xOpyYt941bozBmx5M5tUTT7 yt0s1Vkp8vesIinh3vW6rUmCYWNZ1vKirlYnDjwPOTMaxc1jedavOdbzmdmc5WcTjb7oS3jLpVre LN7HORAdCG3fzgofxATnIY5IKSPtQ3yBxfsf+cLZmFayyMGYbRcMvAoJpIMVBqeHCrT/MeTqjM+i ePy55efXt2JSVcmHZCoLlxFs+7w5uegL1ToUrH3DBnhAxFwg0Fdnx2+Hr6ev3Y6WznhC09ZVczUG 5nC7T2smsp9VqdVaxph73VN37TcsdkzjN2Ovn1L8nOt/3B+35Ty2ljcP3qOb4qY7IPEOZXqtZc+8 xiBpB3+K9wPcf3wcRl8mEdq7W7Epvv+Cfvq40jyu3iIbfLw/Po8nv4cMsNlGF+s1XXmHs3hRfS9k uzkrhfHs8AwkHtuGIZmCX6xvfCzq85vrceXO3MTtNrl/6cmj3aih1t9yyK1pX0Ns0MZ7GLjDB61Z XEoXtIcTVh9sH3sUZYWrGDUsSdRisIFtU6yMNF78sJLfVtB+FjhKiYWatc9ZvtnBRUNo5HBB/wIB xEGXIGRHop6AeFwr7vze4+cOZlyNjMHt5v09Lwjsdn9PNOfbik8y5pE8WuqbVJs12slRONdgnh3e dHCgpXflppoy9vL127EIMKzfDzwszV/goR751B6vjmd4552dz5nn29ns52SROv1/1erwevO52zYZ XorKZRiaqiMCY44adeYy0Uuxdqygrs9Fi12aqtELoOpoLLHU1x2VUQ7wcPotvukVI6lZSrrdKNlD iwW3C11t/kIiXjlxMJU2mBZG66dNqYCJuBByZr0sCwROmlCnwEOoRIibzSqVLbfBtEb5aMpNRRKV DMrYE6aSRTKiR+kODnyrq8STQdBVvBSS5w7QTw9oioxiiKwOpRgzdycnVy93GyXzqnKe4xTzd1jd m7svCy+0yxpxXu4fecRDw6qM6uMXvONa1vFvmqeUYs3L5wsPa2itRGYxjEOjVarFGda05haqnzEY 3aHeBGG4VK3kSp6SlU5Hr4KNAZGZkj4WCA1df52a9bBgQxHYnkyMm8t4GI8OcghM2bdswtv2nCrO BGpymf4+rp08YPlpzbM1/2VdUevWypBoYDboePHoIiBJgYQAsi2EYKcB9HCELmTm5nAW5WZmJ3Rc w5mctcKb6OnWjRqi4JNUtLr74vvsnK3RW+CuZhVQ7AqKsxfArtng6yyNal8gKued+FksA5ufG+6a Kfr089/Ybz3z16RjmMi4zSnGZi1PEdLC1f+837BIUXPrETNXVVjXQsgtKXSREBnZxS6T70JUWjUn Znw/tHa+3bKnqcZxnPRVa2+oNT2nEWwp6579/V9vita3oIl1ttdlsqZRUxDIyCy6seTa2uqlH5XM 178P5mPPq2vOrdfWuuD/gfsHtKta3781jkXjU6zRrFkE6gbt9IQbAjVpWP6EGxv2vcN1G3cNbMuL VjclktZVph8IenjPLvdvS8e3z3Y4Wxa29AwUQyRQcDhBFErXZXs1PMZhcDp4esd/TvUT718FWE95 mCc494xSv2ue6rjvT8TO/rYwFrhzO0uab/d6L+k85pz+ZuvnJxzie70ujypi/hexhta+hEQIb1hQ ytaU4wKjTbdHQ1CPWjSijMT00mXSjow5tbrrWTNV4hpyFfZVRXnMK0L8xxvVepNCYGT1VVVf1wlp MOI+KPVT3+zqkVPy+rnOvF+681q4ut+3uuuxv9nWeU+4+Kxvjvmqjj9vfrXOdedt41fjUMNR8u1e ma77xCvtwtrqqnTh9AlWP2CVZcb6qbL30135rqOGcx4sFSiip9RJgUYYCYVMylEzMpTkuKiooqmI zbM7kRA0kzWGCXQIV58QoZEQKtOIGncBO12jMR12tyS3EcLJ2WD5vizVVQre04wlJ6NGV2pUvVvx mnV3Dhh5iIclak4zyuTW7rjVc1WKmoxdtwLSOcqbYWYHLzl1sm9Rp8XETcGDWoVUOORT3mJ0UrxW 6et52sXm8D6d6vc50sPJnObNK3UzrGcXWIjOoxjUSPWCnjGMRDVYN1E9QVUwtUh3nWIUnioiCwO8 rlUXSL0LiKIDCviAOQQUCsDMRe/Fca2HQahcOAyGvdqeI9Cg0NGMRxPOv6ErVFXeWBlAviPETK+F z+Me/M/ymPas+PVLfKOcUMcZvRJd/RXtUg+AePEbI7Z48fa7RTjYwxuIv8PTMd/ulda1rLkQ793c rhOXWrxyM53Iyj0TrbQ3Gu9G/Ow0X1rZkL6U6l3NMbbRFBEQtJbJ5FZa/CwaD43XQoISjkuWWUGW mAb9Z0vWI7071j0YOmaTXi5JlsrrVauM8T19zD7wt8bN08xU1XLyeBoA9DLWJQ/mHWbMz5phoh8q 8H35Oa3BEyjcDWVxAal+eyeMJxdVGkEMo+DfbuaA8WN56767v3srtZPxv2nO684zHz1v1dV6oid+ vaRANUPBST8x2FPtO5n4d1uH77jt2xhLrwnFwpXfQMcmbH+MPe9yuu7+F0Z46W4+Pffp6c53v035 f0nqu1PHVHj14GGz6cxDDGkBlDMyxEMDV2cGKqLhBMbMIWRaWDrs6nk1484HZwYKlQFURLVEYUVR FVBGFREEUVACvC9oXD46LyWt5lOPMJLPN8Hv8vnqNzPbhV7/GtP48Apuu1121grtz455jPNT2vrq qy2Ve98aqc6zwfEKMK63K66D5KToqqk+iOQh2HMMdgvccATzJ2VLoG9ScE6Y4i8ToBPA8Dd67T/X zeJA6ibEimHr7FwqzLLvccp7g9HS6y2cXF6Ih+Rzp+X9xJi0ZGhUeRmQvkyMzA4fBh5AgkF39MRD 8gm6Y0LkSRmQpAgP1UjPKCdY/84ZxyW+4Rv+Sme+1CIrxUSn6HFoRkLVkmv7f0CfKyNIr1mwSFf0 WpJdqMMlSoORZfLItOws7q2JIpSmk9YekPuCD/rGBQ/vfeh23o1iMCXuEccejmw1BD/ltIG/OV/p 2L/CBdyZuwxTRyCOB0jC4pUWZg0B5z0oQDcHw/eI9JpaZ9BnHtC2kvHD13EcxAnSaMJwIQv7Kpt6 P9nTxPcXJYlJpHKa6oBXfl5ZCAkerjjBc2hKhfAt1FZqFGLb2yKzwNdCQrdbUQtS0UaArRxMvepe vRNr2vm+h1Sr2jNt12F1wpRIodyoQMXeYzIJoKRSELjpUu26UujXcK51RNQe64qyp8BQTSifMOLg 8TQaD5iQYAPBPUPzT/6Jv7z2w+yx6vWMe43jd8FR76k7/48UcgH8EgPdKfXIcQIbSD5ZDUiOUM9G 7NR4xc5R8ZflRIZf2OJzFoQWn7T53MTgHz1OdpqU5/9XXcr8M85v9WopL6fT/F4vZYyqcJcfyWe8 c+9171C76/rXI0+PufDSH85vebdt+JlVgSg/vk1DJoKzFTWvqjFFQq7YeZ3RbRLCRPP/6K69n7rm avD90/1CjEbHfERmX38DF25ZXr2x743YYJT0n9gJ/d/on1w8kn+Vk5rOKny/jqZ/WPUbo/Ed4+78 b6vj8NfSxez1+xbsxHoZ6fm5VINTshUXp8sGngyMEHNirlXPwCW9UqUwFKULG78GIUjIRFAZI4Kf Oe5PcQATfSlfRo14oNmVY75DJMzyeorRojliFIholzTnp3uOClNwOI4U2lyVOJ1thzY5bnyHLnG/ IsrkJVRVIn/zwWzV9qixYRtodsxp+KdLRTfAyYyWem8c8fMWzCs7NNlzqNtMafSxWb8TnbLTsNIo +IEmU4VWStvittpt88430q29xJ3c1SSSUky6dA75d8uZNCqKvSj8GG/5gp94If7wQz9i6lP9PYIC MupoCnwO7Zzb0JkyWdTsNgExOE366dkiBimPbtr4uW6GiUWuN2vnK1i0y+X4OsOQp/4rYd9xx+h5 kTh/VYTG12PwclDx3Uy0b8n6F/ho9EYq34ZmSZhfw1qGb4CgecRcu63sFpEQSBxW1fBULTZS6mbB ZtklS51gVcurwxkvPM7vTp1V7mo5/QP6fnh2ydpb4FduoZVS2Ipp2bBdJ2f8uEjSazIJR3/jTkaT aUPHy4icKowr/SqjKPGDuOIB41R0mcsDSqPD7vmNlYAXoZB6xVAlQx/vRmEL/oTu73eRbtcdSvr/ ZB0uTnkVKGlf9yEeKBuzhrTNB8fMg8jWIcDsq7mGPZxJN7pAiWKiH0KQmtcmW6hq2XT6S58JLcoV RHum1/9ma7evB5/DqkmhbywyUV2Xx6Z5v63Easi/jcDRBhu1Sm/6+YZ2Q50XU629fEbCKmkK7dhr Sh3H83j+jz8cvva1zFp6k+5L1JUDMMs8MzBm5XbHasYHLOIBmMIBh0wNGxwZ0w35RMzUXJvt7ekk Ijr0xCUEK84qT+56T5lQmf43caubHSl4grMvhTqYvEIQw9uTx7xuxGzDzM/dYzU0tPxUO+oQQ+zr OxrcpISF8REm1WNrYCsNDKvK8O4lemHzerw4A2jmq3FiylRU4nndjls2dc15Y5151RxTpIpYSu50 2t1P91ZW4Kcrx02aUFCCpBXG57v0Lats4OJBJslHH9WddupzQ0KGMWcu7NsuWu3eJf9tn8MZElRd wZYPW5y02f0vqzfI+6c2duO7XGpIq12yHjPTNdh3bYs/rdtd3P58loQhhN6ZrpFCoPwdu1kwgSZK 3h3yPIpzk5SJeUkLzKmEZPZe6rY2nDQoNBpw5l5YHR80mvYeORPj8cpfbsGcZFNKNyzY/Sbte67v Vw4AG3HEyWn5sMpp9UmVUZIZfPGTFSxTRJXPPHWBXLHOcGTD25hX77IiSgpZqijpxwkib79jTMQR VUtqczlmqplvZYJQ8o21jQNLS7XjZrApTshf4ZFv6sqSNej0Q8b7us67gThiMfNo2egXy0g0hR1m WjHrvzG7KTMMx9qGLrEMx+o+sQ/1qQ+EYvRCc5p8cHRbDJ7u3x63XVvQwGWhZjJbJ2MxNUpSx7bk fB5abu7M/d/Xxv6HMbd5nD0Twex5YfMMoCRvDoJP3eUfquyba2MFez92/S9p6PJxCuv0bzW6MRoU iA7TDBeES7EwKxsrDKiebalTQObQbbNvBwDzjS9LN9yHWnIKMe7m5Y6xsbZ2kIvTqHNcvFcvdahv ZYMPTmVcqIqJPk71K7LSRkYe9hyGzJg/k48Mx7N9KEc5kNrD1ah2zzQkfuVytQzP56hi/4r/twUw j4ufAxhKl8DqGhocvk21qr01SaMe3xwCLoXPdzleJr0HQXb2W2XQp+Qx7WZO/WUDMfHvDDbPVwjm fejA1iHY+Dm0N8kFIXR20fdLFAzCo/ugbgJ4T7R5bcNlO+Q4l+bYMj5Y7fOYGzFEQ8+eHtIE6kgQ y+aPSZG9tR6/YUMYTJC+tMI66iLB/VCeyP0+woGcLeoNMobQSgMYMGPGroXf26x+ov3EYNjoEOmZ CGrx0UDgSQRRwHBQx2MiIm0gcM+9wibV1mVSrQhngIhqW2eQ8/Z66G7XpGiM4363td6aaezR4Mog Bq6GcIhtZBHKFmDDqGD/B2rRmtrhQvQ9kMb7Mnlhegy4XyFIsaj2PTZmq7H4fXeac0Z5Zji83jWY wzNjF3jOArEQWiorTdRFqJHs3hzA83bu6GVOqFRQHmZyCrWKkRUILHcMnx+TAVqSWhUT7kfrTqNg 3NB9pTMxJ9kKvl+rfHhslpmBtSL89yLro8sYAVARoeBnsjz9GOGHk6D42/buurXf80fe75s1oETq Awvb63isRieYlNw7whCaExG3hDsIJWyH5y+NT0ena5kd3HX5PR1f7FUjTdZcS4dYbv5XH8RMWYiA 9mR9PPKzY5yXZw6RSKXhXLv2oPVRj71wbl3zFxyoUuGEPDCO2KsjWmeEDve7Rpg9ogG4zyxTc+jw xpax6eumlnP9z2xrkwnwDcnDd/H6HAI5MOtWSUEWhdT0LFAfvRl3b5H900ZkkiVLkLFalTQolr5D hlDbFkSSjCD+BT93WIHSelvculu6TW9vsGF+R7Wch/vIJkutT9sfhgaocEiPF5zH+Rpm0muI1Gsz ohnrR4rgyK5GcS0gSMpFlUzcek8DiRMi8vOrUbT6Ki3MYfJSkwDoURygkltEcCZzYxPteJK8g8B2 7ndnv+DpN3vr3++SObVX8WjnvQZPmYYHmBF4i7l910i22RRYjPyUIBSA8Enwz56QTJXolULt3gIv SPIgsRbgJCnNURP6ikTmEvpKh/KocKOgoxharMw8TFuN4u0pK++NFJrTRYipo54bALQBhEPSY0Js V97PI2Ec8RlPEUUx9pFkUfaLhDOKpHBYByySiSCD8xf0ME3K7bhyMOacMjHnVu6N910aStUbFD3l MMFsaGaCGGGlzKsPxmEKQfDe7tx7twUIs2SyJLMiqRzoR47F2NIyBxziDQ3EmhBIKyRxw/UOEmT/ Hk6CWcNI0ciLD1mxUU5w5ibNgwIXgp+oVKe4cwWDhYh6MH7SYDwUWIR7jki8XZBY0bObh6WPcut2 6sW35LybnZpm7Cq2GDGeIoUmTqZDm/IUgmmA32Di3IjEWmvbtsc/8GR6oEJfrJe8/aBJAzW+0OW4 Saj2+ByuDMWlyJhNMSgVHoqcSCOKIC0J3pJ9f2AkR0T4NE5ydHXqlMf8fwR2k+OYPunabJx/OR/w D+Du+CrNCU/1g4BF4miFf0/3EWyAYwd+WLo3jIaDxODBNO1B++DBIk3xVwKzEEcCamZNgSWJyDp9 WC9OyDBYTkqIxUkPpuTtktH5ef/A437Cu+d8Z5s4oDwqUXkBwOkoSDnME1pV6JQOEJygpM7Pfray d09mGAcJVr/tFJnTAyVKVFqLsIYIIPLidFPFjZPxbRDBYiKpVSqcViqsq4wysfiVipFSaUYxhjMF SqmUTFSUuViouZIxYqwqyXEZTwzB2rEzVYmKqmMO8pWNYdhUozYZQw/2FlICDQwVGjY01jGY0k/+ z/1Gz2OjxdjZkVVWFO94KyaKoqrUbKYtVXephpWHnlx7MZAttkSV3+y4GmMWDUanUYREjGGAp8oP rB8vwuG2fPvGIJoIfMhrG5xwI837oGPMj05hqgrOJIr0lo45S/q/2zQIfzkgPUSFQgSRqUoZSJUI gmglCZWIAiIlSgSktSfpBIFVOf7nco+DtJ+BmbGw1A1ZLY/eUyxJ/7+92n6lf8n+Xrb7PTntU07q 9m/Gm7+PWn73h/BpOCt1OrqrCnQfrMB5EkOUK1Hn6lMKRhESo/EkclhKlHlpFyTBBHsUH+Bjopu7 mKC76DAHFUCsnakSqwoJGuaf6/UZETCyn2GGWAFAWEqfwEOAxEAwSP54EyL0OIu8awqDACEjGgkP rsljv4X/jZpjaIxjgzTDJSiLJOUBkfXB1+KNtcjCSlKYIiIYokmo2wciJ2MsDLKjbUD6LnUUU/fg zMMkpEricnIHJGtYplFVk5NE89rVmHAjHvw3ai4bYAxpLShaorArS3KTmyc5gxd3yYorzCIiJniM bDMkDuw0dAw2Yx2EYmxSjcEMHXKWjfY1Q/YIjY4doB0JQDEEMmif9bB/7+/8nmNj8cq7GcNHcwCv vePo0HYyZEQaLIIjDREMnWHaeLaDi5d+AnM1iLxPKeUhiUKpN6fHW2jLN2uez0bMT6SycWTgzF7L o3FLKsRsVA6WFCICYi4wyzKk1QxTRRbOEsk1UechvByg4g0kJEbz1k2AiCGSyqKqKqrVJIpSqFsn vNvVx6NIxuiKcpykx5ARwynX9JnBIcv5zU8rH6+w5ux9ng0dyOukdx/4vuaNseTK8gp/wbpurGAY HBmeS/aRKzwAf3UgY/7FNUyotEsD9RrGHCLYeUz7C3OSSZYCKCJWUiZFR9BpAghAQAcHqHqY3JwN IKS2D5BfbIy5G5DJs3JzO7qO0ho8Nzm5MOdU5PXhXUuObcweLv2O8TvV0efuN2O53Rind6O4msQ/ zH6B5aVIiY0JYVCJmKkTeQE0RIl+YWw85JsmG5bNfV8EXz14nfuZeqzoPa2R5h3hhcMDMn8hgcKb DKAhaaiwrGFMBiwmWECJiH1ZGDysGDEkCsTNhWxWWi8RTOQLSkR4oUcpWWimYU2H+hoMxEYyKQmY jFoopkedp8Tknk0YqTg+Z1ObztmOHRu9qmzkr2K6OxWK7Ha7D0Nmyp8ymFdzwO1tFKQoJihyUq+0 tQ0YFIBym0oJJAwFNg+krBr042jkgUG+IawXIp0DCYFEC4R40kW2H+Zo8nwMHgr1ezXQ9QKetWJ3 vleZ4LPmray3snCSHQUkRiYwizDEPYSkx5NCJzKmxIqkdSkpYkP1Vptg39eROFVSRRsYgMFSPPYh iipYm3NL1dTpKo7+05Dx7ZI6IrsRL83V6Xqc3YVObkov/xjukna3YzMV+MB7khwYwUHQ31u3BgYr e19Ay2wE2ROTfi6GicjGNfV6u3znBhB6q62ERwoaVARCYhWw1Ti0cV0UOTGX+4SB9UQ6piMOzs/2 K/qV72+PJafNTSWY+L6nmNnNxsbGzSnm9CH0K1T48xH0vsfY93n863sPekgPICmWoOg5ANZiQkMg iJmMwU9VkGFPnEU7GN4lheTBOQFYkFmg96MnSKWCloqWm4mnWvyGrIjyQjCSKDj2qkg7CsYJBgIG uXFHE8upg7v7RTRSazdzTSJDNfyXdaYiQrziOHcMEceIoagf2Mnq26W2JhY8H1DcxvI8UnsnHpdz DonUiG9FKEQ7CKUkTyUPKtXFxTRx3kTZAiBQ5lEc02bTdps0nD35J5ledXgo5coxlehwygUB9C2n A8lBGbDVS3uY8lo5CoRUeG9hAvwaRVqlZcibFfOqdj2nRoandiD4e71t3bvC1IeuyWVOPmeudD5j uRN1I7lRTk9zk7m6lY6aaKpVRqwcKaWclY3V0aExSciwOGMkaVvqMEkkkkjjH+oog8jSIs2QMYOL HNhvzbRsbHRs1EbqZElN2n43R0I7WxZZJoosgcKJPrPJbiLLbn1Vpm7JmcG+ktDcEvLEvJ5iJG5z IYz/d5PVV2HSCX0gTlUZRE3M+wnBXMlfXkZ5CkGLhzzIwNcSIV5zUaXNpuknk7U7VOdni3hs0x1V 0U4Wets6NN1JyVs+Ux0V2N5OFNLHCzZqTZpTDHuMR/uPJiI7pTmpurtciczk4amLpK3YxXaac6aK 3djm5uSh0IaNFKavEMIcJH+V/K+Q0IPb+p0v2i/Cv9FiMJLIxhioqUpFKUdMkeUqQpYM7Llzrobq RSySrD8rX7dHrV2l4pHSQF+qUotslq2VWJSYxiTqnDrj2fMff4di9xyOnW1VokGVf3+Bi6SKSFam QkJgqFVSSfzu31d28g/sVViJ/rI/tOhrIgELyWDxkmgRGNGKp/anx8Rh5Dv/yliO9fH8k4FlA4OC +QiUc5n0DEhTaPGgq0gX8K+Y74SUtQgyTVE6x+3pT9TlqBisImxjSfq/ae0HgQFN9iFAjkT+P81A /x/syMz0MTYe8/TIgRMxZb6dLW/F57B/9W2v/59DRU+LaWc751roq+mj5v30zbW3++s+UFfSoqpT OEVX8lpr/Q7NTPtlKq7GV86lqDhitacNHwVx0xc+DQSrvY/Heq9OucVtfPPKQ13aPuvs+VP8k1Iv /ZO9+R+Vzgb+02PtPGfQD+IEgf4Ej0KyOUyZMf3yp43ax+wioedyfjNemp07LjdH8bU1uzvOHdH9 EcJu65OMx37RnS/4pCL/dwzpXFbT/KflpX3HxfR52epaJafgL9usRQgewTEo3YqxZ/U3v6f/ocH/ 0fMfsOQ7R06rD4KP7vv/SrtJO1+1x87+JPi73gjuHCTp9yq/OTExo08SlVVJ4E0TGkoqlUQREMQR D+oF9PMh1/kvIY28QqecWJ/e/VU5RD9BNPGehfdj8H9L/RcrfqTlnqK//JuMNB+b2L2nI2IoIIKi GFimCkpg7T+ww5Hy4jujwpPBp3gtYwaJTQMaMDCMMIysyxMwcIiLJqSRiyQmGFKUpSnRWlNGMP0l aVWmGitKrTDRWlj/0OSYRpawRvJ/ucpjcs2KYf3cRilUVSaRWKqlSlKxWKUVKFSqYxiVUrqwxTTG MVilVisVgrFYVjBjFYKxWCsUqlIpgyMMYYwVimMYYxhUpZjcaaVVVERERERETERGmkwwgwwjFdjW RajdtNrOy4rFGzSiYtP71JmzOrG5pyLflXGysUrFTimn/O4inUqpkkoxiFViqqlVSrMSpTZjCmmS VWMKMLIxMUTGNJmMpjKTMjJSrEgJCgIhiISRiKpihopFUWkpVWstaDJikqyqpUsYigCwDrmYZ6/e KiR1uq8Hof/YNEfL7k+RJ0YG3RJqVSosLRCJoZX1L7BkID5w4QQSnhBgjOCMUhALoU2SJVCIIIpE apEZkFlCCREUYNC+tM/z8U6k9DyEmKk+tMdUkO6d6R9Hd/Xp9OmbT/OaZbgNls65Ect4NPqyJ1LD qG5C1EJBYqP1+33EHodnYMD2oYhzZwXGPlE/aR2Snp8nlD2ey8jrXaKAPjAl5zwOaSSOOW/HpNGc kxYDa9ym42WPDExFojWYLAygEhQkNIjlK421LSSIjCi9vtwwbG0Yhf1d4Z2AfRPQgOxI8sNpzORo 8YJL8c4Eesk6Tl0ibdbI5R3B6nHUT7h0RR3BlF43cRH0AISjM2PnwCQuE4rPiw0+sbO7DYpRZglA CZQEibSLFehQ5tOG/q6dQFDwkJu2KEBzF/mYXcMcHthHQ4dh0FxJ6FdHFkYi/hYGFhxnbJ54hnZI 6GxYrxgPNG8eQvqIBdcm4PFHoR4mDzM6HhELB5IyjkIbkAVBATIRHMIxvATqTkPScD7UT4NPZNkd E93Kz1SDqlGPR2knnKcnrEiPSknqNsklqLLH/tjm0SRiAN1DmgDyeU8vcrSyqoZWUYgfqDvHtVwJ Ve3ybuLx49InbCnUvWonkOYI2GC7hdhsvAFTP4/2hpN/VP1rI3ITmvuR+c8a/u++dw/jBnH/IY4b cvMHyqYhLdqH/Q2izJLS2SZYbmCeHMRt87aQbLDZdg/wcX/AOJGc/3XJG/T2GRwzRGk0ZXN+rlyP BJ6s0RBEso0f/hiUezbEiRanezMik8tjrNSRJxOFBRtOB/gffx0vOQxOAMMm5/9czMh2wlqLDwNv P80l43k/4f4b6/vKHSRywk3Z3Dt4eOzhSK5v9l01oqqjF1DVbtHUwf96YTCEpH+pJOfznish7rG2 +XgctA7mR7ip6VeFkPfTvuLq/xVIf1Skfig/D7BjZZJij7ppjsRYk/GP6sf2nZnhJPBVe6FyGWUG VghBpWRZdD8pPuKxI/lQmB46if5yPwJRRs1PAsnmFj/kkqbuHKTkkVOxkm5v/K6cQ5BwXELiaJJ+ G740F8cYnciBwKgflc5INgepCU4i/k8+6QT4LCP+XpfG+VnA0JN/wh2kTgpEg35gX/QcC+Ar/wc+ vOr/q19WgbN/vdnYcG55gX3lU8UVB3/I+BnxJ4oBNQf9Y0BUxL0E0P2en/CnVr0DDp5laL76RT4y T+3zv2dM5fdzQ2c0l5mLJJPvJtX5t8aqpalN4+Hznyq9T63qs42Zrdo3bEnZCJoWHdE+7Lo0KDtA qP5w5hjyvxfcxydHGDRtomLB9djJNhrBqLmnv0MIr6p2HCbGzkw7TQ259NNSdyIwTpA7koc5VO0/ +mCdgfShiah7QiyUnJSpVdo6vebt1mSI56fR2Nt+DphdxgpDKMS97igJ8RAxwYRjblR0cuuGzbos njWOn8v+pyTdRZTsek0aPKHq8P2eJdaxzKr4n7uwOfDmEKFY8uGLrH036eDQqcB3ESM+Kukfg8zb iRFK0TIkFFSAsyguASlFkL0T+/vd762z+Z0P71f1pGKNKkPkVPkKkFVISU+QzjneHIqpz3grZWkz t0jZs2/wTfYaFmyuGQjojRdGNquL4jk6v5HxOw2V/sU/waThuaRu3eLHJrudFMjrjsVmn72I8RW7 cpoxUxVbn9m+2fn/OWGuh5OBHR/Y6bEP5782k2OP3j8Sh8RA7ix6D0d+Zi4MwepPs1Nkjlv8iTIn DSyjdunod6VUTzdzT0mzSlaMPO1Lp3mkr2K0PV060jwohuwg7yCmwqaPExFHdA0aPjIxjENIcN8J 0fRZVrkld8R0c/XCSeZ0VdWYQWVkgsMiGTFCVJhKXMZkIZUM3JYqctTg2TEwKR9aKhxIgMgPJAUI iPeIgmQltV0+pA8QbvSk7OQ5HnY6yPzMnX7meXltbwSTZSbrFsnnKj0KiqiqDZN8mFaotictmR6r qpupVaKqMpjsgfgYes4YnJ4ORLa4+enkdqoed+Q+Q47I917If6E63reprtY7ct6K9Llp5OaYHk/y U5Oe1sjNZbhwPueqbHWPHhrwj7mPGet8Mma9y78uceV3QOJ9vsVcX48DlxgBI44D7WnsnAQ4iims LHIyAdfAuCIUaSQ4NrIlDMJmdDOBrZP/ZYP5lVFJ9Bxy6+1z5d5ziPTJ7G3yPSvh6DPyU2WZbjSq qc1R7j2upYjkFkkhskjg4KqqqlaJnVzcXQG46VFDRBELKPx4oc6OIoiJvBZosRPcqQORLJVNioe5 UkTuURDiWEkJOipBxZ+bqOYMLdpO77/pWMH8cj3+Yj+I+e+kCB5fJePhGf363k0+Kzs/d0U/Z/Dc 8J/YYLIokmwh6BUAD8kEVBNaMRjzW5GSsx8hIn6IyeZlBUK9Q5AEUrUGfaw58+1eYyJ7I5fmS8q8 miMPDHPlIMCfesQ4i/tbR6Hm8darfczkxVnSjibqtNWMWqb0VVtW8U2nSO+JxvumR6HcjR3u7DLc m6fyeHolhp3IqPIoj5f9s+U0jht4tfxHs/gWiiNz3CaPo+f5vyn1UPaaHWU+4quzNgcgRi7WG2sI G5a1tkZRKEaYtNI+mQA3KpveONNtfbmpApBUk5GHByLJxVhBeDFODpNCDFEoJRRoQ6E1Ic/jG5ra 5vhrg5TZ2uZhVKK0yVfIcg5IIa3PzKMjT3k3oO2HGIDAJyKE3Ysn8vQ3sit2zTWCss4aj14MiGmJ +544ia2ckslSyIrGKUqmNsxZp/5dpNd2CH0/kk0slQvpFz0pOCftHKSP2pYPTB+WpOSOY2d9Us0m ifmSp8f2s98KT1OzE5ccP0bCE5D+LmSdiTMJnCPxp9pUFZXEtUAR6gWa1X+zhKqxTMA5MTzCHoT5 Hd2IWeZ6W9W+eBUnqkSeKN4jKJoJlwcBEsKlS/XT7kMaJ0eaCSjLAIym4enB8h3lQdMXLmStoDeG m8tK1oUXTZYqh8A3Vwm/QHMXNAcuJqwOyuFMBfTJ1n14U1U7geTYTovah2VBWioCWZgopKjU26mc nRo0oh4bqGg0DsJEQJzvWHI0bHXdeQ6fEdYLCqFKcEiZIIbJ1ZHEhXT/I6NIY6cMyIxFdHZ2ehR3 +s0p6A/HyeZso+kZujmfonS9rgz6G0ajtjHNw9ZpzJPXBh2xaWW+1kTFgrxr6fWe5TmqTCpXcrGl NaYvcuPgiNaj6zeN0vrBxxJrAmCOFfk89hboYrsEB8IEimyTaGxXeYmyVXPZg1KDpNSua7cnyfn1 h1/b9w7B9waRtx6JO4SYdlw+skfwY9dI/ZSfbwD79X/kEB0ldo74XuezuLH5pRsP/q47VU9P3evX v0g9ePmbtnwe9wZEB/rBFRgxH7B7zYYBz/H/Hjf2rmzIZGNyXzPE2cuj6zCvkSRynddNlhL2CTt2 dmO/7+yId34yViqSXajqmdsOb/RbNA2J8NqckFlQGUHJz4VdqZowGo4tyCh2ppDCqndorgosnXpp HBzBjEEj35qDO0mCRIxgokKksEg0MwERBI2sQMDodh2iQEgNgi4BmVkWw3gxyaJUGGZnEEMtSxCT pjh9BBKWyamTIsgSwjKyuRBThgMGBsEUZ0S6nLUAtDmgR00ghDAHqF/F29dmhueHYESVw3B1Pk1E A+x6m1sk7dzWY3i6wK/N3eAMYIWlBf0rnBHMMEuYpKo6HuGNAbpF2/Kp/AgT976gPqPqeDZXHA1w 1WZb18JCR1kctQfjSes8A/MkzY8GVjli5kZSS6wQ1rGqemVsmlUrZml8Wnw7PXUcD0GMqFUVVJvP ewJydOqbwNqCpNB8JJokJSV5zznn8ivP9LccJ3dJyzqp6FwUXe6HYYJSSfsD2BgaDZVOPqiJORLB 96DpHp5Nxg862VzSMfD7fS6B4O0eFuZzA3GX3XkTKsSwE4EKm6SqqPZHOo7yTeOPRiZ1T9P/af5b Em6qdvYfHJPf0jt7iu6TPDjWc468HKNnhHsME4BEaF2OdeDzkq9YOiF/eSoosmKNx/5GNHSNsSPi nVs89SzYGJiAQnXSqZCBEMJOkCfHYNI0sQjb4FSVpsT3TGbz59xp57VkbHhOGsNvGJzEnc7p7+g9 EOSdvaPcAHHIcnjkagoMYUlUhMlwXRxMzVErShsaNafiEbEvSAHMCsve4M9vY8LRbxhAyNWOA4RE QxsfQglX5UztTjg7PSUw5OmpHjTGMO3PfZyK3o8rksvFXLXJkzGmjW6nDqwhYDgYh48GvgbtwNjk koz1ITiruUefDcKbL4hIBeQcWZ63z+47Y0pPFYqy2Xzdg0J0JWyirEUeeeiy22K+HG6dBNmDyeDw Zuk7q+WtrC/JwI/1A6el8SE9PyqkHG0wk8fQhszCa5oBA2lhkIFwVbRjjnZVIuHbBQ1DDyiRIpCd kBp/iRo3fUA5AzNrkb62GwiDJozIfNQIOHYMUOaku4Dt3uc436qve8rY5Rod13Fhw6iPM3HWD0RR wgJNA7bxrSEcseZbFDQRNKQG6b8C6DDBRdGd5xuK6SFZOCbqckLTpwzHI3LMYM5y4JMhxOyTgbZs mLc9j+MPf+D+76dfM+jw4jk05VjB74yK/4VTbcuVxNkqPKMJ5eZiNkltPMEE+tUEbiifTBB9/uQb 2vFRRWOpnCDjxXEO4Ve6AO9+bNEajAVj0l8JalfOfMIe8EREREESxKkfRg3pGkdK4s+KxvW3YXLr D7QpNuB7M70ei/lP73ufnfh3j+9Q/QpO+eeHjJp8h3ZHV37NtpHOwnOWfhgdD0nmg2I5fPjwBFAz iATJDaf2BehoyeEkC0QEQr8D5aXZ36TQ+61ighuPcy1VpsJSeUYtfJulTmkXaJknlYzFhDGpDkfl PxvjaY2SJYNEaCIRmzbls7G5D90IeDYiMK2Yn89fLX5XHzNTMcjsOd23uI4dpu4OFN8do0YjkYmG MOTThU0Yzbft37Tg+Fp5p2STsJN88K2aSS2Q7/hCa296cqFWRGLIZ2GtD1z7ns+b+1VV2ughOcZE tLzdh8OQ7ZrsWJVgb/A+iopTF/qRgfofjuwb+Gx4g/Q+7QO+2b+1Iz14UGf1xiH6CF7llX1kJ9yA A6wIxCpv58B+yPss2OB2XHXDeH8HxecdcSf3+cVUnrlYqPZS/aRpiMIs2jSVks2wkbCuCYEMRGkC wxRyUbHzMYWakNzHzftfmc02nxRXLnmzd2uxDJEeZKxp6TGCqVTUef8ThvXyqrHD8ykk/MqTtB23 E8z5lGpIPqh4fhO1exdxJej6RwSnpk0nZOxatURVcHCckjRzhX9XVqQnnWQ9apP41YsKqqg9CtJf nT4staUzpD/HX/eT8knne9EofAqNzlPhNJ6k28wJ6rAH0yhErMNKCfWMO0jtBh5fNsOHrj1uUREi fSb+UJ8aJ1cwsdesag6OiyVR5VJYk7AmRiR1KRVhVUTJZiG5NNoNjZVSqpIR1gYMQLELAxmBLgqm wRDZZtIaqMKGhJTCTZImGJqRsPlnSQenDI+S/bK7KHrVNxUU+tVsTlp+2JqYtv6YnYp7IYxAxKVs ozJGMh9LGlOWBl+cJsyDovjH3yDwRjIUNx2GKv8IXZbdgHADOd9mkMDYEcBdgAnX1VNVRSHvh9JB kkE6qDIYnID9R/ZzD0Bx881Hb36DGQ7gpnCCZOpQU6kRcQOb2J/iRIUMsytU5+vgVOCD0v6kYEnD qYk3kJTVI5DwdZHyfvXaRukcQc1I6tSTd8R+x+R125G1tf7v9/E4c52Q8OSfpL4vhm5hSyofvVRy ZDFYkoumXcPOx6LGep9B8kFFf6j5v6tUmcSfvj/CWXCf5JP05Bw83vGrmJ3VvX/Bf5d9nTsTok0c 64+MDtPUH936TzPoPsIh47+LH9+nRWJ1sjlHRgqKH4AbwKXIViVCXe1IzUih7dQerp64eoi6zgI+ kf5t9D9ZkHY4KgUAz6Xz20rAhG9BsdErwDtVJIwYjRgLh+CPOdpB4EB8ktHisXpGmrPk/ouNVV/6 5kPwlP7GE6maPizWotyc0RfVZVz5XWm4UZbLbbNi7DWzGDYNqnpQWRtrCyyUwh2cSE4//CzOMUYE A3NmLf01nSD/DVtW2ra9sP72+nnH7p6U9PtNomlPWxiUYkjE9kR/t7Dp/Lf1nLt36E9QsgHBE1Pg pMJOZ1Kz0h1PrYjwsZClVZSUs+Y75+6mHRB0/4Z+myoeHypyPWP1DGKjlyYjiru+gehvD+pEPB4R PSmoR+BZJJ1fB9sPueySTcetUsvoVDJJ7gWRJkIroHB7bwPtkq2rTw903uHdaft8yZKyQUnRwIbB 7OPRfIQbcH69efXVR8MVPK4DAhMlTswD8M6P8PLabuzyxnrduzDINBNmsf0OU03K3z5+UzaR6Dcn iJ2u/B5OG6QDkYJc2zwgQZsw97SDLaK3k5g2DrdTmgiQIPYUfnwEsNk5oimahAcKIaQ0oiavyoQD tlgIIIJpZYiIGaoaogCCFYkokgUghQgPDzeYEP8Uh7xJfMoSGhhNhQexVQgWd5+DUD2+BiJtztYS coPrlPG4a39yfK5SG0PfZ0WR6jgbRHrOO+dsSbJWKTxFRGtQTkTkeoYfeIahLQCaCaTZW1AhejDk dqpVLSeipOLWnPNSd+2GUtUorMKVshrZdS01LMViuq7awouVxqUQouB0j4/iODbvfzB/F2/Pfc1+ DcrW22s21gAntlQ/OQvzP5jfYUVk5NYH4A3XhhN3+UoKKftPGwi9Eg+h2O8+cM7qiv7dQ+19ayaZ WPeH22A2VxrJEmhJZeFrxun8dCa0ByJg5GkdE8ISNc/5+2OOS8se3EMT+wbwCFO+X9xAbw4buIei SoPRR+GQfRAVPmk+tH8Ifs3Nwhwn6EO+YMU0qh+37mN9r7u38xtxwcEkSpqMcTD7Jw14uIhyHxpU ftT65J9iQ3n35IdpPJybDUSZtEfQmcET9mfjh+Tkh0FeAffhfH3AcDxzADtZU5Mi+OC5Inmf73VP 6Hy14H2smJ1h8Meh+TKfmUeDSQJAceFUZoRDAqGVSkJ6RiDC4xroZ/EWAs1LI0DBiaS7mbN3/EKh bbnBqmG+zWzTNjTTgn/NUjRXsxsOUEkBOFkgGB2kcyQqJ1LsNQ2Kj/wUmnIx3EKcWfnrdZzfrYZv 71sOjZBg0+aMfa/A2mthggtzI4w5QkFKGtBJgmjDh48bjFuL9USEBvDhAL9tHT7AYNgA0uwvAzFE RMTF9/5z3f5y+Yino8H6I7ti1oo/IQEa1c9LJZKSWFI1x4aOSpyUVwwXhjiybOY4OPQQ33Nm34X2 n1P/YbqTQ3nDZwwqtaXOSuat1aSWZTCx04GitHRify+1s6Kqnh3p7pNDNYkzQ8XxrLENKm+w3Gh+ RGJOX41havrPwLjszshkM60OFmg0W58oQQ+CqPoAJ0PwQY+lyjDgnElMGAHkPqMUXYZUh5jCDwgH TBoYGQ6A0tCHDbqifrdWQelTTeAyQlRo69p3f03l+kSgmEgIDwVI2hwfUeyPYh9X2n3/DhyPvPoG RNaUwErRD6QUSSqBzAqUVvArEbnaUVJ7dnTj2iexREY2JNBgRtpJX1K9lm5YcKiMX43JTq061i1E FsJ5Td+XluPeYERj3ShvyqQxR6bo5jTTjEkmaVrUJB7HIduk56TB7ojXyz4OzkhxT43L5ydu53LC Pr+C25BpOY5h2Pn7U7G6zDVNNTNUKsZC1VsjNFmYyGGJoahas0WjEkWSaYkMkmi2TQdgUyEVJsxM WqUWFhV2DIGJMlkfbCog9hfK2zXY9J4eLFY8+0kzwZOpvDEUq3BZ7iJ1SHhHps2PPbRVJCMIQRbg k4HuNhDhIvkB60hzkfa9Q3PO3jod0H0NI5j1HCbpJUm0swrESa9RBzeh0KPhY+16T5HDhupwxubr 6vOnIVFb95oYOZ6mDNC1qA8BpQHD0UFGgf8bwXsMKzUOQ/jwCKrIY5iINu5aY0Lu7PT/CpiUPzN4 HOXWpPYLyNmEJUTmAdCAcRUBcOPNhoALNsU+MHZLk/NOJTFMNqaQ7fDKiV/uJN5aEJYWaCggoh3z EnHMogi5mUYSDLKxcKUCGoMRevUMUeFCNjfB67ZlQcpeDzuAaniATvqeR/DBzWBy2nFlhI5WGQhV FZHaGYUaGNJsxkIlKHiESjT/biOlqAONzknORjjjEvII9J7w8R7l+APXT1jg1BpTakZQZAZ9YpjT ftRA0E0CCgsSglhUNlGo0LFFlFiZDCZCpFkY1CwWYmhFSlUfWmyNpqGyVatWVcMSGipBWjBKxRJX QmAmkFkLGV3HP/u/JyQ7z54SiYPk2T0Ep9gxHEYLohiAf6n+v7h9jZiF98GfoPzoFDkbhaL7wz/N fVXnZf0sbmG3u2HrJepDiY0n6o9B+XrwcP1YPq+Kb04ieD4HCrT5X3qVic2iUfHw0k3ban4K2jb8 M92AcI3+43J1Gxm/fjIX4/F5eVJ/h0eIdPe5q7EUxhqlyeSOiSJfzj7mbd8ibhPtCCIhiGA2O8iO ow7NrzU1yVwK6kbUAb8t/wcuOGaB+4e73pVC1W3pT1Qw7J64zYqrDxqemo/mn4nKfuQmzq+A61C0 T1RKL/UV4UxZ5HlWH2KyLITFm0aUiVUYnQ8jiMO1R5k7Y8XeN0npWdEi+k5onnUbSR8BYkDe+bCY J8W7rzMSqm890r21qR1Y01td9p7dTonrTd5Q6FeKp5Q//h972uvarTGNKxTTq2Z+Q3k3VSfuj1ux FUlihLYwLnwOwQZ4v3MJgm5E1FwOQBDMUlZxO9Pq7/h6MSSKfA9E9MKkDQ2Tvkjr0k9u5w9qIPea fA247tnzHZVr51dDWpYFVD0qnJYkUe5MR8BFSNJumAvaGs8nMe+85+YZ/X+8cBOwI9srxImfuHHW hfpPOKD+v/SdhRs+nR2hf3xsumfKtcWi+m3E7XEx6tnySH4Z5OvCn6X+m/qfpbE/ZTix+Mx/6nmM H0CHayYmh/ihoX2j9ISfQYi+sNPu2MNvpkwj9BAftdLS0JtodpzhCZQ7UQYQZUjwAQfqcGJgiLQ3 DMSP4GYZOO9J0axEjSfvJ9IYYkbbq61wIWTYn4J4F368KrqrfbSn7G7dVJ885PiTG022v1unON6k dEN2R5EUYCQUPuKmg7TudkiGOY/pOT5hUHEDgZJSoyy6yS3VKhqsJMU5OQ3g2siyJSbGEwo6JWgQ +qOPt6AfsR+fblzHAVDk7EKK6mpMlSEwrcuAsoilhZK0iwaR7NldvTxwDx1eQ6UeGExQq97OfnxJ tESxYNxGIjlOqflROr0SsaUqqfgVKppUb8pJqPGn7u2OAbo7Pg6++h07CjuNuF7wkw2ITyrKEKSP 3U/XHwzh6OSborzvgPfiehDkn9FWy1yiv4e3xcPQb8JXvp/8KnNdhad2vk5k03zGQ5iQLA/OPD9y HI+FAbf3JSqTYtG70dk3EzOCQyZTdxV+JEEmADS48j/nAPeSkhA+uBy8hRK0AbnIl6inVX9B1VxP Nv82oLAsM1oHCHYsODUlYjSXdatWI3lG72E0hqSesNpCsOHKJhH4YfNfq/UwZVRPTwxwQ/EUVPZ1 OPMUCtwFEl/mwRh6BRVFHCJ7FEEmn3iN/VUQPYuQHKWnefZ05ncD0RcRHjhhJCRw3eo0fp7z3H1K Oy8OYF9aqP2fr+U7epA2fszDZps/p3kmq2/nm2j+c6A9BR5rCpKgj5dLmusP1I+Vik7KkYXeo4AG xt9iEeBx2HWbHRE6rbEkKiWRCdT+g7Qeie3p2WGQkZkbE7AsbAilFhRSpUWERUqN3OwcQXn6E4Ig 9yC9cv1wHPCuoF1KbjdGYJkRSF3c0IaP0aMbRIHiYg3hQbVJGvEl6yO8spUVUiPIlAQ5oXk0qHB4 xV1EsKFfUHZDlJm8crEen2Y1CtZ92rLJUoOo7Dm+VIbiMCAVvcPWLranLRsOwA1SKYMx+o5Ro4JM Wpj3uSnufpcp4DzHl16nYBqU1Iuzp90khljc7jZRHo5BwIkiR9GPPnle/YDJBPIU1PfXAe87ztM9 trlOf+6FSO5RX2rOp9or3ITEHCXMhvz3b0RgT2OcFnhGyR6HqwfHErw6UetI69PeamJ1d3UD7B2c F8bAh6FDqXuAfZ2CcLl5bzeol+7wYldUh2oj1WL6seCzsLMkTYcmxLZ7odB3uA4d6Ov1e9jrPowV xgPIQ+PmRfoKI/mQwK/vniEQ7h8ip/4jJ+Kfof59dramZrM2stUqHDorGsyR/M6DeofPP0a9T4jt /Vs+8KJ+ypaGsssb941iZEElhDKgMMjRbW3ipTKtzIU0yB87APTvNEGMN5PxzgxM5+kwYZubn8Rd CG06dDmAjsN0lPjNnJqQriOwpjZrNW8/Ie9XbfxvLM/I+8fuD2G/K5ZlmZjl2h0Hj0qp1KJ+fQjo 9Cn4WWfUaJqn8FbKlVBdbvFc2fobH5NSzrc5Pumet6XadiX7n4OJulkc0XsODrwIpkDk9wRiRpm3 4hH4OEGGuSbdIJMDQnmh9EL3bCb97REHSvm2B7Q+J19h6v9Fx9X9c3fLIczrUqWPgkHyrSz+l51N 1nXYK4JMfxVB2ym/Msjgj6H0uyOq1X8Ench71Q/pfoY2MaMUlKpWKnpRWzYpGkqtxwcoI0jA+dPz cR5q+YHfqI50co+VkfdDUhrrE+3xHJ5Yt00SuheiPBpDrBgvxGdVD9Q+KTsY+xvPjcTYi+6Pa7XP dpprTUqe6Do88DzRQ0+hIQ7OsxA8XvnuPflHUbdR3bHJY5HIx5HI5GjkXynN7f3TiUPzSKoZ7QxA PX5o8qzgh5wdT6BR0yoGkwsJHcnNk8fUJqJ0ieCPqkbQPUfd8Hq7oI37LT0K8DxaYdtaVKzGmmPH aK0U9qvMDECfDYdE6A5sobmyGy9Hv74NocHgjv/lqT8yR9W2xX9kfpianyTZUPlvtL8iTmk9j1x9 yal/WUSn0v0pwTJgoIg+mVoeqcgeGNt2wzS4J+Pxzqz9kzodMnK91IbFOv4HqR2vjh+B7Nm8klQR 8yWfOO6Hrdjl8NL8cw5ZqYZ8bEaY8IMIORFC1lhAlJ6jELkKiQlpGzA2SrmiS2wAZD/PK22xhUJ7 L4S7A8hWK6UjY8dk0EQxBYwGLBhLDASxO06nUBACLEIkSAqswKjhNosxzWIGnS5jGsCYHLS1mi7W vANg/yFXbuH7LUZvm6PjPcFSOPuPnCWju/sHbmJ0DlDQTFGZGEk661rvPTJGSSRZ+CftH2MR9+dr QfO2afh3+8n6pETvOyBrzp3Tbg5n8jsO5po+8TzJ2BziUHTsuEvk7J/pVDDaSSqoh4AXDHCPLcw+ LBTSKhG+ZwdsnsnOqvXSeLpzg6J22RobYHtCcbJKJJSh5OvNOcsN49QVHbhNx+9ziEeUnA7kiZqH eVu3yCOZTc8J3qpezGnFtNPF2Q7yuJJDowyHakK8iX8sB59lDskR8SQuvAu/3GCZpenDx8I5us7c JN3jOxuTvet1J0WyrehLPTzJ0dkhCeGyBNT0ybJDrOYOUTYOgdEe7fdgQHYCoO0sCWlcJ7T8AbIa BW+xCDoGEBpeOkZjmSYsLkTmVaZUJ1fsL9+KKQgxyVCXkEdDklvyEgxCVWlkcwkGQibBkRBORNhK BYOOYAvbs9ElGscassx2DACyJd0bG0kbZK2bIyBiOc1GENgIWbY2H4MfR+g/ePxNPw+BvH7EJT5Z TcuiWJYgQM2HcQfZ7zZ3h9Y7heeF2t9kpyTpGS9X/D/PdHBYdEWcnnf+LyfW+/6oftF9LL5z3+o3 DM53XvxT5uKOj5Dq2axw2WYWpso6Fifn/d3HHK2bPj4IXWxi5Qhs8u25mD/m/5+YxVpCFlAyDRsQ 0ko/Ww3PUMZ2OXa/J/AwZufT9eCkgQc9dLIQ86iGItoZMs/wmCjAWaXjySJkIR4KggQhndxaWtPF jjv8wak16RyHXwkSPB3jvbll/sS93e3dkkZI8CaExwjPob5cqrdnLQ5EB3RxocncLg1FGGrLgtvG DCarOWY4YuDCqMVnfyOK3X1eLkcnLOjkTEqRgxUtRKc5eGfCZIKhblEZPZmgDwwGz9jx4bf0U93V 2XrazH37h4WeNMsZUj/fv7HMzcpZrm9LcjuFehjFm4MTJgxWPS01BWKylpnmcNORw1qcax78589c bSG470ewk9ST0SSc5P0vO2HkjhD8qthun5SOUkOkTfJ52ONLT0zXXuhE3LIfP7PAkzrrQrqJZ5ca F07LD0fIxToeZGJ3wifeqYfgUrd0a/dVu6kcfZzTUhXLz9obPZYH7WFWyyseR7Dr0+xhRKXxPlx7 fxMQ+UNwHJUeiTyFkyCNUjbYe48Txr2SSDg6VekTNtD1kI4QeUgoSU6dGOkeIPocU2/OxwV6/1se VDlOTElVCyq/mVktdDtMqP73udjc8wvoA96HRKew9abBKj6EjmOG30E1InHlkm3Xg6E2V9XftXns OClWcHJO74ySuWliThu66k7E4SdzxYq/Gpi9FDQDhPMPDsNzb0mkQ07iqbEhz7gU2CAwC2FLX6l6 qnzJp2VdvOcjubHxJE1MQe9HmzeaT+bzm7Z7uMPWevT9qVDZ5ExMTExedDuI8hHivl2o0NjCvUmV D0p5I2jbTwTskifKL2EgETrqNCWpEeIPt+hXocwkcCpGV4xuS4Q6ibQ4hSPo95t39W8GWe86mtJz lvtZAQS7MxuRzjJeUfY7lDYJFL0MBEHpADMiIckD40vUs5AxIgLBQRv5efo1kzG7dCXqNwMN+ZFu K7KN14O/uHc0BzcebCbdtAUPXPlQ+0P8VxR/D7T9RiaoPD8Xh/N7TdJjel29YWOvWL+zG+zaOyJr UMr+gVqXlOv7a2XV02gsSbwb/zljoyMcg8XAVFZn9H8vvwttjREYu7XTq97NUVMnWnDAZYmiIGgD bl2nK1rbNn81hgDO56ElyJQlLg/kHAA41mHj43FH82p3PlJETzSnnhD3JX0J+1/S9G2EsipiKkvo MB4hNPMMhcPVrj+FX3oGdQzJl+hVVWBglGaYYnb57Y9xPAeKCaSXSu768OaG56+TsptTAh1oX2ix 5oPIvoDoD3PVfJ5FN68FKVp8USfkAPmA7zxDyFnuZTwOagdAdAcwsFZFc38yVn5qZqp03/MJ6p1O j94wv2jIz8boufzxQqOlS/u/fB/AaWiuMg+2bAf7Rl4AuRutjYHEJiJMVZUgwCHjWIdeLB0+Ju7f r7e87gltcC4gyEt8dj5aQKOj8T1j1WOGYBYYag4BegUAYfSIH3nf5+LlmT238o8bxwfyAckRFHoH yoI5+ZBfkYppG04K+JUPGMcD2BMxZjiZJDJIWhDyYNoHsj2HdLieZ04m0pHyfyd5vDxIO5Ha8f2R hIO9OorzWQi2DtWJJQWQiHnHydYgN1NgTeFxICZVn7RkySVuPGJoO7zfuejY5MMEejt0CxOgESjk EIyKQEMSGCOOIjOaxU5IhnMOlebtJupU50ehOtZRgA+RTrUJB5UDAMIiJqBVMEkEcemSzvB4pcPB z6ZJNp8GviTyR3TkjP39XV3Tz/DNIkyokeKxJ617fv5D5DUYHx3nCpDiEzv8x60yYLhjO2+Wx3zt 2RymyOx80j3idR56YT0u6R2fVOxpKY/YeZ13SsJ2+KRPI7J0Ru7vA/IeYwe7ynItcUxr4dLqc2Zw nDd6ledWJWmySQV6NBxHZ2eROwQByXDETQ9q4Cgm6/EpgoGbJPChpXOtjyQYHcIDmydkbuob8JzH EmhE5sbIw1HYskNOpMkJk4YODmNtE74x2+mtQn6vfgf1URN7/w+fP7Pz61Pl/6ZJJ95Q+VYOyiT7 qlUKWSOVDKif4X+R+r9MT9Y+fB/iHhcR+vFP6SB7ewwH9C/D74H0PtEL+LAFwhEpU4hHBn78Pxy6 dYDgbQetADjsvsExf4ThCmEn2BssbmA2VZV9eCAmz9InvR6F96pyZNyAu4+9OokqcfKyI+58f523 SDo69RCerzPD9EkrKlX95tqtn5AQHmD56sDDCp7vLXp3SoOxmDhmAdvJU+Kh+k64fwUPmzQvjccl kHnjyYlkj2J+k6nl38x/QTabkUDAd4cxib2B8Ee937CdCfaQ4KH1QmLDA70fScTgJ6o2Z5A/qN4q B61Q43E93kvXz3VDM7kD78/FCOSXUeSnwnM1oPQiw5mUP9UU/HUr8T+RVi/DGz/ZPIiuVORO/0Id CNJBJKIOsA9GQIYzvX2OQ7uFNcl8lK8yDfaIknDlB7J2SRIdCkvxKCKMvH3wf04a2O/o+Z5x+UOg 3YPOr0cg3DdoT5Ywj5mHuYa1PfB7COwICE7GIqWTooMOv2TZIdHTY+P5z3fu9x8zy5iIZAmbCXuQ Of/Q4hQlR/c2OHhiyHlUR63qHAUO70n2GkfQHuqh6/afERp0Q55s2Nn2PmcU7VyBRbfBduXmaexh 4RsREPBQiBRJapQJGHvHmp+AJ7SO8kH86HF3g/bejy/sHAPCCJU/FKIbSp5YB8L+sv+QSnvLT3wr kBjD7WSyy1Z+DTWK/gn4PV9aYqqWeprDRRnTDm8d3z2cT3scqJnJkcjHNsfBsxNx0vC26LCywWxn KwjfzlzgjFIjFTcxenJvccts0m5pHqUfSs32Mtm6WKxk5Jt9K263Tdhu/hJ+0+XnycPHkx9pilY/ POsH+/XJcuL570ui/fTKzvnJNK+WVJ1+zHQj38NF1tpBDuNIvCynqgKR5QvTn5BoT6lTFVjIKkX1 rJNQU0oM5ptK/u2VH96Gwnw+gghheQnSU74mA9rVdrBonoHo4iml3SpZBreNGhVtI7GlA38gfSe4 JhrtcMMnJvRH9lq2rLHpZi2Qb4xLRPO5D4QkA/ECPWFEUxH39n/IoxfqtU/K2wuY+72aByQRGREB M9zXmaW0RDDUh+CGzPJtsbD4AdH3pJ7kJ94sZCbxG2hIe2BzBs8FwBOt/MxTrBZQbxvkhjs9j+Un 7BtYP7h1qHPdN/g2U/Q+hRN9VBKwPCn+yTsdjDJ+Vo0l/z+p8j5v1DRG/4Oif6OgweAGOrJ9q5A0 P0GbaPzuIOiSuYYYP7Jck6AQkMJhDAzf3GGNBClKp0OatSf+Z3sdGwOxvHyJZEHCeooELhRAJyUr AWo7krCKAQ/6eGaZkEqiJC/9zzfUOif97D2kgf+jD8K+gb712Gf7d/8P9btz2n2fCdNjcu9VY/j/ x8A2AJyjBHY0aj0c76F/0/P9wleK1CUvQZUNH+I4tUtP+SUIhZhAKgfbH9U6pAViWCpUcjwCncpZ Vvuy9DoIiilQkUM8nUon3fkVQo/MTWbR6jH/IoCKLxE6/u07YCFYf/oU7QeqEGgUQvwqKnwf3EY3 DNGkan8v4t833t3ZuBVVT72MSqlUVttpxBaxMH0vvbNDTTTTSaabubcGzkpiiweUqSwERLKL1ITY gMJTTyNnJjY2ROFTdjIhvt2pTrduMiRVMUPTuH+HMmz51k2fZhh2Tp/6dmd9bFvDyNRiGR0XEJFP m9/vPVl/2+zgPA7ATtznKTvfdy2fq8snNTkpLLG2ae57FT97Q00P0O18g+pH5ZSdFc0lg/le98Dd HsOBxJGo/tmB/n69GiaSf5LUw830oqVKlRykfC+N5Tzjuf5TJx3vXImFGK/4o9LbY2Ot+UNjA9r2 Mj+T8V7e+5fJEffg8Y0kf8zMUqqq1Y7FPp58uwfhJJ8bzdNkR8XsgzoU9CVS+NrzbMp8AuADP7Rc r/8MILb/q23PhjaO4+bMNsFMIiGIYiIXCVwPMDKURGj1wVGVyC0z/hkxn/5H98XwH07B1PD/qTKx TcBENK0pdUxES8mFwyh/7TQ3khv8H4+uwOzeTFwl7HH4w7R6OjlAG5BSHCpp9s3yvvkzJu3FU4mV Kwx+U08xX5m+K4cvj/oY2m/bSYavM2O83dWmOxTgvoNNTz/U1G9YraPCo/kc2FS8SsMnNxGzSre2 K+yKa2Yk4WJq4zrWo7VjFtSTZ+hh/TCb++uEcKE+mkf+MCju1H+cJ7hKnItrIYISgEjlYYS2NsQk /SUFSz+o8/UP2I99Mjd/SfY/IPjNnrVT5DY/1HoO/dPkfxOb8RQpKRxJ5Dd+NzJ1J0cik5mxonNP 8hR3HBP7jpycr+PzNHXZEx/7o4w6tkwaUZP+5n6xWiyFKkfWRk6tOBoP+poc967nloiO79c9afge Ll5TrHKqVH6l7yYR13Ntl3qfspOiqxsjhT9jjkmkyQtEqz8+M51I52aZif3j78iaJTaUY3J9iKnm 3V9T0k3G3VfhPef+af602h877ij2NPwDZXfJ3+LdixsrhhqQ9KStof/hyMSNFIxPFNGsH/cbQ8D/ 7HqdHNvOolkUZEnOk/OVN5rGp1WfNYmzY/oc3sahPoPlT6k+Y4dieZXg5MH0qeFdx9BzO1RoBhg7 9x4eY5GlIF40ZteZ8v2LD1+DkcqqqzVP+j3J5jmLQcZkJdfYIjhEviFRnELxOAOcnOSD+7MO7JmA 4rpXrGFRRTmB6Trcfs7T8PzpTimzzSs5J/9qRknRFSodcmY9R/A5SKeUYY/aH5ZK4P4JqUFt/6vQ ciifbsKkq48vkDdMQT+qh4cTtvPy7QGQOjT9AvJcPO33HSHpzzH7p9ANsbTP79zkVZIp88I/9rne OdCn859bEIIvu/d+v/Xdr5qSZ3FRygV9EIH+hea/HnJ/7XrNHBHSOQr4nuF1lAxzkJkTylJ+J+zo pHh+ntBlDlNGkva4ddCjgOIEks6CIdBrPAnm2FR0nnBQUU/uCgMof7VQYiVBtznq4Ev7zZjImekY /b2J1mesOoUKxT/YKJyCuvDDstBf9TQZZsszZ43R/3Oj4lsDrF+kL4voL8NzbjwFJnlPnbyX3bFp uOY2H/UoNY8j/7dNO7zFRUVFBmRRwxUcArM7y07z1DHgSLjqXaPOn+/1FBrNAkjy1nJVZoMB1BE0 iknyDLhrPEzaAiERgcchWVJ6PApF+nNu+VecPgZmS4gVgAjCooqKKIiiiJiVaVMgVygulfscmI8t OUTkctJUUVm7t6ta+aX7ddJYGqeEkN4oaSQFQ4xUoFBSBx0cIOWmttMwf/6gm6JIzzKdc9Q+k0De ZOXu5HnR/0To7QfWW95RCjyVEB5zmwcWjwGBRSqzxCgxPMKRHih53DEbPQWzr+qmZCt2dTS4pdAx oJiSgfbhgYBFwth7X4EfF92n7IyQ/a+xf+H6nY4Dw6tAUC/rBN5MRyfv6P2NRtH9HzOz6vl7c47r IdquCo7ChWKgn0qCeSo9wqHtFUO49Tt6fp8/wOckJ0xKEpgPHo/y/2mfYROdUkj6RSkPSH2eg5bj bWe6qgGSkmKKSPQcSwNJoD3VI4mKSJDhLzACIoUieaPqdA+i2q0HqMZSWo1jz2/K2724K5KWcvAv hqBaUuzOFHG6Lxw1ZYb3ZmUYNx8Cg8xV7SoU9XuYmPPUPFX1EHGoFHGccSge4qKUkdkTeUHIUCbJ zPaWxkW1i21EGLR5P2q+17Vlh/6ilxzk5usrnaQILN8P+VRWf+oRKy8kf7ydh7a+N5eWj1rLTOQF eV0sa8xkUwIDcvEjAqN5UahwxYU9hSeo+sPqGLY9UkOQWgdvvXQv0k5nTQUqhanbF778EVH6h3wY HFegiYD/oKCmk0m4hALRTDX8nbRD2ajsLId1H2Lf50PQCrsNI1PjejqhqCaaprBOg7TtC85RPUew pKuzdVb7+j0Fwehp5LoppOQ+MjyMD+ifOaTSOHoczDyAWDj5GlZCqTPy7xuVBMFBD+Qfc4cGzaIv 1fyNpPPJ435fL+Sbj0qn9KtKMg/LSFfm8zkzCoAkB6Zzp+BacgMXyPybUujDL0r6lVczW/cm8l5F 7Z3R4x/2A9h8YTz9x4heMnyEa/9gp9JwFDMljCRd94OAYsNJ7TAoFTUUhWlQwnEYmM/jYxJ+FjxH 7eDrK73fjtV9sehknr6N81XbSkHeCFGyfcURD4V/W0gowKMNQTztifXY6D0TsctlxsyTqbNR4jqd yo2dj+t+5/BSuHoPYckjm5v7HDR/qFNhueB3nrJJ7z1Spj5djZKsf/q9X/X9nN1UnZIdSH6mf1v9 kwT/ipNx/wLJMbq2N8k/Sm6SMG6pg8zCtHOzUhzIrLEYqkbsbLNrJhUf8eZyO8+epZU+e+EoH80P xPTw+rZB2Og1BvdF/1je4/UHryBDoySouURDOHtGPpUkDaAclXKqqKvTaoxny7/iP2JFU8WhvHk+ A+1tD2a80gmGDFFQX0Cv8op/CD5yPrD08/5OmxowKbRlZwYY2WEFFNp/l1+cOzs+s7vIH6UNifiN jg75s3XfHsj5XiaJYjjoa5DwO5Ok6pbZKr+unGfC/e/tHaG6pHKdvhGPKWVNRzB6o5GSJoxTmc5E m5/K5+P9DubC7S4NK20jYKk6bt2O+Y008nnsLZbSrJP89SDkEx2CbSkKKh7XmN5ynZJzcJI9I6Ti l3ePWSMDSNIpMjuk5OT9z+loxjk2bFbNmmxDDDDDD9MIaMKaGUZCkR5l2cUa3BRLJ5NKrwbT2tcd s5O5Sq8+FskYqoIheo7kjo0Dz8x7rFguyfutoOI824xsxjGMYxbAP5qJHZO39Kj04R1G2pm1yCBN kD2Aga27/XOgodj6uGaRN1GxnQOiiseevNNkeIc09cip0QPrPBgdx4NkzURDvjB2VZfaqWFTaQKb Rz39zumn/6Wr4vh73gvIc4Ow5SN50HeqPQ8bJI4iTRPIPApO5CEQ7KbE7e6O+g4CQevNwklDkhWd WSceQnaTsTyO2HX/BbKttv4Una2KrwYMVVVUnV4adPV9zbZttmx1E2nJEpv5ngPI8LVs44Tzerz8 qVO5VzzSHbjCnLlLInEhp6IngfCjsYUqkhhiBiIIIgXrHi8HZ4GWM5QhrPKXCGogJJEUtR9uDnD1 tuaKVcBbp20letdcYdLrnSnl9qBxyHuZq34qz1AwzMUM2mpGH+XslMjPCaHdJ/CEMHJbB65MHsN2 gDyH2aXa7qvaO76h707d/FnDoEdSE153DkG95zkcK5LnGFaKnRpt5YyoyTps7jz+edsfYEo6pSil UVKVRUpVRIYIgOpwZOZHmHrPUIRD80PrcaPNphuROJ7zmnnf5XsNPTJHRPbHpieBdhwX0C+n4ua8 kkU6HnPAHz51xyVgDyhO2CI7B7Onsm0HnDsGTZJ3ubY8E2nmmZysXNnIe2Qd6TDum6J2nYfF8BdN yh0azkAW1GIuZRReX/WcgiIq18Px+nD6ZKVSkpRSkpSlSvrVilYKxiKyFfxq/zf+7Gym7H9r9bR+ 9phu02bP+DZuV0aYxSk/+T/2H/ocnabmMR0YxydDTR1fmacK4bgoMgl0OpwYM5r/QigbmwzRSQ/3 HCxKlJVbI2aLDUMYxWzWNMKwYxikpW6sN1YnQrtbJsOGimym7h2uRs4K4VXJUYqbK1WllUaY0w0m lTTSn/6uydkxu5uHMIQ5lOgf3lMMDoQ6BuQpCFKYHAsFhDAZQqImGiiwYyxjIQYyG0U4aNmjFY0b GjTZoYbFThZS6bRRMcNMOGzHBjg3YYwrYYwZ1MKFMKKHIxRLFgUIQSwqxqRU2YrmrZyK3mzZpNjD c0bpMaKjmbNymlVG6t1bmzZNo2VRGm7hs04THCDScZoMkmSO53CSCjJgbE0UUEBJIhCAyOWeSzgc wYG4MmDIjJoyIIKKHAQ0mCyySA5qmIrRpgrTFMMGMYYK6vJsc03dFc3NhzUViUnCMVpNJ2sTTq5u Fc27GzZpORwxJphhpJg2bKNFhg2GTJk7mDAYMBg7lhZZQcOiuSsbGjZGzDdsbJujdW83bmzGFdrF cNk2abK2bHgrbgpw4YZsaFhhSmGGFIQ3Ngw2CKhRgwqmyrdGYt7lhVbiqxhiMV/5tMRWntntSRPe j73rVKp80/Eh9XGH1/O0+67srJlq/aPufaaPypdbIn2j63zPtKp3SOzizvn9qqV1JynNIHa6dpu6 i8nhVpVLT8GuRe373c+5XnQqOrzuObzW42DQ8nzRFBUfHNjyq8HRBBmQRRIH1fzjTS0x+BPMD2PI XyH3xdh0HHRd0Gmjp2Au0DtWAOfihRWg6NUJLFXj8Z5wXzvbsvM7Q0e/sczeCiHZ9ZdirFdqd52K xkif3qG1cnWYbo21yh2tIep+lHNHelVHok5K8zwjs3HP4hh1GLg2Yigbc8EnyS9G/Cqto2WPdJQE EovaREREEMQxBEQSywMQGCwELImEkVAxKBDQOjYVe10WvUcj3zcxSbOI5p5ad6u5Qk8BWmldpAqy SeGDZ0OJRJsTmeKq3/QTuRzO1XE6Ic5H/Olup1OJIebwfGnomHmcNyqUTnId7iB8/P5J5JJOonHa GGJJ0OxSR5g2V6xZNyRw9Ph2duBRkZ53QPAV5tefqXY3Kk+zWbkC9hHedh1YFhYQnEF2nmTZ4xDy St93jGPJ7F2HRHOx7lkdXKqPRenWSM3LYRiShnD1t5Ox1OUSQkLkiAbqdF4xHggPOI8A6nLpV+q2 8MyIw0kO9OW3ZL21n8XwOkg0m3n77i1cHIn9CandHvR7XjXbAfHFhm7AakMHxU3dxnrENckRRAiB SmhKMyW6gREknV8/5T/jTg2wYeZL/DC22mG6/ceO8bOCr9ajHysbOT+fSpwafdue/P/C5zPxnumj fgPY+rvA6oZ66XZlcD+fTsbKp9R9ZmmTeRY4OIY4YMp/2Jx4fcEnIKQ0AYH4crTR0CTCiVtrP0LW zD/aOeHG0iWpFqHwI/57O98USPrfo86y8LORwG8Of3pXCHNuT8bE3VaVZb+gH5UHXg/X3frvs0us jVtaXs5o7z/OTsHTtQlElQztXwLZVlXDGNg8WrYVy/3NkPpknmVKsrhO2TzQ3c5V4EO4O3TsR8/L lGo/votegk6onckdZ4f0tE4DmmSdtZJYdZ3pujd298jE2kn+Q5jynRDvlHjO9RSXyHA9PHYyNacN EacjsAiHwIilFkWSUpKlf74Ctzd4ujk2d+GJps3abFaVpTZW7o0/5K5JpWKrGN1Yxs0qtmzFVjGM VjSjDTCYkUVJVIcMTEVUsWLKKUUVCqCrIiqNEVhKGzBkqJUxu2VyVslOQxw3YxWOFcOBybyphyGy KxDYRIgiMRHYO15x0EESsBsrKn/USh39kNIiTqlRCm8cE8Uzx7HcS0KpP+bg8qZO1yVlVoxsxeZH ftEhbsqepMQ1I7k2JCdTZiZCrKtWoFKGCpJqNEmJIlNHpGinmWqgtLSqklsQ5nKemHJzn7U7jicS eFjhBkh1eqSDjpbVrQ7Rz9T/x9bMeWehwmJjErKu6bHljTdG8VkTTZjSbGdJEOhUvCNzltDg9cpx ElFJ5lETvfeZE0skoqCdvjzZMalM8Wq2bOxvvukabbtKOhGJGo0wVSlFVKpSm8R1iSxDwcI8LJVk 9adExsbsWPgj8vx/7F2mN2PprHzV/4poSeajtHmHH4ACfeG9lKUcJiHqE5mD4odUIjeTlVpoj0pE N02FVW6DmLBRZKno3W2240jNUajZQiZIeeHvn+q27e2xwhwpkr2QjyjvGpu75ke1TnXNDuklWKSy ipQ3Kk8zTE3FGxpSsNlKUpSUoKUiaPAY3NMKrdW7DEm5Sm5iabq5sUrGMSpWMYrFKYZJVKjEUYTB MgmIxhIyKmFYYYiEaSR9bmk2kmkYbYy8phzTkhvPP7jdWi5OKNGlszvOaehuwfDCcz0ySN3kVVFK RVKqVSlRVRVVK7XoOSc1nc7nEkrJh2LObtSfIczhYqviHpkjQSzq4TtO2Nlh1i8DtcmfITeVa/G9 A9CxQMREeYPR6q7OnmOBTFA0Z+sDkbAC88qCKqKiYiIgii7QU/zEXFYiADhPOPoTQHQe96d15+o/ LUPRGzCKFimQmIUVagwUaupWtQ5CalNQUFGS6jU5bApmGB0nSJMblkJyDSB2kbCRKR+z54cegd49 siax5nz/LPaTyqOxycQMY+l3Ix72PgWk16yqWaiR/UpGpIdxsh5h58LVk+JOyD4XcDzGkU4Doi/W fY7ExjwJsndBznE5JAaSE97uPUd3NwnggcqOjwkSNBOvXod42CuTg6FbdpK7SDISlEzmxLBE8aba ZQ0qSqT1M4dgmN9ZmL1zT4jeZRp2zN6IMisxKSmggwwzMcrDMasydCfBGcVPGWesI7ByniiOGnvT oOqT4OnblkszMON07CPFPDYcIae2c48ich1nQOx0LZJEWrCkNhImoh3k0VU6ExPCd7qmsdLl1dK0 rRjhmYkFZiGLCVWZnzJzJ6ZEm871UKWUnwaHKvMqlSTaqoIlDAjUtOpIjvHCEiAHFQ+Xlw7UxEk/ 3oruiTvo+ROyOxHOzHgoVUeLr63j0jQ1BNaOHhYqy8OVeY6cOUknCTkJCqQiyIwwBxI3clVVY+Lr a5nI9vgt5klR0dFUxy6Q9XAs0srHf83o/pObvm8iTgHchrSel73cO8k2SkhUc+dtmRco85Y1FGsM nREOwQxBRVFMUFiSqUop0J2JU9qROSckSeiaa0vmh/5+gjSdpQ4SYjFUpSqVVKRyR2w9KagLV2SR O2RJ2DvmOZ7Xic3gquqpMeStNImpIklMaYQ0MaVoYxUpVkhZElaakY0rCNSFZJ2g8Eeg7GylPJIj ExVJUopjDc+FXJDaZ3O8VrC4vA1u8pudhKpSShU+FOQ9kaeZJx0R6VSqjfzt0eHEy1ZbmTuCxx/N vIHmNnUS2IpSRbJJYqFKVKklFFbzwT0yBsWSSVFHc675yYb3s9ebzdhZQtyKMksQHWEMaKwgw1qM 0nTroQ7uoVK+CSfEG5wNweUkJmiaCUks0kcomDcRgoO621I4jsSTYd9nKFPgLN+O6+Dq8GPDUuQi 1akp3wdtRVXeCnWQRCQQwQsQ1KRRUiqkjwPLtx7EwsdodxuG3JSlk3STYdDgJ60qxViBEqRCgdw+ AQctkKEGIVj2xe/JJHgjNO1weaHficg7XaiFGm4UMdYWdR+/+aIhpUQcsq2Qi8gcDqLfGmdG1hhU E2Ksx008tRFNEGdgzOY/kKk/9pXtIEBhYC2kg+QpwclBhTVAZogeOTQz0nSVvvehqgmS+QQM56z3 g8NUmxpGPvBkfDqEWBaJWlHvPrcHDduxyf8BQx/1cbuNmdf/h47Pm+GSChqc9gsEeNA5gwQOa/dG kaDhndMx8h8Pz/MjzpyclyfGr/0MMJ2sJ+lonxmxsWbqrI2UVkqWphyh8Bur7Xc3EPoIIeRlxmBM xonJqq7DFecpVDezZ8etI1Jal9C+XDcWclK06BcBMBiZZ+H6It+R/hEoNdzbYh8I3hcMffjJFjku 2l4Y3bRGLEu64kf1QKiImoRREcp3C2eC5+jA/vFOU7lK7gsIgpES0jvx61YriyR/0F0+ZPmamoq1 RKsT35dgleZsddGf8JMUDoNGJlhYvogCh2HtOi+j7Pivvmg4WaMKmWJjUOhBItF0MlS8A0GAsori TS9xAiyLd/EYEE+5gu8rr2HZp3dnqacJVpNiE0Mo0UkcaXIWyLMYaWDFOmpkmpsZEiGlGBwkyV3W QpsQiH8YRqkhwomKHUrdYRqyOW+vwc/wb+H8Tjobc3Keps+ZUetXqc0crzlVUqwSMIYG91HeE3LM Nx13AwxhMzNr0SvHfOMBjYuxMkopwv6D4f8G4I3WJH5hh9SP9vrPc/w38X9/4PmXr4fV4FyJkiAf ro9NTqrrn6UREEk73331oNhFiM4+sCQFqAlVlmFNlf014YUD5UcLtB3In14BSaYB1Ahxcnu01GCi PMr3589c4yNWOUZ56Y5zwCEoLog6VmmSkNt2vTv1x22oHeGdK7gauPHbqu2+3P6wPovr94hhgShz A5FRVERMHD0BREYwXMWtfhU92V1j7sMssouqqpoyh6REW+/Y6E1a2N9ZpudO9sFp6kRWpjdKt8KX Y49BeqoJq0nS94ghvFUVAU7Db8Dgmf5GiRA8p8w4U+dNt/4f35aQJO4KHagZhsMZNIYMYwVVVzM5 Bw+CgX/xwQRPnUEenHfhs2P47eV3Pzb3v+nahkbrijk5eXmpqwwufj293TFfQJ3+JRVDYeQ7/Rne MMI48wxtI+sgmzxaIXKaKQ8TqKbmxKip7rGRFoYPQGGCLPlgzIw0sLokpvHaNnlgZJwBwFMEEpER EQaV9+2FPfy0vF4nVzI2jdTZBiyI0yGIkcjhDEm9Vu2bqSpSqhsTGyXT2JTEZKrLD5XaE+Cwbu0k iIAh4KgKoB1J+1PqSX9/BqWefItOvn5obKrCpRe+8SB+xU2hO9WH7x5A4F+z/Kqqqqq3BwD8jLx2 h0IQwQSp/oEoO8VOpzTI6WE4UnJwUxuosVufW7GOGxuhRySw6Hy7NpHvWdl0tsUq/c5846JkPxU7 vW4FSELBmYMfMWo0MylBEwQkh8bKQm2oMlbPn9ynzFj3V/lUWvquG6bK1EqR9AfN/TB9ucgkoI3Q 2UN0XiWYFV7E7+v39Kh95NHZYMbHiM5mydiFQj+IwRwRTZFcb5xUj0PU+3HxPYyzHy/9Ld9xPC/T Y8n6vHJ8qoeaA4/lPKXlEKBIa/mJkzFCFD50wZoPbinUXcxKBGLAzbkyTecVIRdRGSed0+L3apgR 3TWA0aMyiBMhgsSMxMJgpU8N+tvj9vu+P331fly/Vv6FecCFgZlVgKlol8Ef0UW+6u/SQz7Plf5f M+befdtWZeGx9koEq/DNvl0EU3+WkbyJ84eP24MBpB+No2nr936eIbn2sQyPSUmOTJivzeWMst0p 3b2b6/imYTjgYc58x80+T3wh22KUlmKGFgkgooJWiAmEqhqIJRpVCIAmECJKappfmDw9WtgoISR+ AcR5znH0n/Df+3n+Hp/2HPXJNaVAwiB0F9mv5fPB2RF938figyIhwDj4V3d1tfes/n+n73jz3OW6 eyVPm16H0wIfEKjhJEkQSiwkS2FsCVRIMidXD5RU/biFjmAcGa/ObGB8M7MkhTE6I3Ygwue7IDYM KNIoAk03uflWtSKEdeaHESSfAk5ppA6k27NpE4bpSqgrQCESJTEirDLNDBIohyflae0+dy956z/V U/2/Bkn6f6pBhHfLI7JbCjkSilqr4dFTkVVG60yFxeTQfMyroANeczSByhxFizFE2NboqMWt3SP/ X/RVt8Y8VPwvyn6FbFYM2jYxNmw/zTQpSqqoH7UY0z9Y6EPrDgHAOoVT6kUbxQh4zyYRaOzBTCRo PUQuwSkxJM3o/wMB0Q7kUYEnfBgFAykJTFQXRjYkiHCH9LHqI9rq0j8BAjWlakLHzGksbFO+SS82 k3bnw7crYl0zVDitaCKKEUGYlpZlKwONakkzBZmqdot0UfyOQbMIcMEDj5bJZm4tNRiBu7kYHDo4 Iejp5JVMEZPKNHLPi6HNt3GOOro35yYqJv1mE6kphODlujabLNyCvKfzO/obL5sZyTFhzk79vXHv 9OIYPAif9SYhDs9gePXw7cLMsDGcQTFEoztKoxnxHVHYLsIQSJqpyEMmjZQyockE7s6EHju4Skjy gx9oRBgyuNsdgo5bY6JtsMbQRhmFLMs0Y4ONmQPUmPNy22Nyor3JROsHPcx22xR0HCxgoHMQPqBw RHQGyy9rFAZLEuKshhQBK6ECoIlRUWC2LFFsnhGJl7GYI/0naMcx4fnm85XkOUwSwy0xVAXErksH uyUER3+Qj4BE7BUMNH2CpuqfVzOwkjr6fYeq7xo2cs06ODcIliNyNGNm0woxoGk4LG7FoejREaIe PZM2Js+fs25xf2MAew/o1arLMqgwiMMMFD3dvb7ZJJtP+1kncsex7bnxIPnYJ/Gek9yHoOnir5iH 4d1gaKGKAlaE5dhhqWkTdYmduXCn6tl5QalO/jmAczYbn1JjZ+c9RaNobN5j/fbbb9n8l+C7X78N t845Sj0VEzVajMPl8znJeQEgt3G+qkGHxDCq7Yl0F3RYU7jjfJ/8YHrSdO5H5DG9J06owrbhwBOt +zxB277q1nap62VUf+MiKSyUAJj+IRgMhDFQiFHpJcmCDaUMgA6wKmoclUyFYlRiEpUVYJaGqRix EKKkI/NZJEbVCEqOXXrepq40PM2/inJvZymR9ZT6xHdUd05I4Q73D4OUY/AtpT664TSlmtjG03fL caNl99xSyQ5FTapqRbiybWDVK34xGiPz5wouovvtUDIIiGhGNIomFFU4EBi7RidOHXTYFNQ6w56A /Z8tK9E/EnJF4Dsejl26HcM8y85yB1b7jD5IH06z40ThCnEo8CSiYSJvJko7SCxKtG8oYULARDMC xOwy+MobShrNg1EKxNIdWJwtFCBHfxRz7fIHMNkO98qFElEshYcG6v7oAKLSqthFpLULYtBJ4HN6 uDhVRHrk82o7M5knOjiH/HwcHc5RN34TkPi6DTn+l2OiQ8z4L8U+rWnR6UcA9NtKsjY9lep5Icok 15pGMP61PbT4nz9fieRGWlTSCmDfD8hirHiR50tjKbEThB3B3B7RA6OXbhjElC4yHsntJDco9RA5 ta/BkZdqOYEg88fQLk4oGoC1EP8rbhXIvj7KEuRAgo1/f3JQVP3Tl6QwMGLqfjGfa04JN3M5GrVX 80hZGo2hPn7WPO6zio5j7NJac06w0yIxPMCJT0xNEfAe93XsbJNn6WRIhsdr7DNWUv6WETT2FGDh wftxWifoIME0W6ODgIjXEu8MLpQCB8hbQ6NjlAaiLRZGFDEsQMMqBERsDGBAVibNiO0nvqNQsSG0 YyxyxGJKJhKB79CHF7gkR/h5NaRRaE8HiHUlQsP2FiVUYRwSnyMUqlRARBAEQpEgDBKrMPUMfiWN Ij8xjERNLut+HZEOSNROsTvRPo9/vehoyYlPez66m1o3ySIHpkPnnr5OI5nGOyyUlr92SQZG7bI1 UWcMxXRC4SlCB6SRUx7SQMkOE1gAcK7QiKdxKKD/Ie3oO7yP7yRF69+x6PLrRrRqopaDzhotaaCq +uG1uN6/Z04HBV/lH+QOQPAVfAej4tzu1W3562d2rN2sR/EE4kIcH+B/HnG1AYYHxcdfi2eVq1OO WUEM8mZ3+HsM09jvkVbE5FJMlGpcmiNyMCoJ5nLRzus6tT7OY12P6Jf5FF/YSp8AB90qDMCUqH46 2gO4RDreA/SB/v+ZN17+zxd3aRrY/Zl9ebf0FjWr1Fke9D9AFDSQp8ppPYREOgb8L3nFDyh2Yzgk HknB8p7wJCphISCIJklC2WqZGiWgSSaFP5cMWn6D+sJFLvBe8JiGWI1Yn6/iMG1gFSrZCVRVkxKQ VQjvPGq3PQ1NrGpU+FvnjG4oImmUdbTSiYwjZGKBqyhJaGoCnUIxmEkZFV4RkhQGggMTIwzDBcIW kGIHJ2MdzFxNl2PgsSQQGEHsIPjxHyIoJiODhy060B2koOWgkMJXGDLadATouMtsIwY1dScsmEh1 Y3yViU5JiihpPg38DFfjzYRAO045d6pqVJ8pdDcR6eYIIgCZKUYgJllKgYiChoIGoUOCF3PoIIqC hPhkH2B74H5f9G2Wt8wPn+7o7HqUSrhiejtmzaT47JyV+Z9rCefyORYqqWvNJH7QjE1tmDTaAwzS n1o4mwpDYdg3khHKfX6k8Lrdg6aYSYRVilVrTEaIooZmrFVlWyuMTA5hibkrKymmBKauDFTiANA9 kjgQSDEroncsYTREElDUBC7EYpVQpEgpgG5g7rYbmQROEhwBHqRQ+OWSKFSJiVqJRKEZGVChQ509 fnfL0YHfrTnAJzTtj82YdsRmEEsweclDUjVMLYqHw+Vb3lNMSZPgeMzNbE3OZEKMWr7sCm5NGwx3 BuQ+Uz6B16WxovG+c9jcRsMNghU9FCCg40RwpCxqMgWYKrZiOQyGzkfmatkYdOeGJQTBGPcJEMNC UiwNcIoQYqLEQEqJjMbFGiNRhR3YheQci6YbGZTQuC2GqbG0EwYwMkhMSXkCxMA5gUYUwWO76Mr0 V11LcTBeXv+5IOQhdwCF87RHioyoSqtELYBHon8O6Jzmwo9aqnAlRSIggUISGCGFWJFFimPn38b3 PGNaq52+DJqqGEfKjSh34bpBmgYnSLYqmjn96mNaR/3OGxf5qlF7bBqTh9NIacVAk2npFkwDI2zm 9GIgDDfiaeMetypGZEJ03FlSeGVIYwFu9xAtrmwxaVZI3sSDNLyBTNjZAhLcC7FSSW4wX+oWSglF 2M6dYIwbEjRzKqdQpyGPzQUXVkW/AcCdMxQqViU5xgMAsiakHKZEFRCshaaDDMmSop6zIYsSCIOL 3kyColRSIhQA0CSwp/IHX0+k9qAp60DpJ5vMo6kSIQ+WZYfDl4w+U7NAX94YH2mh90+/NtRNkP6W E0+6u/dJNu3/c/lNQfldj+t+VXcbt3wPHyYsid1EfAsRpGUBiKkMf03ScpH3lT11scfEj7Ju1N23 +ERgf0Mj8f9p3D7n5wj54cvoMsObMlITSSIGoTvGNtIZ+J1HUZo1AUsQn5EuMYnppGWJkWjGksow dB4PFUmvvw1up+GMj7rDlucmWWryYk1VrUUqiqR+z1/3/oel6vMR1/J+Rb/dYvoMJ/3KEyoDCOC4 Jo2wNBKJ85AL+Afi3/xbMrkVMuVKU/rjGQ3j/R6tI2pEUUEEQ61BhOqgteTFD6TK2sj+z/YEgh99 7I67sPHucTs2ca18D9ebSB5KnVU9yuSFZmEGUEDVfL8/3Tcv7v1rcz+BgmflCVVMMMip1Gu24tps /ddm+3cO3UALmO8amI8SdtT1rnt22d8uvHU2v9C+AYfnvfp4i68bc4zHmxY8q4+3fpvfXgjv6aie l26qNET2xvXOc9tdePQfjJx2xxrmohzg5qsVvHUxDx6ewbN1Xn2eO1d3by47e7cjqPXkxGUtJZUV UehMKYhUofUqSSNFefu8O/z+bs8eM8eoT5g7UH5b6aqH437qYWNk0MKJ4hsyUjmsO3yx5ezO2SI/ Z74zTt78L2juZoRUBr8p/Qcvebfsv9NhJCJijR9FUrEfSuQCGIfig8UyDiSgpkomjr7S+z5fm9me fu3K3Dhyx5n7+ejn4de8GIoJiCahQQ6KWSooxquXpdhCSPnVTFAamfOkxNWs+px4GvPXpK11Pr1W 4LjkqAkY2CnnokABkhH93n7Q/3pJRxlBchAAUU7u8duUg48IQSJDdu3cLaTIjY1Jqz4vWzHBNFr1 nJwiCaVJFRlzAPQCKnOoqgL0dDfFR4AX++MyNzUOqu3Qa0/BEmlF7zsN49graQqOqXDH8Z3Q9Fk3 Irwz+Y5QiYCOAUEfyeObNn4aebLaxe+0sDy50mjhB8QZHqv3H3x7QIIhEiEiRJWAMnxkclfOen9x 6efptwOp2nNOqhEUKT7LqeoXcjKAB/qJJEKNPtgwYFAHinxP2PauoBKE35iUCQwuQDkMSEUMrEUJ ELhIkEoZCFWIVUkjEsgNwqh2sJJ2g2BQwagOxeEVDQpEgSB6aki1D9J9yVweqbRER8VdCWCI6f7f dnsRTzo7xJB+o9iRt6p82FzKmZVf40zTGXmZvp/w9BZFq1GP0CHgZD7yXwt4Kfdh2oKvZnzn6MNk UUOQ50hESRJ8BjxffmwRtH/QokNQbRGzo00Uhov/nAZUesI9wQqfR8p9XqXpF6kBU8siCcmEVPtb C/PRIF5Q/X7UfXW235Pd+CbHL3k3zfXFhsbDSINMTGlG4xQdERiZ9SFmZmGGBY5kTFC6IYJTK+Dk Y+mN5hqT044iUantfMef0RPrTwjQehsSKCtViRDls/L6vHx+RIeo+36/r5ScfOmiOetuZ4/aYr/S ZUZkWVzNBHHKx5w/DL57yGHGjEmBFjhG/KZ6LSuxHIhIkd21tuX2zc05UOFBGaBmMxE3SedSFMSK kZHqUG6kJp6YD+toSOlQnJPb3nmmyKK86wgCbker/zc6IdLIhv+zx/r6sLAsMTPylo1Un5W/EaEf RZuu6lWWobVJw5sYsV+9yY1KrZW/XJ89TanVZOFJOVHKtKzo/O05KJVlVNKHSyQb5s0L4UyCrzqO dk24McnA6t1Y0YlhMZbLsNl2MUGgMiMJxkEtq18lQj9Sux0bKqWNSqcdjFeyIk+CkCWyRBaENNpK vc8VObv5ndxvOx8DY4xsOQdqctaRaVeUprqGdKNdDNFBhDqiAXueBzzQYFHA4GQ6HZuKHOUAbWdh d6g5kIkmcim2DFNFN0+nQiQHBtA3GklRoSXLnMXZsVdDoDDg4MQt6QdNZoQjA7EMzSVKK1+IurFY WyBxx2OvmTLM0SMyc0x60OICpVHRuwGD+Eud89Cg5OxFsLgKhkSE/xfo+kc712eTUk/l9+WB+3tD Z9cFSa9EkgR9nXMdehwfrHIEX8KIEIbQHJjkrtm6qLOXr/A7DD1u/R1UrsUwqUqlTGMRUpRKlkqk hUsRKlUQpFKhRJUosilVhFUpRSqVTtsw+Xsej2d59AFuCoUDQBigsHcIpUouvVi6KGhURNIqCcln b0pfP1DjPLyBB1RgThDMrkGxHRaJNkMcpsnPltRQaC9x8nkR6jyHmwNHaJgaSZBEDdytkDEhIHoz 5Gb31zyDagKRjMML56EchIOVoL3b6vCTrMGb3OzkkgQTk6OnYU/AnPx95hysr7/h7rqMH10NyGGG GBjOzC/Awsuuc2GDnfNAwLdttc8cIlTsXvM73veY5srTGUS51Nrq6bIrCnDLwlVitjGbm4BN8RSt WFGwsxodfCKCU5/sM2Ls1FN3EUUVRUDWzKSYB8POVY0Oqg6q+NuIpofhZjTiZ8PVdZbnZatVxtre 0brb7LHWaA0ZzMhRoqprsT17XSeZrWpzPeZIgZD9LGrXk8ZmDoGf0sqk1Oce5U5k7qhwIoC8Xlg0 sp2JSFdHNqqKqA2SqsFYkwjhjNZIO1Tq5z6vqGE635/Lq5k6op2GYmDlp4duwmwhuRMkJ4qD4hUk 5nYYRGSUm8gnEk3OHhIcQcDiSHKlipAYlSflJzGkwLBN1kGyRUNhSXKJQ4R4iDkCSAwRNvJy712b 9jx2IhiUXcZ1jus8uWHycK7tje+iiSKKgglKZVJZ7gMBNAbSp7KCO4fac5p1MujWAViPqwp9IXFQ QM/IDllQepEYm0Yvjwv0mnpDpFOo6zNhdoVX9JFIZcfsDnEovnPxmBTDw60PycdtrPFdHgsAOrTB pDBrR2ZL8LDefjTx6RoJzUR+zh3M8+HyPxpeQaf7JJJ+dka9TFWI4SmHETsOs8debDV/8f+YVaQ2 Gx9xhCFC4EGQSMBL9gD9k/9nDdVcOHGzEwxo0Y2GGw0mlcbIxVKjY6tOCiqlJzcm6qMEmMwsahDY xlLmDwpGCf+AOfsxS22nDhjThjmrSt27ditaYjLZsjwt/JmUbP5J8ek9l3ODEn1VvI1jm/+6Mcyz lvhudGFViuzwYVLitp3PFp0GxhxWU9ocwQeaKC7tOES6RhYsIwVhSdBsSkEzARAxK+A3UqHZ8ji6 CfOeX2+PlPQ/Z6/R7rfkCFlxVP2e2AX8gqjYsMm4V3icDyFvs8TV7wsNjB8D0NQoI6IxxIgxasaz If81ftK2U/YfK9atmyc0FR8bb5XJhv4cfhHQ1RMyEU8W94AGQoprN6IiOHCn+0Y/k7ef9J7/nX0p +4lbMXFnLAQYIUkMZTG8BePruY7PrObR8dGV9PzhGOZ7nRHjwK9nv+H+T4PtenZyQ+6H3x81kgtD 7/lWVWYKCYcPSBBiS45BmpTA1TQaMWsLIae6UqKwurmFzJg2wshFanaUQNMhHYAxpjQk0h0sqTTG DQyEiTWOtFEzMEi1NYZCgkxISWoKAKEwhoLDGQq1GBRLYmJDMVrVqsHMQgYrBFCEg000RotUYook U9O3PtP1me/X1eHh+Pu45dsNO23Jiyxa7g1WoSrArAoGnAQwR5rR1bW7DWoxep/Z4dWMPZ6fr7I5 SOaft1CNORzUtFiK0jf2SZBiaa6DFJ1rK51HBMwyNiFaqUZoEwHUud3IpZhYIRGlToiSgyIip3nM n8jbjl89EDZp0aFdOLOoIr8vT9BoUPKCqiiJD/9VWkZPtlK3FPl3fz6/bf7bSz8Ig/KDPSJfAvaz 1r14vbFVfiWf74jHiIEIGgKFKImmOjZhSLLhQtQZg4A2ZVTAeAsYozB5YK5FZjhEhVEdQ8hWYPGF x1FGJ4Oo6K7QlxQCKGzZOBmm27E11psSg0ySIlRzzd+pZPtpHZ6rQe2XwA/S4B9ULukfrqKpAp8j R+fDHaNAaqysUIwxSCQiHW2IryQSMaChSCWMjBY0FYqyjEagHIUPRC/wmxyuTmzWIML4h4YHglQK HXqQfrW98Q0afhLRNngMQfh8ZyGX1Mvt9U+Uj0/UM+CFzzMLkZzGd7JVtbYdJJ2YU4eYg+Bpew0g c72kdsr1gf3hAa59mqJRRS1FqcOraHxSeTbJjZtISG46VVFJJId7k/xV68MPY1nt9OF7R22V2usP URIk4kdFbJeJOMyY03cSDvneck/wnmnHuWCvvkfHGn3xehvS0JkhOkmdM7JtuD0j9x+CfL2ziOdX MzKRDjBODGOY0HINPaMaSlqNiCRJAI8tSbqGgcTC2uobBNRwpU0aMY/GHHYhIsCxaopomUWxizDG TMySshkDZpqGSzQySREgEVpMWCEcCRmVoZCwxMMljIEwjWl0aN7M2EU4lZRghhhjGYZZEWEVBZZc yjCMKpW0/BEzSOImQYT5/h6h8g/51I0ZLal9rGoD3njx/WB68v+rza0fUh24OnGZRpxz26uZq2xY ZYOjd0ONbts/k9pi8OiBDarYfZq0eoPP3Azp7AI7iqL8w9hYdVfMCGj5/IRh6CkSYOqNSKoohZZa 30Rgix6G355nS/uVDPvDad4oiIIKKpURVVVUpZAvzdx6Nv81xa/Aafeqtx1K+5XFWcHKYX8U2aar C5z5uNw1uYoryGAVXglUDkQnrQ0k3l1SuOZSCFwMKDDcCnLdftQPqA6/QHcJYKiRPWPEnR6jqrXj jFL51gxNUwbrI2PoqHlyLSbFUmoMRKTbiJIk4eYYxwwlKMR896Lfwt5hD/28U0kfSekY+x+bI+z0 BIyE6KPffr+DFu7mGFTPdSYsCvKon80x4SHlGhHiGe8s1FDqsc63+PCYeRknynwf4Yq3Kyl5Nj8f J7/sx8G8MS5aXKnspiu8xiPF/O2kTZZIbRHtWAsWKpVhFVSidhLCfQitE2I0qJiIk9SpGbpNmSBG 4lrjJWB/Zeyx2yp6IlT00Yeh6FI8o9rCrJZrCZXmIfQYbr2g2KES6h6YG6+xE6VKHihERn82b3U2 ZY2ayl+WxhVqdHnj0tidagc2gTYI2TFIusooEvL6ymjG/hg2TZYchD9uKahf7R7A4DpE+8ZENwS/ SSilg2Fiqg0pOkKkq1RqtmlYxSsjExSrjFZKpWMSrDFFVNSpi+bJjZPIrjTJWKTj61w/ySfMXgen 1utJDrDGAO/t9zv31ut+QqWiKiNS0GfMVsEMPsW2TAkRfkUakkGSRNk0VtULDRCGQMSMmF/Gai1j Y2aYVg2aqpXorMy1vCBrKimVxRosaTLlAv0YRg1k4YbZnElN1xihdpVTQnsb24C+FpHViO9iSIqq k3o6Szq+wf6H+Ls5LHpOUT5BPNUKyO1oiqakkpKTTUWKhxG80h65Hv3ejSjqB8s5y8el9X8qe/2h 9Juw1FA/sLhViQfaLKxL0sAv2C0MGnI4ULiYfo2xePk9k05DjOtYaDMMmop+7FKa40qqKfeKhpF3 71MmcLcGIp8HhWCHYYEw9LfdaD/fSR85Wax8Liex6q9DGVYxhb8EY5LyWR5u7NHocDei8cW6aunx UH2fpxU8knIYU/R7zFDpOgUefXRefWatezz90JbBS7NypfOfz//Vp0vJP3PFknz18aSTS88UfhhZ EmYhhMKJhiqYmtGtLhrMiUgPTG1rBzBGcZBCbY1qyNWoirIsFJPQhRiKhXe+HRu2YpZMWGEdZPc5 7K2MXKRsY0gY+Q2ntKUcSZCFpLJCDdTMtExCwm06YhtFDZihkqW0GIBoiXImDbLRnr8wOBoZdswO FkZLGWQXMAqQiyREtYqmmXSJjjiwc31YPm3n3k/cm/1x8yeWB489xZWvvOtybEh/kyY8qRv39UcY j6GkeM2euR3PM3NpCeUtJvEA8h/yfjE/uOvPsPeCm8yNqHkLgNQDDhQnkiCRicY7Ssf7v1tt5psZ FT6T5TEfnVpp8jUnh1Y9id/kfDaeJ2I9no9iAenH7q1NDPiFxrChaojOLRm5swG18psBpew5EW7D BjXEtCylU6UjFJXbh0LG/FN9HStWdcSdTKNtioAVrx4Wh8ejcGWKKdhCgwQQjSILEziMN9NGIblj jLYCRNp+jPAmQDBjRX0Nki6wg+wTaWAFIymYJOG5kSbqjtaZIT/52Yc+z/vMTQrq3VJB0i7aqNAt QIjDmlCKWrTNRa625NIlsYOw4m1jBwG6quwHaBxofy7lKYic1iHI6ZMc3cbabMNCw1khIzCQ2xDD jOI+ezkFCO+3xSehyd5K+woLVg4UQ4JQ5BSJ1NEDUzJmIAYMaXSQOZiAtEtWMEmqSJc4rQrstS64 I1rMzCeNHI7zcd2KiJ3IhrrYDAY00mSlDiwiGYMZ0QcFGGixDAiJYk2mzJOAnc4w43OkmywCMeQC lgm0m0OlQIpphgcEDWnhUgP6GkoMAM2d1A2LEqEGa5DwYx5CcLDRUMG2AdqhDTNBso+GsGK5aYY1 Qg6tWEkbQ7zlIUryGJQaNi4KwaTGZtTB0aQzIQIchhVoaZBIhhNQoUyCPG0jRiII41Bj241sWBho tozClirAYQR1GlGCpsyN+THCzFdDz5DZeTuyEc7ILY4mEEnFhvKnTtLoYqMI8DTiKNsta03rssJG ym6kmYmAbvI20g09FLEkwoaGZAiSwGxoilTu4TkG00PZN5M4w20aK3IqDTJgxOJFEhlkaDctQm0B amCjWGKxoeOYNqIkQQYLRFpFxmgYV7mrtEjFyMhTY3gbmCA0FICwiPUGTjUsCHIaKNGNUyLZkWg4 ZRtE0UwaK1K2ktU1Uxwuxzbs3baUsKwUYo4VUwwA3BpKjZo0wZRIqsEMgRPRqGYWobFCTQ1GjYYG DQG9Ylm4XI43Q1CuiR5QpozHeE0wL4RhBJWrN1zIHlOVyxw3xNqB1JNOSAcFKUFIA0alKEcSEyMy yO9dLGizLawxF7fl2424U8jZk/EQgegnm6lpDEQNyg6AU0xKCW74KHBA3BQlnuEXLFiO3xHrJQFk g4e/BpvexCpHnqOpjHakvOsasxPjb43s6JHgDAh2OSGrC9pEZjJDIKSRANktO7IIQ2WTFMHlMMTj yM6L9HptfPt3UKRI4OUUal8pKM0Gg7jMMYcbmbLCK2hx4SYarYm2meD+2ZTO3LY4m8hEy8TXTbfA dVGlJNNrMhGabrG7FgyRklm6yqaZieHa2am1FXo4YdhiocEQuBi07gRE5DZvDZKi71rRpbLoLhty nnIPEhBNEQMQPBmAZNYhCAoQBCYhGvZ4D+MQ2AucdblWwVsVVleuaW92zJIeqc/7eqD9rnOu39/6 /D/H+/3fpnt+2UKJTjLEG7OcsgvjVVj+qotnCXJK79ZwxngCJhTU0KKGyRzTum1XrE2VgWZEawtt pqlOqkz3rbFYoGNNJQt+M61ulVU/NZXkzFmbApuqukugSNuVd0rp18AdDWAMyvv0jv347HPbxn5M zMNPNY2vbnlQY631nHmN4nPaS5uRURAmLRg1GFs3ZRfXKVi4JNEVODbw1IaYIkD2h8O5y1TNaG4T Lg8aMyZ7xERWRHwhz9UDBlGuDKVlIQIQgNMwcEBUkMGIpAUMgsm+jDJWIgmLRAiZCTGMKwrFZKzk /Q02fLFTYiodiSp5mjBaWOaxk1JU2FbsY24jMDBhboLDYHZXe6AxQ6l+j43F0vzNHCnYHRIwjJQ6 MNg4IhxjsTR10RjeRiMLtkUFihE3hWipIppKpWFUVURKqKUlUknWaSbQpokd0BWKRLE7UmG5UNVK 3L/PVfRjKZcPHTM6AbhudgwvJ5piLgw7gQihusUpqQbvixxvIwlWIO37e5swxaqlxDl4429D+c4u 4b6OV3Kcj4aAA5LyzSYH5IEVFFRQgkahElEkQGRYVhaUXUT8zcedX5U+N9ZqMf6W7Tdy/Joyv4fs mWrbCqr78fO0ddZKtK6VkiWPQcLU1BJ3lhd8Kq0YhqGseBB6zRhFBiMbUglmwSUBW0Z/G1g4bDiE Vtk14YbIQkfj18v6uHIE/cvtC1MY4F8mtGikIcnFkEoohpUjxFMgVOh52Jy8/I3V5ujy8/T29NHZ uWqqqqfRVR17dFHoRMlTg6WMdJoQeqEB9yPuo8JI+xSlmLGVVKFQpuu1+fPHO+aIOQJ55atM4hhg AHoHAhSqChdZQUDQEuEm2YjQqUvaOt2TmA4oDLMkCMFJoITRozGLWjRRoyxwLCUcQgGMaIlwsxF0 ZgalyShGIEpQzswHRBCcdeTw14Fx+Tf2+Tj286nPIAUNLQyhKRKRZEQ7RYg1z90PK+ZY+WfzvtJI 74woiYf25jQVk42RmFiYZgTlfZWjVQatGgwoiQ5IP4ea/GIVNWPsPxuupXknwPanrYmeyypi+l6W cby72YAwCQJBQwNVEIbGwV7GQukNpM6DDILa2t5dDKkL6uOhyPQTzZfmDDCTQOGGJhUpKUFTRISG YhDBDmEhMUBVKGOgkNSVGGjSiqlYTZ3UfjXKIX+DIO+WvtRu+t7X4uPwH/ZllL7PSNST1p+HHth/ 98lpZVFPfkpjPyNP+58TduTZmESRkVvRhgUZlGRadta0gUqQLlwRkibEvxUitflwgzA/OJeIehg3 a9gbpP5KWr5sjKmZmio96sKhqoGgKDAhIRBl/7xQUeog8p/W9SsNHwu0+EmzaNW+D3Oj0zzcTMw+ eCyebe5nx+MP/2bD6AdzZvUJbFofn2b7Gqu0MMqTX8fdUkj1CRVKqqpSlVVVSs9iX4/Lhnml/fq1 7c92uby/l1vD7svmJUuo4P5YOcGx023D3DdX834Oe7iZ2d6AEEVYwh2RFogaL24vlH2ZNAP5c3qv gbEbljZzPgU0egsBs1LojR5j1YvcaGIIlYwD4p40h/VMfKYhkI6CQjWBRoCKHBoZ0w6cF0atBiRB QanUUoMxpYEA0ewg9/me+bqOyp9O4HBBbNa1S6US7BLtBnjPLVO8eFeBC0Xk13JaHgGmJBycRBBA ZCxAK9gezz+n1fAy9np9lEKI7Q1CAono6kLVQ8pgcpynwh/SSaUUUR0kN+tRmWtEDUJ94cXYDQCS PP6jl2R4b1VXeB5lUZA9M+1IRt7PjXuPR6PkJ08BiG0aKTUoPkZ5mVCphkLMRgGhQZutFGbk0bRY mluNQSjiaB2fHPe8T8DyMomXsFeOe6DbvpFRRU3ECQSfJWB9dUevpZKqYbDdAwhjkSQmV+FmjGKn zXEUkn/lX4Trrzxntd9jQcYBzUSdgcQifkQcZeMAhArC4OMliI3DsvT5nwOeYsTt7OFAzzjj0jHi TInrS0dRAlyOvXu7+QvsN4LR5RvJJWqLcbTUDunJdA49id7SIZ3RVTD2ca0ha2o2Qo1TeBF5tVGg YtJgg8/tD13udp85FdXdxMOHhdITda9E/1ZMQEkPlPMGyrpYFXR0N3DuTYE0Pa8bifMmAa8DN2wp Pclylr8vc7h0WUG7wzQI4yOSlUlA1rCdJIndnz7LoOgzMtTrNjtLhKzMIc9xUIqE9SHk7tFpE2EX xhiODs+NRCVyRKPVeog1NWYI7QhIcTjmlMH+qiKvrw0ywZIM/OWA2ykiyTfJV1D0V2o9xi3kmWsX 0pmzDzlKeck/5niEJGaZQgHT9HUWZBEA1/cMbhU2KC9SsqqqyP5S1ibyQbkkkGMGeYgpyJYxtiaQ 1o+IVJGKnZxrW/bmtOCP7lek7ZPlYuTYEhH3XrHsCPLsP3H7ET0Hxoe524PqgImYA9CQOtsBD33r kz5sV/tJ6SXckCccixRZhAzKqhxRlDzegwEtO63/VodCCUTwgNjSPnBLSEflG+0R/wI90VH0yorx 6bkXXpg7ingfQxp4O5MRU8QdYsCELBgcFkOCnJf4G4+CkG5yIMJ6BKNxiHssdVUa0J+WLlE72spT ZcQ+5w6PS2CctnmHXC2un4jMtE4+jc5Cm7MSTzsIHJ2jUYYBA4ZePMdrEQtCWIL6yEYhYzIs4es0 Ypys25KwRej2VjUkler4kXxUPPj4vsBivqIL93Q+IP2r2kCYQgP6CBdIOpE/A9PWj5YAPomjD0b9 RBQalUfOfFM78PQh4ztBNyKG+VD8UYH0+wRuwwND5X9p4Bmq+MIFeUeAyc8qqvKPKRsjFjYWLZsx vlmypsKeDH0K1FiLKTeyTDyMiv0ffjPjW5czY70h71/C9S+KWTrwWKPa9D6ZPlS0/BFBzI2rM1Yg jr3DMMgvciA625D92aSrET2Hclt/2Hv3C3tWxvJEyG16+lv+wnbmMfGCcBYB4wjIGghSDptMwlNg pooVkmmG76efHBtF5VBlDXCS0vIyKqOzoI4OHh3VB2AhE5sdPOq+X3z1vDBZLRWm5UjNEcfRFQi8 jgR0W6Or2o5IvVSRFcYJJECCWgecT7Ls9zMpJh3Yav6Z+xLJ8U+Ru9LsU8g0HfKdWa7o8boLZCrc oYzITfur4FXM8GCM+iWfieYdXbw/5uFSj5ZQ2RsZ4rgk9D1P1K2PMqYtUmz+UzhAeQ8PSCBtej3x KeaFZKv3nhJb7dJtH5KZr5PdmbeZ3m/yvHribVY6CsXKo+5giv5Gjd81TnSa3YH67JN7I7+eOqcM aVvyw21T6iAGHQWIM7OpeWOEFJmLHcOlv9L5a2H8CdzRGZnMcYu22iPDnahuxlxuhFofLZC6NnWG 7qeByEPt2DW3af7HChMwQJgEhhq5IOCSO/+XalxfMMOzOaKbRoo5NOxIyGbaZuBEGxwdMCBNAZcR PMWgOp7RhDm3GbRTmOuQm+N5cyzEDljmodToctYXulc+I3pOlYK7LaaYxpWdGuTZuYqMg1DeXLeT QLGl0kNtkbHbiXPbVFqBcoJEb5MQNIxi3OuPTuNnnJydJ9RHj1hjwMI6KO5AH9QmaA108QON6I5y Uei6Mb8uZXo7UgpMibf0mFlaATWzYgoHuCxGbFPPvbPSdittDhOjgVFhMptdlSGoKA3VBhNPcT28 obHswDFO2E7NYbicsVQ6JL1JDCUAOU6B3IWAMU7pXQTAhcy6b4BsLYLgoZFg00aSJ3KhRZSp0568 +3RxiaYyrWy2Hd0lHKpG2nZK0kg0G8gNJBw9oYdsm2RYZLRzSTF1Pi8IumJFSZnR3uENs7FIEOte zzw4FpCTzmM6QniOUQbjQ0bo1DnVVgcKeYMpuLFbcMqvG5yY3TQsdyuDWSNKiN4qKqUsSO9R5RZD TZibqdIwCrKDIjBLV3IiW3nwGcnYEHoabZU9wy0dhcjip35KJbsmbNytV5hxt1Scgb020MgBp6pg 0Xhm8CLRnI6FGnvOYchxz2TgYMwZw7KabiaImKJ8wbEJWkZoHGtjodoOB3LBO7s7W7fsY+hNGt7z Q0bfjbmK/6rQTinsO/pCbh74l0Jx7GbuQE5KF6PlDiBpIBwdvAXUBLN2EOzafZy4XrKD0gyQdJz5 dohUhxTo5MnYUxUTSwyyLUddMhzbWLSDpSM1J1Os22uzsrRsQKwprSDZhTLBxcUOluwQWGBuVYG6 J0oSoG0eZCQQNBqF32Cok63A0uCLIcoWX2jf+Ex27HwAQOEDjnhtkhx0vYwT7BQYkaCrmSlDQbWj Eq4zwI6YhOOcAzPYFLLHgCDfk2bM0jGdzViJDRgiG0ZxIxq1Y3RRqpAj4YBpbLDr5ozzSHE5lD5K nByRq29GNlnaTgxBPI/ZGwRNGDxmA7N27uN3H3myh7PAf/ZHd7rFafLcoRA1PrnLVb4o67B2cmX8 Qcc+NQLjQ/ieQk3Bx4O+VAcAIRA0glCcMniDKlM0goMSt3EngtbFi1nG1TxrJK7vF0Hd0arXBrCL OPApi3wcBwBBLXhJZLggcc7OzhTXZx7f1ZMFsW2NQ3AbJofogMLJkEOI7bztYJHznLGWlNzDNHgL HESmOykEITMhEjI5TNnGi7oBx5Ihf+JAxhMKPHcPSOjtzkYnbrXBHd3MQZeTO8GG4yzshNUv3LHk 4zHcxLW3RGdVQedI0wc5Vzz7ksbuDqWA5XlGRvjlnGxg4OCULFoNiI7cyo2GeJchKHBuolgbb0Oq OpuKxNJG5UHFMU0rFdHYddWvPv4OW0Og4uO3odm7Y6tvQ7TognRTtAmIx2JuvB2Hyxg4ZjJ32aGC WOkzIQb1wLhMcEYld46aRFh277hYMaXlAiDo0ZiiNm2kM3zOvejVNbbdsT4coPAJ8vyYbxk5pmck GHXddoaDydnbt3fo0aWTurGQhjtUGXHZksKjWiMI5EM1huo7MTAQM3BvbdcW2JHdSvAWFFgO9jnJ tymbKm90NybKL87nzmkxpcGHOUFbFEcmUcN6LxOLG+xUg1EhbdhheehbgNkpPGHfmyGZvVvD8ZfI MUTmL4Kc7Jw8O5RTv1OzTvVqTy7N/LuJ2nGzYjCsrzMxDFmmiC9hLEPRwpg5gy5GvHAYJZuY0oE7 t4gJ7lIgLsbwdM5zB3FPfo0QPsQ5lB55IZvDb5gcYTWjuqqjIKSGBpRTkMwOKnJKQUMxFWSO4P47 TGX7MxyA50diiuSwqx2Nks0FddSQzBabHcg4Dwx4fiSWIFJ0cGGEhgo5cRAeNdgowDjsduDIQkcj w0bmBuUgIZogQ47gpWkqcHFDw6bduzqp1JpkjdVNmI5jem6phYYKZqKO1DSyRbKQESIoQ7UnDfYo jwbDQmYgyjYglDiUOYqZx1xGDsYHAhctptuTNNt4wnbB4yVkCjXMZ2UObyEMwmA5dmcvQ08cToTE YLCcdCCUMgFDj1z1ho7zuDAO2Hqp1hoaFy5ngduy903KKRwGg2plu4QxygLTM0457dTSYtkMe5OO q8QeNMRHrQd128dyIUEjr1JfFDGdTjj11NJm9RHns6aOZPLdgTGOj1NF9J3Ojucd6fquMI5Nu3J3 159SmcftwZnZNBdEOM3ZHN5rl0UOy929aH2QCG8lZSpViMBgsEhg4bHoQqeIB5ZN409iZiRsQcG+ g64ybodsBcQYFkhwkowNUsk2Sh2Y2FuNgbhGSDWMRIasMyQiJcCRNyVhoJMAaxcvWRHSJDo0NvBi xPwUbHRVbTswP3Fs5CWMCfbnJzgNs0jITAyN8cnaQkRpWMQhJY48uOcXwSsHMHENuhJ3HebhchZj qt+Bw6EM+9u4QbHZtj9b8SMZKiGNHGQ6sdmRLlHPoAGusdbJywYOXLdPvh4IHPKIBDXiCiW7qqbt Ziry2l2tzjwYJGKOTAmztwNmDLMwZ5RySaQQ/mBCZIblAUIZF7nXTt32m8byqO1WR03yd9Rskp1I BxiR2VB6PxgDgznG+TOAeQQn0MSXjT5MMxjLweR5SbJsHaDHmpNCk0OTlsWLvRxssB8QawNVVrBs p7wOMWMgiY3wA5ZVrieA8TAU5nGarx10g2M8lB0je5HG6UzqGaejZknImt1kHcocMDj0JsgO5aMU /NwMcWYLeiHvuYIln5EGGbDrrRWDGng7dtnAjLu+GPRMcrZJkcpzhy/UwOd+wMZEE9GCDnDFIEWh 7ZEaOqzfLk9sZwCFuI7AZH0bgWAwOQ5sk89r51512ObCTsSYR6vwT6pHgLDhNp3ONnEBKDo8UNBL lKnIM6iiBlhOZrvaSIzBjIJESWhJc9GAijeNJdV1OZsZRG5A6CRZxtIeGBq9PwHZsB5EdhhNcIbL cS7JDINKYZ0kQQOGSa1PMjseMOeqJORHr4J8HObnuQT5nvKLdjfYnsMT55n0E0saWcenRwV12tTs zRowdGNKT4UOdgfcAw+wboGwQE9uW/psCm5QEjMmaSD2+3ijSMi8HHTVHVHQmgTGRA0pouVVllTn pWSa3dxw4Nom0qYbzjmHBxrGdgnBMFpjgPeozwxhAuJo5aE0CERy5PIuZFLQiTywUe9SN2YQMxQ7 FFYyORjmrRVPicnXGzVd/JpnAQB2hFaksp+RFR5UQCPYZlhcUg7pkbAPCyRj4OUR5SLxBEy7phsV jTkp6gdNCbY1Q3cl2eZiQyMkLrI8j3slearzQQVDFTZTSdCe4MXK82WzDFgNCxJL4MGKItnxGLyU 071U6xiTJmGzq8zTmi5Znd5q3txyEkSC2bzKynx/2w+paO3Me0uISZaRsOvdyKFfZlll55rjOrjW w3HuJypNhRposa4CJVKdbrROBa2ULwPLNTVTY7DTxj1+7NGRG8PlxnQkgyn3hzxI65vKmPtjvtqw ka2OQISXZPp3J5RDWKROlBBA7kczO051ai1ELQxdSJfs5z0Rps5DjbfNStT29ojinWXcBCZbCkM6 m07FKZcOV0K7a3dik0btngU5EQ0CaxMcIipKSMyw3a9Ec6GPWQ5s6hhrXJl9vCJ0YIalahJ3SHYR FwP8Qx8MGAwYNC4EN96Zmi7YILDY44mhkxX2uOxT0i4Dl8cP5MSKMoH9eiCnKNrHfbSa9G1cGqY2 DjlDs/KHt5YhlAaZsELEUprMZwaOmQMF0gbttEbOJhBLNiOfF3bGajcmhGyaQxpNakoY3mQ0OaEg g0WnMxojLEWrfiSusQDQMOJhDYAy8FrC8i0REI4HZvofH7oBWGs8tujAkp5MKCsBMxMccIzIhyTV GhpCXYAdJWtQgGwNYNJVnTdwUZMGB8gEM2b6QYkQhI0W7dxBZgmsPRY0RGHlzvGiy0cHvsPBgLMG LIIIPeA56c5HHzodtEE6eYNOREHKn1OYrWyWOwY7qIHHowQ0gg2GzqNY4jrBxCXJrJvnkLnmdBVC c56ev0lHeNXkLE1y3LtBkgEBDQJQ5xjghHwLhU6yZA1szHY22u3ba7NtIMEB1Qjx6Z3sgRIQREQR Uxt+7b8XfN5vvXXCbcwiWyp+Lfd1PZXtbla9/3LY5aEd76ETqEI2zuwamsd7I2xrxndrLfvsuQwZ aH51VbiT1dcuTmuivJybOXYMtWZjWpdt5IPz6zhYQUhR/NzNf0SnpnF99TY1a5Msc1D6HUxtWhmR Vg5onNtpdIlFmbOuaHQrXvNN2FF0KKGHrOpuDSN23hXml2vB8fr0MWXH3Rw++OPh8a+GPj206+HM 4Qrze5jUSbBCqyT9+LrsFrnitU2nOcKB1D3W2Pvxc6XvO+mnKq+2rC2psrb5TlBmc2OLVrhnzKbg XgiMYPfoZtoVvCImHwS7EcGvLFfMyD9W8bfs1VZCRbwrqghlVoiDCrvs3nCCQi5otGxQ77SanyGb qFRR7UGQIghul9axzS3l+yqLvNuTY7GC0Cxyz2aMrHxGQjjA3opRsuaHpkO7CLNjRE2M5awxvtLV LG0NtN1opaWc9m5vVVQRpPUu7eiY4MtINWhGNIlMhmwaUjm0MxcicDOGYWNGODA+R5EMnEIQjhwa yINHG6LsOBkGNVkPFnLAEaBNcwlzgOEDPdSBZsEOIMAxThtrMYsI5GqcDRvXVuY7NGSE1GM4HDba STZJJwwyqirJDZ10NJy4nGhsTFEWoMzOQX5raNmsR2DloyJhJAhhMxAV1Uk5vlVOIBSFPDbkfc22 A8/5Ryea9TyeHLp1DzLcEFCUxLTwgbMMhgveujzBh0T0BuHLzYvIV6HuIQ9ZXTwnGk1OC5DnOzd4 8zXNixOZU7hzuVMZHA27fwzeNToy5khaTfsiHqOceiaQJERvuHS9kdKckhrMKg2AN0wxBv2TnIWJ zmbm5xCqNq/7up07+m6rx2LDBAzjggQjQDQblgv3Oa83589cGMOaKmv2HRIcxUk7KbE4bBsTY25E k3Juh2nEbSScXxYTFSqlUqUUCRBYkRlXZNdTQch5KIQ8IaBVUpUpQiihWiMTHanKYHI2dyqqVSRV IxzkwJGw89uagbAC9DqTVU1FyDYBR5CcnkimKIHXYAYMAkhdDzlSgOrqaIQ9DKeYSA6C47aHkC8w NK5JJwbJs3RJvIHWAySHAqN0qlV08Zrob8YItRLZqCdg6Q8SIPCkS4R7lEZwhXXycu5mZ2EKTo77 URMUXae2RL/FgoJGf7JH8I03G0gjt7Bq0IMIJjBGQsf4g4DvBEysEJYVgZURmEthI55tERJsw4qG SqPsdGBwlmIuECORmhPKSCHnsFYQORHmBhdk/0CVSJaEVcOgfNujpsBNu3UkthoTokI21JIb2AVU AMkCCH+tQeyr1hTqVzhms06+tfR3Z4w7/d4mR4/9z6j9/Uqhzgq7wn3kHoF+1YJCDQZBzwgZhBge xhWgMGisvqP3ipISWw2k5Fhh45316fM2/N6OXR0TGIi2CRasiwVX0+Dd/R+VrQT8lPF6H4Or9HIO 2Ia57wHodf5HeLWfQfw5HDhVAPvD5KjlMDe4i5zbNbTCnDHymPUrRs5WW/zqq/6lmzowgmqDYDD8 7Oba/q0bXBE5EUh+iFdAOxSi0dCOzpN6bgmc9UFQ5JrpEBAZDaowliHRipI5rNVUGkjXS7aZTXZk 7Do7VNDmqFLyaY5sZhgB/3NC7iTtME9DEwJYnuuUholIMjHusovEwx0SUUFAkQUBhC5IYErBMSn7 w79GoOMzsMe0O5NOjBpzknDSn/ww5Ha6lObg6JJ/seTzNmwUaUro+VD6pZCX8pJJHylk+eoNIPuH 4WOXwofplknyK4g+nAdR9hwKL912A2kkEPui933E1TGaDJTUPmOLd1O/CCF15Chodoh/6C/WJzNC RyAN9+VDBRSDVmDkREk2Y0kq0NKXTM5yJzmpbDng1CYsgc0InDSQuEmLhGH30ApwaOhzIbFD8fjm PfRKWOf6XIKBH94y1pwzk/wIGaT/RMIQU2TUFMCDeMsKzoZ+/0UZ0/VuwuGmhIOrAXiE4ANjr2Yq muUqG2cHcbqK4MCygaUS5piS33YpJRpdxwbFImahyF+BZwQBtoTEDtXg8GoNWOhenQDl1QOvMA+w sewiDfGByBFMYJwMcjseIbt4Ph3NMJ7O5PCYXDltDsc8HfZgVHJceA8LAQhmsMHDvkfJ4d+f8a6B UOzYdxNYP6EHREj9FipsQmcNow0A5hzDPESCLQJx25kOAryU6bz5AexSAsRwIycUDHBIzYBkIrk1 28Msw1OTNOTHK8ZoktI0UhaFWQxVU0qdyoPFvh0ZvOm2bBtjFE0hzBZcoEtDuYtmY0zCOnPAjjk2 RwjDHoPMSa+TirsA1miB2hyDXITOxzudh1ou28iHznQ0ftC6RJrSh2sUJSlNQSPPRg6JhsHbWCBM JCyV7qGvIZJwJIBx+bcyQBQQx6Nq3JJFCbEu77hqEJkZekQgZEwV3nvkmNpOWDV/gZs78PzycljF FDMbTbPcaXLdVRE8nUndOSZgwDHOWKO1YpwtQbUZMK87aNTVLcvJEU1XjB7PhNFTBOxUIvEUhEj4 lKXstvZYoEMPZGXCy8l8GoTAsiZBjk8YgwcDk5O4Z4CHu93bF+HYDxigrizJOR21bmXIWMjgPQ+K qawJXD4FNU4zauGSydsa/o/zf29f1f2fdD6v7O/6/VdPKSPubnUbPB4YFGJjYgyEFG1JHl6Em5qe dObwcNnoizmOkrE2hgiTkilQUlREpUoVJGI4JHVZCcdEwNJtNJyNSRUbQHIPDu/j15s9nEh7ZJG4 D3yGnhO3tdtuTc1LbU1bwNEeDoOZvNhiSbv7Yvmhj5SBE8OdiJkiCIxAIxmSwFFZQjYMa9WvGnIX XjmM8uz569ipUoiJsFRJXxcioelQ9UlCB9hC5HvfoxQU5QBswxA+XAxD1dueXx9I+d6YDw9o6EjK dQZNETpPHg8oehl5e3gX4gHhQV8fc6+Tr6fZ5Pd28no7CfbO8YEjfb9DW3Wk4lqVGl7PZy+7s+GH 0BxQ8wix8ZBGkBoGKAkAkJUQoQhlEGh6qqyPlMlClKRKRIYCPlnQD6g/XD69iWSE2DCB+zHw6DO3 vMBw4c4KaVDX3G/8LEx5438XIcz5ZfQn0v7Y5Jy5I3lhNNwc0ApQDoRUL1EKStEKwo8TDxXkZOfc MPPIYMlXAV5SpSQRB0LewO0cvTlzUmJM4IOGRFseSi/shL8XxB1zHQdELXW+e26mWjX3XDv2JCTk YpvjkPoPA/WW/xBKMwih2J60+Gj2H8ePcf58HrOkeqSg18z4FVa59g+QtxL9V0H7TA1NUm60s4Jd FLZXDnTmOG8je6OJ9hKwqYlbbSN1JVStGRX5ZgcD6+1fHP5n8x9eBfrA0dIcSd4p0iv0d8eV6ZfT 7wxcigzBzbMDMM4IC+I4JIGlU+yXn3vk78SnCTvaWYdH+jWl/Zin6SkWh/EnIbDdhI01kTbGzl59 abrC4aDFckE2QoQ2J5kjGOo1zMyD/cH2Gz/b0UOwlXrHQHo9Dkbg7kMdmWuDIHggMJKOCoDUmoyV 3++Iv8+QnLrQwThTRyUeGtDW5w5EqeKPU3qkBYMhUwDlvTo1glB9RntYNDBokMSckXIhhAIm2gzF SAzAzMIYMeMIEGlisU/kENkA2F863Ed6VODcptBHCXP6UHA7yFchQS/kkTjn/F0XY8+I8h6jBFCd IkfOWJD0r6EMfTDEf0dTcpadhgQTE4kLdx2Bwfx9H/I/Kfe5xLHNRJMZMCetURMojFQkZXXsz275 KvDhu0yNWSKyspMVvhsWNLKAbbxikzBFTYGJEjaHWbWbEKWTNI2j7W0jksjSjguKrTc1xm0nrVu2 rdZSlNxUrMFONNTLixgwVKhwqiaJmsKmQQ4MGCi8u5Q1kQGoblJVEeaCP2zcBQR0IEODyrDTpVlm SqqjnQpQmWpzzGlU4NCGmGQYFJHsJU2gHSQMWETyJ4g+TPN6BpoqsVKqV/ix8yjSUr+vGSZj7mmF DdhuVNHIKw2bsQ0V9SjCdkenzMDu01qsA89a1HwWTISNNqySVQ8z0GTkFeg+0E0cXltJzJOm7022 BdnjEchCSiWP3qVW0kj4Og9P0WM2g6WH+Xd6S1yxYr5Wu8MCbQ2NgO5mgTRCQjUFyUEHsBDV/p3L UmHYv7DDA2fGy/X6GBUc0u8wRT6E2JHzwESFCJQZYw5C73vfgW0BBsFQzLQSCeRIchiN5zbBDIP8 Q5j2hLWAweoIn41Q4NL3YuIH+Sr8ZQlKSUQqfGe/wbnNDmSJmrPf+jnbVddNv2k9+tkNnVFnpsUV 0PVCKQxvJ+3uOc+Pts7/kd/bjXevHFXg0TTHsFt2DqPx/OTNtA41sQmDjUiZuNEp0NJTbaMq0U5g 91sZSsxzZjGBgK9KZmXiQRjSx8+C7HZzi4FvM7IXOdkkjMDCazLxq3Zh+G3Vg5NSOzcMGGlymQD2 wmY6DgDJg4M4D+gyGzuNK7N4TI+PNDtu1SHU+bkHxn5An16wnfYNaCIZ7AGT+uRpjKiQ/qX9rhVx 8rKFWzYvxAYeePZR6C1U9evdpprJDCjKpT1qo7k3vtg3rKHYHoPpE+4kDivnWH9/yWWxLUXhO2E6 +7iB+BSJjDA9vrhWMaxiQakINaGetixhTBkWjWFCo0MbhQyUBhU40NJoiNKghb7Wm4qaGCRNjjdI jdtA+RM40mUEgfxCSIG4TydhwUVd0YcmSqsh01ilWCfEiPwTRuUlTkTIVwXKFgZEPGhvOi516o+J B7iIQQIb4t7z7TJyTZmIfSYeyiWINUNA+DQGBiSZtuqYk9wcbNJFaQoBDZZ5TjDYNI8ivGb7TLlk lpE02OEH8h0EhbUcmAHs5FabaZm0CR9IjonAY3gmBiUae2+SjLnLDBjNuyK74cyiVAa34ZmVWO2e MZFI30NSCYxRQew9Eu4UwyEGYJk7x2sG2Y4jnsckbKqb0W3BpWJZCUCzdRJrhKUi+DAqNBsLViJy zAtFCs8N0oF2DjZGQ4NYzjG9jI3MUUosgZiBYm7EUBLNsQ9GoYaCV3xk3utIooHHHGkwWcMdWFFg x9hBtaTSwkMDnAKDGkyjkAnRtjql1XKgdQ3zpydTBlaEOKAHAqCwkmDiDKJTNI5xrRYUnctGKcjJ 072IijCKJutMs0MmcByqRduVLPRBbQFAVVT4QQqWCngSch1qTM0Q1lsjuYqdSW8DgQFrngGPg59T Dr2ovaccFZnJpNeoeOXyLh5FANYhkIDpmmUZY40Gt3s2Q42zi4ZDnYmNlBzkkg5EQcuXHAXs5LG4 zxF2tNw+WFsCwMd/1gF11GRrRuhMVm9Q8Z1DoC6biIkjIc+w8eQ3e4NzRl4B5nPfqho2GIR7DWZm ZkYSrYlBS0LFSDkGITkkoYNFFVCSqkqqsSqoQES0KQyLBEBMQMBDBEQEQsWMbkCGIsIbyquEbkSB UyAE5KvH348DycNC6g6I6JBpMKqhNa0YakGuCCHNzH8TqBdEfXChhIDEoYFTJBDKlDxRYEkzTZ4h gIgbBBkxHoQQr1Klw5B5dCAXPEike5nw3fj3LDssE57umnWnKNV4FjXmig5akTJIm17ixFiXv9Ty NHsmBrs8uwg0JeJO17Iev5jEdyk9SUNCRAQPPLn8jMKOOjvR3+K3VWLZaDwZkR8ITbxqrD+ISJ+i TjcxxT28HcH/HYP8fjmW4+O/kpSzlP0p/giVU/78nNMFs4hUB/3+5DQfBBg4Q2a8vlzWGfj8mxvf ozlDkUOjiEyZjYlnwUcIaBgXfrt5tvQ93S+ImLMl1ntNi8mii+We83kN9EJVfaQhoacXzSvf6ycv fvUz72AakeqA/1wMMRRCFKCvcaExVQ6KLQCnzjtcaA2TbEz+oe4w0dh794aBD4BLIypMUCUlFUND ETU0UBMAVSNECQUSERMStDRRERNFMCSVKEkKiSiREQFASpCyTvFTer2fgpgPiv+AkSdsAYXbCdEA +bdd+ux53PJE8rEc2MHNRJWxkSkXi4FIOMwkMxRnQ7f5i8w/7NNqTaGck2zQED28e2aGEBys2SJD NlDDo/Vs0qrlSKFnJWQ4CQohmYj1UYZBJBkOugNaZqdza/jx/N3B5LwzifsIRHPjtBJx7z7BsyAy ExhTx5Q5i1AbKybhBkESvyaNFNIHPHUFeQQm7dA2ztuzpLGTih8GDtEohsEQIreoJLCw6Q/c9AsQ 04MNOXJXBIiF3UiR3NHbrGTaaY5XBLDaM7MDDECZh8BAhYFsRYIO4mZb3WSNhcEEZknCBzGw3Hgx kG1oLs0Is8R7EgS2bIdq9KNdFI1z4PTBhXwFFmb2YODeTyHBfbRIg8CyGB23AxyjReuTrhmDXGQR n37UUaQdMcO8t2LkhQiJcjn1AvuxiDzM9+HRE0FiaxAG2xzcZzfDMjQyBHIRySOOSSEZimXIIa8U sEwOMhkM8yBGsOLw10BIPpWg3RjaxVUxz1o5tGkjLz36d/a3nih8mxkHEUXJBh0jwIYvXYxuhrF3 IEaIBHbfEEsIRAmsgcW0x0QX4HLBkNRJJ0SElDHBBBZ2CT0bNmS+OCWoprFpt9riZDmKHgIbXQoK odBQff+86ON0yw66eYYBOYPCOGh8zs1rEadsbo2od4kCvkMkglDg37kefEaW+zTEMYm2UIoY4M9K iwmyqHWH/o+cPAi0CkwV+upon0JsT8SF1kxVZINCqhupun1UxMf1uD/2ORkhSqm6kYk5xKoqKuUx a5T/3up/4EzY/A4Tc9E8U9D4akmoRoqSf8cP4Pi9EfOkOH8LA0QuYSiYl7Rr4D4nWUJVHQgKkHZH RhWnBqFaijCCKCiBoIA6WtK0ykURLROESxJfg6OZ+l/tHNyeUfKvQ2NAHe/GD9yRPElEU1KJ35I4 iAOGiMOORgrov5Ql0sPEq6LtUkmuGtQLNGYMabtkkP2rEjYWE5lgjFSHCmScGoytLjNSU1UiHf2o c3kqbo5cLZ9ictkeipsg5cpP0wuU2m5U3hPusibRJPqOwfY7/Pm1MUfgcMk86uiw3qZTayl9+oGi rcpBgmktni/NTBmpoTYmPGjzi2MonskOQdLIMOB6Kh6VbY20cgZwtHJEKknxM8QaPr4DQHMw/qQW pPE+zk7MbSbJpqSVVSWB6jwOvkTkDqkT/JsVJ7D/4VZHWPCQ5wpObUnpJt2momCCaipi5996wRNp SwT+BKRAQQRJFEjMFMyCFKM2TrkbPvj/CObve6R3ctuSnRjIstC1SHqV0GBa8ow+Z5OGpMBEOcih SrSiUIeU5o3cu6B7/TgWPHBISId8f7atRatahmW4+F4/Wfg+/9htH2mxjS/wSqbfhaqZy0c2xwdy b7jE3TD7V1Ed8caSLS3tRShXSflz/Rvumo/E/FPVJorPtphfVx9LhOd0Rw+qx8mMD5CCjJyiWk0a wyTgEIBhrBP3+3A+aP+CMjolhPwxfQPGVr6GM2sHN+zdob4xGGOEh4Iev7xh5lHtWvcYQCi9JP3h fy69phuvZ+AKaxhRh8wOFMFk6f8+GyRtIo7FmJ/kqOFPS/qbyHVY0qPHd28thqdGKVm+Q//aoaqv pYOJDkvyyYSGSUiGSGUyoWQZklmCGRTSlKEfbwcHaPE1nEG5P+mOwk1zzfiOWjTG+O8g0NocckKY JoaQGhAoUMTs9GuXYbpMjfH9enJ6k9iv41DFVUjgdHcqvScxPQHoxHZXlZ6bIngro6GYsT9LqqVX hOyRsNB0Qnpc3ciSeSFVsSbND/FyRzJX4YHbjyE6IiKiTXlbNP+SlJUz0ml0YqMUwpWow7WByf28 HBwqKpPgThqJRxPDTTeWuI01itNDGOFeZsw0qs1VrdFO69I4LgNh0Dp31kaFN3YdkiAPslurhwrl PmFbitiY+R9zGm1fTEc8TuSG6vC+lWYL+0yZiZs2pSxUnsh4EumntVu2YPZficuxHNHkqQSvIfcT 60HlZkP+9WloW2p/S54Nu5+PX26M0Pwl07qaaLBCyQKlWRWOWhGmhhK22aR+l3I/G/I5LfDpi0rJ AtMPxtImiIRww+wwiAXv/htb5MD/CqLsOZDZm+8XLUFucylCsQojIdWgSpYRoK+qVgjSTCes5IQU 7hRJDDIGMTyNJJjEWBsMtdJKaOk6cdgqcCiHCDKockI6kq5IgRGoVChEpMhQpVNm6e3afi8FN25N x6DlO9uiMi12LGDflCzwVuePdlqa2dSG4Cbbm5Sj7xrKoNFI0OhAVVhp1oIhidGjQZFAUJEpqbHB iAhyCJFoYOiKaLmIIMUNTQkqpKSQgTY0YEb7IGggXYMqZViqTezdrJup4NN7GmHPdqJ0buGtlkch 2QpTYzpu3P/jbHKSFvWjqFoIRrRHI04tGBZBBGiV56Dd2YcRrfi1S2rbE2GK5NMmXKpWjM5ODJTW VKptklMQxmxxgZTE8Gjy4ZohiRtkZuOI5wiS7N4FLjhbuYcDCcWgQF4kDBKVKWgMxxiHArMiMLJW SMwxjCXIYHGDDKgJsSAnCXkbbO+2USmUNDNYDgCvJpRFLSsRsHiKKppVFusKY3m/Oc1r8Ndpx8E1 o7e05RsFpbHYq0obAowS6ZGOYluAumGy0aIQFO/zdeRu1tJxI+g0asEw1Teqb1tUKQgjT0yLcZOG RbMxFBr9UH3rfP2x73pOJLWPeRg0EREkiuUKFEY/xoESlvhGZ/S/+spO/y/zsMTO1W8o0lmP+O8Y 5/66/8YnPN5/vwMuvbu/N9579u/XQMZg5uPhe/99TCJNS3CEKpV9miGFIxcIDBPRVosxqpusfUgh ZTGFMrF0Xwz57rL3Oe2MraqsQSpTCmu+b6ZZimqpqbVopdITiek+AUVWYaMxhe+VdqwlmXNBtaD4 q+jQyvwC4KTOrDhSBbPPmqxoxnnohgPA3aXsyqrgbau4gCX+KjwcA3M4RCEk0dHQwAVA5eC80xJA KDhBREB50mjhv36tGrVr4UoVZ0xEQELkSy3Rs6fDOKP5QB+o/hid8EQP1sL+DJ1KvvXByUWKkO+p sn63Jo/OxEz8/wyI+qxACe0zGbfDfs64Re+Grdw5C8FIEJ1eU3XUbrqIXuug93J4Jykrey6dmbzo Jq7+lAwhdqXHHUPqH8tuELL888dSAg/oea+vuUN69vn5eISfHulUYTbpPWT/E3D5evp6ub4CL1f7 Dn3MBGvwfcLSptBIE+4d79EUTRGRPFEHCih3sKDAwibLb76r3tg23XzW0eVq+8E68/b19Xm8VUen KI56ZIQ9vUNH6iRE3TUhhPOg/5Kg9yibw+B+d8k+f3Px2G0FWJbNsYKysVWSNk/lNon4UDUM1Pqm kKs1UIqYaEmM1ANigoOEm6WzalqYNjhwmm5u/1n/RunRKJ0VCyJVUi2F5hhZBVIjjEMIWF1nLnvo qPDebQHGEBieURfKPzYnukiF2JdKiDsfTy+n8eAHOeM92p+9p/IyLkfoX8U17ENPdt3cyztrIdFY 5/p73p9Pjy7enY0gxFJPeqNUkfts3qSWq1+h52YuN1aVTWF7q0taU735Gj6CkPsHh9QxU4yCw9yX fyZP9B6STSIkFRwTFDa/tzIsSfHJIl9mvE8zk8553LZJwpobu9tjhW/tWxf6o39bzoqirJ3NNztY VNGojGlMQ923ob+tHpjHs8zJmlvOPh1mWaN3IGMbGUE2D0hyRKLCFZVI1pI1rfEZZHCyq8nmYEVZ VQvGNMaMDImyKKHgIowP7Si/A/VJJP0KO+2mkr05lzPDWem/KdmepfdWliH00C3bZ5GeZnnkvUrM mTy28LtbW45QZ5ASiYsC2JIjwWY0pwV5KmlaK2jzzIhyl1HzAUmEpMFi20nFJJXWOU1uqebDE4RT tet7m/RUUKoqkqyRKiilLIlH5yipUMdZgDIKTSgqKFCFiAUDGBR7MDkaUHIZVNYkSfq1E20SGHoF 69leqPiiwmRPpgnCRxHg5scQhVVExZPn93hZsP4U0CIJnlQHjn3pCjT7wtKSJqDcbQaIViBTnOef a0pok0QRoxQ4sJHI2JwgT5QJeUP8EG0LuQobty9oyHxbuGmyh0UbULFI6JYTVmpQKQHrI9qt6wwT PchPMCp+Yzt7TI+Lsxu21+KbHMp849v4LTFYp7GzaLNTSf0NSOJi1KzGkYpu4sPf8FLtN3vHlxrE s+AqrIzWMqOsijm8P3Wc9oQRsH718PC8M9Hj/yHYW5GblVsYaSX1mhlMNmMKKrj8WDx6m3t+dfQe RySSOSySOUib+tsybTrh56UFRyqYHMlslEz3lirGQw/9/xkPZCRGyeudNA7xFf9OxOSv1wnSPZ2Y RoNKvwpYtvZDrUpie0IR4kgc68CcA11H+wTw9Q+HD36cCSyQ/fP3T972k7iev8XhHOhYpadLlj21 FK17MhssbCyVpjGZ6roWJouFP2WaaYYvB+YbI2mzCZMXZqd5DOKQMQ3DzHDuERpFI2cA6M7ozMRe mV4EqcN5iKwSUijywxWJDRCOENOYYg6nDRD8Y6TS0U2rYsBVqVEMxiMrFEKqqkFVSqWrKKWKSqjL CUvWyTShVdrTu4cG3DRmG5wbQbQr94h3IXmMi7m5sI6VMYZIoovI8MTfh4XY3TgdwwGC/sXRpD/u r7FH/1l3R3LHnnnQmrq2aqnNd3fQxZOhYeLin16Wjk2zNOe3KkXG/wh6j/iHzkGBwHQIlVZZSQrz 3PrfN2Z5Htk8XqJkeXY6xM2ZE0ofqslUb3piJGDafKK2KNDYkDHv5xkD3fYBmEzY9ZG1NJt/Ef6H DhZHacRIo7Mj2zvps44isJsKw04Y0VUmptDEJTADWBgwQnhowSKS5wjikzMKs9FjgkIqUeEVJNnB UbJzSIKDaKTaobSNonp21BnxzeabqavLf9jlMieZX2UmLI7Sox4GzWn2ve0+7tP3Lo+0+fsPEsB9 QZg9ZIVBCZDkd/dhsSbJKYzQJlSp6PZ7PG2Q4IkhAC63MwQzIjgZ9Z1CHZI/oJX55iZoofpjkm/T mRo6bGjrrcKlnXMDgIApJvW4eYgk9sz6G3VOgx6awPSdh4N3OQ056+msW+J4pPhJeYnj7/KI+OPa lpE8ux8DnDckj3T3K5yDzWSLZArnXt6UGGokHgr39wbm3ALsPQqG8MP7h8nc5yJOOmetoshULJX8 CYT9CkqhWp3pPl7UYnr+LfvI2DyVCYLgIR/VSQxVQpoH7Hgob5VKJ9uW5FOwx+1f3J80sfHNff5E JnWq7MdfsuGvt0/qm3mun4a+zlDlUNJu/rPO09Sp819NHZhplMxmosnI/BH3/uif28R9x8EJJnYr 6Fg/AoPgUPbNYfbXg/n09rnvE4ebOcIHOT3rUv52eQnnVD/ToH6o+Ifz4nCR9CB+g8DlFiYQSovk GRHUOj63FTJWojWBiEkgroEWTNYaI0QqqupMWKk/ho1TdKGVtFjbka90rZE+FNmkOCzHaVasw7Ok kTZuioer3hf3RuHyCyc1R+BADNyeoSlWQqwjvpJC9Z2tHU7kkdCfl+h+H47W+kwtGmmyQTjIhn4j ClBlLEYGFg4YbaIK0WTmNRUtIf0HYI4KYKYEGtIVFFTSOiXaTeNpSKpxLGFNYZCtijZociu0AbUl KTWLmbE5Am5C4zsbYUBowUiLFEhpsLFEEhHhCDalLcFi3Lg41omiyLW9a3ylNgveyBYjRRRpibV0 VFRly4MbaweQujHAGoFhwskjRGOiHJh2uMMxWXKptQqqZkW2yYUxxoIKBlRcag22hNNlLSYYFVjY rbDVYVpgMWSJisV9zGbYNi1yGNq1bsVbicl1YqpjQ01bEqMliC3DRbiSVTSgwVGRpNGcjUkbCaob G9KSqHDnvJw3uSHCssPSQ4xFqCDjB7TmOi0K92BQiqopn/Qgg/2H201GHMyH43ojCEDOeJEYZn5Y eQ5LLZLbXjcXLVbtH9eg02jBUiO6IxqA84dRx+Ec5mh3Qe/O680m7oZLxhJLKiw0UipFRghhSQjM UXBAWREMJFEyNxCpJCYluAfN7pw9aSRQ3P4WTWjgQswN+/8p8rA7ny+nsxGLWlBGKl3jm2BA0ITY NSJ0Ru/yBhpNNsxpOIw4Ei3sN5xaT09LG446yP+B1mGRYfhhkacI5I5z06giakmQ6dOTz1s9Nowz MaXfwP0/kH/B/Phj8++zdTe0nNcAtKDO3v7ZVGCPBI8oREhEgda6Q+dB/vNkA7pFEKSqIpwxD8Li Jn8H72hipHVJpQqwhWlNPAf3skN4QbLJKokrDCFTHe1AY1JHVJEP9iyQi8tHyhwg06ATx8XPA8Z2 7tjwV+VUkYQloBP9xCOQhhCg5KNUgUC0j/dLgwOS4+8N3fKKfKUerp7h937w9BX1u1Gx+Q9EemfL vGrIi+WRViYoDIWCERgkEiGkIgYlMjISlIkSIKpSkWJYJSCEklHIUMkShQKAKEiFSkCkSSUaUIlY gChIlFiFYgIJAKWJFgmhiSIVCJiBAoJliECIkkYgRKQKUChKFTIHCFaRayBkDDEiGVhmQWIDvH7v VJMFj69Ya9l9eo63S/Gw6jBUllkDEREQEs0gQTMUETJUQSRMEJIzKVCBLKEsjEjAC0MUyJ2TAVCv MfEiNQfAqOaJyK+SLGL8TJM4CcxZI95YRSwRUUkSVSQVSIdkGJ3hiYkRCzRmGEySEQzkREEJBg4y zMtKRo1o0CtVktWfCY2nJt4R/LG4c6WVCS0gECSRE0PZxog4RkwjMOkWsSK4SgqWg1BUhEEE0FCy yg2RonInWoNLrWFDE/AwYGwz9FyIVO8MJlIaJNjQwVBQxJyQOcZYoSRSG/ZxNh3Ei9XAPKSH8D+9 8OoP7FkOyQj5xOZ2f1eEgzRXxw4hJ3Q9UnyuoiGqq1FK54ZFVDiQHhJRBBEJTBDFFQBRBNAyLUtB Qw0EhFDFRVEzEsQRUEkEkEUUkTAypSFUDEQMBSVEMVFDStURRURAD9R1QN1g6wOIiofkCetPv5Ui HSEqInJw3gpyf2k7/v2eAIZvfJEFDwhUE0ihOjBqCdqwk73TUspZt8tddknPNI8jSc3NGOG/wvj0 xFLL84+j8Ld8zhlVlwkM+zGrJJHJZJjasGZsbO51ChD3QDEK1M0mjQiGGCfGD98STo7gCI9Z5RA6 fN3k8jJof1WqCJuOA/gDlm5sKBCH40oMvx5IGlFCEkFFMxONSQzQ6OwPe7cDmEeJwOicK/nlaU2d 6Oxs4bsb90kn5X/k86T2+aBvNCOoNSn3ynA9ggnvGOAXO9FnR93i2D+nat1SDJX9A4R/vOUBg5vV gEhEUoQPnKfx8lYv1pi/hwTgb/q223KogfiHve7sEt+ZPTs3SPYdyChOiOJO4z5PWOu6L2u3WrPT d7uxX97s2gejz2mPuPqttxRKNCNjfmXP6HabLT60UVFNTImhVFoVfMj1nYeTWUb79pw6vFrp7Ovh vDwPR5DFpiaFgeYOEur0Gkwo1paWkrQHVo8tsBwBZizVIVLpPQFxGMaftM2xEQL4Zu8VmFzGtC5y PVzB3uQYgSbNSM2J9/Fgd55BVVMYPoJdIgwZYCHIRLKWQhWrCqXijJxQx16rI0Ky6UNwz12oe2TC f2qn3fU/F/mf8IPjfefGn5I7RZ8lwp2WTSfK5Cp6jg9Jyh/gPle56EyGxRoz6CMYV+Tv9gon7V6m Gv7oTvNKHryIlimiCU2WENaHDb53kO7IO2xAE6sHIALE3dDhoIdLqg1KI7SJIjCpJ5FJJJGKDSMf RHxOLtJSpYtN4khXyHpDv2ZIUPAgEBD/CVmRGgKFUiCIaFFAiAQWIiUYlYkHqgCkOaIz8L1mpsVH zI2yqMNR7L2tnYSdNKMHIynLRohtyNnCHZNGjQlOGsKHZjkREm8alQ5CREpKURMEhKO9wYW2/mN9 2E5kct22kqi1zKqpSimxilKpMIXA1jTcnA2CIiGIYgYCGFCASCFIWFgIIWHfDCmn7dGkfzRLHU5J ONCkpSpJadxIIiJ5tTpBNIuERBBpQTokBpJsbIVIxjd1k0uykjY6IDfjlp36r83kP5j0Yey9qp7T M9R4THU6sygbn2kHeiHTP2SAYKSFAb2NQompMIUEPMA8YoGxB5SI/UoLy/s7U4B6Ta9WOZr3T0k7 pDvPBp850RuqdDqdJhjTrP69e78iz4zuf4ahG1b2WgeEn3eo/ZxP+rj823AB5QLT22GYpzloglMG zpCCHYtz8kWZ7BmkZhs4k01A+dwTR2wYVwYcSXhZoNYH0x1dXt4HOSmQxMpJeO6UnfLYc2mKdhta Id/3/lyWMCY7sUsSwEp6SEx8A9oL2ej4Nj5Uygy3xNNrDZF+b5MDaO+Mb3V4SSdYnu3niO1u2bzX SLVV8NYpjEYjevkrpD4ngg9jKCcg7QiaCFd44Oa7FjA24sC2TlTo1GFpuxo0jVZpjeUMEld5AyQS EkIliAAl5k5DCg+EPUEIFAgf8xPhaoyPmPNCHUYbgxjMIYX5gLmGzWqeu0umPLipIRp1xmTExlIS uAxxpVhZIiyODMmPMkI3CwktR849YOlCieoGqPRW4UhCAQwuLC3COVZSZkg3HdFjwaG2PStGNmoo GNY1K2saKDDClI0qsTTYOQUGSvGUMYmMxg2isqayQGOlkdmMjLjVIRGFlFCBhf49XUJo0nG2RpsK bENaccWP9qLWjQx6UWYw/xGZjaenAjGMTccVOw5rgdmNXQv7HCUmTJs7jsMMZz2CY5PI6GynUhwt pNTvBNI01rMCsqdRpkXCCmI4SjaoNVsmzI+SWMQW1v3shyWKVpyrwdTNnTGRN2K4avXTi7Cci2wO qzhZtyx/P3EzDQmQgBVTmBgoMKQwwMwgzCEKGBgZmRQRTDAYJlFTKU6DGY6tzZwUacNmmzvcJpuc KbqxwTNRaaZTCn8ofcEDNno5FKU6NWyPS4bKmjFbMdm5jdW6zGN9u/GKU71g4aEDsSIvrI5TYcik zjkjaHokHOjN0mRJQhiGMO5AhoHmiGoJ/5hNyWXJVLExUh+NTlvgmywbrI2ezzvYkfHq/EcjzHVv SYeBebzCJKDBhVK0UsttVSO11Up5mK/K9I4TwtSq3Kf9iv3NOrdU2ejxGykD4YnyyVnomYSypNOj WtA4eY4zXgpygoEoi7xaocDqAW6AP7RQ/JzQc4fGQnQnPSyYs03bxl1sZPsU+cj77CSYlJI+0kwb inQsYyqShFfdhh/iR0QB9h0kfrP6n7E+UnIonoRfkfZoqo+C/F5PxSQ88h6CpJHtWJJ/R6J+63T/ s+sbJ7YeuPMJ+8lxPzTd1GLE0TNJEoGA/avgqKdioZKPRShIJGCKYRwO8a1IlWQt0xmKIyyDDMYs SYOCYuMUBgSLDQQjEjoIMUWJYkqpJDMYgpYMFYIAQlW4MEkpHBUD0H7rZUAX8gGFNlUT5Oc4bJEO eNT8MiIaFIlKaUKSmjgKOpo0jJClof9Eck0lSO4iVB4frvdUryquL7/c+9+PIfs2vwB7dvsit2cr xftTqdtLasiP7GGBQAZGTWIyQEK5GQQMJPf3jvkkb7J+R2j2uJIjEi+AzuWDSq1hTnTBqTcdhVdN o81gj1CF/NCpEoUAJSDEIkQYSqZAaIpBxZRDEaCfURsGaDZtMUbKidUptfZZCeaw4o2s+xY0VzWS Nip8So6L5Kw2w4zNCtWBEUDIT5YzNxtsfHbAU4SpDIB+ixJypYsLvKyTb06HUX1qw6dXZWwzlvph hMCTd9YZoTDM0nt4yc2AGEx3mXNz3nXOTbG0Ttcm2JVSFqQU/1qUVJWmJtd5uunexP5Cwc1dJ1c5 4JDmGu44ISZPgkaIaxcjX8/xdyvVN4OSBox5g4hxc9C+2GImCTPP4u/7BUMlDy/5vRNEVMzX4s+D QZEa1lrIiKDR9pT62AVDPyC94VHxC+34y/ltCm5BUgLu2Tl593r4Icc4vCUPR3A/olfCX1EgYBLR Qlr3v2piAuy7IMIHI9d61iGXkOjGPjAllh3H5n5MgOyDC+ljCl52SQbKNFqzRiYnyqY72GRpaFBE GGGioRixwj06wItARBKa22YGoTjaRl1FSkSSwrGEyAwReIfkihF4lVHkbi2yHDvsuhKV7P5Ufkbv +v5tCXlpWMT/BP/hP+F5SbhSEg30QD31x8ZWR2wGUSqs1lxcPeiDxT+QQfvG3wJCQOYRBZXzkmiF VGC5PYBeMBTmGbBoB8YAwA9Eo2LFGoaZJBv9ObMJmbEql+pb3jH0KcWNU4pSHTwRl4g6IB7C0QA1 PrRRD53F4Hc+v5hEE5hjD7Nl0SG2aLENhivRaVLWOH1JK4k8eDDVopJvZJIQj0VEixGrgRtr5oiQ LIWOHAXjT4A2JM4UN4isLjyLGpfSODbaOLHPJR3DQxsoY0btWzZpHI91jWs4DeBJCQIObEORwQ6D YZBb6KSaJlsBkrApPIjJaNHI3YcMlFYEFBQbG5wDYAs5IJcnk4bIOgzLV5sBxQIDAqgMm8QU1Ucn K2JEqmulBbr0IJ2GMYOiB0WeQvuNRW7bEuSDsSCRB/bo5lu4CyhhzNAHB4OIvBIaOdXZRBWjmae5 haUmTXbFmgOTCAQiuwyKk4NNsZW7vTML2kwGJipUzWnjOJ2TecmCmgaSTlZNST8SUjUNLFLa8/XR MGhyHBJOA5qjgO/wmvMQvwiA5RRTBgAuNp4E2crmHB+wXkVD8Dfycv6f4xsOn8Ok+nPm3PBPcPS/ ivFAPVDSIRKn0BKhVEklWESqidj1fGj2T3T3I9BxH18jkEEQp65/g33aGUGiAp6mGbUhfCgQczb8 Je2odF7I+9fZbk7mZhyX7L9BTVb9sgQa5QhVIQrrKOR5tTT7SY30zOHBOaipTDzJVUpVUoqqpKp8 pH+8jcTc5bOXww4a0/FTdQByJzKXh79pNtg+jl951cBdtyYUdFEnzwnuLnl7CAMIQOMwRLUBUFNy cUyD2BZ39PnNGoHSNBCG00GGLtz7f1tnoDYV3YFSGQZS7otZo30Uteqkq93pecUMGbOBoc0cKjWw s3Hxbl+3pneM9B4inMNY9gbEBsBzEkiSw1EZO3ZMP99hMPf4JHwk5N3J5zbq7CrBodjB8XxTLHJx wfSZ4mvIEDzepJLhE8adsg8dt1p3L7oR4yE/KfGIHtQiAkRZBjmTomokvGYP0fFm3gyR9/4I+3Ef Ux32lULZViKslSKIFhKGAYaFImkpaUiQIaUJCYCGCCiZimgaVpZCSJgiloShKEYhEhSSJSJKBoUp Yo68MAhoAcjAJaCZYliIgVL4LE0QWOEwTP0WUSUQyESFUxFALqFRcISSJUYVZZSlUkVgAojCRMSI iFCJaqoJSllqaEKiaAGJFIJKBIhSfsdDMFD+28YYh7l1FhYRwMxHYJcdsQg6AzCUOhV/NLSHVPxb Kvbo6D16m5/3POOBph3d4FXBB4GBhgvQSvYL7yEp9BCgFAJgQlIoKfWQqIdRxf0vXv2T8CeK5Wbt eg5pIP6aI4m1NlhpOJUjEemJP5laR831+V/Kv0rq1PsfYbGkjZ/hmcz0lIfj7JDJEfw85LUWWUoq sSmhGQh/K9097qLVWRixii1UGBRgYjSP0WRQqUrSMMkyJ3GAYRMsSeewloWaGJoqCEJhSglRgQlk loSZIWpQYYYNzDCpWmKKISIgUJUmoIkgkghJFpqQYGISQgGMjCIWgKJlJwgbBAMloYIVphZc4jRG YKY+qRMCKnYlwNicXngiRWAPObDu+70RFe5z07Yjdb20sCk0ZKQKhBKxIfFXL6G72Fls3bsHlLJj 9acfRhamVj2BE0VcgckRVCEhhERUBXFUV4zmqFWViUIc6zoT8XhH3u9jgJ5/NXKb72Qlr3MYtQwC D6iFTySjjMVGwOwYFAi7GMnMxtEOwqJN95Nnpk/XpYVNob7pubGu+P2fNz0Ksi7iHKBqlJIIlNCb Kc06G9HbB1wcGSn4Yu3QmEKqVvYk1WVa29nQjQRJv9h9OegNvVpzdFSaljbdkT76DlTrRvROahPD lknS46K3umWTVDFhKocUHbhiNwTQENt0+7zF44JQ4hIgiy0deUc9o52RyGnc3jE2xxPCk+eQ8w+w 39oPI5HILwhHMxiYk5rwqerQ95+ZRjX52xsZHAg8BfD1e6uGxuo5jhxvT1qh+gkWJVRkJVT2Af/G AqkKExA1AtCJ6BVTeeh4vnNmIvCzMVbnjvQd2729+usMhKU9Bm0aAP7EzkjvToknV74mNNaxodf+ Emwnv8yhu+mfDDnEOOkRPBH/AvAtI7hg4RERXwRhClWyjixEDrDt1s3RxHDeKbbRaYTFyQxh55yY 7Y9KK/D06HqzHK5pmGwaJVcF1jBDowMDRB9JKak7kFFEYeRj1LHZQ4J6T9ohrxojrDXNVN6hobC9 G21XDS9HPg2qqtVUtS1EpEgSFNzES1bqrojBxXa203kNpEo3RiSb8NEfgf8inyjCONDbBGhLtXTj OZRjI4n+2RQqHuRSIjVpMjGgMXaDIowgsChoMQyBpKKNEJoPxoihxBDQ4k1VFyJMZjlzPbE958/z Hq/R53xtjg5bN/s9shq14bxP5x7U6un6d8/np+938nDk5REkpAKd8HxJQFoVoAmE8gSiDkT/b3Th /sI+iP8If6/S+N0+ZJI/mO2JEj1fa9JJwpbar/b8b6yjiefunl2w2lPn+jNSk3IkUhFCERDztXj3 DQqRC+BMOVzUSMMUrl1o2kaWerzzTUUqNnY6oqWDGyhAwoqDHQeUBhxBLm0iFxXQ5kAwMSZAjAwa 2KMIUema6cE0+e3jDTWYqWxNGMkykVdxdRapSWdODzeONpurKY7K/PqTsePUn9MlpmA5BMwaO7Cb pRgsH8roTepfD+nUhS8iSaOrA/uOhFtg+3t4YM8OpMfuRwoxUIDwSmlXAxB1d4a1pyJgGs59C4Cd LStdGg8f/qLcZ3R9wRB69kg4Ya36FQFMr1g0tWlRbZ1nZo00VWkQPUhiFGgKNfv39wwxJXlEG4PE wMIg6JUkaJJKJr1fBGxGP6z+V3nufG8H3QQe5DxIWQjfEwiEaQKTGlsSMq1lH/OtUaWq5dmSO80b d7NJqm7bBrWDf0nefFjSJPtX5T4najrBOo6oO2VCcpZMsEmOhPH72f3bloFwG/cL8P8BwoEcTYSH 6VFFT8B+zMxj/cqO9D8gKzQiJFDZ9Afc4Y8iInTihvgxqY0gCIug7a2KpWMXEkqnqa40sxmLJNta NA6IPpJdmChe4zBaChiBjkTUP1KjX8T6Z+3S8kwn8IYejvTz344om0ASapkqlSJUC+ncHzPw5PSK KZJj8hNyLD1vTJ5tzHZTPTM1pVjLcMIDYqUnKGFGMhFpoKNJlGyEWWYrGJhjEp+F3FOjGOCcJP0w 27MGAVoiHqCQliZu7NsSg2Ch52NK+KmcFCJFEDr5NI0YQ6jQsda0zqFFaQDO7cqsZG0CQTESGFlR uOYCRILOAzGCINKDCp0IEIN3ONRAYDHIZ3MQ2hD2bBkkb8tDjXLAy/FB5knhJBMJMAJd85xZ37J1 diMHcjiQVIyGGDDAWKgZyZoHmtJQIEGEKZAqSTVeVVBFgl4sOppYUJBrFcqcOWMptWN2YupVqWoN mJirsWNN280l6UycLcMTC2LpTKyTWgwwIxIcMLsNZU94YYs7m5a3BjEMNDfnKtZDJCuC00xqBQcX l6ckczW4nu90cGQDCxGWECI7QoGsDFuUzAYEIKSMgPscdGNpoZHAGNQXAOD2OCEw0XYZNluq6QCE MC5SDiiINsN5e840cYQ0QUYMeSjBjrqlTVE0ohmFVKbHGIWmCg1rRtiwrMGK8GFxoaLFpqoDCbGU 0mrjrz1xFitmE5WRaOFjYzHKdB2B7KYgI+ZQz8GxE0WSIoQjsABzRkNDsElEDCGIcE3CZtoyxHak deLoaw2bAkVVLZUWR17gyMY07ITshRFSPQ4/RR1pm4L3yMwGTHoK4w3D2UU6MdudeHHVXD+IiWkr G0k83/Oerc5PRYtjqEowEOgJ7Hn+HS9ZNWB5NHhPktnm8QTIRMi5d2UplzvNGkMGY0BBiNNFhJBt gwqZDbaCFq24vxno/YPOCMTS/zlR7z1Bznaj1nBedX5Os8k6B7N2ZHDWS7MSok9xSbNKmuZsrZsw 9+mydai1F55LzbHKSbB71SNpFhwqaahtzhsnA4YpNMrBBPbx4RsQTJWsXJDkd0bHJpGbemy5AZIk 5shGSxpiDBHM1BUbTk2iTTk41eFXNkkVuUil1sty8SBo3QVtOFSHVSTZ9iS2RS0Wiq+mEfX82485 MjRQh/B6VSlClTZ6U84CD+MqFUJJJtI4Lx4eb0ovRvnvnJ2FOHA8aHmVCeK/6keIRDft8isv+gsq lELEpQTAFCRun88n54PyQn6e9/Vq+/PP5gfI9QRQD3n+7e0CaHaEbkHlYbBsMw4A3fJxPPRsOyy/ qOaqvxP3D4R/SqT/Un5x8wjRXZGPmHmbMkGz2Pe7Q2ifFHQef0KcUVkn86ujbqWVsqIRyXQH+rG4 YOidZCqOJZiv9JJlgY0k4RKAxtQNRmoLB4dCIXIoEDY1yhLg4MQXyYVZloe5iykwE0wGrShDVJhk ipFBQHoyhUbbnI3ZA2CwSX+v7QqwgTQH/LGdHIW2hadmZyTYzIMdxh5ON1VMlWJ+pSw7DjmqkvNi Rjc8jlO6WacDonCYQZsumjI5R/QnAotmhaWwUVVEUlHBFBKbCoJe0UibJOXs45Lyjlrgx3uiNxWk TYFQ3HqhXbG1WBh4mCcDgqm4h8d5v2sjDKTLwdo2AyT9BGV0BimO0tCBsniTJEnTa0MMGqIhQCpB qCfqxDIGkiTRg4JkbTkEkOikGSCGEFUjCHDVNLS9EISY6ngooQospjaTB0zgw8/JZoIEMKl8/o/G qKpmSYfL6cZ+RMxoR0Wh3l6odmuiEQO+wnFvcg4OCdGZjE4QJleSKwJgNzeIYlasNEE8zDUg6JDa RsUTBZoGtGTRCCBwbjaISNQGh5dhSqhqbpWmtqcZGgmxQpqhQUSKZNyIgIYthDETaDA1xvTTcwIo 2NLSGMacYyEayFuBYjIh5DYZ17Tq+fuXp/7vxq8Ha6yDtkqTMcXS7ZBijSYnmWHRAIGlRo8XZVJ0 J5skhmEzIGjBkbWpjxYRxgRDQweChKwjxqtwsZVEKW91gh0MCgWlooMB4YYWtMsjExz2DZ3+Xf+S vB393h1eDtQHjl3ip3g+RhPIyuEEeOC6d+HXgbGJQRHIwMqYKTVZhhGPPMF0pCq+RFnbbOhm4m1b RlBASyTNMGm+llFCNAKSYoAMaVoqCGU0NR1TDGwquYkwzerbU5DeBZJNkGJFQ0lRoiwYkJwRjZu2 jJGoYigWSg0imqgaVYLxgeUY5w5VfAlFaOxOeA+ogkcRJZ60hVH2U6rHY7ZdHcpscvITGjBDYgHE 0WEzREGrDN9Roult4uNXJVbvHojUbB0di1FWFWn66aQ38ZHrlMVVGVMp/Ex6dB7WR3SXUA7GsoUP uSB7ZN4FNrtTwgHlYnL8TDOnGLtiTtWbV5Q5JyBckfBkSYEKDywGrUoOoMJFqGmlYk/lsjxVJt/Q OOOe4k0RVBAkZUEmIhETlrroB5Cw0JvDkD0joawtZVGREqaDRmCUa9rIwKSIUQ0CgMcIQFkSdiLr BpVsVTUtKZHo02FpthS0bI5Pfu/EefsuRqVpZGybvix7nDsnKHvJIzglAeCRiUF2juXd0nSD6jbv 8uYTS+rX/i6+/T+rwnxvZJO13JHOQnupJagfCkSlEOQpf7fkAtCoaXmly5APmPo+Y82nM9IwfXAO GyTFVSUSlFStNN352hsG5ODbgnqVFVVJOr9bmr9XVNLOocOpWmjE5q2U3Pw7vn2OxwmI33RikqoT qsjCpVkTcxhVS7tNnRPlbzOEDg5zYf71Jv4YnapNlSdqblE/qY0qX0w/n+Nps8cMVH+e+8n3O6UH bFkQY45PqWFP4dz79wv8p08DhDse3mBOHT5RFd/Uj9vwtDsLjs8ugkTZKRunZHTfd5NLX6mcHJHr yL9JJ94eAGDzkHLhm+eYiKxK5iz6zMMkGOhWhWjNu9psb3IEGQ24GsWDW7MMVjSFnAkqwi49rTTm 4bq/tJInNxJBHJRuO9ziYfWMGoiwyKBoFE8B8UBx0Iv4gePFf0EgfupBsqIUkrp8YcY08CvEqvOx VKw5tIYslVNKxj5JxPntlMhIO0pGoW3hVVYolWJ4RIWlsFQqoqKxsZG03TFixASRVFMJIkADGxuP I5GitKrzort2T2K7aalirITsexGGj1mSbL4LtOFdsGpepJ6R6ZCfkKJ4xxlwH4C3b7I+2ki1DduH 6E+iwqlSepNHCJvnF936NBsfAShqSuBjyBYvuis1skVy/lTr7+B0L72x/vfsbDqpH8XJGT71mPrT 0E11vw5j7a83mhbkfefjFvnZ6fcmTW0tZJuep83P4labSHnUqkxYitH66Y+bWDU84PlctRIxUjkQ /8hUUWSJixLCKfLBPuUxOZZJCoUSkr/3de3SclKiq72neUix8ZXo7jlZ8GmtN48b/TscGCHCaCMA II5UQSTIyY/xGe+h7hNIafKqBaXzFvMgEZ8+6ZJs0bmCmqifQl9jaonIlm/DQaW9WWvYRuCewIKe qNfYEdFoQPkuRNJZY0IEhFASozoyDc0EciqZ0eiFeIjzObjY1G38N1zdH8fzf4R5289kbKiqlqE+ L9COFDAfdhhANXIxxYZDzDhaMwiN9kR+3B+QdxiGLCKIJOAKYdzHJpAIMwwwnALLCdMuUBwMibwj TUhEo0m0zBqaIZQJAkYbyJoYmaZgZMG2ikgOQUTUYgyXDNadUFQwxpNgQw4GXCXJ24htVkzWVTlk TKSqguoybijQhTFRVFaxuHExMif7jIp07GyjtouCCIORCnIlFDCFI1EH7GpXU3miEYkipDYsQmpY MzDSMhEwJyW2aslsYii1LmBIqihVWJyRTnZPGcG+pJDlUFKNGx5Yjze+G+khu/K4TSiah/tN38p9 ARQz0eTwMIuSwY5hfqtnhjKv6IKYuw0AQGr8bPW/jeABpM5+z5zEBiOnHxjoGcMiOwaSO3+VoMaA +SEsXdY4xRjOOTpXIarttGNkYyIk7JIRCwZW1EIgRCGxpBjHSrFKStbEucjfjQnX60k/esEfLXSC ZJvelh4InaTJ5fVycr4FpcSeIMrt1XfpianDbRMwVrYdPvTUJXj0G3oAhRtsxL/MtGVqVlHpeytH 7ZzbahP/qqeVaRZHgzH1xR763squto/1Kwn9yc/jSJJTydAgfnCkNSvLgntdypvD+jHAhbzGk/fG 2wsJI4ihssTdTaJH+Ndj+CEz7geWYKEKFfoX9QJujuuygYn3Nz8Fn8iib1ld7GSF/fkDukVdsgxb Sb3jMhMLUslUQrpgMLKtim1Za3xooj4Wxkkj9Le+7QfL8l0AE6wAlANFC0kSIBSoJEA0osCPegHY YL4SekI+N3Ttn4cE59ntQ8FJbBUpSpErRkmFi0VYmLIe45PEtSIr6n62n0lMKhMYvyjCnZ9E1ZRz DEbalBgw9yUmGnJ/5NNle0x0dXRsxN1VVValVsqYRVbmNlUUpppWhUYlMSqwwxVY01pKVuw3aYpV NN2m7GGKwc2NlcNn8rGJu2btGJycKxpu03YkxpsqKcKIbFOZVoYDNHBhTRhCkNAzDCFSCcFIIgMT ExjYxmxhnTbZ8nccp6DDM3k2ebbRfTk2urdjWWV3A0MdbgaHEzCyLZECcmJsqrE8LcIG39Gt9xLi bUlb21iYMwYtBwHFuiJa2c3yLMkj0meVNO41NGKjGHgeYmHnCLubsejBdzdvWwYwa4YmzjRZSRuL RLw28EaebwVLyKo4Y4q8sjK2NscrpOGJ3Ow002MViqp0f8nTbeXGfxNXXDrKd5U3nZRa2V3JOY22 uxablVNMeY0im9c22hIVsxCKqlSDDhVt2UAKMe8xro1xYVpYmmloZBsrCo1kmEWSnJJ2uYxsrFVZ kqq8lByTToqabqV2JgqabFaVUmysMLBo0YMQsdTgw0MGjfNqugcypu0J4x6Ew9x3+jA1UFJRRFRo vUolyHRHc4tkfEMR54prEu2jHOE0PPD/H1fzdszOZrWvRmc46JEpLBOD0PhjyJ8aVJ8CSUNybose JTxaY85zjhP/wtWJN3fifZv8qSIWB8nrnyjvQfTInEKRuHbYk905weVFWJObR9U/Bfs5tbEMZ88F 5jCYgkOiWjA0OBrTzFQwlYnMBDAd0akmC7fElDSH9ZouBhErYmxJooeR2cRA5kk0FklkidDkCHYz AUWs0zI6XGQUQxJqNJh0wircSghIQhfvMW0GVyowJyXCIRIOOR4uRTwjRzodSzbVERJaGIkGiIwV NjqfVhQ4zvuV1zotS6W10ZilarK7e1tqHstKPal0pNTMRHBigdBqJfwSu9ABEQrC35kMIzfIti+l FR6Jf9PVtsTZqO82aZFZ7OmTg4WVWmvBeLHJJopMZsSb9YznTIXhOZKrwYYiaGNPJbNJlzZOW5zG omtDSjXJG6NypGuCaNNhCFNFSaVDByjDCYILGm8amhIcZweS8GjWzTzgTrP29RaxgiTkXcChkByx bVhAoh0n7VBWhsE34M4YbLSYNWRsHnDaJtJiwpRKvRuyhtjdk1Uu6Ibk5mDVaGwIIR2BA50XYOdI 4aGlbOK/yTSy552QpHaGSRrORFBj0TbVZMBZkcYmoHaZOoTf3hDcOhOV3sTNxf1LjozELsFBMeiM 6zmRGjO7DRu7jkSxxPMQQJG3B2tky+AcSZG3J/1BICx/t5M65FzYdnwI9cG3k/NNQb4oHxn9fx3R /JJ+hnHR8S5OPw7tC22eKepx9Mh4vFrrSyaucDKQrS2Mh9dJUMYwY8cG28YQkj9gx1OioIC5fy+8 nLcPkJeCptGHDer84voPZ6UiU6nvmg9fst/baTVYNwbhnuDPMhoqSkTBksfj0gG3HLLkf28gMdxm UV43MGwlADFTBw5iShy0bGiDU2g1tdJYYbDJY3iSo14fZ6vHPLR+6/DdY4oekIkllCJChWJUEopF +HA/HsfsJ9fQ3QTJ/xPQLIkKRUnh1R/SWI354Z7AyQPH0+rN58lbtmG995HxVpuctyafom8hym29 51Vn55IQSKeUebp+s6mDpJU7Cx/Ju6TQQqqnIw7nUe4D9c8T363WIYginwo6BQNAqJziaxPqfd4/ 0ZWJxEHw/RYc0OiZQfIo8iBM9f8miRrYVZKR42ZT6s9T8aSOjeUdQfe0keNbHR7kajz3h7M+lrWk 51D012odyyTw7ibLK7/s+E33a3vgm6yHnUkYbRB7u+NtT4ce5y7HX/XiO+pe9FfcJIOfnnY25p/v 4SRsbIx9Z+YgpRIVwgxQQTAOhXmc40YQQKjqRIm7zFO0kRTUwQBGxiCSTvZKQUusxKZYhImGMkwq RQgksGVUYBBgQgVorAbqZY4Uo4ZYDNYGOhNKRmtFJlOYJkApvLoJNpRyViQpGkWhKUYkBoVfDADB gmmIgkFpH5/sf7Wo5VY8RicFJbFsktE8ykZR2LZkTId1CTJ2pkngD40hG8wajd3j2t4Uck+Mjccf GhiSc01fiKyerktdfrbBT1Kj3v+t5BQTo9YYYlKCKczZxVH5CEwjwoHuH8OyDYVe7gkCLERxTbPN o+bfF5hiZ0wybHFyuDECwcbhB9+7aO59+e2Jx24wsZjJbGjWRaRoKJVkSTd+K1Sfglk2Q2GFu49R 7WvWaZKWqpX5m0WZjTGVkIfXrWFNJRsfRo0autoi/x9v+Bp35/stKdHtT3JC0RARPoE6ViwC6F/h RzlrnjPLMvSxAVNQy2cEdneiPXUB8Co5X+iqfwwjQ7ixPyvhfKV8Hl48fZ3DOV/DZ902WHaqLesY ww2foqc3WGI+5T2K2Vs2aPVWvn1u+Eqbp4S7+rE0lNvnCV5361Ubfw2btdWtqtG+SeBY22OwMO0y qHZaCUGiMBNrRavR0c5tOFjnj9C6W/h7DzQmj0HROpO4PPggaNjwQ7vInEneO37Oz0pv8jHSR4/q yYqvT7Job02ZHzxo2rHkMcL+X0N0HI+QOAkaSpomikgfzBH2hozop60REzInkzjBI35epGpGnHU7 3HvanAPhkqfHEk3fWh+9H2+LANiXzBraiYxNIXmJ1jg7l4ddUzRSi1TAZTyZAMB6Il5mdrE02bIp on9Ht9vrOlOJ0wnBg+EJ02mGX7PDsIWzfeGG6sFuM++wiAYIZ8i0dubQiVf39iXKRNfSEDZ26waW L63lD4ez004aEeTlorzrnQjZSKxqlbLj7eJ4U62euPQcqYhHs0oIizXXgvIg0OFYIEB6yQThIHQR Axe0g5Ie/26Ro0eosGLcOS6MwikkIhigwgmJsSaaH7+4v3bYTtMw6YksSz3lNh62otMMbdkVK2MM eSjxtsFAYTYsiAuRyeOJQ33+Sw5W5GY4jwQREY9aoQqSohg727RNqjBmCZNkM3xiGxRJtCckon8u vzSSJUnecnQNTiIQMkc5Su0hRUQ0jSMFSZiRhC9VmpqJn8RYjX792O0FoOsJjCiqiCDgvrCVaR/L pISQ1G1NpnrMRXe2ngZpvdKNxWwzJpYyzUKxUJEtjaSM0CoaIKadY2jbuKaEaGCFOpQgaiYkk5EF Hqyi8rvfulpeW0glAjksKoqsabvlSsRoMnwpqJHTsyfEkNNaGfpx4qTSu3+0S9a+5PFtJOJpp2ud fc6MdrzP+M8XlHpK09SeeQ6KkniWRt8XzJs5guA9I0HrmeXBjGfnNatI0KgyYJQRCNLGjaSpImWJ YYYmlI2MMlhlhKAhSCaEIYPUa1oKsTKyhQrViJtYaWbYTCqiHMMcI1hhDrKyGNHt22AiIlq2Y4cN mytqsReIqMWRVUVLAGsAxCAlSYicwxGjMHIkzlkk3U2FKkWJsqYlhSpsYDgpEMEsEJRrE30mp0kw FYVjfbRpVS2yrqrvu2NlUVYMrZWNRkordYjFXGGSWSsxiwZMDc0ulglJGWAos30aNxjSBjjY8iDf ZQGJgtR6NzfFZpQpDQMowoyDrZ/xKOE2wm6a4R49aMbS2SE4c2ziG5w10moOFjSiOSrShArBDEls yDLxTcMWIKbboyo3qsoQsdarAdtSa3CBiwZCZGFLiLTnkyaK5RHnY04LbujC2xDRm9Om0Gt5GlFF KeGHEcVzhpxKGmkhqEh0MdTjF/qCIs2dMxJI80MxQ0iBFDl239RH9s4BZvLQMZCgcZwOtYihpmNj QY2jYLExa1mgcoiRySgcHGxUsSOXZc8IclhIRQOvAGYkUJtCINx7MMyIrAg00wWmSFrcLbzi+azY CYwNk9iaDUwCbZoxmCizDMJo3DYuiIyDLQaAIUhC77EpqE0UiaqZJgXahG8EPJdBA0bENnpC6iYb owNyQ0VmFFDHByiZII5lqJoQJFQiSoHhgkc5JC5YcqyTbnmgAg4NjCsIITWOM7ySW7DEkx4TSNKC o0IkvLAroEDJKoZi0G+qbMILbpqhdCjBibehMgD3IqNDG0biwqqIQDTTaCFiMUva1B3A1Q1wEDAM EcbRYAzMGbkMFQKQ0lNIwg0VUmqUqcFrsMRWVYUOAe6xjDNY0GMEYDQKp0GWBiC05LKcQNAMBwtI UNGD4prCvMm4w54ilxSC2mEWMFIOJ8WCwBxDU0iEKatGYDDgpRXQI06IabTVxPKhkmEIDG1IBkIG JmrRVLSMhMCOcKEoyA2BUMW1ibAozY3imwmrACJ1Yb5nCY5DSmQYMbmKUHy2Ldh7pmOgsUlQDW28 SWmIWgaUGg0y4XSULhE2mmjQNUpYMkjm/YcTW0Wo4XFXfhl3Ym2iqsxg0iKzKox4hpG8ibBlnehk HSBYIIY/8OSgokHHAQzNjROPQJiBaVhqRBWa4hWBZTQzCCiGZChsjQQYXBlUIKujiOBrziD8rImM klJAYDVGmN2IK0BxhVcYoMYyRFhVAZHXSlZWsIlQyOavZoZZQbG2MiCwuEzSwDbAbYtp+tDqQRsa mqHhk6BCZvmBxzH6bf9tZ01aYHVoZT9gHuaNrlCGPGYjM2WMxQTJERqOQRApPdiJm9qqjN1xU2hR yEpISMgwSQp2zEhkNQa3w1dnXjWxOXuEpxyUhhgwLAcTHjTrRNgMI0EyBh2OY3Q55gYAGNbtpjZD alU5qy4szfDN8y9WMOFi0DaNEvILAml9hSZn9/+//b/fuIb8zDpHbsRlJRlExKYoyyWoH3U+NrPN y1U8XgbyVjCKw8hsk9skPQyWQPsdfX5+SdXOpRiQYEZZd5pBFsvO9c7xmtTQDSttVaG0RyFIA2cj YjpN1WSKqrNmYcKMlG6sq03WJgxIMQEREERFREgHJlMBI0PDE17HAHZE9Iu9U/sw3ltxaQi5Hci8 INthrgTqMIkGJyjEudRhkJasGm2Jm5Jk33Ir3T/nf5NJG6e9g4UdAwowJMqB2B1dtsg2P3YBpIVB xmkDDmD1HSdPBT2znJwwmajIyMBpVglxwxzCF+5830djZngauDXFqNCuwMAJDIgQ5E75sUp+GGjT OoIaSQmhK0VA/HaP2PefVcbr46VUIJcs2cEmwZuKO6YmB+DsWU2KYcZg2IRi41bmaIKeCE2qTSOg x5Svhcn4CuwrCmITo7FPvOzRe6Plcfx9+PtsP2PHMYcvrgbsY640noiJSEJzxfUY3+e3EpTsenLx oRMah32/srTJDJN24upMJD3zpi2sWjW+9wNDUjI+QMxpOZa1ocK6hxrLzASBJumJtas8DRhoTAhc jEggQMhmQHs4aZMEseh3xmYqDnnpQ2IT21ybZhVOWTpro3qc9Ojznznc0wf1nU7v1THN1OTWDWQX eW92ZldHCqqqVIpHdg7J8vGHKPJWYn+sk2iY/Pdhv6bl+ru05uAzeJU4ZjgnI795sqhzJAb1/BlO Q8CSJ6ngPAkRu5Tn8f1+1kH2LG3tDAHkeghnH+9N1wIXwhU7OQG0GWWVZB1ElmgpGybTlGjtqa2Z 9GqhY0RKsIff1BaNRJaENgM1hBCxttGK2sBN1gXQSYmDrRjAaxZUjkyGlU3oAU5yIv20PiOoO4Gw 88XLSe17yQ+XfgRO0OSj5LRo7V1AQQsW7G2I2jYdjDZjHTPvhwNELtmjJbbNjaQyUNpUyQdTmGDD YzJ+pjJioyUq2vm2ZouUbtMFzABghBiHU6pnRLokApNJowM0pokx1KRhKYQmTqMhcBtgh2KsigyM hLYDCDgKDQDiYYNoZWJShMTBDXGtOSBFqlnJtrWTGNxpVamUyLGINBJ6+HYTU7FwDpUxkJ1gpgQP BpHWQRj97jDY2sGH6miW2KsiqhDDLDCguIaEE4NIegkDJFskbCNpAOdi2Gl0rSxGtXE/k+XW07qz ihwASKlAqMSgUHCoaEcYNjB0aJcChXRZAQ6M0YNQlESLEAUIkRAeGGNjdhpRZERaFlWtimKtlsg9 0OERCESRMZGQQwSMkqRMMLJqMJSQYKChoCppJiWoIgycn+7FRxREiUAiIEJTUqbzkkEPjRPiqJ5M 5/LwVHIKXn7Qx6mIG++1BQ0iklFxjIVRjgIh/t7/SCnxPYbj5gI/mJV03YbtGNm3zpY3bN3BkD/+ 2mmpDtf0Mg5Czx8E8FZYxJlp6Xmyn39HF4k0x5oSPp+/IjccynPn+KN1d3tvdn21jxvpeEskpBlW gKa9HnjfDwW0NUXNmgaOfmgnOEcjV/Z/n9LwbekXkD/OGgcBp8ngaEVRbvHyvZFVL2T1rAxevChx BHp96o8ImYgazo8R8vEqmkVlKvG92DwHnTbVGgxkLEbMRZdq43Rz99iD30CTJEKK/JZMOz5zFUU0 ANDSDMAI0QDKlJSDECCRIESBEAVShEgpSq95OVIhQpEDASiMQiRBUSkJCifsJFQx5KNIYBYYLiEC HwhR09Qhs6VA8Fn5ktPk2cETsTxlkNHMkT7JOYeDnyqGByIC394QziFStsMqujQg1BWbZtsS7A4B uJg0AdEV3tEI/LHV2NghXfANg8LZTxSBiKoJglSJBkqVIlKBIhpUI4nnsNb/FL8birLZngSmioLm BNVjSO6ZgjWQA/UfkA2UXeFEA3GDABOKmYVjEk6kn0lhBViRXy+/0zkd3NMqOjvwTqsc3tpaWpaL V9rtbfoqQ/K7JH32SdVGWCuuJI9x4z7TtNJVSq/92Iwn5orFVKl/7sn+upWh2f9SOoX9gEnkJUS7 CKJTqJZkJMVX7Ir6Gp4EInSu1Sk/vKmDUMGvuZJqiT8a/dRw/oNRT8iNNlc8cJlMf7T4E6cGw+qV L9b9w7my4PwDWJiR/pOJsidpUtl5zpzYaxicm72IfS2+cfnfiVWNlvDyJMflT/T/pPz8T9NHWx/S Kf0FfcNHzPI+RZ2d3f5mas0bTpMf72fyLJVR+xuk6IsNPTFe5r1a6Ph20cVyIndNmxwzcCbz+tDr 01eCntf50/BRNw9IF+hVNHS6gpIbIn8ZCHBQSZCkSpSERBFLRSHvhHEhMgcISkiQCJSIszGGIHxk AwlWtR7zA+KScBP6YZpmp6+bNF9/ji32zbbCu2WysrtluR0mtQjzCEga9/k38y+kHT0FfbPYW98P zB5DqIeAvpfMnI9BQNQKlSrSCct2z/S8OHv9j2wq2SI/W/THc2J9Td3U75YjeJ3Ondrv4OiylzWR pGNhuMwGCVGgnkMC4VowKiGoRQuIwYNJMGIMKnEAwrkuUJhA2k1xm0NCmbrgq0hEu8J3Ox7mPTxZ sz7vAgcw5o9iaNDQlARUrxddLD99kiUqTNycBbmq0GjeSKqqtSrNQx2Htn1G0cuz0dnw49nseXJz AUgzCqMEgRKPWGYmGIGSCiZCrBOMJB5jDUiQkHWbCMqPFB+xtP4ItU83wVQotKmT6y5pygXMIwVq tyymi060OlRmCGFYDCphQJSUjTiIraNDHIEwEFaMHGiDVgyaw0Q6KViqUilbMMSwgyCUgCaIko1C ZBOmwiCiEjAgMySwHDDKYKDIwIlMaZYTNYaITgyCaUUJWoEYEBqtHwU9LwMUIZJwN9AImhZlgpIg yE3t8wNvQcGDrHDLKyZgcwWVkhOINayIUlM0R2DtEhCJsOg1I1inPc2CSTtUq4mVhF7AIOUbQamB YWyRyLIxRajclJJo4qKlsinEIVNoRUk2uygwSavN+++hfsPbvIL/Q580ptR2xUhMqdcxW7M0RqmL DNMaItOIUAERDAKwPyqKMkdbZBNLh86CPbIBL8nJNtSTppmnCDlBOiamPkLCEwOA7AZ8Qvr9nX37 hB5p5miEcQVhlI5Q7rDUlPyO57v5vWfkTwp6ZMRsUmuyeeElpSv1F+B+sZGUnO/a/s7jwd511T75 7n2/Ie5VnV8ugaSqo7KP1KaqqVR71TSyarn0xpwVU5sZzXZGEsQaAkYiJCIhijRqP8I0M6MUTZkW hSbsIQwgo2IyKM2jHCIkNEJLC9JBCIcIdowMGqCOYjnaGxSbmc2UpoLRhEkRoHAlwkTwJU7A0aQy tGIpFFSSMKYhpiTJFEUjKRGFSTZDkxJtROXS3mZ7d05tzabThJlcumOSlWm1WdIjIz/KbNE/9bue GGy9bIxKLtn8jUwalHarXhNSw69eNyNxtkJxLUc3/lhMqOak2Xk65G68VMN4wY5TTdsy8i45ueOW yP9JUAyFHadoFgZMczgHzYu5DubYo7zEGtsSJR1KkYYjqCCAcNQF1ZmoEE1TUAbQnTg3KYCGPdpD yITr1MTxk3VpB6DhtoiMdzbLm89OIyTJFVNqxXnxnUvVW5VOWQyzdeiCkmCk6yw2dF404Cya3sYe bmOS96w2zJCy9NZeZzVs0jq5NtcbMk6K4s3S5Sa1BjvpHBtkmyqplZK3U7FhMSo6XhvI4mo0azft KGhMSbrY0u02WFF0NwtDjWJFAXRnZoxxmRuSxh0HVQaJLZJSkhY4EGQHAkazu5rxFmC7ORgqJsN3 ZSWwu/062Vubcd7kOyizsZ4SWSczosSqi14R5/i7PPycncYxKqmCphPMMdL2eMChJSnFkSBiMAyB TmCYhZzpZIs47LB8KHYtMMmRpMw55LOxybs/eM3qTAzqzEdrjHb9k7R1bRHgxExDzWSOnVpz1w6L iHMmzlYtbak7lTDjgeEyI5zhBZYjtUf8EebXRXZjqrA6qO1UxTFiq2MSvFhPz6bPu/h/Db4YnROI mqf0sME9BPWhUTILSxDcGHYIelhDv8T/Aep6vOI6/9hkiFsIEkAE17v/c0pEyEsEGgSUY72T8fXC frz0vYlb5BI/OUfmuqqkn1mvrdkRNgIgBSIgWFYYIYVK4JUVEsVRST9SOTSoqNPsfscGP2yQR3pw sSpcR3g3+Ned+Puzc8VSIfOBAHq0Y0J6GFWgR3dCPepoB2kBNbx3hKp0J8h3ngS386TEsKZKmUYx iyUpRKWVVLEiqCqg/jkKTOKH0IsLFc/9zYaKEIgzEwpBnWLk4CSOasIZGlLh1hqIWYMEwxSowNjD QRIyEKEYRkjIoroGKuEtKkijmxHJJ1RGJEcoWlpiBhmCEWIKlJRkgEKGZiHx/69aJCmaDfWdCcF5 ge4fhfJcETq8xH5UnXB+6yJIf6qSNmpG+++c/2C55BOng+nQGVH2baT1fO+Bmlqnz/435RsofQxh /chy35dD0Jh+VMohZUqD2vmpF+dcEVYiE+dhjyEJBX2wfm9vB+89qP5FQDvJQHmA/DsNyMG3QP4j +sCKKKakIJmAISJUmQZkoh6NwIdC+1BlOgiU87zu755dvoMmQTR8scxsqSdak8aSRVRIkkJBKQQl BElORhBKQkpLMJERLBIxAEjRlkFDDMrEWYhHlM62XZFUiwWIWFQc4T1JNxLLAbHO+iH3ylJkr/ZH gRHYOwyLo0mjQxUrD5PibfDx+P5MM3fiHQ6Gm5oxswph/iQ2OT/9g0AMRn8P5jRo4BLe10EehfDR E8zzx6jbwJ/s3j4j3JD8lKvEj2JFsnxnQeUqhQi0CiRIjcdUU9gqHrh2lyEOmBDRJu4h4JiCJpLw wxKg2bK2ROFgbo35IyPhwyKZZVFYuFWVQqpVZScvk0GhDfyocth8kjLEBJDIwsKEQkQpANASUoSE AbQNUihkikkVYiUUqqLIiklAUZIGn7/YH4m7lZyORlIEVDBEwpQOTZiUIE+YwiXAgbZIWPWpMU8D NNVRk4pkLViCA5E5QRDIkEi8pDIllpFIICrQ4VjDELqQaBMKKNGCOEMszmJAYGAwpDkKOTUQpEgS QHvk4l7JXcBchDzM/yYhiDkUGVDlpVPmk7IA7ISqXOUeOvBlENw0Jj3FQaCByF3umDtUNYhhAG0x G4lE4yI6sCHpAIuxIK7kKaWQ/QkPOBPIwjdJYCo4ZILIkidnRLHrWqT2Fgqu/blDET/iulTSxiky lpYgoMtGsB0eKTJD7owlP3mGS9ccSuFVMZKWeBnhxjTGSm0RooTeWFFd52x5cTnze7k70Q9qlLbB EJBRA1STAEBMwQECEAMsgytFFETEg0rSAzA1So9ohCADxz8rgjkYQZCyor3RiMlToRO0jfZxWuyI e1ZE3gA85uocIHYRAVBMLDRUlKzC/WdTs8zzAK+aApF7pBMIQIhKQDxXn0slMwjBUEjgFxcIJgQJ CETs7cRUNQlCMJPADg954H/MgjnQwZJGP2YnkA8adjP6RqTAjnIcYHQEUdnFe8JSUJJkJYgJJISh IISlA/Ez67p4q0UkmlkeieDnHRVFVar8fX3aHtDlXQTp0YiiIIKtSYRyIxI+p8xpHZZRdxwU6yeQ egj8ccApPGQYsXTBKChycaCBdTqCWJhh/i2xG9ETa/AG0PxvxGPqRU/crZUe16ZyZxFwnSFCNn2b HhQw0d4klQXV5J4ozpJweXyw4k/kaSf4fe8HR/csSf/uKR8xKB+Unyfe9YdgL4ivxBCxKSKRX858 PkOk+xfkxOcX4jDYyWfXY79lbalHcmLg/7SQ3nSqbm0FmMJpZIsEQbG1xQy4mchwabbuBSEEoJoN aRwdEq5BTQmORjoMxdW1iE90OS2xYrQFI8waTADIdEgQSvW4jUlIWhTBwgITckxEN7EELoT5jwDc Zyu+/0Uo0aE2kMYMYjscZpA4Q5iolVYQQxoRxFC7lDozhmgNQRBgbDgRxMG07SJZVAMCyGBEtGkT NOViNNJaaBPIJD4MMQEoTIpHIQM5lPpDMQrUg165MhnLEEzAhqmmJiSigIVeYwBgPPhTSO7id5fb evgY7854MEigqgpkOQpRImIaAJCFhTESedJ/LsTZPE/PfRgxLPwH/s1Ox8pSV+HknJT/IOE1dXAk SJC+oHLRaJwY1Eyd+YETORQ1oDMMMw1s/rLQUpfHIjI44MOG+m9psb0mhk1owFCiaCCYRv5xLswK IUFih+fy5PLYfHqBDxECB3HMi8mQOZWX5CVDysJZNjvk1kJ/9PI2B04RJvPLIyp+PHYqakQva9qD 8dQ7anChpWCwjIEaXAZQwSV0EOSACfZUomRSlAJUhK0AeG5ixsJ5BdIPEo2RgbiZqQ7w6NKtKUlC IoqqIgIKKHATtv+3dma+398H0LIsykjgV2UJG8a/AnYB07Dt2EmWhWkVw9f3sDfi68gSVcEqtQZg cqZTLoLd2TqvRaHUv97MPmUYU0ZTlXQNRD5yv7fM5wuhCEOQCA5NEDkDjoUBlITAQ9A7J+T3oHUe Yc4uD8vz5c3AgEIQcIkk5lMfKt8Rra1Hr83l3PKHhiIf7JEfx1CD4woEbsU23Gjm8uDza7fMvper unwNV5iUPiTaNcyFNjVC7YeSTjli6JDgiRS4PVkTP7zEco+ty+DTJ8DJj0qnnbGMKg/1Vbh5Ol2q vxBt9Q+pPFTbbEdwDwOc7mTWI/A5Nk0VTeyP5+GH2yiROw3hBYJkwRxBj+CK0kel2uuL/bzgflU9 tkkyxB7aIfzFkjWsQ0lIYJE0Qo7RNg46tJ+B0yPbuA2ImhjKLKEWImCbTlRABDEohnYXErsd6xPQ aUuMYWJatLmMq0fhKuJsbdGhHkzDDwDoVDmHQc55GEI0PicxNz33ye1QP+cjQrASpgfrKNhznEVX OYrMLGYpYwxLrsa+YgipIhKCJvOYGQUQxMtFAEzkUCYUZhVZKaMc3F+o+/Uc6lWKeqmSpZDz7BHQ TyqH5IKBox3ov7WUDUq9g9zF+ZhkBFhaTrrfiT8JKiiyFVYTfvbZy4O9fidcWmtfhTZIkcvqn6nl v2dTZj1FmlIprICacoqIC/6nophxgsFSlMwSExUUdCBCEgGURSGG+9Y2wbSbXGzbaxzZjjG3yjXO bq/2qKodJ2yfhJ3Lsr+wJBfqAhZQU+s/kBcD4BsMT8jPvMf1lGK2brPOHsVIR64+CPPbAzURESVF 80AWDgJ8/JPVCnuKLOEGx7ghcgz+rzdZvYZdYMU3A2+m0m8dKlEGiLGWBIUaaGYWUgh4aNBGJsER Oy6NoYgJmIqhUT5pS+T6XQZq0tqUQ4OQ3PYQ5CJ8Ekd1TFkWpcZMpVYsxQqkG7WRpTUMsXGN2m5c WVkYU0VB7hGUQvd4MRRP8BR6rgVOOcS2o5UkZRr8kTkhzoiMXoJT6/l9hxcJxsH6oUGZopTRvhtq XFL6Irh+w2nm+Cuj6nUyIyi8vNs4dOQ3HkvIJBKGNucEkuowzMPKBOh+Tqmlb327mk7IvQV1m22m SOIvdEYUq3eqf1eAQouvbRcbkODqxw8vl7sWafiBj65cpwNnhul1se1ixi6DQlqHXRnctTt0blyF MjyGjySYTZJMGJIYRKCCncyeQsvoZyrqR2LbLozbjy5JggcNicuB4IYl6k5agnDlUgaYIHJRzkds ostOOswRZR7rhrHQnAWwrJEiYDlyQihNTI2bLkYHdbbQ1AbTHODEOwbH2iHF5uSqSx8FyOXzs5HX kjeSutEGEhApY0sCwTxR2l3R2T/GC6s5eXa13Xdu7Dy7PP5VwclqIhlt/Rr7BRrg4+QG50BY5GLl iCkHcBb9X8oafiWp/syWUw/QtElQ4IbrKSEQct9jfyHTT47eQeezF5k8yYdpK4MJBLj60GvTGN6E xDuDUEmm/6h9Q3LMH0wUAm7h9Fj/a7nuHcexE/y0aOX8g9wuBiS+WfEgnd54ry826eBvFRaKpaS1 JeK7KG1mfpfKcBXsEGGVRHDKyxfk7bgG90RvD/KqF4vt5Yn40rSnaZGTzT0602GhlnneI2ZEjmj0 GiiA2xIE5skUS54uM4OVhtoEb84GmjiNYNKTaUjchJqYjYAh49YB7E5zafSK/GQX5hgO9EPtIS22 eMRyfq7Wk7DrUd2jJHEdLE7Pn3jtJ8ionaIJHGjkP2Ko+xfkWSnYMUwQxqDFk+y0NJAdXH8XBGFg GEwcfu/8jK0eMgfQk/hElmYoQ/SC/+Z/iaHYB7EIDgnvPies2X9mGujoVbycNwbmN7Cg3VMm+4DV IYEYMwINUbGJ+QaZIxSYwU4XFsr6GskdLwrYe/l1a/W25cUqG0gbRyxxIrpTdJDI6FTY0JoZOHGJ vrJlTZzYdGNJkRNnNOnGNWstIPxuRygNRJJXIiJYlVgkiISVSAgYtHzpx75KHaSngAxxzU8rry3z eWehinn6v2i+T2KgY1vjm/w6MbGQSwgW3G2CGQQ44yQUDBkYr0W/W1RFTFSZ4aD6ts9qftiPVyvT bnxgXKkifnqSSojSHCwB936CCCJhYFL0nk3P2GlUerLrDszTqD26eK9RlBRlZ1H4g7SGYAiT6FLD CFxgJPNDqI+LYdRKLQBVqXySOH2QEPupI90thOe8epfRXNVI473wDg5AbyIFKJEon7wSYBkReUCu hexKhDnBYmOrTQ3SEVzaxlarPhbm0libKFVaeRoGDGNK0SE5J7rKJkkBHQZ/PQ6MVW478k80akTi WevxPCeao8lnl3B8MNJqyHooes+oUUwAS0+QaAYQuC2YL8kThqRR71DvkocXn4hi7hrk+dIPUGGi H9StMYxEk00YjT632SSeD2MNMcmMcOw2TwnuR6okgPg08/vjlTVnHgfTHWDmJF6TD5y86Hfgmw9b xO0PIr5u64ejWC9kRH02jIM3cpyqDKYNnzjnowzpYnQBhwR63cl5U9u6HmYXWjRoH0ZotCbGsTJK oshN6kZdSopUKKlCjsSJJNM4zPNLKqhVMTEJziykcehPSRzTfZXDUns6z1dp+E12Jwe9OW32uwfM d52Bufpv1G5uxoL6sihovwSP4XQJ/jnWPjfKYJo+86F4Gjej5/MoOodSDz8eEW/+dZx2D08znqVV l0yqxoyJtLPpVvTdFxTbGkm56MZac3HPK7rGjnxJMUqT6SOjQabMJElkrm1CZTZUqlpMRQyZkSrK SsMMUVSQxgLA2+S6D1nyJdG/d8kc7TAu3iZ0VJ/obiR7klVw2ZJGMdBzbNmkqiwKCYzBmDGYdTjl v8W/uRFYI3/gRVhLdGJhDozKYjaMJN3/H6ua9xCfj7gATeJh1gKqKvoMOkvRreRh47BwthtzQIHy LAE60+eME+WIoiJQmQMlCSAghpgRgH0MGhJAeEzy9h3MZU5JbcS4h8qD0dyfCU97yxNIkbB8KpWk xTwTHYGMCqJj+GGmsPSM1fQyZDym+ydCf56k4l+P2bmnzip2HYuMNsl4qYUG4YXH3Pl2H+aD7vLB 6yp6T5gfOa/Nv5tVVd+atV7Fk1eJvmp8YfMbmAvkL+QDuA9S6+J9Dr9e09q82xj9yyGrHqeDiSNM rytpw6GB1mYpucPpdE38xC9cHLkPcO3dW5H0yeuED85c+WDtA/BGSoZsvL6vuZ7J7uhoNHI7QEFl DkDWmDANBVPd4gqnKqowzAJ7nVEeUpE8PV8mojgp2PHBDpJymLyP8U5FBHvXznjPlkIEJc95rIjx a+TfTQmKlMi3I7MUePhOAJ5BsdmlxUPXyw4KnQmE7IaVhJYj2T0O12uryck5J3IkTB1TdYyqi1wr Vh7OH60abJwbKgDQpsaVDWwYOLRC6jJ4sLfbCmSJIWhq0QDhEGFghERASSmBseUV7YPbh0FpVfl9 hiBtbsy4ZcvhTUjx6O460a38ci3ubiPrkSNt3x0tT5J6WSVJYm7k6ND1Kf6VfOeJD5vyPUEO6Uwn CVwgckGP2RiOoIhoQAOxrS9c1GvDqfgdYTVMNBBBEMRAD4PHtIPGeQ5zljiP+JAdBGiQ6gzwfSF1 dUhRNINJSrSwsjhvZWQT408PXH1eHO/YM222eZAUhVV/PygoiS/EHxG4JzijhioROakQkSqkdo4R ohQC0DJNQko3tBMg+f7bCxNAnkKSqqxCxg+8QuF+FwITAVA5S/7/fcCUiKiI7VntPMgfyzA8UEoF Nv2gfBSiZXY2UDaQjpfimHa97E0RphinSdv9T459rs82HxVauPq0Z8jgnhjTdI1DYoEYMYDHjCCZ EMTMB1F+QiCLfJRMcDUChQktizAqx5WAzyxLGsO4GtkthgaNJtMwoRFbo8oTHU2BnjXeQotamlYZ +/vD9zFwM3azipgUEohbGKIKkZyiixDTROsCiVbaNcxHB2YlsbEZoIEQmp2yzHIjNY4CYRElorKa NXQ1jiDtURFDBCOQRjZSkAQA4QI4WFkOQmEYMjOYrgjbBKDEkUkKAy6yjIbBo0kmtBQogqsEXQzJ yCJE03FpDKMfL14Tac3guUkDYHckdCQPYZeWyMUNkwmdps31p5CYYENLEQQQgyhQDEsJKmjI6GjU NLyHDBKU6/Dx8O+HaHC6kIpCHLCaiYkgilLmgiI2niZBobkBvm9UIsCDKURhawwMsWnMwkgpCBkk 0RiyuiyGJNjtdzGxHG5OciayxeTMlCbQYYEU7dcdKkskcDJhDJEBBLxJhCUMRRvGKRAHSTUjvGwU EROsbDJISI3tjRyd9FTMJSFaaRXSjL3ltUA6kIjfYJTLcyLdNY3NsKsllqbKGKopJBBsQ5EHIwwN 5xJnSYJvKOkNzAwkNzMRZKiCSS1YJsCtqapGYjYtaI2NDbJMaxcJJQDBVuObxWqomI1mXBqNaF4b IJIIhiQozGIHCwMcootlLtHGmhVVeKxaMzE0SsgiN7BoQuwwMJICCCgiZZoJIghICmQipkKZKmon RFhQZb5GgcVgh0VEUSzARTLBIEEtlgkwULTrMgFYQ2JahQ7ly95252dOXNcmaGI+roQQU2HBbMMw 22HZaiI6mIp28GCxhBkEKkKQSyc43zY5Lz4ywTfWtJkZkxkqYEZd9q1LyJTGiHWtB3qMXAzUWlGK wjaNzkaNYQJrePAZStnQMI00wxpKkiaRzOEZiWCdhNNUgtnaDQGYxtZVG3CxAAxthCxqtxlfORob bSdxyQhI1L7pgbGmvis7Pp5tJTxrleeLkqnMrdpisKjAMQiISUxZKZIKAEE0N+lqVrX65gi3YckW mixjXmeqRml178W4zWzJdqbYVTvpQrlmPBHv682u2LP+25tHjgPv0dwGSQ84xlU59GkTXPg9oHF2 22F8uYL2Sid672NVaTX+hjN0wy9kduw1sUirh3DRoCdUoqdAJRhFhlklWVKpJFRZE3UtPnbjuHax nxsTKnl/LhpNaxmW+b4XLtHPaSOp7El+4O7o4HXOMdZOM6BwQygoILx9etOobjHqLSulXtsYY4Sb GtmNYZSMiLnpN5NaO5WbrMXCXLJkjGGymFq6TEWGYOMgySSZRkN13i1WiAaAaKynx5WZg62wVUTY VBSiokyjRBNRoQzYphQ/2GAaAzNUi1jKq4YqirGVYZEqNSSgSkEwVQkVQxCVxkHAxDAiSmJQJEgA DBJBwRYFSDAOut9MTHRwnDIJNDujCIbGJsNynzR2elqVYQ6EVsVOkC7+4O57q8xDhnsUDZJ5qKYS HBnzi1EcJP9Pg7YxK4bB/xRU414E1I8yt6m75mx/usoWbOqRB5VaiUoqqskCIGBud55iQeyGIGJC aJ39COI9pskhhBBI+OVLjjtNAxEbEyJRRCLRRQGlPk4Q8un4Oo8mZaMKV+9/uP93WOzvoh3z3f2K M3MigiQmAIywSGVJJXMHAKEgDbtRwFTjwCgpEaihhTBdwARf5QYE37aKoKiKlpwSUODkQYJhz2V8 o29JJTBRrFMIYezqaXTIQUQvVkEANTqJLIWSfS/iPFsLKbR2Bn1LquXbWp0ZD8sNJBocJCAo2BiI hhqwDLLS1VZJB6KY0tbtajGTcpi6OSESCg59kUSreOtVUGMBhQTFawZBOg24Vm8xGYkNUVKxNikg pjqMCzUGFhwQGrLLUjuVCQ7aKwZjWnoYYpACBFIMowyukNBWtsm2WKGKmZl2sFsxLNCN0QGhMRlI KYDYroYS4OtjGRhWNEtK7FaGMqYNsqIMD7xpRoanYs2rcNjZCZS0GHJqDLCMCtEhoriCpqqMJ/J/ pNCMGxaQoADDcyxP96yGRsCfqD+gwOQHBXcA9/hIcFT1jI30L6PwYXW2X+jvvc+hKAGPWLBIk/1z gpBWF+7wv360A2gPcIF/MNAlUL2fB20f0XeSe7Uv3b8dEZIPiOJ3aNSJr2/2kDQkQRBStBTE0BSB 9RJhCmj5zc9HeOI6SRfrJDzH78+4/MwSCEERBQWqqpaUkjHyPBr5d2mdmCQ3btluGQKWqpCEShEk YMM1Fhp6KRoDeYswm2amZs2QI7JIkqOQqz8H4hkUJEO+AxBoiJUT+4HRtD1ge3UH9dn6HmQxSRVn pE3nOvRGw9xK/1MMipSS+Cc2df3ujU9FSfcd71akf2okKn/r0Z+h3MVSpTtKlxh1fI/Eqt5udqcK xjcxoabQij2pRZcJPKKCQbkpCQHlZA9fnROT+GMlUk1SUg5YVg23UqQKiA0xo8cSo8l4D6lQfgSq /Kdhu9h5+HV0CbcQ4kHAjtYGE4935uAuUEhtYuLiscjDciDig/V/r44gbkQ86eNjCTuj2BBYuGRh 3a1+oiId/IemyXDJIsfG7vA0/U7Xoal9JkmRFT0r7yo7h2KkpLArCOCyfHfnvnnsx0sTUlT/pT39 IT5H620dFtb9M7AcmNPoD6IZ77DiT1LSlkMhJEqEhQD/OylFgUjfqGMcuUwYx4MsZFWUaZqAsTAx jZlHOLd39/BsN+CXcxrCDSqYNNKD0UY9qspMiUTckW58ymJG2pN8X3DBddttnfh2/nXTg7QF6mhp giOFec16WhifniPPIfie+PifLiOQ+mSGp8xKskgSyUpt8YWMkBqQoA+eB/gYjTZhIWoSSp1npO6J racxQywhIfSSsEAvxmwJj2rbB3iwGxHXx1NKnTmIWfytcc0tJlMzIGUxhgVnGhqqaZBYuaYEPmCN SMlEKUKHYG6cn9QqRRFun6EL7YnLhe9DrfzXPuUvoOETh7TA/GXZoTDAjElQXzidAE9ciBLBNkbi mXtRugnnQlds0kuuWaZYTToMQdawDqK6cO7zD3y3NsPWhxT+h/bI1ZFlSK7ttR4nKR4FT8MPDhVD ktlmMUOEuZIJFguZ4lTnl7QlyD3JMSVpRP7U5dgTp2850ekk7Hk4OFY5LuayLU3h8aJkegxXzvqz 5mn1NPWmDU+0i+U09HBn5KlP6eV2Ho9+5Vucog01h3d+GRpiGKWRqS1LKsfR87Joxw7NeO5BYzkb vHo+3MalG5wDkUkyZOTdk2FWSm9HsrePNyNHevoTTmxJCEISVGJGlCgKUwYMKpUklSlsgWhqMMgo egEDR5hIpELG9IKnZBAPkqxo3pCk9XwWDSj4NXFuuv+mI276HCnyfaTAbKbWLRJ32MoJD5ugfGhP FB7lQ/KGJAaQGeKdh57YdoAhVDlWmFfuFE/ifkU2MjGjpAZEzogZJMOFtgiIHORCPb7BbJ4rB+xY 7frT2Ock7UOcHL0zQMRLBQxAwkxIxMyeJ3+pX9IDKwNUzUkwQTE1VDVUESUDIRQwSxIeteh1WSdZ HRWvPDwedHtkk0PQwqyR8QmzvIOiPfHhJNCZdRZNkY40hPJJ/Kl1R5KOz7VTA2NKCSHowVf90JQB SDSJMxCo0IpsNG091BpMOMxINmcAI7DEcmiIKLNZRpnCZzBjWaEtEGjMcjJ0ExRCDsGjTgyFVHSC gzQyDNGFFTRBEP+w5eHp68qH2cuHIUppUpRkqk6FqdbDGaZqQaUkwkIytkkVHwJUiMR/vhiIcELU TgyBcESkapDKJssQaSKiEJwBYIhMsCMkmoiB+eEMNLJjGBi4YhmZgqYMhSmGB/cOiMlQ+VWVZJYi SbClHmYNUrolBoGhDBgC82aOw2JTM0USRjFRHvCwmDu95h4+OtxeUoxuYiVwnsWeAjY3zDsfmJ1J B7p1eao+pkMI6kJ+oIyA7iEO7WyWq1Xz+jqLl8f08pE5SJPjPvfc2dXU0npMY5N0iwTzo7X6u48y 1SRIf5+/knKR7CJukj86m/x+2r2cIclSqWxaTBVJMrJCIgOEIl6E62VEKy1bxkI02AOQtenQ6ZA0 WwacKTU02OIGBIQpooJLGYKETrUaJBRRjo5aFjOiNBhsaHSRsREY2CGQskuECRkC5GBCUUYRkxC1 ayMq2JUhFIs0MZYK1IxpEoRQxPdstKQYqxw+Sn0WfCquX134e68uNRfttI57vf2mGmrf5qpFG9H3 nz5B7jTwO93Oytmxg4WNLxXe0Y3R0djR1WR29sZxk3uk1Vs7PpYTwqbsOHiw2Ik6HIDq+I67u18b kkbyCLAXhzt/QeKYYNHdzAjf/EThygscXLnaSBHPLgTJBLSarRwwOFkDoxini2NLXfvq5ts7jBcB AhmwmZvAhuw3LnkgR1/o5o4MaCrKdHK9NoRXW6EhuhWIEig0/wOBxkIc/8RzogcPJ6YDsclHmh+/ Q1klkQbGY7mgyNYi/+5MP3PznsG0ikL8W4uQ9HY5NPpvAIgwM37KXzu6Ebk6FA7hs4ExIaTTExrB VlKUUqlFJYVSq/0mGDMREMREixKwxERigRt5mhI5N4RijGjsI0JGGkYVJgVCP/mR7ujW5kh4L8+Y jwcY0UA7z7EHHfx5aGGwm9TTch8h4JE2sYHoWni1xXBmcd6p8xY7kO7ZwwZY4JwwJkzSHJI3r6MZ gDbZBzgzQtlkejYBzDDOSONRhVUqmKmKrLWGJWKVJ2kGw5oo6OyPiINDmmb1IHJ0jXlqZmNks67E HmfmexRn2S9huePF2eUzD7TjxEHpPf5JLblXNKwU+/qPdEeKSpS2tMhUa16Ol+wL+0hGJYUpTG6B jhoE4fUIOSyQ0e56HxKsaFj4YOYGMlNpJg0D6EQNDDtgYh/knExYrCg3hhKmTMWucAPTTwiJz74+ o+oRR189SGvpzZHB5RPu1EZxs4GaKiplOZeRf7ypaB1mh0fYTEP2mBB2eWlaX40u/XVMwXDXb14N MMQYv1Fa5rEATpyI7o9ziSvY5eBMWO6PQdkkbDR4ttIP20aFB+RDMdeKgDAiUN6C9/Hcjz4Jf36A 4RYkQhsiSBLnlzjDhzXbwSObbEcOaRjv1z325bMvnViyvuPGGTiUyPF4MPOtPLl6Duk6OU9PcdE0 KnY7fO7+PW2PPkyQHRsZzgH0oA8dnPOHMptvwQ2w5c4EdmMmIZkNlOQIjTmxB1w7iYbBycjw0kmi Hb4sM/Y0PXGQaCUxfQ+uAezG+ZOduyDlnwrEHnxRAHgQx94y48a9u5yWIOvSG0YO0yAJGFKlE9++ iT4nLHcUEud4OgQG0MwWOcc8+DUiMUZ6MsW3oI21PrA5wI5WBeFgZEr4HIRBhHYY4gCHEdzuO2AY J1mcrrNkoJ5dnXid8UcM0OznpwEx3WC3vTgbXkTUHqu/BPAJu6NDlnHT0yMu43oc67SNW381NCPV gYcTN7otkwxIhIAwHYk8hw5IjsiwER4HD1PMw3ng7RJHHHawi7ScLenLwNpEqmyx9ix2lb2HIvc4 CAXRyPcokFZ3DkcQUXBkH7iFokbcfHdeWLDocDKYYblOc2JVkQKVa7iiUCClmTZDXTOcies9w4KM +lYkOAZDL0fsdCBtt2FRZBbjqajBkCaCFqTkjTPMDRhpJKCGGggqKYIhmLTgmMscSHNmgVvUMBp+ KRe40E1jQdAJnlO3g9lo5FICBMxfkkJJNkOiGNjjtqHnkkj0FIcrhMd5yOec+6PiHGWO5o2INs3e mcLHnZLgcw5RIODN5RAhoCnBjQ3qd47WBG5Mx2gymoLHE45wQOz0HGeevCcsqXu8xkdVFKxXFiOL MwyUzNJ9BM+DWjwcvfFcx3EHQtI9iwHG+RDkCrRsECLggQfYQO4pNn4qrsYBaMRWbbRGDEQejIcw 0O9RXS8xZrGQsTfAVirEFkhBfEDqDuiIKZoiOBxjuubniJRhghiYlh1avkMOMOtWW2DTa00lScER CHOHHM+pI5R6cGcDZp+YesVJIkU2IqcDMfeTVAIzYB3tnedpeCmD1klvfY+z3dst0jltmUFHmoB3 K82awdhDMb6YyzH04Y4OJOLbJG0OWdjBE3U4mUnEy4caU0o0ZiLE7MC7noGyKK7hu26D1amHOshy GnNjJCZvCMHasEtHd7ISqGyhsWeT2hxveyID0O90UFiY9BMbE56u3YjtBWRzpuHdHZQHcD0Ik11D w44SOeqaPPBs9UeiaMkkBVJmx1wMePTBvtKGR5Jgdn7XI1YEM4a38eo6ed4OTZPcdVR7KO6ppXYp tSMHPvloMI9w973GDrIJN3w/op+pjTkMd0OYyPi8zbqHV8J0e6k8T8j1lU0dCOFR6FMU4K0ppSjG SRqqaU9LMdd2NKrdpsyQeQpTcbzbY8fAPFAdvXyew2p7bVRrc05mJQxGSW0xDEtJTQ1VDsb25pNr GW5giWBDYMlCjRyZTtdT99Nek+e1nm+Gd23Gn6yObOzYeefR37aHPxjRRPlCwnRlnKCHHs7CxGZf i0eESH0IyWb+EDbTWdbg0Vv1mrEI0QNALrtKim5eyL3EYr8veF3p7LiULcxnDwmsQibfepJnyH2n p7+2I78vzrJA31ojDsZWl8Baxq/WoQTLgyRSv53DHNYICTRskkZzZs0yoqlVUqKnY27GHWw/h9Tz NDQE3FY9hhzaUeDGIZxS8rFMRxoHkh48NNzExWlNlNmzExUOExpXmODcmyk2YqYphhNLAkbojgqH JQqkYxMRikxjDFYrFG6+kcN3Y7sZKnmM7ml1Xckd7NicZMFhCcxHochmRuOCDkrGrpdaDxJEBQio Jak5j4ZQsXu7t348r8ZzhuRkNhwLt3GHtI9DcsZtfiKllEqkbp4PMjzOvP2id7v5nY9vhPOLNng5 XZVHSdVcz0GtHRwAEGpG+4hsH1hIza9yFCMcbLhhe+YZuuzjHv2x8SYpFut9vrHLY4KPmQa04Zhx C2fSjUjYDZOAkNDIbjbs2jw7ObwQdEOWZO3r2OcIbIZEIBCORBk2OErCKy5JRlWnLbA5aw3PBjo3 VhyVuNbStAgQGHZyFaMxd5M34Q9O2gcd2KNTJkQ5sIhuATdhxzWsawU4sicU+cQevfqnsprvITcO YZLBbC04mtUSBCpLWlRQ5lGFLwRCtuh5DcuZVYmvObsk7Or7NzHVq2BBwkOo3Y398+GtlnwR7H1Z s+f4XYcp+mlqr1WMHX9uwGyhgzqTGROgJCwyrqMIjdVabtE/3liN0p8xzR6XsbPlnncIWgbQibDf 2y+r2Nv4UvhZ2LyLAl9YRoVBPpR6JqSVUAgixRIgsJMKImnzB0npPjp9C65NEeZ0ee51POREEQmS OkepQOzT9Frs/w7czYaPLqNlOd4uk6VGVBVLh3Oqui/YTNoc5FRTDuRgeHZgQF4lIJAFiCaLxhJC g14r3xK+N01Duhh8vCdNHyH4VIdCXjy94EkaXWh+VDWhE43pyx3oVaOhMfGjc+XMesI0kQDa8Kzp Ked1Z4HM9OhHhZJO6oZRiyZ5mNPF0YijWac3o+sNJwVx0aTJvyRobPBOo7XJw5OxiYxzPBVVHg8V V0aOrsYjs7EZIjOkSE7SyK5VlOjImPwsnN3SuVTClkSrIynk6nlzzuOG6UVR0DqkAqboUS8T0jrK JiRSJfWkwxHwBuvoXTpA7SPCLtJ5lDqYb+gNmLt+Mcib0BA4g+Ag9UUIJWkhFmx+Oh5KbLOP97t+ B6QljvBujzD1jnO2RI8R3KqqqpFVTScj1PMqrJXMgecT0hDBgmyEoBzSVUgJVeToDqImhMP5e3dR e8dhwTdUlUIbSOzY6jubjqfIp3PMfPyROk7UxZjILUO2JJI3ieydFXH1jUjhDlFP6TDDU5xST5JT 5a2iNmc53fc0k+J352iftfYxJhjTTUs0/uyJJ9P7v8+WyU4vPonA3CbZO2/Ad0L+W00eB0Iv1f07 w+btQ8xBb+P/VYn7ROANw4BMPm2ifb6a2VmIzTSaChA5VFMy07oHrMPOaDGUO08iH0j5qCgpKKq5 Aby3nQEmmEcCHm8PXzvMD7UFT1yKlIedfnEtfLhjJIJEAuQRACZLhCc5Ar1yj1SGEgPtgPngI1jS MaQjfIAo0GFRShjDcdPFmk3oZU5LDZUcLEhbISLRbEUpeInJZxtscYMJRpcxMbXQ3gwIAxZeLgxj ygyG2FTBKpiTTGzZQwarMWEFwNGMNhUB3bFApxybIbJMEmMNZLCDND0AmZJxZigYu4zHoYlWgZbu LArSbXG0RRIcMke2GVDao4wj4NweocY2t3pnAmuGg3eMOGBjGYCvEMrM3IKFIDmVFCae9DRsCMe2 KaigBBY4KsEGYb6hcEN0kBsHRnAzbUJd460VD4iUDZ5sUWxhjjYGmULdTMGH1bE4EKKGLPCG4bMY mMgRmgwyRTEQwUM8SI9q+U8xrIwPc9xGo9xBuZzN2sismahcYqmGxIoTsIWJUmkpVVVVVUVVLFKJ 9v2W3DFZMZQWH5mtugFJ/kWQMWIY9EC8ch4Z+h9xxGyvlWJ8tj7ZNYH/ZwRkxLSvwqCZWB/ssE0R 7CDkSaJTeYH95qqpd0mZ7l3PPmytJKjw8PprRX0qgp5iAYNJkt7CysEYNFR7RMipJASLPusnlA2B AFzhoYGcRrRhBFtDErUm9VdlZ8am2l06vBzVvJif5PqOR0hAgIC8uhUN6I5B5bQOEyDc4dqOI28H mTDhHvJ8vq2bZH+ijOREidNAMO6DcweKAZ/jz0DhP8HmWbFEEDpCKdnayDjsmA1YlsAKUVEHIkqO pT59pzeGbOWYsn4Hxa4R9PvnnnZO8aCqTNLmTGJkhUQ8OUf/FiZWjkcqEaWCQIUYJZWllIjtvAQN w7GwLwh3CR/bev9Xpfe2BifLc7TDQvvEp5Hq9NJ7Zd+m46mSCBjZjYgbae6jKwi2w/2Mm3Ih6ql2 G+4EmK7f83Y23qCNh/c0+zrKeLx/EeVBAhAJ54fAZhIimriVissVMgsWR/E5fIZGJ2v06nuG34V+ +x7LOWvK+HNvGOZgZS2Hxy/h1N00IR9A+95r27/OjfL5H4gAvq2sc+KLE8TS/CRuQG0n2IF6lFD2 ICfc85MLh7H2f7xmEzMhMhD9g6/tPU/Btpyu0nVh1HytwRiQsmXjLmCwoQ5g+4/TsChcf+Y5yUij ZAep+tr6ktG/5eDTEDvkR1wZaC0Mw4dMHAzPW/Iqj/u3nDzdvW2z/xV5zQghpCIFU9qaNTWEYFSq lVUVFVEqj8r4hP2hEoburzsVTD6XJE+T69zzIofkqPPGlRzNc/uyyVOrXlPtcHq58iw1qT8r0TwD ISCDs4edk4CDmVa4AxnDOPMCs3YslbNmI0VRXRwcrUDZwyVhuopZE3UxStpJExHqeH3a+tSScqkO inmydrR2HY4Vp8RLqzwh+H2Owc7sVjg3bHqc9kRMRBAD3QY5IO9XqbUB4dYBErk97h6Guv9TY7pL zDMk/ss4nkwkdshKvnlTwX1oHMiZAp/HLkFtimrR5c8qSaS0VFTdJ8nQdiP2Ltfw8foHisAEKRHZ j1GCINtsyUwlwUgyE2CExhiBoYiMwVdLCr2wptGiDJAzDAmfOPdx8IjuJqnsOOT0zno3UcNz2FWR 9tQsg1KZZRUn5SE+KB84H0evQaIKMtrNsPZGo5TVPCWV/+r+fHNSur+2RC+QZ2h4eUEmmAeVMWDs uKj7ZY486RI29n5L6SPmQj6jnUe5qJPr6pvDXvTsXvjaV/e+9OXlNzDefzJXwkp5MiZRYsbvo7WP er2vOfZPhf0N56j9FIwkk7wqjGDTo1AkkJA9bBEYyi/lxlhJaDZI+qxVmfquEPjB7ZHviPJ6zgR/ 4ezzT6G09Cfe+Ibvss3OFTA1X1BsHtRPe4lGBH5JGGHchPA9vxvtqG4OwSpKkKVCohOCjCifC9jZ 3nixTvV72ok0cknXqnWdMHSD330mHIBjz+l9sWZmJi8PGe84LhEqvkwT4k5/d8jgd09XKv4tknTa N7NFh9nHXQ/KaH0nv+wj2Gt+H6YPxJBQ8iXeA1vivLmAvzBKIroXtCPNERMaSiDBRENA9syCaeKD kHAg8EOodZXtRS3GGCJymY9Da88tHb9R4TAifQfr+ZxY5WH581GosLph6vgwqm85ek4eM3Z08nCK iKQotiyylYxUezP1Pbs41rYbFR3zq2fBPdD56lRasVbJUpS0pH20MEkYRjTEhDEJREzBNQUUBSMU 0QTEEYQRhlSlb6rQ6kwYcAmCKCkFcIBsApmJYiVrGFqLVQqRJTQY/mK02GJUlomQuRySJGmTYa/l NI7hP82OxuK19nurbcWs+YkN+mG0btmmurEk21JGqiEbqSN2zAUTfMVosyrIsqiCVXtmo5actzCh sgVhhcN6MPophVmxo2WxHSrQJM2WtU2NO6QhCeCWLC7DWGUrQVL9ZDkg7CzYw+aAQ+AMjYaiYGos yDyVtI3pqakcorDkb8liMhw2b7psUB3QmG22tAhkANkUoxlwpUtFyt62N7VbmSNb7GaBoss4k5qs S1SWpZyZMymJ8LcdVRolZWm/MzdtdCYyc5cvDIGWcyjLDbBRyxOmxcNlMujexIMVN2WTCKYwOEC8 EHxZ+BNnZeGODDEznhotVRK58uziRd0hZyXInYMYictorI5M4OcyTsahucxtGOHCTkOcOTiRHQqG OCnDI4Kbw7aBhRYBLRUfsM9fBT9N5SEJt7VaXFksvvxNRlfVqbJ7Tgm/cWR+Zia6q8Kk8U6eMHcH IR0BnyJwWlQL+Zz4/vX7pJ7iAv1M+nsbw9KQ9B2s0oz+CbOWy2lXdcDKN0SwqAMcCoRECaaCDVaq 0GDDSkpUisIjSpDFT6mo6tEmR8xfwTVkx96vz8bTfbJcVTPKeGz+awbnE40mMy99m0j0vbEP9MKc fJDaSBkfEv7h3HzwSetIjFUxwyxeAE33YfxXHvgJnDwjZZwoz81VYD3bgt82GJoegUnWGzIcnNNI VDW0sZSwKYI+SJ+cbniNoOhzxZUe/ePP8l9Pr8CTf2BJ4ZapylYnh0x+svzvLx7drL2t7qpcbwFi rUPxSNu1wNMTi/d3A5+Ah+Ps2++weg39QQDkVRb7xrl51A6VIKEEJPcMK5TVX00xefnmUldczph5 BV0O54bRJF5I8orodhAiBnAcNJ3+3d3JNxTBWTeYaTaxNA4cSB+z89o0QbNPPhPxL28NFU0rZWlf 8VbtJuY5NTzL57S5KYnxw9zPtJp8UOuL5buuy2PNmup019c6ewjM30ma1ZFs0UUvG2HIfHOy2q/a +reewEdgSAifbYkkQvtJHAHzB2iuHJwkcI3h+tPScVFhV98bydVLP5LbwWvViX/psaTyyncUwvjD mgDEfOCweuyftPmI9evNJEoqGiYHmT1SI4kOKKpSrL3eeDp7ck9pjplzJYs13cDEng4cJ4tn8Lba m0qyA5OwTKqlilK+DCe2hspD4nRifZfUGE4wNFQlEDSH8ooJgff9G/1774Ah49HjtCHqoJRH7Xvf GaiPPcwcP5epUMNX/NS2InOiKhzGaxKrtKG44AJ4h0vIKiKF48b17w7o++6KLMIs/O+zuT1G9jOC TPF6o+5QbncgK0Fk/Qm640nWEe+ozO3Q5y8OOOp+wjGdKcFQMYgkGkRhHcfbkQ1JBoGRKIyJlkkf Khj3FH0LJPFuqLLI93DZu3Yp0eLyDw7uLL+PeuOBOjdgl9v7gszu+V+PV+oUajPq8MqjMy9yw1mV XiCWtZVVpAldtN2zErHoaN242LI+psnxKpwhuU2QyzQ2OG6BBu2Txlm0fll58o2O0FrWVXOE57dB 8kHMQcfgvBEfRKv3m34HGxJvIi1I8HYVWsGLirGljRApSDBuhSDGQ7SlEZ7dpX9M8Q34p9X5Y8pT 5ix7fNvsP8R+tH1IocfVH6MrL8Ri90TI/VGeXDidXXizlGoTYmqGkTJihJk3J+txId3xhzMn0wdu BsB+HOx/AtLh9BkGbg/1FLWxm/M7mB2fiiyDKbPUQujlHSB6KOj/UcmQa97y+sgjYhxlsRxozR7m RHBBizA2TGWZ4bkvGCyEQyZWY5ckiZkzo5oMsu0gbFs0ZINDEmzc2GmnjjJI4g2dVmmXcts/7vp0 cByaO+89EDkerpkOLPAd4wzEsORASwYHUaNaElN3oauEM75G99C2uVAfBhS6GhALoNJIjASKkeC9 zSDtKOJewu5hhSXCLJw5GHpbphObGKcf6vfps2pzUTsPBYu9XbU7p2Cw6i1TzJ5UmkLyCEaqxcnp gSglEQ44cOA0kOb0XPuijesnR6mW1n059NqDeGdY97cowAk2JMk2dMt0eed3OG7czTsMckhrdkQt grThNRInBjStSmMjkRZGDwMJxZEhv5HQzTkk8yyJE2pMeUyJv1ROIqcZ2Mw7tnr5Q4WEk3pIcuTK OEqyIYIIBw9G7SWI6h76kqUIRgtxBjLooTPQ5+YX6MCyXLS4sN+jIBRxZXvhmepvhaOQQEgX0e7T E2gwQEGBcDZJ26dGc7XjJ6mZcd2gQ6Hwwy41C9wtm2HAxS6LYDluaMCODEcYeq6sgdmcejrBg4MJ JxEZgwRgYcMGHxRRgk989zJB2yzWaxnDMUf6LpE3ZujAVsxyZzgaT31BFqDQQBqpDrUBsG4ZvG22 2R2sOwN1442HQWMKsZ11BmIlug6LbsgSEUOwyYTu7ZwOcNOeJobueC0IkQmM8mmzRsIO7TZ2s15f vI4ZEcHZ2J7Mmk7y7I6mibBUzYmZYDoQMA1Cp0kTAxdxAQIh7bc76wGgozRZASSzNZ4LaXBdIKZt gje5IM8RC4oq8AUxLowFRHIXkxL11hrqacvkHOGC+CyTLoMg+kOIZAhDGiSARljsYNlY7FG9NwjY n0Y3gFKkuDRgHF2MWhrqA0rmqa3iNGp1N1uuoM5bsXU6HbAoZElGYM7LBJFsdegsV2dMHMact3fL m06J3pWyWc0DiGkQInBnc3uxtiO5swYNgjgwLecsdoBobVWo5QaODg7Zbo3hsicEdVIR44CSm3Ae EzNxQUgrfMhBNbnhuKIYQhvB2g4yOG+sDwOBqtBBwtA2sV4owIapFRA2STEh0g6XdDMaNzEodDp3 EIQahA7sbEcicgeouAjyObguL0EaZA4dFPRLmGcYcdWCkOWvph5xWDBySA3ihMrE2FhthTnw3saK 5+TbxdrhuVIuCu1ZkbNHnkONMGRNt2ByB2HGIEzAvPFDNBS7OI3xg4KkEbQFtg5ASoQRpI4eoY5M FswKGuxy2oeg7WRttGx8BkrRrjpy2HddOFEqmhBlx2DInBuMSYGoxYA5Rqg5cxZQFkl1jks5u3pw vJxrHCKOxQ/HRlpOablsnKqy+IgRi25kIZkOUIFrQxYFCEOagsm2YCm3FVIZhoeSaLl6ln1A+e2I GnAYbBp46aKO4Z74OyLA45Ig57HRRyQW4dHBmYIyRwwFOoLg6Btmx4GsGO2M74LIazipxIA8hxRm wQyEMcVJ2lmvkYWjCa98kGy+CWYbWFkkGQXTF4mqzNub3eIW49hSuxgrSLTVw5GqYEFiegwuEN8J UjMCBj01oDUyw1KDJTRpwB6dkMydOZPSTUG66I2RxZXYiZmGwYokySBAcu7O5aJtyhziZIberWjZ qRDCtVgNBLHbL7szLGxMHTUCNG+2QgNc8hq4Qwxw5lpR6W5Sh0NoIyBV724xunbafsOZ4EIK3sxA 7PqxygnJK4KVWrw61s2as6anc0OjWJwTOnM0VqwplHMHkxXPTg7QQDqoEOh2FEwOZjZHOwbHclJ4 o9N5GWZ2O0nQi5GtybEYpCDZtFDIgg+8YkbPOT6923JUp3ZIyVHEOMdzsGJpKdW5gp2HJprDRpiY lT/oTTtdWnDg+Ael4sZkGORHpRKgECJRIiIbPSC2STJajd03VOurlMj05Gn3W6I9SEZMNU7A1Q3z cqRUbihNEOCrKdt125XYjgLHsoss3BnIm2a1D8BxxqDXBFBvdwditHycjXRuZtL31immpStjT1Oj kacE3sTKobnJOo2fYa33zVqumPRAxwFEgPRvXmsiEZHgZtYqhFBCRTiYY7fUHIcDCYYBzor9Mtx3 DYdw4T9CZD9dHRVnvfygbJR0+ZjGhyHIUFmlg5w5wEg74JJE3Dg5zyGmxY8uqcltptXWRjoqQjQ7 BtwMyWQ4zCLBwcyI+OM8OdVyhaBsOQyBoe4wpSnRhqMfM6kOC4pkoa1rjeywHMlFtQjQaMTKVS6I 3IkWSKVziq4cMDYMNdrVjhMoGAOUM7JmZnbTroyyMKkGm95ajE421A7FGGmbv7VI4zBeW/CcOEix Q0n2bEcTRKPqEqzT9m38ySH4FyWlymKXpFhTCKPLxQBRFNiZ4x7Nip7HiMxFHd5V8DgYk1IpqKPm oRmM2Y6zDE/UaSFoMWx0KQxmyRwawUcU4pOEqJtw6tTsVvd7I6OTEequg2YVNYTZy5DSbziZpurJ TiGdyWgZsuaL4ye5YtbUsxYe2WCJa4YEzOFCbmWXDQaGrDXMMyC2Mu2sMBdsLBMRhVbSZNOemkbR LkOEYbNAPIokTtZsfltdX1thfxWBoQhkhCMsfRdJRWlVUqwiclTU7qW6FhoEjSvNExEdBEKEKh2j goqbFcDDJJCOEngJMScSw8E4RhoUiZB7kgzlA4Lj0jQpoUpVKkyY51V1Ik7hW1HfBE2GIqRJSIhu LIkwRXUiRUnXqxI25aDQTSHKSRsDm6JycmpxYhuHLEaAG1glCIWYAlKNLEfueHQrq6XTK7mvFLtT ZndtobqnCyGldeCdztMkN57+0y1P2qPa7XTTFD8aqj72JiT+4VyRg1y7PPw8H16343VM104Hwqmy us4dCeedparAZEn5LpAOyd4QeJp8HKdhzZxVNyBBTdog/0rDsn5XDGh7I/QznS2Sd/tV9Vdlpo/E R9JU4pPCCUmPQyzGD4vNJCEkIXRS3Z8BUjW4dxnnEeUOPybaQNLz/k5hRsSfpDt4DspZSxSLSPUp iSiC+C7SekgwlpmU3WQ7SIRCihjg7ysQiSwUDEIQZwCe+ewUfen0yByH1nD1GNoCmgDCcgZSbNaX QYir/ayGlE2kkx+HeNQd0H4H4xwUE6rKodfqpgEaFEMJGmJg+DsdjHSakxUNFTTMmOsZkeVtCULc MEWEAGMMY2AwGMUgMhDICQnTNC7WwJRMTgiBEoSMGGFMtSadQQeEU1BVm8AbTqzMKp3ta7bW00Gx TRO++DwfDB4DSShRvxwKiSEYIFhZggIAkYZhzgMVDQOndUPMawaTTxLmGzRZEBs0Hc1Tr4/Edc14 DCJMcGghhtVvhCSHNm7OWibmwUpWGSt0YmQ34SK10xOTscYaGKhUq5p2iXSrlwWg3DVVIxptrbmB TczZmzAhYpgcmVKAjcq0LBJoZVwekgGu5H5P38o7FJV7BI/JZGPuf1cz3Fr9306fSPtHyTQ+gKKh sTIj1TtDypMPwrXuPR47vM0fgOnqctCNnEYxlPcsW6V9zBNi5sxP1BBKdHmCGYhrs9JNqsXbSYLC KjEioQ6DbjoK2FWzAcVlbGve1GmjbmLtLkwGZKOcLFHzSHZ7yXpRletTmEhS3KZetLAl3VeZuZrT 1jI21ajOxDwh7i+ojnKb6zcxkmmGSW7qjwJ2kJ9SvWUkpSsfsNJosE1ZP6LB9xUj7nwzFEEEDBDs ECxI8jfDeeQSmpTb8THJWn/sMSZtlWZYtjhUaWDUjRuQTIYXvk5AhvByhT9grKyVE3X4msuW9unA qq5Y6K0pSqo5pTBsbNNIy2nLTJCrCrF3gjuPp0iGEondES9IOQ8owd0VLAsskgap74idqyD5Jtgk 3etZgKSbSrI7u5pfref0Qi7R7XmOpp/ACNkPAG+QgV4vFQgfUOCOx4J/qVRubEbYPvp9UmEhEQy1 ABJKFOZiQspLKwPnGAyTaQTCSCpTGcJiAqByAwIoCWKhoNgdGCsWEaWQyFHCgjUOMb4o6JyBA+CV 3+nE4gGQpOFicLEDGoYkRYkKgSoJVE6UED0SKjgkiPhIOoVUH5SFB9EiA6lFH33nnvLgNQajBtyf BrE2N1ttkbeKhXr6NbfyuPeGw5K1/Hx6Wh9akdliTqrpRakZKjKjCV5kqj/WQKPdCDhCO5AMSAUI 0FCahAaBpyViANyHI9MpwhDsDtHtHzGGOGTgEUE2TjMTDJiMZGEoZcLWpMqsQ1LkBRaC0MGhJztN Zq3EXA/2rCURJMFBNRgI8INkPftvcSLLJYgyIjYAd4EPPI5CCYSq/oPMYUId8HjpsR7lOj1RQfd2 U9pQVO5EKc08zCPM7Jaw6pFjhPkRzHPhg+o2iJKigiEIlRlJRJxEJPjsIVKInI539+ZmZlbNhE6Q mDlJZ6Wzm3N5W6wyngmk6toeDF0j8NGJzzrOs7mPnt6MRSqVKuHXG2+WbMp9UyHBZNjfPK+b0OEk 1H1FnWLNIfVjfD+azHM/OnmSTwQ8pOjv7NrXk9nHYa/CcdWCyMqaLmgoQU6BDmQ+6FAkXlKENzFK cC30bFNLAQRMBG6CbnCHKoimRIhuwLIwwMoiWqShiMsUjRhlowwsTMlDFkyKZkw6wOtG2s1LtGzD XKVtxmb5S6VioVZN4WMVGGZvtIyZkSKpJAgECQBsxxVqNpDGMaCYCisyXDEic1rRShCDNI8HE2mx kYLBjaYyEgZlddUCtGgcLKVC21sa2RQiBBqQICAhhKJCZQNSuRREjmAGDCEOkhlMNGLYcGZtgUkC yRZBmGJjFW5xttWwEYYWFEThKmXEDpUtQhhtmGnYzUSZKmEHVeQ6DjRzR21BSeED04DpA3Scp6Gs qtf3p/0f9Y1J1HdUyKjD+CydnjHeRnAmYdkFpZUsHRAGE0yOCHIO+9AQYdJBkPSG/0mk6+o0Kqbn M0BrwPvkoKwK/SbN43kMGhPhvOKNhreaNC5FEQGHpBwIITYg0OhrGk9uOHh+5+XsPkUPKfj6ovpJ iSJRKopIgViaCKIghCCQUPUIyoMDI4QKlCkQAlAPzyoYEsSmoBcCECISSEGJSmmYApLY1SDJ9D5Y Mh3yQxkg8tj8ZzTdVOTGB1MRW9sJ6937UHql+EH2kDhIveyDKRaJpUGqFhpkZivLCC+YyXDhnSXo g0D+MDWi9OGyuH4dwHDxCbdvsOYF9vyDLKMlQhMoXbiYQqFEQDTLAOkBechMySGlGXzIObKQI0oK U+OoiPMyUabzerNtc9deQCcU9COFYAD/NZGYmpWggJH2I8rEdhKcsZNVAxjPNIzGJMOIEVEkQFAy MKUGREJin5DI8Yp3Q5nrCw0Csh2CyP3D2cOjxrT52Mx1RzKT2qSHFcHwO9N03NxQpTyEjww2qY2S Txk67jyEkpqkFIgZCAiQCCRGCEWxE7G2Ijv8EYknSxs/Dk+YsNxYe2VU2d0+fH4nnceqRNzK8xEH AFlySWIyzrsUP6r6zQbSIHDjuPFbAm2xtW1W5hzQ+O+z4rzVo102aIpoJF+jDTI4/3WNVDYwSDWE eS5IgosTBTWJnAQWSpIsocmH9BIxQ0NjGCrCiayQicbn5SZz3Ur9owN6gYzcYNI1FSYHI6bFhp4B V02h8s1wP1Ql0unII9Qd0CWDOTS0mFFqkWcimhgMMiFBtsYO8JpySbspdzltpNlOsjJFaTYON5JE +/He/1H3z5xe9GHijtE6xy7JMyJYP8uGJaKWhlIiNyD3zvGI5BoeCIk7SD7WlNhTygf4qLdXh5v0 R5YSIKKRLyzFkuEHQ6fGXLgMECwfTcHdS9SLGYCIi0Ai7MKJM6YknOJyh656486RHCkLE5FpNDf5 ZowP9QTjg3ucQ4PTsausSyKjYJHCCSNGZyUfkDr6MDA9C4Z4yxmEw+JgK4BPvvzIUsTDEBQWnlJW PvVPQeBzT0J70nlBUkJz+rzvH9PokNw9Ty+U/Xu6dC7ipgAS6kMhXHlLoKpCmpOm22wlorWTpSZR 9/8PKKKsh4OFRE+r2swKFyGpOBn/tG/aiKBo9whHOD2/s5vp7g8z2Ag/d7AtOucXw/U853DJScob GOFErDFVJaqmtTZrwu8WyRz/swD8bwF/5BuQlGQIIXUh7zAUiE+vuMGrO6EXl+3bNLFl0xt/Uf/K Xx9p8jPaRHFR8ic3nREM5Hr0ehqcTn8VyrUFJkbnPWAW2RLtdFNzLc3pHTuX4nyXTaiyVaqbb40W lYV9P9zybQT/mpcgPYDiKfAf2IUkAkxSFDRRQjJEsUMED1Xw9YeQE2GQeyiqj76TSMzI9pEsJJ05 WEZIiTkyQdTxnKSdDZHviOlR877ufTLZ5GdEvKEh6gf/d24GRSMoSrEGYuIYwkyCUCzjYjEtCg/A bJNJEYJhhBjJ4jrZU6YASZBP+WsUtFgKGQIHQLE7Xse8WCgkWYUmESIZYZiigelIGFxf88A+Xvj8 53g7whKX6OameCE2oEBbLf7wT8SPdXRtQibrloGXP4X73OPNUdpJ7HisFsSrJGNFO0sHkBXw/HAD /WaDcRu/1kfkF9KjLEAGEnnDHL++AzvI8xpE7nx7JxR/cbsFut0H7Qz6kH60D4Pu7CrQYUhGzVMj hSwlUv7N/qPKEOO9H0pOfySRd4eNBsB6VgjP9hN6Wk+aQyKfMiExIWqVCfOofHpNHh504A+Ik2P1 E+T58yLCM4gBCbwvykQW7H9TbdL0OvP5/D/VsLxJviDuknvUjbUYe7Ur3f0q3ebfCXfESdvM2KpI 7HZfD33+zf0WbrUsr+7LWR0x1eJJfjiaxiSakSNJuH9mGksxTsNjOcnQl2isHgqfSSBEKYbznhc1 Bz6AaNH0d2T7Xxcfa+Y/HJ+VUkZ1vNLh7fQSoGGGQUtlGxpkIH7TKD4IYVb75E4jcrQye30b/ztn 96nO2zY6xkihaKOcTJqH+D4unXNtse8k0nP3mGOvfsP3YRClFKRghVNg1KO5wP1C6UoBJPllHMsX zZKgSIn7zu47HIYwG5BN7MKD+OChMqqYxZEkswwdk1EFDESaC5hiYBQTImmMIbYUEl01kmBJFdU+ evYQYW31ZkV51dDxJ0Wdhu5ubpCSH4Kk3iH98+DTbEp6Nw7e8HMMDA/FA69GPPTkYmOF42oIiYuZ bJNoMlXVyJJth+3XxGpOnLE5Vy8shOwJzS7LLPwx9R+49whs/AmkpIlKmCgoiIqFIfF7zNNEQFUB P/eYYExEFJDRSky/BBhAxUsDDD80mRD5V69BQ0o9JSCFdoQ/rn54ANrXbATi2CiQaaQUAX0876rH 2RX1NDbZjexHcsVZ2K+ImsIdlfnWIyxu5Yi5eZD0j6vW+p+RoI7OAT7qAju8hRT72H1pgj/mZFhN OFhMEPzGZ+aA21hrMiwwIFjp+zt+iN/SE+1t7445zpZoGaHzkYEphBHGBqn89ksMR/pwNxUcCAxD G0yRRGHlKILiE2RT92xDTDZYRKyhEGYGYJmYFhNBElBgJkUGoRSEkNQINoYF2qYrUiqWmCoKsYsM iVNVF/GNQEIAHFFPW8sNebL3lchXBMMRGRUEXAgSHmSAg9KATRXEMU0mDg2kkSoq75e8e/Cwx11U P6KUKGgoSAqKwsKqDlCHbZEg5wd/xn0Nu/w9L4vyjS5L9K/uPP4IPzI+RDGmM7jD6+Pg8c/av7pb SMZmQmGEVH1NcKSk6aiybuoAENcXCJMXSysSqxVCqpSsZhUDbEhxUahNtkkv9khWcdJUbu4U+pzq Tc+JSyPLJuV8Wx/hqRpT2eG5NIiLBkON/4Cs0MU3C8UdwroWpa9G8DcMzIOxNbrwZ5+Z46yScIiF jqNW2W3ozj+VxQ75HUpSmSifmC5bczSmBEtUpRilTEV55CyOyIv2fB8v5tvtan8t25pwc+zcnm6Q 8UhHnm7R36eYTwc4gGdOHPzvbTD4ZNakG0BlNrCrPePymK7EMhx66okiaBqY/n/MMdQ/Ix8a/3ue RDtfvfoT9qtn9phIfYqSRsVS7SpZJKUTCvtLE0UPCCPh+L+z8ej2L9sI3r2Ad3L0NPnCukcYmqVU rBVn5bGm2MWW1WwtyrVKYwyA0wHBgyMcQEo4OrIo6ZIkzIcCYgkdEGVmRCQUqGBJShbq6HUCwwia wVUJCBWMCblExH8zm/l9WNLOA3HDlVas6FYYkZtsJ6YMpqxkVYqrJ/6KywcvJVHn/KR6Lpt7iROE k5qtkwlPvR1c8HudnaDIyTIoO1MwbDMd5HOYj0VTgeaSAm/LidziKPiTMBbljtXFPV8+GlEtbqYe B240lquoxQSbd1wNRZABZsGjBeUO8iQqMA4ISAlGezgV+0S1fpMFcIqhB/tR5jxfFjznWGw8U11i 0elQt9B6skKqcwna6p1TiREHNDicTqfCawOeyGLW/oa8B/31EvwL5FiWHYkGo02JjIl03NyX0D3v V+T8ifJ0fkdqeU6A+VQKZ7Zz/8vLRsUttk6aY3IlvpM1Sy4y4Rt0JV+uNGLEwMYzAhgndkkbXyJf 07dQbPpN/aH3m/++vKsBQnDch3qPI1eUf1YP3WhMZA7HoH1ky1H2B9G+643gVK9fQK3BpuGFO5Iv 7rMw1lrDHBkhJdoxTCDCpxcU1jKGljKW1bVxWUpLQFFFEJUYiAwM/L5caxHMn1dOf63B0XHKmY7G liHVsdW7IdL+T9Fc3n3Dpqyy2UhA/QfeJ7hN/m+zw9SoaOo8R4/Mmke8hR7Tc4uAom3M+dJU3l7P uwPti+84fmcMEwOn736JCL9+TKqSlig87rCPuUnyKIiW9rerzZhyCHap4oiCigA7Bxt5hdRxQNmy aI5QEf00T0IvwX0Kcnr61HqibeNGzsG3wWgJoInFwDENDKIaPZienQbQno/MWP+T85tCPZauywyo PKBDI5BKdsZ9ZiyRS0ERLCEhFCBSm0K5YTzD9U5ZYmccTWtamVdVhVPgKPJJHCRNNSPIpAeeE9/v fYMBAVBmZEAwMTBBVKqymj8qTSas6Jyr1K/yPVn2/M6vZB0b73qkjf2kpDxWQ/ySyTKh71GEgtKJ 4pFoDJRhngh2niD8xhiY9L0q4etjqrThybryQ2gjE9iPvn5/kiPwUb8ioFSDkx5nwOw7Xe4cUqTT R3tlaK7p0Fep+2BJFiC/rJPAHiAeR5GfJYyjxJCCfakoczEpkMmGDSyD93LH/H+L7jUjax6KiJDv bl8vvPi9R59/Krbli9kvu5L40Q8TEwUTISPzn8vqPufc/g9FfIh8fl5GEX8mZDHOj0nNmGPWr7vh ZDq0bM4Z4KkGkLc+Ip2h4DIkhbJDA1yWklRLq9cGxfpkPPP7cc0FccGf83kLY7Ixg7OVI7aIB3WB 36gcoosgIvBhHqgDn/jRiQ7Pq+tvTM96jx+csOFCbi0YySSXvs6uDYU1UPtTTzNHRur3ZksrUYc4 B0Hyfq9e5W8bjnjf61h3PTuem+r4IQe+btcqsnt5tHRthXLLZlUPBjE+FmS1m7yTfJ5fR5981JD0 h+uDEwpAoohg2Moqg2VizFfwV8M2xI3e3z4rZSbdBEq3xuuLmgORzcnCEGOnOTVAICFKIgQHj3Vt y5dNjYXHjJ/WGKHLmiRCgDST8rPiD2WuyOIk4TYZspHtskfD34iNVse2YQcsgeCvBqEXT/1AqY5G zOF7Rk7A8wocBuwem2x1EHaxA/B+HkR3efOTWe6e/Rq/6R0+MiGNReTGQT1q4No9aLGkj1u7D8LZ z0uLKsB4JJg0SKKLIqLIqR0HcGfr4QXy/A6OK8pT95eIDSh/zvu+G4XfKqj+v52Qcx52JlEm6wi3 wChKHhUj9YqHePefAreGag1Ch0FhXEiAQBBIO6lttSg7H/m+c/6P2DxSHi7Kk7SdEdaiPTEWJHFi T2EesyISNyyRPXznz6RInWVB4vF9wr5uUT8J+F/U0cVBR7iDAkROkkiFUDzj3p0dqx3o6pNn3UT3 D4ewfcqT74e3o69fwMSdvz7KAfYkenywTNOD9/z6P4DQzUW8OHow1cbqoysihOKRG88LATNGBDlc SYGBgEWHlprfbZLGN4iB4xDI0kooTfRoguhkTwyHQhENZEbDDd8kcMhqyg+DY3aCteXeVhq9mxhL CrShyfIwMsBkjpySGWoyWUG8aQzDwGGxRmSDCBId2RHsb6xMYzo1JphCDSRwMrXCZht2ZhizBoyK AgJHoZqag/4wzNqQygw0iLjlNRGv9WGcGTG0WGhzlGW6eALtHBmuraTPKzVjOh3Zs/rJLLcA605l Bje0maiQ2NdlqVWjOVMGbDFHEmr2QwfDCBAbNUS1AbNlicc0WwM4iUPl1dsVJaYNg1lCoqahwNMX La51NcKnRI3ywDh5EU3SfKJXnkNQJw4bPQxBsZJod4AiwOSmhJA640+Ap2uGakcS2syaJyggku7N pqNutmOqoTFVOSa12qbOQrGTmYPC2tHCLFgx1pl6SFSjUcYkyXKSzpKYs6+udvGyJu5jHNs2aTCp 32O+aw2damClOxyK3cN3dTaztEwQjg5ajLBofFdGEzTuFJMMOyO2SCDVFt5tGli2cWZG205spiKV SoiNjDfdicLtkxhtiw6dMNHSSjk7587uIdY67HmDY7HmvCbkBQlDFRFBI5iZSRDdMLDAOUBnGO5a HcIY1zemlgPQwOgHVAokJI0YmSrPv1fgPCkLzp/sJbfZatjD3L9j3WsqCiX3usHk0UacYhbIvNjt yclg8/T1ThL0wMU89CNpxo5HU69rUcibMknduk4j5u76USSe6or0v1MYJaf/U2SYk1S6fkk9oafp TdPyfuczUoqI3qFLIVS1ZYzDn7CiTB/BL3h6yA/sIaRCIX2D6fkPJ48w2vNh5w3YF9IHyoj4KMh7 VV/XLStCtIolBVCJRQlAJZFWSiFqApUSDdQfk8fNdIJwdJIffh8tJEbRHTJM7jv/8UUniP9zziof CVX8TnH4QAdoIv/csoB8Qqd3+fstEnhJqkikV5MEmEWQg4pJqxBRYSd4qGWSRN06I8+5KSZD0D/2 Bnft6kPJ9AHgICS0HPMrEj0E/YTEmzBP8UyN6tKoTYJSMj/N5KB8TliWAYYJ509oiYlX5YJ0dFog Wgooog9vWdWzzU0SDfyxJJPJZJNutyfjPUB6gq4B5ytK0uc1LZQUc9BuxPaFDJ+gtuDl0ooYeYDs T3zz+zqfQPQchew2A5vdB4/00S5jfmDQ5EwVCaRfqM0oOQpH3NFo0ZrIsTHLJGkZ1tZohClYgYgi iYgChiSYoIikaaiANKiZAxIpKIbQfn3wEjf92nEkhKWhmUChYgYhiYQ1i5UhPBIfhhzYwXGD+EGf 0ASFInUIdqIkn6Gf+A4AD3kopokQWFlUPzQoIf3MAvNhATGVBV27atMD8wE/yFCEQwUwSr8RAEQo mAwPMxixAMSQK9sKVQlNFLQNAETRQhVMQlIFAEQkRQtNI0qROpMkHRJE0fqIAMGSNgsUikiln9Cm eTBKUKtpbLYLQIwMyKWjLCHIAwhcUaGVJYzEwkcwCkDJRDYgdQLE6IQyAaSkYIFchcCGgYgWGIiC IiIiUiIiIiJVUqsXFKYMhSxikZWWCVRQixCsSiRK4FkijQg44GBSAUowSBVUlAZmAhGAOGSDlk4Q tKFOEJGNMC2WltYjxt+r8fz/k/j/n3/XzlNFfkKaxLTy+flOgtTyIpj/c/5h8Bhil6ek/I0Ew9IQ IEBRSJIBRPQERLStKPrQiCGod6r2Q89jeuuaCfpDtkeXB+jrwH0bHb2231HtNHmBPkhGlSfjMMkH Pjio0Kv+W2ZGr0HwLNb7Gh/qNf2W2udoOc8bob4B7ePiODD9kD/1IGkf99Ziah4jcHp+KyOktl99 NSBag7JMigoB2w1LqFP4V432WICmhoQKE3gaUwh34O02IwdtpMQT9cnkkH9GbvWSN1ku2++XR94z YEvp5RCQt/mFyOlHv8nedo2sMxc7qk7VjdrZV8DPBv01bRJ8QK1QZKRUPVMfUbJGRA+hddg9aS0b Mzyo/y5sfw31AOrY6j3VF1pL7rT0fLF1bCiigMHcMw7E9oaxrzebhCABnsPeHOBVUqJMkGL5hpE5 CAgwiIwOzInyEsPcGiv5Aqf3UlyMWDDIZugBk344hL/S01oOWkUOgS0MrQqKOBYleYBj2c2Ig8Fe FilqgV5gI408q7nag5pbObmcbw2Cf6mNww2k8r3HTE4uZMk2DiEBbuqJAkVgzhdH6ePlH7ANiQsH qferm0J95KpUqhVSbxJOHT4ths4MJ6h3akiBzEogQymw976y/oi4kQsEMDIInIPHp1HYwEz5fF3U iouYasERPieIiiXgbcvR28hB/c320SWVD4aRPhaYT0jMKqSolCrcAEwAzaV9YQZJpCPUnxOHwB8v /jcIne5no86i1Pd+LJNU2+u3tbfYtpOxPuruGvBHA41Pi+U7Gw+1zHb0TEpHSnyv7q20TeQ/PH1n pPTS+1yaf2qVs0/0Do0fxnV+k+8eLmx8xUmJhpwFdiKaO1U/qYf4Phe3Jatl3RyRyd7ybKqUUf// MUFZJlNZvxB83AazBv+Af/+/aX///////////////2J6/vq+bTEfdr306W2gE3tyNtFVSh0AAgUQ K1JpX01O+410CnN957xaCVRt52lM83Y9qAFH1p9DdpjufCUiAdd261ts7B120R1hrACiQu9zkh2N 6zTdVo4ANk60CQRp4pQzUCTbWg1fXFddaHRqz2Y+2zd2ZhIYxWhKlrab3GdCizdnLraKbtyJCOms 13dQRzbazrl1tMjXO7vEgd2cgu63SJBRRQHOcJqzLahYUaFspl1onZoKIG2b7n3wb6+q2mHBpOS7 u7gB1wkqn1pC80tsBhLznu3rZoYm3ua107fLOzaQVm92XbKk01Q13YUNGgVIXYNcJyOxbSy2qAVL RhptZdNjB06ilTWnQzbrhCd3XVugO7WmWpTudqd2pQKu67lGEsYKtTd3d1q5VycutTqmy21wA1mT tWwAAA+guynbEiObR0t8enabrWrzrawGNdrdPPUQFFAABGHMYi+1ab73njrz473lSBO2dmEXd3dp k2yMjs2mCAEvs+mF9fXD6AoGI2rXzjpx1u2tsNUNZVaZUkdanVlsXYq1jutGa9DlcaAKAxsa1aq1 MzRkqXWQvkAx4akUQtr64ONmpzbRujNuO0crZNtayNbrfeu0iDsgr21DnANo+3F3s0dIBu5mcXV1 xoAsmF1u1YGN7j3PcAG1zhbABzuuKHfduC9igHXSgARAAThHs9kbmyhte41B0bpO7OLtVHrfYavs Xw777M++BRRCkPAD6Fl0Myo+7C8Q0Mm8HipjbTWntuvduRSPs6Oexo+d9yu8fcZ7ctavjV669DQ6 l9RmUeTKqUfX3ZJ99bmsFr3A0kdYJbaiYqdHVVubvY0e+2lsA573U720dtQokQGqsqwyNZbKlDas 2G3q7Xe+u27rde9xy63HfWp2alc2pVdLvU5XjrbTemTlt0N4ed2aEKC1Z3DOy2SapirLc7Xa9fTl RUpqM9XPnVABYtTd9vKgS6DJs0FObVvZ616uwaInekw9Hle7rsSJrTt6e9iJSXfM60vZOYgn1qlD 5B87HwZqU6PqUu97UdPWlbG8BZ3c5rSp2ZIBa1PZ57e9bppe7nfZjllbbd25ifI7t9KDctI7a0pv fY21xTMjVXbXoGkqHqm2GfXS6zKxbLDSpQKWfdxSSoRdDWjTbBc7cVu3d81phoDAG+nRKKvTWzs7 tM5ZQ+mlUhLtrWKT3u720L1p1XdnyMr2ddPCjbVGqeZr2xKo+tKPvu6rPrnAnRrqnr4nl9tZlt9t pgclahUlRLfdz7D6+npo16brHshJBmb7Q7rxolWl7tctObQ+qM7eDqzZqrrWU5O5Rbc7SlErPe3e bzvl6u5w3D1xMBtUwwwVSa3YxfbUUKSmFK+Y6Cl1qUjKN9dOjnaAJ2NHLUETVxuqC23RuesWDHVb mHV1vsxVH2+25VJe2+sIeK0+tyVeXqFdtttG2zLe7nWFI2XQ66uOwioUqArNubVuLuRDtWVISUPT fbXmzWkq1vmOLrLKNtWzSDZoqkhUaszoG9ZfUt0Gl9GgFV9m2NzaR61dNTzGpFu2rquxrqp2W0OR qCli7brtqJCUVFbDFs5u4pcdnfbX2POdyvX09xvE6uX2G9vPru3nbrus07ud11kxDTW97vevNvo9 KlR2GRQoA6YPo7mOjJXWo9fcyHsaoQBRd996eN0x2y2ba2yWqBvbdqxbDNM0rVa+2qlUS9p3evIr lValrGmqjse6hokj20etSkHSmragx7ZKnLNxd2wK2jd3cCEJOwBkSqiSVe20HuAYn3b7PcCvMCsD WkOEkgIACAEAJiaZAAmgAACTJk0aENNDImCnknkEpoCEQhCaJiGRNT00mNTTII2UxJ6g9GptQ0yB kaDQeoADQSNJSIk0mQ1TyZGiT0ajxTJsJqPUyaekNND1AAABoA0aADQSeqUkQmglPTDRKe0ME1NT Mpmk2U9pRp6j1PTUABoAD1AAAAESIhAQBNACYIAAmQAjQAmNIaZU9omTUY0k0DRoCokhBAIAmQAT CACNMmQ1MCYagCZkCaYon6oADTyO84H0/T9f0J/x1EDSIRiAOrECiISLEyohaBio1FWltpMsRCsF AKtwVUsgqiURVWRQA/0siYpVkgSxUBVSSKqRJr/vy1rbXvNvBRrUVXstspbVyqLVJVFWxtj/E21b XjAqhcAFWRVUHUGAFpFAH6iyQwWITaoiaWBGUjDWSIaKOD52D70FpOW7CGSEQXDEoh/WP/BjGxAd mKxiAuAikIqEgukq7KsysxlpjLVNo2jaIy226ba4aqKrTNtJsmko0GMhBqZZNuKNEIpAairUkYRh ATef6l2iv+gJcFlKqOUFnAgK/rijbI72hNWLTG4S2kjEYxS2A0yMEXqiDL1CsZT1/5fwml4AZZD/ B/gZ7P7CfdNPQNQSVYYmphJqtJqYNP0xTEO0gohUEEjEHMVUpgb4oC3EkLfbKiTBthbbIyxE//1y //a30v/J7J/1GP/oy/5BaHwrdocYC/zG+aDkfOzUf9W/7Um1v+jhtBa3EbLOv/jDjf/WH/+iOS7H lgX7knK8vOtkwzfr3L28xNtifYXzLyhEm/5qdKkSsLnxzbme4d/+c//uCX7xpSdN7UuVTj8i5kv/ iByuV5KcD/6fnyFg8ieWmfgOJD814Rp235v7Lxfq183p6H4t7OJRtCjy+nmN5GemBYFw+TZHmiKZ rqKRhrcawcaIHYpXlSgquP/Ae8zWCfRwqVSeU7KD+5VLl60rW1JFKbUh2CXVknBk2xdjCn3dDSOy aEM9d+QxxJoQgdLUTxxuAOgFEdOk7u7xkSoiHd19/5351ts6z82hpF4ZfFKLH/xta5hhYKCpCX/j ElJUzZmbFPzyWc+ZldqNKOgw1P4kagScZ3vGzDh6uqHJ3Yy3wOlmz1Na6lPi/lUOpcTlWVMFOuS2 j1EKNac5dASF0CsDU+/MhhTTAgw3QH/pKZFXXaNLlVQhMPHC4xkkp2zJZ6Rj/1fvth1VTSuIOUSr cpBXJgc3UhKkxOsEvK8QJYyGNbFKN2kKRPXWE0t6fAuAhqctEIYSlxxRubr7nbxu5gmqU6SsTgrT MmQ4Mv3ofwaUg3snhzbK+peVahdN//xFjl5kcqZGSksJEleih0BhR2rfFRFWvN3JU9IAyGGXKucm 8PGv71hrVzc23xaiG1zhmcOrbeDA9KWkZgeG4ri+hinXIiOWW1vDjjX6KvnijiSYqonT6vcc7nai Y8VO59mbzPqiX14f9ONf65+AcTE4HbXg9zRZddZvKMGKaHf4eD/qkdFpkU7PAId7I9z6QKDQUawd HWU+GOCi+U8w06ynjHBRdv0WQ9FUBIpVUpXPJ4732GhrtZwyp9jgxLqpNyucqVDtdxkUER/pswgi 180xTnCLyDk7Y6S8YaLjZxaappwEUz08EjZj/S2L1NWvyqqDQ5zNjFOoTHdA6ITRp421mPSHV0vP jPLzrNVJRqe2y4boH/rZkzRRU2iOrl5WGgm9fjd9/r3Hlhq93CPg4Dn2se63h6ObyMXuTo84uTOE xZdpfccYa5OftVtVVVX7hPiso1KN4J+H2T1xPv+yivZEFFeHv5v+EuO2nNVdOawAtUE0GHhMtfEV 1449VNOjxK2ufca8gU+PYhxKf9p4oRlwkY97inhublKGL5qB4SNChmyiVsjFle14JFNX/7y5W6NF j73UM2NL3Nck2DUs+LnDF2b36/dOE8QsJ/9mTvsbYD/W1OrJ+/neY5kSCZVfC96gxh/mjx0bPBpD YuNoM0TnJw8XR7h+by0bTZ2x55gDXvpLjJJI6UUw0dlJgHld/nzYa9brHsFw5yp4A5BxDdBRqHhc GbtXnxffDsqekPDvQ6tMtNt/LL79TKvj/9qJDQh90QLmA9rA6uo942AMu1EvYwzj0ThxMkFhm1b1 ZHdFd+sI9vVw3fNqoeEBDteBSHKaxUNU0mBNBwjdx2aphcqXJymGCrtslnSqr4YoK1PWGLiKK2nE HbQ46A4BpopnYuFg9owasKAxzzbENdwbctBcxDWKvgvYQkQ1TnrtdkDkcUO/9lOYwrgdZdU/izVM SxHITC1zysUmNDjdTBEFgEafZW8K66IJqbnHSxhYux5UF6VONamDwoDq488uzzebzySWX/NGsVGo WAPqoqqfNHgVZZ53V62+qOnj1423SfBg5UU9DLiRRo0aK4ChCENyOuMYxlCEIRhCELmZmZmZkaZm d+PrvMzJY68Pd3czMz9/6mLu7u7F1omjoRch2yy2aMUY3XXXVI2oqqqy86O9E0SNEiyyyyIuATt1 U5eE7hWWWWbkWOQ1UpSj/raEkdW+zKqqqrdCEIYFpDlqCw9PyO5PTZRZZuRcbrvEw7bllnEc2kwR vRCFYQef6v3Y444xRGMYx9UIQhfCEITR5UcEXW3HbpzI2WWWQRqRbppRBFiGpppphCEIW2qXPYh1 FFFH/VFqPNNazj+vWiCORHVvpwwRUjPbo3omIwRTLRo0aNNFiOHiEciIIqRxozQ6yyyzTCEIShCE MIQhCuEIQuKud1P/C3FmgjTxcQPAi2BlgtsQ/1X3pEVB0ORb4iVew9FAedIYZ9KFuS67dA9J73lQ Wz9PmMi7ydXpZzQWFDmG7fHiQbu/8O4/R7EcPM12ffk9jT5x6B/L5HeX/pF6qY0+XqaEY4D4QTrt sYx49dE26jG2PE6hejyhb1J1rkgrXoyE4je+KJdntR48qXdCKQMang0Tg8Rz/b8n0ubnfzcjSPRI nxUscX16+33cR9EDRz3R8/CFPX0fB/FRW/64O53dDdn3cTubZHxuat0D0tp6POzn4+TIgffW6w9P m6meWxnXW8sfh25Rr+//CDN6g2p+KgvVKHly6eZcj2ee6iH94M+XIu3Kp5n8oK54zp6Xr7pzn9uZ +fjqaVS47jn559fzloiPs6+efrj/PfAj1nXFHnncz+L/4Fw4mMyT4Uf/6/M8SUO7o4vvR278+3P2 6pvtQDpjXnyEvOV8UXZcej44u/j64R5c0vzlTB4Uw5SiP+CCkTLlKIcn8n/weLjPFVWqvzd3WRMz cSp8e3+yf4c/A/T10udKEh/MWQIPi/5vhyxh8Plc/boeUxdG2L72JacB906L9EdbQbhXe934v+uX vpefu+Jl5KnVTc7mdPmP7wVDqHIPfPcnee3tJMuffp9pLVeYCXeOogldVUGKIcpRDkqIclRDk18Q N+Mr8dKvBa51H8ig+EaXT8o1WoIYZ73qjidVEYbKo+N2T8e/G/OUY4SlKtQ6bJaYV/RG8zYrttT9 P3xnS0tBB1FAfL6KPE6eDTC96ogP2Q9G5kTBUt4MOooZY1ciH2h9/L4pwi68ehur3+hzNyDwcexj GDmZ8IwJov+VwV6RcAbMbPrNAScDObDB0kzmHI0g5KjmdnEJBVAfSwmcEWlANcbStBv8kKlN02MH KobByHNFm3dboQGw7XJYQb4yuUyJ4DORMPHi0P43ZxHjrFwsYsNjBGMx8mPeEALlhmz5GYk4PY5H w3fFwTuJ5vpEsRsB47gmxBi0j06ctcBfRTU8nu2sjNwnf4eH3r9sR9lQHbmoeI3cuZboydOzKHRC TCTfK5Fnc5JUN79LnsKrrcwxqtCeXkFtQfPbWRkEPvn8d2Dn8RR26J0hzPE33eTcZnp3eBqcch2j uGNv6H5HRwxp9D9j43Vw0/yK5CDyU8Wn3LaKxPXpWtWlSFanL8VJyeHMZnFRa/WXflriFIuvKeXN dCtixnmPxYQxCM7CFCc4Q8uE4TXDy0sfmspqVAs+bWSJmsb9bGDWYdX9ZkezRTNMMikfDyDopZT9 ctrqpYKje9NrmHd8gzqAu96r6c3RCIXDlY+2q2MVFgkTH+tMKQ+53ip6KbyH/m8/efyVdbDrAdyp r7l7VQY05oPPXs+flWdk21A7CjIiVGmJiGzjR78ypeL3dyKAg3yjgcJXJhtiVGtf00q8+Ob15dmT LyXeKOd3enkj5W9TD2Oc+SmlkaTu6i3T1hqvKe+k45qcZ8IdrEo+aymyoOrlKfAOVg67tc9F/jls ishR2AwVjkSuDZ/RrASAlDu/7fTPF6jxOHTyNCCrUzPUaHhGEXuc2xi60KDLPah9L0jXg5rqmaBh bzxXhnMgG/5rHX2Dv9iLhxJdSvtfv9V5cxGOKWlF36Gq/0Hxf8Nx7c9fRAjo66Ncwjwmpp7ZiJ2x EEH00QtnsKaxHdDt3lau4oT9XSYdfh8xSNofUjA3qeqvbvlqGz5XqYyKdZ6Xf47/HwzkuPU5YAHy jFBVRQ8R8wbfo0omI1Lccwy4qYSYCBIYhe90ICtoHAwwswzxW8eqVMoVehye+Lvs4Rj2u0PdrTUd MHWlmbqRCmrFyMGhp7CGTwuuomzJhh4qUW+TS+8dGg0CNhWA7QgcciRv6DOQ+dRHlEy3BYEoWUO+ LOfm5rQNwhrpRocyZUdsaSYWMgVph/TOPth24RQFnv/VrfnZJ9Q/Z8q25RxhUDAeLZ0+ckXbqsZN HCAhOJBBnM9OaDhHHXzElixcNbEMIvqgvCI5RGyiJ0r06i601G9lqSEYsIR0sWzWpzNkPKSmBWxU iEjrrV4t0qGbQ3Q9zMyKUwsahjmcOHoy06KPHnlltL32Us6Q7veqYQc67LvH8bWbpo0qYVRknWEG 5FAjDxQms+kdoKcrKlhtLFAJcLT/zhtbeXZEFMOILE8Tg1jgN6OFwvgOwQQE/5lW+svT3iSA1TOz ktrm26QM9+pz6l7Leng0v+8jTLU5ZcToltDrJxesFGI8HyujFZBJ2O0c0X9MVBlGbyUIe51jKJGi nM0ogU6RmR1uWWedmJt1nzPy15V5t3ltwab2ZVvZH4jD8x7jc5nM3R4u/uTT59slu/FVktb30Hyf EuSKUGeRjSYmf6L7Ej+P2vqWPPGOJMkRKdPWta1H5VVVTrbbb+t6P0z2n5/vJQ9hndWwJgMsvmT5 oHuDI7iDy1eBuLqmzUSpJJJJBWyJMth7qB8fo6dNV3RDkaBSRBhKKLlWGyot53Qe18uXh433Gm7B U1RusG8p2MbbI8PUm7rTsPiKYU2MO82Ow3HqMNx3lcjuh75HIO3ff0cvqvl0wxWfbc+fId05Ob4j R8CPIbCnmO7nE6122Sa3FEzFtqnHXUoopUwsJcZRai2jgkWzpV/ZxVU67s5OTSGQIPZyCjhyqj0b 61TEd0WoHoqj8qaj5Uji6A0I1l6rcOTaNlahaximV3B5TYIihkMhgBz0YjKqJtcTn0OkQujktetP TwkEVZzhqEoCV8AxBg6BGwNImtrCnC7tDbRZQ61Q0VhlwB9oU3yEuYNYhwRrDcGHOFgXWBUDwZGO wNQNVuC+nhv6XLlwuC1Z6qSw41ExG7AoQ4Likw20hVO02TZch5Gsvlw3vd2fncgbmO6gqSQTDfsP ud7jIUaO3zcMruMcSrsMGzYHEDFqjgDKtZpy7fdilBHQlUprQPtVquUmVocTcGHF+ptap8RuaOkI 7Z6oNsdXpcB7Gw1KWC9/GVJwdAeYPFoyOpCWllFke+LlYmkh4utUGYZ7OmjV8R6PN6OoQj3vUDTY 2227NOGNsY0xoYhzGsSSYcMbctvsbaabcsbcsGOWMQpjToHqGsZtkavNGaWhdhh8+6eY5N00cfNz 2NjZPqNsmzodR2QvibUcZpVcE8VA6qWgmxlHVXTFjLtHbMKlwqpNOBJfqwMf2bnxFS0y7O+FISFV uUwSj3/1WRQmCkVA7BCI+zYhCRtKMyJQl4DsKVcS92Plrfs08gyUb14W27YoMUU29icDHT2PnBuI QFDqGSgCw5K8Q1HVbTyDL1kdHNobIKPmDOJuO4nxl1qfc7fFE6WeMD4o9UajUajU3GgeLd0u69Hl AkCRN8U7A7+wL0fA1bkkneGEBVoiiHdzvfLbzZ2RCtzpvhBzQhB8GhB2vPU8ZZL7qHt7a6clfGVY etw+PEknN2eDTTGOW22hIBex3hhvfCg2iSJIFSSTWvDlqZfFvO7e20MfGrG+ShS47vMDSoUvMDSo T/X0eFkPRaB0p760ZRpXD4aQOlN1BamHotA6U1BqDRsaNJ5i1ilZUtBL81nglpbBLqzCWwS6swlv yB9Mx74gfSVz9YdRzDA8He0PjkkhsQhCEjuaw1wZoMzNBYab0o0RrGWMHCHehimN6mEg1xxT3Wus N73IqxqBQPqCE+U/L9yamzqbPz7975wfKM/J4nn0yqsqW38ef6i5jxbdmlxbdn+XiONiIpEwEs9f Q4ny/aHoKKbGFNb424q1bmW299mxvxrD4z2DqCmfZk5U1szNimD2Hed4xf6XUBXS70IlbizFjg4N Tw5TuP4CmqaOpwaNa2/P3s19pXv7M9til1POfjlZa+DMzweE05Mmo7UOJ7KxqpRro5++CK1Kkfrr YPIWrrDIHKwDqNgNxFQVJseZPVyX5J9NpUSorVcIa15qEq30O2SrCkjUcQw69bApcNogkUheprUC WGpepNKYUJODeHqDvBwRRWaORZVAqe6fFHzN7W/BplExmZv0eVo8DEeGddddv3+UP/WvILLbz1XX dXIGdN3iaf0c4YI5AYP/gXTgtaiG2YYmSKAcMDEgrCgIdfaFgTpD5iQnrnqsWSTchy2iuwJhR/7K etjW5gn2QC3cFF4SVtaTwmJwQT+HRcPX1JTCw4JhnA4VIhuz5oV4OPOO7uMgixmCQZhXCE5OlL/z toeEQj8eFQEgIfoGgRiR8COn6TE2PBHoPSeCfSU2PhJ3I+ZHEr80RElZt5S0wgkYhiDo4b7xzrxF FrXencArD3iKQMwnoEUJb3+fmp1dVIlsj9uzFaKAvC8RCi3inrETFSHwBwleDXRCzcHzUZcAYtBn Bp3fOu+38FmRlmTGLRpLBv2Ppvla45O03juE52S6qW9MpQNZS+oKJS2uC9yzC1o604Opsfo7M2ML wyZys+ZXI2ycHX2Ne3DeH8/6O/TztR+n8GLAkBdaDuouHvCgHBh1BAgMXs5EIuR1qE/ogSyRBGoP POVMwZz65hEHx5JdsESa/6fIOEfYeZjTZAK1+P53QflQYEnkTQtOH3mmwpIS40Uoh0VD+dMjrBi8 LkPc4JFIboXL1bl8KqqnbPXF9fdG0tR4K07EQ9NKMAZH4h5fQT1BdoDSBjyVHF5AvVCUHaxl3PLR rYONhpoex5A2LR/6MaSUyLI0g7bwCBajAbj5PWQ55HzLhWHnKue8ikgH3WIj90WLZViwsiDD/T+Z vFeN2gmlX1Lf22t4qt6zTltrpfqhl9Pg4hEm8kP9x9koPDZ0Odn0vUnsfez0KZAcD/Pfy+t9D9r4 efAO728fz95BF8XR+lwD7zh+fq77HACfRf5HeAAsPu77u+mxNHdy+B+D+7iE46SWlKtLCU+P8HQz D/Ofjfo8ilN2xwcYbRypvo4+o1yM3jDkZG1G+xtTrTUcj5eX3HMzg6RyCQ6fmSPZ8F3WL+MMf4Vz YPwcuIdnTf2fKY8euwxZt73lUFzURPHBh1NLqP2da42UaYVy00SdzUPlKV7JXoQW2xhgK3pxrY7U SezX8w8ecVRwAJdvxyJoNHJ1ePuMo5RmtNQIQlSkLqSlkkUPVAqASTy7U2/qLu888GDCcEiWdMLv vHJifGc/7uONfeCocQUNgseshSeA+OXrd3ZzqjnJKkrm+QNGsGWSBA+cZWhsfsPtUydmgdAz9vK9 4xSF7OZkWbE6A+RFEZEOLocPJlGVBV0lS1sudxrlCsDAscDnhYHLLQweIHBe4JQA9YU72fU9t46d NpwifC3ndC6oZDECpJKJjkK8Eg4EzIcbvDmlh0GhdVWVFNFV5gpj2Zzhur5HevxEtQrBm6WA/I5O Ye6Ot79hJag4g0gZA4KCBuDCPb3vU8VUPyUPggsGDEiMFVtbXeVSeUOdivmCG/KgUYmkC4ir9TvM ELK8k5/QFJzmcg/m6qfTDsPN2ve2HOGgoyRexxuXEhPUXnzPSOoK69XdB+poWbeZ1aVODuxWc8Qs CkGCuVMVrA+IOcLjBNBLZsYY6ECWtgTMAEURQVjnXP58YwfS5cA7JSoriVeggKKC0KbWJrTUiULq /l2E93ND1ef5n6diXPaXfmizoCLuAM8GtoDRTmadBzP5BvEctdAcy7Swi0QYGBg6KqektdziFKUz SEkLjmuQMAoxw7HSRj99WvTd00Rz0FT2J2G+oKgDEPd1Es+UqNECYhR1ssm6Oki9zdDh56mIMsGz Lc3lsM74IwFSDAewGIt3gkew4OJ1mHqOh8x6TRQw3hie/s7ClFMRCbanm4komCOA4OIoGyKNXJB9 KkD3uGceA18BAOe7Cd2SA3WMp/WDobUyLVP9X3BnjOSV8mp0hk3rcTJFb7sbpuqjOMpphGDwYI2u 0hRIj5R13jheDlDNAnp3P4a1NkoAxk7brfU772ngU/tMFPoMGCjCiNwbAcEQ1Kwp+YIh6Qti0zZO 19bIIpPouHcnMKM60Vguxuwvwvwy9fnrEhAOVbHZsWVyl1KsVBCL24nIvVapCOgoIhWA8NIMHzA4 IcjDsO45EblIcijxOvWTsnOzG+B0ZpORNzPCVxxsUFBiGT7yyutrcREaBtO1UUNZcrWt8mgEgkO5 dUkYVDqVacPIfL05mukk1w5eTe+F905/Z7ePnJG58JsYKUJ4lI9R0MNzg7DRzKTqKI+jlv9F8EZw DgIOgPl6DwHgEHQdroNK8M+627Px0WQaNQe81hyjFhWrAfgpvS0oQSrsjVRPwuXIWBQzoaMlWEg0 BmAgwBgVClVIk5euvAqDmHuobSyRZ1mwEJcfZNlyX8NjzCuhEr36oC+JgQoMEGoKFBQhsgPSrbh4 0BoZmQghei3/z2y/Cx3Vr8nXPGzY22PiCpNjlKSv9rtiQwwTap7t7geyXYDCOT+L//g/G20/6Ntt D8Ghp/n/VqOrq6urq/OnLzAyPFYjVl4G/xO/kToQjxfJVxU+eWLAERosIdq8bj17Tx9mPSVvZyl+ 0cMb7DNUqrS2SBn56PfnM/jjSCBrEcBE9XhmWmfTi8SQxEE1LUvdP8p8jSlm6b0gvsyeIKs2d+LF RJwgcr3D+aAGJvPUZL0imIfbH2we7toQ1h+O1JIEnyGnAtxE/n81K3AQhFIddA7RdMUCESKHKqkY dWKtWJQVUR4zO/BeKlIlLCebLOeGLe1ScjgySSsHud3tuhyI5UQ1XYnUjHoK1H1ZShE7+F/DHC3H Cj3yyrqqpY8rv3S/rfTR9y4/I8jZazA7GL8O80kjrp3QaCSjgkrXcOJwWSo2jkbbsA2275MyGpyz 7Zi90xAxzbD/QGF7tzWVK6wzfZ/xdEAhUiyFTuIulbGymFFDrAhLfa9yOh1nRr46WOlnfO5pJJUf kh5taxIxJlKEpgv9sS/S1jg839a//mbgTzBNLpWTto+h8fu9aBwUgQ/GY9bgXyU/s0/ryUp+pozJ P0y1NAPKSIQhWnm4ZvqDU06C3eGIfTfLKnnzMwrLWApSAMc9mVI3TfgZP7uytC9FdOJ3dB/FNCZL W38Yx4Yt2PE4qW/rq9pyJZJxdFJv9OROj9iNp2X6G/9+77BOtXXDiBtag9NJnPaASBkusih6Ryns F3HSqTkA86HLevIqBSFaVWs4EanbEjlz4QBBNIYOYBcQCQOTi520NrObU5avJ0U3nzf1zPH1/V97 yEPof5DzFUsmyaj+JR9nTmj5kWOQ91FjZNnH8H83nZx9r3DH6enzQD8BtD3fS0Wd9fvnChoM/zu5 e5wYBv1If7/avk8vvn0kN435MMVvhTNiX1fqWBqYwbr9X6ZIuUans63x4PijF3h6HHw89bxc0Aro hUS3ltMVP7dbxzO9WjiVxyeVdIJNQS2cV3L+2dOew8dacjLOo5yyXdVhK9kGxBabLaO3DZBIVFiu R93e93T7vrppRSyLsIUn4/y47aOl+tmbPxjgpnZQh5xOd9e56NDbvsoPtRZH0qVY5OfCtOOVxssB ygIox+1TTBGtdQ18siV/fZ+v46MctPlwVj2VUiFVQfPyciWzodSR+2rU30AkEo3wPoO4ZJiUhEGU EMNa4KxgAYaHxiPtckcVdQiePYSjluOvTbs1IRga05JFSp01u+u542I6V6EbB1lJeyZhmR8L8JN3 v0knzySp+U+mXJO6SSc9tyfuzQOhM9r2+TTdym0kk4zlJOUxP5ZrJOfL6a56dWe+Lmc46dDKIwY9 7sUkVfLCppU6kUIeEx3sPlpp1k/sxXA23W4YU3ZmLqkjltmodYDZOcDxgHHDiRJGIyLzV8dPaHl2 /m/Tvjf1eVyPtuQ5uTo5/49WhJYoOlUKk5+AJ5ysc0c0Cph7RkQRB356TlCKNe3Qid7I8fOzkltp ejo+fJ1iU/XFuA+mqAfkiJ8IoFwBhFAkF+65Yha/zWJDKh9tRlJbHmsMpVFW92tW5WKxrGNbRtrx kgpYcyVLIVHJh3wcU6kCPfDrCPag5IN9yIePdufzhw6HqlHkndywUW8o5anljw+m+DNPd4D0zDDM xIqdIKGtTy6VxX3kM8U+OJuBQ94GE+5aU+ukPtgGM/MpWZJJconLP3eF4z8VdA9gcw3oejVSJE5q uIDhr6niQePeNN/jm7xuQ4Pv3gPST6vi6seUwB5u+IEoJhQ7mxMfzbLynN6hQ+71u1qcL+v5HtIQ k+XtC+5bKJxzr6dDWa6Uoa323skYaV1aa57rA2EYENKy9ht4uO/UPjVV9QnHSDwn2IcU8QjY5+Jl ASfdF+4gdYQeqdh14PbgJAvagm1e+c3+WqTfEGKQ+V6B3FjdqsSKWJOk73mgIzr59AGn4XSvaBD8 kKbkU0neFZb2ZVrYOwpZOGmEgcMyghhXydAqD28kfdX1j/TTW/0fcxBBWhMWHe6ZEcciZGidI7mM 9hWzwz7inUMcSYCihySkOGGCgHABRgT2MOIHRbnQ00XOpK9NoBnxtJrqg564zgweEbENbPUAUEPp 4DCx/1wVfsg8eJ5fpQLgpIiJ1CUh0KJpxieecsnRn1RR3hEHItGRShKwcIpjjJXvcZOhs7j3FGg5 /bovUCJUVOQ52adaDELXAR0uubY0WNxinD3GNEfbJIb7q/D9/03pdavSQvQvvzG+avD8J+v3qm4i q5c7jNkzGVoNmFxZE55u5CiYYDqRFzuCgMgrt63Q0Vl6jQPap1TEygr2hAm9tls2NdU1+UKxPec6 zsUHKA8K5cNA62Bp5SUZjAqtyFt60uq+cp0tpz+blpPOo3jxjnDft+HPFyKiGpAkgV++a4o6de3e c9Mzvo7kbQvkFJxPF2dXM85kcLVicSYjGyzCw0rd3f28T5ujJt+RKmru3Funzp7CSe+VUkqpQHt4 96ZgyGBhHRhLE42MHzJ++Vzxr2i5qH7MKplm6bzyIh+ij2b4/vvbCHT4iztMp8aUmiHdhIxPR2Un YRNAiWRLIkIkIlfjv1gGE7Hf76T4/s50c/lia/F5+vu2qWkJVMPRJT+rzSfPku5KNKazHhOJUTKm H+FStf1rWo3UbvKkzVZRGRlQ0GOSKNtASaymNYzlDxNkMq1ZCmRoQwYoYVO49kVMSRMuoUK3ulY2 kUgBVWafU0PMEQ9EJy7iXu7mjJL1mtKSFEYni57nlERTQkmHObfESsd2bWTLcp9RkTNEvayguY08 06DiC5HDBMkgwyaTDNjy5e9RerfFOakuHdx3TUszL3GLHombSUBt4SUae4zdarIyEUnfB7oWPEYV iYe9mStVMvVQjIuIfmqNIJTNyXWqvULitJqdnrbsoeWAu9im4mMKw3WmJm1qMktbVqKTxM1l0a08 chyZE8QuIdRZOOUp4QOnXKHP18KI6MwZPXlK6HnKZs5BQqfRpRckDc2GBcUmxHOs85Z7QJ+bzban YZfbLcNBWoWFCnD5Cd9iNxTCxHiQUoNceq9MVy8l3O6UbDTBDndw9z0dXk+rrCmPo2vyDy1eqx4+ hiyytV110VMfgU8GOthjxhctoU8pxm7y+qo4oDm0sVEYauOLnR46oiTPlbjoOZvmYcliyZLUd0jd LDlQ8/+QSRchNJhAZTXa6pHd3Mx+dfYwg+Zl0JN83vkosIpGTiH7v3XjfpSbjFJ+2AdU/7c9i6ro FR92h6OQKQcIcMiKrcgooZvLv9BZTHl74M7y5aYkwGCxOaXjo8dJgyGZflxiQsbj6EW3+Y/N5xo9 BXb0/ZjoKFjajxA9wikHQZC0o+yE3ocQI/E5HFERcyGDxwbzohPQReIpxxxx0kUXzRqhSj3BW4OV kRjJHx2222xRYyGwC6c5zkEUTR8GQ/6G4CLgOXYR6XQMcdDxmSZu8+ZGjdcjjmC6t19Xo5Rw2mq+ rBsXtKwKs4ZRgQRbz+Rn4Z1UIzX6/DBoYTxIrvir/VEHs7/jz6jtl3R82fHfX+tVDuxalpYS6GZg ebKXWerDaYHYjlAqQwMj5natxmwWBJD4+K940tiPPA7YBQTDSIzriibAzIbd584TTZ6xVjCZ9/HK ojEy3Ozlf7nQ5mobw5Th09mu6Gn6em3NnRzrtUfE14vCGzsjWEogyGDU5HSD0V9ekvkiZSJHQjRw MtU0e8MbqvHgks9Agu2dL0H2WeJ/Q2uPKW9ikefioQ14e6wD6X2j5WDwwp2r8khBW/lqiP75UR9M SR6I/RiqnrgSqpL+S3hACzx9PcaE4w+fb13V0fKzE8yMQX8Bw9jZ08uyH5Nt72QW2Pa8UP3pKqLJ yqsLUYACCND/VEKYxjHeUNCf/T/oNWMdvZ8/HCqqoORUYJAiKICMVzBPgrGzLG2yVRGkZRqk2yM2 titRRtZltJVjaYlaNi1JW1v0zbyFXlLUUCIKn0kE/lppFDWAphiibxBWtzW1Sm2iISiNjJiNVlm2 xsbbSa1SVrGl1QgPjiqhTFI20giQIipCW1JtUWiNaStJbTNWNbXZrVzUm21k2otUmay2Wm0tNVfB qtzarJJG218212yrNiVsstq2SsW23+H+7CI1YRHCowsiyx+FL9kStLHpxlKllbIx/HpJhSKsk4p3 0y7if7UjcFJOHw1PsmBkEH8zFRT/rBUlkRGooiG/Dr/TtDKB5rEjiUCm9ivt+elUC2CGxTSoiEeu gUNIhIKwiCsiCeSPdHSCIXAXEFXoio13Xp4jGQIQQ/tj9pERuK+bQruxRqxp2KRUqIJyYHRFoYDr BKYj1QLiCnX4V9MUdn9X5d+BDSCrX4Uj/6R04jQcIQiwk/T0XtA/KB4aFDEmZynGJMZD4X9Xq08b zo+GjPUmSTqVFskqpaWo8KkMolsg+e4WWe+ZN7JGqYQG7GlHyVQD6ieT04tGETdQlQkhJIoQjMlU MCwooQk6uFlgvVm1sG/na4oiWisaqmfmW+zNV+iym0rFIy+BSTSnx2NliLKklkVZE7iLIuBJIlhA MtiVcGRDLJlHlKNFkKppYxLGSo2yXNbqm2jXtm1dlWmbbSWpRJtZClJhZMpMViKk5tJjrtoaa9bu lNtn6niyNXkkUp9uGKsjpkiMRSSJYlIC/1sG8jWRJYpIZdkiSXKtkkfhQoZYHv/biE+yHJJMOlkj 2SU4ewZAb3miK8Sirgj1cWkRsMIpRTERDrlMe4JJD0H05tP1sRzgvOLCtsiLdLKMqSgiRCQpSJ9c C4pFUiKcojk0ngFG00KIz60m0GQpYUUZLAXEUcXpYD9qRR0MCGnqu0sggyG1jRaTW5um1paVa2+p WvKIlbxh9PavN4o1c3Mbm5jXIxgsY3bq2/GrV+/8e3s0/x73wNoLcSQVkVqqCMGMV6iAFk21LK2p SUlLZS8zXyXbyTIZe6WGNTJBlgmUhEyJajOKNaq6kpRtdmq+DdebuUkGxIANJIXiMga2haSJHXEk la5tauVo1ZEBJE32a0hdAsksQtCS2Qt5aYaYu621Gt2Wum2nXWtpGo2NNbTkVzju47gihMRgV1Kl dym1umls26lsvO28lt5mZrXObVytcNmba1zSVBHKm1BhIpiASRgqtAkFTmrJSlIm1upKY2ubVa5r qW3Numorom0uW3UX6PN1bavFs0rttzK7aKjbqloRvWUg89mbGAZKmUlkWC0yUpq2XU12u2ptrbl1 RFsVCGQFHVUIypVRmZH8ixUcEJ37q6CLhe9T6WAI8fq/HxzkBuAf5lml09MmWi/HKTSiUKEIiz5Z N0vqrtSfG3r5rlB/XTR8jVJ35IYoEzAoMhTp9fh/90qSVZu/JOTxf9YX9nf8mn33Z2Ox7ndPJVjV y2UVX5Z+bWnPMLViuWTFrmgXGRKdG0yNiOINH1UVIfl93+U/y5BpokA9L87dxN6cL7w0pADimBII 6ByuWphGzALRqxAgwWjo03OXKWGj0G5aDdkb6gwJToYveaFjEIZ4g+D9Fwzja7S60bkHg+c6Ofw6 8euJU62UMnKc3cnZpDiSPBw4E2iHgcG9yfL07dJhB32I2g3VcQnFBQU6stfsoyH57yf8cpjj3Djd B6tmpn0XdBTSiiBmc9Kj8UOUOiU6r/MeiNFmFg1Ag+juAEy6LrB+n4NZdXrwelHVvDfGsjJznApS ZkMwMyNJNDtbCID/7wpCuQ8fjMxfOvVqaVHLSSEJWL4w7XOqWOOc7s9hZvP+biwH/fW52vCxJ0H+ CWSN1aWY5QEYyWaRRDjhGxu2E3pLUeXfw/5bHB9Ox+zl8IzSEcgJJZh0AwN9zbekvQ5ziYsuNDxl eEMoQQb8QX8nss9u48Vb1zrtQ8uttK9ChzVg0bwwCBxCUbtwERD7AtOGAI/2d3isXLH59moFnINg NY9iSC6CzjdWBGlgNIQlNN/VhotwEAkIDv0Uyju6AwGodAa2rWHY9JDpoTQ7E3i8xMeg2/uy5wew K7wAAZZxDH8D5Ptgpcwi/IyMxx2DHQMYHUUlTF8KjNIQ5jYESUlrRzHd14VbmckUYhcOuYE1wjnx 4Z6dArgnCrE4F1f7jpVT1hEUgEAKChoWdPKzo12Lwq7BDAec3qmSUkC5SlhQ2DFSRGJBmQfGB8A7 VWwiPgQA/QQU/hBA/ILaJEV80V4QT5yk4qRxZ7i1Er2VtLMWQ5VBqbpkQ52JlOLquBQTeWSPyrxF j+Khiw3lj+CxPeUc6H91OksDusFLAAf9v+p/7/0b/t/p/Z5UigZLtR/4X/c/7VU1FhYY/97S7/9R S+yix0UWUU0XTneL2JH46tLDMci1LbNO6D7ynZwKA9tHrlGmsZzHW5fV/xGF3kV5nA4wwuTHw+8p mfWkmHoPL8fnki5J4nadxhZyHenk7w/lD9/+z1pfe38D11NS5zNRWQ+7ZfwMHUltwhHwQiIQDBFi UfEB5oqwRYRACKiPmVVTuPFsEigoMQi0D+E9ghQRQEVxLUYYALSDEbUkZUFaCkgsz9AGCqwpR8xc HwIBA/yvSEcTzMSuYEJOP8zi1XNKIUGeDw6J0e2tAGBQX0GlyRnQcQLTsPdVuICNaQH7JkDlnvuB ww1B4ryQao7+/ZU9fV6GzoYbQwQCpJCECGby2ZctMIQhCD5eyrhUqMiSaaE8RO06eKMK6ii78kkq geclEmqFArGGKdcDVsqtLNLitKkXYWLuWL7Be4o4gMBeQomic6HUujixQkf84SnJ7yz7B9huIvQ2 IMM7mJlAQrqJDzYDge8KFK/OiRNcUmZPM0ISWTgEAU2Hycnk7w4Ai6KJSx1pMByFB8gH/fEGS+9L Whn1ft7nU7Tt4ttt1G2TL8SJ4d/cPIFoodjR3eSj0kdRntFfQC9FPkOAO8NHVkvwPDtxIJApKQhw KQXiHiFkBit4ZA4iTCyJGlQpOjnI5ef+d0HIkPbQZhIEpI0hcESVhCpGK7wX5PClXLMOWoPuEHUE ADoEH5g4KCkBseHYssw2kuw248YjgJlPWdNAgHM8ptkfJgc6jaqh3IRRU21+epre/x3W5ayVue/d a4HWWy1lLbbf855jP+zrP3z5InskHWepoqZh5j4h7D855pNv/U/GnmPEpSh94USlGH5j6DY0U7p4 o7hkoqNSB4e5CJEIHYGG0MAR9LQKHgOGOGm1Rt60EgMYAfE+BgYHgNuREHiwqVWf8tKEFYzMkmZc YQUxPOCCKOzkvCcOwMal2Xd2Xd2XY+mJnn9ZNBMhSf3j37utCtj1GmxdDsf28hsfAcBT5ne7lH+8 DCr4gMuzNmtA1YyesChChWhgP5vfsdJ+Y3A9TAY7kEru6CvR2SjnCWS59YXcvzzjBOI03W5Or1C8 BUAwhbgiIkjgFjgwC8D8w8ofI7QVih0MDzFEN5872HR4prH0gVypNubB13a159q0jg4HbRejMkL3 5Lxy2F/tDgrSGxBfefNSBoRSQTAR0i0Dufik2T2h0/uCYYh2+Oh4GqegsJBEGRQuM5CfM7QBQBYO hQilCjYpOZzH0IVyfwOwOTQfR7GvP05h7D1zFpYtLVtstcwwlKEgsFyj4w4A2p6HWBGBDsg7rg7v Kr7DN+LYV7fzMwze12/L/YOp6RSw4mTefdMRrVttuDMtttwjlzJbkZyg/gaRHZLbE3HYSltlVCB6 N6O1DCeAaAM0UBpbz0x5Ows9tLmkOBva6YgSplxtQFMCrIRD4mRYplT7B5yEC2DoFfbXV+V59JxZ e/p/uwbSSdJcLNixaooqfTAT/AMUch4UKMNCq6WmEZO0tDov2xW163pYhzk5MZHhnvo8wryj/QyJ v380w+vmpNQFccrHhq9BykrAinGuhOBzFu3ITAwQEgaOE+J1OKaIwIv/DLy+s+bc1w/TCn8DS5mH hsYcqGjGYfKa3rgmXge36D3ETbtAk8T+BAOXyGSJcA2BgBNAY6x+7ndHJkkLSh+hJLaNiMDHKVHG YhQsZhkiuuAkv3gK1SGBRNiUb7O4AndSYYEC/+VtHOfttOF8XkCPcrBsiwDIK2SvQwX3gSSDsvON FgMxz0cnsBIMEzFqOeb0SC2LzaBCv05g7ORXUqgOkHNjnWzOhyo5+dZEyKN4uSLFCsmjXTbqrTck 63btXApMklYJ7Rgrhj6qim240baYGkCZSiBfZ5EvgcjhP+N+Ahwd5k9ry2L6IBcPh6a7kFwpHc97 GO84OHsOsosPOvXeDJSZCzK5xZ/IGVPA7q02xweoIUK0JiLR7wmIgI3hIP9i2welUZYe6uVmZZ8i /0G2VLuDTId9Vz47wD8zSDgoSRI0gy5ECKKOboSe+lEvEoEF0B0BQTKSPNojMP92uVgbo0OtUeWq 48UruEYRXrgPZdKLAiAJ0AqMR1Pm/heRIKq5RQht+nn7zRrZ59AyKzTZhgJQljQqPWBmG2pre8ES XKIiHv+kPOrIRuxyv6l6T5Hqlak41lOw3KHLtW6YFJ1EhROMpjtzjyHi7NXqXrMqlQfL4DX6rvn/ 59iJo6WK83JFVTYPzfxgXgQ+pflzKogJFLdU+u32DvTStX9O3X7KnkG8V49HGPsD48JEzSP0v/rS AQim3H6ZYi45GUsud45LG8GfMNL/9wQfHWtJDzH5+e4kDgNC9YRd8FTCnVEf6Qgp2T8TZle+ILRY QVY+6zmdCYeHejprcG3NhNQVgol4zxfnwdeMmqToMQx8kCxyHgHDZzPHd3wI7zbGzplyE7claMqO Oum/Zn10fiH8gEin/0HPLNbeCV65hXAPCwSoOcOGig6Od4XgWFqOmtpXn2TreUeHf4r7mtx0iD+P mEuDvklQj+Z35rrkhipLq4rotO0uhqotaxotLfdKxVbSFp9L8KrIY0sVhanDgrpPekjXZCMqBfh7 LI2EhyNTWUugwJmAtRVS1JaFqJaSrDXhx6dkceHd6nWt8PlV1blotisasajW2jtVDmWn9RKRzBGR TO6nECBAOph84wgkyRJpAwDjVWFYlusMrqqfVlyemhXBIx2xOLIwrBVWF3BAz8Dx+4Yb+n8v2AeY XZiywDjCss+7WHD4De5Mt++pJGINAIOlFwItQhhkwwnCPjTCNXR0u+JxycFntl6nKT0cWK1nKVC7 dpJNo3BoTcgKG8diV8xYDBcrAGA8qrVoo3boHFuFQ9JOFNdAb1fVRENgF4YnUDGABYAcSPuOc09A FYjM7iwUTVYPD9QZGRt53wYE67a74MNa+xso6YQTyh3+wCCHUguUPIjawTGQCxc4cRLCLAIkqkGV IJEwtKXAyKyplIkSLuw6LgMAfvncPvWIeEsz+ishtSZq4bZkVZMrN7FmMKSo1jI7K7iiJPmVxSTh mZmkc5BbmEynYo+cRz/8Ii3BUnI7WBZ50io7x6WK+R00qqWEOSwMuwnuA8p5jX4dmE0D2+VG0OZz Rwfxymjl7JPwqPwGx17z8cYIhXmBhNkhu0JD1EPCxHYuqGwEhcgMJDL2FyD5iKTrJo4fdPY7xve7 s+1vut8j2PuDz8hJPmgdZh5vUI+MfKPSNwZEJEkGoyMg6jADcwd7hoQwwdLqqo9E+r4xUq7Xzivx duGM98rcmOFyS6GDUJCQWf+nLPAgbG5p72PSDDcB0nHdYFYB5EeQtEbjJDJOO8YByzLQOepwdTGS HuiENnAKS4QMEQLNO54fbbqoERC8fSQhLSdHMPQWXv+0MqYcJBHWjoJ7HCRG0iRYPPrRow8lTfo+ XCpO1Ie9iikdBpaGEYBk5h5SjknmEo+T1+eqc8h9TDj19uIGK6ADQAI2mKRxi0sL6zkBSPR3cdhp p4zV1q3Q/BcPUyREOB5FPhHqQvRlQ5y53n3BYXEVcDh1gcYTAPoP9hsr+1eDhazn83mX+a1edQLZ 1pqcWcMY5t6D8irxYB3nWXhrTz7wt7Q5Obaw08/ojMGHLoGTOdwa+Cf0Af2WdP9FJ2ACYo/r8TOA QqT1n5j96n2szFP3RNJzQXhsfDx+hPAVABAQi7gT9154q/EivP/8/TSwuf1OEcZaOOhuRkJGWH5x RiHIjeCX3BiHSDB7g4wHB0AwbUfsBru5ywCIdaJhmGgKOX7qQ839fMmxT8xy5aI8ikm0p1c8Nvwm BkDAOCkLxKrvtw2yvnvqBl6WC53O8c1In3oL+bVKxaKxtrRVG0bbGtk20FitY2sarYttUWsMgiff kwQJRzp+UrHf5CH/b+c22TgyEgpLHzXHPExZb8fvPXsec5nxpI5qiyymAYGSQB6WSS+LzDez43fI 3QnoUZIP+Pr+/l+qyHTL9OXdu+gP6ENqNZ/t1Uzq0z2v+FTfWSoc6i607yXEUXcCw3Gt7NJaqsq2 sen3QiiKiYKLItzcK51UEaFBqzMVLEnp4fN7WY8bfOMwaUudvpY/I9J37NQm6fqDp5oJCBuM8Ah5 KfpGr+sYZXBI95kjS2vfs27ds3Dbn8KGo0qFh6NjqSzilbAKmGenr7ftPaJzSwg0v7M8wN7Jh1fl mKKzlpnFt/cokj3iYKOzlXNBXWzlzHNO20yXrB971rcqFqTZydBsQqcj9ADhfdQK5uOdRbHFCOS4 rzTDbuVtRuuiP5+GpfihNmnfjpaUO5hdPst9Eq/hdItBtcW3qDak1m8u0o7+DuW6m3iEHSdcRtM7 uUu8iM6HhMdKJT8Q675m2cy+F7RDWawm6tIbpunvOCwgVF7VeaRB/5kfCk/CN/Oj4z2Q97yIfgRK EeKPZHyQ3vH2S3z+efQl8z52ha+zJ0VVmrlPErW5V28FqiltajcPspRBFXvKy81cTnGYBvoFI9gG C4jwDec/PyfYfsnLenIPTxLcnqxO4JgijqBk9y9MBTCYszX9XKjnZZbOhPXGwDLaxY3EwPY/U+Q3 X5ir9M3D/lp2/KHdJN+S4gurupz3za0pULaId8W3qHVItNMPRrage5jfIg0tKeO6lcTcW62bkp97 lo07UtJnTrdviHnI3LRBrm1GO7+gdv0fb3HNGeI8XJ3dr/QB7PvFpePS5MlJ+ZDcaOoNw6Wkxcep vnIWCiNU9cURG50nRAc4iwOZTZ86eXx6LjBw53aCO8CX5BMRNcXx7k/UAaNhS27jTBQYwUCGpDGT RrZv4MY/oKCP4izp9Pb6pdtjJbchuN9EeOwNSA/YjzKHaH6no/iXDU2/3YR2epxaGAggFMiLyhSD gx8as9G39Hve+kDSeIr6BJhlwm5nR+v7v1n52J/z/P86v9nIrd09Q+nV7u7d62azNZoeh7SaL5vj SzyoCiNFR94ZhkHT8XkBz/Mf8vo9yGQs8rc8s3Pg2WTjQ0KISgTZIcRcZsiDnvCh8NCjMtubcSnj 7Q8vadG0KqmSrnZyma09ubRStQsTVSyNoSIe9TKX/u6fclafUua6e9z1Ev0+Libb1+RNZUAfX++e QG1TmERbdcknfRHm00pQum06Iyc5zOlTOVFQs3zoG417tvxkwPWdwfMhxyIj5MaxL//gXj8s9MiD YsaGE0HCk/N6NLDouCEB9Kc2onUSmmHSYtNt3lM0W5O6jSlb+3UFriEjHOEMQsVJIqntNMKI2syo Mpy1bviC3d4qIVLIypKQWgpY8RSClipZSdqX5nbM3e53F84rKs2n5SV6vVLuHfauZlZRdqtTd7iN qsrWPUwtzu8iiUs5NHn5g3z/83+/8cNwZ6eY9o/Rg1wZMGlso6H6IORNn7FpfKNak2miQnup6x76 silCq+iNLPsc27mk7vtYoRtMXl28k6qZdN2HgHaFx3bkPvH2gu3Npi0Xb4jEcdyk0PkD9OYiU0zE 3VTcWgSBR8fEjMLjAFc1110FSNW6wsID4vg8iXJ82UbowZsyIu7WRwyMPfx9fc6o865158efFaB4 TlqU+3lBtEeZeZ1DhiHWltWm49xxBif0zf3gIKXTvtF3+EyxxFJkr5yJW+ndyYAhAruC1bEmFeDJ Om4iwx2ZhgsLItRZW97SEKnXSZ7sj2s9LjvHhzvt681U+Vitad4Vw9rUaqSkWg970pu9TqVMLTVp 30OGkP+dPvnH1nKiB+RFS+TUcRGOJA6SPQHw7Ut05OZyd66957yoSd6mTke+MRvHxWsiO5frQ2fw PJ0fYzhzpuI8rpHn+399z7L0hlpw8r2njzPsniqeJtBFOQm7U9vSEo3O2xXcavkStRvfORn8UPxa 3qNvUXfHjrXWtZll6jXrjuqxa+8OtbOPv+1Mke7ODN/QMzsrkpNrEtRaktPelH43Ld+t7P0/lR2H s/b3e6nedEcRE/Ed3fyp8uSmR+RdNZ2mvx04f08b4K5kkGMCAF+goS2ByCdHsrhg4w2nOWTl10uL KGQZuzV7FwQP3cjeaaO2iglYL0Ts9ISVAQVTaxgLLgdcUweATVRnS86brDpCmKpBwMm0ktr86Voq pRNSK1Uw3RDjVAfHovsqpqNRLQzU26HBq1vhARBPcmYeuvasdWLEX2jBfIP4Ql5pGvS4M0wWplVm zhYJpGu5Inpigmwm4yMXC7gzJCCEPCJ8v79XrwdwMfD9j8z2jTTvDh4fyc7s9ShPsKIPGexGVC+j NKes+vf49jJzEy2EhtdPLNUek0fL2Ee2QRc/qK3B/U3YD4lIfyB5laBf6ex9MPlOsaCd9Iz4zE8+ eaT7YiSdR64ezr6OgzVvR8Uw9zfxbtqctlq4V/B8Fr8sUTWOL0fywCbDZITj52NY+ydFXv3Y9NGG 5VRgCW4tTnvckFw2hkBQwOZMigJqa4tFcf5NAJqxQPt6fjNDzbaKhUJJdfULDZ21DJhTWPZ6es7/ xAem/dten/kPCsX8p/00CYGGFcktIaxA5LAWI42K5xSlIKh3KPNh472trC2SU/dpMPZ92H8Bwc2d nw8pxDQ0roOdk7isoiEVSL99ABSHsRUbyQFESYSGue/n3mUIB0cuz9b6WMae9UwqaI9QhFQFOgOZ Qm9Df0yEf54n7DIU/jPrsrQMUpu5lYH7hNDxjInqEwF0HFGurIeSJehBTof7mh7GDYQQ11Jod0HJ AMhDtQM+NtsU8xIUkOV1xpZplwlgj2+1HiSCQBGOuywsaVANVket7aek/MBYjDYe8MnS+r1CXoGB ZKEg+3+6NGVM0QBZgMCzB5QVIgQkGYQCAv5BDrpAtD4YsxYxsdYDpA2l9p5Sngj8Kj9vHdTrRD3S HOw46Jmo0oNa07P3Nph3bMaHCjxsycMzS21qfbzZJhSfEqPhj0YPeUmJZIaSciuMXnxAY1pD6E7A SPjgPYm+eDQRpjgH8CAuCJ0U/BHYi4L66VWIY8zJVgxeGC5nJ6sTCUxERzcCk/sy2POCtKC8LRWC vTPHicGk+k60pcrj9wePCncm5tOBomO+bZ2/ifm1m7fWbxAwDaQZeRTzzoyGLrh1ITUnLKuBEbYm mgVlaMiQaFHKdLohDAVgfHB3iLKluo/MHh3CMIi4nBUJ4uu5dUUdQxSpVUCpev5MOkQH861hzn80 EKuLyvthxxi+L3urRY7oYZl9uno0GMQ79WxEb5Sp5bE8sslfbJ1B32e71mOR1iU0X6m1eDENYoHT 8cn999MxHz9DJCdX48jwR/RDCTr0XAdmt7oOO4LmNS9YqZ+jjrnESNiOOyFo2wyRAPwPGv41nHQH xB/0CpK9BjG0ztlEcHqSGACW11iGMGSMsVRNUq9HzbLw/Ma+v0Nax/Dz2n6Tb2dIfkWY0LnRcH3I 4KCORI+jSZsHuHCp0VpXos9Q6Tq9WpzJhCPaO8nkHUkxgd+rHB8ankApOFDhAtfA/5fpxGAZ3vaI WeNinHiU8Ugp4nrtAsYRMHzBobx5iZYfGxPgXt/g4N3H2Oi/H8lY2U0zLcEwwCZ+AUZnoKErByBw IzaLBojU9BKiERYDuFlsUWybYW3hNbWyKgcStJTorClFE8phNMdF+oNSIswPNrOFYzgYWb0qV074 EIRv5abF6/DdranR/MuphNDD1LXnSrukgw+cdJDJBgNZqZNlzFh6pEy4JgyTAfzqC3DYSkfL8Mi0 sWoo3+514udJIZCBis5FRcrju4eqk6mGf87dlOqox3wZ5mYwr4gchgc4QwMliRRgRIwgp5aKkChT VGancZPZ5Ne7w3c+RjZELSaNUqcIWwIQOMSpCRfT030Tun2mThfvFmP1PB63rfrYbva2f5NnUiON 4VLINx6ON06tIUA8C4zrvkshfIE8WsGD2ft5nA4GprOX4kY4o0IdpQ16IMg4kyS5kwpKD5vj7fuX J16JSQ0DalxAjAPhC2w4fg85kq+74iz2VlkgNty5Yk171ZN/NhITDFGhD9suZFet/oG7WqVjdq7U 5JYEQsj2uRFEBebkcPw8xKiNMi5Hk4oGvsXvxCjaA6TMWIgqwYHKDgNTIyQMkEAGQrXFnZ80QNni tc/L6N/kCG/EHIAvDjckbUW0axKMTEYLAFxpemv429redvE3e3Gzc5SuKxUPgHcp4ZOw+PV3hMOw ljahB2CGqnjHI9viUkFQ5PpftGwN9NEBkMTpTw18se4+YikWAwrm7AajkdvZXJNFRxOVGLzn03+U IaLsxWLRjDSgqUVRCC8CAL4g0JyyYmyQNTzXuRTh/0kTRu9CfMnWB/Mzdxqqqqqqhxv0J6eAcs8T xRQxAJJDtOe+qYdPb6PN4vRjNG/eKwPE0DGkf0WgUwDrF0gUdVt2YUinZBO7L0J0w1EMuHWhuGvJ q5eatqlC1O1DIV/Un0amihiBFIKOyeQKWggpcBqdDZaRsO3hxtTI5dW3XFBJMVQQGRMUUySKypkW GfNhiTdcSf0Orya60erjrxO/Wzyf5ic25aXI2fKXD0DDAzIKmQL2b+HYYCbuvtoFhYQK6Ps8Q2HM RSQkVJFD9JdoZUnQ5DwC0S4LJIYbKEuBJFbAaEpKlqSlJJ5/sMNWOKco9/88PdmTMYREEIgsVj+T abv1TjCB/Ievf6538dhqwTDAMjNA7x9WG77UfULZhp3ns0U62Zg6Q/SCOgiQiQeYZb8XiD2cBFJh 5ud5Yyw8KF1mhe0b9fLrXmjas+dfT+T936P2PHBAAjpx8Pl68/N81LV3+z/g/5/yIiI/4WPpVVXW qVKlStUqVKlQ1VVf0Meaqq7mZn/BMzM7pUqVIbuqquTMzuZmfeZmbmZn/ExVVVSx2xq7u6mZmpmZ +szM11SpUqWlSpUqXdVVXMzM3SpUqVKlSpUsYTFjXd3MzMzTFVVVMzMzMzMzMyxTF3d3MzM/4PsD 8hAYH5FWsKzYfIJLARECYygfA4x4fpxFjfB7njOMzPCYzm8TfPokknkm74VujiXN00n+6XO05ZT6 foAuAqDrSEoCZACPXekf4aFpBa+4zOX4+cXRHJH1rIjgj4Ek8l4OJnC/OfFkn3RQYoQkpC1CKZmq WniD8guCYXgageEyR9TojZG2mR+85GH4D4fezI8pTatTdh9o74wMy1JgsWJSHiAzKKPlfyiupZBV wcA7ZSWPAO45POWbTcBftJL74GhM/o1MOCcJlsB2Dtb93c7V24+TmUif3D4o7h/yX/TUuSMIwgkY JAKe98h4VqZHOTkdAdmz+ZKpT0I9ipBPuDCyCof49fzeglKTh+OlGCeedp2blFIjtN7wU+GT+HDr fYgYYpghnph4Up4tIwEHnxWQCAm5GFYa5jFTiDpq3RcpLIIzrBlg6hGMSezC1pOiKkA5WIU3JWgm SZKBsJhT+tlAeubWvyxixg7DF1gywdQ98Wgo0REtjCUaaaLlj22/rXUMKQYrKj4sPTeBm/1w4bYU 2m3TUJtNsKa5Z3bDGPDE1w8BjBHiH07DlIshBbC6B0NKZugaNGQE4Az5mBmDCgaJgKYgaWBA1tds YyBMRfAvBYGU8ibDAqaEIy/+Rjhthg1ti0UD3w23OaOBSZ5p3JlInDCcQKKU5Jw4YhwKiWlhzApv xKauzLoOnMbTt9Uxheg9vRRDOP9o3TDjBlbCzspWCYc78NDPikr6jV2Hz69YLp4fzmzvYHHOj59M pjI7EHWVRQytWS4FBkh8Yg72Ht4pZECXknhRKwgfP99fwkjLz7bq/qv4blHwup3PV2bxF8MiNW2L VtqqTbWcFTvV6cZRxGRyqbtpJMLCNkKWEWKyRh6zzUYy6RouGlLP7uy6qi0DYrMC2eMh1wQV7TG/ 3mPex2qtARmkiO/uMUrnDfsRO8+E9lkfSj+J9T9ZznOc7q18ZQdbWdPNjwoknjJOSM4gPvgeN/FG BWFIYx+AeHSF0Dy2gwNnQO0fyDlhjsZwPVn1hk7uJg8HlVCXQnIjsm9+TKQOPYnoekKKUMwVR8Jy 6bR27yNo93Th/P+rt4jvajUQQ6aMtMHoazYaqV7gpiFecRkTQyMUh4DgZFS+hW0W0r1PzNi3EqQ3 g1ev/sDog09eVXe4NISReF+SRrDFaFzfQ4ZhmGY76nJ7G7Q4jf0vQUDeVXEfKwWaKsrFwxZSSMxo oJJykAtT5oknLmIDweEZSSKAi9E5C4IeQqoK61aHrpNJL+8Kg2PgPZkbHO8k7XlnGh64g96O1L6i r4ezsW+xHfSEz9+m4+2BHLoOIgT1a0lwy379rCoBsRDG1z2ZhYJisIEB6LqNvlUYpG8PzWFv5SCS RAKRJ44Q92TevH0VZBMrIAysuOVZqWiw50PF0egKsZewc5F3mqW4qVDS0Jg8ofBI871sAUnCNFtO jOImtMfLwUfga1WbctDf79E2DgN8xGjTul3DQDEg0h1KAPoAdaDBOwA4nhqplNaLdICp+UqbpXR1 4T+J86ekDgmE5wCgTAfSgfsiryiDlPEHhE2tPEcYpZaUHVSfc2nVDzQrnnsTC6QLdmBRA+6mnI0O G1KTSqHEqoNAwUkUKNdyjZgB7zx2+PXduSmIODWOCEdFQh8Fx7T3kyrxVj+Isc40rXi6h5YWhYUK ZiZGU0imxUegNcGpvBkwbCFLT7Kp3LTVBOXft6j00c1N/KcsPELHcFM7NmJEQ/QiFCdjxYxj+DTY 200K+hy/nu2awYH6E6vajb7ivCJmwerAWIGQRdxP2Gyw1BFgdHTYJx3hyuP+obbJoHG3uElX+nhy 7/T2ClHXLeFp6s7n7chUQgwksGQ9rYORXduEWROE+OnXW/Dj1ZiI0C1nnPW8ch3QDXQpMdTVdmDS dj1UspjWyjYhVWEeeMwYVlTMTISUGKCiZWhNYKFD6vmD3g9wYOjn3B48sHcYuoYjqFAUJebLzpgI XG8HJ5Gx5LD9XgcMyQCukvcEIEYDDKNVTtcAmH8Puok0E5HUD/k18YmXlk5dsTCm7uCHidAyrh0y YXRPRXimNqBKGH++Owa18foU9By845DpDXfAz0YhoJSq+Pxcgqr4YX0UWVSaA7RxmwZPwoRSckn4 1yBsAoe0Wv7BcwmQtDw/ZznJ5tKlcNKUEEOMMyx2uwLwknSBOaTxgyGNNijGjWRR79ZKJNTLEymk vC0HIsGvZCZkFQSAtIuGlU1/lt2IoDVSE1OYb761ooJE5gOybrfBQ0gMR6hKM7DJmmEd8fPk/QWf kvrcsi2cfylSeFItTsqenjJ/dny+szNk+q3w9R05ab9YsDyGknu9nw6FM+YKlYv4OVdsGB6cBvnZ KEd2j0Ezk43hOOm500ToSZPUfVh47YemxmVqR6eX1lfz35inOpH5ZTl+Zh4pLwqZ92tclk8Lfhw7 EH4OV4jD1jwYQVjCQ4MwbIgoJa+wJq3ZNvKeI8oKeT9BSiyBvGOFIOmvIxVld7n13w7Y6e7Y4o6y ef70YP+diTvq21ViGTCQjRfrtC0NEFZpmEwk08nBQ/sKJuB5+fi+n4QPQFJQtYHoAxN7C1Awo5/M cHqnKxDzSO07koCNBWOcxvGE9kayOsBQHLOuR9PfpEQw0HxzVYZB6B48wpxF4gIGqxaUgAIyMkj7 Zu01lIMPgaTwGGNdhQ6qSHBdTazP1wjol3DWZuKSo4x6KF7Uca8F8Ua5BMOwPJJaLglkyMC4NAEQ mZBqB61KxxQjRRsCp9mITgpfHXceITLysTTKNk9uQbzuTFzCag5NqaiH0aV5NqdiOycnkapuOmD9 PTskDZO05mBI091qUle7I1YQwGKvqSI6jumgzObKyGzGxDq0T3Nppkm6qrWxwmE1oSrGGSxfQwSw weVwlJBCgOaLnOcjeoG9RK33bZwCzIKRkj6NkLpI4hxsDQhtsX5kzWnh4Z28oiioRmjcj3jaR7mh /gi200ORPI4flZz0o3lwgKHo7Po6uQKGgKFdaUG5g/Lw/yPiwe/1IrzJkL8Ck/46DMv5jck/UdHo Cfv69qno5Mt50iiCvOLxeZuh1H5uUwp83I/J28+kjgzZ31ueI7Cni4dm+XSDrJG0/Y/Eoo2aQfBL Dn7YqxzlRLFCjbZ9kBD1sywwMiQoULZmELSCMCKd6pgelVC7VM+cEzBHTN2iSoP3mIME1ZFsf39Z IeEwnLzi3EZ/2bgiC5wUK97fJybM7Y4EDkHiSCIJBEjvQdUSNI2g8rIKW2qtJYoxKMILCIGBLOXY Ggn8JXz5d16a3ol/9HkIQpmcE7E2yDWpjiMc88rLFrZ805OFa4ZaBegHeCOYOq7momjoBhI31HUu oJCOpFquvYQ5yaLWHxntODo2y1K7x+iP0v4VTF8HbrLOGgvRYJZ443Bi25hGgGzWSSHHewq0N7BD mCh6Rpg44/fkamXPGgLrSpa3AjBPc8GcByAw5mRAXBRQ803qKqR0rvA1MNEJSaR+iLaR6103g8uY k8HPEipvLCC2VjsxhVh6AxUFA4woYTirzDZDGAgdXJ1kDnWjY6vALN+N+uNeA5rWfAUsT2Q+iI+i KuwTWB3HMINSBP4B6i05ZOt1aIpJDsA7FIHm469fGlVoh2IyRVY1wDa4zBg0ky4NxOoJFRqPdwpK RN7rETCyWAFaIBUq6Sg80DVMcZIzeaCmg7jbDR2B5YkVMNXxPVrrs4z/Tqc7D3dw9HI8YwIHOk6+ D+neb3jC4S2vQ8OaSx6nqTYbO6LZMH0Td/j0D6JDSDiYIDA5csgg4eVCn5YDgmFaLEFSKsm1UIvc rKigjsE/esMAkCpFEwSrzglirByRYyJgwhzS10vfMdlIfGA6MFkhFkFXqSD+eBkLz1P7XCsCqn5s HYhWF1ghyA0j08HvtrFDCWj7M4xckd4aY6Dd8/SezaDYxh+4jnGPAe4SNRIuWMhwH4xQOIgxU/7J C848C9b1MNQXYoki2lfAix7Htp6dPpdxnnkryrK46y4j2xPb+PBVMhPDWyEO6XvuVFCMLOcEwZBs DmnhHABVDCdoTkTdqIfkj50dCKREbqNQfryLJUCO4PQF6HggPWGm/pnCBvjggY8evez7YP9ahFUL AfASRMESZCxYFW0qUsUk1lNorVAKaIJEwSYGQAJrZTaKtsCxJattllKHvdcFHmM90/PmqMHhDz5a QAOZQ6GETAO8IGqowG1eIQNAsYG9XxWD3R4pGJ2cRNwqlSx4qJsVM2DqJR5wqCWPDVML73gwiZ48 StfL3A/RI8TvVzpMcrMiJMlhTrtHafGw93dIz3eiNmdIp7JnwWraLV9rqrNLZZYXfiJXbvC0dmgO z2TsBQ8TxOg3e3baI6VCYdzOTppttMAr8uTlLpBiYU+Mqq0HJMg30GslL1Z7PaE2oOYFKPYAAZ1N A+btfORU9DBQKiO38U8Qd7u3h6eXdXdu7OCsEeKQOwtWez6vTGy8ZFPYIwSV5cxIJcFyIySCFMpP LpLg5PWAHO3OSJ09bH7VUVSAjXXvAtiRRWDh/ig1SIBiGYpo4it7AlEJqPq9qShYSa2rOy0Zxh9t 7nwQOBw29aRhgYEg1YVZxM5KhJZ1UXYyZd2LQvTYhP7mRMRAV6iXwfUK1hM9swtSeFIQQKToTKUl DlNTcGBKD2lV4qd3Fia+NK1uKjJkJ9F6jX51cQq4xl4hxrX9w8coWlepxlYJfn8zynEEbivTiXD9 xh4bY6uK05N0U7Ghr7e2R6JD2CwPvShDBSDRQcAOGtHaEPTig3hxnJZLrFpaTwJ5lbv0KLPkj0be 6GdjAjPvodqCj5pRrd2yERLBEx4HIe9FiLUZnKWT9IFPI9I13EMA8jPyYi1B0cHf7017tSGpsQ4Y 5va4Oz1c2nbKZGoE66O2g834vJ145mvXFTfFhGdzSXacPqlObkYqKII5EUgGlDBFFY9gq63B4urI HgHZ2U8B0Ou/0nSez+FHySKU/gjHmj5CyPQkeqCetNeaH92HlwDqUtLjsF0OAj0RGjZFTSJsUvTG XMOdu7QfhO0DkYAEWD1VIO0PxkEGEV3OGd0GhKA4iygnic/tXEFSWdlNWEvsNrXFPDgF8AKRnNfk gA631ZDibt2obqzSEEW7ENIK7kW9uyRKOysHlbF4BZNaArLMD1Uu/Qdg20OUY6I7fUFJfXkoytBh 33jA6v9X+3eJyTIdxo+zYT706T0gnM2GQZNdN0MnWHsg4KU66kB7B/1YCHOFd31TR0xmPpLJlMLy AO1LB+21E5bxNFGkHHuRwumECg5w8Qdgk2jvdTJ3/u7NdUd0cGRrJ2e6wUsUNiS8A9NgtldYVV9g aUX3SIWT3xUUPRRXrsZznDwqQ1zaeZVBeQrGvrdNPFBEtwGo8hsMCU1XqYwpxUrsSjp6ayAGuQ+2 vOWZD/mUPTOb1MlfODzMT3A5alKseGlXHOGoKxTDEBVgLEnZz3fSHEIpwg33cqDsSH+szyIFUd6b nGw2J3w2USSHHEcSwr5mNlFeioDSyRtNjwzb8vmBU6I+l8r1rjAau22C09YMr10AYjADDIAZMkVg kDBIYEFGT3gw1ZW4MobCLvxfhYYPJE6QK8JqL6gkWBGhNJUQizlxiIowChHsC8GDxNpJ2DtOSaR1 G8SHZK/JUWxagwB6BwA5JTRcrgpCoDTfB7X9RP8/IH3g+Rh/UHHb8UuUyPky80N5i4cHccK9wogM JevTo2bBI6gVZ20niD4w64WnwU3pqhesEPCtnwLn6ve16iG8tuU4RhWU8RJK/3UWjQhN11D6mJJy RjQie4JJCjMc8hPVfs1YytDrpEiwKM0cYDDIGrt0CPKeEBTfh5TQOA0C8hWhhJTHmRaohsame++r +oZL5MgrKUkuwNAIHOQwwEDZgjg+22jSugTZXs8P4ZpOHYnBHCRwjZXYeaJReqG1FzqFEK5zkraH CWskoKJ9cxCRmyA7BgEhkwK+JOsTq1+VoVwGK1jxCWkOXHKKSoV1TkQBlaI7U8ReMQdS7WYggyps jlSeYmpMqlA4xY4iXvyO2zkLgkFwQqBagcUBYOx8Iiq/Y3U/T/asGI/qwduy8E3HHzbDY2unuUqy oIVV/X7frtClHgMVThQnCLQGRhAHBeMDixDgg4JK6222NWFTYFyKusiCtAZFwDA4SxkHweGBED7Q f5W8GC22aevmNqHnmjZsoSEoeJjl2OWPuY/v0492nMkHdA7E0oMbUNEDcjTudjHU6eCBkEP55lQi c3EQekeOmz4EgoCvc1hMuocD0IKgY9NtXIECgoMHg4rzAff+oK1UQt9fjrhbeWr9BPwSSrRUPJy1 i8xEYYcEKxmMoPJoy/IpTQPGoubnbCQOWmkBzF6daUEBScXFYUVBGhskc9twRsQrE4kjA8qvgU1T eAwGT8MWgzR8dDJDTCWwjC/SKpZZWcAaphVjVZhaHM+rBS6H/DPAzzArpwmCnfd4dhKfE9+/WNL9 WKMiukarRZ+qoJDd4iuYK3aXpzwK62beFzykMPyefkB0dL4rNE7Im4+rRWQAkkkGq3PLpePpDsNn Vp2G2tHaLtiuG/oDXqrLbqQDc2wsr+eoiTdbSD0i9Le6JewExxerIAakC2aiz3kr6qEPZEXs62KI BsgDr/M4cGfWz9aHAZMh+I9FQ4MhpanU8/oqepjLAprJmbg9XAdvRVlWFsu+uQsVbwezvcFgCcnU IfThEVcP1AVqNpWPHZN39KT/d/HCb/k700tIMCCcArZWsTnv9SWFhpwnwIu0eXH6YsVC9XxeJy5q e/wihXvSdpDqVIyw3VJEisHBZ6gk8rZwbD+K/uhWHQp0dGKrmkNwuXk9bhFLIlMm9q7zNEgiQvST p1rtFoNRzKCipCiWK8H1hvbfMHYhThSHpTz5gxN9gScUiM2FATDHYovqC4JQlhdEP5EK6R0Wd10B UxQKI/FVxCMQ9F4UpxpCQRP31pcMw5oahqJwTYo513hf+HME6m8j0CUpnpdysVGRIaoHlHLbQR1f sV8SKZCRKafXkWOFkOBya9K5ZAf1o/vgzQP+P8fEBG2v4AqZEc/fVFSAmxzpmOQzQuA5h5Zp/DsH jtqdyH11prpde3Us32rBHBCZWQ2EbXp4pcTViJnz1M/McmGNRPl/9L4A3wx7YRLRAF8Qw4UG7ICa LHKg2KYPlMeDu1D3mDlOVR9jvvzVId2LhFZL5FZYnpQVltnYaFL+0b9ES9pkEKGQtTIcDaixOdip uXXm9jnJof1PAph0ZvHbMR0SkeRSfYPxD08DYflPoKdTwOp4J9RGwMQKSWjHi089gkQzDoOp6DpA ZgjKQVJ6LX1DTQX36xx7QtyCQFYPCQPD3Z9uAMFkqTJ03puXiNsCK+7Ex3MzUMqQf+INxAzwa0Ih rA6wx2pyEvtLMp309IQG0g59oUujFDvUxtGH5FhwqNlh4yKQyO6PPHvjbmU3Vyst7o2GemmZP3ZG o2L9cjXv6mx3x7I3PGPdujUHTIyO1iP7oSzUH4dQUWkY6tLGmSpUaEelgRPECoeh6RrDWKgqMEYI rirzNEi9GNlKIjkOg4MO2eCYet2y9ho97Mdp2O5Xf3u7crlcDrUmHQQz1EzCD+fjku6AYVuRUxBP LglDJQKKqzGMjn32zCAyMrA2Xg9EkXIzB6mpgw8w9J654DojpZPEjTnm2qnYTJ5aPnntJixOaU6R scuQjQYpxYH+Ntbt1GoX+/Z5DjIdwaKUGquGg5LQUGiatAZTCwwbvAp542jyjI+55lHE88cZFcUS dklYu8XECgEkRQ5IrODwxLcAmPHgq+bbv2TY2Xf8CgIduHA0R4ZToE4VuJDqdN2B7wp5yyNPErVM pIk2Kws74lObY2mY5JI4kM5SMU4xdoNReCQxsNP8ma/ZgocwjA3MSJjADmbWFekHCdgiqaJoZuA2 cdGqQj50j1OOviUVzBYvqNzgZsaA3hsRwUUy3xHApwvfnQhjyvS5AZIfLSXuFU5rQq04H2bVcE3R LEP2FaeMhKJo9iJeOlwi3fM8+VV3aB7XomUgTBs8WTogQR1FnhFJRWelKgLDwCIVhARWTmGgNg+p iATJ2PNT+a10ImDUI1bwhWatznsBgY3PBwCtcEEWlgbAt7ArZCfP0ebzaIDVcr8QT6BqQ5u5OCRY lawv17HSnIW0bR+eZqhuKb3rUAxiSHxsbTQYYSQA6yD46XjPK7aPEMBh12ynSfmagfS7goX0RRUi bIpaxERXDPEagLF4wgbncHTrvDkehOJgUnJr7bU3CWO5KymvvRDLo7NIfIQtIuQ8WqnXg6tzttjP dRwSgHIatDkXW1dSgQYDny1PqCsvN6IIDQwFwsssePwcb7TkUyuLrWQ+gvLsJDlHQOCoGBIOIM8s ClBQXvDq+AxPDPUOputW8RbaIyTiXGHiKXQUo8oqGRgBIM5HOa+LrCrBEmEORvY9gRRxPM/nxO1k 2GhIVYKdiGvEdBwdYeTIeSBr4C9wd2HfCw1KwkkkkV04O8VYeMKOpLVTSg+4ORt0D4OmAtOO4NDG AgaHT5BTxuQypkOWpIEbCuh9/CCWuTrpSdw5t1LaDLRQldfqsgpkKzA1YnjFNTJOpo5ljRtmpU6S mtRjljFk3CynTO16MNUmkFIEQ7yByJkM0WlsBOCdN4TUN0qw3hxGk4bsjz5DVudyV2eMC+XwJbra URF1hc8NKJqVZUkexFQol5Qly2uB2R+ht9dffU5EWNWM9GR3xqMnWBrLqtOE6ChCThwwFsFQSHMk 9iUxyJSNKaWmkHCQBt2iUYHQ+XG7PVaeSDpgNdw4MYDhTu6R6OGAo0XcGNkhTtgMK92w7OkFNF04 WIjXUoozKYqlEk4IwcyHF447Uy7yjq2DF0nIdjgBDzs7jaz2cbLoUfuTmwpMRpphsMglQzBwLCwz jkyLUMic0a0cqV6ORHXMCcDr3J4Vm0I+wP0BwY6kMOEnIyppr0knb6do7fusOxNs2eFFAHhW5W06 B+vAaHftrgNIDRLH2h5umpeCT+RAeGvTWE5jHykjpkcQeTD+V98xrBWTCY6PDH7v19lK0/cEH5x0 I000wpD3HZjAkBzkOfMPs8VoKsHGbpyKyBt29JgBv0WYcrSCQXYKd2hF0zlLc7xJWCfyA4R6Q00m 6oiP94anrGoYvsxa0JamCiE2E+ocQZsUZv4xFyYl9jhD7MRq+ubh2Fp6z+4d9GlOYxtF6hYOCsiz nstIeg2+MKrpUGn8utdidrCJQIVoanL6bRWBJGDrHlpTrVaaKoUOhBz85UnocxaTioY6cp6ub3Os wX6OqdTkfn6PKWOaweEu9EOVGKmB1rJ4PmVs8PKEgeEA0B94aQgFQUhSGYVBlaTtJyoIo7AtBxDv DN6TrB3EV8Yy5cPEGz8A4Jh2nDONlXBVZMA4oocdepCHq+OhVZDqBPg9oQM4BC+Pc9FytieS6e13 cNchuTYsbCfDlY4CBAmNJ3B6cYOgnZPYGlauhQYXMEpylhXAMJSYTAU3dIdIQhMheB6Aw/bgApcS ux7uOeHM+jkDgpCXGVciHXKFkw5VzgwtIMJxwlvn5mtCqpz9HpRO/B4JQFdUY9+i3uz0im9cnj+y s4+1h5NztfJuLu1YHIo3GebI94QDtTpDeF+Pc3fmoBVRTQT1lyBtPkR9hQ+AGc0a7k5FugNuphiT HhBLLKEqpPUJjHeD8QkSg8Z1nSe/v7pFLkYVoZ131pVBsR8wGTNcd4XCVgU5buYKGDNYBCAaK3i+ SCedGWQpHKJwnXOcN/GIIhcFf7hpHzDUZ4SOndh5OcePxJzt7O50NohsqAdUh4gRVLidzJtqPGiq XlNPCBz7gdaGtFyNzxKxIn6qKS6ca9I4Qerc5s+aq7uYDQD1eCRY+gNDqrKNJyNMuLQoA6wHVj6A dWEQVTCVPiF1fJ40gCWqnFDFmkTNcbJOHs6GAcc9oEwyljFvZ9HBvqhvr/Bn6GK+oVn2HXINCJQa AIDg1Rmq+SoU1HFGwNxjSyshSI6TDuHBiGJcsUGd6Vaes05Dg+QJA4M0aEa1ijsqQOBkWLIcYliK 3mWq0jomSUwpUk+p3ipM4VTaQV0qhg8yrxlWNGgqZyViDc58LJC3pTXEElFqi3K9KGUp3gnpEASx LT2BtWeru9ce8gC0RkjIZEZf584A8Edig7dz3fFwQB7CAOCYQHz0X7/bwamKGSbTfBHxlsos1yAL NAQCYOC0HpUAxTTxUUIVS+ATD3BApRYOw5x1jprLv3+lvJKhMZWBk9rhv348lYRR6nJLiYJgSdeB qL6kVhFEZK8jJJQDB5w3vl6ncHM5beCByiJsaLmOfOTA3NWFkSYKdk5aaVMJoFBhTlsUFL5hOgHk mHcRNXbf9v9MP5W+npQgQhqSgWRZE+2qU6QgjUkkWEE6dPl6r48vFdP82xemR46e/e+kUB2S9It1 IuYRdvCtgZlSthdH+KslNMiSvRXdENoR5AmrA01J/ko8Q2StwkZRIwo5JJuysqVDouze89IZ2Ei8 TprKhaFkWAIaKByEkoL9QoNEXVDchzvRx6F6dkBfFgsVtBEHBpTiw0HtYLw41poFRGOfMh5Q2DVG Gpig6DLld418gZTRMrROI7QDgJyaPLpQB6QT7E45OKbJAJj7gIbIl9HQ8dv4FxoYxjBqbx5RJr7X t2vcrzcRXen66civBXvMjkEpSCcC2B6gldcGFAd4H8RhEgf0sKT3YpORzkEwYMwz0nmRtHo8Sexp przI163ZOtOlNYmO5MbibJ5Vecgf7qOoJZNk38KTa7OxSZvx7EcHDjvs5n5ju013s3PHl2DVDY30 iG+f50FHEI8InU8mBUHK43DOGQceEnkWKIg4UWDnycZxE7J6L0VrtCwIETlCzA8tbQQ3xPQfLFRv 7vfjLWgsRPzTx2Uyd/t9r5CMw0awrDYjQCA1aVkwFLyTxF+3JVKYixxqUIZCGgoKtQ5dbKVT5gwa u3nwLQoVTOEwmAc40uL6FqyzbFFFDx1OK0+igszmbmCisiwMJDWGSQ80SFeIYJITgq10T0l6LLVA VIWBXl6jEotbmaJoqyprATr2H65zfglPLxVytCchQK6Ujv0nuRrdYG1Fmy2oyyua84grArFqMDE7 hjvBw4cQJDGkkTcU8MkPtOW/fIgmwoCrqcK2jlC3n4ujkOUWRuVStbNv3e31ctoTr0KfqahhsHcG odF840D17nRDZyNcrDmAW4SJJlUImMJ31hkBOJzCzTA4Yl8DenoLOESkAkNeNJQb5uvrjZGJ1Z0d vtTLydq2DVZHUosmuQ9Ww+iTmb6qwfR60a9PHc7/Ttrq5d4Z4dae9NVU73w3UEfNvqzA0JfA6iST IfikM4TCXZwZJ0h06Z/ndzx5CEYJvSQl2ghkZ14pkbFcvl4jZeFpO8GTFwOWsZDFQi0gT8VjzbQc tcwB8kqG59QZSJaoenSluUdqoOCUlG/qWg+G8OmqU/MC+NBaS5iCjCoO4utYxRaYshVtkxYDgSI2 EEuUwE42YIwthBFdPzFcKW63hhNTGG6wZ0jMRYqiV0yBtKvMyPK8reGIUs3WZPexsyC4tNxECouZ UqFRSopwgoVBkC0OLIMKzMDqXJdItkSwUsRlScIVIyTEYJkQqWtTMhJ0kkklsQxCCuZJ9lDN6PqI sbAf5EqIwidvG7m7/36nj3vfPfeTB7uceGzNdV2bJamSWJ0lCQvVSk5HyoZGdt6ea99IPLfuCbLa gzYsYkmWujB0ORKGSmHJIlwL4VhwFcX1c03m42EsfoEicDbH6ie+g9oc8GDuzDtxMWmKCEOLnj0F BkffN2uDrNMJvGXnDhdJE9oUNZX6ayRlTwUJwX3NDDn0Ovf4rL92+cAusJCfgTGCMg92ImLY9/LM IOsOhwadU2vfTGb4jsWR0LTRlObPDq8Z1c2/U6RTup3BRWnK9MupUBNFUCC0vmEhelTLzBYmTrkX X3x/j0e3fu3b+TxbRp+vbd42G2uDQI744dhzm6CvEmnkWxleqgeQLIzpMCKNSLRF4k4RFVIhjYa2 cWwQ1mNCIknHo/7GaT3hmJCwJIYYxk0twryxgZ0MaGNdN7LYaGpjac9TcUVGOyhCVSptK3gBzjgd i4VSQ8eJEoXQNeewvynGEb1fgCfXhjTcYMZSxlgEJj2DxhcjewYxDaFp+c6GKDTsRIf4S+qPQ+gj XANv5NQzGHREswhiYwawwYoZrQ7Ez0wQO2imOAHOZZwQJlbymc03lEMePIx0MeN0GjD/CGijfniz +LnphDcDTHVvpiuwGlWS1nb2S9NbSwglJmPQfc3rXzTWFk0jBF8YEU5KM7mhUDBHCDPtVCcrs8SW CqyB/R4DR1HwHTMzaL6YqV3/LWq6jVhPXsEbjLhmSrZRtUy94uLECysawGvse+2gwtZqGT5Rfmh7 2uu3nKcnPe6m5oNAzU6mOdKrOb7RPPAFCyyJEpZBEeHLWgxTzsEsqEd0PlCLjVODfRvcJgJBdHhh tOq7CE3hzNSb9wljyGhuBjD1mHLBaGiA9mkxjziR+Dp1TfwEioiULaBELdgW4QmJl8GQWU1UskT5 aEYNjqqWbY3RORUCLrgqGnRABw7AjcF6Rq+q0HQ5AkcdjjA7eg0ScQJJsCOuQKrQ7CtGxNRJCqDd AL0QT14giqiKk4EXHIWLWhg0GVWV4gcyeUdBaGAOFhQwWylAcDt7I+e4IrIGD1pKkMgsHU6tAPC4 LC0qdTF1JzD8bThg8NNgm9N29efDQ2VKgrt6wxjcPzCb946aZScUoqn91hhw4DzvATxYNEgJexA0 SgiQurTq92E0DT+LxL7+h0FOz0Z96YrkcguBwUm22gZNErIWJYevNoZaMpxNAIJEokYQBkXhSD0W ogMhjgrfpfSUhIRckrFGpmCpSsDsHyz5VE2bansWtEOcLn0ood6do91KbigNL35C/LgcM2chphNU 9RSaX9zbD5MdhQzFX6liNjLOmYWPENoPg3MljeGhmwKkR08Ow8rQHUc3o8A5jQx05QmJG6O47RIK FskmA0j7yrCwkKD3eK/FMSRRIHniE8s5S2YV1yRJFK3EKlQ00CkJFpFzItbGn30bSTlX0A20s8EB u0zDeFxbOQ7F8uS6BaEF1P0DzMc5jYb3keXQ6wSIXlTnEYOf4SUBWsa2G4rqsYlcipGtHDGMk7fJ Fk5ALeE5zQ8HvNF8LAxrkjicusgG8C1y0ociyaVDi1jsjUVh6LVscCn9rIDYdswux2YM8bH6Gb56 gPYKRz6np6e05UKALyncXF2/WXBRZsNFGm/Q9OkDCoiQk+2v2BTOe58Dr4czwPV0pG232EjOSGvp gY6we70FJo2TIHCsB3P9obB2AxxmyMQX4Nw374HAb8Xa8D7N/H5hRflBtZdeVU1vCOWgsStQ445D sGbGhOtK65iK8khmDr2WCWk6R1q58PNzsN+RSnNUqm7tpejYJrxW+jFyev2jRDAyQ8VrXg69ExQQ 5HToJvxLZo6eG56Sx1J2NhwNSLx8873ncV1TiMY+mmDsXtjhXkHDEWVskjuIpjh9PfbGjGNnU4Dl ia3jvK38RnqEzRkSq4TgmpiEhTX1PkQMAkkQGk7ayQ42qm1GNURK1YOKwEOpRNHMp0HOOP5pzmdh Z3UzjXLTYtq5Aglf5tuGsMFskmGQeNK0czgtlwnbSlcZO41SU9tNQvF8HAtqnSR7DNbBWiS7Dx6d Glc4+EHjQgw0d42IjcP1iGrFZAsDMUDoQCOPM6PKPDuYxO96glSw3bw4cwjYZSQIOAb+IW2j30EY 3QPsVhIxISHjj6DqPo7NON2QM4EAm41of9RBcdhdst20HYV/Ia0fhRweLtuN/Ok4TTyhpWgchgXe 5KTIfG2lp+zY4PyPUjb5wOmTBPlrDjHgtiG2GmJ4zm42U7DHB2n+E3wNmLuU6uNOeKm3l37lNyaa MjUc41Ho3bxfW00ezg7Bx48ymuHSndjt9gWQqN6MiuySpg8sMpHUd+pjpyA5hwG7Dgly2BSYIcyD qRcKacGrSiGpqU2GPO9RSYs6dx0vvrCJtv2SttI5Wj3fSDitQlSXh0OoQxJA4kuLRyohbGD1SBRp EjsRcV2DCM7ykNN4yePg5U1qBgQQWHb3G24L59CkCuOVNS3u3vWJCBevFNUpBQYEDMEsx4kLCvAI YuRHQRVaND93L3aBugZDQh72OwndgU0x0dBoJtTRhKS0sXjVHYfK7FNMGsx0WvBngdAwWmmhFFx1 fYB0j4boFbtTjPiEpFtOSlCeiBx4lJpHxaroRJP3TxdvK32gSU+s8Pd/Dei81CoqAZz6KKKKAlKT 8ApCk0WjgxoDkh6wjCMEJRC8cs6kPJwJGeTv287qwfkbZMpJeU9d1olPdkhlBnfR5Jh1BHWL1HqH lIVsIBrFyXDbXYR6gmkilR9J54TE8UX6eycjBjI1IQ3mNCNQV1jKdwO6Bzn7ZoeD1JDj4TH7Aupk JFAnMndArRI410CoJnEh1vITKQlHgJ1I9HcesFh7i/FNZ34DpkhkiG6vVY+Y4oBqRRSkSU3kx6bE G/YGx+3WHHd60JMjXIbrJvX7CS1Isgbldkbzz7YjuVGSHBU0wCwdwwHEhHcwrUryn+NL7vx4TWrR n4iUuaF8BhwLVz1I6DR+ZJH4pIp6XoLFaI7I/iPTDc+2nHjOI1NHjGQ7gvQiyEzAWCWH6jdw9gH9 q8lwvyBzTizvT3ra8SeEn4jvD1j6R3IJ7b0v9l+q25fTdrb5rzX71xdeX/Sbekk3v6rk9LsR4EIR 7pK1T1FJJvKhQknVJ1CSbipX8PSpeFR/vOk7vrzffzZ4o7jnRIkWvKS/yd7ja6W0lK/xqlY72rSX spUqUk6dJeV4WFvatJey9LpeVixYkteU+hECOCJC3tJWvmtKlSS9mfWtbht9+s716s89+V5Uqyn2 rXSox+JJL3VqVKStUpXsksLe1Cp6hLSxSqeoSxel4VHh3Pd38u5Dudu/h+lxJeG9pbGcZe3zd/5i jO+uoldJL0qNva9LtUO9KlJjpfFNfGQzyl2tLpaSXFS9ltdGn0tJLtOvmul2kudya6lFMJdrwvB4 fS2ktr6rwvKqbGtaySiNT7MVvzQcJxz/YF0T/AqvlIHugj+xMB+Xj+z+v+z2mZmZmZmIiJJmZmZm ZmZmZmZlmm/ElRZ/EfWYH8W/l5g2kfFbRajaLwUfYYfCzxsu47DRFhU9V3WTT1bUWe1U9BVhjAbx F4CRRdyROAH9wUitpzAoR32lKDuA5cCnyMFOhh7KDHx9LV92jrLHlH2DDXLrqPn84008jdv9qHlH knrlLFRo6lj7l6eKN5DpR9mtFUkJSa5mh1fQ1iNQ+UnLEckPGQsufe0La0B3hdsZEOE+G7eZo35h xp3KbhOQaDvMvP3hMfoBgpDrAd6UCTCP8A+LB6MmC7ddcA9Qicu6MmnYOXtCG34hssUUCSBGQQFt QfKLI9QsEh/NXqOsfrckiSw/x/s1iIfgwhAcreUGHpnOQ7jQJcxj6ubPI2rl19xmv2qNZ9F0mPYF 1jJrOgGrYec3dOH86prGy5PXmX097tx7Y1kqvxPz/hGVEXeH37MAg25FHUYBU7RFDDy6Xv9/v0UI 6Zoo0I1ov1IvwxvFp6q8rONihO3+FtnxOsNfdzVQPkdclLozNF2imRZrLKm2G7dBWmWteJQMSBqN d07nQtYhCoqGk0ZMQHpqYlPNMKTy8xFrKPYEs4q70ejXV7GtsyHFJ38gZBptCJc/+3cflsoDQDhy uu1obsTM0novdcoGAUjpdREMXlXU+EE7TeN96n8+8osWv5KDjMf4uh5Tb0dFfQz8QiFp9LB41tCw KPEaN1JAq5tL26u7VyEGCCccDwc5vwTFXX6gvu6OSZqXIj0PPQc/pCeNew3B1oNW8u6giBUG6RHs cGJwxkyP4V+Pj3Rru0/bDoQvICcmHL19cEevP/H7u09Wnixt9evfh8ji9AfSgoQTQ3q8SDws9Qbj HnvOxkjnTMc8HDz3Pw5I3Gu/rx5Qjr1fx+D6+urV4hXh4KoJoMXBIMQ7QuOO2gORg1WQSLvR1h6l CMrvnDt9R8g4PZ5PUbQ1/AVdnm+zcpe86KV2/aLpwvw+UOUvlVOc8A7ry1B3eqsKp4HgUryNSM68 lwVMeMqHFlAP9MlLwRwJmnmdH3B8UCsNh2hf3+L9Xrhlw7vBiiianOcpsaOzSf2fAH+/SEWl+J3r n8Dycp3i7XdGC3Alxajh0pb95v3/x9nVyqUmdC3je7Z6GXzFlFkqGO5GWhyEG5bb9HO5uh99zGzw 9iXchKo6+wGmX0bONI8URu/Dw1Vdxza+ZGvkO86SnQs8Ob0ZnEEPN3PNlRy+2ZwA70LwBBKsRqDJ wFHj0GHNYjzooLi4lEQ4YK2D9H3n4zZ94wX+q9O4wXu7HBe6HY4L1khUM0dQbkRy2Hyk9Tj3dfNz P+iyu6mPPof83EILePMq0637P4/fYI9KbSYNp05SPM6wtOgQ+J1BGsejapuOsN8jqo0FYhVaN+OO LrgayEJnOrQrGBUolJ4UlMIcORF4kmVuhOSBKorKjU5d8uwt813P5mOksGjtDuLlfl3MtZTi112n aQhCDy6WnWDMiazBNYDzXQ+s4oeWWELZpTD84G6iBQvQ2kJVl3ELf1IeZjvHp4HWcLPTlU3HlOw9 7IinT8d31zH0kWHZvpbuzmSm4xf5YkUWC7HA9FSII+9HlR96LapG4KS2FlZufZg6uj1EYWMWDLFk PuVZ4SpVKdks1eLvsR6yiixBXD0G3JN6YooRBFAiaKrGBRCyJl0QCgK5p91Q9W12rMIGVGY+tkXQ e4yrI5lcc4DFB0mJ6zYB0nIMdL5lflk1PqYw7nV1dI6Obo5OinmfS6u5jCHzdmT1mS3uMFFmx+z0 msNod5w1hQ5HubCjC/rtKShDiRQi0ooogPHvpojU527eVjV2Ej1ncW221qpXFRKUpD3vePe/xpBM oEktg4wNA6kQ8XUJjIsCCNulw9LdkJUpApIoJHrHEE/XznAqGC2HbgxomzuNGMCzYPCilwEE0SJl i+If1m9PGbFGSiDZBybDyvf3e1VDpQqde7duhbkBqlKUrkRFyNN/LjoC9GdllmSe973ve/ThaWg0 5zmSkUXuCAYanogcg7jte/kGwZJGCGSBX37+SBqo5WNXNGml1NLimililZZ2zBJPx0ID18KBysNK Drih4zxu6xVMd/DU8dPAsozpN3ms70N9DjhpbYY7ju8l8HTulzxdVy+6qqqJCRkJCQvjxuTwly53 SpUHv1rhNJ45u8VZnknP4VfFV+1VW/n+B/Ldn8vpV++/bfuvzfy+lX1fV/N7fu/O/bf0/Kr+lVfq qv4Kr91++tt1bbrQ1jTmxXphSwWsKHKz0zKvP8hHMUkbXBxXeAfeg+ZD1vW225HYfsHQN/xMB6/v fRftZ9QH2NTxn9QQPPgGnDbpJBBZryceH3HOO8W/vSEblu5G5eeiLuvr8eoOuQcgTDYAcNut6Q98 3qQeV9IbQ+PeSSHiKU41dXwLw5iD3bepGSDoA3JyDmkI0MJZhgPsjXcnItRZPf3+ZHqN4dXg5nxe xZXXR6wYR7Xrdke33DqehQ1Bj4BNEi5gS0bTcx6sN2gdjz8/Pse97oRR18moOHpEcRxLMb1bsLLN p4qz5wZIYZMIf/qfu+bubv+HEkBknLqKmtP3MxLirIp50iH1HiEhKVxEf1J84BxswSlmMkrNt/r2 dXWVyzUvld0q6Xv5btjRtVEazaalNTVNlMHl3SysWNhZZppqRsLC2wALIFADEgMYxjGduzO7u67j uYL/0Wu2vNZtuRM2KIxElpYJAJqVTih/o1nSLkpFnWWMLLOEpOC7gsREA6kslkOAgqslhSFv4v0b W5rWoqUWWBZRsRJZOosQ7KNGzBLFiHIiyMlcqhGfvYWtbR3t1ad2rqzblkrLItoMRyEkEKSCjAGC kTclSDhutxbedveV4a8u600RE6m9VhqJNS2IWVDeP8sRuJSbWlTO3JiiLZWUa3SutLWLtHc+eMhg 2MVLKUpFhBAiRpKSh2rSktT4ra1wIEEqLeNUFyRFKmtNC/k/L/O++HiA9UCQOHwWgPQHP18p8RMS tf43jwbiRIQ7v/i45rXMxNJAjYMCqyC3n/Tw9/omzoAQOLTa+ZcDdlkhdUArmDpbSsVPD79kgOL4 z8DP2D+wd/4fm/DP4xZQB3ltSP3I4xG/ethhYkI9zitkHlIJe+ekPnOfYSeJfPm9Jr+mGc4MzGYa +PXJL+b84nMCmIQLFQyCjPT9j+PSDaRZSi+PpiyjdKMCwiIyQIyDE03cDY/f1eFmuBNgTX62BMCw F0sCxPjDG+DtAExeqgGVGldJ3ZwTbXKoext2ObvHv9rZVUWfH8frtn6KECf1lIOl+kuE7Junp2I1 bZjmFAwnpaFNLvraLRLq8NN+yuCi+fVsq/aYVoKofbbosRDstI0h9vFRUtHxcJb2Jz+6gKKKJ0MU UTU5zlNilHBtZfxl89aLrr7wvvv6wwqYppoVFFEpscvA42C0Eai/YH98aF2aC7LA5iDyPl1w2SRS aPscSALgnjAYAPGC5oGg0ey1QYX9wKCJo728YySJT66uB2WDSzZSlmIo0ot/DZITSKJtZFYGRP5N NKTWMSKgYVGLElX8oVosNK5UjUDb/c/uP+67/A+O5CAdZEYWejeDh3+ggdjD70nuc3qcjdztsIpf C2zzUxX+aKJJ/TmtqvGNrf8MqlK5SNItTAg5oCk/IqjtYUSTEFp/60tSRUm7dt0ymiskRtJtqTVb 3iWklWDJFKsqyDeiSbFk1ONwC+xc5p4+4XiF0Pb0T+Hf/s4oH4sIyR619gzDB+C+vPNsQyAtVJio VtZiSVsb/VtstqJf9TY1H/axs+C5HLEZVc7Ma4TDogRnndMD8GT160jKHoKL0wGIaklCoW+pMGud OxOKc7nQcH9+WYJlqkczOwZDMC0y5sKdauiNFDKUyeSiYhePDJHEvTUdwlQP2caaNE0yYsXBGUUr RRhMVhBoNn/500yAGl1dlDtusbB47k1TAYAY640c4yEIoYf/4DfeDLWSRKtNbdyZuJhKg5YSA8KT u9EZpMSeE72ggeeAe0SUsOYQYLAsnptcCyw8wNxeLpQ3TYLQskyMLUFQsNZD3ZvJzweeWTgS3yeD xZSFE6To2TsF4hYWDOuD2Hd0TvJgZu6NnuMnSSeUxoUsPNSMnRTPgeHHniPkTSkZpGE8nRh2uOsg pO0luLAWkLEYWmmOlXgmKCpHIa0ZcRXV4auI5KHWNuZHZ84KeKFnnGYYiX6VnkLGkfMGgfEUD1GD l0sCKMg/JJjaw49uC0LacVJS+tbRcyjogHhGWHdr0xFKiugmAyWmJIrgIlsHI1SZR9zRs9+2aRG+ gt9ULiFWScoWkM6maHBbgL0cULLQhxZHAgxDMOChZQ5rzvOAaYE6eQvdQKTF5llmwSTBREstSwu1 NiwsSyDMncTd0dLaG0lMCbJpp3vt06LPJGHNoadLscPTgGmvToyzp3BdEmLHUKBvdAfJW2sZEOhk PIdSohZU+A39S96fNLNN6noPPO6M0tt3kOZtOMWGKIMmhyGnImBnRmsZfgNPMUnhiedxxTCIEKSl OKcG6OhbDpS8INCjBhaBgwgVihToZ7sh3BzhvoE4L0PPMWDK2DJwPTbTgunyiccwSIawQ9BQaQt4 L1Jo2wDz0w16eRCDLaW24Lri0Xo9MhwPyDay46zTy6nS0LGFJ5KaY8mEYxZ5KDwM5ohrNOpr1iMb Yag6Amhz47BoFzLDYIWAaNJh1wlwkqj9QTkOAUK2iuYhIp/+IJ8keAxNGFJKYKaBFoHkJF6j2CGq Vrh+ofYfUfabxDmMiipUsVKkceC4IO1KFKEVSFUkVYbU02ep9zU4ahnH4MP+r6ZH5KSO44pPtH95 468Y/m+9/A03lltVSlttpz7XL2YxqvweWS7G9M4ycZn/ZeDhzBxaqTQUCJE6DA3K3eNbTQwJEwcv u4CCtGVnV3Iss+/Uu14HkouHjDDCDBkf6w+ffgCRFHvvNm0kUikIeJ7Q72Bn40iWl+wctJ3uGKBz vS4mSwh99GH7ivybdtyONjENlWAOoW0mGAH4iZsioraIrVMfw3hPZKVt/+8O5TZw4Y41JM4smNmN itNMa2SOrls5DByOYuRaskbTCPlXicTO9mEnFmRbRNGyTRotWmnSlXRgYCKBowGmL2QDF0hiARgx QyjFOAG4LENgOGXhDF2FoBcBgl1UI5pohwJR0SiVzpkb/FGQVqFnJeZ2Bm9djG+7ZI1Yi2I1hDKh iQfQIEOWQF2FsUUVSFTSMPcIS6WzBRjQor/MyCqkqlVUhp9RbUTKTaCQymc0O120g8QIYAgHCoeK agvHAUJYCerNw1KNWSQspMlKm0I8ZYeMqGTxbSpYcQs5zDd4obOzxMhajE30FEKJhSylSRjELYWO IMoOtVBQiGSBnW3QxRi0stEGgcop2mXckYEG1CSBNcjs0FDl0fK9vPQA+V5W39EsurtlaXvta9g+ QOaYUg2pB/bEYVHiptMRWIsJFY5FbAPRPsT4CmEhqkeRUZXDjDafX7mml4Uqq005qON+7hO5WqlO hhv/05N3HHnC9IgFKQJ5w562daw/9k3Bq8DtryC6cw44QlCGtFSFt8loohIMISEWPoJnKHjTKV5U KBX9iaYUuiUUJSAy2ptUzUzUzV27O5t9jbtyfgoLk76ohB4k0LGgSIwRpG7LLJwg9EHdD1RRBVMO FFMUxA1UOVRRDVQ9UUQVQ5VFEFUPVFEFUPVFEFUDlHgeBg88Ok4U4qAUxZSmomIiepv61vh4eHHs xilpaFFImZEp1kZQpQpQpv8fGOFRe1paXUEKFkiSgaIJd7PXduk7t167rK5eHA2bMzKu5oveYjvN +4rTfvZqqOu2hmGULwqhGSSSSQdk+2gsLYZnFmkzN66oMIoxgjGISAFKvNRJ9/Zkg9H2ZJ5CHZUh JOiczqV/gQO8IBPZlQy4DsI2ITwhU3EV2WKFJKSYpjP9+kholSSMkVOEqeUVMT2x057PUlyL0y61 n2l20UKIgiScrolp47u2jWqYdCKJSRJARq4eBx0ACFmj427HtrXfBwauo02EOkI2PXVDUpYSQZhj 1kIQKaFumA6GAhrb1MxiQSBXof1bizHKFEj0yiEI6vBjZYgAEnolIMe1TDTbS6S5GqdGPuUTJkEX pUTCiWCLaiZDLDEadD8ZpPOnfOfBWxlkJyESyEwkawe+kmDsPv74+671rFVvmPM1rTQh9DQaWlpb 1OPw2222223H2kA/rwCwsS0S1oXimztfa/cbOz4hHDQW9xwcixE9dJm0yWxDESkTGYtnTBhST3RK nqrvTKSqcdNpyp3PwMM+XZus21bfHa01VrUAARJJJJJYedrcxsnztb1QLCUK/GxV8xPK/A6EhCxe 5IGx4tyVVCcCikw4s6CzemzwuTLivWshPONSTJRYA9MolipRYzs6226XrsSk/R81im6HqKTeSuqx OOe3pjZCQyWQs6GKZ+DQ0eZm11TG5HeKKWJhqOkZ+ZR8Nini9oneGVDCGzkHRsbB3iTrDgMFnYvA ZFakaKPaW0kVyci1Lssuhz1ZS3aTQCkoPiUNjRzS1HIoZNzbSWbYTKPNXJ5MGSYrGHqZGTEjJaU+ CjbZCkKFh8w+zYxtttvPPPPPL6QF6AWUANr1rvufR60YOWYYx6QMi2xXI+sSCN5SgDCKNFkMRlRg 4msOp5nqNuN87YZLFlP3w26yUpwiIiotISE9n2gwguY4YzqKAHIJ4sxgW/v0LJHSiiYIHngYMdQu jGYm6FoWh0IyDS0ugHUPwAoIHyQfVqKqiotqkeYp3FJCjJgUTBhkTUwEjwixIYSpxqEmGxjPfuym pJiQsIw/7CCEGGT4MiX8fdteyKIiiJwWyYxtjCqqqMZo4lml0Nh5bS0MGLTLhjGmNNJSdKUIPt1b kaYYSTqscayAz91ytDmzVahnaJTO0SmREVVVY2FEVVV0IaFKFChCyzFCAw+JZJtbkVnFSajWRYNx 9ZRDSUMKQd221JeNbmkd5/oOccixRKuywq8xdRVjgk9ZvtCr7UzN5fjizrsnie0KeCQZ46UTiEVQ 0DyhSiHXOEDeQltCtpZbYiUSMESHU6XYSHdeZmv8TPNu/oes/scnelT5EtTkkz5KOfymkaR8gqSe aLG7yjDCd2elG47NGDuNcGxOOUaLGjKZ2RqfJ7kkdJCj4VeVvFfCut4AgCCO7u7upoaUYfOTBCIE iWGQJaMFpaYiHbuMMD63Fhu7zSy2sujgMEIEQhzVMnzvkrxq8+vHMUh380ZTszKX8G837FetX8N8 Ne158JfswwbTMmJL3brqQtWPuR0RqHEbGRJYeMSk+ykwfOUSTdpuQy2yYiT5rJiKQ3oB3qjQxIn0 6ZJgjQQwGgU8jDrb7XTBaMUASLB1YoULYE1PMWFwmOA3Y9eGwL3CkIWpXXSgFwKP1v+R/21z5w7V 542IGSQkZCcIEoqMhIETg2x7T6DYT/mdoOsk7gsafGFh8gd5xX7jYoPyPSd7bb2GeaHt2hkcHDf+ tIxvJoNykFKRRIpREpRQpSPOQpKYPuI0kbE3pHeTTJMwssqqlkzeFy3RQoEfGU/uiiQYUlClFKUU pRShSlJSP/RtOzm7Fa0Xg7g6Gw2iJRUQwpOslCyLIiyWIshQoKlililKKLEoskRQWSQoolipSVJH rFH3Dved5x/YbbQpPii/tWuB8L8r5dxy/vPuNxsvNIr/xD1BzO83B1CfcqAyKIT2BKUEfkigJ94n zccqCAfXERd+uOXYh7fReN803/T+BJGwskSlSFKEAhFAjxE1flITPEeDCDlXZn9TvO36D4MSeOfR 7H40+H/2mw6GpUr7jm6Qof1hwCx/1Yu/dXyXSPc1mST6eTnCfW8K+lrDIyBGdB0FOq7a7o38fi2E JL3bYOavP6NnpFohEIdDouS2TEhIwhGJIRiTlTzeU48xk+TLq5ddm8SSR0UqQ7nrHedEJCcBo1eB vcWYnVlrLu3D5sojKHj+r+3yOK9AfWOCihPFHY9GracPJFcK6E/votjGpzWDTf/lnm8ltTfgGrNc xELJIp2Y1yudIzCCC1KMBuFtkkeeJF4buoNNFwVdE0vKUn+76dd29cwcUw02B8gMGkLQYA1AwOCd C8CXXrVa0KDlIfB93net/5uzH0Ozl3Or/cxsexjNN23UHwDcHUe7+RVX79bb0+k5tt4KUKUKfu0J 0/anQ7+lz7PO77h5HftvcvBpjODZri7Lu7Lu6aX9t1nO052v3bt+46bnTc+frRRtv0rhUqFSsdL3 +N8W/iHrqSSEnVlO6EhOnvSRGZGhakucLTcmX3B1BcEgN2YcauTtNy3S0p61LCYUJ6cGpQTgrCDD 2CMdwSCPtduDALQs+oiuEMAYNOYYAwexwUsA8Cg6kH6o3j9AFYXBX/u+1aCwLbjC+hnjXyBwWk7A 4AwMDD7ev22/dPjNyTYpPMUKeY9I3NAYGACCBJyB7CBbmu180YdiNn2L6jyDwv8EI/xSRjKL0kQh 9cMS7+S9i/VbsevmNNOB7OlHFt98vLjw6ivnlfVJ9Ue/TOjKL5k/VgZxRNdZenJkTaM/9/YeQzSS hZqAYYRZ9XQLUwgs6RZPR8MEUvsmh4pt9Vb4n+Xi2HfIrr+AGinM0ZIkCLwUXB27P019aFn7y9b1 5nCgL8jReF+XI8sRm7dkdHl/e2j5vP/PqX+5Mg/0TLkT3aXPcszvTbAPuOCUES0B+8mf6HaeAc5y f5/Jw+nZix3YHxPf87sfR5z6lPWR09ST5z6KWqpRgGYZhmMK7t5tO9XnJzKGxjYPv3WeH67aaTNJ IPH5QSDeItGMvuJhd9YFRIkHcvn6eiX1evX6fIGQl4hROLPjaovz+xp6PvtNBHel1MPnDyges5Mf QbCin7+Ju/RYSB2lroYTZt4cA2h7rdW2Baat1mj+Sh96NefDOwKKS3OO9OlWG0OhyEMGCPNyZlow zSPO57OZyYKLj2IqOsCsCKVCjaMemdf1zjCYh6AeIYAg1/TQOoRVUMQUxTygWFmx/FUf8H/iHLRQ 7yAO0UICsT/CKKhuCAqXA/kiUq1CRqigipcT9jZQp/qEgxcwrUyEKA5Ekfc8qS9fxePhLb2UDu8s /kEAen2mKRv9y24dPf9nYHYFJ1kfYYxPjsJVMB8a7u2sNAMcBDISE4GSEI9syUg7rehaDYT0nDVM 7p4noO7tntHlHk+JjCefafZJsGywkuoZFFAYYUB8t3aphEgEs6f+5d5nZ5/qDZ0X3vd8Wp9+aw+q vKK9/NiyiixSqfhshTBEiiwWBScwu51/HdOoEE5mT5CXUTAkmQULS54TYW7eH2BxAWhMSCbINdb6 3VBhbgH54+fkecLEE9Ls735jwCfaYK6YWP3IUw70SEuN74ybAVSFCHv+IxOMkE0EMPuHHA+JJZFJ /+OfdqNyOYMy0Z9/g/VzckhuHLlnTu3GDt5bzB0SNh/I8NRUshS/8T6P79Gyo1TCUWpKWuDDJ2WZ OVGEs73tZNLH9cuIssaf96g5P12d1vf8Z5Q9MKQZmU00XqaT0yEfi4oXS5H4neT0HnwjyWalSWLE jGFwloiZUiYJYPuIVURMiSTFK+yK1ATAE4KjgP7f8YPypn+xhR8bLvsYgfWk1AghDkolOkLWGvqz bI/OokRxYFEncQQh6PltUPq89LkgTPh3f/XTju7fLuq4TdvbnGZoaD6bkoTW39wbpUpIyNok/F2T lXMzHxVW4BkR/k47jK4U3wP5D57CHPAvZA2i9CJH/lSPZKRPYbFjs77327dsWD9VgGIc3/28gIKR l1MdOgcl8eolcMPKGDRIoYUSOxEyM4+XFgbomSZvQk5dGTrX/b+Yn/H6MKDwojba8BsO4a3j+6Ki N1lkk/+alDHwYiPwIp8hHpgbO+gpqj3gqw/uh9gqOh6Cg8nU2Dw1bTlc/Z0OGc1KWSQyRh2OMmP6 WTayJPooJOFiCFOMj4dYdXlnQMIUj6GAHo6qsJiBmI/2TAxAdroyQ4T580oYZISBoM+hKSn80U1I f9IJrlCtU8ZQ9BO7uIayWp6fcCnj99fzxT/SAmzB+z+ikKqhqqUP3EXEQd5GQPylQZFT/H3f8noW DJmTMJa/y/L729zR7WNlnU8uY+3sc/F32MD3FVAm/W/qkkj4mD7YDp9RQfoh0eX32h1xeonI/Htx 88Vcx/owcmF/LT8P9MXccstviI+Rn+Uyob9cn29bsezNcROcPZFeTHyQhDo+uuyuy+c7dK3sB/Hw p0gG6FxWRPC+7OHq668vWlIdGlCVCvOFAHbA8Ueb/uo7HtE7e3oyL1JATMFDpIDUP1QO2H7YBUKi 1CoOIh+9gdEX5YI6DFB9olnKlstJPWewxHcd/d/n2yofQWDrSTzXUkknxieNSuARDxxd8MViWg84 ITalgSL+7xJ6WbAsgYAJAmBL9/LPkpj0uKyvZ3G9KXNqKOlFlHckGrxuU9zWPSQf4UedI3q6OSuU XkO5qQqOgHLh6OGMoGhveP7HYFWs8zv7Aa4D9+HGLAGS6Z9QJjS413hYEeQO5ZmARsXcuh92A6yZ MIe08QShg4PwTQSqo84IuTYDFPV2TmXw9mYEKBDebil5sd3UUZgw4ZEk5GnSR3pJ2QVSqxPPE3+T 43L2RxcFgZJq3As9ocYFbcTB3f2aq4skgArVzs1+a/kblJ+Y9HOSKrz9FQvNmOGPTu+zqxKbrFAK aWXjTkyZM0xpjTGmNMad0uXTQTrpUTzw6HQTcFHkxqx/tE6RPIWBieSq8534SyO+qkkhhN8WTmU4 sd5c9maxmZv73omvo9wuun5Pkuq3lHeoYhwPE8rgQYhZIRQx4qfjSb+r09ph+58A9fwe8FFBpvC9 9uTjANbglyHiPI/fqu9DuP0aUlGisepQA2vDVEHHf9CL5H66imoAilp6bS4jeMa6efn5/xXknwDy JFfsfOUI9ZFHYJv9Q7vZ7j6Q0VqAkgvm9B6vl8hy7lIR9JAPv3Eoq3Xmn1vjJ0vC3hSe8OyrjtdX xjHsD1Byq0R6/N5w2XgjzZOBeu1e7kclByd8Rc8yRa5yK2EXazDhWCOjxHEpPgOBgSK3AQEz+WFn LJ8PEThY1aaLSY9uTtzVslV/trefr/he5OUWoOJFuoZ5cdvHbzOl3+wFTDP/1t/T49uZVzQJx0VP 6r1ZTx+JS3sk7SOQpeCQg7n3omiB8z0GTiKq7WWQh+uhqzyE9PnfTF+U30CGpkI/p+w7XDkZ/erR XJCMEyD21pfanmQ95CkbvgGCvv/akln5kojmI5s/HTDPH0lpoh0ictxwIrwpoVKIDQFUaWpSjN/n 6v7FHh2Qqp16+fo2UeZudiSGzNo1NBSQNKlgZh+kMPjsflCOzrTUGv1u1j7f9k+f+3gJ+qRHrkR5 oHpWFWH4ey23IgaipL3j9EIv8/n8/9eE9gcECZtwupkyb0kFANa9YBaGkw3g2tksA7140+oD5QHo KlJMqqA+oQelOkv87D5TeDEedOCyONfEeP8I2jzJO0hyeoegeJsptAaR7g5I6EUPYPPUCkcIeGaJ hQH+p3HjOf9fy0EQJJC/tqS4ITRZvBwvGEElAH/2Fh5QDxxU0iAcHbCG1cS+76+IWwXkp5QomzIe I6/p8zn/lOSH214MN8XhGLMzaz+VGO6oGISBCBD0nY02x+eeUscdHqSbur58YO/LIL+m/m2v7lJR hFf3vpZ3/puFrVacPqHTOBPbu7u7vBgxGXU7XhlyXcRX2xZojGpVrXj2Tke3R3ttbAksHK7udH5/ JnPy631XSLoKWnznqsc9i0m9ORC5uFOWPFGEKAoKvP4nnfHJ+NHD0SLNt/PTEqY1OhhVTAJhBEzI fCq+fdSSSWdciGDQSEBsJCmR+cB0HQb/D9YWhgEFiGtYKkGDgFAYpcGFje5F/cOYbM8tuCupf0e1 2TdvZVEVT0f88tsxl/I3TN02/pyYuTg8HDvafofE6uPCSTTsZvf4CdgbYkk84ekHbtYnTu7utcxT 17XdWru7urV3b/1pJe59nP0/gGyxa+rsTwj/UD0rwG0BhspDikY5hKtqztXvGU2FNwReo0hHWFIR DON1ZVtC7gwVgX6nTanrphCb7ZlpyjHM6W/GgpqjmMDBwBgeEQUQeHcdpucHiOZ6vZ6Ve4z7e7NT 4DW7aOZco1PQB8oU8qsm7A+U8vXsjnurffuKLUT7lEzd14b0X9Vk+6qVoqXs8Xv/zn5PE8xyM51N x0q5PFs9j4Bp/CUx/zWQWx30RsBIMygmH83Dh2JLYJkn41IT+NeLJ+bMjzHwqh2oWMZFh+Odp1OC 7fjoq/e5t/WWnSM5+U+9aKLYilz+xf2Es35HOaYNJVK+UPdQiSIIBkTnwUssUqD5WDTVAfFpmrUf 9Nz/OIwOWh6N6UE1KV5YMH8YnX9LiVznVDCKRDUF6OcSiYBOYZECgQD0HWqRBzLTchEI9TSicMTU 3aamghpdX/BfsXbXjJJmqmURTLUgYjF/RSUDIDAImRRIVwNbH92M7yIe4JZ56/UkRwE1EgZYNJ30 GsWp7kYzPRpeHLMjQJQ2zOobmwkDEFzDaOxOxSBg1+UPs4J6jVHbRD9YaMZDd9BGpUiwkn3ws9aR 73i2pIdI3T9KPhWWn01GH0mSClQmSZ8upik0bcenj3STVDcnki8AGBUcL0Js0NB+pRwW5ImUYMkU x2/3v4l+v+PHnm+N133xvLGP8A26fpX8wWp818/z+k8UvLt9uS8x/VllFdhEcNVVS6qsrLLD5LCl wxT9NlhS/PH/XaG38N38af9WKaaFRRRKbGvUZjaT8MNPmsr/rqT3ve976JbNw1Othqf9tR30iW5k lvDoSPiCJ8H6E/zODH/Jqn5em97+ujs/xNi1Jhp9pudQ9hM9JMPEGjitsuVoVg6jsj27vxppxd5y qicix/ieVeefCHhRh7RPblf3B5bLusbL9x0HnJBcjdya/44tjL8vyOQ+I/3wP1PBj+pO/h0BaFSq VSpHnzKf+7+WoL+rlEioORU7Lo8sWGnSnvxikRIw/h4uNK1Mp1LF68xQdZzfMHmOJHYXsFtV3cBf EOyA8rlt8jpEyX9zFXU5w5d79FbRPt7kYbwhOmhB2MDgsIhFEAucD2KByb5FsXxRiqwknF6giE7T KQMlZd5bS0qRWmRdatIRA1BYvnZTVMsApkbT/AK5Nok+4OVFbbzioxV66CoPjp+xorRz0h36yGwn Tki18NLk9VTIlZ5vlJIfBT2jcWcwYHfrvvuMzJfa/I9IGvactCG4oJcu0PGDtbaAoIp6/FhcwfK5 IxxCQKkQ0KwpBrFPIks6gejI5vkEiSHzoOGYiq2c4D6Yc5QkDi2XPKkDHqCfQFAVVZpCzuClg1U2 WLtioYs4RotGGB2Tgezh7Ov77uBR5mVnTJcusIiGOMLnpaUWyk64iPfsRJ8NsnMmOPllqh/bZ0WR rJgpmoLJJ+0Lb9PmK59qsBqaA0htE5/8nHoYMApRlLej7Uded4UOPVOkNsEVyB3Q3SWbIyx4w+0C s0RN+5y6/OH+s/aQ+RDknBHP88JMLEdbIeklWFWXuLHn9cGWdpkbl/4f6cm4lfBpXzHMJ+OzxR9d nmqd/+fk+R1YQ/nMn8EzX7qXE7SjiDg63syNs9kamqNdZVh1UIZH6L7AHAOSHBzA+SPNtNH4dv1d Zjs+EiH8+jv+3nieexneQ/yy+T8plGMXU/TZRXQfnJz8IzdGPI0f6fnC2kof5e6FoQqUmrwaQRbY 6bnu87fKxfmbnwY3MGhuAxFpMdB3j0Jw0kSeVk8wd6fW/M+7f8ixE0h+M/t/xcxueudgfoDB8AYD 5vKecF+VIf7Qc4Pa8DYnrWTMAb2oUOMNKpjz/deYuJAnTKE/EulH5R6hbd3l6enmdHv8n7VdIHnO izUskwjsB692cANXp00dZ4mCvBx/Eutydp8jVQurrmH9YHmLP98Kf5oO71FuqsuXIspj0v6d0JxE f23EJUJ2f455EQTp+igB/ygp4or7wIKkWCPP1FDE8FSc7anNYOBZEG+DpF/o2kGxBTSEiCmsXIkE EqCp9EJFHcv91jTEw36RRhJP+B+WPy8j5UpH+H+e/usPtXV/lrt5/3n3LlQ77vVwCig9f4gzVkjs 97DK64h+3gSaDWGEpTFJy5OGfLHzdsn8Pzx7X7++W+z/DYCGWdaKir7wrRMQbwPyBwhMyQWm0853 XI1atOzf6Pnd3nq5/5axjWl3LuYGSQ5JJwkDIgEP4Wv5/dj9pFB1AkB6WhRp0YEkPs/AOKmRHjJ+ YrlHUUjwCmi/xCxG/3wT9xhh2p2uGmMZHK22vN9zu3kco4yI4aPnZP6In9yyDITeltWpIo4lnjjA SDQDCTheI3C03OE670esF7GBuekWKJg/7g2/YsbRD6/TpNQ+ZkJzKUs5toPhPxG0m5RT1GFOIZbf 0Sfgij8FttSlvBOBweydJ+s59BvVv09k0kk+IWTIFGLi85DwpDMkLn8cdiH6w1D+IvyLqPpD78qf l0ckB0n6JQBCEIrJI+74D5F+nJx+KDlpQ9jI+ZqTLavUyGW3zyZEEf6ST+nsemF+TdykHhtGPNIo bW03HxQLW1gPZFRaiooaRJEeQehCuQo3JNz03Kt8ySsyJhlnQcTkWR5IBy3YC1+eJl8pVIQdxBkk 7ejxKpQbirwvBijEJwhrGwE3B5wwimIDINvUrz9+G1i3rjJFtv6J+bZdpP6B6hwPsq7Xty8IQgDX sOr47+p5q9LVnz+rlapdI8UcHZofS/hMP1PrjzR37JPHEF/rGGEjIwIJ7RDwfz2hqHWlSQWSShea +NTD+cMq1JBGSTsXe2SHCVI2v6u4+0ebecPvE5GpLbXpP1x1NvUYZhhmSWNij10kSfKpH13usP/j 3MdIvSOIyx55GO2VUfpuWRbaRU97rEwTx9FTEkI6KI6lh55Uc7PozMVLknxP3z6LE/SPyGgQgSD5 YBjrou7+WoHW39c+s/W/JJ/in739sh9nx9iqqotqq1S/TDi7GzcST4CMI20JbbAltp/BZKknXVMP CFQ/KI8Q+VMCXGMPBaEPTBM4zc9LLkW4lIFB9AaC+lg5DCmoFlyBEbAi1AdBKbEVZzqeNbUuScus OlA5BlHdBiP3egDaRcKgGYMKoQ4p56AwGIRWpILIxmpRTJOBirDFCxRbTiYBxJLD4QNgIYeuO/Q3 IH6jcjywQOajxBC1dpJAzXzVTw8m0LXSEwOCbLEoeAdopse4+pNrQZ3xTz/U9Adx6Nw0T2jIB+FO zjVlseixJlhwUflXSVHuQoxQqij+qsgttgtvpr786mQiHORfgLE931mSQBcqFzAz2CGzbv3u2+o0 7x8VwWl0E9kOWtnvRSu50K05eqCY9M2LYJ86+hUK5oXDM0kU0Qhzyqcpzb91cUPkw4V38NlUaYuJ KBqtyfH44UUYslRKeDSecqcO9a1JxRjqxhT8dlkMac3poD5xoSKZrUR5BMpNOhSXwTqaTSOjya4y SSTg9VNf0ugXsVCVvtp8UGZtYRrr0vkrE7IGfq6nbT2VCeVhT9ZUqgva2Rg3r1jubYFyt868W+fE kmn8q9XExyDT7N/BTh/NJJz25eQNOfmacQOYd2uXrPFJCQmu6STYeDo1Jr2WzeVcznK0L2sfILFI KK2mW0iMBWZpYcIlDSZmGYbIH3wM73D8CIHG4LoVajQsjF1NF1D3qvLW/HcDhTNRQFkA4w/xLB4Q M7TKhkNgtEB67oGirya7btLDKbVvTvr80TOOJevcSkOfMePfYicR5BoN3hH2acCZTFGOKgGMK103 /y6NERqCY+t7nuA3Nrb7WDpGk3FS44ddXjsjv5Yj98X7N8UTaFdWpFEXRnRGNDOMMFpKYFJyqjFJ aEMKpLayHI+IaToHKYTYd2U16jqN4ndnSeE2m4zdr2wxE9eqbJomuWjQugzx7omgBfp1u50k95LZ OiUOyUB5+3CclZwz3cnizkTRM7og0P+GUoTKdCb1ddx2JyTKcE9+7o5UkicEpNUehyScIuR4XSC1 oFc0yQ+m2mjieh9tmIGAppyj9kbxvH648jUhxFTtRUdSKnSLShGJhIld0Ojh0Wno21EtOaT6Ub0J bHjE4pGSdslpjJFOQlgk0J/HlnGyxutt+9yOZ80zSenbAphxHzstn6KKaOGRyM7jkies/I8Nnp3+ LsnTTbRs1h1dyg4c6+l2tW3gyfYnSDS7E5Eh0CeRQD+5X3wFtagHyH7GtRUVA9Gam4xzzeiCDW5w TZaog9ZTAj+fxbl/7oDAKy1r2FelHuAACi4BleoBQtLqG8MAn9rFzIPJcG3vWAbKQvD38auDeuT+ AblTSjMHT14mfSUBdANUnFngolESzTWu67a9LbON1umHZ+7u4PrgXQaF81OOkpS3ENCaJC9vmJAP 3cRKvX/ZrCCq/uWKp1QTrCIqFUH/LmmFSJFDvA6wpXWDBsKHr/V1Q4RdRnk6Zo/zSpZZZZTOfV4Q 3ij1tn7H84HfWv6wDSNCjA+9k0BLQyPnCqp4PXIvWEfsD+ggsRgj/ADH8ZEEloDknQiYeB6OxkNg 4ZIZC6jUTfrDvQ7QGTbcUCG7dxbWCEV7nO5PRL43H71dsUlqmHavFxqVvmZIHBgw4EADGJT64f3r 0CHb2PDkbqYtz8/sjHxhRSdEPplL7ko22Cg/4aKdi615qo/DhsbZ+tsbgjv4zWbFb4fzT1X1df2w hT4L0xJ2O7BNeIG/Uh5tgUFdx3p2XnGziOoG3HtqSeceBRfIkayeIpHlEL2+Nz6FfVnmnaGd8fE7 WWG9buhUg5EmCHOz0w3A9mWw0iYlAFhXpNNd7hfh6/wo+w+e6/mxjPzlWn87GJ2oaLHJaiCW/gF6 cMc/BpgLQW8snUvYQ3MAwEbwENz/ZYaQJhy2bZMBeHBk0vNsymVHO5oMuQjiwyrtmw1bDS8YFyma DrqNC0Yodw0NBgTrOT+v7UNHd6OgFxK4CsA4ywTkFoYhEFiGDA4M02c42Gw5DnPd5P59eyJ5Mfv6 /GYH9pusKDIKevUHMlEIgvGDlYe8Hh1sHgEwDfJEA6IH6tBhdxWC9ol48KRoDmLhk57hrPlgO5Ty KTsLIEB/fazNIfIoEIkHh40BAfekeaQkoB0BBDKkEIP74Qbe1TAUH8q53gdlKgKdR+iFBW5Kpq8g YbIL2owXooSSyVDqVCmSSbNpUqpXWbm6WjBSvhJsmL7iROAMDVr+U3qAwkDMCQZtKjddfOM1GpmI 0jxXqd7vv5/11yvHN1H8D+BneaXLIYNdDs+Wl/xauvBXf0qv6j5j9aPhBAQAzAmSY7fnluqUezuq +5MzQHzZMwvpGKTz1ya2h4tiS0QpWKxySQPxYBIUb59YzH39XjD1a+RmEA5Ai7+rSxpmlMKah4D0 L5chJbUPGwCsPDrbANn63iFtOidNNtpLgf2eN9qrInmXwPnpwQs0hJAlJRss9k+/z0dk6UuEsov2 obxjfYlk6Ew3cTywrUD2m4H3PkAs+AvZv65KOClHBgbrCfIXuTpIPnh4J5pPD5Gh2lke+J+R+WP0 KMjKpke7cLtNg8Q/GhaL93VSL8/+/6rQFMQF8wHT2p/HD+aGo+aLI9h82OkhyPqyQfU6oaxwBJHo j/aR3/lCnnchYfJ78z/EWgFav0DgmXEHBY7k3PN7kjjCHiWrAZCRVGP6BhQB8SwAfvJ88VaViqRI B8N3x2gm8P5jsQMcjqzXxMYtrC/bFJIO+AY+i3yMl+AVCHLAIJ6ZLE0dpaiN4xajsezPPQHgGK4t PzVcWoMg7KHBOMxbCUWSKskJ/a/3zCQ8/kvyftl+Q5qWruK8A7FMC+boz1Q/JHz4EPVPmmiM0nB/ TmALSELzEHo04Db5AIqbIGwSU5TuHCTt7+VUFJIyVFaCo0H+cHbydiM1qYfKpkyujukYyxS9f3Cd 8JPvfL49Ts/fHnP6E/juHk40PNJ6rEOxWCD5TwmyHvNf6752hs35wETbS0mpg7TC0OKn6Ocj06A+ WYc0108x4wD0GPkA+Irnav4dStW7rAP36y9hJXlwOREGEjkFYgp9x4kbVpGK0pAbwQClQ96X5jK2 FBcELEGqYtg0yHw0tMQs0oM5H7VMKjFQjAd8ESoDAA6wHBhD6u5J+eKJsMrJYRP9zgMml2sYDYiR u6ag0Ziv5oFpALIL+kOSdBRiHlUnCSb2d/+EDaHwWifznsd5AeEwsPm55d0TilCGD6CIh/eD8syh jlJDcPoNd2O9Ztj+VvRMBjCgSPkciuiB2jL7UtL/1+/WPBjVMZgR+30OZhW8RH8wCU0JYkHrQ+YS DBYi9np16N8b4r+m292r8a1rmWbSUpYQgf+KmTELGJJVJHw37WpMKSqSZqUUom2ZY1pNV6mzDnCN q1+b4Vo/Dg4ItQVg5yS35Ifwmgcw17j7eXzUWTy/X0v49u/R9fL+QUfTlDiuuS+zeMsIbwyMEW6s DggN/n5+nP9OmgJgGIigLN7b3HE6ZQzcvvffQlBvRD2pgykFAiQfoHxBAHgsgYPiNj8hzPhMKe8w 0YU4MKUpNzmaMiaKKfrFGho0YaNyjY873YejaWnRoyFORtr57JzL0Ig4FokiuCNPlf9bBbrvqn3a Z3AjbISFO2Dx5rPJTb6a5FNlNDVMJbjLUrBAgUbQKbBb3nADXtMRt3t9gx2A9ZPgMM9Lq2IPrYPO CXGB5zs7ucA4o8Gb7nM5zcepey3x9fH2yArPEFJUHMAwcGUhSBLqL+dciOZhGQBsCgWqjZGhFaJB QmP8z2BoL7TpPxx1Ps6kxjVLC7kscBAS78oWOP76HMpJSlFGiyYc6XFwtG5rWwyJJzu5Vroleinp 9B9HkPM9P5rKcqUpSKxH9QAnHgKf1qHE+M90rd/r/bf15P1f47ZN0KmaNzzJj9w192f7YZdJQ3A1 orjCocc7BB6RDbrjejTf8SlHeGRA39E345z8c7+nS851dkecF4RMRSTaJNqAzEMTGaB23UIa7UJc XMXaOdLuZoA3xxEE2gBdDlWqLZtRyra3jG1JG1SasOLHaIzO+9dqANpvgI6RdYpUAzBLgvEM2Rlv t35bAUmSANobSIQ1I4mZ0VTaideW++t281STVSOtiZYOlMo0gGsd0So7QkC4Kb4siG6KF61tDax2 Sv114mlndetrDlOqptV3lYleOPDaiOUEnPduCY5hXHTM9MzqU2kZIGzYGaGkjDd9vxab0jy4m2Qd nh61H3hB+qJD9H/1KtVo6elNeKbliwgkCHzoeMQ6VDPZ3Twm7Gdx87QVFDCfiF8SBqEDB5Ie0vFh wZJzJul0GFrPI96LWSAPf47nthKiq2MoEHUxxaRQRaVXSvGtiQQppWFNb3WNL3KNkYoCT1ZS4FAt OgA/uNXW33GInq53dENn3HgPZAfXWvsaWzZ2a8nr+2K3/Uvaf+Ta+Ph9X8e2vNb9J565Ua2hrGzN rBglMyZMw8s4zXkXYaUzUTqHfY/xaJaRRsYM4LOVMsJAj+7rPa93z/GEeI5F3qbiYem3EENJR32N d+r2t8vhrlXLxMY+6fFj6w17ydbZbeNn9nJ1MAlFv9861XWtKem7idetf+Du36m+V9hJm+31ePrv VtM12vUYzAEXemhw1uqWXdXHJrIf2x8p6eVKhyS8qXAoqV17sfIr92tAzdAPyy4otMwk4kPliMfJ 5E1SPUhyA17W9gZfQLC/Mo0s70FOmXO6G6XPjVPebtvvDRwaqkc4zRtH6AiHbA+nY+/GGEBPripC d3du7+8zHlEDe1C1fREQ3RroaAbqlNAUJAUI+lWIr3z1yonLrpqABuCKBOBTugD8UOu5IeqNLmen YkaWhafiskPCgBBiDDouSRuZCCknSdVog5skd6V18QM825694nx69ojJr7dfBmGkqhY+r1l6pV8R lEqDCmNZOO8Y91GoutVvH1BEVzbkm9xO9WnrcuVNVU5iWGo1FxrNi3WnrcTFbm/9B0fTwzN9AZg0 CmngRM9X6uChnpi7QYhooiD1qqB4MIE7TvGaRYMMYo5CRGGNE1w+AGNQidPjVmlkQrlyTslkpf4P zQdvb6jkdPv13CjbpFWWZUSIJ3g/eJh6Dv43g5kdjBDbdSL4g84ZIDbQDkkB9oSByQ8QuV9z+V+b c2d/oO8CgiaP5gy4xYekssCO074Vuo/GVPnPLRmHOUxFgwbYjyuLkyRi06ON1Cb1BNSvEu0eggFN tEU8oqctPkrItQaR3K0GCoZKpvAsAfGVffCaRyjJIICp0XwsywKaHwdG4g7U10k410uJC9mseMHn yRtEC8Q/XivkNNo68er+d/IPq89p3peFrNW/26r1rJIxYCVUpFTIVUHLCcZQrhUO0qA5MhvK6jNx nFyeD3CKFmDlUxqGda/NoUwdS6/K25EkEc/G/D14f369nUz7QUxJOqvDR8wZn6RSa2CVPXVHn37+ qlvSAbzj65Fv6t+vHqaTOTe2Tjj+4zTAC47Dqk1Y4/HDFwR8Crx3DBG/fnjuoM7jXyGt6R0I9/T9 qRfXeoEq6yKU9bhvWnCkMy8OK6KpaXbYhJM+3BLQCEBzIbaa9ge0EJj6cyTKDtaQHXVZ3c3fzc3z Wsp0GjUlzSL8OPivKegaCHhaoVcvWGJCB9M4bJqU6Mf9CDibiOO7bFK9I34c+fTsM6GPBv41RhPk MhuSjgQC4KT4RVD0q0fMNP7Fa1k2gesvkMm3zuZxDj7JHUHxdywFIGYSYY2VyGbjzft07dLUQhPh x0cfyck6LOE0LlUQtJYo7RhHt5gpF2HCOpIg1mytzkRAmJoiZxDywslx+wSbgiUE7QHIJTuJUVfU yoqhcdZrDYRgesWFzEAvN8fZWUIJUV7skZRvW9Fs1fby1bqNqjMWsyp0azFBOvJLEsMOXCaOso+f p0/4w51JiO33T3SrhVPJ9vN8Flc5lLFzVim9Y+szOauMwpcLvlXyHTrnHsm7xly0+pU1Vp8kyb09 qlq6t5p5qqvVmvADewzaD+IuwfLh4R12nnPOJycFKcbqbtGMPn2KRFMg/MXSIsSYgUjBV1Hnq3CV QqUYA94Hd/IK+nUaWMNMpYnbq23U0ptlims1KSMgY6wf1gSArkpTa0eA6ZBQEjjYRxYpyiNCQXkB QFDq0B1vDNGDOpCkN+3g+ybkDXI30CPmZJclacMJAXcVkC1oACR+meS3b1SafPs7VW4EvC2yYVDy j82D/E57eXA653t+FeL7J99FNf7duVr21/Ly9tLnsu2Bc3UNG0BcfwQcR1/3Rqhg7znJ6qNY/WvK MzRjKMPml41p5sMm7a6JqRqMuU89drE0uX7sPH4ZIBFvffmDx08Hm7mJp4rWgNS7QO68RF5TRJ1o CVCeUPbs0puciAoPxAfzbs3VRAlp8eK79+mCS04gzH7pz4XhdCvrzBMviCU3ZzjzVBGnH1rrMmH/ r6brZiKtziIeYnfvDRLsF5ENEymhvKYNbqxdxrxEW+9aTMS7sUjxDtvtwpFoa+cmqzWbeJHmICEN O7iURT1VR9Exkmur1e4c51M9cetay9bYHfbr8OYdczMcd6KUwjr7b+JJ27dba9tXPHXjVahxp5xm 5uZJxAcQscFXUQjT1kWeaBm2ZTB+8GGa2XvH3EyCCh0be+6d7k9QfXlpgBt6dQdYHkYOcuA6AoPE tOMQnueO1wSDZnCWp/Iv3gQ2aLDO2izzO3XcAQVWR96OM0gvAqK9RmZraAGERLNE7tcw6OefceLK FxJrKk7YNkCcZQWYobIySVEcQGyDJVFAZl3i1Nznbv11lcdu58vvk11kGtPL5T1vnH2J6NxUQZsm dbMUwnvdVutyaxb1bkwucyn1O506mMe35Jud1c6qtmal+Lb8jmtyidC5T5G93p8i5Ie31GadbhPG QRox7jbol24B0zccHBvtA/EPRX6Bj3brYLJENWNNNMgwIkDJ0G9utwE8q7++bx3edU4n/XP5rPrR PA9o1TxFMQ8ETj2Tr4X39878ZdTqZFJvuntGVuzusxNqPFVNRUBnjI7nJRG977iqzUds5SoZGnfr 9sxTC/aqHk/P7DVcTTwe0mBwcQbwKMarqbWMTHwCv7wtD/qH0hR+fK6IsyUv6XROnr3iHGnshztm FLnkXpF8YG1nJpyplHskSaTGfuC8WQt+ITcIOidaZQ5Z3sjw1l1Xlq78UrrrTNoFNw1jmAoiBvZ8 eAnTl/8AP9sA4cq/fcZzXVzqn3KDrAHd91JZwYdPkNmV+Ev4Bdm++Qpl+sjj8aoguQfqHZIiqhJn ioakfxje5i7rXFc81pvG0Fj9XGlExA+ExC8I2becH6qonThs4Oxp31y7fWXBF4Bsr2fmEnT9RxlQ jpUjeudS38Ij/A38pye1y43v14dp1rNTNJSwu0TV3ummnUIdyHjMPZ7DbuXfVjG1q6INbU9XB5ES Bozuopai9z6oSm58Y3SqaMRsrOFS0Eu4NYUgeNggeoKp247dEC3LK+M6JRdjNzyrLKX9ZFFp28Zc ePKgWZVIVz4R6v6rCzjFDMleFh0BAwQMTMCrpqGOzN3bQOqvlkaqB0PtpQFA+2+b6ecnq+Q+vCmn I5wlXGPOdvmXlZMRo29ZtbcURWZNxqUOa3b29zV5O1vk5yzTvxx6sm1Bm75oc4le9xt8N5zfJ4+b d5VVTxmtSVP6i2DP1OM6Un46eBX0m4wnF9JuZOW5XAaTtEIgHnkikGRAmUGI8zRoOtivJIA201Z2 dv0v6OOfGHIK+AQTHIApDAZCACeg+gCup+rZdfr05T2Te6p0I00BZUbYSmxB9Cwn+fvuRjoPx3HT MTyDbqiJgquZINgM1/p6ljNvtb66vtUxHHD8k3y4fL1qs5uDtIVJpmIHXaKlz17qK1j9ETiM/pCR pY1LmgI5EqU3LdnQUhnTS/7W/H28efpkb58dRSjteK8Ye2vavlcrJY9KVaEjddbYeR+7P5+3sDdd Pu454ic1fXQIlRKOMQQs07V9N37U6aMcde/73rl9TDz4HNQujvA0vItsgUvEajX2cilbNtcglB/I wS8cd8idvrSnq1UzT6K+Lm67tx0FJnncek0fATBzddU/cRNv18dRtdli1kbSWbyAy3vVQQgNa3Pv 1+gJ+f2XvvhcT58+cJe14yfOodCTTlQIBVtz3WItaTYmyFXJDOLIK3UxExtKNEvGqDfVDwhmYgyB z8KTp3+riL2AsFfWcdzPFqYKTZjdKuzIfAzwiOuhWgozoxc51LqHzrNRk4PD9XHl/sadoYTs/FFd 0HxRVuCvOihAl1CRGS1YiFqIkxFxlYYzECRpGDura55Y1TyrFlvlmSF1homhMzDw7RjMzA76JCrk 5y3+MJzmVZ1O6jOLK5qM0bnmqpUQREq7jkve3uVCury+m1qMqZFDzZKlOnK3vl3ExOlb1Vcq6zZO r0tTCvV3MbjZHRq1M72VMLW5tTW9SZnTQfmCGtLTsiZjQh2ypHxpHvIbT2zRbjVSXGgjG20tuqCg 34OZumxvMvB5BpvNs52CBuB97t5jPW49vFV3q6zx0n56DD1uoa0kaffWU1IbpQI1xw1FfdIYip5M 7TUSHi5s433f+Jv/Q27O9dPDeOO6dDo55lmaGrs1qpzM1p7uYgfIM21bqjwidObra8dfymdR1s51 zvpK+8szfFpm9a1ra2+Q2lW7uWi3UVFvcdarrpb5Kzc6gnad0HEaUo1DhK3D0pDSzm9Vy+Zb1MvN yGtLSbiJE6baBDuzVLsStozc3/0lZFX1XTnOtddMczTfpqupxBCkTcQJFJauGhmjXNUGS7QKNVcR 1es6fKmL3G9UrOUGtV/PISprqOGOEU4Qja63lSaN5HK5XHnk9arSQ2beLqIyOta35+em4uq5rx40 JkLF9+vj10rTSnGJUuva2cJw+NUOQbRG5B0gqhDJONFTTpw5tQab9DqFPPTQ7hW7QxKDtOv5/QWV 1cx7KyRmbD4hYrnWxeZQ+P4vDn7oHurlZE1ZPGluSqq1FtXxZpLiM82atRR2rpmpMwFqSBuiFkvL WZXEhlIkylpD4PjL1Hp8zt2zrzt9X0+Y+I71rcP2+nve8rd5HOQnyea3VxXLmi4vFtW+qfWo2+t2 +Rl4a1k6ndY+526useTWaI48xm+Ry5i1N83rNawiOVFb0XvfdDkA5zp2xqfiR+Ix8h9EFJbLt4HH V4+JjrOxOf2nYZR3fr37H9OR75PheL1NyfprOauDqP4H6R/fnUeeTPH6vx15uavOFeJWnP1anibm 3YvnVSjdHeZucxG9MEbmLr908qXhst+IHUptWOK3aanCJ5XI3WWo74nVXxFotNpkEEuz7cDrdRSH sm5+DCs/eETciB6Q2BK6ovrhc95a6ELEuY8wr8NeVK8vnX019f8nd7+2+y2/kAAFZSm2MiYbGt55 lWvNJODrHPbw3O5mDUY4vTnOE8g6DZ5xnKISZMeAlcJK8Ve9CxRevp451H1s8X9ua9OxX3OZwczf yj4Wr6x57h+uZmSXFQWY9xqcnE80Q7s3I71zU3lDxe+VmrxL96DendStQ58bfXH/el1tmqX3r1ye cXWefPJfp80k+51qZP4X+4OAgFer6uabzY83y6Ur5T0brxGT4vePNeurU9OFqCNRlajdQpfTHuDN ZH7QBCci7gDIN7SKLn538r8vFRnC/GsyodX1C9QFSznF7z7g7e9EOXXcsqFHRixuYrd0HO8FXZnA u05DSQ4DOFMihDK6n6z7kaWZV7FUxpUtfEvuxJ8jQ8RU5kZCpbFaey2razJuomqq51oynh7nWldD 6zdWo1L7ndJ7TiqY1UUnvWs78Xv36bt17ZUT2wQGEeAQTrSLR+FPgDR4Zv6Gxip68eX87vz5heK1 2/NcaRY7aTbR+CX10aorexwlaTUjrWjRyzJ3D1T5D6ZIIpV4UtfY/enHR9ZLg+itBAn9epsrzHl4 l3OkTThOnlEISpYBOfdD56p8Wuc9b60Po590vGWTHKldTAuUQ0bB11Oq3j7J1szIDXUxWVg0ibw8 KZ3HaKJqBwF6Ub558v3pZ573XXmN7l5iK17afy7mkUitueebiFcufu17eh9+TUenXhU67XHXSEj3 TOgrWveZh9Jv9QA0Jm66HDE47OnHPjq5COyNhnrafYVNKrTDJH+VAGdNTsDjHvqW68gXM+Zrt7vv F5iHXl7qRtVj2QCAtYEkqUgYGFjYWW1anvyvvI3Pnf7L1CD5xCqZ96jw+mb5v9ipel2ecrXXkwiT uMySkWqFaSH8aqS05k0aR2DNRaGZgG/MBkJSpom11dcLXdRjO3CuqeFspbM500KiNzz3IvC84x/f 5Hrmq6v2f3WqRPzdILTISenghOpcchDao1lJdRDwSlT1p6W55UafMzWXaggfRKnT0781u408VmQ6 zdox8g0tXVY+7SmckqJNLRmnt929Gr3UXOVUwt1GZys4VCrXNy77fVzzb7dGXrWtz+LdGab9TSw0 iTHSDe9cfe85okGhutOMDQCGacXfzquAfE3rtb66iudZTk0cr57xjJyMqAxN+08+fpzm9dy9u68d zfdX3KoWlaDzSdn1IvyrlizLW9PF851ep0+lD77qS83o2C5fAFT+3db3ze+Qu1nLjzk2jS707tO5 3JgiF7fZMfcMX47ed7jxFz3T2oc7RyXxVRkSf7P5ea61ajVbm9wRzVftDbGFiMUfoeFp/d1F3jAq +f492j255jy6NdKh4zuOhF3X9JyMp0lr11yI0JVEHOVbEGNLn6ndR5gLMQsjY6hsLx0ya+5iIsHD 6YRMIwqvjraUYunKZ7gMpNuWeBdTnCVY1EHbnykW48xTt0S9RKNY82I60eiAFweodgo1AVYc5r0H x8vtkd3BS7ilA4h/eCCE3YP9JnNr5TtZpaW8qR3fqqV5u8o3t5p31Suqyoze8yr3O4us0+RT7vN2 bydid33vWriJ3lveRuc1UORudQq3Ezzky+t5vedIG3+kGedA/cNocZA5GDeH5fXTuu+/HdZlfpZg 8CYE3JOUkddLrl2/tkpLHTuCPt3xivS85PHtXyKPQ3d5PXqQlN4l91Txzq5cnjdnro1346vnTrm0 fo/T+Hc5vz2Od0qrxbn+U9N69Ze4J5UnVeov3zFnXec95ernauSyvO+9zi+VPFLp4US4/Wff8/n5 jxmjUeIjz3rIfO3qzudewB/ATBo+AurXQ+z3iePv3nJFH3eu/IHRXfS9PwT3gcr+8R3qknz7Ojis 3fS08VEw7xq5vrXO+TW54Fkj/ON6p1x3ufXfEqvNT3dVCt3trqtRFEHXfVlZur5xTD8kH3HB9OWI +lcgC0YsEGCumVB2AwMIQwMJDVwysdc/Vg6uFkq7aI4votNwbTBGkgZoz6/rChcfM4v7BJm/RF9I NfghmMJG7ab5n4mB/oSCbjbhqbgoykE5TfZocqDW3lofkx/n/Kc9gwa7giDZCi+Mw/YPwBOP9EkP k16t4swdQULbFZFNQgwIghh1lGwAkBxZpG3TRRMtofdEUQGSRwORufX0dHNJuafiEfWIqARiBYDb DX3IhmhJfehMJcTL1IoNIxviCicjF8HcBWHMUUiY/pSHBD/VBwCY4j+5B9YafKoiZMuPqsKdSRVp pppppppppppppoCAxSBAkjJJIl9YlgqPnPR6vn8WPV6q0x9OwCL/S8hDiMOdc3rUKE/+0PEnUFLm BLYWrXSQD4/l/pbI23qrbV+tvxttQIAIACDMpQf3OuUAAAUaAiJCr04y1VtttrlMyCO12HsjZE2f v+ByRvCU8rD7v83l06W9n+Lk2sTnsQdsV8TR2bo7rEdH08a6IEUnH82HU9IY8ZvK3Nn3x5dO+uZp sBal/WPyA8eskVQ2PZQP46I5/OQEWJJAkHYi9GKRcAXpZgfYGoRpAamgCgR5CsAh6z5T82/q4f2t Be0SPmRJK1MVIb/zxcRl/KVDb695o/WT/kdSPMfC8kkZGDIEhB8fpuIc2d1tf6k1vlaYkmYcPMBp y6au8gXFm9Q/oE8Du9Qj/YsTxEDd/3VO8V+RPQnxnE/KamWirHMv3KNiTcn3Atj+AfUInwBfb9uT /f+pK/zVPvYp2MAfXdDGApGKHe6T+X0Y+KYgSKPd55Z2E+g/CaCFlU/g6YxgHBG2CEiqyKh8+afZ uobzqwklgoexgHJiGxB0ihrrTt6HQZQLMXNM+bO6ZdFnTYpc5zJxZg0fRFIC/JyQ2sDlHf2dG/Xb gTbMjqqeeiHTtw9vuv89vjao/jdsbXEqZ983BFoiNKlN5B7J0nGDwAXezHxP6PEQT2mCkwa2OCdD bi57NZLmtB80xrFKO7pt3gcYgmzEDv4W2gNQV/zgBplKXdf3eGEuC+OCCHVfDt8d+OSOPN3Fo+Vd whz0L2waxEHTs3WiWxTbroU3TcQ8nzoQpjxXMJ2r83lBXl8rpqtKN+JujSAmSLDEftt285OrKKu1 47zHLdop0x4ZftSPLBi3R8s7syw+h8WwZWDMkCjrhZGDRs4Z/bacj7wD6g0gphChRBVIrg5LS08N VFzDEJkghe8BZpH70kFekqK32Zsw3S0fUxKUJDSaMmO3lT70j9KvR7CtF6X5w5r8beOBVivGTPn8 3+79bo2Lk3l0NPwOYv2RKONuJ+v29fZgEXHrNb8p+iugCyT+UcIX5H0X/KcWwVAFSV1wOR6W4yk7 p6EvgT6WzD0PMaPsnd7DT6qpIaU+MPkLRgkBiBUD3io8e76yugGbrqUl+zcOddBjjAPIIOLZvZ6A Daehbww8dCkHD0hctBijWjV07wRYlWwdR5tK+tjUG41rSMvNBOOP4/UnJOfpmQ0ce578Nurm5pEh Ra60FPezLoGOMsuEgmToyD8IcUomCYcUomCYyimhjmb6ay3fA3lSSbw/hvw6a0227BOQEYnODXI4 S5BJJJAmKGjFDRm9AxB0lj4ni6MDkTTWGH2v/MaC+2WB8wR3/CJkqByh/LJtFfrYbAZsux8QXQOx 23+S3nPo9eHb3Ic2Fu5+szqnymONHaeMebzthprhNdpnKzVTkVXDwxpgn2nJdBhrIwnCz9/jeFDX UZvJkRxU0ZKv3hN0Ex9AToMR8yxoQxaPtKwFAUM7e98gHP0OMQH5BVKWSGdJYO561jEdl38yQ2bH k7zbQzWllW6YBrEHpiFiNtEIv0vCkwtw/rM7W8U4pup2OBMnLiLubSjtoV5QDXKKUhAgxUYvDcmu F3IZrsGyyQ6SVlOzw40rthpLQEMmR77H+9SCxc5U6nP5tbi7YZOcwjj4Xaec0/saPi/3Ditxd0gd XzoD5oCriBvqQq5+0QdcD+lmOC86n7eTXebaVWpiGQ1vmmEzbz/EAdWiC6KiTRoU0ToDLXEm5fR4 bgNGSXnFpQlucDFVUT9NDaElsRYJ+AOFvagdAf5z+g4uh8zSeQshD0fmt+tDkD4JT6NTDt/B3Q/r 91/3IGcUlhyIp/ewGxIM+2UMivXBP+jHLE3yAP/qRBADbWvK83vYltRS0vZ20tRpN8D/yR0hILmK I6h7KJBqEXohSjzlj8JhvraSnz88GplyRcsmKZ9xWkMdR0jSWUGwKDDYIMshQLXlAeLBsOWkOg/V MmSaskK2emzXqM6dTkCmPBl4n/lrfdOAJFdGDQ2GQvjhsMD/8f/kDuDly7g6DclBGBD6JQxZMP1P 2Mf5FEw+KeFUmsen4qUagPa7IZLk/uJWZUCLFqevwZHgVspT22MjR+fsm3uFs8uC5PJyety05Rcy QUIbfqMuR0ciadRqXNGFsfh7GGqtQ9Vbw0mFt9MiMNDIFe3GK0UDRe8TsA/vOw1B4kro93ifZ+od vbE3upInyUNYAV/iSQ7F+w9b9hA7IJRBhFUIQ49dKXE7ceEf+25ZCQQkVkAPrgIoetskQPU0+MsF VwgP+BEPw/KkEcqQwB9YDIDJhH5Hx12/lsUb+LyD7nH1cciMqac27v/pCru/9vKmXd60zS8zqJCZ du0hRGruZgMG/BBM/qv/O3Gu7kiI8biO6iPbrbDW3p7vy7u7/k7xuId3d38ETMxERzvlrp/1fN1/ l654/7Ub+vxFpOx6iPUaaf9n6PAEo+ytJJJfDvvYRHvuIqoiKiH706F59TodDzc/q35ddvg/+ypL D9eUTGB+e7rNJrTSWUUn5Dtuq2q/cu8SYNkbZYFK20kbASiWCGf+set2q1HH/Q/wtf5TabHS4WyW WFv+6Mz9X8f8P7PH9N4fsseB0ZFvZFmShZUZY+wWaUZWitKVlMzUs1qZtWyXVldky2gsrLWMm2sS AJGISKEgD5fiO89teiefy+X1fHszQj4GfhyilXLq/tpF/vqPGMi5ggIrP18HkcHivPG/IRB0P+RN BAYTg0Y/3Ui/xlfWeQ0jKR3U+YordQesQpOEefzugg2Ua1oz0XZMlOcyUIsQNtqDSfvY4SuuEz0P DfZffQTgzQg9LzzIv9GzTxTIsixEEXgJwgxtFv3/XycvI7Ns2g2QVKoYEY0FFrwwTw1yApCWFCBr 1QXIMQrH1k777AuEG52G5rNW5iVdrL8dzzOwoXsI2caGqwnR0bZV8WTqB/zYB5SAlqAYK+TYZ5jM UwhoDdoNvLhnnm573jnvyBG4/vVFvJRRRuz3l0n0bWFeayiMdL3vfxZFdalU7eWBQ82YOCGbnJxM 2TMB6+aR1iefvJ4CFUWk0hJLK+x6XJKDt6+7DWmhOmiQuFQl0dt+PXDmebaBJ0EkE6OUmQSOgXyC mRRRXTNIRtgbAvSD/C5yDRNBcZmlR8gyFpJGCMy80F5gMGrK20AyZHtg4Z1NtvXcFdzSudcxRRNT nOU2V4ZYuTrdpWVu7Czs1TsxVQ3VS0y4SFkjA56JvDdhDdF2g+5RMrsm47kyHocPmb3HBUCejmm4 1SouXlgNQ9IT5fJlOCcksDckgk60tMphOSbJabzCVOqCeJOSdqeZKTuSJzI1ohYiSKXmpFQilGaN GeLpY0bWIFTZoZFb4JE3JBLSJ3JaWm5MJYmU7ktNE4KxKVpIg/KkFaCxKSk6DjXLyevHIsRUhgRe i9K9FFGyqx7oduCJozQyKGQVgOgXjIutxNO3+xuykN8U4WTA/W4ew9zhhOFXLhxCjQdOIqQyOPeP OZZmcFmqzQlr27Xve9PGePHbHviaISJSJJ72FuYIQh9SU8TLUIY0aTlwKWrr222su22yrtttmbbb bbbfQA7u42yu/eAO7ni7flDGMKsYxVVVXttgxsiouhtldtttlXbbbO2VwTGMKq422nwAe4e4METe vXpVFVVREVVREVVVVVVVVVVVZ7u3G22Ntttxx9fZ+T8fx8fHvbG222V4Cd3dtsiIw9n/V/Q/PiT4 CSE/MgMD4Pg+ddkNttdk2yu1uyRVcbZVXH4B3dwbbg23bbddttkO2YxiKm2Q23L2u3a7btsbZX7P G6tVUzEd/X/mKLu/TvP2H5H4EHhtZkSEiUy7u6qqqqqq7bKq7iWHTuQQQV2222VYxiIm22+3ZXhe wXBgy4DpjDtsqqqqqIiqu22fNQN53bbbbbbY2222/s2cdyquCIh3eKRyZp3piiZl3dx3/nPQN5P2 bMASDFgUVwsrIlZWcy8ZgopCKRIYN+lC72eceLcq8Bqee67IDBnvc51wVsBxMJf6MGkRzOnOAJ74 3+gKLu7v3aSZ6D+n9pTbY3+43+w+gP3nfbu8Qou6q7u6s3QIPnQX4oguNNM/b9p/TwxX/L6uXZpp U/PD+j7v+jXLmbv+p609i+6DOfh1y3Ov+XNbOB9p5iDt3FSc3P3RHf1b7NnnnNEe8kydxECRrkzJ 3431d2dWI0TJPvcyaiJjucq28TEEzHZMzBbjk768fHa311oTpzUzrwRFDnmMkuecu7Nr9++Gb9bj WVdlVbRiZTc4njVRRd58XXyystI5M/MvobDS+3c7HPM0Lmx37+EO0jGN4FoCVjF50vhCnHS8/BC2 LzQc2LamBd9nB7Zlz+V9zhWvQd2A9hka8weJK7ODOgyBlMvgvX4eHnu7x0Q8RnOaqu67uqqqr6E5 H0NfYG47/VK2+w10XDz+Ye/y7OLtEI9Hv6Of/YYWbUha0MHRCwujspRX0B6E79QmA3pZtYVZuOB/ QJo6prBwLUZg4p0evCLNaKRynjSEROezSXqFb0MUiPqEbWFF5yOdpQnKnY7uDAIQhgpsCvRBwPga EhyB38Q3RjY+INSeCJCXXSWgh6D4u1VvRvPwdmjsL01u4ni7cXjyfHxgVJ+O75mbiwhudBg7FcZq ctsaQ/AioHuweZb5R4IsVFEJzYVBM5P+FECK7vd30QyTgp56DmIIBqnIpgIyBggDAEEm0Z0PCgY0 jczzh7aQfeF71YZmp+vx2DxuIpCAQm1C75gVlWrX4RiMFFoUPSeoGT0ICoeXNO8NCPgY220udY51 wjkBhRhBznO78aQwmZDx+IZ8BpGQD/p/u/R67kvvA2JkxrPrLNL9oUj99+fX1+PoqqqquVXLlyqq +TbZfZ5ty/aB628Xxcv09B67vFVVVV9B7+693ztvYieeHnTp4qv9APqHA3d3YWG5ne4jjvA7/b2V VV2Gw6YKEHZkZkM79h7yHNg93cdnQez4AUHnWvud5CzQOANsFFVAUAAgNBYd+NPpKPJ7BqMBXfPP iuM3nbfaSOfYnMv5N5Y3IiaH+O/CQ0qQwCULp2NVhXe+FlohxrKxwzCGF5djwpEzjc6JtxvXPPnK MNfctyOOSMw4/OB83EU7x7P117fQPM/AZXRXyvUu8kxDjjju8u/yqIh36mIeug8B5N+et7+x327u 775xaXkFmZ8XyvLYfZsHbvnMd+3dw3czzrn4x7+m71qehjwCY6QdsX5lnBQ+fMBZvj42ku223622 +i+Kqr+QO25fx7uOMuXL9Pv2VT4xj1wWn18PIFMFO+O+RUzcRHZdgN2B0EEA3tDvIUgIYzICAQa2 bwHY+1u/p3ZTt8EDmNfyYydExghUPwsLQJ4YYVWxdpnALkVV2XNQ50YJDC5obz88Cb0uEfwpRaSE Hvo/oX4yH9hQhQjEKKGmKxYEEIMGA/YUr9KRBIEH6eHj6jgZ5xN0BYRZB4IhiKw/ysNn84b84NSG qsGhQkIDIp/ueIKh9alqsFioJSySQECgJQRgCkkKiJEoskkVZIJHxdp3DbY4wn/PM0sSoqKiT/a8 wwNSBYUolksksgqR/otlJE/rf8ShQ2YooaCEeTGRgqXKYChJEikheSCUEoUZUv8pkaFUf7Pb/2Xx sU9UARfj9Id/iT2JsncnqS03JE0TQc7JxfijwFFYezZMRJ+c8wfv0RdViqlrcaymn0TGXde83gyB f1h/ZAj9/oPaU/i5/5cToset3oc9/uadXx0fb+NLeyj8az44tCphmVVEZM3saqz730zi7NEqrsI3 0VNQqg4utnrr6POz4t1OfBoLrYPW0qHKP1nqOSf2W77TRT7H6eOEH20kpW6pH85Yfzz52uv5V/VI KQ6KrAmwQ/aIkTf/MVROMano6TogDnJwht6XkeJP+0zd/EJH+8F/vPtCspUxNMVr091ceDu4psGT 2sH5RW8qAL8H6ulUfenD/P/ht93/i/Z4gM2kjo1X+dcgsKSkOZBOEJEz7hNvGH5j+5Se1ZIdpE9E QibqViFrYncmqIHKC2AnBE7v8InAPw3l4wAHsSAkL1CoQepJZ2a21bCD4MQ2QfBDVMY2BHteO7XU 21vaih0ep1QiGwUihsJ+0kI+Uso7BTykaij/aJEOXYPHjT14We4fU58HraUspS23yBY4TqfsUr71 RCSUHYRrSEjfcopbRgI+BQbmxDaSQMCEIkN5bZBBdU6FdEnNKyXjEDFpUtqrKq20uoxqvCrmtZ34 keRTyjwUiFHUQj2Clh63mIgvLYiHNRTVh2Abvvz9Y8qZmJU+KqanbfNmb8RMAVOtAOzD57C8EHVM LC7anoO49Ax/rr2xBzL54/0k3e0WSSCdJIP+s3WUWXfOLiDJ9R+RApHm0MDsf8//77NmlEfpqQ+9 XeqE/klRVT8L5kj4i91Taxqj4G2JOcKT/Wd8eT13ILFCCRwgfXwp9qQX6hXk+0gQ/cnzMCDzD3mr eNB4/Y0ljuBEiGih1daJSCAfP6g8wdam67Aq0n9sVxe4V+wXYCfXJ05eGwdw1Enop5pE9rJhUUpL AAivXMHYnukkViQQ9RTIhxiXEuK0EFDejBjERQ0OyimJpEwRH3bb8bWBTW4xkP+NP7qmoskKVLGw Uyv+Pw6jY2KRZkjvLE01CniZ/htJgtWdbckTjBheD5ImpLIuq19c1vf1rt5WrNlrVggNssikDQMo 0gGFAgmmPguHXKkiBEXaO+KL9zyo9kBtilaIXu2C562kLWSs3e4KgmojCGEw4YHDmd/H87i2MfcG qgr4g5OqgXFWQSjye+m3GlBc8n134x4vrJIqmZGV9gUbPSfcn9E3pvo4UVD1l1mYWMCLCtadMUqH oIAsgorPzn7w0z3Bqn6R29Dq2jkZGjsU1OcYZsO5kjU0c5s8xwblVvKZLzuWtSSTBkUsokJeAQbo eRMJkCZADmvH+3fRK8o/XDXRaZzzrX6TguU5hxviNmBw+TcGgOCSHWEE11IZMuQyzCQcxoZKwH5Z 20jMVWPyNNoMlLKkpdRd4H6UOtIB0+MOIN29bI+VE7qI/IsSSR/np/E9s5HLJQyHnjs3EOicYIGI Da3adoYxCXJS9LKHK9f8taMuQhNrziJUWHdA3nMzPQAKgX3oKrYC3ByReZQg+dIfV6E9iIWbw6j7 kNP3bD/UwfpJZDfg2+1LaUptse04LTNOvYaHFKlsjZO1J+H/Ked/R9B7MjMxjh+Z9cpH2XMSiZjz 8gH84IdJbTo04F2uDc7sgT4D08evLrnxe97XqbJIiZgpoS7360GNZKIQhldyE78B3AeMoEP+kdv3 VyLKuLtEtSNQQKCNR12kMkqSqMWkH3PN9d617UzdILzkmKzrjEFBDnPq2yQuaRIxNi2m9Ywednq2 nckEb5Ng+Py0S+vWs92PmChttycOPH5nwHo8iJjJ1xtNKWk8I09Ztv6kxsfnKyUpXpMk5rJNGSbT mFFDEfmKeE/h+y38H+9/09rOFlifp/qcT+RyQBtHAr37GpPpf6ODFJ883tlBy9p30PgyAD6IotBc M77PtxvclQgcXy6bY6XEs+IiVGEf6l+0KUOgiPkA6j0ftTuT2fVWJIMFSwKEEoRSCvrJ7RsMD9LE +LVMJoVG+7XNZMhS60w+nfTs4YVSxdZJhkrJWHmHdw3bynQz9quscM468kOnq68Utm2upJSytNNe ZF/H9mFvHQJ8NzGDD7E7DQfuRDT7VivIAnWD9dR5HeSIay9EPvnM4wc6DqMEFPoZmZmZnCpQixJH gblWsRIRnSBgZHN70kfzofg0EUoeCHyc91bSEDFGGkotwVD9C52NAM2+JgLU8tlW+8+8rzzXBJkg p5rrxe2Eq7rur1LahWopT7GmNMY0Id3kHtDmQaSQYgnAVF8UE5ShMefKxcahCV2oGA7/MpGHJGNK dJ0NAIHnKd4b4on6ooB/rzuGOY5FpKnDaHR5OJnDM8+J+LNGMShHvnTAiQ41B6LmypBmkveqHgdn MPc/WScL40Be1GukuXiYnGLOg2yo6uOxOcCGxoStx/+4aNFMbbaQMOcDraGjwC6rqk4lJ4jwlWZk yNA0mcHQ6nHKo9S1zNU22SsG8w2ksYI7ajrypvKiHd5wqZS9MzGRR/nb+8x3X1Du6viT89XPiqsA ADVLdWqqlyH7yBjFG1Gt4CO7zD7x4JJDysdsqef3eHENRlU0KH1rOlOidA9A0JRP2kKl4oKpOm0k qBayQl9xxjkSEkZAhK3SE3GscSXIkHKk6PBQ7AEVC1I6Op0EExxjCEPES6S/a+jXm/a1XNX2rbcF mwprW++ECKCsulhBBKlGG0P3Ew2J0qoZUU4KHlIoWu/4vcFhhWMBiM/p5VCNURoOg79k4uuDj85N XrYMIke0AOgehNSGd3fVNPxGMkSECEcvA7yGG3pDBECkFMDuvpFcGrj8pGD4cj0oJH6h29I0HDma SQZJKdORx4dxZ7+6h7xeqarHuItzXSQlJQBDKxYsAiEPCgOg/N2/V6MPgfjI0+E/BIfqiKdadKdX Y/WCB2wkGMEBfNFFPiiiOkS8LemD/l8MhvNSlNR8iJ/JBPk97MUcsMZZBhQtW22wqyMhIkJJ/JZ8 ZaYlRUPCKzGloCJ8UJ2SyDtNztj8ExY/JivqP8f6z1vB3Xs54tZrwmvDVm29vhh6E+o7XkRDh6+m PohzDZ822SPbFkBoRZWU0T7J6vlvOC8Yxi7vBd4Ly47dkA6FALCsIY7yBYUlNcEgMhkiVhKHGM5V LRKMB9YkcBi2wT1T16QL5CDdvO7u7ttDd3YnB7ZODB236vO7rD0eoCLB3KrbarSqvuGJsyXjuOnj 55xxxxxxxxxx8EL3J2dk74Q7K/gxgWoGqSQyl5ph4x8ESxYG75X8zCfyrEO6/tr6/ViSfUR1GBcU fz/FSK/B1rwQj0HafECQgj2oUHwS1SiB6eNiiaIQVckITBtswxIKziaujMrQRqhlWonZpj6ooKm8 E2Aiod4e9KBHwXiPkeT4IbhCMA8ZxQ9PXSkioyKHWRSMUhGT7wIlMQ8RGRT7ZhPItBQRNyv/jb+7 a+59NU19q9n2tJtwAkA4d8enca+Pt15A2/Ts4Ab7uvva0I/iSSHaUKwiHnTgru3+N8XOAeEENxBb hggqmDKnqgHbP5oHhF9MQyRT9Nftuv4I9NSyLECkWdaEw/gxdZHwoqJtX++wP4bE3o3njMINOPuZ PFJ19tSQRwdhowILWgIuK/L8gwiWD4fQ+3Xi3ISDIJbufW6zwRx+EdYZAlGAao5UHzxE8h7zCfxA iD9kke4/d6Xgnn+almRxV9GOS6zMfoPIYcTZp/IcY3F6B6n51UbiKobwDQiqtuvlfz9IfuPth8ZD ESQNYT4GltsxLhy3fWaB7R6DtBHQffD7ZDyNG6pBylWPjRbJDwnbLOQ+kKKg6KhFEyoEVDzEPsDo U4DEEC33h5F6HAPijAih5TD0vWP6ySDyPJrFEVD6R5HnISd4IhVEYHX0xjLF+wPq0iGji+gv8Ym+ +bsVfpJiUT9ZiUTMxJMXVku6ui8PW7HyFc0CJESMYJzAVPQJFIshwJzzgJxxjLAMSWRQxULbqHi1 PXHNrNJY7rCWlq4YykcoqaUvChSYuhwDAii36T+Hu7yqgdC9PjpETxEAfGIRF80VP2Zss0JZ6/gF 5fooyTWmI6WRPylS2B/XSNU+4SST5xD3I+wwmtn9cUme6fj9+Q/GLdYbSRNzzsQ+V9a+cAMwDtT8 A+gR9ZoaJw/zyu8DchzPhHsqhjHp+yZQuMorNXdVCAhCyj+uxkN3+YJjn80xGBbYfRv/GGA1PKwe 59Cu0SRF7U13f1rW6K+E69Tfn26/1exDyWff8wEN7fZKjKUEpaWGEiaRLmxKwpWLzLJH41AF7npD 5T5E7X1xs5OHYTBOwsbInG2F4pe2ySJ2/q1820cSpwslVJKw8UNTRp8j3uP8DakwebyCWvp93rTH UhlkgwsOMDSlNRTlX49Hojrm/PMzM/GT4CI7ihocYtT3Kap9TPcQTsA+0oE2AhiQbE+f66A6Yl9y UKkB9j7VXpAgqb+rtN0a+g/t/x8WqGde92LKzO4HL+A2H4OwYGAZCAKUGuyktS7PTFSroISEUk89 2EPJGOiFWpSnCqsHSsS7q/3549hVA9WqhzX6VCJCzd8L4Hy+ySdaExasmRWVBG0lgn9LFMyGmaXF ssktofuHCbRgwSakslQWQ2Za/ad7pHj2gWiZJnCwgUcokHSKvqRqAwXJhoMRFQMgeCdHQJE9o1+R 1Kfo0TTKQ0GsqZyntcULTQULitK7MB7gF8VIaIB/S0Pcch7g8Zt7nA4dBwPYt0ti0LEYr5iwClyN DiDZBiubfz/+Px/R5TxdKoajF+uImk/linmAgfyhFv4UD0KHZSdTY+hOq30aOBIN0jR5rsSED51h UXB4qs1A3P7FwmCEtVqfIPjk85VWJao0+NVj72J/Cs35kljKmoNFdUrOpNtL9fIHQ0Oj0r0kVIRR 5iP3skfaQCofOwfHQUh6+msRDIO9iS0mHYet2DtPobjd2fta38qNzzvPph6mOJ9k9fkT3H/v5rY7 CqpXk8UHrdf4C2WQU3JlM8XViFIcyuB4YH9TgR80T2ydVA/A7CSk9p24sTzfdR4MDte89rZ/5Yn7 yD4vyJ4oRVVIjPQNDGH5P5FC4n5g9BYeuJ1LaJP2TerfkBixX96Dr/Gf3IbWwCZePnfWobyDTIIV wBkHJSiKh95pNVIhpGygiq3kOREO1qFkK2iQvDpHzSRkUtMqxa9VlitcxEkPBMfzr8PyNNT7Tqcp Gk5kMmDt747kNpnEQfrw043Y3YrB5wkWiL8e9o6NRHKQ5Kz6I6pH0yDZDV+KAeQGP13QNfZQDxi4 /wpE+sA+/r5V+JTV4S23iXWCUe4YKn2EEQBkVGUktQItmm1XhJPCB5/fffZi9uRltpSylLbQugmv 69ldn+J3nZ/rE7z+MJsB6wg8wofWHoBKHh5VFV4jBMgmE2h54kPBHXB0hvJ5bwfESPOjSpxMCKGC 2qCKGKE7DRQTE4Jz1Dj6voOCR+boxHPWQMWTp6eden6PuSHi9InTvP9H9B19Bor5jX4t+rQsnqXw HSRtFj1xfKfEOT4us8OCHsj4IijJxIglFhIKbxNICn5QD9qRDmHpI/X/7/n938bqGX5LqfXuDxQF 9ye5Pn1PTbJKMQuqCF2WWQuyQTBYQqUuLo0d1gw6p3WWk/JT83HqFH1rhS2Itp2B1MHYwUoccbFo URO4N3FpaWlp2OA/vFO8n9OC5HAVgkIXIVd1qAOymXORySFB8bDibEspwY2KUMKWmJSOM6zcB29n j9uGe0av45mzJWJZZVyyyrll8JeNKyYzLzZvUUyUHxHnCNKv1hAsIDAgCCC4ykEDYwDtCA4Pik01 1rnrIRQuegoDRaUpTQyAR3ZFMin0PwBN1j1RENoh1sUfnHs6B+tefanjfItC/pOgPkzkhgKaREyf 7r/yR6FHuCKH7vNWAwFJeDESBZS5S0tTRqxHxxwnwxqadIbPYwlED1LHKFK+Yoery6KfQiHawhAI RC1Vh9+fnmQJ6Tjn2d69TWflKtpo0FlGPLRcUw+cY8h9owSO8Ot1Pq9gmh8BzZUXmlmIVTQ4P4L+ v8KZGpZ+Kz+M+el9Q8iB+Iv1e3JRwiSfD+FOCMU0IEJhIYW4Q3prHI1sIMlkHJzgHUlHdrYZlyOR Rn9FGECiBKAeocdxToejtp2FvoSDQhmDYWhwPrQ0GELutkegWuC2yBeSgwH9Ol6GkuVaH1alg2h9 AfzjI4Nqk5aTJNWazWu0Pl/CL83lRkL9mup3CTIglFz77O9eNd/B5+q+lBXeop6cCIaEQ/LhQWln f8gEQ6jbODpxUTIV8Xj1YA2dYolBo0JPX58Tf9JB13u4UtsKNiBwHoBF8aEHzHgNXlVh2iWPQdZ1 adSPPUh/MdXkyp3E7a1Nz+5jBjYD05ATuVN46oZIKjvSABQDS2FJ2Gw+ueo7qXiQR+IX9p5rkX8i woom72txT5GGpleg/5frDu7EgnhYh44kSeGv1apQCL3BIBEJrmYpg7gygg/CmiAEBBpnwkJanDdM xBBM8casdmAHKqZGN4ERoiB4901x8dvp3CHPfuSIfX6A3qkcCsscjnMZOKCEkYvejGpnKm7B4ki1 5NPCJgYxk6i8/lNRLrnckm9NrbCSSEJEkiFzqouc6qqauBZCEK21EzrlKXiTnESZjtyCKE8uadBa vbIKmtrzvhGgcgyKRyK2FUkKGED6PkIkRxmYKCzvx15BSUNbW52NE1yYLU5DN2hbcNQShooLtW1L uoc5gMKhhSKJELCG4w4MwUDdu3ZTKQXJbVTqoKN0SRqG27ftemryPk8X86ZRPYWhhfcKa7h6HTiq Pgm4gvYQSiJx19U4AoHypFauE5eU2DCAOMZh8vaPQcE4gZTxu9PK8HEHfGfnlJFIxR43hMKeYzXa Ra9tBqs6vmq+rTUxuSQPwCBRyQ/8pCJzEO4MvnQ8Biph1HsX1plbA8Yr5DaHgWbeCeaflk4PBXzd TrHdjJ3Zc0gb2cSdYJv2P+9aQcSuah2q9FTC7pWSSJSzDJJfwtcryX1yy4iPGQ696WIWtSyLkQEt E7w3JbXrED6kpxepKT2LvDj7K7MQk4HcGjgE4KfCAdYsReH0vf5W1fo0vDy0ug5yZU/HQnt/AY5G mPi+H5ue9wRNpKLNO7gEk98JKN5ofaQ8iWUqxgIc4oB1wH/SCffM9fa9KUbMkyh0qQ0x0aYVT+ss P0VH7zsMJ3fjPaj8e/3J+71fNmlWfNbm/+wr/FdGhfsbf5mTf6H6l4D/lJWdgQzZ/DGK09S41u/S 8Q3apoR21q7l8VdjI9aHylIcRQPkksmQcR9jZ1RvBNl/QiFRHlGYqiQs6XEdie45v5wNEQUwQRGP QdBqfVhy8ViGghxQiGDpDrGDEcH0yR2JQMoijUEJCSLqCJsxdHT9xy6RFKjXaAi1JZgXlYIU0Xgy ZPPcTxG2Sqapsl7IdKiOvVexOwcsTYeEc4qT8tCPrgqeoICfwieqSBISIof7e87nGFshI+LUYPx9 w9MBHfE8PlxIPfQjlUagOKaRv4jAdYuFe48SyMgQiSAEiWedf2AEc+Iim6Gwi6HE+ZQ3KnrU84ZJ sHqKVSnWF5HzKEyGD2g/XpQoaUh16aI/2JEf4/PX93m+r1nnMqyAME7ueIiULStsHlh9rPdCxy+b 0yeec5DbdzkrzVGQqfloIPpPAYPzGj9PAPmC0+f65JO4u4FsD3xH0CvPsCd1W3GLgVTrgDBIiWm8 xZ0oGv8oecD86ZVQMEVfvICv7So0BZP6bPy/klId1sKVFC75ou0rx0ZEvbe8mmGWRKsmTGMQZIFr Y5lsLIBEitUUNIoYAWJiDEaiJEii1GZ0o0dK0pQ6LQpwsZThuwI0GrPnLagMPeAQKD+kTUSE+CJZ JGzZEn5M43gewocfcRPXYTLETKJYlkh2UNKIGrJEtIGcp9GoH9JtOEegneSiKiLJ3e8ePElhrIji R0+9bXf9v6l9M8HIwKfRIj1No0dX8pPoj6nxsMx6ZPwxPOPhGyYhzOQ5iUROs/11LLLZH+kn8s8T /Mj5SGD4ajapxHvT4/wfNr+j/or6Fb5/pKx0fpyqEqPD6qnPEFqDod6oTGvUydJMc5QDl8z3gbfx k/tliZeopM+b0vzaj+CcJwDSfaZEf4R7UeiUUO1zRroiAapB/fsc4CAGKPOUAxT/s/PmeDve+PbG MmRWfNYylWP+/tyLUnwu5437N7yLN+p6DkQihQCAwKJDmZGhSACj+4w1/xz6OiTy8qAYJEMJAYG/ reSmquQiv/BLB0U5GUoEOtO74CTHM30OoTX/gF/sHWKLGTAxL5jTgv+QYqTxHM7/Qb6f99W0AJoQ L5WAQX6Ebrucn/0GIn9AQcJmeyofo/9f+X27voUccwikD9v3CSbweAx9YXp36lsPYzxz/yEWQMRP R+ON5Ys6B9x+mRHi1IP7oZE/tEX8pEnoP6O3zoT3FIkWhQsh6/dIjaYd3e+zyJ5yePQ0VIwn5zHY siNolQnxq7J/KUnkjmTNif7nM9iK/29252SdU+zgXP1fYnHVdT4ANIwCIitI8IQoaBOSfp4mFNf2 k9kt2NqoqIjX3torQHIoZHCMfpFaLCVFif/WSScp5JGTvNzy6Gwdk5h+dwckiTkcP4Z+i9nr9Ymc 5yWv5VDWGozF/Nd+8nOd8dyHQtQpJIHmZ8zigkWJe5hVvcNe4PwUg24CpFqFx62P1eMePY7t8jn4 1SWyKpLN00BSsRCKwOtH+I9GEcKYIHQYKFaiYVhakTzBEeCWNDSTtjeVSg+uQ0TyY5o/IVbVVXOR HK/Iv6h8CcChWn69odAjyr7lqV9x7f6DA7QDJWBBsgxQTkykNAbC3wG1dFYDkGlHIqngzA+w63yp vPjyKJoRUtlNwz16kO5wfVn2W3sOIg55DaHPPpiSMz5C4FYAf2HWXOPjHABfL5bExBhBL9lW9fHp Typ5ER021X+H5UdHz77UFSDJmACELqSSO2rerTGQAYiNK3KIidKbeXPKk2inQ8RABtpeekLikpL0 JFiQoN9bIJBPEokUP64ySI9e9E0sE07KRP4HQn93WfDjMnVhWDB7eWIaK0YnmafWlBIkIu6zFABY ZpHEeB9pKr+PdZ+eL/1DxuebYuWGvt++NG2jzf8IOaJCt8LrK3S/d+16b/af1g8Osqd4KMGNfIbw +wD8A/zBwaRHEMH2QLnfE5yUXeCRo0bMvgb9AH1eThetdgC8Saw/HVUlq3D1FPbG6bduPzx/bzcp /5vf1vxyg95bwJCBP/sHw+T9whh3yJFOcJ+cfTXTG7BnlMDVaY5/jJtHNU3furP5fBvJz2oHemCD avbDpynv1H6O7xGX9GR7xN3vDV3uQdEHhMF6Mdgdp/KkoQ/zYo4toBe/4QaAVwiU0/yC5xm2P3TQ Yb7kfP/Ww0UW+TtvEuON4kv+OQUQg9ZHzvaZE/iep9PfsDtnoPOfePnJDcTAQ/RRcVX94EH+GUPO kRLyQykDtZgIMBFgIu4zTajAoii7TUkhBCQiPMoUoSMTKkDEFgMV9n6ztO1B+OKJ8TFbIqf8JbNv oD9K4X7VyvvV/zsL0i9YcEdQfWjMFMRYl+gjcGoQPt3BGB/s9iN/vn5EJ+Af/Qt7nh/QP6qPjy4W XLa3Ort3NFxzGyjRbJa2lsy5iRFVliZYCrfefsh7P5of6j8G38yNiINem3I2Ig18PjqiG6qI1/lv 3/y7BuX/cogPDx8TOlXGwjU/mTDTQVUpTDWjRS2mlPakz8BlK3Zq7q+k0D/E3ijvAh4bQ3/w/Eck eQcTeBlnI+XrcxNm604HO8TeLjnAs0UBMbTp+uuMiTPZxCBCH13HaK7wuZ44/a6UWmByXdkBrnaO OPp9exTtjsi7DyV+yvvpsfN98N49W7FyyTpOjqtVynC3XffCJphHHShNO0RLpCCLmJBSiIQkap37 ilZGIYSdYT0VCVIfTQ9WBrOstI20p7wkEQk/SB1U9yZU6NSru7dwSHZNpyISkfMLwwyIOa4gFDCV 1N5UL5PvAcJtQ7ZUhPHyA/ZAHkdMJFkJCSRNc/5gTVwnIB8gkiKCgThG+dyKUv6RW3GLFrNmnA52 trdc4FXrQYL7vf7uqstQnITPruO0V3hczxx+10otMCcsoHwn0+tE76X68lO27Iuw81+yibV0Oqpm qGSiDqGclOmicnlPbrvvZEioc9mrrDazIgyiwYslWzMdKScyDEcUpcDQ40aCQtd8vaNQiQkgemq1 sN5hRi77KG+vG9buvvw+dQvwd566W+tmfCy0tt4Ghac4bh/OH7Xn5792ddnXFNqm2xtsbfo92+g/ AA/nADpD360j0l2zg7+l7+sk8+NBgvf4+OqpknRrt+0V3Zcztx+1xRaYHJd2QGnOu3J4u0Q7xDju w2/ZTtNvmkulux9mjPX0T1S8Hp+chtTIgyiwYslWzMcqScKlibMhqHo+ieiFNJ8XfFjywpbQ9NVr WJmB3HZ3jaCOTcZW4QLRN5LJXEO2ndlCSTAVAkMVZUureDGPqfqfWB3q81TwPF3H6/J5P9LOPyer Gmmprck1vcbtmrl3LfHJCMHL1AIecduA6D5VUZ0PrrV7Xkd6rwbGPfu7Elqf6sR8Zse4bdJ2JzIT kDy0rlHWWvv/DwgQAAA/u+t+Ov56fo31TyiHgnk71iqfAne8Heqf2JY+GRBLKImQOaao+1XsHrGk NSsnxQkWQkLbY1pPgEzeSnxSeobFMMJJ+0ohkIFqefv1DnE3emSEYT/jZxOUWRZCQkkTvuFyedoK rxTr9nvwcN2wak9/d77cTXjXCE9dlzO3H7XFFpgcQGlnW/roZj5MwHkatD70iR5T6J7zeKQ4ehif SfOYE9jkDeScoeZZVSVSrKqrDmnvHqTw1oHn80B6x0QgGEKDo0K6Lsu7Sy7uy7tprWtNa1prXc5Q EcOl8UpSUo8HP2j0z9n6p8YUY/2TmocoFECKdQRPb61MK2qZNFv+ryOgqfBPgnY2v4hAyMVa02+V P4a7UbHATfHzfPOLNSSN1hZvcDFKbCliWJeAFNAEPQvpFWIFIW/Pfd1tfo/jtbrV7avEDTTMhgAA ZEY2jDZZklFirvB9ciM2FPvA+/2U/Xnq0uuck7x/DYOAkisgkiSJIETeItKJ0Pxw7rCqbNWXncZU MzLZmn26JMSPMjIs2fl1UwKMCBEOkB9atyRjJEk6x+YQMoUIYlKEYMWRaY0sCOsiaG8iMQ4RGojr UWwFoXYugfT+PiUNkNgpdUHYQ1BA8VK9RYnFk8qqpSpUVUsv7okXy4jl/3yNk6kwO7ryFJE1iUYl JV3ctLvXRM6phhwlWW6UsWwmLYQxTDumxh4a7dPl0GoQKy0aq6OMJSaiaJaWkS01TUE0TCZIpVNJ IQgwgLIFOUwXhQYwkDYDCCWAyihDPj5CloQ6TvS7vXh6vXCd26yWyZJKKxuwxlgWV101G1eq9reO bbWuo2Mlr27doik2sV6p2a9dc1zN01G1fKva3jm21rrGUpDxjC0tClkJaHBWWHI2Dc3TLV8q4LwY qRUcQk0AHihwAChIoyIrFSKBarVAh0oEYpShhQYBDH1p/PQEpLaspREVVFtUAMmwGQFE3AkUEijh kkAE/8u2606uwlsJqNTz2Wp1lLjJ6wlSRyWQSpO/e1ELbbbTqB5T18Ikk/0eBFTIDiFkUSLAWIsk 7liatu2bpqLWlXEQw7axJFGJSRGSEqJSSkmAyQUg0D2qdKlCc4kgsgJ2wTgNMl1r6q+rXx+evz/w iQAHytevxb307SqVZFgd0dwinVHadiMMPVZKuZZOG5ipbWWU01d2rtlKyarZu1SEJpLsztREP/Mp gXKFd4oOQtUs9aAcAYDT/k2MGMZ1mnH6Kglk0juzn05DQTbMQ5cS3BiyW2agmVMpBkYQIkSRhDRF dgdjIda7g9eISEkYEP7F0AE/1FtNNrXvb8fz+P7jX46r6riBJJJJJJJJAgmSRb9m20ZH0KnAXgmU RTmq6pSAkgIRJEioSLCEYFpYjEiJoCqeO0ti0WxZDaRDVkEeQq1EQpYIUliXMkkWBkLG0ZCSDoJy QyhgYMcinQAHp9WVTDMkChRGsM1omaEqi6dslbbLFjKy4lMMZkTI5RHLt12mva4p0iQiYp5AikQ4 5NSQGBIx9TuUmGUZJLVg4kWmsRhRRSaRU1ZYsUsXSNQkzRosaJPOMG0NI2l1Ud421NzNjRUtSoyN 0ZFKTKG5YpuZGxY3XerS1IrEa2JIio2wXnw9J3dBSq1tgwSFtjWMghGKAJRi0qtFZRCxGDCJZFaV WlVrattjUSJBFkjRFpVaVWtbY1EiQRZI0RaVUkkIaQh+h2zxKHAp+A8aGzZRNBagsIIkSCJNFTqQ yoQVwNg0hXk+KiiiqqqxmW4zLbbc5p6W8hO2CNeMtpVSFKLSpZNSWkmN9fz23tr5bdJAF5RBGcRp VhEQiuqmgnFLAcWkkZ/oUd4aqu9IBE70dE2dFsii0u6Pm3h3e/KxmUtyhiuI8cOCoQNT9ABQWC5T qe05dqi/+7mLIKMgRIwipEDVDqWw3rlFNgNByinaiu8Mio+wQ0BMKoGQeYpoAqwU9ScE7t4diq2n Un9B3KbJzTCCGRkfHHZIyOuXuQmmlq0p2FSosVJFWSKURkJYsFkiOsNJN6Wha3Hx+CarSOkSTqSW RsDnJG0uL9iPsjqRhkYR6U7UblBO3gPlXBzAgnj8CoQ5AJEIqiqeIQdIDkODYaN5JY7EZFlNJG/g RfnL1KiqbocvjkhHMajmnOKE1HtG0OUSUnh77OBqSsR4vn5nlEWOEkdMSwpBLSlBwkkmoNWSQWiV YqyRakWnoTZhIrSQSiJFrpBKQQ/AjIFpgZEorajbJWgtDTQH5d9t6smgqu7qBYLGAccCmDlmVIMI 0kcRry+YyTQ115JdeDJKWxZlRbEmmYTASeByRlTJjIT+uKSDySHJ2o7osUixYjJiPwhnT4oXxoE4 3XhJ3G53kOnl8wQGriYUDcN8dkQyiecIsIkCKh1GoUgJqgI6gKMFigjBVpGlIpqDy4SJEiUHxhk6 HymoagvieQpom6JBwmUPMdIwlCtwNBdTcKrhA2kTSfD9Pz5DqhyOOy0W2rFYkGLEKx54ellWZDGE 0LINkjyNe11Ztt5LRqKioqUtbAMIgQwDkYL2hHZAeNPJVfY9JOM6z7T0kPkKKPeQOkf8dt25fGjw IwXkBkgqSX16y6k0pUiWltfj18rceBjbFqqr4HoY0qlelOLFLUEpEG10e4AaU5d4FpaHv8DZPGeN IUlJuSK2RIWkYlpaiXEgSDIYaNSNUiVGRqLGkaRRWjRSUUpEUkkpkRNCYaNMJaARVRmjzQkM0jQw Y0xjGQgyoxgMYxgVCg8aPkDz8U7N6VUopm5OzuLrK07GZpdtVfC2/NpG9RsV3c5AgorIggEYpIIi q+mvK8SSBry8sS2VN+Vr+xYO1AM5GRkI6dvFkRKQ1YwemNNGR6CBCKSM7k1B5AHAO9FDUdyoltkS 0WqskSijpPVJBiKIsUnZ2HxXMuWjKzxUeEeBwWc0k2keVUslsVLaUuRPGGHQjDtIUAcBkEeSoYDR UHMCLIMZESW2FFipbYWB86NQahBHc8kILEFIQIQF4jY7vBRJEYkk0aSxGIoNJiKI0aSxGjRpLBW1 8reWvoqvokeaQ6XWSSJBi94rkNNpImI1UkKLjC5iMzHtPje98SvjYx8ananDl65GsLbBBIfZcFDE MyE0MyMEBmZBwMkSyFNg0kANAUIMlhZLa2V9/fft7e0nq2+rwrAFbNKpTWfLmozTCE9Ek03gedIv lbbbVLH1OnK247td3W5Wddyk0pIQk1TfaR2NyQE7lBMCIuIJISojdB71d36J/Ss+1fb80yOtzZi1 bSvIKKm+j/a+Vp/dE1+qgOrFVpQ5nT1U/4s7SHvifar6vZ7UDghBkwCQxenYoQWfMHgEHsKDo0pM LQUUp8NROwb5sO9COhDFo7vYpjLRNZKVyJAdQJgwLkVMH57X8A8ikVQZbv6wIAdovBwv8TWheJCp 0l13nvJkwlU1jzFJb5uTRHu649hsYcut0UlGQihwih95Hmk5clwf2SHsZPLA0NQ7jU2KNNslkaYZ rEKxLhWHMPgN5Z9xoD8IR1U52J/pqUmJAJmkqBwjvUSdbIyKLCWuzDaa32yMjwjHM23vW06QoDAw IwIyYac7LEi7EKkjIdkUxFPtxYES3KU8WgpGA7GC2QgsSQTLHHlCApmmgG26AaFgsIRaf22TmWJ8 8WTkMP3inLlv/GzGkZXCVAihkGCxZSp3EQ0Aycc+C8wpwpsoyzJFtVdrDSzoxNmpkLZRjJkSdkit Vg6nzJqfe85kT3FDW3UN4RpK4f2NAeR5hSifnIFD7pQe0anQ1CO6WTCVCUvbkw2oMqSGpZEyohqu dBLKSdytixI2odrulzjz3UVQdQhg0IcG5gRoNqc4lct7I+O8km8x9SJTD9398/fRkbOSxvSYX7P0 /0efXnCV0H/MeS5B5qhaBJSorp5A2xoj3Q8Pm9Uilm5RJA/vhRZ5Y+rMnPJW2R06zRvDpfNmY5+f c92LI6lSj5/6v6utDQ9vMLqF21IYj1uz2+zAJ6WSqTxHL1tUuvhd6QUx5QPiKUI3Z5QtMy0xjylj iATxrAIlBTkIGg0lAaPZCWZl9ksyJI4bZCNQRBSRppRea15aRom7AZICGFWCJFWIiZHKFLj1esw2 amlNJmZMltebV3kNT5oqU1ZH8HSSJYR/zoWpLYLiHESInb6HZ8/h9HAnHQQ/R0UkqfuqY1I0jSNI lJ+yUlWylgU/aGQnbpu3/FgSlOSRKAQ/3kXw9aB0CkYQhEAYqRUCMGKmGNtsI/+101UoK2hvTAxm FqWA+7qa3O9qsw3dG0IQkKKNCWKmESCNqhhFcq4rbTstktsd9/Hctktse7hs6ckgy0jNO5vckG0T dx3LZLbHu5vcwG0d3Hctktse7juWyW2PdwcciUkpaROO6Q94YcWENmD87uk6ssB38G6lxIfw0EwU KTx19XgO7z+KTp3eabbExjHSdA71x4XiHJtEpDTTTExjGJjGMTGMYmUEfspgxsbH2Kf+LHu02222 gYMGhs7Z2ztM7bbTbabbExjGNtcZ100ZpttjbXZ2NjY2NgxgxobDBfVmDIwXWaZGD77u7+TBoTCH Gl3/723jFhCKmlP34ySEhIZrahyQS4LKUUiVOtySLJVVc3a1V2I7qmo4raSSiSGm5iCDIasf+LMq 0tTUkm6UNQqSS9DJhjGK2gLSxASMGDAUS7S0uv/1QpaZhYddLZGkujVGWaylDKEkZIRRJCQlNfFs B1sS8EJwrSTdi72N9mItLDX/YCwISechbClkIcJ6WOGwDes6Ak8IMhiUNbSNT4+NqTqndrVZTeMt yb6xgKbQdMRLVpaNXlfG97r3vVe8fc6t4LMnnXABCHQk+DOEYXARlNFw5QqTdVBDCb9zfq+5tJHJ FbqAOMiJJky1mTLbagyuKgWpakbYLGo0xsGkcIcRpUV2QTIItAiwUSKJOrULS0NEslqlpU7SSosR TmktwVBgj/IwE9gRUycK2IeKHr+9X3Il+78C6mpLZKUlMXG30UsH6vl/NfrSoP6FtJKWJIaO1yT8 6rJ2cmtW2BZ/pMjsiR/TccBd7EeH5/czz3313A/l69YiYWqST1fbY0VBk4/dPW/vcsRG0J8dRrlH rPZKS0t8pUYGWUuL6bhMowin8P4n69mxd2JBiG35NE6p+EnGhQnChgjA1gNJIkGAcR7HGopBGQVV N4SgZIhQJhDQOUcCuz9H6/1fxHycjPUkOzU+dYHzodyxIWoV6bY1TZtVty107LUVaoLZIkTRHwcP 7JfIYyuS/pU3qbWNw/vjNWxW2TEdCTX3m21y4ttTOY5EJ+lyhoh0MQ7JGrJCLRalqILRZYsoslIP 98/V3bJ8UR+sKInJFDQVJ8ipavYfesSTaQsTeUB3QQLUeq7UbQMQTMUaSYEMWmQNSf2fd8cI/ZHm RpatIltr/cNgwUstofkRKNIqPmTSH6E5OR/pdyQT5iB44SeeVMsSxYqw9VnuaS6t5NimUzf4td1Y vJqu1poEDQulkAf6IXGR8E8lQsv1+elQQkUAIEoPSWwZLDa+K4vCYEipEtN3JmhmyCF2vHGmyN+M wpjnI5xqETGFjgIA1tHKZ91VuKMbZpyGGJiwvWMihIXUmwbPaErS874iOsB3A0KG0C6pDUdQrKKG UpSCw2827uRYkB7KrvIK0pEE0EHoDVDYnFTo5pq7UEKEqQDW2lZrHnDxhiklmLLJGBapSZZkuMHC pqifno7btdlDkgotqJFEcp5cFNAtFELUhCEAhFkWR37fVskDGcYVO9N6b08gofd/bZIUxEfeH+7/ cf9X1kQa5zfLdcEc4cziXORvfE64HOHOSIOc5vYlYb2b3Ig3r/eZhjQE8Hhae/3+Ukti+0u09pam 81matiwosQol3hskE0y0pAw92a0E2OAAeMpkbHskhkTEFfAJH0TIh+g7z1+yPPmF9mJV4xRcuFbd A++KKHRKJEiglanzNP/ET6R/pqYlEzRU0iqmJRMzP+irh1PUGYdrfKdz3t8LvT670HnZ67XM1DH8 wk8/VgsbuywncUOlmR4jlSKlnED0RAkFBT5GCDS/4jCoQWQUjEUIxr/chtzTNFWrcrXNKW1q39qA KOoRFATXtE4B+dMZynpU236KmWAM/SHr/G4f0d0DiHEwXasDBZBqEOyhRwMVwQMmVKLaRaiswRAp I7KjffZI0SkUqRiVifGbSqsCaT9Pmky2ZEClaeSHI12EMMB+OSVSJ55FBwWCarayRlhJlJkMte3d qMao0pb+PZq1daWs36FFjBpTjqRlFnBPktW0D9egwiMIG8PncGYkCIryVpMqH0swBzQ4HQAfEZB2 De6QeTyEiInMt8ithgwdG8B0EX+D78zknT9jE13lqURW/jU6Sy0epdHJgmGngZHXeh80bIiyKd8U D9npV6D2Gw6RyLKV3ZZNqj9h6DHCHE9f/30GYNphdomA9RlRgZQNX9AoHcPcL1kWdpVdFpqLgIgN Hf68F4SQBkGiIRRqIUlQfIJqMSzn8v26qSt27GkCQvPIjJY6LBj8K4VS0c/HEGlSb51uhCVYQ1En ch2wWSQosqLFkOh+mWQlsHOokFj1L3RBfJFkUoeJBIwCgXtF+Q+FVYXdUV7ki/YGH5q+jeUGuMfJ oZhGSyBLurolBS0lpZ7D5ParDhr5P8/1v7p69Wnqxh5iyB6g3VNJoh3d7Us7U98cLmalCZJxAnql QVpLSz1PZ6VfL5Gen17Q9d3nUstShWqVBWktLPU8tvsmngIeeTu4pxywpn6TQDw0BDaNENlsJiId rQ6HNl0XRSEi0S6HIf9XSnJLxEjQmxEIc20yZcjUcwuFGc5IiDyA0APN3ev2ltiSJE9NIWQAAGvJ kpzk0SAxV0Yhh8KWQWRFW3xmRfXhwFp/0SJQiI+SCgibLk1UDYU5cYwQIkZEKYkvnd0YbS9vW3k0 1W/Xv4r17ISMUYAwF6IKnmj/PE9R6hUP/dIilCj74KrIID8xfIBO4OzbtVA7hYRIidSDYdREs6an /HuOHe71oe8PlkkgqrKLNp2RoWSFFtties/+CkPMh+KKR7LJJ6UWIyoiaVKsEiLGDINqxRqCiO8X pPpnDqskB0pPv1qLFKVqxsplJilZFYyWGAoglkBgpRmpDSFYFZVpYuy6wWLLx151sVlNrzPz/JoJ KpQuKZ0QEzpgUzHGfeCvtHTtVdsquyyk/V2vMzMzVTNWWTUQskE+YyIfQfh20pNjYwkyxHAFMGMG MQzxlDbBwT5ZSMWIxYMCalMIVRAUVTDAsIjZS0y2vwIKBdgsCGDiOMQUIYKFikMNJkmFRSlw/je4 95JCYTIYH+ViRouphcLYqRZks9NwIlpSCkaIsRgICUvjeqPsEkBh7Dz4dAOGiL6EgRJE9MGkIQgJ aegZ7xWGMJkJTaU7i7U/XA+p8SUBhXWSvx/rFjJNUqWpcMf8JkgdDz7SI8HbsefSqJYk8mGXsYkg ZNjWKZM00q8VltqNtWaq9m2tJ22SYWSktkN4sm5jGoULVYYaUoRkE1iKWdexiG2WSv5obJjS3RL3 DDUSJ1fwXjaVcKSUUi31nWcWGVysJ3FiOmH1aiarjjgvzZpyhh4fMLBIIMDQUnovnEqJPYy30LjM JJfu1sKQmMaOglXrKNCgWokLzAB7dhwSFgbcLTUbticZgJq2Ns1slMFU1irNq1y0fgxR4qK7EUA8 RCRBVXcjFR3jygDICsiKwIBGVsaLSCVSQm1MhNCqttgiwslTOxHWyXfN5XU22UgmLgG7UODm1jgh 8kLSOaAoUwQ2NFKTFpi4Rc5MuG4JgxsJksuk1OQfGmTZNhKiIbGqV+LuBctxKDdRk5wslkXJHali y0tihRSJ5/Tv4R4QOsEhP09nlPWQj2TQhziwnqs+Ef2l/B3T7qJrMLmkf4KhskpD9//pqT6vvfv+ ie4zn409XjkH74vjiH7ZggpINhBSlUWJBAppdVU6ZYeYD1Q/oHD/ckA9c+n6fyeuc/mG1lLKiHzf PjbxYh8lR/AXVILB+8xSGcYxTKWYGfGjMwbHZmmiENA2tFsJGASCPznS9XEV/gfIn0VT6aP/NxtX tVsKK/9JhShEsiaiYipSH10ST9hKf7Sy8mSM5eWkyRYlgWuKD1rlaRTMUjCJAUHewervr7xH+s40 /7jwUF1tWglhmZMkjtM1HYgvJBmQ4EDJIcwCP7P0/b0Ofh/KP7/3/5wm0w/SuWIUb5SZn102Vfzo rfW+drUV/1k7J3qt1mi1EQWhj8XuQsxkZPCmkM+VSiLAdcLUBiKSAgpDBQBe+wTnz+UPF71hD44o HAliuqjGzDYWMTB+k/nNpr+pvPp+qqpkiN4xgMXzp7Fo30uwVzPq6xNzAPJA9XaFFTdCbRHdxV0v lu+DFfPAQt4MhCQmEwC/lcDBBBWQI11hfq9XxdHxbbBqKh3nspBfIw8cFKgI9HJthGEbFP50hH86 fSh8IugIb+ASAViQoAMCMtGWb9tSXXQzUJPCsvF4s/yqvb36lUsSVoNqlmzlcVG7kkkOfsoMOCn8 /VWkwRnVXBN/HcugMIgw7hCyIIh/2SRIgsiKKN/X7qS/Gq0G5bKVZqWnXbFtcpNO6ddQy2Nrdpqm zQYqSqJDJKSJsSc4whOY2RMhX4+TkkRtJakthSPRHnhT2rBFQ2B91KApeo9qeADxERW+yQZ76K/v oaJIyReRvESlP/1LFGBwUAX4oFJARVNCpBjB+0J/kbikwkXxyyKZImP7uMH2nKTOVtF3x8BUkeu+ iSdkRJGpYWSgHciKQVCWPY/D4PxfgHusqLZiKUwZ+SKwqVaUu9E2qKgoUsaSUPNPPHYnS++GPhn+ Lvi2LKNxJ3gWiBOg6Q4Qj/aUv20fwtwBBhMhOXo9qQsRkTMfNFZETSEMObCku9Fps9uKi780fucH vIX+Mv4PqHB8Uj69J1kjC5gkbuASrxRjAokihgR3RUY0owAp88oknjBZEH1YDzPtU/DKRZSfPFXr XI00kJIM6cWlkSYHy+UWxXM6WRwUh0WFW4ZMdORqc5ZIsqWLcFlULDQKFXMGRW5rmjcAUmEtQGSi tmG3EAuLC4lG+IQW1/0dCcaG5GkqpwUvikHpshHoqEQJFDGEISG8NZa78H6PqDB0aomZBbKYtk04 gYMEchxSHUxs1NArpjvmWLulHqDs2TCBNkymzg1Li9kW9HFEIA0kVeJHcGBa2DYILolmGkhTW7dG Mg2zTgmZjfnQCvSTX+WvM4AmMgIYs8UHDj8YivT8dpG8EsbCmZ5YRSpyIiF+sNCGgsEmwm7cOx/z OFMZBvTc4UA23Yt1OJ0O8xgy7tKrTfuTC/Gr1kpYezbZ17GhqSLzA46Jblj0GkiSg3h+ziUPzO7r IYJDgG4OG4DMGbaW9sa0CK+oOkxqEWl7YSNpYXbvCmhLDu7FnMyah0lfVAkU4afq/D1eLGVuhiPb X6PfEAU6qMfV7pFO93str90paSfyqOrebqcZGd2i7LgtvaJ2txLS1eSFkG5DQxOCT0yXzQHosRz0 nNgyScejZsuTKVMzDKXhcApOfamFMCjmIisWAlRGmVIKQCRYDIRBNNeFzPuz8U10isQCDum4INOy QoLktKqFJdB5Q9Oo/tcG0QnP3528vSfQrpk1yXdohM1pNZbIlUkdsUOicumTbku7I2JmqNoWpUWb RMdXCHROXTJtyXdkWU1RtC1KizaJjtch9e1pplXVxZWybEieCgqRLJKLCDaSFQJ5yWUsqUiSwqEU DJkSlUBqCosiiARVixkKiSyKJLIGQqSSbAKkLlSKgBkGCZUYIgYVEyJAiFCtKxDAhEyhFShEgqLy EqQjiIpNRFCG5YcJJTJBiJQwVgMXQIoiDFi0hGgGDaMEVF0VcoCZSwEXAC6c5T38UISHBxDbBTAt gniTwIKDICxHeeRhB8vyz5AVdz6OXJCCKQv/fB3/I0p5QyqaChaApsQeAxDV/AJxglwIgvzEF0iF QDYf+4/NTwkSHjaPSTQXq4PEu43+fBtAh9SkS5geBZoGzaYCwrSlJELjm4VQRxVUVhSC4E/F69Ms Ayonph6DjYeIJwGJvU4k1CgUA4P5ab1CktgVsD1GyhoFsPA5WGUsMMH/AILaZayZqaTBhy1JDLdJ Zd6xJNP7Akh+fDPP78Bngc2gcREtD1fZiwTdGDQttSoFodYSJIsASt8oCyJmyQcH+WmMKZSJIhEi PGtEhjqcjdCOaNsI8Y9Z5lMou7q27PP3NKayltjaZUpiwy9G4Zb+P/ah8Tf4wOU1C6YhDuGQHaDX g8dMkpuqbLG+sT/uZ/rpqPtD9+dtvU01paKypPF3GaxTKCrCIlcJgVYezx0QEC9OmkH8p08NZdLH 2PtEbSz4xqSGDQo/F/4Gh+f554+4ekfyrakMS1JiZgyJlCyXifF/Z7Uj5OPmfPfqzPuTFronxxSl TJ6Pv6vtu9/eidwcs5qqCVSyqWMEqBCighbJJMzIGZVZItykyjCz7xPfKlvIXLDVaSr6EYbS5E0j Skx4mESThLTJJs6waDZB06Q05dKI2DS2WZiZkTElGR8PZ/F+Tu/I4d0kNzujAbbAGkGO8wWJxU/3 +wZzCMe7ZxxzhuOVlqqJUSxM87fHWdVU57arbI2UuNcy5tGpYydecFVFCKhqrKVSHw8fLdwPiD3e 7/m+X2I+1J0oPSutZ5oqaNF79SLtK2i5TA21FjJC9EJ16kCnQSFN0AMIcXixKK1aUwCuqzMYgXkr swmJ+pyOVUAtIPR8kE7iDuB4rSxSPIgEqvrgh64FxBwwuwKiELIgcR/NS8LVTaIpdC2OaL8mskK+ axmsqsdNJEYm1llkklKaaBJs2Fstm1ZtWaaSSSSAZgSSEkmZISEhJmSZmZJJJJISaaBJJIBppppm SZmmkkkkkmmgSBJJZZJJJJJJJID8vnm+vXx1tt8l/RP8L4airNqU8tcQhI5PHtx9P+YyWPtKDpFE QGGVPuaExHGx/PQeOAz4nkWfEcwzBFsEegqk8UcCh9NOYO1JgJszi9BkAesiWXFgJQLQqDCBm12m zbxKddtt5leZeXWS3ItSIskjWGTaVgm1RBMpVBLC2skZS0yVJkRkdhY5ytND1FoYcBQiY6IT+aKF Pj9tJ3p41aQ8k5iSyeEPZOLD0M1g3zF9TFUCSMUYjSyySQkJa1fHavU/datqMUEKIiCp4b+QdY/g HyHp/XEU4s3p1z7yPhsNSiktskX3lid5DZ41NEg2tIxNBDREATIGiaJajCKbL9QWHkUd/ltB/MHa BT7I9n3ipKR2IJ+qwdxSeKqpFtNsiNHU9yT6/ftlOukZSVATYSDXjA+8DCqmAigyoltIeCNtCGEs lKlRRKiyhSRuVslSpoZIGR8iKkYXzKqqskLCyBDpCQn8oWQEgJjCVV38p/NnMkkVAXVBIhCE2hQB BXuOkSlTs6gfHmwLVCJMCvb/6lEzEyGpNNjfQm26tLllqloihH0SokNOlVYtSy57iM7E/afA9jtB rDcfJQWv08Up94sAwBSVURgs4d5zTdKI1ApjIVGRUwveKQR0uindXfZHE2lV0NDFFk1Mzh6ooOj1 N/6a7LE9dnSwn90noOx5ybCJ+BBZGqD9KnhZEnNFI86kSkhYlRQO6pkSQskQ5ooKioiNqnJPbi2Y SklLSzepyoxBKJCpopTApSTBIsMtq1akRSiQxMKZIUsTUxNGklKMqbosxYwcMHjLtsYZapbMIFED TRT4lLaDJVDKiOm26rXRgSI/0QOoG+8olijpUbRlpck4pZQGMQB+r2FKZMiSuiI8AIj2ojsQWJli YSkyaWDxo8/t7/abSRjFpfllkUJ0QANyfO0jSusB9zbzI9P1h3cm9nN3X4o6hPZFSR1eT24aEJ9e a19VQMNRV8P+VyJNWIdkyb6r5syke+kNAkBA8EkrxXKIg4MkLcJGZw1u/yU5V0+jBwPGJ4hTT+/q R82qaxk+6DtTQINwCUNJCFAhEtS6bFi2FUkSCpIuxbe21tGjVNpbRo2yrGrLWjbUrttNUpWkk01p TIwn57WCl8oaSBpClkEKStOARpgGYIZbaBYQVCCJ+alFDVRGiFHV+fDry+4id216sefnIZJECpWo EhJeU1hj/UN06++oR4gdxMVIEtSBaWR9B8xz+n6ZthrpR8SeiMP+5dGskPCdkePvJA5Q7m6fGnuS hxNAgFSaFUl2UWob0knWB0sUSQeoGswf4lgMPak80p1JSfp1XdMBJCRxVE1oDoDzhihqUq5LkuhG WgFjFG4nfaUgtk4f/JrqWVCynJviILFjuFEy3XaasS94sTeGEVKNQKF+zCGIFqjSazPAbC3FNowX OAwgRI6hClqHLhgLzY7FriOzU5TCwxbMWsSu+xhNXJjZ1155xe/0vL519d1XtElkMdLYxKULawQ+ sNBsPkPj5ndEYliQZCNANZLA0EjjCtpYJW+kwXWscxWKpFsTZKbtlAA0VkgYuiNZSs2ttttObmba R0wkMFruP5kLNDLQxY4ICEJuggMKaghFLy7D94CkLEpdEuR1wWSBG+KQG7d7ReaU0Cwy+rAG/JkL 0dLtJhLCNNwG4GQqSnRTZmSNF6ODzaHDdMlqIsqF5TdgwVHKm0i6W+HCa6bjI1LKsmUwyRlkhMio yxFpIeBZBNQglhxB40L3oNG/dYeQ9PWT0VJZRBRI3j4C8WE6geQk6E0q75i7MiyRS6U4NZxJKlWV XEIWp0BoXdGxMhhTSZSAqVVGzQ7HiDAbJhZS7FtGqwqiLIPkzjBAiMytjG41JS2rLOkY0bViwwom FuJTYXjABuCAtyZEzZIoWxJCVcYEpfKbuk0FhPmwuWjZIFxyZqnKxVSTUWRJqwpRLHEYjYZvCQiE hGYkGhsIkYmgXi0G0SFD0mwUgUGJPtQTBY304ghv5mZOX4p4/LOe76qv8vxNFzVt37uWaEOMhB1u FPP2XWNY5aaDUksFqoqop4CGNGH3yBEJxZgt7BjXLZ+p70mDXUZQWd5eFQcSKB0HCtwHRBGhqUEI kA287Q6udeNTj4/n3OmDNctwKuQxjJuwWd3Tu8InMsjiwlqDHJa59NK4zWo5SyaK9eGOLPFhiR30 mHTDlxoY3hkPVxI4cQdnTnsSo3YmFlUsFXuhoSRX3UfQxyEDQg8BGEQjADdQBtJLLL2cKAdHj9u4 fJ+zZ6Vn5/6Zwh+iq+fdRQhBDiHAD/np1un88JAP/dqtdXVVgCXN+Vm5cdlmTusEra6nWy6WsfQ6 FNYE8sn0RrpvrOUiOfvNaCPNA0Se/V9wDB1lFewus+sRrfBvNNJSUBkpaIjYMIl0Nb7M5N3rrzZ1 7a1znv82MmmM7un28nV2N7dfFDAOFinGmg2CirVolVSgolwIwnQfu/bDWfgnmg/se++Cd6oa0eWY 8oYTZXUKqUsUrlUQWUraxCQsaSIsEYhAAFoY1pdbpymuppURbGmlbICiUoRReKKQVGlYEROAgUoH EyOE3xBDCkWxCKglAhGyrVep7941cMb5+38Dlb3f0ZplqIhGAb1O0+0PkQ+Zfp+JLafvrGtB8j3t fgcylPHU+ZIZq0OHHT7JgPq46Fj+iA1rpZnFP6U+oV9I+mSEiLAh21R1q7j1qQPvwvy+n5vd9PAW fT81ge0+n6j4CqKWA+wQ9kYQoIhUT3cvp9eTP193PXA8vECfO8MCu4nERGDSWST78b1TjIxIUshF laS4soMMoEQ2jLQzCiGUAwWBElUoWSRJC7BgFG22EClktJcZGKVz6+GzaoKVC1SkIqIiAK+C+Y9c 9PpwP7CHjRPcUkJAkIg7nxp3H2+O1MrbxNu8WFRuy7RuLvoxw31E9u2nElB48m0nynLzQaLDJhmD TSsYiyKypYUUxlDDdPHlwDZxQ9nOolUitMQOso/Ys7u2hfrNAj9dHaBEwniHvD/5XEUhFOA0/S0/ qHyOHKDBs2m2KZv7SV+X7tV6q38vd9qOtKJZJInpGKsi3l4zG0KXxPL/HDXrbhEVAp2EL7O3uS/v FdD/4tDyglh0CSJIyWD3j+D6Qb2EWEW21KltJCEAD5Wv5/n92+in1aXVt1ZSPfGIvYW6hlT9D8T3 6fnvLsiEMssZMkKme8wDI1N4s0nYlBtdJ1+7L7Psj8TXWYxRJJPev0fZ+rK6/eyNCyMlFKhqNSvS rNtpIyFJLUFW2QwoJNbdGT3Ok3IakT4YBNCLRAilCq6C7hOQUoPcIIEwTUjM8m3yvSWA8QmXVRpW kNpGvEy8WWmWjsqDVP+X65qPqVPR1fW766qDVPzqajokD0Fhf9ha0MViqvSUAdgLBOIrsJzXiK7t s2nR30FGECAUmAiRlxLZ2pUuvHQVHVEmgWuzswf9R39RHq9gwm7Gko48OWjY+WU84LRXBr3H7BcH vdgJ9aiBBVCQySkmYZLwUFa9o69ePXVQaXn1ETKDdSQawM78MIam0yJppnf2dDsJ1IUgFxZE3bjN FCVRs25iSaW8GdBwEHmdgmk9N1I4ejZh5Ojs7m7RzV2PBpps2eE7ehT4bfTk89OiojmpaTnplaxW mm0qlVsNrHpplNXpNYjMFTtgHn82zO5lW23fcrCQUbNEEiShFWQvSfr4zCTTfi53CAahtzIkTwPE aNyRtFSIreYQ3O03mHnNkk9LlN1kUqou8ftyDkTx8tdR3oQGOlSRod3EMDbGMTDw49Pbr0646+d3 mddVd93G5FkV6eAcuY4QyPGuO/hty4cccjZ8lajzySBwgs0cLMNlEBoRs4QQSSdM7eATLwCGYHZy jtRafro8HK8OeNP430d0xZDk7k7qHY6hw3JJJL47uXHN5km+94wcoKnSqRVdw4AaWb2KqalBtEDE R8kBogK5WEfV2qV+tMFHevlsLDu6RMGYV02NjKXv9VO8mTF9BJskXqGqbJ88F3H04QPbx9X92LA/ mApDuIDFHp8j2mIyJkYTXu74s2P2J7/S80sPQpQxCMPTxpUDsRItN4HtIAWgZB8zGKU+uoewn0lP 5Cnmgce+ZJ5z5yH0BTeWiYQMIYRNKUkvpUF1CCQTfzX9w020DregE2VMTrSlKGEirqUDRBp1rQs3 VkklqI1FIsUWMjc8wIGTKK9TmMoHxdZ7WveLxCcPuNkeMW5ar9uag881ytokaklK2UCRiPrlIP8s fpiGYtQROj1BK4A15iO3dmzhin9oYV9sE80BF3xV/WQXuIJ+5yHosUOmAb4h+84g4hcYsFkJAWcg uAQa7ItxMLIIxihDrZQRYJeeB5TILR+qsk4qnF94aOCBPNBkN/nT0h2bgP7E+1dQbanyINg/YK3E +zzgXcivs8VjFj5cI21XCtRpd+DWzaLYs0wXYkIiyMgJIBxWrRSyMiYhZnFqkIKAF1UgKA0hBR2o RpLyiGypm0yQxUCrJkDxPxfjIpND3RQV9D48T0fLvp7NsnXlEWC/BwfNxE2gHwDtDrbf+OsYgHBb RA8guwfmCG47yhhSliPsOSPQetD1PiPxVA80+/QKYRMsQcff6SwNnLWzGuxoRMMJEWx+wiaQujFi mEnoCObT1JgMHHTW7/pMWbRBojXi5XxcA6mJQm5gbo67Lpj8MhndpMKYQqBe1I2RdDNIl/dVEcNY 5buw0oZmQQiS8oOBQXksGW22t8z7OAfwLZo1CHOLtwKDhCQDLCQZZSYDtyxBSYkwxyGbtRfTPHWu cD4rgJgJImiXsFaF1MG5peMTkxN5lSDFQ3QGSRQhwpqINxVWyIXBIbBSYKgu2HFZUjVjCsWMrLJa hTuIiTP88kKUYjv1kMAhoth/8x24xHpecao+c6m1eIcYmnMpo2SpSDmwKU35sBIYekLOvFaBUaIS EeEcjY1rkKAhdUdfDr04668tuOkyRgyBBkj3BxS6tROwymodBAiBUGEMiKxyvPGs3a8eJqlhBTLJ eO1JpOKilkypiynTBvVixzSyEpLEZmIg4SbyyShgYcpJKGtsBJKwiSAy2EwbSBO+wUUtjnqNJ2A4 pHGHKmgjWM4WDgmKM3/etqJDQHUaD5tO7ahMRnGZuxhyp28to5TYa8Bo5ioyySNSWJbbbCpZByoy NMbldxgzcSwVBphF9moPBtp7Bxn87bkLbm++gcppM7OowNjaF8ePLgDpvoEuCmykBcgahMA7QWgT y4C5nBtMUzHRK/6TRLBXTjmppTyN9E0uXhHf1V53YdPO6PB127ibQ8O2ZwlIywaUmVN4V2bTGnRk oULaOCbqdYY6LDRDAUNJkLG9k3kS3I5AicRcBjAhDSGSzDQ4nAddz1EUaRyjDPUaOTn0HVJ2TsSb yUsQxw1LLDkGl2RZA0FidUvntbfIFjqjESHQGY0gPsRZLIKYqBmCG8MUEWPLMjJGscY69BJPNrI0 zkzNPpmF3v7KCWw8MP3hHgYW9245xu2IaA75TnL6ZBKY6Jtw3FuOGbxN4DvNu+BYSw5BopyYkTZa /6ljjUpkF31mjKkVJY1udlqdhmj541X5Qdyz+3nYaAx7NL1315ewnwO4xTHu+BM6FA/QO86p/DSM SHSBMO3tSa9SzVOG3iczCmClKiZJY5Smi+jlByA59fIBwOpJwtOPByIcTdSnQ74NVAtymwnPCDwU iK0GE6kh04WZ48OGnHpxu3TLahRGi+HF6WcgzCZDMTik1NwUb9QpgdBWqQ3nLZLCx6K4mHY0DjkT hBKigKAd00tY7e5JXwloA6Ys7DsCcOmKHkB1NNARCnmUdCdHQYTeu+4O/IpSGE4RecjVJwTLv0NS hOJwMHLCRDuA3ccDCPNEDKPIeYY68a4GhoPYPAdeNm0MbNMFJYlc3t4bE0pckSHA1Si6riQ2Ma7s KwOF0QDW7eij0IXuNRDe2houPWyj38sy17d6YzkMw4wG6cLFVOR5PLdHHIEFMenbEkuUBEoThgTm Xygr0Ti9jfTsnHoyakbZMS0LK5LNh6ZiwXuHuODQgOIBxP1DSe5ShkCCUdN8JoR8XFFt1LDjRBtG eCRCIijwGQA0PnhwkIcJ+PZwjyzDtrs6imYrQSHt6sD0ICqbGGpyq8cSPAOQwuNDer7uWOBdSiY3 Gid9Z6nBj4YyHaA9pr2QwYhigVzKDTTYDuBoEHUyx0EszIOJlW0uAFpFN8NNLTbCuIkHAUpQNIIC g2xKXYimOEs1gdMUIhzu/djhtjljE7cMNRBxDHGKZHpma5HcgZoa/wKMBumryLXuy4d3J1d/RkUm g7PPeVLClyeZjvu1jeNNQ7OsktFlCrJnidp4bbOcOqY8i0sjAcMWm0WI8YsrIAXXoyGDIBVjnhEM GCY8IYofeUuQSmOIPAS/jga9pDfSwI1Bmhlxwz3DsgAOEHphy247UTjmEA3sXbFIlqWUx5ByLd7M EA1SmjZpoYB2YdesMhYcHfwx0CQ6NTVLUbCK8A1KdQ3VElEkZAa0xllVLUHTFsHgW8bJDwBoBjyb DgWHFMhxCIWxipNyQOJvTfZlB0OVbaFLjdRy5QvhwE0rtLDYIhsJE4JQ8nkD8DiZuumHDH3djCHT OVh6Ysk926IO158cZj0vDdIbwR16HCWJcNwV3wi7E43lnYtImOQTOiPbBYw3l7wyu+AcmJBOMCb7 CSJ0pRpjjY5TESi4CFJaUbSPYxqaCQ+RGhvfDBldN1oPambJdh2YzrzEBuXO51JRzi8AM7sjSXWr u0tygzGE06jozN1oliAdokJ4MBEQw4kBuiSSgjyx1TGbZN4Y1tpeNN1IPLC4HLY+XA4YMxPoBkNg wkFBuwIQSxIXDHbSp1DEgijvKqmPI7103YIOmUR5roO7Z93bSSg8a78g1jpHXrAxaLzDRSiQNylI awgo8LGREoZBDQ2SjonVOcxCidCmrjENeJucgdJB5pbWeYaiXBzRQSO4hs1aQzDj9WYdaePJeSE+ fDDBHqh/Fb5J4FiPl34aE5TUJpLGyamNbIvRHIYLX08PHifdioR5+5ntVjI76NZjcAwDRiEb9N1U AcKhjnVEMJHwosHhEIaRbZDMRQPC2glCiKCcTJE2OzM5oQhwClXgwhiyhqZmHLI6Y+wHMzRTFBAV SccxywqzQbMGSHiydxkowTWpZcklr3TgDypWQzbYcGMIdhjWdwxSNoCYyI+b+vBkeyJy4TbB2qJG nEouTG7DlLNJbyPLYOEhcc3CkI7JrQPBjtSD3MyJunIL7eiMA+bDSxZSH+x/ZXM+lTuU6ggdI8PV dU5MuNfs54qYPpftPsR/MWODdbdgZ3NzLdM3nmYcLcpxzSC4rq2xRNOPZYpthTdws3bjOm3sx4Ja fkg36YcWq23fid7sN9U0HDfhuoYHaRjBHQnBeHellqmkYk0xojalIRpWw2oc5SzfnknA48fDkNRr IwpDlYeADWhxsSk0IEHSDVh1BSu/iNLTVIXtjbEMVg1wx0mZI7ae7w8aLiQtg68yeQ3kBgc1m4aU BwVMT0BGBtzUB3kv5idar3F2xvbsIwPDi1LEM0k9SMSMSMe7DnRrNsPttFz7WY3rgOXYj9gTPN+d zgb4QmbokY1xo540x4lYz1TyVTfRFt2CAOiGbpFFgj5w7Swzu03WQLscaonMivDLgMglOebfD7vV u+y2P2Enz+77uHew/6Kb9/Fw4uHJJ8nWud+TJ+Dk2XyVy0+ppRo1GvGObadojVRr2TpwuCy27Zbt A5xuI3Gwwx78ewWJDcyZ6FTtsiGWSQqzsyFKoKHl0pRhiSBN83Yx58XWZsN4sGWsgMZDILYcj5fs KKQhlbag7HxLVi/JoT5aq3K+pDLRToEL1cBDUGI2DH4nCpzCzBxx2HYcdj15MZmOunxhpQ2/UnnF 0aWaS3bHt6driwQ0HfZtSvIxtgEyG4SLdiGbFYWFwQQOayhoEAgCvAUSDjKZJthB3728rboO9xwd Gwb05ZCnB8iYEUPsVc42UGwaoyBJ6A58FWWQnVfcAkhWxDOEESesL9rMYZkQ06yXdygejyaWf+od HQzCZYjGAhqA6549OZVJqB2oE33EbxzQ2HBJNSJsSamjrjLY2IqabJaqKMEm20UYkStsUYhK2xEW FirXBLbEwADkaEdOY1mQhEIzVJgg2pKCSNqSFVSKq21d0RjJJOriOzURz2paRB92c5TQi+iivh90 RNNsFoItBGoNrXzltvhq+QwN4qHSC4CgFW1MIaoNKI2gBEOEUTJAOALSXhyK4yCsC1RNhUC0G2QS JE9VtgJsFNbPJptOZgDlp5/T0WCcL7hD/W8SQA5vGt0QwgySSP8UFVCpJFLYKSJaJILhS1DQiIB7 C6V1CItc2AMVCJ0DOoQFJwtaUVTIEFMiJi0BcRFOQAf+mi/9eIdPjFB4i7bkQ8wwjEgnasKQjEkE IWa2qFxOP6qCxD4fq9/wzvXSlRFhFAkUAYAoRRiJPUAP0BAXe/tciHJH2bK13gwX9P3P4pOokS95 +MY8GmgH9aDoQR0zJ+Jtr0qvJu7tXu0WNoZaYpgsRjztq5tbJbVVNGgJKAtlS1mrKc4DNzhco5Du uakznAigA2KIpYAPKed548cNMNAPXnnlbbrWVXMaNY0VYAAaC0o7uRo0aUHo3blFNCisGANEwoot paq8bd/nduUmxt7/Bv4rv13ZtVSnPjLdc8yqFGoCNMHTD6nhJY2AHwMJiS+e2F9O9vsJxt6F2JUB gBpMVFUKlIqiWI4aMVTek0rakk/P/Njd0c+tb7zeQ2SKkIGv7oDwJHOrlqmm0aFP2Kj/2bQc0Wd1 J18Yw1UlVH9LpiTpZ3O+a5Rga4Rvqv8cdzpykR0TGBOLIi9JJ/R4+W2wpqr09wfKpE9Q+VBJ8IgK AGFVtR85PjEhujrE/OfR6I/HbQpEpiI4YBZbSfKaYMmMFtFxLWGYRo4sjSof90fjMgNG3MMs5mCY 1MYcF7bxdIBrm8RF3LFAbRAdQI0aEUPaCAY2jfIovOEhVsce2zBZg9qn2C5DUy/g2AaxLCBiPzVT cSsBlIxEKUk8YeAahEbZJGb78aADSEVYAxRhmnenHXhec1i9ty8Q1bMXjqjhy07I/PtNp1wzM7SL GHYczaJd/HzYfiTFMXJODE9Mt/xdgmn+Tbc/rQkcLLSYqMOjOTd3mFR3jZq/7Ddk5V3+Hj3ZOvRx JTe7RrDnh4HmLI28RtOwbc+ZSY11Eux0GJHgJgd4VwAviiuAqQUom8UcFO6kOyp1K23jANhggB2E 4S+MpaEU2BDUsm9mmdMAlJCws60hoYgceqgomm84vs1TOx1NLq8aBiZtLS0ujaCGgacAsvXdtFrF GyYPJ3ejngg0+oQuk/EQYIUleHSgkJkK3ZnB+6IL0XKLY8f9bDwHyG8lmbGCB7aEbH6m6kmGgIcY dDLxTB2mCQrhvo1q6zbZwWQW7MMqintekkjeK7NdBoK7u0t4K8cbg25A6BvKAh0c+IyCBWpXBjTE MzdtYybbblj3DmZpb9mfksach/H9H2115OrbcbHAM0EwYxaQUkJAhHep08scsmgm0oSgMpSgi6qw IqwGqWSKLJS0pIPFI2TaERZKCyOR0ko1IDhI2/HpI8Q2dUKEIevf0W1X8we/VCG48SrbbaUFPmiY Snoil1bWtsREpbVbb7DZD4XI25YSql3xbCon8t7z1mJ+i1BfIrqJGJEpaogkqTnHdDt+7nYKvYKB +mDqxOuCApFGJIrVUJk34kPiTlF9dq2ej1/7aTlwke8kJ0EmVBIQX4uP7qsHD+haAUP/ER8gfU/v 0ACzzHyFJoGB5itLssEBkQJFjJBFEsQEOoGRUIhSqodQ12LEkiD1KUGBDPzwt3QTnaDQLR9Jgn5v kqwhK1kYVjweJYMgDlA2QoEtyZbmRsLkXgO/2/tfSpy78BveZUNxuZGMe4CgpEjAQE7xOX39e7Zy bROHjDX9AYBMRhEhGEizoHzYl4jkk1vRauDf6kLgsyCYFMSRJCn3gUqUckMfc/nh+AlGaCNQIUSs qJsK8/I91KfUMFaWLcqItjckj0nZEaRJ+1Uj5zqhY/tKsEPwehEYxQ5kZ0BowtpAoiiyCUVErSTV P67Bkwuyo/Yf7OEkkdYIuYiMHV0dz/k5ihEGKZAzEywege1O3r657JWQLyzAwnUp6aaCDUoJIqxF +WxpqGSwp7XTDWxmLIqLjM5zdHOTDc4ait9vkfoHB8+yIzLEcDUN6WWqTognw98Fo4NVO0uYVMVL R1bJ9kf8Z9k2kiJxH0yYFeiAq9UERuKlMBRQqFMDfCwCusugi6YG0obBKwTJaxST03Y6FJvVsccG NSPPLuTSWLCUpsKQp6ZMQ3SS4tgHWW/axnHiAvrGihVGgWmrkWEZBn46KW3QY6TQylsb4mnIZtGE yMNDA2kSiaVBHoD5Z1D/VFX57J+oD9cXy+fNWlMSMHEoP2KAwxRKNlOGGLIGqcFB5xd5lSsYMYuy 7iWRMz4rE0iWMR715xSeRUxYleJ4JE3nwk8nnMjl9/ENI0mEVLEOkNi7Ikvn5DUguXxLjq6yPs6N yQ9jYyUZklX+X7dt9omHq6G85mNyeqUCL8SA5fY+DvQwCuR/8QQPfJFNqp2Mf4yfqkS2qtLVixPZ BwkR/N6p+SA6ROaey+QsfXDzvOGqgK0Du04m2ROOQyt61pYlGjwSOo35LcETVDA4TCGbNYo6Bcoa GAbWUGYGRhGsdMgZjV5Awh9CkNBRNtqmVoSyhECD0UFAkf5FBbDdEKK3NZEzVYi1ggH7gPQHPsVE 6RTvvYZhGFSY5km3EAbIEmwFJ7dRdDqVh9avAcJfzREE+C2kGyQtPt/BhiwC6sJrwXuTQtsbKzyB sVJJK2hI2aJ3FSYsYEB/MiQAHAZwlioLoQGqYyNSkDIkeqJ8ttQNTZxIUyCqSc3TznKz7KarVPna 9HZrOpvdNt8JwKZqbTGyGyPLnqaSUciYlJUczCZOZp/DJOQNc14RheOOMNve457HIwQd8KdIJRW1 OiQbGgKSxNF0jppSzfWyQQcooe+XO2YsgYxgBMhkmHeGsC8VvlOXUy4DTMXe6Do5aXSqdFu6Xtk4 NE5bzcpdS9Z0aNCmzkxMaTCVslWI6tO5V34cRiBlyrmbysgam9Ias0TW9G1NAu7ULMGaQzIb6G4C eQocfR4hiyCMU+Wb6cB60hwfQQcBem5NLZ2GuhY4Nai2FDBAiWHDV26ygR9FD11vE0OJGQQtQiBf EIwSgQzHWY1SHILQNHAYS9QubZEew6bKYoMt2Nv0btihh6YdjjGtEMNwbfXQ6uOGtpGJZznC72Np 84IbhGRjATOA21AdBICFo0FIxKYkR0YlJOGlDYOQgkSIrQL2RKBLgaZrVmbQ0tMWVFAW01LRtFlN aWySSbNLIgQYxGMQE0YKC2iEFQIrFQe5eTMcqEIEVZEiVLRTOwA7yCyMiLIRGIhXIlCcETt7FNxs OidT3eG/muWR1dmJD4HPJrIrEYUiY8WSScFY7zHsYHikeUSbDvjzgLuiKkIeMRgqkBGCWqqeJdB9 hif3rII6BJ+Hnq25cqxydec6pWGDEH8WGfilEebLYePYD7e6B+nvLoSBKShgjgRf5UkgsgoqUhFE XZRO0ir4FtBPBGl9MWERkgskCmjaK1KUl+HW3rVv66plYmaFfPxlcpcHoqgBLY8LKUJEAIthUsjd piIe6m2/yRxjRtF3xaiMsS7l0jy5BjTYresdJIEEc6FBdtvTcNaNNBmi0q9G+hTeFgkMOmlUaRgZ MdjVMx4HRy7eY7/CvB0ehi+2EzH3pxMIfx7VLGHY4Bia4dhGthWgutQxfhiZ8XHAd+btDsTMcue5 YxUNpmKITefZgbfCuOCd227t3EaR6MKM7jQdex2/pcYdGjmN5kBwwlZEEuKb8haR47WG4IPRBzHi 7grOExHUhHQIs4dMeIG6Cm/zAmC0cYpCBQ4vLR48d9t6ksIvtmEHAoIsPMdU47DpDMVxP4ZGYWHw hpYNBMDfEj8BwSYc7O1p5hsUlUvhMRg0kuI1LlvGu/njJHh0ZmAN82N3BTqomqbrqDowvpYNKfDn OuymwGTUsTD7hyj1TdsJnpw9m4CxoTjTpZtbQHJNavTqxfDKa4TZtW89WdU40Ri2LTFsSx3DEMZ4 JYnGJNt5A3QcvpjjgCMhGEknJdGgM4x1Ve7IHmwDyAIqWUnPjtirK2N9aKgkQuOvKxLKLMsq9mYy 0mUmi2gWCaIgGBG1QTO8+p67f0SFo/AmNGU+1qJpJ+amJYsGESYUaUjhhmiESoCfNAtdGDgyfo5H +o5MiKKWNyyJkRziVAgMPsC21EuEgY2bxUP6RsWQegfBBOsVKCIwPOq0q9SBlflLE7u0K7dJgND9 I4lJqIMGRPb1NLKzgiTQlChWkwgIAPEEAeek/UVBPhkAm8pEhN9oyHYpP4jMNX+pUjYojZKIk2qS QT7qhH0FgAo7RzDWKKHA+dXnuQ0DU0PVRTRF80VI3hSRUSSPidHkcHyHyWJxY3mVG0lfe827yolt glmv89X352h9l5YzAOQAy04EaCkZsuS0alFgb7FbzUN/KZ2xSnJkOSRnU1AMqJVidk/aTWlg7YjE HnO+TzBsSckkftjolE/tdOyTkgs+tzPyw23hxfOig0C/9RgxIsIyEgK2BuIG6qIQ3UoeRXC9zBjG 1M9yzv5WXSRDlD3GiImuRV92HehCf05CPwx2+5PqRD20lDUbT3YKIsWxJCYKtRY+pGwMbSJLYkWi SVX8U0r77Gya06SQDbairu9kEXZUcHJ1yH3BiiEMO4IjEKH86ezA9AYRd5zV3ES/k+49YthCpIna +xxoiYB7wZxyUCBUWRA4kahyCQDJFpccjtvAgZM5hdZCEFcJLNgtO1IxIwKWd1B3pdyXVVVfgoZ2 pXM/A9/u5vrV1tKtcVq8tWC6uXTqkQuf316Jp+krlLmn9f603iGFXeKsQemAUqruSKpUQ1SFRfof qtR3h4DAi0sCySc+1jBAzJzP7WRVNStYyT5zfG38HpJZhRCKoSQj7p2wdwdD+4jwcIHlTxi+SfnY KUwJETQDk74zuDYeqJ1gEVDqgyeU118uAq6ZEfsdzEkdlsBwD7d5PsxEMQacSO7q6Zwp5iLqIinE iueV5LTuvogSUhE9Q9eFO4G4ybVrTNVrTcf47EdCe89JOEqUseosE2Rmg0B0UGs6hTAiLERnnn9t UDSWI99swwlRYWy2JqsoRcYFaRaUCCVSpFWMsZYyDYJUgj0WSE0kM1iQtlpVsLIUUlkpSFyIWMkn O0hWFh+WGjBYGoSattISiawariS5ITFJN62lbtXqNKNSlLTYLtbgjy2Go0lJQKWFhoVuHbf2Q7TG BXQlOBq/hSNh7REj08EHCr2gPlIwYH3pZhYLB8ycxJaWnakdEwFL1XcjwliES+Ju+lE/Ij4fp219 TGD7g+wZrwVo2FIkKCFJSklMMIYbNGgwUYbPVon2x+DGF9PEakR/wzBtTDoZI4bYROVOSvKRXvg4 KsshM6kmIaRWGH4FGwKrZNeaTSaig2bYQwam0tp5IDplBP5YuxNYiGd/5GPjuukI66Bv2Ch6ZWqG nQUVlOmBhvHPQspCLUYyJUJCQO3b4adsreNEymp9nx9/bWVJwmjYRWKxAaWoEiXEE1YF5CgMBNcI 0t0lpaOUCXSG9IwioEIKIYEiOuoaBapNEHHXlTgLc3kk9SgwWRpwYxox1KMnsY5c3AbtiOxtCMIO Ck4FBLqEWBAsGSINklhLUkoUSfU+UQo3TsGV0mGBNSlzLjGC3QqINwRsUlAYWEiSlQULYNGCiFgl JIlBQEkZMZ0wpjIUmjBQw2VIkQxoKXm+uGzjQIyRBsKEQOqAu52A2zZvys8Bum3vSPAILAQwh2Qk w7IcN4C7h1k1NADDiw4pjDHl1o+wsMdZSWA5wA5iiyLxfqDviiVvmEgjZRZLjg6nA/dR+PS2n9fy q/qP3Jy0IRiB+zAh9H0ERBADV+54keq+mSFf8T8LNS8RYMUjxPPb6VEWOPjQKmhRLioGHjyJB7v8 e/JkIOVpjrz6s2J56KNKDyhgBpXuv16dEPZrmAHs2BsByuqjNpgEPNx95xckRZCT/YqJ6JCmiT7E TPYMn/20NjeMKpfwxYkfe7iEeju9Xr9v0c1ORZHy+vvS/V854h82ceq79ynH3cRRMCAhmSfAlDGT dOCY38L+zvltvs+d+74rZavo+15kUVHtzeJ63ngyySo7OZuTwPmeaFCUQKjFxAuJEE+GAXYyRZMW JW7WESTz/31I0eZ0KsfpRZSpSy/atqvMJN+rZ5X67u2Wk2K1ImGPTdv1q3KzZqkrVeV/hba/z0ao SRE1ClCmKLsptEoFwbat5T+oP8cC7hYqboJqRKRJCJUVqDXbaK2VU2tpVorCaWsXLirJaqSC2snQ 9Xba9O25+TlIw7ddTWYDsQbYqneioOXAeh7v0lhch5OM3Gxm7WWz92vsk+yHhPV48sEgJHQweqN8 k2SWylVGUS0sY4nPofi3rMxt81Xh0H5ku0sxcJrhuEhISNQC4no+RmsPs9Ce/tSD4zi6iolD9siw +2cSn8+ofqhVjwOUegWGYN4qVQPOSci1wTiTtBcgY5BDXjQbuaVvIcCLCB23397wyWt147w6fwnR prr4conoeUWlU8u2Nk8mIppNSMaUyHniZ2ejtnDj8txaKjKO+6thJjlWJpZDtsGCzbG9lrVjysYf h8Y0U/lNj6Kf8ld5edCfJY3qO2SQWUSI8JkdYqPKFORSaixqFN1RJ3pvPh2SlS2UQKLErNb1WVdl lNrNUjKVTMpRtmliKtb17a/D0G6bkbwT2TfY5pFlC0kpFi2Ao9ixkkqpQliRPtUUULrS1dltUs2a lWS2NrbWyKQlKRLJJUQWJSQ0M/38k6ED/TH3hYp6xdQXzO50cifmgMgpSzVL+rHyaf8r/0sbREj0 0hVQOdnpqGLJdBRDrhcEbSQnh77wVKP/+0s+PBqQiMuilxdXCCxELqmKECM8VAfBSCLlggw9wUjm CZjYQBuIroxBTh6h5CloeCKwD2gZaqvCANJBPTJ+43T2YRomlPa4HKLGNipT7wZTwLEeBAWBbuqK eoqRkMC+WB09jTy1lj9Ek+03KayTYwxKFKDkpnpz+VUJ9+yRN5EdcPSh5EWJEEE6D7ChfEpgaSrQ DCiCrbkpXCh9n+uqod00YpvRBafIRQNlwEGlh8H8T4DtRFH7X1ic0Oc8FSzd4VpNQZCKRZJCFwG7 Fpaq/JS+X+bG/r20AndhiOkVEcF4H4xuSaWLpKtl6xiPDl/B0/6ufEKcpmd/QmIi6jZpHNBrs0n2 Yup6J+RgnSyRwURyuCoSoihEiu0BRCogjtASsWShlFB6W6DGEkEiSIUQKiglLFTpiydyibXaNsDL ImqSMiyxUDtuq7TNTK0almltqmlbLF+RreyyKGGbZlls0oE0iBNFVAmaBIvUBAzF3sBd8OQwwajT bdVUNRuNEnRUTQySjzJ0FLFk2hshsZE0b6RmK2SfuNn/s3HHCGljlL+RgRLUXg6x+bUxdnF/Wakc R/MZhwVZKpyZlkwihIFT/37zeGpApTKmmi3FsJ3ESyLcQJYHwC0J3CkpOYx2BIwkFjgoV2YoneF/ HkPMj/IHIbAdhNiAd7UnHByWGM5aTwi2GCQIPCAEK1qzzQGUCHFkkjn76HyHgHhEGM3cHBOskCYS JCUscsWByK4DG9BE0CRKTWlpRik1bKyytW9aIgiuFitLAWK4I0gWBgUBLCgCCERemk34BOVq8HIb 7zAzuiT+WvlLJyqNFJ+r1296aQ2PExCZvnYmnG/mnJOhn/QOdAQYpFilwFkQ7e6gxEMQF9yFFRLD VF+aQPTSOTTQ0pt8jCzK7erV6haVvxtV+ReZquspTmpr2CvpUMBvwh4j/1PKnlgaMEcRAK7dgxuI iuYJsCDru3vEynQYiYFOEFcI0K9Rv1cf8nYFNB8REYLPziUDnFiWKFjWx3O57OsZDedYn8co0J0Q AoSlGAH9UQsOAj3x186N2LKEB5oK5EVAX7IQbAnBCAOhfPvpKGLiwQUF/p+Lo60yHuOA0H4Ibyny DSooU+WCfJAV5kfv/MX8eARMwEPDy01B7RgG5PVKhltdnkNj7/62ff7vyaxXtfMiz1zDIhMWma2k 25tc1+WXm03ZW8Ja0YsMuajJLpEqJQ66yWxQ3WA+Vejb0Z2QNg8VJZ6H0P/ezHEBDVFU6w/Yhb/O RyoPoUA8XEwfmIkNg61Q8IGwmp0B9Az7CMltjKSNJL/kC4MtKsahOkocFSvUSXES2jtWBmIH80/O kmrNRGoTEq4m5swkpeGow4SGxYkMw2NajuN5glbxLk2Cy+RJOoWwh0LCNCgUBljzCA2OmDuiAUJa WFC9gwcGZwNApWCxkhZSQtDEYwzAQtsnLIU6MaBwjBM6GU6glJOUQYGMrFhhZhZsjGFwrIsqTYqK lJMVFEpiYYswuRphhSwlJ2MHdBhTHaSotZC2SVr+DIaYohCyX2lENPDHA0Dh/gebRtrLKzkaI2E2 oVhwSzeCxbE0v95WUpZY2Ehawuy4ZWbmJHreH9acpy6cDmW7RW0fPrayhVSVdZggu0IN9RrZlVIk wgxMgjKYRUkkoBZUoIMRgckoV8FcEwg8AoHEIxMP88RkFoe5ApVcQBZgKQe3ID9Qv0BSgCRJ/TNg 2Ng2Ng2Nhuhv4t17Ovd269nU6HcUP3qUZB48x5xpjjJTq3q6kZsuKaq5IzSbQw3D+YwQ+sO1fkGR jD6Fcn5zLbkiHTNDuxCra3p5p6erkdZRrqPq+u89PovnHx3TK2S2DZxZFKhTBcy0O7pmSYdTaSnG FUzMREypmYIiEoJYooTFVVOOUxUFKSpKExVUQSJiZnEyTBbCKSa00kzUyRKhJqTSQOk0JodlsKYq ShgeouUyKmqkYHhXYhVwUOSKif5JAFVOQ2CyfHHrP9Uiif4xYhaDKmRYkkyhZRliIc0h1J3k3P95 ldXfBFh/lQSJQrZU2lNVdm1m02qZVisauzVzNNpptitNKlpZbLatJts0tV1zt0xqpZRYJliZFExZ hUixZIWKQU1KmLaNbprtNFW0staiqxrTNk2rTNbRtY2rlbXZqzNbblJzpfb2r7WKrxUxg2W3USaO sHBFCkyonvtqSRlkaixJFFK8+ONZKi04TfbbGlpmUm2NqayZKhlSxVqSRC2HYpA3HIs0ieWmqvPd tZfBybqRtybrtjO2yCOkXoIKwiKxICgsiIJIm2timbWa+5x1pRNuzXat1dtLLqzSEmz6fPK8tKKf Va6ksdCkVA0kSRiViohGggDKi+iaYKGlhpQMKwoaFqODNmTOUZtD5WRJ1Ryq2WKNpotKtpYMiEjq KuysWJBYgwVYrtbhYj9ZvIJ+GR2nMjk85vCch3TsMVo223vpW30KKybGzZrMKpWbKiUjSbSxaG2V qlRVLaskWxUVI1CEj70bCAhrjCjZQ0gqCmpEGRFjFI6UkloDSQlE6bAn0zG9uzA4jGnGcMlSLYrf Xm8fXF2jldGrgMaJQxhrdN0mifyeAcX/RvW+ls/nKQf1b1De6Hl3rEICcwchCS2EEjdKsGi/dU9N ZoDTmHJSCL4METNgrQwFTv8n6p3/JJxGZPkGR5u7calZf7GpgOhA0tyGKd7r/z5CPIEYqtxeSgFQ Iz81Du7t9m/FOzxzuF+bxFiaP0Go/rRREkFBHuPA0so3CZPrPQHJBUTRDX/FTyVvcG23zf1fx1NY E97p+aBmbopGW7v6La/ZlL26gZzPr9EStU6HWsF/rZa/KbpFutGNNCVgdfqAjO0pK/WlHkOxOi6G eBtTadgQO7M8UDwgOJ3x8Ku01KN/R+b/9ocrgI/ClLcJfAAZaQvDAVoHzgvk6flWlMJL9liveJtJ FJAVO5CHSHH5UkkD/WhKAmBcogGQsEwxVsVUHAEBehiqgBZcQPIEilo/6EkgxSSSJMilsSSBVJFi 2pbEqyQ2goNif0TzRs0mPvsp248nSeqeQrAo3qh56w08ZHikPKFlw0SEYpESBEJent1wGhVC5kSQ UzGmGSlveuplbdlur4deDXa6v5L21vXhGVis2jSknrbc0212lKCjRjJLKizNI0gsYjC01GmSLILG IwtNRpkjQZJDJExJRYpTeAtkSMkmjzazWdkBJkCTIEmLbaqtmHJtTY1UOUfC+CPDnseSfDKvgh80 Q4QEqCr0oR6IP7FAdncKHMOrohyOoTi8jn/qOq4gm4QncUc0d0f8YFzVpMav3m1dlsxUvvdXt5TT M7qZGzIxLFFHlp3P3bk+ib3hzTnHnknbiJx7Fqy3Aa01FTHVk2AbA6K7viDc73Q7b7hZBuilTcB1 danBIqHE47i2xOWi2CaVOcYwVZNjLSwSpgihiWiRRIQBiQWQSUhKR0RrlO07qSVYKT4WSBg7oxzJ JAwRjH0tegCsiOIAlsjhqS7/owH7nhWeGB8lmwyRxew2HUH38BrgYMIkjMIZoSwghQMWgbb/cbI5 lVKbVyWN9ZiJVsVLGXpvk3UgZNCimAumaS4SS/3iWU4QjrQE0DeBOjTR7oTFlnBg6HcKVhEKR04K EsxMHQwZ+Gm9hvRKETIG0RLkIskgqFx1C8/fq3kxNNKxCznQjRyJiiy9e7+6H74d5OIHkp67btfp 8Tb1TwZgsi4vqL5YPEYcecbRdt43oFKL2+fnh53crozfDrrAzAAlj4d9DxhDzvhK5vO6F1+DodCh bmE+Auwh1NALNWBPHTEBoljFth8dOh3+2HkkxLLSGMJPx1D6CkHZuDdyNk0kKWIOYVSWG60Gp0rA 8cDDHV1eouAR1aBXUQtiCdqPgnjtSxsKKVL81Ggu7ge5JN5D/Kcxy+r3DU1JZg6+6++BJ7QSkwbi XEIISIsIkDjE+N2E/P2onkCL0innOHzgcvaMUVPKAc3oDer8cD3huIyQivXscgsLul9qRDcFKYRW T7FRBvJJpR1tsJVkqxlp60GMBijCwJRSAlhJWQQjdSFJaUkjUqKwCOzQFIsQILFZqstNaMqm1isr JtpqS2aWkq1Mtptptpaa1KkpIlkks5zIsEUqxVihUW2kEKQQRPeiwULRQ0giu/R2lksDvSdZtVoo lkRuWMotRKpH/WOCaS2S2odgRUT/SecdYB4CaPgRUf3QQpooFIwUOkOxe2xIak/WfxTdA6heoyRi jIqZGidV0kPgKh3S+ypE/qsILYiTMUNws6woEzZQIdrAuAqkQWCqqTKbFjhw4nC5tG5SbUO6Ug9k qRv3iZG6K6FBstWRvR7bzOUZIyxRZHKKWWFL9ayNrqgdGIrIFIa0FEH0lU+rfynVlNQiQZGw0S6A LNEtKsdzC0JdG0HgIu1EnO6MjrM0HCchDR/OVLZJnVtvhZw3Whv+tJk14qOwmA8vnIkhU5mqj0+M 9fU+pOX4K2/wUzU7xGII+r7fufntrxt34f+3XlV9dUoapM2ShCQYgp/8euMV9n6A5BZOJQMQO0dC LOCI0V3N3oe+3KqnqyHppbTz7nrKcM/zfT6vFl/uPxglr4Wvvb8Qq0pZLM+2/TWy7wiTRPDQyEzQ L6/SHqCY3RND4h+KxaWQiiLYlKkv09Mh8ezN2MLRbJbNRsaaFj5rsKa77DKlcuWpI1ZKWtbezVtt 7+WquoskptJlmSOMLzT+JYcHD3kW+ik5vWUw4HWOomTfKQwb+KpPK+KI8OKILfsqrR1PTlBlBJ35 aNcYowCRNFHa4YSsFaJPNY5Abpxom5zcTIGt6B6sNqWOwnAIed6/G2LQYhK1sWODkUxDMdW92OFf eGEwxjm6hj+e2ZutDDtoUHAUh/kx9SaK7cK2d4buHHgJwv6+IYUvdnFAYEQaokWdUcuIy6NpDFRJ 4Ujfw5Ru8WprpWQ1fdq9QYTYNUTryg7OGukL0eikusTWjksblKWdYs22ndI4OscjR5hhUoMaEU1I peRJudkkqAphQCtpStiqcS1FLAbB13Aj4cDNhMAccI89w1HkoFsop6Q2B5oaK7B24ej1HQ4gAbAx mHBEglb+FJNlElAkCyDvwi2TMyTDYZwlhmh0lxLHHVaTXIFppmkMdLZVxdyNqXy0MgmMLllECFIX iQ3rvAoAtFxLV+aIWiWkHelKNJnoUGxNBzLz4BEPATHgIUQEHKu1CoRsGCBihJd6RZBagI+osJJi pJNpwtlWVU5vVJpI/0fEZBuoo33RRYsJmokweyos0j5zjeD7axeVTJd1VabsuFW4UsWllxI0a9KP SktllpaabTTTTbNAN+a2v6kjcjDj57z/TNuG03fRwkdfiOw0pTqVENYiaijsU+ULqkYzhXRiqhc/ P7Gg00S2wH32ajTmB9TlzgxDdi8aZjuCft0LYQbhUwi+xwjxDvwGmEWH0Qd671hKCNxG+IhySQ0j lGn476kR8iB9qe8g+KSlC2xE3hPRUj+efU8oax8ppY1KURaIa2UEqpVRtFlG2Um1myNtJqooqxsb KWNpipqlKCzZtSyoamhZKbRtNNgpItrRJKbLEhWtFGssmrLVUrWatGRtszGsM1Ky1G2silosSEVY LD5XksJJBnzJL4geUS1+JIJpRqK8qWfQiOkakSXeGbn/vIaRQe/+FCFgelU6BT6ID4kggJGKsZKl sRbaLSQE8M/S7frjyOCIcKMBidZ9QebuHz9Q2lqns/kroN4pNyBQK8VPvkJBkgA2gWqh49FkGdtF dbS0nWatzW2aRtSosa+ybmxltlKzKltlsrTSlqbVNXnV1KzZtlrZQmipUtlqKVLSUa2LUrJUYQWK SSxZZJSzIjMQwYemm5+uKkPJ8Ma1PxR61T2Kh0eybIhscnPuSyPn3J2R/zfN2nxr1gbush+eyFFf PFS1DLLSKGZEjZo3hNzhC0DmpEaTAh9ArSlgEIv/dSbumqjH4SlQQhqIUoqevmDRg4MQ1YIsIgXE TEHjBXWBeIB9WTATDXDroD0ZoGQAyQZ44bLYVEDHKFtwMCZ4iWkc9O7pa+LxLqiXsSRiMACJemQ5 WRr4B0nFdnf/Dy5OsgfpLICegjALgrcQToQH08MvLtDMBdzECqPSDXmnfyskjwl0YQWYh4I8yToV pYtPl4GAbOBIPXK/7BDmmAeGgGBLSJASSaUi0xkRBQ6zFmRGgwnAhpY2yXJOx5K4PjkOiyIMSUyZ nOjMZCZT5IsiGzQ84yaNU3qYt4r1rzTMSym20tpWla6xC1tGRrVJJYlSTyxPzn/NKPiChXVQwiBw PHrxeBpIWNFFg1D8rLgp7Myc4ZTCQB9jbW9PWBkh58QaCBvgZkF3PRIOODJIPZJZ8koyJUBYWDCy QkfFD+6P6j39iQT8xwRJHcicixvPScHlKWplRmTJFLPfpqr7doN85avLIWke80EaCLFLCJAp1DPR E1y6ZEgVQkUkQwRJCQTFFOBw23aQCJRi5DENCMacpaEVYrmzU1spqyCmw2k0pZGmRMSxSwSwUTSl 8dSYIw8DM8CwSfFED7b/2OKYLP/eg1sFjAlxr8p/9EgWTeklU4jsM1JLqFsiaMUxirJ+qftKbASR RObEGokFEgpFU/WfhuNj1TwfMQdoeyoWKqWb2QWSWMyZJLZIYqGK6WSdRzNkXEhlPJPoPQzhJP00 9nWOaROqcOiInCiEoIFCYCOP6zMjq4BNxadD+Y+sJ+gdzrzEnLthsiW02WSWlYYUngqLRCdykLSS 1I1JKhFlpkVNtGRUEpUqqF9+SN6JpSeRtIf/H27Td/gYnVHeUjIhbLS2SN/9sbCp6w60hx3pq84W WkKCXKugIPOzDTY2MMlipLFSlVUMxGYwxJWUsXJSYMMiyQ9/ZFcsmeCNFCaqn8odSYP+vn+hOTVE pKTCThA5dBTm6WopCEIDmPkJpExwAkzZcG8lHtknE3BNygRiyNSSUqT7FnDaKEExETbVpLCJJTqw sT7i9xpjI6UMYrhOFKWMFIukZEmbbEYQBkMImZi0xapSJPil6cfPwX0TQ9fdgxgAgWifRPmXBrOs pE2x8sDXWJ7diDaHgY1wUnk+wExDmT1hKBgQKCSotElrIWWFbZIeoOTfi85ymHDGgMkWriQlIMDi EaCa2FslAYW0+DQYWTWJBGIe7ALpoe9HoYkKHXT3TaQ5EswDLbBJlS1llJaUAFud/HTSszOgocYB oDKo+hPoBwT6HgJZwsLSzTH5fJvA7a9p2WiVPvoKPLAzKtgbI/js+ZA5iZ25JW/J58+QzVQ+8cPF e0CO+00FJJmxH9gAFevogVixytKWGkaIO6sEKL3TRwMOIVRL0SgKFH6w+LrDJBfQbGuNUGMaQGop 0kAHpzy0DERtg0kEpLVo6m5BTvenfXTHPQ5lfoMR6FTiyyNkfeBehImvc2h1nFRcNoi2iBrSiUCw FNhPrRWKUCRBGAmEUKUApEOcTxDankHzdSJ2CB3qgP3iRFiQEUQpH9D3qf7Bqn18RNweXrQOxEIg 6LuCcwE8gpj/NICxWYQfh0A8I62KiibIWD/bQ7juKk3mMiJ5VdNyVokXKqdnkQSJHygQCUiOv7+n yhkyF8R/MR1OSGcEaqt2x6CGivVkqcoj80a6SSOu10aRhZMLosmHVg9d0hiJLCURhPoeh6h0w6SI gyKJqZDWLg1pNbTRo+MpiN3ycZOX5oQOPKNhiKBBjs2YKaI4wzH3hwy8RyOTlVw2M6QZO+KbHRkR 11EylBfeEAgnA3O5YjDjvptUlA0gUKlAqQYmoO4HCH2ruDeoaJqJqiqJiSKnEmMQaJwn4v3noLH7 L13TBacgZf79L+vUK1dAiZmuQzbkImZneg7x64WCcQgUIjgBkeiSKtCNHZHvJaU9hhpI3FKGD0mE 5DkVd0KPmV9EsPPUaLIqyy1ORZzDUJqKtl0H5o1I0aTNr8NNGghBhQR1TET1JH1fLD35aYNIxgye UDaxI0gw+lSSWzjsGoUATDbI2NbWSlVbLIYKUuS6inrO0HUDqyGSMOhYHsND48B6kugjQtLZZ4xS 8FxbhBshAKUJIfvXyyHBU684CHSKyD7LDapCFUVGKxHYEILmIXEdSIlJqysWKWEmqWUrEauy1X5h IBqywIoOkFWsjurWYFHMyGwklcjeBZJMIZApE2iWRqCiUAJohSrSMURirI8U6Fns9ar60fiTcKUo ImUWL1oJGbcKaDmwQ/FCyv10IMgQugiHuhtJB4GRNLxgSqB6NB0wLuAN33SDLF5g9O9pAImwuYVv kgKrugjUQR1SKv/BgCivIICPKJgjIFRaIVTVwqKR3da5ZrrrN1usWeaa7ZpbJcu7dtdNmRtJc5ip CXVkFixiRo+6HOximUeaTrPRWHl46AEVMdCU2nQkCPBOCh1dzmvfXylV+qH8Wo9KNOfSDuD71ifY X12SBicFY2sgelO9HFahkQPGPhljycPgGj5ohH3jZMlksiqiy60dv7NDYN04bTgT8RSKUpQPD+J+ OdIs6nYo1FOw8KOcdr4WG+zCdhTm4wc25yaHabphG0llRbIjqVMFilkGwwwUsqbXRt0mjeJJujJH 7yidaTCkc3SchZJ2U+032+3CXuiSE+k2+Qsfy8SYl6HLkkejwRwqPr4ZAA/gEQPn2MP9m4BVysFN jBvrS0skgVvw2abZt2wnWmEk+h1relbo98cEKOB/luMFLZ/rII1+Rm+0QeQVjg1kNNdCLEiKecyd kbx1jcpwQidN/stvJJCLlvM0OQ7o3RMPlGEmkkkqUJJ4o2DVgjipGliRPZE8ii7w0yTKL6xYieuA K0EFAgqefEajwhTxFKeRhSimD+00QwpFKTRTDD3cR8VtZEkHaKTSU4i1L4lVRMqmw2bzYqaa9q6n MFlupKzUopu6tRXdWpsDaCzZG0FlqsQZGE5HI5FNFKegimh64qu7oWk+2lNwjZqKdwncI8UE9yBf nQnEw/F9Fli2vVqPpiHBx8Vg124V7Gh8FAPyaG5/gm8u1ZEIQRiEPyikjCmiJP6J5Edyg0ZaodJQ ny/KPywKo7ULaYrIIZDmENA8TBsLVoIrSQViUiffBEoKiBSgHi9Sej49aTHqM5MWYq85tMTGKS9B XKRAwCP/MCJFFiHzVIaSWJUIu8kH1FTDqVAqFkFJZ/9Su2UcQsVLJMxI+cg7z4+14csvf/FjZMhs mhTEehO0w7+YPm7rwkAiDPS+aiK6DDSzAwyISkIYC1G5BgeIX+kwb1D7zu/MNo9y7dt/Bd1LFoPF OquzW31bPKbI2qD/olkYRg4QgwBjoFNRKXTtFLNF69t615oE289a7e3ZA6RvYCayhTHraS62BZEh QhWDxzpCgWS8cSQH1IV4EopH0YwW4pBoRlnAsJpIEoGCyFq4WArUUVLETUShEIgkUoLBNkWIiaos Swtk3cRkxaUQNFxaA6KQQG15BR3nF+6B8hxbsBfFHNIcgdfm9rcORZO4qQ64STSxIsVgvx/an2xB TzTb2R+eYaRHcDdT1yoHn7OFnoxSjMY9MwefTS36+kDQHqBd+bSDBLTkQagnpgp2LcVJ3HOkp6aO 6CGipF+OH4PgoC8w8OQ5kO8Aw/mopICU9EDQMI4VAbyFI0ERzAwiv7YqTmHyR3TGpOp4EfObwnN8 Jgls+rawCoyE0LGkjQKbf5HEnHtA/bAsqRBpWJUQ2goS2roKRYRXS4kuikPnxlWN1SPPKIpQ7Iq2 8W220VrZm1MrUtTVCUnbEkqO6rZB6xofPB1oWSlUJwsJVjCpalipBGKk9SPhJJ3e/4dfFrbQtnx0 0oaVFRUPBWCtCROzP8cYT7Pn2xhMb98DEkkkZMxohb4LaFLGoWDDx1pTBnWajKXxPM0tN0POYLEi Ji+dywTHGGiCnTxETx5Ymv+aqpqqqqmqqqqaqqqywLPR6MNJMPUNt6hg9QsOfOgw8zoMMkxirQM3 rikojGSSTClsGMGMELSKBwt3/iXeECpUkXTfQapBN6EBHMW6pOZAVgnDV+jlKZGbabTStsVRVXnr 3PNGyFO59+zChbaWn9p9e6erJQrMiGQFuOkH/ti8l2BGY9YJAkkJGnvKdgRmPWCQJJCRj5OMes7h oiIaIiGiIqoam8cnlCG2wm9pjDUYmbKTsVT0sZrYRkRdxatmphFxF3Dsc1zqWmZmWmZmWmZmbt25 fNuioZuanNW+nZjuJh51bS7NrU3lvmZcUuuuNc8R3sNyu5JcqSFEIQNggJub0iXmE1aCN4JYjgYp BgFttKyAzbSrVgROaV6RDvHs67ODBAIuuo9ao9hUesklE3OqOIKn1KleGoWnlX/7pqAHoURDgKB7 IIeg9APIR9aE4koTYTp1wT44+w6JHlULUHd+h9/3G/2zdl8TVonww6HM1zqFJmqSrCDKIRNEsBSy Kaxs/rNZj7CPjWvMsw7QxLx0N8byXmFhmMCyHSRkpCgIZkEC2sDtP5fJ/GU3ptoMQ82L9YIPuKQt ZsOIYHSCEDAYptqRDhA7gc09zslzjgsSS+XMBsLwJxOg9Hd0CgnOKAr2QWoAGq7dyRMMCOwXdBVE 0TBeDARHtAgv6RHSOlgChLpW0zQQTKjIsTfjiNm20bYhYuxjKXWyIvKmchL0c0+DFNVI8dB79NAd ghpkISEa1pNoco3NE3NtZZKylRSOQkYJYBhHmotkg2h04ZE6bApkxwQb2cFh0OZljn/Xw4RZQa3s jSGUiVXZdLGEUg6RKJCMwE4G/J/P9E0+tchrrNScCoNEn6iFpc6oyV7ozrREQpEASReQhYG0kYGQ cQaiSyZJG0Fg4dfkxckk/ms8wnzCe8iiTR80hWKBXRZ0BINEQOTgfvMjhRnsBEgEFU+gHTvwn1gb FIWzBFcHwaLJX1YLwQV0PFeIYolOD9ka/LawOxNP+sUs7gYGR7JD0lqfIa0RufJ+Rc6MmY3n1wPX FcQkSFeGD8Jg8X1ZLD82wIGyuqPgHTXk2PlaczxIZIMj3xg9c4LCOvBNnkN6yCHJIq0WCB0/aFHF DeQfUcEtPiERWRUn0gi8QSIKo5A8boNbKxLiKjsERAOJBLgTJSowi5Ro7zzzNs0tZZSsraaEpzwT c3kGzUmVJcmUqsiyZFhLEghgmmrLrQoAE8oHIwg6WUq5tdq7tVprNsmNlWPTQjKSSEayVUmSxExY RFcNJqqHCHaIkBtXZTpDQfYIdijuFeO0PNQH69sAboFOzbAl3QjPnCg7U3jJVm6IuVKqRl0ctE1H AqynMC4pcaQ3KcGJ1k5MJIyyiiJVVJuzDRUTIsUiiSOcjGMkpoXpULizpqmIJ+I+ohbkTQAUfpXt higZwD9rlFR+xIrgOEAHreQfNNtEieB24a1yker44ZI99j/aXZdjb0mnogL9B9pajGGHa0e6xPnr 62ZyHgY8Z/RD3RVC4sT2vQEpdYX0FC78HpmMeQ8AmAhCYzw5nXTPuEP8SA6hYmaQkt2IOEGwGI+b 3SQ/KflkjsU8Xd8duSVsVLMpWBFoeuKNBE39oX2zJm0+v8+cmPz/pxg1zrrnJUzMiRNMVdUT/0TM l1dVRUzMks35H5gx+B3uBA0e1aHyQXtP0tbw1NEd0TDJEZ5fo9ntawjf4Jvz3S7BwcNmUrQ0xmNt sMMSRjW2suoqJsWRG0j3ykY+0k3jgbSESJScTnBZC2WA0ajBZLIqHMxpoj/ohqQ6GzlvINKWU6hD 0N9hGwqGFYGCGGLRLIUFUUlJSSmpCiLEq1UOPNyeazs8ok9B5wfo4OynQmwZ1ZQFqxRLDeFAeSqe +LX5AYv+w3PQR8AAwxNyNBEPtMjr730/DVM2KjZiptktQyZJtZqUJrWSi2Wm2YzW/l83njKNdppS 5qLWua/GLbARQwwGQIQXFB4r6oOJiMBImUXNV42dutaWmrKhllpaIKlKixhhkhlMlJShV1vWV2rF TaSpk2m8yt2lKMtKaqaVKaW6u129dXAWcpwMSWkhSWQmuDEaQIWBvTlSbW0020a5mW3a9dVtrSie osNjUsYCqslQsLFIoRGAySZSQqEQYRGnN2+UzdxaCsllSWSygpXOJD/4Zqdu7RpZEZBEc7vuSM2O VhushOFqpI2KxmBwRakzCGGTNxpqJpEnE4kmD0Ca0ZMZrdjGYUGoLlQ3i3QyBiGqsVIMKmDTKdKK KrxbzeN8hTuk0GxhZBiQD5SMdQlOl4vehVKmVODnBz+lhGWUGmMY1DhYwJ4BXEs0BNzAUIKaWeZe ocY0FhLsxAxbSNg7tMOXLdBQ5iYiraRGot24AozQdAwAyHVsLgNaW/BIwJxyL6m4GlKTII5Lqk89 1A1lQW8YLTCmSQE4nvhPZ07r0hicEpHzzMktYa7SwxZSYjkGH2QuIcAfasJLnzbEujLKT4CcT355 DIeMkDaSYoggpWGoFAExIkl0BIyFJPpZinKmIl6N3YRKSlapKVa1tF4EDC6EECw9+guIdMQqcMLI V6unSYmtayGkUjlGmVGw67hZtsmxUnEYZxgIGNOGEyxM0YbsczSi8iYsaTJgG09+RwyneYhiBSUR tnnnAajZdZJcWObjls4LeQydpqHQo52YUiNEUkMVKBITMUssoKSbh2KfIeVQniYIfHB1JxKQLSNJ 9PH219iZMU3cFaMKYhqZnLY3bNnE2UEG6P0wJiFPbHr0wOUn4oVpZ3rSM4ENUOAbwIycIyCJiYsY USgVpFAKScGPvONmHeMMXuChqEdTOQuBuy1aXaGmhkkZZtYPnI2ZcmFWSj8WUUi0xFW60ZMsQYwP RZOh2PR1h9gZN699KBpG0SEwAtspbbiNwCyKVuOLaPdBOETKjxWh1AlwqESDIbS4OUrClkblkaLH PDaXq2nx2mjFhNmDIKrCpE/C+Q6xouYlMj4jq8h65x0GCbgiQMlohybqYaJDSZjLrEiMEsGFhTn7 +LfnN8PcoNClmC2CmWxVsVmzUamzRZbuqW3OUefjHBwshhvPDwzmt4hMQcEWLeEYRCEQgp0QTCnc JEB0RiRAQ3C8CwvelIiP6IoUG97u00UN7ZPrTUGygRmyMghdBaQ+TgP0/JpmilKVbEiCESKARO5K cYhK3iVJEo1G+h5sPTOjm8DoczmSbJy+Q7NbGxiJ2cSG9iLpuWRqVHJyYTssbFSHXpsK517jO1OM KuitAnWdpT5Rg4TqbTnU1E0snEhoqUGCkAiJZYmvH7sWGq8WwNQ4BxzgydTg6bLtJv+cXpOJiG85 RqLFiliwpQSljsQ1Y/mlk6KcpZDlhhpVEt+MIYNgQR5huA8iKjnsO0Io8Z2pDAFzkIuEXDFSERJE kF8hFikFKdRpAXDFlq95SlG4gbGxi6QsIIgQtJLZA6wApYLIsZIk1II4okmQrluDUg3iqJUsxEtb cRrZZVGqBllsNQm5B4Kn7VGyXBQEGkLwglVtTar021vLRnqpaUyep4gQzADywQpLLC6M5kuCYIdL CGoXRkEoIoUe0g0soQMGZDBdLpLJSk0sLSW1B0UsIiVBJgk/Ww68amhoGBkLpIkYWhS/gyKRQQLL EFwlp+yAhQYhIUnAAFklq+woaYSFbVlsEopMxj8XXDW1tWqsq4uVvJHAaSWUktDpIcAy1siIIQOr KELNGCsamSxJFpKoiUL6mN6SbeJLXtU+vLxvJq6Wo0WbMpppTMs1GgsmUkunHLcZMU0s0q4XbY1M lJGJDYXYD0wYGEExN0ewNlKwEB1ZE2ptIsiROEI9IHuj1Ro+kKfeKQaN4yG5pMNjaeuWpTeNjeOB gh/+DRo1B3VP0lg5QvY7JA7zxjvQNA1Raj4afonLsvindlogecWxKCIHJIj6jmi9QP34BoXbdkHC BtgYHJA78pRyggEYoviqqglQUVSIREkRICkWAwMeAYbhEkk2EWwJbISWgiWxCEIIsYCq6tUogSIh CAgyJIn3FSQeeJpYYtiUWSKVEnngyMkD4xc2Tt6zXCRHtjg2b4J63rHOajS8zJo4yGxUuiWWMjeJ hNyZEbhHJxGyyBSamEfElsYSRYxAhYWc3fEpQ0QfcGgqWSEkJxKmSDdS2EyGqB7J9dnmlFjgcIcJ ZwkembqtlpbfNc5vm8IDyYgHybFKhqdYcjyFlrIrJ+iiiME/tXJS//WP5LLo/pQ9PWD/R/eejRYO +Ugj3KA/JPt6QEOyKCyKCwigCcwKIj+0g2JBCiI2RFf2fjStkZkT+o00LMir3CrpoWe9NTQ9/+h6 HQdx9L8CBFIpFCCQX9we79CaDzYocYkgBAg8SxB18riPypFfbXKgOj9DI1gxmUmmjjGNMyzExjLj F23f1oftD5hT/0A1D+QPkAsD1cx87yaP97s/gRCRS0cq9iFnjPOFFHj8mpPMdJhzSuy9CpHB+0yd 3uh9UhlSwT1AntVbNSHSA5V7mKQSBoxgzautDbSstLZbWbUzNlmqUotitJtmUsTbW+yWJ5VBq/mK Hh9CXPkOD4onKfnhvZRUkkAQ4HNVE9/3GrSoWZgD1Fxgln0YTzHBeKEnBZ9nAnW9OK0xbCXyJwWU FkQoB3UqQpPA4h3SdFiNWSNxYb21FpkWQmrIpoFoXhR+4SGFQyIuS8tlgEkhIh/rfCbSDcWEtios IqQRyUVkFCkiMYoUhQrUXURPuI6h/lgj8tH1qSEaWxDUiGVIawSUpMed22Ma8pVdd55tvNTRbNVK RtLW8ldEssdpnW7rszS2Mq5lmsjm1ePKXmgtuSEGElALRqUgjG2RlKS0sjIWljGmuJINm0WI3SXY 3NVK0Uir+csWkHJVKoU5BJqCJE0ESCYw0rSJYREfKkFQpWy05RZIaiwWN3DWorVi1LZaS1C1ZSTJ bj1ySQVMRHk96EJ84M86WTficQHPDIkhepOlEoAFhxiJaCkSLaBbYhSv0H5jXD7k6TegB+JPDybr EeP62DvGP5GrIMT8WlCkgkg/rlRYlPssuCe7305SJgjmKU/oIOKQ1b9eVkCQoSQjGTNJJVVq6h7Z m9U9byqr1sZk1FbOwTFSMskyhYpaVNRkbUtLy2pqWzTNTTa9LstZWyirQGKTClraTiwyNRLAbQ2S btHDYXSJpFEVW1oKVQGQQ2J4IqkCKiUQKRuhUpGoSBixDYVYN5TAk5tHS78T/zNjghiAYSAkU1Bi hobvX/EdFyPm1ByTW0qyU/XKNRoOc8ObZtCHVODsGpI21H+NbVHfU3U1ujIZFJSkmsBMBAf+uAVg QUcxQ4wEcaD2WDrFNJUoNyp1NBaIQIiY2raLYQTEF6SsYwMYCXKiG0Wy02ExbgW4AFxQN0XIv+uo 2yCaiBFkBgQLzlwbRwWqk8Mb6QsVaLYcpUaea4OJE77FOTiOQ3jnFilJ205kTEThZdomjotK7giN pAkRm7NyGmtKvMw0jrlKUoJxFhazSDWaTiGibaNdGRUWN7I6rOl4pygscOE6UjasIMEiLglSJTUC JjoOh9JnK6bJWosBsgpI2Bx5iYAyxDfIw5ixdXXNCsYA9HBNq6fNPP7r3G8N9BQUwNasSwIkYV2t CrIislJIJ8aYSkgW+n+D5uWEs4DgNf1xrIH4QQgE1/JXjGkmKKbaHTQPk249hoG6B/IdgUqwQihC At9LrjfQjnA9lh7uVj2qP+sUP9Y/3m5jzdjA60ndYWi1GrcloTxizrrgoyjna5AKgnkjHeSkkItV ZbQMIFSkJgTsIcIg0iRVDQFoy6gh12oncdXT4RB/lUkT/2qlaIsSRW9RR8Hf+pIMj8zGoUwUB+gY CHs9H4E+00C4n98223vYtWjKtFUtqZ8bNWysrWxrRtprLa+OhNTdX5K/QbjDsQiPZHEslmB3km8U 9g36bQJRSSqEWPXFQD4MUkFdMgGREPG4RA17wigmRWhTwTxz8yhElddis67Sv2e3S0zFrd3VRY/E pfUkCMIqwIKn/ISAUwkVSWSylUsKQqyRCOQYyJK4IK4tSwDR4qJlXVgiHTyQNwBwT4QIkAQL6AU+ 3fSIif5lqUPJXaj1j00nszP6Ybp1kcfSkyPUeYtWkWURQsipSEkezM7JE8mIkhSj7/A6zr8aryYC Lqi4F2w/2nzjIQkJBpVkWWJdnWT3SFHi+Nk7ZbT0E2OPIQnjIpkUbDYLSChzWSSLCCGxUzUtNllt NNlm1v3lXtFuDzJ0RzBQwKEFWIpBTKnar0EWjXYk63lYLY9di39q1a9k8PkbbyeHcb+Ymxu2Ntj0 p68hsWmUVLTQUtLS06CQQmJjQ4hiMnQ7dYYX/s2pIBA2EMe/dkwa7aW/x+sNA0BeIAPf0J0HgJ2o J7FfJ+F4fE6CkFAkBCEFVbNQB8QiNZCCJuiWCPg2Nt5r2qSmm+1acrdbKUalKjFo7ZVntNa/RS1N LbKorS2yptpZatppVqlsskCKCRBiqEgKihCIfQr0wgpSlKlpCxUK8MMKCn8gRehgPG0oTAJxPmtC 2BJ6IUkVjUYxa+lb5SvNss2lav7y7TWt7Z2RtsimpUyWy3VK7UVIC5ilSDBxGlg8IvniiaAR0t7C fnr7FGMGEWVZUZtI2sTzS9LLpgy+jvEwmqRZROixIdlSI8R/ApB0RggBFdqUGCKrq6CdRZIvbER/ VU2LKs+2o5qi2ElKVYNtvrUbFKVG79fBpsYlMRnYsSdkdJ693EG/YgknroosS1WVMjWSraUVKtgg 1aQGRAQkAOYMRVVdOKdDF1HeEOknxywLQtIcQcjPU3SRypIPVEAkRTIqOwR4UK0qhRBB1KRD/Hji PPP93xJ6mY/NNTO+mWMzI8o8PB/bzO67NubW9rX7dmTTNCWSzCQYCc4lMIxJBemKgnPk6CbPy07j im6KETRdoxRW+8ycILqvXAEPHSdthlRJNSfVPqjPkRR9pTYo9HytAsaAhAhB/9sOyc1Qyv/Qm1jz E4q6J5Q/v6wPv+To4dCIz/vEpirBgP/4WClSyKhUsQs5JJ2+6UUfyHt9Y3+J5sk6SNFnxt2NLufR brh9s31EI/eJKUk4mkablqWYS1TJYXGElVbJE0ZrXI1MrzMjKiC2WhNnTI6UjaqVKlElpZKjUjML SODa3L0t26rq3U9SPXnIptUUgSKQ0KBakAixQMUNHsaKdaXAU7YTEMULQQCJRXcwEkRdTVcluMmR zvUdNmpNkdZTdOCiRiMcTtZQmSVpQDWQjQjtBQaEyRcxaCIjYAtgsUoF9IJ/SmEPmU64iJzGAIxi KHu5h5YEjnH+2toQH5NqU1EaDGMWplspfVkwNpJY2SWCcQmIiUlOKSBJLPUiGVtE3BMh2df+pYJa lsE4qSFiDYRR6oiK6KbkQh0pF16UDsgwjPdKFPfGgLpQbipWwVhgJIrRdiWCWMDJrJGWC2aKhImf wyNOoVtEhYrdjxOgklnsJ70d4Wd0iwCuvG2+5P7ucn22QSPj62WFhU0dQfo6e9D3vsD09KvITw3A 9UQ5BXvfUVWtKPHsUq4tGIC1i5X7Qv8Q6HnH5onS2lUMED++ScDXfRBeo7ERKV8fJGBpKA/ZT4NU paEiEVuxvQ+JSRDobSRFIwyQIp9jQg32QE7fXQFRA+3DQqDRBBsLAlsQ2iwPppG6lupvqfZmrIYR wTwYkySxxFkNJUnsOso80XfKlRLUThm5xh4zxGiSd51jc+Wtt9X8Vb+ukaoYabNstNtt1/fOeSZF G8kajiLF5sLLGWGVMO0vydphsVX4K7q5t0zUbK3QhVMkqgPkghVgtKwMPvRdCIyEYQgRgnwV0ENU gkOZlA/GA749nOFivv1lgsfQk4iyqJ654bTh6VRUin1J0SR93x2cCzD0MZOZnwbtZ9ZmqdHjQ0lS UA2LHBWwbWUgxoKZrhUbjeH1itaOn1q5n/YoUoN2mbJ+hQrt1IH5UqTqxEJ/kfykmPsby/sv38n+ RTLtv+Y+Coj3p6UtWpbVr6qyosKtRxETxSSSjwka3M++eouGGI+eU+sXJmEuRq6jUWJ/Ia1YmI2R YpNG0bKWxNGYEH6AgfQKY0c4QIiG+SMg4SD5ogMFLAyihQZDrQ+4dyc6luFSaNhwv5hgfbo9IjL9 CSglQK3m30+Gu11rZr8jsw1BZse3qApRpTn0ctjnDWm4jlSqLxGmm0RulnEXSEbKq9BL3t3qdUcd OfLs1GXNKZCKlnAK6AhwknPdnQNBUzXITPGECl2cQahvBIEduBXiX4eBtHTsKsLft+2aGthdCyMs aw2mI6GNJZA2Dlh+ZrkH7n7N9iQiRxM5CMF5yDrpbdn3hAgIUCRbWQJaOwMTBgaDjDTg20oZo1Sm WcaLGZM1N7eiVj+/+OvBDFbB+/898ard1HDVpldPRzryZ2Gujvr8FOOiPGkP/B0jzJ/cyOs6UluJ DUtX8HmqZbQMw4sCZoBgD+ZjdIokzZjLklZEbM883xVcdvowmcbbsBdJ5DOqWuvGkT0wFOxJCm9T mVFAWNoiVDuCtxHph4T4SR1h1hYVFF456ic5FWNJg6QkcCsnQ/2kmFsn7pT2+bB8gsjtWH2P40n9 3+7Ww80j7E1pfi3IsgEC7QsCCHvAjcIyLJFGG5qZVaWhfaXTcihsVNNEaGIo2MjeLhojQLlMCK2C ARRRg2kGBCQSCtNNNpWrNpbaYWi2i2MBhUyEA1BJokOn0TIl20WwSPWWQCMGoL4GT0z09Z5g9MjE A+5eR/dkf2+LdZ8MU6AvoM+JfShEiRBsgDVSgGCVVJZbUmSzFWKQLPKJ5fESQX0glvZE0AJj8ibu nepRrS6QBf5oKhFGKIG+xYs1oLu7EF0spwIFUwqRgRMYVu0AkYkZxTS1MLEgbxdkgGQPlNyH539D JzR2/APwaCMQfV4D8dG4PUnRzEp6A7yB6hqO+UxSPySqkkpq7CkBD6RXyJzChyWkMCO5KTeJ2qJU UUEe9XlxNVcxU3V5Y08ikXRNhD4kWLYj4wlPAIPmKCkkpqki7TJIpQmyRYNkilRYlJZFYGoqC4O3 vXEBIEWyhkEPNuGipI/jq/OE5tul5Cdh75zcEvEO0+uz5Ui83Kc+B2EBOILaQQiNCEoJALD6Ag4B D3OidILZZYUlZJ0MMklChsyLhJJLPKs2bSQ3li1JqQqGSomRZSYYC2EtkbO7rsvRT3MqKco7+1BO 6eJLq5jEMYkkldDd17qb+XxttwJBpCw4GSwSYNYV7LJM1GJsWLGh4I/lm4vrj7CyE/9MhkkSexE6 nH7/4+a+W35eA9yVP9ZbFke6jULGiyasJZEQvwx7kE6RgEe/cFPeUr3MCUgnbO5Lq5jEMYA813d3 B7W9Ut5bqR6+vv33rUy17c0+EituXea7cJK58Gr0aLeVyWIT+++y0stssg4FH0M/500ASCr6YJ9k U9APSMnpAtNOcakPdQhrRJ2HyGPN/6z0L+aof9/T6Ek0ffKj1RSxTi/VFQ8V2h4PNqSR6AikdKko UIomBALUgIKnVRavGLwCApIIpaBIIkVPDLy33bdl4wMDGDwtENwR+Z/N2loh+8g8NikQOaeo8vmX 04k242eIeyEmCjGl5hBykciEZyu/UguQSEBevFDkBAoGQjExEoit/rT7gpwLFE3JJiOxMhqQOCyG 1WxDeKJcRtW0IUBGhgUNR3Y9J3jUTRJiGyJ9kRHdPiryiUP/Yo+O/o/NHvLqmomy85Krs2rr9M3n mKjSiyy2xAdZHsmmleKT75UtS0sJO0+I5wfsKOZfdY862PrpndFigQ39cPbEDtA+MPMq8F+U/9l5 f8g1U86Wyv9jUV9e/ekq7T+k7j4tiJW79ypvHeVxyF0Ih/p1BTxEwob4Nvofz0jnCqZvzeIuEAtP pSlsRxiwLCP7tB4xTslLHcOg3WCXYhkmSy/ISPSTgsOpsYEaU4JA4OtDcVuDiHOha2fUKmrI1ZWS tHSKuLNT4zYpUM5FNsGHDYzhJSRlSE0MTEZjYaEmSbG7fc2G4OTZG0OUcYhlwBqpYlqWyiJG1Cow gEYNQxGRLUmKTCkzN27ZG6Sm+jUiWDku0KDU1Ay4IOhQLSumjkEGIXFYMYgwzFPfdEIMgA0hQmUs nKJeRrG9NsZIqmlGkpllUqy2JE2XapnFbNRbBNhNLmrFNZEyIoqLZUpeIyMJpiUGofpYaoqWajkh NEYxgFtFKwJJZaUMIWRSFklhdIWQowUQ5qS+E3javIbZFNIqpmwwi5IrSpLpaQlQcVbbAzZbLtMD oDSGLAhQylhSJf3USfsI2Ycr8VNAGKEwMiN64AsG0kEMJEgySWssiMsZRlQoSFgqSgaphaWRFLSm mDNGtBsyYlNUknRAtBkA5+vd0KN5tAZYWQWMYxZxUalTSWLEycJgqNIyXWEQsKCVoFCDPJDXIW2S Xxvo7xqyU0yom2hmmllLC78JgmsMZFJxFDFlkqixFqRWsQyoMsOfgbJrgndmB2c8bVeWI599ydyx 0RTSi2xQlqQ+QoaXUxbbSyFaJJYYGQZqwt7tk0Up3bJamG9YLGFi2OIkUuzheEYoOgRIHKkoIQJA IqykiikUahJrf75tGD57zicosRIFLFCLAYvEKgRgENb7brfit4uje4cps3s00bTcpebElYv3zu57 HNoklLSwSJAZoxqu2nBYFGCAwgElFJaSVCQHgmE/EzQSA5zSrZHxUaVZqv9PuLb1XcHLcLp3ZFJI jgKkKkSoKipUspvWCgilSMMmRNSCH+X7GEcavfLV1ptbLStlorTLTaJoDBrkYl0deS06ESgXQDI2 jXTgMFJuJcps0jJDeFsFm1SRSjEmEiUJFYkVKMAFqQEjUsHtghITahL7YcbRXRbClSBrFACJFKUI SLS2W7piLhrYCNRAiNkGlhEibkYUt74WjGAxSyayWQoGxDAf3nAXmtGhGA1a2NgMINWtGwGEPgkz m3ABYSE+wA0CxLTChBIiJFWAWgqUqINgQFsYiWqQRRoUgtKrgApVAoVsskjCJaoOQ2EyuQ7LFqP3 +MprVW0hOIkvr3TIe1HULEOseYOBI8VNpqoIFBAQwKbtvgP8J/f9C3XOcif8UlB5KnqVYf68jsEi PGUq2iwqSxSIxbFJEPdncDpFC2KXrE82iVKsJbqKMWSWMUpbYg0PjeXbN35/9Z2xqRHu+OuossFV FqLIhOxIbwqKRLBBAP2JF5b5t+by7tEgkaqlIiyFiqQjpkMkJVkSwBKksr8H8DR883OZx9DN1sbT LYU2qUWiRkLF9W6plwpamYW3BGuMAowSsKGlECgDoTTGELdBcULLMFiTC6TUApKa0nlA1xQ7QYBp Z7syCRvFAvRIYuBGTWkoCS2lhayUqwLhSWhTLVMJEC2DvOT20vy/JPby2+ElK6V7k4dPKX+1xJjE hx7CjdAZCqHspTAtBKg5hHBdhCJYsSllMWEcNWNsq22bf4MjWyg/CfqYTbiqcju5Ee1r/3P2+ZcH 6KEK+cE9KgP9JGEUbVDwCBr8X01/VMpaxSzTTat3dtfqy0m3reMjGE+aaGpI/CVPZ7iyrSxBkWIE UB0U0PUmZ8fh4k1PHJ47VALIRtGZsxkETZRNRZsqbSWKoYQQYlVbFS4SEiigHHyxVCk3BAWdS/IL J8yeELC6iBCQUH50itvSGw7lZNqYJypQEKShN60Hth1Fr/xhhJVqKpJ8hZP0kEWHoNjIsUWJRYqP oi/NlxpOJkXIzY1Y2nBWAdgwCoPR2iJQjyIHNStK8QXGkI1aUNBAgLqZPIii9sdfNQ9mmkSCMFFx 3FrzIgRiaqZUpHjvXj4FUXQNXZZVXqPyWU6o8BIqbPiOAph7iLJ4l6SPCxyJYUaDgsdFkilQIsVI 0MiNSJrUV9T+dMv744Xvgo+Mh/ujh8e1wNAaCoK50M3PO6kTypLYe1OuG4+JEd8j1k2PIdHrLFkF shaipFWkWKj1JQxRHrf8ZkaipEPQdkTOFkJPUovlA9cQOIR0yqqZL8jSi0G5pIxhxclkluqkNVEa hUiVSRzDBqf1gRch9PQmpjR1IumxaWEjEGJYQKSKoXEQdFBbvSsCg8EQLATJlT65H6yEiAbRvbIP nAuB1BQu9zLY/56xJpEZcOaSPrKOxSVRI2f7ib2w5F5i6kcAfuPIo+mdX1/vmPT8VZZJU7izS92u RVFqxK2pa1NUssRrL92psbZUtZDpKI1jt0Midah7W+QScRkpMfIdyMKWKtqTmeLUQsixYIq4kuKS yyKoKuSSZJJ4EWrLWppIxUR7sLhFnrOtHN/tGvGLkInxCQF4sVBuIiKyKqugB4hU+kDx81OoEA+i JCDGMY6nR5+pA5nJiJlFN2gCodKEPtlkTm8JwBx4oOcj6JziUttkr++v6NMwYIMlJi+78flTb418 Gx0dAHwReIEBfICWHcoPigEIiqvQmk7gXAJAowCqtJAaiVkKQtLBuoGLYgkOvQlzAYFJZENoMxDr AP4QonQShYlloRskSXu2vbNU8NY22o1MtG2itqWhEou0kksLCoR/kWEhvIhlIqhURakWMN4Wq2Ei MEhcFkYI0UqtCREpVpf8ELCoqSSCABZHuYiIU7OLiPJWkAMFsqI7ke5J2Qak5/qHeQz2e2PzKmdM Kb4LEiJVLOuwn30BxNy+uw9URwKroJ7G3CewtD3BTQaOjoCFKrxHpN/KEkx5yRkgoypZZJdFYZAp KoWLUn4yWaFOlQpQAtlOQYWFLAbg0YFpDmDCTrAHu0AOOhihpNrGygYWawwsHQkEKZ26tbNdbZTU xLNNsVtVEVJMZLISTLEBZIRTZjR5qLGLEFRqYVPyZu920YpOdttPJkrCfvpE/TATcQP6JwSfOvkg 7eqbk2ymRi9OxphdTvbfoYivA/cP5/DxHrAf9KxASxIm6/i2SGTyYbrHlf25kk87ocpF7ju3Qw4N NEcho0CaSSQQSOlUSxIPLf2F0a8dHG/PRxyw503KidGsJ1sOCk8zJGYNi4BwdYOCL6KseV9FXxzE 65zrrnjxYlryoRemJXVkUoNob6429cVDRjvRad0tHEdxvgHhncJrA6aF4bKahI6Vv7BS6R6Tb1rd hXRgDbak4UrIPPfQniN94csRkphqi0lKWLKWlMmet3ZooqNqK1MxnVate2xqEdZvEkyk6Q1Njqht CMNao0WRoLIh+85RsLEKNM77OZ6LR6uFpUwiaKBlTEKVQSGWDTwdVexvYkkwF+MOfM2TakvpCxt3 hxEww6gzQ6JAdBLDNJwKJGCUxqSqGhI1AivQ26BAIKvVW4KE+gWVhExkklUmBFS0VIPdfkXiGoQO mte5wF3JPDtDGkS76EgctBTw6Qx6UtADmwZFiKCaWadmI/1qxkNZpwxm808c8aTEXOaa1SB4GzoZ 5vBw5WHINWFYDeyMz2sWv80uD5h28OxTVsPEYUmi4S4Nc7NbxkDBCbp3BfGK8cFaeQKg8dw5NyQT ldRYAdSkagmfHuqNmC1IZDalU8lnZ0jI43jjXSRcE2x2eyeOhz5hIRTIPMN7a+RDSwUTb56Ik8Bj A4MI8tLhOMOWCPgwKCGCe/ZoCQXYKRDaG8nwQaJdpBHnphxkSwhjcfUPbhualyWmmiKZioSAoya6 HLfadWEK5bWbuYQjG2QBeFSMB8WRdBDkjMFRCaxdFPCITlAZlNJODGcFwtuFK1IweBUKbqnAZAxk yUQorMEUIhDFqVB2SNDitKpIYcllj2PiwUmQUFqS0xmzfBy9IbBlwpkExkDMeoIZN70FWmoQ320G Z2Zx2QTSK2ZDq0TasSR5pY9VOUqHBTLI5mu3bZTlW9OeZRkCXOEOs06mxyEOR0wLW5OzjXWrgilc 9GPvFOxHiwOhw7uU0t8vHW9pAWHQeGyG0BmggvXGphE6abaG1cu4Jbn2hnGaFdjzLnoNs4xLHHGH 4/tjDnQxvhxtFsw2yFyKNrmktkrzDMkLZtKSym83bbdRNFny+Xje9mkl+LQEBt2KEHZMsYSwIEM2 HxYTLQBpr4CK9urkkyRh6g57eJbz5tjTQMsI+wDHb1wPTDyEY1Q3vIHE1IxXFtDpunJgDTeQkhhp CYCGRD7gcbAY6+jTmAtg4j0czxNt5pvTCrvtw2kdp5o4E1u/NGQvV8BadiilUGnAHpbHBMRiEo0s GUpKIoAT4cc+PiKKthskYHTQYDjVTDge9noJzd2GUkamWtS3uS0siTGNEjCVV7mBxqtwb2zrSgxZ FIhAdg0yJrjUSJOOlk9oMKN/L6jxDqg27fg+RD6b5nqT3odSmNXA5MBokDk5oKzChqcnixNDIaJM JQbMYomlBF44IIwWEQDCoUUCkJ5N102rxjGd8DrzYTSdsbIHPZkBwFug+zTdX1HDeXzMP/MDs2KD g8QhsrGJEXG6EpPFJ4ZLR4623LfIc7PDu7/GcdEqPRFPJTeLhkjN0sea9yzwh5zDl44Y1MHjpFK1 hQlis04yqgqeK0igjalms4YWxsjUEYJIkSARXRlBadceNnVZ5Q1Y120dRdciAYFv4Onbr5d0bBqO TzsF80FszwCgOoNC6d6IrONbOE2NZq2GBPBIGYHckMCZmMjorEqxpjJSuXFwbbTXTyyV4eJDkC4d SzoPMIOfS7BqICqAONFodhqAifEDk8WK5QOKtWuPTkaqmYiahZrDilVuzVyZbYA4YI8AIEDloMNM 5Hu38qJpyDtvhDtCadpR387LZVVwLaIhHjz4muETC+kRJShpZXepqNypH7okSpAAG5YlLvjVDcE8 Icfi3Yw+q85xUFgwIkUg7uyHlHt7Og4Hcla6gx5hXHWnxBDhHxQ0oqgzq9DhTu6HttE9s5uAY28k JQS/XURDI6kHuB2/QMH71Kp8D32Ww8/eraJ9wkm0ZbGSoSGEDxwymC9eumjUqhDgNOsO4uSjmkLa DxIsDayWuWzXDTrdJiDazc963FrkjcHO6Y1DKo7dbxu7dawBhNhlLueDQ5bDoCzeE4RoMuGfNwuX Y4Gve52HgWgISf04kZEsKJtFJhN6b0mmpkZi4GcKFT4pvtSh3b01Vjnt4qhwbxvGg1FjjqiZNRY5 DxckMdKmVOVpwsDTfSZHfpegeqpE1w0+TWdBTkIGXxNhbCEjgItNZlAQegQ6EiJhom3/uu1gDHuH 65+QHwgYZlcakRC+imhgihdK5ppUZcmrVct3mHARPQhoEUsL2EOFJ6PsaCRsoKSlZR5z3ybIT5De RtI0ZwpGouzjfR0CpZW6pOV1Y3u2kwI2bhkn9SuVS/+P363nJhLEp6vrt7o8j5Xo58uRFNg8rtQs 1QuLPWAekD+zhdfSfs6v8Kyc5JIEYwIr/jy857faHUtz2Tt9FTffxdwmU3ICQGhIAeLQAsS0GQe/ xcXPHKX9ku/CXM+3gaHHlpZCVBHn4wwiD7oPxQXgMFai8ImIF9GQ/w8nAQ0N0hqUv/PAFu4R+0Y6 KJFZXSDUxl36Bnow5eCUIcLwF73xHJRVydMjI8E4NLlN6ZSCWNpSbCau9KVibliOsWE7o+mMRkZG R1iglsTUoJwIF00EiHmCIRi8OXXfhqGPo39SGDku0aXfiz3LPAW0rPgH3bej4DiBvKGc9jHDihOh YWEDhOx1a5ChQkbA+viIiLRD7WZjKsFIZD63AGhDjLvWzIuywvvj9KWvQvfqdc5d0xfDGthWSgqZ hiGMU1ENDsVStbXTjWl3mZcpjCC0m8HFBiYxCd2hA8M9ZZCyVMXOQA6lEIqXmWHDktLXDRLYSNHF TlU3a00Yyatc+eDfXu9vXe8A3qannMbA9HstC09GgWwJDEPdJx72mMmrXPxAAhrslZpTFTqBnUoh FS7OgJz3YGZvcHdxJNjaScQ6ojCkHJOttS2F0tNAbAFAFAfRWvlomzcDUmxhI89kC2JEWknPyI7T UkmIliCyEsUkJUJuLEwRYkBOqRKjI8ZzQGpEMFLBoHUw4VBNytORyCFoBBSaUhvMajc67nMcE1fN CrA3iCTznqko9nqQpyOVsftXI05xXrUj5bKB80HKtpsWBFD8PhSotJVhYmlNf05IG0KkUHdH2yJb T6Px7TTbbNv+OQ8Q9g8WwuCH0BpraJiQB9A9kJIskgyLISbYdAioUkV4dW2/cHg+WMRFskKoqPef CfAHuVqwjKkEjBDixBXmwAbg1AGEFRTylkMlEmvGwGWPdKk0UDZUiSWhrBhymQ1oYSw3koa1EZTk VtdVUSlSlLS7zeMmrtTt+x2MA2W0Mg1pQA2mJtjQydrcfC8vGeHLglIOgQCojMOGClWhrdBFNKHS I5lBWaTOE0N1CGY3mkzIlEK0cGoWNBGEEtRpLMGmLAgXqaWbOoYtDESBNoGoamVJnAFINCvUqPWh 7CJyikWLJLZEsWFFKUpSlKULFiikopI0h9xIh559Lgh5L8H0BSFJgozPKSKxDaKJXgqhSyAej/tu ELWhGf0xKSvNYG6BjMErEfv41RBiawwt4Dro1M0BSw5LTzfJUmHbiZTtqMqeh7ZJc1lJxrrQ5SCe BNoGhBCpuNyb1yGBg4K+Efpa4dWxN1InX6xN3M4KhwQCCQ0H5n4CVig9i2USnyDVGG3BdxHAoed9 Z2OV5pw7kUPSjhIo7BQ+llQCSIrFyHqoPYlP8JfKO6UR2WGCyzTI4RNksiqsIabxMib4n+/rh4gt uVDcG0YHNpJSSli8qW4WFRCHM4n/SIa9pEiYsuI+dr0SyHVPGi6UdTkoNorRAy6Uh2QdYK7n+OwX sZk+LeYQueaBIArKVckIQ/14d6AX8juTZfkIn6QRGPaCAnenCAASQQfF5v9YjJx1MfVQ+secDESo F5q//lO9+8v1puOe57w3Bkw4m8JWjU4aEc1CJeL2cOif2pNDDqXnBFphpL10XFV6dygF2Lj+cFmA hszcMh/UCaJaoBgUV8rXk1NWWpmbGWihWyWv3rD/cgqMAMv83kajAoPi0UdRfi+zRs22zb6Ol6Dd sJIj8cUqMIEYsMKYgO2/BW50ql0slYxMLD8WGKZRgo8oKmR2w3jvOR3jcwpFNjYwjQpQp+Q4jlS2 jY4MSxg3KFFJJuUYUU2QkYR4na7WuL8pSE6FSp2TB1h1OCmjUItQci59DOXYMMhSBzHOcQPWahUH yOETWjKmZF6keLbwrlxJGBKI+++GDmsC2fkVbGO/JGIqEqMwwbyTg6n5PGeFJHFBlqLFK5SXFttj UjUW347NrxJovGtbJba0bipUpVj1BvNj1Hhx3CQwYGhOnpwc102eE4cYyBQlbnU1qvRWnkaE/WkD UVOSD9YntRtLDEeHa2HfTzQyGHxwrJ50p2zCMsaj2y+c87O6GGQ/PYsWKVLWpYk99RNSxbBGiHpK SlyiA4AlkuNAZYikI42LEHm0JPgmDNCWIJgj/fYT2pTnI+PEep6lNA9xFSVIWySohNhUYlE/YeiN o7oczCjuKeo0BoconR12/i9CSMnOyJ0JO0/ISgSzl+Rb74D43KtZI0RGhhH9nXOurFERx2xdFj2p CSRUOPVR6HrGJgTh+uxzjZ3unD3SySQZ73ThqsyPUj56bLO9Lm0ZDVh1Mi4w2yJllkEem6RndQDc XQg4MXjDj5CmSaFB8gwZE6+x4p5vjmJlSrVFkixUrIrrks0TTKxs0jazMJWVGRJZGFQZKGBkiZlh LYSJIiNKxMXEaYrUYhKekVP4OwTZhsC77CbTb5mw2EiHFQjmABAfeVlmgmLG5VKKqTtoIYDCp7MA hskFwQKdgykGx2ztZhXLGiGlqmhCysJoQvNQmgsEiZw4wFxw/NEzFAZjMyYwiyBrIwP4BGK2EJk6 RKdTLoCVUzDUMhhSynAVTl0LE09eoGuaQokgnPqTevAYeQQnDCTSNA4tjecOntya3K5axlmZwxVq 6NrLmR11AjsKmk2yaYzbqbtDewpcTOko10bDITBJLaEYJZSIIOSCoC6BAIaaY0i5jcuJUSgLc0o2 HI6YvTNiq4snKamnRbeSN1RgbzdCZBLJIWJqWG6CzqU2RIUTaZBhDlzWvb0dEBN3pntvkbDvPTML HEk1GuRQyHYccTiollfDqr6L5/4PnvLzz29vV6QIQmSQhGEkmqlp4vnS/H8ISVmskoW2IG0pvMZB vBhdCMKiQIqxpuKpRBFKiCxYSeoafWxotooKAVfhBPQwkkk22RiAXzxH9XOZKbw/8OEi+0B2qiYe whGYJE7QwCW2sPvPEC5E6wqfiBMg36RtmpGRiSczSGkiUoB5BfMUpmOwr9YLqhg0A69Us2QOdlyD 5UWgtAnmoaLEroykcGAjhSkWYRxYlA5P4lQo+87GzBqJEg+yeaX9NJaWJ1zzeQxZZRT2hx6UE7FZ IgRLLSxHSBu9nWCeJ4BtIWOUnyyUr8qNnP7Pb8LSVVi21fsbor0qxKqNOLMHln4fBG0NAqT0Cowl KSw+t4T3iWhWyeREm5GWJpiaCxMUuEbCbGus86JJHIh6S7u4O3PVDvMkE7Y5ImKUotLFWQqrUkPZ N5kjxJSHmRG5h8UhH0jmTXJT6n+rn5PJI+Y6Si9hTSEOpHQRZCLbUgsJwWIYhIi0o0oQEKBE5IXw IHOA3KxUcCRtrEj7ExOVesK+RVmuRIajlYdDoYSxh+M0N43ibIpJ+A2h6ClHBhyjRwSmjDcpSmco U1hJIVmpB2N4QTbu0bNds2/RqPtNT98QIe57hZaQoVspBYwGDGyv2aYhw3nKwvqA+hB4IYA1kW+Z TTcvtXXEUIiXK5AYv7KP3x4QMfls4h8CdH+rgdc/IcbV6mtPIbbrZkm0w35tpeNzO4na2YbNzDEU wONKC9kjaBbJb+hdB3oNmTVUHGpnb4kjyjx5zXm/XmuiGM7PTelXnpxjvfiAPNODMEQ+Y8IDfQUC F3rINjoQBDQUYJsiLj4r3G7lroiilRAUuCLyJFLKVQy6CphuCRFxupNjQRANbYZIwk1NcEUcTcx5 VHdT+n35OXJZjCk4dgFYRRePVlXI1BcXIzSc94gvot0UyCwZIoaKsU7HE5jOaY1wZGuJJBxJRJG+ uEaja75lZMHRCoiYO4yEkHFkdxWREebAkUQ5bwcLATPCWGTlvyGgaQgjEVCKZ0DhMcuWPZqDkASM VIgo8uZtpNTgZEwJYUEW14CcbLrT2QCBj1AToPDM+24bNjsG6BMSzOfnTlyjbp0i9qC6Qco2UZPL Jx0F5r2CtEm+ha3NQTdoF5c66UkcGYWxoIGU4Gm6QJO4Nnp6HOqbJVORIm7qyOl8HJeO0ybY20dU /rPB0TccmcR3eHM6G0jyuFFeRupJO9EDJ2YdhDeYTxzvshrbJbzKSSdOdndl3O4TkcdCmOrvtRk3 6HAStAmWU5Om1HSGpk9nmvEInHcFJoBrwS7DCsPLd2vJBVRDazjEhNaOU6OOaODwIZwDgzF0xDSb wNml6CxmIhsDDQ7QWYSk6olBIBoGLdBXenSGycqq3o9b2zHlHT5tTXkBB2mGxBjDngEW3XYOYpUp Uw6TNIsjGMklWLU6I5gwiPMoDcBvnTs0HFengG5bw8aWtJ1WD7YhjwEksOUx712NqVszY4Hlth6L O221gvQ7WcA8TeHDy99gmB2YjTyHYDujUIpwl84UxK1VbdcKUYOJsShvCs3V0ROOiZDaPREOUW2B bOgJio89i5eDeD56JhhaESFshvDKhEyxnAJPQ6XlqOHNIzg32HJJW5uLLPfhkbzvPRHbvIJmJxg6 wo0dHNIBM6pu2tsbYDPM0x2jiUzmJ5b5qNpwjx7o6HYbxwV2cphtuIDeyGQyZjZjFszRIhiCfF5J TkgTFI3HrwHv1XGvAThsPbs8sU3kMDDQWFx4MCEKwTo8wzdK05WMDWXADP4soZ4Id2GbGMYjJwXn GOZLDLQcDCqaTdt7hpsGTLoQnw00bPNucDuHY3pjw10HOhum31TRQxXNwS7Mxo9Y22sx14DGGTIZ nKc3qaIf0Aq8K10rowjtB45SbQwbqp10ojJ9YiQYWwk+PeCbsQ9QTvZnj0hrJ1scpSMB3OmpCSbN pjGJEzHm3Q0MIfhbv2TYwEgW2Gi7zonFLSOQgkopIZTheyzZFWtMjbgziE6TdIuo66nhn7O53125 gb9pHtukHThbQoXTs7IQb3DzNNJOQ4xO5ryyMrw8nKOMmc/G+PUw46HYNxk9DOyBUP4H6hig8q25 bFHByw6wyGOlToLNBTHSEtUObw3BUhMWzEKCY5akHKrzoI2aJceGeEHQj0g5pjotVhbDXDBNrTaD qAUQzBu6E567rwQVkWDoRdFjpjwmIqUFDDIkYVS9KRN1V4Xm5tm20mMzerpinKmtMqQsjaDGRWME mbDhEATVIFWNDoYoIcB1vqosLpCkgoGmMf5DOFajqHkBM8GOV6KZLSuuNE5EkrcQ3PZ4szODPO4b g6cJR04R2M2GnSHRoNhtNILY7KjiJ1hgY22ZN/VrRiW9j8B2p/MkBslyOgdhpvp0FP0HYg0GXfyF TTpjA2OKsYpxxWNIjUjnsa1mEl2NcDlx4ccblRl2WNyGfcs77SRjcY61O3MwmZwp9Mafds+rA8SM NMJhxiWOmh8DBtjMTvC5V2NxthxbDQN2woIPLTiGuLq7QHfZQYihpFQFKIgl1ituVjJStVIFK5QX JYkyTzaLRHH7MDu3hwbwlFDkPkswGU6/8w1eM6jlrQqbyIom6IkioFRS0C0MyYqQuVE7I6ks6atj cA6rNeXsby5vUU7DEwqcYhJvY4MlQ6SnOS6uxu1aR40VJMTHBOKZHBsozDcgl8kziVHz9u1c9jeF vi5QeMgDx2D3gUwKNgsvAQUoiUEb2KHkmTnjOK1NGbqR5HJTM2ZMY9MO7bdjnWoKBnKQZKFgYL3W FcOoNtMI6I76E7WCQ2sTdEhFipBsom9JixGoqRqwmlKipYJbEoBiRQulKVCCujiTaTaErJUSSXa9 qa3tajQTEWkkWSQ5zEEjgqSdYARQKVImqGUaSMUIhFegSBMQU55JkEdgqTsREmjAVChFVFoiAhmM IwjYJE0B2UkjCOdRKHM3E5InEDlOI2IbBvcZ2CBgcxYdFDcC5C+IT60OHAJyGt/JpJAsNQq4pYVQ qlsTG8bN4M65I5qPrFtsPfkw/UufFts8/greWTF6B4AG4EijBSQ5kBdFDgQ5Fy1U2siEashqh/u+ PjRHoi8qWhy67/L1+8lZzWXn9f5juw7abbXK20u+7vUDMOIRhGSo0QaNxpTGu6zSiH0Y7y+ivo2H IBOKDwUXugKg8Xy80KZEgkAGWoiD3xYk4STf1yIe6puHr3CdLKo2scWTK0bxYjWTawWvPYIYoWKU TQBGhXxNUHjXGuiUbBtVOMUN3QSxjdqhrCFKSaaDIMqWHVoGCmRZm2VFkxRam1TAsaUkrA4JiWSy kpqTIMaRgTJElpSRpP7dNdU8sBC2BpKaI5rKUghlMu2aq61d8K29eZaxsvKtwZgDkgVFZy81GCl5 WOaClMRTIlDFSPIuEg5GkFMqHYHYm9NlCAnEULoxUhCpta07a3qHEymCCOpu0IFb289ybgtyR4oz sWL0kQ/k8hNN/vHoPZqR6xSw2TJI5x4UPj5vTVjuqBwJUWH0wDxXOiwOthmmVsYl2FssLawUXZ2Q zYpUcBYutB2641TIarTwKDKkQTgJxeKIb0i4Ve0opDTTIVTIwVUensTtx+atdlxmG2Y2U2veJ2oH kCKqnZAagrRFgesLLGyI2Eta4w1pNP5q7Wr+41bb+/KSTb0um/XNsbV5Nb4LaKuzUW3sYWRFuvdb oy//AFI/hLzRTFCgiC81t7OVy3aX8s25bFFtXwapQFkBNkWKh5hAgEVIKk5UYRtGzfGbpIG9tl1v bbaWt2UlDA0DNhbiIrIYxyLLgGIjIqaF7zpJJk2UNLC1JbEjpYmq0ESQkEWHOKNIKiMulPSKPCCs lA7W89Jyw6NwyJPiWydvfq+HzzR9SX+oWfEj1nwiPZPcifDMkT/FZPhJSoxCCsEIBGBFTuYJqXSt EQN2a1J1Kzq6mabbLZbN/ZbERulq0KAhYXaCFqxgRIoNWSMkKkJNYYhJYkKkCywJLElgQtOshBlS SJ+yyIHrWCSJ3qn4FfRR9cokfHY9BZIH8SCtVpS1b8La0a1vyKrbYSRvU1SI7XmqhUeGRJZQyWSV l6MaQ1mCpUSpKW+EMkyIYFlhYgUYusqr/xtSEVpUbAye1FkW0NJJDypIbc03SE1D1ljYFYvm4VyS 7kuqqqoRNUWGQfSJqkJLM9qotlValWiom4MognWUME6L54hhNLSUK+MXcHc5SgYECBBiUJR6o2EQ 4nisV5Kcys9NQKpBnp+C8gV455AdBZFoN9+/HVqrm2aJ1mSwo+HZUxcMbBa0XQS0PpmMLty0Mwxh EcN7OtYWOdaUli2o0ijMyYikpFkKmqmJFk1jNGEYVNU6yyWXRmXA3zGrUq0bViMKZaeJDU6HY8Y8 vUNI0mChMFkKSKhKhEjGhiDkKbKETJMW4JJWQoD4qoWFuGMiSUIWmsC7mLbTGC1TeOk1FpMOkQNa KZpd/7j/g5OKsIpwD9u7gGRphB3UMFZKQpA+3iTIowQ9nu99PYQuEAGiAehpWiHeNEInvhbYhD2n U8FOOAHkMIkJFBVRYpUsJ8Ei5FCFskFpUYESRVH0SRRpIooQWAoQIAyIQSAxIjIqSKqecPBG0os3 qJjAqGA9oeTCIkDfSix1XuT0VlieiojKk0awMZiQ6kRtjokYffWbSHxFkj8dSMiwjLfjHVF86dbE CMFixECgA2SLYpzUnkytAK2Cu/s8CNJ4HyHjcYDzCbdyAKaknx3z+BpXgMS3GvMDUfgk1S1HDI2R r00iNjapPjJlFmFiN4MfPY6R7pOWNJOs1sNoNjCzJslVaWhStslo2NtJW0tS0WhAGhSKp5ExV2BS hX2QfaxXIYCSxifso6dYkbFIk3URJMDY0h0njZgXm4MeTFiRKyIJQdboIdYNUjhyGtmdFq7TM1Si QZYDpo4BIFWlphXHNLStLSq1KSfjrsSeQMhruMjMxnDGBAgZU47jVu6ZTFiYJeGa2W85RgyGaL1M WbYqQIZSJS5SBBIuhdBqnEgYbI1wFcs2RvNbrN5sSc4uRCwXy/6PtfajIck4q8TQisSClh0EwnTt yTIuS4fK/yGu2cDuVbJUjLI6wPXK1tGeawTide1SosDnGSgiUQGSwUcpFQjIykBQeAvB5TvkN4cQ /+Y2j38jBus7WmWtMTItWTlzSHpk91O3sE8wTSYUtVFkaRAPO+BGQuqfhpiKcy5G16es3PgPSq+c FiohEARgrA3dYJBnXCR1nRGAaxyOYiQAI4giHRBM7p0/8HRHUZAQiukX0xUOYWKYLUT9O+UE+HH7 DmBnUgjyeXHBhD91HALEB3p26rFjLecyp1ca13ctNpVNpbWgpBOSjp/xWAlgoeHelAhvFTRK81VB hAhF/cf/DHpEOt6n6iOrFVA5vQcvdquaxy610Nsvnva8vKF6XQ7YF2RoFp7xP2sELhBDsP+UWxh3 u54dpKQS4KK7qAaYvUIvm8ZaG5kIWQj+xSBMQd7syR7ujs06PZCLv0qaPEVE60P/mJ0DKY0UhSoF URKyWljtkRHS2xEWwQ8TJHVDmWpNtGtKs1paq0RDatyQWCUrRSxGhkinrbV0AD7CL/ztve1X1fcT WyWKmtNjJau24Ih3EED/SEg9AnmIRSKSLIL0xUIkDQgWp3oec9vOwLLuSS+9OwRF1XucHa4ACxRP /gA/Uf5+kA1UgexRR+dTm4AbCEIh51CcofGwoQYodORKf7NSlD+w+5HxsALhA+79+BsWMFOfd44h 7ZJLJIjZO0KZE9twdW0TLfawxSz03DYyy2JLH9V9kk+elobxqOckhpjE959EIf/VnyPlSP6nI50r FKwf0jELLDOx/SsOsLOoVCxjaWqKKhB81p3AsP2xeMc9yj3EAGEUIpUgY2uzwTIO2oldwkwJ+f2a WudpiY8LwpsqqsU0zGVsmoFsboIMGIXJMWKUQSMhE7BqlhEisIYGFCVSiSFRDIiXKtvcNw6ty2on Euv38/+E6CQ7JRvybxGAgh7nJfBVKQOCTsKK4sSTIkxhsk0iSTdSQO9cs2qQG0m8BcKmpJ6rFkSz 2fVGEUoqkqli/f7pm2aRrZVlfo3V2LNRE02KTJQ1Js+la60a/vfC22RNlSlAf/Ngmik3qNivKobK QFwRAwMUTkvBfyOvxTAA+1AEMip1+0PnEP/A1UGoUkYwfkpKEon/K2lt+H6rfofb8PoRtNr9jNyi ujLQT+AhiIWFll1ELCyGTYgwSgmYRxAGSoigyjRsILBkZI1GRgVYSgkS0ZRSkpRqUBu11M1dqaik 2pUWlJv6QGBJKqJ7zrRJOptkbeKnKZEIgUG60u9MaCND41/Pexpo7XQUkZDxbb/YtFUW0YzazYzb a99W+lEWkkFcpPan4TH8R7n/SWIdT/lPwRatPIg5FkFS/PVwymTExKLbFXDDIqRYSdxD+uf+Zt9w 9cqkqSFWJ6rJMiks0TDR9mdPdVegxo45HJCEvy8a9k8NoiffLEwthaUsKjukOiX4eznHdZB1RGna g7JFLLSqWNaUttbFtqU21bFKm3hOR8uBqPpqIiWoEWLKibJFkfc3GCFK0FLSlECkPypRfCvlFJSm klSyF6u2smPVEoFghzhyLEf0wP4JFcJLQgwifCIj/hhsLRDEQUJkSkKgCUJdCrgjFBgxBtCB6UIr cihwCZ4Ri+DJVlXFy5fErIpQ1LhMsFgjbGggXMiUDIW1gkNdrXXV2lxMUo1XaUc19nlUWBFkQY+J wg2hAUSIgpGIJKsQlSTwKjB7n+xsGnFu6UaMhOSNhUf+liMI7JI86RGoNsZJy/UduhORsxMiz0Hf Irw+fsROQfQJUEbuatktLKSX5bzUpZJYqrTRTIqVlMLJVZqi1ITzw6RuT/OOphJNFBvLEUlkkrU0 RfJEP7wiLURQPGCY5vVzHcBeOpDoHsIPWEe1Iu5dPI7h0RRo3qQHKb3XdmECJa+Iygbdawi4XgHo BNxToHYa+sm0aOyhDgI4WD8GqjVp+khjBWrQaN9tazZdIpdDlDTHf0g/q9bf4XsP3PU5ST+o/t5d hu9J976XeaNpkWn/IqTSnFJlThUcFjK1GjMsWRQbSZiI1ZJx/L9xxOOBHEh/jufg7+8NCPrNnvdw HPgqBvSARBUiHSq/oiYPWe8X7VCJ+gMi+REYqA/4RfiQQ5fTOoAO8d0hI9FeMOyGHxXy2hZMQxI7 QkpgSaLC1BHxyLAb2TPfkK+QTAsD9gIHx37/rx9QSannm6nkzzt55kLmc4xioFTGKMikXeREXtA8 yEAkipEYEIkSQiRNBpXtD9nMWwyi+9dVTmwB9yQQoiISKgMYnQPwgO6yczmnI+YBPmJYXh6masOu qYZ01mqjKzlBdyb4mRsew+B3gONwwRcwK3p8m/ldySTAKGmjAgmnJ1DFNhHeh2hzVFEiIcIInev/ bZAeACLuoQNgiMCIlrBYHoIUCwVIFwFfIeQpSR8BiD4vVQHEV8ZDYT3e3c/WH0HwD1seFMKUklOb xwx2t0k+yZasmwZSEssR8IqTkWTUyNjnJjZTmbRy7Och3gUmobq+PdRWgZDTCth7oFYSAySCGGOk Gtc2uCBwRYZiPrC4INIRQfMhbTcm+goQ27v4w3GD/KzJg2+jh2922Jqx5PwLK1jRkVbFLBbbbB6L lGH+WVqYibdt5w563LM7X/xXgeZplOhUKDoi4Zjngf8DGsCyD/o7zmLAIk/D/E3STUKkjaoilIwY f/c9v2vth3VegPQnbuaTzEF64PjwtkWeKkm1SPVEtjawxmEJqzg8qdJNR81TXreiV7sox8XDginF ToBCKUn0+/r2BW7vImQyolINHHgO4F/F8xwbADzQFt6lpRQMpFFd6wFB9wfQ74WR4I0qNxBBwskj B/vnwH8+vxKTqB9kw8fhyT6HVA/5JRJ+GPuGRJJHeUkRP8TkYogqWRIiwEVeniofOd4KGicQihzD WvGFaogfQn6I/SHR++5ZRyKMNrhmrMN7ibWNvmbNaTQ/HiRsPgFjdGIpJ2zZOBdRbJvKKtvpZCjM ahe+YB/DAYMpUHDd3tHka0twcaJw4Ydi2FbKssk5sw1yZwXt45wyMOI5JujP5NJFstTcbym4svfk 2wEWGRM5t0TgHC+fEjlsxhFEMCEkAlgDS7ChyNxeqzU46mRubQuR00jGGu6dJzdYaIbO7ci3oUGS aYhSlBhwXYEUiQDQJkzB/jXUsaOzEPpKymNAdDvMxy5gM7cQtFs0DUDfe0xHEHIwgMSXRCtrwRLx jQxsBHKb4g0kYmVoyxLdFaGt4WDsQaoLEtmEJFuLBg2XvgXEJYFbzOEtKGC+6Ic43MEJBIGzoQDl ZYxAfA94UvGeudRtzMctyaA23zPhSvelKZSlDym+5u7NNOv7c17Tzxkk5UdN2DaxiLLSzxyEtiLI wk2amUqLiUP4ksSH6/X/1stet9L/d0dHXynpdiRHSwjFIk893pIid6MTf4mI9zu+4iI3KST7bExl ewsSZT/s2RGQNVfpahdjZH70az0uDPwT9WQfRI98YkjdRbLYpSqlLVkS1EtlskdRUn/h5D++VKWS FiyHl7Hy+kv4j0fHCe5IU9qQSf3IoqqUaARVRoYFgUOxpyEeqKfWsRB/o+R4Aiv7YCnyCQfjA6kR 4wCKMnKAlCMEBT1iMRtSIsgKd1QjpMh5rB8aew9CQR4J+NMJSfen2NE+cuvpn33879/x8Qco3jKg xRPtvZ/2z2L9Fty+YOc1UnBMj7qA3kC8PQlIQHOIGQwg0/fptzSWA2bG0W1eK7+mwZCpEsKkiLR9 1fBZEicFGhQ8HEIbyQQbjENZCaxsGiLY14rlnja9ertrXk29CMRG0rct/zZel6WjNtvSOGv4K3rj ETUCAuwgxEsgrITSja6uqEkmrDiyauZnwiRT9kjIMsIJ2WCMpClWaZCIZKgD/QsiSRjGEkIVj/r8 Rh+erVJLZKhRYqyxCrY4zEHwqhVkRGimqskVbIQTpY0vcEUG0tLBpCXKJKLJ/nqMlSFSiiyERIrB CQGKSIqWBEQoIqxQqLYJJ8tSSTJIihRUkqZAwhQO5HxoYO4BkaAUCPPzdvbX7zzr+z/if0TnYVfb kZ9hGMWbAmAwedElb5YAGB98noO5eSQncQFP+pFUJP+vs//a/j+H89WCr8cET0ER/rqqJoS2p7Kb pjiEmBx9NL8+AwsuZiFQRO9upJHWIuYMisiCGkaYaTMsgI0k6IUkGauM2Ykg/ugAf09HEs35zomE UkODXxcDFqTFJwR/wowW+uFwEfJWqLlTANnlvoDfgKgN1QPog279bCQXogg4dpDCm60ERALTO4Pq HeAFiEJa0wMAQE1DU/a/uC2yDwwrgMHN/MDydg94n7Ayem8W1I9Ts8v+PSPf7up3HM47Osdm4YUZ kj8R/k8Bv5juJ1WT/PFgG07Lm5mNo9T+HvIfzFEk/zQqKFSkLJI4IRkHnPrKdDSJ+EtLVqWLKkss TcBRTQwn5DAI4KIhSUk1JnHo/j9jmZKSUpKigdRHXg5a0jd6A5kPAuDNUIGBCYC9JJUEo/R9Es/M +twkJPEog6kKJOc8SWBYa9n+JMQkCMkYCyKnXyH+np592Lo3nC0T6SrZSyThZOLILYgn21Dtcjkk nfCn+t/a+89jp3dZ8SNR852B5llWKPk5JYHpUIFeqJ3sSNMDxnrwPXhoNSkNJQIEYaHxlobGgOmi n0O4PgPF8+1/kwZgLD+sA3hY/iPtfqD9wHa7U9ZFKWht0AY8EINnFi+8KH2f1zyMnmNE2Q2eh6/V MpZV//mKCskymsgxVDe4G/XP/AP/osAD///////////////7DtP3gAAAAAxy+2h9ljStTMW3tuSl Kvdu2NNNJFpibABgIKAAFA1ewdIgHoAfRU99d9OjsKh3HoecADdKPs+AAAAAD7YB0ADN72+3u5Dt 56+Nvfe96q7trqt9ah0E2bMPOvt332vvruqvjl3w7b0PoAB77PoPUQBusAAHXMfec3luApTQB5Zc nlrD3ruqoDRrNjp5OQxNdBuw5Pob33t4pVBX19OKVtoEifSsAJASRoxQVJLvjaDoBNl3oLc8AB6b pnplKCVB95Pt3NzgAAA6kej6btiPvn3dvPWx7ik+8zeAADruvut9B7y9gfAAAdz3eO93Hnbx7d27 mN9u4GrTV2DVTTA9ZoyvdmtZ8A+tT59jsNmnoAOqNZ9H1wt7Pu5vu919Q+gYPrbz7e77HvnuiGVm r3IIrk6iPa957dZ09fandh9nXO93feXiiD77e+zu91M2AoGlDcar3fekB7k+cdaSoJ272o9V1kNB 64u+9xLPj77wfNvPVNmHu73u00egKJUfbQZ33geQE22wyJCRFe+94GlN7FAAUETl9AzsAiAKEKfW +g160BNYoIp7egenpQqgBQtYE2DQAJEPdwFAAAAHKOqXvvvvve+LO+e3uz307b3n33B7jL4wH33y vN4Ogbx0J7sxvH1sBr7m5FptX2XrbdzvmPvdfe3ss2zHXXVXW+3rczZnb1rk+9z167GvjMp6YWR0 97BXT7b6efTVo9dPLTvXfX3Pjd77jmN7s61FjLZJs0UCVg7std8PhKPj3yGmF2+9uXo63rtl3bjr Qqjt1d3dwBVL7z3sZ4F98A2UOqvkSfT3ba9d90qreG2fAu5XH315z6h9tiXtty2bujZjd2uOUKCT 0bfSSvdX112NJb72m8FtvdX27C9h75et521bNd93l80t6250HoB6SdBqnpoI+zR2z2+HQp656TkA fe2bm57G7nxR9tvnothnyt81q5nZrs+SvDms3UImdHbXtltyLp73dvO6B8+hR6oUuPZsKp9ix1YZ wfde3ec3ajNt0K1110AN2O1KWbsbrn3mAB5vbAl0xO98DO9912gXMGiIRu47tlt33sovteb71zd7 m6qGj2wrvXbMuaAvG7nOcnXVtpdsx2s9jpV5Smat7rBt1cA1AoCoa0+98O3d93h9FDuc4DdT1zoA az2Gmq9u9e72GvR62zd3ADrWhWjnK3axptat14Htez2qTdmlLZrHW5tptVcHAFBTWqZdJw12Lubr buGzbW1uqm22DuxR4LN82A9enQTO598M+et7HXX3Lb2bj3Y93mvvu9PpPmLbWPAmbbpQz76vF3xl OtUFUpRMMcaSDrm5XA32DptLuCuRzGcZxRKcrZnbUdu5d2Wrh01OaCZb7unC28N9qY94Nafc9Du9 vXXewSggRoAgCARpoAJkAACACMQ1MNBKemjCglNAgggiCAhNGpgJiNT0U9GRpPRkajEaNNNBoAAE gkQhCAITFPBTaAE00j0NFHpPRlPU8U9T9SaADRk0BoIUiIQCCaZBpNGmjUZqaNTaTaNA0p6p5T2a o9JPU/Sekwk2TUaGESRCBGg0NABNA0mmI0TEyTwmIMRpoTBJgp5GoAiSEEAIEymACDQ1J5M1PVPV P1U/0qfpPU/U9FRvSn6o8yoZMn6p6gaDR3d2+KiH7YCrCu4jYVXCJIK3gNQgzAiUgIfuv3oUAH1Q KDzxzpGkDqSD/rkRVSldEgAHLwH1BCghjKQQC0NCESlKFRIlADQjSVQVRQUKNCtFUAUlK0UtNBVV QoUUpQFAEEINBQ0lBVKBQDEKUlAlLMixChShLAqRrEwogoGlSIUpppKAoAiRCqABoKGhiBqiIBKK RoqgoKBoCihoIlppVCIEoKGigQoKJkKGkoKUShJkAoGiqVKB+aTIiVipGhaVZgKAiaaCqKWYSogK SgCikoaRIlUoVoClIkaUIpoYUaUoLWCZKFCRFIUq4YOKqTUjQBQhSxIoRCMEI0MSLkGBCDVLUyDE shArMiGSmSxVEBStKsTVFDSUDQUtFCUNRUIkSEMtCSRBALQZGEKFAswAf3sBK/ug+udG/vcVDGpo pUJqWihaE/gjJSkoSqKQoCCaSloRppoSj6scCIoUhYTrmFLBATQSv/+zHX2ZphpghCmKiKmliKWk aAaBlIESgYIQIqrT4q/kcDe1SEgGoYia+XMJgKRpYJSilpFglEpI8sApMmkIgSJYSFCBkSkpFIJg hiQZKEhWYFdwGQJEiRNAUERUEi0FU0NAlUgREEIRakwkSkoKmKKBoaSqIqViEKaR/5WQpSNFFNLQ 0tIf+nV8PDmP9utXOV/3/4/97f+pf2f/x/4gl9igxdhOCQ6Hb+y22ZfDGRYVLWP+malls6x/3xj/ 6llas4tRmfH/Zf190rNSjYa7paaNfRUTBR/wWFrf8NF1bNhqtAp+bwUhRpYEN2jM//xacyq0VSZn DJ245R/qRgkOWSFDfCHRlPx7ffisNp70H4Tj22jH1+SY2sbiK4aslev/GqRKMawdy/ggj8bOc6Wc 0roWzkixXYfVuU/RDwuq5VmW3AhB8V2CjwiKKgWIE9pQdLJ3CRPR1HblISb9uwM0veFYh1XeeQvP zRgufpLKMLNVIj7TTJcf0Z7GpDUGzVcSzDCd3IaFWBYMToYk1ae/omX7dCd0HeESGJE2Ygn1Rf8J w2uHeP5d5/i9vd9GRSfd4LQ8uzx2SRGu5nezES9wTO/PipOIMTBZXuCJ/ZQLjvmImE+rj/6UW/iJ 2dr8uZZilLrqHENwd1odmvkv7yH5IOUHtVaym9ZcbaB2AQkH4Fu0frrR25t9Kv3SL7Hm589THNev 1X16Jw5JrnPj7Fp8Ym/AYlg5COsLiwsgRo8UfYprr+lf4fbQslgWuywMboNmKrZUpJOvPqV7GtKw XUdlca1zodhUtYqtL9hghG1Xaa98CZGMH74GaujAbjDz+b5gR7+ObOohGodT9vXpiEyTGXD7pg7y 46+NuoPovHFNt/dGFTQvcvMxh5lUhL/w5iDz4dhGfmpg2muvUMRz6wV6mp3cdx+2s1c4xH1+mdGr e/5H98bzgXeFn/X/psVL1nYuF90fVpKgKtBVxa+kXxrpHK2c//2B4caR/fjsXo3FkpFutdS/IuoK Oh8oWM/7Rte7polmG4/Tbrlavw0aZE8YuhQLywBdIuxQ/i5/R5YSwJz43jzg16jvZ49FOYSBQr4J 5yLNwdk81f/Nxvn1R4EUJLmfpilL1P7IS8/g7r6/Ljv/MPlpQJc9OWDlQrf9tXud3NnvJISTzmuW Q+ZpJoYQCRf3X2SEvwQ+pwGcXdfMnwS//9fJgm7YkZ/f0U84R4cnfqzRMweqo7YTHF13+sc4DV+/ sTBmT0QmNjS5n/HL8p1+Lee3sT2613aY8Sk2Gtgow3gf0052YX3UCRcNWI2qtRjaQw5kiMgYi9SM f/7ohHxfXgW1QwuNcb2drZ4K3kvOD99JF0C4jnN0xMi46T+1L1Lr9f4xGgBF3ZjSyil15/yZ/WvO 8Nn8qfnmu8WOUJUbl/bxf5t8KU1p01O6rw8CXE15mqQl/nILufpI6SP5sPcwrnKMI3cxFm9kJ1jE mRV2UuNdxXWIw63E4cawiwsqH+zEfG9GW9ta4zT95/xnhbn0C35BVQpbGxz2Uc8u1KvK4xUTfPzG haHLf9fj+7XDfiJgtIRD65taCJA+ZRjMUxpae6/jBI9Wvh55Hq+e/QPx+yefD0mvtZX7B1NnPv1W POGOvb9VcRaChMvIg+YMdA7H7/R9T3l+PFCbokNpKrLHCY8DY9ZwGmrTmazJJ/ONKWT67TUuRa3E Ga1Wmj3QGUcqrMxoojiqXLxn0PP4lIzstu5Lc5rIbPXWscwtGCDD9iSu0ykR+PMR5X8mohCYll/i Uo3+MUc3EYxwiECHe0yXibb8QAwgPHjmsjHhB1tWK8+lA2KSVA47iX9egvSU9mrC3aQHd4PB/apX dTTOrsdfVFolfLvCEr9TOaaFEVFTCwpjLkYuprH4fP8Xu2askeG6ZuLydfGtT9d4rba9Y1lOkOQ/ mt2ytVk72ynKwaVhK6tjjzlqzpBXm2X9ODPIfPK0iafiZQ/xOCZqTqc5oh1+/58m/26xsyRtbqKi STwWfl/Ml9gMltVOz/dc+Y3Vfw663PL+FjJ1wkcJWePnHetxLjdkl4iqHiZiJXeNKmEoarNypHxM 1THkrMcccGO9cRmjSo+353O3VPeXfKsiOav+w4ky+ERcLLdM3gxxV1U/KlK8Gdma3u+xEE2w9suK IuX0gJ9Rsh9aoY436w7pemiNQOm+rzKsb68WL2ZI17tQ9+aJa07zVbqykjG3zF8TIscFGWNoz14W cl1CTWNCHY3Os2xfsp7unrvlVGxF+P/D4+oiL4f4TAdbiG+spHVazWbKUMN98V8aY38v+fRuGCpR toR9FXqdDmJEBi2M/k/j5KafNjp0iOGyzMT5sczOGiOMHQqqAmMSCrEhrN51tlRaSZZeuHKEXBjj Oz1bU1hwd1J2HAXyLFIh8jWis5RVXyQ0ckhxQToUMZStL8vFu3aF3TvIlqWAybI2weAgxl3fjmdt b7ECbGYgzubjer/zrhblC6WfoL09lLijJ2tK+Lld+xiXJZZ2Lm3yQK9xKJKrg0pLu2uzRLMY3w6q TtXHhnnt2EuFhnfj9MY8K7idR1ZoVW7bdr2Py/qquRxyLh0lib/R8Psi238HH+c5IU3GOe13SRDA QRPl4Im/Q1tsNihuhjzFUgzLdLUWw2zbflkNQNm2JljYSvbCbHNsXtFM1ZVVft8jxUVSFosKIRzK xH3VHP2zhTXiXNLHwOeExGnfJhlKwnprQF0TBbyx4uRfaosneluz3w3JbNKnW5fciaLjWz5hYebS 51Ib4N8bQdCm7tahrKTir92kpLAiQWSuhp6vtWOeImUsWYj1A83qbqjR6/d9sfkutdfqapfbkeyz urV8546+iwvLu/H655gr1D331jpJ5zdKJIj0teK2SUhOjohJUZVxakd0SllHxap9NOcNm/bvwvLW 3aYvSNvQso3v5urONNnfZrXZLK7kSWEd2/LT24X1t9vRgQtu55WXpfsNo/ESKA3Cq6syXreriiwZ mY1XBYH8i/iUIw7oVOz4x8TVDwvM4uorEP/V+GrnXO6f29ZPfePVndjxQfiadPwecL1qFrr1kxtm 5FuPM4zOVxh2zisYoysKYf7XHMs/lx29ttMvSY/oXGkKsGEzjki66qcOkqHF4fnLgml3SwwT/+5R /1tPn6dOUJXLarN4np6E7c5wiQMijDCgooKoawk8FH8v/vsv4inulZzVk6le5ieDYQWbqqv7YOj9 0fUpFYl1df7ahyXvWnltzesSxUdMI9bytiPssoBKEWa1Av4TEJt3jDlPczduK+bUT5WMft+dGhV2 7dIl5xEs6VeJ/dQf6VuXQi+B/DlFSjSlmGNvhOLb9/FDjcPFiTa6aOeYKPuzTXbPodbvt/+Jv6Vh oVVgf/wrU5O0rGtumgGgqqEl0MDqdVQnWV5BN9L+HzdG/I+Ho8euXZJoZbZtFb3z532RXGXJXhFv hpGsH1Xms4eG4ym3CX+snRfMLy2T2eaX/lQ/SvZ/7g5/yyx7IfOsFScmQ//MIv8QtqsrL55sq949 sFk3/eDw+S02b11+3l9h2eT7ff5Wf7JfdP5GlBYUHo8XlL5LIWWRokYUkUPA/wyvUPOn71NHXls+ Lzef2zveztPk6H8f06ey1akhfXX/qCCYfWyYIuKoh7lS+0+Rz5VSC2cLpnbHKw7bursOrtaNkovH tZlec17Wk9PeCB7dfJjn9GvPuI9EtoHbt4b+qXwjGMYxqZYufk46/N0YzpH5FxZnKwcyVIq5m25z dfFxYxcLVIKWnbIzeCZ/avDeWERKGKpfZAjC9x1Fd3DlhAUxt+f2R5XcuWu7LWMYxjG9LIcbOCwz NVLPnW/Qu4UMJUSNu/ZleSXX1jkUN9k2uJMfFZl1KE8QGoPScXz6z5+ePVVVVWW8drZfzzU9HhG8 r4qBcu0r8bbr572R/wfNY9e1rx5ghmP6Pwq6+OcGLu7uy7vxjGMVL4xM3dl3frGMYMfrnOgO9a1p Rr9Nan8LwDo+gpRXEbkmPpH+b+yYwuNGalddXi656zCJfqCLnqc9dVKRh8wR1qtVGc1KRh8wRGIu 5hddcbNKuusxOcvnL1nOZlBnLmcu1LOcwSjKys5rOc2SmyjOc1nOX989/9k/82z8cLBeSpw6Grxn iWnwxbftsXdltsvp8f32Fq05ZfXBetnjjs6uMhcs1zh3XfNbcR8Ffw8t0IKhTacFPx6Z76H6/Mu2 vT82lYMuxeviYuvNunpgdCkNjFdnH5pIUW/o7e2Hfy07srdXXv82M7xCGCSfwVjh03X2Vn5KDSQ9 6lE9R1XY7bJ3Xu5V5O8c+9vm9HX8/o8l3qvse5JUdXZU60Opunn09MjqWfRSlKUmTlK7uy5u3u7L u7u7Lu7u7Lu7u7K+riQ0f5J/q9NwnD719Klh0UNrp4vWfC6/Q+T8hsvmgrYQWI3qFPGWFpb5z/6f qMI4fwOx1met16z+BA1FsXuFNkj9hg6/tNVLv1jlxuLzQ6DcWn2kSRMvPqtX7SpM1fA38dOfjXyk el+2Ox2O0hbd9ueBguD3vtmLCMKScg/YsoTgq2UpOT2RitjE1slGF1/4Zj+jyZd6/dvaW1hVPo/R cZhqiCMbylQPoWx/Bvl0nJIQWS5PvNfZFVXhs8p6z570ouapd68HJKjL4KBNer7Oh/sUD059/z4Z nu9g1lijc8rtcukMGVRm95ks6iklCT9Dsil02clZzQtPvOhAZXZgRVFZUGSWJj0r8zP+fjyzoEhP mtph9yqfU/3mviZnWSp5pK/zR5enc25YM3BtWNiGSz61FyhsUjI5T8+9tnvLLVX04YveuTDO164i Su8IiV6yg/2SmQJ/X8Xv6JR8Fm+jx2Jat2Uk9rSoUI44tb0TfZ2syx8dltg1DcYoHNSELNCP19Oc VVVPji8ZJc8FkMWq0bTyzV0g8vP504Lh49wrAqqppOD7cMeJu5/DHDhb7Vu4jJs5SXpgaRlihwVE TDhZSuDYPkh493E2YtU3vu2OvhW5pV3PLpnDF1nq2PGzODCrqx5ST1siJ0rOtaPA1ONHFNEJjcJD LuyeCziqvtfT6SWbNwUv5EcH60QkkuOOJUenJnpLX27u7/FocMy2K4zQZRVu+RmULfiV6V1s6aZ7 EIjdMHs29sIVatyQtMaIyPWboQEhfnwvHVIxkDMdStvazbOUDOLKbOeEF+616d+7xEIW3aLAxKx7 12eYk+s9VfYqtttaFVoPDCHPz+L5RWwtsqp9/Rfhhe2yzfoSJ9FnQxoLKhLfWE6xurosuDOvBmWO Gww0w6b74JrDzNUMjbgCqCiLmGKkF732ZdvVpgZ8OhFzt/f36QfudnRc5BBFKaQdBXiIzsz3sbbV +qF883gijXy2JvBqDCEPTmv/U505/RZ5PHrEvI0l1bv+oxs+fzWz5evo6jhUMeHIVUMNmkNtvKVf NOTjJ8w0qnfjZmPt/p7dcPU++Ws/UT/Iz3G6Ygg4nbdLXGXl6+n+yXu5MKDlmZSaogy96w0GIfu+ Ffaabff7+zM3vwIQ5ShGh7+ibqWtHXUomex4bOEMl4c51Z+2JpEmSlwunfGMqGcKCoTtacMlIqLm 1L2hevcz30b2zzLZDrOydzxvYh3bvNpFcm5ZEFU4JBnUOezPgmntpCdsDhE1g18bteFEREvf9ubb t4taTudUFUFMt11kLdCVu/WiQnt2a/L0E5/Pk8hbGp5i6/zx+NpUU90IdPTscoJy9eF+29HqbjJU Nq5qtuXihY7VjZDWI9Pp69j2JYS3cIocO9i7XY87WNb44nRYUqdVPM5kssm6BeT0eig5VrVpCM8K Rxan1lkUfBTmEbVCF1/PEJkmrTwj7IIgeXOJ61rJb0PLzU++P8vQ0Xr8vPqazz3GDxiDz3fPeNrr wLnWJIxxj9tzzTmsx1eeln/D9snM8WtHGjn+978+wtZGrMMe+DarB+sJKnp7uj5HQRNS6h8ddOxE QIgfySXblKfwzf1et+Wz+hQs1VeJj+/0edkhArm8BYjHxOPTxmIt5Q/AO3x45Z7vibNxbvDBMLCa PfZYmVI+HTzbpwYhE9xVBrVVcMoaN67da7Rya2JQN+vGXX9mcKYZVqReKdi1r5XGVNqQYs6/DN+0 tLOQXeR62WLUUmYSICwgy65kNJOanoLh8onVQLtq4zVbDA4Lf+zwsRfrZEtDTFmFEQ+oRDdskgHR 4tb86+Y8Sb1wj5/j2C7vHrxzp+Ba2DHtUmo6i+SNhrV/eTZQn88NPj2zc0Ybc6JL4vfYABmIoQP/ nr4dXqLPu32BTggkhIZfMXta8D8qtaoyTePnY+/cwu3Z0MvXAeKnsjbe8LlM7qdd3qyO76biawVV FQ6OxPN8FE7fGuz7dN1cvFgYI6fVhhceM0+OlV36uYHrwc1PXEuvs226cSFqIpm1n/7J/iXLFjaU +Ty4STCOj/THdlHKqi7LDQ+HVn4crByPzsK8c7rknTZ46Gwf0KfKcOjxm8+rR5ljgG1477us2HlW ry75bvZ7ZhEXOs+vFT18H6d837D013wLTmp1nTB+vGr9grD8x3FHymZQg0YJ2uNxxbdY1eq8u9sS ik4aNV8OrgmJd5QgT0+TZDScnXHy02457moeX39h4UtZurxYXd2LXqLR2+EvZsDjbiWLDMIIH1SZ BPF14bVKYn2P6Np3b+3H8/j2+LgSMjmvdl+WsB+PpPXjEDPtqd3sRvap6+rqNhfw9D3+Kz2/Hvhn 83y9PmxuDqSTunS146e7XH/1Td+H0GnMbMPXPiIfo+ytEymRN6WSUTP4qavntbChhcvonCJ8Ssm/ o870WMr/HFs16Px6n6T18/Mqwc8mr/9v2d8Td+rYhPp4T+16bfp057vEvS5y74xvl4YOY3tXDnGF 7T4w8vxbJr7Tm3RF/v6fByXw9Gq8NfflPWyH0HYORK28U+PcYq6tLWWDOfZkpVmJllbT644GOy1Q ot67fgEgYOQq8uPq593oh8fjOZ9lngfH+HV8hX4y/plg2KacKeiqSoXuvnXxZZtfeqqqvHuAlDxn LCjqOvOFX+2Zj6d44T0z5YKcG/RInDDqBAOc7eUtNlGyYd2FpCTCi1pVEgE5ZIZhSGM1OWZmfLmU cRhUbcYo4N7iCJDG2De4spCblYskYxqLYSJEpRWAgHuBSQH9v2n8++D+xM4yCzKZ/fATM+/3RK7V 9fu8bREMxEBdFTdPduWCDpKq/6Hk/rv7xNSWnpJfL4iFi6xCwVP+u96HNcMVe2sSpNrYWVhR4cLP hXadHY38yCMI6jFFOrnyIp6+LhoqwJqnd5LIHmFR2OUuXrl41SnRJIX9UsIqdXrGgTBQXTIGhkf9 P8RLy25xD3fonwZ+YYbO70xHFUHVjgp7uEI2YK4I6oWizy6YwFF9RE+15ty5imnr+3knm4xoWVS/ f3tgilsB7zx+RESMqeS85xN9RNm75yxEIxTqrfn6tPi8e/qVMX3dOzJ+poKg5pyZEASKnnl86kB/ NB+CVNT83qxyHmQycjcmzPwXlo21po5d3Cn4Zpg2ZzFtrTE980rOtR5A66JxJ+Z9mttDaKwOGKsW mkbZ2fPPGsjFGLbDpl3BEaj4vV6ry8SHTDloxg+uLGisrxh0wCcRsDlgNnZoMgKQ3vKUyWzKV3KO tZdMEDiBLMy6sSG8kGxKSDaAkg2q0i2NCG7rC6kaDIDc6l6EHdJrWJ05x5ntC8wBR2h3d0B0h4in m6VGrm6Zm+mauJ6wnEJ1l6RkmpUyDpBRzInN1ncp0hOvOUBqA1rKA1AUAkA2HxlVvZlOPezaxObe dwWliso1ooaKrZSM5xmLEpSbxiTk0+TbERA4U8g35eiHkFK4PoQKnSQI7/JI86cxqaz5RjEXIOhO n6lp6ttVwezzkuDpivw9dDjBBERO0Xp6co+yPL0Q18IlFh2N5vp7+wbjn49PMc+jP23OfY+TNpRu BAVN6qQU8OHxa+7ZvGP8LbcqPOZv5HdElDDvPEiIhuRECXly1nsWKVf1Wxt0l7NcpfP9C7eWv6BP P1Wz3xO2FS/HzOMnHos7DxfRQqSzOySruDxOMP52dmUfyEYkQ7lPAX8eoPfs8ENU8g/433+YOs+X zWKW9vh4WPQF6PS9ynnEsnw2vx4NFeKWLObicYxQCiojHvsLhuwkhJsOprg0i80KdRaRjTg9Rhxy Xqt6Np81uhOB18BODrfFTJZeMUpIOaWIpSzZZrwkhU2MgqfULJKmK1ZUpFSzGiCqJxmro1d4gvSw YKeIuapVFVOS8F1rL1eFU4FepzLqdVhTZ9QYFRKWITvBlsIN5QS8O9NvDYlSWBLCQklZTLI+MyYj C1MaKiIdiJfOqitTO8xbDaQzbMuhELOJy7tI7ThlqYrUKsMkgi3lqy1Eynw+byqtPibIw87Avcvn GE8OBhpzamd7TONLPdPQYBEBhg1IQ2KcpqzBmpvVrBlsuhsMa1RlTu1D5ohso3G7qmnUVQLDM7pJ rHcpJJJAVKQ23iMbu7Z5sMVe8ZNbfaYsRimY0anCi91Esb2QS+WYaKE8wZdxU71qs1VYzY9NOnTv NpsBdp0k2UwFbdZyNjfMWo0Tn5C/mmENpM8RJ5KeMdlPmyx8hAil+QjvoggdpqQ4Qi/m5du0z7cL fLf0knRzB2fAc/CKcMOKDIhqqqcprni19YNj7VjuxjMOzy0obBLjhv7LE4qeiKU8vZplKOfS+uqn S0R4fE8+Xzapyh5heHEu42xcVftVVw3po/w/S/BzAGYgcHOKeOHZBkTukhuW4jHe3FA8xxns60Sx U+dToGMl9J84xhwtguu/malhE8tPNlntkX7O7RGh43ge8ltby461+O5EMxRfi364FGySfUMUEjic BeXMlGhboxODApZ+nboR6Z5lUw9iJcqbFRlBRQeASHJS4MRPUQR5kmQUHuIiHyZmNdNb4e5BTonH +NBwX8nNfdnpRQEXEhCY8f7Vtr5/Tyhn8MNcyHDjpVQRdTFUFF/jSw7o4QVRRRVFTUBSSS1TFQSS UsRUUsTExRUTRSyRTEEyUBASlDEhEUlA1IzFUxVJRElESVDAxESS1NIVUiQRVMwkP9OJ3VAf6bYq QBSIRAyQLQeTBiwBLTRKkxCxEwUQtFVEJ1nBoJoWBi/XBhJISRATARFNBBEN5whgBEzATTQAShIk hSMFITBUwBIVQRJCgSoxFQSxLUtVJAVNRRJBFRCFExMRBFNFNBBBQSS1QxTDBUk0lQURTUyM1MU1 RMEMVFTNJEjQk1BFUjRQU1VNVNNFEsxFNBBCZGUowVAwsxJVDBIhIRasiIoGqkmqKSaJgIEjrhiw BBIEQ+QQYEfDA+HsMTcJ/LmBUHEoYwFNFIVS0TETEtNC0NNFJRFUyVFUREUMxTExVRMUEMoRESEq wVVDTREQFJDFSQR6rESFpiIaSipIkKiGmhKaBKVIv2xiBIBJAd1kZi4M1KQUULBSkTMkEsUUFEkk skSEBExQQQypSQRCyBAMBSpRO4yKgIkCJmCVZFSKYkhggSqCJoiZgKIlgiigpCIaYIAmEZilIiqA iJiYKEgggaYSakiCmZKoCIpggZmiIYCKComqapAY5z00fmIda50IaVDmBwIkqGgWhJg8LJEe51qt sQNpAxojAxlGl2PO9Zb+7eDlAPCJvxa3PFZ4te5C+rNi4xdcR+SHogq6/Zi4kGJz7Nmt+kI68LAG CQIqO2YRSRaxMeMO79O00m+PHYbSOsDkzLSfCTIIqKKCJEpaVoCnXfjpJApoCaWiaCkooH+8/nPo 9WwOCRKKKBaClJevfoENCJpYBO7SmoQjQGJCJI1WEg8guBHiaTdFAJ+kZwjhIB4IV0Qeyd6QcDxN ca7r6YTkeJBKFDBCBVOP0IjUtSUVVPwPtovA8xMGYEavI9LQTsnCHW8+eVyPdgpg8cFq5GiUpTwj IC1dIdSkf5y5vDCKwBxKAwyXenDIxQoKGGgoYaVh0YqGjWInxkwgAiCU2tCWQQoSFMIkEwkWFjS0 pGTipU0Q0ADMQEEVCSRSjBNQSUMUDEQUqEQFJQtNMRSUtRE0QFmKRFmIRFA0p99laxwoIDJTIHGT OmJkqwwnOIZITvEwCICSCCJKg7pMYI0ZUTGBgzZZO8DKEtZlMoRNLHE4kNkgjaLRJLAsXgBXYqc3 ZlPDss4/oyQqDjER+3bRzcJ1gb2H4EyIAH8DP3crykTVPJgtnf862bAy6EC8aA0P0osMCJGSHqjR BM+w5QIBf7gga7UJf/n5+vA1TvJhnoD/4QPEPdgwf9f+o3ahBsX4+IDKu0WjjD0meeHCEru9C86p VhiUXzKyAxkYNCg+Q82D+GQKjrNdmDlxgK8MciYEzFYeBFhjBY6TPD2lfFIzBmoQxdk9cZr0iwOx A0xj2BzIKQkLRoYPPx2sV0GBiXTAd7i49Dp/HPlnzwIlFUcDi4zu7zW5bmag0paQhQGgJApJHE+r SQkh3embNetksQy42bN4TNcL/U8CBIvBwcJDlUDumAM2M2D11uygbhhjshoT9nTgl0b7jMUWw7ww 8TleqNxRoWuPhM4p/DictewjDE54yZaWnpCOB04lFV4q2XpC8IHHst5t5TjibDWLugSQrpltQL8y xoy6koNO6jBhMRSJuJo8q8VFseLpknMmAgaE6Y2u/K76VeiJTIBBbukIsaVUMGU8+c3LUWYiF3P0 OL2Ph/xMOk1NZQ2GyMhPLO1QREHS0cYTUiV1carBegSHP0/x0Mu0qiIH7TC1Ba8P2Fx4wYPp9B8E 3kLv2R+8n1FP8FsQ+csvHDHKgxiQiQmqk6ugATwznB6LL/76Pd4+n6++tJp7vzYOqZt2CS9MTGh7 pksjrudLYsKRIDOooxFhLCp6OSuhDAzRoXUBrMcKShsJSikMpnCAsxaLLDMwcMzMwMxwKyHJw046 SHSmDIz64aKNBjVLybEe8mra7x6wxPDzN97R00Bsh6d62HjQU+v2GkNqLmtLebmSAhJWIex3giqC sXNGYsV4JwJm9owYE0bkEf2sEwYL6ToiIHt1TL59kJ6ss+/uy7MbptvvIyQOSvy3Itfs/FoD4QSo K5LwShkqUoHWAPm3nMHG8DDeJ8j+BYbtxDOTEqjRsoqB2wuxag6Y+TvFMPNI/J7RUUTI/I6eJy0d cLPo+WFJeYhD5fV2cxESC/3GibOM8HcNhgb4HtPuv1agxPxOs6EFM6imlNaqIZbFG4mgfwFDTaZM aIZVATkfzQcFJbUHiiPz9xzddXFPFxwJSqvl5TqOMdRD2F0gbm1AxmOkoEtm8cj4OTeXmkN9NqJI ROApQAUAyA2GrQB8yHjVD9tzMmFQl4Hd04loOtf6Si6N5n4DAH9h6j2PsvVnnOgoiiqjMZQVdh6n WibUUNwWFiPYvaLx7TcFkjX1zQ1JSB6j49IceFBLezI2jsAwNC9BS/xPJ4G7DhzUKHkVtxZ9iJLz lbKPC2itHHj/5gJSSIKBv1oIDsczj35OIpoHiyoqb5C0NUfNXHoXRi6jRoKc8imxUuC5gqNNkU6k UOZFrkrR1dGN0eSbgA1ikgDy1SQgh0bPIzI9/dzh0nHu0vM/A9LwcfLZ37bsFN6MIX7eqzl0iWFa bLOSpMx6EtUyUkz9MzptI7hyYwcg9Rb5U4OcdxQrrbRsPfhs7r6K4ipKr18kx0j8ATccBk36APo1 sfJISNGDXBmpdseTFOckgZ2NVuG3Pm8KPEet7QOAQS4NvDamS4qsV/S0hSfbfeC9IMJTE1Xch1Jq 6nkO0XB3lQkIsGjpnquwyQ9NmBqVnpzLmfHSx9oLjFDUKqhDpWEE0sAg6Fqf5I3fLFNl1jStcSw6 qjgRCd8FsgUHtO1ekRF4U5powlddp1U+oxU03iCwlp2rNmTFI3hejGLJgKtHR9dTyGTmJBRIjULk QI0m7k8ylImzIWc4iMUJo3Z5gfvLTMEbDvn0BxnuvmXHc4l2yQmfdE7D0FeKFiKKDuThvodDui8M iaFiiMKijsHm5kjwVOCbbXiExEpAv7Zc/ngFqQ0MJV6WVIzm177e8aFBC9QNppBLw2LYik1Lx6iu J06Hyo6X41yfxv9vjRAuiUPGhvOabTsIjp2CtUOlUOWkHCgyaJeObBC4UIgfYJ6jsNwkTyCUSzei Q9Nqf/Psw3y8zu6jC5szCnrtK1Iv4lHQb5qGFzPg/pPCGAFjPCZYkqzaHzxHogvBppPsnfOr9nsJ bThsPNuYL6SO6kvepMq7YdnzGuSZYvNDuwd0C8SETKiiTmoEoVIbMLwkiAbSoiim0EQU0950aHr8 Q550f7F4n2/UGeQHoOoN4BlXAWSIrzkEVF/b9JmKlkJCZLRQzqZZW+XwDkZtP7+jUhgce77NSYGB nntz8zunMbc97seoyxbuv17z32wIPjhAmJpAJLdhSF4jCqLRLSXr7MxMs98LcBM/OWV82kPts9k+ 43Mu/hXHEUU57LUR4CpCIc7f5c8m7k9xjqVbyiL9RglUorXqPn+LoR+ZEQI0hZN13JOVmx/l0GCQ nIsHkNMxtew33eCCCGIlrqhZWzFnXGF10zBe2KWP5OXmhcRS9fzpBxpjWqhc8B7heTYVI57W2nP4 CbJZ0+T/5IT17kr++9jOr8Nl2B9UCX+OHzhHWQ/y3gA/0SdYa+Ttk+d/zO/PHA4ZSJZ/BhkDJCMJ A5IUnhCvu+71VN/B/XEbwCtG7rPNW7Wcn3dt9g2JQrVBSMc/Th/qh/LxnnB0kUgCRDhlGRk9zPGs K8+3W/lNLhJi+PG4VzZisZeCVAwqku80/dTTWj38Pv92/duV5Dz6bQpou9GM4V6o5J8JIGcvKetD y2/luDdSBzW26XNFEgIPHtJ8e7E0F+P7bmZ+vg5h2rjb7WXg6lz/QPS9qX/QbST7LkIYNblFDwo3 H15OXdp9P5/wK9P2uUOINa9cNwlrFbz8wgDpllr9oxbvbw25Ij4meH1wvWwYTQ/SfHeD/EkS8Jvq 2WhXWGdtTBWLHPkR9UkA8gOsRM/nXAT3LAcbK3HzYpox54QdQY0gaaMVcVaRseVraLbu6XXsZ6ef hf0erIoqpiD1Qdrbh3es2HNw5Apw/jw/Y+qekU5x3o4ZiWmOpvzSBxaevb0dVybxJMocREwA16FG 0ulcbHPPf6uIKDqJzJ8gNBCJYNK1v/tlEtkB+ApcmPVUx6wS4GWqq2Q0Sh0B9YmVwOWNNmj5tx15 GcmnPWEy9A3rIvZ39tKB5lQbRQoBNHNlT7IMZYYLuuTtMwxsgF5nR0EEP6QVej6s/eQghxXadt/v U8+4794cT0Cc9eqcuXivxYduExxthA7ssNT5X7/u8Mz5DkNDjx9WMlVJJHD2fTOfy0VHCfof0yHP 3oAvzuIJucvr8uZD9LveDsWuiP8v6nt83Vyrbr61GgfjkgtKIQgCSKsgI0AsSChSjQKFKCDQX+7D CFiFJlSqKWlKRoKCQZESRFDA+MnNm59g+YfWfL/D8qNmJA0GcZ0Mi35UQQIqIggH9f+1ucEIbl12 f3wpCFKfnJ3pCP/niIg1UPqtTSLqU+n2wxg3vO9ZT5fRMl295jdazGMTGZwrhWndXc6xGTOnohXK WXeLqca0SXnNRnNRN1rNXGbrEwtXq6zq7SxqM4y+ZucO4+NRWc4V28xjYwx1/2t9zfTpgB0h2SAS /GGGUBSFEERJFLE18P0e/qoIeG20TYJyRk7OGKaZC71yXZtbebZSaG6DSssJrSd/2xHGom8XGZpQ 8LebWIQ71ninzKeP9n73rO+J3+SpJUpSbcbt2KmkBqDry+j/qnNvlt15XtK1TaR5w+FSrDgrxZVz c45iUHeYjKvUVMrWnjLsEzMFILZNhBnZvGpxZkdo29zqdqXxpQi01U7MQoh5fUy2sq4fUViilNvm fcUi9veNwQJRlTrjTXM8TeM4msTZUXBKNPSMQTu9VrjmclDlhWE3DTemRR8WdMbRy3YdMUJm0jCG 3M5znNRiJi50glzdEmZiDDuRt/+7Tmc1ucKEJGk0EuQh0Cw+1aaEb4xvFNavWt3dPuMZTrCVlvGJ xALGrnCtZExGXhGZNYkziYK0PbbTPjMaaInatVlxLJjczrdQ2NWKljcwn1iZe6idUZp2ouqmXdnx mCKd5xhRIlnETlRM0+VmZw+opNWKrFNCS1LhmX0qW2fUVra1u7inLUaUPFK0xjL7Sp2Z0Th20IdB OHa00qa1KzmwlMkwinKhy83iYxUSkql2M1iEkmHtzGXb68BxCpzRvh8ya2+nebfHG53d6lW8FDp4 T0svc7RiXtWIlROCB3q81pVeHuS6cyiU0K02IdoKdpUqUYpzCa9XU5W2Vq6W863u9Zzbynh2cS05 lRilBe6guHiH3lzaqpilrNakhVi7vLvkdZeMthQmKmYZa1GMZxLGUWhtpgNJmSCkrk90ajmT2/Fw xiYm93l6ZnyzJ8VECx55CAbON5DsN+RRfjigGyHFx8HDbfrZxyclX9risXOJvQRvCbeZm8lws2TG nt3ut6yWop9Y1jVajMQsvWaxrT6fCWLyTWIiah71M7AYa1HCTEwFVTadG9fLz6/AqY2W43YqOo2F 4kBVFGS/NFu5C7ifdbQkQko07SsrSSdMvT17uJzdxPOn1lPEOTReZSJUohZp4Wk3atTp23tRBCbc PaEgtDp97jYpebxRKlFLCxLmnqGwtI0sJ7zU0jShWgymMLKNL6RmAKWo3NRIsv4xUPStJSmvTg98 QzqU60mjMTLvluTbjOdzW+MtxHexbe2Nk3iqx6ccY1auLE+MRSLQYtyFgWkXbsh3lYWVCFnKaeM1 lKOzqnVDLMfWQ4Y5Fy3k5Y9RccSWKPh48ZuGnvNNRnA8ZzMra6ZxxOZbtorK6ySbYxzhw53zxhX2 +i1b1O747PwiETRi442TcxnM5zxuK29ykikGlipgHSQkWbe6fGnLTotFYfEuQoQ2YxGlh8RKYu5z OcvaMoyrQz1qZMYcpaTULCYzLj5mCdO2tD5mIqoh81MRUYqsYpDJBpGlOairxmqeZjCMJpWMJKqT 3Sp4zqMLERicu5k07WiM4hJnUoitRjOrjO20871vVRWwl9YfcPozrLQhjKYxcp8kViVcZvK1q9YW ofWqxMlXM4uqMvKu82adRcLOndZSLesSZwh51cqdkVrWt5SrJcFvQ8XUCjEbxauIcyjKN6nazlIi 8rCy2EoShYso9PScf0N1Mga/wRGASL+fgSQmDPPh8S29LCx8Ja3K8FOEhYgCdvCCmBFVz3bjju48 ZSWU3i0pShwjYEJWUbjSx5StZnJqPKbPdPWtvNXGcRqpd7nCzBBrbMwqOP1/wJ3s6xrW3h6RxzL5 6zLVD0mq4ztUz5MxbzGpfUbuWLTZWKcwtKKdS9J1S2oStyKisU0wnxhs63WN5nVb07JlO4t5M3vD MzPjN4l9avdxGLuNy927rMr/x1OtWTnPFpUo3eKbNZeOBj/gb8TbcXwR988xVXDQ+p3QVLvh8IvH KzgpKZ5huyHZk+tVqYfWAnM277BgSdzebvczmpxGWV6qKNYq3epyoqni0tkRssuVQ7zgzKu6t6xO EtRq5xcTm3mdYrV1T1VYubzjUYJWaSw7xdTm6nU6WHkhVKWneMVOL2+6n9zfw/0iQrnK0gxz1Gqm RYT7JslFdF11UYfT3BKRC28YNaUzNRmrVWxrH9flm8A1XT7Uck8cypq4U7XHOavUZurq6Ubuev6C 4CUWmfHJEZ5jC5R92RnqT+jGuHs4jiX0HeNYwc8YgYzi3nLrGpIne6rOd5mnqMteVnMRthgvsty3 d+HM4cSGdE6FuDazh/XDRNvuNu8LNanG3reXtaqXuJZ7nNRlm/LqP5T/QjEb4E5rl+SYjTvCbm+o fT4xcMN0+6tZzd7yyzZeOddrOJox9uICxgseMS5kSRzqC046vcNjWl/JEzre1OH3WIm94fea1OE7 41a5b/KgSIx4aDrE8XT2F3ox4PlNhumgMIHrPj0e9gvq1UOsrGI7vMGGh2+FFQJNyD5IFphANEyh asuy4eZ64nJ4/qhKuZR+yQ1pH87S/t0B/JYdRIgRqMOmEXF/Ye7Ef8zAzaPDrRvOJ4NA29QJ+k2d jDWlCSPQxXqC5Zgz5X7meziLs02myWIwxTUkAkENkUrwj+dr2vn+rpkuDhnb0Ld6vLq+zdy9PZjb hcsbxi03scMne2RxJnCF9Jbt2/0rT7fu9/KCpu6cNkEvVNWjqCqIqFvFvLADKWbG0T9UFccChyGk LGqB+Tmhd9TYIwIcRDLvydNylxip+WZOGIr9yFmjZjjfsthPNhdnPbZdtjpL1lpKA/0powQ4x8sU kGR5FGNxpu2ZYzHWDpE/xwAH9HfxxMJucuzTtwHQAKAxIXurYwZdqRk5nMjMW9ukIgZmPL2bj7YQ SoSf7szl/lWkDthws7S5ub55Hsj7uGlhcpnCgvShRF8e4qFG6RUAbBK0FxnOVog4TukVDV5RbzXS 8cJLkhuYwEcEULR6KOISPEvIcYgMKAo3pJYSyWPjf1EuZxPIMfvD7Yu380U3KJ5/PXo+6PPcV5nn ySmEuPLz9XZ0sUpPlnkn2KR6rmmWOq/x+l5QfZcBYghbkxzFGFQdRN6pxvb/Al4eYgSODAYlGC5a KYzxklpFJCXqhQPHGR+m34oQOl21OP60TrqE/HWmhJcpqZxW7ofyn/YE7p9bMtu3DHu2v05ECxBW YEJuyKocVEwG3Rly5eYN0UKEO3EjC8YaI+f1D9WBqnC6N4/RDIVYhvx3SIhgwMbapatVDoommwhq qFFQionQHEolV8+p1j8MzM4pUTsSjHUpUTFhMlTBS3SN4bkIryXjGCjtHqXbkDiISNRTI+1KKecm PRJw9xqmenTFKIkiZ5gAZoiImwBi9YIGYtCPpK6/QbhLCYjXo7NwtviKONQvuL8LySUWlGaBQbfo dHJiBHFCbl7PiY1su9WAP0hECZcNxol7gSBIgyR5lbhhqbxhInV0DDiigs2AwLRXuY8RY/iPGKUp ckgv+dscz8/5oqiqoqrw5qhFKGZc66OzW9U/QE5IbQblu5f3c5pcph+rh93/su/jPM+CpDwxy1h0 FBE087w3LEfewvfD98LNo1pL/Qe9Icd/sRC9VVbCaBeKCHT78a+VMXVdZpT2sAYK65iITQ/3fVLO 9Xy6H0oNYP5t5x5CfBpi6tHAaS9u1WSSpDGdPmTdBNvp3Oi8hWAVRNPbEHCPWp+GSqY9deNizNCZ pUTwXBQQkpMuBEGPZeUylMhysZjtvymWfL0cWZVwSqpeqXgsrFyvgCr+CzFp0MMtguSI2bhwhcXc 9sLeuXDYmFWtSgjogqgx/lUBnb8YK8frN9inqoNpOQjnrclcSjPwOZG/LfldMY2xakNSVRRsI41L FOMd+9hOIsFEkfpwLyvRwRCRdfLRx4RXGoXKqIgvH/s29waTG7ThbYJ/y3ZXd4BvokZGRTfFkKkh Rh9lnp5P6rFz1oJnvO3ymMQ8+x0IeU+xH7PLysA/yOFgm3H47zXYiJ+MTBmVe91PqPGM477Mduij q0kkZLfKbhc92UT7qP/zuoXIi4amj3r2+G4H6fH+ptjvE81l32B/T8e+z4EcJWen04UqGf1Wxa0+ 46SocMIrDqnGlo5RBC4IMXi2qncnagbENDK1Yt7n9UGwMez98oaGWNxZ+Setg+64gs8vvpgiaeo8 xVy8tLf0tBvqj8KPxKPuKjlf3t9ecSN2IwaRXSKB1yroosn/ihsU5YYf969D9lSmpl4XS5MPkTSu dNUAylilFLbOajLz+m0nOs7Eq/EUus+LlT0InQdafAD/Egxkif5sgEYOJyHLw7/C/rfXx4pxHCKc 23PqFRPi0CF0hoi80XXezhvLaTEisaXxgElgLph26+aY/lccwLhND/j08y/PM1QmruijcdjMPiV0 tvHDLX+zcB/ozX2U7zxx0Z7vMw+BYz+7JWlhzvNNHRcybd31HCisVfBjAUq/0543Q81gk/xp2UNt /WIht0544hvFvDrlup+TdR5N5Rw9XmsQ8wU/me8m9jkJvMpvWc3vfqHreHE9DFzVDqcII93lVUXw 0PvLt8dm4Nl9Y78qj1JrI2c5JEm80PWnXEfGRtHj57UUGTD9RSswh+0s+eQREDwi+tppeYBmuseO snRUtpUchpVk2Q5rdfUUeAj7/0hxN6sdczniYx+FNgmu8SiMJq/gIULMjQIkrcrOk0pGaSsuAgZu 5OWwP15fLLHbYj5EMoHqP2Et4Mi3eqfy8tEvOHv9TjTxh2MQ2VAtfh9UB2Q2Fu9+JhW8/asd6l6s OZ4DxoSw9yX7eEcJMPq70WjxDri3jtecEw6CbzNN+C+l/bM8v4XfbHQr+tug901siQEQaBFNzR2E HyrR5MZxhzaEYZUuWVe70nwW6KaH2difqzw9aE1Lz4sojpEVddOGxN0pJSki9CCkIG6MR7BVdp7o 6b4vfJv2KHk8eUbop2Qh8ykO6oz4PZPN0hIvn+6sJQG9dmiIg5BXWzRo1piqQJT57HRniIh2QcgF GylHfOqyiKdlHINN5NUW5UFqPk5jWXZbApMRC/oLtpti6cBm2QgrwRPYrZsGMYw8QkMLkSUWMOpQ xx0e8XRkazyQHkSRkWVDfAkLoXDfjAgMZ8Xzthop0603kjeyZ/yzFWQ9NtHqzYR+fPYgblOV/+NU sSLWx00hhCbXqIg9ZCSPcqkGebSijQRR11i/Vbg52hfSwYZN479S2zk+/JiFhE12la5pS9pLd7D3 ZG0RW9TIORiCCzcoW4oe67r8+1X9L+he61n3XG085NtcEx+cy5XB9YGo3lI2wiK9NmBKCfFHSYRp gud2eUfb4VtiuTrVsFuYGYgqW1n0cb3uZEtYMrSy3N14ZTzNzbMsg8duGmb/Jvbd3SvVDxlXvvoV jydhI/Pxxr8/jvvXe5w36WeOP+/9/7pytnlDshbhMnWOqhBPJ4I/Ob9IOpWktsCN3oYc6YJyT9Kw xtlLlLXwpF/3kdDTd5hrw3m6tb8XMzRjq7PGox47LrF8+lnnaKc7+hlHkDMMwFjSqhcsYC5GxPjr EWQiFOzpNxgpng01hwYUUkeqtpDhLk98fJsuGxU1NOy12ePlWOyndL99rYhGE/SbTZOIssbhsIee 6+cGVNWm/Ne13dwV72iohDcJ/aEPrXRaqcyXoOFpcOdlWEQowwNNRIwG2ZIBpinxxBrTsZMcqKzX 6Pcc3+odtXoKDVxdXDo8WOq3SNB0mTvb1VfQw3jnzgaNtEirgKW6iWQ98hIUxuqTuUeS1YlWanAC 1mRERKKIFhcboHXP4BTLs7PEWKePW4bOy1FIrURGBJIKhA9hsx0yoa6vVWECWslePwvTVH8cxw54 XoWRp1DY3MMlz93S08/O66nrhT9VrLk4OodJNhRHCjvYMxil2Nti0Eg6ZWQS3ww36ytRkToOlGsy T9GPkOeK7du/A8bJVFU2UnL+kccskHyWfkus1XgqoGc+ObVO44oN1YA0ZlxsHZeH+jvu9z+RTsPU Lqbf1VMiqqvX7r9+vlEp2PYldycnTsnu6GJRZLmZbotnBqkatEmwpEeBiEHFQX2D7w7UX60cjEeQ 84HKb6gaB+vLIM3Lv5jPDQZ1QyNagUeyyLkS2/bLHvDd9wO2MhDbcwg7dLLU5ytPJeqCMwtoMGvE 4lso6PGkFS0gdsZHXzF9JciiL0inHZT0GYqTnmPuawwTciAKWBapHAg6arO2XWF4na+yvks1VSct 7sJfNlf0RV9eNNhxxfl2S0ca4hQ+GLQZ65/D8KPay+vjVJNeZoKlYKCqi3x50tex80hu9RoTVU4q KaMcbm+xFO95RCZFPAehekKUgbMij5+GyEGzpr1HUaOfkW2Cl/6l2IXRFDBPMpDtbBtk1uayd88y x6p4GHbnRUEWsKlYj0vvrdfpYdCHRcIt5zFC4tjJURy8w5sjK4YUd8PSOSFP16PxIZQ0eKIodmOK qqXED5JO6eQUMNMl9MAlFRtANWO7NkHVYK2s4vOjEt6rbF2GhLKHiJKR9p6GvUqKNuyf5cDUO+GS sGP1/OTyfBAQdIsxtm2MIKZ8Ih3iWm2HC9ZrYRw6dNcujn21pfBBkkZGEAEyTk16uE+FMFOLfLhR dxsqn6GuROe1/oSiU2sO+lFL9uOAybCy2jUR9ZGtY/L9VL7GuPUziwSbd62IsC1hl4AAu5M+gyPS lUbvpEHFK+YqiD5b91vCGKLduetkBOJwCcsUW1+pNm1iET+KtLHyQHFUhs7L9hEN5NTi8oJ7HlY1 YlqNncNplRRpVjOXKOfkj+LCMIKqQQ3rA0oA7901o8V8Wv49mi2vQAXiEh+7vmrx4L61Zwka1l2L LiuN7WMuKpbutj2C2mcHTmPRse1Lx1nOib+Fn4R8/aUvhRLx4dDoCZAguZoTGAD7FQfmgaG/r+X0 9vYF5ikpvxnd1BINbUJOlQHFQUySamRxFrnv8ucu2UpeMa4dbCFC1sGB+5xprBAVWqsov2rbur45 m20iaWTNZ4oTFXtdxyoXqbhBKAibgXzKgruBOA+mzK11T8asJCkiyxRBVRI62KEAyzCPWcel0neL 62ZHsXSOEoS4X69e41Pr16tJNhsg3O+SJJ3248fn1eLxtdDzQQG+qOc/V2vmP272j6ryukLHcMhS aPtsaiUPNF2d6FwnvfPWmaz93QRafid3Th3tlR3fAImx99t9Puugh3XeEC0lFJkImZigOgZsy/OG v7STw4VLnMNlf45wcz6NP8bPaa90WKqzXd/heTx0RUTXrJoj0SSc2EGXl4U0xbG+y1yxUgqHA0ma +QT1CRH2EI7b4TIweFqFrQNhB/mIgQLS3tv7+Z5MhEC/Mve59A9Q10VFRpF6QUzgfVcO23yD8OZ/ Dk2opgiBPBalr/ibxZZ1w2siQypRESy9pkoU7PLnNMSlbYQvucUWQoWxJseXOWqYIplbaUYGGEil hk0SCX/wfrnHHYxaBvwHlVIk4j1yTBh6/3TBzXe6UzRyg+/1BmOQZiKz4h9DMHUxaEd4T75o0U2M pOx2MEgS2mrRk3BZQbo/2c3KcPShZX3RS+eR68jysX8BB93ef8eRw6EMp5BeWuxQjGSPgBqokVTB PFd4LGtt3Dq3pzaBpc1uyTpWraTujCFFkjyq8WUfNdJS72ui1Z0DlusYv/C3pxrPFt8ZaQx0w1mK IKoLUZVT6Vnhc1jtRmxUue15PW6kT7957UtsUjYXUzZTVEnNRJKenDRCdqTpr9MHjo9zijZ/V029 djSxxysIxbofWCiLB9d04KpE+pYyI4BmKGTqi1m1qP9pPDFObOc/6wG+P6tk/GIUG9ywx62a9Wn1 s3KETgtB436KJ6DatBFO32XOYkyGk03uCRkPOwvFNddM4NnVb0dHIa7yTRXNXl0GPXyNNbCwygoV HlbFnD4LuNukZeprptZ41PKqIgJ9Blz2Ge/d4jmffjJJvKhcfT5tMay+fZpKHVBwRAUz32ErUjMV QRVEX4k6XVSBaTeZPHDFy75Y/oocvaaqLf9DQgGUUveRJiaiHV/jInhRMGmIlhaRJm8xXjH8La9S w2gggS0ksjwO9SF0lDAggNPwxbVBJAlUcXlr+3/k3jMdGJJ4H/3pc5UF3OXP771glkobLx4eWFta X43Iieq7/4LZmCoJoKKe53xYlL250n0zoJAwbg6fjoCYxbYlv+MQivBUgRKMofwmszVig+2C0RlP 4DTngX1ihQY3ndtWA4wTdOCPJyN+Bhkk4P9dxyZuz4gfhUinYM1FI4wQt2tFOmC+zyDVJb5DMOwc KYkOzNl7nHjifOWzedPHPzMTeTzi7X8QsELqhnHQTumz5qv7HLTQeG7n76rTBmtRLZuuR69Zm4K2 70zI74DIEaevZdepQn4E6XfjecYzvXCyDwsZN/XB1uZlvmYj2jJ2zpBqvuyJ4ahmEm3vkh/v3mTG D+oZh4TLHHqoz0VE5qQgrq4UqHIEQ0oRPjEv6X0NNMKbOY5iq7j587Uh2ewcvpAZmk7i21FeiLMb cocRzJ5asczO5RbZqHklRp5/bfWYYluy9BC4xeWJLKUCVGPoznzJxSBJG8kEQwrC9P5qgWPSzWwa CbSLrPBQYksmFYVdr5e2v5rO7pxN1Y8VODt4/1nx4xJ2OE4JqOX8odUiPD7od+2u62FLluW1hjJ0 kNPrL4gmtov8CCkfwmIyjCbDslEQyKgNeTns70Xnnef2OF2VRzHIrP+fEaxlx9nNz5Ejh7ndef3O MxN1jhSPyyltLoiqW1L7J+TOKfVE8BDwzipA8/Kj4EeDtsbRTgP9leiRU89DVUxC4hfddqlynmpY np3mB+lICpZS+nRhFEmY49O6NGd+R9Kx0v30ooewzRL6Em04uayx/FjBPiYkesycmPjZO1wAj7Bb ODqe4OT9PwcIHx58rW58tiEECDp9r4WGWXtSLj5sNLbOBrZYBSR4yB7dEWmmzNP5Hp5PZDSt2Of8 cF9ZLY+3Y1b2FRSv95iDH+o3nHHKIxh0t94r2uqmG+y6EGUMP7Q5f73bRgfgSWXQn13/mlfXir0H jRyOz0syOEWdJSplnnrz15b9+0fWm+662zIH8fYg+tNy103OKZJS/lR4/C9mL3AjljIyEFZhQoQY M7SAMpx2rO/bdKv0JiZOQ66BiY4yILcixYri3KfOcxaWR6L9kRgtWaceDmx8RJm5tCBZLDjZZ4hL me7f8mEJZJbNHamLqiKorb0ZDQDzYCOKeyCXEDvVPlS4Gyopud72bVUa0WUpOT6sk6woQ3StZOTa ukfBLuk5BbbuUOhcqyV6SRjsIxmuvHx7THbzKrplb1RHWGKPHkstJmVzHBRhLGsjWBVgobDZG2Fr mJreYPV64W2SQRzAoWxwn3z/oKh3UvW6BciDg7b2gLYqBV5L7OiJE9ESG2I9dliIhA2XxNEmNrNH Ftt9z4zlRjx9zpJLZGRDFkShf3xJG46k5bocbiZkOF2tl/4woUs+PLO5REO6JBe448dtvGHX7Wpf sj5NmH+/dNtldKWmYj5+sTz1cSkvX1PHij5MefqdnHzh0PMOfP8U1jUQkN2tYdze8YTBQ+F+K9tl kVlrI0IGhG4sYIWVSNOUcLwb1mD23dLVuZ0BT7F3Ed2HxmRCRt+jlHw06e/q32nLVGxBRErVggsR NHdJMw0XJ4fGgADgiCoiIaHV03eLC7MHaFvkPJ0ES3qsMhQ6FfROiaJck2abOqaCt2MDqy2WVZ5E Hj5JHxTpQpmGwwJXz02QizMvek+xEVVHXVHYRVFkcHii00UL+WJADNXWi+KxprPvakdrWiURQRHt vuO036FoqmOUeohhCiJeheFgoEE1Cc1U7R7XhDNBn6XLSwo+KIlyo4EV9E7WxomP1E2focC51Ta/ I5doHyP9ROCJ7HDn3EYV3K+gsEVUaLLJ2l1k5GZdZJPFEHHRhjTWuG5ppLcYWLlO7mu1Y1oitbND iqcvaR1ubsWqxI6uyLJFGGXNw+P9eo6V/Z7M8XJZxI8B9fdYRVO32hohk7rLKiZCY/FfSz9Kupc5 6/Wb+Rs/X7zo2/X3M/TVXag+NyLcEMnIvimBqWHetYzmaeLtEowuYxl85lutmccUbD1zjUM0Wf2s ux6KN1iuocjMjRdyBxLxtZV1WElmZW4JCkLhndN0fd54Uh+Asmxa3vVVzrDES32SKP5dGqL/JXF8 TwhLb8KEo+caj/zNcLgat8tB82QV0+ONvxLrTD/WVNzCWqRuVqeSZyOZwsuEilh0q2e+64NIoSVS BsOwNxUc2hYTCyOx7CZJ24HJo6LsM8aKmrlc7BKK5Med8YFbHeCoyLFYGyaufZv/knfgJnrrRvCI 1/DWv3QdcvNv/sxdOS6QsvAv0/Ln4EkisKZ/IZ0nYom68iW3MU2y6ehH/hSSnROmPO3KFxAsiPBO 30s4zSUSkJuy9K+hZdp0CpG6h2G/A6YySfmOpd8G29MdPPDyri8edyE+eO3cj7nnv8dICCIEp1uV iNYMqsKq53LeGlAwJi/qNmGZmfztefRcSdgVxjN1hV4vNR1HGQZWGVmxvuDksbF880CictGNlMeH 4G587oE8CZ43uhNr6/H64lu9fCXDiaVHNd629vh8xkzM/1awB6q9kEWC3TRTAxJu5cqc/9iZah09 3TkWgYSOVQDsRy8hg4PImkMnGvfDs+SvnOs0QetM5pcM31PyY8CtMDm7XSXRBC4E/wnKOD/VumhI ryvZRksLTNc90yNTJKsjIxJS0+Dd36ueQiFRELTGdnA+XB/MJ50NJbzv8APJvTlfXvROEA0M8pqn Lj00iiUJMYdZevVx9WRV86/JQckOX9pfHbj8zzPwfJqL+tAWNxXWcUd6vf3vqSpfyo/XfmPdGoKw 3TuUQUnaxmkScCGFs7sZLjV6QkTdBdlpsonx/DgUxvWRbgfXzs46KKVw6Hji9dFxSdehz3Z+kAU7 CFFFFFFFFFFFFFFFFFFFFFFFFERRRREUUUUUUUUUUUUUE9dkHcdfb6uqHd8NlVxXpJueutoqc6k1 ptMMDJToWz11vxIc4KxYTILC98Mb4o3UxORFiH0GuBDEwBIzb+GoZ9047C/bpi9lRx4xZFaDhwyx zJ0GiKk1JixdOLHp+y9E1FQ/ajDLzYQv0t8SrfWIb8WAzJtRO7TzCpHt3ZYbYyezrj7aEVsl7FcI HFuxdbhrtgNTph60WHo7sMWrXgs41Ls2deUbsUhJ6Z7EjCESJvfr2IeU50iSFt3AhzuwvKTkgjX0 SREUlmSyhE4xx606Imm4Y0yhc6+8bXKnI82MiXHQkeSmSFhPr+YaPnf+PfKRoOn1XzrGDQHNd20V RRUolAiwFvg9INfFoZMy1+QSWMI6KjL6KO6h4KeCoOLdPH3/dKRG7olXyLKPGnKCkd8X4xjWMIX+ 3nyE5ahWfDG3qjhRkyV64nIlaSN3HV01XtWSoXQ7c02+XDjwpapttxNYXu8rrtCs3GvQsVDL17ix VzUM7RoPTKEFwvd5aITZ4Fdzg2YxYG1mWApBTdG61DeqEX1a42qeO2w8lh47cMd9+q91OjDbt+1N b1TpWrq7nXaxrr1W7ljDhISVWpJMAlRHFhF3Tividtvkscu7MNxuW67WmV6Y8JOXiILOLdKSa9JS wxY/t7+Fmt86HlTOQ/iZY6zniAcHIx711Jimc4WcdtmEYcI9Q3lN+pf7HlfXoUbk2ZMkNnJMNKhC k7plsHiQqj5AIc7BiKTnVHkxuvxm951PAbyqOZcO2fctxOEB3CG1URhVXa8BzUeKXqbPajIRnHxh 1RxRDuPz5wpslgNRjTPPCxVOLF7kocqwaLStcbrU9XaW4d3UHnfCE7KoSSfWqGZYHgS7uJvlxDVS azFtRve9FjAUAbjbQ3VuLTW9RRlHuQSLk0bWtTAbEqEtU2s1BqQoyTNaOTng3KcELu9UA87xDipM JC5NOivcTQYcGPBxhrMMh9UPaE6zySHSFiHJeYiUyU6E5JQbtaMIJPmjcainUuTrDBaAoiClzphm lAxOFQjpCzIRiFxYq1RpEarDhk7bLth71h7DguBpArr6nfdscufl01HQ7bHPaHtEUS7a0FmF3Drs yHIrBBlDq3MRXlBqE4M5GHjV8R+VtYlvdRAsFIGrj1k1djymWEutZ2al0B7KDoNYYOSKan9hFLh/ C779awccaV7s7b++N1n6YnrrY0AJoMm8wHVMDb15uqF8aL9Vkh98KRS4znKZFfuKHvDswc6IXJvd i86khL+mugU+Nawdp9HvPQjZsxPNklja4ojt+9XZ+HfXfG0s+uSvnFNZ1zVvWOeGO9E2+DmPMa62 HXGpNV/DjXB0osnheY1znD8XFqHH9GvHnvzPZwtBzBxq8eOX4HCTO4Nv56Oa8eNYlZ8x5XD/l6vi X5xOnHRJW4hgtcmak4s6zWSjWLxSlIco5JkQjWShxyVw6VcZmVw9IyQPIpt/x1kMy3sH6hidj8Lx xjSpUxjjmoV0nZyGm4gjefduSa4ztMvAzGOMVlpZW8NEp+VqZevv575/XvR187bzmeuTrt9c0Wq+ brh9a3D0Fe4jmA1E8GNcx6mXS912Epve3/x5pq6xZwWfHE1T84eVr0+vv/XjKS0Js7xw76VL1l4n 0emfIKih5I0bggGpdRrr5668t28BMxepxcj3C4vMQgxUGal0q+e/6WeMmOM5lvpzjdNXmR15Q623 iLwNvxDm8xj6xC+t5GnB29+rD5uCHGFs0L4spa2Dy0il8TnKPccznSNx47McyJohfrXvOnQ5ZHoA U1OBxalHzlUZ08yaEGWTLibjg7OaM7skskQQblMfP4qPO2VPNbKMO52fpeKrtpIgQU3T7R49R8HE QfjgyaKrpbZBVGXaT+C3QSNVJ+wIJiknq0W7ov9n++bEebf8H/sX6IrnYcZptVPKNr4/f9N0LPPx gbltMWPYcuc41891WcmZlIox3Pmma9/CT3WYu926X4zOD9GvlZ7dI684SpN95c0QV1E5tzjDIBBB mft5uuM/O243zj8SKOk9o89d3ZlyLwnqcqJlBx0M9V+cF/g/WcRtvJOSnWQ/OVUiaoqFkO/YWepO BtNm8prRu3ne+q5aMk/Ts2zWrBrX3330qyZZwgZ3OOoiDt4VzNux6SnGtnVFJ6TSfNxWnZFi+H8c 59a0zrr+XzU4amHbUGzw24ikbuyyzblMqlp5e7SEKD3l505ZOpwl1Q3YwLirFLKnl8+Tx12zKby2 +Ig8DDl0QhZSc5y6FHnQznGi2Rd8o25umiL1J+X8AXeLsgjl8qmh3ZKFyoccDtNPwUYouyx05WYH rMniuEVL+tArG4IzJPFasPJ7JKFSkwp0iqtGFRg927R+i+2wisSAzwKWnVzlhY29MSyy6VxMZaAw xB0Rs4jRodj6YCcFQHXKqITfZZAMEUw/Bb7ZMq8/Lo8FItiz9Iy8tVEQOjbEpiOwa5NXGMoXL34r bsIsoW7p9opGS7YwXVWJRoE+IuHw8mJgbuY8Kq3l5Pzu4lV5c88V6xUGyny+uf0XZJWljszRFbIi z91PFfPjJTTGlvjhbo3eiwD71CxfGp12wuu1y+nOEsssbq3M0GJGQlKEo4Lc2gbenPl5gD2ICkPo MCOCR5z9oqVQoY/d1BgXHAo1Yok2qscfpvxLMxTauaPb5rIVaTIrSTzTs7BoL91TDJIcds639AK9 m1DflPbAgLKygqiuI0+h3dkzExa17ZYzw3sEr91pAYpgrwi7OeerBIh74SSra3kykjoc1RUtMhii LDuMKQsieb+n9Jp7ljForFaU3KrtYp5IjiIdGFX+jXKM8jxXxjGJTodL+m1I+X2UY349Fs3sM1BD pmnp5w9xWqrdmBuYWS9yp4RV8kdIPbBFm04+yvUHo09CcOvGTBR4DYyQt3deVoZmzdw594zuVCht Z6wnWmkMTU9uWNDMdqoXHL5dNm4JeiRE+QYBXg59NoTU4YwtoKM9tX6a0+77nDycgv535fDDx6uC L2ECVS/JJD9vG623UGEeAhIkCIiIJSJWmqKJ85gN/GrgQ1KN+mXyQR9UEOw9tIKbFEkv11ZYZ3vp g3X2cb8fu7441j7eYmQclETjPeHyyigfo5dPAyPHw5zePkazom2PVD5iInthg9oQrjrh6DZS5rmv nJXa5wjy4NjAm54vDN07tBDy+3Xd54glbaqSpUkkJs6HdGySN4fvsZr6efeZJpOqDREFJ5Q+eHOn IfnJPQ0YcN5xk7J0dTD8gL+ekASiZUCIP1yfwyiZW/EpYM5c95/sRtBERfIeREkn5HpHF+n7j5D0 f7s/2fc0VPtbuZ3/3Wdv76fy/Kxfwo/6Kn6JLG1RVS2cZKv8Ftu/r2QtpLDLHeTDf5fY3jTy93xK 6Hwk8FgHrVD0qSowR/x/y+87wEEY/zPBEgRQSPq+gX+Va/d6Wit/3fI1HXYthZZZZaN8Rba1rxs+ EWiTNqkh77LXvyZHcLCW/ExGD+QRmJSrQX3i5gsarIW6w9485k7YrmX38QtSN+FVj+m7qnqf3Rq2 z+dENKmVby4Wuz5/n2ygpUn9EYCum65lUI3mtSBSnczo6stlSi2wnY05My8P6Mh3FMboOo1MXwvY IEMdKulh/HCks3lcdf1w4xfq6eqRKW416TT/BWGjbs3G7XxNeblGoETqOzdHdSQW7HhCDK+V+ZJD SlP5Q2ZZcH195jUvuMbR9HNu5LzY2XPN4Rlkncv853yYqPRB1Q2xh+cDLuLXrnxtWdSqopcMXQYd laEReakco1LQrZOyB2zzWgmnf3XwfKRXGN53bXQzUSyMeldYeXa9GNU68Jx1x56JaKboYlkcuvl+ uWN9ij0sLBoXmMBIpRjsrDG3G7v8PFiSSVEYUVtnhC8XwWc9GuWEtE8dsCt2j7+TWYVYNercUjkW zsWPj469GUdltoW+ReO4XWJ2bhvJBd/HOmdtaKlq24kAnOcjH+rE4dGE93TZ0cNv6crbJXs83FpI WPKvZJsacux9lmU/3dPhGvhYXfnvH2em5RF5N/dXdr0e2lps0o8BofWbb5JxnP5aHi2S7/rtL14J p87ML5uWXs6evAn4sZv3xTZHvbY0NxOW2COcqJmS9tzstXv2Kj0suSp5GKlsG4Zrv74SlZwvb0wJ 6TdKeeZfZCOdIvCi2F8TSVls7Bpu0XF67YY89C6M5FFXrrLyyt3Ilm7C0habCuv4GPptvJEPEvzm 4CkMdBFDYgiWHC48fk4pr7d3j8UrefhwA9C5TfDRB9XZUPWY6OXCjmCFSBAy4dbeXch6m6+h/ldx /HJlVYEu9aPA+Atxma4ebQ7NhTzyWJnto+Z3n+vl0Dsm9N7/ggfsXf0eyxlgcVlOqzSQu01BYMhD iJQ78GiHVRxm4emUdPl8Lw493bu9GfthmzJ1P5fSEIEDfv8b8sCZOEomz4XYyQea+V4o1qmhYQPw XbUYnTmzKr3HE5i6O3JD50TQ/mb6/sQ3ATPXdG9Ch7iEj6PV0/2/t/2hFl+9T/f2or+SKxWLQJ0e DRhN1sios6nGdF4pJ0pjERFlqjWMSY0TSzcxeVNQ8qNF5WWUpOOP2fbo3V5L69f0fN/Toh0eX/R8 F6M/J4f7LPS/O3Hi2l/Olzz77eHHI5O9V6G6L4NjQdm4tjfGU7bVrFavVmeL1VXHWbTnbIrGycow iPCxXY3bbNnn+cPs6+hWo7jnPqaH7jet6nMrPyNGNtxSs1v7vwp4Pq2t8ubzLJUWUJjM6fLdBLfQ LMGf9V1vaq1e+gnbRlvAIYPY0blldRS1Rm/58qdd6TBaj9c9fiZoTPNuuyUhBRg8P9sH8E25qC0c L/LrkLJf+99TOv5nVfND4coTw5MblotFVQSVlqys7faWzSZe9tyqvlPfbKdBE/HknLLRsa/HEROK 5IHzTsmiC97B7EVEjE92x39/BusivNmOKNZENwwhAmcZNT11P+RD8bj/UrQvTv+x9T7yNcszTzfQ zH7BitZ7+MN1Tjb8Xk8fo9ruoiH4PPA8VrjG5vOc6QK3wv9Yo9aqWMINZVJiD7kvM4oJ9Ps3VjAL /MTW89Ro+1cEBWWSyIyJRPT3b7xU3jDFhLVg2BYAeX5P9bCSKSJJKUmGak40Zt2NlllkrYQgzMzN wSJUPMDJRE/fcBzSsc2NyKc+eWZeQOeiGGNo5PMhQHvmXuPcuNidvStk7Kqqu1lXjZvK9V8lVVzZ VzZavkqqssq3ZrPS3eVlu61eFXuvZxnuqwul4azuwmPKSu0ldoHmXp9m3G232ftfGo3OSAhalnVe /gXxUuWEVAd9yyU8nUArhOZI8fUakPjuQ83+IKe3agOUB3+09Codfvx8AU7faB8sWv5T+ZVFBtWm j+Y+wP5v5uA4RxxspTJy5dKEsoIGgzl2KtiwxWDDSo4bJky+cBTQ0sYaUYKKllokmSSiSTLFfLfz ft/MSSEJCoyciDMxqSoi3mGsoqsirMxJCEkhI/Z+k/5axV/b9NZrFf5nxZdYnN6w5/tyFrtMbbab DrKVP7ossDm+fp6+7XF6q7MD9DS6Rx092hO1O8KJkOkYsgx2nISCmmiitnOzSGyCbjjG652j3du6 e++23ZfLe686n0tT5XW1c3y313hVufO997LwutzeCwXBZqyutqpctqxWi2L7o+Lf2n0e+++H072b o83odNFjFYu6NT/n4rx/JfE8/SImfrGeOqw68S5nUvVZJx1Pb7zuHp7nN/PGq0tx19NcnOep/Yj+ in+F56xDmbjTzCxPVj+Hq/Ok5deL35m/nnees2jfvz318YfDpee3l/3vE816OvBb+XTHphLXj19b VkstZcet8C4vvhjGsaXytpWV1kJVip648Rq+68ae9bqtdd+Oh+4zE1rvPjNxzrxK1RjU858Vjib7 u141vq+1rjnXjm+e9c3yrIW471zGZ7NPiMaYXrShOco4NK6qwxeOWfU2tcdOG3Xfxhy06HwXoWGV vM6aZ39Od1NrSnb1crZbOjlu4uPBm5xiXq/NXi79MK0ZmVcsDNWJljnzbTpPNz+k+uQKIURnn6Dm 6iiSRSDJ/gZx+UO0f0/UQaJC3sdEYF/BvAtg2bJcseg7ZdRmqEkdlb6H3RzgUjxx4flEfASffZ32 HssvkVnC5rI6ea9EQG4TukzZ2XCmLXIKEhS6Lo9/5Mjez4WJ6C1PcmifNreeeRhYXnTohw+0DBCR kCDIEY0FIbdIfxRv9lH1/55KhhEvX+XDAokhoIf6f96d+g2FTKEEX7nOmgxqIIKUCGGS+qwIDoNh hYhz1w0QQrCtES7MDAhhiR5iwXAxDMU2SqLgwgGgbCCiQIgswMJSMcMGqQmpgQzAxSQpJZkmKoaF gklZCEyyCkMlYlswbWLq0RAFSQ0ZOOUzlBKBg0Q/2unBmQoAKKUpCSiLViySyyk1Fi2BAUQ42MAQ SgULQCTjOCblTIUKCZaRQ1FmDBKUCYOCp/loAMYCFmpSDMXItEGJIwUPLg5AyVlgUVVTTYSBhMQk EDFqc+GZUkECRIaccKUMDHIllIIYILDMEZEKlWIcCMIwxMiiHDMYqzDDIP+ROocLhxxyw+cIRMWt BSsTBlIEESSxBjBAgxAZHcQbJ2SRKRFH4TlxFOn9z/w5NGRZ7bujmHmf6V/ZifGejQv7lFPEfiTR z+h9Pr3cABznaPOjzRPw9Y6YBN2VKkkoX8TABCB+Qhzb3wu5xibynr5n+S9Cyi3spbeoEBUKoiB7 6CER/xgBIEgQIiDz6vD+E87t3c9Psy23xFHwTkkAPV+rHRLKVCf34/vsmiSkVVkFFCIfWs3acuPT j+aB/nxtdeOlGMXpw8pojdVjn4YRpA+JfmZpr2zd0krzZZkPbG0hFPNDo6rG1P5P/yr51oU3uXuU cwp62d12uu30jwaqddf5Zx+zmdxsjlj9kjWUycFyIYlqeueOViDySyasmkT84fE+6M0ofXses8JG lSCOZoyTsNdHhlTKmdsvPRGvhhYy3xkrkburr46TzMtj2+R7keIs5b9JzjF9meNkMmjpp02Th7y0 Ra2MxmotkyZdO86cFlIAZQjxLjLwswUOJndaujZfnt1h+nd2/pmumfXY10l12/n+NZ43d2H6licZ OfM3fr1bru0ETjBTw9xUYHZSFHth/6bFJBJFJEJDVFftgTeizH6QwznBTDX45c3vLf9gH/kbVBeE IeCVIhYXHFgAMkKiAfOxF9yyBT7fIU/XLWNM+xwPdvC9PQY+7HG2VsvlGObGRxIMsOx0PYaW3OsA zNSq3ieaFCNCDARSFIUiMyJXrYTEFIF9khjA0ywlBGGYSBKJDISpQEGjMjxJF1CBoIZgAoiCf++C GEAxV7YxWmpEUJAKBiAg9v92CGiIlEmJRpOCXE7BmEwlGftIibOP6VpLuyiP32ut5S05tf+0WDBk CuMY1p9h5n9JpQMjabHhAIctZYZuu2ZS2GDKxjHWqrYf72o7jiepI9gaquFtb0x1kctlGseKYUwr xMo7mZMkyO10zMGOkjbThhCZ5Uo9aoyWMuxZs0admiySWZHlYSGWq5lGw6SLj0YXSbkJGOsqwpSR 5lbLcpjzAha8hkeY1C3IWGMxp5iwlqlsrwtkxxuPAHZLkYVweRNmPdzHkkNYW5MG/91lhBmq9O0h KhlHY7cpHYPGV2yj3rLFjeszA/4aNXWjFIMwktIUwjnV1oxx2GllqlVrhBxtYMiqdLJMyyV1OTFF ktZXGrjYN0sbg8ykkKzGOO0yEjDbK9PHpkpSlbpR5cJG2yQZjiSdwmXJmZiY3KPLEGMjRBR6Zqww hZSE05hB5KTJMZgmzGgsuSDdHkLjlsLYyNZio8y5MHbGZjtzJjMXE1AzQ3jZNajdzHEzIwx4W4UI 6zMmG3Ab1q2ZiYdH80x48Bc2JQ3EIUUj0uDuYczwK4n/X4LqFiQNlCsgCHGAAWP6LvHzn3fJzT/m /h+lUoQOKNCRzhyE6oOWe7H+r3cb+4xvXWd3K6iB+i/gIrgsv2BI99bT2ew+mTHxRTzwNyCXDVzr innh0ciYm/v31/aW/HGodwMgq2H+pDWnmmYJjJnDEpURQFJJpDSaIcX8jkfvbMG0Sd5Mdl/EYUJr ibgMUyyiL9CuBoImIZRSlFIn/54M+zKWtgiqkLk20gT88XG5Rg8+4Tfk6GCmij7BEWIWgdkQovot ngDoKaqYEQ4EiQaOpxfq3iPtetQQuw4OtPqe7iNGoJGZ/zXu5uF3KrkLQlINK17c5+Qz/m/D9PQT kIIqkkpgp4P+yeMaUD/QEAcQcEJ3uvdURMxEREdDDCqgJ/FTVfnz/gdfy/8fwIf8fw/f/f/KJ/r/ JW6vXP/HWZTKxl/z/pOs/2/8TeGcqNGP/Cx/5/rC+wo9f+vFG3VUYJf5tyfYzx/bD+ihlcdDwj0R OKHqIGPefUdoeshgaq8fcEKDcEQ/yRTQfnjeRh7ocJiqg/gu9ZZYX7iAT5wgQMQtUsfgFlV8Vm+w QfhgsGsaHABoAUWn13UHSH68AVep9yoe9ULKhcBPyiaHYQKivo1tZqZFmv1nELDZZ0FCCZ8gjZa/ RtulTK5Bj9zdUACsaj9UYxI/p3rRR5wZL2UczDCLvAg3jdnKU7EMkb0tLS489tuEbWxDFM9BQlpD caDcLk8brRi9UFCG1UIoA1VVVVo/dzo/k30Oz/sRdPvP1YH/UE65Ebgox+8HBAQ7UKM95AXTXqYL zaFbMEb0g1ZTtbRsrQTYNJtjgXECkYKQmOkjT0XfqbNdr1xs2GBWVKdAX2lVCP8748C9pNPhGUx7 PCu7W5r5iMCvfIGCBCHSyWnAPAM19Rg50wMGFIYQiAiRh4sspjjTo0ag1TR6B64q+jc1m+NlNL87 Y0SDUI42omRcCfKwEuwmSE4hnEm7wmrRqi2SA4cegg3qunlvCprsbx4ZDJfpeuk0vOEpjjNeutzP Avk8j+r5vuv1twuFqeqwFaqiUVccClSpg1GUeNuQg2DhE65GRyVqjbcZGNukIxn9+S5KA7G0moMs rttI3GjVzKGcDzRHqRwkHYNxttjpG4NwcTsJJXJJSUcZRSUk9IYMOeArQgMYlGjGfQ9sEqcLna0F xFehBMfu+qG9xtQYxhGgxJhIgrK6vTzM9I8yIjZ1Mw9JzylwCfbOK86NKnH9UAlj+d9378liLrG0 RjMUEiPPBJikNRs9AM3oHcYZTJIFpD6jEbMgHXIUVzR5iqDRDmgYPmISOmwUxxz4FOgJgJJmSSfR ssqu/QJog6s8M6dOA6YANIHpHlKeub7WxLSZACBqI+rrNH0RH0jNj+Egk3r13rnQSmUFFOj0w0ce HG9hThhj5lVi4zIGNttBhSlKKqC2CcE0g80QO5T+yHQgLHYE/xzhrOQS1klCwHsy3/XRJr0prXlV VVV54PmG57yDel2t5TBmcGzSDpfcYYcMYEPqxxqirbb0MQYQkdCJTMSFKEhiCtYLlFmd3rsQ2URE QMB3VVVVR2Tn5tO5pqqqquETF+6/L+Sy54Hz7cfKbPyVnjyxC8HDGunU239W6qAcexFAoJJVi+XD GIOfYcVqpL8G9Gkoo9cdemboJJ532492N6GRnzkFFDbRDYjcN7wAaIaIIgosgcgCzWaSosHDFV2P 3EM3NJsr+YolOJGg0PsznImk2wY9EUkCNpvQp2s9XRGiPrI2ZhCMamYIG+6dI+WY2QGG3RiCT8Ha la1+DwhIP0Q0cHSGOtDDhi62Re7a5fYyLQyLj+stDrRW0kqNPQNSepHvuw9biNmxo4oK0yKUiPIj Nt8mlMW9QRlY0UVgZEdeqY1aOrGHn33BpYDvrgJCRxvjlTYYPpg6Rgv3zAxKoo5z2kDpXyMDEnv9 etERazBoDePWDREyB4RVcgmtGg8dJ2tDHBqX90nQ2/LNFd3TMzEoDpkRUTj3Yl0zTTJwMNQsXKPV 1YLYxZCxJCiHcpvpe/B/KZ3Wo/bYyNB9HPv1qN1EJE0F+HAfB0Hv0p+Pg5OZg6RshCukTd0ZG3hj itGzqZU40TJFHC0/+5ozFZE5I9RkUm0BUHf66Yb6OTfBZAIluyypv+W2HljEssXjqLwztKl/Dnl5 BpefRVhlJY1KMibdB0cLbX6Wu4Mo6xp3W0vez1fBfE9Qzto9DUBqkR93BkPXvR+QZ2Rs59mEI4vo sPznuET7uQyb3WATPgatJqonuY+wOy7fODyg1P8EAZUvJxYh+MzE6zg/+BhgWE4vmBh5jKNMmiBU ux3odGRGBIhjY6MME0YY5HCaDcH1bXF904bvI8RGALWKlh4a24iqXJ3fuTBDo9KlBhM8OnWXiWaD XdS/Lf/YQ9XGT9RodenIMVEuUZkHGA8Tld8JRT34+/Zs0RHPca9qhwicTaA3B7INLXrzPCONGpHv GNkDiQEwuRCxp4g+L3DAYBkW9w0M9Epr/FgsOPP/AG8TL8Pj5G6aIoamoiaJ4yOBkQ2UZoJuOeLl wHzYHhtkgZWTbB/UIsgIVMin4pHJKFUOwPlBpUDvqUV92Eigue1B7Hi3pxwO8BAT5+P2ROj3a4wD hzK1A1B3wwH8AUtZVJCdOTm5Kf2z37AqH1kFW2JJT8/k2eUs4ChUmjJMJh1EftMTYphYVPDGf7rb /9GtcY7PiWEC8WEBnFdyfP/XHBV91vET+1bH+wz8D0Z7U0478gup/iaXc/+92Nm+PdL9sOiZ85j3 ++ufSJ/j/9/tA+uPPYp8imw4YF0l/vTL/MiOjAKQCTyT6/j9e25FmHUevB+LF0sb/pCZORiaJdyE 2av1esw/4yyMPPSHi4Nn5aon3nsTE/y8RZtLT/k7Ojb6sT4dx9uBkvsP9PhjVUsKnF2PgWHU03HW K+2UU4Xvp76sSizU3frnwnGWc20alIQvudkFXaNAG/zako2t/PGJT/aRTox+veYbeOD82yyqkXId TEvDJvTfdi/BRZifK+n1i1a4IciHd+cQfeqLqKjbKe6Pad69nzH/PzOew9gkyaEfVJUs+DHrZ5gE 0UCMP1AH9+e5dwMaKSJ1QKJFCecgBgNqPoRlVQP2jAfFgLyLOgj7JSXvPJC08Dsx6fFvhml5oMCU EEy3cOzy5/E1jc2X7dAPCQQ0zyJH7ZRul7AEgmDw+MtoMK+ryeXPsIY4ozkVlGk+qNLoYMbTyn3P c9zeaQfg3psP4/yFrrcjcpVO4Bn7jF8aOOASNNxxn7elvm67bCvTCjWYp04+7UxjPKZ77Y2bRhFv KfWE/4tqsB2eg9vrsWLlN7UctqyBXKK8UaIKwI7QFpKMQCkft/9Cfd8pR+fpDM+ybkA4PgMw71z3 GGEUyVDNX3RHHje/hL9yoeqrRzwD8WcEDakD1qjVxGXeDLqvAfv1d5RUezOLMwqragnJyCVxhbu3 P/jVwvnNJDOsOf2ft56h9UTXqFf7RLEWaa+fe3bnVPmJcfrgY+H8OZl24H9WKGxgPyblwmhvtIGA 0r8cyRJJxOhqlL1QfPFAzXu+7bcyxlEUv46HUjv7jO3nT0QkiRybpJc/hoe7TYMY6A3wprw3qDi2 a9d8gkq1FoSO4zzaKIblUm4AI10H8BU1V1Siolr1cP4VG7rQYMKNquKifuXKrBN2S48cAgQz73rm EUO1OovTODKUWm/i2GG6ksyEdAzz7usxurBsvXYVWrTP1pUAPmUF942qiH5CptmwKp5N34L9PijN V5inUPtuYtmyITFQ59LbF0F8rLZlnETDK9nAoKHyXhzcC5/5oNfLtqx55i4vvxo91i4WpfcFar9J D7TXhQS/RsckaybGBRQlmMZxtu2RF3YuSgwMuTXWwum26Rca32z3PWIeO4xndh9GTn9VxFQZf+4r KCsMygrMUUd2VRlHUYWXRBzWrVOm7f3qvYvot2bbd63ayW1D9qomGJnz/SW9WJpQxbs9FKYZ7viU aGy9oX2OnWpKzbPOLu0FNqz/Nh/lb0bWssYsm1f4f7u6pJD7MOG2BxNV/XQ2f1uffac+fNf1/9uq iz8/kghH9VuuN8pfq/b/Tc/oP2P9fT1c4mw3LA2/b6clR2HdlgqdEpeX2eLxcb/JalFu9/ui/sVO +lB09/9uCf6wQPGfSN6cfQeLs4GxNN29KJaCGfxtDQTgXb+/JhmQEK0RET1qAYpJkCNzBz6eUuvM w1Txind6e/BEQNp+uDoEnUZKYjJ5G/ZHvcQ8Xo3eWD2MICFN3Pm7QN6iRmMHHTch4KKsEQhyGBP7 7cnPenyFPJ1xOCe6wg5c/51ZrcsQygds5IYzegFytjjdzQ4I4R74O8B3MHjiwcityr9H9+vzQ8vv +D609PV/1b04gf/73d5LqblbM228lvk9v9A9Xu+L1avePVeGs3fx8vh+z09uP9cvhv+x7SImJEPL X/m5iCJ3c9NKS57WM/oqOfd2b7E+SN6Vijp7vJ6H+2ijHksg+xPJ8Pbb2fu507W/4oxgvWbCeNME RkFAuDxRh9cI+fhn6J8xbNm2eGXrpeu7JqmVwwAqiyZk7uTK9sHcD15/M5+vGv9G3qFRxfm3XCtI hyl797k95KMb0Zc9Yxbe9o1sVrWhJhuz/IfyWbcCxeO+a2685JNUlZrhCip9wv/jgGuJz2MyodGv pdHlpG0FM9bsJX6/n2/OH3btJm48Qqc/Af5z+P+tGl7cqSZmaIdMFWzJIBBWokgDiDyniHnwD06B u/q/xw6BtCMwoVgb3R6vrvhMRrLTLWjUC9ih2i7s/y0ne9wdw7VsPEv1FH2UZuPWJ+9UNSoZxz8H uefYAXTddPidxyE/B0HidhXAmD632tw1YfCd9HGbx+nxnjPvYMj+ka/2XCyY4mVUVdsKxsZQ9SuJ 3qnnuZgTog2WyNEMitZ+o/A0dOGiqmJeiQr8FG1jKe8zOw6YbOgYPVz21heKZYNsVdmyXW4NDGKb TG1AVT+alhcuDlpu+vDtpaTOCc1OMe7A2xxuYL1+78NleS+PJoQaEGVXFHdljg8RRdD9O/O2Hpy5 Fwp+Kp1HCHE2ZbE6ck5wsTZiFlC5xfYzr5zRkf3iHU4otqpzDzxUvy9lkdNikxnmtXL/sclzSQy8 k921Kh5pIPyX5vf3PUfznPeqSRkgN/rfORjMknrU/ZUn7PdEGJxCnH41c0ZwS7zwqPybbEYPs+Yt QUZqc31ePK9V/p72MdMVkkRXGg7GIIbUbB+7P8GjhwO/Z39jiyRwHfDgqiA/4JuFqBZspKiGMjoL iC3+YShBrK5l5Ze960LpeJ7jmaRTUg9ik3OCR4h5fdqSoBJsXdJDpCFbu0mG+hFgdoFtrtIsBJXV X/cWfqalhrP+Nf0LSXXmDhDdewi72JM6C9geIpnHMSktLWnEcDxsqGehM6hYbGDkrGoqTQMRoBTH uV/z7HTnleSf7RIPDxL+bU4nu9MeZvrVgw6in7nnJELyaxi97jB/+sShMYuiCZj0NYE/r1YK+b4f YFlevtO46PmM/s9BmDIt8Pbz+HMFjIEAn5J3FLb1h9kb/u2fv5TL/b9BqbrmFq0lPUSG4Nj1/xP6 e38w1VrCOZ9L8m6fND+PD8s+QgcV/R3XMShx6ghN4wPm2y++PzFi2l/62PKWeZdSzijfpqlZTu7d n/y2fu4rOV5J9ibh/Tj/txv1P9HH+DvtPFodb+oz2T57kx4FuzOZYkElyJzEbYNzXFlqkz9F1nHj Q913VOdhN7kpP+NshYsdr0AZW6lHIUZViWdOMnJqbV/NbP2Y29a3L05sV9dqf0rhumjptsnRYlmk UwH2GjWq7Q4Qk7cVtg1p/Vf+9IbraShXZ+WuF05JfQsWqlNJyvOc2rxnOwoM54UihCWm4/mt6SMQ 6vW1W+uIRERIicf24urdsywLVwPjWdGimvCLUJphhnnb7eXRnlEXqwMkhVLv8aJICQpFlk8xfSsV iWbIQfMXPeWopuGn1cX4XWVn/R2SUhSkIF25y1jDeS/iSYXiqEcMOu8s8aQf2+z5LrPyRP5p72IB RP1qHe5XpQsaKIX6HUfKttQJLnxJ8TzJ6FEf6P3IWqCvmIPFloQf4YzQPL2i+b1O7vE9xt0tOoio rMwv7Qx6Ioh6E3UxO15nznUiOb7BnTCB2fUfSP2k7BIxXrgVamomT5YHVp1MOm/uQ25J94W8RPy/ y/X5922/ctISfw2ioVeA+UhwgbKOODUP2M/hO2O7EqafvoNBmqRZEPZMNtN4OaA4nE7LYSYU4tUW 3Apahhi0ek7+71f5fQB0H0/22/FaBUU/q2+EPF9G1uaC76jPqh4/7EIZ5UKqkJKf2RpN0ESVQVVE hBEtIEJfs8xWB8JiUfWJR79ClrEhCJDSBWz1nzACaCKF7KH0fhgJ0oWgbUBNl23Dem8I/nLaPU6E f0ntl8ww/UB/CfQi/IcEVBUElEwkhCE9GlgnEOwA/ou8F2h3GR4jJ02EIPwOJnjeuLmVSgU1gjwg JIomaA30xDCgJYmAWhEgIECIEiKKJDrp0xMTpFPBJFWZQPT7gU9glEIRYdICdCm+F5wH6DkvdObs TNnhIwtCDRkpHR0NMjQO/QM30QPOJmtJpmyOpFH6gDszM1bpt237P7iwvFBxDY14CCgIGIgWGMYM YpGbgm67S4B7/3+KtZ7T8/O/JyynD6g/MUepPmvP2Er6ME959tWQhkHkNFgdB/A+LnyTOGIveSMI QJB/M/mzPdRPxDBwlvgCj4jPQF3g1s30+n0tn/M0GswpwWWey6p/1JIf7/o+Q/l9vw8aB4xD5kUC wqfYt+rd8z4z5QOahZJvegcjaYI6IGH6Dn81oJimT4/Jqdd5/LxGf0nzI5knymJQ61oRx2feDa6F wNnVw5d7+GQGgHZ0g7rL5rWsW06nJ3ALcQYionjgicwuD8OI7U+LfOHSJq/h2hRz51PPayoMLFbh Y8gUENEmzRseAwMJ5oOnUNFV8nPOvgJcTjmh4Q2fU2aRx5A+CO11BTg5bOO3rX/zOWfQ5SieYY9Y PI2aHmQ4AZRtEcRPjEXELnxnWpzOvxT+XpyPdCI9aSR/pAHpfeDjljEgcgcoegO3ow0/r7U7LpK5 xLPIcxzCrn1B0AY4mcArjjNA1OcDYJiG3+5O5DIEV4ofYeVKQNzvBTdLdWLMzgWwHVw2InJKnLSR 6zY4qOIiFUKsFbmbnuVcUooETAQVCp0ykQNp3AGcFUXaiEqJPVCQnidlh0Acu6tWhnShwOFKLnWB 5Q3fbhuC+V/kDAMAnMJxQeZ7EBkQEIL1aIUQ5XmWX+CXCxYCeM16ned7Ax0IcIa6jPHCtahVFqJH gB/LrOXSrx5hDeOF60NNpu5IeTXFjEOQuF6IbUB5wCjkdZ95Dce4A7ExXT4gAidUOUqX8byh7yus 1UxluCJQ8zcjuE+QC9yyJ1WBQM4wDpY7j+1E6xtuc2Y3yVwbR5j8HI91cynoX6x+55JHRnCqZw6h YVWPE4tpRkvXRIKONYxZJvX5pj/FWzyRGsYY3sjYYMyo92C1VngtOlfueSzpP71uhKsyZvb5oNSt IJWGMWtlZLSJh/bmOeG5I6Ead4XP9bneFhdtLR5zwp0JKG+k4gl6Uk9RDLW960UfTtzcRoqXeNbx tX/ih+esby4UbNulS/0FfEGb8LO+rN1oR/pqmmM+1VHajRzMqH39HqeTmn1rDwhIVKLp+Zd03S4T TL26eB3ONH1v2RiHLwuk/r+/ZzT8vfD+RbjlurnT29xCyY8hh74PBG/RCNW2zomKWRkIhdJrmnyY ljJ/RZN1tbPGP1wfGHz0WF0NHbc1YTyw/i9mWlfbhT0NSCwMpGDLar3HR12kKX0WFltjjzzixlt8 bThVaYWxlHovhOvHnZBcp8RZG7rP/wp6fmywYyifckn5Tj/y4Grgk3Z7WHEtlOl03YOH0eOOxFLy WgodvaPC3Lje5YtivSZZeudZ/wq58t+9BSg/GAXMGOokZCbZUJOyq2QolqxGzCEgcuzrmM8BX+VZ 8+C9fBA/3zu5cjtldChbUjzINwjbTdvPhXui3pre4ukRlXZm4l0q2wmWeApq9vU3BmbyFMGujc3e +2M4WxuGFLEt2bKbVajeY6a3emflnqEIzezVK3NRz/1tvCCf4yGh3yGS1+a+9QYOHxJN2VCDyZlV WY+/39qIi4PfvGN0SFntbD7KM/0Y+M4EyUwKLG/P/T89fSYmcU/nKXnyeTIelcBxPxHhIibzGwY1 hm7engZM3KB9pQNoijwwc7n7cPXM+o+0nQfBy+rvdFQ3ockC0LQtG0LQdU9p3PI9Snml6I+vO1mV VWlCLMeIoWnxKByRHNECzVsy/ZI3QQ6OAcXIHW6HOA4zCOKQ8igOkYxPl7xT7SHvT8fh9v2weXzS U/GM7IqTgkiRND80GUae71lm1VN3Imp1rgvTnO/1jXOuyU6Ouv5/k5FyGlwbvDp8XdsN/vNvG+8c nUGh9l7KDb1fGeaNaQO3siPp/Z1+M79yF4P0T7rPvdvvsZcks06ywpfdvUKueSJpfz29K/54iozW MTiVC4kbLU2jBZITgNCGoXvlgTNJRsaKOWht57VegKCG5PqCTHVOKHUm4K0Q/E+79Fmfk766nock 16RBW7lT8hS74hhGzkvygXoKo6FwjRDrGgC4AvKX4z8rxP4I/H8NwrVP4ltxVu90Q05qHilBVDqU +ZzlePMlJLx25g7DeYcvPwFq3w5xGOI2xgtrFgiboMGhA5GmdnaEC4SSFtF/2c4T+pr0/vaE78KX Qt6qRrK6kXpnU+CKCoqqgKirN+TX6pDV/s4HSHbUXnQQg/XHLNkJFyCn0zRkD3i2Y/5Q01ZCEkgR 9PzJ7O9XXfs3a1fZwRb/L7cbqHwBPT6mVmTvTjyGd3FFB1Bg1O7Pq5qgZJmAoZnsPcYIAactzCIa Owhfw8zgCH6BQjT+4ZXbi4+6bGB7t7Pqc1eSHL+v/XSFo+WCSJ7w6B4czuH8hw8ee3k37gqfsUJT +K1P3qXqQIeUYZDeHrHQ1VAPr4c/RY/jMQ+4kfy6sRhjqEkQ0CSOBAfFFsyPlo401hSAYnEqfVsk OWGsyPr9p15DCf9hy4QHMFBQXv/R6iP1W6IAB+7KhSxISQjH9n+KKLO6Jvc61unj4n1TG0h15ucy zSSNZxo/tN6cTiMOSuo0E0+GOChpN5NV1wUR5cGSc6CmP/SFvoNlnLxEfcy3+4/zJ9EeEY2GkV+x ob9pXNIpNc9UQT2ZSmf7H3/l8P0WBNFMDlX1nG/EeQp/bu0GM+7ON0AX+JQdS6Ao5HE7yvhKCJyD gXN4r4KPLBkTnmGRmZemTIvu85Y0RT2gHXot4xOGAeFjaJ+xYjViJIUoe65Y6R1KNqGS/YmRYtab TMAbvwAFO7FFdBLOQ1+nyUQf4rATZWIP5hRWkFsEObq5AFQeaofM6MBLdpyM8/7T3bBZpZ8hex9/ z/19n9vy7PxXzLDE2fk7J9q55i6H2hg+CtfduOH0sHAH/XafyRF7oJ/rAqIP++DSSEBOw+gk/Lrw +SBgMJ/p5/nMD7hyEBQmJ+lbfH+/sP2cPYYHT12AdZwH+OghPE9/Blu8sHl7p479QKYnM/l56MwK P9KMP17wvUb6fT5PrP127hufsPEW3wU/TAFNsBTdf3drVUVUkkkkbbkjcJJJJISQkbbkjckhmVmZ WGZjmYGZmZmZVZmVVVVVKwzKqqzN8x6RKnv927x9Ht6X8VyYi8eZ4/Ro50kUmoSw8/jy78tM855Y nENDAIvVbaZrnUYYdJX6fqn3yvRfFxrKX+z/0u5/zmICxEl6dZ7cK4pwIL4jdPSgdWs7xvn/Xm+d IsPQXfB+EmMQlx0c9+5Dv26vfpIDOJp+NOIOzSbQGMRGsYlvcQYRhMGFlMM2k6zl9o2mbSAlAwbT GkPaTmTJe0nMJzOoKeIOkrxFJqUM7Yo8wp0u0akDu4O2hNymTkPM7uscSZPENcz2gecwKeZVOki9 Jy9TmtFwtUwZTMEpt7xDJbW0wGUYRpHEoUd0HEcSp0kXiDpCUvXuwE6QnSADJQ4hO09JQ4jJXUHa V6SmR1h5hdR21nW6SHNxCGoGjUjCG0jU5dE43N07sGFapBCZmNi2qe4bMLM4VBlEJsU4bTDOsQpu 9LKd8DM8u2UEUb0Tl3a0Dpkhqm3zLBKBIoRtaE0IcQBszuGYbSZmG1xicVK/zf1JohTjjOZ11ai+ L5ir1xtstRlyD9mtT2f4c/nkW+szi+jyw4Mx0v2h+7oOyFcyj+WQU6n7h3bBP8zkwPhF/t7ihAbU QRKgLtCiA+7XJXkLCCcRPaQMDfN96cjevN8Zz1m5hnenzNSDMVpkwJS5gMfQfAx8fqUEb4nI/1nl KxHDUbZrvFwIw8HY8aUMQc5at0pzJ3UKtF8yPfpMsXCJJNNURvAB/NzIAANMGeIlISMxGyYvzdNn 51K4Ov1ZuW58OesCylPmjjcx4whVCl6aNGmY0MIeSIgMrCIyWTYSFIv1Kq4zl8MmtQrcuGN3EItd SaOD9IkHuu6Qb9Le3NEXQwQl7Z4PZPZtCKgBDohDGhfKJeILpFAqlHGDgm47JMngA91sHPjwdznr XVPxEaOpyYKisTBeQPWa21y6aNsYUkv2W2pMyTUVcAGRYvxIvkBYPDwg8t6zvL1zQ7V8zW/7wBHx osWEzzn3u72uSL88mDfz4NmzycD4h7fmjrpx/jC99RiJvg0956Txby+bvhMQmIfN0aQkToAZWahl 133U2XighBvcBDQmwRpiCIAgJAQC0b3RoQUhjb1+GeOVbdS/E0vBBWjo7eIojl2I6GHqsywxM10J HnZ57EdmuVzxx06eXuOaOtGspeNxGB9DM4zYYMh9TdgANgBDMCGJ2yqbwYDQ822hVpmGXBBKeRiU DXcVIC2Hjd+nwwNowz5YBvWnGZvFnBfOYlgthjpomnTyMLl5uRUz+jslm9bMFg+GH2v+0ZmZdU/K MqFlcwzo8ccW8NdkaaiCvB/SDRnrYzA6haxp7qOblXEIUkvmxSxHaoZxQllrK1sILws6i51MV8Q9 jvTCNABoYrc2MIE9DDxypvqGYpITdiHQvLlMBpmMYltiwk07hop8mBfT/q8b2XHMQSc/HHnk6FRH bwvTp9w2IW33BD56gpmPzT4rDww4GwaJYFCOEns0xbXQBZ55ayZKDLsaQzM1dOPMwe48ZOK9iWhy cuy3mJTGynjhxmdCIHwacwjObgEdRGbl8V1xzrHq2x9/XgjlB60TnuuIORJ82VksqEVA8I2bAHsT AkGpcdMaMNmLVLGqqVQuCTW/sZtIrK4HHh2bfdEfU318/PB1s22v62Kcu+OMmSv0zz3J1xrx5sfF ZpJJJIkN50SCcSzRhHzZ8FzsZk2QFufnMmhHKXPPzujRPHGqSwSOjTnpZIrvyXfHHjpdHa511wAZ VV0897e7ngmVWFGbvERbjGW5MkvXsuGbLuNtEZT6dy3uKsfbxGjNWWU94zPymws+oI4/Ec259Dfk cDpnRjh3CL4hK9TgRdpFTxCe27SijxcwRDYm8wYsc3qY8czdsuN9hgbTeYbjE3Yl/ApfY93pAUaB 9YAY5WNjfJrzSGcX0jYUaWh6VhG3QssoaPSMsnc1ncdiAymwtMbDJoYu5dWySi0Io50Tk0jH0o1R 54UHvJno6o8C7+eTfghzBeDFs88SAuOMy2FJzPoQBMs6RNHu1xgSJ5lRptEOa63wo9YO0WZc35y8 HvY57eR7xQ/syI8cbzhddSyRcwxeW+5A2gUEOgQUC9Ac6wPvTJDcW/ELiv0vEDznK8IGY+x6tE7C Eg/5SRJVSKMgAb9nilr+GvlDugj+kXap4sG3LUANYgPhBuESh6hL8/4cE+iDiEV6EZfmjxu+Z0jQ mPKAIQBS0hvKZmJTQiBGXQmzF5IcLc78u/SHFk5OZgr0kNynDClregO/veDS8QZIFIPpUnmMv6Ux x1j/b0VPcb4fOV112tsMFRN1iNbk1u7rauXq1t94jOSKRC0oExCFhxW+dO6LUptIdGkNtKdVut4n e6NLCJSh1qIKRWdWUsPFsZ06fFSnxDJatOFpg2INqd3F7eHfa3lx0MWqzO1ujDu2076jFOY3caNZ x41On3XAioJjeeH2pM4jWHUPeaqaktKIquMTubhKbfGdEXjb5zvKedPd6re+TXo/lCfJPlAzHloA VD5yFuFbsXeYk9ggDqICJ3a79es2R26XQo5e914dXSGnV9hOUBwfYp12MOQUn1P2Blc3xTf2v0K8 gDuEyAuBYHITJaEs4A+nf5OBfX5+MXhLavzBqbBANq/oVEtJ4ZuBmqJVQVULo8HjzhrCYuM2pLW3 FDvqXUK3YDwAwYSFyAyCiklN/E/4U8aPPdOADQu24j3tt0hZPDVbYf6WRrT8rq5kOLA4fr4Iuhht ArqnEt5GeBMHcmPTsx7LOUQMJvA7wf1du+5rsAeVCS5Oop08hyYcbVvXT4GaOSD9VPQxULpz8Wo6 J8l/sDR9NmDYfpyOM3Srb+JeBceliJu/OfHu6NV0JYDlRpdoms4wzUm0gechk3QWmkkLD6J49Rqi RkYEpdny79sG2NMS28KyBxIiPAzswueKHqeDOeptvHF7XPKGeBKdy6SassrgOKfSqBh0hsD6g1yS /HXl8lnX8x4xre+OoLTFJmBcOtYqImtoMP46vv9yx+IeL/F6Txt9j2RRqskqBNpBZkPUekzUNe7z PRGHS4h0L5CYISaeSPmR325jp8SxI7yT2tHlSllwcQ0O6x30w7F1Qnd1fT/C7VNw5Vnu5hRtN/pY /ZLxlJQ5AChHje7W9Pzn6w5x15+09/N/FE1jt+KV8fGl8WZizXF3u55zxXu4m155z3RGJru9ddfF 9xPGOFjU0phEgzEhJwKsNezk119WY9Sg7EMeUw6Zll8kS+qml05L25OGzxkCAKANgGm0sLQyPe2H +ZcgHV7ekbEUtR1WavgcZmb4k9Y9fBdImYPabxxI03tp0HbADxERifjPRYHIJhjC6IeZuAV+1xj0 4N4ybJp2uB0SerigWLNksR2MRRlTUjstvcouy2eJlO640jlfsEQ1XLBbQzdJoz8US3lRz42+NIfC 1i/cPvhp2MxkAoAxp1BuJRs2ibkMJ0m5SaGfJATg5phkt+OZPpOVBvuwNaxcggbcD5AeruKFNq0J CTGacx4gilxuYDkQ2IZ/SSDEDru7Y9Y2c1ZB64yvZgZUTe2zuw8bV6HN++GYKYSY5VJhJDpCZ07j rnB0/OtHWG8oDaZjr307xSJXVR5bd2yuHyvFLHzm2YyueNyaZIpCXMMOlKY+UQG5c1LYWWYhh8ZG pkIzueulXSSgxIPKGzw5oci9bCASTHhNPWaOqdCTC9jlxKIW3HTdpivh1mGqLrsRcPb0e4l36rWz fccTYyrsWOwPhBrxR0ud5wxIvCYHu/OujQuuzrx2Vr+4Y1W9XGVDumc459ON9ZfEz63PN6iIpm84 GYsDx8vSnmLJdAuFhyAhJA6dB0zCvBUUs0ppsRhWHZiGTN+yaQ+VrZ1irT0Nk9sFwNery8bxHQyP H2fWKe4athJOGRjZ70pg7Rr62SpQFIHEy8EfHdHhBaSSDXWbOvjzPnIB1pTt+axcPDZxjCpPXWcr l18B8fHIxetZ3UG6aYIX0UsDvwj4SxVvNIQE8EN2pAQxjAzO9FR4N3jMe7HTFO6FupI5o8xiGInS YiYzo0EWMRjsxVgU2lW0h1WtZzaZq+D1UtwJnQkCRpDow7sOm8JorvxF0HYiEyE4/MPm3NdUxc+E D/Nmvr5aj4ks+SjfLIoHdhvPmH9PSHeipiuu/toqbfrRjw/G/q1y2kJMkk/MYU/K2uzwPau0drXz YA8W3tPLDs9uXDq6eEnAEaNuYTFq0C88mZIJri7rNkWLjrk6BteissllC7CMzbaNkNPQD0gf8wx5 10AdNt5h3T6deKn3cfTGInPM8/BFsbQKCXNoETAk944ma40Cp3SPXtSx9khnt9/yXxonH3Q5H2Ac 1IyiJOxxLrQgpWNwBywoiz3O+zV9m54a21YIUDLGwmnYrp2mSlDfgKEN8e3IRnzj397sNpxAfKMr hzMjhL5xNkTQVYVGkiSDfj1mpO7pjpoa4GeR72f7eULwhHUQG6Hj0IKPm7y6iBBo08SqJRCSCQF6 Mdoy4mPOJAbA2dewe4nYbuZgoesH5m+KOB9fbR2V3p/xIoYIZJUdfgedEk7OjwY1Bok8TRB58H9o xJydcmzHBk9SbDnuTBwcSjsrjOq9Hgvrt9edmBc6LycC0cm/E6LDAzvvHgYkbYwKVyuLpFTMAxoX Z2puiR4qWyLjMhXDCzE92Rn1WGyhYRkMYV2tq64m0JGLStH2SLi13Bgr3ZrOr8ZJTUYysdxPvs4P gCgNDEPSFkDZAPiRzKbiJwiYKZgDLx8obIUJ76A74AcIHpKHoMeuUFR67UqSCwkSgggYPlrpoc9f 6y92uVHgczJqHsYjizCsJUwTUKfWR8+GJ80Kc9Mzp7d7NlSPfIata1oJWfbEXQJXDNx3NaG18yYl dGOiGMOUyl+aEV26QghpKgeOLbAobC2sRB2js23222Z4m2FGt8Z0PM1ChOLKJfL3FxwZd7yWnvJl Y3qXzphQYN5yZWc4K1WIKxi51vVXOb1jObwir3etgZjd3p5p8u+dXc4xVFFwhbzecxMPafRrezN0 ouanC2iqzBNVqXqZzjS3rKecRL6ec1UZytLd7V5w+97zUreCtem4wZUDR/N5744VbzClY4Qz6KSK RaSVqgSMAYKq5ijpxuDlWWmNtxzpOGOeOkuy5TZJcvIPNOEKCifYKgzCoMqCq3bTeicO1INjrnys ezN1IHiOXMyXeEes65w4XvDLh9Zws9ay6zmfHJHAwzbcqzDPDtYAmQwvwFwS8Mm0FmS8IMFQBh45 7zT9Xz5pLUHiAQdbujhQWlHy673T0uIDd854zzj9Lvas5vzDK9ITSm4o1qGZcDga00UPgzubWH4T zO3HHBl6i1NYX0W+4TF4m13YvUffvb2tQGHqcbKgSkRzaPsQRgNRrqdjsHq44jmHMMkKCgnLJDj5 M14cGnU5DkBluT0SJ9M4nipK8zr6GOzoRrRWMGQbXnG5kXUV1gw8G75+XGKAjnt27agjl1mOAho9 bCZkS3DCppRi7tFEdTz8bOGHOlWuGscQNaHWGnGJce3fh6ji459lvuCDIKIVeMyjkAztKGo8jA1p DspOQal8JyB1UdSDEk1B2JE1anJcg66c8wUtwpSPaDenFIvZLkh4FnbPSouxgG5TxOdc7DOjIFFE 0VC5TOUi4ydJZF5dh3ABISpeqEzSem1VY4jx3rU/f2HrmOhuOk5j27+UxKYEoYGZHmxE8dU14IaY FYxJJ7aKwKxN9/eqPC+UDiKsBgBAhA64hpDRTPnesuOT2hNxiwOeWOAEieWOURCxPTkuXm0xCZhX 05CQyRinhN0X3dUwCQkw7SJUE7Kylk7MUu4il4bjdXLa69msJD059DC8HPn7dsxx03J6dhxNw8Tn t5wP4xWer1DVrXvGb1lydtL5ztt7+rEN87Bx3aiHZLYN5iAzPGIakLc00mCWYDh2NZpTNXhWkY5q hhSzOsOnf5KxYdoCsKkxlUqZCFsQBo41NFfEnJqqFkZmaAH99VAe06GQJIPSZxAkC0O2hMGzXUFr gWCBloydEjYZFcxrkhAxyzjuxTz1zvnm+c8Hg66NnZc9lk22JEhvj7O/xoBmbWmD0Wz3TMeGmVrn u6p1/DxfmcYmNS5YvJLBOB55ph98vnmeG8V4xXg+MO1nTMKLWzsm1yLYQXaxGeW03HfZ9AqDfLdH ud8NSYMceu33seoh6RWbxhQlUXHXHPiOGG6xjjnpccmzp+I51Ucc7Nwnr6Ykg4rfDzSTzes19cbz 0dw8EXiL9XF2nEqWRR2S0dZ6ZmGzLRNy+rwSmZJYyugxg67ziMx2sZzesR5LqWNMX1DGGYqqE0Aq VbEsKKzvbizrZm08csUR9y2i5LJEe+qz63dyecHd5ijzF16x4xZxccTqOUa9m/+EzB6bfv5H8Hrg 8P4Yx44z361C2+LfNTFNibThyOUZ4hAJ1CIt4TnzxVV5E2UehYu9zuON6PBeGubxoVkW3ZZlC7vQ lu1RptgpO1lWN8WWWU3dpDTXWcdwghrs0q1RjZUfVbYWq6i50RnC8kPi9kYQUZHfFZvnGVnw7rkR iH6XKtBjBiMNh/MdeMU3spshUxv1hexB44lSvhKzTPNR776xhoTg1ITGyizXQrBr8bYZmkBbsAI3 jc+B7ieMYJjzgvFQW74Cn5UiEIy/3o+KDxpzWOoHQvs+1B8Ds/Y7mE6erkuIOjuA+LyT/brmsg1s MzN038GD+OhUD7AH94j3Yh/nuC/IHQR5a2mzjzHBhmeA5GYxvNxsTbfvkSC0WNZUPEmRPA6Cg2Vx g95nC8wk8YnwYa8E7sea8VsvTccGcmLRI5tFH6/pv34NTNmychncWWXM198cR7qllKYVwpOZmXCQ aDWuTGMpla4uRMjMgjlfaCISywzvBxWta80S0xI3oFyW2eSthrdHQyFoTKXW36lByZhIhaxWAYkz Ih5FJFpVyntAsSNhZItxgZkzMw20twLCpq2ZeMXYirXJhqGEVHaeqbxDeh363psIIhVENonAJYX3 VnjUxAPYBwqeRAeV8i7A3ROITrj3GBCuLHbyb/yG8Nug597SGVUSO7A1RkQbO/DVAmS1qXC3xhud kcw46CwJktOd3H4125NV6rIMYJxxtBV2LW+WRkJWmZ1hAF/lL1wtYVGN6zjLCvE706t6mY4q5xcY kiYWLwPKM1mZdTa0sZJ1p9D6jWHzbvgq84jT1pLT1Cua3imkzne6qVT71hVjMKzMzikVRcvlbzLz GSLJtZmKgxDatPjEQ95zT1OYjVO6I0nw+MvSxbreMGMU5OqKwQbcjbk5ziKzO8b7b+o4K3qNuTpv FczxnPg7th2Zvz6edpW+2MLYW0hObK2vrQ2JQZMUVPgObioAZ/EIdVAQOAiIkQCKCWx4dCGlbMih Iyr6NyF6U327D7j76qOcrFqutsPgEbMWo8C0jod2WhimGCIYcGZhz2dPOs2BODR6OjVfxKvueeTC k5buec2sWMMYUA0gpUAEdMs5fOHxxMt40qtUfhsuye/Eap6PPO+HZX3Lw+iMVqwxZ3GdyhjGiWD8 DYBCYGiDDsHgZsczro2NjgAH8bfzJ3Z3AFkevRrzLWMLaTMEeJnS+NP6O+YLQN6Wt+jiWGvbpEm5 PAXmLF7xDMXrwcFg4tYGV+fo+RENamKmCbIZNfBdFzMpM0WoLSTWJCz/grWhuTbH3CJQL7C0EECy FUEdbi9lgwsEEdqlEkRpHB8JN+R7+++g6uy8pIDuUAD2ei8WzABi9vWuP2YxmWZhvvuGatcanPXL /bemsng04VMX2CJw0LomQ7vkRKwLMj8hDVIYCrGVs36UzzldvEI4TXlj3rN+iFk6iqBATV6HkzbA xTVsizeXxTejKIH270J3PZb/ejM8QejmO5MskW7o/tBlmPH4mkaOvCmT2PevsMdY4kOHGh/XInZ6 dsyriE9V7nxznnTMZcu1mHs8j6amA7JOaOShGYjcPKTWJqjcOZHJJF5ST3yJCBBRhd1WhviI+Nzb IJu26RIC7C3EprbVK5FDO0hvQQpS5rlV5Ta6EeImZKCRUxpZXbCqXtA16RmncDxEIZgHeja90Irs km8O0Spb0fFzir2ZhNI7pHx+V11VQOT7f6O3uhx+X3x6fK6u3fxCtGKIwLh5u3rC+v1oDV61s+TU RWk22DFFS5YGeLusR8eYGwhnLXJizbbWGwi0GZ2GsZIamA9bputc3dZGezXYVphB8BdkbLS5EVTG Fm3eqmseK1fcwoudVrnnnDBwDMUMDOHD3VG6ves51ql8u1Z9x4IOqnBL8MAz4IIO3BGHpWojaoXK pJ1zKOaIU98Fbvg/lb+AB6r1sSfzzyS9vO3Z3HfyuMvB9zRTNDAt43vbtF+5iIYFxnfOhbrsLp0b AawfaohSksUt85ZbdVrXLN1ZW0nWMsSBlYb/QuJv4Ei2sLb0MNuZljY0Z5yvSbLqG1eLqMY0/D5W RhkOwxvWJcGnf01s8ZOYAiGls46xxd7w+ToiGcunxzXgyeF4JYyTk4NhOcd0GT0rPF1O2Zqi0Wc7 5qDRycOTwc+dGRAvK3BkVVcTTIVoZXlxQyvwKDZY2l1sSpIywaY9w8K2xOwQtSN5AspQxMSt2BjB sJ+dELy+pCyVpbhGtxdSV+ezXOwuyHMLkLyWVci+pYphOpIb85OSfRrs6tsa5xr1ByVBujRJy+Cz 8aYI5wRR9M3Ns9KYGGDxhmQqOlxm8ywgp7kTtRBrRD6pCnnQKQzgaFDl1AfztnFwfSBzuZKQPdzL y9Cmo+V1vjr4+FsX0cZ5YMjfV1TE0nXHppi2zPo5/o0b52+MDbWpJvQdYlg0RpEK0cKiHUMkh1tS gxLkIY/wJv7HOOYnZamdxy8TLxxecVDukq1dsZioRgwKtYVmLmNaLepeZjD5SgwsKnmUpxWX1L1F XhaxUVppTu8vlLFvjWCZuLdzGdXM6eqhYs1WYzrOXeaWoxOr1U0+jBWcqcqHvELWYrKWVZ3043Jw j/t/xjnfNJ+scomJ6d3iO+l3ry2TbjM6Zxdgfn+fGIT+s7swcMrzYZt/az2TNyE1FNoFlLsAbABV kR8tbubXmAcSZHqi3U3F3yelT71m4wL08bifUSzBhPvMOLyfvq0ALq4GYZv28DM1/wxozzRSCQEg qOXqxcUMQScUDXcVpK8WzG4MxbA45RvXHnNK8lGSGAYnZ1u+v4n0eKjnk8HFO8rieufWOJqGrFdh hkCbzMLyjkF3z4PBohDweeayYAQ8rDjyt8aVrqR2husiiEUxswnTKYA5dil8IUyYWNRyyhkmgxla ZngjrTLfma6JVzCIfWr8zBnxiK1svE6u/huGNIYZoPGLGIS1XPgnhMZ8vhci0DJlX8nzdehMw+Xy jzp3d4HclOAm3E+IeWz7uPGfMAb5kG2F+VtBtcaQGe+qLQoZ56GmohiWKK8G1www0n4SRda7zJRG c7u526NMvRWtagbT8QzBpkfJv3xurIhDnn5mTO/fjwY6xxzo0XurUgb+BTLAMjy+wEzMYPleBEAe ueOpn1riQXOTQN5nj2+c1a3SRi+3vNLJw71I4zNLtam6bCIlSxoYZoKpvdmAPDdnZdaXgv1x6QjP g4k2Mc8x58TGlGHp8dBWcGK6PNaP4xitCmzrBhdFo8vml6sU8d9p8XHFKtvC1mN5mGlksBsYw28z g+6AMGOilb6o6iWGt8EejuDDNWfb4XEjlfMDxWJEQbJknJVpC/pbHwI8eCB2g2ed8T7CvfD2pqRq u4p4eicW92zERmBdwfKPRrePIlXHw5yyaCiOW9Noso39Dv1WTHBbfNG17KeoiKRy3R+0LOTn46x7 z8d3xKV/D7f1F36q5nEcUYzfu8ZeJpWzGB+HsAn4x332w+PBGyOX4FFBWvKs98b4WatJ6M6QLEwH svm5a+WscTBsFxDiB5GZmyfMv6bpFROPgfxXFmeLfVvnOXlM0sDPtbPEtnycRrR6gfgYfkGYXHnn luf11iESs8ZUei/JzrHOXo+KOjjz64Okb7w8hyPwIgiNx1L4WXwXkznN588E/zDEt7Nkxw28S21T +qzXHPyaNa9dmvoWYipeTjVnxG/jPHOvO+jzzyO22rwc5GZhMkAQ+06i9L4zMINao45W9r2IZvDQ gQ0oxYZFnQiSt0L45mBr04SsncYYJcW502ELXMDB+KBIupqXsWDUstCZrAxwI0zzvsrmmDLMUu1x xlphgMXWavmhiTROyJ0OceCjT+EtWq9mW623McneTRg5SzqpQPfWvBEP4HnJJMDlZbHROM8jlSaZ bTea+C+UVcwdE+z2gH2PanzqGZn3pkBvROZ5DrPgQrq4XA7tQnXNTQ0MlQipCIhTwswX9HpAbRwj 8E2dpOGxgBuGZyuHAeJCbKunU50PXnCSAK3DxbnnF5gYtMwyp8YTsMStDMGhQXjKzxc2cVG6y7zV u/EpTjjMTlVdTt7rU6zuYzCoxhFveXsmiLzGhXlYzMY3rN3jMZt3zhS6uDF1UveI1l3kzNZLnOVu rUzi6hTiojUQ70qUWGKL0Sic5mYM1pzOcXrNTlo1M3i0Vjd61WojVQOs6L3ule4hRgxcZeSLNafc arGpzFO8VWM5UT99ls8qrFV3gpjhpHYMbloh3RvBMQXODnfTfs79he3DhbZyXX5fGHidrodT2nNT i8UY8lNr6qplB0sRLfpyLFrWrDLopOTvGNr1tXdx2UkW4XCJY/FNBgetpnJ/MvWaMl/U+DTBAma/ t5xIMejVHqoYyaeT+J9afYwuF12dx2YZsxjWdzk6H9mv0K6bLeuz4FkkuPGHNZPBo5EezrhNp393 rm/BYoc3OJeepsgfurQAgbAxq9oJ+OIZhMDNl2FybUBjD8xKx3XqOfeejsxhGuHMLR8axdasZn9i bdyRuT3bSQiuP14U/PzGsc4Otv8E/De+QB0gTMweHiOSfccPjHHD4cw2Y41KhTQ5VYYFkjZCL86z Qs4j0m9lMdHgnekwzkw99mC1gtlLZlNcTQT05eQ9JHIoxt2kUDXbsw1eyy2MGi6w0hsjQjsERE20 3XO9oAYkgGEHal5nAvjtNpe8S8piO2Kw7sY0aduaXZTtu3pKEaDbCEZNEvtT+oDhvGdi9sy31vGH xKPjCrzjTzZFD+YkGxdQ+1EIlm5jaktxiffo+NHyaN74k9cc9GcapyhSa+PE+cfHrzZn3XkH1lVp 7g4XMtL4iLsw11jFUMal65FiXlcJutejeMXXjHHsyjjvTZ/Ds4+EalZjZ47zvCvr1jFHovvJ0aIj 5APuMNo4yybtd45u28zT4t05xnFYubJXT5zzWiIRR4mZ9xz8N52dpYC+O3s7m5bnRLb4wb+mM3ri HWdOHaOr+kGc8t4NPL6Ot5w3kk4krRp5uNK8bxgGbarHxioaDl6sfGBhl3qafe3Msh+PGPF3ypye u88wUYJYbSfeiFSzfoWKaqy2Mt+cR3NWH0wIGsTSJ5j3s70YrAnXDJOeIJ6uMcHBzNF1HyGhyFz0 KSLTi2p1HmZ61An3637Oro+DnJ4K7PPk9+Dxj9mm+bvyl80qnzpduIuHik3cVlMzDRdDyOePoXc8 CsWFT5++mhcnk41GuFjWDk8dec+OO+LV9NHB3nS95ik1JM2NxxA1oKpqLFTyCFc6dQlvdtRdLieS OSz37pRyJbFahIiQLJ4ZvSZGpVZtfYM5usuOXNBCBfukuGOF423JyWGeAgmD5PYYaAFaroLpW6+R ks4nVSskWWCTPYIMhYaVnQuLs5XTFgJeEbMe5Hs9tsycbIaDPfvm3M3Xx6PH6eTbaw2JAyusWssz FUwzjGmGS3zLi0ymYZjezVJECt95iaWtlEgR0YnYZaYsZQshn3otnPFAHEIIAlQsANQBgp4gDu8w FxHY7EOleQDtADyqibelEQT2GgiImUrjsMQJgVTns03Py4R5vCU4in8qIhwyq7b6mouh3eEQ8zNp mybzhYatZjbIjxWucOnvsoduoq1U64DO+ZbkTfBy6lYxL1Wq295qFZjGlVU+MrWdqYtavMKMj1pV AoDES9utDxjOtQ+NaWYysot81A+czqZxmKUM+M1nLzc4nKqo1rWM5uKdYMwZyRd50iL1M1i84nRG qusYL1E5neohycRdTus1Wt1eLiratOs6y+MuV/G7Jtb271iYytTp+oQCIbH4XjpGtLIR6MHwLMW8 qakLEWXRtyyqiGIDo4hNEJxuPEn8kGCK+J1lpzUPjGvA+NGtGXn5szphmEx6Nnjz0yyU3+jVOw16 OtwKFXQMZ0b9KFyB5VuJ07BIn/aT+nHUeM5jZ4xwxdXs9PyKt7JyAYZX0hWyZeXGN92+ndiZUxsh ibMFW4k2MyEsVyrOVJrnOrw+EeNX8kccUaPZxJLCsuG9p693IBnZbtxY/tdlb53zfOvA5HXHng1X N3K9xIiq9+yDGTHln4O9b05aIH9VnM3vJ388Yr4RGx24Ry/ME5adl03pl607SmGfcMZkoXEwamJ9 8xIq6ePPvs75O6uevnyOOesd48e3XhdLGPXqKifVYzPVwURNaNBil4yMQYzDv7g0tljxDMwyMvCB eUwtrkjvjPTznvTpIjc8dN81vWIS1Z5PWRyheFnHZB9VQLUTPBztNK3wwFV6NjCGWi1e37hNaLbl +PRVMbql5iJF3sHgbSGUdS+UWt38KkKDE5MlxkqtjWLRN9Zk0e72CAeYih5CIl+vPfCHfv1y5ms9 hjicGM7oWMsIPmjQgOmixZYQZ5rt4k8zIVo0Ps6/HjN+sv0a9FD99vyseHOIqMQa6yVfL8nfupa+ HZZHcdvGH0TcCw/TGd44lGF3jUrS6lyzeEtOrcNkwQSIo8vx9qjrTmutQeBSeelPrOYutcj2oF+S ipfg+tuWsrGhNMoReU5UhXDziJRKiVPS98/MdLikXxJSxxoieXvDzt94qG7MOyQT3R+zg9/BsPML ve/PIsSSS7V4frzGZfx4FzcEj0XHMCh5TZv4PXNHHa75lton5T+Dzcz9MeYpISR2LR6RBjVNPRnf O+vM368ZIzfjhSpVLecLdGYWsYs6qEm70/YmH1nSrjOBW5J5lu+XvngfpWquS6tTXMnpDEsybB7R SBUcwJEHtDYgCE+1ARENhMwnaUpqM1unTmlM6SzsJWky2+6cSRdUviRTKFC4qNuH3aZNSbJMsJVY riNiRxq5K+aQxZrGJLrrvnz1RvnxwTzfY/WNdnnT3rezWeT+fx6l4YltuTFV8SIRM8DMwxzzL7zJ Li9xsVGt0M7sLy2tpMV5UIUtuUzMned5GphSSTsstipXqADx+cETYLmdSGlCvTxCeR6LieVHzAHM B07JNvNzR+/iZf8Y/eflOPvG8u4OhaL1+WWmraEzcIiFpQzOoPN9y4HGzkvPKnLWsylHXGq1Gdcx DBopGh/+PEbkzvGoucReDGycxb1RClREzDp4fF3Cy+LWZm1wVjE6modRNrKHt5TRUPWBRlzWVEvh TqaunjU5WbNWrpapagzN1klRWcYtJ3urwqqsyPqah8ZiqwRl4o1Q74zVPFqFWc6NRh7zNRd8bzG6 fDqMsO76unW1jdajF5cZrDkPx3M8Z4WvzqZw9fSJwV1z1wdn2a2zk0aIFgKB2ibhLApSF1IlIDKL bdvpqedU64WpczfCxl+IudYzE8Qh32a4/P6QcDGR2s05P6c3PHnkjGTeQzTmKN+MEAd1eAbYL2tV 2noD3SmjhEqsy1Stl19c9MXHWt731vlFep8Ye6xxT6t6jideMYN654k5/c4Hr9vVzyQRtMT445cv z6i/lP2A56Fa4AEwPXFT8stHuYwtI2LCjaimE9XAMS+8sMzWRVWYykLbLLzgPtsSs/Krnm/A8y84 nNz7mznZUex+CRGSN1IBFnsjzK+m/oeO7MGj2Q2IKh7e2d6GgI8ZprvgwkpxJ8NvEmjwORHnfNXu N+ZfFTMwV4V3nznGuB+H5mUYD1RPWJ+D1OT5k0ZMP4hLEPBhgGygDVaOShZfF78hBJjtgZDWlw1h MzLsCtLqT081D0vSiq8ytSsZ7Eu1pS08KBLS9evUMMzXgyImazXTbV8MWkt2sipSknUEQuvlo5qx PG5b8IZzs9CjnUZMepuq4zCzN1GFeSHhfE/CPUT2eH9Z64er35Wr03xOevHjxgbXh/JPvhn8Hmmt de9ElsG+DWXO/Fd1nwpXjrvc8Jn8v5fmNbvNeZ75NfHPswV4i+s8nDkF8GxPGng8u09KTTwmzmI9 pD31K9XPJ5c8c1p7OIV9V/tY7y4zdozOF22Ue4nC1XweXwqXKFL+JeBLLnabW/U53VnK9+BhuCjv B76IjXS378eYXh/V8+8y7vR5bTfMYQyz3HfJzfwhY67nj1vCPhGvl+UeKc2eB8bfi5378HfvOuDf R7jPvDnqe70V3y+R/fWbK6vcGr8cE12U/A+KHxoW/gsvZ7ell3743FZrrw1EGXreNjrq/Hhd2cyS Z0VBERLJYTEE3gpjjoYWGOlphIlmZmRJzK85i9HvqEzHVb0iDV9h3Oz2YLPRy2ezJ3UZacni52eS IPM+TGDySQECI66MeR+ijZvRyRs3HJla/xMxrzfWPFcxyX02BUGSzvx35g7HfR5EXyuTs63yd9H4 jHRnvjAuqn110dEchUWQefeF087cCaIWmcAzRqkSD4Fot9UwqFWFyjNspGWuhobcG45JxAPaIuE9 KHZqBoL6EB9AmABf2J6REmIiJyTe2C8KOuRDdu8plYPo0mGKuyEZk2mJhykG4JIn9LId8V9LtlTm FSE1ZUy1u9JkiRQsTUA8uzOorlYzt9RLq+tLO5gzWVOtaiqzEzmblW0TGrvOpK2+rmoWN0bjV0LC pqzEUnE8ury5GN4jFwrIzrRdujJmXLfWcFXep1nT1bw95czktaxps6nMTvOtV+6OOJjUrWId6dbf D1UM+s3aw8xxFzWae7zbne873OhgilpMQQrJ356UXnAuum9nuj8rpXlyRBBRQRkRkoAMiBomO1Nq EddhhCGKw0tvq9GjJpRlY9QlW2Y6Ftm3alFeSbNdclVEziIpfz5Yt5MCgzO9vmSkrkyJa2Wvpi9Z Rg6d6WaOrg5x9fPRfkd+eW5vmYt5LfVTNKovm4FJhO7lZTx25VVwfpjIzG+e+t8nFBo5DeMZi9W0 cLJwY8Hk6MZNkNyeTZGzJ2/js3qeu7qeR7y7+M51QBLcfrGfPqDOmbqjxuc+YzYtC9bqCO5hjGuy H31m9S1leTFw05+URESuJWtJ5mYxN4X4wImRJLi14nveqWqnU5x2t0+5xjcedjNs7kw+pVPl7g5e hQMPwsnsec5hAcnE8zYMxRV7x86aVcng+eBzXye9eG8lWM2vfmsStnmor1PfGpr1jPjjMStNdb6H 0RnKm/BuIxWTzOZ5FzHzm2ArrOjzu/ie4JLg94K6M8Z8mu/LNl6fPfnXv2sR6xcY1Vc4fT7zvW+a 8eB7GFfWiEamZ6/RuLwVZmc91jYX50aPHM+7qeLb+sObb1zxlxdkbT94zBe/2MRQq9vjvis+SPp1 MYnJWl5mvpwe6g5rHk83XXXWKz1fyOdCKMnGE3TRB58+fL8ee/a4143EX5ek9+lM9ZvU6t/GyPWp 3hVilXoo5vXnBzfkxg87pY5XnG/46PWj2bPLnJfaOzn1/KAUfGlyP6S2/qVPGIw9XNbWOusQSI3X Zo1XrwRF6fWq9xZ+8nxP4OeO8V4GPcRJfY5s8gIg4hnjRpYrGOuerPSRKA7ynBpkWMrsFgQKmpbD PPpQOdt0sVL4D4q941ZkBZxyg0eArVn1RifKzAtitZMYKvPzo0Pjz0e89kehiSaBmPAe2GbjiiVN dTbl3n5k4bB58rHeqI8vQgnxjku8b8dq/EYk6NUsHRB1+9mH75TptjELXZhcSsLS8z7pMXE1kQLh SeFc8JTsvLZZ94ml+WGBQts55GRPYa3j4lxUrnTKCOoaW1Mi0Vy24QSM1iM3dnA0XAYoYkqml15q t8M8HWFaXVgWF2EDC27TqAL9QwF9iIYpbApt8ulxIvljnK/dXJWt0IFu4OcDYB3BwocvYKcgp5Uw 7ROAFNwHOB0qQTQHqTCHXte1TsR3oUCmXh2AHh6B/Z9Zr9bPxc72ebMbuNrw2o3w7GlhERSwpIty /1qZxAOWmHZqTtKMbltGnlZ1NExEO/Ked4zndb2ZusrOZre1i94vWdTGoWZ1LtT6LrE3cGKjGdRq 9Ym30a1rU7TypqNKK28U7Zitu17qpxc0Tm8a1Ke7xTW8mpzM6f/Fqbu7krRmcU+zG3uwyhOh6TkV EZm41D1einqDJNajNvMTMLUQlrWnzhJ4dLPGJzvOd3uVC6fM7SteiR8nXW/G2zLx9mltu/XPFjfd 3UCuaTNUYJvBYAHgYdhjHdQ/gh1xO4t5elitdjp7nZb/nnW7mcNlmPkrmu+SY5U8c0ThEZWmZpc8 j0dwRuR0RetcqAKtOn4hGqv1TBfXMYl3fhc16OUbNEmh/LDbK1k5x3gw85has4m4m/jG8GTydEwb 2QPzl567HtA1U5vDsxAdVbsO5gWhdHeR881H6eqJ3fPZ2eOjTnGRi9Mt6nM65SWU6ih38YxMW2jW IGMe6kXiuNEre62+jXZMtYxnWyIOuXS484INevBF1vxqvHhHJjwLDZ9+IPOjkfo+oV1+56W79TO4 1OaePPHWX1qVnz8fwDZrrIdTIsfR7A1jBKv0/wV0Y85c8Oby6c5fiWB5cypy+Vzjwc+eoRI9sw8S cTWV8Ycieyx203o+nk8yvQjqcOsvx5nwsYnFRTAdrguISrLwuZ4I8qZqAELCiPRM5Xpd8uMZRnb+ uuTvvrU52det7/Viee+zv1nUOKsV3MvcZUqJp+NW/Oe+PrsszxZ8GTyS8nB2d0c3unbPT6E1+yMz g1weia7fdOMNoxzWCk3HXHdCXmtm4+D4nJPfhgPQxzuz1F8xzq48xajEzc5U3eJvMNxocZmbuesP gXn93PqTtYW29jjxZDu7exNs9Fq36ozk8EO7nkznJHES/NJ/KdannGpp+YM1j3niGzq8RyUDpkQn Xxg4bJzQ+jRoutvurKJSfEEJezwY1ptnU+5M80bOda9dtxqV5MvfPJM8leF4N2by/xzSUTz2trs5 vDK+iN8SVhrxD5fep7Uvv2VipbePE+VHp+kF87i9ntw80UeuConeYbo9FwWLj2ePMkiIPejnPd7O o87rxrvHid3rFXcu9U+HH3o2Y22L96zg4fUZ2TaycQQiCmfM6PjEHx9c9nXBfwXz46dgAx48QZox HwgEK6de9aliXd9dnfdNF4I5+MmIIPfvG8a6O59gbdfcZjkQAmWhCyUjJ6zSJK4edtTUtoY2GwUb KZpfVM4YBVrBzS4zvthQyUW6k555mDWPXMxSdaGEC8ndK8Us5H2dXxB1Iugzz2c7g31z0dDU3izp zoR67zUpbYOxaKWwKroIYZmF8y27LDLLG+sSjkUt0oVvCT5mC3YYHkENZF5HKsKY62s764QmpRLJ FtBTC7EpViRYsJl5qnNO0BQRjuAOgSwEA1AMBeQTWBRYTIA2CaxF1vavHN6evpt/p0SXVVA/R4vV Q3xTwac7nUW3Ov4xJx/K1JlYpFWsXAVC/AyS9bdz8A/qfaeMdPTodUU0m6IajQFAP5KgoJIUQO7j 1N1HVEAsQMFwFqFt5wUHBUAUdsvnkelZGun8YWSOkLdlJDNA+j40eKEVVVy3dm5tp4Ym5mDVAhE6 CJTIoe3UHdjflMUslqk5xlTRSPpAkWOhZv4Bzs9mjfMCDf3xQgpo7+c7L8mtRLEx2zm8H3H/J0bv 2T43dr39/MsfPv2KKdK1SxH0ZUSJmXpBNTLjYSmJvmOV5E6Y/HAwwzW9dzcwM7tryQQVg/NkP3Uw p5v1U+xNWb+Oz+5Xke9fvS6BbAOGdenuVBhVPEzBJBMPmZ9bElzTlgfAbPm4oK1jWYYkH7SzcfPp y04YzXmB6/V6/5d+q0DExIxIXgDSf8H70f4aerwfIbH4iCe3DTY+IIv8bFJWFKW9IA5V6iJkgJkU /B8iKtJiHWKjeICcnWDhEVYH8TwiCJtIAp8U54KtC/rzAesZLf4XTd461F4/q1q/BdaN7xQL/KYy pB0+r9efDaPDPyb5n8sMbG3w+al/k60NMS4ZG2hNDc8ucM4sElUc9+G799lZi+QIMf2wq+ubY2sF JMMKdikBV8GYWFFQC2lrKtz4aZXdcafPR/HKjKMh+slIryqkiXqtIcNN+AC5I/x+atIH0Ey20aT6 ZbXzbabgRVOSmoTfGi8rTUJy6K7r0PHA6sqzFVwzp+StXXBPkqnXcKo8IeaGNCqhFl/u6kQLMPuk f7+I70m2/ooi4n26H9kOoj5TAw/bzpfCyDdSVq+yDXbHDFaRxLkkOW7le5rt695cZIV/DQfXc7nC Jo9okh+w3Oqqec8SPoq6RSkerg2Wf428+s+Q6hUTy+b4pkDsBU/iXWm3eTME0ChPx9RxPs7iNidy MoyqrK6l5g4pgyHw03a15P5vbwmaHlKRMvDPTn+HjONikVU6zEf7EFpvlN5vENl+T98t/uNvKbCE jTw4ZH4afnDPBF41Ae9VWRt8Rctfw4brbHGPPu8ZnLOKKNPzy8voZ4qmbInrV5wbInGZRNkbzaRM ztpaheKQhtrjuuGhrU1vnwqY988WTwLbuaRGHIlnP6EHDJmHQxQr4nozfEG0GOjKasqbDPD8d8Oh R8DSjqKqmmmqqre4101+Dhc63MX3fp1qOw0z7oJXpaCnWoEBcVD6n1cIK+rJug0A2MzKzK9au8W0 JKMfqUTLzrBHUYbrclQ3hF1SSL+w7WbQ/85dG1VQvbOdtzKAmDtVC92zbC7A3r1DqgpkaGpazhz4 gp0PdXa+tPTjU6v2VU+ykthiBR/pv+u8HMygoIJo4jGjLDZH+M5JX0TlxDhNNNfzns322QQJziON owwMIwoqqobggMKEdSgZGQZKOSAdaiegCZB1k4R0zOJd0pqOCm3ZCy1XMak0WRhEUkbY29tBG7A9 ftMKPTg//Rn+4Zf88J/2UeRUIaJqZplTn5e/C7gE79m8S15wVRs6aDijuqhAOzjqju8Rl8OrX/NX s3P55uv29wKX7r+yNPiaa+r+amY9fnISBIa/h/upydEApSJBiQRj7BT9MUDVKKdgUgU0iPugQ+Tl T3KwD+nYHLJIol8lgKQQKSAKf2BSIqUgfB191dPtq2bl5py3LGDvWuLy1oaoLHpptxh3X524YbH9 0WidPjXGpqdfyTw2nX9qcebueU29HPOH5V8SO2uuMVRjDu74TKU6USh4TZ6jms2zoJQ9vZw9FH8S +tcd7yRmAckau+4+ry7f4cZeF5+Vz6/+ITNBNCzMwlKNFVRx44h/PvHCIl92Fo0tD/4R19vstPF0 f6P2Ybpo24kDkEVX+pzmA1VQFCUUu+30aDZNMQ0NAUhVQ0QRRRJNElIRFBSrQpSxESxFCxRIxDSR JQMQ0MQV2/Yeo/zPTPo+JesjN50w5Ui02LUseaR3Taxhtqq3MsS1AP4/n1F1iRW9RfINkgfuL77l 0WbCAXIcXfRyvL+aaZZQ4gLuhqpFemsaQD8RI60FOLoab0cG7QsgGBkQf9zRoAxA1GGlF7L0fX22 ivJMyVCa5luG2lvBK+t4NxvmTEQTQdWha6h6oW6W/cYOHIzSMa8MJh6i1oupr0qaqVeNF8pZahrG UnI7MWzGT5+fhgDXg1vTH/Jy5KOEuqgC8BgI/7Mh0GgvEFmD4corqNCgUzXTS+80NFyHRNEMvzrT 9gB6LKVE9oKQZCUUFA0VIS0FFIUkRDU0tRLBUM1ESQcgKY5DMREBNBTBVEQU1EQFBDJFA1RUUUyy nUFJTXfignBB0B+TO/qhKWBgTNIBbtsQECAwSGBEooopGMjjAgLwzAiGJiKmcbSOSa3jtYIhTThE 0gBEUXrwFySIiIiZUiO77Ohr3XygBMATTTTEwTTTCTTEyzDME0wTTTATTTTDMBBAk00xBTTEww0z ME00xMQwxRl4FKAVIMMUhR2FHUX1JyIu8N/1+S39PA0mQKJhAR9bnnYyb8kRA2yqFKmo3ssBDZLV zAtnEstZZcGokOak5Nu3zHN6DRX1QBv81RpUu5QBGo7DpIVMN/ApKVDCj7nIPDlxu8+glmdpZ/11 3+1T9P/9AaRSNtzyt/gkzx7n64eyHR930ZWefHbt2kkjcJJjN0pBxzcDuOMzMzMdzvAZocr5/5LZ py9f2zwMb74P/zoNGOPLdvFyQT0WbLf8e6ApDA4CbxdKMdqpSwPTTqvdzpn1v/VbV9/XBHut6LfX 3HbG68M03Ag3rOPiCsJJw3HwEfxrzNTuBKUV4vFUVGHRUU9UhiRtCJIvDWjCfnqImmmZ89NHSSDd 2w+jy/HVx2ner9gDoWchdGeQYl5JPQRlQt5Y3qSTx+SYBM1sCwQOyzTZs/di8Ff9WJkL1kaKEbCZ RqSUGno1b2uG2QHZ9R6rmMpEgh7Hh3Dc4N+Gi+/qHz+ZtXuThkWqvKrOh6+K4emoplPiYmDTUtxl LlK/sZ7Pz5/v3yux7ye7qKnr8XpSpeoP5/53+fdx/PdyWa+chxNCal1/dz11jU9S0MtuPjeI4oCH s++m9r0kJJRl1+0HJZDf2Clj42l5hdjh2pULKXfqYlfdz5+cwse497VR/1j/MY+m7TXBjd/uUD1K AyJQEBTsBTAKUpsCRWBTqCmgU1INAUpHIKf3ff+UKGSn+IjCKCSUigh05/HAPeA25ZWNKp9ooGQM MoNDBQF4evxYF1TzRWgWRIQE/03QUsecKP/GH+XQKfsV15+WMQERBdlQn2ApdDh5f/Td7qQvAJF7 o9u+m8QkdmmWljswh0WCg3eH+OzA+7+psV98z+g669J8pS0LYhYaIe/8lgOKD9hE8R8B9pQea47/ 2kP9wIMBgYG6t1zWqqvt8OlMcccwZXveqr2AoIduGGEP8K4hfxcffYeODN0lfK/0P8ET+9I9GIZe qn6TMMwyADT8SdICfSbh+vmopgfiJ/IlrfvouWIFJf+y6RcI+e5T5NAY0Bvi/9JvZygSj+FK7/mU caP9hBNrmbD92E4w/6H/5vGESEIQhJiMD2E/7n+Avye+qO5XlDbvc+EdVNsHkLSFzmardFVjCBFd VqV5wGIOrJ0JWrNzQA23Fx2JrgiMphRNATYKyFqQuumJaXYj4g4mEOa9djLaAu4B3KsBMBu3SSc1 BquoTq+D7vj0ZD4h+04Wv93tZGxaWsSNm24nx29uh0Y4nctUUSMP/2wlEh3hRQHmxX3rAH5OD9eF E1pPIFN5TyfbgagPJh5k8L0l4g/9mvsPEzu4FCUlKRGmIhgJCCAxZI02nCQOwPx8j2Fro+YhpAxY aDwVsXIBAenI8BsIG45pm0GhDBEpTJlGhy5cqA+2Z+SkN9Yj/LziBtiFQF0n23gkacAwwUgwBqyy bPK+YjTLKKTtlSycUrXxjNFkXCS9Bho2GZY8eGIqSQiYomIJIKikpX1BiYxElFKLiSkRfkH/ER/K faMSKuuxqips00YYS39acJyAHjCh68J12A/v+nrIm9Pf3vnEPxgsOB+s/mY1AO50DsXf1a1ut2Z2 zY2oAhZ3e42qJcsikYGCQmko7zPenv1zNnoZIQKeAQ7KvYPIULyIQkJU4MGkEMjfw5vGOT7uONn6 Ai8LFsdXDQFog91rSNqq5bpC9+vfR4CEhBdbtJ67DcglmDcuQQ8NJ3emj74+aH1SRWKe6z05Hr0v TvF62PxPyccgxo/sG6Wtt/vPw/iw7hotwWAQajTRIeYMI6KkL0Zv4Me5QhsPWDh/qp7eZy8ovxjY qNJH2lAdcB/ThcNmHGad0I+lsyu5d5/m6BXR3ED0t3z4JqAMNMDkiX8Hhf+e7UCP5MBmf8Uj6FVy SFiJ79TaZ0Q1IbtP7vWqiHdsVvrBzM9MT5P6EGFBgaJgWaZ2Gh0/0e/300jAwgHSx3jkOrbxzMK5 pcLuHIdzm/qTmHAGrY3LGo+s0h3Q9cFX0RH5InuBBcIgYsA9BnAHT7QU9s6yxQDCpSQjA3rUYB8a G7rSYDy7Os2lsS1mBkSUmLIsFsOuDuzNPBUykbC6tmKq04lJMUlVcNGmY6Df5J9DtwrBCWX8uQNy 3SDtJAsU2bGCP9LMph8mg0A8qHw+U6uyQFSZUopUpqqP+gVNSaDUi7IunVQA3Xh8ZgBsYDeETvA1 A7k0F94dSJUOJOJ9Rs42ZPalqTYNcycAgr38pdig558j/D1uJOQ4NhkZMgRHgwDr0AIq9QNMWEzh q8gOHGBuCY5RXlgNsfhhKufMAdEMzemXQNAdlGiDWhBz6kBO+qVnI3cu71E367kDmBTMzk0DdCHp t0KmGBEUW1EeykFU1AaIm14+z35yu21tfc4+Ki3vkIEhC16jF74mVvGIvfwUyBWA9VidrlFe6KPa wFTWg6vG5ZX4puFH6NXa7vAiSCSI2flMDYhwJsHTQ9xyoSbK9HUXve9qZpMWyTHWhmiBIiuM4D2H AORwsU+I46TjgUT8zAG0CTd9E8JSM+vWJ7hjAIPIgICCDMTlQfefIomgr0SAHZ6Cs7gYcx9RENsJ D+x6ztVzR8m+uD4B4PAH2MSQSHGdmVLzOpooKAwg0EVNaJtiPJOxdHD4+MkAYwhnOW1nYy7q3Ptg 0cJ9Lh2QPeyrvkg4ThEouB6/DQwVKHIkVUDBGGwbYYXghhjg3Qf7tVT7izcjuJ1bTpY2EqIbzFHr g4WKDqI5Mav2Au6QvBAOXAEJ3aLIGAp4zTQHXJFsHLayeneCsLGDaNjbRjLkvBwuUFoN70UbMmJK PM2bmt6V6U302anLtZ2RBBT8QeS/oBvSKhlcKnsppiD8T93UKPUeHbYF2yEUD0tlBOFDID6Xk1cG 7nB9ggr+Q2P3nuBx9XD091dt6z9Nuqqq19XqD2HbwKxWMIBIAX0rEXQwAOk1bm+YJCvH1Zh1PY6P 0CA7TfeqNRsZcggwfx9G8DYGuum1DIK9ljwv48CvEN7LIeZ6y5oDNnJaizkQ+ae5sZYmVYyxsi5R dAjUD1KJ5BNp56T5jBDAObnKdrAE5jwQ5gtCHp5Eu2KDwmvCq/ZEqEkgfVNv1lHOgaMDNZhEhu10 6uwMxhZkvACY1gZQfwgcsmkRqBA0EaUxKIeVR5p7Np+vSu3B6n0mpwGHuwTRmNEz3Xc9eIB0SrX4 QXnJCAvo0mGu4RhUYkA4QkJogVr7PfxvP3aMIqww8Fc1Ft9FV0WXpuUYoolmhyN5SYLCzElnPl8i XDgRRFunS+Hsff7aPdmATGZGdxBoo0JrAwYWIHjLGRYcEBh9dtoGycF1972ph4lag18jdhwwEMUS 8RONi54goKGEWwKxQpSwvEBDe18MzmtKW1gqBCETS6HiX+XttzEMGeaA8EQntquav/KowG5X0zwg efXxSfMDw9B0JtWZHRHFy8MNrgWdef4UYtJw8n2pb3Kz5AkM+727+ZvV8ccjY0SQ1dgXGjyoaomW 5vIb/vzeKhft/+nWeWS0cdR3c8SlolMb9FBVXxKrKpeeCpAkXc2ZSfLYD4Oq4VBPf3YkghR2woe6 9F1Cr1AJgHqxPfbYZbB9mCST20hhiHm0lP0nm2IdUSdSileYCFrUJJX5yhu6GLSXYFe35/dvL3kv m+rRNSD44PetQLFtDaF1lwdkEFfoeO84AXbykRJEDJPRNg9dQx/EUzneA0ZIWsuRUkRRfFK7I1HP oDrkigI0aYYq4EZ+lJDMPpGIJtG2pXbToEzBTi8v1RKHhgfH0kpA9ZPdfQT0/mrM8tPiSocEKDEC pE+QHv/QHy+VWJdHmMmo7QSwwdiIG1WzxCG4ZqTJuXAd4CQN8AWg9bSUgXVNrwmXM+w9ywmm/Qej GggECFvifsd6dMA5ce/5t9jlo8o2TefYGOc1BsNvCYL9M94TfxHRkqpu0HHYAByA9BEf4Ok3ixR0 UA6eeHaOqmwR39VkhFVp4QM3KYJRSZhvsKyycKVMqXszaGjliR7AFyaUH9CDwxJ+HJJJJJJIdKse zWVc7a/HSqxKnqsW+79XgZjnjGtbqw2/v0KHv+UxzOnMghCvoT1vdCUazJscqbnfEIQIVFVE0n8q X9brA7PA9wS+8wMHHHqd7k4OHrCiFcOJ1LA6/OVtNFd54ygHQWxpelQuF9VCZEUyOgs7N8Bzh7V/ WfYlvoiH0ifMZRPvS5eSI/d8O2ybzfvX5PcfdknQ7PmqdlHZnwmippYp04wYZMclrwURUEZ2boKC wU5rPQridB39FTeqvDMdfp8ZnVcfaG82x7C4KbsADACDj6OHMepdu4M0mzhUPDOY6AnXoANQS+sH cIaHWY5jYR9ZAztyA7utWCUcQu1so5g7I7aJSh+Gbm2xRCMKzUjVtuXjuDQjNS8ETr3ik7aidyBZ Le/8XfV0ET9AC94txXuTpx39Xu4kkTcqRWcFPeLGMybzcg/E4nUH+g4woinG4EcknpxWqPKOAvZc phi9kzL8Gt9yfChVexkZSezu1dztU2ktoZFiAXwse17aqyWhpHT7ZxnVk7wC+3HaUaPXfZYugESE JCLUR7YanLxXeIHffoaj3EMB3CcWnT50Xzy9w8ABzgBz5U5ZaRA1GoTAzkDCRTGJSf/HOefNwb0A JuvSYuGiZ9ApR8hxHw7SwDd9pDoZCnj6dyHLgCYQ3oOkS+YU2i7+Ep53oRyCU6hDZYSbTF4Q3TTq CaMZdNGyMgYYt6McsAPq9WywyFqDz/T6qfPXo+VyySeFBnxQhH0cbqinS/kchoe57b6fpbZMEn2S D7fw3bBvEA0Gkp0EOMMT1Eklg1rqbmFxLMF+hT20Jn5yQ+Tqqv3UedwD0oeXydJnqZ+GZ8hKter6 OqfSE0T07ULsL6FCelcnh/hEbZIvsM2k3gMBNRYkJBZg41tj9pcAvCEkBvBHg/MvzlhC4ai0Or9d 3kcPXDQ23D3C6SQdVXeXUOCBxU4n0HxOvRQy4jvl/Ya3VptfaQyEEhn1ajWtzAA300we6NQMhyWi goPjZKULX5Yxi+bBcTjHUpuE2ayID7g8wVOwHkcWAF8D2DsUd13lORX4lzbHIaFMg2BZ5Tc1+ZLB qEEslG10G1QvlBeNYxgQnWZZIQgmkaUMvbwZH6GBxAQhFTkhgBwSjcIFkEHI0AYGLUQE2pzKB48+ p/N5TwRz2XIwGYqVNRRf4djj/VyENgQTfIAfHAPEeKUpfcrFZU5jY7QgSpvUahwsd5eiUbIFF4YQ AgolCRAgWlgv7KYDQVyn3kPvFwtMBy3Um0gH6cdO6ZhkIDSUJuO64FjR7xGMRCGIfRpuH6Pr3QN8 aAgJVGYMxYfZ70CTj74HLhaqo1BlY7gQCuYllIe3E7+sd8854CksBSm95DOfVH49Z7GB5RiBc9G3 +Ufb+svPp8mHNkZW/8ezA8Y6DB83ytPn9b5NY8e7cd8zugPx3P/dw2ksWH69IdpE42K2IhcPIQaP 430eTPmMA/0V0csYoPtE+h3vt9e/4dSPeyP+g/BO2/p8lA96BqKMS1PpOuLVXBv11n/JXm/bz8+b H19mwsPRvKmqvBEiI0wTLDZ3iLHzqWQs98mSP6CzqxwH8bDFuUjf7cMv87HIBdBfeCChGqahAqio R8/+h7uzADASbnX9Zn/yU+Lr9/iVrwNG95/cD8YYkor/SiFo/3OO0pJZUCUOyMJ7ev+yR77/jv/8 Vf/fv/pj/cjE2OMyf4qbyTQWztzX/BMjKsyv+rvURC+35PjtwFJT+6CFX8bgewy0UO7Mo5pRXJF2 KhbkOI7EIjzJIJwgKMSkkmKwgTD7u/5lQ9O7o7zRvGw1W3rZOkG7NUZOj+o2LSKhpWhqEIQUkjAW EyXFtruGsfxVudK+uvZoonHoa/b2dV+hM3JhsoGlts+f5sJjzQo3gJSI+SYl4e/qX7tE+4rGQGab 9ab2ZaJ14o/qRNYrbWHD/bEEq48pT6vjUd2AumGl87CL07T20fuViZA2P7ldumR8Ng2chm8fcEsY yaMl2G4+9+H8Oy+mcNFbWBkHiWQLL/kRaT6yNLB0EDTqytbAbe9fEedXFAd8P4K7me8Pu10NoQ1H dYasTiWXYsHA0jhV3h/Lc/bM0uQQMItry9vi/LEue3Dkt9Cv+6v9lfxVzUfKrAPA/4a6Bb2R/UHb 4++MQLDQxiSze/4u1Aw5cij1eu2k1ZY/qVzrgnwQ78gFOibyoQU9MQDog/8ctZefmTWXqMjGDp8O C3j+Iawfd1trG8eJWwHvq9yvIr5e8/R6fYW5pny9DbaMtX/mb/c9HafLP0hd9vBQ/2GFP3wH/Ws8 TBPwdz6Oo0dH+rJNqdZ9VYemI5nFoXRCu9xKbBQ/7xkoDgtmsHj7eXpb53ef8O227nXBsVnGQLfh Kss9+VP8W1fMrZXeam8Ob9XLxYUdpl6t0d7x/h+/8BOzQ7zwM/N8IdNy7B/BHHftgx/k7jdAP3nT rx315OBs7dOA/hc/5LaReE9pYMG/kqGU1iH07PjoH+wU9+LuSBSAOhYLOoFoCYf7I/lVjTMbwOID eP+d0+Sz82pd4zRcTBf3roD53U334mr8CuU+LKHMJCEy+z+g/uh2SioJTUDwQP9H4A7f63GxkGOV /eP6Jxd4XhH7lVPmP9N33TMmO4WaMAjb4d6i37v4GifV6DktTIVKtevqutD+qUSHkw3N7dNwH20Y aoQ6pJAIgzRVDZtZAkJsKB/gQcF/225mK7NNtg2Ry5Uqj3NDZD3PO4gR8faef91sd9EvcGFUvrg7 CqMrOyIyGCoKoxguGqZ1rlhslLbL/OeMvRpL28Kz6sdu43TtSYjDmqX2JH0pNtyric2KG9k45kN+ kkyTkt4sLE4hJe9Npp8i/4SOhvaHvsJ1KqWeM5bqy06kOvaOgTLPnJ/z6Pw4+QL5BOhnf4VE0RU1 RUReLwGzlJDfzzS8iiBhQkBgZMWCy3pYJYAb5SQL9UGS2BPm4473yBEQlTLB0YT6oHT4S+Hm1R7/ lRkTh+zHDgr6N3cGHK1Utn9SmlutrdTgJ+8gfcQwMRSjBhZ939oXU7wU8oH6ZIsJIeYJsULMIE0e YQzRkyHyB5k+X7UME+jSg6IzOBBGXbREGGpIIPujxjIyCIfv5P6Dlp1GSfTsQ5V0AsEzvRJIh9bz AuAlZoR1bDWBbN7PQHGS2wQQcQ8d/3qUEnb4KIWDLtcN0QZWnCMby0bJINqOMbWWQ6UCFe0vdOAx JESEwFQkhLAEEATBCykSEj6GCbI2NDZJLCHiDscZRJ2j//EXaBtd1FIZnDuTMDGwJN4vXcDB0NF6 jNMAJtGhKAKQghxi7M6VVw9ZIRjYBv02Z5R1JDbceLgtMNVMpZCW0SHKUrjeSphkUjfYYMZ7fNHr O9qwGRorAiYxM0wwttK0oGMr1EUeUNgHzK8jDpMivPtvnweSrLKss6PjSjAdek2mgkk0KaRPvRF3 9G4AYGDyB/ZD/ecDeMk48nURDULpfVU77kMKuIOyCwwJKeDBdQvkByOHthriyMCKKchJ9Q/jcwou 4OU4ewwBSXyKgiWhRUqOUqxkcGDQ41CSNkhKMwypAKAbQdE4TQ8KB6Dwhg0O3kaPQDUudhcMxRud 9EJNaDYd0JBTxAGUKFYYfGxFhAoilGRCkQCAMaASkRunI2FBRYA78D8nWUUU3CyrgpFWk06I6BtX /UqEMOZuEwBAOJgMEJ4oUU11omo55FJYfAPAFOaqaGlpoiX5ELtUegIdIA9xnieyAwhAbgOQe+oV oGOHrGcXE+MGsIm2NPUkkGDTzOCj3gECSQjBoYmKCyEY9aMYh8OKFVaccYwvO4gZrOoeA0hoiwIi w1B8EshYeZjVHiQAzUwOSmGzRG5CQOacgYtAhAfIhYBpFMIPt0Eg0o40wtC9YOF40OnH3smWENFC 8ebuQaxkPUYc3l2wxrJA7DsOt2qYFdhBUKEAzAgAHMuwjAHinAyN7QQ7gDc6fwNz7mTtFPTYFzss sDp2Dfwk0D0IoHJsMCCCgJxMTLEgJNoHVRIPRCyOblNeyiusovGigHgR0AwGgpcbqkIIQgWHcPQ0 AflFuFJuQFpFhATJKdDPABgklg228ORYetnyEUYVGREBkY5mOYUZmFmBEYuznlevVOfhc3LZGtc1 egxh4gHoqaIUsNxDDm6o6UiahsLqVcGcTZveojURRRMBSEQUtIU1TSlCFIEVNUjVA01VFFRJSEVK QTs4Krk6Ceh4niclVVcDOopAjGAURpHRBR7ja65vQc4Elpajfpqg1qpwB44jc05OR6IHq9/te6ux lWHsXoOLmoqqe9YfB9cNPghSoWTRhDwHv8w9Yp0XYDD7E9g57VPWdnqQUBELElIm09qx1CXvIJTD x7z2vkG/OaCmqqJi7wA7h2B4HYDZUtTMew4NKhEIi6K35nEbl5IDZzwPB3PFOJ3g+KEhmZ6jmSiB 1G80E3PTEbwqmoVYqypvAgUtxTZpNLmw2CbNS1W1gd3TdPpRFOUMk7T+BSgbCGF2JSBmAGggYX6P yGPzHq+vw8X9mROv0YVozvD8t+TV61e5CGyBx0cZgg012ba7WMxkXfRcb0GlU00M2SNo+RwNTGfu xxTmNQjGxh2ekh1TRTprE2mzGNkFZ4eOODXp+831yEuhdjo8fSQYzdWlyxr+uGDZ/IdC07H7vh3z x8SHjXgWzO1mDkeNfroT7h/jQhSDvRRjBQkMQjxDGBGAfmtqDohi2aT1a7+I1kQJEXaQkjAnaKWl vBJCYKEAro2jQcSf1KloZENQjBbYH+tVVMuQjhKeqH/EqB6FzPHOEZkkZRjnubBazeNNoFBCo14y g4jwOk3unB6Y25SlqNx7Px4gJzcS2GLd1iqeyEKQQ/NFDEHpTv377fR6LBiYnjr2V8PV3fyy/11r Xda1rJviuzZr5IB8/i/UIyCcZG5RK33/z9aIvw2mzYcRuz9G94z4NNzlzUtvocSK2HMww+JAzRLb LCd7VYt7EAQuvSRRLJ/+DGNEBEEbKjMuOjW5F73DFuBUQ+IAwuF1pqTW3IlaZPdfpaQp/StiSTIu GTWJgOOYUgNNS/gsh4rWceIMD75gvHfZvs1WdlBLkcF4vtzWPHPGcy5XcUZ+IOOcnODz3zg8SUz1 qSSGXzm6J7MkHRPOIWDWfE9OcyeTvkfBwZN4JNHGV+7uhHa9mH78Vfg5N8nsqzvhjXuA34r1Agsq vXBfg2Q0CKONTIgVGMI5YNGqNYTJHyCJleUKFKmJcpNKyChidiCJZC6ZeMPBSwuLsVpBjS59Db0d NOjQ9bNLwfuYDqOS/JqjrjmOypMfB15w9pYYd3d1p9X8ztUb5xUjE+gJCgn8/7nOHlBUz1FNTnoc FOaS4cyE5jC8jnA5WkuIxyKXHx9deihZPwL7GpjkULxZzv6i2hXEtgZY5lxdGo15fcTsX3Z1wh2C ez7QbD6J97PuGfIVXUD2abwo2enGG8hvauM1dBjtMuhI3DjOLstgNfgK07cDmlsYisqxAwb5E0XN QFiFgaUALAOC3LseDiaClNDntA6IH6PqIMKJ0n97iflgXLwkSXQLpeR7LFCGYDUgCHkIQ17Tmmw6 /Ds24HYdfKdGd3E2Km/vyHjJXuyqPkZUcnUrlVf5R9sUEQzBEEQRD/kPAYGoOIrcZG8zCQV5NWBq ShINGKi4SkShQ69+AJohE5CEyC4jBiaUXLM5NBr/4yZBAuBhayIjARSDGAQ97xs7f5ruAHbBSRJP OBjaZEXhUNCoYAlDeCJYcR4+0844HkJYE7lMQ3jp8O7xEIVW2NVawyWlEZleiFiOHQ/rgPqgHt7R 5z5okIEIibNQG57xphIxYTdWrEsffD5EKp4U/SZ847iZxH855yDEpFKy5ZSVaU3IxlxtyJxAoIY0 Jz73znGPBCZ90kMHqIMgYmGqqfz/Od/H3YfKfo6peCnmTs91PielMMEBVEBUPp9croiAG04CoIdJ APCFROpQYmwgUnzwMWyGGJ7bF0JlLyQxisEH4b9/Q6vncoR/+4ge+DYJ4vD7/qOR/Y5bUDkRitOV DFhhnIxegNfI1s0TH+/8HyAmRIIEIChz+04PHhgHr9UFhECOgtuBi4b5xDeoGaesQZBDtFPrh58T PrPFKMocplDyU21k5IhVXJnlQ7z9xqn5odgEzDHy+ZIYSLWyHxKHm37mi5m4RPHUNaalgvbOlDqF hEYQYERJShFQxIrTEUEk0MxQChT5usPzmi5bnLVIR7YBYJYIBftfCwCmKKuA5GWWFoenHSPsFI8Y BagTtaQrdECEBkhAT7RPLR34gYdEYHABIHK/ulGzummz9TPtfbAMwwKJNLGRpkvFYRuCWN3H+u/s HiHYPIIZlA8aDF9lEUdsTGiSBhGhAhSbwIqXY/kbOiAJ0iDml8T93sc8wy9miGuKmcdNIHEnL1we sqcXVla56caw61CmtOzJjAZxBGzh8VbGtEWVNP49cnJnTsSitJsq4WDVT45SwOaWcmDA4nEaRdHf DpIgGHR56EddIekmhqpiSqhjeLiQR392CVQG94nvW2wEEqnqXD08Z9elZGICyBIjI7mj8HDdttWx /cQdyebdNSGq/sLLXzEA+bTqeGnactSxEhG3HEwWmrckoEY7fY4x562EZrrSQHvR1T7SIX7+5Fsm hOsneI5/9LJ0uHyBygQkEKAlCSFIF6bqqqqqqxPGOp08VcKYVSPrxAxIYhSihP8JCIDCGkRchoCY EUpaRQSQFMBSAqTD6DYiOPzOABgcEO/ZcN7a9fBgOpdAEIFTDDQRoDBohTAlrMtIBCQ+Jb+PEXAe JPx5uqb9qg9jmfKcBKKEnMcIIAIIycIWlSZCAog+324Bof2Y5UwSFAUhuQDBho3imSK/ggyQR5E4 8A0Pcf+MVTRwGgKAPVpX/G1qwd3Ah4LqCm1bC7Z/fjb1WIAZksWMOw0nzlCJkp/h6HCdh+94yPkw KQTYMagFKIJS1xoe3Mos3BA19t0W7z0Q8dgK4CIs+oPZIbUX58xUkdYRQ4eskdwmEB/4yPAEI3Yj EEOX5zEfRCE2Ae4XlhSN8tK3ZwATGkvE61TG0MYAz1ogiD/gJJBsn/5+K+z/+/Ft5mW8vmpbGdZS YADRg2kBguwAtQfI9fIYOwllsgdLAUblrm3PbCihwoV1QEenUZQshkSPveqnCBkRBJAE0DLMAVN8 3IWQ+fZZ2xUkEuhBP2JakpkYI0mQlFAFJSB/b0x+En6vZz6zjO47nK95ktKGiXntTRNLeQ2o+km1 /g1xo3Of+3dnnojh8UXWHjyGxaN9bbZaDtMqiC+eAyf1rknI64p1p7B4VQ/7j0Ih7IotbAO83qnZ +JLAQARTTJ7gT0f1QafXz2o+n8jESSQMUkHUKCJpivo/tZVfIT88gPSUwg/LFIUrhAB0jWjJn0lE 1rBSlMzBF48fxeWGT95DqdV79JzrN5lhJhkUMUYZNRkUUm3A0Tfjs3Ncj9u9n4BU/PUUFUHMIyfg O2h0Q6N4aiL6yUEDUOmsz6CNBF1cFcIChSBPn+U/IAjkiKRjiBgYuEREylxmGjAgAjAo/bFabdLv xfbg8a5zz+/wOd6AzwIEgQgRAIKgiWZeT8RhoGDQUjm6b+JXy2atNQbsAuIwDo14AoIZjfTRmSoh 9O8FDTlQnEOghXSy0vpJSYEnFo0YUUE8YzCB78zoHDncvQ0ApYzAnaRR6xDFNbKBM2QCYVSHV0nF Jh0B4TR4ZwR5nuqKUoeKCD/ATpJkDz93NbkSOmtNYzgRNmTKHLzXg3jLEhPJXXLuFiZuhxdjdcA7 BqbdXAbaFli1WNCmFPuVGKb0Fd5FVU1GAh2AE1EQpEgssxUL1B6HHUko0OxmRmm/KBGFNQte8uMZ zmQuEaO4zeE/XIY+HvEEAazjCYTDiwSeRRGyOGA9a0g6E6GoJC0bb229J3gbbIDIA1iI6RzgKXrJ lg9RqcXV3BwNFkEIMiHY88GAOCGwET7eaA7wzEDkMxJAsCvyk5OQDvfh8U+Q3rEMGIe2FtgZ0P/o uF54zvFNXKkEOKIgfztRUA8IBYmgoQGgjBMyLnd40ef38G1V9YAe88nP2KV5iioBIEhaHrvQ3qmt 23clzrcAuPdPqUt1+INhzlHj9VHJ/ihRM0U8sNX2UTvKmNC54oHIb5SZuukQ3d2gAyJ9vV24Ykge X68/1z7P1bcerObM9dm8VqqA4QR/jE5QCzpKGRTHTOo4hlh+07v3Fa/tNkKRItRyUokNjGhQYUlt H2m0gW+tb1xv54MfTS6FGsdnXU894Mmj+uTfgTnnvMdcmKx3uWGHfhxHfU5Oacnjk8thIwSYKyeD g7zEd5L75P3Mj0eOIZbOilrJjTj+l2SdmDhq27KUWeec8eXJz51BnBxJ3kcjZmcHrlbkh9QaqwcS fZyjJ3/z8SWY87k899iuRfmB8aq6f3Q7e6HFb+znkyWjHneeuuY9SQWb548a6Hs1wbfohZrJxg98 M/RxRtWbONGrOiddnZwc88ZOzd441I5jEm5PfvxtTnF/LDUb8HBwdmOffEnGjk22NhzzzuWOVt50 Mzhrt6aCLyUfEwke+KFIgKggqoACigGWy20ehrniYTJGyGJqWamdhQ1YvKztKkiwdMwIa9J7FA5i fIR2pgbaWIgX956dNQ/bL7kK+lCTvlfVNK09l/rifVrMWdMpT8vcIhu6FXZh3Q60U3EU4t0K4/Sd nTI7AmF3cWUp6U66WTvICCQQ6RKqdpnbCtgsRnvMsS9MRBm7ryRLOzBJk71MbDEcpII429yCpby0 RCtcHTubArgPLR6VUs0phJZ5vUyoOMWWsZ0JFCBTJATxKIgBAICPK/dJEQkBkJAUx4vJ5c3EbmrV v7bEymC7eWzYTGXBu1AluN5vjIbZu3wNSzaUmAibTa0G6ZqXrg44lI/JekXxO+edALGqK6wTloXh yRy68xybIrz57DaLWZuYkOWim+2+mRBROCciyIRO1HYN+I5Pd9RO+gwcTFngipsEYAVP98KgHeL8 gB9h5aiqSJVoAiBSmk+vAwAcSGzBQOvJgwYC3FlwqIDUIB4lKFTqelTnQsCjuqIGc4Ot8stRSWOo D/CeZxC8Q9ybqBoUF6hLH3kM4KRuICnIoe4+/eT4s60YZ/2x6dfk7HfAAESKVStKoYEEJKjkCBEU ohMAMyMQYvW+tj0gaxKSyyGusRXIg8EJAkGhAzIKk3sLgbfOOg3cIx/RXrsVFRh/iwUGkfD7JI2J E+B8Pi4q5MEnKYyrDDMDVUh/KAXHWR+iO2ANyHYQEzEAJEMdgeftQLgOEEeojs/nTm8iasAPMBQH 8QNz4KAYi0xVJAUkTyrD4nvK9f5Ypz4YOrUo/PLkJSUgn6DuzS0wXbEhDHi0rAocvB2Cqi9ECRFC RQUzvqa+k2g6mBMksMgGW0peog3MNiwPtkHmDc+Aw8+3pqgTVzDznVfTr4HLUHTpVwOYRzWUENVA 10KRPf7u84bt0ie9fCZL1GdnxPZTPQmJ9wqZqMo0pSluIoKmbf1KEIQU6BM/n9WPg4k0/QNoCaqB 3ZlAuQGR3hTEOUvDJGRLw91MXmLDDm4+lDVsOf3jnfIZj8+f7xY9dfoPwTKNS5sgSIfYxIHM0Ifj G89VYu1YNbG5L8S24qVa8wKMWDTJ1eAhai9/y4ltPDO0HjezvvwUiOu/BTkSqs3xg/wI6Mzo3yY8 0bH633NKjGfTvy3c9nTY5OjizfZZorG/bePJnzgW4Ejwm5gVMbiY5al6arpKNuBeRumWKRFNwg1d 8i68NC2fHnDdI84jgmzXXkjZkvfHnBlzyMNloMkL9RnJzty2fQgZGWGUszMlEuuFHKaEYxgh/Pn1 pePRU8GhGoqz1n358zqysmjx9Bjv5GOtmk78MkOM3u1mWFi0gRNSZqNCFhMmRzKFibkKbXoyLBcT 9P3bxXz4gmBIEWHdCUlEIVCxMCqMixMCroC8sLqAS1SWCABpgECFlExBJVSZDAg0wmgYRZCNISTO BEH34EBgAmArs0GD58xwaQAlg5BgEATrCSIA46EARd+Gps22jabtsdqp0RnyF5kXhsX3DSadZc7N zzhObR4zW+dj619Rmudx2GzndbF5/mcHFdCuGIfn3gjUFEN3Bgp3yDyeKkiyxESA/mbEa0MvJIL6 GoFR+j9bJP4yT9rIMxskMY6Ds8MpcHBq2Vli1DIaARM0m0aY4V2UhGxSgVSKE/oy1YVRtlZpxsax RY4ULKqNojpF/jo0Gfz7N41I5hRj1S4yGUK2OlULLYRhIS05HQ0RxI7n6SL8PB/iXwJgVp8Hc//R 3AwI0oMGdKpeavp7cDJIwyIKK/qDSI7Z/jz60Q7vd2+Z+hzyMHkdzzRF83m7oFfcIInpKRKemHkJ +nU9J7PgoSg46QXjsUqsy4Th3HQaOLE4i9t7Zfi8/twOTLPWoOI47a5hqOM3MTa/oLsihBhBSAOY U+cVE6Tzdp4wb2JzUQ2pBksKGPEy4dTHI37Xu47zkzt76rZjUQ8u3uDzJya6lUMipGPe30Si1BLS JNgxRfgFhlUI2zLlMuCbGqlWDSUtjrRIxhcKFBssgmMgxsPWw0IrSgY4NaCSxjZAghZ6dHH5/ZY6 jdk15jGXm07cdvX5sF+WevG0U4nKSRhamRhUAzEDIZiSzRwapvGdGS2/XyfVeB+dsbw7ETNY0D44 JsOBusrUTCdjBR0Rg0ioTdJ57kD2cgUUv/UBGw37NTZS5KCbjhQwoVXauCSutaUaDcnHU8X+f1eJ A2iecXTkAh2iFDkmvwjCyP6yUImfQVLVNNOzDJRvBiyAqayTUyAKmGAUp9qBzYJGnujSEDGH+A7w cgPkGDxamOzhSL5WE/ngFMIgiYHYT65KAFP4P2RC0fxi51yE7SoeQPWEEEkyy1AQEzVVETMRVVEV UREVM1VTMzURUzBNVVQQRERVVHY6LPkJ2e9wzKaimmAROPK8gRBCFgWkHuDErtOCy2EXOhiSxZC6 vOkIYQj4ZWJsG461LEEYQiVFRoprJYAiSkSXDNTaYAwUUtw0XtdKkQLQMHnEfBtddPp2BW/E4OSV GD7xCHuVlHKPoraY7w/P5jJ59JJuAHfNpvoYh6doI+BIRIe6gOcwR+AFqSFVvQKB0DgLySGWSZFA ZYlATjb3WGe3VlZn+6MvjcGpoiKVHp8ff8DI+RPn0HvInmUzmSvcu+jmbo7RI88pIm4iSLQCPSNt 6w86kdgKCEC3whUhmIyC9DAMFpSZCFwsgEwkKxIPAPBQKlgJEZAOmIpz/IU/oI9TGaykPRoFa0Nr fpLMZP9KVrqqopwEKYoQ8w583Qj+cxcfjcHHOPsYlNnPDBjdwFMMqLehBUZQ+QaVEwBiTYk8A746 GrcMEGKudzQ22smHBFEoD8M6QLsQn4ET0OBfLVdSyXJxhwNO3lJINbYhIP9BEf1kIGabSesxB9J8 sf4/jfwHigcidKQMPax9SDKHuCtNuii4yi6aXw3EBzui1VI5J7dtFghg65TkxrYnYHZl/hjQTeRe CAQ/N5mBEESREQwQKzB41KhFEhEQ0IsqIB4/FSnLCJqNIfDe6KNk2YSW9OUEWjPn1v28aI75AePv PLnrxVVU6zRKmgwBMGeNafXCejJjJ6x9BvrnJdAEGSQZckumbB0gaZ+4wXFDvWKtQ/+NCt3flvPt TBzP67E3iAX6aXaH2h/jQ6TAXIbOzyWOWAGER2MCEJAseI5BNSGgQMD1p4g2dQ6T1g2DCDW4FMhS J/TgZMRLhIjgMCSsi8BRGAEBAPCB60zw6YnGkjMYDLASUIYcEDpIgYCgh3UoWgtsVCAksSlspE0P aX+l2qeRPLZD57SCHFGhoI2Oe/25FhjUh8F9cFPNuGyAobznRU3F8o8/LvgeJ1Q1vPFJxdObSeIC 5EB0Q6L+Q9cskSHjUMdDxVUkoqo9sA3tF/rr6D5DFcImJRXXRUNE0TAn0YBYb579Jhx360ZJo9DI fi0zQ/32iYodW6UoP00aYzQQaUwDrpMmnMFy6+YYpqLvOvA4Qd7viqoRAvgYph2YjtVEuGbsYmDE Ns4GTQOHYtt8+0602g0JDhuM40d96GmOtkyk0QRQZooIIlwU3s44DgqyN2ijiE1rFqyiQ60MZiZS wEGRg4vMi5ZRsX/fyTgwOAskj4fOOGkaBvCmOjG2hs7tZZpiPBQNtVoG0Axps1IlLamabwsQ6xtr ZJ4QobCkGwfRAkhkRFQQQSdMMSDpLu3ObHCMhRojQGJpI6eWCH5E2ligsoUC6FbYQjMGdYYMYqJs MHNHFMWm5BapAYSaieO5eWSzSrgNt62Bbo0VGnmhw0aXDNa07qhWEjGpSRtlCRwI5AYU2TAbEjIJ jENyQwbe3vk6BnIRRUWYxZZBnSMReInIyoaKCgDpCYQ0m5wNYYmnOI1C3AYscrpKEYkNwZ4Zop2Q PUBmMiYo20YQ6VnIT1+vFvJtcRRrGR4x1UFCiAwowwKP8fy0s8JfbLwVz8GX8Z0tACSeYoNEPAwv k1hXA1vAWvds2I/+dLPs/kRTQ/hVyUO705YvaVkF79Qv3pCir0wWMK0hqLD4jOLho6zhDAvBTy+O UZxLTbF3U0m5TKzDCANOpp5B6FUHvcVRDCczh+Uks13/gb16Dh4eX8bEs6umtL6p+BYX0e1pFs7f ojrmseIja3QjrGtG/Kyc90fXPnnzoowdHBKNxAnhexQvGtsdus0ncMRJSrcaXWFSZKRlYSPQiHHK pPLIsLytt9DAkak4JZCYzXIiZzxmPbaYy/k4o6PmNmckezs03zUHT3g88rjqvRhlJ5WzqINo8VYu NP58Y4KOzOyCyRfQAfxt+j14g8334FclLCREW03IAhbOGm7mj4mww1yTo6BDSFatRVXbUrhreZjQ 0Nbb/WgiIlxPYiFK37yT1ywuW2m089+apHlc6R9a8Vu+/IMxsj6G4vhGpKo+jMOCIVAui9w+bui2 peWe0QyM3nEwwkWzxmVrNg3bZVwmTw8XDn0DyPTR1hpxtVBy2qMUbMUKDHDUOo0uvnUEXRtdfHMF 0KGFHZIVKmaPX4NQCc+DqDKqDQQes0Dog41DT/xkuwDuDg7I6HUJPiiYAbDSOMLIa0uoEsopGA7x oc0sg5mcJSlwHhIOEg62xOQJT8BBoDYEYRiVRGEVEkajtw6SDdHUcjmciZN6dBLoOsol2ZSZ3H08 cHbuEA7t+1jR+2VIlCiWFAgRjIkGKhLCbPA8PZ0p7kDy4emhlUT2IzMiMyqrqKq/N7vBfhWRNPi8 GucD0xPpTAdz5SU/Q1iJkd4n1IbUTfJfH1nM7+zt7SUyJx9Xd6/Gd/geD4XGOJI8h4TsCqIWW5qe ZIgGrxlrgYzkSXW6uOuZbkWC9/hydekV4nOe4/eEV8RPuog9ZhjMBFCooqigMuZIa7dliZYptSym MTTWbxBAvBQK7mLL9RCuwe+sIXXFmYIooqbAL2DRUxRVRGE+8A/QITNIQRJ7hSIgiAMiZcqE1CYT +HeAAd3fhqFKAkQisPixMbzIbPCXIuTCG6e1Ilo5Mc4QJ25CAGsYihvAEW26at47ODjsUFnwfkfN Q26I/1js9PT4exPG1JGSBZF62moYXPqUVjx/KSINNA7ezy3PnDUO6KrrKCFRsnVR1zL3STEB6p9H n8LHwsTz9nLYX/gOimj0Sib/nO/fwUCSAQhCSEIAckociiTbZ0LUH59gHlLA/d0r0VqqrbAqBtVA 85CfqO6sn7QegauvVA+JQv68bF6x6Ylo/YORKJtBII9NuzXBry/gsfjZIeZ+gDO/zKlEiyAhxgMI xMiWCQYoJ79YZmJR4bz77ILQ5kIaDQ6NFBrMHYZJGJJVBMEUUyQdMwgpnZjxGoInhzIImdRu5O8z dyRFEPjxBRrLNDxqeGYEHSW6BMzaIbZkjGo6D4QtAcbTjyS0shVBB+XjayWkGUcvacyKNG06sTQG 3DChGCoRNd5yGl4R38jcfT5JNr2S+u3AR7NZKIKisbAgUiR6fMCQS08fp9Cer2+sU84viO84vE2x 7iREWJORYPYVJ16zPxhvCDIcJH3qdBKCEQYZICRO806SzmnSW2NBei54JCxQaAxEfpJMilE/uTpL 24dZM/BLnsPpPO0UyDZsXJ0fgSrecg2MCbzt2B5o/5cN0eTjM9LrPfVGEm9d2xJ6TfdwcS5T0OYJ lSEtdm/fZFyi7snd4piKKmrZzvZRXRottWIoyzPY1bJt8Rs3d7xepsyR57t4VKPXLOFR2Z5wONUx VhHpBQ8VXeXDslCEPfGtkhCBzCdCEPW4DNrC2slaKd8778+Xjq8S3r1K8YLbkOzpDn2KSbOH5472 BLn+wf5Kzq+TK2vUL39+MoM6GWOPZqj8EesIMejRIZ60kw1eXnUGLlsbjpKMq4VrONErUVKSohFQ hfzcOotEIGuecWkNfMfDA5TkJdD+L5DsQrlRB/GnjgSogOYNr+FRbfwPAi9FMIPJtmvK/L38pL0O 7fYxzBvp99rvxlrg+ROClS34LQZbd9Qe15Iv3wHDVvwex/zrQj1Ie3SSSyvx/HFqqqpmZl/PXwtw hCX2nwkzMQH1CNIm9d48WIdoHzxAPycgrxz74jYIAX9748wyG7z5HdGRbkgQUqSKyjq2c6G/xEtW 4ekhvARNW+0nacH12+eLzRjyPSNdJ6gA5CdkH2sBCMA8N9dYEAO1CG7IDK40TBdwXy+FDXza9vky SDbZyoR0iHYQgWfD1Xl2eqxgMF77gDew6QkCEHc+kNgdAa6NwTTQUEkgmeFOg01ebardg8rKoKEo Kc6asHRDocY6RhEGc7E4I6uBhJwno56RBBRrHB/RBxsNvPeaMnMwVLnv7kOCLu1Sd4HQtC4OWYii CSvGqO0ThPKekTHNoGqK9KGIcYGAiYRChTxhPCaGhNNRSU9AijMxCov2f/37yyfFET5DSoGYN8/y cFNU2QBPaIyfTA/3XjefpgZS4nU0BoKCHFpMwUHAVCdw/lsyNsaFoGVU0OOWY78kflJ7OINSWMCH XdT8BT1KHtOBxfGxOLd3dd7FqDGEIesU0kDkaOvx0kJ2YcNi+FXjOEoDnWcVnBpwpCJTHh07tzkG IFKiUWS4FgPkpxcMlhnaQFgPt8AfO8t+NGbxA3rMPToRKygflCSrcBN6xhBgeFeQF5SqgCuKKgUE cTVLAS/Lt2xcHZgMsIyNX55wtkhXuP48c5T5775OnQ5SIGG3Ax/sca23qcMR9Hd9SoOkOsXLHSAS yyEfJIb/NxUjfCEfS+Ed+5suoEDUMrKIMKCjiwjwj5rUd3j9WnqCHEEHWJ52/ArWB+XCCEi9UsKv 27eKwQO6SQzqMOCSQSg1WIlFIXbmoHZCQlSd1aaK0OA+Zamo2Zt0LGBOzigwx06QRb7ue6874MpO uV0jnE8vLA504/KcQg5ot4UO3Uus3TV0iTSaX7IeWOiu9PvbsF5Ip+5mc99LBj5XPga8Xy8uDUYg OtOHwaWoQCEcTPQnVIlqAHjuN+V3+K9YDh1JdULOEzg652fvCZhBdhGEEDbCwNyd+IdJwLlh59N6 RHkuCTmch2MG45CkDgqjGUYmNjBQGNeRkMaM2O1g7TO83KMMqFUnPbWfCqZnajTj1GzhRn0Jj6G3 GPAmOMEGG9oogfrqmn9t2IMPyba9Jj00m2DaD0LLBtUzIEQa9k0mKz62ByPduoCmqqkorXJxgZs5 L+x+fgxgRkR5/7hxvPDnQcn1wNJSYpG7Z5SZRXqwdNE+r8QYhzbvgQcs23IPqzcWzScJjBf225qw OMsl8S/dPLg+3sdoXkw5DJnYEAmhx0wk2mPHW6lp8EruolNWnXQ8QPh6VlShtXpwyybgzJDfep8S 6Rb7PsZjTZo46s8cuf3NoSpZjbB1XdiXFVypDGGA9UZoMZCIVvtsKUyTBHnyEJjAmSNNTMk3PLda zgv8OZvcR6s0LgobcMYavEGFWRy0HCcpYKvaLpNjSbtMyQQT2421p51KhyRmJ0ZVIVXTO2jy4WiE w446yYy2Cp0twNxTrjfamDA47uFlswGt6fIqdqtm7MuY5fWh9JmozuG7zxDFpOWOjMjOTPTl9pyu DjPS9M4OCYQbt/Yi4dvHhzQiXecd0abrkgpu0azitCR3sfQeCoMZgWpwmiWTYhkwdxnySFtI1+FV OfHADh6h55+JcUBAia9c2P0Lm82wHfSpUuLyIaFyPLU0suizuROuIv2GAwrFhCvYofpZNoJPSbz1 4nAJMbzijl4lLbrnW45+HWE1JOhQ57GvXwJnRA9LQpgxxuNeuCvqkMfHr7YzBnfc82I8X0gMsGLB I6VV0V9qhaS0xrNWmYQky4lsW9Vxh3d3HMQOHs0yoieefj4+BuZZvai3MNwzj8s7+PIukkEpeUMU 0dBjgh36ZhLTUcYnSE8z0w56eWukHRlDsw4lecc7sa8O1wOxplWXSSoUEPB4vY7kpx60Py7YiQb6 OHAapaHvKvhMzaUBxHM3L8jbSQIbfbzlSmyJhcCgbjO34dYQFocaXZ/DZblvYzGepjNQgkm4ChMI QBhmIem+f99Hfl+uvMePMCDxPcJCTp4Vkwnkamc1N6FGHRe1ONUVkMOTCNGmKoZ2rLsofryzhYg4 pPEXB9EcJtreZDI5nuEzabEh++Jc75HVyxBPPzlSj6OoXxFRdHcc8BZYUjjPRDZ3Pb5fs13SC3wb 87K+jON5TbXIIzMOjRiWqWTIR3vtqNC61hiI51LXrbjsVq4azZE3wdpvca3vGmb5S7Nq561itVk+ eRrbVXaGx7uh6oN7EwNJD0IYSAqkdWSNuS206d2PSL7fHLG4KWuZLVaV8Tx4zgYN70EnecvRu6Tp wPdW1rLLXbDbq8QHd8WYbPGbylIur4YZicPKuRGexmFGUhVppIQdk4+Z4kDAsUa8Y33s1mZktyJg UB2m7tsYle8iKHSJGH7OnhgdZ44g7TXv2GYwnquZ7iIcVu5Goz6udbzslyahG9eOiQtFihJWMxkH UtiKpuW6JHnGJGrJx7mWZy1zrOOHqweekxiZzAmunRWSNsZOqqM4cflJCLsMWnyxaSHiE8JKxq+y ddBrWVWDjUG9oIwBn6/dFt4hai7GAykuBGUkgHuVbK3zH6DCtkzYZByEXVB0pBCFSbghg6PGPE/G DKqJ+FLfLuE3N07IbxKcsDQCPiXl+nYTQyX0UxxBzsMEw52ijqDfJV8Ej4718OFfS8Mixnebafcg HnUaTRl5hjwEPf1yod4791uXf302ZP1vccenwkDdVEWke+KvZYQRmHjqGSJQawvAtInTvb/XLTqK qcuzKyXFNsgxxRGEuKaG3gptvJneFN04UGxTdtsXPyhABxdUywBvjWUvuuPThSlvyIg2dQx8a8rX fVMaodtK3mKElbWY6aMbXapsU63BGXjac5p1wXVxq2umzxMqh32sRa+kgxYKjbkY5/fkxp3yZGhj IcvgNOQdE5UHXjlsKysowTHQUP1eyuOOLJFJJEyBEeo4jTGgfBlivqQP3UnGKIICtLmpt5/j97/J 8p1Hey86E52woW+IRKD0tZb6Lut456cKUz5SrLvwyrfKU4ffP7qW/fvn2WU77Kl69vPv55mZ7hS2 G5dRjvJnEdnJchkicwS1HoUkp0sVrz6n6EtFjcNaTLClh97tuK0MVuIXQMS+fJCyCZmJ1pbVcvaW X7PZHk2OYXjfg9YhZej0Zk1PU+ice57OCfhsS1il5aES+mlSZQw49XHTTnbhj0dE4WY8/NbNd2mN ttMMW7Ozq8O14jeKcLueT5dsbI9fie+1c9erTSRnd4rcbcGlJ2Ni42NcnTwN6E0OszLzo7MDt+G1 5T5DOXmdxjcx2rEj2ndMrikbjQk1xO+Ra8HDBLa3VnnSyLXNG4kNKeNaK0Vkzkx3wbYP1G4jtucF rfnFY8rhuCk3g8j1K1q8GriXTiOSI3XzhXGLGmlxAqYTfAxIGGFxQ1BMohffjqkymjIQrpmaRImE dDIwakidkymzZrRoWzts51vlunDn5vL4D4d4FUMiK+KDUFuCgIIDS8xGAiOEVBRTDw/Dv7lV2Jrd VyhBfwOjZqutXMncwDeu+aXHG5uLAjcn4rmeGarXnYzTCD+qChhm7GYl247gkVBx+FCiYoj1OmKr kCUtK9w6E7b5tcdm642+pHt4Dii8TeETIeBhDbUTTGHDRMGoC0x8CjTaXZ59EEWy67AkfZAp3/Sd 559po8zsZDQNCFIksQ0hFVFFJRNM1JwHHoj+shD9sA9UDuh9lt2enFO2BOowFFlm8kyeJIJadoUe /IBvjXOUZGAp1Y8y6bKJde7UU7i6jztyBM9wHZO6qnrHQRl5E7MvedHvQ53QTKMfLFRM1FTFVRBN FRRBFVIRAEgRSkh0UMEOXvcN00SEtXFkVQw5mVFW16IQHInk8c0RUBwPY7LpfkkoE6eBB0AFNCDy uIdA9yKsCmiQoaoodhsOCElJO5g2mzBDb4Z3u08Y0IeKYHZDqAbNhMlVFMzJdeQu3YHYcMxVEQcr ypYMQMQHALAmKRKZJMNAwM72cWjth0HiHgRhmS6xkjoUTA8ZM7rKLqYw5oIdJDZ/qgoMhN/uh+AI 4hCQsCUFfKGhA/EeQUo+ETkIKO9iG2LJzwiQOdA/nABJEDF3j044iWIqXYuQKCFF3+FCIcaBG3jv 5LyOnoVTuc50nE84u8gRIj2IU9Fh8OPYL6D6f/HmjwBOAnWdv1AyM6ojRGOznfcbeXadnYwkMHsd OfUduzecEBgxhfj8A+1/XKOS0eT/IFLha2IaRF16zScMw9CPvuRxzsH4lDSSQCv5/iQa1h/MmiSo iUQdakXD+eKbYYwaEV3JgKkAJwSKBTtdRCjjIwGRAkQCYooAMKUgI9pVCtKhCmF7FBRD4pwPjKos bFQzxUKYqG1B7IIvAh6EEA5oXA8we7gPCFjwnO38nN8QeOB6qaD0RQKgBiSDBKgAYRQxCpf8B+8M fUcx0LvDZ0CTrANIJoxEC1xGRAM0sagocalq9zb+2Ezxe5jer9lxzZR2Ax3IqNJiwBwAxRpWfVr7 NpAI515PmKDN0SIaM7cav+Szn+wxxOzHH2O8MUdXPR13qbVs+Hv5uVIXZiZ3EkMMTY+V8RBRjz0h qx4d9HHTzhO9NuXJ/ynQNK5EzJC0uZvFrS5T0OdZH/uXvTi65zjzdM8cadFhiexrNuhnGnAg20Jt Io0OwlL9iaAM3VnOoOjqiMnjRtG54LUPwXwWSxgcd/VRdu1fYzDLKBSYkyCFwRcaTRb2h7mDy7sL 11DDl3Dp53CF8GmbI1D3hwea3tkXEliZrJM9HkYze4m8CskqGSitMD1fndo+2xqAqNm4X0ZRjM9h fc1m+1nB7VrNaWDHsfMlLD4IPMedS8PkxWCafL3SctczgnAZ8pDo6o42bo60iTPNqd+V5qez4j2d Z0ztPTFoZu4y9j7Doz6DhOCcpFOTbFsXJaSjgwHGO1OOBHAHaYAZ2DAGBiGSFBYsHBq9Wz++rhN8 7srgQo6jcJc5CPnON5041JCqnKOWT9Wb7oBc+XzFB4/30BQaAhKYhQwNm6X6+rq7sTkOM42/JajA 5OPms1myzmoXHhvZHof9IoSBIJ3PZmhZUyiF4pqm9nNABwidvlapGqdxXu8sTrQsvsRQ6hRKQGIc es6beWOZrywZ9ympn3FJmpP5LY+m5hxhAOA2RyI3EpYaCCZ5SMu09/3DRyKiZwVoA7YBFiRUYgpI gUqnGp8kqyHM0c8J3HUr5HDBVyA5MDDWnUuWKcQGbkAPnFupbuXf2OyBp/OBODU5Vu5zeZZ7qEeH vOuSnkxIMXCwJ5Y2ihArmcT90/cfd8SQli0oq3XUq97kNFVbGxBTp9aMiE5dSvVEqqIzAI43jZAD M1dveJKaFdK0LhpR1CYpQa14BLiB/f/VsXdWvMNRPq8ffeWsDwlmH0gyzE8GWGLg6e9Cy+K5jMoV BCJREbuKH+E/y1z0liKWiYqCBegI+FL8slDm0rVJCx+gmlBEecgqyAAGNfBZguEGVJQRVT5cVGVq tIhI2myMllZEU9ZYURMUgkNDCNNsaJI3FmtdpM3h6ocIYriOgErJL4SYstjDNyTnAgMUwIltkExR ii6gkdhOg/VuifvPmQwAoJ36w43SMAoqWlWUAJR+0eX1ngFx+1CXOEFwDAYNAQqTL8JYPFBBt1E9 fy1oSEZlStS8+K1MIIh5BaIhCj4xBo7wrf8bth4MX+wd4MAIEgQij4K+M1BXB9Iho3Es/QldnMB+ Rz9XkfI1jSPg8OIQuyvSmeNSjCJ8QtSR8SXWLjIA1vi1MIQrG5VR6QPppFENZwBrti5yYIoaGQwA nqbWhIbzAWta6nEFNgIBmXfOM25khiSBUZrShoiI3Z7b+LMDa6AWD8IZwKIPVSR7Gj8aOI2Je76I kRpg7bZfXfCxEQwIOELWwg4EcNCdFCkoYEIQRSF4QI0CKNUUBAYIPEr2N9eGRYANglQ/MI6OfuH8 nejymUXm/ddaYmzTNiK7ag0So2LL6Q0y3iaWPxstMl5GzMiEQXbibEu1Ft/RQDUi7o/zSVrKNSTZ vIVirTw5hNZYFtf4Rm5a7NFjVW2hBQHbS9u50IgRLFwJTkaMvVQXknds3MwctcAfwpeXJxTfc5ew LnPaU3FzFxqPwuAltAJnDZVUwP0aswYTqgtaTCjdbH7tDF8sS5Xum73dIp2xY1QM5EzsOJ6ukP1K Js0E9OOiOYUClV4dA8HjW/KuXOQOvIPR0sECVTQMEnRGVNAYYh4gQ9sDE6d75hBGdxiIwTKZWm/o Quh6SxMQpMH9kD3t3IXoppcg0HZHh84RKtvhrA1uSBMAClNEBTozGtsbBUNYa86pH8PMcqb/+dAD 9vYalQsRv+sk7nl6/lOxKe5+er6caWbhGqUSZE0YgfqiI3BsBSKYptugp86ligFOxmCH5WaUKVqo aKhhhIYISgUlEiWYGbt7wOofGfyN0D9vHphPsiPJzIifR8+b0TTIRpfZxAwaWtQ23IYE4I/e9mVL amIcWMzAy6VJkEacuXny0yeKQBtCiYrIC8aMYqwXprrOFnNvHblNIbEjAPt4D3l99eOsHWGwRvsr tbRPPDczXZcCSZqH0sStnMAt5uaQ8Q8CEFOPXIyfFD568PlstXPPl4wA1nDK5dN1zHWTrlsFGMRC TWyZ0yZQPWs83jgrOShZE6JJQnOpK+cnJJtxTvb6k2jxCsabKQXBtQwHtKaxpGDcFoQUwRlAKkTe oJ2WWg346Uw3CGpGxrO8INTp9YmedNZIbNDmnHSaVWeHI4sdKxY/qzRxTt4Fogjz6iibfEpYWx84 sakCY2m0J2NDjyYOmZbpIdYYPdnho2rSxUMQAawaioa6yhTkI3D5hka7aMum4kDWT2AUg3ImQaqL Pwec5qCEoPdfbAJPgsUhckCOH/ZI7Ug2iVAw5iYDm9Yhi8aeW4441vRoKZZdqw/qc4Mk2TwUUqFx xWGW7Vl/2j7/DzB9BX50YDyDn9FfpwPWvin74WwGMD6CjIBHCxlgkMURzKgxEqHIQegUUcYCIv/M HB7jBPNyAxRCkVOAIZIQAmQChqjpgKOdVNRQ3MAWaghSpY/iHxfGXF26JkFCA8TU28Tyk8sQtAYE ktns05I1QUTAX+gswizA6Rk1+J1jaZRE+UwC9j4IaEmiBSsRu2hScIGt3BxA/aBimpW8kWVi8mSf KRsc4JhESQzifxwRIRUrpeqme5PBy5j8pmUTwUy6El13qvdEFmAqwieBX+PCkSAo/ppBeU6lQ8QF AHi76UkKliJJUPGkgdbaSP0sBMDNYEJhT75HhG8rTb4S2ATNGqWDlJGSQpHxhQYNH6VwSmk0PYQ5 roUsOlJD1nCl7kREAuB64SICHU8DQgc4BzBqBSC8RAzCQDdQ8ppCvPJ74WPgWRFhxQ8fHYsWY9LR ta0OYaRywP6YI/ZREa/ecuCOXOV8zzW1tSNwCGcfemJ4kHtgOKkHry4NM8nzlAoKQFCoVQWpgRkV Cqn0pIGV5ilrfldCYHB3SrB3XBwf3XDGe32IcZiVsTMG0C6BIZHBWzUCscGpAFWhiwVRS1avyCnP zoJRsdEDnA2Raqz/g+35eUT3MMQaxF2b3oGD2xtELjRFY6iROCtrTNFtn6SpzYqwGNppLIkcpEwK AOwDsZ9IQwkH5BwNhed4Y8NFW2MDSYw3IDI+jwgsXD84FI9aKbhOXuPY2kN4oJQ9/fS1AXyqccO3 fqoT+dVCNzYfDR8V8IV2ZHO8RIwLkODY7hQY0C7pqK+uVGm1yVu8BsdaSRYERFolM0jcE72m9Kmp cyKMY7WcI8SgYaRMYMJ0SGMQRQR24O7OPM7dB7EvWCaDDBwIONa1SkFbbCO2GMHCA2dLnps3CgAb qktuJklDZg5mNIYUS2OJmYTEphhMOWcwBqpLnMSRGgV56PHa0jWTcHFC/9FTyM36V/VZgWNaDlrQ uERM4NeZp6xKMsSUYikvcBGxTIQICP+z9Zk1QCh9hrnLXX1nVkf9GDpucivU/7v+lv3cAbk7fUb4 V8HRRO+e+tlClbCkJDFcGyi0i2heUqX2Ig44+ECw7v1quZiLas6Fbb0mkCJPPKOO8NsitxlZisYF NC0zMS3UYjmuczIv0W+kcbCeEit40cT6EQzApETTVUugWGGNueccTI0k8gsDLVmIwvRzRciVC6hZ FdmM88zZRIOYPJ63iteit5rNXJJ4Z+eO+jjr1mTRdnh72L8isycyRe9uGDmJFsoDSrikSqkuRffW 0wxGMWFzylbUhcWGajUFIGUMihwESl5iULCwpWeZMjUwm6iizien0UcwmXGa4V3MaGkNtK54l8yu zf1U3w1nDRycxJyFDzDE0fecrjbr8764E4nMPpQ0H4dPHly4wN43CZZCXKBM4JmXmaKLqCICBKZr xOSxvb3Lvc9d6ulOo96xUQqKf9XahOVJ6+oDoRFEfIQDjyyy5QhskLs4wpSXLb1m0Y59ikgWt2At kIz40MYkBTmIeznC3S0zz9QHTdphiUiPds2D6Xllt97Fk9fBCu004GDGudAtUzxs9IgnbB1w4K5s mbSL2Dl2UcdIYXZcENAInRR1Xu2oiCU2ql5qmR5Vx4WOwxOUzFkBIWOEy4fV0vZGbTOHfJDXt159 FyOxDQPKoiMCoODMKtxkcTw2qXXzu5YD4J+zebRyOvLoIHHO+ZUYY7IRI2UgSrebbNUAQkhYa2Dm ut7oBC+QpWS9B3HJVRoO8IVD47FhNiyM4hCfHj/z3ihwgwuAkDSshM4rxpP7ZHYCc7JOAXAV26E1 HSKdEjo/bJwETLAcpSsLubwa2JjJCJQlG0NvWSvMtzwgOzSdcV61UTAiqeKpJHWazzRskD01QEhU C2AYHfifD8OPnSZD+WdoyJhTgaCFiwfsQzHAQSD9c8n78UnjdDaPaHUhdccntpapCm3GPezE9rFs tutVJt7yNDYN10Zl/FcejcWhpGPhB5r8hBB1uCRGJpAtsIb9yEEU0a56gdpfhxd7nxWD1hJlt5Qs ZoASNoH8apiAxBE13f7JT88zI5s1VVasyN1aLLCrFzIrjgdaiQNrIVSR4zHf7Gmbqrbw36iVpGft sorlzKqrrGEVeBmWiAwC69O/S7QwRzvGG5yesqn6vZ6ZgA0wTO6r+iUI/IxbP7JI+EjTMhwjYXAx iVgZUrSIteEUIZUfrjyRUkFBxz+678ti1s7apaZhgt9ZSVDSEEEEQNQpHrTw46JYHJxe4SB5V7se SHQGJTVkKn8AEDqdDdDY6TZsRTAgI6xgJ50fRY/HlYDgGBAwABskhynXHnFQvtCNgoGm4QpBUGX2 lVBUajIo5HWRqlgAQjrX1UwzCjpGNkB1RjtbAbJIrqAsYd2kozTml/hVjXDNMQS1ANRrCFF91a52 Q4haO+SQ+CdYTe/XZGAU0HmNAkaQjchm8Hc7/hPkCpHxGt6YR+WcbA3qSNVVB+94qyowbbJmk/jd sdJBDKIBIgSCaj8b/IgHahED64r6rFHvAOtQVKt1BgT4oWT5ZuX2gpDegnV6OvnjrxVp3Nm1s0Kr 2WBtZEMBivxP73o9EPLED4iQPMClJ8F/YB9ORmZRISST0UV4bT0nAzk0bDZ/hS2hKmzn8Eg15Vn0 aV41RoFCW0hGiAoDJJSrSMbH9UeswPIvEDyvGgDXBmiFDJdSjSmSiYSjSCG8IGgZmIy6YOrUgUcX G8DIV++XmU0byhDUoGWoch5lMhQogpsN9cOhsMeJqgMwwoKBIphP/aMILVjVJux8/LzvX6ci15EI oYtBi08KLYYsAa3BwTJZejGef9R5GQZwmrrc5ygxMmBUjVoHrkrJ9RzH+HNsva1uXtpw/1+XKMuO IwzCM4GfLXcO7g+EvVmGV7gGLAKgSCmVGNkdhvcIYA7QVwpfu+IFCfYfOJmgOUTZClnQtA8gJ8IN +NO6zHIMwziTQEhhUekogbQxLgDKVI1vLk0aQCah6CgYjCAaA0GCQqr9x7UYf4sEaMXIMFtHwcSd Hb5UB4wfBR1qmozkAgR1sVhFOnq69vOWhe1XwARcTSMzWIGo3Q7pA10+L2VqC2WfY329H98NHWOh Q0jsJJh/Lmuhnv7nfRHgkI2rv4mgwgkX6iuBO1L0TNVyuZuRAbDZ6jxaaBIdFUCmwT3zrzCnj06j N52lh1l3ip5QOSNv8EaDQD2CTa5j3ieLNdA7KPY8RdZBIwklhiw+pIotnYJzmivjOkLPzpkFeEzI R+SHETV0hAD9OtoUTDO4h/OK+HfQlwU3aBkHEHym5ywIQpaAJK981kOGfROi22Zi6RjcEhtwqolK CWnZ5JntH9AKfT3H1BrkCBvVU8BK7gCLcR9wIefVTeYixkAIUUbpAxcPDTDxeK1hqpNpZu3WXoNO ZUxiDeoxUMhDMxaTc4RFg1KRsj2Op3EEBVYOGUoqKjg4iHM1BvRvQUEQFmah0wUEZGEbwpcaZtma I0lSQM4Y4zmIRThlQpMRU069tvSccGyByISszAKjpal1hIJFEBBp06hCmHGsbE2EHGDpC1SgRNyM JIvGgkSIglGy0imKGhgg3ViVYUj9Ab/0ABn+Mbga0DJD6V00gaYofPrARIkmUdIBK+KGnGAKQAiK mRYREOYnb4T4Qpg5pmrEpfZGf9JKWhxPkP7wg0ADuV2P5RgZIbR/B+kgBL/2NjdSQSn4tFo8AlKv QEGEMnpb/6eryRT++EChpUoWJJOTEFHgPepOpPMAfAFAcym4choRqSfcRkuQ4EBhChkCZAUDQgUo tVVDRNQFKUKlUA0RFLQDS0q0gFCUiVRFQs1IhShQUUBQUtUqMQUI0hQoUhhCH4IwPiRg7iJMAO7i EeQG5wFy4LhPlkiKpgpCJJgmGQEfaBFtTp/i6BMDol09ylUhYmjC/VkLgdBDqJIIoewhf9+OGVA4 RFkg4ExeMGTOi1pwbDNf1H+mP4k9fRUTrBJQR0Y5c6I6QAklsI42NosEYkebBsIFiRhgV2QAoU5g UK5m+aKE+W4uSdmIhiXhO2BTTTQxA0hBQEUUUkyElRE0DMhTREzEREoaARP3hF/Qn3iciq9eHvEy d6yoABoiKBYF6GCVYEPHuN9W9JjtFeyD6e3QveRCQJPJrosRe+ISLQsQQxWAZwD4Ue7n9N13jMoG QBFX63rBTMPQAfdy5aHM8PefeuwTcHwWz8X9Yfv9X2/N0R2gHYmwXlBeMAVkFADYREHdInLg0LNZ wIKi0Ww9uPRDfg4mOyg/tC0jNsYe0mv/DX7Nh/LT8vYcMfLgzG6Yqxt878wHgCnfs0A+kAuLgRfA YJ/cAekTnpvm+fN7aOXbfkK4joPn+jSonYyBG4UDIP7PMBZ8cBLycxQ0IInxRkVBwb5RfwGmKILQ f+cAOEiiGQlKgUIKDQrIKEgKGoRu9sOPvptGqoxejC2qwNsCw4uxiFkAjbUNShrNa19q1tILxibZ 1FC2sMjCdQNx/CI9U0HPEVg8hqSIoIi62jSmAQyQ7To6BxDQCmzS5VVVXJBhIbhKSaHtRfMcq/Dx drVUMsfTBJFCTadUUnAKKYaA763A5BR9cEaiImxN+lXZEP3Cuuiuwy0pdgKQ9u648eJxLP0Qdiz8 QOIB17oC7tIUe6TEMTa/fiRFQwIr4GojMIVWQJWUYkvckCEmjAfCTxU0DkhEMzQ4nQRYApCCZyiQ m/9Rywoh22ptS7chBKeuPcCvhs84FwE2GsaiRoMIoMnJaOIU1IuAKdDg7lPon0kf7sIhEPtURGvt RalWP+f5dWyDX+Uwd3qV7m7Bu5a/+ni28dIuH+KQ0hpB2fGYf+LOL2ct4NlK3qCWraIvaAEYY5jc 05YhmRg8JMkHcJky7piY3YEyktspI7HJJTLFmGCwLjg3WZXC1PJhJmTMGyRYxw7bWXRuTbyW1yjp ZJbB2lyYZIWDlLDOMu3HEaGaNwusJqrUmENQujBv99rdN7QbJM1mm1y1B5hp4EMjbeGS1RVNPeSw 1owdmQkcbTJIMtTVI3K47ZJJXI7CuySmZibY1mlNY4mW3JFJFo08bQxQleDscsrCykUjcHXCssHZ RwuUjLMMKw6yrSEiPHARLqLueGB/HpE3kwAU41NpETpNymQ+XHVJA7BBxQP98c8B5yMnar4Rv5vo QB+hSEOjK4b7aNj9yLFUkT1YPxnRDkEwAyhWg/pme4FPbsBTmQAfZ/H9WSOvQmw9yNJ5RM/5g2SE qmUpmLr8iKBsyYJGhSgiYI7SFQQ5eIy4ElARIqlItAGlsJzMEaCiGBKFIZWhZlCgCgQCokpEJYlA YARgB5oiP3tA+wNgKmNIAcwBQohxqwzC9BTu++aFIQ/ZYRSZmEwEiz9FGexk6l0EAa1qq9e9iILk XAovO3buTFFiTx0FJE2vk/PaRVXXAF2lUqeUKJ9cO2mVD5ZUTb32CnPOKHowMHvxEeYkNcMSwYtd YFHWTxY9OISncAlOScZlKX14Hx3j34Ojg4jlgkTwITHgSDomTgu02SShhovkdWACaSAZuUtxlIgF jQPOGDUTxGwkZH3TvEP+WIe8bwazi8iHnfOYVxlta3MjdDfTggnYRqEhKRVnAWDlyJ+XZYLmAnId 0Iiu276UxE8XM5bGIlmDWJnhpwVNSFSUs0oGR9EiGhDMQNFqLHV4B7a9hxkoKSiBAgdXQ/e4RN3D 5O07XVT8TwWXy+E+2w4ktpKDhaAOrA8U2M0SC5tC+X8bQQs41AYb9zOriBVcLVU4/X4lczmMHh9z Mc+eJbi+1hq52Xx3dy43HRxmTgQzBCAlDBCKQwTaI7uhpEDEiBn202RJzneNQd6pq4g3h88255Nv wIUnIy1MJm1oFD77u9CWNcD52G2C8VC5oykYOLq6bK/wwPpt59cOvJzDJsSZqiI7imGDV/zPIrqD ogYfqJpzmJ9t1s1vWrlcNuwEZRuisIFptT1wto6YQm4Rp+n228q8Ih5T0wQuTv6BIU9N0EhFfdFW mbJARMiZVHg/B8t3p2AP3AaMGC6hDCNWKUOxnTwKHb7Me1T00dyTbjor0yV4M6J4Z/JvVD7XfyTY qfj3B5983+7jD8pEaNp9vM44do2E2wbvOtkrGALGtSCRJJapFGwom2Gv0e2ngaDRfdtH2EYeXcfB bPmYps4N9uTjeBDxfjv3QHwOQwCXugu1FCUI6LcoVtOYWzx0QR8afUeUHzQ1TYdQUgUwAf6n7j8v od+EUUyMAUlTCwKTSLRJQwEVAMzTAVANNKExSRVDTARREVARFIgSwTRBQtAUAsikFKjCikxECkqE ggUgMpDK/iwxKQoR/OHlAX3gchPyz+pcQhJBPID5zsRfnQ2hkj1MzGB/0Z2uRggdiu+ip3xJOeCB SQFQHH1BQCHwxUpSQDVt7eAod8mjJTjAggH5kfzlZpIA8OSik8zMVaCiYIhgpZPoskKRpgIgkISE ZglCCQJIioaJClBihoaIgmSICCqaFIlYe+MhiNmEHHlBEofWeejRXP2QP4eph8VNfJ1HYG2IHehy VAAzd28IYHaUFus7l31AD+yGlIgEmIkS5OhofqN+Q8JwdMD8/HRhgPhh2qpoiQFOGAPm0KeqXU0o H2BHaWlDcPcusFLBGIO157uVgsPUnHXjs/PPRBf1xVkU4gRWomYCXN3k2c8VRI1GVyRtt48qACVQ FKpwDI7UKQf4IHQLb5g6DRB1jTCiIqJEp8YQT1b/zl6O0Oe7ehHeaAPUyGvqHuI9UnlblY24ak0O jETboTATDDwBDSh9VTtN9V6HU1ZO461asRRIFWCTREGPAH83yv6SFW9UMIASB3s4eqAL3EjbH839 BKsI/FE61NULCP3fhQKhuzJmmQN1VGxABNPir3gfmIugnj/fwNADAkD5AP3h41A7fnAMFFc4HaHc QPCJ1odKGzbuI2RM6jxP4uFW18xMsyjqwfxy0eopTGfSmflq0u8301jiQ9ISMGMYo61GjSmpXm3c cFhqhqIorUeEhpd2LQz1gyReNa0ssqEAMvAl6vpTNpyZllQv+Yq+oT5BMCbgDswDkbjQkAK2z424 RM5zJYwYQuoJBS5SJbgFutm//PvPMh04vtQfAO6YlAiOxRxdvPR0gTWzA3jkqJ3aUaGFAyiLLEPT mfz/rb877EfARzTSKd5YTvEyfeirDcGQBxqoOkpfIgUiBQwH0zIEJMX9pJEJrSJ8XIAWsqvCmgPh jZYQkfMKZgVUIgepV5CLO8+KGzjyNZZq1U2aSmhgDGNjthWNjJAXZfKKh5CPtEqBUHcNGUVROwBj sA6bT1JbS89dq5+4lCLNFCLQeA+o0VnjnG8/NBwIp7IRCnpaGAa7RAQbeezE23ZAkgzihQG2Glop UkUShBLlzSxWhBoCCHGBGyAMcYkUWzk2EaVN53GGjeU2E5ODmv1kSzne/aXNcOEIlpFYNBGkq03S kQRuCINI3AKxJ0xwYywByRRJEG5CRqDbY2ETI4OSwgqRpxwS4gDIh3xaNVMUcTGcTgQa3rcgGkDc f4qKTzwZcWrxJKY0zsqPctMP0H8qaBpMykdO/DLqQ2w8PWoE7zZnK3hjunMSnOI7bKL9/9QJaBmc GLYdBlhqZGYtcqIyoQY79dmLPyGnapZ8A0WGcH+sER6KagZCPpDqA08JtVzvVHCQ6yNgxWj3nqNB kCHKKGw3gdwBg0FTGoDQi4QE7UWzog2EgDdSioQQ0d5oipQfhH2nEPX/jCHzcRUVBUEkfOfy/r16 VRA+kyP9cxjRxaTY8RA1cAHNyt4MT8oBGCGB28q99g5hBtwxVYq/HYJNnptMGIpNKyxBeB1ramoV m4MNQY0duQncnzlheEPdg50+Z2vdvt3mEulSmC1AZ7G+idAGiQg02EBsGJEhMLqrGda2f0Eg6auD EIDENeEJH+EH+oDQZMjAhDFjIwNC7mhQC4UDAMQaYDQ9A64dkJgMHY/vN2RO3AhzHsIMDQLIfOdB bCvQYkBi/C6P5JEVqNI9aoQTYIs2iwpErID1RjmtuzWzBmB7sMIOk4hQSEBi+5xvMlQzjZEFQxND BN9SAgnSwmngsokSIKwwt5p1YD9mIgdhiaeU5pWFQxkhCcVVJsb5x6dSUxQSVxb0pgWELhCmDLuD RIpSmnEqiTKMO1ZGR0ze1kqTsBpF6yWhDCCkSlF2tKQKXqKTXZ27zO2sdxELIQhhosjldUzEcJSI GQhBWkiCpgNCTg8GAG7SAQSwyD5ntPnD6JYg+Y/CRURd2KHIHsyfHuMu7Oc1pfRhTRESkWooqIND 59Xjjhxw5X/qHZghYHs3XNGcPHVrVT8O1KAxW5TMCjnslOpTjCPWoUgnGIhxj8EYIj0vSHGJFyQi Zg4RmYQWYVEU4ZhlmRjMOQ0DQxBSETISZLmYYUBhgImRJQQYbe314ep4NmdoqJaaLsp3nVN/5gp3 j1NIPmBKHcLQFkCRWSfgB4/ASPID18JN5x9WyxcDsIv7IMlKqlywXnFONGg/uNbNp0v6N75HiYNt rTSKDI4s5KMd5g/fDj5HF9fELod01J2TO+dS9j0UTN4RYVY4yE2E41P9Urbar1Ucq7rjnJfL7z83 BFgGxobD21W/K/A8xo+WcQ1NZY+AZ/m3tul5H0EXl8+QdWtU6or4br34rVfDZOmEvKB/VdWDN66L 4oCubdEBjUCKa/SRyRwYsvBxUvCOVyc9/XBEHUhtMDbyggrAG60lxzkIa9PYHAZ5ipI0wGoBTRQu Wd9A0yA2kD7iZY0Q5cQ1/vjYFzBziJtu2lFWai6rB+zERGgzTKTJnTSA6hEtSzSZRwMJwJ3jwMqQ MEIQqcKnaFA1I1MRIv0BAUCeMiOrViEyEAMWgKNA5RkWtzyztyyydKIdkLW1y7rYkkKY4sIiUcMa MKgv3iHIp6SGE0nOVjTRQkQ1EDGsHJCiJoohoIhaWhZHMx6NvWEETEkU88Gc2ygh895v0ziZ3hkB ko4hPQk8YcJvHY6IJHiktSdC2RDBG7JlkaaUqkp81MRwDl+fzxUPGQSJQoSC9DPI7/IwiaCJk832 AfScaHeoH2L50WkuJ9UEPZ7EAu+XSllVfRCuVnbPF+1pqIcUSiB3Er9OVtg0wcI+A6np2VZ89zMd nV0b7oML2a/CCVCaawCKvsidMLIuGeUH3kRYORbxTurIz44Jqoo69LqaN9nRocIqhIokeu4oIJ4i RhfriWxD3ffDbEGmwZ8/4oAFG1vL/bGGOo60OkkRLAGyi8bChEgSCWoMMYzjCEZat3LO1VVSfzL+ 6es6Qd336UVw0tjkutjbxFzHeMlvFmMDKC1BcC7jcyhixhjRa1GAlwJ3M7+dGSQCvrAMENvhJECA f6JeSpMSkQiCwv04qdpWnSVBrExr+Iw26NWrWZJGBA0UMYq3p4rpq0lPIwteigm0o6NQcyDppJRl aBj+SI1VlT2RBGYm0pb1rAKovdBvh2aFSEJB7SpSxKBkAatUWSgYsGzkzAxWjAKbKTWIraAes3vM 9t7HundylT9UO3e5gQVNBEQzM3dH4CdMkB+P+lDE8rwwU4xer7LGkd3jhhZLFuOwWIJ9Vr3C4wJi MJ5h/ouu+A65nthvZUaiet2sEi1upP1EB3V6PQu5xruYH4NVhpdWkodc+bEXvN8c8jKxDt7Sg6Rs S3oFoMIT69hQQgdCj9PoVR8PYnOeqgCYpUIBPoAI/rFJQ3TtEzKCWDtAPSuCG+h2ukgUneR8CCZD ONOlQ0ZjqUPWyvYATUiLRRAzI9w8KymYT+Ng+gNiPIZvGt6qEAPWV2hVFgVPtBSPGD1jF+FiXrLD 5fpf+TzU0JhwTJ/o0i4HDCjBjFmFFg2L9uhdhLMhoh/O4+eZCuZ2gcl1YaNZs4wUsNPG3AbBga+H RoNhDF+cDQdYqwB9PU6qS5E5UT5ca3o9HCJddHa7O+3PsU+8GM+GJjNUje4iHiE3P5WqxsTWTDjC hYjjcRiaWJNG5syGG7EFcachbpirFqSDI2o4OP+YT2uGcUjVVlKIeufhqKVkQPzQ4BuE1iqSDTrP zPA4TMecxxNhK4xAtFGRbQTZKggb63gIftYlEAXJpy9dId8QwGhSaFqM2qMhSqojJRtDqZHIVy8z GDZy/XUQ0H7B2xts4ZW2JRur9WLWkZRwnzdgwj49+/fujwmYPcWJDJNbuM9xOjx4mbvFdAzGu0LH Pcb21nnD2cg0MOUlK6ggxgrBgqg+irQkkAmhMa3yTab/IgOw4/WoUKuR7lR5AHTtANp2HAOq1iyt TsaUsXciwJc3kDQ2ciFNAFJ8X396eSHmaqPnjZgU2TwD2jzA7y5mZsqVBo+JamoHjlVV7UGjNCAH CSUAfMwKeIdfk/VePIxZOYoAb+4e+2Tfghgho5FzKqc10HhJD08Ok+jGCEI74HUL8mxEzAycIuDa nBgJCO2wcqiBcInWgP5hIKGgCCgm+ZC0r+WQU6wGQHUh7o3PdKHMs2iKQpiEMwsqMwiNNFkBSLIj iQBbRHTFXrg4RC2LSJTDv7+vv1o1o2vCygVDRFTAFK0IMAqyB3ECq5AB4JAdpWg8D4AoIQddnlO5 ycD8Se06eEwiAQxAoKhUMBQQgCIZrpmQ0ZNYj393X8MHB3tPsjmSzEyDBlA2flKJPxAp4ApThVIB hMjk29dFQCbPQFV9zU2ys9EDUFIKlvI8BX1PJ8SZApkIHcjoGc51oTA4dMs7Nhv7yRZwpqK7JWk2 VE4Bqlycj2F4TjtPlpqRVLFBoFYKWj2VVs9SX8w8+JgnE9w7BVA0keKALyTjB8vuOrl9Jq3AIH8O tUsaIvSLQFZmnJwMjByExfgytTBYkMDGP2YiOuE91TepMCqSyoZKgHeOeaaN8ZF1qBYaoka4tGfz 3E3tto0vxyVuRshI2D4TC0fhHyC0e3SPpk+Egd3h59DoXCezMIKKIiIaiWu0njGiqmhSCPec+49y OzTsyD8lDD79hiL91gKRylMGc5TVOiVDAITmAxeiv1oCYaBnrsEQcHoGlXUf8Ixfx4JivAObGRp1 pOoTrBbafSJ84HcBsIJ5vpmk3lBIVbxNkvFhgiiYKldFRH6uAIjgD2bDyTgVBspR1G192bb0JzRr BtAA+WPZA/UjwKGgFyl9DbH2hF/nURfrcDPBEEpFWFsTv1hI5wPYpyImx5ujiGMXlgFQCJBZBkZE iQLWIOKEo0NI0KSDKBQlBPy60OpHN6wtKkAExLRVCMQtUGRlEAZCuKhbzCSRiAcnCItYYFYZYmSq ZI4wSkFFBTMNRLSBIlEHMJhKUklWswKZVMwwKhGlnO4wNVrDROviZmzm6bPeKr9co0IPY3xaOOkp 0jlZVNQBybAwThoCAJiCxAw/XsfBo5cAyHItwlwxdRtU0LkHUZ4HmOTA4FpySGZFgE5Aav97mkzA ZusetYE6vCzZo3RZDSJ0E/3vSfXMob4tDIFMwieiaa1odSbGVxqJGouWQwgRjEiOfthCpPsuVOGH Okt3PtqhVA2XWNorAFhM2Fy5ZVLQjqUkwDSVPGiMesBJhtAlFmRGU2lNsKc7RWNDKGyOig9zqPLY mcRkDtxsoDwncfYcKmoNZHKdR2HwLXUIU0guohsMGJ48HRsGwUGagFQxQ3MxDmQ03mMpSaqN60qa ymKhlYk6Eq2GUKbkwwmYVMdleMVGJm5EjbjDb06wTdYSlLqRphjCTbW2LBmbdpRImIuNNsTVQtj8 3Th5vZoaMGxe+RNjY7ubAYjEssCpVMjFI02t1dksNKsMc0c053zjnhOrdx83XhyaYzGjJ3ZT+dje smsiLGzo1J4oWtwiaHMZKN8ZLXhSMDAxB4inc7zeLQ6gwsMzxdCYquoU7EOgsDCzCNEajCCYwgoo 1OpDJE5l79O3QYMB+OMAi0ZshM1hFNECk0H8ikr+JE/pE9Im0FNKHmVH9qFgNaac7pGQEakb09ug y9OMeO6RFNVp1oxKGChUyTTUYZVmYWoqR6RYIWINJDQ0AwjQQnIS7EQNY4CpoPbtHSMkPmuJ/cxR M9oByU6p8vU7dQMFKMGYFGQEAVVIWet+Ds2yxjZqlvXCmkTcOJdEhPWjauRq0R3Bc4WZH0Wz0GE8 VM2HTYGm36DMaGZAeA5j0OiX3zEBk4ort6pFBlxg/BNlDTY7Z5p9GcaQKXdWgzAPI8qJQPbhi3M2 PbxPlEtTs+E1wOOmxFS2q9lDmyiP+L/J5XE4HT6lN0FuxEAhD0kIf+bbyg8I8rzxdnTuC0Ywb4gE 8ZKChEOE7t3gZ6MjnWzRZ2SYvooo4ltlvbbSFzQ7cZ6V7SQ2awhGlYWY3RQqVN45/vbMH3LdajCq hcySYkhmsQgHA9vHw8lJ06BduECZfKOPNcfyobcjWiuwCqesFLnb0Dohww6IhY/cmlyBwF0IL6xi +qxQg31OxVKdhFqBVElAGfaQfQaMYdwGnDFHE5kUhI2aQkAKNMQRRCOIL35t1MQRKm4S41r65Clc ijZAWGHGYOoNWtGJqTidkG7IE3AUh9totZGFJtMMIETCsQqhoNwot4VgRoITosbHMwIR5gdE6lzn ECi1gIzZgY02GaQE8VIFOmgQdhrGGMYSXhzPwMIsFSoaVA35ToQYtBiBdWJyASuCZGOIP838uFGM x4GXmDROAYG1ItJkE5liYUgTsRXRAfZKymOEA0kHm44wRARMSVDJDhBgRKLVQRFDBIx7rBVg9gP4 +hpQN5nvMyKoCQSomeAGIIc4HMPbDuLFFxPaRDa7weZqIb1fxAreKBagCQJEPJoFH7Ewr0vx4hV4 kg+chyHk/sbNIkzP8aXQf9n4vvq/c8k1eREKuYT8eCTjyDWN0piVLhHUELSJ1RiMiYESz2eMGf1u oQvoWB9h8ahxRFhApEj/4lBU9zoyFKEBiSgACkEaWilVqIBYgaGgoEof1AwqH0gEUBQKdP4hMz3g p7wV+o2fGqvjW9ZpymA7rA1uRHtdUHIXhEwcMPFYliCJpGmifENL2X/Yh+hE4UXcCjRELBAAB0lV w5ZdGhTeDyH6Uxgwldh1xAJ9QGiHPCbKA9yEJJBkQkRNJ29gfgAWP/jgBwb1z3gPwROi782PQIEs CngB8U+cU64CeBBCRSoftoKbDQIUtQp/s2v2+f9Z5DuPUQWEQ7sdOfSA/WQfisPa+a9SEru49epc FPVFpyUOYMpW7vLM8Mmo5IZj/jDHv/jeQNptAG96xVo/PqEOUA/OnYotoOZ93LpbtJ7jEAkgSRIU QEEEJEyE0MyEwjTQUAP8F/SVH4FvQLyLFwP3w97vyZCQkhFe4/cbxDmB7VKpQ+9Ch0EyPMD2HxuL pzjlJMQ0YYOFKUUpN+MD0CNmqjbwpwJo2acHUaLP1KaDiWISYVIaWAghhB/hgKBkkQCh/qSDIdAZ 0X+Z6dTUc1QQBGFhNRQRJS1VJTFANqqsohHCDCjBaxTCCIWC1YQ1SKiGoQ1a8DNmsEkoIFU6Lk0K 4cEB+yDi4DryY87xMkiHIENMuBwUbBNGtoI3xJTQIQAp/WOzCX+cME3InJCguT0cznBLFkEePOih qirjw3OclBD3cUhzhaSmD9p2TwkDy+cu+HAlMh0HqJ2aBWgQCQ5iYAxY7VPvU0LPcBvegjoRRk96 nwPkTYAd+A+5XjoBtOXumsakI+WKItidIitNsZBiTBiIDQX9qzMAoKDTOEhFH32rUQRNqMqV1mIb cygPhgZUhSVbMKxih2VzvbWkRXmFAAySIEH4QQpuyIMZorSQJk8/26tcHh2N9vo6d0KnchNQSJnL 2KNT+2Vm+Dgi0qBYIwd0B//ATzL3wckcBPNkqP4oXkjneHcEh/63MnKEQSdkJexHS3A+Dl1W8+7g Pr8TyvmqL7mIPNnluIzmBqQK413kANogyUwg8I0Xl3+QGQzAad+E4JzFyoIUYLQxI6sdiNNFKqVg SAkO6EBlDL+7sd/ft6yUh1IuIOvXB52d3IOyw73Xg+LGpMFrt/xIG/YNA/CoIaQPb6cmC8RqOccW iy1VMhmvEP9iw6S/lCB9Q3exzgEilPE3zVOOJmrvLcDhzAD/ah2J7OwTMrnTSJ++lfwbJqQYQJNZ Hcoy4aQEuWoBJiw9ow6EYGbR+YByzUH+jBCkoBkZFpA//poDFD989n07DTsfdHq2aHn7DKvzIfOk 1Dm8jJC0rlT+akQgVKamFP6Qf3Pd3xZK/wRqb44ovD8YB9HFOUkJ0wfmnWGOGrCIyMRIIkgipQiQ ZrOut8a0cH63kdEgHzwAYAEQsCQh5/R0tmxZW/GYgYvVJEKCSQ6qGCfq2Xdac9XiTQarBFxVAI0U kslsURAmZaBIjtN0JhiRkVSPXyE9SQEcOB7dUgf1xXgcDgBzBcxqlXmFJgLzp8TO6CEi0RD/McPg SESM0VKRSElStZiCYiQAUE1MwAQKMiIXxHjjvXgDmQpCWaCokBoipIgGwDAvwE18IqHmTiH0hFjB UkVRh4AIc18O8O35Fn0NIFFAtCob6Q4LFAcC1QoP7l3YY+wDWI8PEopnLJnw/p74SEkAgMfyE6H+ zteABt4lkfk302igajCMCHUq4MRCUAVYYhkBEORkhrRjHesYiO0fae0e5Q7EnUUB2EAnZVpII3sW K8XaqYWgf2/uYWu3/C4bGHUXNUt6epMWmmDabDI8mpXqiS53ghvO5O55P9Ot9f+hF+/tdUHMiISI wQL8iD0QE2CghJ9RDAGzQb+WGIswpmZFRO6BCIVRiABKpAv4fQohaKDzly8sPqg1T8uBifaEdtGL EU0isk0FKmoXL8MhhMQKRrMJpUoCoWoEpQOR/S/vzmThJWlTz4cEX4gfxkGUsEFME9oNwvsl8Y1K j3k5CD4SiIfYwoJ1USBWJE0IHqVThYOhD4DqEKRXkgAzEwWMIg8YfyyaIIIP4yONZcFl5H7NCcRa I3A+0FKcdWlXJx0oAcRILIJJGCSMEEMLEpATJCgUKFDwGCipz8UJzoqJO6q2Y1PfyoKiPdBKgNyB 4P6IQ+HYDuhT3S98PoYEEKhisRTegCD/nnRekOYDh4rWbHm3BfL6SkeH6piViKEoipAKFKSJQ7oV D02vFQnRC9YD0OhAdD41MlMgRDELBKBHsPPp8agIhSkqigKWh9xORVRDVFUP7oU5H7HAfGQIQh+2 DRAyxIx3boH5WsgKbhPh5RMJ0n1FVTh++djJD/5gDIP7Zp4UCV9Xldi9EPKP+AHahofkcj0eaXoJ BR7HD69Oy3mTI5mJEBMFfmlcta1oBpVKRaoJkpGbkzB6PDrTZiJjIFoz9Up1k30xHiDX1YZARBMb XDQEQxsEmcyJhx1VdfYTWk3qXSDQ0HJYd2c9aEiprhES5qERlR01CCWpssVDMXIlIWLoq6wcvtFM V9L3xNDzMGEOEsHp0p4ZpWBXFC16q7UUC1HlSZIIwxmDlK0mUoNYFQRoCFgu2Qbxt5SCbXQdDy44 MNSP94Au+BoVDaSKuH2eKBnQn2NIyUwo7lakSIewi2gCtMQrSi/gFIOiGYDvREESQBTWnHAw1GxO ZKu9JwxIEnacQ5QqiFa/ZhT9CwnAifYU5IsZItoGpcQgYQ72DPuwNCfwxQCv0yvfI/TIm/Qx+uEb CxK5wE7/xbh5akwYB9rAncJ6ld+lBkGRMN7MTO45ApQxAIGSnEwFN7UDlcFP1p/iIiSMRz/E+hnU kjsYUYx0x+i+mxJCiizMj8MhpKdGASpOGa0nB9FUhBIeRcgxA7DAn2QLQQ6ngwJBhDzKmIvMlvI4 kDjmyAdn+4KYACIebLi4E57NSe2cbBdswlVRl45CP3QCk1+VKzo9kFkPhE0jBQG6IX7dZFrX8n3a zgwieAyP3QtyIKQxRa97KBVXLftAb1N30gDyE+QTAUEPoA9YQUKVUx/UkQQIZHdDqZrjfhCOMP19 /IAhD0TwKtGmEs89lSsigzEm2SSsskadFAS/Iv2kSw7xhGRck0lykhX1obqdAnD9oOY6N70mHX0D Hn+O5krypQOUQ3j9/R3+YQzNC00/chqyNRgyDUIWEzV11w4y/4Uth/5NEYyyTbzxlf8l8AKhGsD5 F+2SOZNYDOSSAtyn3MRLoIeKzp77vgQJUmwg84cEITDFRhkLJCemKUZsGkMT4XmmnMo5Z2Of/HUl Et35wU3lHEDmxT3JsAkGB0bcLqKFRLH6jJmB2GoCxTEX+oHabM0O5MW6gA/T9FNBYAbxTmD6A1jp 1k3iobT/6bApwa9FSBQKUVtlryjqsYlzUCbGFmeKhpc0SgKV2wJ+FHbbCv+kK70dgNExVEFySnQW H0JCjbZFuPrUyXshyBBM4LnlKKHQCn9gU/Uirz3/oS0qVPsndVQhtiaiOUPSeIKbFIkJin6f4YqN LKQ+T6ZJ+unQ+yPqu7GMqJSeuWJhSZjgxLGyHDQ6c4xnFtISKHrn5NxJZwxfobYY22/vhzscxcT0 shi3g9NZBBUvP5e479G0hqgho2BwUVOFyEhETAxJjGPBkY2EkmWieHTKtDkWgootJESDIiCaK0DZ rMdUWBihEvdNATNURTFMQxCcnA+hC/KL3YHQoOr8p8weJKA4t3OIDZQ2HRBhAA6oqQgpQwB2xQ8q 4fKIoeVLC8YBghvdUEyQA/ySEDroKIZJJmkEMQcwcQx7SjkqQh36Tw9JqivozRzzfYLAaQFN+g1O qGl4TWCvCDxgd8UuetA8Dx0AUPkgeiGiQmD6j6jE2RExMxVVVJNEGb0N6/fp1rWkTzP1YB4Ccagg 8OwIOSH7WjiDWpFzBBkjF0WdS7b5k+fifhgAb+GK9RA4JWJBCJcgyVRDvNqxfDggIjTlHM5RPMli 4DmHrRw0pZ4cx0xne0OoyNCsHQvZGbNyM7eh+uXHIYGAOUSopYookihrprWkzxnmeLhTgPmE3o3t MEA0fRBvabZKTOuCWYj+P6uU/EzxUdyH29SvWXKuVKogwi23bFg3uZ5QeXYvLzVVRCAjF/8kkUMY Mj4VCkgDG/kUTb1HyQN9oHErn2hxMHPHw6VdXAwKxDvBXrKCeiBiJk3pB7auQMzTCFsGipQWBime Y6aBu+HgB4GmaJjLdGrgFOlGD+2Rtm9EbbCDS1MxCpd2HoHcqX9+U/pX1JzG7St8ANQYO6AZkOIk Z0hRGG0rqGxEhgC+QhhBuHuhaNRAHnDkUAJAikOr+dYXoQ9IKeoBSApVyDuT3YgO13hTadlHV1ku WQqwB12VwYaNzFDUiGofpXnFDXWQjHUgVGiTIoqwtRB/pFMXI+8k6CIv0IdNG56SHMG5bQRjBkfz 7QywwxWEDFsj5F3Dl/0rfSY9M+z9CH3EA0BECUpQNNCUCr3Qq4NNyv3eK9B+nzHD+8ipfY+i9WvV FO8A1vv8fUo/3H+Ru98e5n08ztDDP656LIrJPkPyIMxzrnz622WYN8D7PmQHFM69ih3HeAeoDU27 vx9Qfkvm9oOXfcD4P8xNgi7UT0j2fZC+jQaCvGh+G1D5bmHZXJxLtHs+hDQAaxP4A+TVPs21fT1g QR5un4owhAWJA3GMIhTgHEKx4bFhLL2CeQTQwD/ITzOjQcngSgY60OFbTZR0cFI3f2pIMD8+imtf m2RpXS35+9fmxwcGz9sIIXOJM5bgRAEpWUUSLQjMTaMVVHBkrcVKUsAMOExERpRo5BFsVGgUaRFM iiwhBRmRaMyjmU1cOxkHUBEm2GUmMakcl5INNEjqymRJO7jRqnoKZhM3GDlI1xk3BdFA5eAN740G oA0RMvqgTFIK1GWQGNbwTFGJNRmsxqZgkON5EWiCsjRIE0GWizC1hlkZVKFNLFBSkFNNMQMyNIRO SaNG9YOQ2406IIhgYNNkX05rebUmTRmtYTKZZEEQx6WAaIMJPuMMKAqJiJqiDpjlk4yZmQnMmkda G2Os8WCNjIxoY++ihWzcFGWtBZBQtLSFBQTUhQGQ0OSmEuMLjaZUMplxbMAxnMwJA06wDIYjIi7s yiiCAq1gUAYB0MdBEkCGqIyPxnJi0GzCihk6PE6COEwOIDXBcb3JDWYBUmIWeDRA0Q1lesZRj+CE wXTNZydN7JoydazQpajCoCZZMcAwlo8SwqCtNCAnqJE10cN2ME7CwC6+7iA/l2i5KehTLQiaEaSo 1WvdDZuyKGSSc3hgmEVqdGsKoRrQOkAKqCRINIoIatiKNKMa1pNQERMwUo5KWkwMSmNLhAAtVIy/ FRYFQwYmNjX/navQREJyhhoMVDTwqSCwbMV2mgxV2QRgDiJI2CwYaExNauhqT5yeYgg4gHLQ1hii rP3fe844t0JDFnGiBQ9ABSBcNCg/fq9+4fzWB0MQOk4lX/bIh07CI+qAGYChCYViU5IrRBRa65xO PnKqKhxgNGgfCXuJMLxKa1AYFC6LDnTSh493zgQpw/McEoByQodATiggoowBNig8QB/hBQCQFMtI lJkUZB5aDNDgoa5q+Eojti1BiQRXFCGrE+U4uEsmq7tNyRyjG4cuCzK7BoZFD+UkTpGmmhA0Mysa y5jAhhZW5YisGIYMsqQawwaaw0mtMbVsVYqxmMIkVlccGnppRlylJIEkHa4aaxrVxxRBE7SPoMA/ Ea3HBib4SQNmpmspaCP1YKMNz6dhSiDhBo+QXvaPm/5ID7qEB4QT8CJiuDBfcAdlev9IGts8R0p+ 6SiqGhiaDCpfjK5Ds9SUh96YfH4QyUkwRESqH5T5Mge+Pdgpwb2q0JXzRw6wYgIkpuDB6dlaEqEd Pj8axqUkJBCgDSPMgOHVOjOLTvI0ojWwMjMwULRAKxLE/w7rWCkgfB342PH8btpcm5BgM2kK17jb kb/itvkQVwbNLTa7eQwKKsyKGrKIxIfdpx7AUEJw2H/v/ej7iI50c8NOlxvgcEOE2x+RwAyaKKQ3 L75cEUJUkRGWxVMU5lX8rqcJhxNVAh9eQFA820A3C4BwwVPgx+9P0Dv/E6qGaBBWLTANdkHgQB7+ wHwvURv7yofLQdklFI6Bht7OK6/wndMgh3kIRqYrK//PGAMq/+sMzwSBEvFTZNCAkIG9CovO1+sF K1wHMCl7ZmgBS20FKQQMUBmS9QnlEiHGJ0Ap0iqnPABkUbCRH4UeQKQELFB0IWUSwcoQDQFaTnVO nEU0RGSkiHiDJU0Y4NIHRx/cPQcP9fgA0HtE7vp3G4NnAokhmFFXtYkUHgKb6VOYgUBbMftD9ccF /SzxiZCR0+KGxU2QO8SDURDcMsQLAXyh1KpsvA6IwhCJQL81rYQxssWvpP7cT6uTnQh3gEgrbS+j lfBZGvZdqEKLNrZqYYSR9yJ5aJfAhTIwgSlMlGcSEDxUt0unwA4FRUeSuIxh9IAcSHcPeNAbpFFX xwA/Ub19KAkSD405AZ9Oc5gmogp0CcCqO9YRdJrEyyA7wT0MIEeE/AP/AFPifSoE6CMUIxjAsYwL GMBxMiIQiUIQHEyBCEQmQGQLGMSxjBIwjEIxjFwwwMMMVwZAhCA4mRIZBkCEIDiZAhhiEYxik45G GKkGMYFjGBYmREIRECEBwZEQhEEIRQhAhCChCJQhAhCBCEQyJkRCEVFFISiFOziNw1E4th6/i6ZI cokI1RUIUS5l918H8++AJu0OcBNBlyGpeXS7cbZf4GTjOKRmvqIbYmx0idamIwgTWTacL+kHsokE E2hzcytrgIUUIH+IAMSI5N6lzmLWGg1iGAUpEBOjMIgTn+3NCUjwY/OsmUi9ZDy+btxtjiVSgE6C EIHfCHAcSNAhkmSpEARC5mOEA5YZgNUqhk5AlHBmkFNOOKdnu2GyB2SNdRwNUvfACn0H4ugm87J6 Ug9JuoRKfgSj6wElSx0tQGEwTGH3/HoC/Sw9XKDGSAxe3Egi+YF5qAQHmBOCapkgkDYZ5micwwkz WIYDBSlbsYYAZLRa0BkRZbI0lVA7YYxIn3BAMenGxsTMTYWFalqumjkUfZC5BtUIDIxiGHJTn+gh xNwmwiKlJBVCMAEklQgeXERcBdAph0naexXiwHUfrv7Zsp0OfZ5EfRT+/+KNX/LBgWBI4eq4wS60 kuAyO2oeBNupkfdYNOeduwYEf0rpBpdJ0Vp+uXhC9YqQjPShv1IOSGJQZRxDmU37ZcB9Q/L21M3m QuNeMKuqXA4Uv+JGMbOMHm89P2uYdv69Nx5qN3BqrOAj0W8IDyzu0MmauXsfe+8HIxqO4jpm2o1W Dshoo7XDvCI4gVEi9mFaMcixVOpeosa0QhwHEo/TBXjekvQNZrPnTKNjocoH2RkagBDGBr4NwaaN oo/oussc6aO8DSjbIokl0E9NN7V2Nl/+JBlyWxUu0YFTp+dvaQC9Mtrpjvv33RHIsFqK5n+qsci6 JMonA12hckQucg7g6ipY7iFamFYyt/1Mx1d5b8qk5ixUalkULp5M9Fh1/4H4VLSjnRqJX5CdAL7j sc4edvHDyI8xqRmPpwfJx7vQLLlRorA1ao/tUI/zInbk+kuCGPaaV0u00/nqLsqhhgglHbIcsQen ctDSR8/eWaFojydNq+VoyCQJNYkg5Qd17huo7M87c+yz+jab5zOLFp+lhmivfNOSOL2u58wqB6iD 173wy+y6vNk573FTus5vD3DMNSC4/YWo7xCS76ut/BbaamxG/L/7ESpbG4g5cr8BtRxZklttL1Xp L608GdRbMqcLmT3VpLEQOUTU5E2mg+PNFWJkOIDrBMM4+shIxhDFeGZcyuWHXDNZhRTRRmDgzSR7 erceM1Xpwwb/D3hit7wOORDjLwEBKZId4Y5FEtrMjWrEFCBPmIEzSiV5PDFE3TNZj0ShHKC9Uo3z PV26FdWqcWDzzYuTn1L/3+KGpdIOsvtmSOR+S5j1VS6YlkOwkn+3D9p52xqWMn259qTtGb58ajwN rGFAjS+fbtoh2z2OP0S/H3RRxKDym76p849nzhkqW8Oe0HHD+OpnN2OffLfCLWGw8+u9X7svl/Te nLh/7dYJNDZa+zcalg+vBfhJQHIJIYQIZbThafTlGrIhQYo4SBG180CGHVo/J/KXnJlhFnvt11T2 xFazoieawKs49kyNpnnSC7LcWntWs807vlS8dxUF1zIszCK56Bg0FPVPHHLv4wdpowl3JSwl3uAb YuIBaWNqGmYBhvjpc8Tfc5DjBTEIUnlWgDEOwZx8cE9inPTJiUp03gdtmEzuv3Kawh4oh7kiqHkg hZpqRYZ+PkRJLU42I+VTkQYgRU8wHlSPfpDHbTrdJu0STTx4xg+qS0nIIBRBFE0OZKNkGi9mjLBI OyHJT9qkY0K74yeIcAEKohtPs2csLeaUbZcgxJR1FguMoRgxsxGoKklEykw+xM4wiljGalvFPkXH 1fNsAivyiy/b0siPacEtPMIpmQMDcYhvFIKvZoT5rAWez85kkkt1PBqSfq5Tr75zi6CCHYPuuDDs WrVJIfWmjUuK3ERBiWxGoM/yOP/CyCkePzPUXOxezCsI9HnXTvkYzxri+E/u9IVO3MWZk7NG/w23 u2MjTIeswUv2Gu8JXiZGnFYK5QzCMCEMu4fWRPAPAucoaD9+WCGa/QKfSfYkLsFKLQaOx6LXRwbL wp9dXbIDIw4CQaVEvIWObG/aZlC/9FMHfwL5ECQcBYs4/gh3C9JRkdlID+CftXA4zxTURnhtqu3z 3Z90+T63EHsv136TYNSL6ailhBjGqU6zMiwZR9pGSKR2mMSFWgGSBL+TVDMjajaJK09YdceWa3OY nk4jiZohm/ruHOsp65n6UCtuZlsMjAGDbNQbZZ0iMWQBtECIYbQQxGO1AqAcC1rNIY2mQYZcKQms DEjAuKkkUskXwwObCUa1FyMLFEMGRki0+2/48OUM4TYuuIjljekNtvRkqS9ZDtD4xm8MSSgJKFS4 CkBSpwFkAu/Pw92u1DSGkcHHqG48sjeSEzXaSiwSkIUEpCcU1eoFPIbYBrvSDSIH0NchwjimlQQ4 ExcCYtcd+RtEsrbaPJaUOTVVXSwoAUh2agFh9vcFIpWF6sl5LNgGmiEghoQRC48XOwIYGMQhP9gI opkctDA/0/2RB9etIVOkNgfn/z2olskoqRn3s/C0AMrv5QqpFlwmNUbND/Df6Ff3sGP2m4Nw2fvP UdZYj8h3B2yabzDkjw1prbQGHLvQG+vEMjMcglkgmq/H9Qp8YAPCAShEyWgAypQ+icvoxzaCNBlS qUAhQg5p52aNrMGNQApQ0nF1H8xisDMLFgklT0BiKmFbvStCR6mkcuhwSM5IS6JHm9b52tbbQcNG 5gOW8MqubOkhxGas68FZTv7TgNSUScr1kOEk0C4JhOiU0kB8fNA9/0etA7FEqFJS73GlegYv/Ouv +0PgavYgycR0rTRLqD1sFQvZOv6yiJEcjJ6jZlDiAnhiCE458T7jIHkG6ySWg3DZkMjyFOJqbNUX DmVH0vk6BiSqqxLYLNJZukHbw04qdwGpJlAiJPA2g6BIEuE5eXgCGYQ9T7JozQZPFDhg9mFN4VH8 v/XdYcapkhYdVkCY9WcxlB9QSJMjbF1inITPJNVHRQZUXYwGFZDf86oaqWpinY6OhIdr1PqtI7jO GKBq0jEBeJw0IqaSf/wAjgLJr5uTfBzc0QlH+G6fbmHrZAsYlbJf/w0nfif2JKyYhzHmB/y3hJiq baMTBH++A8iCq/LGGf1ICUgo3P4E0b1UhBEkG4lHVZPJG4lrZkLrtgGeOkIPQQ5qprov1XdJEIMQ RB3PTWjUUIZPMai1U0mDLRFaZFKeeCJbVhQCHher6KKrXm15qyyDkGjV0dkg62/lzAGB8gmJTMCf oNVoQMQWF+Xgle7LHLLE0nBs9xbkMjrZEClSmEjE0YpBVGSuApohRSiCgsWxIV52sjMsveaool/E flKNHI4pUgSEMrqT5Wjp9WpwBVQ6Ci5mM4Soa/jcF4oB8e7uyQzQ+RQ81S7EKhf2J0aVO67xkCRo gSJxxAsSxSfkJzNiz8ewNnaBmHadx6wTeS6BwEw1BFcSz3WXC2je1+8DLPLDVK+cSIbZCjfYLBEo EkBGXkeMTdN4EFTKhr/vh90/Kk/hTomXJxv8usT0f993IGSXzFeBUGQkLB2o6l+5S3AyATzJ6taC FUEi9YWnZIEOdMooC/GiSeMufezPRVETNx3qGSBcsfMD8XUm164SZSiKghgkIYkoUgmCivZiYFUU qQyNUUxKg/7SUMCqQopT99YPYWsSOEVUNBgrEf3NN/VhjHrLQk+qpTU4ZqxhcQgQqIYhlkGAiDQI BZJYgggNkaJMLs0mokY9wSRVdhuDLtZjk1tCU3vTHNQzTFm8SZE8xsm9mYghp7aW1i1rK2zEMyGg YyQgz7C0RCqNoYwUQFqQgmTA/bDnGa1sOQ0ueDVaiAGkUCniRflYPqF1suPTMTSdYOSAi7FhHGOc aNKJATgGDwBpF8jRYS6AUJRcQMjOTBFE03efmkoFOK7ivthSZGgXC5iddLomgnm+iSuvM+S3vUvV ZKP1MBdNFaqRjIyo2gd/YiCxopucIahQh+JE9M7aM2e0kTJBMJXPMdnEUfgFGWH5bAMkDhDdbucF xonEjnvEgeBJPMgFnAWADVsNFlAgFJYPBDiDA1hnMMkqVey7UVb2iTc4flKYS1eUHUe06cEmNfmk 91cee7QTrTRlapxFxf9OSg4cDCzT3lyQgcvHexX6rbYvM86dLHKdp850U7Q4CmG0N7p7EMgOrI7C QzY29MbIcHIHEJYuKSEB2EA825dsyEpkFo3DpDRvCA5Kf8bccgXngmhIDxRjJIRUvuVzVPVYQ4AU EJ4kWHkDOPdob6fud9ySIGWAJEYSQiKDxyhMsxDJDIbCGMjBwFwdbRomZmXST3H7xx9Y8PmGoKwP i3RBEQ26Fwjiqfh2gfsaXz+aJ82gRHE5ntXxWMYL+VQfyKf52xH2M4ulK2gjWIjEXD5xY6G4Uz+V 6HixuZ6IITKfYUrAaxI8lYs8WN5OUtuUKI83pIvTAxRx57rPeOImNHcXUkcrmA7htAzmgkFJp95A V3eugCiKJ1XpBtrQoawBS0UAkEM4CuBdutWTeK8YqpnFQzGIXCyUcCWd8zl8QKUyKGjM0MOaLs8g 2K3etBNJg3xPqXYaBDDUIAYZEHGGic32ZQNtuREOtx5cxIxiOu7jg66TQV84x/X+Wm0tDSFzTsmE GLoWOhzrQ2s9E8ujyajF8GAsDN6U2XQcLzUZ01K4g5kl4Oc+DPfwvSLnnRpmTnuD7WzVmlRkeCU3 GqZ3xJbCzJYcCNlCkXre41ZeP+knNA/LuDuPCHtuFC2SczPOSpIwnrYh6inEkbXLONFe9HJ7b1mh 1eoCBSISvdlZw45T66ljkXBMxRsNQzhLUQFaOazMu9vvATJmDcNhmKNI/bO9YMiRKHEJbKzriGuG ejTQ241ZzlRYSRkWQ11R28DPTTM1Bzh3yTHW5MVTxm6jCa5q8G7OVnMmTBqlBId34beN8nKDGkcO eJPEUYeeTjiLncWYjKg4kmXxUxha8c6lbMxSKwERhM4jKbSNWEkLQ6Y03z2jTqW/U1Ba2eSmzOPR +RfxRPA76f76K7c3puTALXoZiS8ugpmYTIw/I/7T1hbbdcGRzemdceTmVPGJhQ7G0dikWveP5NFq asd3jQaPdeDZQ8auevR3vCXnnZEmzbVT/MYVGGwMxA9lKhUVEknDeS1HnwaCON6I8TvbInxb4OdO +Tl9GyL9I3OMThtQjTBo1urlwK+20NiNlX0pEw0c8Qx1wknXfWSI4WhEkii4JTCFzki3qmi3qy3Z cp21OKgjOfA115Dqq7ONHNlOVGrpO48MzvwK9tb0yEjlQm1wOGdsGBNCLxzMbyyC0agbaE61Mpo4 uokowZYiA+jvdBRjDU2TSwzW/CJrYxo9rRBtqOEnmw5XOsmKtPXLlZgKU1FQRCCasBElIPznlKM6 azOoZ6wzaElEDfFpAnM5WsGwKajOYhOniisbGFWA+zesVjPAI7znQJapPDSEGhuB5hh1p4M754q7 308imf+8wjtjKWduybA7vInfekbdw6hy8O+YFOWoTlSLjQUfoSsWf5NPi9IhOe3Z5eo1K8PUJgmn 6h0/SevO0mjwco3vYcgkCBwOUxQXYxvXaXUtIEnGsuLz3cyKm+K7m2PenRxrteGziam6jZMsZmdG c1AUuSJANrypdCJDNWkMograZUlZQpN+mJKuiFuZwAoT8AMi3APmAOQp6kP4v5A7RfYavUCtoowg T0b6HnDFb7Mh5TrNIYQCEIvqBTO4KX8pkkZ8QjJcxLq5eEJWI+ycLbH0AZi/qRqMGk405IyuGnpB by1hBgIcKrOb+2R4XGpfe9UHDYMDCZsnw13h2LYI4GBaFAzJ3NHhGDDgS4q8LJKwJcqQ8Ep3CKG0 Qw6pOleTNt10BSnBJTowFHZkjhAUKYCMPVFEyALAtIom1B1VGw4DRpSjMzaEDDr+bkxT8Z4djk98 13vGWZuCYGtsj6eIHYew+n6S7mKpJ71/Lmh1WD9xEUR9pXtvi0PeGx49SFBCQEkU9BvTpA6xBS5F QMoaWJQdxGQJCTlw3YnLm8ueDwBP+HcNL4SmSgp4OoKYgpRKFApUHARMl9AC4POBD2aMFjaQ/c/W AYgnDBBTAFBIfuD5ihiqIVpChDT4+ozt74Lv66NRhJlqA79hmS7SCwzCdFlJUSERBXVY5AtTLZIQ GQaK3TCUxySL+vClNn2dEtaCeI5T2AphkjpSwBsBNTH6ff0W6CgTHtM0TiOUWzuwxUxSkbCq3ttT +ktJbjhrUZFhliypyVoh6QWnwTNNTofq7zDpw5ZxSKOZDhU5rTCd8CsC4UG1OP0x124DaAx+L0O/ Ogr6bWSqLpO+RieDAxjvet2ISG7sA425CVewcDK8G9q+z2TWe7WNY9tFDUWZY8E40bZPdFASLnaZ 59bddBgnnuJzODqBgBodaM3LBQZY9u5Plho7+7cUCp+4kD43/pK6lAoEyzMSgNEq+2QyFdy/CBMh HIQIJNW2oDWWANA/XfPwYG4yByB3IamAgQpEOYSgHdXM0UI7lEPzwCfNA8E7kA5k7XSE4rgMAf1S 8QYCQHeEhRKIRz/mogALfnCJfQCTO1j0hLAAZAq2w4mCKJxiDwNl4UpUedUin9zkJBkqKKIqjBPd XBgK4EIRBISXf9JmqlyUzDDAogrHCLFgMwsMIorIxDJH6Y0RACagMJCJR4H6kMQUNSMyJASAHggD 8IUoRPhAg+yBF98o7lEX2xUS8QKgIPCB8/xo8K1ehkGBU/4xERe0zAUUqPQhFfTxLyvihQWevDRN qxiWmK2EBqKRidTmcAuFJ+hsulYDqh25NZvXmlrUUoj0wehIkNzgULD8hIGgvq2Jnx7KMy5gPpDv Cg//AwB1KGgO8OsKFN8ooQuo8JEVJFFotSm8sakibfRSGI8mqIKZKWMhigeU5Fr0VvhCBIMOyAKa PYA7tQdeFvOnkVry9IKDjLqQa3hEiBuG34GOGlwR1xQg2gjwB0gu5wAyRiU7XbRvRFhZhgZYRkIU TU0sQBqycDNWpZpdS6jU5BZO9LokyQGgdasGzKciUKgJSAMLIUcYAwYAMxzTrTjWBqmzMSIVZRlG R9g3hwg2QDcD+xI4/0iXc2HcA7mDoHcdwnR1qiDuXGgygyIPBDuzAUb6el5OngKToCikWBAOYryw P8oHymAvVZwKKSyQfMNVCkkLzzf2VHneMiFRLELFSj7fU9kfkigV9CQyiiIwxXJFClFKESgD0lMG RCmgKQiWmmkJkIhA5Y7Cwdyl1LpFDWlP9idUURkAQw6hmCmiGsf3wSmLWvYxfADhAQoEA7AlheaK OcFIKKhAFNbqBTe9B0xmAxxxRUDZn4WHz+6HY7oEuB6lxqVxwUac+6FBsIfz93p6L6AeA0FANjmg cquu7iRNmnCWCZIgChIZoU+EJtZNl6QGKffsM8jeH6L/V5VnCociQKLET8Hs7fI5cwk8HuwAt0Iz PGcXYzgSJJgwdzg2Xcy2uJuhhszGtfgzHybQpwc/cb6Y60TOKkN5MtnRYNNqEOOZjSGMyaylZWsO ObEBS9gJSKvkA/UjpB0hMXrDQBCNApQFJqCWYm7Xaf7OnoyNZGxRwItZm5UxA2ZG2ZkoqUMogWQU 5ygRM0MvQJjAROh/yEX6WjPOittQFN2li4wYLYuClOENpyfXDa7KCgHoKSClKF4zApHj6MXv78jg 4RNc9QTsThRit5yAso195D6jmHKCqdPF2HaYNM9KuxoJaiiQkJUqrG0XXz0ZORvTYB+H6b0B70CA HnA971oDze7Xofs4hmLgqG2qR7IGwhQsFIh7nCux/wEAuonlYO8dqHjf0CdWDvIbApOmLxLnehTf FXpOEQGiFbEsxgZ7GjENMrFvH49SqZkXxB/0A2P+rZ8g2QfGBwc1aw44EIKbLA8qJnoX5qaXOAv9 qaYIAffEE12VJuaFsPMkDRRR5eUIRvo5tcoA/BD/3l9xKlNYxhmTOPUxX+dQhdRQETRQJ4Kp3rCr /74inUgagkkUUkIppCOCni+Q8xX4XBei+tPXKBQBARQmjT4CP/KKTOHw4Ip4AxCRADpAQ4oQosD7 jx5IicnAJdsq8YLqYv/sQC/ueQpNhQUUAQCEAz94FP6Am99nxWrWU+uikeeNoh+40+PcNl7gMXwj f68TfyyfBhDS3VMK+NEB8iaIPTScC6MfcB+X8LTVKpQ/V/Yc3CbrbbsjCP8tVD1Zr3uDeN6R53AC lD6WKJItxDhAIidZpRClWmvNhojaJmZLOGYEJiRkIYQMMGAoIUv7c4cMdIwuiP+sBDQkPNm0v8Iq sYYR+I5Q8aDeQdkkosVH9dokD8iYuwPhET9qVUTEzf/bMghSCCKi/olyZgkimH6/2l/NvQ6z67Ru Xejej121CI7YieeDYi6vXQGsXyH3Vr0X1rs7OgKqH/fwMCPnUkgUUE9BSFm0LGvTrSz4bZJAQ3+s VrZQjsKxpxhCghxYmkzAIgxqom1Y4Q6Q1FAVJLaw1GgPzWLSUkSKvcIniJ6sRQT+UHlibBRov2o7 Ae850ab44hbQVc3+YRIQQkc0VA6riVyPIf6xfYJhh8aaf3nse41GUm/CCQIV8qo0fzRm6YmBT3GI GMCeASKShPVGqiuXe8pMSIFYkY8aJLiJMzPYX0S5BiNVaBIX4QCwnFiJf4mhMzinpA50OAsRg8Rv ms3gAoVcB4uab1HlBXeCghzW48JBBgwRNBxoHOHBYDMiq92ekJEGQ2SSoUWoPyDMDZCQiQPX7fVa 5/YpDQIQZ6h2W0JqAmDqwgEEkEBBCMEMyNAwYdbDbhuRDRU52fceALnhBTmZWCGfiM1DaZxjCiKC DWGitVlGBjq15WbBGKIqSFJBtuLqHwaIyiWDNwIIp5+XtI5081PExKPRHAAwgUlAJ6n/5+Plk948 Q8y9zDhCnTcxDD5B4ArpIEAgc8fzLNRgQyeNG9C5SbdSNv5CkyxDc8DiZKNgQuOHrHG9zHt+TbhG 7NlfTdte+CMiVVpx2ONnGTgN4LzgmRAMqEnFFBwHvMfE2ibpN18nqmlVCQd67QM0pUADaJkAXPcx NyosgST2FGYsXptSpU81qJYtL2C7C5eymN/tQ0LxfkX4gPQp+QfgpH9af3ez7bxLmQQ8IWhigmgo e8ilSVexAlKkE02yT0C/GJ0ied2u8BwgpoNQhAirFTl1CHoOdD0r8aRyFwDaEETo9+gE2ktN5da+ DDh3wkIoaBB6AAgAZAJ7SICchnm7wpAu8LALO8qEKQE7CImsik/P2EqrNonQBH8SRB+LOCHsXfIa kQ+PwkiKggSImSDOhcmZx2s9N75AHYf4d15LsPXUk/xeeYo8oi8iG0nBaoAhDN+tfUB2uAdoHHRL GaD4fqAI1/RVeSh+adwXA4J2SfqtFFDIUkXwkckNg4YiH8XOpXUQ97Kqg6yAwlmQhaFzoP8YXbg6 wahqMq3imSCdS+U8oh4UTZE8ZqKbFovQrcv9bxYRx8tjQVMq+0mM9UWyZGCjxx/sF6gzRKSg9aTX f/ns77eGN4a+WNC1BV1wfLO38Qn5gP1HxAP1aD9TvE0TUucI3IEID1FNKzAfz+iyHADAqxiBzNc9 F4+yBPfeE+57Ez2Kj/dAdw+H2ULijYtq85FiSIebP7lS7VrVKwtU8qHiA0KCHCERQ9CxK0Y5K7Bw 9rzm1sCo8JAXw9OBm0Mjvq8G/7Fw9kPvYcYmoeQAJuxecRdBQiWIiCYAexE2erLgHCSM20FVRXZL BNr94FuMTcIKd8FCJEFPWB5OKj5wNEk0iFIvIobR4w99B9zjv1Hs8km5KJ30WjpuUR+Uo67Ez3O/ mmHMKBQPIY1twGmhn8MTFuC0kdPsfhOiCRQjhpI7YpAy8sKNHJq1jGdqLp4c1KcmC4CtM6sGMuJz 1HFuhGo4KEBxHLnEWzRgFKESg2abrRjE+qAHGJ6NZPGGm1BdMNJIfurhoJyz7iSpjcOBwgJ++Igd x771JID5BIqr8SSIOzWN3nfmzhvY1JHxZJEjhMEs2H10TMli5TMXTiayB9zFUU+MwOy2nxEcXjq0 mA4DzetJEYcCYbafThIKPGGFwYUxj6tYaCR5aGPd0FH4xyXpB5w8BKhjDXd4HYp7w6jxd8Y9SDtr AaKgoJEoSKg1mG8yIqukYqQ1k5sOmkFUOonRTsexDzgV/IVd+zZqbKKFAICkTiXCkReQFkBoFoYC kALsEDdE99T2Y5vJ0YvaKFQJEYH+sQKSAeBZSHTb1lhP9vPcP5FjNYUM0Uag6FNpqA3APsijycxx TnalUHiRMydIm1CHuAgnUkEHIFPGBcFLJrFUzeRp5foE7lNIov2hFdY4L2QpA+oCf9bAQRED6AEj wAY7/CofIpY8uwT0+I7zUbBBC0F4Y1e8okqFVKrH5Qsaqwy+RH3L8oBt3ibD6Pw+fZsWCRGJuCdD p0gYLQhrxkpFUN71gelHtR5+HtTrEsJ+YDqUuveOkDtTlBTlB5OVv8zoIwCZ8QDJBBwOnmiF4GBv sANQP07rmUYBfsoaoAr9Ln8kv9RbSIYKjjB4kRoEiDShVVQVBl98agbHWgItquiMZMSx1Av7QDFE FTFZ/br/PQcSFhhR/EQdDX2iJ4bwEE7X/qrKgnhKCaNn7f7TCFGikaZmEPPuwEaRRMtBICnVepmo IhYjn7NaDjHKmSRmVZA6SDjKsgCRAIyLCTuooX25Kwzf5h2hl8+IiR9tyg/oDupyiET7S0G91AGT /0UGE/vRKZORB7nrVx+eOH7S+/sMec44/W+v8IZgCeqIiSCPdyWsCc8A6Wkr9Ng/TEtICAWCDURI VpKZ3n3b+05f15Reymg2HLnB1WY48ZFjEKhyfSblnxqBFA/ggFiKYx+QM9sEtoPlIQA7MFPEyqex 9j/EOwJQvC/7M4/WIJ/eKCJNUAgbybaJGg0GINa/fJJwDwU4HGeABy8eDbg2jSEijBgHqfvtrAPj Xp4ngQ4G2ROkvzzRRSPzSl5ezuDkE+dMCdU6D0uqaInlV31xjjxtvaiZXM8wMDz4tHGjyfdpVudT //i7kinChINVwbrQ