From 629ffccfeaf724248b0227551199e225a8cc407c Mon Sep 17 00:00:00 2001 From: JustinAJ Date: Wed, 19 Aug 2015 23:58:27 -0400 Subject: [PATCH] Added tokenize() functions to Readable_String and various subclasses. General fixes to CString. --- Jupiter/CString.h | 60 ++++++++-- Jupiter/CString_Imp.h | 130 ++++++++++++++++------ Jupiter/Jupiter.h | 2 +- Jupiter/Readable_String.h | 59 ++++++++++ Jupiter/Readable_String_Imp.h | 193 +++++++++++++++++++++++++++++++++ Jupiter/Reference_String.h | 21 ++++ Jupiter/Reference_String_Imp.h | 32 ++++++ Jupiter/String.h | 42 +++++++ Jupiter/String_Imp.h | 66 +++++++++++ Release/Jupiter.lib | Bin 271514 -> 283594 bytes 10 files changed, 561 insertions(+), 44 deletions(-) diff --git a/Jupiter/CString.h b/Jupiter/CString.h index 2eb9cd5..78f5d5a 100644 --- a/Jupiter/CString.h +++ b/Jupiter/CString.h @@ -183,16 +183,38 @@ namespace Jupiter */ static CString_Type gotoWord(const Jupiter::Readable_String &in, size_t pos, const T *whitespace); + /** + * @brief Tokenizes a string, based on an input token separator + * + * @param separator Separator to split tokens by + * @return TokenizeResult containing the results of the tokenization process. + */ + TokenizeResult tokenize(const T &separator) const; + TokenizeResult tokenize(const Jupiter::Readable_String &separator) const; + TokenizeResult tokenize(const T *separator, size_t separator_size) const; + + /** + * @brief Tokenizes a string, based on an input token separator + * + * @param in String to split into tokens + * @param separator Separator to split tokens by + * @return TokenizeResult containing the results of the tokenization process. + */ + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const T &separator); + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const Jupiter::Readable_String &separator); + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const T *separator, size_t separator_size); + /** * @brief Copies the data from the input string to the CString. * * @param in String containing the data to be copied. * @return New size of the CString. */ - size_t set(const Readable_String &in); - size_t set(const std::basic_string &in); - size_t set(const T *in); - size_t set(const T in); + size_t set(const T *in, size_t inSize) override; + size_t set(const Jupiter::Readable_String &in) override; + size_t set(const std::basic_string &in) override; + size_t set(const T *in) override; + size_t set(const T &in) override; /** * @brief Copies the data from the input string and concatenates it to the end of CString. @@ -200,10 +222,11 @@ namespace Jupiter * @param in String containing the data to be concatenated. * @return New size of the CString. */ - size_t concat(const Readable_String &in); - size_t concat(const std::basic_string &in); - size_t concat(const T *in); - size_t concat(const T in); + size_t concat(const T *in, size_t inSize) override; + size_t concat(const Readable_String &in) override; + size_t concat(const std::basic_string &in) override; + size_t concat(const T *in) override; + size_t concat(const T &in) override; /** Default Constructor */ CString_Type(); @@ -380,6 +403,27 @@ namespace Jupiter */ static CString_Loose gotoWord(const Jupiter::Readable_String &in, size_t pos, const T *whitespace); + /** + * @brief Tokenizes a string, based on an input token separator + * + * @param separator Separator to split tokens by + * @return TokenizeResult containing the results of the tokenization process. + */ + TokenizeResult tokenize(const T &separator); + TokenizeResult tokenize(const Jupiter::Readable_String &separator); + TokenizeResult tokenize(const T *separator, size_t separator_size); + + /** + * @brief Tokenizes a string, based on an input token separator + * + * @param in String to split into tokens + * @param separator Separator to split tokens by + * @return TokenizeResult containing the results of the tokenization process. + */ + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const T &separator); + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const Jupiter::Readable_String &separator); + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const T *separator, size_t separator_size); + /** Default constructor */ CString_Loose(); diff --git a/Jupiter/CString_Imp.h b/Jupiter/CString_Imp.h index 71a3c00..36dfba2 100644 --- a/Jupiter/CString_Imp.h +++ b/Jupiter/CString_Imp.h @@ -264,6 +264,8 @@ template Jupiter::CString_Type Jupiter::CString_Type::Format(c return r; } +// substring + template Jupiter::CString_Type Jupiter::CString_Type::substring(size_t pos) const { return Jupiter::CString_Type::substring(*this, pos); @@ -306,6 +308,8 @@ template Jupiter::CString_Type Jupiter::CString_Type::substrin return r; } +// getWord + template Jupiter::CString_Type Jupiter::CString_Type::getWord(size_t pos, const T *whitespace) const { return Jupiter::CString_Type::getWord(*this, pos, whitespace); @@ -321,6 +325,8 @@ template Jupiter::CString_Type Jupiter::CString_Type::getWord( return Jupiter::Readable_String::getWord(in, pos, whitespace); } +// gotoWord + template Jupiter::CString_Type Jupiter::CString_Type::gotoWord(size_t pos, const T *whitespace) const { return Jupiter::CString_Type::gotoWord(*this, pos, whitespace); @@ -331,22 +337,54 @@ template Jupiter::CString_Type Jupiter::CString_Type::gotoWord return Jupiter::Readable_String::gotoWord(in, pos, whitespace); } -template size_t Jupiter::CString_Type::set(const Jupiter::Readable_String &in) +// tokenize + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::CString_Type::tokenize(const T &separator) const { - this->setBufferSizeNoCopy(in.size()); - for (Jupiter::String_Type::length = 0; Jupiter::String_Type::length != in.size() && in.get(Jupiter::String_Type::length) != 0; Jupiter::String_Type::length++) - Jupiter::String_Type::str[Jupiter::String_Type::length] = in.get(Jupiter::String_Type::length); - Jupiter::String_Type::str[Jupiter::String_Type::length] = 0; + return Jupiter::CString_Type::tokenize(*this, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::CString_Type::tokenize(const Jupiter::Readable_String &separator) const +{ + return Jupiter::CString_Type::tokenize(*this, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::CString_Type::tokenize(const T *separator, size_t separator_size) const +{ + return Jupiter::CString_Type::tokenize(*this, separator, separator_size); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::CString_Type::tokenize(const Jupiter::Readable_String &in, const T &token) +{ + return Jupiter::Readable_String::tokenize(in, token); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::CString_Type::tokenize(const Jupiter::Readable_String &in, const Jupiter::Readable_String &separator) +{ + return Jupiter::Readable_String::tokenize(in, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::CString_Type::tokenize(const Jupiter::Readable_String &in, const T *separator, size_t separator_size) +{ + return Jupiter::Readable_String::tokenize(in, separator, separator_size); +} + +// set + +template size_t Jupiter::CString_Type::set(const T *in, size_t in_size) +{ + Jupiter::String_Type::str[Jupiter::String_Type::set(in, in_size)] = 0; return Jupiter::String_Type::length; } +template size_t Jupiter::CString_Type::set(const Jupiter::Readable_String &in) +{ + return this->set(in.ptr(), in.size()); +} + template size_t Jupiter::CString_Type::set(const std::basic_string &in) { - this->setBufferSizeNoCopy(in.size()); - for (Jupiter::String_Type::length = 0; Jupiter::String_Type::length != in.size() && in.at(Jupiter::String_Type::length) != 0; Jupiter::String_Type::length++) - Jupiter::String_Type::str[Jupiter::String_Type::length] = in.at(Jupiter::String_Type::length); - Jupiter::String_Type::str[Jupiter::String_Type::length]; - return Jupiter::String_Type::length; + return this->set(in.data(), in.size()); } template size_t Jupiter::CString_Type::set(const T *in) @@ -355,7 +393,7 @@ template size_t Jupiter::CString_Type::set(const T *in) return Jupiter::String_Type::length; } -template size_t Jupiter::CString_Type::set(const T in) +template size_t Jupiter::CString_Type::set(const T &in) { if (in == 0) { @@ -369,34 +407,22 @@ template size_t Jupiter::CString_Type::set(const T in) return Jupiter::String_Type::length = 1; } -template size_t Jupiter::CString_Type::concat(const Jupiter::Readable_String &in) +// concat + +template size_t Jupiter::CString_Type::concat(const T *in, size_t in_size) { - size_t nSize = Jupiter::String_Type::length + in.size(); - const T *inData = in.ptr(); - this->setBufferSize(nSize); - while (Jupiter::String_Type::length != nSize && *inData != 0) - { - Jupiter::String_Type::str[Jupiter::String_Type::length] = *inData; - Jupiter::String_Type::length++; - inData++; - } - Jupiter::String_Type::str[Jupiter::String_Type::length] = 0; + Jupiter::String_Type::str[Jupiter::String_Type::concat(in, in_size)] = 0; return Jupiter::String_Type::length; } +template size_t Jupiter::CString_Type::concat(const Jupiter::Readable_String &in) +{ + return this->concat(in.ptr(), in.size()); +} + template size_t Jupiter::CString_Type::concat(const std::basic_string &in) { - size_t nSize = Jupiter::String_Type::length + in.size(); - const T *inData = in.data(); - this->setBufferSize(nSize); - while (Jupiter::String_Type::length != nSize && *inData != 0) - { - Jupiter::String_Type::str[Jupiter::String_Type::length] = *inData; - Jupiter::String_Type::length++; - inData++; - } - Jupiter::String_Type::str[Jupiter::String_Type::length] = 0; - return Jupiter::String_Type::length; + return this->concat(in.data(), in.size()); } template size_t Jupiter::CString_Type::concat(const T *in) @@ -407,15 +433,16 @@ template size_t Jupiter::CString_Type::concat(const T *in) return Jupiter::String_Type::length = nSize; } -template size_t Jupiter::CString_Type::concat(const T c) +template size_t Jupiter::CString_Type::concat(const T &in) { this->setBufferSize(Jupiter::String_Type::length + 1); - Jupiter::String_Type::str[Jupiter::String_Type::length] = c; + Jupiter::String_Type::str[Jupiter::String_Type::length] = in; Jupiter::String_Type::str[++Jupiter::String_Type::length] = 0; return Jupiter::String_Type::length; } // Operators + template inline Jupiter::CString_Type Jupiter::CString_Type::operator+(const Jupiter::CString_Type &rhs) const { return Jupiter::CString_Type::operator+(reinterpret_cast &>(rhs)); @@ -668,7 +695,40 @@ template Jupiter::CString_Loose Jupiter::CString_Loose::gotoWo return Jupiter::Readable_String::gotoWord(in, pos, whitespace); } +// tokenize + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::CString_Loose::tokenize(const T &token) +{ + return Jupiter::CString_Loose::tokenize(*this, token); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::CString_Loose::tokenize(const Jupiter::Readable_String &separator) +{ + return Jupiter::CString_Loose::tokenize(*this, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::CString_Loose::tokenize(const T *separator, size_t separator_size) +{ + return Jupiter::CString_Loose::tokenize(*this, separator, separator_size); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::CString_Loose::tokenize(const Jupiter::Readable_String &in, const T &token) +{ + return Jupiter::Readable_String::tokenize(in, token); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::CString_Loose::tokenize(const Jupiter::Readable_String &in, const Jupiter::Readable_String &separator) +{ + return Jupiter::Readable_String::tokenize(in, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::CString_Loose::tokenize(const Jupiter::Readable_String &in, const T *separator, size_t separator_size) +{ + return Jupiter::Readable_String::tokenize(in, separator, separator_size); +} + // Operators + template inline Jupiter::CString_Loose Jupiter::CString_Loose::operator+(const Jupiter::CString_Loose &rhs) const { return Jupiter::CString_Loose::operator+(reinterpret_cast &>(rhs)); diff --git a/Jupiter/Jupiter.h b/Jupiter/Jupiter.h index c878171..474c2b7 100644 --- a/Jupiter/Jupiter.h +++ b/Jupiter/Jupiter.h @@ -35,7 +35,7 @@ #define JUPITER_API #endif // _WIN32 -#define JUPITER_VERSION "Jupiter 0.16" /** Version of this program at compile time. */ +#define JUPITER_VERSION "Jupiter 0.17-dev" /** Version of this program at compile time. */ #if defined __cplusplus extern "C" diff --git a/Jupiter/Readable_String.h b/Jupiter/Readable_String.h index bb5fb0f..e13d654 100644 --- a/Jupiter/Readable_String.h +++ b/Jupiter/Readable_String.h @@ -315,6 +315,65 @@ namespace Jupiter template class R> static R gotoToken(const Jupiter::Readable_String &in, size_t pos, const T &token); template class R> static R gotoToken(const Jupiter::Readable_String &in, size_t pos, const Jupiter::Readable_String &token); + /** + * @brief Contains the results from a call to tokenize(). + */ + template class R> struct TokenizeResult + { + /** Underlying type used to represent each token */ + typedef R token_type; + + /** Array of tokens, with a length of 'token_count' */ + R *tokens; + + /** Length of 'tokens' array */ + size_t token_count; + + /** + * @brief Default constructor for the TokenizeResult class. + * Note: 'tokens' assigned nullptr, and 'token_count' is assigned 0. + */ + TokenizeResult(); + + /** + * @brief Allocation constructor for the TokenizeResult class. + */ + TokenizeResult(size_t in_token_count); + + /** + * @brief Capture constructor for the TokenizeResult class. + */ + TokenizeResult(R *in_tokens, size_t in_token_count); + + /** + * @brief Copy constructor for the TokenizeResult class. + */ + TokenizeResult(const TokenizeResult &source); + + /** + * @brief Move constructor for the TokenizeResult class. + */ + TokenizeResult(const TokenizeResult &&source); + + /** + * @brief Destructor for the TokenizeResult class. + */ + ~TokenizeResult(); + }; + + /** + * @brief Tokenizes a string, based on an input token separator + * + * @param R String type to use when constructing results + * + * @param in String to split into tokens + * @param separator Separator to split tokens by + * @return TokenizeResult containing the results of the tokenization process. + */ + template class R> static TokenizeResult tokenize(const Jupiter::Readable_String &in, const T &separator); + template class R> static TokenizeResult tokenize(const Jupiter::Readable_String &in, const Jupiter::Readable_String &separator); + template class R> static TokenizeResult tokenize(const Jupiter::Readable_String &in, const T *separator, size_t separator_size); + /** Access operator */ inline const T &operator[](size_t index) const { return this->get(index); }; diff --git a/Jupiter/Readable_String_Imp.h b/Jupiter/Readable_String_Imp.h index 29b7f1f..5b4f1f0 100644 --- a/Jupiter/Readable_String_Imp.h +++ b/Jupiter/Readable_String_Imp.h @@ -1301,6 +1301,199 @@ template template class R> R Jupiter::Readable return R(); } +/** tokenization */ + +template template class R> Jupiter::Readable_String::TokenizeResult::TokenizeResult() +{ + Jupiter::Readable_String::TokenizeResult::tokens = nullptr; + Jupiter::Readable_String::TokenizeResult::token_count = 0; +} + +template template class R> Jupiter::Readable_String::TokenizeResult::TokenizeResult(size_t in_token_count) +{ + Jupiter::Readable_String::TokenizeResult::token_count = in_token_count; + Jupiter::Readable_String::TokenizeResult::tokens = new R[Jupiter::Readable_String::TokenizeResult::token_count]; +} + +template template class R> Jupiter::Readable_String::TokenizeResult::TokenizeResult(R *in_tokens, size_t in_token_count) +{ + Jupiter::Readable_String::TokenizeResult::tokens = in_tokens; + Jupiter::Readable_String::TokenizeResult::token_count = in_token_count; +} + +template template class R> Jupiter::Readable_String::TokenizeResult::TokenizeResult(const TokenizeResult &source) +{ + Jupiter::Readable_String::TokenizeResult::tokens = new R[source.token_count]; + Jupiter::Readable_String::TokenizeResult::token_count = 0; + while (Jupiter::Readable_String::TokenizeResult::token_count != source.token_count) + { + Jupiter::Readable_String::TokenizeResult::tokens[Jupiter::Readable_String::TokenizeResult::token_count] = source.tokens[Jupiter::Readable_String::TokenizeResult::token_count]; + ++Jupiter::Readable_String::TokenizeResult::token_count; + } +} + +template template class R> Jupiter::Readable_String::TokenizeResult::TokenizeResult(const TokenizeResult &&source) +{ + Jupiter::Readable_String::TokenizeResult::tokens = source.tokens; + Jupiter::Readable_String::TokenizeResult::token_count = source.token_count; + source.tokens = nullptr; + source.token_count = 0; +} + +template template class R> Jupiter::Readable_String::TokenizeResult::~TokenizeResult() +{ + if (Jupiter::Readable_String::TokenizeResult::tokens != nullptr) + delete[] Jupiter::Readable_String::TokenizeResult::tokens; +} + +// tokenize + +template template class R> typename Jupiter::Readable_String::TokenizeResult Jupiter::Readable_String::tokenize(const Jupiter::Readable_String &in, const T &token) +{ + // special case: no input + if (in.isEmpty()) + return TokenizeResult(); + + size_t length = in.tokenCount(token); + R *tokens = new R[length]; + + // special case: only 1 token + if (length == 1) + { + *tokens = in; + return TokenizeResult(tokens, length); + } + + R *itr = tokens; + + const T *in_itr = in.ptr(); + const T *in_end = in.ptr() + in.size(); + const T *token_start = in_itr; + + while (in_itr != in_end) + { + loop_start: + if (*in_itr == token) + { + // push token to output + itr->set(token_start, in_itr - token_start); + ++itr; + + // increment over separator + ++in_itr; + + // iterator is at end of string + if (in_itr == in_end) + return TokenizeResult(tokens, length); + + // start reading new token + token_start = in_itr; + goto loop_start; + } + ++in_itr; + } + + itr->set(token_start, in_end - token_start); + return TokenizeResult(tokens, length); +} + +template template class R> typename Jupiter::Readable_String::TokenizeResult Jupiter::Readable_String::tokenize(const Jupiter::Readable_String &in, const Jupiter::Readable_String &separator) +{ + return Jupiter::Readable_String::tokenize(in, separator.ptr(), separator.size()); +} + +template template class R> typename Jupiter::Readable_String::TokenizeResult Jupiter::Readable_String::tokenize(const Jupiter::Readable_String &in, const T *separator, size_t separator_size) +{ + // special case: separator is a single element + if (separator_size == 1) + return Jupiter::Readable_String::tokenize(in, *separator); + + // special case: no input + if (in.isEmpty()) + return TokenizeResult(); + + R *tokens; + + // special case: no separator + if (separator_size == 0) + { + tokens = new R[1]; + *tokens = in; + return TokenizeResult(tokens, 1); + } + + // special case: only enough space for 1 token, or 2 empty tokens + if (separator_size >= in.size()) + { + if (in.equals(separator, separator_size)) + return TokenizeResult(2); + + tokens = new R[1]; + *tokens = in; + return TokenizeResult(tokens, 1); + } + + size_t length = in.tokenCount(separator); + tokens = new R[length]; + + // special case: only 1 token + if (length == 1) + { + *tokens = in; + return TokenizeResult(tokens, length); + } + + R *itr = tokens; + + const T *in_itr = in.ptr(); + const T *in_end = in.ptr() + in.size(); + const T *token_start = in_itr; + + auto is_separator = [](const T *sep, size_t sep_size, const T *ptr) + { + while (*sep == *ptr) + { + if (--sep_size == 0) + return true; + + ++sep, ++ptr; + } + return false; + }; + + while (in_itr + separator_size - 1 != in_end) + { + loop_start: + if (is_separator(separator, separator_size, in_itr)) + { + // push token to output + itr->set(token_start, in_itr - token_start); + ++itr; + + in_itr += separator_size; + token_start = in_itr; + + // not enough room for another separator + if (in_itr + separator_size > in_end) + break; + + // only enough room for 1 separator (empty token), or 1 token + if (in_itr + separator_size == in_end) + { + if (is_separator(separator, separator_size, in_itr)) + return TokenizeResult(tokens, length); + break; + } + + goto loop_start; + } + ++in_itr; + } + + itr->set(token_start, in_end - token_start); + return TokenizeResult(tokens, length); +} + // Jupiter::DataBuffer specialization template<> struct _Jupiter_DataBuffer_partial_specialization_impl diff --git a/Jupiter/Reference_String.h b/Jupiter/Reference_String.h index 1c6e8bd..749a87e 100644 --- a/Jupiter/Reference_String.h +++ b/Jupiter/Reference_String.h @@ -234,6 +234,27 @@ namespace Jupiter static Reference_String gotoToken(const Jupiter::Readable_String &in, size_t pos, const T &token); static Reference_String gotoToken(const Jupiter::Readable_String &in, size_t pos, const Jupiter::Readable_String &token); + /** + * @brief Tokenizes a string, based on an input token separator + * + * @param separator Separator to split tokens by + * @return TokenizeResult containing the results of the tokenization process. + */ + TokenizeResult tokenize(const T &separator) const; + TokenizeResult tokenize(const Jupiter::Readable_String &separator) const; + TokenizeResult tokenize(const T *separator, size_t separator_size) const; + + /** + * @brief Tokenizes a string, based on an input token separator + * + * @param in String to split into tokens + * @param separator Separator to split tokens by + * @return TokenizeResult containing the results of the tokenization process. + */ + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const T &separator); + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const Jupiter::Readable_String &separator); + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const T *separator, size_t separator_size); + /** Mutative operators */ inline Readable_String &operator-=(size_t right) { this->truncate(right); return *this; }; inline Readable_String &operator=(const Readable_String &right) { this->set(right); return *this; }; diff --git a/Jupiter/Reference_String_Imp.h b/Jupiter/Reference_String_Imp.h index 3cb4b21..98a8ab8 100644 --- a/Jupiter/Reference_String_Imp.h +++ b/Jupiter/Reference_String_Imp.h @@ -237,6 +237,38 @@ template Jupiter::Reference_String Jupiter::Reference_String:: template const Jupiter::Reference_String Jupiter::Reference_String::empty = Jupiter::Reference_String(); +// tokenize + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::Reference_String::tokenize(const T &separator) const +{ + return Jupiter::Reference_String::tokenize(*this, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::Reference_String::tokenize(const Jupiter::Readable_String &separator) const +{ + return Jupiter::Reference_String::tokenize(*this, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::Reference_String::tokenize(const T *separator, size_t separator_size) const +{ + return Jupiter::Reference_String::tokenize(*this, separator, separator_size); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::Reference_String::tokenize(const Jupiter::Readable_String &in, const T &token) +{ + return Jupiter::Readable_String::tokenize(in, token); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::Reference_String::tokenize(const Jupiter::Readable_String &in, const Jupiter::Readable_String &separator) +{ + return Jupiter::Readable_String::tokenize(in, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::Reference_String::tokenize(const Jupiter::Readable_String &in, const T *separator, size_t separator_size) +{ + return Jupiter::Readable_String::tokenize(in, separator, separator_size); +} + // Jupiter::DataBuffer specialization template<> struct _Jupiter_DataBuffer_partial_specialization_impl diff --git a/Jupiter/String.h b/Jupiter/String.h index e0a592a..655a38f 100644 --- a/Jupiter/String.h +++ b/Jupiter/String.h @@ -203,6 +203,27 @@ namespace Jupiter static String_Strict gotoToken(const Jupiter::Readable_String &in, size_t pos, const T &token); static String_Strict gotoToken(const Jupiter::Readable_String &in, size_t pos, const Jupiter::Readable_String &token); + /** + * @brief Tokenizes a string, based on an input token separator + * + * @param separator Separator to split tokens by + * @return TokenizeResult containing the results of the tokenization process. + */ + TokenizeResult tokenize(const T &separator) const; + TokenizeResult tokenize(const Jupiter::Readable_String &separator) const; + TokenizeResult tokenize(const T *separator, size_t separator_size) const; + + /** + * @brief Tokenizes a string, based on an input token separator + * + * @param in String to split into tokens + * @param separator Separator to split tokens by + * @return TokenizeResult containing the results of the tokenization process. + */ + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const T &separator); + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const Jupiter::Readable_String &separator); + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const T *separator, size_t separator_size); + /** Default Constructor */ String_Strict(); @@ -422,6 +443,27 @@ namespace Jupiter static String_Loose gotoToken(const Jupiter::Readable_String &in, size_t pos, const T &token); static String_Loose gotoToken(const Jupiter::Readable_String &in, size_t pos, const Jupiter::Readable_String &token); + /** + * @brief Tokenizes a string, based on an input token separator + * + * @param separator Separator to split tokens by + * @return TokenizeResult containing the results of the tokenization process. + */ + TokenizeResult tokenize(const T &separator); + TokenizeResult tokenize(const Jupiter::Readable_String &separator); + TokenizeResult tokenize(const T *separator, size_t separator_size); + + /** + * @brief Tokenizes a string, based on an input token separator + * + * @param in String to split into tokens + * @param separator Separator to split tokens by + * @return TokenizeResult containing the results of the tokenization process. + */ + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const T &separator); + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const Jupiter::Readable_String &separator); + static TokenizeResult tokenize(const Jupiter::Readable_String &in, const T *separator, size_t separator_size); + /** Default constructor */ String_Loose(); diff --git a/Jupiter/String_Imp.h b/Jupiter/String_Imp.h index 5b87dcd..fbd3d2e 100644 --- a/Jupiter/String_Imp.h +++ b/Jupiter/String_Imp.h @@ -315,7 +315,40 @@ template Jupiter::String_Strict Jupiter::String_Strict::gotoTo return Jupiter::Readable_String::gotoToken(in, pos, token); } +// tokenize + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::String_Strict::tokenize(const T &separator) const +{ + return Jupiter::String_Strict::tokenize(*this, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::String_Strict::tokenize(const Jupiter::Readable_String &separator) const +{ + return Jupiter::String_Strict::tokenize(*this, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::String_Strict::tokenize(const T *separator, size_t separator_size) const +{ + return Jupiter::String_Strict::tokenize(*this, separator, separator_size); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::String_Strict::tokenize(const Jupiter::Readable_String &in, const T &token) +{ + return Jupiter::Readable_String::tokenize(in, token); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::String_Strict::tokenize(const Jupiter::Readable_String &in, const Jupiter::Readable_String &separator) +{ + return Jupiter::Readable_String::tokenize(in, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::String_Strict::tokenize(const Jupiter::Readable_String &in, const T *separator, size_t separator_size) +{ + return Jupiter::Readable_String::tokenize(in, separator, separator_size); +} + // Operators + template inline Jupiter::String_Strict Jupiter::String_Strict::operator+(const Jupiter::String_Strict &rhs) const { return Jupiter::String_Strict::operator+(reinterpret_cast &>(rhs)); @@ -653,6 +686,7 @@ template Jupiter::String_Loose Jupiter::String_Loose::gotoToke } // Operators + template inline Jupiter::String_Loose Jupiter::String_Loose::operator+(const Jupiter::String_Loose &rhs) const { return Jupiter::String_Loose::operator+(reinterpret_cast &>(rhs)); @@ -663,6 +697,38 @@ template inline Jupiter::String_Loose Jupiter::String_Loose::o return Jupiter::operator+(*this, rhs); } +// tokenize + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::String_Loose::tokenize(const T &separator) +{ + return Jupiter::String_Loose::tokenize(*this, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::String_Loose::tokenize(const Jupiter::Readable_String &separator) +{ + return Jupiter::String_Loose::tokenize(*this, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::String_Loose::tokenize(const T *separator, size_t separator_size) +{ + return Jupiter::String_Loose::tokenize(*this, separator, separator_size); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::String_Loose::tokenize(const Jupiter::Readable_String &in, const T &separator) +{ + return Jupiter::Readable_String::tokenize(in, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::String_Loose::tokenize(const Jupiter::Readable_String &in, const Jupiter::Readable_String &separator) +{ + return Jupiter::Readable_String::tokenize(in, separator); +} + +template typename Jupiter::Readable_String::TokenizeResult Jupiter::String_Loose::tokenize(const Jupiter::Readable_String &in, const T *separator, size_t separator_size) +{ + return Jupiter::Readable_String::tokenize(in, separator, separator_size); +} + #if !defined JUPITER_STRING_STRICT_OPERATOR_PLUS #if !defined DISABLE_DEFAULT_JUPITER_STRING_OPERATOR_PLUS template static inline Jupiter::String_Loose Jupiter::operator+(const Jupiter::Readable_String &lhs, const Jupiter::Readable_String &rhs) diff --git a/Release/Jupiter.lib b/Release/Jupiter.lib index 3805a6f6ab68396656a3964022db48717e13f11a..d01bfcaecb727a71b91692e9dcc8ceb899f7232f 100644 GIT binary patch literal 283594 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%0A5X33KlC=T`W>|p(-VeB#(>PebR{RYp zynYD>_t#e<#sPkexJ_{PN)8^o88Pu@{DyW#@RNH4+=IAHa5w%<@Dunszz76R<14&FIu&5<;d9T6)Ve2XJ=~dYLk`AqidEe zizBf2`55B;>LqJN4=WE3t{!B?^_5n2{=h_ayfINN`B$%H1dMx>tM5C z3vM!MD!-`B;>rc=2s3a%+26`7-@A-&byP_-p`2Q4h z<6+)pmR0K;+EY<715&_4*g)7TN~(ERES3*k*x0zSQlAK0==`A)D{ic`$ET{TQta*F zLyO9zgF|bJb5>R>6P5MT)$*!#vsT|w8ZON%g*BI-L2*O1y}DW3u%X&q*qE)iwK|Nf z>%Hx- zw1>mCn388k*c1zbMo#PXwik z>%D5QJc^!lY-laL^DQgKg>G0_%IEE9p@>T5)mvs@UxcP^RkG%qMN3@_?TMn6jEj|- znJR+6p&|#@lxvOkvy-I~8ib)jyWo%_eP}qZR4rw)G>9tBi8)P91+1A_=%lO3Zq%~m zXVwg%2^m0ke=yM%XPS-iYO7VAtRb10tkr9+DUCy-t6Db}I%F6c^O7raH3GT5sS@o7 z(f7ui7z8MtuMq>irtzIWh)Te)E2lgnlPzj2A1AQlt#1wb3N(o`^03!H=lD64Ft7=t z{uHueBop!aGWxIIBW57%lsN;9?u!X=JEsa3U;L~a(-acGe`0I|a_w(J2Uu)J1`$t%o=R%#Mb0*^4%n&pHzqDPO7wfq^(Qfc1Wx${ax z{^Vt`)vh$#W!@nc=L|NRl`YF^t#%1xHGh0hkMTA}_#Fn}U-L#fd@#|u7{iP39iN9O z_GM>ES$k}@sarmNK9ozFShkd#3+fnlovKZ?{W;xW_M~H5D*T)|hx5!&_QPys=({0f zS#`2qN+*=FgUocr;u5o`VJf?*&tWqWSP7@Ff6Lhk|LEmpCOA6 zkCY<9!IH!!v9ObmVM=Yh-10w3tSQbJpQ<#=?PjIcZXrsv+7l&;9+m0o#(1UOz(|cg zTkxM%hfYAqZo@LJ9grvFw_P!Px!bIyY75#{MAFYgWhYwPc$*?VU_1u542)liY1v(#$U0J0k~vyrI!<9MNb_q{UuJ+i59F81r*b z7AB`$O%%B^2k>R6Lva=T7{!5uL0!VRX;OQ)$xy#mZz*1fzt( z5pMM^22Wwpx0N`%aw)Z9rJA59Zd;>mBWYHpQcPx}m~XKeeEMlm*R`X#(3>$gEKSIU zu`(w$zPegUbwC-i1M0=QZtnjp+)Mzvsl%qES`u_l4V7J zB(zFqIp|;{Id{uTP!c4NdtuQ~4%%WwtB1QS~nlcMr7D?TfN;agOj@?Qu zR!^9%Ot&n3t6OP)`L?Od3?-a1XLZ=T?UfW{z8t%1Q(Cu>l!Y*pte#eyotE8-v@f3$ zk*y6WsO+UEiGsBhL1iyR<9-(A_PuYsv2mt?1z>4O&k~H|6z|JUh*d=PvbuEzKV)o6 zk@n?Nyw6%i-}|ib74OSPWnUJ>`>dt--q*r%!Bp3yDFns!GEx=o@Rdr*LQ=#ccA77b ze`1V|8l;Rf6OFY5)lRlDf>FYFqu#F6>aEnWP^Kwmw3+FO#lbXlL4af}Yy4tyK^kYC zCac@nve4K{=urT(EKj%6tV*S{5F5q(h-HH+xsxq=vG|T0b)ALARzkPd_d6@g@^mZB zs#I!STNo{;A zB1c_kp|O?Ft@VStw$rU!X;!6D>)JxGpsp=Y<+`>+FBV60)O8jbTM6A-Kd5Uv-MW=# zRVuZvEffpt+5%OsYfJQEaV$q&XQ8o`(5>}@y0+7;TWMCMQtR46v7oLkQ02O|L@ySH zlIwbq7Grm1nQ)K6Hjz~<9@*K2p!t&C*&eAYwz4L=OE$K8s3ROZp@PO%LRYmHPMBKT zwYzUpR;5x~k%iHMR%C%Hw<1gQV)3YSpOc5lmgv~yo6gs;Tt@NbF4@@Xq586&(7>1N zuzTgp+eVs|-Be$;P%Q9e3sl*cEzxcE6{z*xm#_j*-j&6zp)CBDwui}^(R*0Q+d`aO zxgu4Osu9-^a-l=h!cMK)~sJYd#seyGtgN*#O! z>A`md&MnE25EG2OWn64+sgIY`U4>8u=O5`#DX~K~@-)O=c_D~NLK3M_o)Rleoc;J< zdL8Ct2^hs@b-ID$8*J@pi=MzY$sm3rZNX3@NGL}BhMt0`t@OwkVI;fr__asvtJW9aF0%{(79)lY+vo1)U>{y+QVpNV>K#y zXpvEF=o`7|N%FEL@6JM9Pn!(xX7C-o;^pHGRr=RtrosH%S|l zKwcVtCSzPxWFVwWTqj$6o;~GA0XhSD)g6%KcF&CKl;K1JIeCq#(-oiGnn?Z|%!0u* zd32FD!Hcr;&@|ZmEVwn2KHr;q2>qvIC(NUu0c1@WCFDY%n zZ#O2&^#;~Wj924FCCA?@l(W;*DYOv`g*ug3MNnvGYiWWN1cg?4!w)y_96!y=tGrhz zCyW-tLDmW;l{chQtd}6 zJ4V(MO0Sg?g)X6`lV2-z62GJxk7zle6@p(C-YBIOkN>V>*7S(@S-~?fq@NW$Jv)gT zQau{{N2PXt4!G4?IL*Aau@WnY^diJvQr#ToSZnbgLmZu0ahQ5Q3ME$8HdYt&y=bf) z`KPEQ|HsbTfOcc$_$oY;l{~azdJH1edRL69|3Qi za!x;>U60d==laS=~V~rE5&DAG1sMwKz3TsP0Qo$ns z45UrgH_fd?b@zXiadaq*k0u-S4a1FD+)Yp#86AlXxrP?4Fpi-6R)k-npxm;q_>d+E zT9_|U=#$QU?}`U$uox2@ZLJxWo6WFXF+*+^L0ym?wJMaCnsq2IRg@qe`S}EzXthXC zBCbOo4kUd97g^|>k(SZxh79vceM=Mr?Ia?1+yKv7mxd2VF4nbWh9@XU{4_N&SPiA%)X8}`AC{*%ZD#jzJL;+%`!B8 zokm^q%chxH?Saa=2&R^Z=p;!ktIeZG*MiPC|QP74~cBK-4ij4?Ocj7`5Dlep$Q9qSef9-vKAw$DE@?Geg-MB6>}s@ z@hvhrjkBQnXANCpq_3dqi1@yut&+FDibc4nmbq zA!8!eFP${eH6Mx*{F`QyDyD1DWKFu}!=qJ_76}HC!X*W*F1Qq@DlJN=%q$Wv+mr3l zH6L*^MUoy;9O0*Nr{Pi#FjlEG6AOpb0p(v?nVzk3+`04m>GOkbL?9RU`Cy$}U#Wx6 zt5=XSN%IX!<~7Y<^p}j&7x~$dUHn;$BqpZWjQ)~#G9y1L(nm~4B=IoKZSXFJ*@?YgcT@62xHPRCWCL*6hZ_5=q^3Rx;$dX7`D#CQ3s@zM6=_^Iv)K zsx`g^XI=V`O_q^EnshlIPc#7K<;Wg+>Qhp3pd>O=Zag4m={@F3-j_*BW1ARI+e8nU zl8%%|TiVf9!=AD9_3JcXYdzK046=MI(6TK>Mw)phDzpuId=UWTq&_EgCaH4swAYo| zYH>g}Y&I<&q?XP(^E1vPD=@QBL5g)bg-AXCgG{ArdckD8F^$_+MpiBi?_la5 z?%dCWMHLgqmkU=f95cRbRyS3f*oI=_Jd5ux&1qWGY{ICuE7P@cx?aSDQKzLO_=IIp z9+yigi$Sr9qF%2~mljUfs`S}UCJReXH&6vD`G|p7GP$OO+e7mZ<`KGj3Rft~SD&jo zjZM#PsMTeSS5`6AFjb*1>)7@qsUJrTcuRP})nBWys-nJu-!Y|L-DP+8mt9Gv%fC#Q zh*{WL;)0D&leG=nx|xTGjG)b<0ZDdI{K7(>S^+vg;1`#PYcl!zW1P(-twXl6&7g8Y zW^b6GlgXh8t+bb-au+Pn5p*xV3l{n1O9PhNW#9vr+|;}`mU77M8Ho$+2I~{U)#+-R zP7}=Rq;L&so}R~!UhvahwP)9AGzxW5t|B%EK?W^# zruIDIvD<>y?{1=)$$d=}+h4U?DurW-M83V%G@*a#Mp0AGV#gElIf|&*RM)3O3G`+) za*p>VHVk=J5=B&0jrAi@Y@MD7Z25({#xY{zt-Tqj?4{^tgOx)saBr`bU?U?QvCS+n zMnZt>)nO&*R-SKB>E%&Y^iX$`sFJ^^ClwD?qBTGMRqIL}rHRmxrk8@(N_^q&T=`p= zjnaC@poJ#l3KMblt=U9|yKhy3uoddWnePx)xyUE!^ib?JEvNAU+~>Whnk#UhXPIa^ zQer1vm%44_TGcDvYp1!oS=BJzeUmQ2Re4EH+;iF6y2R3QG@IJ(VR^0NQx9ckcjw*< z=atW_-rybP;-78?|GjrL= zmS?Xtl-in={nGX0ZAiNG*utHZ)F}@sw+3woPIBLL)idj1%aX<^nVX0|K+Z#&S)REm zS?3!o0RDd!(P-uzI4MXjh$Ew=*}Z?382)+eSsbm|Enll*;AA7Nra4 zK;&DR?Fh5VlJd=r!uSlL6;0ruYCe#M)UI^0ysYJm(uNm38|^QVgx4L511)TVHmm|N zK7L(Uovb#ib)3N?gq5V+mu9+^C{ANlI|3`-(!oR0oOYT3iONcfA)$zl{?o)Jv9Z-7 zvZp8Am=G#xY$YU2Z&(yCN-d9763GoC{TNO9AWcezrQu49k?f_t75;yr%*OeKZB%T{ ztiv{utOn<8UERKP+xn)EtC@s|87keyljb2}>?B8jJ~a5hQ+g@4v8?spmYrvR|5qgE za{1mCKJa^agqq}b784a&$d$3SEunb;6pW~(X_M}mTI)zPlXKD{NlRO{J=9ZblD3YK zt|f10(iB8enL{^&gNDPAoYe9hMv~O@GUU<5mTOimsp&>4${!folrf-|$K*+LVU3uk z2eMG-k(%D@!^r?!UCcafHB7JFJod8X+B+>}PqMRPx{jj7cV;@0DkWeRxMdK@a}g_} z^dzaFQyYfq_QcjQ<&uVxO`eQM5*ne-B{fG`WwB!3g|9VC(iHOr;;gFfE?)8-feued z9U=EZ9zX0MU6Rrf*eNGSimj>IWP4e4(xyCeO=TqGmp`S{4>s{oNh=eyMt>S4(TUD@(UpbY%s_`{_2Yyp`g&3F$&H zns`+A`5=(+-DbU9)&!M})2Y3b$E}<$DP~Vw5=;J43TgjeteJh>lsVZZ>(9JtZlBgdRV_bV;R)1m2L={bNdG(uEw3# z#&acV?4?Pki0tRIB|y()i`waeYzZj;=NI%Q#TG=lb<$ZwSxBfh()kZ9S`uz_%|H>< zwFq#DMNpzDM38~3$pSgTNlPh$h7A!-K8eKFpa%>y>L!h`vgyFb!9EE;|95E1SfweB z?@2L;=>#i{L3+tKu#7mZxW_uCIYDBX1I^Ny1UVg!oER`I4%8U2XKZun8TYVE`UHMP z$2z4E8XKAtO}gb&oTyGyxUgxgh?GX9q+v-9IcC&uB)1lvl6If<*cLtHm{B{~7TL5A zw(x5)*-POOQj5q!64Y!ef1}5R6Rx&$lUN1TP19#22wN1jBzN;ooS8hA+_30*#Pa!o zxrtpyB$>0oMIM)iWiWq#iBe7V+@W6ZqWJEsB##j_NAuW>4b5aECo(3~BOA&eIUcQR zRzbfejj_7XhXP_(tVo~80IeH+x@OfG&FHj0Y5s}f z+ORdW$m+0gy5^yKW|B_)_ArA+$tPI*GftsK`B_Q&(3#i$na} z%Z+9u!|}ZpZgHa4N@HoXnS7Rb*L-X=$taMc7gLHSXG1oq#Ti_HT4`=sQmIc&n-e^# zTI~snNH$uP4LG!$9|dZR%ccxSj?2AZWv!1n^n^);twM>sFe_i57;Us` zOIq62EgP=Ka#34dE7BF8;tb}RgDj*QlXT6eJ554I=}HlrpE#~jtM|epUGwQqlh7hv zDMA*(hpEBYc4K8~_o05wvZpE5S{BH3F;Un-Wg(H~WBiX6y2g*MWya1bv}QQ9lb@BO z4~^&aA;5TKe7}6=W~feXPLehzO)vrsnuPs*Ndbj6tSF~Nrt!?Kp)@rdTFA0=!Iu(W zfB$Qy-eaV-H=&$V3Mvl`y;BkWQGhLaz&F`5gWiN=Njnnm?P#$zE=HD&OGvI1-s5A_QbiphsWgg&;p%i{i@s4Jk1>cyCn6cEs!d!!F-G^R8zRJ^N(t=nL(ZMgKnCu{ zIINM{4X;q6T&aylo4kBP%~q!Cd6G3nkCoN@Tu6(~C#bIKrW-D#g;=q%yfJ~Lid`wv zC8JQ6-YAlf3u%FQaDI((SJvo)3F)wqUltPF@Y9thU9&2#sFQnWy<>S&RwCce-4zdL zaQJLZA0m@A2vdS?SU~<^SZUh6dZSBMT&QlQDqXkKE_gtLMa?FzYs>5&a)sn)LG>`Zv5IYjMh(ng zY-JU?;sPyJR!%f(U`)Mb1@bZ=*})XAKjt$kB7aNEN(MQ@$=?mB1%_#}EjsujZ!vz~ zj54*r#d695hnur>wS*@N%i2cz$;KsEQH&ymPq3#&v*F`#FGN@yiCzm!7D|l9BCUWe`N1aP5 z;+^UpIb?TuL_O6wU!L7fbFq^AA{TwkC311esfFZEUFjk5kvzn%BwDAmC(SOe<4Qr1 zJML&HwZi~bk6uNKwN$2%n2w6FXpkshh_s(XECUy*JJ3qOdz44IbGNfQKcP%^=;*01 zIW^m?;%enpjq&4g7EgzHG^I*I1TPCNW)zgskeBg#)82w@O90CoP(>YDXL$ZK+@x#L z@dCcDVH*o~5p_FD4pPVyO~6Vh-#|%epS)1L3l1IW`m|Y8kG`nJh8wu9Y9dGqE{yK@ zVSpKLZ8o^5c^$_%vlKKFAGz^r1@YE9H})#px{?vfzBS6@jhQXY+J>pN|B1Bof^I*@ zY*O&$)c{pv z2<`Y3dJlE$5kF|A%&7NJ!yfa6rv7|;4|VJrN2+0(&F`UZJ>mz=#1ws3s>$)BH|(fB z{n>vT%}iec)J&si9HAXe>f2~$OhROv^@17c6#ZIYqhQLH18WwLFMUO@A(JhTofPtd zF9unKWu(K|u8rC0iIvrjjZM{9rDKF5FN3$jh3-QYFr2EireX|{FPBHvTCqXq^>1P* ztvw_+Nka4Yw`puDF=_KXa0VQ{3WyIP!ZE~=gBSw%_!uqdGjsX69$M9un@73^>gwKP zNqkN3WV2e0qZxNa%0TtLTlGc(}prMcH@NlkmXa{4lnBA z(TNJfdvX5f;j`7*YG^C4GZsvZM-=}+LK(bsg?tMuJD4Xs$MoA_V?VqMr;Qt@Dk zxGwUHxZySCiIV9IuQBr#r!!4hTVs|F)Xf9WA1blV#8H#?X@k?#L9Y;EL*@l_=H?Sxubu~x6OSFKuB z(xXI@MmuD_OWD8>=3IhqSL(<4CL+Cb37O6y*p$FCEN(htai&^5-ilW`VrQSfu>@#X zL&Jym9U3;QaeuLq4GHzM3#-j`ZL&6A!D>)F4XVl1=gK3?p782{M$*#I?o}dYq|@?h zd#W*!V4x!g7S+d_TV`lItB;H;zQbziiU&onWDV$MNWBW7?{>$8bXZuMnW{GVeiehO zU{l%9up-i)rZ_&`XjT0_s%P6pct8Y+BC+QNCkcn zTErS3J%&+XiC+p9;=G;<^&8U4h|Y2YE9`Wxel5y5d8#HdO`-%Tz9%u|W3?oNuvSvA zkeM3oA`(=MDRYpZFO94~;JxVhbhT2Sohe0Mt{Rl*TvD)jU!1~%dSDX@wf|+6R$I($ z##NE#MJzC>$F0^dkrZVFzmzzoVDWx?akH^8#)fz9gKLl%V&m;(L*7wKUAQ%kpBY4I zg}8^#BXR;g3eN_trTMLp5(8@*Ki|-cml$eIghKFqim%nwRfRH%LCI7KW-2$S?WVEg z?U#^NH?+!+4N3JIQ`DY_>uiZ0Q9lC}ml7)nxqD3Y1S~Tb!<3AggHSIR@f6Y^iB>OB zN}hcm6Pb2|xrBz^y;^Aw%}(OBES(Zczn+T8qfukLGTqtA8!gwW!DuG3%nF}4o18q# zF&U3IiSn+hour9$(Mt-_aZwkE9BHaZ9sSs$hkUg)V_=$u8qx zTFIDQQ+JgoVG$Q{7aNU|@d8eK=e0&BV|xla4PTc$9Jp<#(b8)54SX4pMguu9AUCu@ z=U(6=#%&b+9z(8}j!Zo1h=K;ry@;tvEDuwLNU5mAZxwY3_B^f7i7$4+XW?sw-Wean z1EXnVkbqgNw;Q@N5LYwD?|hqwEj9ANuDNKr#QCwR<5yZcl4O8wxw_vPy9iCd-M^+DVjC=9mGK z1x84z7b1cY8eT<1JCZM1Kl~$lJX~f{{?#^t3Lm$m;Xqh6`jVT4jLNmDUBPLb2~>(K zIEggpn3p`0J);scs;bVk#XB4&7nkPb^qBtaTKuJHUM&$bobxuJX=l3=kyCi;9j7yq zu4Nseq1qd3HrkEx#&oPT&|zar=9h*^-1s3{(RLN%l!Qe&jad?AQq_YoQ&D*?w`E2% zl8N!stL38+pW$k2yjern86OMc($t7%7RY3=B(!J^q~p^3YrN*wnOFULn!Aj=q1je- z6qSf$;Gmgg)Jl@@44kCSMz07V7-&OJ)|1kl66Q1Cb2cl6Nv3(3L|8eCXuDdQL8=43PJrR;V6!fg4mfs*BdUu zH4+%ds8D`Af4^2GQ*}Og*bC7^fZ6piY_IQ-voIgVXx{RqN)ifEaavMCQ}}!*eKIFIWPd?wgq8XsLaayCqo6yBzfgKJ z{cCc2)h8&#Sj*Ei7L z*FRtVz0d#Wg82vb4e-B@-TrSbV`qKZW!HSxWshItvYnQB>@0%AJhmfXr&0V(upIve ztUI8<9v&#LtKU&zO90Jx7T9h0?b6qI?55j2cFyNL_RMAYd!fh9{JG13VZ*wvuD4)5#FxNL3JV@po+*vj{KY{8BNHsuu9y-#^;{zmAq zLxCOhpvUg~CGd~*SRdfxbspR2r;v4z$4>f*#~!=eV`F&#-2IUAEtjnZ+;gMLj)lx+ z6CN9Vd4Zh^y-Sz6Z1Z}^|EkMQeo29`mw-QDw=bZ4SGerxFS_i)D_yobU?2Ruv{!-c z@J8qYXuqkzJ~OAlhW9S8bH3@ZIX8OjiEBJ|%2%PwwSZT^rhvt-#QRqj*kgFk*`>g4 zoP#>}y31}@?6K1h_1I-Ikbi>5hG2)&f9A2L?)BIqfE!<5U@P}5u!jIwyrIA*<`vk{ zKS0?4_3wM^S-?KWd+hw}1blHy2;nF;!gG7n$E(2~|9%|L1+M|k zt{yvPH~jsi%P#+u%kIW=&!=2={-0fT5$u1?Z(VlOqo|k5U3Mw-So+!myJoinyB*J^ zyBFB#?>u(xqaM2p&y|mPY|~u$@Au$Gw|eY0JhvNypPdRB|BCVfo`BEY{%x171T4AP zWv9Y7?*FFCj)7mShaX@18<(B(JC{8GnRCA6vVH#mT^@JYE?2v3X{o^KhZfk~3k&R` zMFqCwP=Vcm-yX(qyDf$;!v%IKe!II^U{B-U`vK=z;GRENV8`LNGw|E>z}X6%{qfsV z2Nu}g2f+sc_bn)}o0h|;0q2eu*hx!K&ch09&t>3`zi&Pq{PFKTynAL0K7fDkjNjL< z!oOD**xC4PKfpQodw;;OD+=sc;NFbq{E-4X>k#k)T=_2ij_1YrZ884d3jU`7&VVj^ z0&e>#>hOc8+YiA%&qlldH;?W25sz*E8IPU21-6`pkDlqV^=EkOpijXsF7nva{{SD) z8}aYOfAH8*Pk8J;JTHG7zV{sJ=5_FQ)YV!%Z$lmJ{xEzMupfMW;sKXkhk7{ZJ1%<| zboUnEoBsg)w>`E${B+tg8Dcaq0;-UMF)?D-!a zyB=`+gDxBRp3ANUth^1+7o&|{1OJEKm;4L(L++K3x%d{BZAGj(@9!>aBWRwn(qpe2 zgO9!ux;+K_z5+Y_7R0_Edh8+i=|#K4E`W)>;9IXpn*!W1f%b@4a^}tjcF-KOq1SqB z9^&TK<2`ol&s?_aWiET~=iq0EGj~)sB%_b;%0 zq5pQ@Kzsl^dIRbXaN$kR5B9BJigx-rw8_h06FirF4R!&vcP+5OYv4L4HE4fFJ>jzXe?)8m z%t4H}V5`fXL#*E6#i;+67T8hSfj6FeychB5!ybG3YUq0|>f{2Co&81F`C*r>yB9Xy z4(;@E^gmakfBG`~7I-`1dC-?Uw#OHsC*YKGJobq){P~YjzP}e7->@P&D`ERtd z4?yO}(06${`em0rhTnI3)@661 zJ&%6ZWjmui-})=iJ%reT9OWSJzXbitZ4TP5i?T83dzZ`Z103{gmt8Txz;0PmU{9d` zSb7xN_C2uAyU<^tj0>RevR{&WTW>7MsMFXVU+GnDHj=m&qh^)%Sz!>Efb;D_J)(1tI4 z5ppQNUWXvA{RsR4Gk1FImIvUcfP4Rpas#e<67T?42!*av=o(d7WNi-XZ$TnC$6i?*>8KD70RE_?P4#AH0D?}R=70iQ$JpMgE^ zg)QnozSz_}cDc@Q|q{m5kx0j>w`y?deUqJ9p6pRI+T%^=ry0SDiT-%(#nkmp?q zKfL3|=&$Z}+06{~hQIIm34Hz@Jn`FF{5|?cv@QI5;-~0O0E^+z`yjsk;025w#;VSQ zGw#ed4X5s0#SUj*WNX<g?x?I7^*F+@ib5 zJ=Oh?JLn8K3!VRP&vpOPJfYqs@2qz=IzMsV>b{!Ib8lq}*;`QheVrxF3GS@>LAT_b;|{t% za);c*+~2!@bHC;M+_|0gy9?Ya*_YTI><8=scfdW!eTVxab|<^i`I2*$^JV8N&ehK6 z*=6i{INs>@(~Vb}9Q`_C@D&Y>Iu%+0#AJt-5b;k8)kiG$GER|*SUMRN4T$bSG%uqSGv2qYuq=wN4tBwW%qUNT6Z^hmHTG*Sa%<{;!e7I zx&P!I?taYus#|lWoVL?)e(BuE9&}D|cVTxsKX!iT-02+0j%RzbIqXerFZM?EBKAVG zn-{Q`u{_svOhZi;@;+d&;1wnE_N_`C)<;~ zfxVvX&mMMu?cC-3$oYYDhtqQZ;5^|hV;h{NGnY*|Cpc~Q{p=L>&+NVIee7iR9#(Ot zodelN*ct30=U2{KoN2a^-RvIcPP@mu$2*&xU7UlRcRAa+-*#_tuX11IywkbD?Ps5N z|KTv#alh{T)cL#fobyq4SNAgaCGMT>%bWw8Z?T=6`OZ9crTZoKdgor}70x@HU7f|w zq0XzF|8{R;-)5h4U+wPfEO2&o2Ar2W2Rb{r|K{HA9O4w6SGqSi_c`;NerL+9xefP= z?yKBg+;2MDyWe+T;l9*;nY*L=e)qM`?#^z`Yn<0PFL!r#cXD6p9OQh*{fzTj=YO3` zoR2tXIA=Ql;=GEzlHKgw?%w8n-+6)iLia}JJC5sq&ndW`d#iJc^Ihi~&d;1hPMICc zD(q6{U!Aj@PdXPm7dijqe9$@7InDWy^KNzw`;>FB^J(Y9&go8{bAkI|_gQBT_E+Z_ z=TY|t_6_z;R(ChLTi8kL73@T|nf=Lm(z(w4ntQGL7w2i`4EG}Uf80Ta9bfDaw$(X- z&9DZmv;ElH*gov7?9J@$?0Wa>?hreOy@UPEdBl0t`K|Mq^JZrs=M(PZ&PUt}-A}r| za6aIEja|#GV_#=`JI6V*&KsOPoIRb_J8yH|>;BGtpZhKMM)xN7o9+$nH{AK`MegbD zCGKb4|8+m*UhF>Q{Mq@m`x*Cg=L^nW&fA^8IbU|a;2yv(cmLHr)BT})mbvwn zA9w!Sxxo2^^UuzEo%cEKcTRCW;9So(vEMlFaewPR;=Yvaz+TQCc3^{a` z#&%?nvfr^^yF0OecDJ}Exi5BJ=)AxwI4^P@V!vQNX7{p3*ss`6+5PM{>_PSu_H*=1 zzhw8Y``EA91MF`0Gxi(TbGCEfy#GJ;{y!Rf*EnV82xqNxtg|!Qoh@ZYI!8I1-P7EA z-Sgd_y6c>W+^5_z=NRYzy%@d138M6ZajW3>v;rU&SUsr*%Rzf?9c3vY%6<-v%T{;`#pP# z{edC4JFfG0_AL7gdzwAT{=uGOe`C+EtoRW=M$RvY|1?(30L)m6inS=q;pGrpEY@6E^3e$Gah@tpohlg&yU_?@7$bXL_jGLZ)IXro1C{dBb~JQ{Vqo6NzM->mza8+DUz5g0cFsdKBjf^!uS(Iz>9( z6cDiZ+RX$cU43-O8XGrOuunA3IN+;85N(z3hcwBhmM7g0lYCK)a+ORns$v^QVNosbhffz59^oqR?2 zUQou*4fBoJ<&jCKa*Oi%9+-xi)IJkwMHzvD`z$mou;mj!gu+R9K7*hWGIRAE*^D5o zrC-8oT6W#hGLcML>6J#H=xSiH7MR)X?+JRXfN~BW+hF*k$bEOox!dBBm}Z>4ZU$ zrFR_32TlnV=rA;)CA2^^w1saH$zlOVqEiD-_(Icuq?awkH#`3`x^$=gs5b`M4%Wp& zT`6-?*(52aG^P|jM)gyfB+RvRWOhGif>Ngn8s4}%;l^@I_pa@Cx4Z_$k zTu+oum(*#K>8SA%MCYUtN;~>XRpzr!!q(S(5HGA4bUS+#R*X^6sIiQQ9aAL*hQL~} zo8b(}4mYiQJ0NyL#qy?rshqB7zc?A3lhUr>vSnrdMo_3Z6W4}M$_P|3GUk|?lq~K$ zq(m$`i=*ihvN)D?ZYB(^-17&6Xl5JYGU8cV9LF#R5l2kQ<%Eu+mi;NO0prkIuvWV+ zfvic_Ivy0kkB??`Z0#AwlEIE(x!Z^jBI9<_q=+3}Y9T}ynLOSSmc^BlTn+zjNz}iw zdktho+wlTjQ0t6+aL5C{Q6q?xcG%tb3Knuin6p3(!rVJDmDCQq`;uD75hb-i3`#nv zjIk5CawRRtlW+-PpZ z9hBx?f*);(Z^h8;D11ln;2VQ>grIZDs&1^de9(B6Mt`Y~FNo;SM@JQy+l<{H4foL* z#lPIy@`63OLlDV%DTl(o#=W~}6^Tnbk0LZ5(6j4BiIabeipeIFYlK)fRV6f(Zg@;) zEg{--7iaUE7#o~LEGp^M4XCh+e_?TEH3I+d<%P%mUgzwZh|22OrO^DQ@a$Ry2I=8N z4SABe$WOR54gJOmljF_c@<8)ZHW;%bUoo_BSyFn2~u-BxId4 z-07x5B$b2BW@Ss3uZKZW7oT_(ZSi?v%hTW(-{|~KXF4IA2=aA}Vj2{UqGe$is2EIR zC4F%iF*w=)|Du3$>X(2R?=0>Vhpstmt!~)pux`XKI_W5pe2XP{&+2Av!vn8Ap zFBhBm1Z@sZ(hBFyTEIj)8v1@We_#TA)r7RZ8MmndAKto%{38vAhYAytIKe-OO?bw? zF9};m;@Yf(Hr(@sATy4nO&lqzjRAw-*U|L*RC+84uS^8 z%Ds&7PE+7CHqKOk>Yy4VmoUPC~Oo^PLg8h&sGEir9ZYV}rXy;A?{7i?xrx!vG_ zQ}gAYu62-iR*W~S(RpLcf-eY~Ra}Kzo(R?#!~;4H&ouEC3(sRi@hCrT&oAB*Xc{sv zOE^vf@f0@IA=`+TPGotC%_pkUR#{MDCT7coR|1f2QW|q^K~2V%i7e4F4>6XMyR`!C`2XUEYb-IdcuXBvs6j=sNSyZl@Y9H}$ z9XT`HqcUw1R{j3c8s87Y8SsPtG7Cx9{iU@qzrPgtHH&^oF_;YjZ~VvvyV*%z-8_R$ zmVCM(kNXW`ILBL>iH(KtsXY9y*U)N4c#NE+TeQ;>HVnM@#bZTV?7*D}pQ}we=<^)h z2PutVjX{{&OTcYKa}YB#W|n*ohl{0QaWc#4+13>2q+3&k&CM=EThZ&F3Hs}NagOiHSNSV0>4(02xurXUVj8Vf< zDY&AECCywW5^A;%V)-oZ8^f}U)F-N#r_|$`{oHS9zPdCWY~o?GX~#UZnW<`%voI{h zmK_9(4<>6H0#`KXZInrQ0m{xhs_1S!q^;-{0*vZpWpT-j*q5E=QcR`$_x`|1DDd4dLqjLRB2({xyeoZ`oms3*>cCMARX_^MJ91vJE!c5-; z4NL|CCL@R`x=JxMT~rEPZAgV7(xfUevFI-a9I!V;E8L(o--UzDK4|$wZn?e0=${=! zfYCy_R;x9;(Vl4#3_&acq0W@1uV^r(Z^>nqR$HtuiUyTcgF%Q`R;yP__N^|k5s`_W zBSsr2zYOPbO?R9ru0a^pmNhnTE{14ksJ8yV*OoPKGMLUn<~0+2O9K-TZIZW{c=VTK z7Jd-aDY3$!KB{Sjq=ZEnHF4@M$&8HFD4U7`P0Dg%IEN&g7&#%U3K%V~Y>uvIXqo!r zz!#TS+f$7Rst(;5C$upCh=E1*@#dBpI;6(O#+Lv;#)|GfIWI9(MyI(3{k`E79AkU$ zI3qFWH25SV2F-+4M%D8qDnY3O`d-BTjxy0*b8J^XR*G+nTg>|$IuXUwm{(V4&K z&Y!l5t-K3olEef_ayl4fo*Y-x0|)PIdObu*j)rU|<*NkZS!RYo)D?vKLAj)XDc*PH z3~l)+axJx<+dt5mO&}7#u9B-F=+YzteJN!`f0{6vvuVOWtn~CNqq_-5QaYJ~TsMC3 z>JSZWq4oEC=#erpY*iGSMGQlWh7Ivhv5F-t*-3c*MMX$M&Mzp$-`wlG#klJZ8PK$5w!_!h(%7n4DWbFc|t zaj7e<)v@I)n!M49PwE5c<*HT7Op}ViGTd5gaJJp(jL(f@bHTG!t^m6%)`@BsWa68h zkbYdFR!{8G@qx%-A^)R&R~*PX$JeH(OYwu3gnsyVHW8iuC*2J?iP-`Zku+yRf{kcm zEJ&}DXVwf#hSuXh$8dbW_*CjLC|+y~#z^@L6kV^Ato#I`9AtMVkFYnRrbxRJn;i9p!2F_TR~27Do)S=(4? zZdrl_qSG|;(G6At%hBX_YAh1F6UB|74vqcpNLCLetk+so znlfs3bp(W2c7n{b8+BdWqaAy^sCciBaZ)%7aIu=!+)CjhoFR}h><*f-N9XL(6eh%K zE57S;|JWd6-6Kars`HROM@YgSEZv7u%HyPC)% zQOL}{V|)`Q8ZG(c+KLzNH#SgnId6gbUv*q6BcMSrZ-jTqawQSSTkRR5!x`^mJ;P!eX>y!3-5rNPUY`Y zvBQ-lNNROH565Q=qI%_{^6QwFCPkQEoEBg3Wb9Zu!xo)XV2C*8DFiA3r-b)t)>QF) zyrTpJL~TML+2C3tFbU?75KB~kxY53kiZ!i!mYF2sbPTjyj1;rmiMM&uHQ{(E>Ua#c z@aJlX!RkiLh@!ZXH%hj#ME6T5#tjJ{+=KqP%dKuLzN;r`ViLv(5=cVM6qK;u(6=|H z?Gi4WGsftSx!V?#cBnO;WkJngS4ymgP@3|n*i}Mkh7BQnBq}z_b+F7^LVz9AnzVaF z)4&jQ0>p*YX1g|7!#%dhj-WhZ8mrNJdRwvGiLC@EwNzTDBZdX%pExu5+X4hl- zi|+om`RvZyR3-}HJr*SCAGB?4d+fKH|F$f^>lze^y!aTxJ%t z8k|Yh(5{eCA69utrR<^1xc6=gseyrK>-x_~{79t}u}a!9(E>lp98YZ4+SSz!Yy>y1 z5i(6K@J}3Nzn*CIP4Ibw$v^U(F#gME11s+<8(ZNU%$#-(xYhq!j$w;aVMFY3+VIaM zN~n|dO>;vO`d20VC)SA%L9p^ec(Ww8W%#bvQgOw<=MO|N<`2lK)>^~Waja6AmeH0} zH;4bEm4Z>NH`eMTZ2kakUj)j7x?FA@G9VWrO)|q$=dU)FM1<0j=rx7|&Ylmuaa| zxRB{-1K03{hDq$F*{HI!CT+tP8Yc0dVhYcOibd=oz0vWJe``0|m6!)^fbk&}MubZow%SV9rGW9&{3(Dv9*LQV%rlqnX zAFxM`IE|Qu@2WXxn#VUde^wr<=L%{|r`LH@CI+f(`fNof4wOavz=aQ;446D#CoO5v zWNsyCRCy$EH;tDd+N3Q+OW#(qQpY?v?Q@hNjQ9bH9_r!E83UM+k6)kq*gzv1sTHO( z=~;A06O~XkiKOv*5j_C^2pVy7U0_e@+Y?OLU&69CI^ae&s9_zCXkL8&vSa%MR9($Q zh+{iSv~4)P@dRjcT;PjuOq!6f*7QY-m`E}>l#xJVLoPtw`y;A>SS!{xU`7k*FZ)p9 zozlG!A03kV;iXe^7U)*&qk5vHNms8>nPrT)MRd*_$BM_>IF2kw_jyRuJ!sKnKFUE* z=C9I$-$ojeJ+&+|`uWIjzLCschb41~eqN7ML^ym;>q1SKvM>wFC_bNtpB_6BIYd;` zEG;CP>O2o@ld%1zGHR!5rcoM@87;0ZF3;7h$`KkXd~}*55{orK8OStcFbGhJ5np?x zx3>mQm8e1Rm!x$Y`QB<3x1)odfGZ(15LH&-GsH`>KV#U^+0b9Ehelm$8y z!&#z{I#YU`PC(PJL-(l(jWNVXSdYH9U=a(OF&=6}jK0>i>KIDuIYALC85>u`aR-!E zZ95@^9i>PDV;zXfEUB?7P27r`u|Srr5@ruO^1EGO6m%-EL#jCXoG0OnsivbaK$LRt9ew29B4b;1!^neZyTd>cx=#Kb)<5UCrl=v!*a z>|PSD9=4ObTBx&BaQmb=t>>eGr^}19@N@!GnKUzRof4^I@z4%QGFXzh#`{#PtZ`s?J?2WxdB7!$IZ{r3XaU74a73aK!B#VOiC{C<&7&t@gp_| zIABAmnL8A8Y6i*m<5PixK%O1p_?nqKllN(}R}-=>RW;#SXRV@Q_)S2ux{M~V2{jYX zXHA;vQriT^Nm;JYT{E{mpig-_Vsw3sAkieR$yAYKI1xE3^H`eP;U4em;u8a=3eY6a z9lkolh)zFweC&G>Kb@A`i0{klBx}aBA&{$&B@1+6H%u7(qd3%fZb#Fr?$|<_9EdH@ z)j<4?92T&n>6Ha6q{$YrKvyj=m}|6!k2>-EW-dPsAaF{RaZ-n;443pLO(d~4I)9XJ z6fwp$DF>!QZ}~>8pnOBgt}{r-gLmZw(j?51gwY${*`*u$S`z7sp-h2;k2z6Hl5Rzn zDt@^RBPB@L(R5WiQf_J?O>UwV=xP%k&0zsMnqFDJLYiy=3v|^2D{@%Cj;2=@u#hHO zzye*hz*r6o*wOUL0v6I_3s|757C5pKhKz%(Skh)kqcg1%0d3jzX7FhtO*W(jx@yRy zsJ!_mZR9UMV3Rf?m(j}yDv5?&J}`f%)R~ctFo<^MogN|V^`q2TrVsVBnT6^G>niKm z=v;jrAHS;a)seIME;_oLKO_we;oy>K2%r!$e31J~*mqu1D3|*~%cqp)@IN(sb6M7z!+hC3X69NIn;zkpP0Vf=i zKwFP!hcenR?ilwI&<>R`&C-&ss1J&-S~}NUZaxSE2lq$|3p-q*j)Sj6IP-O_#602t zs=0H+ENTTdtKdive)67%sei_gU-lJsUImhrP9>)lK`8@gq7jz21PE&SgCtXwlC8jb z^irpU^B763aFhX~`nWdYWu1p>t)ycgqhciVtdhi)sF~|sR#vdE5sY*~mm0_`6j#(o z>YK3tP21cv)Vj~5E3MSlv=qnJ=g>;F6lc+$N;12{aNA`LjnuHinRKUQZW|Ysid%L;HtT-T*DnTW6sA!~s zbTDOWb;CxVb>e1(_{4uip$_@XfG-x?s}byfh9)J zBsiY>ArJ~=rk19Xd~%zM1I?uwz`nyy%*w`bM5de!2F1onra|FMT}--#gXxNmIA!=< znVF$uo#XQ}!chm;(i?xFf>OgKI=b}=UwLC+dN6+Of?3?NbMuq-O6AlD1~gOB8sqr` z6a1_SxtY;f#qjqus<4gRen~WD@C{7KDXt@qrN**j&nlUYy>a~os zp6bBKh`swpB*v#3t*Vb=ER6|2UK$y*G2LjI%hA|~i3eC3EJi4&8Fx zmP#D|6IjEZ%0Hwq2VsxC@mQBoXuzG2sVJk`#Rod(JWbHZ8=RxS@T;r{;d&VeWs%{zXX!1=tQJuC*Hw~jGIoq^l zCDlJjZ1O(SF~lJp6c*Ki4ZPdB@hfsLs7#7lehszjQ9r;nUR zT~;Ta1d1C!Sn1HEG`ho9qr_l+Vz@e8#Y}vT@xDF3>=vq<91SW_uIQwAzE<;X(Vqm;v1q>^$7Dw~^9HRiM-<8d4rer>$m;%AYVZg@oBSec$~ z;93ymo5LlH1Y7M1e#fXELaLi_`u+r;qRQjCgP07ELW7B!h2QEp`B}Q54a&I$u0o{Q zuy~IhHd@?Hpe~`brBR)bsCaQmEA8|#&OnvtM=bi>fai+lASU(9jQLz77fur|HjJln zMIz@HeD@FSp#*iC`G;67MnD)`M8&`PMq2_Rk37>s=nY&pq^m+>BS7`ZIb*;hsSb_2 z)NGYl8Sck|lMfAt{YVGXd`FhJYbLAf7!#}hlFDfbj<)1!nIFH@Xt7AC2fDX2mZE5U(0IQm zaE&F5Nvf0I+XMgu%LAnE+OT>@sc2dtm)O8+KxIXjTI(Fh)VZSi=(5GogNQ*=<(U}u zmsCF3DXUe)Pz=6a6iJL4Wr&I8mRn=>MGORX3+c4?*6c=m)@nBZ79tqy3~l<>4MQt- zURG(f#iGP$7+Xcx@=7(btX8i^@0>E0Hflj47X4K$BB+I0hSBPD#}VT?MI$Rt{^uMG z5!F!5{i?U}>(g~sG_SYnTdJC|fs5vn{ME!s+`=CEJ*nacVx2-O3S-p9;?)vi7gZZcO}N# zXaBiat36D7oDCr^9%tx=fbX=4qnF^z_2Brk`mSk3BWZ8MEljm^>^ zE)t=|*O;Dh>79qB-ULh|%Fac=5#yMy1C9nOOl(ef-#&9j$_^Pmaa6XLMt<3$?j0$mL6BB2(i?*lTdXP;QeL0H0bC7A09yreAFniYKnr5u67n1E4Xj5 zYGTeJsiIA+`b!Z`?Fx1yZp=aXz~aZ%cj3Zq~>V+d?JIR%8O0VoHDajF>ChJ1DP=Pd z%uqO+wMRpXhV7l)l40Dnc-BdUEv0-mG3cW4H;JX*c?_%~Bj&Z0X)Lu;Mr=vlyB*Ub zZ~-McXVZ$Juz$fcl;RI5gz23@PKF?hbiKYNNr!9%+8BwAeNd_ajFcvs7y{WO3!z}O zlgmM#-n&~e4T@xNElh#RNm0+38Vz8yy@m0tXfs*P$T7Fsy5JbISxS2iEvB|hRALHc zdg)9YlUi)LK1tNik4^#CXcP%;WUR3C;uuK-spdwf*cUSj=pqv5{SwwMgdx6G$M)rD zno0}M!@)M8tXj2)1=g%fBNS|sOJ2)m8NIsV6Sl6IYV~+S z?8j~}X*xq7#y1E?P!=~E8)K#+PRim!RepJrh-gt#Y^e&2p^bE;jWwBU{pr~av@fkQ zN#BonrR;u)hDO|w+&Oe?rZHnJR4QTyDp}PgZm(}{S%Q`B(=?FPjXKpDYSys&Bz--3 zc*HJN{WPl;n0`%h&iGWNS#CEgwRQ_@?!|)p$g=wxI|2F%BiiZu^RAwa2!nzRT4P(D z#2PSDmZINkF4c6?l1F^Wzue=^Sg^@m2BlAyC86Z?T5C#Eb~Il@EA$o3zV~mY-Kgv0 zH*H*(>u_uy5p^;69<(qtIv$iSw2gmE0ueu^R zWaclFF|e~*^cXUum1_o0=Kfk*v=(yW3uO$fOiON*^+X{nFB#B>fXBl)7(|Sw{c{BCq3*@ug9G0 z<*w~PYuU1s97S@RG;W>5jh!~_fvU)BTNhdD3X=MmnVFfHnVFfHnepTM-t6wIhThXY z&B{rCzqYo#tM{KbZ{EClH1O=POj~sPpg~vP#l<7sExHvf*V`TNxW_vXRq3N1dRlQ` z%5gBD7VKiqm>J3nu!fuQC2i#KS&qoJ zk+w@NHP!8?)RXeZ1Cw;~T)e_kqL5gv%?bFX(JD)#b)7LKoeVx{m|w+K1>mwI(Ndl; zO1*Ekco?YwjLt>s1vlxlcnu)Dqt7x`1Sre_8_>o-vS>~B zV>GY5qeXiKEV`qZ5u(_hZ4p6}w+K^HrNGkC;z4zbJ09tc8PixZi^Qx2}_mMx|uo|jm@OpfUxh$Ho+Ob zD8odn-_kt-9^^XIkY!0eQj`A+NeE3hZIkuii!; zQuZ0~1k<)x7=^#B>rwo<9+b|C*zsJ)X>sf_pELJQ*E5DA#&{$=8o;G4-Ati0m8l)p zi~1hKd^e}iKZmNm?4vhh3xiBLg}CB^U<*8YFla+7iPA;d^XVFQZrh>|N{I$-9MOx4 z>iXL#x@;B;RpZZLF<9kPo?*24(dEu>ew0yWQ@dES6FE3;y)&p>TVJG}8pQ6M4{=n! zH-!E`tVd?v0^FbTxV&3mrf@%B`k35r90GI_Xlu$LfBFmk`R~@~`nM>I$JU(wLVvQT z%_YB*u!@_KtZs6p;t!+vFNaE1AyNFR5zVzmy}dy4x# z;On3jMO--RHX7${fqx3c;^=5`d~|$L{MP$tH2JZ(V?6okvQuX_oicLs zxo;f0#-@>xtBpkeY&vH#IMQ9-Iv@W!GE#;g9xs1M{$Cn7ZR(u*B4q4u9g}~$KK$?n z`1dEt2dBXQOCzHnPM(`gJ|4Ly{P1u1S3V~`FO6*Z@Mie`=_6Mczm8l(8Pu60*E{X1 z@R|5N@z1s4-@jgR`o4Ot6}H2r&X%(dp1oyuX8#4zUyc6=V&X;d1tTL@iheo`{(I%< zCxyyLNnF$eSpRy-rcM6_d@(ukhWJN-+dLwNTpAgP;I7C|qQQwbPLZD!#WV21Nczk~ z?-TL)7V)3tAMx!YBRi7c#Q!#r9EAT?Dl_}$4jf#lOz)oGb#P{G;lM#@(ZSy$L9iYe zK?UVhWw@CnWo$yqjF6Pgk)*sQ0w*AjI3;B<`cv;eilmIoPlcqsLjIEcUr5SOBp}PY z-U2|N{A6=&+jeVxeFF%@lkDaivA!lGql74m^`-u!tgoW{Ts-#``AhQuT)CT-qo^Qq zIl4nKbjxL@g6@FDIlD<{t^LvHt~9c9=ctxzn<=UafpyX0WHd_UP!O^8>5d&z$Li<~ z0J=?}a!hpDVznqd_A1^{bmKc8@NM?OC&F7^oRb@oF|RX#>=Z9#5EW8^@p+c+o%)>4 z0rj;MmN`(&d)Iq0x$h>j3;&DFEu$VZbRD1@duH6sdF{Zt`}Zz+Hh($L?p|u(?Co52xwKJWU%e&$c6W;WW(Kbq7V}yWb%4EOzJ9bxb}+1A7*?Pq_C% zak{_WK)4J>u@P-Uc4l!5zP>~xQl3R?-6WM3D$^4oDV0!zij8DDV!7NEkldh$gsjBK zZ6`)#`p$smhFP)Xvl}DxBP^#IF_5@-WZ!*{TKhL`Epv{mkG3IeY#VUwCRs7% zu%B&5bkN-Z$4w=Uei`bRK(kjDb$Y*9iY7L(g{7@u=*l(0xpTGynKR){ym?=Ai4Jm$ zxCp*0a7NgiD~wCCQ@8Cd2W+>)k37B71=B)64W7?sS>HEILB?$4gMgE^eYQmH?MilZbDv00_@W5ISn! zQ_~EVZ5PymA+MJaEM^0-Lu~(MGYCe^wKtjwg?y9k*2NJ zjrgG;B=Am|QTX~!CgnC}%){-07w6C@3=vS6k!dHNL{5%p0p)Xhl)(ZE^n5|hw&#c^ z5Igv`Ky^n<)vV)&sW*tSKj_39cn7mY*dy1UTyjiGZTjEczJHKvSL z#ixtTSJrkQJL_KH|J|~o$aDnaa%U2e#&ZGJ-80}aCWkGTlow%VO5fd29Xq~rd61?V z8CH+*6qhn#NIH&q`#q`iXt^H})A(c0#U!DNr}|Mh1c5sTly_j4N_%0~oTI->EDErW zdy-;J2Adz0_jfuornsS)KN?Dd@6Le66c6qUQJP{;2Kt78uxDcuv02Z7ReD}R-)`QP zmyV$9$Gtdplj;0XBm0Ipkr9D$QANrVz=66xAEk(fiUU|yrk z8=?6RlQ@Q{`7a?U`|3by*S$2M-1iR1JiHXdY4jc{4kT3R%ZId}%Qy*&Joj9D;rDVN%a{^pz+$gi1eMU7_l{9fEE1kPPXv@-sgfXY2n%$o@}*4K zE0-md&DgPnEZ<5a)<`v`OGa-EhV$tY_URFYz8yC4rcBu6wH{?xl+Yl}m2)aOwb-Ma zdvuD5(*!YHoy`sb!p~cGfrc$m@QXSRAM=%n>|uufMN3h@s^9oz)Fn8j7sFe zd1Pga$Ur@&I*iBwv8wJ9Q*}iKau_e=Q92q^COz}UB(o)s@^>~;`aO?gB1NUrkjK8N z(sp<|9OT(!r@TAOgudZTbCBh(E6TSK##DzjULx0OEun1sHXH-y^O;!FmnU>}??N6_ zDL%Jis*bZ%9+at*L_48;qE8YX6^Fw(beN^=c`uAgx00R_Dw;ubBl<<{B$2fg2`n%)-1*&sL_kF^g$E6e&dEA1w(W@iC;_$yOKfxvVy-K7J94VIJK%W;2Tv~Cq3S~( z+CxLuMFM+V89<0Jz@5KB>f+Efujr@qupAKPxw&!2Mroag`;N^nVq$BZ!njmBI`5AG z?;j!YC9N~;y1rqV5L_-(mj5HOkHRz|*xaP5p&ykUM-KB!<&{0!K;o!QOAW&uIx9&N z)v)eF1@dDUNZbm@F#6atR!AG{>GIzJbdP1B%dbF_E&cMiXK+|lkvuNz82n|Qh@n0{ zD~cQ>pQ=`ULX3m5K&489RQG86wNu{NGDc~qCnkv8u7GG6iVHO0;BA#y@o~rljv*%^ zV)mp2hZ!}J>~J6Zxspm*YEO<4Q1K(^;uMws37ghge8YQbmuJKnT+t{3 z0#_oaz6Q^X5oC@_#kwRvtw!aKJuAj$#;Is!!j=&#bLrVJ0y}1vN+{=f)_gNLDNs$QHwuSIYi2zDiTM`rym$LR|sA9f&_~Z z@9GDE%@1mCd0~uUBRD~5)E6Zv%t%!; zmvY}|xc~sz@oX-LrAenFz6T(FqXTiafE~a!AIt$OWpTVoVx^*EQ@hLY9oNeK$==xu z<1$F6bF2j%dvk~!xHl8T&%?`Vr0gl9$z}~8SzLF45xgZD!QOuNr{|VEL*)Xz zm4n5_bE{mK%PH#Y^)`tPk10j>n`5lvVxi)1Z)ai2#47%|OorbKKbNTge@BFGpNnw9 zhK;f@-^oDYwMLC_4tKUG8}nUR$1qeo;N4kKjpeUyRZWRd6{0j)9;n%VfGuy7<^DN|E;%!z>(Uzqbt~KF;a;|# zJ1g5X*O|k;lpf7`uBgeWlIk$wS4dEuJip+=W%`jafa0FDwj&wgQy@=YOfkg;6N9md zjR?tu+X;xiWFQ)VL2Q{$)0&MHC;AG1Il;5b5y>*eh06!3%jZ`lT{F?kB+4EwRn_^` zgsMpH(o=R!vh1-+x1z!0Gl0imOQ`DkQoadGFHS!5nTwrC+V6ABIaQE97g8%HbC|JlB%8* z;!hKaCW!ktevr^~B!c+UCC2(gL3bC-YiZ`-uAcQWK0W29uc-S`e-zOSn@ja&=bay8 z5EPS1mXO$?0pUtD6_@z2urc?9t<`F$goknF%MgTuOl&a6FZHW7rTV-6M8kpxN^mgj z6+l(@{Zybi&@9(F^|0xjqkZMwhat_ybr2mdjhYu|ac8YCDnlfCw zL;`cLHsn!KU&R;0D*n5I&5whY2(q;eWpDf=#nx7YruAoJv)A%xu10kwwz z6{Flgm<$@g*fUG*Bmbcw^W&c{N@^eZ&je-Isn<@71mY*Z|I)De@zD3=NAd8#6P#V> z;$N?!s_=ZoQ1HHcmpVQFkB%)16EU2YLBn3hh#&ua(AWPP^VKkv9vs;e`IaJNe*E)ANkx7)#V8L}kE81snOJN2 z4zP>Jpr&reh+dAHd$_!q=gT|Fmw8HpF-VTMbK)0!y`43t-i`N+PcMaB_Us^GY6sC$5A_V8Eb zm~@!xm=^)_HHU=ROq1fybDt6V#GwBEcWdJbPF zK`XPVs8&fch~l$K^w|) z?J_gOUIQ>i^3Erw zPV_faP|dZ1rTP^mDetam8!@BBk_nW}J!#At+$#b1Zp6nqRgl9>nf1r8B z6FEzL zaAl3U@!)18n)x#9Na24sfk&h{PZk%!?*Y-9kg83E3s-!`oh}wq)$oR9b@`oJ4gtl!sm;E+WYQgp)h7a_<20JK;2Av zj*z-q*nrG2GKrnL(kO55xzU)z)wOCX0RN(GrKQ_HbOhYHb?btmeDcIH%EAJToqVxK zSD>K*M9p1+iAA`e4LEGQTqw#kY~44x4tU16c=9aUXOD!ExN+7?c3;IPyu-fQXd5D@qDR|~7|q&xr4vSO2}cKeh|8r1 zSYJ7z*6*E}SWI)3D=Acj{w`cBCK&cwrYeQ+8t>n0>)?f6>GTfHHtWmaISCO+w6gpYXqPeMj{aHi@&$~0R+UAI;UnAkNXOxO7 z?97fA<~VO;+X?%mq##=fs*4cxu;)CEOXj8(s5?c=0?%U5kS==xMvXQn5)V!P@JNgm z^kB~=wbM><5PItgidVZ5Bw1oYSk!8`yqe}9%z;$cwMsf4# z`2vN=CtTO_deRnNB9aHChSNPmqW4n{{urvK(gg@Msoh-xSrQzdb4UbM~w9jEe4F*bn7k0-ftT9*i(Hv3&#%orjIX zCU+jGv*vt6{qkw0NT<_!p3yZ%$fU^D%F|iEWJ9!Zo&q?c@yqGl-fA1va-8kIC zQqSOmvc;dR2?|BIx#^bpePM6Agoh@|;q*v0^3*Dn-n}#$$rWqW=3HjhIBn+ z1LJdh)SW*)2i(2~i7~^*-~hl>`Wv6> z$(?iR*63Q+F~H{Pn{i6*u8R?lRuF*HwPr+2%S?Khhs<>%3-)QmhVN z$ygrujme;Zu1!V#Qr(F;gRO9=w-YFyogC0ov6cHsw6+!%w{|&eSfUK_njkAf$!5Df8ywS14tx6~ zsk3~@MKm>S3KyG0l>cxo!86r>9FTf*Icni! zZjI6Pu)dZKCF7S%6k*sXxz-=LD}r{g9QS$3cuPe_X$TadBfP<$K`M{2EfIE?;6?o9Az^9wvH$a+w=a8zE zTzBD!O)9FG(+0&};ndmXzBsC0!(dg$Oct@xQ27k^)6vW{7Xzr>bOXV+eZycH0HIU{ zx@9c9Y4_I=igIcUAZnI)OFQAmdVs`NUt57DCIX&27c>{$P0i&4C6cJEx!m56$wYZ& zY%c7%q#}zCN)SdK7)zsrlgNK>BQh}`EU5=e)o!CB6nAu`55ghu&Noy~;)kSI+O<}F ztpjxfCO>At&^9K6yKhid+CwFRuzREtIPEmdc>!kHeq+gVkx_E|Fddl`WS1q0AsjE6 z0NHZ9L#iahKG_30>EQ`N(P|=E@kY-H;t=dRqtb<7pb}lC9wAXRLg*CkV%I)o)x(7D zGbWVHFX~kONDUb^p%}vPk_nJ2anx#jRDy3WWMg9XF4WF?&K;#0A1x7tZD^NdWbo&* zb5Ir5k5Q;MqaDmffQpVMSEwE;k2P^+vEC4%6K0#K0VG_yTy-nuLRfo`b0c*dQV7DL zH$tkL;Nug7GhmFnbOUDHfo|CAs~f0%!zU=XD9wQ38!wsgxSE0LC;h|(-37tAlWWLS zN@u5Ocn%fQ&HTfE0|)(f(6W5UMTitH5Bq(FFMsaZB} zs6F8I8a{t;T;5T8z#B|#Cv*>>^0eNVBCR(&2fCfLE*kz<`kokK$DUWplk%n%QP>Hg zOP5RTy=_>cUii%kedvkNI1#o5Wre*Z#in1Cg04)HQS6zby5+ppL<1F|)phLLQ90jN zYN)PCZ!@thz-8>2p>Wqe<@I`dibPz~QiXVJ?E6Y+MEzZTIYHIrz9XSe8RxL$%Rj@Z z3sK)zqctv6{WTW)n|B<|q{a|OlOGh(^ciGdQLsfFTTSqq=G?zOoPIsME1jb(P zRL|h|=s4PL2>!Ay9hUleK-@v}-V}kjgeZ0CZt&@k@(jLDLm2xSSO+T0XyUFq$|L@M z4c(luDiPj!Tb4wG=>rnQiU8mW;_N|H(&!#zp|K^L@)3PdLnc)u2jO_h1jwB~DogT1 z5?`kZ_iYjdReElH4w>xK-5VcHP%VT*tC`-%>DAIlY~|NK+unvWY;(FQG) zKn|c=+`cSvqx2^RL6l7#bH(||tT_3?H~>!RpwMjrkx}uf{BYW$$VN)}1V1g2qPHdy zIf$m&%SJ}kAbmzhmSq21mpbK;Wlz;0d{&}ZUxOnXo$hZQXu0~0^0s|W#o_R_`O>ED z#QS_gJBy;*mNv38R{J9(O=PL@PL>Bq0yXxw7uje_#%d`&@-6#dXV!O}0SW~SVkqfWkGw^6!zg`x9bcd`MBAy;LPt8ZjR zr)mhp>}TuHLP0v3b!~MSAo`|>Xlh;DUY{jB0ppAM2PhI5+G`=b9^y|j;-MJC z#v@$=27koOyFZQaK>XO(CCQeg0-?QrHYloLd4UM5Kj&bT(~9U>aQ2#R$pQE(0}A@S zCHgV_B44aIc!Q`O5Wh6hW>~#8B<^aVZiN2TK!~ylWu7>Hof#)zAlW#HzL3Ak5vTvm zQ+oTi5~+ug!sgtl48-dzS=>VLyNr1H&ugv`(W=Wh`fz8K>ah7&fv(=H+bOh;>t5M>p>Ejwo1{EHKZ|vmDetzfoaJMXZW}{a z?EoqIdxW7~?smeoMhMIL$N>p*YMBHi|A>)PssN=@i*8bLT&4w=L0B-@(tvp2&jJ+x z6!&)2JJm+LCOW3&dIK!AM*by6f1j}4BqLn-tzCA*MlM&V>ZAYgMrSNwwhU7%_&)`@ zqxD9kB+@!ty}W#vu&^mpyTX47%Fv@_(JZPKQi`5;e0f3Xl>ep>DLLA{7$)U`%g`xz zfHm|#BnE#!7FA>Tzmm4y!5LilY0qM0ZmdEUwzN=p-~FGCO)q!X3vF_+9jN@;e+wk5 z)lO}tZ_EBjjv*t<5E!m@DHNsB)h(GTKwd^R^U&mZZ3%ZARGrYKbR44I#E~a4M4dqS zOgE>vvRq&SOT(US_Bx<$(LRNXC(jAzkAe5Gh4&}6x~93&ezQfvVil^{CD3TzI5 z(4Cbha-y%yL5M{TEr{GzGl5v3w*`b(*$fs}Q{1KiErt*7>h0d+#&x}HzEHl6s|vm} zJKGGgV)qq`FQr^=FS1nl<)U~vDV-mRXOV#OJMN~S!dT3yTMvigx*%R0@+Mv^=;L3&t zSwA8J?s{A-=47!~GgW(b{RmB~zFKXq?}dxp8gTk{mJH>fRUn@=Zg^&Bm1W?{4H6vC z5Yg4OJ(+;0&-+YSh*Eqd9yI*|KNGCLLp!(DR;sN^r&Xs%f{v( zwYT1ofg4u`T=^=D$y7M~ELI0j-Y7-Xh>LZqi=s%?U8}S4yhN-55p}sS3weIrq^!D| z#F#>H4@+eUS`1?z%}6MXBp~lIH|5d0DGM1?yBlI)f#a_Wxtxvlyc6c~W?9kU)5yj{ z>A9O{#^dkZqB84mVd4OxYS!B;4zU7*M%Y>P zB^&hia2gO-hf$Rpw~Fv|!lvtNH)FfjxU{Kil`WFC`y8hn+5B-()!4U=aKIIb(M&ka zOQ_p1j9j)5rDW`%eUV&b@#!UI=-lh zB?1s@W0^yrQYvTvEFEE-HjO|;otN+j$3=T=O+xwA&z3l&h>2ZqkNZ~rtrSYf-o8IB zTgkIIL+x~Th!NC+`Z2hx#&D=W^wV_ZaP=6~m+g)T?XcN|erWEs2R4Y&@Pmth@@3sA zL2&E@`LfRG(KlE>Y+u&7lJW`nWsSy2mh0_K&`NYibSIEgk2sPy*y~|J9$t-o{x-1B z7h*J`wNlUUyrk@1e@9gSjKwrJJ_`UjKTQB1#%WABo(m?C*|-y+DE2|&e^#25fiFWA zZV%KaXzIRt3CU!-BT$}HC_8s6PuhhsIc(j3vjnua#k5yL*bp?2DHSW}trbvQ;A(X| z>mU81svWmusN-rlM~#^Y*?iC+FJ+PJQ1H5Dm1VXT*gt5y-&+hR%0ce z12TD+zNmc9Thux9u6?P`O{x9v3`Vf`Co0SDZVDDW6P8FG^Nz$*H&@-ghpyac9B3X4 z`fa3KDWNjgcJ`teeLJ3#N@@G^Q&g}I0&C1= zBTmrZJTV!=mIrG6UeLo}oZp4(1mTM1QsT}P<TFh%xWE)4Zyo}{!oyiyMAQjkF-3&kJd}rwQ#vz9 z5QuC{QRy7QZA|7ui#D+f3~^?!Gz!I1f?_^s4jBbC8_NlbA@c#LTN9lVRwRPHeW~-1 z3o6c9SCKdb!ZNGa@=zc;%iJfS&g!}dEJ1cttNkZ;4O71CqY2jjO(qUoh9DOQRRPq9 zaIDmqIydJ+Rb7vjiCx;BOopmU#%88QlsQs=&Q!y=1M#9AfK{_jp>yOOWq`-$ z9+Iyz3;6C!;me@%e0fLh)%S}eta~K!(Prr!Z5#%aS#?U9-B5MspV5VA8*0f!zn5Tar7=+P0P^=9p)=>Yf`3K8xqWzQ4U0r0UT1}l++ zPn$TCJ&vO7={2BE$B$3xGK0g0O5v_xDx>!aeK6U_AvSeHzluJPPwYe8m<+xYAeutt zoIgp>?yLwGj;j($B!w8{*&~-BJ0t2XYEPcrqi#B{@}P|LhY|gip3DW2HhVf0c-rZMUOw6hHDexj>i;L(FYyW8lLF4CS)pLTW= z8iT7L%~VA8N-7kk^3uohKp4xjHg+r*6}@v>DXD+|uW)6BA>m zmhknFJSysP_F#~+=Wh6D?1jT0k344T<9P^-=Xo1G9*4N`HNk}3&h-&J3`X>PV?=%3 z3l5>P-q{H4HsRg{9|>c6!HF4D9$Icfntb|9Jsd{$!V@tnhxoDA6ERaSVvGsVcmoJu zE?RHGt-~J;Gxg#VHmV%7U)o4nm%zusxL$I?#^n%0z7{M>$FDxJ2f)Z)YK)9_(>YY2 z{=!D+zaqZtzHFmMlZWObtksuq?06i)#@2bn?7SlDXb^?R6}5b{opgukYv-Y`c3yb` z#*>Gh!)>Bhoq!QJgpRG@s63Kai->c#35^pQ^=96+sgjk3pGtU(UL$zfZMu8cn5~=G zBThGAgYs6O{8}+$QHfg*o4sVAabUDx-T@Umf1McZaky|fqk{^-c=~3kin`ZFXj=77 zun^9M%jmrkSfZqr7S5j^=}s}`=hiSkZ`gdbkxHUiE6`{_wnI=8K}Pr#rJ^z@-V!Lj z(V!T)FEw&pJx|qwzsW^ye>hidRae`7ROQjf7~>f*#y6`}MSIlA;$lz>7Xv?v(%3a9 zigorDjACVYqkOAPGidscl91N7sT6A~LG5THJ^B#&(u!!#TLE9+zWM6C^-&Ag)?4-E zm5w%zY*YNYt1k`5bVRJQuqb0Tv`)^7JaWxYqIDy zvefBejBE>x?0qh3zM6$tb??{dO$Rl&dZ3{Vk1wCZTKIrYZ*OpgA1#WPA5>|H+YB8l zj4LTrjQ&F^z14bCh~;DvSPI+GY|vcptoV&JJ!BbjBUZ$RRobnn&6GxrJI)D2$D9eY zKBChS6$MInD~&8$b|?$?qc&Zq5yc%V#n+FiG$CZz2%6dexwI%v^KqM2VRC5HK4DWE z9~&CAPukQxwP+EMP_YYs%BHqm8yZ_KDH-{+L9G)mYQ)$wLRg=lv1wJBVSBAw)3!_$&Ug9FBnD{fi*ii4VS8riyr+IzoBP&Fo!PnWP0zviN=PbHfkrNO^$(d+69 zl1+`8%WpWS4Sz1bNl+c;Tz<<%*K;l@yXMXXT)NBD)luhQ#;ovQ0l#a^3~CisEs7fSrw+SZ&awI8bEJLWL>bEWnp zmD=%Ks3E@68^ezEV?j;a%C`_gO<+r7B3DKzTk0nfov_)d)|>75_0=Pxz74Z!5o7vk zOsm`M%tD;UPwvxzxv|^d1bFwel#XLSe3>9d^m9Q8E+JcV5Mpx<+0kzRBl?A)10F)b zH%%1yqapk~zf7pig~x-|!tu~JV&+QgR|YNPfXSytaPQX%E#Xoc9`}BuP}w6c^!D|K z6C?Uq$+NUYr!kt-fzDq99q72Z zstFi-Br<)<~Qrr=((wGk-M1PW>;9jy|6M2k=xn`2YX_ delta 37562 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