From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id A54D8385734E for ; Sun, 21 Aug 2022 18:18:12 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org A54D8385734E Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-596-g2VveHF1OqWZrnF-xoWGCg-1; Sun, 21 Aug 2022 14:18:08 -0400 X-MC-Unique: g2VveHF1OqWZrnF-xoWGCg-1 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.rdu2.redhat.com [10.11.54.2]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 76B9D80231E for ; Sun, 21 Aug 2022 18:18:08 +0000 (UTC) Received: from tucnak.zalov.cz (unknown [10.39.192.41]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 6831C40C141D; Sun, 21 Aug 2022 18:18:06 +0000 (UTC) Received: from tucnak.zalov.cz (localhost [127.0.0.1]) by tucnak.zalov.cz (8.17.1/8.17.1) with ESMTPS id 27LII4OH2981467 (version=TLSv1.3 cipher=TLS_AES_256_GCM_SHA384 bits=256 verify=NOT); Sun, 21 Aug 2022 20:18:04 +0200 Received: (from jakub@localhost) by tucnak.zalov.cz (8.17.1/8.17.1/Submit) id 27LII3lW2981466; Sun, 21 Aug 2022 20:18:03 +0200 Date: Sun, 21 Aug 2022 20:18:02 +0200 From: Jakub Jelinek To: Jason Merrill Cc: gcc-patches@gcc.gnu.org, David Malcolm Subject: [PATCH] c++: Implement C++23 P2071R2 - Named universal character escapes [PR106648] Message-ID: Reply-To: Jakub Jelinek MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.11.54.2 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: multipart/mixed; boundary="BS73ox2G6DZ7ACPo" Content-Disposition: inline X-Spam-Status: No, score=-1.3 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, KAM_SHORT, LIKELY_SPAM_BODY, RCVD_IN_DNSWL_NONE, SCC_5_SHORT_WORD_LINES, SPF_HELO_NONE, SPF_NONE, TXREP, T_SCC_BODY_TEXT_LINE autolearn=no autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sun, 21 Aug 2022 18:18:19 -0000 --BS73ox2G6DZ7ACPo Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi! The following patch implements the C++23 P2071R2 - Named universal character escapes paper to support \N{LATIN SMALL LETTER E} etc. I've used Unicode 14.0, there are 144803 character name properties (including the ones generated by Unicode NR1 and NR2 rules) and correction/control/alternate aliases, together with zero terminators that would be 3884745 bytes, which is clearly unacceptable for libcpp. This patch instead contains a generator which from the UnicodeData.txt and NameAliases.txt files emits a space optimized radix tree (208765 bytes long for 14.0), a single string literal dictionary (59418 bytes), maximum name length (currently 88 chars) and two small helper arrays for the NR1/NR2 name generation. The radix tree needs 2 to 9 bytes per node, the exact format is described in the generator program. There could be ways to shrink the dictionary size somewhat at the expense of slightly slower lookups. Currently the patch implements strict matching (that is what is needed to actually implement it on valid code) and Unicode UAX44-LM2 algorithm loose matching to provide hints (that algorithm essentially ignores hyphens in between two alphanumeric characters, spaces and underscores (with one exception for hyphen) and does case insensitive matching). In the attachment is a WIP patch that shows how to implement also spellcheck.{h,cc} style discovery of misspellings, but I'll need to talk to David Malcolm about it, as spellcheck.{h,cc} is in gcc/ subdir (so the WIP incremental patch instead prints all the names to stderr). Resending with the generated uname2c.h part of patch split into compressed attachment, as it was too large for gcc-patches. Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk? 2022-08-20 Jakub Jelinek PR c++/106648 libcpp/ * charset.cc - Implement C++23 P2071R2 - Named universal character escapes. Include uname2c.h. (hangul_syllables, hangul_count): New variables. (struct uname2c_data): New type. (_cpp_uname2c): New function. (_cpp_valid_ucn): Use it. Handle named universal character escapes. (convert_ucn): Adjust comment. (convert_escape): Call convert_ucn even for \N. (_cpp_interpret_identifier): Handle named universal character escapes. * lex.cc (get_bidi_ucn): Fix up function comment formatting. (get_bidi_named): New function. (forms_identifier_p, lex_string): Handle named universal character escapes. * makeuname2c.cc: New file. * uname2c.h: New generated file. gcc/testsuite/ * c-c++-common/cpp/named-universal-char-escape-1.c: New test. * c-c++-common/cpp/named-universal-char-escape-2.c: New test. * c-c++-common/cpp/named-universal-char-escape-3.c: New test. * c-c++-common/cpp/named-universal-char-escape-4.c: New test. * c-c++-common/Wbidi-chars-25.c: New test. * gcc.dg/cpp/named-universal-char-escape-1.c: New test. * gcc.dg/cpp/named-universal-char-escape-2.c: New test. * g++.dg/cpp/named-universal-char-escape-1.C: New test. * g++.dg/cpp/named-universal-char-escape-2.C: New test. --- libcpp/charset.cc.jj 2022-08-20 10:26:30.971107520 +0200 +++ libcpp/charset.cc 2022-08-20 23:29:12.817996729 +0200 @@ -921,6 +921,282 @@ struct ucnrange { /* ISO 10646 defines the UCS codespace as the range 0-0x10FFFF inclusive. */ #define UCS_LIMIT 0x10FFFF +#include "uname2c.h" + +static const char hangul_syllables[][4] = { + /* L */ + "G", "GG", "N", "D", "DD", "R", "M", "B", "BB", "S", "SS", "", + "J", "JJ", "C", "K", "T", "P", "H", + /* V */ + "A", "AE", "YA", "YAE", "EO", "E", "YEO", "YE", "O", "WA", "WAE", + "OE", "YO", "U", "WEO", "WE", "WI", "YU", "EU", "YI", "I", + /* T */ + "", "G", "GG", "GS", "N", "NJ", "NH", "D", "L", "LG", "LM", "LB", + "LS", "LT", "LP", "LH", "M", "B", "BS", "S", "SS", "NG", "J", "C", + "K", "T", "P", "H" +}; + +static const short hangul_count[6] = { 19, 21, 28 }; + +/* Used for Unicode loose matching rule UAX44-LM2 matching. */ + +struct uname2c_data +{ + char *canon_name; + char prev_char; +}; + +/* Map NAME, a Unicode character name or correction/control/alternate + alias, to a Unicode codepoint, or return (cppchar_t) -1 if + not found. This uses a space optimized radix tree precomputed + by the makeuname2c utility, with binary format documented in its + source makeuname2c.cc. */ + +static cppchar_t +_cpp_uname2c (const char *name, size_t len, const unsigned char *n, + struct uname2c_data *data) +{ + do + { + char k; + const char *key; + size_t key_len, len_adj; + bool has_value = *n & 0x40; + bool has_children, no_sibling = false; + cppchar_t codepoint = -1; + const unsigned char *child = NULL; + int ret; + + if (*n & 0x80) + { + k = ' ' + (*n++ & 0x3f); + key = &k; + key_len = 1; + } + else + { + key_len = *n++ & 0x3f; + key = &uname2c_dict[*n++]; + key += (*n++ << 8); + } + if (has_value) + { + codepoint = *n + (n[1] << 8) + ((n[2] & 0x1f) << 16); + has_children = n[2] & 0x80; + no_sibling = n[2] & 0x40; + n += 3; + } + else + has_children = true; + if (has_children) + { + unsigned int shift = 0; + size_t child_off = 0; + + do + { + child_off |= (*n & 0x7f) << shift; + shift += 7; + } + while ((*n++ & 0x80) != 0); + child = n + child_off; + } + if (__builtin_expect (data == NULL, 1)) + { + ret = memcmp (name, key, len > key_len ? key_len : len); + len_adj = key_len; + } + else + { + const char *p = name, *q = key; + + while (1) + { + if ((size_t) (p - name) == len || (size_t) (q - key) == key_len) + break; + if (*q == ' ') + { + ++q; + continue; + } + if (*q == '-') + { + /* This is the hard case. Only medial hyphens + should be removed, where medial means preceded + and followed by alnum. */ + if (ISALNUM (q == key ? data->prev_char : q[-1])) + { + if (q + 1 == key + key_len) + { + /* We don't know what the next letter will be. + It could be ISALNUM, then we are supposed + to omit it, or it could be a space and then + we should not omit it and need to compare it. + Fortunately the only 3 names with hyphen + followed by non-letter are + U+0F0A TIBETAN MARK BKA- SHOG YIG MGO + U+0FD0 TIBETAN MARK BKA- SHOG GI MGO RGYAN + U+0FD0 TIBETAN MARK BSKA- SHOG GI MGO RGYAN + and makeuname2c.cc verifies this. + Furthermore, prefixes of NR2 generated + ranges all end with a hyphen, but the generated + part is then followed by alpha-numeric. + So, let's just assume that - at the end of + key is always followed by alphanumeric and + so should be omitted. */ + ++q; + continue; + } + else if (ISALNUM (q[1])) + { + ++q; + continue; + } + } + } + if (*p != *q) + break; + ++p; + ++q; + } + len_adj = p - name; + /* If we don't consume the whole key, signal a mismatch, + but always with ret = 1, so that we keep looking through + siblings. */ + ret = q < key + key_len; + } + if (ret < 0) + return -1; + else if (ret == 0) + { + if (len < len_adj) + return -1; + else if (codepoint >= 0xd800 + && codepoint < 0xd800 + ARRAY_SIZE (uname2c_generated)) + { + name += len_adj; + len -= len_adj; + if (codepoint == 0xd800) + { + /* NR1 - Hangul syllables. */ + size_t start = 0, end, i, j; + int this_len, max_len; + char winner[3]; + + for (i = 0; i < 3; ++i) + { + end = start + hangul_count[i]; + max_len = -1; + winner[i] = -1; + for (j = start; j < end; j++) + { + /* Actually strlen, but we know strlen () <= 3. */ + for (this_len = 0; hangul_syllables[j][this_len]; + ++this_len) + ; + if (len >= (size_t) this_len + && this_len > max_len + && memcmp (name, hangul_syllables[j], + this_len) == 0) + { + max_len = this_len; + winner[i] = j - start; + } + } + if (max_len == -1) + return -1; + name += max_len; + len -= max_len; + start = end; + } + if (__builtin_expect (data != NULL, 0)) + { + memcpy (data->canon_name, key, key_len); + data->canon_name[key_len] = '\0'; + for (i = 0, start = 0; i < 3; ++i) + { + strcat (data->canon_name, + hangul_syllables[start + winner[i]]); + start += hangul_count[i]; + } + } + return (0xac00 + 21 * 28 * winner[0] + + 28 * winner[1] + winner[2]); + } + else + { + /* NR2 - prefix followed by hexadecimal codepoint. */ + const cppchar_t *p; + size_t i; + + if (len < 4 || len > 5) + return -1; + p = uname2c_pairs + uname2c_generated[codepoint - 0xd800]; + codepoint = 0; + for (i = 0; i < len; ++i) + { + codepoint <<= 4; + if (!ISXDIGIT (name[i])) + return -1; + codepoint += hex_value (name[i]); + } + for (; *p; p += 2) + if (codepoint < *p) + return -1; + else if (codepoint <= p[1]) + { + if (__builtin_expect (data != NULL, 0)) + { + memcpy (data->canon_name, key, key_len); + memcpy (data->canon_name + key_len, name, len); + data->canon_name[key_len + len] = '\0'; + } + return codepoint; + } + return -1; + } + } + else if (__builtin_expect (data != NULL, 0)) + { + if (len == len_adj) + { + memcpy (data->canon_name, key, key_len); + data->canon_name[key_len] = '\0'; + return codepoint; + } + if (has_children) + { + struct uname2c_data save = *data; + memcpy (data->canon_name, key, key_len); + data->canon_name += key_len; + data->prev_char = key[key_len - 1]; + codepoint = _cpp_uname2c (name + len_adj, len - len_adj, + child, data); + if (codepoint != (cppchar_t) -1) + return codepoint; + *data = save; + } + } + else if (len == len_adj) + return codepoint; + else if (!has_children) + return -1; + else + { + name += len_adj; + len -= len_adj; + n = child; + continue; + } + } + if (no_sibling || (!has_value && *n == 0xff)) + break; + } + while (1); + return -1; +} + + /* Returns 1 if C is valid in an identifier, 2 if C is valid except at the start of an identifier, and 0 if C is not valid in an identifier. We assume C has already gone through the checks of @@ -1094,7 +1370,7 @@ _cpp_valid_ucn (cpp_reader *pfile, const unsigned int length; const uchar *str = *pstr; const uchar *base = str - 2; - bool delimited = false; + bool delimited = false, named = false; if (!CPP_OPTION (pfile, cplusplus) && !CPP_OPTION (pfile, c99)) cpp_error (pfile, CPP_DL_WARNING, @@ -1108,6 +1384,7 @@ _cpp_valid_ucn (cpp_reader *pfile, const "the meaning of '\\%c' is different in traditional C", (int) str[-1]); + result = 0; if (str[-1] == 'u') { length = 4; @@ -1122,44 +1399,200 @@ _cpp_valid_ucn (cpp_reader *pfile, const } else if (str[-1] == 'U') length = 8; - else + else if (str[-1] == 'N') { - cpp_error (pfile, CPP_DL_ICE, "In _cpp_valid_ucn but not a UCN"); length = 4; - } - - result = 0; - do - { - if (str == limit) - break; - c = *str; - if (!ISXDIGIT (c)) - break; - str++; - extend_char_range (char_range, loc_reader); - if (delimited) + if (str == limit || *str != '{') + cpp_error (pfile, CPP_DL_ERROR, "'\\N' not followed by '{'"); + else { - if (!result) - /* Accept arbitrary number of leading zeros. - 16 is another magic value, smaller than 32 above - and bigger than 8, so that upon encountering first - non-zero digit we can count 8 digits and after that - or in overflow bit and ensure length doesn't decrease - to 0, as delimited escape sequence doesn't have upper - bound on the number of hex digits. */ - length = 16; - else if (length == 16 - 8) + str++; + named = true; + extend_char_range (char_range, loc_reader); + length = 0; + const uchar *name = str; + bool strict = true; + + do { - /* Make sure we detect overflows. */ - result |= 0x8000000; - ++length; + if (str == limit) + break; + c = *str; + if (!ISIDNUM (c) && c != ' ' && c != '-') + break; + if (ISLOWER (c) || c == '_') + strict = false; + str++; + extend_char_range (char_range, loc_reader); } - } + while (1); - result = (result << 4) + hex_value (c); + if (str < limit && *str == '}') + { + if (name == str && identifier_pos) + { + *cp = 0; + return false; + } + if (name == str) + cpp_error (pfile, CPP_DL_ERROR, + "empty named universal character escape sequence"); + else if (!CPP_OPTION (pfile, delimited_escape_seqs) + && CPP_OPTION (pfile, cpp_pedantic)) + cpp_error (pfile, CPP_DL_PEDWARN, + "named universal character escapes are only valid " + "in C++23"); + if (name == str) + result = 0x40; + else + { + /* If the name is longer than maximum length of a Unicode + name, it can't be strictly valid. */ + if ((size_t) (str - name) > uname2c_max_name_len) + strict = false; + + if (!strict) + result = -1; + else + result = _cpp_uname2c ((const char *) name, str - name, + uname2c_tree, NULL); + if (result == (cppchar_t) -1) + { + char name_after_uax44_lm2[uname2c_max_name_len]; + + cpp_error (pfile, CPP_DL_ERROR, + "\\N{%.*s} is not a valid universal " + "character", (int) (str - name), name); + + /* Try to do a loose name lookup according to + Unicode loose matching rule UAX44-LM2. + First ignore medial hyphens, whitespace, underscore + characters and convert to upper case. */ + char *q = name_after_uax44_lm2; + const uchar *p; + for (p = name; p < str; p++) + if (*p == '_' || *p == ' ') + continue; + else if (*p == '-' + && p != name + && ISALNUM (p[-1]) + && ISALNUM (p[1])) + continue; + else if (q == name_after_uax44_lm2 + uname2c_max_name_len) + break; + else if (ISLOWER (*p)) + *q++ = TOUPPER (*p); + else + *q++ = *p; + if (p == str) + { + char canon_name[uname2c_max_name_len + 1]; + struct uname2c_data data; + data.canon_name = canon_name; + data.prev_char = ' '; + /* Hangul Jungseong O- E + after UAX44-LM2 should be HANGULJUNGSEONGO-E + and so should match U+1180. */ + if (q - name_after_uax44_lm2 + == sizeof ("HANGULJUNGSEONGO-E") - 1 + && memcmp (name_after_uax44_lm2, + "HANGULJUNGSEONGO-E", + sizeof ("HANGULJUNGSEONGO-E") + - 1) == 0) + { + name_after_uax44_lm2[sizeof ("HANGULJUNGSEONGO") + - 1] = 'E'; + --q; + } + result = _cpp_uname2c (name_after_uax44_lm2, + q - name_after_uax44_lm2, + uname2c_tree, &data); + /* Unicode UAX44-LM2 exception: + U+116C HANGUL JUNGSEONG OE + U+1180 HANGUL JUNGSEONG O-E + We remove all medial hyphens when we shouldn't + remote the U+1180 one. The U+1180 entry sorts + before U+116C lexicographilly, so we get U+1180 + in both cases. Thus, if result is U+1180, + check if user's name doesn't have a hyphen there + and adjust. */ + if (result == 0x1180) + { + while (p[-1] == ' ' || p[-1] == '_') + --p; + gcc_assert (TOUPPER (p[-1]) == 'E'); + --p; + while (p[-1] == ' ' || p[-1] == '_') + --p; + if (p[-1] != '-') + { + result = 0x116c; + memcpy (canon_name + + sizeof ("HANGUL JUNGSEONG O") - 1, + "E", 2); + } + } + if (result != (cppchar_t) -1) + cpp_error (pfile, CPP_DL_NOTE, + "did you mean \\N{%s}?", + canon_name); + } + if (result == (cppchar_t) -1) + result = 0x40; + } + } + str++; + extend_char_range (char_range, loc_reader); + } + else if (identifier_pos) + length = 1; + else + { + cpp_error (pfile, CPP_DL_ERROR, + "'\\N{' not terminated with '}' after %.*s", + (int) (str - base), base); + result = 1; + } + } } - while (--length); + else + { + cpp_error (pfile, CPP_DL_ICE, "In _cpp_valid_ucn but not a UCN"); + length = 4; + } + + if (!named) + do + { + if (str == limit) + break; + c = *str; + if (!ISXDIGIT (c)) + break; + str++; + extend_char_range (char_range, loc_reader); + if (delimited) + { + if (!result) + /* Accept arbitrary number of leading zeros. + 16 is another magic value, smaller than 32 above + and bigger than 8, so that upon encountering first + non-zero digit we can count 8 digits and after that + or in overflow bit and ensure length doesn't decrease + to 0, as delimited escape sequence doesn't have upper + bound on the number of hex digits. */ + length = 16; + else if (length == 16 - 8) + { + /* Make sure we detect overflows. */ + result |= 0x8000000; + ++length; + } + } + + result = (result << 4) + hex_value (c); + } + while (--length); if (delimited && str < limit @@ -1274,7 +1707,7 @@ convert_ucn (cpp_reader *pfile, const uc /* loc_reader and ranges must either be both NULL, or both be non-NULL. */ gcc_assert ((loc_reader != NULL) == (ranges != NULL)); - from++; /* Skip u/U. */ + from++; /* Skip u/U/N. */ /* The u/U is part of the spelling of this character. */ extend_char_range (&char_range, loc_reader); @@ -1665,7 +2098,7 @@ convert_escape (cpp_reader *pfile, const switch (c) { /* UCNs, hex escapes, and octal escapes are processed separately. */ - case 'u': case 'U': + case 'u': case 'U': case 'N': return convert_ucn (pfile, from, limit, tbuf, cvt, char_range, loc_reader, ranges); @@ -2256,31 +2689,47 @@ _cpp_interpret_identifier (cpp_reader *p *bufp++ = id[idp]; else { - unsigned length = id[idp+1] == 'u' ? 4 : 8; + unsigned length = id[idp + 1] == 'u' ? 4 : 8; cppchar_t value = 0; size_t bufleft = len - (bufp - buf); int rval; bool delimited = false; idp += 2; - if (length == 4 && id[idp] == '{') + if (id[idp - 1] == 'N' && id[idp] == '{') { - delimited = true; idp++; + const uchar *name = &id[idp]; + while (idp < len + && (ISIDNUM (id[idp]) || id[idp] == ' ' || id[idp] == '-')) + idp++; + if (id[idp] == '}') + { + value = _cpp_uname2c ((const char *) name, &id[idp] - name, + uname2c_tree, NULL); + if (value == (cppchar_t) -1) + value = 1; + } + else + idp--; } - while (length && idp < len && ISXDIGIT (id[idp])) + else { - value = (value << 4) + hex_value (id[idp]); - idp++; - if (!delimited) - length--; + if (length == 4 && id[idp] == '{') + { + delimited = true; + idp++; + } + while (length && idp < len && ISXDIGIT (id[idp])) + { + value = (value << 4) + hex_value (id[idp]); + idp++; + if (!delimited) + length--; + } + if (!delimited || id[idp] != '}') + idp--; } - if (!delimited) - idp--; - /* else - assert (id[idp] == '}'); - As the caller ensures it is a valid identifier, if it is - delimited escape sequence, it must be terminated by }. */ /* Special case for EBCDIC: if the identifier contains a '$' specified using a UCN, translate it to EBCDIC. */ --- libcpp/lex.cc.jj 2022-08-20 10:25:17.648071388 +0200 +++ libcpp/lex.cc 2022-08-20 12:41:17.660235308 +0200 @@ -1512,7 +1512,7 @@ get_bidi_ucn_1 (const unsigned char *p, } /* Parse a UCN where P points just past \u or \U and return its bidi code. - If the kind is not NONE, write the location to *OUT.*/ + If the kind is not NONE, write the location to *OUT. */ static bidi::kind get_bidi_ucn (cpp_reader *pfile, const unsigned char *p, bool is_U, @@ -1529,6 +1529,56 @@ get_bidi_ucn (cpp_reader *pfile, const u return result; } +/* Parse a named universal character escape where P points just past \N and + return its bidi code. If the kind is not NONE, write the location to + *OUT. */ + +static bidi::kind +get_bidi_named (cpp_reader *pfile, const unsigned char *p, location_t *out) +{ + bidi::kind result = bidi::kind::NONE; + if (*p != '{') + return bidi::kind::NONE; + if (strncmp ((const char *) (p + 1), "LEFT-TO-RIGHT ", 14) == 0) + { + if (strncmp ((const char *) (p + 15), "MARK}", 5) == 0) + result = bidi::kind::LTR; + else if (strncmp ((const char *) (p + 15), "EMBEDDING}", 10) == 0) + result = bidi::kind::LRE; + else if (strncmp ((const char *) (p + 15), "OVERRIDE}", 9) == 0) + result = bidi::kind::LRO; + else if (strncmp ((const char *) (p + 15), "ISOLATE}", 8) == 0) + result = bidi::kind::LRI; + } + else if (strncmp ((const char *) (p + 1), "RIGHT-TO-LEFT ", 14) == 0) + { + if (strncmp ((const char *) (p + 15), "MARK}", 5) == 0) + result = bidi::kind::RTL; + else if (strncmp ((const char *) (p + 15), "EMBEDDING}", 10) == 0) + result = bidi::kind::RLE; + else if (strncmp ((const char *) (p + 15), "OVERRIDE}", 9) == 0) + result = bidi::kind::RLO; + else if (strncmp ((const char *) (p + 15), "ISOLATE}", 8) == 0) + result = bidi::kind::RLI; + } + else if (strncmp ((const char *) (p + 1), "POP DIRECTIONAL ", 16) == 0) + { + if (strncmp ((const char *) (p + 16), "FORMATTING}", 11) == 0) + result = bidi::kind::PDF; + else if (strncmp ((const char *) (p + 16), "ISOLATE}", 8) == 0) + result = bidi::kind::PDI; + } + else if (strncmp ((const char *) (p + 1), "FIRST STRONG ISOLATE}", 21) == 0) + result = bidi::kind::FSI; + if (result != bidi::kind::NONE) + *out = get_location_for_byte_range_in_cur_line (pfile, p - 2, + (strchr ((const char *) + (p + 1), '}') + - (const char *) p) + + 3); + return result; +} + /* Subclass of rich_location for reporting on unpaired UTF-8 bidirectional control character(s). Escape the source lines on output, and show all unclosed @@ -1914,16 +1964,20 @@ forms_identifier_p (cpp_reader *pfile, i return true; } else if (*buffer->cur == '\\' - && (buffer->cur[1] == 'u' || buffer->cur[1] == 'U')) + && (buffer->cur[1] == 'u' + || buffer->cur[1] == 'U' + || buffer->cur[1] == 'N')) { buffer->cur += 2; if (warn_bidi_p) { location_t loc; - bidi::kind kind = get_bidi_ucn (pfile, - buffer->cur, - buffer->cur[-1] == 'U', - &loc); + bidi::kind kind; + if (buffer->cur[-1] == 'N') + kind = get_bidi_named (pfile, buffer->cur, &loc); + else + kind = get_bidi_ucn (pfile, buffer->cur, + buffer->cur[-1] == 'U', &loc); maybe_warn_bidi_on_char (pfile, kind, /*ucn_p=*/true, loc); } if (_cpp_valid_ucn (pfile, &buffer->cur, buffer->rlimit, 1 + !first, @@ -2657,11 +2711,14 @@ lex_string (cpp_reader *pfile, cpp_token /* In #include-style directives, terminators are not escapable. */ if (c == '\\' && !pfile->state.angled_headers && *cur != '\n') { - if ((cur[0] == 'u' || cur[0] == 'U') && warn_bidi_p) + if ((cur[0] == 'u' || cur[0] == 'U' || cur[0] == 'N') && warn_bidi_p) { location_t loc; - bidi::kind kind = get_bidi_ucn (pfile, cur + 1, cur[0] == 'U', - &loc); + bidi::kind kind; + if (cur[0] == 'N') + kind = get_bidi_named (pfile, cur + 1, &loc); + else + kind = get_bidi_ucn (pfile, cur + 1, cur[0] == 'U', &loc); maybe_warn_bidi_on_char (pfile, kind, /*ucn_p=*/true, loc); } cur++; --- libcpp/makeuname2c.cc.jj 2022-08-20 10:59:58.136694587 +0200 +++ libcpp/makeuname2c.cc 2022-08-20 15:52:51.203405535 +0200 @@ -0,0 +1,793 @@ +/* Make uname2c.h from various sources. + Copyright (C) 2005-2022 Free Software Foundation, Inc. + Contributed by Jakub Jelinek + +This program is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 3, or (at your option) any +later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; see the file COPYING3. If not see +. */ + +/* Run this program as + ./makeuname2c UnicodeData.txt NameAliases.txt > uname2c.h + + This program generates 2 big arrays and 2 small ones. + The large ones are uname2c_dict, initialized by string literal + representing dictionary, and uname2c_tree, which is a space optimized + radix tree. + The format of the radix tree is: + byte 0 either 0x80 + (key[0] - ' ') (if key_len == 1) + or key_len (otherwise) + either of them ored with 0x40 if it has a codepoint + byte 1 LSB of offset into uname2c_dict for key (only if key_len > 1) + byte 2 MSB of offset into uname2c_dict for key (only if key_len > 1) + if key_len == 1, the above 2 bytes are omitted + byte 3 LSB of codepoint (only if it has a codepoint) + byte 4 middle byte of codepoint (ditto) + byte 5 MSB of codepoint (ditto), ored with 0x80 if node has children + ored with 0x40 if it doesn't have siblings + if it doesn't have a codepoint, the above 3 bytes are omitted + and we assume that the node has children + byte 6, 7, 8 uleb128 encoded offset to first child relative to the end + of the uleb128 (only if node has children) + byte 9 0xff (only if node doesn't have a codepoint and doesn't + have siblings) + + For prefixes of Unicode NR1 or NR2 rule generated names, on a node + representing end of the prefix codepoint is 0xd800 + index into + uname2c_generated array with indexes into uname2c_pairs array of + code points (low, high) of the ranges terminated by single 0. + 0xd800 is NR1 rule (Hangul syllables), rest are NR2 rules. +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0])) + +#define NUM_CODE_POINTS 0x110000 +#define MAX_CODE_POINT 0x10ffff +#define NO_VALUE 0xdc00 +#define GENERATED 0xd800 + +struct entry { const char *name; unsigned long codepoint; }; +static struct entry *entries; +static unsigned long num_allocated, num_entries; + +/* Unicode 14 Table 4-8. */ +struct generated { + const char *prefix; + /* max_high is a workaround for UnicodeData.txt inconsistencies + on a few CJK UNIFIED IDEOGRAPH- ranges where the "*, Last>" + entry is a few code points above the end of the range. */ + unsigned long low, high, max_high; + int idx, ok; +}; +static struct generated generated_ranges[] = +{ { "HANGUL SYLLABLE ", 0xac00, 0xd7a3, 0, 0, 0 }, /* NR1 rule */ + { "CJK UNIFIED IDEOGRAPH-", 0x3400, 0x4dbf, 0, 1, 0 }, /* NR2 rules */ + { "CJK UNIFIED IDEOGRAPH-", 0x4e00, 0x9ffc, 0x9fff, 1, 0 }, + { "CJK UNIFIED IDEOGRAPH-", 0x20000, 0x2a6dd, 0x2a6df, 1, 0 }, + { "CJK UNIFIED IDEOGRAPH-", 0x2a700, 0x2b734, 0x2b738, 1, 0 }, + { "CJK UNIFIED IDEOGRAPH-", 0x2b740, 0x2b81d, 0, 1, 0 }, + { "CJK UNIFIED IDEOGRAPH-", 0x2b820, 0x2cea1, 0, 1, 0 }, + { "CJK UNIFIED IDEOGRAPH-", 0x2ceb0, 0x2ebe0, 0, 1, 0 }, + { "CJK UNIFIED IDEOGRAPH-", 0x30000, 0x3134a, 0, 1, 0 }, + { "TANGUT IDEOGRAPH-", 0x17000, 0x187f7, 0, 2, 0 }, + { "TANGUT IDEOGRAPH-", 0x18d00, 0x18d08, 0, 2, 0 }, + { "KHITAN SMALL SCRIPT CHARACTER-", 0x18b00, 0x18cd5, 0, 3, 0 }, + { "NUSHU CHARACTER-", 0x1b170, 0x1b2fb, 0, 4, 0 }, + { "CJK COMPATIBILITY IDEOGRAPH-", 0xf900, 0xfa6d, 0, 5, 0 }, + { "CJK COMPATIBILITY IDEOGRAPH-", 0xfa70, 0xfad9, 0, 5, 0 }, + { "CJK COMPATIBILITY IDEOGRAPH-", 0x2f800, 0x2fa1d, 0, 5, 0 } +}; + +struct node { + struct node *sibling, *child; + const char *key; + size_t key_len, key_idx, node_size, size_sum, child_off; + unsigned long codepoint; + bool in_dict; +}; +static struct node *root, **nodes; +static unsigned long num_nodes; +static size_t dict_size, tree_size, max_entry_len; +static char *dict; +static unsigned char *tree; + +/* Die! */ + +static void +fail (const char *s, ...) +{ + va_list ap; + + va_start (ap, s); + vfprintf (stderr, s, ap); + va_end (ap); + fputc ('\n', stderr); + exit (1); +} + +static void * +xmalloc (size_t size) +{ + void *ret = malloc (size); + + if (ret == NULL) + fail ("failed to allocate %ld bytes", (long) size); + return ret; +} + +static void * +xrealloc (void *p, size_t size) +{ + void *ret = p ? realloc (p, size) : malloc (size); + + if (ret == NULL) + fail ("failed to allocate %ld bytes", (long) size); + return ret; +} + +static int +entrycmp (const void *p1, const void *p2) +{ + const struct entry *e1 = (const struct entry *) p1; + const struct entry *e2 = (const struct entry *) p2; + int ret = strcmp (e1->name, e2->name); + + if (ret != 0) + return ret; + if (e1->codepoint < e2->codepoint) + return -1; + if (e1->codepoint > e2->codepoint) + return 1; + return 0; +} + +static int +nodecmp (const void *p1, const void *p2) +{ + const struct node *n1 = *(const struct node *const *) p1; + const struct node *n2 = *(const struct node *const *) p2; + if (n1->key_len > n2->key_len) + return -1; + if (n1->key_len < n2->key_len) + return 1; + return memcmp (n1->key, n2->key, n1->key_len); +} + +/* Read UnicodeData.txt and fill in the 'decomp' table to be the + decompositions of characters for which both the character + decomposed and all the code points in the decomposition are valid + for some supported language version, and the 'all_decomp' table to + be the decompositions of all characters without those + constraints. */ + +static void +read_table (char *fname, bool aliases_p) +{ + FILE *f = fopen (fname, "r"); + const char *sname = aliases_p ? "NameAliases.txt" : "UnicodeData.txt"; + + if (!f) + fail ("opening %s", sname); + for (;;) + { + char line[256]; + unsigned long codepoint; + const char *name, *aname; + char *l; + size_t i; + + if (!fgets (line, sizeof (line), f)) + break; + codepoint = strtoul (line, &l, 16); + if (l == line && aliases_p) + { + /* NameAliased.txt can contain comments and empty lines. */ + if (*line == '#' || *line == '\n') + continue; + } + if (l == line || *l != ';') + fail ("parsing %s, reading code point", sname); + if (codepoint > MAX_CODE_POINT) + fail ("parsing %s, code point too large", sname); + + name = l + 1; + do { + ++l; + } while (*l != ';'); + + aname = NULL; + if (aliases_p) + { + /* Ignore figment and abbreviation aliases. */ + if (strcmp (l + 1, "correction\n") != 0 + && strcmp (l + 1, "control\n") != 0 + && strcmp (l + 1, "alternate\n") != 0) + continue; + i = ARRAY_SIZE (generated_ranges); + } + else + { + for (i = 0; i < ARRAY_SIZE (generated_ranges); ++i) + if (codepoint >= generated_ranges[i].low + && codepoint <= generated_ranges[i].max_high) + break; + if (i != ARRAY_SIZE (generated_ranges)) + { + if (*name == '<' && l[-1] == '>') + { + if (codepoint == generated_ranges[i].low + && l - name >= 9 + && memcmp (l - 8, ", First>", 8) == 0 + && generated_ranges[i].ok == 0) + { + generated_ranges[i].ok = INT_MAX - 1; + aname = generated_ranges[i].prefix; + codepoint = GENERATED + generated_ranges[i].idx; + } + /* Unfortunately, UnicodeData.txt isn't consistent + with the Table 4-8 range endpoints in 3 cases, + the ranges are longer there by a few codepoints. + So use the max_high hack to avoid verification + failures. */ + else if (codepoint == generated_ranges[i].max_high + && l - name >= 8 + && memcmp (l - 7, ", Last>", 7) == 0 + && generated_ranges[i].ok == INT_MAX - 1) + { + generated_ranges[i].ok = INT_MAX; + continue; + } + else + fail ("unexpected generated entry %lx %.*s", + codepoint, (int) (l - name), name); + } + else if (codepoint + == generated_ranges[i].low + generated_ranges[i].ok + && l - name == (strlen (generated_ranges[i].prefix) + + (name - 1 - line)) + && memcmp (name, generated_ranges[i].prefix, + strlen (generated_ranges[i].prefix)) == 0 + && memcmp (name + strlen (generated_ranges[i].prefix), + line, name - 1 - line) == 0) + { + ++generated_ranges[i].ok; + if (codepoint != generated_ranges[i].low) + continue; + aname = generated_ranges[i].prefix; + codepoint = GENERATED + generated_ranges[i].idx; + } + else + fail ("unexpected generated entry %lx %.*s", + codepoint, (int) (l - name), name); + if (aname == generated_ranges[i].prefix) + { + size_t j; + + /* Don't add an entry for a generated range where the + same prefix has been added already. */ + for (j = 0; j < i; ++j) + if (generated_ranges[j].idx == generated_ranges[i].idx + && generated_ranges[j].ok != 0) + break; + if (j < i) + continue; + } + } + else if (*name == '<' && l[-1] == '>') + continue; + } + + if (num_entries == num_allocated) + { + num_allocated = num_allocated ? 2 * num_allocated : 65536; + entries = (struct entry *) xrealloc (entries, num_allocated + * sizeof (entries[0])); + } + + if (aname == NULL) + { + char *a = (char *) xmalloc (l + 1 - name); + if (l - name > max_entry_len) + max_entry_len = l - name; + memcpy (a, name, l - name); + a[l - name] = '\0'; + aname = a; + } + entries[num_entries].name = aname; + entries[num_entries++].codepoint = codepoint; + } + if (ferror (f)) + fail ("reading %s", sname); + fclose (f); +} + +/* Assumes nodes are added from sorted array, so we never + add any node before existing one, only after it. */ + +static void +node_add (struct node **p, const char *key, size_t key_len, + unsigned long codepoint) +{ + struct node *n; + size_t i; + + do + { + if (*p == NULL) + { + *p = n = (struct node *) xmalloc (sizeof (struct node)); + ++num_nodes; + assert (key_len); + n->sibling = NULL; + n->child = NULL; + n->key = key; + n->key_len = key_len; + n->codepoint = codepoint; + return; + } + n = *p; + for (i = 0; i < n->key_len && i < key_len; ++i) + if (n->key[i] != key[i]) + break; + if (i == 0) + { + p = &n->sibling; + continue; + } + if (i == n->key_len) + { + assert (key_len > n->key_len); + p = &n->child; + key += n->key_len; + key_len -= n->key_len; + continue; + } + /* Need to split the node. */ + assert (i < key_len); + n = (struct node *) xmalloc (sizeof (struct node)); + ++num_nodes; + n->sibling = NULL; + n->child = (*p)->child; + n->key = (*p)->key + i; + n->key_len = (*p)->key_len - i; + n->codepoint = (*p)->codepoint; + (*p)->child = n; + (*p)->key_len = i; + (*p)->codepoint = NO_VALUE; + key += i; + key_len -= i; + p = &n->sibling; + } + while (1); +} + +static void +append_nodes (struct node *n) +{ + for (; n; n = n->sibling) + { + nodes[num_nodes++] = n; + append_nodes (n->child); + } +} + +static size_t +sizeof_uleb128 (size_t val) +{ + size_t sz = 0; + do + { + val >>= 7; + sz += 1; + } + while (val != 0); + return sz; +} + +static void +size_nodes (struct node *n) +{ + if (n->child) + size_nodes (n->child); + if (n->sibling) + size_nodes (n->sibling); + n->node_size = 1 + (n->key_len > 1) * 2; + if (n->codepoint != NO_VALUE) + n->node_size += 3; + else if (n->sibling == NULL) + ++n->node_size; + n->size_sum = 0; + n->child_off = 0; + if (n->sibling) + n->size_sum += n->sibling->size_sum; + if (n->child) + { + n->child_off = n->size_sum + (n->codepoint == NO_VALUE + && n->sibling == NULL); + n->node_size += sizeof_uleb128 (n->child_off); + } + n->size_sum += n->node_size; + if (n->child) + n->size_sum += n->child->size_sum; + tree_size += n->node_size; +} + +static void +write_uleb128 (unsigned char *p, size_t val) +{ + unsigned char c; + do + { + c = val & 0x7f; + val >>= 7; + if (val) + c |= 0x80; + *p++ = c; + } + while (val); +} + +static void +write_nodes (struct node *n, size_t off) +{ + for (; n; n = n->sibling) + { + assert (tree[off] == 0 && off < tree_size); + if (n->key_len > 1) + { + assert (n->key_len < 64); + tree[off] = n->key_len; + } + else + tree[off] = (n->key[0] - ' ') | 0x80; + assert ((tree[off] & 0x40) == 0); + if (n->codepoint != NO_VALUE) + tree[off] |= 0x40; + off++; + if (n->key_len > 1) + { + tree[off++] = n->key_idx & 0xff; + tree[off++] = (n->key_idx >> 8) & 0xff; + } + if (n->codepoint != NO_VALUE) + { + assert (n->codepoint < (1L << 21)); + tree[off++] = n->codepoint & 0xff; + tree[off++] = (n->codepoint >> 8) & 0xff; + tree[off] = (n->codepoint >> 16) & 0xff; + if (n->child) + tree[off] |= 0x80; + if (!n->sibling) + tree[off] |= 0x40; + off++; + } + if (n->child) + { + write_uleb128 (&tree[off], n->child_off); + off += sizeof_uleb128 (n->child_off); + write_nodes (n->child, off + n->child_off); + } + if (n->codepoint == NO_VALUE + && n->sibling == NULL) + tree[off++] = 0xff; + } + assert (off <= tree_size); +} + +static void +build_radix_tree (void) +{ + size_t i, j, k, key_idx; + + for (i = 0; i < ARRAY_SIZE (generated_ranges); ++i) + if (generated_ranges[i].ok == INT_MAX) + { + if (generated_ranges[i].max_high - generated_ranges[i].high > 15UL) + break; + } + else if (generated_ranges[i].ok == (generated_ranges[i].high + - generated_ranges[i].low + 1)) + { + if (generated_ranges[i].max_high != generated_ranges[i].high) + break; + } + else + break; + if (i < ARRAY_SIZE (generated_ranges)) + fail ("uncovered generated range %s %lx %lx", + generated_ranges[i].prefix, generated_ranges[i].low, + generated_ranges[i].high); + /* Sort entries alphabetically, node_add relies on that. */ + qsort (entries, num_entries, sizeof (struct entry), entrycmp); + for (i = 1; i < num_entries; ++i) + if (i && strcmp (entries[i].name, entries[i - 1].name) == 0) + fail ("multiple entries for name %s", entries[i].name); + + for (i = 0; i < num_entries; ++i) + node_add (&root, entries[i].name, strlen (entries[i].name), + entries[i].codepoint); + + nodes = (struct node **) xmalloc (num_nodes * sizeof (struct node *)); + i = num_nodes; + num_nodes = 0; + append_nodes (root); + assert (num_nodes == i); + /* Sort node pointers by decreasing string length to handle substrings + right. */ + qsort (nodes, num_nodes, sizeof (struct node *), nodecmp); + if (nodes[0]->key_len >= 64) + /* We could actually encode even 64 and 65, as key_len 0 and 1 will + never appear in the multiple letter key encodings, so could subtract + 2. */ + fail ("can't encode key length %d >= 64, so need to split some radix " + "tree nodes to ensure length fits", nodes[0]->key_len); + + /* Verify a property charset.cc UAX44-LM2 matching relies on: + if - is at the end of key of some node, then all its siblings + start with alphanumeric characters. + Only 2 character names and 1 alias have - followed by space: + U+0F0A TIBETAN MARK BKA- SHOG YIG MGO + U+0FD0 TIBETAN MARK BKA- SHOG GI MGO RGYAN + U+0FD0 TIBETAN MARK BSKA- SHOG GI MGO RGYAN + so the KA- in there will always be followed at least by SHOG + in the same node. + If this changes, charset.cc needs to change. */ + for (i = 0; i < num_nodes; ++i) + if (nodes[i]->key[nodes[i]->key_len - 1] == '-' + && nodes[i]->child) + { + struct node *n; + + for (n = nodes[i]->child; n; n = n->sibling) + if (n->key[0] == ' ') + fail ("node with key %.*s followed by node with key %.*s", + (int) nodes[i]->key_len, nodes[i]->key, + (int) n->key_len, n->key); + } + + /* This is expensive, O(num_nodes * num_nodes * nodes[0]->key_len), but + fortunately num_nodes is < 64K and key_len < 64. */ + key_idx = 0; + for (i = 0; i < num_nodes; ++i) + { + nodes[i]->key_idx = SIZE_MAX; + nodes[i]->in_dict = false; + if (nodes[i]->key_len > 1) + { + for (j = 0; j < i; ++j) + /* Can't rely on memmem unfortunately. */ + if (nodes[j]->in_dict) + { + for (k = 0; k <= nodes[j]->key_len - nodes[i]->key_len; ++k) + if (nodes[j]->key[k] == nodes[i]->key[0] + && memcmp (nodes[j]->key + k + 1, nodes[i]->key + 1, + nodes[i]->key_len - 1) == 0) + { + nodes[i]->key_idx = nodes[j]->key_idx + k; + j = i; + break; + } + if (j == i) + break; + for (; k < nodes[j]->key_len; ++k) + if (nodes[j]->key[k] == nodes[i]->key[0] + && memcmp (nodes[j]->key + k + 1, nodes[i]->key + 1, + nodes[j]->key_len - 1 - k) == 0) + { + size_t l; + + for (l = j + 1; l < i; ++l) + if (nodes[l]->in_dict) + break; + if (l < i + && memcmp (nodes[l]->key, + nodes[i]->key + (nodes[j]->key_len - k), + nodes[i]->key_len + - (nodes[j]->key_len - k)) == 0) + { + nodes[i]->key_idx = nodes[j]->key_idx + k; + j = i; + } + else + j = l - 1; + break; + } + } + if (nodes[i]->key_idx == SIZE_MAX) + { + nodes[i]->key_idx = key_idx; + nodes[i]->in_dict = true; + key_idx += nodes[i]->key_len; + } + } + } + if (key_idx >= 65536) + /* We only use 2 bytes for offsets into the dictionary. + If it grows more, there is e.g. a possibility to replace + most often seen words or substrings in the dictionary + with characters other than [A-Z0-9 -] (say LETTER occurs + in the dictionary almost 197 times and so by using a + instead of LETTER we could save (6 - 1) * 197 bytes, + with some on the side table mapping 'a' to "LETTER". */ + fail ("too large dictionary %ld", (long) key_idx); + dict_size = key_idx; + + size_nodes (root); + + dict = (char *) xmalloc (dict_size + 1); + for (i = 0; i < num_nodes; ++i) + if (nodes[i]->in_dict) + memcpy (dict + nodes[i]->key_idx, nodes[i]->key, nodes[i]->key_len); + dict[dict_size] = '\0'; + + tree = (unsigned char *) xmalloc (tree_size); + memset (tree, 0, tree_size); + write_nodes (root, 0); +} + +/* Print out the huge copyright notice. */ + +static void +write_copyright (void) +{ + static const char copyright[] = "\ +/* Unicode name to codepoint.\n\ + Copyright (C) 2005-2022 Free Software Foundation, Inc.\n\ +\n\ + This program is free software; you can redistribute it and/or modify it\n\ + under the terms of the GNU General Public License as published by the\n\ + Free Software Foundation; either version 3, or (at your option) any\n\ + later version.\n\ +\n\ + This program is distributed in the hope that it will be useful,\n\ + but WITHOUT ANY WARRANTY; without even the implied warranty of\n\ + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n\ + GNU General Public License for more details.\n\ +\n\ + You should have received a copy of the GNU General Public License\n\ + along with this program; see the file COPYING3. If not see\n\ + .\n\ +\n\ +\n\ + Copyright (C) 1991-2021 Unicode, Inc. All rights reserved.\n\ + Distributed under the Terms of Use in\n\ + http://www.unicode.org/copyright.html.\n\ +\n\ + Permission is hereby granted, free of charge, to any person\n\ + obtaining a copy of the Unicode data files and any associated\n\ + documentation (the \"Data Files\") or Unicode software and any\n\ + associated documentation (the \"Software\") to deal in the Data Files\n\ + or Software without restriction, including without limitation the\n\ + rights to use, copy, modify, merge, publish, distribute, and/or\n\ + sell copies of the Data Files or Software, and to permit persons to\n\ + whom the Data Files or Software are furnished to do so, provided\n\ + that (a) the above copyright notice(s) and this permission notice\n\ + appear with all copies of the Data Files or Software, (b) both the\n\ + above copyright notice(s) and this permission notice appear in\n\ + associated documentation, and (c) there is clear notice in each\n\ + modified Data File or in the Software as well as in the\n\ + documentation associated with the Data File(s) or Software that the\n\ + data or software has been modified.\n\ +\n\ + THE DATA FILES AND SOFTWARE ARE PROVIDED \"AS IS\", WITHOUT WARRANTY\n\ + OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE\n\ + WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n\ + NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE\n\ + COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR\n\ + ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY\n\ + DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,\n\ + WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS\n\ + ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE\n\ + OF THE DATA FILES OR SOFTWARE.\n\ +\n\ + Except as contained in this notice, the name of a copyright holder\n\ + shall not be used in advertising or otherwise to promote the sale,\n\ + use or other dealings in these Data Files or Software without prior\n\ + written authorization of the copyright holder. */\n"; + + puts (copyright); +} + +static void +write_dict (void) +{ + size_t i; + + printf ("static const char uname2c_dict[%ld] =\n", (long) (dict_size + 1)); + for (i = 0; i < dict_size; i += 77) + printf ("\"%.77s\"%s\n", dict + i, i + 76 > dict_size ? ";" : ""); + puts (""); +} + +static void +write_tree (void) +{ + size_t i, j; + + printf ("static const unsigned char uname2c_tree[%ld] = {\n", + (long) tree_size); + for (i = 0, j = 0; i < tree_size; ++i) + { + printf ("%s0x%02x%s", j == 0 ? " " : "", tree[i], + i == tree_size - 1 ? " };\n\n" : j == 11 ? ",\n" : ", "); + if (j == 11) + j = 0; + else + ++j; + } +} + +static void +write_generated (void) +{ + size_t i, j; + + puts ("static const cppchar_t uname2c_pairs[] = {"); + for (i = 0; i < ARRAY_SIZE (generated_ranges); ++i) + { + if (i == 0) + ; + else if (generated_ranges[i - 1].idx != generated_ranges[i].idx) + puts (", 0,"); + else + puts (","); + printf (" 0x%lx, 0x%lx /* %s */", + generated_ranges[i].low, + generated_ranges[i].high, + generated_ranges[i].prefix); + } + puts (", 0 };\n"); + + puts ("static const unsigned char uname2c_generated[] = {"); + for (i = 0, j = -1; i < ARRAY_SIZE (generated_ranges); ++i) + { + if (i == 0 || generated_ranges[i - 1].idx != generated_ranges[i].idx) + printf ("%s %d /* %s */", i ? ",\n" : "", + ++j, generated_ranges[i].prefix); + j += 2; + } + puts (" };\n"); +} + +/* Main program. */ + +int +main (int argc, char **argv) +{ + size_t i; + + if (argc != 3) + fail ("too few arguments to makeradixtree"); + for (i = 0; i < ARRAY_SIZE (generated_ranges); ++i) + if (!generated_ranges[i].max_high) + generated_ranges[i].max_high = generated_ranges[i].high; + read_table (argv[1], false); + read_table (argv[2], true); + build_radix_tree (); + + write_copyright (); + write_dict (); + write_tree (); + write_generated (); + printf ("static const unsigned int uname2c_max_name_len = %ld;\n\n", max_entry_len); + return 0; +} --- gcc/testsuite/c-c++-common/cpp/named-universal-char-escape-1.c.jj 2022-08-20 13:39:31.101523260 +0200 +++ gcc/testsuite/c-c++-common/cpp/named-universal-char-escape-1.c 2022-08-20 18:04:43.128581037 +0200 @@ -0,0 +1,174 @@ +/* P2071R2 - Named universal character escapes */ +/* { dg-do run } */ +/* { dg-require-effective-target wchar } */ +/* { dg-options "-std=gnu99 -Wno-c++-compat" { target c } } */ +/* { dg-options "-std=c++23" { target c++ } } */ + +#ifndef __cplusplus +#include +typedef __CHAR16_TYPE__ char16_t; +typedef __CHAR32_TYPE__ char32_t; +#endif + +#ifdef __cplusplus +#if U'\u0000' != U'\N{NULL}' \ + || U'\u0001' != U'\N{START OF HEADING}' \ + || U'\u0002' != U'\N{START OF TEXT}' \ + || U'\u0003' != U'\N{END OF TEXT}' \ + || U'\u0004' != U'\N{END OF TRANSMISSION}' \ + || U'\u0005' != U'\N{ENQUIRY}' \ + || U'\u0006' != U'\N{ACKNOWLEDGE}' \ + || U'\u0007' != U'\N{ALERT}' \ + || U'\u0008' != U'\N{BACKSPACE}' \ + || U'\u0009' != U'\N{CHARACTER TABULATION}' \ + || U'\u0009' != U'\N{HORIZONTAL TABULATION}' \ + || U'\u000A' != U'\N{LINE FEED}' \ + || U'\u000A' != U'\N{NEW LINE}' \ + || U'\u000A' != U'\N{END OF LINE}' \ + || U'\u000B' != U'\N{LINE TABULATION}' \ + || U'\u000B' != U'\N{VERTICAL TABULATION}' \ + || U'\u000C' != U'\N{FORM FEED}' \ + || U'\u000D' != U'\N{CARRIAGE RETURN}' \ + || U'\u000E' != U'\N{SHIFT OUT}' \ + || U'\u000E' != U'\N{LOCKING-SHIFT ONE}' \ + || U'\u000F' != U'\N{SHIFT IN}' \ + || U'\u000F' != U'\N{LOCKING-SHIFT ZERO}' \ + || U'\u0010' != U'\N{DATA LINK ESCAPE}' \ + || U'\u0011' != U'\N{DEVICE CONTROL ONE}' \ + || U'\u0012' != U'\N{DEVICE CONTROL TWO}' \ + || U'\u0013' != U'\N{DEVICE CONTROL THREE}' \ + || U'\u0014' != U'\N{DEVICE CONTROL FOUR}' \ + || U'\u0015' != U'\N{NEGATIVE ACKNOWLEDGE}' \ + || U'\u0016' != U'\N{SYNCHRONOUS IDLE}' \ + || U'\u0017' != U'\N{END OF TRANSMISSION BLOCK}' \ + || U'\u0018' != U'\N{CANCEL}' \ + || U'\u0019' != U'\N{END OF MEDIUM}' \ + || U'\u001A' != U'\N{SUBSTITUTE}' \ + || U'\u001B' != U'\N{ESCAPE}' \ + || U'\u001C' != U'\N{INFORMATION SEPARATOR FOUR}' \ + || U'\u001C' != U'\N{FILE SEPARATOR}' \ + || U'\u001D' != U'\N{INFORMATION SEPARATOR THREE}' \ + || U'\u001D' != U'\N{GROUP SEPARATOR}' \ + || U'\u001E' != U'\N{INFORMATION SEPARATOR TWO}' \ + || U'\u001E' != U'\N{RECORD SEPARATOR}' \ + || U'\u001F' != U'\N{INFORMATION SEPARATOR ONE}' \ + || U'\u001F' != U'\N{UNIT SEPARATOR}' \ + || U'\u007F' != U'\N{DELETE}' \ + || U'\u0082' != U'\N{BREAK PERMITTED HERE}' \ + || U'\u0083' != U'\N{NO BREAK HERE}' \ + || U'\u0084' != U'\N{INDEX}' \ + || U'\u0085' != U'\N{NEXT LINE}' \ + || U'\u0086' != U'\N{START OF SELECTED AREA}' \ + || U'\u0087' != U'\N{END OF SELECTED AREA}' \ + || U'\u0088' != U'\N{CHARACTER TABULATION SET}' \ + || U'\u0088' != U'\N{HORIZONTAL TABULATION SET}' \ + || U'\u0089' != U'\N{CHARACTER TABULATION WITH JUSTIFICATION}' \ + || U'\u0089' != U'\N{HORIZONTAL TABULATION WITH JUSTIFICATION}' \ + || U'\u008A' != U'\N{LINE TABULATION SET}' \ + || U'\u008A' != U'\N{VERTICAL TABULATION SET}' \ + || U'\u008B' != U'\N{PARTIAL LINE FORWARD}' \ + || U'\u008B' != U'\N{PARTIAL LINE DOWN}' \ + || U'\u008C' != U'\N{PARTIAL LINE BACKWARD}' \ + || U'\u008C' != U'\N{PARTIAL LINE UP}' \ + || U'\u008D' != U'\N{REVERSE LINE FEED}' \ + || U'\u008D' != U'\N{REVERSE INDEX}' \ + || U'\u008E' != U'\N{SINGLE SHIFT TWO}' \ + || U'\u008E' != U'\N{SINGLE-SHIFT-2}' \ + || U'\u008F' != U'\N{SINGLE SHIFT THREE}' \ + || U'\u008F' != U'\N{SINGLE-SHIFT-3}' \ + || U'\u0090' != U'\N{DEVICE CONTROL STRING}' \ + || U'\u0091' != U'\N{PRIVATE USE ONE}' \ + || U'\u0091' != U'\N{PRIVATE USE-1}' \ + || U'\u0092' != U'\N{PRIVATE USE TWO}' \ + || U'\u0092' != U'\N{PRIVATE USE-2}' \ + || U'\u0093' != U'\N{SET TRANSMIT STATE}' \ + || U'\u0094' != U'\N{CANCEL CHARACTER}' \ + || U'\u0095' != U'\N{MESSAGE WAITING}' \ + || U'\u0096' != U'\N{START OF GUARDED AREA}' \ + || U'\u0096' != U'\N{START OF PROTECTED AREA}' \ + || U'\u0097' != U'\N{END OF GUARDED AREA}' \ + || U'\u0097' != U'\N{END OF PROTECTED AREA}' \ + || U'\u0098' != U'\N{START OF STRING}' \ + || U'\u009A' != U'\N{SINGLE CHARACTER INTRODUCER}' \ + || U'\u009B' != U'\N{CONTROL SEQUENCE INTRODUCER}' \ + || U'\u009C' != U'\N{STRING TERMINATOR}' \ + || U'\u009D' != U'\N{OPERATING SYSTEM COMMAND}' \ + || U'\u009E' != U'\N{PRIVACY MESSAGE}' \ + || U'\u009F' != U'\N{APPLICATION PROGRAM COMMAND}' \ + || U'\u0020' != U'\N{SPACE}' \ + || U'\u0030' != U'\N{DIGIT ZERO}' \ + || U'\u0053' != U'\N{LATIN CAPITAL LETTER S}' +#error Bad +#endif +#endif +#if U'\U0001F402' != U'\N{OX}' \ + || U'\U0001FBA9' != U'\N{BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO MIDDLE RIGHT AND MIDDLE LEFT TO LOWER CENTRE}' \ + || U'\u01FD' != U'\N{LATIN SMALL LETTER AE WITH ACUTE}' \ + || U'\u2118' != U'\N{WEIERSTRASS ELLIPTIC FUNCTION}' \ + || U'\u2118' != U'\N{SCRIPT CAPITAL P}' \ + || U'\uFEFF' != U'\N{BYTE ORDER MARK}' \ + || U'\uFEFF' != U'\N{ZERO WIDTH NO-BREAK SPACE}' \ + || U'\u116C' != U'\N{HANGUL JUNGSEONG OE}' \ + || U'\u1180' != U'\N{HANGUL JUNGSEONG O-E}' \ + || U'\u0F60' != U'\N{TIBETAN LETTER -A}' \ + || U'\u0F68' != U'\N{TIBETAN LETTER A}' \ + || U'\u0F0A' != U'\N{TIBETAN MARK BKA- SHOG YIG MGO}' \ + || U'\u0FD0' != U'\N{TIBETAN MARK BKA- SHOG GI MGO RGYAN}' \ + || U'\u0FD0' != U'\N{TIBETAN MARK BSKA- SHOG GI MGO RGYAN}' \ + || U'\uFE18' != U'\N{PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRAKCET}' \ + || U'\uFE18' != U'\N{PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRACKET}' \ + || U'\uAC00' != U'\N{HANGUL SYLLABLE GA}' \ + || U'\uAC02' != U'\N{HANGUL SYLLABLE GAGG}' \ + || U'\uAD8D' != U'\N{HANGUL SYLLABLE GWEONJ}' \ + || U'\uAE4D' != U'\N{HANGUL SYLLABLE GGAG}' \ + || U'\uAE4E' != U'\N{HANGUL SYLLABLE GGAGG}' \ + || U'\uC544' != U'\N{HANGUL SYLLABLE A}' \ + || U'\uC55F' != U'\N{HANGUL SYLLABLE AH}' \ + || U'\uC560' != U'\N{HANGUL SYLLABLE AE}' \ + || U'\uD7A3' != U'\N{HANGUL SYLLABLE HIH}' \ + || U'\u3400' != U'\N{CJK UNIFIED IDEOGRAPH-3400}' \ + || U'\u4DBF' != U'\N{CJK UNIFIED IDEOGRAPH-4DBF}' \ + || U'\u4E00' != U'\N{CJK UNIFIED IDEOGRAPH-4E00}' \ + || U'\u9FFC' != U'\N{CJK UNIFIED IDEOGRAPH-9FFC}' \ + || U'\U00020000' != U'\N{CJK UNIFIED IDEOGRAPH-20000}' \ + || U'\U0002A6DD' != U'\N{CJK UNIFIED IDEOGRAPH-2A6DD}' \ + || U'\U00020700' != U'\N{CJK UNIFIED IDEOGRAPH-20700}' \ + || U'\U0002B734' != U'\N{CJK UNIFIED IDEOGRAPH-2B734}' \ + || U'\U0002B740' != U'\N{CJK UNIFIED IDEOGRAPH-2B740}' \ + || U'\U0002B81D' != U'\N{CJK UNIFIED IDEOGRAPH-2B81D}' \ + || U'\U0002B820' != U'\N{CJK UNIFIED IDEOGRAPH-2B820}' \ + || U'\U0002CEA1' != U'\N{CJK UNIFIED IDEOGRAPH-2CEA1}' \ + || U'\U0002CEB0' != U'\N{CJK UNIFIED IDEOGRAPH-2CEB0}' \ + || U'\U0002EBE0' != U'\N{CJK UNIFIED IDEOGRAPH-2EBE0}' \ + || U'\U00030000' != U'\N{CJK UNIFIED IDEOGRAPH-30000}' \ + || U'\U0003134A' != U'\N{CJK UNIFIED IDEOGRAPH-3134A}' \ + || U'\U00017000' != U'\N{TANGUT IDEOGRAPH-17000}' \ + || U'\U000187F7' != U'\N{TANGUT IDEOGRAPH-187F7}' \ + || U'\U00018D00' != U'\N{TANGUT IDEOGRAPH-18D00}' \ + || U'\U00018D08' != U'\N{TANGUT IDEOGRAPH-18D08}' \ + || U'\U00018B00' != U'\N{KHITAN SMALL SCRIPT CHARACTER-18B00}' \ + || U'\U00018CD5' != U'\N{KHITAN SMALL SCRIPT CHARACTER-18CD5}' \ + || U'\U0001B170' != U'\N{NUSHU CHARACTER-1B170}' \ + || U'\U0001B2FB' != U'\N{NUSHU CHARACTER-1B2FB}' \ + || U'\uF900' != U'\N{CJK COMPATIBILITY IDEOGRAPH-F900}' \ + || U'\uFA6D' != U'\N{CJK COMPATIBILITY IDEOGRAPH-FA6D}' \ + || U'\uFA70' != U'\N{CJK COMPATIBILITY IDEOGRAPH-FA70}' \ + || U'\uFAD9' != U'\N{CJK COMPATIBILITY IDEOGRAPH-FAD9}' \ + || U'\U0002F800' != U'\N{CJK COMPATIBILITY IDEOGRAPH-2F800}' \ + || U'\U0002FA1D' != U'\N{CJK COMPATIBILITY IDEOGRAPH-2FA1D}' +#error Bad +#endif + +const char32_t *a = U"\N{HEBREW LETTER KAF}\N{HEBREW LETTER FINAL NUN}"; +const char32_t *b = U"\N{OX}\N{BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO MIDDLE RIGHT AND MIDDLE LEFT TO LOWER CENTRE}"; + +#define b\N{LATIN SMALL LETTER O WITH ACUTE}x U'\U0001FBA9' + +int +main () +{ + if (a[0] != U'\u05DB' || a[1] != U'\U000005DF' || a[2] + || b[0] != U'\U0001F402' || b[1] != b\u{f3}x || b[2]) + __builtin_abort (); + return 0; +} --- gcc/testsuite/c-c++-common/cpp/named-universal-char-escape-2.c.jj 2022-08-20 13:39:53.783218362 +0200 +++ gcc/testsuite/c-c++-common/cpp/named-universal-char-escape-2.c 2022-08-20 13:41:38.852805993 +0200 @@ -0,0 +1,18 @@ +/* P2071R2 - Named universal character escapes */ +/* { dg-do compile } */ +/* { dg-options "-std=gnu99 -Wno-c++-compat" { target c } } */ +/* { dg-options "-std=c++23" { target c++ } } */ + +int jalape\N{LATIN SMALL LETTER N WITH TILDE}o = 42; + +int +caf\N{LATIN SMALL LETTER E WITH ACUTE} (void) +{ + return jalape\u00F1o; +} + +int +test (void) +{ + return caf\u00e9 (); +} --- gcc/testsuite/c-c++-common/cpp/named-universal-char-escape-3.c.jj 2022-08-20 17:11:56.662620753 +0200 +++ gcc/testsuite/c-c++-common/cpp/named-universal-char-escape-3.c 2022-08-20 18:19:57.786455576 +0200 @@ -0,0 +1,22 @@ +/* P2071R2 - Named universal character escapes */ +/* { dg-do compile } */ +/* { dg-require-effective-target wchar } */ +/* { dg-options "-std=gnu99 -Wno-c++-compat" { target c } } */ +/* { dg-options "-std=c++23" { target c++ } } */ + +#ifndef __cplusplus +typedef __CHAR32_TYPE__ char32_t; +#endif + +const char32_t *a = U"\N{}"; /* { dg-error "empty named universal character escape sequence" } */ +const char32_t *b = U"\N{NU" "LL}"; /* { dg-error "'\\\\N\\{' not terminated with '\\}' after" } */ + /* { dg-error "is not a valid universal character" "" { target c } .-1 } */ +const char32_t *c = U"\N{ I've just made it up }"; /* { dg-error "'\\\\N\\{' not terminated with '\\}' after" } */ + /* { dg-error "is not a valid universal character" "" { target c } .-1 } */ +const char32_t *d = U"\N{_________ _______}"; /* { dg-error "is not a valid universal character" } */ +const char32_t *e = U"\N{O.X}"; /* { dg-error "'\\\\N\\{' not terminated with '\\}' after" } */ + /* { dg-error "is not a valid universal character" "" { target c } .-1 } */ +const char32_t *f = U"\N{.}"; /* { dg-error "'\\\\N\\{' not terminated with '\\}' after" } */ + /* { dg-error "is not a valid universal character" "" { target c } .-1 } */ +const char32_t *g = U"\N{BOM}"; /* { dg-error "is not a valid universal character" } */ +const char32_t *h = U"\N{ZWNBSP}"; /* { dg-error "is not a valid universal character" } */ --- gcc/testsuite/c-c++-common/cpp/named-universal-char-escape-4.c.jj 2022-08-20 17:49:22.227798169 +0200 +++ gcc/testsuite/c-c++-common/cpp/named-universal-char-escape-4.c 2022-08-20 18:23:57.803274374 +0200 @@ -0,0 +1,60 @@ +/* P2071R2 - Named universal character escapes */ +/* { dg-do compile } */ +/* { dg-require-effective-target wchar } */ +/* { dg-options "-std=gnu99 -Wno-c++-compat" { target c } } */ +/* { dg-options "-std=c++23" { target c++ } } */ + +#ifndef __cplusplus +typedef __CHAR32_TYPE__ char32_t; +#endif + +const char32_t *a = U"\N{ZERO WIDTH NO BREAK SPACE}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{ZERO WIDTH NO-BREAK SPACE\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *b = U"\N{giraffe face}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{GIRAFFE FACE\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *c = U"\N{Giraffe Face}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{GIRAFFE FACE\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *d = U"\N{ GiRaFfE_fAcE__ ___}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{GIRAFFE FACE\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *e = U"\N{GIRAFFE}"; /* { dg-error "is not a valid universal character" } */ +const char32_t *f = U"\N{Hangul_Syllable_gAgg_}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{HANGUL SYLLABLE GAGG\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *g = U"\N{HANGUL SYLLABLE gagg}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{HANGUL SYLLABLE GAGG\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *h = U"\N{HANGULSYLLABLEGAGG}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{HANGUL SYLLABLE GAGG\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *i = U"\N{HANGUL_SYLLABLE_GAGG}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{HANGUL SYLLABLE GAGG\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *j = U"\N{HANGUL SYLLABLE }"; /* { dg-error "is not a valid universal character" } */ +const char32_t *k = U"\N{CJK-COMPATIBILITY-IDEOGRAPH-2F801}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{CJK COMPATIBILITY IDEOGRAPH-2F801\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *l = U"\N{CjK_COMPATIBILITY IDEOGRAPH 2f801}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{CJK COMPATIBILITY IDEOGRAPH-2F801\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *m = U"\N{CjK_COMPATIBILITY IDEOGRAPH 2f80}"; /* { dg-error "is not a valid universal character" } */ +const char32_t *n = U"\N{CJK COMPATIBILITY IDEOGRAPH-}"; /* { dg-error "is not a valid universal character" } */ +const char32_t *o = U"\N{CJK COMPATIBILITY IDEOGRAPH-X}"; /* { dg-error "is not a valid universal character" } */ +const char32_t *p = U"\N{Tibetan Letter A}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{TIBETAN LETTER A\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *q = U"\N{Tibetan LetterA}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{TIBETAN LETTER A\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *r = U"\N{Tibetan Letter-A}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{TIBETAN LETTER A\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *s = U"\N{Tibetan Letter -A}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{TIBETAN LETTER -A\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *t = U"\N{TibetanLetter -A}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{TIBETAN LETTER -A\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *u = U"\N{Hangul Jungseong oe}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{HANGUL JUNGSEONG OE\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *v = U"\N{Hangul Jungseong o- e}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{HANGUL JUNGSEONG O-E\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *w = U"\N{HangulJungseongo-e}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{HANGUL JUNGSEONG O-E\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *x = U"\N{Hangul Jungseong oe __ }"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{HANGUL JUNGSEONG OE\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *y = U"\N{Hangul Jungseong o- e __ }"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{HANGUL JUNGSEONG O-E\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *z = U"\N{Hangul Jungseong o -e}"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{HANGUL JUNGSEONG O-E\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *A = U"\N{Hangul Jungseong o -e __ }"; /* { dg-error "is not a valid universal character" } */ + /* { dg-message "did you mean \\\\N\\{HANGUL JUNGSEONG O-E\\}\\?" "" { target *-*-* } .-1 } */ +const char32_t *B = U"\N{O}"; /* { dg-error "is not a valid universal character" } */ --- gcc/testsuite/c-c++-common/Wbidi-chars-25.c.jj 2022-08-20 18:42:05.460862462 +0200 +++ gcc/testsuite/c-c++-common/Wbidi-chars-25.c 2022-08-20 18:46:40.884214767 +0200 @@ -0,0 +1,28 @@ +/* PR preprocessor/103026 */ +/* { dg-do compile } */ +/* { dg-options "-Wbidi-chars=ucn,unpaired" } */ +/* Test nesting of bidi chars in various contexts. */ + +void +g1 () +{ + const char *s1 = "a b c LRE\N{LEFT-TO-RIGHT EMBEDDING} 1 2 3 PDI\N{POP DIRECTIONAL ISOLATE} x y z"; +/* { dg-warning "unpaired" "" { target *-*-* } .-1 } */ + const char *s2 = "a b c RLE\N{RIGHT-TO-LEFT EMBEDDING} 1 2 3 PDI\N{POP DIRECTIONAL ISOLATE} x y z"; +/* { dg-warning "unpaired" "" { target *-*-* } .-1 } */ + const char *s3 = "a b c LRO\N{LEFT-TO-RIGHT OVERRIDE} 1 2 3 PDI\N{POP DIRECTIONAL ISOLATE} x y z"; +/* { dg-warning "unpaired" "" { target *-*-* } .-1 } */ + const char *s4 = "a b c RLO\N{RIGHT-TO-LEFT OVERRIDE} 1 2 3 PDI\N{POP DIRECTIONAL ISOLATE} x y z"; +/* { dg-warning "unpaired" "" { target *-*-* } .-1 } */ + const char *s5 = "a b c LRI\N{LEFT-TO-RIGHT ISOLATE} 1 2 3 PDF\N{POP DIRECTIONAL FORMATTING} x y z"; +/* { dg-warning "unpaired" "" { target *-*-* } .-1 } */ + const char *s6 = "a b c RLI\N{RIGHT-TO-LEFT ISOLATE} 1 2 3 PDF\N{POP DIRECTIONAL FORMATTING} x y z"; +/* { dg-warning "unpaired" "" { target *-*-* } .-1 } */ + const char *s7 = "a b c FSI\N{FIRST STRONG ISOLATE} 1 2 3 PDF\N{POP DIRECTIONAL FORMATTING} x y z"; +/* { dg-warning "unpaired" "" { target *-*-* } .-1 } */ +} + +int A\N{LEFT-TO-RIGHT EMBEDDING}B\N{POP DIRECTIONAL ISOLATE}C; +/* { dg-warning "unpaired" "" { target *-*-* } .-1 } */ +int a\N{RIGHT-TO-LEFT EMBEDDING}B\N{POP DIRECTIONAL ISOLATE}c; +/* { dg-warning "unpaired" "" { target *-*-* } .-1 } */ --- gcc/testsuite/gcc.dg/cpp/named-universal-char-escape-1.c.jj 2022-08-20 18:39:17.748083650 +0200 +++ gcc/testsuite/gcc.dg/cpp/named-universal-char-escape-1.c 2022-08-20 17:27:39.556111606 +0200 @@ -0,0 +1,8 @@ +/* P2071R2 - Named universal character escapes */ +/* { dg-do compile } */ +/* { dg-require-effective-target wchar } */ +/* { dg-options "-std=gnu99 -Wno-c++-compat -pedantic" } */ + +typedef __CHAR32_TYPE__ char32_t; + +const char32_t *a = U"\N{ETHIOPIC SYLLABLE SEE}"; /* { dg-warning "named universal character escapes are only valid in" } */ --- gcc/testsuite/gcc.dg/cpp/named-universal-char-escape-2.c.jj 2022-08-20 18:39:19.829056106 +0200 +++ gcc/testsuite/gcc.dg/cpp/named-universal-char-escape-2.c 2022-08-20 17:27:50.323968411 +0200 @@ -0,0 +1,8 @@ +/* P2071R2 - Named universal character escapes */ +/* { dg-do compile } */ +/* { dg-require-effective-target wchar } */ +/* { dg-options "-std=gnu99 -Wno-c++-compat -pedantic-errors" } */ + +typedef __CHAR32_TYPE__ char32_t; + +const char32_t *a = U"\N{ETHIOPIC SYLLABLE SEE}"; /* { dg-error "named universal character escapes are only valid in" } */ --- gcc/testsuite/g++.dg/cpp/named-universal-char-escape-1.C.jj 2022-08-20 17:25:25.196896042 +0200 +++ gcc/testsuite/g++.dg/cpp/named-universal-char-escape-1.C 2022-08-20 17:27:22.628336712 +0200 @@ -0,0 +1,6 @@ +// P2071R2 - Named universal character escapes +// { dg-do compile { target c++11 } } +// { dg-require-effective-target wchar } +// { dg-options "-pedantic" } + +const char32_t *a = U"\N{ETHIOPIC SYLLABLE SEE}"; // { dg-warning "named universal character escapes are only valid in" "" { target c++20_down } } --- gcc/testsuite/g++.dg/cpp/named-universal-char-escape-2.C.jj 2022-08-20 17:25:28.190856333 +0200 +++ gcc/testsuite/g++.dg/cpp/named-universal-char-escape-2.C 2022-08-20 17:27:10.689495477 +0200 @@ -0,0 +1,6 @@ +// P2071R2 - Named universal character escapes +// { dg-do compile { target c++11 } } +// { dg-require-effective-target wchar } +// { dg-options "-pedantic-errors" } + +const char32_t *a = U"\N{ETHIOPIC SYLLABLE SEE}"; // { dg-error "named universal character escapes are only valid in" "" { target c++20_down } } Jakub --BS73ox2G6DZ7ACPo Content-Type: application/x-xz Content-Disposition: attachment; filename="uname2c.h.patch.xz" Content-Transfer-Encoding: base64 /Td6WFoAAATm1rRGAgAhARwAAAAQz1jM5IlS7/5dABboBA2GkxqD8xLdu7kJMAnOicxg606R/HIc 0TdC3JRgLdGbezNqKVayYZA+44ZL/G9fF6yTTvPYOgXx9wzVbAua2oegU3Omyx2nKCLKj5IxC39+ KyTivORXeCnmUo+qE3fywaNE63EHB3nyy3BIdgEReqG3EqKEJb/8qT9zHgUH7LCzKULgK8IJ7j/j iwxLbiKIbUYiNeZj8heNUPkUMy/xgLQdZhfvp5VfmfLy+7kjKyNDBQrAdu1nRWxlBsWol7wQOPs4 Rmu+NY01djxPxhgDcnn7Nq3FI+EfucosH47Pd8zYv6lzh1ZwSHY3+ZvTxZw+ZDDGdTlh+pCzmguk QujTLgc6mt9K6WEo8ZTj4KSYZYAOSgYJXd8t3XRW9mzUzj3yQm49RjQ1TlPuXqzTGNOohDdMfJqs CVoGk25Yy6gfM1w2UMOGs0T8xqq6ah5WilaL99adNTOB3nBxU3id8OLryA/AZASYyChOtwWjbS0I YaoUZG3Z4B4KVovYBN0vI00UGYsNmjGhCWSVX4d4qHQmJE0OJeHs4h1KQMH/E5h8hxhpDkYtFdLb +zx62mlVlbp4+YcoZlsKyKNHfD2WN8MVwwxuXTcT4wOeOYHFpmg1dKC4IjlaGaujJIIS9pFgrocx wwnRjXQOBN+cGYVI46fVakarYiv2d+NZtU+XlkUEml0icyzw0BFizylaYcc0LPOmp0D0O6UGDCRq dCxIijuY4qEMoUCTUIZBfhDv/voiW/hQqFJfXOWsGIbd4ExQ/QHO37usvWPbadz1DzbAQYcuw/HG 14f8NAnCI2MVLRKqhFQXyVDp6LwKRIWlFWIWVuqe/DAN9tXliJzFBsIUhSW2laAJ+k3vIj3/Bd6M YkjsgS4tQYEhTKG7gG5i/02ffIeSj1wyansrlfRUbpwgfbRx1gsgPi2ZsvWVJ/TkEV/MwsF+SwXj Yknc6ok+7vjT1jfkoGwpJq5/UnuSRHCPip8HM5omd7zxxiqg/jtU/AzHJ+TvW2uJ6ZONwS/YUahb Ki79AQX2dgNGNoouwCI5IEWSCfou511xZmLZjy/QKKhwunz7H5cYoDzNgVQAdaiR/3QEeqkvqGdj Ze+1qV9SiCc50MckHJP4C79Xa6KpSyVP2ZrM50VIIx9EFl3kMZSekCBfKCZuUnNMFAoMtOaHH/Cw ppleg5+jPgaNL2Fv52E9IQPzF7nHP598JFlrKL9z8yV2jsAA00ZbNq0MA7t48ZEe37kdbzsxlNy6 d1ow1XP+VamnKS+wg3TZvLBy9NnEoXd8T0n5YdsjSvLHSpc4WlsPVyi5TFYkrI3csb2J6BzKNXKL t9g0wsC5B101qXOsgZozRas5oaBUwfaTwTqpiKre/TW0nk0yBqLUG3ho1uvOmHnavRDudbNZiW+b zO8LBsYyyo4ENcz81lO7a6RtY9du/7MRNlLRxJQLvFmEmzHO70SaneeZtGQTxMqtbi4tNJXesncm GTm/vZJZPEi8tST4theK7VJ1w2f4+CQRJsfElUo5Mhwm4Vokcms8KLzGC256kF/kUV/9iOK2pvUb nhbQXBm4/sLk9Mkscs7tXHCE6WOG7aAUpHeI3Ze20TzVEigAIZoUV/4JXUqjO3S43DTEjWTSXJ4V suhXkNbbFR+1Prm64Y+9YhSUBz2myWL7sOGxsOzb+ArfL+E5KM+zFgTOAobiWPwLwz+hZ6HZkNpF 6ovDgxPefNeowvmVLQanrMktOcoL45fnQa1NCE86MpGAMk3o8W38LZnSBdWFP2hbO4wsnzTdTBc6 hX6DOusXgVcCeBDUFZSR621l5WnK8L0zJbhUGs8MXDhUfi7yzZpQKzjTGg+d5WDqTnIzopPcapUJ hK44jyFVsPiYeFqDvOpzpxEyYLOz49Y5iLCx3/EnSXXltLANXxa2J7++e0qte/mvqpgRjNMmUt+7 8OZqIPRlUxximgWhZbjw/NKZDt84cOK8XTSzS0TzV7YKPtxWdk2H8jgXl6RJbfKcOoWEIGhDcNAB 8QuODFAuHekD+JYX0BUhSenmKm7rd5zfLOCcHRnfkjxMyALRkgYAmaGOEjf6O1vxqcI8g+q+eb1W EWEI1bZHivIuGv3XahsBejDAwiPjeukhXivtkZ08kiFGWejz33YdqDM5iP4HsBI9eYwhQqIJsh6t By00TD5gWuG+WnOliUy45Dyp8dMybKqEYiTxdJ3HMOTOqXHWfpjm6oKTs06nSQifNn0pMyWDybUq XtW/7iJYrFS33VOK0pWyHakCgKACScEixt7ZEkr4H8IL26S2+RZmfs+nDAKjzxISJ8PpT3iQYOOq GrqX5iI5ckna3n1gvb6zOJWsBN/th3DLDHOvTjqGZPwnWWFwSizAd2JLbp7eRf7YJzE6Kbkw3d52 D82BsxRNGall47bq/gThJr6W6gjCqpmBVwTD+wGoWg7VMKUwIONM/fh0XHkcPXZvxgOCIU0Hfk5/ FRz+pbA7WoI7U1LEzG4c1G9JMll6ODPi+6xLW9erYSGlfSwKH3D1L2DD1yEgkieD2NiCdOqc5wju n4rIgo4iWrUTbFk105R99g8XjosojJGf0U1Wsn4mHKyJUpXyC2/URYD+K7AKkXbO40U1nbob4vLh EPqibdvlmXeKzpGgMb+D8z4ORjDey1FflvQuKE9o1RXLBI1lPW1b01573pNZcUZNrbujzEy3OcMd 1ouKPTpf3WH53enCj2aWbQiE19yGTtYLu5U+uUb90onL6op/kj3QDjgL95iMWqSuG5CHfnSXiclC h0X7pXHxkEcjMH5SswTbwwmDPZE2NSo4hAvkbjyteGzHerHpoGY9TU0oBAVv/IntdLTiedYPObw3 IA4fz8VUmLCdXE2Io08ysnVDjzPha8k4qW1J4WBJT/0ovcH+5v96UbjEHWdZaaL5GG9YKdXLgJ70 dcsjuHE8OWRryoiRAJJzQhyHbRCPCkrXg34vA4cFXnTdzQ77XJoI7pYxlWJ498GdJlS5cFHiHzNw kYKjnns6qWKn37//ICbvrNtWTjWmvwGggIuAtXDlnWqFWi3bY9zhNFo1XggK5PEJBVCyY1HcIthY nqo28tl4O2WxMKW1fBOjFoMTS8nKgcvaaGaCPjdRO0AUZh4hwkbI3n43glYn1Jh6lYO8GLPwGNgn wA5kUyzDIl5Pagz4Jzh/40LXuY1AS833cv1cZbGEQzU5CnHGPeH/GxMTlYsuYPbQXvSAmEvaGOEZ urPU8fud+XJoIcsnEq6OC7EZeubElIav3gm9v2+mrMEA8WkJn9hI+0iQ+Q3Yd4llHJ6H5gPhHY9g iqdByle9cR9uhVvnMalBbWPpCPlSRPniKGf9Jy1JqZBQNfiSV7/zccVT1rCjSTwEXLcgU6K7kIn6 af2CjZKOAh5/FyRrpH2k8SD5IIRU8vSE+oy09BAKQAnVnQrMEFCyCC8hP6DvcQPkpAD90xGUj9Z6 Xi5H37SOzyDhS6FI2tCWebYJmA12Hcf8XPQq1MSDlZRPgei/jn4jv3hhwBXpxSTgqQOBQXhigSCW McqzQY4bBoc+wMC2NLZ14H03BiLxhD/j+RbFJbob7gf7cX7i4LL370OM6jaXcR/4PYI9sPVRGR1Y MxY4Vs/Na1JAtfw4nr5VqzWNjaeWkTpC22txY329qJ7lO4ILm8xTYpKFDo5BHrLUxP8GOmABibDo F7HfHUqaMdn/HhEZUT/j/m5QrUMmoMbxwMFvMMy0hxBaE8RdS5HGm98pPYpHvGMhaFxdkH37LrYJ f+Lf9Cw6FQDRrHPRLTEcaqdg02Ien2EBx7Y4MyitixqWf9Ztxnb8jxyFz6gr3InNgC5HgxmczA6O P27RnAOIDkU0tf1o5FqsSRtRXHr78a6u40Zy5ltT/gIjSYdyDjB+1T9rFGOm3MNnxprX1ZVAqpwI 5CdJpVzeCFhxZ/E5ou4wx7d1IZpJxc0uy6jLYA+DsY3oHCh3P3+3MA5gfGza6Txxf5qwBA6iPl9K DvUMHiSMQAOXO/awfp2UjbYch63zrwDNLBZd9m2EaM+HKwSDu/jQcsmm7ZJQPnMy4W2IixhI6BtU foWrzdDOE9X8TLfBJX9WkJpOekAMg8NImadVI97FiNXyE2UMBP87CRvzNLgiFqZM2gub1PDEJ5SG TkIeSAHrkkg026q9fSoSnlHRUDhukCZDgQaEB+nMQufSKdC0StsLyLtpm5VU2zAE92yJrx0qgTsD 4r9pegCF8ZWK47M85oOgfDhJe+Sbyg2Sgl7MWrpbYCAMrpI1po72+P2B1JAhQQKZzN6SaS/utag6 MR752v9XxrNm5Nc3rUjuqsSl4bw9YHK/QAotgCVM4dBB5tkP7xddNee3lHqPYFfC1XAk84w3VarN cw7BhNflfBA6z56a12CuDKDFFMpYS5wrWoVLrx9dBOc/k7fA7SWa5mC7h+e14a6qVkRDE81BIJCa 8C3fgVPvfBtsCSodcxJzpSzDgov+5BsvjDcSs0LLPZMfA9kalvB8d7xjUju4F9rriIjP1nMU30qC Ox9NzF4EXn2h8pYB/i+Fg/fAJayIUnwDwrMDIwPNgcf/j3lsqRFTlamwrkaHtP+PrQoZU5IzjY48 AvUYr07vXaJBLrRetI88/bMpLmteupWGWNC6tUp1GMQ5Oij3LyWLS3PKLCC3Qnobv1QGWpSdBZi/ 4FtQkQt6nAwnP0narqTT4tFOGCslqBfI1YF+Tg/8h0fFc8rAvcKIqHy3a7PYqYFNoq9Y0ryEhGya nojVxTXtRA5L7f/XpQp2xVZ5HcBfH1kM4tmKrrzM0qzaEEhWYLaBYxy5qIaEfpu1fzleU+2OLIg4 FtDxZHdbGO19zDbJaBoEc3ZQ29qxfFTYaOtwO4QDiif/afQhQkl3ljE+U/5Wi6+AwuCV7kiBKzNw eHcvfaotgO7KdPQFv6FtfR3K+ps5EOn5tPHg3j79paVnnFp7F6RLAiA7gQ/I7CnkRTLWhFDkO25G U+wkJdZeUCaWpZOMXY/MbwzocQsMU1TQJRq03zgrepEKGAlnAvFkLrt5gsV4FrSGiPx1HsdMUdKD cZ1wSvrNnRLutiOgICXVfvJvG6x5CeVJbqYJ/bG9rsRzb87okSyNJN/Sb9xJjLlSZLzxfsedqX+6 9DBcscftldP365N6I4kL5sGET5gqXQHvbndNcXMCCafuXw28Ikx7NRf2cuvACdm9Bl8zs28QtILs NCiFgCHzwKqNcE0BhF2GEUbAGZ8xG/4Xd+798FjuWGM/oBxdJ90HkeoU6ML485TngKw8NF039i/d zZ9RiM+SGpo9lKM+X952LKKxj4HhcO6VJTaPX3Meufsv46WwMnVB03rgyc6qRQd8400zKtMD9mRT CUyWEm++5jQAxM3NzT5hunN/Hw2J0rJ00SHbrIwqKfoXFBtw7swsnCFDrRGwTZRX1heqfTSxEoSc cAqxBUa5lq1IrtlUkfJUq61cFetotyNpynXaU6VZrfVB7IpuppnM8TvJQfjCswloKR1K8TwgY+ow ygT9mLkuAriIevw6wV3lM3lClQICK4hMOaxsYw+RipsGBrKuJIKRaXIyZdLdznh0obcPSZFvc3xO kewNL+eITijhCxlQAuKTrEoMm8HGtd9k9X6Gt6WkA9PbYozLG8ilFBm7iU54NJHaaLRz110If+cG XCPGdnegWzCuxyQ3XnzVbXfdQhoctppRKYgXcgsrh6xyryUtCK4U+AV/t8FkN2I3zms3olRTskXl QegZRC5AZe2FwIyvKg7MX8bnDyAz9wsQVzfgmWCXhOqNW4kNqY6Tz7wnrINLm2A/VhP6CWhYvans hve9udvJZKil0zjYnsR5R3ZhhP7CCEpij+IVpE/xkFkuBOI4xk4YSjJOXLNtB2Q4THJopsCl30gG LpbeLnXKiuWo5r913+dlE9cgvTLgPj5PumacuNTZv75Vw721HUs5ArfLtLL0BiHQWSV/yFleiVwr VWqxpMq36OabZmCRHNcsxMAt1Yz6tO0oeJw+Fi39ZejEDVoVfXSEuJ/VHAHKHH81O6OnXlRK2+nR Tg4ZuJXNE3Xo9SMu2LNWFtvypxiBZLLixWgbELdVc/Ih1V2vAro/hU5rm7R/wDVOiYJ/6gU/wbHX Bj6ZU0OjIc+CRhbH2wvI+5z4oQZ00F4iWZqIPgJeDdy1S5Z/CO99K8FGNfQWJlmsP22LUyibMjUa gFexJPZ3eczrYjD0wsyXDT3gFZ1n0ogIHkw7r7D3Hvt55S2DroBH9YDcazEBNkscsr1D2CD5Vt8A T3vqwXtucmqxOkInPEPLOK1Oqp9A8X7nzBxSjQxzZfIC71+E5HzvT7KFBookGjhCHEaUDMjqjq4w j+P4jyFIqJUbuEv0iFk3qHEyB8Yzrf2pxZdG4PH0LDeISL/a0hj4eUNO8JHR7trCUlFMisyLqz/E cpDsGHC/8nrE99qPxWto8DUNC2JTFxfopiLCd5rh/i5ugtf3drOKI2fVF/X/VK2pFSJ+PyhYfaB7 0Myk/uEviP5fx47sSsuHuZAteFTYHcjpOltJiMg+dkuhgZ+5MNIdFjaVErE6KhB4VckyGGF5l0K1 WVeLB5CTG9njNERjs93omIhkoRrCgYENKQ2NyKXylCDPHxIXqkdI7A76N6uZz4mOJFwRzalf1Kgc yePRLhh0hqt9m9c4v4lJqwOf13kHuRpWo0DesAt1DYHMrYdQbarWv/tx+zaLbp56jYED5QPOfo0j w+8SII1q43boapPgWdrmy+GZdtxEz9mL7yJdSmJmuBfkNSIwbERmrtC9+oMM8mRjpPNMhsFegob9 GPiLIOMHW6LBAwrMS+kOjjCNP+ThmRXML34YX43p1e8IcIw2+/UVUTzcinHIFp7gxp/pEfltxIY+ nI97YkGz5GslRj+SK5AGxbhy9k09eG0RMeu2u3cLjmZ8zuOnIsNj2yLi21LPbUTMgZw1890w2TIB 2X2/c84TKOMzej3ZlVGzftnyHG2YI7t+7NzkwCfSi3WjrSa2sCX9Yro2UD0Vs3Z9ZxE47mhw0AuM kIs+791Xx07zPcQOxzpBFjyc0L26vB6QGr6+dh0DNKB14sXJbdCKVelqX1QLnlBAhFYIcK9DOg6w HPZA8gZR7wlxIxT7K4u79CHkYpWIf4cn8bQdT4MuQpWEHXez+dgmm1C73XHF/pVtu8XmBSI7lc4o uOF1jlsQ15JCI8i03pDmg1QWe6DpQVUbzfR8jgxeNDMGmVmZ7fcSbIQn+xLR7EJxfNXf9/wDQYs6 lmwGgL8c0QbAVJZkRBEzB3mDK0qIoOm6mWLHkPw7uPc9NdZ6a8hsVTpB8ef98VFRtMQFfYmMv6Xl SDo4Ce6quMSWjnNUTi1scOgVjKYgnTyg5bFIMJvRI7wioVhbAJAckPtR+QOyqTzvVtLCRmVat1gS kStcv/XLPfb0oHfZO3Ro8BHIdPK8NpwSBlzIcS7FaLPrqxPRF61qaiPOWl6ejLUYBvNbOD3j5wTI uoQx11KAP3BE8jXQaX2o1S4TCZW5d3SsB1IonbV5vcdEYFW76h2saOy42qgrBLcY7610QYZMJ5wT uQiYERr4UF4Eed6KJutV7vh6V/+oL/BjhLxO7coKd3VFzGqbVjMoQdSskOmpw7wH2tmc5XYSsRIx qy0IqbMbs4ofivLViipZm27ROIRSLapxF4BPk0tQuJU4Fw5m/PYY3l1SHVTap/ONBD/jxRHSwyPf mtserzg1GHSGAhCRzH66blFUEA+txDfwvP46YX+0MNlpRp6SweKSBwygiNlOTNTzHsBDiwwatWgV ayrx/DQAgWOoqKQYjNIRfM3tBcwqCdYaVwKAb+8i2R4tXaq22FAVkgqjtys8VcT03DYj1P60Lveu 0H/5YYs4o7kfbyiCXnmmqztQebPyfy1ozrMqrsKX8PCfaDR9Jdb17LLaoOVSiv7TNpHtRrqWKAsW CdzNoAHsLAN7zo75D0EpsAEVVwh4RjRC43IQuFYjL1CUCB6zu8BgkJGFZyvuPmhFmLMF/5ch+gdM 1IMknHsuSda2QvRO7d7YMLM5m898g4dCGCO4hMK2nnAO/B0utTlpMAS0YgbA4ngoi1kwPwQtD5c1 YyvC3mPLXWtkujvKoPc30ckSdumFgi6shBYTq95zjN4BjjwjSkGbSu8nkMz88zZhQGXsVUkBsh+j iRN3fU3EdpWcYIqS5dUdzGMMPQTM9R7U2JWtFgA7qu6kDca2z4ynHmw/6J3V0OxSM2Aen74w6f58 OjOBX6zjAqlURkSOLqLxu55hOZ+1rpHY32GL3S5eSupLqzMfu86B/T5htbA0gPCZY9qkm9hf/sOj PPub5MkQI5we93c65P3eHczFRwNSzWj5jtQmSNyBNKpmAZttMnFevGHvJ9qSPxi1R9qNHOf/AKTY B/AZnVYwRuUrZdjtQX7SrhSt0QcZEPM5S5jlgCLCVz38GCxykcSNki9seByi9wzWKdLlHeirSDMu 8SLgm7s5nIcDJfspxeG1gFMDHBTULL4MBubY/3tz+EBYkIETpSGmH6T5tHLmkiWGWCElrheD2Hwt S6syAlOU/4PWEhbAZeCjydPI9bVSWgCxVKQIjl3yOwJGYh7DripW+hgtPVN/VQYkZcK7dFCdqcU6 7r2m6SriUHTDHwU0AdB5LpqjeZzxTlmJkkx71aWBjjwoFRlP8bcVMH4Tgb/B6iEQsGbEnRJCVc8G sqqpdSge4xFGL5Etifo5XsrtKs8JQMZG+hzsYL5WiGbx0/MvITaWo01IKivRcG66RBY07b7TRycH EMTDK+HNJUwJXYXycyH74Je6ngocZn31Jdye0Z6d9epRwgllaNC+jukr2BbSY1cCNshz2behUUzX OF+ldfjvqMi9O44sh7NqupnzAcwUmivKbV5DXJ/0HS4+DpbvW0noGHzEXymyYmGY3+gRKQiI25G5 dCiBztsLN9C8aCfcK2MElsR3xrfhCELUktja0bsMmZiTxhezG6I2ktYO++lO94JzVjxZwRI/EBIP 3ARdewRRXXEZCnV+sLmeHdgK/WZo33CprKB8WAWeqTEYOF3RMWqC0dJFAGuWv+J9ClGpt+cjEwyo BfGOszXQrft13r+FzfYvhqxDtExsO3XAdISE5mRs96J6bC4Su1jee2JuEuayyPpHasAHekkQX+ty pfoecxD6x+x09gWUyr8hbOrvX2pLQ9QWHgMUp6/X+QQor7aTNw3GZXrL8zsrTQZHY5D8s/S1XDR6 rCVtp7q5utUBgIHHysb26pBQFjLoQFHq9NQaKD5MuDWVklxoK+n9+poGUsNo92fvDOJyQ/Jdbv/5 vVF0d+OvwM3lCzBwXMqjZ8zu66tUgf1bzNPreF5PaWpGQt8XPqQ5wRoSaP2RU8migKsQ8e8DfOOF BpR8zwBHltS9WhaJzrM9BnIoAEkp4Ybj+KS8Afkr9NJn9CqUQtroQsOHJv8ZFqD9rlaOKAvJVLun huRGQAhOmyeuLOraOlNZMz5xXyAvZH5e23mfRdVWX7awzFfZwBNX3mWaJ1W1ckY2fsVQBKidhiUX QQnWyliUNIpvVWIzd8SL+YucsE7CEt1liXKTYecPEpm8XsojYJu9w7iIza2otC695zr7mcElTox3 NgUCxUGNfpgnt8cQRAyDup1n2p4aUmMteXaN2gyPT1tLvxwkwcv2gPNmX/83j5kQbknO7TNCrBOS PScUXgJLoWjiGH+HshqdkXqeG0ep9PLQ0cJ1MISp2pIrnvLXMpDXj0SaujiaYxuQcXzxiQIcA9hM BZhN0FZLggg6RfaoicUrRImQQagUrHdpLzuouSZ4rPWSdjdWMKb3MXlA7SyjE1qi0nWxO9YHlDj3 8j7wvYEYIP8xSne+4Zyhh7/PqZy4GKg8SqYl+gl3oEHe18v9C1fHGNkPkVB9YwxkYPvLr5AxKGu8 UXsDtFXo7KvuTb+I9+U9akbhfZLvj/MN5G9rcnSctzULHD72ggZjMxNzieMDVpeB+cihFCI4tI8s PBjFn2juLmCDczCbc9bRMqd8l4hiVpsgbiTIN+NmW7Udx1qdSyt8VcstkKxwroCERSm2HSZnwzMl 7ZmLigqDigmnVWFhJOtdZ7bxC3abbpsG6FUNluJPKr833/kjIV24SH5SCvKbuWkl164Q2vhgwnod g45WI47mylWcd3NWlxa9UPIroGhW9MH+9G8n9GPfsaJlspi1fB5C3xv/JSk68liXrhpiVIhKlQqY ujXB7cOIXWMP3d4819M3iu0qD4cjSuSMzLwehTgDHVtPeWGyPkBdY+jFhOOPcXAiIGHXjF67XtyE nqxVmSkNXgKjb+piC+GryQ6uAgmgDFK5izvpU2/cNUKkvBgLwVNTFIkMsRetuDLYNVtIOxowDNsC D4hNHPPWm3qxI2ZgKsFcJT0CWeuhJpmcjTyhoI7IAMMIyfxSYdhTtUfakhbXSzZb+gozYHBpVpT9 pM7iOTGQCO/MLat6ZCipvBdXWOeoYVU98YQv2x3074jsuvjp0QPsdHuWZS0zqWGUEtyH8y/NUaeA c7hXxEa7F0cYuHMlxW632AkCjfmou1dp2AVKeMg85oxeBddGN/HVzY3I/wb8L81f9BbODy5Q89q9 vMsoJYSTHkB47Pn8hMtStyY7imEz2I0OSkq+eLtKzdbliuaijji9vwb9//rSZfbqYJnrHdAvnW5w 7TId43veoZM5JTDv/udEdFpwV5IopMhXO/VLk4j6u9/qkv1harn5QP+oK+2TuycvUZsLC7xnA/65 IjnFVSBB/5+bHSn/qdhUTKCpxEE6VT427DlMlxfm28ILF1Tdg3p1taiB1iITeJAOyl3fD2Re5FgH 4NtCJHPFJcj8JHX/v1BKwOtTnYkNvvGg5qsiV5W9DxHO2HPx2VKYO5Y/bN70IvI6tX452mvRip76 /MHK9Bzja2d0pQvb5nnvG1f20HIPIaoeVqCNZkSftw0ELIPklIP5m5TnHz1BU9Rd1HP6qi1zXBB1 jviGmfTpWM9lc5a7MxgO2G5oSk2vPXuavy4Owiz4/fQ36q3x6Np97KPO+z3/RGG0jMtfSFBpbqMV oNlceqjcRcdJaxQdaYT8TsyBm7+EA4xQZ45JYWOGLer1K7tGvQCerc3TPfsk8sSA0uB/YB+MHUZP L2AdUTZFyZzKx5aTTQJ+PvqYlV/nIGsPTlpQd7pCveNKWgjCIt4ZoPh7xmgoHbE83dpgKf44ceiw ikzLsx3pWRxmNd70QDLogdYS2sa2RPYLM6vcgrqJkzp5up8LWoMfU4v4uzwCphwCgo6MVIdrmsyh SX/tucnWWiZFckmX+H+RmmhYF/l2uHFg4LT13/y3o85UIcTRDBiJ50Y91Ff/z3vtiArbmh8RqwW/ JtSvMV/VXorGUv1+UkU6l+kGyRmdmr57k8a5Hp+gS3IBszLrUR6bJa8CFa6QWSGQSjjWD/e4536Y gNS0DDJ+MsDZbF31zrqRxemry5F658vmi5NYtquqwzx077I2HFu825ZxEm3nHu0Zd2Cr7rM5Y5Ah 2xFiOmnug0cNAN7933Nldbym1mk2A6ZBmccQFv6bNV0bUx070YStCqZYXO+WvJeVCaT8YkQ3GKn3 gOh28wznbxQNyiobdB7iMHYUaYXIj/9R/jbHYxCdAq4l8eHWD1olkGpqLwJACxmGarOyHuk5ZO7q 1E6HCNmNkMlcaJbsA/WdkL8sRCoOQhWMCkBlp7+80N523EMl1BYXMEhLtCU/HqDpE6Jimby4KTI0 uonQEVPo9WuyKeeiFIIowLxS5iesPzazSno1wwYJR8U0AcBzmqqHByiLcF46PsSxmG30M0d1/3/1 Cj9Z3WZOyvXt9QSpckCfjA1g/YyjXJqEb6nLJdRBEJy92c1Oygk0v3bQikTBGVrNMj/vKVPMhVyJ nBCJ6Fefbrn4D7RM6oU0lkXC3DT8S3AF35Cvd+Wc4GamuzTOu/fhLYoFvtMAeKoHuwhhRj/sOMIh fsm9ZhIcvv8lrL2NDRq0Z3LLQ6yCV/3POT9C1mVoZJiW+x29dM07sJT3XA2bCtaqRCVAlTa/bm0/ 6U3IKJKKaj97h9lY0wATRsKWXpJY32V7gKJFQhTCoHn7SkcnL2KPF4k1oqu5FaUzWXbs0dEa3CDV Q4l3vvupDq+77mJmkCw6+zLEDBvZFwe6jDDQZI2RmKo/2Kdmk1c0SyWgdAbLQiFpIKyx+l3XqObY +KwArfhPKmOMqF7iHo0F5w8X1HGxRfmCNMEPR8wduMCF6srF2flkSS8QJdsiiXiqZSBi4Buj5DB8 9AILCLVOxP9kpAtURezBgj4U5G0t6YsRfYtqizZBVljNylQiZgRHvyhtfwzlnE3lpPU+q/gK+BcU /h6w38wMIhl0aavLSodLCZIfJSKS+jlKjLrr6NtvOGE0RwQksvgh9FT3MD503C8T3jVfifk7EEKw zKxlGKtk51iV5/om/yxxJg/jGXyHyxxv2sM8pPKEw/PUVeYnpjd+rXk8li4TrK5/d8SlJXGBU9ou 5rv6i87sn27fMzkKMeQm1saA1YzsEjljkU5sZnX6J75R+A251Abvdm6UyOMD1ao7V9oZF/DGihkS zU4ZoedRzmrr1spDyJieKBkT6SpkbR2YY2VYYMirgnErXLixnIYPiUjl73dEdAaibqHUNm3MQYxg SfbHTa/Ax3UYyH7eb6UbcVFrt+SNAAGzawSxg9XIqZBfqPj6lK5KAm/hdLKGcCYU/g1i7Owk3m+3 C9Qrs8jot/VpeBtURME6S4yJPD1/W+tFKBxizzXUpTtcdiAsas/hM3jooBeseY8r/qblFaUCn9HH h98c22NHyvn7DDaLf0/pOfKW4ANwtKEV1J6LwxY+akJKCR+AijZ/qigL1RZ39G1LtNe2meVaE1pD MyVspvrzCpMIk6YpxDDacqn2W0ZMNL0aNmN+Yzu3V7KJH5TK7EC9luUtk++Hsx03tCl3CaIDG07d XW7ZMiXddVtLvXbWghKYU7if3oy1oEQt58UoPDHNkNomcbDINQJh7EuscD1z3Q7KTPjlWmnyTP35 GaOTAHzTVIxY5LAJ3KRIbyj7eFvidtPCQRddMj8wKRQl5365K4Pbgeo/thtpVgwBFcLTPvfhAO3r UKJ9betqSigEa38Rs+0XpYC0DVAnT91gMpypt4fsR1R4XvnThgXL7RgC4eDUaOBW8Cb7hLxRzn6X Y3FNgCS0P9y9YSAhDD3grYz0eDhGaHUIEf6u9/jwO5oHxpEuA+H24kZHwmpCG1SirzXKbtVB1Yww 6Xs8Y/bCSc7xunFFXrbG8jUe+2y4yNmGf6cxdUHxi9u4mXCyP266njAJ/sh5Ianxi42nfMnd6/tO AcfEDIqOPVNodJoA9NDhVBslTHtA5dFSTg/oZcEsp/k0Ov3JBxhycMu4qx8bcZ09JFdKhXLPNLva UftmSpJlnfnqBN/BeY+B0Ls20KN0+YD0z83Tl/1FIHW84QLlRBUW9P76qfDMpJthj0xrCz+hyxH+ KIA2ZQp3RrZvuITCNoEtB53mvGp24F23SZKvXGU2MzDFymXkI3MMpSg3YAbIBbuCITzN7olRbRN+ UDYmQK9QvvZcyz8ibN1vw1yCsHmSAnL73EHgnN6RkdmEjq/D3Kexf8RKdwslFg0Ul6uY+JrCnDkv cYJCudAPMHgBuVa6qx+J3dWhaBvTXnWe6EJx9qwtS/KeHf5MWUjLIOhllPoZekSekeJdGwtQepzb /aZRjBbnCYRfXX2qP756YXvzV9IpY99y5e5DkINES6g4Qo3GWomiDYyYXZQViPNNVYpKATEkkp3Q QBRwP6hS8K+dT5hH6PdQtfPIc4R4N9fXhlsEkXOhq71PGmWc7+T+NCuesuXETPDfSQ378cM6D0Lm t3gGVazPRYJC/da2CmrxDHQ7p1xB22zDjYNFDbNHLs5tTsxKSNcZsSZEtrNya62kQiAjhP7b7feI DCzNPx0/vr7FzHJHKDqHCYB/i69depi1O/l7w2Nsq9p2+fImh0yE1u4VWC52yZ9hrr3eBu/q+G5E rxzV4Ln9b96YMfAvH895genaMLdEUJpjKjuJuSebnaw7KkG25x+ZEPOeowx+PbdwnHuePSStWsz7 wehVFFmCuorEv38d9EzgsCQXj4zyWJAVqFgsredo7ghp7bwar1weVe0EgU7bWnrrGIduLA+Sv8iR g1Vj9IrhrVCIyVHVSU8TVx4p0w9fvLO6IO0V04J5RP2yBnckLxBw7QfImXF+BlV4/tPDVqgLeHhK FBqmq97Bn2xm/D5ObsnfjovvBB6+LG4tlq8hkLQke3B/4n8WSPetogswFdi9Accgf5chFF5NJ5qs 0TcCjC7oBBZJTsC1y5kmTfpWeb4iWaMNOjwqvkvxyLp1p5MLIf44ah57/X/yLHTJk+0Ojf3okbAe WD57Gv4Xj/I4mdM2ZyqMocd14JMMIOjFigagpIRhhSOZByzWGwjEZFc4x6ciyqLWr/1WqhZSYi+O AE1eWGoT9/z977IJO9cw6m+msgMwIekyXdiUhVakDSgXyENBRg7SV9B5eLMtQqQ41wXXPyDLTNXi +TSjedeOJfd1jjZRXtfgllLQWDR4Bl9XrNd/rwdAHQTuRsPUHwZR5/cyBZD84MhqFNZMAF5L4LB0 i9RPSwmZn50sr0XOLVCsPvTfUfBXYaxPs10eM2yQwHc7J+KNzcL5zw1ijdOO9iYhJ78Jfw6ZqMBB 1PgUcko/3Oqz6RLWkkWoN89CcZ81GB/VtOeCHNQFtYD2QcYxTNXoIw1iUZHRFCTjKA0nEwv9AGCE DAMXxdwRF8X5cKyCt3/WxPh0t2/lV+MvF2fydb9psWcVzsEplrNAlAsI5l3WleUfuwtL2yt/jSbi iYKyGB2JWUeegMPewT08VkPhThvVedejeIxSEfJ00+QsRo9oEnyXz0AvqzoYHk0yUnWYY47J1M6Q rIupkmM2chDLOed9LZaX0bSuUa3ybvwGc/7fMBQS97l+rKf0sH0PQwwR949RM4EfvX6cEzleyr22 P9POn445p9MUAAjBTGleWHOYoJOtWu/wGHiHgz9LykwtjbMsJVm1GCGmCvz7ji+hgL8pzX46D3BX MJGkTnl4HchT/r1pt31634upv5Y4mMJhP0oKDxaoxKOGGkgHpp2PXGUol482NttyVoLJWrLY3W3m ipQxgOgU3Ps9FJA18+4phg8ELE9mYpXmljroxE+I2ErJVMHg98XDVuKNwqemi+oXDD9cCmRfFw8i SPstomxSGvzweT6LAFqGf+v+kD+1XBO9rtIQVOOhaQbRrxgOHO2RZU+a2XZyNWFo+QRBTlqCMjn2 aEhG6C/8cpkVkcMLP5lfEkMHFTqgZb2YFhrEybsXxp71SPGc7WYj0hdpEkqtuWO+agUwj6RBTV5O i2PInGRkq6p+tp6+vGToevhwhDDPGNJwPbQQ3vbiz9Eg6V2m/MAHGl6Mp8//QqW+18LSVHvWKyqk NUSgpRLLffoGv/1uDgGCuo373oEfOg2Bv/dllzv23EI0OWe5oSXK+TfZ0BmpZaMHjdzIkkiQcQAz HB1ft68Vm2r3jppwfmbD38Cmfq0yvvROy88Mnkz7kjWVCKyRZPcaZ+tSSERJxqluP2reuwq7uO3V yboGpZCjHLIIBhbrRN26K1wfj5NqkA3feeGF9aJkTFR8pSLeBtE9aiAnZjNE52jGQN4BL2uuVCjJ dkDqmgO/WbuwSi9VTLLTiiACtEkVpI4FvNg8Vytts8oIJvc3HIveXkAP8NcendAEuAsFablNUeAV IMWaCFElpxcqMq9VqY0Ytk7sJoGVV2JAzSPpzyBp8rhSdGRMS6kQsRfrRCbRxqiH1zaTcr2B0MX+ eGDTJEBAKhMiMpLTTCeHWczHpYQ9OywLYJ3Bfj7OMcvwFMUs+GcVmvRrNLbZpDwHIutJ0a1t4BgU slx9KwVRhHXWOOWxNMdoVL253+nAQnmQWj5Ewdt6SwVU8+H4hWa7NCHKkgNQC7/xeI1CNqUjD2Rj 2cSiORvbe+hk1Nesa05svZ9HEsMXat2bTWHIzAZr5/d2iBoO57VzNQm8XXy1WQiZFIkIPwhQyjRP /A0MjaNjPab1atKfta9akIhIOZ/XGAfbn2MWQzOPA/A7asTx5JLTq5TLwYUyX71rLon5nUMdc5b7 K9gBu2sGi/DCCG3eDsrOOnaBDYqpNz+X1aVnZSoavtc6YZkB882kDedFTtx+gq2XpK/pOCzETBLL 0PJKiELM66SQVmdLi6ne4wl3q9xAqtgr7/BM3K8Ha/fsAP0yhye9L2KUT7bZZAKrCRds6D3QgHpL fYC3bwyz+9SzXpF8kc3OWGfKeUR5C0GpRa2dc5lRr+0zfAKiAGa0l+LAXCkzGnUE73qvr/Pmm/Gx JClvv+ym79qb2bQwzTckHhvIbIgEdC1Sb9/zKjteMJ1F0+qNKC/IqEfbbVV7gnni4JNQaMrMx3/O 4uZ2bVmJrbmEVM4BAPFo8x6LO3Gd+MQ3d+eG17dClvnQ11EzzjaoIpF11dV0P6mNYpTYs/3NUcri gGLqjAKECE7Vs6Siquw1akLxK/Ujguie7PFDxpu+yQEhGwtNS2Jg+WccQ2Yp6LbPSQQsMycd1ipj jXNBLzocph1CjpdH9bnRc6KxdeHLzH5QAuzJVKlX+2nJWpmp3u56+ZxPoZPinzcJ8CcqO3ynCoB1 R8JkpEv9QzQqyjP7W6yh/DmnAuzmY3dL28zTpJnXKfDe7K/mbKNxBuEgTFX/K4FmMcM8ZGi8IaOK LQzNJMqkeIx69PLXds67CFXJl2JCa7gPiUMp0qxQ8XBQbaTGiJA/7LlxAI/kdm7Ma+UuYd+iyCSY Vge9TYvqj3X611EUbXAmPBNzItQrI5wpSrLYmlvLWTWDF59U6pxXX3OPZN89gafeXW2opW8lvy5q A3h60qmsxZDGDvhp30ES/aWKpjwtwaQSry3a2DakI8c4n9RNoqVvyk/e6sBwfI8C+pSQnJEFsmeL z3nD8LeeH94242JbeHFFnKeNSmrn+U54Y4hP3Qgn67Dp1PneaNq5urq98HnTMycUH+XHyWXMn6on RYl60K1ER1cAHW3vUrQgZgVJG4fxrz9osfFOCKHFoIr/dkMFqF/KpdWO+8ekJX6AngfSeQPx+M1D HBr9goP8d4sa2TJe66GTVGc/aM1hjE6sMb6Etr0xUL1yzuwtKuHvAxRls33d4YMon6zXz7q1Cynk t4islYWdeNq20r2+yn/gUGnWwVSS/sbzWrz/vMnCXVqTPlDPtowkEPJfjd2OlDHN3okT8bt2MfB3 XQaHIA/dTvcew+shKmzAZh4qmtYj7mIZQPU75eJzQ3RSjnqL5AluA8i3wFx9sbdZH/OtJqMz8Qfv vDiO4abjay6TQCkD8CChuKnDhrK1cV24iULfoazERyukAs25I8y5m0pZGLDi7Tr7/AJqBEUWvX7n LEUnsJEP03qeO51K+215cg1LpHJxQOPp9bMrB/9j0DSjDFl6QfJRDN7vO0QUkwgNkw+Bi+9iKP/E aH6pauk7Y5TPfocyzT/5Toy7ZLFzXs80ip+SvCkwEujOJkh3U3JyTkK7mInuQBrxhpzDxDsLwcrW 1z0qkkLqT60uGIPDpRP6DTV6Lx9eb1M57DDEB9K77z9P8JcO8CQtW5jYSnW+/u/6BW1fvDVj7OfE M58GID2ZVdCV/dYMCgoJXWtDK3MtHlynvAs9UVTy9bBxSaBrvZRL3aCrqNRQeyfflHyyhDSJIxxa QFl/fi6ThIt97AIJBNXOZRmSoBKI8A/czR7VxSqui6OG9F1ZuvY01yWxZ8Tv/KuQjC+5/eyakNlN /7PWnvudVqLhWrtXyfBJUtWdb74xLP9jaasiz5LmA0OHv2dsw7McSLZPrC2v4k0dp8F8WX8Hbgx7 CQqbBqYvWCwZb/3AnpOZnK7A42eyfvgIrdB6RDNjok3Vpn6BbOtdRiB5MX700w0SJRpBR2pv88Gl bKr6UfvY+UllOc8hLPSCskzUXNaJ4XxDNHq+6af78rlEwUGHRvxFbnSzXfQ+zNOm7f3DBcwuYyPd dnF19fMtY8qFkcXzNLgAxmEefJ2A60hgWWShbTi/h45puCdfgmyGA4614ABwa5WgWtkNSMYby/LC mN8nO14GpfAtnnjNrrn5Vxarb+vGrPyKuishDyoRZvbZZ3l0S9oo5g4xZyCH2jXYXnswju+E0NFR RnHnAHRDRbBG/r5HI26RmZx/TvRK+kwsi821lj+DL0upZY+IC4wvzgX31cWSQMaY94jvWFjXMmNw uu0DV3vOI54UZfSS/AAZ66mJqsAsFmO79WlTYBXimx9HvBpm3EodmQtM57ZKxjrqeYgOX5uFVpZx kY3lBGzmVt5LMnF51kmExLh5gnBeAYzLzNVGKyQaeGGfJ2NcWQQZLrMxMe1O9DBg/w7e1aW1zN7s 8X7SYt6M9ZRSKwfTcGiCZdUdnKBfCVI8jwpVP4dZbYGP5i+wR14KrhNDPclJRxLma+zRaJXjLU6O TtIrssBpCgriOy0uuYeLLkd29iTAcdJ82TgePQ3Ru5zFk2Ha8LbAi92JyU+xEykwBeNpzw20KtUd 6mibW12lCYD1DVFOBaAknMQasGk0WSebMY9ZNxkOOYdoL8Tklv+hqD9+4LFARl06V6NdBUrIjNh/ +CnTrXJD3K5ecCZfSFtBw5f4XOJjWb4IOP7xwaR3gaFEeOYAb/do77RH20X9d2LaCKwYJxi6etU/ f5MPfv+5CYkWo6t9zCQVyATRHrZKyLO7KJa+CXNdAeJijQIjc12TWfXzR6mXmpTwcUh12XJ/1sta WZrWV1J/6tUVPKvCf6gLjYUsml0+L2T5Juuynptc943m3rds/P2QoupHEzddbcy2FcxaYzxQPyh6 r/yShUdoQ0MjHaV5pUBJeeIm4MtAmrb1/ce9PtUDm72aF08k5TcfePbbyA37DrzlrFuzJu+93p/D AzRLfLSsXDVISEDZTwxnm7ooF8KVKeTrOXREmxGT3Gd2UaRoHBwVsZY7NM237192VcWOPEuCXdya zW/c6FJMnzZUkHDAvQgL+Z/HMJDqEhxqcATae5Jd5kPHwSj2AxCUpTN0NWgCxBaXia6XZhNcBOJD EywLP2w3fR8XrdkP0i7naAL5JPle7DZ0BK7AoQ3QjOG/saJPluA34wYwrnsYXAU4i+OGt0egosal zAMu3b/fiEVVLRwgHr5rJF1sAucGaxGklO0GSKFBOKagSnStiaf1tMRl7ukp+216eUxUwE7W3HM5 uKpRN97FfwLK+wDMuI+Ywwl6N9lBGTNpJ4EfJ3gvCQh8pcYNUUtUOgF3hWz5KYz6o2JVIMhTjliB eUbHphDeZlFVOndAD+S8KLoTLUgoy2aflm57G1CKVhG0n09Qxn5hr54wg54sj8Orj625EVjouw0H /5RbMviyZZj+wlZlzkPSwrHKhCYnA/fMUltL7jg0gsG8ouirJAmwIp3tAzxabblHXDetVdLt6SBp gCs0YBAA5j6SJDHqtF0QewUA+NS2Hk5d/RVWIOatI8N5nZOs34E39QcROS4qDCt/aqr6R4lIr0K9 0ksyAwQKj7PkMD7hlPgaVVyAeGrwFKM8tfk1gExvsjiEjlXLfN/fNhqu8XYOj2XDTqpPq9NB4Vt/ eY2EhkJMcVUKniyLpnZdN4Mwvy/gpNSHKtU8HevSjQBV/ZCTcZeG3Yj/iCAhXnImmk9VeZLO2gji Z89dU9a6vEBYbj12bsl2fwGvfCbb9cZcsvnr4NaxgP3CpTGTLOQR+8jXpTuJ6Q3aIwNnlcQkVNlJ Dc4J0yv5NHAB9VYKMcy5Q5Gd/f7THxbK7uegweuS1UsjYrUtLKqlGIZNaYE0fuBjug4NT6FKrWWJ KCu6ESIXWZgSkS5OolHHT64GQI1BpCQ7IWOFauNmqyzpFbBFM63WLSxRLaMQ/iKcAN5PLEFw3xUz WGt8JoUV06qYJFMo0+Um7X+oTF9Dvo9jtaF51MMbRyGf7o6nmfBLbaiRIzjU3TSdEEy/fl4EeQwU Sry6HtyjRMQ3CCU9+/GTyUFWS8iY0jpzy6XXkQabZctjmlkp8KvqOEiNLxlO5taJ5XnW9H5nMAvJ Sa2RG8bdpf/TplF/uSgGHy41/Xoew81m/SwlaLDbRcB+0x7KrgurOo9tsTYaVNORVIgxhevqPW9k jWE+264VO+JQO04uFlAhAkkDfUX1SDEX3CFIGrv6GshibF4hJ5S5mddUd92TCQ3IsWQqoJ7jZBB9 YvTxquAsG6tUcE3slnlQVfhTSlvT8H9pMqJQxjdX0f8DKe3+0oXlP8LXxRH+RH1oPZ7I07oRO41A oWDbg0+uwaVOo1Q3gQU7fKBtC6zFC9SlYvwdgA9rsxb5gBZ8gnxZ8vo3O3ZCf4wVjhvamZvjk3N2 +K+hm2ehw323qzwFo2H91TabcJdgR4+7CiAWywXRURY797MUgstkpVnMnVCi9mu+e1rAPoVYDQ0s PLwZLuoho5Wpj3UFu/nR6fun3aKqxJZKVEt9d1Ne/DId2ApC8PEbS10+KfVnm8pHobapLZO7qpUp 2WwkhzlzlfzGoj0+Y/b9RLLL4ofrTjEr6nF9Zru1DdlpkiiSR6aVEj0QUZFa8IlBaRD7EdzCA/HW t123r4OJz0JA+03/tv6xpnvsH9YbHPaSjK5551PlgVVFit3sAkfjDOOY6CjvWxezb6nZp17vef92 XdMstXl8By6HFkRHQKV9aJ+uhUE68lGDgYjafrp4y09v74EtHTP1PXjNj/XIgv3INLcwy8sfYNVz /gqXAiKWKooK+wLzBlRhLmK+YBx2AkHw1kYamqvhYbuM7k2lotZPtqeuqE8h4Vjwf/+WxOkTHrc8 xOquwAfNjyRhKYLp1FMTrif436ChAmdIha8T8rMWLd7BgM7hWVPkoxV+zHFJIpTAzxcu7GYeVR5y z+jTKL/IerEIzYT/rH+SZRfpvkdbnA1v2yNROVJ4Wh8edNux8AmVVVbYK827XEYVPXAvecbRkyFs usiaOk3NTLCmnrnr2l9fg5DHFzczPe23NfCWQj9AnVzeiB+gzIcyO14jD/CiztKCjcdnH7U5V0a8 b9eRNR96u8bR5ilvv5AQCZba4hVNhAUjUbrk+15x2nQC1TyOpH3v4TCOpYmlfnuCjnWIVbRjEXLC Je5vc38saMzvbybS1xhWPTyQETClgpQMw0Qm7UGNaQSRY0zxSGcKfv5HAg84OVh7b7eDqOGIzRX5 5DfJMZ3p0m66aBp9PSMBIqhk5SJn5d7hiYFZKty0Cl9ptoKIQ1RmT7IWy7x4PCKGYNcIcj94Vmyg cD+KYt0g619iTIOi7QVuV26qPYqsD8WlmvjcN4xoAj2m4cXl7u4gVau7FtUOCyyILoYXmYB19vka Ad93iuFqEkHluUp/QHGaRoxFZIKI16nnhKUXnVpMQNye2rYZkqElP07wDmzbw7/UA2Z6RzzLFSlu 42hSWtCfGHN9ofAOHSlI9/N8XaeMZJeKPJcyI/kijeMO6Bjl09I+M8fUc+MxuyPs+2EFyLVWSH5h V/ctJtW3s6GlqgwscViKFuflkLmKsGEtPY2zO3Gaylr4OnC0zVfVK1ltb9d02w9zHDszFCsqiIBT 9fhHyzHGywVerVgThdHqfYiGGFaDi8Ch+qCivUt77VgRfe3oPyTaE/gfhNbwaAWrBWwHUkwM1uCt GuvZiy+kfH9zSbut20nPhsFHGS3j8wU++gtb7ZtUWAdFA/a+5uUmmBlLYDNnZafsszK/Jmf6QFUW d2BlnPfMypyf66U8aLKw6wkIqaTLlJrVVyoiDw2gCFRj+UxWB1R78wCnuo7oRfUdWn0bddXhcZq0 qewrEi67xfklE4Go0WKMqEHTO42v+C4KH2NsVkMpdn3pFHMzkm/EeFc2z9vY7TZjsYE8s3QlbNkh TV40PAlJs2KA+EU0V10T7deLuDgga1xGKRPPzzt34ea5E69+aHhW+mit/4UZS291JOS0jLoynwSJ xQwQl+3TiN3DogvEzYKU5VQ3r9z5UEp7M0gtB5zBqs2/RYYS3/A9bvzCye4oMQXnRmNnUxllcKNR TqbOy/EobH1ksue9si9axkCPDsjpKiiBdCZ8x26oyN5iqGSFTZdCn4N/rHoy6/1Qn6dEHOzgvfMu /8nIFpDYlkQtug/jOiQfL6EVAVdAuxWRamWzeFbO13gyZrl+AraEv2+cHoFIQnM5OKj+OGxmD9P/ VZk370M1tt5QjPrq1Sufz3GvQ88vL7Xmz/02jeWKd/INcSLpO16bludv1gtLvpALvVotWX+uZ+jz OeonFzUyz9Lv2wNpyyvJ36PBoRMVzOKEoRuVmoL6rvgaafhO0JnmciSYLmc164r2yikJHwG2M8at MvWsz7rtndnRBy00fezczfUk71xfiwICL6S34laOhWegV5UGzyuldVIrGhke496wtYcJwa3DIQ50 u17GIElUmpHoj4Z406H2oed6q2IpLEK7TCQjHl8g5f+eb0g2vvuIhOABi4AQbv/Lp57lXC7nVTXE Ow6QBP7THQfPVaMgW2OHF67MR64DMn6xSMan/hnDU8x1kxCoBC+syLQ9hXLsfaUXan6oc6xmmlTd 78U3unf8QhCG4O6G3n2io+LVJ9eVtAHbr4eCr0K+F8qahjGQlVijEZ/UgaGzcbdksEG/2kU2O1dU 4OxZcUY4ONebXnaB3XAeZ41mlWisTvtAArvfFEtwWcRn18Icp/T8S/KaS4VsMBI7hg3E4H9AxTqb KOU3wbgLHSpqhk+NCJVcv70WBpYnZEXzd5queen0NDi1xK+L5qbDIl1mODD7ekwepcMKMuOCLvO4 /a2hXg44nMWcLGbnz/HaB+mD4dhHT0iMD9SotnuloERusBJy7Mark9VmTVIZMpaOFK6famdSplOY aiDu4/IILX5lBiiq1PGjgfCeSNBsa3dqFA/xSl/LwxRHCkO5il7dpA0WtdfJonXgBANKPmvBfVQg DUnRbKLcintZsPhAZESTQCaW8Y781eh2Z7wHCFVEB285YMLuB3vUvzuG9Lr+ba7nrr5llTxq7tr0 VqWa5e/KqTZYISSMbDRPCcaIiWbqrpa/ZvRinZrCyApH4FoT1iZvBrRESfruLp6er6a2i1z//LLm Wqhgzhr6Y2GlXZQBWCa8OHJRspBNcH2E85HhVQYKiibDkBzfv18/z8AckJm4a+VBpByid+1dLKKJ WrXULUTlOmrEwbgKB78TxbQhg2oFGFKR3fja7u/Vevsz2W/EyWIReVcHLT1WJ0eOZsn7e9Fp5eDu woPAfZpqO5wv8EeJgd7adEgBkrnUGQV6ifLIVdbfWlkJSVsiM3kqHanF6d5yzTcTaTYRTjKQQkFa lQKND///IHK5jyrrLqKvP+tLlvnbe/ZuUW8ARFo73R89r/5xX3VBe9XlboEQpSR5QTZOd2b772hp nZ3IrfUT06B9OeC07FcwdRteEiTlF2p/03bD8d4fM6spY/zhRA9pr9TY0w7vuSUaK6EemDN7fMr7 l9u+AMFiLnGLkx11sg/R/ef7OHVluSUuK6R6wGA8lYAkFWA5sYglOduamXiRG7MrGtU95EmoThqL 9OpzvtJLGzLi5bYaF/YolA09880p2m1EnE0Fg2pIV8+cmh1YH0Yy8zEwy45N+/Jw5jRN98VRx5VK 3fABa3D8wgnBueY01XnVtZzgMEJgEkqhX5sVLLCFDCqlEwG/HSw+BhsYchCvfTJiVPG/QOU/XJqc BbID+fg4TSrdlsncQNGdqe4EcFAIxvqmGV+qmNWcSfJQv+D7XuiiYUNx28SrLqZQ1P8BudSBtoJP taLQw29Ny4pUntT3eGqGzP68MwKXMvAgPmkrlcNLR5U9K+XYKAAWVE4IQiUXUMxBAj15uScKww8O NNzoGi3cJb2eOkHu5OkeHz8SWN2gMqPU6GWqzWgXR0En0aUS25ZdoUS7nb5XAUo2H39hPCU/7Ou0 NI3qBvHdHa1YSTmStDRqzlM2AwXI7AAtiUj7+fC/XuIgGMK6SUfMDPgSp2ohHATW9k5DHNg1I0Tu K8YDZRnsa8eLC0+dtY/PfKISOJqxiavH5Z5xoo7YpApua7OdksA7QUc/X6XslJnsLpjWOVE2odBS sZ1BmlD5d85bJ+0HXue0ohFsiFAtgOXlzCzOmqLpZ0R6OAjORg8h1CUXknNwVtnfw/2YVmgnXvIT 5UIKpJxS9QbY9lRJG9c2Kj8kLqg8G1M8FLpMJe8LWsa+jOpbAMctXEnOfiZq38fSLOg2LNRNUPaU lFTRXz+WTnUPcjGnR4P1tjShikp5nxxVZdzqC8rTc8ku/R1hxYIJ4YPYEIPDMcSdGQepSxb0Li8U ENRLhyz9m0EfWVIYRuU2xCCEIF4v67m+CFTEOMISg4bCr/dxGZfJt7LumxlLxyHQevKJZz2bZIoq KwHlNE/BJdWPposYbkoJPB2tdawKZuc/v8dlbbaotkwqDk42/zfT6s9Pj7re0yDwnsnJv4OCkKbL mQ0o6q+gnO2xmt8gk5lRpF79GJsBdal5vcdcsJVW0QKL2ZAIo/2jbZDUaq894eE7OMhGgRuXzYOt bM0BXG3ap8T5JNRhsI1fzwcNLNOZwrMReNIK/tkhI+9a9OQeof603KRdcn5XUlp+l40vMJXPyBPD APjtq3h8L3SoE6clDeaJA/p4icR2YvPKRjdNqBEfQKTtCQ1q+7BE1nQEn1RZ5/tApkmoFzSlEr3K Aan91M/6f8Y4iIvgln/lF3aupm1MkEXmrvvzbgDdianXr/ctTqHFvpzeWLdMOw4KjX+at87VTQXy fwPZy0zLCDTQfBV32T+l0/0PASZYAVHvprg1M+cV3OyWN84bFpyZVKPwLRjCOG0FcSziYfcttXA2 Yzr8EiTSwCatrqe1nzqiZGpuh33pJaLXJbgZpR5VAL7kTmmb9oXX+pOLuFOy6PWxj/XtiBi4yvlL 9QoH327I34HpE+Ijt32UaXq40Vqq5YK88f+an+8TLYM+LsM681pKM5428vvvWx43R//eO559rh7W ZzOvjJ5sIiwJCm74Xf0501atNm/ipv7baPt8ikpIBgYOUiPdst+VxSinyl41WmuQFlWQ0hRENF/v BnzutLMw6UzYc9m/O79tDMR90xHvd/LdFxeiKudo9WxTbb/BsyNNDi8e53REek+2tXJS+zz+1lbx GQuu4Iwpci/k/f38XcXTvEIBs4CzXqRSs7eiaBhFDog/ZSYtssu34G9jIG7/vtB153ZYqZEgLzSX rT6j40X/9Gjn+wUMNkZlSyilxJgbT2G5AsWKz5DBqzna4cnqWBtnAgbo5MsaJ1walOHPjxEetVEr 2uWqGzaf2UsV5kUkPpNmYWWXFKaRjzYzsLEELH8lFN+KK9rec06781LyPG0i15gpsxB2u4lt5CfP LtZpdbxqbBZxhKE4pk/Cqec1Uw3JxGjYii7Fr4Oe2I1lqodXqs2Q/q9oCfoeL0tLp5nZCUeeE4zQ rYH0RUCWhOtPtL1fviN8rGFSefSg2Pbvh8JRnMO2vdbtX7KbnoQ8j45fP8e+ymU9Nn/ipn5wpVU/ pRoqp7e5BvfiPz2uCms8e0DglAwlykJPjxQMcycD9+npVlTlZzCNbd29yHCL/1nP2NeQ1bVgwbbA 8YPg4YX1w6mD+yZ8Rj9kIJXaY37XSC9Kb4AMCilL6ybTya698intIfqVXjruSVPNLNuQkhEUAQ64 3Vf7aAwvvZgbwAf86eVI7WQAwvBYyZvVhrb16llqh8TOz71ZC2qgSo1T/qIYutKuMxY1LGdVB2Ha U+lK70u9xCBNWMXAwmkUEgazET6l1ELA+u06HMbyOJ73FCYc/FIk3jjPW+6qO/u1ATiAryo6ravD 0GDByio2xmINwylLb9Z3jVAb01s2fnFsjQqscAMHO3ICSL6893aazvpBs7hcGSVcNuQz7MHIlDM/ +yxuubNACUiI3Z3lYLLzXYwhIajj/edr2EtDsdo3Qe6m/ducYunA5Te+sAUthIMwyKDfsvIzYL4x xUpsDC2NrfIrEinL30gz6H8f+5UItI+zmeiHhql7HppmoZ4fkSuEgLbbij5I4HHqyDEGS/Mgjyb2 +j9IeDd126kg8RbjbmuMi/FAfHn942vZBFaGPameG8hs/Ovlv9er1v7fBrCizRqage7EwDUBNchp 2IWmkGEXNdDeQcaqtAjDPJ2suIjC+tA4xpXifyFi1a5mRP9XZDFWgoIBWQ9m0meabwFPUR9O9exX NdMHisICNqoiJuQ5WXdOfEe2z9OJAOzaVMS7kqjiaHIzaf2w4cOjaFFsoTAmf3DOMyjaWRtrIayw IfFowzLHTBEbIHXdirzQH8+h9ZLbyuE74CuNais6KX42W6yl4WQUbEsJqwaCvqcsVHrpXXodCfLH QED2Aqcqx+bjABJDnTPwVZoVN0PeSYu537QhC15Ohry2xpxmlF0IRpKeyNMErlqiWF7xP3Of3oZE ncFd0Ca8kzwWVfM3+HzURxc3DL0dduEErxVluNzvzIUvig2ny+CK4hWkhDU/YSd2Mm9dlD49pi3t d3VKTGWabV7vL8BLTkprL7YPk5tVsXDaFPzBYsnRAHyJO1wnkHrhevYSqiAZlcl5Dz7z4lfLoTWX 6kkw2lqzjpTq1FbICSsOOPw55mOm5E8mkNPPUj0USxD5geJTsJdtXb/Wae8/sCaot9P953M4yZ8X JF3hXnLXlYwkCeSj4LwC86WR0QXpK2dSv4d2O/Ec2DnwrDANrrSbOSuib16QGp7MPv8o8MR4vmyU VWJpYKaH/UOskNGT1CkWauvIeSEsIG+RucQRAOGohFVp9mT3tRkAN6ya7Af7wy4vt3NvgykGqJ9n 0KwXKUOP/Knm7GcUYHeX/JZnkOr9dv6oZgdwIUOxojNWhip3qnRFP5F9V3mFlAkOkXNZ4fH9dya+ sSQ6nUEqXW0hBB4N88qlCPOwKSulXOJm2kPOVnPeuORANnBjfb4AQBSs3cdeJA3fiLMC29cp0heZ 1LziI0Ziv89wRwJTvYBRI5rzXXD9wcS313zLYDVxc5JupSsRcxMkXBiR1Y4E2SO18BvynGKCzwOD +bgXuBAFauX2ADt0wFVSFxwgdxwWLbC186c7brLksSr/pW15W328/zvO/X5kfWZh7jjh2GFfE8uv qvPKT15H2nD5fd0fB1S+dxAPrYizAZK43z61N2hy37TQlo658wTuRhlEb5K2p0XP2mk4Z36Wc3Eb 5pTRoE0wUzB/tRMjEzBDnyqaqdtQw7tR+QvYusOB2UXC2ZrWUuMVg4QjBnIm2NYJI3Uo3IRwQD2H SGeTnxI+z70lsLoXrioNbvhhJO6fBIMGlQI7KNRxu2eRofQhMBMveq5toUuYYsLudUroqp88uKVX D4bo/t7qjzvEB6Plwmgx9SJ9yQRHQ/uxh8H2zTrTfnLZ7YhmfG6JI3DhbOYpaW0rrwuRJG8QBr/v V6LpqQViGUHfROpCK/taAgV/fJNLjqcrpW4q+Vt4NwjdIc3Odpv1CKzLTS0OtwEeqCJAPHSjnyYq YzN2ublBP5zaa5V8jTuAclkMvBVH7igV73IJjfQevR14jhX5hTfXsMFJe+K4BoS7y1ZQRz1ZTmFX uKyPRFSUa2jGqZeFXO0w4l8NoguWAWcwMonaksWf18XHym0JxV3zNQLgTd6XwXZsH55Cb9BZMPhk pZU9EDzqUv1OSbmg7AVh4NTGaTnWQVXG48wBbN7FFSQrU+I3513rRbKYIH8pc4ucp4bbytaCDPTO bdewQDJMiT3j7FX24R0P6U+/EN9iQe7uSTqEvfqt2TmiMlg55+jmw5hjRC0Xx2Ionhj3pSVmLlLv PnLL7qUra3fBH+faYHdEUDitZYlV/nPqcSDyRcXckSzQTZMIDUeoxGjArDqT3u0D1I6yKq9ymn3q XbklBVjlVfT8mbIZK/Z056LlMBmmVOVtTfPbfuNy3sYtRZaPotKi0QEjml7ThRZdd1w88dDcNI/s A/WYfcSiUUKqvPCXuiqNNcCbLHkXd3OUjJ7H9Fy4QAdmge6niqwqBg8w1elPwHUcrfy3rW6fDZjz Lz9takyFXxcgtQdtgHjEge/vAM3AvHRubCkyl8QUVm7p7Op5aydSKO10rkv6qSUgFQFGHXbqzZpt LarKBoRKIf3tR1uVS1axYogwQ6VNuo3LdO3S5sgcDuRfr5L+IcLkHjk9SrlkFSIkrffhvlzW2sr8 uG5oZq4cq1woVPM3FRRRsL55VtsIlKzeOAbLck8moYpAApCx/JGHgRdIbaH7+ZN4WWy842uNpjJ/ gZ/Cucbub9TJFoQyfe4YI4b0o9dPG60ZE7rQtiONHmcFMUHYgTDMzEH9VdsrEaHQOeGY8uqEK59h 6tN5/lXeknA27XU8/Bs/R7F+I29DqbLRRPdQU0n98faJ+aAjMQGdccgUHmBzHvZtf7bYjkk5bq8j X7nQYy9ePqAd9tttC+irpb7yMyr5WGtE996c2/8WUoYFdUAj04+UeTwe+ntz0HJpA4w5qa0eh52U U32DWTc4IdIA+6E4cRHc3VJgR15W7msiwjVjV4NCVEowkEP7/MmQANfhGrpn/hw17I6o8Kh085he rpWli/1JCw6Y9g/eL2Usp87/W7XpA+73WVD069U32Cl9X6xdo9Ok7zB+mmPL1pI6/HVsO/2xRovf XQLGEbkT6rC8lji3h748pNz0F+4LrH5VyWcm2bN3qQA3ZqMAhjcPGWNXxRXlo5u6yvOtxTSsUN9l aX62LqDqwexW0gDjvWRvRLLrvfDUl7EuvxJo5yZOkF/h6jkEtj2IjsXuEmLTTcxSJFr62/AP9UcM e3vnVYSaH2ftpNBXgSl0+ob8UbKlZgMr4c+mAHqEWsAzG+TlK93NNhsahO9GQSpmcI5yE+/4TuCD ZonX0CCpj4Q8hwKQ4moSZeGpyQqZtJ8fVMSpJwSEVS/U5uhHNCr6Ql0KqE/v63zVZp/ovn70iKFA 8XcLcl11mMpAJWNNTWN8F0Y6BUoLWyv7CntDjWn8Prb1xyd49gDb+qnC2Q9aBI5P9mMeYdeRbAvf a2HmY4zqNQ5scPxQCyXYy2k6JpiB1AfdMYn7kWMyhr10wtpxJffRyB9Q0uFUFe+1tJnRSC65Oq4A iqah0pkoG1xfaL0c6oHIns3a/mcmOPF50t/nBQ9xh/CMhhvSLrjP+o+0BLvyknoAWbZGE0Sb1zhJ uwggzuUl4tPtt3zr4KYE4cUG8iR8bFsmHUWkcLVVUnylUHN9tqrXFZ5RrMK5dw/DGzxQGFUakfHu Vou4UDbLB88Ugn3LXpbtOjN+qjhRWflE3reuf4vVzlinEaS74/XXYBoyklcVlcdeEPt2kvFe2ELQ N58M/yYuEPGal+5qGbPUyeEtKIS/C5LL1PBThLGZSwaYikkjGSSgBV0jNmXff1affCxy0I1NJGxQ +odguy2QaB72c5aGyYBHjhWvAm+CvnjzEETAj5gFJxZ74bPxHQ5a7JjZJFUYjUlummnjHu6XYMIA gVmnoH9HS0F6eS1gZ/ap/B2cVUglDDJ8lqqtptZVuxge9M4TIpOq16psx0fu+XDTxKIoFOeGDXH9 u70PLQBiGT9ZXKgwSX7+etbFbK+pDIa7kDbAATSpJzFAfspcs16bmXA4QByJAU6g2K17jgNYX/tC y2ADp2LmZBPbCX+JIvpRKZT9P1Pr7vIIWgGXiTlEqltjXfbfB671/gbjVMSzowQDij8FnC0XKx4r 4ukFO1Nb73Jj4aMdJrGOck4ttg1i2NuUmYZqDfzYX8mb+WaALJpzwvLed/kA/vma7pHeKrkS18H+ y98NodprIIwJnEpsSY0vJit0FllNAwA8hj8dvlaIoD/oZ24HT+AveYMXSQ+x9sVBNtc7PTKI/IS4 VKRQISSRWlFsaKRLp3ignoAoI/Os8Fn9cASISrP6J8h3LY0D12jKSD/eV6NcWc3orIL/UWSs4dxX A9G/UeO1390lqcpcSBciQJk2B3XvGl3lJQFjhWMWg2f3ZdsSX+2E/veJvbV3v8PjFYYhe4pPrwQn IqP4c1gK3onlyVTYV4XBUW/T9PYQPaMZiKcgNd6G3jikYMmBble7nWNt6DXgWa83dvjWM22xAxxT Wzauhou+6ul1HMWdZN57Txxd9ZqhApT8bXYu8aQVKcL0W1E+d+ETuRiWvy24X0/62AERFMBDrpNg 9fFPQJs3taev8Psr5ZTKdQAFghKbKSM/95S7YlZ/3FWlmywEZmdUHOlpmeAraIYQfeN4AoV9gfq9 ZTuYHe+Tao0YhGtkTeHXtRe8E8PK7fli3PtHzJNJW1sSe9v80ze1QGfpimbzjmHrIVClU3xPMpyn rKEbYpuZ+ZkNUdZgj3/XuK3BWlz6ECaGhLcFxIYE88xiNH+U8AR5vFlkIwGk1eAhbXxIv4hdTZSk X7XEPsqMMzqiMXb1zeRmI4U9okZOebpaD4kmkAT2DoxeTkJjF2K6IctNbu/zrzhKesdRXVQ5p8y7 mQlhu5zk92xMXlZQ/3VyJDrZJTe8ztcpX9ElYtlHs0vOHnBoA4X7zX3nPH0gk1/P7KrWFlka5ziB SKp8vTwn6OvHNVucGomcS5pKWoU4eVJx0rrlpeS9fB/7kDbFUSabcE5jFs1dqNgIAVESaBAWpmCy 1nKsKJEaEezKrFjyZBbwu/pOW4K53tuoMi+81O1beYOpcM4PgRDpQXaB8spJwMxVHi+bDfA0iyAR 2BwdZYYM/kMxHjOdx4Xi7O0Q0dnCUZLJyokMF2ekFdEtdVO1pbSJzmgG51gYHp7yzQZi9TflnLBR c9vXyaLjhQvpqXU9M2fod7GGt1kzG2dRMVs/9stPLv+HoiadNfODi80JfXQOGJtIsO852t9pn5cS 5TM+Klui7fNKcAW/ajpCec+fQ61I6t/XNc1j4P1q1sc4FZu3VUmgWgaMgi9yWgoxAuwQDFLa7NG4 Td6WWw3w8z0jAqCOCBHD9iv03TYbYaQgu6G8MBPpUSgX3s8O3fIGCk6ctFQqK2986k5teBMDuAKO 4USCGutC3+KqSjOFTzpgmvP53w6VVr40wWyxfVL7LTfrvQZuWHxQS8C/EtMXu4GkHy3AZDym4mvh BohLGZKUHP8hcTrkJlFLx+inosNJFn3YQQUjLi+/Rbd8O/8J97GSo9suMxN5ZzG6fu9uso2KuMKL aidiMnuVC3Mfq9A9BqtncWzxgg7WvxFKrITr4LMgYXsV1Xn4F5rfDI9eZ8quB5mqLD8WznyrybUb cwbi0GziGhmAaZSJ7LWaakOwdQZ/vhPQnks9ilGvSTZ/p5rhP40UyQ14tQucLpgpM5Paq/cd5w8O Ga+iuDGmCy/7YdQDI+YZ9x957MQ+PipUiR8hDJSvq8/Wyv8IhaRlLRrep/vvaZdK3Ma31783dhWT 2ZC2X21RJKpfoTLsUndL8Z/xQik0obDpMeeS8PMcwTm31/bOFkNcR9jNCsRdRhDyS3451DAOuPWf PDFfqoVpiWcHU48VoBUMHPYLJg4QkoZOeKzLewjf9QZFzffRn52Ktwdb3Amp0HsLe4ZOlfG4JvFe BlTWxQtX/yVTd8DbZPIYRPrbXz6HfDJ6RzoyI+oJRtTJbBQPNzXtrXs47k6zZUbHJLDclzERa9N6 FqjUSKM6U7Sf9Cm9SmzZDeqUXD0k7wofGfi3IOC/NWeUxIDjJeqj6U6NCc/KEHuWaq6PZU56kg22 WPbzcZHEUxjDwNPd9FkqiTX7xCE5+YQSgMYQT1mDeZ19B1DnfVfPhoHEbTkMrSH+kUcOG4pa2WGv eFDhn3sVxuYX0nt4uER2FjA4iko268/+sD2GeWtGfnEtz8PiPSgKnFfQTI5/6nTHwxpN9a5w81dH +TZzuyPosr2Tey3yy+IYheLPfu1rwaBWa4NYwImMBlyHtUXEG/L9YlSiQ9qbraSOAkUJfbvUCDjE /Zn1OUduXfjg2mZDk5rPN/h9NZshpSiX9OUu29uht5boUoWGFIAyBgP/ux9FQHGs9n5zUmgo293F G5W63Q0lrMAAb9Lr1iJvF9toVxA9h6iy4GuSJAZBfjvicWrgwlykjuvZvxtuRoVTmzpy2O+MCxoo sR85Iz4Qvea44Sk6BqM9/X1gxwGB2V18Ii4twQiTqvzgap3Qm/TjTFLG5yFBV61DdKiQwp9fpZ9s S9koHE9HlpmqD+3hAitK+08FaGjaRYKpma7VMoo4+xFvna8VoRHA0Hb/akeqXFty90MVhFno+zqf EqkQDP2UMixxPs2N/kxhfFpvE/gLp9u0V7jVjAF/sBRkJexXBFXdJKYgslFesL3xas7gH2EjjoTv f7GY/vGhOuq/nZhRpq7inqAMKZeji4rn3Wl9PiINNLzqxrZEzC+fHJy2VYHiM7ILE1yNHJ0n2/zj heT9A5HsAXdQ/R3u41wN5XUBqDX1dXa45zTaGVO5SZt6035aPCHJwA5+f0W6wfmZGK6HhbkmG/jc deV61IfsowPAaB81XKjCcF0h4VG5GB2rT9seC8ZZlSLYSilu1J6abt7676qpcrKAEhDzThM/jNKi 9TrivtlhaMsep3zmyikky5p8zagvUJtBA+60guxQocUCotNSNKGpBK6OsGl9Be6QkUR1PS/ugiKY UCin8VzrD/iHN9kqh22Zq8ieD4J2rSOxNRzIuimX+ajiMZORwmJ/yLvsUmGG91MkcBxgHAiq2f/k yuAkBU7aaAB5B+lUxz6tnDB9JW/kjQRAIjtISugCnXUj2FlGr5PvDriJWAaM/gx6SW7BLeEalkBl 948l6Kcoetw/B541hie7nbcrMWs3Ki7Lmu2y1AXGsD9RdECounyjig/0vdi7qgKqYucTyAuT/vSq P50AN/USfTENFnVrRqJxUQeqB2TZgzH5UA9pNTTHlkeWPPo0wXGogaTQGpmWNUuUDbprsmOKCohN FR43Z0fylaDtEnqwKsZ882YmV7sEoMzPxZZfvAaMKKlB1NXwyd+WzTq9Dmu4TGXw3H23sjYLtWbl aVx8MnF1JnHh7KFOImVvNULXe2Qh3qG5lwbmoIQHYOqN2EmWcRd+5fHs1AeWmrJwJxoxprpgTv1D QySntBNIW2FKn0o1+UriyP8IVFJy5Eqs3KszVkHi8avTMoP6eniu3hnhPvjbY69LwopJVl1Cn1Na nntrP3AYdwKIjdQi8JIWz9+PnDbkmbEwC779gzExNUvbUT1jHUcdhdZ0TDOozQtDTyrKfGtxaRph T73ml/isNT/jSzQNhTJorbXrjcz5WEpEpdwEhlVG31iESjnDqD5TwNwnt2npX6l9J8GN6k/fl2Pz 7x0+lh/nfMeIzysjCeH5MdsxGc6OpiuPzEK19V10feBJegly9HjekaAAYcuW2/GuMv9JYWsVZn/L nLIavGHM/pF89/8IqA6wKWPCHjNg9EYDkVOBtknZPJ6kl9rGhtFdEz9BVFGKxKer6lgapBXky0MU q1RcakGBaGjAAxuw8BAzCoBmMjJG4IHGi9mWZxXC/fF6ckcWgo+MRDtJ314mDgWFdLvwpUh5saik wHX/IMH5cEIG2nPWGV5oUe6U+3Hv8h28OfeEaUlFYYBOLYYpngpgl7Wxu3SuWa6ypUV/NwrHCuf7 O8ENht3D4aRaJpyeTj6PZMxxSHBwziNVhR7rdY9QVtu5BBC4RGIi9h1iGKsza4RorZFZaVSllgqU 6SSkDO1tMaaGW2L2vtZW+7G9Nfc+YI3IzdpaKWqrjkYpa1Rg1pIaGY07TBFPyud5XshujAEMQach 38qIMxP1cNNWEhhDKuoL9wJMT5W1/CHfV8gDDVWhtjWEtzDJS1ozPoJQXkrdWNmCVwq8wZUZ72S6 NGxqgGumskrcZfTyF+LW7pebl2VfvjubcqfZ+2cBrQtgXU2xG08IxBIp8OCbMK9nkg0+Ze0ZKMHw 0ryDDD4hyK65u9rlnl/Yxl5gtlWsYiFAjKNW5s4OZX0Xc28bO3bynlr6CbO3UsTCmi+EFYmOuaxg IZ2vQD7UHdiaD+piyqGsJ0Wr8yNyenHG6O+Q+RM0UFZqFxRbfoXsXXDuBhlYtdVXUOIJ9HdxyOgR 0KiEVr/7pTWkimWySZ5GKCXihzZzlgqm64x+mLPcFOEzC8aUD7dFQ3lIxbWp7rEbjZGl+uSG/WL1 xtj/6Es8Tqz8zA5qapV2wJXg5yzTJkgRm/Sj0oZ5Lv0mep6BHzLD0oXJnNmauaRVEQtPlbPkFv4S VVi30V1Hse0+XZ0zMyM0qQgVu5GdmahZaPkqHlrEX2W9Zl5upw/xPGqY0uegroDTi4twtxxr6j2y uHg5AfbDWBUd3Mb3337R/+havmVS7p+TZJ4LzPZyh8TABDgiSZgtMjOaeqc/Nxx6w55WyOzeVCeb QmIgG63OOGFXGzNOqBGbSUqw1lpMJwYYMi85sMgVm7f0dsNmjibIXjL+wuIlXB5auEQ45qx9vaBZ SlZzjMFqL8aKx6biV5jmCmFrdhGvKR546hc53/9P6KbekOT5BdpZq67ZtpIhYHdB++WEUGr1kSZY fkWkzWuus1DYQBNGyjAiyaYpT3nYGz6JURDX+AxHvHaGHQH9Td8S1Bt1GB+NvVA45XOIlYGkvHNl sZoyIerJANltaC5IxWMANn1d6wyMG4T3/EVi6sYrd3uxr3kCFgYhQ0OE5XK5t2NIzFtKMtJKS0MH fF0oa131dWEx0OLJFPhPjXMFbEvGrqpGO+cIvILyQGtaAS4ZZ5wNyYvqleczVxuuxsHNmUJQTcuO j2Igr1ETrP2c4zwhX9ST7Tz/v4VD/TDaaBv33WmiWBLDhRCi7/RtiKZhojveCLUW4sIY47e9/KQ0 U64glWNUYkiKwDtto8INxp7PVoR4I2gP7aeSLQ7Zix0YS3o9u11Htc6RMsIyeyTXH3Kx3PQqAd/9 vc42x/M60gLW7xqJ6QU3294YlT3g3yt9egzgvj+g54PF+nqKYdecIoK7XcpQ4Gy5+rnQJ7jbmW2e Ulvhi7j/jarcgxXCQR5DWHsoTz5bez1bvp6hef2To9O3bDm1bSCOWYs0ngRUtrfYp1tuxNH637xq K3+hr9VlPk2N2hRE89SdsYq0dqfvYNOyIudCEe7f99XZsfPpQY8o4vhj/ck+bY4vdMG4SSHSJd/8 Lyd13BEd4gstLAJN/Ynqpsorh/lr17ThevMIk4oERQQGJtnuoSyLhDwN/CrK0DXN5SHYfjO+aQLj eq4anFkq+uLWdsqCwn+Ti5S3ll0SQtqPo6nQPrAVPNymL0cGY4MLGla37LaJG7om7VUP+/vUwniy 5YxxJHj0Ioic1CcsxX/n0KMJv4sbUZUoQRX0jsVt7EbXj4JbWW7RBkl5XK8htdbDpc2QRIiynpP2 YwVwxopXtovzdhXihpWkFBeI9zJfLGejqmctUTBoDGsvCBmJPw7KAijFAcrwKsdB07WloBNDrrTG kJw819KJUQpthvMoeUMVuI0THq23qyDAcYK2HGnrG2afstwAt/cAWiPYRowztwbPE3HKeez2y3EO sFIbWkjuTFLIxqh/Twp9hNA81nYBW6w1Ocsh+6vgf7KDhgt0yajxOhU21iEUyhAg0b2Uw9tsmxJp zRsgOIbRxqC5G8aBiOZ/JVh1V4r3v+YkTkjvGhoDOvof/P4NlT/X4PbU0+oRehhv1etyKkXxjKW+ /0l8AllMT/6y9AlPS1uIfGvNunPK1SK9Bw/80IjI0BcnFzAvhyK/VurOJxOnlHpLXy2JV/T2zwD/ IoK43iBu7ne7p/HvXGIKydK4JIS78QA9ud/KShafZ754BweyjpHjwr2wwzua2q4seLUFv7fCf0iW L+dfLlaPzhzPqoFXPx4OoSh9Mzqv9jMnv6z7QXdid0uhJ/UwIzqaCsl4grCGVROzQPvL5UTDN1Cg WtBhKwtXtP1uOJOARlAkAAzkBjNYIuDFHa1tDsEc94SrMQXS5yb/CBH8fZefb8VrI4FLcHTyy2sq Cgeay01DRq6RGm5kOHZHhP/NsBMXf1lRkv7uup3vVGyZJz0BXQTDlzgyBLsA/rHPY+sNmzqZaStP TOMgYVEo2oK0BSkKyUGI21NWU26B3TvqsEpk5ikjXr+F2surDPW/lzj/wV/Enzlk+UH2i2x7Mlc2 FtMTwUBOH9/sQVQa1VIHPFZvkD2BxchpsIId6jU4JOL5EZ6vbrKeeo6/jzRTq0TFB0CT4qu0l0sV sRL2Ic9o/y+pkVsBttIRICQ2p+sAmIvwwP/q3Aqx1zA2E1z2hxlY5Na6DhgJVstg0y50GFshBmjO dloBYhMBGLsDz8XsLO4kTtYwElIQreltS3k6DHxNa+RIJK8J9XeWBmKCrxlq5m8x0bimGCXovJxV dBY+43kI7eGdW0Yxc+hMjoD9WSawFbIinJ5lzU1svYRCdvpy8tb1wx2hiq37m8jtshRVjYvNJblV 7oBvQx541Rp5VlDbsXVms1BSwyUjrUUP8JXkNvwLnyA1Hap19P6O0XQLBZt5Yh52mQR+8kfFbwdD 7eyBCEp2T6g6XJKKDhQ8jS1g7wrX0ij9t4+LBlpK28T+QX2ALoOk0/N5w7rlEdIz3SHcf9rvNJaE 8troIWjw2Dne1DSiWPXy+RPBaUovxcqb9ga9SFBq32J2zTXsNncL0UqBKmfmmyht7CffkyR5IIuf KokxWM+B8ZtL+E+KPuge5C1Lhu003TKtqDp7SC4eJ7u3uuCWHwgwPIYETxOO8lV0xXWTkyxa7CON tnDHiBVDoyB9rz9apf2awMARMH2dwLTLCj42N26mv6LsMCaVuVCWHrzK1CJ4JSsqZtALW4+YItDw Dfu6FyAAcAT+zkUMOV3TMpWDWoVB/ixFUruPur5K7RolyQDDw41W4qpLK+IVULWU5tzA0CZe/RsY bUdeuNx41jwQku3XCIlrZw7NcqZnjaJjCdEAhcx/mIlXiGl6ImML2BQgjxw+F6lv5RhHhRWG10il DwlIZ9X0WMfS39a7WCtuyMf4lEjICRfZVZwlnXgoe/iAVGqRGyBjqtrqISn2SX7zpSd4fJaYRAp7 rJDvfkmFl5UZ6cosCwA6m4WtLOqBWBVyq5NALQOmC6YhMVAvEQ5LNuQ/0m7Z3ZOnVj2P9qKaTpJY ICV+owX52nSSRMhP4P0Y1waY0txp7SPOgiAuuR8tINiFtOyUXd70S0jiFm3EiefRoz8jO5k2nchy ksuTbcLEwF2BSTRP4q8p2fOiKp1r9vHEZg0mngEWUFMsIW7phVCGyl6Ovw7QcnybRM6rZ95mvL7D sfSUS3rfTAVzHjgpZmoIFN75vkQ+Iq0bEgJxb/n+Mu+bfXsSgSfL+LdScHwX41uKnRHqRz9NNp6N KJ15UsDVydCU9KvwmBmN8Fzj1IPTCaIJXCXR6mj49gY6GWp1wTe95o1mE43F4SmaXfmzrq0hPP0m L9Ha7uXFMH9qNbrZc7Wnl1zCMvqrr7LPQP/BtQz9S9DrIGRlPkPH8pJ4P3lkIvJT86r+zOElrDcL n08w35oA8XLelS90imcapZWm+9v91cPTCXe13hC88CpmzArmEbJXLECsTbt/fiAtEHeyN9GgroLw D3cmRnWdFZUt45KJ2pVy93lmv7R2BW0NNOcKX20ayfntw1o0Vvez0fEdYZIJrIOg0rH+S0DT/D6u Jy45+fOJDF/hNbWQz5iAbHEIdqgj+peUUxHNeKDOTXrFCLtdMyPfzxJJrAj6l50di9KnhhOSFjXa bEMeveSICys10wyIHwwHSaB6SbH91u6P9vi6rwsnZojJLlsfHPd6ZAXSV/2h49E36jGTkLirWvVG pjgGcFSp14zwGDKrMw/+76Og7Be3+bDZuCNmAz0jATdkNLqJP3m+YrITkoVfEoJ9lA+Ur9Cdv8UG wuJHqh1ykH/pZP8UqT0m2bq+lzyisGIezIRXc9Or98X7z3X8G9IudyOhGaUP4/Zs6ZC2sYPGr+F7 WdVPBwtkRr8KErNNjEEGx8OpxhUg492Q0Nk6oZtm1Md1UaRkFsaBHGkz2USu6b4sYxqxRZGOnx3t oJGdd8hzrTPGYmj08ndsa7lgDTpp1QvPnjicCOzuxXYxAg0/h+VIq1JWbtv6jUSMNL6zy/ZkbhSd LC3rnG8OoGCfT2lgQFizbG/GV2pIX8tvP11fJLbdAY/dh3dK6/zkdRPIwAKN2c/v3MNeXlC1Crgg m2CCUznGqY2VKUpZTDfgIeeXTbr9KiUEXRTYV2A7xd2Scw5tOBwnvKZYmn5j7XER/KJaEjkzuI4L CMRFcn1vxrXY+S11j1eStVWMLP26M+qVE971lw8zKAEOkDJUJpWRPBas2jpr6TKjpqYjZWeXhifl /wQNaNqtAArTR1bcZUSPVXo0TvfN6bU2mrQS0jKBJawRRLxRsOgGeHvFLIj3+c3e9W6LTMnPw76A 82cEO3HA83TPrX88kutZwrfH+riBD1kSNDi1g8TeHXq6EoX2uMcZ+G3ecvB4ZEoEJ5DH4SGK3/sK wLzJn1q4KQgYhWCpzNmaeQxfy9qXKTBEaK+HsHu+erZpPWf5KLQqEsipBiMxyWnTZLkEyfE6QDqI jjcbD3CxQC2Py951k2O1nvpT4osZkWZ92d35fmDAx/PZj21W7JqjtNZ0JUOv7IaToqnbPQoWDk+H 4bHI3GfSAXGa4Y5JBYvUOsnoQcuYld1LOeVHsAxSk0LwV04d46uI34msAVul40JahfZqqCM+FUSj 1OA6sZwITpyso798Ov55d6Sji8AvD2KHwcA/T+IxkH9yZSC1v7W4g50WWUGc8DpibaLEugaMai31 g5UOc0FvcSk52DWHMN6LvpWlwtRKamMqqTWjH6yWktqHcN+47FUVCmEPz2RwYZTUl9uW160UOxlX GgFrO56g8Hu5p1pv3fQwehbG3ixYW7thJ2/Gq1dOhgC8NumhmS4QhNph7d1zAyrZl5eJ+fnzxCY/ OBF00ReyrZ3uwYn+txCEG21gWc9UNqFIlqK7LLCcHRFx07hBJ0DUbUOhJoIpolRqcvfFtKI5xhdK WyDVil88aho9soDt8Twy5FPmOwE/4Rb7BgbbvfOU3ex07l2NU/QOqTQ4893oEzcKaAw1CjUFfkca 20TECaHUeCnSs4kPjusc2v8+Vvm/zbV0ihq7PINAL0w1T2sAS+svyixa6dg9tnI3jOtk/Rd33UUx rBi6W+E/wPoabdcbKdLKDCjVJq8RtsfdRV3khKoheammzy4PL9YDPwmm424S0i4nB3VP2TQdlqfg uJ4Rn9lh1q1mzeBWVJAOhN3ICpTu7YYlgbFUpYqYb0MZtqLQT3NZAI5/jE/hlm5mh8uxOeNRTH7K UDRYQw3GSicwQpegBz9i0O210dlBM1J+he2F65v6j6jbr6qZlf5E3OlqKKxaLnP7num3QanzpLcB jn7j4RxOS0OraJSSx5YGsi+TOLBexFTh6xq/RWjLk/JJ91bT3eV307IDTHh1GbFiJcutD1byd+rJ IDnUdmX6KIDR+VklYhA4PIJuX4Ux6dFvl9/BdMb8I0Zg0KGt7ioiGGmdhLsYH7fRKy+4NIBbRC/X JGqcPHaaOgVDNWT77KrXDPRrJbXbZIM9qljQ1Lh7MoaNrRxuSnor97rHbJSAj0BzvW+dy/+HvD/N LCBrGjIJDtSRrEc39rlXAllertHhF/VM5sLahJKO/uaaIfJQ6qQhVwF0GcRf+o9rZx8/3AeYtBHh HAbUamXbVEt8mzlgqgaZ9UKeurbbWhuJMMoQYgpGPOzEr5Q6om7TEXjunWjWMmWeKfENlBxK85jr mJIR5hPWTrKNqAH8XJR8Ptj8RDpgYsCV/VnaMZegj/QLio0hWTL1iy9GNYkjpS0Eh9O5ZydVMF0R xFLn3/UvD4C9GJ+pXxam6IDlrNS96NbzmqRtaXKIP+cyQfpi1fqWgGnEbcv+3opQcR5SGUhfcw2T 7OjLcOTA0U6um7K2T5jTc9K5DglV+G729ktlpkUWuIkE+KPQqjqnK0/z2RiHWsmDdBFizw1v4Puo 5w74YKBnHVB3ph4LHyz1gQY5/dl9X12oz66k3CWjDlfqMXyUARBJ63KFD0aTFGU+pSjwzXlimdLM Uj9Sc9umdomSrqpmvz8weaxZepu2IltPt13SD74Z0UTa5cQ673dp8TAkx2OAPi9GscXkeSU2Wf8s 02Kkzvbbbe4WzHSTi5wknYPKjQWVDEbAHsOkqiG0u7WDD1IG+6wSYRbcb3aNEZq7fJwpMxusJtww MYeh1Jf2ho1cyc8Cz4TyPXhMjUGjl07cMMStZxPzXAcwvhi9kQ8NpzC/08VLXFwaNlxZWZWkh49J Ykab9k+rQD78gzYQmLR4kMZwI4j1LJXm/X9w89wdqwoArwuvKm4X6LVA92STer95+PbLgEszZxZP jvsxki3i5/BhSANDpU4YB/3nGHddEGru4ihRJmxq66ArFhDgAfbYmuwowbaBVpvYzNaTVkRHQ8To JTImwrukAwMdPBsaEi9X3qe3qwyl3xZnEm4/aYrZvPvhg3aR/xFl4FTkE+vPqrb2dO3PzUlIYuEe 4MRKTaRihig6qXI9FgpWMhtQc8M2U9rjzsjcJ2mpRJ7oyNznmEVw6191p44plH7tsZOAJCwJvgLz X959fhWuF46D09SZp7HLwcvIpQPl75UlRoOw5iVZ9PEDxpnysGzEWSg/y3/QhZS+cy34L7VpZ38+ B3K/OlMyDpVKkXvznWveB3iKulEMpPFAwNnKhyxWHFY1MV6bJJ/K9ZPa6+ZA9Isr6hjlwhmyhHP5 4lIffTd/aRgn36ov4ngldm8rg2CVlYxvr1odBxF3LC8ZGK8GOY55NBqgAfenyDXwlXdFlqJ5Kdod iffXvLxgj46UxWlk8V/p1kFCSX+1voykZ4LBro8cOuP+oOJ6GstikI4drjIigN0l1JmkdgDamx4G N0HZ5pOOivu+8BQ0EgQtBS5VcoEaQo/CeIm3Xr736+0VdKP88ljtGKC/CCZfSRxjcaFgXnjrzsL1 H0B/cBefzb8NRE79D3yTgjf0gikJXEGymnTZ55HN98wXDRgZRd2Lxtpi9jBH979bnKvO0SHA9cAG XNjwuyYwHo5Mkoq6jyBLYaWFkGFq6LAxg9og16Mz/TdsxQ4G/BUc1LM+/gQrv3wvpDfmJLgc6dW/ Eld80sXz2AaYd7JplJh3q/+ReEvv3nEkqr0seqwXU22ehNfMcQoTj0hBOBwxlaLPbEHpAy0Tb2LP 9X6G2M5QGFMU2lZ14qxwAQVKdAOBNSTKnVBQE5XlkVTswQyjjTRXPNuu+/DLOKBaNoJ9H+d54Hvh VZkgCuQsoBEsx18NgyR8bOfANJSA3BhrjmTRjDYq0oYTlYz+DGFUcIQVWi8RixCcArEtw5Lv0Pi6 GtwIblhOuEUyDXqJW15jrM8vIE3q7m+v/JatbKrF5ab6piSKL+li7ClEbng+yKOo7BA2fC25kJlh Eg00yHBB48CqD5/iMCp08cCo9Dzdi61VOgu/y0hEhIJv0YdqW47CRVMpxks88sbYJrbbJQqr0pQl QdgkrMc2Ua+jP6owmR0alfSarIwYARLMUwgVW7sdEsuefQRaRWIVgDDEmL5xvsqcEn2xnBDqY3xo wCPaxCZkZ7L2GWdKPJcfSAf9BoSdo2WvXovauQX9k+qD/l9YeoEWL9l4EhdkeCtjDZy6+EvqUe0l ibqEWGoJtNstz4ZTibH3wAKWyMYc+x7ugncWvUEUn9mJpohzvDtPfpRXCQC8xzK7fAmt+DpJbGbO iLZBb58y5VkfnOZCj2qa+7aBir9Y00mrIgbyBeXEpOaByLbtCSmqfoAPAZXJpRaTwopLbBybswYM 9cqHMTr6088SnTUNoJZK34zr/h2ZYXjDGlMgcmziiRoNJ891lgmfbuygr58gL9wEA/ydE8wtKSyI viRrEJxMFv2t7UgISgmwQbhQFT0OEw+nC0t4ebaU/XS5JG8GrXwoVCaLenZ3O8lQ4iPHNSSFucLY E5BSGe3rB4/UnyOTRJfQjwLw5o/98JeKvMsjYWAmSiYA0i2gbP0hc5XDz8yT9m+S0OdqQznfvM3g Gmd/FYV4Xj2j4R8dKRnYX1bPz4CKHKzOHOuHiplFBaaO6x6BxyIaTpi+0HpDfJAQa/BFDElfZx7w 1hguHTJ6j7TMvfQw7f4X/OjH9/dAeyk3vPO5bdpyVFmtGxVzAhBrLTWQh2xj0AWtYGXQorFlwTNF q+4PL3EWZVWnJVInDuJSk24HggrtAEI63t/P2Fq39Jqzh6Et5VfwygHLPv+eIePwk77LpnQ9Iy/4 ghR3vbkEpJp++yBhzuHlZ5CUebdV0jYYX88okYA5Qa8skkidr8awep+20h/yfGHfgZTIiOJqC/5x jZnTq91DeuaFJFISXC/VWh0vkbEGPxvwnPkHpytb42qyA9M34Onz2mEMxRwTlcBUsLgEY3NY75ZC 5xAH+6eeiTgY+vmJ7Lp5iAdEBbprbldnMIjZSpUeXyGX+XzzgnVSIYgq4BgBS2w/XuhMScUt1EIU PTfTFu+GLu/5CvjKmOWypakR1OkIUJLQ2UES5UbOn83Mn2ttkZAX3NEIxB1Y3jMryByn0BkpihaD eddGRe+qS6R4CI+pN5qO37bpCzkDTHIXCbN43xvQkdw7wJQjkXUm0CdeaTEI7/0wSV66anF4UzPh BAf1Aa1uGs3SZtXDGqOFTq8VfgrIBLXqVsyHtqvgBx4trEc1XFxQTocoRcXLc+51usJYzOP+9NXv 5d04BZ0spPy3KLNv/kq0t9NmqVlj6oL1/b94Efd9Iqv+/ifnKvpukug3Yond/aGtPuzyjm4Cawsk S4wtM5o02EfN6kIirwPoTL3gXPa+qLEWA6LqVbUBGObmAS1irYX4KpS0CPZXYKnXUuWEnSpknHmh PI1u1IIpgR7FrOmG291U3Pc29Opw1uJKAvNItPMLJsuUd4ZDggGu997JgBsXyndNA4JNcmPPZycQ iGJA76YhlA06rTyV1iEZPUHQkiFpioa68hs0VwNhYSaXFFxn1pPZE+U4D2iL3sY6wCg3JVInXfe0 tk8keaNljYQkv/dT79XZvy69cXTv6rAMgtrOlqg5sO93lluQw7wUG16kD8BAR/grUiD4rRtnSKzJ 1khdFMuv9W5lOgb9iqjcRDnTqvGSITtoGsp+QlqP6gkaSN5AyqhEOY0i4aDtgRgTDinNYeNvhhDn /PmwkFdD8OZTOTrmbVmoGj4No0rH/eBu2iKEzLk/sjrMWGtaRxaENEuRn1S+oUM566pGPFAloKzN vceIUSUgtZ/YasyXVgMIf2fHjVVEzXSW/7Bs3MEAKeoo3/+TC0aGuRB9EW9+FMyMYqpTmGicc/KN EP2sUXoM+xw5ojDteDpiq/JoZlzZB1nl8FwPu6R0spEV38nA1/Ds3fSupH9lbQB3loxP+DYiubUc tj1c4j6JuA/QFYfBMu3NkzX1d8eDASCYT13lleoFqTToX0D6TWwb6EAs9zaDGk34Vn8FpN5xEwcH EEAfSRn428Yj57uwj8bLWGw7Gg/m+Jyto7rGMwTg/cv8w0U55OvDQ7MwbUZX4GEx6SMSEmWvqOI6 ScV7rNce/B+BuUj0nZJa/zkbziDps/8PpyRYOk4ouHhIcGdzRzyvRHiVgFjv9ZrbFGoZ+U8lNJhj WuADsw1LtUIzsQHdQ4PC/AJC6KEPtM9T1jyI8BeOj/rehQQDCo8SzH/35G90S0/E/09pdn2yTkrA HOQqYnNTfWFV3dmmkAYFU7zujTvnJMcLoYeBHV3i1t2+kKGMIKSZ1CUYgQYzMCtrfwZTimm9mX8e V1fsxLGqGX6zmedzRVM00WCN1NISk2BdBaYCjFEkIDLUdGTlfNhdI2G0XfmEgCVEvbtqp1HXDu8z Z2HY0RXozjkqb5ZgewPGiGRzs7zMBjlez5cKzBTAw4FUFL3e/bDHFo1Cgae/cPbLKI1usT14dOIE LAiVFOfQLV9IfpcgsdM/tNceF0UUj5BIxDu3lyin0Ko90U5TQquvY/nWjPwWkKulW4Zk142qOaFF KvVry9846oXwJipYLo+iGLke0qqeuhMiy54JTUuPF7zWZ8Xw+QcPkXpaPcXLt3ToxKWTN5Wd96PW G6lUNOYbaCOZF0Ivxqg1J0ngHPTTIA1WBi1VYMXdffbiya43mvNixq3tpvuE4nb7sV90KcNfJ9C7 ZBZ3K52A+igmIJP5nmipvkeWkZ4bIozoYu+nRnap4kPRjcZAu/Cv9lQsOYN6KfJZAPo/7aZRpW7g iyYzi7KJkb7T1njuqnLO+SwQxIpBLs5KTcYWqnMbAREYl/J9pjr6lPKbrmWjpT0/krYzf7IhQjlW fkFkaSaYd1zNckXhzRAfQpqbQKMYSYlyGO9ceFvvreBqfJHjwQfLqGxTfsSSEooWrnVn6dL6eTXO fD4a8pemklV07y+5bK0edxXbpEQBKTAxbXnV3SQ4DlyvUCLIbsJeWC5WtD3v4PxBJs8mhCD5brw5 uwRN2nVZ4S6VCFerAbSLdoKnZ/xKAElaPYXMLbtCGlDVZfGmtlnzEn54blE6q6rk23dXEn6jS8f6 fC5AMorYSyhNAB35/wTyunColmASD4RSTQ4hLz0iaw2PoR2nAKRojpmSBvzbYlo6b7OgS5lko6uk MIItv32X6ADFdmzUi0CBaj9MVnKnkoVK0XwS4krKk1K3vrHwSoUXifYHTYtOC47DZxk/m3QFh9Fa EcShYVJp6V6xzj4jmLL6fItM8HNmtVw+XbZv+oZSMBKmtbMNNgjMqLkGPNEU/xIGB9VUZso+wz4P nw3P9XqFkHSu+Q7JvMLKKEK+8p199RirJhbuyvWSRKvwQ3Jeya/TtBBTbm1dtAz9b9qxMp8sUQl2 KYHreMOz1xP8irbMPX8kqAJqPKSeroy64ufIR15f/62S37bOeVxeNbXs4+Y8gicn6BS4Gej0gO0T gwdLy9BBjwZRdWQk7mUc9aefph606U0HTKSZdN3XhBTuOcNImmhNd42DTuQyv4FsPB7UowqpqxDl 53xTU+v33mWUc3jNSi8G6lhfxkO05UDh44P3nV5MShGsGzuhD6bxKCCIbHQiIIBNUDaE1DIr8dj4 WFdznHu233bXofQ3SSsjNhtLzbpKwwYTnAQst4fgEQ4AcVJ7a457nCyye3KfxzCnbLelEghXAls7 RzvZamh7a+LAzPSCpTb0UosDv1ZEAtoUAREPj/6ShZqf4rGHqPI8f0o2UijIKuntvRhJjx5qnTKp 1jWrXlPeIK/HIr+7Q3ShOUaB5yCGMRZe0u9zaMsBIJtYAmyq8SFP1b7zdv5ThrXoLVkEIV4Tni7s 98J2ZBtCXh/8eHxuVeoXhJUGxflakboWSdUpQyYg/9yZt4aeIW9+E3wEPM81/wlbaAfKJ1fmiaie JujlyYepT2nVQZ2w8XpRK3yoLEDkeP/mqnac0t3Fgi7KsOnEc/L+bLTB40c6XtVdj3jhNkTmzr2b 1AB47ceVT6eA8l7F1MHJnDdC6a8WatJ3esxxrEPBGDhTRBwNmgy4JYyx6gIBBB9mgRx4jQxGysBP VSdOVWjcE9qudjLEnrPQJ/ZskCtaEzCSA7qYuyCB7N5R61rHeJ2GtbkPAmrRyAU7QBGEFG7eHNCq rUBbc67/Z3iCwy3aegrTPer+gZROqG4LT1f+fArvvDV0xkDGIm1hntvO3mOPatVK0Dcxh4NouCEg gosXn3MIULw/MJkAh4w/zrKV8sBUimFmVKu/M5t+vXT2Cd5GeAWwCPER9GbnluYZ9dk7IKdylfmY Jq1OiyskNeKa7b8rw0BXBHKg1iUj6hEbln2rQe4nHVKa06WmQxUFMMBtltda+iB1CyuqKyIMjsZ8 pEnaaTGLKLVSYchf+vMGZ4HGWCCD2Vfxsg9o3ZiJuAC+cOIUq5Siy5XLB9sSelE8niZYR3k9KsCG ocHAcWgho/ztMrZ9OOSgHp94lG6jmBx3i+gytg4HRMYpe6vGX/AXoGtnQ33m6h9Vt4Q3ib05Qv05 fSagHJEt7heaEbOGcbMRvmqWXw/J4KrFXogNh23hJ8AXw5i/bLH6kgBNoo4RDTkL0uNDYorjgmRT wUAPT62BkGQvnf2mcXUTQa+/44vdAKrt13mlaz/ew11tXvge+U6E7gsrxwN76r8SXY3B5bAk1BV1 cHkQG4iGY6JC76V0mSV39ZcGPw2IIm3xzVmM9E6/SRdS5uMLRCJAlQgEudh0ydO6hRrjo3+9Atol VlPnGVV27PeObH8e7flk32LHeVnTU6PAwHlcp/kLpHDJGMyvpo2DVQ/fcH31W7LhqZgSLRwCHHK2 HNAQ/j0FSBLvGakEI49tXoVwYtxGV0XASnIi6eLWz4tpEazVYfMUn2e2oH2fbI5SDNzYcLWe1JiL FdiS9fnrUhUr0MK6eTjI8ZBSe5R1BJK29Xf4hgBY7GsWQXKNdVeShuXMXj6txwLTqTcFGLkna8YR tu3hn7jsSA+wunq4aJIEODRilvIt1YP0UhQSIgaNhvOO41RNYRLJTRllXbhsOGnjR0/P2GKH2JPs 5o4Ea1A11vRg78aV62B+9/i2b//ehq79DKiBdvRNTddnJ0LhMNilFfR7icBwd8wEPVU7f0htvtRI XjZMM6l9uLMUnRi5LxG7ybSTcmxA1TFVDehQcCK7S6HeE5oVh3wklAkZwLTZsikPveHjM9RhJcOf u2WH/Sqpanz/eANglsxzAaenlWDmzox3WpncT8ZtHnqxxI4dInQHdFFnVKPO9TtRrwJ1AT14A224 tgJ+y+1P4tUdA+gApN6ZQ2EsCWmzMO8SCU8h5JNxGgpEVT+MD3kkZelkGkFSLyixpvD1Fns2G3X1 /ad2YPdoI8I+S1uQ/o3XXKHRm9Jf+6ecORFdmvLVHAt7u9SNn23AEMb8UQk0DgrxwkA7zgDWf6Ov nQGcYFLiSC3GMd5s0UCkfB7zTPZL14QBbG3f47zS7XeqNtQj5XgrBY6CBQ3+QceeT4dGqwoVZ5aE D1ZaQ5o2cVQLv1z33d2MhdHIXj3jickdo/kB8FWZBPPrRcT58i+MR+01MtmZozSNf4LqfWe1b8wo QavZqQjAyU7WsKjOVEG1MY5pcS1YGVphda7BBysBiuth32wVHE1r6WxFmTslURwcvBMO146/AiA0 us0hF4Mp65EWXtJOgPLMu2cc0fi7xVc4nOJ7PX4GK+JcCVfmyW7J4kRlpZLjYZky/RhlTSXlTCww +J/nFbSY1Ns841HwpYmjTJxf2HTD9KUIhX3TIwj/BuF834uukdWaD5ow/LkLVLUgIVUrsKedEApL AEVdopzpn/TPyUk5KcV5NV3V8S+tqNVb+2IB/hu2KzgheCtaA7Ys1vKsYDU5uTue9uYn/bK2hWMH V8xQ9P5/SGf60YunQOcSRHsPTCx0zhwa4p1N6NtWolbcVmcoSIz2FFxin758ta2uFJRHbA0mKjVl rebAJI165DpsDYgZmHtQTUETNaw6Phnkr2Nryj38Czf+1P4CbnnGE3C+OsdGr5eBxodQG6Q7/c+u ZX6/Ia1ubKZRrgjXsPV4uY5dEktDW7T+Iq+9i4PGzXY7ocOPA6Dt+Qre8Y/nw23XQXq1Jcj34dhs sV+jQ5hGNOUE3gVZgbKXSwOL0+M4eGgSYWUMJzRkVUCJdYVVENA9YIZIgrRuuotiExPn5RhAS6/r 6eYaWSOv+uIyLj98mdq1ovRvcTDMws3TV96AUeopBrq8de9CTV0iXuuezjBATRIwbrZyWG6c0ev2 CbxzLcez5dYNs8qa5iz7kgmG+CHgLzOFqJvSUZI/Kc+5G9R6fpA+sUaX9gweEdgh6KJZtzttro5O 3XDHc7yasY4zzS70JwaJjCWgfZtdX9bREi13+SvPAdRZ3ravmsA7H1D1gVZpRUZLzsqQ9iGsJYYy tfuowVow1xsz45ETXfm7I3cAUHaIt/v1tiVvtjoPPWmA1DSQc/N8l2YvuN8hMwqSjSfWYxD2sXqB iImSwuA1eumF8LBMWYcHk7m3Oi5DD8k+jejio1dk7m+xDAhM3s/Upi94vsn0yAqbUqPBeV7oMDjI kGvXvlOsmnGiu+9+aVw0m89svjqd/D09CHajPolKZaojY3oPAkPPjo6ccL7C1KpJC3nkNW/1z2jl dXMBhQ7PA7kRPQwJbsqBg/T44hHyMYneO4a9i395kua6f7SzDLYrkCJp2AuccqMqOOSJyRrZTGL2 FRTXaKTLPEn3TgVFThAp2LiSyxuInlB4NJMzuxlV36yKiN3EneKsUE1o9N2fFmZYTAbna9PC+R8r pdHGaVLchTK5ib6E6afGt7rh10T8+MXHSuQi6VjA3LmR+pjDlInj5kJ6JrhXOQSV/An0vmWUdejK 3XBtiNgkMxbkC/rzyXvLGuYJRTKa7nvEumoIf8TftbT8naSXejkxEA/xV/QQeyFeD8Eq5e4et+Wq wXjeu0GGX+5Jgr21Hsya4FNVoC6kT6oSLOLtsLEmkP+3Uq1XeFZDLRT3dfTK02PSOEb2Fl0TtBSa kSwFeo4QUulhN4hApV7fnEz/HuRfL4Vjd21zzzdcI0K7qAzD09GYxtB5ZSF0kezGLf8KJy1PYsQm 64WTa+bZl0nTu9P8BKBznrSkofK8kAWbYtenRGdp/+OTskq+q9Miw71Vts+bPsMGMpgM9mHCruXl Ub1vFiM97RNiVU38rMtx2wgfyhySMVsw7soBvhxYNAmqh234JoZe3CKf2WNTytrc8aqefEKe5b30 S2Uahxd2r+tuT7M1iaiUbalx+bZ8d6CrTgZnpqA88oNFg6NrS1dDAN7KF3ygX2CmqWOO4vRuTjkP vbleGy5HGd4mbKKaskD0TZIVsF/dcr83pO9YJr8GI/noHyLRm1HmO3Lu5yDE1Waw4N4ppUPeESCQ V0zFLlZn9d4TfNOtXHWVEwMY+SQO1SHHm4LN2dPhJvEJRd+5zzOt6vZoJIJl6hADgPnz6zTJlqpm FYwjQPW+Db5YzsM8B9MWy3fQb0uWSSiKAPWcDcb9nwZX7hLbvQ8jybuqNLd3OspWqX76VCMAOnOG 5OFBlaQg99PwLxqGwednD7K5dYIUupNhVn+xJUMjPwqOVH6LnyVcKLn+bwzlnIpn4mfaIX7Ng39W b/ihDAZrmwstoAPdrpbW/ar9uJjE0FvdjJOM0k9YCL0numz+H+Nc/UxclA3ZABeCJ+7OUKs7iRXg xjSE/QY6Y0Ai74j38adOsDzGIrEERqy0sSWZCfCJReDO9J/Q2+l3/Cid6ArFk2RhLwQJD5DeHzZ8 mscuQunpeoNgydmraL5pfC+NofpCfjHp3kHtvPUmLR1r1ZmN+EeUw46p+0JsuQGBUYoTjCYXP4J/ x0Q5RBz5NbQZY2L9xdGtiQwG5fWCfn7uQmZ8KUGFFr8B1PFN4UuKcn7A9Hpncb6cZ9gOZ1xK2YLV t7ADeGZoI6Rhv8sbj1rm7c88kaFvgjwyqrlSbC/1wski0SwUQPDmlG+K1g0Y1Fz4SpqY3Y2ZTh9r BQ1AcaB9nCZgYmznyoOm6v0XjRtvG365zo9jV2JC8oeaaLUPl5CHmjJhvN9kmKgmkmOgsBoJfPBY yB93ikHB/9gDXOcRWhV9oFUrBNU5cZe/WsabWsckmlDqWb1x/7uak03+Gk0QXGuG3MPCF2re2LF2 V6HzWJj0C4wizTeI9SqYcto7FfuZsNGjejUcSy5XUrMch1t72IeqQtOwPWX1JCtxcHS+bUp95lX6 MsZh9biONcxFGaYNl9aQa+dQcozykgwTqAE2+QmviVqztA4MFFXiToRgl7MGqplWDsyOmmLnMZmA UDjHoUhP2HkK+lp2z205/ARu2/b5mzv21qOsO8qS+K9fVm0cfqCKmfg6bgobnEaCkV4CgliTSNSw aUBRSL+S7fP8RkaPXf43DvjqKxVbi8pqbs/j2avvKVgdKf7KGWKX5omgQtkJB43SgYpYqyhniyZz XksX4U+NOr2btUEOHISK7mSXs1+1yXSk4j1wgDCgZYdIUxDIsQnov71BwiJdQrnpW/Gsm1lAEkyc iqoOEC7bs8qwUl+YIBAXEM3GaGLNq3uANAZWq8OZYLsa7RBvLGpNHfFmeUwIPC6oWsSTdtQsgAM0 FmpsYitxMr7dG6l8qVd8Yd3uG7x6WDO1hhFGSOV/TTn1j9x3f7b/MwOgvt4Ud7LHaxTmoGs3dyUP IdnkNo+9Gn1K+O9UOrrXG4O3oYEC1g43siwZobP3ksVCd2UnbnrwIos/YAZn5z6J8q7D+C2XHXpl wcj8YsOb378uMBiUhclbLsN9xA+BBlvAWfH6HcsBgE0o5xeS+wPV/Ox0oA2v2EqxsTpvttjIfQEp nL0rtCz0u6v6yevvxlGC8XYi392nr/sMm5M0l7KsM6wUNNU5htMEs3aS12upDrKI6Ov/9v3j4WZb P+4lZo9lZpSL9di4bSDPgVdl7Z9CiSuITnzBtbslPpQvHG5KsxC5RYys3+TbtNniNOTCXSRoM9ES ML9EMZxbDMHENe9gjTww4WC9Wa0Ly8PQELv2uJNS0FP8OROd0CcM9UbEwn4PAjE9uFCTyNf4/fQJ qgQZ5wquu51t98Jsw9qNcWeGOIYBYz6B4Q2xN+zcz5hVpHSwFEu1YjpdCTfPo3RMozRetj+HDxBS P1ztwE4KBfihfcVj4XMnDlDtLEEBDRbhJc4qH4eOkRqz+4ACinhsihlWszF1U/Gu8QrVoOaHhS4i R7fMbaUA49kBgoN74LCXBxAQmRetmRkQivxLKmx7GUZ4lrdYI2QE5cJDxxN06g4CSRdbRxxTsiZu 4aOspJwQdjdhs9krl4QsWlQNRtfQc9ku1kQ1StsVaT+u5zM5Lv2IhEFDK1gn3jZJGzvyC+VCTpG6 gGcV1sJ7TsEiohpt7aizEDiwP4cRi5KbWvCrKLfsE53nLvu0PaBrcVX2ih//rrWjJziHivM3ksC5 uua1UE618i9KGkERfS81bmIk+tSpl1/VAbfrI4bcWtoqR85D3JkZxugOFfp2Y/0pas5nA9JBd9GV bkD2M2heBOiiZq6oDBXAGbxhTwOgFHipsEEd/T3rpRllJRKOgLJ+bMzrnU7L2xBV5YlK/IfHrGr9 Mu1+XyQIb4GLx4ngufm6IjzEZR2CXFkkc0zRueJ9zc0fghNO2ur0p5Qmgh4mL2VoH18uxHdBvA6r rG2sMrBCsUkDptd8ZAm9IQypSaqcb4o8/X47Vho4dTYYfkG0iL6Tviu8e4EeJBkKEvQ9gEcH1fsj b51RgekJkuwBDo0oOv0pHuuEpqIdkdQPVmNucXYU5zIItgvl6kOao4adkjs4B31ew5pEm3lKi4j9 O/fgr+ypqTWqIbtcz7bFcmCEvos0pBo1ziavWqOMByxx2bsR/upab19+Ui8TnlOJpskq/ddLIRvV tidcx7Bbt0HRF062YjR01Akj/5f6pKt5jr5mpaGT0GFUgzoWfJp25xPfKusMrI5/iFuR8V0xiLqG idyBB7V52/7zyW3Y9fs6qs54fOFKKukhn3bExDj6WDGnuj/c05rkLWxqZHMYDeBWpolTKfqKCy+b AG+YrOmnU4vPr+TH0k+eUXtmexb1zBX8tP6ctUGaJe3VAjZf64sJ5KkFJ7Yb403K/rGM5I6TOvLj J6UAQDBYMMICjZTcRUpFA/m360r9ULyUE8yog5+8O1VSTvGPnuPngG/YwdhPFXcHDUb6fFT0qh+o LrNq5TRChDF7QXiXXrlnVhlFrzMUN9/ffS30N3D9D3jd4sLgEJ+zwN2+KoJ+yHutDrtpJIQTYh4H vmQ/GZXxg4k2q1r5xbeLnCcdduI4L9NCb+MgZWc0hi4uaLpJrAlN0vX3PWixHC44cslL4qrWiK67 N7jz0TEZig22uMiTbYi+T/YMTlLKfk8UAj+77/FiHOxX/HVyH1GtS5Jg+nrSM3UNw2YgPLfs8GWe IidsS0zYIiGojlA8E7N8k70yjMXGExoaENxGs/WyNYFxXE+lWzmOIfZ1kWEvqHB+Q55MyI8MsRQm utDcO7bxAcHOHijz0F3OFQWCIl6ZuyC7pvr2NcCeE3fOL2xZZVotsK/G58LqA8BCqs38iolh0PWE vgxi3WpZ8tT8kviqSszAWjr4PAU9HEYhloazyD+fwtJ6crMQic5/UxbO/qB8dto35RNQpvXK85ov ndp6mfF1jex65+IHoPt2+fwv5MnSpOX3jFxBEwjuIMjsHbe7j4686VKLJgRUxSwXkFcg+rbVfR3t NI1KYgn918SyJDM8/7kAcp3VK3BePX8MhNM7geV4p78BsL7Mi03qSlmETWs5TI43CEDLfQlnFTCx PqBsa9V4OsU58/5mOhwXJ0OzV1G1m61CPa/xG1kDu6lzWO1siY9qNAaebbWmgfDS1+SbkpYoo0+u jgvuUcDWCl4gIiKZAm/rH+y3BRa9mOLxkuQYLhw5SZiXpULK8yOlpmEgO7VxcauNz3EDaCJbHTg5 RVI3ttIZnZEgWquU2Ahv/HHGcOz+YDPlHAVJtEemCbtbvCBxMIPJOWnezO+rdanmzbFUS4/8CQHy qTKotF1n18irtBEGAHznNVosX6/uz8gIXU/2rsCSyW5Frlhcj+9Oq9ia2hsRH17fJMb8RiXCpYbx 0jaPDt3HPiw9JcYs28bCTg9DOSLSeJ3n8FOkqMUg1Ok0hjrxHTsfVaRGmrSkrt/iOrgKqkew6C+U 3JU4Y3LElS7KRdf9fGtfoDCh8Ncbjzf6e7F1dI7c0vNi+D25Zzd40aykB6flL4DC51nG/xgpjwbv ETr6IrsCOZ1T0vqAjC012YhNbEYeTVlBQIOsAQCAHKQT81TdMqdmZje4r+2coDA3F6aRTBlInF5X zV6qfD02yR+hDiGhaAj7D4m41qTT9kIIu/MyDGpnWHLoehsVVW9bPHrSCHsnhMiEfn8sFyc33ZbS jd8g7BMFi/+7j3zUipu6JqTlcpsQ5nCNWbwRoqW0MBugReoVtiQsF/j6/LVR8krrc0EdLNXERmAl th9fEh81kfmWDKZGImVh7EAcRhwHCncTzVEULVZa/DtyHtMbIyr/+8zQ2qXvakRIM2sJbY0kA61P R8UXMW9vHRVJyiRz9KHAbfNqc5ETwcZ7A2hho8AhNTgRPqL98FCUksXFBeJtACQKjO7YGHc3BJST SQ8cFwlDKgWCR63yuYWGOoSkFGcwNYu7KfIF9ntnPqujKXMmvEql4ABb8cKd1mVmeJx1SCv1+QeX HFJJ6hYQQLfNBlfC/TQUJXNrQyiSRarZvUZnyxqQzo2j/8Sb+7eRM5hJz4gMwNaa/CmT/FzRpcrE 8vjdTQs517/swtl6iwulkHNxD6elCUaA1TI/CndlL7pA693278rPNPlf2Ok8kJm89kR1EZw9NdJq 5D5nUwl+55NSLkuWwYlDEUwKhW5NmamBrZ8DyTh2kkH0qd1kVc/m9AuPBaSDvPDXCClukPYBXFrc K9aaJm4sJufZdq0W76t6JqfMDhqgkGq7wq9FSyMfwTnum/nGWteHIqrHY0tkV2L3OEH/jl2s0yT7 mXI+ZNs4zDV6gDCOJsDhp/22TX+dJ1X4xkRfwvKHU2SjrKlD+MVaB/rE8sRWOKHMM/lNWOBt96Rm 3jGygshftzUtBt3WetFb0Pd/0qnTxk3KINTihY/L7+cf28kkcH6D0IcgB69LT79Jt5i61GcbEGu4 U38r+fSW2ac03cGNXL1pINUiBjzRuTie5aJ6NGJnoFPNyzpWTri0at9hIFtuU5Z1c3ix5JooPEx2 O68PAmaPf8wNtsM7Y90NOk758LpjzpaIaQ4TnV77FU8sYNPn38enk2cJlT3XtyLA7F03wcgKmBWt 25145pSypA3QPsbGk7oKCHmQxXokczKoZGVvPVyhT+oA7MmCYmjbYIHPjMHEQHqlWx3HCFkMs/u5 Qit4jUXlngeA/bynQ2OY6V2vUrPWQFCqsQZN1QyfjDpHKGHSE7n5DW68v9XdEy2Le7JznEpA+266 Cq2mGFJnErtmf/M5w48dwSb0SNcYG+smMN+FOO4UPqZVjnCt7POuZn5yS9hfP0z/kA81UlN0MEMG 1zDYbpPG/4Ibl9S+S9prUu2V/7UadWvmCWLVhZtG5r0sqU6NwnEzS+Gds3aNLw0uSRvDUvnQ1S6T COquHixwjdUE2VFxUhwRk/AkFlGmvKln+XLOhs5gTIRZdKNMgs7Pwv7NfriF02GgmxzQ+eAGIX1A h5Opqg955Hm2NeiO1CHc5KMd3wll9s2a2sdxnxNTrrizPTy45cRV0ZP78SwHO50VzOTJZjTYdpRD phkqA+AxLvcNZ9fCx5jUFt+a/FyOUvdze8HjbPLde9g4phBcvwT2kVi2E1EnseuTnW2yJA0B8j2x vJktW9P/Cr/4T0DfrsdBgR6vv2WYx0rauStGo8/DFYh/mzzUYes1hiPw2u329vC+8KOhJ4MQCTwB 5gVPXhxRp9Ly+vuEWPK/RyZ1aWxp2/igSKNLP68SiFA+oFvxY05eyKIUdB3wwOnL9dTr240tQxLC axlbrv8tE8RLBFhgL2LdZycdtHsGtn6krY0AD1JEHMvwZRWqYEWoIZXUxRJuJFoY2wo/ZaS2sY0s ZY3BsqoEFm/85xk3Yez0SJj8+9qdaXrMAg6/l6QhtyVr3Oa1pwUBhV6D72wa8iv0Tw6Lar9o+QQI Iy1vmsliQO0QvfOBPdx6+TzFcPHLyPDicrp+XPEGPlQdWShrI7BR0msdCbyZEycifYzp7CkJOk4R J18hrilG+b1tQgM4c3cYnIE9nloK1zWoAbdXOIodXMd1m8kERYbSJGudjtGor9KABWEFqpNX3UIp x0H2MWrjDXp0o/QHLnbLm8dVD2cmvlb0U4654S5s/fvdvVo/MXCwjWcOVaUG5xGUyz/uy0tLxIxU LOltSHdL0+00KfYVjBIfXhNEySjdOJ6HrvQedzM81eqYfnR0Yqc3XmbQWtP/ohcZhe5HGkCM7WsY TWFp+xIvJOu0L9f6nRW6Mgb+wnry4k308XL9gke9dXjbeg4375F4Hnm5Xzw5xI3/5UQcHSvh/zqj eAA4q7A1Xo7a3n8e+gC2Zh6Ff3L3AjMGkckcCNJFHsrCdhVpdpTlLkfH0PIu619CxnhXsoMTmBAy Row5vw7dI+NBhS4345tNQcyfbU4+VJfv7dEoXNu/n9jkM4/EQjRZzjH6yYDc7gtKbS0SuRolrLQR JY8FP5A2/v5c8GK2cQZKvLXAq6vR8lNQ04yHpi8xbk91VmsXbBzNALM65m1ALsnYghwVHobS8/6y x53dinEU6Hg20UH/gj/b7y4e66yna1X27nZw6ga3JVXueWCfy+zZdCXWno5EadR7CR+W4zRXgNnJ CJropqameryjnW2Bcw/T2q6f2T4ylSmsbUPPMJeuVK2CQZzyELw2blKL5JJENW5rIcalcZ1nwxnN +VS7k+TTDjOdWV1IYLyX6G1ODafxAZ9j1YsXHW/CzMWKd6rHnXkZ5OYA3EECYTAd0yLEd4Mia/Hd VnE94MzIi81XBDbJd9snNFc8vYobAJnT8FM2gJ3tEetoK6rTqw0tN0XDxLHPXDe1z2QKP7FIawrN 0EYyDZ8LRtNUbD8RM4xX65sixjQSCgiTYQSNTEj2QCXvzBpE5b6tiPpN8bL5zCSTLYRWSOeAxRok QZ2tfVwsYjOhDSe8Y3Re7n/HjG7z0fM/b06jgTyqdykgNN74z2LSKQSF7zMbnNP20KkBeOoIte01 BKMa27Yfa1tHco9K4PwPYO1q/XJOoEdPjOOYQ7Ly9oOCdnhMdFMecD5umUuFEy+rHaadoPHztN/q XZ/01EWj9OzAu0Z8kxgAlkkcD/iQBSVkVsJmbyUWA2bLyeEdGMoEm99Htntysn64nLTlIsPMfl6d U1Cw8+z3R6New3mPXq7s+2KVPV8OCY/zm8r01Lmk5OunXmmwXLphlPY+6YSvB7voeoGjIDYcdYK5 zHuZjW31XMGajjlvf0ssAQ/GbJXBC05z9qDu9NWQGWCoduBPJSxS+z4+2JvY5ppELrQ0XwwaSGjW mJOGovlafFST/9LGiln/eLv883ljF9Pc7ogEHnECas/tM3CDYS89OiKAAzk+bSOj5ZJ023+ZzXYR /IHkn2wN0HW2pngXryzn1Q+xGzoTQ5mz6+AGaIwXN/+lkPdoHEhlx34hOoHd0Y5/d4ZOJ/DvQ8Jv kI+w6Es813qrarY/dl3KcltlVwTP8qNtASaBhonSVFJITrWX5N7d0mhI8YND5RczFkOM4Pjt8hHG d4dOlqr+CUCIkN7kEZviVNqm36pdUB5Gv/K2F1vCzezjd3XiYzoTrm52pWdGPBTJt2b8ulnhlp5y I+S5tCTsFbxGhGNnSj9FjuCMMemSWTpmFwVMlj7IRBnwhGjz2WWriQ7jxRM9VeYX49xIrqn0BOtP 4+h+oVJuHyAJfpmVzygR20HACrUdFdP3DOFfogWzdQBKLu3R8inEt6fQFd5ZSZcHC+bpLdKiTqjU fLOOlOc9e19HdKtHkdvquQyU/uT4CZcad1RT0VTSDjzMT2+0tpOLeNCWePaIsG8POnH5gX1Wxjpj x8Pi2Z/dsfERLDAB0wftmIi+7QeG4m8DL/5OBVgulRC7OCenIsyeZrG0hqsSYfDADAUKhav1tMpH vb3T8BVoYyjQ0ZJVtHacVt8OM12SYgaO/xEEyy8Z5h1f3ZiE2oiXqeE3MoIWEMOg/oDPfyG7ugit gOyyzh49PdlcG8smvBE3cJN1vXhgfwFeJ8IUk1DV1dfAdG6oauXrFLnRSarblvJePhXLPohoC00D X9Jp3OMHTOCS3lrqSBPvQn4u929xMeo+Jk/2qBsi64hDiDZsE+1R6OvIWSux8k18mwQiAUnoI8qE qg0C27CvEy4UhUj0LO2faUA11L7KYYtZJrs1YkK5VBo83HQAIY5Ukxeiq6dN00wEd/x8P1pxiMdp 8zotbEFU/HDDAEnlrkubABK/vhGjWj5RmC4wgqh1MMOcX+bLvSYx6kwdQ8iCQQSgPuzAI2UU9ahJ e1nzXdESGqMlT19Dh1UKY6s9nsbsB5PLzhynzb15/48Vsc7lfCe8kmmejCPdF+axXRgf8KXYs4Dx XkaBdtQX+ZxUgL/5bxn7b8oXphs39lHsB1jUXS4k0J75/4Sox7VArnFjajZtJVs1nzO7UuQE+IJ/ deJHjWpVHQQ68QemSLUdR/jBF9f+8M4rSL9YMpZbo8j+cLM29fTFOlRZqPrm9vUkg33C0hhjc5Fe mSVxzbsvOk8j4OktI1mEBtOFBY0S6U1P4kbQhGBCcQ2pVD92je54uLPDgywgZCqxvDmxNCTKEQPb lMXSeTVAYYhh5HQNroz8ZxB9YHEBhiU6eAWtY+zBJYIMiKL0QkAXKujYiteVmvnTVwcQz2ktowMn PWXo6nUecwgneSJ8bYErAIxscVj6HWm0E6+mJbmPzVMnUSNwIQkAgBzSXz+6YswO1j34l27Ddq5d pkdaL7XSlG1VQ4aaNUtEg1FJ1I+LXo8WBFuLttWbAA0+u/JGrcFXpDd2/zYz9mELM+3Iex7yyG78 Qra/2Oy8Tbq6b1U3BfQrGh++4/v06oBqPJvqdWgl9maPaKgpp7mfxyut3AxTzkGKFXhoXmQFcLt7 ZhUwFDtvBjshGq7Ne1UlVC/V+B5n3Zw3CiBSvqqNxyQXy2qJOD/LyK2md6xVTlArnPOZMzP9wtIn qmFBWQtFrppUd36x0hiroeSMd+2BuyLazktMgOrMHYiJ3JUgYqDyDO2mQ21uXFacsQ/8FQbQILSN zgijPsQgeMMxeR2jerMHIFGIqvik9MwyIeSrZ0laquygKB5qrUkqbGPYslXvj5u6ljP519Ektb8s 4YQoc6wnR04hdB5mwsXJA4Y3B0R8HLkS2T7p69XydiTfjiZ7czxzW74EgmvvLhewycPaO6I+yq4b Xo63xv97DskfLLnZV+YsF2vVc+WJEevqVCO1iquRsJlqdC1ydiI0Y39pbPBkHe0SuAPyvkhZbFKS sHpR/bE8EoTGvsy1uUuANbSdZqXHeRL73HtxF+ahPAJJzFYj4/ihW7SF7gM96+RwPPlUlrb2Jm3l 2eeFqUz0OEEo7LKfKxtCEgXxEf9tPkKXNlFygZr7KL8ErbQULTFWceYChwUzhNfEYYrDQ1HWojW0 TEfLH8T28YMobiQvfEDRz80wYt+O3VTvRzw8Hqgsr9539WbFX3aZsJgqeGP9r7fLyTLWdUMwkCvT ljubDcLgyPVN7csifFYNfLI9qYsH8g+GlHQJYukZLvFg8xnR/kwe0BSUzP6E8UhhFluYdmndsx6c Q60U5gnUXHYVYprl8q4V/Av5+haQIH8/vTgw8dDOeq7rqlN5UWxMTGURMTLRXmDZxn764N0XntBU WprthOVsomWKHyQolKBDeMNxpDbD/jaScIdz3kr6z9mY0DhACLhTQp6OQB04cn6WSUlq+Ph00nUk +NFw81oS4Wwum5ue7RMuQVyn+5Lws3oFHdgpt54oxlJ8anINHRwNOlGH1dhrkzjbwnYxBZR8PDUp OYLIJguRLvO/P/V2hsdVFpuV4mruEUBGT480oNyYm5vj8eNc6WXlx9t6Bc9+wH6L9nZ4o0KRu7ze qmxY97N4Muy9U1vyUhVRCD4899vYfRzXhOSsz8odnopH9B3DlzZRYtRUJjLI+FvmAeAVcXBHYAWR qOYX9CByM7HcE+dKo6i9FHg74meM5HAidomJ2DfMcTPuXN4jt7yW1bGdo7nhpamG/hve2hX/7RkF XJmJdMhmVEDtB9DBtDFlVvs4ahZuVXRm8nz6N8i26jweJz1QE+M3+2gHKLgJXr4mU0IezcL9ccoE +mCb7o+6jwe21Ks+qO7z2D5Uc3KK+m/MbPMD8005VnIY3vikSLp6f8uZqsklqm+lee2Qdh0dFwZi H+94Dz3A/RUFYGidTCirsvSjCemHViOlIG37cWzuDE7XhNN+j7IVc0EGuwuYIjEq5Qb+RErVxrqr kHHH8agB+517i3pYEE78sK8Sw7BGL6FLQJcXJuxDrOeVehdVreMyHAx2zrKkO7bO44jhf37sFegg vgVdpS7++v5ll37rMUV9GNW0TwHGYrVphAjtKOPeEUvztASdzLAye0ZISZ6Xrh7ovDNgNIRHT/pd Y6VBzo8Y8QgO33NznarKIrN9imywwaAOHyJ48x6GENGhhq3ATK4IoFQZQqAEhq5cinp8ihUuBA9u Co9dAGipzPjsJQM61uLoD+h22W2cXHY9grPLOg+yw9J6baUrzmSEbF17esM0ZY75HKCQclB03+nI 121yEvfApeMIyYcFKdotgBDgAOBf1Yks5oKw01ISYd9DioReh3oPB0GJU2RZRrrPIJZVpdy3PF2U O4G7Ne6rdg7RTWxLmh0qPPSW9JLptj65FJg9alSobXKKa01XmU1S0QucezbpictTkaHTa86c9vlU WxOhTX4tmrAnE7oxfqmvcX+qvrh25Ws4RLgNOEUNuuXDBSRMUyVuAbEJKAQqHap9L0hivToLRbpi APZV0lr47ikRRSYe4B3aBIx8MTIYQOJBi4SBk1mWXQC2VRqLf5XGfdhPVjJctV2ei/r6se8WJGx/ /n0BHBw4BUGry7ZLt5dyoEYa18CjuB4vlOh0KndeorfkYN80tQq+6wAZRd/Nh5hpvwoV1d0ieP2P 4K62E6OndNAffEH0vsW75w/swhxZUrUZQALa2KeJQtBDAZ04eWYzMAPfU/rNLXxdY8f3Iz04iOr2 lXbc/CeATSMpTjujVYN6jepXhth48SC6Rl42PdFNx8XaNbOuY9mOT1XmY3i7PUAIOfh4EyUpOV1Z YNr6ce4qzpufHpG4KxdwBxPmpQV27epkvM2wD2+AOzyjvepk5K6k2KZjBL/yCA2nQuVnvwPM2CMR kmd6AH1gCpZ0nS9bJKeWxMSZpaNXAwr0O5qBzQ/Fom5Xd1FilmCaDUrhO8ds1GwJ6X4+Dja45HdN yL0+de//wF8P3p0RKJaMBTZ8/d84T58Xvf8VeFofVmaej7kzGAFIDpwVkAEa0Wt1C5adfCyYEQEV lUTftuPsibcFCJwRbX+UFL5O/CfanGjYewFkNeQfXiegyUPt4oVraNKsbm1eGlfVkeiCuKSm0FC2 xNmGuSQ7Y0rhvaKINTSvg2JCxO5tQvj2hZtFC0AoiTOlRbxZWnkO6WfW9UtUnMo4VVjUpH7YKiDY n6+wrr5H17iaCsAYRvURY7a6tdFyoFSG6MsShtHG/xwj9ApAlKn6NC/Pp2md2UV3D3vIF75R9xPx 8dmbTOhai9Ml9aj00F7qJ6D+gSKDxRecWHmA5A7YZyz5TNulXFJpDv2GYWbQBRYrieZwQXvhhE2w 8aKTPJ/ZM5kXswdGlpkiIQ3c7kO1TknWCGyCu05nV9x+88kZ6BwIVB1jAxI1jZD/mbuofzFdEO+h tWnrkL8upzHq7a4ygfNeC8PE7yXPq9+8yfWM7Xi+AP5x5KiUMKRE9L9ggYZ1OHcVgI2Ct1UpAKoo S3ZlZMjblJGvfNRHeZbnNN9WEjV2x2TwUTGhUCcAMyFR6d5tJ8m/ndbNfoEG1OpAdl351Cd7/oG3 KC4iVlfU+tuId+LF0DNis3IVQz1d8pDKt/SMQVDcKls2PEHX2QrCMx4FTnSaxdk6e8ysaHqc7b/5 jqqxWbk9bgoRr6uHJbzAPr5aqbjYA1TzhR5dXvhx3ENMP1SV6DYuiR065r9VRGbCEgJbEyOj0Y5f /LQf3jUHlIsFvdbzs0WQrrvPPICXJXOSYjf5rYRrIb9jo/urA/75FmZ2uc75dZKbEw/5mGbP+hY4 x5UVaEMg6zwF8mj0omyUKkGSqw2B+yjaiEWVqTXYvVK9T8gNtGNjooW5E3cH7K7202Iy9y7ANCAD XwBlKGvNi4rJKcRBFhagSNlkIMWbBE11rbORPS0CQUJgOZ9o+pslt7uM+khxoqILliNodz4rBA86 Mr8o/Ngz/x57w3Vqm0sIH/Ea9jPg6KYloM3pBRSl78ArrgzacF1sRvv17LA1guqY+Bq9ryMesvPc XkoasbjLBDPkyGPeZr4pXIzoWtwTe/IWjZmwg2LgIvFvqtVoeJS1ei4LYZjMz19OCmA/wuNOcwlj 6gxsRmmbLfhLg9rzjWVbsohBoyg1BYPsT5KjshhVKl+im3wXyXWPGK0ny6WKLxZzfH134lirzKOl 4cRXTUnyM3MVrMxfAtJ33mBttUpMob3aNYq2P/GQ0mcPkZMqbMLbJjaEEOspt93y+/RUJMyFp04J tKslgomC1IeS5+ybyESanAuP3ylWyPttOpNxdmDGvnuusXFh5kGgtOWh0qnxG3p00IJJd8sL0Y70 RABd/b8TYGcGYlxg/DQ/eVPhLXMcODJeqC8h7ZP1Fn99wExfdTyv517ciookBYudVTLWWdszUuXH C+vLUtqODbV/f3m+vw3TqTB7aQGm9YzJUm0PjBI3WQRZf+Nj8ciafzJQKU99wwAkCobs8GPX5jJ/ hIOkGWW3B2hnCYeuMwL+2J9RG+9u5GrG1XHh2Zjrmar3bHCQWbShtJslgDvNWVHItF5CwL/0188d uEjs6fyoqJwwsFy67HWi3AtB2SqQ637GrlqqMA7GSAD1GrWRW0yNvBnjvTnyCMFCdzJRcUPDFwlX rz8jxFxmGNP/QACLlzZ7/LBLeL9yqocXUPROSHNwNLO3rR7+mtzDPs1YzF/NWK9vFtaTRqT9UhzE v2bfH3q03Xlar4JUVGE6iDzPyVARHtkt5mOqp3/g/b7bn55skm7+GoFHVWVKhkp+2t8SfDaza+90 cj3LYqCEqRF49nVEkP6MlIbxs7Ssw3v652+Df1HOvpWy927yy7nQ4Q82xXOHXD2QaL9DbSWvJ65a 9WCEQLyGuZUIh9+jpchHYwaTHXDLwLVRiMefsXW9i6kLo2SS9wh5ed67mbAdq3azT+WiLdn/ElpM fs+gDpiF1E2vO8dksSmboW85UWoi1QicSHOI/eAulrf9aayXUYrCRv/O0qbRzuaxBWFl10Vd3yVN VFPNnP3iuTZBRxdILLaGM3jsLPnNGmR05oPk9NOPNH6RlZfenQ0GAxMIRJDDlw9L8sM1t0Ap4iij 0RXa34FHZ10xSAVyEA/Bls6HE7IBejMmvCTX9uZAFcU7wIPT2BfWdcV7msKkX+Aj2SI9b3Erzuzn gr+fblEcvkA8n9NcoGugt6uj4Aeq8XqnRexRrV1sWEbQD7dOtKT4pubZ2sjAA+XK3I80UzmvjRtY YnCb23QJ7QAr5oCFrNNU0wuDtF+jJHa93R64GFpO/totE5Sj2WRGhzkGTplEgJfOkw0572tWj63o 0WPUz8YcsxMhBp6ssKNURXjJalTRPHtFMdkd8lj+v/IM+CVkIyF+eJee6JDbTpGP+0aArvbwJ3f4 JfeTv7ERciUkoDyEW7qdyXAQxrXkPEiKPvmTIWG7duEFM8kX3deGTXhUQWXWWvHdGG7vujv+qLW5 A5Voz93oWszqUErv8uIoOZ7ZrAu8ko0T4aKSKBnAAoiECutHGpYkR1BcpJb7wbE/csB3Ywc6tEsp kOKbPg/6NdfIb5jbsPc2ODnJedTyz8nSqmOJUBH1DyDvWCI1shPFiOZmVEFQd7xKRYfVfIKS/8NA OQIVoXzI26LAGp1IluMsVsxynJE/2XJ271cwR5C0pQzt9lJMt7P+hTcp2gCTeX2f8zRXQF2QQoMH ckZ3ViIy6/aMf0dlIryAaJOjITvB1sOT6V1Jj/HLP1r+pjj57WZGFCQtrUdDHecwcSpZXwgDfQSH Hfhgb+ki5mRFwT1DFzaqUdUoNE6XSuoAtE8I5j/NTK13t2LaKC3OknYaCwpsW6E2PsjWny1BZ9po PVxjDxxCIr3elu4pZdp+LWi59DqUQbF7fh3X84hZ9bxCxy+8DABf8h2bYKgBlfv+n63taMUld6bz aGL9giA2LC9qQjy7jfYJ+0G9TNeOwu9Qp6t6fztiv5DdJghPKh/Jc7NL/lJpSyzNd8dO+RRxQ9E4 uldjsRh6kPSvnkN53UefU02A82imi71y/spEd/wnhO4WWZKxOZaqoifwVQ9TzPpeBsHxX0NZyPrT D2FtT738svRoAPApK9uzZ6OgZgc7nxrcO7GJsEXvjtf+pZ7mswmts0L9z4oz+hp7GNbix09xBv9i GdLYIbQqSDNiibV73CX0xxYZJfqfxai+oSN97t7YxC0tnHC5yP7zt6aL2VrmBlVngtQviz56HTtS +WIJlbS8AQRTTDbsOuofIbFiv6/zz5odSYtn7vFIhH3x78t8A55mxlNaB7Bxd/09f3V+6KM4KPX8 5xadMYp6Z3zPXjizh5ocDoz91TJNyqDg8CEPnGU3BejUlY4Z56JsiOO+c8SB/97s0NKPOHZD/jW3 F7MG/8a5ya+8o1TCmw5D7nROYfekc9+juQoRL86lK9RnzbAAUNXLFK78ai0K8CHg2PaUVTZHxzxp TgqZcBn4aVfieRurJF7XvDw/ssOCRF8ZR53Iyy2vGXchLOc85fAE0NYzog4a1erJrYZvKC6jxs3j t9jgjTvPZ6ePPfT5nD+uGBp7KPOPofj5L8UTTX/RIUlFjtNVnZKG54a0KQxe1SC/y/NJcEXBumX6 6dBrQgkQ1UTLj4wgE/+p75a1oG3uJXcOxrB+KwMjNlkztfAxLg4vmOhoTT5kwTObCOKxHlxVVTe2 Xy4HA5bKwf6GcguHZGgry6euEi4cmZmys3u8jrI32UPADgoUfoPSVCJ656MAWvZydeGiIwVY0kkK NTmpA0jmVG0gn+v9vWuI0Zk7Gdcug6uIWT5CgiPkuiLG712yITiifzwM4ML0Scg5kXLtvwtF7Dvb HyKFuOIm11be0ix+/y+Mw623dTbBHkv6ssmUC95lfyMnQzeoM7RvNDEk1W7jI7xvrD3TdItlo+Cy 11M2+IrwyYW9AA3f7rYSHN/fjFbf6XQKDoZH6/1b9xSirS1HR/NeAJbaDLm5TmSC0FoPBxXHHEUv 9gjgFSRJVe35QYfns+sC2dLe/nE74/6dMxPzonhb52P/yrQme9kpzVp0vyup0v4DR0zkyCYgPUDf sht25l9PCJsmekM6T4nSVBwKHcI8BchtTQwKEKwqbcEOr7QsEjMH5xP8HQf+v2vv6xgGPPZQP+8V vOze4x/qbbEdfi1xdVj9PA+Z3AlllImIrL7sag5lPkHfb3mcAWOkASnJffLozZp7vsixsDRp3Dpy B0ypO0LLCfOSh4DDDAXuOqjaxB1co4UigKGBrNHGH6fLLizakUatrnPZhOOH+XRCAigY3qTznVUk pxvrXYH1rAXIUPqUzSSZ83eg+lW1gH6T4/eqm9dEYSjwUopSXrod50QE6OisGDZB4cw11XEpXoSa MdcPDMOyK/u+oikMLlVP8u4gIObawv1VSVAL7moSqPNXbGEy2JOB0j1RLO2wHZRGVVE0RwrD2GiG CeltvAhLogTur6MGoDrXeeU+IEye7ZWs8CI7CPIdfLlcDrI3BWfvHlre2CSojTdKsFz9q2PNZw56 VN93/2/Rex2uvvJcED6pU4MW20luDT8kTEk5n9Vh3vg/fRctmZONjYvSAkiPS3mmucvGxyq24kWf DBnlc8roEBvKKKThdBoLP1/Hj3D/wUrUHV5rvpwhNo7KDYPaAevOSsL4lTo7jpRxZZPhr+7VfgN/ rSaNqWMhk2mLDrcVNv3cLfYsmXdd0Z9Q5tVrn5bHpz4yfS1a3Y2acmqRw7kWz4KqjUSNGyMa+7Pt uZrQMzeKez7MNXzN6aC+zD9tMti/nNkN9ws/Q02uRxDc6zmjvMBQFM/LIjZQ1tOj5zyglAh4hL4p VLsKdQ7rQ/FOnrXmX0Jiz8sJ8R447S0indcOD/snUkSKZWYTc4GR1tWUQpyzS4HAQdHRMnSaZbk0 c9wbO5fSmW5SKKm/evjyCGwjzB1r2WG0WiPYHHcFFlLrJ67vteS4Kq+UgXJddUg/baUJ1W3S9dzt PiANZR0y6IkhE7NOA7IViSps33ZBNpC2QEZsI/w9K4L6gFDKSG/YyH6CVH/jVBY5uudI7lyy6rMc CQ3jTcK2gvSxxY/ohayRVUeCii9GdU6h5A2r7njPSA5kw4Fc+EfFxhgGc9g/bqRNAtPabytEP6ur 6rGLr30+SCyqkJHp9s7hCTd4oph0YpV7LxKnRBahWkVR5F/40n3y446i4LxNXQNKC3mVIDnmru5M eWVKjbdTx64vSVhgah1TurCIrPfRLB5dWPGDpyT8PcceJkciMbM5pqQsKj/1BJEMOuDuh/VuJS7o ZERUSCVG3zTL6nAeJn8/9uHlTn+fFe1adJjGvHJUrn4NE3/sqWlsRpAO9UkqroPndgQ5p53gfkR0 7Mi5fXa/WiwbWRLhS10cIhIxPpC2O6MNcZ/iCYSwbaiYNnWiK4KIDPY+/jJzU3WZpqKhI+NWQltK 2DOs8JDzNsWBoaf79w6hiQbbkh2Pat0ib4jFAZdrUQu4zBTAtqVpluFLtYo1YWpxIwaUpAMfILmc KLwXYHSoR+OKnwygd1yx88OnhTMufR4kstikwWpM5wMwH7fHVdlWq1Le7RtdivmOvVR7t17pelL/ UIoBdURdbKr89Ja88u/wmNK92jcsNELMCuDF8CgCgr6rXXedBnGZMtSoukzrpTf9F9hK1n8eta2w 7mH1wNzprajtOfH+PkbIflyrCBRuI+bbjPWNHHGchq7N0RMRYwuCN+CbNJcaRD23xm72b2DOIb8e /LBQZe2EzCj0Lj9A3Zc+Xu0iG47L2vcehKePqYH3xcpJfW2hYqtPJ9qni8XefiqFhCKJW8gpZDar GageoqwflCZ+RMx6JMSXkC/rqBJt1WQKsecF0yPgHTmOyjxwO+J44II0OCqlLcvdwCoUANCbJsk+ m9y+6j9wS95o5Ze3BQvIDPFkgBlilniORXrISPgdt1bo6qSkGAeUoodll6UEWv+4dG3pSCUPb1HS fAPpKoeWmp5Ku4z5XigGxwdq+lxz9xiPTlSnVa5tGNGdcTybSaZo1BARIULBTIKLnMTgkJ3Tt2YD aO7jinURZwE7RwxeKpE7jn+qchhrwrsk/5cPCWTpjSFyp9js9jPH//PX9zdbTx310QeQYV1G1R0Y jL1NPp87Fj8Z2WyL+FVm1AJ4KpOrqutGngBQu0CRdDZJmlFB01R+qV5D4aMruMtxuTUQ1igPazqD EP9MUS6j7GKEFC/QKw0xnQHGHv8l3I9mujB2PabaLIXuwnBTcWhsfVGHJy6hT2gLYs/mOCsps3tU n/OtrAiNQ28/W8kWAScAUCqdHwkpiG0jdGof77we6bcxGKeqlQz73Xwl3EoivJuldozXzFvB8xd9 GeoJ+5HXEkmtO8qNWJVmfsITtJtcIgOucy+SfHfvvrqrPoKaEslZCx/hhW0SyR4CIEWay+f3f6TZ cK4W6qmP3I7QHhcWFun5lu6MMizrgUpZZiAk+4KQ93nE9xBg2QWkVfe99I8omw6V0BwG3Em0Rfui plsOz9xNrh2nYtM2i8aonfr8p6F41ktj2mY5O2r0h7kAHewxcBzk588AKxslNHg9JuZjMlAhaVzs yGwZLRT84ahkNmt7I1pSaOmxboBNl7Rm13gchduH5cl4EhsnzcNB0mljXBFRojNGLBNjuvEIN59w V38UNPGCQsZGBAmEoBQUi8nXurBP53dbrtfMN9xaJNAHdBdUUE5gpSO1ShhCEwPLPo9aHvabbDtR /1+oGoDD5MyEVVjz0RCd1JfuSBZpoDUAzShnQDN9qjN+AsTQJZFhKFGHrkf8DF1iA3Vu2kTRXDnR Uul0XiY9IdCiHKZzAOexs56JgWEK9Y9naR0axPdNcNH89bAvZHxYQcGA1Op9u//w85TwxL5BqTsY zCJl2SgxtqCb0Kw942NtVFheWu+/wNS6kY8Hm258ru8Jwq5KY4CMSJh+Z3Z9Z3P+/Xike9B4GkPJ eN+Y/A84tEX6JvXSdGL4QUmZC60L/ceAdJ7X1wanrzR7h2ziLiE4IlYlwtLE4pyyWAylNt+j3emD NXNF30PGm7yKaULOZrzddL0P/Anr8I8qRY2iglR76CzSuHUUhZENr2jY9h7Ubvh6erIlZrdleHQW jZHvZlkAh5z9PQxd8idupJZ7hbbWkMqkxRSsdeA4rIsW3pOV9HFsOJiPkCyVUSK2dyauy98R9xkI vqSL8n2sPQKXgx1OvathGRHHRwf3aRijV+2MFhGlspChhkgyBiQLV5G1JjsziK9lwHv1q6UtzSYq bsuk4XAQ9qvjSpjuFlf5a5dv91i7XbXS+urIZJ9BhGiaCd7vrlzbjI0AUasFPjOALrEqi9uiBeXR f2/QntNW10l6uWMa252JtRIgsl3h/GB8KDTbf3/Jjp/WDHTln5HrVOooE6Z2jrDlDiLOxWBJl6dM XW6OJ0EmFgoETCk58fCWti3JHfA4mJ1uR1tshQ7BT66orZdjpxhnHTTALa3gqPy9wv8qLltZrDvd 1soJtL0oILp8OrkoC/K4n/RXD9iEt33BpnIIiP2Hxv0yQ3EizEIZfZWga+dQJTckV+OR5kvbXKW1 c+uWO0yyN0iAsVdkWFc1LvhXp7S4I85eR9Le1xPSxRnEIkyM5huFNGRnztmkP7/vd+grJOJ9PqLH Bawr7tm6DMGHFrjF5Gcryvm14W/M4oDSyFeT5OlSLtFcOqYn/5ibJ4azK5RLB6zRryA8GKqDeym0 q23T4SGWCUvp0Ar+veXVqNaMObhqEAI6D9Lg8QGcNPdUdQ5A8ZKbBpnOMFnze2sGPKcrA4Lf8AMx 7/USeEVl+MaMGPOdEJ8n+7aFOz3DE//6iWihEwJtSuIf53V8PH76WcguHQ12onhUh2XImxl9qt79 297fRoMUvEQw46r98zwnpkwEId/1TqN5JnfvWMfQiNmg1iTWa2B/MR139hLI9cQH+hrslE8f/W+B k5y8UQ8LabjQoCp+0/OSkB/a4CV2Nz5NFix1qo7p7YUMpZ9uNGMRVpD8msvJCfIWVoGFjOWW8MdZ 0OrW/MsCzmIzhiPh/jqDioibzoLbnGKRN6GbggU+6Qi98yWsF9l7qIPUhAeA4+RALC7xnhhVwRz8 zn52nB5LQCeCr6iBiDzolhl/IL+D3erF0hUVyPw4teNEAPyL9fACOkdnGHXoic9PnPu+6WPYXKYC iuUDGTPoFcXB5OY1YQ/Yqwm3ECa8bAsHoO9uyhdwbkkURDzWYGqinUiiHRupbVepVoTwWksz+H8S XoWwWf2tAcd0oUGyK9u3bBe0j56D4cMaCwen8FI75QOGopE5Glks0CxTuTlQ+EgKv+hnwpDPf9Hw HmM62JljAGzeI6tD7jwtOZ77jx8AcRACzL+i/lp4RJ2juIwd7g3gPfCf+Efz6I41JBOTM+8+iLwV gwykyNjl+7KZYPSQRIhFqhVN0Z62swslXphkPAqYXETX+ExRoisd+Zj3lLiob8wrwG+ht4sAolX0 tEyrXTCJpLFZnJ9Fh69Qt/+F7lsqcWOd4/WqxDl1pE1HebDu+B2J4se6/Fi2tcCKbECx/fJvehJE v6ZBN5NLj0TjzcaRxp3SvCqmjowbdBn3SrujJ5eBjSJ72OgPUJDEUr2ncj4lS92oB+mjq9EWP/GB MW40sMzDVTM23Fy5+F1QwJWWus064txRAl20cEBQIs3tyHPGkYhyKIhM1xHgrm5CPwQxCEXRDvCD j/dAj8uczvvZo9LVrbfnqHmDtIX7pFdxXNofU+cX0z1uJtlxjj8SrZADp4XCbehFaQUMpa/OYZ5a 17me8fPHZ966MGigE5SUAI1OvgE92JL0uAwS/+G6LWZOFTEx7zJOiCxWHOkjbd4An9CaV9ngl88y xF7UCLoF4StPx8CEnj82FHvUssSgF3lw4tZQgnYFjjpA4S6ljA4ngz7DU+7i+iUUm0RWwdNM7Rnl zgrq7OQkMwb2YBbtZ2tHfbBQjK6nVMPV8zCitFxZP1tIlr88jBLKi57UZROxwtndCuhE+JspUkuT juhggr4YSYRnk7qK8MotfczfbfKWzVN0C/d6kniKhihna5LRueMTW7+nCwd22lvDyH+CDCLUuV3W eK7vd8qd+oynJF4nkU0Xm3TP149jIncZNIajfwI+WMMCtKD+cxuEOQwimcr+bQHJ8999+9tornIN QfPEp8YwvA2HGQorJiM+N/+UY32BhCPMat+ktHFwP9XmPa2d/UJFCvQ+Zv+695270sg8sr7PLPfa unLXl2isbx1KO9vlbUgNqJH5VJa22ME0U2KYqL7qKuj42ewSojriz81eoPRjveRxkq+zDsysRlcD iRg97HWGhom5IBvWB841esWFsCYab1KP76dA6DnVIzR9Cfdc55KiBdUKcqyCmvDtI7FeTx9c89RS baGzD30oyOVEXPeIxFt+lr/Ub9hSVm7JCayBNc2M0b+fIZaUl7sRoUE7Cy9eKliQ1f04+goxjqse P6QFAkGrdZBaE+wZ4cfabMCvrxaZdYVJuHLKp8OU1r3tFqyWcIdxY7mxGRE9vNcZEZFp+rHU5zaT E343Sghg0aK0DF7leV1s5ow0SLbMeD9sddqYwMX6pdVhMm0xQy8HbubaX/O0OrloW6pBwkOrqlbi 7yWDiYV8X25MQlSIo/u8nAABoBRwj2bfYkH28UfGWRc5ZsqYotmNvavN7DihrZwSsZzVX622bdqh UZW9ZdmFLpnQUWp6uE3LkdiAKMzKgqi+NbDZWWLnmcASxxGoO/45PK0BWOgamlrCpqUy0MSqHJDo ixC1NzOScKndSwoLjXTLon6BNqRcRrb7NnUJxPB2x2egKCJZjHJEpAzaDa8SDkQ45e1MwS4ptzGd 8anyI5E4hlpepi1RRsUBFQ1OXsxcWdV/5RD/PEosuZqp5r+liXnEJqAw/PGUtOApVBP15OpLmfut T3ATWyVQEg6kvKDCr51Cojhg2YKy8EfCjh6SkO4Mhi20h8xPSHZqVD3pLQHDtiqfhrpss2VZIf3O vQrfJvAo155vyu/vKchfVwQUNi7x/lTIaXlvP5VpS6Bo5Bq0zwqdUR2edrpgl5HOd1KUMpAvoiZ7 Iog0It/Zsm71K2QeKmBBd+LQHsG7SPvs+bkNG+SKnX+lak7KIhGS+LOn9d/JoQnimSQsz+MmiUz6 pQ/oChmVuw4TMnzq/KU2HA1L6FxIc6KHLIH66TkOuxe5WQcXQFpUA7v9i+2mbuYq7E9X1Yz8B+df MXzTJD7PNR0wkFs2wR70fQDuMYDa9D047DmYZYAio4PclcJxkclcWo2lIgyphvnfCj24QJqtZRAd DKQXYYxhar0fWAxnX9Eh7UAcHZGRbYADkohKfKzcjzaadTL0wW1XLxhIjabcrBkNtkcEyMxiTHkQ 6h5J2/FrEFsEaRn+VALTN5NobeVQ18CjMtaHKg0R9bkjCtxA0cKrK6+TYbj+zSmhVsURlRRBXDUo ZGWm6hxpIRUA3sFeFZK5mwgx1L2Wki5ztZwGLuVYVWlcjenJeIku4TzQgsta14dLOPKG87YLR6C0 4fRmE1B4wU6yOIgPyPLYICw5h0zYj70SJg9QskZ7vzQjACTt/D8SScuRqkV2sS2IvamHRGSb8lfZ ID3zXFgVatYprXhnUBIjFUz1O8yL3xw4olKJPa7ep4iBODc4Ht88vkqRLru6tOoutegoPLoQjRi5 AwU51eIgujgnw86PHtY/Vs6u6aesMGSP2iQ9tY4LYzm91CJfxMjCKHy7/bgKlQA8yQMa/rlH76mo HbfSmG5VeW9q5ujdJkxTKWLLFtmMdnbT9me1rsl/HF8TDWM9hJUmsaHaGjHVIiebPcipNPEl1sl/ MKEjnioVzwnnt3JBSz+9i3Ea24Rr8ochBWWuIkQvkD+hh0mMVLC/9qrq9aHJf4AHukMORd8b4Igf JIY8FMROCmkaJSIvZCOuH/mZaAS5bH7su1MsdWk8wdKNPxV+1pwunu3Kgp7zWfpjNOZn5jWa9OBZ +7eM1HL2InRObu93mjetsdfb1plc5TY+ADuxi0/bL/0f9aRzgvACmL6Za5hcISthe5Az+AZtctYP cpued0msPVgLa8+qJZHkd/mEp652eyeDqZWuoN0spAkr+sse+r2N6QPY+lo4EMjXrfIGBp/29rAh SumRMkuXhwEpmqZpnR/rFfStJ8r3s5RdW6MWDx2Gu2KiOTUy7w3nV6Q9TIyjrbIC6pYVniwuKkfm Vc7ns+nj5dHo2KAMkFVhPPrnlz/Vrko36+1XF5ABnKLljiRzUeMw1TPGZHE+y1gpRb/Jzh90hK2/ ugqImuOVVnxXkSs7kKsjv0Yi83owUGfpw9shx/ECUf6ThlbLVG4OhjEJoLmSf8jJN7f4kpjP8Msa 5npwJlxAhtwok1LguPWskFm78mmqG+Ut17/nyIM5xtgByISpFhcqqtBJPuYyfVYNEw2Toe/TIcXv 2a2bNUqZKsaTJ7xVi+8N3HgEcLzGE6dSAEBWCE0OQjkE3StyGHbX1kfpz2C5G0bnOh3OxtnFaRqh +HMRCv+3PlytbdOLtH6pz76xznKddR6RN9tmWY57VWecDcOxrYyxye0PzjFmtLzOtlm3on4ilWfF IJruQX8wBh1yY7yhtorzaVFs1XPlOMPr8jU9CXQ8Zlwth2f55wZmMcbSOhkOugqlvWCf5HJHtf4C qr3ZDPL+lmZ5iwxBBWE1Bhdu/+FrdGYFu4NVL27yjw+Mct5ALLF5EbDZiu9/2gXUiqZxQBlep0es Rolik+qlRHE1/ADanq/Py92zjgs/nE2nECRntEQ3+2YGtYiQQKaKPjhMwNpqL/moPzpobS3LhzN1 sIcDMxbZwlQRKeYswmIa8d9c224m+3N5omGTPdT4WxhqgsmixJrmG9KZE1uh2QXHxPO5bX71JmMV PEibmzO1bLyXStn+10fff0+SyhSVEhA8OOjobqmbFAQGO0gwPLu/HCoXopvQe7pabO+KxWU7YXr3 +jFOFWTLEeR3NgJLC+XYBYAGJP3b+L9/I9phHY+f+O/UF3xSPdvYpaYmVXbzqukZzz75jBagVCDg +xGK7VkFB4R8xWTleIqSYiVY1GgS9pcYm6nl51It7Bqs/YDOmq3lQU4pq0Ghqzz0w5fx8JUiNZmf kDslGfE6sXkk0hYdsnpv1foNoNIEntrfVGoHvdIJxcWbsmjwvKr8zn1BriRbNHoMXdVPOQJTB2Hn zbT1IRcngyAnUE5r5DVxbUJyCrLAUGoizeZzWJuVdltBytfwE0FH5v8hruH2VHLOsCzO3yPS59L/ EPetyp7/WI+0nq9lvhJSomiKPB+sGK4LONNo664RSpjBdkJNvhdRVTP/P/1xPoxX6gREv5gTkkve JzoIXFKoNJAK3vH9FCWcCeDg2myKz5PTuoOrEDbsWMfBE+bWnjGfE1BxC6E0NuMPootWnGMI8ctz v2zO8hQwoAI1nVkeqjQrKJaSCjXNxsFuaEbHzBfBDoKGpR8D/HUgA5UcNNbCnHOndDGpJJeCr6FG wBwJmJJFKmQzIwzucZjWw8iWxe2mbzsPmIgotTPz+ppTCMGa248DO6h4pqlwlwf4TPOkIrTbFY2L iNnzZ2RO1+znwJ76Y6chSLgHx861G1w60CoimbwjMfnMR3w4qVJ3xpfdIvIjmCnSkQomQp05Ip7t fiWvns3tlqH5/y2UwklvAvLfocva2l4LgjyuFwyWIv3sfstogzxryJ+iFiW0LcWlkw0AKsEknHCt 0IfdMsk5swaxqB/Xqos8PN2owbooMd8guYbW5mBDUYJlG17Fadc6x7X4gx6qhEUGrWdHSiuTp/d/ KYuhmZ9eH72hQg3n2kL1N4Ssz/D8kyFMGMrdb1qIrvKL8uToMkFPpy4WApo+oyLapenTLk+FCzC6 vv3wAiP+L/+OgXle/YvX85ik3xD4Ou8gQvSuFHA1r+fAacaCEs0AfZlxXds0M1Rm36Ba277cI8aZ oqtBAHxNCVA1np1lhlFoZRqRqXnJqqbhP3SMPuV4ObGncT/VmziWU53bNNsC4e8SVyXIKmURvB6d 1bCbtkxxgzGWVu6K1lzwMSmxekbwTUQ529IyII6+zSsfb4UgcCC5qeFuoN3HNWcj6FUiuW3jGwYK 8/0SEfYGLN/c564O6n2fgC3KZ4TVjns8/al3uOWjmXOYMujx2sKr1DpGmOX2yyxpMN0Q/JuKd9Ba szx7oRpsOFwFiIgw1CSci2tmNra2VCF7WixuOyMsAgtt3XOyKV4gLHXBGGLPWJXubOzhU8Q+vw/G UHdXihlTnHg4v1voUc860Y/eVk+tmKftz5Td2b1VgTiGRieGtzGivpoDvOGNrCxuzMR/OgL+HmXz lEYENa9LyutdaNwQLzXV4fsYPrUkjsEVqje8SILT8EgAVM36Qc6ZsU8XBW4CeufFQ5yhdgvNxBjU HJwXI6ntauJX6XviQo9JriBsY5LoCnpEo/yDwG1aXl4Bx3IiUESq9e3c2N9D5JCxJ2cWQquvJUWJ kW4awCBxGYHXm0g1UYEY5/ArIDL/W2aCuN4r+6njrf/TYR+OOMmZpDCyE4bv7RCc4FzO/8nrE37d uqYlNUtg63O+D0E8sY3s8V41DYPkIeWSabcwngrcP+mBQCheINrPgV8mBbfa34XvqoSyV25vaYUt h2by414RmH3jRPFLYJPdyObklpAIA3sZ/GIQmYwC8+DWLrxev66tTHpHCPAGdNNpBRK/fCrCCeoi Ay5N4/kLQOCp9cJDiPzFxF/Q6NUKzf1LJalX178gK8kPZEceMwAWsoEC0xJ2jg5wTNQHMKydFesy NzHZw0DmUVXsx7lDsgLNRFbpzNTU715kP0d2/R29/iWnKm548O1Mc88vxjrMyBa+cKTCZX9OK4t0 NhSgDyjPYTkBaKOkykRaPg087u5mWxUvw8sFEY8WvtUWgnR3E/DV5P/zthlpLloojWrD8ImapJKA kwoWQAN9JzXE2X3LnuPEXzJYWUzpSYe2j4PU38tlSFtHbAMln1z4jib86pN1q2SJGDnMnTCJzUuO jojDpnCTuYxrCqTFwKQXiQjTbVaFS2yx/wTbBFVXopORSufqBfMLkMbpihBP81ENe0W2MQETL400 8WBDIeTvr3usDZAlmfwU1smHB2fjhsGvKbuh2XNJURyEadcMjGBDbLFPanpZHOZiyhAXc791zLNy eqGCzOUX/0uCsCIAn8TAEWe5nfBtwfXBqpllPsfUFQ76rt/nSnnt1v12qMw5YH21GjbEpS+npo/o rx76iaT8K2lxwEY1BDkrAJ6MQrCrdctZvVR+dZeRUyc3kIMVe9zrjzWDI1hEtv7TUSyTwBRBp9QC O3L/xAOGunC+A1hN3ATNo5UL+tbJcI8XDuzhmg2UG/yye3Fb9z8JJCy6g8LrMj5f++p5FP6aezgz 6bHc45vIzV3Fef2l8VRkS2Vz/EYhxzrvvb5M5+VRJblmXJp3VAUNhX5jlNEBcTkYm00XDuoZ7RbM rZVUK6tCkJPkuxnEXZ66lJB5YoIt2Due8QYrM3tTdEC2qnlNhhOvAXbOIIMHqoSSfOCDWM3db4S6 IIXkWdnZfSIRKQbKXZAyraJzTUqPekpu7cZwDGDD71Z3YyR2uNPnayjAv/L1rpYPYF6P0aWeoIe5 VQh61ZGpdXRHwEC37m/xIJfrDebJRRlNRMM+CK2i8XTBzoPnmkyEMhgAX183YAod7juhOwqABk7q iLQE7eIZigigkrNu+wtSEFAThLi9slZdXy49s4PFFDkcc1EoDnVk3AlzaFfrT1yWoeYm0bVyjIM3 WSvQMkLSlc63u9GUbNO/6LsxVeTPFk9a4iCiVNvIoo4wU0/cny7sRTNhkk6bTwYMT719q0h0m3bR mJVRbr2oAx4kyXEGPgqWPOP0tmn0FQHT1zTsJzBn5G9V0LNxWL5J2fxZ3YHbFzAoxlEliRh04ZUf eJjqvVsS8lLGyYlRfT+6dVegpCrGF9y7Jo0piHZhOKMsEqZ7ZyOMfG5hYJ1bdY0hjIOUaZsIR98r FWYetYe/xXrRbkAUmjVrLNamDRu/19iQEA2c1e4QXCuZWCtg52IvP/HX10FfoWMpgJh4QXvC2YBE dRn4mEAwSQkQO/QrlGYOd9TxGIjRLiNG5IJOl8GJibGXZ3G4jZgOMSim0efqQrx0YiMRdFO19NuC A0ELbC2wGbq327SE2F5aQfwOX5i7WHznRAgAwFSmOjPnrB3Wqr9eCYcdRIOcdGi+yYK5gKkUotxc gE+e9o86gcrErgR1c6bO4cAh8j1++vYopj4hjKkBSBUrYlOxYAW17scpo7afV/j/0haPPEGpjG7G qgdERDngYiCblGI6K33QzrEWsTFuENcqcoVmQtGqMQEzGNVe6WrQrfn0aY4WgMz0OlKWEOu+wkAC ax42YhMP3q469SPcF6s896SeRiD9T8LqVWBonxwT1D74FFSW6XdjQV/tHnqwHm1cftZOUjeTT/r5 JEe9+RH4yffJy5DMmUvxPx+4ZtaDikDTtvqnUdvDF5+l1s9KCI6SagJsn932SJfhaZ7GU5Zch/VS 8/G4/w+HtgGtF5s91dlXazUcFpkz84HvZbABZ27QIICwXZ7UodIiAOms9ck/se4bKcdPXbifqf7X uaiTtanaBVJQHIVYE8xU4PG+V3PYQbOJm9buK7K61vfg0stAddUIIMlVC3fcUwtFjRv8mA8U0bLA 0hpSkojXmFTG+mZRiuv4Szqpb/I1Pv6liK9RrHTxe0xScEzVx2AtQp4HQzH8/XPqmuUwm3jjvn4q bw9MclopyZpJe3XPupX7fIU5r4WuJ9VMAPb7FIPlzir0YyLwaYks7+xqA514TSdnoDVnWt6KnsZF 4cmDExW6Ec78LVFlPPdJpuGNz5AuMt1LuQSMWihH4focKGq1Shz1s3ZAgWlpiDHSFHwWnHTS0dGj 9GtDK23QVevi+gogOiWF5rYgvcPkDk96HotVBw24BOWH7gPs+9siNy/XXAm01LIVhA0uDkWFGYBz ETZv2DxsHqCMaNP9lUP0ueUlIi3t0FOb7NpPCVxGuT8XWHALQuEBSb+CJG29cCfSai3alAP43hLF t2qzcNEZDwJs3lChaUrGdH3/TF+Cky9ujsqX3omv5NC1/H0xAm86C2T1iKACRjqVpE49W16odrT5 N1J3MqJcLPU6hMKA+rHPlnIPKlb9e5BblH6uXr6E3z5ISxjicJsCgaElzH+2EMepF5BNPtz4y0dd 420f/fwu56MSZRg68YnpRYJCqzF529JOl4+TBmQS3h+V8jw7ofZxETbL0Y0FVrBKDR5UjGNU9SuE DRNRPAx5M6yJXYiG1Mc/hGlhxUeJ+XfyY4jUFYt/lGc/n4/dU0+J4JxpVDOIlgfQAFDcGVWuLa6w /TfOQPdylfauZBEbzjenA1WtuMJW5+2Xta+OdfFRfzWbJCEAORsQhZqrE6wm0RnzdIVQ+1vIfTsg zgTJzCA9pAXzR6dhz2NHRuP8hX4XNq2t69vhFxTelPRzMmtiPdEaiVG2TkiEBR8cQMvg1dYlCaek DrWNUngKOcIGuNsuAy7s0x/M5XfUb7D6E8cvTISzOlDLynkKfqlPsVFygZsea04SujuWmQf/y3W7 whgob4r/imYZyzsmVWIc7KRhTsKgx6NsV0UyYgbnECVGs6ZEcbaDWNUzJP71NXYwcdK5wf0aHm5a 5FdfJdbL0y/GWxJW/sk3cV+XEfp4yVVxTQEce8FfBKOUHJJl1/u1nEFV02HjVTOtGVbB3335N7bo Jk67jBqknk2WKFhGsLdfsXD7kFLZrwiBmr3vtUj2k1abe8sQTMoqJboieGtnEKlSkGI+xfFOnKHt PKHzcVBC36ZofXOAWCecAqOBlj7qPLtv475iyKqRG3mbewpLfm/xVzEhAvsX2A0z7qc7ArtfmoVK e8qG7v7Bmog6k3OaE9sxnCLYGO5sLHYP6KnPW/mFYP2JtTGRc9DZDkueke2iXpb8njJlZAm/1Bkj LgrZlrciORbxMqIXYLnMz3l6D8gnwtQz9Zfc7MoeD6ulR5X3ZpSnRclBS35psK81/MqcO4Cf5kVX vTxqfEvX+jKNOrEib+c/AFx3igAE4nAHfmyuEOS9cM2LdgVh8/e2oa0QWnxKKR1OpWxm79dAL6/l nHb7mSTkz3axANRbO31CY4ExloYfKzWhKsJveTFmtA/Xc7zP0mAcwjzHw2hyKmfHF/mv1sTiTyiD anq2EiEM18W7m9Tljqm2oF8AqGL4ROwBUkGir8h6gfzfY1r0oG07RFEPtDqc1U8Xm1yVpNbcezPy ou2oQQ2cF3XhxUtdWIq0uBqB/YVIoZrRdTiMSuigFmNGEYzNLHIG00fgThvW9Ns71eTsMWJjxvpu ftCYqCri4PPiJCVckC4JjLzZp03TiHZFagqMn7M4XnB/dDmQppjS5rMkNK7cpUpuPgmeGaCZtUNr Te11qxrcQN+sa16NkIEVfBjVSXoEkHwce2XZYxSNPhorqozvggmx4PgwdCy5mof2hIBstHmvCC3H 88mGU89RmNIf70eD1n5Nj4NLvTpaOLkKKihvrx3DbZ8GwMeHlcUEIVNbMtQMDhYYv3D1YF0J0rAq LlHrSj2HCyJJ0S5IBhRJ7QMXEUiAd730EMTHE+ak15oEjMjvtbbbZX2QOHv85JFNzjj28uWRVOL2 6iqqBmIP0YEGMl/PbZl1m2sfZJSO645/BnMuEsKipdpSfquhIN1ST5DHVH2vJTur7+9rodXx84ck pqQKSXE2knC8wAm/xI/Hm8PEbv8Y7QlEj+Or3aYZtMfq+kIdGyhjxCivU97ecuFT199s5BDQDUsb QlnbvezZHbn7PfpVxkg8izk9SKFFmu/nIkucmfBud2tMaALDJWMnw3Vga54kThLqFEA872xgxME2 p0UO8RkKlkmZDovNX1HgYOy4t9UY1DcZpXMxiiIBw7l+vJwuI9hwdchCXpn7+d9lN74nsZrzelYS Nruc55RNs+v7/XKWIJTn1ceWllUirlfr00c1M0lHHHZBelpdcCmAmSMUoksODA6jVvtdOsNOuw/l 3utYRYdtnyQJSrNWIie/OkU02mXxjs+T3ley3Ym+UKLO2H/e77w4jJs+4I+KvENRCN0ocJXgea2Q 2KVvtscHIECy87SICILQQY5N/LFfqDuhVLaw7CEoFCg9FuaoaMxzATiIwrK2QSdUG7/g4Z4dkuqZ +HacYiQcM43OqYh5g58GDXkBcA0uHSBAcP2BZRVLC4Dk6a5lie7qSUM8Dx+v66yv1HMtw36Nb5cR 2U1qexNQv/8DEbWDWiTSg8ABBPgRbAa3Lw8BLiRDJyRh6JeLO2y1NM023XC0AyRDFgg0W1+QwNSO B9yRL4oE0P0tmztkeofxR0mglDQQhaPekQzBxLuO7HAwe18TFnnUxmZqts0NERnXhxlHBARve7f9 fpZq1FAdUg6J1btAorSBnPeX9RGqOA7WrksnswwO7V21gHHbvWgJCuf54XEMOIKN2FEkRy2IzV4H nSfhK8sGOuF/AT67gqdttOjXClJYPJl4fEo0w0BpNUt1IT7CgxydOXKzv5TPHQtFexn98pQPXywu zSc6MQaumi19uSiFprqijNCcyvu+JAA1Ew9jvPr0zQ2HjmZ7m36z+aAmSyCqCLNhjhxIw7OHrTlV 3JJSHYrFaOcZb3QICwdkuttwedTk/FA4VtBSI+o4yFtS3ZnlhGe1CO4UvPxDIYDUJHLgZu45BoKb 9vkW31kGpwJGO4PSNUuhQrqlBJjWnXPV4pO6PbqKvOo7cb9XTBX6fHe76x36gcgZR2+eRKj2mvXr I8pehPoch+wADnl0HShk5Z0z8Pm9V/F5WJhrJAewR35CPZhTF08AxIn4VYijVWrwx/jJVor22rn2 X6c5qtYWlv8xJC2pIOgDBrg+7dchD8A5UICjlOWUCCTVXodt5PvNnpm7zFAP6wvq2exEaFj1g7+j LCX/9GKVRyRhTUnKxaCGyOON8RF6Qf1O8un7viqvZAmsDniggtNoktUsmfe9p22LmICTWf5tWlGg l2F4Ow5qg//2X/QWAwRrT7BvKLkhbGMiBSZx5VhCAV9ndLBSDncAPVBxFebdGR5JpEcWgRZ2g+g8 sLvGEeb22Fd0YEfIoDueG35qH7zIW1E2GReyqKV4VgEJdAaL1b6tKHzOkmsQlMXSY7ldX4QCI0m4 cRv8ocwNUv7UopdjIVAPlvgBzyqXlRL39LH/V3KHhs7Q5kidECz79ZEYvO7MW30f34+bTnRpYTs/ fTGLE1rBksraSDHt+EtEWfpyp5ta+Z7AdrCdcA/AZUQUQToj6pV734lNWEt8RQIGr4YSIMT9+TtY GZPOztDZ90shObrQGivLQwtTGswuZlp6ICL39IIQsi1UPw6kCc6TGxXBlw1DD/CvlgSbJUlyWLJ6 0Ynyxtg4cnAzsX5Kc5NURH750qfFrGOhX9GHplLTYcuYg27wPbAOchicWNjIvhil6TdPB4NP9xsu K8S3A+Ikdi/wgHAqQ+gLYdXmWXdDLhzJPcBscHzbQ4JKTWG6wYRpO9mlgRUhU13wzKqJevKP0NKm mAphc+exTQTq+OmoYzhY4IBMevfR2xOpqQ5ZcdNvy+XI9AmIftzJkqt24bePLYbsuJJ4TjD2OdKS s4pgTxBqX6t31HOrR27VS5lt/bu9YaoocSaiJ6tTbdtzJPCX9Xn9MKAARVZiXE9nEz2/ApTdeIKa Pmr9igVd8riYBTfmMgklCVxL+vjcBzpRRsDxO1ncKL2xFhmLnXLd0VIxtD6qxJCcJPurFIg0ZnzQ Mn8ikmCvoJUgVsZf55KFllYTKRTgzYI4OCBmBikW2X5Sg/ZXqInlVSUiTsSr6Q5FQhhW/SAgTCh5 mOnb5C57R+xpBAY0Z7vLmrdBblA0BnQqak9pV3bsnzO1BVG6J1Vvzdqpx04EYT5epwm7DoArzu4C OwUVSYQzBxRYi5LLo8c8B/9CK5Bd26eEtiL4z0v+77UuESXIcxTEkGIu7NZlXD7qhwSHPVsyaDH+ 4+eAdMhCSogmdDnTQuMvVw84G7kcadyeH29uOwGxf/t/pMdXlEfsl2+OXZDSt8+TeBt8XhFijQxt V7EizlFOWRBGUlgGmbLTRwUVtfUaP35o6atOXjkI4nfsDk3BetNHlBqnq88pWt121GWq68AOgo6m tizkBCOeidn40QhbeAwMPK3eI9QZ7a2icQSwbd+BQ6In8ZCUJ8FMb9rY3uyfn15wxMCnbsMHR0Z4 hrgaL/y5BW5pdlLMZn9rCTnXuakGvje0G777PjGe3P9fJcjB6Vx3pcT0Pz+daFabVdAFlHmTDSTG oVeaGWNIFt/Bi6lKwK8kktS4Iawy0pJssErLeyx8cx+5vqVfJyNn+uM3ZX1IjVgeWz01VIcYFUp8 J9v5TCzkCvLUJcJulBlYFq/pb0/mVCv9FZ1CTR/Rn0fWko7AfOGPEnQoByEnPABvzqtCwhAVuowp dlHmBOgI04Fvg1qQstzvp9/CaZQIf/AB5g1ogW1sCtGMd+lDmII7CoIjFPSWMPto1nhxXVkDMaEC dYxPSe5ZQch4jRIVOk3/RAKM2zhX4T6/cU3zYZ4eDFoG4VRNPazTByfmYvhN2uHanaoFE26R2xuf Fscq/L3pjH3INY6x7z4+NSXdTWN/28Pa1CQc2808t1FRnmUB8Xt5gPx4squQMnRX8M+xwxJnVnrw +IDar3iTQDis2UAbyih2IEEnjZEbdBqwnO72/TVas2wd1jaDPWtmV7yGubr1fCg0roECO8q+tEUs +Q7b3fS1KXZzieM2h4Syqpq7VvGil29HG6e+/bPIIIxCA1UBtV+GaOCHulK1iRgsUfqFLetAu7eu u09wZDBaGS1fshX0XKIYvnZt4h4QuvquEGeuM8BmLiaNX1Yd+lcepaM6MixMSyB3HyKBcqJWThBX S2C4f4sHPDTcjBzUUL/hNFNaG26yHfsSxoTsGJLakLaw3iiQfrh7z6KDZ6dTblvOir8z9i1lCAeo HwaqrkZaE63a6hY8vAnGqqFMc48nwGcOcrndqvN3SXDUtVgtHfH0KoIIx0ZcSgsbAUql7twkKhUq Nsc23C0TtoVKq2YwLjERwAS/QAdor0TVMOCwwfG9rgohXNsW1ZBVWMT9CAoHNL2iAdsj3DmbUtIy fq815RY73aCKxxu4HDgNqCicR5S57asf/0dE6yASdYVBZLQrvObtu2DDEshz+7IVyYZxLSinEnXk DhL3cF2t9yICh07Au5xg2kORGlGhf/HfxbDvtpqArQlYnSG7mIVHYwzxI9mll5i4hx8OMn8VP/+j uB5Mrdg6Ul//ShnaXTPef6Pi6HNS0hNwr5KRlLi/EDqxYUV9zf1lWIFqOfBEcNzkZTJcBSHjxsU/ IQvCB3znMGlsK19vKfAIP9SSO4gt9jth2DcHlXWBW0dMbI+0uA/vlNVuRwpboZDI32EMsebi9MYi Nb1Zb6w1zFpHNEEJj1r83SLvSNbwhnEFPvcD4l1d+O13fgGdIl6wyMV3XjPD3FGNySaZJyaLRcpr NikCuaaRvyIOiQcdi8idJpxuI06Ot5uT2EVGbwxY65htz5KYwdSwJyvwN3K82BZqLHm6l6qgfh4/ EIvSEFAWWTm5fYXV7yEJhrX5jHVBTg34huC/H6tnm01SD+yLRq2m5jpPx+Vs5u6QAjWFiJpe2sJR mYGVgEQ+AzVpkjq5DOVN/7fbrPLxr0zrJrMopKvtEv3HKuLP9nyZMPTWj1CiGG9L3mwJyyKfJR3Z +bcKfrU56B4WsCqUKmYs1XVT88atlaAOz+3pPQmmOiagetuJT2rzxtWT/IOodXSuilq2Qd9n7Uw5 B0I6Yb8nMexcmTo6CtPb7NhlT1ie1gCGo7rwAQCc7RrwlbooIFCV5OnFEGlOgfFoT47/GC1oqNlJ lh2i0azjim/6EkzrPry4y3RKlCRmqUGbCv+RpWa1sutLzUgM7Lm9QvFP6Io5hAD4vRsZhLdYMLP4 MyNv2ont8qeNjInRnzsroMlr2RZZ+XqtDAITSarfmdzr+Ej2PU3AQuHbM+1zl4SX4KeJnxtH+giJ c2rfetUs0qosKLik1f5riZ76ngzQ7t71btJDyr4xMfqVJy8cfT+8pf8btdow8QJe17ZyYWV90UVB emdXAobvJu48PQk8FdHGwf+hzJ89N/XG9bnnqII9K8UZXuGxV5dAJe3zAhkucUdTjeRDqirXHtsL jc48gBQf3DqtCYqoLauvHYhAq6vRBoFu6j9NhPgKt9+vOV9lvdSrR4OaukeRG7ljjP1pmY5fX5N8 kCCfACy2lVv/Myg2Wq7WVwM0r5nLozw4N5scJnGgL7JOikDdev8LOV/ieaHi9QLZ8RPa6erLREGf VFFXOQ/+M1xpLg+unSsapSZPwH0HYYy7kHgNCHKGEMcXbsHg1pZx2TQA5Bd7pe5a9gMwBzbbmyXZ Y22RCVyFRsgs92cXHDVNev6swoyUoReNdShMNbSRk/mEr5cBmW8L21uLWT5912alGgbD9I0fOLYX 3lBz/thbT78FTzVzoEgpQCUNHGQLPkJ5SOPx1eN/JPSQIqk3D2be/sMpcYVrdX8Z/T6iebsD086Q XU1vAGpQE/Ev05PMY0IKFgmu1BxJnwzA1pNk7n59ABr4DAk5ecW8FHsXmpxiEIeKYNJBxdR39NF7 rViBXJIK+0QjwO7TDBZxCTHvjzVhA7DEXks5wFoGIu06L7yRE6g7HaGWGwcBvNahheI76W7vOBwl v3jN8P3y0XfKdG7saA5cHg2gM5WOWmccxPifkPJcbWR6Gr+b8YpkWLxOH3K8rVpOyFtivcEFDCZw GFhymmx1bFeJ4dk8efg1YhSeap7kiZeXTwskOEbHVAMwW0qol5nwBjpmqZ8rEl0nR3mdVEc07rdv /VR7l/ihie0mVdATtqRpN61fXLildkh2OMRijzMd2EQutJxWZLqxPeBd5ke3uhfVag7M6F6uPwm4 SByDEiXi2JtHY6ZycYuWtgxLDQvKSyIcTCONNmOYNs1dhdwM4n8f+qLOxLBQveM0jtRiiQoo2p+g jjWLJyfrTozGD7kNYdp/0TxR/rvWPaoihAtylEc5HxAtLqoIXVP2XNdyIvuyKX/6cl7fZThONakp 62/oHCQ52s8t5DVP4fNuWX/XwYmqq5z97YmdUDdqL5fZor39KwTN5SZZOdQIpJg1pFgbWaIXV0xq MIfBr4LrKxqjITcFqNaguwueAakoOteKTD7F6pvJ8UVVDCdPPBRWjNvVXBfA8bromX8i5w7bQz/6 K1IuAzM9YREqdL6Q/yNkz0bRERI5qxkGKJ/fbvdL/mmfyfmOeqcwT1amHA2APV0wtFuz48dmdxVZ DlWJKT5FuIlQ+7vefcpqbwchZ7xg1DuvE/tLKzz/zMV4LNFHa+W1t9jDHwNuXeY26uEEM3HeQ0jf RiD06WTVPCnMCMLyCAY4d4CRF1T90iXEWAvIJwOi3MPa+Toq4zX56Vok138uYd+YAtcl5/hU5Sau tp2xbAnHLWJWkBiiK9VgSeBidsspvhfhKa46HsJv/KemaX09I5BTbFg5v7acs2pJF6DPQdUGx+5m VacY3fkYcFgEvnu7H4tAkvU9/iC2Nf0PhPw3iWqmbUsOzYOrhSg8PVqXhtZSAZO1GuiZg9pGn/U6 qRTA5SGTKpChT8KWb+vRrSRMGi6JG0T0ZKEcdTBulEGCtfes89We5qOF3dBcF+SSy0hiRPgh7nAd +kUUeBejehem5+sICeb4fFRGOLnfK28j+YwXMsG5D7lOKvPXaQ/F0kaTThCEWcN2nA8msh/+0feF rjue8XNXmrcUBoJPmF/z7+zWeiL6TISD/AaLqyV3Uj/2eqPAlBGYrocBykcn0BxXjGhYcSVs7F9B FOCx7VZXnucHB+3YeEB13rEdXywaFMlLfIHvtnj+r+YmVaCicHu/jkkMm4Cvk9tW2adS65htskBy ISkm+K7x4v9OZVchxS9uANKTj51mYwB9WIrvgFoZeWIpsxMnjVXeQP9hPdGPfvu2VHDuDaWppBee cwNmIDEr76NLz1ixWvYWI2wG4xO4nPvgDcWtEhyDcKkUnM63zOSMXEyIuEN66yLHYiKxxupg4ch9 xEh+YDuy56kV36QM6QtcH12ejzAYcms6S6BptHBAusSyv2TZgTOlMzifjVepeLxAjtFQTfQXBBtm WXcUZPYGSvW+0PkPsWAjhp64/FzmyQVl1U8nK6t4u3hn7PkVzu7L+ndjZDfTpoYFMNow1P0bWTcC YjF1HHwoLx8A45QurUoKgiL53bGN8hwdy2kNImDIDdW+6s15dBqVNUucFD1RYhybA5pMUEh64X5M dX4nQ1J1Rq/vVwRgQCoaXXg4r2+7HFegSSRslnnfKEGk7fIDTf5ItM62lcpKRvVfY9TqWnzM0PNR nZPy7ELZx1qZic8qRbSt3aOLMDSmqqDxOodgfFjq33aTvRlvgeqob2BTx+FXuI8ALBrj8p2k0Uzp mEp3QHFIMxt3oqw+hmW2UrrDfTdPdeunPgD7Igr2VkqmIK7i6+bFkkdTwt9Lyln2sBvkMehYsmBc BBjVAN4ib5Vl6izBME1hN52VYpVK1eSCMhtRNughYPz38lzLfnXLQZcw+RwL8F39UEO/4E39b2Dv Ys9cHh8Z2U920TshRAHWAzNa6MAZXoWcWSTsqArMtsuIovngrW2cWIOO45EOS4lzQUPT/csqpgDl 6YJO8goHDG/IxkVO5PQ6LOGt0C4EpYTuHtxJ6KPHvSWbQr1X7O9quMvM3Xna9Pf3FLxsnWWMDO1B o/mOzHDbsIV4oNbJjUxZXaq7DaX9tGcKPUrP+HVThH6wfkcFAsgNRScwFFlQB+DmEt8mUYh6d414 0uwk8OHQ8iUKm7140QbcRYNcVxFuR9NNC9VF+45eBU5eYaOJiLQClN+KBMsLpr2cAMkFdjV8KSob rNkx+qfqz0cLwAM54Z1Y/bwIzhqiNA+FI8VT0GiTfWUHXx1A6FUEGEwp6A/gYIYGiTEv+m69JoMw +OZ5cUjRDXkkdWJ5kpNgE1drwEUSo8EC6VALDgDSA4IGgPbZfhjHukUxmZWEjwZgngmKCDzHUAt5 tS8mSQ73v4gmzWCgOMwyzmSBbK8vkEYDq1fZY5c/5cgLiMOwLOuVFaYI5rMEZmC1R52jmFQrsDmz qEBQgi5mzis6j0UGGpQxarLzEjF0Um+xycSQ+/ehXU/R/0/i3onWxv4BvByPiD+oIAN+5Wt+ez+W jyL1+2otgp/wMCC+U07wvAsUBUnbPPwYYr6Up3Z4e17s4SMM7TMPdMi994GTbhqRiHUyyFFuF9wq LwnoGnCqhtJS+59CrEhkqId6k+VcaXbwUcgRdtp2C/Pk5So9hs25IvrJ77/YmSygJpp+eSRF9gbI Gpxk1Ik5GYtxBnwAmD5y3vI+lUMfqy0D01gvJoDFqeKI1kcdNYcmanmcJYM1J+e5uYjwGaw3fT2g D2s0bWz7TNecCiZVuyueiso6f12ljCv9X1mirpbjq/WpwCgg2FQO5fYwuRe56WLfRKxNEfSKYXAQ 0S/TkpUUJL3AUOwRfzdiUC0BqgJX21owyJKVzyiAuB+tbW3/ev+I0vteKriFRhFh5HEqB7VCmxY1 O38XsvA/8aM7bitJTnU4dK6McpVYzCIF0mwA1EaQmGBBiobpllgPO6mUi/LMo4jlokgU4HqVbzYF Yi93duP7UkLcmP0D4hSBVr/rXBo9Zalz4rfBr0bzmbvCvN+zce3u/ReVhmKMnc0Ih+hFgnXoHRut RKcm2E5EjGSg0UqEatDjoqYyjv7nF/QDqpY4fqF8O65KysIemtJHSjfQIYgFB7yu/nXAPJ9BqyS+ 57x9aoBPCcnJ6QaPRQ74FkBgeNo1ly9h9zBG0+Pl7S5+x0smIhcGbOpTvMNfxfNu/6F4uiTyTuWr cxhkve0e0pjX4Vtob6nNZ2pDOsPf5PdyAnue57lG/mrjSHoMIxyOg57JGSj4QZKozrehlMSeSBH9 qb03HgOrU8FIyDlm8yfgKV47169eBbb4SXEuDChkV35sIf7Ig/sPqSt8rfKKXEJUOZnPAh3sY45S vdbf3TtdwJk5UVJMwSMyW353pDF+FPmO4bm5pIggITZlBhI8Be0dFlCq3/kIdshJwg0uJJ2MKrKs FZUZzSk5cdOjx6A4GFi4z8TwpS1RE67Nw/rdgm4/g312igQBke0aOusduIXB3L5GF0FsbUjwtS6k a15SWeiz7HJqIRSWNgcLoeQTsh1hqvtkvnZGrpzcWU34GMVsf/dG2mBa3xR5VmX9F31YH/wsdDFR Uid+eEuFFFZNcpi9ir0QG/iNZt6Vkmtdbt0X/Q8xSxqjMHJm7btGEud3hRmbh33NOBJ+bFhpcixk Btxg7waykeqcpM5mvVdSe4wuQmGSWfzLTE71mAhpvpFUBZl1GJ1MpgiBVZH1pfMsBR/IQUNbngj9 IFN/+yvI2bZ42cHjm4kNU+dIAVH4nppQlGzorc+XLUKMyDCuEyeObGiO/UK/IdstIjPcjiasJAW1 YxOoY0fhQwm6txgDGZ1KdubSMG2eRgaZ+6QoOmem3PLaLAyS0lcvj3zwRQqr0LuCoDII7L4LHlxD gqRK0hFEuMPCckwfFfG1ciBT+9u5UOAzRky6IgMQ8yLgqkF9PrlN/xsRTjJYhebYfbql8uDP+9dk vblOAPArP0fDeS1/yR1bhkUwy3bqEBK9wyhxWyQL9hSwE+b1f/b9rkNQz+jrZOudkdnaja+XSUmK hUWRmcSUb8BMZaYCuSIGRAiYg/uW/Iwxn0KXDIdXddsF8UOGBVc9xUiA2qyBHw/NQXaJClOvKW6X DtRkapL1YS1O4YVUjECFks5rnNB7Nvas9S/m8CCWjrbDMxiTPF4Y07uQ5ecLda+120Tu3P+cQTRk FUDbY3f+KRlmZ1jxH6bmHDYFPtHNTvFM193r6urVgpFGu3ZCh6to7LD6QcE1eyIaYEaXhhVWVYnq AEwv92w7P7NZZKliAiMv4I/dQzmW8l/tVI2dhYYbmR1H/W/zLYvYOgTZRruNk1LI7qfty8OVBxjp cEqSVIVXbYScDLiUw62hIrrk4bik4H17EaGadh02qyrhC4GVL4hf0N7gB5WI7tbuBycxb6IT6Lcu yyWNV77wd4tWlL4Ww0t+nR4OJeLa4sMy1IjzXUv/f2TvINKc+DCXK29nS1pvlq2Vwf1x4JSEjebu pLcpXtAvdz+lTlPAB7+KtmHDDoSJOy0epaioFthxX+6Vjs5VyB+VGqzmJl9NOJ+/qawfI/eXWQA+ eAqpDxhjLgzu1riXgdoEsLEaxPrzaSqj0PlXO0xPx32d2Ut51ToxBege00+YfV2P/yq/RwLv+L9a qfPfL7QHPR5nFkMMoZdiNk6lrQSF4aTPT6l4pPqU4l+8WCWtDh6YsrQPYjYUVHYYGhMdG7nPV/F9 n+WkcOUdq/eLcW1Vw259IvyCYmESiBBkMRXNE9hzSlNh1eGx5cdKpYJtAxR29Wgd12Lzvl87ulPc VuCExcBjTNsj47QugAMBvpqiupdRsGGnNO/SFrbcxo4ef5LxvEw6gHE1qfGpO31x4Nmmky7PEwXF zt0UOhBtlEOdf01mEOGEonAEwUnjVKSbDV1psf4FqyKVkSq6KloJyfVjxuMhY03IKgKDfX3NvYuk zt7d2FzddbAplKTAUZWb1wMLw3rjjDq7DOE9RoOoeXIRLzGMEbMAUP/Qs1rg5p05qDBzL4A+lMLH x7vP4DrlUHx9TEnMtEX5f6fKbDYU9ExAb0Oj0U6yqt0lhalGxydu+VaZ+ZAH4joovXwN4xfvCq5C aGD3hRjs94AUkzI/vPb2Ykq7nf1SM6RPqFo7Z53PoKkCdrxzHQJMLiU8pomHfWfFeiP/mZySCUFI EU0OTwFgAH9ym50AjGQHgFVkli0n7Nd81zq06tQawZ2ul/sApriE9ScKgMWQyH0wdb9nuBkDBEk4 zfy/K5mGjx2kRJNqboo39VEeCMwvAdUwDiSQmcsghM/HmyLhHbZchf30sBLoKvuzSkzlYBD9wUH6 C96gDc28gRVSMDBfl02jncBw6exlStE37JiK49zroQ070i81lRBDRS3t8X+BZ73ox3e9HRgbdWnO UsspInbuhcdDa7cCRguVpl6NynPEnZrJm74iXCBVYfcpwV6k3jgcA+cTwVL1+oDrwsKNxrvvtWtJ okt/X193/UiT8B7AnCrsKnW6cNvyQz/KGY/OaMwD/9a/NmvfqUikNptKyR7Yvv3yXfpNCOkSK+7T vzBpai9nP/4DOoNHw1+kwXYIJKTaYntmRF3dNASgWn0oMILE+U0zsz654uRSkc8YCmvom2CKTTAK J1h6PcvCxjSbrWz5Dl1SNZmo/AoXH3XPUplqBbDbCMCcK+pG5bZXW7IdH8ztvdPaRSURzPazDO23 h9zSj5So/ClZ2Qhsfk+RrU50ETWybHiHXqhSZesbygYADzVTrPiH1YwDxCEAuuZbtF+Zkb9FQUsD JUDx9qg+2UmPCT7raO8foCy1gxjwMvEPkJYFGypq0NjNy8RWgPrl6CjvSY73TZ+VTYsC1E5eu6I6 MHx3sqjAK5QdH0tx1A0avdiqyUDVh+GdKA6cXKjEztyXfecrh3cXlBFb1RtDsQXXaoA0LWl/3Q80 TJK+gGI1M4V171Evebii5Qej1eOgewHQLz4zFvdfzqjCGOY+qjL1L2YSDrI8qHrc2MSVy9uXDs4b SHVitk2LvCjIOlMLuKBnBYIVkFQH6xrq++XNrkqS4ZsuDuWZ4TDD+HVB/uZsTrYTAVv23NuSBE9M wuTKRQEP1r9c3RTdA1GbfFpBhEDHez/haFzD4Tkd7MRE1n7popBWSBsvqujfr72hKdQUddKVw75T n3JynGIVEsstZ8VA/lfgtW+Ott96DKwqd+PObzCJ3GenPgsnpLD9cNvwnrsst3K7upM0P29YX3ha 4F1zLqkgcUVODQcHlhyrrKUxEekrJ6cJMF0H91uWsIDsA3T6eKd4wZbWwJlTQIjKT1UHyZ7gVnI9 nLQ3PnOhNY3OmPJGGXAIa6OgWlKge1RneYQfv+aBCIjURJKLb11gyVKrovGMCb7uuVNvF376ecqu amcF6GSPXojfUrIeRe5NA1d3PTGmmrUu0TMSX6VO+MgMjL8Ro+8m6a/aiJytH6gqpS+GVXv3l7Kn BSs1m3vxMCyUTIIz3a6jIbSrJ8muO8g0lt6nG36JEfDr0o0bSWOHmUAcum5OXP8JjzWBn7gwOlda hXcEVaHLpG0DcSmWKVs/ZsMytfcOJmCXaiu+AL/1QFVgRyjmCWAaz9UTAS4etG0K8AzwC4xxp9T1 dk9//7OE5GBok4+fz+33Vpv3tbrfs3mBlJCufA/hGI4Pu0ZUFi1kXQqlsgghBecgeYfbHNzz5O/C C7sJ6U/Jp5h0+OyEaAW2qEwZwkQmtfLEeQF086ZehpjJtw+KtxJQyE2ZgstiFILBsi/iWeCh9Z1z 9CmJxkl3ep+3KmFMuZaxYexps7iHPdVt4+oyZp/RN4G8AfLxh0M2aU3jEtQf89/piWaE4jtyo5oz bhGJiXD5sbEp2iALCg68g7N8rKUNG9xiHYro77z615fcJ9JaMFDmBsxdh18Yd+e/vJuuTAMWg7Df lPtT8MQWvJMZMsn+8R+tSuT6u4NgdkXMyx2lBEen4trahhiTIppUXEQ+wi5te2odnLBz5mVSlfSH 40xRIqO735zCSQlDy7pmaSOJIJ2qDbW2ME5ZeT17cgy2Rx0tRbEAeaMRo4j0E5dKXlsx8ldnaiCv TsTPqx9nEnOybn4Jbru5ZHJVyNA3eCZwzftTyEli7FCyDJBT7S/t9JX+Llp6ejJ4XP7qgjt9JXW1 HqSyowSwM58WpyDg2uPD4zWL7PnTlSM6qOPYFJy/IlMw3TpgEfnCJbcPkwrhN/KJDZBk5nweK7LN DiBlk9pj5uZe980fa3uKptobAI6myFiDoL/hu4CPKzpwjcfiZenSrbyg8SVvVPptn4WiREP5hTPh zvu61zgHYTaTW6rAuidi7W5OWVkvQgaa3rNm9vZMD/hiavuCS1yN2jz1f23wLtLLL5QCpOkgTU5d OKbKBoVNIP/HQ8SiSFG1msQtBuxdw5JeWrIvZ8bwpueFRHkTn3hmZKkUFsOFkk/ib3pI62LbvwFu +wh2+aV2Bn09VzhevB3YIMfl7PztgeumLbLWjURwGWDTtf4noRuvAnb5VvmCddEyDAK3u/VDYYjt 7Q3HjUBu7KB9Yu6IbeOV3+9rkBRVKL7jHE6mBnjM7qnwYGZ8O8/IP5izBUZPjZYl5ePAbQE2xETI XyuJ/8yM/PHWyM+RvpsJlwsmP/+0/GTeSvgKWnBaBNgph4lalGp5g5Qk0zxtXIhqZXhNB4T9JC1w 6yozORtH6cf6o6wN6bLc0GtRMOySoLOOlN5Vs2LdC3riu1bljzJOo+u9PnGmS0wgRuNWuY7mgawA IO8cZpl0eWcLr+RUWYXVW6gUHNfjYYUP6rnbNXhCnBoKmPcIHevwAk6J+JGMKvLHUtR2l8eEF/uW 7zUF9UnUsIdtr36QS9MnXVm8eJtX+OR70/+iaF9uHyG6uwoDjiKuYIIkB0fV7JdQmmaaU5TREUs9 ZqIaqb9nPs2mFaSnvdcetF01SLDrpgGcb7wRqVQod0wp9BSyoHljZgiJNhqHpPYWO4DR/Bw3IX7v D6KLGvX3n0ak2CauTi+IgITP9PrL6l8bpviDD/FscC5gNQxJS5T/eXb7J5PWaAT7PCZeiw6lVJTt Pgel+FhJFzmYmYaEavkmuZAq8dgT7z4rAtZlfqgT/GtFpiT1WJurOJfZaX/lrniq0ljS1aiNDVlc PoKtcA257pFwsn2tXyFcYjp79qZC5P+PEFoA6ZwZqYUv2SH+KFMf5veA9l6CQvdB6ZANJmbe2yKJ Z06ZUcVO6c/0X1Bx6nPTWLlqPJb0HBuk4ekrDrhGxzPPXc76GehBlKniKkDX+NdztNQ1EQgbS742 MO2ifLlhZNKL0PTbjZ7+yxb5/PqG8ZhQaq5oIzXFmL4oJDvNOnun9pAFpmu+9ziroUlecXaHHwP0 xLohRLbX7Inpjl/ce0o4k2GZpkVbb/2XINsJboCy5QTXtOcCg0UWWeK0bWJAR29sBeHJAZ7cGjpm AglOi0VRWteeZsklq4kwcLvvLGeq+ljy5WiKnIv228Cy8t1dkqAoizF2tBHOy6pxhPoM82Kes3Yl K8lVog5IMEO1NiNMeTbwsQaRsOHkJExt48hkRbDaISrplTlzjviIO2EJAx7yD+oLYcUKXbRwMs0Z Uf3exNJvF6kUdftFBw2JXti3jqlR6ZODhE5iPTgbJ6yQ33a6akaz+4oLc4yW+rZ1+bb2Am4jp5k7 siHfY2FdKtQn874P0Msb5GTtS1vrj23MFRP17oJHGxnku0PpN58umck6KYBYIq12geR85y5h3i3m lOo5ROHmyQ5/Iugycs4jez3/fTxTh409AJ8jm0aMb2YM0uQjRHR/gZdXPcQvKGSKJfYLI/Z6uKLv rp9K7BS1kSef71qqyH7w4c5hPyn0RoSRHiHwOqmw8tg7lZHC8Z8//MnpwgZtHuOm4pHyTGrFNW0d HQ2j+GpPekXrysUy9A9I8WPpazS/bPGSvdYLS1rXPLEOPuJEZcoqNeeLFlsdIBkHUv4/N2ahAmwd cGPhR6bEnwD0Fv3MEz0itGeC/nCZSK7flzJvg6xE3SKw3kg9aoZMpHVmvJmArKWoEmuqnKYNXKjL 24U8MhNP4N60AC9hp0rinzkKaSH1fRvBtTDJQYC9Rgq/1d5h/S9vzLxXWN6cbTah0tQZQ0hBI3YR Ef7Vl06bMni4gL/CKdCX5PVKZXJNzLbozLpGN4fkEdVTzNcVN6Bf4durmjhx3g0iD5WPkJ/SKbQ0 4UY2SfFx4tmc2TBRIQ0de8KQ7Hn8skst5XzcYk9dSY1JhzrZM6X7O41ORDInfTOPcc0Gwu58EVzc kA+CyDJJYKQrmEq2vJWYh7w7MB/ggnPckpbEfr8HiUkLg0Hvws15TKBQTau7fnYyg0lvCKhfr1mi vqfFnsE3/aNx6tuhLhyAPa33xoTH2vQiQsRXX7C0quO/R7fVtXEwDvHTSvdTj7Cu8H9HF2MiZ5q5 qcnUEvrYTd8EYNXApgoeEOZ2XaNkbrVDaENJZlTrJUYvHkgy3Zq7u6nzb8J/rnYEqPAzbqTA2XwW oSOp5gwj78EM9a7CAV5wQqp0t0rAD7OAZZpincH2KYUwZUzuRnvEyDqTjckMUG//cMd7UT8Uvi3j 5Ikha+FZD/imTjfjGMlTq/cpaw02MoEauQqmeN7Rmo/q4JneBpGrrvlPxmNPfD/p6q9AfdU8hZvP C4VbdH8Eblry9IoT+W1+IsRPwZMqjsrWryRIrNODB2PZc/mAtxMFQTwSN8NNcHoW9wt079y5pAE/ ATUIjs0F7zM4u0tNq0C5pXk4t8P78pB4rB3R35AD/89/dcCOuvxyTWaqYVAbrvxHJ5Cgc+bq8aHT ZYbWyYpbHGknGkhZbYxJw5FDoH7S9+chNsWpIXSIhKmrPdx6afBktkLXAb77MV8AG+5naWxj12Se 8hAZdQJUSiwMpp6H5HqhJonML61KhG0UGc3PIS8/fYuT/O273+OUMmlJLe3K5GtPn1Yu3nzm18qZ jKak/qKJjmgggyE0GfX7Xg4pTz6xHtfg1bIKnmWnRUSSpgEF5i+Li4YyIS9NIk6nDCvNBBOdYnrb FAnQZ845OMiv3FqMKPrgl1ONqvzHXjZXDQWOpsRertrovNr6DBRphAaqpujZDL68CUkrVk25ObUH Tl26TZ4XMT5I8c3nBiXosFkjN+ygn7n+YfOP14jvyDyEyrxuu/HHsLtwwm6hghM77hokPLBvpdb+ paDCKOqLD6H8ur7aXd+dyhEj1jjCalq4+gxJBy9J5c+ykYUDqlxnrMabcnLRyDJx0R+QTu0qgkq5 r974V2YieqnoqKikKsoELTbqoJwcJNfdNM8etsHSe/pRF915zOEzDdPV4d3+VSDcOQz33kKbcW9U YD1a9x+zqs2lZgBupUJyXcpgvQZMxA6hT6SIRETGDv93hqETKk0Fw6albTwDR0vJoxWmTnPHw5yM oZyl2dexuHZ3Gb+l76OBONSUMtOYSuZPciTEIGaXQQSyKmdy0XUFelQbGL451w7JEREChbHoKbtO vpUz7O9tVA/+3hRTN9lQ9KIBlIi5dPnkMSVwCEOjgYel/TmVow3oQluz7q7r7Ky76z8ktO7UHR/o WktUNPBa9eBR/Abm14YzxLNVAExfvS+uCzSPUu79Ev1rewAZhektBVKU2LeZas9oA/peGjJHjiZl IUNbjw6GeoW3tQXWJti3kQR04r611RcPg2M42pTEBrYt9fiz5COYYcRR1MZa8qbIZ1SPt9UuXRO3 Ya+vUFPeIgo56pHj4j8OUtav8utIW2LCW6X2bTLmyweVALzHR9JeL/t/+Y0vGnomc4JYiFxy551i gs70Y08pixyOka5An+ZOX+K1AhxK6gZbCd5rmBeiyWcBvyqbEoggNHbJhUsXL7JlfQIQJ8bzCtzt dPgAKDLTeshzVCliLq5d2wzews/CmMfEzIc0kCP6F4XhRr6LN78nsFMdWlLwL7G2uKyplRauXHeU YllByo2d1lhac9j5MvzTB3Md5d4e11cXALMLmRCwjbR3Wj/s069k4Ts4TwROyJQmcmPuYWCkmVad pn8GE4kFNlileMsh4nsD5KydlbniVqYYXLLOfcOCP+OqnC3O7fbT0predTeFv/BbUvlKOXnZjjNL 4Ea4UDTQESCTFx9Pjm5jy+fejwRvAHeoKQM6Z338HdTm5Jj6bigpERd+lYPL1hadG54p7GMWTQzJ My59PeKL+dMrvwAL0tJLj4fIXzJwKg84jUBLcxSsVEpfsK4kjE015JVXrHa7lybnWq4+yW0ZYIod g0cyUObxyl7d8CENe500xTQckniZB4GUI7MK5eh7Cf/gQc3JwPLsXztCQkD2zK86TvRJ4qEl7hph vj+QKkADG1dFmSa7Rs7vurg1pml0ep0edEpOgupJQ7XZMFXAZQqi+FMZzgLQyhUNwa9107bVy0E3 7FBn6Jbkt4oMoKkdp+uRRHlCDl9mnjWGcJzFpw96lP5IU/U9yuQM5UUT2DAlbzWFaOMABchNceVx FoDAfhcRPF+51pf5FZjPpHPpvs4z7mqPJZr06ZBZZQyPl4IxPEr0kE2XD4Jy4TyTKzYIAercZEQN fx+jg2vcP0r9NeTRh76gPEZKPlmOvVyc0Qm4RUPmE5F0xm9LxUiaxqwTJTNUFGvK0+RUCykwYxZp REJ9vjMoYMtOU5Dy5Mb3jewt9SpmvhRFYJwKfq4Ik/bQiI0+pZoEklXRr0jcYBT1o1Lsu3u/Yu3+ f6gmx9SwYk/jn6e1qInTmFZ5rk1snSUeXLzZ52l63Zy6rtE2bP0is56QBlRr3ZfzowAXvwM282U4 q4WDQqs3vsTSi9hnzq2kjQn7TSGMIm/W6DWGPpjTloOwF1JsExU1wAg+pJ3lkGt3L+NTmImGSixC lJxQjwMfwyrkErV8hYH3AeRTYx462zvMoy4VFFdc82rhbM2/XOxOrDIYlrCnP88hXpGiWuJSVNbs InUlpKV5TrZBBt1t25nqMN7E5OCGxe4Dk5BfGHQn+FkmMBHaob4R64Cy5uZKDkgsnE7SyS4nsOG3 qNxMa3ClP8VVC+s++C60ZsBcfBqXgp9v0Q757WGKLyT//Gb3j8csbfCFj2SXUzEXXi3OH4SHKMZz BB2OcsCwOU5fUgV1qeHGNAq9A+xA6KA7dEb3m90spB+5uDdq6LF3gk9L9+yT3i7weTYT4hQPUK45 JW94PQDbhMFmjeRVNXr/955H9YfOAZUC6UaBHIdcKi4Q1JcysCCJnlTuNs8hn+5y6aQ29ukHy2dx ls7AMOfYVSV8chK1TBGP0RPoO25+z04OzupLTyadSrmVsCXOoM+geaR81aJNPB85RjhzbyWwlO5H VqYVHNCK5BCDC7RniSMRsWyes5szWse134vy/5TwKHYP7SeKNul+u4cyCXPiWcBfx9bcCoFm+shd yqkTgiCDliOWw5pFj+nKRKo9jjsIs7XBDZcbsfxbfW8eaQpKtpFZJ7zukSrRS5soRcrNULdicgP6 QJLr7h1kTfAQS8TPEx4zT2xzEsvgfkmmf46d+2xESwBsU/ou2SWmtBrzwZLvKUqmBvzIh70nk8RE dCBEzeQegmZGLqifYGiZuOMubbE6mutZh9lP9Q3IwG3S0Zq3wXAyGaG6lp/vVuPfB4z+fpjNyVEH XupjlUK31c40TUwAooFIkNOGz7fGABr9YiGaq8083CY8YLjxtbNXuKKVN8FeEoXnzhMhBEwii9ll xx7NdxvELC7pCvuNSsOCQ9ceTfOmsmdHVV7YL6v8CEgmzZr37KbDf22MMLdVAElp0QbBTWaRbisW V/NUvL3QUW+663icZRZOY7C6xpZd+IWeoUHfRjLYRpsXPhb9oft5GBIXytWfVmUwpBlYlIT0IzOH U11DqcdXYM6WNuiMBphtwOzCYvf105wjY8QArtJU4UB5uC49na+ckROGDSODnuKPT/HUNZuEoJkj hOpIMpqjMe0UizuOAzZiStzhmmA4VTFV8HEdYri0MX03HVKl2RjJB4W3LRIsle3hRDWHjZmPOoTG STQwIVj7lIE6MW+dqy47XHpn+kuMp4o+5b8uFFbr+2cBRCtZz4SN8knEoLXysoD4tsFbiBacN8yJ WV7aMrqK2QYAVOXLPDJdFnjgq7/IfHXVQC9A/L4RDtbWemmbXLJi9OQWqHtSVklumcVJWnyRlezR mfFYYN5C/9XrLTNnv3c8j01D+TVh2GtbTLFyMO28DcBRUXU46qpoS3+Aq6TDf3Fybo78GQIf2DNf 8KLCFgkbGKK7H3EcLBzXq2GgsYqJzEDogChpLBV9+JVRb9Z2wu+IaCkpXdeC4NV1C0uBRg7j0a/x lrWLmzkp/35Nz8q8PLlAGGD26AGxB6gOEI5BIg2wgDCvDBVdch5r/hLQ2QApC9gpEfA3Euts9Gfj L7HPLHj0QbFq3HijW4te9UeBweCiye3DMPTQleCN/NXD7hz+T9C7q6TjtUnl0qMgfS/xxvyh/vaB O5tyjQ967HGq9ILsrb7Ik2Wy6Me20kVrLQPWyVHKLrjITdSm5oodIQVjHk8NlzsoZSqnRcHfa875 PB8vczWnffrsnZBFtZ3NxdPIvbFHkC4+oTql8WD+K3Ls9wSlVw0G/2UPxlXXXxp2hEBZZq74zczz h3acS1j6Akwaxlzy5FtyAhxo+uXaTiceFceDi2fQ+hnoJPz7I0+5dpSOJ9py5W/3fvUNtO3caWUH vJr9jMw4cYAu4/Uazgye5p8mfX2uQlKbXaMSrhilgXXzyWL9xwptx8JGffp85POmsEKdSM7S4epB U4v0wYJgbYJ43E8I0mIzMQPTgvRqvppmCC99xR+Dhv9Itxz3WO51S3MT37xo7lXhF/Tfd0jtnWbW x676JkSVf72RSCYh5uqFyZLZb/zg1DyVy0cAsEhFDFPy4hFf0cOco6gVXvULeXH2GPecmwj60Spg 7uSfBcz5va13CupVjyKA/2znX4GJoPDV7uZW7s2YiRBpIChQPbfqOcxwQ2SXaMtKPsGUUnjz3LHq 28rlMpa3N51sZtP0OzRbwd9gWc7SdhP4mp582j2zfS62U9pGD+9LgI4Hn+LYWsm5tZg/67jNX39D jXNj6BxTw0G3FArw8xdQC0ApWVFZ/tGEvG8Q8/Eh0StydCnGWmKn0XdOuxyQCSMQ9cvB7ePrP8C9 0dxrP4WuWvE9hR6zjHd4ZF8HlGIGduMvco2TG807CQhIOvMnhujM6ADJEgi4cXCegQZlluw/0jWR +Oz31oWLHPJspgrA1kLGcJHktxaiof9Qvs/bNzbm9v85EMiVm4z4AfICbERS1K6paosxdr5D1Mjy jAFFTYsiPjGkzI1+psXx8EYhQP9EDdKGf63HbqxLeUmP8PVjZgMgc3emOM63FGQVtslWyGwQCXJH aGI4Nn8bmflvv1Kq6N4/LEltvM1NuUMLBji/233BpCaSizr7amv2lVbSqomtO+fUr2zyg9e9hamh SQAN2rI9cIeTftHzIxvXt2Mw1R4g4Av22eCKgXqMzXt95jWe0iJ6Y/5LKyQNB4gszkVrzaYX5Yuh Lm9moQiiNckFu8eCBQk+cc1oJ8ZOSvT7ZTA6P54q5V7S35/VkVzw6/EqEXO81bi9s9BlTq7I5T7t F5g4QRbKGu40lZZNEADOmFDFQH8/SFfNQToubePqgjPH62X+Q5zrhrlv5J4lxT4X/FWYC7gg3XnK LrOpK2XvBtQyYzGt7ZsHKbIO4vsJ48kPHSfh1FT0pPWXCsWeXGBU9KsxgI6NnmtczZm+fSqI9gRW qdp19Kq1bNDd8gkIbKhVLkZ7RCYNLXVND4SJk85LUcBb6IjzZzhyLGwqhZawsSCeSNuIDG4kQhO4 WZzeQjHS0ohQTSKtSlQDZ4MErELIzz7lCpMln6L59XxV9FufZIOrqLBvvYGNk2hKvIv/xmPgk8Xm m9UzRDXvnsh6GoWn5FoewvgvaM3iGMFplldOnDwrblW8q0Lh9DDb4w9CtIR0eP8otkB1m0kP0Vmq xwJz32y3DuMXTJpAjBaiHj9chJm+3m/NzacsirOPx5qWOKFgqzpcnEt0jot3hET19RLbtEmvargi MTltw6Z32dBWQQ0oXSSiZWK8zoMz89Vgt8g4yVnuxzjrh+P2U6d/m3+06oJy4whYpk6ZodD3fJex ngIlXaOQBJ44wFtOOZPftwRncLyjh4Guqa1ggDAiBwQ5uIVqs1R7QDPUDT62pv+EKHPU0VMXJPAw EHrAtheMneocAvFUoP02bXOBiGxW+PW4GS9rSSrK31EJ9Nv0kCPjOxfLZRHNddwNzagAY1qFqE/g 3K9+SfiDKIchSzq+/OSBs7T4xoQhzxAIFOS8GiBsDvlXlI2gqkTMg3TJ1gcHZYoYH/2+Qi3ccLuc AcoNvoG5VG083ZKOAVxXRCUOTYz7xT7dlUHRFIdwZvphxAafWkMNr/GBL4nCHkbKA63QAIM7W7pH YZx/zY0urw4KjoOGRt/kQ1f4WogS8fQlsgLvFDnm41oSNF5YHqNWJ/RoxxyOLrxFKggY33JP/5Px 1SYwax/iaZ1YUoyyHvAZbAPMmHpUPKVXhjXDZBzgWP5NA0x97meqVC+5EpY6jRauhkygS+46JiNd 7ghBSzwmJ5UY+gm3vs6dEB+hiXq5nwxuDmcJeZQpQwNZlMZlOaP4kYIKKZCXmqsaERiTK/zaMy9l RG6zlEPutvZsWU5EZ5Pl3ByPcsoezESz8j4KQ/CjTtI2SGsywTXzdu3taMV5WDswARUbu9Vu1avm pX6QDxzCuoZdGMM1GhDtDKgK1LjDyjH7UVWyeZE1PJO/Z8iWelWPhykmbVjAq7/vcxVaWHrnP0Jf 0DPpO0Et+wsWJkDMplRxlO7mGYs02NsGaOLvklcGTCAqRNa3DfsAitSExL+rFaAwKUxFBO6PgE1k wTH0cBTn8LNkuHQvBdGOjTDO+9dnYgthA88pr5gYKH40fac7m+sNGe77JCHblfXUsH/nGafV+LrC 37NCAZH5P2akbqL6A+pu89DSbGji+L1tEScMGpOaIpyFd8il6Jya2VIjPU+34xRCvCgujwitAA8U rymWYsx1QRVJ1pBg+gBCyqz6WiAh2TwHJ6q+82AsA4rrSS7Ls0Q4zArk1s+ZXDCjgPzGq4N5UvzY BIqw5GphQOV3SVx7u4XtwI2+ysS9Y6XNnWI3/0Eo2n6xDFlpu5fLCvJCBCc1nEjMYmEyZP9qS3Yk sgbdTcPQtEmOai2ww2Uz6e9rYjReiqQl8YGhf7nzzRo+6J4KvtTuNl23JVoINVZkiBM0u0LFfSIe gUM9ZoBeEIE6B80Lt7xhRdErsSjiUN4FoL0fQ18wClBtvkULYOt4WmCdpxM9/Ck+g4cC9wxXwP2E YCpuh0D9QuEqham00T6UPVyJNAc1Yni50apkbw2cGpGXYqAAjR4mK2gxmzFw6ubXzrerpywqs+Qb A4YakyIABcyNhcmCRjBuLByUAUJbPuuvT1Y7pBFImHeb7TSHrG/gZkK+nSy84cYFg1mcwMK6zHbz h8rDEqwoXDTinRU7AgkZVs0FXmiWCSMkp9GyB3CmeMQ4uQflXg8Hu5r30xM6aMO6CdsUf6Zzd1QK DH/k/WU9vJz/4GJeE7/7ToK7mFanCZ9t6+0DlULO+n5o2V7a6nzGZ5zv5bTKEzp8dbBzt8UhSakD R5fU44rGLE9mXncIzN0AJgOaLeXBXSEWR43/e36hDMXpUqtduVFC+vpRn+Gsn1xWwTfugGEKmzrR CIcrAFCNubA8Bo3I2J21bbvevUAbJAoc5BgV8mZ61PIPQNYxV668wsReQteXXyqXPeXG2VxCoN3i LZyCk84SKAHdZtcLyll6oaQZDrbQYzR+18sp554B3hqx1NNOyFgezVPgYEDBfk9zk6X3XL808sOu e7WXQWjpYeWesF33XUMprINITiPazsld6Zrm+4WgqybHhEAJIL2EBVdWGCTmP6YhuluC1S67rbYu 2dyCFcnj+xEc2BSgECbTbMl/q6+TWIuiDTpWxHa+qVZbSkOG+h/Fs9Nxy/bgj6bugzECtWhBjhaj ONs0AljQFNWme6HlFHmJG3vXAwEoH7nTpBQxRzzEEzghXbjnHZp4XruLTDacDb4EAXc01WkiSoXE S/W/HpNy9eiQaZ7zpGbSZ6YkRLWFDlh0EK7Y4CH4reVXfMFmhyTi5sn3btzgqBwBfteLLLKgou3f 0XsqagZrJZYL7auhoBgy0kA5WZE+49Nt0XQPvOWGjs2x4r5Opg3zzb2+IXzQ3mOJpTBjuZVvMFig aSOCnbw0hbIWgb5HqeRXu5cDzk+OEUimf2u0mCTkhZDsGyYXeoURFqDQ8+fr6T33fVmdQxA+/lAj zeWZTqYI8IfsKburn+v+VS/CD1nd2MUhzkg52MPZcphBrOB+ax+BJ36H3CaOqfIV5JvTvP8MvBG0 GhdrSKjhJ5cm7h+QPQ74yKuYTfXaeG3iG0oo7QruKDPGDMknahDaqK4VrD0Y68UhelSYHWpQ6QNu 33HYyn8taPYlAYEOm5FHfzj0rRczBEffWhHo29l5XrrYnic4ZFVcBvkTO2Jh0xaaVFeTG2H3Nh7Z SXr3RarWka6OKzTYqrNBxBMoyCifjdhgS00t6pLfi6KUovNz6CbnivXDR/2VW2HiPKerd4X1RiWl lAlJ4f3Cdu5Q3VaYKGh8YKTaYeHzNycrRw1q6dpjvljU2Adn2pgPJQZGxxhgGYRXI8De0ACPqt3y Q7KtBSyF1w0GxrYyV8fR7fFX6CjVOa5/1wP5USF7pAnd6YhilAk1mlIm0jD0WK5OLEgiks3WXfNM y7U3UVWPPpGkp2EXWPfvgpuk8O1Sc5sFK1L6GATTWdE0pPEJUb4QabTPfxUVkd6VBzAW/gV1Og8A Foeylv0vD3grz1VqlaLhGFMml3uDW7NacaFIGs8QJyl/hbzClV81d4DRNhCdhi4Tme1K00r77bOI fqtmRnWsSynM2VI1orhnM+xh4AKCidKmvkwhyTs6akP/AFS0eDhME5dvsUt2WOW/t2616YATxYGK PCniVX134JHlT0I5E7CP54J2oMhBWwGNQMX71x62cl4IJMfHUyHlAk+Pj8eI2i/Vkg6V1J5rZjfR B1xBDIvM9FuY3L4mhUsOVperQVnqlzQkCwA72Fpb54yWEy2rWY2x2tH96xamDzfJdIlr+pwmLPbv v3EQduGA4z/uYDinAsZdQ1qC7JZzYm5CYMW9Xy8h5U//5sRvj3xKK0gKnvm1UkLaH3m3kj3F3bg8 SH872v2/RQQInSaH9Y7cfjfj+ZPtjks3073U5qIX+U9iDW0sgsDiTLCWjJooPtOYMGLqWzkpmkch g4vTMgOnZfYvJS/kXZU8zb+WR6cOLs7nMiVKIbTifDLETyztFbxUXCsbqeadvMf2Z0vpEN+JybQ0 OzfOED1NUKqjXbvGIvkZo7/TdiPa/fVDTjoVk1YF29FE/S5tcWz+dPyfJ8Nh/al9XWyjupSRyo3h CIKOCyZit3c4dozP5oVmW3oujFlVlun66B5BRJZetumtMaR9S6UBYXryw0tAiDBKzxUWZ049pnhv +Mch/8QJlfqwXHXzjgWkVJRgpBSuprRZBe6jLc79ThDTVkit7v3HXc0ZE7xhxdRcOafKqfnj7zet C676uFSVlRvbiESY8Aj7rT+G66eLE0Flqopu+cXE9CJotmuVtX3v0QrS05aw340EvV1kv1GwiuKI MhEBwm1wIzH9tfE6ei0BAZpP61WxfViyRCptj7Iw7YxJBMD5FpyrNSnccEsZpMFItfjjLmIehW9C 4btHmJthq/OpQDwMqy24udBB9TlrB8JRmWvMLiqa39d+PYs7YK0HlGCSG1Ol230f95CTQD+dosp1 Z9+C0CfxtqJUhakXedcnQeTSWdXYSHj9qe02S65vJeupkP7YU4h7wAUa6VL8M4R4blnin5LpMRP8 W6hWucBkD9JDgIGrd2ornCn7tpZSFpyqwhLvRh5lhaecgnLbQk8RjkdnTW+3S6zuiELrDX2NuxJL 3FUT6LrZQniwoU0BFMBAFvxskvzVXTpGDJFlZwsFFawDfxY0rFHOxISwSgr1CXWaQ2taKzFEJBVx 4kGfHdKNm2HpoTGAnUiGpyZuIlLHZmNk0ecXqhF8QfzVah7qaHQM7/WNWcq29QfqmKuCNRNdvXcz KLD5WIu7GK6/Gc7mlhaz8t9cPW06H15al5ypU1UPMrLSk7dtN8ow14dSdxnv7Mk635cKA1fqnl+D 4iqFom/opTdTu+YY17Urr/5Roy5zm5e02ZeA94GVD0wY2TSkUUZgguyEyc6YDG7Fms035ZXvY+lV AiwhQuNHLBklk1HFCcxU5+mAsZCAwbvsYZLCuOhIJhu4QYIFjPP4X//IhZA0W1esf1G5HQX5jcPg uMVqdpPMexdQnQpYIWkjQP4Qc3rsch1habXCQggtSDLKMRcObEMwEbo9/rwNYGy1D/q66PTQTE/H kprdEr1uWAM7FCZ5cMDRQPFJqETR7ujVpeoG6JRqA43VXX9Go48k6+SzrtwsYpJpu/TQv31HfmgQ aHAwO3/aq69dH00qMGvWIA/+EnpSUKLanl7CFWbjbpXoFiE+ckTeOQ1FZgXD/0dF1BLqHFsA8cLL lid4W6Q8QiUX2hf7cat6MdOebBcBMiszethbfJugoEeLKbQzjGWFJSLyR2Kq9S/LpTFlxAekIHwJ qJOE8qbGdCM2G/FdW8CXufhjEf4gHlrr6vyYPjWV50Mxr+b70mSdGNdSgt6vx5kU3CVoXXhB2JRz WwoOGCizlWIo9La/l03iJAAlN46T/4G7z7ZI3vU+XyMh0O/+49nIdWTCN8EHv4I2oCpiHUTjRzFd noVS2MQXhjUlKIoZ8anGK8xsc9A1A+FEiii10R6z9FwYy3htJIB1w83BbGtd1MTpF1pFGsAdPB/9 v0Ln9bNBzvmf2jKpwRkaGfrnlWDblIHyKjKcSW+7KPEj6ylyTIZi8Q1tCjWJgK+DmV6tvlxAyQSN nhCbzSkqGFxwqEgzsmAkO6gQCXnCduuksA0lpmuvMoFrsj4PE8sm00ZZp5iutKJToO5OZonWFGvJ fsSzVYMYtKWpH6hURpLAfEAeHmZfp5J+8g/pEVhPsau6eDBfcQ+NvbyHWYjW3XtX0+6RFnPmRmT5 QmIUBvv1FyQAbauA5G1uwHeH+wCRNqe/iewSNvPBd2JMbPfpEtFbJF08Suwe4pgHp8LSu1jjpoqY U2346Gs8JziNslBqAJl2N9XOH/7JpKtXSxH/jfOAwomqHR7U9RQY8+NqG4PIagn940MWvAPvu1Hl vREXXVrg5W3nbghoWAYZOUVo6Ji5Fuc0owa3MXG+SZWtvMfGCUIO/1FGT+EcRRhSn+Itb8nlRN93 c0AJZXsAcrTSDnxhKGYPqpoyLRJuvL2cI5RTRZKnx7ntggLLBUXIvSrfGBlybHK7k6/m8pPDUz4d JHjuVdBNn3/FCf5w/1Z8GIWFmUpR10rDVDrRx7bUy8QhghqFk4oPQp6swaQJ1zfjwgA3ZBlPiH2d r1Cu5TPVS5GxMzxBpVGNbfKa6MPOFGM1PxFnepp9isPcmi7t3SLfnK/+iC5v1Jzrh7DyvPXzkrIt +viqJmUOVvJu5wyGLXyllN/UVSHXGndcDWjgQa2ceyIdOrquTiEhRohRzw/0Ym6UiB8NmKl+l+6g 75AC7CDRPGDMcbOgWA72kEAllOBfxwCXUF0t0xJaNAdlISVU3aYlI+Ox/4hnlFoXRnRzbl2y2CG3 JmMDEtorasu4a29DnEo+ZZwrgPYPLQA5S/Zu6MT6j753e6jKjByUcD+VgKrjK+O6C1XdYZJmjRpY fwHHszOp71VKHxiftkQUkliNIhpqfZ7okmsjIOmcixZ6UC6enHD8kCUy9hKjqdAPzdrS31WSMzM6 C8Im7aQ+/TVXn/7bZGuuHU6lVSPGq5DH1IHKXMKwQEe4L1OHjclL1yB7J6oGEKI8G3AebqbO6i1x e9GPJkTzJT6wLXZXdLRFkP1caeFBK4mAAH7yuoVlWpczyDdUw7nSTOiksU01AL9xCcFyiZg+vlzo Y49CLSJHCi0jIYvixHfJZiIBgm3cJZSP5qCIy+HPTOTlhTtmczZydH3AQe+MSTyLerYDjbl3LgBa rCe4oYlpLkHmy3BY4vkO+H2TLq7qnkX3FLxidbBX+uEfCuKYs/NymlAgpBHUguzKYON+5cAccuyd USp+dZX42Dq705dVKTAmwMpyV7bXdSUiKWsFEHjKO30kmZAm+D2nBcyPv5NcvZEKBOLut99lfv3C cMggDoptZfWkGy791sUu4OkP6MsGDfebluvcy107Iq+K8qATr8Pt2/qwq6ydLNtJG4Q8Df28L2Ql 0YHWhphAcZXtGC9K4qlKgKG0/3eKm7eGz1LigEGxmTwEpnL6jeiez9k+lOnGLUV4YR0pAirmIv/s vOk/7BDQQeRwxLuRCFOL9tuiX4gwPk02pNOlZdwFfq+PVEivItu4Vwmz0w7dhNS7Cyuu3ut3CwPK HQTRQY2GSxM0ZQMf4ZU/JkZkxfcjOhUo2kljLR1adnIHxNF3MZXJ1rT57Z2xScvgJ40ihPVAjpUJ DAXfHo+q0VqWFo1B5EY/mg9XdBbXBSvK0Fk4ZLl579f+cZs0+VtNQrHbKxZtIBUDzY/DoNt9qnzM CrSfwLauu5hMUDN+0EsW1ubxwGa+1UNm35o8bp3fQQUx9efPR/fYvgvJZ72R0tgz5W9+kqmpSfYl gLO7zm3x40hVrMWBFMvINGhCQKXtGTyub8T26OtIyF/zpPsEbaL3yuzZaCFlMRIg/qMSF5upmB0l WQ/JesTz+qbOP7+R+dlDylxptbOy5lieC7djFe5YYCSNx0nkN2ONYvC6Sq7unDa7rhoQYIbp8+ZU Hn/aerLu8wmMLxMN6673ufBLwYQ5m/rVcn8aQJlMgi6qyOg/Nl/1rlSgs1/oOgFsK2Lk/RnyFxL0 m9t6y/tqiJnDc7A9SM5fC0WLlIG2j4wzpWq02Sje3i+9fZWtRRIsYBK1R5jR9JCQSL5HnvP/0srC Gype3gyt0LQpR317Th7+R78DdLL6IPuWDPxaho8xDli9RJE2207utl+CAHP7KAKUOFshnhPht79B rd+KBrZzcGw1eap8b/oGhl69SWuoudh+PsIbYJaq5YgjszFGkhoTGgdN5r9dVzwsyZZ5VTVmWT2W KLncPmK1SSssgjFPUXR7vOlyXVlYIikaCaf7QAgE3zh/O1m1jDjfJvRnppPlKytC9J71xiOxASRV ITss8C6pjdaXhD7Okl6HHh/MAm4uAC3cv1vqQsFLji67hOAQywxlWphjQkg04LpjM4UnE0UK2GU9 v00+qIgqkaCId5aRBj034qSMa1FMPzhjKV+9m8QSwV5C2aUebW7/2eOfSNJfRpBujafq50ABR8JV LKuoB6pBcFfp4FlOTNfcpd0PmC4uqw0JT0bo+iLuSgcBOCPoe8pfpjeLKBzm9rSUcECUN4GipoV7 csMosIY8bT9IsXJTZOCdLErDJgLMubv1IAUpus/UIEOGiiu1jJl/uuJR02syHHg0vlV3joc9YSMl FlGKDredaOeJ03BfAyDZGsGr128oFqCbdRPChKJQDK05/et1WPIf52cYUhyy3gXontgByd6jzGPt u0rhZufvNpqlovzbtX0Es1SYpT3ljjYZs1X4YYY4W+osg4Dnkh7/9aCV6DOt1SaxqQfq1UdxfqhD YbEnVSV+jcshcsqRxaDtIylwq9a7d5D8O3uop/PL0qJA9ZdaT1bbk5F4HFgD7EX1g6yEPZF9hbqd n6oHA5aCLNBvh5LVdkcP6YyDzjlzvL9/whxikegwNXwy4Ja1fvJu5YAvLPjHTcV0I4RmHeSQPqWb YlfIvgfU9L7u/CiaHBpOJQFfXO5sXuyoRlJFhql3B7MK42xsrf8NsByeMchdF68MhxqzrX9s37Y6 LLyZOfAANoU943q8EQEyn/oe7dRFK5+kaIwG3cZdDq0LDPR6rToJOfU6j+VMwqQZHUInEZCQkObv YGcVk7Fow71Vb/P2ZS/lu/k3Q28uQrOvHXG9beIQTBZbIMu2j0Mldl75FOMvv7GJYh42bILtK7OY 9Lxjd2przaqhUFtS3RB1J+6jw32hbQ7XYR4CMQhW9/sNUTsy3G3dz5wDObv+Tmw1nmYNL4scNcOG fq0oFtBTBLqnj1gG0LPUr+Noq44IzXQQt/FpvPfiZGlVMOjd4IQDRTofTGZEaUDu2uZBpFaOnIth 3o+U9QVx/gKukayD/jr6u+0yc8JKxF7yVC8akmQlk80L5cmhwL5SdSHOQyia0nCZc1F6XFVDRiHt 1dAuuabv1UwwsIJpSzp/F29RzRMxgq7cxc9/u0fLThATfv94us/29SgrdDahMmcx8mp/kcbjizTN F1rhL2iwwu+Kmr0enBNUxzm2DJUvIdO8UmDCUayXUWbNVUUOA9mPF5KfYrSLWK6QdIyMSMbKubT2 XobEwfPIjuWERAmRZREgUBob51D0VQq+qn6B7PNtHnGuGVKgQMxg3QaFO9vK8cwBZl4cLCy7bQI2 urYmBF8c9zwQVHiAoxsSmP2Iw4MSmbVbKEFf891odRE7O8sQLORvzhy033dllP9L4bkRKuXakryx N/HHYPKrKgoKZHxtZ+9vL+WB8DfE8KrF4YM8Q2g1DxTCkFlNOVm93hWBFff6C4Cnub3dNZO4QW4V MWerm7VdhEOwjk8H0woJDnoynce1SWZAQmhUP5zWopefkkwRjZgAZ3vCEL8nJygjKldcwuI0P1nk ag7IiCjCxOzTUsBy1d2nEpzIeaeX4ppSPMhe0MJX3WGF26iwl6sEoeCfcs04uQN4NkP/gdwkaInd WIuk/hfOJ1S4od+tpj+TWUkIlkGB/h7YvYGVPISqQErZmtJ8Y/UFI77xxEDA78bjQ2nAjColcucE ul+V7ecx/ay92eQ7T1wQGaN8rEy7YQL7o8XZZXwXGagA0XQxqTGTjyihwHaKE1HFdrhtgfzqmMw9 Q2MtyTha3tXz3e0CwI9nln3Mds0d9dOOtyeV3ITI+p79XlESMyGZWBqsVkZmT8eZMHsptxZq0WPj zW7nlwBMwOyASpzKZS3xdcq4Uh3UIN9MG1z7ErbQbmRmTArIUB+sATHbX0YuLtzKKouskWPlDbb2 WJkjDwUuZqgVO7Rcb5Tt8seMwSMyaCg28oc6NSvEotazWCE69BzdQ10lUyP10GVXg5ktc5FH6rY0 FSmGOtc3KCZxprIXWkwZM6wVLD35D4b2PNzlIMX00vG/sXV4suiTr7R5UJSf9BdBducar5rBiLvN PrSzWJw6apCNqFSU6IqjTMJnuQYCFCPQ5JFWKaAweqCmZyFHQc6RvYwbzKXo75FeALUdPS6QiuhE 4kQf8PdIQtL7GnnGkdhHJfyWZp3qFELvU0OSOZHYSo7zg5jOhMCjKx8TYIyTDzWmuJfxmln2Q8yR 7tyWg7+fy9N8CvhhhiA79pUY8POWnmTir86fDch9GkKIJiDfljN9P75O4Kq5oYxWCORGNuioZWtY +5TU8V8vcGIMNl5ak2ZPNp3+sNmX/CMAq6zj8+IY4igJk6oLi4z0oKfQmuJw8maU61KhbJd1nEfk hzI34bIrjDfsbDLrn94kOR1YB6c6biyHXYrAcTKI49OD0u44FiRMfWswYaMb/JNXEc7Fsa/2rZxw ZQmdoT65r81n951TP7k8kmvqcqKbu494IwMppXkdD69UWF3IE04rJUT+c8lMS1gIceGJO3Ag2oWx 5CgLMsfKi4+icSl8/9akdyhR2Y9Um/4FGBXRgk+0yygmgZIfh1lvdOZZODl8s9aHGB8AOrdUEZDq /51dUz4+f7tyLy4XoN6e9kP+2coDQOQkfX0k1Q5eLlTlPmZphiOFsBOuib2w5QgslnjsRVdRTXIn BMQit7xcUstxzm6iJHGAhY+4aFdP6Jr8dYvTZM0pqmMYHibgmJOCyKBEmoGwQGccuRqiyNCZa8N3 0d1aGoNbGZUqh4nFq1wx1NEwAeURjUDGnoD3YUtD8ECSyckCAvsqpJcZOqldRxgw09O7B8s5FUmR gk9JGnJauJrkMBO74tH2hCPcw4FzM+P2+BQZSBThVMlihH7+Ob0zSKvHo474wcNRtLhBQxWDt2Vp fgxTm69RlHeuOXAeu0BYIr6v+zO+N2N7b0teDgJAqPzZ0q/VIWYMk1zOHifMfL3zfi59XOx5VvBG Si6Kcsf7eW/Y2UilhsLAHEvrjsgJESEf/Yyedi2/q9kEMjj0JhUOX051R2Yl/gJYrC9onAncGXEA HdgajVmK5gPuYkuMv/siYOSdzdid2Cu7Fr0j9/AnbANsbu2fKXRq7RWz0zE61cMcCrQjMZHOjPXX kNnoRpXqdSLeBL40fg/C9AnLmCuYcECl6m3KWdI6KX72gDhw2M9KvDcYugMb1vqcohbH8Sx9FxSr 9U4dYoKh10VmqfcpaE9YCGReQLaqUpmvSqx5ffx+qQF6/kQzSxk/hXMQJ0mXPDyObHZjqJdVj8or EP9wqxHNEniV/QEG7s/pPWdfoF3O16QiJzty7hecns/xi0ahGGYrBwucnwmjBhq9kaM1qwZS4PAW 8zosYBc+LOPXVkfeFQ0spV4h4GITjIhyWd6h8zC9oeuoFczWcQtxy27Lb+dkspLdCdDVm6fUe4KM mzvSSARz+pJUnsMkjx7IOWfnBKTQ6N7GL9+djLGGuBVLLXlxCKsx5Wc/mIpEcyn22UrhcjVoNRq6 JL+zaFOS1KWTDf3w367UDS0NlIYymbRCLXwVYC71Trbg+HjIlIGsLDRZhQ2j6PLAVx/Mt98zTWKj txQ/YwPuDsaxQZWpYVjTkxq6LrcNleBrUKSGmR0BG/WuO1HcR4bhi79fmUoQNUBc+52jjJIKob1U Fdkw4wXIzhxctptj+7SU6Gq1FhYags5vqC6CwpEMyrzhlrEW1ujZNzBwsoPovznCemjOKIJzmzYj qJNyntFR1Zbh2AZM4swUg5ZDSArDtkNYl9RfNiW34EFq50CIbpBWv/4gMUsxEH5YDNWDOA8Bv90I XeOMXlc/JdwpyEHtP/Xpa28XNtD4Zm4tkOXeweLopLVnWRALTxvs1o7ipD+VqymxetYmKosaU08E F3E+GeFOYpraPWsEjfkfk26jTjeP5DVfHz2Dgi+q0j3k5/DlmgMcbPOVfM4TH3GQybSg5t4a6xLJ AV8vtpEF5PDpn2ZUlSbrGrjN5RmxNlE3hpXKLFCDfbmK25br1d3+q+ik1qFi6Ox8had9LRFXUXFW QOj6VGdeHpMAH+L6wU0IBEyiXcm/+FPAMO7kShFOcvPgoQAz5HQtmZVlNST4+lkcJvD4T6jcIYOM yGYAiim6TU9cT0mBLrSF3qELIPJuvYNe8WMWiAPYJ4LAH3ENZL1/mMic/apOSZG31kD7vW14opQ8 PEWhnpQ1xGMCnBmCcj1QWYoLExBqWdy2ERagirWRk+6Zt0xbIi9/H1GUY/WRMPtyaSghRY8Bt4q3 mbBqJyya05gwpOgZXxFTkbHMpKEOWDtCgP6z1YikoLvyj55EliWoQTy/8ZPvfdxQs6nnr1LWbe7B C54Sf6sm/aMDuhLySv3xIFz2LmKyGmQApjsA+f+6oySY0BQpjSKOJzY4uJofdp3aYEzL7SAIOFvC +mkgWuhWC08sWYFgU2HCcdT7l2uIxvUNXfJHnXxcWp0vCFpsXxn3MRWeE3URtHiow7Ob3/WQl+Nh V79qLE75cWkySrHpuXQGa7kTg7+T8Jlm9hOkDNo12IaGGtLZC3+e6mtKN0UDbdiRDjywZKXvuuuM zZefFFPkslOH6FsyLV/JSlagG+OmsYFTstSF2VW2TEit/LyiT7PJYAjxNlIhxBkAZCiyla04aTyL jTTVYjRGJl/iFY4ZVmDV7lnzSVpfvj9MF3BwXsMWSWo9Sb/JkU7L6ZkCkbEiGcQ9exhbro5u3G9n NRKGmx5ut0uD6HuLJXLwIkCN4M394fCk372s18kQ7558hPBl6pvkpxyAG2skwaKporEp2fjnfBJB q275ujLCJ1vtOuOEgGtfqLZaqn+caeNayN4vNTKIaHl+W2+6b0EK6lO94qhwNEa6gH2qkOoWtSHV jXHhSNw8dbRwhQ5kjajiP2BGdjrJHBXSWlL1GDoAdeudmrWMn5cPCaIG4aClZvmEFQYRGeJjdwxt Z6cZFHSBf7kbDgLOjyAN9bT1HbGMwUrvZJMvJAEZbALSINR/dzBpYftZrzOsov09xCV8sCON8fOa tVAL5DB9Plw4qOg123dHT6/lIRB2ErQUgN1pnLuvoWykbL5qtPJCYn60F6fLmrSNFyUdfJarTPoW pNL7CXmyODtQTD7A3rsTpqYWOArSDHQrWkEwJ0yH9m6S0m7Qqp58S+KMDiFRM+I3JBPmmb17WbR0 5oRNVaFgnVcosy/U0UrqJSPFU05cifomPBEoAhyn/D7/AKnIf31CayJgT9yyICtHgFM6O7/JKsgZ wIWYYEhNKyOBKHgWC/lwLqo3R0r9DFO+nXd7612v8JaX6L2jCMDGB5GbV4eIC/vctu9P7OBF4Ky6 YkUt23kx4P+4aAFHQJqsLl923Nhc73JtHmgxIv7hqVnupGywWJrOFcthGdjJRLuWIryjzN/CClWW VhSEau2+IEVBBhudjl1hW4fWEHZ3WWHORajsy+lEN8kMNz7XmswpH/TNmB635llRNaeF94vGq7jG /lAGvVbFzRliABlDOB2akT9ac0oeuRHf2yVrRd1BevzrrQedVAOIMIgD0uadSIW6+pcIf99XcgSX p1xR0uMB8IeeujbKX2kc1uMqWzoBg2t+B85ps84ettdCNp/Up0WPYNIW1H+9QkiNOiA/Jq7w1QRR Ie56QDzUKPycRoEXh/Xg5hqTDr/ZZVrcHsHOhIkS3qMhIPzY8CcfDO66jbKVeXM4atCSBivHjja6 XYQjwm/d/xsM8coTXLkxhafu32RZcwOKifd7F1dG8TOdv+lpGcT3A0KqxDQUahqtUP49WU+kO6oX guY4rrEaCQ7b23RWWB8AJvkC2MUA+p/IEsqDVk6Z22B33Trr0FlVL9AVagiMNpxn+RFRY8gezBWJ 1k4+qRBVpH5fTouRvPn1an/d+s/oWpeSMp0X2QHTlH8m7dfe20lBRNTZ7w9ZKKzHRDh9vBslx13M devg1aR3ZtKOTIgxqZiyItsg4+YrJnVMh0vG+yHHETB6coOo4z1pLj7QxyoF8DYDRG3YkeJTLKQq 19j3Ffxtrz0/RdcCTlmOfSUPJn4F4PnRUv6dxCZjY+82vJ2f+ei16Q1kzqX9mxFGuWKMLIseonrP lf33wlgGMZPObk6UGPiFdIwVlMh0+hebaCzdpWoWLKPij+9+DOCfn1A0sv/BP4SnKGZK9iIwSvfD WmADl/OzNnZ+9d+EHZyDeFk5TUUcsoScD62vxXx2MNxvNc91r9BDtb1WHzs0wPWXeLZKNlOPJmqJ HIMzSDRm0Jj7O7jNXyEWgHMkm6PmlS9FEWlTZOoK3seIbbOEJEA+uNINtoO/eukArZafJB/1T4Ox hEk7lmacBFpNZvhpKqCHsFA89Gxr8nqgmk7HieN5JyrfyRujj7u/DMoQpHBgTwWL7ez6a3r23k+F p+WRnpoViX0As6FPO1Hk48o+MOkVxOUZSOZQokqKCEPAh7cr9JR9XnUJs2vYIvo5kAqX6dWl3qut wv9HnRn38benGT7sDkxFzoCNuJpbUm+fY4+KdrueYRGNwrxTxy9q2isfiEfGmiOf51DLjfj6a+4g tFyIDC+u3sbbdXa6QSOdlspZXME2BlD0R4C8ccbjn88jJi1PAMJe/DydIpf2lViR5jPiWg77/okD bvDPHBuyYJhh9ra9hEsYbUHixmRJIeTk/+AjDEvR5cq2f+vADOMosftGBAEMKMXZrG90lzcfU/Gs FzP7epnk7gaj67kpuAjZYJCxueEnVzATqR7dBRcIYhBx9VKFb7L7c3j4DuX+dCGBdoI0l3naboUY 3nF6dd2yLuPb1dXaRM+OdLtq9tb3UZk+y1JPaK3oRSTUmQH+YI3QVIfaaoGfJ/IEWAti91UpV0rW moYqypAjX4F4Jic8OXRS1qd02wX24n+02ZZQzxdYg9By0543lMygzkOTVYJrCDSgPd7puNYVr+ok neEiZDV0wc8LDZRlz1EAcTVpgwfoDpHfu9USYWteEE1f8XReeE0F1uy62X1ABW9bVW4/BYoqOjtR 8Tzd88Sj7sWgp736yxRTC2xyzHSXxmR0md79QOAX9j5TrVuMf7aZhU96CAhM91nxf+Ypczs/iV5C zQYCgHb6R4RsDCkuiTvBBxlCoVZY/joU1et9q6FnUCzrqLsxgZWly0z3+9EgD/SpuBi567okSYn9 1g/wKxyDBSmPf5qrasA61QJYvljAjK3mY6Y5yNYrEprTcP6qypqmFaua6GK5DMd8E8N6rXkoIPsK A9zRgGqDZjXtWVKT9Wm0wZSZZdHXZGiYpOKDvVyyapx6wdsfjEo0dNtjmaRItkqL8brvZhx7gI/v vf5imouLuZaDHI4k5+4jV1GOMoOTauclxqKkBU0Z16DJAkEnQONV3LQrX0fOQbeegJwnvF+d2WG6 3B6YDe7vM7bR3617VMzvcneLHjqC7iWuPUma+20YxmiqeFz5SC3BjhuCXNS2Rhyz8qVREbo4Nwuw FsLtN+k1IVvh0/PPu1XiBsnTt1ie56y3VQhR/WA1YcUMadLtwfbod/86AUDf7OsNW/nxw/zdSXal unh0lx9nkhExjaO3wxILz+iWGKjzmW15c6yV3sU4aQHWyBzu9drLxPanvLNpfqYJ+DpeKfo/+V3q ZcVVaC6JqbubT/3S+oKJzR0/79jqjEzSuU99l/03O5hXa+BTIBnT62LbRFGsAYNEbcAjFztEw6ja oqsb7cyMtOPkRA7F5jzJLZivJmCVfaYtxSufgCaJCKpti2pj7I9eRz/ylyORK1hKmm6IHhQZTZyf maX1wmnIY2UJk7phXJ2wVHvuVzdcBixs2iVNGNLUCl8kALj86dln2bNkGAsNalDW1+MsirEjBNkR HxuqxQxHTWLDj0aJcMnGhg7gd3tqLH1NG1rjPiKAJZNpdBZpGElzE/49W/5ww5TM+VmsvJSa2Xb7 PQqhC/LxywK6GFtOMMszDTTsyCyF18UNGBPy2EtCS8Yay53eRxQFqI26ewaqA0LQfn7ViPP1+q1V ZcoCeVJ7S6gtV+BaVBAEBHjbgpFR3G/NjLEU/vzBq61giGzKbBk1MCDvzZksc0iaMPQg1dKxuseu lf5XJLjXXXAqzzX+YnSbxXgUz296oCMxNMFmIbOu6Mk2B7A7k8DLgp0YHjAnxKQ/cllwl9LwUIUS qj2qOcbJ89WSpvCmd1aRhSYlKS/u/xvRUdQC0nqYcRBD+gFJKUgTTfTlffa5yDlj+WcKTR3598tU RvCrys7PagvD+An4Mc1iQwP+0jkMNsZcDF83RYcwCK4D7SFfCwd/vj/e/fWbV/hy5/qB7rxZ4ZAP vQe8tB8lbfa4RZp0QM0YkI9V+M8x0qSBB5C1a4hwUikT+zIIXo32dU9lNktwjsDhV22K4RQAJTrb 6TZAyI6pcqa/JArv5kbqfXiuG8OJNri6ATtDvnlOM/A2wZGdFHa3f+lDRtC+JdhPgrwG31gbW/hM E1hiXBrDEKWKeq8R4JO8ccAOSehq3dKx6txPVh1l1KLft45LfaPxjUBSjNmtQUnRouU3cMOwXcS7 8bAHIk8r7lqXsc9yKQEqp37dPoq+lugQ66KtuBqMm4i80uFyyZxDNluG4a6aMliOMY+nCAYK7/bT ZF18BCLdA3V3YyY9JF54sQuks1znHX/bFaimXXO/uyeqXFy6a3UfAy+/Cx2s4PIl7YhjMKjJtqLT IHZJAXn/mzpJcUT8+e7xpq2ls1Z382u/fH6u5ZUDiYZkOI7oCILdf6nOsXN6OJMw4V3l02DhB9jk 9o+wwEFs2pWOu7XSA0CnziwLUHM7obCEy0G2x2Tgk9kXk2EvUVDnPUi/r4bL15raEMbZrIvixeSq m9rzEuoaC/mZbLkb7QxOaFaKjVLvldzgI8gQpIrVkv+WNmFVhk7HdLn8qadDa/h/7mPmYp9AmNwm Tkt6kYCs/1CBXp/ccqkN3VcpbMYlA+mHh1DgfgcDEZREOC0tDAeRZq7XnIBUXZ6z57p3Q4Jzmy9Z /d0nCRYurUpqrZ6PpywEOw/6ewQ4xrAhjl+zLBeAj4VsOITUs+wDa8MsOeCAZETk9Bkh7cecz8os wUL4lQqx38qcbWz5eub7ThBS0QzBi1JqLbo6yrpdRL2lGrffWWysO2J1pUnE0pOt0SXyaHNh6mQm iHPnVH9R33u+/9YTyAEePMxBpMP8F48OU4BIEy7CH/e+QM5sdIhjBHKJtsHVsih5VeIF+MHnyTu8 VoR5zSXkgVWikOSSmJJ2rZk4jgIaGp1cPYH1LE56Esi2NPSUTG3hnojHfNzpFuOayI56dfqZYIgj AhfbS5uuM0hPyO/1HBdaClBCVusUvqZ7t6v3K2ZNuzjRlRqpPrX7RHxe2PVXs25DDrXKnlX55DTA 2ENnz1WuZpCXPkJwQP9RNQBRg/Z9fANq/GHEnznR8c02vPDDSx4wjr77wYsj5y74//hwAuF8hgyS ok2uEXOXFVCqi5J50JFpcJxwhmxfHVE5mKqdZRVAk5bgiyRWZQvEYT+qvBu2tNCz6mtxL3iqXT2U xRfMmZd/nmO1FkY/HkAPX3VCjM5iWXVM0MyvbJYskQ7Bik0NU1MNQE6Hs6AS5w0xijw2a23ozAdK /BjXQo+ae1a9IQdITTMwGbJPbby9JOCt2MS2fVhBQTCkm4C3HkWhGCr2Q7M+x1lKCfByIWdWlgK1 GXgpi927WGcvb6g9CjbgBPOS0CYkj/YSDwCWPfFIBmfk7dTZYGVWhZF+8A5olJwe5BiPUtiiSDSi E5TRw1SRzvBOXoxyMsbajuLf7ciAZB72YKwSbX1vSNvk4ch6mzpEZ57wrn5e7n/wGwxaX2Zdrsqe JI9U5wJkQ8Ggs07ZfqDAUIsZsMaY+AUmx3y/PTojp7ypAQm8jQP4DFcoRafoYHuS8DrvVi9C79BP D0Cp9Od68R2R7XeFiPobWhR6iUaGBvV7XjnjOyMdiM5ItL6E+Mr9C9VnHrrbE9a9ATdKI+nlCW94 Lk2k8H4no/ag3IuD9JgRsTFWPTQh3kqbjc0ZVWWp7F8Dwl+DOcAlJw8OhUzl50DsxJ227Z5w4QzL jScfqSwdjubhD1VEgGA1rvnekW3i48hMk3i03y4XR+ZTP6nKhkBiZfd16kw2wWeWIG2p1nXynh2Y xs4NyeBK5mMp/pzYcTr0P6paQIDgwRio+4CNkhmKa3VbUgcfGdE+AAhQr7HhHNaE0ouIGPMKOjcm 6V+jc55E8Qr4shVXa5VMtodUXTdPQ18BdC5sawSQvDDom6EhsKXRM37xyZrFcOSZIiuA0uwrlclx na6Fg/ltXHHGvHCHpywKTc4AYDnmUkTzmMyAcvonBShYkH+6bEsU7Nwu3xb+NlKtq+YeTMOHsqkr Vakcifw/ZuUjoocPn3lzsTXIWlRGeIL7Tma1SWax5VZ8yxsbfhu395HqxpeQt1Jk2feDF1zsR7Gd QXDSMpVW/ug7YGY/0oZq/oepYSmjKx3xFcMFxPue357QrekpSBe5OaFMkqhj2+NNftjKiQHGx0oP o0yB10kNGVhPnDamHnzaZIA7EDNmYcEZTuAlmW+UK/eODV7NhmS4WNBs/Ju4tyXWo3K1kS91BS0P 7vPBWWByOAgPNjyXO0pjfdoV/syaSyDScrQ5Jf9iOuN2vHGZLAzoWBlNYBff3GSEhybv82Qs2S/S PMMOcw2Lg5PJ7ef6b1DThilzSq69GsniswPFchPRqtetoQOpakJn8zabU+xbLOTmjswra5xpm59T bKFe5TP1xIIx5K3mZP9FUEPsA+tNZxBzG6DsjDpdkFwdHtcCwUh4dJUhQmtYDAGTyRt6SDEJv+pp cwyWO0OC42M9sx2zVOcY5JVE9AAk5qD+5ZYnch/ed/MkOEm1Z6tBqiiqO4HAG4rSW/Vf7rdGhzn+ QD3g4V4IVC3hTrhCXo1gjLsLxNJiim827y2mVbJEZQno5xNt3q1zgiVH1j/i/ey2BB1wNoSsg5+a wFQ/QB2KJo9INifemBObxTf28Fwi19KbK+3xr3ZyZquSrJTl9WSz6Z1BMHr15rW/+ooQUP0H5YF3 djh1zHv80vwjcMYfErtDK3BlO0Wy/LUR56bdVOi1T1ght4sSKQNu+5TesIagk0gHhtkpOKPmtEsY 27WW9Sn5WkQcPteUboWpYypzNozn4ITOplIa4GoyGu9kL51sQJp0tG3A1pZmCklH05EOQNiL/ALF JrVmUn59f/S5rmlDhfWv4gxMxewwZipk8gHGdqZ4aB4Tel3m9k2Up+j6B9O3bvVetbspMVPVvrA5 FcNLf+OdEq81Q5fOubZPKNnU8+SEe/9/RmBlZoJMT20fwZpWrGtc/rrlgBSf/4TKUeA1dgmgfUeL NS3BRnQDhkdipc/7QnNWF//MjKY/7iMjE1NSnGFSf4zqpEBMu0dAjwzc5IO0Q2xgyrhbv2PYLldB JJmyCOrtW+jULnkOX5nfOZwHXDYpJ1WySB+qHZ3ZUVPjqxSpJLTTKpGsIQd+IPDJij9EYdGDjLad v/1YEKA98AieptO5Vc+C7uduKdqNzWriDKnsMA4K2YKjPgGLdn7dd3Y1CEVZmu5maAmPnTRGhFR6 4oksVjY78JutYEo56M3S399uxz1WQ2ZmQ/wCtQByIqGz5lIlEBc36HKX4Kbbw/XlbBSS1EpNG0r3 0/A6fQDU2dG0XjY8c/DNIb1WMzacuY64irwqDqDbuzk394Vh6wve8Wga/7x2YFIDIh3FjgExj04y d/j3gxurgfEIjIogxw0alVqjTsCEBoBKsnMxPDFOa0pRlkEuKYh+lnfxZ323eHx6OMXo6se7IhAr 5n2SwEmQOAmFZGVNZdQ1pn9dlmO+6R3etyjMNFFL7hEJALJuUEGcvAJYRaLH417d5xyuiP3CikId FNqrJ+HohIYYv8g+uSsIcXD6jbWO2GwQgeVXPGZy39mkpWTnAxlo+8WP0ETeFICohUrCXxhiGnmd ydLD+gKJHKG0BskA5EkbU62Yd8v++wtM1Dc2aQ/qz8JnUiUlM80Mxmu7wnp43u/zVAfV1xbom37w 0XVvvPihIPQ+J8bQtK72aipONETk/Aswg4ifRVulPZqcul/LUcN5enuaiiu+CXQ4vDazHZcZrUHt mMWBWSdFVVzqZBNsONFF4offyat9hlGmCP5bH2xfzQyeSPnkaiTRrK548PAig4CDWyBNAhmgOfWN mr5FaE0tNyZ/uNVUWnbR30nNbaIGGnI4kgp4hmcNDaKlJ4/cvunoPnNE5k/BFzlBjcalZrEWfDz5 G+OnqTzK9wXNU1DbM82CUHwAcwvaPC/hCYrhVmIrwMjfcaDd1E4TvNnYn5XWwtHWhCiBkBf6CogH gMIUTLKuKJSUZQgoEiwNyZUSsRE9kLoQUOF8PJOuLKSQLimEkpTHOfRrsa2nA/Vof0UbBG+u6xqn 8ynhfcnaU72MqSyO4tUJk0St48hS5yxxBtqc3KJcdjCiWO2pVSGURiBnqHIsnv8CJVXqSm/LZg7e UzNIrx6a5CMurF51WvECaXq4pAO8//EJMhT7y7OrJGUj79ak7KG/rNbburCh9BtZ5QQZ22J6rzDx J0wxPYZoSoOUv/DVtfeEcFgwKCxUHIQKWPjvJzjhcS/q+ci/5AfJYVE8DAq1h275sbZGqZElIxsR TzRvGMYB5BGP8822e0Qmwl/GXzbcP4dPA6kEuaVrYfLxA+AWEyY27mFc8xe/0APh1zhT3jh7JYQ2 BGKRSk18fHGTXq29SSZhnNDtF3RRyJRH3GEtsp+gbctY6BIbhf05LAWgcb7xRz2m+1+8GjdxtCve +KZTAge4UxYArZYA7EFbEpz/4HMS+BRr6L2J+ZEQuv9GGOc92v7EKGXnkfAXyDAAQhmKLcIKUTWU lc9LCZLb6GgjDwpFbvFMHHOtYKjnKUwdvjk7wAq79A2gT8/jDsmFFBBmqKq7b5qSQUa+as7y4Ryp CtyA0P2PLt6/6Gq3u/doWFpfMn0tHFtoMY63swLmna3L1pw9vhoh6g+QNLLNFjwSpSAhbAaDSCzk e1bB0DUzyjHKj724KP6vRSGVWVGgI7v5k1fNOEvIj1wywTDuLrF6WR388yF0kS4Jq2tAoqEZW7h5 re508HJGiklt7HyeTCZeXbPCY/Tum/ENStQcR92MYn0bSAdNTgpjlrdTNVnL9LTggjSVCErZWRW6 t7GDscA/69gzGDwDc4CuMwlXJjDk5kASDxqK7KlrfZ7mHRevBLawz26d6zfs6Jhx7lmUYcDHxBm5 P/hU2DP54hoMZNtjxsew6BT2lffi9N19s6kP4INeJPbETxIwKvdUEbIkWMK09eCt8eXhPgWh0Y6B jaGEZFb33QW9cLlEIiMuHyw62b8aidvhEDiMFgpbDWsD1KZoctHrtpE2PihJRDcx0QXQCVj+ft1R 61/mAUFuwSSr2pGvndpiDejHmqfged2lFXN8w8SIRZuwlSPvwKdIvMlrPGskl71YdjY1HOtTwCn5 99QHsW9oUNCYsMVbTPt/kFnOw1qsoazfLt3o1IQQT81f/7EjsezGiMHeD9ZKFB6qQWqOxz9Gk/rM jS+ibvI1kzI5616jnyE2V7KZnAF76Xs6U3wygyp1ZeBXDvudDYmrzTT+8n36RDushTdc8TwY1Nmu O3YCjJuLuV6ux/2ccMV1dtzm+F3bOTOVYp3+f+lA10E8OZ0cBlxaBrR0OLrBKYy4r82GoTMxUNqc nbj6jm4yIfBt1ZaG2zRxbOxNYYF3UizT8Bz8OM5OnPRdTKcFYnavreHzV6RiMh3jcUDC+ChgEkN4 Eox3j1liyG5rDqHwrEGhFQPpnXiQxgDUdIBr4YS53sDYRy1eg8VFsdyw4V0nbzyQRCmXmPeUeH9H wWem29VGS6Z+CIVtI9dxZo4ZRoLJl7Wrvp1lz9xLasnAYB3egI0rNBlt0IOEnwVYuSNsMdAcc4YN jepgmYbtDyXoFQPwvR+N0Aw06VhdETznzYgdZP/lLdmXbl//g7uiz5ZO0b9x0STGEKHnkFhD1/QO 86gpuIfCmPLZJbSacpTeNE9UT1m4SI9e33wrLmLSgqoeQCwZSqQmZXlUCz1eXfxfb5vXTZICmq5P SHxgUS+bUDN36iVL+aLue2ilKKThtulS8sTZ/qCVDQ2uUXkoLgilaRJvaEXR83p7sJ6APR1NiX6O eF/0cSbq82JoEYd68IFX8FOFlFKTPEtkEWpgIAcY0oEdslcnQyJ7v6oVVERe0aslnhGwmSv6g70E l8i36PfFBJWEG1EGtNQ+f8vW/aUCevSwNCZz0e/ahubZlO4DNZheR7LjCS7KmOKd5RkW0ehRC12b b1jufHR9wKKKKyfQq9wMIKc/qAz7kHbf1/n7f0Ua5hvxJF/6B2Ugt3V/1Y4TQ5SfGq5zF/O/TbqO gb220Gq2sr21yyXxE4W3Zc7U/aBLXlzSBzDHFcJ+yDAAcpSCMxjBQe/ah6j1T4sZcv+p4n++nPpm MPcOO9yBVGjgLz65Wz91R86C9w+Z3YroIA1FH1595tRk0VEUu4fNhD+RWm89j5A6bssvSQ7qzvBH dq+gCJ1iY7Ii88B4Wn9Amm+Ap7ecMnDjYTf2pn1oX1MFC7i2x0UX1JrlgvgTVxy3A1eow4+0lq1Z qMASq/AO4IF96Bk3/7LCyLUFHih9Qy7j/Dl8bdDRnvh0hVN21M7g7l6PuVCid/sCoaLwKwJG8nZz NuRAODIWurOgCsHnDB3VHt5/ntqPEa+kB9QKej2SlE0CKUSfFwUbsxrY4UEekKobdzzhcrIeDJBK 8xwbjKVzaCKcotVsahSMgiJP2/eqAQxGKmacNuUzAcKcYaLxst/Ys7+4GKW61lXwSOZtfhl9h040 cTM97oINtECdeIMafc12IDUtGT5kty7Rdh9c4YKyMwTPv9mubynBAjvcRMumJHDG5d5thQ1e8hJg aW6NTKbO3Be0gPrpEVCPKJwh0CNcWJltzbkLDMNPIGVK6Q04osdg+yug6qMM1CtRLKWEU8dJSn2z mhP1CmIp5BzlyTVzyRCi7XImF6lj748SQ9in+CIQvN1D+uHGA3l3WCRcCXCPUaovIvSldF/DxHVZ Ee13Jch2ijxyyNhZ4eQEHpS5BwUUie/nfo7m7pE0NOlLW7Kp2dc/pHAO3KTI81znUxT9hkPPttgu bDU3Al7AiWYzpO970umLAF82OnorJJ+dMcb3bwMFuiU8VcePUKRdWlfuqNz9D4HAQBKlBioxUxxi Z2a7EEIvoieluDbtF7hDAZPl/t+nso2+ipGxE/fFJZXEoWcO1P1DpFrCIbnKNaGuI1vg1JlkIaBN MtuWzmfaPjJo9TRyUof0ngQk9FiPWV/XtKO4dH6jVa/rA4c7x5EpFwJe//T88Sh6TKlZwUd6obc8 X3s++MhJks6VbrGpKe6eSCNxgujawYL4OsI9VnNGC8bDaDs8CRrGGYUpvRcTCDPW5j5FnxcFF5QC WDf4C+X3hLBBUuVcGWso9XX3StsbQq5C0g+006C8DYQ/olbfHdpqXCGi7WryzvIACrVXWlsPMDY3 KLZNI6zdN7hKKJAQXExJB63PDdVWafYpARGz36Pe0fjQm6lDBhI/k3oZjPKcSVkwRLOJtDp4t38i BP81HoXLOVKRUXkwr13PmgszNTAkhhvt++xCR+BxIGVcgL+8KxBuPd+1v3tggDDsVzs8Ahw9WVC5 3hXS28bqXm5NM0xJR7zIcgKQUBbSto3vKYMMilk9FBT1FegpQmS8L/Di+lLdT+LKUDziNqXFqXz2 WTsKJAoguYEoiW6cDRFZZ9Brje5mnY0l3WFS3BrLa0S/hHavo3d6b4Jnid+2LwzC2hVz7ODc1w1Y pXT4KGzIqiCrB5kHDt8W+womAUOCjo8J90WEr1gmvHwIgWGlFvXBzkEo2TwW85xFjlkIXmLLd7z8 Q084B4D1VVQnBdzx33/97f6UzKcrKbULXIjN3CIOi1Qb1gLW4kKGqy5fCL4ALcQ/9zsSZa8aWJ/F hi2K+i3XCuFSR/KVEfCOEo7rZTDAnpcFcmRzKGAx/wu2VeSdSk0W0T+bRu3U3OvKenyMf+RCIuqo mDfe5yNAHzXrip53GSEuA4yvHpK5ZQA9CyJop6Rph60EZs13FBzA0aCyPn18mB7JthKBiTB1qPn4 oM4oKwmCOhv+muixiiiJcYgeei/A/pcGZLpV1gGFEGSY77vsoMK6+wTdn3fsKYqWa87NjdZHsAmk /iwWlvoJtNUdg1WewUQ8c/lIsWr4IlcsrK0mVoWS2etMuIBBlOgoPmd3ptg2VNTPYk0tlD0xDJe4 BCSu4gXojjTDU5ZQTC/Wlo8FDOajTTJzyI4cZIxyWeF2Ym+X6IPpKx0O6RHpZNjHrMNHI0WmG7f1 nwL7uj5xInqTgYj8L6bs8alajnMMrHAfOnHqhPgw7NQ5VrBJQiMIYs8ejdoxqBzuM1HRU2fljaz9 6cHr7VYGcvSNfwnTaDN7bHP2+kFjwFXXF475HYp5IOeqcDVgOdKSXgJm2DUWlCoqtFZX+6zU29ou LUe3rI16sJ5JE4V63f7CKr90KpaHP3sR4L/9RqSg+8djOkHht0R8k6ew2Q0FZJ1yZZMGs0wadSI7 WWhiR1mK+tWlgY3qXDmg7lRFh9tbt3NIjz9AC5ogAKuiJCdho/Qo7Ec7lXnTshIFlQpQVh3IAkS4 pY2gzheIIEb6M9AqfavaJ3kTRjVqL8q36eCm+zOoSaTctsYpMH85Nuv+K0vg+5zV3SqCU8G8aW8b onL6w4KIrt3zr/Uu/7u3FNjUpERMSzBpb00qn6mhfoYrFTXpCeXeflQ597AypTloXkfQRal5A8Gs ZJvHqHXEE0DzgGX0wQlv/0lz8VWN52h356+APTuG2IBlcYHQoKle1yD+LS+eSVIOtgnARW80VZBk zyvLG5UOd8wMWtoEnCPdL50Pfyi5bIsyss2A3XkGJ+t5gAsEilGiIcyfdzFr7pIYaQTTuWS5+2U+ y/KqusJerxWgEBA99y1kWtkSyQef0Nb1iQQDWk3K18j95r0zZqj6gtR2mb9AsUVK6d8jk2+WZKTa XCKf1HOyD+L8xuaUnPcSscDQ0CUA68gY5rMuBoVniEtQZJXcZzdsQe2jPZyf001pBrwKYWtPb6Xf GbZvddcUg3qPSn46FsCtZKkTvh7HX/T5trb0D6Hxs2DrHIyO+QBGZk2OoIRvBpehm61i7p+tevMa Ub2FAhwTea56wEHUJiobTHqJH3Nsi5y2fqdq+JUgBxmSGC/Ga9Kn37xIS61PhhzqYLXNq297EnZR Ef2/qhbipTZZwpoe7o7OGtbVjHYH9m0JX+EF0eOu6aflv2uimd7xWzU8DbV7kWY3io7bcwYQIhiU 7Cy8BVFzpfLwjleB5e4IToEQPLF0vITD6fUXRafIPcLEvzMWTh/LvdT5pn2bW/fe2/2YZ35dfJ6J 0d0UiArj0FItWQDvDvBZrkrbqTkDgC9jgzcnBubIAUjNjGKYOG9rqcj0GDbNG6/RsWS+OoBDYo71 NeXrdwW2Af8UwHDUI1hsQjcoC+CIYpX1Pfq2NR523dLSfA4nPdIG/98h5RpgzVwLecDcZCDjff5a IC+tu9Bm2azfs7GDlnnqfHoLn6Ac1QAWICKRBcdPgl+tefMlCRroyyBAuaF22foo9SGEPb9HMWwx wnAsAaWvXBKyJwLBYI+IHw64VYU8gelXxzHAWtP22aQel8jsvewq7dwe3mQ0sgTN3Z9Tj3ed1QKW bln5qjPT7PiDxJuBf6IKWEEAIQ3ggZjpDnDUqwriY/of9uu8eM34d5l6tf7dzr9lD7CrlyruN0ep /hc68HM954AO2PeoC8UORyAgjymvsGwR5sRgtEFNTWDassijMZ+lqVA8CtZKLCnltckyWjUDrEdj oxGmoqW4BxZxZRsUwjzvpp7XqVviEDrn86fDtOsAgMUJJlYM9TzznD2XY+ygfEGk5pzP+X4Y1i4T zOa4WV0fCkH4yX3ywPg+IChlX8RqclTdA+IfQCbwp2VIu7ef4LD4aM6TTOuuG+Xpq862NMhpIF62 8+BeEEsv+aGwgOB3LKKJ2hR5BU/rnA+htfzq4cKsj2IoxSJBQpgeAraXTNZkSwZ8LTJt1AKtDlTL zaE1WPnSABOW3lYKNhDzw/30ez/ek25fFN4q3rDfo9D5eqDEpxWhCgvkWB7qkrSMMZPHeBdqD4Nd +NnOexgDrFtenCoVmHhwiwVrAIOOM4YYGVYvIh9pxdFoDwzHQRrfus2NJCJmEvH5ZRJHM9uSyAnM jFpq9e42u5FiQiBgRL/xMmv53ySyXGGnyRIwEfWdYSigY8MWBc/mWsaOY/W4Btgd2EIANiV335VM 0/8DNXII33xgeV4CJkNevNogeG2MjjOtnjKX6xp5xMzsRDSyA7Xo3Vf5n5aKNmmWpdvi2Dnddi7X vDkx3y/uMdfNtDYEmTaUeSrVJzwpQ8HLbbwmOdXuiOvF/vaATmDnXYf38CGA5kCi39lIfluB5hYX ZUU7cLx7ZCXgEaNWx7U4oXEG5hk9K+VMuNVSHl5TXT3bjZAugzSmwCeYUreYKGxadstya2hS+M9o TTcXGBsPhlF/zNQWCG24KDshLhoY9G7tMvJMHeF8OAbV/fFmb2sD9JN0DTCwzUuw2Gn4bCOvlkRt V9zpIJo9foLKQ5CzB+Wa3rGicYRkv/aTVxgZUn3KN1OwrgwGVRkvq6Lj2anBg3fclTJAlZN9vNbq G2NMh/AO85Aw/dEBxOLBEqUo5CQFCWprX9R6KbrQlNYCejnVC770syL0cHYVCogEgDQxxhLYLFiV /eHVjZoWPSP1xm01Cz1vCRWMiKCsCNvaam5Y8r3xvPmgV/YbHEQvMgj9PNx0HSE0Ez/A9ME+DHra xmeNIzVNc3kJUGZaDx82/iWGSLxXtvrpCd8Tdm/ocjr9mWPvxM8fQSvvB4FP3Ld5ZeFaeI/Ad92V BNFQzLLWPwqcyxWMEQfiUybl5KULN2BNQEnl5snrR086ntN83FWGksav3xGKalb6Cq1WQOfm7A43 mN4oM37+eaPCyUEWACcniLeFT5Sflw6LaDcUo6CIlJS0DcITyF/CfvJZake7dCkI373L/Gi934hr /Xsx2PdSujj3jzCRKoP8M0wS4R6SYbrdduLgtggnGt96KO/EDCjUsTiuyXSTVwCsYUm9q/h9u3rM RfaE+LWUcvlpP+3jSO2kCOw0y0r+Pc0zl8BctMUYCkScr/0KDHpp5EmJzpWzT8ZOxqKW6pUwzHsd AZo6YjcPpix0FIbCjRzn5SpGHMvd4Zt37ZiVdCTdfJ+bH0QzPiKiIV9NCrSl399CevuTI7VX0IPV B3i0VMmhNTlfhCj8vCdindIwNIvEr1LFDCShDi8hFI2HNBrkwU95fzCy0ONcmqWrSvSN5VxpAQe/ LUPaugxV580qaBoixBR7YAGFqVPqVelcs5D1WR1R1kABhIWDRHcycofnqKmJ8nJ6Gq77MhLhtUOs 6mg8+NkYlnNwof8AcUko2PPo8MNsmR7F9KMhQ/teuZ+fEGJc8VK7L8av86S5Rze9zXq4cXsW0Ve8 HplwZrOfRIIC6dcD62XGM0raTP3rr9oEKKnS9W1vnlW+y+3nKzc1qM9VdvqXJR4UBCs2Ca/rFV3d mFXBq4jMbSrR4teB8FoRv8FebTTPVLImImHbcDgYvqxN4LDas41LoNyh8/r7yEYnaO6AGpeMpdiY oFA5JA+RJE1KPqXwoLOGWlIphf1P7bxduArawJ/FuBwM70yqcChvGYvXIbe5sYFWPLOCHyCpNVJb as5603aaVPFWHiFkLhcCfItLdKW6uYuYIsgzCjpoFoKCZl7YP97G8EG1P6MpI5x0etdAlWoJAUfu DB7vLrbDiqBTWWn2XZc2JJJkofNKGtevvPr8P9sHW8eKU6BHoigU+CnTw4kJt4ixNhV0Rgg0vAzH u61+X9h5NDiSUYpgJuPMypZbKYca3MFvWj6FSo+xBWKU2ITcUyf6JlkI7ZPSia6krq3eTe0iHJsR Z7Qgp7NIk52Xv4rYXDiv0WMW9tAPk2pneCbrwhZqzTKFG4EYUBFayRaPRV799YzbXvO4ATbxElEh eCQsxQkPrV24qyxiVFoiBp5V5NJD5Zt2dT/860wwN77v+GjZys7Ti1ushx4cXhYEBWr3QMwzo0Sl mg+h2YAlPllWKKsOMZ2klrQl600IMZ8cfAjG6+f3mTiPSZnG2dAIKM3DKmuqvbml58OlUfODpbap se6fDKmBhQG3eUj+36gapesrFqtWkMHRWNVvJn6Pulu59wJXzHX/AcMvTu4CrNHtBv/cdxHhZOSL oxDIGONVM26BvPKfa/w6rry2VUPUJ1Cf0Tkxm6Z2gdbqWO+s+MdEfBF0EfbHJDsE9oVNJAtGEDCl EO9jx98gIarPf90H1QFpQM7qZR1MplpWPYm8F7NHLMggxRkNMjsj49llYmyVITS9SggPfx73Hg+W DZws7yBAZaqn55cV/Neb5TdjBuFwrdRAnWKrKZkMKs2x9W4UCkQd1erLOgbbQ4gixcXFdXWqu4JD mBhadma7BzYzgGAUMLAt+813GUB/Ly9Kxrm+axzySm0eF9jRhkP+kBcDjt//HZfG1mhk69DyB5xz wj8wGoYSMFNjBhLyvcb0yKQqcrtb6Ssck64h7m0bS8mLl+lxMKUbidUcR/brQpHed7iFf/i8c7Z5 BCcX6FM0lkrlHeDaQVKTDyDNlu5g2PLqT6ujzBnrQfq0UMlWqiA/Df3pHGM4DUzJcP3yFp4W8RBs wWCfLdMKhI4c/LUNO5VpgPkakYYasKsUXpyxTKAklC6Cm1gdXLPXZo/FoNHyxfhtj+5WgmjwRgTI QRVfwN/6zifwz2MkDKO9WkpammTI8mJkDYCQaU7JN4EC76sgj4e5QjaZB9L1e8AHmgEKwDriwLGK 2DEXxTqCUGnsrkPkrjqciWY1+NaFsik5RIjCUdUy6j9dLMxz7mgvMvnnxV0bqcpuAbs8DxbYlOYH Xuvxf997eD1mj8zIV2doHhr7nTt7CZkJdQVxDs2zrXDj0K92F8sDEQiliQ7ajn7skdwL7C/fe4DN bGr9zFbFN695Hq+0d1ujxWJEOGvWRSY51QDcKmBvb/TFmbnNWw+67WnzkxHaBnA5A1sJ0Krl/6P/ AWEmALpHFidIy2h2Z7G5PugFhsbn1gwz+aO85GekGl3PQ7cNEc58DfAf8gQ7H0qK2Of3DPutaHXE +tu5J9ugvPT6gP+ahkjb6WKa1LrRV1enabZCSxnciQCw+5zvpQCn/a6eE+LoENBnVHt0Iylc77D7 uEjSy26kT5zf0eNKF/IgarV69TPtbW2Vk+PY2/V1mRl5sVbnG93pizM9cAx5zM3xaufuXhd+Oq/p V1TZ1xElHjRo7rjlguHpN7ZtD7ahWaYbCKz1XE0EEQnQXucuOsb4zMtMm4u+9/n8iLDuAx7hh45q cMajCb1dQO+1V7Uum4BpY7hVsZl3Ug5JSybHvnd30+u09+ycYoDsDbwJUetvEh2cigG0Wr+jrH93 eCYPq0MSyVqBIML0h7O0IuFJc7Ox4tWQPiJlmVncOZqTNhDwOKFlTKskYyUU4DqKQMFcz/Mz151X l0ybGT1fCDCJhoy1zy6GEmbEndK1hFRzQbBc6qLH55627ZhEXEWWLPc/ehmMjcBaWWy0Pm2IeGBL gb7Tp57SrkfAg3hW5q1vw543t+HNGlvmxNCG0eaq1kloWra0d8ZPPWiIOgilA4gaiPS2DQYmrZT4 4xM3C+bYUly0ndcwD63SSWhZeo4psHaZQlyi0qDMOtUYBGmT0CnYtX2VbLLRpH6ocepcS904B906 F8THQsHGdruTvD1CHMi1Hlljuvo46a1OF4kRtav0S1U7jU0zabNHEW56ZhFOf3mvNHwqdXIq6QWx eAKm1CsOTqryz1iBiCGpkeapcX4eGSSr9VEJr8qTEYbR3dU6/166syK2XRvHSopxhAAtoMdUAx+B i7ZhMZXrArhXAdyGjjDFtKxVckMl/0ZA4zYhpgaVS75HcyooUkdqdRTLhzjeLAB1JlnKO7ttNCpt tSHr/cgfeHCuBFuAZ5ua1LZoTxgxgjRT+nadErcKr4EKVQnGSduOYFcuTCv0T3ywjaGjgBAm7czq q1nXtHpM8t6Cz2Ymr2vtSm9Ey57DMe2P5guNvJjGfMLNmZNkBEHFUv6Tc/XnJohJIagWEFZkcOpr F/yNx/xZrCRz5Q3pAll0OHYa6y4v5crqrepX9hNF2Alr/cm6XGZqk4flHP6/9nP3YlVXrHyRlfdl SmvXmhk84dj8vy4Mb0gMiTRzTIEncT9S1198zy1+saekaTwNEDSWeKuZ14ziXoMRuDaR/0cA8OBm YTp25xqrjT3YE2lq9uz4backtXa04Wo+UzMArreI2rn0h7cTZWURfpdFPenT2przAn7d/l0UiFBV MuGujsoGPdJsbJlRjKaKf17oIlHS9x/vz1JOOUDtegfxK8joBKCUkrx2WoCzTtdeM5Sd1tdYnxPj 5UtvHzpt2jJQJHl+dT2a4eLOcGbatkaRbb88sCGSFRz804GvN4TkM4DTUOkiNFvTr7jliOCKQOOb rHj7wooTulcHlGlGAHfTJyYndtwpgpi5i99NUG1nx0IqGZ9N8ODWg17SHZm5xo6eAUw480d8tS7B 7qF7fhCVkUIVZxRFhEoh0hsTm+Q46/lcR/s0Uh190RAnDGbg9/l1ZItvjyqV03EyVbolyZrORVjW UR0PeZTlytHMgN99sewa00TQugo47mo68CqF/TWZ2VHhDD6ZG2eFs54iR7DReZjacZs8hbj6EWzB 8aUbje7GzjNvHVrGnCzjCsSPX9ADTzqab4DVmGQ2LYqSHOlXr4RLFNgHe6Mv6OAYt0yHUt1Q6Fds To/MhR1Q9S15twOWxTqmtk08TCZXyKUqEHLpWBrzNsmIvwptfZ89kPiXZ1Qx4VMWQUHyOt9d3gsJ xjshSuplaWVM52dMWvk4+2uW3IIURIYctmUgL1jgZD3NNvcFa25TxWQmYTOrP34gHqocnUi2Z6+Z AL2sLB08XbYj/ypjzRUFJbeYytqfWqK8kCZSgwxmBqndKt0+OiIqnbpV+kfi+opxwVJS1GE0oylR GVSYmJN6t5HnfM4K/e4IPqeGlaFsm7CysOR2FQqYv815oNkbk052cuYig2KiVSfyBUaA5ZRWr2LH miIVjbdFtYM4+tFF/Qup7q9VXjaVeMHcXkAiQWyG0QKDn1jyJHiyijlNIXadkkdWFYP4eIh22LEP 7wLfTpxAgyRkPwDnRI42yS3YOXaGHBVbjLa6QDRh8xdM2pE8RX0o9SrUc3XfcKHjzknw5bJeg0cR q1B22YvFEt9BMCXYxVB5I621ycXathvP11gXTM+si7z6pGe7I5lh2bRYyfvAZbSCx+udV6Mt8Aud cCqQUpzG19tj1r3b7ShFaz3B8N2Z/qaFIiW3JI8hgKdKRwj7dkHZ450ByHRDOeDy7avxAYmH/GIG yeqWn/nZqZtXddE0O7CgI6jvAhIhmnkWf8p0iMGfjQwYuNM967jE/X+QLwTrb4B9Qbq0H4M1Huw6 iLFB9gmXZ5tlTUsZOV0a/bPZHjBEucBn7jkX6MPTUbJK1IoEo6+6ws/tOVfm/ngrV0RjMvIk64gi U0cxnWuxdvq0Ob7VxPPHXq+n+TeDC/MuDn4a6D9HrAzfuMRZIF/VWe8uoa6yK/glfcjctjkM8kXo bIbswgZ1t6/Hc4crtTfiJMcbD2kRRiDbhrxPg7M6mGICzkR9rSO5K3PCSjj3FpBF9X2apO+YPT7a M7ww03s+uDSsXKT5gnIgb/gvTLKo/VR7tCcRrNAJE/O7fCUFF1+DvZ1y6kAP7wBlaYMMlq8JLs6g pR4vpas9JObae2D2wLEY4ntOfZqTuOLn9EDpwwh4zqB5bMGQTeWE19MPnk6buXCg12GGksvILtAL vQH9POGInHtEit1xp2AkKd5zMqpnHlxm+hBKuEqwEaaycFUsHJTnxNB5nl7KaHEXp3tw9UOdmfeq qgbu1wEnqJB2dxuWr9mWJafqCelRLkGWtcRLPCuUlh2HJn3SMbou7K0+eMCxTsXNmpLL/Ga54yZ5 T36ciIlqTkhnW8vzS0JwjgVk8TwYJEZ+9wH7KRgLXpSGVtaWqOqvTk6L1t569O1ESqcpShFPgLAR bxQKmfwu+UBm4KZsKDONkOfQpU0fEeFryPd+A0hH3RY3GqRD4sNZcPUAoOx4R7bdDrqcU3NMksLY 8GgIzGWO91xmzNml10N3GGF2YNJtTg1uXy1BnHVbLYApPqldL8WpU4fv7FD4PU52GnSankvNWV6/ 4lb79F11U080CxES9fGye+1GUIPGxxgPLg7I2seKI7DrLbq2lG8Bfqr07MAN1UScX3E2ZwHU/0G4 0NKs9lF5XM04wgXWpC32WLaeCbhTtQsERDBtTi+ROwiZnoR5+AdrZHB40AP9cuYUu6TRrrG9urO1 SmmQ9p+xWdzD3zt/hNG1qrXGC99fgtEkEX5YQogtjhmrFKXrzuKFkCrdJli2g375fjDozaR+Duvl oc/kwxsXcSWbOdZIm8AZuNpuuG4ylo3MK+f3Oxlv6hKC0AxhduhWQVGFpqCfZ/ObQB6nmezZSJCL UtnQWZcRka/njNadqQWoJ6JxhHyc8t/Kv7xg5/LpvE9wus+tP50/9lWfxRIrLH5S+lgo71y5vS5u Cob0B/DtJNpcDx4JLCoH6ycRHtZnaHToSKmCT5Cj6svfWNYl3PSbHlgYdZ+v0vfrFLdfgD3WoTcn N1Xy3AjY/xlkazDH2eRkdXneohtHFrzwxcCdm4ow7ER0LQkWvsZgihxTKK74BNhv0EPRwD58WUT0 dmQ4lk2NsPKzZbavTqxd5a9iL2aPdhoYmfLVLEVIGWxeQVvf6WACmqFGmDBblnkaA0NpG6noCfgu rdA8ibtkSjeMCITlWf8mbYiWdXseK1E7zBgyxOWipeipVqLvs5yU/4uOJnVWzPD5zUGANbJKc/5Q ZqbptIjXNNQqpg/av1yqzx9aOZkKXvUDebK5oWh/debZRrtGZkk+9VoFSlrxcVQWplbQW2ryHwjc gypoFeoEW9YwlrwYpsNLMcf1axxiY3UpJlIWd+Xryq1DfYyqnSkOsGdqqJnPoDsF7DyQUUxOiRLQ thc84K17zcwRYRo1f+JXEnHK9SIUmWiJ2e9hNhcukButkHv4uuN3TLWVqQApJyPQrDmtoLP970mB nImdaMa4Ny4Z7T094JT/XXWT9eGb8gxiIaW4igXU0N1FB/cMJB+uaDsgXElTDR4X1n8J6/vxEM3i VDgT96Ftewbx46wMt6LgEnkZZI0gm2TSlCDJbRPU0iQVqsMMgoA8Mt7CEpfgRqZQwfdYzqOsl9el QqiCOUbblpA7jcsuoBt9XIgBR8gSrXWPPSaJd/j0myxPUOjdGI54SyRvamTQBiGs8DaO5f8JvLZr mlvmTOu7w/caNKdA9dGRMLyknxOHjhQs4eEqDSKcjcHmi3id4joW4zK4UC2qmMPOXTGjClsQoK0q 7gNZglk6hrsIvxLFkDcqsh5ZvFpqDh1Wew+OHowSVpuXlo42A82h2hgPTtIkmsz54RUgahJyPy61 /8LfwEh69jlh6yeJspvdKbJLFdLEWVr8bL3M61hFP6TppXVaRivneFretj/DRW6qcgepVhFMZHH2 y0zU2e3Zq45W/FeLW2MZ/MUtmDU4lLGp/kYqWFFBE+OQdvWzoe4YLeKQt2k73DvHYrHKbCRDNZHD RyYRdczvAbPMOTQ8JnTKA+c9ENTZ6sh6XbIpFS7Qa1JTPoMWFUQmV9Lvbc2BLIhI4jG2hnITQGpN Et96UTnLO/MN+qrXDGxg8v8bMwdQwRfJja+T8FUEAla+/rIyXyjDEcAwPLUEELrDK6rV+NuLPPAG 8GpQ2LCIeQED3w32ZagswcGrAIji2bWdqdFueBcA3+NtaZ3btYZbot743iotbq2S+u+R3KYtqAv7 QbJ2X8B7tCdJNgP/bwsYxUQrVgnqWHGHDjpGMxKUWzJFjNL+ogIhMWP0EQFqZYH0nxrrlDMVbNko 8lL9XuBIvovAmBHkfw0zPyt12vjVQ58Z7VuRpR7ALbpoXFuQFM8RQMC+dXPVbFG134nNtpIvq51r LWRpXFCwEXDI0HgtFVU2e2d9JK1F+6F6eHwWcZhskL+FBA34n0oFo5v2AgK7kw0kxidBV2d5vJGU 4wgzcFZPP36MWgAxz/Zl1WfMHkUITr7YWeTo0lSx3YtQJi5fGQsVPoYGyWxbDl2U0wmr0gWAY29D 5Ch2MKc8s9VRIVHIDd8jDZg6w+gjRn3r8rglsbZ9a4tLBY3Eg0i7ivjwqG4aS60pKz/uY8G07SLV scXD10B7PZk+w4YTK2MX4CKo/1FT+RfRIkXXvzhkuBrjTvSIMosZrZNfWmJQpabP+YtzdJ2YAlra IjODVXO9ST9OLET3o4N2aHIMGPRpHlWlktFGhEEpqYHMS0/i1aI0U26zMzkLIuzy5ZBc5DLg0bWV mfqS7/wl2EDg/bjgw4RuzUD+hqalsSYy+GAW4plamfwCMzkpS0LvVsfs/R7XOStX93tbH5Jj3XjQ OjBcQ9ZgQ0lIPAZ8d9vdmL0kPPoFxrfB1aGkwmFU3jcGGayfPl1tMBL64JTf0B8EWMFVlTc4sGtD MAh1PraWt3B2/+cu460vRD6K/m68YxSge3tQhZuvs8UvF8ifB62gDqmxuq8kM7veAvJQaLurhStO ENEaD+aPQNKz5lHCZQYGhG2FVpRmLJJehvxBFB+RmV2cFhga7rK8RCAG05uyieTkq42wSvTlgVUg AYd2+MonSzIp5BK3aYAQTQQvZdqzMPQUKTMrGuDp1iC5U0lJbjy3l3DwLq8TtrLTQRkzb7z7Gq25 SY4yH+MIMvrpAb3/OeDd3gwdf6Nm6yvH/V3vibRFY6eK+e7HH8c7iYDiAf7QZ6Ta//dUxvM6Ttph lYq7k0C1YX0tRJ/UZHVN+eDurPKDZ2GftpaRgRFHZqI4XZJYLixGIKNUFGwCvwKyfT1ZNr02F32u DcdWS1UChePRNxkAAZnDXuAdzqmhNQFUP+2BNK7pPYmpEyb72kHRzXXZgbSW1/VwWZuPG6yp7zS5 zHFPLW9GAq0oivgtVYm20BWafJLTtoSTpBqHztGLxdMhJUvREvZwHd2+ndHJahzmbIylz0TF+coj +CRM8UTmOmizVaPYRb+h2C8nJQAlHy9knlTXX2tOIx70k0zYuQalFCRak3QOWEiKRQBD6YuPMQmU jaHt3XvcVnjhFB8ryMKn7C+7qcTJ0PM4ofSkUkblmn5KTKixGAsByrj6OQli7yHTTy649J1tOOrR CzpZd5BZIhAopOcIT9T+IRNMC3CMIGzJx3gSCmf2FUhNMQtrPMkALwt/2hEeX+DC43tXlUSMHgZj WAbC4U4gM3/5f8gZgVdYOmRHugINVLaqn9KyDALqPzrl99MMQeyF3VMfZyTkgXEWmlSvMdy+mykj 9O4fxlqHhhu8tKKqs2v1SpoOXtcxRXtI/M+tXmjI3xQBCVvxTgqODoSk3rFxSL/r8wHXuOma1OZT 3WqGqXuXZj50ti6GICPGYEHCXHrjfME+A3GUGLy7rdvz2K/l/OCTTe/XRbpa8BuSm8bKrMvxqgB/ MTrNFIf2ujuDfniknFRjvzbNw9kaJIjoNVS+8Rli59NqYglz644lL8NrTXdzeMadYHWv3jijvGyf 48AF4fEQxlA0i+yyAykSCgJWyo0OvTHHsc3cixjSh9q4k+WA2qamswG87xxUXvR7gd9n7OskZNU2 9QHcgg7CvSpr1hcpkuchfON0/mryild82TGl4hgxSd4q8bHa3/NleX0tujv3MizQ5NBUrwhxQ5cQ gB6cryAc1x3CCaJw7RVIVe+RsFat4Ee9NnIkpgptBBDeRrurOsVLgT+ZkuNnscyUFUZvhKtXHvoi Qir6G9PflLiDUxapCl/hDZiphrL6x96gYF3GaajjFNztqr9vZ3HuebBMh8t8m8ME1hGuteKTt++D JltXH2R5hwzE1PRb0aYcd/3ilNXHZIsgBydHODuyOzK6ccNcNrl+/vnBT4ApDeIGfySU0eU0Y1/I 8ZbGRhlPYaOfD+EbxXXbKp4CJLPLsZL+ApLFrfCS3zSz0cgBjj4xNt8u1oGnqm7mfmSsKxcjSzwF ViZZSGn5kFhT7wqAlqd4dCChmjpe6tUM6raeXF1aYJWwMOLEuB6qNFdoF5eLPvGZg3QmFwmPv2He 3rcKEOvRQgGcKgBjmRZE54azv/l1mLk0Ct71KQ6y1Ichk0/TdbkBxSgSyG9MRSVSqarJ9CpDjz/H wm0sK/cmv8G4dYEovaOTuNYNyB26tq8KO1/eE5ee1EPqzJk1lDnHNzpP/OInji+ysJRxGEr4NkOP j5E9D+fnnXVVyCDZNOxey2KD7UrAdDhaRks8c8hamShuPca6MSBXg0TcQfh4COOJOyEknT9ah/vB +71JNjzxDcUysJEIdNXHnkYCOw+doaI5VyJhDUnzSWgg+TJGI/iqOxp0yrdpVqIhx9ad4lzlBLOF Fu3phkc8Mm8XAdlvUG3+t0rOWJZLeZSIyC30/1GUsi+eY7mPSZR+lkrWUUFmbOhbg2sGQ+ikdXN+ Wzj1DoIrGk6blSS+bstggkJOgOgxU02UuhP3JzomYX0whTcT1k9zEdP/7e2M+yyrukSt0zMKHPOQ x7qH83Fa0LDYG/XyD7U/ReOCoSrDktismhLtEnKqZGRUssn0B+y3cj2v8JC2nszk/cxW+Nl8POv3 wec48y8UIzABmui0c1O1MnedFyHKx+yw8EY/yH3vyTRAXVtToUmJsWDH/I3SDAX59G/MUZ+SQNP0 nUkYPWwtwjnJR1Mr5bonxMpBABtiDoQn1FY040YXz3OyGtvNyArCACI+TCzFPmDqaept1BrvowTK 6yybNzvNTYSSR9i0cMFwBbx9opNv2IsuGUqGbY/QSL4/pV/U7J98vxmK7mXhTs6Ai42yxrZKjdaq SlC+uTydHHEyKBFonTRwtVzbFZkTy3fvJFD7aYvUxgbfoEgb5GS9Njopul1HqDmNUgvMEbI7On9Q N0K6+wK5q5wK4MYtlw5Frq8YLv0CBKVkYr1Ko9xeNihoyCxGvTNKDP8GQMcYDetLuCJMLhxPozkx C/EVfbB6MqQyFzbz/LpodNRGnP2LkioPYvE0xX1I3m1idslEUrQ2RbEBLplpfzzuxRU6mwvtbVcm qga3wcqc2owZf3FyGH9CMR7pfq8dUJJs9YkxeJg1Ra0bL5DjPSmjezlRQwqTU6RkDaWfFCQtz/P+ 8DFU9pY5tHaClwUo8Pq7JHUSBOA/37p/81ACXq0ywD7TYj7+YiAzQdR/NPsurymPY6j+LV27v0qF I+qR5sO2PnrEiTrory22f7mxGx8aXqwriq98QIY377nyno8x0536rJhF3lsrg1DK4XTNYQuI5wZB oHWs0/F/g+q+yXQXo5/T2QAQC7PrilFYcp/kCqYR2Poy8BZeXoOgEgpd1qRGN4RLUV55VkG0YCtk r/MsIBAHisMVYxqWUNDeXs0Bms0DxO5LpawYBBYKbIryNFx8f+HBfFJqIOG3DL1bB81zj1EnFg9S rb9ezhr6AsvKyX0xLWEpSu5ZtDcLM5uetSCL2Sp09Us+mj/CkmTOVaRXK6APehAPM1bq16+8RW2s GIthtwUO7UHgQyyOGIvVisRsYXoyitVAfZhmVK867zV5iZumE9j1edUgntF2JGNxyuFgLj3mw5Dz xw5pPylM7TPZBl4hgAig5pH1+ExhKFTecGuBTK7cEHMOfEZWLHNkjjaNHlwlg3fPq18VI5xX+j33 /NHrwusqvFK6ZYfLFpiHnRkMoaUmX9/VCVQJbxvAkUtQO6/nEJ0xwZuZqURZNxjqvDij8k8opMZN TYzzMoG5L5qUtlLMF3NeCYKQnUdIMdxbFFEjvDntsI9l/uHKrtIriUadPLtVhjqJZ/1lPGnPELF1 oHF4fnpWEOmb8Sr0OlvLdnB8sE1R/lP5qQr6RgN+HFk0kCioUEVsf8VWvJjqB91go5mOmWWN/yAb aPvJ6gb3P70rhXTp3DEANfx/Jg0PWvXXVABsDtR8LLg2WhedSCSMbL40mu93ThJAESY3WGHt87Dh Z9HQhe3CcpIfjIgl0EJSZ6+o9Y9Rdo1/ScCQeFQopTrYBxwnZnghtMhqvhZHnv08HMu7s7oLcEyA UiGSnisYR4UWEB7clqVv5MZCORZ628zOJPGEpQdGaHIPs5vs+wnl7KrA+kkED5s3kuqKsQe3gKlx Q0pac2vDBmOpeaJZqlOxlNe1WEa2EVXeaJSg16L9ZzZ7PODm5KyhnQwReoRe/N5lNHV0CYQlTG36 F320b5qCbkz9wJ73q/5zd5cyDxcBgrIJepuCWdlKRHNMwidV3UKZvItUOTXoh2/nk8MOT6O0BUfA 3iGslx1NSUWkC6NPwHLA4/nWih5pOGV10mrXKzQPZSaCBdW9d6LQi3P4xFLYD9kzv6pGcIzOYEj2 EyyLF9On0GxHRJOej5EJdNkRaZ+vvoyWCHOAMfiOu9XIwAGqUtXQmcnslnFrlNBTlGuzpqiFK6Sg +xjl1xSLGV6ac87vJtB+Fr5uiDXflYDRDeplQGCLikX91c1cIwvV2dAMmQV0leJtiEuHLhX7hc2P CdvFO6lFrXY/8FAMsXcrZW9a52q5yYZhmFla2hcHrOoYJotZEN0gs2CUMJm6qyCBLT7nG8SkC9XP B+UuVRZgCqipg+9X57dnsJ1XEPspzlvqy8N6JJZLJcERXWSQbc+N/UFTM3HGGoFwd/yZ+U3diW3O lWwKEkDn5z8FMaRQ8Ea5sQgGfr+sv0HS1+XRJZ8/Z7XiOtzZ2G/AnwSOWQTxQoiFPkrouNkdPIjP gT3+Ddr/Ws0rI/GphX4K8K3wgJaevxgeAekY7kBv8qP9xgRmSIL7HvfB0H6GVcj/XJKGGYiplRff gLCt5eogcB0xACHmwKUQYIqGlfQsTsNbZeEkCSQVmB3cxcDQnHJhWqSYJeUrmjigyBDjuyNo6G7Q ZWHfwqSdj0q0mLWL9chPY+RmjNtl73kXz2udAII+pSUfkLnsu0FPCPI19w1x95BWtcl8+aHgisGK PO2aZx7/VNs0DHOzxi640ke7kHk39LDhlC1kJVgKTiBSMqyoHgfxcvzhXQjyTdqScfDwKaImL9dh PifjDXklOoj9W0sjDgM3YJOXq+rlpHIR+OK79m7jq0/PinHSGYaBImmvQfWPpdgsj+y0DiFaNiCw HUaQoG1WGsFhrkWnHaW1tdG8GbsLEWkqqIsY7Tm9jZ98QliJUvhfRVfMHLlSt60m8CjNWeG88nkW 9vNA+Xj0jDHqRyO9FdiK6bqT43d6Q5HoVRJsZNL9HYXrlkwhu1lyWOHcqhFWtv2BZON1mqMDX7R8 nD7xsdlb4G7RLO4yvosPBu8X+DEm5hThq8gV92QJYR2Sm6tWVc2nXWkWn/gs/Zh/K24u7vVhaiAQ J8xSN0CnwAlc+2EdsQsw2WmkaeIEPVRm4HkPmtSAGwLsZx2KodNuMWskkmwmbTw9Q73XNak2rWPR +g1CtJiz1Js4bs9UJeL+l2b1VhbRa4nHf3Ga9FOH6zqXwBpEQfbNf5/ohFWMky4KvGRSOToe7Dp/ mHrLj3ofMWH/TCET2a/7DNGYfWIIyc92tIgXtxdc7ObE3Fgj2O094C1zsuYUyQossHvEjK9KBaWl LqcLRvkrVSyBXPUcWj7odKucNtqhdbrUICH5v7MOQ9GFTX0G4a2VK+NtvsqTrJ9/9Ni8e2g7UHDi lrU7OlEhtt7KASb+Y9ljsuKEnF3ro0OumY4q0n4ituQqvgsEL7t8AHQX2tz/KCMCmjxLCf4x7Ygb HWdShnBiF8n6RIHOMt1oXkFl+o4EQDI3rbanZKKPz4SePZ7k9sI9Nf2rOeRTbgNdHsIZgIrwOD/K mKeRKTfSRtaMsa274uAjPUhUYWU9qv58LTmjRZcN6H8Z28s0E2iGIXWbbFgyp33yZVFLd3p0RTIs SeZ9uDQlmsseRlJbUx9PZNjlx6uq8zhgMtrIonuuELbryTRPAN5kUwWntW3wkBj+fbrfFvHhJXHl wBhVqtXhA5+yT5JR+bn2trxG+tHIwnPEN9haxYH1XmCbDFuvxMo1NVeg2Q3vLrySUNhgqxYfyqH2 BKeu5V/7eEef7IxHf1oNhH1PQllmIgDu9V3FVSRmtBYV5pxOcawR+F0jjMCwiuWHsYO7BvQ1M+Gu AwsOqPXxumJYCGZkW7teZBdhLZ/rmYywDi0KHRoKwewlrKDm2IwRxorFE5B6cL/g3qGuow3BnWq8 WRI4Qq8VLZCTbxTzdtC9OzU7ykamoI/KvJQiKdo+qJyx8IZwnidRjsBX3Ii0WAOLWqQI/Qk0KBGr Efrtne+tl6+A0wMT6MbVPo5jo1dNqusYr9t9KW3gW6xbz0UvQRVmLmAOGzvj68IuxILPKU6gMQqs j7mQdBVM0wGYusLAJIFy+QI7GbnJXgJ39ac3cmXLHmaSCz4f/BoYI8D3K4tvzsnSAzpOrhVxdwvP i0TEAKMxuIxUnRKfJ06VI6kUyubch55KE6wsWp60IDTc28hKqdRjINHrh3GqMZOrEdRgQERnpYrz 54Uij5A88iRt3Zmn8Ow0LqsC3hMwRwob+QdOHDoo+yw6JbBgYbyxsHflGeXsAMbi9NbnwpMiQKZ1 +KPJ1FcfbMkuYTA1z1Xd12R6D4UOHQlsefttniupGU6Ig7DbyD931ehfOJBDobVUVUoDykB8GgvD 5YS4nXLU5G/WQO0fe9XMrzN7bHQCXIMzTG6YJcZIo3WAAWfy2Feo+IL24jnKh+slLBQ5vFHMOsk9 3vc1Mrq2QUyrCN1BCudttBaPZzMEmXEzSYecNVIB2hcNALcMy4Rd++ZEBwE42Wcj8KVZuFZWVz6t bOGKreW7zKAiycD0vKV8OJsaPk1NnQyDMkGmNA3SAi1vDAkWm2l+/Hobs6XsckV8277nF2qwvhK8 LRf+DDqH23cUz9ijVOkuVJS7FjDwKy4OHt8Wflc887AnIg2vaQG/mTAJM083q1X6q/OcnIf/m68o +yNUSi5jsw0pitijozyvp86Dco8jJ4lSTNcs0fvssW5xpmKfROS+8wSPSOq3HHwjpsQF/GnW+o4Q CF6yT6O33i4oWp8/lKsRxERtwbdXw0PQE2N7BZ9ahnmo7DPTLOpZ7jJ0SUenyt6KygK2nJoW5U+8 +i6dQ8Lr1PtgEhmMeeZngYvehO6SNRs4Y1ij2xDez7TLbp0d/GJz6MgGVOHu9smNPU3haJt/736m k0bALGo5oFdclJkS8iQ/iCV/kBXlUFdUovZWDr51ysP/NkQ3oNO/bNEUUwSpsZZ5CanGKZXCLLCt uiQPJ5OVpb8IH2X7oBbrRSuT7j1jPRsZTfPmpFbQ50vGu065Vu/3ccvmwNMg+zNaZkVjiW0x0OhK diTfRnWrbYqZwG8mbq0+m9MQW4oytDhF5V4+E0QB659h+J3uwNFTyBBK+iF30TVv9WSVHMdz9pxe 7GFymNb35AJcr0uyDRK08GjvaiHT7OWjjdxmJVRWT4KhsOzOgh6M1UF/HiORCPQ7QJFE9cSkzQwo /7ZMvG2aUl1ZdteM/1DtNHp4D1IdaK/UnnDZUXQzaZADN7dwhcV/dIp/fq0jFKR+O3ygGAJKWtyu Tamy1B2q8rZ64JG1scfhGJx1L7yp3w7tur96bBI5oXAmjbP6AK3cGMPuh38C0R/RT/S05HI0Zij5 7fK5qiCKDuqBvbC7n3WV/UMJ8CoPBEKNTlvZTBFECvWdrU6kr6VAPCQf9+56+omOddDVfKVpzuot sQbutLw/Fscic2WMZuigt0dRgWPaXrK2J5s0VkU2wOj1EFsLMpHM/FCSzEsmm0/9HsjtapwQN3K+ 17IpZFhH/C11ho1y34c1axUdV27jc6Y89kqX8tl5MG2syuO59zcSgLCS7v0tb8udS1yrzV2SDWdJ o5+kPUZ7777uXK1VBVN7WZSc/KpRlRfX3Hx9rTmZ2D9PYWfNoXWippL+PblKUpCS6bM8vVPPNfek rv7gumhiu5V5Dwhs0DVmQmwmWSQtQtkPm5GBwNH08LowXaU8Ll9ERDK68/8qX6gEWAhdz92yLL6w C3lTj8r583f6x2Gv0xDDd732N7NUa15rDk2k3w+xnFtf9/5ucyqvcGJy1rovYj2K9/nsQoXji3lP sT96h/ANiJUlEWXdx4gCHSRukKLtxLXRm/ETccPo3+/GDM1TpEXNnrBXoedR+OZVIBUrH33T9sH1 1Y0wbwdYwbTfDycXz7D/QdnvOIcjBiNJ9uyPMSlgmSD+hhqdT3DJd9JcqJI1+Vty9GnTB/gV43un lXQw5Uuk2nsItknL2R9EoKBnKjJm1vxfgHeQsJsZtINCNUZVchlzvbWAcqXV6s9JhJfqPys6jbjP emjHBSCEG2UQXtVeuH4zzvBZHNZDGvQEWlg2J6kKClbLYIMjx4FCVKbWpsCB8ZPAxqaexZorril3 OFzP/JJ04w9OojPOtqt7YyrHMexRTnFbW7RXwhHMCoXH0in+cgmmvzBMHIvwK7GCTUZYVmR4a9WI lVi3V80L9U7gK7I7wnDkY1BmiLDLTDyjcpI8VVIksGKXl1S/b/rPng5pf7nlFjwMJoF3POSwK+Rt pzvIyEafGHHVDv8Ex5GpknU/z5eNQWXLvgaXgPblpxCfRzMEIhCAJ+HJ2Yf4A18ijawptJt6Wc/W TiiZM2vqMu69mLlrTQ0rC+mjRQFZadt0tPChQM4JIKEPdqd5AnJ8Q23o8aWVLWZhwQd/4jKn934s pKQk0nq05V8kQTRDOPSG2kkvP+vJ2miykKZiGsLtMVeDC0ysrOD+7AcfcXacFLvd6bk8E5p0K5QU BEz9lBiswee2qkj/4c5/AuEtqGU/OxI/yGZy1H65OOJp9M5GiJ+u5Rsy0AlptM6h4FSJVnvlBLwb x1kUD8g+o1C98dLnmZ7+JRxIAlPUEYBemE9hJqzBH1PkeHTxTbJQv5Dpy+c1lmYCrxJhHJvkZrFF O8Dj7QkntVUrTANH4GakshE7/3iXl/p2fhrl5tiNWh5j0/Ce3wZnSFVpcvfuc/vNFla2fDubrHQA 5i7peORvJne34t/P+1u9WSo2BwscxfoKFhDa5JX+8mdRvnDhFUehwQTnuaFQ1OSDCo93QFZtBX7k lpHjrTU3OsNJbXqXoVIZ4ZCcoknccAZQzMaJl1/TPStLbeYngtsiziwGkQTP0j6O28F3c4ue/fz4 ZBdCHLyar9n4/TnGeg8zA1pqRvxLbHdiwflyAtq1dirxFMMm2mlB89tQ5qV57s9PyLNF1BNsOKn8 3PNHX4Yx0PZEz3a9OXMtUz1M69OwKx0xa3tT08tSDEoZvlgn4VyEPsNsBsklyV6PS079Ln4hV/lc ZDSzJKCAmYrFEsMppGy8MbbWqSsG1UazggvNEOchZAF6mCwkCMRxmfxwEMt1zfoZSyh+KD3/7+st lROmTWWmsMAylAs6j3fqBrC7oHbYtlQv/KnBANvecbwJbxyhqaF4MA0yMzxIv6kX2+oz3yMP23bE uAMLWJwRbFOGGNhbVlAvXSqysoS3LQlDStW5yneR9qlIdIv95fLCkMN+ouCCHxyhxhmn8d/3z4W1 LD1GDVhXIWnn6UEAmmAlOeh5MwCgXkyFtS31VGtIvwM5/lpI8YCnXW12/v1Xl0WPU5RCydg868jz tX8yLnQOuFVJYqxBmL+Fd5ouF1sc3r1gxlavdecnLhADhTHVstgcZbO+IT4WhnJgCwHxl19i+FXo UxL0Pxz/16evD3xC9eEazXRQ7mAaMjWSdZY5nNlAuU5KyAV65RtIAB2wD09mEbGzc8Zzrzrj/auR M4Fm08vqiegUQ9XOu69cmuPymK6lgioDVZyRvRSeXIAQNLekZLE7Qr43wKo/iT/lwMUNOE/e+sOb /EQrBC3tBqCHyNjqwcRGoNPFj5WmHaJPcXrGsa/uDML6C3t5nQn5dMmrjvrWwFAA3l+soA8ei1+i 4SdwmbgqsHA/2pzdex9LSspNddQMS3ALSO+pn5QicJQgAS6w3E2Nhkr45UXA0n39jv+aaWdrurJT ad8HYP+ZQxym7nObGgbBdhG6t+3xp4RrGkQ529DobVr4zCf1DjCLwySPdIzT/MNxeoZ61f0hsykr wpKH5Aweieu+POJB+wJmg0rg2GpvnFaJrIMQAMogG+9thOVFvLEnx7/GkkUVyU4aHThJrLV7abOs GwuAdzqjUSkw/uPlxB+f4zZbw5Oj7mh2BvBwliOeqguw4K5DwXlnQrMVofaDae9f/w9NonsJVF6L +TmtRmbkUer5dL5JyZbglt8CkDEWd53KKL7+1sbkLcVQdGTxoLuz/LH9An+kS0AM7lhlXeiU4FAK eMUDgudQAMGQpa9S7/olQMblCrmJcrcWDU6rjuJGCHNdnEVouEbAq3RcvMdBaqPlI/HrVNzxN+hN /QL1USK0p+nxWXBv1QUsMra32pPySk81Xc0FqpqziWSoBf72jp3Y1kMuJ5EfppewHzMGr2gGpNH7 VHveOlwCQyrS7Qvaemt3Q2JCO6SK/qr+JSiSwyIc11inY04F0D/mGwVzBjBpGf27FeEIz5mXSKId EV3Mj/oXx0YMs6+f4OUReOj1ipxgieGsmxrRqodpHbiAnjlUId9h4LwvRPb0hXZQCMUxBAdrW6vK FCfx2ysvgjP5HYS/T6iiM54szGA3FuLmrFp8bmUjjGiWbdchaa+SSqeFDo1A1TrrQfd3lwqjZ3VT X7Yv1d0mMWe8dTzAphpnoVc19FemUXb6MhRmUA6w4+G7wrIQcAjdBWSAVrttnq+qUbpAOe9812j6 /6kIXVF7dIWwL3vvGskF93e0KOmb2vDUsk4TyFmht/6Zt+HX+OIrmvqMAq1Sb9zXhJ1zqj99w9K3 Jg8C9vpvjQykURJUpVhlwm2bvWeMS2M1Aqqm+ATRQC5t9FhNNnbcfY4gf6blNIFhG/O+j6aQ50t6 5QZTM2/dEF4AA4nmwDL3MmsqCuoSX+b/39ddKj4gsYw+HZpOujTHjW87BVh+yucbOcxAGQyeKLTN opbAUY1yKNrbRknT3i5+d5oZKtcZ75HvAA19ju8I4aGE7WIm1/0/z4hX4MM819n8zDN061sYv0It 2/LHr2uqaiIOBK+Pnw0USs2Nwfn8Yr4NpSKjTrMftD8rgDBPEeWvd7TFyV3AxswvIZaOkzuIMLO9 R3UQaA6gqZm3665v5K0dp9vDY+qiIqjYqTRKMQ76ea79R73uTLRZ5LWffNA7HwdhmAc2+Pd4TbII u5MQ1gTRt92ZFUSG6SjBTy/DrbqB6tkvcWx/eFmW/SOumcK9kjbuprSXUNRFooVh8OLqW5EOcg3U TpiEZuqo99pcixAVHr4lN3bW6ScTIeYYMaKagvOE8NzhYawYsszHYCdY5b6iEgc9tanMJXjhRUr6 grM79feU4rYwGowfDDKxzNTAiBj1yOk2WVv/GfvfudChVEzf2u1soPkRBXuT7AxIE+iO1IUh9nfS RdGKt6kuQaJFPipfvBozHaPSmGcBPnJ0BVZC0dbxszq4vpMRW1DeZNGo9+wNVKbQbZTIbGNfOkXz Br0ijvq5YjVpmtNhjzZPbDkQy12tFgSg74HMEEq2Fu4bGFMg5ZMv/30JklOH/9Rc7c+5sreDwVos gLjGegjMn+cWR8RMfA0oueUPuZYR7lpC3GFyZNfq7K3vsmM7niBgLitmvSibKvn2RWPZPAVycoji S1G4CsIkBZnkoiTIMxNO+8DF1wkzWty5CPh0Az9S59ff0a6J7rt9pl/Xi4Vu1Kz853ExtCE7xUwB kWH+B/4hg8bWRmLezuXD1Ieh20AIfGzzjqpUNl2UkVX5mW0PSYYRYOyIZWKe3LsRSqoI5OgE2/W3 qVYTxq3+cqZxpBuuTmQea/oiTRcX5s6wxmnmztnVfJpbDhKvWbSs6cooRXYY9uU9yqt4Isoggj5h D9naE4rjex7lAZ5k2Vuo9plEKbD4GnZEumuW+wSfGslFpK6knj5lGuIiQDJD3yMJmISF9qLxyYV1 7XIUS+SuJMamnLERILP1kLvYB+AMUzk+7DpsVyOFSHp7ONoxp+RT0XybocKgMzqUwNBPNg2UCZO3 PChq9irxrTd+zKdjFUv0y2uytJ3BHTrHr5SpG4JAX+lFYdbiF+DS5msrPyZiX1dt+k8IzbaVmtbF ldiJAWkgtj/TDVtvkV3VlOK60btT11OFF4uzc18LUf8zpC+SgfaZsJvAUkMepZoDSlzCE1G2BmVm VUOtwjpG1Ycpv6tENcXh+rVo7P3aYhB4D9y091mFYi111lShVaEIFhl++f6xmhWuBFSdleqtwokv 2tdMWEqalVOx6Gh1h/JOaMwYxD9lglNNdqzRh+tS7gK4KeZcsp+dt6lfAhVRj4vJ7BHFIQ6mld2C gKRRRsKlNK1/dN37SarLq06MU3M2RfaJminGqc02qNXqyIRiePhH0FLmf8W60JZqjLiZ99l9NcQP qMaKGiWhpSpg7pv/TfxOUaXyUggUpAMFVQP5+elGh/Q3/fJVULoldJq9Ps/imPTrjRtnUnncCJTY sM1PptbvOlrON+isHsMIEBRt/UrDvZEoVGO8rP9c87uszue5Av/PB3tMTgD4fOibfVXqEleMBHCY jPbbF77+JDB8pFYoVOdO3B6jB6NIVk2WzF4zvxx600BkbPJeFpDdkIassf9tsRkxT8RdTeaayqlS +CmyrUwA9onS44FdWspho0VX20v77GzpJn6O268JwfRLl7F1+hySGHQP9MuXCyYUQ87a+gFsGAr3 tSZELYof9CybB+9Qr2Kf1pfPX/46TbYiYH1JA4U1EjvZ4Ddj3x8cWcCt8WqhvS3q92PgL6209UWa GxQhfWnWoRf+MCKQF5cQmB6FqmvUeFfsv0B6y06ZEBsYyhx22v9PECh4Q4BqMf8JFof3Vv5SIvI7 WOWGcFLQGb3U5117U6CX/uDJVZsOVMfcmWChHl5MFcYZClAoRtLgqxnratNgwkC2qUg1Nn6W8bfb e/3V1aOyNKeZ2fvFMzme0KtkNPzQhNgQO2ySzjhuZFZ9suPzb4yvMoV1L+mnPx/fYqplnwPQUv9U oG2ON5zKE39ON2DLsXK/BqxoqQECR8nX4zUKw/d9NEqtr3Bfw9lz6UEALa1hbMMEQ3efYJ8tHXjB ggooFM/xI/GmMrnhaRwmmt6Yxo5vyZzYrz3sWX652qxgQ4hca5jh1MpjbfITBsxTeQhXVtnh2qdT wZlsg6+Lxwq/Ox1XmxjNMkJ/9XJBloM+dQcS0g1FompMgt5ALnR4Encwjrd10apQDqKKILRxTIIZ uRNysDKL2O9qRVfqgP4p8DrEE141fP0+7Frpl3r6zXa0EJZFI92MM1hM6VaJctlgxF9ncvwkpQXR 0JFooHludH3VYkXvtSHCCo9NydbR8mqlW3LOHitUXrHcMlTbdIF5hmvcz03s02ONOuSzF9s16ck4 MV14jlTSEeyDPrP2SGY7rdTzzdybOE0zqpIyZ7op4Ti2TcqoT96PycgEyjtpXCZWvskbczCZSd2b Vb2nhJs6W8BUkQXhggH7m1CyuqNDTvc4+0pNFGvjiSfr01cXoyBLcl2eSuP1T1pI0qmU7F/H1DOp Sj6leVFkFIp9afOQGCuGL/Kw/PpFFHDa0VdIqxamv+6K0PaKKWbZ3mWaUr8p4u+pbjcutCl5kw5Y GfNhmzUq4h2Pt8xVgsZHShPi8J5n0wXWoPKEtOn05bPmEh/mx/DkkW1U27mdhASXRqPsa+Q4Z4hB 3ntNRUL773eQZpC5lhO9r17XAyb2xAxHSW6wOVaMZSeXTQhJ+MTwju4cX3R6kpxpoolTp7A2TgOc UydfHcAV0B+k+bXce3iNfgzJVgNhd3yBQbat6/0CiLHaWCr28ZhogN3r2nvGH0nlNFIOGyxPRZ4G r79WY8O0QVjL8DYhBlFnFxgtpIi7YKWs+cJp/kgTZhHdqfMOTxwa/nmupnMg1oDcAn62UbbAoIXX F6zqzP62mrbQqePpQigyXI6r7AgwNBuqFRntGdwzzQTX1X6w6rpt2vBAw1RsEoXynUDz2Q8nvhiy pgS/w/NXmnUfaULdcKXT+12YECL4WQFsUxO2v21oqvSSzqJX0OYy0eo9AvmMnNGoeyIgkF4kKGWD k95YWsyAO/YRwa/W0UyVXCH7+Hf8iFKSDiyr1EfKBOrNTOIquHQvGJYV+AVKPV23lJusOUm5uWBo 0zoT3sWIP2sZxXslD6VGTwy0OX/7CPVcgtnJIbIzJA+vr2tXJsg0CUfkU2/KkV9ExNILLsus4WwA z08qyZvXmp8bjYG1EG1dIXX9mGlruoV4IYc/Ep6zuQxhXR2rkCmDKOL0vE9umfi5g3QVh1WqHvTY lifDndtM6BXU06YSoTd6WduorWRxYdqSkXIgBCl4nRhflfONwwMp9Yd7wro9lUrHeiD0ceiwxs+V WVI47YJ8mUGMjk6RfIuBh3ukDgN/AYHR4guDcLrZKTH/9e3ZSsQwc5Dyw2GBZgRDIbmLQEX6Bs9m DsYZNnrV3tNLPeww/L2lx5q2O6m+lD6NOFcBEYxPOa+iTO4Qyt2xKfSLzQ/+XHAr9ocG+JkOsqiG np6OSPiANCJi5MnWZjVaXX2ymZmpxwcFzPErTxU/bt8nTqjt03fG7+AqoYPqdXGIeaQqtIlPxIXC vgWznDDKF3nElAA6qqY5e1XU/at+Xup5AmL+i4MKrcvYqyG55b/1h/pKaVGh/yYQ+2Q57qIHgUlU NOoOecuNp1L5RCuwsa4nhNK6/iCEiQ0/lWgn54EliNvrSUwGji7v8Od0ILFANfGw0df0Wlr6re1I GXe6fpgoPpQO+EjyUt4z1vXqKYsHWCC+VFw9acPfIYHfPPLIsbIngbz6/pDBUWZ5sYS1my6xH57s X5eakky4slTnzy0qQiACX8sKYzXvpsF+MJAiYBIFdN/pCbvQCSZXGjFJ3L+StQvexJH7alHvrRL9 Lh5r6w4B2H+QJa+S5DcZVjMSibvUlcFoESFtYxsQKXWFfe2eoq7qhf7Wzptu5E4teqBggiB+SFxW rXYgFDaBRoAf1oDHOnxJ5U4llg+l50mWKzMbI1RmM31yy/M+JOYNWQ91I3IzULAej8Ht+nyCjuY4 ELvUTYeYa6fdZuTMqjiX0F/jod3SurR5CA5uk3FwF29Hb4uuWiWEyRRZP3TqRJ+TFx+VNpbWHVXU 8PLIND3r+ta4B6CVsloSzuoo6qgHDTh2gB1H+gMpURGxzXSPAseOEWZkZZbiQbet3wBxIW1L/qKa +fAi4DOFbrBX5b8Xsd8zbTk9SC+bPLke18PljPSoleW622THeKK5Ac1ILrDxAUf7CwRn8W1rUyaP 96aSR4+lz1EqfnOwtSVk5SecgGm3KuyI18vC5K+VqFYyFifGRuTR2ITwBIB7dBzmoq+U8R5OmuKu ViMRJViHGA/9Vv06DOF7ZQ3F3EAldM8ul1kgPKiuLNQtPy/MI7jVBM1msdHt+V1hi/1krgTXudId 7Xy0xZmcfeEdp2BVkZaDv/Fd5bzKNTusqOwm8ejEsal8vtRpQLbaySJ1HjE6hJQhNcOIIts/EaFY +Xx2Rqz4WLy2rXMLMrapJruYFS3AOW4mF/kYIabgtzJeWAgL69I34JF77gqmJ/UV09YGY5d56GzF yG9ufzKKX+ieoZOnqpW8VgxIfP3rp50+Jh0QXswgSCIC6nYC/pI3sFFv5ty8leEPh49Th7b84HJE PhwTJSCWn1zX9oP8ccHKimU47LoMKMUgZycaMJB0OI/puFS0O9+VoY55E+zoeuiwQJcXsdneYjvx aCtafCp7NjGOw8w6VeOL9sWknzbYyLIlZeRM2lA2to5RUHfFo7ySY3eS3jLBjKPbUEye0Ppf++0t 7tisuOEgB9kLcfuewxgxV+2XTyqiWLE5SxqHfca+3oVPs/ZRDr/7aPj4h5Fk4+8v+jox0BMvGKLV yLSKEjgYgksCTWhCXshmwi6Xt51OKYQQ+dzUPoF8Yz0uSAW/od6u31o0fiZXPxfg0GzxWxfXDrZm wQrB/l9U/lxuzDFTNNKydyGiRjhxqN5W8BhaffHxq4W+q+H0Beh0JmJL+j9LoNvMt/EI4S4kXhkO QKyd588zntLPWDE+SJ90Iix9jHi010pHmILbGP0Z3QXrgx6evvBI/hAgGdz34nl9hMFHxyR7qTd/ S4o5LK7BLGzmdmrRzGl0nitpG9IKZZugDvAuUKIRzyluiToUwKfMPg34sR3LJFqZ6SJXK48S5g92 EO961wSNSnTtcm+kNGKSyrhAjdXXpUeoA6/dZ0Jb8sOnR+0Bnp5JbySCSnDOOS9yBVMqOh5hbZMi svkYr8cG94kWexzgzJOabdweZ3xCDW8gAScj4PHG0l2in+A8QjH+Yym9MpHcfVNgRd+8wJ1rFT9D 0JfvG0wAWxAmqUSCrgpzak4BrCoJL1dpb35J7o6Nrs7FIdwPaLIKVxDmg0io/FExevRavWFkPovT PCvVqwQ225xZ7dSpwbm/bwHDqyFdQQvqNAbNvaClJW3Cywoof7o3PX0g4T0UlE979Zn5sTWBGX2+ J2uwy5N8sWrD2kfxSgSpngk9ut9HetEb4/XdrYtAoJhddikS3xk8i06jBVS0r1aDr1uMlqdZ18Ok lbXmCq2RyX9LEScsRQ+mzzTcBPY0CTEVw9ZjF/DNBKgekylVnuYStb4wwSkJSBpA3zarF86LCEGD sGTWnEvwqtmJGQoDHzYtf8AWtoGaFF3EslOr4W6wJiHwK13BgbbvgzyWXUkdQnv8UEo69vMDEshf gqt1ueNr64ngZ2wjWhJQCecBe8EzjiKA3M+ASgpD7+JjH2O3WpQjK3GoepTScFVlIH9naOV7RNAe STv3C34+iMDKg1gMtfLxffNVOWeKaFXb4dp70zYhNaBLl8VLt+mJ4aiMZ9pCSowSON0dWgE0PK6R wVhNWPkb6saKXPP4TbRypN5DoZl4uMcPqZnsOFJ05iahaEnhpkq42FYy4ip5jje/jbF46FKY2c0f l++p6aBnC2EbBFkLTGJVlSSV/xlWXTKRh0490RIfEq9H60h5A3dQgasgd+WxyDclYnQlVFwSctvF U7IHp0z7IKC/w/HRfbJoEpKDjGCp/gHeccteC37z2BhRTOx8HK3pb4jPIFG+bcIcxNdSC0EoKb30 SqZGKsKI+vrduQKHFnMi0Wv4mZ7Y05Jfjk5C2459fg2FYvfFTt/7RrjopoOqrm5HcMzuD372o/RC WSaenqAIEfokSmxHCmf7Hl8bkBjFFDAerRH0y3g9OBVUV5sh7sDKL9nLIQcy1Ty+EZFTZuWhyCBw CbIR8/YmapprNZwxX3XpzUJASS8mu6VIbyrOlBQsMK1QTtW3t93fqFAVpCqNJH84OcNPv5UAcz5V Xrwc+M5+P1EEfVA3CkoX9ENyV5AFuIJdO7XJSqQUDTg725KhqE7l3bDZYVjSyYHkNYfSzYuC63Iu sZcZ5Cgbd3M6E6Eif3sLNS1dbdIV+kPWFXpSYT3jFf9y6sQP9a/Qnm4EhcTxLRtr55+KxSSBczQD GdF6suaD+bX+FPfW5wlvPtY+D03VMtPp5jv0MQgx3QeP5iNX/G5n9cWRWM2wsEoguK87sKjxiwlm 8JfRd+eYRJlvCDTydU2/MeeMLRzSVVLJ75AgOvA6cLJPA+aHV3K9i/LnZsz3hc+Ob2yOcszOjEve Plm+YIT3oIDVXBxwSleWsyE3q/npu52eXKTCMk8cdIvQv5oz3tDBrqsq4eAL9nqCu5azjqXIaJi2 eTs5mfpdrzUHnf8WScZ4FTU80hj7hJqigpvrkIw2WNWtrDxKsgkh7dFZ101td7ukLKsz39fIUz5D 7LzGAJLypfk6WgMSUsUXkx4GJIK3bESc1LJPtY1lwudRLrd2T7t7JgqSmz3nG6ahLY6dy4sMMQ4c S7zEohUytoSNJxP9vGzZOZQDD5T0ytvHzv3xfi6VdOgmmrmUmZ4DiQh5KAH5mu3L+/FTC0/PDdnU nku2A3B9va+R0tI/1mka3+7hcPaBBZHSB9EZQ/DkJHml7niy7kKslIh1864sj+h+ZTH2hxcvozPM x1rq8ibFGa3v1Zi0k9wpgoyXrNM2EchmZei2bW686oEvWvEuLK9EsgQ17kggxUivIi5nzSzSgGPD svuh4L3BSLfPdrk7HMtZYqkDH0xYZgQYXP3hYV/1Tp5eLMffq0xTc8YO4WUOghTtlDloF76IqPYo WwFxqDIn4eQwTFXseYgvyIsxSiaGTTmnFP2ofx5bUQMY+jK4toYulbeBKoIiymgDlh2uF129KIH7 dzz25zXL1XQvctF4g5WdFZiXE/cABpDAYCia9hdRLX+dA2VyhfdH91GtcpiKdGLyWgE7N49sk7Zo ItkmZ0DsitQ6tYX7Pdi1JgTf5hXap3Mdmm949o51bm32E0DwsxrhTTi8+h/Eku0OUpMStuUEjyrO zh7uN3rPoXdPMg2V9TWbGqxpLNmioWUWtBLFZ6lb6vvO6A3MkchoMkqHdkkgI6GJsQt1ecClCSku kjcNwz/xoHTr4sAs+xIg3x2qqB4qr1+P2Tlc8sIVVdW1qk0wq75IayvI9tP32/1E92qT2iMN2Jd2 hp5n0nfrK9+Y4xwAgEiyLNLO27a8By/nfhgMER5k3PZsVjK+KNmWAMYpgJ4mqwchDJ2AnsQxb3I3 uXBql8kBcAfFdMDsq/tsPFSiq2YOhg8ZInHN7gqVFrHyJIP/ICZG29WY+wZI1+oCCb2wT2NNm8KM ZIS/RyZBDiIShJu+cIcvgll6k/ylnRvJ1dwrq3KMlz5qNCLZjTxLs8P79ZMjunzxyvHLOfZ+WK1F gSa8gEvPVeVvh87y7eE4qqrAH7XsI/VTStNtAeOccZNt+wNXRUbKRGM5QccvtoB5rfDSA2/hlFen btimT63w6Fe28CORa+QYASokyuq44eNgW3dWW2eBMnAnJvbKMMP3izXe2FW3Aw9nLjI2vNQWXcqX DEv3+xcDy4QpJygJLYNB+kUXTEYuvpo2mvigOBcBF67YU1UBAsQ6IZQio9tv6PAUTdr1gCYa2sed 2AU8v8L81FQ+mOvwX2ZR06i9Bdcn1zbcDbJxoqBeL3ARF32sN0K45oxNZILeawEkJ9HXD8z/2VZI gLHdrnZgaMtHaZ91PrxwIEpVcuG0aw1F8VfhIJjQRIEBrYUrdcCYFk4QKWWtkDXBRvNgrV789kyR rLMTG6+IDYCJWJ1DDc/J/JxdyFP6gOhHXLYZyjvqRo5JSpgoctwCWP4fkdPZ3NOE0SVDuj1XgxQv nGhG0wuyFaGybF3OD6nsEjRbQc/D70RaAqgzh6iXW8hW6WeM7Z0bx7/cvlTMOeoBs78kUB778Hky tFBEDuPsY8p1Fn0u7JvY4D4VBC2kFGhc+8YsRIbCYTkkXsVhXTlQlUcScvAO19H4XJq7U3Srd1Jy 77c7gzvrKvX7dbKlK3WVU7Qr4t7HN/4XnvSfDJnQi2baRStfHn4y6+fPPgstvuV9rWGOCSUwMskd fP6FgX3lNrQdTTrZ39/B6z4qIS2JqRYR9MjGm3oGhkZ3pr5hpLu25o9eaiU+zhOGhqgFu6jRI5an 3EEyBL/l6KN2tPf/IjVHQOAeXQRvJKjKvqsQnTiaBENSHxqlDetvfIesiMnXiFY8CwlecrTHMXA2 5+s6mm63HE1miTyMwX/meTSwjuWFpPh7oDywLwPNVvPPutHManKhGlljzAKxripl537ZwZ906Vk3 Cr3kPzi+qdMZU33Eba7wlI8B0zUK73//D9aygh9neHv1D0kVVln2tjMmISqpIKTx+xFgQdkeNGx/ 1W2tG5d7W8hJnhlGY6l7KTAYiOZ7O9cJfON0qBp8z5U70ffWhCQ5lTxrA0M7sJotjUT6ZD0tJXf5 GUSoBFdbBAZ7KdPKKKE9f7H30AQAw4Gnd8zZL+iJc6j+pbP7bqR4tBPMIsjKDSrrOVCfdKFSkY2n JjbOHFnwzJ7/VU7Fuo/NYA82hpou5/t6ZMud0Cr1fqCWFISmkGXNihSLN6B1CrAv1dhBua7hJvqo UJsi05b6lgXXLgqQ/BVM72lFywviaLlsVkiB4qKlUre5p0yafTniFqXQd4smfFBgZSf7IWCcXppC 7YbLQ1P4CpqexaZeYES0bIJ6ZZBxAQXRUQGhYkPVobIVSYUR3c889YlOtCsrtC1t/UFxdrt9xo11 a8wlmzLwefrPzb0ux+vBQgzZTHFgBheG1hQlJCABG7KYxNMWXQpujM4fBvVRDpVjyBDb65tTjktR zl3MrvR4WEn/hiPYF3evTput3IKOcUzOyaqpqYj5spF05Xne7mu2W9Jfo7HHrrPE6W5zHcjn+ham v7G91Hrju68eXXWxjsaPicv/bIPn5WpCbJS3wHOBVo56cKm6uQe+FvcXm+YTpoj6QTi+DRGI+Q+5 wr3GkhxwZBun9pz8aoHyprgCoki3Y5hnUCwDk9c1KSXyUnquyLnJv6CKfHZoTsEAeqLUA9mLkUGq yqz8VbcwapEJZFuA1eAMbbldHbBi/HXi19aKFMdXGNUAX1K3P8ZcMhIMgGAhjNnaIWE3OcEQSEHY ffzd5bTDZzQstNLk799x9wFZqtG0879onYQCM8wT8CuvIyYhlA4FQz/pWfr6G6veQvB3z93ez2NS c3Sf/8bOIAHL1W6Jrtm5c6j6V12xMHICBvQ8TLqAD4J00NKPcYeHfJNNgwhcVXB246ooVf0yex81 IjvL/vl7qMkNOjPVznMQ3W3E4CbVFDVyENEguIQpuzIzE9KsN7ExmdrjJ4omjsbn1vrWp1wYXJ/s AlhG1w4Ry45wSduXNC3BuNFW+GfXExEJUinbpBH0K/69AJubUocEQ2ielz316myELOHSPwfN8cN6 pRhTxhU9ZKhw1Jqa439V5bRGy/q7vURWuT3N0g7q+r0AM7LcjYoeGFjgaguuQ8oPKg1RhnRQ2myB RfZ9gvJiOkXo4bM2QcG2fU6R+SlDpUE3MVLufy07jweJzovEsr7BlymlMn+7SosNlI3WVDpxmV65 BLCETnpKD4RrVO8j02thJzE2bVRvrhI3WrZ9sJRfB9bXpCvB3z5Nszjp/PK4viQVG9W/sauSevuc oQpeKOfVW8ZoKuPmY4ngaT7E+Le1Q5MuqmP6ciVPjJ7NmQnAbOOmBeBACcGWNO48rYWJM4HxYTo1 aUXh3B418n2L2x/pv9IijpwSqQBh4Vrd2OrssnpX+94KGM9Rlx+8DrVocmyKRFQnGrJF4naPHHoj u7hEs9skUqyjlWQSC+0cv9IY5R7UdVIElSM7hRHfDiXdl5VwVsNtEbrv0+CvV732hV/ZvJVkOp6w t1Pb03T4vCCJ61BQVKE/urX4IKNBKRyHffj+TQmSNaktE6fiRePYDv1tiv4zflUnKxII6YEfApD0 lqQYxcy8pALxIxosUV5UNbaCjv48v37tNOjta/+Ydg6WCIhYS1fw/SsXPqsBVlYa2QsMBeKO9ieV zxBqWvmp3MomF9ceCwoHciGbj0EWDCI3Dh6F9FtMQ65KrawTVs9/61nVaUHfJcB5Wb0mY7LcGfsR WQ0236cE7YecbS9Yo2+DB+17judEPv0/zQQPvI+091XqQrzIh9Ae4HyUbyDPHGoKDoXflSZlN+Fq jo+rOUivUtUfSq6/lUVZT4BqHVod6ssnXzseQzOA1RHpBENWphH++sOtsAjzY5LKOi2EMhRiicsQ b/0b+HiKJuKLr4DwiRgrH2i0bWNadUGRqbHWSAY7T5WRlYYzwaIsnj3y0itQyKTAINLbIS/mdclf +sDav1zfIfTLIJwBg9rbBtVa7Xdqoi4DPoj2OoTBmTGPhjBUBESQXye6sjJZomPUTuB4cOoAqfjp WD4VfwVhU1gPEsZ/fJLFqkGrsNJF21Vj0C82tEc8fkNJJMCC8IXuRjNMgR+sh3Cb5tcTw3wqEO4o GUQE3xRJaDNemHeE4ClHBrNciXAU8MoQdHsaBrgh9PaS6jOYBt7Mp3ezctYeUArrpj752Iacx9T7 VqMiy1v9pHcPvfoa4tMDjhJ5I09ZiYoHMSwPOLJeIYIJvfbzr8mQHHRkH1NJYk1OaY5vIzcz0L5W 8rx2mkxoQFpzvBinpjK0W4jNXIXWPAKLOISBb86mRxXXjAARsrmLeNvQ8hshVsmV5A4iBsk8Wz07 gGniDy53zAxG2eBtNCGeCpKudseOZcNqmg/HRLSERMQW4l+IPGgcDDs+RToSgesrGgDCak98Rv39 KfYm53ajcsAFkTWRV2t8D82/CJyurppxYtrvs7B6tKakKgJuUCWX5e+7wHflhW4TK3eOVBHe6x/7 md9TQCyDUPIGRNbz2KUw3RD3FT3SjP+JPcw0xa2cNjyblVn5NI9qVDLpmtn4qHXjMus2xcGZHn/H Phph/GDPfoc+znuEypTTO0m+1vqKPowWPknp9EPGI0tAKR+au4vNoWLOfDQj8n86FPwqU8mDkSAd g84vCMeNknx+A67ggIQe8Oi1SRrdzUxPaA2lKdWAqkOvTPA/A54UOZ6Lg8opbuGBH6YpGjjhtS0s ZRFWzCUs2zPunwLQZqNAbLISowxz1JyLMsoo73FcehY4JhPrdH1OwEDmxt2pm2iAeY868rNpO5Eq sV9FcSxLcC1HzePy2YmZNY2tX6zeE7ZUOM8k44KKmosSyzKYQ6vpyVOuC1lb9tUctoI7CnPNQqFM awBpsihpPm2Aa5eNd1pRPXV0nWqyyM/v7qfJ19BUyVWDPBgahi5J83/ptAJBH++iVwda6iV2/juq EMcMzhdfvfzzHEAvRtVtHCshe5v21BLkmB95TGfy8ecGCWXNHedloxFz0FZbtQKk3T0YqVFonZcT r324vR4/6OabzURaB7YsR2oWPmtpXJqGxurkiO3y4/sS+8v3PkYkq9TKv3QeldQsN/7KDM72werO mWNj6L8jgjpHhvxIRtUiw9k+q8RZ45UDmgCHgfJC678tISCvQ+BAxJDJHnrZXMcKRiUUJF0ri0G3 xecnGNkCFIuJW6GVN9UDYQUi4n1R77mW0TX6enOcHSUISwFOtYDs/PggTy5xJHXq6ybX+u6NfUJm qHPbOC6SQtdmubhG8znnzEPHKtoVP8uOmZX2mZscUZF9yxHKi89zdaygXY6nb7mc6tQJ8n0BhJJy L1Sf8ZBLV/fRVX0sAPf91NHEDeLGrDXECvQiwF+7LwgtcGjqVW4f0DK7uM/xIFItT2FGuuMp86Y+ gGKr8jM8ts/H4ohC5aHf4UebxLddyxbtVcmVw3loVivfGh28PLOZLzhc+fWkDr1fCOkQ53wVhToj /II220GSxkFqD6alXfmGXYglZx14M+yExINFb4aa6JICUukYkFlW/P4rNfOsGy/2b6jdDM1/GoQ9 8u17H+UxIXOvgcDAc7N440lV1PkmR0jhjKrMDaiI2QgIJC0gtC4wn+iXQNlJSxzqaLmwRJUp/OsK U2O880Ujl0e4W4XGEho2UGOLYLEDdsSodTVWlTnwz+k3WaPmwWlgUzygXXfEYr00KgnpSWtnOQE7 u1pnOa7QXLjyjWwzemJiyyDXuSlB5fPHSnIL4xbU6eliRIVlO0gnwo3aEA02HO3kupzGHzyY2ebI jowlUCcSaJa9nrUxp2o0nNCtzJoN2+vsRgsc4qWwenDhvbO/Hg/Q61MPaD7FLACfLBDQX5eAwpLV JMQYbD9DNJXR3xgSxrESKpTf2iVpG0Tb+a9QoshfJOxDeoo4WBXYZRXoShilzPoA7oFujENrflJh Bu0I5w6fhtqeMIqztCJuP6pQMpfhA+hTg+pAETTeDc1zkAZgWmYGRiB45PUYVOsLrRNRURRaQJl3 sNY2qNTkFh2DaiE4dS9UdKRamGkYwxkiNfjrIBGwm9eBjaXad/IMHNFyE73615+IX6v0syQo7XtR hqRpP52valHo85REjTLbXrSzkV90LnDmG/awZyK427QEcBbgty2KSQiNjsh27Nk9iapjepH5u7QI kxtcDCmvLM7++ImpJ+GMDWe3Awnh6d4j7IMXXoHee5J1Bmo+ztifulY5QKMmkK552+wkXEAq6RwL DVsYH5QDOR1SnCuXNLFfbCwh/8Dkw96jU/8LiJoSPCs8YCVbURNQVc52kwIMuknzCgTjGHKbdd2c 9oRuCWcH40lfnTcYYD6+A2ykIRUTdlviD/7I/3Ht/xrpCH5VYxZaAjhFilcED5YkpKzWkjuTBAAp LA5oYoZEWYWLG0fzYFiLrP6vqBV6f2PhJgnR8ISuDZRcNAV6AepR/h/EF6Ee2xnq8HFK8t/xRPQw JQTk7JOc+MjwCoYhZuCMAHKN1z5jeXxA1BFMMIRLqdIGbdSP8wZa2xcICMiDDRaHEoWxku27ddHb YewLh0sQ/Ux9JZvTsJ+c5CBG3kqULO7+i4ocX8FgnSJzLdU6SWGN12JLR+/PdogzarjOo8O25saB tYajtvUaTmuUaV3WkTv2GYVE6wC3fI+qKHo1xWtajkhDbBpG6KzhGFIPmA5C9bZAh0/QEJCN2npb j2tT2JumaQ9ygoopKiCWQgAbIxowSxG4qI63IuhJhR6FEFx0Yce9oZTBEQJ1NkpkxHo1ijHvRG+O 9oC2wVFXqnieioMQqqVdzI0WnOHA0DBWMMfLGx9WzPzWmdE7LFD7Dmr5Au6jQGNMh1PugCntpCkD 9oJYQPKL5SGroucGGfNP2kIuZ7bzcv+NZ23HFsjAUqkrqMEoLqJPyQY/W0qmOcKbwD8llhjAWNSm I0LR3Hy3VlVmuh/ZznpC9J/bL6LKfr2roPTzjE4o4biqbr87Ymf91D7eOLYe3mXyHpTtrw3BlMMn TASQ/fAWLqFPjJMHJ/RczoszItiZx3/Pal+b96H0z4zfj7S0YLwjpnYf1nc+cp9TH5agZxZYnM75 BPq2QR0SpFncZg1CHNw5yeztlagrwEdX+nd/PJguqrzsf/Gk9dzFd4fqI6537VBhcKDI9rPObgGZ tbj+f3YZf2I3D7NqQM7Rbxekp5WF+IOLz93oon+ULIVQRcGVjKg85rYXzpZM89XWZAzNf+cPbk9c nWmaKY79I2LEQtA6K6kdiIP0ajSQMd7UIUz9Jf9m+AD2px702l1nvxClP11KDFj9cinXIJLAn+ne cp7QLZRpDoeJwz7yz9Bv0NCB+3QQrI4vQo1lqmwf460Qm/y/CLvnvUTqKHrUXSPcvbUgtQp+96/a hpLU0vKWixL0gdumNf9FyC/ywDviRDUwjYeeBZ/mlv5jyGK0d+IV6oiWzZkGzfAccoMOo6BWL4U9 9YpmRxKd84G1N8Y6zChw79D8o3R24O3T5RPEX6cjw2asSIncUF+ZGAJDHSqCuY3F/5mIY7ZR2DwV yVRD7uOGNFEnTr8ihOkbejmP7aHk/ldPWmxGOe5BUPDaFxMv1ZxKireBqCIKZwkeVpQzoWewfaad jzr9F/VEzXW6gkS/VhDNXnolGmUJGr3j2kAX+ibc6H+TlmHlXloUJ3mXijeAR+unrEoh1JjR86C7 vEefLgkyGmoDUWYdpU3p7dg0RhLkClqFOoIRT1hcOMrjQiD5KQBy+lv/M3OW0qg1hrta97qvW1g5 z9x0RugCr5GbXBmZNF2o0E+rpxhGf8G+Vn6CF2en+p/JRA+FOgwOd/g9SeTeOdwIN0g+5PhZydDl l8XZUsG1jJTKBERC8sdxKP4KM/tsw0h/JTd6TjuDvAFfi11uFP/CBIJIlSORPzajgm6XCgivxD+9 1NOonUMbk80w+ubOaRCpxI90Dt1opHSRgDGX9bPo+o7Q9D5uc4lJKyTHoMa/j28TFq87DSxeKh6R 499INPLmX5Pk0C+pS2zSSISXpQsps7j2cxwRVF89ZlvkNt0BQLps5kKUHi2KHcooOhQF6RxD9mKk DQveYBtmzJlWTTNOhvUAuMEEQTwEW0k6w+64yj1CABbxcMNivaTjb2HzTviIjpFA7Owqkwlixlqm Ad62LGI/Qaub3t253rcDbHflyAkxdXEt8L2mvQlsf/Gu9fAtGS+EkUduv4Aqc9ufch/fdwaf9tQ2 8wP45PlRyG28ZKIJl/KEZMbef1zSuQjfja6YsyZZrTPT3i8hL4ueeYUtKeW8OjeCcCWxG3XrsXQJ LkHdH1XAxm40vFuO216l9rWYEEKm8yAhWOFtcKNbxcZF/7cNEglGENku4McaIIiscmQsm54gAu1K csgrkBu3tI1paEe3S5Xb53XoH95MVvDk6TvGNjiqjkypKlax+0FXiPIg42p9IHS4ZYO0s4JA8QtY 7hmB74ytRsVDf3OZp3YSDUMX4xJbsppxNZIZWjap6yENlyXQ9+wbYTu+Z0vqsbJlbDaDcGpr2axL 3X+reQgRvQTI2wp2BzmCQPUYnRg/ASwT8wMUVLMPbsMM79IImXGHZem1+dDftzMqm+0i6EoTxg+0 5qbQQ7Vggjfpcij74u7bcTlLenTQTkN6uZWjJQgmb7fsLOMOHNm2cXncfYoick1FQZVxY4I6QqdJ 3OyMbL4yVhEArvAelG3spugMmySLjtTO69EyB98rxI491HbaA0hoEQ5pkmYx7uqKRy2wxnLo/Zky dus0scyO3sM/xQg+qInU5Vj7UNLrfG+m1dlH7P4iPI6suxVlmOwSp55DUVeQtUdkHQWJpJR+ey1c pNuKRnxCbNkKo00xh3+z/YLNbWioKSmWZIVbrCcZneH0uc93UfyCk59Sf0XzQLfnvSzkX1PUYFmx HBdTUBNhHwaO8UKMx2aHTIer2vRbNQZB4qYi6en1h8eRrM9cXZosIop0qGtTbah9bAY6nS20woXm gSn1qIzf762VRgJyfb0BNkZTbhQsdTEg/ApyCjyzzLpQ27f2fysjF7Mdm++P66cTAH+yyx0AV5a5 uNmcl29Ma1u4UWHJKnsHod6LNtRnSQmrUctzdKNyKxrcsa57LjcPJqVul/v26EeFo+lJ9sgWNHPC R9h+iH+gol9tZZmG72bPEZdXIAtMmZ7ACCGZ9RPVb/hGV6r/pjQEWcGOQr8+rT+kdePb/DsGxvry IiJvSYwurjJ5zD8EeZGhCOkWf+fT8AVH+TP3+nGfiVsSqE3fXh8s2f8ATMwvplzjVs/kzJnlojRr YZcUXvAMGZU51xp/Ie7gQSrA9QEy9K2/VMh9ZBDzlfUK3czhTjhzZd7fYYRYsUov+haENjYWh4m6 KOtPQEU9eZkzAyn0HW6OCUJqDGte/qBc5eEIt46TgLEeXZjfaCoaXDqdKd0kuRinhXJyyBaLhD31 /9+NZHIHLNWsUIJ627ugu8ZVAFpTBZYGSBHi80WtRhcFcM4RTVP6PVXP866tWPSE2pZK2xbFW8oX 2G9c793aLE+H+2WBlbjbn8tF9T9TyhAVx3Imo9RXMcsbgzFrEpIRb7dNxGST0a+mewaIPyBXglXz B7o7kIne+9nheRpqMFFeHBrxWrm213L9tRZ0S5ZuzYwXFx+TdHN3n+VxdyOMaaRLAODBXhcM/wvo jI9mHam+oLmFmxoiZzHHMMUAKmNfWujlRKYgEv9uDro8KGBdHcLiO2Tz02pE6LyXYOS+8YGXzPJT BheHYW4AYTv9FsLEx7UFugzwtRkHUzvwSzrliLbyaJ5PsvtHt0lsl3PP3EyHpxsC/Ne2sx6oyzkw cx6+3jyCJ4kcBLWGcU0p6qZkHIneiKJrzlGOHqaoIKHioBiXRrsbRndMiX7fL6tNYe4dZP+Pmtd8 gk1exeg0nuyl6ngz6JfcC74EB88IDRynKqoKEs7SUenAIsczjoNUJ1Qb7/gcOvGOwlqHSm3snFtV sCbI+WIQ4NbuclXlgkozQ/wjIDGsn7UaEO3nPyd+1vsSl5mt1DlOWqTdLkT7dCLXYF+6rvCDzar0 oDja/efUnVkSkBOPJ78c1k7QpjKDV+9uJAHI0I04zCISM1l3sELYt2xKyBQo8XHPOcZUtx9PoMJo P6Hlp6dZYUKw6Y3WwNM8d4lm0coAy+5SWK7XRaDIv8/Y2VPXXd2IbulP8O8OxPNKteMm9q5P0ZAz T6Cp8D2lrZ/I4CqCZ+m/7vC9YxJSM7q6y28GzaMVj1toaNSvbD7aKhhagRbR8SlOVOPPgyz84hT3 2+yt6+CFHf0XObqWaVbhXFsrv+baaUilPMIJPlQCgHllk/dlCVNJdOndeHi1Vm0iavyFdiIS/Axq wD8avwRlkTQ0gFF8I2DfL2d1px1r77+JA880Qj/pSmanZGB1SqOlLC1iyNgne7Qz6o3y6MjrssMc kWA4UEOCIV6s8DmptzUVl5bIwJnDhDhbg9l0TcAVxLynHIYhgtQKsaiMGflx6E6Ngofupwwwmq9g GW4+zNGr+1GY7x9J9CSVVRlDIaC9FkeJWH/nBJf3i75Yzgrh22m8Ak9FwZjWGkDpuECo578i3jz7 av4xz3SFhZkH4oC21T65VcNj/uYmsF9WJ8LNbaPOxDsrn94Pn1oaYBeuh4qvMAM55GtHXAOkXK/N oXFhQZTIKnHyq6Q+vrkmoBtRarYrnidU8TBFg4n87Ey6wKg3zNBVRUnAoSVmawpAMDCFus58Y8Vt QttZw3TVGkQS+a1j6lXPEaFg/rCprCAwS6oCZ9gNjiZOEQruPHhaqAxIfaBRc1TrDWrlImXWDaaS 78wV2x+SWuvYRHX5Wm0icM3Bc+e03x7g7SGIeH1Zp5lT2ckoUC3EZ/2kOFCxCBiFGI+HBDKcxoO/ drdmXxnTevxIlWg2m4JeDs2MoN5Lbymv6aIdheVHfUA6u6dpQRpHUqJxqSNCLNVWzJtZM713edEW KwK/ifVTQcW1PHDfT84+W0LB/rChYPPePyoCl7gO+KSiPoV+mXap23LEkiXmLQObQurfAVQnSqVm 80PgMRNVURjaBAmgooj1qLHVagvyRYAwROneqH9r7AC0zbNsaoYkAHQFwFcXmJIB9NaAQGfRQn8y MJoreN2znKr2loT00GdIKlQE5YkGWUKo8dNBdbEPYZn6kVjedCagVLcz1d1yVKFsXHqRhvFs//dt 8m+/53dqgke5MTLUC1w7PnxdKq5EqiuK/ELVL/XPPRq4NGCbWxVfZsVE9KA5boADZJwkELzgR5AO OJ0kc9OGgAf4vax3MsiA5sxW/R9MC9fJ/ZWOrcR9eRHCMJ6BnRgjoSXRA51EvkMQne2h6Vn9M7XS X0/6WdU3fw/EdPzoSwu0drDHrCVi+0zZq6aQDCTAqzNMOGpkP27gbsvDFC+8mnds9hICYEssuim7 SJCIefhDKoaPurtdlbq0/3SmpiRB0fliqEybRdXQaH13ZN1fEcjj4Svvvd7ySC0YxJuPDs2cZd4B 2fya2ih4RL9EtR3VfEJ3Ej32/fc6HtncaBMiaG5zoMxhhBzjvSoSdBvmnBEWqGumTiScmMBJ5DF5 huyxMER4R3NYVdLkgL+2+V4uD3qT2YRZsjX7JLkkX2upRtzMXYtq56hSNn8FaVuh2evX9M0nQJqt fu5tDs/751vo7QVz9PeoFPEDaE9rw8OrbpCT1OgW+eLMYLNuLyJQCsMZs+xQ8lGLkJF6RmgtZxoR 4feYxfbVcdFedpDDyzScIsBaFeILa9mIsw8xF1tRIGpQZIDvjhEBigd9VmmBPRID+YyilEGnslxS YPLfZJWSw5vfICqZlRpfnvi8gdTrIbsDBMB2OxxFTJ1/1XOGn4IeXE/NZFNiGbvKJ71vvhC05hwO 3sp/cfLubdZMTzr05E13kV7NSmh7H9FRe4JUyRKT+V5oYp6opHLl1m1fyl0hFwtfRZEyJNL4i67u n29r/puXN070iXjAOteRvd+hGY2Uqek43DTeHx9Amnxg+Np35HltsL8bk4CDVtZ0eAKUE60bgVW7 /zyTlcFxIzopeIF1tyQi1KCRcH31kx9yzuU8LL/Cad68v2XC2zgD5WBZzs7bVgeTJMdl0knBf7JB XyOFpzoZW9dN0knWbdLVQNckrW4JfbL/4532X+mSWxBEBQ1ITpW5mOoc8VSPjcrRrgrwWfKByDtH qVNgPJwpzxOGBUWMjz/TeenrovphdRjF1f8vM2CqHP5lY/x5Q0Thy3fxapy+KxeuyBHWWtcWhY6w 07NnalzHJQEh/O7l1jUGp8nq1KQs38aLpDelW2Dok23UxIlQBZ3zdUQUxhPZDkadCRDGMpYFtukk Iu/xOgD8u3V8Y+KCNRgikyD6h8H/7tRYYOp34/Ij0XmK0t5W7y4XPOhcnfISDSqnHf9q2nj/n+Y+ ilFXyY50ZjyQc3ZraOO5xb8xu6Oou+DY9ltfglhGWY4RBJNunuk2F2YYaPhfjDdrwcwhh1xajCzS tzhYdpLC5GOel8V9fE5h5ZWBv8VqIV6O5Ou0xIl5cX3WWON+5LGyTADG1FGPrh8+RnmQe8tLaacc kF7L8j/8PJ6BzSpjqn65MjsdG7jTtjHUYOoBaW5wciW3K0Bk9aWD4CPRK9zoE9ftmKykpRV2GyeG aZOFeMg5q1ZjACTrjzytqb5WD0KWTDllG0EL0206BtpFEj+zjOHRSpawe5Z9Zb4ufASO2931hH85 049p256RcNH1dhXbgYKKIzHt/XOaxo2vNAsI0sZrqUqYO99Epf+eIZOwnQtz0qaK+CPFoji4twYj LbXPcVHF3jrNTzalriNzKG6MgemJRwzNlHvesqVYTrP1k3HwrfOyLidbJJb6sjOnoV5EFIa+KQ2b MaoPXeSDaIltikDDt0zoqdGmRI58wafIVFrAmmh5MC+OoRs/gJMiRfHyG6r4XcO9m1u+jPQRU2pI MWvvGuHZbiRYZw03pDvXZnVffKrMBkTX7KkZp9q3YDPHU9qSsEMbFnnJFuUQ4Az7KEUiNrHehrtC 3pPZ6sc4g1XvFNNFW7EmwCqvqwyLGD8tasSFhGIIDYf58hJ0rmfgcw6Q7nTLmnLVy9lS95vzipGw Lf9QWfPmZzVYfLdVF/ak2cj452zocKuV3kJYzYoJBaC1Vc4PdxXXXSCQ3xG/nYRL/8LSeF2Fxh/q wC39/mIGfVNms8epxQSoFNqOdnbJn2n0Kn/VaXkfb1FBML9XDZGHF/guxNT6xovbN8iXN4lBmHcH 02t3WAwd+Wxk1lBt4IeO1fPfsp2RLuV+jFfF04wc29pdWSUDNgY+oLpSGKYw4ZXqfrm8DnWS+chJ FjeuJEHdb8FtFWy5SpfAZGkTm6EHEllt0a0uPKgpownT/kR8CoDWy6WfvHoWOwJ1chElTeTYDIPU iStJ2GdQj9445qRmvWKKxye4u9XVcgPrIg49suA0QBWxjLxtziwuOHgKOSYN715eIdCapT3Wvs3o FS3phQH16xLjJ77nnOauNj/2rRDJnBD25tcy8C74sp/0lLYzhzAGXV0cJh9QKhIqBw+h+7wyNE5R Os2z+1vDUJmhraE5Fm6JCw9zx+3tFopmrHvBjKr2DfxlVe84ahpsftpOqdMbRezUN5PPqnCcrGKs 3G1J8Fo5Zs4Thg3NbEKnV2qSQhhOvnYY2GERMTjuSuZJvLXFtSt7qDn0xJ/s3TacarPc7u8LG/sf Vo2bNj4ay+fcvvG0k6v2N8H1ewfTYLHZLpGrsKpCFB05ExX32iVR3Wat51A462L95IihV2oRI3SV Vk3traJ6UhfDCC/DsBnYkVRcsSJPXO4NKk1A+MxI7fZSN9VGt5dvvMRf0hrfsbS4imJV4T9SaQIE wIUdSYQRkyx/ouT3B8UHrsZ1KtDhcQfb3U88eUSH+9CN3sPib770QdRw7/dAaidcSpYhUUsZsxYj 23MBTgzanGHmcsjio8vytNeKUOHpPtgzGHhDNDePGYl0fV3P8bDgv1BKr6B3JBRlyIIUytr8R60O 4X486v8BHlDJNVQVfcz73StDmPMTNlb/puHiamhZh3SZ4U9d6momW2zRF59v0UWK+KZ5LIA90Ifr 4YD0btgo9OwUIf2QnMDOvPrPNsUw9j3LOJS2aAsQwrpLbkJjyQxy4IoJYrjfnUsgIOYjs2ohDDki FDEphasyIiy7OjCqKxpWpNGaPaGZidEIg7RcgdehNi9neB1ynYjzk6Uqzenim0elipOpECj1QNjP pAlGUw4YynPOuL/z9skXg1Tf1u6JJir+eDvgPo9AKETs4FI8oDtuirp5LWfr3GRyKY3bijZXiZji MvhZeJnzcBcuYimwkPRP5YDNcnwNavWXgGVBex4kQScFj4hnqpQR5R3zaGC6KDc8AaKTB9kw0iNq qEdobxNq7BE6hPMAu7CqO/G1KNw6BXQSJKktT+zrB3E6VT8udm6Gy2a6mxP91L8P7Ham0uYGq2RT GTpKveYj0fZoSPUWBqMIpxRKdn8s7pKlY2ws5Unn1Kz/0l30qqNfr/6TL4HosfWhyQZ7rh8ACwOZ F0D1s+NKoWB9OdAVNW6BjCfhx2HzCgyZXZiiGyw2Mo6Hlv6TxkG+gHxWLWOfsYIDtTNa+AWfEnAq iJi0ukoEsjccctZusIfRdgVgWkObk4F6mE5G0dAGcrlOqwYOutxB7xlUSB5X+y8zEH6D3s/uoVyG hrGG1JpLOLxY8mk2cnR8fgIZuKHm/jiY6GVJYr3cIg2MGHykTDAEESF80218cWisZw5/AtITjVxE gXCXuFBjO5wUfXN4ioqdEyPMsBi9lUoAhq8I7/4AOHR7xjWGdAY+33eA9isAgvdpX6z1z1HXmK3G y1J8X6jT3KMdPranUAHbEjN5ItXuKTlRSeL7V4Ud3adyu2PHRhAHP4TuxorfCffkoqwpFMbzZ5dk yvM+83srb+uAjZcwHKlVKssRbFF300dNGOxxbXJz8afDezquWACNHzEd2GjS2xWviV3gaMbRknJL KTdF7wcOCGvbwq/4d65wl4bgaZzVtEgyn34FKyyEQUHiodmbWMq7StMui+M8KqopqGK1078dK5zQ xLYC58s1MxPgrbv5oHCgOFOiNAoYjRAjvLu/YEALp34/qrVMjaZ6FDPy4BLjCCoDGAdFUOW4OMBz XIvVK5TDV5p1A8gPf0btfrshWnrRA4zrIPNuF4QOoETr2hVFoTcoxliJFYEpx1gCILjaKOY1z47d 9QxxGaRTJdqgu4aqgnXYT51255iKtln3DnLqkk2ah1/JsCqiMABK2ut4HaV3k+CmVE49xldmpjaj QgYp5hRNVNEblr2LsrlP9hBW+VogfQ9rb73aXCeIkyftss3qpoTPD7NxVa7Mgg+bTJ/bJVnEIjal hOi3ZpHIWi8YNfSVCfZtvsQRgxTdKocpp2XpQ1jhLt7aXZv9t9gZCZvJf9qjyvgfbbjBzZHRXbUs d5HfOxJAUPUeGu/Lxo92vFn9vqrj7BnBCkIg3qpC0NDb6m68Zg9yJAgcWNMj6knGKuH0vRZowLHV +G7AveT6d1ER93WYwTrRZmM91iMp8BR/8qL3vLU8Wm+0SUk2Fu656GEufyPOZcPQ2bUEH/C9Y8zs 32Zfu+0/3tlPs9IA72veKvjMP4JkKT5HQarNUUIANvXDOGB4p/dnGBb3SLHU8yWvD7zuoe1tGoTe Dr0Q1VATrSRT6hWz/fk6SblnneO3FlWXeN9O8c+lKKm8Xy9fPUskGclQq+IfiyKQNWh3an8fSxLP y+r5bfSKftX7VHPUdRX6irT7Be7UNHN8kAPwjGd0LLuKYAPtFHYUMTh5422Rqwq8wmjhvJrMhb3w NM7Hk3f7s8u/Lc1Qia88U/BKAwl1OtDZaEA8sAJh0JnghzSnHCs4Mk+Suwje3Jf4Cv/xGIaejFr3 +PKtgkl+EcXJzW1ZMcB/qfnFv7nkj6CNp5/LNZNbuSwZo043jwT6nN4M55BV26ZTVNL2k9zCdJqx 06KO3IdyAU4LXjiV2jQKMF+NV6h1oPoVFsgLoxp7cdtHkMjlK7XzWGyYcnGLp3V+xga6LEGgZ3Ab i516RIUoYKznp1U3jaVVWFdYB4i28YC0317ct2Tdix4JVvDXFmU3hoX0cxiAYjP4Agi1cseewvWW Y13xr7FhZRCe2xUa9K3ctexMeqPx3iJlTZBDbvBlGt28Q4i6IqHwTC++cz5MEqu2Z7M4XzeBH9Dz yi9ZX5KJhVh1fWihJTNx8yvyhRn8e4RCxFKWzTkaoIHmNpqEJgpc02jNv387IP68QH5G51zJTVbT fE7Kdw2umv+LIkzrihKJLB2SAxto2l6VNZMavA8Nh5q48WVlysBYh65VGtLczt021fAEQizzwLlo 8Jcn2oFmfqyecHjx79e5EWTgnaqHJ/PFpPjCX32VMOuCdnnkegrMIidl3DYlxv4ZxcLxgmdCA5/x BtvjkILIRjpFez7Jp5tFOTCqggL2kJq0UBxGKUZdaC7DBkHOoiyIaAW/jQ4ZBsnGhzADMp+42ZWZ rXiqSSUJncBZsGDCKffpTsycB7QwFfEmRRPr+U+/su4PZ7TZf+zUjOmjTsGL8qYCToR5yXEympsN jXqt/nDoKIcR6NbaV+Q6qal7b0bNsQweP8su1LE8UPFY1sYcoUoihAmpdtsFkD+PWwpKg5suVX+/ bYWVaVbelD52xUg8sd3LyZLjaZpd1YdOIjMpoDXgCXbGSquI2QpKIquf/XU7FyCXAs9JEljbesD3 t41rEmKLtjmjxIoP8wXYysWuUc+vLk40QfZb9Ru0jXITT4Z2ag/rSN64TKuKZfmiurCw9UXcXqeJ Tqwff1fncuT2M5LttgezyeBhr8SC2DFU7aXdBKJbeIoe5CjnTITDICJ0gz9U8cE1McMS6a/P39/v L+Bmd40JpAGSI4pBNj5BDqHuLHRuXkH6ELirpHispf4MlCWcfNYfqvvztwnjqP1VSEx3V3jZpi/O tlSoqk4xr5vsMJeqR+vTEmIqZiJDiT6Zzb9L+oGOM+ZvG0T/clSOkHUrqrS+S+dudhG3oYFczuUJ +38O/GmGHuESVYDpTxAftwEQEVUoaGnNnZ1RObNYMnGL2Mgp104JpCCU3MQznZ++i9KCQLgTdR1I SlWFROhf9NR9RM5+Rr1xqjVCiNhpuUfTUFK+4fb91twMUeIKH9Tyk4n8guOa9YUI5JpoeeSGSeRj gs81cvsqvR3IMGBSHfQk5Q/r8WNfNrhoeV6u9ZcmoujzNxp44/9VsiQhRRKUFstBL4i0DSIcVAf2 h3Oa2deZlNSU5NxTnbT53j5JimPZRIf4BUQ0LdyTGJ6BDAPSYQbRbzISd4grT8mRT2Z+KIN19sXb 9fwIF9+4E0u9ftpfjiO2pQ79obB5vT/8IKdmG1axlOfWbLiQiNKCXUCskP+Nb3fZAek/T7GNiiaI cRZoXd7x2Z2K1BmUjzoXgSz0Dmig213wA3JNsF48tERl0BWGiMIwxoiE0TFqRT1rDmu5k8oJmeI8 naRze1lHngKetpU4yO1Ax2aeNiFUR9Ez1npmbxmER4mc/XnnuY2E0d7Jlsl+tl1/dacTa3zKI0k8 Z+J7029sIUVFr3YGuPC+4llwfCa+k7X999fvYDRElWCQCmz3WHfrmqGcglvQoj1By25FftdGrwcm AVbDycQIYObgGjuongUu1qWN0u6PaEW0A8dMvc41oGkvUbMufkHLoPIkDqaky6AmW1pk8JIl2dti DLtzDiL4WFcJ4h0dN8yM4KbXBxeQNn0wPN+js/bCLSFNKG7zk1Vf3ZoI1o+LP3vmqGOoL+/CN5sC O69E3P5caBEehl9MyadxLElWF5mjj6WU731g4PzusWNklx598AI5ejp3vxB1ywywrcSnMn7g/Afr tZN5jt36SfFEQqqYS1ioTGmROTP6VCwMMl61F4EmmOGpLYWCn9ihbFHU1kP9apVjQiAjfZFhojdA wbFTVLu1quczZazPwe4G1oXQaBf2misUx3uAc6NRL0YJyrmLrPfKYoBaB5mnR3fKBiVWTPefxtps CPxFTXexIPjLW0hwSTVfBFuzZ0fRjqaSaptSPQcqteg7PJAiImCVheYjTlR7pivUQ5S90m9LVN0D zn2JC0SfiP14X22innane2IUvmGa0x1Joz15a6lHIQvXONv4uGUtsNo2+jeemTMyZtB7b3tNo50e xclHUh797t2Y8XMcM61u0US/T3Lzkk/JRCkX1qMsxSqmBDM6X7yrihL7JdQBeRSJ/Zm8hcp46p+T QTnGSVlYnHvZT7r90wR5VpNr2t0VSpRNzxPRzgltow7/Ejxi0dvkpY+Pp5Nnv5pSRRsptbMpJfpc siU0ffFFkcN4N2WbNg3SqzfNnX9OjpYLgf/ei6AwghJX5wkt5aUKmxN3ankpVKVQr44NeIYJpfEQ sjXKIWsMezpR6ZNR8feykDtqpZGFgipO34aiabKkbQZhDAel4scESs7lhYiCLqCEo6AiOWzL9D8T 5jBdlt5hrY3SGb4ftt4Ez7zkXkftUCVBgKc0aH167RKdj5tx6hght7EuKkHtlLqxs/Su2AzLQ/N9 nHKvgjgZROV8W0Uggl6nQXBK292dtFsP/xO+qC+q7NmTVy1rKyNrBZWF/G4auzQKaWaVBbB5jY/6 wp4aDNnDpTOzhGukFk97Fhui1Zsg9uBJBp+l5urdbqN3cXoJdv6daIglYOZnCNjuatITMGGZKfyp d+sv+m3Bfu0gXPugrqGtfwrJEWP2wiPmvjnS8rxbG6BeyTlbfAPXfuKTKYHMgWZcqzSxhw9Wef9T pRRDcdbVNBVWsVM2gC2Lg1RWC7/X4P/nLuH5T+9pwyzsZhUkZFvfe7M9GXEAGS51+1nJ/xpUE5bf Ad6C9gCIn0t1OQfzrNcPy3YSS/B/X2jFflqVOewCYMOY7TdTBDFd3Tt1FDSA6XxeeutT/ftcu3El C2dPkYbCofnrg6lWReM1VyPPGKOE0VLtA9vcdzsMrfvQNO2xS1euDQwHqbeK+SW8Dg3mCchC4+P7 bESL6gBMcwY9yrtHxMnAPIcjpratfrgJQ0WLCsZZes9dkaGKw+oR6qt1z7/y0XL9ENKtoxEXyT8K tFdyvuFEFYO+kKybA3RzyNrJ7JObba35qI1Q/aT2Hfk0M+OTd/+KUQB3gncLhmMTVd/aQC6+eLQG WfWdLha3UVsP/C5aXz4JlV04lrs1pHZClk197RsDraK1oL9xivmr+9PZs7nB483/5DSiKGvSw6Sj lFuwDKKQjPLbGwNa45Lqiq4aX3Vjsrs/mRJV6etjRlu2cA76T0SUoKZaPrOaSDbxwwvinkSiaE+c jHOenUmlZsXSvgkLyuLB7hrxltQR7G0FPESQmMqc6SSaiG7vIHKbTCxrXvKB+j7m6jRCs6PDSflj 2XF/wlOgmpfG+Lx6TVr0O3pJ+yq21JY118WjsWbDEsGQYh+Sw6uhap7MVyQXlUC9662Bhux31Hsz PSLjHnSicyiNWQjK6nRz4jomZcf98/9RsHPrmOmk2JcWnCEmsJvLDsg0BOwqnWVwatOyRqpSmYJl u6V+bJ+K6B7noqz/KJLt5PwewXl/UNbTLTC0F2K3AtILc8YJa2hXwl3WW5lPkfimqa53Beg0c3br Vc7suxM5T1Mwte2WM9DFTTNiScIczAxcLI4Gpxs1rmorkW4bA/wom2TFGaIroKOowxL0V3mSUIkO X7bGqJzBCsgL/28hX68X7ctzkkrVeUi4ddSducyEx/RWdEDcxtv0da0+s44C+rhMK+zr0MhVUHQZ ReTohdqVDJSyZh04tlXhPZ+Gfh8horFHf9RpK7+LdQPqMjgaf3tbbXrsxLBRsT9VKzCImq5O6Zyr BIqEveLU3rRLAQ/eiqI4ai0+c63rLAV7nf+KFwGurYGm2UW13F7gckP1BN4xHI3P25RkANJjsWW9 Rak21Ryby6LZjMvXb3GArfY3rYggxwSziPmuSI0plhpU3Q5h8584fwleMyYsut2wyFTej5TTA5zi wJh35ylfqDXDlv9MVjvOGfk+3i8oF8FOjUSyftmBcp/mIKPDOu0HGHaZxnkI1o2TbNZuaj/iiZPC ulSyK0Px9GJEDnLcPrw0cg0c1PO72zM486vNPXAUzfmb2jRtFB0MrpC4c0Kbuvw5NoNn19Mw9FYm lS1rqWnmQpFJVvCVmLo0YTb4iarAdjXQXH8VRAgm5ymZ0d/Zmli9qeJHkqT4SzoKvpYfqhoypGEL Da8smmZcoAAUxHTRf4/wMfFfPfy/kJ+zz0iX1cuuDUannA5Y4o+s3igVkTvYUoS4YEkfNz4p1huN VWG/ikbh3ui3NhgWL9oKXq8X0U/Kdceav3LmAvPbGXiU5eAplWooSEVkoabRvQXYN1uCicARzjWe 3KmXJqGWbVyj8lj8LyPelz9sXTOrrEczFG6c0AKMfa85l+LvgfTZWGFz02e1Iqkd+Xb2rL/5pGPH pLlBB4heISlxseTbgoGsTa7ZXx2UOWmNImpPR8rCwGxjVhygqdr408rKM8QtcamurT7yAb8qsAtD HdEidV669KcGlxTY6PiAyfNI0GR1DM1MjeYjHaZnryrsPRto/KHUZzCMc6aop6WhWsl+b8SA/q7c rNQiO1fYDkkrrPL9QR3XAgwVJEDSx+t0n9TChajY5HbM2/e7ioVAOTBaidVQ5qw27XlghLWy8TpP /4CbGR+i6iOdF6qPDlI7TQ6bRuu69zUsmfpHXvIKOarT4vssb3Q5qxN91bfrQXyc58AiX+B71Hdi UnFgRXPEPuzI6Lr03FUVb459H+tqxbfD9DtB8S8OllYFQuKcG/Noeyo13AqJynXOCTFLL9nzCiUz Q23BbfuCXYcPtHegtfhU3GqX2WoRyOcExbSJB37oASAbZ2db1c01eOKn9SvyrYCNvLNEsMOuvqQe zniktOhDF2rFEqGsJlYfKikbTLjSTvmxqbb9ho6O9WqAhWUV+PuK74hBH+1MN4WFIyQOIn9Ym+hO E0kg2BuPJcMKordfM4byoOXv0i1fy1c2+kZQT8s8+yJrzqU5TNrUnDyA8v59VrGiG6X/t+Pkw2Ek ewKCqwNUU7fiwLwTrD/RrGHOrv2+h1GVd7ZUdOCKoSAfbP/tvjC73ybio5pN5moUsSX+f1TqRIZS c/WnuznFYx/I92RfvVHV0DRRaVfDhW+KaN6joAc5qXLRYqjE3z24XpxZsVP4eWBBobCoam6Q2JZD sgsD9tgT8rnjI0OrEz9iX77Vh/vJmQJsKaU/OwUao4oGLNbwSaPwRi4RMNIC0aRmDvNjJDHyZ/3H I1Rqq3eEE55XHQivRvWUhxONmF2jaY2hvMFDnByGSHctBRPrvAKcjWWatMjNW4TN3lZve+iAjUUz yOdXAmkE6Iqki44CRw+jCoUMDD7biPQkO3XB1ecoKdu42/LtKoQQbxY5s/+GfKM1h+I4h5yT5d95 iPdFICScM4P365/vZWHuzSiFFuB/m1zUFJBz+Ditx10AwU/AjLU1MzKz3QywHppitFe++7Flljge ImV0NIrGo9Xb89h8kKLUB9DZkUbQCFdZOLGbdEn+Sffov4fJ2v0lhaY8C/Vnt273OgwkdZdGA1R8 xrP8jVdaEOlWJolQefykBWqYU4Ga1HKNYIjQwJqQ1dpU1AD7qzo6kiZTGkc0I+0lF1Flo9rQibGT LD8BHmrtaJx0JWvT6GHIUMhGAWhZ6bDVug2q7l+SUmhpb4R+2aB+SHhrfEnqtezpcuVcAQ8hqcDe DdpAncBqVjJwZ2epOipdys3Re19UnBzrSxzb4UxEVi+5BpSQKdSfFSmYRT/B5FNP6UJqLO//k2RP XHCCpkT2m+n05hsOmUfFuhbHoVQ2uuQAusojcYa6Zn4YC8Avp+77d9xpzV+IO19kqgMj7hNgrUFW 8UZ1PP4tOqM1xTfyqfulRrIxEEwevHv9mi6LRICB09IaSqFs9vPoeU10DByFm0Go7EJju73tn7UQ DnxgnTn/GJGPZ0vpASpdBsZTMyAmE9nnWVyOyZztSGpSt6sirWlbiF7ogswd1ZnxkdvWYBrUp3VM GAI+hQe7aTpD6ZLP0xbrigP/0kqYU/4j2winxEdZ+z4fs26HlrSxjwkW/uiuavupWUZP1ov4uldT oqdHLyCGXfXDFK/JmYHnXjND1L1AckYGuNCGtgR4bYEpCrFPI9gV2+gb8WZL6Nc68UYpbbzKfxWA 8I7tVyhN7ZJTSR5KIh+2V7xVdHhyPBuUTRfDoNQ5FZrIyo4ZFvkFGmYqKt3CYtnFNz4gAs1cSuSS TOOxxirbe4I9c+GFAMKKS9Ba2K+XfnmTHow4Pas5V7GiKD2EUqp6G/Qafohxj42wfv6nWnf7bM4E HLfK1NelZnR4L7+nJ5BHz/zzeCPwXLxYbXvRPrSf2Nyd7w11wZn1HmFwznVMof+3sjs17Kwqpdul wmbbKCqt903e2U1TkK3KrTDpE8KS0VRu8lXjJg4/yvpThRxO4MWDh3j6LFrnuiCz07aBDjj8DZY3 IsCCIF/jBwpj7J/ebRzHNjVZuGpaxif6fu9dicLOrfnQjJUxrxp1dNhbTmbAwITQWvk22wcKb86O /wp5ea+aK/o8BcbaPFVxIRwe2WdNZHd6GAecrrubclPJBpot1W0sGSO6sUEKZm7dj6lX4D0s8n37 99FV8jArwAy/qQ271nEClm1QNgJRDXXe+SmatWfbkrUNxIS2r95aWUJDWu6fMXlGyiLq7coeyY4/ /tD2ohG80rkD+2a2uc1B1sqcYHPeiMPbFTb0jj/1egOwrJnllA4gMY2h4gIN604QY8RhCdSugmlH kxFbro+//Ipncw4eYYNDB3uGB40c7gY4KPsZQR/kIs0wII8bF3dwWRa+GLB+5AggNB+0rRrH6Vg2 8c0ael/AfhHJbLJYnX+mGNKzUvzhMFHRAznaTYsbho8PLiqpqOPEzgLCU4Nj/elmeKOhMCHHWnrO nU/SwaEMKLsRQeaPLKLDDuTpZMO9ktPa/zgBymoJvxj7Du4DIOzmDsvNtKkHJrA5qyByXGrJ4ins t1VY3e55vGi51i2FZ/1Zfg9dHfL11EG/uakRN+7B48Bi+RUHSOFlWl96VNPR0t9AM6nDax/WhM+5 6AY8RiwboBJzEM6zqIcLNdF5V81l7SsxpRxxwQMB3CxAxYGgqDuTXW4Dd3zBLBNEKckuEnl8Sqz2 EwRC4/BP7A+FPSLmbaxdHP49MmWTPTEscVU6PUxq7nvlDTFVX+mQf2reO6J6mkChNu71rYUvvmFY 3qHMsSxFKY2CLB9oXG5mIWxMxbJIbtKA+ja89+N+ly7SW29U0NB87GZkITDTtRVSQMcI8XIy1kkg YNMF1z7gT6j3mA5irs3yKdUK8dwqMH16b/gKkuWKo/cPpWvHz+8oI4lLl9RCzrpWOTSe/9s1ZbAg Q9R2mwUro/Ce+knbSv3VNYKB1IXhuxLkwZCCXK0sYPMMzV9cpeTYxLgjr2XldQnD81yC3PPBQQFe q6Q4vbDv9mfI/zedZVLG2kiD3FAEHCPXcFC09YCfU+QoKvdUrq5drMEMJQx4WDRsT7umhgCsUHuw qyOlZL/GEC+ECSFUfnix1YgKdts23S0q1lwxfEAZDIF6T/F850Mn0E0f5CMuVkdSeIFbUvuyRcAr gf9ILMUxWgr3iOsHf5OSJUufi463B9qX/BpHdlGpDVxpIlg3pGM+WVzm//m2AHaIOHH/0MMPyBgf 368bBUiihGRRIGOeutcsTQZLE/qW/DXfSUcloFZhmXlEY0UW16mZaykvFowDHvUmfm4zMz7+uVXA turXSrbmbyqeIIf1KxpjXDNFzfAvw/RQR8CzD9HME51W1GTWN/DVd4QEIWBsOaLe6MHjU6epfgoo KTCnwOLPLcYg5g+GShtU6JzhIWxI63pbIUPOzhgsVbxFrVx4GI9LovDJwTv4gpk2/mVHVH2YkAbg lhBLiPMjhG+iIcPhtEeHI/9KdJClIL0p9azegMbs8QAg1lLwtJ4HNd4HNiEzzKVApMQoMDs6crp7 fGOAm7fJxwfgh5DD4s1N+PrNdrfxwQtv4hiEPnJXEVlBkYY9JFzYc/9AdVAub+sCGCf+6qpRbRPd 8lajQlRlRw/Jb/OKDJThtDqtEvX0qpygxQON7jG//slg1RRfHsgoUNrhWgeHR7bAEWMX3FBVL/e6 zn02QsINJ4tF3/rF/wnQvei/Q8Lxi/YeG8Who+9S8+bT0VFzJNes/JLuZwVYx0M1uUM8/K9ZjNkk WJM8KMW0OK7RLbZBDzApT5G1izW/5ZSkC7H73mxvqbLFhegW5cGW4EWwcTFJe2qPczzvP8CVML/s pd0LXJf0iYYHIQvPJPFmeAZtQ3KmXntblyRuHTkP1LkIMnY7zIg1KvLK9lauCzr3jH4EHl9ng2VD qZBO+CP7e1mxRage0/or7gfsn0PYRJjrhyRxxxf6qgqg9qZHZAS14zqYpSk3v7yIFDxeqquFSyEg 7JZp8U12k48RFL+i/kNJ2Ik76M00OTw/GEBN11nT3UmDlwA8dyl3R9wjaK6/LKxCWo3ILkUyW6Rq Ni13EV8TKhjK4RKZNt7+AS/fulqtNpA09tTMJk/Maut/3Z3FfhUC3eRKIpSP7KKTh9Rkw17GWomc 03xPXqqnf2RPn9nPpR3MNFJnOL3DuF/QtN2Q7Ec1F6bmvWXTg71Wl3K1wgMoct0mtzD8Zg47e2SM Kh1BExXie7o4OGT0ZykKxdl26f8v/dr09QMVAxsCRE5eoWUxuinl51FOIkv5JyAFFCWpc/kQ7kqe cp9ijOYs5LQCI5ZTqamLnWOQT/mtm7a7BnwPKPjtXufRy+O1dzftMCQJ31xbCb+CN7GwlxaG+8Pc dC0GuTrUtPCKGRig5C7W1m/VmT5iNJLJoeU5WKgW/XEUGoZCUf2JbGEzRKsBVZDkyNKhWui/1KVp cmW6cIBidx/TVjo8nNIGOh+ikTgkULJ3rexN9ZrF6dtHXTELf+PNXpVjP5jKr/U1Zgt7dYL9Q66I mwhVGTMNE86MugdyhLPVgC+n2nyu9k9rk41ba4/PT2UXihc8Z22CR9wgAhOka0s0gjNHNNRUNk4T L1JXsaFoi1ZNHJQnV5+mq5NBmXLg9UfmTx3TcWqoB4eXXQwh5eayYXAXhuNB3K9f0USEsL6rHeAn gk7ZDRkRYTDwKI91BZ6gLtk1oBWiz+wW/HdEhK/aNGLDeztp3bU8traFmWRMSuvj1TeM9nvkPuQu O7m9A6ylKpt2HVx7sWuDH8l69moi2uBCeNTg+u9Ts5vmH9M+Ym0BJvd6HE0oH9qwktZuuI+IMyKr rxN7P9GUEXgmrmwDYrVZMermCQP/HH4GObrBcaTi9XAUN/rJp2qY9OpY9TlTvG+IHTFyTSpP75Lt 2ORAi1zQB5HfE5oGSD/i52MKJXXptZWzeN77pMumebKQD2YjoumM0dv9plq/Lfoa2Os2iXj5tFnE 8rsmWoxoLdNpnMKxuxD54Yff4J17qML9+6Ka33zr4juIpdVXFPscAYgQbzEUb2UmFKmyzcCFMWZK 8RdZgs2aRU8cpWoOYBUiaIUy0nudisBGwrepsnapwy8ah0zyRGMgSNBRyAt3KIsB5mWILX+L8VDU XxRvwe70//9IS+hwDhk+393oUSGaKoHTiBBwBX+niDxG+gz2iGNbMeD1151vzRpMA83XeIXZDUJO 2OKyiZOxl67UvRJOv+jlMTaZcsXA8qgh2mPABF9s4YGGX6g3rHOBsEBYxGYld/bN0XtD/qUejFV6 MPWf2tkmEBbg25/zXVX6UZJ1OeyUVaF/8M3bcSl1MVGp+4I9y44IsNo5aL5slXOAadDYEytqGw1X bP4ScOCf4kA/Je5oR6p+PvSRwAYm1ep2PVaqMALtPuKoL6u9YqIz1DTu0HRAnQY9ST6Esqg3uxzI 0lRsp3A+roBbuvmRqxtXpStBQ0qrRDgrqNQXW2xvreJqzgNKN/5NTX22aOS5EpQWxhTVcwyprX5A 0KLXYdCKE+6KMRUMNGYtH8CDdDDosnnyGxwfENicWK2sg0NpnhvnJH37IdlnLYXS0UQUYc2hUKIr MYvoOnhkdoRfLHHXU8gG2xQRXCKfjm4XGXzPeiFe3+GI7FPrFnOWZu1IDDASEvKtK92NyKOa4TfV synUNBmgrywdYDy3BKAj8gq6IRJXxovLz2L3AMUoWkayX9GXXZvdqzRARivtyb9hcqhMBJY4CV1T 03SF+Q2MI05Zceucj2QeWHwF/MpYKwgH3tAu4EhHE8hE/vvMpuspHZN0fWCb3d2FajTi7cMXyAxE xbrdU/lBk/jvRK3nyLWsdAqJEFK2P7+d5LPb7YWIX98ljkZTcjV61/oagidIRmkauQ+1fGZVMSMg oiCIPWZU5vxhYEV1Gj2EBHoVwX5rzCMprxXMFhFwogKxOn6J1Sk0TJQDgLS40wRISWSW45ugrvMc UGN5lNDUF7Cw6W/TwVaoLecZOxVd4uQ+SrqHtlt3/gIBTLoo2xKVUI7fUwNt9YgtGs4SsyPWH23O Y23gSjRqEJipVV0u9XbtX32C55wgmTw1g6Ta8gO+/DxRRMVhXJtAbF/uybjzBwCEnUL/N4MAk4JP loTKZ91eubcMdazwIyQVHzGt+ttmUwmAaPZxEBzS26GtTszRqWhrnCSBh6GJF4ZrM/goYFGPpdtZ 5ecBzjxV8dHlLCclKGvGbEWjH6DGOyYnY/c0AvVkMS3FsWDOpCPsSqCoBVSBZEjPWr3dexgB/ysL QfS8Mdb0MnXrgmdw7UhGFPSsAiiKkksnIUjMkQ6ZViMBbx+3Tsty+1Dg46KZpqSyFSWZBk1yqwij IdTd6+EBSfsrZX2s10sv4kLqYriy7OGgPnh4Ef9jASSLU4zcgyCAKtK+5sX2OcbJc+WktDqd+KPp TpvkPxAODcq5nZe31QWshMP4xfL/lSR5hZCBs8EAZ7f5p0dteuQsX2RlWwSwBfFFcG4cRYRG2N+H 1iW3wZBtIksa+Cq/KWlwMBN87q8SQELPZ8VvV59L8CJz+t/ws+i82WpBjUVZH0mCVDS2rRP8C71j j82QoXAX1DvA4kMIsddyFyjjJmeO9VKbR766yd7ErT9hNN/YumyIu3zr80NkGoV+ga8e/xbhZstB 8oUtvozaBoISzGMpZBrYpiHJZ2eHUSJ4DZKo+jI4+XYf+qkXRBKE7Ph7sJEdhcsVqG1LOyRhtdTP zKHv65gsN3WLLrafO/zJOEdyTMQCEgLuhM4YFitsB5aT7OhnUaCV58lgELpcNimQwA8bPOqZmsiV 7P9MpCIYsHAn9k9lhZqerU+MuCTriSL5zPixE+UnQ5R0JUjavDao/qWIs66s1X4jBnkGiY08b8wQ XKBgWeie+NggC7chJ+J0+aO0DxIW/HvgTqb1iEOSf9yEP+Ut5ae5hoReNFG/7Hz9nnnP921sHPbh qazXBty+Mfj57KTjGujRxKHQs9Ej/kC2dm/qCcxsnRDkFHt1Tc9PVXblwBmO2zGdZ8KnhKhqthpi 3661sPWv2KBZac++TzgflUQmRV4j1AmKVyK7oKukVdbfoKTrdKJ3hMHUV8yFKD19vbcunc1A8DsD 6haX/kgu5ttQGIJkf5sJh5j/nxzFE8DT3ORpsGHcklD4L5BNMQhlAMwR9Fhz0R5B48pGaVqNvzSl jk+ZiM3QsZdsfJNQIVhe3hBLEC4pNQFeqEzZW5Qgq/zYedjijmBdZ8JVS4gEcdG+fdMJJAlTiHvm CWAoG70kCA/JEdrq4Zy0hk3MzIXGz4jx6pYMBQBXn+5byz5wSPH+FNyMO+091rpR5itOn6H9fr9z KewoluiWcje3saieHvuTA+cxriZZIzhN7T5ILA2UmrkS1SomeTYkG16sc5DKWsF53rGF0Em1lMNE ZxwiW8o8mCfZ7Y2XZO8FoNn7eORVMtlfpN6lKicUjQqelITlkpFouqVVCodMfcp3tj6icAwG+c9f cC17kFXqJuW4utxNkbvGmY13igjcPq0vfBORnTYmHstys8t/9ecbjfUhuBRUafYHnHSRZGVJDeyC IZShDof9qPuJbLuXPhi4m1NJTa6D3cYOZg4Xdn4YQmQP+au6csoAvw5kqRYtaWxKAB9mTEEZEhcB oNNws6zOLaU20ZC2JAIPs3beAyh1h4IuqfpHnD1mTbcbWDDy+o2w0YVLAC2Knh70qcYx4vK0DuFb eCddEiFQJK5a/wFqD3h2iPgpZmRUcNvn4IMElPxrxaTERS8IuxSwX2rCO4QZuQ/f6Du5eG+CfMO3 ubqHDK9Wo/JsLHiHS/htM06AozC3/e5L3IdvRzGgA2m7PqOXN73HEG8+BmGb1ZpVhKgZKXqAm6dA 4EZdqP/xv+lpwlPtY5RxoS/2KRtvrUw7/g7bHhsgw7h/YggR/xP20p0ryTLADNYeA8LK65kJB1yV j2BssNVCPeHwiKofPaxxQJD0pL0aal6ibl8eiBDtQgqwzYiDPcnnkvsOYV4r38lN9nSpHo3DxO++ HTM/5wzEtzq/iGhtxHj6VxOlCLJ1cJePOLKFNF9frzan1la41t+OYyfUVECWA5JqmxrCdwbvrkhP 1heBrDgEqxjMvplJTgEOYM1QtePLPDtUP94wUDy/2EfRZ8LHLYl+66K6gbx8fBBSk9wUA1FbkyvF LwmdtZXo9/owShedEvrFMc8q0yufjXZiVzFqDNcaUivtzi+DvSHjObzBymJPxXOXhwM/wkSIgluc f19j+OSu+OVNr+bJu9NIbkBOc3QtiHhMirfIWkbUQP5k9PkOyuBI5Osm3QwOb4V2A8sosnCt+B0i qIJk52uBaypaBaulaF1eRv2za6A4fb+xeopi3DSPuvOClBb9Te+poglq6/rFpcjhiVzMhEZ3dpU1 GW86m8n/z143Y0BfnLNqvq+2oZARLJjIGB/IhPIohXH/AZmG4p80Dl4uUUhi7UR9JPFQxDYqAGO2 eGX5CJi10HKIIAD5lYYt5u7oAxB+/AcdnchPwJk+3W+HXMTqcrIJKPEjO1UrQ6bgQr59w/Z58vFg 67orMnCDL//ja/+0foaELA/O4N1p3vJkyKFDJ9gRzrQ44Ch0Abk4IbSzep+G5+8snxlcCnnoK/6+ qwxiLBkMFB1U+OCmX3ScPNEjXLkLpZOLXuMzu1qzEcJgcIS1SN8ymRS5MDh19iC77hrMDrz2FhAf aHwkQmWV5uc0oivgzqEiWaTZiTED+ttxbIUikHqMxo7VQLMKdJaMCmaYaG+7bqiznM/MExmLgLAe /51ORXQVWXYbcFtDswURnrX8DDvA7b7EEXZRJ5Ypy8l6kAVhvCdBHz9uEqoUmuCQshvefOHpolZV AIGm1STBXLlhoQUX4rgZdj8fyZYlumkCAv2YyedOCV5GDzv3vpRKXMlxNN4h0e3N9WmsdrfKYiXb ZpHOsXU76AXdOxaCJ8QPDqgkcWrChiCb7Lb3dQo4I7RahUQ/fR+xNAlXwO17/oiHsj+CVtO1HnYb QweCrJvrt8Qs+Ng3/SJSDZrIwGJU/G1vNsLeJW6o5owmHa/FgSvm1/JOpIDMzkXSKetdpMOUh7yA rVLXl1rHofn7hpYpeBHCQUCmqR/XR9mAbfKi97e91spPyNqQ/1q5eIq7sE28TKg4yDGgcZfUalln utBL5NnOnqBOTCNJRuY1nGq1jZLgXrIWVZ4WEK7NYySy2H8po8VKLENYnnx0RU9Z+w1EbG491DyO fp8CYEAQ3Kb362vpCKCczniT0vH3oocUDOf8aXc0/6yFZOjLPPU5zW83GWf9D79VUozzLgWr6nd2 Bw5RBjQ5740cn/9dL4Mkn6c5wwIM8zLyV2ormbU3f5Cb5y2hKYr1LqQetMNl2c8eSLN0EWzRvWmz hOBCnTxXMHjCKqwiMj0q2rF2O3QJUbW3Rrd+CHYaKLmcEVM+ESbrIDjXHKcFDWDN2W/Ln1vAx+5F mcjRFegSzxsdQ4vUhV6dimtKcosw1NkwiKoGp7sTWG+V+UsFEgKJpw1g1ZQAXuDcDPocjhq7mpCU 2se4GgwOz3hcCcwNjKyCv3w/baPhHRn5Z9WRRU9ie1NR1XaR9EWLtVe79UpxgKw4h5iSVEJqzqWY 3TCp8LLUv48l5q571Aa0aDrIQQqCsPvb0GZ4o4H0q4B+wNAkV59pFTb8Chh8wGxv4fVw8Qu8YzYt DBLrnP3URhbZp9ySYTdac8KEjnX9fE3wzRtBjtaoPuJ3OvZuS4qj7aw9sVyTuqu1vencbZ0ea3yb l/KRG9vPDV7+gmmzR9kwhBkXNOp5T7lWGw/Z3h1OWj1AfFUN1zyYZTIq3HLPgSHcyNDc3IPnIOx0 SVs9+5VLH2lRWtaRWI9oLSg3wihPTjyldyD8EOKfoc7sJH0b5qVoowJJNpCEnRLkpi+XE4Gz1kPl BQsDtRKEWfK0Owr/vXBtz31ItgAm3fu6EJzOihVIATIQYEtKjMZW4SLdl3AAY1xaHVeexcjU+t3v hNN2bvN3qwM+vTmkmT8T9LJDAn6IJt8i3nC3NzqkwgqCxSKSCC6jBvV91WsFhnB3JphSGqU27w/o oPViRyYg3QmBoIdPRHkz24QHlxLKt9gREfuzOXMKCHTb+0qF2Dwn2XFTE5ES/2bm58jLFbG0xRNN zCZMGbZszygtyqfK98C8/yKtkbaaLHMuPqNAr1bDslU8s7lDDsBfuA2Gp3qsGPBeQ321LRkPgsGe cIJKAyXAMfU3tLCpFJd9q3NIDrEoVDFmtKh5Z/si0kXq8HbEymWQoyiA/VGMjX1s4b1rNU2q/Kcp S/ywB1W1DfG2NzFG3/zBReqTF/BXHzGPWxYtC7V1w5ORrHeTAkzqNC7O8RX2OO/1Retl+02/utrd NXuNqOrrj15XTsVHRI/JuZSdk5PHRDs6lbJyF6kEMAlD4A2Tf0peL6VEjAqs9HWbpzbQ5+8W4Xl+ y//ILeg8Kryve4OdL8jJSlDp1WGMC+AIP8224De2eXz2wA684catOOt+5CuRIUXfbHSVcng0yehH KHcrPruVgAhDAJx8dA9CRTUqcl4E0b1gO3a8/5PXkhVBd1iIVTfRw3ECnr+LBnpRJPTU/SMgU77q 94jTspHUOY9k/Q601zilvhs7MruOgtFOScHCKNHehLkIn89xLo619EyJDGX8qkgxXSdITylQG1ed ow9nGKiQA/tO15tDSTtU6jmkMRGE5ab1J5hyk35mqyOIYwVTO9QJ27h6AvZn2aae+iKTAj1wx/GE aszznRAeax+O8tk4wDB0sUZd5HVb15bXeYN/O48xHAQl6TOopv88qvZVk/GB8Slx+KPrKwFhtlhi hXhpWyColUM9/yVi8He0lXMyAkghnsEMQVxHWykLEI0ZrfG5shNO7gbvYlIPjtHt5o68sq40QbhA iY/Xdaj6eJVrOLjEp1mk34VYHkC3accCZYCaRkJJySHeJdYr8tE8WnrWTBCSRPKacKYvz4wyE95c wo9Ifj+JvafI3j2cqsq5AhEQ5NR3spaAK1gaW+9IcPh/nobHE9WHMuOjFzY9kIUv06pArtJSuuT3 xIvGzdblJD8/g3VL+nSzkas+QDokvafyJ3+QYqucjIeRv99Yd+B5R8Hx5/cvKSRf4HIa6tTaNW2Q 9eYVs4Sm4ADbji1ZSK9YNPLRymbNwvIthIHX+k+iz/iNurPiA/m7VG81dHN8B4mf/ZzGNG2K4wTa CRs9NOLZSQ/nnQI5RBE6+rVrIULk+jLKexTPcTze4yq5hrZNHv1TfFRMhdGZh9SYnG+hENzpcfY7 nhkEM8r0kcpHUXpGu8xHXgSDOm6/uMVK3CD7q1U27Y4USGV84S9Sj/v8Kor7IMTWHTG8AYujHEiw 9gSX+zIcqewgkYwMv/FQvSxZFIPgjs39yTzfSOsGbRfo/Z/7wR+vReGM8GXNogqCKnTjGnw81DLH 9Vu9gONdJ36UKAvv+X6Xw7TmU11+Bc8Z0kz5cLcsZfitHadBc34HB2sFaePRozhtQq/HIjPnD6yr fPWqjBK8q+mVIEKr4fZ0c7X4IRuI0vAp2DeLmJO6qZANUhOkS6oH5t0zNdARGRpRNTjH5s1d3FnY ++SwqcTQozqu3nkm4UBKP7Qd+sKseLyldpBQsMrwmz9VqsJi8iJBQbIYmkCzUjsD6yX2OuvTPXiv 6MzPcz1lIkNzNBY6OLVa6483Q/5h1IgCjd61aRkUNYr2u01UznV7+ci7oZ/GI5pchbpmD+Q/l91C stS1kP5aP0Jd61cIcVwQpicWi2NHTZRyXLcGOYP4XxbcCNo1sEAXUAJakzKUJKBp1WTeT/b7O+Li o4OgoxWAHVjwqeHWPqt1oWACwazCwTs9iXoB1gt94wPvMIZFOgO11+ukWlc5DT8WVN/mRt4UhMRw tVsOi2rst7I/TsuiTQXnrOh7nIY8lL0EgmD7ipJ3010FFAV7P73Z5XIfxveB5yBnq7sc+2FAB+XJ zBDrLIH8toJKFcuEU+U3QojGYNy/V2ovxlTZbmvgSd5MMJUiSrhQC+OXLUEuHO6n6mbAa7SAhGUC qWZc5+XSEJvcHRIHeWI8XUDOTVAjR3vOHgTnYu8ZFz5HaL4cjGsMzMWO+iSNxuBVX+PgwymG8ZoN Ms4fwMi4rcKK1p92A9Z7kmsoaDuK7s7q4QftR/obj0igOOIC/5iQrRVKLHam0RZtFsxO2h1Psw9l xOVW/y/FDevtfUxmc+r8AHlVlGp2m8JR/o7x/QtAxqaSaXRvx+FUVaYCSPuhqevCarx8moqIjqgr uuiLEz/Iu4yP3mHrE904ZD2O5kB7arRDvOhoEZDtI5S7duimByd9rlVgptBEy/r19a3rkiczuRqD AZgK/pu62ijGT+0HNGLAZj/imlkwYXbXryqnCye+0OSS4HIeQVR/lF2tuXYegw2uJYh7dxYZj0gg gp5EJOT7jgYCIw8aGT4ocjinNzWmJ3FItwFvcJZHbMbLy8MXuHa7NzCq9DEy49nc8gjqs758hS0f vkHUNhriYYs+raadRNUtTfqmJ2GB4JW6iyrbbB+lBVBB+n2TqdT08fYEiDv3wCDhG4byJ97FhGGE /a2s1g8W8aC9meuaKCyNxzibSlAzJwI//9AuW0cNbPmvEb4BmtvnMRyi+M7c5K0uVnbQv7NWisKK 6AyDShm71PYsInjFxiSO32P0sk8EBRgIPN4GijsKQBFUG+bKT82zygISXumtaw88uT0dGvStdqDe PFhMV9g0aCBdM92PmGrfzWD2grjuDNqdZsOJ4qOQMhRdX9ctMhLGBSvzI4Q2PM5z6WkDuG0coBYz X6tWkdd4i6d4ii9Lznzjn3COw4gCqZXaQVZMDRAL0TRDQtdOXQiIpoCsqMh8owlslcN3znjcUq3V wSf9UK0V+A6g5e6qTPZ6uCVTXl/FNN4cWEWGcLdumVeCyhbwae2T5oShlP0WzkvWIPIp5r4u7g5m bCwtmwZ/ZtOr540VCPdssknDw8FYiAni1kZcfrAfR5RLpGpmyfFzoyV7qrKXoavUk/vKnVzEoliB az70it7J/dp2jMyFxXN3xli8zaooSbR23MMWThKVNFo6v3TnEsRi0eToxi7HC56pYDblWVFBiEqG clvff76wkicdcNSZOvdubJFDE2ZVcijHhhvUX4ygLJR50cb355lb21YjKsACNR0+P2mAhAhaxR3T LJtj7ejievM0HNzqWsb+mAKltx7RF4fhis3aazb2n3zdkYYI2HlChEKiAPU4R8y6cFCR69TiPSPA KEDm1lz1k0zfpVrwEO2bnSn0ZeDIpDvWpnEQLpHYFJ1wFjJDxUlg5o1kMpRVxV2vl1EsTguHxtMm xdXqm0bVxmyt8D7QM7oZOE+43vEacDA2wDHh9fO0BWDp73xsNbnI36N/tbeqAppohpZuR3AFfatb qfhugNv7+D/jabcvS0OINP1NaqLgPtkfFm6FRM+y6DA2zXVSQ7jm/4P6yPEA6OYqYnSCiLqz4mof KHMSaXfkX202kWTalMeutbchqA2aHap1IlLNtOvJ4xxdaw57jxueBCNx5w8gtJ01x3Vv4oSiVt6x yMrxKsHK6GjSj1+K4AxG/u4KW1ozOsv1GO21lZxc4GBwMhHsQRHxwlqqC04BJTOKgDvmriqo9UV0 YgTS2hAGdNWMo/wujw2H5npFQ/UgrFOG/wysJCKX6bFqP6dmnn11FfgLvKHwYPoPAP+ssf02VPkZ A1uPtEAHv29aMUMnEclESsZ9h0DVn8J99qvxPM8KE6GqbmXRbrx9cte24Sn/OyXvKZ520x6Rjze3 tpiX8jxPegsGmdqqtIUWGfPz2lVtoigmYQxVfL7K7Tg8UlbquPhm+a7I6D77gEukZi4GgaOK8W5+ czm8uRVtLP/gfBdek9Rn2uqcWpBN1HBv7enbMJpyx/xqBAVdGu+xHFIdR1/ugNi5KC4SKCpTsjId bAB+m2C3zu29LvARSAAjJoN3cI1Ulx1uf2vVizV+RJutuswVLirOG7pcfIcEXR0+2ihBGaIX5yE/ L5CbQWGm2n8nqgfYgsELPIl65b932e9KdnHN1/zM72f/QhhYyLZ+BAVBnEZ2pZkW2CCAk2tIt8qg vV/O1vEfzfJiuw7L4W8YID/X6IGNvyj+YPotE8PcvsQWj/C2nKSK2fmKp7rJsDD7AZSWpV+BoIKJ oexTHEZX6qbrdOI1zIbi5F3zM6v+tQGrP5vKttBi+rvOt8CsML5AaS6ZP5w2Q/oG9P4XzG1ff4ef UdhkzEolovJAIkHqSKkNygai8ZvGxx2/h3+Dy+9NBYKjBHYgRa8azb825VstmPu8uaOkotSuVuZg 289DzAd2MzjbNeIGU7g8OgByPS8YBL24HIbZIYN0tNGZgWUSkZM6sW1U1kAu1QnQ+b5VrunrYbSS Byb3y0bscy//W/cslMBMa+771+0k/I5ospnLpAjpJfDObqVHsaHnqThKiKBG6DzJiY4Jexe7kl5z pT6zY+TgSq+ZKnr5FWT9OBxWyvGlWWQbtCCzryz00DnIglVq35e2VZzwn2HTbW2GCq42ECwGuAo8 oPgc3+n8sHE6Cxg2p2Na7+XbkqFxe40ukZlZtAmWTpXSJcTHqxpagNNWJqYCK6aW3zfJ0Kj6kOTY hFglTbiEgAZisjsaxyPblRSvEUgNwMRH2gvJ5kQpzGMV1wiBxxE0WEpIrkEojDJTtmiqcHVLDb2w S+ayIL+lx04UBrV5XAtgK4XEo8XCWY9SZMAuaQTHMJUCWwedc7oocKQVeon5JHX6kDyfTX+mYXbt J+iJ8WIuZfTWvxrlfJjKIxecRU4yuQWgL21Gbvpd0i1RBj3RYv3VA3RK2TeDzBPg60G3Ke/VSKBV VXArK3FKUOeHtkMjcc6h8DsKIG7XqY4KD9Dw39l9E5ZlAK45chRDEizSTMFIKRDkBqkktlLlPYSp ULiNc13FiUyJaE3wCZKNuLOIUv4HZfzAn5YEDclVh3vXQxgdWny2awS8RxRMlIJ37s8a8xX1OPXz z8mTWeY9y4kCALZVLFBhrSVwYlPFEeQoegoI4nIZHukmAG6ie9ZwE8+S8inJnbvuozHCfHwb61A2 3uXE2N93Ro6ViPv2WSS1pCzCEjwfmUwZ/I2xGQahzgIQ7xAI+tQuzMivqF56ASy9Ydr4MOO7db+0 qoR/lVNTRN5cFgw72MR0hnGpCklM+CmrIdezXOOg2ox9u4Zqv5wuMnAhInpzDXJ9SjMaEe3fum5S Z/RFAspgCmfv0YSclKXOo9U/9/nj5N9VO6e6XMLlTxpUexnsxNc4tS7cREv2Tm8/O/CrHXreY8wI mvKP+hkkRVrUQvQE+IrCJLZZFeyOgpSXotYVehoH6i5jJ08l1rwIhk+fyzirRlQBPr+IP1JKpcTU 3WPSBg5nApd+lSqYODJo7inXeFxtooa5pQk+ojvBNDDOQrNTB98GtHa+u/5KZ31+Ar8l9vK8I54g w2FDRazjr/7Kn5KqvKPl7QrD6tb8cCTQlutFDkVHTWVX5YAA5v4wgcsV6Gm1Pzk0i/StFqrXUOvq AVdisQlc+WQJNd2WmH0dbnIxuvCoM3m0Y9uX3dFLzih59fY2Hs5F9xkYQ8LpOLMN4/WbWorgTTV9 nKggJE1RshVjLhQfK7aX8byWbbLpu/arR8hMJdzRWq23km70ZBR7X+09CsFY2u3CDp+71eHZhVRM 9dxhd5vSKSbJ/YewBz5RJIgMPNPYaUJA0cp809wp+G8Ud0CCSX1V09EMS+dCtKeRq1l+SbJA6fpb 0cPxcjSsjQSWAy8El1UqB7SAdQfo7sTpxNVUGiZKsNIwdQi6NqEI3WBO3k0Xkpi2RvLqX+iP9OLN QT4zfY0fXaW0XD7urkAqD+ulliAqj6kZNVRAeyZIvB+LrP1rqz/7KuFJXZ9ICmT01KfBk0xbDwLa Nf7IRL0HlOE4vYKYXB+F9q6ZO3D5SCDcPGZ4XuC8h2Vd2fK1vuFNUz56BdfVqZbi5l7nGqdZG/bv lMfC9lWAURlCEcLQG2uPPhuGQoxWS1jtI8mNtPx2bcx0qWIVSsJPHIgsQcd1K0McXYic0FG6d5O5 i4/pLTesZwVxaW9jxR0avheQUMezulQ89sXT3SQ91CweMP3Y0ByyElQ+x9k6n71hKM3vX71wgASQ q0WpBZrnkg9O60tZfGmF4PHH7Rc+4yocVoXPUFfoDVTmbuYhXHHj6/s/dWjSMlit2Xpws+7cPxXw iw2091WGAMtN3bdOjnneDHY4nueTy3hxrKxctgzRUNj6ILuB5l78YBiBNxLLyMgbNLJH0redM2oa qtfr/dLdQjSCZkKjq4EDEay1INVpY2QSnny4wdtHFdqX+/3yKshSC75dE5OlNno3ctgmdVi0Gck/ hXU5jTahJRFMOzKZmHXhObBMYYiNnD2Ndy3VY74GjAaRG5A3q4PI3JyS/dDJN2YitoCVGiLeSkLE eL72V7z6q65hyE5Wr0LCAxKpNySxZCK+VzKog8UbdPCVVblYIfpCxTYKGiVYK1YljnufUbBwMaWL Vr8uiPdeouHMAye9craBfBb3N8d2iySjLehp43ONjrA6mZXoavyyunVo6jLDD/kHLoYM/E0dfGX/ 5M6Y+iboDi4eu41TQhSFNAAqnYDQDLzSiecoHztt3hV1GMYSA1uBgP/JKcxroowpYEcOki3uspmQ khH6mJutDm5ejZpMHn71m5IhHOOTOLYB1/D5xiXVVafpAEBu1paPjfkWXO8/WfVjChBQGEa/lquk FnIAEkkbcgN+GkE99ZNc88KocVpcuNaBbnUXLS4VX/nbJGXdUPwSsugDzl6up9nfa7eGqldWMIgj L0RDfHp3hCOjWjZ6Kd/3may3MCevV1QIfF+AyWfGIZcSiIDQKenvVeYeIELyN8RDcDgwLwnouzY0 BVZF7Iz65FtCQNUUCqNbpMIaq4k6fKxb4lq97FSdjjcSCT7raP2HluvUMjUoaD9/yC9u0XM0jWsm nMh6bsdknFXUE610ip5enIDnySaCv2AzAmxrG+F5heqzB5Z0zNdGBKBp13Ay/YYQGdsoFvxa7Jig IJ/6FfSLlZ3HLw/0Z8pvANNEDrkcr6qWTJoZsNPcCf1Pjd/sNp6Ocdk/yB0Ey7bQYzjhPM2UCUyq MqtGwb9yjn0Co4NhXHLY1W5wSG4Sv3lLGFm5dw6pPteQQLxN5XsI0wzVGH3LAUHncefvAyPPvvFO 1ivkjJ7hzs8aWVrPN1pnHv4HWSX0ubSr7GZgP9EZp0xoLuvgX+DpMDvg1bYW745lyPXtXBLvaUPb 11m9Qu2/RddVxIpgLLrZ4Aw1ZiVMMJL1GSGVrwLToVoTkP7RFRTPo8kCeGI7bRow5w02hWnsbpK/ dPjN5ywEQr6ABqDQB3wlCtsUgtD/sR6z318clK1Ea2txPycwXR1XEDuGoJY6w9ATBspFrj0qu/yl uZCQLxMgiRn6/eMPB+KkkQ7BI1nFOeVCpDb74QcgRlPKBBNYxws4jcW/ANM1GDYvqg0ne5cuMAp7 ATLyinJDF7b+tgXv9NB+ZEt0Fcx4AoFiqq6gBhKLrk0/5bYRkhCViZwKc1yjmBCvcBdSTVUgAR7f zhjCzfQh2nxubOHB9pP/CRF5jlUPttBW6CmLVjrCo72gLwZu4Ku9z99xsfVYYsE6fcZhsvyXSqOZ Xu3MYaxxxjsgvWKpYEIn2JM8wniyWbXMwQdXoa2zZBNKvvV5BtkYekC4DoAVgrCLIjqNciSE3tfd 6mhrCu0t0vRLgpsRAYi3P3nGrqXI4C00Cg0bykxpZy8DMy/OFzvCMLC6saRa4/CF2hZVGWEKXkMx FXiAispHL2hN0Ps8URD+Dbqg3wrDzewMvTXREUCx4ncLVnjBws+LS1zwTMrDyA/Dm5SAsbKE0Kvy wQFzZqvLQNbuXWBm8Ar9SaWvNV3+hD4qmbjUyUwXL7DCCBInMEslUypypOTGVO1WW7hoyWFc1GdT wmQFwzNdbXYGlG1iECSsHLGBCoh7T6VAoQh/ogt1h6om+AqDIjCmbXGqzpi9A9CUTtSrVq7I1Vm0 HLMwP8Clna98/P7yW9dKgt46p8ABBkLyYCffgHQWTGoVpteY2OAOvTh6fvVbhKVcarKdpOkhe7cp vxp3ODNy/bTiDFze7Dg/HK7qSHXyipqB4/shXqQikgIW35vJLbrIHLsTmz9jxlaPNYe/iSUoDxGt H3Pm7jdIaJJ2MsTwr9aWJQ6yjw/3gcB8Sux7xqp7YSZS8PqVg3ArWyBQs78xiMqNEcGluguNALVE qSPGpqNB+g3f7pD/Qk5FjcobXVxU/yNXW4YmeFZZzG3sCnNTrtNO1TTjtzlafB94hLV1u2h37G6j XkmwgWONRb2H4VGl+j2S62AtZwrkRJGDoWg4M1LX40zqxCtkHmprfmt7l6UCGBstbD1YoIFLqb6f WhH4xBWCF5vvMaR93jp0xf+JM4UlgBrdyc0M6jAibdCdPPbmK1V7HuJ7D/1fp4/r642FgN+B2fiJ C177bAtqIR8HLrwxkJfGE/veqFXeqEJnpw6sswh1Orp6hcIMYuSwZ/u2wDJMP9Vh6fW98UqNgRRb CnTLju5sT86QmcPWAaM+Z+j7M6X5B57/b1InoGHb8clOZOnJgVlKskTXz1Y5teSd4wSdRbOiwGjB A7IR7xdQndcXfyihXaxcgubMOV+OA1FA8S/u+BznPvDDrhyRg44jNBCC1lyc7LHk9w4dKeBywF80 YmMNyOGKIYmNS725PIzI0zm8ZO003u0mNZqYbAsnAt3XVTEMGH1ENWCAV/KSswqD5MXU5/aE64ve xdp1HJLtBOXQ4RiuCmlELhM7m4Qf0/kWxeX23Vo96czdLRUP3TSzhYgTpz8K5VoIdgpWcJ24u0Oa gkrecfEmu6ZGOdbZ40uEYJb9K58+jSWRvl7CLukOsNhDiKMqDsZzxeT/+ZZC4763QY+XCZwPe0M4 UNaTdkNvd8DKpQoEvY7CXkMOm8a6Fntsypbx4SjsP6pegLw/EPij3+P5+vpMtOIPTk5wBvKIMwsD RZNKgcsOdhmx728aMmYV5U8ekoYBgy2a3OWNuyfAbHbosNV2gH7EDszA2vDw+xnNLagMG1Pdgj6m tW3v/d6qTc5VfzEXhaNKdXbCzmKIGTA8xMFw6FPUYNgfhGAZwgoArsyIx3M4KEVfoC3kph4RZQ9Q bn/5ML1j2LHLxoZ105MK2O7PrjdxK3HX74xeH0D33ltE/cRL26z5EHNC2MP4/6MmRyKOOK6mScqg gO2+ZaKV8ndyLXwwH3WX8KfWWfQx02ksqFjhBWzk9T27E6XHVz+f9Tyv3BkZuTDrFPRsbRHBDt9I /psGnFRgxeU33yjAe+4iQ1l86crB33bZtjPAsx7GOo6EwtjKbZ/0SnhlZe+MHkMVv835A/9fUBNi jsE7TMVYfdJcvnGEJImwy0oizt7ZDdvLl6SpW44c586jhxqXyuQHfm4rSCH2VXqznkajbylQjNuR O91bHwzI6a1ARllYxV+ImQ2VTDrQc2ZxNAUC8PyykyHaoM/2n6HEYuEXNLmT+VHEIx/WwV7lUZhD FbTRluBloLyLV0XGX63StcTx5WfoNNVhWZEuyox1RpQ53EN4dU5wzJj4mnOj7G1EMvYR0Y5wfdCD E7KfMLqAVXe2g+Y8svxAtpHNxNVi4MmSK4rROpmsdEUzyBY4wK9Y5NBU3qqC0oEn0FbwNiGCwqiR H1uIJoCBuGC/N2ITI4d1zMwQCwDiiILf1YbgRe0ueUU8iupNhwQoGNrcviXGoXkFYhlg745gXa1w FNm4Sl51NZOn8r3BS6jHrP4vNwwly1KWdvuBap2dQxvah8otyUnHJRZ9wU/d//MnqzMoVfCcUA+y X7IauOdHGl35cVKYThKRyNqTMefRBb8Z2UdhzEQxYT5I8qKwP3E4hvM4Fajc0D/V3uMr0UzDYlRr 4QbCsJ1N1i+YdIUtI/rV0f9tGZ5gkKVtv+RNENr2D1srT75KogqzlPfvSocTOufeL9sDZljYpBVv JxwaAebl8IU9nRTqTDKgunPWaX2r5ffGl+vo3TRMWwglSmkFtxItL9Txwl9AFAK4ZRfQi1/3vV/0 qficv+5DUjQj+2NMtffzMyuZmVuSrBAuAFRqcOTnyHkxQcaStIGJPJ0ntlPg2xA0kLBiUiXRNEg8 tZ8gfze33vbdHoOYxpW9bOfFgjTTvNMFNzbcz2+4eN3rsasP+zDaXYRlf7hNJS+GwbLwXdiT01Ko MvCPzB80Yw+LLDakM7s1MoudZeG9ueyNxtNOKH4ZKf/7rJXlZJl/dPTVSyuYejEIsw7OBEZREaiQ 5Y2VHIKKZ9I57cRYS8FBkl0xZHHwJPVvgAiJEY0poXoeSLfhIU/uhjmXMIC3BIie6DXyQTw2LiG3 Srhvp6c3LKqzoBprQYz7r3DwNyvX8y42Xfh1dt2KaZ7UHGWAOtp3LDVH8DD7vec90dBtraOD5ord NknDKjHAFTDFUZcCDtLJ2JCQa2IvAp4iaxy+wgwwKdoeKURosi6EVVHIpXOeamIghwZ0NnivJe2V 1xVv457f2mpYOntkEfksg+apyiWGXZJoLyET9i1ru44NhDwEu2ATMUvv7NrrpGPzW4mvMkKhWUbD F0AqRD0aNfZIxehy24tQaAr07fIT8+YHhot5qSZT18i/xqPU10YNpPkHiYNUckrdlv8Dro1KcAh4 G4/zbG8hIFxEfm021I5ICEFF0VrJadC/LJw2Dxqpb4M3dYBE9pzm7KGIYdPNbediUqZypFJMe3PY kACVnwhGVmY3VXjrHDlMnghL5QunZGXmkooGnyWswwtMcI+GfKsdO15/q9Gmrx67TDj8/k9xHb8i gS81bcZjDzrwZCJo2ImeRFkWMbJU17a8fX1zjh5MiQJ6WP1EZMNuuT1LMmdWS+SwYePLrW3Khvfv WZ5RYm2hnSn9esOmUKPtMmSAlHbHxSlrkzQKbPEdxynbjgGJ04+8hjuMCbuIHQ0EpyHmZAb12aYo ys182BxbkP5QMuQKU3/jkfFGNhKQi0kaLFaFjSy24rk+7DSjd1j+5sHQHtxOIHyMcAPwHJ1HA3Ly Zpj52HUTaAhaPk8eMFbDxqNfy/IzB0+AH9kNqWIzDJT4kzFEWUgjJ+0aKn9+sS/bb5qDWqk/ag4a xh5wbBo6gARhmutrBS9MzShK2FDsmhK/SD5znONderTEHYBedCHnQ6vCqolTAezB3xNVDhCQuMkh 1et/VaZhcl6zuf1upiF2rPzFXbkUX4JMsagAIVBV6W9NCss8JugbEoqQ6i6NIufWEvt0Q5TMQQ2k 8Oh4mf9xQdmwLJ+yo7KD9jNRBXPBzkL8ZdgGVPfdRUpeipM6TVLdRxovu80wi/LSqufuxTVzOiuV SWxqY3nFcNKQ83adruNfUyL3WD1By1nbC0Le/sCvP9uMistizbZTArVut6fzk3XYmtrDJb+oNn/g PAbAM7duwCVicAZhhbBbIPz3xCtFx/Pho0/cFIe/7pyKRxDksymu76mM88vQ5TzjvodVSFGvic8N VjSE6+7mNEO18sxAVXBpEu/n6O1AEO3tOrueThRawaggORt/1z3ze9oHahhPXG1Ua/p3LNFMjIr6 uZ+EagZLxOTqGxIVVTLHCrCptFElovxKp2OJnodoMM8LWuWGGUqiJAkp4e9OD0lEEKYWarjHQ8rJ bi7BjdJBdZdgIhds2kaUCEaxv05xyPcVKjUQ2vmuXv7foRcW/bwkGFjEpBpaqZIoFJcNSj88gyLF qo1UMk4pNMgUa//ttmlVJjkx1TMxZRfHYlj2Tx6SxVvCzFu0Xif22owuzQoTHkBhYhHeAcR/GRvC hnnywzgVcZHg82Nvn5Hna30xbKuQXF+7u/g3n5tlWeXoy7ThEM3y8mxcqqjOMTPupSdLvNoxX+7h FaHNf60uZMPCAc7VwZG5bLLC/Ng8dhyXh90bF5IOH0bqsrrN5CNyCO8CpoZvDsUItLIticwjOQSo LVsDwKY6NfEdq0E+9FXVVujvNcMNhPmwaAKeN6SudYRw2xwtQg6/89aQ6STN2a4WL2tOxA2GtmrU pq9ghahyq7Olj516adG5YzRFbV6bOifNWbkXp3MztFxUN5xwAzzLz4D1RaYwCRyqXwQbkekDGi47 qH9uakt3oubxuqewtnpDGpKl5y53bk+FgMXhYbsmQJLVcU+90s+qHwch8nT88gBb1CoVfQveiUae EoOBWggYulVl7VkeTaWNqJ5C4AFlCgrEVRinOtWxVsVo2tEuDL9zMLgucw7PvAqLt9R8xoO7XrGB ZQYYNsXe/232+ctRGkDBGuifpdvPGzp1SPLolhoGBDGnsoTyS70yO76vjck7zH4V74gUOV6gUElY W7/wTFfF+JM853ydhLcFrrvweSTEcCtXOya4fLG45qicf4Bu800Q+I15JElfnfg1zqX6t3oDdv0f Tjf4E30fssRWbQMel4HmOSipB2J0zCbNnly0SVVu+SNErRQN/qxSu9RjzWhPyYx1oKr5lNDbe0aF TXpIdeG0mC0jQ1H9BJPgHVt8N/qghvjlxV2tzxHh9vQbXcVTb4D7KuP9mKaEXaa05TeRWNmUfGdN ippce5yfkbaan4x0sASz1/3f6q1XCmr+jAb6SuDWo/PPQRfxhc0UXixWV+9J0RU1+pyaHEUYdTha f6tJlja+EXouS4lYr+updObHsZL/bgz8P9EFltj6yzYJQ/yVwmNAPhjXu9+FRTOJMSNkppoFkKUe +Y3ErHzXjjobsZ7hZ0X3xNsuweRQvw+X8rsyXigO32B2p71CJnPrGbxlADid6oOcF3YiAkZMFwd4 ggiiOIeSpdWyN3p0TkrvbLo6DTPbSnsc/W7mXjgro45jtPWKmZyGY/5FX6cshKkFGxuXWVUPyvuz 7WAk3NVEKktenBXwcH9pOMvxsThLI+yrbhbHeGzX5B8F7CfVzGTIgNQi8HgdwXSipg0kbEXF6KQj 1Wu4Nlqchs17h4FItydvtwHMfdNyjRShr5rxbw/hA+srnCq3QaQgskwKyEwsXzNeHPQ5MhKxPeZt 8vTpvjrVMcWF7jrpG7zgwnv3ADXWsUK06sK04Be5adCEEYtAjT3cf77uSsDlfWLuq/IbatwLQeMA QpDdKr3ORY1UpPhYRPHX5FOGLVRqEZthfzJGTLKbe0UzwVky8t/K+OaexH9EIJTCAimdFAeGvbls eKtz5FrtwYNQ7mRCV2kgnMnyfQ5hUpaIn2yuubmV1Xofw5YHOJjKmS/wG3+aWzqKcn93oHsJPTTH LE3tb+Jd6ZHNEiev6h2JPaUJwNL73fNbdW701yfGD37mm5XkwknflIZu7qXM65ud939xcZq7UQ8S QpqiIiFxEi792bASDPB/gT1ZKV2cGMHUjq/d775sc3xV8RvNHVdE4WHdRoiOIzJL9O3J5829mCPv Bt/4Jvnnax+HLdsC/uDr+UoNgjy5ZnaUrWwkBF30vx0x9cp2Pp3uzkggpG8Ml+frCmqRttf6yTUQ 6jkd6rIDHhW93ZN/288va8jGmRBubNsEsUeHCPGf1PqCELNezmKYKEggLmd+C8wjcfNOElD8hRrd WWYHU9Fj7Pg261mN/bFGe7SSV72oP8Ske/WgUiZa1O2ZFxuMfWI5C+6m7JkdjLV+o0cycP1Rs7Z6 t+E9mYbhFfdrL/t5aLQ2IM+furVB8NGdwlu8OpB2WXGKq5vtFd9McakcRPRVVQiaBWPTcQ3nuHW8 NuWYCP/E7nMynZJo0e+gl06UC89NlmjTO0uCT+dXdqq4q1AR5ek3YhhN1/usQXL2a3/yiSN3IsiK FjARtUnqWxa3E3X5eOi7GPZiRvPRqGCyCBsOhuh+MUb8liAqtEl97DVw1yWR9r+2ag3yR1sd9/jx d/6EQwikGWItl3jx2CsdnMX84vEvtGjLrnOpMZiVgTbTu23ICV6NCSx65YyptriDBawxi/JHkqt9 kfbyJ13feYoI+MnJNRACtvPjhHEWBB4yvFhVafRBoyZIZFT4KsK+9o9DBHic2qYwXQp9bec1oOWN bttdZkojXRiwkFu1EExo1PLspWmIeoP684OsZUGLvn4TtohA96o21caUbuav0oxklYrvJvfv0zO5 qHDDiU+IqOYvpOyxzfNaeVafJOx63Qhb7mIA8vkDW39NaeDkNll/SF2CG74nL0qIW1/kkt90mlMy veywwuNycNrV/JScmeJwqwUVR2WoustVZg7sONb/S/zzVV898O0dxI9a3EmZjPJd3+nNCcDLvzyE A7j+BaFoz48M2O9ZEC98Rxdw7/qZ/o5WNLlYwxiybNjB1epFmMVKPjX6OOb7ilZyszad1LoMfTfI Si+fnwHPEK0j0Taiiocozpg7dOPO3lqAgI0pAkM5vVpwkZd252XKRUiFYVZfo06XfL5pVeQ/BWXJ Cu54X433Oa5DKBjIUfdN8RImOWGDGkN4ZneYaGozZKfH7pxW/uW+MAcH1xo6b6x1S4NFb4byoREq m9CIsRmbOGZdxSwFqjhPwGbFN5+jgU//R5j1d4gnNHDOIt5oU2PfvGgZiExGv1Y9cnjMrCiah6oC O7l4whv3Q5NiN4/Q45ufvb15TI6DJPMKF7xxjxx3rimi44j4PUjhPsGoQ+2gYrO/hGKsrQyGUgrJ Z+nKfuEOksp71P8Lrsvd+0bjpP6Wav1FqkRccFJA6TyICoDzzboRwZcxxn9OdOgwJvi1KVIH1mTu xa88qCopC4A/sZ1UwN/EGk7RnbkKHcMFe1CGP4fUm2SZCfY/9/XtTCdC0A+QJHMweU0DZy+M2M7H qwAO5yUEBSK3fIktkOOCYlgcn601HPDu4k0felZsu9WUIRQahBDM1u720xnNUzbskKSZGAEEIFHV da6Izj+FLt0ff6dj/UCXfDUPUZexiPrVqX1TfQ5pxmxn/wnanXbxK88SumI+MSEedyHwITWDnmsE dOCYCy7bvTsOHSeGenQDPLTunSqAmPxNWQIKNujHtt2Kk1vRf74JQTV1DpbCNwVzxYDYqeXe86tk n794Hl+k8pOkzcI1UBr8ESDfotC3WXu7T/HvPbkn0YvH0vwbyAalDrcjjyiNbQNb2nnf9TBMdlLE BYTjbC8XkMBzY5Dpr+j2ByHemboNH+8o0lngKlqUM2ngDpzMk3mQqJ7GWxNSCLey++/CxmBnJ6sc dLhzFk8bQw1tL/OC2why7BqdgzvMiEozrG3EehmCMP4HsasY4HpkLDJbQ8YbkzoOf4eVGGxjHizh OqaaygxQmDMTs0XfagYt1W+28QY4T10HGERcXyRepnCpDIMDQ2VJ9ooxVjgg8eEywHirt4UJoRbi lTPFKuwPTt+Q83Pk3BxsuEMLzxv84Nw7Mn++W6vI0rjCKSBxL/YElfng8a6WC5O2/2Ll6sfqOllw anbK9zCoivuY7tJNgKtTVF+awDu3bABSFDp9s3DBKOuhxs/0KNn+nsauSvrxHwlWzoz7VobOBI/o oPYXtdZ5JVq2nRBSy58K8+b3XLH6DsKKZ7Jh2txQctgCKozcfz5RLq3I2wRvIu+VPB9oEmw2yvMC Wy5XraLgFx84YhkRqWp2+8gAw+ifJ9GBp0SucTxlMiOGjnltiL5WBlWdUXKfRQnruAcl2z9qSN/5 /AkIZIChFSLWKc438LkPwW2Dv+UzzKrPS8A/ecRwAxMmECL9ug7gDFeJQvpksIwkKWB0Of7HI11R m+lsVyGGCjmoSPmNH9275lyyA8P2BLQbgFX2to/WurQvFEK4ObM4QZqLwhEEEvAykA9CxIFtN7/E mmhkNaDahQX6g9Hrp18yQ4ar6V+axMknXzNfG+07vTW6ktzQs53SqRP7tWoAvKBal5Q2XqW2E3uw weSQxqMY9TjEhGHkaJsQ7lYmMxLVFgc3XVb4OaouHLqNeLe/wB/npRRm0SWwmPdNFIZJmW8AV/B5 bOq5Ec3l4D6mmZTLzZcdgSDnqXCsuyLn10MlRTCNg6Tcle02GrIEyxx9BRpD3erARmdqMgEkpmmy bYPtwJsaKVNLc4ICuRpXAL6JKC4dFFDxR8Wl30XRFdIl/qDjzUUNNaC5RPcg1kDwNOaSg87u1BE8 9CWfE5+eWeEs7QF6RIHknJKgtzMiH5cQshMtkKv+8Po0Cy4/Ca1fFkmM287dUCx4FTFRmC/stNUG xo1w1/HNjS/JlshUNHGsUIetuISzwCsqGduVLzw+2pm8al/1flkh+1Q3dVIiY0WJ67XqR06IADpo pIW9BjLtM2MJew3yYs1TvyqmnVLGLs04/RIaxO5DnTy2M45FobYWC2d/exjs/XPh7HerZjn09L8z g+Agzk+jnAEtRfMTD2Sxq5CipnXA1eFRCDPbu2+QGvYIMLWok5DPtbemEAvAa16dgF73KR7J0p6O KJMgONk2VuME+z6j84xVm86tYSWSmuzkePZUViJDNMVQCYilt6rgiurbRsjDG00GXRvGKP27wtvo DFUrDRsSsycSI1TeO/FZV+I34vP1xcX5HujKmZpoETAG7kEFQmK0qwxEcWTRSjyDuN3UmD0snGco zDtrx9WTCJbFpdPitpDBW8bftCkC+MDnDGZDvZ7SKxXIibH5elPsWeaW798ExmurrAVMmaFHpZgh KisXELcvqkvTHELNrifsPqWHtfy+VC/pjckQx2sUfEtqxrnpG2i0kCI/PxnUKouIMW9m3FZCyFpu e2mAZdRwEFb4YMlVeO8KsLki4unbSs00mAaaQ4YYRLHyQXAIhNpwVZH0tYPNqSqYXBNefuVZtlQf 1uroPG6G6HeuXXtKIswRzDVSO0QikxPuErUJThs00GHDRUQY2sdMgmDeXzrvdkYrHWBOgEgqRUvL aimlpqU/DKOSaNRHZc3KXDUequ5/93Wv51yktFkmcf/jtzz1IdHqQWhwJbfSwo8ht6gFzlA93/F9 m3x/HLvV9mEl+gozqGWBT19BkgdbiBpOFnXR9N6CpBgjct6Qks7apUMl0nlarqEq8VerhxOHJZeC BJLyIVbDz8i6GzSpc6xptd62nBNosokNogarbmJIv5lDvox+KGx0dT5xv7tlZ+nAnpo5bjd3q/ST 906IGEPQkaPGQFGlJkGrEqPWmhap4ypu2pcoWu8ljrA5YeatBEbsMqii7iGOGbhONDY8jEWf/jeE EBteVCpvinEqKngYHdMsS9yJL1SEMHP2JCY77T7xEQMMHtjXj3hzndhHQifYaTc3vCbRnYBm0dop 2pf9L9D43AC1gugszOYBarLCRe6MTLsWXPbsSU6d4SgFz3A3mw8j8A151YFJTKrXiPjzsdEs7uwy 90KeGHvrbYGkjP6LB870BVoZBwODPEGJOsyXcRx6SF0EOmcAj/ZR3SUHDYifHNr7QMDdgtVjCrpM Y/sO8XxpspSH0JZOE2ZaG0GkstJbUSkaKlAuZs/yNwHyov5XAMbo1oSBtGTx2pA62XQm6pKb+03d LB11I435s2uif3FWcMMI01EIZggJ252n+pGsDMRS5r5zZnNJ6SeljRyjt4m8XF7Z92eUeQSNyp9m EeBFYPuptVbfO3U3sZxonKWR+e94TqkLVtBdMVyVh0HRhFvxZtx4rQwluVZRykG2IGzaT1R4zj4j H2ZZgGA8xwa7CZBQbEESNOFpZQQarF4NkkLZ2Vgs+QHt1JzKB8jqEvlR7WC+eaU5nL/rPsNpwuYk EIWRay0uF3X1/+L28FVXSSB4a15i2e3lyGVbIr6NrUiE/9Q3pDwyc/S0+C9nZbb5Z/a+Wl1yhy0r tj9zAq478Fbs6uSwXuIA77HutZYytcc27/RcF6WZcPopTkehKWS4wDrYHVCHSqz4JPKYUd8McZwE TzjF6mh96uHIlGhUUedqsL2/MPggU4tvhdmMOfi2q7qusND0GGyhKxzkrWWL4JnmTp3x9JV7YFjl 3G3YLjfobl7Ta5ZmrfIx2yx+M0Y/SOsAZulOIsTWJ7YxqdE763gbdrVPee9ZjRm8QDoeKSRcU9DB dmwypfwxVFhE0BQ5+OQ6ar6fhzvVRx4svsSBotfyd0ZbJmJ25ABiMCWObGUZ039GypMah5rDprXM QSlkOF3shOaR0Ekor/BykH5x+so0wQVIK3fugeJXYa9E1Iq5S61npSPzB6gkEEenOzuNU7gDGRj0 ZeZaU8rYCN0yQzGAXBGECr0V4NcmKvbppYiTM12L1Ml04Xbf3uKZ2EbX6lWeMT+qPhJGRSHccR2U wqy11HUvpSgynn59DBn88VQrpdy99vZjNG7zBqr/I3r0+gtdJq4+1iPk/aIyC0a9Om6psgOJI//k gAoDaJ8P6q5MyZXbPtGTt/CLf2kRAm6a369oWJawnHJ9V0SlxbES/jbqZyM28b6ioM8umVZL9Di/ 20LMeoWmD2sdewkH6EfHmpKC8mEMIssXBlI9TOYjB5hZkJzGslweZNWwV6SyZnZQqqfYqkmsoQfl kR/jEpIucxLzZGt4bLIybrFs8oJxmTxSKPMqfXixL4+t3yVk3tP+JKnX48kDJwGsGFFceX9fy1Ue GsgNujIt705G91hD8snh8TPlaW1Ry3AscfX+cN1mXOIyoC7g/TLjadilaIpI0eecjV9smNLQ9hhu TJpnJvDwnNzGokcppG9fED33AjUFndRzpNXbEQiWA9+USKCxMQUdeeqFBWqPpLcBHpZF4Oj15WjO ASRxa8w1LSbd7/bqRqt/43DY8NuFQuhX1sKRQ+S3LaZ1X7Q9G1IVtgnRhwDumhhPIU8b2V3YWK5B S15QccTHAbOXMA9HT+ivXW8tsaqgC9NOpUqZmXwYTJGZS89p8TgKixqAcUZzI6Ewtdf59N/PSAHu bOhVLg/k64smbn1Ao7cYvNKfc/NTqQw9Dcy78XFHQGRe6VJrK+s9xSldQDEDgUoVrv2+W8O3WAGM sSz8ApnBu2LTZXcWb41WTmKY/3iJ54+IHL5pNZmv5j7AbSYgeX+pQo+Wb3VSVFALP8TwKvM2DHiW Eo7INLEToO6etZoOpBxu6PTkM3uSH4TxEhgo+ZJGz2Ut9p9QCGJWJ7EQARQsKM4E9MF3eiNLJt5q t/VQFBKwJaKDQ5mAHcsHp9yKNGwEsGy+VaQIwL7X34lsr/37LmhB5z2FC/XAK7IzKbNyZBropHYs kl1bIxDiE7bNu84z1Vop/sXSadieTn/h1Xk2/9OAufhKIs+/mopzh4GAGwq1rDQQZ/EQY9AFm2hb kcankAEvWAac8Xd4AeHz3IHSaQs7/4BTAK4jk9Wxh3DICvmEvGcf66EGBjHbEMyvnUEukVSKQSlR fInHul/RdPc+9/rqcNcg7dieBEvPo9KFydymXfAdnyGqBFwrRY4SZQoOryeCApPesstwj6+aeB0n 209mqzKP4jaUtGr4b/A1z8vMKq9vaY9jTieQuh7rzHJHzy2e2+IkvSUUNfcyBjSnG5pf/T6LyCo5 cukMSjIss7RmcqpPhQpidohjI5YmNt9dg7xiE1VSxH+dlAcWnCQ2j3YqQRrjO47X9acbeF7x3TCC IkzQeF7t6jLka9dMlDkhsFmN0/gyMqf688hMj+UXdodeRYc5YXjpGn8IJvZMXMBNfKutfccUXuEM lGBk9OD9p/fhUPiSjsN7WCRECIyRUsUuseZ74F+Vg2aynH6l+u72VwQozLjvOhBCuFfGfSNaVLXc /AzqCl3v2XgL+HsHIA8okpn+rWdLqGEwXbV3b9Tdj3mtmqhJgPl83AzTW+G/TsTVzVLcYxF8N75N R6pjZwEi404Ytn8/uamX/viFKfsBq0YCk9VAgciX4+UOH/PEAobO2mCzUqFh/qooynfmlM/FW7Qh bh4h1IY7+e9U+QsHLXP1mZnmHsUddXe09aSVFqetnmhTTFdHMibCMqE2EzlmiwxeBR8YJfCDHyt1 myxFxJGTr4fWlaKLELZ7jI5s0pN8u6rM3fbVHcbm2U1ZZ5T1Iy3gTo4NrWZa4ppiogDj7i3famWC xzmlwo8FCHfoLPvsJLSDc592FPkzFV6JlDgopAMOus7yjJPCMTjWIGq1PVmIHNX9wPak+BESwHUu yNV5ALBgFvlsWKu6p6C3fTQUG4uvjwQ5isWIilAgzbkvFJwblMg2MxiYDkA8+FSve7iPMqTIfbug osNNQm5ToGTYj8Ghgx/CEJA0tMKmgnWbsGF3RUu3wo0bmQ+jYPtCuaabo1uJO/US1WhTMqnbsFoC CNGUa8LP5gp5HTJ7cxjy8uSaVxDkVmDmfhvyws3cvpOGrX6nnzQvHXi+qt73MrL7Q5ONB2rZXCrL JqZ2vAYtCYDn+Z+cjOwLYQZfnsRAf4BAEuAbXP5jA6rOeQs6QBiXjv8AJSeiByokzybb0AGVK9rn al8o+djIdJxXWdQAEQNKEI6MFPOQHzP/SpKsio9P6w+2BKLbnsZQLHg3Jv0BNQ2Ig2Ekt8jtcLB7 A2wbasMAwokT7RjAc4+xn5gocERbro4oloYee8xD09Nr2jEwRWvnhJ8JD6tivpwj8yWLpc2z/T7/ 0oB0WvgZjxcV1sdLKy9iB2Dqij+k8uMrWq6bHiTQuqAcRW0dKSnnCO2bMa39YzqcHq5mtpOjVWRS B0oQQR2MfTnYtgOP8sysLeT16MCnCHEtl9PMOXc2TSD0OQ8jdKHk+0sNIxBH7laLxvk4P2bMCJ6Q IPW68mNnKUEVB1uWnpv3/1yBfa6nCDugx8MVdCewzoruKwNhvjPmxPowzs6EdVOHBwlvOSBcWwyb 8irc09nEGhlxAfGWnMjPzwMufnq7qBRmiN30Uc58Z0jbWstfjBkoY7g7Sckaj/Prd8jIjQI65/bG t7QPkLhI9+15gN7UY5jGVHazakvl65GPFNk1ZtnBeL6TH8rZiSCrkMut6m4GVdrhqinwTpfy2Wq/ F7FtIAE+v8HgMh3EQilyNRjGCnqRQqebwoEHqbHfmDJ7bonNat4M0UYWUbXav2ZKp675vdoJWpNA SO7URLLmsBVR/lsQSCwYtn+Rk4juHFqGBOpC46saDTesOuV6jRvQAsl2praR+J03yCspshYdeEgl GzBvPILbcQ3rBlDwOd12gGGwYh4e806GgMOusb3PrilIzf+CJT+IbaK/xMPPxm9ISLTYK2exMS96 PIA7WSSVRN9IG+ExGyR/k+p6kmKWK2atJFS3X+3j5wyjPeC3hXbeRrT4o4c0Se7mEmO82kpjiRHE UX8OXzviEaNo/UFqTSRsptN0UiWdJTrp7UAs6O2wMyTtyDbfA1Eo1WqE62FmghJ9PIxGSLzbXazc KWbQjFSUCuKRTXM0dnIVHmu0V796iYyyyANqtJdFHJBcVKXgJraagxct4cQTYLZwb3IJWxzgrNzD IoTIoza4VlAI1GMtYI6Z5XZIgXqabCV2O9QSbNggtW4Z2Un6plrd1pHvEESkPZ797ALidny3XRM/ Wrb1uNlLirJmiy0/W8br6rHMzRFmQx0b4IOU2TMX//Wls0xd4A2NNtBNru0Jx5EWYQlnZaWhoaV5 Yly/5lPagoqrQAzzAQ4mA+kH6iKRAoiontjAZ/hptOyD8gG30nqyCGezFbcZt6BwCiDTIfjqBLGY Gt2OTNue0wajpk/NRysvoMbbEiaLWIyO5PJ+0Hi0BS44lmOGgK8BudeS7YhB+BdxLatXS+wDCXSj hPfR/8Nqg8P4taxujAMAyu2l4xsQlxo6BakNFayqW/FPTpE+Mi/N2IAXJ9WO1sZAeN28XulCSFuw /lWTZI2l/YJkvlgNn6jaN5J6e14CO7huQcj+Ky8ZfQcwFWthI9smIbQQGMnEaKq1M2xb2Mrh1v4H WalLyn50iffnCPDeRCt1o+GLLSoYspHNqm2mercqR5Yfc1d6nkHBDwyTVaJ09y10FnJ9NQHQEQF4 wukp3ocmvhUA8EHr575eRQFYaP8Y9sO3B0a2kH6PHapKSDlfsIKQvKT9Py7YyDfoAiUfQLZXSNkk 0hfi4tIXfd5vpDM/PjjNrgX/gGnKl7yMSEP6aCI8ZRJjgTxWHIK0NDECh2vfB8S1ukV0hiNEiXa+ mZqUnjqqh7qGBoiaIEHwYeADrm2jZ5pmQ7PdH7kuX0iR2Fu9qi8AHBt0xX0kORmB07wDm5W59qZ9 IGfeyQltyiUcQtJEzpi96WCMr8xX3k5l2mmVjHB4mc9gOiC23mvZ2sEk2U62O/L0scKIaTWL9o4A YOILvSvcyDR5kRV5llBkpog5RwLIFz3B9MxeyJJe9Tmq0juR/c4cta/y/d+x9ptChX0F0mKySamM rlE9R85oM+4WTtaYZ4NpiNZva+v5ixFzJzTUHgDdyycsKu5h+xYO3aeffccBLkD+YNLKUd5k4NCZ M07GY+C5KJ3QcWXuMTI5bxVocXrMTIitUZS6KT+UtIBKP1/8JHTekTb4OEEDInEmw5GMmxdySPHk s0dcHcybytMrVo/BeQvsDb4dnjFWpJ/oEUwRuH6tncjIANIWatioAKt6Cuha0z9EXTMvcgtIDZXO WI3KoXCPtwoHvBBHrAZumWhTTiA3GZeLyfk3pUJTf+rhiaZQDPzxZpzoLKUtzT9bH8qhTq541LQ/ LNGSeyngHD5BSJO55PVif0dRypYJJ7tYFWsabBz4TKuChJdWjSAhfAiCawT//wk5EYwBipu0Eeo2 W9g0EIlqiJSDcEA7NrRdNd0tGc2GLs5TxlNQwLD5+azjdKHNSPBgehu4qNrQhwLGZyn+uAIZjaa7 2ESdta4fgWFA1OUlVzEVfhp6JTLYZ9F1JkdDWSmqTqcizH7cOz5myWbQ2X4QZ5AOcGChLk/n9wiW TcCNLpD3N9IkUGHfKYCJ7Xeh8YArXxAmsjNHZKy9DDGKz533oflXD8X9Q66tXVQtJBuB++mqWKS/ tpFJ0J43OsS/brlc3DHHAC8dsFrR3aGqVT6dmG+9LccZa8+UJ1O4tiyDiUfBovEauoBuHOw7fYCO ZZN4Fa29ATSWSzoHGDFuAMcwzu5+GB2mDajFaCmEWe5W7D1xwep0tBH1hdPvoN1kULY2JHtflNU+ XllryOvRiQt2JHK5CH0xf792ef+B9pCqJnH6pW1Q7nYLRb2sciyR/dZJsR+pKw7giSlYyP5amj+n 3C+M6QijYZGtqLiwfqBk5juzK+8nEc50CkJSwDUJfBmF7MnrzGPlJGXryNSktD+N1DRTp1G+gbYq e9fpeUTNn/Hj48pYCBq7HyR45okAJ1e1SJCXjKcABTeRfPzVZjn3GkyoNu7Qy69VOAzASAtuCRO0 4ZDOWF11CLy4Xyvh439SfbZMgdjo7NdSQxctrkHe6j/QDmSZgoXCngSI3tS54mYfjOu1C0lJKyii S/cWJUivX4PbVUZahQswLkbepHRpdHpCXF9HnNz1uldxyVkbFMwXU3l+xgHNoGYUBsmYLdwW3dlV GHVTbYiHBj6RQDPBj+fz440uOiEXVVTzSbdqaEoiorDo5QgPTnBL8JrrpYDkFzC2IK1kOJzVokbf b/53pSa8CGQ+tiD/vqAxm5LscGHKRe0Tyd8kSwQ+zDvf1cehrDm9x0wi/P2I1EBaNu8AGL9wPrWw z6/ds22MdBJ/H4rdTFrQpvpPdPy9+54U3MxCvYacJIckiSS98u7QV2qzh81CYNqioN07hFH9tlnX DH/H1GrT5qDv8Y98Wqc/zbqCbGVyRhBPvflGW2PdYMJnzM1K+tQS2joAnijuvtY5++Z2Cw8gG+VZ ONpxBVwOV9OXPPlulOaFYbFWRBvRNAar5f6nWKE63OS62lQ0DZiIp++R954YoGqkTYM+MIaCMA32 Prld3MCEYE9CgsjpmnlQi7svSH9SuYWhpHZk4svGgWXlBObyL5m/VgBpDydA1D2SktFOAsj8IeE5 g7LxGvjnLr4xOWC7ISp2ve22iO1RXo8ure721gzY+sTEtrzdOdNJMyFELnnkrlQDO3+oRRRJBaAN CDPx2EIXaR+Y5XKjeVtCL2Dy1FumgstdWX17M3GTQttUFcUGnCvCW1AUfh59ObOgN9hCjxSNw80c UfV+lMYYi9ZZVYvQfotyAvgvz56qOD8ornk5ggdxfOFB6g9vdgfkEiPyvtotoejPyKAxXljoprTu tWZ6ON1qlnOhOyWmy9sBq1AOPHacluYO43ZBok1LUVY9y1d9CA5JA92GSZT2/NPdmEsbkHrSJb6W FCFDdDW5hzbAfKaaMPLquhvvWRU0vECOGbUbbQErepcyPMZzU7fxjK97SA/xW4thKElAVByt9rVr IF1X9kMFe7OSJQn/YfkWxiKO8E4SA36heYP0OKOltndl/NzpTrwpFvuQCImr7oRjb0ABjn16uC3M aHGPdDaDLb83MHmGkv0pKayZr4s26YCY/jpuuyc09+W/D15DquRJsn9NAC0CY6EbxjHTwImURK8Y ej8mR2oHLn7x7omoYYqFWwpDXIpvxseD0GKKEACOFy2PIeX+59XaopuTBpl1cw6FpqGnRLQ6Rl0S 0EqU6ViDL9si69sZvj1iSgl67X0uBcSIsxnzF2WMsvSXMM4H+qJ7rnlbmp5gZzy+OkBdLHZBzIH6 gZZkstnTYSdHK1MYVXFVA+BcKYxdQUTXmZ/eCCrfigwhV266ZUrTnTUpOZmf6HNgbdDnDBbr5nZe 46oRt3m/TmvQyhZuZm3B9IlhKV46c1MqMLn9LnKKnIN1FX+0QURHkU0kfxD7ndLIboJU//IU3DSm ZC1aTNUMmpFyAHtaFrrwxwK48iNacU3Ce7jTDYIrQc1FDdmIdT5dYTe6ixx8hr9bQNxfUi56F2Eh s4HBqX12iwB7fm2ShflhKjHqNSYtATr4WhpDElG0JGZp/yaOMkvxjpAMg7p/beaqYcLdsOgzhgiQ CA6Wv6K6vshmVzMnC1exCEMBOtrPK4WMFEJ0ga+4emRHeG0oT+4jt6rYUbiSHZxNahsPXhQBVg8v zhNyiD5ffnza9Ns5rITqkzz1d/qpxtw2LoErGfDtG/ClpzsjlgGvLIbhFKakab3QMiQlwiyBc2eh 6UXNn7Dz1z1ChA1GPsX/+KxmqpVDrVkivX6bqklKxzPcxq6cdU/xeVaUq9C4Bu4JOg+AmSLFeh3D SuUKQPUPkBeieO/wX2FdVfey+9KY1AiC8AAhZ7TXAK+sVn779v+ofVgl007PFE6T7DFmiGvrL6An qMrk9/n8tt0rdeoq1XPDkc9/7zFqNSnE8cVHaDKEQVniO7zWGRLOXACN/yGWYGGMxffF0xKFkrq1 ZijfT08piiACQ1NkH2HhG9/bMjWUZeLSwTcd2l7wF3MY1ONZpkbqzCVXsLAAtghfRtUPxeROKl4q lNe9JQvOfBOfmnB4VJk1jibIDR9QqCvmm89Q/atXeSS80fD6GCSqiqXyePE0XPuLf+nVLrWlN2Rk dsYc+32/YYIUqzsrbHDs13OwPQ30ENRsMZd/rAPiJXjiLq2jVuBdTg6utMaU7T4UdobFQDOf4BP+ DFrlb6ka/uRlVe+5V78IuVlS6w/Y3LmRM3JxMtflJQbgjCzgmaFX7rHAJLr0fjjASDJG47ZsSIOi hS1AABDyFnqdWf1Xk2JHz9zUV9vStdaKYQDkgF1llewi7DpwsG92aoGbbCZM+wOHgLMAP0ltYBkr NULRCszJXLgwJ8PROqc1bi0FvobHiHcVkfAglm+6SGvzpjPVj7gNZJCQxDCjkfM2BRHyBk4dD4KV c/wWS6Rh387aF/GipxJOnmENPfQ7d2HvsPxSuUBIkXfF8scFaCONsPhANzXp44paUSohOAZOyNVD NilIlXSYBDE7AKaGGrMyEA0R3zCpJ9ROfuGI+MCsw7DGlyKBeXKttJHKxIUm8DE8clug0K85J+B2 GuU9DuVEZ3i7Q5/413bqP4lCdIx/HrfxxV3eKnSDxvgjDYnzC1vUA7t4jSujOE93MZTSyaW9MSij BEUqi2Sxhck+lgIMivF8DFIqJzwepT/Q++BQUpUZpKgPwt6vLluq01M7SklrQps6U620oWzHPH14 lc6PqBwbl4PjU3VRRC2QnLo1GtiTmo+rPAIzj3IDw+lPiNc3/1unfSGOOUF0S1HHjQVH6Pw2ymbz hJJR0df3+irgWjgmdYJjAEDQYEpVcrJR4HYg2kP3lm7pkdCKZDF2YdWV4ErMaLEKNhKS6hJbULSN T3sSxc3G7364T+DVgMc3/b2p4JZgg27uiy1D2ij6ukvx3JsR5OBT4NeoeOEALRfN9wq0R4EuMOaQ irhUhWSxGHtlXjE5sB6xP+RPoI2m6lz88vkeHK/enRO9YdwUJ6vY4nUsEULF2hmGyIX//CRCKCGG mowu0y3ywz8xnvVDLRZyOAN4Q+DFPzhUhN9XZYQJd4jUoMlcvg8zDE3LgtwpCz6aQiBLO73uhPi/ S2BNvXUgaMqa5KuGFpKDZb2ak61+7czTRYsUMu9v2e563AsRram23XJyf7Ajli3+vhOiomXpJTgu eO7szqt4Z+up2ElRh7VasqzZWqFukThUk/a9P3xhdXgp1hLjGIqWgUIGaASHZdf8QuaRLRCpF1Gl k+Y7xY8cKYv08s1OLUAmBmUht7jJQG0iDszAaDklOMXSq4J5kPVzUXcnffTO24zYECAL0AidUgPh n/YvHTZRtM0lTd2G5gkwzOOGM4YwMMa4BEdBsEf8m7JSiPqJ3ZmVuPPOzp+nTSP/JPHYTCGqGCEl feut8X2ycOgsXwxXn0ZsJB3jnknnzhaNu9mu9ZE1REMyJkOQybxZ5bO9VquQP2hyNYPTA2m5nKOe O2MunqoX6zsTeDBQieyCJHtWloTbHnFGqgKX+QxCqc9vSbiPSOkiBS/0LioGDom2pBu6EJo605tA /3sLfvOHoxV0USdcBB3ysLu3IkYcUF0Gq/IoOILEzuSDjOeC3VJuyVJWfBuxFofPnw5M9CZBti52 5DVIZR1Bo9a01CQ5RssaDTTyIRLD4WxtsZY3FP5bSVincKgMOGyrWlQf3JXuuT9odTP7G9d+LTJ9 SxjQ9yte6wfdgZ7YvTCfqJAZZBC+05c4ACu6USvIwAQm6O40d9zpQnqlDVFOFtv8nw+p0QeswfPH cXtSmY/wOzqCM2xYMD82XqphJ7u+WGrzMLpJOvOrHFU8t6rhIu3VPNLb5GqGrmZt4nCmyiPAm90t mYQCTsPy4lm1Wb6Cf1aWo3jvcZreoWaKRgmzU8r6Dn2epln6UgiTZj0/xGb6BvPzWNKvl1p+T7jQ 4mhpuZiYqf7pwu4IcMGeFSxGTxy2CV+JU6v30XVbm2c6sI07Jgy6YCICrbkd1RbvIa4+YIZEUEZA Y2v1hVOiY6/SgFB/JzbSXaY+upsfqEUkogdmYP4CkOe+ed2gMdqc06wUh0r0K2ZRRW4S6aLSsDdX 92RFOicfWWBEy+k1k6lHg2FY4dl/3xEjPvJIhb8emyLqTISZouL+wu27FQm0QbdsTocEzOZJEz5J ufQmCszHVFQ/zXSXEfDvtAeMGetMAzUHhBqPNze6XlqDJwY9L5QWdymxOLCMp6ZT7rUvg67CIYBx tAfk2X/Nsj0d67UK9Gs9R5kIp72sZjSgOGpVKTh1iLxiEAXOww0IRF2CcsFRmsdp65m5WZI7rqaP OAzBE1XhGIojVuFoELAO5gz3C+0xqRuJYtPa2/p0u3ovI8PHC56htwXiPu0idv871Vd+WNfQUSpX pWYcYrBaO21A7PFEOy9I03iQYBWB+hTUJTXlwJavwCq+Wap6hhMShjQ9+UtK7ZQlnZ5+Ffjjz1hq 6kcvJ/6CZoUvE/LIxe+DLKQVrDYAG4Kgc7QTlSNQBioqMP64a08eZ9qOWf9GqCvZ4QjZeuSqEy4t vgCPjEqFixI09XVJNQsn9qbzbWQHZ4/gdCL9t2rx450syQ+JdKeudAXdZKUAxgIkTXSlRVZ9tj11 5rIZqtrXQtIYFBuGJUMnNJPtFeNP9PgN1GxmxTdcI2xhz+0iOFum/aTNGMtLngwEVpb1wr7Cc5pa vq4fNRr2MzWn6K3ZtaOcue4H/lD0pZ75eBk2p//2Z7abOTiPcMp2WTMV0Do3TcAgpe9eXokvpQ5G piFS74+x63wV8FgvtN//741m2X8E03O0LtBPMC1o+U+mKnMMbYiCU4SrPCb6td38jFdm+I8IpfX9 4LQg/BGHUWyb49myJNKsmi9KoB3c8ixFkX5AVBDDagtjuxjJ+dledlCj4egyrleFMLdycsb8fzV7 yJm3Wtr+GWUlmMeARq4pFcvnykfmGkoNFmGkMW4ghTK503yhal4EF4rPky/DEk9BR9V8RXNzs3m4 kc8NSVplwH2qF017eEyD5V/vyIYhg1Su3YPBxxKMgIKbmGlv46tXEGxFHhuGilG3AOMwxIC8BWte 0ertLYKZ4rxDsKhVEw8gj1bOnMnZHidmO5WQr/FcpXO8MZsbkpXrLf64f/Cf0wN3LYqU1VSanEdD JUrnXk4lNsHP4ROXNLegHOew7q0U/omAJ9Sh6AuAU552+x7OAdK8PDTeG9bcWEhLf8GpXz4hDiSc YJE1cMF69nwMb+KmWKzKY+4XIvGGNqy3ePWYf5QR/OGuqFe/IeM9k/1I88UpC73ogQ2t0f9EwInx XHhMT+RKCQRWLD+qLk7tgwqenhBo2XYSJLIGfFvnPS30pCc6sHvBbZziyzq6Hs2+cIo7AFGpf9Cv /I5AN0AdEvC8HMv2nV5qUHwSOnduBOETa1trr8s5QkJ5mc/MKtQj6F0Kr8d987tKV+wSZMKkW3GQ 3ZUzg/iF64XjPHbeW312r6Z/aAwu/YWCvIyfkPxUathdWYzphq6BhmNQVxx7ox6RzMmaY1mRerj0 TPxreXsAs7SKwHK/vzqw474ALElgkjx/AsrKH3cFHyU3+doVFUcQklTcPxrDjP7omi0gcTjYiaRY 6M0H0nAcioaaM0NIxebUhntIWbqZerzclsG3JNfPHNfEWiUphH4xSx6EExkO/F6zsatceeZgJ/sM 5gmi15ZUf7ty2QaRwDhFZ9vZwTkCNRy8zH+8Arxlg7jfS2im85punPIUotm9hJAeh+Tt4TPTC1YP AP3OCWaFjVPgtIKnBpiUJzbE1P3326SYVRnN68LDKfKoug7wCfTezepETfwndHtRpc4kDBXt5JNS //3Y4ss6G4TTzJA9PvsEJ28v7/Qu8+HbfIc+cUK/EqDJab+UuakOGhNj0IOdi77ygR57y3fCYFtK XZLX63ihlGdlNZH+W84NDlVnQaHXKQCUV059UcjthP9XM5ynSPJe86biDQzcQCwpTghvNM7qRS8c YSboZZyM87PGHSsPYmfv4TCt+fLmVxrgQto5ehkJnJrWMFjPefLPOy+2hrI1I479kbFjGaidtsed q5tFsVNaG3m+KYF7IQRcIuSjdQylNX6I7cnyTynDdT1U9WpuwdI6RLx3jwIvrUP+lF4VOnIGOLoN KINHs31qgtI4KTKexevaEcaURvvSw2DT8kH3U5Dd8xuub+dYII7GqECAhAufwI5dTBiQzD4NQzBs oVMUsO8yPRrI1/VgBml5oMzIEl83KkTijNVZuZWI/YH+E4Yo0QF10lf8r4kt9P0IkxC2qR6kfU6E b78jO+RV5tQwW2XXpleOy8HEa9+6rHsHsp+uV5TLmuRaX+5GWCf/o2tKD4uyu1l849XjMoaGkOvS 9Xi/XQrUhUrsQO4NIZ4ux0jPLx8RpzyWXMyPTnoBmCRH1/x8Ac8yGV3oBc7mYWxPOztv+YM98KD1 roeVAISuMu3s5imwI4ew0MfmcvOp37dJ4DmMY3H9uiYvZ2Tn5sFlkdc8kHAl9zgu9i10ZiUU0de2 NNRHV//E2NSpc/+nuClOGLKGZykv9SRczEGehHeEaqTbr3ucJa5in61OS7mei5ERMgD7+ZH1GD7m RJnkP8ahsAE+5IWX52ion8DgfgKdO/fNF1iPbzw/hQq+Dn3Jw2brlrpPPFWL/xkQaLdORCtoF2zy Dm+RbvqzP7OVTUDo9Q9dHQE7/ajmH+4z4ETQop2v/pAROPGlVqVIn9jfXBqx4+EqZZISYDHdtzEL FqH1Toluav8n7xEkovJw1armOSn6Moe8Mug/9Ikuug8lEanLxW6NHd1Kbui5zDPfhYBle5GtNqcj 4rnDFSz2D/H2lEZaXQLpZcPvsFg7aGKrUiCqVS7PecPBuEHwVWLrCntdPgznTbVDCa/oun3l8zQ+ TgJg0CDyGJYUtMFZLq4fnQ0AWLTeXSbYsisYapDIYfll7j3nrlz3TlZm4LC1xTYQvDcn5wrUZI3l m+bRShzCq8d8+LHoQaD0cHX/2yVL+iKDmut0b6gcMMjPcf06tawVvdtslB6Y9g/Qm6TZOUve2Af8 CA9TDPxNSSfh346V2FwwTe3rIlYNtTh/kMG9le9VHNhyaNnDUeFXvlijWjTjgJhPJ2Zlhq4oXkAO KJC3PlH8O7i0lpQHEXg/IcQzmwdMajce7HhGQ9hYz8C/HHm1gfSz0chrdVxlgkScgQQV3TlPSQ0w QTg6PR0gj/t+fPnG+wlhqIFuYDpyAQ8FWu2JFMxOMzc9SiSK6ydLlXb/2oj5a37/0NvQsgcoPuwo Sg0y/zrBcK3dj46c1KMGtq5VX5CByNlJRURyZEdxnT/m1ff6SW04BOYnZss6sxP6ovhbxquvaF75 IQneaPT6bg/KyX6YbmEBuPvGarfTswloMR9iF6CHfgbS7msgHaJlmR7+F17I19zj70GGtiqtXNYm /AIk1BmtTVUIe5E4e6KkQ/xtPPtbNw+Fs1H0W4rWdA9UvMisQ8zh+UgRSJVyoub6uQdTrTg+1nVZ 9+pW+LfJnSL6pjX/Xmk1kITN4bfYv0dNL5j9teVzW17AWDzfVFnYplfpx2RDgMZrJsbFH9kQ/KsU FZJKB5kRAG3MSvsR+0RNRApdqUau/Onti3l+j/87VONyN5PBpomf5VTMbH7K5cyDSTBPuPWBdQCv bqOHCxjXsq4pc+Z6ZJr0hn9gmIg+UzovYQKqSKZQ/Z2/lvlgLZTfUy+qjdFQvvq7k9ZZ7TpfTJzc V0wjShR5SfwsRLI0TOtgS60QUV7m+XDzsjo0c+gqj4eTEc6KddHCAz+pYyYBJyAFpS2sUSXylTKu n5Q0RNj845irvfdkwpPRbGDcrzCmj/cA1dJ3B6zCBFOjJxo/T6o2RN04q4UFPcalvsrBhyr5M3VX bV1Kkj9alZDanMX2vP/Vk4BfPg0y9ctSv+ves7gtHgd+EJo2MIJuSyIekr3IcGnsVb0VDysCjIkP IzQr+zuthxDxIAxv9v3L1db4Ai8B3l1MbkXCS+fk0EGhnEJVHNnZqXACO5EkQkYOghJDfUHsa2uB nAgWSnGUwanc8sWYrxFrXPI9LP/2JAVuCn33HypdcLK0E1MTfv6QCr3nusn5YpePxj9fQ2bTqYcb prvXol4ssJvQhO2MXIXvqgH1GlHq9A96UorSaun5OJ/mZ8u5bzyCnMsjzLVHdVuPz5lXCZuN8pv0 6DG2C1PwJOCJmOfhoa0Sx4MpVaW/OPnlrHii+p4YvLqEKU+ZX1yTod+p6cio8HShmdIhYPlb09z5 LCq9KyWvcdBcabmDyl5CPJxdtp+YRvijm7WJKDc3Jw5FwlIRmEsNpMKN4GtxCeX6IJin+k/M7iiO tv6UCzvYikOiGNHqjzdM9rUe4BSyGXOipa7lUAxgrJCrUQD4er3iYFQJEHSRQvMF3fVnIwtYT3el /cYve/bdvcblprOSH2RsT0o9fQl4mOoQ6Q2WJGdRY+WW6ZgGQzpmzHTMtjNf0Y7ul7jYt7c57Fgb lawVcUJVybtNwCsH6FjXfubn+TwvEOL07zeAuHG5IqFGbHAoiKzc1jKP4VxJ3RKnpWdYzvOZ14z0 j17Y7HAKmSCSHYbQGebwpEMcyYVDUJR6dXpN25lm++pgp/dA0h/2SgmcIAgb8TzF4Ro97Yy3Nik4 3MUex6UiX5EbNmIhr6De+xiWXNFUzLLyoz6jSLdqBeuEpQgiIyBtyVZWm3X6tNiR8rLklTHd/gLc TTdRLJEGfcEtEiF0oOwcohBbsvy2rG4VZR7Zm5m4p8/ZGMIfC8AvEkDVTv+C2HdPEdBbe1a3d261 zqautPjXMAxlrvIRcVXXBXEgQPYtNePvdgT0xzhZ8cM6VosnSDiDsy9zC3S0D5Lsrafz76cPhlZX ujk28rpgGzsQo46ASc5EMP5HoYane/uaFaSuYIGHVrcifMUtvOBC2BIfvv5MuW+4/MdGv/KMH2je mpcwEuNqXMhAEnH2nqgkqiDnHHltJdTQlG70M1oU8UBEC0Z2MKSot305eISiD4PqHd8O/v8CC4sm ZaVayEXpFJ+WeK8m4VEg5eJKURQzz5zukzh4rfgooNQWNdYEQj9r9Jtf5nLC4sporcEpfmpGsdO2 +35wKvQa6GanT7XnbS5jIAVAnXUtZSmCUAcjME1PA0BUKih5U0imU+PKhupiJNKi71r5U8CnlifK 7kcjwmrw6fW3nQhqW92yr8pGvHirpnuaIoVA7ZOB1NvEnbaypZ/6uD1MSmFoQaznKEQXtnEpkQOV ttezNhSbO2r6m9Ri9z8QEz3A5o8JUGnP9LxTwu66TOpGuAYStCyhxl7U6j9OYSeu6kKaWG6XDqLO EFj1K2Lz1IDAQ+muWuZZzoiZegEcTRkIoMEuXcWF3X5C6YlwwIrr1R5Kg7+VtFKNHxJbo3DMLsVs 0GxeW1l28IcESusWMnKq6EeMPG7z30eVJa3HISmp6BIFP0ctljPTeVWwBI/x9kgCE+1Xy5jbFnA0 5h3OA1fqQnoIdo7sSDCiehRPTjVsQgoC8zc3Kbu4pBqQ70FcvYzCtWSsPq0nvT/bgFNQwyFNSJ13 sOF0GGDJA7lqMJqwgzDCQoRVUJObKu+FBUGkkXABBBsQi6LMEYb6nE6APLDSKOQ50bZXpQaYjmzU r3R1EJG1v2RVnoZMggQEog67vxDgCC2no5v7tH3XH+mNlGPCEw7yRfklhePOhtuMC96uItfNRuj+ BWwK05z7gWTNUmq7ePldx0tVgsDKmvk1NKTTsFfIzDeaHLqA19826CoRSoD8Ic3+HKDlbvLcMqav yaZZtRfAx3BgzhkKOgKsF6ADHwVDuJu0dlcsa4atxQPSVdTnRm4KthIm6zLXfANFeAJVaKGRde2/ SyodSAfmhFpEYSCdBKhoyZlVHL8Zsu6KDvIUS1ajA8KdjHx0CC3aD0rORvnp8QLBzqb6Y7d5EdyY HK/MDE7IWAbQhZha8ead2ScaRNhM5u0n8Y/2RvpCGEEDeyDDis1h98gr5SnR7tt5osv6fqK1apW2 wN/tJHUYit5I+4hXexqwfop9ceqpLsGvoeb5qEf3DRriWuCV44d7KfNXXxNs73C/KPduVWQnFS7u IqlJNDsooveAz8owxUvbQ0rjwLYE/fyOy3W/HO02FI+rEJBO4U6Ydsh/vq+Y155h3m8IjikD5MlV TiKicYWUQxEAcT2G3IW5/qYSib3DZrHTEewbpfIuBhsx8ZjwPqkKEkj4zS6ld7IN4bMebQdF1Z9s 9V6/L7DvUuj7BdmNk9Pa2J/1/hNxiWOpmt1Ey5pER7fafmZQv4b60TcLOM6lszEg8bxy4cAbac+0 5YcKUBdRDPaNxVkeXkghSnEM8CxbMYF6h3bkcf6CF0h0Nb9SCbczAEYrR6TirmRLXUmIb3pLVOdf I2hPzjSq+M46MG0qaJrBjeQOx+r1fZveG8AD2eK/9YXH7NaCcplW3Vyrb7PkKSjzyYQ1ARgW1F5z oY/b+YC0Ayr+14T2HoqEPsK7+jq7XKWaICC8XIpSc9jWJE19DN1v09d/4RtKhdNFgLptxmPq7A21 fX1paHAoO92rnTng8yYr30/3yr5wKuD6W/PBUl07PYPMfX9eW0726oK0ZENBUyUvZERJthbWq+mo on7TfagTO3j9JO0BIIJ+LvLmw2tqmfEJBmMfY1Nd6RxfOCJau69F10ZwQNzQVyycdY4X2iedhYbV TfDj1DMCVKdLrIoEcOi9IuoNJVwm6gZEUFD+7RpqhMmAA5B3Tqm5wJH2SfIOEN4s0AlBuJ3D3Pv1 aPfC+ABjmFFL/ZLKNE6AFbprvPdwj0OrdugS2cO2wMAZY3wBDfsE4bcF5QIOLjI6zZ+7AKd+lGQx AeO7ZEQgeiKHC3agJLOyNmt62TntHGLUqVUWXAz0B7wBF+W8otpThYbhl4zDxCqLJTU/9UOueiZ3 WhjbU62LanuPdsCKoIhVSuBk4lHUbEi3DUA3CvBigJ0mZwS44v9QD/J//SZCsHqtz8eBmekQBrv5 x1+wH92s41gqWpMcZahy5iIup7Jfko6jMD7yOonkDeNxsl67kq5AL6k1lv32DiNQZHyaGW8676kv kAHc0gwMuQIKUL8WNvGOnosCUYCxFDC1+hP9bhB4bUqlPvP9NHJ7EiykirJMbJqLqZr1IlJMZR33 j0cbmTRzLR8WdBA1nYC5Y2Tj7owpbZCcDf7O4Su79SU+Jue8GBqmzaOTWzIj/2ev0MtseqLOer6X eIO5qozbTbx3NzOWQbBFP0y43OTK6NKsV1jjeLWrwjHcEyWywSCXwo1ehe0kFd+errzfIrEknAmj MHbZPOHYd6HECjNLUENv4qR5MUfNDViPVcSIBbYfhxpTVUyZsS3Qi37kZByMd2NWHtfBm2aH9hoA iBMQQBlG+E1UKQrThIFCVRw2cjHChdEJ8K7APDAwxXdpquIiecmlND65/qUEfBkoTLuTmLanHB1o NTMzShwq58fjsj6qEOT522nOQhQxrT/AHAqqzhdzrNm1HRuM29b5wLPcrgA5EC8yYfSMqdTCSFCo 8Hj4Kx2KwZ2p5a0CknGZoK+wJGN+qSWtg/N1oobw3RmTYILpzf2ZWbe7oLXoHmXsEASGvakUrZiR CbFvxw7yz37NFHvWhnsxY/rQQVcm4ZAzq9wweqbfqFitIjbEyh1Xu+JTlJoNxg7kaMkez81CaT6A omfOMO8sKgsoezoj6vu2pGQiDjcDD+v9C0VbeXO6HFAfBT2RmfHcVvoSBpaGxsUyp4xGSyVt4e1v cBeOT2/yYWrSKjEyDHKlWXqrB/DJETxnZ5yE6vUCUQJ+NxOjtkTBiYFBSiN80jDIMyovSDpB/KGR 40RqRZXdsIYMQHFGN1KSMlfxQDnfq0fOv65/hD4exwFfedO6DOk5YXvK1px3Cp9KqZ3YL0r3SqJ+ gMbAuvcNbp0ghe2gWP5TQAqVj/YIIgk43UQwZLG/wmKfRkhQhsQBJfqvxbV3vr3BYrQ8QXkNoSiF IEzfMfVRb4B2ayfJCtmmDD4uxl0TbJi7iRf7b/nSQFEPfY7/mYoAqkPFgzfHJ+hZOQWDwH5wUL0b Or0Z1HY5uPuC56gEOtCXoN7MqyhYl7ilBjfXZNJYslX6g0vWu2papE3nnFVEakqIzTl6Tl1a6YVK RcnR5Mj3EwPtyk7BKnlHq6IXpycNIH3QS3wVX4nxuyNLeb+P/Q6Sw153oKleUYm8tacEv9FawdNY 8UNq6nSmzu5ZfB/h9OMFbKun8nKtmGy4Z7EVcQWun6kswJZ75tUx10B2EjCgt/rxpz0aVAvJinpP BNzp3nAHn0C34SWtaK1p/ETKJwtjZGiB6cL1PO6wXlUS/8+CTbmNdNdvboO6Cu/gqDw3u5YoZ1SL 9/YuExW44rjZVIT216RaBxjmT/02hRcgH0Jh/3br9PNhEUfq9HdyuZWP83oItB6gzFVwz5LkpEBm F8tVu+JV/Ygd8ijtT0cLUJGt2mmBwmnf7QV+Q94hH4gGeogmtRbvRIp4NxXyV0oWzhSCeC7Q7IYb YkyMRYm2Y5oxuFj5jF4guQ6Epu1Q93b1fEkt5vtKpbbtceguREd0Pa2gV6Kx/cGxst2tuurDFjKb 9MADRRbRH202G9l1RA4WfH0t8+14BbSooQNZL4OkdLpTl7dh4cND1BhkmlxL0hyASjQy7NqpwdjJ IhTRUiYIyEEQj4jYzvdIxKsVjmAj8hARSt2Wtlx1SDSQPPyIKOKCWP2htOZhu0bN+DEl0ThejWbJ nGj7g4mm3s/VEXEPiUgJE20TGROhOw0gx/2Xc6v91cMOJbDY52FxdjOrQ6WeAXLiS0EZqR8uzyfp u5M/rLW5JsVq7vCoHjdjkELGir7OMQ7yppK/1iG9Iq9JprOcYNpyctYcTzGNxJGDNBXLr93LBvsc OEqxr/UMh+6lNQ4+Y1BlMMZOIFlwgM+juEngrLzksOauYcqxL/hvV2nLNcudam6c1L1Xax63vd2q JXkNkPyLzpZl45JNMCcLDl6eW27vAS8maTGPqVbRxsHXOP9dMjPisJwnxUsoH+ybUSI2vF4l4+g7 z+iwLgFigFPtzORHzRo+nJitLWALjqfhb9+Ej6woRmmD6HRMBwOtSe1PIxQeisyZ8P/g3q7MWPwQ HmTp0n/DyEaUpUNe2pnRjSDEb5cp55c2Sp3eAGl20/uyrR0tA7pDZg18bQt1uVvI6X66bD+Ckm+2 lK5iGUoTUdh+jIoKlMhA/kAkZrc6SlvhZBPn8Ny0PgRAxvlHf04QF9FVwfJyj4L3o7suC/fIn+2t 6VZYcrEVO4ny835TYgK+pC6wnWJSjVqYeNBx9AzoUmt89YGsdny+gxWZ8sLhCeAO0TwoPSSLqHeS nRyPR/M/c4LF/mpvkVTe6u32vU1KMrwMlBS37hG29pk7zKEXrBF9By5WBALPhPHo+B6uDQbIOEgO ukELoKZM+HizDxw4DxajoXTrK+YxvkvdbFP5y5FO8tO3ThgbpFG8ZcosI4xxDrm7PUzc5DVkbXvi B47qalKinwYaQDM/mguruqXHJFHQhZ29Vd6o/ZqRQO3NOGEAkAPsk+YRKphyu1gb7Sl5ZvsgtIdc njN3SFG/91fY5NoZQSzGoEohu+j+2yhgZjwvXEdPFoMdatdBKCyj+u4biEW9rPW0ZnzOvWmsnawS D7+6KS671orNKZVu0i3sV8p3M051vsnoRDlxKIsiiNZ0WArHeb0YfWvs48BJRkwo3rQJpt3zYe5M wWeJoS00+8mGW1ly8yCCUHtH8sNwG94DolSDP4tdqaBB+xSrfUCxdNr1VaPXZiTOg18jpL7xlKJm jLRpdY1KB9MJCgIJ1hVc/HUndpKE10V3DsRrOLot/6kx3lPmDj6lzILYwg1ERAH8QETRAaSZshDw pHylz3c8QGXlHbnZ5aujGmrVhf52qW0TzolQGQ6qDoM3RDsaml/LwbRQVKxa37ctTSXOGTSpHlEY VtB1UuyZ6S2ZrvO5CinKEuvDjcSxu0M0vqk3P9bLx5VURzsXp9LWheqCCxpV0/PCx5XF6fii/1Hv dHiwzF2F7gg7ByLF3+LX/gjshb/H08qd208Vg4Oj0t7oXWUx6ITEFXZQasJ5YhoqrYGIkvHd2M7G kVEBQ5bIFXO0MonTsc7iSXJKZPjHVtfFKHGHWYDndLdvwEzQhGNPCM+MoL5KBKyGg1zRUk/Ir9wl 9OQlPtP46IR146M/508ubj+dXyVfyHurrWN5Sb/7vjbPpEmCGrDIqXTIwXZgJ09kfXyNVtHaBIDO +YomOaGYz0/bAc61vi8C32OgEwRbRYNqouVdgyKOEm0wYPrLHqJaXZQuplkYmdeG9DUQM5tyDg55 oaCzJhRra6HfOORwtU3TemfAfs4Rl0NbwVusMGcRsttoYLvCWmxbW0TT/8IMtuDVhEumBwBjveem z3z6u2V1mn1J4s8tALnOflP9BgLu+L5PxDmlrpoMQdqI5dJFy1q/dS0aMix0RoVvi6+vqWYP1ifz YdshtIJqKwv0vDJyV2+XhawFBLE/adsMdIUGPc4up3meXkfxiEC/m7tEVroV1SSLGKZfMcOdMSRi S2NBQsMHuAXJGT0aYtONVjd6s6snQR+Uk0Hwul8b1I6sqFjLovaod/6MQOt93RB21n1DbQkCuBSd XLED8JTTtHpYaTQY8yA9FAUpS5U+G3vsMSIZbZQdD2gV2hksvVrFA+SoH+M9nomwmJEuReiBJWS2 vUbYTdHVryiPJ6qsV37ah71qVoCyD7GaaRX1grj2QeA6UhkG0OFVtqViOhkaKVPsgOc/XNcoFCQX B2JyVdPxyEVf4fyMdAzrssWBYtriaXWsk391/IS6jFFBzq4qdup/WSv6NPa8Q5nfTe8yYS+AB7wx 2giqpO4SkgZwdXx6XBLjVOzCPMUJi28tX50pY1MeJaZRz41qMeA+AX8QZ6FvXND5zST+tSFvVnXM HypRV3rhVTAylEf/vBpkKkSRGYlsc8XX66Yu5l/1L4fc4244+DsIVCe45gdXoKupHUyGAsCqOR8z YXmErzvoMl4RPPCX/4QwtIiz6bUgnSbTf/hTn+FjwNl1SGeoGxA0gtFeUfmkuPJ1+nr5Gcr8bpEr iXwe2gFIXapcvCp5VFUOhrm3DG7LlL09z6sjhxYaxrRANa1szbBPZJXFtitgTiBt2A43VcxHdhXo dXprTytvLgToHhJxTaLN8dRz8Pg3My9eVhG8i4VnQqonNKjPIV2zHWxzXvRmgEl5r+6jl1Z7pq0w V5syu2OStW0gIKTbQy72PmjCjkCNVjI0TBgOzSGCv6j0jL7H1CecgXP8VuGZXN8XCK7ijitRga1L 6eFkYsaaFx/uQzWjh/uZihIopcrV8lkPlrUEXeKrGb006isOM6B7p+IsTH7mpqxB7SFofJDXQRx7 YcJv/UGGG47+VAo7S9FCbJGpH/jMD7vDRkmpr6WLfGvKnNhcdwQg4BXxaSiDIvsL2y6taJmuOmNE /XTCRxcnlnM+6OIM8GnOFM1tBMSTjJYFiWxFo66sPJmRzBLdnlWlacH08t/PN8JswwHJvTHP8tpn EeDTUwE8E4z3ACLdfGtSiX+paV/VwUwAs3f06mjn8hkZIYpqF7M8WqFQ15KzbOb4Apuy4hNlnGaL 9bohUSdyQXQdPl5x79qGV7jAYDN96S1tnWPs2nPgbdR431xSew5cbdnfFKacCNieBRAfZk7OhOs9 /M5+kpNej3BIeEcVjd0SOdm75kQJEWvMsL9gAt7wK8LZKiII/lebKiUcJbfdetBcHwM4r7fwxsY1 1UmALK0qpQkcAqwlOL7nYKLJpMBNA8fgohLeJUH774EXRPHIeWaHaa1EM2aUTu/mkhoyMFMKgstC +TkGU9OPhe4thTPgi4OBCEl/Z4LF9F/w/ZHQ/Xf0Dh0Hu+ZpckGWiMW63pdELbbtC1gV2cMhSaF7 N9ljIzmLpbqdSFisawKMI4C/OLgYe8E/w+wiJg0w2DLd9j+OAui0v12XhX6vqHkTw/MgHxN+GZrt TKZWlBsz3TaD9kwKabsm6wdc0Zura46jvQSF97xdZf5TSeo/ljculvAoiJsW9rbnyNUtW5XZ95m3 IBSjUuYv+o1iBkF9QkLXRF4J0buLjriI9QfikDcTU7+hVT0XbliTT/Az8hIatG9c4g6DZSUaIHTA s3FO6g7x6r84M/RdaoY97vX2eOa8C7K8+uws5cszpJR5BgxL6wpvXQh50gZpZB3YGX3OkISUu6Jw MDst7XbbLbuT/+Yzqe71kYaiFPdf8/MfRaKLL5mgLl3JxEoPul4A+GgjJVcnZD0GJGyXnAA8l7I+ be3aj10VTgreYqcNbR5tom/tWf+K4J6AlKSJ15zC9sItwywsEnSoXxEnGN+L/e+KH3+snMM06ju5 OBGzqsSFfgRHC+WNTsyw4Ftw+MK4Z8iaMRcoTljI1UwTEY9ehRP7X11putl9MyIMOx5cwZiHCydW OW4Ery6t4miue+kEOEBo9yLLn2mZrSY9vXtzYbRjEdTU0Igmovtmoduq29JrZtwL5FKPY3KVrk9I DOrmZ7b6k0d7CG6irNXLlj2RQtoCLrykWRyqvzwsi4smtKf6jUrepBSGfx1Gau4GfwN04hW3WsgR hZPxby39Yro1SE2UgSuUHTgDHXcm81tVnVmqqodM5IxXYGJ8u95fifJyhNyK/Ht/DUr+RxrmylPO kEKTBrzCAm2CTKjQQIryd/5peKaNY5xVJfQxi8+kzOPLBx83u1XWQVMx2yoU4Qdcyf6/+uR9OT6t GpdKvdvrJsTUYb18PuaZPBBXKa8DpVZju7k1q/FAIn41Vc5c5nQjq+p/okXyGIPIb0ZmBedVtKpS Vm1yFNJH+eIBbh4xpt0BOiVVXf3KZeJnO/zHPRv8OvpM5/QBsjhUpPWKFYQWRhHmvZnL/k7qp+VG 1nknqgpM5n58JIgkRP4FLSGUUdKUQkjYs8husym9oN9PdrOYGXUgtRE9c+a0ypqK1cf1Na+VccLM LdM8Kr3Y1a9yBdfJvkPU+PHK17tDmKTjsgl1MYI7P2zapNcMBdoF4hJRdB1OLMWUkG4cuTlsYMKv mbENERLptT4vylwDK1gu1xykWD/YubHFg9ffazWw2DiD//LEG79GkXPQ8NUNg57gDqWGYWTU0nHm IuSqE+CQ38M7CJxPigjTj7Sh3Z/UoNZGZBnZLwSTXhl0SN/QMB9FypyOXRK985sW1suDay+1XVCy +OSNG+FWJxzQlMAJ2EKULNEEQqjIM9w7Yet6z2n/TAMvNGpXA7KxLE9yQsa4KFKWAmhHDHdjdWmt lmAyCItY8vWa7/szO0ovPQ8+uWC0hpmTgFsJOLv5rEms2AMMUawwukqDvi6w4JBD/QOtXE3hOsNN g+HDux+pv/lgNNRVphLwahuvuDdgU58517XUAQYm6b8nvK4w9d+9xVdAylYHD0aFWVvG58iwPIq9 c7B9OjeBqZ3XfFHrYulRzbLB/JBnfRa7VOb1gwoUkHsZ7ytG0+T6HwyAFHMntJzUdpwkoI2vYwG+ A9UaBlqMl+26H7vr1MTj95B5bwrWa7tOroWGo7BnYmjzHuqcHlSnfUJ9/SuZLik8DIjsnPoLBOdF 9rwYWRlh5KguC5TXYdr5FBKz0gDD0aYYt7Ft2T0er+1dUApHO34WpplcpPb389qQ0Hgx32FB2jno wbJIMlgNkp1RMU/ZujSoyEW9n7EqahCvL2I5b2BNdblMdZ43ct4FvvIlhzTuozH/fYZRwE+UrP5e xSqj5nB9avAP2dVEkgp500XeWk/HdK9JU/32O1Vw9l1h1Qn2ElLqIVtXH5d8IUmZlE8ikqSnkw91 GnQ63W7tVcl2ehifehyzgeq+0L/5TZI2IHyygOLiAtchUq9+ITa6SEfnCVr7gSH9EwgiL/iEBccz 8KSELV6ebJMUEzwpOsH/t6tMOnyvJpTakAWgObMfMOWvOEfI4EmFHpcBNZwgWeJkjA8o8ogK53UI TzpGjXeHwIjAqjFePJzFuwl9TkvqrddWt1QjegPybEcBuPwYUj0K3IOEWfdxfD9f1JVs6+Uu2wn5 ZLPCQa+ZWObrfNcNk76YK4e4g8SwELI4vS+VC6NheP0HsBtXhnKd/N6MxnjfDQhOTnuBpwjkYvpU FG+YlR+TFPsrpuxfLEVGz+MZf2HeuSuIUAnkS06qhC5LBw4rEuEZCQhKyphk8ET3NfZNMOGWUrmW qAkSQg4ysIw/qLDUsCMObEaz7hQMVTAE7ei31zUQiuVGgbnRVgCKzjE7HxfS7h7qpCTU4P9/Rq4s 9TUPOT27hnHDE/jgedKH9uS0rcbJP2gnV0sgQmVGTrCQMyPQDcZCbkp8UaigQkwAS9ZB+KCBcJUz K4gk172UoqJYhYu4+k7MHy67K8o7IfRoCtLfFESAtF5MArwKHTMd8fWbLfgKCnwU2CAvUM9fJcJr hzqOtoahIoBCtynF68BId8Yby7BhOO6IVC/kFG+eyzjBkBE0BBd5sKWyni08vF4Z3jMjhmrR/50L FX9B3PNAa+vnIlJLVdn4h3ihCaMcCG4YOJdPVBMDRSrBacd+UiH7ATxqHghycrOowOn7ng8Ws9ae o56C/+fCbHaOzScVYq2qJGsOyUjKM4hYhAsHRdSwvgGU9WpWcPNbciQr/x3ERk8jJKB9nIUjvTPu YXKoLnMcaNFM+APFL2eev3ib6VDZbHkcHDMpfWU+UVCNaxxqXIHVzji74Uqb+q5/A5TLgKyvkSTD +QaMBVNky0AToY03Th4wUSPDbMMh3mhOMa+GfR32VKz9SKHNFurpkwoaN+J6YWd6EofbwQWeMzWe dq+QclmrSDxQPUrQ9WkSkxY3z0NzSevBGXte/vTTk+ZP75UeG5LklilVAGlQ63WC1SnxaiqR1nc6 ni1iyVx9vsFR8CnJH3ozawAVhrNIDwKOWHvVf6twL0HEpt5Zvuh6auKC+4Ex1xLsew5hJlecMy4J 0paemYvqeV1ENuAsWxfbpXIe2cEBGZsZ3IQrEq/2rr2Eq0JPX58XIj49bhgBcEOatsJwg/xaS12k f1jpbOCih7t6osrLHNPzuX0ele/on+E2kguwIF7+wymwhODriBj/sUdMTihFA3+NTa7MLESCl1Dw 8DD1AZaxmjUgCdU1MEYnldekzz0L7Dqak7nP3U6wt94FgCCZ6mXVZJ1WGHzqTWsGLMwgyRpZBuQf sqtgNCuEE874Eiy56Q7HPDvchhmtdPggdyL7I0cJS0gji/EE3WaMpHFGoP8SLQmgnOO0V+g4nmX8 YBWwT1oWipv4FMkFgvWRxVRf8Y8JA7F06ndQtAE7zfrWCKyc3dujB5GajvoHRPBm7K+RaLcTMoPs 0L0uXKHV6cPTfyoKj17y+IsTVQG/fnTZEDdcC3fz3RYOYSEqKO+DjixJhLUeQHXx7UjHIkNJzA7o rsHcmh9D+7bWvvckvFRMLD63Jxn5abNuxGur2g5ifv5GCtxjiIgYyQaR8cqQS8wGxBf57XNI1UXr PTUiGfSKoZNRWJX0/t+w6VpntYGTFsRN3h2XT2tD4ACstVvXTnmMuXau4rBvK+4hp/m/2M0jS4uo vjgkoaLo3MiFfPTHKrGNsmUVG6CMS2tjKKSOLVCmHMmqWeVaLhdQoEW/94KfM85b2la6v4lyAJ4g Z3iE2MPYA2Yi9NdVhvERV3tlzn37YwsbLA6bX+6DLEMwsqf4vsG31bQHURpsMKwO0T9dkcOkDyR+ oevVF0vWb+dndivmN3+ARKGLhVwWbSoouhqRMs7ImXazgDxTcm0TAzBAjlLNpMyX2O4ho/XMR9cf e8pqZBFtP7gs4TlNbEXzYXXyt7xUHS0J/yrMo617e92H6j7SVW6IQbBz73DvFdPcoDlIOesQBKLM 3GrQSAh5EWo2U4xxIHsD6lF/ZIXnWMypqCR/g8Zxk8E+UMFh1Ybi1P3gAoVq4UO+88mBYCtdIB+N +lHCvvoH4WZweD1AVKBaByV1fkSQlTJGE95QV9VZhmsnixxItdyrB0X1/BcMFfDeOnOUI+U5xUYe Rg2wjVUOn1QqUzftxQkomwyHL4+Vv9biq7CiHblIVTRIzl5RZv62PBIYXR8As6cP7E9iFLHR2CNv aTGOwfUCEsaBvh8fj4HDgzKd7zEbKANmFfcWQWoL1UQkW8WFgTQjSc6xKZ8h85lDft/LwKxdVOQ5 kDsLdjhEcGMEkY7MDui1aQTz+eSY6DubYzxDKTZ/h833dWtk1PSs+WpnjEuBr4yLQw3+wh8kNA32 +243vGoV5CEGVcqTo71MVSPzW9mTYsK156sJ9SKXhYqHSSDA+wZ8+OS48RrpM3AL1HNBtXbF0ZI1 vB8xqeyD/B0HJb0LxGpiq3yz4joKrCJVYZr+HCwh2OgEjLgoyOv25T8EtT0Ds+bM374m1suiMV9d pRqYL2TyufaTlLx9JxbaWHuRJN6XIaIgsVufuV9l6a6/COLoM28zW4RNxp7WfJLO3vlpBWjNzX3P 0Js2HBdtFZ2bl2+ZxYzAI+W2TfeB+mr8r9ACTnIPJq3+Xrxo8+kA2+gL70psTcVOMrZr6aPhMAgN 3/35wM2RHqE+iMTs+Do5ZkJQc0uRlhJGdmuoSILIUoeinO9FKPZxOD1h1kgWzOR2Nd1cQ9KuAsP/ c4/TbPn983Q3cG5Knx6uQuXuPBgyhR9F5kQgX2psX13H3W/MkCSdtlEr4cuJ0Ro1KGbZ5pUlOwSK f9JGhSOYuH6XwrkXS8u6t+Z7fbCVxtgGBNhqH1GqpB5A6hN8mkrkHv7pbHgtafwOyMCfiNKI5fhF p8f63D6bBrPIoAYy4FKriDsaCdXomAS8ohm9/xHq9mPRlK8/4la5ZhGj9zxPc+B8pV0h2YuLaAna 8uZSU4+KbCuFlUHLiJzEYDI6tkiM1gXjdA+xIvw5xVvEj9djbLYaSKYW9Ypd7SWTdHzXLFCzZwkJ 2fcSmvR/FkA2FstILeomRFVAL+vAeQY92QuYrZQx0xTPRWjMC0433iPNrKk9nIeixZMjujkMB9xV MZAiv0uMy6SKQeHxGM4zOhvH3+pcXN9fwNTlDYJCKKFL++0YtO+pvpi0rToQmvxnkgGEMPqH7cuv YnlNX3EP8vA7z/dsTOdc5V5NxVKeMN5E81dEDBN9xJH2uCkENbwk4V2ZNuE5U2cDydHcvajhVmHS 0KKxodlU4pDjY/9mtWrrz6F/TWXuv56Ju/M9P52seqLwORMQNf/ofDBKUx6EoSAPSmxGnovdfakL DP9HjPleRtzhLcRRaTlV3mU58Fj6OVHF09Niz5zwo6QTIZvxKmH68N2XcTU2DBKLG+EoADyJ/dIJ d36dwnc++50jY1kaO9E/4k85YYzXoikEIajlEzn4axDdVcuIkDgACHr+YCaJGemtLIv3kiyrjLka Yy/ujLoVMpePgw+g7qgo/yjXxsFgJ/D8e7jOqgrvAx8sw9LYgd2qz657NhIYcUfmPUhNDHko62Fp 9QoGjXa0L70uHnaXgAOLUURp1nTNX3IX8OQSYefzZzEkHo3vp3lkI7c1T8uIwiXroYLJ6wsiX/E9 W2Jk13whzhRyFA1KXZ5aawOIPptdPAiwP8xRxgAjeXRKgVFYWkoa9yHFCTab04odLk0zz/Eo2rFy SEoRitA2N7UhBu4P5dO9F1ISZUlvpI4xfLz+Gt5hP1DQNImHQtofDozPBk0vLTa6YU5Rqdp2Y70Q Cy0uSpnaKkMW3c3FFnLWRkoH8P9MWL/9N5uResit3x6OI2cV+2jA0IPbBlKEFv5cMbDugpu1M3Co 6R68HZ2xb2ZnzadkA4pUa60jFfr3GJxKE6MGLgvmaRav6nGgSVwoAUAd+gKmcBUsQB3BGTh7VoOX HmYFZta45IkfHjoiotmOMLVe4VhgGR5WrcQ5aA0jGWx1CapqgF4l2cpePWxFNWQF1w7VTrCsusOR datXbn/OoZQrdzYuGCQ/waf4WOVqOlvoVcPDrhX/RMGPMeHrEpo6Xawu04sk4UnCT5Xk9oaE+VQM xq9NhkPqAg7B78y/oHJX4whnI9o7Sj5n67/9vi5LVY1IlrLwNs/cCLp4UfQ9B8Ro1ueWPbgzXghw AEWYWYZEwRtEzHeTz3FuRt310jhmsWoo5/O36OYHYfoAn/gvNE20CqM4rNFaRXMg9ppe3iSOxfLB jvjQvhnwEFA8jPcOCbqRffegUbXsot7SeTQCZJcNcHddcemjX44t816hCn6LH8ri4fF1jH/e/7XM WP0s5ST5037WqrhIyFV1lINdqtXpZzyBX8ULKtDWBNllFOVj4qSLiOSZ5Gu7NPJDM50ZezGLKSoI wZqEVdWyNbQaE3CH8wENKRLbmDjFYut9gwYeV0KtAVx17Pr1ME/4Ylfl84VnSAiHnOEDvxvDcO6x U2/a4tfroEQ4KxTa+fROVNh8PsnYl+FfKTHDvDUhHnpaY56MaWwrOHOOBGSfD4bw1hNrwDKH6nor /IxESANqSq3KC3o1CEcH8s4Z+cBuyybGRg7JoifhR5O6EA1aZzcF4XBbdJ2VOH4mccmFL+eJGNyx 2MRjmOohD0OtJCfXjsLoybH9TmiOWPNHR4tsDBCzZycmsMudzZ4rSBl9d6/hCIgXssF1s+N4nM14 0jffn93TKroUMGS3ZystYJW+TaskvPHPuy7N0udGD1czR4WeU24B6pmJXzO4RpcGhbgXZ3DHOWFX IsVD3C8vbVrvFpXqbwtCDcDpqu8pSCcBp1PDsV3BY8y0hc97mmN0neuEyi9pVwGRZsfORznekPLg c0QYHrQJZf25v4FUvj4ZG0VuJ2zgUx/1tI2rr+z8RlUmb5uwnWz0a1IVfW6KFJLpoifTNFW3F7OB h7ZVSvGOfLX+vtX93/johPYcSULJutKhh+hU7HnaBupsmRbmTouaSI6YU/t2QnXVwSr0lrv6WYqA et2SdVK8tLHMkkUxKjipY+85Jb+oiGRlJVE6Sk3fH7gNN1kpKU6EmmlrsU2puTWWJbzLsq4YPbWX Q4j2a+u28v7VfCABtrOkAwPhDa7t+edEy/GqqzyAPpYDUEE/mGzl6AP7ruGN/Ph88Y7F8XK/83k4 DAEOoRUaDi6JHwSYnUGSS/TXF71/uduwU8jxb5hTkmnO++1yV32r7bV5oMdQIfgehmP+DvJCoe0F K3fm6cryHUc0sAzDbFBjOJEjxeZ9T58QkqU0Um0x8298EpOKSaXeWkCAPexS35isonsUBNQ6Q6+u ZBDOGrcSEDsr0VQZXZrJZTaUh/GY+/zSpCDsHQCqGGoXRYIqCnTuRqHGM0wbi4+laUuhKhCKUfQF VVln2RDOrYHXgZEAMf7FFbhk+n3Ozh2IofjN+HY9RKVoiYTfnZ9nH9g49sv4bByVlBrGeCa7oB30 ybt8eOUF3BFNy0OfDlJOmnNuTCVUHpqr8kxdF68DgPkY02zaCK2jQyt8y2T6Bx3n3fy2Qa1o7gE9 4olCIV0ySY+TtgqR2sbJByUY5JY2danzdmCdQ5NVjnjYhmPAtl55mQDnNS2pPR6Ec+AayLWvfqdu d4NMsB9qqJmx2x5Z2THqmjsuFCsnGjFBFPAv5Qsj19zdr4tQdRbwzGKtTj4F6/lm8qyfHqcvrb/b 59mZwWAiC0frAmKrAWU1YKAZkl8qcFHtK5zjAslo9L/mdIpRlDMNt840vU1r/DmhoRTydcnBb+r/ +I5rmrJhS1Dc8jSJDGqviO35/68L1NY51ldKewB1IXgUKgdisr41hrVUioOsZ6FCdlPRPAynl+Qr 6RYRLUurx81kl+FlvOThL0ZXuUCw3rCsjn3HxzhGQsPV20a4/jCPbPoh+baeYe/H0UC+1wKPvjzL Pudjh0wKqBhBh7rHUOZZH+T2ead0c5kbGctiiCuTlpx7wJBTfMGiBJOVJpVJ98ksIjLMZk2scdjT 1hx1t5bDw7v5Rv6TbijJ2oZgu8Grvb4ct88Gual+JASNSelq9aE8eKwuDT18t8Oh5k80K836yBhO u+7mGA9KU4jH++e7QcKaKf2PyDStCu+ClkVnfg6Tqi3xkoPT/pZTT/RcFoU8pSLPnezr1exATO5F qPxgiS+jxBYkEk747BndRy+MY0LrwMpq0LayJixX/VNyMwuqqCpsVxF8NcVVZ9krt/imo3+dIMXq 082uhz01xOYtkHbRe+yDrjCT+rIFDpCgL2Egq+nlFzv5Sl/G9kvcqmz6rajz8VkJ4X47DGhUAlbQ ysAfFAA69vIf6klHDp9lDl123zLGJREiCGJkiQtaAwALjl4dFLvXfn/AKbienEt1/Lgup9AOW32+ E70Wkk38po4GWt2auo2fqKh+b3aKp4AxwO2XjKaihGCCxpgyZk6JT39P8JaDRnsf6lTX1GcAqrds f4fJqrFxq1lU6jpQcVW9t7LOeeZ6+lPFjtqStlWZHF8+CG+/Q3TRrqch3Pq2cio9VTix78lRFMaZ 5J39HLCuY9QGg4K+HaGPQMCgnpXPyH6pxPwORUTAOmMdhLZXPpifYhxmCO13qe5oAVzMZyl3pvQh B7fyPCfiqKj4J2PAJyNQtm2UNVgko3Qv1WMTGjspnx/yv1JDL6myrApK4VXORa3mgobiKK35Qj/k 466qejoNy52sbmMn+ZZQhZr1hPmbONbijeYEjP/6P1My1EmVvFsRXwnOhbQvd4d4CgL/hr3rXNjt ZHvrIBg4Jitnk/EgZ7Vz3qX9tZqiEs7X8hDYarEYnhm/9/D1GGmAZOXU0A2o7FT4r7ZzeZlNH/Pg OoxaTNW8DVsdO3zoRoEMdi2VHRswllBjlmSfEkurrzLuurH65sM65Xo0mCxMbEHsMp68qWm5FFl8 WmKKkGV/y2PXwM+wGRhpBP4FT+YeiRaw/eDIDvgAfh3yTShspY3/3eqwV89KHZ9O2dN9HGEsix9p 6ItIW5MfySDEZ5mQc3IDG76xrvKkHowhk3zoI+cxElCJNdZswh7SIKwusqTsFplNOD42PpI4Cbfu 81SpA9VYLrP3hBY8VHbjGC13JA/Z5K/BYTFDqpedaY8itnEmiatO2PNeUewYbyev8e5bblPw4B5J ZKLy4gAHi2ps/b3fJ/Qj/gXU6BFgtAGRb4RvBii30w0BHPLdzN4XTSHGGUMKr0ZK2GlQv9FKjyy5 jdfOD1fnEP1r3KHwgBW/0mM6Yz0C37cwX0npi5328EQ658AMbrCJO3wGQh6vV/qGGpz3e4suBU/x 4Qi/DO8oTSKJDAhhu4d7BrJQhInG6R5ixFg/iKdJ9pyFMGVSZ7chaRW2RYMQ7stCFWbVoV0z77Iq g/AIWCy/F69TZJ25pjDCca2RvnytUWIjASb+Ct3PXl4JwnfyKf2l8RNtcYH1Q+WDxF4u+3Y+HMf6 G9j2w6Hozhy8zselLa7roPdNUDw8GHiRWv5Dy/ETa4I+5rk/CfXhQymC3em5HmGqBUMxr/cf/fry KdFb3rQWO4ES8CC3Qma6K0Kh3nB7txQsCAqGQBQRJvJm8qQ+IDbfG1WsgT1tAeSVpVsiFyBxg46x qdCb3XRmt8wXgnSrY/PKRLBzY6U1M4OaNnWL0h77ULcTErC/1gv5EB0Q+cAgxKqrhS7RLnxcd70V DodjPNlUtCvgLT5xDQvpXaNrI/97QXchUAETcbbx2sPoJ6lnTs4h2FXcQZdBUfNOlrsWQF42rnqa 0RI1WLPVjKgdRDzE0IDP5lvLqzwrjv8B96OjdhpaWHxQhpL2w3fjX/V64j8iQ2hH3L0p4EvUWvB8 utwKMdDAIaoLiIlQTii+HwDe2y0DSMR3ginqiUjV1nznGNHa+v8aun/+gNlHM5PUHIwek0dQ2nsa 4SFg1mD9pwcrPMo1Gjk89WoFAZZSylhob1DcljCppBT9ZidbBEa7EPCRwNb1oKXFZ/JZysOGvrtH 5u/WIkxO9Al/1IxtYt74yzQw9xNChCM6Aedtp7UGKZLnsSncv4ZDuy1yQ33PnB4KGLvnU7/vor9v 9xuP+D2HKx0YpXw7s6ktjFbzdcvFn8lxnmDD+MeFQqShxfcHaFx8uMhewpfrm+SMtWWt+eZdM7k9 8nyaguJXgLnGPw0togMi65ReqxXyQkWbpxK9tYEBmax8HwboJIqxWyQjXjC15QfDuMF7CPatIgDO Ld6Nwjr/xbummaXUwS+1y3gg+6cnIE7tmzztNx6eHQ/r0BVg2iVM1rE+JW1mc/C9z26iUNVMW09f dA4nW7tpTb7LtuOVldQ7fRb6qQOk4A34CXp7OeFxBk3aOjIMALeO7LA9hYFXdYLVo+d4zScRvsZu DEai5iwRVDRorKm4Eb1mW+p1byjW3aIgi4EtZ5TWBd2BCce672skETQR/h/h8gX65EoKeE1WxodG W0GUMlgkCNoQh0apKbhAEtEYpA8stps4g1jGrwoS3Uq5zeij5gWLQ+HROaWGIy9fjzKAEzjw1SjS nT5kfUUR8IfRg98ZmVFCQUeYp5XnJynarryqJiNFE6pzDHBoZp4iXhOTS22ZaMsH+FTJ+px+XCsz veBfnKQdkve1c2FYH2h0Eth+Sd0pLqiyT32nCFZrOXJrO51AduiPVkNsmfiXS1V3caKac7CpefF3 BjRYp/WqOWWkyjn6NH+btIqTDwWvAqde+Yw2CNs/aNupK05kMbFgS+lsOUWT6y92QOfj9tt13GmS 5X+Zlvd499n0MKtRLi7VlTV1VR0YeaQGa4xIx2wAbdGsOrcLSPATyrA/8cTi+J2hEzQgQRQm8cxg eB9VS294eI7IPQGFASGMGioZbZNly6G2OxSYfrx786fIO2pfub9bJXP+biCzbAwt4UUJamlxYdeD CfeFjh/29feAfRSHpS7nkDK571iDEhkng4zALiBG5bYA5KNM/NQRkhas+i6EL0rV66Bmp3iWqMf3 sDuevNUT9JyL/v/RdYOwL7Ejr921cGKRQgyWb+5O2E0D+LHKIbSHfYgJAevPzguDcyqhIfy4h2Um vpEnqJi8+VS67kQfoebPcBf+eWEX/h/r2no+2/oVMu33ivJWKylA+wRqdwClAFjiGfxWAei6G8DX 9P9Ye0kFPRnPK+b1Tl4ONZvfFB1yMA0dpWKuVbLtVaBnDn+G3YaBB0DEnOrpnSBTHdmDAb3H358g F44ZozUanQXkgtU6OKS935gg/qftEp0vYSbeBoGy1pSajyDvwI0jtMrwLwNS6NSfcHc3hy3d3ccg r6aeZkEha3l6hf72udEe8HMVpf1f54hTOQivGctNotxlokoHHhibAaYZl3/AuRe27oWSiKTZ1/jG YQhYpBMjKr2zj+5z1u87G8+QB8bnsDQMGQA33b6Jpj6hnwp1xEVXWfOoN9Ss3aqICELJuvkkvKLj 3Zoa7FZ6qAKoPkP5shQJAcJ1td42Vb5gtsCbi2D6fb73xY9vqwDW6YdlVVCkM9Wj5Er01TCYK/Kq MBVW5W7jwQkEDgFp/O+QKAkJfR15CxfsQqLQNYCkfa/w0pXW/zmAJLl4hkKy7LAPNab/tUa5VS44 xCkWrRV7sdbhpqeoJm15QXrubyvLAWfTwMXaSU0MjGYm3jWTpoLtpKhRJE0tclpczy93LZ8R9ZZQ 637RrovNcw4XB1f8iWfIY0hKEjJsFCvxcYp07Fk+7SPJ19Qg2YVUuQVBsb4xw484u4e4zLlVLWxo eKCMBeRPN+qQy3133raPyOvLVbvRUNutZ4rjWXJeGv0FZYi9wLvSk9mpv8T5//0ZS18cDrYlcI5J LKi/1tETFIwfgUYIcvdk/6o+7CptIfZo2RmqGg5HjQ5HxGvZeu7OuhU5W731SE+rrsL+zck2dlsv c0J+Fplk6dQhEcsayquwoFaxS+1iTvnL/n4xbQt57TAiDH2cUPkc/zWYEFzyxKMdmNu4Spe2tpB9 hXbo0JMJXlEA59sPkRbK5jCojHU4kMgJbye7nZU7H91M4dLuJTF59Biixgp8Vij9WpgP7AiWyEBn 3ba5jkrgx8GmGRFzCT8wB+k4rcMuMYkjo1ylb/KEJO9Iz6/YjfsuWC087NWW82iXvS9eF+Y3A6t2 Z0SUz6leBzLSaon+A68FxxFG+oAox1DhTafQorDqS2Jb88j/9jdzKzNymLQD5TqGmBbctDXPKcq1 IvtijkkVGigljHGxiC1k6HKVJ/qepJCzlLBj7y7xnlMkU6eJyeF38i9Ys4XxkrpRW9iuUcvsp82Y atZ2UEcTokpbXMdW+Ptft7i0VRwSnZkcS+5ztT2DQXQQ1+XeTInKtInBNun3DYOxOnL4KjBZpmef K09m14Jy8DOV9Ta4NCmfoDcNl3IU78rzi+TzUy4rE8vSLnKAsc+/H3K1zwZB8fHCE73eVl4lh481 BlUO5bkDch5lOyI/r4O/+DwsVfaMdoJgXPXJXwSXRRuP9OZ8z5nLcxlN3h94fh88BWy2HvOdZnys 3NVcoqjkMnRQtB4l17sfpzunfX/ZdoGlurSh0/4kNEWvDtEYyoUdXg9F/cHU+4G69r7rG7XwrvmG SK7Sd/pLhoOdcHGW4upmEXnArG1eiZdzSBki7KskOYYxEzF7TZ9x2GrKQfpp0wZxhA7C4mj5mmvc vbCZKc6IfhKf7uKHFuqbkinYIP3gV+EFLF7Y4W1zpIdvuleQWgIHaluN6TuEaViXahh5qOokRMGI jOvnjWlsfgn1ZDeOgBRTWMjyQDXL+eABQGTUjyvnVIIOv5xmaU9FV6cHOrarQda01CO3vkz8ear0 v8ch1ZdnYpzvrxFHBos38ehs2P65I/1qFTYQsjvlNeRim9wgaCBQVMHAiVMcqXBZkssKIYW1cR3p qIZyM7z8n68xP9AGoLbWcvxLrWE/TgbT+yWj+PjP34auN0dWw2f1GLQLiE8pAlW042uohYSWhZ6o 6lPyKDjRSDqzXyg3KDBMGgpNOXMm+y5hanmZqmK+dNTTW7M6vtZ4d+jQ5chXEoHzXP0fffZ5Q4FZ m8w/QrxqfFay9YI7uMDOD7R4rtMzJbWaku8k55peydAekhcH439nbSP7k44K0n7o/cq8pgJ0oU8I +TLvmd3RRjRK7cALJ3m81w6YXTBz2X8Zw0kRe+TOEqSzaqmTMbtyu2//04JUQZri3/cPZjsAiHJD m1PFfy0yU1JCVZXQtyn4drj2YzeuNcsOmlAyBsM9Yhu5wfQxQfmdDHzhUMgitCUle3Ms2RBr2Tc0 tDy6w0cdz6SgNU+5tsqsKWSjfXhlPulplJQM19KYdz16uxGf9qN+1Yj66/7r2y7c0nVodxBO1nRM bMSDOe4yJUuBC5ehXH9rt/i/OVnRtm7/MRt/3wb6DyfkR1xmhtbpJVBHYjNVJquSOMg4G5L9DKVz 1j6X5ggdo2kkN3056q4lsH3Ptog/c5GlnBx/1UyUQuN9bZwXHblWKxc2MoChxvTbAIgs8BGZj1b1 8OpSC2rz4mcaCIhnYX14mpHSNiX0PmKzxzyy6ijfZV81XiKPngFQwPk8zJcVlrHlqN3Rr/0PMbAW zZXI+h94xMLT8TG/fJxeZjTOuIAIGKA6cXtaBvgMyFWC1+tJibOwL3Sub+YZlqbtSpzUhlq/4XTV pXOQnq3Vm5APdNd0x/y2NIAmOo3KEy5yjP2G75POpXDhDKQ/8TR+B3EK7H6PYxhYf6/5ae8wPr5+ yUyN1iIFM/n4O8ikiqzvC0/uGYVWHTM/EPXgcZQTr5lpYrKNtv+msjXIq/qrIGxONlfOs8eb3bBI KqQD656U+9tPAh8rYjMkKvMtBqtsIWdYqnh7HU7hklNAaAKlk9ILpgn9MnsWR1Cm40eBOknyRW/w pxaSlFzF2zQ4Z/iiV+Sfzb+dvHWtR5OFAt0mmHPRGOH6ZinBp6KTSlgxsBhJHtzgslmx3NQiNQJx cTqMedgZPzhaoIhPfqvPyoxgehK0iXQk6chrG0ucOiroogpeyajfVkfejRoDsWmEGh4Q2SpG29aA 9Aohp+Wh5xG5Ky1B0MtLhl9IAb18PKQshKFRhybxCqCoX8n0kpQgN3GTxIW2bxPSrGRYBgmTgBva 9ev4Nzk2B5vioun1WwrsGxDs+vrhLds2dnK+lRnXZ6cE9I5ephso1328e3ubYhCF15BKC2CZEDx5 Netm3Q73oUXyl1mczjyDCL42RvOQBj73Dp08saRDS8IH23zlAMi7vnScDhNJw0AvFSBpsx4Qf1b6 96ai3cGO9N67zwZfd5sii5gqqPxgne/5oFDQa9EpfoYBMY4od9nBjLt7UvLqrMEK90uoOjWPFMen +SQ1FL7wJb7aRdfuQVosxo7O9tzAmelSWBjdoK9g3GYk8kE6V1rFPjuSoJ42WE15BA46DQUX8udq fZmSWo4BOyHLtGkr/Ux4viVSA8/SPUiAOZ/KPwTULoWZeKpci1O50avalNwGnKJDE/eL0i1Aoct6 1jXbEO+D1Ti9e76B/mfB1Hqad9gUT/9zmVJlgdEHoPw5ErxfgY2GaGus8cjX3N1qMgjcNwI50Sv+ Gm/lTizkgVBAHQWqnNQYfzTeTu//414aIcdicWhsBWkw5w4je12pPXWPoOyetKhWEjLLxxX0E9si wVSQaORmk47sclNc4ZSUVa+qX+TrpQ7IzZBWckfVi5NUplYA7TF/kYJmsKE3xjNcvDnE/TNrLSub Cw6VTOMRP64rWujDScYteUwKeWQ3o5e7w3x9oaHjVZ3F9EZmJeS8Znc7oerHKKSVEzq5bCMnqLxW ZVJKI2WY3c76llDGi9e/zND194SdaFpWj7lO1ySG0LAUANVSrKD6kuTvzgJXSKF0uNavYr1iPuL5 xJAZ/5gyyc+zSaqFZ++lSI23bdy/J7Tu6T6A7VxdQXNUXPQyIAWhDxfAJIty7OZ1DhymXp8WgQ9s IMcqHu84zXUQmNchWkYx7EeMm5XmYWjeRWs3TJ4T40csGLjGAlZtL2jdu40GGnKsadNP/yJOVmLk 4g2EDQWoIAj8jPiwD1Bf55BMMsqekQE5JWXCj4to3lf5Js65yK23w5+laqLHcsYoY6aVEPaeDPrN hofITbRStG5Zzu6WkCxXGYxMvjsKQh1B5fbHHGL4WPcOqvC1HwybiFxBwPJ1DVgU327G96sg/2g3 B5Ef5jLUIz1gouvZEN7emg6PfPF6Ncn7yPujj4DvW+1c3sk+r/K5B+j7hsr/ISPyq9CedzbTSq66 FzSlPL39BGEDFVBi1n9ANIy4wFTaRDyggRLkJz3bDyXCdF/4PMevLO0wT4uc4YX01b7/iSGePyNX T7EyA56upV4IqJXX34OqDSe76iV7n34t5frtSbPvAym3p6LYcMJgnaEwxm11uRCRMi/HLmdyWQlw MX8+Zg0HFCNfdSgCFvPpFi0jWrGfwU/S+OCa1u8JGrtIR4ct3eGukqBklhHwX72vrexM6Unl5kDM cSNbGStAALjXBj6VmDi1ipWyn8mVDWd7xmhkDqVV0D2RhrZndNB0N5sNolS3RXQubj6RKm3HtzxJ ecE5MflNgAyUGuKwFKCZK226ay7lIN2ByroNm5CGNsIerxEQxw/vf4sCaRrCTehjv/df5ryQKNIi H1GmMr0M6aC1nN/TbG7EP479iINC6CxTH7Uvw1smggA23p+FA5EowN6YF6QKuq1o+UR8YpVL6/kR Ba+upE6BL/YBw29WRkFaufYIN39JUYkn3LdX04UTIgn6crvrc5IJwvK8xsCh1VuFeDUU+9osX4T0 3O59/MtV7WN6YS6NYW8oyQJ6cDtDgwKh+AofgKp+Wzrulue56dGDi5S8QQTTijPnm8eKxL9gbSgw hWfiDt3WiQDrsIYLmgohzTuXGTRANBHmQGNB7wDYCI3zPQfx7r9hN8C+1j7AGrrX1kc9HbQhJaW8 fc4r9/b3y7LjATeHZNgUgiqaLeKR9TlEOx0BpHQXVJitFFO3UsK3HkQHJzoozPeAAIzGLLRccDWE N5O1KhVrpQ+TklATEW9qsLADUj2QQ6F0wmVaOZGyKOaI314N4W/YaFK6MA5yF8Ee1zVFbOmNOYed P/r/niJ/T/W986kNBMQ+54gfMbOSe1H/RW+w10vyqmtsufHTgASmL5lvI0w3n7p212YpK8oK1Jm8 DzPHU7/C6Rvj4e03fv8P0T7a6YOIpfqA9qsAQBf8lhEST/TBsmxwhHWHjRgcpiqZy72RumAPyagU m7BWISXttBaLDp64AWpqYbje5Coo0UIbu3I5si7PHrfbwA9Sl3x1Kc4F6ta3iYHli0Jco0vtw93W 8Oj29UHIQOrw/YXm+PMxvP/lCx0nfKWOL5WEQR9pOd6GrM2h96s7JGlK8rgcYHjS+0PL4qKke54D cJnEww7SkbJa74sCmoRU40E1Nsi5pjJa1I3S83d122/cyNNbw/nfE7KaLzrOEK7yHyANLw7QPOIf lbuno/ymsjyxVgCGiikCs/YfTnWtRq6Bgvy634a+t6tr5bCXJ+GGtCol58SFqxKwnHRQFBFf5NIb Vs1Yr78hrjmiPdx0CV5FRXkMfoWTC7cubZETrryXxm/Vffsfa6rDsrfxvEA3Dkd6FqZDXeqEsCaO eCH1Bnz7ASnb6kajrqL64s7GVxveiJ88sAbrwvGrcnkoFcdTOmjtTtnhINlI+Jup3BtgyzRoSPTN AmFM5qCQUfqrfJU6WccMdV5JOEbWpzHoQEHeCjLDOlT1e+JnxPjNXVNho7UYvUgQvgd2NL/86jUe qcc8qjKmp+Frat5tkUNRBl88rA0dYjGf8GpAAesuxbZR+37va4hyHq4JMsT0fu05+CIBDVzGpRCP 4QCbvz0tIcvs6FnbYbU8iRdabKIitt3BAfKBLJTYBGzuiQ8Q+EpUBCrM+r8xXo1z0iC4OQXa14vt qT2WP/aBc6XxizEjSYA67lEe9P6oMFOW0VcPEPY4L50KAceJ24JpoDCFQz8M5WbXWUqmnTczk99B Zgui397wd2CW/aUIYcjFu+o9dCd4pZUmyElxUQ79fCfCig3Hty62l19JbM1dxz2MI+KzlQzMWo7V USEZw2Nz8LGRFUw8MvgNsUjpz7wHdXLp67cU++Kisjxe5OXy7oty2x0senxnkQuIhXWyOmpRu/I6 tQde0ZEwlMeFvkehUTVv+7h0NV0NwXJ04FjndsQam2E24fJe6r5kAcinhTR2N3v2kzBRCQWSha4C 28Atk9MmZ4ixXOk9UgsuwlK4LuOkuZeNPiMRb/zBUPV2wtsTslxSBwN6lkdU3ffpjSkS9gdGL7cK icV4mE2miFgTIsVGsCMEK3mGePIck1BjR/dVRWd6qTp4ymbLhuy7Oskwb4K7MmBVjqT5XqpHZqgB DH05nGDRdLfqOfej+X7jVKVHpyN/yKswJ1a/Gdp4TjNdErHstdb7NZTpci5EdbIPPyNt0qIeQ2tS na/L76BL3kzcoYfdKwGDYuESGTE8HaxO9hHadwewDgjfN5LAKL9tvHBHewfN/5260XYnUreeneKG htNQZeL7Pf0LFOCZQ74h8LLzcKXLeN6vGaauTtwxGgz4bKLzMv7ES4PBkfspk7idDUuiDwMPkbtO Iz9Al4/96MuEvbYKP+NCVklG/l9O2laG9pfQ4K/uYcMHkCeFwl3t/zAol+Sl2I907mp0vKvwIoXv LS/QO+GWV1DxPMVWLTxhI9buZAzc6PoRnq1qbPSUYzMlW/9tLtZu3ljzuGzxPhTxoKPzpccY5Ls3 kRBPXNRzepV554SVEGX6UgvHAWnhXGuT8JaB1AhFhusSziDFZ+kekK4zTWg0GM3dxuW1QH63dbhN KLllmgZ7O8NfhrCxbUCcu49JQ4ldeULQy4lOMEdZSpOCWmcZEV15ND3GGwBr5cksg68ZS5/RvyrR aWHnowTJbPzTqJJ+rOYbw1NgEjvPZ3b3PUjGlJnpyJAJEdYTp8jolXoXhNNiW6AVojyBAquR34Q5 fJHifb/xsfrrecT61L6185WCmvqO3UgK+mAgUyXEkdSCR6G+KPSe3LSLcDPM9M+xnVzMjBVcf3Ed Tk1p1djALFxPjh488IZQxgGbFUS+1F6kJdaM7G86h64VV6/fZmiLKHgdMhXw3VttR7+eRLdfsbDS OYXHeaUJAd6ZPPktPLm+vJuOzmOkF7a/6DfGb9p+abdaRpNhmU/VfgvOibNds131bxm7cNX5b/Qu KEk0LdVe7+UEvyAGpCWx5MuXmwjjiEaCxgJhVzKG2QQczb+BbJBQUoEOHXHo8X+qyIaFW21P5xKm 2yAn1BPu1HkANXmW90KQ9rNJ1RBTklW/0vW1RAbM9z1aiQ/5tChc8ZeAAGGITLT+JhxlhipMycS9 mZawXhTWwAtAiil8NGkbc1nJSSMQ5ZDGmk99VQBK0XGC4Z/cX1tcH7FReBTfS00Mz9ezJgIIi3ZU xJl9jv2d/UJxC0esDCCLkwhouXEtr15Fy0az/bCW4xgcjj/vPuEYccadTgugKwLmKC0Lq0fDguVn VWdfGsoBcGe84jPs+T0bgdILN1xfwxHu4nKZfFPufhQLgLpi47zfktXUKK0mTLK7plX75/frYjQg kcWmiWuOLaR++bFH7k7Y7dMnHXp5RTmt6nGCuV28BR5fNSzWs1sC9S+sl2mZUqj24JAR9JNhwUds ST3nTXtIp4x4UTnFoI1OxtzdANq7HNAKS3lr60UvX5Ds/oGSNVG63ZtHaVDgX7BQB6XwWjIM33zk 3Wm/YN+wkpuxxAoGxiKLa8/NDmjhJrzPl/Wu9z5IXvleVaZGuEvXjB9Z4vU3W4Pui8otAAiSQfNM 8DBNSItS5weDn67GTAkkp5Hb/LiwA+JgFH12Bl6D2+R+eX60qspV42f16c38IwLDivwTQ4N+xgnb NxF6nSmCW11OvWbWwb8TpzuXiFgGH5dKkUbQvrvnIjJESJm+nRW7o0VaBBF4Vr8hOldc7T9CDWDV QX0ArnR7QbMJvwLgbIMmtx4PUAtaLHxLfyE2TnavKD1cTehhafTkei8VrZaJnyPoaBvvWWGZzILK AhvotwyWzx9aYYHCUYdYxq+atg7mJ7hrnTR9ks66UKAiq+ZkIzYjTMkhlbmuvLmglPTFRU09z3V1 9drdkzzCI8bRjBJWlX1Qmb4L9YQGe41a2OPxzGp9O1x4JY+1iLVgMAYjkWIXCrl2xZ9d15HT3ESM +0004Sq9pHa5P80ug80SuEVlbJ65Kq9KJNivva16vYRiN96CiIwvt3cr/FW+F87C5ouP2pFPXd7N cS7CMUod1mMnOjzlY2kysuSwAgiL986X6OCw8LqA7qL8XM2+c0D+A55hVaI+r4nIucMI4Ps8MKvz QlU7GOQp102CYoYi06srDtf4I9qqPw3D8eGycFJ7r+PIOvWntbNFFVHkPIHnGCsnfuLk/IRTdR1M 2BGPOwZ/5sZOK2SHe+ZGLI984MwMU4PzB6XZnTFvQh3fu8khtJRjKvRr6VTjydg2TWm502X0GnF0 3/Srosg8ZWzhJc+y15RWIr99woGmQTI0hAnYliuMl6qaoLiaDoX04p9u7si2gfHC7kX6bZxzskB/ xvQJbgMX/bgQyn0yl4GFyLwYl//Qs1UybTE5n3d/+SJtKA37oglPNmBDdwZkLo1aUS3utfSzSpRF lzeoTRdz03VMazT0UUWpgA6rqGRyNq/j34kFPnDIf63xuWJPd5vgzN3JiPDDMT/SPLO6Q8i0K6cB LN7DtLJn8MnSlwZPfuXiJYgwAHFtTEf+aGUu+JEiku7t748HKxW/mGmMhyPT0jTYds+0CXpFH8O2 gYYp4qVNa+vJ8Y1aaQIEqGbUIHFNdBCYJJ8mPZbBER1lQqy1dM3o754TbCUvSAclSFhIfLY4xSGp jprRmUjXRWu4Te7WjzZAuOV1SaWitFvz+pyeah/m/KgelFgp5XSOO2nodwEEoAJvyY8l/VYv+IBK 5mgjAr5ks60PHq94bILCIXiu+r7mCQRRNSqkBtP7G6Y8SFOuTGua4HMOn3AU4mqEy43ntLH5UyNk H1vqKy8LMXWR4lwdvkC0E2FVrzrkaY7SOlUy9F2NZge+tOoRK7lgJWyyAIQZHQhTyRoEdqzI3LrZ aJIQhwZCq1rTmicnQe/sJTaaZ6nqFnzhWcsoC63dtUi180Gr++9u4yX9N7gsSzkZp9p4HGpXv2Y+ wiNXqw7iFQGUBd2BkgI+1O3bS2/RN0v4HzDoKorMiTtkYk2xqLG5Wga9m7jfySwm2lJDk5IlkGf7 2m9z5HrrtGXLgKQNejgBuJX0rZkxW1H11piHfr83QEDsg+Rxzu6AiO5A59kFAS51GH8G+pmkOYh1 yi5mrww2O+F42pIiOEOzLjz00eE9q/U9mPWHlhK54imWofqZmdKnR8FhMhgIrO7sq6Gs91jmKAgJ r+2t9hMmkWrFlAs2Tt2AoFN8f+TpaG8rn5kM4a7oQp9BtIQ6ycWPNr8La+lZSWfGIvE1SvJqCydU VV4gxSQR901c8Y+3YuFBi7xFiy1irq8hKNBWIFcbdGVHcIIN/n76d9XmFnJhn136r3N0m+tv+NIQ p0XiVjXPJjv8qUwHLFil4cIQWOvTjeMFyzBP1QtfYVUBSY26TitHeC3Ws92MbAyErQFeGs/td1Uc eUcFZPmY1oA2hmhCaePH4HgUEJq96+9SzoO4JjVfnqqOthlkUYOMG/bG3lcNHTPTawYy77dC1HaR Pa1bLjOkiU+vLibFSvpFRAP2OfeXyQf7whPfqlTRBnIGwISqi5UI2bshC7wibmMksF1/8QAoGd70 9+EXCRcPRDXp5CdQTBNnEb3LYm8X5p16xFhwrmTMKR6mTkWtKD936+77PWHx015q3hioCywePihU nPP8fKKdNx4VtAyLyP6drEo+AlMvmKMUgQ7FFk/I0cqz05I74rh04dbj3YAfyt3U5WeZT5dntQGm 69Z+ZucM1onU6sT2x+3HVfbWc01rlaQikpCPT3eDCswGpUA6cV+3oMo2zdwk/87I64cEuk7x/gmW ohqK08lBhE8ellR07/tf7Gps/bodykdByxxzNvn0mFeRUhyxWCG9flvxi9mngfSet71EKispRXDi 4MECethQVgq91nu8jcsZF7bFcX33ZUTL4puf1EJt3/9nvnL+WYbupk/q2zkh1jvWVwuXA+LM5M51 xecRP4zgvokgIICF20AOEkfnz79MTNgrD1GKeJ+tRclMjJwgbjEUnecUfyvIbycMmf28ZPliVGK5 Txb6oLIEjBVMVn/RxfLfX0S3p811hciy8gQnaPrhE9F6ZCL8TwiNKzmOxs+n/mXzO/I6ZnATIj0x EwURxiIF8/b7nhePC9Q7S+zoX+rnIhefBsLCU8LDeBRQ42XZ3ooNEwMGtjVR31bPCHkIrbTZb+YD HHwddSdHxEVIEILXeGu8o3snB20d1vKLVrDXBrk2ky3SI8xKXSwN5fZJqR0E8VROPm6ecU9ASSot E2hU5n8vBS6hcHpQbxSZvW/kyo0bJFYqI7TEhIOKcbi4E9HlatLTFIWU7fQNlG71NbZM6VO4OV7Q 4B6j9cSxeqPFhAzyMRXnjKOXvoe+JsYMYXzv9nslWRgSpx3HEJg/3sXwYvAYACkuoD5wwdTSoHg5 Xx18ptRgx2S1zeXQK/OMals1q1zFj85cLhi65REWadSIAq20QeozadlstxzSqVfX62qjyc8I6VGZ Lw5MoXLgj3EQlHIjJp9NNTaUtUtU2v79fcLKgq0dtkqinqb7dYe6OrRFojJun1BNUQC82PJzs1+K gWgx8yBYMSI5yOy0o+VE7mMtu2h8fXCM0A+TEwzySbz06AzDtBT+Yij8UBwvXJ69uzsKYhd1uKQS zw+4OH0OGA3yF8LNQ/kmXK7CxFO/K8yV16ywXfJMAa4N7J+54nVQAAy3aJO/FhZRNtT4bR1vP0mM B3KJ6SWdIZMTC8WdA54yV7YvSk3X6gzBv2IR2lHfdRB4GY5985AlFJVkaHGKYyLNfZpdo1A6NHv6 8RHdA/Vh8ZhfjpjKiiar6yInF9TdPQuQRRBnEdlKAqg6XhluuyMgD5ut5udCxmVDqTbMwZqHs/np 4kjaBDXGjKw2LZGWD/g9oOjRB+mF94TF6zbakFiQ6flnEyOSf60isqntv9asAe9ar8J1ddYhdjm3 GrjTmB6aAg2nyFIxUnocw1+Q4NWdJ5xrddWrg7DmepLo39lumVBhB6oHy/Mvg01d/xzsczWGobcB WQoSYcGXmoLEQFgztrxJe+LUz3feKwKJ9Nw31kbk70WMSoGiKdTeXu1nmXoRJNm/HbaZwPaZMHDC wPd9FPXGIsSp7b89qDW+Dy9N2yBjeQjR4bY47ogkpl40ZNNPbjN2o92nY4DhW6rNcmtTTAmlYB4w dT9Bl0f0PJNKQExf8RAQGM3njzC3efMnTVMClFAI+vYovUXP2xE67nyalYow4MeMAmvHD8h+eA1R GmgUT9P4kxDOHH7L1CnoPuFnODtKYNjGqa184SJsoobOfFLwH6Kv348qJH3tpM3l34OZBuXT+EBY aXvzz4L9x/3NcflHD0MnWdQsAjkftSBvu5vG4T3G6fwLfAameXv4blmTlDaT9gqqUg17QuYzV/fl dWfHDGBcmI/Iby9Gc1lw0y8FeGuhtndyihm8/alH9Rc2A/bF40zBNGNgI/T81OGujayDt8ACNE+g Yt5aajVQycayt4DoQqXq7AOsSWi/RLx5EwALtNbuekFxlHENJdUraDFgRTSm1BhPBo83yduzgU4z xzEVwmmXQChg3d1PZH6t+rSqP5yrhIyNItSzEKEaaVjWOpx3RJXxTUHttfjC5JvlKklAAb5X0dIF 3MJLjJOvK/ILTQ5SNCv1XKGn3nXceRR21W84NX4oRkpzsM5jo7xJTk9thCqwHFo0q3U8ioEgn8/d K+7d3RM2dyN2JbUClpiARs/HmyL27XVJ7Ylc4IzGIYEvPdvpevkNMD6cD0EyM6prL4tkkBwbnq06 2pldcxGZYsOuz4Y/Gvwkdk9K84uHjwrnlNy7b+0th2ZWZUrpKVqEBlTadb3u8MQZbHhCdep1MobG kuWO9kIjCSm+FxcX4U4xCf02TDUWTJbF/kZpZ67mjucPLDxcUrchgWGI/y6a8hp0TddZK1C54Y86 IRtYflXekWcxKzQxwzF491Z7cQbicrj/oWuj4yLaOxIBi+p7G4ralBhw5Eq0OelCvs5ZXZ3jVKqv 5LMe8saG3PNJg2lBuEV26nS448Ew9Fju9UJ/uvigmJAW2PPJjLxguu6H+MT1lIk7hF///b1/vZ0a UvEEOsts6gJBbjHWsIIzcuC7tLpU5mSBpY476ylGt6iywMRq/CCXuLYS1/MBEN5nBs/NV/07BhCl TBH/uMqmyGjCAsqLhz4PgTkmqlIOsVfJshfxahhxj3WjzHTsBhGajt/+fP72pgUFZoolmvHiMTxO Wvf+WryFONVQVvEXBCkdRcQKTw/iH6cq3h9JiDrqJqOJxpD+WvHJqbip8a8oanrLKzVy+AHtOKlV gHnxAZEqsV4OH2Un1uhUV8bscgZvDOS5rOYxUp6lHQOUYlZ0tLpNN4qfxblD9Rn827trI9buoN+X rA1potOyZ9Lm14oQQafZzGzbg6j0FZiEcGxqMK/roBuCAWmTnnGBJqVvTiery3XZt1zKLozRKCG7 SKqteXNlciWDsp5EX3qEuoJuPb7YsqnXu4PT0ak1gwT5nqP6ctfQyUfPJpA0cYXbL7MxVI1EOcCn 9YdXN960kteEPic4OzJv2XzJo6KlB8lyXZfq6Gz2Nv3pjdCK5znoCDhVmWWyLA9lVHSd1Kivx45Q vloKZTYnm3Zur3l0NOSZUICCJNBTHWoFU+v+Gp21Vnct88/nEgNqgNPBevW+jNAZRJQFRpcAu8AG pTFy4PnKIJsQ9aSEwwU0xkhi8SOFgicJSf7WdkWEwm2xEP08FbBYzIm9vpqxsMyKJod6uAzHQJyB XF/XlWPolRUQWj6kDKasn1cF6FDn0pqdKGUPWXkmVSSCj1PCKDHwzMD8w0CL55LKnsgCKVTuFgFQ OsI6vtpW0XWbR5iO8OHAsNaGm9lf3AHUtHUZQz4QHgfExpiWROLADbLk/T2vS+IrTMRZdE4y8edy lr2AhAcUt1dVkzsvDRPyKKmmERNyTFHgfDS/NwEoaIhsYT9Qk54+LLpczs1tIKs4u4rEWOfB34ZD YFiZ6cfb2winZNOI/SLTRRHulXZTeCVoaqnVzFjvTVKB3bdmROaw5JQ6C64wG91K3ixneKAt8Xez tluojM3Ny6diZfN3zDPIThGRqY1SfFvaAPUeTa3V0JZ7RnGswJ/soQq2uIT5ZW2j1Yh7vbguWXD1 YQowHgCf0yKAdJ/NPMtOvp0nreA5fRsiCZCrxsHKn9xAruqHTjvnW878llbuKUGPtk56mN2xgaQa /yl2x7jA9F7nVCmQQpCeTdQxmzI7G7GVmShwb6hbJTgRdO13ht8/za84XuhQiHHxSC8y6NNAB+Zt cyjtTi1cCKJEi8zHxkr2DUlxIBnrsIvZFUbsAYuZzCSugPahr2RDlRBxcDgCE6/+kiTcMOlh97x6 IO129yyBV2UyBEq9ZR8j32W9VMafEGQZNBqfSv74jjO7TIx8TvHp441EKXLMIugoa+li9NyGWOMO SSXxPVbWL42u9ESL4eOpgA2PD0AYS5znVXAer++Cg7ytvz5t7BCPwooY94xpj4I/1UrKe0/614VI ssXXyGL1HbVc9yRtObTRFyPddiyQEnT5ZZPGNuRbBDFfU2yC/1PZie058mySVNvehkG9MepN2Bc6 LFYWqjBBrHpUL6QZ+N9rE/xFQ7mQk7+qq/fMFdUxztVXU2BgTzgsW+PSgxcnPRUNNVlkipLKcWqF fIgmsWSPNA6huRPwb8DC5QrPiBrjx30Kc04k4ybHUCj+u78hx4m+24UJGKVztPlTIiQBtKgTD2jc CwuhGPCAwNSxCuYp+p+S9ifiRnEwtcRX0l8A8291cioFRVd5UB1Zt0lj7UHlAyGpJd0hv/wk9sy7 muAdQ+YwIHMMocCvt6uhelwFnrIbIfJhc6q0qASjC2sRSFureS6vXcIvypnV4ZyVp1iY2m1kGBnW wbEbf5JTIQYqZWdiMZYeTfj3cpP+b3TvIfolQYx2IhzTTWf/gPlommdf2r7czqH+ONzc1MM3s46o C5JPdyM+ovMsT7WaCXUYgqMa1Y27l4+SwxcioZ2r5YMNMYSg/+F8dlIhJDM1ym0AP+eylFXz/s/X 7ZMUlv7NL0zXahycSD9sqxyu+hW3nrLk0BVagCetYefUxoQ7H6f6+s+EPJv6D5aP/pwhKIwTWjRY 7nYJELVggmlFqj1q+85rIwKg7BEEuq/9pSrtlQZy5Tm/zxjev7jpe6HgwsvrXXiefpBYhPCJ1s/R cZ/n9kyzPS4okcWOA/hIkfnYAZ793OSQIwJrBO+beMs/iwj1fcPAZda/PgIMW+uxY4cdVoc2Cb7M zB3GdzZtPlQRRYAnpr/lOrILrxFbzVlhEadrdaysuOEBlKbBjOhp899CYMBB2WkOrCwMNGSv56Wz 9Ulug7rio6ZQ/zN/TF8i86pqWC1S29xwV6gztlZn9IAfF+lKmi3Iwi0GbOvnrPW181oi50CjbHP+ scTWM8BOwXhJjzNMc7kKHK/3sVb9aYPLZHU1k0m1+zPF/AdskjJ14HDSg2af5MFZFQih2JaFQ2x6 FCRS6Gulf7KTpT4Qkvph6ihA8Q2GRkco4RJv1H9jd9GHtbx/1uR6cHC5EPHzEkpW/4yvJjmLcAFB /6PqrHAbIsb3vkpX6NtxQfuCeVT77Hx77SOYAiEYKDK+0z06/R6u3bUncSoTGPqkVjnmV8aAjaTR y7OxX2zf7WhY1HL1CjhYll7jSQs0eUZRU7eTHTSR8w4egfBCOehzT87BRvLWlDbhBSxp/IElbarO QWKWGx7WRLHNkyyyZgPHD9CAy9Yua00eV/FViLdV8gkwSeW/F7N+nQRU35T18jZXCME0T1Onm5xf zadcr+ztWgRMzbsUrCAYvdlpP/BQmvT71FiJjoWRUR5nMfuUwWDRQvLOdPIRAo48ok5BPLln1v75 gHupAkr0tcVKu9NLg1nROStRTbofFtTejSPOHJIzl4Aq2BHYBZku/8xq3HFavyQrjIjdZeFvOOWS 98oyuil+ZwAhEMqvnVT677g0j8yhXsj0uOa5wkfswpja19eGjwvB26yv5Dw3KxK+DJ97cd6RVVe+ qrbAv17SD5cdBauirzzzzW5O10BtIguemO/aGOAWMC18y9sClNUKmglN3cQVK5eGDzPFB5zHbZ6o lf0uCNhz44nWbgJU5jT6Yfwo5eD0xd4vHpe90O3ghHwtFvaqxO12oiRETdnAsM4m877GMQN/HYbC iWtVD3QWBPYcOMGg+ygM82UUJSq3Yu5audQPRnYFB2i2Rt/x5sPsJQcLAB1SIRE79sfY3k3Rvphd fItoZ/Wg8eLmZ5yfThCBcqoUmO/SRXVcvGg17+EssmqysCvFOLQ5oOiGAtRhEc2OeuQ6jUB+i6mb ChRdBMXWhPDdZCMKmOEm9qryVMlzj2d4n2zqLGOdPgBgoaGRA2mxxVotAacCAwydAks8gVMiWbWX ZeHV9CQpaZXEMhVHVJCPwPPiUFlT3J5hZzgu18tluk1yP9kuI0xwlB8zBZafLXFqDtxIDTK631Ez yV25BkNZowSj726dslYgyoAPhEqR9xnq+iv3/7Lj7IJGS5UIJx7z0V0IJVfIPN4ZdxzxHyqhTAZD Su9bF0EBzbfePRqRX3W9yYJRgblQBH7OWKQ6bY2g6wsENwEPQQrRXa3ev5YrNsB+VHH9A0rjKU1o o1JaT7j001X4J7y5fQYdVZYQNOr9yOHsK2/nKUcTwHBGMHRh6wPKdmH6mv/xC0Wo6AntKQEPQDDz eQ5y10NIPfpb/nvNshCOhd+orAH6t+AChLElQGI/dF8Osa9bX7Wc/nmHvAz8kmzd1sgFtoQKlVzK Zy+Imw02BTeTw2T/4odn0Sd6XeqvhYMRiWocABACXLkqI8EGuCGotC+GhoQDhbZGd2DJ3lItlAYA jTSfVgdODtg4kwQ3T8s77MuAXgX+UrYtKVlEeNkGFBVpk++PMzZQAo2C+R99FxsuB7dwVVJF+xFj BHstazMOTJKYxaz9YUGl3yvzVfHH/rX4rizP299PU9Xc5sVVnHJOuhWAFoEt4u2LUJMATrE8PZAA 5FTG60/iAHzQ2WYDpGpB9t1QVoY211M9EkFy7fwRxJrlyK9Ee+n6tE7u4igVQj+ts4X7RX632Bxm wqrU+Z/V5B5oB8pbuCRzrJ5OLr8NXIfh87xzSDigNeFwVEK0oU/xIIpzdVUp3ww2/dkjdQ9R/zaC xz2zL0VuqJ3Bj+50lnB7GyNdW/4Cmj7348q6WP4hyJFHVvlg+FTQ17VBMkTK4RklyGUK/N2qCi33 5mvYMRfpLJh14cFGTADZLFYpSD1Dxii9HOvULx49HRpc7mq2iU7ZkyBlIRpBqQT5HyEvI5YGoDLS TiMKQ/j3b7tdcnayZQ7RoF1czr27/xvVNRNaN3IXbaklVAneQBl2ZPrYMalos2ErftXAD9FK7cn5 0Low6mqCsOU739msuy4/2fdtykKYegpQWYKbfVE0lDcFtvW+SOPNaGzB4CQhuti4gFcvwT5SgmEN ioDwEtlL3qIglNbVQo8c20/vf/wxzyTjvRN4W8O3XKkFxi4gtXC7mjPNAZv11Ioa5fDH/zY46Mnk a1oSuJHgGHU+0Un2QThKXtzmrUXCLTAV3xMl5XT1n8nsQmfT0fWQxq7i7amTel4ATyGKb/poFASH 1qw7TDXUQ0BrGlK2HYf4e8FxRt5EWXPXzHNMAlLAzLoZDcdAFmpW3xW27sj0PF++tcy6TLrElcX5 HjLAFKBQ/YbZnRer/YBd+KqZE/vHKQL5s/A+y6/H7l6pqUkSgzHnqDNfDk4DAW/t3elrHbPpJ8JO uvCO5JYDwAiyyokTfWCu4lbgMk7/79xEM506oAWWrXlEHusf8wcF5yGzIFLguQnFXbJFYPizBoiL lzJwHXZ+GFe548HIDEZy9zV0KXddCok48w1/VFKylQoSuPY71vXu6+8HP0a3jzXsqaQBtI+OYODW KoqlMExVpAYa/XyPo3mj5bR/0YOYIBu3qEIeXA29yoitnsxDNU3RnqlbY/ZEC/M2mwNz4UK+418M Wk2Dyp628jMovOZwHJk67oatTxV/k2X3sLj38VFf7EWRNC6bQf3Rjlvp6YK0jRiLC12nlvk1B9gb nPB7QmWbGQfFMWx5/qRCReO1NS2e3NKpULtXuDYtNV8dVhBnIZv5ZRqG/GcceGMBbd4zTwv1YsAz FnXlVn81QmZG0xWyb6kmz6wQogOFj/fXENSezJ/7vLQNfuzzjPA9UV0We8nCU8ARYzc+VnJ71J3m UIZJy5KWa2Bkdlo4fnj6eRl5akkIVo+SZfb6X4RoWaPXawekjBkvKPgdnRaLttZKAlga0mqozaDM N3EdAP7dLajj2GiEQU2SbqwvAMqXf3CTlQntRGUuY03VXPWGb+wbd7+5DoXvVhwx04tYJCoR6FOu k2ek+8OmZg+962OeQgM4aH4SP2Nsx393shyU88XNcAT5fdd/TMeQv6P7ABX9l1HhILeELosS54ll h+NMFn6u7A3V0Ftke+Jyhbn7FGYt1JgfdB0/VKf+sMa16v57JOtYQaoROVPiOPukktyqPYHcN0la MEvXbwexU9afMIUpqOsfLPmxVgRPUXqoV8CxbCp0cJw2ax6nNbsRFVa6+amfdxGmCGWFMhE1Oe6X p8nEVmueE3RR1WFx3g32dAjzOdoLFePFZb49nwpdewyIr3bWSxalw521a/W8XLR72ImqU0+DYcGu WkNVGZRxJi8mQjt6gDJ3VbzDXgPr4H4CnafWgdPFRhwz0kBvthWXX3iZk6OmyP6vhpTDK27LrRDD WzIAhxz8pBNurH5uUouVhyAvAoBVxvbVW0FM/Zdx4daBLoqYo0Zz58sKI1CMSDjRmrnPJCWIb60V cYSWqqujo/IYgZ7j7/588fqZ9is2m8IUQxZrkPksEglEvT3tcLiaInhre67KumAolYUFcFbRRirj AlLGXBuDaqBuN60u21vj0fD0qi7hkbKiNJKS5z05mWro8q+gakOBxRPbnFmmkL+IK89Wy4agC8QG C4gc+hnCDvf//tGtrwLRCtangzqEkNlfuFSrZ5EyBTh7Uf/m/jGgknJYP7NHTmdm6PIvMUkPhG/q 33Q19UXNOaQohGYJKj+l02sDkx4lQVNfCUebeu23CprBFJiciXDXhVllVwnLupEpMyWhRwud5lyR fp8zj3P1C1vMkVbufxMf9SV60m8R44Eb/KabDO4D55MI9RKrqy4lREA+RhzSDjclZAY0GwT/uJvS RYK2cUeG06qmZOzHDVYitxf6ZP/9wpJ6fG7GnoStJShymmo/WDWdB5sxIs53/WknAnwE+p0QCPII nam1NIfm4Q43ZoefaHu5R+YY96KtBD0oPeE4CdNoCwTL/4BevNG6xLI9O2xtK9mNUc291i93cNLu aRvjQzSw4yOLRmql50Z3Ohf1mJRNQtyTtKfzXBnXzDW9j8Kv6H7K8o8xCKt8v9bF8azSuXm7FY4N eDNPrQOtYDdqO6kd2881Kg66zJ5S6Bsa9aUUIm8OgEaqwvafKK3YanH2Xu26ShgqYDWOHlk4gaVr PPirbsyBYnjbtqlruTkznE4woiwssTSrgedIEe0SQOSRPjn49TiGtw8qOEvWb5n4OkaSRRAlRFoI Wsr5LlA+WLouzGCAh13xigSGpSM4728zXW+uEvuZoazeI9JOO9pvb+rGZw3ds4M11CmbThveqwyu hwlQIShldcuSzCVn7AP2sbWpXMxZXqGHIYkk4Cjrl7Cod7RlA9R3gGH10NFimXo75VkfdAfhuQSv sBj9YNVpiKhqIzakU/NkLMjN2M9erd5mc0LZy74+INhMNEgRcliUu0am0X7Lxo0EtHeFYoWRcsHL JnDI47vgQfSNfP69N+zYes8g+KL5KOstuCLpDiCsUhDj0NBTb0I++EolAyVlmBJkRyTSTWXDzbC4 GtDQHXiNTN/Gw7qs0cHuxgs/uYDrRXICiDNqk17d2llF4t1OwNePLfXhbguNTUB9SQ1GVGbOJ/kS A3QVJiFsaCCzhORJuoYgoKlGXs9DaKoF+IU1UjGly+os9ybX/PU72jzy87VvMaMFiC7exbEY935n TpC8E0mb2ZhknkDGQFiK/Uvt1ED2O2Q8Mz+7wFBZM4RAkyI/g90vSiOwMGTWvQgb4kiP5iMt7woW 4071R6vhEzJCIHfAL5N95DVCdOyY1naEEohubve0j5BjP301re5BXVO5I5Pqgb83KV+Dhz+XZbY1 KIgBCyo+viDqjIqltn3CAejrSTKiVZGihCik7BrWDgbrWzghSTHFtwuC04kzimbCp4NAIrcA9zSG 4iQihjQF9QDGUXEUSsy/66/aHMtbgJdIwrSVdtJ7aK6Q8tS/1ev+tIsncWnhj3MsY39dN4xi/52C NCssJ9Out65llvMeMyWKBTCzGO8ZHzgJMHHuCwCklIxSKcEdDozwLk/budVPysFPm0uDRYHXBjWM Pkj3v9Eit3eWxUSvZpZlpQqQs97Sf6IGQwhnsovjULARdrOWO2vbG8JHcGDhBFdCSUgCRF1YRp5N Ngi3SfWVeI+fpROsck1LScAg4nVkdnTjXs1KiPgFrigZ4MtdTTHUG5DoOxdyao35ZOP+WatjY2uL rY8hV8T8I71qfoeG9p4PQnPpBGScXfqeaA9dqVVv6HIeVXpahH6vfM9VFSZvXN4xzm/TLhIVXOpE 6eyD7yEToZKu/zgPuwJeLdvhTqiQF3b3Qab8CyoMIRhtvqAR4wI9Yl8S0j8+0fU6GHcdqd5CUNih YBWfapY3IMPHZD1AZeOPyUi70/9pO5oocV3kJRkd4E/AUodNDUt5zdBkVAMcnhHKC33rKiiAB7C6 SNKkvBPrSjMgT81dGIqCKvxWq78q0o92EBFGt6fbG8UCtV5Lye7Tt2WHuy07CV3vvqhiq+YKeVCm 2dyyWG4G6/+qzlcF8D7Nx001cOQD2paWdWcrqXUgmCTgUkw+Bnwm8JX142ZwHLbMl9POXbWbmG8H H3AOr2btNPeptVjUnmsqnDbispCR/n07HioAWotkvbGFtR0zEk9F19tBIkn23hd+eUFqATRGwc33 ZjHGlmIw2Lhq2qlw6VsxRyTC1nftZ+meRD/sUX0RhowXeZflCT5jbz8bCl4haK505FZNJUvJFYtn Cm7EZ1EaT442c3nN6TL6Pna51FI8WTp3RZcExPTjwAMl0xcyQtWxkoui016gXah4soFLPSb+gS1m BbfUf5wXk1gERS/seVEgXPkuqVdOIeAQzpAUjKQHonz7RXgOz1PRb9ih+eh09WvuUVybmzreh3eT UatfDj41E4PAY9I/YhdUKsYbdMMTJWl6OHWcfLp6n+rM80gSmoqcUNdkqHgLuN3/0xkDo39DBscy 7h4wUz/s/ttzeKZ4Uhv2caYeNeveFX4Mk2RTh3zQ7sKS0EPEbXfoYNxfmOXB8jARIStWOox3FGKm orlg8WW7j2BEPAZAq8RC7gsEdfusoKuDXSSGoErLKT8e4rsx/kW8VdrlZTa8V8jx8DcJKIky8kDQ VCgfEG/b0l/yU2pWXXohWGJn3APgdLKcBErcVANZj1Rww/a2FrlF+6wkzV7/QfbtzGs/jJqbj9On 5NdH+S+jbgIhJaejuFo0socq4e8do0IfryU56ici75QpxVJDpI2jG4C7y3wbo6STcOqDxaFfA64v ByPxZyW1XqgEYvqb8/+oNqebfu62+XDd9J2mIBlh0n/1pZh/6MN2BfMgxKWivBfbMloF+mdT1kLX fX0H1epJhiAi5SjW+iksbM+K8It2VrSX9quGuxEiZzTV0qNV+zbfDtT04qRA5YjyrbGtVKT+u9N5 8wM99be5fe48hUr/M5TuNVatzuO98UtK4l7ughzzGW7kPVBXGjPM/aUzljoCBOwMA59bE39VpsDW 83mZIMyj/rCQX1P90pCZcgM0hlJcZWrMsjxwCKjE/giQatzdLGhPfzIQ30dszRFGj7PElpUTE2A9 sJZDY+ooDR5UbRrcfnMwTJy3ofauqkZS4hUIvVgAenQ59dnJHlUttNM5vTwIWuawPTuHlvXVBdb0 UzVyiST711XcXF+Iud9DAuSLkIYFrufwRnqsCtjCQuuI4ajJPpevC1V2ZFcM1A7JBGO7LLMH6dRW 17nFhN3Va9lOxcykE9I8MSqpGW0Jsweviw0Y9jiLniU7K4hlYHEzLtKbT0hBVzJewMaQBxOLCZeW Hy5ryuUQiHbqVXnqUyCz9wSXAmHhQ/YeYfBAeWl5bjBA6kyUpDdWTcZWVD5E8qJKZSNMGTjgadlq 7CJribu/kOEK3kKvPLHfY0Mh8bbqI/Swc3Ne4aqWIIjHB3NQyBE8Jieh/feqbElElhtyKAce6tJU 9OT8vdmuXvZRha/PNEtkPceO6jtMe4jcjA1J1E4JC3htF/bmRTTJvEmvEXvF3rLXqDYTN3F6piXa LPDzn+nGi0z1+KAtFRuGiLHh89J8TyDZZJdbvhMO51YTrDxD0OvAX1mrpYA4UduYIK7aOrb35DCI Lx9GhWZ0FxCREads4nGRuzOnX0d4+YmO5ydtN/Q4ReEQVjPdyO0R48VhaomYHCdRYEu4ztVbs0Na nPnzOVWMUBEQWrQhRALmfx5N6AwMTdIR+GcRHS6UmZmuC3dv+p78xVVdtZI6nS/2rSYSECCl7s4g ufbDKHWNgKKqCF+WDfnS/H8uzbRU71ytnvx+U+EyAhBrIHUk4A5sGh36ymzEg7UUXNk751YwiPLY uqEzclssM2BcVirEXm0b9vTxHAkSB+36EfhDxpAgD7jRjwqm8ui/OfQB9Zk4hJO6dJnjssOrY5F1 vCEXWnPA+zAwRfpLZzXuVd/V0VbQ34P1sMAJMkdriwQX+GLLzHCstlP+ogDAMCg4ZGzeZjCDlZlz PLG7rHtibvUIT2hga0DPvFF8Bbg2MJAhATuDNYdRh6KXFWcDP7GTHUTM0SR/pWooFmUb67zH0Axx tBd3lRipHe/7gxK/h7b3hA2/DDzcu0T9eGcwnifiNa7CqZmsA6U9dFdQUSInza0faC+mZpSdivbr BnNQgrRCKLJNwhoOUSwPsfPXLkqVUmQwzKlHmKNqJH3jzHkK6XNJrKrKExf8u5BXJFNQEtcS6zfR HpAn/fZOKH+hsG8JrxbMU0lpOotlJzKBMa76kPVcAMJ4XEM3Q3US6Zry9PmqMnGjhQ7qkbvXNO52 dCbbjctCbXUmpqj4crU79x/0uUpt8rN5/Ya21DwI+QDJDQ5P/PYRxydiPh1iVe2PDF7hXpo0rPsp mcjtLuTL/0DpW8k5zeycJMIkXwxj5RPfQEQgUlKDEZkD3mK+Rxgem2We8AczlnnvELOGZAtybsUy yoI686yn7ZcG3S8A62hcam0RzIsspbuC6e4Y1quY9K/Pc8Z/rGSb9zli+aZPVPh9gBtJUhXe70zE uD39sQVpY+QVtDk/9I1qyqODYO1vVgmpTE7Xl239w9fPyD1iiU2fp+ceqkfDOFAAMamvZ2ZaAWl/ hqlnZPbiwQCq0BcBgyIq9yfm9DLkr/2zPDFm272QAEt9vLpIGFmm/FrkGQxJOOO8oZIBO2e/JXRP kRH3J4nuSc1C/N/sIYHGbzGlUvM2s5h3WKC3N7Mjl/JZ8BttFUfPdH2tbCPwA1rIuoOXOk8fRQL0 R1NqSbacW2HOCE15i2nbCrB9ZaYFlici8fHyBGD5trKiPOhB7XXHLSJZZ4s0PZNn6WKe4A/z0Er2 V6tQJ9ZbypVxPaEy2zshSYvYFzDPkJDTHmfPFfVuVNtN1+f1Rp5DWhqJ14dgccfiVW+WcQPgi1VE eQgWpQCR0cBjVwxkyex0YNtQgyC5fBjv4WIUd88vlYRJc7D44toKkzNbNrwONQVcC1IVUN5uNhdR FCU1hZMXHJMuw7L7Xq6sR2myEvL2KQDW7APUTnKGSkTle38O/XPqf4Gv0cXsIAJ4dtYuOmBjGqo0 DlW8mARfvYWctNaP/ja+zBCJxoom9LcrIaVyyFLaA/YNjZPSd3JVnfs5/YnGVl1MqXl9jiVa0XSO i2+9izLL5HFoKyJwmHxQrJWcojXLGCbExvkrltJTtaRu2zv4XnY8F5dIjjxNGD3YTIzmIaE+7sZI WZOK4DLp8+mgl3esKExTBZtU7eQBqUu0+AIe6RJunIsjDI8hiVScQZ+57lkPgVWYxyiYKlXJtKM9 x1S1SLRzWSVZ/chE2o7Im/XgWUEmCefQI2i/+tA3XE66RsLC/OaFzDUXPaidm7rcarn9yZctYpzj 4A4vfHg5+l7gNzg/AggmZgTkyrVYBXgXxUV3wzX1xOB7pXvSkJrF7W2HGF/JLUmtK0s9ePYzpFCW BY8ABMqLNhXDg0w+JBZBSPlCrJSi35Aauu3IoZ0cZuH3JW1zylYw09MMs4GQL8r1Ve0RYiWZ96mb UApnIQ4D00ureonk+Meu1RdpozRpl75w/h7krxRI0l26NwWvnHifRcYktfj8qemxmu9UVxw1AUPx uTWGfpgbFv6ESLBrBE3W86yHk8V1EdFFeEX5ZZO94Fz9PVOP/fgZ9xe9pFGzCqdvD4ygHfIaY5hN DP8pvkMj86y6CkNzDXX/skypF+LOoFu6AYrIxAFdIyqvMXFR5BLZ8lg+PEnO6jETP/YROlfyEAOZ Jp0PHPunFShL7ujvjK2QDf4KLQwKQNBLlllGx4omfaBeDrhmajmHSGXlP83ItYedt+Xdt8729zr8 Lyo0PJlvBVqaXM2wDdfdzZ8jDjesBq0etHwojwGR1kR8z3xOCCBbUBsZWGjPjyQbZLotL7iA6fde YKNw+864YB008kY1IBKG3klb8ZGx04ozyV8piuZR0rrxrt8s0afzQHdSDdO1JTK6DjgS3i27xKPT rvCRRhR+EoeTtHWnkYL0zeopKOz1RfHPez0Hf7uXgLI9ah84Kb9/Nq/bzuR9l4oed1gSG6hYJg+n V9FCowMLi0Lco+NDip6zqpt7haxUD9b8kSmj25MZjKKw+ti4aXzqVSSm3KK+nRrH4Pr3+rCTblZ4 pl4/ExxM7/SrzPUgdBl6BCJM0pedz84QfSqvu0VXAbVAjHtg0ScUkpKsMD1Vz1J3sy79fVdwVngt 066iG/HYINbjAhgQnnPi6V6X8qViX8PuO/xnjrk/49lrbtSBy3HOUzfMABAwJPojJ/CTGlcvuCp1 /jwztYvTXnOIwnhiOnNkqVCLBah/7WKsgMXYLViRdzriwuuf7vyCFMPopPRUFbTDPOQtGST3N/oA 3gTuiD4sO/bhPdeEJ21DBq5Hr20MFMv2VMb6Q1obs0mSj4tgHr6qefgbBunlT0FUtP60cQItKTDm SXNAUN74B48Wyw3xum7dIeGrDqyZNvW2oTbHx0yCUjxAN7Z9DP71whytoVush/tyf7r+asI+iXnD U7IIjFcUYV7jkZSscSjyObyldoRYdma8FkvvyEGRoE7P/oWgQkIRTwq6Du2LgybTPJNgMzpZssbT N8zVmsUfKIlmlqiPwZdcmUiYqyvAY012IX12HBqlJ2deR5WUGLz8rJHNzlDtmXg+ABs/ycir+C7w GjgZaZ904II9Kivk/sci+oXrCcMx+x7KwjgFMd/MWTiv6JV60DUSCUXqzQogXs74z5CyXlkuyZ71 CloPx2cSWYIqViM7zv7M1IgrMxLMAuK3nuYHz82k4hs5erK8vLigFVrqXU0uikscgeFd9Ii2cWZZ snim+ruyHpUYwweW7qtIzPp1jhzQV1/joQPcHy348xRb/ugkkm+Q+jgUKvXIcO3L3r/+j27UQDG8 lGx7S3t+Bpx3YOxfWsHbGswam8IjvoRomgbMXrhBzs99uHzhFI/zuqlHM2bzbm38jAb2cDw4C97p T/Fwhy9w6mQQOkEvXGwaosb8DRlKAH/XcY9P2uSQckm2b7flhHtawXcGmyBv0+76nAeJOFJ3GF7L Ao9fbncQkr6qcKJbnpOuOOzvB9NIkMkpxr6Mdy6LBNEQ/PKlPPCd+KcxNEwgwWGEd80fZa4qB7Zn L01F/kmwCg0P6yt03BCxSdsaeXlHBYIADfblxonPpkO1sc2tS7b4M8jSWqqZIE3rE0Kq6swFdqlS MfxFdA6goHuBzCJja4NMAz+KutVeT4RqNETlNVDGq4MyQSduQNr6/gHJeLTPF1IER5cBaVQkrD/u mkAUEKJZTQ1s891sfBFRjihlqBaXki3Y8PzWbDbJJwhxiDF6yNCJ7s43qWTqjj8YEKmfkdErroYG 9TBK6lhG9HD5TgpCFke7qTKHp6AvPnC/ad1HKM8rZzWiqLlQ/ySYU2cQeCuPptmu6pMijMl7Xnoo 78JsSH4gD9E5HOaNshVGUFcAnjasctK/YQAY2khUMiIQgxdTLG7vv1+8q0zYuLB5giBXAodfoni4 sY0ZHfBnD7aoYJiOIG6tm+n/5UX+akuOybGN9eoOUA1KaosNbX/HqblAwTW6siWeec/fdHivwet1 KWWECr3J8x9esL97RMc/5R9ZOPuoVf3oTVI7TdBQRy+psa+k2+6yq3F9Qgx3zEVfQigRmtt7Dptm 9D9deIYRJCIPl5y59af0EygO9WH9o8A+kvWoTNjXZDJmDP0E07QFhiLKf+But21ncS0m0dS31q5D iqSZsEUH2fETVT7i6SY68wkDu60bjUUQSpXFHA0sGCyQB2yn/eAYL/4iDtjk2gdcquKWcAbdthWz 5E4G2dXB4cfX8onIqy+ysaAq9hHq9G00X0lQTUl8oNuVdK9dMoggXrus11JI25CkI9KnI1cvQwWq 07ICxGgvWZg0MLeE47cYUvS8sM60e+VsMX92byYR1dTd9J8ZceYKFI4CLF49swVY19umvvZnpp+B dudzItKULBndBmZa7sAML2mp8O3TyZOH0Xvcb4ylVHBUjjwN2VswNlP0rVfMRr7jIulqo0jR1DC+ hcqnXDBurGn1TOkkWcLmm4eJe2il5Onp2eulAKNUZpAqrjT/iTM/NbMo5JqgGN74DDM//dvar/cE sEMrLWlXt5uZHgat+IIQWd15d0ZTOOWo1cslnx8FsbsufdF6fKHEn/dIGYjsfDkd19YHdI8bOmUP 1H+Ne8kxBML+J6rZ86spyPvuKhnhzMERi51AH7pdkhUIJAjMB0nMn4SzZGPzBca62bMmrZPOem49 9J41SZBch9+ygu7JCltNE93IVjkgsOYq4X6WSOP1yuQBOzQiUr++hScHdPg9d6rSwpIUlLv0RzKL Goku79V93OibTAk3dgOAt43HFxhfeQtLJauNS5ZMopC6eizX0LUgsJbN7cs1YQL8AQLW2qtkchMy ZHka1wHtZETlNc4z32HOxA51RGl6mYbT5PzqZM77nFmVE//Suf1kXKuzm5QrRHsTSSgJLm/GkNbi G2Tkq4TFweJTvnm/pVsE8/NUtEmx8SfvlgcfCHp17SSZZo11W8+uqmV5xQp++RjIiCSJJcDcdOig cyg1FZ5Kr7eDHac4CAO4Lja/wUJ0f+gPPmNUO5vY+bu4KFe5UjtJJ3gDD8SuMywa0MjFJ0cVbD9p S8EvvgFFVDQQZEv/sqIm391bcO34I+6WY1sctbjFokfXDt8XOvIG/YrQlOp+iILt3RMhnd0jM+K3 23fhaiJDQSVv1+tExo0LNrAta9975EFk1fyWgfI+ddBaVT2DKWZaeJptdtxI4yZqH8nH2mcr73a3 n+W46L3vXtro3Zj4Ek8F5RLVuPc+KXEt7BVKG82i5o+3VaYyC0WlW2nTxLn1jQOTMLDgtllXBG6M 0MqmbaBY7R/1wEG74C59+oMPZhArdxZSqKO19ypDzJk2O0wMgMs6Rfk1X7iG37FqCon8p05Ja0yQ 7aDVb16rRgpDiErw10nGDjEbiL3mEmTSsW18lfBWcukC5linBDQM/4k4LawXt4DucfEwXI1K/Lra kM9p0h68iWlt8X4V6pBtuafHSbzl2gmWlx4Syas/wdvsG/92qO89Kvh2TKYBHBhpZ+X15cxobBLh jSHia3xAtlkiZyEaZmBqmoXm/rvCkjxL9kXoYU05+SPYYrDpSKY6zCMnSkYcYf7Ukd+mYovdiLQ6 LQ6oJOer0UYc/mfzxsHvADcXGB1voEINvEMS3n3D4rkSGohhw3uF8xy6dr6/UCWLPhRDpxaJW1iA ic4YTBmyhojckmbfYTxh5CjuOCvqvPksk6bo3E23aYkB9dcLH8OePh2KvIb9QrGScBourDGlTaJq guo1QWzHgnkt98et7vSSOLYSFlNmQ80imlbdElhJ+iA2KmRLgyGgERUKfQa3NuPW9MMoZvEeeFYB 2/FA0J/qJjNDpDr8wXCWNuulBgjLKen/N5b0+cBBYQu1ANuH07SBeyfYTwFUp3mVnoAFbXTOQnLU 4cjqHDxHxj64zqBI04YnSRtVi27uKFFyf2kECaS1HdI3FQcDzQ2JZ9EXgvd10YRZ6QopSctgU3I3 1wQaTVmHLrJFjy981bXdIU9Gjms1tqx3ua/tSbQK5m6gKxdu3eLiia+brkDiaezJ8P906KommDJ2 5M9YTmItO0kCKTWNI5d2z7kWp59GkjdS7ZcIUhVuF68qmx1C1gbCY4YKAMgpLKahfgyK5nstTlrU kjmtdwjxHTVxTgGEhutpWtMPgwiBJHzJx3Fs8KrT0BRwx2PUMJG0kCR+lzLpLr1gmREiSOSnFPEE wRm4kGrYDBvTAmUHeczKUMrSC3Ch55WmuBWj36U5JTw3pY71htE6xXVQG00e7vUsAcz487/CkbEu eO/2/Yve6FO0bC3rQV4RVK8HPtyEWoRKZaDyXf3GF5L9HyNDc0w+7Nyl9JVMGg2BWFavPuqfeegK p1p6TA1Y/Ma605qKMo7xWon4xS/aXtU5jc22eYGKGVtP+AT4IF1ZZ8XZCwGaWbeuVW+0ISROWwQB BfZ4bdQZlNRSoFzBdpTwY8KbktfQJKrKQOL+r98IVxFp7c1wD+LgMyr/wsVpDcOJCPoHhdhvy5dj tN0f/IeYOIPealHNEvS7oiyE5iBYv8e+AIkGQ8mMSxS/S1FpT5rnF1qLCb4S1fctTPg86jofJIiT 56UdAg4Dvcgz943jRe3zNyNO5uoPNofelbcre3VXsMf3+oF7W2x9yvpgy8LzD8rJNtaj7ErTejmY BIwpPsRlHplpmca0EUxkq7zHlPBNye0yezLI8BXqZNLnl4sDveA2kqxGWi9XX8M78yMgXGg3dPeD bc0gCZb7BDDFPy7491hdkQpHVDRVksMkKozj07z+2aivW3ePBdStc4ZlHmGVv20j7SL4kZtgbPvG lMRqa3ZhMC4AR6kH45uqQp0TUFPq95RBUC6Wlc2ietDmbVlk1gJ1QnJpy2jTY/URSslt2ir0ICF3 Ym85HCgtjWhJUvOvlN7faPhKyCXtcRZ+oITaG4RgMRtMwekhSwXkjWzgdlQcX0WuxzzKgy4cPmhC +WW23DGZonWSqgo6/0MbIvS3Jd8eheVw0rVzXpIgYbZ7ZiRyfcqA+J3LDddYCknwhKlWidBQAZtB 9rpsG/k26KYoiZcL9jgaA7gqX/eGVOVHdN/HNG6xn5nKj7qloEIRBRVXfIU8eurauah4y9M3IzZv FG6a7HHVUVRW00wRtoL9F8vBDlyiuB35B8TxretJzcvS5h90/M2Gm6FsPDrBqlRXqE8QWDKQKBdI sjiicffo77FzB2RTKhNakGKFf3U3t+rr0K57t8wtxhGs9oADIvBT6qC1sKfB5ZWrmmlNrqDZ7Li/ 5k5vZZdCFzfb1RJhLgOidYncORNc6DV0+w7xQEQLxpCieelZFJ0T3ng70hKMTP/HX/CwX93RMhuD j8GhKlRpof22FB3GomxqXboQkYqwzVbDC7TCMz74MJ3+9YNcFin6QfDSwHZUAM6yOGY92UWH6BGr gcHx/rcEU3x24fwDs6VbodGsEbpIqTQ4JS8x3gKKWUkC4ZF6dS7ZHeeUpKhXCRdmDiu03VDsOm1y Kyz8NhhvbAWCa6lcm4HoHqhIkscI9gqcNW7w4q24zKrZJpEw1kogD+nGuqsSNaS/SHIXT8Y9R2w1 1pwo5crDbvo1TwHO6Jv1Kqk3plGDSwbupOv60pmf6axB4IYFdSt0GpJBO1BaPdWUZFUYoG/PnLRW 0O5u3CCq54j5oNfZi+ipcwbruUhdIZzmdBjjFQAwv6QhdmcNcrb0pudVXTh2D9YwSVtgO162t5b6 mTPimHBvy/EjU/1Sx+QkNvxy4GVTXfe8qZhdCQgdyeQZBYPwvArCkWdMKK7ZOZhlrEALIL7OS8cR MiNhysjNWvQQwmSFWQ6QClpaFNERMaTVXexVmbLun5ya0Abb9AH+ZzcWFlWJgjNE6eYKfckEzSzM d0+W5jCtjmdKk9g5/I2YRAhqBMBopPCI7iblQWmPyhuxevD5/Gzf0p6zEZZjTwdNUE5QYp6KFMFH Cle5e+kH4IO/iKp5XOgt8cLDodRuM8QZis81/zqh8Rtj7xGoOvKC/zvQ+AT1P/RwjT3biLhlw43a Xn7iNGM1QZZd1VirGLCBfoGplJwpglLycUlTEVC6hZQ9ODW6pjVUm7Ppev1ZAhnoPZEamGEdIzI8 zaFkiEkBjcpPnf8GIhQk5vIDq47zFJv2k+wjKZ3CvClCgOiNVHPRS5kCqEsEUIXPHMsU7/CUXGDR WtTa3NgqNbz1yG8qpq1BLwKB7iLl3O6FVGVbuhInKv2rL2dKJL5RpXJsDZXqUyosHWJnc98gkBFv Po0FXKdgL3SB7Lv3bFZTgaYmqqSJ8fgBH/oOPgvqBEcotNDPhoz7ljHDZS/lrpZ2SkFLZgk4Rxai Ku2CS/RWsy40f1CYy4TqLdKDarCFPNVIEM6fT3KtxWG5xJXk6+RFuxhsNQJdvKfime+JYGOHNX3l VrUJxhqAiOVRMjP7kNrZX3/lO35PXEGWqHeoJfdRUQKfohQM5p3p6oWW2EuWOVHVxub15yy3cifk BqUG+VDjGQtKew0fl5B5/tonDIlitcu21e8QO/YugPwn1i4mNlPNmqXpZEvXgB6bs6fr1A4D6Ofs CXMSN9ho+2BAxEogR31atFf+Hn86lJ3GJCCUIo7EWWlOm18awod5Te327tnolYB43mmOPcn/EClg 7lSqQ6JLQfByetXvGB2yrMGAqCYOXAc/rhEaRathRtoqVnvySWuQC5Gslsnq9WWTPMpwJMuro3Xe J90152l5X3WJm6fw2qwr1Pe6KL5Kzgy6h6SDuxSvtRk6tTdPF8Dq2aqZ56amfAMpF+tjVR7zSh9i KcX5W6Imyz7cPj4JvhRVYho9XlKmWVsyG4NIsOWoGGh6sxBxZW8b4iI0uxv1jxnghTgEr0RgM+Kc hUp72XHrXaDAIYwn8os3TplOB/MmWhjqKJJhNAg7ji3Wnl4oN2D6CbDxvvO7I556gf63rN3gt5S+ OlytNAdyKtERDEHQLd8oNJJTnTWodKkJjTTclgOERBJ5XdDLIKmbCHivCADbDQB07TKFrR6qHiEN PEV2eWbYcTUyR6r0MaxOlKjTnP3VfChkBZV4hAofS06bwF0ysIvddBGj0P4DArdeKCm5OfAxdzaK KnTSrXi/i6bMn70MADKR+OUJFs/kQWwOhCzGtbtBl1WI+xVlkZ8GsyZ7BgEz1X9GPxF5eaxyK8hU p8L/smrdlM9t3NUZ8mVCyp9T3xy78lAZwnMdRhwjdnxmbJmHz/F+GAlC2puXtDaFyF/YSuHJL9/P GbOilwlc+eiIrsdvY6aA/lpFmDSZzfzT4ylh5jDWXstYGWHMjYVDgfmfgAW/dbVusdFo4wE7Kxlt YTxxyUCzrNa3WGf5/HllfTZoBleAPE0vvyrW10/DmVNg1jBFKd3qI03oRnHrpUam58BRC353bUpe jiaz+9SgNs2OLYYXcY3RLWuNN8dMASHpipGSXrSfn/rVXF6ovZDxaS1ugTBjlP5JWfCQDupQPRnZ HqpIttGyTA08q3N3et9dcM6xvP6a2+OifNkuYAiRveKwv12fqz24+iPXN7SBWXkd7MO1Ta7p0dKk Uq/9Xi3XI6K//vLeeejhjTOQeLYb+23Z07dFVDJao15mQVLNsx2J6qJ9/HmKJryz/7CCUI/s0V1V OseKWXvD44/grS2eC9vrzqd4etZ//BZ9kgkmNrqFoyK1CnRkEslXNAxSeTgTbsnOUDKxwzps3qfb JqE5ureEJ3w2qauV1DaxYgNctJSb69rDwDJkHv/H7PZBcuDKlhrQ/iKKY+yXlKvbmqOqFuJ1Nny8 0vuNMy0cMyfu9nnna26pLjTY3+O5GloYPlz8XzNzvnQHCLjj5ftvnFN4caTQsU7EUhV56ra4wZjk 9JGvyKK3L1cb/9dEir2PfnaO5ZI0MRt9jS0UuHLY7neh9V6Q1L5eZa6P1dpKTVjgd2dQEiLoq8HK tiyPU9evSpcJIrkG8NM8Em0qgRwKcqvJCvxhDbc3LTQ6hztYF6MsdHOP7zTPMB2RALA1zjg654OV FOZxyOBi46SqY+Xb9XpBE5DvdYi5VC7Y0A0mu3cUIrlh5m100ebmIfUHeE9FKkaWSQIRYE/iZfed 4I9IvaPkBOlN3h+l9vkhQPvkbbwqhUOFOizhpWTRMkGZHchJ5n5Xrqb3AAvgXZEet4HbjTqAp3zu p7dHKWeRGuObOXXIAiQrOKuNk754n7Q6/UetXYc3HuDCCHNCI12tblkIAJ3oObw68smLVfxal7i2 eqPmFZtsKfIIcnRTf6854SY17tcdZBobhcAewpJCUGvnlc879eGX8m0r043xq2XpAO+6+LI3hNul u2U207P0NM9+GSN+w2FWROEIbRa+VG0TYboEghF/xavaxuyLfG5OJtDDE7LP1xatqi1t0OEpzjXY zjsr4893TA/FjF5Ea9vbgrg2R5e1RllAEZBL/MMWS99TKvk6wodn2spBLnDcy7oYNx1PbeBG3bNj qi1OYcGhf6IuGvF90nr+8FsFBg8IPFAkjtSHI/ERVIZ82wk3+gvq10Tu0Qwp/HBzSkPmd0Ko1uGB eHOl5RyPqY5oUt6tRn/984NDSCsRSfx1elRuqHhtyQnBOtFxNXn3w2oMISwM+RX7rpCT2Byp/T0M UDOx8DGMpa3DPQysYoYFcGXPoHTvxMUEEl7JQ4hHbC4MNpRla4pCg6LHfzCddCd4VV69knbqKgAv /pZFl1KNuZghmKvguvtubrKpnSXKsnqdakUQ9yTsA2cA6pbIDsl4DuTBGxLzpDRorn13DOwSNYoV 4irrO19XtghNeujex6YJuUdPY4LqSOtsFR1ewhstdyKICcvAJYrdgPGmTCg1oZYXVM4tM/S620Za +wY728sewdSVp8UWnOn1svO8KvjaFI+dMBq5yTPtdT/5J+xE6le2bINbjwLeYX8/gIp7irCovkNE TdLgstR0fys4u3P+XxB1Ysc/Scy/iHJ7Wc7mMcfEpzYycKZ/4qn0wQJR16G5AuxsWl9nGXcw04ls Sldd4NNJNK9Xjzd/WzlZdRqIhUvjI+fcYgnsqTFyrzTnrIxdkl7qbkeJUR3KpQv6bf6S3BmqADph +FVTBK810lXhZ9RJicZ42uAIdafPKKdiH2tkZIJI8Lcls8hwHQX7zEO0YDrDTMvBcVU8Td9cTExB c4bhZ+yzyJe2Lt21b6S7/DM1GgzQLzFBZDAFjOvx7gk7Y3ADYGITXSENCewkILRBuKdDaxUMcyvo NNsiJtppHQe6rnQfIfqvZQhW80FoUXazVosoM0VfLHxm75JoOBazhdreVsmpM0lk+fkGN6CFIZBA YJBtR8Lbq93nw8YNmwiL1XsGu0lmi+jN4nbLliMAGsDVSdNHlEDIkztCjccnbr1pbCYTe9VstvXN BsTwPtn7hcfqYMSoCiH0ZherQYiUKBZREaXGGTzNTyRaOEuGT12c2t72Adn7E3tQQQes1MXEvQak dCuoxBDlMEB5RdL3z+y90txcEp2OPkJI+X5RNXqSCL/2OPshQXa+fz+hRCC/eZFRSfCOtnj3/2Mu aTjYkH4xsMJ2BRxWjCdZOcAT7/UeYTbNukHk/KZKnKOPmv3Nl1nqfY848kjcCdvwo6+PPETto936 SYugbqa9RS2fqxrHAsz4DNtCYeHTeC+ZJiWa9ZxQug9Q15HSUlH6KL4DmOy0YqO4aEs5pSdzLLTB MGkMAgb/cjT10dk5J7/qHV6+DSh498H0sNErm3icr9Phjj+ujs910gpH2wR7YWzzkSID1fBbEekl OGpDF0LcB952nw8UengCL75VW2rZSfKvTBEz22Q7FhsL1X7TC1VXR9Kgz3qeEqQ1D2lLukyo4Opb QRLYIEmY2yNf08hpy97TRrPz85KZYVJtCWIndphWK4A6xLbYDgmy45e4nBeJ8En4f0qT+7oRlDSR 52sJnjCAMuucqphvKhL9v3OpnBSq7snaFhr3WqVgS23pR3VeSgu+TAwvVN5EFhSNyuHgRXCaSf6g SVNscpRBrb0iqDmJpbnP9uY6zFrgFWzWDVA3E+cfqDpw9pSLPtdWNnjCsbzBvI861dYrXMvt2pJ0 kALUct/5VPJb8/Jq9RKW2Ks8Ka2vJPKW5Hq8xLbZyPkEzezNUEAc5s+ytYjgTzjCmYuQtg1x5vLD 9dqUOTIF7vall0FGL1nMHvdwa+DULXbpjny3hpJTjC2wrhh2NRR5o0AgaJjnYUacWPhbSmNe/NDN OkDc58cpXme/8laiYtbSH8LZwFmFc5a06YlLRW+D77gXtz9z5rpihTk6D3ytBRsJYdBJvp4D+Zg+ sX8KMcZMYBUGoPQtHcci5POO4tft0fms9n8ZgRzCD68W32XDklY+R3ktLPslQUwBS4iGobR5hGh2 iV+vhIl0ztZdIAb9P2/y2uFFvkQFAXyRlwvIZGKFNDoYD/l8pRgOwDRUuVdGXzZhHupXO/4wu13w GkFcM1W+9MaoTULtre2JjWgO/v3T8YZvqTIj9HcxZP8icCHcqL+flIaCdHGu0D1Q5NlkjuVLxiEJ uaoB7KwMRKoDmJzX1Y4YNb072m9uMzWNd46LrV5oXt3mazVIG4lATOXRuO7Ch4vyTa5fsJ6kg3Jd 0yHMt2I4ExHd07j3miWu+CnvxfZYRsi6cQewWCy6xTltfspVyw4dU/VOae17RwRMES7D38Tkilk1 rgJ772ClGLeq1W1rXeC0S3rLnkawQ20iO0pE1sorqoY7K15gyfeVgqeRA43YnZjAa912RtVtYA+P rMY3qJcAZdUGfAeXN8cggnkVtYJUT9uOhW+NOqUHC8zPZm/kuA5OL0yofZJHMfPOcPmP5YtO51S0 3RWJ1CdMIp5/NAQ7X9UXRQUhumaDueJAj//O/EmajX1vPc0rfoGYt1KFIuDBCVs3avnADYg45wZY bmMVWwuN1XTfk1zrL8/ZJz2+8GepvUwZgd0SUXaE+s0g9kTytLpRlyiO98jVYpemrxPGAIn3DsC5 B2FXZ4hR1MLY/AXBOaJ+whuc4q8vyDWLG1b/Ta7xA8csaO6cofFsMHcAVAAMSxXOXZ0GQNsxvUYP f7yueGHTPOyhjMjOzJw2XJxOqz24H4v7B1eXrgh/fAnY960I87n233OwVDioxjmfYs82cyZX4zzL EvNlhhwIisF6Q4WlKXbFwWpQrfj7LreuLVB4qUuDto1OZTfZzxf1wRZoBOwtaPqk576Rh0k6Iop6 CA/Z2+q0APgp2CwYVxfQKeMjMTH6AR+zviK2FTn64tsRQZvYJBGgJwtnZPPl/Vn97jpF1gwcvHsy NXs5SAzJRE5YCv5da5AcBU+ex1R2nUwSyjTkmi+faNgO0mKMc9RAqs0zBNgk5Fp4CxBd0n/rtR/U b13XdvkFgkwjgDb8FJG4Vaehui8vh0mULW7v3Shh0dRJzXo2Ja3Nu6EOF7vd7NxeT+FekHNTUMnk 87sw7q9h4UbmeRsra6YK28Pil4YqwgNjq3GKt8W2LkwAfwvJZNAHumggsuZZv/GlDwR8pjXULca5 9y9Rsrb1mJP3rMvOjLA4iUxwt862yZp2s4sBegFCtC0uXBCTcI9lQhAPm7WAiuHgIboO5RzmGZ3K k4410CBQArpzyNFv8UqwOBQ9Y+h+F9e8oV0DjA8AR0HzkunxrBdsSBphTg+XmOxqpx0N3B11MmDj OVYk4seKlrLQaLQN8FmD5FMbDR80DZLamOKLBcD6wgbOLlrTsQNABgCvvhxPq3XAVAnGvcJJTFyw oZXYqfH4arlj7ihnmo4ydD3zq2W+jDkI5O1YYBb8fmGE5+3QQnp7RYnKcs/1d5ZL5rHvj0ZMXPuY iXwTnB15AllxQGjsWk//csy78ZxEibjWPWA711fxvm5fi67BvARfM060LSMq19I2whIZ/CfsZjsn xyERvN12tmzhpMeiJCaCcPIBUvrUMjcObeTc49IM0jus8E2i17pQ5D81b6qg056sa7Lo6dBHUFoX b8Eyv00BsQ/0keAkbRnqjOL3ZRmF2FhpJSgBxfGyAwPmKTuDWEmlbFxDjZI4qN5Bib9Ihpo4L//r jBYs5JCUyQXQIsLZxUjEdWxmAOKX9Fv0ogK/2T9KNPHsuxP+T5uyD0oZNqLr7YnQpabZ2BnsIZlj clcMCqheg89RPOMePXlq539IyVqht7pR8R1VoscMI8Hi2s1fYxFtsB/8nWNlACAvk3vdT64uuWCe mzYybCtNw8IsO6GGDAtbci3RZg53peWWy4aghrN9xfLcI0h/NUAwdAdCRIo0W1T9irzASwOSpzFi PCG96xXU7J4xXG479QJhDhF+k7GBmkN1lmhcPLFY5739bS6jfocHiGIKGQQQbpY3c9FYGTqYofYs JEcB9U3MZSdVk5h2UR1L8Voc99jK0T4dLXI3UohkANu7nOlh4xX8QZKPjF8zCRwUd70bZttWnpSx wjYQYAtn2JP1UWiHDtVRsbB3F/kH2+omUpBaLAn+7zDQw/0n8fOGI0607hPz5n6b4nM+8v50rpbA NPMX4uJpD8TUwhBLTRiFaoMvb02K/LJSYn28aSKPXiNpH5pPIe6uaYN31nfC0djaE3aV//FaIyAP CoiFkvCAp6X190YF3iZvtTIKRxYAtjHJ+X5mWO4xbBKwt5cXhvXTqlNnWxcPI9CHgKjguMw3vQO7 cGxD5BhCIGgrp46ABtOeijqKJHay0uCu+TtKOWy5c7cuucTfDYR48xqNw7xmE2zuD7ZhKvH6mQvy vUz7kHUHOnLF10MRt0vaVbRKudm2nAuVbq7fbWJlte02iQecGw28miGa46WWqJkk6WDLMRBQLfm+ e3QZkd0I9hmN/cXk4QJ8kPBvmz6my8kMETx3n4OmgxaFRCB5C6OENF2zSQzajKD/gUwdV8RuQp1C kMMRAnBBYcDauJVbgHKJzyxek0LpuUWTrLyiinA1ovscfAoYjVS/4BoFMUgwQazwfc6m3wZJvsQC AbVOBVun/NRoiezqqo+RRcawIVnHTVdyUh037uMS5wW2GEwAnumzz0IjB+vMVw/XohBzQhg+nxiB u1nE14HIZegC/k6U9Dd6y7Nm1TY4UB2zAk9Eyoa8nb3FyFLGhyrQdxrB4TId7LTuWcY0yJX9+JkE R6q2sNR5s3c+9FJ0aLOr08Sq/mDdwjXt5pxTIiifU3GhHM+UOVTm0E2UNsDwdMLN76/FJGu+NnmB hRoRvfBvp4Tbhx6ssZCw86jf3pGR78qnuWbFbHwAxkQDkYadTTB8SY3Edif/rfGDn6nRVEcj5gWJ ubKhzcuNmnPx41wLDa8WLPDq+bCa9LH955u86bm8DIM+Y0sBp3HvbR//a4EHP0cr3TRBtxoUowdP p5HFJX634Ro/CgIqmOgu/P0U2LxPjewIM1nE87RoKOoOxhfk2CVelh+Bu13+rkwKy5YgHdQ9JtUO lxTn9mZqwctFW3+xeKj9TEZcTwUnoXSwG+4bFxUSKNvwI9v3s1PBk04m3oU429ZqXsY+/7Pi/uS6 m0lg0SGIf4Y0iubwCex7KuCdnabeaIwKJjL9C2BVbR5q7WrnLavvvax1jRolBwuBKb51oTKKA193 U/v9g70VTpQLQMkb6Q8wrhkCFd1yTfHZbyg4Y+xZ4emQxdFgm21Twf2qEGFzhz2tFtfk82sZn/jf 2aYIiwygvIRIswY8m4P3CHQ+n6xXKKmoXyfm11hqZmMyOPVYE6ldhHvQ5mS59QlpS/I34TH9AH0T NGcrj84+bwiYdFM22tUHIIwyjT2Y6iMivo3nw1b42obZRlAR7dACSvhVLC0N0PNhLmQTFpiPta+B p2n6AXxhrtXBpDZvrUVLcNslH/3Gor4xulJA7EF2JxNL1UitHdu7pt37dsTVpDHBldFpkv+tYPbj P5CA+siJd04Mf9fVIUjBcVufgkeB08A7S+PAhnc+VxwcSabMtOBGKbwpPS8+CEuPWbyBCee2/RuY QQYNYOoIeQfI92eaT+oQplkmrOdqzTliHLPgdOLHxIO6T/8mZoww6r3noaOMQSxS/U8s77S0odt0 JZUlGL+jgDOzFcSYJUL4V1oAP5W2fsNZerDgjrk9HeFbCdW6kSSkgT6NUawiFzmxs1qIIo4LtpKO SnvblDYemQsaueejLqQ37bXYWF7rERRtVN1u036KywNfCQwA9XEIRYHZD6Kb/o9Czl9qQaXvXVR0 akVAPC0HW0VWFEO5ObbqdlYJGl8IKOpvlfqibJMzJx2s/lIKi/5ubK/WoTvEmZOolEk7YnKPQO5X 6CA7fYwi2Ok78DWtf313zj+vL3Oo7wfBPUwYYX51HYikA9/wFAdKIe+6KrATP1qFuqYON27a/wpT MrcAO11Ef4rojRUSDbxHHsy/ue2fG9MXByXb8pQjxdayGcpNVgT4d8+1dl7w2fcBIM1POL5Efe6K pD0kwfAe1aEAbcBBIUMzMMJw2lbfQFJofucT4D3AIe64jqOx+Fbyc2UKspLCcSdXW7etPX8BK05W 2SeGJeC3afS1acwP515rnquZu9iqz/m6SgfGKbiqtsEDuroo7kzKwSN/Bkx53invicQZkO33KgLe n44s75KJBZteLnaSBNYHlglte+538s60s5Ly8C62RK/o4OAQ2eqqA32RkUm5uCBrj1Rpqo8xS8LW N9i9GtxT1kXqvzxPHV4vuYV9FZ8HBVycv9XQyiquk2nAkG9jq6tFq6kowHowdxG1KquEpxsRWrdi 2wFOnzJPChxgFZpMztIXbvs9gxXVNldvQtHR7Ynh3HYBGSt0EQzSAVP68wujhPnmmyrflp7FGx/y FAkEBryvYDapz9JILvx5N1tJiYqBgop9jVu8puLi0+oDSE7pRM2yQyXVpgPVdPdD2XEgklaBavQy VT0xWPJfe56iZHPIjF/C2a9Qe1QzA496XhueLE5ZROcLYhVtYqheeSwv1SbaqDaK5o+m3AX694bz nR622XNRmdVzWqN3Ntjpx7r0Ulzrb8BL4/mxClMLvTHuS1Kssnxa284SwaGjpdVLu/QQvKTqyWRG Q+StIsPIb9pMiLeARkTadUE4nR8rHLZoAV67bxsU/JE6pbHavQ0w43ZaiQuHV6LkxrzRMHv0iorl UkDziDRX2xSwhXUSgu5/OqlBTuCjoqyihIlsFA5tpaChY2jEw1ni7ls2aWdhuO1M5qdWtcLQgDTN Cfu/t7entKZzNcrlEIotDOyosmtrLItqb94ECa4BEEKiBVkdZ4fcCbAsks2uPihl2P1STOf2AnIh RLd8YhQaHBX9HSOcL1fAD3z/m31OOiHi1C2S3jhBXSMtEZSIa2tDSNcAJ3HrzAvZgkvXrfL3tfyX j8WosHb8NcKTp0jA8qYy/KIq90jhxBTUDGosocYilpryc4vuILPrSEx6ajt0fVOdhgU85NERGOzq HPI9DX6tL4IZmk0LLThKfWCRIV/iHNpvBf/9iYlFOq1tE22HV7C48QMT5n69+xVfVD03M5o3SH3i TsdAo7JnX0t8cBdb0MW4bZB8Ghi8XF5gsZYBzlGI8A1nedppri24ao9plEGa9L+ndvlitMkK6UBm 60YdmI6twfrCXnyhafIm0woJ9yIDfk3lrS+M+ZbqhUDLFsggW0gywstoDQJG2YYBvUEAg7R9TH/9 wHM+RK09DTKRCKwr4cFdJY6xPmTfBkuD5xQ2NLUSs1ufbGiyl1CVkIc1RUSJrPHu7V49g4N9dyaE 3tiLPgvmMfA0Hh4VfsUe0xyzlhMrodVH0FoTITP6ON6d7ZDScdCr2SQpUTuMpLtekNUTEEy/ZpkK NElr/zru7KGqU0KYivIGki67K2yM/BXQ01brqVNYHUtCXWCaJiBaLnIbtgRVGAPS6Jj62j+vkwj/ 8EgQLtQ/ZW4ycaNMHxBiKKx/50O2V8HogU1yrvb9zAdWzEmm+/66NS3Ta/wmibut7b4qSi/+xA/H fB8GFGw6JOT3zezADVzc5utxGStqzwtnTUyHj1j1FcJb2SycZJ9HquD5Csm86QC9rwkyUXd52FPp EA9A7ES6ftV7VRtnHZZoQj4A17qO7sYQfyHI5mxP42YR4evdunCH7JS50VPxXm6+etBfcF6fNAp/ PLNJ23u86dTD117p3eifgYsKw+eMYViJkZg6/QozEw9g621VUCc47ndkcgcAz0JgWj87XcRJrzup ZIqfavQ2XwjN4AyEGluocgKjXcIiEdX8c0dpjFxXB3e7LsI2WQCyYX0IChEzvBCtiD3e6FDM8QDN y7YjY7ZpCpFj8FOjXo9OHT9WGWvvrd/ScYr2pSXvags4f2ZrKHuMMvZ4Z5hI0Q/Qa1cbGbcVu2ko Kw+d+P3NEc0W002pIq/ey26yiHRC3pSohbHn/GZEnKobWx2uzmJKAObruLEjVcDPds7Q5VoOpVqf X8LZLS0sX2TeDydwy30e9aHiC1dKmFmOIoljjSHyvY9z1Cl0ejyRy2nQYDlGhhdQceliDQGIy7JZ nkLwEAK7FDjIQsPIpnUUAjMN8/DadM9myJpV/GxQtIlv2tsw0UCtjyQP6wW5+HcIP+Zqkg/+2FCp f0KnAgHQupgkv5By5f8BG3+ubVs2WtSZ129Mh14Ih1jkyc3KW2FOweHt0I+xpEoHLyiCgjyhDFHr Df4SYST6Qf4lyn/e33QPjTkA3v6m7ptlMNOvZwtJAIj+GDJfrM0MEkp5YwMEur8IS5y5D4vj/eAH YvLTzsGebfbt3N+y4AUXl2t5qMMRjUd2IXGPnvrWuTHhuaOOdhNZfyYc6jm4oMuR81K6UlJTZyBD /ptAJQWdVqxt8ponX2ZpFN0wns3MPHVuWInfP5+gkfMngYI6kNe80P9SfqdmVSJ0DXFzyR/Lan3/ 6VSBVPdHLzpDJ0ra1P8reDrmORvAre4WiooADqrt4bkz/CbFjZG4jCWWR6vh49OXeEVjsLYgXjxm CIa6tmeIBZXB48duCCTobLn1a5MBaikT9yZG4YaXH5VvoO8RvBtuTH0B5/BbqvskM5Oz3gLkfhHu O680hRjN9wry7g03Yzd+aH80GrCZoIsdf6Uc+c0myPtVKVpti8VOy+sZlvht5uF7YILfRO8qaesq oDJxEKIWjRS1EmJbUiMxsMVHwml5Xd750PAMnsctHdDWkDhsy+8L2VXFGRsR8obevMnhhYRyL9H+ nvS3C1jjZ3Lx2V8bCgp54wUcSKipNobMDqltEV6LICwSmZZXaG8AZmsoEGR7fjPk05jeoLfdchk/ auLp/BklKLxeetWsb2nZbb5Hs5tKnE9O1syWe7HvRc+2Ukt5r4HN3p7uh40Mb99hX+3y1qYkVRbJ njgjhHZa8R5sdyHtDF8ONFW6JMke1k+TfpBsGXP/rq1JRxyfsgYiiqAnUbMA/y3SF+xsCwsV4RJ6 /TFNIcNnc0XVmA1YxLek35hrd+RRF38uUA+MON7c9mFn9DF6ezbOwkJLk6HUMS4/MTh70XdjH7Vg qnOSdtVtcBAk0Fvgr42nlhohInMbt+zg6hWaHK6j8w1DdH1utNMkN1vz7HfEhS208gHkjDm+n6O5 eZ52Xs3GAogirt5TC29PPudioxrwx0B/z9tOwnq03ZPDmRlWBNIl3ZJHLUrxtsbKcxkhx66rUMdH jWceQQbg57AYCD0qDE/af6qBZATleBoJc9H/x7cpflCw6P5FUgLskH0u0/dMg1BshgGynlroAZJt lxCRS/Ib6b8qIk5wHP9pi5pjJ+9Gxcu/PiJm+HXbd/5masKyJI74mq++uHCW/dINX7J689Ljkvaq Hw8bVREBCcZxRcfj87PlDmbMCxWXR+6ruSb+CN/nfAWjeDIBypHzkVShKseaGpNFy264BbArcZcG XyLi88jJLku4/PvJmshVcvVDIbCjUjV1czSEUgYU/r2MTfasOUX1XJBL39FQTOAFWlMKuQaUwBxt RGJ3S+jS0w/ffhw2/dGCCQodW2/zeJnu9u7rBHohRIatern0uKwL1j0vPreRz5QsjZuUlwVG/XJB j+ZmilJ+PiCaP1OhDSOZLFRzvbj9IihlDjS1GKdERr4cjQLAccBaQGiK7MbFhN1+BGHWF+NaSOht Jzbt1I7Lp32je1Zz4gh1PY+qdw1jGYGAkPWUJBHkCcjemP6ki2b8a3PrcCSKiMs2eCm53GFT7zGH VPbacTtW3gGjJrbya1CFZm5TyXd8WwaAxuKcQAqmGQVR/2JQsDjrKzXwmTFOH1fftYQSF/8adH1J 3i42sMD+EKlsL7Fk+4UcftsDgVr/rSHrfbwP3WRQwdcAMCGAdQS1glem/IL0Okv6CrqzwAqg/N14 AvfA7WBRdXR8bMpOpLuSCTpIngY4NziJFP+q+W11Mgq3HocmqhEN0bCeN09GfznEUdYI17JK1rZh flba6P3B05Q7XR+EH3JemKFbp5a8y1lDxl2mma6DJLNvB3HRx0mPj8y/27yPlXClx8CkS6OBB1aL OXFx3qCaVNvV7mA3TWl758jkwgBcNFBdGcBP/CEJimsqi5XVnsd0MQOdB6ykm4+gyXpe24af7rMV 2iWeB3BXiYDofli2pG7Rgi7+Pa0StZGC+BsRzHmwXRM72vEPswS7YVrJwnP/uGv8s/9wTG59xkHj Wk3//mTLM7k0zn/sOswNANdVZwHIuezNIwJSQLXUg5KLQczuWBRb2Owk0nWnVFbv1mnbHX9LB6gg aAOrRw/6xbOXBGTJUbDDuRxXF6JHOlAL3SVhEkEXYPK6Hru9Grhaz/ZIV+5/XWkHj5TiOjGp7AnA 8oSsy1DNHDi2sm2b2wAtVk65HzqpMoiTuUg43n24RBGZYqCKvH7PmrVB5UCyZly+rV4Rk1rkFITq nuCbANXnNAISn9o0CHm/6csbOXlPeQ67LCtZOM4GV88AHAJf6xatV1au+dzRmp/fqfuxSrYMKxuf V0lJiIbok4lBqyvXh2Ao563vGsddmxxzaWydLler4sruHjaHC2y5EprFV3GpsBUpc47h1AEjWsHW xn25/VTlWshxsVjHT49KZpAJ8RLP6fttpZf8UP8J6u97Tzgz4YriqKG9VxvLuWIWFmTJ9U6zksOt +zMBxWa2OuecNzgYQN4gBUVTxZl2JD7CRMqmcD80hYgAFbSNu+GDO/couQmnVVWSx8TSU0Hz/3E1 VgN/G62Fz4eRANLjLcUDiqhcRKhZ6DiDO+n3g9AsZcW2NULRjhqvD2VplGIHnjY+7l7+FNZhu21E UOCGKfKt811vnCxmYBpennB2anJ/fkOxiedrjrDSrFF+Th4Bc7zondmJ9p9AJQ5uRXIhSe9FOq7L oEGeVSHyhehzYZk5uuoPULf61mEVm1aQTRV9OBMtoI/gALpn4WiMOAgFKpMwOzywyY1AmYXABwD9 yvE4VKu5QC6de1CFO9Okcug+enjYuLAZuNpnyGzHTJfCkzLfHgj8lpDacFUSpncEXQHdGDyjIkqr lyzm71Taw7d6EGuCi4LOCPlMjOKktTrj3joqCI8TdCUBeBc8ZosS/DJnonTi8e0UkGd5vl7En2w8 ZnBN4xQ7nu5gQvKoD0m7c7p9BLE4WneFhmkBWQoBq9uTAKNUWrsVyG/lKv4on0eIQQ74UJ25ZpsK XtJu98zn1r6u75ctaauNvV9y5bNiYuzihdFE72T6xEnTuWhOg3u6Mcg+rLLFRYV6CySrLuedH577 BLQdo4rw4pktwBB/S5jX44eHF0W4V7wX0jsOjnaSsw7KSLTEPMrJiTvH4/vdR0e0f5RhD+dRWQ9g P1POnFe9FH9c/Gk14oD5px3jRH1QKZXcy9qnKgcbRHJV6TIC8oS3x9VmLvSh3HnUO9q8YpYGQ1fQ d+YpyDEPJxluzKCRQQR8eIl+xbADxnFozAIpL+5ORgSHBRMk6u2IwcIHo5qm1JuMrq+6Ev6jBe8d /1rYwLF1UHGkuGJGg5PZhjdJ+/YgsiAgI8Ks7UhHiJrUHwMJsvzoi2yTdDLGRmiZ8eOhtpTYYLfN iIuVf0Ti/Qun6TfiU5/ubH435Ik/zHsT3gjIPoYzwETO2lyf+iOPrArBAvkqGBwGX7r5MGCCqz5M iy4nWApyBmVuECRPUOwAWG3jBTAKI1O6TuRbDBK9OKjWLLHH6Au6VKn+/UX6sQyhN8ScSgoBtCp3 21De2DItT//9EAUQSj4PanNaRvSC1eCMokFH8rNk0UjF8SiEroWwkeHsbRWDgQrJaW9//YHWjZvr sx2b5psvtBMzasKjDLtGAeYbiMJUxNCraRl1O3KtIHtIyZn50dM4oQ8AdXEdSXVPrTSn2bEjatlI TD+eH6/RK+2E3tMVWms7uP/Hb3G7HbUvDIOf8shswJnE1bQh2riro0ABvB5SC5iNip6UW9grb4/q 8Tc38RVrnZudC8MvC5R40N07RH6NuyT+877lRqAyqRp8HSVtDbV7rhy9wn6LjRZlaR+ju2S06wTr YyX+A9JuSkSkwx7bvERtsLjkUYBAIQo0kLSSjrjFJJ+1BDRWltDiXBeC8LGy8An+rFfXxdsgXYXt +mAw9doYHbLzR5nrv8k7/EBI1YghO9TwVni1aGavDQu/cYqYLZVamI3zGnidq6VPRl3x9AH0OMUa KIFc5NyHbk7r8s31rOtVAIsTcBoWKMqhHLk2rHOtyamSo/Dno0Y/Tk3lzyAwtakY4QKK1CqRWtIL O0ZO9TqULpwgC8YGdSQxyVr2SL9MOmy4ZWnU/QsPL7UJUEN0eDOcFkcKSD2ZH9pXBuQx0tcUcloU Fbn2Sca/2GlDN9GT2drjGRGJgAyPpJypCYC+usuNGBbTOYpTccIjQt9xX6EAJ9aEEJ+y4wtotPiK 4fPJ2H6qMaZBQxkcurHhAqVjp9h3ESfEdGW1/jyGFA+Kz4VqAxjxYhH/E9kzEbXxkqeU8/RfQidr UaCydTWpPrfMzP7hOLAjbYqanDflWhabQ1HFNPQqZiSxTQLnzYFac9QalCbnYzRfL3OnUV+6gi6c Zmkoh0wzoUAZ7zfvtixb8c4QsoKErtCGMx+cTw1JmEIU9RZZOhJI/cpHDPP/x8u8uJdMOiMW5QSc 8tR5T+2gbForKu39KlC3uSbfegSmCXqlmPRzk7481RpU8lAZR4sGVL79QyKujvuCEEYoKmLXMzxa 7kS10sRxmqNBa+Wjh4oEG/iepv7ghFVo6IVGHwYwtx9feSEGxh8gqVoFMlL503hg5QwmFZZjFeJV gGVOMLFSZCr4OinAF4ZEV9OmTemz4V9+OjT+wXX0x+0JVEpOmQDQGazZeUguH81hm5bmFGLiTjMu pqLSAHiYMPJ4RVI+/6JBsWBBO/+bfGriEhqNwqQKi5BQf4hSs0st/h1ex7q41GD4aHvg3w6G7xmm VQNuyRJewLLoPpfPbwRJh9BN2q7zuQ9QEy7bdh0iypHBytn6Z2+fVu1CKqoAOz5MDw3FWPMbqJ/E wwROe6ZfPbLkUmGSQ5I6c6S7NetpGlFDldxH3WuNh2Dq2b4PA+jbfdr8jJw4iHTgnk/r3r3sgSd6 TnPCQJoUFzvSDa6ofwjRAgOwYRbYrVse4JhfZgvCuWLjpenl0p3uNxnJkb7UA84+m0vKLMDclOJJ jb53txc7FcUY+xFu6Iw0lEviQhr3q0wjWHnuLXqDJESbkXLi/mnB1DS0uyCpdbha3M9LDxM6lbiU Kav1TSpan7JYqwN0/6HjgO8BGWarSGCX15OzS0UjlFAdNprGdOJnGMwIg4C08bbAmD05RFR8BepV 4FRJ7ZZrkLcagB+7sIQnjQOk1Y2QWTynychCti0CIvCPZTBb8nBGiR++1/ZILgg24bL1A04MDxsj Vyn59fpNWsqve15vi9pOfbMaxluwClKWQekD0buD0K9J/BtTwcGzmpnwsiPHvSBCqFMZqLE0MMP/ J9ySvancAPAQwIbkwnqVcB/pwSpI7qHQgEYRtp9fUZmvbq7EeNyd7+LhMithWTk3r1sURLCWt1zV Rs39tKKIQ5Prpjj1MDvyFOIKZcFHwspDPECZJmCQilBfiQefp+HUSUaEcE5uuQ6n450trY8t9NZe JZv90qfyV/Zk3PoW5+s93tGU9xzX2rWg+rysliYwvEJsif12Q9nfr++Ykzg1vmyE+PFyHCKfwQkG qGDnvTkCuw4DMADpp3ZrZU0hNLAYoT6shlvr1pvsXhTCOdyLGhX4JVOqFLAQjBLenm2MV31MmHfZ GXR7gyNJXMY0L/AJl8uASfIALh+m51w6qMW31QwAhzjwFhNJOAWG0fVfEeMQUurcOSTvJwEBRMkO OwpeUB4FuWPM0adTirGj09USNteiS4LsCXXoYvRfB87ai4SpWKCBGyle0RQ8kcddTWx7KRWBYGGw 0dmpzkfhUQ1aqwD3qwjQue0S4UEI3tso4oMpQjxqZa9rwXV9m6WigSRVLotuDjHdJEp6VsMFmOai Jq+OpltIWaqYfHB8rcp/klJ5lDSEUlJ8EEd9DisdIzLUYj4fgd/BnBaupNbWhkaIjU5syEZ5VOt3 T7u0sD20PA7aB9FOZaD3nSvQ/h1GfSUq0Vojjj+DvorG15osbDtdHbYw2/gTB+oXI5Lde0rB07zE pX2wzoVDMs3WOxUd9mhnbsr47R2Ggbt/RK4D3U41N4fleqaCNW9x3di7aaJN2cS841cNPQPdfOwk /98ZSMOyEj7NWVar2H2CQkQtVRkNR5EWEpYUk59kAqnZIMyprSHIijKm+4FYpgbXDxJFL1oGIZyI 1JJKdg1lNtnfbgROoR2zLh8TbTiEhc01vo0swlUWH7JuuHaujmt4rpXGpuq9hB2ZyLu2/shUXKKd c0ny32liiB5AB6zhYnjzAKXuJ9C8fn07OgT59JLsGG5GdJ9mWV3MOoPU1x51LQYERHscr3oxToSC xtQmHpjDD/vFlCux2nfzx3zku84Yb7PIaBMGIPqd1S+PdgOXB2tr/SfvF5lTiisohEg6LFxQEDVw HWkT3vEorlRR0Bmi5D9duV3knACdq92ZaBgOlzP5VIduU1lRX1jBfQApNWMnzob7H8E+sgrSMPEF wZ4xl2XdihA95Cewf6S7/M4oTZP0mzsjxNnO0PDpxR4bnrPg9Z6XupptKl0Kd6SlJQCSShs7tsFE auqqXONMnJA7Tyhwdd9OdpdQnouvf1CdRdnpJTzXfxTH8M11FmlM6AxmujGONZi/WKZv4HRR2QoH +/Jl0X0muSIh5uaqF7uLXuEUJIPQB52Da/FxQFqgV79zFuUgBvIJfYxL0/qHKNBFBAiL3Ggbz21A a6/O/tdJOKWtKUEiDwrH4n688/x99Rows148ws3XDFFts/oBAa8JDrEwunGSmc5KZaLc7+sphg/c Z8GF6UYIFbofpwHWeJR53bgCauJFgBMpu0KtRD3TdFUGD2t2+YcfsIY7wcACZgaXN2qv74NSd/RU aevdKCH9TnwEPMvFMxnLIKhaqXZp2h1Ge5tfI1Tsc7Ea7KkorwIUEzFaYhY/0nqCnEA+kd4p83yL TFeUldC/RbNPNAusQTaRZRAVQrR2fGDRX6vqdLG3+mek22e75mqvco64W+h7uvtWlx6i/Wv4WZFo YXkw4v+G4XurnHJNy6sDdEiUfEPpG1czNKrL6McTxBKeU1/1cE7gVIPfFWVYuepaf4+QbEVgJsTo 3EZDLvFiYtHTsQRACN6XlBW7PLetUl+OUBGRvToheWKLdAVYxf1hYtYV4ad2RiapSxxi85SdVAuz e2nc8nbZa7in5Gbgm3/++cq9LKmUXYHM23CKv51yysA8eq4po2B5aX3Dh5LejKtThwrPDRZepCfq RX/ct762GeBXyOa5IAAspZqe9f0a+MQa7X7p3751296ybqZy5CZDpRwuug0lgm7SBSvtwxaHhuYp eYlsAqUbW/uLDiyeAUXl83s8lEJpeo3Qx1sgK/wG3Nbhkmn5fy6We4jHyei5PBsb98JbNIAHSLW5 yUv0g3baU9ttqBR62q21DpaygWF9muHUK+SlK0uN5itKo0kz3TJRFxrMWt/rXlvvpS+vbuXorcAT ld1BcQ2o2KSOc5ZBO6W5beYneeoww/IKulRxtxLI1WW7KyLepACL2cwW5YuVWaWrZPamglohJaeT qQWQ0NLUI1vwWu+TwqKKq/aVS+fG0D5ikoaALAlu+ZNVPR8EwtJc/RoQn5d/LWABojqfus0TO1gw LcgKflut4Jk3A+IpP62UG5nOGwovXEMiQ/9YzumHwBYqvB+WF9pLccmBEO0uxi6lhsxmkUjX9oBD pa380+q/iuBWZbWJz/WR34rknx9TssEtzekhmSMpWf8DzwMBqiJdphPvaeOO8YaHQndzSlcO+OnF VteN1qUttCEVo98JIq98paQhKl9O011CAThTdGlM4aPSrqR3rAvXnTmtp/4r0722jch9lm6yWUyT WObW7W25M3EMRDY2UWTGx2bNwRpZftAkcAQtaG3T5L3Gd3vzmR2GQlN8CPrUKq03PBuE7pL7momu Q6LTPS0rW6TouKOqkeT6Mq5Lc99whWhZc+koQyoQrDbPDcbSZYuosJ6fO/AssT2PogFHawYW2huN s5VytdRxeOpuOXYgA1N1r+Bx1Be6imcdt+2dBZhPq1WLhaHzxgF3xhzSJzRTw4pYfIVylw5RUV4c f1g2Ko4ZVZRRFiZ3L61u9qieyXr+QjE1tRD0ytOju0rmZIL3kyvg6ZCkOgqsv0KInbh582WaM0bM Vlb9G8tJR8BrwkUwjnyLqv20W/3BWXVbYvITDZVzwyK/9RGa9L+PjLhFCxKIfNwIHbMX508K48ZX vQEsjnywHd0lzMkKO1KDJ0BwV4y/iKMsDB2G+CWCaGts4oOU4N0g1Oc2/nphvvPnbho78+OVz61x T+chexIgHUY9jCg1EP12/Gsq11oAEb44LMzL9MgAzc0YC2+HKQziXvFeU5iZtSaiWFbIN9UFSxay 0dn1rSGqjYue7mvFHyHK2kk4275tRb8CJxvfIMGbEGKpaao3fl8IaKcSTMshuWBGjdHUIdfev9NG H72HPthD4bu4KGXfdE6IAMESk/K/JP5w8fd89QNp+HfHT6dU8cv2LhmJ2n7L7LJMlC1ioKXelqzc n3gApzyPs8mX3e6ckEMjlvwHE/mB0L2laJC6cXa6K3uVy3Wvm7ah4wl+0hFvFJG/p8sv4mhC4Hj8 myyL5zw8PgtFsY5tf7byDmKuckARY77mU23QFzcyq0Xirih/G7213g4qv5Iafg5uaPgz+h3Eacdi LI4uRk+MnzWsi76360HxBOi5b3d/OSRTKV042+LzSu5Y0L+VfSc9Xk6ahxkiNdIcTNNA763Jrnm3 aNxGg2klGRHeNr/OHk0g9b5EntZWKG3jUG5SqK4uWPcbVeoFdaADako1i4VesRZPqhcLFZIUPHGT JF9MxjqWwdjvYithtf2Aa5IHOHStxbUhvNt9UjfBjAYvm427tPJGcCV7m6DgZ6FqDjC+X3WgCNci 8h+ltCustvRNrRFQdUJCEPppcLeo6G4+MMqDvGtRSh2tLc2ULmeVzuLg51cSrEM25w06zYlP5K0c 7l8x4kQS9Nh99+Uo4a8/kS9xZ+F3REoHFXePNcqKWI1zGW92Wcht6vG8ecXL3QOpU7PHYHabDSel dD7Xf6zJf5tHwG+PE18aBKgUDiBADoPVKdq67WTDOWrD5LHwa6EvXJvVpLZUzIxJwDH2SJaBw5B2 qkSXGK8k6hBBtY2WQ5BRxqNM2huSV8weO0TocBq+lnOJNJ3YBUFQwMEapRE0JprYBZFCJ/2Q+UQ0 LxLEjJ8AG5mS+dRJ/36yJTHdRDOVteeRv3kJPnUhFamNrirBwsUnyZCczA8JAF0U8DdFq4At4jFt Yu/Z89oU+clmz+d4C4YUXoaqB3FDUJOkBRs2P8CZLAgk2KuRFrQ111Mkqz1sUDFPvxiV2YfehE0g nyeGzWSpi+rnQimZgFTk4mJEw1TCIL/ZRP6AfxMmYWCaLUJpPeO1p1gTVzQVEZ0F5YHZGeU812pI VPk+Uae5uD0tyJeN3om07CM7Ye8ZqRh4/7jttlIe1LFxf9LaD8OIWjxNaSoYxLxE10fyaQFaAnvr oum6Bh/ocevRW4OBvLj2pYlX6c9REldqMnXu0xjz72mekVlJovviSRzBlaDWHj0ZqN8BwBUdj6v2 oE0xKD5LU5l8caBoC+FbgUduRLW1lKs6IlMuTBZdxiTS5nUUoeDmuOGO4oVu7G0+iM+s1V80DM2c hkCdZEdhxURxJnxKPRbz0m16ANYdGuMYXkGt1NC6PvF3YSkUO4bBZZgUUlfM0RzXXxctBkbeLPLX 9CWIvK4AapRdG1GTg3PFJ8h6VOEo64KCWfZJZyaBm8XpIJdPt3TohCQOQ9EIk7afqFqN7akKD32j tZ/DVgF25QJKN8hkxqoCu5l4wPYga5FMIwyryyi4A+q5P/Hc91aVLRKt8DkaTI4GgYMbTRz+61RX phE0sXGJIlL1uNlhiePvJz00VQWZnflO1NdGpL9ng/LgNbZr3r85hbcnonmN4k72pFy4+/e2mOqb CR3kC3og69CyenS73x342w62dzsjZYtl3Y2D7tqGIs75OBoLD8OgaziKS5VIF2ZHZbUGpsMPvaGD reiCKjhY+gx6QGf4GhF04qj4+zzi7Q2sBVLC/AwLV42OcWgatQvW3A/XW8GepUKKX0oLfuc5Fpsd Cz2FDAQXDKGbz5SqeKMI4b5imqKKKFm4gYfVjnB1sCA2WA7hDqAzC7bpDVm/3FJlwEtJdd88WUOg kim+QCMzm0qNEUCC3o98fhiNxzj8ROuvCMtySAWEZm0oIFHUHtGNHhX5wW8pW9JbBnP1jM8rHKQ8 1HwxDdS/3BZtJ8qG8JJf1LE5aeoSn8p+HHV9J0Oswqggvlfz5Iy3S/Gy0SdcN6907pxxwfL59Bpw ACZ4vL6HiHb9m9a33Z4gjVySr+OpbYqviuyTHHZ5YvWFrLIVb8osgwxhq/1qXOZcirMKhdHWv3Cz /9e0ImrBAxIiwVItRXGyridRLJ41vODj00YZJ1J9WrTDRJBE5JjAycFNd/dIFbM3Y30fPf3xv/Ly Kmu8IkZoOVEnABftUyRrKJ+SUUyFmQTklL7Vrt/uGVaQj2rODs4/9cte9N6W+NPIOG5yXJB0A0UQ 87/mPG+HMRZQx6AtsCgRCaqW1WtMiD4cZn4A9DqNyjyBn8INd0xs7OYq13tDaqwuakITNFTkMjVB TwdOc0u+HbQLPpT/H6SUuWLCL7fY0MK3VLr3Prhpa/KfmLhRv6hA1/IfJWi2c7Oj1BWArPvDgAEv lhSndeCokudx5OXt2wzPgdOKnzc99cNhJlOrPbwBNuvdOCw4/62A9NzGk53ISJCD7vGP7tGtvHn/ UxO8NXVGs4JC3EmcFbXTSVacfB/nH7Pj74Tqn9rBTUReLW3HDjI8U4GJ4THkoUJLH/Kmxmm6adMF di+NEq05DnOw84glInBN13rXb8MCz/T7+AUEsEr8Mg0MWxUqK+McTIeLwv6khpUefqmJaSksA17s cLWOqDYQytp76dl9DWHn4FaYF9vfkL51CWbqPOchz9j1M4vItnnyq0kLM/c5KO85+plIuVZf+W4w 7P4nhz+mIjO7sZeJwd5+jB/d7+GoAmnjdKyHrL6iXSkd6oNqVyPoupN08A25jEMhqB1FKQptAwAg 7w+MQum9h82Rb1KmjHG8XSUgK/kjef3MQqygJnbCa/6UGQoBZYu5Xu0KPYehNfK1zufrKGXRjwWa Z4pcFH9CVtKbTi8l+Vg81g8jP6kSLG0arlG1ztVDzwY2Ho6oqwNBJdmqLHY1jmAswE98iF/ToJch DuV9vrBts8XTA9aUDFGYMRd0RWC1c2cyvgop4RlMYiRWXrhO1Lnv2UOpLoxDxNOXV+z6pvQ2Wwec SYePgg9rqyD9LQp9PwO4v0Lr42YFIx+qFRPikfhqNFkRaiBq4olWXUegePyV+R9rS4wLZCBvfK5K lDsZsEsyepfK+aaUULnlO5rX8YMr76gV75TFXCNYGXdM2aAL2XunFdQdliI4L0tPX7Ly+GO5pwX3 1IVRnOjc0kYduMNsFMPgMap3wlEClh82jitLkIp42eQwGItnqK9bfECp3ChE9UwwxCDgNN8VF+wV YOrFKV5fUaW1sY6GssarcyAlYNLJJASYl7gJyQ5a6KCPqnDSMVv3fBvc2n/j7AeaC7rA3qkBnjSX QrcmPA/tt17nz7kYtfH5nv9fLO2S1aZtyW2di1BcMTKRJwNVc4ok/wtqUTyvwZNGbqoJdRC/Om5n ZEO/GGNxeTgu1ZyLDK7eIjmNCUDep5s3AqFguWQngJud6t/o3SSMzcJjNHTCtJPJtVjE8lUuUEts HPgPdLmwWtItEr9480ghGD+WjCHCmFh6hO3slHAUjYsApQhg9J3cs5wBUiyhpg4XVLM454TxEPDJ DJTSTQe9lQ8QrZLax71PepiUPzXoZOLEsx//qSeiZbuiqEpkgQvT16Cq0HG4qdPGQlBmSdkQxpCS OPvBPK/GRU4yghXXhE4XMS++iLpkFRsPHPBuaoA5UmPH9ClkqUWSCvR7W+9XaQlYlRJVe9lA8peg mXKh+uzx2WB5x1x5zviUMo/JsKjh6JhFNXlnkPvDlWlKHo8nOPq2u4W7YLwsyQBl1rFuuKeZyh90 3fDuAADoBsfRdPtRzQABx/QModtTOZjOcLHEZ/sCAAAAAARZWg== --BS73ox2G6DZ7ACPo Content-Type: text/plain; charset=us-ascii Content-Disposition: attachment; filename="incremental.patch" --- libcpp/charset.cc.jj 2022-08-21 19:03:48.747215419 +0200 +++ libcpp/charset.cc 2022-08-21 19:39:04.717421624 +0200 @@ -944,6 +944,7 @@ struct uname2c_data { char *canon_name; char prev_char; + char *spellcheck; }; /* Map NAME, a Unicode character name or correction/control/alternate @@ -1006,6 +1007,11 @@ _cpp_uname2c (const char *name, size_t l ret = memcmp (name, key, len > key_len ? key_len : len); len_adj = key_len; } + else if (data->spellcheck) + { + ret = 0; + len_adj = 0; + } else { const char *p = name, *q = key; @@ -1076,7 +1082,54 @@ _cpp_uname2c (const char *name, size_t l { name += len_adj; len -= len_adj; - if (codepoint == 0xd800) + if (__builtin_expect (data != NULL, 0) && data->spellcheck) + { + memcpy (data->canon_name, key, key_len); + if (codepoint == 0xd800) + { + /* NR1 - Hangul syllables. */ + size_t i, j, k, s1 = hangul_count[0] + hangul_count[1]; + size_t s2 = s1 + hangul_count[2]; + + for (i = 0; i < (size_t) hangul_count[0]; ++i) + { + strcpy (data->canon_name + key_len, + hangul_syllables[i]); + char *p1 = strchr (data->canon_name + key_len, '\0'); + for (j = hangul_count[0]; j < s1; ++j) + { + strcpy (p1, hangul_syllables[j]); + char *p2 = strchr (p1, '\0'); + for (k = s1; k < s2; ++k) + { + strcpy (p2, hangul_syllables[k]); + /* In place of get_edit_distance etc. */ + fprintf (stderr, "%s\n", data->spellcheck); + } + } + } + } + else + { + /* NR2 - prefix followed by hexadecimal codepoint. */ + const cppchar_t *p + = (uname2c_pairs + + uname2c_generated[codepoint - 0xd800]); + for (; *p; p += 2) + { + cppchar_t c; + + for (c = p[0]; c <= p[1]; ++c) + { + sprintf (data->canon_name + key_len, "%lX", + (long) c); + /* In place of get_edit_distance etc. */ + fprintf (stderr, "%s\n", data->spellcheck); + } + } + } + } + else if (codepoint == 0xd800) { /* NR1 - Hangul syllables. */ size_t start = 0, end, i, j; @@ -1158,7 +1211,17 @@ _cpp_uname2c (const char *name, size_t l } else if (__builtin_expect (data != NULL, 0)) { - if (len == len_adj) + if (data->spellcheck) + { + if (codepoint != (cppchar_t) -1) + { + memcpy (data->canon_name, key, key_len); + data->canon_name[key_len] = '\0'; + /* In place of get_edit_distance etc. */ + fprintf (stderr, "%s\n", data->spellcheck); + } + } + else if (len == len_adj) { memcpy (data->canon_name, key, key_len); data->canon_name[key_len] = '\0'; @@ -1490,6 +1553,7 @@ _cpp_valid_ucn (cpp_reader *pfile, const struct uname2c_data data; data.canon_name = canon_name; data.prev_char = ' '; + data.spellcheck = NULL; /* Hangul Jungseong O- E after UAX44-LM2 should be HANGULJUNGSEONGO-E and so should match U+1180. */ --BS73ox2G6DZ7ACPo--