From 059e6a5bb27992c06dc2fbd1e8cb586cf0c2e081 Mon Sep 17 00:00:00 2001 From: tian2020 Date: Thu, 15 Jun 2023 14:10:29 +0800 Subject: [PATCH] init and adapt to openeuler --- 0001-init-and-adapt-to-openeuler.patch | 4056 +++++++++++++++++ 0002-fix-build-gn-files-config.patch | 67 + 0003-feat-set-priv-false.patch | 30 + hilog.spec | 85 + ...wdfx_hilog-OpenHarmony-v3.2-Release.tar.gz | Bin 0 -> 210043 bytes 5 files changed, 4238 insertions(+) create mode 100644 0001-init-and-adapt-to-openeuler.patch create mode 100644 0002-fix-build-gn-files-config.patch create mode 100644 0003-feat-set-priv-false.patch create mode 100644 hilog.spec create mode 100644 hiviewdfx_hilog-OpenHarmony-v3.2-Release.tar.gz diff --git a/0001-init-and-adapt-to-openeuler.patch b/0001-init-and-adapt-to-openeuler.patch new file mode 100644 index 0000000..8faea2e --- /dev/null +++ b/0001-init-and-adapt-to-openeuler.patch @@ -0,0 +1,4056 @@ +From 4611bb6a513f43fee84946994d5b5fe05e341c16 Mon Sep 17 00:00:00 2001 +From: tian2020 +Date: Wed, 14 Jun 2023 17:32:44 +0800 +Subject: [PATCH 1/3] init and adapt to openeuler + +--- + frameworks/libhilog/BUILD.gn | 101 +- + frameworks/libhilog/base/hilog_base.cpp | 535 +++---- + frameworks/libhilog/hilog.cpp | 121 +- + frameworks/libhilog/hilog_printf.cpp | 3 +- + frameworks/libhilog/include/hilog_cmd.h | 2 +- + frameworks/libhilog/utils/include/log_print.h | 94 +- + frameworks/libhilog/utils/include/log_utils.h | 220 +-- + frameworks/libhilog/utils/log_print.cpp | 360 ++--- + frameworks/libhilog/utils/log_utils.cpp | 1044 ++++++------- + .../libhilog/vsnprintf/include/output_p.inl | 1294 +++++++++++++++++ + hilog.gni | 6 +- + interfaces/bundle.json | 5 +- + interfaces/native/innerkits/BUILD.gn | 41 +- + .../native/innerkits/include/hilog/log_c.h | 4 +- + .../native/innerkits/include/hilog/log_cpp.h | 17 +- + 15 files changed, 2590 insertions(+), 1257 deletions(-) + create mode 100644 frameworks/libhilog/vsnprintf/include/output_p.inl + +diff --git a/frameworks/libhilog/BUILD.gn b/frameworks/libhilog/BUILD.gn +index fe1a662..f8372a9 100644 +--- a/frameworks/libhilog/BUILD.gn ++++ b/frameworks/libhilog/BUILD.gn +@@ -39,78 +39,33 @@ config("libhilog_config") { + ] + } + +-template("libhilog_source") { +- forward_variables_from(invoker, "*") +- ohos_source_set(target_name) { +- if (platform != "windows" && platform != "mac" && platform != "linux") { +- param_sources = [ "$param_root/properties.cpp" ] +- ioctl_sources = [ "$ioctl_root/log_ioctl.cpp" ] +- +- socket_sources = [ +- "$socket_root/dgram_socket_client.cpp", +- "$socket_root/dgram_socket_server.cpp", +- "$socket_root/hilog_input_socket_client.cpp", +- "$socket_root/hilog_input_socket_server.cpp", +- "$socket_root/seq_packet_socket_client.cpp", +- "$socket_root/seq_packet_socket_server.cpp", +- "$socket_root/socket.cpp", +- "$socket_root/socket_client.cpp", +- "$socket_root/socket_server.cpp", +- ] +- } +- +- utils_sources = [ +- "$utils_root/log_print.cpp", +- "$utils_root/log_utils.cpp", +- ] +- +- vsnprintf_sources = [ "$vsnprintf_root/vsnprintf_s_p.cpp" ] +- +- sources = [ +- "hilog.cpp", +- "hilog_printf.cpp", +- ] +- if (platform != "windows" && platform != "mac" && platform != "linux") { +- sources += param_sources +- sources += ioctl_sources +- sources += socket_sources +- } +- sources += utils_sources +- sources += vsnprintf_sources +- +- defines = [] +- if (platform == "windows") { +- cflags_cc = [ "-std=c++17" ] +- defines += [ "__WINDOWS__" ] +- } else if (platform == "mac") { +- defines += [ "__MAC__" ] +- } else if (platform == "linux") { +- cflags_cc = [ "-std=c++17" ] +- defines += [ "__LINUX__" ] +- } else { +- defines = [ "__RECV_MSG_WITH_UCRED_" ] +- if (use_musl) { +- defines += [ "HILOG_USE_MUSL" ] +- } +- } +- public_configs = [ ":libhilog_config" ] +- configs = [ ":libhilog_config" ] +- +- deps = [ "//third_party/bounds_checking_function:libsec_shared" ] +- +- if (platform != "windows" && platform != "mac" && platform != "linux") { +- external_deps = [ "init:libbegetutil" ] +- } +- +- part_name = "hilog_native" +- subsystem_name = "hiviewdfx" +- } +-} ++ohos_source_set("libhilog_source") { ++ ++ utils_sources = [ ++ "$utils_root/log_print.cpp", ++ "$utils_root/log_utils.cpp", ++ ] ++ ++ vsnprintf_sources = [ "$vsnprintf_root/vsnprintf_s_p.cpp" ] ++ ++ sources = [ ++ "hilog.cpp", ++ "hilog_printf.cpp", ++ ] ++ sources += utils_sources ++ sources += vsnprintf_sources + +-foreach(item, platforms) { +- libhilog_source("libhilog_source_" + item) { +- platform = item +- } ++ defines = [] ++ cflags_cc = [ "-std=c++17" ] ++ defines += [ "__LINUX__" ] ++ ++ public_configs = [ ":libhilog_config" ] ++ configs = [ ":libhilog_config" ] ++ ++ deps = [ "//third_party/bounds_checking_function:libsec_shared" ] ++ ++ part_name = "hilog_native" ++ subsystem_name = "hiviewdfx" + } + + config("libhilog_base_config") { +@@ -124,10 +79,10 @@ ohos_source_set("libhilog_base_source") { + "//base/hiviewdfx/hilog/interfaces/native/innerkits/include", + ] + +- vsnprintf_sources = [ "$vsnprintf_root/vsnprintf_s_p.cpp" ] ++ # vsnprintf_sources = [ "$vsnprintf_root/vsnprintf_s_p.cpp" ] + + sources = [ "$libhilog_base_root/hilog_base.cpp" ] +- sources += vsnprintf_sources ++ # sources += vsnprintf_sources + + defines = [ + "__RECV_MSG_WITH_UCRED_", +diff --git a/frameworks/libhilog/base/hilog_base.cpp b/frameworks/libhilog/base/hilog_base.cpp +index 8e8e248..85337b8 100644 +--- a/frameworks/libhilog/base/hilog_base.cpp ++++ b/frameworks/libhilog/base/hilog_base.cpp +@@ -16,279 +16,280 @@ + #include "hilog_base/log_base.h" + + #include +-#include +- +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +- +-namespace { +-constexpr int SOCKET_TYPE = SOCK_DGRAM | SOCK_NONBLOCK | SOCK_CLOEXEC; +-constexpr int INVALID_SOCKET = -1; +-constexpr size_t HILOG_VEC_MAX_SIZE = 4; +-constexpr size_t HILOG_VEC_SIZE_OHCORE = 4; +-constexpr size_t HILOG_VEC_SIZE_OH = 3; +-constexpr int32_t MAX_DOMAIN_TAGSIZE = 64; +- +-struct SocketHandler { +- std::atomic_int socketFd {INVALID_SOCKET}; +- std::atomic_bool isConnected {false}; +- ~SocketHandler() +- { +- int currentFd = socketFd.exchange(INVALID_SOCKET); +- if (currentFd >= 0) { +- close(currentFd); +- } +- } +-}; +- +-typedef struct LogTime { +- uint32_t tvSec; +- uint32_t tvNsec; +-} __attribute__((__packed__)) LogTime; +- +-typedef struct __attribute__((__packed__)) { +- uint8_t id; +- uint16_t tid; +- uint16_t ohPid; +- LogTime realtime; +-} LogHeader; +- +-struct HiLogMsgInfo { +- HilogMsg *header_; +- const char *tag_; +- uint16_t tagLen_; +- const char *fmt_; +- uint16_t fmtLen_; +- HiLogMsgInfo(HilogMsg *header, const char *tag, uint16_t tagLen, const char *fmt, uint16_t fmtLen) +- { +- header_ = header; +- tag_ = tag; +- tagLen_ = tagLen; +- fmt_ = fmt; +- fmtLen_ = fmtLen; +- } +-}; +- +-typedef enum { +- TYPE_OH = 0, +- TYPE_OHCORE = 1, +-} HiLogProtocolType; +- +-sockaddr_un g_sockAddr = {AF_UNIX, SOCKET_FILE_DIR INPUT_SOCKET_NAME}; +-HiLogProtocolType g_protocolType = TYPE_OH; +- +-struct Initializer { +- Initializer() +- { +- constexpr char configFile[] = "/system/etc/hilog_config"; +- if (access(configFile, F_OK) != 0) { +- return; +- } +- std::ifstream file; +- file.open(configFile); +- if (file.fail()) { +- std::cerr << "open hilog_config config file failed" << std::endl; +- return; +- } +- +- std::string sock; +- std::string protocol; +- file >> sock >> protocol; +- if (auto posColon = sock.find(":"); posColon != sock.npos) { +- std::string sockPath = sock.substr(posColon + 1); +- size_t pos = 0; +- while (pos < sockPath.size() && pos < (sizeof(g_sockAddr.sun_path) - 1)) { +- g_sockAddr.sun_path[pos] = sockPath[pos]; +- pos++; +- } +- g_sockAddr.sun_path[pos] = '\0'; +- } +- if (auto posColon = protocol.find(":"); posColon != protocol.npos) { +- g_protocolType = protocol.substr(posColon + 1) == "ohcore" ? TYPE_OHCORE : TYPE_OH; +- } +- file.close(); +- } +-}; +-Initializer g_initializer; +- +-static int GenerateFD() +-{ +- int tmpFd = TEMP_FAILURE_RETRY(socket(PF_UNIX, SOCKET_TYPE, 0)); +- int res = tmpFd; +- if (tmpFd == 0) { +- res = TEMP_FAILURE_RETRY(socket(PF_UNIX, SOCKET_TYPE, 0)); +- close(tmpFd); +- } +- return res; +-} +- +-static int CheckSocket(SocketHandler& socketHandler) +-{ +- int currentFd = socketHandler.socketFd.load(); +- if (currentFd >= 0) { +- return currentFd; +- } +- +- int fd = GenerateFD(); +- if (fd < 0) { +- std::cerr << "Can't get hilog socket! Errno: " << errno << std::endl; +- return fd; +- } +- +- currentFd = INVALID_SOCKET; +- if (!socketHandler.socketFd.compare_exchange_strong(currentFd, fd)) { +- close(fd); +- return currentFd; +- } +- return fd; +-} +- +-static int CheckConnection(SocketHandler& socketHandler) +-{ +- bool isConnected = socketHandler.isConnected.load(); +- if (isConnected) { +- return 0; +- } +- +- isConnected = socketHandler.isConnected.load(); +- if (isConnected) { +- return 0; +- } +- +- auto result = TEMP_FAILURE_RETRY(connect(socketHandler.socketFd.load(), +- reinterpret_cast(&g_sockAddr), sizeof(g_sockAddr))); +- if (result < 0) { +- std::cerr << "Can't connect to hilog server. Errno: " << errno << std::endl; +- return result; +- } +- socketHandler.isConnected.store(true); +- return 0; +-} +- +-static size_t BuildHilogMessageForOhCore(struct HiLogMsgInfo* logMsgInfo, LogHeader& logHeader, uint16_t& logLevel, +- char tagBuf[], struct iovec *vec) +-{ +- struct timespec ts = {0}; +- (void)clock_gettime(CLOCK_REALTIME, &ts); +- logHeader.realtime.tvSec = static_cast(ts.tv_sec); +- logHeader.realtime.tvNsec = static_cast(ts.tv_nsec); +- logHeader.tid = static_cast(gettid()); +- logHeader.ohPid = static_cast(getpid()); +- logLevel = logMsgInfo->header_->level; +- constexpr uint32_t domainFilter = 0x000FFFFF; +- if (vsnprintfp_s(tagBuf, MAX_DOMAIN_TAGSIZE, MAX_DOMAIN_TAGSIZE - 1, false, "%05X/%s", +- (logMsgInfo->header_->domain & domainFilter), logMsgInfo->tag_) < 0) { +- return 0; +- } +- +- vec[0].iov_base = reinterpret_cast(&logHeader); // 0 : index of hos log header +- vec[0].iov_len = sizeof(logHeader); // 0 : index of hos log header +- vec[1].iov_base = reinterpret_cast(&logLevel); // 1 : index of log level +- vec[1].iov_len = 1; // 1 : index of log level +- vec[2].iov_base = reinterpret_cast(const_cast(tagBuf)); // 2 : index of log tag +- vec[2].iov_len = strlen(tagBuf) + 1; // 2 : index of log tag +- vec[3].iov_base = reinterpret_cast(const_cast(logMsgInfo->fmt_)); // 3 : index of log format +- vec[3].iov_len = logMsgInfo->fmtLen_; // 3 : index of log format +- return HILOG_VEC_SIZE_OHCORE; +-} +- +-static size_t BuildHilogMessageForOh(struct HiLogMsgInfo* logMsgInfo, struct iovec *vec) +-{ +- struct timespec ts = {0}; +- (void)clock_gettime(CLOCK_REALTIME, &ts); +- struct timespec tsMono = {0}; +- (void)clock_gettime(CLOCK_MONOTONIC, &tsMono); +- logMsgInfo->header_->tv_sec = static_cast(ts.tv_sec); +- logMsgInfo->header_->tv_nsec = static_cast(ts.tv_nsec); +- logMsgInfo->header_->mono_sec = static_cast(tsMono.tv_sec); +- logMsgInfo->header_->len = sizeof(HilogMsg) + logMsgInfo->tagLen_ + logMsgInfo->fmtLen_; +- logMsgInfo->header_->tag_len = logMsgInfo->tagLen_; +- +- vec[0].iov_base = logMsgInfo->header_; // 0 : index of hos log header +- vec[0].iov_len = sizeof(HilogMsg); // 0 : index of hos log header +- vec[1].iov_base = reinterpret_cast(const_cast(logMsgInfo->tag_)); // 1 : index of log tag +- vec[1].iov_len = logMsgInfo->tagLen_; // 1 : index of log tag +- vec[2].iov_base = reinterpret_cast(const_cast(logMsgInfo->fmt_)); // 2 : index of log content +- vec[2].iov_len = logMsgInfo->fmtLen_; // 2 : index of log content +- return HILOG_VEC_SIZE_OH; +-} +- +-static int SendMessage(HilogMsg *header, const char *tag, uint16_t tagLen, const char *fmt, uint16_t fmtLen) +-{ +- SocketHandler socketHandler; +- int ret = CheckSocket(socketHandler); +- if (ret < 0) { +- return ret; +- } +- ret = CheckConnection(socketHandler); +- if (ret < 0) { +- return ret; +- } +- +- struct iovec vec[HILOG_VEC_MAX_SIZE]; +- struct HiLogMsgInfo msgInfo(header, tag, tagLen, fmt, fmtLen); +- LogHeader logHeader; +- uint16_t logLevel = 0; +- char tagBuf[MAX_DOMAIN_TAGSIZE] = {0}; +- auto vecSize = (g_protocolType == TYPE_OHCORE) ? +- BuildHilogMessageForOhCore(&msgInfo, logHeader, logLevel, tagBuf, vec) : +- BuildHilogMessageForOh(&msgInfo, vec); +- if (vecSize == 0) { +- std::cerr << "BuildHilogMessage failed ret = " << vecSize << std::endl; +- return RET_FAIL; +- } +- return TEMP_FAILURE_RETRY(::writev(socketHandler.socketFd.load(), vec, vecSize)); +-} +- +-static int HiLogBasePrintArgs(const LogType type, const LogLevel level, const unsigned int domain, const char *tag, +- const char *fmt, va_list ap) +-{ +- if (!HiLogBaseIsLoggable(domain, tag, level)) { +- return -1; +- } +- +- char buf[MAX_LOG_LEN] = {0}; +- +- vsnprintfp_s(buf, MAX_LOG_LEN, MAX_LOG_LEN - 1, true, fmt, ap); +- +- auto tagLen = strnlen(tag, MAX_TAG_LEN - 1); +- auto logLen = strnlen(buf, MAX_LOG_LEN - 1); +- HilogMsg header = {0}; +- header.type = type; +- header.level = level; +-#ifndef __RECV_MSG_WITH_UCRED_ +- header.pid = getpid(); +-#endif +- header.tid = static_cast(gettid()); +- header.domain = domain; +- +- return SendMessage(&header, tag, tagLen + 1, buf, logLen + 1); +-} +- +-} // namespace ++// #include ++ ++// #include ++// #include ++// #include ++// #include ++// #include ++// #include ++// #include ++// #include ++// #include ++// #include ++ ++// namespace { ++// constexpr int SOCKET_TYPE = SOCK_DGRAM | SOCK_NONBLOCK | SOCK_CLOEXEC; ++// constexpr int INVALID_SOCKET = -1; ++// constexpr size_t HILOG_VEC_MAX_SIZE = 4; ++// constexpr size_t HILOG_VEC_SIZE_OHCORE = 4; ++// constexpr size_t HILOG_VEC_SIZE_OH = 3; ++// constexpr int32_t MAX_DOMAIN_TAGSIZE = 64; ++ ++// struct SocketHandler { ++// std::atomic_int socketFd {INVALID_SOCKET}; ++// std::atomic_bool isConnected {false}; ++// ~SocketHandler() ++// { ++// int currentFd = socketFd.exchange(INVALID_SOCKET); ++// if (currentFd >= 0) { ++// close(currentFd); ++// } ++// } ++// }; ++ ++// typedef struct LogTime { ++// uint32_t tvSec; ++// uint32_t tvNsec; ++// } __attribute__((__packed__)) LogTime; ++ ++// typedef struct __attribute__((__packed__)) { ++// uint8_t id; ++// uint16_t tid; ++// uint16_t ohPid; ++// LogTime realtime; ++// } LogHeader; ++ ++// struct HiLogMsgInfo { ++// HilogMsg *header_; ++// const char *tag_; ++// uint16_t tagLen_; ++// const char *fmt_; ++// uint16_t fmtLen_; ++// HiLogMsgInfo(HilogMsg *header, const char *tag, uint16_t tagLen, const char *fmt, uint16_t fmtLen) ++// { ++// header_ = header; ++// tag_ = tag; ++// tagLen_ = tagLen; ++// fmt_ = fmt; ++// fmtLen_ = fmtLen; ++// } ++// }; ++ ++// typedef enum { ++// TYPE_OH = 0, ++// TYPE_OHCORE = 1, ++// } HiLogProtocolType; ++ ++// sockaddr_un g_sockAddr = {AF_UNIX, SOCKET_FILE_DIR INPUT_SOCKET_NAME}; ++// HiLogProtocolType g_protocolType = TYPE_OH; ++ ++// struct Initializer { ++// Initializer() ++// { ++// constexpr char configFile[] = "/system/etc/hilog_config"; ++// if (access(configFile, F_OK) != 0) { ++// return; ++// } ++// std::ifstream file; ++// file.open(configFile); ++// if (file.fail()) { ++// std::cerr << "open hilog_config config file failed" << std::endl; ++// return; ++// } ++ ++// std::string sock; ++// std::string protocol; ++// file >> sock >> protocol; ++// if (auto posColon = sock.find(":"); posColon != sock.npos) { ++// std::string sockPath = sock.substr(posColon + 1); ++// size_t pos = 0; ++// while (pos < sockPath.size() && pos < (sizeof(g_sockAddr.sun_path) - 1)) { ++// g_sockAddr.sun_path[pos] = sockPath[pos]; ++// pos++; ++// } ++// g_sockAddr.sun_path[pos] = '\0'; ++// } ++// if (auto posColon = protocol.find(":"); posColon != protocol.npos) { ++// g_protocolType = protocol.substr(posColon + 1) == "ohcore" ? TYPE_OHCORE : TYPE_OH; ++// } ++// file.close(); ++// } ++// }; ++// Initializer g_initializer; ++ ++// static int GenerateFD() ++// { ++// int tmpFd = TEMP_FAILURE_RETRY(socket(PF_UNIX, SOCKET_TYPE, 0)); ++// int res = tmpFd; ++// if (tmpFd == 0) { ++// res = TEMP_FAILURE_RETRY(socket(PF_UNIX, SOCKET_TYPE, 0)); ++// close(tmpFd); ++// } ++// return res; ++// } ++ ++// static int CheckSocket(SocketHandler& socketHandler) ++// { ++// int currentFd = socketHandler.socketFd.load(); ++// if (currentFd >= 0) { ++// return currentFd; ++// } ++ ++// int fd = GenerateFD(); ++// if (fd < 0) { ++// std::cerr << "Can't get hilog socket! Errno: " << errno << std::endl; ++// return fd; ++// } ++ ++// currentFd = INVALID_SOCKET; ++// if (!socketHandler.socketFd.compare_exchange_strong(currentFd, fd)) { ++// close(fd); ++// return currentFd; ++// } ++// return fd; ++// } ++ ++// static int CheckConnection(SocketHandler& socketHandler) ++// { ++// bool isConnected = socketHandler.isConnected.load(); ++// if (isConnected) { ++// return 0; ++// } ++ ++// isConnected = socketHandler.isConnected.load(); ++// if (isConnected) { ++// return 0; ++// } ++ ++// auto result = TEMP_FAILURE_RETRY(connect(socketHandler.socketFd.load(), ++// reinterpret_cast(&g_sockAddr), sizeof(g_sockAddr))); ++// if (result < 0) { ++// std::cerr << "Can't connect to hilog server. Errno: " << errno << std::endl; ++// return result; ++// } ++// socketHandler.isConnected.store(true); ++// return 0; ++// } ++ ++// static size_t BuildHilogMessageForOhCore(struct HiLogMsgInfo* logMsgInfo, LogHeader& logHeader, uint16_t& logLevel, ++// char tagBuf[], struct iovec *vec) ++// { ++// struct timespec ts = {0}; ++// (void)clock_gettime(CLOCK_REALTIME, &ts); ++// logHeader.realtime.tvSec = static_cast(ts.tv_sec); ++// logHeader.realtime.tvNsec = static_cast(ts.tv_nsec); ++// logHeader.tid = static_cast(gettid()); ++// logHeader.ohPid = static_cast(getpid()); ++// logLevel = logMsgInfo->header_->level; ++// constexpr uint32_t domainFilter = 0x000FFFFF; ++// if (vsnprintfp_s(tagBuf, MAX_DOMAIN_TAGSIZE, MAX_DOMAIN_TAGSIZE - 1, false, "%05X/%s", ++// (logMsgInfo->header_->domain & domainFilter), logMsgInfo->tag_) < 0) { ++// return 0; ++// } ++ ++// vec[0].iov_base = reinterpret_cast(&logHeader); // 0 : index of hos log header ++// vec[0].iov_len = sizeof(logHeader); // 0 : index of hos log header ++// vec[1].iov_base = reinterpret_cast(&logLevel); // 1 : index of log level ++// vec[1].iov_len = 1; // 1 : index of log level ++// vec[2].iov_base = reinterpret_cast(const_cast(tagBuf)); // 2 : index of log tag ++// vec[2].iov_len = strlen(tagBuf) + 1; // 2 : index of log tag ++// vec[3].iov_base = reinterpret_cast(const_cast(logMsgInfo->fmt_)); // 3 : index of log format ++// vec[3].iov_len = logMsgInfo->fmtLen_; // 3 : index of log format ++// return HILOG_VEC_SIZE_OHCORE; ++// } ++ ++// static size_t BuildHilogMessageForOh(struct HiLogMsgInfo* logMsgInfo, struct iovec *vec) ++// { ++// struct timespec ts = {0}; ++// (void)clock_gettime(CLOCK_REALTIME, &ts); ++// struct timespec tsMono = {0}; ++// (void)clock_gettime(CLOCK_MONOTONIC, &tsMono); ++// logMsgInfo->header_->tv_sec = static_cast(ts.tv_sec); ++// logMsgInfo->header_->tv_nsec = static_cast(ts.tv_nsec); ++// logMsgInfo->header_->mono_sec = static_cast(tsMono.tv_sec); ++// logMsgInfo->header_->len = sizeof(HilogMsg) + logMsgInfo->tagLen_ + logMsgInfo->fmtLen_; ++// logMsgInfo->header_->tag_len = logMsgInfo->tagLen_; ++ ++// vec[0].iov_base = logMsgInfo->header_; // 0 : index of hos log header ++// vec[0].iov_len = sizeof(HilogMsg); // 0 : index of hos log header ++// vec[1].iov_base = reinterpret_cast(const_cast(logMsgInfo->tag_)); // 1 : index of log tag ++// vec[1].iov_len = logMsgInfo->tagLen_; // 1 : index of log tag ++// vec[2].iov_base = reinterpret_cast(const_cast(logMsgInfo->fmt_)); // 2 : index of log content ++// vec[2].iov_len = logMsgInfo->fmtLen_; // 2 : index of log content ++// return HILOG_VEC_SIZE_OH; ++// } ++ ++// static int SendMessage(HilogMsg *header, const char *tag, uint16_t tagLen, const char *fmt, uint16_t fmtLen) ++// { ++// SocketHandler socketHandler; ++// int ret = CheckSocket(socketHandler); ++// if (ret < 0) { ++// return ret; ++// } ++// ret = CheckConnection(socketHandler); ++// if (ret < 0) { ++// return ret; ++// } ++ ++// struct iovec vec[HILOG_VEC_MAX_SIZE]; ++// struct HiLogMsgInfo msgInfo(header, tag, tagLen, fmt, fmtLen); ++// LogHeader logHeader; ++// uint16_t logLevel = 0; ++// char tagBuf[MAX_DOMAIN_TAGSIZE] = {0}; ++// auto vecSize = (g_protocolType == TYPE_OHCORE) ? ++// BuildHilogMessageForOhCore(&msgInfo, logHeader, logLevel, tagBuf, vec) : ++// BuildHilogMessageForOh(&msgInfo, vec); ++// if (vecSize == 0) { ++// std::cerr << "BuildHilogMessage failed ret = " << vecSize << std::endl; ++// return RET_FAIL; ++// } ++// return TEMP_FAILURE_RETRY(::writev(socketHandler.socketFd.load(), vec, vecSize)); ++// } ++ ++// static int HiLogBasePrintArgs(const LogType type, const LogLevel level, const unsigned int domain, const char *tag, ++// const char *fmt, va_list ap) ++// { ++// if (!HiLogBaseIsLoggable(domain, tag, level)) { ++// return -1; ++// } ++ ++// char buf[MAX_LOG_LEN] = {0}; ++ ++// vsnprintfp_s(buf, MAX_LOG_LEN, MAX_LOG_LEN - 1, true, fmt, ap); ++ ++// auto tagLen = strnlen(tag, MAX_TAG_LEN - 1); ++// auto logLen = strnlen(buf, MAX_LOG_LEN - 1); ++// HilogMsg header = {0}; ++// header.type = type; ++// header.level = level; ++// #ifndef __RECV_MSG_WITH_UCRED_ ++// header.pid = getpid(); ++// #endif ++// header.tid = static_cast(gettid()); ++// header.domain = domain; ++ ++// return SendMessage(&header, tag, tagLen + 1, buf, logLen + 1); ++// } ++ ++// } // namespace + + int HiLogBasePrint(LogType type, LogLevel level, unsigned int domain, const char *tag, const char *fmt, ...) + { +- int ret; +- va_list ap; +- va_start(ap, fmt); +- ret = HiLogBasePrintArgs(type, level, domain, tag, fmt, ap); +- va_end(ap); +- return ret; ++ // int ret; ++ // va_list ap; ++ // va_start(ap, fmt); ++ // ret = HiLogBasePrintArgs(type, level, domain, tag, fmt, ap); ++ // va_end(ap); ++ // return ret; ++ return 0; + } + + bool HiLogBaseIsLoggable(unsigned int domain, const char *tag, LogLevel level) + { +- if ((level <= LOG_LEVEL_MIN) || (level >= LOG_LEVEL_MAX) || tag == nullptr) { +- return false; +- } ++ // if ((level <= LOG_LEVEL_MIN) || (level >= LOG_LEVEL_MAX) || tag == nullptr) { ++ // return false; ++ // } + return true; + } +diff --git a/frameworks/libhilog/hilog.cpp b/frameworks/libhilog/hilog.cpp +index 80980cb..e58c6d6 100644 +--- a/frameworks/libhilog/hilog.cpp ++++ b/frameworks/libhilog/hilog.cpp +@@ -1,23 +1,26 @@ +-/* +- * Copyright (c) 2021 Huawei Device Co., Ltd. +- * Licensed under the Apache License, Version 2.0 (the "License"); +- * you may not use this file except in compliance with the License. +- * You may obtain a copy of the License at +- * +- * http://www.apache.org/licenses/LICENSE-2.0 +- * +- * Unless required by applicable law or agreed to in writing, software +- * distributed under the License is distributed on an "AS IS" BASIS, +- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +- * See the License for the specific language governing permissions and +- * limitations under the License. +- */ +- + #include "hilog/log.h" +-#include "hilog_inner.h" + ++#include + #include + #include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "log_utils.h" ++#include "hilog_common.h" ++#include "log_timestamp.h" ++#include "vsnprintf_s_p.h" ++#include "log_print.h" ++ ++using namespace std; ++using namespace OHOS::HiviewDFX; + + namespace OHOS { + namespace HiviewDFX { +@@ -29,6 +32,82 @@ namespace HiviewDFX { + va_end(args); \ + } while (0) + ++int HiPrintLog(HilogMsg& header, const char *tag, uint16_t tagLen, const char *fmt, uint16_t fmtLen) ++{ ++ LogContent content = { ++ .level = header.level, ++ .type = header.type, ++ .pid = header.pid, ++ .tid = header.tid, ++ .domain = header.domain, ++ .tv_sec = header.tv_sec, ++ .tv_nsec = header.tv_nsec, ++ .mono_sec = header.mono_sec, ++ .tag = tag, ++ .log = fmt, ++ }; ++ LogFormat format = { ++ .colorful = false, ++ .timeFormat = FormatTime::TIME, ++ .timeAccuFormat = FormatTimeAccu::MSEC, ++ .year = false, ++ .zone = false, ++ }; ++ LogPrintWithFormat(content, format); ++ return RET_SUCCESS; ++} ++ ++int HiLogPrintArgs(const LogType type, const LogLevel level, const unsigned int domain, const char *tag, ++ const char *fmt, va_list ap) ++{ ++ if ((tag == nullptr)) { ++ return -1; ++ } ++ ++ HilogMsg header = {0}; ++ struct timespec ts = {0}; ++ (void)clock_gettime(CLOCK_REALTIME, &ts); ++ struct timespec ts_mono = {0}; ++ (void)clock_gettime(CLOCK_MONOTONIC, &ts_mono); ++ header.tv_sec = static_cast(ts.tv_sec); ++ header.tv_nsec = static_cast(ts.tv_nsec); ++ header.mono_sec = static_cast(ts_mono.tv_sec); ++ ++ char buf[MAX_LOG_LEN] = {0}; ++ char *logBuf = buf; ++ int traceBufLen = 0; ++ int ret; ++ bool priv = true; ++ ++#ifdef __clang__ ++/* code specific to clang compiler */ ++#pragma clang diagnostic push ++#pragma clang diagnostic ignored "-Wformat-nonliteral" ++#elif __GNUC__ ++/* code for GNU C compiler */ ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wformat-nonliteral" ++#endif ++ ret = vsnprintfp_s(logBuf, MAX_LOG_LEN - traceBufLen, MAX_LOG_LEN - traceBufLen - 1, priv, fmt, ap); ++#ifdef __clang__ ++#pragma clang diagnostic pop ++#elif __GNUC__ ++#pragma GCC diagnostic pop ++#endif ++ ++ /* fill header info */ ++ auto tagLen = strnlen(tag, MAX_TAG_LEN - 1); ++ auto logLen = strnlen(buf, MAX_LOG_LEN - 1); ++ header.type = type; ++ header.level = level; ++ header.pid = getpid(); ++ header.tid = static_cast(syscall(SYS_gettid)); ++ header.domain = domain; ++ ++ return HiPrintLog(header, tag, tagLen + 1, buf, logLen + 1); ++ ++} ++ + int HiLog::Debug(const HiLogLabel &label, const char *fmt, ...) + { + int ret; +@@ -65,3 +144,13 @@ int HiLog::Fatal(const HiLogLabel &label, const char *fmt, ...) + } + } // namespace HiviewDFX + } // namespace OHOS ++ ++int HiLogPrint(LogType type, LogLevel level, unsigned int domain, const char *tag, const char *fmt, ...) ++{ ++ int ret; ++ va_list ap; ++ va_start(ap, fmt); ++ ret = HiLogPrintArgs(type, level, domain, tag, fmt, ap); ++ va_end(ap); ++ return ret; ++} +diff --git a/frameworks/libhilog/hilog_printf.cpp b/frameworks/libhilog/hilog_printf.cpp +index 9db1742..1316128 100644 +--- a/frameworks/libhilog/hilog_printf.cpp ++++ b/frameworks/libhilog/hilog_printf.cpp +@@ -55,8 +55,7 @@ static atomic_int g_hiLogGetIdCallCount = 0; + // protected by static lock guard + static char g_hiLogLastFatalMessage[MAX_LOG_LEN] = { 0 }; // MAX_lOG_LEN : 1024 + +-HILOG_PUBLIC_API +-extern "C" const char* GetLastFatalMessage() ++extern "C" HILOG_PUBLIC_API const char* GetLastFatalMessage() + { + return g_hiLogLastFatalMessage; + } +diff --git a/frameworks/libhilog/include/hilog_cmd.h b/frameworks/libhilog/include/hilog_cmd.h +index 1043e1b..677da27 100644 +--- a/frameworks/libhilog/include/hilog_cmd.h ++++ b/frameworks/libhilog/include/hilog_cmd.h +@@ -258,4 +258,4 @@ struct KmsgEnableRqst { + struct KmsgEnableRsp { + char placeholder; + } __attribute__((__packed__)); +-#endif /* HILOG_CMD_H */ +\ No newline at end of file ++#endif /* HILOG_CMD_H */ +diff --git a/frameworks/libhilog/utils/include/log_print.h b/frameworks/libhilog/utils/include/log_print.h +index a84cdc5..e90626a 100644 +--- a/frameworks/libhilog/utils/include/log_print.h ++++ b/frameworks/libhilog/utils/include/log_print.h +@@ -1,47 +1,47 @@ +-/* +- * Copyright (c) 2022 Huawei Device Co., Ltd. +- * Licensed under the Apache License, Version 2.0 (the "License"); +- * you may not use this file except in compliance with the License. +- * You may obtain a copy of the License at +- * +- * http://www.apache.org/licenses/LICENSE-2.0 +- * +- * Unless required by applicable law or agreed to in writing, software +- * distributed under the License is distributed on an "AS IS" BASIS, +- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +- * See the License for the specific language governing permissions and +- * limitations under the License. +- */ +-#ifndef LOG_PRINT_H +-#define LOG_PRINT_H +-#include +- +-#include "hilog_cmd.h" +- +-namespace OHOS { +-namespace HiviewDFX { +-struct LogContent { +- uint8_t level; +- uint8_t type; +- uint32_t pid; +- uint32_t tid; +- uint32_t domain; +- uint32_t tv_sec; +- uint32_t tv_nsec; +- uint32_t mono_sec; +- const char *tag; +- const char *log; +-}; +- +-struct LogFormat { +- bool colorful; +- FormatTime timeFormat; +- FormatTimeAccu timeAccuFormat; +- bool year; +- bool zone; +-}; +- +-void LogPrintWithFormat(const LogContent& content, const LogFormat& format, std::ostream& out = std::cout); +-} // namespace HiviewDFX +-} // namespace OHOS +-#endif /* LOG_PRINT_H */ +\ No newline at end of file ++/* ++ * Copyright (c) 2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++#ifndef LOG_PRINT_H ++#define LOG_PRINT_H ++#include ++ ++#include "hilog_cmd.h" ++ ++namespace OHOS { ++namespace HiviewDFX { ++struct LogContent { ++ uint8_t level; ++ uint8_t type; ++ uint32_t pid; ++ uint32_t tid; ++ uint32_t domain; ++ uint32_t tv_sec; ++ uint32_t tv_nsec; ++ uint32_t mono_sec; ++ const char *tag; ++ const char *log; ++}; ++ ++struct LogFormat { ++ bool colorful; ++ FormatTime timeFormat; ++ FormatTimeAccu timeAccuFormat; ++ bool year; ++ bool zone; ++}; ++ ++void LogPrintWithFormat(const LogContent& content, const LogFormat& format, std::ostream& out = std::cout); ++} // namespace HiviewDFX ++} // namespace OHOS ++#endif /* LOG_PRINT_H */ +diff --git a/frameworks/libhilog/utils/include/log_utils.h b/frameworks/libhilog/utils/include/log_utils.h +index 464fe84..6a79155 100644 +--- a/frameworks/libhilog/utils/include/log_utils.h ++++ b/frameworks/libhilog/utils/include/log_utils.h +@@ -1,110 +1,110 @@ +-/* +- * Copyright (c) 2021 Huawei Device Co., Ltd. +- * Licensed under the Apache License, Version 2.0 (the "License"); +- * you may not use this file except in compliance with the License. +- * You may obtain a copy of the License at +- * +- * http://www.apache.org/licenses/LICENSE-2.0 +- * +- * Unless required by applicable law or agreed to in writing, software +- * distributed under the License is distributed on an "AS IS" BASIS, +- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +- * See the License for the specific language governing permissions and +- * limitations under the License. +- */ +-#ifndef LOG_UTILS_H +-#define LOG_UTILS_H +- +-#include +-#include +-#include +- +-namespace OHOS { +-namespace HiviewDFX { +-template +-class KVMap { +-using ValueCmp = std::function; +-public: +- KVMap(std::unordered_map map, K def_k, V def_v, +- ValueCmp cmp = [](const V& v1, const V& v2) { return v1 == v2; }) +- : str_map(map), def_key(def_k), def_value(def_v), compare(cmp) +- { +- } +- +- const V& GetValue(K key) const +- { +- auto it = str_map.find(key); +- return it == str_map.end() ? def_value : it->second; +- } +- +- const K GetKey(const V& value) const +- { +- for (auto& it : str_map) { +- if (compare(value, it.second)) { +- return it.first; +- } +- } +- return def_key; +- } +- +- std::vector GetAllKeys() const +- { +- std::vector keys; +- for (auto& it : str_map) { +- keys.push_back(it.first); +- } +- return keys; +- } +- +- bool IsValidKey(K key) const +- { +- return (str_map.find(key) != str_map.end()); +- } +- +-private: +- const std::unordered_map str_map; +- const K def_key; +- const V def_value; +- const ValueCmp compare; +-}; +-using StringMap = KVMap; +-std::string ErrorCode2Str(int16_t errorCode); +-std::string LogType2Str(uint16_t logType); +-uint16_t Str2LogType(const std::string& str); +-std::string ComboLogType2Str(uint16_t shiftType); +-uint16_t Str2ComboLogType(const std::string& str); +-std::vector GetAllLogTypes(); +-std::string LogLevel2Str(uint16_t logLevel); +-uint16_t Str2LogLevel(const std::string& str); +-std::string LogLevel2ShortStr(uint16_t logLevel); +-uint16_t ShortStr2LogLevel(const std::string& str); +-uint16_t PrettyStr2LogLevel(const std::string& str); +-std::string ComboLogLevel2Str(uint16_t shiftLevel); +-uint16_t Str2ComboLogLevel(const std::string& str); +-std::string ShowFormat2Str(uint16_t showFormat); +-uint16_t Str2ShowFormat(const std::string& str); +-std::string Size2Str(uint64_t size); +-uint64_t Str2Size(const std::string& str); +- +-constexpr char DEFAULT_SPLIT_DELIMIT[] = ","; +-void Split(const std::string& src, std::vector& dest, +- const std::string& separator = DEFAULT_SPLIT_DELIMIT); +-uint32_t GetBitsCount(uint64_t n); +-uint16_t GetBitPos(uint64_t n); +- +-std::string Uint2DecStr(uint32_t i); +-uint32_t DecStr2Uint(const std::string& str); +-std::string Uint2HexStr(uint32_t i); +-uint32_t HexStr2Uint(const std::string& str); +- +-#if !defined(__WINDOWS__) and !defined(__LINUX__) +-std::string GetProgName(); +-#endif +-std::string GetNameByPid(uint32_t pid); +-uint32_t GetPPidByPid(uint32_t pid); +-uint64_t GenerateHash(const char *p, size_t size); +-void PrintErrorno(int err); +-int WaitingToDo(int max, const std::string& path, std::function func); +-} // namespace HiviewDFX +-} // namespace OHOS +-#endif // LOG_UTILS_H +\ No newline at end of file ++/* ++ * Copyright (c) 2021 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++#ifndef LOG_UTILS_H ++#define LOG_UTILS_H ++ ++#include ++#include ++#include ++ ++namespace OHOS { ++namespace HiviewDFX { ++template ++class KVMap { ++using ValueCmp = std::function; ++public: ++ KVMap(std::unordered_map map, K def_k, V def_v, ++ ValueCmp cmp = [](const V& v1, const V& v2) { return v1 == v2; }) ++ : str_map(map), def_key(def_k), def_value(def_v), compare(cmp) ++ { ++ } ++ ++ const V& GetValue(K key) const ++ { ++ auto it = str_map.find(key); ++ return it == str_map.end() ? def_value : it->second; ++ } ++ ++ const K GetKey(const V& value) const ++ { ++ for (auto& it : str_map) { ++ if (compare(value, it.second)) { ++ return it.first; ++ } ++ } ++ return def_key; ++ } ++ ++ std::vector GetAllKeys() const ++ { ++ std::vector keys; ++ for (auto& it : str_map) { ++ keys.push_back(it.first); ++ } ++ return keys; ++ } ++ ++ bool IsValidKey(K key) const ++ { ++ return (str_map.find(key) != str_map.end()); ++ } ++ ++private: ++ const std::unordered_map str_map; ++ const K def_key; ++ const V def_value; ++ const ValueCmp compare; ++}; ++using StringMap = KVMap; ++std::string ErrorCode2Str(int16_t errorCode); ++std::string LogType2Str(uint16_t logType); ++uint16_t Str2LogType(const std::string& str); ++std::string ComboLogType2Str(uint16_t shiftType); ++uint16_t Str2ComboLogType(const std::string& str); ++std::vector GetAllLogTypes(); ++std::string LogLevel2Str(uint16_t logLevel); ++uint16_t Str2LogLevel(const std::string& str); ++std::string LogLevel2ShortStr(uint16_t logLevel); ++uint16_t ShortStr2LogLevel(const std::string& str); ++uint16_t PrettyStr2LogLevel(const std::string& str); ++std::string ComboLogLevel2Str(uint16_t shiftLevel); ++uint16_t Str2ComboLogLevel(const std::string& str); ++std::string ShowFormat2Str(uint16_t showFormat); ++uint16_t Str2ShowFormat(const std::string& str); ++std::string Size2Str(uint64_t size); ++uint64_t Str2Size(const std::string& str); ++ ++constexpr char DEFAULT_SPLIT_DELIMIT[] = ","; ++void Split(const std::string& src, std::vector& dest, ++ const std::string& separator = DEFAULT_SPLIT_DELIMIT); ++uint32_t GetBitsCount(uint64_t n); ++uint16_t GetBitPos(uint64_t n); ++ ++std::string Uint2DecStr(uint32_t i); ++uint32_t DecStr2Uint(const std::string& str); ++std::string Uint2HexStr(uint32_t i); ++uint32_t HexStr2Uint(const std::string& str); ++ ++#if !defined(__WINDOWS__) and !defined(__LINUX__) ++std::string GetProgName(); ++#endif ++std::string GetNameByPid(uint32_t pid); ++uint32_t GetPPidByPid(uint32_t pid); ++uint64_t GenerateHash(const char *p, size_t size); ++void PrintErrorno(int err); ++int WaitingToDo(int max, const std::string& path, std::function func); ++} // namespace HiviewDFX ++} // namespace OHOS ++#endif // LOG_UTILS_H +diff --git a/frameworks/libhilog/utils/log_print.cpp b/frameworks/libhilog/utils/log_print.cpp +index 6d47a9a..c7ebf21 100644 +--- a/frameworks/libhilog/utils/log_print.cpp ++++ b/frameworks/libhilog/utils/log_print.cpp +@@ -1,180 +1,180 @@ +-/* +- * Copyright (c) 2022 Huawei Device Co., Ltd. +- * Licensed under the Apache License, Version 2.0 (the "License"); +- * you may not use this file except in compliance with the License. +- * You may obtain a copy of the License at +- * +- * http://www.apache.org/licenses/LICENSE-2.0 +- * +- * Unless required by applicable law or agreed to in writing, software +- * distributed under the License is distributed on an "AS IS" BASIS, +- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +- * See the License for the specific language governing permissions and +- * limitations under the License. +- */ +-#include +-#include +-#include +-#include +-#include +- +-#include "hilog_common.h" +-#include "log_utils.h" +-#include "log_print.h" +- +-namespace OHOS { +-namespace HiviewDFX { +-using namespace std; +- +-static constexpr int COLOR_BLUE = 75; +-static constexpr int COLOR_DEFAULT = 231; +-static constexpr int COLOR_GREEN = 40; +-static constexpr int COLOR_ORANGE = 166; +-static constexpr int COLOR_RED = 196; +-static constexpr int COLOR_YELLOW = 226; +-static constexpr int TM_YEAR_BASE = 1900; +-static constexpr int DT_WIDTH = 2; +-static constexpr long long NS2US = 1000LL; +-static constexpr long long NS2MS = 1000000LL; +-static constexpr int MONO_WIDTH = 8; +-static constexpr int EPOCH_WIDTH = 10; +-static constexpr int MSEC_WIDTH = 3; +-static constexpr int USEC_WIDTH = 6; +-static constexpr int NSEC_WIDTH = 9; +-static constexpr int PID_WIDTH = 5; +-static constexpr int DOMAIN_WIDTH = 5; +-static constexpr int DOMAIN_SHORT_MASK = 0xFFFFF; +- +-static inline int GetColor(uint16_t level) +-{ +- switch (LogLevel(level)) { +- case LOG_DEBUG: return COLOR_BLUE; +- case LOG_INFO: return COLOR_GREEN; +- case LOG_WARN: return COLOR_ORANGE; +- case LOG_ERROR: return COLOR_RED; +- case LOG_FATAL: return COLOR_YELLOW; +- default: return COLOR_DEFAULT; +- } +-} +- +-static inline const char* GetLogTypePrefix(uint16_t type) +-{ +- switch (LogType(type)) { +- case LOG_APP: return "A"; +- case LOG_INIT: return "I"; +- case LOG_CORE: return "C"; +- case LOG_KMSG: return "K"; +- default: return " "; +- } +-} +- +-static inline uint32_t ShortDomain(uint32_t d) +-{ +- return (d) & DOMAIN_SHORT_MASK; +-} +- +-static void PrintLogPrefix(const LogContent& content, const LogFormat& format, std::ostream& out) +-{ +- // 1. print day & time +- if (format.timeFormat == FormatTime::TIME) { +- struct tm tl; +- time_t time = content.tv_sec; +-#if (defined( __WINDOWS__ )) +- if (localtime_s(&tl, &time) != 0) { +- return; +- } +-#else +- if (localtime_r(&time, &tl) == nullptr) { +- return; +- } +- if (format.zone) { +- out << tl.tm_zone << " "; +- } +-#endif +- if (format.year) { +- out << (tl.tm_year + TM_YEAR_BASE) << "-"; +- } +- out << setfill('0'); +- out << setw(DT_WIDTH) << (tl.tm_mon + 1) << "-" << setw(DT_WIDTH) << tl.tm_mday << " "; +- out << setw(DT_WIDTH) << tl.tm_hour << ":" << setw(DT_WIDTH) << tl.tm_min << ":"; +- out << setw(DT_WIDTH) << tl.tm_sec; +- } else if (format.timeFormat == FormatTime::MONOTONIC) { +- out << setfill(' '); +- out << setw(MONO_WIDTH) << content.mono_sec; +- } else if (format.timeFormat == FormatTime::EPOCH) { +- out << setfill(' '); +- out << setw(EPOCH_WIDTH) << content.tv_sec; +- } else { +- out << "Invalid time format" << endl; +- return; +- } +- // 1.1 print msec/usec/nsec +- out << "."; +- out << setfill('0'); +- if (format.timeAccuFormat == FormatTimeAccu::MSEC) { +- out << setw(MSEC_WIDTH) << (content.tv_nsec / NS2MS); +- } else if (format.timeAccuFormat == FormatTimeAccu::USEC) { +- out << setw(USEC_WIDTH) << (content.tv_nsec / NS2US); +- } else if (format.timeAccuFormat == FormatTimeAccu::NSEC) { +- out << setw(NSEC_WIDTH) << content.tv_nsec; +- } else { +- out << "Invalid time accuracy format" << endl; +- return; +- } +- out << setfill(' '); +- // 2. print pid/tid +- out << " " << setw(PID_WIDTH) << content.pid << " " << setw(PID_WIDTH) << content.tid; +- // 3. print level +- out << " " << LogLevel2ShortStr(content.level) << " "; +- // 4. print log type +- out << GetLogTypePrefix(content.type); +- // 5. print domain +- out << setfill('0'); +- out << hex << setw(DOMAIN_WIDTH) << ShortDomain(content.domain) << dec; +- // 5. print tag & log +- out << "/" << content.tag << ": "; +-} +- +-void LogPrintWithFormat(const LogContent& content, const LogFormat& format, std::ostream& out) +-{ +- // set colorful log +- if (format.colorful) { +- out << "\x1B[38;5;" << GetColor(content.level) << "m"; +- } +- +- const char *pHead = content.log; +- const char *pScan = content.log; +- // split the log content by '\n', and add log prefix(datetime, pid, tid....) to each new line +- while (*pScan != '\0') { +- if (*pScan == '\n') { +- char tmp[MAX_LOG_LEN]; +- int len = static_cast(pScan - pHead); +- errno_t ret = memcpy_s(tmp, MAX_LOG_LEN - 1, pHead, len); +- if (ret != EOK) { +- break; +- } +- tmp[(MAX_LOG_LEN - 1) > len ? len : (MAX_LOG_LEN -1)] = '\0'; +- if (tmp[0] != '\0') { +- PrintLogPrefix(content, format, out); +- out << tmp << endl; +- } +- pHead = pScan + 1; +- } +- pScan++; +- } +- if (pHead[0] != '\0') { +- PrintLogPrefix(content, format, out); +- out << pHead; +- } +- +- // restore color +- if (format.colorful) { +- out << "\x1B[0m"; +- } +- if (pHead[0] != '\0') { +- out << endl; +- } +- return; +-} +-} // namespace HiviewDFX +-} // namespace OHOS +\ No newline at end of file ++/* ++ * Copyright (c) 2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++#include ++#include ++#include ++#include ++#include ++ ++#include "hilog_common.h" ++#include "log_utils.h" ++#include "log_print.h" ++ ++namespace OHOS { ++namespace HiviewDFX { ++using namespace std; ++ ++static constexpr int COLOR_BLUE = 75; ++static constexpr int COLOR_DEFAULT = 231; ++static constexpr int COLOR_GREEN = 40; ++static constexpr int COLOR_ORANGE = 166; ++static constexpr int COLOR_RED = 196; ++static constexpr int COLOR_YELLOW = 226; ++static constexpr int TM_YEAR_BASE = 1900; ++static constexpr int DT_WIDTH = 2; ++static constexpr long long NS2US = 1000LL; ++static constexpr long long NS2MS = 1000000LL; ++static constexpr int MONO_WIDTH = 8; ++static constexpr int EPOCH_WIDTH = 10; ++static constexpr int MSEC_WIDTH = 3; ++static constexpr int USEC_WIDTH = 6; ++static constexpr int NSEC_WIDTH = 9; ++static constexpr int PID_WIDTH = 5; ++static constexpr int DOMAIN_WIDTH = 5; ++static constexpr int DOMAIN_SHORT_MASK = 0xFFFFF; ++ ++static inline int GetColor(uint16_t level) ++{ ++ switch (LogLevel(level)) { ++ case LOG_DEBUG: return COLOR_BLUE; ++ case LOG_INFO: return COLOR_GREEN; ++ case LOG_WARN: return COLOR_ORANGE; ++ case LOG_ERROR: return COLOR_RED; ++ case LOG_FATAL: return COLOR_YELLOW; ++ default: return COLOR_DEFAULT; ++ } ++} ++ ++static inline const char* GetLogTypePrefix(uint16_t type) ++{ ++ switch (LogType(type)) { ++ case LOG_APP: return "A"; ++ case LOG_INIT: return "I"; ++ case LOG_CORE: return "C"; ++ case LOG_KMSG: return "K"; ++ default: return " "; ++ } ++} ++ ++static inline uint32_t ShortDomain(uint32_t d) ++{ ++ return (d) & DOMAIN_SHORT_MASK; ++} ++ ++static void PrintLogPrefix(const LogContent& content, const LogFormat& format, std::ostream& out) ++{ ++ // 1. print day & time ++ if (format.timeFormat == FormatTime::TIME) { ++ struct tm tl; ++ time_t time = content.tv_sec; ++#if (defined( __WINDOWS__ )) ++ if (localtime_s(&tl, &time) != 0) { ++ return; ++ } ++#else ++ if (localtime_r(&time, &tl) == nullptr) { ++ return; ++ } ++ if (format.zone) { ++ out << tl.tm_zone << " "; ++ } ++#endif ++ if (format.year) { ++ out << (tl.tm_year + TM_YEAR_BASE) << "-"; ++ } ++ out << setfill('0'); ++ out << setw(DT_WIDTH) << (tl.tm_mon + 1) << "-" << setw(DT_WIDTH) << tl.tm_mday << " "; ++ out << setw(DT_WIDTH) << tl.tm_hour << ":" << setw(DT_WIDTH) << tl.tm_min << ":"; ++ out << setw(DT_WIDTH) << tl.tm_sec; ++ } else if (format.timeFormat == FormatTime::MONOTONIC) { ++ out << setfill(' '); ++ out << setw(MONO_WIDTH) << content.mono_sec; ++ } else if (format.timeFormat == FormatTime::EPOCH) { ++ out << setfill(' '); ++ out << setw(EPOCH_WIDTH) << content.tv_sec; ++ } else { ++ out << "Invalid time format" << endl; ++ return; ++ } ++ // 1.1 print msec/usec/nsec ++ out << "."; ++ out << setfill('0'); ++ if (format.timeAccuFormat == FormatTimeAccu::MSEC) { ++ out << setw(MSEC_WIDTH) << (content.tv_nsec / NS2MS); ++ } else if (format.timeAccuFormat == FormatTimeAccu::USEC) { ++ out << setw(USEC_WIDTH) << (content.tv_nsec / NS2US); ++ } else if (format.timeAccuFormat == FormatTimeAccu::NSEC) { ++ out << setw(NSEC_WIDTH) << content.tv_nsec; ++ } else { ++ out << "Invalid time accuracy format" << endl; ++ return; ++ } ++ out << setfill(' '); ++ // 2. print pid/tid ++ out << " " << setw(PID_WIDTH) << content.pid << " " << setw(PID_WIDTH) << content.tid; ++ // 3. print level ++ out << " " << LogLevel2ShortStr(content.level) << " "; ++ // 4. print log type ++ out << GetLogTypePrefix(content.type); ++ // 5. print domain ++ out << setfill('0'); ++ out << hex << setw(DOMAIN_WIDTH) << ShortDomain(content.domain) << dec; ++ // 5. print tag & log ++ out << "/" << content.tag << ": "; ++} ++ ++void LogPrintWithFormat(const LogContent& content, const LogFormat& format, std::ostream& out) ++{ ++ // set colorful log ++ if (format.colorful) { ++ out << "\x1B[38;5;" << GetColor(content.level) << "m"; ++ } ++ ++ const char *pHead = content.log; ++ const char *pScan = content.log; ++ // split the log content by '\n', and add log prefix(datetime, pid, tid....) to each new line ++ while (*pScan != '\0') { ++ if (*pScan == '\n') { ++ char tmp[MAX_LOG_LEN]; ++ int len = static_cast(pScan - pHead); ++ errno_t ret = memcpy_s(tmp, MAX_LOG_LEN - 1, pHead, len); ++ if (ret != EOK) { ++ break; ++ } ++ tmp[(MAX_LOG_LEN - 1) > len ? len : (MAX_LOG_LEN -1)] = '\0'; ++ if (tmp[0] != '\0') { ++ PrintLogPrefix(content, format, out); ++ out << tmp << endl; ++ } ++ pHead = pScan + 1; ++ } ++ pScan++; ++ } ++ if (pHead[0] != '\0') { ++ PrintLogPrefix(content, format, out); ++ out << pHead; ++ } ++ ++ // restore color ++ if (format.colorful) { ++ out << "\x1B[0m"; ++ } ++ if (pHead[0] != '\0') { ++ out << endl; ++ } ++ return; ++} ++} // namespace HiviewDFX ++} // namespace OHOS +diff --git a/frameworks/libhilog/utils/log_utils.cpp b/frameworks/libhilog/utils/log_utils.cpp +index 7cef847..af130c4 100644 +--- a/frameworks/libhilog/utils/log_utils.cpp ++++ b/frameworks/libhilog/utils/log_utils.cpp +@@ -1,522 +1,522 @@ +-/* +- * Copyright (c) 2022 Huawei Device Co., Ltd. +- * Licensed under the Apache License, Version 2.0 (the "License"); +- * you may not use this file except in compliance with the License. +- * You may obtain a copy of the License at +- * +- * http://www.apache.org/licenses/LICENSE-2.0 +- * +- * Unless required by applicable law or agreed to in writing, software +- * distributed under the License is distributed on an "AS IS" BASIS, +- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +- * See the License for the specific language governing permissions and +- * limitations under the License. +- */ +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include "hilog_common.h" +-#include "hilog_cmd.h" +-#include "log_utils.h" +- +-namespace { +- constexpr uint32_t ONE_KB = (1UL << 10); +- constexpr uint32_t ONE_MB = (1UL << 20); +- constexpr uint32_t ONE_GB = (1UL << 30); +- constexpr uint64_t ONE_TB = (1ULL << 40); +- constexpr uint32_t DOMAIN_MIN = DOMAIN_APP_MIN; +- constexpr uint32_t DOMAIN_MAX = DOMAIN_OS_MAX; +- constexpr int CMDLINE_PATH_LEN = 32; +- constexpr int CMDLINE_LEN = 128; +- constexpr int STATUS_PATH_LEN = 32; +- constexpr int STATUS_LEN = 1024; +- const std::string SH_NAMES[] = { "sh", "/bin/sh", "/system/bin/sh", "/xbin/sh", "/system/xbin/sh"}; +-} +- +-namespace OHOS { +-namespace HiviewDFX { +-using namespace std; +-using namespace std::chrono; +- +-// Buffer Size&Char Map +-static const KVMap g_SizeMap({ +- {'B', 1}, {'K', ONE_KB}, {'M', ONE_MB}, +- {'G', ONE_GB}, {'T', ONE_TB} +-}, ' ', 0); +- +-string Size2Str(uint64_t size) +-{ +- string str; +- uint64_t unit = 1; +- switch (size) { +- case 0 ... ONE_KB - 1: unit = 1; break; +- case ONE_KB ... ONE_MB - 1: unit = ONE_KB; break; +- case ONE_MB ... ONE_GB - 1: unit = ONE_MB; break; +- case ONE_GB ... ONE_TB - 1: unit = ONE_GB; break; +- default: unit = ONE_TB; break; +- } +- float i = (static_cast(size)) / unit; +- constexpr int len = 16; +- char buf[len] = { 0 }; +- int ret = snprintf_s(buf, len, len - 1, "%.1f", i); +- if (ret <= 0) { +- str = to_string(size); +- } else { +- str = buf; +- } +- return str + g_SizeMap.GetKey(unit); +-} +- +-uint64_t Str2Size(const string& str) +-{ +- std::regex reg("[0-9]+[BKMGT]?"); +- if (!std::regex_match(str, reg)) { +- return 0; +- } +- uint64_t index = str.size() - 1; +- uint64_t unit = g_SizeMap.GetValue(str[index]); +- +- uint64_t value = stoull(str.substr(0, unit !=0 ? index : index + 1)); +- return value * (unit != 0 ? unit : 1); +-} +- +-// Error Codes&Strings Map +-static const KVMap g_ErrorMsgs({ +- {RET_SUCCESS, "Success"}, +- {RET_FAIL, "Unknown failure reason"}, +- {ERR_LOG_LEVEL_INVALID, "Invalid log level, the valid log levels include D/I/W/E/F" +- " or DEBUG/INFO/WARN/ERROR/FATAL"}, +- {ERR_LOG_TYPE_INVALID, "Invalid log type, the valid log types include app/core/init/kmsg"}, +- {ERR_INVALID_RQST_CMD, "Invalid request cmd, please check sourcecode"}, +- {ERR_QUERY_TYPE_INVALID, "Can't query kmsg type logs combined with other types logs."}, +- {ERR_INVALID_DOMAIN_STR, "Invalid domain string"}, +- {ERR_LOG_PERSIST_FILE_SIZE_INVALID, "Invalid log persist file size, file size should be in range [" +- + Size2Str(MIN_LOG_FILE_SIZE) + ", " + Size2Str(MAX_LOG_FILE_SIZE) + "]"}, +- {ERR_LOG_PERSIST_FILE_NAME_INVALID, "Invalid log persist file name, file name should not contain [\\/:*?\"<>|]"}, +- {ERR_LOG_PERSIST_COMPRESS_BUFFER_EXP, "Invalid Log persist compression buffer"}, +- {ERR_LOG_PERSIST_FILE_PATH_INVALID, "Invalid persister file path or persister directory does not exist"}, +- {ERR_LOG_PERSIST_COMPRESS_INIT_FAIL, "Log persist compression initialization failed"}, +- {ERR_LOG_PERSIST_FILE_OPEN_FAIL, "Log persist open file failed"}, +- {ERR_LOG_PERSIST_JOBID_FAIL, "Log persist jobid not exist"}, +- {ERR_LOG_PERSIST_TASK_EXISTED, "Log persist task is existed"}, +- {ERR_DOMAIN_INVALID, ("Invalid domain, domain should be in range (" + Uint2HexStr(DOMAIN_MIN) +- + ", " +Uint2HexStr(DOMAIN_MAX) +"]")}, +- {ERR_MSG_LEN_INVALID, "Invalid message length"}, +- {ERR_LOG_PERSIST_JOBID_INVALID, "Invalid jobid, jobid should be in range [" + to_string(JOB_ID_MIN) +- + ", " + to_string(JOB_ID_MAX) + ")"}, +- {ERR_BUFF_SIZE_INVALID, ("Invalid buffer size, buffer size should be in range [" + Size2Str(MIN_BUFFER_SIZE) +- + ", " + Size2Str(MAX_BUFFER_SIZE) + "]")}, +- {ERR_COMMAND_INVALID, "Mutlti commands can't be used in combination"}, +- {ERR_LOG_FILE_NUM_INVALID, "Invalid number of files"}, +- {ERR_NOT_NUMBER_STR, "Not a numeric string"}, +- {ERR_TOO_MANY_ARGUMENTS, "Too many arguments"}, +- {ERR_DUPLICATE_OPTION, "Too many duplicate options"}, +- {ERR_INVALID_ARGUMENT, "Invalid argument"}, +- {ERR_TOO_MANY_DOMAINS, "Max domain count is " + to_string(MAX_DOMAINS)}, +- {ERR_INVALID_SIZE_STR, "Invalid size string"}, +- {ERR_TOO_MANY_PIDS, "Max pid count is " + to_string(MAX_PIDS)}, +- {ERR_TOO_MANY_TAGS, "Max tag count is " + to_string(MAX_TAGS)}, +- {ERR_TAG_STR_TOO_LONG, ("Tag string too long, max length is " + to_string(MAX_TAG_LEN - 1))}, +- {ERR_REGEX_STR_TOO_LONG, ("Regular expression too long, max length is " + to_string(MAX_REGEX_STR_LEN - 1))}, +- {ERR_FILE_NAME_TOO_LONG, ("File name too long, max length is " + to_string(MAX_FILE_NAME_LEN))}, +- {ERR_SOCKET_CLIENT_INIT_FAIL, "Socket client init failed"}, +- {ERR_SOCKET_WRITE_MSG_HEADER_FAIL, "Socket rite message header failed"}, +- {ERR_SOCKET_WRITE_CMD_FAIL, "Socket write command failed"}, +- {ERR_SOCKET_RECEIVE_RSP, "Unable to receive message from socket"}, +- {ERR_PERSIST_TASK_EMPTY, "No running persist task, please check"}, +- {ERR_JOBID_NOT_EXSIST, "Persist task of this job id doesn't exist, please check"}, +- {ERR_TOO_MANY_JOBS, ("Too many jobs are running, max job count is:" + to_string(MAX_JOBS))}, +- {ERR_STATS_NOT_ENABLE, "Statistic feature is not enable, " +- "please set param persist.sys.hilog.stats true to enable it, " +- "further more, you can set persist.sys.hilog.stats.tag true to enable counting log by tags"}, +- {ERR_NO_RUNNING_TASK, "No running persistent task"}, +- {ERR_NO_PID_PERMISSION, "Permission denied, only shell and root can filter logs by pid"}, +-}, RET_FAIL, "Unknown error code"); +- +-string ErrorCode2Str(int16_t errorCode) +-{ +- return g_ErrorMsgs.GetValue((uint16_t)errorCode) + " [CODE: " + to_string(errorCode) + "]"; +-} +- +-// Log Types&Strings Map +-static const StringMap g_LogTypes({ +- {LOG_INIT, "init"}, {LOG_CORE, "core"}, {LOG_APP, "app"}, {LOG_KMSG, "kmsg"} +-}, LOG_TYPE_MAX, "invalid"); +- +-string LogType2Str(uint16_t logType) +-{ +- return g_LogTypes.GetValue(logType); +-} +- +-uint16_t Str2LogType(const string& str) +-{ +- return g_LogTypes.GetKey(str); +-} +- +-string ComboLogType2Str(uint16_t shiftType) +-{ +- vector types = g_LogTypes.GetAllKeys(); +- string str = ""; +- uint16_t typeAll = 0; +- +- for (uint16_t t : types) { +- typeAll |= (1 << t); +- } +- shiftType &= typeAll; +- for (uint16_t t: types) { +- if ((1 << t) & shiftType) { +- shiftType &= (~(1 << t)); +- str += (LogType2Str(t) + (shiftType != 0 ? "," : "")); +- } +- if (shiftType == 0) { +- break; +- } +- } +- return str; +-} +- +-uint16_t Str2ComboLogType(const string& str) +-{ +- uint16_t logTypes = 0; +- if (str == "") { +- logTypes = (1 << LOG_CORE) | (1 << LOG_APP); +- return logTypes; +- } +- vector vec; +- Split(str, vec); +- for (auto& it : vec) { +- if (it == "") { +- continue; +- } +- uint16_t t = Str2LogType(it); +- if (t == LOG_TYPE_MAX) { +- return 0; +- } +- logTypes |= (1 << t); +- } +- return logTypes; +-} +- +-vector GetAllLogTypes() +-{ +- return g_LogTypes.GetAllKeys(); +-} +- +-// Log Levels&Strings Map +-static const StringMap g_LogLevels({ +- {LOG_DEBUG, "DEBUG"}, {LOG_INFO, "INFO"}, {LOG_WARN, "WARN"}, +- {LOG_ERROR, "ERROR"}, {LOG_FATAL, "FATAL"}, {LOG_LEVEL_MAX, "X"} +-}, LOG_LEVEL_MIN, "INVALID", [](const string& l1, const string& l2) { +- if (l1.length() == l2.length()) { +- return std::equal(l1.begin(), l1.end(), l2.begin(), [](char a, char b) { +- return std::tolower(a) == std::tolower(b); +- }); +- } else { +- return false; +- } +-}); +- +-string LogLevel2Str(uint16_t logLevel) +-{ +- return g_LogLevels.GetValue(logLevel); +-} +- +-uint16_t Str2LogLevel(const string& str) +-{ +- return g_LogLevels.GetKey(str); +-} +- +-// Log Levels&Short Strings Map +-static const StringMap g_ShortLogLevels({ +- {LOG_DEBUG, "D"}, {LOG_INFO, "I"}, {LOG_WARN, "W"}, +- {LOG_ERROR, "E"}, {LOG_FATAL, "F"}, {LOG_LEVEL_MAX, "X"} +-}, LOG_LEVEL_MIN, "V", [](const string& l1, const string& l2) { +- return (l1.length() == 1 && std::tolower(l1[0]) == std::tolower(l2[0])); +-}); +- +-string LogLevel2ShortStr(uint16_t logLevel) +-{ +- return g_ShortLogLevels.GetValue(logLevel); +-} +- +-uint16_t ShortStr2LogLevel(const string& str) +-{ +- return g_ShortLogLevels.GetKey(str); +-} +- +-uint16_t PrettyStr2LogLevel(const string& str) +-{ +- uint16_t level = ShortStr2LogLevel(str); +- if (level == static_cast(LOG_LEVEL_MIN)) { +- return Str2LogLevel(str); +- } +- return level; +-} +- +-string ComboLogLevel2Str(uint16_t shiftLevel) +-{ +- vector levels = g_ShortLogLevels.GetAllKeys(); +- string str = ""; +- uint16_t levelAll = 0; +- +- for (uint16_t l : levels) { +- levelAll |= (1 << l); +- } +- shiftLevel &= levelAll; +- for (uint16_t l: levels) { +- if ((1 << l) & shiftLevel) { +- shiftLevel &= (~(1 << l)); +- str += (LogLevel2Str(l) + (shiftLevel != 0 ? "," : "")); +- } +- if (shiftLevel == 0) { +- break; +- } +- } +- return str; +-} +- +-uint16_t Str2ComboLogLevel(const string& str) +-{ +- uint16_t logLevels = 0; +- if (str == "") { +- logLevels = 0xFFFF; +- return logLevels; +- } +- vector vec; +- Split(str, vec); +- for (auto& it : vec) { +- if (it == "") { +- continue; +- } +- uint16_t t = PrettyStr2LogLevel(it); +- if (t == LOG_LEVEL_MIN || t >= LOG_LEVEL_MAX) { +- return 0; +- } +- logLevels |= (1 << t); +- } +- return logLevels; +-} +- +-void Split(const std::string& src, std::vector& dest, const std::string& separator) +-{ +- std::string str = src; +- std::string substring; +- std::string::size_type start = 0; +- std::string::size_type index; +- dest.clear(); +- index = str.find_first_of(separator, start); +- if (index == std::string::npos) { +- dest.emplace_back(str); +- return; +- } +- do { +- substring = str.substr(start, index - start); +- dest.emplace_back(substring); +- start = index + separator.size(); +- index = str.find(separator, start); +- } while (index != std::string::npos); +- substring = str.substr(start); +- if (substring != "") { +- dest.emplace_back(substring); +- } +-} +- +-uint32_t GetBitsCount(uint64_t n) +-{ +- uint32_t count = 0; +- while (n != 0) { +- ++count; +- n = n & (n-1); +- } +- return count; +-} +- +-uint16_t GetBitPos(uint64_t n) +-{ +- if (!(n && (!(n & (n-1))))) { // only accpet the number which is power of 2 +- return 0; +- } +- +- uint16_t i = 0; +- while (n >> (i++)) {} +- i--; +- return i-1; +-} +- +-enum class Radix { +- RADIX_DEC, +- RADIX_HEX, +-}; +-template +-static string Num2Str(T num, Radix radix) +-{ +- stringstream ss; +- auto r = std::dec; +- if (radix == Radix::RADIX_HEX) { +- r = std::hex; +- } +- ss << r << num; +- return ss.str(); +-} +- +-template +-static void Str2Num(const string& str, T& num, Radix radix) +-{ +- T i = 0; +- std::stringstream ss; +- auto r = std::dec; +- if (radix == Radix::RADIX_HEX) { +- r = std::hex; +- } +- ss << r << str; +- ss >> i; +- num = i; +- return; +-} +- +-string Uint2DecStr(uint32_t i) +-{ +- return Num2Str(i, Radix::RADIX_DEC); +-} +- +-uint32_t DecStr2Uint(const string& str) +-{ +- uint32_t i = 0; +- Str2Num(str, i, Radix::RADIX_DEC); +- return i; +-} +- +-string Uint2HexStr(uint32_t i) +-{ +- return Num2Str(i, Radix::RADIX_HEX); +-} +- +-uint32_t HexStr2Uint(const string& str) +-{ +- uint32_t i = 0; +- Str2Num(str, i, Radix::RADIX_HEX); +- return i; +-} +- +-#if !defined(__WINDOWS__) and !defined(__LINUX__) +-string GetProgName() +-{ +-#ifdef HILOG_USE_MUSL +- return program_invocation_short_name; +-#else +- return getprogname(); +-#endif +-} +-#endif +- +-string GetNameByPid(uint32_t pid) +-{ +- char path[CMDLINE_PATH_LEN] = { 0 }; +- if (snprintf_s(path, CMDLINE_PATH_LEN, CMDLINE_PATH_LEN - 1, "/proc/%d/cmdline", pid) <= 0) { +- return ""; +- } +- char cmdline[CMDLINE_LEN] = { 0 }; +- int i = 0; +- FILE *fp = fopen(path, "r"); +- if (fp == nullptr) { +- return ""; +- } +- while (i < (CMDLINE_LEN - 1)) { +- char c = static_cast(fgetc(fp)); +- // 0. don't need args of cmdline +- // 1. ignore unvisible character +- if (!isgraph(c)) { +- break; +- } +- cmdline[i] = c; +- i++; +- } +- (void)fclose(fp); +- return cmdline; +-} +- +-uint32_t GetPPidByPid(uint32_t pid) +-{ +- uint32_t ppid = 0; +- char path[STATUS_PATH_LEN] = { 0 }; +- if (snprintf_s(path, STATUS_PATH_LEN, STATUS_PATH_LEN - 1, "/proc/%u/status", pid) <= 0) { +- return ppid; +- } +- FILE *fp = fopen(path, "r"); +- if (fp == nullptr) { +- return ppid; +- } +- char buf[STATUS_LEN] = { 0 }; +- size_t ret = fread(buf, sizeof(char), STATUS_LEN - 1, fp); +- (void)fclose(fp); +- if (ret <= 0) { +- return ppid; +- } else { +- buf[ret++] = '\0'; +- } +- char *ppidLoc = strstr(buf, "PPid:"); +- if ((ppidLoc == nullptr) || (sscanf_s(ppidLoc, "PPid:%d", &ppid) == -1)) { +- return ppid; +- } +- std::string ppidName = GetNameByPid(ppid); +- // ppid fork the sh to execute hilog, sh is not wanted ppid +- if (std::find(std::begin(SH_NAMES), std::end(SH_NAMES), ppidName) != std::end(SH_NAMES)) { +- return GetPPidByPid(ppid); +- } +- return ppid; +-} +- +-uint64_t GenerateHash(const char *p, size_t size) +-{ +- static const uint64_t PRIME = 0x100000001B3ull; +- static const uint64_t BASIS = 0xCBF29CE484222325ull; +- uint64_t ret {BASIS}; +- unsigned long i = 0; +- while (i < size) { +- ret ^= *(p + i); +- ret *= PRIME; +- i++; +- } +- return ret; +-} +- +-void PrintErrorno(int err) +-{ +- constexpr int bufSize = 256; +- char buf[bufSize] = { 0 }; +-#ifndef __WINDOWS__ +- (void)strerror_r(err, buf, bufSize); +-#else +- (void)strerror_s(buf, bufSize, err); +-#endif +- std::cerr << "Errno: " << err << ", " << buf << std::endl; +-} +- +-int WaitingToDo(int max, const string& path, function func) +-{ +- chrono::steady_clock::time_point start = chrono::steady_clock::now(); +- chrono::milliseconds wait(max); +- while (true) { +- if (func(path) != RET_FAIL) { +- cout << "waiting for " << path << " successfully!" << endl; +- return RET_SUCCESS; +- } +- +- std::this_thread::sleep_for(10ms); +- if ((chrono::steady_clock::now() - start) > wait) { +- cerr << "waiting for " << path << " failed!" << endl; +- return RET_FAIL; +- } +- } +-} +-} // namespace HiviewDFX +-} // namespace OHOS ++/* ++ * Copyright (c) 2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include "hilog_common.h" ++#include "hilog_cmd.h" ++#include "log_utils.h" ++ ++namespace { ++ constexpr uint32_t ONE_KB = (1UL << 10); ++ constexpr uint32_t ONE_MB = (1UL << 20); ++ constexpr uint32_t ONE_GB = (1UL << 30); ++ constexpr uint64_t ONE_TB = (1ULL << 40); ++ constexpr uint32_t DOMAIN_MIN = DOMAIN_APP_MIN; ++ constexpr uint32_t DOMAIN_MAX = DOMAIN_OS_MAX; ++ constexpr int CMDLINE_PATH_LEN = 32; ++ constexpr int CMDLINE_LEN = 128; ++ constexpr int STATUS_PATH_LEN = 32; ++ constexpr int STATUS_LEN = 1024; ++ const std::string SH_NAMES[] = { "sh", "/bin/sh", "/system/bin/sh", "/xbin/sh", "/system/xbin/sh"}; ++} ++ ++namespace OHOS { ++namespace HiviewDFX { ++using namespace std; ++using namespace std::chrono; ++ ++// Buffer Size&Char Map ++static const KVMap g_SizeMap({ ++ {'B', 1}, {'K', ONE_KB}, {'M', ONE_MB}, ++ {'G', ONE_GB}, {'T', ONE_TB} ++}, ' ', 0); ++ ++string Size2Str(uint64_t size) ++{ ++ string str; ++ uint64_t unit = 1; ++ switch (size) { ++ case 0 ... ONE_KB - 1: unit = 1; break; ++ case ONE_KB ... ONE_MB - 1: unit = ONE_KB; break; ++ case ONE_MB ... ONE_GB - 1: unit = ONE_MB; break; ++ case ONE_GB ... ONE_TB - 1: unit = ONE_GB; break; ++ default: unit = ONE_TB; break; ++ } ++ float i = (static_cast(size)) / unit; ++ constexpr int len = 16; ++ char buf[len] = { 0 }; ++ int ret = snprintf_s(buf, len, len - 1, "%.1f", i); ++ if (ret <= 0) { ++ str = to_string(size); ++ } else { ++ str = buf; ++ } ++ return str + g_SizeMap.GetKey(unit); ++} ++ ++uint64_t Str2Size(const string& str) ++{ ++ std::regex reg("[0-9]+[BKMGT]?"); ++ if (!std::regex_match(str, reg)) { ++ return 0; ++ } ++ uint64_t index = str.size() - 1; ++ uint64_t unit = g_SizeMap.GetValue(str[index]); ++ ++ uint64_t value = stoull(str.substr(0, unit !=0 ? index : index + 1)); ++ return value * (unit != 0 ? unit : 1); ++} ++ ++// Error Codes&Strings Map ++static const KVMap g_ErrorMsgs({ ++ {RET_SUCCESS, "Success"}, ++ {RET_FAIL, "Unknown failure reason"}, ++ {ERR_LOG_LEVEL_INVALID, "Invalid log level, the valid log levels include D/I/W/E/F" ++ " or DEBUG/INFO/WARN/ERROR/FATAL"}, ++ {ERR_LOG_TYPE_INVALID, "Invalid log type, the valid log types include app/core/init/kmsg"}, ++ {ERR_INVALID_RQST_CMD, "Invalid request cmd, please check sourcecode"}, ++ {ERR_QUERY_TYPE_INVALID, "Can't query kmsg type logs combined with other types logs."}, ++ {ERR_INVALID_DOMAIN_STR, "Invalid domain string"}, ++ {ERR_LOG_PERSIST_FILE_SIZE_INVALID, "Invalid log persist file size, file size should be in range [" ++ + Size2Str(MIN_LOG_FILE_SIZE) + ", " + Size2Str(MAX_LOG_FILE_SIZE) + "]"}, ++ {ERR_LOG_PERSIST_FILE_NAME_INVALID, "Invalid log persist file name, file name should not contain [\\/:*?\"<>|]"}, ++ {ERR_LOG_PERSIST_COMPRESS_BUFFER_EXP, "Invalid Log persist compression buffer"}, ++ {ERR_LOG_PERSIST_FILE_PATH_INVALID, "Invalid persister file path or persister directory does not exist"}, ++ {ERR_LOG_PERSIST_COMPRESS_INIT_FAIL, "Log persist compression initialization failed"}, ++ {ERR_LOG_PERSIST_FILE_OPEN_FAIL, "Log persist open file failed"}, ++ {ERR_LOG_PERSIST_JOBID_FAIL, "Log persist jobid not exist"}, ++ {ERR_LOG_PERSIST_TASK_EXISTED, "Log persist task is existed"}, ++ {ERR_DOMAIN_INVALID, ("Invalid domain, domain should be in range (" + Uint2HexStr(DOMAIN_MIN) ++ + ", " +Uint2HexStr(DOMAIN_MAX) +"]")}, ++ {ERR_MSG_LEN_INVALID, "Invalid message length"}, ++ {ERR_LOG_PERSIST_JOBID_INVALID, "Invalid jobid, jobid should be in range [" + to_string(JOB_ID_MIN) ++ + ", " + to_string(JOB_ID_MAX) + ")"}, ++ {ERR_BUFF_SIZE_INVALID, ("Invalid buffer size, buffer size should be in range [" + Size2Str(MIN_BUFFER_SIZE) ++ + ", " + Size2Str(MAX_BUFFER_SIZE) + "]")}, ++ {ERR_COMMAND_INVALID, "Mutlti commands can't be used in combination"}, ++ {ERR_LOG_FILE_NUM_INVALID, "Invalid number of files"}, ++ {ERR_NOT_NUMBER_STR, "Not a numeric string"}, ++ {ERR_TOO_MANY_ARGUMENTS, "Too many arguments"}, ++ {ERR_DUPLICATE_OPTION, "Too many duplicate options"}, ++ {ERR_INVALID_ARGUMENT, "Invalid argument"}, ++ {ERR_TOO_MANY_DOMAINS, "Max domain count is " + to_string(MAX_DOMAINS)}, ++ {ERR_INVALID_SIZE_STR, "Invalid size string"}, ++ {ERR_TOO_MANY_PIDS, "Max pid count is " + to_string(MAX_PIDS)}, ++ {ERR_TOO_MANY_TAGS, "Max tag count is " + to_string(MAX_TAGS)}, ++ {ERR_TAG_STR_TOO_LONG, ("Tag string too long, max length is " + to_string(MAX_TAG_LEN - 1))}, ++ {ERR_REGEX_STR_TOO_LONG, ("Regular expression too long, max length is " + to_string(MAX_REGEX_STR_LEN - 1))}, ++ {ERR_FILE_NAME_TOO_LONG, ("File name too long, max length is " + to_string(MAX_FILE_NAME_LEN))}, ++ {ERR_SOCKET_CLIENT_INIT_FAIL, "Socket client init failed"}, ++ {ERR_SOCKET_WRITE_MSG_HEADER_FAIL, "Socket rite message header failed"}, ++ {ERR_SOCKET_WRITE_CMD_FAIL, "Socket write command failed"}, ++ {ERR_SOCKET_RECEIVE_RSP, "Unable to receive message from socket"}, ++ {ERR_PERSIST_TASK_EMPTY, "No running persist task, please check"}, ++ {ERR_JOBID_NOT_EXSIST, "Persist task of this job id doesn't exist, please check"}, ++ {ERR_TOO_MANY_JOBS, ("Too many jobs are running, max job count is:" + to_string(MAX_JOBS))}, ++ {ERR_STATS_NOT_ENABLE, "Statistic feature is not enable, " ++ "please set param persist.sys.hilog.stats true to enable it, " ++ "further more, you can set persist.sys.hilog.stats.tag true to enable counting log by tags"}, ++ {ERR_NO_RUNNING_TASK, "No running persistent task"}, ++ {ERR_NO_PID_PERMISSION, "Permission denied, only shell and root can filter logs by pid"}, ++}, RET_FAIL, "Unknown error code"); ++ ++string ErrorCode2Str(int16_t errorCode) ++{ ++ return g_ErrorMsgs.GetValue((uint16_t)errorCode) + " [CODE: " + to_string(errorCode) + "]"; ++} ++ ++// Log Types&Strings Map ++static const StringMap g_LogTypes({ ++ {LOG_INIT, "init"}, {LOG_CORE, "core"}, {LOG_APP, "app"}, {LOG_KMSG, "kmsg"} ++}, LOG_TYPE_MAX, "invalid"); ++ ++string LogType2Str(uint16_t logType) ++{ ++ return g_LogTypes.GetValue(logType); ++} ++ ++uint16_t Str2LogType(const string& str) ++{ ++ return g_LogTypes.GetKey(str); ++} ++ ++string ComboLogType2Str(uint16_t shiftType) ++{ ++ vector types = g_LogTypes.GetAllKeys(); ++ string str = ""; ++ uint16_t typeAll = 0; ++ ++ for (uint16_t t : types) { ++ typeAll |= (1 << t); ++ } ++ shiftType &= typeAll; ++ for (uint16_t t: types) { ++ if ((1 << t) & shiftType) { ++ shiftType &= (~(1 << t)); ++ str += (LogType2Str(t) + (shiftType != 0 ? "," : "")); ++ } ++ if (shiftType == 0) { ++ break; ++ } ++ } ++ return str; ++} ++ ++uint16_t Str2ComboLogType(const string& str) ++{ ++ uint16_t logTypes = 0; ++ if (str == "") { ++ logTypes = (1 << LOG_CORE) | (1 << LOG_APP); ++ return logTypes; ++ } ++ vector vec; ++ Split(str, vec); ++ for (auto& it : vec) { ++ if (it == "") { ++ continue; ++ } ++ uint16_t t = Str2LogType(it); ++ if (t == LOG_TYPE_MAX) { ++ return 0; ++ } ++ logTypes |= (1 << t); ++ } ++ return logTypes; ++} ++ ++vector GetAllLogTypes() ++{ ++ return g_LogTypes.GetAllKeys(); ++} ++ ++// Log Levels&Strings Map ++static const StringMap g_LogLevels({ ++ {LOG_DEBUG, "DEBUG"}, {LOG_INFO, "INFO"}, {LOG_WARN, "WARN"}, ++ {LOG_ERROR, "ERROR"}, {LOG_FATAL, "FATAL"}, {LOG_LEVEL_MAX, "X"} ++}, LOG_LEVEL_MIN, "INVALID", [](const string& l1, const string& l2) { ++ if (l1.length() == l2.length()) { ++ return std::equal(l1.begin(), l1.end(), l2.begin(), [](char a, char b) { ++ return std::tolower(a) == std::tolower(b); ++ }); ++ } else { ++ return false; ++ } ++}); ++ ++string LogLevel2Str(uint16_t logLevel) ++{ ++ return g_LogLevels.GetValue(logLevel); ++} ++ ++uint16_t Str2LogLevel(const string& str) ++{ ++ return g_LogLevels.GetKey(str); ++} ++ ++// Log Levels&Short Strings Map ++static const StringMap g_ShortLogLevels({ ++ {LOG_DEBUG, "D"}, {LOG_INFO, "I"}, {LOG_WARN, "W"}, ++ {LOG_ERROR, "E"}, {LOG_FATAL, "F"}, {LOG_LEVEL_MAX, "X"} ++}, LOG_LEVEL_MIN, "V", [](const string& l1, const string& l2) { ++ return (l1.length() == 1 && std::tolower(l1[0]) == std::tolower(l2[0])); ++}); ++ ++string LogLevel2ShortStr(uint16_t logLevel) ++{ ++ return g_ShortLogLevels.GetValue(logLevel); ++} ++ ++uint16_t ShortStr2LogLevel(const string& str) ++{ ++ return g_ShortLogLevels.GetKey(str); ++} ++ ++uint16_t PrettyStr2LogLevel(const string& str) ++{ ++ uint16_t level = ShortStr2LogLevel(str); ++ if (level == static_cast(LOG_LEVEL_MIN)) { ++ return Str2LogLevel(str); ++ } ++ return level; ++} ++ ++string ComboLogLevel2Str(uint16_t shiftLevel) ++{ ++ vector levels = g_ShortLogLevels.GetAllKeys(); ++ string str = ""; ++ uint16_t levelAll = 0; ++ ++ for (uint16_t l : levels) { ++ levelAll |= (1 << l); ++ } ++ shiftLevel &= levelAll; ++ for (uint16_t l: levels) { ++ if ((1 << l) & shiftLevel) { ++ shiftLevel &= (~(1 << l)); ++ str += (LogLevel2Str(l) + (shiftLevel != 0 ? "," : "")); ++ } ++ if (shiftLevel == 0) { ++ break; ++ } ++ } ++ return str; ++} ++ ++uint16_t Str2ComboLogLevel(const string& str) ++{ ++ uint16_t logLevels = 0; ++ if (str == "") { ++ logLevels = 0xFFFF; ++ return logLevels; ++ } ++ vector vec; ++ Split(str, vec); ++ for (auto& it : vec) { ++ if (it == "") { ++ continue; ++ } ++ uint16_t t = PrettyStr2LogLevel(it); ++ if (t == LOG_LEVEL_MIN || t >= LOG_LEVEL_MAX) { ++ return 0; ++ } ++ logLevels |= (1 << t); ++ } ++ return logLevels; ++} ++ ++void Split(const std::string& src, std::vector& dest, const std::string& separator) ++{ ++ std::string str = src; ++ std::string substring; ++ std::string::size_type start = 0; ++ std::string::size_type index; ++ dest.clear(); ++ index = str.find_first_of(separator, start); ++ if (index == std::string::npos) { ++ dest.emplace_back(str); ++ return; ++ } ++ do { ++ substring = str.substr(start, index - start); ++ dest.emplace_back(substring); ++ start = index + separator.size(); ++ index = str.find(separator, start); ++ } while (index != std::string::npos); ++ substring = str.substr(start); ++ if (substring != "") { ++ dest.emplace_back(substring); ++ } ++} ++ ++uint32_t GetBitsCount(uint64_t n) ++{ ++ uint32_t count = 0; ++ while (n != 0) { ++ ++count; ++ n = n & (n-1); ++ } ++ return count; ++} ++ ++uint16_t GetBitPos(uint64_t n) ++{ ++ if (!(n && (!(n & (n-1))))) { // only accpet the number which is power of 2 ++ return 0; ++ } ++ ++ uint16_t i = 0; ++ while (n >> (i++)) {} ++ i--; ++ return i-1; ++} ++ ++enum class Radix { ++ RADIX_DEC, ++ RADIX_HEX, ++}; ++template ++static string Num2Str(T num, Radix radix) ++{ ++ stringstream ss; ++ auto r = std::dec; ++ if (radix == Radix::RADIX_HEX) { ++ r = std::hex; ++ } ++ ss << r << num; ++ return ss.str(); ++} ++ ++template ++static void Str2Num(const string& str, T& num, Radix radix) ++{ ++ T i = 0; ++ std::stringstream ss; ++ auto r = std::dec; ++ if (radix == Radix::RADIX_HEX) { ++ r = std::hex; ++ } ++ ss << r << str; ++ ss >> i; ++ num = i; ++ return; ++} ++ ++string Uint2DecStr(uint32_t i) ++{ ++ return Num2Str(i, Radix::RADIX_DEC); ++} ++ ++uint32_t DecStr2Uint(const string& str) ++{ ++ uint32_t i = 0; ++ Str2Num(str, i, Radix::RADIX_DEC); ++ return i; ++} ++ ++string Uint2HexStr(uint32_t i) ++{ ++ return Num2Str(i, Radix::RADIX_HEX); ++} ++ ++uint32_t HexStr2Uint(const string& str) ++{ ++ uint32_t i = 0; ++ Str2Num(str, i, Radix::RADIX_HEX); ++ return i; ++} ++ ++#if !defined(__WINDOWS__) and !defined(__LINUX__) ++string GetProgName() ++{ ++#ifdef HILOG_USE_MUSL ++ return program_invocation_short_name; ++#else ++ return getprogname(); ++#endif ++} ++#endif ++ ++string GetNameByPid(uint32_t pid) ++{ ++ char path[CMDLINE_PATH_LEN] = { 0 }; ++ if (snprintf_s(path, CMDLINE_PATH_LEN, CMDLINE_PATH_LEN - 1, "/proc/%d/cmdline", pid) <= 0) { ++ return ""; ++ } ++ char cmdline[CMDLINE_LEN] = { 0 }; ++ int i = 0; ++ FILE *fp = fopen(path, "r"); ++ if (fp == nullptr) { ++ return ""; ++ } ++ while (i < (CMDLINE_LEN - 1)) { ++ char c = static_cast(fgetc(fp)); ++ // 0. don't need args of cmdline ++ // 1. ignore unvisible character ++ if (!isgraph(c)) { ++ break; ++ } ++ cmdline[i] = c; ++ i++; ++ } ++ (void)fclose(fp); ++ return cmdline; ++} ++ ++uint32_t GetPPidByPid(uint32_t pid) ++{ ++ uint32_t ppid = 0; ++ char path[STATUS_PATH_LEN] = { 0 }; ++ if (snprintf_s(path, STATUS_PATH_LEN, STATUS_PATH_LEN - 1, "/proc/%u/status", pid) <= 0) { ++ return ppid; ++ } ++ FILE *fp = fopen(path, "r"); ++ if (fp == nullptr) { ++ return ppid; ++ } ++ char buf[STATUS_LEN] = { 0 }; ++ size_t ret = fread(buf, sizeof(char), STATUS_LEN - 1, fp); ++ (void)fclose(fp); ++ if (ret <= 0) { ++ return ppid; ++ } else { ++ buf[ret++] = '\0'; ++ } ++ char *ppidLoc = strstr(buf, "PPid:"); ++ if ((ppidLoc == nullptr) || (sscanf_s(ppidLoc, "PPid:%d", &ppid) == -1)) { ++ return ppid; ++ } ++ std::string ppidName = GetNameByPid(ppid); ++ // ppid fork the sh to execute hilog, sh is not wanted ppid ++ if (std::find(std::begin(SH_NAMES), std::end(SH_NAMES), ppidName) != std::end(SH_NAMES)) { ++ return GetPPidByPid(ppid); ++ } ++ return ppid; ++} ++ ++uint64_t GenerateHash(const char *p, size_t size) ++{ ++ static const uint64_t PRIME = 0x100000001B3ull; ++ static const uint64_t BASIS = 0xCBF29CE484222325ull; ++ uint64_t ret {BASIS}; ++ unsigned long i = 0; ++ while (i < size) { ++ ret ^= *(p + i); ++ ret *= PRIME; ++ i++; ++ } ++ return ret; ++} ++ ++void PrintErrorno(int err) ++{ ++ constexpr int bufSize = 256; ++ char buf[bufSize] = { 0 }; ++#ifndef __WINDOWS__ ++ (void)strerror_r(err, buf, bufSize); ++#else ++ (void)strerror_s(buf, bufSize, err); ++#endif ++ std::cerr << "Errno: " << err << ", " << buf << std::endl; ++} ++ ++int WaitingToDo(int max, const string& path, function func) ++{ ++ chrono::steady_clock::time_point start = chrono::steady_clock::now(); ++ chrono::milliseconds wait(max); ++ while (true) { ++ if (func(path) != RET_FAIL) { ++ cout << "waiting for " << path << " successfully!" << endl; ++ return RET_SUCCESS; ++ } ++ ++ std::this_thread::sleep_for(10ms); ++ if ((chrono::steady_clock::now() - start) > wait) { ++ cerr << "waiting for " << path << " failed!" << endl; ++ return RET_FAIL; ++ } ++ } ++} ++} // namespace HiviewDFX ++} // namespace OHOS +diff --git a/frameworks/libhilog/vsnprintf/include/output_p.inl b/frameworks/libhilog/vsnprintf/include/output_p.inl +new file mode 100644 +index 0000000..d58873b +--- /dev/null ++++ b/frameworks/libhilog/vsnprintf/include/output_p.inl +@@ -0,0 +1,1294 @@ ++/* ++ * Copyright (c) 2021 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++ ++/* [Standardize-exceptions] Use unsafe function: Portability ++ * [reason] Use unsafe function to implement security function to maintain platform compatibility. ++ * And sufficient input validation is performed before calling ++ */ ++ ++#ifndef OUTPUT_P_INL_2B263E9C_43D8_44BB_B17A_6D2033DECEE5 ++#define OUTPUT_P_INL_2B263E9C_43D8_44BB_B17A_6D2033DECEE5 ++ ++#define SECUREC_FLOAT_BUFSIZE (309+40) /* max float point value */ ++#define SECUREC_FLOAT_BUFSIZE_LB (4932+40) /* max long double value */ ++ ++#define SECUREC_INT_MAX 2147483647 ++ ++#define SECUREC_MUL10(x) ((((x) << 2) + (x)) << 1) ++#define SECUREC_INT_MAX_DIV_TEN 21474836 ++#define SECUREC_MUL10_ADD_BEYOND_MAX(val) (((val) > SECUREC_INT_MAX_DIV_TEN)) ++ ++#ifdef SECUREC_STACK_SIZE_LESS_THAN_1K ++#define SECUREC_FMT_STR_LEN (8) ++#else ++#define SECUREC_FMT_STR_LEN (16) ++#endif ++ ++typedef struct { ++ unsigned int flags; ++ int fldWidth; ++ int precision; ++ int bufferIsWide; /* flag for buffer contains wide chars */ ++ int dynWidth; /* %* 1 width from variable parameter ;0 not */ ++ int dynPrecision; /* %.* 1 precision from variable parameter ;0 not */ ++} SecFormatAttr; ++ ++typedef union { ++ char *str; /* not a null terminated string */ ++ wchar_t *wStr; ++} SecFormatBuf; ++ ++typedef union { ++ char str[SECUREC_BUFFER_SIZE + 1]; ++#ifdef SECUREC_FOR_WCHAR ++ wchar_t wStr[SECUREC_BUFFER_SIZE + 1]; ++#endif ++} SecBuffer; ++ ++static int SecIndirectSprintf(char *strDest, const char *format, ...) ++{ ++ int ret; /* If initialization causes e838 */ ++ va_list arglist; ++ ++ va_start(arglist, format); ++ SECUREC_MASK_MSVC_CRT_WARNING ++ ret = vsprintf(strDest, format, arglist); ++ SECUREC_END_MASK_MSVC_CRT_WARNING ++ va_end(arglist); ++ (void)arglist; /* to clear e438 last value assigned not used , the compiler will optimize this code */ ++ ++ return ret; ++} ++ ++#ifdef SECUREC_COMPATIBLE_LINUX_FORMAT ++/* to clear e506 warning */ ++static int SecIsSameSize(size_t sizeA, size_t sizeB) ++{ ++ return sizeA == sizeB; ++} ++#endif ++ ++#define SECUREC_SPECIAL(_val, Base) \ ++ case Base: \ ++ do { \ ++ *--formatBuf.str = digits[_val % Base]; \ ++ }while ((_val /= Base) != 0) ++ ++#define SECUREC_SAFE_WRITE_PREFIX(src, txtLen, _stream, outChars) do { \ ++ for (ii = 0; ii < txtLen; ++ii) { \ ++ *((SecChar *)(void *)(_stream->cur)) = *(src); \ ++ _stream->cur += sizeof(SecChar); \ ++ ++(src); \ ++ } \ ++ _stream->count -= txtLen * (int)(sizeof(SecChar)); \ ++ *(outChars) = *(outChars) + (txtLen); \ ++ } SECUREC_WHILE_ZERO ++ ++#define SECUREC_SAFE_WRITE_STR(src, txtLen, _stream, outChars) do { \ ++ if (txtLen < 12 /* for mobile number length */) { \ ++ for (ii = 0; ii < txtLen; ++ii) { \ ++ *((SecChar *)(void *)(_stream->cur)) = *(src); \ ++ _stream->cur += sizeof(SecChar); \ ++ ++(src); \ ++ } \ ++ } else { \ ++ (void)memcpy(_stream->cur, src, ((size_t)(unsigned int)txtLen * (sizeof(SecChar)))); \ ++ _stream->cur += (size_t)(unsigned int)txtLen * (sizeof(SecChar)); \ ++ } \ ++ _stream->count -= txtLen * (int)(sizeof(SecChar)); \ ++ *(outChars) = *(outChars) + (txtLen); \ ++ } SECUREC_WHILE_ZERO ++ ++#define SECUREC_SAFE_WRITE_CHAR(_ch, _stream, outChars) do { \ ++ *((SecChar *)(void *)(_stream->cur)) = (SecChar)_ch; \ ++ _stream->cur += sizeof(SecChar); \ ++ _stream->count -= (int)(sizeof(SecChar)); \ ++ *(outChars) = *(outChars) + 1; \ ++ } SECUREC_WHILE_ZERO ++ ++#define SECUREC_SAFE_PADDING(padChar, padLen, _stream, outChars) do { \ ++ for (ii = 0; ii < padLen; ++ii) { \ ++ *((SecChar *)(void *)(_stream->cur)) = (SecChar)padChar; \ ++ _stream->cur += sizeof(SecChar); \ ++ } \ ++ _stream->count -= padLen * (int)(sizeof(SecChar)); \ ++ *(outChars) = *(outChars) + (padLen); \ ++ } SECUREC_WHILE_ZERO ++ ++/* The count variable can be reduced to 0, and the external function complements the \0 terminator. */ ++#define SECUREC_IS_REST_BUF_ENOUGH(needLen) ((int)(stream->count - (int)needLen * (int)(sizeof(SecChar))) >= 0) ++ ++#define SECUREC_FMT_STATE_OFFSET 256 ++#ifdef SECUREC_FOR_WCHAR ++#define SECUREC_FMT_TYPE(c, fmtTable) ((((unsigned int)(int)(c)) <= (unsigned int)(int)SECUREC_CHAR('~')) ? \ ++ (fmtTable[(unsigned char)(c)]) : 0) ++#define SECUREC_DECODE_STATE(c, fmtTable, laststate) (SecFmtState)(((fmtTable[(SECUREC_FMT_TYPE(c,fmtTable)) * \ ++ ((unsigned char)STAT_INVALID + 1) + \ ++ (unsigned char)(laststate) + \ ++ SECUREC_FMT_STATE_OFFSET]))) ++#else ++#define SECUREC_DECODE_STATE(c,fmtTable,laststate) (SecFmtState)((fmtTable[(fmtTable[(unsigned char)(c)]) * \ ++ ((unsigned char)STAT_INVALID + 1) + \ ++ (unsigned char)(laststate) + \ ++ SECUREC_FMT_STATE_OFFSET])) ++#endif ++ ++#define PUBLIC_FLAG_LEN 8 ++#define PRIVATE_FLAG_LEN 9 ++#define PUBLIC_FLAG "{public}" ++#define PRIVATE_FLAG "{private}" ++ ++static void SecWritePrivateStr(SecPrintfStream *stream, int *pCharsOut) ++{ ++ int ii = 0; ++#define PRIVATE_STR_LEN (9) ++#ifndef SECUREC_FOR_WCHAR ++ static const char privacyString[] = ""; ++ const char *pPrivStr = privacyString; ++ ++ if (SECUREC_IS_REST_BUF_ENOUGH(PRIVATE_STR_LEN)) { ++ SECUREC_SAFE_WRITE_STR(pPrivStr, PRIVATE_STR_LEN, stream, pCharsOut); ++ } else { ++ SECUREC_WRITE_STRING(pPrivStr, PRIVATE_STR_LEN, stream, pCharsOut); ++ } ++#else ++ static const wchar_t wprivacyString[] = { L'<', L'p', L'r', L'i', L'v', L'a', L't', L'e', L'>', L'\0' }; ++ const wchar_t *pwPrivStr = wprivacyString; ++ ++ if (SECUREC_IS_REST_BUF_ENOUGH(PRIVATE_STR_LEN)) { ++ SECUREC_SAFE_WRITE_STR(pwPrivStr, PRIVATE_STR_LEN, stream, pCharsOut); ++ } else { ++ SECUREC_WRITE_STRING(pwPrivStr, PRIVATE_STR_LEN, stream, pCharsOut); ++ } ++#endif ++} ++ ++static void SecDecodeFlags(SecChar ch, SecFormatAttr *attr) ++{ ++ switch (ch) { ++ case SECUREC_CHAR(' '): ++ attr->flags |= SECUREC_FLAG_SIGN_SPACE; ++ break; ++ case SECUREC_CHAR('+'): ++ attr->flags |= SECUREC_FLAG_SIGN; ++ break; ++ case SECUREC_CHAR('-'): ++ attr->flags |= SECUREC_FLAG_LEFT; ++ break; ++ case SECUREC_CHAR('0'): ++ attr->flags |= SECUREC_FLAG_LEADZERO; /* add zero th the front */ ++ break; ++ case SECUREC_CHAR('#'): ++ attr->flags |= SECUREC_FLAG_ALTERNATE; /* output %x with 0x */ ++ break; ++ default: ++ break; ++ } ++ return; ++} ++ ++static int SecDecodeSize(SecChar ch, SecFormatAttr *attr, const SecChar **format) ++{ ++ switch (ch) { ++#ifdef SECUREC_COMPATIBLE_LINUX_FORMAT ++ case SECUREC_CHAR('j'): ++ attr->flags |= SECUREC_FLAG_INTMAX; ++ break; ++#endif ++ case SECUREC_CHAR('q'): [[fallthrough]]; ++ case SECUREC_CHAR('L'): ++ attr->flags |= SECUREC_FLAG_LONGLONG | SECUREC_FLAG_LONG_DOUBLE; ++ break; ++ case SECUREC_CHAR('l'): ++ if (**format == SECUREC_CHAR('l')) { ++ ++(*format); ++ attr->flags |= SECUREC_FLAG_LONGLONG; /* long long */ ++ } else { ++ attr->flags |= SECUREC_FLAG_LONG; /* long int or wchar_t */ ++ } ++ break; ++ case SECUREC_CHAR('t'): ++ attr->flags |= SECUREC_FLAG_PTRDIFF; ++ break; ++#ifdef SECUREC_COMPATIBLE_LINUX_FORMAT ++ case SECUREC_CHAR('z'): ++ attr->flags |= SECUREC_FLAG_SIZE; ++ break; ++ case SECUREC_CHAR('Z'): ++ attr->flags |= SECUREC_FLAG_SIZE; ++ break; ++#endif ++ ++ case SECUREC_CHAR('I'): ++#ifdef SECUREC_ON_64BITS ++ attr->flags |= SECUREC_FLAG_I64; /* %I to INT64 */ ++#endif ++ if ((**format == SECUREC_CHAR('6')) && (*((*format) + 1) == SECUREC_CHAR('4'))) { ++ (*format) += 2; ++ attr->flags |= SECUREC_FLAG_I64; /* %I64 to INT64 */ ++ } else if ((**format == SECUREC_CHAR('3')) && (*((*format) + 1) == SECUREC_CHAR('2'))) { ++ (*format) += 2; ++ attr->flags &= ~SECUREC_FLAG_I64; /* %I64 to INT32 */ ++ } else if ((**format == SECUREC_CHAR('d')) || (**format == SECUREC_CHAR('i')) || ++ (**format == SECUREC_CHAR('o')) || (**format == SECUREC_CHAR('u')) || ++ (**format == SECUREC_CHAR('x')) || (**format == SECUREC_CHAR('X'))) { ++ /* do nothing */ ++ } else { ++ /* Compatibility code for "%I" just print I */ ++ return -1; ++ } ++ break; ++ ++ case SECUREC_CHAR('h'): ++ if (**format == SECUREC_CHAR('h')) ++ attr->flags |= SECUREC_FLAG_CHAR; /* char */ ++ else ++ attr->flags |= SECUREC_FLAG_SHORT; /* short int */ ++ break; ++ ++ case SECUREC_CHAR('w'): ++ attr->flags |= SECUREC_FLAG_WIDECHAR; /* wide char */ ++ break; ++ default: ++ break; ++ ++ } ++ ++ return 0; ++} ++ ++static int SecDecodeTypeC(SecFormatAttr *attr, unsigned int cValue, SecFormatBuf *formatBuf, SecBuffer *buffer) ++{ ++ int textLen; ++ wchar_t wchar; ++ ++#if (defined(SECUREC_COMPATIBLE_LINUX_FORMAT)) && !(defined(__hpux)) && !(defined(SECUREC_ON_SOLARIS)) ++ attr->flags &= ~SECUREC_FLAG_LEADZERO; ++#endif ++ ++#ifdef SECUREC_FOR_WCHAR ++ attr->bufferIsWide = 1; ++ wchar = (wchar_t)cValue; ++ if (attr->flags & SECUREC_FLAG_SHORT) { ++ /* multibyte character to wide character */ ++ char tempchar[2]; ++ tempchar[0] = (char)(wchar & 0x00ff); ++ tempchar[1] = '\0'; ++ ++ if (mbtowc(buffer->wStr, tempchar, sizeof(tempchar)) < 0) { ++ return -1; ++ } ++ } else { ++ buffer->wStr[0] = wchar; ++ } ++ formatBuf->wStr = buffer->wStr; ++ textLen = 1; /* only 1 wide character */ ++#else ++ attr->bufferIsWide = 0; ++ if (attr->flags & (SECUREC_FLAG_LONG | SECUREC_FLAG_WIDECHAR)) { ++ wchar = (wchar_t)cValue; ++ /* wide character to multibyte character */ ++ SECUREC_MASK_MSVC_CRT_WARNING ++ textLen = wctomb(buffer->str, wchar); ++ SECUREC_END_MASK_MSVC_CRT_WARNING ++ if (textLen < 0) { ++ return -1; ++ } ++ } else { ++ /* get multibyte character from argument */ ++ unsigned short temp; ++ temp = (unsigned short)cValue; ++ buffer->str[0] = (char)temp; ++ textLen = 1; ++ } ++ formatBuf->str = buffer->str; ++#endif ++ ++ return textLen; ++} ++ ++static int SecDecodeTypeS(SecFormatAttr *attr, char *argPtr, SecFormatBuf *formatBuf) ++{ ++ /* literal string to print null ptr, define it on stack rather than const text area ++ is to avoid gcc warning with pointing const text with variable */ ++ static char strNullString[8] = "(null)"; ++ static wchar_t wStrNullString[8] = { L'(', L'n', L'u', L'l', L'l', L')', L'\0', L'\0' }; ++ ++ int finalPrecision; ++ char *strEnd = NULL; ++ wchar_t *wStrEnd = NULL; ++ int textLen; ++ ++#if (defined(SECUREC_COMPATIBLE_LINUX_FORMAT)) && (!defined(SECUREC_ON_UNIX)) ++ attr->flags &= ~SECUREC_FLAG_LEADZERO; ++#endif ++ finalPrecision = (attr->precision == -1) ? SECUREC_INT_MAX : attr->precision; ++ formatBuf->str = argPtr; ++ ++#ifdef SECUREC_FOR_WCHAR ++#if defined(SECUREC_COMPATIBLE_LINUX_FORMAT) ++ if (!(attr->flags & SECUREC_FLAG_LONG)) { ++ attr->flags |= SECUREC_FLAG_SHORT; ++ } ++#endif ++ if (attr->flags & SECUREC_FLAG_SHORT) { ++ if (formatBuf->str == NULL) { /* NULL passed, use special string */ ++ formatBuf->str = strNullString; ++ } ++ strEnd = formatBuf->str; ++ for (textLen = 0; textLen < finalPrecision && *strEnd; textLen++) { ++ ++strEnd; ++ } ++ /* textLen now contains length in multibyte chars */ ++ } else { ++ if (formatBuf->wStr == NULL) { /* NULL passed, use special string */ ++ formatBuf->wStr = wStrNullString; ++ } ++ attr->bufferIsWide = 1; ++ wStrEnd = formatBuf->wStr; ++ while (finalPrecision-- && *wStrEnd) { ++ ++wStrEnd; ++ } ++ textLen = (int)(wStrEnd - formatBuf->wStr); /* in wchar_ts */ ++ /* textLen now contains length in wide chars */ ++ } ++#else /* SECUREC_FOR_WCHAR */ ++ if (attr->flags & (SECUREC_FLAG_LONG | SECUREC_FLAG_WIDECHAR)) { ++ if (formatBuf->wStr == NULL) { /* NULL passed, use special string */ ++ formatBuf->wStr = wStrNullString; ++ } ++ attr->bufferIsWide = 1; ++ wStrEnd = formatBuf->wStr; ++ while (finalPrecision-- && *wStrEnd) { ++ ++wStrEnd; ++ } ++ textLen = (int)(wStrEnd - formatBuf->wStr); ++ } else { ++ if (formatBuf->str == NULL) { /* meet NULL, use special string */ ++ formatBuf->str = strNullString; ++ } ++ ++ if (finalPrecision == SECUREC_INT_MAX) { ++ /* precision NOT assigned */ ++ /* The strlen performance is high when the string length is greater than 32 */ ++ textLen = (int)strlen(formatBuf->str); ++ } else { ++ /* precision assigned */ ++ strEnd = formatBuf->str; ++ while (finalPrecision-- && *strEnd) { ++ ++strEnd; ++ } ++ textLen = (int)(strEnd - formatBuf->str); /* length of the string */ ++ } ++ ++ } ++ ++#endif /* SECUREC_FOR_WCHAR */ ++ return textLen; ++} ++ ++HILOG_LOCAL_API ++int SecOutputPS(SecPrintfStream *stream, int priv, const char *cformat, va_list arglist) ++{ ++ const SecChar *format = cformat; ++ ++ char *floatBuf = NULL; ++ SecFormatBuf formatBuf; ++ static const char *itoaUpperDigits = "0123456789ABCDEFX"; ++ static const char *itoaLowerDigits = "0123456789abcdefx"; ++ const char *digits = itoaUpperDigits; ++ int ii = 0; ++ ++ unsigned int radix; ++ int charsOut; /* characters written */ ++ ++ int prefixLen = 0; ++ int padding = 0; ++ ++ int textLen; /* length of the text */ ++ int bufferSize = 0; /* size of formatBuf.str */ ++ int noOutput = 0; ++ ++ SecFmtState state; ++ SecFmtState laststate; ++ ++ SecChar prefix[2] = { 0 }; ++ SecChar ch; /* currently read character */ ++ ++ static const unsigned char fmtCharTable[337] = { ++ /* type 0: nospecial meaning; ++ 1: '%'; ++ 2: '.' ++ 3: '*' ++ 4: '0' ++ 5: '1' ... '9' ++ 6: ' ', '+', '-', '#' ++ 7: 'h', 'l', 'L', 'F', 'w' , 'N','z','q','t','j' ++ 8: 'd','o','u','i','x','X','e','f','g' ++ */ ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x06, 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0x06, 0x00, 0x06, 0x02, 0x00, ++ 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x08, 0x08, 0x00, 0x07, 0x00, 0x00, 0x07, 0x00, 0x07, 0x00, ++ 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x08, 0x07, 0x00, 0x07, 0x00, 0x00, 0x08, ++ 0x08, 0x07, 0x00, 0x08, 0x07, 0x08, 0x00, 0x07, 0x08, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, ++ /* fill zero for normal char 128 byte for 0x80 - 0xff */ ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ /* state 0: normal ++ 1: percent ++ 2: flag ++ 3: width ++ 4: dot ++ 5: precis ++ 6: size ++ 7: type ++ 8: invalid ++ */ ++ 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x01, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, ++ 0x01, 0x00, 0x00, 0x04, 0x04, 0x04, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x03, 0x03, 0x08, 0x05, ++ 0x08, 0x08, 0x00, 0x00, 0x00, 0x02, 0x02, 0x03, 0x05, 0x05, 0x08, 0x00, 0x00, 0x00, 0x03, 0x03, ++ 0x03, 0x05, 0x05, 0x08, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, ++ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, ++ 0x00 ++ }; ++ ++ SecFormatAttr formatAttr; ++ SecBuffer buffer; ++ formatAttr.flags = 0; ++ formatAttr.bufferIsWide = 0; /* flag for buffer contains wide chars */ ++ formatAttr.fldWidth = 0; ++ formatAttr.precision = 0; ++ formatAttr.dynWidth = 0; ++ formatAttr.dynPrecision = 0; ++ ++ charsOut = 0; ++ textLen = 0; ++ state = STAT_NORMAL; /* starting state */ ++ formatBuf.str = NULL; ++ ++ int isPrivacy = 1; /*whether show private string*/ ++ ++ /* loop each format character */ ++ /* remove format != NULL */ ++ while ((ch = *format++) != SECUREC_CHAR('\0') && charsOut >= 0) { ++ laststate = state; ++ state = SECUREC_DECODE_STATE(ch, fmtCharTable, laststate); ++ ++ switch (state) { ++ case STAT_NORMAL: ++ ++NORMAL_CHAR: ++ ++ /* normal state, write character */ ++ if (SECUREC_IS_REST_BUF_ENOUGH(1 /* only one char */ )) { ++ SECUREC_SAFE_WRITE_CHAR(ch, stream, &charsOut); /* char * cast to wchar * */ ++ } else { ++#ifdef SECUREC_FOR_WCHAR ++ SECUREC_WRITE_CHAR(ch, stream, &charsOut); ++#else ++ /* optimize function call to code */ ++ charsOut = -1; ++ stream->count = -1; ++#endif ++ } ++ ++ continue; ++ ++ case STAT_PERCENT: ++ /* set default values */ ++ prefixLen = 0; ++ noOutput = 0; ++ formatAttr.flags = 0; ++ formatAttr.fldWidth = 0; ++ formatAttr.precision = -1; ++ formatAttr.bufferIsWide = 0; ++ if (*format == SECUREC_CHAR('{')) { ++ if (strncmp(format, PUBLIC_FLAG, PUBLIC_FLAG_LEN) == 0) { ++ isPrivacy = 0; ++ format += PUBLIC_FLAG_LEN; ++ } ++ else if (strncmp(format, PRIVATE_FLAG, PRIVATE_FLAG_LEN) == 0) { ++ isPrivacy = 1; ++ format += PRIVATE_FLAG_LEN; ++ } ++ } ++ else { ++ isPrivacy = 1; ++ } ++ ++ if (0 == priv) { ++ isPrivacy = 0; ++ } ++ ++ break; ++ ++ case STAT_FLAG: ++ /* set flag based on which flag character */ ++ SecDecodeFlags(ch, &formatAttr); ++ break; ++ ++ case STAT_WIDTH: ++ /* update width value */ ++ if (ch == SECUREC_CHAR('*')) { ++ /* get width */ ++ formatAttr.fldWidth = (int)va_arg(arglist, int); ++ if (formatAttr.fldWidth < 0) { ++ formatAttr.flags |= SECUREC_FLAG_LEFT; ++ formatAttr.fldWidth = -formatAttr.fldWidth; ++ } ++ formatAttr.dynWidth = 1; ++ } else { ++ if (laststate != STAT_WIDTH) { ++ formatAttr.fldWidth = 0; ++ } ++ if (SECUREC_MUL10_ADD_BEYOND_MAX(formatAttr.fldWidth)) { ++ return -1; ++ } ++ formatAttr.fldWidth = (int)SECUREC_MUL10((unsigned int)formatAttr.fldWidth) + (ch - SECUREC_CHAR('0')); ++ formatAttr.dynWidth = 0; ++ } ++ break; ++ ++ case STAT_DOT: ++ formatAttr.precision = 0; ++ break; ++ ++ case STAT_PRECIS: ++ /* update precision value */ ++ if (ch == SECUREC_CHAR('*')) { ++ /* get precision from arg list */ ++ formatAttr.precision = (int)va_arg(arglist, int); ++ if (formatAttr.precision < 0) { ++ formatAttr.precision = -1; ++ } ++ formatAttr.dynPrecision = 1; ++ } else { ++ /* add digit to current precision */ ++ if (SECUREC_MUL10_ADD_BEYOND_MAX(formatAttr.precision)) { ++ return -1; ++ } ++ formatAttr.precision = ++ (int)SECUREC_MUL10((unsigned int)formatAttr.precision) + (ch - SECUREC_CHAR('0')); ++ formatAttr.dynPrecision = 0; ++ } ++ break; ++ ++ case STAT_SIZE: ++ /* read a size specifier, set the formatAttr.flags based on it */ ++ if (SecDecodeSize(ch, &formatAttr, &format) != 0) { ++ /* Compatibility code for "%I" just print I */ ++ state = STAT_NORMAL; ++ goto NORMAL_CHAR; ++ } ++ break; ++ ++ case STAT_TYPE: ++ ++ switch (ch) { ++ ++ case SECUREC_CHAR('C'): ++ /* wide char */ ++ if (!(formatAttr.flags & (SECUREC_FLAG_SHORT | SECUREC_FLAG_LONG | SECUREC_FLAG_WIDECHAR))) { ++ ++#ifdef SECUREC_FOR_WCHAR ++ formatAttr.flags |= SECUREC_FLAG_SHORT; ++#else ++ formatAttr.flags |= SECUREC_FLAG_WIDECHAR; ++#endif ++ } ++ [[fallthrough]]; ++ case SECUREC_CHAR('c'): ++ { ++ unsigned int cValue = (unsigned int)va_arg(arglist, int); ++ /*if it's a private arg, just write to stream*/ ++ if (isPrivacy == 1) { ++ break; ++ } ++ textLen = SecDecodeTypeC(&formatAttr, cValue, &formatBuf, &buffer); ++ if (textLen < 0) { ++ noOutput = 1; ++ } ++ } ++ break; ++ case SECUREC_CHAR('S'): /* wide char string */ ++#ifndef SECUREC_FOR_WCHAR ++ if (!(formatAttr.flags & (SECUREC_FLAG_SHORT | SECUREC_FLAG_LONG | SECUREC_FLAG_WIDECHAR))) { ++ formatAttr.flags |= SECUREC_FLAG_WIDECHAR; ++ } ++#else ++ if (!(formatAttr.flags & (SECUREC_FLAG_SHORT | SECUREC_FLAG_LONG | SECUREC_FLAG_WIDECHAR))) { ++ formatAttr.flags |= SECUREC_FLAG_SHORT; ++ } ++#endif ++ [[fallthrough]]; ++ case SECUREC_CHAR('s'): ++ { ++ char *argPtr = (char *)va_arg(arglist, char *); ++ /*if it's a private arg, just write to stream*/ ++ if (isPrivacy == 1) { ++ break; ++ } ++ textLen = SecDecodeTypeS(&formatAttr, argPtr, &formatBuf); ++ } ++ break; ++ ++ case SECUREC_CHAR('n'): ++ /* higher risk disable it */ ++ return -1; ++ ++ case SECUREC_CHAR('E'): /* fall-through */ /* FALLTHRU */ ++ case SECUREC_CHAR('F'): /* fall-through */ /* FALLTHRU */ ++ case SECUREC_CHAR('G'): /* fall-through */ /* FALLTHRU */ ++ case SECUREC_CHAR('A'): /* fall-through */ /* FALLTHRU */ ++ /* convert format char to lower , use Explicit conversion to clean up compilation warning */ ++ ch = (SecChar)(ch + ((SecChar)(SECUREC_CHAR('a')) - (SECUREC_CHAR('A')))); ++ [[fallthrough]]; ++ case SECUREC_CHAR('e'): /* fall-through */ /* FALLTHRU */ ++ case SECUREC_CHAR('f'): /* fall-through */ /* FALLTHRU */ ++ case SECUREC_CHAR('g'): /* fall-through */ /* FALLTHRU */ ++ case SECUREC_CHAR('a'): ++ { ++ /*if it's a private arg, just write to stream*/ ++ if (isPrivacy == 1) { ++#ifdef SECUREC_COMPATIBLE_LINUX_FORMAT ++ if (formatAttr.flags & SECUREC_FLAG_LONG_DOUBLE) { ++ (void)va_arg(arglist, long double); ++ } else ++#endif ++ { ++ (void)va_arg(arglist, double); ++ } ++ break; ++ } ++ ++ /* floating point conversion */ ++ formatBuf.str = buffer.str; /* output buffer for float string with default size */ ++ ++ /* compute the precision value */ ++ if (formatAttr.precision < 0) { ++ formatAttr.precision = 6; ++ } else if (formatAttr.precision == 0 && ch == SECUREC_CHAR('g')) { ++ formatAttr.precision = 1; ++ } ++ ++ /* calc buffer size to store long double value */ ++ if (formatAttr.flags & SECUREC_FLAG_LONG_DOUBLE) { ++ if (formatAttr.precision > (SECUREC_INT_MAX - SECUREC_FLOAT_BUFSIZE_LB)) { ++ noOutput = 1; ++ break; ++ } ++ bufferSize = SECUREC_FLOAT_BUFSIZE_LB + formatAttr.precision; ++ } else { ++ if (formatAttr.precision > (SECUREC_INT_MAX - SECUREC_FLOAT_BUFSIZE)) { ++ noOutput = 1; ++ break; ++ } ++ bufferSize = SECUREC_FLOAT_BUFSIZE + formatAttr.precision; ++ } ++ if (formatAttr.fldWidth > bufferSize) { ++ bufferSize = formatAttr.fldWidth; ++ } ++ ++ if (bufferSize >= SECUREC_BUFFER_SIZE) { ++ /* the current value of SECUREC_BUFFER_SIZE could NOT store the formatted float string */ ++ /* size include '+' and '\0' */ ++ floatBuf = (char *)SECUREC_MALLOC(((size_t)(unsigned int)bufferSize + (size_t)2)); ++ if (floatBuf != NULL) { ++ formatBuf.str = floatBuf; ++ } else { ++ noOutput = 1; ++ break; ++ } ++ } ++ ++ { ++ /* add following code to call system sprintf API for float number */ ++ const SecChar *pFltFmt = format - 2; /* point to the position before 'f' or 'g' */ ++ int k; ++ int fltFmtStrLen; ++ char fltFmtBuf[SECUREC_FMT_STR_LEN]; ++ char *fltFmtStr = fltFmtBuf; ++ char *fltFmtHeap = NULL; /* to clear warning */ ++ ++ /* must meet '%' (normal format) or '}'(with{private} or{public} format)*/ ++ while (SECUREC_CHAR('%') != *pFltFmt && SECUREC_CHAR('}') != *pFltFmt) { ++ --pFltFmt; ++ } ++ fltFmtStrLen = (int)((format - pFltFmt) + 1); /* with ending terminator */ ++ if (fltFmtStrLen > SECUREC_FMT_STR_LEN) { ++ /* if SECUREC_FMT_STR_LEN is NOT enough, alloc a new buffer */ ++ fltFmtHeap = (char *)SECUREC_MALLOC((size_t)((unsigned int)fltFmtStrLen)); ++ if (fltFmtHeap == NULL) { ++ noOutput = 1; ++ break; ++ } else { ++ fltFmtHeap[0] = '%'; ++ for (k = 1; k < fltFmtStrLen - 1; ++k) { ++ /* convert wchar to char */ ++ fltFmtHeap[k] = (char)(pFltFmt[k]); /* copy the format string */ ++ } ++ fltFmtHeap[k] = '\0'; ++ ++ fltFmtStr = fltFmtHeap; ++ } ++ } else { ++ /* purpose of the repeat code is to solve the tool alarm Redundant_Null_Check */ ++ fltFmtBuf[0] = '%'; ++ for (k = 1; k < fltFmtStrLen - 1; ++k) { ++ /* convert wchar to char */ ++ fltFmtBuf[k] = (char)(pFltFmt[k]); /* copy the format string */ ++ } ++ fltFmtBuf[k] = '\0'; ++ } ++ ++#ifdef SECUREC_COMPATIBLE_LINUX_FORMAT ++ if (formatAttr.flags & SECUREC_FLAG_LONG_DOUBLE) { ++ long double tmp = (long double)va_arg(arglist, long double); ++ /* call system sprintf to format float value */ ++ if (formatAttr.dynWidth && formatAttr.dynPrecision) { ++ textLen = SecIndirectSprintf(formatBuf.str, (char *)fltFmtStr, ++ formatAttr.fldWidth,formatAttr.precision, tmp); ++ } else if (formatAttr.dynWidth) { ++ textLen = SecIndirectSprintf(formatBuf.str, (char *)fltFmtStr, ++ formatAttr.fldWidth, tmp); ++ } else if (formatAttr.dynPrecision) { ++ textLen = SecIndirectSprintf(formatBuf.str, (char *)fltFmtStr, ++ formatAttr.precision, tmp); ++ } else { ++ textLen = SecIndirectSprintf(formatBuf.str, (char *)fltFmtStr, tmp); ++ } ++ } else ++#endif ++ { ++ double tmp = (double)va_arg(arglist, double); ++ if (formatAttr.dynWidth && formatAttr.dynPrecision) { ++ textLen = SecIndirectSprintf(formatBuf.str, (char *)fltFmtStr, formatAttr.fldWidth, ++ formatAttr.precision, tmp); ++ } else if (formatAttr.dynWidth) { ++ textLen = SecIndirectSprintf(formatBuf.str, (char *)fltFmtStr, formatAttr.fldWidth, ++ tmp); ++ } else if (formatAttr.dynPrecision) { ++ textLen = SecIndirectSprintf(formatBuf.str, (char *)fltFmtStr, formatAttr.precision, ++ tmp); ++ } else { ++ textLen = SecIndirectSprintf(formatBuf.str, (char *)fltFmtStr, tmp); ++ } ++ } ++ ++ if (fltFmtHeap != NULL) { ++ /* if buffer is allocated on heap, free it */ ++ SECUREC_FREE(fltFmtHeap); ++ fltFmtHeap = NULL; ++ /* to clear e438 last value assigned not used , the compiler will optimize this code */ ++ (void)fltFmtHeap; ++ } ++ if (textLen < 0) { ++ /* bufferSize is large enough,just validation the return value */ ++ noOutput = 1; ++ break; ++ } ++ ++ formatAttr.fldWidth = textLen; /* no padding ,this variable to calculate amount of padding */ ++ prefixLen = 0; /* no padding ,this variable to calculate amount of padding */ ++ formatAttr.flags = 0; /* clear all internal formatAttr.flags */ ++ break; ++ } ++ } ++ ++ case SECUREC_CHAR('p'): ++ /* print a pointer */ ++#if defined(SECUREC_COMPATIBLE_WIN_FORMAT) ++ formatAttr.flags &= ~SECUREC_FLAG_LEADZERO; ++#else ++ formatAttr.flags |= SECUREC_FLAG_POINTER; ++#endif ++ ++#ifdef SECUREC_ON_64BITS ++ formatAttr.flags |= SECUREC_FLAG_I64; /* converting an int64 */ ++#else ++ formatAttr.flags |= SECUREC_FLAG_LONG; /* converting a long */ ++#endif ++ ++#if (defined(SECUREC_COMPATIBLE_LINUX_FORMAT) || defined(SECUREC_VXWORKS_PLATFORM)) && (!defined(SECUREC_ON_UNIX)) ++ ++#if defined(SECUREC_VXWORKS_PLATFORM) ++ formatAttr.precision = 1; ++#else ++ formatAttr.precision = 0; ++#endif ++ formatAttr.flags |= SECUREC_FLAG_ALTERNATE; /* "0x" is not default prefix in UNIX */ ++ digits = itoaLowerDigits; ++ goto OUTPUT_HEX; ++#else ++/* not linux vxwoks */ ++#if defined(_AIX) || defined(SECUREC_ON_SOLARIS) ++ formatAttr.precision = 1; ++#else ++ formatAttr.precision = 2 * sizeof(void *); ++#endif ++ ++#endif ++ ++#if defined(SECUREC_ON_UNIX) ++ digits = itoaLowerDigits; ++ goto OUTPUT_HEX; ++#endif ++ ++ [[fallthrough]]; ++ case SECUREC_CHAR('X'): ++ /* unsigned upper hex output */ ++ digits = itoaUpperDigits; ++ goto OUTPUT_HEX; ++ case SECUREC_CHAR('x'): ++ /* unsigned lower hex output */ ++ digits = itoaLowerDigits; ++ ++OUTPUT_HEX: ++ radix = 16; ++ if (formatAttr.flags & SECUREC_FLAG_ALTERNATE) { ++ /* alternate form means '0x' prefix */ ++ prefix[0] = SECUREC_CHAR('0'); ++ prefix[1] = (SecChar)(digits[16]); /* 'x' or 'X' */ ++ ++#if (defined(SECUREC_COMPATIBLE_LINUX_FORMAT) || defined(SECUREC_VXWORKS_PLATFORM)) ++ if (ch == 'p') { ++ prefix[1] = SECUREC_CHAR('x'); ++ } ++#endif ++#if defined(_AIX) || defined(SECUREC_ON_SOLARIS) ++ if (ch == 'p') { ++ prefixLen = 0; ++ } else { ++ prefixLen = 2; ++ } ++#else ++ prefixLen = 2; ++#endif ++ ++ } ++ goto OUTPUT_INT; ++ case SECUREC_CHAR('i'): /* fall-through */ /* FALLTHRU */ ++ case SECUREC_CHAR('d'): /* fall-through */ /* FALLTHRU */ ++ /* signed decimal output */ ++ formatAttr.flags |= SECUREC_FLAG_SIGNED; ++ [[fallthrough]]; ++ case SECUREC_CHAR('u'): ++ radix = 10; ++ goto OUTPUT_INT; ++ case SECUREC_CHAR('o'): ++ /* unsigned octal output */ ++ radix = 8; ++ if (formatAttr.flags & SECUREC_FLAG_ALTERNATE) { ++ /* alternate form means force a leading 0 */ ++ formatAttr.flags |= SECUREC_FLAG_FORCE_OCTAL; ++ } ++OUTPUT_INT: ++ { ++ ++ SecUnsignedInt64 number = 0; /* number to convert */ ++ SecInt64 l; /* temp long value */ ++ unsigned char tch; ++#if defined(SECUREC_VXWORKS_VERSION_5_4) && !defined(SECUREC_ON_64BITS) ++ SecUnsignedInt32 digit = 0; /* ascii value of digit */ ++ SecUnsignedInt32 quotientHigh = 0; ++ SecUnsignedInt32 quotientLow = 0; ++#endif ++ ++ /* read argument into variable l */ ++ if (formatAttr.flags & SECUREC_FLAG_I64) { ++ l = (SecInt64)va_arg(arglist, SecInt64); ++ } else if (formatAttr.flags & SECUREC_FLAG_LONGLONG) { ++ l = (SecInt64)va_arg(arglist, SecInt64); ++ } else ++#ifdef SECUREC_ON_64BITS ++ if (formatAttr.flags & SECUREC_FLAG_LONG) { ++ l = (long)va_arg(arglist, long); ++ } else ++#endif /* SECUREC_ON_64BITS */ ++ if (formatAttr.flags & SECUREC_FLAG_CHAR) { ++ if (formatAttr.flags & SECUREC_FLAG_SIGNED) { ++ l = (char)va_arg(arglist, int); /* sign extend */ ++ if (l >= 128) { /* on some platform, char is always unsigned */ ++ SecUnsignedInt64 tmpL = (SecUnsignedInt64)l; ++ formatAttr.flags |= SECUREC_FLAG_NEGATIVE; ++ tch = (unsigned char)(~(tmpL)); ++ l = tch + 1; ++ } ++ } else { ++ l = (unsigned char)va_arg(arglist, int); /* zero-extend */ ++ } ++ ++ } else if (formatAttr.flags & SECUREC_FLAG_SHORT) { ++ if (formatAttr.flags & SECUREC_FLAG_SIGNED) { ++ l = (short)va_arg(arglist, int); /* sign extend */ ++ } else { ++ l = (unsigned short)va_arg(arglist, int); /* zero-extend */ ++ } ++ ++ } ++#ifdef SECUREC_COMPATIBLE_LINUX_FORMAT ++ else if (formatAttr.flags & SECUREC_FLAG_PTRDIFF) { ++ l = (ptrdiff_t)va_arg(arglist, ptrdiff_t); /* sign extend */ ++ } else if (formatAttr.flags & SECUREC_FLAG_SIZE) { ++ if (formatAttr.flags & SECUREC_FLAG_SIGNED) { ++ /* No suitable macros were found to handle the branch */ ++ if (SecIsSameSize(sizeof(size_t), sizeof(long))) { ++ l = va_arg(arglist, long); /* sign extend */ ++ } else if (SecIsSameSize(sizeof(size_t), sizeof(long long))) { ++ l = va_arg(arglist, long long); /* sign extend */ ++ } else { ++ l = va_arg(arglist, int); /* sign extend */ ++ } ++ } else { ++ l = (SecInt64)(size_t)va_arg(arglist, size_t); /* sign extend */ ++ } ++ } else if (formatAttr.flags & SECUREC_FLAG_INTMAX) { ++ if (formatAttr.flags & SECUREC_FLAG_SIGNED) { ++ l = va_arg(arglist, SecInt64); /* sign extend */ ++ } else { ++ l = (SecInt64)(SecUnsignedInt64)va_arg(arglist, SecUnsignedInt64); /* sign extend */ ++ } ++ } ++#endif ++ else { ++ if (formatAttr.flags & SECUREC_FLAG_SIGNED) { ++ l = va_arg(arglist, int); /* sign extend */ ++ } else { ++ l = (unsigned int)va_arg(arglist, int); /* zero-extend */ ++ } ++ ++ } ++ /*if it's a private arg, just write to stream*/ ++ if (isPrivacy == 1) { ++ break; ++ } ++ ++ /* check for negative; copy into number */ ++ if ((formatAttr.flags & SECUREC_FLAG_SIGNED) && l < 0) { ++ number = (SecUnsignedInt64)(-l); ++ formatAttr.flags |= SECUREC_FLAG_NEGATIVE; ++ } else { ++ number = (SecUnsignedInt64)l; ++ } ++ ++ if (((formatAttr.flags & SECUREC_FLAG_I64) == 0) && ++#ifdef SECUREC_COMPATIBLE_LINUX_FORMAT ++ ((formatAttr.flags & SECUREC_FLAG_INTMAX) == 0) && ++#endif ++#ifdef SECUREC_ON_64BITS ++ ((formatAttr.flags & SECUREC_FLAG_PTRDIFF) == 0) && ++ ((formatAttr.flags & SECUREC_FLAG_SIZE) == 0) && ++#if !defined(SECUREC_COMPATIBLE_WIN_FORMAT) /* on window 64 system sizeof long is 32bit */ ++ ((formatAttr.flags & SECUREC_FLAG_LONG) == 0) && ++#endif ++#endif ++ ((formatAttr.flags & SECUREC_FLAG_LONGLONG) == 0)) { ++ ++ number &= 0xffffffff; ++ } ++ ++ /* check precision value for default */ ++ if (formatAttr.precision < 0) { ++ formatAttr.precision = 1; /* default precision */ ++ } else { ++#if defined(SECUREC_COMPATIBLE_WIN_FORMAT) ++ formatAttr.flags &= ~SECUREC_FLAG_LEADZERO; ++#else ++ if (!(formatAttr.flags & SECUREC_FLAG_POINTER)) { ++ formatAttr.flags &= ~SECUREC_FLAG_LEADZERO; ++ } ++#endif ++ if (formatAttr.precision > SECUREC_MAX_PRECISION) { ++ formatAttr.precision = SECUREC_MAX_PRECISION; ++ } ++ } ++ ++ /* Check if data is 0; if so, turn off hex prefix,if 'p',add 0x prefix,else not add prefix */ ++ if (number == 0) { ++#if !(defined(SECUREC_VXWORKS_PLATFORM)||defined(__hpux)) ++ prefixLen = 0; ++#else ++ if ((ch == 'p') && (formatAttr.flags & SECUREC_FLAG_ALTERNATE)) ++ prefixLen = 2; ++ else ++ prefixLen = 0; ++#endif ++ } ++ ++ /* Convert data to ASCII */ ++ formatBuf.str = &buffer.str[SECUREC_BUFFER_SIZE]; ++ ++ if (number > 0) { ++#ifdef SECUREC_ON_64BITS ++ switch (radix) { ++ /* the compiler will optimize each one */ ++ SECUREC_SPECIAL(number, 10); ++ break; ++ SECUREC_SPECIAL(number, 16); ++ break; ++ SECUREC_SPECIAL(number, 8); ++ break; ++ default: ++ break; ++ } ++#else /* for 32 bits system */ ++ if (number <= 0xFFFFFFFFUL) { ++ /* in most case, the value to be converted is small value */ ++ SecUnsignedInt32 n32Tmp = (SecUnsignedInt32)number; ++ switch (radix) { ++ SECUREC_SPECIAL(n32Tmp, 16); ++ break; ++ SECUREC_SPECIAL(n32Tmp, 8); ++ break; ++ ++#ifdef _AIX ++ /* the compiler will optimize div 10 */ ++ SECUREC_SPECIAL(n32Tmp, 10); ++ break; ++#else ++ case 10: ++ { ++ /* fast div 10 */ ++ SecUnsignedInt32 q; ++ SecUnsignedInt32 r; ++ do { ++ *--formatBuf.str = digits[n32Tmp % 10]; ++ q = (n32Tmp >> 1) + (n32Tmp >> 2); ++ q = q + (q >> 4); ++ q = q + (q >> 8); ++ q = q + (q >> 16); ++ q = q >> 3; ++ r = n32Tmp - (((q << 2) + q) << 1); ++ n32Tmp = (r > 9) ? (q + 1) : q; ++ } while (n32Tmp != 0); ++ } ++ break; ++#endif ++ default: ++ break; ++ } /* end switch */ ++ } else { ++ /* the value to be converted is greater than 4G */ ++#if defined(SECUREC_VXWORKS_VERSION_5_4) ++ do { ++ if (0 != SecU64Div32((SecUnsignedInt32)((number >> 16) >> 16), ++ (SecUnsignedInt32)number, ++ (SecUnsignedInt32)radix, "ientHigh, "ientLow, &digit)) { ++ noOutput = 1; ++ break; ++ } ++ *--formatBuf.str = digits[digit]; ++ ++ number = (SecUnsignedInt64)quotientHigh; ++ number = (number << 32) + quotientLow; ++ } while (number != 0); ++#else ++ switch (radix) { ++ /* the compiler will optimize div 10 */ ++ SECUREC_SPECIAL(number, 10); ++ break; ++ SECUREC_SPECIAL(number, 16); ++ break; ++ SECUREC_SPECIAL(number, 8); ++ break; ++ default: ++ break; ++ } ++#endif ++ } ++#endif ++ } /* END if (number > 0) */ ++ /* compute length of number,.if textLen > 0, then formatBuf.str must be in buffer.str */ ++ textLen = (int)((char *)&buffer.str[SECUREC_BUFFER_SIZE] - formatBuf.str); ++ if (formatAttr.precision > textLen) { ++ for (ii = 0; ii < formatAttr.precision - textLen; ++ii) { ++ *--formatBuf.str = '0'; ++ } ++ textLen = formatAttr.precision; ++ } ++ ++ /* Force a leading zero if FORCEOCTAL flag set */ ++ if ((formatAttr.flags & SECUREC_FLAG_FORCE_OCTAL) && (textLen == 0 || formatBuf.str[0] != '0')) { ++ *--formatBuf.str = '0'; ++ ++textLen; /* add a zero */ ++ } ++ } ++ break; ++ default: ++ break; ++ } ++ /*if it's a private arg, just write to stream*/ ++ if (isPrivacy == 1) { ++ SecWritePrivateStr(stream, &charsOut); ++ break; ++ } ++ ++ if (noOutput == 0) { ++ if (formatAttr.flags & SECUREC_FLAG_SIGNED) { ++ if (formatAttr.flags & SECUREC_FLAG_NEGATIVE) { ++ /* prefix is a '-' */ ++ prefix[0] = SECUREC_CHAR('-'); ++ prefixLen = 1; ++ } else if (formatAttr.flags & SECUREC_FLAG_SIGN) { ++ /* prefix is '+' */ ++ prefix[0] = SECUREC_CHAR('+'); ++ prefixLen = 1; ++ } else if (formatAttr.flags & SECUREC_FLAG_SIGN_SPACE) { ++ /* prefix is ' ' */ ++ prefix[0] = SECUREC_CHAR(' '); ++ prefixLen = 1; ++ } ++ } ++ ++#if defined(SECUREC_COMPATIBLE_LINUX_FORMAT) && (!defined(SECUREC_ON_UNIX)) ++ if ((formatAttr.flags & SECUREC_FLAG_POINTER) && (0 == textLen)) { ++ formatAttr.flags &= ~SECUREC_FLAG_LEADZERO; ++ formatBuf.str = &buffer.str[SECUREC_BUFFER_SIZE - 1]; ++ *formatBuf.str-- = '\0'; ++ *formatBuf.str-- = ')'; ++ *formatBuf.str-- = 'l'; ++ *formatBuf.str-- = 'i'; ++ *formatBuf.str-- = 'n'; ++ *formatBuf.str = '('; ++ textLen = 5; ++ } ++#endif ++ ++ /* calculate amount of padding */ ++ padding = (formatAttr.fldWidth - textLen) - prefixLen; ++ ++ /* put out the padding, prefix, and text, in the correct order */ ++ ++ if (!(formatAttr.flags & (SECUREC_FLAG_LEFT | SECUREC_FLAG_LEADZERO)) && padding > 0) { ++ /* pad on left with blanks */ ++ if (SECUREC_IS_REST_BUF_ENOUGH(padding)) { ++ /* char * cast to wchar * */ ++ SECUREC_SAFE_PADDING(SECUREC_CHAR(' '), padding, stream, &charsOut); ++ } else { ++ SECUREC_WRITE_MULTI_CHAR(SECUREC_CHAR(' '), padding, stream, &charsOut); ++ } ++ } ++ ++ /* write prefix */ ++ if (prefixLen > 0) { ++ SecChar *pPrefix = prefix; ++ if (SECUREC_IS_REST_BUF_ENOUGH(prefixLen)) { ++ /* max prefix len is 2, use loop copy */ /* char * cast to wchar * */ ++ SECUREC_SAFE_WRITE_PREFIX(pPrefix, prefixLen, stream, &charsOut); ++ } else { ++ SECUREC_WRITE_STRING(prefix, prefixLen, stream, &charsOut); ++ } ++ } ++ ++ if ((formatAttr.flags & SECUREC_FLAG_LEADZERO) && !(formatAttr.flags & SECUREC_FLAG_LEFT) ++ && padding > 0) { ++ /* write leading zeros */ ++ if (SECUREC_IS_REST_BUF_ENOUGH(padding)) { ++ /* char * cast to wchar * */ ++ SECUREC_SAFE_PADDING(SECUREC_CHAR('0'), padding, stream, &charsOut); ++ } else { ++ SECUREC_WRITE_MULTI_CHAR(SECUREC_CHAR('0'), padding, stream, &charsOut); ++ } ++ } ++ ++ /* write text */ ++#ifndef SECUREC_FOR_WCHAR ++ if (formatAttr.bufferIsWide && (textLen > 0)) { ++ wchar_t *p = formatBuf.wStr; ++ int count = textLen; ++ while (count--) { ++ char tmpBuf[SECUREC_MB_LEN + 1]; ++ SECUREC_MASK_MSVC_CRT_WARNING ++ int retVal = wctomb(tmpBuf, *p++); ++ SECUREC_END_MASK_MSVC_CRT_WARNING ++ if (retVal <= 0) { ++ charsOut = -1; ++ break; ++ } ++ SECUREC_WRITE_STRING(tmpBuf, retVal, stream, &charsOut); ++ } ++ } else { ++ if (SECUREC_IS_REST_BUF_ENOUGH(textLen)) { ++ SECUREC_SAFE_WRITE_STR(formatBuf.str, textLen, stream, &charsOut); ++ } else { ++ SECUREC_WRITE_STRING(formatBuf.str, textLen, stream, &charsOut); ++ } ++ } ++#else /* SECUREC_FOR_WCHAR */ ++ if (formatAttr.bufferIsWide == 0 && textLen > 0) { ++ int count = textLen; ++ char *p = formatBuf.str; ++ ++ while (count > 0) { ++ wchar_t wchar = L'\0'; ++ int retVal = mbtowc(&wchar, p, (size_t)MB_CUR_MAX); ++ if (retVal <= 0) { ++ charsOut = -1; ++ break; ++ } ++ SECUREC_WRITE_CHAR(wchar, stream, &charsOut); ++ p += retVal; ++ count -= retVal; ++ } ++ } else { ++ if (SECUREC_IS_REST_BUF_ENOUGH(textLen)) { ++ SECUREC_SAFE_WRITE_STR(formatBuf.wStr, textLen, stream, &charsOut); /* char * cast to wchar * */ ++ } else { ++ SECUREC_WRITE_STRING(formatBuf.wStr, textLen, stream, &charsOut); ++ } ++ } ++#endif /* SECUREC_FOR_WCHAR */ ++ ++ if (charsOut >= 0 && (formatAttr.flags & SECUREC_FLAG_LEFT) && padding > 0) { ++ /* pad on right with blanks */ ++ if (SECUREC_IS_REST_BUF_ENOUGH(padding)) { ++ /* char * cast to wchar * */ ++ SECUREC_SAFE_PADDING(SECUREC_CHAR(' '), padding, stream, &charsOut); ++ } else { ++ SECUREC_WRITE_MULTI_CHAR(SECUREC_CHAR(' '), padding, stream, &charsOut); ++ } ++ } ++ ++ /* we're done! */ ++ } ++ if (floatBuf != NULL) { ++ SECUREC_FREE(floatBuf); ++ floatBuf = NULL; ++ } ++ break; ++ case STAT_INVALID: ++ return -1; ++ default: ++ return -1; /* input format is wrong, directly return */ ++ } ++ } ++ ++ if (state != STAT_NORMAL && state != STAT_TYPE) { ++ return -1; ++ } ++ ++ return charsOut; /* the number of characters written */ ++} /* arglist must not be declare as const */ ++#endif /* OUTPUT_P_INL_2B263E9C_43D8_44BB_B17A_6D2033DECEE5 */ +diff --git a/hilog.gni b/hilog.gni +index 116b058..bdd9393 100644 +--- a/hilog.gni ++++ b/hilog.gni +@@ -12,9 +12,9 @@ + # limitations under the License. + + platforms = [ +- "ohos", +- "windows", +- "mac", ++ # "ohos", ++ # "windows", ++ # "mac", + "linux", + ] + +diff --git a/interfaces/bundle.json b/interfaces/bundle.json +index f6b5cdf..330ffcb 100644 +--- a/interfaces/bundle.json ++++ b/interfaces/bundle.json +@@ -39,10 +39,7 @@ + "base_group": [ + + ], +- "fwk_group": [ +- "//base/hiviewdfx/hilog/frameworks/hilog_ndk:hilog_ndk", +- "//base/hiviewdfx/hilog/interfaces/js:hilog_napi" +- ], ++ "fwk_group": [], + "service_group": [ + "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog_base", + "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog" +diff --git a/interfaces/native/innerkits/BUILD.gn b/interfaces/native/innerkits/BUILD.gn +index 3666081..ee27551 100644 +--- a/interfaces/native/innerkits/BUILD.gn ++++ b/interfaces/native/innerkits/BUILD.gn +@@ -19,40 +19,33 @@ config("libhilog_pub_config") { + include_dirs = [ "include" ] + } + +-template("libhilog") { +- forward_variables_from(invoker, "*") +- ohos_shared_library(target_name) { ++ohos_shared_library("libhilog") { + public_configs = [ ":libhilog_pub_config" ] +- +- deps = [ +- "//base/hiviewdfx/hilog/frameworks/libhilog:libhilog_source_$platform", ++ sources = [ ++ "//base/hiviewdfx/hilog/libhilog/hilog.cpp", ++ "//base/hiviewdfx/hilog/libhilog/vsnprintf/vsnprintf_s_p.cpp", ++ "//base/hiviewdfx/hilog/libhilog/utils/log_utils.cpp", ++ "//base/hiviewdfx/hilog/libhilog/utils/log_print.cpp", + ] + +- if (platform == "ohos") { +- output_extension = "so" +- } ++ include_dirs = [ ++ "//base/hiviewdfx/hilog/libhilog/include/", ++ "//base/hiviewdfx/hilog/libhilog/vsnprintf/include/", ++ "//base/hiviewdfx/hilog/libhilog/utils/include/", ++ ] + ++ defines = [] ++ cflags_cc = [ "-std=c++17", "-fpermissive" ] ++ defines += [ "__LINUX__" ] ++ deps = [ ++ "//third_party/bounds_checking_function:libsec_shared" ++ ] + install_enable = !hilog_native_feature_ohcore + install_images = [ + "system", +- "updater", + ] + part_name = "hilog_native" + subsystem_name = "hiviewdfx" +- } +-} +- +-foreach(item, platforms) { +- if (item == "ohos") { +- libhilog("libhilog") { +- platform = item +- } +- } +- if (item == "windows" || item == "mac" || item == "linux") { +- libhilog("libhilog_" + item) { +- platform = item +- } +- } + } + + config("libhilog_base_pub_cfg") { +diff --git a/interfaces/native/innerkits/include/hilog/log_c.h b/interfaces/native/innerkits/include/hilog/log_c.h +index 2649f33..08aa937 100644 +--- a/interfaces/native/innerkits/include/hilog/log_c.h ++++ b/interfaces/native/innerkits/include/hilog/log_c.h +@@ -57,8 +57,8 @@ typedef enum { + + const char* GetLastFatalMessage(void); + +-int HiLogPrint(LogType type, LogLevel level, unsigned int domain, const char *tag, const char *fmt, ...) +- __attribute__((__format__(os_log, 5, 6))); ++int HiLogPrint(LogType type, LogLevel level, unsigned int domain, const char *tag, const char *fmt, ...); ++ // __attribute__((__format__(os_log, 5, 6))); + + #define HILOG_DEBUG(type, ...) ((void)HiLogPrint((type), LOG_DEBUG, LOG_DOMAIN, LOG_TAG, __VA_ARGS__)) + +diff --git a/interfaces/native/innerkits/include/hilog/log_cpp.h b/interfaces/native/innerkits/include/hilog/log_cpp.h +index ff48162..bc6077e 100644 +--- a/interfaces/native/innerkits/include/hilog/log_cpp.h ++++ b/interfaces/native/innerkits/include/hilog/log_cpp.h +@@ -21,7 +21,7 @@ + #ifdef __cplusplus + namespace OHOS { + namespace HiviewDFX { +-using HiLogLabel = struct { ++struct HiLogLabel { + LogType type; + unsigned int domain; + const char *tag; +@@ -29,11 +29,16 @@ using HiLogLabel = struct { + + class HiLog final { + public: +- static int Debug(const HiLogLabel &label, const char *fmt, ...) __attribute__((__format__(os_log, 2, 3))); +- static int Info(const HiLogLabel &label, const char *fmt, ...) __attribute__((__format__(os_log, 2, 3))); +- static int Warn(const HiLogLabel &label, const char *fmt, ...) __attribute__((__format__(os_log, 2, 3))); +- static int Error(const HiLogLabel &label, const char *fmt, ...) __attribute__((__format__(os_log, 2, 3))); +- static int Fatal(const HiLogLabel &label, const char *fmt, ...) __attribute__((__format__(os_log, 2, 3))); ++ static int Debug(const HiLogLabel &label, const char *fmt, ...); ++ // __attribute__((__format__(os_log, 2, 3))); ++ static int Info(const HiLogLabel &label, const char *fmt, ...); ++ // __attribute__((__format__(os_log, 2, 3))); ++ static int Warn(const HiLogLabel &label, const char *fmt, ...); ++ // __attribute__((__format__(os_log, 2, 3))); ++ static int Error(const HiLogLabel &label, const char *fmt, ...); ++ // __attribute__((__format__(os_log, 2, 3))); ++ static int Fatal(const HiLogLabel &label, const char *fmt, ...); ++ // __attribute__((__format__(os_log, 2, 3))); + }; + } // namespace HiviewDFX + } // namespace OHOS +-- +2.33.0 + diff --git a/0002-fix-build-gn-files-config.patch b/0002-fix-build-gn-files-config.patch new file mode 100644 index 0000000..502ed43 --- /dev/null +++ b/0002-fix-build-gn-files-config.patch @@ -0,0 +1,67 @@ +From d0d35591b378d879f1659f4bfd082b165b31e8f1 Mon Sep 17 00:00:00 2001 +From: tian2020 +Date: Wed, 14 Jun 2023 19:55:41 +0800 +Subject: [PATCH 2/3] fix build gn files config + +--- + interfaces/native/innerkits/BUILD.gn | 34 +++++++++++++++++++++------- + 1 file changed, 26 insertions(+), 8 deletions(-) + +diff --git a/interfaces/native/innerkits/BUILD.gn b/interfaces/native/innerkits/BUILD.gn +index ee27551..c74beda 100644 +--- a/interfaces/native/innerkits/BUILD.gn ++++ b/interfaces/native/innerkits/BUILD.gn +@@ -22,16 +22,16 @@ config("libhilog_pub_config") { + ohos_shared_library("libhilog") { + public_configs = [ ":libhilog_pub_config" ] + sources = [ +- "//base/hiviewdfx/hilog/libhilog/hilog.cpp", +- "//base/hiviewdfx/hilog/libhilog/vsnprintf/vsnprintf_s_p.cpp", +- "//base/hiviewdfx/hilog/libhilog/utils/log_utils.cpp", +- "//base/hiviewdfx/hilog/libhilog/utils/log_print.cpp", ++ "//base/hiviewdfx/hilog/frameworks/libhilog/hilog.cpp", ++ "//base/hiviewdfx/hilog/frameworks/libhilog/vsnprintf/vsnprintf_s_p.cpp", ++ "//base/hiviewdfx/hilog/frameworks/libhilog/utils/log_utils.cpp", ++ "//base/hiviewdfx/hilog/frameworks/libhilog/utils/log_print.cpp", + ] + + include_dirs = [ +- "//base/hiviewdfx/hilog/libhilog/include/", +- "//base/hiviewdfx/hilog/libhilog/vsnprintf/include/", +- "//base/hiviewdfx/hilog/libhilog/utils/include/", ++ "//base/hiviewdfx/hilog/frameworks/libhilog/include/", ++ "//base/hiviewdfx/hilog/frameworks/libhilog/vsnprintf/include/", ++ "//base/hiviewdfx/hilog/frameworks/libhilog/utils/include/", + ] + + defines = [] +@@ -56,7 +56,25 @@ config("libhilog_base_pub_cfg") { + ohos_static_library("libhilog_base") { + public_configs = [ ":libhilog_base_pub_cfg" ] + +- deps = [ "//base/hiviewdfx/hilog/frameworks/libhilog:libhilog_base_source" ] ++ #deps = [ "//base/hiviewdfx/hilog/frameworks/libhilog:libhilog_base_source" ] ++ ++ include_dirs = [ ++ "//base/hiviewdfx/hilog/frameworks/libhilog/vsnprintf/include", ++ "//base/hiviewdfx/hilog/interfaces/native/innerkits/include", ++ ] ++ ++ # vsnprintf_sources = [ "$vsnprintf_root/vsnprintf_s_p.cpp" ] ++ ++ sources = [ "//base/hiviewdfx/hilog/frameworks/libhilog/base/hilog_base.cpp" ] ++ # sources += vsnprintf_sources ++ ++ public_configs += [ "//base/hiviewdfx/hilog/frameworks/libhilog/:libhilog_base_config" ] ++ configs = [ "//base/hiviewdfx/hilog/frameworks/libhilog/:libhilog_base_config" ] ++ ++ defines = [ ++ "__RECV_MSG_WITH_UCRED_", ++ "HILOG_PROHIBIT_ALLOCATION", ++ ] + + subsystem_name = "hiviewdfx" + part_name = "hilog_native" +-- +2.33.0 + diff --git a/0003-feat-set-priv-false.patch b/0003-feat-set-priv-false.patch new file mode 100644 index 0000000..054c976 --- /dev/null +++ b/0003-feat-set-priv-false.patch @@ -0,0 +1,30 @@ +From bcefda18f27ea4c427ad11ac1ae373e503787fca Mon Sep 17 00:00:00 2001 +From: tian2020 +Date: Thu, 15 Jun 2023 10:52:07 +0800 +Subject: [PATCH 3/3] feat set priv false + +--- + frameworks/libhilog/hilog_printf.cpp | 7 +------ + 1 file changed, 1 insertion(+), 6 deletions(-) + +diff --git a/frameworks/libhilog/hilog_printf.cpp b/frameworks/libhilog/hilog_printf.cpp +index 1316128..ccfef1d 100644 +--- a/frameworks/libhilog/hilog_printf.cpp ++++ b/frameworks/libhilog/hilog_printf.cpp +@@ -219,12 +219,7 @@ int HiLogPrintArgs(const LogType type, const LogLevel level, const unsigned int + } + + /* format log string */ +-#if not (defined( __WINDOWS__ ) || defined( __MAC__ ) || defined( __LINUX__ )) +- bool debug = IsDebugOn(); +- bool priv = (!debug) && IsPrivateSwitchOn(); +-#else +- bool priv = true; +-#endif ++ bool priv = false; + + #ifdef __clang__ + /* code specific to clang compiler */ +-- +2.33.0 + diff --git a/hilog.spec b/hilog.spec new file mode 100644 index 0000000..05eea0e --- /dev/null +++ b/hilog.spec @@ -0,0 +1,85 @@ +%define debug_package %{nil} +%global openHarmony_source_release OpenHarmony-v3.2-Release +%global hilog_dir %{_builddir}/base/hiviewdfx +%global build_opt /opt/distributed-middleware-build + +Name: hilog +Version: 1.0.0 +Release: 1 +Summary: OpenEuler supports hilog for distributed softbus capability +License: Apache License 2.0 +Url: https://gitee.com/openharmony/hiviewdfx_hilog +Source0: https://gitee.com/openharmony/hiviewdfx_hilog/repository/archive/%{openHarmony_source_release}.tar.gz #/hiviewdfx_hilog-%{openHarmony_source_release}.tar.gz +Patch0000: 0001-init-and-adapt-to-openeuler.patch +Patch0001: 0002-fix-build-gn-files-config.patch +Patch0002: 0003-feat-set-priv-false.patch + +BuildRequires: distributed-build, libboundscheck,libatomic +Requires: libboundscheck, libatomic + +%description +OpenEuler supports hilog for distributed softbus capability + +%prep +#clean %{_builddir} +rm -rf %{_builddir}/* +%autosetup -p1 -n hiviewdfx_hilog-%{openHarmony_source_release} + +cd %{_builddir} +mkdir -p %{hilog_dir} +mv hiviewdfx_hilog-%{openHarmony_source_release} %{hilog_dir}/hilog + +# build directory +cp -rp %{build_opt} %{_builddir}/build +[ ! -L "%{_builddir}/build.sh" ] && ln -s %{_builddir}/build/build_scripts/build.sh %{_builddir}/build.sh +[ ! -L "%{_builddir}/.gn" ] && ln -s %{_builddir}/build/core/gn/dotfile.gn %{_builddir}/.gn +[ ! -L "%{_builddir}/build.py" ] && ln -s %{_builddir}/build/lite/build.py %{_builddir}/build.py +cp -r %{_builddir}/build/openeuler/vendor %{_builddir}/ +cp -r %{_builddir}/build/openeuler/compiler_gn/third_party %{_builddir}/ + +#directory to avoid %build fail +mkdir hiviewdfx_hilog-%{openHarmony_source_release} + +%build +cd %{_builddir} +rm -rf %{_builddir}/out + +%ifarch x86_64 +./build.sh --product-name openeuler --target-cpu x86_64 +%endif + +%ifarch aarch64 +./build.sh --product-name openeuler --target-cpu arm64 +%endif + +%install +install -d %{buildroot}/%{_includedir}/hilog +install -d %{buildroot}/%{_includedir}/hilog/hilog +install -d %{buildroot}/%{_includedir}/hilog/hilog_base +install -d %{buildroot}/%{_libdir} + +# prepare so +install -m 0755 %{_builddir}/out/openeuler/packages/phone/system/lib64/libhilog*.so %{buildroot}/%{_libdir} + +%ifarch x86_64 +install -m 0755 %{_builddir}/out/openeuler/linux_clang_x86_64/obj/base/hiviewdfx/hilog/interfaces/native/innerkits/libhilog_base.a %{buildroot}/%{_libdir} +%endif + +%ifarch aarch64 +install -m 0755 %{_builddir}/out/openeuler/linux_clang_arm64/obj/base/hiviewdfx/hilog/interfaces/native/innerkits/libhilog_base.a %{buildroot}/%{_libdir} +%endif + +# prepare head files according to bundle.json +install -m 554 %{hilog_dir}/hilog/interfaces/native/innerkits/include/*.h %{buildroot}/%{_includedir}/hilog +install -m 554 %{hilog_dir}/hilog/interfaces/native/innerkits/include/hilog/*.h %{buildroot}/%{_includedir}/hilog/hilog +install -m 554 %{hilog_dir}/hilog/interfaces/native/innerkits/include/hilog_base/*.h %{buildroot}/%{_includedir}/hilog/hilog_base + +%files +%{_includedir}/hilog/* +%{_libdir}/*.so +%{_libdir}/*.a + +%changelog +* Thu Jun 15 2023 tianhang - 1.0.0-1 +- Init and adapt to openeuler + diff --git a/hiviewdfx_hilog-OpenHarmony-v3.2-Release.tar.gz b/hiviewdfx_hilog-OpenHarmony-v3.2-Release.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b63046f3dee2c4f1e5b8148a3bb35b77061fc2fc GIT binary patch literal 210043 zcmV(%K;pk2iwFP!000001MK|;SX@u@C?%FhFn{e6V4M_s#Er@9y2*yL>tM;I=4fHBVB&1&VDH7|&cn{l_TIwQ!o);qf9PTL zf0X~9tS#M~EnNOvQ~ZD{X}tn`56te+0!U z`ZjN0q$ujHfTgY2xL@%;$xvxWp+pJts8sTLW~g$1x1_a%-T+eopBnLBpTH@Crp%5I zR%*0(gnxYka>2EDe}79NA~Qo#K5$1VAkj-ceF%LU5dS{O9DslV3V8boPcZ;l;pr1J z#xMD|7z*xpFp2svR@%RnszVl@EBw3IcLXHDd!*NCvh;u9Zv_EMN4A`+ftPGpXIcU# z>?wcVoc$# z>xWXw)S^N$GVGh=-V^Q0Z!}r>4h}=EJeLYy>G!G}9(jg)%75uZ7086zL0r2iD0bZH zlc#48Lwa%DN<8|ze;v)Ajq-VA*>kPh1Ib|pa$>&>=tE&2rFD;KimKdJj4b%oGt;nz6qOp_T)q1vw;28Y*i_j|Z(gWoR&rX7yEm`Cj%} zr!RZAKhK84Z9Qy~U(SQSH~!?kb{u^e9jZa9g7@eKz+1-2u({{LQ}r*RTu5qozGiiy z?6X{DhQl#K6det*nyI6vTK1PJXt4NHq^`uedho!8hS!1jGY^+m0~G@^J1JZCwK0b> zZZZKPkFv7GawQQ;a=*V~fPh?s>c9A#vR2Ds+q+!FpcutjYn=0gxEeHbi;7@Z!NM%T zfcq#dC=Mk;H)0_6MX0x7GaW-d!C!&8KxHNI<@*tPv%AaOg3ZJ1tkThTbK2s5zDQ7! z#Rf%0mpEFArtuSdTon~^)Yc$mH%jt;ZSqqi4;d)c9Bc|n{L9Ha;Oade(SjrJwYan(|8e4_PG%kpPq|U2hhu+{E>V+{Mnoy0I^29l>@V#Sa_WL!5=(H zkiMgK6x4O#Mbyp3h6w9@>5M{{Ze4hvAG=YD8K>c~RrzGXUsy;;EXV-#@?LvmQgYLB z0VCy^Wp@(!+Ot(7O#nuCtQ;L=^eYvkbe6b(cr0t21zyrwBI%XM=D;zE&F8@b-i-8t$?Uv5IKJ=ooq)zam4NAR zG$yZv8P>^y2bG*5law!=tgZ&vW;%EkmJ5P$fv2%P7nSRY8~Z7GJX>6UDf|P~9QXdi z^nklZ5Jx`N06UJ0+P`E$ogWe1KM(c_ipJ^6_^%N1x8aElg9YB&w9c8 z?71fw?_X#XUlC9q<7fJnzx`YBbc({YgjXAB`d`{%D+UAs2S1w?{%yB06}&!CLrj&w z@)=Gq*(G6K&o%Y$zx14O2q-`*jE=$P>FCB(bs-GU|T!oYC z+E6;}OulOj`Rl~L>Ui@+LR}}9T9vL7g3S;3MH7(LabV`{{-f%yGZnl&=hIupip)?y zQS(X5_bnJpGJ9;`<*g!cPOE?G;zCQ-^$K=;ZGzbo>N|!ZTO#n%u!0UCu{= z(T}m9wMr#%6=~GKA05_w(8xmRU{3kvI6zsLP}B;oN~P*mW*VIG!}X=V`^nRSCaAtD z<|yv5+Y%Hs2Dqf;1Obn4kKPWDe+Xe+N?$5Qe3gUy2a~`8-_7vHfMY24ocs5 z=9+O6+#%mF)x5Z~B`E#U8>RRiEDghdc9{4^1hC zDb?7_(3d9Muki=f0)ldK_Snsqi<-npX2jE&*E@_>Cb$%`NeYhN1egze$%TDMVMWxV!IMlZ; z@CwLyWVhuWVZsg%m-n~(#ah0X0?x(z%5%o#TMoY|vQ%mPF~~^fKPK)CMFM1#o9QAZ z+dTML+{2`6!J|0AeZg*1d*eYlUm8oAtWFZJQmqp@m5~OB?^7XNd1-aOy%>urk>#0+ zN^CR?f-){c+Kx1q8O?orsPD}4kU`GL&<8U2E2%)WOtTr$vXj`&mF3=z6MqTzk^PeH z?k_2^@=Vavs_Tpc&L&mGlwA|-s|7~v;JBA7LV@RK;sJU}o*m4`Efu<@B^~tw%g4_} z+2-03E`^T1MWTMTyMJ>rD@M3C-K?`7={^}9Uk^⁢#j>tf+3FQz!Jr3LT)Y0wC>> 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
    T;+d=aY0!4XQc> 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¨K9r}#%Ntp*XB73quT|?xecy3M7;7Pe+VXNS9_EqkQMKQO3(42((4W= zYN-G8s>|1c(Bx$%og$+_sOw|T>65NysXv>3YWH}(0gEINB|N8wj~#iu{}9 z$0nG?ir+deb=7u(pXJtiZ`y<{_EW$LZ!5H&yR|@CNtfFGb*_Z6tGpd+Lwm-?FON}j9Dw4d|H zSiPI`pz{#M_|frBmubYvV|Rk}`Y0Z{WK0rHBAWB#%YG5vy&EmZCN`Z0YB%!OFF}4W zDS0095j^d*XF1O>zbxFm0Q`J-;~KxM!7Dzo(78I3kOI)q6n!e?oha~I4o~BpEWFd9 zV3b;suQesnFLREyBm0D&uWn%T-7fhxE>vS-RA~fJ<$Pw@i7CvxOSNJ$g4)O>xpHc^ z_~y^tQ%WHX7RckXZM1VrEHV#NHmW8aVuVo5enBMl3Dyp`j23jh7aCEXzQ6ft*6))2o0zLJXg3T)^@2JPiqc!T{b*vRp;gu|-7$yrj>D9Y8c_w_=v8|eujd)wPkNajM!4b zr{fy!rK36f3-~uX4o-l_>4E2dB7le|D0Cd`9b-$$ONy$W0%UJ?v!BH*Ws}h0+1#dD zb$6zQU85x+W0~r{`tmxluZE0(MO{8YHxTHlNeo4JM)!zl_wyU3na>8Nj18mxN}OO# z@d{%sczl$5@ZM^mY6Yh_kW*QA%1E;B@SDVvM%&m<^jwxokd?8$#n@RAAJko#4B<i9`-m|IC3H&O5 z;eyOU^5lC0*Ntup6F)R}+_9+AMz6v56Rg>HoIf_)PSh+fX!PruM9?M_-%1gZ5}{=| zte$w=r9PhciSFqHEw5j$rSw}vOWQIywUvDBWCRGTPCCjg58_uY85GJCmNgL>EW{73 zzqq`>S#w`$ZRvDxQupuz0bYVX(*lLoHDX`Ums}=ZZ>YP-3CDvXC^zBdEd0LYZ(8bD zZF#~+EwyWlRKOUJhrro;S<+#>q|wr{F38v7^kpydu_p{NA_>JYWS?)?$#B1sT%J2d zyxKaCDCHP_d7c_0gO6-hio6|7v&kVs<8zqTTvG%s)TifDaewCgDZj*)^p5q@>)lXM zftMF2b5#5}NbWh}Q*wO_U?Y+-Ev}NW%|Adieei;v+rd?q&R=eSk`R3TDxJ|W6dss| zFJrsZAaRY_tum3t4}BaX@yHzG+%tAqXeB{s4?hh+)S9#JvWfLuKZ3JywY3AC(I?{G z$%|SpztSnEvaU!#bozf5GStiGG|xDNHi>Jr=?E!hr(Am<`#v&wN(RQkI3M43gJ(Lv ziX@Fr-mE6y-|nU76kVR!RaNXqm_LWoXOqy2?G5LF6R9Y6wcMU@-MbSMfCOZSoGgpOw!u~hh`$uB=c(PpMs5gPgQnTPq$hICKQ zc@5#gx&s~=zHl>S^{FNSqCOSZ04FnzDzdTj;1N1bJu^<9_M_D4&+_O@F!m#|`@m0I zh>j1)yT36#>zA9K`?IABxl`Wo9MXPpZ!Vd1QLy=4uGfTdI#d3(5#cA^h3$VO9Kagp zu=jN%3-!L%OYOp>)hOY$WHo&8d=H5!DFS5>+xNhX-=Kx*ZC~d%1)@E zd|e5+p{)w{tbDT)S$8W8wlT{k>@0qV% zxOm^s;-ZEd{%2RxS5yZ`DSHjx)iSd4uk9Q5I0CAm7yh-4If4oHQsD|Jn|7fR351N! zVzAh)D(8{QiyvnU&ptgyt;zZh-;%3pd8NKudq4Q~BxOJ0&wkY_?&5O86#;FNLUq2U zTB1L9W!rXH>kL!iQQ$8WQ8}-@Al$$5vUQZ&=hKTxi?!5EW*PVQ?A*c+IP_jO$X(Mk zqWvsHNy#cR9Kfk7L*R4!9+|F>=SM!h%D!8N*UUJNrrm!3(;nxS=BZlbFcv2v4k8-8 zpHH|?b#3aXNF_WSmJv{HdpY!GC8SE3-RzKPZY~KBM&IAZRpV}S$4tno@G1A?jLbrj zm_uRbrXO+^k3URhU%6ke(B>ck;&WKYQfYq#-;mz<>&zKH4?8M-*4Yy{!T7nq_uzA2 znxcAqUria`g|DShgIMRItdG{mfZIPAoO?G$U0W;0(@fOo{t4*C8N`unROpch`q}3{ zBUe8OR6{8$gPRT$S(9?t-FAFg(bmh>T2`zQTH@Y1qjNezxUAjN+>4bH*?6nxzKRYD z7iZ1Wy+>vFrL&1yyV0zfS4E5uCP@p+JukIJYa8q59`l`1JUk(9Z|u2Y5cr(Pd;Jze zPR-*AVsF2jc(hc`wQ?Hy?Y#@HP?a(T?%ra1bx%|~GxL}PO0rvCJTk9dHmo(u;q1xL z@HE-9Bd<(E`ut>-?)@-eD$P@NG>L{cA{G)FjMo#1&pDP06fPhTr{kQ%RZgsG)}l@}IF(dwoHl?|r8?e<(I6l{L3xr}?{$XxCjq^LE{&u8#0Q%b zDtg!Y$3Fi89x%W@_l|KfrE_Gz*TP+zQTCCpzF7OKEV#5r@L>r;`LDu{bxV@Q7zHs26*RFsR_j6op{C-wS1Is3fxSB}hwpb@v4O3squ5-yZ|Pc1c* z@uAJf;Qhf-K?%!`C>JNDH2Hb6iv?9j;39Oo%r_3`bybGmXR~Vg9O&iCA3JuLohg3f zK?CdILiGv>Fo&}a#8CRxSKx$&k5&)5a!_9@c&g{hUL?yuK_&N$Ur^zcPa{cg*yGNk zJ*n-mWYh=wBkPA$HMp)lOk?(w=tU)#>vziCeNr~(&%Of^o`xhW)h{g1a$a~6BNTe< z&GSQP&GV&~!n?IK}e%PFH2C6QFjoYKZdLdh7Cr5WZltwy#X zuo%ZG5)~pWGbwl44X}2m(KDVEu^BHA3&4Mh$trzD#`4=D29sV zod>;i4=vgj=DVL`*N*4Q)!JmKUb85RD46V)*a0Nm1_07QEjE3uoi$*wMv)CUPr>;| zFeM3_oZ1u|&6JoKhTLTY2iokuV-FSM5O_rpM%37LRyz;;szURf@%2VpJLsX)gkawW z;z~O{)`CY9VDCx;&nb{jo|*L#P9ONx(_QBD1XJ8$JRRB=X@mA28Mqm%`(&(%Y0+$< zlBY!@_vdM^n7rU=iV}8r5)aU6EY$9erf#1A3`8YysW6yD@mOuO5qm3a+k6b|ccbBE z;v191`IEza7C#4L#~1|**{YWvNV{vtsEDp>XN zQjxhi7ix#!!bgAtL$j*VHN7-3Mq|CV%G1p3Xk*e4E?(~F697tgIwa^q`lf72pFMZCm zV8kg-EsSHoMe|)}+sCBy_4v?e@a)#1bi3EYrCOP4s(o;UBZNl@WyV_MKG-usPVp|*(~w?(-S^>Sz7};rprzhDvBx&dn&0vu%gTuPv5)f`uy{|vneHj zYLdJhW=;?`6EF-;8ML`i_|__u3zqYOLR5L_n)u!GS@UKX0?qFC)}sCUp}KC3j>G%- z^A);@?8J`{9UT;|dhsZ^;-EE=9bPtRQ%&vp%Y`~8`K%M{JACI$nTc2zDB`k!ST7af&e(zC$briS$KDNLF-F2+?1RZX517<7=l6o^$n_kJFVp?pVYWMaOFf zD!GSq#@!RGosU>{cfsY&WmI>1#~bNg_u}Xc&4# zj=~qwl|!gO&=`C!E>xVzz`XOq`J)u`ZZH#kXIgW%zFVmSyuYlv#A+%Xi3JA(7?_cF zop11A3tjjdGf07H8S8-l&?PcYN4u(uR{^DdBnHdZIbp;I=@g3(40Rl&){t* zljryokA^{s6njozynV=F)s?q)!jA8)#550f>xIJi(zdOH>n+j1tVvfMw;c7`Bi}~4 zVndtBDW69oBy;ZNtoZr0M+nZy$@)CPc}oUrG<#eC|FT}}Gc_SIA`v`^1ClbfKT~8G zodPajVyfW20LdMNjCJV_vH=KDi5Ajm|(t1&I8vV*#{&sJU(2s zemXZRq!$(Egm4LQ3QT<0lhR}4-9m3CvB}J>q&`j5*ra1az0RBiTnYW~VG>JPz8gur z==R&=gcgL7QXaO8;F5w7{#GuZ^QhWmURNy-Tjagn#VYl1YhjU>5dMPo`<6k&^ZCA&h?6Gs2tR3Jb6^X7K!(K}3yf%dF%B5N_ka7|M z2V%JR)`G^PmM1D3ud~LwR?E2FQ_U?bE=j*WW%KcN&3*mBhA5%pkL_c<3kd2Ep4W)4 z+i~AoAf1Ry+JDx*I@0cwQa9{^^E=A+{nQTT6>VS&hmf)-F0{PiSy|lX6Km(DsF~D} z(j0A2jd?t`)=4f7MR2RXxiPpH#)2E)JN1CrBIDm(uPz&4N zq|@J|!3rUa0wZzY^voWaW$?@=`}ZdoA3p`})liRzY0Gg``t2hi^F4=MRQ4B@lquLI zQo`#fYK2!$m7HJ&{ALln&z{zIRK`s_R>r{;ywBcoz@+8ug;jDOI`cBXu3gaqRDoB8 zc4a25$JWFi-hV66Qb{~Tj-Yd?9X#aJ-h7#R!$ypDOE=s};$Oexs)22|GIyyY=?ps= zHi~%qjbI|G;ZgN~aE3Exr7*&AvH6nMhRl}!5S*6serg!_YL=3JwZb{H zfrBTbDu8;@&%!{1lj5VSi5>}(wtX=5J!VXVlJYbW`9e~!wF(sVbM|=O`nWNrPH23GS9;F6$9lpr~ zF#5sE6y~~88aq681a52rC@<>=E|TqHt+b3S^8Oc!zJ0wfVGYp3D+^M2yDNoKotLql zy!X9k!*^9mt4`V5gq^#kTVZ%$VZ8l`O2XOFW%%dzO!w+!5{WmAldPbO>YGRt99HH= zUO8Pn(O>D8e2AQK-s&W+0MFDk@glYTXHM$Mh5Kh-_8*v*2EhB<`t=KKX;cBDR&wrXU*xl5N}M! z0Y6NBj*#g{Zn0+@sn2nYRgc}WNw$MKNyXs8h1P1u$O9 zLhz9fPgG8wsQTO%uaY3_-K6X}ReYtOkk}cPhf{@m#lz3uG^mPL#Z}r=GKT4)?qww~f>DiiJ0Dx$M_xz_HlrwJ5Cs3ZXkMG=u zh?^qu6V|Yk?6>8E_NeGUl^)5jCgn4;^7RRugc%j{&VI9ZE)n!$=KJ$ zi1j8_}aUuH-&_kJ4Q~S5z;dbC5ck8v`+a*p(^w+T23$R&j8tV%)LC z&idnLBJhN~iFfW1>zuxyq$#ZmS&PmdLA~@3`8?yvKR&Ze8#A!j4kcPzLs4lFw^eYa zJsdlRMf%oSMj*8XT(^%9bu1LCY}H61XVV&fbpw*6bixhR+b6Qnt|uyQ8u;+=Dlk>d zuI6OSrMj;@dZ;+F8k}ncC}w=fjq`e5&CP3Rou0mCgySvbX17|RPjWq9J(3nNmUNPl zxCTQt%U1vN(i zBZabwr{ksX*8xw>vLH@=ginAp@O(^uiub$#LJSKGa*v1 zb*B3wvu&u_1D=~*KHYBfej~kze5Bthc-t~~#dliSqQGLEhgnd9#5+Uq01WV08_6SJ zq&u-OUt%&|Y4iB~alN46A=%ozO8CLNOG zkttb`8C#COidV|Jo~6!q3mXyo!^gT8qHccrY)$dnro1_|XNuCXlV0o%=h#LUVe}*S zP{hf(+8%I4k)P7~)N1g<{WB8L;PnpHAMhf&fmm${F4I%Z-}aLCmf3Z2(Iswi^3ydw z0S825XMC~4W=>m9V1uIJNTFPQ}TY{a$9n{{MGbb|-PDMsbK#@;njOgC1% zhyCt;d|fq}{CUnsIsTCN8``QI?Z#$FgiN)H=S>Qak5CsFW(-k_?@Siaha_4~_yU$f!CWi&O#!DvmY$%=W z1ee?<8>d@JtxGg>3?%6iN#dVim()V$$Ddkic3YO&wpu%fP0dzy)$MO99NM3&?td3? zd(VY2M%Ik+g;xfNqAS5IEA_uP%{?Y7*&`WV{-ldwLRKh?@iP0hliqgCsrDc40w!hL zrwd$5T5w#C=(@9y;B0BmaWSW2dyL6p^aW?wgVpLtduG6l$77Q##qas??`;@V$Sk@R zFt5M3ocr12hOuGXvB2w6!*X4Syk9ihjt^JIO6S}eA}=h>_}RFKwYToRB7q>a_VvSx zX042ytKMz-t`{bCqCTA4Tm$U?Xf^m*Ko>)qttHsSi`XtQ&ij$gMUbUUvyLV~v)<)p zv^2AYyNUk_pkFE^zXRalv%tn#W_LEUQ%%M@&T2-VEm(6xl(D$j-s|JZ`^qK z;&P&izFMf0o4E7EWRIiV8BGee_gSpKj2E3e%TDo8=_O~SbI=mvxp$_r`JKQ_Zq{7M zYZF~1rhKPY>3f{7#+Z}X&y2J%n}XY*j^ftZqR#xyUJW)k#>3csCrK;04)q4eSm%vr z7uMEB>#}rOM@|^mS7zLNf6suAxUhiZyz(3ai_z=UB6oVswFLA26_J@EzU^4^5V zG}crW9sT*tAc0{@-kP$7{!KK}rt0lgnfdbl)R7-}E6$j*2E5|>I2&1AoqU1d^o;k` z-jLk!_K`uc{FhPoBlQ!cLrN$hlzA5Nuxx>PBAI;iB{i*lt8f-9f?D2gFsHUFB;Ed9 zw|Vc0#jZ*RrO69p=TtxD{LC7WoswLZf6=v!{@s1GN;-})xvbQ|dcrw}-s`GelbfGT z_r&IkM=P5Q9>c#4UUa97*}S{1Gt{Cf7JKZjJL6GoB2CiK-l^YU@ohR3}r$d zo^{40$v(r>PiTBOV@>3;NIai%Q$AKn=vs2_jh@(e(yS|L_96Rj`s{jbDqSSvEVv)% z?Rqi6-m900*-Va*c)fJ_IT}TbpuZM#ed9pPxLwOr8-f_Id z`PqJ73-9x(Bfvi-&AirPV`?emI?R-=qZ*tKT=qmJi8RHy-jE(^8m<4S&md0oN`i-N zmW;p}y2sUN8bXFAA(p{G!ushG3(My!yz|CXVuREh_1X^o>CAC%B+|5`30huGF1Tgl z)hLn0lTMr;e7HBFOkWbT#?r9}TfH+Z8y{RVxQ;OrwHY4i2H1icJj9QzF7#Jwd-DrA zHTNF39DcIRp|^+X6dIa0>R-MKcevP^a4ezgBk_l!&3Qv`cYhO=-GFDesPohXrz!fv zJFKYtn*p58<2^zf`zNwUokxSk)+M%Q!T5b@sU08v*I$;YAAg^%m8w9#Ft?w#FWAEE*t(+VCPNTO z#n1f_BPT{SB=|$YgH7?|I;zfzi%$1@I>cDTA}2+;`LlV3{Y(2_vo>Ff1RTiuW|rBZ zMr%@f`6r)=#Ic?vJpGo2UkJYOc-dyt6(=o9JmM-pN`9>vA=@;T4rHrG;t)^L;iKuT z=kT|^SSbRIh)cA1f|3VU!x@ebyoqMFFAy5^WeQTR@Ekc_48eK=)z``gvbE*b0S?!w^A-PIo{1YST7+bz&dEG+y;c?Du9de_GjnW0QDu& zC<@5@8J^1iu%o)=O;sP+@g5@WZ@O_JENbAy1pzv_ul+VV^bno?gAqm7-?>-ZF7!Sg zc>rNjZXjk_UFniIA6j1Q7AESrlHqKmMGBr54)_%**L6Twc^w-%dMquS&adyC`3bza zY>3uZ;eH7IG|9^k0@ZlauTV!l%q|WqwO2o6SasB>oR&-piqs?P?Nd1w8Q@4cTvvKu z4bkl)@Fwj3rh+C#B^*yUnPM;B z6|S^Sy#5d%i-SO!*|Fxmqx6BdvY^7z*AdtCiAC`9^Bdh~Iuce6o_;@iN^3*Df*<%GcynRfLLTo_-N#52nNQwJJ9<#Z6vsP}EzA&MMtCN$t*A z(M3g?FPy&p(VxhmK~_h=|C2mLTEx16pT!NawF8eM?piK#HrJ$5HhoxMx-m=rns6?K zmo;fS0*se5?aXY^wrlwrn}dvrp0dr`r0g9GY2laL%kOm3e)9Ok?y^nO($4IH9BI^Z zmtaI9XZF_mDRXE8$*U81MaM#u)*>rXkI$#xz)xZ%cR1M^E>1_3To!&*<-l7eF56c| zVUBMVuJnc*f(|O&T6kQuYy?jcI;EKYuH!(eqO@Vg6iKBm|2-8Q(czyhUuxI0=Mb-9 z%45^rcSWkKRD@<~&HCOBYQ3*XsvwP|6w)DLZ|!{6swSvD-}EV9+>aJ9eh(@8G&0V+ z`hap*?3;HwS|cy#<`kW_3Lj!*f{-rt&TZGYma}alIo(uz)_QSjOTU!d?xC;iX&Lo| zxC&85wP@|6a$At|e&WF_R~uvH3S&49%-#-)5ae2V9+IucxW}=Dv#wKCGLTZVC-m;a zr-YifJMKKu^E=EDypv-NEGXq%dN6|DxY3a?F=rB7I5z3X)>0l);=#6$IzP)P&qV_~ z(62F()7i|Vh4t=Cx$wYvt2YqSn%d<;c0zik>!Xwe;~5_hJC-ptIK3n;?JCV`Pwh>0 z*<<;lp0evz#D_7TJ9}gVv;FUG=r3dm6?68CIxM}o;{E7tjqcSiuKl;GkLl$hwl3GN z%Jk+w9SlVIxu{5o;E|mi9V{M<=Qj^{D&$$$(cbDwHNw#v7c_E|=nFm3W0bD!=>_&i zQy5$B;8nUoAFd@X;u{oiqaL^Z%v%5A7vJn?rR#A{LvX#7XX6_^&HJ8p2e1=P(+(16 ziAVedoF6$4lHGX5di#S!LHR^;`X7_!ux>B#JMA{jDAyMXog=Q~-4Trw>uBsCrK z_6|OqIR7BN*1YlBsTg~&Bi)FSSViTkQ2I<#OTsT%k?u5PBeAJ9KdV;%erUAqIG6P+ zN0Z{1;ltpWaYYH)okPNIrB%pMcmn^M;TE=;>gTt$oyr*t6Pvht4yM?vlA*e5cTzde zQ;@_WA|Lldx#mAwJ1=85x0RlB2)n@16v}>rHdU21;=B)2>QMHJX0FEKck%pPS%{=f z<>z82qQX6+(G+?wJg)^)!@kHs@f|;|)()Pm1&Y^cm5vphG_(*4?- z)Dui?Zhw@JJOf@zK__E>@9+qJ#3|d0HEnJONxL>yCnp0~wemBLYVb&We{oSp?RrKU zBTHHDC=KWQix>UE;L(el6gNI4Acdd5&+GB|kkVCLn`g&;?g$_nQ5&Imz@q^d zz4o~ZzVCi~92di9vtkU^DrLCwCuJF;cuaqy{aocSHBkMqd-!dF>Z>!yF%A?TJ(ZP6vpjLpVLLXTq%c*GXk z^^V1y?#rO~m;l5w2t3!5l1_lFb`s;Mq2#P25>gMp7i@HRG=ivfZN@Udt~|9ogvMjz z)%7_Q#4o-wGcN*t8Y*$TD2kB1lD%z~+It@9k&< zM#}6oJr=zb*W(zn{Rt&HCzNX$J?*M0F3u?TO4+_>diC*@a#Alh>!|I`oQeG}orb#h zdgl!Hqg?tH<|MCDW;cB8#FOkLOJX58Jtc8^VybD9ZDUT@AJ72 z2;jP;31@0{He<_$@TU~1F*bQcF9P?~__Z!&OcoHWu*ikgV7X)LXYp3-NvXHabHu8T zlL2wWVtCpybmol;Wx_fqGx$(pfm2O+VPq5BqeGc7J;k81nsj$=^S-q%UJ%oY4xgTp z3j?0gNL#~$>Fkq3@2?T@6;eoijNVQnNJ?dfUH-3x%;&&9`tS_E|Wwn%#% zmjUnCAbzdCPt`yS=0gASGsE;xiiGfJ0@8(kj@MZ{92v490r-ii0f)$t*@wh4wBZ+a zulTvWq5Uf1Ds}3s70A;wUc2+I2ku|^Dvj$UOtX7YQDWf8SNU9;fUlCvB(_q20=0)c znDr)!@BNY_KP`p-B_B>ggSSlsiNt~Xd$wU5IPLc4r!R?g34NEHocV#%T<3RIgWO1t zLv~iXB)kak{R)kws*J!P8JewSp%Fvd;gQ>SExQEXUB<%w>C2MPk0C7V1O_~YIOJA; z=4EBI+1XN4pAsp~1!&F$d8u5Hkae^9bQI4|Wasp2Pvp2U;gEz&vq6)Ih?< zb#98b3!GnHxealO=>wB2t*?d8g%hV?Cuy0|VRrPelN`gW>1AVzku|zJ!zIABheIxL1}gpEmfV>XQVX7@?tY_}lv6^(k72 zuSvV;QKu_zZNCim5-xIR1AVBV;j4q+BRGBHw7QHyXnDjLSs7d3<*G`%_OoV{d?R7h zp`C=LGe=J}8C>&plGSZ@GS#oDbbjC_Qw#`07v@nw2rwrBAVTTpG7*s`cWyl-kIeYu zAwwD4%htpuW`|o`nttL>IN2BQQ>{sR_g+p~F(xsR6CXUrtEdl5SGfRCdNP3lIWb+X zJ+Uz_)LqOg)J3F(vhn|Kfs!ZLgPRzMXK!Z^!)gVO9;N)8dF@0lH6=!QOoO!)AZ_JF>;|~*@acIfnC%C1 zx8|Tp?=&35FRN%;Z!dA}$)~T&X7KdwgyR);B~n%JnO2LnmCu`NYf-mV&s%iE1Wv9d z?}3WCmA^>pawAz5SI7a>!Ga+5B{@s?D3O^)IB}Wf!_~U=i0+C2Bx*6G^SVt!VVkm3 zV1MAT&f;>#WD$(Kt?C4UPW#A}*AnRcSVguwTuEKYr!8jmw&J2zmO|@|Qy)dm#fH^f z%N5&BXbifOL`j2c?Ug1;z*iCTerp2oV-U?y|ANrUtzlPfJY^MI=cJRVf>XVn4 z!Nu+mk~myPPax-{4cHJ7)2>ffa*Yy8wIswW5~J5%L`iagY9eC#EXS6h<+XqvR`JR2 zxO+m!UB%r9A=$+CZ&IvAVO%o2ZkwNyO|1W?^lE&^`DGztA4Tn}5+!6jGH(H`Qyo+H`a& zcW&L7*mU8R9xO<{+3dwA5?|cM$ z>~BHc8A-Qzb{vV3TD-c`?Kd{e429_u*`7G|OIKK6x*cB}6QfTlk+a=7%+Hn+Y-J64S;zKFy(+sAo=4QtNe93{ZJP*bPQYXFf(K55y9KsMVaiewwVN}_+uT?! z8fi&dT{4}fEpaCxU*P~8!cbyVvn<0h#{tC4x^UiF&+-6A{jU65uZ)j?ISWyF@C&;g zs_*IsCLP3o{?hCsumRD>nX@)3<+7k-xuC36bDoKfrnD{pI{) zN1pwB=N`!c5{|2 zh@o2iaw*zHLcQGa*?_7$qR@V#&6MHH2h8a)w?2E+ADMNkQuXP}cuqGoxH3PMY&P0t z1(4f0vT|wjo%4FxTrPLIeZ%K-FEvv%^U}hZoIht)JsW?(Se5HE(lGLo&ZId#dc_RW zd62DdfcZWtrdVCnci+it`Q zBL~G#m{lb;G%l*+#kiNh4Xy}bBFi7%TRL|z%XU0ggPfs4YGl;a?_d)d(ZEbXJ=t>m z^J`3vcZkPl=dXt^{j^@LWJcp8nr3P(*v2wPDW1kD}xejV($l+&7ob+m;v5wuZi3gaos{F5Yh~7LMB6tZitus`r z8*Ktj&&;W6IHl^lc*o2!@hQ}D$%KH%+xGDCM`)XR&Re|}+umxl4&SnTGO@-n(q6@( zizIu?Ax$}qWy6E)iQS9Z9HVzMp3}#l>@*(r%{HCy4ni{IQ#?%COK!R_Mw3pEN9|Q` z&!p-6`F7zuX3caQ+2i}J93%=P^WK|tVf?D*-euFG>i*iF9X|i$Lu~+ytqdq+VppdY zEm*L7;}b)*b~SM(xbKnPr~Z^B=7!SApH*Cz@Ejb3&QG67H|Q@u|A??6#haK!wTShi zYH>uQiGXQ@xEW2%3c=iU%OKqpG^Jjy+4|i)vBNcEdN38uedD!M`<)4=r>9jNFHQ0~ zoj;!IP|-A$VA^b%7CeR7v%F?l+r}N-UQ%(P!dqfNL z`db`3-yI%n8Q?a{ll0mz&heHpx$|dFmXfp;JO=U##nvlWSbPK*vlwqhByCyB}3bA zCTE@S4kYv<+7aGK5%1tbZl>D(vUx92t`na$#HbzVp6*#}b+2jla#%c%(SyNMH~bt$ zJl|1?dl%Q5tb1jc(PL6aB_6gvDb+CyyM$@Mua6Dt({~ikrCuo6SDv^Qs1#!-{<1Nz zQP=Sub#q}wj0xSjhNa=PkJs+_Q^L*Hq?sxU(7EHBs`i3WlLBkYHTI5S8SN+)vl?%c zl@OuUc;mIHOw5z0g0b^aH^@tcm7Rt8w9Urpav$rB>P_UiD^SbToo;hhrn<{K`QAFN z(5$eJ#zNGTe_6iM316H<{!C%%^C;*3-X!f!BZQ^OXMF|fWoBrevmmPCLrva6t^DdL zW^yA!m`muZGe+mhogIz{n~udJq=RepsYMA5&MM*EtLe)*c*5%n{k&=btE$;)1*a9= za=wqXxs$FR4EHN}3%Yrxl5#S~LCQxQFZMf9E!}wM&3-H1^h4YX6DhS0>u2@N_v-Vm zXmRHt8LB1OizDqd`xA)H5>N+8JN8_t%Aur=r8?W0Cp&b+xaWe|O`73qPvnG+uAt$0 z%juidkCWLSjZi#gquM`zJZs+O9d-FMgm}oMFKM=IA zBrPOU6+csqO15-#)3ObewigyHX={JBS*+nux1KvSqM)mDXMO1iyROSq=)%ggMwgYE zt}gb|<;{Q=RlAt{QTrMecDu#_zN_{gD9YKITc z<|fNF8f)^*2tWKJsX2cB#9qBUneSyG`0I4Kr}m0-h>lz*DqVc3*}}G3cZx2f#PTRc zXhJ}QYU5Kx^JFw)a&+J68dpA-1N!)Z_EEehKIhITWG#w2dx!29Cm|%$yX>0RHG3o6 zapvlK-ScXuwU^=}JEp^^^I1~!XE$)h2>6p7Rx1B?<6~0U#VYNYYM#|c%*}y#Jz=@F z%WNb2G!a)1P7NV5;qxpr-HSqJ>P4rY&kd0~(1=Vwj3FKZRQ|x7Sjx238l{&nHT2AM z%_kxbfMpP7t(Pz9pXGRyU_c}s=Lg*6uC+_$@EwU41}oruMVcQZh_p)Ey4vI4Xk>lxHg=v+Yi=0UtKYK$2%4f&@e%n-b%khQ?ofwUZ!ZMGuy#q z{dQ*VL&2n?kbJb@^UZSH^%0CdsQO2rkQq z^BBLo{qo{!J<>^a`C~FVxJ_&&A?8W5D=3U%-`97^Q;#Zrs62D;OztIaOaae9_JgM0 zGGh<9F)g{sq&%%6&WQAPh?t30W?DZx({NsPwM?y|>H8cNHj}mUX2Vyk5zc7{lV_4u ziN8?yvKMLB(3&(mr=ZtX;AZhADh*t#1P#|z>-|wA{^$Ckpmg-yuC0TP35LkG@U0R^_CYN*Tc1O7vkgO5A>Gh(3n8`P#wf)Kg(p0dhsC z`WqFsPM>ONonGfaZ*@`3*_jTvbQs2n6zA+&`7nOBjFMI+`*x5VQ%LD8(HQfW2j5$< zo1H`gl6f0QdO^nq<93bV7JcnOE^kTZvrL{mHSkUXNhF<$;p&ik8n32vb-F60#j2wN zCpDg?bwl`TK6Q`O3-I=ZWvAfLX-CG2J=8OurMx3zYJyJd&-vcwNECzSyc!t_rE)>Y z({wZh)>?%N(mEQwA4*=2deKV^Ir@u(I7NW2){`i4j-HV`<V*A3`k$MLj zrX?mq7mhYMRb9k%SPg#=Qt@{MM4}*YE0EO0)E-vJH={O zK{&QozEfImx4KbEoEx+BK{T2Drs2a4y^Z1)&J1`!#RsXjL(}&jxB0DkXL)zn*Q4&7 zwExuFc{K~8@B)f=+d$NYHO_~VTTtts*kVEBRqm0xc;Stu{-6N1KGj6|rv`;n*UOyN zpP)x?M63_c)k{QNGz_j=Q3+Aj6cj(@Yo#1K?iwrF{KU0zO7+CD+savL9obg_qK9he zS=*Ex-x@bpom{%iS4qy0%k*mKam=Lz;y|VDY}JubPyZ6XgSHnFqKc~=pzp~(lso0x zDxK(jVJq%<(;;Bb3p#oZO$%{zUZgo{d(|amDEb_N50(L&CbS2j~JClN-|;u8*n|itr62m^~V4Z(?gcrZn@=V_IkACSH3Z>pHWz(+upU z=EMp_Oox@PJG$sDf8y+$=*F5P)V=X8!%(vi@$DZRBYd_eH@(C9qUfVblotReKua&_=xj~-5H5$!`_g40aPjQ6WP;oQN>Bx zkN4zzE49ov9(tl!RUbb?=Ve4tSr8ZcoS6Dx#%13iHY3{3;zQnNI*IERvfPe24P=@< zf5PJMj(%Qgm^)st+hpxUFkbds=TBsFP|yuhg{}+4qjg{`nO7s%IO)pjg(QNi7C+8aENx@B%&fSVeDcwS=Hq?%Yu^sAAMqF36VJiX#q! zllFe8Vpex%8*-E0ImIAmuQ}MI2|IY5Uhm79+gEk@?veH}$?8TNGiF2;()N|6OrPIo z#qyDK{Egw|)|R$MW>C(Rx58?^vpo~ZS>z@9RXonsqgdzQQ`h{xD&oD6>B{qvBWL3J z);rQ;49lVKq+8JJ7VhMMCn!c^MZYlYEvjhk z$PN(rCH?a9Xz~Y)__YuHXXo5q`F?U-q&e@Xy4oJYT-$p3?X_pb;Y&Osn@=>W>U141 zF?uYi_{R#*WHm<9KBibjQ*lQjV@o@Do{)CjS?DMw8Pn=TJH(<9PemUG&^eW^U55T* zxX^~<$;vg|WW5WNtY=k+o`~VUOnO*VbrRr8aU`+vh9F#p#VEaEQQN6B=Gm*&4l72P znLSY^8{D7M`FC@skt&LEX2S<5SM-_N{$2m!0GE&z{Tc+AzC^>b7+d75WqARy@h)8R} z!l(Y)8C@UtLpPaaVvJ)RdlRDtH(eZBJr@-Wrq3^%hP{&wk8xzJI2WR*(`+i3IdHOB z;6lv0?E_a)J+c+U)jH1UTYEkvu1r;VF7maOR0f=TYWiLQ>Ojp@rb=BNl9apRglPs8 z$)9SSE?{P*@xla!ixNYbU+UC|1O3&QW|XbvspW+O6*Sh4Q_4y6r*-Bc%qlKpI@XHw zMDL6%w*3rkwSh2f`CAQ#GCevc?azs9^f%xId3H<-P!|h>{@$m+Sk1Nbg3)gwBl}-N zp198Ld+SM(HB4|JQi<~3N5T)1+sta<7gh~UC#5`b;@K#CT70x?+z+XQQoJ4{I_K?N7u=>)q&rS)oNSht{DIT4;q-e{ zZf145tz%H72^&<*cV>LHvPyTI#Y9*$;(*F2&{4*dQp_JPtsr+^@@*>NGs~Mj737jt z$*#O2M$x`$U!D8mQ_$57gh6B2d~}HsJg6;%q2=ty7xqN~&^ANXVtVbB4(Ep8USd7* zlcP1`k{MaVnTVF_Bp2efSJ!`*rXZNf$oF5ncD{=JgueTn0DnqyDMXpi@?j;j=vmKo z0)LHj&!IlE*J^X%@z-`!WV71d>%>qmJo0RAjWze=5d^nEosB<)OhCn-vsPr*Rb4G> zyudDHy&{!35wFKtmUlLa*@yk-7a@B@GV6UTIwJf9#8^v4Ogii;Z+dAmXB-*v`uHG2 z`j^!pR!*rbwY+zC!<~-RN{1Z2x_p&S^j#2X|21Pv)q}T+bdzeHJCVNqAmud!dYBXt zirY68c3%CwaytG@4V>G*j>m=%&P(3TwlYRy z_GKriZ>mjaFFu{Vtyk^1P&*}NG+i_IcwULnejgYPHMvEaXYv69KqW8rUD)uMngTy~ zYaegN3dh2-aNt3spAk`+tKnW2DQOKl3VHs@r3mfv{CPJtA@#DHaDVMMW9Vz{Nelz0 z(seJ?j7o5cnD%N;D*Hhze676JB?}IFXTi>;z80z1#K43QExqh6Io7O$3P@3moNW+7 zp0j+_ykh5eTGmwcW^?+1&a8H=i8d%_)5i^TGKM zxavlRppGT|sMPX8(L~T-jFaP4M4D*F^~M9k>%dUb^vF}>#vE9qYjft+RJvA_qJS3B zJ(>GC@uqu2m*+(T>2u~{$Mfcuw;1W+k!Vw>lrB zM8}5u_qWF% z-=6V*+#ienkU%keQ;+^hOI5=mt%}!eX4T7ct6Dj4dQT{et`74X2PUEJ<}N#}hz9k^ z9MA4NMf_o8Rrh|3eCCkIdR8V=)M}K!!eJ_cnU(wx3&Fb5f}Ijhd`_jp?`ickN9>4~ zRPmR`L}O|$bX#)LXy3|dN9R0k7?4}FN!L^AKAA*+i$L%pDVu=MXnf-%k)Ab%1poW| zDn~I7dpN|XZf%%#%%H3~K3r%?ac6!ucwN}uiNfCH4&-HG1>&LU7V#Qw&9K?q< z(+yMPA7}i0{-r$;BK|4#Fg~4wsZMNw6$#m+r<-#Tg70+VHlA%3EdA8U7v(gdD@PTD zF9$9C;PNqJsXeQ=>hQZ5ltU<3??WB5U(LAlnji|-w>&sQ2Z9?<-RKzq4 z&rLi~;&XcUfOpkXX|G#%Rg7eQdhx*}{^P=*bMf(rj?%&QJkp~(O>ja!mS@;?o;hxX zb#Ro?~eN7Ylt5^M+;lEjnqsaFz})P-0~I|UsyORD+X8e@+Od}^+~7Bu^YKy2N& zsZ?-WV70NCkG&VJ&ljQYv}bc2ujjr&6k1wvt*i4{kN^rZrz_0AzQjDCI2)3Z7Ti4K zeU_!XabZ=oH23XGDcE=p-`n|P)AuJgdFn+*I;0Ph++JJTyK(yokjQcSf0mA&}N zikO&CgwFmA1$^S7@%`%f`@~++ryQVBLeSUu9#x)6CVh3M@Jfub{nMnw-e;(Z*_&

    *`2x6o;|+gJ(oj1dmK#_(&O^KH9!95m9hk)<*VY!v3-oy= zB|!eEi(25wgq>A^Ba5zOXN`BrW2ERx|4k_Ao1y*0QzKTL#Ayo*Hykbw1(`9E9Lc++ zr(9*DbUpN*`S?Ic0*}#UeA}z^X7AVukA|&;g`yYq4($6NQRwISI&7T1vsKABSNOdw z<*4#zwWNbB9d$ZcOj zWfH~f*=N)lA-qWApZGhLvonVC1v zT2Yh4Ki@)rQb!=|quy)VPi1a{5MuZzIjC9hRlZ?vaZOXPAo?rO?q;2Q%2a0qW<6#& zsKk0FV+9009VO#aNmZD0kk-H2;Hso~wcEPVJ*et*Yx#>f0x=m;GLjXs&4pxGK)JZ9 z1BtJ7pVl~)w}p=D4dMHwY%mz<`wy=}FPNxd^u_m({d{xA&|kJ?@G%}aG-ASWs^}G+ zFO=t@YX;#&lD#dIdm=ZV7K zds{SpKZk6g6n!HDOa}$c=HYI@2Q=7?8{NHjB}) zHDbtjOaRlf6gwt)*vq0QM(kdlHdYdUCk1O$Hoe!J%pF; z@25_AmzJv$F{}~TyZMH=IYp11Lcq4z_DGLxpx*wImR5yB5&h1babR51-UWy-FDv>; z6H;(6;XQ?kbAbV0S3r5FXf-ta&$gGgEACDxtAVpk&~xz5mJ!-7eQe z;*#~Oi=-+ItQ?-vmX4UVgKO7IGDus~{g`KYy;WPTAugSAUYmZVJv&&R?BBLBKjyjU zOKn8idXT!e{s?k3p$Bq+{;4T?jD_TzNLT;z=0#0kd$ z%WLh4*?|2qT3_I9d$hUH7vkq&#JN5YWFL5$RKImUoZ2;DHwapLjgv ze4pi5YM$EaURx&DwVTB0f#UY28;WLoYgFw`ZTW)F7b?tl-c=FnBU;dU%+hz>)^xu( z$1PwY5foYtMqXjIQ?z@v)@PQ)wNQ35rXwgcpkq2?8W?+HZ&#koA{0Bvi>u!3r#O9> z?rpbJ;Ozbf2!om+kC`DlQF^9g!oxRd=zvgjbB%#8erm}qc8Ki<)dXBW(} z=AS`J{k-fd@}$y)V_EswMRTdGih8F{)fSxCTYdwW$rb$G3y9g&7tSp_=1(k0N_$5C z+6KOw&s=tot&rQG;#Flxj(6GxlT)|Pjja!<9Hd~6W&vENa)L*h>HZIhjV%qvB2mif zOL3aDWw>}Wde{A`n(Oq~pW&}6wi+j{xg>~1f_qMCk`4}3dlSbX@=AV^99ZhGf=QFu zuF0R}DRHD5l04B@c=({Af!I1rhFQ$$ltiB5qw6V3Eun#HOEc$fbp|vBRNL67n8y;F z>@L<)QM0!jXMJE_6F3ccBM$mHz3on=#w=AgCQG}_ z?SJq9^w|#!W5Va&EIMn9BM;f8HXRY|M%eH1Xp*L&b(%UIrJkF5L#B&~=!lzf?ulgA z84J+^1~sqqrNu4#lMCsdT}?NmHgJzAg|s_mq-G0(6kZd{iD4&x_RuWW?`#ZDg}=jw zoZCKVFTl6Kx6|U;&sdMfy_RkwqvTc=xtacE+3u34X!qhP#G+7-VEWYff)>%88ySG2 zW@LEZG}En1;LRG`A60mEoUf#V`l3~bp%vX=Q5Y39k|&G_N$GW7w@(_8am&kQzqoz% z!4O5O_aaJHg_HwxTBZUpSi}dwfCtef zqjXj~(yuz>W0+XiZtIsHH)$?vq`DO1Jjy)siD3iYj^bz{WTiPd?Ml+j0@th{Sx?-2 zecL9(%y7(gAJiB4$UWAo}kGqt79a~Gw`H%o11 zNmPAS619-~VEMsA^C0J~9@`7{aK1JKUmpHlVB$tr?#n;)o44bMd8mgTukA;%J z+}kne8Z5U|95m^%qolQiopUI}HTB0K!5`HHm(A=LRKp4!Vf9}FTwksdjj&p$Zfv-x zXE%IDt*4<}boGLTiI76negDEGBxqobWx5g-qC`>p9+7R;>9*@n)|ceon8-L(MKP#z ze*(<rQH;|T9AS9 zQdXU81xo_Cv{G>%gOaeQK@skr4V_!LvOvI{x9Bc+e)d`RWx-ChKyJBH+f-WBD=<1F?@ezHflhgS5W=fDk zIL}iXle={d!S=oCrGRslMlkWFmH&xM84qfFbLnXZdO@zZwvwhM%yH2;v?QrJ(bJuA z@{M)OTG>dfYH$*`FTnCBEIz{7QfzXc=A!}zsDOFEC2Z2IUK%v}0nsSM0zR|VyVdWn zC5zcgbW_yFoc|Q(dFn(^1FDW`GTgo_CKahnv`2pPl0+zgZ;X%ZI)A*@qE9D!ub3ql zsgmI8kH`q6(h}KF&kwFG>Im&YUK<@h;t9#c(FQ6NmCe4lljcIJfDnmBO0${VOCE| znX!p;r_RJ%P%RBs38Bbdwn5eh8_wzmj)jyaQT2F=wq|Db%TpSAvL_!7Vp2_Uv04%R zkUPW}RK+aQWkkMuY24(fbASWkYq2z85tmIQWuhUs|@@OboO#>#Ow{$WZ+<_BL z-j*AkIL#g>$dW7U9DN{1y(+GH`f4-~fKUQ%UiN^S9K-6;5VhRoHNL zj?uQ5>jOpO))&KXtwGheKZm3`@@Ogoju+r7&kx(RKaY4u%uYRkP*|#BJw0<|RpCXi z&j~R8^{IFO!E4TpY$89(qI^{2#`>jex7~hTGlD$|w?a5C3jygaAd1CWuV83JgLT1AF+TtzQI5m|;erl1XHDtq0G_cB$@o)8q$6zhjoye5ZK5aGP|!Uu_Ky4p zwWwuQH=R+EpMt+1)zHbA%sb5qP6RnEjXz6b_k~SmlJPmROz*Fmo`0UImv-H>cY)q< zri#Dq0^{TT;u#~`CKGVs=B<^)qWlFngXf+zIbS1c2-Rj{S@cwVeP=3bpmVZNop)8S zKmigU|xny--b)T@+pF{`8=dA^e!s$(w^JP!^ss3g0L%6n1-+SrU88y_6c; z)|#C6cO=pyR?|kI-5Pz1?wUyTb+&y83MKRB^r)J7zl{P+yyb{0?2mJA}$Ge03 z@dh_3ZqpR-hmZSojq7)cnVHs|C+A)yynWof@e}aKN-IjGN!+;e)8GCW8Cw~{t@RCT zphm`~NJCa7b2#E6%)$(buw}L4X5(VL3^#?tP;mCk(&ADI(oj1iHZ%Rdh=T)o_;`4* z{{zoA|MPKk@pApd$-~3R!Oz9P&Byx_2Nx$77vE11j=#UVzkV!HXqW{A@{f_qWPaS)n=r{>Kd*g(;)~105z26GEn5R0|f=wLmMLzoSb}o9K1Z7yaL=i zZE-cXn?UVf(`P>q%r@+ZZ4=nz(g21C<#%{zl3k1=H-Ls>;bMKP1bzJmex21+A_ zio$RugK-{%(YgIDw+AErFn8mC9|np5M%~2}1_B)&^nQr(%fLYZ+772>05S*5z48Vh z`VEvs0`+llhRf~^$N3K3%^d_vQoZ|K?i@OF_ADl%6vBD-ECe?y07Qe)Za~>iM+}S& zd3gAMiHeK!93ZtVK0_df4jnqJsm%zywzPnw*zJs1^$<{FGngTK*C62K=HcSuVlzh= z0!-Q>%H_7Q1yT==LXEhD50`o3D94E&li`8;731NKNh`p3gkjttV@HlYMAy>50B$jm zp9*wx2hvcu8}>CO?=i+bZ!j=@(D(KZkm1sY7|%kCSH_@!62>bR6Ob`k?4^f9ppd5U z$zt!}vIu}3gE5bXB7Fdun0vm1A-MwuF*qnV;&uTC#DSv(6L5dTMi$w1MgFSzcN z3`K-uSvrvKGhCK2kY6;M2nebOkQhMaaC+iUkq53@lf~gU#lpb@RADgZ_FzW#mKKD& z?R0Nj-~d!kHV9-e^%3T7%&=<-&;*m8Kk~E)R{^9x^2tzaAVAuXx7T1~3Qpjdd+C_F zPk>&H6on3_J;MD8LgNB}VM-o;!Sf^z6BRO?;R=@Qk_QMF=wWOzrZ@oO8;p5e0#LVG zLIcII0G9#Q45vTF^%ZPVkPEcJxaVS0Los)r0Hh7%yA0$%8}d)bl*A7eKg4)E$M_Zk zqJ&_(w!?}o)L4n&_zMUK$9)_F28#S~JR43g!UP0c7$XdEYO&2&-!C$c^~893;C=;Z z3P{JvbxT};-W5Hkc&C>KS&Z0(v*}#0M0)f6||*u8%Z>86&h9aRgve z@8M+2j+2=d)As-YWf*^-q2i~z)DoPc{-o(Rbm+#78;96+K__U(TVls@{!m|FWM7~Q z@CRaG0YI@vT9}|9UmjWrZnhdIN*Id04b;8^6!rxMZnZ(c(8gBquj*r`ovjy`wCExK zjGeaIn2Zrm@~e{gw@eMg9BhJ=25UDyCgI7SB)TFH8e&b;1(vvXw;WR9_}Nq zPj+}d7@j>6`5YJmm`B-z!JdFA|1O+u5WA4$X6oN+{-x>7-96k*`%Tmi;oDq6!7Z$e z0iOH{$kv4U6{~P#cGsMNWA*pjqLE0`U$w;!!>v}JdSDgmPx=(Vq*xj?oD&R@G=(7y zAw$K%!|C@iVNbLe&z{8=f%fMd8wVQ)M2iV)Y99~e-`!T*Kk0#hb+?t`PkSAp1sslh zg0q0QIa^#=7T5gHp&bBdn64?Dm*<=SCm%2Hhkx4)9umgB5fw%o!D0Fkn5nTLLWIT? zZh!{fqb(rD`XV$INNY|m9sv$c0bbw_Kj%5{l@UbG6ox{H(CEQUO@SJ^NDFK<3y|^K*P$fG+|B5j^KW z@Y`g6TMkhCd+&xai-g(Dfljfbjliz`6(YI0*#ypghe)n3L~?SR1C)ZFOMnY-4fuAG z`Kvcy5&FHigTV!ZSwa6XwY;2c0^HxBmU}m~pv*XVIe7WMq4lfsZz%ot-C#ff;0)}h zlO1h=`x#IekZfI~zU^*Z;RZqQ^Pc172UQfU{~ss{2pVpI`bJwIyZXk*i*?TgIM4A2 z@PF02Z{K{~zwf-o&foGdUAXCXFR|VFD|Bz`&UfkN+D$hvFUT8UdI9v|E3&_N@io=I ze))xHM!>j0(6;7q7SPN2rxx zxUL1gB7ULIB?{}AfKHGUT-VYN^u&t;wnL5ZLmZr}Tzn8tPC*Xf4Lv^h$Uo!!tF4TrPoA~=Ck{L-Fk_kjs`%f3wnkch8s_fPt$Fl^quicaiVKG#Z~qt+ zzlGrc7TZTci!gD~!|6pk+2DbEzY!M~VCMf(c(>Kv=0_pGfoFx=0QTqG;(!0y;(Ju| zuUQYKDARm@825KLZ}XnMSl?LKlN<6GHInlC22T5YYBsawCL^#b0^#XUrGlk!lJ_jq~q#Hu*-Xt2&XkTQLy|2!vROYwgAlkpyGe} zY>x?SAfjjcb+IrK!HzUA_!kGomH==oO1L%G4AJA2b{s_$5(~Zdw0FFiQd&U1(rW-l91p;omwXTg_7ylvi%PzG4n`t21 zGYyX6Cc8xNqmce@mVs=~GXFT!S-)MD|JxAYz_X&zFtjlWZLEjdRs8QiyMrvynMsQq zD2p4soeuhokuE!4rB^Vk6wZ@t5B z=55xa|DfW3i~t87>#h8%cq=FVgHZpe=PTCZvhv?$JsJWtH-})8zs3mTzk^#lte5&5 zfPEJM4m>MvG=Ed9C5$Wn*E2LY)_+6e4??)j@hd+H0S-Lt6`0|#iveYa8UCxf{uRg3 zuphNJx*Op($6-GT0S-JXc8B@5#ahDurh4xp1QYNKm+i%P`+-D(pH}_I)XW#Y+x;j6 zIPk1!n6c@vivJJt{ht3n%Xj4;g#ZVh6^M#{U92Sx6#t)?VX!-<2lD+e_k00!`VFyv zJI-yU|7Yv6e*ysxJgWuV5N`8rv6e90#@yonfDZ#I`>xMj2Xnm!Z>JCB`)?75@huo} z_XEGSjPnJzyu0TPKP#;DPuFVTd;RrWlN$ zz~X=1ll(s4clOmpx(p}Y27VnV^dCy~2L9#ak^37-*p|VMa$>h-fUq>vgY_T z@&73q-~<3j0-RWW*xvFT#^3x=2yoz8Zz6Sf+p%rNV~hX&Ws#yKryFe?c7 z)dGozq2ahXK=Yx9G`2rM&c7@UvpEbx<3~EA3a~_z_A@SUE|mee!H{Fxd$eEHp9O$$M`R^9)ZfSPxYE z`%rJs@K%2t$Zrtfz_S`4EzDr(Z;G{qamD|70Q=9O`&U&RZEW^`V{XT7f{#qWL}q|z zv4v#+Sfu|d)Af+1$RG9f)t`HIGkq&Pk2_~#SIJ0x z^T=)Jp2uXd*PyTWNYVYFuo9eko-FqM^W^-i;((hY^?uZs=zs3nEsmjxd`x-)rvN|4 z4;}~qF4N7B2qYSbFxLCAH2luoW3iAJ1wp*g${~pJ8(Xq80TbeeM^kC?DDW)*- z|7o@({!g)es4(mQ8*I0Q!~R`6`?a=bcwh>$2Z~At^NKKcW5M%RapC|sn*9JN{L4Yq z|COx4Ht%KM z43vNiuz*K7SsX6KC?zd%^#T*SETgQVj1m*OI-|PyWkn`-X-4VGmz6FvvCA;Zh+h$x zXZmxvaVL-MY}>>gQ^tA$!leLias7|K-QV>b8cs?W@w^KF$8~Y*jAd+w8;Hrd6u?h= zcOCKol!0jbUGDrb?EjdiZ#!%V+1jxBcL3k%FmA2oo6Z4P0I}}o!Vm2#}Uu6 z$8Dhnen7(vw@$kDe=rjE2q!gAD|h`09u-pb824=)@B@tw4Y;QBC>uP91RM5Y9{6Is zJVwF;hf)%0fW|azG=ou(F=@VoUiZEy12jYjRC5+k>2Qd^UjZnfe*9`*^%nYke{dU8 zQSkQak;`yS9*!pP5W!!g*x7=On^gW=41ZqZfJtT7Z{WGhf8o}ILx(h_WUlQTl>G+> z6|(Ci^-%1(rbu0OGZ+dDx4_*Vz-|GD>6^jX0Z4SxymaDHbOIc7()@H1+;kEW*dHY5 z1Z3FE^qBy3JLi&XL2*C+5zgJ$zJNb{g@5-|FHGQ>&|iTEM057+w>SZj09uJa{}sI3 zZGI2;*H}=tsK1P5yUm})VgR!=MFV{_gj?wUc|5yY{rUa?4YZ)90O-HcA)pbq&7Vhu z?f+j#gl+a0QGq}Hbxhz-e~9SczA5Mb&F4?w|Mca81NOg)1HAu)pO^PH?tjAl{LTGO zJe+(#L3n>ehrfOPKYstyer|K$HqJpYaSakdD1Q3#vS z@8J0T``fBPpM_Opi|XCabEb6X2zLnAbVQI8421x&z@i<#1v)?L0Ujy zh8A$#!QcQD;O_F&bYyiA5fLxT7SGoX|RaBI| z483@W7AP`Cz`rR4D&wY>t+1XQ_{(NQg9QS@fI{`mO)XL2-$QU4z()l5BuN9YKST>h z=o=dxIs{%?fxRO@*#h`c+`ec}(7~sUBz^D~a^6$~?xJ@YTKM4ETuNeR`>>nQg|H=H1oA(j= zCV$cc_z&zqH!sis?EgRU{CD!-`H4;McX0fH{paH3;{MkD^MLaIpZ)*w5Bpi7?>hjj zz&~8SF@-{A)k{RKw=tV{IQU4flue}gkX^tX5eM1Q9{K=e2H14Mu95P((K zi4GBcG4sMGw7xD9Y073K`c*m2SD^*Xuik);0aOqBh6ro)l`cX-JBl^?j9(l3Z_WIl zGVtHOQi$k~JrUOQgH0{qXd&EhU+n&u0_*|>Bg~uy0<>n@DhHZCM80)Ua8zy)w@nY0 z1}t9Cnb?5}xDAY73IK4HfD42p#1Ui#$jfbB$f5u=hM;aT{<$uH&8RP(-9m#Udl%5J zNX0e5k@0U&Y5#lv!t>wRe~GKI@=|Puh~LNYNA{nC`(h& zhyJwxedJI3rvralpzdD``@trEN6=6EH^lt3e_zN?`?o~=w0{)v9|8~}0kcQL&aP`| zY^u+WG(w_)>A{$W>ChqYXDA9VH*kHxT%GCS^?WA>d(i??%>G%UXh;X6r9Yzyr}z&|LYr3HA)GC&4|W>=&` zgL{ojK)_6)`f&5FD`9C71p2tOHvwDS7_hc5Q&Zff@L&3dvPGfcW>Aniu+v-QTAJ&_ z0O(t^fF{@!3lzEy1*i&upaB^Nyfz1X4Jh_}43V#i0AHdkb+?dwsj7=z!}gugC-UM?Pv|H=QKc>X5& z|L&6TUza~0A0PMsT2BkR9VsG6#x@?}}YD>BMZRp>=1bY~IxJFj-7h;i`@pbWsA#AYPA`;{IFtq;Hu z{W_rxvoHkfv7bGA=q%*C6da{zVQdZ(DG0d&khe2MnL`1UvqWGw@q$7Cg=_^gg(J|Q zEYZ8GeyO*mp4$uqA}?TC1VS~4J{*NsfZ4F?AuSQ;LubF)Pz*2(TOW`IpgqQDhy_r~ z09rt$zt{}Uip|1W0Q!qYL9C3CrdV!*bYmeyfOkL#&=6K2$g@D|TLNPNX^A$sL_=VD zdPoa>P%r?oFv!+N_AI#5v$p65le;iIkUCJkfT~;IzQEt28h{V7#tdd-Y-VW&**f+Q z7)s!KV+58c2yV+iBaYQr#6S}?s1;xZ;CF?y!A;!RjU||W&NiYO%zM-=>x6}os z;0RO#6wqdicOaVp)v+{#gR-zT24L&LAz1kXqY{RK(Cl29NAm^G7T;O7f50*N%X$jb_5VT_$bAY14A0mVDm!RENEyWm#x9qjs-iaT;eZPWK>IJKKm zEW0#R)&QJv;1(8uP9yd7EG@v9ZVN9fCz~=b#bW0Lm?;G05(29XfRJ!iK=7=b5Njhi z0^~D752q|xKtM;>58-w=$SX;T%R|MLWwFaOyT>3SZV6&b5L;cdUl6 zU{^3eF|d5I{{qYXU0X14YzOyY{G<56RU&Zj$IkwaU(ap-!X}U3dHyEd@A{m=jV!T#U&%KbO7Al0pcx^+ zFAy4I1mJla>+iTgG!PLHh~iaw`9BLA7!ntxaezU0`+KlKi@xQ=VvYJYIB4Off2PYg zTfU2|UCJP<2$hq*tSBwN^Y*VY1v@}Y7$G!tD9E=w(L&I$fR+9N@UOY@J>cIm1w;b* z3Jbs&6#T#Ikin1akilQ?5Oys51)0mp%1eWLYW_1tmq!|^!U1m>E_oRj^htx00wY#8 zA=2130FnQhqW?Z@Y~3B$UkmcD^nj7k3Tdp*#POfe_;u@@nP`Wa|D2Nlf{O39l(;G* z14vv+P5QFDxbk+>FD-Xy|E4u=PJmvyd{t3W{E9S$k(G-H`?WS`cz}7|QV)$?-NtPk z!$uN9xGm(^-~o`I&>=^_DC=Q&g&C+~k3{{lh5U=H5to#Ms>*5r$|$X>3cUiTD3ntU zG=|$%wt4{8fk*;w1n6G@Q7qPr!3Nq~+z`;40Bz*g789w51_C?_IOs0`V{fdtya^szSnTXyUw0(iK1`L?9}2Niiaxpp?le^V2*ugbs= zvZ{cq1Nj~RkPCpBWrNUer4ayU%*@ghZHx_jv5bbWpa8!|K?1bYAjI#{j(ZE?fr4jT0Db}x4w_rQ z49#GSfNKbPRgC7AC?f!-7FHd8^%n38K~GbVM?ioN!o$hM&-80V(uz{Qf$TfjkmewS z?+W9)F#bHY-y9t37s1(6L;AAPAMnQ72=xCMIhg(gGEmwErZ7X?+-;0=K>=|B#aB_F zn`H*mvp}MDCtctO!01?Pd8>dIrVH1DfuRQqX$IdO1lx5$cODqNyS-X48Ug47b3|}J zJ%BO6_C5WPkr%%J=;H;&T_%mg28?q#ul{yrsH(EKr1Y-JT)$CSURvhLuORdMW@T|H zEZ=umKKEOdl|YU88ZsxxZ_#{F>GG9tDs%m2WuSx7QeRi*`K`+0^1xiL2u`A3DxdqU z%8Jq##IMMzN$-Np$?;p2Wt1*UN<)<-uZYWUSLXW7${;tOQc71P$fW_D*;wW`tq*IJilF8mX8PWHRN-@1Nq8j zDOnkrFO@-(e_Pxd(qBR5+Nz8*W;>N7l@yc#=}CaDm8{~`YoLG>#IO7Yxr$f73Hu9B zo-LqTlMXQMu}N{OVQt#@L|4LDIm!@7V5x zr}dM!RS;-ln?Qvw>OC9*|A@YMjyHT=_*{geq2G@>g#uIT7U5Mb??QJ3-5LWT~1T!&rMF;NeK_$r$8 zyMoypMRD9i{S?q(_!*>wBz(MB+yQdvZg02G(LfV^-55Fn#pnE7J>J|fl?xsvgyMz_ z)kL{|v`-(9O;apzs|CY=4F{&Sihu0LFVZtXD{{u)@uG&xBCQ4Fs~Pmo4G(nwS%Zwl z*c=(1+}y|lqZM&LalcL-;;lL*iuEJlV(6a?tQm!Dyz%M9U7!cFGwdUk5v@YupYZ~& zK`N<&ev!enRP3Gu1cZ_;l?2Nd?BntXHW1WyCgHHS@YV5%1wgPlF>pJk>;vxsG<(UJ zK6<~hg8H)}-<7BeP^PhOBiK>^JMHc+?Q>dLeDqF1D=X_e#^-Yw!AJG#Ccx>kKseN5UPLG)?EK|&VxWMD9qTDt&|TEgar{L(w-0I?Tzu@7?7h&UkXoOWBy#jMNT zC#c+QCvAa&K{$xUUwDgM4iCPae~~5-2pvO)4ZGMk`*wSk-`KpW9s`{Rq&2DlH{1|2 zBEUFLBZ!gIfmC?JfQ z_xpl6G9KFkfa|%bp0JHDpX;lTu8fEt0%_|&BZ1aen9&51ftYVAv4eUJ>B9<7*~Sk6 zfd^p`;d?ZSqcXZtgq-1%v*t`w+(U9ie~PYvP_H!4>c;_aoM#nLnHxN$TUziPtrSc* zwJ<@htm8HeD@eDoh*y1u7>&G=#3t4?muC1CQgGEq^@TFHkRz)S5sv9jvF+Ie)E-b0 z*m}SAK^nWnq1=*CoM1*B`uY?7B2_yyc<;OFvxVTh+KXr>ElkW$?f%XJdjaPtCwG2n zgp991jrK}l2wtt}zxUE^41fP!o{$AD?x`c&D!US_llqaBd%PR4gS6FY$H^-;?!Cgw zI*NfN3m`iBn0FLlsE)1KY=A}?yF>`~A&$=!ZT+G?Ws4dcAnARF^8*sUsz)?Fy;p25 zpf@g`AnAZ14jS zi6!eIEOkZREPSIyt>P2VMtbudZ1MPhu0?3@1Zbf0MJ1%NFbzh(T$1K}uqb;}lnsbj z4R)vo#DhimKfFJuQn^KqqADG z%GJw`n3__D9Y&l`3=M*2`M*HiU#;WtBNFXP=?n4lO+%8WDN2iU#5@|ECPAl9f#7@D~zW~pq z5s!D2>aCL#36I0zQ2DmcIfGTfbs8HSKePBjcioQFuCo(dhXSx>@~iDdZ0PTW(f2xT zl55U(k+Sdk_7L1z=Dy0`;JGLJUwzp-ZDiX2u0LOYxoP|Vy?il`|M4)--2QiN|NBkt zfAJ#neItPy?Qs{*_7yh4Sm#4<25nDx~zimA~z`wl)ubXl-r1e%*S#{<7S9 zaRB?>=0Rn@Qh6?UuGwpPZp=^0O|*@otN6m^+TWgT!Py=#3#s6uAGH&vYQwQjLcbl0 z2BTGb9Tc|ywz*-zp?jxpG{L1H;W&WcXm6>j`;GOjms>wNbRs6B;-j#CTt%K@Mt!CxeYQ*0{t9)?KdR_VDgp7;c6`i_U4Ro=X z+Z@k9OFGD@w#C^{U!VMl0OBBCKwtT^0@e)s2IH@Q-8U=Qf@aOJ93 zjIXQ4P%_js3xTk!!X1J0eyGNU1%#%5U1mua3to@n$$c5J<^uBpNPoqpwT|^*`@R@Q z1LgLnZZdY(=oBy^p2{9u5LcHGq8v~TsLY~(xa)F)l7M!NiV(hPmY66h1kMBP(zQEt zqZ7(rK)&W?faR_c2*@tW*NsG2bh3s)ZqI5Lz`Xa_L_P)1*-?@xnNV*No6Lg2h>5zy zln6VTaK^8xyKu&Jk_IdXRj@ZJ==bf%Mc{b^MT1B`9-ej#)rI9B;XrWnW3=gy@Ld06SM_m?t`Go_sw?9 zS2JgaxnDOG|4=fSZXTSc^8|2CSbsT7Ym02QmdzZZ=evfSge+<|%foYe4^h#P8^@a_hcDsj=*S=?p|y&j3j0sQwBufG#KecJ04{evqM zxZ($mj)d_MZ;$N4;Jn<0V$h$WJw|-=qQO%(LD7W(TC@n)t^f2X2c7G&aBTfnePOzS zU5)_Y$_hYy#e&s2XF$sZh2UM|7jO;?mQm-%W0;&dxo{}oW@b^j!iNH^%LW~+Fxi9X z9BGW-Fme<8B%@7k^Q{aJ~b_5OZ{nZe3I%&?I*i8q>%{K`51 zPJ4(J4C4@Eq>wUZt)!Vnu~3~#F+jSdkcIld62GoVzCIdz9XqOxR=v_7kr-IRle0H( z3&Sv^KErOr#&6<>VTBh;MH0xFeKHEXZ&*bMVN-XUC%i{Yh1c9J8m>c+xOg}g-8u4_uW() zC4MNTdXZU^C+9AG>eS3-)5<;1+=EZt!_8a9v^g@^>DlXARr-q^2f+{OQ@#2VR+iuX z=Bve;Tof^t7QNL)8D>*>qb`OGJLyyQxsi+uj#;!gUzu$*9UCVT!(NM@t4{k;srI*` z>)v7LQh1*rP(2f_RI7wvvOxf(~4%c~C`QYWvLn`VUD@b9UP%6aLuueXVtp+L57iztiQR*2}} zW9Z*!={=`-<+i36rUBIfBGG|>Ee`_Q*mXK)lDxCQ9im;*xD#RiJO5Vq&)l>9 z&pQDX>|zS=Dgw6#t%6SFX|?)di}c8Nw^t>Xp8%HKi!Bnt)j|`bnn9~Cp77Wl%LPfH zjFESWZapbFbgk9d4L0(VwlM&7syBvU5%-iKY~~-r#vO*Rv>W`#HwJqMn;Wwaq5FjS z1ZNcKu_8W+C!@lPwpYCz``9zIvC_;=0(O6g3cyz9K1n+Vat`z$RPX5@J|)1z@cC~>CnJ(z=Vzu;wd4D*f7Pk0GjGOPu}9XtG4 zQg`;jGBe50#oi=jS3>kcidr2q3pZW+r<_V`>v^mq0kp10lh5{BZI^GH)XMd0gHuiB z1|vCMJ?KEXAkJXvCMqDyt!qO>g*P8-k)cnSOB)^WP@84sY{rOEUYFRYYu!zBNFheT z!3h6&zwtpWOZk$#LU>>f*5M@z3v+Q%^psv#epbd>9h@i8b*I4au(EeeVxXv166$;L z0u{KfFIVd3;cQcSGi(5yic}p*ldKdJ(JQf%oE~Yy0_#DkW7z+~OoBoayGnWBo&B}6 z2`-p~=3$Y=+BdfFOfm|zT|(<6nG<@*MWc=B#waF^t~*IIIG0mQ{s7b?jZX3zqzLQ? z*mt4@82n|J1m4k-#g%jh*Tyb4HMWx@U7Exm==Td$$icdX2z?RRuoQ{;sWUc+ll(t) zPFDCXh^;eY18?{@aCUY87EbY3%FZpeX%tX;fV#GDg+@YRhdo)8jSvRcTJ{n&0EXUl zJ_h49+3@lJ`6wP^k1+sQTi~Kc;qu$0-?{8`qy-O&^km|RzqHEqLEf54pB1LA4urTbzc4$DVWV?6~^wR)-!DsWCPra0WwJH11;H4ZLHsEoip` ztLToO>={+M;Ul%HLQl}sG(5;{_i@(Aiurx zUw9EuXV9RJ10P1$%5ayP895O#r5&$x09dGHr@e;TJE4~I4(86`8&4J=NNd00!MrfK0@Z;aywb*xY*l;^hy2 zE5F`9s2sjq%&c9DuKl&!=N;g)K6^|Bx}vnzy5d`fJp;Wk6h`BAxA$2U?C|Sfj{}Yy zzDT+ZaKE67-esMqZ-g*H;n>wL6L&<+8ToT0h%u>Biv0U7_JRTPo4Ok;hm?l59h zru9X$9%2zrcbwPKv_@6gXXYF@-uD|!Mp+XE1nO?mHEBmAVn(cC(*FW$qun*-ewQi? zD<8C7L(t5uX>;=>wQR5fAY%q=+xTl3iJg8Bwui>%4bM83dGgmM#>)+=_+<5o{&JJO zTsB^Av6pMc%jfLn`V;iz37-7T`1pc-3_wJC@)ZAB!GHc@lzB;If+tt_2_?HHHT>rg z|G9n=z`w^&N>Ba`|N9O8m%#u2Wz_$H*YCoY2>u6xB3geu`3(Pi2mcG^zHur9__qvzUyz+Ga+p{<=NjGo_4nA-Sb=hdpErO;QalA^Zun%>!s)K{Ox3a zbz7T#JZb;FbpB3j^9Q3Hw}uOEE%Qx|@t{u%dX|y(2@muK8*!iQUF#b^u$+PTVeRt| zYrueDnCt)Y6*zBa-p+%yBcrq<55N|mb?5_U*a7atI`vV!x6XX>vbK)=Zj@N(J(GQ` za~|0+>sUv=#5$>YhNbM2ID0pA_hkJ2em?|GI6y%<-?aZkVvCaqH^#ht z>4fbX@EnIVnVoKM_Cdc#Sm5sIP* zo+oA7rT`44%if?$l ztIcb!k*DpU{=Vvmxi{dL2ey|Y@bQ>z<-(FpB4&&=)63h}AN0rv;$3lFoII43$qf6u zo4(u*POPIen-QN5kR>8ZTfhqBJuYG^JQ*xZmd+x3S?i;_{km3A@-6JF(;uH{i%}PE z@-9g3^hS4J#LTf977cG6OwF>cB%pg=SQ@&#aA#RoOTLbMnH_3Sa&;g zV$caoAT-?T+(e51*-g1GfP5 z%YC^ZNQVxe_~y9jA`ijroq3Pc>Fm6JD5to-5j51%P^U}jT4E?cEyy=gNP<)i$%JO?LmbY+mS<<{(mbfpA zzqKi*?E0h0$|)k0+jaMiXXGB5XpncWwHlShO?G?;wGuf9+P#Ft-BXGoiKu&(Kqs=d|e=rW~DUcNmU? zaWDRe!Pd$7!DUqN(HO&NjaAfUfJC&ysR)&`@anK!t2N)&&+JA#fDZ2q(3|@LRK67; zUZWEYKZWB&zb&AQerP2ZFq_tjNL0zn#ynU%#-bf!@<mPHEIqSD%p(S3r9rG_jt zFw*L`Ii@zsY%4**8EMhSWzV`Xg!hH|i~9m}d0&9q`S-jB*so@Yv5*GTb7G|h)yUc* z@nL~V?LA!!ji0iy6(hoU-0|i?mya zJb6!^KA~8=8Gp5*b?in5S zlfywGmkDe=8^V%{@e({A^(cyaBn|MaOTZ>$urD|Wvsyy{83<$9auV_z8OtCl-fojK z2Ni`0mx)%iq&**|R9==15#?}5`6|5)+aqDk#gQWucWBa4){G92|0c)6Cx3ks6u5bk z(7GcgZ=Mv8uaZGp;iU-bD#~SGnp=38T*_ackV0S1^3syU#@v_%rY*pg6<+W*Cx<@K z(zC80$xe0w<88?>L9po~ca9+&WO(pQf}?FkYe*%O(r9JcIMH$V!dDS}Byn>NhbYOF z0$7ky2NM&8*Md#U=$yg=C#bYdR_w9X&6PH;tgY3=18XYZ28&Pr-4LHCJ0d>0_F#Ne ze|c7C%h}3b3ElfYGJDF8=+duG{tCW*`t)O-apR-uPOgR4B<;Ru$_PGc5r{Zx!#i&A zhj|j!$)4jt7f<@?O6!6Z)+oE0zBwX@DHD6QV;4`D$r#R+P&h7*!%>L(Dm?C3V3j!P ze_~8f5=DJjZtd|P2>y|mT*$0VA`*p5lH$oV&X1?{xg!mZKnHM4=ztn zzNx<0+>}!Gqg-3jA94He(*1WOsPDFad;?VcIrb0#j6KlE|JeISIv;MyYdIBSOity3 zCveOpj<$Ic^D6)ZlQ9m{Zrb%nGFtUYMeE3vp}N|UY2E!MDOj`GWcPDT;n}zEAw1mX@=}701f%q$uKn~nhY7!k|`=X zlRn)&56ICA1UykXV|b=N*7Rm>+m6?TD`3n$5hrr^upjW8b$00t$TQjO*iLTl#s4V9 znugigwwZ>Ohwse}Dfx5t*a#?@iH^)jnm#+Usa9d9C)ML-rJfpo+Ra&z8?=g@&&6z< z{Pqy%Ph>H;RhM~o3k$BynxPFOe@s&hb8naZ>D|vK^&cCp(^|QS#ij>7_0F{eCTqmj zo%B=;S$-cW4DeKxY6)-vt&3})7jbvQ4PV$2upI#7FXC8zE6s@8rN#Y9F(yAbYo4Ap zTW>4x#4vd>`F?LW`5b)ud>ws^?e)_t1D<_zr3GF8R_NUbmPKH3o@-QFG#bsNk;nZa zOoeRLpIJ?_-lc3~QoB9D_-nwhd=`c$(oU(ft+giRQbYaKF3*7V#VY;P!_04hR z;O>U66W{hF_Z1IS%!>GE+Wr`Il1x;H&iwGedmQ}P36W9f=IHVK>K8OL9hI8|=Cp+(Z+Zz$LXyFg0mJ}EK~Mt_GzwjPWapPDI9 znt?Kt&ecvPWBF61-l)RH^}MykQqp)fHO9mH_cU|Bn;YEwl*Wq_7?n)n zhgqy#Q!m&kk-)d@OMc-mFaC0M8drq(=5I=8osiA4zjv8(aYhguMRPGG2cE-m|L1i8NP0|rc|$VfpP4Z>j5ZztGg?ovhi$m{l(SnV`9uDqRn zF&T_%oaT%V#eOd1knDZ^xbg;=%%3XLK_$%9#mXW6p8|GonlTPOI135+$4t@M-O;L| z@AlF^?E!6R733TN0`oa7<)bI%0N(i>$BJtxuM0_)jr-yQ3BF}BD(VLZj^ z)NOT?jA4JgXt@JcUv}~$d=`S5Vs(9g^n|%Kq9C615<2Mz?anxg1Ca2M*_^;&fDgE8 z54(M4sdPSW4?ErvLU#A?w2T|=0gK7NwLaYTPo|fn6KbmEznBjH`8Er^o z6|=y7%tV&)$ZQTo_l)@27s4$L#?&wz_i-rt-u_YD_tPZI4w;SRIz zBw;h#yMq!#=Oqvj;QLeKdI*h#yH*M-{S2P>j%@c-!pi7aicpZ@+BF?#B%QM$l1oc> zHFV9<9N&Ufi&C?kUuw?Rl;rVbTepYB_%R(#u8PQiA?2z-pkK7*qDc33v$#f4<<)?Y0Wrp&GXiahdus&eiMu z)X=VQ(__fdkhDm~w>4St^y!wS3p!T3p>%w93{$z>S^AX*Ba>GUT~6^RRt`n)c>Klc z$yBeWlnM62x+f<{j4DTTjHJ*`+PKWucJNmml>#z~iY_kb>XqFymEhBp(UTH7NUq73 zL{NCEkFT>YH4$mz{NSPPXsdEAAe~Fa-+#9=v**2*n@)N9Z68{HA%-gv37Uwk{*Kimy8KUv(XwHaV& z$y@P=+}sGx(OiQw8dDrfIR(AK%0*VnR_1U|X_UN6uTJO428aqm;7kI-9h3Vn*F z8|54hKFcdB_8G#>koao(D~vQFW`OJ{J!I`CT&|6HG;eYLycA^x{w@OK;qMhOVE z^OD?+h>yU5QIzB9Rj0dK%N3i+spFID6w^Rv_A8(@i<&aNdEZq}$G5-K3e$ked>rMrq*+Mtqlk+g1z7Ep2Tl!BLe{S?XU8|?#XnJoIAi=o30)~$^ABEg$ z3ry@63|qL4RBM7*>~KeWtQ zDQhqwkc?BwHkBo0!W0pAxg*kyU70pY4g&*X{{Fi;vFIQ0m@t%iPR)wcr%w%cLsaaw z*@)BB%Ff$dG3HY@1W#EL;Jw@}=DSmb1Mz2scgmV+B;$fFjbE-IIL#}rAtm+4-7lW= zKoEC=Qz9t}4>830laVsv29iX#rbjF;jYzsdzVrgmD^gHK3;tJ0Lin z%lr9f>Pc|RVFh;`mS<0xcI{+(8%=S=w87`vU&SR70jGq1;;74=bz#Qqq#3p87~d*I zHL`4gT3N{q4dp9boS|%ghO)gG$_{gt#gc`TlImc8?(+vp^CRF9oo8@a7oT?h0dZFp zm$af5gh$w-U~38b=&)#>3~WhUpiy*K1cmlETp$@^V2mIdcbUnFm)3J6AHfubPVNy- zt<2Y1jBzjh{u#U9rl=PE@FHPxAd|6pOhD-jOocB%RhPht+olKE#q*!QYH5 z8qGQqs!aMrv*yB^epz_2<@E4ZNGAKm_aSooGF4?M>NfrpX3+ z_qC%1#$ZP?dMry$m%s-f(t;G$tc$GZ0B#^bH|xV)8C;wyT@F24>RnYx4BX zAgg&Q%eN$UaO?)P>^Qu}avq!~(RHV=M0H`yF3H3Uu%Q4J(V%Zif`&izDy8Fy4=yil z;WG-J?s6=p7hf$4pkVIQ!av5k$uyAw#t+~Z3>AE!C9 zWIFC$Ud=_*%$C2eXc|5lhe0iyVA z>x~P?e2)pabp%@d=J5DiG22>S(=Y_m*v)r zgN?P#&4bE*rShD1qW_okx$1rDh1cDS&n;jJqRW+&Q8;|t9uK17mz7VOs~aoz5aiW3 ze0DKz55ntc{4svk@10ZOXT1m}>e9{a!a_xje>`r1nv#0x05v9-Ce z{{MpKc?WTq2j&4buHgTTqbSKLH|_hM^tp%mhre3%*J@`p^0k2z{9W&Sswzj*oF zn*Wz;>o5Obu=WrL_#dDDXUmTk0(6cTePIklp;HVt);2bRx0CjD*b5HAPrXhE1y)Nz zE$OaO@fy4uVvyv?uuE2XVNf2mJMbU=r4;G#@0=m0S`iE4p$ie6n-9!aSYJW9wIg5Q`rbZqZ4S;g1_TY*y&yLIxxE7<)nQX2A9#NkmVX1VJ@r~ zr#Hr%8-mmC4SETMl#bn@QB%(zEj(KIi^vJMsJ4x(Mf@^^{UwI^2!oTiCyn5%{^l+1 zQU{0c@bx6dKB$jz(%nG-c<4iadG?t%VbX{?AH(Dr3Kpu^(EgwsbOznxqXmE>SO|E5 zLb)igz0J?t`ac>NFXoZWHSo`kll>nnz;cw2Dm$!<;6j}mFfq;gNzGT~(ZUV(ycS(j z``g>%FV*4kZ|J42e#RrTJC12+1#^&C6gb#5H9%IZI;22n?8hqpDin7V2DCzC4r?(p)tk`-yBBj7G5y^;T2WTxnLH@YAsfWZC!1JtwH=A*t_zxb-rdqq9b$o7_~`IbGm zd*EzM8co6mMX6oxx;Wuw^UEmwGb~W(rm;fxuFtwkzw`R*&)45AQS$)nub;a9EQ-6Y zHJD@Z;mNHQm`l_C@oBuET249~xt8<=sw~pjnJczC6Nf74J?s1<>dD3M z;Nv+hHOi5tZg*;m{!TeLXX|nLe(&k{T~1Q!R{EKQPu96~tG?dmbe#=-4>=;cSNXYK z4cP4tUu}K3pjg@+6he9e+ov}+yUpD@GWrjExYb?!C93i&D{qp>@JjCJh6}q z@5&RW$(R1c^#^2*`x*4|U&|e54f?*><9_;T@X|_NMwt@lspW7$-G<);r#ifda;*c| zyA%qc=G{f`J&ebOh-=v*3p4QN`~>Dn!=FVhKW zmcBUDldb8#Njal`n}l(~T<;6a?2P@W{}v}p{Mwn$v5U#DgZKKc0D@UE9xc&@^d8SY zp*FE+&w{np0Pk+mXd*;ow?P=kXhwjpo;crVjKGpl$D;@>57>RB+R4}*81E>*2YjXa zSW>;%V^`nW(Ta7mP8zm%!+%WLgl?~|`g_N_Z|?n!(J2qRr>u(XQGp{QlR@&;yEVo? zg`FfC({1M-kE>ERs2rBhYIOVe6PftdD#vIazy~d12Fn1`cMNJJ_6po-8{?-IDU(7>>oK+XlET~p&|N`bGZw%jviPQCMLEhW|?hPna{+HRxY`xy4WP*bp4b%Oxt z{a%5$i+B3X>hW2H@{PRE7k04$?VM^X2lx4nsL>d zb?-C_9E*HxCVR-%=GR~?5N0SCwazB$Da&k$turnP;SZbiHO%8g0DxIox2XclRBb;| zP@3TAS*myJuioH8wosY6BU4+rWI z|FlBJzJ`YZ?r0vvN9PL~N#29~?>*RmbBoS&KY-co|DV6y+M3({Kg4s7^RF57nr&p; z|F6B=e6eB9|K{2{e4g9?Kfp7$|DW6cKdk*f3#m~%dDE(%>^EzzxA2lhI5S^rz5=h9 zaJ#3!5}bCsZ@iAf&SV^RR*vysDr>4-2%di~gX&#Mf&*84d8tu-Q> z?-n!AZFTw>)%U*q7&`qn%#)Biu;gfR4z#w-IEGv<0-U?}k1Sk7y94H&DRp?5s2xLr zy+WNZ_9JMnmjd-;V^0YuT)5*hO>f^0hL|8P&bdS0^CGShyeloZi6Wlm^(g?}eFu?~Xt*dLRPjQ?}s+f%Ai2TW~gr z2oDamq}*}edO0~9L~aJcydf9fgek6@7$@9Y1|vc=TK_n!)PHe(JgF}oj8gjQRj|l= z9F$M1B&EcY(I^@xOj1Es68g1>C1Kt6ck)h9n!X(I2WY!T#W>@3dG;?jkD*1r|KP^d zY4`i*z^}04%?*#9`4*aGq_lh4rD)k0I<;A~V~=DIjc2-K@x3MPKh|?M{m(SbAA4>Q z|Kr8x#$5mR5YN5Lza}aB+Q`=bt;3YRu;%~8%dO41{_i24XUkso-}*|H4)7jSfcK#R zoIwEyMQ2z4@k;lg{JR(3-+ik7?n(1EUGcX-(Wr#h?`;(iVw3{jN~NFvE?r?~f5F=Z zd@aH77!P=Nr{0y{wGK{>%2hy2;ko&~S$+dA*R9g0)dRQaVYODFupOjCDZJP+KR257 zO8H1Du>QgVT0hy>K5uRm7Zyz2O)dNs_FrSPHILB=qUWIU`s@v?8c#K{mG;-FReq|} zD9&cEqS~;bG=;&n9|%TIwDje;w%9L=AUT2spx&NKX@uM(ke9c3byFsd21Hk zuT{!*rzn3biZTLk9o9~M-fz}xT5;!#sDjg4uN<9VKnPh{e<=$7h^wk{T*kyCs-*E& z6a^-mtHy#5BZnwu2kqN2N`Q8>2B-|S!AU341b;?iTqq7c ziG;%91uz~vLbk$~E!Y87g5LBocJ58kYPA!-$F^F9LW}9~yRBBSsM=MUXsuy_f@+Bx ztm@c;j$*In>-xF{uNgSpEk9`OjKjO>l zulrHwqm96Jug?)X+a!U=`qiCj44X)4-uoEv70&H;KSm_9P%AR(Pbkh}5;A@CWpahO zX?D0^d}9%DQXrIO(!w!JxQi6)P2#-iTC>lJeQL#F$9*|;-@;KCnT7d;%h1q-V~~2a zNkK%s|3El_l1%hxqj!fr4f)#se@JmVo4rBkoB(TVQ8%kc6}9tMPEYpVvOkYbj!&8= z$JPB3Eq5=_a;Gy%1ANq|?6bel;7U|+^G+kE+r#G%J>C}Kcmz9Icop^G4B5d0iVDFhh(E@`5ZLwMlLXeo zmtfRJ;WoiMpCp68|5FmZwhm!xhuD2C?@tpN!8-}!s=Nfb;~haJvTWE1|Kk>DdrijN zNY9PXd)8@ZnwX-PsQ*?C$YJTQ-s|k;ZMyy@v+K74=dPkV^whj=&cN_(S%F#l;Tc*V zkKFe{iujLM&8!wHESy;S~W*@eb<3g*27}S zk}-MjTWTSKfL|GBN8fcW>2;>FwVV z>4w*tg>uQ~(OeJ3Id91LDO2ur(l`a3d9p{j%$?BgJc;Htxi!8dejQ%I+_>w5eK>a6 z((YtT`X9HB_~NOQL`j?R{HYrdD-sU9B{GmGya{zI+7u^z9of06&-e1^7TDbHhwX6| z`*90s=B{!ZU~JHb{pfl>8TYmBk(dzW7l|!Eckda@NJt_#Yq?MCA3$)h$&L^chQI&hPxKz zegkrKi^Q$fNNaOYtp|(Gy5Xm1lVR`kGiEdQY*Ci29$SIn`PEbv^V+ClZoqh6j;W$l zK~J1`UUEMgCgZ5TXkkt7Wjkr(l^ENKwNC2hzw2uoTO!MBZ!j4Mxe1m`8+G%pKG3=_ zBPg321Ov*GJ~5`aGFcT3U2srX-}oW-^_uR=w`ROW!>XXLvTlMx9SFPBQ&(Kvkol;3 zY~&c<#g>4E5h=#SnkWz8tn$y-H+ThKJ;~XUIKb|hpt1==HtDYkeUuZ+YotO;ZQF)0 zrQfLNHyS=ZJAzspP8l6EE3*#Ax3?So=INx-0?4Si{d~X<`)Q@i?|A7$e6mWHPfsQA zOt4gt!%YPWgwv`XaDeN6c%lr!I;$Qx@lS8bpUbc%AHQiGl$+(&Q3HxUr?D@v)0QVD zfMth^NEi!Wj3Zc)oVCK!g#PH#F3MDkZ}G)Ze5rJb8BC<_Uc`L!iJ#Hi!KO#7g4bI+ zw9)~ArTvq7rG%*oN{z~X5GEb{l0@Bi`C##Dm+j!i4$J!GziGMqUC6DjVWh@}-H^mr z?S3C~a-lglaUJq%1g1|Iy#|`q>mHw+lTlI+FKBAI+uPy@dPTp+;YBzOfstulkAZ&( z$FG`ud(+|V&j66y%o14rK*5v}u&owGKsUvp!2Y|khcmJwY&Hd5p_PCrz^AR~n=%{z zX|ry_$CKfy159;|$JzK?B)$yj_= zT3uKYZ;sFQVL?#lMez%BF>bMB-sX{ddiEN)z!qBkT5Ic5FYcZ9`n}{!P*~)iREx!; z4@m7~zg)|PQGkQJ+YN^VfwIeHb|$M4E-Z@8WqF2&_+rZQ0lafJi~~$f=e%r@4mEBC zn4@mg8vCE3CgDW z%-@pv0?N_&dCUFG4-4Q@u)uRwfEi}k4g6rXFHB10v8$I|U(YB^e2-pu!(SLUwJsq}ooU-#Qw2~y!CXH2=agPGF&BB|9kOezoHe0> zeKKHalXHC1#Lush%VWg2sST-lasph(@h`1%{mt1CY`zUDp-sZU*(q!qn0)Bu6y-wt z{?a9Q0f4^$;Aue^&f)jJx%HWO6YJsDnx{UQ(&5K-&quPp!;czvP{2Sb0Snbmj^EIC zjlPu}VU*Btr&g3vLc?E5t|cn=!YSs>YeZ#Vrj!*9PE_azr;wJ0he~L8HRgup2_t<}-eFPv{=$cOl7jG~hIwW>MwQ8Mi@tB@WY?;n9Umjtiansuo5p9DPweDT zwb9^Y^#V|T!;Xr5I4O|xu=SQ)u1BunduzJpkMFsY{+H=}N0=?_A}#sn|C^fsbMxhf zt^a+owKmuPKFBlI|IYQl-%|gpDQ_u}psmhrk1rh!uURPR4MIb2>nePGO5gz?^YflJ zG6+eCD1@|HH4r%7wOU%Sb`lMGojoa43H^1e^)n#$nIC~=#Z;@IV$ga-ty@PP$-tojK&erUeXI={}@LT zHxP?G6N~boVjtPu`XaD6FVU5Bdt17i?ub0I_3#oVD;ytAhMnNDHP(Ns5Qm~PBdZoF zQZM1Ctwon_!lc^W2f`t9FN%k}@a!2HFC<|nVVe!Fj26=YtjBRzfFrdP2UKgv$zeNb z_m7w+@x7+={~$ej(M}3K^!a7LHfe$v793SW_!&k48_@n@phW>dFJQZ&LUDmf@Z4QD zr9V3hHw)wo{mgZo{$q$KWcXiOI~u4(fwsxXc8ac0==T+ ziR@di+dY`x$#{&W@WLNlpo8mXdA~$gZx#dzN)0cxeApYJrOv0YUziNz-X*GtaK@RY zwZsXDRF^D0^AhS@1=7fMq!+=-`DGgon+Q;_$E{ApuQ&bZoHrtBX+BQXV>(BfUXJ-X z-S>{f8)ai6mIVGoVLjlm43Y78Z{AImtSg8Q*u{46ub3{|1ian_<9^s{Eu@U);N^ zz{5DHMNKzR#GnB87%U~RSl8M{!R}@lgnvw;q|MGdt(1O1HYS5wILs_^zzmR6%256e z=urb%roG^jjPCJ;QC2U6>}@aV7S<^~x?YNQE#CA+zkLbo;;=V{BM$%G4a&`vBRDw^ zYvnhjPf`T(SSz@i0Q=Sgwz&n1xL_A={UMBz=W}H0>;x_jt%yjZh#mzVnm3*6t}f5ij#uYB0_}CnuCIIVs*@kW7jXq zARka+fL<8PX#6@Hhr+yEKqlxzX?3m!3BuwPZoYU41X5Wqfe~}cV7YFH)ow*&kWJuV z?YBRNU2W6iP~s#ShdQoG3^N%ei9mTWZfB+Iw(&Osu48Swm0y7%@`89(w5E;C3Q!EgAY1WXVNz729&H$pELVtsXVYJ<86lg?GE-R*j@xIPt&+Rz2-rH>qY z#)L!OwKdtZ*}J77ermsN+-;UvJhroH+Z?64hlL?8LYMdzeM#ehgJn27O4iXdG)r6z z60HRM!ujKyVU3yb5U0ieyQ`7KYM&oFtY!AIq(0M?y!?v4w2z}+SAByYdOiJ9VtnEZ zf&9vuHLWh)#%tB-w^?9lml&Ew#5KJtBi`t6XeUMdYWRro9b%MCqujojk07cn@IM9) zJ5fIxUrZ2<7j2ki0}q4nP*hQFhTGfdrD&By-$PGXe7(J`oDZq|m#{tdH23dl7@Duu z0Epav2KJGGE=X@oHl(5wOe>o8~~4}$vp+4QO*hhbII6F$#Yzwim%Kmjj?^!C#o2a+TMEfanwdByWuIqqO1W~G9jG{cVu({Z?|EX@HY&I1{U-T zt|;rQ^yvlioacs;hn6SS%SW z(Doqr>wYx6q<@MMiN22lp}ucvIA$!H7PxO^U0}mN1x85Z*eFe<(R;(uta$NK4@oIn zZ}vankrJ^kOoO9Zcc_mWkX*v zd^O4+kEs|P*VXux#k6j~GZsLPfT5!Kn7UF*qJX~9 zymXDtqVG;UuG+Wbqm*S;J^Oh}x>SLt72!XvzoTU_~>;d5me4f{RVg4%u3{r9jd z%+^o#1TVSZRj}{v!JGa4)b_1!(^@Bts0~lvpp5+V4kWHoPsS&<77+ahMlc7;hm%DGpUl;8so)1vO{C=fat@8Hd8>ukSXIcRyW^E6;gk^=S%{xC`3DB$ON z;Mmz`%5<*5sdfv>n@`>LU1W41$pyc8HHP96eBUs5rR||8Rh!I}Rv1B#5~|u_|LJvG z!%^Y*tX4zTve&gRp3xUp*g;QL6@E`zX#CP(3~pCLjs`=@rNT~I@^O5snS^mzZkB5v z-8Jd!==K-HFLetAOXvt+?r7zqAY-@jYVDP(xJNf`1z&aTOkoT=FczKB7g*UTw_h?c zZp!y!DInVCrQmO+<@+W#7|R$&;hK~XW7y4gWrSGO)<^@?@}tE0{5_ z!kBLkPsO6QwmVaz5q(in#eI4v$@OdJv8d%a(Di%?Ow2e1v>a8@+V0JJ6hanZ%=Bi_ z)N5Jp4W@d=ENX2>h{T`E^<%RTi^w#NMm0JIQe`0>6&kmsYEI#p95!ijcNe}lf)k99 zh`|bif1I5(%fN7UgM<3X>1pL)cXzSGvZZ-YsLwIXBSnsfo`{>^C803W5R0L`$GEp^ z?}|VMaE58)a9Uv##!iKl@zUXdkSs0aP1b~1Q|8eQW{-@HG)c?reA#lEW_@w)Y@}v! zCLrQs$5iqZOx2F9)XAmJaaB31tE*Cnql?o@#Up>CpEu@XEQcLv{(Eh0{kcgCYwPRJasAi6QGbl* ze|-M$bNzb^GUIUk2~AMH_b}&A%JUHOKV|)IZmwDRA2v7FG5_z}|Kr;~bN`RI|HlKy z|1o0bG%EF`QR>%uf`H4-h4{eh{l;16yUZYE7bMI_5X z$xuV7x%QSQ^mlPj*GuFD#!W;zK=exi{u>UHUc1k;wWYNpHMv?yZ#HJ8u*Tqq`o-D* zorx3=l>?;+D%a|j^1(0ehyC&~d9cz4VN}D~<2S%5lTk1R%#-)hyKr2T;J4kWDmXEo zN`8tcs$LFE_yw!E5)_D&Xv7;JXgA(U&d>ifJM^Q=2KJ)( z;<{@%{i1&^OLlBJ)!v#hWL%BQ)Jc9Xh1Em)bNLI8V;t)l`g>@$s`3*F^_lGUP76N7rFKGhtU6Sy|neeFEIYcT>ty+pZnzh;_x>v9L&|ff0pMV z=6@Rh|MK~oqyOD_G3Wmu;+gaRbN>H9`2R-bA3|T2CIn;@xew0W6YXVtyK^;;hS82t z<~G9L7^gZjZ_l8YJ4n6omr{?VscI*~-fxqz1)TFM26hjXs0viGH%OvMk_m_`Q1_%x z(9?IXgh5|U+nD&$u%|-N03CTSQPa7p8Z~7N4FJg+Fmr6;n7p9_DcC@T)bSsGe~W1N z%Y2}emlt_vOWf{9!(m8RC^-0zhU^u(E)RPBevdh+$H5>j*(gO9yOT*mQCW6OZDsTBiU9tK zz|nfD`Ya2Gl|DW>evMHdg5TNi{n|<8U1i@;*4sWRGKj_UJ;trs@f#w@L1}FItW2vO zW0EstfvIi#DK^GEv1wlvT3~*GusLlyZbI$LB7h;xS9Ju|6QHWwDTX%drSUbC;z|s`Ty;o`T0LT{~z-F zcVzx_IsX;AuX0moIBdYsYuq=xevr zQ*WG1+I_)dD91s;SX76-q;Rhyuny@cz7)!dL40}D1u-1{F{`d=b(m$18P^HZ5Wxi4 z8i@ER8spAT`9$H;>E}`qO%nb>LmHdY?QPxoW{FH~pm@=?;Bj~?M~I&$z^CwJ(&JGu zhjI$67;CENs!3}=h!TJ>+S7GO)x@s|%A6obT;wZZQ16u1X zG?8Ukk#Vx$lb7NjTCehlu>YO=|9!XT+xmaa&42&s&qK`rbo(F2|8MQ(-2d-Eo;m+N z=l{Qx|DSsmm|i4X68JuRKLt6noY?ANjLEwgPrYBSl$(`S`S_p(({xr2Mg=tA8m~mMgxbcEYfNIGc zT4vNt=_5_x@DJJ%I{b6!Qo|2MX5 z|DW}ZwfX(ugFN%|e}4Xd^`2vTL2bDZV^;&tTkM9ktT-wxL4OvVTZ*5$5bz z^Cj0X^+`M$C(|@ha(2gHmY~|HiX=1#j7+dX`AgU-^b@7}+?APWWhYi~2>=bLJm)|r z(eSdMS45qj))@n)$l$1VOr3sIMxCY|G-WPGU{0Dtp1!kdoWDYwc%f%o)J&JO;hX7Q zW;*4*_b&P0``pL*pYHd~xPU3=|JKHfP5b_DYjb}7Kgcsb|L5ob!<_$%8Q~!oy#oF{ zc=YnjeKJ0v72UX6n@bfaQldE=rJUQlg#x?2qDwE3j0B&zT^awda1YCu6 z=O>sMPZmf!10-iISO-`3`Yfv~OQtFMkGTS6(mmFN9itX}Y_XcGn8-Ow9!K!M_nRNM zaTWZ%_F)x1w9esFlnEhsf|(xRaMl9Mn%xaQJvd(0}0y}=2FH z?Ou!y-EGsTy|7j+X=U_lw3243UeJIG&RrR~uf~&M>!LmA^}hgnP(Ey(9arCR{@FHt z$NR#9xbUpjDy@TRy{Ihc@pJHW*RYZoJPJVRjJ~wug4Obft{^#Y?D@t=f}mGBs6NHC z^^bRh%E^zeR3Rh^E+&~%!0rPzWwPq#YM-T6Fw!;KK>*%>oCO@-IO=mbN2@P-rnoKD zK$^x{%Z{!3VaTA(kMaGnpkGS@(XC5KJlKg zsI`+}zc>8oow6OJE{{gZr#5D9Usqal#)!sYf=xgHvpaYnUE?>P_;>5H+-P7nwNkLe zph~Dl9S+T^fjEJkXrNe!0jW{B#w2N3X0PCE#-d;8)YoPWPFXe9qFK^o2yce@yHUU6+EQA-F}cI-DPHQ6!}C2M7&*#v;hSZ>;BDvcra0(64e@Ula` z86bJcF#JHESR^`dN581 zuMZHCV%s@j$D}8|Lt~0nAn1l+sp6rWp^M;oj+`jiipPG#qjYge8Xw(7VpAqcf9YM2 zJ7(qe*&8LR5(f)>WAN%#u*k;1fdv#6 zRua04mRwL?Ee_2z%VSLl+qc2S^%b7j1=;MLN!qdzHZ=gU zB)e#-I(X4nu8QLvi1DMX(;%7>t*-3ymQ*Q3&QtTXIe|ule-}O7PD2}1cIPfvT*|3} zH_?qFdJ`}|-QPp|2c_lcFL$^a_JlMSbNS8@{y%DR>>5LkHIWQ?1OPP2s4bLBX?nVAj%lpYS0#omQ z*PQ(C8!zVfzYp@v<^Q?-|1IVJEJ11}B~OnI&PNCf&1J7U&1`G?^gV z&u?h#1dvK9wX0a{Ka)yJE$r+VIHMaY?FMK~jl4a9Jqn4uF0PYEv_3tl)vCuO?OJOP zTjH5siRmwp+rzi?I~as**aG-%ltFY_uXSTWVm+fFU_tjl;x0#4iyooSOBq-NH>wax zz@Q9=I%q4hx?>BP-o8BE4c3F-e^&^G7Yu*dUHlo{wiv?rT^anYe+*l!m?%=PJm^ihI5SsDdFWBjh=-S2+0&$A9g`MdyNaf2 z_RJAJxKXi~0RvzQM6Zfg$s2nOQn}EvONGo9$*%3OzjATamwOR)&;S%BeAZIkFrkBUyXO*|Z+uOcq zLe|9xb=CCi5q;gY;{-UpW%cf>vqpd;-~CMXD2<3pX~LJ7w48B!%&Q8z?a(enN))sF zzmPS!_xL{^FQ6&s|K`i*w*UY7#@0Ol=Yu@+^M8K+KT!Oi_ITX>k{XRd z&JF@5t1{&GafN+6+w>FU6Eo5>KiCc5oH`X+bF{v1GKNe`FBWcNW~Q3Jv@(ryF)r z227Mj>=ueX$hZ^&i5L$&EYR0!*7zz@uxPLu_647`gk`g1Kxy0&A6F^RNKmAAxlyJ? z}W3kciNky>?A^>OBUV%QLWE%SEGj_4Zz!|i*-+DfqgL7T7p_M87k@t+JXa9aE) z;QXBUPxJf#hk54w-<<#Ze(|5YzTmA^a)tJZ&}b{3j7HITO4=8{9Rc3*kH($Eb`Vdw z{AX?IZy4X0U%zBWRg!LK{tr@-)JUQczJl>KsS^cup_~Sf{g)NR%j?jI=Oj7d$Y_JUvoJ<#atm**Y#CRZ4uf>8`S_FB%>si8exAIHWuIf-P+A$Po6eR=u+SQw!Nc+>Bdi zcnjSkSlkl6p!j1hfg(u2itW5Fcw)~j`+zIS#SJb&@UfAc5)_X6QQMkp;wAleqklnW zo5{QKK7VKWSoo#;-G;=j?Z4T;$RXvwP*?jco_mb{NPxJV%5A)3V z|2hBvu<@U=W4>l4b@@)QoxCp0Gx-*ayGZ?4-b|0e37I?YXfN}|Vp8nf?4g)szZA#! z{X#Lx@c!Z!d#ZmKzqhts%$(4mGQ`MUL5nd`^bCgw=J{`7F79;x^9^%a8&l5z_4PID z{&!<*p8w^6p8O~OqlG)3`;Qjxdg?z~$a&^JT6nZD+kuZY?%}k5v~cIM{?WpHo%D|u z?%|w&w2*zuKl&r@Zu4i_bEo}()P|SOrnZ5b{LAOhQ}h4g-`4)WiTnTa2N?hV`u=|p z^DolBrnWKr{6BxWxiO#rhj{LB{zu~o&W@xP##X}TY4(5XPX0gqzd8T+5YJryGuQt- zNdDi``pIdfj@{NW{u(bmN}aq~77D>qjZazT)drAD=jw#6mH3wvprV8Dd~#{LJw+;w z6Zb>Pn@gPbx9t(WmsWyr!sJaqI&b%D;is@~e>#W;K%DH8RP1!=rB$+tDN(SPC%iYN zSy8W-2%=K1jBAimUJqgI2p`kE|_FobGBrShTpVN`X*Fa%Xl3xmPnSmXbg zL`mD%Q#b@Vsx<2mE9{P*cMfkz;|jk(ly3nY)(39npV+fZ6(}z-FQ8Ah^U<1f=es_a z5+nUjeN|%0L}@vZjA|K_kXFT>X{WQ+ggf7jd3V0%n|r1MYq98J#apE(o{NZo*ykSj zKaKD6hXBsz|2AK|d};IlFE=*k{+|!>%=y1L|MxKQf4KWcmLXrK9mk<*?bo3;Vkbbb z9WvOy1ngko5yME(^&m}+Kjf4gG3zMnKJf~sx7!-PtbLw-BbgDWSbrCd0gVW?J<{(a zU(r?@CTJ{aL8dP)3Tj|}V|z6G&+}T|Zt7pOU`NJ%s4m#&zxnjK+b)E|$sp+TVWI=z zZblRanO))m^YA+CN7sRBE&v4M_JCfR0J|1l2IbRg2`!X5SFkDc`@uP^pW&zIBb2$o zWf~5X{uf+*NQz%D9L}WQ#Znzy?_FvMrHky+10yD=pmYaFW3Qr?sf_5iLO366?b+vD|Q7i$y1DREM~2@H#vM zOL`rV6qZMC#eAq$oDk~DPvzQK1v>*m|N0A3Z9$Umi2qTPCCPjd&W-HC zqBP%FSl?Qhk#@wS8$OuR=36wUZ5^F8EALv>W7z7;HJF?FPCA50h(C9LG18=@JAk=V z!qgq0bd}_E2Pg>_+wRc70BF&Cvj}v? z76_6c3&qS`oxTdkJh4YJdkd?#aKb|mcW`O)jtD@PE&f+D8N+DaJ8_c*(Qj{y6<$O) zCb`w`)9$oQKff}In^jKwtI=?=6f7A_;iiO@^o`r7*+n{)^^66e)l{21ugs}@6;9Dr zA0T@b=)KU-1fwtTKhhJeGU8{Dtc9QfvJVkIEJk^&44AbZG+_3z;|B&SfkV>Qga*bq zq6`=pK((D@+!q}Zm@-#}+aqyw`GMh*&}Q9OAI8j^=b$_WkAY|I7zE|c?8iaOCzgBc zX@J!kD7wZR@KEEi>aF1%lcM5psOw?_@>WzQX=+b#Eydo-?unaPA165jhJ8Gn-B;9R z)Yp%1+!Ms6z_$^m9Yjv#3#AQo&pkV_`IJ3G*88x^wy2wh+~=|8Eip?wecF-pg}~Qd zTKnes3&NSX;i5jmJbc8r8l*l#b7+&{ZAYdXK`CTwfmE> zj*_S^>W<$fEP{L3(5t&sc<V_$rOxOpBiWTxJjo?awBDujaM`%F~^~!(@ zWn}DAK8YffsM)PM%&3ywvDdi5aTgB9Fv!v5yx;4v0~lCU_`8>QN_w`jU>iMz_%F3} zl;CYIrdnO@D9Fw#&BIK52g-P?od*h>8H(UPp8nWCnfH+ZY}13WBRkC~{P70qB1I0O z$mrZ^kfU0)DZ9)WV1`qPH`VHnYD2GmBl-S%`&x|nfRekoAw7JuFAB*?I2iSzaSEbM zK_{AfeENxZCwS(pvo`U=el+|9jjE`pLe=)F$ydMCvn8w;s;x6x>oks=i29c$U8oyJsRhQppPX&?7`Q&|leW722W1ao8jQhn#0^m;bJ z5IU3b7|sfX4SOW|i7zKdfY-<3*@pXUPxEd}6mgxtuc{r%K{7^PF?#rTmx$Ll@%T(e zUDzc!?d>?9MOBP#ql3*tWhy=S&Ql>wgvmi~9Ci|?CvrbFc2n9kp%UyvtcJm6y3ql# zj%qlQ0Tff^VF3k(J!~L8CU2m&+1s&!v<7xE8ZenbNx(VTK@Is@{v>lYJ=uxWer3#; zg<$*O!qezL<~kE-e5_BPC?X>g$rmh`l0)iKmbkuqG4$>lySM;vp9gNL0fUe^21vX! z*3J|RjN8}z2$zwwylCL%Bo@T)6eQ?lOW*2ru`myAc%vz((GnYKyXK0P;$7P{#A|hq znTLt^-Zat7*#YmU*tb-EN_Umh){x10Xrt8`E@o^)D;I-Oi52_`w;Op~QHz+?%`GO( zaI{+r+Nhf0=cF0EhCfr-C!T4L3Tyn6rXYBXZhM0fIq^&4Sj3gN=nHzGEm;+o%MXKA zzZZy;SB<|{J=DcSX@kT@E3lM3Vp+)@wX&%~FsNsT=0Vg-#v2m0HWEEA39GOhNF`|N z$jtB{KQ+c!Rjax^enb0#gXX|Zn{?9)+u#K*uBmS`3yuLPKqIl$#T!B7j0 zzjLp?91N1r0{M$#xLP7PaxVOEX5SDrgW{*abB`zjtT#>L1AT{(d zw5fB}$PY+(D|;6p5*DPjv7!c~vL5OEw8G(#Nke4B3WH#uBy7#ZVCJSN_$tLN=rT*I zYqUCFfSjrchG2|?f zl;)Q=e9;@nn*6FKo5`AhUb3>s`fRTEe2d*NI#-SXzO@eTGZ(tX<38Y8XT7?oh0cKS zrN$g2)I_K?BZ}GU8{W^fxZURNZCTr0{4Q(SG)oHrL82#2wxYBiED)QePwDao%{0JCwT+cAQ3#7_0VsTbaJ0Uos$VB?A_dWvnUY^-Y^M1s-mF3Qvi#KuIu!Y8g@RIAqT9{gsDRyWD|11;VZC(3V(24z+D2SP=b zIF^U@lPr|Jod%)fv2xb;o(E|wq8`!pW&@;s$0DiV`}tE%y(Ns_PM#|hpKrx*??1A}gDiJ&?Zz z+u_Y_z#F_EKX@|gw_)BU5iqOZ! z1?GXDQieV*F7V*zDTUbA#Rc-dPb)+p7Z*Oo!x3!!$wgW@SzvKtfu+(eEXoq>#UeYN zKK0_>d9U9~kU@SQEG};^F9sh_zTv+At!{6OMvm|4uv+AA7uiLEgJAo!g)HltB|0#qw!*Kkum&68y56EB$dwC7l%sYzX z8WtSv4BghJ_PB=|N!+>^M}quH(gEX(=#14B8#{WxqF^d|p)i2}3sbWgv`Be1l~tdh~SHT!HRqW2L#D%@w7|7Fro&itLXLav924h(7 zlwP*g>9F}(0kM0x^YrQZOSNwZuurK(tMxPRE+;=XS}jpTvo|$bL#(QnY%oXV{pld= zIk-i4Yt`ekcTP)ouXtf!x-e}Ah3)|d+!{>czAi4BO)@3oSp%fXvqnwT*6*&F6Ba+) zdF$KukZofb0(kznq5 z&4i!fKpwXHE!Dl=u$N%t=OG-ENal;?=7ilAIg|PNW@q^#TLzQ!n7p90GMov(0+fFQ zx)XxbQ0PIilI&p2x@8^q&gl>H{WQRuVibxX>9uIYVbq8<&BLv^%$j1<7;9ql6jmb! zo8o8uzBT`}aOW-FtmHEI&(v?l$4uJ0vJhxdb2EQ`CHwwP; zKS}OvxB6(V2EB-P%=fr$BnA9X3N8joQU8p9i*V3xZ&T39Q)Dd4P_oc(pNIWbc9+Av z%<%4xUP|kCRs`=B0c?qyE?RA)p|J7(MkMWBE3&IDYIl2^u5kGkD7~s7^k9h^DH+~5 z)Y$6ksvcTLrb^C0AAZpNmiUbpRlPAfQypGJ-@Y%^4qwbHlA|Ft#G|MeixJl$$Nztj=h^ZjuK=)-o(A;p62PPT5CI;|AOm38N3%--vf905 z2E7kK;L&|b0*~%V6nHdU7QiCU9$6vr(P?n?YVVN|e1Fg$_D04#425r0m1)2qr9`{O zWUi^{y!B67#CzvG+tTp;BS+eJhm-g;d-!`RI)pYLQAJE$C% z&uUF5xv{yPUGz=8QaOf#TWi_nPJnveVB702USyZ7R}Qe)-=-A%rBbV%{ES`PNG;hs zf?{PDcDX@K|7|U`mj}((&((wGTLkDUqe8+QH#W{1WFo${R;x`ddnC%H7RTm~PL5Ax z2YyH^RXIJ`e=Ccvrw-<*QQ4QpHq%O->7`O}c&wNDTUx2p>VYhjN?hCsGjF-Z+mm{; zbyRNr2!+=^AL64EcyHK8ahqHI??-)*ZOk|<#YYQYS#oCPc^4F9Fc$W`81V0OTLr9# z5;3=hw4hebj;Ab&fL2jj627u1qgiFyvhWoqA<8NZOT$-`L>#LqTOL|zZq9EN<13w) zyLq&5<04oO0}qJiu572{@S^wGv~2a_o1zoaS3kDPr>C-0i{(W>lB-Qsrs^%Te^Rfg zGW*^#Xr`;m{J5Bbp2c7>6DiW(n#}Q;eX?eRtuVpi6}rV>$))Ta6F5ccA{7p)atOl= z{qTD~8YbZ|S;7gyKZJ}7pAMt(pbcLx=)Waqg3fcxECtadQT+kYc6~LV11IPLH?tJr z(fCMSp)wGw_>w`z+idn%6W(oaH>*b#V(;@31IpY2u4MV3c%m4iNJHD^i1#vhQwdR1qf!5YV6aKQiDAJiT;M4|KrK@Pd zA_s0~!v_ABmC6sA5g=hh8E;Ibdpx3>C&$%&V;*cI2B}C?M?7^!EC|43bjuzQJ8;Y1 zXsm?M9l1WW&bSRMifGidx>-kQnt+1!J-}EqH`)fY&Uc^zH1=$Q{{ZLSVFg4Rt71yi z3DrVVxzm~WP=)Vd0)dlB!4}MpWOEpiYxuyP1NntZV6adX zM1zY-Uv*SlH{zpjWi0;sdHwbK%^!B2?=14^VPb}7k_Q^U_()j4sd#j6F;tIYgPGlYd+05NBN_F32`M^|ba)Ze4n6sG_@sook)Yk}(#H`a9t`-(cpD)960FVcDqfH0qs&-@k#4#4ER*S(N4eamq?{;8*U#Fy0h*VF95Zu}aFV@B5iUn+8h;@LJzvEUD ztmk0l*@is>6O_uP0ysQB^GKhcJ~el6GQq_9X=9mj47~3I(q3J#BF15yMB|XH?^`VF zHGR$I>OZfpVev+n^4Rv4cCYAs(S0NT7oK~#|KVEG^n1YB@Bf~^e7P~d|9gn%9_L?E znwxD*vH#oH+S)Yde{*epYi|GdAkX~%Z+`#xkoSKV@aZC8cJkHZX6x-EX`^Spbn|h0 zZ}kS0OM(3R zCjiD0AO83g237wm%zP;9)c#=PBsn}+iF$ro3O=oiLkxdx6!(DsdD=vFOcL0FCrUf? z;-@{J?@=lE5pTm=AK?Z4@u{Q~AhH`B>dN~M=}iY;#ohO(b<`Jr+Smzhw5#21yg0_D z3-G^UiM1JiDbRoUZXp@||Vrt}V1M*+LIgl$W7 zIm$swqsLJrQWwj(=U!E!91#yvo~jVMaj?K=$sQmP6k8~-exwX?<$fQA8W++=XVn0h z@y_gH$7-viNqp5hZ+AWx#EA6ibH|{yB?rKR*#3mKSU5$QbR%p!9I8R3p+O-`tBg1}W6YC>(LTrWHqf3R^MRH00EW1K=sC*BgJeJI zvPjm#_9ql?i&k+x?6oq@VlT0*e8&@Ik*$y~XKFIGLGMR{^T-Q7zUo~h-WK#a)0*L= zDYK+;n&!2EuHB*Xn?P%<^wu}n)R>W;(Yp7HQ<~t#^0Xr>d2*J`HWwZQ&}8^gVARUl z5{&Db$!2yl;=R+1s*<;j-oF(^z1R|=897{fL2xm!V>-k~3(BaGBxP=D*J_;Bsu-@c zRz0dV-{YOoVhQgdNL+2;C7&1SxKlFrOns4JBH}nH8C#LdY5OxGk34G6JjD6j}k~wEd4^5f^lzp8Bl$oME z7N%&LC0da#RkbfXAWPBg35)i7Nue_lpfKaI%Ha3cUru{n)!k9AYoq)W3Z$1J48IA7 zn93%6+m5da#`UooOH|Ml=|5=W9!9uj<93Z7@z0;zBsw&s1NLdq{_IU!&2picoTnG9 z!4eiN?gd!v4vLXyI*b0j1=sm=FV8*ee^4zLC+)#V*8xq@|GZd#@zT=&tgmg%^*;~t z%;P`I<3D`k_zz0ugJ$ZOD&*+2_0~}Pm>*QM2i#6(5B6}}zzFoMMrB_(`M`5lt8pz3 ziVFa@f!h?+;;IGuRQjfzk8C0gTf_s$;J_}=IbdyEy*rW zBeD$^mwv?a81C){>MBb%$x*;~IBUX%+Ct3VZlGfTBjOe0EU9nCgn0V#__qCcTv(>9 zn75VH#;ZFH^_4l&-+z|{3wf~d%0xz1PxtPMjaO5Vv3Eyg?A;9+dnw59%-UUXvFE{s zv7^eSR zG2ra#C(cvr%oekUa}VEJ?3q9Oxu^Iq zGH$o8jcoaU^X2-wo&V+K+KaWh{QnTo-2QWJ|M5NIzfd5@VX|kxgT2LkcQuZNk?~3> zyW4%^^*Fo?KbwJKq~WM~#}c%g@I1vXI>V%IMVQGGcSbiyfvN18FSA0?nD(q`A!>9J zmap2yGF@rO6Z+)1()#f=9MFaJvl=?btgnen@08LUfl>6&pU=O^1R*NW($<=?10;2nd|7fc4;3kz>eA@GolQ)Y{1*GlBAQp;If5v z&<=`|_17n_pOk|2n-cu>BmBi^ntmSfpGWXh6n?|sy{@gYAE2>Ryu^&K;?#{xv&bSl4;UU*KZ-A7xp!fz&&Jt4M!f|p zYfL(rjCE1&Rw5H9d^;O{97fle+`QKZ?gF~rj-#O}TB+An^4C`N_@{EM3QV00?trf4 zOa%)$N&SgtRg*r5AQ)vW7z1-22JiW# zK2?X>5l?h9`g`Y@&A$eQHoI5G+)^{41K%6sVCgNS#xtYm;e6j z;;X&iGn(B$IXbOlGUC@~hliDVtMcwtYq+L0i~=KyIVgFa6E8AlFvPaGgW>Ri5UBrX zKZ6TKz3ze>h&EqeV9tS1a8TiA_>^N17&%QW|Fpj2GU-82{!J1U?G9mg%1};DE5|;# z(Fo2v8pbp*|9A2lDBA<#U(tE5n`e;Ca^pvs9{96zV8KY*@kbPK34+}VzMAAj6s#px zl1s~_{sPjpZhEGqh@w~*jPiYj%I|>af#!=we=x%jFzO!40OmJFX&9J@%j9YrF5UWs z$`Z$@cP--;f@CxRObg(+WAT)sp#+OXvs1Wctj$JYm#q=L$7nxNduD7fd^yt2VfD_~ zWAt)thcU4YOXH|~tYhnFlJt`vE{Q>V*o7^cc5mp-1hq~~GX#4!tqyk%*fw=`3oOssYe&Q5F9{c;o6ENX1@D%}a`m68zFEooEy$B$@E8=7b=rGt#%v3p1D z&tf@s(2^8arAbjZX}o;V+dR>edG;}~$wJX-^*}U_v7a*9#*#%pkY@Rf0D?h`GJs%7 z3rP75cA9|IPLAK;N@%t(g{YUn9AJpp5}I7{1)d682ADCMs8`-p-Z_ob!^=s(EtPP% zrRQ%P`Dr}=7aVj)m7%ec@1cz@QSpe#l{Yv$xN~_*DC2pJ) zx=93FXD94^QeDAhy*$;X3CBG7j!v7u(7q9jCqtntmB*jSznXB^d4W4nSxEt)#Eob z+unH&hitx_ni$#+XyvHdXs{jsR4UPfZaD0Pz!XHo{uelT!+xKv+$p~|js%V>edQ+uBpiG9MN- zksCQfa@xrdxRpQDWlQ?_XiAE&A`WqhI zC}C5Ixj^XzlTJ1hjhXIKE)GS%6$&+1E2-*9^|$h9d%U1gfy8|$ZnVzkambQ@9q%e8 z1MgZ*Nhd;~{*-!Bbemb!lt3~DHB=#M0io(4PeN4!E$tAxp@9ZES81dqw z0mBMhtSasLA}ZT@*qanRqnF0K9(Nu>v#C4gb13_mkip~PqR~CAFvFEtkj3D4?F}qP zk3X-dY|gawu3`$ePcjk;^UNX*=BKbz)MsDwQ~gA?T_%2+o+l?{CPTK2N;8v8-&tdf4}y@rJw!=z9zJ$&_cTJvpZ!bZgWvZs?T&5X}Im!^pVHE zI`c@xl6VF<{o}33O@bA4JuGN%E*LZH-8a&JTZaITS>|K@vOU1l**|`RwChFaj9ehW z%4P%ma8$DdI#|To-kVO;ay{us0+l1l;`;r%A$ni3RvMIq0_OrM_h5f!_ z2N{T2`N5i?rEkO#&OrWx6!Nl!s`O``GRPuxS>{i{`gwMZ3=U8(@Zk5~q57Wj_BMHmPLZGB>?ap&o{c)hrir!@L%$qM;VB6Eo-EfQj81%coFRF zYNsEz$8w9(jTSIEOpC(Ow4#fG96^aSrElQ8)~?y;a1@z)2(?FHq&gvsd!y~uYEH~~ z!fey3ghYlgtYAhD)T0vb{fgPal$He`y_mqEu$GWx<^~)(@mh#V#g9xo&1yXMAxTVG z#^7{xt8$N>MVe!zH`@M|88O4y)2Jjv+&xeD(J(%RDPszEGcW!0Hw6^K3tc&r5(2;;S+t%CN-e-ZldikLG4%q1ZlK%T` zEgB9M7^iy_mxAU}#<-h- zF?-r#{7$%trST-Z1RCn`Uq~Oj@|PZ{UvjT00cvb!UywtuWOf&b%wYCYBif{}IjlJi znPN_87E)T%SA%ajZfKmm!$Isj!|}z^xtHPa)_lXcRa_o7BoB3t`^>Xs@n?-n>*%ae zGnySig>ie(>J2|d9lGpq#VCrjaM|n_S>%N97baL~Xb1k$Qn~3pN(lfYaYx!0wElT- zn~gh0r+9cNb5jC}t z>ps(1oec2CH(0*Fh;tWcC&c@`I5wUrKibTYygDx)nWLUK=LT)Nd;Q0lwTT zT)YGxJXS`G@i2-m9PyfDdj@(ibM5>KPrkqVi9bFcL00+#mS%Im@&IFHN4EX6O- zEr=P3<9iSa5JIt}du`B|)!d~_X{rsmr>~A47JCfko<6nm66vE_MhLZtt(q~i7S!!U zq?By~Zv|OW!yd?>g*fiChcw%)fT;b~E==Llh$a#0tgL%gQZBZ2nGV0=whG-dHrNr5 znZ_3eVrFi4g5UmtG#ZNIYh!`8;e#^%OzRZ|v5g8fQ0#Ojy~W7s^yE=!v25ejf~cU)c& z&i`*WST2k}#Ozt}Z?L?}hLW{Wa&*Ff46TJXV4gar4ObCZ4rqReX~Um8{v!ONz8Q!R zMH)M!uW;m@vEkMj4I0QyvLxClnoNjQfqR|svLzAZPtPgKe5l|9rNF9SI<;+<#!$Q~ zv7Z2hany`vrLuQw#6Ue*pf^sS8zN9+f6%!Lmp1HSiV}X!kSl7Lz0KF}mq=l9_j@}M?M#lrKU19j*(cN zef#I`^UoaD@z2}E|Jc}EU$^qVZM=9nkN^2F&piI;JpSi5j{j*!xS%~l?ig2#3wA6G z86IO#&-bD<6s-|{(!RCF&!#v`MH=)q0DE|_u*cTqqCLNqmjU#){T_3}~hJNt2ba{Rgme~91vwUf#_ z4CiHnkv=;FE7NcWW{Uha-ayTNl z9oG5_04egVT8&Yc7w0xkZ*RJ;uI9I7w<>IVc5Y{_mxcF zc**}5tvRvRu&vHyJPwE0*sg4M751(xbd@WZ?HA2Jc&h3iQxTc`J*ksqnW7!k?gm4y zE#TD=imb8B?nhbszM3k*?ig5O>=N-*sB8LZQ_HBK#P3TdiVI0CZc* zs-#-~fr8trmYLy%^Cr4F74O6dVEy%3?AsfB_m(_>6dAnj!ONrgvO2toczbVg(|}jO zGIJMd?I@Li%97Z!JJY_bg+ou-i$P+Sg;%Pq-h+bOcFAtGWVcwd8!OrE*wn^H1$1`B zks-d|urMk``_g!aePyrVFZBfnhKkNXV!Y#}**lLrf=-R+KB6SU65UuF1(8kq87>+HDtt|az4@<2PN)?w2+J!=Xl zEmY1ymmJUmCLGp&?urg6f~g8eYPoA@Z=98Fr3ZnZ7rjgLq+>ZjL|~mT={yr>6_!{u z7kHbr3k6lX6dblNt^H%qdgqs))+)z`_NyL0r-(VyCJuhBlEPfIVr?^21T_JLqTQyc zbRz$7eK>sFhR?XEdzvx=a|puL2c~_;`$f#5IXt{C#ya?4w*=uCFR@1v?Be}s$oFAp zu(F7HaP{di|HiF$TwG{fJVh-EFVBrsBpi$}Vve1kb5Oz!NXwO3`0bShEyATNEd}gD zfnPVMbpg!|TTIc#@5>CZ_;?Dx2XG&F$4|xY9j7L|efrdVePjH}08RH19zylag_yCl z`H>IBR%wazLj0$W7?)w%P?VkBJb?uz|zeRqm(UCxKfy% z(uZ$yhpK0fQ}Dub#kB-`iSCur@KWKY1g#nS1izEixyLk=SzY!_G-r}Q%F8v`4r^`C zxAx7Ma_yUEzSqooetk9OTTqiAoAi)!`Tf`_);gnzg9YPCDM>1a@S0m$S2AVpvfbKR{nk zdi^frrkTV2VKhFu+D8B$&VM=R%fCxXOjyF#Z#g3_xauWo23=AYfxsKTo?N{DP!eKI zFZvXAf@QQ9Ul772eNYKGaG(9U#wA2{(PyUR*hg6$$f8`sbS9XhBjy8_-C7mm%_@mz z>4`UDGg*fhz;R~kj@Zf*p+F>LC*rS0W1$?GRwWYEvZ{^DYTQ>ro2ZpNF3GIyF>e*? z=2l9mEHud>^LfYn>$SDDL-HDsgfG=WqgGsClUefU5Pa{r6$eWD7yxkX`MYO-jThAl zEqHs(!=)@4okOQRtuTsXMSC%NcNHMB_iG1Vz{vA~2(BUuSH^`zyBQWek?$rJq|7I0GwZh)4R`qx&8+Lq$Ov|J3p@@koT0(6}yRvD_n8%BUdflX*>!)^(R*zNEsNyhMp0D=5$?x9U(TN(h1~@Wk zY}0P+f--p8?XhuLFi3wg<8)=U$Cs5?7n%EbnSQi9$m!t1I*Q;N&IRx2Ud#f=Zx|kJT8<0^mIyJa4h9(D? z*;tOPe)`C?t|p(&=hM0NKJ;l6Igx2W~Tzqu6uX(!Pwf3TZ;j|I}ms#+zONu8aejl z#Ry~86fGD2 zwE#9<678e#WUfylo7b>Mk@0JJd>Lzbxo~z^+-3QWQ2~zz&8>k2&z08FGz?H4`E2(O*BRU|EPMHFITqK~A>Hcnm2 zI~O7zFKYZ?LLI6a_!5Fn?`Rqvw!9d-J>>j01E5E8)K&yht6srwUaKItP9CmMTU}RN z;$~Xxgl@yM_ace}mxq-da=o(u6U9hGqmS0ve!X(g(kn7o4Cfu@KT7xc#<9AAd?*Gdw8P8Oi#c$Bkbd-O49 z$$z!SIZF;kTRBVqyO+D4@gQf(AL38LoJIeZzi9VMzjvOqZ1_3MJF1-J;wWdq^Iq-& z_4~O>es8j$Km5tP|Ko*WuM@^O{5|YvcK?s{wHI^$j|X{XpMNUXorMf$pZ|@`jhFNJ ze~9PS^Uur$`+W)(mgf1xo^1YaeQoQxo&Wdwix*pS{_i24x&P1H|L0-+e`I>!Y`>gN zZ zJXf;-MA$(;6}?k0)=Ok*Y-?ASu^|58xv*1(_6n@o)owd!7j$DeQT?%3$Hl+0`(%7} zdH+RtM7QK8zQ^t2mCh>vq3WdI6?4Dn=NWc8W z_*FhHHuRU%F6*(N_~|K$dTBM(k#O!YTQ$lg-ZESl&C3`HX?(aoXm3!F-;fWP!{8EgWPXe&*d{*2Dit_! zS8aaWs7}p_AhsFebwR{3O&7$jpe*>OU88vR*l2hF!>Wg!PX%WiTOwo?S(KM4mHC}p z2Uvxr0RJty+oFO;S2jv-kFNzfUpWMve#KeEt#H`x^Tasli6}SsVD1&6&q{4ca-xqRF_=r*U9xx2Bhn$Hsz>jmC`3 z3f}>Y?+PL8u1WvKqVuWtSV%R|*q*nsy)|g2jeKk{46hkBC|eouxV@+w@Q}-k0AUe# zPA#@B>{ha?$T4AxW8jwKgx58ivUoS*)c~d!J?_?~5GmsfvZnu&}qpO8)#eC?~LW%u;=6~ zvTuQX>A*dg!e;kbhd4#wc;%c%h#fvu+fIS@!bni<~A>TLDjH2vS!=JR!1|Mz@zbFTk;h-a?$0$H(jGL>-+ng5H964uAZPhOhsIVfel_nwYEn-!RTa9_^(RcmYgUvR7P9 z3wi_tqyKvE&HPUt?Ta`XW%ev%&?-rnQHKs+3C?JhXB3iUy{TrB@$_b8&Ms^V#hPQl zsXIDl6U*}@hhxTd1WUak`>W*rDh3pG*&ER#<`{*^Mo>z#3axVfG8R=^GM7DWooP_3y%Pcs$a8T+8YMLjXL6(=dj2Zuk2X0{fq>=rL{PXK-vw>=`7p33_y;h@Hhf;5T zp?UZxg@Kte719y*-(4nG@t(Z~8KA56%%12pJ^a5>GXq5n1P_BhC@+C!_7xftrMMnP z;e{9QYRyee)DUxNN0ZAdkgf;O_{(EMjprRJUnY!7lBgcGQ9Rp!dv^Szv5w+#r)30L z5$h{Xyzj>hke75RK16>KU#VJ#28Bchz&N{U05~hM`B%J;re+1p+FAzYvIls8W|{T+ zMHO&QBZDd6e_7FF_(~tZnd{cES32f!V%;iP-Sh_<^2~vF%m^@IrL;e_d;J!P(W`l@s&P8u_+^G4>JK~7CG}^yve+tD|@L;#cnMKZQr+q3m zwGux7R@4hV#u7DiM`9LRClE72b2~N}_In@0{ug#`z~0Aei0otH#1KguC{X}A05Eq$ zH0h$2?+OH_a5#GxrOwksD!cLwlcm^lq9c|qBykV19AFl}VK5nydXcxwX_M_ioIWbr z>8hQ7lJ%OM6;wLETQGkmhTxJ!`<)p%4k(R*gTwqAGjRNRcUcb{xJ_}5A01rvHzn^?IqGVBt z9Q}4+h&%x~`;V1cKuV`=3S%@DCb$c0`t)lvHL~>f^oE`5tF%AOFcE|NK$?QH@u2#0V`9fwp@djV_OALGo zPXhWc4lHxt{0vTMI!{;PLs`8$ooj55f@xL|h*pzS&`?5+Z)46|UKwApACwMBCx6bI zJQfgbu7yb9@vcS$MQzVQEe7q>i0}Vyj)a*&AXhnsN6^`p`Sso1pIhJmaeaFpKakn| zKQ>=J-BV(!P1%UO2@~v|DdqA5a}u%-^_#FX4{H zy-)2V+)mLDX%%jEX5$_Of4c0WRiyLpy^r7axtH^wdtZ2tetM>y|64CMZTqhm8(Z`I zZx8a!&;R-P{~+f-?wVZ7pbmcHrDf>_2aA!fji)Yd_w~0J$xHt|XpfAaq@XvL1UL!8 zZfgLj{_OGzTJAa9`x9MU9M?}4>coAIcKPuv?w}gK!F6{gufg0!Srkb$f(C-8NON?^ zArjcZi-+dkj#i^iq1vjb%EH@~Q8I2NJDQIV=Rf$-{2%L`u3_gU+&)8c?M5aVu{qMZ z6Z~Tmj=!jTBo;e;iHC_1q0K}`mx5lGIkdtU`(*YWu9c{@6p`kR6lnb%#;nknBH{@Qf`;HsLUk7@;h>O?2KZxeih6OQ-7)>AXn;GN#8){8LOg8#h!g0%TwcPjZHY0B8luEdUkUCAi&BLVr?sV(IZ8g8YlWP%;@gTE4<%6Cng8eSMcjnG zM-G_6|G#|k^0~?XZ-P+pe9r$r#53pr=luVJ@&ErgtJJHG0HEGxC3O~_9+_#LBiK5z zJFQRcaS!LnlpvDHILsCgxLlyg3o`d}t~}NJ%b@EKAx6SPDnni{Ukkm;Jw}|_A9Oh% zrR&G4Q77rcCy*VuDAHit`o7%N14|;|amvk9(-dsJ+$>Xs>|NMMwtmp1kyGSYkbxD= z(=3yAu4L5RNWI`-v@uFS^l%&vrq(REf~z(y)H*kSY+&dB4U+vjSh9O!m)Jmk zdsb!L-jY6vKu{|521Z!<4aIKRN19WT#6h|n0raqNGD`OA;e{@$kMKVVj1^vhx{HzE zPvA@d$%%=GQn2R|BJE}R0I>#-=fOfm%uw%^6`JkK8S0#lqt1-Q`FLimHCwl=((toM zY{yc<|I$LO47z-UjJ2s^i!Ot>U1DTaZcWQp^=Ra)&E8I_%t+O#EnmAUnpJ0;Ix0WR z&C+>49Y7-mKqDIf&6(YO^JQk$eUP`tc2)T@ttz8?5sF2t?tVxEQA1G{RbpCg<6TC@ zA7T4pK}WR8=1W;yRX>iB-o=;0Xw20yLfu5RxI8!z96SZjDOw8jV@WC=Qn-Ub%flZ? zab4pPNT8R$cWg!Jk{Q>+`M$j^6_f+y-s(JGkLsMuqC&|b;X&x6^niLo&0v%uRRbnT z@gBW=|FF0i?Ag7Z#4^NSO4vUDx9Zs82g}?H-w4vDPEr<7NUU7y5wket@no82_S*yv z5HT}P<7|Jw(rBbdgCc%M08UG0Z^m-Mf1ANFj@svT)D(fQL>3i7OJSK4Id`gn!xppP z^4;tIqVu?5kW))CpWjJGbZ7k!hS6+|+T%F=0(hGJ*P46(yR|uw|N9`%T>mrI|2&BP z=SMV|IW5;4hW^KVo2BM3KN%LMvtF|zUvf%2miLzRHLUdJNT?_}SL0|HZEs`J)z&D2 zP5qVeKK>HJG2Ei$tR=I`usw|85KsJgPn_v2E3JD~s*Jn#0_q!fGR=}~Dfnm`Z*j=H z@AMzc5?lPE-#^Ts@B7?~{g(`l?Qdhs`M>^rebYJr*XQ}49^^?m|JPRFpN%;aFlPep z{St^JqitB1K-$~8nQrU410IpKW~7&t<{~_n@U1O@jc&s*zxPtU)pO_lzcc8z!p~u6 zLVTLHjVb&8=H`nR_Wu83eJ=k!$TOG!=3D=RZ2f2)S9w?2KWm=o0-*Ie%e2?Ital9n zLF>Bg-A!crYc-a2S&QJJr~LU$yBC zv#G6o3em<^SOw&*8n%arJVF426HB9myI)TTiw}ud-I$R@4P_|S-jhYSJp`S4$v%=% zYwWqMU|$fUvHqFsFf^Lq-tKh~)P*^G4@k3w06kZ3-0`^=`Cqea^0hIA|9i2uX6yf7 zuC2}OKOf|o^M7;x??L##7IU0cA!ig1==r2Ea3gk7n0A&JK-)6P%r^dHI(fq!)b$|u zd6iFRL-Qmeq%NUDTTU)C&9O}Gw5@TJw7pj&MvV2DY(texq5$CtyNm5<>p&-7(t8B4^~T95{+>@ zua74KRXfb-0H;6mV58PhCG1CWGT+}-1191U8yNxjmm z>{*QV`}e~LmU5>(?tb`ST=r;gCME#p$ELs24FrNEX&=D&UZbG0dZC8U-r&bxzh98p z=ylE8AuPeX@f4Tmo%Fq6iOp}UxxkSNn`w?!4?DO&d_iw8aw94++nq5pd(bR94#FPR zHq3v>kj!A;(KyU3a|i<>Uo$^(VmHZ}(XpzPLQh`YavV|r$)d9!UQ(s7t7FtF_5e^M z+oF5RmpbupDBq0=oB5^MO`kY!O3V6V3`p-xN>fX4LjKDG?*N8&H;A?+*Kv3a<;obS zm6Gr1#8YQk>EJubM>bvUt5}h`K@ffd5(w*Tx4SL%k@ahhS-I*itoWN|PqTX^5LDr8 zs6v-P<+xzac@0i4$8dVztfLR~bR3QVqdHt1oKINAa>E3P${CbLd>i#i?nM)2+CQaf zn;n*QdC(f*Epzu&t6}Y-3LMW|u%?M)nmkxjSs%EC9sMojQcrQKH+n5yV$G__34zIs zk}huHm1dYd2Yx5+gyA8d@lb# z$TOG!=kovek^k!_&9ZqHlvN~4YGz^^9D~Hv0a6&K2Jr=p$)*_sjw$Ls)0!w0lFqu0|6(D`* zxa-_>>72WZx@^90Y)oPTBKw@qBO!A%yGnp_mzI?8DdFefk#{#FN5x{dKO^HEdxgmu zxWFC;{a;)ZPN}{oEh#BWG{OKcrWhf3J_E>TBA_r|4d6YsKKH}nr4(_wY>rnltez>@ zha|LBaZU>66!C7rhSOopyDPbC!Ff*lOh7XIg2Y?DAdXjj0!w7z zCcFV{@d_{qOL~(6BeWJPLDBq1>lu*PAUbq}Ly!o@bjwL?RJ)(8Huwf@lw>Z4ZeJ-G zv%hkWPm!;O;+qwPCF#0`4yH^A>Xbs`KW(ZWW&;RI6;=SH9o;m+N=l>tf^q0JSOuJwHD#x{$;b=Ik%MW)^_Qx>cA1Sz970z!YInzy3 zQ`ZSaI*)@<>kTKLQA2k!WG*|(xrmgwu@NakmM-`ERNB1!NV^WvxFVo95YJCHa^T7i>O<_Md0u|f@}Vk+3ye-`vl1W9!#(R;Zo zyQ90}BKnX7_7lvGB{Gbpwe2cq`>eORZJmJ|y$g={5!0}8x9k5ZHsQ|a|3yE#7FLnB zv;SV-dj8z8|K5B#KmQ-%nVqF z9vHuy9xZW4%PzSo>W+9NMqCaJ7 zh?BtxjlW|49)zHF5?sLkaMb?1LlGG9D=w6PMF1%UZ488liENebXl~VP(*TxHu-1+f-*=p@Jm1TcZjarI(DbR{ zya^LNc9HjqedW`M4-Aoxi8b6S+X31y_1gX3zhSpr!>tw$lK_?bcyP2~zr)Qq9L2C+ zhlRCO#%>f9I7;Kpn&f$1wYHoAzzhVtzF|r&1{7G?^$%1p$A$|Ngt`u>w0ejy8t}VN zw2ER6so-9)?(_~Ho(oIRWAKdNT2MqD=Bd@~dg`b4C$Dp1(CLjcmj*#SC z!{HrfRc;x%<}~qa0&-^MR)muqCG9?uOzO<4olBOb%RW^CSq(0E$-+y$V4H284q7xg zPj`dfPUb*lS>Gr`(iJueOw^Jw1}dEJlG!7mqHF}=Fs1(hBWLgB)XBcHc)@T2CaFDk z?!_D&f+{ z9g5d7&X$~2gCyp)t)qFBu`yJ5HLbvqmzdU)T5_tZ_SQKQ7`NL7IJ5Id;0?7mEKLi0E!#{u z#2vlwBDQpDr^GH+a@u8`k``Mk7Pf$<{d$jIIWH;)a@y-oA4Rz@aBhFmVaf^P8wB}& z=NUirA=luIzOs?aTR4^)2l~(N;T}16N+R*pBYC~0-e}t(rL#)QWu=v)WL5>^72iQ6 zJZZFJO$%KJYQM#%yQ5bVNTI^whqt88bWrKn;Uz$hXDECGEQnQ{Mr7{K@-Qs`I$G>7 zRT55Cb&%By@*rci;ZTeQ(C4G6at4BnQN%_o9 zO)S-d_+u$ZWK52%1;MK8WSzH;r0&!TxL2fIk2+saS@KB6(|V@sf4;X?^nd5M7yZ9- zIrg?O&HrQTg%khr#l}4TmXN~Id zo7O)Y%>!9O0;0EgfK>Newd(PYSn}k!_KS97EQ1!xJ7e|j-*D*C8+O;58EYc1H_0u- zFGzP?%iDp>^3m2N947D4Nkch`@GQ!W>OU*C+eUP85o5NC8|hfFuN*<33A&YF4aixb zT%Bl!g$j?7=Nls1`@U9vUDBeGX->kf8-@4+yy0#Dv)GmqB|i1W$)w#U_J4XQO2Q;c z*(UfBnZTvI=HbkIUrkTsqB2Ye)3mCREZi`VFSvmbiEzz zi|Lgwi$M7e9e_8QSu(Z*nQ<_zchI-svZX_b^=NU&(NKD-tH>AWv-M3-jC;$t*A4ZK z{S#K(AE;wK1S^Ff&DQ?gv*RCuT-IM~{;;JvR-qAVb@-k>e-Lg6#@CZcVtuCX|88+F zh)#q4YoG^+;E#x&jQ#mxFo&O6yZg!K<)G6+YfZkF-_B?gWBl5O6CP>bn`OJ#=YHb9 zx0Ckm{Xd?++;IIr*4O6z|3f@;{(sK@KOp~430`g9pTE?jwYe_czSwLrh9?O-KIUA6 zjZf#2~hJu_{;{P4^MtwdxA(Y>VM)(WjolkVx*x_ z4!sT#e);sYw0}~sl&Z(oW~oux55lD5KqKoOsI+CnYG0x*7rwlp-lla)H`8%m4&ArX zNXLAQwm(*N=MA?Sk_S7XQ2)s#9nJrxryQM`i}C=fXkNAWvxZ6Mj5072GH)&Zz=XK$ z-qf%gm<;>9k755yfkO%QC?|2V{D%DZfB#*8Cz}HL&4BTONXnuh|L_Wp5A>{b_~>co z@VQx#fA;BySv2!hz)@v6p2%Wh7+wb~Bo*wUSL5iqNT1&WkPkclkx@mcIqCODAU{m+ znfMEdn`|1iuCUo*ud%PJ*JjJGc!r(PmsVV$iBcn5XFt@dm0*2_{+O_NS4tA^3_i`f zc$FXijiR?Mk6LF@OBZ;eBn;kvkOZr6#BuAxlkthQB6pQSky#BC)`}&BR1kAi5&+~I z5d>RankgW*89OEgmK{;>`Ib{aw_W}>wu+J_zQRA?H*F>Kg8pLt!cBw~Vt*Hv%NW}= z*hl&kYp_j2yd1K(V$-14;s?BkU4vf1f3YtAmEbRhduFhYA9wtuG-A&zB;m zzI68%b`cNK8Qt%zGmBWG5R+i8re(jh7yE6t7p!=j?Ii^%I6-~3osYh(ik~S%PlvAU zRM5evf{eYBxD-Ud=wN`2U1vU-{t1`U9_E?Le{=co!TkUCPinQwz8Un(d2dDD)+2$Bac@p~ zVVp0W3zPVI7@w%c(!jKE7rSNr0GW0pExU?d#&n85m;UhHq$k#?&_T;4W)6bFfL>$u zO_)fti$ZZ#+1{vg4;`|3-fyU0jkzfrETPWT$xtuZ4bLZ+REBGO5AcO5qcOr&n9y;8 zmY7;(Qhgtr+)O#)ZSQ+%5!FqZjS1Mh4njn)3g?COKZZ2oWK`No|8dx$56|C^_No%4V9&;K1(Yi8yb$TQdf&iVgu%>QQ?^>`8`a;9Em{J+G{FnEt?%|k~_ zPMdr)M5S%5uLlO2u58Xs7on8UvswPDZ*X8zCM0H0&NQc&7}A|-{V@B&>n~``{T|Oe zvbYC^oQz;MUTnZ7S_-oNd$S{;BQNnL9O7kXD3q|(VchHT*tbR;Je8<`S)UJl!R#>t zt&zt{`vEcmV@7;@j6N2JbBWcMdmoflKI23%^8q$MfdqDpS8su`3KYL@fkYFdXGT5V zGlA}Ybl&c_VwU?1J#QuI3wlROMg|35nP=%};4zO&Djc3hm*I&uW)U0Yv5onsm96 za?d=Eg9ZI=BXbMrEDkyJtYpL6!ePNoqDC&YMkxwR~ikwL+rjt)-2i`BSJ7};6KK8gH}=toZ>A~ zA;4Z!DPto5#&^IoAbMKGNuFOF3q4;v$QM*2^U z28LHaz#UQ6!T7QUs|ki9t-P>R5rw@N{GDz0KlUS5kcaQaJ2U*fm;) zH|+GuhD^JrIzk`z;vRXiyYF|DUV<>&T2S$gX=56%*CYNH;7Ck;;DW( zh%tQ#_I6XwOj*PxHf$Zv`{4OsaW{afy}@Kan}gc}HT0fX+=!vQ?d@K|EQf+#!d3}l zZS@?Z2?QL|IY@Pg6sbk>bq6?63 z0UZ|dsh6zm^~r`5|1!+S>`EN-3Oye%bXce6D{qhqkWLK8Z(?;uGY;mMt%oash>PBM zfD;i8F+LCN4X|k9;Hn)5=OOf!;l69sCac-|Sur$TLj`o$1_C89sM8NYf)TTxYH(;y z+>Nmplt&{dOg4zP3gLK+^j%yQmDmH}2KeXJc^mebfpJ`%3{NNV)oao+5jF5SMPs*w zHdz3UKykm2i-2b>Vq6tatlg{^flqhk_PiqjvZTluO9@0H5Sq>rRX8L*TS2?qU1Jdf_Cf`mvS4^R<9Q@etC7y6iaPOX+$Nb2{Fnpv}UlMBa0fLq1 zS)rio8U?$uS6Dk=TPNK*1IIQ2*jsqR^gAw!Abj?LrRC7QnYk%ul&rPII-ajFc?r@p z{Ct@?>Jxj!}Uj zl(ozq@f@~`kA9Z~3Rmjj4ZF+1N#tmERe6@3XTESlXkTh8A!PznuUxo?MrSaRs3Ze! zRZmXC+I?e3bSf1!&GzN(@iKzNITbJRa@B_yfe?hGdd6>F?i(4RC#lFd?RE1Y14cd$ zFDL!B)GDHa*E}XTSawsq_JJAd+ad$I9fE%=42)6B5?xh=Rvfm+ohyku>GPui5iv2P zhu1eiACrwR5qXo4e8ZEGivZ&qmv73F|Cog1FVjw4ku_<$o?PbE0a6W&P@iL|hxm;G zMg+UYIlePht`ybaPjOsJ@iK>esnjn#bv(s|yR}@2NMkr#*&DP(H-RQamrb&_3#xLK zIz`N$ckfbgMp2w428!^#xoVRvwv%3TWyPnsu@#C1c1bRXj}AJs#m7#Ei#zrR5eF9E zDG0u>Y=CpmJ*xloX_^p_V_Y}x+{Pb!XmqT%m8JS?^rLIB*ziUpBsqlz9hOQ!2Z*ix zidyW0(+lg8Kc6BIpSvj&_1Vd-g=5C|^~yA5oFzU89^9v$)2EQ5M6uYa0Bu7YOv)5< zjYlehI{Jw;AqUzw>2k-j>fyCcml;H^T=2YyOzNPtGUomZ;}v3pak?;-MZvjd5o$`0 z63W<(dHGu?`8bn8wfA-nRkVjysMPB%S)_XWQ@K_>&`%X{P2r>?)}w#kW|vRH!c4ItEfRBeV_AB8H9&K0 z*cnYdlBp=$KRRgb*DB?@uB@F&JBHK#)K-DzRh4C_$jlXm3Fz$`0l|5h%Zeq{hF_e? zVu`0G!wydKE4*7O0L?|HkwI$OZ}J&?synJ7VfqEF>Eou z=N0QJtF%|pctBp|v2wEYurS_jSM7Ap$e^I}PDimsBcvVFTke$w zC4;*wdhKVU^`iXH3_m9YQODd0c?&pbfSaZ7_b{bedwlt%bE!AklVz!!tqEHa+u0v? zN-{5i(k2G>gHHvsruWL$hcTi1{u7}}vRO(>L~+U};~pVdxO7Sv{0P*M00+P;1DD3Z zVWL@S6{c*LcSZ2MZkOUH0M3GCwDO((xiP}+fkd2k8$ZJIB#q;~U$$6=i$}9DZfM}Y zh2w30FiuBND_wqQq>rfNw*GAfiO}TuUIjDd zulbVm+Hy%@$^`AU@f%nR`mD5A=$Xa0J?OJA$Kt{U)Aurw1Iw+l;A({;Mtj2eQ?dDq z)fQb^WudkFSBrXd9n@w(b=6$a3&{9sn(F-B__b{m-4R1pV=*ADoC^-8(ctR7WL!BP@SN!o_h!q`mt03MwjpEOU7 ztNR3zD%yzSiHF=tz@2Na07T2fM!EHd(<=@=HAQHtjH=YrwEE0MN)W6=2N-FOZIIRD z!xQT>-R%egOhNR%6_=ZCabX-^cNE2cRkW zzc;tm*KPlw&FAy@zYp@v{eR~EKM&*ov#9SFZk#3-uy@gp0?_ZB>)tmVIJ)UBdTMCk z9KJ@Kt1%q@hNqAVh&vih^G5=agYt(M&^p7!ayX*O*njIa^|pmu@vK=x4Bw&cZ8oMI z|HnS*3NdcMf-+G<&OSJ(>|-2$;6E17`jP|rvC&wKGuID52gP;sJuRVBQlnpj(ZWTtS@G|lGC5o zRDP1vpVq}68{&^m@yC|<CFehl;*Rt~v7s=_8NQ|q9GHF&M%Fkj_&Vt)v7RGS zsfqVsH;Wbb=o;8S1#wY^F|o!>Cxd#jxFp&(R5Z(i6NbV`H0c+h#QXIRtHjtT29IA@ zl#tdm&DOHSo`e8`H^JD<3xj$|s&uHfI*MYtvE!YVT&1pL2O_8GCSxu%qy7xbHx}d| ztv0F5X|L#y&jm0dQ)zyA8+Pd2?08Ng#ZQ5k zneZOfYN{?%BZ=Y#D6ZXn3{#5hEnt;kCA$cMG4I30$iCvIRjLfkQ73G{Fk!!dO_=n> zxCv7U{!^|`Tv+5FH0X84qM_ho91Q}747A=)R)gc{I=F=W1DSbj1!XF|zyboIofhv` z;7xNBIImDOs5V_ov)G!9@CVn1den)pPfnUbKgkR0IA(9~G-8AJDhhEG;!W^WpHbs8 z;^sz!CH#GM1Dzr;>iKm+Zxe^kTNPDS0(~6fUWS)Ltb448kK)Up#~?)F{hW?8`Y*oF zlf9YINKt^|DY%ULI=18ESM>f>rA*^M*BTL1FBCMF)Droz^5QC|MvX7gHT8jIIo23A z{!M40d4FIA83de4$tbhpf(wgHHf$BMH{+p!AY}A*5R=iTb~_+$>htH%rPbBd53)-v z8wu08O16#nK{Zz;?EoB3ctFJw(l*J-qLFKw8frZLZGwf)$9R>W#KGeG4~wOMafhYK-DzkV7*WQ7JnIMrE#UTfKI!$l%AyyU9%lT6q(k0}=gOmy5Wv*@e6D#9 zl%k)C5MM;MSnhq5Osvvp=}%ZSYsWzd_-DZlnOtDN`4%Ad48uL1S>j=R3_~qGi5VEk zt1$*iy)`Z|YI^sS8@e=5RUg!)$mfH#wT%~RYkEU$OEOqRw$1SFgTvQQH02VEfSLDTgB(|2vf9wB$F{?P%*Hg3S5WGmwQR)w zk)5eWt`qhl^?F7uj2jPdZ+;cS9$wJD+;g%nsLZDLOHQKm>z{njt?z&MZxL6ipK%S8 zegE@vYh&Hc|M=qN^Y!`t&qF-(`=9y!&$qn)QFk2e{w1mru8iB2_ITX>l6@ybv7qfY z_T^3okJ%}AFTQJ{K{$xUMhAqnmVF20xp4XtKN}3%L-)RCH17DWf$$_Z-?}$czFVbk z4`oj)=cSejbLK>tDY5O+Lg864?^y2NMeD6E9Sgq4^WD7VTl5?xcMYItDQrouLKfq+ zQis)qVPX%ebzp*6)~v&7t%5IhTwRhBf)6T(<+EB-nmRVnzsm4&EuWqigWpZRSLRx0 zy~OmL$X`!ytX?@f`KfZ7Hq*e9kSxG+Y_RbkpB?cFz!@u&87FjX3-*KcwGHu~nR;-1 zQa>u!TK{+Qx>Y^EZp=~{r3O`X!&4P+I8i&6rcw4E}T4xN- z+S;18Q2pej$;;qvX@gPkz9e2WyR}{wbfZ)>P;O8%qCGs}2JpH=TPSC60^Zp329`5>boy(5o5>)xY+B$mB~z3WV>3u z$8-Jz24~~JaSo#~w|WOTGPq&(sveyF$3?1YUvJTN4bpliJ(7mhw6M1Sw90|AYba4uLm0hFzxM+#J#MlK8B})4^Bl4n4k#CjIX42{U3vUS;w9ufIOq zUjF;9i?8;6|FEc(Ku&A~t0W%-i|9`s1Drqh-W`c984(gpO(g*k_TzyE?I7oah|d*z z@~@@fsyo)r#UFcVFFjB}P-RgF1D2I5xB`9x+IyT9DJsh#aVRb(y?t2O!?`awK5Hy9 z@LpjFMn?DiiKAEYXS$+bZIs6$o=CB@*_!6u}z)J29x2bwq)Y01(jsn){X6og-|+_B#c;)KC91qgBS1Ncut($y=wPqJpRg zd{9)2PSg!=KXQS~?d^KwlwG<~^58D)m}?I_=9CpoEl`Y^I(cu$Vc}$y?AOB!-Q|Cz z2XZ@^B%?_J7z)PmND=sm#X%5Glq~Xqp;C)SXkQ@W3{m{2u-^|lAT#3S3kD8D;f_L# z0ka*)ARXESe>+4$(+W%Y!|?BRf;x0rLIoMk|#kdvhL9 zP3WUX{Yfk@ewfum$%*Ky05gqqSB9QbjdB%sR|LS*zQ}6}9{;K(dX?4=)7W--bSMpy zdY|a;rIx&_f|Y5tgtnPgq+iC@q4{}eeAnD3sDSvbN-&Di!YUaIGg9@Zu+th+;D-%P zjliCD@b!ECiF>u-o3#(C@VRx4RtLMmlB8hmTVKBbk;Gn9<<<=t0`Jaui%<*=at0Ou zQ~($yF{+|&fxz}H^qZ={3jVS|f8ti9IeO8TU(oX0V#h2N4vj+e z(>UaiFj*#0S&IKwv~w{Ie>-Y_mIZ)aIb^T&1>aiYX9ElBBeNq_@v}0A(aH?(au# ze1fv*9Xn0*<3ZLzA14+wu!-u;rJ&z!@+7p(rx38AeHXZ3^-p_UUTfr365q@k*dmO& zK^6o_{2DFY^jh?y85<~Pr5Mur4;R7gJx8%tN=>+@1Gu;OyKn?wL?@go$I-Rz04Kyu z_7y{#NZ8u8JsGpjg*wU0Izthq_*k@JYAmv|%_wR2Yq($wga-Mu=q(ry^>Xk_$1_mE zu^z35b`gd(jRJzDF2)byWMaF^cN1}o?F*BZ6}Lv~f(XK(_LY8@=s1uOP*k@^B z&1lfD5TF9ysMHE%N7sLh|N#bro#!481nJLDG5$^lfMf&`nL;IlMQ~8uwJ9Z1)H8RF5<5;mI z21eo)|J%LG?y?9??>|5l&EAD|R3}q^t6mHR%W9Q41e{W15Bsc9i^fCX&wt&XZ2o1( zRl7Y6@nHeGA(-yMztEsZvjWnJFm9NUylhkJib;x@+kifw9E3Y@)}&3@0v>GbKkPC$ zSG0m7*R*#r6I9w+XIY}6x9Q8&UNlx;Z?|OqvoD^MrJLOodo`vn->h{j@UN|1NdRO) zw$#Hp?MNnDq=9BD+d`_oK`Q98Zb&qSyr;=c zzU`^WasA)4Lrq@}IDR>Dm+&$ITcsfL6gbn|c$`I)GIv{(?^Ro_Y<|u?nXT%G36@8x zo32?dgH^I=Yvjbb5x!*5oBeSrH^q!cWDmhL|vuiF44@$H`sVAgv4FAw9HLfjw3VoB^cKYh}%GplU z??kED^l6?XX`;A?Z_heP@JZ)-XFpa%dw+h8-@+$|?9(LnnRtFnX2)k%68x7P0rgwZ zq&>E!zV-t8-**p1eDqSOssMcaM^I8SA^d5$a@^r&;mPlJcgx2YPaT9c0QkxI{e=G| z4N$B-iGOzZTLEy+-kPmycnOx1)cwUMmY2Cj3X$`rby)|tBq#%QyB_Y=U{@uhLheU~ zTPkik#Oj(Hs^-x*J8x<%@04AF6FB#Lv^R=x$K#}!gX~|0osay^TN!q#7fWQ$rCVf&uKG^}2eje=H8OBMpvWj`%BOsJz7HT<^cnQw}?Re1cs@v+1L1qftFM z);m9=Sz1lxx;h+3gQ*l*a&u$pM5>Xfy;bYkrvP=16+Rz=EfiVRR0H0*=OIf{+7@4f z|7eBDK58u(gl%+&;mLv1x*;Lx0Q8RFF3WdVCw-r&roA$X>MM&E)pIJUeOt2uaZ1^? zAZ}7a19WVedsvzEj4n5Y?Tww9PfUx*ADG_L)D(lvI!~P-W@A=CXSGG+ib7W43gy9^Dv+a%^@B?ELPblvw6<0+x8 zPSAllGBz~qEwu6a3-)=`>sqohmD+Q;6{`of^riPc zwBXYRPzKR1cGpeV8afMmIvU$8)UhRApP9#~#|SXWnt@Ss|ztJsFrwNf2cC z39+mflfLi0*?{X{blvVHg-PEkH|-XktufD-X)eS(nDfM(Rd8!TY@;)BD7+RfC_g(2 zQ=D%}uG)#P@5ZQ5-Chh`8j|~kizDgGvd?O$(pmZ4y(wx%XW2qT(PL%BTrNe&8{@V_ z5ck7yRDc5x@d1*T81OjkguPE8GH+zg-o6aUtr9TcHJ;pp9+9zP8 z#kcaiG|^FW$VK-}D4ZohVr&4?=Ez>iH!Q1&^yC$JMa)7fMT0Dqr(?44)Xt%+9r6ay zKig%{DC193oYg$t!A)&`GB8ntFRVeMkFSmxEMg%Kie#Zhl<{?EMiJ5`|BWLV`pmyF zNQ%@yVPGW+BEy$V78_tJ3zlra;0ws1vKM1KA(k>TaB3+L)m5V~Ae7G_8jz=DxsP%X z`SG$B+uMy~ydi#JBdlXAl7I$5lI*TU!YH5umy+&*}O%2m-`?^E-cDAp$PJi6bU#v4@ux$~ek0&YTC3b_wMN3E!bqhup zS%`9qUa$y#Vm}v)Db1g@6HM6dMjUt=n7y$DIWboVpcK$NoR*t!TeON%kP{!39#p>3 z!nTU@2p5T5Fwr>tzv$dtVfCTA~== za3ua@OF@1SIXLxqdLAb2+|oc~sM@Evgi0VQd(~l&WmGE3q1^3|)L;|BrM>xV+aZ(9 zZpA8SykeVz&orZhsPJ>S+N>VGX&scC<c?KfHx0@;RcuQf@dyLXb;^$VTsHrhm&U}1B372vh zs}&(Q+(|#7NYU_Lm7m#MOiZ3rWsDArm*UcFZH#^!Cc{ez=whe)|#QCjnGjGPom}3>4@?tE(Q z3=grScqf|e_#;cWnZRGz7&+>*mpX~70pZuxjD<+wm5_xc457&=!(}^BNJ(n4luzoU z@=Cz_Ot7!e9Sd035DeRTJnoO=PYUHGGH1}fF88MnuIZ*B)XhO>;=f(p$hCmEv6Je@?OVJyN8$Jh-Nfo_CIy)t6qV8EyiH`d=yCQ0*iVnNbK)|6cFw2 zlMfj;jQUlGmh?F(TIZg}08pJ_y&OBFofr9bM;A+oOghLnl|K%9sOGhiLa&WKIlVT% zIlbyZt8}W=5_c#3_C7W(N<|CVf{cG%NCk$Z?KC$$-VcTj>j|FLyT*Hj)GP`x^T(QR81KbJ2z^K@YlA;@NrUYZKi==%M%CHQl9*;AnYei~0 z3EHhYel54?f?+vsb|4=O?)Ss?*rq}G(xgE0;9} zt=x_Sdd6oG{zA>u5-H(IfgX+3NEk>utc%{TTj*;ltP)idSv;|hyv)F>uL4tWsWRC# zx37=C7Qr+TPt{JML9g=)hqQ+rU^K#SrNA=);|^B_x^_=4}-0UwDK(;2Ip(R_(9*64suJeD(Z zjEXjnqai=joTl+`Z`=iKuNFuD);O$-vgyOI zZykMuvdc^xTGpNL{S6SWDP|ZSyN$~n9xIZ2bo|!u8w`$%ZMjD$<=l+n*|PAo@hO4& z9tUV^>ZXs-QSSPNn5F?v9iyvC{x*Yb%sR+MobY`@pyWopWGP#!nrXtp&&)m{KI%u@bo$_2`P?_aR4G1nkRFA=Jq}bCe5Q}l zkb`~0^9jnSBQquKdmNO(_fH>{DN*@`<(0Xz#$`!vcNv?=b8a5O+RU z4H_SN7$Ezxhe=FrPH0ydm%mE(j0IHEdpTfNj9|QdW!Tjk&5$|VoIO(Cmy%N_8iq2b zP6E?NJ>+Nb|3&9FPt!wFK)TXlhPq5v_**@|2kY`!$w=%(79fk9qNdZf)o}H$;$?l0bm@W`FKD7eHY zfM|vei{nLWgCT_)hm;!XNDWEuEF?`5`QbExw(Hz}VwuJUEvvH4Y7L`W?VL&J zsTezTc^i7?bdHK?`#I|bUwZ}7B|}Z*z`*D4`qougY)m>GI9H*?qPO_AS)8G-u!y<8 z=|d8=_&3%C{IFQ`f@32fgRouJ>&Y!U79!?AW*&W=MXC#~^W-OlQs40SdMct3m6 zCog+nQeK!iW(1#t4_}|~qLS?8pmMBBuUu$0T_}qsqa^uFh!8C%K;tKHlB|UzsfsYK&eM&W z+w(F7?=f>OkS*Pl_rYY77$KzpyOTBV@QaNtgb2Ipe!dwc} zMypysYt)0^@voodU+?5!^`GCpk$;^O{UW1|1wn2+YJwqEuaZ1nK6_WK)ynl>G!58k zy@EPIN7%*{NuoAW@$LNo+xyq;wvA;`6kdOi#_&5J^o~N=6fe3tp)9Q>OO&k@-KIn* znalCwhDcCCOcI;`Xj@6N#u?`s_RsI>_LF>7)faR(8sJ5g?954w#3InQ>gww1>gwt$ zW14YH>zIe!6=bI>Bxb=f%>=!o5^EfUi+cUaAGqNybUgWl+h6q^nB$P@QCDG_Tu-V@b*@i+$?tqZ_Iw8kriOX{>;y*P^0LLwb6bsH z&ebJ>TzRwxAlI^KsMg57sG$VZoVsT{ZdfLQ#E(K8IzR!l53w^T=^KJGB?T-?73AZp zNa)hk)0V8=-YB{;SV=WG@UV^yJMR*5h8O|mfI&MWnCujxs2@!jQbm>`e|ptFK{So} zKgHuFI06uzN`$c?n_lVw5Z?#(XT6-lmP-Q-DGj;hu1T(QH`6o~ac)PGMFn;@hA8+9 zu$@u0kh?XTe{UVWJ>AERS*xXM;Mmkk;f4gi-JO)=r%pVb7PBS>uTa?OTBnnJiOub_ zQO`_$$4wWSDi4BB=n@>>ief;t2^9A+5Zo!{>IH4LM_HG#9M4Ex62HD0b>F2nUhh@+ zkjz&*R+e!>7KdG`pI0aMIs6?DXTJUWxBYKBtKYu)_T<}3*ziz&+6XA~hHXR9lRTn| zW#TW0jzm%*X6x|uw4H@CZC_xll5)G14U{G^C)+6| zGt(xZ8-#6+!31^Vz)16+9ad>FU(|Y4A6~XDOu#TL<1x*)ML*!Qv_SqVQI~k-c?0N+ zANy_(Cb4lOrrXb2rpcxI(M!(PlEO0{2(o^SJrXpf)yVTc42xAcUNYfRhIzY`8*Pp9 z_Ze%$4zFm(s+O8G!AkAO?V!zO-r^AGD}Cm3{$oG)5l{a4&-%v3`j&D2v-x6eYjOVb z7|-JTXL0`Xkmo;HM=5lKqMyk0`|copPGdj48HVk+ryte4?6wE&oAsDT`Rewr0~n?o z?WD*JL-$tw(7p+Sfp%Wirv65|xrbW#rRQH6pKx0+?o5kahaYpEm8vPeK~=!GbF7!l zfhk^^3k)RVcjkpX{ayIvNvF^$QTp>J_Is3j(xa?VgtV2U0puVMF?nA(x)BFUKVKX* z@#bi=aq-jMF-T&YNp2E|kD>;8d}|U`)bk03r)4KmqiKyOc^vWp*J{4GXzU$m%A)wD zd<|j}Mxr1MtddVAkVsFpg-Cpn|IusF$Qs_bBHRVa_vj=B>6?m?gRfk_s=N7BZS(ds z-Lj5##i|(PI?Gp@Jub&YZUeYY)EX)BIv8^F=EpWnhd+wpSy2ZF^(AOGecppbfNyC` zrJEAsAmt8&b^nz}FLE<-^q_w#Y?`6ky^pTn?F^}y-gx^bPfI& zaQXW*c-cIdvO)MVX@lYpLROwT+wcaH4()`;aEvT*Lh9$mQ=V*^C-qFr<)HKK?U^Vo zNdxXTW>EA7%fCl)VSGFkSheo*v*guVb05RhgL3joq-CGXG-a&g?zHYsJC2tp#M&vm3Q5)p{3OTk;*O8y zQjgOKJf?y4KBEJN3GVph_pMR^l0oMhL?F0FM9nMPX5OHdGJ=f_>=k>k;~jW(V}-)k z98q4_uo8fn-|zKAuq7m$Z}JH+EtUc$QXX4Uf=qIkegQl|BNTuG}fmpgcewr%DGilsf ze`1Won-HU+$)8+i?}kCYg_3SjRp%m8(bW3JRRE2nb%5?n+y80?OBK?ql}{#FVR4%~ zv;1ZfZb^THuN#Jr(E#=pMceLzIi*dkS-1rSg%q-(jf8vTQB);V<_xhmw3MSIlAp=- zTSKLh^c6EkYuvQV%qmaGvlrCEu}y*SLJ`usq)zD4z&r!l9oZGv zdgOtf2=wO{XXub_@4)$!{U+raa<}u=<(s{W#sL%IEm*0lky!anN~2?w@FAU8br!^| zawg?K0v0<8cc@QD6pe!%`b8A7Lx>p((i(+`xz`tj_tfvg4$e7fyn6fEfWy2t>2;Fp z<0a>;+l{<TbwW|PPV0Sb>%b+0 zhY#5<>`M$mucA!1dAS3#qwmi04G@L1g_QPDD)x8;OGvf3TS(oS;6@ngVn|&vjrTE( zt!PC0mW)`;0-h{mjU~nrWS9a{19TfIx+GQpPPUxHZ#ZP3N)ve0Dqj*LliX<_`vr$v zx}XmWTs#Bj4cXRkn`MDjbppUpZpWIuJ`0PGYNll1q9jo#mt7N=>W(5s{|1BDCnib9 zokR480b9Eq9f@kCGnPo7XN|IXNhB?95q%xA$irO5l97mswD5=GrJAG55vbo$It-0} z^m>fsuo!z!)-LkCswCs9lFH(6i$r)+OKNGcmd3qWCdurBTKZ!v^4e+z^g+)tNM#x5 zdHTU1FzOMX)SBFDwHEhUNkhphN#iJFgS;&ed>Dj%H^#$V{G*|_9rS{*JL(DHTfzu0~n zigUDyHOWP;n5EPiqi7Vz3w6qj{WT}a86`7X{>A*JMRyS|d_lBij?hktGzq9e82cXp9RheVDZSsxY8 zFUSKXhNUWT*HoSIFp3LSEuhe2=~X(3OJ(d?i@{m1OEVLVQIf;=?QQc)AkK?m$nkE_ zK&F>Ew!99}c+2g*l!DqWV~3`d1dAP~Pe2w)J7uXLpu&2}H*VDW==MfNKnjsZ6B((1 z$UK3cD<%aq9*!0#C=y{EX<}Ax1=&K~q@t53b5Px7@wxcH@_E~+(6lUK#$+Icz}9}y ziD35mBq2-y%UzGL!`8Yi@n^pQSZ?T741Zq z=H17fevMzM#;Cp7Tup4rl2k2No- z$7NZmG_&Jf6j3M5qk=?Eg3SxlLdY`GcEc7z-g3%sIZxF4#_Ls#YIKN{gl)ZukkiuU z1xegXEi;RtnYJd$pmhpbt2mm_@AxZO&uOzq5vCNC`0WvSfJl&O6tQTUj2x@GiDh1b zvV6%4joEz>gaAl|@)!mLDX(hASqBS?D>n&Nfm4xKbavnPOh)Qjfp4^f#%ZKGy>2ex zfq02MA%pgi`jwKo($vQJUn0$DhtYPGrwat2o>rw`h56!JVq)3zCBtafp_*n6nvWB^ zHx!y-Gx1oG`ZHN<5^02LB}*K?YvxaakC+K84vECayXE)V!DxnUug=eHGF>JsmLaKu zRR8=lmt}jxbVC9K*yyBGX`lS>4F6>zKA9q^ZF7 z?DN;70gIjE4?YGTJZF{N3X5)nQLh6#ypI@T2xaU+{wgwWwEcDG7N9$w@HI@g)W9P` zFf#~vq<_dB`_2S|Z#Eyg=;=9L+(b@4GvEKkZF2s#U-^vj|GKfcSvBteuD{sYSls`8 zjAwEGcX9vsaqj=x{kV?5;X5vKcLe<3vtNK!@8J5^1Gl%Ee_xp0lJ!y9)`}>mWDEJ8 zc{O$z27ry&_beA6U()V3?k#^!i|mmj@f{{6DqIBC6l-MVbPJw@lZg-XZ!2tzs=!1{6v zi*P9%OiGmYNjBz>mu2Iw^O9@^b|PL6TK+JvI0)iUvEnk$ zwgxy9tF;WrsHS`@e+}{Ud!UN00-#mh#}$KTw>YqEIi(3!KBluVY{kA*1`C>#7h!&O zX-R7a2SM@YJy>i`U$+kSntQF2%aW7mn%^bc8k$DSLql=HhTb^4mY1+plk}hQ`jv@X zqEWJD*E65Be!e(6J^s7%C;Z$$K5P8a*teXY;heBol_nD-H7yjBYd2lhbkpCUQAROk zN#7XCzc7@tXjHDO38d#>EVC9G1cAwPMLF2ySbV7?F{>eQi-H*^rOA^s0h;lwoG}c> z#ilzuUnS0Y;jxQ&mvQHkM2u!|Z1^dhkeqcVloJp&cUXwfIFU}<_|2fz<%n*qWpWNH zolQwuJDHTFaa4AzMDH&*VrX@|tI>5i{;b}0Mg;cV=mR>9R%vAK{Je2`z{usIvDe(T zqbAP44dNtTv9nWZ?$4cc&3779I%6nNv6AlL_~+Lb=LQS6uaSHy?2LwMM4|lt18_=M z`qV2Q*@gu2B!mLMu{{l%#A&w)@X5VVAdaf#LQIEWWTw$+fPi;f)YnN&rO`vGKVjok zt*))H8b^qeqL#j53M!Z{Zz5?I3fR&?B6X38Bqc?D;r&p(c__vtED;ZJgdmHmF8NZ_ zL)la2N`*)M)8t=-e}ElmwJsX_KeaH3B<_-0Z-HJ8T8Z*57@&cP2mrq0yjxZqe9z9x zKhg_1@7rA_EtE?;{zlh(#JP1Vk};yKLx2ZP;4E;tcZdKk7~k(l!`x(y@6>$WQj|vGa((&JHeJn#`z#4$Ks{&2m{Gpl0%ZS zf$Byl$!3_mU;$G0;}58Uf1-oLBN!-DfMtNg3zfNTX_`FQ&Xk0&honx{Obd40DuHqW z>))Q!jf>>k>$MjT(YR5`%WSLCQX&;DnW}?X3Ni)3EG0<`AdssaxVHP92B~!>#;(e{ zVbaWm?0!eZ@_xT_jCQ45?IT|Gd5}a}7WN~T&Akg2y}dLx=h^v08Iy47Svi&1@vj^C zty{v(XJs{mwddzcVxMQ_vxO4R%4Mfs;v0^YR?w_4DFV2ozmuLGwa*{JiUXWHmPNf-@C0#sw+dO~E28#Dd z?GGz6Nq3Ukm9DUlvL||NNhdfAdLPuyWOeEjz$Lct@e`M7jBj9Ky)Mh*PenA}PBr?a z&v~+*na}@Ty*)ZUC|?gIXe0mpuex5{SToQ6Hf!sP^S{S9_;GC1@}JNwiR@T#fu*rxM%*5%37V zutMOoN$UXox7VEOxDD~ZD zO=b%!@^B(WW&e)VDuR;l%EYess{f#ClQ?7G)8K>##tHZ;(3&SS8oq5kN&IV zeD`ZrhVK=QjM;@mVeixl)bo6nM&~_P+kV_DDb;f8qmsj_$0+F17Xi02q8eU0RcCqG zNrLsBADuUp(*Vk3S|O!xKZj`c4t?vh-^>*xZb%3zgrWpKY%=0T6ZTRE-%5dqu8Jo2KMg|J>-7i=k}O1* zI(XoSH{heheFs1L;#n|?IL`xFYCI1gcXnTNpKXcgXn>gkVsgPa*}?2D^L%#gy8~S7 z$R+>_j6di!uqLQgx!=NF7U0#9WRmQ1@~}C5S8}OGQ=&j#{9wI#PU^V5Fr85_4tzq32`QlPkL^QZjS0~Ky8RgPi1*NpMq8QqmzBli|#xrx4Xo9LiQ%5 zV$2bAJC2uA$5Am~!ff7b93_N|Hf}}-<={=|%%(Zkg$@3z1Mbi_l%p}={(x4Zi$2c;lC0~Dl$Oi?EGKkve>=$|5C4*-$wraf2~@pndd*7 z)kXZr$9XExo>&zCYgr0_Cv(sMJeh|I;K>v^0L=SjdM$t~HU~Yxles7Yp3GAd@MKP^ zfG6X10hp!oB)w5rKP6!qpDaDe*ypO>wOd$P5#`Y1rhqBt=J<(ycl^Y9 zNAc?DS8?UZ5)@zyd*q?{6?^j%TQJJl;7b%wj$PGStm$5xneNoq{wHb9`Qr{Dk@tzn zD?N>C#|Fve63Dk(#7wYzJw~^>uYkX^hM#C=^(;O+Yo0@i zF0+fJjK)P6~E=0a{XeZIo!zwUiGr{SuNTnFzqB%uA*I86nzVu=_ zQ6`yRG|dSu1L74J8;o%f%1w^86JCamBBzPoLDu)MmDUox0e!}EQC@hUW#|Bl#sFPF zqQ8JQBAvf$dBi9ib#o+S)vQgQX;F|K4oel>v3IJ16q_XWpYX>tt4w&Jj+JD9GwI!& zYgKCx_yp5CQ6(N}L20U4gIMitXe2$ZrR>qk&YMNjY6)^HD4i)S`@r!P64mCguk_^3 zD802|l=cRBWm6+A*Sxh;?~^j}))lejOhFK1X9@EA`_o1)fm;a1ItA}dHxoiJ<2;=! zub2bh{W7#WBco4|nPl}EG0@Bqnk6o>GN};++a`&$;>WTR$75wix)LlUWUXIZQKWT@ zduBojAdV>(B_|2@T6By#C8GPbkVQBmN~%?5T*$Y&%cMs(gmTH`s=1_CBDdqLCKM@a zbryeM?0~TVB|EbyM(|)`2D=W~2_x@a9>NdEkc{Dc43?FwFe-T6kv>rVcdYH(q4$1U zLo(u6K`|?$W0{aV7RLg`W!j*PL-auc+RV6SEvXo%KFK351MxiOM|zw@5HToKW_?IW zjnb#pUZ=w`lG;LWBfr;PjIje>;cchX0F9j^7*c1B6GV{HS35iQF}%pQ zNrBz>(kmCcE8Px;Xi^%qKcEMB{HtLO^*Do$_c?Eo#wQM9w?~rTJIbGI$&yrWAQCOx zrvw}7ieaBpk{f6f$BrSc1e3@Z*K6q^+*yucMkq^=hP=2;@m-25`gjVCW2D9ryX?E8 zsgH{L$7lOLVyMGojA0})qqvrn{p9TQta)~Nw68%-14SYh{CUarXXu{V@t;4}0apg< zy|I^9hUvX!tHH?Zm^nAs7V8AvFn!hWTVaxwsrFN_x~)~7@Ncb3Ip7)fDU9BLR3Oi& zknr1#vg+gGHC=Tls7TDHP>yNFJcc@&a$pi^ya+S7#pLjJVo2YcP4HvR;cYP)+mbTQ z&T~l)$V_;B;{X9FNaT732Yi|W49HzdC@KX6RwiH&4y`#1M^f!XrxBY(6wjI_*E-?lmm-4vaGeCaDC;- z%br1&vT3rg5%FEdER0o@WRmjCWIPtuT=Grm75~dHe@Ug_sp^-uWLP}2JTu$>cyYTj zVH;@W^I~%|>;4b@Htv7ds%!t|Y(8ku`SUMs|8uYLr=R7a8@lC=+sA$0TCHZ< ze{H^4-2Zx%XL0|3asPjQ_y3m|N7yMuH(sw-$D7_SUThYY_zm@PbQ_g3vV7@@@Gtt@ zpZ|Bt?e2AM8{_=HY}PhX_P^_k_z#crFw6JCZ^2bmfPKk3{mMcCMST2Dt_ljedn@#& z!3w2zWQG2RjvqP|ye)^8;uWU~liXo$2AsqLLT(v$?a@Ke5sP%P%F(?7hdchzlHVuW znv#>%GeOwgrNb1RWKmKp==U9Oj#dUi<=Yp+~YnJw|KqHZOqi_mn z%!_zPH5I|aaTR>VVpSsv7kv)0xK`(c9S2xN)xp_D|D-DphL0N!Rw2?6I(XucO0~X9%b!#U3b*8HmWSAl(o9Hwr0zh zGXm-;6f&j*yFqFvS<1lOqn(|j4ADB@ySzldDuq<$_u7}#45GSpe4jBlZF55SW#ez> zdkE@Wk-oLH^%p|AGXd854b`t5?bSy{yMf6RAHh{)wI6g?*HInjQ)Om8)Ra+{Q9a~q zL_Ja%I%na3QBOJdlK&?30XRnfTU*=MGX1}-y;%7Fdz5Ff|6lC?AIJY6`G}V8|Il$7 zyR@tOORFb3Md9VFuB#dK&$RpG4$y=@KZbut(7sGZUG4R+7xq;s0wK)be#NxN>_tNBleU?TdC=B4urB4LH=7o~#e>+{^!m z;=DMojWPUxb8S7P|6gBUoc}(`li~lfx|-($WZ?vK;RJNXAkf0=cON*+WWkeFMuP#3 z=NFgw$DdBz;Y(ozUg80ZcAe`MGlRt-Bt@ov{iFK%07cbmwd53D^+sL{?BJ$wS5i~g zDfRSl-}rt=-wzSJ9>#k^$n-2VR`K3&h(S#bKYcKg*I3O#jN?MMHZriL_x937Hz?(G z=nilEc4Q=OQsO?0#%N%#c#CozB&3Ov;fy>lD9?q*_J>B|_mp_KcXAyXDX$pJ?Ka-6 zG1B%a?Zl7Tmwc0`rysC^aKq5|!Y)ibBfY_TO^dgY#73hD%i8b;RyjR&jSs|;@tF<4 z$>qVhk-!jt9N3Vz#&G`@md>NS6C;hG{s1H;;F3lfL;8;}=R5=YHHPa;m|H=r7(?~R zs2BSuLC5Q{<1anW50vLT_~aSGv9`y6y?kYSf2Gvwb$ny+*VstWmFTxaBaMv`%tzxp z8y$AX$VfWm{cDeahZ=*kUgJX-#h2{lQBPjWPyT_^o6+Pt>)?N0?gLW@dS)u?!&_ub zM#`a>JVRKr!V4f`^!upg*{GS*2V|=bt_Vgx2Kvwbpc8yD+Syp=7!E?<#YP&VFt$FQ zhXEa_>Nyyl{p?-+1gz0WV{~>jh`kUv;=pUCX?TMX+p;vuFSVq-UozlO*S<1G z(2w4&(yKIXwYa!>kWcAR@k`6b{|e8{`#&?3PEH&7`@b6gm$Lt@F6_S^lpcB_$4Lz5YMS zTc#In?RM>TvEOO~=%TXtBgQ+Gs0&5Jtww7T1GMR73XUYRN0GV>p= z`hK3cQj~d;irKGRr_eeisRG562y-W$W^4G9u|`D@ZS-f!Is$ALm3U zTEul2cphjyDN)K8Ma5saEM^2<7jUzS;ljU$5p10kVG?J3j2CX*r#A*1tJ;rBDHzN~_CYWj90GQu8)%2osOi|?@N&iwnVvd}ECZ!4j?0nnZpD5lL2c-sxWRi_02{7)*_i@DI+m z5(x+;CwB-XqbLtY(M{{hCAa^g00Ux0^#q?D8Kc=r2Sr95NO)DfPBc%koaqxfj5*>_ zPmDP`i}8F6}g5 zy@rJm!@T3Rmyfg`wb*di>mt>Nf1xc036~c=-7&i|2?IpLaE#?}J^EvbdcjOm%598Z zFQeXYt>nI3+8w^y@5f=!!fCLYo)+}F-%7_vQtBvcN?9Vt;xiQ&EBe%QhVF$ZB3`Eon{u7pGbJ|qU$1h@%4{LbYIzzwxLDYbuSz_mt2b1=rhxx8xaT!Alm;y`P!& ze`d(+oHoYUe^k@m)H?+jtJEet=zA z-*4;Mz90l}LCovB!*Ri0?crAoYWSIgVXuM^MCiXToy7HtldJnkaKmvVUEksH+0U*0 z=5g!v>|*cam<9RE$Z~LTc7EPC;Gs^rMGQOMBlo2!VTL0RqM2YJk39b|3SxI#{}zq< z$KJsBC>+((S1n)*X^QX_b_DW}mJ6Q>>J{Ug1THkdVW*8J?r@t${X7KX!EF>7XEh zh(*eS(!wtzB5m5Aq;uZ5I66Dv0c7MRQGw`wNJ1lJliMWlK)+0+?eBM(NhK0%!-D#suu8hIS$@juOW0 z8Mzslu=nw~y^~2tty9K?8JorhX`+^S@6GV9mL@r)%-`yz?JfqKRWfhdj5YlYKbUln zkHUA+oAMv(zzWW=TVyycaa;kDDlrneODfW)4)@6|+7nK!6{aMEF30~G0WBBLRL}JL zzpD|dG|Rt5!MJHlwSeR2Q$Q6BO-${b46ox*?MRnUrlJF`SNI$qQc zedcbVjs~ySLR;;CApFtqz%nCu5zNg`H-uV01>uL1$QqSM0O4CG+Bfj(KeGKIR=r-X z@sE6Ch9C9)C2lKup5f@K=SMetQGuK|biCEbyY7Q%!_&oEUHDhUp2X+qEe8r*A!W-c zz&c*Qe0RLpeux$S!Cx5))GxS44F-Ax0+|*xVjbe9E6XA-xyt0*sO=6R?Va$+T3`m0 z`>Q|Dt^!~@ zQ47eR{Q)*It?p>R>{ZpufA9HMNwwUUtpJ+tq-#*aV6@aBRNJdmY}8@s!Qvq3v5V*$ z7!#H42#-@1H28yo7q&k544o=|fO;nb6mzl`@Sr!Qf)l`~6zd0_QO~1-CQ50JJXyN? z((G&T-1C`H|BG}#sr%nq{Qp+BY776rkMZ1R{JCChEFDZg{u^ZfyBPn6f95g%bVJXN zU@LlCzOl41M*gpD)=c^TMQ!WFLjHe@XL0_sIRAOztG``H>5@kM;OO%Fc<=A6H%m|9 z6UMLCzbZ#1`aR)$Ui&4BB+{5)-UOdSC?M3usUh9|HuA#Ti)gs)gwYU9nWoW|J@p11 zzx&ryncau~t9(Dt0wACNudT1YF#Z2*)vB8d{{I-yg8wi0|0B76nDDO8KSth2JHG!& z7PIP?(7VY2!Z#WYm<6ZO-K0c8{kLn zpts-0gS+pX?<{%n=n0n2=HJg7t)C&+_ZfNkCEeyx^O$9Feg3F-T*VNk?Xt0-mj!sn#Ts4(AD4&KBWipm z3ucr#y<9utcg(7gyQbd8XA|9FhxlO$W0ZgYz7#7WKePOueD$2h?Bwwz@uoYB@rk3L78A?gCqQY4{)DT`4p!F3v6rmQ!N} z1zGj;p(Rn8!p8CNvwn=m$zlNcg|WzsKNTf|qNsWW{z@_I7<=1Jm(f`dE6BcSGx@r*o&e7C*N5R>FfZ~a&EG6z*L~2a*xN6woFk}20p3CWZTl#-7WIXf(h}1RRRVC+MaBySIjrsN{%M zGPdOx4A+>aswF$dn;@B(jT?Hc-y^c69UYsQ>LK zDu0XO26n21u%n3wptzq{h0a6fh{?V!_Fke5133n7?rIF^Ww-iI2?Gj%$cbA=y zC2slKd`9=wOVsPZs4qtRW7!AHgmLj>a+!{0#D78P!n{Iq#4CY;p7$faaEDiCo6C+1 zNLqHTEWK1|-WB1GceT$~{4>YIN{T6B9~FOuyq^b2z;WP@*y)bwwVw2hn;Re75TW7^ z%BwjU3M{Z-#Ay{0d{^NZ3OLk+XJ{qV9t#7MP4ZmG7FgsPoID2HR3@F50vNz;v>$+uQ}3PC(9b zkA)z2_=?Wn_!4)lOVG2I>Adh+#~?l?`Xu%~cHaG_AWa=Z%N~Uf2CbcB2)PZu#<$s@B)QKUifGX2^fb4RPyRx>!gJbkr(S5bn&I07e1v) z3m*kMXE~O%6~Fsn&{k^D?nz%-eGfxpDUcI7izRaM3M(WRXOo=TOq%RchW}|f6Bck> z-MlD5-#x|jdgm+;>8Dr#D$kr7cSwsHs^jsnBM3jB&1@L-9W`X5I~+zs_Y+D~u9{!? z-nqKfvPW(Ukt;w({W}RtpZs1AJsp5>JGh2oZa4NqSsyk|rxeTr5#+cYIZE)HAoM}V zaeJ&5xA)1tOQlLx4L$=Kx@&$l?Lt?`IZ4w#J zk&?)4JO#P^P!qpW(@tehoDn6t)6)Rf@RE~E&=S>D!lhj)rm)tboweFoYMyM!E9%`x zG&F^@VX~BENoaiOQzTr0SPh_*w1yz-x{#iV39El!JNSAR?4zPB(8~HeeyEJ$>e+`Y zd&ur=gEUsmnm~S^T(mO9Dh-I_)fB6;h=Ge#7Fx&@r_8~hc-klnKrxY8Ovf{mNh*2c zllU;3(zMB3kjMd(*Nt`N%I^5Y;@WHIVQ4?6C{%29hd8*ZaU(6Aco*tM@!>R44apWt z&LN0Dye3U!8NEVXOQN%6?^0`7STWa+EPcDG$xf-^2V%XLLKPp&$*-|ss$Rh6R;8GlSK^464FiEAidDhz$F6$w1gUC8U{-YesAstBXuff=-#BdwFQHQ-g|9h1 zOo!~pcwrTOQv0m2Phe;HczR#rxtahUVoEFBwuMvw*f+QevV+3(% z(S_|r@w?UUR24u{K2uM|3@hhUxh{foo6UuT`RShf*nd(?wK1{3@X59Rtku@g*weiK zQL8QNKOf^+*nckUKOe{cdmH4;o`0p9 zBC_4MPKmV={<}v1uG?!o2nOH9PBeMF|2<*Fq!9(;1V(%1)sgR3+Ck`5(4jyDL&cUH z{MTu_2ms8{D^&DSQvve6$cioi*z3BZUhFXVfIO(~64qV9y6sp#hDnUu6GAin+TkB2 zK{Vy8(7!g6P(rOlf7aNaDX=}J^8cQ^_Tyl{T!cXbVa)eqe4~f+=n4?)xZHPrP8C|g zWC#x$uin0{9GxDXRbUZ2t&j;w<#4aLcbqX+muWbZ>MBQ-pDT^Z;h2Hun86MZf1p?U zC?7a4*m}0QUHt^rmw15U>{B(|@Frq9% zInm0K9pzn8=B)7nIf9p09K?XoMS=iiXW|&t3QJN1@`N4jO<-Z}HD{97JM=OU|8lP@ z@V}LNx!1sB-0L;`XByU(UFCmIQYT^*m6>UDHuqlV;BxgG!~wrUIDo%9^fCz!AYTRk zw*d^FYbE$+4gZ-djZIQBVgiq<(wI0uI>^HW2u3Kj5-RAX&klRf!3I(r1M|jj-@vXQ zZnOOYlppn6DF-8QvdZjDe{^25K2qcC=Z^T4)4q^7IzFz`=va}JiAq9-qJ_p@1Bzfh z5WoYv_Jd}E^l+xCu3+E} z#+ASI+|Voy2&T`p1Ar+^)uF`%<7XLiKR&+)1Cw^-kW<>URUXLs&!kIO{Wv2)F_r8w zn4AhYk48Xlu6=VwtcY<1(K`I4(S*O$TlkA0CV-^Q>M`m@n77$m4Q*{-co;`P+e&dO z5n&nZc0Qt3ro*Yy+Jot~CA`hd4Meh?n`MhKb|*3YP9YoXETBs++OKWR(au}PH2L~{ z2z0ZyY}i&B{_0SjAn>*G5+S6{GKg34eTRLuwQ%XhR@|}@1aSwa=U~*o@@OgMzX%DV ztZm_27FvxJt~;+PKUPjEuelTwdMI;HbedPUu~+#K+P}gdC*HM7KVJLnhqZ1FT8Q>r zb?2RaqI7a}+Isc&@UU^wx;*-?20JM!O_1lkwXMCmlNcgAV>tFLD?Pt%j*}$bZIM3w-5#mywu}9f_p{Je2qmy667{FldDk6XAhHhVg zUXE^~GSNS?GN5qNsIm4axJ**@Y}JufW>%HB2qO59$5Q+1rL9F;y2OMX)9>^xG6rPR zjXvZe|C95Qha=c6t*)Zt9!Oezu|b6f5t0_#&{=4~;RPlU^#4Ia=_Eg~f=KO^l>+dr zJs5I1g?{4NOl7mOqce0T`H7+o=C@@(H#-Dk&M4yETqF0RR0hKuj0ZG!%}Eo)CQ2nW z3lxJ2Xg?H^;m<8U5r1=p4u1}hjvK9mql@v3$SxhNc43KOMy*UaK`!NK55&r3p@Fxrqe1Ka>Dv>w6erq_R9Z%l`^b*^?6@w8m0ZI00nfvB zY^f7axhRD;;G*1QT8TljJ0j-D>LW_TgBYb^LzM5YcXoo$SHpw9lyb*MgJ_qF)QJ z>;~4>?j^#UhyF*HF1c&y(0LgQDnYl)6qi_{eJj6Z2@|vofb8Wvq6Aw3@rpv%b7PFo z7z~j8K`r?m!z-de=!Um?ze@4~L@$V9e)}QxQ1z16WgOgzc$)Ze5aw3;c=OP&ICu8LsNsV+>yScZNF^3yMI8wKhVaun2+ zU98*9E@sD{!+8nl)gGg$K_N;H=wyUE-^ydo=u(H1@n-hU&nJO~vT5LO!OPs41~77+QQM4VUfRmYGQDo&p0TbA8*XHuj)M(-evzi-BQAqM0(i998YnZb0U8vjXKwl54 zDEfh9-1R>@6iiyS$^oetRJu|iXnb~u{T}c<5DS$lU%#KFL3ct1G{6^$~6 z66Gjf_JjUakhe%NEkOwA?YXzOzvaRLGvT@7G|Wstulxa@i$}-Djn{j}c!ulthp=nQ z5G;6aFP+tBTfBVYa`tK{KMhe_0YMJ`y>brp?l3u<_2F}YXiS9gl1 z#4sPae#lJ`OG-Vv7}Sux;*}=!FGH~ZQ6NnaY$+7eyt@)lqd3x#rkv!+G^Rv_MD@Ty zrjl9?5)Cz^Oy}YxS}J`EiP~t@>;zi`@r5XL+toO zDmlzBUN=jo7EBLh7EpJBTw`XGCTgh=T~rtaRA{Ixd_XIF&`1qlQO2Pnan0>IDh#m+ z^_^-GCWpfDD2t&G+ z-s%d9dt-MSW28WtS*tmrvtipWo@0F zHCy{9EL1C_Zg^|GX&j&9RjlO8-`+MZ{+_&EG)~TbY9#NI#D!fjm7XwidPG3}x8ukAcTpe|c zZ&-nzm3qT08MUUEuF%Lw?T`9qpU?eH(qY(M+j@(ZW$%Q|)_bE~I!7~WZMxSpqDJAs8-V#bGcHLftSG5&FqCCQ=?hmKx+?5!y6bprw zl4Og5TIj2!5-LozLB9k=&2VrV|3KKG9wfL=^jQ@_wWMm$8yu71M51Gbo zk$1GYD^nE$f-EV_@oBpF14Fiua1GmT-`V3av*02XmrS6~th+QZvcR20=CfF)st+d6KXGP;GY z<#r1_$gCtE*jZO`B_*loJwi_=I|d__ImE0&j}jVVwe?8m$V54DVZt~6WdqIHcj7Os z=NFCFjbC6*zhM2Rl%)6U)zWvWhEFK~Kx3N92=XaLLns+215llBe78a8Gc@bW5B9mI zO;lOdrBtSIrU3O(S@e0#$Trze?3d%di9DU4Xj&#ov~Mc1xBu8;W)Tv#+rl#?QL4*q9D)oEoZ~{ zjSJf(FHGrMprb`8f-TbtjQ3gY+Q@b9Gu+AVZYwUoVx~<2=y)G|H)~r}phLJ>_1L*1{oOGt zDhnSV%-=VjiRkI16yA}ZM~&1WEu`cG%kP*aWm=p{>j*iCyv)#xS(;omiwc+*=v0n@ zmSvF6gEsw2J>u1@i3A)1#f@Df5%rEcY#=bzdCr=1uaCXKN`mxl73)j_7WV%soXcAw zJCY{FrxXr_=#4NGMQ-);j$;$boqyLpqaSG40j0~YSQ<=3d1psU#YYE1&AQ`c3H}-| zEa?Q}l;{8@b(uhs&3u9@d^K{A!GDqiUo(b=)JQ-3@eSXs@QG34gQbciY>ugn9g6N2 z`Gjks+T-Z-ZA0~9QZlj$%B|EL~YY*YG9UC$CWJ)V$CfAq`S~nwaPVRX2kpVEIsgiTmEs8Lzqlv%49x zl}hASv{EIvV;#EqMz_hCYlOBR_ij}*nrnze5_aB1EUB-#52P6ooYqhQtmgnodE(p2)mUOp8?q;o^TQMXC422b7wurP9js7wq|Hc5&<`BzL z&Msn!&T;?KTIUjJtCU8&%~4!tr}-*a{Y*W53t89Rc%N~KrrW|CPQgHsj-LcaX-vs+ zoCZy~+jWT}^z^48NbcG1haFs%2{A^!(<36EwHndeULEi4|A>ye4v&7p7;gWa#Bif9 zVeGVOdM+W6q3MZ`DZHz`$LXautOhXP?iUr$gu-ZoOXHWo0OO*q{(q;lo###smRjP< zyqv;@_!ruv71LfY75>AyPHXSt_1lxiY13R3{6WY2Y=Gj^6WbgFvBCAd8HPrn85}Q?PIKzq^btfhfV0Hg#={z@JkZYpea%$RQ=bk@L z_GmVit?whL$o7O1!38RQ?m>&BID$qYDZMP{S|u?=nkFiPQj$D4T*qgpucs4q4!N4; z9z7G9nyk*HG&!Pwnhq$Ve@UL%`lqQjX6R%}HIlp8O{-QW+4Hg^M>=tQ-AM0!&E#== z;Fl>VN=7%L;jY{w<6p5qHgl!6$;4<3AJVjp*+ongqsV}ELz zR(!3}Hkl6ORnNaZyC$JsniI|xGzXKsDZ}q)n!((e~MNMxp=!k_4W zEFIzJ z>!EKz1N@g?0DPf-=Y_3vR(+(=j@t1@MZvkh%g1B7|DfTP)ONa>e&ttDPOl+&^B9Wo_NUa zsm!)q$O{eEfCyC)w{BQp)Ba zxCc3=y}{Qlr6_0Kkvv-+&$sTa>y*YY*f$|K+Vq?vV|F(uQfyj{ZzkJH?(<8k_t;Ld zqj{BqOt_1s3kYAw`jA*ptfUa`KLN);*(Yv{&G9QKOD2ZDhhKRq==YsSpeaN-7oF|rfa1d{=L z^Wr!qKc&*g%1~(tOD5D=vQ#SD)bf-r38~9iasy}{{F;$f0sa)W)$dYQFD?dYsc9~s zI?YVjGSU`IeuceT4=#C}HOWem+1rA9^-7h! z$6@AwGt6bpbTIeuK{q*^MBj`!aVxt*M$ zFsDm@<5Y)pRH7Xxp88nRGilLefF^dob$U9{?QC-i#jwzwgi_cQH@f$hA{8xd9IYg6 zTM5Gwg-^k`J$_#jENjjqD=!7Ji}1`B-Tg+F-B6x!bg6L0=#CjVx|f(Say)J9EZ1Qu zsW4^Db1h5uL^lxq*fZGL{7mDFyy-rg9%28jDtfR^L(jvr<*RwOLh##G zc@;yBw3UZmw{ECGcktFTv}!BH}CTNyt2#F3TGqM`1yq zzPdSgmJUg&1x=sLn#rBL`BD0(FPOw&F$@1D!z?^=EDzqEA0O@G4e+yb3`v$nCnn^! zK*FYpddd`CsoaVa*8i!iZk(U(zZqAz9gP#!e{yzu);v2s+BcDt(Ng5K%|RSlzTv%v z+%Z+G?7zvevY+SJ_Dz^f1gVz)R_p$8<1o5c3vVZAA%)keS~%5P$Qft6k6`5j{NBPi z4uH26tmXNwhNL_`@$Zor3s)TX+!N;McoWw$bidQWRRt3@uYo3#Ais`o5%*JfNhcBb zh35(o5iin~Fh=TF(a{84&S(Txlp{=5eb<(*aAt~vwjhii*I+Yowi%vM~iY9x}E!ZBO`tPBVQT@3++-8PYe!;R!Pp$ca zjps=(IN8Tm2CKs)buoW>`IYgx@X+$lDZ6!e55*zwmGt|1=^8w&fo?iwRiNInN|*0q zc@elIs|w>jQ@WOGsAT}++At2&cuD&Ov|b=8v5Bo#`_=XWf zZ)m9!9Uqod3v3HyzhQY2WwUUm8dj&<|A6JW4^y-Kl(Ry+8F9MO9#+bery<6|q2le0TpX$Ts(1UI<5g=BaiufqRixtDYGb~_`6cvRJ zUnm@rD>RhMn8;IH<{}sR8((>+wfbI)yXcmLWoz>zBrc+2jc8X^P!8ObgEnQ0snwj? zWuic>$VUGAGQ3&ujb8!tR=n&bTTZ|{LL=V^wC6ics@ms z!ECVY8Q|IJAdqj9G}7(SK``(5Bqct&y%b1+rAL(g`EzwkH5OMI7?WV8IxefNf8+XA zRkyC{=2T4SXM7UV3#o0|H-X>wq*FGrvv@`<2&!CGX-?-Nt4{5`dNghvi{F2?syk2I z(CrpEv?iHbflb|pw9a)+$w2iG-sol`?#~iT!ML?cw6T1KzdycvuV`};7N`x9&H#mR z0_lE`39t`>uQGnBGEkPDxZmdc;sobVEw!*xYugoItJ4djgNaDHOm!|HV#N|vOMOcFqAczkR ziVxYMgQ4n>Qb6_2sP`GPDXLvg8X=kBG(d=WBqdonep4w7UWsaw1@+Sn#snPYi2mFIB|l3KNWAc&VV$I+)2ks$l}9?gut0bo`U7{tCxN4TW1a5gnbHX6Y4mbPZz zBNUyNcB;1L%|aM;b9J|Eb^eut!L%^QhF}s~1hwte)om+WK&b$gMHWsu5s+sWyy%Uo z4+OL)rfh0k`P%;!BG6=eJC&?z`_=C$)wOui;+2ja#kMM$%zTkiQubAWL-dGs6+4wB z+sWz8vfB9{%_zaWb{%ah+Jk%G(C?p}0PP*Lq`^woA-5&7DmTGwSt~pI5(IIoUw-*T za#c3g0yUQ5=3Nw=XX4YIjBz%{H}8Pq4q->(E*iSPjo$bleecu3;V)*w*_*RVCN5As zf_y=Nso=3ly)J9SpHk3Bn67@=r;0HB+v54FJ~uSlo$lurY5iBvhThe|NI#*2S*s*izy5guha&cB605a;C^m;M)hp2GS!ybb;9n;7`;{?6?r@8 z;i4c^0eJC>M=zuxmF_1DcI#e;C}G6`!i#!B3iuWU-T0FmdQeNpM``zJ6l=&5&_SQo z3>a{8;1u>QoukWw^J?$%=&}TL{Cw1WbN06B{JeK@v3J@$YFs*J7ta3K>A?}oJ@9tu zfF$PpcyxMDay&qlhv#`LN;m*XhngM@9ESN+0l=LwzRO6QJ$Gu-6Vz4j=^!Qqwj zTBBeTw&|q!9j#aeY!|RT?76q)_HbBWiqQhDkMfl)C!T!mt)RU`*xoUzgk zVGaHigdZXxu`Bvk7eCY*sHKiKRGO(&U^axE*3b>(+sYM)MxCey^xFOa!_g8x@v*kZ z1JMH(a<7v>qn5?U>UEZ(1wVgJS_Jt8hS%-2^rqXbQSA4kI{ho^WH4hK#*d!t1Fs4P z2UusX*Yf*7HcC}2@~Eg|H0-!Bo*x;d*zHSx91q_S?iN>C@rL=5gYKzhKvN|PM|)u* zfZXGmc>U*Ga+Wso*Z;MR+UBOQ{#VyF*B0ylV?0k%d&ktHFYvhql(oO){HHq@VQA&G zYIP&K)R@Kj$r2T9HZD#sVXZq*SHDA84BuYj*=gha;_Tq9y_IjkfqIC_}R-b9)fNghJIa)YJDCdOUFbp~)V#y^@ z7iN|VJH^qC@bJtZFgfDVYqMHv&_EcBu5X+lWPI&T&?Yra8Z^8&WWd&zQd{t8fT46l z+`r=r>W<=@AoPEy7DYw2A{6Ny+Pw~476Vyb%T*Y>Yq#e#sP+^bqXG7k%U*7q>Jfkd zE+DU{Ct%VEruiO^v(E3fmnfz(f9Vn6B@(hQtTl-lAQ1vf5><&S@mx4`W8P#LPjy+O zbfPNC>%AuEIRp8YWxV{qIBU0Jm6Y4)f=I~H?j^~u@cL~M4w#%eeIT2VIVIf4L zD_9Ka;0RidM(rC8S_$J#69%qs8T>9)u3_hskAy{M6aWj2Qgq`Fv8t}$1(bqB*2cPv zo7HbusJ#GC#IP@G8pXiU0A#e|LR~xbf+ZvY<7oq< z@szWx-+(I8;G6FIbVQ622m0k7zrD{^!RHR_B{+oR9{K& zq^QK`D{idNrWm$P2p;e2H4p{#g93{yz1El-boV1;?&S7^P3FGW@m+S&R_*)GApE8n z1xmyOHL)k8yJSkh7K(QznGg(tyl;KC1Kj1K>-R`#Ol>_%$Y+rn+b$<7H{lh6>j5rs zJ1f{8-$_usapW~|jH^#a#9BvqMIA-x12>bzlEC+Y>RCy)0|ud~<9~+P)eAnYsHiyb z$dCzx$s<;xf=LV5j2#gi1EMO12mw6qJZRg9le2@3;A8+oVk`{XqG7|S@#)5I->4h{ zMh%@B!ek9S+5De}sR>a`@z@5Ub+olDiq%NWovnj9;LtfBTN1u)sxFld5d2>R@IjlA*(a0yD zSZyUJSerI9M9&>AvB;_dh9N2j8L~Q1Qf3H-HG(<-ZpqPMCkE_<^AjPS5SA7t|85_>}M=N1N8e+@(YnXpmh~`wm$#146rijT|9oGKm28tfE&1Q5lm7B)f)E zun}s5yZ}tPghO%V_K2WR`2%<&5oI*sL*U?q&@k^M$Uf7)3CZ`)>FFnPHd+QBpSZ zBL8|oYeJ%?%OFYQUWHRYy6dR(wp_4HXhR~GT^G}Fykw-J5qW0cXqSv6t~?Kqh1wqR zcYs@MNSTolUZxtvJ#4rg0M^-Zj`FcG7X@otD?6`I0K=9O?XQr*oXZhgdO6uzcR}i; zQ<=2~YpA1O$w8h1aFf7Ck^?GlT@(g~UJU4wlnCsw*ZJh5JTeFdt3(13bQ@n+@yzNP z_gulP+ly~kyP*efK8S!H15(STS9`vL#3sc~4T`{w8zN1on4iMthodVf47lXF!cy`D zz-H@kL|?e*q3-##t%2mwBwnZ5w5;~TY{WRNE8}$TQtZWlia{!JO+Q)z#bR<2h!NXK ztvEy0U1bnKz=zsy+>ahfgAyd#iwESU3RefO2V9x`%aqYIF22eS(fb5evJ|R+s9x!202amV$3CBaMgJtKai)4^&p(5a3 zNZ)d3V*i=};a+2;qL>&T-}@JnwJedu!yt-Q32WFBGR=V9A-&TvPS5=mjrHt_1;43nN!7B5Z9y2H-&?CNAS1M{JLv$;8CPt-CGA-1@tV4CVphAgaen!?2tYM??XWKh0@)<(eih@epFfxkhrV(a^Ew#H|0w^FiyBCIGx*7rO%+})rDJ1Hgr2zFLa z*5RVN!n!*Gs=G#*5k$5}fdTfRpUB8mIXT%_;*;vFdWM(`-8NfhWwTdGvrG?^h~BvW zLL~sx5rrXn$%HXRnqfQ7NQHo`9R-DBrMUgSCY*SzBD3+f(s=0M$!AFj+KL{4b`$`V z*+aE$*=9lk@)%ncl@NHH zfCOMzf@1FSlFh*|R+cr^ne=LIqOP-o+)UB}-!|f?7f#QbNBfO}gLXaa7#e0GZw94w zwJCMJDU87~byE1HVN>f8TUQsx((TX|RXxSFAs2a-i<)G$9?tEEU$DMVFG`bOSFOj6 zXe)M!>|Au;??$*0(~bmqnPdWk1O?631)#2gGC{a<5U$ZzlnceS%IGz6(`LG^(Lxg~ z$$eb9%ph0DbOS+HvY^@(a-pI(<2woqrn=^|At~dd7qTIvGuu@K%F1#xKaA> zT-d@kZ`cM7nVJRH%CM7!!S>=(a|k<+Wbcb|i~$gzX~e~DwKD*@q_~|9{tj`Yq>`pu zjewqGX_84%VnYzYXlUJ{tr%)aIvsD&8TEybt5J^NG;H%I1~tXz2+Kkj0;sS~EYf}9 zt!R=J!cmG48FI4ENUVrT_97(Z(xCv85)4h6IwDvL?~DpIYWaK=ay6;gBJ?ZjLd!7~ zt4BGW3c40}O3EDS(q8j6V+W%u{N%i%3bAcfLzsY&IwI4SX(^{O8z4?lx`sz?aE#r9 zF)o|5OX6n^Y_FThj8R$G`QX@jpT+HeR;O|tlW0nAO`%iKjwx!fOjVe&J-{|itq>Co zuT<^!RJ%GZkrAK@<*+)KsN0cepR9t@AjVSixQJGstAOq2a2j9J))3bh0xlZCG7)(l zj~zYXoKQ!GH^l@Hrg{Zb%Dog?Owl9|CSbIgW7a##j3a(5krH~>ZpekfW_&VW!5dvltm-i z=1N<#F7?Tc0%rX}Lkp5Y(8q&vga>d9l1Upn$p<9ate_S+rTZ0gOAH@hCoF4&K-Y`1 zbKpm`?ZR{8uJbcUtAL!_@f@${wCz zKo^G4tWT#KbPB{al?L6w0EWRZ^iiItPIrOM=$;o+V#0_OT`bdLMiB^3*kj4Y{fJn8 z6tsQ0(`MYBAM=u`S3T!V?}h~xeqV+!0z)r%TH9MG$wT*&rYTPJNMmWg$YcpTIq3OUB>53|*QnP> z4oF0!F`7d}D>=rZ#8b6(1rp#KMww7Ll3ZuRzW4(^qzbdu^bW<` zgLwfL_PiG`(!CCX&L_X8X(XAmxS@->N0b^y2s`@D8ij13a(lvbl3A4uGHg@uumR~< z#R+TLi-3TTAW@(OaoxL_L7KjSLkFoK+ zWFc23$j@|LPM^K0L(1GEJ|VESZ-Rj7S4oAcANi9$7X-YnM;r#&AHhg=+0>CCQ?PQ5 zcuN%M^#^F~qUhKda(e=NC%EcywHC=X6=XyxCbM%L=n~EyzAf`5Ta}xVH^C>|Ke1h? zL>ggLsX6H)+1U(w>cNW?(fJ7sX^8n} z{3Ch(|V z^wlkwMwC9?A{G+FO5y*LLY9hrDWMUx+&DeJRo7;*_oa;;7fBzJOA6DE|Jp`%Z883j@ytB_%p!Lp zGMIk+*SB6Q#{W^C`;I@mse|T-twHBQ3zP6JmDWc7{g2w_R&`w;|Mlwni^ctqM|mpG zmYiqP+yRB$_q_xPRowd)DAY0OHBg7TNISI2FM_f{^SBBM)!hFsC{!}H%b-x#JZ^(R zHDj)WI?pOgOHai~=S$o_-0mtL+ELu;`B&N}bXco?@B`+@QvDWLKCw7TYIE1brs&`D zjha{7#6{gHR$*F!ms8-kDe=UD=@3od0 z-krjmBlrnJ+h{f}n@~T~$R*Aj5NP;Puai@yCEcro^T(3K|AX=MIJidlw@s)BQc|w> zMgugAq_dOQxjZ{*pzGXAXUC~kx5wl@IlEADkIjDh=Io-0`7!&}xZD^5N@T8%uly(U zF|U+at8RP``0@s$KKZW~X58p#lDpwJXuNv+x^>ck$#j5Tlh`#?a&IX=*4RgwX{X7@ zHTJP_adCE$d|hW>5BHjT$H~_X_LaR~a(CG9eY1q#lKF50fG1vj6LbzogEslI?$ql- zQ}q%(a&TAoN~ADnxgTAx>?RHnl^is`)UaYD1Atxr-a6eoXPfuuGX7$%SihB96?Fb@7_CEeN@9E;%sT*bZOD(6{#{H zLxAktKbUdm9ePBCa)wJ5?)-AVnk1h zbzuPl**C00iKn|HEs9kK>C)5amGnwY%w=tZWjZ`MZaB}n=wWV%jTU*$iC3{g$fOpB zdH8{>cHc+j+8tVXm$XFA&xHpyf)hTrVh4j%chT^t2zg7uZ-k3ec!d_bYT!@q8*Sk1 zrX6Sjgk_g*AF+xChV!Ut+DUvu4comS@`^H5b4Ntjy<1vp_gs)G#{&CvAR@F4g!Nb)#;Fo=@!qMTNMWkdp_&nBq# zy3w@e3rQ!y0(Xi3H;g?Vbi0Bc^7AsU@;v)pJ{S`<9~QL84l2=K0Lcb@mj5-gOA5lG zbk*NOH~0fuf^(+~Imncy6i=C~f^Fydb3aA%1Mk!R4TUKS0SZ9-w@&f9-@kKKo$uW5 zR-EVfN0|Z%%>q60vU!xI5(8oHXLQSqxGU;QD8PtT!|Y4RQ9Dm=#`I6nof3ofO#!y3{Up$jzoH=rSrE&rMBAibo5**M8>hNg zLtg6+|53)vBEZ(FC8LPi#3<@{-mr)Q*vht3c}AjG-J!2e4fr?;_I6C68xVtbE9^p1 z<;v&U0%!HJm_HI-z@vJGBTJ=n9!e>Sc+aDiRF;H3UfcsgycjY6 z(1y1~q)d?0#ZasupI4fw*9XHOGFkBR=Mr|iqdVD07fm9)&M}%z9tSc?sUQ!SF7hX! z+^L`}PS~fPb#?~IOlojT7vI1(u~z+73gHx>md5S zZzZHznxT?{d(|#v_T_Nz_;Q*mSZukIBdQ0eBjt-3E@rgnyGC6bQ1=Hpw)vtQ0VrebS}e#zIJr`$C7f0Da0!lCHv^K*|_*= z@0g!@R;v_Dg^6|5axLP@_H)_axv1KO8hv_YyY?-uZkIxn4sgl2gn8V)VZSp(CTM}j zeq@=?21UG($=7X4rI-yFsVr1$M&cQ;64H;QQZTw_R(mYEpHWT~$MrF^$S6mVC~cEq zjv^HFB8m3>3^tS1UHVByaVP#q0pryc4)C8Y8Cc*y9@$*rKcC171OM^KE~9X_ zo!goSf6khMCB|!`D6ymLh2_3d*}({Ll2Y)M(# z9Up2sG~@5W?$TaOL(WTk-NH2;<8*ToduWi%At2a8FSv1eV0FVX`aqpcx0TmrRmT%k zNXP;TA}tKrd;fknUEVdQ?%{f@wvy4;Jodl>ozKJ{k{SDA7gcm*p$7AHwN`SfWT~-U zayCe*4kDp-`ZL5v%%EknwuYyM(yS%ZJd8?FtD?8uBnATnV`}!l)iJY{cOz$1lgRKz zo|#S#c&I@vmo-v(C6$rG4EpHl8ka?+2;-TL{ePzEKRx;SpY__-dP@JZ{$gvP|9OmO zq5oOvfBre`|3?ErYDZTAnYtv?^q(n>3d(16V$(;@8qvdD1R&{R|Dmn{aHSBF1nA4L zd*$_@}B{Ax1@n~eqKO{JynHXoE>kfCnpnBaddp#c)fSb zQP;|>u>p^@#xHoa;q0fzg_6DcFMjjj!EXROg7N>u+xYq7KBIX>$M^j%o(XX1Q0IBNLth*+>)v_BGla8%S zdhg^BZ4cFseO>m4^Sv0N_A}#}Mw{OZY2WKwNHW|hgY2*7rieN(4GSRHd$0Bn8i%jn z9R25y$0w&}=YPAnY`*>J=U@K*UsXEK*?RH)4}}Tlpxhaz=AkMq@{TB?P+k7S^Fbs# zDQfuoipwS=pNYvdl(R6u9ldhPq{*DPVzN4`O_a-zk4}!7V&bZ2th@p?ZN$LX=M4>i zf+Wqha&9M7e2PC)tbnU{&MTiK04D>_K8TD!;mjbQCVch zV1;$(@a^e7si$=NUTNE#YAf@6hv3GCRS!&U2=Wg8sg=jT#GEW*7KT)cROA9J#cGY> zWJ6Ypw?oinInFz(%uAdNQblDpQDKs@7~81wqxuxeNESVn8)!G1wEg;2gM>skZj5lF zeg7d+TDtcLr6Ib{0Ev;2UW9>5=Z=G-2b$9`;D&MBFrYT#{==ZObnjtEL-eS_plIIa zGz_$_9ybo8v$_93sBPVQBrGsJ>QJcq&N+<*sUXIU1u3`gKNf0R_Z|xiOpiJis+Rfw zV}Y_9w77rcwLheXg0hmFnTWO&^+=O%ryLTq$**U*fI8cw9?9=omnnu8$geO!y^h}Z ziPsV3e(vm(Mv;ToY?DUOug+EI%D${O!5C!%^;eL(5?%LMIh#rXLSOB3he82)maI_BE{>k12#rKUB%ZWXr|{v6%$HiO8#zD}n-1 zGzsbwB6zyt(p$anU?sItgw!dZF6U1ssa(UcLhW+Miittv=RagAj23z!GiY@_G8085 zK6E7V;++zGE}|BlUG8HC7xnsUFFqHxVO%X*7M&bmok zCQ&)Bn)#lH%C$20G{$C$Xdap{SWHuu#rf!ioR3=lvQ#IXXN0xOp#8y%$t8z2&;B;@ z!dosOM3jezpqgT?y*SL9Yew@q_k%1Wp?;)_C}va8yI^6mU^$7xPpj}BJcTI^?|PB5 z3XG*v>3AP2qk;dq!a8438?ns6EHbiFg~~uBWu&`tztg~>-(jc3VJ|(rY+y68OeXvo zg{R|{nt9JaAT)g*4awL5O4=wQT%4VsHxBrKs%PNRRJ)`UnaE}+u`ikkt8B>`huG{~ zli@a9en#|ii>Mq7vm6SNJ7F*!dL0XrIfAtkv)E<*wVVP?cmE4`Mod4ZYGa1@Pt_M2 zi}*i}@ys~>Q$&B7DgM*?)?)l0<++}K>ie|nUs^6ZKA z0_a-S1<)sRxB>cP9#=r0OmPPk^FEpW7N{&XhkKw;=5i7A$vkg@KAF>1&?n>Xf?}4+ zlT@T7g>&2#Qpx-_rt0}hRGCr%$ys$mRo!66l-G{`x zi=qY=_~Q>avz34|D0b_F~s0yr`_+Y zJX!kViBx97hqBin#<#T3eS6cO+hL3?ZtX#TJ`gbD`b%`Ua23^|25=;1pZ4cUtU{BsnJ`lZj>DH)_}K+8jJ=r zQ}*ch-8PS6?l7i{e4I}6R_JP*HXwKe<%V%tu&S~5Kp%b#Rwe<(XI{l8${S3PcQih4 z^|Q?V8OL3|{ldyl-dK67TXK}Q9=cIWQ_e(nc}h)<*{iu$s<}3*nY51AN*%9ftOJjw zwl-HJCF`pzs)h6UVbf8B4tDOqDl(W1yl$sk=rKK;m=u>FYQ{xqwuJcs%wGqxzT86_ z$Soa7`Olwg>nUpka=i23i-<--fKnIO40K z+JCTrx8~nezKNZ}#4|zb*i^Hj{QXq3q5QpEIONV`wt^Fux}K?&vEM2z=51=;swAD7 zyZV{*mp-LfJP-BE`TXz3)<*vMU$ypPW79nUtF6@*=YNm!EYANH=YNlR{?{dcsI;P< zUmTq_TePmec_Lk-T9Te*I&jr>_RK5l6T4f~C(^Z;Di&rs7keVSi-{#Y+r3yiNBWpU zhzzQGG3AryUyKQSS=M5y6znx%$QyM0E~Z!zm^1(9!T;$%_CEZ7b0f|FHy8Z>F`fng zU-17g#Q)zmkB%?x{9jL+KmUJ=9BWSepE&mT6+mV)0;y%K0^9Rg26Q~y=KuZp|Esr0 z#|P!>K|YTe!~fSeU(^i#zp=UbV!{6(<9Rv->tA|$@6ZoV?;rW$>BNB_oJsN@9~OD za1%r=!KI4aULy$Th6gX3z#)K0Lxy3FqF@xZNk90G+atzMku-D02AAl{34leph>;iS zcDR|dSVRmmQ=`|FE?y-56oellAj>QIRu@0i8mP&RH{?)NDlmJ(4uBlSx0UN4xMsn5 z>a;$#@LCE7)B7C5pt`-5D9pfVGugdP{|Xp+NFNyHkDi2rH=luGxt`t|$LeNcfn^=b za@Tr)EbAuw|FT%V4ujFKSP*#Tc*URO+i8b90VrT{v>2mNQa?*>qkT;#h-mvuFZ}$O z!~Q>Ei`L!$Ec)NAt?DBF`=dOI{r_VB|AqGd&9k#(`}SW;ng8xzu;|Cz{9Dw&Ia~jE z?EEzp=FI=O@_*~?zj6Hk#oAic-2cC*tuN019_3l^{{{d5V)y?P$o=jq$~L!~R+Hv`?W}EX{Ww*TPtcoS zICT-&9wzs-&`63EIR@b&n(Gxvai8!(Za^B9Gfz&ja*OeC?ma@A&!2xCw;2}~TNf8w zB`I71A9IeP#%EyBM*~R-)@XnIjx83@GWw&MhA_zg+(Xiar2*md#77^X2F zUWiiWv`h2qmSh*y#Pnv{dcsxcxgV5ocV7vuS+4XGYEV3QIdpwt;alSU-raR>ydFp! z$B-d01+P4#&&ZIR2w?I*V=y|9rurllVQ?zvQxJAY4#EO|6wpNZZ3Lo~V)*?J^h}2d z0<=z-Eo&Q8hTg|}qzLWuf zwpD;W^dmIQW`C2<-Cppi%{|FMD!#6YcLin;Nytkpfh}K@?gsrUynISO`~l%mNoGE` zFrEKO?BsLq90>8K^@awJepahBnO${qMuVvg;KWxBL?b0fZzbcl0i&H~oSLr;(+B9dScoWYZKL*|tMseDVo%{>h)(Bh>pjhMq*>zSFvv$rBOz2k$t6vY8 z<8IC*R1ABso|i$zuV7N4V-h4amNA@#gtaDSCt+9=m`~)ytut0S1~%Sn~4Ff|nT`l||ui0oI3h8}{N|Sg~$@9oU+tWdJK=zH_go z+ufewVw#stu6ATd&LAdpADxpGAON690yMv=!iT$p;Cf*QD{03My>^VfgipaJ=0c2t zJUYc=wXN+g*KD1J>M#=Njzggj_JfYMb_udpH&Rt3k|Nl@jfG|ur^on=O+iO`Z=RCRsO)Um!mr${>PrwI=T)EC&E{ITg`nkHEw-h2cF!*E! zG4F}mqz}+S{=`HOFeCkVgh_}<)B*dlGp^~}&q2^EleD?_8fRv!d3FZ0bNc#=OwkQf zcBOqR&MP2`IZf7$drek%I4t=C5ZBv5=n0(zs$!gXG$G&XlQtElB)<-onDb`;7)UsC z$c1Ii8Besj*2_DhDNtG%GDoB&Sq_`Ts_Hcdfk!iORF>vr)Omw zd8|yIRj(1YA8q**)`K~bt`IRAbijD1Yd@MCC)w!f6(CmcS3_z@GHaNHYuOkNq3Csj zB0>uz1fz}I-7L0Xzi00ce!_7Frn7G}Ofm-REcNvsa>nJ+e>G;1GBnucz|1x?nc3^P zF|*B?nb~z}@~39x^s{ku^4WNuGZBxoCZQkk382rKajUA%sK(l~8?5$XAb!9~v5smEujDgeA-8I~wFy zw-SA@8RY@)OXxlgD6#HbvN`Fz+dn&K)Sc@4DH#&k48&otjE#I1Y)M8=OLL|i#B}^< za?E@|mZd~a8{a=p$y1K|__5|kAYaF5Co$ZnLC9ZcylIKTkAKzW=?7zZdgHkrz8X2p zPSf@0W#sU~{p@rGWJ?#ZSmYq4-C*$Xpv#pFxoecIcnlqzp!oVdSC1de)q}#R6C^v% z=GYa*rNbFYkAoJ=LUw~u7A>3R+C(F=gpG!Oe}pz%7Jzw%IdXc|Y@NP6dDXa>!#StD z`zg@oQLXFLs#rPvt5%)U)BUrPlfBb}FKLHSs~XIJnMBTq0o1DZ(yij9mtN3zd$Hg5 z@}_%8FgtFq$0j?hC|r3mey-!SC^z(YW7pUeE=TEhCuIP&s>uMbnih0t08D9z-ipE~ zH(4P^X!g^0p2huB$|eCQE@MHF6YZHDvR`dN+Pn3&_h>d-y%W5q>l9fH8J54$QkQC# zb(BbJ8+4N|xDI~XU;Vb@eEX*U?MeOH%ksBq`AQWl#&!9OESy9;jmqPaqM{}k=65v1 z^hqTTUpeRU$UMs*U8QffBwr0gZPH4=^Qp`Ft_N#q<)TZ7^d=dj8>M* z4p~`325rcZCdj68&?$1rSJ1vb*YrGr0qrW8A7l(n@V#m;u8hiYQ>7?gTFsl7sL#fy zOq)!M95g2`HM=dQU_3y;(=nceY0>e?)Lct7=EP1<&!uv0IgOd@tkOZ(l*dhTp34@P z5O>BV!+I?B@Q~1+fZCnWAhY@R^TrpI15A6&b9P|TbfXVqZ*b`Myi=%4y#Hr#b<|N4 zkG;Wle4}L_^{>2ePV@90R-H)cLJyi;&wwpK^g(P#bN3T*Fr2mc`eeOF?+GKyYIg+krsm_@ckGom0~Do1+CEb+oD@mp}^XE*S@t$`lV zQD&JRtUwW^P0t5YMz=HEx6Njq;+AbT=j8K@(ZV}IR=xI~lgtCLEDpZTIWqwP(x0C| zrXWC&l4&Z5R?k}->|WkAx#C&_8mLv*HuxV4GSQg^*7M4`nt_N<_w^ye?>+xY-IxQ} zU;~@VC+a$WlvdW(F?CkEw2hYCAoI+gb!$x>LAH)?CNdF~7}!bxSj={MwNJ^i3-s+b zTM+_#W&D_C7R9I%*#AC7tY_( zBmN~dUJ|a}RB+wX8gMGe244rB`YiGe%yBj+5+pveh`)%yU+Y z>RkYfe1p0bP3e)TnZYMd{X!gdj0#4fO0xPD>KF!F$`625ZDN}}gu1!1@cAwX_pEJ} z74xF;y79{wzlM?G4s*OaT$}y+1uUFsmL=~3O>&ztxi~aJ{|eKyf+_A7up^XXD>ul$ zH8q|OQ2DX(=I*0tHFUVg9NHk`vr*K?e! zCwr%VmxAu)13?7;Obpb)+w+Rb#{)<;Jyk*a_)EL#71Vn_`uo7`O(4j+#vUU z!;m)K`MQ_iomyc<%&6KAC1-QI8iw(e^9(6t9OoD&`|2+!KN#HQoKThU77Y_t{sJXR zYF{{i$ze0+U&k5#Y!k=45ORtBdoaW)c>|i$9J=3y5OOKxaDR)rw-teO6df{`hjUfV zxDTMb!dns4fdM7*G|KFpMBY0P1#M1pCZ6x9YazM%Rc7H9SubobY>|Q1WS$PkR))8h zr>T(Ry(Luk$+19Z)(YgHCN;1_>-F(mEy^=H)kcqRvS+`Bi23I-d}uy6&(WK_zQ-KA zS~VFx8V)x1X2raopBPz#>_>|kS(@&3DwmDHUz#SGI@QeW+;lb$ZeGSYBrY^3&OQ4L z9J(#XE>Vm#Oj5D}0kpG^wAQt}{a_Hp!N70lF>5t{7IskjS1#{vHI(;oj+=Kf7aer zSJ&RJtjZ7XYHRQL&-HiJ+WVDXe~psd{O=l+T7SP{QJ0ISP=_p=yrz0ld08p``fC~f z@2vb$Ev?_J{QLj1o;!{aV;^+mt1=%#T#HnWMbmVsBoLbRBxjBaO&4ugcu~kzEFfm8 zrCRl_jK9|J5|m7chKKL%#x%W^6MjsOzn{6ovzo7cF$1);Orzs>&D`r$D#D}+HQi(@ ze${ga9~^Q>YE~YWy%1e_S80tR*jnUuumvO03cAIDQ&`E^PNha3YDf<@AMpHf2Ns(- z(JfL`$iC*mT#+`!J zdE$907V)*=czqfiqg>>I&O073u|~?wX}?=4DhXRN|G{U?I#hFU$KTsUJ9< zDjL=?c(V$h`<+zDb27*SjARvRy4R^frVmrAQeyntp#U}heC{uE1UI(Fatyynrw;^4 zD`pKFIFzY(DLAo!1ul#S{;J1SZaLT|q}=LFmV~L^1$Xtw(2oa4SKb>7jk=u)vI=IVpmXENli#~^Y$Cr&FsSJ;z zWA6D`7Q!`J26U1&*v_XWu7Sat;KAA<70{giX#JiEn)&yKRF>%9&r7WACLWkOGk9%o zY}&>1@Xs9L|FVFbIT3*KV9y^d|0z!d?pgUAyES z+$Y*Y$$Cppx}BVjlzoSjs=?glSfgu-tJ6w+O{5a&iymN;ZQv-a#O_Xu{T4od0Jw!$ zGD0N#^!E4|Aw!o=g&*x{YnXOoPg}>d*Y-5r@)VjfP53f0qX#NIvFZL{vn{XqiV%W0 zJ8NZ9Z6)CWx2;9_a2E?TJ$FgQBTStDfbh+1mC!yR^sb$E)zu%~KY#b?$CKC1_y2Ax zqm?GgYkP%BwZ%E)Yx?Yf9SFL`Q7D*ynF|r;x!;(Kh*Q26tVGOVR%p1#zC>vv{)6p^ zj+!vg?!z-Iaio^O zkEsH%k40ec4;J`YEr1_W1xP0eIq5GJX{bf$YpTrQUUTmlveI8HbEuZ#si{&NS+r{Y zQsDnoRZgPtXWU{l&$;TL><^F=bAOe_0IfI`k)jQx;`aoZ6xQj}h6(<>OjQqGpFhuD zpXCfRTYu-jFN;qrr4;c%Y7~dL3pmsCW)!s6DBH7En?TEF#0((wk{NLG)O_GY6%+RW zH*G74Q{aM3LY7k`@efEP=<}&_yH)bajGg3E7lS5mteM%mZrO>-D%0JRdfZcRg=1GD%$m<5osur$=^1%s4;+ zz9>znVBIQ0j`Edv?GI4Ti!a`wliayXRp|D5REhHkUQmD;3oPSK9~U|>riOQ9_Ir+o zX*dWSIzRV2uh2AVE@P2rIyl)_q)hSTtYo%yWM7eW4;X{T$ZNJ%Rw=t%MB6IvW5sBQ z@64FZ)(`aLSCtf)!)DI3*ZJ9{Bdum|5X@zW@+@^G8zO7i3U(Z!09*Wd@2Gin3fmPB z@>?gDAjL~Bj3CXwdoPb)h*>TVUG%i5$Z06uedE%F;vyy{$0&!bvmaMdG96d@Uo@Jn z%eVXcjmt~BJf`G3+&elJf>fGZAY)0bE+LhPI!h<^aU6fmojnI|VzQbZ1Vt}|e{;}) z6)en2=JHHu|MBYW(eXj~dN5rZ`Su^x^{urv!~UbTQQchFe>}$XG;R7(%QF2~dU{{O z52)e3W*<<+ghn4rPa!WplN)?ckvSN9KrQz+^?*9&W#|D_&B4qAYRNb9SXzPxQ3Nei zDpw=F*CD0>?7}asEG_ke&Zy_Lf>Asi#VuS~n1Ma#Kg^b_u(Sm0Q`f&P7I=OhthB{G zqrEh&3LpK*zwj3MUUIfeSOg7bdqZfPmF38EG&iES6zW%1L4A5mi9g%dyo6lu_w zmQb1=g>ACMeMbvXA*ollf4c(y*cx;`NE5h1DZfA}?|W>I^)TW+vUi{5?07?-tx|#c z6LtXRFutu^2f;OKuYOI=_Rs>8m+?O1l`yy05``Iv93U9ek6yj!U$Idr z!4%kV!1@lNS<)SDe$(psq0$~u2CgQ?uvcL5_rfl$;8BG&2VVwW_`#2(3a>~snNdSG z1R>y45Ppa%0#dDH4teZ#++obrHM5h5ZM0ohaWd9lWT3MKd4^%)9hzY%$TQMChLSA4 zMEOcGqSs+C8gjFEWn}p{;!jd~?U2(Y1)~grdTRVjYJ%V!_SS?k?AW%Fp?prmVOY`D zWkuA;I9Gwe`)-wEVZVkpCXzq1{{oH&BJTQ}_>LkbEVk zGp+(|{X?GuyI_V>;vr=DFIhG^1N`WBK#W15BD#%Yug^<=WU?TZTrb!7M=p5bM_qPA zk&)*aj;?xsbh8&>u6EGzRwM7a?+s#}F5c>5JBonfz2_S&VB;!uDg2Ii3V0nB<*%%V z>K7D1gMr?Fz>$I-EIYd5J+3RlOp<&XwcR14y%Rg(!X;(j2T7DkFlA{oS|+B$Z?C@> zRWP30X|ZM~V3SrKM#Sm3VaF^N1_V>>`|p2zCE)?iiXYct+9_X=Hzhq)`yZ)I@%6r- z9Fi881uuyN;_G{vUQpI7qoS(-_({})(QkhMS+mt04cbIxYULF8L{`f+1_Ef3Fg2)Q zEL!Twy%R-f=$|azed)>e6+RR5|BJ@n!AYas?@ZsunEM~=>(zCG|5rC_i~awjJWm~B zIxk&PqU{tKr>k!-Tg|icqx}{ipIU8m>xT^(pu+CUio3hCvc29BufqnmCV{P+A4JyJ(Pnq`69XxH@_s);h`ZhNK(v2T# z8*A$?l>Ahw^LhlU83hVfO04~`wYjlbTVLDSSm7wR@P4^Z+06nXm8QE?_Qp2nQOGmQ+Y3UHInWLwm7C{q+t+*m|nln!sv`{j+}MyOv2 z9dy*ox9qS`@b%dVM}q+~O>*N=l&Aw(s+7P>!f$U>qS9Ou!eX{LOH0q59s1WWq>fX2 z_RMki!uE|Hdo;>IA;WsXz?YqdEzZWq7EJiH+V?OPoU|OMap{|P?~7fkG^%)m)lt;) z`!FgBHEynNtZl57hl6WC>stVDm6_Co9D-_V7z|X%@Ngn=z@ms?XSw;lJeq+N5a_RO zMDP)$lCtzA?7;%1)q$GxpvQD4$ThJ__(_fFIlDbKf)R*$0F!@=(9a6T2lEEIwA6&( z9S;M1!@vN#TpWd7FZdMI8GSu_#vpn2tj@e5vyniB6V^k6OC4WYs+Ao9Hjs;pH#C8S z2eB-JV+Sc7`Bo*BR>$kQqh9QMy730;&_gadQ$e-S8dPh=ZyUoFD@bD<58Xl3_PManTt>CiRU@vDPX)^LHSz)cgDrduCz5cIV1z)?`}0hn+* zkpxw=(*@xun=DG)S$w3!)|DzjHWy;V+z`(#^o*Pagk0t@odI;@ax_Hs7z)Z<+7Uy| zyu`*tP+f=i${u>FC#699)}g`lyFSA7Yf?1$b);4~q)_&N8|6bI-$D|vl4NF|K zQ)qj=9^|+RLLi$0-7Uf@FjS}W$?wEBJB8Xtx%$Jm1*)vy9!9nDT6v>fE7zc+A$=Ww zzqJN((i*h$JytKkHopVJxoI$l0s4xCDzCP_uK~+4s59>UVIaDW`=gNR{mk# z0`0mAEs{fRv%2}hfK~f$Kx(EPB$_1^*h(C--$0NE`&H1nRcUb@>v^&H{pJgt32|oz zLcAd!7a7#(C>`9|Bti3s+V>kjywJL6rs$otq|#J8cCWmi=p}V)8n^`kS>aw&;ojUt z+yKJ@qR_xL5_G83i3!kTdmht;A^atrdR$6RFe@{6OHi7%TkC4K);FuTPxt|esJ5wf zES02p&6doVJ%}18DWkyB!;Y5tNeFd|i;Jw^qR%Arxz}a2!;D%J>iiy`yM2CtEz!<$aTNI2YnDWOnj8D!sW zK87q2ub?~6y8XE1l*{GEpwP7!8{Y%0RamI2`iSTW#)za6&)If@_L6+RNKq|V)hA z0ty{sD+YppbOY$bO#zw#pjdTAyB$*) z*groz)#_TcMpgrL=a2%wpzw*O{ju{7%{ZcZrE(41Z4WOYR8T&>VVaQl#oXkT67B?} zU{K$zu9p?yLZ;rlKX@kR%F7FNwe@R66G2N_mf_7B7>IGMo zz6<%oiZ`g>7P#+KV24!hcUGWAxnugZ#eR;fRaFw>FRcZs7+yh{RI8hI>}G?ol>lNM z#M3k?%49aIHvzbsx(QKcq9#an0=>KT!p`K4sHG+oqY{*Um?b^MvBW~zJkMTUf_~Y^RjoJndaK8PgG5+h-_4W0I{m)}O zm1kD>ui1Bi?(h9|9?oB<@cjx|r}zBI3(eyy&^+9}&eQAboSeRn_xXzVftQw^`dvur zI&Y4CI%@oUaQI8>%@N+~eY5lwKBEmsI>mGZE4;cE>lrbJg%ISMW>Nac3r6sJ!-Iv_OQCU1g96jCjg`?i7Y%E6rCl3Cl zWu3*7ejZBx$32;7V~qU2UftL-q9@b8m-P?8Hx07N9VT}i9IA^hU%(HczKww-$x2)1Bq0(N4dF4Yj_p=)g9n}DI=f98fJkz?Iqgs_% zP=^uM@S}ewXL#ch`pxrzNsj~4rvd51fYe!laul$n9Ry@`RX+x>oC2f|0n%pxmLmYm z34rAQK-K>*B|80AfVl_O>rbiHUosTNG%a#9`$->W((YRu%v12&+nZF$Z*4A5&u?#T zQeD5bxmy}gN5{?-O_wf^=7C)WHgDSCgb>fXA4D_gyjTrEfIFIo7PmU0$P*7E@J ze;h)tDeQl0FV@!0{ojlAjfMRG7|%lfU&#LtDgS3{{F@hh`;9!Ezsz75`CwG9>1}+3 z6pBk<@!5rU?c+t#!_lC4$cw8w%ldW@ zj>~+%BX)_dspkJ&`2U!&Amh$|H`Yx5&s%sTyx{+j@GRngEaHDWNc<0*V}IuQlEnit zLxrH{aSSj|EXFbDpz2Pko4FR7bX2>5`3>$E<)p^xJn zwa`Z-22=|^cwxyYJS*VNodQTiuvhXrEvO-M!`mY8k83Y(;aS@X*Ke>B-IgBc!PXlV zgTV+(FjZuPq*@k?qV>P9gQ!m6u?%<%7}rarU?9H&cBLQycDR?y7A~Iyn!k`G3JT1D zHm?FUif*shVqQcc!#8SRiB{Kh(R*VnxIx8|R)RdZY8@1A;>G)D*m0A{67Lxn-H@S` z1&T?UVo*t^C`umTe;plu<9I`FJ(%%DAF`Dk(f^2b8&QG@X>5yB}zuppWA%6yFAf-c{Oi%k%A)5fazA@C1LtBp>g5!%m_mKZ4x%yAf)aSoz>sxCJ z{~wR?+;{xPT>YnK`tjdf+gP0cKgu(&@z1#WPtWw@zqOA0zs2}J{4?M2PhI_|Cx8FH zw(+96W%_?uuPyAqALYr?|E|J6YYQdtLJ9oEoB&jw5%&MX?R4UR0`GCR=J@dsJ~sbx z75Y%`Ig3C>j#IA@P8ndK%rhPap@@=DBEo9}ei_ku*msd1N04oWH7BebCp?@5JGd48 z=*2;5kJ*IKI8lHKVF4jv_zxBh%o!H}OlJ3y?7wFy6zHJ&L3~z6!2#h>hPu$PV2i~f zpnB!uCYg6S7BMs!lKQ|M9X>*Y2BXWOn{;l>u_;@n35zY*5y%QNa|((ELOE_JcRKDx z`PTtf^>WnPecAJOFEv2w%>D%@A1lCWky}8jKMA1Yihh)xqc}p(zax*uO}POQ=>Qmg zw}-9ans*HZ9l}H)d}7#;>gOu9RQ-GiPubyc0ZiN`sE+kB_t;jb=n4RZ7y%l>fO#C2 zm%xK|jp_(Jb?4>PE}3tjFe7z_Dw^oR zOSwKF)%nPCnt9M~f-5$wE~&ge%Ez#j#3#5VKz;}KhVWF=SL zZNMie7Q?s#&<5Hiq0He9V&@7!P(-Xz9AHEWc{$M9`Tw4rrViZuJ9Fa(Htx5W7Qyh27oV5FAHH2kLssWdjx&>uSUVBcyi_w^=YWqFQui?}cq22%Ecv zkIeN+S$CC6g{;NSvyfiw5%yTXGgNZJjQrr;CegPn?T97a(#~iA;yhphKC@jClUi~8 zx^XcyuOG)f3X%k?A>xkW#9avS!x(lV`WE4oJhAfL8VCYTAjKzHdcujIce=5TN%=|R+(EWs32*W+|?-I3|5WJZMJ3*^sw2e zyID7wk`s>KYg*)MnuV}iAFvKvC1NaU6JrNr7nW=WfV=rYsJ7Pa$3|<~ z#!zi@;9&R$U}YFwj|q|1y(IBQ76&s@xB9f*R<>A|TnU9-yp*vG6uYgdcYMPL{lDw9MDNy?E5T>~Z4QtyX^9iS+iVZ~Q!OA&s zF6d8$6j>z^kIDXMc@hfBVuH2|_e+snM{Sfbx})B<6Y?rto<9QW>oHuw;xmVXaWj$-CpF48-Kc4A_Rl`-z%{%rYv3*W1LM~K#8Y`RdluIfAC;R zwZp*BU?Q(zdJ$#OEvf3uo)SeltuZM(uZ4umw4Vd6(NAjVv!ev6?8*avJ>VgG3DsnN z!ZzcIfcN<8*38K^`CV4~T>B(8$ctI_70>fv#(&5{jh_KpEo|YOM8tDVbZ)J^apYOA#QnE8!QP%eLE8?Bex<&HsDw|0|#X*i2;zeabVA z|8LY5{QpZm6x=`xa{qzkT`_1vT#TncS_NeWVu@2qqusKk5HxMX>p0A$PI!8t(tILf z$@OxLf8?APKkADKt|2@R?Ny_jy$ExmHT-JiUE{Wxr;E3`2-kps#^-K)g9U631qzt& zj(5rrvEo1YE9;^91sO>&&>Ij)%R?7dCakQryh$?M34*kDPlPXwv5bi2d@rhSJMIux zkrwA_xDVCpLo?=%8+OccVL&j|zW@HmR}voBW#h*+n3&2}^v;lUT}4QwHszqd2tO9Z z=))-Xdl7RDA-=ws=>^iKv`C*~RCE;pe~DUcwB&%*s3mkpTIIh3>rbkE!uKg0Xj+3b zs3Y>ck__cLQG{sW$k~$Qg{aYjotHWUc$xmOV12o4mr0$<-YM3*tQ{fjs?-I(Q z0xc||_u&t%eKC>m1Bc!tz6Y%94ao%Butp|Y6Vl}Sy;626MLNq($FPf8IfP^8f}Z@o zWQUf9Y$p7OZLHSNUGj2QdcZNUk=i{6#*Aq5FOr?BwZB-%0lU}us4ew)ngmwcx8 z|5JPMVsqjD=P{lc$A4nqZ}?0<{%bEbUM$A{F`oO3KZ+8Q5W)20zrOWi;s5JVo_mjf z6t>6F!1Uw4v9Yz_|Bv#_W&HD;|NYxc{vS8D7X1HFo;i+xrYq3t$N$AzZEZ3BkMTUf z__qVd`Z-SMVCwN-uP)aAM|#SYa^*jcgTeK&Klt!KZQuas+W#fA!M@jOTh)z!bB-Sf z9_{%TAO8oO|B1d)Mgm?uU)%E-<3DEpudi)wnDL)Cw-)vvkMdNWJt1FW6B_|i_IsKE zQXTg-1biZ#?Mz?_hAs%R-y*azY zwB(CCoW;+h2yubUktbDW2k)4S+Oargpp}n&t;E7b$~H@h;!eHJ@9sbb_s~=9HTK zUwX~_XL`Pl{a@AG|82f_vDp7T#`7rqzs1(?t9`zL{omU9re*)Px!C_b#!yi+zLbndADOX$dm*`QO^s`sU*N?@^vPkG~@Gw}(UC z#u)i;t7_i=T(8w||F@9;9{yR#e+&8VapgZnM$6L}SmZffm?K$ff_!*;s6~;P3Mm1S zU%9Y;r^^;uO3S$&9*9H`(Y9FyQqU6qveCi%K8lKXxG=FY{K-=47=otQUU&_{zh|`T-ElDYV?ZvJ36;;ns!&QVPIVMf-AR|f?Ns(yFBO3Y?J=@$r6{Su_GGZFb2`lz@I>7w&6>JPqDzsGVoX^ndv;dNoKkT zS(2GSgdwqHXosE~doU#N`WnNP=y<)Zc!*x6zbn&}WbSU4@y}G{m;=vc{4-TK?vrqt z{!Uer`&nD2zXq)hLkxuw-%6h$6ah;7jNZKmv?}+3PJeQt(gP3JN=U~kmqb$Myq02t z@K`7@qF5(Is5Pyp|=N$p767xI9p|QN zpwE-yA#rz?#)eFjvuGt*t4I-}5R0ypktD%KTFEH&L#(d(pTK_U?a1PJC9)+IyHCH2&9CJ;hk+`QmLY&7PG!FOP9yiI$Z}acx z4dK}Q$r3xmB3CuX?v>Ybj`vGXq24l=L6vL@IQ#qB+az`6DS(@73xVC zQYe`fo*bRFPT!uqYT(v*Ju}zdFG;RiwVIXh{Ov24(zw~c*r1uYE{=ZMYc_bc7ung) z&Knoazqif-n>)^$kxw{e$J$z#O@yo{#k@gxV|JosIw$f_xO{UK~{R#wzaFqV40lYp_UC4n%yt$3Gk zDAq1*x1cFrE4~%QR)x}g9{SysRq8oLw6$-=&M-hHm{s$0I~WaOC4shCEI`~2Mg&Je z7-j=4B1P_hzu0R144m)mXY{b{{Q0Mod_URSPklQ+I(_>K`eJ7-h{}&53cGtYAXvqG zk}%+)LayRBZ0F=GFGGoQHqw`{R<&<CEIR^xO|hi95Zp9DsMw@_Xl-9p}4mze`nO5&&i1*7G25@&_7p zcdFkbY^_+t&OTQs-*av9tT0R<;`G`TLK$5FHH(UrvL&V36=!FM`w43oQr)4lFiP2A z7=2R)fC3__eRRBD`oDh z#LAp24JjZsCNVltWWj&;nBrq^ZiP>8643$k3cB(0V|pqOj?_H=%|<6$_`K&#V~L ziMl+wU73J|On$#^;_7Sn7RhEI-OzbKc*4GvsJp1C30AgQEvKN#|piuVo zmi?1f-DJQL{vHxkr4%iN_4*O60;F|?8TPFR>KGN^jr!F0BM@KPH-(g-8u6`(I)4#B zioWxWH0>~EO@vD$(NW)HORipTqF(H|Kw`*_inyZcD{s=zF--3s7t<${m@!96R8Dlz zB}LOLvVTSL@OUcV(rtJo$L1FROjH^q@7Cy@;UbHkOeQDx_ev! z1mH73kWTxtHeD5=+P<_qZWy{48OuVVXKyc>Z{Dj#{HR6w8G7g^v$IOPArK&`BZ-t4 z!a0bFIjlxS94XXM3l4M52MCkdx()9y<#c}S;cRY0pB?}C^Ayk3`g$GxM0`#3);CoN zEas~rgejsNucD;5Nf1Rdc{pk2O<ba*pA|dy;4N~*z2#QFH_i7wH zaZzB~l7V9Ya-_S@i)lUgNgiX8g;5`3AgL#(`?)AE(16c4T9=YyHm$Qi=1HgINF{lk zsT^bSYKTl(RAuwzIe&XEmRL<6pi_9#TDgsKUeVMEXp+f4y@lNz?Z5g#XVmkQdtc%i zd;h<>X8M2K++5uMf0Soo|Fy9H`XcsUFZ*6U2yb`QPfQft)h)iJxg@6BYQaiOS+eh1 zO=ujIcDgmSdB5sXOWAwK8}z%o7(cBuYR5wG6|eeEy6=AQTC9SXa;LnjUlh>HPRIsl zd70OSXNSDr6;lrVhNrCV^4{r{POY%eR#je&*zc44dUAH~_P9}`0WEQquHeF&z2sU} z+%L^R|Ju)7)_*?jvf7yb{{JRsU)=wHglC@PPw$pCX7K;;0{wq4#{c1;xsSi{}=NASK$Av@yq#HvvHB>0ZgVtj$!Ct_gz3w+tYUxB2KK^ z({>e1@oelWlHI}7e!#NbdnNv`&^wm6p<6V)B&;wmS6uz=hw;emIsc;;-Vs)BGFy^5 zcF&w($2gmDHc(?TgdOm*%X0 zjpqT@e|eiqXadKq{~KFdsr7$zt+rVIALCi9|BLni%iRAou3gT-cakvksMp1>2`%+- z#Tja!3QbtLd=nbfQ6FzOsZks&(}^Ctrf6Cw5?mHj9IX-oR!%(vs&Q2z{t^V8 z<4rhgeMOe)ymaK*I9`N+uOD0QSlW9SyKGycq*c6Y?8ZU(?)^k9b0B%1ZPm$3Ql~T) zA`wVPpD!_2ab=gVx_{%fKX}T(3HqqYJCfL$GE7Zwn!(k@3HhY$GLjLO3H(esN*yRG zPP&)&V?WknQi@^oEd z*yIPlncbSKYZ={3tGLCOs-P?LSWI3yxXP^K^idp7Vm5xlE0USsF(hDv?~7Vrc=6D4 zdt~9UlguasCs+kyL}Z;3B`P;aZm`}>+P}U(*rPs(clYyNewSqlp7oyH=hZp8N#;NQ z6m4V9MbC>^MQ`frj+|K0ZzqPIP z^_2hrt@VZc_ZZK=nEZ#&LI(U|GN3s9JvwbRE)Mth8<(yBylnk=)VyRzcb6CYt^Ko; zle1Iy{`T~!^`^0R(70&5NzR66E1h?8ocIdFlViN3GY6l8>JjBEAV13de}Mfz9;|DZ z0P^|&+8PG?(fNOMv$oj(KgzS<{|o;ArE~y^1&(5@1O4~hewG2x{m%%=;|ty6m3zcN z!?1T5Xgg_nJc#)~(nrrQMa&|P2dPeR!sM{?AN#oy)`Nb%RPQoOB~Epq^Z%nrIr*at z`Y?2uU{*;s`_FLNOmHG&ZiJ{}`qk8(cPQRBTCA_Iw~-lj4^td4+}|WQCOaL{mEkFk z3;w&yk#ZF6(Zyo3|9Kaft=mrZigMDov~L1BoFZt%22NE-@cb!|(>Kb+DTe5Xely(Y z4L_m)T0bU-snv;g(S&yHuA()HyWeYllUkY88g!IZJ@xkV4}P^+R#v?;$%?~%HR>|h zc_*GbHJ;OQ+aB^5=YTw=$f{Yf?#svb8NQ42KUPty=M#-`ADA7w9qHOuE5^}& z{#*xO>fR^=&T5+d6nmmR$*~AMl8IqijoEEv?3VLvwR#@ zP~j@vdBD|5g}oWPvWYANcDLtVPYid0_$%&AF994YnhJ7JAO(6S7=hHC0DnO5Deze~ zj`wPL8qUdzJ`Cc8TS*B%ck*Kjcia^P2Y(9SWw5jdfqiSkfPHJj20Lb(4R)ySL11T$ zB)vS-lm$tlo5_42F@0KKNIaT<`gHHyq!HD2iFXka*uT>XDO4~iXFs=0I0^mC#so63 zj-7+qDl)zP$paSd!-aJ>6LYt**9yAb$cyy^&1(z;H5Hh0JUJ<_rt!_tz#Ynzn6DG( z*|QZEvXYK+v_2^3oXZN_Qwkvi`38GTKU6gfcgVhytF*{wHaBi$i5V%; zDptcMPJ&N~Yw((;)^w zO}}N!gI@9S%o`VNn1m*RXijK}^OM)MBHXIKtJgI`n@m5JjaY8ElUUWH@Cwjr#y9xR z%oOHf*KN_0*0h^o`su!qxkBC5_-e_D}h5B-`$tsfKHr8y&0nd{6k`CH*F zShH%fnt^5RlW{gmufsgDcA63WA>5zeWdd^wb>9;X{Cpn}*rr3b@Df`N9G0m7N+L|N zjR%eFtdN}%k=_G692!RK_rVcu=yep)B%K;RIAGi<^}W%f=!Q)DyyOZo>Re~RnV}D6 zdOFXQ743zFn?L(eN}Sy#55J2epU+hdHhu7R(`YS+3aT*qejPFHa8^#MI_ ze&6DLFU7V&YqI226DTO7bs*IY*(1s|M>^KH-e^`%lIV`6nJZZWM>_tr4A#y94l>Q} zz_!GiXODl7WA7D3yPflcKo{}`dLqzdtSMnO!puJw z>vv2)=8E$#)q(q?9`-qS9xx8>Ysxka#T0pw2Sxs5z(-R9pY$S1_hL@KGt5ue1%}M~ zcPtr|DSP$>@6P=*JoC5zj{Tmr{AN$S{U4hBrR@Kz8`XvV-(x(LXVaPg&B6L_9>#xD z*#1G*=`H_wp*h(7&Bg3*o>qTzGWr{D^M@vXONPTQZspuOIyO9gsR`2X4|$0n-|j9c zR(|-+`C}<2uedQ}!i@w)tht~?rb+s2@v&SkJ9tlgcZpqEbA*?MRvfy(!*ErJpgN?E zRKRa}=N@2iSk&d93pEz8MxbLV#S9Gr$*?xHcs!j15}ql6Rs^ls6}BV@lp9`i7?K*5 z&^**T+9Q*0T?7eu>6etRFA*pJZg&?xP|Kud+FpYHY}jgMq67)WUS=i?V|6c+l0^>Z z3d2C%IwCLCmPE(Uec8i-^=#z7`JV~pm^x!8DwNNvj1#L#7)Q4tH6Iu1WgvL8w zyN5Z8%%$3LGr2=jT*+L^sYzMXEM!8$#7!KFqd^Dc@?Y{L@-s4n; z0Z0YS;;2(ec1eRVeGydM38shj-u^5_?M+Y)b$pBks|{(`?Zj$XgPMeKY2 zetJX={~(&8%rya3BEPqxVg1P!NlV+~B(Q^Y87&BUd3B{A$7n0VswRbDJ)_ob;a^)^RUqxSa(^-b6mK94U&MbH#=}Z? z6gS&ulg9Xr^#GmF1sY)4+=QocqycYJx7DgKM(oE<<~jL+N!*uoC?0p*|V9*2@objY3+ zt$5l9V$7**O44M$YnjGdIG|<0z2GMq8CT?gc+ETl7!!?DcgV}8S6eNU zVq}o^hn(pLIWZld=25Q#B>sA5t4p^@v^y@I8n)?tHS5?Wneo#7nBk<@)^k-F<(_(t zN|g*_-5^_ANOkL@;t*NVf>6-DWF*|&740{jXFxp-Xg0n*>t+X$3$A`cn`C~`Qn?)^ zE@{%$Op$BaXw&!rBynmNAql~H?`t&p6uLuZtB;QP|j+b{dZ7OjfF~Eu+J62b?y5<}WCB}KWO?m=k3KV~Q;GCTT+^-tW+snp* za|l%5_~pE@--MUu-_ILFV^R`QcdVvBobuLb^UbR4gJ-JFbo-fIpYVp5@`IRNggNlj zUH4_@7C!S#Z+Y1zq@Oy&LtSnO<{i%P3pcLYD%LFC*s_ZcEFPI`l_E*$j?KoQ)#A-@ znqHXRy2dv*Q&Zy{TV=Vl(&iQ0VBUB=n6nYG1a^TiK#$R zN~HaVd92T0L&KrK@WxE$-9!(oT2fX>;nJX6-OY=f9W0X z;!&S_>wjLoJvu%pUk`HH7-#>xv02mgKWm%StwsEwM|qy6RX^3tyZ=w`ef9t8{crw1 zo%rJaQ^-4=!iS2?&u|LM33|4Yzd5XQwqrE-NlLo$~NF&FkP z@Cv`MqGrY050&61ht`Bzky9ae?y0=sI$HXnFk_3r%=`W+`_ zPpjjH^o>?LXaGno?6ih1ES(jM(1tqeLdlkT6+o||RvT^h(3_mF=&SImlTz0HbwgMQ zKLz23s3IV)K*etV9_7`N*hz*KrGGgA*hO%$e$W~9JbRk_)xugP z$lCOC3UnK_`jGDv9xdZmGs1s=jkDQU)(A-Si2dxu8`L9mL3hbupd=aXYJ^*ULUr z<>)e^jnNOFqispsN^eqdiz+k7N?E!YH1K8Mg}8=GxLTk5K_~bWDS#yNi{VBIY+T?O z5-?eoRoHRuw4Xn(z0eRPfOp#l=u#$qcR%2v=0XO{6m;1Jjg1861rODo1rZPV%wfVQ zJ-Ui+quA?{3tAZQf^4(^$w>N2NTFoDU@=qcDJBgyA^4;#Z!tK{yaHN+X>1nA z!yP*cbjWG7gh%f^7KM|7Cii;SH_XGBRpFk9{?dZl13fd!{}V|4$ulng^EwFoy8ORh zdr@1+|Bvxlo6D%i-kn&Ggc5Gvb7>|YjuPylhg8$FP|IvCGYVM1D zZ~+$p+ENzO{bd37YxIL{luAn=+jrPW25KefrUE3ZGI*=&x$y|ngPV2`dLq=%f|oCz h#j|)8&*E7;i)ZmHp2f3x7SCkQ{~rJuhzbCJ3;^SG+w=ec literal 0 HcmV?d00001 -- Gitee