From fbb00383d82da5ce375f1b034d3fb9ebdd9a8f0e Mon Sep 17 00:00:00 2001 From: Martin Hosken Date: Sat, 12 Dec 2015 11:36:53 +0700 Subject: [PATCH] Use .dict files since below the 500K limit Change-Id: Iec71ad4918cd333f0a44d372017ecee300e3aca9 Reviewed-on: https://gerrit.libreoffice.org/20748 Tested-by: Jenkins Reviewed-by: Martin Hosken --- external/icu/UnpackedTarball_icu.mk | 3 + external/icu/khmerbreakengine.patch | 1403 +++++++++++++++++ external/icu/khmerdict.dict | Bin 0 -> 211340 bytes .../breakiterator/breakiterator_unicode.cxx | 2 +- 4 files changed, 1407 insertions(+), 1 deletion(-) create mode 100644 external/icu/khmerbreakengine.patch create mode 100644 external/icu/khmerdict.dict diff --git a/external/icu/UnpackedTarball_icu.mk b/external/icu/UnpackedTarball_icu.mk index c48d02556d2d..4a6a11477af3 100644 --- a/external/icu/UnpackedTarball_icu.mk +++ b/external/icu/UnpackedTarball_icu.mk @@ -27,6 +27,9 @@ $(eval $(call gb_UnpackedTarball_add_patches,icu,\ external/icu/clang-cl.patch.0 \ $(if $(filter-out ANDROID,$(OS)),external/icu/icu4c-icudata-stdlibs.diff) \ $(if $(filter EMSCRIPTEN,$(OS)),external/icu/icu4c-emscripten.patch.1) \ + external/icu/khmerbreakengine.patch \ )) +$(eval $(call gb_UnpackedTarball_add_file,icu,source/data/brkitr/khmerdict.dict,external/icu/khmerdict.dict)) + # vim: set noet sw=4 ts=4: diff --git a/external/icu/khmerbreakengine.patch b/external/icu/khmerbreakengine.patch new file mode 100644 index 000000000000..03e6079b19f0 --- /dev/null +++ b/external/icu/khmerbreakengine.patch @@ -0,0 +1,1403 @@ +diff --git a/source/common/dictbe.cpp b/source/common/dictbe.cpp +index f1c874d..3ad1b3f 100644 +--- misc/icu/source/common/dictbe.cpp ++++ build/icu/source/common/dictbe.cpp +@@ -27,8 +27,16 @@ U_NAMESPACE_BEGIN + ****************************************************************** + */ + +-DictionaryBreakEngine::DictionaryBreakEngine(uint32_t breakTypes) { ++DictionaryBreakEngine::DictionaryBreakEngine(uint32_t breakTypes) : ++ clusterLimit(3) ++{ ++ UErrorCode status = U_ZERO_ERROR; + fTypes = breakTypes; ++ fViramaSet.applyPattern(UNICODE_STRING_SIMPLE("[[:ccc=VR:]]"), status); ++ ++ fSkipStartSet.applyPattern(UNICODE_STRING_SIMPLE("[[:lb=OP:][:lb=QU:]]"), status); ++ fSkipEndSet.applyPattern(UNICODE_STRING_SIMPLE("[[:lb=CP:][:lb=QU:][:lb=EX:][:lb=CL:]]"), status); ++ fNBeforeSet.applyPattern(UNICODE_STRING_SIMPLE("[[:lb=CR:][:lb=LF:][:lb=NL:][:lb=SP:][:lb=ZW:][:lb=IS:][:lb=BA:][:lb=NS:]]"), status); + } + + DictionaryBreakEngine::~DictionaryBreakEngine() { +@@ -90,7 +98,7 @@ DictionaryBreakEngine::findBreaks( UText *text, + result = divideUpDictionaryRange(text, rangeStart, rangeEnd, foundBreaks); + utext_setNativeIndex(text, current); + } +- ++ + return result; + } + +@@ -101,6 +109,163 @@ DictionaryBreakEngine::setCharacters( const UnicodeSet &set ) { + fSet.compact(); + } + ++bool ++DictionaryBreakEngine::scanBeforeStart(UText *text, int32_t& start, bool &doBreak) const { ++ UErrorCode status = U_ZERO_ERROR; ++ UText* ut = utext_clone(NULL, text, false, true, &status); ++ utext_setNativeIndex(ut, start); ++ UChar32 c = utext_current32(ut); ++ bool res = false; ++ doBreak = true; ++ while (start >= 0) { ++ if (!fSkipStartSet.contains(c)) { ++ res = (c == ZWSP); ++ break; ++ } ++ --start; ++ c = utext_previous32(ut); ++ doBreak = false; ++ } ++ utext_close(ut); ++ return res; ++} ++ ++bool ++DictionaryBreakEngine::scanAfterEnd(UText *text, int32_t textEnd, int32_t& end, bool &doBreak) const { ++ UErrorCode status = U_ZERO_ERROR; ++ UText* ut = utext_clone(NULL, text, false, true, &status); ++ utext_setNativeIndex(ut, end); ++ UChar32 c = utext_current32(ut); ++ bool res = false; ++ doBreak = !fNBeforeSet.contains(c); ++ while (end < textEnd) { ++ if (!fSkipEndSet.contains(c)) { ++ res = (c == ZWSP); ++ break; ++ } ++ ++end; ++ c = utext_next32(ut); ++ doBreak = false; ++ } ++ utext_close(ut); ++ return res; ++} ++ ++void ++DictionaryBreakEngine::scanBackClusters(UText *text, int32_t textStart, int32_t& start) const { ++ UChar32 c = 0; ++ start = utext_getNativeIndex(text); ++ while (start > textStart) { ++ c = utext_previous32(text); ++ --start; ++ if (!fSkipEndSet.contains(c)) ++ break; ++ } ++ for (int i = 0; i < clusterLimit; ++i) { // scan backwards clusterLimit clusters ++ while (start > textStart) { ++ if (!fMarkSet.contains(c)) { ++ if (fBaseSet.contains(c)) { ++ c = utext_previous32(text); ++ if (!fViramaSet.contains(c)) { // Virama (e.g. coeng) preceding base. Treat sequence as a mark ++ utext_next32(text); ++ c = utext_current32(text); ++ break; ++ } else { ++ --start; ++ } ++ } else { ++ break; ++ } ++ } ++ c = utext_previous32(text); ++ --start; ++ } ++ if (!fBaseSet.contains(c) || start < textStart) { // not a cluster start so finish ++ break; ++ } ++ c = utext_previous32(text); ++ --start; // go round again ++ } // ignore hitting previous inhibitor since scanning for it should have found us! ++ ++start; // counteract --before ++} ++ ++void ++DictionaryBreakEngine::scanFwdClusters(UText *text, int32_t textEnd, int32_t& end) const { ++ UChar32 c = utext_current32(text); ++ end = utext_getNativeIndex(text); ++ while (end < textEnd) { ++ if (!fSkipStartSet.contains(c)) ++ break; ++ utext_next32(text); ++ c = utext_current32(text); ++ ++end; ++ } ++ for (int i = 0; i < clusterLimit; ++i) { // scan forwards clusterLimit clusters ++ if (fBaseSet.contains(c)) { ++ while (end < textEnd) { ++ utext_next32(text); ++ c = utext_current32(text); ++ ++end; ++ if (!fMarkSet.contains(c)) ++ break; ++ else if (fViramaSet.contains(c)) { // handle coeng + base as mark ++ utext_next32(text); ++ c = utext_current32(text); ++ ++end; ++ if (!fBaseSet.contains(c)) ++ break; ++ } ++ } ++ } else { ++ --end; // bad char so break after char before it ++ break; ++ } ++ } ++} ++ ++bool ++DictionaryBreakEngine::scanWJ(UText *text, int32_t &start, int32_t end, int32_t &before, int32_t &after) const { ++ UErrorCode status = U_ZERO_ERROR; ++ UText* ut = utext_clone(NULL, text, false, true, &status); ++ int32_t nat = start; ++ utext_setNativeIndex(ut, nat); ++ bool foundFirst = true; ++ int32_t curr = start; ++ while (nat < end) { ++ UChar32 c = utext_current32(ut); ++ if (c == ZWSP || c == WJ) { ++ curr = nat + 1; ++ if (foundFirst) // only scan backwards for first inhibitor ++ scanBackClusters(ut, start, before); ++ foundFirst = false; // don't scan backwards if we go around again. Also marks found something ++ ++ utext_next32(ut); ++ scanFwdClusters(ut, end, after); ++ nat = after + 1; ++ ++ if (c == ZWSP || c == WJ) { // did we hit another one? ++ continue; ++ } else { ++ break; ++ } ++ } ++ ++ ++nat; // keep hunting ++ utext_next32(ut); ++ } ++ ++ utext_close(ut); ++ ++ if (nat >= end && foundFirst) { ++ start = before = after = nat; ++ return false; // failed to find anything ++ } ++ else { ++ start = curr; ++ } ++ return true; // yup hit one ++} ++ + /* + ****************************************************************** + * PossibleWord +@@ -128,35 +293,35 @@ private: + public: + PossibleWord() : count(0), prefix(0), offset(-1), mark(0), current(0) {}; + ~PossibleWord() {}; +- ++ + // Fill the list of candidates if needed, select the longest, and return the number found +- int32_t candidates( UText *text, DictionaryMatcher *dict, int32_t rangeEnd ); +- ++ int32_t candidates( UText *text, DictionaryMatcher *dict, int32_t rangeEnd, UnicodeSet const *ignoreSet = NULL, int32_t minLength = 0 ); ++ + // Select the currently marked candidate, point after it in the text, and invalidate self + int32_t acceptMarked( UText *text ); +- ++ + // Back up from the current candidate to the next shorter one; return TRUE if that exists + // and point the text after it + UBool backUp( UText *text ); +- ++ + // Return the longest prefix this candidate location shares with a dictionary word + // Return value is in code points. + int32_t longestPrefix() { return prefix; }; +- ++ + // Mark the current candidate as the one we like + void markCurrent() { mark = current; }; +- ++ + // Get length in code points of the marked word. + int32_t markedCPLength() { return cpLengths[mark]; }; + }; + + +-int32_t PossibleWord::candidates( UText *text, DictionaryMatcher *dict, int32_t rangeEnd ) { ++int32_t PossibleWord::candidates( UText *text, DictionaryMatcher *dict, int32_t rangeEnd, UnicodeSet const *ignoreSet, int32_t minLength) { + // TODO: If getIndex is too slow, use offset < 0 and add discardAll() + int32_t start = (int32_t)utext_getNativeIndex(text); + if (start != offset) { + offset = start; +- count = dict->matches(text, rangeEnd-start, UPRV_LENGTHOF(cuLengths), cuLengths, cpLengths, NULL, &prefix); ++ count = dict->matches(text, rangeEnd-start, UPRV_LENGTHOF(cuLengths), cuLengths, cpLengths, NULL, &prefix, ignoreSet, minLength); + // Dictionary leaves text after longest prefix, not longest word. Back up. + if (count <= 0) { + utext_setNativeIndex(text, start); +@@ -261,16 +426,16 @@ ThaiBreakEngine::divideUpDictionaryRange( UText *text, + int32_t current; + UErrorCode status = U_ZERO_ERROR; + PossibleWord words[THAI_LOOKAHEAD]; +- ++ + utext_setNativeIndex(text, rangeStart); +- ++ + while (U_SUCCESS(status) && (current = (int32_t)utext_getNativeIndex(text)) < rangeEnd) { + cpWordLength = 0; + cuWordLength = 0; + + // Look for candidate words at the current position + int32_t candidates = words[wordsFound%THAI_LOOKAHEAD].candidates(text, fDictionary, rangeEnd); +- ++ + // If we found exactly one, use that + if (candidates == 1) { + cuWordLength = words[wordsFound % THAI_LOOKAHEAD].acceptMarked(text); +@@ -291,12 +456,12 @@ ThaiBreakEngine::divideUpDictionaryRange( UText *text, + words[wordsFound%THAI_LOOKAHEAD].markCurrent(); + wordsMatched = 2; + } +- ++ + // If we're already at the end of the range, we're done + if ((int32_t)utext_getNativeIndex(text) >= rangeEnd) { + goto foundBest; + } +- ++ + // See if any of the possible second words is followed by a third word + do { + // If we find a third word, stop right away +@@ -315,13 +480,13 @@ foundBest: + cpWordLength = words[wordsFound % THAI_LOOKAHEAD].markedCPLength(); + wordsFound += 1; + } +- ++ + // We come here after having either found a word or not. We look ahead to the + // next word. If it's not a dictionary word, we will combine it with the word we + // just found (if there is one), but only if the preceding word does not exceed + // the threshold. + // The text iterator should now be positioned at the end of the word we found. +- ++ + UChar32 uc = 0; + if ((int32_t)utext_getNativeIndex(text) < rangeEnd && cpWordLength < THAI_ROOT_COMBINE_THRESHOLD) { + // if it is a dictionary word, do nothing. If it isn't, then if there is +@@ -357,12 +522,12 @@ foundBest: + } + } + } +- ++ + // Bump the word count if there wasn't already one + if (cuWordLength <= 0) { + wordsFound += 1; + } +- ++ + // Update the length with the passed-over characters + cuWordLength += chars; + } +@@ -371,14 +536,14 @@ foundBest: + utext_setNativeIndex(text, current+cuWordLength); + } + } +- ++ + // Never stop before a combining mark. + int32_t currPos; + while ((currPos = (int32_t)utext_getNativeIndex(text)) < rangeEnd && fMarkSet.contains(utext_current32(text))) { + utext_next32(text); + cuWordLength += (int32_t)utext_getNativeIndex(text) - currPos; + } +- ++ + // Look ahead for possible suffixes if a dictionary word does not follow. + // We do this in code rather than using a rule so that the heuristic + // resynch continues to function. For example, one of the suffix characters +@@ -496,16 +661,16 @@ LaoBreakEngine::divideUpDictionaryRange( UText *text, + int32_t current; + UErrorCode status = U_ZERO_ERROR; + PossibleWord words[LAO_LOOKAHEAD]; +- ++ + utext_setNativeIndex(text, rangeStart); +- ++ + while (U_SUCCESS(status) && (current = (int32_t)utext_getNativeIndex(text)) < rangeEnd) { + cuWordLength = 0; + cpWordLength = 0; + + // Look for candidate words at the current position + int32_t candidates = words[wordsFound%LAO_LOOKAHEAD].candidates(text, fDictionary, rangeEnd); +- ++ + // If we found exactly one, use that + if (candidates == 1) { + cuWordLength = words[wordsFound % LAO_LOOKAHEAD].acceptMarked(text); +@@ -526,12 +691,12 @@ LaoBreakEngine::divideUpDictionaryRange( UText *text, + words[wordsFound%LAO_LOOKAHEAD].markCurrent(); + wordsMatched = 2; + } +- ++ + // If we're already at the end of the range, we're done + if ((int32_t)utext_getNativeIndex(text) >= rangeEnd) { + goto foundBest; + } +- ++ + // See if any of the possible second words is followed by a third word + do { + // If we find a third word, stop right away +@@ -549,7 +714,7 @@ foundBest: + cpWordLength = words[wordsFound % LAO_LOOKAHEAD].markedCPLength(); + wordsFound += 1; + } +- ++ + // We come here after having either found a word or not. We look ahead to the + // next word. If it's not a dictionary word, we will combine it withe the word we + // just found (if there is one), but only if the preceding word does not exceed +@@ -587,12 +752,12 @@ foundBest: + } + } + } +- ++ + // Bump the word count if there wasn't already one + if (cuWordLength <= 0) { + wordsFound += 1; + } +- ++ + // Update the length with the passed-over characters + cuWordLength += chars; + } +@@ -601,14 +766,14 @@ foundBest: + utext_setNativeIndex(text, current + cuWordLength); + } + } +- ++ + // Never stop before a combining mark. + int32_t currPos; + while ((currPos = (int32_t)utext_getNativeIndex(text)) < rangeEnd && fMarkSet.contains(utext_current32(text))) { + utext_next32(text); + cuWordLength += (int32_t)utext_getNativeIndex(text) - currPos; + } +- ++ + // Look ahead for possible suffixes if a dictionary word does not follow. + // We do this in code rather than using a rule so that the heuristic + // resynch continues to function. For example, one of the suffix characters +@@ -689,16 +854,16 @@ BurmeseBreakEngine::divideUpDictionaryRange( UText *text, + int32_t current; + UErrorCode status = U_ZERO_ERROR; + PossibleWord words[BURMESE_LOOKAHEAD]; +- ++ + utext_setNativeIndex(text, rangeStart); +- ++ + while (U_SUCCESS(status) && (current = (int32_t)utext_getNativeIndex(text)) < rangeEnd) { + cuWordLength = 0; + cpWordLength = 0; + + // Look for candidate words at the current position + int32_t candidates = words[wordsFound%BURMESE_LOOKAHEAD].candidates(text, fDictionary, rangeEnd); +- ++ + // If we found exactly one, use that + if (candidates == 1) { + cuWordLength = words[wordsFound % BURMESE_LOOKAHEAD].acceptMarked(text); +@@ -719,12 +884,12 @@ BurmeseBreakEngine::divideUpDictionaryRange( UText *text, + words[wordsFound%BURMESE_LOOKAHEAD].markCurrent(); + wordsMatched = 2; + } +- ++ + // If we're already at the end of the range, we're done + if ((int32_t)utext_getNativeIndex(text) >= rangeEnd) { + goto foundBest; + } +- ++ + // See if any of the possible second words is followed by a third word + do { + // If we find a third word, stop right away +@@ -742,7 +907,7 @@ foundBest: + cpWordLength = words[wordsFound % BURMESE_LOOKAHEAD].markedCPLength(); + wordsFound += 1; + } +- ++ + // We come here after having either found a word or not. We look ahead to the + // next word. If it's not a dictionary word, we will combine it withe the word we + // just found (if there is one), but only if the preceding word does not exceed +@@ -780,12 +945,12 @@ foundBest: + } + } + } +- ++ + // Bump the word count if there wasn't already one + if (cuWordLength <= 0) { + wordsFound += 1; + } +- ++ + // Update the length with the passed-over characters + cuWordLength += chars; + } +@@ -794,14 +959,14 @@ foundBest: + utext_setNativeIndex(text, current + cuWordLength); + } + } +- ++ + // Never stop before a combining mark. + int32_t currPos; + while ((currPos = (int32_t)utext_getNativeIndex(text)) < rangeEnd && fMarkSet.contains(utext_current32(text))) { + utext_next32(text); + cuWordLength += (int32_t)utext_getNativeIndex(text) - currPos; + } +- ++ + // Look ahead for possible suffixes if a dictionary word does not follow. + // We do this in code rather than using a rule so that the heuristic + // resynch continues to function. For example, one of the suffix characters +@@ -828,51 +993,29 @@ foundBest: + * KhmerBreakEngine + */ + +-// How many words in a row are "good enough"? +-static const int32_t KHMER_LOOKAHEAD = 3; +- +-// Will not combine a non-word with a preceding dictionary word longer than this +-static const int32_t KHMER_ROOT_COMBINE_THRESHOLD = 3; +- +-// Will not combine a non-word that shares at least this much prefix with a +-// dictionary word, with a preceding word +-static const int32_t KHMER_PREFIX_COMBINE_THRESHOLD = 3; +- +-// Minimum word size +-static const int32_t KHMER_MIN_WORD = 2; +- +-// Minimum number of characters for two words +-static const int32_t KHMER_MIN_WORD_SPAN = KHMER_MIN_WORD * 2; +- + KhmerBreakEngine::KhmerBreakEngine(DictionaryMatcher *adoptDictionary, UErrorCode &status) + : DictionaryBreakEngine((1 << UBRK_WORD) | (1 << UBRK_LINE)), + fDictionary(adoptDictionary) + { +- fKhmerWordSet.applyPattern(UNICODE_STRING_SIMPLE("[[:Khmr:]&[:LineBreak=SA:]]"), status); ++ ++ clusterLimit = 3; ++ ++ fKhmerWordSet.applyPattern(UNICODE_STRING_SIMPLE("[[:Khmr:]\\u2060\\u200C\\u200D]"), status); + if (U_SUCCESS(status)) { + setCharacters(fKhmerWordSet); + } + fMarkSet.applyPattern(UNICODE_STRING_SIMPLE("[[:Khmr:]&[:LineBreak=SA:]&[:M:]]"), status); + fMarkSet.add(0x0020); +- fEndWordSet = fKhmerWordSet; +- fBeginWordSet.add(0x1780, 0x17B3); +- //fBeginWordSet.add(0x17A3, 0x17A4); // deprecated vowels +- //fEndWordSet.remove(0x17A5, 0x17A9); // Khmer independent vowels that can't end a word +- //fEndWordSet.remove(0x17B2); // Khmer independent vowel that can't end a word +- fEndWordSet.remove(0x17D2); // KHMER SIGN COENG that combines some following characters +- //fEndWordSet.remove(0x17B6, 0x17C5); // Remove dependent vowels +-// fEndWordSet.remove(0x0E31); // MAI HAN-AKAT +-// fEndWordSet.remove(0x0E40, 0x0E44); // SARA E through SARA AI MAIMALAI +-// fBeginWordSet.add(0x0E01, 0x0E2E); // KO KAI through HO NOKHUK +-// fBeginWordSet.add(0x0E40, 0x0E44); // SARA E through SARA AI MAIMALAI +-// fSuffixSet.add(THAI_PAIYANNOI); +-// fSuffixSet.add(THAI_MAIYAMOK); ++ fIgnoreSet.add(0x2060); // WJ ++ fIgnoreSet.add(0x200C, 0x200D); // ZWJ, ZWNJ ++ fBaseSet.applyPattern(UNICODE_STRING_SIMPLE("[[:Khmr:]&[:^M:]]"), status); ++ fPuncSet.applyPattern(UNICODE_STRING_SIMPLE("[\\u17D4\\u17D5\\u17D6\\u17D7\\u17D9:]"), status); + + // Compact for caching. + fMarkSet.compact(); +- fEndWordSet.compact(); +- fBeginWordSet.compact(); +-// fSuffixSet.compact(); ++ fIgnoreSet.compact(); ++ fBaseSet.compact(); ++ fPuncSet.compact(); + } + + KhmerBreakEngine::~KhmerBreakEngine() { +@@ -884,180 +1027,204 @@ KhmerBreakEngine::divideUpDictionaryRange( UText *text, + int32_t rangeStart, + int32_t rangeEnd, + UStack &foundBreaks ) const { +- if ((rangeEnd - rangeStart) < KHMER_MIN_WORD_SPAN) { +- return 0; // Not enough characters for two words ++ uint32_t wordsFound = foundBreaks.size(); ++ UErrorCode status = U_ZERO_ERROR; ++ int32_t before = 0; ++ int32_t after = 0; ++ int32_t finalBefore = 0; ++ int32_t initAfter = 0; ++ int32_t scanStart = rangeStart; ++ int32_t scanEnd = rangeEnd; ++ ++ bool startZwsp = false; ++ bool breakStart = false; ++ bool breakEnd = false; ++ ++ if (rangeStart > 0) { ++ --scanStart; ++ startZwsp = scanBeforeStart(text, scanStart, breakStart); ++ } ++ utext_setNativeIndex(text, rangeStart); ++ scanFwdClusters(text, rangeEnd, initAfter); ++ bool endZwsp = scanAfterEnd(text, utext_nativeLength(text), scanEnd, breakEnd); ++ utext_setNativeIndex(text, rangeEnd - 1); ++ scanBackClusters(text, rangeStart, finalBefore); ++ if (finalBefore < initAfter) { // the whole run is tented so no breaks ++ if (breakStart || fTypes < UBRK_LINE) ++ foundBreaks.push(rangeStart, status); ++ if (breakEnd || fTypes < UBRK_LINE) ++ foundBreaks.push(rangeEnd, status); ++ return foundBreaks.size() - wordsFound; + } + +- uint32_t wordsFound = 0; +- int32_t cpWordLength = 0; +- int32_t cuWordLength = 0; +- int32_t current; +- UErrorCode status = U_ZERO_ERROR; +- PossibleWord words[KHMER_LOOKAHEAD]; ++ scanStart = rangeStart; ++ scanWJ(text, scanStart, rangeEnd, before, after); ++ if (startZwsp || initAfter >= before) { ++ after = initAfter; ++ before = 0; ++ } ++ if (!endZwsp && after > finalBefore && after < rangeEnd) ++ endZwsp = true; ++ if (endZwsp && before > finalBefore) ++ before = finalBefore; + + utext_setNativeIndex(text, rangeStart); ++ int32_t numCodePts = rangeEnd - rangeStart; ++ // bestSnlp[i] is the snlp of the best segmentation of the first i ++ // code points in the range to be matched. ++ UVector32 bestSnlp(numCodePts + 1, status); ++ bestSnlp.addElement(0, status); ++ for(int32_t i = 1; i <= numCodePts; i++) { ++ bestSnlp.addElement(kuint32max, status); ++ } + +- while (U_SUCCESS(status) && (current = (int32_t)utext_getNativeIndex(text)) < rangeEnd) { +- cuWordLength = 0; +- cpWordLength = 0; ++ // prev[i] is the index of the last code point in the previous word in ++ // the best segmentation of the first i characters. Note negative implies ++ // that the code point is part of an unknown word. ++ UVector32 prev(numCodePts + 1, status); ++ for(int32_t i = 0; i <= numCodePts; i++) { ++ prev.addElement(kuint32max, status); ++ } + +- // Look for candidate words at the current position +- int32_t candidates = words[wordsFound%KHMER_LOOKAHEAD].candidates(text, fDictionary, rangeEnd); ++ const int32_t maxWordSize = 20; ++ UVector32 values(maxWordSize, status); ++ values.setSize(maxWordSize); ++ UVector32 lengths(maxWordSize, status); ++ lengths.setSize(maxWordSize); + +- // If we found exactly one, use that +- if (candidates == 1) { +- cuWordLength = words[wordsFound % KHMER_LOOKAHEAD].acceptMarked(text); +- cpWordLength = words[wordsFound % KHMER_LOOKAHEAD].markedCPLength(); +- wordsFound += 1; +- } ++ // Dynamic programming to find the best segmentation. + +- // If there was more than one, see which one can take us forward the most words +- else if (candidates > 1) { +- // If we're already at the end of the range, we're done +- if ((int32_t)utext_getNativeIndex(text) >= rangeEnd) { +- goto foundBest; +- } +- do { +- int32_t wordsMatched = 1; +- if (words[(wordsFound + 1) % KHMER_LOOKAHEAD].candidates(text, fDictionary, rangeEnd) > 0) { +- if (wordsMatched < 2) { +- // Followed by another dictionary word; mark first word as a good candidate +- words[wordsFound % KHMER_LOOKAHEAD].markCurrent(); +- wordsMatched = 2; +- } ++ // In outer loop, i is the code point index, ++ // ix is the corresponding string (code unit) index. ++ // They differ when the string contains supplementary characters. ++ int32_t ix = rangeStart; ++ for (int32_t i = 0; i < numCodePts; ++i, utext_setNativeIndex(text, ++ix)) { ++ if ((uint32_t)bestSnlp.elementAti(i) == kuint32max) { ++ continue; ++ } + +- // If we're already at the end of the range, we're done +- if ((int32_t)utext_getNativeIndex(text) >= rangeEnd) { +- goto foundBest; +- } ++ int32_t count; ++ count = fDictionary->matches(text, numCodePts - i, maxWordSize, ++ NULL, lengths.getBuffer(), values.getBuffer(), NULL, &fIgnoreSet, 2); ++ // Note: lengths is filled with code point lengths ++ // The NULL parameter is the ignored code unit lengths. + +- // See if any of the possible second words is followed by a third word +- do { +- // If we find a third word, stop right away +- if (words[(wordsFound + 2) % KHMER_LOOKAHEAD].candidates(text, fDictionary, rangeEnd)) { +- words[wordsFound % KHMER_LOOKAHEAD].markCurrent(); +- goto foundBest; +- } +- } +- while (words[(wordsFound + 1) % KHMER_LOOKAHEAD].backUp(text)); +- } ++ for (int32_t j = 0; j < count; j++) { ++ int32_t ln = lengths.elementAti(j); ++ if (ln + i >= numCodePts) ++ continue; ++ utext_setNativeIndex(text, ln+ix); ++ int32_t c = utext_current32(text); ++ if (fMarkSet.contains(c) || c == 0x17D2) { // Coeng ++ lengths.removeElementAt(j); ++ values.removeElementAt(j); ++ --j; ++ --count; + } +- while (words[wordsFound % KHMER_LOOKAHEAD].backUp(text)); +-foundBest: +- cuWordLength = words[wordsFound % KHMER_LOOKAHEAD].acceptMarked(text); +- cpWordLength = words[wordsFound % KHMER_LOOKAHEAD].markedCPLength(); +- wordsFound += 1; + } +- +- // We come here after having either found a word or not. We look ahead to the +- // next word. If it's not a dictionary word, we will combine it with the word we +- // just found (if there is one), but only if the preceding word does not exceed +- // the threshold. +- // The text iterator should now be positioned at the end of the word we found. +- if ((int32_t)utext_getNativeIndex(text) < rangeEnd && cpWordLength < KHMER_ROOT_COMBINE_THRESHOLD) { +- // if it is a dictionary word, do nothing. If it isn't, then if there is +- // no preceding word, or the non-word shares less than the minimum threshold +- // of characters with a dictionary word, then scan to resynchronize +- if (words[wordsFound % KHMER_LOOKAHEAD].candidates(text, fDictionary, rangeEnd) <= 0 +- && (cuWordLength == 0 +- || words[wordsFound % KHMER_LOOKAHEAD].longestPrefix() < KHMER_PREFIX_COMBINE_THRESHOLD)) { +- // Look for a plausible word boundary +- int32_t remaining = rangeEnd - (current+cuWordLength); +- UChar32 pc; +- UChar32 uc; +- int32_t chars = 0; +- for (;;) { +- int32_t pcIndex = utext_getNativeIndex(text); +- pc = utext_next32(text); +- int32_t pcSize = utext_getNativeIndex(text) - pcIndex; +- chars += pcSize; +- remaining -= pcSize; +- if (remaining <= 0) { ++ if (count == 0) { ++ utext_setNativeIndex(text, ix); ++ int32_t c = utext_current32(text); ++ if (fPuncSet.contains(c) || c == ZWSP || c == WJ) { ++ values.setElementAt(0, count); ++ lengths.setElementAt(1, count++); ++ } else if (fBaseSet.contains(c)) { ++ int32_t currix = utext_getNativeIndex(text); ++ do { ++ utext_next32(text); ++ c = utext_current32(text); ++ if (utext_getNativeIndex(text) >= rangeEnd) + break; +- } +- uc = utext_current32(text); +- if (fEndWordSet.contains(pc) && fBeginWordSet.contains(uc)) { +- // Maybe. See if it's in the dictionary. +- int32_t candidates = words[(wordsFound + 1) % KHMER_LOOKAHEAD].candidates(text, fDictionary, rangeEnd); +- utext_setNativeIndex(text, current+cuWordLength+chars); +- if (candidates > 0) { ++ if (c == 0x17D2) { // Coeng ++ utext_next32(text); ++ c = utext_current32(text); ++ if (!fBaseSet.contains(c) || utext_getNativeIndex(text) >= rangeEnd) { + break; ++ } else { ++ utext_next32(text); ++ c = utext_current32(text); ++ if (utext_getNativeIndex(text) >= rangeEnd) ++ break; + } + } +- } +- +- // Bump the word count if there wasn't already one +- if (cuWordLength <= 0) { +- wordsFound += 1; +- } ++ } while (fMarkSet.contains(c)); ++ values.setElementAt(BADSNLP, count); ++ lengths.setElementAt(utext_getNativeIndex(text) - currix, count++); ++ } else { ++ values.setElementAt(BADSNLP, count); ++ lengths.setElementAt(1, count++); ++ } ++ } + +- // Update the length with the passed-over characters +- cuWordLength += chars; ++ for (int32_t j = 0; j < count; j++) { ++ uint32_t v = values.elementAti(j); ++ int32_t newSnlp = bestSnlp.elementAti(i) + v; ++ int32_t ln = lengths.elementAti(j); ++ utext_setNativeIndex(text, ln+ix); ++ int32_t c = utext_current32(text); ++ while (fPuncSet.contains(c)) { ++ ++ln; ++ utext_next32(text); ++ c = utext_current32(text); + } +- else { +- // Back up to where we were for next iteration +- utext_setNativeIndex(text, current+cuWordLength); ++ int32_t ln_j_i = ln + i; ++ if (newSnlp < bestSnlp.elementAti(ln_j_i)) { ++ if (v == BADSNLP) { ++ int32_t p = prev.elementAti(i); ++ if (p < 0) ++ prev.setElementAt(p, ln_j_i); ++ else ++ prev.setElementAt(-i, ln_j_i); ++ } ++ else ++ prev.setElementAt(i, ln_j_i); ++ bestSnlp.setElementAt(newSnlp, ln_j_i); + } + } ++ } ++ // Start pushing the optimal offset index into t_boundary (t for tentative). ++ // prev[numCodePts] is guaranteed to be meaningful. ++ // We'll first push in the reverse order, i.e., ++ // t_boundary[0] = numCodePts, and afterwards do a swap. ++ UVector32 t_boundary(numCodePts+1, status); + +- // Never stop before a combining mark. +- int32_t currPos; +- while ((currPos = (int32_t)utext_getNativeIndex(text)) < rangeEnd && fMarkSet.contains(utext_current32(text))) { +- utext_next32(text); +- cuWordLength += (int32_t)utext_getNativeIndex(text) - currPos; ++ int32_t numBreaks = 0; ++ // No segmentation found, set boundary to end of range ++ while (numCodePts >= 0 && (uint32_t)bestSnlp.elementAti(numCodePts) == kuint32max) { ++ --numCodePts; ++ } ++ if (numCodePts < 0) { ++ t_boundary.addElement(numCodePts, status); ++ numBreaks++; ++ } else { ++ for (int32_t i = numCodePts; (uint32_t)i != kuint32max; i = prev.elementAti(i)) { ++ if (i < 0) i = -i; ++ t_boundary.addElement(i, status); ++ numBreaks++; + } ++ U_ASSERT(prev.elementAti(t_boundary.elementAti(numBreaks - 1)) == 0); ++ } + +- // Look ahead for possible suffixes if a dictionary word does not follow. +- // We do this in code rather than using a rule so that the heuristic +- // resynch continues to function. For example, one of the suffix characters +- // could be a typo in the middle of a word. +-// if ((int32_t)utext_getNativeIndex(text) < rangeEnd && wordLength > 0) { +-// if (words[wordsFound%KHMER_LOOKAHEAD].candidates(text, fDictionary, rangeEnd) <= 0 +-// && fSuffixSet.contains(uc = utext_current32(text))) { +-// if (uc == KHMER_PAIYANNOI) { +-// if (!fSuffixSet.contains(utext_previous32(text))) { +-// // Skip over previous end and PAIYANNOI +-// utext_next32(text); +-// utext_next32(text); +-// wordLength += 1; // Add PAIYANNOI to word +-// uc = utext_current32(text); // Fetch next character +-// } +-// else { +-// // Restore prior position +-// utext_next32(text); +-// } +-// } +-// if (uc == KHMER_MAIYAMOK) { +-// if (utext_previous32(text) != KHMER_MAIYAMOK) { +-// // Skip over previous end and MAIYAMOK +-// utext_next32(text); +-// utext_next32(text); +-// wordLength += 1; // Add MAIYAMOK to word +-// } +-// else { +-// // Restore prior position +-// utext_next32(text); +-// } +-// } +-// } +-// else { +-// utext_setNativeIndex(text, current+wordLength); +-// } +-// } +- +- // Did we find a word on this iteration? If so, push it on the break stack +- if (cuWordLength > 0) { +- foundBreaks.push((current+cuWordLength), status); ++ // Now that we're done, convert positions in t_boundary[] (indices in ++ // the normalized input string) back to indices in the original input UText ++ // while reversing t_boundary and pushing values to foundBreaks. ++ for (int32_t i = numBreaks-1; i >= 0; i--) { ++ int32_t cpPos = t_boundary.elementAti(i); ++ if (cpPos == 0 && !breakStart && fTypes >= UBRK_LINE) continue; ++ int32_t utextPos = cpPos + rangeStart; ++ while (utextPos > after && scanWJ(text, utextPos, scanEnd, before, after)); ++ if (utextPos < before) { ++ // Boundaries are added to foundBreaks output in ascending order. ++ U_ASSERT(foundBreaks.size() == 0 ||foundBreaks.peeki() < utextPos); ++ foundBreaks.push(utextPos, status); + } + } +- ++ + // Don't return a break for the end of the dictionary range if there is one there. +- if (foundBreaks.peeki() >= rangeEnd) { ++ if (!breakEnd && fTypes >= UBRK_LINE && foundBreaks.peeki() >= rangeEnd) { + (void) foundBreaks.popi(); +- wordsFound -= 1; + } +- +- return wordsFound; ++ return foundBreaks.size() - wordsFound; + } + + #if !UCONFIG_NO_NORMALIZATION +@@ -1121,7 +1288,7 @@ static inline int32_t utext_i32_flag(int32_t bitIndex) { + return (int32_t)1 << bitIndex; + } + +- ++ + /* + * @param text A UText representing the text + * @param rangeStart The start of the range of dictionary characters +@@ -1129,7 +1296,7 @@ static inline int32_t utext_i32_flag(int32_t bitIndex) { + * @param foundBreaks Output of C array of int32_t break positions, or 0 + * @return The number of breaks found + */ +-int32_t ++int32_t + CjkBreakEngine::divideUpDictionaryRange( UText *inText, + int32_t rangeStart, + int32_t rangeEnd, +@@ -1192,7 +1359,7 @@ CjkBreakEngine::divideUpDictionaryRange( UText *inText, + if (U_FAILURE(status)) { + return 0; + } +- ++ + UnicodeString fragment; + UnicodeString normalizedFragment; + for (int32_t srcI = 0; srcI < inString.length();) { // Once per normalization chunk +@@ -1261,7 +1428,7 @@ CjkBreakEngine::divideUpDictionaryRange( UText *inText, + } + } + } +- ++ + // bestSnlp[i] is the snlp of the best segmentation of the first i + // code points in the range to be matched. + UVector32 bestSnlp(numCodePts + 1, status); +@@ -1271,7 +1438,7 @@ CjkBreakEngine::divideUpDictionaryRange( UText *inText, + } + + +- // prev[i] is the index of the last CJK code point in the previous word in ++ // prev[i] is the index of the last CJK code point in the previous word in + // the best segmentation of the first i characters. + UVector32 prev(numCodePts + 1, status); + for(int32_t i = 0; i <= numCodePts; i++){ +@@ -1305,8 +1472,8 @@ CjkBreakEngine::divideUpDictionaryRange( UText *inText, + // Note: lengths is filled with code point lengths + // The NULL parameter is the ignored code unit lengths. + +- // if there are no single character matches found in the dictionary +- // starting with this charcter, treat character as a 1-character word ++ // if there are no single character matches found in the dictionary ++ // starting with this charcter, treat character as a 1-character word + // with the highest value possible, i.e. the least likely to occur. + // Exclude Korean characters from this treatment, as they should be left + // together by default. +@@ -1380,7 +1547,7 @@ CjkBreakEngine::divideUpDictionaryRange( UText *inText, + numBreaks++; + } + +- // Now that we're done, convert positions in t_boundary[] (indices in ++ // Now that we're done, convert positions in t_boundary[] (indices in + // the normalized input string) back to indices in the original input UText + // while reversing t_boundary and pushing values to foundBreaks. + for (int32_t i = numBreaks-1; i >= 0; i--) { +diff --git a/source/common/dictbe.h b/source/common/dictbe.h +index d3488cd..26caa75 100644 +--- misc/icu/source/common/dictbe.h ++++ build/icu/source/common/dictbe.h +@@ -32,6 +32,15 @@ class Normalizer2; + */ + class DictionaryBreakEngine : public LanguageBreakEngine { + private: ++ ++ /** ++ *

Default constructor.

++ * ++ */ ++ DictionaryBreakEngine(); ++ ++ protected: ++ + /** + * The set of characters handled by this engine + * @internal +@@ -46,11 +55,63 @@ class DictionaryBreakEngine : public LanguageBreakEngine { + + uint32_t fTypes; + ++ const int32_t WJ = 0x2060; ++ const int32_t ZWSP = 0x200B; ++ + /** +- *

Default constructor.

+- * ++ * A Unicode set of all viramas ++ * @internal + */ +- DictionaryBreakEngine(); ++ UnicodeSet fViramaSet; ++ ++ /** ++ * A Unicode set of all base characters ++ * @internal ++ */ ++ UnicodeSet fBaseSet; ++ ++ /** ++ * A Unicode set of all marks ++ * @internal ++ */ ++ UnicodeSet fMarkSet; ++ ++ /** ++ * A Unicode set of all characters ignored ignored in dictionary matching ++ * @internal ++ */ ++ UnicodeSet fIgnoreSet; ++ ++ /** ++ * A Unicode set of all characters ignored ignored in dictionary matching ++ * @internal ++ */ ++ UnicodeSet fSkipStartSet; ++ ++ /** ++ * A Unicode set of all characters ignored ignored in dictionary matching ++ * @internal ++ */ ++ UnicodeSet fSkipEndSet; ++ ++ /** ++ * A Unicode set of all characters that should not be broken before ++ * @internal ++ */ ++ UnicodeSet fNBeforeSet; ++ ++ /** ++ * The number of clusters within which breaks are inhibited ++ * @internal ++ */ ++ int32_t clusterLimit; ++ ++ bool scanWJ(UText *text, int32_t &start, int32_t end, int32_t &before, int32_t &after) const; ++ ++ bool scanBeforeStart(UText *text, int32_t& start, bool &doBreak) const; ++ bool scanAfterEnd(UText *text, int32_t rangeEnd, int32_t& end, bool &doBreak) const; ++ void scanBackClusters(UText *text, int32_t textStart, int32_t& start) const; ++ void scanFwdClusters(UText *text, int32_t textEnd, int32_t& end) const; + + public: + +@@ -81,7 +142,7 @@ class DictionaryBreakEngine : public LanguageBreakEngine { + *

Find any breaks within a run in the supplied text.

+ * + * @param text A UText representing the text. The iterator is left at +- * the end of the run of characters which the engine is capable of handling ++ * the end of the run of characters which the engine is capable of handling + * that starts from the first (or last) character in the range. + * @param startPos The start of the run within the supplied text. + * @param endPos The end of the run within the supplied text. +@@ -243,118 +304,120 @@ class LaoBreakEngine : public DictionaryBreakEngine { + + }; + +-/******************************************************************* +- * BurmeseBreakEngine +- */ +- +-/** +- *

BurmeseBreakEngine is a kind of DictionaryBreakEngine that uses a +- * DictionaryMatcher and heuristics to determine Burmese-specific breaks.

+- * +- *

After it is constructed a BurmeseBreakEngine may be shared between +- * threads without synchronization.

+- */ +-class BurmeseBreakEngine : public DictionaryBreakEngine { +- private: +- /** +- * The set of characters handled by this engine +- * @internal +- */ +- +- UnicodeSet fBurmeseWordSet; +- UnicodeSet fEndWordSet; +- UnicodeSet fBeginWordSet; +- UnicodeSet fMarkSet; +- DictionaryMatcher *fDictionary; +- +- public: +- +- /** +- *

Default constructor.

+- * +- * @param adoptDictionary A DictionaryMatcher to adopt. Deleted when the +- * engine is deleted. +- */ +- BurmeseBreakEngine(DictionaryMatcher *adoptDictionary, UErrorCode &status); +- +- /** +- *

Virtual destructor.

+- */ +- virtual ~BurmeseBreakEngine(); +- +- protected: +- /** +- *

Divide up a range of known dictionary characters.

+- * +- * @param text A UText representing the text +- * @param rangeStart The start of the range of dictionary characters +- * @param rangeEnd The end of the range of dictionary characters +- * @param foundBreaks Output of C array of int32_t break positions, or 0 +- * @return The number of breaks found +- */ +- virtual int32_t divideUpDictionaryRange( UText *text, +- int32_t rangeStart, +- int32_t rangeEnd, +- UStack &foundBreaks ) const; +- +-}; +- +-/******************************************************************* +- * KhmerBreakEngine +- */ +- +-/** +- *

KhmerBreakEngine is a kind of DictionaryBreakEngine that uses a +- * DictionaryMatcher and heuristics to determine Khmer-specific breaks.

+- * +- *

After it is constructed a KhmerBreakEngine may be shared between +- * threads without synchronization.

+- */ +-class KhmerBreakEngine : public DictionaryBreakEngine { +- private: +- /** +- * The set of characters handled by this engine +- * @internal +- */ +- +- UnicodeSet fKhmerWordSet; +- UnicodeSet fEndWordSet; +- UnicodeSet fBeginWordSet; +- UnicodeSet fMarkSet; +- DictionaryMatcher *fDictionary; +- +- public: +- +- /** +- *

Default constructor.

+- * +- * @param adoptDictionary A DictionaryMatcher to adopt. Deleted when the +- * engine is deleted. +- */ +- KhmerBreakEngine(DictionaryMatcher *adoptDictionary, UErrorCode &status); +- +- /** +- *

Virtual destructor.

+- */ +- virtual ~KhmerBreakEngine(); +- +- protected: +- /** +- *

Divide up a range of known dictionary characters.

+- * +- * @param text A UText representing the text +- * @param rangeStart The start of the range of dictionary characters +- * @param rangeEnd The end of the range of dictionary characters +- * @param foundBreaks Output of C array of int32_t break positions, or 0 +- * @return The number of breaks found +- */ +- virtual int32_t divideUpDictionaryRange( UText *text, +- int32_t rangeStart, +- int32_t rangeEnd, +- UStack &foundBreaks ) const; +- +-}; +- ++/******************************************************************* ++ * BurmeseBreakEngine ++ */ ++ ++/** ++ *

BurmeseBreakEngine is a kind of DictionaryBreakEngine that uses a ++ * DictionaryMatcher and heuristics to determine Burmese-specific breaks.

++ * ++ *

After it is constructed a BurmeseBreakEngine may be shared between ++ * threads without synchronization.

++ */ ++class BurmeseBreakEngine : public DictionaryBreakEngine { ++ private: ++ /** ++ * The set of characters handled by this engine ++ * @internal ++ */ ++ ++ UnicodeSet fBurmeseWordSet; ++ UnicodeSet fEndWordSet; ++ UnicodeSet fBeginWordSet; ++ UnicodeSet fMarkSet; ++ DictionaryMatcher *fDictionary; ++ ++ public: ++ ++ /** ++ *

Default constructor.

++ * ++ * @param adoptDictionary A DictionaryMatcher to adopt. Deleted when the ++ * engine is deleted. ++ */ ++ BurmeseBreakEngine(DictionaryMatcher *adoptDictionary, UErrorCode &status); ++ ++ /** ++ *

Virtual destructor.

++ */ ++ virtual ~BurmeseBreakEngine(); ++ ++ protected: ++ /** ++ *

Divide up a range of known dictionary characters.

++ * ++ * @param text A UText representing the text ++ * @param rangeStart The start of the range of dictionary characters ++ * @param rangeEnd The end of the range of dictionary characters ++ * @param foundBreaks Output of C array of int32_t break positions, or 0 ++ * @return The number of breaks found ++ */ ++ virtual int32_t divideUpDictionaryRange( UText *text, ++ int32_t rangeStart, ++ int32_t rangeEnd, ++ UStack &foundBreaks ) const; ++ ++}; ++ ++/******************************************************************* ++ * KhmerBreakEngine ++ */ ++ ++/** ++ *

KhmerBreakEngine is a kind of DictionaryBreakEngine that uses a ++ * DictionaryMatcher and heuristics to determine Khmer-specific breaks.

++ * ++ *

After it is constructed a KhmerBreakEngine may be shared between ++ * threads without synchronization.

++ */ ++class KhmerBreakEngine : public DictionaryBreakEngine { ++ private: ++ /** ++ * The set of characters handled by this engine ++ * @internal ++ */ ++ ++ UnicodeSet fKhmerWordSet; ++ UnicodeSet fBeginWordSet; ++ UnicodeSet fPuncSet; ++ DictionaryMatcher *fDictionary; ++ ++ const uint32_t BADSNLP = 256 * 20; ++ const uint32_t kuint32max = 0x7FFFFFFF; ++ ++ public: ++ ++ /** ++ *

Default constructor.

++ * ++ * @param adoptDictionary A DictionaryMatcher to adopt. Deleted when the ++ * engine is deleted. ++ */ ++ KhmerBreakEngine(DictionaryMatcher *adoptDictionary, UErrorCode &status); ++ ++ /** ++ *

Virtual destructor.

++ */ ++ virtual ~KhmerBreakEngine(); ++ ++ protected: ++ /** ++ *

Divide up a range of known dictionary characters.

++ * ++ * @param text A UText representing the text ++ * @param rangeStart The start of the range of dictionary characters ++ * @param rangeEnd The end of the range of dictionary characters ++ * @param foundBreaks Output of C array of int32_t break positions, or 0 ++ * @return The number of breaks found ++ */ ++ virtual int32_t divideUpDictionaryRange( UText *text, ++ int32_t rangeStart, ++ int32_t rangeEnd, ++ UStack &foundBreaks ) const; ++ ++}; ++ + #if !UCONFIG_NO_NORMALIZATION + + /******************************************************************* +diff --git a/source/common/dictionarydata.cpp b/source/common/dictionarydata.cpp +index cb594c6..82f2e77 100644 +--- misc/icu/source/common/dictionarydata.cpp ++++ build/icu/source/common/dictionarydata.cpp +@@ -42,7 +42,7 @@ int32_t UCharsDictionaryMatcher::getType() const { + + int32_t UCharsDictionaryMatcher::matches(UText *text, int32_t maxLength, int32_t limit, + int32_t *lengths, int32_t *cpLengths, int32_t *values, +- int32_t *prefix) const { ++ int32_t *prefix, UnicodeSet const* ignoreSet, int32_t minLength) const { + + UCharsTrie uct(characters); + int32_t startingTextIndex = utext_getNativeIndex(text); +@@ -53,7 +53,13 @@ int32_t UCharsDictionaryMatcher::matches(UText *text, int32_t maxLength, int32_t + UStringTrieResult result = (codePointsMatched == 0) ? uct.first(c) : uct.next(c); + int32_t lengthMatched = utext_getNativeIndex(text) - startingTextIndex; + codePointsMatched += 1; ++ if (ignoreSet != NULL && ignoreSet->contains(c)) { ++ continue; ++ } + if (USTRINGTRIE_HAS_VALUE(result)) { ++ if (codePointsMatched < minLength) { ++ continue; ++ } + if (wordCount < limit) { + if (values != NULL) { + values[wordCount] = uct.getValue(); +@@ -110,7 +116,7 @@ int32_t BytesDictionaryMatcher::getType() const { + + int32_t BytesDictionaryMatcher::matches(UText *text, int32_t maxLength, int32_t limit, + int32_t *lengths, int32_t *cpLengths, int32_t *values, +- int32_t *prefix) const { ++ int32_t *prefix, UnicodeSet const* ignoreSet, int32_t minLength) const { + BytesTrie bt(characters); + int32_t startingTextIndex = utext_getNativeIndex(text); + int32_t wordCount = 0; +@@ -120,7 +126,13 @@ int32_t BytesDictionaryMatcher::matches(UText *text, int32_t maxLength, int32_t + UStringTrieResult result = (codePointsMatched == 0) ? bt.first(transform(c)) : bt.next(transform(c)); + int32_t lengthMatched = utext_getNativeIndex(text) - startingTextIndex; + codePointsMatched += 1; ++ if (ignoreSet != NULL && ignoreSet->contains(c)) { ++ continue; ++ } + if (USTRINGTRIE_HAS_VALUE(result)) { ++ if (codePointsMatched < minLength) { ++ continue; ++ } + if (wordCount < limit) { + if (values != NULL) { + values[wordCount] = bt.getValue(); +diff --git a/source/common/dictionarydata.h b/source/common/dictionarydata.h +index 0216ab0..ee9e571 100644 +--- misc/icu/source/common/dictionarydata.h ++++ build/icu/source/common/dictionarydata.h +@@ -19,6 +19,7 @@ + #include "unicode/utext.h" + #include "unicode/udata.h" + #include "udataswp.h" ++#include "unicode/uniset.h" + #include "unicode/uobject.h" + #include "unicode/ustringtrie.h" + +@@ -90,7 +91,7 @@ public: + */ + virtual int32_t matches(UText *text, int32_t maxLength, int32_t limit, + int32_t *lengths, int32_t *cpLengths, int32_t *values, +- int32_t *prefix) const = 0; ++ int32_t *prefix, UnicodeSet const* ignoreSet = NULL, int32_t minLength = 0) const = 0; + + /** @return DictionaryData::TRIE_TYPE_XYZ */ + virtual int32_t getType() const = 0; +@@ -105,7 +106,7 @@ public: + virtual ~UCharsDictionaryMatcher(); + virtual int32_t matches(UText *text, int32_t maxLength, int32_t limit, + int32_t *lengths, int32_t *cpLengths, int32_t *values, +- int32_t *prefix) const; ++ int32_t *prefix, UnicodeSet const* ignoreSet = NULL, int32_t minLength = 0) const; + virtual int32_t getType() const; + private: + const UChar *characters; +@@ -123,7 +124,7 @@ public: + virtual ~BytesDictionaryMatcher(); + virtual int32_t matches(UText *text, int32_t maxLength, int32_t limit, + int32_t *lengths, int32_t *cpLengths, int32_t *values, +- int32_t *prefix) const; ++ int32_t *prefix, UnicodeSet const* ignoreSet = NULL, int32_t minLength = 0) const; + virtual int32_t getType() const; + private: + UChar32 transform(UChar32 c) const; +diff --git a/source/data/Makefile.in b/source/data/Makefile.in +index 816c82d..c637d70 100644 +--- misc/icu/source/data/Makefile.in ++++ build/icu/source/data/Makefile.in +@@ -179,7 +179,7 @@ endif + endif + endif + +-packagedata: icupkg.inc $(PKGDATA_LIST) build-local ++packagedata: icupkg.inc $(PKGDATA_LIST) build-local $(MAINBUILDDIR)/khmerdict.stamp + ifneq ($(ENABLE_STATIC),) + ifeq ($(PKGDATA_MODE),dll) + $(PKGDATA_INVOKE) $(PKGDATA) -e $(ICUDATA_ENTRY_POINT) -T $(OUTTMPDIR) -p $(ICUDATA_NAME) $(PKGDATA_LIBSTATICNAME) -m static $(PKGDATA_VERSIONING) $(PKGDATA_LIST) +@@ -563,8 +563,14 @@ $(BRKBLDDIR)/burmesedict.dict: $(TOOLBINDIR)/gendict$(TOOLEXEEXT) $(DAT_FILES) + $(INVOKE) $(TOOLBINDIR)/gendict --bytes --transform offset-0x1000 -c -i $(BUILDDIR) $(BRKSRCDIR)/burmesedict.txt $(BRKBLDDIR)/burmesedict.dict + + # TODO: figure out why combining characters are here? +-$(BRKBLDDIR)/khmerdict.dict: $(TOOLBINDIR)/gendict$(TOOLEXEEXT) $(DAT_FILES) +- $(INVOKE) $(TOOLBINDIR)/gendict --bytes --transform offset-0x1780 -c -i $(BUILDDIR) $(BRKSRCDIR)/khmerdict.txt $(BRKBLDDIR)/khmerdict.dict ++#$(BRKBLDDIR)/khmerdict.dict: $(TOOLBINDIR)/gendict$(TOOLEXEEXT) $(DAT_FILES) ++# $(INVOKE) $(TOOLBINDIR)/gendict --bytes --transform offset-0x1780 -c -i $(BUILDDIR) $(BRKSRCDIR)/khmerdict.txt $(BRKBLDDIR)/khmerdict.dict ++ ++#$(MAINBUILDDIR)/khmerdict.stamp: $(TOOLBINDIR)/gendict$(TOOLEXEEXT) $(BRKSRCDIR)/khmerdict.txt build-local ++# $(INVOKE) $(TOOLBINDIR)/gendict --bytes --transform offset-0x1780 -c -i $(BUILDDIR) $(BRKSRCDIR)/khmerdict.txt $(BRKBLDDIR)/khmerdict.dict ++$(MAINBUILDDIR)/khmerdict.stamp: $(BRKSRCDIR)/khmerdict.dict build-local ++ cp $< $(MAINBUILDDIR) ++ echo "timestamp" > $@ + + #################################################### CFU + # CFU FILES + diff --git a/external/icu/khmerdict.dict b/external/icu/khmerdict.dict new file mode 100644 index 0000000000000000000000000000000000000000..c935cd088659e4e2033fe74d585d735ec002f70b GIT binary patch literal 211340 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%0DvRR)b3aGugL$u~U!ccx7xg=PuPa zr3VdQ^s_O)iQH|HAEn5XX-tJaneWusLrlluH4uuhs3lSJf;kAjPTh=n*E} z^#-X;7p7TxGG>CUC9rNz>Qlu@K&&PiImdD!S2^(aVCl-qB6(GooJwL=)W&0vL4#2C zR<41%=$T#08ZEN=Q#9P|vW#A$TDfFDVV3Mi#}DPfwk{)wZ8SEoNT%%H{iFxQhd3vN zZ1U+L-M&yTO251+$$M9HfP3*~0>yv-MG$G2eUc9}$wsn5)KSk}pu0Ng!7dz@H$--w zmF~%3oTnSH7A-!O)MYMky5}&O4hP`xGu`FrT2;`JY5Hm=pF=7Mo4{TFVhvUd5W(T* zZ#3VLB)ODN4XY4=zgNJ)NZU^xO!S^a--F4NCo7<=7eh${9*G9K*31aRh}25dz$1k`-Pr-Kdd5j2?rg2QnSrPhR|AZ6hCnc)FMDaW0+x z`70OwuPduyi7*GKNg3vHkGGK@=E+l2$sNAxs%kS*d~gG#J@iA9e(0XhaGa}~XoS#~ z7Xdh?QX5PYJAIT4Oi<5*+#*^Zw=6M%UCxHtu?eCVF|4~vRC)qT2sgzGX*|02E+p=8 zmXkTIKo`ksH^^Hakx<<}zaoJHFN9Mo9EWL;=O!vGN-kXD=BusR+;;K;G%6ZSr0JZ> zgj?gsJ+QngW9I;SfwRFAj90HCfIQ%Z8s{Z{FRC*Tup$(|>6WO^dU>8M6)JI%8!LF+ z*wXidOyB<2{%DpwQlaIwxv@v${ZrfNerVY1ab9Nv48hxy%sS>m+|dx?s^Zk;W^wAP zR_Ii0HA;5y@quP0?JIj{1+EG{f$pkgKdP6e9R|2`QUy#JNS=qrkLl{2P+l`MA0)0Q zOLdrYc1&g{MHW?5|FC+gdcRhDU{9R%qFmak>vmK<Q94x|ZZeeRXx5|*k{zcPK2hQr@*&e-?`8nj4fe&dp;zh8H~jOsLOyQhG00DXQT zf?iTH*#!u_v+ZP;drBEQrNjZUSs#w{aoz$13`5)Wxl539#(1KrU}g2`haB-mrbZ}^ zRa&K!$9&-4YtSlU5 z#s|rfsyHZRe0OX@unKU)-US+)Q8>`~FeoY%OZKFy7N90} zW(~uc!xxa8L8dnKy#ftfK-~O8RaE=W*7|j9)xN%1-?0Q_Yj(?rs7XMA!9AL145x$n z?Y~Tq*iWyBGY#+_2STkNv@)_p|EgXW&lG0$z#(jK(365v2xIb8wCpK|OF>}DvHJT6 z4mXWn5re)3){MN)b~$+qE0kq7J6Qn({4jD9-quhdv2~ESL%<3K_n2mK%sE!U+lF() zEG(Jey}>(i6sv-v&MASk57q_8Mfu1+5%1n4Pk8y(3A2i=~4UYZG-_S)=iz_m&tDO-UQ3hOj|GWFf{n$9Kb;>KF z0s!(ZF)U-y!gYqkQkf&;CUqi8DlSW^>RWKS#K<74}akKJ`1c z@9%aDBxV98X78P*y%$wZlg7iOG>$dS$yX^$a8wOGzOTx(?*lOvs133s2~l#*+Jtf8 zQc>DNea0%X|iMfVP{u<#OQxoFA3tfqI^3qQfT4HxoGGxatt> z>3}3(3Mmvz422hgapvqIU8?2OaJtPxSibZ^(2wGDmwHRj1Awiq0HK5mv1X z_~`s3&+%NH&r$h7UIUw;qCs#HDtnC@0S755UZ=Wa#TfWXG|Z4nxD! zlflP3AYmKQ7+%HySZV;Tvx5*=$%wbK;-EpE56E{$ zyQ6bskL$P~ZEtRIP!I&7vJ}M0_#2$pBRCZkC#V|W4KO{&9sUJ}C$pcd{}2<1r(zko zCvv01R$yTdf(Kv`sSBsl_1!Y+t=aiW2}8v82vwsY8DZlyIH_$?$$uG8FL-&#le?Xi z3EkE@GfN)K^(|>5D{;(5jG=@wible4>DwmAQJL=4ra*U&5kw`84=Ev->k)R4=@=_b z%m;BmS*3e&9Ng6*W`?&yVMXryUuU6@keBgo9CzTH3p9REF}lRWX=I}m1HG{CtjKiz zOL}d*wVg@qbvH|njq?_e+aXcMq4_ABnTASP{Qe^m`1B+@Mvr6YV?Eg@RNF7ys3L{E zOR=hPun@R~Y%qsYtjIEz#eHxeEF6aeVO48olzGWHwYc&8$lA*>yr}$uB6BJ3{0fdV zXv$VPtFi2>^)IXd6n|Y%Y7<=s%5Ol3uvim#1{_fgub3F!NeB4Jc3w$CzjFp*zQh-qEX$xkoxPHRTuo zf(lNB9;=a4a7&2(W;QL$o6CNOf06(Rd3Jt9Ko89n_DPO`-A0`*RR0gSax{hUsdPWjBOzN{{HM#{1Xen?c4auqIOwf z9N?pA;l(PsJYqL2*U0>+r)g-5IW&}M1u0xS&>XhEHw-Qd1`dZ;U{Nq-(%gLU38owI zG}#w4n)U_t2=cJNA&VQ3?f>pa(Wl08czc$*gsNe;Yv9Cc6O24zl$@{Wtfrxv<`Di- zfeLIuyY|n~A)LCPU_u_m>C$AHNUoBKfB2>1g@tb_P9HOi)Bjv39{wAn3@{xcl4Cd| zVs3gUk}E#`Lr6p$RlDX*%_;1LoO`IoIVeC9nBEML?yrAjmVSLZh~FYK3u`~Xso0Dw z^~j|Q#OC?}3hJ2hOy+znUFIAMu@6k$y&n6*qVFk}bn;Yo$VGE{X4Usu6LkCX!B!SA zyEcq(wNQZW{3hGWk6;Bun?Htj%od$lVVYH-hLP?@rpE;?HE^oWDxART6tr!@8R9sc zNYdExNOC69rC~2Rs-V>!I3zEN!&zX`$elrDW;}*}tmLD_lna(!pU1KSZJ%$DVcO~IZeyLsG1ha|C)p5B*ZEbyy)Q7)4A{3{ zD9hEAa0WP?6SW&mEtG>`3gIXK$x)mqhdp};rtg^33mh<4iEUQ)o#)H@*ZctVAJlFx z3}9&-WM$}b@;*)ppNIOXqgVaL7S8CmoBBU9`$tp2 zau2<#pE|(<8#1`f3f>SZ-gS;Rut|DQCU1HJ`z9L$GnxjjGY96g6u>Ikamr=#p1=*< zZ45jHz(AP*F2s&D0Fk+3Les#fCbUFj8+jt=w`Xy16cXU)-o6cbsY@Z%k=s z$A+@ndyTv_L7FPn>0R+BI&c7xid@nlB=E`B!P1dtlKp_VJ! zJ0yFn?UwhMRu^(ZlpnKG98b7=ki5zK_9}(kP~8_*`_hrVr=2z2f`a)Q%sbfnz5lnL zU%w#%(znlhAgoy19TL1d?!NOE`zOowN~`0T6cGw zG&X5SFWhQHL}U3qZ`hVBAQ^525pGQlYq{-gjWqoVC>s{}Hel$ed(dys~+_yGF*vEe;P^1bfI^^`nYE8ne6zAj{I7#D=Q8jrnT;uHBiYG_+Kgq z>SfJnOfoHkgp#XVN&;V{?Tn^SL=Zft>BkDA0gye2GTgzQwOb~6`CT^zGr4oZqP&F6 z%)AT9AY|rt;Yh*cV^+~<1Y4b0+KvDGsjRH!W<0jZLKzEY_LJ?z2jZ2(DAF zi4t|M*OoU-si#n_jjg6a4S~OPcwq@-1vLvz;3EP-BzL5PVt5W5As7XT1gR8DkwPza zp;qmQV&U#no#-xHB z_sn?BcxG&b+Krio*$9QvX$MEX$US2nZMQ+Ko8Qwm3W}|JUq;O?j$|rC4)(wDns{ZV z`AXg*50sVp-K{cP?Ff&C4mXcU8joE>m$2IdMP5wQ8E>=bh(U>Swnsn`eQXITT%di> zJ%)UXJRsi|l)gVVvZ$;cZ4YRB9E3nAuGqR!GpuV(8$m^Vy{HOAvU;qRz8Q?%DsWcQ zfiQYnfndCiJ#CQ-Uo1&L?0v>{Pn%l{k*A7n4fzd0crg>G#y|QqsO>(~e~ZpLp!f?1 zjU*)d3a9yJ1|AE(7`Dgxr0)}%JAa=-Jy|d_~hu?UVYs28ikUgWGKNn3JrAtzySD+K#J8@T*;l`p#=J zSyDEBcfk3G%Q$}2O{oH+cRBJhd-ux5Wos+=jq@~qN*+KsaetCxVa4zJPGtO@AxMyty#wGFZ-cSARzZ)}`H6HUf@!-^E zOTK*co#I`FKiS6Df-tvwo~W&<{d@R>!&v z!p+Ey0#IbFve2PD1)%_?NnJ?xeK9<%9pGZt`eDFGO1Bpy#;n$1HY`FM1A?3C!z=>p z^x-EviZ(wUkYsxxRgHc3sa!~lwVl0!DwD9cxg@23LHuBfNNe*{w#la8k8u)aWvQ?U zluAbk2uL4WZ7EiFvzvCFPVQWmjMlMH_4>xfV+91Ybqw%;c+-P$&@Y6b)>+*h43WHw z@=qXTSg50&i1wilg<-QgGD|1;P`!fi=_Kl=og%hl?^`5qtA8rWgwQ|fiuUjf!C1=N zQKe<>05ci$FESKLGr)A*3WBx9Q4#W{Azu~G_&21cW8E5`9r75T?GK<1nw`$>@*CBD zZ(L9+(7%Q%puEPMF-qpu3STKH2@+mr7g|w#{;k=V6@gP979Wzq^o03~;!$&G%ex+R zP05+>VPo>y-NbgrZiWC{relwm>DYCiCS|W+w`pu_Ew7o4kQG3=H99PYcoiRptc0n5 zW-)dxFi~9kGSQXMLJ%?zi2H9ZpiM&EZXblTEX?6FUA4ZlcNgkTjndUVT<7 z^hXx88&Uxt2(a|iR2K=F>LM8brB=;Y@^9hS6Zx*w?wP0Pt5E+GVy`-bQgC%;2wF`D z(`6Dkz;?`R-JqaC3snWE>K5t!)9euFJ{U&3a|S}hB7J9&J!iAlD2*b1Ex=#WZNQZ# zvDZ#g>fFKBVk;6!L_ZB(Kz`E-jo;K-iMs#c<7uH|gT6D!7Ykkz)L?~H?n<%a7|>q! zAvRhM`$#dndc5Q_;ve{dSiJ;MjvXJkjI!3?rk6|LwpoY?22Hn-@_01kprixH!^M-g2-Y(ademDyXq%BsBzns3hk^6 zJrZUk2eb7ha0oWfOTc{-QG320c|qc2;Yu#)-xuf%RmoRDHwE_#D*0LV6{sfcAc$>= z%<@%PW-*rd2*B2g&~Gn%K{E=U!@jVqnJ52g=9^J)uWxdM_e`Y-H1%S37fF729Mr(e z1cG2JPGiZ?lL9_49cDZ!%6d;ztu--YW8Mr_e1C7Aw$S(uqyc zg;oh{qtoN_?D>~eN=uPAdbCvqn&iyfc8SXvpLg!Kv~2pTVr+X!Evqsv-zJI)Y`Ge; z(kTTQI*>q4U}&HBP4%;>MeK0Up=vcNYT}(1s7k{eTXT(HuIYbgAN$6s6>8(DsRJR> zPK=zHe4#~T{AY%gB%RQP?xdB~|H=`e6gh%*(Zccp2R}71Hmdg8TD>hfx`BP^a2dDV zbB596FN{ixce_+Xx2g zR}h;TjijEJOzjafdEJFuhIsuMgw-+;$Kfff#-UA zhwKo0p#Z5PYGT-jl>Axfip`@QSiN<0nGR$^kJ~I&p3Hkn3f4j*`X2}+7YK@wGmZ0i zpO4;7$(2KFjm29zx8~}asyGkcp5VnBlFh?mR4ptGT`J26_GuxV<{lDG>%k_6&93A% zhpO~mWLuIk1d81NwR<75; zEhUU7+N)aQFyEm##2$g8e{Csuj`g4&0oFFovMdvVHYH_q(NP0V(;@bO14A25#@ZfE ztiB7BqyjuGm@iau=SRAo!WSYDq4y}vGELVAz#Cy4(_p(d2a$j}EfBTEj`Rr760p_; zIO!z^zdc90M`I7fkNqye!*l9bg2H`Nr<%%AXYhd`1Qb7M-P)0j#It^E|F7)agRkIy z(6K~*&_;3{^^HZbKxWk?=tqcJp{l3D5bA33AfvG~SKj?wY61ZZG786Jv0ZJfZV5GJ z?%xPmLy-g%YU7YB8lfK+=*EXIvwYineuH+ZWaA=0f2FidFYLE#eRV1OB&**!VzBA~>>%%^r-|e=}XJx~_)L#~~R`X%+5+MmdL%RdR3}COpD0m!$h@C7-;Cl*!Sv3g+ z6b)D`s8vF8oKL;Smqd-05kS5pXpOD;k+?SPuFA_RGZP=I&D{BRGKsUuR(wrmdKWdZ zZ6vpVibaHbNxo{M&j{Mlxf;Q}Nq80El&=J5Hl0q;ZSzahq-9?Ii$@g)3NZQYcWM0g zpEZo7&$aOK!M4n64gg-n)wb{l7vN9qz$W+PYkMwA(sM#%)>+{p0dkRtz}XD9&0!3S zQ7=Rkh*>L*HDge@PTrr3)w$VYXz){i6GZm7dR>am0Q9gWH$c>j+#;nY^W^`A*32p9 zm;8EgdQyo<(7O3xpO=4hi_C5-%(UA5Qrr$j;p(F5mjA(ArFeB+6Ce3K9m*;Gw;M1( zDu3vqigK+qLYGJET-uZbgE`8h(G<9s?T}xbIG)4)8drz=rc=WNqVo-CJzl5yQic31Lnh`ZygY;jIq%P z{^1>|Da{TC-}9wAGrGZ(89h9J#1s`pgfMy-AdwtuHF91d6`Y0sUQON z1^KNzQ$SGZ>oM03{E5oD=2Y+>t2O>(C9+KH_kKQhL)eEjkQpD@I4}jYFm$ALgaz??q?_DX`w2QF_l96iWF?&h~xixaxBj6!kmH zJ+W}Ta1ha1%!jw{H&1~TsLVXttoW%r9I}Db@x32?Qc?lX}(rp_<5V z{1k|TPDHU&Y|Q|VhQrKzulz{B6cb@f&_pO8YAd138MH=7T?rA4xJR>vDSL--p|uwN z@^73&av_>Bf}sNx|6vHkZp1N-oiC$cjVc##o4`ynJaT zuarbZt0N6!(8G_bY~4Wr%3vYlmN2?p0knt3^EsLWW=)8{wCH71hmXDLu<>VqM2m?= z|AYXdRkD$Be#d1I2xXAXWcI4GR62N;9Gep$lt%Vgy@*Uxi+QG zL|u#vKjE%5xhJ3jG@^QFZoo)pMoC#Ma*Pc{rB(+-_Yj8yyTyUs=NaP3Oc|~4=4X8N zicO2PO|QqJI1SA9lL8|``#6lOr4+OPYOwhxj+N*CYXo}>qjJ#~B?Vvxm^4%1D3t1l zVF7H-(ifDtt-C08eZrsM!5y{wmgJhr4Irj;sl0S(0u#|2eeof88l9v+mpTp+1g_BCwL)vE=99>@V{3inT??itB*tjt?6Zza0UkS#J||5&D)+ z_44L=69^O=l0Iw^J`52P>X@?&8jA69=7sIqcF?XXT#Y%Ko^`WP9$R$HBe38I%209A zZml(Df}llp*h9zTG_cfIGm$%O#xML%0;4h9_Pos6bezw6C6T%NPGF_{<;ftNP4pX| ze})o09Cz-HN8Rjk7$JeO;n3!Dn1n%Y&~Zf#rOFodEw79P6Iysu;g`Sq)5WK@YJ6&%F4xr1 zK%~}dB-=V%xB;qu z9LEBC&|3%^P&Yg5u&^(ED<2CPgU6K^A8r?I#v_SndTn)@Iyhn)DSl{&hu=2HyHgA9 z_#w#lhIr4+FgsX+qZ5S*;`{p4T{UWYAMHa}NJu2{`&q>dfdlL_XmxI%fd$a zMcPWh1U~Yy{FyHz=sT7f z{Buuc@B_i2AzuE4sU_eYtxQ7eU*n;*n(@#oF`YPB$$DVDp%xNXhgYxuPBX6lBVI+& zcg>F>p$|ta5Q6>MT~XJp9KL!h%EQLP1H!J7UZ-94#dBKbi)YU7sw_BYi|{c8wftH_ zlxUTgTkFv!ff`nWCz<)Uo^t6hYSu{l0AMh~vR<@dfo!Wn2qU&T2)Tlkjkq#fuaE0J z0!hnlcrj)iK4rd)YNbwfA!JzD-5R^|!ino}xDn=86)g_vtI&%Sn{G?W^K3QmU*VDCh;WD3+oms65Zj9_uSk4)&levcTA+-U@^eL22Af9>PLwg-&` zZ-kAqv1M?2FIWqXax58t5=tX_7rv_n6ul0H-XdcX^3`)<$o5-R7AjKL(CJd*13&17<4rYcHZfk<}DJI8go* z4246)P}qj0{2^TyjH-pjZR~_2Ju!Dc%o98IKzz&Z6UMl!L<0$Bm^v;ZC^|Up$zCJ; z%0>8f6lIF|X{DyFua{Jp*6!uwIHN-7LZ0eLfBq)d?hbC6ah`WPtk%%nD>{i zN-kn1A4c4L2H~#GQ#e^h=r5u#foznmh4vD34Di7i@G~%97QlZ;Sc}6p+B3m_FY;v# z-niNN8OH%}k_dXkL_^Vs404xJUF4=yZh-nTKtMY6a*Nn;1YvbT*}M+fDeeqv!J4q~ z-ErcPbs?-pasF|9-BWg3(z#=EPO5;g+zpS34yKS`0}8U+^bfzb@Qc%+6C#L4Lh=%S zD!?{@7a)m#(kQ;VqZX?QqE!6NIap;j^3}SXvB9y<|E(!cvQwhqP~VDEhM_lI!yddx zz! z>s?qP*T|f4it*da;LJK|khz0GsqhxbOHCmMiM@AlP{poL^F`A|1-oAnA@PO9NTr0>}Oum@5KOYNvw)Yn3!DT{&h5XOIDxgNPNDZzIF zX#FzPwDH@9f{q=~kDCP>rzqYce|0namBlCTR05xe?+8Z+vztq@?Il7wbq(93mPeAQ zmto031j6lKeGB0y-PQus65tpUoL(W3hkO<2gVA&AP4;67_{RRd_69vpYQxS|8rSXHw>6bqo62YS%MhBSxHJ%*KNEFc?v zn7wWr#BMI;w+^UAC~y)Y%!v0+=Zwi4oY!%mC*{SVgjm&B-hIxwwOTqxM#(+Q(Q+rb zt#Z98nY=k7ga9(%R{Z#5v{*XdY4J zV9PxGxd3FlBv`*ywu%?E1z8jYhx=-qmoIs!h+mQlW2>E_=>SbCGiAJ%nKD+ep>WMa zz{mnX;{8#)-}lq^Uy1i$cH#TYPxcn^i~sbKci#8ETIRlgT=-6WvSo-B+-gc=QHezA zn!1&3NOH4zmI7bLi=iEV8mz)nc5~630H+cnc2vNee}mHh2B$Vq ztBLUFx8yu$t7!{?^}PUsv2(C=^s07U%sEhtP6DoS4(NZ%ENyWeN7^JP|a@@9u+VDbII zdN12ppri;&)juCpvtanohu7CF$yUlnR@_>{W<%*7A>F6gwtWQ}+UM}QyfB==_qt& zS~?PosE)j{5$p--5xLJw)-R7nB2O0c*16VCzELXr_m z@Q$}YG)>~3_{5+2hWV#Jau(K0o$tg7JbpQC za}1&*cU)ekg(ZwWM{>hrU_F@^eh6efxdOqDfCOB?{Q*^PTGQFm}E*2a`Yy4VkUdpmsk&v-DT3H@di|}A}7-oWGe;L>Wuojy4Y02t;AsW zVox_}DY2hX7D=0Pw>R8m(GS8f5F0c5TmQc^;jhl9i<%P#jw5E z8|=v4`K`1~V(-apsghG&Sv@s2FJWAIC}~{vFq*cBpd1}<5a+O?7=dM@#0X#mq2S6W zH~@X_FgA-HnSdtsp~!5KuWq;Hm3r7;sB)6z#5Uut)}cA1bPpwHoU0(M;q!0=Ky3gG zE&}Xr_+69;I4g*Ze_Ut>+=oR3A4uQ_5c1j&sery}xFa~M1y0MLUl&ReG|-#NufNRA zPUW#xo@f+;F`2o)O0M3BHf_iZMMqW}zj!n@J`Tw2i#oOuHx1ekDiAID=YELO_yYPe z_8uh2KEWOMX8IDr%$)1h8o)U01#jRcXeUsX%&LmO{QLgoC14~j)0(^r`6*DRWc z_YQ$`Cp93i3)FV6+z=JHonKn=eY=i?cD@jTk`rL-^e^htGn)r0ZwJdD%Rd!U&d$I& zM)nmsvT~S=uu<|+9mcp5={iyAdf4Xy+g%V36@HJ;&){fUny@6C6Fkf6u);0I$5)?o zUf5SS8KZ+cxK+M!0~xsxGcgSheqyX|ccyG35vfw_K6d&Hb)DkTGU zvd?_OSkD4^Wg4%aBlgkj1h(!Z-&W8=05|^nUmim#@4t_B3OGSJAk_lW&*Auks`QMg>?+kcEo?x;Dv+mZPQLJt2^F`Nit`h3HR#s?mver#(Y zuj661vM`Eq^1+TwQ@RQ%`XXprc!{7&Lb+sc$Rtpzxl0)wFCpOrHg{m*hS1ML`w^r~G?f%S1XV9BsNm40<Mlc?)4zv6 z1f%C(#dFj8pF`dWr%#0N|H7Dm5;V3lx80)xj>MhA!)!8-F_E(M>92ru^bT69%BJH& z9@ZaF2J?qfVIH#{tE&XfiIUINmCb#eUc zQzAZ7c@{0bIspOfz+U{&!lpX(rB3#g8+5=e73^jWk|W~8XoKckm}@_%`r!(FsirR# z9tDJf*wc0tm5g>zBpp3C&)<*(OFTSL4~a_DYN0NoL}WMgJi6()(U*GlrK}ZX26eHo zwWO#t+)_!tQajBThLaMV(=||ZaTnqwoR7lT?*pi0x-ZP0DzTwKmzRwOIT3@2&%?XW zDnZ(DIPiRc)rO%2Y0I7LebRiLUfB?s9+(wowRpbNJJNh!m?~EcH3HDp!cY31tO_b{ zlUPM&;C?MLa8Jrx7=xElfYt7OlEenBv(4n6}H?!>TvSkGFoiz2s^q+S z#@a{XUP}pz3Sl6`zw9%Y((zA4-yQ^Gt1Z*)Ryvjip91p7?kD5=F=DXIBLeBu*~o|D$+Bw^v|Pg8Nf;4eY7(jRe5{^lhJumWG8Xs zsDRVkLG22$_rr*o;(G6~6Hz-^yPFY%###Ks1~ zc;eYOdlerJ>OSraqE8i>_y4M8-Un^HA3H)Kr}j&s1lH~-_cy5ro+d;Du5adrdlBvM zt@tx+Oc~OMSiOkyH-AxK{C&1&{C!r8U-2OLs(j+461?ItUNvBlqctooGUQML0Qe1* zpq~@CWM;p??<;t&z<70q?+riuB^1;zQOlCiEXCO7DuqQMZ~_S`taK`NDN}Z!m#)Ye zsmJCDAULODXoWF;mS&8fS=;%25}m{$uVaj#iYM-^*>Mp7RpgS;5O3>m;YC<@$9;}Y z2(MnU+jQ&I?In~d?DI~Qd2F8op1rR?Gkj9zc516^Q_lmtlo}KeFzE7^-X5g6%hB`Z z<<)pnM3b~u-ivu7eK#tzhq(P{pnWs&8Fn8p8LW1^o7n!02y0!w0$25 zppSt<0WyTsK*Z$7-UJnsgmlriYZ;Q5PS)TW5E~L}tUYuf#V;8m?v868V0^GDe2xGm zv#+*kSYwt(D|^BQE>wGjU#lgzoj^2H zjd@=*u;eCu+33W!sd#thsRAl?-1Tc*amg@PI+{73QW6lYF#u+9bpx_t(0uuYY1ZiV zyo>TOF9wSE3-!gYEgcrFzF{qO!cWEEfIumHtz)*E($^+3;mOT*39ZVs7j)MHY=qT6{tGVc?jk?m5`kQ z$k3N-)LiX;3?=;hR$WF&?kEjxe~&bO`q+Nh&j5&D~*C^M8LW4uCkKG7+##0X%Yt(HJZ~xm!qIA=!YD6302=#p`X$8GfiMSpaaTrQJvPsmOH(&mydiy9u^XfkdVXzUuUC5 zMZV)<4`u-aiOf75uDF9fwhVqcl5x#p8e(Evfwv@LQ3cd|z&zZPh+HdlO}1J_qF=0M zv6tWXD@D+eUbBit52}M)<~MBJVGUzept^;xfp+4V(JjMui0I-7B&2dJ(?R_22Csue z_b@A6=bISPB~b-OkLf^&hmo)EjP3koj6Ho*`u-ZWZ-9KStRM0(Lc|zipGt+p*#bLs zM>4Nh2jJ`k!l3`PQzBjX=18PxV>Fl{2@B^in~hZJo+(O=@7Pi#Xo!ZX=r6!U1NLy$ zdr{u0Hi!~zi@w(}!~-(MXV&nshl_<+%7?C^cZ=A<09zF1H)NV~?JGl*T# z%@(2;MGCcVP{suk$`;vd<+3s9TakxB>;)HM8!XvRnAsC@XSrv4W=SHFM#-IRs0Xpu z2Fw9D?jVt3F|wUXI1om%lu-AhIGeM%OcZ4XX-js)G7sYkRvWAsuS8ceT7j3x>3^eGAUWRBdjaB;)80o z+2wl~@ng7{=r#|l$)0eyXUU8G zO9H(3Kf*X#ZyH_EvPf%rDT0eL|DNbb1y)%6W-D6G#o?EehXh4oHvrD0B3W0K$ z?F~offt{EX8LbkXn2ccL3B5i@qiTIEbZ&W2}hrcR5WAjG3TMJ=Z>d9h|pe$7fV!H{Up*>90w2WZc5k-vX^LuW?NBuS*|>+z?sYjP&=&mu6VdqEMZS)LmQI;JGs>@p_%rbmsw)BjW!CSlum*KTx>MiS^2&qBCK+9ceK7YU^%H1) zI0hker?{8RXznpjL6^0L(=@)E`A4Dq4XyLS9{-r79&ga;`jTg5yLMO_3DKJTm;RH1Lw^o>bL zLb;}sU)&2u7>dU#y$&?LK9KK4{dYot3&RdwK8nOPdXW~c7^y+p9-koW^tteMBQ6$C z_BT}V>l-h4h+HymNfg3MPWV5Ny%(DdcY;QN{0|=?c79(xW76s*H;w{VY3@UAs;)X} z5AtDSkVVH*2nk-?o>BUqG3dYM0ijyOBtXL`SG7^NY zhJjSC?-!Ts0c3bc6rZ+3s#3kXawa@8plp@pXzMN`Pf0uVIV%tzUTbFY*EDn5Bsq7$)lV@gll?zU^kCC3YK8 z(wiSQ zmNpnA`g-XQL`NVjPt<}62L{j<%4i$_hT-*z#__cf$Jj6dRq{9|&@HmTSooG8Y15zKG=>ju%jVK>!FT1MCB+~55gIFoF^tc7Ft_Zw zvigeAS|hbG7kM4_HYr|wMqVPmMalk(?&2e!Ata>RHBnj^WW&QqJX__mLZu0pgo6Kq z2xV-rY;DmpXq#Ac(w z9l6QeY3{U=w|%x}iUi%4>dQ1!gT53{gzN7IvIdtPC5r2=&^DwhcO0o=`{3}M4vcHI z`h+b{+bqUQ%dDBZ7o9&`8_1jQLAh?Byk~A`=U0Q53}%m%uqRWj1NFMO@N`p1OTU@x zFY}KJ>;sK=$kNbw6dVAC4imf}4~~;$rw?jS;-iGGDU%#NEbxXR=bE?O#`7mVO{i5c zji2~x$q&_NVSNjt5Z0rdk5e0jUPBS%me)nykc0nwr8)#!U<4+3c-?jw7*vt6*C3ob zEIzdfCorl4tKc^JiX0>C1Ojsii2g*X7kZ6dY;Ud_!a2aZH)_0lZ3Fs4QP;iwq~lAv zAKcRDY4*=4S}+(k_1;{K-|Hl@VIR<#gx+gcjqS@#_Y)^EgC+;wicJa|@Wv?HkiG~K%d=-=7Y=+yB)g`o0CYE#w%?BVyV4;2l z^r_)x0Q?}?K--(1>R}%u`&hxx#x;JnI+_>-5u8{2$O=NumO4E3`cUH~HTD}?RYV@XHd>6^moMwLD8Q9glO zSTfWYo^pjmZ6%PiB1CQvMA$GMl$>pNg^m+afj}rwBab8qh-!hHVg{)ylw4RC8VdN8 zq;H}BHDnmCF}-jYiDe)s4os-%nulT>T097EWrCiwfF^7&q}Pz~!Q6U@&p>ooL`WCD zer7;$0IxgYF83HuKPMC|0R5a;5BwLcQhF?!mDSnU7(3Bij|>3llBw&`GIgg?V=*zA zy01K$x}5=g$oTGuNM^|O)$AQ4rC`iKhqFMDK<3|ls4AWjBqoSJQS@`;aKWqrRB9tj z4TxBnUYvMPP@zg3zrKP7lSCADiXU`13tdz*CNsSt7)rzp=N_|992TSQnL;#zZkXKU z&1){k4Xc^qYLY}C@DPb@tZ%Qsfqo0~A?S384I>|N(P}#n~d5fNbezLMT~*$c$ECjgTWc0g<%#~S*ilDkfp{vmn`h8Ott5b zEm7H7uLWwG+r=iVv&5tH*vON>P6 zp7P!78&~*|p9V&x-BH9s?ySC2@I_Zr=Qd;V<`{~Ea1@))y^t4N57!>x1$?OENa$Ph z;K=)QopkrkqJqCk!H5m{_FRXm4oI1kpwn5jN`Y==ME``SZl}OFUh3k{&&@Ob`WsIv zZQ>J}enNCR?3LMnD(O4@7b%k~YDk7KVr)z_V4)K}R3DWfHqi&Jvp=34CQOCJ=-Cp0 zNF)Y(EhRtr%5C6oQ({jkLq>rL5fJIA#*BifST5pDp(tv<#?H0bP-UA0_?a9Mknbs5 zVvnOI33P;-b3wRhb)VqfnX_Fpz&(Fo|wDSgS$~5F3G1?!3{g z<~kNJOFPwzRAbVZM&wez0^4Y}uRIV7o5;s@SOA2thrOt%L-)6x13Wwa?1AbY>IuQ# zP{&5tUU0}<#v~~qp-~7qkBn1>xK~1Z?X}Lpy8-9~Jx2sE3Yp-cw>Spy4Y#;iQek8L z?75F#Z7iM}W?dbwHx} zCAa&^09=+ZzvbFuFVQ0fXtEYU9sHq(MO6ljTqoJdO{8n_=Sy5oIrrw8oY5~d{R=GP zTpIvREHD7Im(PZ=2SD0IjciX-#IV+ejdCn8p2n3p378&u>yX~!|I^U#pTR)lX|_1G zB2J4ruJ?|>ibgsLH$Z_I%#HtC{Rs7b{1DV25=8(IfWQ&x6;ON_fIbLrI&1v(!O`#m z;Pib_jWySb-d5O&1Sfn0LF1tD`Cmg+QQ&|=GREy(|HzNQG*ZL}9)f{ektO+IF4ttWrEv@syt?$*hem)BJHPku{0sVPd#y;qF_>Dh29yV6q3W2LO z5TaC4|QXA^}9@W|&iMKr~ zRyt(IcEk6uw7nE=dkv}+k+xTH?~n@)&?9G<<7 z+|laz>Pe}YK+yS!rvuR89Y2C-GN`j9y8jt!5iBI$`dQNG4uk!IlH9v}N}P25F_?Wo z)o)vs-LFy8&BYmM%_CfzP#nO);t(=hS0aiLx|n^=%aBuULTIrC(&<8@1s~-w_Bx3O zeMSM^M?NYlJNT?lTOl|OrtTG0-r;B>iQH{$t<_2+5P~PaS2Fv$P+%lCDl0YM4+RdY z?lPTV>Wz)6VTpzxM(a~Swn3?)4c4F>N;MD~1yiS&&2#y#@l6RDxBV?_*f*C^FaxTN z%U9@&;>q9P$+Y<-F8VbMOpiD6TRakaGbvU%MH|!2=Tv7UxvBptu&SIPnvqiiax)4% z=^REtC?W8HvuXsN#2%+Sht*RSfV3@z+^c|E%cbG+3jGsJ{{*Rt6~gz=$2oNXJX-v; zSIp2JN~}P^K$tyivn9eQoP!bJ>jqe|L=jE{-O| zKD}%e8vIRo%!#81qc`_+&6vAflq0bgTg4LXZMw40k)W3w=?W-|4SPu$q_bq5SBvk5 zqL5g0Lgxa0H%88np9P@si1!0{Tid|Kq38p1B90GXD*j`1*k~I{JV(<~d}_1J@-Kv) zD67`8Rzk>Y=L75Dn~F5P34QEM7`9i4?3jiEHqz!u$i^+Z5hA**$sI)`7t@Y9(xATG zv*YicMfpZ^iNwYWI}@Xh^zljNpTfpq%8z8j0TleLF?I6#q(B5i1M^db>4r9J%CtQI zRQ%)(QIFL(P@x=+_FWma~x zgH3ayWDH8L`U&&~d?xZihQ4ZkEPxQ8ErfbI2({ugmm-IF3MZ_}KD1fN6w1J1 zX}?FuVq3nXAGGE{3>cvB1y%;2BCHI4LWkM^B+wjwV5! zSfPQd+mJOG7*)F^{hlNJv0q=_oFm^YFY>XJ-#E4wl#C!e3h)rv2XefEzZ4N{g(v&O;&TQ70q+iQy-h_GQhX99-C0Z8>rP+nNe93N z9Rjn!UWPo-V}Y>&e)Y@2V>mW@2Zo^)O!gbEI`WJGB{FiL^(p@6QzV1?_jy4+=^<05 z%SOv8yE?Pzbe35n%uJv6#Ad}+j=%T(*j&LsoTQ7LZpK28eCk%x@$R(ad)cwVGY5scOvhPzp^pmH5! z*(4?{v*6g4o8dG>@sLb+he&v33_s>Z>r{@ zV9Z!vRI_qn{7H;lRiFl?&itJlNu2_7fg~N$Tb65bk3NN{7S7%7f-pt}=BXQX^``?u zb2CcZPPW7*)%aS^hRL{QQd7FgCcgPD`4fdPWS0*BEoTR7OhXv%u zAp;AT1C7;6Jphk^-|jpA{2z1))3a@E3t2vn3vf9TmQen*CvsD z&)QyVK%=8$5q@2#L4gz)2)FykRy0EO?s1tG_M=ucrC2SjE}M9v=terll^ zF<1i=N=VYmF~a5`4$JH^Ei-%Ac@9ef%)W)VI&hHjIf1c3wlM^wf};L1bWRi(t7Gz@ zCd*#V2|pdyD&Ei*MOcdTeR^%wlc^TxPmWRF0IMObjM+H3e$D|^qL~}5s5dSVGEp%6B`-yW5(bFUgUWZ zl2&Ns6~VQIb)AM2nKZ1om#j`rgxfNdMUkcyvngPh4IYdIBsS4BVUGq-su*NCM3X%X zJk18|&`quMDVTA6j|W+(C+s8H=22|J7`7I%M2>Zg6B{uqcK(6vD%Qb(mj$7~Vf`L)$Rv7S1tR_2R7KAh|c!1)xNOm zjgUid7Qh#*a1Yi25+OKhp3CvxowP_a*+FFCszCUI?bIFA*3O;7Q>B5SRSK>S6b&Y_G#IQbJ0< zS9vXrRyf&vJnYpED|DS=JLbbu(5&V|aEPCM7pUf9;cMVBiT*%~D7%6As+7i8^>1Q9 zH9fMltj1Q7jK1aZ7C$X*j$s84&ca^;dpX%x;jgznJW^OaK5_5^9zMfh(#`j@x{C79M+7;^@ScAV z*Xs~C)%pq9xb*)~Ezbk&1M{y$(u$kze*U|-~@S3%;dH5M5cT|J68 zR^4>6ESNEL}Cw&!-z0 ziNyxRT81Qevb_l&49OyC6kmh8t#h<5wB~L56NHv+d8$+u&hC?MkTGWRaCZ_*Aip>t z`>`AXkXC0$CV&*93hs_faAd;7qTpV**aNW1q(OGhCck8}5zVyLk1LxxPc<`n?O79z z7pHk=h?nl~e+eyNY&G7Lc(S?wNhy+tR<2lH<`F<^h}svUrJ9I7HajC~B$*uBWJ<~4 z(+6U!K-X5BGNi1V575Xa3#6r2q2v$LMsRlrm=#r=A&xpR}bVj%8Loe0YjP{ z@cH7opeNb%vv$gZ)i!}HQc817<*#zB=x$CC$w?HPieIq(9z@LWU_l%{#0k`6%t+)n zJ978jOH!^1Ppm;f7HufHb_|;W3Mm{!P%H79J(u6}mOJH{hNDIAflK9NPl_FP2CVvD zIXryCF5iTqdf)YW-wn86D38)}D}80>o`ZXHPX~Hn*Fjd=j$m3}tKAO?fXe#F^eFNZ z*=%vAI0LEqrjJ(-3$z>x!r@|~+^)ywjJan@)}|G!5X|Zu0{UWW93__n;u1D=G2DVa zKSYiDAJfE_2yfwZF+*F(rV1R28_K1zkYmu7!Xgx6-~4p@o2@KFfPNI?J^S(k=-noU1 zg(?47P>*bC$5YkD8`r|kRxtT=WnDh~Wvn0d5sj-eNFcr&9yLk;;OboN(=wL>87R_U zlmt^{y9OcDMtPEAi|IWnWOV`-u+&NSwpWNWuOFqa9|J2>$%kMj$!VqK(3dwkZ>VP$ z_4?Tb8S^m2h!1*`9_$jS2_B1a@@maEc}4&D?L^H6`1C!IX$k!>91M}4&Sy*e*U>9B ze`dx?jFnJGpXUt%Na40Jr*Y*7>JZXttLB@!QgCE&)|**bxXQH(a5`2x_sC|S( zj_patfMd!!@J+AgXkl%7W%@N3*_f#Br2LFo8zwt~HSm%hTi#VN4L4EEC)ThC?5Gg_ zFv%VCdD#c(c!G7h1xtZ~d^!&u?sThnvXWjIO0O2UOTNV3wOZ0I_lv2^IP1v|Ap7HH z`am|`1HJ{@E)9%aS$k0}f8y`ZJ;L-RKx{2V!4?Hq!269~za@kp^-d=w8S+$P{vYve zRww%x-Y%D;+cl})gR_qtTj90f=QelcrNaje*H5G4cQZ+*^;NQ0YxV9VI|)vtSdhRI zPAH?1j52fjX#c~zUJ8@RR&_`ZL);wB&}R0v9jv0XMPvUavK1&VZ2N^WfcriAemjOI zBwTT9U$_Q`64*HUSAaL$ z2WT4(6eN})Bd|HY*(Kd4m3!HP@Z`l@I3dQ;i*cEK_qov7;hycCpe#g_CE?VFfv^An z8+Raxkit29-VQO+{9Q?P2;J_cfx|rY`B-y(z`u+5Z$SMw2ZZglE5>jBR9G4!f`nCn z9ox^RzYzLAeU40zip;|+n*Iu`Z3Wwg+T%*LHO{s-+nj8^i@lL6oM&1z>@`Sc4A120 zn`NWtb)>G8l#ME2dLX1Xm>8&Rj3@$xB>#kbkPNYc6*Lqwq$16b3eYo5+$(%4^WXmy zKolYCgWJSTmgu4RqZy|v@&!Hdp#(nlc_B~;=uqL)wy0&5yyfTgEcnN`gXNmO9DXuR zX==xQT4{Eg??uW|W337J^LF>NfmeFi?cQu8=0OF!tx85sqr0UmOFx34eT((DqJyHw zu!;m*ltdZ(X*#RcRZ(`8LggO2yrxG%Q`8=!nL^v6fOwr)eXHmX3!;4dgajLrM5^XA zfx&3u00bDHu;%X?kAfrd5g@glY;z}^c1_4hOZ-C7c4BZ*>$Oe3;n$Ix*M>i0DA1p$=a(Lra2 zQ>&KOX7XbK?dik;n#Z+&%Gea$AUK)Pf*D4mYSm6qOw#xs^>7f7!}&p?Va+APdfj5P z50y*(MAXEu^rD1l`z$iaDmwz)%-;kJC>YuUW|KBjM_mS1SeSiGs_&lyvBhGFmQWLA z@BqXTK8g@Uap560s1IJJU@e@+XLJb>2Rfsye#6nG>g)2+cnskG^5?>WZq#KNZA;(p zNY8MtxXXpjen4G4$;5Hlb8dCVzar@fn=yht+U&4QvVzi8?_tA>FjM|4Rr;(cO-2=g z?3h(bP*A@gS%`XlwU-*8bSd!=9W~IhCp^+>VULN$(_ur83OuvfjOO)kG~|~~%W}kr z4w}%ma`C4ZQ?B7-hb8GUE-&-(#s3PVU`G{d4QjwV_r!Z*^Dk|3G2=ke>;wVQLADA6{8sM7wHk1QGf%Uw=3K);? z+AQljTt=o{+|^v_Kkzx5ZwvYypxy~5Cf2gIrZnDqF*&_wVN_ScCYX2%c9+AF88+MlVHJvDdSN>dWs+f7gqcfw zLqKrddN&p(R^tXd^_5t?P(!h>l$9N`v2HtCoFfmGs{-KD_f)o=ZNfTSF9PEO_?y0b z7h6ily~Q|ulg+s7Dw1uX{bMe4NW2V;-heiJEzc&>|3h#eP%fizD^!*@;+rvht1$W` zrxWG>{xa5*s-dtF7YYEF!Ut3z>_f*w02!&5;3xE30K4sjz)*ybe=f$y4~fJ5)?tSB2lVX_mrz-4MN6^P zaxvkZDnuCT^koSCz&n1^?rQWj1t*F2*;sq##t)jUHctS`aFIvSL({(1TLe4Y<6)!y zsbZ@aTcb<(WSyh*PADg`hjaYD@HYh(g;+zFjgLx-$gCl2fo%-mMod$@>$|c4aC7oUL!0H+*0lXm-kDb*2HgY@8STdLW+EtamZQ;4U*kZOVt1+5b-QlOu-8J zPAeaGONc&$01L{UH`^h}J~d!$`&|fb=$G*EUPYfidzGIO+*$RUk0sPouAqfbaU*3I z;N;thm*LkJ(v1wW#h{LZuR6C9O&v&|MMYgKeBM55d5GWoZJ4xYwxc$JtyDlkgV_QF z1&vi5UQOY5_Nd8}eykq8ivPSM72Gey+7!k4l1CFLR7N=V@20|z|Mf%kw1^M?F2KhO z4O)t;z9~=a@zm`us%!Z}y}rDGAOEbW<-6t_-_BqA&=rxb39(-nrynh0(=GCKv1lO5 zo4&6pPqh9q$x}a~0WrZM&;Y}ITxYm(ke7=AfN)Og4=dhsN_J~MDHBX=xTB+kQuds(~d)X zz1M<6u2+KcJz18`UI$*-iN6|-#fode{5brL)$B}cWhP-1bR_c&Aq-DBk1n{`p3FsS zB{;Qx11kq7aucnU@Y0idZ{>!Wv6WxK`$G6WafM?=sUWhdzk;kDjuxuQJYaQgIRZIG zE9}KOmvoIZ!JA$mG^Xwi+X8&&?TKq))ERMqk@irHeBLWE{w$=fy zlZ&cvNO%)1S0=Bi)3>9$2!K=+HTG2Va4fdsshi-!FO|%4V@VMhujI$(SE)j76Vo<* z7=hfa#go)m4N&qGJk@4g8 z(Un)?jD=7-hNX@~xxu3D&s*S*0kj*}o(xJ^l^<*+=R+>z;Tzo3q$RTGMR4)L;p`pn zKv>cp_=4UP_6fD7fqo7;y@?YC_&kC&@Q-A!eiW2bga&?%+}pDINs#|IdYz)7sDm{r z4CR@9%?<@ci{9r#ql;fF!F~1M>Xu~nxTP>Wef+-C>K|!pYX5bwX8d(G@>00nc9idV z8$k9rY%W(ee}Ej4HHbs~Em$M?58_bqLIfBYxjKD=r7VZfR;c=_n|AeCG+O|6kE~~K z$2ZVYz-+C}QSJmUuW+n?cJaJA=$2ZA9ufM56Uv%Ph0Tyy52~tUqnLz(CZbpGhHfcl zfjV*Wr@z?Y2DGQ(Kb`66?1X6R%JgZJ?2sUuRT`sO|@&J1sU{tq*PYiHfDw?a7 zsrsRcq}CLf7-u9t7Yd+;4sEG`?CrraA%w4o{uLM_IOT99ikd>>!uOU~8D-Wq@)ZvNKRRZbU~dNXwS**Zz`p^2%THgg@zd7|cL*O%?W=K) zbF1;U)wW^K4#MbsfzuwnOB7$6=qhK?0Tc1c=Gg9AV(Ae#wfwcFwIrUCcSqg=Wl30X zsnaWqLY1mj5Pop9VhG)WKT95T37!tt=v zVoaPZL7>eqLB#r?H991zuPF$Go2YfiX$cfKu;rbFBMPSl7oZZQzQWi#T{E^$izUbr zGyOxe8l@N9nj^woQp=(pLQ7zWEzajHAR$HKc<+Zr!cR-7xAUJ$ehuR32ru26B2`0j zbq~Q6MoQmV=G6vg64k?iAENe;s`{YLWImjWh8&XaU}}42UNLn0L@=Td~7J2 zD5|A|?xn=jk3n^6@W0D#nQLFLi!SYK+C{!Qg4dxf;<&+6p_h-pI)sk2=t1FucTOc4 z*v2~mdh|ky9W%0##1fYK5=He$#AZhStJ=7z>LxNLQap%?O5CW|ZxOzuum`8y_kvON zkTgd$OXzbZ@)G>*OKSBaCSkmT@`;2VQVO*jYGkKUUJJh9h%=HOIq_}^;fD`&9U0?s zni>{VN|p;C-EAIyo0q`!jh0f|NYV55tW`jqu!IMNmemnaD|*D{7)okN-DvzkjLUBH z)C%wo!$ci0{Lbtu3F(J0x%lZ)1}XXhD0RYC0Ur_$5qP_&Whn2JI<5H@F>l=hxHCc3YXF zCN!}a?%LUN4hy18OgK~+G4vP>I#EwtU^TJ!U^S1hcP(D!-B4ple=)2Tk4sH#mP4kX z`dMoI4qEoxvRq77mTJ;ZLI%JA{xvw4i0d}brMT|)Uuv1#e{nvpQxb&}{L_nOK`n(( zdYf{YCsF+`@k_1@@`-PbfEK{#zA&6Q6}?c;vM#*7g?(gGh6T$9Ia7d?c&5l~j@6Yy#};5X0d#*Mf&?v&{esZ7f$2rGB=5@qd)<(-p)4X$=8K;^oI1UVfOpM z`+kE7WUnX;7JOwf+f@Qz+e5n-(Ti*>fIE*MB)2d(9lr?m`bHm$%p>WmaHsehB#qOL zIuO3SjrxG$3cvipVES%T7+<78*jX^T&=mT`Jb6b~=o#^i4-ek=5WaD|@M-Ih}|ek z9v!Q{rce~!Wav4Y&Fp7flP zp0+tX?dkcQ&hN9{ouKyjf1dyIXh*5t=YMKt>pEiT$Xt z@1m~XaH`2}^%Xs6*?@I^Q}mus4VkOi%3hZt{u}gBw3BVL4XzkQRu^ZPBm=|^KCC~N z8ewN?ydkK07+B@ggw*az{`vqtykzLZ+32j8`a(UG)i?h->{lc02?hqR$00He3^1!00E`P^1!XL90Rl z;5U3!BAs$Iy_8s?cM2-=2b&JPTYDnV8Y znorq#P~LGjZ@BJLe=o0f^IH5dN?DcIR`_T`IGeI;=8%+u}Wvgzg<1|Yh)--kCOti$W{BIItw{Z`-dRM%FY%selh zJ~$_beR=Kupayc<*;+mecMNs7h`Ct+kdLrZ=f&-kB}5SAuq~=P-A&zS*Uav`4hZRF z`@FhB@EN;8P^6T*>-E<<2U@kS(PI0&15xpnj-r_}+%0CwQP;9>Q|8_G^Y6^guX&7& zL)V&ZV$FVECS#g6dJaS#)h*YxPH3H%S-U>F?t8g~Q`82Z1Dp&u*pcOcBevx$$Ig=h zys1!zlMy|imJQKlI@O+rdEs8y<6ZZ^$cuo-z~CVVXYQ#1XFE<+N<$Xw8=o1!u4(hL ziOo+p10TIjF{tQr(mSv4{XIM`nKvpJOT6tN^S(NB07yZ-Q&ZcmB{#(WZ*TszGJLcl)A6;TA_RNQd0oQmDoCQf#L>623t?C3P*J%U@8 zHeKFiU2`;HU2`azgG&QkjU6fUPuEFS+$I#G;K=AgWj*Hy+=YRAqO1NJ#nlV(`S_gW zMAfmCL2_?wgJEgEv}ri8>G!Q_hU|dTh@wUce>oAeCVdSx9n1)CSwU6dP|#WE+Ep_# zI3wbZ;+5OV77aLjud>DYs$;4MQL$7n^0m57J#4EK3NPU^OhB@Cqv9>{tt9e>N?Ui& zX|=xjr|g=oU|xCkLr1m0FCO|4e5Ga4Ct|AY(``$g#<+|y#Yc-SY@C*8R#*OsOv|F~ z)PZ3TGZ1k)%>H6(+-l57!`@zg_t(Su1rR^h$0Orx4sppC>$)51)oL}KBYI(bu$CXu zCqYWn3Nzk4lalpM3oH++8)>b=`ikPrpU|P#2?RuoaCmmT>g_p8=CA9;#L2GbKAAtN z%u@@Pptv(u82m-v?qwvgx69Ep9~}#yNKh0-18Kyy^SN@Q1DkeKBzBZGTi;)diU54Z zxVo>|dT2Wh?UIxZ;v`pBsKrvcWqo}Zy3K#sA1Ihc+0V-sRZjD&$v%9ib2c>}n?`Aw zyHgs~6+NkNsx`Yan0E&D9~u2X!+_+2S14upJT+zgEF?U3{I8Pu{M6zsRJuST&Wc)} zmE({&3URECgbrnKhWB26kuND}6*+b^2fFvA(NZm0lQzqTZve4*pTmA1a=wKp7P!#2ws!K^=9mMU%Vz~o zhD*oj&Zsc4@RIzM`O(L6x*K%EDF@Ps#W(^+Jb(0L!+Wy)Xg}h26Rtl`ZL1c_->2T= z#R2v<5qB-qi>8cQq^ODsNIaappZ*z1BDd3O`H!+LueIH%o*nhkb=gsv_S~7pQbW~= zu4H823%2ieEHIu4s>xyX<=Dt!pM-Vjl|&sWFL6Y-v5cAuo7W@?n^$Q|jPQYkkW4WI1#xphOt(i+bvfcBl~+V+Ul_>1Ez9uub-;nR9&mQp1n z>tLGXmiQ;5Zp!wgC!0e#b_dXl|(MO^?bI$$Q-z&9g@EZx)f8^|DY=4?apT~HkPfJ_%Pop0>d}Z=A5**J%yX+Yk9w@E z_WauRkoCfck!dn4A*+tlW(;hI5oxkPe}EXK-`V0Slpi6g({4M_nRvpq$dZG`Qmaaw z=`!nUUkrBF%G-G86Z#AYWg})kB{6&zhpMJ37#Ha1Jraq8cknRpa|ULO%myR>%HI-& zSN{5Gv?ao#KI*C?lot<=368E}jEKM~(`G{2>3fNN0S^OO0zzg@(q9$}>rBK%28DjB z&^<*-Lnp>2t)7%m&%esLxwDmw^yU%i-aXVnh<43Z1kfn>7>1`su*(R^@r38_6;3C0 ze~DvZ>9UBL)=*9PZejZcAVXtD6jgmOaY04m-i8S3iRAqCxN9I6ZK|IQH_fes9&OL2 z{@0l$>W{`Hz#5VzuPqwr7Z#1LE$Vm4p7T;_wI}d;VAVf|bO&C_ay;?JgM=kvX)~npi1mNGoE*d)VEw~oXkZKp|6QH-lPWhqj_kQHzNapJd()~Z ziB&hyRG8Il4sz+g^C0g0!5I(YbAi6cBYo~jW8K53ol0in9raEr)F^YPsc_e`iNak^ zwVNA|(8j*8A(`(Z3CaXm)S7tq0vp&Uv>%C(Xg#e9nmtX`O;(*dVb!56Xm=$jv$j=u z*ZeZB?kuMhcfnr~eyUEj#ng1V2#et-gDF}Y3?a9Xs~0#An~VSl7=yI@^k+v(P6<#n zj$zYv{Ph%f=$~acKg26+#Ylf>gi;M$i(b%HTZ^$U0C6~O7c{RU0GGNz@zP|6uFyMl zMW8EEm*q<6-v`+cd({o4zAoS0frrCS(0`#LEjkO5kN= zz2g`Q6%YrppB%~>b&n@vAc4dQdtboNK?r!f`D4!n?=;O8I6mS*8Rm1WcE0K$P>RUt z1NlH$T^CU|My(qU$JDpFaW|$Otav8sMBhu8UexDQgcpRLiKrZZvM#2&^q;(1(Z!z- zLCc@$s5`2oZjpiBjc@SyUuvv3kLzFeq9K-}3!mIL5?3S2TS;geqNM|~MY_EYI~uWP z-UY@Z9K&i8)K5fDzu-y&!We4?Ypu)Y$JhuZ*ueEpCnpc4eXRUi~vz}KUnJ{ zRT3k;Uea_^;-vfWPIDcL4%Tu^NFMN`uqm9$>l5bNawfkgA7iffn(IsITAS9~oLF;1 zca6)SWSG%*d9B%p3|7M_`({S!(N9AocU;nZ3&<#rh-6fMFy?b zi)_b^WU>8ot^IRA=Lg%6M<*$cC{y$Y!UBZv)Nporu-Of5q8wM<(^^BT&oTcyyT42$+&}=p;hW> z4CO?ufw}9WLIqnWA+&Q62vj}x$q0+M_Mq=pd` zi6ipeisj$Yq04P-Ao{O+b zQeB_1-RtL2?${QxR~4pgNG&a?vMznl*KW*^R~_T+G67u5C}~43|2j9da6qP!LQx_4 z19aOcyqj81NxO$K4#^ON_{!%W)Ci-IjU<2P`M;_(p~79Ra= zqVVWH+isU|aoDN#9duigva>#@od<=4#7Tq%^YBIZ4kM%_p*pKL~I<8~w z)ahXSMMt1{cRFiMX`6C4E-A7QAov3LVoKC&e?PbVGPeVAnLhObnZLXL-6$-1JqDg} z<@Yjv(GEM5ojX}g%MnQqNgkqqG`diCLq`+*@+mhR2NnjbNoQYST34EuEdR$CW38^D zfm_bijM-mvc8ar-MW;+Mag6HeX6v$hTGUNRwJz0je#R3CMhOQNj}SAO+&idA@}K1IiSruycCDOtqKl{BPcD&oI58aOv=;Ip_{K z-On28q0-<*!7M_q)|U_2CR2Q2fte>hGKt8S?+OoHDrb1H>}2}=%GKBSjJz}?FRGoQ z&VqNnwZz?SsIQ02kD`=1exgmHHoLtu0w>2jAGs&?3=V`V7o|}{lPN8Z!1o@{II9x& zwyLC|0KP>A*Mbw5hotS5Jh3f3=gds#pf{}eB1UAYd^D(?3}La%JJWkBX|c%CdX~B? z6(ccgcWje8_r-0<7tIE)uC`XE)c5^oV@Wp1wO!tmjTiZ>=`MWpk(OW#EN^2DE5}!n za={x!ISy5tJt04G7{0zW z(Z0)~>DayXYTX$1mpouA8%-CEb~?{Syp>I>uf)Lv?1MxU;7~-c76{fE0Z$x`9`lMN?F&Kbx8 z&3u&S2P#iCSD{*Dcq6Faygf?YI|aQvlX!`7?ywdPFun`f2jf%zh^Rn0y(uG5*%HZ& zEkOJtSU=y8WV9va+%KyMRWvz-K~VMRX*5#euX>C~bvjX~ZqX5u zJrV1P6)vYssjnpiMe`Dllu-Z*o50GTJcP4|ui8X$XQ1MXA8nu)2Ul~n zx~yG)b(`;c)UBnWSBt#2C!UDkl3LoSUUZc-B2a83!_vWnIl4+d{@};-yA^B_Cvbxn7ac}|X{IP2x}rq(RDe2b3;*GQPU?#>g6X|W((21s^_<_@6VLQa z$||$Okv8T){q1&E?7voM7(+NK<>P`{IS#RcQ|b;+$QQEy=TG(HpaEon^vO-Gud=eY z`6dSSEK;CDf4dD?9M;w9eMA(uL~#}nWGkv$yuMpPV?z_8xme+&w&~_-d4pk4a6f`L zI0=*ngKpG7r0jvSB`~|@UVYhsCtnW>JtTk^N5i8 z&-g3xPq{0AeBLJ#1@B|i&5vh75|X?Zi+3o&ExhNBq~cGdUdWm6vce!K_5-e$SrhWr z38YyyXG;<#ewg`M#mPgqTTqRYS1Maxd-aty4?f)`CWCrd9v%*m2^!wQRFDNPnEYuKM8XH6m0ju8dLm^Su(~ z)9%T7ttnx>cI9M@7eX-mLWzAflg%CY5ate~Les4_)O<*{saTUR*JuNNh*l8ow)1sJ zz3Xys_%@LDA(~*hD`2SaPj*bTzLLWw3sYo%qy{8XjMYjq0`P(>&FV?jv*=V^g6Y=A zGLJ~?3E?Q{x>Bke)Ucrwa0pl=nytHQb7oQaDr>O5s0vi7d{v=hy_Z^xV$-q&!V;ns ztxcc~@Pbmfg-*F&7DNQ54IF(4zZP-_Gi~ok!a)8Cq3;d9Zf?o0UOU-*#wPX*8xG-G zJy+6JlJ~q&hJePk>+PGQ)3NzBGW71o7y>`XrTh9SzZ*Fc;2o+(<34No^RP!qzEQ9s zI1KVbECWZE^BI?$W+LVZNPNjc=sP*lH*A2qky=I>*5 zjl);7>o<{wk>%0Cy^q(uBq-j%@zu=(o-=rXiT| z0CKhmAs`KFOJheP(C?Vq01o6Kk;H5>x7FMgR9~o7b3)FkS%FFBE%jRS?y}& z3cmjoe(ym6gb%nfGqR|q8I)&b+~WBjhs7%Y0;I(37ivI=^(&fBGR!5iC>cw-tB-07 zKLj_x0A@g(OI|CRQkJcpUwy0Z0fSg$`FAAN*v26!)!rX#Fj&Kr0AVt1!_LVVRQF^k zSLFY77_$yw6}gK+r-4>6TUAdlD4d{`Hq8xZX1`W& z1dsub9fmacp(6n+j#gl_C7VKW?G+lq1w`lt55AvUKnzlX4VQV?YwkVUx9c#ym^fS$ zdGnPvts5u6qr*xqjWZc_C`b+Y#u{@8m|ajSTPXq@FV7FF(nr6C<05=|RNYn{m=8~G zfvpE~612Wk7$=_)a*GMxVK6?wd%>G6< zXxQq=x~5fjK}w+?XB*9$P}P?0#k#>oc^h{ry3*#Jee9|ASgW2an+WiQrUP&)+;d^l zou=;IIonMyyi27^);(1T>mD1_AMqYI-~#I-Uyroc-4%PH!AN>-_m-9gY+_2Vbo~2G|k{%LwK=>TIz!dyW@rH)6Un3$+S|4Q1K4Ty7D3|5LG zXJ=?01gB(^2;aDdcsxwo&;jG{kD~`S#y^-BSKn`1|G9*E>FnzLXGhzjH^kQ8TEBiV zopsiqA6r}G4Q(eu9V0J6< zSbzMTn<^6qL+qSU%-ZJES;ctlRT1uR>9Y#P@Nz6PsVBgw;d zA15eqfG+~Dr>>L0wa^-7hC7aA$B*iVnkQeV{95=hruLn}E^xy%3| z>wY28h{xyJl=N6#zpsQghvzl+V(od=#~Wr`{?rxBN6g&r%wXR`yiLTN4wb}b+pP`q zuB!2Y#vooe*pvrcnE{~-B-4T!CDm~{(iftASX8}VrwXz1(CpBX_~V&p@+(=G6GQDt z>SIA+nvnZv9;NW_IH=`ls?qRvf2t|sZegWZ_KX)@l?R@$Donh3j1Ru_prfU#!@FUl zVV|9cN1Q-p+U)N_e9B0@?h#MZMG|KV4fu^}Or~Zru*2{Bcr4na!@dYlCdoe%u;+$h9 zs|bJ+wbzC24jZ`um+hq^+?~s1s*z29vCYu(9B43FPhOv}p8RSTRjzfWk;v{Ex+s+3me64q*cMlSBK7OWAWUMUiIg^9HK9hqOz=h-lES}ZZ>fd$Pzr=Vp zpuSXtzTbh#^quhGG!dwL419S2(MIj;0Rk#xzb*+B{~s3XD#zSQmybs;wNh_Po{F# z?~deCBS_{czXKiJeZ**xYFT(YC4?NLG_jq~ZII+_b1rMXB$Gfp%@fW35RBwO_K5zM zxmbKSVJ$|c9Rs1W$DUQ5Ib~{Exw^9wnwR_Y0N8noew(eux2AEE4(rCR`9*fK7s@1T zOQPO%d0NU29)~jtlv&-twgwM-*IxyoxzkOW21%CO0frw zYD^6qcZl$Xd==Sp^(tvdJ#e-ifZ;2o%R|BL(eFegn$oM1TI=BYXt!+%`OvpK@p194)J=J3)re>*+y!3WDWx;J$&?A7 z`hFo{pkiT=0xn!SmlQZHQ)GI{n=zSi%o%+hOE%}^*lEV6B*$)qB#r{OirU|l1ZAh^@CrzCWE=P3h4m4i#&`XT%)+M*#aU<0MDgf3B@rJS zIV7>v(DhGq-A9I_U$$7f#x3L>Pdz?;ecnYaV zIZQpt^OG$p^pfpTU#ahLeyW&27dF?K$UAP3ebVjV4`?vP_kw@y^mTsfZ;ulUgfgLQ zcs_lvoPnbc;+onClXxS5h`LYS@*Xqr0>;}(-IdH$z$ldsLaI0^L>{ImFtO&oAWI^I z*`(poTthtp@%}%*TejXGKvEh@!Gas_2aS-_eqDvXzoJ5)ZG$N&j%D{*~zZO5xPh>w98mK&-<5uUhF7;)Px|;+vo=1ai z^FQ?*;CS*l`uwKkB5HJ!w*wtRAB&gW@xs20oIn|r%RJTv4Iw+J(d`i)S_luq)xyz3 zPf{j^`ZAD_12QiCMrWnW4mM_!Gu}n)pw<|kK&PI%pyA21*%W=+4)6Eu`lCnnRhUnC z5j3b%8;B*Bd6&|(+gW?V=+oIwr>Ooge%h%z^Sz*a2k0tWmad%>f#-yJR#e&=hF{Hg+ zv0J$t8NKAJ6dmAw3Eajr0FoS3ICVwRIeSNv2Y6tVL&e6m`=k-Dem0`r=;|wDtF!fG zO-~6sI-~B(xgtkDh$Wz?*{3~0s1uA2r!NS?L-Q_VcjD#-gJ#!p^DS4?f`qM+tH(^@ zv{nAZDh>nt&ISIm4>=vf_54?&2W;Y#-`TJJQ=&(Ny5(fl%wmn4ZK1oAv1(bwy2^^J zx<9V&aa4!;_SN-e>aL4D*3fg&1y=J!yGHVDGf{Z^NC({Wj!trQV z*j!bS>`Epk?Y_NrcIFlVOiu?w8Gl?K$Y^Eq>3#6muuG1U^$zVPQXD5OOhz3Z`xZAO zNP)_9Z19^K+{?U$AD(ZhY)CyC$ML@5NN57}*1B3($WL0Rp46JQ?*inU=Bs57QP zTaUR_0xKzg9}cN(Sj~>8YojQ9bvvBZ^bDvbYQqA>nM9unk$v1njI)a#6WPM6i){i<5r3{Ikc@A# zxk5NvD*(+@7u^x2d)Y+QC!HH?&X~j;k^8!RG19gj3DE(^GH_j(lVKz}XrM+gZ2xc} zKght_^4Lkdd;E_Is$Y7!bwP53r?F*p1p8g#32a`DPz(wy3!xZz76J)N9(u@7vjeMs z8d~*Sc-7kxb#IBItJ1n+TUECR-)t~MO&3lBntdnrKUiA}XQbz!qiSmnYejm}oKWlCuGWV3 zrmn;^u@6n=oeA?!f1GuUDhmk$sxczwo$8nmf)vXkrf#hAFOI|`<4FQ`<97r(!cdOj z37xsZa1)*cKHO=iH%*_Fv2|Q#SWBJ`L+nI`r!m-04U|+PeynlRozu;oGtHeP@dNd# z#>rM9q+`b+pMx_`0u{Aec=Ovm&k+o&Z(B?8Euug;=@K&Dk@y&^A0CYo;Tvf7RfkkK@wY{P#T#DSaJx+&viF@ z5H>aO)sSF4_*CkM2L84u%%VmlKB#GH{UaKk?~4eRfYWB zG*x5ux{oPr4#)?#-I-LPU_tPYYqx5|4SR0u`ttyG!Xx)-53B zgSJ(mjSCghWqr%a)bw)ISEcrOdjft}a#6}!_!J^{uF&{gdzT!R>RCJQECr4LX4tW? z`BSzf1yOu;&>^5G(GB}1OzeH4q)E+AsB4;WVNq=vE?1jNLl=b-;_^2eAz@z?4T?dc z<|7PTAH}pm+YOdWI96R-ney5j)K)?j9~>JkVm3Yg?(+ZV9W}hBuZgwEelsCpE0>zW@6B%PXCrk&no2)?%?j}OREAPvV(yCOnC)SGJ$9VmlIM=mB} zdd2cimRNC`bzsd@X`ORY+mBiy(8Yu>JLKqSnwyxNv2Qzg=4CZVCrEu}tM52# zCxnc8WNA^)i@OM0PWm>IV3JmQ4mI7SepAwOmAfb7;ToP>OI>BHk*+xXHa|HX?CN^~ zp7gOC1_h$%3TqgT1vyZ7ju5aW2hdT~<)Cz+?t;3;SZmx=$*$=moenF^4dF?VSaPI? zX_0L4_F!W;9m&B?p*$S3@{@%56JLuLgYzKMahG6#x7-NBZMHElK*J(IkjW+L6TK#j zSOj=kQDBCn;t9SE(bGD7XGupTFR7Pm$Qno;;$Ds5Z~RFSS7Nre&dAY=Infg?jguHl-`e95Un{Mq zDg4>HHnaQbw!Zt@%oFYAo~iMX9#QWhdq(56^kwO_f6GkFu3b(L%^f&7(1X&fO50e3 zm+g2nU<5iy^Vt-SE%6C02rO{`46CQhedqd4I^PSl)D+(Q_d0V6AqnYS0+E-Du&~;W zI1;X`ds-#i7C2H0wuE_Wq`X4NPzx)KMbSCYl`)mAcQvPT-Q5CTkSq{Kn&iE4=6j?( zXaL#@w*=1AyZAxV&G%;_Wx-I+WHh@Qz!w}7sH>72KcG`?dyRO|n%@e$j^xkJWnx!5 zvz4=}9`mZ3d^N3fM<#_cB#w37?T}F&@})d#uQ1O>GMl__G_xt+#i_C%<$G0_8{Lw` zm_B1>$EZ8~eu6YTKbY^6uh)5~ZL-F>_3cKL6c7((R3@jcnWFxdS5KBWr}>tK*SQ%n zid}01ImgI4bT%itYh%s)7(@GbxVAes`mGPOvLbZTP~kgIi}+Eh3glCa^dTh3y*CS~ zV}?=q<*x#YV0jPgFt_R-r}(|>C`%o62jjKZX$}r9(0&%w)}S*Jij2si(-+G}{fw=R zu1IksfCv~K6xayf!@oL9aNqdGqVTlcB9pFvshe*U$ zrO+#(W2{?U>vW@_t(YWVr#;pPk#H79`c(DO}ta&#knU+|Am-x$%U@hG#@i z*8B`96P@T1xc_|$uKCLTQTszODItemYo#q!U4b)Ux2;nFm}aj-nY%-Pj0R>t4AgoI zv>*(d{o3(_PIcy{it0D3Ro17b;9*6TS?8(s)iy>7*|l^8C2uXk+%VJw>$wZz9dV|K z-ksjBTL>h;0`4_jd1+mz1!M%ULWQ*3XOA(94Qsd9vh-y; zzle=0gntZq%@ws`k7ZZ=FP6#KYF++b`a|TXqnkO~ zN!jkBaM)2OyA!~fkO-)Ar~?)PkzLMQ7g1eNbxn*;QlZw^O}VGwFZ;ydmx1?XSOC_n zcM{etsgmMsluyw@zSh-WO;}f7J8I>mey64`(jDr8po7RMqm8*=T;^@}o^*b-`tjgX zF?5#jO9SRBf7jySgkShQBL$1>F8$N!zns(0YoP0Au8Acro>nO?fJw`;Jtjx)HmGT* zev>Gi`jv#2Y{>Vjcl}HCO~#6VdM>2C1C3=JeTf^BEu3P)*R{llcvX1n;z9qE!?U)f zUgr>x>X|_XD2S=)G!NQq{_zq=d)-a-cmJJ&-p9^RBdU~)hs02>7=quEAB2pPap;@(3y>$zzZ15mRZ)y7YvNwjj8!EKywzC-Q6_!y*a0n^{~ zkKq9Bb7cKm-xPD_R^JDFfu-7YA2{a6n#5(iRR2TJ5C!6`Fx^B%%t2 zpz2W)Bv@KN*~0$cBnv-0lr5;21<;pzIGEx>vR1WqEg^LI7OIQb%Y5N7LAXjhOlB&2j9hw{Sb3x2j$_w14PrwMYlg+YL zsWqQU`xt^AG=1S}zj{1t{rp9#^(NwUa|>1D{qaz~4yh<1M)u36+q6y0#Z;&J*qpc| zMNh<+kw#XxCDiTB;OBePBNc(m1Fhj15gzGq`BauorlIRRqOx#m5LkTG*qxRpnDqIakkD)%I1_pIdKTdRN25%L*Cq zc<2~!YSr6q;}hF16~gRb?M>llqc6eTWvSC+ifr3XycHoEN?9Nuq4~tsX==j5sIsp6 zv;ely-$XL!NLBMKndzDC?7ZCKJUV7I)-CQByMK)|CKUz(G{7xbeIS^Z0;I;sl?}5s zEe^(7^#c&-XfQn@_*69VqMJF;98a~Rt!)?JI-#`SFn`KHx!LdFsSn34iCI52^!W{G z@F2SW5Fz4Q$qj2wDP9{4t7m;NToSQ4=4xc==pkf(?vQ8KhaPM8AInsCrMfp*njDiH zpH5`5>{%8)Qh@{rSP@LBM{V*O?B`QZ$>L*W@>i$>F2`8dYg+rE2<1xbN~hW{Ex5_4 zV@b^8bOKp8nVzkbmch0XJ*$Bz?%k*ICKkOlY66jb8HVb^lGN%Ylcr?~bwzkk>KBCX z*}^kzoGr+pTlbq|UC~rQ4)i6^&Z0dgW+$T2BYua`Pl%3WF80 zPHf6}lvLH>N`EqXPPCC_(dHK%tw=d=nRUrO)D)h53#|qeSt(}>rNVgAumRSVw~FH` zRW)7!CI;}BEALj*s4No}&?Wm5)+O&wH}|TQ?po{ZgOS4j{CgduS#fpDAB_7)K38L? z3_vNaVbNJ(ZT(YR&@SOR;MxtSr_Kso9l9ixmqyfav0^#aS-p^7iu4j6VaXF%VTWM= z?G3cjx;GFHhWU9!RNr8ficRFAVZkB@-5oUFtE{P<=(X-U$Hzn+^Xangx2e5yJm7l9 zgZ+-EC#k5v^)_7-D_xnOris1L^|0FAfQc>`q9;e?1H*1^_Ff#NwH8* z=whA-0ia~>`RcH)dC}A8wNSqnLdh|d3hpj(7H&T`P%u_S#*Gn>u`f)kBHGaeyYv|; zIUNdpoOz%1);W}8UlVDyv&aN-cG-0=jy;Qj%6j!uHLZ!5ZMb}EBDRTeJW z<+p|_WBCzPF2Jgzwe|rvtP2W+0=32%lXj0@dQhz_uer3Q@Qo({=&W&%#Nze3>%6cV z2h{zp(Ab6vX+Q>QwNA@T_h9ARV?7f=nEXM01{o}T$H;N87a3hCsD4G=R34cCxH2nd zoqJyW{04j!T^VuM$rjcT&>CmjihirxFDr6bJ6Rt&I*i8yD+w`4_eMZvwlR);ErIwZ zDPCFctfzemYNG%HwRa`)gtiRFQbwo{ah_ec>9%Mf7m^~eBZ<9_Cigs^Psc!S5r#0hV@XuLMH^Z2lhz%MNzhwfQMXpqbk^Kk`*7s(I_vKG zScyB4%x7j%$DgU^5UN4iR|_WBjDSj-;>0h|f6fywW_-FxPCC=?lZ^9TN7|M1Osl*p zKtCD}dS)lY34z0j&+!_j;9G48>synBH0Pil=VZxqu-*n~i=@kI2PuE*s8IKN)k9KN z)R5Q9Q;+%WmBC4|24=0h0luDg1<$O-KD`$E#Eo1X-0*c#;1Y8D8cvRlHT8^xm%LOPj)tmin zqa%6+mN=Hpo15FzHpVn(qicXq@5TQpc(OjNtFl-nM2$@?N@|p*}yMP6$v*bF)anR+(>y zmPekAs$89#PWAM}Jl)_$XA(Y`miu{VPr`brcXT~VNgj0wsI}XH;dbfdO|jgoI$`v& zGY8|Z0Vs)O1O{-z(cVzv|AlUGC>@)79gE++*&{;C7$w>xmdWS5U_f zx6skk?CzQEMF0&0e@GoI18JN{PgWEranWHVHsG>t6t?j~ulgc~tnh{f9zlHOJLByP zHe+{|dC1S(pL9EBd9U*oj=dSUg}qNe5Hmj%nKONSh$tHMlg{SCeRrZsgca}iPvz?_ z^?Zr5(KF3EDT=*_R7s#5g(Mop2B|ReZZyvew-5*`4?vJbI zn&inpA3I+^c=A`H4?bb^xnboV|2`AW^nDZ_AFn7G_+l^8OnS6_M1Q47dp9DQw(;jcqrMO*{&gYc{6uXPX5=CDyu)wo zZi?SZ@7njIe15h?t~m36{}BIPTZ+v0*qJ!kPJW&oRIbd2T%#NnFKxxV%vQP zXLy7sFpdYRvna!G)>+3R`m{SkVc#sr-ex&`>A{3Hn0iARn{QEY-DV}aIw=$%@sS{2 zY9C5a$w9T#@UW4=kW%JuV@6<6NWC5Isfe)IZ&?;El)<$j&QZ!$eX_i(o+`B6a`Ap% z@Tmu5>Y+~c{qn$912cm6gdT{fPP!%->V;sy9q4Yrn?B^KXpESVx1T|Ah^a07Ny9MvFMJb6$y1cvJ4xOHwqw33FLEfs~^-mFeg98TC|iNp`vQt%f{ zp45;Fhjt%84DzFH#~fGTk_~0>vSSZ7Kx|7}zg}xUJQ#d0oxyFolYNA;qVPCv`=P(% zC!onoy%`<=L-gxr0il%7lL-6?Z*RK!m}HhXoTTkGi;?gKhpPCpCK$*f z8Yf8UQpF8YT-*to{ee`y zf2On7LdDcI0L3c~%)Igd%@LmU7<4kJofGpxsUEIQV)y@rG@rJ3nyd-I?To8-*fqcE z2F->5T*5OaAtxozy3u6DFFJJZ_^OcXU;)c=_(kk{v95Zxr~%toHnD2tRcto7>?37~ zFpcgf<`doiYJrbspbmo2a~cc=6QMM$NcEl&W4B2PA6BP4*QZ#en-lcsWJ1i%#L@8g z_wfW0Vbe}Ge5qd`-(qBT^szcv`Z`KxWyjPj1a8SX(%|MtuF45?NR}#+e%alU6#S&Y z*F!iIrDSu9{=V|y<@C4AhtD*?(A;%NomFG3K{G~4s7#8M>+1EZR}5s{%cHZS^QE3B zc`v(Di$Wj2Ibj{YUaunTyNzX`9E6@7y@AEgk}n*K$oly+lujMokdV(F)C=X|g!!)`F;iFzQ09SW9Zcx09qeexDGElS+PM%O?oIQdK9FYmyd&QpL&*p zc#Ln8c{pJnroS2qXK_~*Xk}skG0%=SMIn0%+;3e5Ids{?%dNO^1tt$P!F=0zzcRY_ zmHNKMdi9ktJ!2Zm)8o>GIX$h}?CjjGy&V*FZ!_3Sd9c)&vPM*tgo-6Gfq5ENy>PxG zQ8@4aB!MW3Wf-T|sNZ&LBk@1TgW`jc>~A1aKcv2PR_isnOLD1>*>o(X1zMz@oa!-F z&RN#P2G9rDX{YhW+b@%%u))@enN$|KfrBbYfpA!G?y=rRe#1Kf4Nvor)V4H_YqmCi zn2M)eU_DTd!-%;^%=Mf!Qade{}%F*a@;xt9K~QT6A#Ra;T+K0CD_ zb9H8Ut}uH^=Y0@qg(o0WO|Q#PA@qJk{g`M%-4<8hN?L#XRR#}P7L88P!@d1bEp_5< zp`b3*qj!9m@B_@){VD6*ooNEjC=G!F=8pIsaiw!E6if+yCuCp!>yi7ocs}06r62sv zr45ZR_xeJlf{uPUaTL<3P`P?Z1c}T)k(mcy3ev=Tv<~5EPZ^OILu4`FUh9oZusI~F z9Om+}@fF%C(o;|ZGNBEsI~{@4uJ<$F$zPox*QT=KB){y5Toy^xS;_Thkfi90q|cDt zgyYYNlMZyYgr6+{fgBtk!=|b}={SXw5znLc1|pJXHBV>SS$jO25kN{rFYXjmlD{+UzuLg%?S%HB7g_T!_M$Lt*ownA*m%apVPO;p2Ho zIvYqLb3m=;r0Wk5Y(;4A%sSo}Z*Nj766&YT>Ssw%*+T(ylem}fm4&`W!CF{##MIT$ z;?%yf>PWS9?u$O_g3AL|%ifr774z@3FNY#jbmUwe9;^9>Wq2>i=e74+6qK535o_md z!h(qM;by>**We(7e%MDxK+8e;V$jb??%%Pt6v2SS!x;jODW%Ta2%gv@eC_~xrr{^ix zUFvjAln$s;=d&k_3rK=r$H4vEFx?*!amea?tT_V$NE64?65^ z<_qmDQ&lhiR55Pu9io{i&S_VUMqM+zRULCX>Nl6Ge@g$LAEt5VA{*OR}` zS{-jrMPRqY-9mPGzGf&(;Laci3g@3C7ROSrlY3_lfw$a&4aZ}v$2J#?!)dGGa-IjR z$=;Dl{cr3UWioOL{q7B~XD}Ear&=c!rreyi-Wn&}t1JLyd<>{hN8;ZgF{)-I)YZ*e z3ep#Km~XheH^mmqfN!B-`hSwuX^hJNRtEiyjSs5P-?c9cnZI~tK6#p zeZ4jN=1v9uUs67UE-)#n&2QjI)W@)=s?bPj^xXiT!tCWL+TKxwt+szkyYN+UOkTyB zzl~tD`dN+US{Bt^6`7ftcbDW;mJuZzM{CEiR7o%Nt8G$@_{OKv-eZ)rfhX=;C3RM` z4!1i0)?yxLQ#;7 z9r0UZz7{kxAkLT}oVNo^`RM>`K*9Lb7ahLTu6>y~nFq4gSJvj1Bjz%-1hT^HM0cj9 zEfSb2W|QLuhoGjDAH@N#iSiBM_W^EYPaD`2S8h{J(nu|6eX$Av2CK#(`>2#Frk zms9bLokc8wb=xg%#@?d)C7p(4r>>=9nL?An$gY2kWMd2B>KDyc+nq@^=YY^dmQYIg za>Vb@glp+?!akc>8mbSqgmaOO2H3d{QcL}kKxSPC1h|@JKcuG9fkibO(2&La9xY2N z-Btm$d;$hFB!UhHun?6yLoOqgUff+9Nwcjb6N?ilh;oa zScRIGC9CN8u7-$`C#8sXX?PcQY7E6b}#@`IzND{AJc;Iu=U@#Y+gy-@QdoM z^5)geyB1{c$Q7E;>RbZ%wZoe?)Q9xxya3UzS4Tka*duepnWY)3huX zy;Z}-B?Q$O@^D}ZkqyMb+#Oh*&U+s*;MSC4-dl$a& z$0O7|L5W~9%DHPP<#tRAw%5)IFOKUM$&SD4F9npO4_&M> z%R`+}&v{LYFT6G?EBFIJ<4Aq>Rj6-Ps-7zKy^8o1@p;)rIqTBN?dAc!xZuuAG2hOk zfD~Bemz}VYLB4q`+E(n%L295Jw*<`Xk$pGDZn#v6+CEjL@MHovOK_qm{ro3L@38jL z5N|TKlqSZ|@YlL+?NqSpGDIx*pkD(e7>xf!AX0CyA9atHWhlNt&*A{7j1u{_!L zy=39~8L6JjvgXQM&mtYlNk6_fLJOm6Nle|_pq}RFwfe(n!aMa1)JyEtSCyJ>*i+_e znxB|A8cW;*93H=;I~s{il7>J5`{0y7LjR`q?|)M>@+V-=P*DesjMFX}(3IL9r+X}o zs?CRmb9)9fq1<+acz*z*FA?#e;}M^l>{n9)CGi`Q*0~R&>MX2SKO_dV#R%v8ar8{< zGNSpWD-5FMa$h9P7>4j_5p)Z52a_Nf?+Cf?1I?I_WiN3u^)!YSL1TMsYW7o3#}jqx zIkzJfm_}{Of;yTj!Fuc)u^3Zy*9ck9KmbwDq|Cd8%#*${ZJqZ&IZ+QSQ?Jm-4{=Xq ze?*H>^F`JQ>(?iBhXMOR#gipDo@5&`uK1?|#7SylRbpHIMd%Sz)x(|Y5z+<;SHA8U z!aH+y!dzY5Dw`W{NA;J)y5h6b=4r`X4wC)GxV$-uQg=zdVAsV!O#5Ec+)>(ecGH?K zCDzPNt9igi?!r5BqSnC2aVmAAR`g17C^o`WLbC0F=(gW=s%MSpB=@Hhrc#t9wWFtz zDDV)=J)XEBJ-)Tjb{OV5p)98YG*a_)9ZzuxskwCYSbw~`iQ%qW{p*;yTJ!fw($;Cb z=zaCP%Q&_(U|s(Yb>{nyLi5G0aUO{f_p!&>&X3hp;X%C$>EFiooeWNvq63NQgv@! zJun@SW+$mBLP(mY|KTa*aN_FwWZEu0QC)bp(sv6Z4F}za<2m@59WDW~-r7v6{BEyqAvzHDxJ!TaUPjGCtf#kqX^R%aVG66a5{It3TXf& zxEJMwy2}LI9A<#k*IfG!lt6fxpBue;04Y5VA8;(1G2$>15PYq{yZ4yDZ!yvu&Bvx` zQWYz_M%EYUn74!y@qtu!nNKIor@iEz-#%az_A~|3!C4^=#-w%IvjUm+GEVl2Ipqg5 zO-k__ZDDep|1HitT!>ne@c?7`z#Tm@F5b~(t$!n7t$&RZR&DXBO@ey}bqyLcW;@KZ z4ZsiZHb!b3Bt^w$vt;>4Xo|+V^CQAOLOa~t8@F!W-BkF>;zZ#qi!xYqC-K0*S$`;< z>-+tOR|kIo_2@YzyIIzn`uuvh&S7{`8>v9(>38uw?-Vb zsrP)7-+em&?%aH1oBCRphK6^jmrA{tcxMIXMheYiNR3&S-I}m2yG2`gJ3tmCAD&(? ziw%xh&bgI@k!qQg67eXaUu}S*gLPT@12HS#~V@? zs4Z7CTnXJwlGw#k|0Vvy?ZZall6&LvQFVNYO_)M9jdbhE1Yz=mcx{5g`*79BGDs1O zpIHXn@9t#6+T8@8;0nQ36+=inNilI!FvxoxlwUqbfAZhNDi`@~_aFFuh!PTerpIb`hpk-$FJs(#FL@5hzz+y;bDMKGA59 zR4&}1isToPOH+l!a|8h^SWB(mE`;(lBAR^b5qKpG_sSnhWNbMzUHV@e(GksDEpTkD zT;#eSVME`g|`jy}LD(kKZ7-gA{}K&5#94%tynN@d_nCuWnr=8HgDn?G=jd zbg=I~f-^$uzKHrTN*wg=fgFv&xdOJ8raeeCf!gjD*ksV< zNYtmr`wi@WJH@qFdvFXIGrHta0*R5yot9|l`6y7}KFK}FNiT$E*7GMnlz3a?Gjcsu zc}ec`IPCTsvZ~@H7M*4DLiA}Cedpn7dMjI}|0`jg{-a$aDT_@#epYPe73W@IeY^Qe z>)W4?)3d!w!}{v!AX$3tYV^it)Zg@3bRWfae3_q*_$0kXcP)Ej(703p`Jq5A&=q{( z3?#od#9|o1Q{zm&_0QU;6(i<$w{s%T zOU%iL{ZJo^8gZMs1D~yn&5LilCSG7DBjd!`8%ABV}J6gr=4Xf!$6DM{&f?L;19@%TJT48Yyv? z`j?25ZqmQAOrAyng?&EYtpQKomp|z3lJnU{$zTZ>)?X*eDlwdn-L&wMx0UanQPE0c zoWjMw&FeTrP9P0Yg0br~O0nd+lEVF4J@d<)MpnxI!Z^BERWU@8yA7!~bO*e5Jc&qR z-V{7u(fI=C@-^r@l3#1#IQAVg5=|pvh~zoN98m`<;OIQ3`l^dF?}tWi?+@wwk@8F# zd8_Q5fs#l%Zas1|b5AxfYI3N~RIi51;tlqOEYpieyB)ROXxiHykfvn-4A8p+N!_HN z=*q^s^4)=$R{klf?Ews^pcgeH9m`ljgOfKe%;`SI?i5q+Pg)XS`;oH{RjDHp%Nz2!$5JT2ph=ZfPi?@;L zjE;cXE~zUKr%-QcH!KEHxs{s8=KWM&XwJSIhZ48y{;#AtE))jLGf-cA;?tav6gaTi z)({9qB)bFyo1>rnR!Fu$_2Vq!(wH!C_%&#VMVQny;64(c*Fie+`b zpy&1EJM~wu`L3(Qv!Kkz*yXwHmq!NSOp^~M)pBfUQOY5y%8elqG4eP14HzM&|^CYpRA9t5Yt7UvlP{K?@UqPv-xNIB~bR@LR5?;H8#RR(rnUxfmMUI;?lr<>bn zn%mVOyK; zi(}@Gv9e25+#+x^+u@xy0F(h??@i z*>=eyNkne_ddHbNCGl>*^vao+ILf5+qOg4detSdT4$;_kPNY2A5VgL2Gezo2H3Ko| zyuUIdV*On18)x3@IIziQO?@+HO=u2@-ea+(J`rDicP7P-m%da60w_V&O{{R?_efyz z3TYJ40V?{!_0IUF->_`tAZBJ%Ta8)~Bw#AWH|?CX=|Jul;wbCjY^1U_U*CpygYA6^ z3FzMc(awbrx@@oQc1pUYaO#WEd)Y>wL^B3&>K)>&R5iw0kZh479@K?vJA-g?fa>eC zf3dmAmbQpn|K=9{ebK$QDt;jg+2z=Fal~prIi`jXwUqdm72aOZMnm5+JK5p2qyItJq*4=>%-<^_EouqO1e>1A3;jk0<*1c}WruU3= zVAJlnb!hvD!-hAZlPJCAJ!2|+CLq%~JGJ`hto71qh5`|ifMxwkA_VGyNcJO_Z`3S{ zwZh$;F=k=It(VIKl&}~w);TkC8}7!_b0+uRWsfj#LdSiwDA&a|tWR2h-g9Q;Yoy#E zbXTPC!_9TF+%oEF;V+87?MpW$td|yYAsNg1!msa<$>L93@j|RGv!RwGr8n=LU44`9 z4r6)1mF=2Z*s_Fq28G;!A0>ZjY><}HGQ-a1rFx8c>BG#1vC`271*#7)8goG zSu=j;DV*~}84U`P)`s(C0~K8sGO}B*&|vUEQuQAO@IUmc(bJ zu1k}g3gE-`rf@^VhdhzdbIh<4&q{))X!z^1Ay!;SM2J~0-}O9Ps=i+4Mxh9;waMM` zu&Fg=lk+@yjT`qy5{nEjse5)mmn{5FUlJ|-xOM!7%<7XE9P5``$7n2^%D%!%io6`T z2)QumUF^U@VTXPP5h)grNKRABa=2ZN>zwq-b-S}h;X8EZ?TxN~Lm!shWv4d(mC1$K zFJx6VucmgFRNm{oC$#xxFq+a-RjTLiNvogD_8ixz0TQ2u^*?FGAL&J?`cvU`eBEN( zG9yGT+BFP-KiJHlC0A9XR9l9~pV4w`O2pGm*2_B+*2~+Pp@i@UPVf5j^U`9faF_Hu z60)`{vmjfz;g8)VL2LX#$a?u`xM%KYwF-458{kVw+{-7aKBs?On>45aA-cL_6d_U{ zI3sV>h%Nt)<6PsN#^~-l8g6fxbHTwAW7Pt!VPhTrV!}Fl%_rfRCp0e95uXjdfN>!7 zEjF!Ml34XECI=W;&!FVUVgah`Wt+R(t1Ppdngr`;74j5_`rx!;(OpR_y0k&y&?-hT z0N2OV>Uw8u&)7^L#C61Q4&&UEwl=oz%uX((=H{_L?pbw!^K2WjFxD@>#q*spek>^f zV@4CRU5t;Lq-H`;A#cW7X8?>&EoSPDcE|5)dLr={8&~yUJ%4%mnG1}_i0PkM-`Fm# zIws%9Wa$m0-M!wb#I9my*U3!b%ImX*CBu2OqWkRN!pO8pWAuT#7qCQ_-qJCVF%wcf zb8~kH@I-2JU6Y!hP}gQ>F;p(=@+PuYq_d#4C*xPbg{NRU!KxikinL^g`#tk`kjdX_PSR4gf*f1GqExo9NEb6g5&v&SXI}g z37OUJ=?04AxO#~jPTpK*&A7wcGw;m(M<+D*3`&^_N8C1-2uT(ldr!IxU%Sw-*6s-8 zL!5jvT(qDV^$Eln$&Ljkw9^0CWDVYyum-=LTKxps{(ObX8-*YIfhM;sE-Uj?3L8Y& zDM3;3|FZQi;B8e`+P@@AR;++!NyoA*xyUhhNR4rgEL*a$WJS3+3Bjak2!VzaC=)1T zfI=JY_e;6o3HN=3NkcFpga9GnI5$EFA%rA7QJRKy(wR)#Ogo=DGi|4>zu($N4)Fc| z&jX5eJ342dz1LprUGI8VRr>U_)tB#n_p-e8<>`}YuocQgt=W|^m$BrZQ^gDUtTXZM zdwCgoVd+Q&;4Xb}sIfaSmHR5>7pzP@^9-hYrj>Dk}s0hdG8rd81~DSxW}{4VuePF;whWb!qZ_RZAIC7kX% z_$h`A8^|f~U(kByGAtm^+&eZiNj$KhZftk*)7S(eLq4v_3Jz99n1gv>aMcwZHi+!b*>k$dgWn`4W zTduw>S-Scr3_vh0;+UaCVqwQ!B>6FSylwrUA!+>}g4Jj}a$6a5);!k*1Fl2Z8gc8c ze!Vh1*}2(L+k_rEc2)XL@a6s8@!2$Fv!47g)xQny6j$4Q+XPy#l;dzJQQvbl(+)-^ zAhyb;m@p_V{o9MbowOF8+#wezMDX|8Q7*&~dw9+xa!yBrPw%?D{-F>2Gi!?D1I07I zhpeaHFPLlOc1&CrlLJ&{^VtV;rN(j00OrQPmBwrmLg{fiJ~}3)mV>eJE0VPmDYik5 zu(>_Ebh?-WfgFvcJ(`o5Xi2H{Y1Z^=DBU;LchwhS^BON7cNGG78ll&B!`V^%vMll; zqRZN!W0s0c#2}xOsVCYUBO&YR<%YHIf$)sF(v6ozDiSLO($;}9y3{WxJ5x(nOkhTE zKif-cMY5y@cq-d)yZSJx-WTcdk*Z^>tl!^VUFz=jw*+#UOE=<7s~4EaGF!Qa%zBXg z((<^cv^?fzxN&)kCdQuxY?x`oo@{+GJ;X&0j_qjA)MBj*2utx6BlpLqa6r(KjwOFh zFU9v@&Ps>YQt7^AsdU#@Ns>gZp4mZNh{lnJD#oe6{{|5hd=|#PPFq4laap(VDxyi)Cql$?eudr?nm)5px}T%=UIF-DEa2$vugLIPcm z$kY}GD`b7^V$Ps4+n1e}>p!QkQ0$A8)iU#O5FOU;SC8Bv=noJi#5oc(;ApG1-rj3S zc+K*_*DAB8CfzwYDvoaVeDbB+KZ};G{dY;2O7^OK^PiKO|4V+wp7fkUgZ1`fY&Y^_ zokxDmp?=^jzU~^6>P*c|_rKHCzcN2he+xuPTA@ukX7p#|v{<6TFl6M&K+;S}SSXxh z>B=FEVc8z3*P8h6qhAt&J5;Zs)4Jy0)Nx+UNGE^Zja$VYU7xqP`#Xj!Tbg zOUzBH8QOQ`6rH7IKcgj^+y$%WZ@T}SwtF}&qt`$2$n{rQSMN8hrb5j6!!h*c#Oq?E zYoeG?NYHlR1(pRnfzzNhORh<{=OZ*5{4!tMG+F2JI@H=!>HAlwo6G)ZD5MJ{jf}B? zD3+m+<%(CK=gg9a^_;Q)zN73(L-CMmP=13$Gr=3X`DsV#{Tr$lSF4=Vr2gm=w98tf zGh*}NI-W@s{axz(e6b3XA&DWNSEqZMpvx}zwu)STTuyV)==16w(f)mzyTsCJW}g>b zh3@*|Ut{1R3G3lKk_#Q-o&RF>U_d`UBUSvB2FkqF>9eY=$KMN~nGZBP7)VJ@Rcy&_ zS{?01H+Gb`N=Bzjy&X|28su1IV~N6$`e2MPf%_O%k4G_aMqo(xyFj{N{c+T_vR|IdOO4aFDJJpFBh8Oh3 zfY+Mv-jVsJKBrh1ObkhP{u_s?OdgwD*qzR+8wyTO=|}X2#$GWsWxeG8V|3~p$T${% z(JoXRUGfR|rFSETvuE907B^;sn<_b9d1XrZ75SUaZSroYuU_jBp zNCHl`*OSJ#63+k5UQ48~2OVwnYqhJf2H8fwn3O8bttAB^_p_qC^f)u`@y;`gwrGRx z*~hOMXZ5_<cq+wYTX8MzFZ@*DXUY=dcE9nt)#8zb$DT2>6tJMd`cgOL?Ex* zdH_}PsFhjO1V2=a*u#I~o(kU7ae)kKN6W;JAh#Tol(9$$Sljz!tKZ}Bq|T1K^jK_l zKQH-i599;)1+8ygV^rWH7E;#G;~KT15;IXR*-PBP7Qe*u{2AzFAdFsLL2AdvT@P9N zcO+ohkI>3}jx78g6OyGJ*{>Ep4$m8Q*Uv;cy*in*9{PD-(2y{aF>IL}6}vIwImy%J zweEbVDj+iQn3%+AG6_R)4(vrH0%sy%wTBA1MHPWF@q;U+)F{971!|4B==8h$Xl%(P z>uFG3`n)yK)J|@c;J~^+(iaTN&vb1_bS*h4v*b73OHasFg@(?9?`PZ>QxoDvsl}m8 z!h_8J4zM9l6j*GQ0=3tBr@9QTl5Vqb)F+&ToY}Nw#H^O z%!w~VI?+{c6@C~e7UG8j-IOxJIK>NH@64hNg99pUSMFyj1J~`P$d*d7dMP5qOKrPJbnfIh)0KSrGuRnHNS zHvgx~`tfI;8A1UqSJp}@N30Dk?-@O}h@^d$cx0#=B=83>1duzC_d-#>l$BBTWFsM@ z1pBC&WI51=%6`u?-LNwE#$ovh4ezT%5QcFyPWYyyYG+5s!y}&5FyF>&x74MLaJGtO zc;qwSC@4K>W}CWkW;1WniyQPlV}O;o9SB! z1(iDHw3J8+!T&8GLQ6X^s*g|L&gz|2NF#D*SGp1Lp^SFIR9ijeGeLnjKs~dmp9i#J z-eyO$XQmW_f5HN5_<2F{#1S@ugXkJ*Q*J%o0)?iiDA` zN8jW_YMINi{C6SiCqI*PsNHK5V!IJ5XmH3e-fg}PIa&SC8~Iiwi2_$4&Z!f(9AFD~ zm@9=Ay_~aH>6j@*BsEp6#x{Slv~BEHR)gNosqXA0()1PjExAd`_70%b9ZA)5tGT%% z>mlXtBO23#c4xN%BYygB9rxs(IqVv>UFD30&!KReZbRa!mmsHwS_MV^e!AwC@Vo1|mN z99k{El41~_^@HDr5&U9)eC$j~IEbNxu$9HtrT*bac9AyRY(S;7pe3tFEkd2_@1G%YpGiU8!X+Wv#nUZ2lqLEo#csR~UFC5_pU zyW;l)lX}cgL_=*SVQE~P)WbC3+T|3HhG<-Bk_qQuMLpn52=XL|rPykSG#ssRMTc_O zX*GP;)#BALt9K=jjySkhbxuZc)i4oJs9eh{;nQ$!stQgL`CxR-qiS-4njd#M?m+J+RAFQix{Cx^k&gq&>F&j5 z+FdMk=UvSrdefkC7QgFFoq7JqmXr`o9J(Amxy_Hu8;is*ZzrJ(lE`{H=#g@2VyQe; z?bg&^Q%@b&-ZI}~50wDL<(nNvvD~f4i2?RHU0mGt&bry~~^$}k(L-!h%M!)0?aS6A z)ig(KaPykTM}_#N)$u7!1IuLULrht=&b{no&$9m!R?7QhQ{nuk@%e%J!T|kAeJ529 zc;HXqPoSdQ-9FHnM9;#+`eIQkq{UWXm}yYD{i*5}vatf_ z?$g9W(G5@oj+)vJV+&%*_^hUvPE_BM)G8=I>4{&6=pDz@!9O{cq#;S(to5&WW4>a< zU#!J1VW)IPmRuo2tP#=wA8xE(ZX;nw)#OAI9{gbKg7E#3$D?4(&%GR9c3q-5A9TC& zta9YOWKMl}LmBlz;Elj+{qK&1@4D3_W}qbzva3p_ z-TEC;(;}lb=$3l^p5lZ;ISh6=ien?Cf4a@?*)u3KAYu*tTiN8CO{H6kI=$@3IMwuu z(p%k?Qs>8@P$PfCzfm?rE76eE_?$H3lrY8>KP5LEU<9MUhB_J$GV7wm?z~Tp!iWx{ z1v#=V_#$at@EOteN?N(f2CE>KTa7j0wv@SF$Y3a#ddrLR(!LilNT-jiyg|Wk0_w14J zL}$^hX9qwK1jt@_l5S!n#6L|5#22Z1(h?=kL`Kr` zxze0=u2~1V)T^Bpmb-d@dnW;0tOI#J9X{<-cUFeyhT9^-IhG0WdC-4X=;VwsqFtQL>e^hf>6KZs%-OTm><%{nSCH6$t59{;>Ad?#|#hwu5Llt*oCP*tKX2|ol9L2I!Y2bi_ z)A&s|hBw-nT_|p|!o?9uG?VTJX8qu68^>~|Q$S`ZhLxsUBVT{h-GWkyY$cHY=$o-S zzz(y!R_XvGogV3oiUc^KsHozUNw((uQQs8W3 z8@&ogkjW3JrwsLFSdG+Ggy$p{X4jD7kyb>H{~~EU{)N8NY*(U40u3`%x_2t=gB|7~ zVpFLv5)Un*erz)pSIV7Iw|k5x=iR^ zU{+SdT04^2v^4j9R9yTutbq?hZgI}GXvpM4I@a1x>9-vfAAPAEQR7)a(L7w;3OUAx z4ei(E)ipwR{H${AQ1!h`%PRr~<|@byRr{Ucd_t`#BgMkfmf?mA#%ljWUE_?d&Ha9JKi{dKsw^=(i-dV($Ai>4 zoj_GJ>G>`7>e-N!^c?qluWnAwE!?UWYk>~*r6Jo;f&!Ook`(Io+hbH)m(Xsi^a9cs zC`l@TVdx{d4pMFy2(@vXL}=S1=3RKyQ8gQwd`$cJ_C#`eLE7bP#ZeP}q%&e&{5`!3 z+0QgmgL{r8cH{yx!`8mRsJ-T|51QAbE)q41^6ul*p`0)$k8J+afa)9L@p`b%cp|9l zHb(sGX8A7&-4QM>u7eiV^JLQMd9=eid%n(Vn!9x(xS}_qK^V>Id;|?mLY+Z%fK!NP=cDFn<~L*YIm%GoSc{(I(`rPJGb)Kc2db*fSt3LypQ)UfZ@>Kq5#j~35Ua_3t}Ky5@e!p{T*j<)TJ~a?^wv6|Gg;T=*lj>uhQ}@ls6PbNy>6HFz!%_NTtDKZRk8Nn2$qu4xh&Q>)$1(qm6~tcJ6^rRy%K zS#=Uk-`Pn~5kyf6IK*MDVbVs}xOcZdoV>r|@lN^Hixsp2>8e@z*D!65G9}-u_L<@e zL?@!;yXPkMLp?>b2PwbF_43G-ACVlq`|#G=wc-4 zOQt)PP3@F?tHWH%uTknN&h`YHry*>nE{TVgc4FiE`T0hr_(OPwfec^*Q8F zbhVySRXne{Vrp_)+gZe5)dC!UsvhweCm3zDX@D|O02vPU__<@w9^lwOPb6D`_7)5v z`Pb3xOwxS7Tn$7(mV2|bB0-=b!0#MVkBx2mu;b|t^$;ZcJ{P!;x<0O6GZM%9r`{uW3N$_FIH~;)k7U1mt+4mNlrL6K+4Rhe&5Qdy(H)ghH8Zy1k|tNW zrF)%72QhD;4pn%ssj;Sh$G9zCZm~#uoIUj|+?y)NwP6asdLnPt`qCk=bIQu#UB&@f zZ+Dzpzd4eE|JIxTc76(-JEzp34>i6%P)+Ke=3$}=hDt>&Lwwa78P}g`>fgfNTWt(Yiw%wCfDPuRxH^kQ z-5xmSt&vPU7^cibewLfGPI8H#yXX2YH}tM3S+4asa+M`dMTBvd*cdDRh7m7B#a9j$ z#t9o5#K1E%F{jtO6+@Gx9MWd_^K;@O-Y-<^?Kn6;s;c{L-4)TBVh=Y^Z{Tt#s;z0e z(!pqeL*Pe7)w|^=4Lo{N7zJ%-U%lkp3)a7V3JHx*RkSbNkX$;HDXqGc44Etk(%@{^ z*2+VkDPHS@|MXAg#Pu?>qo9KjrExRJ%v;yYgvw-{v<(proOz==f*{bMXdoa| z5~)X{TiW6Es;g^T`|72A8qS?`gn}|80xN1qtvD7!xu|ZaHckJM_L{UdzqRpkf<4G( z;0ZnJnB!Kfy;77@B+9%kXO#N(CXiQeNVpqF=Bk|(5nq>Bb0sR3USG2>Z_KMJRece6 zrb>;&1!-t}0MPDBFWNyhVaq{P?L{J`Z?Uo z(&5{7BGz1ZQc)u23AV%qFu-OF3)iRNYt_P|TZPyDdxD ze6E+gy-?Yyas5Q0`!yXvE=AT@8d_jSh0zw&>hAPW#&k^R$kR_?(d3(Eps9fr zzl54Q*lYF$!eR_oyQ;0n>!d$0uYbgx66?#EF0Dyup(jX_BHiHLe4>9Qj0$Q>c3~&w zwFByatS~<-?0`$!u9o97wulEY4}}Ib=^H4^1NM}WH?L_}^v$>A#VHLlzWJg+GY?3a z@+N)t0cRR<7b&gYQk_{;IFmU(#X2jmiS;}W_I_6UuS3KWEX=tR$96%QvAT~(hc;&9K6@*X|*T0>>k5%t>D)P zEDjyjeqT~O)S>gb8#Lc3Q<7Kz2tu5M3W zY6rrPRfN@5b)_G?+^(oI+5>!c%cOAW*#0_^xDYmnM9cc+(|P%!I&~#4+b@8o9(z-r zx_}q-!KKPq4o>`jOvjWI{hsJEk|h}L-+9zBWzq0zBWN>(nAv^b9t23k933~8ADVx&Af)p z3jQB!|ASCWycnE@2KAn;_g1~()zG@C@X)HTT3c6qE^<_QPWCt&%%$_wbrFj*+K-p=ppWh>v>y+r_DDNXET6KJyl|)h{<5eWE<}fXg`IA zO^Lq5r5)CBlTrXBoS#y`sEu-~4PTd3-S4hyt2S@;x7JJ#Xl?k{IQKnH-^#NM*j;@elAm>!nv`1mSbB41&$Tn|!Sm{%LR|eYsV>qp2rd19`mWrAz zED&J@u6{+>yeVPDZpccL37m?WfO&hUblp~?uND;fz)h*P>}q_k5I1R~P=2scYNNL? z)>x`~y<^p}DYyd&s5#@9ErhWoqcT!!Z9OSseert3mWlBI`};_>nn!1nn&PBD@jAqI zoqoZC7NY4DxgdI9!mbsw+Z&6HRHS;6oT%h803rV$iQ5BO;`V@!m79V=QI_3~O8a0% zWELXt4=2?sG$9uURS#)S>$ZO)(TVXJ!p+0`*ei2}lg}Z6aSH1(gvRGa&lhey`?UghU2vz^t?dUA0^uDWpSscP>GgpYE+`+ zF|d=U`4}u9=5L4?%Wb}`3z?TDNqRl*a#^u~3L0bZIx2Hjh$$>cpCY{fT_B)`ozWHs zMDUbdnl!n?G0D9!c3)y~dySz!sr3>ti0@RM0~)a;kM$`bJC6W$y=t>up;WVI?Fm^dksX`2WDW82$d;y%?VYOC&3xsNqcU`S-zOQp^DRa5bxZ+MM z@n*x>mR#Ee^A#8;_-bp*;l;<4xV(FB^4+_He7`|`%GT1=Yjo?z9dr^Aim~LW_@yVD zz80}6uvqsA>1Bgg^^7UrUnNoh!sO*0chEcuv{wjJLoTC*H6x~GkZ(ROa;Q}T-)?3I zh%)6F9~;IA*j3qeYL}JrcF)YA^BTpS{DCWF&Ho4WD{7mKjY>J*Zn33q^M#nzaVL_o z=$GAs79MQm{pDIs(ZD&Nep(ei2bs1@kOY738@ux^Sn-bjIb}TRnxJ`&%)?+!N|a$g zM_`GSHT4l-K|MWbZSeJki|M%5`(O}Wg1VCkKqfpHF22rWT&=;jw=jK2{uY%K8;2&x zOs>PcE}C$`kgm?s8tx)q0Ivs5W2rkuzq-4~~ z%mz@h?p=DjkaC#)+RntJSMpU{-v|Pg`M`^)ds!P*rL)Rn- zArg6`^k`Bqpqz8k5f0p&!hw5Ju*Q{CF_MzR)5J_2mAEifM@D}6w%ogKxm^c6^(WUO7N0Hzq@_IzD>@kj;v3r>VLH=-M~8WP;FKVHh~{4~G@Feo zWBGL;^IS5`Qd&cpjVJj3F)sOy3ZHe)iT-qL>4d>}Eq8F7lwt`L^>Edrcp2_?^M$1O zLdT8=(=AzB@^1yc?PE@FCwgwOF9k(h%KoX*fMghv13)6(sa>yBm_^QIpLm_A=~N4f z(-(I+raG6s$18-&@`~e#Q(Rr@pOq_px0YpM{b`Eb-%#!Fq!dBZ<1_g1Fq`$q^)zg5 zgxK69fGu}chKX_yUw3sV9iIX~$rPI`3d{6f^0~Td8tQ=7!I^MQ!QbJgX~ZSqZqyr^OPURWfba-{-`Z)w z;gdoH^}4tIjC$!lKZ|527{*1*Y&TZ_Hm9J^Sqh3+(~tfk&JE)*4gx~RQl3+MZOjAp zp%h?Pay#}pt6TguOkpv;7wD^|A-Qcd0M84{UYoeWH(9N9gge)5>skB16DLk=A?G}U zoouao-0ew#FJ2P9Lhst7q<4vQlI{Tj+XK7f!5a6mo4+3vy~+dlS`4!6E%*1FlAk)k zd>=MWOtxcoHvNT=`HK3eGIF1wFfcR@jRO(ho9B`jSJj_dziv3%*|6%?c)E#fnOMzW z!7D8I!ZwppDm_{i+1>^>fc?usyVSiG`mZn^4-+?ke^b)>{<_gsEz3;LFA;_t(GP^6 zMq9k}$oeK35V&}HIfy{ zm_R@YxA~bLW|!?D80J14VTvZ+-O{8llGK{6hZ#_7gUI``_YO}qw{)t$l)5-w$*rZr zyOl;_lz2hDLn)r2bkY`BU0-IU(#^_lxh9q)L9oC%b03KwebQ$zudSD~@J5mRlnA`I z!4SX0heGxQay!%{9H447C8Vy#?{Nt~<%lcja?JHC8JtG{KK+u*k?|~9&Qpq(JxgAd z*F(-uYsKf3Wpr|927`Xdt+_hpWXbeY(@^itj&!zkDXj8|>ZgdinV&IRoIw zEqaYP#yyRTb7~67vMc-x1b9)mJ8N13&hF(m(h*2Q`0gH&4+2PX>whtBmr0*Tb3nHT z)gWw$-H~o+WYP}G>6(}M&C6W5YU{hdBS%QKYUVUS>!CGDf>H*uwkcsZV~DIfslA6PJ`pMg3o#X64TUbFJ^C1XWv;q6zhYBV?@o zKMk`RlJQ*QqH$_clb9T}EI>9u$g8pj=!L0Qgl)ncCLTuvkMwpMNi6#p{h86~sZEoP zpz+ul5HI7=@YD5bZd6?ubJMw~Ps~6z(@VKG^UR24rNzjI7)0y+XwrH=JlcB$ixI%) z>@d0zisb~f_(@mU^#_a$z<-~^7 zkT-EuV#$JzB|oIvu@_ZO!m?I>@l@@akFZ@#PWUBamBu2pHB)D~)oe(9=Tr*j;&zno zyeyH-l^*=p-p+DM!Exf&45}fjq*paLXI5KR{>ZRin#A(oen)cqt$OimyGR~P&|_{5 zrA)fjiu%Ci+Hoa_4(t*MTzHGhO~wR9z95PR9ap#)htxxc%1aRX-KO@^ldmUBPyW2T zKCClNl^ZR4d9T`EQI+(s-XC0D3>Jj9H{$U7hCRSwsp}^Zn&ICAeIwOji@Ho&E(_-bnIP1xYwOg&*;GMBa#3+BvnC3 zt6#7Mu=iH0pBw5IwZ%)qV^Zg*W_4L>zm@G1trPeLZgXS8`p$b@rIYpxkQ1XUjrd00 zSK+Z<-Du2>T6-$v!K_Dk8Rz#Vt@9_AO_aWk;cVQY0farcG&>k*NAY<2aTObJlsYMN zSKB#F-ItW@<~j8YC1LS1L`C%j#_Tn|v&GKhXjO5$f_hAQw7q29lq?yG=s?_za2e;c zoR2PJE;y{%(QfmmkTrfV!Ld%d9l2d!*SQnMAz>{N&B9mOj{dB01~;e`K@SB}Hl?A< z`u)OOOP;L{E;nd+D`a3MEgx5=%hP6bmfI+5I^rP%4Orl-Pu*7QF2Cy2UF%7btg&_2 zhY9k2w7{>0$3Edgo^X1~wKTBk5Sy+{O-S96c`{dO`xCcZY8$ZZ8S8g{(4==~mHD6m zs)y;6x-o1NYDooDnICW?z)`LTQHh(cGc)3FMy>BAWEqe-{`x1?M&Nx%Uf>GOac3Zp z%aEOuE9QEZ{5ZelkqK%G%tyXg?j0&?RlPbkx_14z7sjcD6V=VAleGGqqe-!ogJq|W zrUmS?@fRlIlT^aORX4aD1?SYrtoY@}Yp@D}DD2^lqF?bQ)pw#N_4THs2lQsT5i-|9 z!DQ*7YTN9_%nvj)%Yud{MV1htWEkGIFGC=xm6rrA446BljvCJ0dE;WaI8lz{6q@ot zF%voNqFf6mtC8=H_?!JLp-UqH=`Ait$VjE}W|oMfu9~iN_fyDG{ws(rB1B2LXI2X_ zQsOimQzwNxnia5;<39t5%(3&YHN}sym`&pEd!uWA8&!A3)IePA#zUo?*>M6aA<_$V zxOnHC4d_Ld^|1Px&wp}VsLnd+yr`ACJ{~Cem}e4^`jNYA2_uBerm&T0pCxLN7P{1R zITt9^E30Xu<5i&NI_odZsm3ML4qZmZ)=CG~BXO(b)$0)>>&A}A**il!YBZZwkk5Ti zYuVc#>zqk)%vYU``D`#!N-6sg`;*q?CvFol9H=aD9tF@8&DhS;-G3pFz-w^a+=%PZzqSo7*U zg)!ETE~*M-;-vH%)6uF7y2_s9*kmSa-T1b?e)&eC-R4gT_ULrX3JIHV`^7>gTzq@7 zwD{()5P2H}*-b$5f@`$-_h(0d3Z&(%dv8nR`hZ-b0})-5C?eb&u@w7lNuAThu)smF z0j?^!|LBRzEKorY&weg#l%zacR6g6Q}O@tTLvgko3p%5tCODLb1a9smgl>4C3igQZ5V11US1HvUl*@7_)9VkW@9HYPpXop5%q6?J zRlgessUJGV79@`w7|u8uEi$cdK%F;8ONmQFk{OEoQMGILM*E{T#MCwP?jv-YE?tk< zE~R}KP=W3E;Q`@Ref2~=>#kmCJe+u1Ow5}VqDhe(@n)ioD6W?wh%=j7C?@R3L4m5& z>p(#cS?pTEUSi{6&_@Mw!y&}(>icr!54DRKIp&yTX-xDh;&W{xJSn1H363Gxdblo4 z%X1=7F2yr-tfpnrA1PtJ)^0uekEHeJU&S*X@x^`Cz566Y+^^l*GUactE~EP_3CSes zeY6TVM>lODYf<4!7@g7iv`L1txRtu&?KM^9Wl5q`xAue_%_QhTJ=htVl29+9>OCzf z$-XezSE^IQRi6Y%2Y8l$(T8JSE)sZ4UP^xb1!ueU`)<1%+8(u|vc7{H0_IKf!b{bA zBy6Gs--+jJ#hq;Ft_grH61&r6j=$V^*|mN2>!5SrhU9?x z;)|N(Q}CPk6tNZc7asj@U78Bq{6t>bpt(O}CZan242D3w4mt8p^&7AC#blrQO(2wV z@Y-H=r6UlVbb90InO5t?mEUPibfilWJ| z!KM&mi_^d-UIMd|vZ5Ka1!P<1*FPBz)!2={572DhW=Zd&Gs?tJRs(*njP=vs<}xG- zAfI8}HVQ$B>kaW(2G(>+d8cP;WnW;nfjN9imaGHe31Ns02MUd>E7&7jog%p?ZFJU( zEr-fRS&|rc5A3=$^(4G2k>el-=aGH)_Vy)zN-p`&j%6QruG*h+)P&aE6dSsfE=}?7 zLNPJ1cqYgOY*v3BL$dv-@Y+Ae)_xgNG+f(q>JAc}hEj30acuC+hT|Fro{fWCz=xt} zuRCY;9mU%Nce8$R#erMU*n?>NVz@KL^lccpuTe)7a+(+^-)TOpWys$a5E8j&j?^SP zk)!F{_EA&m(sOkcg`ZUyTJrZ=Q7wgv?wVhvr;Svr8>KtQ`$nB{tL>w4sGiLKP;2Hn zT}y7}SK&=tsdbw~hl_IP4Rf>BA6AOY$gTflp96vtA?uvs25aI_lN8K{Oa7S=_`HG_ zI72IzB}j*i)P(5^s{Tgkt6QWob#_w>;;U-oLDlP)ZnF8r{~a-^0lBI`gDm z#Ks!jR;X8)(DElo-~<}#*|1s`^(5PqPi7Ne35)NfNtmQ4q%Y(KPjZ86)Yq5h#d6{0 z=JZfmu1!4H&aOa1n@gitG~hPaxTQnJDW3J_<`@cF)tN8>g~#SOT4A=au!{l-Aat^H~YB= z1}wG;o;Lp>erygoGF~gzXdvZ!ASJ>vD_u3EISV2i9s>#64O{qd_1fPdhN|AGAty+? zCJf%gZAY>N9ISfjjCyrnRiF^Cp7~{MXI(CSL6eaxNCP`a+1xS=0JZLhoQ{T!f%&b0 zI-AWtqc&+t?hh=rygN9$p$X0NT2DL=n%M+ewU^#!ycRF#mRMx4>sgb_-K^z^o_4v~BBKzWjofe(^ipQ>vy}CtE2bWC zX?Yv+5f9P2EZjF#p^iv@L_JWi9*wJ~2}H~n{N@YNERJs5 z9`@U*^|!>GMp-ri=X4}EMPR@h;sug6vfkvD(;Q3wm$VTy=;xhvlcu3C<5_c2jTIYn zMD;|73*=zoj4&wd6K7BZ8b#nf;r~7 zlcu0PHKkg8m$~YT9*=stxl3AHL`C@nG(wd1z~PABNPp~u>_+m@Pqk{ti)d9e)mm5o z@~bV7hyso)L?Y6>il&#Ge7iM`Ua-?Hmg<$GT1ICp+$4ii2a@=7ry;*Y7x_}_v+ml8 zRH#xMcp>i|pv~pQp=DlfBVSfo{|gkzfwtD%pp)Q?y9_-S@gO_9-zrubG$+M_)(Cr) zXy65I43EOG*L*8BfQOv^WH|>R-7xkBg~WGA-Rp=!BSFe0zAT;_r=D$67ani3ppD zl#o(0uQj-_3;+#!LdS+W(=*Vu)U%JP8s5EFFL#QZ z#OjJb@d!1}w>4BGb{^Bc>7<-mr&9&qL?E$gOKMYHk2TdbStnXX9E(Eze~PSnR_o?e zB$AMmx|cL-tzse^E|9I_o^Z0xx_%&{uGGTzp8R+7FU%+{TFmOGOdgZGq$`)VPCR8I zZ8RarjFWD8;5t;>#W+|D@zI(~+wmy}5#g>$_8;A$iQ`&-$4OG~EM}7ZPn9U|>-)lx zIArih)jdcRg~R%CyJ)kGAf$FdEz@TEiAihwu`(p*J*A7aHGCI{#LU4l$??hiy3D=V z{(qfZe4I0^h+B*M62fdD{Wuby22!b2TEH}6njpYu<)B94m;rdQkr{{~3Xm2S>GEc#!AA#w;ZV}Dxlv|CN{sB^rYLR}#(p0LzFg+gj!Qp*Qr_&PFwC+R?KN%j7Qs{;6_qYrKdC_;LP{8PZsoE z6<(WGF6Ybt`~Z)RIZpN8E(#uMDADW(}RS-9fmDjoa2=v-PnZDDF zAHXkAkje}WIwVJ`2n84)%~F)O#kZo zPF;n~x=_#J!^t2?#lRqrix@KPxVTU7o6G6~Gs4uyrnr}Z&)aGc zS3QtWPde&D8^Y0{wek1jS2U_0j8iv5)$IhmFSxm3nn|Z#aaF&&$*?{>+A~dveME~)iT36M6YP+eDrb=0@tGd_JO{VCSUy}CHrCZbb z3pgfBWWh9wAD3t8-_DzjgTAL927zk&~yp^@oO$isnZf>WqXEJ|RDAOtP=0&U{EM)wqFri2}*{|K4ss zmo%U2P0aXeqfsjmrZ9vx1J4_t+hI|^QFUuK*Qq5DI(?|Sj>3JaX`(l4DRk@P()n#O z7|LZ4a#Z7LQx51>ECK*jz6En$iz}3^#o=JJ&=^@7^8*hWF2AfDm-vF$KQS1u`sH)wlvW{?g?atC*p6mM*31v!EeTPAFIGGBY@>?%GpS^PTRjLq$x;>@6?spo<0pd6J}22c5yO5* zsBTNt^HhQ+r{t~EKG3@d7boJrjy7@(tPlBHquw8(#bb*9TQ#(=dg$!xy#JO!v6Ico zdi6ninz26&gN=>2i+>Ll|H?IMjuhLqOdC71wc7;^PGx#UR1;`AlE*tY_annn zha)Q@h#P==-qXc}^s|T{`0`V4&BB_Sj0YoXa@^^rJS{>_F2Y`Wh)%WQ6bj6(A(9Fb zb-0@qJUZRQYXFt;U5S*{qyG;Xf0YwdqsFQBK{NFCYKThIqSP=gV*Db>=FE5|jX_L4 zVa>Wq<6T7L%)IqjB++UCw5D?wCxQL+T5XS_=`yuxegbr0gsJP99PZR0K+MnBLoMl2}!nPhCAW=->|RCE*1*sIumS8l;*3-W%_3 z5>^Qz5C$y9$CUa> zulWGCt$4eu!ktW;dkB2(y_mvXF(1A}BHdeHzDl|@ph5nS`57ms9&ywJ-VEOsz9jN+ zRAu983Y9&rp)@N|U;zQvFysOb$zIoPWsXf+8S=5v2FJy4Ae@M+E12^#97tm z7n^GyM5hNo9;A7Y&}>9T1o~FUEv}-&x@F9fokd;esHq=XnHZW+A{QoiYQq%(6>1%5 zW+D@-ID2L`7&q#xj$x<3yryQ@Q;K zdezhQAPe67jJ*{|5eET0yjJd_-_a)qAyD#elUXxWxNT(C)dOEgSPs}qmv08mH%aoW z2uDLYk_xD^%#|{7NUNd9VeWTyd+w@|=4)!BO*DMRMM4YBVJE+`sf72GK>)UJFDrSq{*LH_G3)1pjiD*2dio>gF%UVF zQ>>P&M!iSjAu+x) zTA|Yf4cQf))dk(Fw^n-g=bg&%H^+mChDnkJz@3YzPmu*l zTR;C_c0sv{PvJy``G}v=DB>Bw@cM+ok=_Xk0&gWs?n=G~f_~(iL!;je+!QLlZwwq2 z9=J3@<|G3%B1*%glr?E<#(a1pKyrjMI3S>;w;9@p)z#IJwg1}my{6U^`%+JeGW33U zt2GH7wZg=fvJ+CBUndvauG%|6(LB|)ADkE+(ISdI?QIR3Q7pV=nOg@UYFbRqZ&269 z-J#i$i`s8U{$zA>4xo5antYcOnqnTv9Z=`RO#n_1hPVP-AoX` zqkN7~QozkaLBOG^KBsq1l@t-6tW$QD%xy`QuNbXuU^Q6cH)?9Nml)`=b@;a+7Eu06 zj%UR4L9XE?%Ax0cEv3Vn3z@GH_Pa)R{74?v2%EROU(Kz`tp7!3$^BV+-Yj{#cgawn zH?Z!11L~aMlA~h%D(;T8CGx2U^UDqt&q~HyEFUr+(<}`WDVasF1saMHXE9W&Ka; z=R_}w(V}~T-QwiRYm(NLI8UR%DDomYQH9+<_d@NexZG_S>leS!!X9>txPi@;6fp#| z!)~dR>#+9L=ByKcK&)A+|GDJ-r9zS*O`2np{gNrZC8+WtYvUs5O=0Vtx9k=a;`xN8 z#MQ?dlyF$bzBRhj3GFQ(5*c$4nTr?q$f@ zb8D^$&@|ot4oo&|wX1#8E6Ghtwq~FQB6m!SKF!kgrzcC-f18ZD#8>)PU^Gnk%&)w` zc3U`q9r_B#f*V!U zw1OlWl;V$voxai!uMRi^T5)1ixGPrISB2)lh_5r2ttW9 z?B)lD4TK$F7!+g4Vx$9a?Jz_UWN#5FjiafdXtks+q71UH#-@@oU40jgEikAR_2xYp zE2(noW${e*(Z*H^(K%W4Q`JBFl8xy=y1A=W_(|}8$W(aDSCTV2)ZbIMMH?u=aFl-V zORsh4Z^qPyIqfinZm)2lkD%5XYMqRQ2x0{!SM_rpt7eHQ55nNV-tTA8*I3CD12X4@ zGQ^PZ3PKgnfnp46R$!F8=b>^-;Dc%(H}t18ofqY#!|HX2cu|m#p;%}8tYlw@xMgr77J%&=8KBg!>kiP{(LFN!ePC4UNO7RQ!=}N6xL`DLZ{l0Qy zF@QSc8*-dxKae%U%V@0fbe-Hao0_V5dH9XH15IxI!;&2t#&_cp2=jTH%dtP&ow81v zpC<1+Xh&T;)Efwcq&Ep$CTjh04eB0{S-2octon<(mSI;S(NR1prRJoGUq4k3 zN&iXnkyvxwI`xGD>Hzn+&?4`XFkQU^JDM^ysTiZY4im{Dcgw|e;Nf7BBz9&A_JoDr54 zu0O5=Xr2Iz+F0Un%lhmkZt+_%=HS#gtgF`^F^E_^tq(xz>+?{-Ck;9rN!MKO3qIl8 z=a~-G){l)F@vZXAV{E`Kz>i(G*2JI z*s}k@o2-Vi|1p;Aoc2Ekq_PTrpZNB6r(tCIINVwX0szKEb-*JobFFCNB|f}drm;9z zGl3=v8c;sPO?5PrqsKF1=$z*B-*9%M^RnDqb2qnDombWLSd+SfxrNQm1EPnI$LY`g69lmHPy?bF~8xSv1!Vrq*7VZs{U<^bSp0si&hY z)#1=_A?we;6xa_Y)kaqMIpEUm&yJ; zDeIIuX%-{->X$UXd%N22s%rMPnU7oYK{PEV2^P^#C%=kK-{n|BjyL{w(9n#OiiX=)F|>RF2JuL-|}R; zb=v1i>$FePE9Q2wJ0CWFVBFQHW{SgJTJ zoiC^-UCvV5G>^6Aw;EDC#K^AGs(+ZX^`d@=75Y=8(1dSiCZI*r@0e4Rvg} zt6_elIntztD-hT)IuU1z$`Cf;OCK!%yN`?I){{2(ap~|h@S4=EV*|5d<6|@8^I)J_ zxmeQ5)%7`D%h24MBHFeHr=0pfStD_mG+ zb9JW_Y@5$i_@_49l2G}K+6*T>S8ABo7ZiPVT*cAs1iX@Vb0BFB=v`>QZw?^yUGA|a zN=f=<3fI=aG<8@zw|e`Jt4h=j{5lRF&=0p&8iwrisLLzWU%lRBWAci0YhI9CEYxev zq&w(-A;H-mtmi%?6&(EqA$DZi)g9Czoc(*R_0Q)@-Sz`eSJ4lCG-SPgz8FyU&{FfU zY=Pn>IxEKe1ijcF%2ct9B6c`7eR?*QRh#qH@&7JB2jYA1&0v~9*%CF?bW27(+YQR{ zHcs~qDCHaG{&8oH8#py_MT!q^nJA@3%|<>>?qDmow#RzwQ$6<%h~z4pfMnug=C*?R zge1v5K?jcHVMhyJ2+W{lou#i=|3OqjIoW$W-DA70+;6k@)45Rk4vvSpT>W#FR z8-Xy&tER=!QAQ3W+?K1^?{b(g8`iJ?+CX0@an~-}oGe|o;VXA-Y}fJGy6nn3ax2&6 z$@WmdZ)wAI0GYooEBY!_&;+v#>P8xX`d_M1-wRX(wvOwtJ{S^` zC_y4q6MTVKkji6W6=tUAtWu<4BNfaV;@^~p@d;yhyV|!kC%2s{=%CyB{2?2A5K1K) zCL!+RAezSad7kvT60LYu%u|MW^qvEpIkA@^`rQpX6A6$}!I=dj;mFU_>VQv}fiK-YXvOu%UVqr?fL$x2XeO;}pX> z`Q(UoT3cL~1c_h&I4t+^|7)BgL2x;!0Sf?TBR)GUECUdy*JYuO&2}Og{9#q0ZKC=F z$|N4&di7F8O=qZdwy4}_RuJM}l7|97aj{u%&kl^_mhbB^H?~)|ubiD+`P~l2^nI+D zyLe-`_!O9*v%bhic7r2ObAR3By4f*n`YR3AIqTvxnY~ zx0D2z-tz)d!(nw!Pg+i9=Jr{hT8kWfZCjkU9M`|b;fd(k^z4IwP&>*4iE?l z!u#TRbARP!Kt@)>4}G^(TdS`mxzoq2;MRxjcu43D!dMcd75yMdjmt_FREb7k-}^9= z%gzO!(%bNbwe~ED5UL)FwnCq1nn{JNh`woZ2(3RJt|*=RzDMV)Xtk9HmCjsBqb=-{ z*bd@MXQCC0Km!Vm50+UXgAhY%Q$z))#udP5rAfvWctA3fgp__Bk zht>PeFmnb!hefH;Tj?r-Gzr9+PelspWh|^za@^*BI6(3k`fPfB*X43eKXy8H4@IR8 zT5zj(g06xNQJ7*o#CV8C8maQQx$Wq#6gFX5dv3s&w;C>-faI08e?BUu*tf2h%)n)W zU=aaAsayq2QR~d~|HQuAnF!jS>%Jt>y!^D}^6@DSi2wLBmB*fbGv5C}0YJaD|7VS% zOg+{43=a%*fo=BtQ$q`ThC)3{&&XS6tS*?JO;ihyHlB%|A1zJ(x7c$HR?ob6MPzzz z)2)SzsH16(S~nc8oBYy{gK-cNkpM{VXaMOQWQ$S5berom@cS;McsY8|H}J{bmNq^;)BsEv;PDL_-{$6pN)h?&_p9?#dqPw-kFodRcx!a`|}_dV1nW zMD;h<6hg=)ZQv#z`)^6>*niRefhE6m5E;^2T$q6oS9Nn}rqm{vCj?H8o?RE%{g3Tg zqN}fVI&(nmVe9&1BY~X2wIXq|C6(w>`EE5qL^NN;ael7KJXnvQ&J#`-v~(N`3(7rk zomj|&$nv@9Oc7`iZjeN-feD)X44Ux{;L9qu%GG*CG4avwg>QxS4ymL76g ze|V+JI^z?=O7;o%J>nT^@u=Ta6;JRT-8F||)&4hfOJ2{HYA?`}OB8UKTWD*^&{#i+ z9&yl_ZcErFzM5{UWV)3RBAIRW_;LPA<^ROROueNmlS|+H`qaBBu6hdUb!Tn<|2y%V z8C=?`489`ODEql=BpX}8b|Q7VAV(Vk9+B@PW2rXb?;Q~5)o-=^5sg$n{S%FmAzT(n zptTyv6Q6sM4axZ(OD+^QX2dP0YhBQAWO)$n{^g0^Z%vm zT;QWD&$K@?nIQ)>lbQF;WHJ+-5S1z-#z-fV%w)_A!w>>uOcBvi%c8YvU29#|TC3Ir zrPf+Jw58S~J`*D#A|fIpnnVx~0g);`gwm8<_FHzl>?z%zw*BV&-_JV%?C$sbX-MYy z9-ikuT=#Wfw>&}+JPHZzhpwDQJ>m7lr=;|?Pl)wEpOXXlX@&h&J5{%k+N8QNCe$sS zB4u>f!l0#>#SBmri3=wepqZdxW?*r8`_waKu7qzmd1j~`S#P`W7QQExMs9L!WZG-k z5da4(&vXvKgM7o;1r@0(GlG^Rs);BKGA{l`NU-tLoDMzl+%yYo7dij&yxQ#`YR3`w zrQOC`_}IJ9e?#OhI(7B%9X3iaTR779fR46&1(4Z8$R;Y)vq<%4sSTXFhpW-2He;9t z#&TDYX7A<(gZe;Gr%Xt%Mqok;Emt)=tA06+`A`r-k#&4e{Qxd-)$O5s!|vqzJ2N$9 zMkT-k0udn_Ix^H+8S^?k_qV0`;9f4vs|mzZ!1dR2q%X`UyaAWDSB7M$zmX0vw#uy- z{uQZ!7$_!s$wbjuz%g4At-OT}AI#Jz5kObVv7{J*^Pn7mZjZ4au|zUWU_3h=&qebHN@*T>YQO*A!x)hbw>vi};h;lc-Il zxiAU_)Z<<@U&ZXIp4xdax5aA&Iv?Q^f#VLds9u&kNyiW+?w#Zn-YFtOEdo9-8!7CD zRuWQ7%4k*ApSB#Av1^&*GU)iI)jMj@p24Pbz$oi`T)kDp6K};E5&=Kq6s7IDkZ1>w z$kuthO?4&J11WW=L;X60+ z7JgX8uKuAcFprDw)?>Y8z7{qa@(ZL39N%G*GvisYU!?#={n#x%2Hk^?5Rb(R+oTZo z$vBienvt82w#N#u1Z-MY9i(+%u$DY`KjK5)JN=|MRZ~NABUeWQ#C1rVnDkc$CX@a) z@-qNDb1WFeb|Tz17VyIpIbiAU9*nRKj|6L3!8^q3)fcuzhZaU5I6)&(o4G<@D?8y^ z^!fsRx2~=$K)dd>ojzms`zDW1&wDLIzUDyd!=fX^m*?EI%iSvXCz=P$#@mMbri4teqc*mP&c1#xfgLVa6=!85HpZYkkRg#R=6goW=>a^=GBWn`y9JFy88gl$<17b!p8{_#f~uu z!=0RrQZW%ppod-Lf^}sH{(8{rWK=U3!e|A^%V8g^n^Cx2<*RG2jfG>03F#(%M*W41 z7XW}F?RZ5d9XwZ?V4m!cqgL9(mcrE{*|pju8pRn*Kvi>-WyM)l2beg9ikS;>O1Aki z!hxI<&m2Os*J|!;9g6T^v#IOGJHPXlIrBGMoB6ydlZvs4p5Me2+EHP~CwGy>K>JQjhrOS%vp) zqysZkXrtf`jneQN_~K^ zHr>?Ll&Im1QK2Fx_prp(?P2v62_?ahdbrYRw$>->5|Pf>oF>AJ9uv0`ZhcZ4r9qfu zkdRV3`XD}NVN-0C3QpOrzT2y04Q(T{NqSEqzU{;UiLEB$|49B9w&+{JWH_R(@L5>d z{Wb)8i9h7SUh%Y)5BJ zHri;2I$8&S@Y|Sy)!N%7*wslZuWXoNM{x^=+3G8amuCxVJ%F6;pRMs-I0z>+|a7^1uawe7L)5zA1NZu4Vq3nRtUW z*};O^CS6+trI8HC=M-I?9x}@#J~&OAGa|qJj=07B#LQ?;v-lV;g6Bj#8H=`-YImeL z58GGXf}AvCS76|Cd5dAjR~(ZRnOiqjiL-m^W&Fz#cY8Zbh;~b@3%Vt#Wt*J%-T38W z^m`(>fd?67hEjL^!x44FaIyHXF~*5nR_32-cSgEr2HLH{+d{&T4A$zY?v?R6M17;` z2j#Izv3S##zvU>Tg_JoeXpe`c(=}zq4K8EKtJ?XAoTvI?KwTHXU+hwMl~F>R-|z%Z zMve&!}tCjk_R~RZ)Q!p3?wKEaYaQJT$!{M(>>fTy-C{cJw-Y65I%v(pp3@_p+ zV&hKZ;T0E1TjW>(=w^+;JL z6`4boGb14!>!?_oQ*|)NAR9W*KU6o5x4I*Vh`uouy#+ZgZ**>a`?IaX-erkl??WcP zG%S7N1)YhVMNj(a%+BvZ1L1ZI{vaeGFec)kUKsJ6?$dA2s_NSv2!PuUK;ON~Bf4yQ za8p7LZs@IXdJk9>WtFL9-^R?~*+jomi=kWrM^8fQO5h{Z97NUlO|vK8{itCBDpyZ5 zs_#$G-}wq#(&N86zHWYoYxnpsVwlh>WG9ZEymhcOE2&o zw)fcour1G7cSZ}Z@TG1)X=2zv6{Ui12`tkNn(etD8K)YLlfak!nIbUKp=azmgCo*-X5jX~v zVnz*)3b~hDL}V0>yJz;vxMQK`ye}66_g_Q=3E#{gHeEJ?XazGf9D=A=h!Fy>=D;1s z^V7D_Bg@P?eBtsosQGBm)rQG!1&}9f82goOlj(&mmTQ(wW^m~j&vg&yKQ+S6N1z>2 zyW_j?9~v;EF2fz)SXKcJ0CEsV(e^O1jl=fLN)a&kC1;#Phh+5u48eMwudMNCx>ewGE-ov9J-`3 zHp^?p0XFzsU;0+DL$h8R2KnE$_GJ7u2j>L>Wfs{ zZ-_Xkun~?ug)6x~!FuNi3;TiDWT|laddsqe-ty4c6&gwq=$I#lJ+~)@J-3ZLAMbuY`6O76u^-?Dev$8SZ&)cLX)2!Xh@6Ldw8Cz+XS1cRYq$wg zt-*P1hlF-S0=yrRZOzzEM3*N3#5L_SSJSLf*KqV6_Y_aJ3^;hp#Mn^YWq|@l4%Oyd z1l!c|TxTUd8O`okm4EMce&(uc92%dR)*0zc zW!BxC^N>V^xp2&fpu`g`Y>`SL0O^})Qt44{2dK?*H)#{~!e6=!Rb2}A*ta8zDT({r zw!fPkXES5q5Gg7_WX#+n1htNN3!6@(i}Dbl9IhL_`}>XaGPeZ*k-tJ=d_D!(@823{Mg#`4ge{TxXwA12(_9-y-;jXP_ zg;Tv?g^T|78xi(qQ3-$fliDUPX)F1M|8#%fp8|@JrUPJOTV!Djf9{Lrg7p@yH<9se zj&{-%N;c$f(|12+qJ=VRunLyg-lSgfX$}ZA`g=~nx;~`lht)@vg&$c(wj58jZHgwL zs+KmSbZL%MBx(}9Nxg7YN}rj@Y`KEyz^j{{i0a1ErT)a^E;p1%JCp%wF-YUqpyWIZ z@vbLq4C>F#jZBKQh$w&!_49oz+$%0X|J|ht{dY6RESc!*mxs%BZltQ6sT+D>(#brR zi%R(c_oE&)-ODw&yA0^-=9oTX!>k~pMPqiuFNOj@VQtt9P;}H~WZ62vzpT$s%=-L9 z;5-KQj*I+tWNMW0!3&H|XL;iEL|5C!#?0E^OEd7OH*V?I`-n`$!*YpVMyq^1&2Y(1 zKl*5hMw`KNM;QTQlZ6j)U6Xq#8T!8I9b^Y>v(=NRho5AwnLa@cQ=*^h8>0LmvqT;w zmge6rysa{i zl$Z-+3_@r3uv6lLKgE-ocK_h;1tJalU?hOW8mO8L1d^)BV_jX4f<#tJGzTQrb^?;I zI%A;8X~JnZt@m^QFerhP8~^e_Hlo!VE?uyYzYlt6DI$Fl*iw=dggP3w!~ z`X)?Qvr$2MFuWi3-b z22d)n&!(zORaf;5{yPKiD6~2#8P+T*9BuMMr=(k?igtiC(a-wYNy%e_6?OrPed3Ob zAz*pS9M9+B!Y%aOO#dqyc|sDPyiAPF%!m)!YOlU066Md^ajzg!qwXXPekQX%24=BY zoGp4(7NTk|ibMogiV-yx;Wxu-dPFT?9mmu)s91WaTVGdCu;}IMckxZn*OGkjhhk=` z;E5)oI3RJEdK{TA8Dt|L_PiSPSS=YcbBoF2hhd8$wMo{`?^MWS_l>Ft#>JcBQ*(u5 zT{%R2FoFP;qn4EnP(vD32dr?ek-jKbkNav0Bay~<%4j$6hc;oW3%-fmHao?I=b zR8-q*sc_em3vVvE`d&;euZZL$siwOw)K6a(zt>(b_3tS_113Q38nyc`l-9pO^6*k7?;$sqjB5C~kD7%ZiV$QqWMa6p$qOX0 zJgx>$i=2y|aACEf#J}1FgD?@*FTDVXLKJ?*bf-*dfRH9QIheJswu4E-2>ZZa_<$Oo z9EP;rBmE^VEAA0^K?Nm)y-~kTOkJ`OrLQNA#k2kT#m2~-1_yU^?28jMq_uo5M@gn`D2ro&$eO*0H6J)vwg|%{*c#-RWNB2J*NvUn+wu#c z#zp5aNX$TxCJN!C*m)$dqpm5wte>;m$3k;QH&hAmPdZZ%tUIbyRbZ$wGWhEVMe6wt zv@%AiwyAaHvGZc_*5Uf<#BhC8SK**1)EUqBFp52(mRP=M4>b%?-`dMZ?eW9|v#kU3 zOEr|RdbJjiI*cLhhtDd#Y!A~kZeL^PLUUpd#wjNj$$A2*=L>Re)VW`=N7d72496txKOAWuf7jWIE(TaNw8jalN#`Scn8UanIQAd6&r zg1D1rQOT(4B3Q=!)05l)=sST))-BvhdIQ_KrWcmUcz~kY5#D_S6S4s&x|Dusng;cz zd{Efvn(DdVyUbVU_fxF=3H6^tA@!hiunTn&9>0_!oVMMOFOL@7Z*|FZMJ|FUWTR&xy> z^S2M!V;v$ylz2c&sq)mfdFqDGJQcnnqOOQ~;uQ(q-9rlZZyLYnX?>_ ztDKk7@qdBQtDl%2(D5Bcx7E%$+tO`;XfWzwa;ZIya#Il{koY{0+8Nfzx*E*bRC{p9 zM$ogjPQW}~KQ1wm6V3F^o~c({E=xN$1s5RPkN}>QbKBP#lWIdTIw_vust`x?(2OC^ zaK~q|M<|DRa5W^QCzZBKqUj{FX4=4r}1=W`qxj-?zN==|*=s?ep!Wc>&& z%x$f0jtbNjKuxdc8~i_2FICO=KO~IBX`#gMG++gnzW6yJv9Y8e70=V5vV65IcP(If zJn^-Eau$*&-jh|=qZcsTdbO=DxRCMMx~bo^!&F5kG@jPjKQci-_%#t<9Ej){A4PTN zeKD$@U9TAWjw|KM*XU>d8M7+7V=T2bm*r$b>Fb`7YakEBb>dYa&9LxkSS$LbmM^NX z(w0bcL3#YEwVC0Iw&wNK*NMHh)B-_Zik@jxdvxowrD%~Q${mMhuI}_e#v8u)cCXQx z9GB=!s9bhIo)f6L%YR428`F(vPtaGr8`t?yQ}0~RA)n>us>?qiia(;m1fqKK8oP!k zez!W&$|G1j({@oZeHis38Aj{XV;P30bM@k^-q8%fz#r9#*J82 zA{BjUD;>}2sbX_cGaO)p@{`-;fvxZ0QZ&lpcG`}Z4A(uq@QxX@Vu*dC3Fs&--ogk| zEpQ1AJ4pzdYN(9RF{c8nI`24?@?p(nGo|=WR1T2S2sVLouVGj!Qx|7RomB(~8O1;MX zeIi91A)e<+0a5>#Cs}yB<76w;$SJ?VxHr`x&S|arOljn!9m#!q;Q+1YuE`$tIzhVn zMtS(A@bEdmkL}vtB2cUANw<2$*I+eFicQ7Tk!;}I$o#3l1?B|j67adgh8QWaxA4>W zNvy+=?PR2j5Rol`Fd$wf{kEK$IR=>l%8slrZ1$zf7gpU9LO;ooIW|48((vK{j)isp z!a5RxO+c<*=&8+%a`iAR$Zp=dZ9Pq@l!SCn@A$-Lae21|BnsK?s5;;-fF8pi!MyTO(ks~7bXIEfYrvr zaW=;gnZ5oz2+M3N6q0Z>wfyNsfX*Zg4M$gocH`{$Z z@lP@hn@LPE`QRn@vaP7jzF{}lULBH<9R-lYOnuSmrL?;b|MJ?$(x2Lz+%4EoEmI)D%NF)h)GeI#Do%F*b0yJQVdw8?#3uSk} zJs+2frUrw#1Tzs?uJQeor*j=5g?EBXT`3IN@BA9=X6Egg5H}2`z;XPfg&Rs8+=xRu zc}E{1t81$JCJ(?2Jm8|BsByjRVQDH|`3JvV`CpCQV*?9m#-16%vE)&&`aCNpV z!7AH3Uybgxqbom+t^Cu3HG%k=Nv&oC7W&_<+*Q3|S!mvpGOhsL_Fd7Q5_1?qjyPj{|L&uk9pXP&12UuY{5fr#P` zaUEdA0V%AS%^NVXRN}~j)nJT!BTq!t)$CV~_Xhv1aTIEOTfQL@v!LsOeqP7`=L-kq zZaEE;s6vX#)T)V(3E%%5o+ zKGU0{tV1p4cmre=hXf{RjfniLidjag<2W3rTqM`kqpw{ln(_|C>{Th3JWsUxq)V^a z6E_oBALBXUgzc$K($FQM&ZpGAq|Mo!^Fcpg*unD5#moT8&z-qIE=+lIn`K02Ul7{w zlXS`#-Ztc-SBS2@c25%MKo09zWoK()Yof5Vja1ipeJ$+-a=+iN8XWS^@VBr>%{Kd( z7@!k-vY9~#E#H)E;YV`$hP?5vMKx9eGJA_--fjZKrVb9fE__gC@a&X;jovAlmocH9muW~)vpcXM?tIV~?cSGRz28lLKSw^c8 zg;i!5t@0OE$(23K3Li227`cRIaG(_C)U#;Lm51Yo%O+=YAVQ(;#9zn644{$~NKl_+ za!Qb81iZ+wDt83>qlajY7f2*I6i!R z;~9rIL4**pl`zI?6>w~^5_1*&Ix zFHjlvi6a6$6t;5Sr#uF_QcwcaZnb)>`|age0_G~V^>pZc{YJ!4Uh9Y$3Jv)uB4l{V zL-f2#iux%3FL!rLomrc7cIFUUZNI14m#q>^<)}M_FEf3@MKp_M$p^Sh7#7aZ>jd`1 zPcUf_O!4XCG<;`)8)MkgA$53M>qV`F-HF2PuEHoy#9mL{r`gHtsTOhG zCJaPke)2tBYFgfnwN$)p>`0(B^$n93UIeZ(%OPNhNOZ~v(?&kSb0Z&xFooUlc zvcPbxK!8T+AvvNRENfNQCe*@=?%&W`=Djzxwk2{ef)=SH0n*{xKp6N!B1hL`d+oza zFyb>+SQ>quMwd6`T0Da=y_E7^ogYtUur(sF_^|QoqZIUB3^3v1c+G^uNcGmX>b~dw z@Lv1g3hJeISSX_0O~Y+QeK4!k zh7Cz)XQL4dj;^`GzzO3LR$@+DUn0{tUT_bvqqiXY5a&wel(a*12nox|;@72g?iZa~ z;u-ZwxxL<2w}#cj4eBwFLcA`*ns(uJH~{u66cyaPp_m91e{REAmR{BDpIj4Qm~>HT z#&VrKJ0x`uKG&(Ud=$h*o8Ts(mPF+XF1I_wcQ!0N_0y5NlN%Z^N%|y5|JEH?xsz<4 zn$v)t@kse>3)ABq(AZf$oISpSpRQE7o@ob%>+%qT31%TVa0mc@nEb`aGcNxASfVKC zDr8ouj_P5LdukvJ_5}|d=?2>KD0oY6!>AEV0Ws#4o5M0PGQhLrs)x;@x>-yONqt2!CR%cJajUDL!yR z)Sg8NnsGMR-8YQbzVWp$SP>!D9I@L&H`Of;+mUMdbC0KTs+EdZaj8ZgG46)-FV1}{ z;Ty>&EvBLr^+EYX<=0gW{?va{08@oF5f08$Z@8;a5X3qaY4*#w3Oj6P#xd~*-wzEW z>$%BSo1B64J7z)b&MR&a>X-d>2$qb-i3zc5GupSg88s$ir0D}Bn~EK!Z7(15u^Iw~ z5OCzBniEroX+I?<05p6Fx})JF`}FeLE6Mss)z-4shZ0LcSKypvsXnu$s?{#O$(Bs8 z^fxsVx3!F^h(xAi`T+QEcRT7nCtu9(=7p)xzAz+lq;c!&`pUMe+OALEl3hFtNYVpr zkuE&tHEU=1g8Pzs!fLcXNK{@Yx)yb0L;|0ZIbcOb5|<-*7`@EWzxy`BV&u@`2!S$~ z*@*HQtGu7(XSa0X^@?d$l@35;YID6M~EASHeQrQoN_Zr}cV=evLIdbhl*aJZ-M z&%M6-p^NK#qqjE@syAGh?*9WApLz>bgGeJS14Fa}r!XXIf;B8)x)|7@2PHEuEKg3! z!Rx@JdAv-0EzVFwwnVQ4Bc z`_t~KF2P1G_+w)Dg5RF(=B}qN)HSOSBg;86-85{4^@iI?0h$7NCymihwc26XR63I`>$UC5)Q zOXh$%z!U}?9Cg$DP$6q|#IgAwOVYj0tMZn*7UhY_@!`l{x2?H0IXtmH!(#iWQuVnj z^hN(9=~L5^gl@W5HnEdFdG&WH{QB*QHViSG2>)yH4pXY(s2;=R&9DPg$O60wIR>Z0 zA3Iu}3a1L+OzVO#N8|nhyb4hrP5D@4Z#urTZT0bFEt;3MsMGQpyWDONb~A#F^#YPV zX?eMBy2!t=>4YC81z!EH0)9M8khHy1J)2SM^6DFv_EmOQSbyQ`vF-_KW>Y9e2VaEE z4ROn~N_fKAwrfBj+rlyTv>PZ|Oe3Bbz{3Xc07bC*328%~pRNsLpjC#vj;?>6`yS%IvF9wUu=L?SK~@p;H27A-0)7nfCAFj2nN>?SY8_1p|#~6Fs4! zj0#9N)$rN1dgAIge@(9bgmJXIdQM(_8XJS838>d?Pxk-c)XJG1D{-G9M`7vb`y13e z0Ii|T(ZN47eXXhUe0|qE!;b%P&`meWabIFW;s#pzCDSZOB+r0jX0;aHOBCKq7Y2p@ zbI@ugtCBTl!u%#bZU3fXIN~mEXHJ2GHG0JDuwCs2W0$wktC}3QutG&HUWFwCn8l%uA(n&@J)l+DVyuiJ9o&|>OOmA|wIPlsQ zH$zgHR>)X6(GVp6kO^O>awO)^CVO z$AO2LQ)PVa%e8=e(q4rcW#P3*GjBEshbnjj@nB~pAA`3H5-ID%B!I}p1cgRH2R4Oy z?Dc*k%{}#0vDe&ts$q`|{vt9retoNYKB1m%lQ4`e3c(+82nCdn+||S5Cy^|Qw%>+v z)(oqi2_TWH!M!ZGZ0beBj(ssvcu_60n`ShL-&8xwtap6EntdU`$o7HHaJ2^oq#SfD zqS4oH$f_HmJ_huL4{K>nGt8!g@EL?632V;OA)qz5pktChJY8-#!Yj;05Pyi`>x`&| zDGUed%*8GjA(JC`$SVDB6NIqvlB>|i5mol>wfc0}cj?d*m-an*S>I3beyVU<{km8; zG{pI`%gDnWE|3&fPxkeE%n;sS8j6jG%>Y}Al{Vl3#UJ0_Rt*P!Y1@7?YWrw?DylAb zR*UfVLBKJL;I#&ACq3X>)RBP8m<0z<5xWa*{j(4L#h=D}xXn*u*1+YIP48i37&$BD z1!&C<)7S{c3m+lXe_^IYq85oBv?=1h;iYAt6_-pqk3(rjs2|H{hABSf>MmC^ketA~ zMC7p5gMlW>?`1W)xL$u7q_Uu+iX$>~<}ie3g{pzR_((!u493MNn8ykES?**fa-xq1 zV(j>C^K3)L=V$a8^7t`X`AO&Z{FvBr?18pYJ2~y*_|&<-~Pz-wci81=`9a! zeI&#bg1OQDFThuBY29#BV#8OVfRevM5F7OmSFf*EKXTiN5JAlhH4+H1Q5>4eKCf%d zptr@Ti%V`+3`Nrbi#hIwK#M!nBd*%WTjyMsh$XI1uU{*9<%p5sIeU6y`0UKdpzWON z;(MD~)yRbH}-fVp$2`j>1=jb zl&9ssrQ=x%SWA}}VBd|LcZKAZM8B*3vx2tthNuA%sBir^k@)!Y`Jm7g=^Uh)bTT9m z$(^|2OjnE0?p*XgXMfFZ3EfeLk|CB(&@M95H5*!{iuC{Ke&KMSg zun5NT4BG_{n{#nJ&b;_>YH7K8sH)6f-NKexkhNScq2Z{_1aXZY*{d5k-4ih!M+4kT z`NWfzYKmMpaRkWw)42e*gF>{u@}Jo<*<4Pj3=m8R`+l?8phZ|a=g*hSpQMmf)Aye~ zmZnRO86V}2u3W{r@4M2wkkHq_gJxAfn?l>)UeZwUU zJ+Vbix0nju?i&)jzj8843C8Qkm=iW|xSTZLc3)SubC;bl3A8@xD_%$BS}s(Xci)WG zZI33l{m}T=4a>wJ@;H+yr~0oM>vVH_himrZB5@)89WlWmq;*j^32wXZ+XmZU+N=Kc zVpt8%x~TrxO-C->R2+i0C#D~~E0O&)(;2o zrqt)j4p+89$iGPXo3i@VtLa5_>En}NPF0vtq5+7IGJOL-UHun%`oHV#f6l5()Mrl5 zOv&l{V10@D#lA#$+nVQ)5;2%5m0WTd0{YB1PppXQxWDfY7HPS_P0m%7n6&7>rRLqM0u+KwHwJ_2 z%xFL->VxZpYAC5;jGre+sYL<6)r$$$XQc4UFD&n>7#?3%B~;^63NjvhN<40?cW|aK zY)wWgk-MvzgkCC`NXE2ebwiV}d!<8Si@Jux&ipHh3)oqz=yjX8cn zeE$;r@zArdd(jqH7$!j_hKeDd53ZxTtc31D(!R-9M@)sIXf#S;g@OwA6@r}!puiC_ zL8*rC#4&vm$VkpKul$Be{l^Qcg2@=&J~)^#6^H#;aDJ)}8KNf@DdEWhGjk)pSrJGD za`v3aozZ(wwPS=jdlJ+~|FSQ*-^+ z&@UrHUyk%OMf)bj`dXWiFRh6?yb0+wSE95oG-R1jJL0y6E3N?`U=?oxyBLAQR(LAg zHBJ2>r>KiauBx5{Mz-O%JU6tIbRx5@=oKJ1RQHxK@?~~t^Q2fE zfP5e#!v3QKHDIwXfI>*@d{}+g9hhqJevt<`MoqjkF+C`HCdWib{bl^cI;RNtY+y2R ztLRC?E>r48_k_N?dfncuqjW)4bk?v6r8`Sn+o?yb;ku(2JSyit_;-=(a7p*ap5?rI z|G%eAw-R=CGi_EgAclAHW+N@o8}tIYh!*L=vSd7)o{lh~$RBPqCAtA>?852*h23I3 zX|D*WT-ekuk~eiMHbxR4JnHaU$q(Gfu)!lZS@{sMm#>sjMVf5KVi@*|?|L zNMnpv6|)zZDgrC+a1HL&suPb&_1!L$nYMb;+b@z?fk-kC#8*?1J?MctKb5&@mZ7FIc2w$n zQ&Y9kaqOWycK{~se%5srN7Qj&$F^nZhcoEXLb=8Ss&!=zQ({x&?Oj|(n1TmIRQhPp zO8VV0!=@$!#RUbR8uKS4tE!5dd#-Fn@wjZyC2LL7g1b0*a z?m6+H|A?z!NC3I1j6rQ-eeuzV8bl4^iO{>7!_PLT0vzf15r2z)iz6^~#M7EfboM&E ztYp4N1i{}4LNfL%hT-)wV=v)SK9CFD6um3<@TnFCd2NX+I>(w-FtBW84#V<>gfIdx zYGPu|SyKHG$j@8&#HIgZkvm;JJpRA^Yt|$476$A%N@{xC&gvC5mX7|SqS_YZ;u1DD zAWS_P%+Q2=P|Z3$T!@_&EBtsuOUsz8iXW2`~12etu+I2h0?2L52{}RLzuCs2nrBQ?K3CCrD4ZlL_wBFI};VK<> zcj`xvRBj6%N!|NrF4r&%P;D?J~lgOJ>Vp^W(vkkCXsB>cp`Z1Drsyeopij zlQxOyz|x=-mJ4e_-HR*r1@IY?*0LFt`i2-^Z@WKh_5aLX7!I&a52~kl@O3ohT~qzT zwZDl-Q}r7{v69-32$?^aWu6x$r#jwh$K!Kb)xw1O5?9nI$Wy5qwd!P&-H6aYP{ayJ zYW0HGY6*;6B@xMdZlC=l^anvq6QSSyAte=_mR<$=VKge7c94Z`J zcwBT+Nx0@_5*W9mJD5VKswiqzjMziRV3tjHa_iJYbGv9a5TpY|yk*Iul0FOmZ>7JL zJ0~}Ly52C_1+9Swd7vi?daxGvUC!`p%dyb*BGs*5}T1l%>&Ua?YU6zW~a764+yStskwNtU` z3?JxC)fe85KP2`;fS#hatlM4`)2}_&s2BX_EVV=O4z$Zm#zI)h>x9o6?Cy}wdfn;a zD`OYLTAK75ZTZ=A3M)Lh&8uc%Lt}h9+(z1YwyGzfc3;>dX&$$8AUqW}0m)j};Oez9 z5x(h2n;E)+6IYBS`n~E&)ere+)AUOXCE0@Q52m1f6$5kRx+5d*lu1X#$?kK_ao@sL zHcfbfWeXujFcW-0%UJi&zTh|sJ+YoBk+~+u|8Ys@C-+U?f5r4|7v;CbX=m)(p6wkM z`S6a&(&*q<8uabiCQqB5_{UTVYCY|~M1p~+#5|R-6$Aeq$igugMQmK~+2dpTwV7VZk_@*Jb z!aS1Rt2)~=+e2A}i0RIyykDFPD_uS2_O*w${U zF<~YBW$XSCXUuz5;Rvee=!wq{-%NUhz!R2pw+M9ab!S%|gv3QoM1rufE3pxkMjECJ z6xQHH7rJ|3G8mv=~&9m%i7gZ~HW}W+#qZ&|!Z( zpeO%}9hC8e@GFP8Juv8>c`PDz)MI$jsXjepdX>qqNXprV0R2T*v%AY9zz0Qp{miA_ z4ZGuv7H3@&Ea+Q5He#J>D=Y1d^F8{F&)NF=f2-3E%*Q}Dsarv&>KN$vIM%~vDBW)N zEa|PRX5$zavNh-j>N-~0TA8T6#;><5FhnV#F6={|!&$dr#%36`!fcy(KEf>qm1T(g zA=h&HA$)284e*-&y91L$Yi^X$uhJx;Z@OGKzRbvUZ;X}mayFDFxq4$xJs`0g&+sie zC?ZEYYj!E*-!vW6!_O^N1xnFbkA*c6yn2{ol5wQp4kKn~6MK zNWClwi&uTXD1)D!9;m?%p)Q_OM@f_Tp zhXbF|^?;0=Ypthr;;psfc#@zMkQa=+OW`m;xT_iVeO!zOXY{6w@?jqwuF;u2_Ol_? zANKK8&AHr6uu^kS1F|v%4Z~_2^G->@(O^A=X0hqR2-lBr+yf=~zHy!D&UKa9d~W4r zQL=2%E4CB6h!~fQClrIc+Upu*V&$t}1BzR@{zUdJqM^d>5Ms+ah!S*CW+>SxL! z4Pj&kl5kV4#~DiLw&s$=a82?g3dlyQ-0s|_RFgpvyzx8I%d%=ikN)7hXx=jOn5k}p zIj#BGn9&QQ*{|;S+Owy#He743D(5>e#yrO3y)y5EM0M@ATlJE@gkG|Ok5%s&!|B?x z@x(J?x>kK?b3z~5n8e^*|FV1Sa+m}-fA11Y zT^TR4fl8-FJ838{@8mLY3rzo%TtVjw=og2^E&->LciPF^uFcHVDY-h+MaCmPIPnO5 zAZHBq1_DHIb%O`$)O}&KyuSbaNM-!e_zieB-S}JfV7| z(f>jLkX3K)e>L~N`jq=G(Bz3WDLM(d?0F$QEp4PRAWHBg=jMsWbA7)f(vXX6hP=8{ zn~sQuoo3V1rjvujH>RP?Yt4)6i)W=)-;=qOp>QphK6qmkvLkUiiq)JCecIJCP62SED`&@7*SEU8 zN)iCUNQPm&s5wb25yyHHEp+g{nG5F5W(BczyEYy= zalZu6bZz|L#NUZjo7$9gSMOaL6EOt&LW~t33oOhCy8*9W)NJWTpR)51;Qr#tqEl}u z1|uFWqbI4pp1r@dX7SJN8I2PMDh&LKrIIJwcoIE@w*UlhrB0t3lN@d>uFoLETjLx zY~6q!`5=mLjdA%jW;C&kS#n}Y@>kPJx33spiQqBtsS|hgg~q-Pc;7@~I`xOrLj&b% zMTPpOs=m`H_j03FPR!~@9wqVD#a;G8Vg2HfNacjU1pVcS@qIj7k-Y`Ki4E7U1U&kc z)9pmPUi5Cv?dp3-EKGK;V`q|^9az<OjMyBoe3GPc zJGdtdp--v*Fkj%d`VzACg&Q-z<3b4TT0Pu@L?Aa*z0AepiolCU2))?Ro1Q#PBK2ae z7e^;)RH7=;ne6|f)Rid>0cU)CWoyuM{PFIur{ipr!Rw<&q@|2>d)vL%;FWZQ@LhN^ z(??{+>?DPtG=IGJ1MUoLjrW6 z-5g01!SSKB@n{URp-?*qeD7XgoT9d4V zvTA+iP4pk9gmM@cV0a@-TI@MdIBhxw$hJ^mT6rfn^SVGe* zNrj^E!Cute&ijvmeqh8g;7k(Bmx?Yz(=EDlYY=B*b%K74%W}UM7%X><#nHAr`z&|u zENg20x(lQ2W)iDA-jo#kO|y7W7QwoZks0vmjxUw#MpwYy*2jsl`!T_s8eBnMh>1M^ zy9j^fnq=gOoDeV5ow6xQlQ5)}w|r@Nw&KpJC#xaI?27NaN(P)Di3kiXV7z+H?KdMP zz-tc>EeYRCgllBrgjXn0y^#v4F%^k=nIZb<1IZ~_CP%_v=6W4bBYf7!uAN62d+N-h zIPUSbW2fy}-d9BibX>hoAV`q`!TTj1)$3I^_?V-yEOjq}GSzzDJ5(a(#fXGO?N#oMV3P+7HhF+}ddMRcr3L+xFwZEg z;fs#=o8#NhYUQ_gO0fA+>K|EkKoBv$=zz7vR{t2L0Xof)U7eVv< z>J#P>gx2IxJm97UX9@#I8oByU4_p<#09Lt{DvVe>Cbk~`=^{?gW8szLTeB%+Qp7hRvTsO)B+{?(;b zf&3VUkDPY;WeGif7H6;i>{ow`NYXt3+{%*NLu&6-(*3excl)VPnWT?lGsVi;u>N4^ z!37uc?7mXE^dXpZO!R6grP2Tc)_M>IWh3LQ_xK_=M_MMRMNGS5*Hk6X?+kV(GOJI| z+Wx#C^heo4dzs$b(!os@MgQH*cYi9#AR`9gq)-l}A-7HJC>KV!@sOEEWCgE>MtI1{ z-<+vX^zAcc!lf>)W>_O75;&hmBWkg`e37Y3h?>#~nOMjWsp`y0Jv@e5)zvqpVwoo4 zxEbpv8hWE>;-pI-v^^-Nd|W-@gV@&6rvLmc@q$0{c$=ezL20}?s=ni{N>Thh$#Z$m z6fj+SaUq1aM=h_MSG^oS!*{gv$&8wn?dzV_zbyv`$bW_(z1OFx#>@!%W!;iThXW$7 zDV?1VQN4veE}+_BA$#MZOB%2Y3l~<}k^Meg(fIYo2Pdc*O^TTC%Q&Jkm!O)y!k!rj z`;TD}`cT+ zX9WC!P32T4Mx*Nfn8dQ`r818wD0I$Xh&K`peIU8Q-y8LX&IhhpL`f=T+Nx_Cf=0|~ zz@~r!U%Ci~gFy$xaxONLD_uU{4hx%vijbr*A?dw3IrY*#O-2z-Ln@tjQZ03Uq1`J9 zu-$uFcy?4C1G?pxb~@Dez3|7u69K6N zs2=_4o#m7b_;A+(_w_!#XP{hP^$SUkJQ4IDLno6X!c=MMlf+YMp#y@!QBgalekPW- z9++uBCMBHUa*qg?dqf=Qk#I{?&a2kw-XWhh|b%lcvZQ;F*`l9f72i>PRE*DP9VQ z@xr?d7~F$BhFZ5%-RJW+_@{<-^5@Y&z6lI5-V8iuQa-6nK1cm`p07j!WNc?k-i9{H z_B@K{4C@sC!N=?e*mte)ANZ=hqCw>)ir+%$g=VMjIin$vK}W;gM!_!9CaU$1 z3Rr9G5VLE-%cL80l{?NM)T@KoDWkjpiU4{eObDS&sO}6lIYK^AuH$%+!rKW7yvL+9 zYt#?~k5*5qPWVx`QNUcdtj$K}y%Z3dUOCb#mNq4rM)NNW{`qLGG23Q(yf^4V&gg9r z#=}zGH#oC;wahgqFgLQW5l%euK+Y^1e>}v#5j^t4k{KN`koQ2jKgp#ltd6udLWt+Z zPDR2!^Xgu!p1@vQ6ej%PmlFEn7rE3W`wWop=L22(o=W$8_#8fUugACY62B;$hp8O7 zt&RJIPVz=DGlB40Eh~=@GDdrv<`KMOu0>>Qwp>WEaY+>)PM|4tJLvE+bQXc9W}%YeCr}@6CR9o9Va4Otf)}*v6$5 zgm<4Ij?3v5mKGsg*OoyM0aB3)i6_Ug!-) zd=7b`cv|wyoo994oXfMCx?zr7lTcrTBp{VI7x_rDiDV&?9JcN{DYIZ^3vLrA=vo&!tt&HN|E?F&z^i)+Bta1ipgL zj;;5qJ6v|n&}pH;9g)W)y|i^Z0s^Z~Pw3T^CkaZva3tL4jZUTelRF{txgcynAh@QY zxBm)DpSP6Rlaw0pqM!IOt$a;hU->5z=QFMDdcC7MQZ_-iT4#P0q zEkGVl@5%?Ag0QvG$gq!C(LC+KJKSvv>3R09uP-UQ7;e$@ z!sc;b9QSzn6P2pFO3(WP;(PgQ55V}Yth5>xLk|7Qnjl5rBIB*4NlUb0xGZlZM6raS z1EmVsH2wS!h|5UiAX%0!8_})Gd(>5B`k(&el)aPTIxe#kRS4dTXKDFzLsMu8F;57giR4- zSxSXqPE0Ln?EArl%C=~mZr_~h>&vRWIi;MjOnYAQnN&=c;o3jN=a{s~EIJP3oD+xP zajhNkZ`i`9v~g{*Hnpr%Ey^-hE3RMq+v!BqENc$?pB@kn-GFPVS3mrnxR`vdh4T@N z%WwrdR^`5$Q{9*h*&WDLm0OKgBCO8{M-qg5ygVp{9L~fnx~!~j*Ukq#YaSLmMJVAs ze)2ae-2?7gf)I{gTG1q$=2Ng;9W7|f=Ckv;9kTl*T}DNjD8S^;K`9g!J>C{J4Hr+= zmmL4@7u{$Jnl{naNwWId)SXFatMV)#-CO2b`LUBua$#lT;x_p@m;Nh;e-@)_-j0`5 zwnOD^m?LTD03sY5Ub$|2Y;5o1ha}plXiv1Se>%DPgU)NREAQ|2^5)ibqCL6(K^Xz! zd@g&NkCtO^Fvs?vUo!ke@0$5AHYo;;!D;deu4Z`adtr4`{mMXOWqVZV3Yr!4q@|Yt z+OC`+*aD_45$_Zy$)}q0W$O-1LbKpK z8+p-4SM-{OCt`+W&{GdVo7n_7JRA9)uELK3G~K-E&bJF(=hFYa%bXa7iN#C*tBLmB zHIYc5SrolxL>C{B#8?du*FI3YD6}H1E<8n&_uQWFlin8-%O!K8ennGJmRdVPb*I4t+5Ym`+5-U8dnw6eNo$ z{)ONs5l~=ZP)(D@6mpGhDj%rEMM`rRVd`MeCQYHwVs?Cf-m=oC&KQwOQAr;5Luu0e z$cCOxaI#f;?nit#`Fg9!mh`|JO4Wt;jH}jnFA`GT(K0EN=jW70WWHKrKdS>lK@gw} zVnTLYk_tpmxjp+tOe5Z&P3QEj-*vh|MBw%*?&KC%p5l9HfODyG z9Q%jPr6Z#GhC1M*1806)|Ftv8bc#t7rG!T9Y=c;TWg}g^EI4sU$JHn0Xp$##{jD?G zd!YI8c+e`(u}b0)e^`}$!|~>1e|@K<+3L9pyT$IVn;%}|j@;nX_i9Q@npnOnWl3}q z57iqk&zpXfV3^KUboDLwO!cP9S+x@MG8_X_q+UYERLZROEwyS*NWETH&JOPTtBh{m zp4)d&hT0o!j7f2_`DFtismk8eJ+WI~9>NE6$*Cf=slS)`bOU^>$JKXXIsHI<3EL$5 zI5u~tD*7@tnZ7S(-fgTDl>07GB(AYz6&@YUq?m9gV-M6i$?ul6GeZS6Ov}((4vFFBa-loae_hH1OaoRu57?dYDXnTF zYYM!_tOjhL0I6R6-K~CNX#{9x!t+RFvLU%)Zf1)syZO(^Qxb;a5Jcb|hK4vh6WVcf zas9y_C)5e+-z4H9u~?;Mou)Qat2h1Xqw?$pRM(~@ar|_ltn(RyrZe3@BYl*#cT|@E721^z{HUHeAJMNuJ*=k zo4QJt0j}v-a8`<arR{c+MWN4`U59>_Os$*#CG8{JrH-&eNBwNcBz5F6Ut76uE`m zc=P2vx762JzN|uhz0%#bYt>ALIk3@}31-wEvn%8*E&Z#n7<`|Dk+*wX=gQrX3tgTG zW!m}F-1eJs2xKnC!{Vmn>N#QQltMx({{QpXIR0R?(clbnrCjP8?!I$9eOGzO4N_O8 zHqGnU^o8_>X|m+Ku5Q>yO!Fg_FjxE6A!D;Cu+->DSD+dKEcer&vy{0x#D^LEtILhz zliV9FJ9k+eEdN;g%*W$>XUp!BC9|t4`NLdWZtko_WZP+fJC!%}Y(hQNCZUK(XNc?P ztXTZ&HMf7Np+lK=E8$zLPtMKUnT1g{z~uy_qT2J%cL&xwqiKEhm8^HZg!l4c&VG?) z%y$qa7;ho>P;g?$cgSzN1&B)|K*Y+iMK~wk4aejD->~hZgf}1;z5><#T^D86{yDqy zy&SJ%)Kp1_dV1l-){T+G#=0bkmzWSfM>Y!YiO;4l;Es-UhjUBizPePNRz>-i0h$i^ zbW{6v>7)O3V*f(3B_3Q=y4X@;D$%((9k2de%73m{068GFa$IC+d_?^|+D{+FA7#?S zr;LX<-Tq=E9?3Rz#{i*DVZa1u0+Ae&^AE;wKD*ticn=FwGjRs*6+qYEh@GzMhMmn~ zbrYJ(AW7D^shF901){#@o9;`GyQT8SB`8yvD9G1%=~iIhF<}9rWyfrb=X0k;_)IrE z-Xwya@W|m{ZIP<<0Gwd3MPY@#Qzr0Yu9w0^OOv@f0L?)`rO*gy641Gtq3#9;ZRU9c zgCYjRJGD(Yi11+u5ov*+2VGNr^Tm(IlxxLAH@)F)sF1z2ZVCpK+%olm$MsOP+TwS2 zOw2OT(5F_EwsWw<7ZW5};t9bpkD4E)H6rxa*2RfiPp%)IJFTvy7bk7e@o0oQO3xXA zy3*Tt(bBQktVlflnOE=}j@@~`$O_8$a^P}-LHXoUPw8WpN98k_D~nx{THbyS3(2cy zam@(fK_OXj2W447gRj<$&hh81>l)1zQxPi>#YcV;U=*+zL`e@D=Fm1Fforv$Kd3s; z?&#N7&H)r~x54QW=!_3Oz|jDG9<_!(s-I5V=xx!v8Xk-Vx>M>$A=3YGLfYKL&?j#^ ziNB$%?HE#pftl<9tJ6zJHEM3CP)<5mz9;O#WtRHCHs$ob#dUoQce}1CHMlLiE~}oN zrk+Cp@vkDlax)E1eXueaP3lkI1eK1%u){hW!!!HXvB=DU%tnp4#mjLhP`=`LjebMFiI4X$gGSvlCYv zba_OE-;J1EK)Hu_c{BN-*rwj7x;+2xf|+BFz!&v6k~%7Z5CQqaw5h z$mNp*d&9IBAeLyBbA)5^v@IZHG%x(?0xTWb`ejJCe*U!wZ*E2h)l7jP!$9+lm>1qFZ9ieRU{qQ31*oR;Y9 zKal zM%}aK_F~;eJYjwKPYv*^4Ry6tM_|OZOX_q{$WwsSkw(s)1-ubc70aU2@tW5)+txS# zc0w<11boaG;ypwI2NAkMrW@-R@Qx*V3@2@52KZP_!T0Z9y{Y0?*HwIcYo$K3yvo(k z{^37lcl3YQ0cB zK3N~ub1sgSB8Greujw?R7CGS6Z$A)Qui^r=7K3S4_18mPVTRXP3~ZjsJ~NOaQ@|d`>U~cWm9Y6O5Aw1KRz6EYtJ7 z#-06tWW9Z0ljXhtpQK4ct2WI;(=@53)QQRzD|Ttxq#;Q|3N2z+88XHgW6UvR>KvQS zd7N|V)cLgeG!Y$MiM1jMB11%^Eg&KwPXl%_#<$~)ozt_Oe$PX{XXokn`}X(xTz3lY z{QjVnk|y_kU)S|{e1G2W#VBt9yU7wjdD|JdwraS?-YQ+{01-F;#in=ZcU}htL~6q# z@Mr*>w5aFf>KP^*rBK8@&G?AnDZ?X91TAhsf~~iqEWJF+kkA=^?@8#m?rw>h?&6S` z=rM1KC<_1w)DqP?dRvYDe!&XF?!d@EA{RhWCLfe8MK;x;ewQm=IaB?@cnzixm*Wfl ztHXt_!2RlQB;Dz1y7R_r5De0Se?|Ns^ei^?Yiqf{dl^8tC{|=bS8x=g>Zj$QD?@Gd zo7z+;&WNo$iV3#ty#$sb_ZTj`Rr!Ed-59XP7R*KtH4`nBF)@2qq6>IJB5;`) zCQJMjDUs^4+hdl{umN)$V1SJEfDA^~>XhKj#?+nVl~-5B1N!)%(YX{r*BOB`Z?uQf z1n$#3@DCZwm}ff6T+XPYsl3_P_B}Ks3+Ei$ zJ2rUl2;38SG>S&zi5C6yXX5(jPs#2UiiOj0`Zsmz{s7^dI3O9np>9aWG0JEdaCNrH zi?+C3Up&W=G{ZD!#7#=|raH&8-;EaqhUQ0yu8hVTiWg2U)|)~p6w}4nFEZ+jdG#y; z>q|n*>w`UY{GO0?>Up=u^}H1m;h4mc2E0BJ%5_G2Lp?CAK{_2)_oGhTSQ=ztRZQF_ z5cUzwYZ1L4X$S3&V~GglkS8v^AA+4She&rD>t}v;{@>@n^E;(vewGUB+>mK;oiR@m zNjW*&k~}!f+_@DpveMSJkgD0iIIJ(`jsNEl|N1q)j3=SC*sH-3vGb0zj_(U-=}p?P zwCSzzU+PA$Ih-H~M+sEx*qmsqV~v=9jT8>M+Fkic_f$T_2q1NRIFUY*+y4j?6}z=X ze>^j;Kh9*DI{cL=Y48kzWpFflLjn~dpg3lmW{*3hV~z1e9(xClp2GZb>9&4o1Fujx z1qn9tj_telwkwrVf1B=qB?CQCg<9%S_n;Rgv*wm@L2xQH4Y0BpIklKxlyTE%xxG}6Ry*V;H8pv19B!(Wb&(ObKhvQW!>`FBg zXTvP=|S#KOk!p^7q-eyD>3oyDP6nr6OBhQz!6qYL3vS8KW4R z(q7m`8{jCcNYVwAMn8k!AoNDD<`20XiN0r&Ke=CuL`vCa4ePB-zFvQ_%V${3Z|i zbo$;vSrts)b1%vi(c7rlQx74Y;C1QEBl{rl%@a6WI>mhFLXQsC9m07@#CCBicfem0 z+x%;_kM;Qx4?^nl-9^Ssn}r+v>9Q zdb%%4q9Xwmyd-Q;0#+0c-1?T=;O#dpF%u_Dz(kf^6j&2o9_?+sHv@&fRIfyKL_Hz~ zNPuv60;{MemOdFi2OZfb(2;%qWK?A2j6i`Y3Wf!XNT?Zg0h<`E?~VS|ze&7#GkATn zrdQ9N;H4n)xKKwTo+&YI02F_Tb)8^?;a`;rDq|~rcS~6iEHyO&bNDJJ&bDs>jLW14G$3|s%eo{5Vvm3rPMRe%w}2?(6!5;im*Uf5Zv zoFm&htX{Fz)efGDe!X#eWBM}vy}PFpbjn`Djl$k_K|=jQT74laf2V%*kcD!L zrA^C#EjE#|!HOawHGi`Ge@947Y3cS*y3Ubk!fDJV+#ZlNeOYW#vi}chwT5lqdid?0u{huG*(ykV!b;k{+L*Sb&gJHHV z*WoAJ^v(Ch3;Pn=WExB4Z=5lG#m`!GOE;zZER>n@h8$da&ek=v!zCt^S|VGI|}h{CRA-Qnr9*~V_DS4 zI1FGtcdH?Xy~!6hNQ*9dd;R!k!2eNsnayT35j}zIH!^Td)t z7?&h1&#^SYj>?2boU3Io&V=@OV;{O>>O@Qb_IUq$p#RlFPPL>WbX7=SdK0N&?5e`C zX@x`H85mk$#zpX^UwS*PUwU)G3Q5=i)#yVGjF>+9+ZvwX{xXWky>aPV>&EM(h$k;% z4;+!~R8kc)Fo`q@)x{7RyWH$HFR?b28Di~G!RZ}`=1B%8$ossrB}#y}_<;%C;S;jU zVzOG0c+T>cI(WF{QA~}9q`f0)PzUDlg^TJ2Pu9O&e_vF6vr#>qSC0WFK3kdgb|IBX zV)m`NUT=`MCjwy8?2{-Twck3bR2#~oT`l*-@0u-SB2Z?=B!HD;&a63mMjpfqp}2k_ zFtKylt+K(`{0!Sgr+2GLUhtqoQ_yhJJEuss4?#7?UWZB<;@D8#BLQ(nLRxXBfZ6S9iv}Qj&mb z{oW(qvZ}V2zUkUr8g@eV6g2M_T7X3HV8+3cH9Ow*H>2h((y=Sngtf z9e6pe53H6d%~3(sh?EdM$gdyzra3Z5R_bY>wJLsWK>Oy(Kg6UcH6}Zl2YuWX562g0^)t>-w;F(o_rFQ>5{iZO;<^^oasb(8 zICl@zX-<+B_N|Ziz0P4SG193WHPqf}B-(|dt1AE?oO>3V+ur}7+`h@t%#=G7n8M@n z!sC)aJYJqJUr@Qsb8mH7i~dbdT>oZHLO1^QJTfFeU|^6xiB4>sO&=;+zHF=AeO0C8 z-dhb$;y4ya->}W`REgjbazBX9tlGEp=6h1an3LpC-RA6ZZvGT+0qa*&xNVm*D8*p7#?S~uPgeqL1 z`b2s-w9BYJvTKL=v&X#2usTfbMim`ZvCzhuVXHSGzVJ|0f7Md2TH#mU4yXsQ3w<1j zke5kYP`1TqE%!R=fOh#_^C@M4t?$R;t@D^QRIhmJus)0ue8i-!B(@XR@e-f=Qt4mk zUUu%A4)v(%32bsq*57@jJ5O{pxX&~AQADbjX2YJXmQuv@&bXf5VGORRFG#g`ccskK z{YZV61F$^QhV;dz1JRy_yBI*GqBrZ>pou+Xr{YFVS@j^hfA2eC8OwcvXUHaHM;A7G zm-_Vk%L4kFuLc#(EhrRoR_Y=RQDg{w;6FKpJ*WrlbWTS<7F&|MJ$+wJtt+#& zRd3zn)vxD~Aj2h*wcr-m4D=!{`&(hOg4R^M!>JU57EmxunRPOQGuHIXOm*BBnmvzu_@GXUL$;NHN&40oem(-*5wzJ zuCT|-o|eOW4gZI-fmcucx<5tO&O?Y$#h^$EZ%IZ!`LyZgOSp4~LpS){t6(^wd;klW zd45>%6^ly%b!ha=vV35z@QLb*QYq5X=r#Aq1lJjxH?ix+^w5{n`i0MAidS~%?43Ei z?W10&6LI(Mka{YjcGN=^F13zB;zg+`U=Rl=L2qwO zf|8OD1<;kGaXd;bHnyn!KDKD5dJOAn6zIl)T=7)*LDeL%9Y6BKCPkowdrMp`XDZ8J zq1Hl9N83cI@1!vclln`C+Lz~GMWblB!fu}`*!?#xgw#HMIvNd3>J0%~7$YQms3Q59 z%F5Q>Qs0ET!zAUXf8x`ff78A;G{NY}jR}80h@zfX#@o-Tezh^Fr3mQWIDylyA z)_0(u_koWNi?Jmn)#o3I-DSpBN2@1cCwBZcu6LXet7qB7M6o4VjJNCjO)2%=3;fF> zmq(IOeaXMdD?p^z6}IAjI$w(G&KC&BCZcWGa;d-_QkMS4+oiHJLX_zmX9=EdC*Pv4 zVCgYPAffMjH=$=7ZYOgccdd4*A9&Ocy~Gzh+bm`S9yz8IB8))sDQd$7G?s&5{kcEE zLn1{#x#_*T%}smPzZA&HjAG7mdwVU>K{nWZU!e48135VEu0{dkq(?W)teiv2i2VA4 zc74<34vejo5v6A8Na&4^X7zQy5UUy6c&mk=X~GnFg&~l4y#0G*J6w<*P&0g>U;n#^ zx7E;&NBD|ic}DG@6s|?kn@^~p9u=Z^!GK!}6h?Yjf{7P$ij@kp!^3f}sUr*31IRjrc01^CBZ24!x}2 zH1}ihAm#nV?YW@x~hl7bQqfK!`4^zq;w4R2N%s!;H^wOkx})<{VM0G3h_CPom`q z^E5bkZ1SKwYU-H%wwm~mCq1|?_fBr%?7KxX>@9n!EnJedkwU5r1z=jhHl2Vt&R1ce z>e3-_x8B&=e^cVojOxg$T@L4*zyeA{dg@Q&dg_nQ`)}-P#cVp`-q`_=Q?K9*Ku(QH zpvPf8iVm_Ruo&p9kTKn{P~ikHJIrdNaJ0-xy4lP?>rt8(+~m7Nry`I5{dAXfJJQps zjCBc~VLJnYphTETqZiiI8c!@ru1wiUlB0zk=7Zi*ebp5dMRuD=qYndhz*j+V@IL*m zI`3@udN4LQ0|GNm>v?cjWD`3x*4(1r_Se_(zsJk{EhOuKd{p;+O`@cH{(7pIVqfcsYXxGL0skW@X`Y$5|JE=8D^b1>S|D$z@xU>#LgG8Lz`zd&YYVsywa)Ov{#!x z^<-1}O>+z1aHsqYxrryxZ<6*GcwgfHd&1(z-A)hP>~S=9ftC9-L;$YWuT+xi$A8qOj$$_?Aa<;*Xd` za1x#kFxv9&A7iFqU8Xw&Fms|5STfJ!scTZ3Zb~<26v9xZKEesv>ruPy zuI$8fNAHH`&R3asJDX6QNwvD&Rd)@+RRl==uo^5wKsjBl{@J(!`4}Q0uyhi-r9u*C z10NnC_kc6Wqt=*JrZG*kF7iYtp>9;}Ppx&@((ZY|#bKQp6PGJb+1{qNw(%});#W*N z=zuRsKW~84$Ue=DVWxv%1#t-Og_&qSL(KIHC=omK&ptA3{ozP|OI^#JZ^iel5WZu{ zQ@6*@#i_^z zc>yWISfDDPd#?`3h?qCwMj|cdysuOUT+fs--l5Da=T+f6U)POYjB-3sgZ+`ml97mNR_$4+U}I{;e?j|_TxCwjzXyjx zXW^aprWq=m!B&nrE8xBrZpUIB8}|wIkOQTyuBcFR8+}ko(fwhu8Dl}i7Gv}RhXL)} zz&8JdsUT86!KW>UoGaf}0)@sVHd!`0`k~{eJz+#j#`ybB#R6ee~fw z3!4~vK~o~_pCh6CfExDKNMmS3{lq6+v^#MO&-f}iGGoUqv51b??vI0KG= zGr#h3Hjcrph%SO&@j+a#c+c|u@(8?=TiWZEgw>`pf*(Emx1qL(H$mOVKQqdFK7~4m z2__$^2&@d~fmNYd^-H6-eu~9au!Q(p{eDM6O8KVt5eNfFp!!>$xIB^0=&J)cfy48k zr{ZAz?4`b}?1Mn9RXPmm-4_#42z2C>`Ql#U`ChfY=1re|^+t0r?2>_(22H#&U185b z21pO6L80v1k>^`Oqo)6TYbiHd)doQgV~38 za@m2LSPha0Gfssye0S@fi3xZ<6!(4Dl7E-} z=(x{2(*R@w72cVm@rs2!Zkir9kHz6-w2qaWWVOasT~|H5CTZ1QH2pAKGt1d1j7Dsa z9s$7J{DJY50g0B179KO*{UP-?Hh=KZ`b+EelzsGA^mX)bg$e3S zj>#~ePX2nxssoJ&bG46!WVOCP-FN-ZrLTIlEOVftBbVFUCD*LBooifTAU^dk$^tj7 zCLp7KMJx}0N@1HL6Pv9YcK1rJg;Hx7t7}eQ`E}*V%6zr{?0n{ng|L`_0^}C9q;*Sg z2V-q9J^e|jhicOL%IO)2lETCU3+?I)4z;9AecNT#sAM$->?9_4xIBJId|7f+ADFpc zQ!iDodXyr=w-RKI@&U3w4zG#3#p2n6BmibgjGjziI#)QuF=o-n9qsyx56p>W!5B2* zIl+Uf-+azgjTx)rf&aA3b@UeZ9RIwiy^C%ZZE#a|hYyurf(ifoam5kZUF#4mVls9( zinb%{T63(x`Ii5T>s$WqeBdnOxtm+nO>JsrLj54=3N#1O;ROv0N>pXw_=WF-3vLi1 zKnWrRZp`cgiR&sC(~+bZ2FA0`trx!KDZJ`ecR|)bowu-sHXeuPEdtEbteq8#ZF=*( z@u?||&KMU&dt$&9X^j-#&0|(RQBOD>X$DN+3-{J9h;sg9fh6K)YXM)zCKV1!TgZrg zQ`q{c4FpNy4ceRdk5H_zF7U~hBl{0T)DP-)(@;!pXxWqnd}*rKU(Hg%w`MlRVH+I)YV{^ej82#J65?Kv)c+*^IU!?wBCyLH$E+<`eYoBt40V}yld zk(*yMqgZkT&ah`DZ=Jn)Q`hGAc+1VN;61rs^_(kuc{CoICo^kCjrAn3u{Pl#m$mYuT^je&|0Mhk6>-w#$o`T~qvQUcGXmFJIeQt1rDR zl%y~CDV0FODAbr^4^hSt-}2QPvwA7JF|5-|>UaL$R6?ka(1ky0AqH-BXf z1pDem{}3=W&(P(+4z13cEv?Q|WdbnBz?6>5Ftr0>Sua<^K0j>zOzpt|ow4OzOq|MM zTI}qyrekPXM67~LDIK?Wi1+M(2@oFqu>4iyjWvj*!V%Jfopx87$Dcz!Y$75NayD<_ zczr&q7B|?FS7p3luim9K1qdFzp-p8#;)!IlqjI_jbdn3lH6~Y4nwsD6Pv>^89Ayrk zHQl)3H|KtigM(gdSY(Lj#TI3jcCLV$4C0jZ)5Mvs!VX_7h;27Isb{@5stGA_9D^+fb)6Vf9=@?JQ4y7O|jQehwmpL~&y^w#vLz>zF`>v0%&(>Y!Wg3Pkdi z6u=L}3fsA2k+KrbjdkV0reG>M7h9V|8r3GOibPkZF4fA1@h^eUaD`HzAJ*jH4@Rz??}CeQ-`o!5$`*xxwP{5Y$JsF&EMe zt!=0JeT&@ziW58Vs`0IF!>*ick*QE?gMgv5o+M%Ek|~UuG=9pNjh9_;yMI-;3>-Ra z$F%i6h-?2&u2|zXYH(58YVR+sdgnON)nkYNn?eX3mzBHVSC@urQct1`=fC3=(F4PjJ2^Z@_sl;;uwS-84W(gZGCr!Ub_@GI@ zBYdqG`c3uVaJ5?HRS){05C+||sYP|i)vQF}!*2DcyE<4M_ZGh#Ie5ab`(JbX@j+d!F3MLR%741dReGQ2X1=-T?3i|$yc;O8S z7lk*?D84Bwaf=Q7MF}hK6Cut$paWREGcx$TzAVf%RUTCp zFSmwOV)vY_27v&FdZpUoQKww-`uJ6|3L_NR)sYJVH-{3Tl|*TQw(xB7n3JfI#0r~R z)Hf~&bcY&)4!BDoD@Scvyp2}Oe$kk+*P;?u}k-+C3CyowJj|E&XH~`8OfWLMQ?sBGG>Wgj@V8B^KD!5hM z>h{)p_1dsczkF2#$S58W%VmURZOx7z*HT)uHj1n=O&~d!r(4P}Be0D10SSO=MAvk zF6Z`NPfOkS#htz|dxGxj6A5)gUVXk>Jz3^j=-$&GS;Dw)37?9IRF+ZU!6*SFvuCvl zj5c7$A_yT{l@yn#m0*1t{z8t_i*q^Sli7*W=de)NwE@9Gtv3s{-UJXsf2<$6r17hb z3p;Pe0WxJk^gx-Zp0I^nQi@$@i5({aVs8BYl?EH99+cvu5kO^Gj{B>v2~-gQ5rF%! zt;rqpddUe-OCS88v0wWrPpSR}GYLBGZD=oyUx>&@XjY+rc5{z@^51&B92X!0lt83N z5Mw+6tACocy*D@|sDJ!KZ64ozo@EXIJklA^Q>rHe;b=F^ImaD$xL0E&&1Av(DS(2= zEpu??FL{h;FU!A6+u4A}WM9iS79EZZ64+zv88f!+MdM^V^v%#?b^5tgCYD-pK9p+m z_C0G=N2~Paui?6Lp^4Oy_IEw@5UPXONB?6YB`zz&yIe(hz$32iro{Hp@7?;EFMEi` z%mqo_vb09sV8vupz6XPYWD;y|2ayNaw4pVkL>4<5p54{8ko6)#kkCw`JK;trnO~LB zjgcI#FFA27-h`_#;2!)}ev{o9)sy42T9(&V(-0ba=Ph&L5!qiy<8XB>Om=EF| zDJ)rRVG`21)gzVaDaHZZu^F*sLSK9VRG$2*7;=hx_BMB~*CHL{S5bm;S~wBuoLDgj zO%BXoJHU1O?UfJsw=Sk@V^n4=dt*G%b{|qpz5a9GbL7-UE7qhWbmBHyHV=p;(+oNu zXF4M3SFh3q^TJdOisYC)M=yLIhvkD#mo=89=;e@cOrFH03Q&krfE+#;=Uw`K>Wt$s z&#I*kR0#)A(r%g97azsJG047K)S%-igH@sH<{=~ z5aE%3&*~NL^GTSdVa_7fglt!e{s2P(v%hj7!`TTqR;j22=7-cvb;WOm)iHMcn-De` z+BP6>zQQ5O1+&%N-Ksb#*oNBm0(gZfe@U0Y(Q@$0_`xYAtl(krx&C}5ttj&sSc2%1@EZ$_6Vd= z4xZV_mXMt_A49InXfY1Hp09Mc?|Qw}@a0LFmd$6%wd3Wfs??ecWF2pG(wT>Hj=@72 zndyWoD^U1Z1TWI-lq+C>qjUiVgCvlAnG6=efT&nJYRqTUUPowZeRHnxj;Lr-V=Ptm zj#LhPrLuTsRqUwXA3<9Elf>WYkUQ8Ng9}Z|Knoxe*MVb75LvFS#_0 zze7|l$Nl&k3{Q=ztEVf< zT2yCTr9=t|66OwXKqx3>{lJ1rkrIQ}*t{$Gv5aSlQMa!m$Q1n0v)By;Uvd^#klz zIWbEtwR;qoD=m{THrHk{t`~gu9Au%kkbAYU_3GPxeKz~aefj-!^Xsp4LmIZ}AO6{{KiA?4{xccM`~AU)M49~PsC>1ZTn`#%$zn)e}e=vQl<9vc<%5&6>vuMLqCN1IXzoXU&Uqu zV@&ytT!CdDtl^1C5AYyc>b*MA5Eg6E!wCb@@}j6q0MEDU=CGG3({bidi?vl)|5Ygj zNCdhj1pvQ#)0zS>;-1nYu~i2jkIaT3EdN-i62Y+1Ul^cBK|{=atvltJ>(zHOAZq51n&t`{-3P3ikBR|X@$0qEgA3u4 zK|V-T9dhL*W%`AKxKzdq~?ST#a9GXUhu)Mcj5PMg!J&dPIj5`%(* zmzk>R2_3Ns^_H+2oel)L<-d)kf+5S1+0xUo`Li;MvllqZMp{t^YvTt4NscUm=7>7s z44_2DnED^0MTZ1Niq-nYq`=z1g5c7yni*AJZ!FbSCP+`knoI2sHdaSuR>wkdq748m z&(`#YK)+uIz(LfEF94+jBMI^4geJD#mkbbi*JmcgfNEhC^Cx5+f;LvVWmdcdTer#x zpkt(r$Qv9iL73r7k|*oxZi4Z?$Ef!+}nwb~8q8@eRI@ z+3>(3jx(z6stW9UvSDpQb~2>FbMm!S30Jw~N*tueogsbo0+uG0PG@-b!cHyBRAbBv zvPv7U9ZqRJHN)be{#_t2zXCibgssxR(UT|~uSoUXnBFs*Y0KjGC8i9TT%Y~P44EzO z*ZqeP&f|a_4m8FZq)JQ;ak7mGw#g{MpP|M(O6n?%x$5h|;v=EraJW1=pXD z`=eZ7cj4{w)Mo^g@@jE5OtzAci4QtuMxwXJ3)|KEK65r~X{x_;aE%W-%rA=P-)8d$ zR)(5Fdewzo&!Pss>@U}_d}0S@Y?0=nTVHz51R9N0xJ2F;NY?0UZVWE7V0gT|Lc~L2 z_7a((NNaL>g-Xq+;PHlm-YOwjfK9wI#(3!*?{W*RfMF6y61zY$NqeiF0YQh@AgS*N z>e8@?LOChF%<%T@j&+kuLQ7@-IGRU&moTI-$})SiCq?=%<2wu+8>l;TiKnDX`w1_=lu~S)UnOtP)(YsW|I3no z5EADTM8kc1Lxr7ulKjF*)ldO)l;Zu~;!phccFGs@yTu#Y-5U>25ao>$`;S&6zMr@& z376x{tomZE46JQoD1@~G+J)8Q&ebD0gBJtmf?B-mX;eIyPuqaRAmet+WOz!LEKlb{Br0`uQb826VDWeMb5~pH6oB^_fPpCCc_u|TJ zVKlaGr#fEa%2y>nO%y0hLej~3l`#^oQwneyVdqBJZD z%zK5!{FV%vPpB79Oyt`idI}#-steW?9t;;gi46WBIxUZAJ@3rkeAU*4pDS#kQLp-I z8%47+L>+lRZE!@Jap7!qvI$Dz(uoiavzI3{l;1WMn1UYI()Mjjt+sHapiS;+YjXB4 zl3~YBoK;!B{#H+He!H&!dkVR%z;Vk_NgQz8e4*|6k}Vh-+}AMovlo3U5cygJ0oN}?%VG<& zEA#jCmIdPBtrtf6PLhv>T37?;wBO-m%{dhInIe+%1sH~edSye4GxNJ|0l!bfi6YQib|dQa-cZ`-FI@UdnSi$_U_BNB-t8wbj;1sDGr1?tox4U zC+-{DUHZ{=6F=gC{hblwur0T%E{B>|rhneXRL{Y__`!ncsWGyrfAHEw=I0FPXJ*CX zxjkhw=UNLtj?zm;m;{JlWZWC%3cv_SnS%P7FH%#$SnwtsPAPg@v>-P9{J^NOs86JYS+%aC*qkdao~eE` zDRf^b9!)i@YE(@pvs9n;5LiO(jXL?M;6^g2mjfo^ddLs)>8ih-6fOyYO2$`H6$Z8>nA7%4bzB zVW?Ua{cM#BOUL(pdsZgivNFz3Gs-8#5S!Eo<)IftO<|a|&>Rc?v9rYtepedTN zreWDb48?aBeko|Fz5bA>LJqX=yr;d`pDJ!k_uY`8yc@nVd~5XX&L@aisk(~D_n6v& zhxyKZcD?f7&uvx~t)?-&vhy8i~Ds%oeXu-5xMoBAvTmz3TQ|=8K2Y(YcL`PGYG5dPgvKHSKj# znL1&)X)*BbHr+JMwQkrwy($pP8^TtzA5o6I5QOeEp?Tq@k>%9K^e_K8u7CND=1NP) zholwv$x)MK*)J#cbfCG0DeIQPv+=^Sd;-3s08~Oe{+7zmR!*y4;01{Kx=}p0NNPV6 zedGg%(dr}}(7%~N&PP^HQz|#f9y`34vcAM@Z2g&()ROd#@UQ$CR7aftcyur?5iij* z{0K2spbux9%UMp}*6Qo+)m!$X_MvAT$JS)5;^mkhhS$UBaM<)cBjP_qwRO~~gooUu zykCsOBl(7Vt#tRE=Q5k#w9?(`6rMOr%m;&?)P_>PNhx$tqL;r#1@&xjdMIv<`ycdX zYz%ZH=%PkuQ;3$<@!_i4s+cE5_|9|Tycp2LJH#pPIP}85b(^{DU6PNy4RVdGg?8|J z$O)lw%(jfGS1r~_XW@0TA^c$;`dC{rCQ~0k~J!7Q#fglHbLPSF~@~9QIyl>KKJ5})v&(Dyv@$#o$0);(mCq@k?|#7hj47{L#*NOFpv=q{ z%B+k%?;yaLXyY&dNE_#4tGIe1PMwxB5U3}@Bzmzev)}7@*ab3R?ll5!lmgtEQuqSn zftx4DK_O)HV{Ny{CO>V(go5|D`tPktQtsjqJZ?b(aB8&?^&cP}nDV)(=7H!URZsG}jd+`(lQIQ!M?;(!VDD4uWKgWJp6dN!0a8 zO_Lx18N(#~lVkBVd%B(dJnoA~zGsa_j8|S)x!zm7(7QZfub7f5Y%O*DfCe#aRv7g5 zx(kCq`A4J&a)#dJgw&mg~2;&H-8j*Cc37Pp|aR!Pjbgs&y%qX@KkI&dK{+oJWg$UJgXOe)S)v^OUj#F z-$TL0j8}{~+BY2&5hj^?8pko=_p4K0{m7KSLI$ZQRv3IAs4Ejv-2Q*gg%r+YYd*Ow ze-~xD$?{vJF(H8{%fuffw5P%b{vLG9nS$6fXa0<7gr0GI#+7ocNG+q>%Sgf|C3fu`d+c#;F@@TPISi?;SEMcuX zQWM#9`K-dB+3XZiN*eWb*jPK8{`t3E`s+_sulsFSopCg-TW67osb_&?Puo_Xg(n0E zE8%6JHW}vk*ynYS+^+S6yP(CeuyxoxbaiTVd^^>z^$tMaI(H-zm+@0aSOW(N*lcp`v(|r}(w%;;a7R zYXSAPeYU>h$K7hBt=jWOFh(72PIP(09VBffKd4xrweiB*a}b7M69o`HN{!{Dto$j@ z!s;~v)lqZ4dLAmQw$>3Nxmrjrbo(FUy4~zJYrRFh^=)PYS_<#P3-6Th4I{wQVq_-U z%_>IyB_>;AB~5pVH@$!bqcNWpCSmtom1HhLaobTi34zd2Bev{!x&#nw?Sg|InM4yH z2MRaT{;l$T8jWWN*~)4Xc?05*0)a#mLN0wLWv=I|6|o@TRe#j+AGiSGRmKxbfdYGD$K(Lf7DF zInfh8aebN_I9=&V9n51cV?4h5`s;PP#)3py)@pFx0_yG5X804vW21)~vf*pzE2E!ZGG z<3%-igczC)h(ee>3HdDewD5_mL~4!5VS_t(LvS^-S^DuZ^7MPd=b9F{9oxFIrZalj z9h@5M3D2w7kNq!R)O`L$w55&`j2;luoOSP-7Z2g!pTt6$=X!fhL!fRrAtKV1F zs#d1dlUcR8x7y`OPfkyVkAr$b^nLRo9cTMZHoT;SCd5f&DD03YusP)~AukL}kEIf(R7Q*&5L&+Z@MH4 z9gdc5x5l^KlDE1*-0`83d6%+JYyW1-PN#Sw1ENKrDgyELcgkA_$6D3?lscGICwt3-PjfKlN7UCEiO(;7LE`f)zkG%p z+$ll8+45vVvN@&JrE}6yk;D75vq z{*w%l91z2_(ZIaOD5ws;DBR8_D0ta~sz4q~J^Sam^rrwo2Dbhx0_D2g3m+F0r7S38 zxGkQ03cTq!w5k48{^w%q>--n`7@ie%WMi)fqM_aZ!$F^-b(h&;<7p(yA#06bl&Y{q z*0QMe-bU8U08$Lv%`5Y;1))47v_1E|*A-Sz2-DPqw!(WZW(XkM=FXm}8d_TQlxMA9 ztqoAVuq}4q+zm+G)#S;V@NZvj!U_COW~0s!V8JSnoi-%iWl-0hRdS*bFD4vt+;xlx2*Cm&noZFBW1Q@Gh?}gzVkx^Zi0=B%w5*q16vVL zh5=u<02&-Edq0Zr-EBpnrXBo9MN69n9Y`$At>8b@L7x7*qA+jJmhuS2VtPfOhHeYa z#a_z@9Mm3B=6Ta_uJ%UW`W^CZ!V*P|LBfqaaRdmiCo@LiWM`GH_d*)4qM5MErsg?| zEv|}WUGlB(r1TOu#B$AYoGJ>tq9j%n`fX{5iBCKqKk-Zg%=bq!(evE784Ek(az1L| zcVx$HkX4&Y0B@oLS*Ow9^jbCF zz}x9v>K{efX}89KMpvdiNgAdmL&Xoc0VK+=AFzyoU@A)@N`LjEzxqctnmSNScRP%~ zhGtmYL4>c>3DhNwp*MOGM&fZ44;G>bPvt#SK zWL%Iih#ty%IzN@EK-P?Zv#q3bH^xCY4eYpq2GU_pxLAiVk=4?dHUkPZQx4;0)HTS3 z<7Q?UnL@(G4K}=U`O?=B$>HhC`6gI+F&(m!j0~cf3{O2 zb2p2V^{ef)9VB6Os$C`I`j0L?cfW+u$Dj^EJ1Qk}Em9IZAf?Jt4B!!ZHycBRJyxZX z0E8$*f91xBp{&rG}S+!uW40Y2PR!{5tw^Hl&XV%Tm_WxuimCA$R z$R3-8;_(;WH50IV)tE)UFy>BOms&TLzACd0=>2KCCshxaN}AEEkfFPKsVo?;E8ZfV zBdKd15<28#&RH>aZ$iB+B{&FoHn8WQlvfXxduMsOAmF$=dXDY~bQy(L`oyN+5kZ)n z+KUin=r2AA?+S%!>Qv!Q>s(1MZ`^0T61~UaM+g=AO`+s<^8iKR;Si^huWAIXVNX}6 z@KIFB;Ob7RN;QH(d0iE~(8-)(MIQ;8$Pc%-+3DQ*Ul6?9pXr||w4$RfPsr0m5Mugj z-tKaHws==BfFrh%2p^-Sa}*2}lsvrntp98nNz@eVp2Re?EOEDAZDQ#STVXzdk)7W*-t=91_YRPJ-Is{AGlkvXCXb)i$ zp}0D3%i8tzi=7}G4l|Y_4;D#N{E$G!ce23`s#l-7ZPFbVAJ7`y(@?*@B zj6p%x=StKj*58*Y{#2UG4+580Tgd@26+2t@b;b8}whBO*p-e_n)N2AZV^-YVzNj78 z!FSTCC#zm|l@F!Mi?PVIF9M?04+$Cm;Vhw+G{`Y*MTfg9G7owmV_@quJZla-U!_mM zxtH^8!~x6~9_^`Eb8CNR0+l$55=w}=#=~l_z4E|P=Jc&X>`|_t9Hg#rlmW>Yp!YF0 zv4hGZ4Ou|{POQsYKyvhg@5g4Pu}lI6efUau|5vFuNl;0Ewdl^e!cR!R9TU2ZJF<6o zsE=|)P~)Cyq10qk;L_OLY-%JRd;Izf z#d>}HFkL4wGwPi{IiVAz-SUVoDesDGHKI}v{+0)HaB}GZL2pc}Yn=WJ6z?v=4}0uh znG+`{C+SP+J6A|dC`-VUBoK`wz?gsVT2Mzn2(Bl-13zWDJZ1LYMtHQ7WE5dKWN7xn)4;Dh!M5Vo1B=P zQXl)uxr#yc3R6+sov|aEc>@Ow57cL1NL%5*HFPfo3ymOB5Re)R3l)%~W#1L?eIg)J zvhjG65fZguF~q?`!4(~(^igj1MTnM)RFg(%zIjV|g=q<4Z>3lAqq6dBWtRsy@Jx96 zqIo|ZF1BJsdJ$rV0mrIeGAV54jW+q^MXd5RE}YRGB6XY#>=VK{Inp*QFRld?aL5&(#!=?rcr>wX?yQ_GcUpgBM(6F;5 zscpon4HLKXRZb7s5SG)%;NzHDSLy$DX6%X8i8LE!PGiHJ$> ziBchJ*ImCB1ks1K!pl6M@~g~I+ei8}qP9881)x0EYYz_ofi_g(UB+bV34bL7XRQTn z?$5%#^h8Kv*Y^lWK^-!}P*|f_;6&7f*|1-mjKeCw$xHzr_yRmScRDN$h_`KXE7eUN ziQSIa>uA2pVG}6i5jErpJ{;DcCvjK{s&dlO%DtndM(as?Rg=I7d08o25!zh{#DrvT zz$~f398ee6xo`X;J2abq9Wz@8@`OP>McIs=9a+p zI;duaxo|}FIf6~0yji?6@?dMCxD>J9f)yGKeyaPt-&)tx}}n zXw?%TrNH~foL$ua0&0$gnceCW;USbftvr5J{Jz#{31)u?N4TRtyVFu}LQY-g3+#1d zIl~-Qx#bbt_WB6ool*lpl9V?Z+YecOHOjp;ie*vb7qm{x z)@1b+eFDlAxZOtqKq5Td!+hGDl%9HP8tXe!k1d9&KUUZgy8&^q#yB9>%uRlsS%AS* z{jO+)&PYytp|gQE9su0feVeQy2DfP2^6NSt^9fEVQI^*xWo==#^36modV{lxYmf4< zP66@lo=lOz;iq3C9JSY}nEO)#n1OFu5_wm4_R8U$2)T@%BhI4s~PA`w^ z^e_+Y#vbhLyOfZ9oa|w9R3}PiBUNcnjtaUOHo@{{*g6r=rBXR3K1&kX=cxeg;O5ZX zinU!|*hJ{fcT@OIk~&jK4{bkMr*C^Hte&)85#4uhV&|UB(8AnMEO*sR^*dl=uDZwS zu8QE(*x9#E@=x<;Yi0#|AmXy>?J^f3b5rP^fsi1HD7+9ayddI2TZzRA_UVqc${uOq z9|zD2Qnosy_SKX$r_Ml7%HW#Rmtp;bmdZZ(yknlb?=dg7BPs?1Q)3VG-9w;36e>b3 z@7nJ1Jr$zT;NAXeXhEahS3;!hmd66Iul!}IY^SU95U0#tP~2AouK`+Qn%IspXYSQeMrZIaid>`Gi4U-6QzLBfeOO>W|6Z zBt)=eFdT)$fn@ORT6^Z;MdS(+DLP0g^ArPH4Z+6aHIZ%u7db9473tnT&i3dm{1PNZ z-reK5huPK!SsJRCa*Gh*fz^e>mgaUikcwKlpp}9nj7S15`KHl_uZ&@X~*%{ortFS4mHem@2y>V>!!dR9*)O`9-y{-D{_BO1{ zxO%fPv}-)N>u;m|Pd4=L#M-L2Z9(7AKSqWelj-1ZZ7dNpOkDya-=g!x3=UMIx@b~U zMtV8E_eBafM$`cP(2Cfd*F!rn? z4JaE(hKN=1hGz3d(}GFre!NpseM@Q&aC7HeIhjg(TS;+ z*%QU@a2Xu@Kyifu2NKuio-(R!ZG#IFW{TE`3vm8fMz~VpBpbZXf(zmukssp=H}u2! z-g_+6;0@5isazO#qZPi0UQyqu6Vr0VVBTIiEof3n&bn+Q=sbwQh^>h9NPK8BO#ZjH zp8PLXXemWAn6-FwpIQ)5w*=jhwn$e;Z*Dn3^z^W=qsH{FFbc4#WP&DnIsYTOZ;D*4 zoIjC98F!{Dc0lN~B3LUueLhgE0@vN4?}?Mv^OjRX6mZb+<66r60H<%xsISSDc=e1& zrRo?i&b6?Wgdy1SarfX^kMhi`R!_k}n#^yZ%rBz|^TB`;6z`DV6<;=aDU zH?VmqTozdO`^j5gVJ^n356`?YEMdlk#Ki@5mq!E9>67&>&k3Ijk)zt4lU%8;IjkeE z)zhZqy`gj*sHv*a-`x?^k>62*lCp$)+NC2;18(8YxLBKBQSCRRpYFwz?yoFsYf84I zHa*1+`oUU>C*ouMUIv-44b55IaF2A@%rg`R;!Uw%8kzFoo!8jaT@Lk3nZ9hFt2{F$ z6U*iEU1UI%<%ow^e=lta(Q*;}+RxTN6vKme9ln=GFB_&jc128oZbpl~`--@}`!f_= zi`RLIO<|Zuyll+7`*~46K@(w)Cr5f z`4zuMW~NU%K0T91Gk}Nxi7A175-Mx}r9j2co`pg3jMs0W3;A{1T^09XSNw&&0m9Yl zY2Ivf7H<`jS{|;+0X?-eNl!AYAj&aRNH9VN?0(*6m(Ne+KMF9S_%D%`!B}z_n$xCcXLHHL<%GdG6$>rFZ85pE~`nx4W}DEj>z~U z>sd-S*fpdZd=-IXxIwBne%>qViPdoI-W>AHW}}b0u5qnvb5E}fBsxVu8`djyC3^Jb z*R!aMt<%}KYv5d6J;eTiWqXA~6i#>n1I)a{ZwegpIb?V+OI&AdBx+cOSzz2f&8xq= zhL!PVuvT349g~79i#S!d@SgXhG_VlpBkYPUt^L= zHZA-E-ohJB=RB!7CmzcD|7T1<|2abEfB6gsJz6SCOFR86)zVtoGsF!byXCu37&sLG zSb9vO=;duaPj%TpnLRJxUzg_`8XlNmkp0<5JvQC*3X6I&N*Lc~udnBP`EF0;M0#J<$^ zKzV6nHp+(uNc$VHc0o!Q)^}`>Yu||LYhR=HS_;I7B)B1JaOwmt=deVbWOf&}C9~md z6P=n|Gx3$(x&0#;?N~k59984CwnR!W)4wpe$4)HHDF50bZx8{hI@;oG*>WPj<<~;L zxCg>5F*ppEFfF3gBt|Y%L7nx~>Pu#X7E8oREr(71Zpn!Yc+3hW+#qpdWt{nGuC|I^ zo>L%?ilDsS!|MSDgpE_@+O63hc`D^?m$gk#=G%32kt!al1(P{Jv+NYLzjgVY7_q$R{u9rbk)04Q&RehE7Pg0P8^llxdET2n|r{3jr-Lw z8~wW{%rr@4)5!@E+#?J|40)y+33Tpi3(@Ei^~8m-n-a~5c>C=$3uk6ix)OVvSF0Jj zyzyrNeN!ZeB6UM=$Yszs=8F7Kh!cjG{6LKdU0i>NGV~Zc;x49hA?PqeI3uB`lvvD9 zCUhStN0&yf1Po_Oxn>dZ$lIG)t^Lw6gITW>HcBo&lOp40xtmE7$2QoI39$`WQYoV) zcK4?Vb_3YIQ&?w)GERBbLw>b7pw%o2yx_}Bt|y9 z{4PgdnOm<~I&qa0u13muLI(8L%P?M0YDv;8{n(pE(P=ntd(QMMzTi~zU8JM2d}eu; z3e8EN!frkLS>c^QMZoSYzC^*8$Gg&I9xoHXWDr<@&LqU@aVusLv=`pLUSIlnRJ#5s zM;6{wZ$_*1(QLO?fKoM;H+fc}cuVHMw%#nk^!sxP%K z&u~oMgo)f0`pvVU!}rx6elY52IsBdYVW4Xgqs#FoyZmJ}KQ;-(L}^fBtTE5-GEd(k zZ{MiD?=OLi+Vk1E>@jz)iRV6BVjD`E$2rr|$NHc>K0|+PPFkieqD;^;*@noIr!6YA z5>`nhPX-t?7k&7aMg%LO2v$TA*(6ofU14x&40Z!#S2S%eT%=?wA5Q zixhH7*{RQ@N7!3AJ1Z_Vi%SA5#!u`mE$|FLPM=LsM9^L!?>wGs0&^OXtjg}|-+-Q` zyVsosyZ=-*i|5x%!a?!$1a|FvXIbqBKFoo`KVr`veW0X#!c8C`{f_xOdv5FfvXp{8 zfhohxyV`o}>PE+ob@b8>4|8(QXX+0B+}r}H^l?u!iFN<9pr{)N7N1XvNLay=4mj<4 z=3W%ouBg^mPw`T9V7=ui6JzLPB(9USS)H!!E%WMcKO52=n9{0bJ+Hq|u^em(3W z{c!aRuuy2bAV@kc{e3nDKU`;bt=sFika>bjR%b6rd^LS(y3d=NH50N_Tk&^xJ^gQ^ z#nTP4WM?V&jtBajQlv|^_dPm;$GYDqaF_w7ZN9T_L8xyj{}%x+>)Cmgr!P{|7q!mV z=!A3!RkQ;T+UjdY*2mz^Z0WqPcUr{HX%q^ z)X-Pc{Ky@Osef(JP2ew^Iul$#*F}M+!c73aioZvMiR|oR4T}aT@-C$9>#Ao_2o#>= zLEvFLQf^+x)HVbb1y_dbRk?O=-8r4WgQ63NVmcs!@n9kxs}jPdF|sRI#s$72549SA zL$fnit_Owgm+gCwxHrsIAPRCN*mB zU;x3{AwMH=b(+5!ed;9wpHGGAvK3v|G}!P z;uMl1ukjiM3giD|V0_e6D`Ytb|D672T4i!-rdd!Vcdzw)d_ptXAaU+rp42Ol+(7VbWkW>1o6Lr`~ZO;gGfl zJBTpEo3RJH)C5OuJ07m++wN&5dQl&Gg@@KWV?3E;CPQYJ4j};=M?^$yD^{dfYwcxgw_B^$+O4&%T5F41wS8xr zMv6#j`BO?s0tl2+1TNsP$Y$A_-J836v;T5;*Sqd+?)Q1m1gM|;`H&%*KWEN)&-*^_ z^XK>bJ@eF4t?r(?q`-X6o1Du?_niJ`u=4B%^XY%0?Z(H z`MNs0a;ZZ4K5@{0I;$$o!hR8u&ZclHl@}yp2MYrY-*#-5QV8@S!9oO>Um}LYw%| zq&5rEGV~X&VE5kaH?o!Y{aa2N&*Z<03HNcyg|4CBW{&=Vk1>WVmCt{i7Hmi%j`A0} z+ibbA%XqM+KIcKay4sV9x5-bm%c|B!HJhlO;@K0zQ3$m4M0 zBZ-_{kk-;&Zd7z|&-h{n>)R5Rh}#W#rr;TrjY)HnDT3*(-*kzJ@stth2vkaRETs(fxYXD)Pda;)1vh3o5vDM&)JNBC0q($vsfHCbVjDwHQT7Lvi^Twa=qVKu@l?GTAxe$fPVr*9f5bKorO<7tk1E# zJ)6wwBCR%JFMv_>4}CW<^tc&pkxW~q=RJ77zzD^iLPxyn%#iCdB15Q-v_Gqjirdw# z4+r|k`MiCZzobM7}4I&62BGz z;}5zQigF<}MowH(e3rVUQN0%Srn0HK^Y?S?t!JV&o#nqzmjA9-eFi7RZBP#*pT{MW z^VS)p5dmW0Upl;4t{ckuO>C^)yo`G*6 zd;gD($m|?P$pB|6C>|9-l;PcSL-TTct0Mb!0R@1zq$=dwt`V&RzA6(WMpn$pS?CkDxSpKOZpy&118>|_C;@bMn8wSrgcW!EHVu1 z;C8jo&NzDR;F25G=m(qk-8D~B$i;crE~eh*YQA05?_F7|Hlj1TrwPMZdAC>homa#iY{oLX6M$L7z|lScD_Dz`K`XMk}g7Fyj`9hebwv6SM-L5!H~h;{tN zW}^Q9-!rwCOIaPCJvo`j)rKCr^z))?g`186=#Y{5jcxl}9yMmErr*4kmFrFQrLa2DKpl2PA;FdCEo1GP-_)j!1VI=M0+~2d+x-xfFnG|W_y53U;H}> z11Iclf07#dji4M*)T-;fu6HmueD$Kzq5N{;Mw440wcyAOVL_=^OCXA|-$jQAgpgQ~ zP)SQ;7<8G)lBtnO^z)ALw;6AOfp@fi>~r<2gX+7Mda}`-BdkQpro2%y!Dw;`vgV>1 zuZ`tnm7Bg`=QEGyaL|Kf+JVQ38u~e}d6l^;jH5LbWSjn>w=`DQjV6(L(Q4FyC=q5j z#`gH6S^B=KJCK*E^edt05=lKfLF zW*B2~9_}kvZ%f4PO|49C$Z(6J`*y`7(Ls@V*>qy_e~HEVB}07x9Z<5*#OO=~Z=X*s zt5ZckJ>YI6HLy!7rqxi?*ZmZ9iNGCL(X8GESQAyE1|@0`pILCpJPg3iwJHn08WzV7 z53g#Jj<_>$<=F^Dm}shZYbCqw;oPe?FWUXtyn4+aIn)t56pwBBZDPwf=rUK#-2Wf3 zv2VA$*ivkL;=StodVd@pPL95Cxokzq_Wt{DPw%-A6*vI6t_3#tEX_TmFwMx;)UP(l zxnyq)L4=gEX!Nw&kt|sNRsq&nCKAZERh59Sjr1a@T=TO4^LT`H;BkB){KpY@V!=G8 zN*l_WPQFO|cURpK&B7W%e=DY*iL0L^eECo2U+pVA)vuP&=O-R*116=*G7a;XuvvT` zp;qd8l*FkBs%!>y$f}?`_BGiYM`TYG>c2c^muY!25>C%cN0x}=S>Ky3W;f)xmFE6- zrz%!m!whp32n|b`Q`Ul-K=3%AWPXc$g=pY?I@L|(jB~Hb>YHwF8d~oaV-jJlHih4T za+Vp&d<~EOV^|fN)I$;VWYpv8_f(d@W#5|GAo~^O&F$DkQkW86n3c6pXqIW!uLHTk zxAI!Tba#`4j&f*ARvD$a+%;q>U>|^MrXG{7+;lXn26B~8?UZj^@o3bDRc;B|<->Yzc_WcX zI|)V@>kODKSI(G&v<{cpaQWk&SxReYiDW~az|Y6&kvY0$G+DW2FQvK;=>b)JP0F2a zvsbQI&@>{dsr}%tTyBpAnh(7ZOr>-X904l9W8JoU{dPUvmlhD)+&FYHz#8!}p~a5W z4ArdhKIKzio8!)qGm7im5@IKE2X=o)yZ+SzgEnYZQ+GgwSimn-fAgW^SGo3f5aejY zSd|Z76_o&-ua->?>(=pmYxi%RiXUB|D_7s0tXzF(+JxxJsmTpsmzI47$`FxU7yOEa zYs8UeHaaIGhvE;H8gQ%sFlv+S$?tZpXMDt)vbv=z*JUlPc3IL$cOXp~W+;+$&hvZ) zwB<9MJX3wmpSm+Qkb7d$bC74+qRU%#S_#Mv^R4YmZaQ`8=_m>tCw`~f%hXuvX6FWo z-H2D>TZ+L}&K|7|i2zay(#xg$5aklapDC^s2}^-9kd~9yPxT$k!vs^Hl^Xe_H1|c=(6X|`m_#d_A)#lRXJuGy5_A zI@&5~ih(FL$%fJ9NAO#&fS{U61_evtZIMbVHP5qAb&&1m=G6(I3`~2HepRe5y%%!<%xcKSP#Fn7j-`ARSm|Rj$1=dUt}ZWp?F5Z-X@Fro1vM5;Gzq zF$`QaVN0Ttvuuw=f)v20^?LW*jt47Dfkm^1_fw79@DeUudZtD{W8}8(%2!t3ide@y z?c}M~NZ&Hv{^;0~iLnnP%I{uW+FPuN6r$>ZgnF%&xa z;Zj1~DWU;EtMZ=DI<}Nb-eFgVd#%LeX!DF}Mn^)6rFJDOW3eirRoSku;RKYyZ#;i0?ZnwarG8osb)Q+-XeWp?IE=@K<~EwxN7H7 zY)9c)x2{lIYg-q#7CTobS2}ALkx(>1 zTR1#UvYrP$-SsyIZVNtUhR9`ctv_|UYzu1=AB3_>A1as&QV%)-pxf+7f%rpf4FQH%dG-fyupDh(q1QcU3h!4 zSu)~Sh{ru(EC;pZ-`N<5t(~m8Pb`^r^3+q_hK7dIw@O_w4@gUJ#M4H*x3cWFf*eEC zNxVHhJR zO|VEb3v?y2GQKY1P66sC=Z=-GFV?dVKJsm6?UEC8R;S$Bkf`0yG%jc?gqL0}c^}p# z@54dn;)uH*qG^Ff1rwaih>oO30KKjA;bU{srAb>9ZJdxLSddo0Eq;6!fg%u42#`cg z8Yt*>i$I6&cSimQI)c?s={G7!m>E?v8jk)-l%6m_WhNp$FhA&B5GVxKo2A_vFaT5J zWuf1_Oe2^G)laE?O-Sl0E-h^&ZkcvH;ojs?zo_-kLtC)h%42yol7`wF{Xan5N|$dt zA)rs?< zh&=-8ZePTX^hNJ%*(g|HIwv})PQmfJO1niS8n`E6(XZCP9Q) z1J;W0J&}i6pA;Yrjc|?mGP|er>_%$YX10kcE+wyNacsC7&1q@(`dH%MeFzUC{WiC>KUCUp*k4O2R$sLNDZ_Ms%e zZ6O^KmSfgbFG3x57*hU(zcTPyI?|e@7c7)?T&yHZo7!PL(vu*YRo+XU0LI8Ky+Jcr ziQN&F@Ct*D+XVb?jTYG zQuziL=Hih=#IoNeE6XZf%LP?g_>V~CLuY5xsAMwvJ`XCr(&mSpk*=)2?aR+u?`LOu zci-i#Bue{<$8wcrQZaF-EAzh1P6~XE=5?lSj82~Ln}&Ls5)IYwcG}g@PzgE@=3$~X zdsFs_+|z}h7Cn+!h-9KgC%|B=D@lryJ@ZA>Y=i)M+6eF85aC>yz!IQRqlH$)+LPGA z9p1Z6kIR(SC>OV-RH0fVu#F>^{?dTF+=`;%-CvB5bxpPEuu~lW?+dv|xYPi@CF{UF z{eD$%hB$!svXV8!p}F8H`Zv}GZNS}?r9Vqnmj2k87?S8`q|%Zi3(A^cU9;hmM87JR z)^rtj-A4f~K;I@DY`PDZUot+CZ-I!DhW_xoU1JxFt4 z#>Wn{Q;}TVN)Bj>u^ZQ&uBQ|_E6wT+h!cc998S)>5#7~ z*5M@Uu=u1wcywoOm8@ol`yxPe8YeWkjm~w+weoCdNucPGDRiFJ&iCxoLYsY4FWoxH z5}lOASn2pgveNM}2LLjjERB0s)haT3OX=;Y7j1x6z373lXOZrD9(sbeGPug053Gq; zLfc?!m_?72EI8J}ImlaiG7mO1M$m0G`ID7fBSW=W80gkK7Zyr44l$y%k znme(lXc(1i4#sl{KwbmR9u)EnNUk?qD#=PO%|SuG($bYK9m$>e_M(n_W2A}PIj2Bz zIRLK84okY!wBzDmxt7`+<>out$K~5*7cTy#6Pi%+*NQel!ow+b&TWn^iOEP};pi2Q z1)lxrAJ2X?c3-?SM(a+G-7RG)rgw;5s(k&724@%8kL3@>OPb$oRG+Vp-<*skZ_Ul` zOAnM@37Sr;N;ya16@8^w<4Y53?As93mTztHw1BBMY?y6&*3!KJCAtW%>M6@iX@%3) zfFiSw3hKe6;;h~p?iD;67SoL(DZ~lV>J_rI8I)7_0(mcocD~sqaHV`Ec13B^H)mT$IZw*JerG@}87hw#4JvyMuiA%5>>Kw)9$!>(pAG`UZE#s#jPhSSQtj8E7Qs8(Yg?yxcgoGB-V1 zDZE%vH}oRYRnLJKY$U zKJxL>>ox8NJeBk#{s%}0l`h&9ds(WV>@BzNin{qY?Ec2ZiGqX%GkS9p4;vSSO_Es{ zD_Urrm>H|p;XAv?1%k_EKRJ@NvzZ)fk^0;a6Jipws7!>FX3xaB@CoD50-zHJ`cyek4gMkt#TMk1H(Bh4p7N@+;Pw;vQd8$=*Z;ULvV zMq~=`W7qQh&BbuM%he*En+^wbBDG%faq;SN=HeDIA(Qk0A!8Z>IbGV`IN*%g#YPe1 zC+lBn9{rc*O;ORV+a0fAb3v$dF(eB)mvFPj&Ok+Xo84EoU4C6gil!O0oZ^H#)|NL7 zNeBs1?^SmVv<+>m#cw|B@9fOHJJa5aHf1c|L>rkzD}lucws|Y)EuhMlNXtN;>1dGtG*+pvbsXj`m)%_@;_iCN_IP>@)OcU(yBhGWj| zcIh2%dl1GVZo8a_kE=K-w?IU6&%zN%ly;i~;j|A%6pq7A{n8(Z`N(D?JAf9q2u9&* zS}D`QWS^ugxH=E;>GWb4=$6DJq9KKt-4D%xC4@mb0$_`(1AyL^tMpb~-drAi*nT1d ze3=(S^|EXh3Cu*(-0&9yIn;h>qxuD_aX@%=j4hqjh+8zm?WgSQX6Yq!!14^J9o3r0 zEWL2To&6ELgI31Yk$PKTS8hB2H3AM@wz8y$5zI>EEsN;V6due;kr*b?%}50S`yJB{ zWV(69o3unP5#*!T)62RdbGr??j~rS`H&hHaaSa+U8P^K1(H%K?eHSc z@O`~Iu*jQBhh^F7j2H=K?G0hoiOc1O8z#R+)mLOT2z>9%oUuKN4GMigiW#eW}1o&wFw7||wv36^751t$7f5|w!Ww<(^Z<+&= z1h^nN`09WooN+?8|G>#M?Cwl2mLTJ&B#NkltdpY{f$E=gp7X2E)vH|rqiaR(UOD}) z_8u$1;cW>|ov)byMOX|+Xa5QX__i4f!AJ@-XN>OU*;PR2+T*mP*NI;cexiT6+w=+n z@kApgQ9tj^MRLhPx|+i_OT%1dS!WV1B7${mm+2DWyb(8|Z{e04@LMt<=&`g^f5Sv_ zr2!fj&omA=-Pwue=jZHYrEk%%(AOiqujB}?f)mK0{kmRn?bc$Sgcy@%9%n?o)nw%t z*Xjv;N><`s-fS$Jrf)-2kUOM>F~-cre$Y7++`zGDhuxhvW6_>SXya5b^)sd@vd=Z4X=3)bbhT#oIw} z`sdvR9Yu}1>ywfzk_mAPxdHLscX@<3n_8Z}3n2itEgoL%B>_hSgoG0=0lQLd8?KN> zU{i?l&GwA^tSQ!-R z+ql>V*qM0p&SNlDUpjBr7hBj_)OWmzRHFU*m9{zpSOgG`?m4d)2EHd^B*bj*!~jVS zLR+xOP-)VteCR*JJKOYX)(PAl>^C>E>iClXw8>ZxMLk zEn6aOm5AtIp}a#EKt#p#H=GWUht)0QXM)RV-Y#{Wu(=wE^8HffM}R#IJH1>^dERy6*ks30E?cC!jX1@`ERu66GF z40nM(uBQEm&Dgc2VBtzd!y*QvI|Pl_$VaII-X)JMQFr#MFCwlmC-_0gZl^4ge3cGj zWr8wtAMQPqN1fTx;5Px@4l+nl=Q?r(i8Fd={Bik%2yL%4cCqBZLk`4 z-(3YgIbA_qW3vCltCA z^Tn=Mi=Ntq?Ahn2`DT%N6k{wk%A-i77+0#B>QtPQk<;7Mer7l_ z?HOtKLa;G{oCDM1XY!i#J7;N5`8)iTR?=(@Yl23wBi{|~%@Gr2ZI2VD{)|EkmBo`f ztBYJa4Qe58x$^GsdTTn5FHasH$nM-Kq5r8Gd%55W^|9HK-$;tGq|ibL>Mmkv2e;gn1{qSWJG6C*!YNkLx!xTLy7RZZh9I5V427H~2(O2>k$nZ~tiz zrdJK9mq_MLN&{=by%ET=M@fWKN1nmduz;?=)d_l6yIbWAUD8wAeDJn(J~353I-rJv zF6lAYZuKTsN}?0SEkh!tI}mE>kQ8`Y&~jqw$_O=+AWQ&OVK;%PbaZZXf786NznoWo zW^ws+(HDj3zbK|Yo9Jj&MDAZ{}#oXxFU(FkPX68v3jLv)+2R@PJxcB+;EPfZXGK*w8R>V z{dPB07M|Di9|;IYXv(q1yKc?{`q0Gmm4yzvTAT$~Cp?H0EEZZ_#O^@pyhWGJoeDkJ zgBzZj^{AKtalV&0Xp#$~n>F9%zmKjw;AQ>&7&JKfkin?@$$li#Q_pdgx(rPuD&f|- z%YW~bzjubbWHd&iy|KF!PEcshOZyoU?Rhras!Zi15efs9yhsP-W(pzG^q*tLc`fiQ z23f7OAQ~MuI`2p#W-5uX=0@90NsxF%4xvuh7!R6{G(X`SLu|h|!#umvT+_U^`mFqI zo9SktB=Sw@Sl3IZQ|ekQ{vWDgBavzCBVGax#nhDqma~l>r#T&k2VC?Qaeo;VHd^(^ za63YGS@(w3pCkak9|cM#eU3_;P{1uAs+q=MFXD zq2fAS6gT`?Js5xBhF86PKM7wPK;n8nb?{>KQ%(j7H;io!b-Y&_n;eJq1e@n8C|FC& zpP9gsw}?Qa?GrM{K2J@h<=4#6Xrw+BqA7OmFk zsPoCvc?e|weErHsY~brUeMgosQhMz2-G-q6VG>Jy2?8ygG07rN(Q4K1L8HF&p5)yF z_ks5)BJYT5iV>kyA%iWKuY=@iwac>O)M_zB%_)PAz7=#)-f&eu9BG~(OSe$Dar&uW z4B^f?CwoKqH2S;^Qx+_W)Npx)wjon zPCz+iHS5paPZi?a75w1S!L;m}5*DdX>6k?<)UeraYZ3|Ldai|1H*q$M%HD4&D_l zuZoo)P8fj&cDrO|&#`yy(6SSy=K`hYY7+UbzSPpZVAlhHO~4N6?d=E5z;o(AgHOuR zYi+g0?dsE!n?ov|&5~?q2Ec@Q-f5Y1G(=M6p}FxNpw6O`fmm&K=nCSo76{Q!)o{Ec z@pP-{N(qFjCa^(k*chP>tCG4!Cl03cMgK`Pr=h*K6Q~cTSS2{QtOr3Wu6(B-_e`?% zjNJOtGa>#F2|?$i1Ycb{R@h2H9%ms;O0Thrh6WrR>4=*1Z!oJ1bc)F$10F3sB8%mx z@-=e5N?VepEth8%i_}D{??qq6%5?N57nO!(7e32YxC58-B;ty*$aX|`878(fhOQLsIOg_)sa3$ERQo}yMB&9@t}WAU=`l37hMGbvP|G8!dOBV*iVVV9{H?{2?!T$9im?53tEQs-hF> zRc~@(Qe_83x?8kWLBM%9g|ix%f-=u0`51Iwh!z1mm`PX#Ls-e%wA(AP@nGC;j{gV- z2w`k~1G%hH7xlsYdFVx(5N$W_yp2wQb;s2c+{$ClDWdI%tJQS?)wA<_CqIr?~ zFw;ONqE)$>*gWgi{t=Ht{nA_kx3!s$8f?tYq?X_2^oDz1y(K&JrCfPOe#?%k#hmfxjTXT%#*e`>J#bVH?gIPc7`&79$L6l~dA8>v?aJH8T9e`C%U>6K}O3#U1S zSv3N(TYmM|bJgL18gD3HADo-|UbZ7U<$h4MuOXH#{%g)o@9AfH~tAu*0jw9%BUU48Mm1gJ!1eHV1xvxhJRoZc!n>RIU#0pG{xUaY>>bkwrKj ziUB&9vGZN!52W&>zQDENzX8A1)FvpqsQJwR9TZqy1H2Xi51wx*dP7f!)N@3YY=pZ( zqI{r=fAy$)=LQClzsNMLjvA5jckJOt!8#zv&sitPDp77r@JQJM^~g}te3owkP)hFO2tzGFRaOX$X`}K-N4;`7((gy+BrC*!?cDBw16y|< zWk95$dIor50*4};_0bu1noOBS{&nXveIj%l)TO#f%++>Luo#il+JXR2GTTJrwz;$i zkXl=F<->h4rMs#VmRH<1mnc68dTHjwdGN$9LejzM;?74Smi(d|>YI z!Fo^UkeM86=o&I}L*0C%QdgBO1m>g)DfQRsa$WEG+|c{-=*W)1osW@v1lm#S+vQU~ z_p2=pdm0<1K0&m>x(lfPBK;gkv4DxH{toIDXbM;PYMD3%VJnX?zuK<}l^@j-fs_f= zOr82KOU*cTb6ic&4UT;{HkOEOU7WC6C9fzj#*g{l|e{1wR~XiEZio|6e}Km&>0BR$7J{Z)grWJaLhd zo%V%&l@EO|u=xjAXTiS zOn+??3xVpbYx_)SON(Q=1v<&y@ctTmC?< zY!^M=T&;S^rw-PY=S0mSn(w8VtGd#;mRvqR$PL0exO*$D8>Nsv4xLfV+Bm;YccDU( zZm5IlV5EhSMJY^Laj?PK?X#L3Gajy?uH8ic&N1xxhN@Fmg?EaHkmK99vIvTKMB0G8DC+zt@9U0fG$FbARnltggk z{@@2Nw{*}_`x`+r`$c9kSghq>lN8xmz#OWU6SydK6FyD*3o3#1I+%g^qpQvsx4rV? zD!9?=R2Mz!ue>mJ?PgP&iTrSG=Ii;-=kFYN3LacLkTDJPnGO=f-NA;P>5#JFd1=2j zgRwfu{CI<^O11e4t@@-=s}RfV4h>%e0DP5({gNm#q!)KI7=|K+0X-DVb2$>_PG#D% z$EZPCxbXqdtdgiX*x4YwT#-{a%9H0fd6{Exi%{7_Gm4=pwmEMqlB%?{ruUM%jvKC7 zznIZ}O+MVk*)b`Q9~Y&*89*?>$d1;#TGfqNwJfIw2h>NQz`+M^?TQz*0?9Ehuct%K zWS3mtv}~y!*S6kR21}jYcFkfnObJ>#gAA0OCIGV&-YEKT)av5Qf2weN5E_#xrQ*d- z=@iREq`f%_R+vkk5&!Q5g#~w*E)>U5e?Ly`A`)$qaD#wI=!2(>hIUdO1);A?NFK#4 zoC>TWJ$tuVNd#zf6y|eO*R>A91t|?5HSPK?4CW=MG~SZ>Ho7LzL>!s#j0X=>&u+dQ zr!6e=OU84GEYAx61NDp)+1$2N8JHX)ssMP%?r%j7@*O8PQ)M^;QABMso<6>G(a}2> zzxm%eMM{^0mBd;|)rW_h4=!sicf`uSj1PY?F*nuKYxdf?onOeK_5@Gl1l z`{_`uEgyKEtN&bMZansuWfFU)Dp$Wk4;JkmGRwi=@aW3;`WkKv8rBx`QYwM`mlNb_ za&t&ORvTjIdyPT8KC2BXQMLThq5r7y+!@7}x!*$CWm6RzFM*v(Q9IpY~`V4~TF<*XT+lrFo3j+uR4C zfxZ8|v&UEC_30P#J^9RyrM+S<)qe{~Xz&VYGjF$~yhf|irTf$#Dj$s!2jXXnpL(g= zYr5F8viJBrOtKm?j91?ue)R+5APPQ>!A2=at@QxD+-Thwc}N=4K8?Mq!|~6H5la;i z@-^Ejml2#}GbKeyY6xp1ho}eM<3w5G$LItQcm=jV zx2@LWB)@5oLFa??wk7Qe@i|UA!s@P-?hVp!5UtM}`h}tc|C&vhF$7D=tc>NEp<+kL z_2CsDcYo?*x$JO!BcXe7ufHkV%4 z&dx=3h!;wx{Dh`wjd;rMx5^JRm(Ik>-?M$@=zddu%TkXutH+VWt_yXBPR(f?46lyfk)Y-= zYe59MEFL#oj;JHbp2W=uW(gI%RivzETq`{5e0QO`YIrsU+ZQQXH6>FhJZxEe9IXbUr0L9K`>b5@7LstsBVynx{_2gS#xr$m?d3mFs?g zIT()^XWnruqwlN5B?0F(OO(|moiILW*)$s`c)sVSzINx);R-DvOs zPxR5YmPA5*#sY{y0&0dHPfsNH$OG;`AwhCXBAFP=Uz*nNNRaCnATsaROSXh?!Yb`I zNmNOj3>aD_?6p|D((+%4?K{}}wTukbFDhP_m^*!QqT()wJS2NZ{G)ICx4jP+qeo9mqRSob0&DLa40xCAgNG%vhXWh+ zm1~DG+kOwWLOh5OjF>=ao9PfeOXP}nMf>bkykEVE%R0SSoeRmNhqc4nmz97lb&{wl z(OqBxu{yL7;G#>%J^eIfQm-13tEBr`1Ar{fjQjctEHEBhz84Fp)o4Nq9O!Hnm$YlU%_1vXq_ z3`+xvr$m0?b<|0Bxa%mN$-8j?e1bN~(i7Yh!ybF6Fie5$D!rU6z04_1use-20cpia zQO4I9>D+oOx%JI_l13bt280>#8b;Y#9lhDE39u>;@Cl{??HLEun+yt$IT_FadX=58 z{#B{%igj(-*<U?#rz)&8u$sp zQPQTW$9H;R;B@xV&ExC#$#mU|~Uq`JCHyinu7?121g&-wt zFnwYvFe*Zcq|Se-fGoLqDbbEEJkYmrXjSjfC$d8iaP|8)1Yo}~<{?zDxG4RoPPsKFDK1NU zCl@=4z31YvGZ^AtCW_-Db%g1#;dn@nE(dfgY4Xd4@2kA~(OE-APgo)9AoG4v{U~G< zbg6@_Y@$xBGSw{+))JjmK3N;Pfpo#r_pAYUt>0obYbwVy&Mk;R$=C}fgL*`axk~GJ ze}A*=K|c`l*8-B6F1P$VDVZ8JE8VJ>>Bu@fq4wAK+U1sHB(M?)q9_&VdO?HN!DQfy zFbYD0_=Z`mmH&usRzw+g!K{dn=k8_-#k%=CcM}31Q_X*!|45ghzG!k0m2RiWNE2g5 z01g6T`qGxgyoTOJMs(4OlKAN)<^u6Wg_qMo|70RV)EB7%sKDuZssMh5`N)*YJlMD%H@+Z!Wb zP-0cx81B%?Wa%VXrsxA0q#9W@>3*?8GQs>pC6SFl{%>k28q6F~5_X6yKcSUnQ+xBO zJ{{jfKg;+-FD=*3(=DY0|LyRzD_o7z9gw`xKkmx3W0l5ciG1IV*S)daes zWCq76`>J87qZ7#NQqLo0A&pJXBo5liv23z@W0%_5U5=%^%}+DMm?a7I<+;Jtjjag% z7vn}}Tk?jiv=f?w;X`*BQZOX7Dx&Q%87zd>QZG znb(;xd^E!TFVhuW)hx9QlbS%Ta9sWeCwdH1a8XukL~R2TB!&bM zoAx>)qDOdQVM2!T5%r{-3FwYgJAP2-Bxewcp*2eimjX%`rdLGk@(_`U#&yyJ*ryK~+`WT{>zmNf{26h-X`vv1sGMT?#J4A^kSdQ`m9>iEHnH;Ojn4T=*ar_| zpk5AX27^YQ*5?C#rn?#ZDR$b-i$1~x`Tvt5l<6t`r1tvSHlM>T*sqHs(&+1#WW9Kl zjZ;Nxdx`3u6uGO-_^wyK6~w{8^YF+&}c; z+vb)I2Cfa2=*Hp5D*0$e1-??Gl++8PQo$VO69{lVP_LE{(hJT@*J@>(oJq1C9E;y9 z4FszVesN}*4nu}}zPC+g2{-PF6v!xgeeOPl=B`rTXh;}!S|=o8OQSpXrXA{Ac=gic z8Qujyr1V{_o&WuO_SnA`4t=Gt){+MM^1-=5T3OF_08DNn=T0e7@kdpdYWCg!&ZCNs1GJDP|l zvP^x!Y3ea^%>D(4H|nUXscU~%@9m2Q7nROP7o2Il;%UzvfyWlBuhN~#*V~Y9rP#$0 zWzynOaPDtbr3t>HzE9-@kqWXfg0-ek6~$)R^}xvXc4T*7n^QxKzyw4gYuoR&Ty4+j zKliA!nbGwNwT8_J^_8m{?`~e$TuiKO{n~p?t0|9iSG9X`h(DNO+Sfb7Cgd&%E)I1>1{j-CN5X%4LY%@aD)lql_lEj%cQB|I~v&Bg0}-tmUdfLN8b+%JoT zNub2ZCi*7=pkRv?LU7l?btzR&tFQX3`;k$9TF`Om|JhNg>5{>l+lQUxjH8HQiAQr> zj{QYlvoS zY?(d!@2ER+p$S&uzNWxFtD14zG&erK_3GC71zVzMX9``UA-8cY;R8_#B}`JyXnM4e z+L(r$m9!p?sEVnl?P(*sCXbNyR}4Ud8LJ_qUe_9Q^M{asYS9hj#E{BJP_uQcU^z$`# zN9tHx&(jW>lgRaA4U&ntjPk^BYV}+^M>(rruR2`F6#aW$o0Vq-ap?54!!75{uYrm) zPW+2s{dz#%d6o5%$h?T%oR2OQ1RdUs+dlGFDImKi=`{#ZCJ0(`vz2LFM|<~}+H1ze zKA&*sWcA2$Ip07#LsKMOOD{Vf+PE)EZ}5k}6;*39ND5Zd0^;ww?PQTI_a5AST(b*J z=0F4Hj1@z1wR8sdj_k><%_A~=Tf9nB$0EsNjhC~0jyeCyWw-HEsL&F{ zC%BPlv|qxUM3c0Ao(?|}d9oShQGa_l9|?IljT6j)DhPFkre}yCh!xZEz=f*6{s!*6 zFeTK1ATjy0W8n`%ldEf~+xovC6!%)<0FX;P?(R`%$Wq~#oX1j=jwre}?-r-m;DW{M zm@#+Op-ZdBMCR`1*w`PneztY#{QIwe$Vm`68hZ|A(D3xu@BD!7&7{7PRQKTmI-2P- zp?OkZ#xKwzssq52F#kw-Hp&;|hdlB9*(YM^$8q&i!khhQcKDvcLq%`+ns6J0MlrA2 z`H;HZyhAN1Cf`WI5&$KKtiYk5i9F}&9-Sx-_eRlo{UJ$R+#L;KaC1hIt-^?^-8GD_Gu$E^jh!GbE4#j8=&a{M&Qu5 z?BRNCkD4|$sV_v-*PDk{M(gYkL9E@7T$dVpxL|lubw(v!?wX_x1t5d(fK#v2uc#IP zH5A!cRC|k&Rk3v(9~C@&N~X5dz(?ftgVH9Nju7!)CLr3f#5cHUo^AhRw!xAre~7fP zT&mn!oHRIRf=F?sW=yrgQeOzqNoJC2QP0rlvV*!A)c#7e#vb}e=flYdvjoN?K0eC6 zC-=De*E^d*jd=DxV|Is&osvD#!R^c}qkyrK%fWXg;)pXkp1NL>Ub)%w3Ubzt01TK0 zCNr}`=i>3Tblc65y0JNd(c^(<8`Rf>>L($AE@1N3BX*VXm;+bFdgOtfy5)$>c50zy zkY?|4jeU2Qn$+p7!Kh&^pj$D<$K}Poo zyl-TVmA4*ohNkc^Y6X3Pyg6vCiUI*nCwq1-5(q1&`CyNR6zW0HJ{Wf%r-ccCBq;B2 z?R%!Kf9{HUXN~E5!?W^PnJCrL7H17pgP)=iZjTFPOjK;73NcdcXGNpo5w)^5Pz?09 z6hELAGk4l#c23ewnq@N?iY#Q*Jg#;+JrojamkA*oG1Ui zmLfgJB~@VykP|f`aR!x4k>T<;Z%T9~3N3dOP{eZGV8}E%DGwJhBTT$~Ur+8sk7jmq zW691gqi>89XJ_att5yQ}Ra-rHJh^BguCnBkr3I^u_8xqX38XRDAgxB^gHp4>L3N?% znSzh5SB*I9`WHt|Mt6rQZK{7HQ1+PRt0KtwBj^=aaDBHdNu=3y3j)1cTte6jML-bt z)9P_w{KDF(gK5)}{a;iq&KlBpE7fpSHMV;fUnyw*VDVi%2;rbVS(tTZKB0&&tk0i;b5(cs$08f#3dgrGOCUrb5|LIT3o=RO_2pShd9cG`kyh)T0HX+x& zv~+A)>DWyW*6=k?*91#bsbry-I+_z*o}fhzi3SsfA9Kf<^}z(|Nj+QR>h%v=x5k=^ zR>}ptJx`c~?4mP%ZhPzB=-TI5(zAZuI7vM|H@qeK739!WAIkbQo}`tFml4v6!shsu z(_>+xQ4For+2}#nn2hvC2NRf0-mpKEGo?KBdb0F-P$asP6vhC;aan#3xdje8!?_qkBYbwz?}O2iH$rI%d2?t(E0JXKAYi2>yG$0b(5#%Lr& zgH@e6z|KntlBEN|qJSA+rjmDEF9Gdev9S;I3t44!wS_zjpj3=baKs9edq5N8D zFUKA153GpX9J?n@3{M7dj|0;_%?x02mQ8z(;4G{qIYL~eAiug1GRnGzhD@dweZ_uu z8|1?c|E-DpQz6S=1J#^V_$@X>3@N}E2 z1|4Tt5}GLRo-LC0ce{p6jc?LRc7!$NUEc8OBf%9o!S3K{s*P?}`JePVtdz%vIS!DopE%? z<(+KEsUt|hOY4#&Nl`C>b@Tz|J;~AM7fEGkQE9U{PMZk=-ta^`+g>H}*zFfzV+?g0 zaeA3j$3UvyW87aODiRg94FTPx#7)>Z9ZGqwnDIiSVz(hZLli6m0Gr*-?FkDqvt+Hf zHab|E142$SlAh(>hB?(KO;oJ;R6#)=Fqzoeb{MV)=uXY%MG<2^8T^)2iy>}=wtS7t zXMa@NuH@552J2#wZmg5${zsa}^3Cecqw1ey<#0>+TDvZ~Ci)GEz>Ir}iCMIp<2BBxmpqAHp_&gYFVY~)DL}D{iUz7) z|0lUruhy3k{Z#F?I|)9SW9nJMXb&W51c?P3k&yf#CvA}%8Bq_rTeg2YrKlu!Hx&~4 z%!MX%-pbP;9Q=uHk|y{dMFWMP1KZY6Ww!TPh_>Q+>rMN1MtEBI;I;sRo^n z^` zokX8y8xc~TKW2r{=}kL*e7?F0IilKZbgBCX)Sne==Bi@D*FtJpOb8@PyNcTTRIdj$ z(PfGt{3f<5JhHdJ#{RsDnVWQnmUB0Vcc7M&_>ojNPWZO|X^5 z{NoyS@o88)XW zvTm>Jm_D^H6p^%PEAD}IP$X&o^JMAgGHrjZuT)=eRSRa)mA2GCB%Eb#H0wGH8U$|F zM%y{O&R{$ijQFZ30hS^|Mb=t=Ld7{ce;rld6Iy@4k5v4$u#kdLUE~FkEnf?{$_l{r zcMK_Kfd?Zqh#_{VkDKaK)*pNZ)^|eP;dX7{9+B4^^kEErX$^&%rQsdKBUU`N7}#{>fdY1hdk;< zfAcq!pG&IS2ktJ`7`bRMzN$r!FXdd8!YTC@mfF; z69IE35^Uj5DKKrq5sXJ2YV;QwFt3Hue0=oC5qN(;wI!nSzPyu8!NZm8PE^z)^ zu@dW(w{<~AS&AP(Rt)URWY91!xp0o#C6EUpy=}z_!1oBFRnYUIRxt_GT);@kH5i@cmC5o)FS{Id zy}iAwv*l|RmEV`&uvkIyoUOP@^dOrx1sLi%>ep1AV^nNTfhajoC(h~hLiwwS*!G>djo=NPH2fdX zsbzv_Z%2k&(n=HrEJ+UDFS`oW%n;6IdK#i{cI{ue0?z{ z&TN&L#}93=yxN`7^AT{ZFz#_^Vszm!@??~YF?GJt!{x(I6VMB;ytkjIQ=81$m{aO= zq>0!vAjsa9PzMe32IOk`N)uH;1vO#yjMzwyFTbA-*4$Xyk$N<(Huk8mWPnfuP2j$& zbp{1jWGxrN=>?PPj z$tL9yuv5=9pcsoW4ya#PKI!v^?PZeS_vmVU$P6)NouAap=aFuhi!%YcC0v9Nqg#47 zOk9?j6d7h{42e3TQ}*Ucq=+wDGCf!#{a{b36PEq=Ms5ogVtK>G=uauJ+iZ~ZjtS^| x_RBaVu9XAoJJh>tx^;PwrgcJLAJSKG0jhblRAO6|p?yJ3p+P9*3;eQ~{|DbO(HsB( literal 0 HcmV?d00001 diff --git a/i18npool/source/breakiterator/breakiterator_unicode.cxx b/i18npool/source/breakiterator/breakiterator_unicode.cxx index 91c1d357e241..3a0f542dc8b7 100644 --- a/i18npool/source/breakiterator/breakiterator_unicode.cxx +++ b/i18npool/source/breakiterator/breakiterator_unicode.cxx @@ -123,7 +123,7 @@ void SAL_CALL BreakIterator_Unicode::loadICUBreakIterator(const css::lang::Local OUStringToOString(breakRules[breakType], RTL_TEXTENCODING_ASCII_US).getStr(), &status), status); } //use icu's breakiterator for Thai, Tibetan and Dzongkha - else if (rLocale.Language != "th" && rLocale.Language != "lo" && rLocale.Language != "bo" && rLocale.Language != "dz") + else if (rLocale.Language != "th" && rLocale.Language != "lo" && rLocale.Language != "bo" && rLocale.Language != "dz" && rLocale.Language != "km") { status = U_ZERO_ERROR; OStringBuffer aUDName(64);