From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.org!not-for-mail From: Paul Eggert Newsgroups: gmane.emacs.bugs Subject: bug#8525: Lisp reader and string-to-number bugs and inconsistencies Date: Thu, 21 Apr 2011 13:05:51 -0700 Organization: UCLA Computer Science Department Message-ID: <4DB08E1F.9090206@cs.ucla.edu> References: <4DAEA71A.3090503@cs.ucla.edu> NNTP-Posting-Host: lo.gmane.org Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="------------080604020806080108020707" X-Trace: dough.gmane.org 1303416462 7014 80.91.229.12 (21 Apr 2011 20:07:42 GMT) X-Complaints-To: usenet@dough.gmane.org NNTP-Posting-Date: Thu, 21 Apr 2011 20:07:42 +0000 (UTC) Cc: 8525@debbugs.gnu.org To: Stefan Monnier Original-X-From: bug-gnu-emacs-bounces+geb-bug-gnu-emacs=m.gmane.org@gnu.org Thu Apr 21 22:07:38 2011 Return-path: Envelope-to: geb-bug-gnu-emacs@m.gmane.org Original-Received: from lists.gnu.org ([140.186.70.17]) by lo.gmane.org with esmtp (Exim 4.69) (envelope-from ) id 1QD0A3-0004Iv-Dh for geb-bug-gnu-emacs@m.gmane.org; Thu, 21 Apr 2011 22:07:36 +0200 Original-Received: from localhost ([::1]:37537 helo=lists2.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1QD0A2-0001Zt-R8 for geb-bug-gnu-emacs@m.gmane.org; Thu, 21 Apr 2011 16:07:34 -0400 Original-Received: from eggs.gnu.org ([140.186.70.92]:51222) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1QD09y-0001Ze-Jo for bug-gnu-emacs@gnu.org; Thu, 21 Apr 2011 16:07:32 -0400 Original-Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1QD09w-00039B-Ln for bug-gnu-emacs@gnu.org; Thu, 21 Apr 2011 16:07:30 -0400 Original-Received: from debbugs.gnu.org ([140.186.70.43]:41098) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1QD09w-000397-GY for bug-gnu-emacs@gnu.org; Thu, 21 Apr 2011 16:07:28 -0400 Original-Received: from Debian-debbugs by debbugs.gnu.org with local (Exim 4.69) (envelope-from ) id 1QD09W-0001hg-Qh; Thu, 21 Apr 2011 16:07:02 -0400 X-Loop: help-debbugs@gnu.org Resent-From: Paul Eggert Original-Sender: debbugs-submit-bounces@debbugs.gnu.org Resent-To: owner@debbugs.gnu.org Resent-CC: bug-gnu-emacs@gnu.org Resent-Date: Thu, 21 Apr 2011 20:07:02 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: followup 8525 X-GNU-PR-Package: emacs X-GNU-PR-Keywords: Original-Received: via spool by 8525-submit@debbugs.gnu.org id=B8525.13034163696486 (code B ref 8525); Thu, 21 Apr 2011 20:07:02 +0000 Original-Received: (at 8525) by debbugs.gnu.org; 21 Apr 2011 20:06:09 +0000 Original-Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1QD08e-0001gY-RC for submit@debbugs.gnu.org; Thu, 21 Apr 2011 16:06:09 -0400 Original-Received: from smtp.cs.ucla.edu ([131.179.128.62]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1QD08a-0001g0-86 for 8525@debbugs.gnu.org; Thu, 21 Apr 2011 16:06:06 -0400 Original-Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 4A2FA39E80F0; Thu, 21 Apr 2011 13:05:58 -0700 (PDT) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Original-Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id TKdYmow+E0jO; Thu, 21 Apr 2011 13:05:56 -0700 (PDT) Original-Received: from [131.179.64.200] (Penguin.CS.UCLA.EDU [131.179.64.200]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 5EA5B39E8083; Thu, 21 Apr 2011 13:05:56 -0700 (PDT) User-Agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.15) Gecko/20110307 Fedora/3.1.9-0.39.b3pre.fc14 Thunderbird/3.1.9 In-Reply-To: X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list Resent-Date: Thu, 21 Apr 2011 16:07:02 -0400 X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6 (newer, 3) X-Received-From: 140.186.70.43 X-BeenThere: bug-gnu-emacs@gnu.org List-Id: "Bug reports for GNU Emacs, the Swiss army knife of text editors" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: bug-gnu-emacs-bounces+geb-bug-gnu-emacs=m.gmane.org@gnu.org Original-Sender: bug-gnu-emacs-bounces+geb-bug-gnu-emacs=m.gmane.org@gnu.org Xref: news.gmane.org gmane.emacs.bugs:45931 Archived-At: This is a multi-part message in MIME format. --------------080604020806080108020707 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit On 04/20/11 06:08, Stefan Monnier wrote: > We want to use floats rather than signal an overflow (this is evident > from the history of the code since the conversion to floats was added > somewhat recently). OK I came up with a revised patch (below) which does that. I want to test it a bit more, but thought I'd publish it now. A couple of things: * It's easy to use floats for huge base-10 numbers, but there's no portable and accurate way to convert huge non-base-10 values to floats. This patch still signals overflow for cases like (string-to-number "ffffffffffffffffffffffffff" 16) where the integer cannot be represented as a 64-bit number. This is the best we can do easily, without going to arbitrary-precision arithmetic, or without having some rounding errors that I'd rather avoid. * This patch uses strtoumax to get the widest available conversions for non-base-10 integers, as the result can be converted to float easily and accurately. strtoumax is a C99 function and works on standard modern platforms; for the oddball exception we can use the gnulib substitute. This part is a one-line change to Makefile.in that drags in a bunch of gnulib code, but this code is well-tested on old platforms and isn't needed on new ones. I've attached a gzipped patch for this porting change. For Windows, the implications for strtoumax are that should exist, and should define uintmax_t and strtoumax. If Windows doesn't already do that, a simple substitute inttypes.h like the following should do the trick: #define uintmax_t unsigned long long #define strtoumax strtoull or, if Windows doesn't support long long, then use "unsigned long" and "strtoul". Here's the patch. I'm afraid that it has to be applied by hand, as I hand-mangled it out of a bunch of other patches. If you want something that applies automatically please let me know and I'll generate one. 2011-04-21 Paul Eggert Make the Lisp reader and string-to-float more consistent. * data.c (atof): Remove decl; no longer used or needed. (digit_to_number): Move to lread.c. (Fstring_to_number): Use new string_to_number function, to be consistent with how the Lisp reader treats infinities and NaNs. Do not assume that floating-point numbers represent EMACS_INT without losing information; this is not true on most 64-bit hosts. Avoid double-rounding errors, by insisting on integers when parsing non-base-10 numbers, as the documentation specifies. * lisp.h (string_to_number): New decl, replacing ... (isfloat_string): Remove. * lread.c: Include , for uintmax_t and strtoumax. (read1): Do not accept +. and -. as integers; this appears to have been a coding error. Similarly, do not accept strings like +-1e0 as floating point numbers. Do not report overflow for integer overflows unless the base is not 10 which means we have no simple and reliable way to continue. Break out the floating-point parsing into a new function string_to_number, so that Fstring_to_number parses floating point numbers consistently with the Lisp reader. (digit_to_number): Moved here from data.c. Make it static inline. (E_CHAR, EXP_INT): Remove, replacing with ... (E_EXP): New macro, to solve the "1.0e+" problem mentioned below. (string_to_number): New function, replacing isfloat_string. This function checks for valid syntax and produces the resulting Lisp float number too. Rework it so that string-to-number no longer mishandles examples like "1.0e+". Use strtoumax, so that overflow for non-base-10 numbers is reported only when there's no portable and simple way to convert to floating point. diff -pu trunk/src/data.c atest/src/data.c --- trunk/src/data.c 2011-04-16 16:07:57.605482000 -0700 +++ atest/src/data.c 2011-04-20 14:48:29.597646000 -0700 @@ -48,10 +48,6 @@ along with GNU Emacs. If not, see -#if !defined (atof) -extern double atof (const char *); -#endif /* !atof */ - Lisp_Object Qnil, Qt, Qquote, Qlambda, Qunbound; static Lisp_Object Qsubr; Lisp_Object Qerror_conditions, Qerror_message, Qtop_level; @@ -2374,35 +2370,10 @@ NUMBER may be an integer or a floating p return build_string (buffer); } -INLINE static int -digit_to_number (int character, int base) -{ - int digit; - - if (character >= '0' && character <= '9') - digit = character - '0'; - else if (character >= 'a' && character <= 'z') - digit = character - 'a' + 10; - else if (character >= 'A' && character <= 'Z') - digit = character - 'A' + 10; - else - return -1; - - if (digit >= base) - return -1; - else - return digit; -} - DEFUN ("string-to-number", Fstring_to_number, Sstring_to_number, 1, 2, 0, doc: /* Parse STRING as a decimal number and return the number. This parses both integers and floating point numbers. @@ -2415,7 +2386,6 @@ If the base used is not 10, STRING is al { register char *p; register int b; - int sign = 1; Lisp_Object val; CHECK_STRING (string); @@ -2430,40 +2400,13 @@ If the base used is not 10, STRING is al xsignal1 (Qargs_out_of_range, base); } - /* Skip any whitespace at the front of the number. Some versions of - atoi do this anyway, so we might as well make Emacs lisp consistent. */ p = SSDATA (string); while (*p == ' ' || *p == '\t') p++; - if (*p == '-') - { - sign = -1; - p++; - } - else if (*p == '+') - p++; - - if (isfloat_string (p, 1) && b == 10) - val = make_float (sign * atof (p)); - else - { - double v = 0; - - while (1) - { - int digit = digit_to_number (*p++, b); - if (digit < 0) - break; - v = v * b + digit; - } - - val = make_fixnum_or_float (sign * v); - } - - return val; + val = string_to_number (p, b, 1); + return NILP (val) ? make_number (0) : val; } - enum arithop { diff -pu trunk/src/lisp.h atest/src/lisp.h --- trunk/src/lisp.h 2011-04-15 01:47:55.574976000 -0700 +++ atest/src/lisp.h 2011-04-21 10:25:15.716995000 -0700 @@ -2782,7 +2782,7 @@ extern Lisp_Object oblookup (Lisp_Object } while (0) extern int openp (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object *, Lisp_Object); -extern int isfloat_string (const char *, int); +Lisp_Object string_to_number (char const *, int, int); extern void map_obarray (Lisp_Object, void (*) (Lisp_Object, Lisp_Object), Lisp_Object); extern void dir_warning (const char *, Lisp_Object); diff -pu trunk/src/lread.c atest/src/lread.c --- trunk/src/lread.c 2011-04-14 16:10:48.006381000 -0700 +++ atest/src/lread.c 2011-04-21 12:15:13.973449000 -0700 @@ -19,6 +19,7 @@ along with GNU Emacs. If not, see +#include #include #include #include @@ -3005,86 +3006,9 @@ read1 (register Lisp_Object readcharfun, if (!quoted && !uninterned_symbol) { - register char *p1; - p1 = read_buffer; - if (*p1 == '+' || *p1 == '-') p1++; - /* Is it an integer? */ - if (p1 != p) - { - while (p1 != p && (c = *p1) >= '0' && c <= '9') p1++; - /* Integers can have trailing decimal points. */ - if (p1 > read_buffer && p1 < p && *p1 == '.') p1++; - if (p1 == p) - /* It is an integer. */ - { - if (p1[-1] == '.') - p1[-1] = '\0'; - { - /* EMACS_INT n = atol (read_buffer); */ - char *endptr = NULL; - EMACS_INT n = (errno = 0, - strtol (read_buffer, &endptr, 10)); - if (errno == ERANGE && endptr) - { - Lisp_Object args - = Fcons (make_string (read_buffer, - endptr - read_buffer), - Qnil); - xsignal (Qoverflow_error, args); - } - return make_fixnum_or_float (n); - } - } - } - if (isfloat_string (read_buffer, 0)) - { - /* Compute NaN and infinities using 0.0 in a variable, - to cope with compilers that think they are smarter - than we are. */ - double zero = 0.0; - - double value; - - /* Negate the value ourselves. This treats 0, NaNs, - and infinity properly on IEEE floating point hosts, - and works around a common bug where atof ("-0.0") - drops the sign. */ - int negative = read_buffer[0] == '-'; - - /* The only way p[-1] can be 'F' or 'N', after isfloat_string - returns 1, is if the input ends in e+INF or e+NaN. */ - switch (p[-1]) - { - case 'F': - value = 1.0 / zero; - break; - case 'N': - value = zero / zero; - - /* If that made a "negative" NaN, negate it. */ - - { - int i; - union { double d; char c[sizeof (double)]; } u_data, u_minus_zero; - - u_data.d = value; - u_minus_zero.d = - 0.0; - for (i = 0; i < sizeof (double); i++) - if (u_data.c[i] & u_minus_zero.c[i]) - { - value = - value; - break; - } - } - /* Now VALUE is a positive NaN. */ - break; - default: - value = atof (read_buffer + negative); - break; - } - - return make_float (negative ? - value : value); - } + Lisp_Object result = string_to_number (read_buffer, 10, 0); + if (! NILP (result)) + return result; } { Lisp_Object name, result; @@ -3242,74 +3166,179 @@ substitute_in_interval (INTERVAL interva } +static inline int +digit_to_number (int character, int base) +{ + int digit; + + if ('0' <= character && character <= '9') + digit = character - '0'; + else if ('a' <= character && character <= 'z') + digit = character - 'a' + 10; + else if ('A' <= character && character <= 'Z') + digit = character - 'A' + 10; + else + return -1; + + return digit < base ? digit : -1; +} + #define LEAD_INT 1 #define DOT_CHAR 2 #define TRAIL_INT 4 -#define E_CHAR 8 -#define EXP_INT 16 +#define E_EXP 16 -int -isfloat_string (const char *cp, int ignore_trailing) + +/* Convert STRING to a number, assuming base BASE. Return a fixnum if CP has + integer syntax and fits in a fixnum, else return the nearest float if CP has + either floating point or integer syntax and BASE is 10, else return nil. If + IGNORE_TRAILING is nonzero, consider just the longest prefix of CP that has + valid floating point syntax. Signal an overflow if BASE is not 10 and the + number has integer syntax but does not fit. */ + +Lisp_Object +string_to_number (char const *string, int base, int ignore_trailing) { int state; - const char *start = cp; + char const *cp = string; + int leading_digit; + int float_syntax = 0; + double value = 0; + + /* Compute NaN and infinities using a variable, to cope with compilers that + think they are smarter than we are. */ + double zero = 0; + + /* Negate the value ourselves. This treats 0, NaNs, and infinity properly on + IEEE floating point hosts, and works around a formerly-common bug where + atof ("-0.0") drops the sign. */ + int negative = *cp == '-'; + + int signedp = negative || *cp == '+'; + cp += signedp; state = 0; - if (*cp == '+' || *cp == '-') - cp++; - if (*cp >= '0' && *cp <= '9') + leading_digit = digit_to_number (*cp, base); + if (0 <= leading_digit) { state |= LEAD_INT; - while (*cp >= '0' && *cp <= '9') - cp++; + do + ++cp; + while (0 <= digit_to_number (*cp, base)); } if (*cp == '.') { state |= DOT_CHAR; cp++; } - if (*cp >= '0' && *cp <= '9') - { - state |= TRAIL_INT; - while (*cp >= '0' && *cp <= '9') - cp++; - } - if (*cp == 'e' || *cp == 'E') - { - state |= E_CHAR; - cp++; - if (*cp == '+' || *cp == '-') - cp++; - } - if (*cp >= '0' && *cp <= '9') - { - state |= EXP_INT; - while (*cp >= '0' && *cp <= '9') - cp++; - } - else if (cp == start) - ; - else if (cp[-1] == '+' && cp[0] == 'I' && cp[1] == 'N' && cp[2] == 'F') + if (base == 10) { - state |= EXP_INT; - cp += 3; + if ('0' <= *cp && *cp <= '9') + { + state |= TRAIL_INT; + do + cp++; + while ('0' <= *cp && *cp <= '9'); + } + if (*cp == 'e' || *cp == 'E') + { + char const *ecp = cp; + cp++; + if (*cp == '+' || *cp == '-') + cp++; + if ('0' <= *cp && *cp <= '9') + { + state |= E_EXP; + do + cp++; + while ('0' <= *cp && *cp <= '9'); + } + else if (cp[-1] == '+' + && cp[0] == 'I' && cp[1] == 'N' && cp[2] == 'F') + { + state |= E_EXP; + cp += 3; + value = 1.0 / zero; + } + else if (cp[-1] == '+' + && cp[0] == 'N' && cp[1] == 'a' && cp[2] == 'N') + { + state |= E_EXP; + cp += 3; + value = zero / zero; + + /* If that made a "negative" NaN, negate it. */ + { + int i; + union { double d; char c[sizeof (double)]; } + u_data, u_minus_zero; + u_data.d = value; + u_minus_zero.d = -0.0; + for (i = 0; i < sizeof (double); i++) + if (u_data.c[i] & u_minus_zero.c[i]) + { + value = -value; + break; + } + } + /* Now VALUE is a positive NaN. */ + } + else + cp = ecp; + } + + float_syntax = ((state & (DOT_CHAR|TRAIL_INT)) == (DOT_CHAR|TRAIL_INT) + || state == (LEAD_INT|E_EXP)); } - else if (cp[-1] == '+' && cp[0] == 'N' && cp[1] == 'a' && cp[2] == 'N') + + /* Return nil if the number uses invalid syntax. If IGNORE_TRAILING, accept + any prefix that matches. Otherwise, the entire string must match. */ + if (! (ignore_trailing + ? ((state & LEAD_INT) != 0 || float_syntax) + : (!*cp && ((state & ~DOT_CHAR) == LEAD_INT || float_syntax)))) + return Qnil; + + /* If the number uses integer and not float syntax, and is in C-language + range, use its value, preferably as a fixnum. */ + if (0 <= leading_digit && ! float_syntax) { - state |= EXP_INT; - cp += 3; + uintmax_t n; + + /* Fast special case for single-digit integers. This also avoids a + glitch when BASE is 16 and IGNORE_TRAILING is nonzero, because in that + case some versions of strtoumax accept numbers like "0x1" that Emacs + does not allow. */ + if (digit_to_number (string[signedp + 1], base) < 0) + return make_number (negative ? -leading_digit : leading_digit); + + errno = 0; + n = strtoumax (string + signedp, NULL, base); + if (errno == ERANGE) + { + /* Unfortunately there's no simple and accurate way to convert + non-base-10 numbers that are out of C-language range. */ + if (base != 10) + xsignal (Qoverflow_error, list1 (build_string (string))); + } + else if (n <= (negative ? -MOST_NEGATIVE_FIXNUM : MOST_POSITIVE_FIXNUM)) + { + EMACS_INT signed_n = n; + return make_number (negative ? -signed_n : signed_n); + } + else + value = n; } - return ((ignore_trailing - || *cp == 0 || *cp == ' ' || *cp == '\t' || *cp == '\n' - || *cp == '\r' || *cp == '\f') - && (state == (LEAD_INT|DOT_CHAR|TRAIL_INT) - || state == (DOT_CHAR|TRAIL_INT) - || state == (LEAD_INT|E_CHAR|EXP_INT) - || state == (LEAD_INT|DOT_CHAR|TRAIL_INT|E_CHAR|EXP_INT) - || state == (DOT_CHAR|TRAIL_INT|E_CHAR|EXP_INT))); + /* Either the number uses float syntax, or it does not fit into a fixnum. + Convert it from string to floating point, unless the value is already + known because it is an infinity, a NAN, or its absolute value fits in + uintmax_t. */ + if (! value) + value = atof (string + signedp); + + return make_float (negative ? -value : value); } --------------080604020806080108020707 Content-Type: application/x-gzip; name="strtoumax-patch.txt.gz" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="strtoumax-patch.txt.gz" H4sICMyDsE0CA3N0cnRvdW1heC50eHQA7Fxtc9s4kv48/hWIZnZtjy1Zsh1P4olzlmXJ0Y5E 6fSSKFVXxaJFWGaFInR8seXd3H+/BsAXkARJWJPdu6u62dm12MTT/aDRDTRIcK+urtCamNaD hU30YNkY7XceDWeFB2S1v1ev11F8+dNps9WqN8/rp03UPL1svbtsnaGjJvyzd3R0JGvXQq33 l63TpN31Naq3juGqddy6QNfXe0dCWzQ2Aht1Vyvs+gh9wOzH9dJrBEvbaGAz+Lh3tHf0069o aHzDlGrDctDBnTYf9G/04eh2PuhODy9R2zSR57s+CdbGtgGA2aPlIfjXwdiknSQu8h8xXD4j y/ExWKm72DAtZ4WWxMQgRDYVNJYU3feREfhkbfjW0rDtF7QJbNujjaiSB2Lb5JlCV05gW/fM hd4xen60lo+ANlyMAg+sEgcR26w/GN6jRRwQbGzDByprD/QYPjKJs++jR+MJJ+QvQQHoPAGW /ssGe43HY5S6tpxIxDAW7fBSENhwFerg13bqdpC9zFxzdaGCJ+xaDy+Rveflo+GmLziZ9XlM r75xrcb6nCoQpFRCWyWMRYGdvrITfMRYvB/YmWtBHSOlPyYKYJR83YdrGNU9JMQy+gM76MYl zw5E3bd7+uN6SVwHg3YWdWgPQdQtifNgrQKXhx0Mqr5eGxsdxlC/Dx4esOtB8E2xj3yCXrBH R7zzsgKrjb29q3yWCUHM80wQxBnUbAHRS0iiswsh02Qt5bl2dnZ2/Bs64n8g3VA6W9AV+o89 hNDSoPFuW843iMSl+7LxycnafItMnxjgWMZ4TVNjhX2bGKbxtKI/ycavQ9hzHdbKIS6uPxl2 QFPI37hk4yHb80Hl+ptvrTGKjACgjpBHlt9s8LznmxahQf/AGnkva9bGe/F0Ct47Km4ajXke FHV0NhoN9N6gfRf1tV631hsCE0y97pD6ks1ZNlnxy6dlneUvXK1DH9cdY42veHI31t/2wIQD rVyyrnPhJfrlgP/SPXdpWu6hdLhpnsRa+ICnRPFAtt6h5vll8wzmV2HI5W3lg/6eDvn7cMB/ ZtOUB51ApgUOs+4DHyYg5GM69Rgeu+1iz0fkgc9EMHAr11g3AEvhd9jBruFDR+5fwkmu7hNI 1L36z2iCobUZLDHcvBTvin4Gn1w14C/cu4L/0oip1z0SuEtcvzc8TIXU4+f8an1OMWTJr+AH XPpA0OMC9hNERrCNNRcMFh9U+B0yWhtLl8CsBG23Vys7M+Z/MgleE//Kof//Hv7BHi6ZMeh/ hqPpbPC1M+i2tV6fTpBHVzDvwxr+awMaLb+ZwXrDi5jfzo9hSqZ/zt+xRINc+Rlhx4SpMCwF oCuBnTCFJkfQ5B6vYP3INWFrI61vbub9wUyfjuaTDrefrP709s/oC2aVTKb8AJ3ENbFLV58l uMHH6EOC/AgFCeYVC3TYx2uqyCTYi4sOqEl4+j8T95uHni3/kTVfWU8AXJL1BgbHhaUzUXqJ UoUIzIMwVLAWWrZJp8ETvmBSx/mBB3e/tCeaPtL0+bSrfzoEQXtyp2sjDWbqAQhglQbRUP+s 33W1Q3eN6g/ol+u6D/+D/vpXmLyPfvoHwstHgvZPfkW3I6SNZqh725+9QQDoTtqz7i1qz2ej YXvW77QHg69v0K8n+78zJKwh4LI6TMTeyfX+/qf2567e12azr+PuVP+0v3998stBRnh4stoP sfQfhv0O2L7WGcxvu7rWXcwA+P2XA1Fy+F2OGk/ad8O2Pv06nXWH+qdu+7Y7oehr2Y3rciWd 0WA+1KYiPBQVASmzdH+BdkYoY37CjPb1YbszGU31m8noj67GvZUTy/xF8e3xeNDV51r/c3cy bQ90GuC3XIf0VpEeNjyDkXbH/weIC8OWkpdqmGvT/p3WvS1UJW9QpBPcMJ5N9PGk2+svYs8k oiJcWJ/0h+1F+2bKgWmZAvK2/zmHBFkFcjqbzEa0aQobS1XQcyl6XoJmrr3tdgbpLufEavi4 4zlxNT7TfckNRR3zIh1lfoBQOjuFxFnoA5Z89Fesp+Bmia6Lc9a8++88UEVN+VtFeuYpu/Ms q8LbZfoS6/M0s4KbEl0nJpQRjsXKVShO9buBLqwYJ25uBVFQIKxBTEF6TRIVfIC7YUGf3nDz BeW/0Ee+OoVL0/opWqz2jmRVRLJsCj/rPl3SYRqetPXb/nSWakhtsRW/sKyIagZUUFbYcWFD S5a3Z6e0ZHlLK5dmeckS1UslJUu8facUs30QnkYkN3lhqhtibZNpWEwnsVXGxy4kYysxsatp 2JUcSkgoslChUckjKOYRqPEIFHgECjzKiKgyUaJSzaUsXgPVeA2U4jW0VZSb4f4jzs7f3r2l 2fnuXeu4dVqenYEDG3mzJDf5ozpKUNaH6EFeSQdiBUXsnw3XqROnHnh0jkC5PYtwHwzR/r1r sg3T++YF9O+ivINp7UW9ZA/4pDum8OHka7dLIUy6VwKPeHQZoXsm5BC+TYKBNhzTsGHvBBuj EH6JksehlVuizmJx2+1NZduh3OL0r9of/V/d47AirNdtz+aTZI+TER6W7Y++dD61J6nNUSg5 LLOYQomSIlRYMd/MRl86HCVKKlBfOrPRTQrFJBWo4c20r/VnKVwoq0ROcjxDWTVywPaKKSCI qrky9dMsWy6tRmtyuKaE/9KBZsOsh5msEjllzaYZbCitRmtyuKaI/9K/nX3KgJmsCjnsDjuf Jmkkl6kgh+M8cjhWQY6/5pHjrwrI4ehzNwelQgXstDvLQUFWPTrZWOYihVGVADUlZM5BTFSJ G+dxYxXcVJMY1JQsSpBjJeS0057l+tieqXDNAzUlZC5gmUjFYh6oKSE77WlXZpWLlfoqVaAp a4CFc5AzD7Jq5KI3GWaRVFaNvJ3nCINIgWt2KmIihblXApwoITvTcS5DqawaKQEq4cY3kz+y QCpTsDjLdRJE1bjZKGcQRNU42aIyla0q4tMSof79LisueZHU12b6TKyamKC01BJKpuS6FJEq fERJBWqSsVRR8kRt4rleEFTxE6uVtKwKqcmgmgI2VeSIkgpUqsBJy6qQmgyqqWDF8kSUVKOi KVOUVKOipUyUVKKSkiQlqsTF5YgoqfJlOsrKC5HY1TmQpoDKOKO0AAmbjLOYcTVGKD1ESZWl HGqsgEpKDkFQzS8L0hRQmQAsLTQSvVmQpoBKVQgZoULfJGBNEZ2UFqKkCpWUFaKkChWXFIKg kl966igtJuIZLQeaKKCSMkKUVKFyIAVMUj6IkkpLs0ynSgqHqElcNgiCKoxQMqREpTj27kx4 tpERqmCzdkWxgJdWJJPueNDusPVz1p51o7okJy7iETUUCpSUqAon9DwlqsKlypuMsBo7ybOt qHOEZvF6kpYpMBarlpxYAa8VKNDUNKSKn4ywGpsqgXJiBbxWoEBT1SDEeUaoYF0KLsxP4f2p F71A7c21DkutyZi/gk0eYf8veH+727vZ8Ml99Ff2VjbZ05S8NoneSKA9kHi+/bK0seHUbbI0 7MuUaEUPVVrLPfTTNT2ODtsm+kZifx96JBC87U+mh78jk0Av2JlSwzRTB0qTN8nJidJE9lPr /W/NerNFTxE3m5fs38yRUqFx+ZnS5nGTHdpvXbxlx/Zf8YaBNe6QzYtrrR59dNA5RKfN5kWd GkQ9F2M0JQ/+Mz0p3yOBYxp0vI9R36HH78HHX1zL97FDj58KHwgcoxs3cAj6ZFj3Nj5Gt9jF 39AYnIo5jJ36Z66CvxvDZQdcw4OLdAyjJuFxV9rqgZLxQjKX6IUEaGk4yMXxyVlQ5iPDMU9g 0NgB3xemCIRAHPPvCvjJWnaaFtNjyOEJWhuNg3vbWqIBUHQ8TM/ebqjEe2Rna5kiCilyye8I W3Dfjd9FnUVGQo3HiLhMy4HhU/IuIhsKPATGL8g2/ARb5IGko2b0hcMj2YQnA6GXz5Zto3v2 ScNDYB8zHdAafenPPo3mM9TWviJIyUlbm339nR0iJHAXP4Xv06z1xqZHoqFnruH4L9ABpmLY hQoLMO2b/qA/+wr9QL3+TOtOp6g3mqA2GrcnEFHzQXuCxvPJeDTtNhCaYkoMMw0lfn5gYwWu NLFvWLYX9f0rDK8H/GyTn4B08RJbT8DOQEuI1uoRZFro279VdFwycSbQ6z/QF4XHUGlg9OHR 9zeXJyfPz88NiMEGcVcnNtfinXyExjRNaKKAzl9RfzpCHfT+ffoEJ+1H5qMR21h+g2FpMJRo A8bMWbkk2DBLXuA9nW3vTSHdG4/+2v5IcczwzxZMrzp0taPr6OMVOgPRxjVWawPddTrhe1D9 ERsQ5HALJj/rgb9Ih9yGTLUDk40FjJy1shxwVYo6aIfgwVuILu+Y5g+V+FGCMj8+Gvy96j2G WLG4RhO9YJ8Gg9g6uulFky894uv4dGIGNey7Gxa6geskTWN0NDfEanQHb30Y+/8MLBcaGsiD EKWf48BQ4zprxJJtFRiuGQ4U9dYbxBYn4JicoETfv8dSulj9bT6lx7j4i9Pw5WfSmr5WBkUt +jfNRvQdvRu6O3F7IQFY8N68jgJvjERZalA/RO79iMLvpkK3uxiCcYnX2PG5U28g040nYpmI nhH3NnATbYht8+8NqAsBtgxjyUtcCRMnC75B/waij3klZzvpPFC7g6Bgr1hv+rNYTQSxrbXl c8eFfqJn4fRhX0OwgIYn2eACPMXk7YUgby8Omb9dF/paS1YQw/OCNQ6Tbh8o7bN4xVtjCUs6 OjtF99QoGsPi7tGZhJ3LZ1NwlLEs6qNj1PTUwYf7YBV+QnIdTgkfGzVxlKGrNFBLqyg6acNs RSdVWBpw6A5AZtodHDjHjUbjeH14CAsU/YCNDmXMh5KjhxJgcjMge1/+zjgS2wtXJeg2bc+O 3tPV1KPbJ/CA4a4CGgGQu8eI6kdrtA48msaQzU6dUdwQ+pmd6/EwcdAVavGTE178Ld6D5QIo 0nbMGp3Gdz28JEAwuo2wv8yGT7q3YWodxFMaDPEZHfJQAAEwmoQz3SHN2mTuY1MfCnMo50Wo I4y1dwjtDT9cKAF0AIagtzCWNlyFbXgk2XSZqNQnTfLC4RdqXvnwi14RGvPzMOCXc/Qh6TH0 PuWnc+qnM/ThKuOsQ8aoLcSMH9dEEAhPsLQa92x6RqvlMio0PHTeOGs0WYCxCiSimHKJQPLg IXCWvAKEjPOMFT6kNTxMixgmdF2n8yJ5oE6PGh6i6JdkWOhRIstZ0atIXTQy2SWP9js5zdzv zPTOp27nj752x3r+mZ2JYvHIFjLswPwW1ggRgX9m56JwQsBl7njBhs4x2NzRZNwKtjld+NOh 50mRvrKZx3Ti6AGPXFlYZkzosAVEgh0Xs9XrmGcCpqmvw/gnYwM1QI3Wmc6qdsjrZw92I99y 3EWlMeAY3L/EGz+ZleLht/h0ZeKlDaWzmf2IBUozn3BmMJ94MIb0JBgMIRCm1UKWNC9vaeQm zIW9xZPhWlDEUvK8HGbzFYHAp98u0X1ayIt9LNw5Omrk+kdPk/FJMTpRxopumtSwjpRnM/X6 n8znwqChuhPfR+NZPJxrbyUGcghIBqYQSUFsu1+euaD+fzBr/2Xe2DHFd+X3Y+aAGMzTjm9V 2ahusBvtVbB4l+dlB7EPAVeFYR4pDoM8rmr15QZqcvpfqU9iPqH7a51a0Uosa1/U398a7xot NKTfN/KyhXYNJiBvg5f0O1/XE7ZSb2RsU7sDCNbbjg6b22F7Fn5GFS/PcaOZNtUn+gwKhu6M eZSWBDCYeI004kx9skETKI5ci25cwvISPExX4WSj6GJWlJpQkoEAh/mG/hZA4XrabL5FYZyh vwxMtpenc9FfbFsSdskHUSFx/okTqg3kLi5sb9s1wc9ht99E/R5P+uY76q0m0xawsGBCvlV6 oNdQsb+jBTsTRRY5smYy7fEwJj8yViyZFUvFCiBrlqIVIrNCRCvzIjMArRFFM4HMTKBkBqC1 QNHMVmZmq2QGoLWtopmFzMxCyQxAawtFM2brQhZorYt0DLQupKEGYPVYk1qy1CxRsHq8SS2R lKV5oSmKVo85qalA0RRFq8ed1NRW0RRFq8ee1NRC0RRFq8ff2aks/s5O01HBn03k4g/A6vEn tWSpWaJg9fiTWiIpS/NCUxStHn9SU4GiKYpWjz+pqa2iKYpWjz+pqYWiKYoui79woPknmKFG dNBE/5bUHYPxxTm6RK3DlG5YvfuAitfw0IQtVizDaUf/3J2kSx3YcNx9AbJ6mTr4LShs0bI+ +jQUffyIzpp0L9Mq0VBUbaQdkUtA6GnsayEDL85z2QYtM5yzuZfLOblyK6/cyiu3yodwvvMY Bj94EIPyUZynhrElH8bgz44jkbua5F1NQleLtEnFQAZy7UFeeyDRHlRo38q1b/PatxLt2wrt C7n2RV77QqK9YCKRLWWDbns6k9bt/I64NRDah1lUuG4VqrWkaqP2Yf4ULlKFaolUbdQ+DJXC BalQbSBVG7UPY6Rw8SlUu5WqjdqHwVG40BSqXUjVRu3DqCgsalgzeWUd3pLGQlJOlweDvJKW a44RSvEgr5zlmmOEUkjIC2W55hihFBXyuliuOUYoBYa8DJZrjhFKsSGvesNb0thISt3y2JBX uXLNMUIpNuRVrVxzjFCKDXkRK9ccI5RiQ16zyjXHCKXYkJeocs0xIh8b0mI0Hy8FRVp4L1ep RRihkCuu0UoMWAUGLMGAlTVQWaflQ6ugdimwTgTrpKp7QYmBoMBAIBgIqgxsSwxsCwxsBQPb KgOLEgOLAgMLwcCiYIBkk1OvqILpxauhxQJWZwJe1ZZs0Lk+MQyjR6T5Vuo7+SKW1m4srZil VcIybKX+FKCIJUmxnGdpljwZiHmSEp5hK/VHCEU8g115BjHPoIRn2Er9+UMRz+2uPLcxz20J z7CV+sOLIp6LXXkuYp6LEp5hK/Unb73CGrWXFDhCHvGnfZXpDipV8v1Vj44LqVq7UrUSqpVJ /6pnz4VUSZrqPMe1IvE52crMf9XT60Kywe5kg4RsZfq/6vl3Idnt7mS3CdnKOeBVT9ALyS52 J7tIyFZOBK96Bt8r3JH0knJWSC9Or3ImAJUqM8GrHuIXUrV2pWolVCtngle9BSikStJU5zmu FTMBJ1s5E7zqPUIh2WB3skFCtnImeNWbiEKy293JbhOylTPBq95lFJJd7E52kZCtnAl2eRuS mx0K9p89+faz94rdZ7F2S67d6v2orWexaSI3TXqv2HcWaw/k2oPeKzadxdq3cu3b3it2nMXa F3Lti95O200a55JVRxiwVi64KKZqWaFtarbyoiKnYZXRsEIapUsGp6G8YMhpkDIaJKRRuhhw GspLgZxGUEYjCGmUTvOchvIkL6exLaOxDWmUTuCchvL0LaexKKOxCGmUTs2cxiveLo1nE1mu gDh9gIH+P2/LKjKKr9m1V9RacouWqkUrtqicAXKLJG1xXmySxCaVo11uMlA2GcQmlSNbbnKr bHIbm1SOYrnJhbLJRWxSMWKnHS1/hJEJqw4XcmTt8VEpTqG1JbNjqdixmB1L0Q6R2VE4xsih YIgoGgpkhgIlQwEzFCga2soMbZUMbZmhraIhySlDLq08+xeCa+rRIDVlqZlixwzVA0JqSumc YYiuqceE1FagaIsdNFQPC6mtraItdtJQPTLyWyMurTyVF4JryoEhtWSpWVI//0dHVmpJ6fxf iK4ph4XUVKBoSv38Hx1Xqamtoqmq83+7H8oD5T/yPFda3S6H8lIadjjMRQNbsvni4lwK0CNL ac6lh/JoLMuVW3nlVl75P+dQHo3FHzyIf/pQXlrHbuNI5K4meVeT/27v7f/aRpLE4Z9vPs8f oSHzPfDEEEyYZBKSbBxjEm7BcNhMMpedj1fYArSxJa9eAuze3N/+VFW/Smq9+SWT7DJ3G2Sp u7q7qrq6urq6iqO6slMeK2uCHmehxwbocQn0WzP02yz0WwP02+pqotkHS33RnSm08lJDzBX4 uYBdI2BXAXYLAfu5gH0jYF8B9gsBx7mAYyPgWAGOCwHf5gK+NQK+VYBvCwHnebppn4zk01S6 YvKZtTkzaOXqVomAZu3NDFr5ulUioVlZM4NWzm6ViGjWzcyglbdbJTKaVTGDS5NeY60KFc2q lxlyJac0SRKzqmWGXMkpTVLErFmZIVdySpMEMStSZsgFTmnFlntJoxxVwuQ4pNfR1I18TaKg ATenAVdrYAH7vSRnzgqb07qvte6XDS8uaCDOaSDWGojLGrgtaOA2p4FbrYHbiqZ2pOVB3iI7 h8+UgqdzySRTH5Sq7dunl5eXObXVrj63bm5NVTVlXNUKVd4a5iHHnQ85rkSOOwdyhKOZtENU Ro6sqapmkVPLjw2nSR5y5vNjUxD1KTjJQqAxXhrwIxzcpO0kv3JuVVU3i6BaDnQ4zfMQFM+L oFgiKJ4HQcKzThp8qiNIVlV1swiq5bmHYioPQbfzIuhWIuh2HgQJlz5ppaqOIFlV1c0iqJbL oJBXZiV6Lv82DWSegOYQiiV0wvCaJ2crO/IJ2WNW6ecdqKsG6s4zUOnhVyozK7sBChli3mDM 6f+lAc0VnPpYcyVnwuycJ/4qexEKcWDe8cw/1liNNZ5rrNK/sFSSVXZCFDPbvAWbf6y3aqy3 c41VuieWCqXKPoxidpv3hHP52mkgE1IpR67Usu3ndtWdt6uu6qpb0NV6boFiepl3rXP6g2lA E5IhZ2rXOl7I7Ww8f2dj1dm4oLP13AIFg5v31vN39lZ19rags1XcAsv36wf52/UD8279oMZm PR+6a4buHixrp57ftG9u2j+osU3Phx6boccHNfbo+dBvzdBvD+baoBscjfhrs6ORqFMmS2v4 wiGhzd1wi7rh8m4UyskavnBIdHM3/KJu+LwbhRKwhi8ccoe5G3FRN2LejULZVsMXDtnI3I3b om7c8m4USq1CXzgTkxr8iPjrcpcwUb+6ExryjblFt2qLNZ3QkEXMLVZ0QhMAqjuhITuYm4wr N1nTCQ1Jb27ytnKTpU5ohvCBO9aBjAiKEQSvKO90GG3euOMIg5ZHzhXGXcbI3yqYIIuOrcU8 VHENrX+mg4Jvi7G2ZDkAO7Vvh5Hlwh/7IrQ2xJvGXiLYoX7czCNqnp70Dz9QPE0sydDEwfCG KNXOWfs9S7dzCJhqv+lroSVFIFdeqwmMyLuBYVM9DDxIUYM3rTURmVD7by0OnVSODVGdouFT bXfiRndrqcHkIYWvcHx8fLhDBDp2Pw+j7x4i9nGYYRTEo8j6p8Lf32M/2lM/A2e6Z/1uyap7 CRbJa4BLKt4/QSL5lT8pGjWtxakFAHOptX/4Sw61oBanFnZoAWph9RrUahWwMBAl8hGmtYER fCMLE65YPzb53x8JW41MjPSNjVZjPvTJBo0I7A/OBieHJB0yKJQ1Wehi3u050agALIbIOInJ +EtjMi7E5HkBJmMNk/GimIxrYBIT3fjeemRd+JR8hYVjx7jRAY9piz9uRiEnEMZhpV+sx6Hr jVjMVRDyziZi1x5hIhYVHJoiX1PQZ8z3AgXGkztMmRLwsNIyO4hpMfg9QXV6wiix3+fkhqie GgLbLM45hMmQDGmH8HWdzENUvmLyoe2fRfKh+3xC9/mE7vMJfUv5hF6fnrXfHreFpHnXbe93 z14r8SW+d06Ozo97/df3yYWWkFzoNS2z6vVr0j5fi2q97ofBa+s1/kkXus85dJ9zqFbOoUUS 1txH2P+DIuyD0D3kyBm+OTv5c7f3+ovE3C9td0VR+EvbXVVc/tKGVxWpv7ThVcXuL214ZdH8 y5l6dfH9yxl7dRH/y5l7hTkAyhl8hVkBypl8hXkCyhl9hZkDynl9dbkEynl9ddkFynl9hfkG ynl9hRkIynl9hTkJynl9pVkKXrdPT4+6w/Pe4S/ds377aPjm/PBo/7Xhit1rWXnY/e+huO32 +o/LaMB2Ykpfg/69/sJJDvKIt6K0B+XNrSoRQg02OU/wyXkBo3y5tAmMVc57/cO3ve6+gWe+ aEqFcjIuN8lCeXvLTbtQ3t5yEzGUt7fK1Azl+sKSkjWUKwdLSt9QrgksKaFD+aq/pBQP5Sv8 kpI+lK/my0oDUZHtlpIYoiLnLSVVREXmW0ryiIr8t5R0EhVZcCkJJipy4VJSTlTkw6UkoajI h0tJS1GRD5eSqKIiHy4ldUVFPlxKMouKfLiy9BYV1PNlJ7yooKJ/0RQYFXTNZSfFqKBuLjtN RgWNc9mJMyoonatKpVEucr/O5Brl4vvrTLdRvhR8rQk4yheWrzUlR/ky9bUm6Shf9L7atB3V BMtXmsijmnT5SlN7VBMxX22yj2py5qtN/1FN2Hy1CUGqSZyvNkVINanzlSYNqSZ1vtI0ItWk zlebWKSa1PlqU41UkzpfbfKRalLnm0pHUsFesNQEJRWMBV8uZUkFS8FSk5hUMBMsNa1JBRvB UhOdVDAQrCL1SflqqrHCazkDh0fkr4xPeFj7BZOklK+g83R4helUyldNvcPniR6fF3R5halX ylfK+bq8wjQt5avjfF1eYUqX8hVxvi6vNP1LubyolRAGweF3dqT+un5ymHJxUCtdTKY/dVPH lM/2eslkMh2qm1imfC7XSzWT6VDdtDPlM7VeIppMh+ompSmfh/XS1GQ6VDdlTXGHVpnEprTl laW1KW15dYluSpteXeqb0qZXmAynnMtWmB6nnNFWmDCnnNdWmUKnnN1WmVSnnONWmWannOdW l3innOVWl4qnnONWmJynnOFWmK6nnN9WmsBn2f7qXzDZz9z+6svL/1Nik1h2RqDy5laVI2j5 /upfNKPQEvzVl5htqJyMy80/VN7ecjMSlbe3yhxF5Uvo0rIWla+YS8tjVL5ALi2zUflyuLRc R+WL3/KyH1Xki+XkQ6rIGcvJkFSRN5aTM6kidywni1JF/lhOXqWKDLKUTEsV+WMpuZcqssdS sjFV5I6l5GeqyBwry9hUQflbdg6nCgrgF83qVEGTWXaepwrKzLIzP1XQZ1aVC6pcJt1nh+q5 1dF1ny9KzxdVvjLcZ5BKZZAqX+Duc0qlckqVr9P3WabSWaaqyf1/ybxT1WT4v2Qmqmry+F81 N1U10fqvmq2qmpT8V81fVU3efaUZrapJrK80x1U1mfPVZr2qJjS+2jxY1Wb9N5UZq4JZZKm5 sirYRL5c9qwKBpGl5tOqYA1ZaoatCqaQVeTcKl8eavs0rzY7V/mSME+HV5jHq3wZmMPXdrU5 v8pF/3xdXmF+sHJxP1+XV5pLrHzy1couNp9Hs5ZprHxu1co9Np9Hs5aHrHzq1MtMNp9Hs5al rHxi1MtbNp9Hs5bDrJzt62U1q+rR/MdkOHvNcwzxVGOvBWKYE4qehez1fQo0I9b2D3/Jw5r4 dJ8j7evOkSbIKROQmQiqf7xPpLZAIrUEts+LsH2ewPZ9trX7bGuLZluTDLs1UrnWtJcVMq3p pSvlWXv6k8qy5gFmiH8R74EzC5zQ8SJbZHexLS+eXgDygH99oIaSMJ/tSeyI1FjJbG2tZ8+e NTEzSmsT/tmlxyf077OSJG4EjCVyu0+4dp9w7WtMuJaTXnBLShWRNAoWgkv3iieNgnq/OAFw I+nIwaU9cjJZprScZ0lIYTTGJISp12ufCeDW9ZomzYSTNlsWaKlIL2FHR989XCNMsB7GgbMZ uVOHy1829VGpByZgWdWC2Mu6lWXBokgs8BT/7mHshe4VykuiCP0DY+aLCLDtBq2WbAFNr517 qY0JbdHzR7maQWpjTA3NMKIaA0qoI2kycmX6HcyAIbZA/xQjWlY6hM5ILUV7fy4oIUiifVMq VELJ0L9OBM0yH+SXiSRS4QiKOl7Qbx1lUPS7h7q+q+F8FgUS7VCBfiKBLuzQaXz38J9M/0t2 DIUGm1qgLLn/cEDKbByi9gart/h9nuBkJKeuL8GevVpFWRu5ASHgZZFE1e+L2uSNBg6lK5RM R6MUo6WR7klizDM0Vl2gO9VeTnO/F2g7k4yqM6mu50yqKjm7j3cX0nLIkFGs5LQ24Z+dJj7u bkql5zH9+xOqPk9zlR4CmM1eS697J4Puc8q0B7qN77kjWNdCUBZGDlvxtDS1Uxt6apMOyhc4 thx2CNCRexHYwd0WplG8CklTuhCJBKEGDJXSBWIGRZEtcJmKF7wgWAsrXlKHWEjxQh2LoNzr WV+/niU2Z5i/U5f//e6wd378pns2fHt2cn562HurrTMm1UtfWuVnVLPYV/nOCQLP5+9E9tDQ iYb0XuuB9nbjF3vSsOjRemnRL3N7WvrQhFIHILMvhaanv0SxpbKPkoJgRITEwNrW1qOJD4LD 4X9c79InTTGxFe/53j+cwMdl58ah/bLcj/+Vr+PryILix2QdJtLMQfUJt+wen958weBCM52F 1aDLiFfWtr7k9wZ0+RThZJUH/Cpb0ovplgUHBQyWRnbFhLGqKwJph71h98Og29snranTPuoO j0/2u0dc49M7a6la7w9hU4/pYZl9k3347/M2K2ellKPhkJksJpPhhBVQJ0p5RWVJeYys6pQ2 J8hToTle1NCctP6LygsOv/rolzD46mMvHLq0wnGBsiSGEOxQ0kNebG5caKp3UTOa7r4aBuDk rzLaBQc7qUBLTUAcMni0vjPTXTNH8E0ygo9knS78rL8mdPj1MClsRMd5r0lkyQraB7ax5BEB DnvWkXjKK9P+IMqw871kGXUV+1wrJXM3O7dRAKu6HUahUGsuYbD+DY5pylIz3/jBJ8AJalcq uTRoiiHDgbN1tYW7KKsT2HdWx/ppa3vrMfxPzxIdxA5OHs+5AmyBRkF6tNT8kusFnRZaA9Sk rOjGXw+pFWx4QonAYcnxnHA9+SYQQKb2ledGuOYl1XrWV3gxc0bYhQmqwcfx6JrUmJE/1hJw Y6MJ8KjIhf6U6TUzx4cP3K7so84n7eS4WQA1cOaHIaWM7oCOGEaSEQRp0AY8HLw/6Q87J8en R93jbm+wAbuuDfzn/yz8lwIt4MNmq5GueQLqX0nN7Uwlbhg4br/tHQ7O97uZWi9UcwmaIYHs ALS4qROBhseJAzOGIdw4NtYYNfE9a0WD39DYDzbo7jRmecthoaZnzhuXPBN8kiu2UDN3uIbJ +ZN0VDoGoY3PhQMvXKgNndc6Sm1gQvUZbEKRuymbOjMw810UnhGgmgqkm1L7sK1pWjOWb33i RMCS1ifPvwGq3iCtL91bVP0vuRGXDLhIcCNOYAYfHp8fIxL+wmy+HD8axiz1lf33J04c/d1z M0ENdf/PWPv/eH/aH7A/WKSR4Rb+cZ7ObrZS7W1sUOWW9eKFsjLAC9iHwwIyfHM4sDatnQbU tFr4dsd6CA+MTaQ57zwh4qTeKN+mxpS1LDZStjyCagSaBzNpoSkAx0R1ChxIcp0NCsBxRWM4 BMHUGQ5xOu+gmZG/AAAnZ/D6hfVUJLB/rwnoq9EIZTPbd8UhMrowe4YR7Cw5b0LFEAXjiFvG ckyxMD//Httj2M4oVO/pziapRSZxNzi9AHFgJsUqvSgWrYcVlsNKq6EqJBHP7PkOW3oY1nBd mIS+FEd41OuNCVG4jwKJ4sEWDTe6106gdt3i/NG6cmBlBalje2j8cvEdbJft4CrGpYVAckg3 1y6sRiihaFVhe6mQJOwA1pXRyAlDKs8F5I3DJB+UDhw+TPw87B0NO+dnZ100oAopWW/jw4ib AKQ2vOrtxsgG2ewHd7D8R86US4ONURwEMLbNV6yjH7HGITv+3O9+sDao7G9bbBvbSJCfunHa PmsfW03ES87H4enZyeAEigyHDHnDiJfOMJSqVAjLvFG/QVNxdqOd0H61wsqMIBsabnSuG9bR gweda32/S5IP5QHMUy9KmLSBU2Hzzj9i++xrNcLJ3XG/f9rudKnx4dANb8KZPXKGExDG8IpQ 20iWbx+dvmur8vZkdm3nlx+cnJ+eds94+ci/iWegCWfLS+3d0C/RKwt/5XVGdCVTSO+BaF8W yhMvjBp5pJAyELGeQxHxaTFy1KRGTWLMRYsqpKhCiRxCyLmlzDfds177aONDQz634Ee2BL6F YT148OHBgyEdloIAVcXed9t/7rWPu1hKPDNAxbYxUkCF5ZzBQu1Pym2QqqNrZ/SJBP/IB4k2 iqwrWGNnaHsTCp60r8kvSZsaX1LEgUMP3S3ZicJf4/S5Cttgql+wo8LTE+tNu9+Veir+QD11 m0Q9fafNKzd0Ceu4xbY+7ITABt3VRpWXgKCBD7drY3fEd66jCFYktIeLctba9u0avlnb/rCW KHvt3NpjZ+RO7UmmSy9ATYE6r6zHT3A9wFfYiQgH3NqWxWGmIBZcdsqKbk9N1Lp9Ii2Wxe4r Rx77MuKHBRPYpLJNN5B9xDCKu0ZQ8CM/YGb5Hxl0ufekQ0TBSdzXadIQTln6xP7Ro/OqxCtx RGjwfbLksSE7QCT6G9YVdqjISovd7x47NLtyQxxaxohpjeLIv7zMKcULTNxpGRg3WcAw5DBZ QhOFI/piqgIaR9NCxOyJYflAiMuJf7NXwRxdQWpawsuUr+xjO7KtH7lOAYoovN58Jdb98ONR Bxvqnh12ftNP0Ekvxh0mnrOEoKOFGk9xs4OAyUBJxZgvulrNl9bR+l+21/c0sB6obwFoz2Le W2hXcC9pnrAzxGwLgo+knSWY2hHM3XAUuBeMf1/wvly/kt3R/QdFa9rpML3iB7//FIwqe/VS V9esDYWspiXo0tgTtRCcbMJ68RKEzP/+r2oUNyLEIaA0a8fbWls4mSU0cb7M/vunPocAhwfk gmHhGViUoFLozNAdA4WuoJeStlowQzwISkQyJPeBN4OT9x29KZ2Iw+EFaAojGGQuUvCsrt/u 7feH/e5pQ6FGoEcD9xKWm5ODRlI2mHhG48lcUFQ2BSsPsZb1O3ukPwrN2fL6IT02ScvFC0ZW esa4jPIHCu40I2mnW9ZG97D3S/tIIYWf+2/vye7Q7MU9yUsLMYAilbMqkLz/yZ3hJidyLFI2 1IS7xjV4g+sjQJ5QeDI8fMhEFHEmQ9Rwg1DFC1z5sGB4Pq4GqqGOXLdtsv3IhpJgNiUUOVxp nwS8yGGKTmgIT0F6WAhpuwgS+5kqzcdx5oz8K8/9hyO8EWBRR5MTGrJcte6yBZ35NOG6i3PK j4PQmXx2wpyxb2d7jAU2BFckWeRJA+0PXM+DVfRj67eGgPRBQspM89B6+NLaScwhBhIgZrlZ w6zshQaZ1/zZSIp0BdGMhsw+bZVRM+KaBuzpb8ijgut5zAsAoNneHez9UdmxQZdVJk7F2qUr XYFoJtkHBCRbAvzlK8XYvXKlQwoSmHXKjcK00slx5Y15T9hv5PaNEbyipdkaoaOQmCv4Ez48 fAifNIwSwfli12A1pExKSiIgfqLkC8FDyCX6h1f04VmCJQSA7/leArrJ6pEH/IbkqhEaALF6 G+A+BNo1rFcvmf9QAtpF4NifkmsWsbXsu1Y6jaXkmsS+ct1+cjckRDvjIZ9mGyG5MTUV5Kak RSM7jx9oUp5B5lKYFnFS6eBdxg71SDNWCtWtQcPe4xVB1TNV/H9FFbGq0MukCHLlk+KWMI9X QpN8IEQnuShLjhHSTTAIUH6EqkSWL0bWpiy2lxEBGrMk6ry08hkmh8zZHjLWG0n+yiubWEsE OhPTEKG5wPacvsTWiCP+m0b/ihNRH4hGm1YVjcm1fnxZzCiqJAjdkVFZSCyPuqADLSu2J5O7 rMSTREfRV7Tm9nELhhos397RqdF4HKDNEkQcbdmEPsf7NoP9nNzYadr5jba7S3SE7caQW3Fm 8d7wPRo63CQ2Kg0lpq3v1aF9RkEgGyX34grJas7V88D2rhzhhmVp+3WB/HV2LgjLbeiOnUQd 66+yUGIEiuwv0dVFCkdkoQ2hBKR3m3+yNjdMpN9IW8bp2AT/TUN4bmSdlNVcsGeKNdM6pPhc rCmetXtvu+QnmnCZSOiNaYmmO6VqxaRu9KfMUcDz9Bj2kmL4d02VIlhEIyeMJ5FYd4HhA38W uHbkJHXFbOubLjToElMx7n/Ogb93rGkMLExHAQ4qnbgXtCd4rO5YeCzwPGGt2UYzSesJLfPi vABkshvgfLjx1VRgV5ZAQFLR9VvOcXwUEX1FZzSqr5lmmDYRbnEvRjK1oF8abqqgD/D+vSO1 d4TNQfC5SxpSKEwxf739a/ksTK4SqCZtkvaPInYnqTzCx4+bSQVS51coy4rs/JZVVosn/H8K 2DkSFUiFe3dAGvPxF2o1mvqYwEnI9qKm+M5GYzKBziNydn74/5Hdr3vLzJV4jhPAwhkFdwy7 0kDFTVRcmbyB1WcoTJDfPUz9FKwtHK3nNWIJy1WBuYqPxmA58zLu3U3gIR1Sqbu3wd+7jsN3 ZY/vx4+Fw/eBZtWd2QF6FKe9dazLwJ9akXMbbZmdu39Cj+6nTe0yW90bbMKrWDhrQ08i3Ze2 Ix2072+73Xthf5Ve2PzQhZzm4L9W+l4au5DxyuSxzX7237XPhPOkrHYNk3sT/a3sSBy20krS f4fXndHTqT2wNvBaQtN6i/CGO8Nt9bgDUovVHoZ30wsUjays8gUV50by3d+1VxIku4Ol+2Hw RxLE9sSFKcElIVRjcJSLd77Ei7MSL64h8eLKEq/1TF1xSd9NIcn1tJLMupdX9/LqX0peyfsF /L+k3FoTcmutcA6bJnGtWVx5Gu88KVBcMkfHC6gw1QXB/R20+zto99JE035MIiQmGZLRfeAb 3iXm+oN2OyejlcRKLWkYtI5Yqh1xNb3DFEYkrhVGJK4RRmSHpFZG5rYyeGKxSXKkrYhioLot 3lTosyxarcPbO0pfonsNLCaAHcJ2PdokD3/mY26+8iuu9T6pI0zvNaV72fYNxTFpWm+C2POt dzbeaGmSJfK/3Kl17Nw5gTqVVNc7f+meHR78OnynOVCKV0xo0sVMFgACXTaG/UEbMDxs9/vd swE5i5H7e5/c04dsLtIdJPKjnjFeZ7Ox9cEaB/ZlZPVaP+3+DONlytKTradbrW3N/BnGM65f wODedjrW7taTLWX5JAZlV5hwbvFR4tlrzA241hXRIXJCy7FD1wk2I38zcOwx8K195fkhdJUd mt5cAwpFTIWzhnWpE14ft3nY4fyjfrpF/nfIOZ2HD7dlocc7uztaoY3dhra3o2mFgm5yh7Mr gajLOEKXAsQXn7whQxIIW0STGNUBtOr5N03lNu97AI44EyoDHbowDfkRE+CHREmSvoyhAemm 8fOpcuGk/BzXZSiXdd1FaGPXeqFuT+CRnH6VYhctzE/wSDJ5n6LRSEbw0qOAKV9XE8e2NEMB 9w6DjjFXf2vj2TOtN+hEC1J6Cji20Ws+9iJ3ggdedKvIvuDuUOwGAZ0HvAVcBw67gUSikFMo TGIqMf5UkzCsKqPKHxQzZdujay6YQrEqMj538cock9KhutjAPTzpPjndYGASW12Wa0IRRVkt xoa4qWI5t+jFSouGZZ17yKWMTxhzwOzCs3mcneyEA+QUW7/xjOoaJqdaa7AQrml4vML6zmPH YT28JDPhYxIbErx4gbxu441Sun7o4caKLkkiR7MZPozwkhxOc5ddWAthX8SizVDpJjdyCd/b giHKOluWLj44XC1KUaI7TX77klZ/f2ZNYMGbiGH3yRgWEhlpi2itDYdrhIdZ4H7GIy8644E2 EFtOICoemsVvU+8YICjEdXnsMu8JXBXdqQu9nNyx1TmNIjaZYd7O7NEn+4oOntPtuB6dpdrc B5RrJuxsFghD122Z0wy7SKZRmN3VuXDw6JI6F2KQP1g6AaDNsIiCS1xgDZmQp9fygil9YA2O ffJP5tMt1c/nvFk229lMDSNnht3cwLH+CaT5c7zsCGh566ISAr3XiH3WVCfLxBQBc8G+8H2Y 6x4+Xk588rnepAMjuv7YZMS6c53JGPHBAWhwATESHKtxc+2H/MoQ9k7qYjhvx9pNI0sxJeIF Zq44+tySg+0By7EuaE2+p3PzAD0H2IyhhjlM7sorWAE+gBT+Z9KbmX+k88mhezkU7Q6RxMPh c+v9nvX7FgcIrEkNikIplAgqMjlAIIECPV/dWx5JtAFbTNgiZeNd0M1LhIEYlGe+2AExess6 AUk5Jd0ffQQ+MTbBa10B3nvGstxp60ZpdnS72Z4KdDiXlzBZmoKl+QNNXrzdKsPrJvAzjqfT u4/vf9uTnnKsAXYtG++BTTCI5Tv/Bhm+qeaQODls0t1lxeAcykaIt58BQGJaEPXJXNNA4QeT iVyS0foE44h4CQ7isx24KMtD2ajChWIRFGnvuSUo1PohjiTzcYgzEM/nHRAqQtPiKsbUDVHd kLOILsYx8USC/LmkG3TTd8fqZscG+eI3AM1CnHnoFNvYE0e5wOkHXJHSITIpa+Ro0qI8hyaU 4HxAOV4ThrXEmV44tMll0aR0Yc7u9iVWRRyd5FAVm448DNgLWi39i78RK9ly3jYTJEfbkkAN j97MA6Acco9DBmuMx9IubIhIZkpWFGJd0EjwiutpeOW4IAa1/rm1tfW78jtKh4zGr6ykKsPD 5iaK/GguQyRkDW0kyzeqwLM2EICIqobdA0WARsz3WjqhOfORTAHsTiYurZ8aNQSB+PV4jkHE b8idMnBhhIl/AeqpzfyY2jRh+S1dVAMFp9hRhLpV4r4AamXKOyHVhs7awtqCEWc7J71Oe7C9 cdu07hrW7YMHdwXFeCmtnsVeFWNTq2BtEGrReHV02AO1WEPvm5gvFHSdle4jsVv1TOAB8l3v s88uSxANOP7Rgi2EnHLFQgmaIA0jiiN0OLr1yjvBlrqEoLxQcpjWeww1rLcPxNnAdRw3OkMY 3Dl6PQyHHAZrN/TRm1putHEszBmH32MS83erIXHQxkoxTV4iN98eOSKyHosdQgvUYaRWMEZ2 Me+unIguXgWudBWGgTNe4L/p1inuLRV7WkxXTpNSribWR3EPX6du47fCaYe1c+pl5yAW3kjM vUZBo0IDkYcBDk0aKY77bJ8gDDkUlYOJxZh8OXBWjAWnklUdllD95Z94C+/pjjVHnAp0Yk/I 6IqLfqjvAP60DBzm10ipRcumQVlFY/OLkrJ+3TwsCI2PywAHN9XMRuDewgQekeuRtiTTusV0 U3mWpNzrYGuNTv8jmHV7JIBoRdNlOttLXqK9jssXVN5BJtzYgZT4co/OtH5aroOx2EvEAe8Y ypQ+E9xkCwkcPBUT20CLR4ihyOgkHAjeJa/83Mx1NafTj6rvvNfjeDbBC2pOctjiBgIBl1qS vLC0+R6UBLQEe9EQ67EsFiwuATOlPabRs50Fab2gT8fuJHKFpq0JVS5OaRnAicajqgjzGkxb 9++xkHGgkQehDK8CyMB1MtnPJlIZN2kBi46AexEYMhomtT0aWgGTcgOYZOKjwYJQbyP7YJf8 yViZqgk1MEQhi1mAhsKNYZMFi+BlsCcpq47FvJ0Tmh0O1acINRe+vt06JFNbk2zoQtWiqFSM QEzj5kyAI/Rg6XPHYqd0TpIRjU0T2unj7Ij8RDAnbWHWDcEd30Mu8agazJQZRlLyMfwEasX+ J8fLRDSqpFcYSieVFWqdfSR24bt+bjVp0v0nYJMLmFC+x+1ho2v0uQ4Zb9Cu70aGzrBcNIwh InQOBKXNlRaNS9jjUDAgGzYdgFWhRrCLxigRblzymJX6hRtiugJYu9lWjnSAaD2EJSNiN5Vx OyOMNHrIleT9Ra1DFNtF/fz+ZVILUXY6HTWpIunL/cmiYkxJk95bMelsi/tNyfP6K7JZsIsw TZizn8iAFMnpyYSDiHNl4oa33V7/1+MNBqKRUBsFWK2PjWRM9MD5ewwbEG5IRCpr2/omD6dS ZC+k7nGn75Y6orAMKR7kDMF469bNK+0G8mJmixvYUO7pNNEMYmgjElGSNr7/XkjyRIMvdEPS qwaP4SByeyTttbWakeGZ5MqhR2xKWeQ2zpoisjw35a1ZD86stcYabJj/knQq5sVIQg+H+uff 091fVe/DVXY+OcXm6Wk9DtIZYE92Q5vB1adLYsURp6NMTEWB7ZIMXN9bT0yVaoyGncznGQ3j tRgAoYaVgZoIo9EkoURp0klOOKFNNJRylbJe/2bKg2b0X+Axg5T7An9RwXtBlKzm6/l4W7qJ 7Z+gg5bV3T8cfG/B2Lpn7UF332qfD06OEc3to6NfvyfKQmHYl8YXIewg0akA98OH/ROrg4dG ItxRk2XvAamIMQq4QZw0OzcMYyffG+Lpslwg9r5+FwgysaX9Hfg55r3Pw5f1edij4KLo8nAT uOJYy6lwKaNp/YTsanufQAJa/QgqAJAD2oodTHwflM43fhgh6x63re2dVmt7EyZeq2md99s5 zhNdjAvyZmJ/crQC0OKPbKJZ+kwrn2hQTXfhAPbw6BIyOXKEcfj58e3FWEiOretoOkENhrUn D+YJV39DCzJgMgYliVvVUcOjxSNErNFZJTtGCnA+MTv/j5q1WAY3uRlRgscNciWQ/h/q1P3V S+sxvJoF9tXUpm1ieBeCpjVkB43JEEkPEnoxmtGH0wsU/hjWTQ/xwb6xiGl0sK++XM/iW3ZP Xb6TybZ4Eq79xAG/dERrJJrISdz1ngKfvGtkCrePzrrt/V95ebx1xYsSV/T5RUBlbGQ3zWjD R9cHrU3gQ9rIkcsr7aTjDj0yVNHKwuOUblonnvXudPP8g9VqbcHyIUIAggIPVBTxnjwnZBKF fO6E5ULx3OYrLbC8+IWX0lDy80uJKMAoHgIHoi0OwqCCrWFoKHZQoAFhIO/CRyJ7Eb3QshnR bxVbjx8CjRlI7UAZNsBkqwXujLmxYp1Rf13YXe+cSIZuVidB3IzD4jvwQ6TP4pKuNHGgm0AA b0NMYAkosyXOyGijHSwx5l3XsKAR5PDs8IP1ZOsntEaLA3BFGc/KRBPkw+fRApvaeVoh4reY WR1Hp+B7sKO371DgoW8M6Jjcv0YRnTdjuSKkcYS+Phz8GIU/RdBiSw3zE2CfNM8u9gam322U CorIdC9KHRBM8zg94yNGSQjFPFEuoyUTikmKViLo4qVjo5MScRX0AsUpCCG60DNkm1JdXx4E 8ZNdtnzsO+En9JgY+P7kE6y1HTqqQMvV1XPGy5j9gR27XTgKXxfEWoTeFDO86e8/Oulbu1vb W600MJbZoakBRn5/gfq51gr3EUm0lG4F5gSd5qKFbUyaDhMXTY2/mOeNc4thvfh5vghqpSKd M23iTuseHwZuDMh0TOdZFBZw5k/4SQZGNCXpxKaEFuPc+l4Tx4ICSZeq8w573UiQUE98IeIF ypQbHFC6gstTc6iXHJXpAO/8MxliQVV18TKuhigyBRGiuIjtm3ALc5JisfDBcievxKzgW7CQ bn9P0C/GB+3F2VRr6lVsB2MNXTofZ2aWFjAxljOmbGpkp5Y+sbSyfADKmEhjxUIH570OpTc7 Oz2ynGi0RceZoKChHomSJ5XLg0w4Hz7sdw/66fa017LF6Bo1siloVKju44oVkZ2OTOYZ7zJ0 hU6cyDMpzhyHUnsYPXIj9xeagg7FI/PL2O2WUrbk8Z08CKd5Qk5KNAifadFKO8OdM5qAxeGv 4JzEeayWPvbg5OS1+qDlj018SKAd1A1r49L3m9bW1pZ2FJOOIcYR3D46bPdzK+mFMOUrFdKB liWX5eUAqlZHhYMwUCVwAF0jZokwkYUhDDFJcfIlLTh8TpGLAI3Mj2BRji8v3ZErhBiqfzw6 smhpLMirgFUnx+uz7ulRu9NNf7JS0kxaC3VfSg4V441S3LKGDoBHUAZ8J97y6QGvrWA2GaY+ Z0mcmI5lJM4t9CAZB6ES7xQx3FfHS0n6L4GXmCSaapoZnkTI8N2YQJhZA6SMCYjiXJBIMFTm njErMiYfn5KRuMsILCudeXse8TmP/PySc0AaErARjIx61ht29F33Hs89EghLgZMx6YIOO3G9 T/aVtkrnuX5rC7VsjZtJ1zpr2dDZhoIpVcvAFjBdmxhKhHmiKg/CIcyrIWxzmO0r5Cjk0ydM T3150sscOog/CXLmtMqPfGpKnr6BgKDZeSkCmqR7wva7qiuMMN1bGzdKz8XxdWZkaIWhuL/N ZH533KtjL1lM4MuJfRUypjJGEE79Z0wGT7ghWmqE0DvDsCyQnI9jZgtP1x62rA1E6IMHlYmV 35Vha0MSp06HJF/xSpLE+b0w8RybxnPynNrlZxjuD2Q2GtLXwmzQmY3FaVuZrqnVI4+uWeGB 7szs1uwIlmrDgvj8OUJTdwvwiAFtTqQOKPECwjNdU9s+5xIv2e/axDPSQIeZRwMN6XpxnOEc ecXzvJG7XhQpF2mvjkTLvKv5MkGe0ClTQwblJf9xAP+05v3vL1q8OeLQjR8ZobDPDd3v/aX1 /LkYzF4GwO+L9iAxXZArhleT4ej2lniZnUub1+V5kV6xwdQan2it0+4PkhxWNlFd5pxaxqhl YJzbkTOL1P2JjtocyNVjat9J8/gEjynpEsHlpYM+1prUEJ74bcqDJ9zbyLEMZyl3MF7j/lU8 VhzadNbYDRMlSZi/sXQbsvzRKA6KlbF5JxfD/JeYYcuZZrXnWgUoCIfiJcwA3hCJ94ID3vix oYC92lDztrG3tGm7/Llbl6YLTuBihWnZC6umYfHTGO1OTu6KK2RG5VV3PpVJrbrzzFIKLXlI OZNvKAmYz86hJZ9WWlpoWRFOoigiyR0UHQOyopI5PqtLbUzuzCJ3SleogDzSDMLcEjcCZ+qL 8yhGFWZICfz4Cm/ArTNvm3UZH13c7WroxrnomvsWZPbCzK+XXb/klzRs5pzP/XHpuE47V0OT jriBwwZPLchka+KbmcmMDqgaD2wsWR7OJ/+kpOK59hQf5HPAvJJpaZKoCvYWlzwk7MrFj1ld qCS5ClSEcvUgoRoQuHm1A00zSDoVr0o7EMjdWIVKsIAeUGsyLL7i89V+gWV+mTOqGkWWNK12 CiaHfLmjv91Z6XRDRy139AmP2KY+O71zKJIkemBMfFtXBfhZEPLm5I5foHGY9UV0nMwoWt/x Eu0NxXAOnVFMN7cpoTXzGAsc84TlniGXmIzDBmEQja7XCLJpKrMR4nQOV6Tpy8xS7KISyRrh fGBnuF4YkNk5tMcrPLfei/VZx71olFwSMpgXy7HEv7wdwSswL1yaa6+aoEj5Ps8qixZodGfG u3pMXfBkxyp0hEXd4PVSrXIomcn+aouGDMQHGX3toKP0mOEqvPMi+1YEmUCvoRv7LixTE9h0 yZuXTTlV9JmypB3V0jdXyxG1y9pyVQdooXLK8JyAsdMQUryxV7mHvy8bh8uT/nOy2WJrAj+n orWQWaptUqyVWs6OQJ0p+q+OWfgqro4LVQfVcrrOBt+E+69BJdfuBTL9iksvMeuFf3JK9HAB EC5dEcKhs5FzVKY/KouT4cg0F6TYoMvpnwteLsOqKPOESd7CQ+9YzNgt3HyvRiMZqQ3e/8Od TOxH4bV/M4RfW6Mr90/u+OXu459/bnFfzBuMDoBbNRK4gq4sBheSkzZebG+YyF16aX0/HJ6c Dg6PD/+na7hplhhLzqCZaxGWOOkNz/tdMeS/5BxCrA3IDEC3zZ4/X7PIHm2tWXSzL20nEGvH FhTIBYjX+wCOksZrOlzu2LmlXT9JOCkjX3HqY9aEzmBIZ7U8X2V9dIhD1CFd4vIvoRnOg8w0 knNTrxrsaqIgL/tx4dxYgphp1T59qyKL1JGbpixymaFMB0J5zcirclm1fKHTqndMlq0/rIHK /KlmENRFcq01rNrvctHXGu7UGcG3Lx9bw525kZcWoQh4SfRfvrj9w0TuQhheXCov1vxyBXdd +VJXtrMnS4l45serLjslnYeF77DuTkCXDdJOwxygVm5jw2tubW01p42GFTmTSZg0a6uAoPBo T+7+QeGQfG7blpYGiviD6SnCkG8ueRDK0PLIvN+0plIb9Xxvk7rI7dzcC8PDdGfYGCbkveTR v1hgPwGtSYV25FcRkUREvCR36Yx3tDZaEZ9TD0f6mN3+1yOR0iShi0Zq2tBtqgRz6lgkDgBy DxXxkcOhIQzjh5HGhxYv08hjdgO8BEvqtyiM5NeVQCP5Ex7qqrC8bVwetvWxIWwrv9KqeCaS l0WBET7b7oQkv+tZsG6oyB67W49ZAGB2U1MKfR0lWic3lFMQTO7QvmKTO0essKvE0vKRJQtf g/CXANeYQ1qqG+AUIYzd9xAZGRxNnq9ucIKdUFqcezJ88JxNylIZaYUYG/reMGaca2LL3GWU tVNlKV1jCXjXGgljqHGLw4DKCs2M/VMzfOkHqeN8T7KKXmQyVnLak4yuFwvVmCm4l/FEJi9N G1p5KOetzPjGPr80SEo0amJ0ORknNcseWDCbEesLzudcpkHYCvflC/E0vNIZWfdAI8Lk1lTr duHMBfB/4Kz9YtiYc4rP27/lyIAlulAn2VwAzsTzMUbWzvYn4WRtXIlN5Y3j1UPp80vRKBbe d08OMKRhm0Wi8mjx4/dAXW/requh3dlrJa7oMSia6snBul7Exku4wAb0TuNva7Nl0mCLamxs MOgNjJOcP8ATfkvXUnfC2bU9CqroW+HUnkyYAExdxmUxdWQ1yjjaavIwXvz+sHYrRMQZk5HC UA5PL4LIvxmREIVZ6uPdFL4snA8ONn9O3H8kZLZIddsWO0guBTiG1cX27x6KCKnI3ujtIz+x oEHsooZWXqFPYSJRTy+S16zVysd0hyVBlWczmxd3kZa22aLgtTdICvlOG74Y8bbI3jfPRRV1 Q+UC0c5e8CHRGxqx+sYHkPXQpyJNzr9NFv9wRG4+WR/d/LLaBKXJkmqJzkWLauv9S56mFraZ rcTM+FSpwfIkF980eZDGogi7c9Z+zy7RvBmcvO9o0lboNrxjawzbqEV4IraptWmtGcwCa+jm cwXbDPcCw7LEE0Eqim1BdSnQ4VpidLm8l2QwxnRGflwd74Gw9C8SvEdviPfUt1zeoyLC/YxL 0Js85isonOI+KaSpLyi2W4Q69psFQ2FudRd3nB4Uo4Z957fltJC1QiHleMxydmHX8lm7eER5 vE21avG2pESGt993BidvDLzNe7YmMTYPb7PKdXh7gLm6Rd6TH0/7LFgjC9GDe2hMpYfSeXUM DeIfW0qwNH8nlhD5PZeteaGkX6VaWH6chTksXrFiFWFbGVQ+e1bvTR6rcgi1mFXDcIZdj9/0 D3uHAwPDyr6uCWrNybSi+nwieRpPIvePVAa4Fpbi30AqBPr3Av4N2NpG4fWipsnCvSHiZPw4 w5K673AoKqJRsRrbr7K9arNltT0ommQrHnv+3AxqK0ka9xjm5lmOoiSHuCY4ce65GdRWl86c kX/loa+3cXaudCZOHC89EeGVmIfia9E0nKB3PueMpIP+PJNsbmgVp9AC8AsnyCL9LmB/AFuX +znNTMx/1O2ZeZ96v8ZpPz/nY+35FiVmedXWIfZipUoUTdQwrUaxt0KR0soUqVKsWEUBOXYw 1LzOIj+GwWgm2YSIkWQUE8Dspd+dRr7OtvQeGo+U59YDvyoEliicfyAqC5RY1qu6aqzib5Mi S6tl36zKCiysqTkzvzrLAXw7ssMzCw8vKT28iuLDWypLwQ9tNarKYYuLmK9hFDVEzjeH9BKx 9BWhv0BMefPJKa9YUPWKJJWniypvYVnlLSSsTAbRL6rz34yg/9O0QZTecZOo+l5gFKVCusYr dF3BYbiZqqLzzw2qyjRfAHiRSXT+HucbTAlmTZOppJTBaAoz4thsNuW9XxNUn9t0yqovMA/0 lXvVizZMWepvmOJ8/pbzvl6mgPt5sWJZy7hCF7RS+q5a4V9FD5e4+n5tCCye7X8kKvPlBe9V TYmh8bdBZvRJaPSNUkNiYU3NmbklhwDw7cgOzyw8vKT08CqKD2+pLPWHKPxfyShqiJxvDukl YukrQn+BmPLmk1NesaDqFUkqTxdV3sKyyptDWPFsZXgqzDP/Ypb7UeA4GEp/Ek+9kILWOixp /fvOKoUXZfdISS56x8WW+l4gs6iQdARgPJQrGnILZ6cq+Tyw3szl1VDQVNHsKephPjdTrZqs LLFr4OP3h/uDd0Ym5v1bE7iZm31Z9Tq823fsYHRt9VJ7VYrf0ydIJm7NEbtTZzq6DtTO6Ed5 OiLfaPumkTorSRKDAiqc8EjMPFsBz4STF5PAM/lJP0/nYl3rPHy4Zv1Tw2aqd6BcjJ8/5+PI 9F12XXRciyBs5QKpVP13xfOmmCACs/lXuwpQnm23AE6mbjk0Rju8HrOh0ke8xPs27IIMvdFu yLS2G3nZJaT7NuYD0u7Q7Jq90LO3b3bRrdtwvdXImlWYsghWGjNGrNabACQvDcKINZmayFWl EqtslkrH3ePOuzOTVBKjXBOcPK9U4tXrqf9TDBSSI5Za5Czd36knmKYztgKYNacUkVoZ6oY7 eeLKsOKsor0crpjO6i1RrE4+Mxyf5jEDDmiNPy3EDFC9HjPM7nI44ayDe8L9bn9Qjxdmd82S eWs2nivqBKOa7LCCJnM4YnZXnyNmd/kccfprHkfgmNb400IcAdWXzhFNyttje5FDubFGfoCh E60L59r+7PqBvDRAioM9m9GdAWfqB3cYecoOa3EURmj80iy1kjbNPIVN1WYqrJTLVccnv3Rz 2IqNa008LsJYVL+eOhzl6cLAVvVU4RATUtbVN0poPhdMM00BVG2SQp1civa7gxyCUqfX+NMi 5MTqC2/M08TF7KHV6ToKTc5figqlRKwEwGhcqesexqrkGVXM7mGie2vsYQFDSl33sMq0Ytm/ 7IglIztuf4CR1KGfV4x/OXem9i1ivJyecwA0G8/mILBXQOFeLok9SWNvMSJ79Z0AYeWeS20b hSkVqsLaVoF4cwI1ErC25kVV8siXo3fxLq+xhwVoN5fSldCv2DV3EVHSHo8DJ5QZvDGdt+vZ dBXzaP0v2+s4eWuSfLYKks+WSPJZfZLP8kl+mkfymSD5bCGSz+YiueezrODRte0tcRsGwuNL b8NW1KRZmM8hDLwCadDLFQeelAfeYgLBWwZ7FGzH8sQFDwmE+ZO5fxpzl7rhidldrz5zzb48 c82+GHPN5mCuWQFzneYy10wy12wx5prVZq72bOaglQ84yPfm0RbsaAXawnxAzdqCHdXWFuwo V1toD3K0BTvi2oIdLaIt2NE85Ku2eMxFYC9FjC+yfKygyZzloz53eAXs0cvlD08yiLcYh3h1 WUQY+eew5wM/CvN6NVt6lbk9B0TzxK5rkqcquRPbbJDn/V1jD4tM7NrWeEa1CjN7Hrp6X/Sc ZhXt5czn+kzhFXBFL5ctPMkX3mKM4c3LGZLugNcrzyfPvWT4sSqrd+isYIrPCTVn/SZg9ddw qpa/jve7+VNe9H9N/VhoTWcQljD9EWHJSb8A8b0Enb6UHFhFm3lr+1yc45WwTq+Qd7wE83iL c4+3CPtobEIZP2RiCu7PM5sF/ixw7cgRkY6POsPOydFRe9DlAcgj5wrP6ri5aRQHlPxp4o/s ST1R408my5Yz84A0CxmAVFvCQJ1c8XKCwWyNsoX6vMafFpEqWL1WkJ3A9kIM7AfswDb7dhDY dzzML6X/ubhDjgnj0TWL0ukKrYlCxc5mE5enpEBmuYH/CZDOmPuLs6CBgRPGExZ/Dk0QrO4d yqh13vN1zm/saDhwr1yPgvwQjDpsdXsZTLVTgSWKqkUgG5kMAdZlMqyTx2QfDs6OzUzGur7G nxZgMqpeh8n2Y2ASFBp4gKQsUZhUcYwBA0FqWBiO0B+tj/OvGORSexzPit0eK9C1GgwjBaFq XQJClTz67Z/nrCHUwzX2sADxsHYd2h1goi8V1ZsSdgUi8Op7jDIK/9Y6wy3zUqUbpOp+31fm nkr9z3fMLPRK5XULa5U5ozL8LeaLuhwf1G/D99TAb4WcVgCjFDU5nJvnV0pg53Qrpbq5iobZ qZQPY43z4QJaRk2PUilD6JBhCSIk+NZlSLCIEAmWIUWCezFST4wEy5AjwYoESbCIJAkKRMlZ riwJpDAJFpMmQV1xonkrTRzvCnawfB8qw4I6V1OWrxNGwANX8yQBoYUKZ+DwfNoGNye8DQUS 6az7X91OvUOvcFbgikQkTb0LnL85o6jKnnYR0OaVByDW3ttCndwlp3+a4+/E+r7GnxZZdbD6 18MnwCPtTqd7WotHatPRHmF6jAossghkI4fMwSAF/JHLHpI7FmOOuryRv61h2ghS3PbuNI+I ueg9uwg+lR5azskGX4Eag8MzrOypFyXqDANSqXq5WkMIn1OtSbe7mHqThvaNqDlVODat+lSX LHobc93gK58c+UoSNju3koSV84Tb6ZuzP5ulGxvpmuDy+eUbVV+a3abX7e4fdVGkvWv/2h+0 O3+utYhFQV2Zdm2DfLJHWarj1fyJ89UJNhjiwnKNYCxJrCHK76Xa/FKtAstqtKrCrQXtzCXY Ks6QfOkGTc8t3KBuruI2yNn/0VDXOJ8voLhF9TZ/+y4m6yAVjY6rIv+T44WgymOKrIhl8Uhq 6fvdo8PjOvINQFZ3NDMtSGNA/VQD8eMMaFOuwq+uXSPDQHN1FXyokscng5OcJZBGtcYeFuAT rF2LTxx2CUK/0cTiwQCI0GWp/ALn77Eb8NAwbKFk3lTsmFux0QZ+d25wG4DXER1Md3rhXDIn DDds5F1kW15YLFNomVCPLRNWCi4TJsKx5F6X8vJjUdUBUDFeVD2QhXOoZu8KwinNE4EmLApB 08+PQROqIDThglFowpphaJJZi9933rXPeM7isi/fffcS1mJ7TCqXC42vQ0ceEbYpYd76d5ub m1by3X+0nj3d3txuwf9b29vP6f+th9vw33cPHz5MF97ZbkHJ3c2dltV69ry187z1mBd+/dra 3G5C1Vbz2bNd6/Vrns82jC/CyI0wjy1i4LB/YnWePbNeMKDXr5oMMRM7EskM7ci6tumicxhT RlBCNN6uCNyr68ja6DSsne3tp5vYGesgcByr719GN+hIc4CJ1m2W0vTQG4nKlFB0FvhXgU3H 7JdYKeSV9qw7P7ZGNqaSHLuhzLpLSQgfQeeAku4lszrBS+SsQN7pkhe8gAutt47nBPbEOo0v Ju7IOnJHsBCSY8UM34TXtBjKCx55Xd+zHJdSLPEkv9ZjSn+1AYiBngaU4t33Gjx96h1L/CsK 5w1ZjWwscjZd+zOHO5DAnHQnE0wrzXKtsqUOb5a+Pxy8OzkfWO3erxbMkbN2b/DrHqWY9OGr g4lfyYA3Ja8TTEqPQQbuxEWW4+4ZsGlv0H5zeHQ4+BXHcXA46HX7fevg5Az447R9NjjsnB+1 z6zT8zOYxF0Q2n3HkV4nBYi9JOIEmP0yst2J5JVfgZ4h9G8yZpwUOCPH/YwbE8zmfFdOMoba ie9diSS3Cpl7KEk8Hz3fA1c5ZOXyIcFCXmxaPyG72t6nCa5NEVQAIAfuJTRwMPF9UN7e+LCq Auset63tnVZre7P1eLvVtM77bb6S0aR6z28CgV7VDaDTbyb2J0crAC3+yCaapc+08okG1V5c R9Hs+aNHNzc3W8Ae3lXgx7MtP7h6FMbh58e3F2MuDq63rqPp5BVWoooHANzzb/iu8G+YpBww GQcOIW4GDDoLHFrdQ8Sa641guaWs28GYZUgnMOlcpr4MI7bRoB7SGB+k09R+9/D16Vn77XEb l51B93j4rtve7569VpJVfO+cHJ0f9/qvBRilBKBar+WXhC1O6htPAYd7H/Xlehbf0v5IvTvs DQa/nnb78NA5Ot/v7if2VzANI9+d2reNRBMg0P/rvD8QdcQ4uJBvZAq3j85giL/y8oe9t6Io C9wwc0ZoT3e9z/6IYXKEMUQ9tQvfBKYMUXG/Ahk/Iv/DuEOP146NJMEVhCdk3sTN/7vTzfMP Vqu1BQvEjcNYxwY1/++xMGJ4TsjEC9B2zFMvWxoDbr6yXsBeHBrRfgFSaRmw5Yl0xIy7DIi2 UnB4PrMJj10MYDK504AwkHfhI8xIGooX8C3xW8Dj4LBdAikAbuF0ZX6YwKqxzRTTdUb9dRGe 786JBD1Ex1BmMw0U0APrCRbjqQyTibR9ngk2BFkC+hCgWwwXesLPN9gSwWwt6xoWNILoKWKn LkyZCV64E5TxJMwkAXgCXY5yra1cxANC3oCsx9Ep+J4Psv4OpR8IX4wkw/MCKqLzZhBhmNR+ AsWAWhz8GFcC+AK6Aa076H0mPklR9uC1mA297ofBa+s1/hF8zmYw02aB43sg1PIYXgHUkyCL 6QKvtaTFBfOKCYzXpEUedNuD8zOY49iPBwrVl44dodDDgUOvUOQqK4ymqQlfz/jJLlti9p3w U+TPrIHvTz7BetwBNIcwvy7iq+eMxX2EOUXBeuEoNLI9D2E9xSNv+vuPTvrW7tb2VisNDAZM HKAA4zR4EblTR2uFqTzJltKtHHKr4EXsTsakDTEp0tTYjqaMxxOEs9zOYgugrIZM47jTuseH geEtPvvu2PLsqRPObJiqM38yidlU8rj84lbJRBpjJaUFBXIMXQkSyvYVsSTfCEDpCoTDxEuO yhTBD/lnnG/SnVZDFOWDZrFA2ej7JtzCVB3Bzj3ig0VGupYsAWvVbST20Uh02NgC0LEPGo6z qdZdDAc11tDF+FpNrgdWyexTA3sQy1lVNn2y00+ffFpZPij6yG0DPquZ2EA70WgLA1ShYof6 JwopXVdKwhAg9JDDJJ5q1NU3ijl1l5HPnJMDdIkh4P4+t/nScpszxPJUpYRZ8YYSqbwmTev1 Wff0qN2hcoP2oAs0+LfLg/6aN0kJtsXwJWLU23/NFOmMKcQo77Olf43Z0gWHUprsDIeqt/8+ idQZ16rc4a/vE6v/iyZWF7wvFrI09+vv/z3zricX+vsk7N9uEnbF62dGXUR/f5+jffU52pMK 833C9vuE7SWz9qjbM01a8fo+m3uVycawdZ/Z/V8ps7umxbE0riY9Tvtyn/z9G03+LpVRScz7 XPD3ueC/cC54Tdr08sVNb9ny5j5h/DeTMF6KqV6xnLpPIH+fQP5bSCCvLMSUNNNgI1bv7/PL F0sFhav7ZPP/Ssnm1RzhObANs0T/cp+P/hvNRy+msSLmfXr6+/T0Xzg9vSZtevniprdseXOf w/6byWEvxVSvWE7d57S/z2n/LeS0VxKPrpsZxJ16/6+d8j7hnSIGTf4prH9zeaAUNF403Yr6 nM/+81xBLLqBmH8BUd0/XPD6Yc3bh5T10w5G13mJPxGSkb1Z7mzpJ8nFuHybk3u4JGxgldyg f3h0CpHbvjQ3fFF4CgGkUvWy+BQcs4tFE5TtLiWqoIT2TQSoMLHmPMlldVhzRaEongB5wSdY k3NGn2CV8zNgm+MPilGuCU5eJAN2zfiDIo5+5cQrCaF1fGoSWvQ2R2h9yWQMq2gvh2PqJmFg dfIZxZx8QQxojT8txCi1Ey5USJWexyenv5r4hN7m8MkXTrq3oiZzuKVu0j1WJ59bzEn3xJjW +NNC3DJPRscybmnSTSrbixy6xDjyA7xGal041/Zn1w/kjRVSOOzZjC6sOFNM1gEiyw5zuA0z whvYjb828xtLFf9lGW4lbZo5DpuqzXJYKZfnEJs5TMfGtSYeF2E7ql9PAY/ytG9gujzlu98d GBiGvTXzC2Wir6vhlPDDXDDN9AZQtckNdXKpDajIITZ1eo0/LUJqrL6SNO9mC6rmV6nMZnl+ giKZfW5q9goBsSoAMFqN5sjlXpDKPTeTu0zkvlge97oef5Wp2CTbhh1BW4C44/YHGEmObdxI 2l4Bbb1i2sgZN7VvkRoVcoDVB2i2GM5BfK+A+r1c8nuS/t5iDODV9/lMZoM3E9WgQYqX5vjl K8j3Hi4x33s4R1bvgqTeuTm9ZUrvxTJ6z6X+VcrZLcNBuZ5NN5KP1v+yvc5CHeYww6mJGU7z mWG2CmaYLZEZZnNk4S5Iwp2bg1um4F4sA/cysrvX30ayzPUGwV4gBb587vbwi+VuD+fI3R4W 5G7v5+ZuD2Xu9nCx3O2htwzWKdhO5gkZGTeOcvYoN7gbHg7M9YoY79TIeKcFjDf78ow3+2KM N5uD8WYFjHeay3gzyXizxRhvVpvxeNb5vJzyumbSHhg0k/YgVzOxoxVoJvMBzUlHHNVPRRzl pyEe5KUgjkT64Wih1MPRPIStthyVkL5npH2vgPheilBfZEFaQZN56YijOVIRRwVpiAe5KYgj mX44Wiz1cLRY2uEcoZA9GBEvzUJh+RnKl5adfI7M5AVZyXMzksts5ItlIl9OFvK6Z2HIrCaS 9wpo7n3xxORfKCn5PAnJi5KR5yciV0nIF0xAvnjy8bwc9QlNgbKqm7QF8SFHY9ASyi9PQMwJ NUdnmCsRfUke+sI09Iks9IsnoV8kB71hg5IUGZXYo5fLH70SBvEStPxS0mQVbebpFXNxl1fC Xr1C/vISDOYtzmHeIiymsRKF18WE9sEM9rvcK2uGkaID11ZRtY86GLD5qD3osvwP8OkKT065 yY1lUIqsiT+yJ3kCC+obpBV7axZV/mSybDk1D0izkAJItSUU1MkVT4CIHNlEfV7jT4tIJaxe KxxWYHshRikHVmFmDYwqfwf1kWPGyBwXd8hNYTy65hHshc6G/QRGwmD0zGACjHQD/xMgHZHP PiQOCpwwnrAwldcOZ8LJHcq4dd7zdc6L7BBfxGzlMMws9+Hg7DjLcvytkeVuL4OpdtayRBG3 CGQjAyLAugyIdfIYENFiZkDW9TX+tAADUvVaqWpiYCAUNnhkp+xxGFN7jDFHQdpYGNHUH62P C6+47J8bVkL20sgH43hW7A5bgeLVYBhpC1Xrkhaq5FEWxmkmLPVwjT0sQFasvbQEfKas5/oq kvVsFi/Na8g3ng59kWzoy0iGfp8LvV46vWWkQl9RJvRFEqEX5EHPTYMus6AvlgS9rg+ylC50 PFNLuJwZpctZgXgJvnX5EiwiYIJlSJjgXsTUEzHBMmRMsCIhEywiZYICMXOWK2cCKWiCxSRN UFfUaP5mE8e7gp003w/LYMHO1dSJmOTp81j6iGG6XocKbODwNDMGRzW8dwfS6qz7X91O3nFh /9TgncbfmvUhyiqf50xmSp0ZOH9zRlGVvfUioM0rFkCsvceGOrlLFSAmZ62ivq/xp0VWK6z+ 9fAQ8E+70+me5vCPkX0KuKc2hZMJyAuYZxHI5qS/9VmngHNyGUfyzWJsU5dr8rdQTL9BXsCU hMo7pYQTMFF7lhX4WyMvsATu9ZKdV2WRr0AxorTyiyY6Z0CWlOmcEH6f6nx+xakKx5bkkS6Q Onobc90wLZ8c+WoXNju32oWV8wQfSgCz5GMjXRNcPr/so+pLsx/1ut39oy6Ku3ftX/uDdufP OUvfwLDVYy/NS18U1JV2FRPXfzUiDxPOLyrxCMaSBB6i/F7ezS/vKrCsRqsq3FrQzlwir+IM yZd70PTcYg/q5qp7g5y9Jg11jfP5AupeVG+jue9S8lJU7OgYLvI/OV4IW4MZ5udleYSSWv9+ 9+jw2Cz5BicGTY+9NEo+aKy6y59pERsDUaYaiB9nQLXyLcHq2jWyEjRXd8MAVfI4CPBp5iAa 1Rp7WICDsHYtDnLYtRj9ZhwLmAQgQp7YkSerZLGT2OLKvNfYob9isA387tzgtgIvw0JToUhL iitWo+CqZF7spf5ygy+FpuhLoR5+KawUfylMxCfKvXvn5Ud3qwMgLwKbwI1xftZroHDK1exr QXiyeQI0hUURmvr5IZpCFaMpXDBIU1gzShN7RtVNS5uq5RfO//Lddy9hUYeG3UvMW4pJvq31 6e6jq8kmZmnemu6uf7e5uWklXv3Hznartbm9u7n9s7XTev7T4+ePt62H2/Dfdw8fPswpu9Oy Ws+et3aetx7zsq9fW5u7j5tPrIfw71Pr9evvAB8PrI4Pa8xl4E8FPsjPzNn8bE9i53leGS3b bX6ZCD2KQtJNzd8pM3he/QmGxsv7OP2EKX5zv2JYagyj9ZxG/dOTZmvHevjT0+bOdv64KZHw 8/yPwDL5X4NL1p+Hed9Z1vnCApPir8Wf47LPJd+pczmju5tOXO9T/udwWESqIkLht2GQ9zX2 XNxh5PQbdkHu5V1e3Rs78DZ9bxPmex4AEnJQ/7fGd9Z3UGCA266pPQp8K7wGjI1Zqu/PoHaN WcWtRyAeL92rOMCcwU2RJTB0aBNGvNba/hmnWKv1tPkz57V2Z3jW/e/zw7Puxkd47gwPe0eH vS42+wUmF3y/mkCTg8Gvp5gxvXS2QWlcbYZHmHuXv8AtGv4cHp/snx91Adz+Yac9ODnb+EgV YSw0+Mds8LvPmjs7fPRYe7CP8v9d6ezRWoc1A+qdHQwOj7uVZpWoCJUGJ4fH7Q/pkWe7LgH8 1iiflwn4RxVmarLCEX/FcZHTmcmkuCuxAfT5UZWJn6pSrTtxaX+M2D+vjv2YYb9c8MgGfj2G yfNn/uq8dwgjMAFnVQVf/tSCFe9h6+nPzda24kvkLUNdJpRyeyWkUqIH71YspBg2RYZ2gtb1 xkyfT9YI8et0d+hewgq+AZWAvv2T87MOEOHoEK+4fvyOxZ7dHYLoHk3HMGLMgPq9tTm2foO3 oJd5Gx+TNfcPz35rfLT+938Jn49bpEc81hQJWB0fXTlRBDJr61q80FUJ7S2XXfDmoXxD0ooS sYtiJFi2RuLndPxT8sc168rO02arBX35CWj7TOsMW7ETEIWgUXDkG9kVKROgkP5qkv6dfhFn X2TeMLCibcai+gu2kCb6TL1LvxgGqhZjR1aEN8aYTv0mHpJAQF/c3mYqMCiM/M1ok3o4Vm/Q kOiFuEPEd4Tq3W2i+tNncmlD3dOJ/Fmk6jHIqI9OfU+91hc1fPuQv2WE35wFbvatqj3xvSv8 n/aGMCV/IkOIboK6h9189hS1PtlPUu+G16oKY5DkG84NsieKG5KvJunf6Rdx9kXmDQfL2+bc oL1g3KB3kGh/LQf65HHzJ9DmW9tyFmKZ6fBqGvmXl6oaYxEdkCZ4VK/Ypk8vxXaBWgnKFk0F QDzSXsYej/WNTIqgcjeTev8frWdPtze3YafSsra3n9P/J7c06QrF+5rtJlRvNXeJ3riVTNYG DS3AU/Wn1gaXUZvbW62ft3ZgcRt7E4oRELhX15G10WkA/GdPN3e2t3eaFvz7hP79eRM7YB0E jmP1/cvoBm9UHPiwibVR9Wtah95oiwEjNZIQgn+xQsgr7JG2mAeD1b5yPzu4j524UxdtfDM0 4IQ4D9ETfoTBDGxv/Ai2qmMXfZ8v4ggawuszWPvGRVeCgP76ccR3miOCD1t5O7RwFuFfOmPw /MgdOSw3uQM4+uyMt3CDi6AOcEl5E8Seb72zXdhR0xfQX0/PuqDObnzc2frpMWoHiO99Zmw5 PTscHrc7Zyf94Zuzkz93e7infyGn8/UrEWQaL6Iw6wBz/YeKPyIc0r5DHKkH3MlTGdDygc7+ hFl+WQBvwliAlPbhB2t36zH8H+/efhf0BFi+IqV7APTfAEEfkYtRAUcTxPBdt73fPetvfFTd Y7oOdJnWwx/s0XD0eXjt2GMnGIpSw2vrpXXnhERLj1kYEGYboDLIGx9FLnHm0CGg4yBvez0x RiT+RYAm3d+klRN7DU3KtoB7h5kyyqqB7Z4cnx6i+nLQPep3N3SLB+41jtq9tzD8k7dn7eON lDnk40c00zGxnCASWe/QOAMdHj/e+e4hC3s/g4GzN3vKHJKA+NtvzUwbv/3WSL7NH+NLz69c FCjwm4z/z54uXZ16az/kVl4zUhD4BjZloM/99/nJoLu/8THDzL+B6tTSCMGZvgKLx14cklEK +ZwzwJbof6adly38wGyC5gLbarzQ8/75m/7A1F9ooERMm0R0LfFcWTQ/3k7LZk0ut342yWEU vv+eYnffCZxP1mkApZppGUxjRQ4XUibBfAAzjGdoxYRBQI+mcYjRUOHlRRi5EfR6nBaUunFA F5PSZsG2iVAIvjcyH1NytmESssOTXqeblbSyGFp7ZSFQi+yLsKTE2P1cUCK1sc8vw7efD7EU Irbn3wBP0py+cSinBGbRkbhL4HpLVGpbaHydOKnv4mAlFOUsaxOgqbKokXqwW3rV1Esgr5II Eb4NtpcAmyqMt+8YxpoWR0xTWUaaaptOC47I6JAAQs4HICDoPAhmI8rPcEsgzrSwaYsaGsT8 YEprdufZMyEekWnU4nnjB59gJdcW0arlYE3g8lYT7KYqDJnDay7c5Qk7O2SvsKCbaqyJKvZn Z4i4G3Jcr9WtA2SpVUdSsH6tWNXSlzijvqApE1ZaXUjqB4BfWM2YdsCP1oYoFqDS4fHhgK88 VgvPPoAVpvYnlI8WkseyJ6GPttIOrh1orqADkSSUzkmvP2j3Fgd0cHJ23F4EzNuj4X+d9wcg 1jpH5/tdtH0OuseakESQBAdY8iJ2J2OQut56ZI0mDsxVdvppVKvoTLbnM7kCnRrLi44sgiGq DZjZhsmF6S6RjwJVkwyKp3TmTyQrngSM+vwoll3qJeB4wsXVT1olQn6d15FHda6nTW4JQE+2 +gmAA0B3in0HjHIlHYrgSDxa88QRMCqRgLefh9wgiOrjz/iv+7NSIXm581RBnwrG9O8t/fsh WwnqtJ7o0FtPCHzriRF+oqzPysbszy3788FQEyo+3tEbebxDjaBqbGgkUdZnZWP255b9+WCo CRWf7OqNPNmlRp7sGhtJlPVZ2Zj9uWV/Pug1Gcijbrs/YPhXj756jNXjrXr8wB4TQDiatWdf e46151vt+QN/ToDiyNSefe051p5vtecP/DkBiqOMPwvkaJ9i7flWe/6QrDI+kHiST758iuXT rXz6cKCj6EBhSD366jFWj7fq8cNBAjkHCjfq0VePsXq8VY8fDhJoOVBYOUggRX2I1eOtevyQ KD4GXiMg/K/P/8b87y3/+4F4UnH06eBMZ2n4SVBO0dHKwNTJ4j4vHvO/t/zvh0R1y9pLyqfJ AvKp3+mBfIJ/y+QTFPGpYEz/3pZIJoQLREbApZIJQbOyMftzWyaSEDpQH6GXiiSEzsrG7M9t mSxC6MATCL1UFiF0VjZmf26TQghhccGC8NSjrx5j9XirJI+sydGoPfvac6w932rSRlbneNKe fe051p5vNQkjq3NEaOJCQuDj1p5vk8W4VMH68smXT7F8uj3QB32gxqweffUYq8fbg8R4D9Rw 1aOvHmP1eHuQGOqBGulBYqDqQ6webxNlSFRgTf7X539j/vc2X0RgbZzjWLuCiEDgvHjM/95m RYNmnEoaokp3HrqJ6dLVd4knn50gcFPqHWiVN/Yd+kv5bFuGOp3mTkSHfRT5BNvaMmyylYaJ e/P2+dGgzzoA39j+tdf9MMgzXBoAHgOIw/ZZ553e+a4XxizQVKRtQRPWWDKCcEUR/b9wI8qO ddblZja10524UNcnd4ipsNQyVwoX30/uRIJG2EJ6li2goAaOG2J34pBnLaifcejsoaZ+baOh xHIuLzGhC2quttWRhdXmG3X5C7QHB85lPCG1On97Qj2hLhSOB3py5fMsugg7cNDftkk2PYyH 89l3xzBoaoh2zZK4ApzLrvOZ+oAhciYAcXwnte7oOvDjq2uq0jk9PThqv+0LDmF2yY2PsC0Z nB2+fds9y8JMWCaFXVLsetIURSRrhP/shmRZ4qaSd8Nfumdv2oND2AAaej/8n//5HzISwRK7 BE4qYSPhSZrjFaq51mfRDN+LUIaWyKJ9rBIjYvKA6oHS5/QMCPLhpW5r3vRgLy5MZGv6phtZ 4TwU0aS536HC1ZZ1GHG5IdGGp+MR+l4C/dbRbLi+Jc3AWvvra5O19aSdONkYu02yHurNsXI4 l64ms8tb5IT1dWtiTSbW4RPYbo6FsYUdr/wgSimxub7eQHmEJGu9XAew63uakJ00LO0r2Twz RSaNdBFjOehPQ5UbomB+squVcEJ7JJ6LzkE+Zs0aCaMGw0zi2IJfoZGEuPT9PVOBH3j3qEBq efmYptY6QyY8qHMLxTyJ0mvIuxcgIT5xuvqek2PwV5UElyozWbHpSudSlRgW/abab/rpE4hs AXkCUd6mMn3lt7l/+Etxm1igYptp05m5Vekmlt+uKlKn5bhSy+flLZ9nWtZ1BKYQHJ0AZ9M/ KHs6J739w8HhSY/z/0ep+g+P0J41wCf4n1wphPyU5XRfe0N5Ve6F6TN6ivuX1gbMnAaUED8T k7yROmRtn54e4anbISw7/fbR8M354dE+oG9bR17dgbOusn3JsPvfrKDW0+TQWTntm3yHN7AM dc0Dw8KJL2q0isbGbr3cbKn5XZvI5wkqnxeQ+dxIZ1ONc53S5wWkjr3QvWKGwwTN5fs/hPjn CTSfF5D/3ET/8wQDnBdwQM4wdVZIFjHxRE5vNa6Q6vK1M2I3gNhBDjtg5Nf+o2tc+m/Qq9Aj 7WHmuyHeH70UARQRBGVIDGc+6DZQOnkTwpXhR9AvSPgcqmsXuNSctnFz8THHws29ACxxiieO pNSJlJU4d0v5jzC9ZXrhT6wfWlz5bgldeoR9FjdioyB2mta25eN51I1L3X1gHV5aP+yoz5la PzzeUzUQboJsicNTBEchUW+h19xCr2DRge8Puxo0POVFC3220Ut7wrs3SHziPuZ0kgA/bVDC Os+eWbOJHdGJGju2Vn0gUkvHdIR35ftjy/HY1sFPQJrhpS2KlDgLnM0EXOoKQ5ODrjXiKiFt PrA4NDhywtAPmoAw2vP8sItn13zvtYleaOzWHTAagjMfJhfO1YQ/jumI8YfHqSNClBjDH9Qu p0DpK/R8+Yhbl/emYyC+4dD9Vx4UbxGShQVc7ViI5hOdCxUBzzlxEjuKdDtq7tH2Kkzrr9YD cZNKQbDMAMwKsKUuO6XB/rCThsUHISlrbfzwuJEGNxE9SrBDBVC7WVBCbBbU2zYPR3+H8x1Z 6qOq9SeQNc+tzdZvKWU+yYBkF8r96Pm/pRe5RIGsYgiVWnvJBQFebe+ZNH5gfyk0zZMu7c0u 5xnbHDqaiciCaeYkzVWASBsD8oZOFJGpCo8endsZyAB0JyGHBG9yV9d4le7UsN8dDH9pnx22 3xx1q4xKgynGw+8Uyv3IntwKclwlC7C+aO9oQ1FUCQokKmm7gT1jJVkgW+28rNq5rEY2LbaS oJM8SEIop/IZx94E81HZHi088qIEGhD0pdC4p9tLNJ8pwNo37MuK6kksGXdWe8Z6KUQZd0YF NQWuclzbdJdt6dumvyx3bkuUrujdxp3b9KrCuy3PuW0HnYx3NSfjZ/9W3m6JqZ68ulWqHSTM hsJypnRMjJPCrI5CUjMhjOFSlH1gSCU0faL7FvTbYef0VNnWh9dDDl7VQ/222HFWFgXYRZCE kVFbT/I7igtPpXKe38hag/LLr1nfm/xhxSV9pEw/41KXcZNOQoZlzvOT3kfQAeY5nryhJxY5 /FfsBk4Dh3znQmBO2t2kLuakVc40XCRQ1u8vdcUudSsTF5qkdlImYyYZATOpLl0mlUVLKyFa Jppc+alIrjy+lytJuXKU9G3NMveklOAGitcheXWa7/yUoLlO9Cd5RCdK7/7bXlnJo/pRgUsz XUpOqavYpfcO2tzXI+aot4E74JFNHn5sB9zgyStgSz1yppgChdNJAOBaGnn1gey3Uucc/IrA VmUxlDU6I9ghAmT/AFTzrQYjo09KZfhkYpDgfEtJWH25nSPX2c3ielIdL0oWyXQkIpPoz4tn aJydoXGNGRrPK5VjfYbuFs7Qe4ms3UIvE8lxqUyOJyaS16L5vGI5vpfLi9D+CwrmuEAymy34 pSL6vNc/fNvr7leW1aKdeYV2XEFqxyVi+7xAbp/PI7jjMsl9Xl10m3bsca0dezz/jj2+37Ev MJcX27HH1Xbs8Zw79rj6jj0u3rHH1XbsccUde1xzxx7Ps2OPq+zY40o79vO5duxx6Y79vGzH Hhdt2fMFcY60UVEOpKxRr8oljVa2ms7wmN17ZRcFaWG69idjh4UCPeyf0KHfCxai4/pVk0Wh E2d1zDSPHiYwG0O8BS/uiWZk09N/u6uy7wM3ihwPzy67gTuy3kzsTyxKwQNLkUnI9Mc/Z0QY D6eTp4jwzyk9JKcQi+k1PPmz0lZgUlDiTaQouZDiibt+mVQQfSt7vi+/WRuEXFJLrCPXi2+t uAOza8TcWPGgMZLIFFE76aBfJgHgZ9oN2YwCTr6o5H7oM5/msQOccuGMbIyTCPM4E7pxq8Ah mYMtCqPA6ZLjH8WRaXSMEt+Md9/1EjnO0Afd9uD8jC45mwpETJy8x/PSQfoEjyIJjIYs/Ele 36mmuevsU0HPZatfn6cHzwmKFzpo7u474afIn1kD3598ciOrQ57aNnDi1XN2oOwjZ4mL53zV HfNIsczpN8H41pv+/qOTvrW7tb3VSgNjd06bGmBU+l+wmE2yFQKTaklrRTkS6wFmRQjvnBjd LFSB4fZr4i31KfGSd02/vSA+iQ5JPxmuyFxE/g3M51HkA4EuQvQph78BvYW/E5jn8Jp+h/jk 8cebETxML/h6jbmM8GdImYLlI4ttejN1ppjoiP5OZ+wvSGr8O4W5Tw+hEylY2CoC4n+p8GjG /oQe/8n/hiC/eX7iiGeCVYAoNbqWHlvPYyzy04o0oTyvJE8AJ5NDCVCUZ4cnThE5BHhgbR4d WcWTFYFB2KxSc0oqpLoQ5OE5bPTGnmyZlwlNxOuH6slYDBJoGF9eYtDkcSzTKVMWXOb7Q/Ha yKt5AnyHSW4FuHWYqOL1ltWHhfjFdRTNnj96FPpxMHJwSd7yg6tHMEX+4U4m9qPw2r8Zwq+t 0ZX7J3f8cnd7Z+eVAEezhQO4Go22AHpJ7Z3d3W10TPdgCNOpHdzJWAFXtOzAOkFr/c7WT7iO ky7ThAFcMQyQjICWZLndrcdYzqPA0dAdAQ0x4s8IG5swkV6OQA2CcvQMvXz2rGlNYM2gwAI2 j5STkhy5ew1JBZBuobUusEwScRRN7nKiD7C1aciLcSrUKYsKP+dW4YLUOekdDLoo6fVr+PSJ xdZDZzoVqzry8WKJZ0+d8ZD9/BeSvyZpahKmBllqkKHKTd/6hxP41gbeysGYzfhmasPattGw /skTCFORjcae9TtIBOGiw/ZEuJM4+3XY/aV9tPERlRVmS/qtkYqeMP1MwS5QJdhCpca/+Bt0 Qb5raS8zpDZwwT0fLIkPUgygSL6doXYtepdSfMdEcWrih07H2vRlQSzm3DpY94cOXe6yfjja Zw8m9jG2AFUO3/StV//Z7g+Pu/1++y0eFL0dHuxbO6/+s5XpPFnc1JWVtNtcFWkmY6+oTX/y UT7A0r15WWMsWcyoBTvjOlfYyYzdAsh73H877J6dYSxXtRSMbA9VXpgKMYa9oDlEW0x5/3AD ySYJJO7h4bZJBJ6zrU+ef0MyxyHnLHG3cxb4oD9MUT9nq+SLl7RAytUQc7bAQohXqXC/z9xN f/Vjtre/hKWdL4YsYvOm1R7zbEcT+wpwCyviz882+ZAx1E6HJiAgQgSkbsLqyaoeuLfWHUIU kwW3+rC3jmkbCVtSCjPCsJWjXFy50aM/zV7SWLbgx579EgN6ujA3Ly/3rl9ebD9+au88e2zv /vy09bN9+Xh7/HT7yWjHaf08erbzbLztPHlmP9lpvVK9QudDO6EZMDNIdG2TkqBK7pOJHzeg AgFhjooApOnw8bN7/fYFOW9vqYhwSv0796TvNSh5dxZIV6BZmDkyABrqgjGhCqrMFUnLgbSq EJN4/qY/U9vo4u32ljKOm+0Tf5hLp9n+UdWfk/VPxMiLmLc1LSodZuhlpi7s44XjQbFI5MCM cf+jglCZGjyA/+F62i/wHs10P+U6+mZw8r4jfUCzjpn0PeHL+b4zOHlTUIO+J2ocv+kf9g4H ok6mBv+eqnOm98xQ5yzTM3h3hHEB8xxa2fd01wgO9501dY19T9fqadVMtXqGau878PL4Te6Y +PdUnT69zOug/J6u1dOqmWr1jNUo00hBB+l7ss5x97jz7iy/DvuerXN8Wlzn+DRb5/TX4jqn v2bqHJ/80s3zOhbfM5VgKhc2BN/T+C7kPPY9QyKtjpFEhjoaCox1MijonJZUOc1W6fcKMc2+ p5spqXNqqNMHOVY8mvYg27X2oLhr2Toar5mbSfMaginiT/Y9O5p+V1Qzj4a+G0Yk6+WMyFiv Qx5I+V3E7+k6Hw7Ojovq4Pd0nf3zYuzB90zXlEAwdy0tEFiS86KenRnqYFLrQgzA93QdrYqx jqEKJgItaga/Z5oZFGMAvqerDE7+XFhlcJJpRRfXpiqauF7qlQqmNbT29F28bsrXtAb6LTSA 1p65fEID4G/Okm1kapxl2qDVX3UqW0PKU9EoX8Rbezmd0hdx8a6XqJSt08tUEut+3lgS677I e8aXb3PXUqu+eNdLVMrW6WUr8dU7t2v66q3egLAqrCGElXoDa0NhDbE2yDe0brf2cmuodVu+ wlW7qBG5agt8FPKLvmZLBCZqGBCcqZEYuKFGauBstS6ocJquwNbqoj5lmiipcZqpQet04Sja g3Sn2oPiTqVrJHjK1ESSp/gKXdhEuoZYZ/OmR2Kd1Xqq1TKOxFCL1uaCzqm1WbyhlbmghlqZ xRtcl4swJtdl2ag+0U2dSk50viYX9OksU4NW5KJxy+VV5p0+LZ6DmQq0Ghc0oVZjLbV1cROD 1ChwJS6qIFfiRJLKXGmVWIfVPT62kTYyo/qeraTaMlfS2hKGGpD5g/agOxykVNPM92S1pG0g W01b5ZVJSDcOZKtoY9Ia16wDxs4p3UC91M0Dpkpn2c4l7QPGSlJ+a60bd/qZ75lqmoXAWK1n qpc0EZjwp6kKWgZZ42Y/8z1TTTMSGKv1zPXMamfqe6YxrZaxMVkrz2dN5N1RLmviTQWPNVm0 mmOsyNMg68n7ZpWy58i7Z0/vU+YY0zVIa/C1zYzP6wzT6+SRzqvoDpXPLcq6c/J22Olkktzo Xkt5PriXNDxsA/0sk95MS4in8S2cTMpWCN4XOpnU401w37FL37deygzmjfW/bK/vpdLmpHPm pAiWiT+R/GoKQFHivqYFmdS90VhMST3NzZ04r8pybeLA5bv/HxHpcREdGAMA --------------080604020806080108020707--