Return-Path: Delivered-To: apmail-jakarta-tomcat-dev-archive@apache.org Received: (qmail 20491 invoked from network); 4 May 2003 19:46:40 -0000 Received: from exchange.sun.com (192.18.33.10) by daedalus.apache.org with SMTP; 4 May 2003 19:46:40 -0000 Received: (qmail 12075 invoked by uid 97); 4 May 2003 19:48:46 -0000 Delivered-To: qmlist-jakarta-archive-tomcat-dev@nagoya.betaversion.org Received: (qmail 12067 invoked from network); 4 May 2003 19:48:45 -0000 Received: from daedalus.apache.org (HELO apache.org) (208.185.179.12) by nagoya.betaversion.org with SMTP; 4 May 2003 19:48:45 -0000 Received: (qmail 19662 invoked by uid 500); 4 May 2003 19:46:27 -0000 Mailing-List: contact tomcat-dev-help@jakarta.apache.org; run by ezmlm Precedence: bulk List-Unsubscribe: List-Subscribe: List-Help: List-Post: List-Id: "Tomcat Developers List" Reply-To: "Tomcat Developers List" Delivered-To: mailing list tomcat-dev@jakarta.apache.org Received: (qmail 19647 invoked from network); 4 May 2003 19:46:25 -0000 Received: from adsl-66-127-87-82.dsl.sntc01.pacbell.net (HELO mail.wanconcepts.com) (66.127.87.82) by daedalus.apache.org with SMTP; 4 May 2003 19:46:25 -0000 Received: from BESCLIENT.wanconcepts.com [66.127.87.83] by mail.wanconcepts.com with ESMTP (SMTPD32-7.10) id ACA012D00A4; Sun, 04 May 2003 12:40:16 -0700 Message-Id: <5.1.0.14.2.20030504124423.00bb8c60@mail.wanconcepts.com> X-Sender: bstansberry@mail.wanconcepts.com X-Mailer: QUALCOMM Windows Eudora Version 5.1 Date: Sun, 04 May 2003 12:46:23 -0700 To: tomcat-dev@jakarta.apache.org From: Brian Stansberry Subject: [proposal] Reauthentication support in SingleSignOn Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="=====================_9094196==_" X-Spam-Rating: daedalus.apache.org 1.6.2 0/1000/N X-Spam-Rating: daedalus.apache.org 1.6.2 0/1000/N --=====================_9094196==_ Content-Type: text/plain; charset="us-ascii"; format=flowed Hi all, I would like to propose that Tomcat's SingleSignOn add support for reauthenticating user credentials to the Realm each time a request is made. The various Authenticator implementations support this behavior if their "cache" property is set to false, but if a SingleSignOn valve is added to the Host configuration, this behavior is disabled. This causes problems with security implementations (e.g. JBoss' JaasSecurityManager) that expect the user to be reauthenticated to each thread (see http://www.jboss.org/thread.jsp?forum=49&thread=8141). If you think this is a worthwhile suggestion, I've taken a crack at implementing this. Following is a diff to the latest cvs version of the various affected classes; also attached is a zip with the complete source. Affected classes are SingleSignOn as well as AuthenticatorBase and its subclasses. Also, while looking at this I noticed that both BasicAuthenticator and DigestAuthenticator were never calling associate() to associate their session with any SingleSignOn. This seemed odd, so the attached code deals with this as well. There is one behavior quirk with the attached implementation if it is run in "reauthentication" mode. If the original authentication method was BASIC or FORM, the SingleSignOn object uses the username and password stored in the SingleSignOnEntry to reauthenticate each subsequent request. No problem there. If the original authentication was DIGEST or CERT, it cannot do this, and counts on a subsequent DigestAuthenticator or SSLAuthenticator to reauthenticate. These authenticators can do this w/o requiring user interaction, so no problem there. However, if the new request is for a context that uses FORM or BASIC authentication, the context's Basic/FormAuthenticator will not see a Principal attached to the request and will have to prompt for a login. Therefore in that situation the user may experience a second login prompt (one for an original DIGEST authentication, another for the subsequent FORM or BASIC). Thereafter the SingleSignOn has the data it needs and the problem will not re-arise. This quirk can be avoided by not mixing DIGEST webapps with BASIC/FORM webapps. If the powers that be think this suggestion has any merit, I'd be more than happy to make any further changes you feel necessary. Best, Brian Index: ./catalina/src/share/org/apache/catalina/authenticator/AuthenticatorBase.java =================================================================== RCS file: /home/cvspublic/jakarta-tomcat-catalina/catalina/src/share/org/apache/catalina/authenticator/AuthenticatorBase.java,v retrieving revision 1.6 diff -r1.6 AuthenticatorBase.java 791a792 > Session session = getSession(request, false); 793,794c794 < if (cache) { < Session session = getSession(request, false); --- > if (cache) { 809,825c809,840 < // Construct a cookie to be returned to the client < if (sso == null) < return; < HttpServletRequest hreq = < (HttpServletRequest) request.getRequest(); < HttpServletResponse hres = < (HttpServletResponse) response.getResponse(); < String value = generateSessionId(); < Cookie cookie = new Cookie(Constants.SINGLE_SIGN_ON_COOKIE, value); < cookie.setMaxAge(-1); < cookie.setPath("/"); < hres.addCookie(cookie); < < // Register this principal with our SSO valve < sso.register(value, principal, authType, username, password); < request.setNote(Constants.REQ_SSOID_NOTE, value); < --- > // Notify any SingleSignOn valve of this event > if (sso != null) { > // Only create a new SSO entry if the SSO did not already > // set a flag accepting the request (as it would do with > // subsequent requests to DIGEST and CERT authenticated contexts) > String ssoId = > (String) request.getNote(Constants.REQ_SSOID_NOTE); > if (ssoId == null) { > // Construct a cookie to be returned to the client > HttpServletRequest hreq = > (HttpServletRequest) request.getRequest(); > HttpServletResponse hres = > (HttpServletResponse) response.getResponse(); > String value = generateSessionId(); > Cookie cookie = > new Cookie(Constants.SINGLE_SIGN_ON_COOKIE, value); > cookie.setMaxAge(-1); > cookie.setPath("/"); > hres.addCookie(cookie); > > // Register this principal with our SSO valve > sso.register(value, principal, authType, username, password); > request.setNote(Constants.REQ_SSOID_NOTE, value); > } > else { > // SingleSignOn entry already exists; associate this > // request's session with it > if (session == null) > session = getSession(request, true); > sso.associate(ssoId, session); > } > } 948a964 > Index: ./catalina/src/share/org/apache/catalina/authenticator/BasicAuthenticator.java =================================================================== RCS file: /home/cvspublic/jakarta-tomcat-catalina/catalina/src/share/org/apache/catalina/authenticator/BasicAuthenticator.java,v retrieving revision 1.2 diff -r1.2 BasicAuthenticator.java 145a146,148 > HttpServletRequest hreq = > (HttpServletRequest) request.getRequest(); > 147,148c150,151 < Principal principal = < ((HttpServletRequest) request.getRequest()).getUserPrincipal(); --- > Principal principal = hreq.getUserPrincipal(); > String ssoId = (String) request.getNote(Constants.REQ_SSOID_NOTE); 150,151c153,158 < if (log.isDebugEnabled()) < log.debug("Already authenticated '" + principal.getName() + "'"); --- > if (log.isDebugEnabled()) { > log.debug("Already authenticated '" > + principal.getName() + "'"); > } > if (ssoId != null) > associate(ssoId, getSession(request, true)); 153a161,171 > else if (ssoId != null) > { > // An ssoId with no UserPrincipal means the SSO is based on > // DIGEST or SSL certification. SingleSignOn can't reauthenticate > // for us with no username and password; have to get it from user > if (log.isDebugEnabled()) > log.debug("SSO Id set, but no UserPrincipal"); > // Remove the SSO Id note so any register() call > // will generate a new SSO entry > request.removeNote(Constants.REQ_SSOID_NOTE); > } 156,159d173 < HttpServletRequest hreq = < (HttpServletRequest) request.getRequest(); < HttpServletResponse hres = < (HttpServletResponse) response.getResponse(); 175a190,191 > HttpServletResponse hres = > (HttpServletResponse) response.getResponse(); 243a260 > Index: ./catalina/src/share/org/apache/catalina/authenticator/DigestAuthenticator.java =================================================================== RCS file: /home/cvspublic/jakarta-tomcat-catalina/catalina/src/share/org/apache/catalina/authenticator/DigestAuthenticator.java,v retrieving revision 1.1.1.1 diff -r1.1.1.1 DigestAuthenticator.java 81a82,83 > import org.apache.commons.logging.Log; > import org.apache.commons.logging.LogFactory; 95a98 > private static Log log = LogFactory.getLog(DigestAuthenticator.class); 217a221,223 > HttpServletRequest hreq = > (HttpServletRequest) request.getRequest(); > 219,221c225,236 < Principal principal = < ((HttpServletRequest) request.getRequest()).getUserPrincipal(); < if (principal != null) --- > Principal principal = hreq.getUserPrincipal(); > if (principal != null) { > if (log.isDebugEnabled()) { > log.debug("Already authenticated '" > + principal.getName() + "'"); > } > // Did a SingleSignOn valve authenticate? (who else??) > // If so, associate this session with the single sign-on > String ssoId = > (String) request.getNote(Constants.REQ_SSOID_NOTE); > if (ssoId != null) > associate(ssoId, getSession(request, true)); 222a238 > } 225,228d240 < HttpServletRequest hreq = < (HttpServletRequest) request.getRequest(); < HttpServletResponse hres = < (HttpServletResponse) response.getResponse(); 246a259,260 > HttpServletResponse hres = > (HttpServletResponse) response.getResponse(); 464a479 > Index: ./catalina/src/share/org/apache/catalina/authenticator/FormAuthenticator.java =================================================================== RCS file: /home/cvspublic/jakarta-tomcat-catalina/catalina/src/share/org/apache/catalina/authenticator/FormAuthenticator.java,v retrieving revision 1.2 diff -r1.2 FormAuthenticator.java 154a155 > String ssoId = (String) request.getNote(Constants.REQ_SSOID_NOTE); 156,159c157,158 < if (log.isDebugEnabled()) < log.debug("Already authenticated '" + < principal.getName() + "'"); < String ssoId = (String) request.getNote(Constants.REQ_SSOID_NOTE); --- > if (debug >= 1) > log("Already authenticated '" + principal.getName() + "'"); 163a163,173 > else if (ssoId != null) > { > // An ssoId with no UserPrincipal means the SSO is based on > // DIGEST or SSL certification. SingleSignOn can't reauthenticate > // for us with no username and password; have to get it from user > if (debug >= 1) > log("SSO Id set, but no UserPrincipal"); > // Remove the SSO Id note so any register() call > // will generate a new SSO entry > request.removeNote(Constants.REQ_SSOID_NOTE); > } 196c206,207 < log.debug("Restore request from session '" + session.getId() + "'"); --- > log.debug("Restore request from session '" > + session.getId() + "'"); 202d212 < String ssoId = (String) request.getNote(Constants.REQ_SSOID_NOTE); 465a476 > Index: ./catalina/src/share/org/apache/catalina/authenticator/NonLoginAuthenticator.java =================================================================== RCS file: /home/cvspublic/jakarta-tomcat-catalina/catalina/src/share/org/apache/catalina/authenticator/NonLoginAuthenticator.java,v retrieving revision 1.1.1.1 diff -r1.1.1.1 NonLoginAuthenticator.java 135a136,142 > // If there is a single sign-on session in effect, > // associate this request's session with it so any > // logout will affect it too > /*String ssoId = (String) request.getNote(Constants.REQ_SSOID_NOTE); > if (ssoId != null) > associate(ssoId, getSession(request, true));*/ > 140d146 < 144a151 > Index: ./catalina/src/share/org/apache/catalina/authenticator/SSLAuthenticator.java =================================================================== RCS file: /home/cvspublic/jakarta-tomcat-catalina/catalina/src/share/org/apache/catalina/authenticator/SSLAuthenticator.java,v retrieving revision 1.6 diff -r1.6 SSLAuthenticator.java 136a137,142 > // References to objects we will need later > HttpServletRequest hreq = > (HttpServletRequest) request.getRequest(); > HttpServletResponse hres = > (HttpServletResponse) response.getResponse(); > 138,139c144 < Principal principal = < ((HttpServletRequest) request.getRequest()).getUserPrincipal(); --- > Principal principal = hreq.getUserPrincipal(); 143c148,156 < return (true); --- > String ssoId = (String) request.getNote(Constants.REQ_SSOID_NOTE); > if (ssoId != null) > associate(ssoId, getSession(request, true)); > // only return here if we are configured to "cache principals". > // An SSO authentication based on BASIC or FORM is weaker > // than this authenticator, so it should not override it > // unless this authenticator has been so configured > if (getCache()) > return (true); 147,148d159 < HttpServletResponse hres = < (HttpServletResponse) response.getResponse(); 152c163 < if ("POST".equalsIgnoreCase(((HttpServletRequest) request.getRequest()).getMethod())) { --- > if ("POST".equalsIgnoreCase(hreq.getMethod())) { 154c165,166 < // removing data from socket so that a cert exchange can happen if needed. --- > // removing data from socket so that a cert exchange can happen > // if needed. 156c168 < ((HttpServletRequest) request.getRequest()).getParameterMap(); --- > hreq.getParameterMap(); 160c172 < request.getRequest().getAttribute(Globals.CERTIFICATES_ATTR); --- > hreq.getAttribute(Globals.CERTIFICATES_ATTR); 163c175 < request.getRequest().getAttribute(Globals.SSL_CERTIFICATE_ATTR); --- > hreq.getAttribute(Globals.SSL_CERTIFICATE_ATTR); 222a235 > Index: ./catalina/src/share/org/apache/catalina/authenticator/SingleSignOn.java =================================================================== RCS file: /home/cvspublic/jakarta-tomcat-catalina/catalina/src/share/org/apache/catalina/authenticator/SingleSignOn.java,v retrieving revision 1.4 diff -r1.4 SingleSignOn.java 82a83 > import org.apache.catalina.Realm; 167a169,173 > /** > * Should we cache authenticated Principals or reauthenticate > * credentials with every request? > */ > protected boolean cachePrincipals = true; 168a175 > 172a180,214 > * Gets whether this valve should, following a successful authentication, > * associate a cached Principal object with each subsequent > * request that is associated with the single sign on session. > * > * @return true if a cached Principal should > * be used without reauthenticating each request to the > * containing host's Realm; false if > * each request should be reauthenticated using cached (in the > * case of BASIC and FORM authentication) or browser-resubmitted > * (in the case of CERT and DIGEST authentication) credentials. > */ > public final boolean getCachePrincipals() > { > return (this.cachePrincipals); > } > > /** > * Sets whether this valve should, following a successful authentication, > * associate a cached Principal object with each subsequent > * request that is associated with the single sign on session. > * > * @param cache true if a cached Principal should > * be used without reauthenticating each request to the > * containing host's Realm; false if > * each request should be reauthenticated using cached (in the > * case of BASIC and FORM authentication) or > * browser-resubmitted (in the case of CERT and DIGEST > * authentication) credentials. > */ > public final void setCachePrincipals(boolean cache) > { > this.cachePrincipals = cache; > } > > /** 387a430 > String ssoId = cookie.getValue(); 389,390c432,435 < log(" Checking for cached principal for " + cookie.getValue()); < SingleSignOnEntry entry = lookup(cookie.getValue()); --- > log(" Checking for cached principal for " + ssoId); > SingleSignOnEntry entry = lookup(ssoId); > boolean validEntry = false; > boolean setRequestAuth = false; 392,401c437,490 < if (debug >= 1) < log(" Found cached principal '" + < entry.principal.getName() + "' with auth type '" + < entry.authType + "'"); < request.setNote(Constants.REQ_SSOID_NOTE, cookie.getValue()); < ((HttpRequest) request).setAuthType(entry.authType); < ((HttpRequest) request).setUserPrincipal(entry.principal); < } else { < if (debug >= 1) < log(" No cached principal found, erasing SSO cookie"); --- > if (!getCachePrincipals()) { > if (entry.canReauthenticate) { > if (reauthenticate(entry.username, entry.password)) { > if (debug >= 1) { > log(" Reauthenticated cached principal '" > + entry.principal.getName() > + "' with auth type '" > + entry.authType + "'"); > } > validEntry = true; > setRequestAuth = true; > } > else > { > // What to do here? FormAuthenticator does not > // invalidate any sessions; it just proceeds > // to the logon process. This seems suspect, but to > // be consistent, we'll do the same > if (debug >= 1) > log("Reauthentication failed, proceed normally"); > } > } > else { > // auth type was NONE, DIGEST or CERT > // This class can't reauthenticate these types, > // so we don't want to setUserPrincipal > > // We want to set a request note w/ the ssoId so > // any call to AuthenticatorBase.register() following > // reauthentication by SSLAuthenticator or > // DigestAuthenticator will not generate a new SSO entry` > validEntry = true; > } > } > else { > // we are caching principals > validEntry = true; > setRequestAuth = true; > } > } > > if (validEntry) { > request.setNote(Constants.REQ_SSOID_NOTE, ssoId); > if (setRequestAuth) { > ((HttpRequest) request).setAuthType(entry.authType); > ((HttpRequest) request).setUserPrincipal(entry.principal); > } > } > else > { > if (debug >= 1) { > log(" No currently valid cached principal found, " > + "erasing SSO cookie"); > } 550c639,660 < --- > /** > * Attempts reauthentication to the Realm using > * the passed username and password. > */ > private boolean reauthenticate(String username, String password) { > > boolean result = false; > > Principal reauthPrincipal = null; > Container parent = getContainer(); > if (parent != null) { > Realm realm = parent.getRealm(); > if (realm != null && username != null) > reauthPrincipal = realm.authenticate(username, password); > } > > result = (reauthPrincipal != null); > > return result; > } > > 624a735,736 > public boolean canReauthenticate = false; > 631a744,746 > this.canReauthenticate = > (Constants.BASIC_METHOD.equals(authType) > || Constants.FORM_METHOD.equals(authType)); 660a776 > Index: ./catalina/src/share/org/apache/catalina/authenticator/mbeans-descriptors.xml =================================================================== RCS file: /home/cvspublic/jakarta-tomcat-catalina/catalina/src/share/org/apache/catalina/authenticator/mbeans-descriptors.xml,v retrieving revision 1.1 diff -r1.1 mbeans-descriptors.xml 128a129,132 > description="Should we cache authenticated Principals if the request is part of an HTTP session?" > type="boolean"/> > 164a169 > --=====================_9094196==_ Content-Type: application/zip; name="ReauthenticatingSingleSignOn.zip"; x-mac-type="705A4950"; x-mac-creator="705A4950" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="ReauthenticatingSingleSignOn.zip" UEsDBAoAAAAAACyPoy4AAAAAAAAAAAAAAAAEAAAAb3JnL1BLAwQKAAAAAAA0j6MuAAAAAAAAAAAA AAAACwAAAG9yZy9hcGFjaGUvUEsDBAoAAAAAADmPoy4AAAAAAAAAAAAAAAAUAAAAb3JnL2FwYWNo ZS9jYXRhbGluYS9QSwMECgAAAAAANbWjLgAAAAAAAAAAAAAAACIAAABvcmcvYXBhY2hlL2NhdGFs aW5hL2F1dGhlbnRpY2F0b3IvUEsDBBQAAAAIAHGvoy70eL0CaR8AAEl7AAA4AAAAb3JnL2FwYWNo ZS9jYXRhbGluYS9hdXRoZW50aWNhdG9yL0F1dGhlbnRpY2F0b3JCYXNlLmphdmHUXHtz20aS/9+f YqLaS8iEomRns7WxLSc0RVnckkQdSdmXSuW8IDAkEYMAFwAlM7f57vfrnhlg8CKp2Lt1h7JFEJjp 6df0Y6aHJ18/EV+LP11Kx5Pxc3GyjFbyxL1P1ptZ4LsnvzofnDh1jtNo5TrpMf47gR86J9lNErsn ydKJ5UkUL06cteMuZf7W2aRLGaY+HkTxSc/+9tpJZPdX597p3Iun3b+IZ6en357g39Nn4vS75999 //zbU+FGSeqHYvBxLf7EaI7lvZ/4Uficu6hn504qn9d2p/fU5OwzXBrUdClFj4kUk2iePoBwceW7 MkxkR7yVMSEH3J7q5v1ovY39xTIVLbctnn7//ffHQPRpLZiLaBN6TgoAXSF6QSC4Y0JgYpnI+F56 XQ12LD0/SWN/tqHmwgk9sUmkAKuSaBO7kp/MIIB4K+ZRvEo64sFPlyKK+TPapARlFXn+nIQBGB1B KKxlvPLTVHpiHUf3voebdOmk+CMBJwiiBz9cQCqh51Mnxo36rWT6XKP2tFvCLhHR3KDlRh4ab5IU FKUO0CXAziy6p1eaUwQEVxhBT8DTdOknIgA8ApOPzBQW0cKgbuD4KxkbNj2r4oIxLb4YXECttwF+ /xp0MKiGQi28yN2sMAscIzpMHBHhTSxW0OTYd4IkZz+LDS81AJsYQ+W3XVYnGXrHUIK4NIAfusHG hgRybSgd4c81cCfcdhRHdKcSRY77IYweArmQBP657oXraEpcUUzMOicQutZsT97LIFoDidnWIoau 5kkgWss0XT8/OXl4eOgqu9IlE9PuHun+vQDsCsGzYKsFU8QQ/NwKZ72WDomAiclQ8tNEBvOOhuTP WYAPEAJQjUWycYlXfuwdr2H+tiXACdQhXjlBYMAbUfxZiSJ0ViD/iG7/puynuI2jX6WbHnXwmE0p 7mjIoxIDNEI5G46URKB/YiZplkPPIhJ2FGPGQ3XA9lWUSsP+BNyOfdgKDWmO14o5Ge3aBKCHTwYh phkfqrmfJGx+LvLnGkz+tiPWgYTtJu1PHchbyebHXESGG991iewCUnXokJQ0eS54KjOmGDmD2dzI PC7K1I81v2vJqqBP8zbNre+bONqsDcLTy+FETEYX03e98UDg/nY8ejs8H5yLv/+9N8GDr74SvZtz /P9JDP7rdjyYTPBuNBbD69ur4eCcYKDruHczHQ4mHTG86V/dnQ9v3nTE67upuBlNxdXwejhFp+mo g+EGpqfVjYCMLsT1YNy/xJPe6+HVcPoTj3sxnN5gTHGBIXvitjeeDvt3V72xuL0b344mAwG0qfv5 cNK/6g2vB+fwJMMbDCwGbwc3UzG57F1d8bi9214fHxmxF6O7m/PedDi6AT0EYzidiP7oZjoeAvXR eCJeD4B87/XVQA0PFpwPx4P+lMjM7/pgF5C+4pk1uR30h7gHswagszf+qUPcAtjJ4D/v0A4vxXnv uvdmMBGtKrcIhs0wiKN/Nx5cEylg0eTu9WQ6nN5NB+LNaHQ+IdiTwfjtsD+YvBBXI3BqdEEw7iaD DsaZ9nh4QAEj0QL3r+8mQ2bp8GY6GI/vbokDbXE5egeGAdPeHUkYvGep3DDZYN9o/BMhQPxg6XTE u8sBno+J28y1HrFjAu71p1YzhjIGLeOpRa+4Gby5Gr4Z3PQH9HZEgN4NJ4M25DmcUIOhGvldD8Pe TbWGkBiBnrq1FLfDwhbDC9E7fztkDVWNoSKToVYnxZjJXf9SC4DmwOcNlOw5DluRwOlwLHAfBRtY DrhgsiC5a14hAiUHsYIfIgg+nCuc4Ib8IebtTC6dYF6avvXBE5mvVaSMqR+So1ceJQr39M1sWyK5 88t6F/TKGIyfe54KAJxARwgJ+VO42H9s/Fj5O2WOAo4Ri9HTLwrKyZMnTwD7g7Mge74wA5kYuluI oV+gsb9aR3EqKHbu+lF3OBp8dOWaQL4ovAuccNGN5TyA4+leS1hHr9gglHgOpoJB0rsbXzXAoWZ4 W3yYSHcDE7sF4CQB6uf+QiZpQ5ubaAKP2gsWEb4uVw3jZM1vY8QQ/toJiu+hJ0F3DK8ZrQovPnYp Og6A5UR91sPPm5FUu/0o+uDLXS0u8UdDHEOgZfJ2tU7WkO8BwNklZc3qpN8rSn9Hyz75Yz+U+1vJ j+nONoRbmeLmdiVa6xpe+XPpbt3gwFaDe1B8YNOKqHc2v4IRkvtYdBUtFnuaXDuhs6/Nrb+WuNlN 81g6wWpPi/2COEgIh2jbWye43w2FWxyiRJ5cB9GWmOmHaD/3F4c0n2gbgB7IUaDOuwdhk5BJd7JZ U8v9PTRP73C/v/EEPipcHCLxe+JNolhEyxu1jaPVCrR1AygZwBJ/Dmx2gWA7irfkAU6+ZveDMXxX oHMg84RPO8iXs1eMx8uT2Ss4QWRKc4czXKTzknwifJXJxV5SXv7qyyB9YUzwsZvx/8tF+uLlCbcQ MtD5j06nHuSMgvFALyIQLCVHTr+QA7qxvwbS8MkcD8w3oavcJcYQeJDhDl/pIH8TjDPBSSKFq58i KyDvL8ARtTaBwWV478dRqJDhdl7ESYT2vIRdwnDm0kk3MaSCSDgLKEo847BEgu9I/FiDCJvc7mrK VuxBGZtkM0NunyQqk5lxNsTfQYPx/RxQvVy/4o/Zq7sJgiwOfREcItokuTwX4h0GUVAUANyQ0vm/ Sa/DLNZTDUkfAXpY+sASPKFkN01JVTzRQnzhCCSqxPTMCxCbHLH0ZezE7nLbVnnk0rmn1SGCheEi 13eIWLZCio+a2ZxozgmwxQdEL7TCoFY7ZLhZATY9JWi8shAFpFSRRhOPtmrAmQSVGM9fhIcyhvWF tYFojULk2hh7vgkoSw8p23XJngGly+n0lmDFalKTpPX8ZrkimtTLK+l2TclvEIiE5L8lOtfAile5 kAculiau+5GoBvF9zICFGHfFtdtHNOUsFed+vNcLfeX1yH2LkRzq8cKqcGY0v5A+K7lXlkafUNoK wSPT13zInmbKW+rWEZklFP/DLRF73gMhkZCeuwJGRMCgiDORm5PuQqb41qquzTJibTI3BOrkRBz/ kQuzDqOHMD1vndh3ZtAQA5GMGF1qVdWTc2cTpJhmHE8KjwNK4ZigkfSKFznnMDukpjTdN5olRgGV 3CHQKJRd/eZEsyJKEQfjlWbG3KeoXRl3cT646N1dTd/3rt6MxsPp5TV4dHR9/t3Ri3pkofszaBTU K+Z4FIF+qlTfLJ2xli4o1lATxzHdE+WGhe8Ru+c+L1fuRxSWGMktErjRzfvh+fvXP02RM5+Jp39p wHAXG838LuOoUTNgcgwTY8DZhszIglgQc6NplvdUf+VWdmQLxq2oKQCebKNNjBTMSSklaWKLFlk+ /llVfDVMmSyjTeAp3aH0zzJsAJqlHAkpmKVLZH1oDRCyNpBAPNkcw64fGvCcRTCHaKuGOxNpvJEN wsqNfGY6betnLH0TR0x3V3+eQT+DoGEsT842HFPgDp4iEAGtzrKtV34oQjASgjNNo/ns2gEE45zW DDKWcLgqPihIuxyolBTRdHdjWdDGgho2oFQcR6t8Ixd6RoX8EIk4YpHfFEIQswMnj3ltllmhEzGv B6S8wJ7G0XprKQI9LcGARSAd1lZBmwk9xaLGma7xMSM0Yn6uIyqf9MJa2HBmtPDJ4isy+TE2kACK M9UB19HetYhuxWecPO2eksksoX0ROAtip0fMXSE40Ubc8xNyCITXxy3PE+DRoUVtTJx7xXU/STaZ RdmsCYyOPBF4ZjsLjZw1k1APdUsj9dVA+ZQsoUuzJMg8qaRk1Ni4R0yTclZigYR85UOlQYvgtmv1 tUGdjEtssOOHzBy1nGIG2Gk4/gZDrk01LbibRKMJNx0gZ5PcgPoEZLWiqhH7DB9uuuhgOIGUiqwm 750oOCuV0uUy1atwj5g0OisUycqaOYVXFF/p2xYntQ7itu6tGqlO2oTgBP2hFwiXR2HZbCKsZwuj 3ZMVCLtLBP4dA0e5sViHz41EFYZCRtCsA5dOUlJ9FdeDJHL++9ygbgb4c3jZ3BP+wbjSXLTFhPmf +nVxpeWKGuOhTPpGYEU6VLSuNQ+yzBYxW20E2ZnMYzUSz+FuBrytjcvvNeGITP8YXgbAj+yurA4c l8KuNEGso+s+8qHXNlXl6KpAZZE6iDK7bybUksGewGsON1HLfaNCYD/ZbrmD9TzEAWx/BColhque htnqGzXfxV6FdSEgrPLVxIn8eRA/81z/cYGjQi7vTXw1X3bxVoWXB3D30YiVeZz1Jz67VWgIHmjn xoDZyfuMshyrDGKBWFjM1hetfDRfZ65wdDrCbrezxnTRqsEDq8EwCOTCCXrxgksvslXpQnO6WsmK PIKaZa2jYjyFjFYPdNQ2XKYLwQfmf4GWnIIXJS3KcoCWQTon9yCt+qMJgmI7ZQcg8JyA7NAlHuQA TXo0MiVNUomKma310HZpj6IjS3mqs9ZkQvx5EH9NlG+Si1jcO8FGctxL5GxSKDbGXvnHesWL3xtI 7NdBuTbUSyfhhc+tNO5Y1gsmd2EDhUBROvDDfSdwN4FTP3w2rhnQDFaYPsySLI1RoURxziT5+Nw4 jfRcKGh8QVc0vAO0pYG1DbphWhvtaOi9Sz0MKcUErqoleWan7/Zqirc/1dPWdFfCVxb9EJB2zEoa aAebLSXeHfVTfrAHk3EexO9AyAr1DxD/4UiVNMHOKIw27Ae2SzFs8qppS1VBijmN9S2nukS0JYw5 59e0ek8pikx0eu14nlhyXS/nYSbb1nm2mG0NKMq/ET/vi73Oqzk0i84QoiVXk2q/aKDBCE5ZGJ1Q PooaAyknqkyNkXEYqQBLrUpS5m+WH3dyS61NGFiFK1uwUCA5rSnCzJcxDGQnqOZiJY9Tw2UjBE2D zfT6hQ3dsMj3T8i0xK1CUlWR1GRaA7WlyLSaXJzKlqH6rtpiq98ytPYLDah829Csplk7VTqmaZrH OinW+z969UGnyPkSRNZa7ZoLs32+p70JraZKY+9l9iRfL7yPPigmhPT8Xu1mKiiGA2AO79RZmfta lwqUqZImjhRWkY+qVgU0RAoncAb4EDKOiV0uYCc1vct1McqZI3gNacI4Nip6i7dRQxWJLcNhzfFO zkPD1U6moqXLriAwHMxjBEYrsentVNEvxi1DHZn4KjAxy/MZamprmGZG1kuF+tkSfx7oW6UvbfHP fxZooA6ayEoP9bxtz0y6NHldxbUb3LYytAwwK4KnS1nR/Nnv9UhTFqERhREu4VOsWtpBiIKi7neA +XdQZ3FeLI1kkMUUJBKbYphiLy2VZSafrJ9GIkPnRYGbQbTo+gnH+IOQzKjXKqV41IJD+9aRKU0R MKzuB/boGssj8U1F2VutOkHUCa/NS4RsWCGCbwDtM8AzFS7jIQfWBopVjUPSo4+zQt6ot4NNo5Yd lGOqXZI/g2Nb0DxTKxVe0yoKGcRYulFslgaFYnrFhdGV91pnd2efyoQ7xPAZ4FZJEwkVayydq5TQ okvXTWUL1WcUC+mHLaOpJeBmANPni2bwdFl4mGEI/0bczVWkYc8gpsN+pS9f1iR4J1VFhyV6VVdR p7PlyyKNto6m6Ecav7ffEef7OaGPHMtiYwMf6TKSpHWWDLtajA8EUtS+DPuG3r9Xnhaf5N9+L8zI yVoiNAogldALyCgRqyhdPKayJI9kB6uudt/QLDsF5JpqEg2Hz77wG+6hjke19LGmWOKrenv063sT 371nQ3gkYGRsSNkinU/bZrOVnyLfWfEhOKri2qSJ71mBImkR0u0Mgs6WtD26dYBv1UTRY3tSmBQr s3ros7TswrmksNyzrWLRE+Q9u7xRkbwDo1oWEm3x5ZcFgVg9qEaH2/ezDZ6L0fj6fa/PxwnKE5L9 uG00MyvSyV1YR9vnSm8D4fBpbE1fceH4QclkYwqm5MV++AHzymZhjaaW3TddtZqpKspi/lsVH7+1 RUBRnN5dMk6VMID60KkpUiknTyvcrDYxdyzVulGrGWXUNGJ3r9WY+6FXBWXJp7QQrrsVVKllD2xM 8snXZf1pfVHSluvB9HJ03sVISCRbSvrG8JjwANrw9YmoU6jD1MFWhZsoLTA4tDl7VBL+Zw9k6xEG k4TNP+PSGoMyMckpsPqRJudfS0HMtYMcLdnEuho2a4d5AVL4pGrC2wuUTWhHhzSJMle9tmBDg7md UcrC2X2SLURQHeVaneK0dXcZBbLAh7r8HUwo0PtFqz7wsS2cFfn4idoEZ3UpakpNVC8SK2quKEyr pkceTRfTh6L4M7DkC9Xx8tbRbewsVg6dgryJjpm1ZUWr7cb7Z8eUM8ZRQL3DQ3pTLaaBMPi49vEO fZ+2bZW0JWnWMGgmqJO0TurYWpXtOtSYooJQH5VX0Lp7oJfyKWYA2s5tdl6x1bZpLIzyhTJq9d2a XIqZEp/Hhmh30oA5+5WyiMDo3mQyGE+fF6tXhROAHm9La2AcHThrzB+ETZBiGYAqv0uddEM7QB4o SyIuKFJF4ByhUsTDVo0zf5GoOGmPhbLVwcJOChVMbdb6CBlDm/smvtK+ehM7hU0/znYylhtbbvmV zyQFo0BFr15m/P/NsKOMJV2frCIayGdSE7oODnwwLKYAR8+OS4tq7DphtrQKVRSIiuZbSc7Cf7vS MJbatla1pqpCmdUZa2d5uNUpxU//Gh0r0nOQktldzDkP2uf8/6FvPfgrStQcOtmQ6VXO9cQ6hJHA QiX0vqBvj/NXkw3za76hH0DQByh47KpXTGzOHxhDPtEUPtHk7d+dqLuoLiyrDjabFpVti57ZWShN SloKD/DAX/Cp4bw20fpBDgUh76OXhBq2JjDQ0FTb1cAtt9brRmbtSW1M5Psgunm51o5X6LNWZuOR h+6U17EqpS9c/Fe3ZV/WRTTs5oNo6AZq8y5twZ8SuznGWjm8lGqnfp0GU2kA1bhcPvPDu4+123sU 0VXAWIEdzfXi9OBqjMZ9PZpPGRiqV6cZkO8nuUv6HYtwIY0BOXC7Slc15bsxlfblDSvdw9TMl9or Rl1V2aX32GYcdUYPlcNuCkrhStTxiRn/SJA6MV4m6lN2q8qanB2PMlufhdDB3iswSlNQ2X1XYdsg 81SPAlFdSt+1ifWiOh/eqJIC9WNNeu/c4dKDakm0Tj1ox5FOrXPiauBkrehcnphMRvlKaWMl8zZ0 gWJIxwzzmgyFjjYTQ69SH5QjzMedoHmxo37EAZOIQ4kazDMA5UrzrAbEThwZLp+l+vkXXSZP334u n3z6Je9iwenSputr6t1iGCXAiRpVnRJBa1UgmzW1SR3L0JOK49AOOpbGp1M1q6K5WMqPSCxdf+UE VGjrp/magGr0ejOfy9j0VqTYb2yqSbhcY+bzkRp8vFQId8mKpEs8+eabcrCkWPWUtrroti1aipKf /V/El+L04/y0LV69En8uhT6q2zOrW6HX6bwma8AoL8XT02oIpqjr0u/xhF6rBbsXA+BXp1+Jb4Ba eaFcBkk1bGoA0SMQNPAxDVyGxEg9+yNIPfsMSD2rIpWHZqZ8SYOolrftrqsqnmSKsrUt+0iuq+v0 LINfd4hC0MZ4GIUyd2/GV20lnGx2cilzZdSWkJj7MRVP+Cup/LKOiKnckn+g6SCzUqTEmnfluEOV UeozW/VbWGm8rUkVCh2L43W51k1tZrfscny7/+8gJ3WXotX08ySisk3Jw9Yiw28ORKhyXLEmPdmP 3Lxpo6+IhjrNUQFf5ISlyBVNtsAdpsNNlXOmuoCiFh1O0OklqLQBsudYkFClHvpQSxip32nLBjBQ dIENkhNPzmlZ16Sg9Ot05GwTyfEameRd54Rtbdbey3I2tWpsvNtj1FgV/bmB89tvEBd/64InN85K tor1j+WehSFFS2HWVqDgCx8yhavpG0TMZEkHcibbJJWrrubbFPP+2g8CP6nrR7bQFLGyj15YBcUw d32871FgUNe5ztFpWLtcnbkY583aoxjkTPu7doaM/0tbvHyJx774D/HXNhThrzUo0MVk//eZBrVv ctBlcZpWlicA0CIoTRZlnwkpCI70sPwDR2Xu7Z+hCtxhM5R/D4RPsZn8kn9qI7Er7XSii4dWtJ2d LsuyI9JzKzmqzM7dWbHJgKZAyg7qmzKhyuk1jb9VkVGTG9TWF1tdsryTU70DPfWn83AdoeMMZio7 8pzZJGJlKIl2J952mrhtAFWYbownGTs+Z+upvSx2/7bN+0RxZJWRCrB1xF49sBICokd6zccED5Nk Jz9VzyMUJFvdIuMdslId0cElRC9KgBV+y4TzCALctXDV6OR9yCX8b3VX99u2DcTf+1c4fomCud72 uqIIjNQIjKV2ZrttgCAw5Fh1jXpyYDtLO2D/+3hf5FEkFcXLgo0PiSGRx68jebz73YnyplUqrQzf uELiTiqeqW+tzmzpvEgrldi8T6gHhN5GZ5OU50q6ZB9nXa/pHYo1aJdObIRaExDdChMtRCKv3K/U gjS3cMNl4vLIGqMLDOAVLESAEp9Z766M9EIniaUgJFmKYxl8DZRrtW8mh+jdmITHo9y0Nf3z5pde VaeXcx7FZpfeQYyorO0ZSq7Z/u3DZQBbePNLHXpKWuxzipebZYXN/b4Laob9umxYd6pOSdw01Yb/ 4pxLVtTwoINAz9VoFWBPY5CO2W+FmqX7/+Oajmp87Vbzgiyk39rWUa2TfX77dbrNjXjsGuRd6VP8 Ny6WEEZw26qoJTX2Fe0xnlaVYJLkvS+U7KlWcQ2QUzNb+U78JxQ0WjhbyHg+/Ohz0GlVSnZb1tlG GbFYnSh0iN9pR0765moZgSNa2meNFdh+YV+Z7S6BldIOAArFa1DH2Amao2Dh5gzjrNKwM/RIeTBa YPiLD/JDnD90g+xOU+2C2Z8eNlvTXvnRpHR0H5EWxsWkAxTcEQh2xwZb4lGrp8CZZYhsael1cGd+ kt2x5034MSx0p+g2uwRemHG7OmbBG6bzuB00+QfHBJC5LUcNJHSDBTexfcge2g3Tj8Jhi4scqTHE UpnaW1S2NErY5q4Y7nwAeuXu8ubQnjDxDpvLvGkSxH5LJW9U0XzIratBoXOWx0Ynkr0ZjhqaYddn 9OyLkB6aVaWAu2BpmH2Y9MfD3vv+bDia9juWoSNVRtXHuoZt8fvmj+LRShK9sfvFP+nNZW8y+TQa v+Pe2NX4rL3xKmmivDD8aeisPn9H62x4hJE7qDm9MACTx49gqXZsJm+8Kg31USlX64Iv1mAbA23R dz4d8YFcjgXrUSUD2I+cnFIBWnK3J3O1CxCX5TuAuj/g3Xexob0noHI/30H+0u7RiMl/NzjvT6Z4 qJ/1x9PKocYi0M6fdW3Vj0I2KYN3qa3M2Lj/28z0fRCdLR5hIJ5eyrC7OJ2qNUt6AoTE6rpdr/QM Smp2XZd0wLU9WpFyFWtU01Mgr5B4dsij+W3MqhqWoVDkMoiRKYUEDEwZ9dIbDM8v+rPJ4Hw4Gw1n Z6PRrwOzxLH2SEVUA+wT7/NvvWWRvf65NhcK3u0fY/ApGMBuvlhwk6iMPrUkoTWVBWZcz06Mszc0 WIfKV1YlwJpYSYfjZCjxxMolSuio2d/UuVu7IuIj6KuFIxcbSOCSo/cy2m9kcym+wVcQ3rhrKg5J jAg39Xhnj30crVW4jvThG1UCSaqXHwAyEzuE68E+Oqve5ukvX50OxnC5eLZJx/PeAkw51XB9a47z TltQgzgxtgBcC3Rpw+KcNfSFNu+CyPJZ8MSS88Rf2+JulIotk1aDnPN9zvVdCiV00K5K6zIttNxA U3gXRcrdhMxya/1ZbDevyVTD+A/Ebfk3Rm+kgr5d36CbTfA8HgfENTpVqE5bD9JKHXu4zxEdzCAk EiV5hF4/A5ukCDXglMttAdHBLYhobqa0LBnJkt9ijBmwxHIADm4+Wf13IocJMTdQEhOY0AEOIMZf cco/w5ZPdgtBn5kjk80X1goCss+c/AsxVHe6DYWrGxUFEig9mDEHRAu/E0Gin55wDEsK36gyUh7E OSV4mhAjs87dFhknCICI/DMv+NZbE4cMfAoBjEzAsEizfKjVx3y9Wgg2jC2ecFCKgsi1AGOk2KJ4 FlCgxVSosrBuLyOk2iBlfJRNqJa21vzrtbp1rIqf88gm0954OsPvUHVaFW0/NDsab/bWsEXXVFUu 8u3ijMThNrvIec0WV01oNwcVcjqBAGgeN3aYcb+6ump9YjseTvXp6WmQjwz2uC2A7OGgavji+qeb 8BQdEZAHy3wE0cIVolfRUnToyQKLS6vxfrO/YHvJEczaHdXeyCk/MESWGq6W8ZMTrp1B2zLMHd2V 6NWdI6cxDGpV7jFv4Dzd1GIOeiBcl+DKJTlN7/A2RjHYUGQzHU2Lbe6XC0aqQgBDMjxwYURZjDT8 5cBArJrYnZGgA2WszeAsE7A/o6Oqp/aGZ/rC8PBlZc6wzINqo8skF7fukpURhPV1JJlUkA/5RE3U E8M2iX7EWyQJmr0q74vU0EOieGX0kRRk/yyzDeBKkHkxXwA+iWFHiNZj0BHoPde6utHd17ObwpxQ SNzMz2qphQMBaW52yK/hqxTmCpKoNZICfKPZ8F1so9rVCGdodUp04bECFr+T5i8JmtKcHG4Nncqc RfVJiuJwEyOHd8RiV/heyGl7zDkYccgbheKL5+xg8PyiDcrbOSAzSyvnAM6itTQVWeC8BbptqrLG C4gqALPYWU0MfZiBc8Tkks3dC4klR/+yXFJu9gfIJKPLhEiyC8JV2zc6SDY8AJb869XfUEsDBBQA AAAIAK8ApC7FRcodTQwAACglAAA5AAAAb3JnL2FwYWNoZS9jYXRhbGluYS9hdXRoZW50aWNhdG9y L0Jhc2ljQXV0aGVudGljYXRvci5qYXZh7Vn9c9rIGf7df8UeczOGCxF27prOOXEaGeRYHQycJOym H5MKaQFdhJauJIjbuf+9z7srCQlw4rnm+kOnmiSWtbvvx/N+b3rfnbDv2Lc33A+5vGC9pVjxXrBJ 1/ksjoLez/5HX2b+80ysAj97jr9+HCV+r3pJZdBLl77kPSEXPX/tB0u+W/XzbMmTLMIHIXtXfhoF Zv2T8bO/8bsbdm68YC/Ozr7v4c/5C3b28uLs7OLF9ywQaRYlzPq0Zt8qOR2+idJIJBfqiP428DN+ cfQ4rdOWy6/wFKS8JWem0pK5Yp5toTkbRgFPUt5ld1yScJDtvNjeF+sHGS2WGWsHHXb+448/HqVw LfIk9DOcNRgz45ipMylRkDzlcsNDo6Do8DBKMxnNctrO/CRkecoZUEpFLgOuvswAvnxgcyFXaZdt o2zJhFQ/RZ4RlZUIoznZADS6jERYc7mKsoyHbC3FJgrxki39DP9w0IljsY2SBQyShBEdUrLRuRXP LgrRzo096VIm5qVYgQixOU8zaJT5EJcI+zOxoaUCJCKCJxFwD8CZLaOUxaBHZHaclYZNscA0iP1o xWUJ04tDWcCzhkspC7QNc8j324gDpgUV2hGKIF/B+f3SdAgaJrAi2QpOLCM/TnfwK7NhsSBQV6bU 8ntDuRNPwudwArnHIEqCOK9Tgrp1Kl0WzQvifvLQ1YgUh/Y08oOPidjGfMGJ/EVxCk/LI1Q0iNXh FEYvPDvkGx6LNYSYPdSUoefxIGDtZZatL3q97XZr6JxiUHrpGK3ivBkDrgSYxQ+FYZoSAs8H5q/X 3CcTKGUqkaIs5fG8W1CK5sqAWxgBokqW5gFhFcnw+Rqp72GPcAp3kCs/jkvypSl+0KZI/BXUb9Hr H3XuZBMpfuZB1uris0qjeCOWrT0ACoF2MLS0ReB/bMYpyuFngowtJCIergPYVyLjJfwp0JYRckVB aY5lDU6le5ECcCKihCAp4hMd+2mq0s/17ntBZrfaZeuY+ymFCHwM9ta2ebszUYnG7wxSuyHUMXHI SoV6ATDlFSilnQG22lR+bto0kgXeR9U6EJ/iNttl33dS5OtSYO/Gdpk7vvbuTcdieJ844zt7YA3Y 3/9uuvhwesrM0QB/3zPrTxPHcl2sjR1m306GtjUgGjjqmCPPttwus0f94XRgj9512dXUY6Oxx4b2 re3hkDfugp1VnqwdIyLja3ZrOf0bfDGv7KHtvVd8r21vBJ7sGixNNjEdz+5Ph6bDJlNnMnYtBrHp +MB2+0PTvrUGqCT2CIyZdWeNPObemMOh4mtOzD5+VMpej6ejgenZ4xH0IRq257L+eOQ5NkQfOy67 siC8eTW0NHtAMLAdq++Rmru3PuCC0EMVWe7E6tt4B1gW9DSd911CC2Rd66cp9mGRDcxb853lsvYh WkSjDhjM0Z861i2pAojc6ZXr2d7Us9i78XjgEm3Xcu7svuW+YsMxkBpfE42pa3XBxzMVe1ABkNiB 96upaytI7ZFnOc50Qgh02M34HoBBUnNKFgb2yiojpTbgGzvvSQDCQ1mny+5vLHx3CG2FmklwuECv 79W2KSoOdHG8mr5sZL0b2u+sUd+i1TERurddqwN72i5tsDXnexNsp17hIWRGiKdfa47bVcZm9jUz B3e28lC9GS7i2oU7aWDcaf+mMADFwNftkeoxjlyRouioXmAj4hyZAyWYMsiuNK/QfVKBWKEOEYUI xRVFMKd6iLid8aUfz/fC93jzROlrJXQyjRIq9LqiiOQLZ6vclnJ1+PXxEvSmTBh/MUPdAPhx0SGk VE9RYv+RR1LXO52OYtUeNrunv2kqvZOTE9D+6C8ony9KRmX/bDT651fYHK3WQmaM2mYjEoY9tj4F fE0kXzXWUh7kyIIPxkSiJkdrP26sfzKoqYx5ZpCWxg3+cfUHB+LzNHvy7nQNbXi1/ZgStH+f7OP7 nkAw5OtYPBhDsYiSvkjm0eKz2+FjsYHZg7/84eg+sVqBpRGLBegtiOwTt12jBAr5QHY56X2nvMJM 2OvZm8aM87o3e6PqPRbu/HjD1QcwiPmuVYNr33jehF2Zrt1XhHYkdIuOQMgz6APPQvFzrvvsxcvz 31+gA1MHm/svmJq1iBBxHkQLgM/MAE6a7m1VLRVtfEvOBnftSz9aMMdgt0E/9hN/6atK+nZTDDf7 M9iXBjD4uB4mGXpisD+cAk+oTPNPKNlhQzohyWrsX2odsbQBH5YSYgED/AymYJdsZwhjwTP81j4y ZyrWHWUpItbrsee/5mF2Av4JxoU7H936LOZpSZHsT48eEbW7sSWP0X4wMaMGkMYO3f8oaYxif69Q D41cQONXoeA8osxS0JmpHzea2iVL+LZYaSud9gQY8DSQEbLChjdyIMabPNMSNN3vSaK4yNfIYUSQ XeoDeFpfTFvGoTl658ZZ69V/aIvyoUYTsGTRMVs4PMtlghb0i4io0Pw8LtqLCxzgazYotTvwzwoN qdm1iaJBjMg8tPDLV1CWTbQAtxxxGh5Rtoaxnt/UTLjyP5K8Skmp03BXOVRYFsV0zYNoHtHcoAnF lFmpWiG15rIsrQWWr2mSf5PJHIlMveoR6uGQDFX+DNkE49gS+WvGMWqkoJbSpi4NMJrWHGW+TmzL sX/DKzKS++SNPt2FqOrAgiVNCwmqph9jNXwoLVWeeYvZzV+V+rKi/BBlddchBWVCwHKwv2BQ1qHy hJLhcL8GangIV+FxM0J+KbbMb+TckkrjSTHBxCGNQvBmctEKyIopL4s9qxV+DT/cep1nPbgzfjAu Jd0sBGgC0mM+PBMCzU5SF4u3a3W6cpTKsx976kW7gu/Lx2q1uwCuU53JllJs04aKtRA77FXYEtLW UhJj7cNNnVIlKhLFN0qe5ZHqBRF6A+dThte+1UAJSVGsuEj4H6oTVYtFNap4u1RCEa8pYrDaUedY 5JE0FXaI/W39e0POERJxuy9UzclSw7F++uC6Y3vwAQOS1XnFak9FFt7Q3snxDYpFHsedoojWN8F3 jSgd8Fm+sBIqZWG7s7+PHtoX0q52yzwKyGmLHRyqP892uCilMLEjaz5jrdNWDQ56fjkQUqNTanHA BmVUBBE5r9rYpazscjXst6tcR6mqs8epStS0tlvaCcBjulR9XIImTnAadH56q7psSwRrGJ6tEG6p yrawIEMqLjPwPp0BpkHXo+ToukMWUGErL2qRg124SMzdaJGMkXH85JRCtW6OfXLUc+RpJRRVBLoy UW3hGvBthQxfqXRLd0uAj0WZvqmhrU9zms+5DGkLUFJORSfPDoDZdwGI7PAVXcOWWOF0QpdcqVBV RvIFpkku4UJ0ZbR/eBvFMdRIuKQi6KtWiagAH/mw5wI6zqRi94VQq3lIPVOgaYhCxQiSoUaEZAYa WsvUsX8Fu6vB+3lAd9/RP3X5uKynAbO+dCSFVEa9hEllyqfF7+0GzcNzpf3Lc5Pi90fP1fMbDfDo 2XU69eNVu2M0qkkpVLdiUyP0pCRVWbqK5Kq+7CTpsp3R1PD04dbybsaDR0rQZ6XSTB9JDHWzu5hU qOa28qSEioetXffg62V/jUYDkpKDVB3LvhEkgTfS1tOVsIJUZ8omarXtx5JinVpZgagQcrlLuxct /NtcnGDYLTlBvxo/FcbszSU77+yt0oNAb7f6hWqkDaUbJQNVhWc1cfbT/ZFLBJIpbdTx/Uqu93Uq oDVS+r0OFBEykHL0/2q2W/f398/rzXHr0QalpYYVLfflX1sHOuDTET4uxoU8PSar4fY/TEfmFC7p 2H+2BrXDJZKKyDzO0+VVPp9TYtvtKb1RdchfbZagiamY8B6dJSaUEKohQmWX4v6+Ni/sJa1aAiz7 cWbPkb0Tut6nazz4R56E3VIv3f6TFxfd/yNtfJON+RjT2v8wNJLswVxb5b96sjyWhxvDHYXDXpY+ HoLaZmqlGbzfNI4bmRiKLZd9n7zXQBKTWXqPOtFuzZQXtjpPorxfOZpM0nyWKs3aLzsGXlbt0o/o oYaDq/+a1Q1BafRHDbufvvKEJ3Q+bASuqrqaa/3qAk0B7W2iSEF89ZDxFJ1EHS9MjYGIlUYVE8zU If80nrdPL073sNV7X7OzJ2F2WDl3PHaInXW1CDvgyvO7NHhYS49R0tI9QxY9IFVKWMpyEObHgrJi 978ZlFUn8t8PynoYXv0/DH/bMDwIo18dkF8tDGt9YRWGJ7+c/BtQSwMEFAAAAAgARAGkLviubcnE EgAAYkEAADoAAABvcmcvYXBhY2hlL2NhdGFsaW5hL2F1dGhlbnRpY2F0b3IvRGlnZXN0QXV0aGVu dGljYXRvci5qYXZh7Vtrd9tGkv3uX9HhzjkmYwq0PElmIltOaJKysEciFYK0J5vJ8YBAk0SMB4OH ZM3G/31v9QNogKAsTTz5sGc6JxaE7q6qrq7HrW5o8OUj9iX70zl3fZ6esME2ifjAu852xSoMvMEv 7ns3zd2jPIk8Nz/C/24YxO6gfMhSb5Bt3ZQPknQzcHeut+VVr1vkWx7nAV4k6WAcbHiWD8131i/u tdu/ZseW+I89e/r02eDpXwbHf2XH35x89deTp89YyqOITT7s2J+EqHN+HWRBEp+Uk+T7sZvzk1YC 1E9DTj9DU6QWW86GYrHMSdb5DRTALgKPxxnvszc8JQFJPjV8lOxu02CzzVnX67Hjb7/9tpXCWVLE vptjrsXYMAyZmJMRhZRnPL3mvqUozrkfZHkarAoaztzYZ0XGWRCzLClSj4s3K+xBesvWSRplfXYT 5FuWpOJnUuREJUr8YE07ARp9RiLseBoFec59tkuT68DHQ751c/zDQScMk5sg3jAvif2AJgnZaF7E 8xMl2rHVkC5jyVqL5SU+BhdZjhXlLsQlwu4quaYupSQighYnMBKoM98GGQtBj8hUnMUK62KBqRe6 QcRTraZn+7KAp6EXLQtW6xeQ798jDpgqKjTCT7wiggu4euvgOyxBT8oiGHEauGFWqV9sGzoVAXMx epV/toQ58dg/ghGkDQZB7IWFSQnLNan0WbBWxN34ti81oiY1VuR67+PkJuQbTuRP1Cy0zoK0IpVY Ts6w6cqyfX7Nw2QHIVa3xmKoHXYC1t3m+e5kMLi5ubFkaLEoyvSsjpo/DKGuGDoLb9XG1CWEPm+Z u9txl7ZALKYUKcgzHq77ilKwFht4g02AqCnLCo90FaT+0Q4R8LZBOIM5pJEbhpq83oqv5FbEboTl d+jxv2UIZVdp8gv38k4fr0U0xROx7DQUoASq1NCROwL7YytOXg47S2izkxQeD9OB2qMk51r9GbSd BogVitIa3VI55dpVCMCMgAJCSh4fS9/PMhF+zqr3ikzV22e7kLsZuQhsDPst9+b7aou0Nr62aNk1 odrEoV1Sy/OgU14qRe8zlC0G6df1PQ1Spe/WZe2JT36bV9H3dZoUOy3w4tx2mDM7W7wdzicMz1fz 2Rt7PBmzf/xj6ODF48dsOB3j/x/Z5G9X84njoG82Z/bl1YU9GRMNTJ0Ppwt74vSZPR1dLMf29HWf vVou2HS2YBf2pb3ApMWsD3YTPdOYRkRmZ+xyMh+d483wlX1hL34UfM/sxRQ82RlYDtnVcL6wR8uL 4ZxdLedXM2fCIDZNH9vO6GJoX07GyCT2FIzZ5M1kumDO+fDiQvAdXg1H+FEu9my2nI6HC3s2xXqI hr1w2Gg2XcxtiD6bO+zVBMIPX11MJHuoYGzPJ6MFLbN6GkFdEPpCeJZzNRnZeIayJljncP5jn7QF ss7khyXGoZONh5fD1xOHdfe1RTRMhWE7Rsv55JKWAhU5y1fOwl4sFxP2ejYbO0Tbmczf2KOJ85xd zKCp2RnRWDqTPvgshoI9qECRGIHnV0vHFiq1p4vJfL68Ig302PnsLRQGSYdL2mHoXuzKVCwb6pvN fyQBSB9id/rs7fkE7+ekbaG1IanDgfZGC2OYoDLHWuYLY71sOnl9Yb+eTEcT6p0Robe2M+lhP22H BtiS89sh2C4XykJoGyGefDQMty82m9lnbDh+YwsLlYNhIo6tzEkqxlmOztUGkA98Xoxk+jhiRYak I7DAdRIWiBxIwRRBqtQcAYRSgoiQh4hCgOSKJFhQPoTfrvjWDdcN920HTxS+okQG0yCmRC8zShJ/ Ym4Z2zIuJr9oT0EvdcD4aehLAOCGCiFklE+RYn8tglTmOxmOQgEP6+jpZ0ll8OjRI9B+724onm80 Iw2jrRqMfo7BQbRL0pwReLaCxLJnkw8e3xHJ57W+jHsFouCtdZUiJwc7NzzQf8mzDNwlQj8wZpo4 SIrDcJPg1210gCW2MrTO3Wybu6uQt/Q52PB4s0je8zj4J09rIz5YhHJDnlukdusc/zjyxRz6bIp2 1+hsB/VW7Nu0SuObZA+PuwfBOXfD6M4RDhcZ6M4xPt+Fya11kWyCeJTE62Bz53Ch08vx15OYoHXa OjaJIghvhckGNDdE+p7DzpDdk/SWTO7R4Eth8MOYvVi9rBVxLwarlwLKoOONG15z8QIMQl6hUHjt +WJxhZSBUC8CmEFDgD14HJufjVDCffNtT/vX92T78J5R6gYbNrfYpTcK3djdurHZPefRLbt0YZ88 dQVi//5aVWFtBeOnqkU4pCyAGQB8lrGWyvURgQr+AQDDz1it5xWFj/8V/fD8azBiGSnBY9Aog3bZ Kat0a214jt+6bcWxYN4j7ROxwYAd/a6GMjSGJECvmiJtKTUke4QkMAWIEuVenCBUUjlEbpqJCk8A zyQG4qUeS00cqHUCf3pUNaqVrgMKiAEQOPLTuxnltVN2/PwP5julFP4OOA3gxIEAdpwDv6fW5fBv 794ML5aTP1KgBdAYUvc7e3pmTwFo7ikPlRBwb7blISAsS1ZURFDpKjG0MJF7yVDFCBb55eMpi/mN 0dfttcgw5pmXBgj217yWTVEoF7mUo+7t9xJIJgJBkJ3KCWidTyZAq8VVBsfW087ncRTpJWlB3qkd RQWDFsbdnnJ1almxkxrUL3JAnKqbGqBBF+o/l7t5CvUXYdirDaFmDGG13EzhwhZe7PFuB/vWMdh9 RPmUo27tHkrVjPca8nALMSrOHdRx7xepC6IGPWr5Nk1uhJHYqMw2boihOS8pmsM/PpL//r5dYHp5 7I2bBgQiWsIVeUQk9cJ8oRh9YJJ+wvZq2qz03GL1U+X6Ww1mDlEu0Q6LZ5iwkKFCelbZ1+pYmgX/ sAtSlQZR00ZBGAbAXcCJPQt1XoYUl8MW3Ag4NWc3SRH6WL4LD9SUVjynERqssZAOXJBTg1gdaokA xuCpGx5TjoTcBJCRl5HCen0GDM4oc0pyNANC0XkmZW6XrYLNRtBP6XQkwT9b7vqHNBImcGypjCDi FCRO9+Lf/dThrsXCWbbjXrAOQDsuohWJsKZAnJF6wuQGL+R7TUrqSJ/qyZUqoftMasVVOpFDt+41 KYnOIEoNaWKVoqSe5IyVoit0ftA4KPQLTSwhLdSg82HL8q8UWnjPbw9RUzETI0CqM1Lx8TNFPvje VZrAGfKgzefmPC/SmPmfTgYCBN6dEmRAVcsRMW2diFhaRpNUsusSRYsYkQNRx+8NMNTYlRTgkgM+ +i2LNYK89B9xsBq570leschUlg6wCFcCAnm8qO1UEwoJx1PJByBfpLo+Vbp8QTn3JZINILN4lOeQ t/tkPJGUXLImxCPYHgw3A7WMBvXpFFDSWqNWNondcGHZJZmUC9d36UJBVDTM29KRW4xA6obo9Uvb 03O+37mpG+n1MlUyEWVxYZAmHlU18WZvvGKgayc9Q8iwP14q6mJfXcriVqT5LXKRAQbQq6nUGgKm 8lBYM5loqciSKS9zolE9S/XDrHdFPoA54wfjaUrH8x6cPGuz4VWShCIUGxbTNWrL0lBKyz7UzEKz VN+npxmVolJchSdE9s5qSzRcbL++ZltIa6Axat39YT29KIIj6p2JBMoH+Og5Bdab0rpqekJWTpAf Yv5dOaM8qaDiST2dCrGIF4JoWo4wORKuqiZ8oXBVC/iCmVlBNuarYjOJKTH73V5zHDUa59OobmfY KvnjDtubZLYn1QJI8qkbAQPgbedxpwGxPtZ+g8rGAXmoA4MPuRNskD7YtQippgTfse7NNmEc/v7d d70mCZtu3PoMxUHiBTKG0WmcPH+oboIywQM/NvGR9iXVVGwGAdvHDuyttSsH1ExhijzVLatMaz75 4Z3jzOzxu+lsMWmsmjZDEv/iEAoupZcD+5Qo1BFKtwy/FD17vefmvBqhMo/QOBOsmkaKjBX4pCYK vghQPmmZjh211TYv0aoEUJJRCpMnEsE/Zew6NdUzNLua1lufd8CCTZ9AFeVXvkAe0q8z74vjVf5B eakbRjD1/U34pNtQU4ujLEh3LWCPqJ0RqBG/16VvMKGW8k2QAcpV+1YGuGpRd8S6yqjkAdK7y8ni fDa+Y4YWtS/X1CZSq2FQqzyybiYOj31KEJ0i1gvmfqdKda7sdnfIilgVGVSZXmuEptiVfgk04ewC IipA2hUnD3SZqRHqNkBVR/5b7HZJppOZJCUxaxEH0GvPalqjpHtasprS78JYNJyi1nJ0SiE3uzMT yHG9cvXSyuSzadwZN0tmLj81UfZKTPoqa/WlsMZM6rUwnUrOImvjbjmjd8vpcAlbmNv/Mxkbk6Ga isg6LLLtq2K9rtfn2gQEavps+JJQtMLrB/HlFXlPHTE2IocRheRFsRI235ZoroyPvpE29ecaGa8H MhPQdiXM7GlC6k7WFEbEC7o8FLctdF9Od97yXrxk1ldCaToSg5K/KQj6CSwpToTVIX49npZD60oZ HlKRca3cTuePgZfVAqE9qcPyxr62A6UKG5iyeVxR7Ws93LdAt3vjzFpry1oPJCGXKZZcq+AGA+cW MT+ygKTlMVMYA03VtlAGuBPWATI6lEPM/ExGetBPmKxGy4n7abX1wE1HgUaeoNlf1KZb2JQ0z94C AnQ76gSp07sXsSYqaNAtVpnYh+5fehYeouq0iFrjyozRTY1b/VoP0nTq1JhQV0KfdfodM/obuX0q czsJ/7zZLzb4rgE617R3eod6vDi5Y96vye5QV5EGh2VVWexAf7Jz4SyHeiMRtevYTUbyrqk3pGVg 5259NyyU55dJqk4B92sLvegiTWG1YhQYNWjEgAfit+ZpLNX/kMkNqSygeQYZCwGCf5itu49PH7fA vGraC/Z0H2sru63rg1qLwNII9kjUhKlM+mm/Ermy7k+wgMMXD+BRLe4JO25nQjroaFDYscSMrNtc Vm9fM4ZfpDxKrvkPBYJ0faoQt42hcJqHcDO97OHshCs9hJ322X+BlfcgPl7DWgXdFrLeg5dQxo+H rwHB5SGcZCx6OBsEqgcZnIhr/4qtyaD3MHMrA+W9GRo1EfFl3cpDdAH522+sa1iy+VpZXGvNT/1i 9XU6WkT9tjXjyshV9ohqjW5QxF2RuiPSUMxzQ68INZ5QnSfmXEzqypBPRzYnBE8gWMVYw6ZnUFy0 N87ELq0Y6JkY6T5rScOR/7WkWl7SWlz8rO4NLSlx131GmenVLW1Yr2fS0ihE7IF5fcrLzTIrcLEn +OH1lTf1ydbvBQPLXe5LyUsxPt5V9JTnCC2VRx0qyQAvCxGIVp1ku/RBGAsE9pOH4Kl5qG4UIWqK nnmPwkIyVaW1OOjQAP/AhUz9MKQNU/8HGX9GZKzn/puB8X8AXr39PwV4VbC8MwG2Z8CGVR8KfXNB OxNe+qvgQDeGrg5vB6KLOgQoixpDPl0e0W++/MW0RFKG2WfRGSScs8desmdNk1VrqI2vVH/cZ+2U jrAThk7EVUQ75cr17vhepFLW6+pcVJ5rymAo/7RCxsXahwyu5yWpryK2cT5W/eHKzqXPI0BhWn6h AeeiL/W++QoIhiBCl3lhgB0/sq8okWsaeRDxI+xDtBPpXX3Rd0Q38AAi9znfclrPtw4kkvo57eFT nlo6EZ9baIMNROmg8ovx8lJ8VNISPmX2V/5olrxkszkf+n4qL64Is9R212Sp0Q8UY3BYAZv89DNb iZNXCWrqEKbibUKZykZqsu1DIknYXBNS4nJH33KTNcBcrsVc9cc/cfOTnjofGdKtXWHK1RfWewEV d+vrNb9vaQNfFYnnnzJ0GRfevn17ZJ6Us604Ktc2xl7sNJQRjiB72eXSWShLl+ef2PedwLYn1cS0 REFSxD1WaKes03zdEZuqEnqnRqG9yV09qi495JTazOYYenfKjv+rK7Ek+439xPwkoj8O/Bm/yHrh t4PMf9IE1ZkO5vxEgTMUj+h29Wdw+L3XJpBkW29QhizdWee0I0ccCVPanynfGzNltDyS4bO+dLms WgMn+VqyetF5CV0s5zY91SbLMndvsqyXxVzx2CKm8d6YeVhMpclaAyf5WrI6PFmqfm+yeC3ndlmH 7tw62J2OuHnplPsih1c7ViNRvi7J0PePoCJTQknjxcCwd/3y/pHZ+IBFlJ2NobJmaoz9Y28XpEtI exBrV/3NnHKdBP6B67fPcn/Qdm14/+9Wyrb/AcsDJps5rFFjIbzKP1yWDk6wsOwtIVV12iZZl3fl 8oONetGzf6RRE7R+dlfmUUd8NFl9AKLBhdGe7I+/StK8lq3vl0vrabS5XnfPEsixVMEmxD/9e6cj xNFLgcB/pz9arcn8hDE6PMNgokj9whrVZGmfeiI9yNBB3Q0yB1O6nN6p1bqHiuZGwlQ5/8SQWV8G 19qTFnUYG17ea8ODlNfsJ8h+Ow1BhBL+x0f/B1BLAwQUAAAACABIs6MuaBnFDawTAAAWSQAAOAAA AG9yZy9hcGFjaGUvY2F0YWxpbmEvYXV0aGVudGljYXRvci9Gb3JtQXV0aGVudGljYXRvci5qYXZh xVz/k9q4kv89f4WWevViEmKSvLur2kwmuwx4Mr5igMUwudTWVp6xBXhjbJ5thp26yv9+3fpm2RYD 8+XuXEmGsaRWq7v16S8S6b56QV6Rv11RP6TZB9JdpxvaDW7z7W4RR0H3T/+7nxX+myLdBH7xBv76 cZT4XfUhz4JuvvYz2k2zVdff+sGalq3+rljTpIjgRZp1L9Ns09Pf2H/6t37nlryz35P3b9/+owt/ 3r0nb//jw9v3H96+JUGaF1FCnL+25G+MzSm9jfIoTT6wIfzdwC/oB+NwbMcu58/wCFKzNSU9tkji pctiDwsnwyigSU475IZmyBzw9k5076fbuyxarQtiBW3y7ueffzZSuEx3SegXMNYmpBfHhI3JkUJG c5rd0tAWFKc0jPIiixY77E78JCS7nBKQUp7usoCyNwuQfXZHliDvvEP2UbEmacZ+prsCqWzSMFqi DoBGhyALW5ptoqKgIdlm6W0Uwodi7RfwDwU6cZzuo2QFCknCCAcx3nDchhYfBGvv7Bp3OUmXkq0g DaHzLi9gRYUP7CJhf5HeYpMQEhKBJ0nBPECcxTrKSQz0kEw5M1thlS2YNIj9aEMzKab3TV5gTk0u khdYbbgD/v532IFJBRXsEabBbgPG70vVwZ4hKbRkZANGnEV+nJfiZ2qDRkFAX4xc5T9sZk40Cd+A EWS1CaIkiHc6JViuTqVDoqUg7id3HS4RMai2Ij/4nqT7mK4okv8gRsHTmqFUuBDV4ByULiw7pLc0 TrfAxOJOWww+hzcBsdZFsf3Q7e73e5tDio3o0rZbYnwvBnElILP4TiimyiHI84742y31UQVsMYql qMhpvOwIStGSKXAPSgBWM5LvApRVlIVvtoB8dzXCOZhDtvHjWJKXqvg3rorE38DyW/jxPzl0kkmW /kmDotWB1wxF4RNO2aoJQDBUiqHFNQL2RxYUdznYWYrKTjPY8WA6IPZNWlAp/hyknUWAFYLSEpq5 cNTaBQTAiAgBIcMdn/C9n+cMfi7L94JM2doh25j6OW4RsDHQN9fNr6WKpDT+3cZlV5gysYNaEssL QKZUCUXqGYTNOsnXVZ1GmZC3cVkN9nHfFiX6fs7S3VYyPLtyPeKNL2dfelOHwOfJdHzjDpwB+ec/ ex68ePmS9EYD+PuVOP81mTqeB23jKXGvJ0PXGSANGDrtjWau43WIO+oP5wN39LlDLuYzMhrPyNC9 dmcwaDbuwHSOHKkNQyLjS3LtTPtX8KZ34Q7d2Vc276U7G8Gc5BKm7JFJbzpz+/Nhb0om8+lk7DkE 2MbhA9frD3vutTMAT+KOYGLi3DijGfGuesMhm7c36fXhh1rs5Xg+GvRm7ngE60Ea7swj/fFoNnWB 9fHUIxcOMN+7GDp8ehDBwJ06/Rkus/zUB3EB00O2s7yJ03fhMwjLgXX2pl87KC0g6zm/zaEfNJJB 77r32fGI1ZQW0tAFBuroz6fONS4FROTNL7yZO5vPHPJ5PB54SNtzpjdu3/HOyHAMkhpfIo2553Rg nlmPTQ9UQJDQAz5fzD2XidQdzZzpdD5BCbTJ1fgLCAw47c1RwyB7ppURWzaIbzz9igygPJh2OuTL lQPvpyhtJrUeisMD6fVnWjdGZQprmc609ZKR83nofnZGfQdbx0joi+s5bdCn62EHl8/8pQfTzmfC QlCNwB7/qBluhymbuJekN7hxmYXyzmAinivMiQvGm/evhAJwDzxvjKTvccCKHJwOiwVu03gHyAEu GBGkdM0bCD7RQWzADyGFCJwrOMEd+kPYtwu69uNlbfuagyeEr03KwTRK0NFzj5ImR8YqbMspG/zR 7II+ScD4vRfyAMCPRYSQoz8FF/uvXZRxf8fhKGbhYTV6+oNT6b548QJof/dXiOcrOZEMn+1K+HwG naPNNs0KgmGzHaW2O3b+CugWSZ5V2nIa7AAF7+xJBj452vpxtR3kHttOAsFC5jdHs1a3wDacttE0 TAGtqaHh2t9W3v5lY/Aa08JGadr9NP0e0ft6XME/Hn8xBUHSvDi5d74FuZ5AnLkC1c0kdexXn/1w v9q8po5T6sebe3ucwlZIt3F6B8JfRUk/TZbRytg93WyAITtOV9Bvhd1P7HYJHj3N7tDMXnRfMSPv JeTj4lMlZfvYXXxi4Qs03PjxLWUvYIKYlpEn7FTwFNfkoudx16iR4BkHhgV5AAgAO0UEaEKT4J9c 4m1poCUoMrF6b7+X++9X3Buwu/qZH63I1CbXQT/2E3/tM8f/660YUk8Zj+WLsCV56ksghM9z0shZ X2BQQf+CACPMSaXlAuHjv1k77PxbmIbkKJCAgHQJSJqck1LO9ooW8JvVTIrZxG2mB6TV7ZI3j3mI m8D0CeQ2Nz6kFouY5pIiahcfiBeYFgBBbmkFLyEV2hU8Wqvq1hYju2KdEH8GmDWKlS4jBEQPsB3w DgmScz4AntZRiLMbwui+s9+2zp4oCflgTArhYBGZJDGlxS5LhFneKxBm9veLhVuQEAMo2gVKVhuM Qwkj49NZSNHGiVDh2PDjGRZLJpyBawp7JDQsVpMxT/VY+rjxvyO/bJEZB8AOWfiYeAj/mfN9iSkG JxQjGqFjAzjaZdILC1l+xKT/U5HtACTYR55t3TXJYJBQwE6GzG0N2LCgkJXkQC3HTh3MdTitJUQE OrE9hf63VJHJqI/G6GPZhOEyCdaYWCTgYP0YWsM7qSk55ldI8/yNXC8RwI+UWVkkSwPE5mTV6C8m kB5AjmA8NPtzQQ2b4pJAiJJfp3viV6BSUqk8OSQ7cYhZE1gzmqgSpJqUyriAaDECFz+Y9XZXdMGc 4QehWYZFiADihdxkw4s0hbgo0dmiluYhlaEoyz706O5Sie/4MM3fCcG11ZhinaX7vLJEbYvBDprS JeT1gIE5ps7pAhPxHDW1j2KI2yjYSoyVFzWmGYCQNaxQQzFCrGanthQDorp4Z8GONpIVIgC6+T10 ea+2khSnzD/rpEXoAHEr/3lOkl0cn1XEcAV7hNkn3wIVZQJ0pxuaJvQXNUIFjejHxKdzJgdkYg5Q oXpUOOFwl+epG0J/i/9eEc0I3IXVT5ljKnJ76vz2zfPG7uAbpHxO+4xojyILRmuVfPzE19cWjlbv FNLFbkU+nZN37UobPrD9rFbPuPyXLfK6XCjj0t+AiOFt62VLW5+chy9QMtKYCpx3GkS4TVjHDuK/ UJKlUBVBsV2jrVwCtpVNP9QnGmOl9zAHVZGA3iF+411ZBTBJSUV3ZAMbO+exlzcmAPoS6+t0BpCi ejOEYc8bkgBdqAzOAO090HJMvWiVjAHb/OQlgoIu4zo5gCxwOIop9D1Yx2Fh5RbEt0+z8IwBO+5a EB+JCl4+wq4P1zuuDoSQU3Rnu6IhiLqSGXBssBYsZQOjE6y05SnzXxldQUpLMzASrFvVBzNwWdEE EyhYFeDMnlEBeWR3NZXzrZGx6Y7sDs0ijJu7YtXMiTOvvqAgb8oWzkQaQAAmqtQYFIblvkdh/oTN tL69SnA5aMzNfQKyt6N8gNpxEjaV1TZqyGYatFr9NQ1YBIIGUjUhdsAhmMD9Kj7XZhUIpAzqvDGb AiVBwABKnuN53+aeMx31rp266LVZpKU+YZZJz/O+jKcNBeODErTUShTs/f3vgIZyZvm2ri45/jQN 4KNpYaoLviJOhpTqNxM84qP5DONUWPqB/In7M0iMrbZdCS7kBB0lYcMkJzkF+Ugt5A0tYJb6bTLF 4uWkN2Rq6JQLMMyLj9r9agOoaKYceySwqbFw7cyuxoMjY04SDD4HHIl8fhil+Qy2Antz6UcxRuws bqahOi2pG0rJQxXM3JwjV8FOq97ku8UmKmTlL82iFcsvZbA+n7rEXxb82Abj9OUu1qlVmfuFEBfP IzuIL3s/48d2ryTVV4psBLqBQMGuACPkgcFahnaiZ2Pj/d/gJISBBUK65Je5Rjk1bNJ7zei1Dkpu eCDO0QM/SznKJleHAc6wtRrxzin76EFb5XHw/kRiVRR/hoDR7NyQUsY1XzPDcsSzOoKJ2MMQg4l5 Q2lyJty/B3V+8ND1WZ0U3wKADA1U4BhkYhFTLvACSehg1mvKt2yv/+2iN/g2xVMqb3bPMlkp4kRU 6wXsUADGHk1H8YT31o93etgsAg7hOCc+hM1lOtYv3xqSMSETBMpzPREbUKyhhFPVrI9VKWeuyFva WPmq3T4zYrdfagLiOMRYXvzY4jEHP30HKJ6x3BrEgUv2b9Mo1GlBcLqN/TtWRSxIsY8CCiLnJ8i8 WvUyx+oHVpKwVtcmb95A4gK9FjTwoV0nJtxHK8fwF5MMvAeR4Zk8+00fpvoKi8cOOqlypCq9wNA4 3dt1ybM1c7nrinstihii/BslE5CKLny+zaVabPgEhmZJao0d/kgHwugrNrlqDvnq6sbm7zAp5Cpq KDgRKtphhukniZaxmX190154Ueoh9uIneDEiBhgEXtItsRZ+8B17Vrlro7zqM+Q6IUxKxRLK4rYP yQiDmh1EGuJoTatZ1lXPiN+vegZAp6leUnt21WsyeILqdUk+WPXY3Q9Y5FgJZqpaKzNUWY1kbT0+ 8LzGsZIf+OisyL+AQi1NDZhCHRqBZzqsfy3m6PXZ5YAq3I1SxByPVSm0inkFYKQFshtn5YIqGv9J W8z/TzzJ1lAGv3ooeVq0iMB6MCZ5loC3FKcGNYw/hbMmxpTDlxQs9gZcMHg/+W4+HWr4at4AdW9f Neev4NDBFm78OArliYo648ATgRCzELzNoBuHTkHYib6ZGFDdsTMFvCMVpFllEMudgRb+e25Iqhuh QFkVUbHDBI8mKIbgNYOX8XGTSln1OE5FBsY1iDuufk31vUfVIvT0hYnoASWGamnh/HC9+UlmrGma LUX5jCeZcekrHmPGAsvqpcSyYAwbj7tAtrOfR6n8ukBTnWTv51pa36ppSCGjKat6EGw+oTqkC89d yhNAtlt5kbXDoFHFrI0qN16E2FOtgny0BGtgs5nRdtRsdaC+n0glkzVujqrBlAYtj5AFjhkrNdZ+ HQVrnus0YnTjKKC2oCr5LHVcyWpQwmUiM7SafufB9inXxU7D05IvZqXa5PW9Wg3gzLb54Bz03qpg vkEE5thstaqXKTDoYH6tpcMBZuKPA5dyZTq9OrSwhidfYsCrGiL4PniJYZDSvBp6sRod975oFJDZ QdaYo0n67AyJ3ade8P1Y9cKvcPPm0Srh15DrRcV6JVEMkmNrdwhma1oz4Vua6fcd6pdnZFhbqTEa Dtm1GyTs4AdzJ4l17M6EuAAhA2YBfUfwsOoUjoCrUd1lTI/5mS+kLyZQzGj7lOQZHqoTS3+pT3Ok rii2RrWqyDhndJ/EtgL4X5oSObHO+TAOhB2XNoPYwUxBcnDwVsLD7yKY6kIykFMgqlWDjkOaObaQ b8uxMp/NDbOpUtIP08UsXokxegiWLer3tESdshqpyDs/6KSNZCL8Xgd4gGRF8WsVFOCwIJasCTFA 0WOeV6SIsPKT7op2Ry61eUPpjH+5Zx9hRZv3kuMbV6OOXEtqQor0irUBcuvOSp751zWihN/tktio Ce0IKtWKzqbLP3WkqVx1Y4ECmB1V1bfybF3HBF4P5So1hZlVAGGLuAdBHoch5SjjkfzTBh48DWEI wxdkChkOQAeT7DV+k++OySvYQYaYFLqdZHQZy/hMGT14RUVBQkUAms74/exczx3lLXCwIdYm4y1e B250hwgvBpcrOttrPx/xSnEtmJXT+mHIqVgW/9mWE9mJLDHLMT/MTPNvrpqZ5t8O0ljmnfF+j4lt 1v0w0wI6RQ6tTof4KM5uNdpWfGBB38TIDXtvGQJ1wREfeJglfDRZcqoWT20Vg4JIQ6D46CcWdYJM vPyuv1m8MW/T12XoLpYiOp9kE5yKZfGfbTnRyTahKhIVRnCXtSZjb9YSrshdJYBrfT+nlloAjzbR I9XYU6tmODuqW5aasmFc+AgZlEPvV6mqtYjuurlpNEw2Vx/OTez3Pw5cxhBkf/+jbViKME81o2Eq TWllGUgN6Og8PMDycqWHpl7OTL1/29HsTmRBaoj+8sA4LQZRwypxiT6qcrz5gnPeiFZUDaUZY2hR SpRgWtkMUCSVo96fcVvrbXL90Ft4/5NcP//WAh6uVGq6j3H5fZaK8GpHut3F/Cqc0eGzU58yjVNU njHsPRA9sJt5WoM+gDsk6Y9wB2lnrg3Ph+AifeSB60i4TguvuEdA6u0Z/PiovB1eUS/W8O71a8Ml C2aapa+ULEV/GKFQ+16X8oCS8xMd4DXgosO/3pA/whGKoXVs0hlTLrHK2WnO8H728BEssiE6j5ov PMAkPkrgFYfKxp6AYvoySxcp13mSh7x/gZyEoI2rM/nJA8tTSxM+lg8x2tG1v+X4zTypqeAPPYyB QcVFliTs7/TOo8CSHYmeBimc4iOf4B/NvlH3gxq/sNaD3k8J8gF+r5QtH136OSlag5tTXXV/Jvsf 8nFqkObNTGl+u5pNeIWfr5uZWTWbZkDGvjZB9CLukTq6njXxsnh4jxsV3yCqV0Us9V9ZsOMwrJeG qM5/oRgg989YzT1i3zJqS1rqRJmjvqQn64J7vBKNWW55OBMVBxyylMBYS7eqlYGqJxXWlmvCxErq fa7T5KcqhlfNeB+Z5Z6YcbIWzYey5Vzslkusji6kA9XeHg2j1MQN6z3kNvOFjf/rQxJaL395Wd+E qu1o1KdHmXxxMLhItZ7KFn+8+B9QSwMEFAAAAAgAAq6jLhnOlI8iAwAAexoAADgAAABvcmcvYXBh Y2hlL2NhdGFsaW5hL2F1dGhlbnRpY2F0b3IvbWJlYW5zLWRlc2NyaXB0b3JzLnhtbO1ZTW/bMAy9 91cQufQ0d7unKdKvrUDXFnOwO20ztjpZciU5bfbrR8tOZ+drA9Y0a5ogCByLlB4fySc56Z885RIm ZKzQ6rj3KfjYOxkc9POIUNkPCdnYiMJpYwcHBwD1fVCY03HvFK2Ih6XLSDkRIxv12KR5zTz9rEMF HTtAlcB3lBMCkReSch7ByhT0GL6MRndwOgyvztpOPNieXecoeOIzdCiFwtZQanRZHPf87K3bblow ZG3SAAuMMwrixjXANrJgSVADP4v/6KNzRkSlI/5Ss4Ay1Ua4LG8t1oBsUzDKCHKyFlOCRKRkHTx7 gtMQEZSWEnjkhSElRYZjVilY9qmIEUkFaCw4UQsL1bHd4wQDiSoNQsao0t7RoDGch14Djysa1oMO M11KxkTgjaFFFUO941ViUaC0IMbAI2DooawiExYKNK7KJleLT2gTx8kK8JHWkitrNeYZ3bFEa2/4 cj3yy1LKKTyUnGLmLAHv5qeoQFVYc1SciwR0dE+x+1tO580eOYGEkWTbMRNBfyI9oahcnGWhUrxZ WuU/IYdCgqQJSRhz67iM2Y11XmjFqViBW/DIke/YJRjYzehiuh7FEOqIQSjhBNP4s25QzitP4sjU 5cqVy0VgCC15VqGZfMbynDff1aUBw/2vc1Aly4mZVXtHPtrBLC/s/pHXouqyfne06dy32IbE6fzq 80U42oY6LQtruTztxWkj4rRzsgRbEab61iosuyhQHXW61CZ/eW26vP32tTo4XZxvQ5oWY9q5cxPs xWlT4vTeZel/UKUbra41k/jCyuQydMA9EP+woBVXmKW45BKYclaUdYb1yHGZaS5+NdFyUpHHHJl2 z7yWiC2nYH/C2vrj35sVsvfx2Lcl+ZpXsJDtJIUiVbcdvehGWKuUlyVbFoU2LD8Ih9Y7g2VvrQ5r CaKngowgFbcrbnPy08G//vj0xn8H8YLyW0HewGFqq+eR57Jv/Qg7q/nw+uUfJbpbb90rpRPc0WSB V4SYTLUdVRmwXg3q/Yn3dMnt4nz3tLO6wZ6Zj39V6vY79at0yH6P/odHjR3dqZvruf+TfgFQSwME FAAAAAgAU7SjLspV3K+SCAAARhUAADwAAABvcmcvYXBhY2hlL2NhdGFsaW5hL2F1dGhlbnRpY2F0 b3IvTm9uTG9naW5BdXRoZW50aWNhdG9yLmphdmG1WH9v28gR/d+fYmocEDuQqTh3bS92EoSWaJuF LOlIymlQFHcrciUxobjqLinFKO67982SlChbSQ5tyiA2w519O/Pm56b7/Iie0w+3UiRSX1B3oZay G6/Nqpxmadz9KD4JXYizQi1jUZzhr8jSXHS3L0bHXbMQWnaVnnfFSsQLuVsVZbGQeZHig9LdocoH ap7mbvur81GsRWdN5479Qy9fvHjZffHX7vnPdP6Xi59+vnjxkrRcLsn7vKIfrLKBXKcmVfnFdlP1 vS8KeXEQgNdZ5M13eGqoaCHJteZSqGbFBhTQII1lbmSH7qVmBVm/WrynVg86nS8KOolP6fzVq1cH Ea5VmSeiwF6HyM0ysnsMI2hppF7LxKkRA5mkptDptGRxEnlCpZGU5mRUqWNpv0zhBf1AM6WXpkOb tFiQ0va3KgtGWaoknbEngNEhVmEl9TItCpnQSqt1muClWIgCPyRwskxt0nxOscqTlDdZ3XjfUhYX tWrnziPtDKlZo1asEgiXpoBFhYC6DCymas1LNUkMgidXCBLQWSxSQxnwGGZ3srVwXy0cGmciXUrd 0PTyqS44s8VLowusTUro9/9RB4fWKCyRqLhcIgVE4zpkDymsaFoiiHUqMrOj37oNizVA25jGyh8d G04yT84QBPrRAWkeZ2UbCea2UTqUzmpwkT90KkbqTY8sEvGnXG0yOZcMf1HvwnMcMSsVidvNBk6v IzuRa5mpFZSYPrSM4efLSUAni6JYXXS7m83GqYqLw3Xm1Dmu97sZ6MrBWfZQO2ZfQ/D5QGK1koJd YI3ZqpQWRmazTo2UzqwDN3ACVNVkypi5SnVytkINfHgEbBAOeimyrIFvXPFT5YpcLGH+Mb/+rSqi NNbqo4yL4w4+23qKNz7y+BEBtUI7Go4rjyD+aCo5yxFnip2tNDIeoQPal6qQDf0GbOsUtaJGmmG5 Imdre10CsCPlgqA54/Mq942x5ed6972G2a12aJVJYThFEGPwd+WbdzsXNWz82WGz95Q6pA57qTYv BqdyS0rjZ5BthZrP+z5Ndc33QbOeqM95W+yq741W5apROLr1QwpH19F7N/AI7+NgdO/3vT799psb 4sOzZ+QO+/j7gby/jwMvDLE2Csi/Gw98r88Y2Bq4w8j3wg75w95g0veHNx26mkQ0HEU08O/8CJui UQfHec3O1jYGGV3TnRf0bvHFvfIHfvTBnnvtR0OcSdc40qWxG0R+bzJwAxpPgvEo9Ahq8/a+H/YG rn/n9dFJ/CEOJu/eG0YU3rqDgT3XHbs9/Noaez2aDPtu5I+GsIcx/Cik3mgYBT5UHwUhXXlQ3r0a eNXxoKDvB14vYjN3bz3QBaUHNrPCsdfz8Q6yPNjpBh86zBZgQ++XCeSwSH33zr3xQjp5yhZjtAmD O3qTwLtjU0BROLkKIz+aRB7djEb9kLFDL7j3e154SYMRmBpdM8Yk9Do4J3Lt8UABkZDA+9Uk9C2l /jDygmAyZgZO6Xb0HoRBU3fCHgb31itDazboGwUfWAHmw3qnQ+9vPXwPmG3Lmst0hGCvF7XELEoA W4KoZS8NvZuBf+MNex6vjhjovR96p/CnH7KAX5383sWxk6iOEHYj1KteW4Hbsc4m/5rc/r1vI7QS RoiEfh1OFTHhpHdbO4Bz4PvOSO0cR60waDp2FlirrETlQAvmCrJrzUuModwgluhDjJCiuaIJltwP kbdTuRDZ7FH6Hh6euHwtVVVM05wbfdVRVP6NvdvaZqTd/PpwC3rbFIx/uEk1AIisnhAM91O02H+V qa76XVWOMjse7k9P/6xQukdHR8D+JOZcz+fNQc0g7ewN0pcQTpcrpQvi4dlJleOPvM+xXDHk5d6a kXGJKvjgjDV6croS2d76Z4eHykwWDlvp3OJHWH0IoL40xR+WNitYI7fih4xg+cewX5b7A4CBFNny qxKhtAX/qzKJXGXqwbFXk57KZ+mcCT7qPrfudXN6PX27d2V53Z2+tY0bC/ciW0v7ASdkcjdz2ZkZ 58Sf7ISscgwKjTNsKhQaw68dI3hcQkKsOTLs9NbydmvGe8efEUY9bJxT4NBd3MtELhbCdrh36/rS ceh+9K3LEeKvuvHRLOVAxtRqDB28sB1xL5Wf0VcTQ3srV5w1/wZ1LNHt0tl/85APakSOQfxeYA6e ZtI0iOwQftDcpIl1inBfy73kxtxeFtVose8Op97Ztb+RjmvQQYYXG5NDlCE4gOHoTSWO5/ib2egc ZKl77rw4vvwfuWgeHqEwvRTpIS4CWZQ6x3D1TUpsrH6dmCoGairmsvCBdHLKTm0I0dVxJ4zo8EGn l9Xi79/BWBpXCtxJRHpywNgWx9XNxObLUnxifa2RuiowHZoKnpPrcm9WMsY9lyfiCihjj3EeIt1L 3TSNmsvXfEd9W+gSmW1fq8vBw1OYXSLTQhj0JwzRBmiGhTo8mldYMzSwNthGQn4ttzBaCr5xC77l 27qH0sFzcI5+IDKsJg+Np5o973ArEcvGXqoLKyPbW7xWMde+fP5Evj6gqbDNDqvDU/mKqMFTuuqI mzLzC7V5VLQalL3HYDbPEh7yEc0colsit4fKpo1Rq6VV9COsV2XRRTjjF0mt+c4co6KaQzE8VQpt PG+rJU9aHWgbKNvI/tLTbkdb+r69rdVPauJOt3uKhVYbs2diK8WQQb6dcPiOigstsRszBHE6z88g aqqmxncfOZvhRtmh9l5UbhWnVYLsEuKZ2e6z/wuQFpjMyI5Zu61wNleLTZplJCw0yxVK7YSe18UB h/gJvaGT6t+nzTkOqsYQd9GTnrKFvDBO4P3yaxiO/P6vmOc91IsGDG49qXD+9IbyMstO91jdGlIJ dbgg1Q39ZJvmnKWnp5e18/nZg0/ktJzT2zd0vo8NS0+OJ0+bLRPOHbmZ3o5b6m5LHx/Zqnq/H/0H UEsDBBQAAAAIAO+toy4CdwdgUBkAAOlhAAAzAAAAb3JnL2FwYWNoZS9jYXRhbGluYS9hdXRoZW50 aWNhdG9yL1NpbmdsZVNpZ25Pbi5qYXZh5Txrc9tGkp/Xv2Ki2orJmCZtX67u4kcSmoIt3EmklqDs S7lcDgiOKNggwAVAydy1//t1T88TD5JWlKutOlQlgoGZnp5+d0+Dgx/usR/YX094uOD5Uza4ylZ8 EF0X6808iaPBx/BTmJfhwzJbRWH5EP4LkzgNB/qmyKNBcRXmfJDly0G4DqMrbt6Gm/KKp2UMD7J8 EMTpMuFBvEwnaf9jeB32rtnj/o/syaNHTwaP/nPw5Ef26NHTx//x9MkTNs/mV8z7vGZ/FfhN+XVc xFn6VEygZ8dhyZ82Tsb3OOTFHVwS1OyKs6HYHQuyy/IGdsxO44inBe+xNzxH5AC3x3L4KFtv83h5 VbJO1GWPf/rpp4eA6ONGMK+yTboISwDQZ2yYJExMLBBMzgueX/NFX4Kd8kVclHk83+BwFqYLtik4 i1NWZJs84uLJHCifb9lllq+KHruJyyuW5eJvtikRyipbxJfIE4DRY4jCmueruCz5gq3z7DpewE15 FZbwPw5wkiS7AdaxKEsXMU4SuOG8FS+fStQe9yvYFSy7VGhF2QIGb4oSdlSGgC4CDufZNb6SlEIg cKUZiAvQtLyKC5YAPARjVhY7dNGCRaMkjFc8V2R6UscF1rToonCB3S42gN+fgw4sKqHgiEUWbVag DKFiHWgMy+BNzlYgyXkcJoUhv2AbvJQA7M2oXf5bX4gTTxcPQQjyygJxGiUbGxJs14bSY/GlBB6m 2x5RRE6q7CiMPqXZTcKXHME/lbPgOpohVYiIenIBTJeSveDXPMnWgMR8a20Gr3YlYJ2rslw/HQxu bm76ZFD6aFu6/SM5f5gAuVKgWbKVjHExBHpuWbhe8xBZIDajUYrLgieXPQkpvhQMvAEmAKo5KzYR 0irOFw/XYPe2FcAFiEO+CpNEgVes+JFYkYYr2P4R3v4XGU52nmcfeVQe9eCxsKFwh0seVQggETJk OCKOgPyxOUctBznLkNlZDhoPogNkX2UlV+QvgNp5DLZCQrqE10QcvXdpAmBGjAYhR41PSfeLQpif V+a5BGPe9tg64WGBKgIyBvwm3vxqWKSo8e993LaDVBM6yCW5vQhoyjVRFJ+B2GKQeuzyNM4lvRu3 VUMf9bY01vd1nm3WCuHZiR+wYPJq9nY49Rjcn08nb/xj75j9/vswgAf377Ph+Bj++415/3M+9YIA 3k2mzD87P/W9Y4QBU6fD8cz3gh7zx6PTi2N//LrHXl7M2HgyY6f+mT+DSbNJD5bz1ExrGgKZvGJn 3nR0Ak+GL/1Tf/abWPeVPxvDmuwVLDlk58PpzB9dnA6n7Pxiej4JPAZo4/RjPxidDv0z7xg8iT+G hZn3xhvPWHAyPD0V6w7PhyP4ozf7anIxPh7O/MkY9oMw/FnARpPxbOoD6pNpwF56gPzw5alHywMJ jv2pN5rhNs3dCMgFSJ8KzQrOvZEP90AsD/Y5nP7WQ2oB2MD72wWMg5fseHg2fO0FrFOnFsKwCQbs GF1MvTPcCpAouHgZzPzZxcxjryeT4wBhB970jT/ygmfsdAKUmrxCGBeB14N1ZkOxPEABQsIIuH95 EfiCpP545k2nF+dIgS47mbwFggGmwwvkMNBecGUstg3km0x/QwSQHoI7Pfb2xIPnU6S2oNoQyREA 9UYza5iAMoW9TGfWftnYe33qv/bGIw/fThDQWz/wusBPP8ABPq38dgjLXsykhCAbAT26tQS3J5jN /FdsePzGFxJKg0FEAl+KExEmuBidSAagDtxtoGTrONiKApyOiAWus2QDlgNcMFoQ45pXEHqig1iB H0IIMThXcIIb9Iegt3N+FSaXFfVtDp7QfK0yMqZxio6ePEqW7pmrbVvBxeTnzS7oZ2Uw3g0XFACE iYwQCvSn4GL/volz8ndkjhIRI7rR03uCMrh37x7A/hQu0Z4v1UIqeO47wfMzGByv1lleMoyc+3HW 9yfe54ivEeQz513Bow1YwW3/PAefHK/DxH0PdE/6J2FxdRaunTef+xhuJrzsB/S3eQEzDMnUH2XZ p5jvGnEC/5MQp0AhXpQHjy7WQDADvIlOI/RHccrznaMQanXx9nEHLHsaX/JoGyUHjvKugZcHDq1R fefwU1Awvm/7p9lyuWfIlIfJas+I/fQ7iHYBFz75kDH76SYHHkSGN2FyzVFg+OfdQK9xYEHjX4Z7 tiMUSvMj2Kxx5P4ZARjBdHkWpqFgzb17gx+EdRmy5xCnZ+nyZ7H884H8F+VkBYGHoJcdFSKjZgWk 1AxDRpEH8M8Q9cQ8hbQFoYngloJgaRcYZBhgV+AGjGpIk26uMox+wZAVlxsR4BrrAzEWhJ5ZKkzj DZ9jHJbI/JFRArDOlmFJISqlNJVhhQ7EIWRDMBqXRbYC5ZXG22CAWPUqeYi0rhSJY3SMgOY6C2XP N8nP4m8S/yzckCAfxdFz4Ysu4+UGzbN0CNpyEGUxH4SEG6GHMn5k13FegidiVxkA6ZTbdRxR/A87 X4HTMAkX0PI55rk/n8DQ5wNx2+0/HwAyBikuxwhdk4No8YhwKYhKWFFZEGcwW8izRCdPtmNr3xrS 2dpfB4gbsitIbHmuAAFDu5SMYBQOyW+exwuQDCYT/yqnE8zm6huqcRrmriDJAvUh/LBCAWspD16U sGSYqzyFDW03VwC7wSlLaVFDiGZ7faSip3SqFqoDkgy8/xWnADVGeRgv2bTPzqJRAip4FYqc4ddr Wcuplpz21ZvAm1PNjEH2XxTMLnbdw02AxYHsTQolmhTxVAtRwbQBgQDSNWnsn2AccPRgwB7e5mJ+ imSPOKyex+E84YWCiCYHLypxRSJCAk7Z6HsQrYHRkCCQRbljHhZMBxpFT0H7xLc67wf5xBCBgVHd cBJ30E6V04KsQIYsxKYvZw/EX7ArJbyBUTJYkei9YCm/Uc863WfNW1nw+Wa5FBUZrDklJL8CeZGH RhmY5xT20LZonJYEBBZ81LDIMS+iPAZHfc0dpQznmI2WxgC5hqJtuQJfR4ycggDIXtBQuI72Cn/f 5thRC00SJWKMo1tVvuQbiFL1chZIYkt1QAfhtvFIi5vryKSDuoxBF3uuJEnNUEKkgIHGZVEsZFHV u/YKkyj5FIeKU0F8WZG3NhRTxqZlscsYcwSHt9Lhs2JlMdh51V/yUt52wIaj3pVF/5xWakJwpNiG K+Vi3SRctuE0z8CdgANTY1+wS9BcCHGqYIOrbJMARRWj2pQey1E5t98qCBG4JHyGgwRjkOZb4ckh kPxlD4JiVWuZF6zMNwpPQvaWBlFdWKiCaKmMmwziaw5WGcInEdAIZouoELwzkqVnV0jtyMWiA6aW NRGF0WJjC+nX9AaV/8rmWDKU9IKRAHxeIMXSUgGTBNS2tEH+qzpVkOYooVCQfs15uclT5WSRwAoP rI7uQZVIoWDpS1UsVWnOEQ4kmNiW3kRGzr4CREZEOByjr/tFQ+z0TD4TAmzwrsFy1iOkEUlXaDHg Epk6bbmjgpAqXlgoAJv1chj4IxE/vZpMzyps76JOzPPsBkK4hxBVbuZ0wFKDJlfRUEfedCaAHvuv vWBWA2tpVEW/Kfogg6M0CAzJyFWiTleM/qe2PJL/wk73KxoHtgaHfLUUzrIO/y/UYx3m4Urav7tU EbzuRE3wuktVwesu1UXgd7DKNNOprkd79aYR0O2U6TqLITyra5Ljpqpq1aRO4MDEE1ur8Kpq1pRU smyNYhuRxXgV9P0YZ3S6mDMo+I6KC4hd6US/1r0eqPUBK1f0g+JkjJMwlmqe2oSzIi0hrSNuB3uD NdBP/K0if9sgwASr7AzMWLZoCAKGiwWoeDVwTlRmJpSyKXCuEEhPoDDczA4XyjbUCQPvalW+Tu2J BudQTWPcb4Si57QLwmspCGbvalKTQRXH42pJ5l/SIwXLEPoqxFNUC1TOl3gPmtgDQv+D59nDhKdL ABrmebhF803yK9og6pSq7e3de9Tb+p6LRqUwSLdNaqfQlK+wZ2CHeJhjz1sLSC4WaZURen0HYtIG 6ABJOc/5Gg9UKCni4CpA+YU3wgJjJDLkTaErQBL9FakcPTWpnCEUo8MkGme5IXlaHF6C1Einpgtg na50bSawwJYYDqhhd8x2Fw7crC26W7BIG//DiJ3mGFcFeiN8umaPIYHLcDSCPBIF20tM3RnP8yxX wChGWedCcIrqVCE/c46kxEihVQpEKgfyXV6hq2xCy+I52Ms3YRIvRLCFLURrcZttchZt8hzXjeyE UqVzTDRMdGTa2NUP8RILuwUAvbYzEK9OscIUl3LezpFbxwgTCDMW24BWOerKGBQvW1dzI6riiKAT zIbT2Qdx3t1j6SZJrIkm07USSLxwP+Rafn7BHrtbSjLATaOxw07mYcSpaF5iuwF2pghpunvJF+Y4 xCakVKsBVpzYEhZKFRxVqVPwd9ieu5fklPOFOC8Q8SJWgHaKbbb+P5La7/5ksU2z8hYiOznfK7F2 bQavA0Q2W6+bRPbbw6RaIbo9TJKNUoslSWkWEVMiLfvFmkdY0luQj2xxg+Q/7bM/EisMGyTMHeJk Tes4MATYbkWc3uK5BGhthMaeqrYSAgg6nrltFbKFK0oSdD/wgsCfjD8cQ8IxnfzmHRMz+5A4YX5A +wSJmW3X4Ji6Lq8o/njmYHSaZZ9AsJmdn0qMMBxsCrrU+47oZduaNVSlVA14wTQ+8lXHkre9UnWe Z5jBN1AI/nHEHqgXXWtHspYNaPsoySjiloRv0wi0L0UPyzqyGNu1MigxSE7tEKiuKtriLjpmRTX8 q7MfOZkW3kN8HG8IdAzWDezSdzSVuZbg++/ZEZAExOVIcbo6s19m0kp0Wbe6J+AzTRfREYC3T8+c kQuugmPai71TxsEs1CHH6bUykh830lFIOu0E3WNN1Pyj9sNc8iik1X7IlHdxJ2cqZBKk9AFTfIDU nBHjGrsCW56LdmHSxYdYK3qIKiXPPtakE7iKPg+QVZMW86ZqKhjky6YX/eyGUy+2BlqbS50Vlcny oZwdQfBU1udG1PIgplKVTj1Rp3AgONknst0pPhejFBR1eq8crbXxdbzmSZzy6n5NZGH1KVHDLUBb b8oBcBT+UAxBtr1omF3tRKKSm9p+w+S6W6CtdWT3iqJ3j6lWFU3Enqvo5rLbRhTljEGR4Yu1z14d bdf1qPw4LsThO9DkZDY716IgzvwVUqTIazxUBh6smKXJwht11CwV94FZsbqduuzLF2dfOEFuvDaD ntdMltxynyg5htuOpqICZhkOvJSFVf82prneDcauAJp1GIZXpz6sq5VrqZ/ZPqyhcQwhFzshS+T1 Ngg23dvA1dKUJo+zkltHc1Pvbx+CYOIffxhPZl7XdeonIQbMwizLjg7KcCBCxmYLu6L6i8PZg/yx Yj4aoPvoh5GWFoEupj6Yvgfs6P5Rxd2rgReAk65RGq9XlYFdGGmszKGgi0xlDXw0DlccMWvUuaP7 IuJrp9RRRdzuREJtro2uePRJVzQqhwXUz3A4swia8hMgKRKCvQtqo1StEtVoyXlbvHsPAxRt6VVR jebk0Ob4R78UuQ9BePfovYGAeIp6bCy6H+DPczWpT+U5ePbgQZOQGLXAHuZT70Pgvx5/gDB5NJn8 t++pmEltJX5vpKFmeAyuWDvXM57VBs1BUD65j43F+dpAGE2XW4m5YaEy4bJ17E+XSztFkCcvRuca MwS7+UZDqoTmNAYZ8QaHfVNm4Aq3xGmtccKHIj+oRLD1DiMu/v8CoGafNutayKuOW4Ql9eRYmR1X xxTa/mF7WX0cboqW22Htvms6PYWB9riafGjI/ShMp86BWWVq43QFwj1qkxDRe+A3Lz0iVR9jgpss XzSqjQ3N4t+OkXgRR6eVg74aU8G47wSjrgcKUzXTsvwHAgBXIGQZMWIlZNKw+DetjRMxA685wer1 tfWNI3JUQmwbWpO89uHN62Fe1/iinXFYyxCfa2ZskTHs9/1F9NOunN5KeMeFrdoFx8ofsVouk8IC jH0p41CMO/ii2AWETqpFlpuqXEHVNAvOV/D/DZaDwAbOMa3LdgGb669IYCc9yHPuQ8q8oBWom7jl 2mfJ7UuIvSP1GLNfhnGCx1Jyz/rrvzYhqjO0/qQhbVcXbNYI+Q2EP+PJGD9gogNt7Fn1prO2mYK4 1HoKhud+pZlAJHawMIIumtMcgFFkmEYuMpx+E6YldWe6wVvj3DaAb7kNB6JgFa2m+OXizYCYKHxQ 0SwESJN0K2rdCMURaGyi7esyRtc0nLRByqsMnm/Bk5+6WqKbEOrzj+Ol1Gsz/CZOxDdAbIkFUupf wZgKIwRhf35vhHaARXFlx/1XixQBjqoOABZbpOfaddUGH4DCAcbMirIM3fQN6qBZp+p8VE4Fy+xM qHq14EHBdhFscm6djpMLyyW7uOZQOoaO6ycalHsHEDezqXi7biut9J1j7neGog2bI289zlRhJtnK PLMhCtukYMnaPSc4RxBfUdJpzk/wcoVQBo0FNqt+Hi5551FlOCbf2H5A+YUMvOsFRrywJlKpQMlC XyqOeNwyEzs4sL4n17knF9lfqWy52DlVlPZVMEMVWgM/8ONnOgQXgTg1ru2qVVplY6teRM9ebi4v sWt4LpM2+2nnyI6m3yHb/kKpjvoARGY7rHvvLwiymPfxY+p00TkyH4lgJgNjxGwhlpWhGpqVsBlm WiDf23KjSq3w3mzvDjnDZF/0jrMp3VronkO1Np1bv75AEMwcdfQj36gBssxKrixog1sdLY9SdE+7 ODQ1OZwjKNQQpN517PytVz3rcaRnb/5myAM3eM6kszU0CkQLhWrbQU8tl0NQrZmcPJzRuZeDE7xA m6HOqFBzmg4nDjo+UqdF640+Lar7EnPMgX+cDzxUcFEVHCkEDOu4segwLdXJvFpGAcFYgYH7zfAg guVAXnUeukdK/gTRMoc+1UPUPL5GARBCZh0NHS5l38QOqqE2nt/9EZGiEdrQuStXzvtQyggNJWia ZpXyLSQsCF3GVTU+4ztYdg6RJwtvwi0Ry2zDpRlV7nBx7DaTL2ulOz1a7+bLF/1Mlt/w1SNWOy91 2ECNqQ1xA5GyU6NxlwIHzaCGqMuOYZTeHK44beJL3yGa5FNBwtjfKmppGtxKR0R+rFH7ZgX4Nqtq aCABoGW975jW+0cVUVO1PTr+Eb2FosyX5RTRLER0VmXaXpXZde7eKCK3FI+vLnksbdzf+eB9Xsey Q6+B37dXp6Y6dkWTWgvZmr9P2srAvhJYweO6j8RadUV/YK+ybVT09qmP0OgDg8s4p0b/UPZ24rlm XDm6P8jU4tVsbhtw+lrF0DdVILvJxEXDgOtzwb1OsywAPEzinjI2SmIuvt1GM1li4rzOCoRDLUNJ zUBQxtCzQWHBKC4p7RYtZrg3/dmzSBxUkQGARVz6Z2w5ztKlUnsmi12mjN5qzKbNpswuussOzcav TNQEBY6+gW05VzK26vYWrmLf1EyTCg4NmuI40rxRn8togIsKEF1KHbp1FFGxUp0ElbKT6W+sLFeB rYrb7ELdtAIUY6v7k7VwSAfkzUHTreC6JeoxjNaY91S+pujRVFGTQ0zNXj7QRftvcifTvc5EyJSg ML6oIdRUgW8ursPjWslcgzvAe5CPECE3UVBkq1Vf0rGouYuMey9DYHMcckBwPyxLvlqXRb0oKKvX DT/UsLG7cnAMrijVSEgsOm6FRfXrWwow1AFV5XznEGFRW9I3BlaxSUp9yFUbp2+MKNPy5t/142ZV FMDG/hSBi5Nm+bQasMpBLWdpgoa4JPz/hQRIHQrwpFPxRfLwC4aq7rvvvzcEbswY8apvSADpO1Ru EJVGj6UJ2qmCVetLItdJLKsdBOGZlD09goTw1p8rnesvpFtrHacZfm65Ap8qflaKHBz9+E/NP2Fd zfqJkJgaSFs8jwJ5Jv9SRpkg5GouqZAUVhWtlxRmCcIxfBK1hP68YE6NiV5WhU2ObRQFetfHRcVn Y1ZBDUzZUxGbKTQM1NqRW7AFW7vqZ5tS1HLLJD0EnOT2vxRP1FDRo4Y//GG7f+62uh/KwB6baWga 7r8IV3sWRi6DK0bpdiy2IeiFCEBQhtGnGX4L0jGwGz1RXT7stE9/+ilr+LbnlC0STW0eCpgMDkSY KYoTpfj9Jyw/p+AbxK8z3cSi6VGsRG4OaS693O0jz4T20SJM9exUlnJac+wDYg1VXG7PVUWjuADd zAv87w91Ngu7TM59hMev4pck9C95Kb9PJ7P6F6Zww8hL7MGysxDREu60XqDPwnoH0LP+w0JER0ky 9yhBh3DKtTeM0TFz05iGuLcZVlNKLkI+eiDayhoW1z69Caj5tLrSQ8PcD2IUyFp0eduo3bq+JSYr NmvXpAlbYhNO31fGWHxSt5URFqHUbXUdw0d1WxnRREdn99bZq/hI/8OZNzuZHKtmPX02WiPZly/M TMWv+ttmdlU0ZDPOUXH1zbOqyDqWD3S4sQKt8PgjhR5VuXnxwinc1Pba3tOsEKO4r64D1eLtA/bY amKU/kJ874w/QK5LNT32qKdgivsKHOeYjVaujBD1MXpkxprysppWe2cdwegvgYEFBzLRrazv4Jqi z3uWWkjtotxDh3Iu13vs45/HfIxh4rTa/qDRfvfxwQOL2G6XqhEUe5fqfi9NDZXcMqe1G+cnHhRg w62v9/4XUEsDBBQAAAAIAHm/oy5NsbHgBQwAAIUhAAA3AAAAb3JnL2FwYWNoZS9jYXRhbGluYS9h dXRoZW50aWNhdG9yL1NTTEF1dGhlbnRpY2F0b3IuamF2Yd1ZbXPbxhH+rl9x5WTGZEKBUtJ0atly DZGQhA5FKgBox81kFBA4kohBHIoDKKuN/3ufvQNIAKRkN06/FDMy4XvZ2332/TD4+oh9zb665n7I szM2WIk1HwQbmRbzOAoGv/rv/Sz3j3OxDvz8GH9+HCX+YPsis2AgV37GByJbDvzUD1Z8N+sX+Yon eYQBkQ1cd2zWB4xf/Y3f37BT4y/s25OTbwenp4OTU3b6/Ozk9Oz0r2wu5itmfUjZV4pHh28iGYnk TG3QYyM/52cHN9M8LTn/A56SlLfizFQSMlcs8ntIzcZRwBPJ++wNz4g58HZaLh+K9CGLlqucdYMe GHv+/CCFS1EkoZ9jr8GYGcdM7ZFEIeOSZxseGiVFh4eRzLNoXtBy5ichKyRnUcKkKLKAq5E5gM8e 2EJka9ln91G+YiJTv6LIicpahNGCNAAafUYspDxbR3nOQ5ZmYhOFeMlXfo5/OOjEsbiPkiULRBJG tEnxRvvWPD8rWTs1WtxJJhYVW4EIsbiQOSTKfbBLhP252NBUCRIRwZMIGAfgzFeRZDHoEZndyUrC Jls4NIj9aM2zCqZv93nBmTVcKl4gbViAv/8NOzi0pEIrQhEUa5i+X6kODsMEZjK2hhFnkR/LHfxK bZgsCdSFqaT8zlDmxJPwGEaQtQ6IkiAu6pQgbp1Kn0WLkrifPPQ1IuWmlkR+8D4R9zFfciJ/Vu7C 0/EIFQ3idrOE0kvLDvmGxyIFE/OHmjD0PO4ErLvK8/RsMLi/vzd0PDEotPSMTrnfjAFXAszih1Ix TQ6B5wPz05T7pAIlzJalKJc8XvRLStFCKfAeSgCrGZNFQFhFWXicIuw9tAhLmEO29uO4Il+p4s9a FYm/hvgdev27jpvsNhO/8iDv9DGsQije6MhOC4CSoR0MHa0R2B+bc/Jy2JkgZYsMHg/TAexrkfMK fgm0swixoqS0wLQGZyt7GQKwI6KAkJHHJ9r3pVTh53I3XpLZzfZZGnNfkovAxqBvrZvXOxVVaHxv kNgNpg6xQ1oqxQuAKd+CUukZYKtF1XBTp1FW4n1QrD32yW/zXfS9ykSRVgx717bL3Oml99Z0LIb3 W2f6xh5ZI/bLL6aLgWfPmDkZ4e8ds368dSzXxdzUYfbN7di2RkQDWx1z4tmW22f2ZDiejezJVZ9d zDw2mXpsbN/YHjZ50z6Os6qdtW1EZHrJbixneI0R88Ie2947de6l7U1wJrvEkSa7NR3PHs7GpsNu Z87t1LUY2KbtI9sdjk37xhohk9gTHMysN9bEY+61OR6rc81bc4ifrbCX09lkZHr2dAJ5iIbtuWw4 nXiODdanjssuLDBvXowtfTwgGNmONfRIzN3bEHCB6bHyLPfWGtp4B1gW5DSdd31CC2Rd64cZ1mGS jcwb88pyWXcfLaJRBwzqGM4c64ZEAUTu7ML1bG/mWexqOh25RNu1nDf20HJfsPEUSE0vicbMtfo4 xzPV8aACILEC7xcz11aQ2hPPcpzZLSHQY9fTtwAMnJoz0jCwV1qZKLEB39R5RwwQHko7ffb22sK4 Q2gr1EyCwwV6Q6+2TFFxIIvj1eRlE+tqbF9Zk6FFs1Mi9NZ2rR70abu0wNYnvzVx7MwrLYTUCPb0 a81w+0rZzL5k5uiNrSxUL4aJuHZpThoYdza8LhVAPvDH1kh1H0eskEg6qhbYiLhA5EAKpgiyS81r VJ6UINbIQ0QhQnJFEiwoH8Jv53zlx4uW+x4unih8rYUOplFCiV5nFJF8Yu82tkmuNr88nIJeVQHj JzPUBYAflxWCpHyKFPvPIsp0vtPhKFblYbN6+llTGRwdHYH2e39J8XxZHVTVzkajdn6BxdE6FVnO qGg2ImHYU+tDwFMi+aIxJ3lQIAo+GLcZcnKU+vEj8wHPcuPH70+eD/GiS0LeWPrBoPoz5rlBgBjX +MfVAw4k5TL/7NUyheA74ofkvYrFHDp/cg3RbB/9+LrPOHQcLXjwEMSfuWof8UPLHe7H6ydXuFwl pSfXhDyNxYMxFssoGYpkES3JCI4GXysTNBP2cv6q0U69HMxfqeICE2/8eMPVAE6I+a4uhB/VDAsj REwV+3DHOPoXEiraNBbsLEJS4YGiFDsW8N04ohKLKk5ZucNroghjH2Z+tGSOwW6CYewn/spX1F9v ytao3cF9qn2Dh+g2FKf6UjHWEPiIUjz/gHQfStaYuSBn/jfQohWDATv+koeqmZTw4LKiSDqgBzmX yyCLYBMb3og5aCeKXFc8TQ0Y5c6B+kX1lqM+RMiQNB2wRURBxUV8RMwgguxcb8DT+WSYMNoQDU6N k86LfbYdnhdZgvLsk9wrS3paBq2jkuclz21Q6vYI/4rzTB/XJYoGHdR7oSc//gE6YreagRsOKwwP 6KiGiO5tVL+EGA0gg/fENCRXE/wDshVP0BKSn9S9oKIVrKh/7d6vIrQKEoVnHLKVD4TmHMW0ymVk 4/NY5TSfGjFoVlOsaLykfvhVLejK0l1pvKcbBJHq/EK9hlQ8+izP0BJURJAukTkycs4NLCHUssGP 77leqNVHolbqqra+RnPjr1W2QiBlZUCljeoyIBMBhadkubdeB1RWRdZqR5BxmMXe+pgiF1Pxi7If AliRafPSZjcnqVbifi8gaSqNp0R6ru4qyE6p0WkKxavYzGqZUbd4UEJa5APYNH4YzzJqvQNkQXnI kOdCoBpI6mzxbi3zVMD1t+b92FNPQ1v4Pr2tFvJL4HrbPfkqE/eyIWLNz+BGDl+gm4XBqbgt5tR+ StLUfRSjWuEINTHdN2z37Gd1toKEtbhDT3d/Wa8Cwlhux7pw7IOESxBAWT5JWa/rbdHStPV7nXhd 5GvyP7LFGIYYPjQUh8Aq1lwk/G/bHduyiGq08u1cyUyHzeAw2xX1E2FJ3d2GP52zpIhjinKs9tCi kM+LJXt1zk57jTl64BPdjnmQz2cd9s2OI2Jlgv4WcfQb1nnWqTFCTxlspRR2COa7+v8NjUyQWbqw Igo/uTQc64c7153aozt0WFaLHLGtaVVy7XGOBCyCiFxBLexToC/LmG7lEBR4eK9FGwoSCcJYmQPo roXOq2JHGRj0/UYnUCX6FgXZMdp8tGmjEIJYrRjC5j7dmODlwnTtId2XoHu9YRF5gv++Zv0lFUTO pLxLqqfPPqyHRXkVfui6QqCayVAOYbhNpEhiAHKADDKE1AkC5HYS76kAkA4JgG5vH/9tCiWIdwh/ bDk/7IBvdJarZa8ybek0B+50Fdcw7cesVlksQpJQSahIG6Vhp8rjFZUOmk2vY8AeoDx7maAbG0IV 3cq7dI6GfG3HAfNDH8lKUrvqUfql65641OfgwzF6sWMK/MdFFiO8iVBbzJwCqx/228QyvhYbdR+L QklfP8F+3/OcVKDypE7vSPnAJlnSJRSMk66Ykj0bg2QUONVFfHPGVA0nfCHhGaKCRI+r7I+QRvJW wkgyu0CsiZuT0+OJ2BxTxas+bzToVSDdUvrkiNE3fto9rOtW16ZEkT/9TKGgNfXTz72Dh5i57sF5 t2y8jKHlePalPTQ9y70zPc9pBb+uOoSdV5Hvt9+YHjKgkGW+Yi9hO229lns+ydbTrKGsvaux1+bu 45fz+VmBm7GJaLZG7Wt2aLoMhu2ITZkPDXISWlR+HEp6hju8uzBHdw5dkrnek3WCXBNQOup3O80e oOmgLTaqMLIArI/Hkb2KWaY8AE0IuhdVtvvq2ZSueNCZ6eyNbrjbMxrllNLHo8n1/AuSK2PqwOZx vVJuuokmwX+fcmYTc+ZdTx37H9bod2unSHS3jFY7/J3aUTlCqWUHWbe8foLl8bCnWoiMByIL99LR tsRW5y2p4cl2GXxbpe5o99muiiAnvLuxgMIhBEhpfa26F7UzGolLjX9x28e2VzKPt312EuWRT3ca +gMcEgGVBdtaWH1Xqbq/8l4DyX37bbSiQ1jWrb5styjMd1V78dDb67B2zcj+3RHZsc7CYg2s6diQ 56pMR6aivl63KBUxna5S+kRF36BaW1Vqm3OVnOW2K2o0NBsRqfuFDOV51UAcYKvWR8gCbZZRbmnr bIfwJV1WHMJXfa96BFbCsyLw/wCrSP9bVEXaAPXj0X8AUEsBAhQACgAAAAAALI+jLgAAAAAAAAAA AAAAAAQAAAAAAAAAAAAQAP9BAAAAAG9yZy9QSwECFAAKAAAAAAA0j6MuAAAAAAAAAAAAAAAACwAA AAAAAAAAABAA/0EiAAAAb3JnL2FwYWNoZS9QSwECFAAKAAAAAAA5j6MuAAAAAAAAAAAAAAAAFAAA AAAAAAAAABAA/0FLAAAAb3JnL2FwYWNoZS9jYXRhbGluYS9QSwECFAAKAAAAAAA1taMuAAAAAAAA AAAAAAAAIgAAAAAAAAAAABAA/0F9AAAAb3JnL2FwYWNoZS9jYXRhbGluYS9hdXRoZW50aWNhdG9y L1BLAQIUABQAAAAIAHGvoy70eL0CaR8AAEl7AAA4AAAAAAAAAAEAIAC2gb0AAABvcmcvYXBhY2hl L2NhdGFsaW5hL2F1dGhlbnRpY2F0b3IvQXV0aGVudGljYXRvckJhc2UuamF2YVBLAQIUABQAAAAI AK8ApC7FRcodTQwAACglAAA5AAAAAAAAAAEAIAC2gXwgAABvcmcvYXBhY2hlL2NhdGFsaW5hL2F1 dGhlbnRpY2F0b3IvQmFzaWNBdXRoZW50aWNhdG9yLmphdmFQSwECFAAUAAAACABEAaQu+K5tycQS AABiQQAAOgAAAAAAAAABACAAtoEgLQAAb3JnL2FwYWNoZS9jYXRhbGluYS9hdXRoZW50aWNhdG9y L0RpZ2VzdEF1dGhlbnRpY2F0b3IuamF2YVBLAQIUABQAAAAIAEizoy5oGcUNrBMAABZJAAA4AAAA AAAAAAEAIAC2gTxAAABvcmcvYXBhY2hlL2NhdGFsaW5hL2F1dGhlbnRpY2F0b3IvRm9ybUF1dGhl bnRpY2F0b3IuamF2YVBLAQIUABQAAAAIAAKuoy4ZzpSPIgMAAHsaAAA4AAAAAAAAAAEAIAC2gT5U AABvcmcvYXBhY2hlL2NhdGFsaW5hL2F1dGhlbnRpY2F0b3IvbWJlYW5zLWRlc2NyaXB0b3JzLnht bFBLAQIUABQAAAAIAFO0oy7KVdyvkggAAEYVAAA8AAAAAAAAAAEAIAC2gbZXAABvcmcvYXBhY2hl L2NhdGFsaW5hL2F1dGhlbnRpY2F0b3IvTm9uTG9naW5BdXRoZW50aWNhdG9yLmphdmFQSwECFAAU AAAACADvraMuAncHYFAZAADpYQAAMwAAAAAAAAABACAAtoGiYAAAb3JnL2FwYWNoZS9jYXRhbGlu YS9hdXRoZW50aWNhdG9yL1NpbmdsZVNpZ25Pbi5qYXZhUEsBAhQAFAAAAAgAeb+jLk2xseAFDAAA hSEAADcAAAAAAAAAAQAgALaBQ3oAAG9yZy9hcGFjaGUvY2F0YWxpbmEvYXV0aGVudGljYXRvci9T U0xBdXRoZW50aWNhdG9yLmphdmFQSwUGAAAAAAwADAAuBAAAnYYAAAAA --=====================_9094196==_ Content-Type: text/plain; charset="us-ascii"; format=flowed --=====================_9094196==_ Content-Type: text/plain; charset=us-ascii --------------------------------------------------------------------- To unsubscribe, e-mail: tomcat-dev-unsubscribe@jakarta.apache.org For additional commands, e-mail: tomcat-dev-help@jakarta.apache.org --=====================_9094196==_--