From 95e4c5c8260a59492e750fa124fe85f4a26a3491 Mon Sep 17 00:00:00 2001 From: JustinAJ Date: Mon, 20 Apr 2015 00:08:54 -0400 Subject: [PATCH] Added Jupiter::DataBuffer and appropriate specializations --- Jupiter.sln | 10 +- Jupiter/ArrayList.h | 24 ++- Jupiter/Base64.h | 4 +- Jupiter/CString_Imp.h | 40 +++- Jupiter/DLList.h | 24 +++ Jupiter/DataBuffer.cpp | 121 +++++++++++ Jupiter/DataBuffer.h | 216 ++++++++++++++++++++ Jupiter/DataBuffer_Imp.h | 350 ++++++++++++++++++++++++++++++++ Jupiter/Jupiter.vcxproj | 92 +++++++++ Jupiter/Jupiter.vcxproj.filters | 36 ++++ Jupiter/List.h | 13 +- Jupiter/Readable_String.h | 3 +- Jupiter/Readable_String_Imp.h | 14 +- Jupiter/Reference_String.h | 7 +- Jupiter/Reference_String_Imp.h | 25 ++- Jupiter/SLList.h | 23 ++- Jupiter/Shift_String_Imp.h | 12 +- Jupiter/String.h | 6 +- Jupiter/String_Imp.h | 52 ++++- Jupiter/String_Type.h | 1 + Jupiter/String_Type_Imp.h | 10 + Release/Jupiter.lib | Bin 254672 -> 259384 bytes 22 files changed, 1066 insertions(+), 17 deletions(-) create mode 100644 Jupiter/DataBuffer.cpp create mode 100644 Jupiter/DataBuffer.h create mode 100644 Jupiter/DataBuffer_Imp.h diff --git a/Jupiter.sln b/Jupiter.sln index c4ef9ae..d7352d8 100644 --- a/Jupiter.sln +++ b/Jupiter.sln @@ -1,7 +1,7 @@  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio 2013 -VisualStudioVersion = 12.0.21005.1 +VisualStudioVersion = 12.0.31101.0 MinimumVisualStudioVersion = 10.0.40219.1 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Jupiter", "Jupiter\Jupiter.vcxproj", "{367CBCA8-6F27-484A-BC6C-2FC087FBB0C8}" EndProject @@ -13,18 +13,26 @@ EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 Release|Win32 = Release|Win32 + Release|x64 = Release|x64 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {367CBCA8-6F27-484A-BC6C-2FC087FBB0C8}.Debug|Win32.ActiveCfg = Release|Win32 {367CBCA8-6F27-484A-BC6C-2FC087FBB0C8}.Debug|Win32.Build.0 = Release|Win32 {367CBCA8-6F27-484A-BC6C-2FC087FBB0C8}.Debug|Win32.Deploy.0 = Release|Win32 + {367CBCA8-6F27-484A-BC6C-2FC087FBB0C8}.Debug|x64.ActiveCfg = Debug|x64 + {367CBCA8-6F27-484A-BC6C-2FC087FBB0C8}.Debug|x64.Build.0 = Debug|x64 {367CBCA8-6F27-484A-BC6C-2FC087FBB0C8}.Release|Win32.ActiveCfg = Release|Win32 {367CBCA8-6F27-484A-BC6C-2FC087FBB0C8}.Release|Win32.Build.0 = Release|Win32 + {367CBCA8-6F27-484A-BC6C-2FC087FBB0C8}.Release|x64.ActiveCfg = Release|x64 + {367CBCA8-6F27-484A-BC6C-2FC087FBB0C8}.Release|x64.Build.0 = Release|x64 {0F041791-1047-4C6A-A4C1-814E6957D5EB}.Debug|Win32.ActiveCfg = Debug|Win32 {0F041791-1047-4C6A-A4C1-814E6957D5EB}.Debug|Win32.Build.0 = Debug|Win32 + {0F041791-1047-4C6A-A4C1-814E6957D5EB}.Debug|x64.ActiveCfg = Debug|Win32 {0F041791-1047-4C6A-A4C1-814E6957D5EB}.Release|Win32.ActiveCfg = Release|Win32 {0F041791-1047-4C6A-A4C1-814E6957D5EB}.Release|Win32.Build.0 = Release|Win32 + {0F041791-1047-4C6A-A4C1-814E6957D5EB}.Release|x64.ActiveCfg = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/Jupiter/ArrayList.h b/Jupiter/ArrayList.h index 7a97439..128bd61 100644 --- a/Jupiter/ArrayList.h +++ b/Jupiter/ArrayList.h @@ -1,5 +1,5 @@ /** - * Copyright (C) 2013-2014 Justin James. + * Copyright (C) 2013-2015 Justin James. * * This license must be preserved. * Any applications, libraries, or code which make any use of any @@ -128,9 +128,9 @@ template Jupiter::ArrayList::ArrayList() : ArrayList(Jupiter::Arr { } -template Jupiter::ArrayList::ArrayList(size_t length) +template Jupiter::ArrayList::ArrayList(size_t length_) { - Jupiter::ArrayList::dataSize = length; + Jupiter::ArrayList::dataSize = length_; Jupiter::ArrayList::data = new T*[Jupiter::ArrayList::dataSize]; Jupiter::List::length = 0; } @@ -186,4 +186,22 @@ template void Jupiter::ArrayList::emptyAndDelete() Jupiter::List::length = 0; } +template<> struct _Jupiter_DataBuffer_partial_specialization_impl +{ + template static void push(Jupiter::DataBuffer *buffer, const Jupiter::ArrayList *data) + { + _Jupiter_DataBuffer_partial_specialization_impl::push(buffer, data); + }; + + template static Jupiter::ArrayList interpret(uint8_t *&head) + { + size_t size_ = *reinterpret_cast(head); + head += sizeof(size_t); + Jupiter::ArrayList r = Jupiter::ArrayList(size_); + while (size_-- != 0) + r.add(Jupiter::DataBuffer::interpret_data(head)); + return r; + } +}; + #endif // _ARRAYLIST_H_HEADER \ No newline at end of file diff --git a/Jupiter/Base64.h b/Jupiter/Base64.h index 73fc766..f421198 100644 --- a/Jupiter/Base64.h +++ b/Jupiter/Base64.h @@ -1,5 +1,5 @@ /** - * Copyright (C) 2014 Justin James. + * Copyright (C) 2014-2015 Justin James. * * This license must be preserved. * Any applications, libraries, or code which make any use of any @@ -170,6 +170,6 @@ JUPITER_API unsigned int Jupiter_base64decode_s(const char *data, size_t dataLen #if defined __cplusplus } -#endif +#endif // __cplusplus #endif // _BASE64_H_HEADER \ No newline at end of file diff --git a/Jupiter/CString_Imp.h b/Jupiter/CString_Imp.h index fe74de6..f3d51a1 100644 --- a/Jupiter/CString_Imp.h +++ b/Jupiter/CString_Imp.h @@ -1,5 +1,5 @@ /** - * Copyright (C) 2013-2014 Justin James. + * Copyright (C) 2013-2015 Justin James. * * This license must be preserved. * Any applications, libraries, or code which make any use of any @@ -375,6 +375,25 @@ template size_t Jupiter::CString_Type::concat(const T c) template const Jupiter::CString_Type Jupiter::CString_Type::empty = Jupiter::CString_Type(); +// Jupiter::DataBuffer specialization + +template<> struct _Jupiter_DataBuffer_partial_specialization_impl +{ + template static void push(Jupiter::DataBuffer *buffer, const Jupiter::CString_Type *data) + { + _Jupiter_DataBuffer_partial_specialization_impl::push(buffer, data); + }; + + template static Jupiter::CString_Type interpret(uint8_t *&head) + { + size_t size_ = *reinterpret_cast(head); + head += sizeof(size_t); + Jupiter::CString_Type r = Jupiter::CString_Type(reinterpret_cast(head), size_); + head += size_; + return r; + } +}; + /** * IMPLEMENTATION: * CString_Loose @@ -561,4 +580,23 @@ template Jupiter::CString_Loose Jupiter::CString_Loose::gotoWo template const Jupiter::CString_Loose Jupiter::CString_Loose::empty = Jupiter::CString_Loose(); +// Jupiter::DataBuffer specialization + +template<> struct _Jupiter_DataBuffer_partial_specialization_impl +{ + template static void push(Jupiter::DataBuffer *buffer, const Jupiter::CString_Loose *data) + { + _Jupiter_DataBuffer_partial_specialization_impl::push(buffer, data); + }; + + template static Jupiter::CString_Loose interpret(uint8_t *&head) + { + size_t size_ = *reinterpret_cast(head); + head += sizeof(size_t); + Jupiter::CString_Loose r = Jupiter::CString_Loose(reinterpret_cast(head), size_); + head += size_; + return r; + } +}; + #endif // _CSTRING_IMP_H_HEADER \ No newline at end of file diff --git a/Jupiter/DLList.h b/Jupiter/DLList.h index d35d84d..561eea4 100644 --- a/Jupiter/DLList.h +++ b/Jupiter/DLList.h @@ -273,4 +273,28 @@ template void Jupiter::DLList::add(T *data) Jupiter::List::length++; } +template<> struct _Jupiter_DataBuffer_partial_specialization_impl +{ + template static void push(Jupiter::DataBuffer *buffer, const Jupiter::DLList *data) + { + buffer->push(data->size()); + Jupiter::DLList::Node *head = data->getNode(0); + while (head != nullptr) + { + buffer->push(*head->data); + head++; + } + }; + + template static Jupiter::DLList interpret(uint8_t *&head) + { + size_t size_ = *reinterpret_cast(head); + head += sizeof(size_t); + Jupiter::DLList r; + while (size_-- != 0) + r.add(Jupiter::DataBuffer::interpret_data(head)); + return r; + } +}; + #endif // _DLLIST_H_HEADER \ No newline at end of file diff --git a/Jupiter/DataBuffer.cpp b/Jupiter/DataBuffer.cpp new file mode 100644 index 0000000..568d877 --- /dev/null +++ b/Jupiter/DataBuffer.cpp @@ -0,0 +1,121 @@ +/** + * Copyright (C) Justin James - All Rights Reserved. + * Unauthorized use or copying of this file via any medium is strictly prohibited. + * This document is proprietary and confidential. + * This document should be immediately destroyed unless given explicit permission by Justin James. + * Written by Justin James + */ + +#include +#include "DataBuffer.h" +#include "Reference_String.h" + +Jupiter::DataBuffer::DataBuffer() +{ + Jupiter::DataBuffer::base = nullptr; + Jupiter::DataBuffer::head = Jupiter::DataBuffer::base; + Jupiter::DataBuffer::end = Jupiter::DataBuffer::head; + Jupiter::DataBuffer::bufferSize = 0U; +} + +Jupiter::DataBuffer::DataBuffer(size_t size_) +{ + Jupiter::DataBuffer::base = reinterpret_cast(malloc(size_)); + Jupiter::DataBuffer::head = Jupiter::DataBuffer::base; + Jupiter::DataBuffer::end = Jupiter::DataBuffer::head; + Jupiter::DataBuffer::bufferSize = size_; +} + +Jupiter::DataBuffer::~DataBuffer() +{ + free(Jupiter::DataBuffer::base); +} + +void Jupiter::DataBuffer::push(const uint8_t *data, size_t size_) +{ + Jupiter::DataBuffer::secure(size_); + fputs("Pushing: \"", stdout); + while (size_-- != 0) + { + fputc(*data, stdout); + *Jupiter::DataBuffer::end++ = *data++; + } + puts("\""); +} + +size_t Jupiter::DataBuffer::shrink() +{ + Jupiter::DataBuffer::bufferSize = Jupiter::DataBuffer::size(); + + if (Jupiter::DataBuffer::base != Jupiter::DataBuffer::head) + memmove(Jupiter::DataBuffer::base, Jupiter::DataBuffer::head, Jupiter::DataBuffer::bufferSize); + + Jupiter::DataBuffer::base = reinterpret_cast(realloc(Jupiter::DataBuffer::base, Jupiter::DataBuffer::bufferSize)); + Jupiter::DataBuffer::head = Jupiter::DataBuffer::base; + Jupiter::DataBuffer::end = Jupiter::DataBuffer::head + Jupiter::DataBuffer::bufferSize; + return Jupiter::DataBuffer::bufferSize; +} + +size_t Jupiter::DataBuffer::expandBuffer(size_t size_) +{ + Jupiter::DataBuffer::bufferSize += size_; + size_ = Jupiter::DataBuffer::end - Jupiter::DataBuffer::head; + + if (Jupiter::DataBuffer::base != Jupiter::DataBuffer::head) + memmove(Jupiter::DataBuffer::base, Jupiter::DataBuffer::head, size_); + + Jupiter::DataBuffer::base = reinterpret_cast(realloc(Jupiter::DataBuffer::base, Jupiter::DataBuffer::bufferSize)); + Jupiter::DataBuffer::head = Jupiter::DataBuffer::base; + Jupiter::DataBuffer::end = Jupiter::DataBuffer::head + size_; + return Jupiter::DataBuffer::bufferSize; +} + +void Jupiter::DataBuffer::secure(size_t size_) +{ + size_t data_size = Jupiter::DataBuffer::end - Jupiter::DataBuffer::head; + size_ += data_size; + if (Jupiter::DataBuffer::bufferSize < size_) + { + if (Jupiter::DataBuffer::base != Jupiter::DataBuffer::head) + memmove(Jupiter::DataBuffer::base, Jupiter::DataBuffer::head, data_size); + + Jupiter::DataBuffer::base = reinterpret_cast(realloc(Jupiter::DataBuffer::base, size_)); + Jupiter::DataBuffer::head = Jupiter::DataBuffer::base; + Jupiter::DataBuffer::end = Jupiter::DataBuffer::head + data_size; + Jupiter::DataBuffer::bufferSize = size_; + } +} + +void Jupiter::DataBuffer::setBufferSize(size_t size_) +{ + Jupiter::DataBuffer::bufferSize = size_; + size_ = Jupiter::DataBuffer::end - Jupiter::DataBuffer::head; + + if (Jupiter::DataBuffer::base != Jupiter::DataBuffer::head) + memmove(Jupiter::DataBuffer::base, Jupiter::DataBuffer::head, size_); + + Jupiter::DataBuffer::base = reinterpret_cast(realloc(Jupiter::DataBuffer::base, Jupiter::DataBuffer::bufferSize)); + Jupiter::DataBuffer::head = Jupiter::DataBuffer::base; + Jupiter::DataBuffer::end = Jupiter::DataBuffer::head + size_; +} + +size_t Jupiter::DataBuffer::size() const +{ + return Jupiter::DataBuffer::end - Jupiter::DataBuffer::head; +} + +size_t Jupiter::DataBuffer::getBufferSize() const +{ + return Jupiter::DataBuffer::bufferSize; +} + +uint8_t *Jupiter::DataBuffer::getHead() const +{ + return Jupiter::DataBuffer::head; +} + +void Jupiter::DataBuffer::empty() +{ + Jupiter::DataBuffer::head = Jupiter::DataBuffer::base; + Jupiter::DataBuffer::end = Jupiter::DataBuffer::head; +} \ No newline at end of file diff --git a/Jupiter/DataBuffer.h b/Jupiter/DataBuffer.h new file mode 100644 index 0000000..7aa3df3 --- /dev/null +++ b/Jupiter/DataBuffer.h @@ -0,0 +1,216 @@ +/** + * Copyright (C) 2015 Justin James. + * + * This license must be preserved. + * Any applications, libraries, or code which make any use of any + * component of this program must not be commercial, unless explicit + * permission is granted from the original author. The use of this + * program for non-profit purposes is permitted. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + * In the event that this license restricts you from making desired use of this program, contact the original author. + * Written by Justin James + */ + +#if !defined _DATABUFFER_H_HEADER +#define _DATABUFFER_H_HEADER + +/** + * @file DataBuffer.h + * @brief Defines a simple data buffer structure. + */ + +#include +#include "Jupiter.h" + +namespace Jupiter +{ + /** + * @brief Provides a data buffer implementation intended for files and sockets. + * DataBuffer behaves as a FIFO single-directional queue. + */ + class JUPITER_API DataBuffer + { + public: + + /** + * @brief Generates an object based on an input head position; the head + * will be moved if the input type can be interpreted. + * + * @return Generated object. + */ + template static T interpret_data(uint8_t *&head); + template class T, typename Y> static T interpret_data(uint8_t *&head); + template class T, typename X, typename Y> static T interpret_data(uint8_t *&head); + template class T, typename X, typename Y, typename Z> static T interpret_data(uint8_t *&head); + + /** + * @brief Copies data from the front of the buffer, without removing it. + * + * @param T Data type + * + * @return Sum of all the elements in the string + */ + template T peek() const; + template class T, typename Y> T peek() const; + template class T, typename X, typename Y> T peek() const; + template class T, typename X, typename Y, typename Z> T peek() const; + + template void peek(T &out) const; + template class T, typename Y> void peek(T &out) const; + template class T, typename X, typename Y> void peek(T &out) const; + template class T, typename X, typename Y, typename Z> void peek(T &out) const; + + /** + * @brief Copies data from the front of the buffer, without removing it. + * Note: Elements will be in the opposite order than concurrent calls + * to peek() would produce. + * + * @param T Data type + * @param size Number of elements to pop + * + * @return Sum of all the elements in the string + */ + template T *peek(size_t size) const; + + /** + * @brief Copies data from the front of the buffer and removes it. + * + * @param T Data type + * + * @return Sum of all the elements in the string + */ + template T pop(); + template class T, typename Y> T pop(); + template class T, typename X, typename Y> T pop(); + template class T, typename X, typename Y, typename Z> T pop(); + + template void pop(T &out); + template class T, typename Y> void pop(T &out); + template class T, typename X, typename Y> void pop(T &out); + template class T, typename X, typename Y, typename Z> void pop(T &out); + + /** + * @brief Copies data from the front of the buffer and removes it. + * Note: Elements will be in the opposite order than concurrent calls + * to pop() would produce. + * + * @param T Data type + * @param size Number of elements to pop + * + * @return Sum of all the elements in the string + */ + template T *pop(size_t size); + + /** + * @brief Adds data to the front of the buffer. + * + * @param T Data type + * @param data Data to add to the buffer + */ + template void push(const T *data); + template void push(const T &data); + + // Specialization: Jupiter::ReadableString + Sub classes + template class T, typename Y> void push(const T *data); + template class T, typename Y> void push(const T &data); + + // SPECIALIZATION TODO: std::deque - std::list - std::forward_list + + // SPECIALIZATION: std::array + template class T, typename X, size_t Y> void push(const T *data); + template class T, typename X, size_t Y> void push(const T &data); + + // SPECIALIZATION: std::vector + template class T, typename X, typename Y> void push(const T *data); + template class T, typename X, typename Y> void push(const T &data); + + // SPECIALIZATION: std::basic_string (std::string / std::wstring / etc) + template class T, typename X, typename Y, typename Z> void push(const T *data); + template class T, typename X, typename Y, typename Z> void push(const T &data); + + /** + * @brief Adds data to the end of the buffer. + * + * @param data Data to add to the buffer + * @param size Number of octets in data to add + */ + void push(const uint8_t *data, size_t size); + + /** + * @brief Shrinks the buffer to the smallest possible size. + * + * @return New size of the buffer in octets. + */ + size_t shrink(); + + /** + * @brief Expands the size of the internal buffer by a set number of octets. + * + * @param size Number of octets to + * @return New size of the buffer in octets. + */ + size_t expandBuffer(size_t size); + + /** + * @brief Guarantees availability for a specified number of octets. + * + * @param size Number of octets to guarantee. + * @return New size of the buffer in octets. + */ + void secure(size_t size); + + /** + * @brief Sets the size of the internal buffer. + * Note: If input 'size' is less than size(), data is removed. + * + * @param size Size to set the buffer to. + * @return New size of the buffer in octets. + */ + void setBufferSize(size_t size); + + /** + * @brief Fetches the size of the data in octets. + * + * @return Size of the data in octets. + */ + size_t size() const; + + /** + * @brief Fetches the size of the buffer in octets. + * + * @return Size of the buffer in octets. + */ + size_t getBufferSize() const; + + /** + * @brief Fetches the head of the buffer + * + * @return Buffer head + */ + uint8_t *getHead() const; + + /** + * @brief Empties the buffer of all elements. + * Note: The internal memory buffer is not freed or reallocated. + */ + void empty(); + + DataBuffer(); + DataBuffer(size_t size); + ~DataBuffer(); + + private: + uint8_t *base; + uint8_t *head; + uint8_t *end; + size_t bufferSize; + }; +} + +#include "DataBuffer_Imp.h" + +#endif // _DATABUFFER_H_HEADER \ No newline at end of file diff --git a/Jupiter/DataBuffer_Imp.h b/Jupiter/DataBuffer_Imp.h new file mode 100644 index 0000000..ab67f1a --- /dev/null +++ b/Jupiter/DataBuffer_Imp.h @@ -0,0 +1,350 @@ +/** + * Copyright (C) 2015 Justin James. + * + * This license must be preserved. + * Any applications, libraries, or code which make any use of any + * component of this program must not be commercial, unless explicit + * permission is granted from the original author. The use of this + * program for non-profit purposes is permitted. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + * In the event that this license restricts you from making desired use of this program, contact the original author. + * Written by Justin James + */ + +#if !defined _DATABUFFER_IMP_H_HEADER +#define _DATABUFFER_IMP_H_HEADER + +/** + * @file DataBuffer_Imp.h + * @brief Provides the implementations for DataBuffer template functions. + * Note: Modification of this file is not supported in any way. + */ + +#include +#include + +/** +* IMPLEMENTATION: +* DataBuffer +*/ + +template T Jupiter::DataBuffer::interpret_data(uint8_t *&head) +{ + T r = T(*(reinterpret_cast(head))); + head += sizeof(T); + return r; +} + +template class T, typename Y> static T interpret_data(uint8_t *&head) +{ + return _Jupiter_DataBuffer_partial_specialization_impl_std::interpret(head); +} + +template class T, typename X, typename Y> static T interpret_data(uint8_t *&head) +{ + return _Jupiter_DataBuffer_partial_specialization_impl_std_vector::interpret(head); +} + +template class T, typename X, typename Y, typename Z> static T interpret_data(uint8_t *&head) +{ + return _Jupiter_DataBuffer_partial_specialization_impl_std_string::interpret(head); +} + +// Basic peek + +template T Jupiter::DataBuffer::peek() const +{ + uint8_t *ptr = Jupiter::DataBuffer::head; + return Jupiter::DataBuffer::interpret_data(ptr); +} + +template class T, typename Y> T Jupiter::DataBuffer::peek() const +{ + uint8_t *ptr = Jupiter::DataBuffer::head; + return Jupiter::DataBuffer::interpret_data(ptr); +} + +template class T, typename X, typename Y> T Jupiter::DataBuffer::peek() const +{ + uint8_t *ptr = Jupiter::DataBuffer::head; + return Jupiter::DataBuffer::interpret_data(ptr); +} + +template class T, typename X, typename Y, typename Z> T Jupiter::DataBuffer::peek() const +{ + uint8_t *ptr = Jupiter::DataBuffer::head; + return Jupiter::DataBuffer::interpret_data(ptr); +} + +template void Jupiter::DataBuffer::peek(T &out) const +{ + out = Jupiter::DataBuffer::peek(); +} + +template class T, typename Y> void Jupiter::DataBuffer::peek(T &out) const +{ + out = Jupiter::DataBuffer::peek(); +} + +template class T, typename X, typename Y> void Jupiter::DataBuffer::peek(T &out) const +{ + out = Jupiter::DataBuffer::peek(); +} + +template class T, typename X, typename Y, typename Z> void Jupiter::DataBuffer::peek(T &out) const +{ + out = Jupiter::DataBuffer::peek(); +} + +template T *Jupiter::DataBuffer::peek(size_t size_) const +{ + uint8_t *ptr = Jupiter::DataBuffer::head; + T *r = new T[size_]; + T *itr = r; + while (size_-- != 0) + *itr++ = Jupiter::DataBuffer::interpret_data(ptr); + return r; +} + +// Basic pop + +template T Jupiter::DataBuffer::pop() +{ + return Jupiter::DataBuffer::interpret_data(Jupiter::DataBuffer::head); +} + +template class T, typename Y> T Jupiter::DataBuffer::pop() +{ + return Jupiter::DataBuffer::interpret_data(Jupiter::DataBuffer::head); +} + +template class T, typename X, typename Y> T Jupiter::DataBuffer::pop() +{ + return Jupiter::DataBuffer::interpret_data(Jupiter::DataBuffer::head); +} + +template class T, typename X, typename Y, typename Z> T Jupiter::DataBuffer::pop() +{ + return Jupiter::DataBuffer::interpret_data(Jupiter::DataBuffer::head); +} + +template void Jupiter::DataBuffer::pop(T &out) +{ + out = Jupiter::DataBuffer::pop(); +} + +template class T, typename Y> void Jupiter::DataBuffer::pop(T &out) +{ + out = Jupiter::DataBuffer::pop(); +} + +template class T, typename X, typename Y> void Jupiter::DataBuffer::pop(T &out) +{ + out = Jupiter::DataBuffer::pop(); +} + +template class T, typename X, typename Y, typename Z> void Jupiter::DataBuffer::pop(T &out) +{ + out = Jupiter::DataBuffer::pop(); +} + +template T *Jupiter::DataBuffer::pop(size_t size_) +{ + T *r = new T[size_]; + T *itr = r; + while (size_-- != 0) + *itr++ = Jupiter::DataBuffer::interpret_data(Jupiter::DataBuffer::head); + return r; +} + +// Basic push + +template void Jupiter::DataBuffer::push(const T *data) +{ + Jupiter::DataBuffer::secure(sizeof(T)); + *reinterpret_cast(Jupiter::DataBuffer::end) = *data; + Jupiter::DataBuffer::end += sizeof(T); +} + +template void Jupiter::DataBuffer::push(const T &data) +{ + Jupiter::DataBuffer::push(&data); +} + +// SPECIALIZATION: Jupiter::DataBuffer + +template<> void inline Jupiter::DataBuffer::push(const Jupiter::DataBuffer *data) +{ + size_t size_ = data->size(); + Jupiter::DataBuffer::secure(sizeof(size_t) + size_); + Jupiter::DataBuffer::push(size_); + Jupiter::DataBuffer::push(data->getHead(), size_); +} + +template<> Jupiter::DataBuffer inline Jupiter::DataBuffer::interpret_data(uint8_t *&head_) +{ + size_t size_ = *reinterpret_cast(head_); + head_ += sizeof(size_t); + Jupiter::DataBuffer r = Jupiter::DataBuffer(size_); + while (size_-- != 0) + *r.end++ = *head_++; + return r; +} + +// template / string push + +template class T> struct _Jupiter_DataBuffer_partial_specialization_impl +{ +}; + +template class T, typename Y> void Jupiter::DataBuffer::push(const T *data) +{ + _Jupiter_DataBuffer_partial_specialization_impl::push(this, data); +} + +template class T, typename Y> void Jupiter::DataBuffer::push(const T &data) +{ + Jupiter::DataBuffer::push(&data); +} + +template class T, typename Y> T Jupiter::DataBuffer::interpret_data(uint8_t *&head) +{ + return _Jupiter_DataBuffer_partial_specialization_impl::interpret(head); +} + +// PUSH SPECIALIZATION: std::array + +template class T> struct _Jupiter_DataBuffer_partial_specialization_impl_std_array +{ +}; + +template<> struct _Jupiter_DataBuffer_partial_specialization_impl_std_array +{ + template static void push(Jupiter::DataBuffer *buffer, const std::array *data) + { + buffer->push(Y); + if (std::is_fundamental::value_type>::value) + buffer->push(reinterpret_cast(data->data()), data->size() * sizeof(std::array::value_type)); + else + { + std::array::const_iterator itr = data->begin(); + std::array::const_iterator end = data->end(); + while (itr != end) + buffer->push::value_type>(*itr++); + } + }; +}; + +template class T, typename X, size_t Y> void Jupiter::DataBuffer::push(const T *data) +{ + _Jupiter_DataBuffer_partial_specialization_impl_std_array::push(this, data); +} + +template class T, typename X, size_t Y> void Jupiter::DataBuffer::push(const T &data) +{ + Jupiter::DataBuffer::push(&data); +} + +// SPECIALIZATION: std::vector + +template class T> struct _Jupiter_DataBuffer_partial_specialization_impl_std_vector +{ +}; + +template<> struct _Jupiter_DataBuffer_partial_specialization_impl_std_vector +{ + template static void push(Jupiter::DataBuffer *buffer, const std::vector *data) + { + buffer->push::size_type>(data->size()); + if (std::is_fundamental::value_type>::value) + buffer->push(reinterpret_cast(data->data()), data->size() * sizeof(std::vector::value_type)); + else + { + std::vector::const_iterator itr = data->begin(); + std::vector::const_iterator end = data->end(); + while (itr != end) + buffer->push::value_type>(*itr++); + } + }; + + template static std::vector interpret(uint8_t *&head) + { + size_t size_ = *reinterpret_cast(head); + head += sizeof(size_t); + std::vector r; + r.reserve(size_); + while (size_-- != 0) + r.push_back(Jupiter::DataBuffer::interpret_data::value_type>(head)); + return r; + } +}; + +template class T, typename X, typename Y> void Jupiter::DataBuffer::push(const T *data) +{ + _Jupiter_DataBuffer_partial_specialization_impl_std_vector::push(this, data); +} + +template class T, typename X, typename Y> void Jupiter::DataBuffer::push(const T &data) +{ + Jupiter::DataBuffer::push(&data); +} + +template class T, typename X, typename Y> T Jupiter::DataBuffer::interpret_data(uint8_t *&head) +{ + return _Jupiter_DataBuffer_partial_specialization_impl_std_vector::interpret(head); +} + +// SPECIALIZATION: std::string + +template class T> struct _Jupiter_DataBuffer_partial_specialization_impl_std_string +{ +}; + +template<> struct _Jupiter_DataBuffer_partial_specialization_impl_std_string +{ + template static void push(Jupiter::DataBuffer *buffer, const std::basic_string *data) + { + buffer->push(data->size()); + if (std::is_fundamental::value_type>::value) + buffer->push(reinterpret_cast(data->data()), data->size() * sizeof(X)); + else + { + std::basic_string::const_iterator itr = data->begin(); + std::basic_string::const_iterator end = data->end(); + while (itr != end) + buffer->push::value_type>(*itr++); + } + }; + + template static std::basic_string interpret(uint8_t *&head) + { + size_t size_ = *reinterpret_cast(head); + head += sizeof(size_t); + std::basic_string r; + r.reserve(size_); + while (size_-- != 0) + r.push_back(Jupiter::DataBuffer::interpret_data::value_type>(head)); + return r; + } +}; + +template class T, typename X, typename Y, typename Z> void Jupiter::DataBuffer::push(const T *data) +{ + _Jupiter_DataBuffer_partial_specialization_impl_std_string::push(this, data); +} + +template class T, typename X, typename Y, typename Z> void Jupiter::DataBuffer::push(const T &data) +{ + Jupiter::DataBuffer::push(&data); +} + +template class T, typename X, typename Y, typename Z> T Jupiter::DataBuffer::interpret_data(uint8_t *&head) +{ + return _Jupiter_DataBuffer_partial_specialization_impl_std_string::interpret(head); +} + +#endif // _DATABUFFER_IMP_H_HEADER \ No newline at end of file diff --git a/Jupiter/Jupiter.vcxproj b/Jupiter/Jupiter.vcxproj index b32e5a2..b734a82 100644 --- a/Jupiter/Jupiter.vcxproj +++ b/Jupiter/Jupiter.vcxproj @@ -5,10 +5,18 @@ Debug Win32 + + Debug + x64 + Release Win32 + + Release + x64 + {367CBCA8-6F27-484A-BC6C-2FC087FBB0C8} @@ -23,6 +31,12 @@ Unicode v120 + + Application + true + Unicode + v120 + DynamicLibrary false @@ -30,19 +44,35 @@ Unicode v120 + + DynamicLibrary + false + true + Unicode + v120 + + + + + + + true + + true + false false @@ -50,6 +80,13 @@ C:\dev\OpenSSL\Win32\lib;$(LibraryPath) AllRules.ruleset + + false + false + C:\dev\OpenSSL\Win32\include;$(IncludePath) + C:\dev\OpenSSL\Win32\lib;$(LibraryPath) + AllRules.ruleset + NotUsing @@ -62,7 +99,51 @@ true + + + NotUsing + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_DEPRECATE;%(PreprocessorDefinitions) + + + Console + true + + + + Level4 + NotUsing + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_DEPRECATE;JUPITER_EXPORTS;%(PreprocessorDefinitions) + false + %(AdditionalIncludeDirectories) + Async + Speed + 4505 + true + + + Console + true + true + true + NotSet + 0.0 + MachineX86 + + + + + + + %(AdditionalIncludeDirectories) + + + Level4 NotUsing @@ -97,12 +178,16 @@ + + + + @@ -112,6 +197,9 @@ + + + @@ -119,8 +207,12 @@ + + + + diff --git a/Jupiter/Jupiter.vcxproj.filters b/Jupiter/Jupiter.vcxproj.filters index 1a6b281..436b71b 100644 --- a/Jupiter/Jupiter.vcxproj.filters +++ b/Jupiter/Jupiter.vcxproj.filters @@ -46,6 +46,9 @@ {37b5eaf6-0e4f-4609-8518-1b72f93aebe5} + + {aef2e303-8a68-4cf9-8464-c4aef776d3f3} + @@ -102,6 +105,27 @@ Source Files\IRC + + Source Files\Files + + + Source Files\Files + + + Source Files\Files + + + Source Files\Files + + + Source Files\Files + + + Source Files + + + Source Files + @@ -215,6 +239,18 @@ Header Files\Strings + + Header Files + + + Header Files\Files + + + Header Files\DataBuffer + + + Header Files\DataBuffer + diff --git a/Jupiter/List.h b/Jupiter/List.h index 972c737..ab0fbaf 100644 --- a/Jupiter/List.h +++ b/Jupiter/List.h @@ -1,5 +1,5 @@ /** - * Copyright (C) 2013-2014 Justin James. + * Copyright (C) 2013-2015 Justin James. * * This license must be preserved. * Any applications, libraries, or code which make any use of any @@ -24,6 +24,7 @@ */ #include "Jupiter.h" +#include "DataBuffer.h" namespace Jupiter { @@ -74,4 +75,14 @@ namespace Jupiter }; } +template<> struct _Jupiter_DataBuffer_partial_specialization_impl +{ + template static void push(Jupiter::DataBuffer *buffer, const Jupiter::List *data) + { + buffer->push(data->size()); + for (size_t index = 0; index != data->size(); index++) + buffer->push(*data->get(index)); + }; +}; + #endif // _LIST_H_HEADER \ No newline at end of file diff --git a/Jupiter/Readable_String.h b/Jupiter/Readable_String.h index 5459e50..21b15cc 100644 --- a/Jupiter/Readable_String.h +++ b/Jupiter/Readable_String.h @@ -1,5 +1,5 @@ /** - * Copyright (C) 2014 Justin James. + * Copyright (C) 2014-2015 Justin James. * * This license must be preserved. * Any applications, libraries, or code which make any use of any @@ -27,6 +27,7 @@ #include // FILE #include // std::basic_string type #include "InvalidIndex.h" +#include "DataBuffer.h" namespace Jupiter { diff --git a/Jupiter/Readable_String_Imp.h b/Jupiter/Readable_String_Imp.h index 2a03f4c..71708f1 100644 --- a/Jupiter/Readable_String_Imp.h +++ b/Jupiter/Readable_String_Imp.h @@ -1,5 +1,5 @@ /** - * Copyright (C) 2014 Justin James. + * Copyright (C) 2014-2015 Justin James. * * This license must be preserved. * Any applications, libraries, or code which make any use of any @@ -1266,4 +1266,16 @@ template template class R> R Jupiter::Readable return R(); } +// Jupiter::DataBuffer specialization + +template<> struct _Jupiter_DataBuffer_partial_specialization_impl +{ + template static void push(Jupiter::DataBuffer *buffer, const Jupiter::Readable_String *data) + { + buffer->secure(sizeof(size_t) + data->size() * sizeof(Y)); + buffer->push(data->size()); + buffer->push(reinterpret_cast(data->ptr()), data->size() * sizeof(Y)); + }; +}; + #endif // _READABLE_STRING_IMP_H_HEADER \ No newline at end of file diff --git a/Jupiter/Reference_String.h b/Jupiter/Reference_String.h index 63078f3..5b4fb59 100644 --- a/Jupiter/Reference_String.h +++ b/Jupiter/Reference_String.h @@ -1,5 +1,5 @@ /** - * Copyright (C) 2014 Justin James. + * Copyright (C) 2014-2015 Justin James. * * This license must be preserved. * Any applications, libraries, or code which make any use of any @@ -269,6 +269,11 @@ namespace Jupiter */ Reference_String(const Jupiter::Reference_String &in); + /** + * @brief Conversion constructor for Jupiter::DataBuffer class. + */ + Reference_String(const Jupiter::DataBuffer &in); + static const Jupiter::Reference_String empty; /** Empty instantiation of Reference_String */ protected: diff --git a/Jupiter/Reference_String_Imp.h b/Jupiter/Reference_String_Imp.h index 7d4d649..3cb4b21 100644 --- a/Jupiter/Reference_String_Imp.h +++ b/Jupiter/Reference_String_Imp.h @@ -1,5 +1,5 @@ /** - * Copyright (C) 2014 Justin James. + * Copyright (C) 2014-2015 Justin James. * * This license must be preserved. * Any applications, libraries, or code which make any use of any @@ -65,6 +65,10 @@ template Jupiter::Reference_String::Reference_String(const Jupite { } +template Jupiter::Reference_String::Reference_String(const Jupiter::DataBuffer &in) : Reference_String(reinterpret_cast(in.getHead()), in.size() / sizeof(T)) +{ +} + template const T &Jupiter::Reference_String::get(size_t index) const { return Jupiter::Reference_String::str[index]; @@ -233,4 +237,23 @@ template Jupiter::Reference_String Jupiter::Reference_String:: template const Jupiter::Reference_String Jupiter::Reference_String::empty = Jupiter::Reference_String(); +// Jupiter::DataBuffer specialization + +template<> struct _Jupiter_DataBuffer_partial_specialization_impl +{ + template static void push(Jupiter::DataBuffer *buffer, const Jupiter::Reference_String *data) + { + _Jupiter_DataBuffer_partial_specialization_impl::push(buffer, data); + }; + + template static Jupiter::Reference_String interpret(uint8_t *&head) + { + size_t size_ = *reinterpret_cast(head); + head += sizeof(size_t); + Jupiter::Reference_String r = Jupiter::Reference_String(reinterpret_cast(head), size_); + head += size_; + return r; + } +}; + #endif // _REFERENCE_STRING_IMP \ No newline at end of file diff --git a/Jupiter/SLList.h b/Jupiter/SLList.h index 95190db..3040520 100644 --- a/Jupiter/SLList.h +++ b/Jupiter/SLList.h @@ -1,5 +1,5 @@ /** - * Copyright (C) 2013-2014 Justin James. + * Copyright (C) 2013-2015 Justin James. * * This license must be preserved. * Any applications, libraries, or code which make any use of any @@ -213,4 +213,25 @@ template void Jupiter::SLList::add(T *data) Jupiter::List::length++; } +template<> struct _Jupiter_DataBuffer_partial_specialization_impl +{ + template static void push(Jupiter::DataBuffer *buffer, const Jupiter::SLList *data) + { + buffer->push(data->size()); + Jupiter::SLList::Node *head = data->getNode(0); + while (head != nullptr) + buffer->push(*head++->data); + }; + + template static Jupiter::SLList interpret(uint8_t *&head) + { + size_t size_ = *reinterpret_cast(head); + head += sizeof(size_t); + Jupiter::SLList r; + while (size_-- != 0) + r.add(Jupiter::DataBuffer::interpret_data(head)); + return r; + } +}; + #endif // _SLLIST_H_HEADER \ No newline at end of file diff --git a/Jupiter/Shift_String_Imp.h b/Jupiter/Shift_String_Imp.h index 41564e6..6fda85b 100644 --- a/Jupiter/Shift_String_Imp.h +++ b/Jupiter/Shift_String_Imp.h @@ -1,5 +1,5 @@ /** - * Copyright (C) 2014 Justin James. + * Copyright (C) 2014-2015 Justin James. * * This license must be preserved. * Any applications, libraries, or code which make any use of any @@ -93,4 +93,14 @@ template bool Jupiter::Shift_String_Type::setBufferSizeNoCopy(siz return false; } +// Jupiter::DataBuffer specialization + +template<> struct _Jupiter_DataBuffer_partial_specialization_impl +{ + template static void push(Jupiter::DataBuffer *buffer, const Jupiter::Shift_String_Type *data) + { + _Jupiter_DataBuffer_partial_specialization_impl::push(buffer, data); + }; +}; + #endif // _SHIFT_STRING_IMP_H_HEADER \ No newline at end of file diff --git a/Jupiter/String.h b/Jupiter/String.h index ef05285..ff0bd41 100644 --- a/Jupiter/String.h +++ b/Jupiter/String.h @@ -1,5 +1,5 @@ /** - * Copyright (C) 2013-2014 Justin James. + * Copyright (C) 2013-2015 Justin James. * * This license must be preserved. * Any applications, libraries, or code which make any use of any @@ -221,11 +221,12 @@ namespace Jupiter String_Strict(String_Strict &&source); /** Copy Constructors */ - String_Strict(const String_Strict &in) : String_Strict((Readable_String &)in) {} + String_Strict(const String_Strict &in); String_Strict(const Readable_String &in); String_Strict(const std::basic_string &in); String_Strict(const T *in, size_t len); String_Strict(const T *in); + String_Strict(const Jupiter::DataBuffer &in); protected: @@ -422,6 +423,7 @@ namespace Jupiter String_Loose(const std::basic_string &in); String_Loose(const T *in, size_t len); String_Loose(const T *in); + String_Loose(const Jupiter::DataBuffer &in); static const Jupiter::String_Loose empty; /** Empty instantation of String_Loose */ static const size_t start_size = 8; /** Starting size for loose Strings. */ diff --git a/Jupiter/String_Imp.h b/Jupiter/String_Imp.h index 3b0e181..9b65847 100644 --- a/Jupiter/String_Imp.h +++ b/Jupiter/String_Imp.h @@ -1,5 +1,5 @@ /** - * Copyright (C) 2013-2014 Justin James. + * Copyright (C) 2013-2015 Justin James. * * This license must be preserved. * Any applications, libraries, or code which make any use of any @@ -57,6 +57,10 @@ template Jupiter::String_Strict::String_Strict(Jupiter::String_St { } +template Jupiter::String_Strict::String_Strict(const Jupiter::String_Strict &in) : Jupiter::String_Strict::String_Strict(in.ptr(), in.size()) +{ +} + template Jupiter::String_Strict::String_Strict(const Jupiter::Readable_String &in) : Jupiter::String_Strict::String_Strict(in.ptr(), in.size()) { } @@ -85,6 +89,10 @@ template Jupiter::String_Strict::String_Strict(const T *in) for (size_t index = 0; index != Jupiter::String_Type::length; index++, in++) Jupiter::String_Type::str[index] = *in; } +template Jupiter::String_Strict::String_Strict(const Jupiter::DataBuffer &in) : String_Strict(reinterpret_cast(in.getHead()), in.size() / sizeof(T)) +{ +} + // vformat() template<> size_t inline Jupiter::String_Strict::vformat(const char *format, va_list args) @@ -268,6 +276,25 @@ template Jupiter::String_Strict Jupiter::String_Strict::gotoTo template const Jupiter::String_Strict Jupiter::String_Strict::empty = Jupiter::String_Strict(); +// Jupiter::DataBuffer specialization + +template<> struct _Jupiter_DataBuffer_partial_specialization_impl +{ + template static void push(Jupiter::DataBuffer *buffer, const Jupiter::String_Strict *data) + { + _Jupiter_DataBuffer_partial_specialization_impl::push(buffer, data); + }; + + template static Jupiter::String_Strict interpret(uint8_t *&head) + { + size_t size_ = *reinterpret_cast(head); + head += sizeof(size_t); + Jupiter::String_Strict r = Jupiter::String_Strict(reinterpret_cast(head), size_); + head += size_; + return r; + } +}; + /** * IMPLEMENTATION: * String_Loose @@ -342,6 +369,10 @@ template Jupiter::String_Loose::String_Loose(const T *in) } } +template Jupiter::String_Loose::String_Loose(const Jupiter::DataBuffer &in) : String_Loose(reinterpret_cast(in.getHead()), in.size() / sizeof(T)) +{ +} + template bool Jupiter::String_Loose::setBufferSize(size_t len) { return Jupiter::Shift_String_Type::setBufferSize(Jupiter::String_Loose::strSize = getPowerTwo32(len)); @@ -535,4 +566,23 @@ template Jupiter::String_Loose Jupiter::String_Loose::gotoToke template const Jupiter::String_Loose Jupiter::String_Loose::empty = Jupiter::String_Loose(); +// Jupiter::DataBuffer specialization + +template<> struct _Jupiter_DataBuffer_partial_specialization_impl +{ + template static void push(Jupiter::DataBuffer *buffer, const Jupiter::String_Loose *data) + { + _Jupiter_DataBuffer_partial_specialization_impl::push(buffer, data); + }; + + template static Jupiter::String_Loose interpret(uint8_t *&head) + { + size_t size_ = *reinterpret_cast(head); + head += sizeof(size_t); + Jupiter::String_Loose r = Jupiter::String_Loose(reinterpret_cast(head), size_); + head += size_; + return r; + } +}; + #endif // _STRING_IMP_H_HEADER \ No newline at end of file diff --git a/Jupiter/String_Type.h b/Jupiter/String_Type.h index 56c4eba..27a6401 100644 --- a/Jupiter/String_Type.h +++ b/Jupiter/String_Type.h @@ -224,6 +224,7 @@ namespace Jupiter * A copy constructor for std::basic_string. * A copy constructor for C-style strings. * A copy constructor for memory array strings. + * A conversion constructor for Jupiter::DataBuffer */ protected: diff --git a/Jupiter/String_Type_Imp.h b/Jupiter/String_Type_Imp.h index 2785793..4b91d87 100644 --- a/Jupiter/String_Type_Imp.h +++ b/Jupiter/String_Type_Imp.h @@ -511,4 +511,14 @@ namespace Jupiter static struct String_Constructor_Base {} stringConstructorBase; } +// Jupiter::DataBuffer specialization + +template<> struct _Jupiter_DataBuffer_partial_specialization_impl +{ + template static void push(Jupiter::DataBuffer *buffer, const Jupiter::String_Type *data) + { + _Jupiter_DataBuffer_partial_specialization_impl::push(buffer, data); + }; +}; + #endif // _STRING_TYPE_IMP_H_HEADER \ No newline at end of file diff --git a/Release/Jupiter.lib b/Release/Jupiter.lib index 386614fa51077522aa5e99c047a19c4040b78d0d..5d13d17cb66ddb96abe92ce1287b411f3d35ff51 100644 GIT binary patch literal 259384 zcmeFadz@TFl?Pt;HX=quL}bxbL^dKm7L&{ng0ghaWD+tVk0F^rK-Qr%)01iF=^na! z@<2dDL_|bHL_|acL_|bHL_|bHL_|bIL_|bHL_|bH)@5B*f8SGeA655O)vepz@caGo z%ja{_(|ymYPMtb+s%|}Aw|}`gK6SvHx9+a~o8P}+zkTK{*k|8<_4j$f*L@f5v(J9~ z?<40h_JS7kC(mI1)OF0SKEVp!DFXa$Sb@L`fSt?=1O+@N*ap876aw(^jNqPI0~p08 z;Fog++;=T25ZwQufS?1%kJ}MZh=jX9a>UGXWPL#|i|m+fl#`pd&crL=OI^z?0y; zX9zfX4)Xzpo1S8YU9W)7&oKY)qnLkmi9=zRdl`qTcVGpAtC}4A_V$cJ^CadI%)Cm# zF?%te!_D{vv`!6R8+^i^+n*-jC3~>~hbQm}*q)vNE{E;}U)VK(`|t_){4)Y(>#V@x zANT~+ZWl0pI4cm;eE~P$!3qT5!EYQM!zbXoiv-+qCMytp_cjjxujVp>!g;7;f}cDr zVB0yY0Pv4RT>%Q;*qwua{OydxKNm8e!?XB&mKEm0e+XW`T)^p%vI2*_@d^0g`2tP@ ze}W%P2Jkn00)Bj|fS2!48(fRms%2k3he;6(7}a4$XquSK~Dc54fG^%<-{@S5EM zfF7>_yc#$J|GG)Q96aZ6B|ZT!-Xh>dXR!i@ZSe{C7Ifk8AU*-FJ4e7Cum{187jf`! zhW`+J`4jQ98_s$n^+aACN+StMCc<_G1EWo`IbJ-`-Qe zO`s$A7TP7jO*;#?@pk5OKzqCq@Lk9N6mEYafFtk;_yO7_2mJm6z{lZN1n0ni2tNL} zfOC&x1%kWadju!U6>vQ2o8W}YIQV}@*#U(`YXl6y|2Uvc4Zx-spq&%Ej|n*WWW*7` z`;HaxDcFtRq_YLQ7v&+i26ajB*@pyNj`9(-Q8xtV-6Y_P3z$!E>}>*0Si^jRD=rbR z8Tt`?6|{iDZ>|&Y=>4of@Vg-azu%D+2!4BRBQ_BH6*?0JI>Qc@|(U^ac1App6r}?+F2?)R+$_ zeCkvIUj-h)l}iO|y_OXSZoEstiXB*i!%g@EEEy88FLWZ2v|hPzHkGb2<2*fzAY{O$P8dJ^>#@TL%=r{)m9uZs>;r2iz;5 z2t5G)r_tsKPI*|s`?oNk;M(N^u6vUC1lQgn;QqZ3mtc>Jq4UZ2u)+(@VTJ9^V*Y)% zGXH0YE%(e}{@sr<|K~?B|9;fjx6edBKM&ub(@*aK9DsiC4i5e&&SV^>cV#|74e^5D z=m$6yUU?;QD!{+AIr#q#9XJ5@zjtMYPrz3R-teS=-Dg+<;Gg#<0rf|i&jE404w$~0 zL*Z4UjKi+*eSrTzdkc8xMCJnu=j|e3uS-|~;J@oB0mm;zP60UX8V-f#LySWU`Vq8m z3EfHBksL1WJV;7<*}Z73s$%kT;K{-OYG$LHvRwdY;}fuTHx7lFrA)y6_yjcj1sroKD-dkDRKVu9u>yxj@CkUwH3E)U z#tH=gdA@)np2BxP{VV~u9?l9Jp1>#IdngOR6{s76FYYPedf*e>fOY`zzjGOf!Z*Pi z;NNn%fOn0;-heAl74W4Uk&^(vcr%B>{AU=4w_nc+1V`N^VEN6gKrnKvfC~H+;9r6~ zfZ$y40~D@%KtTCv0yaP{!T6;DmK~0^2zdEF1ni98 z0sjB}L%=`qH=ywHwt$_WC&2%|DFM&kjWGt`lO+Ks+>1W+URGFehJgJiSb^Z^;{+Up z@&NqLZV>PZ*aT4c*pCI=bQH!3Xm|f}zkvVUiTQxSza1iAk1LQ10(OGE30?->2<}E5 z5qubb6P$@Mb6Ac~z=wSSA32>B2!05g5q$J^0k61*6$o}&BVdP3tUz$u5dz+O7Ap{( z+%MoV*q7jQXkP^H-!1^iem~${@KJ)}jumj_Lx{D2cY!}a->U<-5ubp0;L8E^Iu9@( zae!bFb|jcuFJR;Ks7JuW{sBCQPr${`3V8FLtUz!ro)a7l9s~=aAHjip3s}1wD-et> z60jCFB{=Mz0@mXhhnw&TSaXtq<={=Q`ZNI}Z-So!2JaHk|0pW}{6AbL;7P`Of=Al| z9(#uQ1W()~;P?H^C-~iy0va3Ved*TJ_5uE*~L7x@Cdfp$P}5o|;7b(DeN z`ZEN41u_ZVjsA(?>azuW^Ht2}fY|v>z&G$a!AH*&a5li7e&B1NRAd@FLV1;OScg zJbpLo4Dg$W1pIC}>KO3Et^)pYFX{~N*Es?nMyx0JExrQ^-?);4|Lc<&hreC|JhZht zn*vrMZgF@TpMX7&6!3-``clB2PYHN8{FlRAd;(UXT@!p2ya4{EFXT|T5&Q^V0oxF~ z3ULzPU$~2aQ~!oK1bpo=0rwuo3ctEdzyl@Zo`AdmA>bEi4+OtDLcj%RGX$UBi-Z5a zHz2OvfVOwDfOAkU0RKYRli&lj03OFD;9kUzWA7Aj$yuyGaP|rTrw*|K!4A-u;44c7 zTzwJdQvlb%76b?0D4-v*2wr%)fNf63T-3?%fqw}2%qhsn0H<#gz^V8Id}yZt;9DO8 z{Ng^$TbwE2*iq;PC|xJuqpJ{C0Uv`d1ZUqN-~$K1=K!bPBH&W!NAS5l1YGtYD-e7h z`VxHhvH*6$C*ab#0$#X1bO#Ks5U|f_tU&PAs|9@dRLoTYzVxJky{|wn3Rt~^fVW+O zIWEB4A(!ASj|uov4fufTP;UfZyC;AVe2y^xZ)lHz!YP{syzhQi;IIOpfDgg`9FD^$ z;GzIN^C&BDI0T=73-=fB>C52{fD2&{f;ZnL;Pvnwf_LmD;4Sb=g6(z^@PZwYw*q$D zRlrM8R)RIYfDMpKaP6G}zCMK<8t|1z1uQ%p{Q=^{MQB?DADJuQ%)Ob<;R<{LK5~J8 z`&Oa8k6`{8+XsL)a|YnUz~^u!J^^R#9KiYb1bh^2hv1he@BK3Zetre!E&+c)c?o{@ zKmd6DGr;jE6TtsdU)D$iUFZ;85vs@T^YH zjAi3xU<|vmB19vvVdykGGO)yfn~a*tFI%~gU94TD?q)L!UZ9r&V|}WWHbf&YXucjc z8*<<#qh|6;+AOVH$c`{W2bBG7tQB~d@u`l=Mia}awg$Opr)9`bLjK`zN#61AA?9?o zE*KB-CbOba-`Ji?k{OUf9>NB~UP)5Tvtn^<-^GpT>2iG{ZlMbYORP9uZjVn@TBX#} zg9n$4tr{3Sq&Rm?r94sIP^*lsZ8xj+jisT|f>K;_oiiwIth7g))r}h~&Bcw`dRwc* z@cJlzxS~sZwJeQ=lH5C%m7hhiJTVcJOG7-cWW7;=*s9&IC>H0ZYIEJdl2U9*GeWUA zFGYJWXrc1F`BJTCp_%wdI_L!fp;+wK=`b)rDx?%~!3D>ma=Sb@J2_ct#ti@kGck2T zFIJ{!+FMHohZS>k!X=KPz-z0=R!n@==H-T8Y`HPaLMyhi zHAJzcR_RUv-s7`PL$Q-gGck*mEi(w6f&Un)dstG`8Nb+?LQFkcUp+`t;!4j(EY8ff zrc9jHj||Ewj|(c|h@q%TD6!xm3YeZs#c*Mprvxsq8?Q*j{#+|Y_cc9rUZ(UJs zwM*#WM8C$nxA8W*x1f_PmEyk^3=am~Y|!S5a~B6>qg!X-XAWuGzxatD8P2%nu{rri{p(tOl4^v$X$mGH75^5y5^HZlkO@f2>zy6urv*n$vecSxZAy3bjQS1hwf@9a0o|LyOZTmBE=Q5l?wd8ju=*|Q&B_Y z;>Je1acHACVQ~Y@Qxpd%<)Z1eIQVox=^}0IfDmSkN4d3dP&}#GM6;79XeFP&M=p5RGtpC2uX`e8%@mQTH>r^_QRto*_>3xW@Wmu zsbZ0WT#sg*r9hsCq}XoGQZkt#K{i$niXu<^Ey|-Sf<5CgnlnDntJh9dC)>ds`&e>P z0X^z zQl;3*pD%H4<${OhR83G6pI@UrPtu%9rI^e`vA|+8n3`?Z>S!zJS76Z`AsRhijjkK3 zHa5&oV#+XzjU7@Ko$2uIqBvK0cmr8Vr9534($7dFCm^0n5kmiNY?hbSRbrR+%2ulb z0mXLX=t^C@{>*eUrC-cXm{S&wsbX)=CoZ7PD=~EEF6Y;B>e{W;T%|;4ky5ohng*1` z%@_|mIt)nS8q7^6)&^8F{hluqP@ILY3CKm5OIEiP7GzI(wCq--C|{?h%tMz)Qn#g& z4e6$1w-Sq$V`j^>mZNWVD=jGB^C~k(3FpoojhnZ-l7cLd<5q1->lTvo5ayEA(@JyG zvRjevc z6ep`#&Y9JKPzpKY%thlYLA8^sjBu2IH-hbQwcg4sOJZs;H(jwf(9znH5gKU+b4~QY zR|(B8Nr`;#8Dq_2BvUgRC>AbC>Afqu6JNzAT{s6Z!UdI2e0MQ17pFYWlQbubp;YPu zS%=z-Xj~=e+Pbp-#Z9P@O|f`*w$I64?}%P39+u5l_GL$OC%&pLJ8%wt*#WhOzWn@1 zbFx_Emq9Y)QhO1Ns|2GH<`ZgUV_mB>OiS7a)&(JbaifkIr`d6=*BTqdmXDIsrYuYH zT-aFkpw~K)<-&qn1S1sF?ze#;wWEG1e_7c&KD7lw%M0et= zHYNwoVOw%Q?O{`Texx~BEb_!KZo26vT)tRbm9MTH(Vh6Jb?v}8tZN6<9@h2qBhATT zsk(O4Ev)O+`Rdvcy;yWWRO{NAz=?Mc>)JuF9!PU7mD(-2=@!=Y%6xV0h+Zr@AgXok zOyI=32i6bcq=RBTkmgz{wXWTC3+sBne0A-JUMxBws&(y5;KaKJ)(`92L9rf4b1jux z*KWFnb-gHGT|1%|iw=ltT{{yv@$P~3!@71*tOwFuOQqJen{HuUW0p2OvWZ6)gGAYO|3Y^*}C4U()L*!N>NX3@NG9_ zBTt)2gZeN@u#p<&DRp7u9MlAk&Y(@_I`_264%F_Dns%j7Tv=6~t|TQ>xWYt;E)>MR z(J?(qUQw;*kt)sLcSan_6wA;O@f7P}m12={7DSvfpfX4vRib^0SylCSWo9(&5p6hH z4!R}wX*m*>mP=fGotAhSoUD*^6m^3)KYT%t0;zfz$7J%ldCEI$2TU_JxgZ9CyfplD zm9(muVJBtMI=SNWdCU$@91t_#Xmx55f@#(6nQ@(RoE#BN#Ou`QiVy0oI5!^$?aPKv zS-^|UbNI~jUX7~?fweT_mGt3l>E{aN zY^|0-o4`=0Gl^9Mg?6@@C0IdFXq6}YxW(u|JYHVqxk5Q%v=ENgQ!uIAspIxI_uz?& zT{R)|2MVr{v3Q{1n%JhfMm~@{AW!uGO(_H4(b7q^pQMb8tS6KnDu3}d8i1=B-Gccr|6+AsVi5pT@dP$#@8vPt{tF~~yVs*Nl zDv0zT#$8s~lH^!z@gHLxomg?aV@L`mMyu16rF?%P8%ul@wG{jqJq>B6%STt>nQScj zL*R$2+}3WL-q1i{lHUaut+@*^F1%~lp8*RYe|0!y6}hiQAkBHD#z476#o^=!jtGhND&c4e?&4ky7*bb#;Ihm z1pX6$g#Nb)ztk%A5Ha<0_=7-O*q=miJWC{$!erzy7Xv4Y2NC1T_coR(G?%k#G-}ySl4;06fHXEK^iQ@L`_?3 zhLvVBtW*@}m_=9@WJj$EW6RAtj4fA`ARe9b2{qAbVNoKjLnj6it{Kd7>GxIR(YqGe(}S54KR3nqaMTJafXQ0FP3L#IqghqaaQcC}F#r)_H)$p>Dz z6G*%}v9s#xLdOpINSbKNhg}ST5lVbk&d~UE8g2KJBVvYK$3s2_*oc6+TP-b& zslFA-Kr``)J=`FO-V6ne+8o0zQM6AweWYtX6eIY%S(_@Riy351y5_^9l}!s{X4+Sh z!X*W*F1Qq@$}LK$%q%R|f5`Uenvb|mz@~>3NBHUOS-6w~jFhWQYvGVOp!|oFYqJ%O zJAXkRy_e99hvecu7pyzhSL&cU)ho=Ir1=J$c}?>deI?`cMd$3uF2M|hjfrVCqpze6 zwbsjlPm@YNK;bq)jw4VPj*Q>F6t&COW!d7wTngeWrPjzLI9z!={a$ z5$Qsc7d8&2S&+U`dJ?2_KBS45$guG+&587tbW>pD(jQ7Ll~ngHe?B6uz0F6espVg+FBy1o6bvy zJlE_#iB(Zqh{#v1C_Mj_7vVbNJ8;&e5BX#nIb=zf^Kq*IC@)9$$Wxz^k^|YuOu2Et zl%@BWD|ufoEsbrWUu_dTWJ)?x9_?sHR}Fi{GSDw-z|MNAtr=vUu|Ugq6q#t|xv0=K z-0?*KkdyijsdGt{o2R?3)K-iAx^cW|nUn)AINDk|=S-_MF;Aexu6$IG;#^K4k`KTj zQ>mI>Fj+jhc%(GEW^sH+SKm-{LDwu^jx=kufZBx7tZb?@aVmuAd7V~!;4PCu02Xab z7$1%|YPclGM2ZW-MyGH+oP23v^8PTfdUIV1IE!o53cc%-6^YBN66$bOjBsr!7G~7z zm0B+DBemI$)w(QuO$9RrQ*@0eovsnQKQH3sjmhdpE$amsp@+^4&j=|@x45}!DP7}c zV&q^+i3@5dUDmM9q=NFR-lWCH4pNe}AyK;(mKX##7jjx0ua%p}fN}?+xYn>+W_;an zZcS)`zZ68V^te+Nh})eLORHR;fBDk*qT@2~@kPhfyjPG?zU~=`n*|5z6GN3+h2PxJ ziCv{>b$-`sFZk*1JalV$@YSS3oix6H4c#Z)2|1SFuSXEosEo^!;&({T5%=dp>*rKy zFc05XbPyh3YzJEh?=gDMpYr^Ue1xtR&UBIIhPkr;{hdb1iir+X6@ zhP*3DA}Xq;`jI5IPEQM49>3O#9d`7g-rh~&8R4R!$ zCLXLr3s!>r?Ukbl9ZH=f<@acg(!DmwNX#aSu1!?V3#WTKbJOORsD05d&vxb3!_3i5 zyYPNJ?y>1TmuN@%?c~a{R~ky|Q=IIVtsimZ+R+{&H+NE+h;$9CgC_><#f2za_1t>6 zvZUyoyNLv8K_{fS<(Zp8hgz5!I_Z{eShZ<6nAeqMkMxrpR!_7O?JBwu*ST%P6_~d{ zk|nZeLaUY1ce?oTyR#dk-?{k(iRt{Y)qS<>(+r!YQla-xy#k+Wb;QHQHYyi7&$xyKZfrgi6MX&O0!bOK>liwF2MMK3OINl%)Kl*L9BrAcWiqq0l{xMwlyD&BiFv5GWrD8IMweZNPPB35npewY zpN)#jQO1y3&X;VqiEG4^y5*tnM5?)khRr@s)LeBj^K{iPyLLOVmn+xaX(=~(H#=tQ zn8DyPJCL<*lbc`r#7Te?!-#gW+RhJs!tSiPi=3Fh{jzC_ zTuy9u?#azlwEHGA73_sPzFR0;lF|{lDJMvZt*Po{dqri^r95&?4pZb7L%CBYt>i+w0ja! zFy*5WAx;A4P&x>q!n(xWJ&swT0PdUXDms-Rn_sMd#qp2 zSdxAt&B|nTOQqGr`t2FZuzsC%L$5Z!uRq~x+-Y4rSE9y>nQV&0s!dk{M0!`$D5Sd* zP)@}UShe-m=>FGB8vyf=P;F%MA6&95Ue20>BCKl>;H*VZ@+XKO138n0a)gtXG6W47 zBAUECDA1q>40Gxx<*oU2;A4w`gdfT?xOJr56npA23}V_=sxe3}Ifs@JM+o&;$1EqX zmO0cci%GaB1^YnyO*`^6M(i2ej`U1>ST21+Kcl^tS%k)hrbLr&ITa@=H3}CljTMp7 zsFaid_mE>w?S?znf>Y8OvmV=`ha7WiC)*;Q7Qz-mE!w>l9wD`eJS1VwX7V?BTs(>8 zD%Zv;v~HF@!(rH>s3o~uVB*~59m$Q0-icUHBcro+8Hr@h0T+2(7M8*MeI-gY)y;st z;6?F0P)QymYPQa~j1A3XBquQ@)FT_ppV+h9HLI{+lg3!x=tBXqD^{dWVu03-K3%hl zMl(7s5{^%W*KS&*6$5t7j~Wbb>oM z+3My1_I}xPllvWGB#AqQ-ZPGLwWt{{;dV^wLp6KClX40d?@Qz?&LqzK9qPwbRU50~ z=4Q2B8Evd+Y;2jLlqqAE_uhBQhM%k`c6bM8Z)wBU;1Z`3yy)!3?wLtC@guzr8rhGP z3TB*QjXGx~=|cxq8PqWitd%pWVs$#^Bx%Eshcc++crsM1P&dpZoy55<2Bi!wf*&fO z9uXDm)h)wfn@(rY)*5y#N%MP|cqk?A^{C_gXDv6Hjg-4~2i)RBwUvctw3&RsSJ!-8 zG|4HDqZc!ZCuc)0sKpuFN>XlaT~@A7)XWKGNiDrzI^H>Xr@HW2LCAt`+HuPjLow&0!YO zjY+!Z)14-OqyT> z7&Zy_LySWTZCFvxgvjEVUqfkXIJS^u>B2W9f&RhUOuffQi^pO)nG{qW8hU3U#%n^I z&_lj<&kTq2>cnTDQZ7$ylybQ6wajMv*X7sg<|p6_HIu zGS*g_I4p96EFHXdqjla~6<4T;GIOWgTds*q|#e&|-k! zOxdj#U2%aH{FH26WU{wNH7In$1UiUx$TAC@p^NMoJ>Uh6dZSBMT&QlQaFcQebtBuO z3m(v5NwbNA%5$qAE6_O$s)yO>3J!QPYG8h2E342I7ih7jyxFLMG4+-e=#&A;4ySm7 zF`rQp`CVFGGRPUSzc-{77^lsy=-`XI#rS?R$dQ zHIH~CJ;OMoYpY1979=O@h?V3M9nnjwI9~^XFqiVos6O4a(7J*;OQ};^cCxtu_r<{cH&5I;eUL@WHhe*0U zWfj$-^6;JK48KFG7025?EDlgo z&}5H;o3#cQMq0d_rQ}nTgUaHA@#SpsjiRA8dlWo=;cF>E@FL$Sx;$=PJ2hI4zb9b7_7V8Z= z=oQRHcc+>k&U_CZ@-`QcaF0yq3)uYF$s}v)(d8&Q*x%> zMZt_&duJAqFU{b)kjWOvPYQYAY<*r~Iq7g#Wn;EBv8FQJ*i=bXI>s{c5_BhA=ss8m zL%Nza#Sr=O*ebPFT#$MFn;1&#{>V*iXu;kxjZGycZNC4^fWuedBrf7TYyg9Z03V|T zeP%9S07NT_I_8nBfx5ERE{U(FoorSrX*A=GM7b!PkQPluvKiwB!ZsLOpi1l%6$;5*t(z?iR9Sn~#Ph_VvJjTpdnlAB{Bzh^}j5)TiZmykQ z?;Xwwi97rTYPGOeNX`yv5L8+_Vf-|t!U-7hk7L#8nXzalN_iCGqcO#$;Co||D(Wyo z>L%~%k`%$O*!xU9x>Wkuc@Gs?OX}mztut-Bt_YClC#=&s4~k@V zYPyw4uR`p{-7z5@7FTDcDows`#NaB}+%-6)h;*kZj@KHkN)S`@{Ly};w8$C1xS?8~ z7;W%PLPo}-LCM3-o# zchm#xkmF$k>tsXTnM&QUGfmLTCu)Vb$CWGkcRdR4*`1{Yt%N#xXPO{)(2JKCYE6Vf z@Z5+m%+ytdG9f{UQ3hrvH>qu9vE%KFkVYF?&xpn}8<3>s`$qAo0o18q!(T+!)M0wX%kJUuF1~cF<+f~ zUmt@V_@j^~~2XoT#pp&sZ zDgJ15-3$)gwl$QYTHnZ*^k_7Y69aNX7j*6g0b;t=lJ8c?6|<3vCvEj_;QWY`n#A&; zc>L*tO8nMRm*CFR37z<2H+deuPUxDPKH+?bq}kcLg{D|qQl2L0|DNWC`6%}H6DX*cS6U8SNSg2b+z zgMxF{X*8VTXu(3B+G^A`Rg5tO-QmCxI7+6-L*mF^&bV_+N)mSe5mpzjbbE>M&o~1h+B|n$u z+4Pvoj9D7RK38VNPtI?fkS#OYRuU)vdbdhUplih>D5-`=nz(s;yirTF803M{G=l>s zapQ+rCEH$#lMRbYcpjnTqc^( z%mJA!WQ6PiU;M_*PP0|)IqtVWWAXW%4tNP0yG!9W|2 zee|T#^Raz3d$aiKcmCeHSPWkv8qi1s%N{r}F|Ev7>n4&l%%fTDG_jjZVfEb7B(f|y zY8Bb65Z09qN2(ONNr4E>tR|BR5xov@B{1_=%4=X3l+^H4E@L(dd=q2OX8b;0Sr&41 zwN~TLTgjyp@{@3p#rRZZ{AfM8@+ib_H`-+bd*xAxU!LFt+UBYTHc^zPQ#z%eCn=Mq z2q{>R%2P_10?k97c(9=$HKipaG|kO7K-)RFAqNXE6Rgz9da?dekAl#hexO8d{bO=Y z)h8%U4390xk`o$j%kKnTQ0@Hqf~@(@JSBA6CYaLGv{)(=Q?Dhaz7o6s(~RQ9Cwd<4 zhEp-E+$1~1(I;h%QovEd)^l~OS{cv6iOZXpS*e_x26t@VbwjD$-u&GmZskosA@`J{ zo*9MquxjZ|ZsUZFhNi(oLzT6%pv-ye?&`n!{R{TnXWoK+_U%`HpBH@HchSPWefi%< z&bh;9?2JjDT{q>kC#pU>#VfFFd;mUAW(9Ui0e^1;z~{;M{nmR5Y!oo}mj!n1eFgU5 z{RQ^6pBLCk_xS9>_Y_#YTwr$}iQk^}+5YGI?93B=w!?dTcI8)mHuP1W&3k2m?eVq( zd&^r3?EY^S82fU89d~ho?fAL^n|DKjop?rpUHK`Wo$+3u%{kd;Pu)~tSL|9~&w&3? zcl)e#w9oF{rNDN$y1<%O71;J|pPkh7*{f!Jw%0K}yBTn5%V*mFPTRh~_IgQyJptGT ze;;>wf$jQ*0=p0J%;%x&Y=Qj)aC@!54xcVCzg}Q>+>F1!Q(%t)7JawC&b+0-Zo}u? zU-|6T^9t!O+Pf9l8Luv|-ChG803UyE`d56P1DgQ0 zytu&5dQpLG3mE+tY!5gGcH4cA0=sBOl<8*Z@MWKEe>LoImCw%mlF#Pi^SZlycKJ_W zdwf3fW1rplBcCn9=Wz|6T{Ppf8$R!|!OMO2x66FC9&pF!e0KVGeRkEIC>wAe|Dn$| z0G|22&rZ1AXZ`rR{5GGB!g=lkocRNvZ3{U6dp_F(zu$YS&sG5*`?k+!pwpiCJpU%t z>9>5gGd^#>5%mbz7BZf=y}*tDG=G440!)4!_Bp4(9>?cV=fZw>!S*Mh+{YK#W%xYd z?><|z2=*I5T>q0d4d%62;Z<^-Qzas|q>8PDOD*Zl_m_-KI*{SLnPd-%$4QHKw~&VN9?;rk8v{VDu51iVS$ zo%cwA-T82VZHM3PeGs+>&Rg)?k@)R=&`tcJz|KY+*#_-nIoipBKSSRq@cl{D?H>zl z&p)BA0i%x>SpQ$aAD2U{-% z9`w8bdYy1M+S=am1?YA9n;>IZft@>y=b!P}O zFl26dzt5Im>$4}XgHPjgulu3PU7)|X!0tI2ZRZ8>tL+fe?t}0A4Dkjr=266$qkay5 z1@4*OMohXH^6~wipZe?oz#XqeO!$P)cAbXr)O_{;;?b3_MBDurl>5K&JK)Gq6xfq* zfK7KVus6Zy9;u@}0Imkj=&MjayTZ5r$7d%#;0v1&!!{S#BY;Pb3HV&JW4kARcD2S2(3vQXD& zT@T(jK-PBxYZ%6$eRbV$Shiyj+tX6^EmjLfv z*y}p@WEnm^37@XQzkv7H6zXgv{B#5K8VBEHh|4d>-#g>;|9p1oKYZ54_q%pNd%*X* zpGExmB;pL(@EHrx*7iqxJsNTjDzFV`?>nM?e*7`Cg_}@j*mLS$ zwZJ(T{1(C|4ul`CMLmu}SA4$nFnnK+HUcs_R-(QENA3yVc>{bOpEtc5{S9E# zD%3OL)rE*9ha*-kgg-okw!6!P=qFLu$58I0?nPhns{$)M06&F4-SrFj3cl}o0s5s+ zBc{XeZbn_c^BnjV=xQH;-2e}P?#^T3Qhc(9|a%y{vF_Z0PJ@QcwclW za<0$8@8G+&&!hc*7UclU#qZmL{|flhY5Nq|)o(>?_%dSGm*9VUBR<2|E_oYh(VicB z3uy8C5oo{nd=2p*aK_(!w&@hKf%kz2;F%Ah9THpw-~3F09Rk?@!UDS-wzvhKx53}< zdOhm)9k4z4?X(^G+7}>x?FhLqMH_^VAGZPh8`{Lw*TDn!I2-NaB>2(XkN9lwGktai z-~#-;3NiZ#lzsa%kaq(1{xIqnu=81n-GE)-SNs1G`N#bz%g-VI4``1+Lt6vvdOXU7 zI(i&F@EH8g{}}oaz%Dny#_+{CA4l#8m~#$n4Y&$?c0lYp2hWd09BaLRvA3`hZ?(6| zdxv+pcbNBXwt$_;`dB}k&la+M*gSSUd$B*qf2qHNe-qp6ZSl5xo4i%*o9s+)gE!%g zdn4>d_9gFM{er(MdnMb}-^TwcyO!%DKVD?Q);7xqH`8uog275f)&A8(nz!av;qckgKb75?Y_fARP5Z}RW( z&-1SFu4CKz+xzds7~s9^J?td*b@n3vCH}YA4eX=dN4&GV&1?(X#M*3@z1n}3|0?zZ z|7+}D*|*su?`__W{wn|F{(j!B{?7g@{ayUm`rq+?;J?P-&A)(sihYuu&(33?U>|4a zvKIT0_hIkT>=bqm`xyHuJDZ)sKEyuAPG@JakFXE3GudhE1ML0mRCYW&fgQ(=W$$8J z*>X1P{kJ#I-`{`6oA3Xx*YA7&+fa@B`OkX$_>i?IwxBry)X8%d=js9P~xA=ee z`uzX%7Wz+n|L*_Adz1eUZ(skP-Xi}${QvP5_^22!o&To9vt34c-^L%e_mz&w0!JTfOgj|IXHU|LMJ&9qb+99pq23jckHd z*d!Zg8`ui(P;U=5!;WF!@UHiE@z%0YcD_I0FZKuhL%gzA@ZRXX$@{hUN&f=>G~f63 z@=o!0WAF9v@qX^z>z(ag<=yT5%-iVy**nR9$h*vcmhItvk^LY0H}5sixm{z2|vv@IK|g z$2-Y8*?X^dv{&=$-n91$wln*bcZq+ocZqku_bcxc-UZ$-yoA%zesrO^= zC*C*x%h~7I7uXVi$Ul;m*~{5G*%-Us`+;|s{}KO8|4#2mUfJK`Z}z|Mt!Ia_L)bcY zw*OIoF1y+LmiKM%Cht4m&fY7$w*Ou4NPm+*>tE{~=6{x5!Y*Z>V=wpCc}IE&u^qe@ zdoS^}_g>|#^KbMI@jv08>!0U;+&>3F_b&f9{{Z%O zwmK)@Xy_VPZKEp0# z7qN@k%eC%e&G;Hnilvf5bo7{~P-&dy4&qJ>>65`!#!p{Wtq1yN~^r z-Orw2e`0@TkFh_nhuQDgZ`kAPkL*$QdzKf!Krb8QFRy-sgO(opHe!D3gwhGZyK59>loI7>Zvirsas zc5{|arx+V7w<5#OhGFfR>>fE?atNJ@&({7nyr$_AJS#*+ft(~e)wu7RMC0n_!k!BL8MF=7UeT=tdTRKM&BZr_i zigSC=UbBQ~&1@x-ZOkKyn{~~ovR!SxPh^&~Bllt58}>N&1<^VC7;3~H3z9C(A`tRL zON$%R(`D?8GqxQqf@p($2bfuIbaMx^v!W`6<(TR*QNmKhE>PNl6KfT;G^J2M{3Tl5 zV?mr2tVV|PbGf?HPX*WERm15=GNBeh&>mFTdPuo8TNx==vFtP08?VLZ3?rv;rxS9L zXE+7!Db}-~26fK`W%^_xTFC&CE)P`!2Z!(?Uxt?hBRi75x4ou_|Dcnt34vGD3#bKOiyVV9Rv%%uqw=^ zOQHn~xb?J90zZ+hAtVd8MbvUr|Fh)O*(0TBoIL5E|ikKSoBSWJ`+bIvZ80>;PFa z`4H(Jjuv7qY}odu;UKP;<}xapG?o!DGL(2E*Te-H<$81-AZP zbG;_ozP|exxX>UTfOAYuE|6A2O$);EC|!WA_f0c$P8K+6%DS4-Yg$G+jY#7d#;eZMAtAO=PY%gaG-JT?y5td-0nmX@+%ahH#f8q zCvo<*Q5EV&V=R}d5*kXEWSPt@SWAfR+{KZ|CdLM55pTA8b%`9T65RQiTaD2FdwFLh zzZx^YCZe)>cCRMCY&E|Yp+S0hS1UiJvja_pL3(s=FMNbw@|s@{p+?Vchz)Ls%&$if z_j-A|WO%coNg31qh+*>$>0P3QiIca--6LXO$r+#+bcok$+9J(>4HQI2|Vf`>>LUqY`q=fx)FuFc$v{~J_ zk=_(1R}x@$)_Ri>5es9dohULom<)%LRtqp;%Ns=pbbPE92pnlvCaYVrUTvFn@5f?S zYMDX_M_$8%W-=Vu8Q)b62)F2B^hyK5vWuW#@CZ?rh5Zu<#uL)5inwtN&tdu{RM;#W z?)N4naSE`FO?*ypAPEbv)7q?uHr$LtkQqnPCXJNT#(=@k{Z`Ip)h_5m7?e(DRq)e6 zSH|Sq5G*5noIwiv(=aRRrW%KvBGl7rO$DJdYgNp25d=*yN?65%KeilO$<(1#j&CK)YP6w=!LwdSzaN z6P21%$7}8UU77Ge2V|FC)ZCqsi@GwAB|3I}#*&8iBJCY{iB^(%LGMJh6;!jyH)wHU;E=(p;wjVAtj>rP z9Kcmpm0AUtRw^a!KvM&!JSu11zFfpL&*hp+n+^IWXZ)az=fDs9r#vKG_fO8kg77Tx zs}4atj)HjI49j|Ego20 zhA7>-4~>OfaB9b^*(!Uoc(Yg5WhHX=7d%XJpbx?%t1gmE_zV^WfD1>H*v{ z+iI<-Y^v1s*#vGqFw}Rf0vcAndtOLyXCiT#36X@Cj9G6wA zh}u>&MlNB3MNDQVvBx@fGetb|jd1vlfZA{?ZUy88;@oU^2NIUX^W&)|rESn|T4S{a zj+KvF=uiRG;>K*2b||t{Q~jS#989v}t4> z=WDNdg*NJw)s3Mm=9Ni#0lb2DRGJNe=oUhZ%4B)A#@&anaxn;^3urh)%f&0=k`#{B zn8k4f+E!@lLC^?S1-2d%)M3$eZP~=7uM{$&<<`8m66>ywv6bJWP0BB=H87{4le*GS z#n63apt~TpscvG@R|MYg&UM!Kmit=ec1Ae+;Q2y(LWXcY*P#+$@T2jIx zjG8$0m1IUnYmAwS0!_x`!erXS$O&0h$Y^DGOY+5f%h;a>L2_lKJ=MTv*V;K(UN(Y*&)TbJ+cUUd+7R>czGST0 z*f2X;3R}1N#=2wjs4&sfMr{x; z#RG=600S2fA0tK@97MdWLmm*K>bfwMQ|RykMJEYL(C-BtR#fU6+f&*eTufrd>b3M( zku{o|D$OVvHn^6-5>ZnL)>?HDk_89estr0E7-~G#XzCN?r3N+8SuYLE$BAtfXJXP< zig>k3FbiQymZ=SL6O(Ga0~Yw7!5ic=F7d|mM*Jt zI|R>Z3CP?h*U^r32aZ@ud zamV7)>mf>VG-NXwFFMeCax)C0t{~J8$|Vg<@m{Qejugn|qsVpCdVXJjG@C#qL0#Fa zBJ9#60=;%JVlYi;=WLoV5UcnCTXZ+!NJ`r|$aNEh!iZ>aD=h=(LywH9T&JSAEMgd3 zGGvH{id7t0$xg!aFDjaSVWY97E1n}U(>sH)5J3mak05lPc*$aSXroE5Q;nzJL>*r6 zN*m6VL6RMUbF%_L)TIT|Z3ni78feIj(LV0DQra15(sFQvx=WWE3k$oD4hU^Mr6aqr z00t*P7bOyjp0U#u*Jxd$M&szqqZ(wlG$PO?e|xD9PMd0t;e{i^(ACjKAeAE_J2VdKGUB600uPV)+C00rYU~ z+7+fr#c;Sm@6e3?NBG20fCtFILf8$kXPEj$T42Yb`Ur!p5e@nQ$dvvW{% zz50#Iq6s(65GA83IH}{ZHo0VuB;6Mc3sK4&G0n}JfMHJ3yh2=zL9jWqI3N=1Ha6jk?a$!_5sd zc&_(q$$^8&IfGS^`ZWu1!x0pW`~?=CSj?BT@MTuo8VpW9((S+rS6Ibtf>)ddMyB2= zSR@j&q4fa<9_CoVmj=W<_$y8W6Vq$b;Eiw0M2syBTnycuvL=vN@qR8n>28jmV(!yU z8dP($GG3`}s-zk$R^9XFj^~!6JHoa3z}l1%Hw20yZqP&bxY4X^thU;iGZF#AwhCAz zc+Cpmft`Fg(yW*g8bi&5b~TYDnxmP2WPB4RN=pNBZN-b{(+$*I2iqJFjgc#9($k># zYgW>n#dM7(M8|J21=}QIlBa261k{xC@RtCA0=lAG@*+O8?u=9fGhS-F&>-AdFh&OD zcWDws^V=6o!Yxu4QJ8^RO}Dq1PjU(jYCHV2;q>X0VGAJ5bzHFTY~cW!x=^^)sBNmy zVqRokshF@98TOFUiw9P5pbB;mfN!>h!F7~MRqK-tkxm6f(M!AZI4-G|RG1u8a%nQi zg5tFJG8AJs$r-jP*j}OS0c`mkm4H*ido;Im@O&y#0s@jYq4;f$VuE=h9urj%o3zi9 zVoj@2WhOS9$UrMark~$Vyv>uYma}K5monHQ7;6)Q(MHOMqPUVbO15!C4@&5?rMAU4 zN?78fc{!hO7n>B6MUZ#7#VK3K$Veh#x4ir9sY5Z)lJy!5F z?`Hsi4XP#%X|-6@SlpPQ-KZvaS9DoiX|}7ARqWzMrm78ymNt$G44OxmYyvJrmKF0- z_1RY{0#UzEF%ZJv^w}~8b3_X`h^a8`Vlxx1m|%mqWUjvA&J``c3MDo%Q#?-FZPMLJ zDwBOm;zZL)ton)l?Z1vSG{9zv`FjHrFdd&>2FDc#qnm z>kn5{CSAg%XmJuj)^!bHbyRDrF zV;=NKLe7Mc8^KH$HheP%32xJM6WVw{!;Tmu8Lri*i2;A~kd|JGHC4KaSJ{KYg_rGI zBw;AbN!9gxr9AS&Mu=;{=>Q<=xJ=n5jgGjN&eru)a{L^C%~;ywXw<+5HaDy7%4h?- zmyEB#OvwSC0U8Txie4^-vo}osk=K9vmsJfc7b{P<;wKpPMQ5k!e;rF~Y$q z#wALqll4vWV-)&Uj=y4Y(;x&ZKg8F}a9hUDsx1{)d|%j~#8}ubt6FUhRmSlmsV1W> zt89tC(u?q<*3;EG30v3?Vr-fa>&s&jF=H%$r};B!A};wTT{-BQ5yTd^XIfCts-nK9fqs=N+xJ>Q9z0*m|2^n7ds zCn;mc35-2sMA5igWzdQ0S-1>8vJ2zL#at3c25K=(U6{*d_L4PBY%m%uN%s~zQs}DP zCc!Wu<`WR^BD>8d93>?x&{i(d?K|=f@)JjF)eG|7PN{8{xd!ou){vKnt`Lr`K<8pY zydwiuHqArPzPYirV#Ga^9mi|~ICHbfqSBSifkv7UNw%6S>XegaO(GcrLMEB6Xu{mw z>gs`mIpdd+57h(@FUWYiI5kvim06-JRbeGf*8_LOF+Tm6@JD?}4%q7m(zdsC;*rtP z&7!Y_wF0#LTJDey?=wZ5;maf<`&m$RL(>FtYGtH05TzGT0!?o3{3WDW6T1FWEufV^ zV-Sw7E=UzN4R02W>|wx6YMYwvM2VD+i1_G`WJYO)bbge^N;^*)N0y_TKhg9#S~QuD zvgO}AZ5#SPqR!l@WtqwOm7pmk(qSEz%q2PhobbPR%$wECm@s8w4wg|`YZiWXJG630 zsHR!2KsMER9@yHjgZD#f|7NC9nui%Jt*-utSfR1PN2iIESiA_!L8d8#L4Z<>^b0q= zy)}5ML=8gl{x%9=nzwdJtTpJ%>t9==1_DJf1CDG2eq9OH5yz98VVqDJgBDHUgO`rk zT+&FxW6QCWie8HIck_|G5>vF)7D7}k{Vp9oKNH=REyv?L#rcOe72K5#Fm<}>FFIDd zK_ut)7q1!u%|b&moK#Qqm6;A(a-({LkwyMt1XM5$1~H+mC~MO%SukCmlH!+4jFJe} z1V*+&c0MxSA=Q|#CJ0GwvU>jc9rfMwlf80Mti4yBuj^}*ED-zbF znXM@*p~8uqu|STjOaTP;Fw1u#(j|3DA_A+p@#)P#+C>~K{+22&Q$2MA4GH?kT6F3}SGx1_lOHGWz(xzue`gJ*yiK%nC#2FZBBbhx}bW0~vCe3s? zm4&e_y%M_X+(Msg*~RG7E*niE1GAuNk}(@Lt^7$0F-_)74<1dJnrzLYgXod$!!lui zaZ(jEWxiZB>Yj~#S}0ZTb&GW2GVaZS-J)vKcBAQ40CkWi2T%ueHGuBdfd$-XdSw9z zX|e?z&{Yczbd=m<);*mk%vUDGRmQfCO3BXkn;~tijn1Fsn?y`8wWW4+02W{C8aBE? zyXy?lS&Cgbfiy9&(k@HeP~B*{(oh;9I7pM-)B#;}(^VZTI?7I2UzTfhNbwZQ5Q zEZ|1dD+@SClP%zYu3BKE0}Hs(^vVJb(qs!bpsN-*EDE~D0Yd6^p&O0Pw8{*HE1TX- zP&i1F4e5Zc8uIXLL&~o_#`aZuNw>~y;b1A6KuIu2_C!(66?a)lYSa8n5--neiJmsM za=MYE$~rZ4R3EFuGWA(h8r8rjUCVfX?->Th+XdpYITS5szN#WI6YS z)QVH()!1o+gZ{9b%|*Pd^N{`a-=r7`J+GuC&1OS?#Fo{>va*7Oi(tO|ETO_>-n=xA``b_YY!FtJU)Ymi$$ z_P6$$xipwgad#MR26`tktx6}6qvSds@EF;u>W0I8+e=N;aZvJm8kAiBe$#S}Ufi}p zO$X7mMjI~rtQUu!rW3z}Lg8N7*eHh$tdCBi3tBBi2iLf0jz>0+wi4ANDkSZCQN`e8 z)i4?d$5Y>ML4n-V()>_B?s7YZxitNyjyVp?lr9&`^ElPTOjPKE>zEw*dwzrrB-A@rNaXGxe$S;+3`{g#isa#mg}LVWN^XKjOoBsuVtDg$Kxk) zg~h4TS$5*SK<)B+L?9gcI5>2m+?Q^UsM1}52ES38FwW$RkG0xO%V`TZw*>Oz-e|m5 zDc5IpM`rVLae{&oRx?<5p;?124amo9jaDTwm&c8Tl|r*_!f2(epgbeZ^Y zd{dVxcN^|}(9FBvVdx|-X&64+q#Kf;KU3O_n3x)E(0Qij^iZ_#c?Zf)$!D}e!gQkm z$$)e+Wxms^!Hk|N);K-F{w&I?+sdgNV`(UYPMtP!AbIMx`DY~4txU!NW zJ4jp-2-CcALb?;HwDcb4A3=E>Im#__qH@e^WwugEuOh>ylDHd~u+N6VwN17P4w4Vt z!hw(6_0f=(PNE!WHp^S{Eg+VZ*Ki4aPuEUkkELS8HqfvUHLuwalf}dIR%8Kn2vH*u z5^0d2S=5-+Y@j|dRH;??SxS< zgG%k8^APr^hjtdJbVP#6l1o4T9p4j^@q8mWnygWu{n z1r5*82Km8cL1>#qnx5H9(urNqfRy-5kJlkC`!_ zugb-^hTBRwzwj+_oNg=O)n#Pbt<%NBS{G?(P!d72!cX5HrnB#pW1O{^B+;i_lORh@ zMIMIB%?x>syvD{vD*KOtJElznp)y09_|{1STgRPA(-_6|5rG4xm~$tw_pgF;5;4U# z?KsBkNBN8SzTjMNNiz&J4O<0`tmM01y5%HQ8SFHGx#3o8MP-xe0y+#s4gMhx#gElN zW5vz2T8~s55?}h{<+!AUE9u~n^a=-r;o;}}4Pmk+VE#ZJmjyk|ZAWJ=eww>3Oo5Zp?g`^n zXQuED3$yWtVLVu&FNu>Bsw{prSLo7tm4fUoL78D!rbA zp0*S9#Rcne0|;&i)3tR|e}|^NN~x8AM`)Nlyu?*wu{yMjkXMSjp3q#c@>@6*eJPHc z)m=z2xMZclF;JS7N@)ZOTVYJB`bsLNWjGT}fBZW|izSLfhzX^{ypYBRjTh-Sn<(Po z5&#TF<2Q!KwU%J14+;iW{nBexR3Ke7r*j}vfI#)pH3P9O#K2a0CPsZFl@GQAY85dQ zBTQn{C__vf_ZAu>SHeJGx0uciZp}`+vsSwSun@smXK3@3u9{J-D7V^T30pFZt)=^~ zq#9XKtyhvKl^aW&OeBd|^jE2fpcZOHW4v6895Jm^GP2?fY0l9QQ4Q7Hr+O>D)KF(d z^Xi;=%N2L!9Blq-;w0`yjQyS%S%Ud$LxIqKR;Ltl2&|gHOGzpQw*mEyKg(bp4n8D;9DWw#O!ivou z)ka4P1nZPTb=8U@F1_oK5-hvvkw(hZrnN`Gz+H*)?%97wtkoVSJx?LeBN%)rF~MNx zp_8Y*2FWN)@ig%!J)P(rsA4rMlhrLWS~WIHgSbS57Oz)&#-(>2nt3M_<%rRhPzmFh zE`~}5E4(+ab>BWajFb@>UU8JSnnJ|ba;0n$5p9ccrlDnvbo#K!6rxf2VFPNovIRCY zoA5DS=NOzzey@#WH6+kw04hJV5e0OeBwefx&casFCRTl=1gCZxYu7uT!5gLf zWca%Z%MFmxElbLqGgN$DYHWK?uenKhzYEWB>zC2o!|JG_H#|+HH||iw;2B%}(eCM8 zk5d1kLQbT4tY&1`smZ!vm?|_@fo#NyDyco6wn+vx#085@gUQL{>5AZ^MrJX&WlxCJ zQ6;BH4)efQ#d7Jd5ve&EKa$1ZsPgI&G^gBbRpSV9eNrlEW9o(EqqQStvbkw=a4g6C zzW&6F4-p1+Yp*o5nk6#5zG?Je+So3|G^wMhwq8s_Q!(s(#|X!eu-iDp}5KnowI3) zP~5*@8cOkp48rWrphJcrOLV<~CbruyLT!x1#y%+107goaObmg-zS*X7ELiR2Iv~&P z-5r^RMKbs+vJg2b>KRj`0gSeHFrE`_F3TA?c5JpTIHqit(OzSVsqGS#m_eCcIul1X z_wR)IxzQ=)nv5c`jf@qRZC)d3DAnBP6boTS0h4;xc|Xhgg*e1l>)7m?OjFllF;Uzn z5z5-ND@^a9)fMQ~mcy<0>Uxf&umj(^cEPp~Sc*hl@rf-$*GHBThn^&s+3W8NHQHMq zmzqeWxwKdnBeL8{6Ow&~)ZkL`ENjd}eT{Y405ZjB*_Yyh)8+Q~ROaGDZWLuhN)Ean zt#;)SX^K@d%yX(V&cJa2Yr3qCguN;(mVuQwR)Pj)n4LE7jFHD~*a_;y$}|9wdDZFc z9<13i90pWxH)i@Zaflyqn2edqJ6NJz=uWw=T3<-F>o!Z$Eg{6iods5yOXCUb0JE>W za*SSG@rgsmOr>(PAyQ*Mlr;Gu5EJh?(kM%tjp>wW2u)cED9NwQZltX}(HwUl0*JEN zA{nbn^WzhqW}3L!x4Cs0)^68mXr>!SsikOEv7SOV85k*mK3Qy37TdS5F{)W9PnU+) z73Ypmm78PjX1UsKVdrhDJprc>|3~WspplCJZTRN2H8Ck_zJ0KJ^;|^g6>K-^x>iT~ zaHT2*mcE5ajY*}z@@)OWA~c2(6gXy%y1*UV^~vf+zNS-K{D3V#dsZ6#@o! zrj=vLYOk0XE!i<}GKW5CwNA{5uMjY>GOaaG7E;8l#593{m!ZekEI%fOyvt9&g)ny# zazbNgptwb|GG3`}!h*&`)IoM71twrwj^a|cPXTw6Q?wI^3At*tBb2<+u36bwZM8Ag zC<2vji-Vj|H^uR7QHWCB12!wBw9inhYHgT^wE@5^D^YPKuJI@#V5M~<8H+AfN5Ia# zn+%nOoI zYv>hFg0KZ|WKe$boMLW%^(gG2om-JJLs7_qT1|IOh&10W@Ti6IO`G-+nn2cZ#75?Y zv;a^pNUKrX#5dv~;Y~%SwHN{oDcO!t!b)|IcU?R z%pgt_6Gt$$D#nDr#m}lRCJB=8Rt0EWfCncY?#*kV- z%6^VSO38DaEYae7+AMM2yarizJDWt5Q84MrnG)FwCrl`YOqPWj&w+Z@X<*1psi^O^ z4332rxr&3@7TH@nCY6iBWG0+l%Joqd;a;{>Pl9%#9?wh2hOJ{XP#RDpQ-I4igPC9D z;cUCHRjTJpo5(0o1R|sClbWlMKobisdaY_KZp_f(3Z}-R(Qa|2*{)7jarTRGtCKmN zpxTut*CjKBmu;I;s?zPtu7R#!b*%{GFWYVTlsT#@e8dckb`7kFgFF`uugqNhi2`W{ z6r2_>O2)B2Q{y^`ma+zePs-yOv*~vbys;dllxr>Z7w+hJP`A!tF{f<}N2w8jY zx!&f3+7RC4g(9t~>STLGWzr>x%k5es%ep8~UY6OKYRuMf;y527Bq#59EycsT))c18 zjy7d=QZnDF9!sOZJU0o@Jf0*;W{@1XMWHPo;c2L~u`n$pd5TRM!`x(5TpUT^Fjbj2 zzpLd$rFNcenv)(F;q_oj^yK-777>gEbs~+-qZ=$}1|H{~55@M3|5`8{oh@VHV{2Kt z7&%n5tj_EPO!ijm8!a7D{Ki%aHM!{ICgwnx{hl|UBH8>pR1hxJ1*L)1ngm9RTst5R z&0yBrCR(O82v5F*iegNb2RRVt6)CH$_ZFj2nN$|LwLYHQ18GT<^xG{X5Vhk(pi#}VVDLYGys?Ue-?*7G;6dG*z|^awyvK8myS%M z8814PJE{cbbi&P8g6UXsiWhEf;@*tW2KECRU*?;#MroRLEKrKxeTUPc!5(P&5%)dQ z@2eVE5?r2cC7+AqZzu5HW};$yHfEp{r`#qf$7vTi*C$0bjzK0r2r@}CS>H5Y_ggvn zBbKEPmRl)p@pF806R)f!VYQ{B6TdF(*JCg2PnW#f8mf%rWp^!2vaGTt`6I1K(wkzs ziu-`*G-a@Z`NdYNB)NFsl>U`cdTHWak6`i^q*k>`JxL>eoxf23d*1^6?`g{kK8rNy z?Z$-u*Rgs7$?|xrQo#x|;nQ?g1kY1m#(%GBWmQ9N_NN9}Rm1PKlrwM@YBj60__2|# z;lZrFaI^N(#gC0_O%DtOoQ;d1wWsvl%sKs}-DsB$ttN=nNokv4Z;elHR)3~dBm9K? zW=M}0*8D)*wOgk*G@?ozZ_L))bUsAnS^O6jiO$_qe?bf)qL4Sfjx;t`nxmT=aqE$O zjGGRAq!=L)($}T@(lqHuTIU;noh~0;LE*x$__K0Mq`&wU`3Sz^UAK(Om&Hl6Vwqg{ z1JI|#zc;6C7IlXajw+pu4rL`Qx@zK`V4uB&pqYqTscyaX+33vKZ^g8 zJf$!El|1FM;g{f(Jmop@0GE1w4U{n2Q*sig_O)Q&MXC1nGYAlsthbt_eeDw(id>P} zm;6s^U;W|lg!hy1OYqrK>$+Oh=!khOx?gC}-H)7u*n!5m!lS6QikEI1RxHj_mK`}w zZeo6$cDc^u??)t!nDn<(eebtl7-LoKRzo`vAt$Mw+mxwMz1;DBzo;Kj^;-`8{I2w) zQMP0)`ENJNg&k3%UWcJsp)1WWIU_5U-)0N-b-DtYZKKi5VfNZsp^~C*R-3Qa?Lg@E zg3fhIR%U*ig`GvBHkU%LZ9CU1QI)x^wXfbt@H>jpi7Q%(1*Z(ExJWY+r+)ErNF2WobtqHFxg813idgajvMw2+C_-=F z%yHC0H+9;5JGa zC510>(Ll_c%0|fF+QLdqL?}v~c5u`oX$VOnx0*2IGV`FrOI>v6HXd5q*p8w6e0Qhl z)2Q6FW6M)srfSw@3YE9c78&Yn2z9nor?-a%Cy0dp%}mW@ct)W@ct) zrg!#vo|T^6XXocgEJcZlRx=TRO1BTuM5(9;VB$ZOhn|+8FfWbi=)rqtGLg+`B>!|M-`5U?8Q*yZNj{?^*>RR8d=ksc8w_iQ zY5DEbN%omow)NQwj7%%nFtZDACP_XklAIpuoT`iHtIy_SJC`WwR}V4u)m8M>=WvpJ zHO=@L!Zb94P|ltkzC`c0{&!$UTFMRf0S3hoBB{fXRQmu94ZS5)Y=^_lx2kn*btJXZ z2U?6ru~^Ja*T~nc!Sbz7ms%K#E7nGmGfX;PTU*Pla2rYg=VqhG6!c29Gt5}yImC5d z1}ET))k6%r-Iwn#UbWNezZrAE?S$%FGm9kKs>)Jorck8rwXi zBZNG~`V8_d0}+qLFcY($O%^g5%THfLl9!J_@#6+wx~+8iS2OE|%8V}J<;FJ_B*s|0 zH;$sCi+Rb`FeeByQ0BnMiE!E3y4PX7Qw2TwW>kkAXJwB~ZK4~!)D0%#1K$Y)lhWto%MuNv9CpI`*xOq zH-iLAHVrV|PIUlHtR$Z?0x1LXdy^5vj!|dq=j#E`nzJL8yyCkldF1F!46Jgo%aR<- z){L(n+6Q2)JV^B&UmnUY82#jE6U$s7yvdjus(NU5I><7%_E=bAiv=~6U7CvPp{3*4 zc2P$ve>I~O<+rYgEfDwb^T)j7n9qZE_{T^-4V zyJeQb4?Ry&F7(cW))QR@tH_!FY4pKx`Rlnt3IB?_acun z8%c)sX={+h7Kf^Sb8Y#Zx>{^S#bS@YeLgAMk@Gvmi@zP!I4ZGxtES`-E1g#;(!D;C z+NGFcv38xOxFNX35jf^7e3Dr_~xXalJ(FLP!0WldTiSY&pBMPaFtOr0!Jw~BV zhkYjFrNr29FlNht0H9cls0VsU6LPr_nOdGKs0X?!VR7xarZ#fKV>zImp*fZ<8q1c9 zF293w^6}P_#;O&llaYHee}#HFBB8(JpR?7im^~qNPIPZ(3jh9RWN|lY4%z83Fd-5e z%cLcA5`WpG%fq>eZD}ntit1GPO(vhWW0UG`4U-pKNNo4kZ0SbrSWLJ-lH*9OVP;*C zXl~XtE1i4Ek*6@AQ$*93?IE7~w0XGGCP}xS=b;Yi7^7(IzS+ORc4p#vfKKGyFFQxt zoyke`uv*?-b;R7?B5|DO$kD>q>c!F`QTG%)KtPgdDHrRhFrZzRY5z^4d!UFezolGk z{W?UqG^}<2AC&bQ{B57vdse3q9-NgT2g^t2yB-p8pfysvG-}cfvy*hQuGq$qcY0_{ z2USWV&I2n_8q`<% zhy;yUnhrIhoi)sEER$26aJ8J~=$v343%T-&L&# zDv(;kTE>5=+xH$55oE60NAos64}!W(9viXQb$mQ=<@UkE6RP|CaS=hfrk~^Jpe~ok zNAg|O{hYOc_I92SQJ_kHWEPA&m)a{@Ri4;paa8?t)(Pspeo~UdQ4z-|QjMTl^5mGr z+6%w{;#q=v;hz!_^jr(blRh>A|DfKH1% zBWB33e-JMugR##T2;WpnjEA`1h9a{R$}VgPvP^X?km^1x>cNcL$J1Vob0$@&dF%>$pCl_G~c5ZTuALXNfjfo(lsK(fEu)(f(JLr-n% zg;^exaa?a3*h=cwg+`MFkRLht&PN zc`n56{n9Im_$3bFY}*QiYyU6@R#ZoLsb)nx3?my#(Zgkl^;5jE7Y6j!f;q+w(%8#F ziV^JZN*mTG^Yf@Ssvy)o-I^whTA zl$D~#w)N(aW7~dUTW=AN?60=<)~w&qQ`>r5R*D|m*4smlUF~dS-}MN*LqOu13aNHK zaa9-9hTbWn^N6i`7!AHF>o@e&^5316A`i<4m9qDQ99OJt`SvvdV!K+aQ(UWWL)~=# zUV8Cl-MXpOMj0VnT0T5dOeT-=6Xoc}v-i2U?3}t?pY7BNY$$1Nh|ZV4zsApNMcKzmO($SfM(#w zSc1uTtI-xO{(fLzACILczBc~P7mMC{XS#>g`RGr?a*a!?@{_Df%$AL*+crOGNOo)~ z+n+7BaK_`Q`$a#crCXcnwovI9qZ8quj%D`bTXk{V(zH6S`WY?P-ZHm8R<2=Yd`~2) zpVd;$ZE}B^;Pl|>)0S*h2YW3;8TVJGz-x>CM@Vqc$UzEtSbO)Tba%1)Y{UoqJ1 zRhLem?o``ionR+y;B|5K7YhYXPW1ZNS0m1m@=UZc79FTlfZodCjL>uM67^Mm+a$=MDqpX_WQXcR$af-|(aI9NIxkU)cDKe-TlRcV~kZ zn0RE-I`Yc|nV*nsJP}_3O_a zE-&Tz>JHU1{}M9>af(}NHiLyl-VSr9foX+VdkE_0<-amCS=8rGhF+xknA|J%)D z?O^6bQYh$+Hq)l2$)^4jlFZD|hEJ){C@)L8M)cmoe3>eD)#SR63Wek|wO?x3?C8DpGb>L|0=Vo{&kK`~)SX13zcLGP(?1}ZhkVvFo^&-`6vk++JO z#>)%A(qui0@^+5V32@iep}+P}KhLdW(yg_4=df*fyGlFh(H05|Jl77CIou|eKG~?u z&C#+Sw68bNOBH#LB{TGju>WYN4#d*Qa4h;U3FHtf&g)V?+zZ1l6`iFk88?sO{ag0|!QQuxNuy=Ol_#ZZGE?^W`ak`(y7A^32v73$)z}dXP(z zTlHutw^~WW^91$R+%fZ4`1iD+mzVCOI7mmq@Zb#Pf>hCN&(K|^F_KM_bc3fSL!Fs- z&LZDlsKq0JJo#M^0lhIuI`I8|z2#x~CiUjgU00Uw|Mj|DYsptPQ{Am2Kd3pzej_~1}}r8YBJ-&UtO zE}MT&jnhQ9I8|(st~BT-fJ1DSbnclG#gJ|#uJ%ZK;bWmP~b< z_+jeHr>B;h4bbFBSNYHocvb+=ODKnj6xEn7%oUU z>yZaKCj935!eY4*koDtRKsK&gHEFrSJX!7~VxcQZd|7mH#_|d3jMA|}7F8a!aKtM` zVNf5qGpj|*#B-dKC(mQd;x9oKcf9CJ{Nq35cTR{{YSUpd!}YhTWZBo&(EAN1W}=`% z8ds`HnVxi3qKt2qjLswD^PN8^<2xzySNK~T%D7IBIoQTlGPcxGFQ0$Fvz?M4n5=KC zFRd7M_Fe2dGN{6Fs)HxJ?o#Mk+ClZ_Mx{1er~0xPluPX$y@POCRvrq-bI^?5ezevg z_4>!@F-fyrsV%LzIIEhmua`ov)twPVCyUEe^_*`eq7#}he(?!zqs+(w;mW;#>e!EzoJ~P>I<~ii~=slfbhE02S*VYS!lWUHt1F4S6)eK#RUG5z8 zhHeF4qt;$Mrd*oRuX0eol^9j(*LJj{7GcMGANJIjMrG(MrP|DBPz~q|k73?j zn~vn+YSHZkC1;)z^Gu*FvAWM{yfzdjn+5urN3Pr8-2l(2F{J z@!HNT^J8{mCZ^D7nN{;pZ$DnFC}wF#bj9gG#n4e-60}lnl#n>wu~aLCg4=ekAgzpP zme5T28VK!C#y7~TrY@$3FjWqblj;pz)2FD{1vVu~w>C=DG0NkHebwP7NpQtJ5WO9D zNyuAmEzO6R`cj=(CE@G3c33NxkM8H(9Lm4t+o_~uj$ZTHlJy&CarN!$LaXa|$k7M_ zvbx5YsuSDW*b~$p3d+dhkwrI1Y}GXOfs9?Wm(NU1|GQv^^%kP#TTi38xeXE7u2ifG zl)qkzB$LaERh0UCsg$Hszq1W{+&)taz1J4**n9AihJl{I)$4WZod8bkg><)$Ev z>Qgn~kyHvTrqD@{6~FY;YB-gqaA?9#;-v&A54$!da6|&JnDEUXcO+s~KkppDI5^rk< zb*wqfS6Q5=%L5diyQevqzH&5{^O_{QPFOE*%wV#*vKANdSfU-NN=z75U{W5PibVcv z8{-eoBTKqoOAlttt!h&_?(i`gMnm2=PN2I$ceh!VrW=*TCUt__`WT}?+Zqh%x`Cp! zswSwnuB!&lIE^b_P?$DuO?fF9vf~AlOdGN*lH>>niZ-Cwj@N3JWW^^JktNk)LUo)w zoblGVZjc1~j;JmnSXAnEm%65^)~U zHdmJDjR769FLmj{!ga~jj8ZP8xz}=&x&tYOaL}6&-Qu+;CLE(++~pg%=#G5DMql56 zI{o%0xR7Vy_y&qLp42m-dt7gf=`IPDomyjtQWrbzz_SaR(*ccXbLtk4D^1Mg<@u6@B9ai@4Y)@QSRfK8vJP-?`j^Z1>GF8 zZ7wf0qszeU5OG4?f8uvykU2BIp6u&BT7IP#6thP--ZqbRaqpX8iV6!UFmHQ7^|AYD z`Ss~?RUN5uE|(J}|4as1?fu&nbK&PR84Tl`2K?6<-D+e-p&Q9+9?)j1%{g5re}`({ zCTpP)dvfh8Ev~J^^}r+-@{kE_)wb;X^^F)9S9pztV484?_n|Jmhz3; zty@c%xWb$7DujI9!!=LPoUhODwY7Dn%Lg~qrW?zPYTtKD^y~Chj$&P*y!H_>TUZ0o z8v!zBoC>_87Kct@JTl3Ltc`Ih{woElgg+`l*A5F2rT5B?ZYqDYrlITd!$n;-jww}1 z#}VbhkFnYI+dTNOZqi#g4=xmRSZiiYWr_nH7Za|SDbe1Zk)ud9_{3fYb=y4NhuAwB zM>XUpXtHW+jvk7MO}<#%RZ6ycG0w%i2Mks8o|uWuR*rPeqI%1d41&>0gOc)kV>ziL zRxwsmC$=VZ`_Pj$S9lFoy3Tj8C0wi%5Q9HO%MR~hRNX0TNWthPC&a@zKAVQ6!xq(oB2cmJ2P!XiD%$y#zUw*+GpD|bON-z%;gz7_FEDAksV;lgbI?hS7n*dNgW6nk-dV0o9Rd^2 zF?37Pi%gCsH-hghFZAhxrI`G+{8 z$yaE;W|`i(0|%$`(mctVugq3P!2U@CeKo~~kVFMbrfMbFZ! zgQC_@N;QRgf?w4o6LTD(uRiuOjdJnp{c!#~z-jd|7 z+c$EkI-qx_-Wto!QYfPAE&Lf3xwBs09^vfc$%2{0woJemU zmvItJs^}rMxi#ADSu2O?tp0?_vpwL8TUvMdFzG+GUes|_; z0;YYfzpr<}>I$l)`a?TL->{f6xaG8w$=5Y-qWYUziMkn1F)6D3d`pp1yOTP3i+0Vy zRb5u8j-?2FOo*M@ycV*vy@V$>U`)^b*o{ zLx!bNt66WK5n>zT?B`6y+CWzFJwiLnWDRDVed46)VBaNTpf_#kxSV>PLtu(WUG?9y;Z) zX7(90vwsX3{3|)=l-*CX?DQSRRJ?BA+RKbh>L`bNY?x}vTGGo;O*Zquw|Ueght(5x znEp(WER>tm^DACjAKEcB!deC+^)7`$z42#8wl|VqelDcR^WhHZcc7Cpzi5AlI&tCX z6zHK(KvlzEwz;xA;XzX)J>24XfL;dvm6RvX0hfOXxNG>=;g`@g!{xakUbva#2K-aF zsja;(2;G^F>I(jigpk`iOCd^U%@E@iPa?wKs+YoQ>OBFvWOqAwL|m*Fl->VM>7~}J zFAh2aUuq;wzde_}id?D%bOQ1BnrApW&yGrMcuKu6>;1Ycs>%I9lVt~^2f6HRL$R)y z3WGY4@JB^N&%cK^AJ(|*z4ukD{3mZZYpE66JvxE&=a4Q4b~7m#z1eNIk;&yVS)Y2* z;V&KeR=$~svJ(+Ar!Y`kV52i{Vk@rB1RkK=G;Z z(1RVp77NAF0SS)epU*jt{zorotsUy?AL^WPQ2+F}<8AM9s`g%^7l!(O=Cgro?uQyyQOx+H+?*mhFxW5@CQp z2Rh^SzmS6-o^oHMPYdog>V~!)r+AhX`rO_@y;gd_LA3JIM4wq7UJX5>9%gWQsS&>Z zlE=#ji19#^F}?zeq2!80Io$h;&T<`OGODXI89+WI@V%`P-JE=!OG#5 zGt}{SYm+c)x?&KSViWgFk9fwQn#651XIO1YpVs5^(p1Su%!Pc(|E>+d z?i|smiy1meNe=fhp#H(TL^5yr9TXj6Sb7*DJ=_&D@!_W2J29hi7E#=71q%ONlwn;o zv~+MfNxwUm?(3I;SH4F=vU9calwIi8pKWGLv-H*XjASp=X+bbDakMAfnJeVDD1~?Y z*1vLy&Pp82QAfS>jt+Gj+5VwFFWPfI#Ng#xze$;Dx5T^a8^uP4CP-Yi2DWRwdp6Ol z9EWw!WhGzYh(RC8v3$bWG&>Gok;+c}q|(uSN=K|HecMR#-X2R4V&9Bz#pA@pG^(rT=#F$1Uu~w?rYBt)=+4ArIt;GQpBmpb ztnQn)Ohl>$R1LgWM6gt^?g^iErX9jmia~d)mqv|}v-kXAX73srmt!*%+*rB$zD(X>eyZJyoo6%SupCD@Anq=pL>A~`~9%e^WovJyZJ0jbB#9BhD_KDe< z(gq|Z8Dgr#CzEzo9Ynh)4SLqMu|%(Zp$%i{j7B#vo}|8iDVT0Gn1@6uUAG57Dj&rJ zCr9#YGi+jSCu!O&dSbfEYK`DLrdo#M%_arW>!*9cj!RppwQ3vF=cee~zY`tf!)-$a)hYLE4bSENhqwt-6b( zPsm~$m2}jQmn}prYDb()m&w(Q`RB@vU%7S3$W-FVC0NYo?<`S}R=b1L6?|HOIkhUyy^%7Y1}_W!As;kRFFR z6!6fN9_M|iOD1|&UDm_dzaj^HqMM*rYZ7U3$zB4)vjyD^zeZDaS-P;{#PdKKpjBg1 zJz8sHwhRYyXqEEafkr;}+?Zs9{J?JIE9}sgJnq!^l=thrsE%=-W@ydQy$UXZom4{b zU3t(sf%6T5iONl?FwU((Ta-q8X;6>a1!)=;XQtk`b);hA8H8@Wx-iY*unx!2h$&DP z;kp#Xczu0+ak(X7l?Xa!{-k>{gKdcMp%S^)QCm-1n>5XD{))KEua z!qI?#Q{CbI#MXuS(bvZe@%v-$^qzd+PWNMFp4vef)@V!?UIvENF#f2dFP+{(v{o?n zYUGBPE^6L&zLvvrr4FA-Z3SL9zfiFi6&U_rrSL1VwlNw zRSj)(lEh&UslZcg4+U^n#g!|2VO@sM@CGTYo7%tjsi{0(5L zMq!7CV$Gpwb*oJ?p~&Kf_o+!`SINuG9XL|mpy+*DL{o27XSN4nPlri~>?}D{u281EDknk zq>t!2rfvV&$N`BlO8z<139GftZj*Y6{YpgV=mX4vCteRxrSB@lm%-)v>JF{dSBDnX zx-PE7^HrtJ6=7Boo*30kBZ+QExJFLn9m$|u&8M>RtbDtbr`FIJm}~Q+^wuUi>tB{~ zl6SR%#MZ{-7pe#9x^8%EAhD-FefZNh5#0Z2KU3w;#OwvAQ=l^vCOr@G7&*q{tGjc9 zZkhZw#q1ugBdS@OD#P`BmRpcplirTCYG6g;nd^ebR#2YvZ9X#(FeAB!m~PAw(om%< zqF(Cg`jBY3Hof26WVRa-@g+*}I1Mv1OWkBvg$(|u6HrdJfMk1C4N!JmYs(dGTU#zg zI)hP9dwm6_bUGxK4y<5t1?kpc$SsiZ6zbH)4N7)%UX^fMr;AlvlqFvL<;-q|ItSM1 zNVkhuc}QmVz|=i4OC8D9rH&54VvVC*pczV5&viy`EUkPEiN7B}J2x#kkK+P2sZ|sP z^#X793EfO%v!@FpeNoH4=)6L?!CvXN>t5XG)daY9c9iZ{{t018& z$j$0&_tGOc8C{M4I)}Q0?-SBAD$QWBzPUcf-ekyaHKmTV$;XFTg^#E4x$i-@J76ky zW9rsBeY7iC(mOydk*SK`izMF9k{B*ThB&ELMdw=X?~*oNr+3fF3rl`dwJW!BwG-$Y zACQzv4V}U8;7l-Gp9%aVf_e5pPU2MWzVbn7ne+y?_g4aIeQ;9Z^n5VAJG3726Xn** zc+O*KBp-6n?K|^hni|3AMcw(PF^pn)gUmP{N%9_={KDDVo`NAtIx_~D&VZvx(!*>? zWkZzwtC$MUF(m8ZNm+A2bA+aZpER_}KEjd~oz+#>w1o?TAy}+YrnYu8edQyQaw|)z zkCe(90$%h{X<5UAUSBrEWGu(gmp$4g&DXPlS@#%I-e@pQS14AE&y(9Hm+rFnYMLB>MWD){uYv^B=3iR}{E$TKWy&H9WXOl%`e)S|My zXQpLM)#^)&O!wc%4^n}Wmi%qo}0)Myf#@EitF3P(wwWb*CoGi zk0apERod&5()Q*ejj5F$PI25Dlr;6az+|1eI~#@)r8a_MsW*ml>a}LMQd^o>UbwDq zF2iD3;G5nQ$!gV_n`xiN&+Z4Ap0^`NcW-XXaeR>6CcqcHMM;{i)Mgxl#F}GP^h4;2 z-m2tKg;43uFa`P7fO^l{Vkz6|dxOU0-nx}y<|^y$mMkm5l*}+0 zT%?|u@~wx1FM3xjOFb9u`9(m=yOorM^6r3~ou?EgcRZME`#nkuNeFK6^gQ58-rJGk z8JP|ODesG=&^?sC`eLfihmyYDA4>_JR5XS~>~Wab;V_c&fus~qowculvGxS-L2^E* zX_~ z$`VAkL=q7_U6l8_&ogGunc3v~{(j&8|MmG?`;2+6=bZc8?bK(s-O7>jMUJ?_8LQWN zv1aWmHC5z#S-@4LR?QIl7oCN%^c|Ua^DGlx857-VF!9SK2fv0hLHNakhlxxOe#3pj z@A#hZn+Lz*9v}~Pb#UM|lZ3;&JZOU}aAY)d(I0v6l!iFGfyrUX4%*FPk`VQ)hPc~@ zY0U1&1Yra!CX7U-gjLZRa>Fzxvz%k%tCCC{if1Bvs)o#*j%g&UWRkEfj^JXVe+LJB zk1#>#-NQkj7$yjPvpDFN!h}XET!E)s9X!MHfMkU<#8U_Z$c2j>EULkz#-F$X3-dYX zjmGtM;ZL7p4m#grlF((0gRaGyBqa9o;32NSXA>Q4N?}r?EUv)jXbo{9iV@^AJV)3& zRzv&=lM;s9)sUZTWzvN|V%Tj5572VL!?GGO?*^ukZ#a{LahV*9ZNnttUD#729j?Hx zrw(?bQG`7q9>Df{fPDiT41b+TjhnFl@S9A=;D!d&69WV#dVtmk0om($a1>V{N4$e< z;Axb^750AI!h;LA0#8;t_39K05;3N2f##vl}gEt%;z-Pk2&JGUb!vBGNw;b%p^MqcmgZKmV#tp*aAs+mS zEAZhO53=A2EE?}1X&V!S!fUL>71)U=A?$!~1lOKeCJ1{o zIM}_52@R-fH?aM%gB@+~0I)rsgKcA&AZ*F!!D3v2&Fvj*!gGYrb~xA+iT?wMzk4tU z*FnrBl28dCw@q=7gm@=x&*A~T-wwPF2O~_0aq#{${2!PKrz9l9%Lzl8I2gQ%Ny3oB z8sauu56H48n@|N#SmkxtzX}`y5OHuA!srSP-cDqKFnX1PxMwG4 zFpmkslCci@pGIB*W}#;Y^%^ zZw{g$;3PtmkW$UTp~p-TzN+BCVqAeQuRFMOgh`EFxB{1Pk8nQL!G%4DfBcabOFK9Z z=?SSv9b7;Q2$zvU38~D39=HPM3plvmk4X*OzYbho-~k$U6}W~}tO3EV0awsq4FUUK z5dbPAoU7;H*gPgRAlNbB=r#w(!6lr7BN2|aa&Qq^(U^fNa0r^yz_W*dYKI(@K{xPzTROcJ)kK?pnMI+!{UVFpY%OeM9=Xt& z9DT^dm#dgKTm#oU7`enVar`io8_NPnp+_LtA;H8K&{9tL03c@Ua?k?_iO?N_Xq3hk zT6v+fgUksS^&~Ly6NJ!cf@>2dr#^MyDp-I?Lat&OV&<#JRzR;x4thcuLXSrpGOJ)3 zS)dU>{M^aGt#wQQ@&l-vQ1GaRh(W^$!}@8+o_Jnk9ss%27C_F5w=Epkb*0a)I&p@xP;LWFr*Iw_8%PO0lpl3 ziOJ|b9z4bs=mEPCy2I%ReGWP3+lfg+zYGpqo@SEJ3IY>a@A4oQu0YpK4mLl;Fb&u; z1#scd=Y<@6IG#zuV%Uf9Nm&PLQ6V5cM`r@aPrGV}ty7prOeUxpSYF2iIM#9?0euS~ zi!X9e{sNPPPN_eaHm_7tBP6o$A1K6aNRsqXC2oXenVQ1R+f7=OAM$lY~qzRFVl` zA2}E^mPx`}n;eYjfMfxvXb188nIybj)&r>ZZD8PI2ZI(dNm$Ap3>=Q{ff9Qhltej% z5JU>W6&lMVp?EF_uWo>Cf!9Ync8#rk4I+KLPM>SmXWwf5q90ZM2T!BW=2%%0h2N5Wc5ZS^()rU+HN=?%c7csmd zT(98ZLIM+n%OxG8-e!VuKH9;#B21hsg7{Av;NVnMCI~;E7b9Hh<=`8H5#cQI1L5i# z2j2~1f^Y->C!9Ix;Pe(I2(#`w7*PxpRbW)OgH_itQ3XcgnUOC1nVsrjVJ#*IOA9#| zn28C(fFTYRqH@C09S#On!*~%GxY)rb^OzvKi;6VX;R>up`X;Qy_k?*{9IUU0@jv~U zkD)Q)QwT#?hYAQEpL6gQDjSdils6P;5bt1R9YhK=G`BtAYL8qFFD7K{;UMcO zbg`>&^RR=l#hD+QgLAk7`|%y&%K;9K{EFojVCF#wvydYIaR;ggWRvR- zT<;-q0K(nC!Po_;3>a6y!PnWD9B|ixI}tGtOuFS@bT1|eyrhHWmzdP3g)6W^IH-9A zIRGfdG{j#pA>sE#%>VF5+zfLtuNFKLaD{sSPjvyY5KaTm6$>1N-T%ZDkOM|I2!|F3 z6K^}1e1l01Xk;?*PFDw`@jYRFG6DHNKGK1DiWCbhnC4&}RHji4S73f44e=KQ1Z34g z4oX)*rUODcI7leQBw-meM+iRcAfgfy7!Y>QL3xx{-i1HKayeLviV3UW3mT|k74Y#7 z8sg>-XlVzNqhM#kNSICooRI(quNvbPW0?k+3nwJZnc^VsS0)LwFL=-#`F}S4#Px7c z zJ1A2Fvmiv<{A#d2{)ov@4kmSCLgO5+z~mzij*emC>#0mkfa*1l;tEUzU*iI9v4g3Vn9zXZ zP6alg62kkN985#YG`8Xje1QLJz>zUB7RN4OR8_~phHU%sFrab~RR4aW&E_8YR%CD| z_sO_9OX#Dq?jM#`QA2BrdhUpiGPo;$@`5{dX(`pEqA0G8)f6SwvYMi_y1a@vcLyhA za93E7Nk!1tkw;`EcXWk9n}ZWVGi~0wX2LXk*|%zq>Yioa-GZ^RZ{kl^!D@69Y|}4- zh5riRn)nd^{|%pi2XIZq_gxQ4cKd*2yADg%1{i%rvQzkO!(qXahe-&vU6D^E9v@5uz1XArbY{vF0*7S6C{gUCRvC6f*t8ASdZR< z#q<#@3qGgx6RZ`m^{HSTo(a9o8jjD47D`rQkz{`Y`S5vGZ^?@Fk?dAy$;Nb%taw++ zdL>Hs5SaLxWGR~@D+@$#mdq7(La<)bBpbUIh5RYl-65#p6SQm?Dt{nYS+smZUde{% zlPuFXv~(<5{H|o_fTz1q*>1@~_J9uz*eBWR!zH^342Xe1Kw=OC0P1Cz>?jbQ1K(vs z%Yhb;G3>nXSg@5(1l#ksU{!(J>!8Z@lI_VQS@YbI9Ty;fE?BLV-~c0#Oj~^<*jeDl zL0k_A)*07axZc`_`}+ku*bASbxgm=M`xRL8Av6e#UnJPJB*88vqjBICNOlP}Yp-A> zcL}x@h~9|;cL)}{N3aa|eixjgDsXtaU~TYyI$XzW6D;2r!4?DUH{;$W!FGHmSR}5$ zCki$QsESIaY=ixiB+Ig0vME5i_a%#&BH1)tGfjoYlO=278Y0=I!IB-ub?t3PTNWy; z0(Alx;smQO8qW5%V5@MA#{ajDf^*{kF{=few?MG5O9VR&U%5RK+E|AF4}}JX3-&5L z9~uOKz>7K|*@&}}T{vd)!I&r5K`W)P;S3%0`z=fU_mY&oNDD<$$lRp+5SHe zF^>d$cohEgCH&^FV0mzjN6tA6ZrP2n|6%+oa75^Zl>uMCyK_PtGvI7J;6UBcGNAJd z@P*6};3vVF08gQb0tJy|5TdWb@hTzQ;(H4A2+xSD5H^csoqiT<-7Uekd;n8|yDA1* za2W3Qgh_!LyYcda3-j%UmM9D0WG4?%C?d<>jqTc#_vK?lKs_jHxAASO)kJ5O!a%Q!e~TNDn7V2esTo=K~Cy z1yv%3!%IjuxdI&PO;l1Bg(KeU!8AkOLnLf~s0jch<`N52lupp~6FfD4Tjaw9s5K$w*X&xQ!u()fQ(_(fwR zwra6sH4H_**-7m7|b#%XL&<&@~ zMxV0Kg&1B6TMvX<2cUq3$mRHdwL!@5_-@`Oc<5btG7!HOpVy(lc`(Cz^cV9{(5K+z zyK^6d|CV6QaBa3xuq!|^IJ>66hu(+q@kqtV(2zu4`Bt*6U%)i)AP2a9g#9id)X>U$ zXzd=fa>_N>AFbSmR%SRU*m1P-K3d7pvg~NhsBaO5&_p`4u*Ua-wLq(DpruXVz#G6% z!FO49!P)A=XBxl{^24_Zz$`%OQ1}KAkMHZiJg)Y0ks#plJ>V3p5W9!*|KelO!=bhD zN1*PnF;W5I_am!)i5~3;`T}ITL$lBVINx>H^D!K<0g~1NJXZjTEBn__`2d72{NUCk zWWdqLejK5@T(Vk#SRvUJ_ya2i`)~UTS?+hi!fwJIP;EF&vIS@m3-tjRj^g?!?27`= zA%EYV2)~#NVSuhs;SCg?JRdm%j{8)>Zx%qfc?dh85x%d5@(016D!>Ulz;TNuNS1vW zA|@CqIs)NwFbu@<@aAH87@q!cm1Ki}A3jDLL#X&sXyHhF2NW2Oa2y9!&P9%x18u~? z^JinA0`$P=`|$cl`Jj!K=r4-miu79#X}F0%iiZY@H^TGC5xr3MQ{;>Bu8+_)mVvZz zrl`q+b(#cc0*>JG7_@vUR9S0+U`K&Y69u~fM81do4K#vt^*aXVg-M#gp*q8{Mjb$2 z0BQ|JqhO-R@Poy0zDiS}WuVap3`F6OHKt)K0k~>>0CfYGP*9!e$aWy)LPqPDp0Qxo zm^b1Lc^lrEx8lQDDfSjC&C0NntQ;%LO0f0pG5?!m)1Pl<{rLdik2hqAYy$7dU*(P2 zXDoqd6~FQVtRVY?|Hjv_PuRz7C0oT_;8}S&9>#@`F3~`=60JojFV0KwE~2aGCZff1 z@sU^|R*J=9iTF?~6(5ULVztOAa*5ByCb3y;6WhgBktBAC8GIFw=x7c$NW?F7k|P>v$xqOhHb}@Y#n>VpYly? zBb&@8@=1IE8_4>zzN{b1CSDMQ*zbHT+rrB8ikyoGkxo?LnMHb$MPw8~VvE=%vWpyI z4vS;6*laeF&0y2mbk>KB=dpY)dxw3%rm`vQeKvu`vhmEt-eZ&5L^g?yV`JGE7kih* zuwiT{8_b5VL99OO%Wv{fQBnNFi;LU5lz7O?iw8VR+~K9gk32;Dz=Oqiyok8Q3yB-N zsQ8(e6nA+U@jWjluJgj;9xp5I^Kzn+xW!9|g5pgPD_-KwczfQCf5MlswY<5=$CmOX zd?8=Nv1Z$pWn>vxI+mWjz_PGREHmpQ=7>nvLktsdh&U0=y0Olz3+u`%vM^SjRbbos zE5a@2ir#DkU(Xlw54qwCcwLdixA73xlt=LmtikEo@{yQtei}DmcL(CTMir-ja{@{FHd0iSw8-b7$c_ekN7XFApet<=4JRFte05MK4QbgRsN6_;CERb z{($A@r}=9lo)_c6{1TtaSMppuH+O}LDx#(sEiUsb`~!Z9&l4B<8U8Il%U>3Mv&ZZa z`-?qc=lKPGj{nLE@mXRxe~XXgBX}3yl}Gb#JTJ?`X7TxA9-q&T@#B0NpUsbOH$Te1 z=5u)*pTpnhD|jhhja6qg*eKqe_uvEhAU=c-=C8T<>%0?xgI8rQvY|YN594q0&OC_s z6m7*pzK`$c8^jW}m@Q>BM0N2B>%elecC0=}0P&5)hu^-s?><0Uh9b|ji=WGYY zzw7|p&i1e`*?yM9cC$llAKS)uu`gIM+sbybPsMlaCPR|@|0f%|>~#45JR7>~bol=~ z8~UX~ziilm*XPApOm0{^QN z`kymsIRD2S>iYj8iRv6$nAPER|Hqls^*ohU<{z>=A~2oi{~spQ|C~?r>5O`wrLb?< znNI8^JH>uxx7cxZjGbjC*fo~QuCvSR68n~&W2f0wc7XCNy#ts zeCgeht1~3!X^TOp{xmuYU2{@wdtNwW()Ks_-Hh(g8TnL9XP(V{aC(WPd_8!jP?b1| z=XbYtS5(oHcv1JW_!92e;u+OjS$OfJ+>`m6LJcb}%O)jH;bG}jR3VW+sr(F{BGr_l z{EehBalBec(l?1*WOVPpSW9)t!AmE-wvG2pr^1TxLP^hd@fA{ik<8yt>avgD4T4lT zlNOyqcB4=3)Fl~Jr_(%-N*p6zP;qB@X7~EurQK0QvbawiY?O51H1EsZvE6g2XXkhx z_tWUYxRn{#TbG7tNFua+8lO>s~##ucswBlDg!? z09uXCBg!f?BE36vlgdd6c|>gbB(&z0bkvZdNwP|1Bn_RL*oKko1XXDpNA{YBxVhke9(?xjVJ6#3N6ej+Fx(UKnb6Y2eK z78@Xf($mc|>PbHloYa1R;66%n6B(u-RZ|Cw{${cHRgOU-_Y3r7TZW+!OQ#}R@VY8! zq$p?d!Zf7?D42gc6xU1@L9+$Jx-+C4(#cIt{AEPDIywRkSVqrsxD_v?`QGEBGq zB@~@rJsT|QC=^`MOF+}}tBNb7r_4%2MR)JLB{-OR8)!BE-vz z9)}Wwv&-DNo?4)0B5FzUvix=fVy6j5ni^nb)+~39UYS+u2O`*8o|eeh%9vqhEBA>4 z>epc+m#!-YrM%#j@@#Qq75Al4N?dl2>{UR@>Ih^tT#Nl|%=3n~dP}tRihz3_d#0FQ zhwt);AC59}IAvaaPZak)=M_CG8T@6if-nJc7wc7@nwVA1jum-KvZsVsYoLPSJ_t6?{Iag}=ssD}XadEf_K-H<7go#P z6}`LyN0JMb9P4qRVIUMyd>pdXkZ*V-`H-KP$QN{3)j%yu)KbqI=<``i3&qs3@uCE| ze|c}M37>gNsg6>DiO|Y>5Bp_K__xQs5SGq8{@_b$h|ABJb%G#g4n=~<*^ZZ1snh&r z)hezS>q$6`K`!o)gWZYm7gRwbq+jEr@_KxtBDf`>SXJc=4^2a(sTbg95femi?LlS0 zF6m(xNW;}g9a>&;ic)CNtUICZd)+grly*G5D!AFm9+VO^l~O`!O)amcPBa>CMO_(n zZK7!ARb9B-qtD8;-3zy6vYH;Q+D$c@9S_)*n9B6=tiGYTIyqgGa7Rtgpe{`l zCA=-y33gdyPhZm72c{=rElHuW&G3q+3SU0kB@*<;e_lB+x zFbdsz6kv1C^P1}OVMcM@G^&Y|M(cZs$Os+y3nZtnb0#BcA{nWHhv<{iuR)|U%_f~i zc-fHFXMzOoX>=uUBGs@t@Sl*p2?4b(~=0j4#qNBD_xC>i8p#D z-N|0vEOP51ZdG++9&~fR3J+3GRiK&8H%isN%gzO4ZIq zN{u4timA$rrjb~z-lH9oMUK~bg*13pgtu2+78()m9f@hDqLJ7u>heMn?UhCoXxyts zY6e0F5-IL7uVd#WtI-`*whxV3yn55MR7D}Ls+k{(=H6NY9q%=jW3l1eUT5)k39qBU z_1-`>3t#NtCs+-BL-8esD3;51QWKV#m7ovP(dFIjrU&|@tbknB4$_u7pQm?+WRVWuk z6MObmUd$HQ%2eIKaUY*jB8>tQkkNFTXb{lD)28L0@O&yZ56>7_rZyyHzn-e?M}~T> z9Mnsl_{eA-sb1GXj@{c+$G(m{x3>_WgOR@a!XZN6L>C82I;m}b9bLxLnW?8#NwFhQP>hGC=ZbztvBn?6oEo2P z@SlQf;jGE-aH9IU8j?$!j;0=OA=aXLHl{}UVohfrYgJ$bXmR(Nq@jyQ%<8ofTcNa( zWW@X5VU}W*rw0U2_It)e4L}^F9;_1`yf#XH>QO-??!B#C>&2_ydwMqX>w3>@XcP#e zRgMi}hL>P|ya*RWW`JQ72xYpmY*3jx*H7rq-S0U?-QG>PM zFqR0`yv?a+1nL<__ppR^Qgrc2iYb=vd@y+2AP{_sqM$9R)fN{OQC9tfs9LGkygF80 z+azB1)nTfrCB{I3z24%q+jy4qXe?fQ3Zy13GBp=H~XR3BPM3mR$)HW>-wQUyUY1S-mt!q47OLI*|5c1d zn(!aQ_|PH!yBLd!atJr9 zFYl|iEHZeO8b4A)5C5wgS7^e2P~%F6^zUl?m`FY~T4JnH6TTAV zI|cl^7#q~aV@49P6tR)+l~++;8VkjiHWG>OpS1CrLrPN&?LxE?vI$*7Op9`X{k3M$ z2Ek^{Xhg#=zo8Y$tZCGBZ_%{!fql1TP^$l2GfD^c-I_s)+v;KbL+4E@&_P0_B~g$( z{e_oPU*wX$g%N9GWSg4)jp*vlV#tHe^R)K19S4}ykY9N%Rrw-%yDI~YMH`w}2T`)7 zwU8YkMnrV0>3&eUkSc!>BS(uHH^swk1ny1`S50V*Ew4bbGyKTn>2o9S#4Zve=r{f% ziQ#L8o-hR;mASPTWkKBiT#V4TJZY3nQ!(v;G_}~HPMkF+GJ0Mz@LNx<#X;DM!rZRV zd}*}Z>gkh7x|6?QT9xvxsO(iF=|>xa^s~>yDXzMnGa}pD0!^eA>?h)c7cd15)VO9_ z3%3VU<@3h0$6C=oNF_!5juq{w^RV5Zlra*%(G?f26$|?K-sR zcuYOHY>W(OqN2l-CMw4fo(VrTRIxu8#p|ggUMq6C!q-7NK|S2nr>#`X9fPOkrF}VF z)r;Vzs1sL>AynXa^duED=w^hPpK64Lt}wNrXYTqc3Oc3krHVmbE2AJs<`%g34Z6sf zAv_`tp{+7btIF4nGPJa`a;CLQVk>S(pMzg$QE3G9O-=9T|(diJ-d;jns z-%|qfro(S(WHA(-Jj(M+tWKK1?w=;p?%z3(?@L~T3iV|PtuoqD)jFlsu=DE44P!No zbQOQoW1Eh+e}P)D`w@RRjZGtKQhJee-~GqPH1uW}`x5aQ`Wrh?u*+(~k7)>|1t-C- zsKPf5{d=836KHaBRqeYedU%bjyPs2+pS|F^T6W7{ z3evCk0@Ckyq`&AV7-0_?>)#zdSGKoJH`LXi&C<+R`W_Np8P5MHm~fd-}Shq9nFCT z{#muY?^llHdAG??BL99_mA`Fxu+?4PQ8OPH-L*C`EmCPwXp!nJlom0PH&4TPy_rmt zDU;m;IY#olD)phLZ@PtZ)VT$pJmV`-3bII#3XR+z!y)f?t!?|Xc9sV3$Xr>d^LzueCkWKP#Za%lY0#ppp+U=2RMQ|EFQFy z3&dKM%b~iYm%fRgH3AIc7$i=ZnP0`MK<8i$*Qg9_YntHagaunv!6Ip8L%M|J9tLe` z42;maKWy`HY6FmU8o|ZkdesTf^pj>S`wG z8#Y_I!TE~JvZ9L3EPcDe76AuGG8@Ws#xj`l=!{8Io`OWEte%a-Mvb)vj-Wv4&#CW# ziX#l5x+^zqn8pbnt5$5ol2{L4FvPNSQAD-NYUsk+XDCYdO1ZFfGeP;s6iFM%7Vq*veUQdB)@RQH0U zZ@YoE%Cz^<0h3bjbk!~!&Il~ZY1Cuw1(hZb9hOZrwR1ViqRSy!%6K^C)ScYYxA{Qj zXf;xoP*&~BEh|uBRN(^*^HM>YLZ&cs}Xd=djjqD$%_%>QFwjIp)x=vf7tl=2x>`=4I8= zg3@ntmwg^J`eqlp77NI5)eCgR6EZz)L ziwKp~vdPFWM`P0%r~9Ru+M4fl9a2+3`RrE#_<~*-> z#ZCp(A?pUxo>pTN74xp{&itms);ePov@c{TvfT5LO;(k7*<8EBN~|uE78IL0~!Gt7a;=v|%g9tIRq0ODOEKso1dpsf|gcHq3Ae$}GAeG-GVz&>~c!@&?5k#kU2e%QTGQ z182!zz3OyJYa3DI9QO-g-#29%&!k#cF#OwLn+vAxJnR?MWs_(vt+Yq=A;qw?a^hX1 zEGs>}qIOp_lwnEV0gn%x4(XRwG9I@^UmZz`dqpt%vc_vXTWimqaG0D;4dH`MMb(zowIa}RARntOCYPz8Na zKy|AseWzr-zOQLCSAJ8|s;ZRT{&8X{rZZ>>XPc?|-y8FZKtJjNTKKn3ZU3;cPgnJ6 zHKVttO0+vrci#=Fbszt(sTx<^(7rW$i-v(BXQ2~$T;1?MtrPb!6&udj3jC3kZ6X;Z0Z?&wJ>}(UPm8L!g@^(_&c1Z2POBb)|2IMB9>P(Yo|EQ2GG%Sv{Fg6|E@<_5Ttc9z>>$99~yViZvX@8hQ^_Ki9X1F!>c7O3wZJvOtB*()z=ODwLo&} zsz}bEq^^Vz(OTVY?r&<{Y-^b`MxBT-qF)oNT8F{I+Req0oKGW-YONG7oNC;c4=JER zL&FPoa9L;d-$DygyVX*A8yZDX*QbT2u5SeCX?%2vG~&;iH;#l<+1)tpm9MT*qgQ%u zG}75972H_*)=Ir**Gi>x0&kO2ht*e)8vB=H9bg&_TFk^I$~DK3+&T&M4j2Q5HdeKo z8U>LT(b}JuhZc9os5wogZ-L$_;a#+8!aUwsjct}j5n4r5#8}eytrFs8KVLEz%Em#M z0W#K`l2)d*mft5*b7M=1NGcB_EAvQsV31ByIa(Thh!vlc>0Ul{ zqNV>hj*c&A3(@g~_f)plvYuK}S`@LfdtmHLA*yc}0fLkEC{4bv8n%(8RM8A{&ec4w z7np6Q64keAM0rEIC*_R~p!p|?*Ha%4Hu457kZ6Hvfn=I`v#rskX)!I|oeo9czShLH zho$2g6m@&A|Er3%NR(e@LZpiecpKHNrQtNr@WgygYnIyGPWq0MSxYXnRonK)k_!o= z+e2&laq2{SBV+>|XAT6|w~$x;r>@NE_~w%PEGdVMuY3nXTx+@5jRHd#aZT~_FiK8Z zGD=SKRE~~@)Y|*3iQ#-TyQ2}^T6Ak6A)W|TRG(LkVT_dn6l@heva#QaE(Y>i2pY)a zq|j@|7{}VAUPz4%FOT;*0*5cORIhUgE!8g~gXc_bmPSljebR?2+Z#roL@8L8K}&aw zsj_?JaawYGTO%t3hRG6DrIQgR-t?kNqJDcRNpo^i6TeY}xpKTr4SdrWBtWx{Mrg%3 zLGjK;pBy-_Tuy|V?)B>n*?J9Reniaj?vTVxDz%a*rsBHzS{A><8ej-zy z7%p?!XMqFbVWm3JO_rr!+svxIjxm;av_h;6ypJ7f+iw2eX0cWg%eT!Jm<(4Fp#=$7 z+8+2=BY-tHt7)1CJG0u^s-u~osGZ%7rNY1w_gdAkhvAKsn6z0bF?~u7(!DGXvAZGf zd`%N+zP65tq2Z#PJtww?@9Pm5;d|?-%Ds#zMw6ZDI-ryd+KVnUr>yNa1E)0;T^qel zw$b5LP@Q`lQAi%8Qyh6zA`-%-1YX-dO{PssiyE3olZDS9RLah@x-e@JwuxjvAC^W? zYMWUpWV7nt*GM50jaqU#Y`ujfZ+M|m8ZGp?nggdE;K_9eDW1#Ek!<1;3YCA-hRwoX~EGlRvPTxHnZRjMh zvAc<13DF&*)(-U_M+X+ahv>crYXXgZbtpAPqxPz+LyRnCtyd?b!B1D>bnv~=vWT5W zEZ#ncS6vM;cc-i^w*6|ta9KemcZSGTmeFBH>eCX@`O5=dYE}E#bRhL0QQN2)U1U%i zRBQ3&3!?fKU#waDA+_%<%;F)J-+TXB{j>?Fg`-94FNx}x+$_Rjm2;$QNh0}{gaZ@$ zSH$wIDUddGghZl>BXA!ztd^)ouHct3yaH)93G}sxUD6#{xwyJFIE{qw6io@_D3RyX z#^FjB!sl;xCDftl;;BP9=6NFgxySj&+3+P_$;UmsTDA{34vFEHH~vo$@kDLBC?DwP z)_gI=LoD_D7oXE|cq3|Wh}uq;`;dex3edG(wcHXcD5mkvoV@O5+DLt1CM&J*AF@@<0oLgWRySJWNU zIlbz#z|;W!WChLCbgeXxy{Lw{j6t!bqDv}Utf3+;GL1TQ)94)5W#st#bt|fb$w+(H z1@LJJZk}Idp5Wn*2KS2Q4z_=4!kUs?g`$GiVM-F%dPiHxy1HuW2U0;EzYZrrpV#fT zc&i1VjZXccRr|B=|&`x;94rm$`3Uo z&C)P#)ifHn{zBSK!~vt*W`*9dujbVP?^p2RLU~1%Z?!F$^FpCMenb0Jzi|~cTl#)9 zNB1q(X|CTP*qEajxyBiyYnrv8^#>~K_8FF8!W$SBQdDS}Xz27OO3Hq$nY~V>OQNZR zrqKz(zd%bq-io$1`~uPn^+%wEyc?pHHGr~Xx*5BWH0{)-RY7TgYg%bFAiIBQ)_mYG z#Zk_t_z3}cg)awr7ew?DGwl>S0Wo5DZ|69`+8}`nUVtw;Hk&` zD<_}VL`v_^h?tlkuVV)iDF8IF4v0*E*eyR&mVX4~SJvR43+V96s&;=thhTKlrbEj@ zeHw2Z9?{v+8WTzttc)?CwK0wjC?$)o{I|O>*bxoWbru&~(3F|Hz=3 zs!hD~`&kAuk(QWTKclL$&{#{-u{vj==VWys5HdkK?rR_F{W#V3C80Oue72;ih1O&= zxS1Vp2m6ehb?6}rQIf+esxPCBCR!`!FOWU(%d2(m1!%p@V7=X*)kCbQVq@vIC(Pfm zu=Y%{VXTn+IS*C|&GG5}Vt-$x^&{=uv~iN%A&0AXmlzUSSvvI3zqsE$K9Z%L18)Yhi%Egz}BT?5K z<@XR@RLL#SknjZmxV1c_fQMa1%`T473#2qUJo6k*L4of4Nei6AL3i%+NUxu0?a_Wy zA;j(Yi*?hmmR68u3Y?`{X_&%NaS=6al`N=+7QzCD^}8%qL=|;d*;g4SpR5orMg-r+ zl(kG6tnRHcI&tgRUx*sI+E_IvkJNUhg@RD^V70MqXPuNOu4b<>?&&sLE2bq#M(r7_x(DS0Yx5+s9WR1$J(YR8%=`B^nJ|k~yx20`9{cu}6+=>WA=%AE} z-G>D>>(I5e!`9ki;+I*8>03VY8b&(=tsJz0Lxk+d8(eJ;82ZyZTJF_6n&!84c;V{u zA^(jH>kXPHhgVv!p>^#}V^Py}0w*f%d=HdX<-af#XDy7j_s~@20UY?<{nbAXWwgY! zjPr`|L{=4h08^`|BmQBl8)}W%JE#+1I?JnB?6#8IX;YBfbtG0Twc{)Q23lRktHkmh zdqSeZq&Jb<#SAGfd+@VY^T4g8i@oubVXd~axe4N{eFJVlvKD~QH( zoxq4(Rg<*hiyUu3x~ZhcH`U&+|0l~~orz!69o{vYJ*~0U#kvs5cS_3}uew%>*RD>j zfwLJhgE#uSQB?1H6AN|ESL=K&p^>>J(mOEG&xy}xQhp<05>AuLgWTOi4z_20)@h?2 zs^M{SP!}*A>#6o0H4e&ZnWG+kjNNd1W9+vw0K()zie{;J9; zBZ+y9=S{W)Fj9Ai%*1a(ngexGfv$v9Fi=(b#!wHvlA#|jiF<=+p#Pu?28Pywd#xI4 zq%&9rpEi0GYZN?0tv_vKQ~hRg3c2SI;*?KzJ?!6&Iy)iA+rGc>&H9 z=%AJZO;$6n7>iJWRlTS9Rii3PnN!r@tA?qpd+)1@|9EezdO6j24wd@M|A9*KyO&>C z)}5wGT{8r-S~FeExn{J+`q8=>bgz&KzHWqyCGkumg(e!A{gy^b@= zJ+l!&2}kIM{k}5-%?kQBhf+X|{t-QP^bP6zb#qIYIV$4DKdET0n)5vbO}=3W3I}s^ zNP8DDg)L$V)^1I(8=c$A&)BhgP}3YR`Kec9}FQa8Ihb<@(3M zfk|aCm6BIA_{ms^2@KjL#PVf6O`sI2bxQrhQkCl=S$S~dd^dHhoHN0&MF3>7;26sG#xSt|6i>!6JO3)&~%* zD%Prk_x`ntPnGMQe-%~<>(tKyC0K;@s@;A6Dn7g~bLXa4iSwYD8%Q5-jTqj0*dTRs zpwWK@YGk7-{J_5~tFlBjA%O7p1CLJgp|a1^j{$^*zj_GyLD-~PKQv5>>0my!;GxW; z&6f*=%_Q!K;r$1vAuRcTp3RdFY$4*?>g3O`>$pK8k8Mb+($Cd|UyMov8@^Tj^oxJP qt#&1;w!iulsEWL#Wop+pEe+H>xci8ns{0uuGg+>^T^0RJ7XCj_1AFrT