From a004907a4d33fd69c415e028e7528cbf7832c5e0 Mon Sep 17 00:00:00 2001 From: semenov Date: Mon, 13 Jan 2025 14:22:52 +0300 Subject: [PATCH 01/13] feat: add update system --- DOCS/.obsidian/workspace.json | 62 ++++- DOCS/Алексей/Board.md | 3 + DOCS/Алексей/Рефакторинг.md | 2 + DOCS/Алексей/Чек лист по переносу.md | 11 + DOCS/Как умеем принимать на Server.md | 1 + ...Что умеем отправлять Server - Client QT.md | 0 ServerLMS/ServerLMS/CMakeLists.txt | 8 +- ServerLMS/ServerLMS/{ => Data}/Client.h | 21 +- ServerLMS/ServerLMS/Data/PacketType.h | 39 +++ .../ServerLMS/Data/StreamingVersionData.h | 46 ++++ .../{ => Data}/typesDataServerClient.h | 5 + ServerLMS/ServerLMS/Systems/assetsmanager.cpp | 220 +++++++++++++++ ServerLMS/ServerLMS/Systems/assetsmanager.h | 41 +++ ServerLMS/ServerLMS/Systems/dataparser.cpp | 113 +++++++- ServerLMS/ServerLMS/Systems/dataparser.h | 18 +- .../ServerLMS/Systems/processingsystem.cpp | 19 +- .../ServerLMS/Systems/processingsystem.h | 6 +- .../ServerLMS/Systems/recognizesystem.cpp | 86 +++++- ServerLMS/ServerLMS/Systems/recognizesystem.h | 18 +- ServerLMS/ServerLMS/Systems/sendsystem.cpp | 74 ++--- ServerLMS/ServerLMS/Systems/sendsystem.h | 19 +- ServerLMS/ServerLMS/Systems/tools.cpp | 38 ++- ServerLMS/ServerLMS/Systems/tools.h | 49 ++-- .../ServerLMS/Systems/updatecontroller.cpp | 252 ++++++++++++------ .../ServerLMS/Systems/updatecontroller.h | 39 ++- ServerLMS/ServerLMS/clienthandler.cpp | 50 ++-- ServerLMS/ServerLMS/clienthandler.h | 22 +- ServerLMS/ServerLMS/serverlmswidget.cpp | 61 ++++- ServerLMS/ServerLMS/serverlmswidget.h | 25 +- 29 files changed, 1096 insertions(+), 252 deletions(-) create mode 100644 DOCS/Алексей/Рефакторинг.md create mode 100644 DOCS/Алексей/Чек лист по переносу.md create mode 100644 DOCS/Как умеем принимать на Server.md create mode 100644 DOCS/Что умеем отправлять Server - Client QT.md rename ServerLMS/ServerLMS/{ => Data}/Client.h (87%) create mode 100644 ServerLMS/ServerLMS/Data/PacketType.h create mode 100644 ServerLMS/ServerLMS/Data/StreamingVersionData.h rename ServerLMS/ServerLMS/{ => Data}/typesDataServerClient.h (93%) create mode 100644 ServerLMS/ServerLMS/Systems/assetsmanager.cpp create mode 100644 ServerLMS/ServerLMS/Systems/assetsmanager.h diff --git a/DOCS/.obsidian/workspace.json b/DOCS/.obsidian/workspace.json index a09a908..c1eaf4e 100644 --- a/DOCS/.obsidian/workspace.json +++ b/DOCS/.obsidian/workspace.json @@ -11,15 +11,58 @@ "id": "24c44b1390af655a", "type": "leaf", "state": { - "type": "excalidraw", + "type": "kanban", "state": { - "file": "Алексей/AssetManagerScheme.md" + "file": "Алексей/Board.md", + "kanbanViewState": { + "kanban-plugin": "board", + "list-collapse": [ + false, + false, + false, + false, + false, + false, + false, + false, + false + ] + } }, - "icon": "excalidraw-icon", - "title": "AssetManagerScheme" + "icon": "lucide-trello", + "title": "Board" + } + }, + { + "id": "1aa07d1707bb3761", + "type": "leaf", + "state": { + "type": "markdown", + "state": { + "file": "Что умеем отправлять Server - Client QT.md", + "mode": "source", + "source": false + }, + "icon": "lucide-file", + "title": "Что умеем отправлять Server - Client QT" + } + }, + { + "id": "77886c7575d9bc97", + "type": "leaf", + "state": { + "type": "markdown", + "state": { + "file": "Что умеем отправлять Server - Client QT.md", + "mode": "source", + "source": false + }, + "icon": "lucide-file", + "title": "Что умеем отправлять Server - Client QT" } } - ] + ], + "currentTab": 2 } ], "direction": "vertical" @@ -162,9 +205,15 @@ "obsidian-kanban:Создать новую доску": false } }, - "active": "24c44b1390af655a", + "active": "77886c7575d9bc97", "lastOpenFiles": [ "Алексей/Board.md", + "Алексей/Чек лист по переносу.md", + "Алексей/ТЕСТ-КЕЙСЫ.md", + "Алексей/Рефакторинг.md", + "Без названия.md", + "Как умеем принимать на Server.md", + "Что умеем отправлять Server - Client QT.md", "Алексей/AssetManagerScheme.md", "Desk.md", "CLIENT SERVER.canvas", @@ -172,7 +221,6 @@ "Андрей/ВАЖНАЯ ЗАМЕТКА.md", "Образец отправки сообщения с маркером.md", "Порядок сборки Unity билда под сервер.md", - "Алексей/ТЕСТ-КЕЙСЫ.md", "Алексей", "AssetManagerScheme.md", "SERVER/UpdateController.md", diff --git a/DOCS/Алексей/Board.md b/DOCS/Алексей/Board.md index 6038471..b7a24e8 100644 --- a/DOCS/Алексей/Board.md +++ b/DOCS/Алексей/Board.md @@ -6,6 +6,8 @@ kanban-plugin: board ## backLog +- [ ] выписать все варианты взаимодействия между всеми клиентами и сервером +- [ ] sendSystem::sendXmlAnswer новый вариант отпарвки XML пакетов ## bugs @@ -29,6 +31,7 @@ kanban-plugin: board - [ ] Прибраться в Server - [ ] рефакторинг +- [ ] добавить генерацию пустых файлов, если shared не найден ## NOW diff --git a/DOCS/Алексей/Рефакторинг.md b/DOCS/Алексей/Рефакторинг.md new file mode 100644 index 0000000..bef373d --- /dev/null +++ b/DOCS/Алексей/Рефакторинг.md @@ -0,0 +1,2 @@ +1. DataParser разделить на подклассы, придумать как скомпоновать. Возможно разделить на формирование ответов и парсинг входящих данных. +2. \ No newline at end of file diff --git a/DOCS/Алексей/Чек лист по переносу.md b/DOCS/Алексей/Чек лист по переносу.md new file mode 100644 index 0000000..49c92db --- /dev/null +++ b/DOCS/Алексей/Чек лист по переносу.md @@ -0,0 +1,11 @@ +- [x] AssetManager +- [x] DataParser +- [x] Logger +- [x] ProcessingSystem +- [x] RecognizeSystem +- [x] SendSystem +- [x] Tools +- [x] UpdateController +- [x] ClientHandler +- [x] MultiThreadServer +- [x] ServerLMSWidget \ No newline at end of file diff --git a/DOCS/Как умеем принимать на Server.md b/DOCS/Как умеем принимать на Server.md new file mode 100644 index 0000000..33c4ca5 --- /dev/null +++ b/DOCS/Как умеем принимать на Server.md @@ -0,0 +1 @@ +- XML файлы с поиском по тегу (DataParser::xmlParser) \ No newline at end of file diff --git a/DOCS/Что умеем отправлять Server - Client QT.md b/DOCS/Что умеем отправлять Server - Client QT.md new file mode 100644 index 0000000..e69de29 diff --git a/ServerLMS/ServerLMS/CMakeLists.txt b/ServerLMS/ServerLMS/CMakeLists.txt index 02c7e74..492cb4d 100644 --- a/ServerLMS/ServerLMS/CMakeLists.txt +++ b/ServerLMS/ServerLMS/CMakeLists.txt @@ -33,12 +33,16 @@ add_library(ServerLMS SHARED serverlmswidget.cpp serverlmswidget.h serverlmswidget.ui - typesDataServerClient.h - Client.h clienthandler.cpp clienthandler.h multithreadserver.cpp multithreadserver.h + Data/typesDataServerClient.h + Data/Client.h + Data/PacketType.h + Data/StreamingVersionData.h + Systems/assetsmanager.cpp + Systems/assetsmanager.h Systems/recognizesystem.cpp Systems/recognizesystem.h Systems/updatecontroller.cpp diff --git a/ServerLMS/ServerLMS/Client.h b/ServerLMS/ServerLMS/Data/Client.h similarity index 87% rename from ServerLMS/ServerLMS/Client.h rename to ServerLMS/ServerLMS/Data/Client.h index 35771c9..32246cb 100644 --- a/ServerLMS/ServerLMS/Client.h +++ b/ServerLMS/ServerLMS/Data/Client.h @@ -50,13 +50,17 @@ public: { return ready; } + void setReady(bool ready) { this->ready = ready; } - void setUnity(bool flag){ + + void setUnity(bool flag) + { isUnity = flag; } + bool getIsUnity() { return isUnity; @@ -75,10 +79,22 @@ public: { isUnity = !isUnity; } - bool operator == (Client* right){ + + bool operator == (Client* right) + { return this->address == right->address; } + bool getIsLoggedIn() + { + return isLoggedIn; + } + + void setIsLoggedIn(bool value) + { + isLoggedIn = value; + } + private: QString name; @@ -88,6 +104,7 @@ private: QString login; bool ready; + bool isLoggedIn; bool isUnity = false; TypeClientAutorization TypeClient; diff --git a/ServerLMS/ServerLMS/Data/PacketType.h b/ServerLMS/ServerLMS/Data/PacketType.h new file mode 100644 index 0000000..2b54672 --- /dev/null +++ b/ServerLMS/ServerLMS/Data/PacketType.h @@ -0,0 +1,39 @@ +#ifndef PACKETTYPE_H +#define PACKETTYPE_H + +enum PacketType +{ + TYPE_NONE = 0, + TYPE_UNITY = 1, + TYPE_FILE = 2, + TYPE_COMMAND =3, + TYPE_FOLDER = 4, + TYPE_DELETE = 5, + TYPE_FINISH = 6, + TYPE_NEEDUPDATE = 7, + TYPE_XMLANSWER = 8, + TYPE_QT = 9, + TYPE_DISABLE = 11, + TYPE_FILESIZE = 20, + + TYPE_XMLANSWER_MESSAGE_FOR_GUI = 90, + + //xml-ответы на запросы к БД + TYPE_XMLANSWER_QUERY_DB__LIST_INSTRUCTORS = 100, + TYPE_XMLANSWER_QUERY_DB__LIST_GROUPS = 101, + TYPE_XMLANSWER_QUERY_DB__LIST_TRAINEES = 102, + TYPE_XMLANSWER_QUERY_DB__LIST_COMPUTERS = 103, + TYPE_XMLANSWER_QUERY_DB__LIST_CLASSROOMS = 104, + TYPE_XMLANSWER_QUERY_DB__LIST_TASKS = 105, + + //ответы по обновлениям + HASH_READY = 150, + CHANGE_DATA_VERSION = 151, + COPY_VERSION = 152, + DELETE_DATA_VERSION = 153, + BUSY = 154, + FREE = 155 +}; + + +#endif // PACKETTYPE_H diff --git a/ServerLMS/ServerLMS/Data/StreamingVersionData.h b/ServerLMS/ServerLMS/Data/StreamingVersionData.h new file mode 100644 index 0000000..3746bd7 --- /dev/null +++ b/ServerLMS/ServerLMS/Data/StreamingVersionData.h @@ -0,0 +1,46 @@ +#ifndef STREAMINGVERSIONDATA_H +#define STREAMINGVERSIONDATA_H + +#include +#include + +class StreamingVersionData +{ +public: + StreamingVersionData(QString absoltePath,QString viewName,QDateTime data,qint32 size) + { + this->absolutePath = absoltePath; + this->viewName = viewName; + this->createData = data; + this->size = size; + } + ~StreamingVersionData(); + + QString getAbsolutPath() const + { + return absolutePath; + } + + QString getViewName() const + { + return viewName; + } + + QDateTime getCreateData() const + { + return createData; + } + + qint32 getSize() const + { + return size; + } + +private: + QString absolutePath; + QString viewName; + QDateTime createData; + qint32 size; +}; + +#endif // STREAMINGVERSIONDATA_H diff --git a/ServerLMS/ServerLMS/typesDataServerClient.h b/ServerLMS/ServerLMS/Data/typesDataServerClient.h similarity index 93% rename from ServerLMS/ServerLMS/typesDataServerClient.h rename to ServerLMS/ServerLMS/Data/typesDataServerClient.h index 5df49a4..32a19ab 100644 --- a/ServerLMS/ServerLMS/typesDataServerClient.h +++ b/ServerLMS/ServerLMS/Data/typesDataServerClient.h @@ -22,6 +22,11 @@ struct FileData return false; } + bool operator<(const FileData& data2) const + { + return this->hash == "FOLDER" && data2.hash !="FOLDER"; + } + }; struct SAttribute diff --git a/ServerLMS/ServerLMS/Systems/assetsmanager.cpp b/ServerLMS/ServerLMS/Systems/assetsmanager.cpp new file mode 100644 index 0000000..d81e9ce --- /dev/null +++ b/ServerLMS/ServerLMS/Systems/assetsmanager.cpp @@ -0,0 +1,220 @@ +#include "assetsmanager.h" + +AssetsManager::AssetsManager(QObject *parent) : QObject(parent) +{ + +} + +void AssetsManager::initialize(UpdateController* updateContoller,DataParser *dataParser) +{ + this->updateController = updateContoller; + connect(this,&AssetsManager::sigSaveVersion,dataParser,&DataParser::saveVersionToFile); + datas = new QList; +} + +void AssetsManager::setVersionList(QList *streamingVersion) +{ + datas->clear(); + datas = streamingVersion; +} + +bool AssetsManager::findDuplicate(QString name) +{ + QListIterator iterator(*datas); + + while (iterator.hasNext()) + { + if (iterator.next()->getViewName() == name) return true; + } + + return false; +} + +QString AssetsManager::setVersion(QString versionName) +{ + QListIterator iterator(*datas); + + while (iterator.hasNext()) + { + StreamingVersionData *version = iterator.next(); + + if (version->getViewName() == versionName) + { + currentVersionData = version; + emit sigSaveVersion(currentVersionData); + + return version->getAbsolutPath(); + } + } + + return "none"; +} + +QList *AssetsManager::prepareLocalPathList(QList *fileData) +{ + QList *completeList = fileData; + + for(int i = 0; i < completeList->count();i++) + { + FileData fileData = completeList->at(i); + + int index = fileData.path.indexOf(currentVersionData->getViewName()); + if(index != -1) + { + fileData.path = Tools::createRealPath(fileData.path,currentVersionData); //делаем в полный путь + completeList->replace(i,fileData); + } + else + { + fileData.path = Tools::createRootPath(fileData.path); + } + + } + + return completeList; +} + +QList *AssetsManager::prepareRealPathList(QList *fileData) +{ + QList *completeList = fileData; + + for(int i = 0; i < completeList->count();i++) + { + FileData fileData = completeList->at(i); + if(fileData.path.contains(streamingAssetsFolderName)) + { + fileData.path = Tools::createStreamingToRealPath(fileData.path,currentVersionData); + } + else + { + fileData.path = Tools::createRealPath(fileData.path,currentVersionData); //делаем в полный путь + } + + completeList->replace(i,fileData); + } + + return completeList; +} + +void AssetsManager::addVersion(StreamingVersionData *data) +{ + datas->push_back(data); +} + +void AssetsManager::createCopyVersion(QString versionName,QString newVersionName) +{ + qDebug() << "assetManager thread ID " << QThread::currentThreadId(); + QListIterator iterator(*datas); + StreamingVersionData* data; + + while (iterator.hasNext()) + { + StreamingVersionData *version = iterator.next(); + + if (version->getViewName() == versionName) + { + data = version; + } + } + + qDebug() << "Version for copy " << versionName; + qDebug() << "New version name " << newVersionName; + + //берем путь до копии + //преобразуем в реальный путь + QString sourcePath = QDir::currentPath() + "/" + sharedDataFolderName + "/" + versionName; + QString destinationPath = QDir::currentPath() + "/" + sharedDataFolderName + "/" + newVersionName; + + QDir sourceDir(sourcePath); + + if(!sourceDir.exists()) + { + qDebug() << "Версии нет в SharedData"; + return; + } + + QDir destinationDir(destinationPath); + if(destinationDir.exists()) + { + qDebug() << "Папка уже существует"; + return; + } + + //Создаем папку в Shared с новым именем + QDir().mkdir(destinationPath); + copyAllRecurse(sourcePath,destinationPath); + //добавляем в список текущих ассетов + updateController->calculateFullHash(); + updateController->changeAssetVersion(newVersionName); + updateController->sendNewVersionList(); + //повторно отправляем список версий из папки shared + +} + +void AssetsManager::deleteVersion(QString versionName) +{ + QMutableListIterator iterator(*datas); + + //если версия равна текущей - игнор + if (currentVersionData->getViewName() == versionName) + return; + + while (iterator.hasNext()) + { + StreamingVersionData *version = iterator.next(); + + //проверка на наличие указанной версии + if (version->getViewName() == versionName) + { + //удаление папки + QString verFolderPath = QDir::currentPath() + "/" + sharedDataFolderName + "/" + versionName; + QDir dir(verFolderPath); + dir.removeRecursively(); + + //удаление хэша + QString hashPath = QDir::currentPath() + "/" + staticDataFolderName + "/" + versionName + "Hash.xml"; + QFile file(hashPath); + + if(file.exists()){ + file.remove(); + } + + //удаление + datas->removeOne(version); + break; + } + } + + updateController->calculateSharedHash(); + updateController->sendNewVersionList(); +} + +void AssetsManager::copyAllRecurse(QString source,QString destination) +{ + + //Копируем все объекты туда + QDir sourceDir(source); + + foreach(QString folder,sourceDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot)) + { + QString destPath = destination + QDir::separator() + folder; + sourceDir.mkpath(destPath); + copyAllRecurse(source + QDir::separator() + folder,destPath); + } + + foreach(QString file,sourceDir.entryList(QDir::Files)) + { + QFile::copy(source + QDir::separator() + file,destination + QDir::separator() + file); + } +} + +AssetsManager::~AssetsManager() +{ + +} + +StreamingVersionData *AssetsManager::getCurrentVersionData() const +{ + return currentVersionData; +} + diff --git a/ServerLMS/ServerLMS/Systems/assetsmanager.h b/ServerLMS/ServerLMS/Systems/assetsmanager.h new file mode 100644 index 0000000..559a0f7 --- /dev/null +++ b/ServerLMS/ServerLMS/Systems/assetsmanager.h @@ -0,0 +1,41 @@ +#ifndef ASSETSMANAGER_H +#define ASSETSMANAGER_H + +#include +#include +#include + + +class AssetsManager : public QObject +{ + Q_OBJECT +public: + explicit AssetsManager(QObject *parent = nullptr); + void initialize(UpdateController* updateContoller,DataParser *dataParser); + void addVersion(StreamingVersionData *data); + void createCopyVersion(QString versionName,QString newName); + void deleteVersion(QString version); + void setVersionList(QList *streamingVersion); + bool findDuplicate(QString name); + QString setVersion(QString versionName); + + QList *prepareLocalPathList(QList*fileData); + QList *prepareRealPathList(QList *fileData); + QList *getRealPathList(); + + ~AssetsManager(); + + StreamingVersionData *getCurrentVersionData() const; + +signals: + void sigSaveVersion(StreamingVersionData *versionData); + +private: + UpdateController *updateController; + QList *datas; + StreamingVersionData* currentVersionData; + + void copyAllRecurse(QString source, QString destination); +}; + +#endif // ASSETSMANAGER_H diff --git a/ServerLMS/ServerLMS/Systems/dataparser.cpp b/ServerLMS/ServerLMS/Systems/dataparser.cpp index b5eb646..c090aad 100644 --- a/ServerLMS/ServerLMS/Systems/dataparser.cpp +++ b/ServerLMS/ServerLMS/Systems/dataparser.cpp @@ -3,10 +3,11 @@ #include #include -DataParser::DataParser(ProcessingSystem *processingSystem,QObject *parent) : +DataParser::DataParser(AssetsManager *assetManager,ProcessingSystem *processingSystem,QObject *parent) : QObject(parent) { this->processingSystem = processingSystem; + this->assetsManager = assetManager; mutex = new QMutex; if (!QDir(staticDataFolderName).exists()){ @@ -285,7 +286,6 @@ void DataParser::xmlFileDataParse(QByteArray array) } } - QByteArray DataParser::xmlAnswer(QList listTag, QString elemUp1, QString elemUp2) { try { @@ -333,18 +333,7 @@ QByteArray DataParser::xmlAnswer(QList listTag, QString elemUp1, QByteArray array; - /* Открываем файл для Чтения*/ - QFile fileR(tempFile); - if (!fileR.open(QFile::ReadOnly | QFile::Text)) - { - QString str = "Не удалось открыть файл"; - qDebug() << "xmlAnswer: " << str; - } - else - { - array = fileR.readAll(); - fileR.close(); // Закрываем файл - } + array = readTempFile(); mutex->unlock(); return array; @@ -584,6 +573,102 @@ QByteArray DataParser::xmlAnswer_tasks(QStringList listTasks) return xmlAnswer(listTag, "TaskArray", "Tasks"); } +QByteArray DataParser::xmlAnswer_currentVersion() +{ + QByteArray array; + QFile fileR(version); + if (!fileR.open(QFile::ReadOnly | QFile::Text)) + { + QString str = "Не удалось открыть файл"; + qDebug() << "xmlAnswer: " << str; + } + else + { + array = fileR.readAll(); + fileR.close(); // Закрываем файл + } + + return array; +} + +void DataParser::createVersionListXmlAnswer(QList version) +{ + QList listTag; + + foreach(StreamingVersionData* ver,version) + { + SAttribute attribute1 = {"Version", ver->getViewName()}; + SAttribute attribute2 = {"Created", ver->getCreateData().toString()}; + + QList listAttr = {attribute1, attribute2}; + SXmlAnswerTag tag = {"VersionData", listAttr}; + + listTag.append(tag); + } + + + QFile file(versionListFile); + file.open(QIODevice::WriteOnly); + + QXmlStreamWriter xmlWriter(&file); + xmlWriter.setAutoFormatting(true); + xmlWriter.writeStartDocument(); + xmlWriter.writeStartElement("VersionList"); + + foreach(SXmlAnswerTag tag,listTag) + { + xmlWriter.writeStartElement(tag.elementName); + + foreach(SAttribute attribute,tag.attr) + { + xmlWriter.writeAttribute(attribute.name,attribute.value); + } + + xmlWriter.writeEndElement(); + } + + xmlWriter.writeEndElement(); + xmlWriter.writeEndDocument(); + file.close(); +} + +QByteArray DataParser::readTempFile() +{ + QByteArray array; + QFile fileR(tempFile); + if (!fileR.open(QFile::ReadOnly | QFile::Text)) + { + QString str = "Не удалось открыть файл"; + qDebug() << "xmlAnswer: " << str; + } + else + { + array = fileR.readAll(); + fileR.close(); // Закрываем файл + } + + return array; +} + +void DataParser::saveVersionToFile(StreamingVersionData *streamingVersion) +{ + QFile file(version); + file.open(QFile::WriteOnly); + + QXmlStreamWriter xmlWriter(&file); + xmlWriter.setAutoFormatting(true); + xmlWriter.writeStartDocument(); + + xmlWriter.writeStartElement("VersionData"); + xmlWriter.writeAttribute("Version",streamingVersion->getViewName()); + xmlWriter.writeAttribute("Created",streamingVersion->getCreateData().toString()); + + xmlWriter.writeEndElement(); + xmlWriter.writeEndDocument(); + + file.close(); +} + DataInfo *DataParser::getCurrentDataInfo() { return dataInfo; diff --git a/ServerLMS/ServerLMS/Systems/dataparser.h b/ServerLMS/ServerLMS/Systems/dataparser.h index c292ac6..1294594 100644 --- a/ServerLMS/ServerLMS/Systems/dataparser.h +++ b/ServerLMS/ServerLMS/Systems/dataparser.h @@ -1,27 +1,30 @@ #ifndef DATAPARSER_H #define DATAPARSER_H - #include "Systems/processingsystem.h" #include "Systems/tools.h" +#include "Systems/assetsmanager.h" #include "logger.h" #include "serverlmswidget.h" -#include "typesDataServerClient.h" #include #include #include #include +#include +#include + class ProcessingSystem; class ClientHandler; +class AssetsManager; class DataParser : public QObject { Q_OBJECT public: - DataParser(ProcessingSystem *processingSystem,QObject* parent = nullptr); + DataParser(AssetsManager *assetManager,ProcessingSystem *processingSystem,QObject* parent = nullptr); void xmlParser(ClientHandler *client, QByteArray array); void xmlFileDataParse(QByteArray array); @@ -42,6 +45,9 @@ public: QByteArray xmlAnswer_task(QString text); QByteArray xmlAnswer_notify(QString code); QByteArray xmlAnswer_tasks(QStringList listTasks); + + QByteArray xmlAnswer_currentVersion(); + void createVersionListXmlAnswer(QList version); DataInfo *getCurrentDataInfo(); void clearCurrentDataInfo(); ~DataParser(); @@ -52,11 +58,17 @@ public: signals: void sigLogMessage(QString log); +public slots: + void saveVersionToFile(StreamingVersionData *streamingVersion); + private: QMutex *mutex; QList *datas; ProcessingSystem *processingSystem; + AssetsManager *assetsManager; DataInfo *dataInfo; + + QByteArray readTempFile(); }; #endif // DATAPARSER_H diff --git a/ServerLMS/ServerLMS/Systems/processingsystem.cpp b/ServerLMS/ServerLMS/Systems/processingsystem.cpp index 7b5fbf7..6813cc9 100644 --- a/ServerLMS/ServerLMS/Systems/processingsystem.cpp +++ b/ServerLMS/ServerLMS/Systems/processingsystem.cpp @@ -12,6 +12,12 @@ void ProcessingSystem::initialize(DataParser *dataParser, ServerLMSWidget *serve { this->server = server; this->dataParser = dataParser; + + connect(this,&ProcessingSystem::sigAuthChanged,server, &ServerLMSWidget::slot_AuthChanged,Qt::AutoConnection); + connect(this,&ProcessingSystem::sigUpdateListClients,server, &ServerLMSWidget::slotUpdateListClients,Qt::AutoConnection); + connect(this,&ProcessingSystem::sigLogMessage,server->getLogger(),&Logger::addTextToLogger,Qt::QueuedConnection); + connect(this,&ProcessingSystem::signal_msgToClientReady,server, &ServerLMSWidget::slot_msgToClientFromGUI); + connect(this,&ProcessingSystem::signal_msgFromClientReady,server, &ServerLMSWidget::slot_msgToGUIfromClient); } void ProcessingSystem::processingClientAutorization(ClientHandler *client, ClientAutorization clientAutorization) @@ -60,6 +66,7 @@ void ProcessingSystem::processingClientAutorization(ClientHandler *client, Clien arrayAnswer = dataParser->xmlAnswer_authorization(false, "", "", "", ""); } client->sendXmlAnswer(arrayAnswer); + client->sendVersion(); QString str = QString(arrayAnswer); //logger->addTextToLogger("To Client: " + str); @@ -238,7 +245,7 @@ void ProcessingSystem::processingFromClientMessage(ClientHandler *client, Client void ProcessingSystem::processingClientNotify(ClientHandler *client, ClientNotify clientNotify) { - if(clientNotify.Code == "READY") + if(clientNotify.Code == commandReadyClient) {//Клиент готов принять задания client->getClient()->setReady(true); //скорее всего функции будут внутри хэндлера @@ -256,15 +263,19 @@ void ProcessingSystem::processingClientNotify(ClientHandler *client, ClientNotif QString str = QString(arrayAnswer); emit sigLogMessage("To Client: " + str); } - else if(clientNotify.Code == "DISABLE") + else if(clientNotify.Code == commandDisableClient) { + qDebug() << "processing thread: " << QThread::currentThreadId(); client->sendDisable(); - //server->slotDisconnectClient(client->getClient()->getAddress(),client->getClient()->getPort()); } - else if(clientNotify.Code == "GETSERVERDATALIST") + else if(clientNotify.Code == commandGetServerDataList) { client->sendHash(); } + else if(clientNotify.Code == commandCheckVersionList) + { + client->sendVersionList(); + } } diff --git a/ServerLMS/ServerLMS/Systems/processingsystem.h b/ServerLMS/ServerLMS/Systems/processingsystem.h index 7264930..3a82519 100644 --- a/ServerLMS/ServerLMS/Systems/processingsystem.h +++ b/ServerLMS/ServerLMS/Systems/processingsystem.h @@ -1,8 +1,8 @@ #ifndef PROCESSINGSYSTEM_H #define PROCESSINGSYSTEM_H -#include "sendsystem.h" -#include "typesDataServerClient.h" +#include +#include #include #include @@ -22,7 +22,7 @@ class ProcessingSystem : public QObject public: explicit ProcessingSystem(ProviderDBLMS* providerDBLMS, QObject *parent = nullptr); - void initialize(DataParser* dataParser,ServerLMSWidget *server); + void initialize(DataParser* dataParser,ServerLMSWidget *server); //TODO: проверить необходимость зависимости на ServerLMS void processingClientAutorization(ClientHandler *client, ClientAutorization clientAutorization); void processingClientDeAutorization(ClientHandler *client, ClientDeAutorization clientDeAutorization); void processingClientQueryToDB(ClientHandler *client, ClientQueryToDB clientQueryToDB, int id = 0, void* data = nullptr); diff --git a/ServerLMS/ServerLMS/Systems/recognizesystem.cpp b/ServerLMS/ServerLMS/Systems/recognizesystem.cpp index 3dc77ff..21b9131 100644 --- a/ServerLMS/ServerLMS/Systems/recognizesystem.cpp +++ b/ServerLMS/ServerLMS/Systems/recognizesystem.cpp @@ -1,4 +1,3 @@ -#include "Client.h" #include "recognizesystem.h" RecognizeSystem::RecognizeSystem(QObject *parent): @@ -24,8 +23,13 @@ void RecognizeSystem::initialize(UpdateController *updateController,DataParser* this->sendSystem = sendSystem; socket = handler->getSocket(); - connect(this,&RecognizeSystem::sigCalculateHash,updateController,&UpdateController::calculateHash,Qt::DirectConnection); + connect(this,&RecognizeSystem::sigCalculateHash,updateController,&UpdateController::calculateFullHash,Qt::AutoConnection); + connect(this,&RecognizeSystem::sigCalculateHash,updateController,&UpdateController::setUpCurrentServerHash,Qt::AutoConnection); + connect(this,&RecognizeSystem::sigChangeVersion,updateController,&UpdateController::changeAssetVersion,Qt::AutoConnection); + connect(this,&RecognizeSystem::sigDeleteVersion,updateController,&UpdateController::deleteAssetVersion,Qt::AutoConnection); + connect(this,&RecognizeSystem::sigCopyVersion,updateController,&UpdateController::createCopyVersion,Qt::AutoConnection); connect(this,&RecognizeSystem::sigXmlParser,dataParser,&DataParser::xmlParser,Qt::DirectConnection); + qDebug() << "Recognize init thread ID " << QThread::currentThreadId(); } @@ -75,7 +79,7 @@ void RecognizeSystem::recognize() } - if (packetType == PacketType::TYPE_COMMAND) + if (packetType == PacketType::TYPE_COMMAND) //TODO: надо переделать под какой то нормальный тип, который уже существует { stream.startTransaction(); stream >> command; @@ -83,7 +87,7 @@ void RecognizeSystem::recognize() if (!stream.commitTransaction()) continue; } - if (command == "update") //запускает процесс оновления + if (command == commandUpdateFilesClient) //запускает процесс оновления { sendSystem->updateFiles(updateController->getFileSendList(), updateController->getClientDataList()); @@ -110,18 +114,16 @@ void RecognizeSystem::recognize() qDebug() << data; emit sigXmlParser(clientHandler,data); - //dataParser->xmlParser(clientHandler,data); packetType = PacketType::TYPE_NONE; continue; } if(packetType == PacketType::TYPE_FOLDER) //создание папок - { if(client->getIsUnity()) { filePath = socket->readAll(); - filePath = Tools::createRootScenario(filePath); + filePath = Tools::createSharedPath(filePath); } else { @@ -154,12 +156,7 @@ void RecognizeSystem::recognize() { DataInfo *currentFileData = dataParser->getCurrentDataInfo(); filePath = currentFileData->path; - - filePath = Tools::createLocalPath(filePath); - - filePath = Tools::createUpdateFilePath(filePath); - - filePath = Tools::createRootScenario(filePath); + filePath = Tools::createSharedPath(filePath); QFile file(filePath); @@ -315,6 +312,69 @@ void RecognizeSystem::recognize() packetType = PacketType::TYPE_NONE; } + if(packetType == PacketType::CHANGE_DATA_VERSION) + { + stream.startTransaction(); + QString versionName; + stream >> versionName; + + if(!stream.commitTransaction()) continue; + + qDebug() << "For change " + versionName; + + emit sigChangeVersion(versionName); + + } + + if(packetType == PacketType::COPY_VERSION) + { + QString source; + QStringList result; + + stream.startTransaction(); + stream >> source; + + if(!stream.commitTransaction()) continue; + + result = source.split(";"); + + if (updateController->checkDuplicate(result[1])) + { + sendSystem->sendNotify(commandDuplicateVerName); + packetType = PacketType::TYPE_NONE; + break; + } + + emit sigCopyVersion(result[0],result[1]); + sendSystem->sendPacketType(PacketType::BUSY); + } + + if(packetType == PacketType::DELETE_DATA_VERSION) + { + stream.startTransaction(); + QString versionName; + stream >> versionName; + + if(!stream.commitTransaction()) continue; + + qDebug() << "For delete " + versionName; + + + if (versionName == baseNameVersion) + { + sendSystem->sendNotify(commandTryBaseDelete); + } + else if (versionName == updateController->getCurrentVersionName()) + { + sendSystem->sendNotify(commandTryActiveDelete); + } + else + { + emit sigDeleteVersion(versionName); + } + + } + packetType = PacketType::TYPE_NONE; } diff --git a/ServerLMS/ServerLMS/Systems/recognizesystem.h b/ServerLMS/ServerLMS/Systems/recognizesystem.h index 07b649a..8478139 100644 --- a/ServerLMS/ServerLMS/Systems/recognizesystem.h +++ b/ServerLMS/ServerLMS/Systems/recognizesystem.h @@ -1,16 +1,19 @@ #ifndef RECOGNIZESYSTEM_H #define RECOGNIZESYSTEM_H -#include "client.h" -#include "updatecontroller.h" - #include #include -#include "Systems/tools.h" -#include "Systems/dataparser.h" -#include "serverlmswidget.h" #include +#include +#include +#include + +#include +#include + +#include "serverlmswidget.h" + class UpdateController; class ServerLMSWidget; class ClientHandler; @@ -31,6 +34,9 @@ signals: void sigCalculateHash(); void sigSendToLogger(QString string); void sigXmlParser(ClientHandler *clientHandler,QByteArray data); + void sigChangeVersion(QString versionName); + void sigDeleteVersion(QString versionName); + void sigCopyVersion(QString versionName,QString newVersionName); private: UpdateController *updateController; diff --git a/ServerLMS/ServerLMS/Systems/sendsystem.cpp b/ServerLMS/ServerLMS/Systems/sendsystem.cpp index b1f8908..fec9774 100644 --- a/ServerLMS/ServerLMS/Systems/sendsystem.cpp +++ b/ServerLMS/ServerLMS/Systems/sendsystem.cpp @@ -11,9 +11,10 @@ void SendSystem::initialize(DataParser *dataParser,Logger *logger) this->dataParser = dataParser; this->logger = logger; - connect(this,&SendSystem::sigSendToLogger,logger,&Logger::addTextToLogger); - connect(this,&SendSystem::sigSendXMLmessage,dataParser,&DataParser::xmlAnswer_message,Qt::BlockingQueuedConnection); - connect(this,&SendSystem::sigSendNotify,dataParser,&DataParser::xmlAnswer_notify,Qt::BlockingQueuedConnection); + connect(this,&SendSystem::sigSendToLogger,logger,&Logger::addTextToLogger,Qt::AutoConnection); + connect(this,&SendSystem::sigSendXMLmessage,dataParser,&DataParser::xmlAnswer_message,Qt::AutoConnection); + connect(this,&SendSystem::sigSendNotify,dataParser,&DataParser::xmlAnswer_notify,Qt::DirectConnection); //потому что возвращает значение + connect(this,&SendSystem::sigSendVersion,dataParser,&DataParser::xmlAnswer_currentVersion,Qt::AutoConnection); qDebug() << "SendSystem thread: " << QThread::currentThreadId(); } @@ -41,7 +42,7 @@ void SendSystem::sendFileBlock(QString path) QDataStream stream(socket); stream.setVersion(QDataStream::Qt_DefaultCompiledVersion); - QFile file(Tools::createRootPath(path)); + QFile file(path); QFileInfo fileInfo(file); fileSize = fileInfo.size(); @@ -81,15 +82,10 @@ void SendSystem::sendFileBlock(QString path) socket->waitForReadyRead(100); } -void SendSystem::socketWrite(QByteArray array) +void SendSystem::sendVersion() { - socket->write(array); - socket->waitForBytesWritten(100); -} - -void SendSystem::socketClose() -{ - socket->close(); + QByteArray data = dataParser->xmlAnswer_currentVersion(); + sendXmlAnswer(data); } void SendSystem::sendFileBlockWithRename(QString path, QString newName) @@ -139,7 +135,7 @@ void SendSystem::sendFileBlockWithRename(QString path, QString newName) socket->waitForBytesWritten(); socket->waitForReadyRead(100); - sendNotify("HASHSENDCOMPLETE"); + sendNotify(commandHashCompleteClient); } void SendSystem::sendFolderBlock(QString path) @@ -162,19 +158,19 @@ void SendSystem::sendDeleteBlock(QString path) socket->waitForReadyRead(100); } -void SendSystem::sendHello() -{ - socket->write(SERVER_HELLO); -} - -void SendSystem::sendFinish() +void SendSystem::sendPacketType(PacketType packetType) { QDataStream stream(socket); stream.setVersion(QDataStream::Qt_DefaultCompiledVersion); - stream << PacketType::TYPE_FINISH; + stream << packetType; socket->waitForReadyRead(100); } +void SendSystem::sendHello() +{ + socket->write(SERVER_HELLO); +} + void SendSystem::sendNotify(QString notify) { qDebug() << "SendNotify thread: " << QThread::currentThreadId(); @@ -202,7 +198,7 @@ void SendSystem::sendXmlAnswer(QByteArray array, PacketType packetType) socket->waitForReadyRead(1000); } -void SendSystem::sendNeedUpdate(bool flag,quint64 size,quint64 fileCount) +void SendSystem::sendNeedUpdate(bool flag,quint64 size,quint64 fileCount,quint64 deleteCount) { QDataStream stream(socket); stream.setVersion(QDataStream::Qt_DefaultCompiledVersion); @@ -210,9 +206,20 @@ void SendSystem::sendNeedUpdate(bool flag,quint64 size,quint64 fileCount) stream << flag; stream << size; stream << fileCount; + stream << deleteCount; } -void SendSystem::updateFiles(QList fileSendList, QList clientDataList){ +void SendSystem::updateFiles(QList fileSendList, QList deleteList){ + + QListIterator clientIterator(deleteList); + + while(clientIterator.hasNext()) + { + FileData data = clientIterator.next(); + + sendDeleteBlock(data.path); + if(getIsSendStopped()) return; + } QListIterator serverIterator(fileSendList); @@ -234,21 +241,28 @@ void SendSystem::updateFiles(QList fileSendList, QList clien if(getIsSendStopped()) return; } - QListIterator clientIterator(clientDataList); - while(clientIterator.hasNext()){ - FileData data = clientIterator.next(); - - sendDeleteBlock(data.path); - if(getIsSendStopped()) return; - } emit sigLoadHash(); - sendFinish(); + sendPacketType(PacketType::TYPE_FINISH); } +void SendSystem::socketWrite(QByteArray array) +{ + socket->write(array); + socket->waitForBytesWritten(100); +} +void SendSystem::socketClose() +{ + socket->close(); +} + +bool SendSystem::socketFlush() //TODO: проверить использование +{ + return socket->flush(); +} void SendSystem::sendStop() { diff --git a/ServerLMS/ServerLMS/Systems/sendsystem.h b/ServerLMS/ServerLMS/Systems/sendsystem.h index 011b053..0f08878 100644 --- a/ServerLMS/ServerLMS/Systems/sendsystem.h +++ b/ServerLMS/ServerLMS/Systems/sendsystem.h @@ -1,13 +1,15 @@ #ifndef SENDSYSTEM_H #define SENDSYSTEM_H -#include "dataparser.h" -#include "Systems/Tools.h" -#include "Client.h" #include #include #include +#include +#include +#include +#include + class DataParser; class FileData; class SendSystem : public QObject @@ -24,13 +26,15 @@ public: void sendFileBlockWithRename(QString path,QString newName); void sendFolderBlock(QString path); void sendDeleteBlock(QString path); + void sendPacketType(PacketType packet); void sendHello(); - void sendFinish(); void sendNotify(QString notify); void sendStop(); void sendXmlAnswer(QByteArray array, PacketType packetType = PacketType::TYPE_XMLANSWER); - void sendNeedUpdate(bool flag,quint64 size,quint64 fileCount); - void updateFiles(QList fileSendList, QList clientDataList); + void sendNeedUpdate(bool flag,quint64 size,quint64 fileCount,quint64 deleteCount); + void updateFiles(QList fileSendList, QList deleteList); + bool socketFlush(); + bool getIsSendStopped() const; ~SendSystem(); @@ -39,11 +43,14 @@ public: public slots: void socketWrite(QByteArray array); void socketClose(); + void sendVersion(); + signals: void sigLoadHash(); void sigSendToLogger(QString message); QByteArray sigSendXMLmessage(QString message, QString login = ""); QByteArray sigSendNotify(QString message); + QByteArray sigSendVersion(); private: Client *client; diff --git a/ServerLMS/ServerLMS/Systems/tools.cpp b/ServerLMS/ServerLMS/Systems/tools.cpp index 436dc1b..3b55145 100644 --- a/ServerLMS/ServerLMS/Systems/tools.cpp +++ b/ServerLMS/ServerLMS/Systems/tools.cpp @@ -15,7 +15,6 @@ QString Tools::getTime() QString Tools::createLocalPath(QString path) { - //qDebug() << "Full path: " << path; qint8 pos = path.indexOf(applicationFolderName); QString localPath = path.remove(0,--pos); @@ -29,10 +28,43 @@ QString Tools::createRootPath(QString path) return QDir::currentPath() + path; } -QString Tools::createRootScenario(QString path){ - return QDir::currentPath() + scenarioRootPath + path; +QString Tools::createSharedPath(QString path){ + return QDir::currentPath()+ "/" + sharedDataFolderName + path; } +QString Tools::createRealPath(QString path,StreamingVersionData* currentVersionData) +{ + QString resultPath; + int index = path.indexOf(currentVersionData->getViewName()); + + if(index != -1) + { + resultPath = path.remove(0,index + currentVersionData->getViewName().length()); + resultPath.prepend(buildDataPath + streamingAssetsFolderName); + } + else + { + resultPath = Tools::createRootPath(path); + } + + return resultPath; +} + +QString Tools::createStreamingToRealPath(QString path,StreamingVersionData* streamingVersionData) +{ + QString resultPath = path; + int index = path.indexOf(streamingAssetsFolderName); + + if(index != -1) + { + resultPath = path.remove(0,index + streamingAssetsFolderName.length()); + resultPath.prepend(QDir::currentPath() + "/" + sharedDataFolderName + "/" + streamingVersionData->getViewName()); + } + + return resultPath; + + +} QString Tools::createUpdateFilePath(QString path) { diff --git a/ServerLMS/ServerLMS/Systems/tools.h b/ServerLMS/ServerLMS/Systems/tools.h index 748ec54..4a8eb54 100644 --- a/ServerLMS/ServerLMS/Systems/tools.h +++ b/ServerLMS/ServerLMS/Systems/tools.h @@ -8,42 +8,33 @@ #include #include +#include + #define TCP_READ_TIMEOUT 5000 static QString staticDataFolderName = "StaticData"; static QString applicationFolderName = "Application"; +static QString sharedDataFolderName = "SharedData"; static QString streamingAssetsFolderName = "StreamingAssets"; static QString tempFile = staticDataFolderName + "/save.xml"; +static QString version = staticDataFolderName + "/version.xml"; +static QString versionListFile = staticDataFolderName + "/versionList.xml"; static QString hashFileName = staticDataFolderName + "/serverHash.xml"; -static QString scenarioRootPath = "\\Application\\RRJLoader\\RRJ_Data"; +static QString buildHashName = staticDataFolderName + "/buildHash.xml"; +static QString buildDataPath = "/Application/RRJLoader/RRJ_Data/"; -enum PacketType -{ - TYPE_NONE = 0, - TYPE_UNITY = 1, - TYPE_FILE = 2, - TYPE_COMMAND =3, - TYPE_FOLDER = 4, - TYPE_DELETE = 5, - TYPE_FINISH = 6, - TYPE_NEEDUPDATE = 7, - TYPE_XMLANSWER = 8, - TYPE_QT = 9, - TYPE_DISABLE = 11, - TYPE_FILESIZE = 20, +static QString baseNameVersion = "base";//может вынести комманды куда нибудь? - TYPE_XMLANSWER_MESSAGE_FOR_GUI = 90, - - //xml-ответы на запросы к БД - TYPE_XMLANSWER_QUERY_DB__LIST_INSTRUCTORS = 100, - TYPE_XMLANSWER_QUERY_DB__LIST_GROUPS = 101, - TYPE_XMLANSWER_QUERY_DB__LIST_TRAINEES = 102, - TYPE_XMLANSWER_QUERY_DB__LIST_COMPUTERS = 103, - TYPE_XMLANSWER_QUERY_DB__LIST_CLASSROOMS = 104, - TYPE_XMLANSWER_QUERY_DB__LIST_TASKS = 105 -}; - -Q_DECLARE_METATYPE(PacketType) +static QString commandTryBaseDelete = "BASEDELETETRY"; +static QString commandTryActiveDelete = "TRYACTIVEDELETE"; +static QString commandTryCopyWithSameNames = "SAMENAMES"; +static QString commandGetServerDataList = "GETSERVERDATALIST"; +static QString commandCheckVersionList = "CHECKVERSIONLIST"; +static QString commandReadyClient = "READY"; +static QString commandDisableClient = "DISABLE"; +static QString commandDuplicateVerName = "DUPLICATEVERNAME"; +static QString commandHashCompleteClient = "HASHSENDCOMPLETE"; +static QString commandUpdateFilesClient = "update"; class Tools { public: @@ -53,7 +44,9 @@ public: static QString createRootPath(QString path); static QString createUpdateFilePath(QString path); static QString createFolderPath(QString path); - static QString createRootScenario(QString path); + static QString createSharedPath(QString path); + static QString createRealPath(QString path,StreamingVersionData* currentVersionData); + static QString createStreamingToRealPath(QString path, StreamingVersionData *streamingVersionData); }; diff --git a/ServerLMS/ServerLMS/Systems/updatecontroller.cpp b/ServerLMS/ServerLMS/Systems/updatecontroller.cpp index 1c2eb0b..c9e5105 100644 --- a/ServerLMS/ServerLMS/Systems/updatecontroller.cpp +++ b/ServerLMS/ServerLMS/Systems/updatecontroller.cpp @@ -1,25 +1,54 @@ #include "updatecontroller.h" -void UpdateController::initialize(TCPServer *server,DataParser *dataParser) +UpdateController::UpdateController(QObject *parent) : + QObject(parent), + server(nullptr) +{ + buildPath = QDir::currentPath() + "/" + applicationFolderName; + sharedDataPath = QDir::currentPath() + "/" + sharedDataFolderName; + emit sigLogMessage(buildPath); + qDebug() << hashFileName; +} + +void UpdateController::initialize(ServerLMSWidget *server,DataParser *dataParser,AssetsManager *assetManager) { this->server = server; this->dataParser = dataParser; + this->assetManager = assetManager; + sizeToSend = 0; + assetManager->initialize(this,dataParser); + + calculateFullHash(); + currentStreamingPath = assetManager->setVersion("base"); + setUpCurrentServerHash(); + mutex = new QMutex; + qDebug() << "UpdateController init thread ID " << QThread::currentThreadId(); } -UpdateController::UpdateController(QObject *parent) : QObject(parent) +void UpdateController::changeAssetVersion(QString versionName) { - sourcePath = QDir::currentPath() + "/" + applicationFolderName; - emit sigLogMessage(sourcePath); - qDebug() << hashFileName; + server->slot_sendPacketToAllClients(PacketType::BUSY); + qDebug() << "UpdateController thread ID " << QThread::currentThreadId(); + currentStreamingPath = assetManager->setVersion(versionName); + setUpCurrentServerHash(); + server->slot_sendPacketToAllClients(PacketType::HASH_READY); + server->sendCurrentVersionToAllClient(); - if(!QFile::exists(hashFileName)){ - calculateHash(); - }else{ - loadHash(); - } + server->slot_sendPacketToAllClients(PacketType::FREE); +} +void UpdateController::createCopyVersion(QString versionName,QString newVersionName) +{ + server->slot_sendPacketToAllClients(PacketType::BUSY); + assetManager->createCopyVersion(versionName,newVersionName); + server->slot_sendPacketToAllClients(PacketType::FREE); +} + +void UpdateController::deleteAssetVersion(QString versionName) +{ + assetManager->deleteVersion(versionName); } void UpdateController::compareFiles(ClientHandler* handler, QByteArray array) @@ -29,16 +58,6 @@ void UpdateController::compareFiles(ClientHandler* handler, QByteArray array) clientDataList.clear(); dataParser->xmlFileDataParse(array); clientDataList.append(*dataParser->getDatas()); - - //Вывод информации о доступных файлов/* - // QListIterator iterator(clientDataList); - // while(iterator.hasNext()){ - // auto data = iterator.next(); - // emit sigLogMessage(data.path); - // emit sigLogMessage(data.hash); - // emit sigLogMessage("____________"); - // }*/ - checkNeedUpdate(handler); mutex->unlock(); } @@ -51,18 +70,30 @@ void UpdateController::showHash() } } -void UpdateController::saveHash() +void UpdateController::calculateFullHash() { - QFile hashFile(hashFileName); + server->slot_sendPacketToAllClients(PacketType::BUSY); + auto *list = calculateHash(buildPath); + saveHash(buildHashName,list); + calculateSharedHash(); + emit sigLogMessage("Calculate hash complete"); + server->slot_sendPacketToAllClients(PacketType::FREE); +} + +void UpdateController::saveHash(QString fileName,QList *fileList) +{ + QFile hashFile(fileName); hashFile.open(QIODevice::WriteOnly); QXmlStreamWriter xmlWriter(&hashFile); + QListIterator fileDataIterator(*fileList); xmlWriter.setAutoFormatting(true); xmlWriter.writeStartDocument(); xmlWriter.writeStartElement("FileDataList"); - foreach (FileData data,serverDataList) + while (fileDataIterator.hasNext()) { + FileData data = fileDataIterator.next(); xmlWriter.writeStartElement("FileData"); xmlWriter.writeAttribute("Path",data.path); @@ -124,7 +155,7 @@ void UpdateController::loadHash() void UpdateController::calculateSize() { - QDirIterator iterator(sourcePath); + QDirIterator iterator(buildPath); quint64 total = 0; while(iterator.hasNext()){ @@ -149,6 +180,23 @@ QString UpdateController::getCommands() } + + +void UpdateController::setUpCurrentServerHash() +{ + QList *fileList = new QList; + fileList->append(*calculateHash(buildPath)); + fileList->append(*calculateHash(currentStreamingPath)); + assetManager->prepareLocalPathList(fileList); + + saveHash(hashFileName,fileList); +} + +QString UpdateController::getCurrentStreamingPath() const +{ + return currentStreamingPath; +} + void UpdateController::setLocalFileData(QList dataList) { serverDataList.append(dataList); @@ -184,32 +232,6 @@ bool UpdateController::checkNeedUpdate(ClientHandler *handler) forSend->append(item); } } -// for (auto &item:clientDataList) //проверка на недостающие файлы по адресам -// { -// if (!serverDataList.contains(item)) -// { -// serverDataList.removeOne(item); -// clientDataList.removeOne(item); -// } -// } - -// for (auto &item:clientDataList) //проверка на недостающие файлы по адресам -// { -// if(item.path.contains("Temp")){ -// clientDataList.removeOne(item); -// } -// } - -// QListIterator serverDiffIterator(serverDataList); - -// while (serverDiffIterator.hasNext()) //добавление недостающих файлов в список для отправки -// { -// auto fileForUpdate = serverDiffIterator.next(); - -// if(fileForUpdate.path.contains("Temp")) continue; - -// fileSendList.append(fileForUpdate); -// } if(forSend->length() > 0) //формирование сообщения об обновлении { @@ -220,7 +242,10 @@ bool UpdateController::checkNeedUpdate(ClientHandler *handler) log.append(QString::number(forSend->length())); log.append(" objects"); fileSendList = *forSend; + emit sigLogMessage(log); + printFileList(*forSend); + handler->sendMessageBlock(log); needUpdate = true; } @@ -242,10 +267,10 @@ bool UpdateController::checkNeedUpdate(ClientHandler *handler) log.append(" Need delete: "); log.append(QString::number(forDelete->length())); log.append(" objects"); - //ОПАСНОСТЬ С РУКИ! УДАЛИТЬ И ПРИВЕСТИ В ПОРЯДОК - clientDataList = *forDelete; - // + fileDeleteList = *forDelete; + emit sigLogMessage(log); + printFileList(*forDelete); handler->sendMessageBlock(log); needUpdate = true; } @@ -255,33 +280,27 @@ bool UpdateController::checkNeedUpdate(ClientHandler *handler) log.append(Tools::getTime()); log.append(" Client: " + handler->getClient()->getLogin()); log.append(" no delete required"); + emit sigLogMessage(log); handler->sendMessageBlock(log); } CalculateSizeToSend(*forSend); - handler->sendNeedUpdate(needUpdate,sizeToSend,forSend->length()); - + handler->sendNeedUpdate(needUpdate,sizeToSend,forSend->length(),forDelete->length()); return needUpdate; } -void UpdateController::calculateHash() +QList* UpdateController::calculateHash(QString path) { - - QFile file(hashFileName); serverDataList.clear(); - if(file.exists()){ - file.remove(); + QDirIterator iterator(path,QDirIterator::Subdirectories); + if(!QDir(path).exists()){ + QDir().mkdir(path); } - QDirIterator iterator(sourcePath,QDirIterator::Subdirectories); - - if(!QDir(applicationFolderName).exists()){ - QDir().mkdir(applicationFolderName); - } - - QDir dir(sourcePath); + QDir dir(path); + dir.setFilter(QDir::NoDotAndDotDot); QString hashString; QList *files = new QList; @@ -323,21 +342,15 @@ void UpdateController::calculateHash() currentFile.hash = "FOLDER"; currentFile.path = Tools::createLocalPath(fileInfo.path()); - if(!folderDataList.contains(currentFile)){ - folderDataList.push_back(currentFile); + if(!files->contains(currentFile)){ + files->push_back(currentFile); } - } } - emit sigLogMessage("Calculate hash complete"); - serverDataList.append(folderDataList); + std::sort(files->begin(),files->end()); serverDataList.append(*files); - - saveHash(); - - qDebug() << "Recalculate complete"; - delete files; + return files; } QByteArray UpdateController::getLocalHash() @@ -352,28 +365,96 @@ QByteArray UpdateController::getLocalHash() return array; } +QString UpdateController::getCurrentVersionName() +{ + return assetManager->getCurrentVersionData()->getViewName(); +} + void UpdateController::CalculateSizeToSend(QList diffList) { QListIterator serverDiffIterator(diffList); - while (serverDiffIterator.hasNext()) //добавление недостающих файлов в список для отправки + while (serverDiffIterator.hasNext()) { - auto pathForUpdate = serverDiffIterator.next(); - QString path = Tools::createRootPath(pathForUpdate.path); + QString path; + FileData pathForUpdate = serverDiffIterator.next(); + if(pathForUpdate.path.contains(streamingAssetsFolderName)) + { + path = Tools::createStreamingToRealPath(pathForUpdate.path,assetManager->getCurrentVersionData()); + } + else + { + path = Tools::createRootPath(pathForUpdate.path); + } + QFile file(path); sizeToSend += file.size(); } } -UpdateController::~UpdateController() +void UpdateController::calculateSharedHash() { + QDir sharedDir(sharedDataPath); + QDirIterator dirIterator(sharedDir); + QList *fileList = new QList; + QList *versionList = new QList; + while (dirIterator.hasNext()) + { + dirIterator.next(); + QFileInfo fileInfo = dirIterator.fileInfo(); + if (fileInfo.fileName() == "." || fileInfo.fileName() == "..") + continue; + + QString fileName = staticDataFolderName + "/" + fileInfo.fileName() + "Hash.xml"; + + fileList = calculateHash(fileInfo.absoluteFilePath()); + saveHash(fileName,fileList); + + StreamingVersionData *version = new StreamingVersionData( + fileInfo.absoluteFilePath(),fileInfo.fileName(), + fileInfo.birthTime(),fileInfo.size()); + + versionList->append(version); + + } + + dataParser->createVersionListXmlAnswer(*versionList); + assetManager->setVersionList(versionList); } -QList UpdateController::getFileSendList() const +void UpdateController::sendNewVersionList() { - return fileSendList; + server->sendNewVersionListToAllClient(); +} + +bool UpdateController::checkDuplicate(QString versionName) +{ + return assetManager->findDuplicate(versionName); +} + +void UpdateController::printFileList(QList fileData) +{ + QListIterator iterator(fileData); + + while (iterator.hasNext()) + { + auto next = iterator.next(); + emit sigLogMessage(next.path); + } +} + +QList UpdateController::getFileDeleteList() const +{ + return fileDeleteList; +} + +QList UpdateController::getFileSendList() +{ + + QList sendList = *assetManager->prepareRealPathList(&fileSendList); + return sendList; } @@ -382,3 +463,8 @@ QList UpdateController::getClientDataList() const return clientDataList; } +UpdateController::~UpdateController() +{ + +} + diff --git a/ServerLMS/ServerLMS/Systems/updatecontroller.h b/ServerLMS/ServerLMS/Systems/updatecontroller.h index a3b3457..5bbaa02 100644 --- a/ServerLMS/ServerLMS/Systems/updatecontroller.h +++ b/ServerLMS/ServerLMS/Systems/updatecontroller.h @@ -9,13 +9,16 @@ #include #include #include -#include "Systems/dataparser.h" -#include "typesDataServerClient.h" + +#include +#include class TCPServer; class SendSystem; class DataParser; class ClientHandler; +class AssetsManager; +class ServerLMSWidget; class UpdateController : public QObject { @@ -24,39 +27,57 @@ class UpdateController : public QObject public: explicit UpdateController(QObject *parent = 0); - void initialize(TCPServer* server,DataParser *dataParser); + void initialize(ServerLMSWidget* server,DataParser *dataParser,AssetsManager *assetManager); void compareFiles(ClientHandler* handler, QByteArray array); void showHash(); - void calculateHash(); + void calculateFullHash(); + void calculateSharedHash(); + void sendNewVersionList(); + void setCurrentStreamingPath(QString path); + bool checkDuplicate(QString versionName); + QList* calculateHash(QString path); QByteArray getLocalHash(); - QList getFileSendList() const; + QString getCurrentVersionName(); + QList getFileSendList(); QList getClientDataList() const; + QList getFileDeleteList() const; + QString getCurrentStreamingPath() const; ~UpdateController(); +public slots: + void changeAssetVersion(QString versionName); + void createCopyVersion(QString versionName,QString newVersionName); + void deleteAssetVersion(QString versionName); + void setUpCurrentServerHash(); signals: void sigLogMessage(QString message); + //void sigSendPackege(PacketType packetType); private: QList clientDataList; QList serverDataList; - QList folderDataList; QList fileSendList; QList fileDeleteList; - QString sourcePath; - TCPServer *server; + QString buildPath; + QString currentStreamingPath; + QString sharedDataPath; + ServerLMSWidget *server; DataParser *dataParser; + AssetsManager *assetManager; quint64 sizeToSend; QMutex *mutex; QString getCommands(); + void printFileList(QList fileData); + bool checkNeedUpdate(ClientHandler* handler); void setLocalFileData(QList dataList); void calculateSize(); - void saveHash(); + void saveHash(QString fileName,QList *fileList); void loadHash(); void CalculateSizeToSend(QList diffList); }; diff --git a/ServerLMS/ServerLMS/clienthandler.cpp b/ServerLMS/ServerLMS/clienthandler.cpp index 34a1813..2ab918e 100644 --- a/ServerLMS/ServerLMS/clienthandler.cpp +++ b/ServerLMS/ServerLMS/clienthandler.cpp @@ -44,16 +44,19 @@ void ClientHandler::initialize(int descriptor,ServerLMSWidget *serverWidget, connect(this,&ClientHandler::sigFolderBlock,sendSystem,&SendSystem::sendFolderBlock,Qt::AutoConnection); connect(this,&ClientHandler::sigGetIsSendStopped,sendSystem,&SendSystem::getIsSendStopped,Qt::AutoConnection); connect(this,&ClientHandler::sigSendDeleteBlock,sendSystem,&SendSystem::sendDeleteBlock,Qt::AutoConnection); - connect(this,&ClientHandler::sigSendFinish,sendSystem,&SendSystem::sendFinish,Qt::AutoConnection); + connect(this,&ClientHandler::sigSendFinish,sendSystem,&SendSystem::sendPacketType,Qt::AutoConnection); connect(this,&ClientHandler::sigSendMessageBlock,sendSystem,&SendSystem::sendMessageBlock,Qt::AutoConnection); connect(this,&ClientHandler::sigNeedUpdate,sendSystem,&SendSystem::sendNeedUpdate,Qt::AutoConnection); connect(this,&ClientHandler::sigSendNotify,sendSystem,&SendSystem::sendNotify,Qt::AutoConnection); connect(this,&ClientHandler::sigSendFileBlockWithRename,sendSystem,&SendSystem::sendFileBlockWithRename,Qt::AutoConnection); - connect(socket,&QTcpSocket::readyRead,recognizeSystem,&RecognizeSystem::recognize,Qt::AutoConnection); - connect(socket, &QTcpSocket::disconnected, this, &ClientHandler::sendDisable,Qt::AutoConnection); + connect(this,&ClientHandler::sigSendVersion,sendSystem,&SendSystem::sendVersion,Qt::AutoConnection); connect(this,&ClientHandler::sigSocketWrite,sendSystem,&SendSystem::socketWrite,Qt::AutoConnection); connect(this,&ClientHandler::sigSocketClose,sendSystem,&SendSystem::socketClose,Qt::AutoConnection); + connect(this,&ClientHandler::sigSocketFlush,sendSystem,&SendSystem::socketFlush,Qt::AutoConnection); + connect(this,&ClientHandler::sigSendPacketType,sendSystem,&SendSystem::sendPacketType,Qt::AutoConnection); + connect(socket,&QTcpSocket::readyRead,recognizeSystem,&RecognizeSystem::recognize,Qt::AutoConnection); + connect(socket, &QTcpSocket::disconnected, this, &ClientHandler::sendDisable,Qt::AutoConnection); recognizeSystem->initialize(updateController,dataParser,serverWidget,sendSystem, this); sendSystem->setClient(client,socket); @@ -62,6 +65,11 @@ void ClientHandler::initialize(int descriptor,ServerLMSWidget *serverWidget, emit sigInitSender(dataParser,logger); } +void ClientHandler::setClient(Client *value) +{ + client = value; +} + void ClientHandler::sendHash() { QString path = "\\" + hashFileName; @@ -69,21 +77,31 @@ void ClientHandler::sendHash() //emit sigSendNotify("HASHSENDCOMPLETE"); } +void ClientHandler::sendVersion() +{ + emit sigSendVersion(); +} + +void ClientHandler::sendVersionList() +{ + QFile file(versionListFile); + file.open(QFile::ReadOnly); + + QByteArray array = file.readAll(); + file.close(); + emit sendXmlAnswer(array); +} + +void ClientHandler::sendPacketType(PacketType packetType) +{ + emit sigSendPacketType(packetType); +} + void ClientHandler::sendXmlAnswer(QByteArray array, PacketType packetType) { emit sigSendXmlAnswer(array, packetType); } -void ClientHandler::sendFolderBlock(QString path) -{ - emit sigFolderBlock(path); -} - -void ClientHandler::sendFileBlock(QString path) -{ - emit sigFileBlock(path); -} - bool ClientHandler::getIsSendStopped() { return emit sigGetIsSendStopped(); @@ -96,7 +114,7 @@ void ClientHandler::sendDeleteBlock(QString path) void ClientHandler::sendFinish() { - emit sigSendFinish(); + emit sigSendFinish(PacketType::TYPE_FINISH); } void ClientHandler::sendMessageBlock(QString text) @@ -104,9 +122,9 @@ void ClientHandler::sendMessageBlock(QString text) emit sigSendMessageBlock(text); } -void ClientHandler::sendNeedUpdate(bool flag, quint64 size, quint64 fileCount) +void ClientHandler::sendNeedUpdate(bool flag, quint64 size, quint64 fileCount,quint64 deleteCount) { - emit sigNeedUpdate(flag,size,fileCount); + emit sigNeedUpdate(flag,size,fileCount,deleteCount); } void ClientHandler::sendDisable() diff --git a/ServerLMS/ServerLMS/clienthandler.h b/ServerLMS/ServerLMS/clienthandler.h index f28cfce..8b2f478 100644 --- a/ServerLMS/ServerLMS/clienthandler.h +++ b/ServerLMS/ServerLMS/clienthandler.h @@ -2,11 +2,13 @@ #define CLIENTHANDLER_H #include -#include -#include "Client.h" #include #include -#include "Systems/tools.h" + +#include +#include +#include +#include class SendSystem; class DataParser; @@ -29,10 +31,13 @@ public: void sendDeleteBlock(QString path); void sendFinish(); void sendMessageBlock(QString text); - void sendNeedUpdate(bool flag, quint64 size,quint64 fileCount); + void sendNeedUpdate(bool flag, quint64 size,quint64 fileCount,quint64 deleteCount); void sendDisable(); void recognize(); void sendHash(); + void sendVersionList(); + void sendPacketType(PacketType packetType); + void sendVersion(); ~ClientHandler(); @@ -48,9 +53,9 @@ signals: void sigFileBlock(QString path); bool sigGetIsSendStopped(); void sigSendDeleteBlock(QString path); - void sigSendFinish(); + void sigSendFinish(PacketType packetType); void sigSendMessageBlock(QString text); - void sigNeedUpdate(bool flag,quint64 size,quint64 fileCount); + void sigNeedUpdate(bool flag,quint64 size,quint64 fileCount,quint64 deleteCount); void sigClientDisconnected(QString address,QString port); void sigSendHash(); void sigRecognize(ClientHandler *handler); @@ -59,13 +64,16 @@ signals: void sigSocketWrite(QByteArray array); void sigSocketClose(); bool sigSocketFlush(); + void sigSendVersion(); + void sigSendPacketType(PacketType packetType); public : QThread *thread; QTcpSocket *socket; void initialize(int descriptor, ServerLMSWidget *serverWidget, - UpdateController *updateController, DataParser *dataParser,Logger *logger); + UpdateController *updateController, DataParser *dataParser,Logger *logger); + void setClient(Client *value); private: UpdateController *updateController; RecognizeSystem *recognizeSystem; diff --git a/ServerLMS/ServerLMS/serverlmswidget.cpp b/ServerLMS/ServerLMS/serverlmswidget.cpp index 66685e0..a72233e 100644 --- a/ServerLMS/ServerLMS/serverlmswidget.cpp +++ b/ServerLMS/ServerLMS/serverlmswidget.cpp @@ -51,8 +51,12 @@ ServerLMSWidget::ServerLMSWidget(QWidget *parent) : connect(logger,&Logger::sigSendTextToLogger,this,&ServerLMSWidget::slotAddToLog,Qt::QueuedConnection); logger->moveToThread(loggerThread); + assetsManager = new AssetsManager; + assetsManager->moveToThread(updateThread); + processingSystem = new ProcessingSystem(providerDBLMS); - dataParser = new DataParser(processingSystem); + processingSystem->moveToThread(updateThread); + dataParser = new DataParser(assetsManager,processingSystem); updateController = new UpdateController; updateController->moveToThread(updateThread); @@ -60,21 +64,19 @@ ServerLMSWidget::ServerLMSWidget(QWidget *parent) : loggerThread->start(); updateThread->start(); - updateController->initialize(nullptr,dataParser); + processingSystem->initialize(dataParser,this); logger->setTypeLog("widget"); - connect(processingSystem,&ProcessingSystem::sigUpdateListClients,this, &ServerLMSWidget::slotUpdateListClients); connect(updateController,&UpdateController::sigLogMessage,logger,&Logger::addTextToLogger); connect(dataParser,&DataParser::sigLogMessage,logger,&Logger::addTextToLogger); - connect(processingSystem,&ProcessingSystem::sigLogMessage,logger,&Logger::addTextToLogger); - connect(this,&ServerLMSWidget::sigLog,logger,&Logger::addTextToLogger); - connect(processingSystem,&ProcessingSystem::sigAuthChanged,this, &ServerLMSWidget::slot_AuthChanged); - connect(processingSystem,&ProcessingSystem::signal_msgToClientReady,this, &ServerLMSWidget::slot_msgToClientFromGUI); - connect(processingSystem,&ProcessingSystem::signal_msgFromClientReady,this, &ServerLMSWidget::slot_msgToGUIfromClient); + connect(this,&ServerLMSWidget::sigUpdateController,updateController,&UpdateController::initialize,Qt::DirectConnection); + connect(this,&ServerLMSWidget::sigLog,logger,&Logger::addTextToLogger,Qt::AutoConnection); + connect(this,&ServerLMSWidget::sigCalculateFullHash,updateController,&UpdateController::calculateFullHash,Qt::AutoConnection); + emit sigUpdateController(this,dataParser,assetsManager); on_btnStartServer_clicked(); first = true; @@ -95,6 +97,30 @@ void ServerLMSWidget::autorizationHandler(QString login) } } +void ServerLMSWidget::sendNewVersionListToAllClient() +{ + foreach(int idSocket,clientsMap.keys()) + { + ClientHandler *handler = clientsMap[idSocket]; + + if (!handler->getClient()->getIsLoggedIn()) continue; + + handler->sendVersionList(); + } +} + +void ServerLMSWidget::sendCurrentVersionToAllClient() +{ + foreach(int idSocket,clientsMap.keys()) + { + ClientHandler *handler = clientsMap[idSocket]; + + if (!handler->getClient()->getIsLoggedIn()) continue; + handler->sendVersion(); + + } +} + ServerLMSWidget::~ServerLMSWidget() { stopServer(); @@ -162,6 +188,11 @@ bool ServerLMSWidget::stopServer() return false; } +Logger *ServerLMSWidget::getLogger() const +{ + return logger; +} + QMap ServerLMSWidget::getClientsMap() const { return clientsMap; @@ -210,6 +241,18 @@ void ServerLMSWidget::slot_AuthChanged() } } +void ServerLMSWidget::slot_sendPacketToAllClients(PacketType packetType) +{ + foreach(int idSocket, clientsMap.keys()) + { + ClientHandler *handler = clientsMap[idSocket]; + + if (!handler->getClient()->getIsLoggedIn()) continue; + + handler->sendPacketType(packetType); + } +} + void ServerLMSWidget::removeClient(int idSocket) { clientsMap.remove(idSocket); @@ -293,7 +336,7 @@ void ServerLMSWidget::on_btnStartServer_clicked() if(startServer()) { QApplication::setOverrideCursor(Qt::WaitCursor); - updateController->calculateHash(); + emit sigCalculateFullHash(); QApplication::restoreOverrideCursor(); ui->btnStartServer->setEnabled(false); diff --git a/ServerLMS/ServerLMS/serverlmswidget.h b/ServerLMS/ServerLMS/serverlmswidget.h index af1090d..6935fab 100644 --- a/ServerLMS/ServerLMS/serverlmswidget.h +++ b/ServerLMS/ServerLMS/serverlmswidget.h @@ -1,23 +1,26 @@ #ifndef SERVERLMSWIDGET_H #define SERVERLMSWIDGET_H +#include "ServerLMS_global.h" + #include #include #include #include #include #include +#include + #include #include #include #include +#include #include #include -#include -#include "ServerLMS_global.h" -#include "typesDataServerClient.h" -#include "Client.h" +#include +#include #include "multithreadserver.h" #include "providerdblms.h" @@ -33,6 +36,7 @@ class UpdateController; class RecognizeSystem; class ClientHandler; class MultiThreadServer; +class AssetsManager; class SERVERLMS_EXPORT ServerLMSWidget : public QWidget { @@ -43,6 +47,8 @@ public: ~ServerLMSWidget(); void autorizationHandler(QString login); + void sendNewVersionListToAllClient(); + void sendCurrentVersionToAllClient(); protected: // Метод получения событий @@ -51,8 +57,11 @@ protected: signals: void sigRecognize(); - QTcpSocket* sigGetSocket(); void sigLog(QString log); + void sigCalculateFullHash(); + void sigUpdateController(ServerLMSWidget* server,DataParser *dataParser,AssetsManager *assetManager); + + QTcpSocket* sigGetSocket(); public slots: void slot_LanguageChanged(QString language); @@ -60,8 +69,7 @@ public slots: void slotUpdateListClients(); void slot_BlockAutorization(bool block); void slot_AuthChanged(); - -private slots: + void slot_sendPacketToAllClients(PacketType packetType); //слот обработки сигнала о готовности нового сообщения на отправку клиенту от мессенджера void slot_msgToClientFromGUI(QString login, QString text); void slot_msgToGUIfromClient(QString login, QString text); @@ -90,6 +98,8 @@ public: QMap getClientsMap() const; + Logger *getLogger() const; + private slots: void on_btnStartServer_clicked(); void on_btnStopServer_clicked(); @@ -115,6 +125,7 @@ private: DataParser *dataParser; ProcessingSystem *processingSystem; UpdateController *updateController; + AssetsManager *assetsManager; Logger *logger; ProviderDBLMS* providerDBLMS; From 12c1582768f01565a0d235d76eaadf7fc463a376 Mon Sep 17 00:00:00 2001 From: semenov Date: Tue, 14 Jan 2025 09:33:47 +0300 Subject: [PATCH 02/13] ref: start refactoring --- .../instructorsandtraineeswidget.cpp | 2 +- DOCS/.obsidian/workspace.json | 44 +- DOCS/CLIENT SERVER.canvas | 13 - DOCS/Desk.md | 451 -------------- DOCS/MainScheme.md | 455 ++++++++++++++ DOCS/Алексей/Board.md | 1 + DOCS/Алексей/DataParser scheme.md | 559 ++++++++++++++++++ DOCS/Алексей/ProcessingSystem scheme.md | 124 ++++ DOCS/Алексей/Рефакторинг.md | 2 +- DOCS/Как умеем принимать на Server.md | 1 - ...к умеем принимать, как умеем отправлять!.md | 8 + ServerLMS/ServerLMS/Systems/dataparser.cpp | 33 +- .../ServerLMS/Systems/processingsystem.cpp | 1 + ServerLMS/ServerLMS/Systems/sendsystem.cpp | 1 - ServerLMS/ServerLMS/providerdblms.cpp | 4 +- ServerLMS/ServerLMS/providerdblms.h | 1 + ServerLMS/ServerLMS/serverlmswidget.cpp | 16 +- 17 files changed, 1199 insertions(+), 517 deletions(-) delete mode 100644 DOCS/CLIENT SERVER.canvas delete mode 100644 DOCS/Desk.md create mode 100644 DOCS/MainScheme.md create mode 100644 DOCS/Алексей/DataParser scheme.md create mode 100644 DOCS/Алексей/ProcessingSystem scheme.md delete mode 100644 DOCS/Как умеем принимать на Server.md create mode 100644 DOCS/Как умеем принимать, как умеем отправлять!.md diff --git a/DB_IaT/InstructorsAndTrainees/instructorsandtraineeswidget.cpp b/DB_IaT/InstructorsAndTrainees/instructorsandtraineeswidget.cpp index 1a66ac1..323dc67 100644 --- a/DB_IaT/InstructorsAndTrainees/instructorsandtraineeswidget.cpp +++ b/DB_IaT/InstructorsAndTrainees/instructorsandtraineeswidget.cpp @@ -68,7 +68,7 @@ InstructorsAndTraineesWidget::InstructorsAndTraineesWidget(QWidget *parent) : messangerWidget->setMinimumSize(500, 600); messangerWidget->setMaximumWidth(500); - ui->btnAuthorizationInstructor->setEnabled(false); + //ui->btnAuthorizationInstructor->setEnabled(false); updateMyStyleSheet(); } diff --git a/DOCS/.obsidian/workspace.json b/DOCS/.obsidian/workspace.json index c1eaf4e..1ee8c5a 100644 --- a/DOCS/.obsidian/workspace.json +++ b/DOCS/.obsidian/workspace.json @@ -53,16 +53,28 @@ "state": { "type": "markdown", "state": { - "file": "Что умеем отправлять Server - Client QT.md", + "file": "Как умеем принимать, как умеем отправлять!.md", "mode": "source", "source": false }, "icon": "lucide-file", - "title": "Что умеем отправлять Server - Client QT" + "title": "Как умеем принимать, как умеем отправлять!" + } + }, + { + "id": "9608f84166966ca9", + "type": "leaf", + "state": { + "type": "excalidraw", + "state": { + "file": "MainScheme.md" + }, + "icon": "excalidraw-icon", + "title": "MainScheme" } } ], - "currentTab": 2 + "currentTab": 3 } ], "direction": "vertical" @@ -205,24 +217,26 @@ "obsidian-kanban:Создать новую доску": false } }, - "active": "77886c7575d9bc97", + "active": "9608f84166966ca9", "lastOpenFiles": [ - "Алексей/Board.md", - "Алексей/Чек лист по переносу.md", - "Алексей/ТЕСТ-КЕЙСЫ.md", - "Алексей/Рефакторинг.md", - "Без названия.md", - "Как умеем принимать на Server.md", + "Алексей/DataParser scheme.md", + "Алексей/ProcessingSystem scheme.md", + "MainScheme.md", + "Как умеем принимать, как умеем отправлять!.md", + "AssetManagerScheme.md", + "Образец отправки сообщения с маркером.md", "Что умеем отправлять Server - Client QT.md", - "Алексей/AssetManagerScheme.md", - "Desk.md", + "Порядок сборки Unity билда под сервер.md", "CLIENT SERVER.canvas", + "Алексей/Board.md", + "Алексей/Рефакторинг.md", + "Алексей/ТЕСТ-КЕЙСЫ.md", + "Алексей/Чек лист по переносу.md", + "Алексей/AssetManagerScheme.md", + "Без названия.md", "Андрей/Безымянная Kanban-доска.md", "Андрей/ВАЖНАЯ ЗАМЕТКА.md", - "Образец отправки сообщения с маркером.md", - "Порядок сборки Unity билда под сервер.md", "Алексей", - "AssetManagerScheme.md", "SERVER/UpdateController.md", "SERVER/Tools.md", "SERVER/SendSystem.md", diff --git a/DOCS/CLIENT SERVER.canvas b/DOCS/CLIENT SERVER.canvas deleted file mode 100644 index e32849f..0000000 --- a/DOCS/CLIENT SERVER.canvas +++ /dev/null @@ -1,13 +0,0 @@ -{ - "nodes":[ - {"id":"8b67634c475d7606","type":"text","text":"ОК\n\n* калькуляция хэша\n* запрос на обновление\n* активация кнопки обновить, если есть что\n","x":-2720,"y":-864,"width":250,"height":320}, - {"id":"8f45eeec193f5a05","type":"text","text":"Запуск","x":-2470,"y":-1238,"width":250,"height":60}, - {"id":"6e47f3d441f9bae2","type":"text","text":"Логин","x":-2470,"y":-1059,"width":250,"height":60}, - {"id":"d8ca6a5b5652434c","type":"text","text":"НЕ ОК\n\n* проверка на наличие исполняемого файла, если есть, активируем кнопку запустить","x":-2259,"y":-871,"width":250,"height":327} - ], - "edges":[ - {"id":"7108bb686df97a61","fromNode":"8f45eeec193f5a05","fromSide":"bottom","toNode":"6e47f3d441f9bae2","toSide":"top"}, - {"id":"8a4d686d8b1f45ee","fromNode":"6e47f3d441f9bae2","fromSide":"bottom","toNode":"8b67634c475d7606","toSide":"top"}, - {"id":"058d58d7b07be9a0","fromNode":"6e47f3d441f9bae2","fromSide":"bottom","toNode":"d8ca6a5b5652434c","toSide":"top"} - ] -} \ No newline at end of file diff --git a/DOCS/Desk.md b/DOCS/Desk.md deleted file mode 100644 index 6838925..0000000 --- a/DOCS/Desk.md +++ /dev/null @@ -1,451 +0,0 @@ ---- - -excalidraw-plugin: parsed -tags: [excalidraw] - ---- -==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠== You can decompress Drawing data with the command palette: 'Decompress current Excalidraw file'. For more info check in plugin settings under 'Saving' - - -# Excalidraw Data -## Text Elements -Инструктор ^UbO1uGDK - -Сервер ^Ng7jOhKt - -Хэш разный? ^myJh9kKL - -только Streaming assets ^lG2t8Jy9 - -ДА ^LKeOnhlV - -НЕТ ^2OwBgcpY - -Показываем список файлов для обновления и кнопку обновить ^PFZ7UV97 - -Запуск ^UUon7eVm - -Обновить ^7OENnVSS - -1. Делаем отправку по хэшу как на сервере -2.Отправляем команду на пересчет хэша на сервере ^A6DtzE7K - -Запуск ^N5WW0rpi - -игнор ^MtsjAaDF - -Unity ^GiWyCxvg - -Инструктор ^0OsBsFWy - -Изменил один объект ^Meo9byj1 - -Изменял объекты не отправляя ^Z6lEawmt - -Показываем кнопки отправить и сохранить ^0S20oqau - -Сlient Update ^C9fJAlri - -Отправить ^7xaCVWgs - -Если объект сохранен: -1. Удаляем из списка файлов для обновления -2. Отправляем средствами Unity. - -Если объект не сохранен: -1.Сохраняем, отправляем ^3KDkfwbf - -Сохранить ^KxsTafUf - -Если объект не был сохранен: -1. Добавляем в список файлов для отправки - -Если раннее уже был сохранен, сохраняем и обновляем хэш в списке - ^feBPTVyX - -Кнопка отправить ^RHz6SvIt - -1.Пробегаемся по ранее сформированному списку -2.Отправляем файлы через XMLAnswer -3.Отправляем команду на пересчет хэша - - ^wEGenkuD - -ServerLMS ^EJX4eIpX - -Mainthread: -*serverLMS -*processingSystem -*dataParser -*MultiThreadServer - - ^ite9vjus - - -ClientHandler: Thread -*sendSystem -*recognizeSystem -*socket ^hEBOsWWl - -LoggerThread: -*Logger ^BKJiGpRs - -UpdateThread: -*updateController -*assetsManager ^ZvWgIkFz - -Client QT ^sWMT4y6l - -MainThread: -*MainWindow -*UpdateNotifyWidget -*screenChecker -*extrnalExecuter -*allWidgets - ^NEUKUPV3 - -WorkerThread: -*sendSystem -*updateController -*recognizeSystem -*TCPClient -*socket -*dataParser -*hashComparer - - ^8BGt5wjC - -Порядок обмена при соединении QT-QT ^vVekpzl8 - -Server ^vCiXe90o - -Клиент ^NxeRvK3b - -connect ^9pnMpFqa - -потдверждение ^DifxXHXu - -Логин ^xcJKS4BO - -подтверждение захода ^LcNUC6DJ - -Тип клиента ^fHhFW5dd - -Отправка версии streamings ^j8y5I09L - -Отправка локального хэша ^WbkyDR4m - -Отправка расхождений ^WvPnPDNp - -Если инструктор ^m7Rgi4y8 - -FACT ^QIsaPO46 - -Server ^57kJSOBv - -Клиент ^Iao6ua8K - -Login/Pass ^FgztXDxQ - -XML Authorization ^FAEhzlqj - -Send version ^Wsgy80Do - -GetServerDataList ^mlJDR4kA - -Send Hash ^uj7L179t - -ERROR ^t7LNKLEC - -%% -## Drawing -```compressed-json -N4KAkARALgngDgUwgLgAQQQDwMYEMA2AlgCYBOuA7hADTgQBuCpAzoQPYB2KqATLZMzYBXUtiRoIACyhQ4zZAHoFAc0JRJQgEYA6bGwC2CgF7N6hbEcK4OCtptbErHALRY8RMpWdx8Q1TdIEfARcZgRmBShcZQUebQAWbQBGGjoghH0EDihmbgBtcDBQMBLoeHF0ADNAhE8qflLGFnYuNCSAZiSGyCbWTgA5TjFuAFYkgA5xgAZ4pPjuiEIOYixu - -CE14+lSSyEJmABF0qFruSoIwhZI17ABJKYBOcfwAMQBlYgB1AAkANmcAWQAauNnIR9hxKttSpVCPh8K9YME1oIPFCBFBSGwANYID4kdTcPiFdGYnEImBIiQoq4LTF+SQccK5NoLNhwXDYNQwbhJKZTBbWZSU1D84kQTDcZzxcbxH7adoAdh4CvuqvGCvG9x+C25bR4920Mrm43a7R+PBG4ySloWzAx2IQAGE2Pg2KQ1gBiJIIb3etHrDlY5R05bO - -13uiQY6zMdmBbL+ij4yTcaYLSQIQjKaQ8nhTQ2TdUjdoWka59W2hAnNDjIsjOsK+JEnYQYPCOA3YjM1B5AC6C2quEyHe4HCEcNpwmWjOYXdH47FmknxAAosFMtku72FkI4MRcMdiDylT85vFHjWkgqFkQOFiR2P8Ne2NgcYe0Gd8BcxXA2EscvliTAAodhKUUQLAKZAL7QDgJA5wkm0BUkIVEYph+MYZh4dV7naboShGeVTU6e4FR+VV0J4a0oLw - -2CdmcAiiItJJ7iLJILTwsA2ISeIeMtPkNTYkZqJgwCwGcBVkiSXkph4H4ZiSH4NRVDjKMI4sVSmFVxhPKZtOEkDaJKZxxnzAszM1KZUO1UTZO0H57IcxyHPafSdkMsSTPM8z7kstCONNRCkOmM8ZjGdp7jmVySnc4zTK8iyrP8gi6xS1LUviKKgNE2L4oLHzEtExs7IcnCVXaeIZIVKiQOggzss83KEr80TLWKxTc3uXMOk1SKapo+q4q8/LmvA9 - -DAqQnh2lLeJ2kskYMr6kTwPEyTpNk+TFOwjiqtWqS9v2h5MpihjTSYljOnY0SGzak8eFmYieJ+I7spO4sxnOwSOOmZ7loQ5CULQjDG2w3DRJNbRUqmDoZN000FR+kCwJA9VdvacZJo1eIlXuBGdnaCG6x+M0cJGUizXLUTOu4mafOYh4lX1XGSgk/a0YxmU+JQjjVQJussOBq17llJmwAaxrtIp8CedS/msMF4XFrq8C5m0Hg1eVH4sZGMjyvK7m - -DRlmU5eYhWdlqtzROY3n7Iq80Rg43l8f29CzXiS04ZFu7TIiuTrTth2Zm9hSoe1u7NRF4ttD5Pl5otcqFV0rpLbQm6nMclzFYt8CKu9ma5kmkYhaFgOTJ4njL06JDYfhzPosKxIy8bxvdfmZPS7LivLwTk0a7N/rs7ldXTU0/UFLk6zld06nZgVSvu8VEWz3Gk1cwu+3k8SPLg79sOcdrrLwO172E9knyWKtfXedLI3JhNp79/cxTrYeaYfOVRUv - -rF8WRbItSzRmOSaEZSg3ApMQauURY7X2tA3kLEvp/WQlZIGCkM59yWiBKBMC9oPHXuBDUqt1ZnnKpqd2vcSjmzrnghCWDsFwNEr/Ii/9ZR8jIqbch/cMHUJobA3BIFWoOSVA8LqaMIoLTQUrThu0YE4I4kvZCK8phr0gVwmhMj67Tybo3e+4is6SO4Tw2RcRHKlRwhVZU1UdGUL0dwtR4FwqrUsj8GsZMepiPYegnYDCiJyWYUAma/k8zqwUiqJx - -KEf4EXkYXa0Wk3YqSdntF2mt3YLwfvQxI0deQ1jQkLXWDsJL/QKf9Cx7iJE7CPnlE+ZEcEX1EvjVKZEpKagLnpVJh8CJ7UolqCYlktYcUgq0vh+NGHDNOmxPpi8DTyOLIoz62UEECRlJtQWpNF4N00c3Gardlosz2mzRUMolQ1gjgafanUzwdAmJsji8E8wCM0lNRS3cqoRwkkRcuMpKqzwbNc3kbUE6z21lXdUSQI5xGjj0uOWNE4/LiI3Pimkr - -QWk9nKNOacRpwS4nC6YCLBKe3iVJRJbt0ZjLmbCsu8KBJIoGTsVSby5hVSmrMdFdFMXkuxZSoS1KSiXnGoU5CiotkYrJbxdliLOWWIPiBVlbsLTo1lKWAVMLp4UrFSLX5AiUIVzkkXQVLLhVEv4qqrlYAdlST2ZjTmvC9XKtFbi41prurswNVzUlNrDV2rNsSChEB8ChCgM6fQ+g1AHgAAq/njGgOcj4xSsH0GOfcCAQ2BBnCICoGIhAIAWHAZNz - -BU2bh7IUAAvg0YopRYCIDWNUSsdR/S9BaCmcYCw60DCGBUDoVUNRoTRpcZYqwJAbHqGKPYhxggHlOOcTNQ63zoCgJoYglR9jPCSAAK0kAAaWwBoBUrx9D0DXRwBUABBf0MI4TkmFBAakh5bT2hxHiYgBI0BNlKHaUkCBz0VEvS6GkYo6RZmnF2JOzY2Qci5DyPkAoOBCgqEjSAEo0BSitIkRUyo3azx4pdZsupUDMROQ2YB6NZJAxvW+sMbpPS+h - -9EgBYmhAytiEKGF05HIzkA4DGXAcYoAJiTEeXlfKIo4TTBmLMXG0CKj/mhXM6ESKXgrFWHDnR5qOz1mKej7ZOz5G9QOIc06o0TgY8QAD955zNkXAZ1cGQsj/jQFuMUO49xjraMeU854xhXjFDeO8kaHxPhfPJj8X5mw/j/JuDxoFxnGrqSlKGs0yzhXCu58C/SJXuQdeag55oJ4gSi3WGLMMV6k3FSU3ROx1XOXOqqRT9kOKvTOqxKlKXLbCvClD - -M+x5ZLbVRujfZWNLw8DVXKcF5jZKzyJh0AON1wpFkqz01BxWrGlfyXy5CAmQFSqW8toKc2wAUMlYtvjhTVtxIcfqWeDwZImjVRt5bR2bKb0mD7EOdsrsHYKbduxgS1bBK1IWNViR1Yay1mRUsRYkpXzSilGaf2CFq1IkDlicd/KvKIpJwGMmyE7Y4aV/76s4coWB4j2pyPh7mjRx2qCXrrx+oDUGmQtQw1/mM9G5ssb43HCTUyVN3B02TqCzmvNm - -mi0lrFOWz9VbajkEHc2ZtrRUAmibUwPoHBBgcGGG0Nmk1FLVaHb2+D6ANgSkuAcI4/mJ2XGnRAQEAAlAAGv0AAMvgHgABNIQVuQ3KAAI6OgQF8HgABxZczxuT9lhPCREn6r3+lfQ6e9j7eAkYdB+5E37r2/uEP+pkPJWTsk5LAcDsGICCmFIXvXiG+TJFQrKTqlpZ46kJGaCGidUIyTOejRPOIyMRnQF6KjfoaN0ZDMQLvawoxsdjFZ7jD7kxoFN - -Xydasx7LMqkMJ7MepqYtbpiRSiSo5PTqwvHUs2vmxqY7Pm/s5AdNM/01OLP3mTOlDM8sCz65rPdm9fZhN06+snh4q52THmSwXmqAemHmz4r446n4vOpQwWG4AEpS4WokyW82e23KvKSCvITKcka2OwyBmOYWnE6BgMmBvI2BDsRB6EJBDYDWKB7kOWqE0McWOEJE/kV8eWcWFoYSxqtW709WVq3Kty5W02OEgMGOu27kPBzEfBDszWtMbWO+/W9q - -DiMkPiY8zK3KshrW9MChkCyhC+ahWWpWmhW+SofWFOliPq1OBgtOoa4aomIBPmMahAcavq7O/OgQ3OpAGaWa7h4QguJQxahQpakAoulaNQNaCuzQnAKYhhDAiuLQKuauOGDYHSqoheSwKweu6w8QIeQ6xuo6puUB5uawgIWIVuSQQg80mgAAQq8LgPsIQAAIrPDLj7D0AAAq9uuRzYp64eFIkeqe0et6uIPGT6He76EeKeqI+mmeM42eYoIGee2G - -0kkG0G3ApekoWMsohol4HQhcccWo9ebQMo2gCOgK5UwO6EjaMawxI+EgvelG/otGL49GjG4Yo+rG7GnGU+8ec+KhG048QmmYa+qA0oUc0cVoaM+WH8Ma1aDecwwSCcCwp+GmNmWml+CAw49+zOpQQ+Rm2JNGS4L+Vm5+dmu4X+R4skLmkwbm14QB1+YBfm06AW0BkAsBb+hk7ksGoEIs3JYAr0aMKEEsc0UOxq8yAMlB8kaEiiMh1MIOcqFEVURW - -+BCBhB/0GBUpZBlsBsKUsst8QsKyYpFByC0pOBJQXsW8vsocyp4htSbBjBuklEuYiW2W+M8iMwPkbs3UIskhH0mGIERUxiiopilUxSKpJWzMehqhS+hhJQPEGi6ybC4ZC2kZ2C/xi+gJhUg8X2LEOC0o5ouhaZ+hMZsiJk4KkJ0wcWYhWOqZUk8+0ZmZ2cZZEJ3U0JYhlOHmVhgawa9OdhDJLOzhbOiavhnh3h34vh+aQuQRIu5QYR1akuta8R0R - -1YsRMuiRbanUnQbMSJOumRawGwRg/ow6JuzJZuU6awHwUAmAlQAA8muoegAKoHrECHqkAUA8DVGaA3AwA3nVEnph7J5UiDHjFx4z4J43FvqAXoBR4zEMh344Y56gb55tAQZijF4wYLBl5Yzmg7FVREyWSUTFhHHJGDZEybQGpa4ukkgOh3E96Ub94LiD5Li0XQCfET7xgLCJjT7cCBklTBnlQySKpijpjAn2HikamL5yx76jBCyKKSnIl0jqakk9 - -EYlYkOEP6QB4nwWgGmZElrgkmabbjkmObJFUl/40kAHNieb9mlCuhMmQGBYwF2Ghaql8l4G2nKzGkkGmkRaNaHxqR1Zry+W0FgzgJeShLBXJmoGcQ46UQVRGwxYRVIGewISMQaRaQnhbnkHqnEEbRyyeztzlyzxdyaQkqeU5WSmSWTAvISak7SaWhAZSpeV5XVXGo5xmSaSoTaQqgurlWIK5VVXjCLxGJ8VlRmJCV9VIQSUKT5VtUjX2QmICUYy6 - -poEVXILmitWeoWG+p2g049nEAM4RrqU4kCCDmuHDmc4eFoA84+GXV+FolTklDBFlAVqRhYBcaRFK48hySfUJGtrcD/woQnzPq7C677mlhHn5EIAmUsnFESAPmaA3kVH+77Brr/lnqTFAXTEQWx6jHgUs7DFQVfrY3Nh/pwVzEsgLG55gYoWF7oXrGYWbEnwQzlSL5zAsRlWlDLFPyPCzQTDlRsQNhVTjEsUPFUZPFMUGYsVj5fGT6cV41mKqyzTS - -iMqaxQx17CWr72HgwTC61Wj6260g2XpwloDzSEbaTdqqaKVn6GVijaaYm6aOGk1Lj4nHWEnmb6VwFolGUObyY/7UkXhUU+r0kEmMkQHvhnk9GcBQCvCEBGAVD2QQxuzJ3zSp1/79jR3PCDiwjYZWrQDvVrCAAYIIALwggAgiCABCIIAAIggAwiCABcIOXYAHwgld/oku7RBdEgJdFdNd9dTd/oxwmAUAh6RAygsuPqCAlQH1YoTQUA5gBAQ9mYo9 - -UAbI/oeg2QuASwTAalOlpQbomYSwBAbdA9RdZdVdddjdzdAoQgS9Vu4QcdFQsNgBjIXwWtPIqs4qgRT1M5r16AHGmIUujQS5sujwv1LaquFQuYqGs0AMPae5/aRYkNI60NhRjluwFuSQzubA9uFAzAVu7QRgzuzgVuAAUqQJoJUI0c7vbswCMOjX0RejBTjXenjUbTHmSJjdBcBenvSK7Y1ZAIsTTThqhc2PTWgBsQho2NdPdB0KqLyKHMRRMAaE - -TELChCFJqOaCLUxt3hAGLQxaZpLW8cxjOmxRxnLWKFxfHl9lHG1oCr1rESJSJq/SnZNBaKqHnHzdJU+lJKRLTI2ApW2Dbd7XbapY7RpRAFpRTagMESEbOU+sSB/Y/npZZl7e/j7RSU5mZWeBZUHdZaHVZeAcg6yZelEKQFANURkUsMoDZZAFkMQGU8sBU1U5YbtdYftYdfYdveiBxoPaQH/emLgCEydRgMsK+b0yEBbr/WwP/Wyc5fARGRBJFR5S - -BJY+diRDY3heQU429K41uVDOYfNhgPgIuBQAU49UUF/Z+v3ZPdLoAzyOFCA8rv9U+mMHsW/DA32vriMF8AgyeQ5YU1cBIP0MoAqMujeeulc9CABew8TT+gTW+qBYSOMUTQw87dw/BbwxAPw8hYI3TVBiXozeI4og3IwZqIqLlkHcsTJPKCVO/GPKaBo+8fcfRdRoxS8UPtLcY98fLdxWgLKPjJ1FhGMNaUCQ405oPEqA2ELIpMWCxLEWEH7SvAlr - -KH4zuAEyk0E4OA7Y0+E7OE7Qkx7UkxyR/sZX7c5uZYHXSbeI03ZeHagA/VHdkLHfHTyLMFHLraqKTGjGRXnZUJndnfgLnQsJc2sIAIQggArCCV2ABMIOGy3ZQIffYRAGG5G9G4G+9fPSPWsMEBPYuSU7PfgGm4vcvQsKvVEBvaQFvbq3w6QHvRwAfe3egIm1GxfWhVfWwDfawE69dV4YUzeL7i/W0G/ac89aERIBM1M3EVEbLryOi2uY8zhljChB - -cdpG81kZoCMDcN8wUaeUUeeRIGwFAMuMuCMMoP0BQOMAAFpJCkDVFwA7qe77DO7jC4C0NIucOwu43cv40vqE1QvIu4kZ7k2AaIVLEF6rF4tihl5ox1hRxa4nioSFwPDEXFgjUsQhIGlFjXFvud6aMUZ97Mt6OsvMXYcsbRjsXguQDmNgWF72MgkKTNl8izRuakyIoeOoAXFOLow2hW3+OolqsqUavluhPavcBRMvXgNxPu3P6e2GupMmX+1mu0mP - -3AEdM+r5NbsoNFNdN1OOBQaNM1NacNO5O2Vdk2G9mM6GedMlMjOTN9MDMLA1NWcUA2drCjv+jskuVzNuW8kOxOLgn0eWSXhMdsR7PJkHNHMnMBHC7NjDszoF33OEgzD3PrncCay8idLt67nvPrAjBo1G6IMw2R2lD/PoD6AwBEOSD3BYhrr27Ps/uvtftwvMOIu1ck1/uosRPouYsUs4trGiP4uoBSiCTQekSweWRnzEVdXFRagVTYxVT8T0uGPa - -NMsS0EdS1EdGMkcmMcVmN437FtTTRMR833DCs0eByqhnfnfnfotyvTqKRnhOLqzKtKW218dX7mdhMu3aUVvrCJOv7KWlCf6yemuZPmuKdWuqe/MZ0Ot30ph8sXdw+CZ22+tBr+ujAptH0SCACkIIALIggAEiCoCV2AAMIIAOwgxdgA0iCACcIAAPwxsUBxtrDY94+E8k8U/U9o+D3D2j2Ztkfjsz3uD5uj6FtijFvr2Mhlu2cLFVv+C1vo/oAM/4 - -/E9k9U/+i4AtttvQ8R3btWUb3P2iWv0NbxNDsxM/09OTPZtfVtBEyJezsoL6hyzqMZcrsjDVe5c/Ma/qdFcQCVAcBEP/BGAdFnsKikCHr9DjA26HrVFnuNFro273A1f9FTEwv1fvsWNNfx9Y2J+aX/s8NAcCMrFoW4sYXgebFQwIRoQpGjbXy6oQDYYNiJALXzQRTeNA3zdaM6N4eP76PD5resUbecvbcfsdCDbz6D+TQAKTDHf2Fhy+eKL+dA3M - -ewnya3ezAzTH6lAol/eQD20CeDNCdoAifReKERcLg/cGWBPNgA8msZP/7ZMh1u1h0FM3qaflM6dvd6fP+VNvc7X+otN04HV9lvd2gumDnJzq/2GYm9HOYzZzuANc4zMbMBBTzsangiN5o4hFc0MrXY4qQwS4KBjgF0pTBdvUQQMLmpwQCDtzmUAv+mb3rR6gq+M7MBjmDtgzAHgVfDIpl1Xb/AN2SDYgXDXQD+4iYHAV4DeStyNEpga6UgP0AfLV - -ElQh6BADuG6IQsMaafDhi12opMMP2LDb9ooOhZp4UWsxQDlTSQpddQOhfZsBB1nj4wy+02GaHWC1DktuADYFFMDgmDSYEssrW4t3zb7LcgwbLbvjLVI4/EwKgtU4mqCQidQfsvVUoNR0n4zQghlWNRtKBmjhCBAJtVAPNE9bUEja6/Z7tCGCZasPuETffkb0P5gB4mkAJ/CuCk4b8IAF/b/ED2v4WslOX3a1g/xuJP96mL/O/s2Df5tCP+HQozs0 - -27K/82mjTQAZZ3AEgDeh1TMAaM36bkDTeWaWAd2HgELMaynEZUDEPVAqh9QoSfgmADuiw9YhU3YBFwS2r7NCBkzcLsUMi5loje+dI+nF2oFW86BbQPYvzU0jpEwacDfoBwPy6a9CuFufAP7h4BQBxgRDGALH1DwKD6GdXFQSMTUGp8oRyg97m1z0HAZqaWLPPsIwL4M0i+BLWeENxlCygzUGoYikTDr7A5zkTfUmC3xw6PEB8K3Axlo18GbdueFH - -HigFEFg1gsYZoYsDUmbCRCeKeda7jyEmDdxg4GQ62jx1swvdNWb3XfhMO+76tfuWQyANUMpK/5geCnLXpa0/7g83ehTH1lDw7asdYiBoqAFnWR4BsRcdbCAI3UADcIIABkQWug3VQAIhAg2dKDKgFCBhB/wtIWNtaLtGOjnRrokIEGg9FejoauQNnvzwkBc9s2vPOehzwF5wAV60dEXpvXF7AZJe+9fAHTwkABinRLojECGIqaeiZwEY5Xqr1vpG - -ibqj9Xtrr37b68rh0Tb+rcO54y5uAhxKeoAyS5PpFEqEFrEbRYGO8by3w5oc2A972410CAG8hwEkD4BAQcfBERnyKYNc4RjDCYpoN/aZ9kR8xVEQYJA758euIoPrlKFXj4jHoRIjDlzTsH4IFqatGblO2pGMtcOng14l3wZbrdx8zI/waMAQiCxVQUmWOFqCO6a16xoJQUckNlDL9JoV4yAJkLP7ZD+OGY1rrfgibKcyhxJZJlKP+7GsahV/LJvU - -LB72U9RkPGOur2NGkTzROdVHlaJl4QBAAKCCAAEEBp65j0ATEvuqm0TExjx6bYpgPGLzZcSZ0gvZsML1Lbb9WQWYmtjmOtHsTL619KsWmi7YWs6xIrHDAOyP6f0ouNwoNvcNQARRHhSRCBjXltjLtwaIaUcVwJ3boAeAN5CgNUWUDYA4AzuRcQMURGsNYRKfdcS+0RFk1s++g4DrTSMHYiTBkof+ARDL72RrQo3BDmKBr63iyI9407I+PXGi0lud - -IrwYRw/E98vxffZsKyNnxlkVQjwdCAzHQj28+RfbcCSxzVghRzQvjLjiq0lHokkJuQgzK7XQkn8sJRrX2nhPVF1DQeOo4ibawK6b9o6jrCoGaEol+tLRUXa0YAFwQQAKgggAIhAWJ805aRxIHrRj0AsYyIvxK2nQBhJpQUSaL3EkS9q20veNotJWlyTW2Ck0ct2216VSEIjY6clpJbE6SuxE7BvHnVoFJEpoMkWSIslMlwNGiFkiHlZIgAhpngAf - -B8oCBIguSE+2gpPqoM8mYcNxS4pGduN0G7id6aIwwYeLA4hTxGFUfGN1U1ihCRRsE6vuBmiHaQfs5UVIcxBwIriaK7gtKSywymrcspTI3KaUHymgl8ErWF2NMiCqgTVJexFjsElzC6QtQ4o7jpUK37ITtxqEnVqEwwkVDlRVQ3CWqIDqajbKt/ZTk0Msn2syJRoyaYj2yBUSUeptNnmsEAD4IA3VrrE9SeEbAnqG0AA8IKgFLqAB+EEAAcIKXUdm - -oBAAIiAE9yetohuhGwAA6HAQACwgtowAPIgqABuoAEYQYuhHNtGhti6vsxOb7NQC10053s2utXWjkpy05EbX2eXXtGrS6JDsp2UTxdluzPZPs/2YHJDlhyI5qAOOYnNLnpzM52c1ALnPzkN1C51dJOanIjkVyq5UYwSRADEDZAmAcY3NvtKXrJii2qYsSUrIxaSSLp9sx2c7NdkeyvZfsgObXWDmhzw5EbTuQnLHllyM5WcnOXnILlFyb5E8yuRW - -Pkntt76I04Ok/SenqTLhr064e9Ni6fTzeekn6d2NnZjYjYyod4bAw+ZW4wZJEiGQ+QfKcAFQCAQEPoARnp9MZLMlGWBXUGQVmuy43yWixz7oihGpQERseJxH9dXY+MXlvjgEgagqZFLToNB1WZ3irIVM9yalJfHpS3x7LXvqYzyl40pIBsATJrFMKKRgJE/AUZLNS7MRKInHE/BKIVk5DZReQ1WYM3VkGtKhqo9Jn1IIkDT5RRs8GSbPGkA0TRSP - -aiTbNonxtAA6CAE9vZ1dUurXWrlOKXFbijxdPIXrXArMC83aUvJnkryUxa9DeY013pS9pJdE5xa4vcXvzbpn8+6cpJ17iz/5BvMgSO2gG6TrQRtX6RUB6qw5cswMj5q8CQXDTfhqDNYHABDQwAAA+swGvaZgkgN5G3A+UwDL9l0HwV4PEBwVKDlx7k+FmMS8kkK8FZC9rhQvxmYijxYjfro2B5jdUkIg/ATPIyn4LVZ4asOVDxGZl8K2ZAijmUIp - -8EctRFfM8RR0AhhncUIloQuKS3kWisWOJEGVH7FiLwTeOiE17vKLlEFDv6RQkoQqMk76LNZhi0ysYpB5aiGhoTcxcgoJqtDtOPQ5Tl0IRVWtjOrTf/vKJGHdNphm8+zmMMgE5KKB8wkLLMxTLzNkqiAs1FctVA3KawpUHYZeG0TkIOynQw5ucOIGkC3pFzEBdcy+loBVQBkttGeBky8gdy44j4R83aKVK7WfwtYAqBvLLh+gHAQEK8AqUQi6Grko - -ZcMRGWfsYR3k0hVn3IX+Tc+VCyADQvmVShcshoImFVDjjjZYpOYaYJNy2VYQ7ouyp8XRUOX4dOZDIj4iIq25iKB+OFFUEzKkgKoEhedfkTywgnyYqojwQuKUoalPcEJm/TRd8u0WNM9FSolNVrJ6k6z5OllfWdqLMW6iql6nU0VYrEw2LLZ00mibNLomAA8EHHnly35vo2ntaKbVlzJ5G09nv4okBzzjg7oYJXz1CWHTIAx09MVEu3mxL42na1+V - -PObYfzyJNYrUSpJo6ZKmxonUfDyoAZ8rjRBSyBU8L0kc1LQZ4ZgRKqy4PlpV38j3oeh+D7AoARgZcAqBy521IWm46Efgo8mEL4RmqiZYaqmXGrKF3XQmaUCwpOICIRoQmN4waryMiUqsMiP8glhowJgHqxbl6o770j3xC3HmWcvI4K0oO9KTWBVEWUYCxZNHVMAv2/zExoYmWR7qq2wmpqWpWitqZ9zVmdTpOZJPNUYrmCEwOgZ4QiYNJtYyrRph - -oiadWrNG1r7F9a+NghFQD0TQ2toxuUnPLrezCeEbZ+d7IbrRzAAoiC49R5Ts0+cXQJ5ezw2jbUNtHLiANrVN6mhOYfKdHuyCexdGOaPOM3RzvZ4bUNqXUADiIKG3LqoA9NOPEzcZtM1JtK6obTxWsDk0KalNh8hujZoJ4abR5WmgLfprzkE8jNJm0umZs82WbtA1mtTYlrs2eyHNTmlzagBC0ebwtPmvzalqC0VastOW8LT2v2kDqgln0vaaOtXl - -C915J0zedEuzGsSIA0WxTcpvi2FaktqAFLYFoM0ZaGtoW8zXloK22b459mhuo5uc2uaTNVWrzb5v82BbgtjWsLRFpulq8jRImn+WurEobrAFzYz9C5zyUdZQFf1I9RcjRgmh1QcC1gSMAXEu9N2Fi2Vf2jPb0BD0cAH4MQH2DTA2AK4KYO0udzLgsQgIdvpv3fUYyhiq41GcjPRl/qW6AGlEbjP3GBSCZxgsDcXyVDFQNQXUEiIpjzrLFJoBobJP - -jgSk8K0NHgwRd4O5mnKA15ygfpNFVh8gpCosiqWBMZWSyLQ9kcKK8yTUMbmpXy5Tj8sAhbrYmOwAFVmtP4fKVR2snjQWpv7FrDZpai7Viv07tCkVywY3YisaForBhGK5TliuAEEr5ReKnFbMLHZudSV0VBAX5SlR87pZgu2ZMrFIj4C7ObK45hyo0lnMuV26u4c9uXKCNp2h6pIsaCcRjYVM4q+BVlw+DXrqliwC3P0BGAfAPgUwUgHAEIADKtB6 - -O5Pj+rGUfqfJeOnGXwzxkHjZloGuDKFKm4JAiYlZOsFaDrDMzliWMBnQlIuJUkckrO9md6uOWc7/VLIi5ZIuYjSLKIsisiA8qqlUb6ByoQFFTPeWMbPeaa+XRmre5q6upMnS/uCr1mQAcmJaoaRdorXkTzZJsq2TNLLTWj4lPiyLRIFf2JK/F6bftYEqHUdaQlfaoSd1pEm9bJ1b3AbVJKG2f7fFi65JcuqUm1j0l66l6ZpKAXcro9vKsBQKpj0P - -NXtteWbpbTT3fabcWe93hbn+A5Bl0h6eos8DL1biv1OqohUnnGW46dxlNPcQFOxZBTeudC5wOFBRiPBNUtjKaDKHWW/xq80mRgeLt4VuCspbOo5Rzpw1c6Z9H7LUErRpVnhaVhcKvlGtX0s5kh32NWNrGLjS6mpF+ZjemtY1oSvuR+zjefy11grdZhai/QbMaEG7v5t+s2RJsf11rn9dE32YAGYQNOU21Jp+iAjwR3ut/tHptb/9vKzrUAYOkgGj - -pYBsXlOvOkzq1gQRkI0krO2KSxyq65A9dtQMR70DGbDepQNj1OJBVowXZbKCkxlKsuzkv7ZwIB01KJAcAdoJgGXD3AEACoTAEIAqK4APgnue4BwEaKVARgzuBUPQc/XDLGu1etHbBT8mcGTVIGkna3oQymgwERYf+O9vVB97JQv8BHCRutBEax9GG0oZ32EU5S8NEAfmVbF91+lI1lU1eKXBQHlxbY/pJIfKxmjFhpQphtRfLM1mKzWpKs4ToroP - -7idj+io9XTvtBVydhVpIo2pfv13X7v5Ru9/rpzN1YnP+Vu2wmZ0xXFNsV1nB3abpfL4qZhb3N3XANcrLCCCjxgXc8ZUiKJ3j8+T45JhtJepOVZRt6pgd3VgK2IheQpfF3zKFxqCjR1dmezIN/MLc/uQgB8BgCOhMA9ASpuqv1V4L5ja4tGRqbYPYyODBOrgxiOoVYjeDRM/rndCpgdoNYmVToJzUgDYZnAqkBHMHChi6QMIMpFKQctpGKHMpyh6f - -T+LEy3j1obw21CvsvAGhJdb8XWADE9MGG/aDwCKA8E6BV9t9sumUVYfBOH6ONBixw3Jyrz1gQJkKoicJs8NjTyJcwOpLhkoiFghsU0i0X4ZCLWinyYGNtUNpbP55ojAS+eXEd3UJGf9wB8JSWz63pGYl7ZjgK2bgN5HUlSBv+SUcN7AL+TPQG5k+lT0CmXtSRUnGHGX6SmRgT7Foz8PINrBYdzS5gM8EVOzG3J2qhYzqdYPLGjVqx4DTwdoXmmnT - -OCVWACb+N610W2GbSIaEBR7Q8KSEfxF6fkPj7MNPq7DYyJUOBnQSlLUfirXmhq0K4K+nWgbXQuG1JZJh4qppFTPqKQTe+r7nKI6mwnj9XGtJk4bdihRSYRZotVCsGYwqy1+o8s0aMTpp12LydATRbMk0NnpN/h+Np3VPo91QjuJcIwJZPrd1z6LWmeTtIAMjrEjYSteREpHMQHp1Q2wS5JaiNTm7psKotVdr17v1N10XIvLktwOEh49E7HsbwBhi - -IaJgg4i9au2wAynuBs8wgGCIOqAhPcCANdFACIY3lsA1RBpe0WID/B8A/S9U3efXFMHf1iMvUwB3r0YtG9RO5vRsfFCSg1YAUU6J1FbyZNiKsOOyFrCqibJCRgouQwtwUMT6lD0FgM1ywsYBRAE9MMqd8ZXxgTNchoaONKHRhipqplZmmPd3o3mH1WcuoiwfsiaQnCh0J3SqRfsM4TuNlFuDnbDzqon3D6J7PZie6HYnamuJsxfidM5HVbdxJ+3V - -Scd1TDSTx1ky0Su/ALDOSSBek6qSdP1Xo4JEJqzsLavYoZgkwLCB6mZUWEzhoe35jybu1R7eJe6yWOudAaJ7K47rXC7ubwXHl/tul9o+gH+AIA2A9wTQDAGXQpAIrNerVRjqr23ncb/69gwhSA0zKTTcyk8cqGuhyRSwU3CuJuTysnE9oCqPrOjAbClXSM3p8Wuzr9PVXbj3O/DR+0VC3IUIPkU6DMmat6HYka+vUEWAg0pmBrGiyw/vusM6KJO5 - -Q4FTmoROmtUIpECYLrvou+ZSz2erw+JvrN2KUhtsjukT3dl9zbRScmOb7OLpjzAAUiCht667+9AIXVtv23Hbztt2x7fLrSXEjsRxefJYHNJGhzaYtI6pYyPqXfbWch2w3Sdsu2U57tz26dp0uoAV1eloowZcBtK7jel1rA1QNBIHrLLs7YsFJFmAWRdzyOxYFDUPOynkQh6G8vQGcCSAbcjoJHWun+BTB9AXwQEJUAQCSArc+AS83jcr0ItFjOO+ - -84BsfPk2zVppl86ToQxdQTIgCTaOdhMOHGn0fOu04K0JbTAriFxn05Vb5t+qBbqhixpZGtULVOoBtl461dsgdBTQy/BlEpj2XJD0I6tLCKvzgn4Wc1oJljVmbGsgQi7/yjW5hJmua65r+ZxOBhkE1X6Tb6ndayitAFbWNreJ/oSZz/6EmDrQAyk7itOsQDzrD2q6yStpMec7rczXMJBpKiP3CwKkV+3Sl6yMoOgQesUH9YuFZLI9fJkG9gYrtK4r - -L70U7Eyl3OQgDzY4wHegDPY/B8Ay4SgPoG569FdTIFG81jvUdcN9TpNxe03opst60rCGfmn9CrzKhFkwMWwU+h84JJqLs0UQ2fZ5u+muZ/p6+7Bfmh181QtMM0FVHH7kb7CMt+M9Og9YCHHSStgiyrZGtq3M1OZkFXmd1vciTwtF1w3rpWuoPmLYm6xRbetlW2HFRdRO/HOTvJyM75dUnhVtDYqaJtCc+OV7YgA+27bxdIp4HfrrlPi6lT8bSttq - -ddnf9PZ8OwmIUtjrZ5qR06ZmPjvWiGnmc5p+naDttOOnCWiNjU9yPZ3c7qT/Sw2MMu3ai7rYyo5O2VA1GnMloGlqhod7g01TeRPLjI6RsQApgrwXMGwE9wq9J7mp689qa0eRWdB8Vg0w3sJ3cHidwUtexaaVCbwOb4t3SDKnG4V5HklyRSGhBQugXyr4Fq41hpuOy1Bb9xhWvGShhmIZUnBOMxEMqk+QnlZoIyYXjTMWHhrgnUayRaBXZqNduaii - -3J3sF810Wy16FR4dNssXzb3F3w3xabM1y959cg+SVqfm+yS5CzyeQPK9kN0dNhPLOa2t/RiXd5dchufZtFdVP1Nkr3OQHNldObu1PT9AGHeHUDPI7ilnrcpfAPyjIDO8iQLXP3nKah5hc3OZ08S1avpXur+VwuuEaViUliNy7fnY2eF3jLH00u7HtFUHO5cDjgVLyF3Ol7pHxs2RxAEdD3BKgRDIelW2ecV6CFM9wm0sZ0dfO9HhptY8+YtXxZ8k - -G+4BCHCmzEV+DaMDvXVMb5ahCWVffZWBcuMBgUXJymq/33jxsR4yErZ5n48SEtXVJk0UmR1c+tip8XPxkJyooFZzAInwDwi1S5ifZnpruZ+B7rbHisJkHaJjJ6RMrU4YUYjAxRD5AYH0ccnT+/l/G2DZEArMqAB8sazqe3vCA97x977RDuR2jXclk1wW2SPjqRn/WtS9aJfdvun3Wd31zncQOFG5zmztA0DcJVzCzLaAAB+OxEezsNhTiRUMSNOd - -wNl0zliGViEkD+5XgVuEgPcFIDtEnepAchlMHaLOAvglQY9Djbzdozors92K/Pfx0/OjTpqovCvYtWyR4yEURlaVW0iaQSRWMU4tscsgoRV4u+BF63yRcdvILqLvwbVYCHk73rnVr61LdeO5hEIZ3EbIF2atCiLeJMNCOhDwvAml3UTld2A9+VicVd0DjWdrYSdmVSwjpfZ6Yr3dXONOJTc3ZtcC84Pv+Awgk/ta+527iHm1o6+M1MtBZrrSwilV - -7pZRaeJ3XV/3UswM9FTOoikEz1yd+sh7eHRlm4RQ9Dey4QL5XqyyghrDStZou5u8PG7aM561gZ7QEEkCgD+4oA7QOAFONpxENxgygQ9BwE9ykAGlmbjR2871UfPWuujjrklb+cpWAXmxi01jBMjPMawPcaUFSIdUoe5IiEbY6nWmAzVmDWHNt+fYguT63HaLm+wEOiFncNhoQ7YSvsojUIzug7p+5LP+nxZcyi7+lyA8zOGZ4KjnwkJNb1a0u4T3 - -Uxl1u/RhpFd36Tvz+g4M4nWsHGDna7g/RUEPIvh16L5g9i8u6YBVDxYXSeS8hVlY934IZsLCGvWpIyQd714yftcPWVRAgG+HoXMYHBHZd+r7geq/BQUNEUKmUOPBoT2mvfrj3v0dwA92PgygSMW+shFz2ormj6b0TbisrGi3T5/52acBdOmzkdkF+FsrQhV9sMTiRIGYK2WoRHgWhpx7o0u9VWr7N32C5eHW8sQcI0srDzoZX1BOX0kE7vd3u+Rm - -HlblLnftS9sNxO3Pm7jz9LJWXw/2Xq18tVy+yc8upNeTmTWsGW2uuFXYR9tY2oleZ/+LrWv/f04EmDP/3wzi17HatfAec/E2/V9pcg+rP/XsHoN9pJ3XLm91ArCN9ToJGPRdz2C0X0xZcvtA10+wLEJUAoBkMJvivqb1+u0efO1fPH4t5r9Xsrf+DuYdJGMBdhbCtlxFH2Ad8VBvQX4VvxTzSOccX3XH/Nh3xp5koootIOCBOBdDsaVTFMLHbrHd - -FJjlS1+QD/78u+D+rv5Rdhjd2h8PPToGBRDbEsz88zbRPwf1k/POiDYJABaVLpbRZ1xKcg7d1zldM5NAGjk5NQAGIQGOQJ5itAeSJ4j5f2Sdkz5duUvku5EuWbU75bOTy1UAdP0WdVtJuXC0Y5Culdl3ZXOQ7MYAbQGjlo5BAKQCWnfzXac0ApzQwCsA7QGDYZXOVyYDqADVyK0mAup34DkA0pxED2nYukwCOAHALwCCA32SIDm5dxRM025C+Svl - -u5agL7l45OgIYCCA0uhYC2Agng4CH3Cc1gAeAjgD4DEA5QNQDhAnV3QD1A8QMkCPXGQLkDGAj2U/dOeHiSL9l5IZwnUK/ZTmtdMjeAPcDBA1QIwDUAcQNQBcA/AKYDCA4gIMCyA4wK7kX5RZ3MDLAhZ2sDbA8unYDOApwO4DeAjgCUCkgrwKkDRA3wM0CJApoKacPZWQJddgg92WWdIPC7R7YA3NSXnNslGLiXM0PMu2lAI3CuA1AnEGal3MuAfv - -wu0PeNdEwBmAdolwBKgB8ikc5fDVU48p/THWV9WPWbwLd5vX52NNl7Smz4N2YeUHVAskefTmAP/B02S48RXYyNh9/aGBScv1fhQu9kXVTy7d3HK/ycxIzMR2BRkzYd2lsY1adGCgUEIlD+8d9AH1VswHGl01s6XeE3c9f8a+F8hmZNlwYsOXePyycq1S90bMdnCQH8C5XWvyz8htckL1c8/a9wL8+nY12L9TXKIMA9RzQbRA92gykOoUfXBAwKM8 - -7JvzZ9RgnZ10kLQYRw3M20cmHRhfYc9XT1V2NgAI9xxC3BHtqiENHaJAQGAFIMWPBXzY8lfGfxm8sZU4OmUDHS4KMcy8O6AUhVoE0HCg5IFUCxgd/KeDMFORPiBO9rfBu2eJ/gqfUBCe3MCnqN5QRvk1weRTL0gBpbSyElkOUDajeUv/BEJ/8b8IHxsN2Ndd3icI/TEI2puRGPzxC4/TJ1NluXaAN4sU/fizWB6gmZ3roKnVAGTlSeW0WjlvA5oO - -QA0g+iRTl5Aw+Uvl9Ax2WjkjAjuQKDug2ujFdXAuoMSC5Xdp0qdq6QADYQSpwrCqwjgBrC1A2QOnCsg3sJ7kegurVQAWw4+VroLNRYMVds/eNmLCUA0sOECJw5IJaDotRsKXDVwluVPkOwigOvluw3sLcCBAwcNDZhwscPLDKwo8NnD2g+cNQBCgggMC0VwnIPXDo5UIIzZwgpkMiDS/aINGcd6Kvx3DEgksKEDxwt8OnCxA1oPk1TwggPPCT5PI - -M7CbwhZx7Dag+oMfDnwxCIdtkI4ug/CAgw+VzkfwrIL/DMIwCM3DvXJdXO1v5QYMFCAFeD22cQ3cG1lwFPKr1nZpZdaBADdzUv3htWjMXwtwrcL4CMAfgV4HoAbgVR1R0dQrHXY9c3ZSMND5/RK3OC+Pc1RPETYRRn1ApSKBi1A97UEhOJxPIWAH0pMTSFcEubc71P9bfS+2I5vQwNXjxr4RCGcYHIJ7D08wJUiBiEBfZJxDV5oMXQ39pgbnyBNG - -pQPwzMkQ+MPVsYTCHywlAIKJmudSASQEPRNAdGw+BnATAH6AhAZgH0ArcSrkkAzQS0DRBeTYu1N5AIQtBZVZrIAMxDGwKViWs3DWP33duLQ9xPBqVUxBIRrQzXGJC+XUkPQBAALBAn5EzW6DuQzSiVcJAYaOHlSAsaLpDWxfaVkt4jQAxZCIItkLjsxza0WmjC5UaNz8vXHkOYj8jB6V/kRdG7U4jjLMrx4jhRCN0ohskHkUBNCuByxGBPcRUMTd - -Uo9KMyjso3KPyjCotdGKiriSf11Dp/dyVn8TgzSM64TQ/jyuDXzS8EDh9QbWCLBdlGRnG4kIeUH85KsIhAVQ3Q18Tt9nIy/x9DkuPMDLhTQO5QhD9PImLLglSKqG6RUPMzwUw5YJUhOcIo5NW/87PX/wc9xrP5TB9ShMP3pcdbDzwaiAUDMONtEfYk2C9wHVlQNY1KCACkiZIuSIUiyoz3mfA8o9YmSB6dPiBIgqfYqlgk4JXAGTE2gAiGJipoel - -TwhPeQgEwA9rdpgfBuYoZlR9kfQ2V2t8HCL1CYovZ3Tx9cfCqNd1EvEnySwf4CmL+NSY16wM9G4KmMaRLPJn1KAeHMPQ4jSjBDzGDOfWPU4IbotWDIhurXDw+ZezXYCbs/PD3goBlwf3CyAsQIQH2BAYlSL1CQYg0KRE5vY0OStDHVKzLwu4QeBYhSYKTH2QntLDBTA3YCGHfhpgW+ChQW3MqyU923D0Ku8L/dTwJjqweaHlAO0Sgl8cJgKmT0Nj - -DSWXvEzwAqGZiZdCl2ijonZEND8kw8P2h8GZHCHagNQJqLScWoiAIT8iQpP3zDYA60QQg7ZSuhTlQ2QI0blS6RORS10Ayp1Log5Jug4DH412WLo05d2VHl9AouSW1SgrIKMDynXzXC0iAm3H+B7cYb2YBjmUgGjl8YKwKyDStTbXm0dtGrX21ceAnlqC6ne+Mfjk5Z+Nfj3450U/ivZH+Mro/4iOSc0gEkBLXDi5DgCs0IEw+SgTUAGBNDY4EhBK - -QSUEtBPy0OEkrXW0ytLbSm1PNPBLq1CEvsOAjuJLNjAiutaO0iUNojkLokSEp+JfiPZN+Km0qE0QK/jaE+hIASmEgCNYT2E6p0gTz5aBM80+ExBLYxBEjgHQSREvOTETsEyrSkS9tGRKISIPPkOOj1nYYLg9Y4riNb8JgsN1LBpg+aFYUA43c1l9xxbOITdrnZcCIYbceIExI4ALUN2DQYmEVUj3nFXy48ErCGNrjTQ+uLb08wbY01hGo96C+DHT - -LxmtV0MWDh4RrQbGN5tz/e33HjXIzTxORjYiqDrBcBBeMqkvfGd1uZZFYCWZlyXIay3j7PWKNic944nx2BkolrwkBsudoFwBqiZcH+B6AXACmBJfUgHiBc0SzH2A4kiBwujoBKqLwhFkj3k9x+gEvWeBJARHWIYGlQ9GYAjAT3EBBCAOACgAFQL4Q4htnFznOSko0SCWT0AD4HTBcogb3txlTM9kqBHJQEBGArcZ3Ctw10V9XAg/ks5JAgShWOMT - -d7ce4BPZlwfQEPR2gQEGqIKAKYA+B2iIQEVVHQG4B6UyouOIutKojFJqi4HA+OIRtYEW2HdcQkWMSSlYwkIolr4y21vi6JV4CYAmge3H+A1VLcKG0RU0gDFSJU+RO2lQIn92ZC/3FRJUtK/cZ2FTRUpgHFTJUpiPgNqxaDwFDTokYP4dPY3ZwBpSIaYKJQVGC0N3NueMSObsXLa5NuT7k63CIYnkl5LeSPkr5J+SskyuK1NDg/UPyT83cGIW8Lgq - -GLNC29P8QkZpucTzm5dvfrh2M3TUiD6TPPVRSx0fghyL+DR49pO/EgQ3gC9hosGvF/wVGAZNatfkcXVk8zEa01lZDDdWjeFQcAP0icg/OMNdoQfZXXD0eYuZPRDN3d+xrAiYaVjAChNUWPhVkfETnSBX8aWOSTUk9JMySIHH1mwAVY0RgO8irGwTPhdjbzwgdlAPWNfoq8JgV8hpQWGAS5FdGEAtinYq2LhAbY5FXHTFdSdKsxpYtQAQB7gegGXQ - -VY02MXTl0kUGSAtYbSAb4puNGEVtFdHdP1jeAAiD2EBMF3ysEAuD9PNjLYpnBtiv+Pamt0sfF2Jx83YlH3x9EPL2KJ8brJLFocyVJ0yLTcsEtPpQzaFSErTtYatNDJjwCOOqYivaOL4dyokUOQ9WOXkR4irLbYw30cDYg0d4hAV6Oucn0l9LfTjklHXl99goGKDSK4kNLn8HzdXyXtI00pIQxHgBCHJlMsBKi1x5GSljYhGVM6EBkuLNGSzSbfHN - -NxjPxfGM6SAaHOENQAUKaB3hn7VSWf9ZbHDFkhiNTuHhD0zKCOVkZktdwSiOSQFNRSrkm5MIA7kh5I9Tnk15PeTPk75LpS0UigSqjmUhl0B5+00OFbjhY+/h5TIAq+LzDBU622RsRedQDdFiAOsI4AAAKjCBZUnVIlTo5ErOzRnwJkAqZXgGADtAMgarIcxcAENA4xys6rP+AxwGenaJJAQrJlSmgHxKlTrRf4HyyBssZmKyys7VNIBdU6rNqyxA - -GcAayms44H0BWs/cHazOspgG6zeswgH6zBs2bJGyZNRaKVTloiO1VSlLYc0tdYgmCLWBxsv8Emz+mabPKy5U14AWzMQJbNYAoMRrOaz1s0rLayOslgB2zSsnrPwA+sp7OIAhskHKAjfEw1P5C1nIYOekgk9nwJ9RQzWGmDcyO6DFCvgoXzgYtgJYJvULcFZLWSNkrZJ2THQPZIOTMgI5NLick8uI0FjgjSLkyF/DXyW8tfFf25FDQCviIwESdLg7 - -iEMHCmlB34GyOkU5FY/2fFfglT1zS8YjpJ51e3CSE2gdDMiBrxmkFfWLAnYO0JNAWESs0lkTQSVgEN0WCZOlFPMpEQ5iTkia2c94o1EMh8T9GoWSzB007DSy8mLMMf4AvbawnSpOadJSS0km4AyTFYz9K7BRbDf3lQIoVeEEpTYkDPAxbgkqzRgSrfMlgzz0oYWxJr0nE2wd0fULzwdk8okyIcMM8kywzzU4lUSifYxGBFh4IRXJPjJWACQVQM0v - -GD50IzFWh1zRSE4RC4o41nxjjUcgRwtSnMCy3Q8j1EiGBQBDPOjxyPmMdkdSc4i3EkBlwaohvJmAAvRF9/UmTLLjgYxnPUiq4o0LJtIY3SL4NnmKxlKoqdOYEURrHXgHUMREBFFtVWsK7kHiT/YzOlzTM7KXMz5csCn39kgIUkbB53IVgCdCQUz2SFNQT7UbBC4dzM3jTc4i13jfM9zng9E3UFIQBwU8YEhTMAaFNhT4UxFORSYs05LiymUiwh1s - -HcgX1mBnc2ynxDsww93v1oQWxVychU+NmjlHQO92yAvgawGIBggUgDQADssZmqywgZYF+y1s6rMCA9AEejvpOClrNKzBAPzG55W6a0SoKaCqADoLlgRguYLIctgpqYBC/7JKyeCtgD4L46JQrYL8mbnkuZTsxROVTwItVJuyvuOIKG0JC191oL6C2QtQAWC/pgUKOC1bMEKVChAF4KJzDQscLlC4QpxBueFXkOiZzGDxNSUc4UMui2/QUwXcefa3 - -k28zwVDFxynow3AudXeAfwhl/gbAH6AbJG8hl82AJICIZno+IH9xHAf3GeBnAfD21CJM5fKkzV8souZyF7eTK3yBPKmydVzQN+Chh1QDqB/M29OyB4RJgI9O8ZbI1mXsjb8kePvzcNdF35kcIFmlq97IS0Bdh2MkMKelVIRZEEgtcROBw9gnYUVHhsXSiCALJkkAtGsO03gBtiAA5MLqj3/N/wxh8Ci/UIK3c0pm2tyTcWIdiMfFDOdjBmV2LOsS - -HCkwwyGUnDOLyaHUnyip3IcYvQ55bK4hmLeGDQhjTboQFDkgrQDUDozQudlXbymM+lO4jQisuwjSRTflRaL1YGsF3M5BLOMuceUj3mqI10IhkIB/cOACtxRMs2PEzcFLN2/Uc3PJKZz18sNO0j1jZb2Md+uCM0QhRuXuOxyvrWImWIxgSvBNAriQiiFgr8uyMRdh464wBDH8oWwsYhS87nBcsYIjCeCR3EEiJcnM4ww1AUMPOmNzPlKZPZjvM//1 - -5je0k4tIgLQTqipkuU9LOa9Ms/lOyzyC3LIgB7cNQuUAmAWwqKzqs10uUB3SzOLCZJo9AB9K/Sz0umzgy9rROyZLM7L7MVoy7PNdrsmIJMK7siQHDLKPSHLDK3SiMoOiDUo6LSV2IpEtiykPcr0JAg6DEucz2UkITrBdzQ8kJzs9D3h+AGlY0GdxD0fQAaVl0T3HaJPcaokaJAWQgAVB/gcb1KLaSybwqLiFJfOqLuPLSN482SjnI5L4IKmESpiq - -YiHocjfI4xRQ7giKEUwZIPAolzPVKXKGKnIszLlz5S5/OtAo4UiCtBT3CXSGT1S+whIglaBFGO8Vi9uO98TWSwSMltik3M3kFdC3K5ircqa3ALjiwHiIwLSpCx4gLilTldyWhd3PTy7i24st1Hi8L0vSXi9DLeKYvD2K+LCfH4rJVPdMn2ywzymyMvKbQ0kR2F7y0flYU3TGEtkg4StvL1Fm/RcwTjZcWvLCS8DJImhtAuWIrlC5IATOBSIAYHWl - -8bgLEGeAayxfKZLA0gm0ZK18yZUnKikxbzrj2SvXGYgEIYqSwgRCLSHUhiKIqCyRLQHyGPtY4Tm36KpS/cplKvQuUoxdhbB4EQglcixxFl0WPQwlknM3DF4gtQMYE/KDS3Yr/8UQmB0ACks6bmkhLI2IhtKXc1qMsU79HwxgDnS99wTRQy6rIv5nQbIExA4QEHJKzwxHIHGya2P0rqcoq44BirSsuKujpEqxguqzUq5gHSrogLMvpCoy/QvOzf3J - -MSMLEy0JlMLmzY1lyqSs/KoSqXQIqtKySqsqsyq4c3MtnNAi+io59u8nDAgVK7I9Sw8XMi30lMTwHio9458/4HaIciBRzpzGDBnLHKmS6SsKTw0nSPqK6FKdnW9BIBgkAk7mRNPghSwAq1TSyIUfjSJTvJ0G5tBikyuu9jy8yoVy8wTVGZMv86NRY4UcSYAvdm02z1bSuGHeMTDAK6h0gLrnG4E0AGlEe0PQsQZwAoBMAG4FQUGlQgEdAbyL4BgB - -iAIhjQLSvdFP/KFkoFI94EAM9ixBPcChmUAHydonwYQ0XNFIBGiFcGdw4AEoqBT0CxlJV0Es/mJKl0IHQyVYfPBHwyzL4h0tIKa1G+OdLqCiwqgBUARoilU2za0Ulr73WWoVSx6aqpjKLsuqquyY7U3Kaq6JRWuyAZauWrr8/EvMqGqhQs1Mwq8lH6giLXteNWQg9hWap4B5qi3GhrYahAHhrEa5GtRr0azGuxrcaocsGUXnfGwZKjgqSrr1vnKc - -sX92c5fw5LMCQ2IF1bYFiAqhgGc6qkg4gd1hlBpgFvG0h7Q3cvQ1jKzt1MrXqh40uUFGOKh4hsIZiCDp7KrCDRiBUG0OKlR9RyppgLS5MzcqmNYGpRZzcs1Kgdrc7yqAqTWVmjZgfEPjyCqCCqCrhUYKtH09ypYi3EWrlqmAFWqP05WKDz/Qo0HIgNqbWDrJ+CFsF3TvnFHSTybda2MJrJhO2PaEZ6qdNz1lwB8jXQHyENEBB2gAPJXrJQcpJ6QH - -gVOJpgX4ZpOAy96o9wSBjwT7QeBRVUXVPS4Mi9IQyT6ppkzzMfZ4uuKC8/PIwqQiiABpN5knCoIzoqeCFLqmkU8GlAQ1FgiawTIBxwbAG6umWbyfrU4QYzESkrwYrRqwGU783hW6Ncr049YCJhnatYH6Br62+vvrH6gOvL0RyiStDqqi5kpZzI6tnPkrZyvXCcRIzCyD2JrBJUkQ43SLOth85YHxhaSXHX1Vlz80ieNY5robkR6grSf2G+rWOb+r - -WKDY/OBMQ9S6MI8zvykPzBqbc7CqxSoamGrhqEapGpRqHyNGoxqsanGrxqWxf5MwL9mbAt2VpQ/jWtLmozMJCrRanMKgCom3lwLDr3e7JF5Wqh7I4A8QZYEmZqs7KpgK92QgEqAYAe9HdKoANguwAagDgEdB0wPzFQTSs96lIApJZcAtil0wdWKq4QApojFYc0bLokUm5JpF40m4gAybSsrJsGAZ6PJtaaimoQpKbKwMpoqacQKppKyamupoaar6 - -ZKoIB8AUZuYB2myMsSMlo9WtqrIwVkPL8da5MryylgbpqWBem/ppKzBmnJpGaSAQpuKbSm8ppcKZm6rPmaCAeppcKlm2ZpWa1mjZuzLpzTtgRzG/M2o7zgi+LyujTaVcgT020almI1h8hy01g2GiQFJryaymupraa+msZrlwZmtZqeiJSKEbxKkOuDStq8OsLdWchTO3zzTM1DlAPkC2j5pNQKYNTquICyCrgPSR+0mg1Gs/w0ajyrRosz+VZ3wE - -x3YNAWxdwzF1iqQlIIlE9YpoPXNngRPGSCNyrG4Apsa//fYt7qAK+xtgdEs0/Xf9rBHvwFrz4nlKR9z6u9K9y56j4CWqVqhfIXTn6hDECQR4DmkX0VlamyopdY0DLBKzYw+tQz8AVPLPqLdaFUdjs8wh1GE88r7id00K7DKwq/MkvNwIRYR4GpUpCEUtH5wi8n1UyfIcVvdgLaArwoaWfOivNrmMlEpYqOxKmTLLa+GakoJZqmhlrKjzCQHGBqiL - -rxGAKAZdEdA1qgltGU1IoRu2qI62SojSKWwFzYhVIdlL6wQ4LYsTSoOZM0PyoYeGN6SOWxyLaTNG3mRPKAaSytIgT4mytXg7KwZNQhJZDGLtDACwGtZjO6lCWNKvK1zz5iEnIephLLIIgzotwAoWr5SSC0TR4scs/JwkAPgN0BmbWq9gqhyPC2KuNZ4q+0CSrZm1QvUL30b9tKz2iR0BDR9asZrKztCjbKiAgcrrNKzJAUIEkAA0CfCqbfmiaO3C - -LyN9o9L0y+wq/a/sn9t9o/2wquSqgOtwpA6iOsDog6oOrQpEK4OrbOBzZm5DuYBUOgwHQ7js/PyqqQbfszjLQDA5qA9NU+NlfbSAd9vw6hCxQtA62q39oKrOq8jpcK1Cyjs0KaOyDskL6O7wsY6EO5KtY72O/QE465E/qv8LjUjJVNTmMpBvbE9QcUIhs20FuNTSkIWauY8EihGySKlQi8jBShACFKhSYUuADhSEUpFJRT5BPYOHKDggRqJaw6km - -zODpyktxPELiCGBzrGopUDGBVyhDFah1QRsASxSYPnNkNJSoeILrPQl6p5an8gGhMg1QdlIHakOctIcza67AVn5AuRRRBw2IA5Hbrd9NmLbTgfTmKc8u0wFXVafKwerZSGkJ0ggrGLQ3TFiPc41tnq1gGdN9z/c5eqXTV60sAUhLIy30hJYESPN/rLlSrFIIfvIsC3TcWj1ueLvW8WIvqH0yfOnzZ8+fKfr5u1WOCQbqrLpdgJWK1J/rQMtYVkge - -RFUEFYurao1AaDu5CsQz/Wo+rQzc8sNswzEGsFumZcMpL19jIsUrvjUiYCru2V/IGrujgcBOfhBQaoBLNoqmLYarRzWMhlv4ij1GxhUVOK1gR+A/yStpbsUy3FLziCUolJJSyUilKpSaUzPV4aGDFtt1Vwu9tpJaouqOvEaY60wSOq/Yeji2VgLGtw6j5oXSBKk4YGYCvaYRIzPdDnqseKK6F22fCGQRkEZGrqn/PnXO4/81DH99TG1ABPBMYDLq - -+D9SjusNL2u/IU67QfSBqOL94pLIG6OU0+KNtbSv10NaehE7uyBvc2dL9z50qOmu6V0hsCPyEoJZBJl1u11tSohPGEJlaEUM0ndb4MlPMgab0k3QQroGp4uQq4Gj2IQbPipBpQa8MxGHQaYoPEXV6NepHv2FHgR4D163EHbEx7KGnNpBaLa/Nss652L4LLLNkOGFe9Zqptop6XLegCR0sQOACMB8AcYGbbXnUcpYNxy4RpqKyWuouhjtfRGKJjh4 - -AinFL9JRNJUUG4ffyQ5OgXyCDpW3IyuzS78w8ofzi6vGh8hPIR4O3wXrFfVJh2rPkB09EUTJjrS/adlOAlFlFrsRDt4o9rALeugevtzk6kJCLBhaPVoiaL4vlO2I7oejjPdLTM7j6j4mgaIgAHZSunjkY5QORTlGnbbUrptXBulDZU7PuVzlZa5wGVr5agVyQGUB0+TQHM5DAawGcB52zwHDawgaNrNmyO22a2/Pjs1r4y7WqE7NokgeQHUB5OXQ - -GptTAelcaBtQN9l8B+jyIHja+HP8Skcs6OCTg3UJOb72Wm2qSIE4RgUUwg6EfJYaS4nvohl6AR0EIAbcZ9KmAFQ1nrmMx+sLukziWyLpri5KkpIUrJQJTH+wsPWRjNp2i1c01go4ffxxRU4/nMzTHqhXsLrCu+dreqAhJduwgQ1FxmurPfKEPMsMYKurOr14way/KwTL/rsb+6+3sHr/+6TCBlgB7lLtLha+9t5TH2p0ufb0AaHP9KxCrVIqz/S3 - -Qp46Ig5RK1rVEjVO4H42Cob6CTawatM6gixvsUGVzVjhoEoW4UUpkkIRIceiuK5cERb0AfoAtircPdHaBNAUfuDrW2ySq56bBzfOKTFMhwfEZe9DvRCbjwCDTytbMpWgBgLoIWE+tp2kzKP6Ri27x5BLQyYASwHW6nxiHwws0HwopWvdpjC2ukGrSHdFU0qh9fKxq2O9NQYbquK2osKtgGKCtYEGikAzOWDtiB+NhhHfZOEZVqWBnnljL2BgToTL - -Dm4TuhHYR4unhGpBgaoCLuhnHvDbdJNUrLK6yWBH+RNB+FroNdBtzokBCAIQHogbgTABtxngJxOXAbcQgB+AsaigAaUNQc51xaaSwOrpLckwRpC7ZM6ftEbyW/atfN6jOIEBl54+IVys1+kRDsgBUHpC2U2YS4cP7Z27lpCH+ZI5wSAPjZfk5N1cun3dYGfZh0cqukSTBcr3+2MJ+H2063s7SY47tPBrUGxxpCSlzRN3uA4ADgH+A4AZ4EecIAeL - -KwKz2//uBoTG69pHSDWsbtgqQ2tPLR8HitPqQrhhVCrId3igvMtrKHBxq5JC+l6HRgzR9kwtHDG5aCdh6fXYl+wMewr2zbse3NuRK+hvdRjcVBioBFKlSbqlmr/cKYYgBAx4MdDHwxswavNlhjnqsGIu6uI2G7BrYYkbNiR4DzAfsLuDCiGZWnQbwxoQAcWURRWaAk886iqxnauW4/uV7Qh25kSBzuWOEDCsIF4ccriIaaDlbnR74a7rfhlzy1tT - -2vtJjGAZBSFBGJ6qJuILwq8WrKGy/RkGwBRCwMuAmXCnQs4lQ7QvyUTEjINGIAGChu0giLcFkbZGORrkfaAeRvkYFGhRwb39Bda+NlXoQJnwt5DpB02tJHmxwsrHZm+3OoJ7E9Q320gSwOFq4qvmRkcTdxgIQAfJPcf4EPQiGXAGnzmifQEqB+gRomxB4gZwBErRR4LvFH+GwlsnG1h6cf0dNhntpX9eCaDm6xiqWSGUGBc3gF6wThlDVG5cBfUY - -PLDR48eNGduVGIatnrT/OF0MlQuBpVffE2NvHGwY0CnbPh6xtSG3R38q67PRnroyGfRxZIUH/R65waJKgDka+AbcfjMjHAm6MfpgO0YGB/HImizhuLkx0JmT7fWhiwB7PWzPuDb0p0h3GF8xhL0h6o2nkm4IrJp62urvjIyAQgHJ1ZluV6VGirr6mxhvrzbWxsBTVhMc/YimpmrLQc0AfgddnYnQp3JoimoppYensVhqUdknQ0kRq7a9qufrUnFE - -RhT5oZUPCj3HdJt1QkhSoeLBcznSEycV680iybUEp4jXM3LSYVybtG7JkEhvK6Y7qHwx2aU3oVadipVtBq/hntIBGsh+KcvA3+vIdd7XOv8YhGBU0odT8JALTXLoY5RthHCY5PuRO0Om+NjBmIZ8NihmYZlWu/caqlVLWAEJpCfqrpYzie4neJ/icEnngYSdEnxJySYImjmiAARnIZ6GazlYZ/VP+aoPQFrYjgWgsvZqaJ/oYkVIk+fQccWJ0nv9 - -rnO8SP+nrnf4HuB9AZQBGBFVPBna810CY0dBHQRpUkBngUwdEq189nvurskqfpkrdqmcv57NiTKjViqLE+FMJTI8XVhRN+jK1kZ1p/wYGLAhgrqV6jptyNLGKocscPzKxglzAlqxm0drHh3OmN4gD8MKMfGD2rzO8me6w4tNL/MnyeBsYsj3hwAiGNdD6UZ8iMYCaQuIJvinwoelCSnR0qevtiUxn1tRVEKhPpzyg2kHuz6QeoqacoSp34uh6UvI - -yFNGXZ7corHqpsSC9mOaH2czbW85qZZIyR+ONobBhiasT1NUO/oRjZqwLvxLEi5YItw45hOfiAk50cants3Sac57pRsGNmmdZmLr4NV4vlgP9tYbvzyt0OQiABQbYZ5iIp9x5T1Mmjxm4dgseYYnuxhIByTBvGDe5xgyQdJz/xs992i3tdG2NN6e9GzSwEc1iM5/HvjGUHUAeiass2JoiqgJwAGwQBukCNnbOpxgW4F4ulRnYJgwpnksZpECaH1U - -iAFFnxZyWf6BpZpIFlnKgeWcVnlZimdxGJARBfgWjOgFpkH8y6hvu1wegtueF+5vvMT1CKCqDYhmZPqZ+BneQWadSIZfOKZQbyZdFwB/cTACWAvgKYEIB6AUgGXAOAf3BH755oOommJxyopXmJynatZKN518zEcEgIWBrMkOefDysUuLUfQxgm8JzPnpSoIYdm7jE0Yqm+QGyfdm5i06LqntDZyYN6U6DmxcMWwJ6ZSHQHY0pVbw5ntMjnehkKd4 - -r7cVIofJHQe9VxqYp1ObimSIIQ1kYs5xMbHSU+/KfzmQvZDMzGABbMfGEy5nMdx7ipwsdus/ixZjKRHFxq1smMUTqI8XSWJqcbHu5qieCnGK2o2mC5WpbvOLmG/qfYEhpyJeiXYl/YAFnpJzWfVmYrTRa1ntF6LqX8LVD0w8imUJUChIYMtfpPBCG/f21gkkM1Hur5enGOuGYLAtPCh1/IQzNoMvHyNUkbp5IVJggoC0AMy35yKJbTP558falv+g - -Kb/nPp5JbBDAq8JvyG/Xe0qKHTROJqhHQZlOwqCkZ2meRHUAIngJ4dNFOwJ46nLTRjlwVyumRm6Z6FdhX4VlBcZC0F+CZIBsZrBctcIAYRd5BRF8RckWOAaRdkX5FxReUWzpVobWAkVlFbRWoVmFbhW8AjofImuhlAx6HzO5heb7diTv1rt58eXF6WfgP1PiSCS5rw94z2DEDgB/gO9iEBncYgCxAsQcYBuB+gCSf9QkgKSaC7xliwfkmNF6aZlH - -tZnRbmWTxN2HUN1MnfAFpOptfpSJzF3pK5EYJXZYCH9lsyavmC0+ufNG3Zi5ZBJW5j70unXy7/HpQ3YViCDnnlw9tDnyo1VvB8f+iGt9G2lmOeVCvgJWY+ARgRCeTnOaqMY/GX4N00bBC8MesuLfxlKfuK85stb9bC58BvyXge4pfdic+5hbz6oe0vMQFvV12a+Mdhfg2tG25odw7mCBLuYnQe5ljOLKUPYUyGGbHCYGvgm03jP3IfgEcQGWPeSo - -FTXzzDNbwU1HANINWl5hSamWO20lrlHZ+qNPEZ3WbuOVAi4G0JpI8rDtBZpqCc8DOxrZuXrdXWky+cOXtGlRX9DlFXDH+Rp3W8oUVHKkvgNJBYCNY8rXp18bRCPpv/vinG6r4KLXIK5KeKH/xyEedKlpX2W9k85fEfLoEVhEbWBkN1Ddrp0NzDYcUGQwdQaG8VxCcwWOB5ob4q5VhVf2AlVlVbVWNVrVcdAdVihYZWJAHDbQ3kRgkYI2GZlZyNTE - -chha2d2Z2huasqRhOFDhfHPmZXYfgcyQXWLcQ9DYAbcYgHiBCAK3ETBYdP3PoBtYRon+B/cIhimBxpxefUXNqqcY3zlJ2cdUm5yolEUZNhLXFPUwwtfulCEgAVFSFEqU+cMy2ZGTGwAnap9agtDp+xZ25nZn1Y7WrR3DB7XPvRyocmgoc/T8X35r4eDmzcoJfdGDi23ojmQIIKZb8Ilj3mXRxgGADXYHgargSXwNo8AEpFxjXKAXUnF3uCrs51Kb - -THy1+CsrWMxoucDaSTOtdB6G1ku0rmyl/DIqWVheiCC321y0eygA120eOFyGzueaXB11pcy32llCms7WKjcg1yFGKGFmrQZOTbWActvLbuB7gfhbGWN18cY1nK43dZ56xG+wfnHUulQgSBEUFrGYImGjaZCFDQAVCUhrQAAt37r8xli82fN9Rr8252gLbUEIofnQzmOYe/2DCf1zErF1y4SDnuXAHOLc8nAl15fSGT2j5Yg2ytyaAq2f5KrfHq4N - -gFYAmn2kGfQAGA0gMbZS6MQejlX0YsSgwqSqodnU8IkzWJ2xB1AHJ33RGX2xXiNuCcjsMF5CfWj0ABTaU2VNtTcIANNuAC02fgHTb02DNiSUoWCd2nZXDw2Endzkmd0MRZ3aFpmfoXWZxhZKXwW3gFmKWKqyw6h1RA/FmrEFdbYkBvAZdFyapgMNH9wM1w9EaIvgQgAaVNAR0Htx+gHQdVn8WzdeM2J+6waUnailSYVHtfA1A70lupfH5YjabDH1 - -BZoZzbMFLZnfv2nbF/zdGLAt2FGC2htq6fsIRt9uZY5IhzcrBsYdx5aBrI1kOY66o5j0dV00tomtRSk135I94PgTQCxAYAfYCtx4gbBSK27ckrf/7ORI3rSXmvd3qC8GtrKarWA27H1rXClvObzHc+72OrmW12ubEg21xud9XO1zPd7WmlhEvr62ZmbdGqopG6IRJjq3qfha9UwrgSTpVi3Dr2G9pvZb3DN+kq3WjVvhpmnZRuad1n5l0bghgypK - -JIznQoJm3Bge4B5G2WOgV1dtn3V59e7deWnRsg0EUXAtJgZkFfU1KvFpSEDpHp2HcVavJ7+dA3bc8i3/mT4wkTCaz4kAdvawFkWofbgV50sJ2TNcOSdkHRNOUCNtNDgAO06nUg9QByD/APtEqD50ToODXWeVQX0Z/aU52cZi3DN2Ldq3Zt27dh3ad2Xdt3bGc2N6XYm1SApg8oPYFtg4ITOV4kZM6eVodYs7OZnEo7GeQMYCpICsWasYGj9qVYki - -LyUgC+B6Ae3HoBa2/oBEmIQH4EkAGlH7Q4AHyPv3d2pliZY48d17ntsHu2gPbUmZqKOEnaNqbbsQ4YYR7fL4nEFQjoQPNwA9821PE8YcXFcyqav6jG2qeuUnJ+5ScyxbWu3tUkhqKOA2kt0vZS3uuu3sCm2azfZr3T9+gBDQOAENH2AbkrNYCIuapJaUhyoa8d+nqt9JZznMlwZgymC5prerXi51rbH2slifcbWp9tBt62CCG5b18nFqqc7W0jxy - -YanGl+saza19lqY32aG3SR12qRz63v93WWaqvUTdkFOqPaj+o9L911yfo8O22rw/WHzN3w4Wm5yvWziBJdWYFd8yoNhUJAaVa9e3GDjBNJiP9+p6oT3ftpPeFtY200Et9Mj9Pd/WDeqVlk9P9jyeQP4d1A77qkd4racxSt57cccOjrHdAWENoGavd4Bhg8J5S6OFZZXyeeg5l2STsk8hWKTjg7RmdmjGYkBeDwlYr8IAD4DMOLDqw/9wbDpVUqB7 - -Dxw8BBnD1w8kP1EmnZkOTNak4bpyT5Q+M6BN9XaE2bhHtlGr9ejjMiLoSmsAdqxV37QEWJ8tYGIAbgHgC+BR/TWHuScgG3EqBnccgCtwYAfIqv3JR5eeNXV5h/fXnzVnfNmARqV+EdI5UT47Ew+3LwZvWdx/45tnyrSoF0hsAPkCAOfto0b+3e3F/bC3A1smLcX0j5Y99nkhRvm6K6VIDZenCjsOdS33p9vYxPO9rqy0PizBMd72kxurayWK1wfY - -GPh9oHpLm2topZGPBmJtdKmIINVHjOax3tfIJ3FjI7G2a+k4U2ORq3SU3btD54W1RW8MYdBouKlnt1PCSi3H0AFQK3FUAciOlb22rjz3cO3J+47Z8P5pw9YWVUha1WChpZCdtNmipAycvKokZvjPnPtqM/iPHZwhWPcB9QSGcW/VwJ1iGeWAlA9I892LYL2P5go4R2f5+NffGD45OrCi0dnA8x3i17HcKHcd4GcLCEggQOdsu6M+i0sqQ60XqCUL - -oSyksODtEenoMRvZrWjBO9kKgNMLxIOwvNLESzNUyJlQ/lPKJ1qZbHxg5vrXNUSmzp5BSoAlCxixVv3vHmXOyebWBGiG4GYB2sm8llB7Tjau93TNlktmXo60twtCo4edkmBENDUHwaNp/OFOIy+agimLVTh9diPvth89jOwKWNrDWB8+LDrBq8R+eDWOLxsFlBgcSxqQPnplA4TDgL95fRPkiBmVPgUuIoZg2Russzvb4Lwk7gD0AZ4EPRHQQw6w - -6htUK/CvUR6MtYHCLwc1ZOcRqQ4gBoriK6LxaLuU6BaGL4c+jndJIoeLbF9M5GHaZ1/tB+Bmjec5P21gUmCxAiGAQWqICctw6dP6clfJM3FJszb92LNvw7nLyYBuDJhcyPsQR4Np/+00u8ve7g+6cuwyry6D+i+ejPzJoy/AxJkCIbDzxTMqSsvhkp9CmomBRA//P4tovcS2gLtA7IsHDD8aPxt8E+B73/luC8Q2gJ9oaw2JAO68I36h9nf46UjE - -i7USyL6oaaBZTuhYom1D6ba2PWM1vvHWcME7yIgqysVelNjjiABuBcANgB+AhAXAHGAx56kpkm79yTMsHb9hg13OZxh44POnTP/Lp8ZgIq08dNvPK1dVCIViBWLNy+PftnE924YnP8wR4e+xnvIxquW/aUnBmB38na5Zi9rwC5RO1Wty8LOPLmVEQ10YGSEuvhZ+DcBnHSoK62j0NupyRGURvC7iv0RjWqIu+D0i5tchohW5V2G/FmZyuNd8kbx7 - -SykG/Zp6dBSF3bSr/XB+B9zSq5MOJAG3E9whAdoAoBD0G3CtxXge3GeBAQHgBuBbyXAEPQbge3EGmmr9G/KLMbtq9uPfdmfv93Hj80JNBlKj6y1BHkNQZS7eANmFGvgLaat0vvgx9YMvZSk/o/YyoH9K2Eu4MNdYuwd0EghgirZhGkgK62XuNo/aERE7RLV7M+cuuwYJfzPf5sJbamsti3GeBlAIwCgAbcfYEwBQZNvYwOsh0sDUHlxyW9G6MlzK - -bs5Ux3Oca3cl5rZH3Gzls+XuPi8ucn2q5yY5rm8KuiBLvzGo3o5tEY65ESAsux6DdMubj7VX3/rdfaNve5vJXGr2FttD/yipH6etuWGxYehvB74e9Hvx7iS9aupL9q5kvees7b1mtjf41OJgEBqOvhvujadEM1Y2RjYhYOGLb37proE7puQThm5wxxikOBEJ+k0HchDiXMbCy6g6M3ta6Et0AsR23x5HY72Z7pxbmD57/y4IPAVsgrlu6JH0qWAF - -ADrLmJ7roMrUL+HwR6pK6hmCZxXuD9BfxXyNrEc4G1gJ25du3bj269ufbv24Dug7kO9Y2xTtYD4ebAcR5+vVdv6+KNeV+lI0O91Mc/omNyAkQF9RV3+/6mnLaG7oK3yB8mwBMALEHuB9gEYGqI2AJjwQAsYGAFwA8S1G/1WDtyZeavplzttdO5L2Lu1RFLqajZg5oDWg2nZQCSDW81YSqEik/BvS8BO7ZmXJjPQT34itBEIfOGtAXfYlEf8wJQvD - -pj+xFwbjH893m7h3AfaNbjjY1r0ZAvDIDLcBuAsge8PRlwSQCH7PcfD0nuTrsC5Ye3hpmOAXfPLo9q3V73o5XuejqnCH3AelCtH2yTcfbB7OtiHu62C+qY9VIBIMp9cmE1Svu/GKl2vsm2oCIdab7+hiqAjcfEcUxQ5ZquG2P2HbkK4Gehn/ABGfQH8frYYdz7w9xv9zpTPoUoSDyKuILsMyGPy3Vc8cp0IGYbjstabwp/mvin5/ItBzypwQexNY - -AkXWum77/BX4WEPW3bvkTly6OuNWoJsmfIpaDd+W/pm/WuuCTkkOCuIAeBPtxUAQ9CvpJAXeiMB9wetGEfmXhBLZeOXrl55foiek64PGTng7keud96/QBXHigHcfPH7x98f/H6QSCeQn3R8+v42Fl8Ff1AYV5npRXokayuDb/68YvqJlU6LaQbi3yyQL1sVZFGjDieaJy1gUgH0Abye3FJKzD8YF9wHyKAB4AVTTABWA7nX58jvwH6O46vY7rq/j - -vQpKJB/TZoE8FhcXy54Jsd7ENb1gQFEAyrO98n+88LuEjvGlTTjngViKsBWKrpBJlRgdLtDwXdmxrwt2sNVy87th5eaekT1p5L28zko4r3Iav0bI4oC5gGUAYAaYH2AFQsZ9qjfKme/5hLI9h7WtKzhZ53uazlZ7rO1n3KdLmtnjraLKutyNun3o2+1DGhC35xHzgyb7KFLfAUWSkzrT1mgkHO1jp+42OX74da12SrtU9e1XTaOGHdeF5MGhuPgb - -t97epgft6DfDVqO6iecb+4+Bfth0F55RFIeeOMMGOMQzWWzyk0BYfBaXuL6KM3nB4Kfhil9dAOazQKGUVQkc8HaPoTn6r/WgEZLqGv63jeKcuSXuKMFu0T4W4rhVp6UlIhC1ml86OChgK5uv8diABFTlgVAHbE+X9j+IBOPm5jFfpHiV9keyN6V+xGLcZ19df3Xr4E9evgb199f6Af1/fQvt0U81e1gHj74+vpPW/43srk19yvjbkdcEZ37iUI4u - -+3VDBPBZquN3tupbj3ndwN0G8leAkgQK0wA1ktdHaIQ0HgAaJGiM9hRvLjsSq3PIn8O60WYns1bifrgi84mg4XBHFuh95ruPOHISIhBrsB43LpvzkPg5ZAPiu6sDvtGIXgiF0PZ1SQcFUUByEFYWOLQwf9mIYl6bereoo46f/JpHd7umLzt+ud9AfACIYL9rEGPRB3llOHf34V3x3KyzkBbmeZ37hyWel7zslWecp6CuGPNn0Y+2eV33Z7XfD7mf - -ePujILOoCocv4MJKACvwr8oI+14PSuewgG5/amy7BN913Z2ZhB0MbXxx5+AcW+1/4vHX5k5a+2vpzo3O/PiJ88O/3wF4A+n92LuJga77SDrIw4VYuvEnmWyEp1Hg6UJ4hc77B5S+s3oupzfhbcqFVgYkZJ0X3cX26ZsjiYSuAq+Yow69RPGH9y+o+R32aGmBh0gb6Y/OHwK8ZfrRAuJjpZs/YE2z7cPYDAnsOiQBp+Kh+n6iBGfu0FZ2KqtW92bi - -uKV81uJAWz+wB7Pxz4aVnP4krc+PPpom8+NX7W4gA2fun4Z+mf4x/1vHpBU/Oj8anZ5YWFMIz/YvqwIQ0qw6WMVZFPbvoWYEuAWL4EpKoAfYGzR2QcPjYBGiHgCMA4AL4BDQiGRq5e+1Z/z/e/Av6J73XH93Re19RDD6sBgbl3+18WI9w5ASAw4YjWwJl2pF5Q/0vlXtQA837d5vui3l71Vgy3o9+FzNhT8+NEbq2UAcfiP5Ifcqcztp8gcQlnu/ - -S3yj3p4gcPeIQGXQFQe3AjMuMTr81a/+me8rg7l8d7QdJ35Z+G/sljPPXvBjlrfgal3ve/GOD7j3WLG8ELd93fM/vd+WgD32RXip8/mvEfvivRU4b+2L2XE6AHn/WxPBQd3hcYjzfwRaZH0AZv9b/2/795v3f3/3//fOrvG5BfV/P8xwhuoXQ/MRfT3gAThTfcW53QfHB7EPZTvbPcozXA6b4PR3z4IFBCyUUjRBrVxaXLQv5b1aGCVQbH6f9XH4 - -UffH5UfdDA9/N+xJtGZ6C1cn74nWW5U/LVIcfOgpsdOpzqfSgEvvJ65SPNna4rDnaC/JK656a352gO37F6QO5+PZ36u/d36e/eX7xBcoY1MVAC0AtX7afY15mPQ77MXfoZ7dff567JjhbLOt4znUnoqzSVYOvOsoW4L5Iu7KrjLgbvph3Nnq+/G44ffO44v/QD7nbIFyaQZICzYVa6+QAUqEgHWCnEfMiiIbZQS3axb5dZF6erbRpv2KODWCG6ps - -wNOK4ffQzWXC3hTQGVo/3Mv75HSv4C3ONZC3Ke7d/HuKRSFEwMfXE74HEgEQLQCasfZcBW4K3CCCOpzZA3IHG7egHMDVW4EXdW6JXCjbqpW7JS7YlY5AvIFafZmYa/HK7gAWqBF4OAA3sKIDHACExlodMCZAcowOMBoAMAV9x2SSAE94SoDjAiYFQgWeQiATjAKRDICuiKa4w/QYFLpHpgPpNbLVEUYEovcFjTA1YFe9NbLPAPForzHYGzAtbILA - -ozbPoY4FrA+YFY3OriXAvYEZAK3CffcdQzAq4EuvWJ7PA3YFQAOYH6AZWZi1PHYfAk4EZAX4EU/ZYEvA+4H6AONh6FbYErAwEH6ABEAbPY6zb0O4FfAtbIKLXe5tbCubIg74EOcdog3CIfBTA5gAlNTqqkGUdYJwVWBOCKxz/iQYGEgwqrOSZ4SagR7YdQBjhTcHD6QAIwBsAAwDdAxoAEADNCqxQ/jxMLEFrZR4F/+RLZTA4MAkAQ9y5gQYHigq - -HLHAUDK8IPxYkAf4DQ6BAAKLXACaAYIAJuRUHRnZ6h+PfAAW4D0DJuI0HgiMUA30ZQDxoVvitEK0ElxU5jIgs4HTiT5ItAcj7m9G+i9oKthGtToQ1sDUHyYBvzYAIgCgZBvw1sPoG/XBYhX0ZU50LW0F2AZdCQTZgCvAGtjyrFUFqg70FagjkAz0RgDtEDkET2PfjChMIDBAUCa8vIXh5RJegQgo3izPZrxf8Q9D5g9MGZgiBrFCcAAf0akr3USJ - -jVRQtBAAA=== -``` -%% \ No newline at end of file diff --git a/DOCS/MainScheme.md b/DOCS/MainScheme.md new file mode 100644 index 0000000..491fd99 --- /dev/null +++ b/DOCS/MainScheme.md @@ -0,0 +1,455 @@ +--- + +excalidraw-plugin: parsed +tags: [excalidraw] + +--- +==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠== You can decompress Drawing data with the command palette: 'Decompress current Excalidraw file'. For more info check in plugin settings under 'Saving' + + +# Excalidraw Data + +## Text Elements +Инструктор ^UbO1uGDK + +Сервер ^Ng7jOhKt + +Хэш разный? ^myJh9kKL + +только Streaming assets ^lG2t8Jy9 + +ДА ^LKeOnhlV + +НЕТ ^2OwBgcpY + +Показываем список файлов для обновления и кнопку обновить ^PFZ7UV97 + +Запуск ^UUon7eVm + +Обновить ^7OENnVSS + +1. Делаем отправку по хэшу как на сервере +2.Отправляем команду на пересчет хэша на сервере ^A6DtzE7K + +Запуск ^N5WW0rpi + +игнор ^MtsjAaDF + +UnityClient + ^GiWyCxvg + +Инструктор ^0OsBsFWy + +Изменил один объект ^Meo9byj1 + +Изменял объекты не отправляя ^Z6lEawmt + +Показываем кнопки отправить и сохранить ^0S20oqau + +QTClient ^C9fJAlri + +Отправить ^7xaCVWgs + +Если объект сохранен: +1. Удаляем из списка файлов для обновления +2. Отправляем средствами Unity. + +Если объект не сохранен: +1.Сохраняем, отправляем ^3KDkfwbf + +Сохранить ^KxsTafUf + +Если объект не был сохранен: +1. Добавляем в список файлов для отправки + +Если раннее уже был сохранен, сохраняем и обновляем хэш в списке + ^feBPTVyX + +Кнопка отправить ^RHz6SvIt + +1.Пробегаемся по ранее сформированному списку +2.Отправляем файлы через XMLAnswer +3.Отправляем команду на пересчет хэша + + ^wEGenkuD + +ServerLMS ^EJX4eIpX + +Mainthread: +*serverLMS +*processingSystem +*dataParser +*MultiThreadServer + + ^ite9vjus + + +ClientHandler: Thread +*sendSystem +*recognizeSystem +*socket ^hEBOsWWl + +LoggerThread: +*Logger ^BKJiGpRs + +UpdateThread: +*updateController +*assetsManager ^ZvWgIkFz + +Client QT ^sWMT4y6l + +MainThread: +*MainWindow +*UpdateNotifyWidget +*screenChecker +*extrnalExecuter +*allWidgets + ^NEUKUPV3 + +WorkerThread: +*sendSystem +*updateController +*recognizeSystem +*TCPClient +*socket +*dataParser +*hashComparer + + ^8BGt5wjC + +Порядок обмена при соединении QT-QT ^vVekpzl8 + +Server ^vCiXe90o + +Клиент ^NxeRvK3b + +connect ^9pnMpFqa + +потдверждение ^DifxXHXu + +Логин ^xcJKS4BO + +подтверждение захода ^LcNUC6DJ + +Тип клиента ^fHhFW5dd + +Отправка версии streamings ^j8y5I09L + +Отправка локального хэша ^WbkyDR4m + +Отправка расхождений ^WvPnPDNp + +Если инструктор ^m7Rgi4y8 + +FACT ^QIsaPO46 + +Server ^57kJSOBv + +Клиент ^Iao6ua8K + +Login/Pass ^FgztXDxQ + +XML Authorization ^FAEhzlqj + +Send version ^Wsgy80Do + +GetServerDataList ^mlJDR4kA + +Send Hash ^uj7L179t + +ERROR ^t7LNKLEC + +%% +## Drawing +```compressed-json +N4KAkARALgngDgUwgLgAQQQDwMYEMA2AlgCYBOuA7hADTgQBuCpAzoQPYB2KqATLZMzYBXUtiRoIACyhQ4zZAHoFAc0JRJQgEYA6bGwC2CgF7N6hbEcK4OCtptbErHALRY8RMpWdx8Q1TdIEfARcZgRmBShcZQUebQB2bR4aOiCEfQQOKGZuAG1wMFAwYuh4cXQAM0CETyp+EsYWdi40AEYAZlb6yEbWTgA5TjFuAFZWgA5xgAYAFlaZ7ohCDmIs + +bghNGfoU4shCZgARNKga7gqCMMWSdewASSmATnH8ADEAZWIAdQAJADZnACyADVxs5CAcOBUdiUKoR8Pg3rBgutBB5oQIoKQ2ABrBCfEjqbh8AoYrG4xEwZESVHXRZYvySDjhHJtRZsOC4bBqGDcVpTKaLazKKmoAUkiCYbjOGbjGa/bTteI8eIPVXjeLjB6/RY8to8B7aWXzcbtdq/HgjcatS2LZiYnEIADCbHwbFI6wAxK0EN7veiNpzscp6Stn + +a73RJMdZmBzAll/RQCZJuNNFpIEIRlNJeTwpobJuqRu0LSNc+rbQhTmhxkWRnX4jNibsIMHhHBbsQWahcgBdRZVXAZDvcDhCeF04QrJnMLuj8fizST4gAUWCGSyXd7iyEcGIuBOxF5St+8xmTxrrXiiyIHGxI7H+GvbGwuMPaHO+Eu4rgbGW2TyJJgPkuzFGKIFgFMgF9oBwEgc4rQJPESEjFMvxjLMPDqg87TdMUIwKqanQPPEvyqmhPDWlBuGw + +bszj4YRFqtA8RatBauFgKx2gzNxMyWvyGqsSMVEwYBYDOIkrSSfyPC/LMrS/BqKrsRRBHFiqUwquMJ5TFpwkgTRxTOOM+YFqZmpTCh2qiTJ2i/HZ9kOfZ7R6bsBlicZZlmQ8FmoexpqIRqszebxHQPPMLnFG5RkmZ55mWX5+F1klyXJTMEVAaJ0WxQW3nxaJja2fZ2Equ0MxTMqlEgdB+mZR52Vxb5omWoVCm5g8uYdJq4VVdRtUxZ5uWNeBaEBU + +q7SljM7QWSMaU9SJ4Hidokl8uVslzApWHsfECHLbte2POlUX0aajHMZ0bGiQ2LUnjwcxEdxvyHZlx3FmMZ2Cex0xPQtCFIchqHoY2WE4aJJraMlUwdOVOmmvE30gWBIHqkty3tOMPCKrKSoPPDuztODda/Ga2EjCRZrlqJ7Vcdx7TeUxjxKvquPFBJqPo5jvHTPEIzsaqBN1phQNWg8crM2AdX1VpFPgXzyWC5hwui3NNXgfMSQ8BrJEzNzpGlaV + +vMGnLsoK0xSu7NVrmiUx/N2WV5o81bUz47taFmpzsNi7dJlhbJ1r2+xfIzN78mQyM5oyjjyuW+BxbaPy/IzRapXxDpXSO/KjmZ3ZzlR5F+V5jlk3zBjIwiyLAc6dT3GXp0SEw3DucZeB3FVzxbeTR3FfGW3NeXinJoN+bvXN/KGsY1N2PybJVmq5XPfxLX/eKmLZ4BSaubnQ7s9BzlId+7dmpi2H3spzJ3nMVaBv86WxuTKbj2N25Ck2480zecqi + +qfRLkti6RqlmrMWSqFZQg3ApMfq2UxbbRRntZajwt5I1+n9SygN5I5yHvNEC0DYG7XgVtYyY9brYQjpaZej9Lo7RwVJZi7E/6EQAXKfkpEzbFAtnncC2CqF8hoU1Yy9klSPA6mjMKs0MEqywZQqheD8oGj+uvJ2gkoGSJwdI5uQd24aIekomBKieHNziA5YqxDyrbSEuQjhyjYGqJArTGBFlfg1jJl1URrDh4gToYRNaQCHGTT8nmMe8kVQOO5r/ + +fCcjS7Wk0rxZSztlqu1+O7MhYjo7uKDvHPkNZUIiz1gHRIf18kFNMUfeUOVT6kXgZfUS+NkqkUkpqEuulzEgTrDAiiWoJgWW1gg3YkEmm7CLP/ehDFWLsV6ck9hIFV5yOLAoi6P014TDlBqYWpMV7qM0TxPWCxMqs0kmjDGGptaYTMeMpuNiDS7XameDoiz9aZT5C1FOC8w513VK0MWipVLV1lCYheDZ2LwTzPwjS40FL922h8uI8dOlJ21qnAFn + +E258Q0laC0nsM5ZwckNOCiKeLIoEmivpxQMY6PiZzCiTYcVxCRdMFFiiiVgBUoROY2sOgzT5DPKlrd8WopOa4zBuxLyjUKUhRU2yfrUrxbSglfKwBsLOYKyVvELTozlKWMVCKlWc34rysWDz+HcxrrJMu4quU0p1fS05bldmdQObKPi3NNXculbqhlNr9kcwdd0wyuLuI8stawkkbCID4FCFAZ0+h9BqAPAABV/PGNAc5HzilYPoMc+4EAxsCDOE + +Q5RMRCAQIsOA2bmC5s3D2AoABfeoRQSiwEQOsKolZaj+l6M0FM4xFhtoGEMcoHRtqBSJp28UyxViSgkJsOoI7DjHCrKgD8X5mzXEjJoYgFQDgvFaAAK0kAAaWwBoeIbx9D0F3RweIABBf0sJ4QUhFBAGkh5bT2lxPiYghI0CUtJA6O95QH0ulpOKekWZpxdjTs2dknJuS8n5IKDgwpyiI0gOO1A0orRB0VMqXiC9uJzJKLqVATELkNhAejGSgNn1 + +kidC6N0npfQ+iQIsTQgZWxCFDDRiM6AowcBjLgOMUAExJiPMKwpYVsJpgzFmATaBPn0NQrmNCxFLwVjnTc9lTs7nNlY+2TseRg0DiHG+VASaJxseIKB+885myLjM6udImR/xoC3OKHce4DxHhkqec8YwrzihvHeRND4nwvjnQuwt3542Oe7AK0CoyPnX0hlNMstNaa+fAmM/l4jdjuvZockiMk/IJahsli0ISGX6qcmdVUnQw6cv6apU6LFCVWqt + +kq2mkNz7HgK5dHRHq8uXh4Hq+U0KKoyQXkTDoFdrq0yLNVzp6DMspMFXkkVf0xOgJAkK1b+STR6pW9t9bMS7H6gXo8cqu3yv7dW4d6yO9Jg+1DvbPbImCk3Zjv4jWgStSFj1UHQhWsdbMSTgla+KUkqTV++rTWCTAeliLH5RIcnzQAyU4PRbEzBV/bHgDsOQP4dVMR4ReTKOB1QSDdeMNEao0yBqHGv8lnk3NlTemk4WbmS5u4Pm8LzZi3s+zXpq + +tNbxT1r/U2mo5Ap3Nm7S0VAJou1MD6BwQYHBhhtH2RjBSdkrgrDWBOmYkorgzuCO598FxuclGXegIEAAlAAGv0AAMvgHgABNIQ1uY3KAAI6OgQN8HgABxZcLweT9jhAiJEf7H3+jtFRt9H7eCUZ/ZHlEAGn1AeECB5kvI2Qci5LAGDSGIBChFEXlDaH+RLRQnKdqloF46iJGacGqcULlSuejJPuIwy0YkF6BjfomMsZDMQbvnHoDkB47GBzgn33J + +jQLs6Sa0p7YsgOmTM2Y9RV3a/TYiFElQqaM5hZOpYtfim0x2ct/ZyCGYZ6Zqc2fAtWZKDZlYdn1xRec82VzGajMDZPNxbzZTPzZYALYzILPzZ8V8M4M3ItSLTcGLCCOLcrUaFBQODlJ2JAlrVWFAgGNA1CDAq2HAtCNAhsZrdHBVYoapJKRLaGE0bCYiQrCGYrGGUrWVeVNyF6RrTeKbByGbWmbCAGNHOVNxerBiN6Jrb1DiNrOmTrPfQbN1OxVa + +OSOyFfYoX1bfWQgbKBRQmSZQ6eAOaQjrBmOQsncZENSnAwanWNSLW/FNQgNNUNVnEtDnNALnItZw/nJzCtYoatAoWtSAEXRtaoFteXJoTgFMOrBgBXZoZXVXQjBsZafUbybXMddYTYUPadI4Y3ULGAkdIzCAIEbEa3VoIQGaTQAAITeFwAOEIAAEUXhlwDh6AAAVB3DI5sG9CPSkKPNPGPF9PEITT9TvBAX9VPNEUzLPGcHPcUSDfPAjFaODBDbg + +MvKUbWOUQ0S8NlWvWmSI+Y2UbQPHBSUqUiMOG0FNfo0fOjfvRjBcIfJcS4yMCfXjfjGfBPBfJQ9afQ8UNfKTbgGUOOeOK0NGWgz+FNZtRveYQJFORYc/XTLwq/QcBAYcR/RnEoYfCzFEpjJcN/BzS/FzXcH/Dzf/M8SYHza8EA2w5sV0ELIzMLWAv8eArLWLUSDLYQhApDPCf+QsKWaaCHZA/JVAuSfAjbRVKuOHVVciIpfk5BXAoU2SEUtQw2JK + +eWO+EWVZaU/6YguUgg8CL2XeX2MOMgtkpksAKgusGgssClDSPyfGORIKWYMYNGI+BrcQ7g/KAxIqRUYxCqNgkQlmHQpfFQurYoFuDZduB+LArBAMvQ1QsAdYgJZieBGUc0bQuBD45fYMuM4yaFIE6YZLIQ9gnrNM3Qz42M/4nMzqEEgs8nPzCwyNaNWnGwzEuwhwjNNnHNQITnUgAtdwvncIAXHwoXZsQIiQMXEI8UaXCI0IxXWIvtdqTofZaEkd + +HXFDDYGYIwf0fYLIhAE3edXIpdfIz4KATACoAAeV3QvQAFVz1iAL1SAKAeByjNBbgYBTzyjr1w9RjqRejhj4859E9ziqMvz0Bo8JjGQH9CNc8oMC82hYNxQS9ENFhy9tZzQNjtoiYLIKJiwG82gSI44iYNptVNc0sShY8HQHj0A+96N/RmMXxWN2Nwx1huNnjp9FhExZ8/iPS7IjFSpyoNVvjJMN9CMiDUFzRJgD9RgRYnYtSYT6QdM8SOjr8kSj + +MTMM8zMMSwCn9IAX8Vw1xcS9NtwCTdy/8vNSSgCqSKTmyqTICcjPxzdIAfwGSAITSOSII9URK8D5TMDyCOCXSmIJDvLjSltihv5spglArCzVYscKIypjZEtwqWTPYEIGJ1JNITwFyA4PLlCFZPZu4eJe465tov01Csr1ocqGVZMidkdFNLRwNNtSr5JyrIzdgyoYoNIUItIVRHVCCBTZSyrJgV4uLdYSoyoDlTVBUGqxLxhBrroeLRr+LsDeqtT+ + +rpqqoayqS6yrDGz6crLSL7CWdM0PC81uz7KIBecOz+yvDBc/DhcygmKsABNpz202hZInqe0VdygAFuZT4v0lgVy0jSxNyjcdzbLF0Ld8jLzNBTySiA8Dhd0Pzb0U9vzxjAKHQ/yiRhjgL/0UbmxgNwKpjWQZi89oNYKi8ELlikLVjT5wZSp1p5hmIRlxR5jn4ngpoJhSpWIGxtphiKKIAqKGMaK7izNebmKp94w2LBjUBRqkgpoZRxo5Qyoa4JN1 + +9pNZdnYrQNaJgtbUUJK0AZoyMtI0ZZK2wL8DLxQDNlLKS0SlwNLVLrNsS9KNwzav8jLVNjxTKLwSLIB/MrbvabLaT9yYROAoA3hCAjByg7JwZeJo6ZpY6AD+xg6XhBw4QCNuloAHr1hAAMEEAF4QQAQRBAAhEEAAEQQAYRBAAuEHzsAD4QQu/0CXZojOiQHOguku8uqu/0E4TAKAC9IgZQGXENBACoR6icpgKAcwAgLuzMXuqAdkf0PQLIXAZYJg + +ZEzS1EyAN0TMZYAgOujurOvOousuyu6uwUIQKe63cIMO8oOk4Apkb4QS1WhCZrXw4ofw0oBtCQPjLESXBoaI8ItAJ4N6pXXtIkExSadqovUdXXdATQIsIG7c3cy+g89YVoF3NgB3CgZga3doIwF3Zwa3AAKVIE0AqFqJdwd2YBGARq6PvVAtRtfUlt+rIvJCRpAp/LUsmLAygrmML0WNL0prQGlCwy4huX4L5ENJwsI01Fslpi6TPB0i1HoYuI4y + +uOosHzouHxFqeLFsHubHYoT0+zjk6xeVZUiJ+KEoQhjoxgtFVCLjZt1t4EkhIjpkbGNp3FNvhPNqUqXrtutvUogv8ICLus/RJEfufwdvsydrcZdrczds8wALMq9pDUsuXuCygNNzsufT4ygHKNHWWGUF9owBWCyZWBybydDTtCpwbOIDpwTSSfOIybvI/vTFwBUvAObEyFvNIAaZCHyPfrYE/ocrgOcuCsQMSoZT0bO2IkMfQsyvMdeisYXMhlMP + +RwwHwEXAoFBoQGuqftutfq4wzv/t5Fpn/tnKJDGC2PKhSIgY2BGG+BgdnQDrSbyPWH6GUHiC3VPL3S0ZhE/KYexsAyZ36PRqGJoZGJ+eodxsz3xvYaJugvmLgubHJrQBWL4bKlKkEaS01EVHNPidhbiDNG4o/inlNB5sUd73owH1uNUfuJJa4w0b41YvFB0f/LlHxnamOX3jTpMbvrwuVCwxFiOP1DDlsfZoxmIjlGcfkudphA8eaa0ogHRIgq8e + +0tCffwUpKG/2Mvdtic9vJNvBKf9ugIeY6ODtDvDt5DmDji1tVFJjRgIrToqETuTvwFTsWHbtVogEAEIQQAVhBC7AAmEG9ZrsoC3rda9d9f9ZdYevHp7vWGCAHtbWHtHvwEjcnunsWFnqiAXtIE8ZaZKDXv8E3vrvQBDb9cPvguPrYFPtYFNdcJOp1b91vt5CSBOWCefpHPQB6b6aiLCJlz5Dqp6G/oAY+rNeQmOK0gudXKgduFueyPubBr2HyLYC + +gGXGXBGGUH6AoHGAAC1WhSByi4Bj0vcDgXdxhcAKGsawXSKAW6HMbQWWHwWGQNLe2IBZiSbCM4WSgEXRReHUM0YWlUISITwUJS5HgxHiwPTmIgk1Sixh1/mqNeb+byXrMhaGKe8aXoxNHXj/yi9OXeQHEAT+QpofNSYdawS51jiHF0YzitM5LXHux9NpW8n5WCbUA/GX7yh5DByFxlX9KIm1XXbf9NWSTtWr7QDFWQ19XUnZ2H0ohSBMnsn4M8m2 + +nCnHB5PdrvbNqKmqnVbRO7Q6mOnenGmZWV78n2nOmmn1h23/RHLwnosXKIq/ThnVZcPoUCPLwiPWJFmgrIAghVn1nNnChtm/1XW42u2gHxrO2ZzAG0AEk+Q2kO9lzUiJ0Rh4bDdYH1mrh8j9AYBcHJAHhsRd0HdT2b2caL248r3gWz3b3vG2HpiINiaYLX2yb4MeHxRkLBJ8L/3rQLJz4xGOrCotQypsZtp+JiXGLSXrjBbKXhbqXx80O6XxaGXJ + +bS4uKJpGI2aHhlbfjYKg5VQdvdvdvH2wg50FIzwHEx5xWaPP8pXESs3ZXGPZxs2lXbNHaP9g11XoniTAD4mfbVOxOaSDXJP7WsgTXygwY9uwfqsE6sgk6o0nXRhw3t6JBABSEEAFkQQACRBUBC7AAGEEAHYQbOwAaRBABOEAAH4A2KAg31gUf0esfcfCeSf4fO7u7e6Y3Pm+2ZOE2k2mKU3xQ0356mRM3DO2RSB16OB82Ef0BKeMecf8fif/RcAy + +2K3z7/vTqbw62VaG2H6hy60Am229OO3JyXqRTwuYjIvCMiZ9QFZzQx2AaCuUu7mlf0vG0OBcGAQjAWiN34hSAL1+hxhbcL1yiN3ajd1bcHhCvuixi/mSu0ayuYPk8w/kaI/IA8aH2OGX2Fj4KmvEKWvVjIYEI/25hxsb4wuCMGwg5uKZowoHHvqRuUO+ayWbjEPJvkOx9Ra5uWeIBGWDnhtpIOhzRZbyONuhKD48OnYLJXOCVbHjuWU8Xzu4TaOE + +Sb8fu7vuAWPW32OwBgnHvX9nvVXIA3v+OYnBOyThO9W/uJPTqdOZOlPimfvFO5PcmfvSnw1LCNOmyan/ndPTOBfxQ2n6n9OunzPdelnAZk5nZJ2cEC8EJvPHCwq99AE4lW7NmXjgudvqqKDzsGm869NfOHHLZsOW17F5AB+zPUGF2lzHM9Q9sWYI8DC7gNx2IwAEFOxBoztTqluCAAHiJgcA3gp5a3LUSmC7pSA/QS8uUSVAXoEAO4dol80Rpx9m + +GxXb9LQw4pAsY+jDCQb83Tx3tquhNWrjCy4bp8liiLL9s4EVD+Q/2s2SaHWC1DYtuADYDFAzS0ilxUskRBhtRlG6UU6+E3IMGo2m4t8XiEtWQYRmVAHE1QSEdqN9m6rNhsOn6SaH4OqyagEkICYIaRXBJ61JonVRsL9VhI78IAFtG7kZyX5oAV+2vNfhvw2BcdrOl3XfnxyJIe0j+FlXVg/3E57lDWF7DJlfxU5v8Sgt/Ips0NE6P9ymNOSpq/20 + +7SdO6uvAzgpxWC/8KAwwt+vgIixOUQBtnEZs1TUK+Cdu6oFUPqGCSSFboLLHbsImiGTQys5sdaq0JWYYCGBfnFtrgKC4ECfBRA/tiQMIxsp2aGkMBv9US79A6BcDQOnO2jYB4eAUAcYLgxgAh8w84gqhpV2kEDFvB8jICkVwT5ysIWyfaFpw1JrcNM+zYZCiCna6yg5QeyDUGIyJil8Ti1ySvqTGr5j54O9fZ/EhxHzuDaWnghbt4Mmj4xhYNYbW + +GaGLCVIQh9bNANEhI6/5Jg/cEOCkOo6z8Sh6Q+jovxtoKsHuhQp7mExe6GUom+/D7nEx1YidpR1JFJnUIB7GtFeMmSIoDygDQ8U6cPYXAWwgCV1AA3CCAAZEFLoV1UAiIQIMnXgyoBQgYQf8HSEDZmjLRNou0Q6JCBRpnRroncjkHp4c8JAzPYLiPXcBhiuMXPZsDzwzaZDBewvUXm629G2j7RmIf0TkxdEzhgxsveXmfSraoA3CV9VXpt2Eoa8b + +qOAnZunW3pXCtQRzE3hvBQjtZfqVAgGqeXeFpdHmEgB3LugQCnkOAkgfAECFD6gipBUnUrpCOvaKDz2ifeERBUfbPt6uafeFhnwppZ9kWG8TEQ9BxHQd8M5gjUH1wSQaQTsPbUkUowFoqNXBVLRwTN0nyt8MOowBCMLFVAKZE4WodbgJTV7ci06h3IzArWLhG0z8wotIRkK/53t78THUTjpRxLFDXuZQ3Cgf0+6qiT+mo+BkHSB66jUAZoSHoaMd + +bOtTRYvCAIABQQQAAggpPcnhIAolt0I2jPaNv3Tb6NAoxY9BiZGDjElAExfPJMTMSF55t8A1E9ALRKPon0ixx1HsmWJvq/jKxTbTXv41rGXCh6IXX+o+2IHNi28FoO2Fb0S4xpuxDAh3hIB4CnkKA5RZQNgDgAu5xxPRScfYMBYAV5BILOcWCLhH3slxKfVcW+0gAfskW37WSPhD/Z2ROuQHb8c2GL7HjuKp4wbheOBZwdnBN4+itSPvEeD6W2jS + +WseI0hqg0IjMNCJbx/EVieRTOeIbwCITyYnGoEk2iKLo7XdIJ3jaCfd1lZwTt+krUoYqPKFatKhJQb7i0L9qn8tRp1A0cD24B4TzaDrGHkROHJmjAAuCCABUEEABEIFROmnzS6JHdGMX3VjahFWJibdibGLgAz1g6vPRerVNXr8SN6gkpaQtNEnltxJXZSSVUPLGmNG2ZwgLvdXrHKTFcjeNOupMHYyYUIGsHxJEQ7GJdai+k+3r2PQAxoXg7vS8 + +kCGIjWTw+ygyPjIN0aziJxsIpPu5MRGp8vJxeDcToK3GoZuITsQ0JrjPD6h+RB4yALC3CFaRvspUGaEREN72C4p43BKW4OSm0jUpJQDvtyIylMRXYMyN0pyJklsohWrUfkFEKFGVTwJ4onqa5Pql5MmpcotIXv3amH9zKXUxJp0NqGYTIAg0nCSNKNZQ9CJJoyaSRMAD4IBXVLo488ePrTHp60AA8IKgFzqAB+EEAAcILnStmoBAAIiCY8CeFoiu + +j6wAA6HAQACwgFowAPIgqACuoAEYQbOoHItGets6bsqOW7NQCl145Ls0usXRDmxz45PrN2fnStGLSLZVsm2XbMdnOz3Zns0uj7L9kByfWqAcOVHLzkJyk5Kc1AGnIzkV0s5xdaOXHMDmFzi5oYnaRADEBZAmAkY9nqPKnp7TU2B0xMcdKfanSRe500udbOx62z7ZTs12R7K9m+z/ZgcpuZHP7n5zE5yc1OenMznZzT5g8ouQWLEmVsL6nwhJtfS5 + +GyTnpNYwLns3enPVUAeiL+l2zuETZjYyoZ4Ql0gYjBrcoMs/oZPQCXlLynAeIAgCBD6B4Z8fRGeCPslQjY+aMzBa5NUGQUsZnkxrtoM/YEy9BCSfGMyx1gCRlkYjPkJ0HwoTNIplkSmVOPIrTdyRLgxKeo1m50i0p3gySIbDEww4KICkL8QP1VqFS4hqmGLkxAoiUcSgqQlqWKJqkMdJRME6UUrJVaqLVZyE5UUJyqFqjZWGonsUbJDoGz9RY040 + +XrXp7rBAA6CCY8XZxdXOqXRLlusnFLitxStIZ4T0bgDmSeZtOnn+KOJc87ngvJ4lLzc2Z0oSRAC8WuL3FV0hXsWNLH3TpJFY++nJOrFa9axFnK4daF+rfS4iXVTWOaR0mQK3gMC/qXArOoxoYAAAfWYC7tMwrQU8rbkvKYAWUW6T4G8BmDoLJBsIuydHyRlOS8FNdRcUx2XF1dYWpC5rmiNWJJESZf0HvmJgYVD9uKC8DWKqhpiXixuyjClreKm4 + +cz+FXMyADzPuHVIdu3MS0DYNiGr535l4OwcVNFalg/YkRFRTxz1myzRO2Q5joBFY5EggmWJWUboq+UQB9F8RFCSqOP41C+pusqTo0Lv4jDiATQ+/nLK6HP8ehmnPJhf0GGf8UVYwiYTrw/pACZhNnIZq5VZKRUcUHQcGNcrrA1hiokhJ5agMWDoC1mpwrAf5y/mvTmJ/bbgKqCbE/TCMZ4JTHyCXJLoXhkC5otUoRVMD4gp5ZcP0A4BAg3gVS4EZ + +QxslDLL2M48rjCPwUYyplHk2ZSiM3ELLkW5pEmYqEEgZUmaOYaYH1y2WYRbouy2KVwvimHLeFNI05fN0EUJ5GqCQdbJJHVR7COW78mRQIGKnbQngpccpRVJcZVT5+ltCUT4y0WNSih8o/Em1IMUVCNZ3tLWeqJ1kvz9ZxYw2VhIInjTTZdaM0YADwQAeQXPvkeiyedahtUPN8VrTx5Jwd0MEujEzzOJkAbiUdLyYxLV5cS+tfnPbXJKbp1bO6ZrL + +fkiynp3K84YpJ/lS4BVeoopbcJN5WtrQsocuPF0uZQNLycql+UwIvS/ADgUAIwMuHiDJdza3zZybZN1Uoz9VT69GZMqhbqCkRDXM1fjItWEyHE+EI0ITAca1UGFnMJIKRCeRSw0YEwPZU4NZler2ZNfFKX6u5mS1eI+EeYFrDKiNhvs7C0IeIyLwATO+YUKaOaA+VgTVFEEjRWmoalGcdF3HOftmsJK5qsN6VM8GhLhUYSS1OostdYuNlVq7FxEt + +1ghFQCkTPWFo7edHPzouysePrG+S7IrohzAAoiBo8+51s2udnUx7OzvWxbT1iHLiC1q5NCmyOZXNtEOzMe2dUOX3J00hyXZ3rT1rnUADiIJ63zqoB1NqPXTTpr02htC6nrDxYg20ASapNMmiuqZsx6Ka+5ymzzRpvTmY9tNum3Ovpqc1GbtAJm+TVFvM1OzLN1m2zagF82OaAtrm9zXFu82FbktqWgLR2tHldqglykraWtNnn7S56i8kdSvNTHBb + +Qt0myuRFqy3RbUAsWrzZpsS2Va/NBm9LZlrM0RyLNFdKzTZrs26bitzmtzR5q80+aqt/mwLdOqflgz0ljypdev3kmArJhpKgpd1nXVAKTeQjSYGjElUW5pVVzMcbb2nb7bwaaRDdvQAvRwBfgxAA4NMDYArgpg7Sl3MuGxBAgKResx9eMt/IjLwRFXScUaq/U5sZlmg9cWQt8nSgzxhUDUB1GIg1Y068xEVswp1ikQ0IwCBDbXyQ0N8jlTfJipzP + +Q3nLJarEfGLmA6wBV8ppjEiEKwtDZxVQ5zBNRK3BW0bU1CsnIQCtX7ArOOoK5jaKMhUmUOp+a1+SYqM5mKDJtTS/sipv4FNtdGK9Ttir6HSi8VRK//jrpM5/8zOZ23pmSuKGgD5hPlVrGzv5D+UhZm2EiGyu/7HDOVSvT+bku/lvSrtH02CmpO3UirjQDiCbJpke0QKrmnwU9fUK+ESB+gIwT4J8CmCkA4AhAAZUoL6LTjX1jkxHR+rcnGriFpqr + +QfMpKDl4di6iIdOVEZXWh8cYUodgaCyT4jKNpsJmQo3vHcK2Zd41DYzrb4XLhF9K/mUci+ykQpFfxf8cVNYjmhaF7Cz5SxsUrqKxd5mKURmtl0ISFRbGqFYYs6kFrqhGK4tYnvSH8bPqgmytbYtQBp0guEgBJT4ubVxKH9SS0TZ2sCU9rGtISqNmEta3psolHWlMWvM8XOLElD866XttnXK8F6GSx6VWOwH+6+VwXYPf/NCmAKIu4euvENxAlSrY + +9UDW3Ansk5MCAQ2QLdBemqIvAc984jhcjP/I4KFBsO1hpCxq6o6NByIivaiKr1ShaYyMJ4IaiMbjRZQ6yv+DXkUzkC+d7C5mR6pp2UjG+SUgfb6qH2S0tQMtVUA2Ama3KD1wsgqTPtUwSKNYuOMLkvtFGi65Zfy2CZmpVlIS99ear7oWtMUn7tR2EgTfhKNGw8RNZst1m7MADMIPHJLa41PRJEnw34dq2hL0A9Wz/Vdqa39rwl8YyJcOp+6jqutE + +gYI63V204S0l86h6XfSO3NsXp4Yhesgb/kOJhVcRGaB3GqoVKrmVk17fQPe1J70AcAdoJgGXAPAEA8QTAEIBKK4BPgXuB4BwFqIVARgLueIFQZcnDK9Vheg1RMpL0o7V6aO9gxjsr3IZuDaMYyEWAARrH1QhvAjM4D/hA48N1oHDXYO7019e9yG/vc30H3Pi2gBodna7o+hc7VaG8buFAOrh2w8MUa1TCAmLARwjD1GkXT8ulF/LchOzfISCq37K + +y9F1hxXWKvxG/Vup2s+FS/LxVoqUVaJh/gbusI7U5ZJuoYWbrlk/98TVuuWVZw/z270seqO4y7veifHiUTsV49JHePyY2CQaP3QpID38qVJvAJvegeN4iq5aUkHSIDKe1QMN2hBxgfkQDyEBPgMAR0JgHoC5NNVRe/BRMYL2jKVTMxwhdMrYO/qOD5qrg3wxNDZk6YstLZTDjEZ6C+Ypgu6LXjCjSUqd5x2nd6pOWPiBFGG7wSRDzADZGwRcU8Xl + +O0NCVBDQap4LAO5jxxnlqmR4PaewjzAZ+Ms1fWYc0UMaITulKE+CoV3jYkI8pbWOJlhXH7kTp+0tX2nCFvR2oEwcM1ANcMmyPDNakideW5COgiADmEOUFokANnYATZwgC2a4AjywjY8j/VPL7X9mWt88trQAcSOdbgD6wDs3KebNZBWz6R1JTWykmHb4DPKxA5GDXV8mf6uEk8KUfKAndlQDYQXbgaPUjAT2tRj4afqYEg7mlzAF4LKbGPPr89dB + +1GdqsNWfqWD8x3U2uPfZ4zyFAGvY6i3Gw7ciYYwNCOwt2PhDTsljbmKaAmCfGaDDgs456udMoarjihm41LXKgy1ZgJoGaKeKVpPGUw6tbWuReI5FTVMuOBeBKv+PSyaNQJ27smcVmWHoTOa+ImaGzMMnZQkRRE0WsLNOHLFxYyOnHTEvR0uNo0oTdftv1mjG6e9Fuv4bRKBG3W8l5ugfVCM/70AEY3tWxJHMDqx58R/noAYElxK1L+9NI6W0fk4S + +EVKvWAzkfXMrq/0+S3+buckiRFilJZ7JJqEyRVGoG2ACU7Uq5CAjKmQIL3AgF3RQBcGp5bAOUQaXNFiAAIfAP0uVPTG4dkxjU2laYMIjv12MuZZwZWN8NSY8oKSrcrriAcidgqxIPgSAQoQ+WxVx02hdkN075DmFt02cvb50N/IQCBmLlKQtEaNchoeODKHRi8pbGMVPWN9ilmJqEzC/JM/RuX6S68h0u+2lvqzWRNd9Rqbi2sbFb5mkTvG0/aib + +12ic2hyndFZ0KxPbVqm/Qj/pbqXlEmCV1ujtmScZKUqwBJpZwOPFsjxxiIfVjYU3lpT4XRrAaOVIcK87e7MBx2nJRyaQMFK4uQe/k3EXGi1YKIK+P6ngZGD4KtydvWBeDIgAAgEAbAB4JoBgBbpWgz5nVa+YxpvrGDKg5g2oNYM/q/z3kgC1juWgEJWI7SepGFCgu8gBkE0AWLdA1C1xGrMh7SlSL4XtWmdnV7wYqCBTcxvIJ0WZOGpkmRqH0s+p + +OEBs6D0WZrjFxM78pYs/cmN2+1jRqy4temdrfF+w2rscMDTz9w0y/W4Yml1nVL2PB2e3ItHRzQ5bs7Ov3MABSIJ63Lptn0AmdN2x7a9s+3/bgd/Oppd7oRGhzelrS9AAMtDrjLk5oA2ZbDvJzPbFdb277djkB2g7S5iSdAYXWZLcjJ21tngPO2uXu2oJBG+9TiJoJGwYcY4n5ZGBQ6lgwNa80QfyLMAL0p5egM4EkC25HQkO3dACCmD6BvgQICoA + +gEkDW58AFN1Uy+rfM02PzWp+m0QtyskK/1gFw035LiDJZjBKhABVTMFVxAlQEl7hFaB0hhcpDPepq+LbkOS2WK0ti5bmGA1FRyzhYKfZ+hsgdBTQLKbaPLUmy8juAFOgbFpCo0MXAT+t4E4bf+UgRTtvAFayEzWtWGOLW1i25MF2vGL0J5ihoVrvaHnXpRp16/vrrKZYrsT1143QMNN0kmTrow4k90ymE85gBFKjHMyUpOjMLIJM7ij/fuXEoAHz + +KHDWyjuie7WmENrlVDYQMw2tzgenc922lhKO7hPpzoBNkoGimRgUIK84Q4aMQAN2vwfAMuEoD6A2+nRTU+lfVMI6srdNnK4zbyt722b3MBUHxGwjFh/Kk0XYgc0SATQiYZoTCOQJ0ii2Dl6Fy4wzqwteCE85R2yGqFNMKQJghGiNboaMzWseDOkaa8LuX1Xc5rBtha0bbYsZmYTWZnB7xe40FmDrQloaXqOrPCab99ihulnYjk52Y5hd/Onj0K2e + +tZNA2yORHODsQBQ77t7Oi06jvl1On2dbp/1pm39O+zSd+O7pe2n6XYjXEoy7xIgxTnM7wz0ZwXejsTOpnkWn1n0/AMpKS7tbey+r2yVyOUHdYrkygbO6127h6oW6LNlxGHrqBSpzIjjZqV42pgbwXMGwC9xy9l7eeqPhldsfvrPzsx780+wWN6mljBViUFKA5TdwyM9YOgshBA4px9G5UftLxHNCN7Qn14i48coUNS2lDDIluJDFGrKpSsOpEoER + +uSLgPf6gTtvEXmMPVS8nCDgp3LONvrXeOWD0p/KVwdW2j9+1/R2fucMX66nMlxp+gEtkbyt5Fm6+W7NzmHOh5nc52RXVU1Y9k5TaoDCpfWAKvy5Mm7uVnLTnTOotGrtOZ7J1fWap1b+urYOcWfNaU7az6JZs7NHGvN5Fc3LSq56cKbrXWru13q+HlWWIDNll+XZbXNXONz8j3Zoo9Z4oH5IaBpN4jb7QnnFbUMdu9nr0ca6EGEgR0A8AqC4Mu6Qv + +EF9Y7XtTHIXm9hxz+aZs4yfJugm+MlQ0jUJA4wHe1Xw0wyGhzoMoRsBqFqREuEOzVl02S7fsUuE8VoBCLVhviCzHjgZ54/5EBsjXMIgkel18bSeKK2WOt7JyYaYtZDEHFhjB+xc2ulPS4Xp/c3tYEtVO7bUr3kMjGCftYyB+HGV+4Yaeib1gtRZol2Y6u10zR37399Lddbv6J5kRwBdEeWd/7DpaduWUkenMSBAP85tvnL2svLm51h+7I5c/ZM3O + +XLDd7tle/w9qOiOKCcBeea3SBW8b2ISQAHjeDW4SADwUgM0RGAO5SARDKYM0WcDfAKgV6VKzW8rfU3q3tNqrlvZ1MNv8rBpwq6hnPDgxTYnmEWB0Ewg9chUI7UqOjBTgsph3nd2ii1dfvodon/5AbENf5CruxrJF/+3mBVDviFIbnJC6RpeokxUIaEXdxd05cpr5r4upB7ysCa7AChfLzB2e/NvCvyn17hw4JfP4DCMThJ3XSQ5KaXXehOJm6zJw + +Yf3XmHj1klTbvpJ265hPDhYWJCM8rvJga7uk4ylzAhn2oNnmVJI6OE+cZHeR7zxl714brCMOB1RybxPBPB8+M0du3eDzf1Glg+RDdkCFaBQAA8UAdoHAAHHU5cG4wZQBeg4Be5SADSit8C2wXvmEZtbzGTvfL0IvJPSLo0xrBRhA4f2DJpT125v1TQlocoO7WhAgsJItPPCjC5E/JfYX5gWwvg6sKCEq2KxFEHaDt1ObbRf7zLlr62PoIoR4zetr + +l8xZ5egm2OaDzfmmbBU5PWpgXsFMF7wfzrVdyTCV0ddi/m6ovF1qh/WUN2Je6Ht18YQSaYcW6KfJJ6u5l+mHZe3rDuzzhQQ4jhDlhAQtYUD91KSQlo/3+xhWdZNmEOVkN+r5uYTd3O/5C7tryKoxjTBLwfLdu0vb6+42C36ADo7gDHufBlAIYh9SCI3sCe5BmV/j9la2+OPd7+p/9QffggyQOb8FqWAoqUXn29aM0K75rj3Uyhuv7qx+2LYDAv2f + +VL3gz0eHWPMRsI7OhxONC0MMuUntjLDTWDrwuek17jeB9D88/HvITSP+XSU6C88WMfh+rHxAXC/4Sane5t987YCJ1r1X+rgIy2pInTarX1fl26B+7UJ2lnSd0cxEvHMJG4Pnruv1X7DfwtCxkBksSuYO2LrHL+RiX0Ud3PAkDzOHM8CXzWLt20FKvn52r4gDtBd0BwbEBUAoCEMVvjktb+vY29gU63sL38429Zu6DrQ2sWyDYIrOMwiOYjQd275I + +ge+WRD3vvaS7asTvsLpcDOJpDwIKcOdDGM78jVi2M7MC875YEPnA5Q+h7jy7p+iPnLqISgrjn6W2FTuK75uFaiX7lqesjYrvusliRIzSudBaIWubTtHbBuurknJoAIcuJqAAxCChymPDlqdy2PFXIey1snXKHyjcs3K5yDaufIpy6WqgD1+RzrNo7yAWqHIF0dsg7Jpys5toAhyIcsQGkBYzh5qTOlAdZrUBtAdoDus2rrq6iB1AAG7ZaogQM6KB + +ZAe05qBkztnQ0BHAPQGMBzAW7KsBu8m4q6aB8g3LHyLcnwHtyEcoIHCBzAbnTiBkgZjzSBqALIHyBHACYHKBXTuYEaB1gVoE6B1mnoEGBIgY7Kx2jEhtJf6w5u35uuXfrB6ic8HnErhBuzuXRRBlgagCaBqAAwFMBogSwFsBTgZwGuBzcrfJHOngd4GHOvgf4H50UgTIEcA3IHIEcACgSQGmBFAaoG2uVAZYGaB2gSG4JBlrkkEOyJzjOpr+WRhc + +5tAFdtDY3OSkvh5mshvJ5ajAKLMeZo2QMpAq9mXzm9qq+H2hIC7omAMwDNEuABUCXkujnr5aqJ/qt7w6yFlY6m+pett7o6/5pjq6CSoAhBWsYwC8iBITED1wFQfLG8jcQQJKWCf+JLvTqPEUTvSIBqKoG44KKbyI8CYsf9lLSpOKYMoT0yi+gCbI+ainAF346+umqMaRToSGZmaASK4YBN7hK7FmDtmX7VqFfiRITBurg641+cSmyH2ujfiyF+K8 + +zs67pBidsmwrOg6u64mWsSmaLchobnMHD+mRph5LBH8suqT+tztP4y4ycHP63G1eOUjw2MeueZsAlHuv5z25RDGjNEQIDAAEGfHsJ5YKLwfYJvB9jmb71uTjpb772UnuJClwCQKbBzMZvBu4QA4UsZDzA5HGaB1gU8PfanGZIk/Z++ungH6/+QftyKoUtMANhsixXt95CUZUNiG4UvKGJQwOutrAHue+Tmn7aKFIVn6oBaPrn6iuBftZRF+UlsJb + +SuNYU7bMhqoRIAFB5AUUGqBMcnjwWiIciMHqBYwTEESascoYGVyjco4FWyIci4FHyDQdMGl0qrn0FhBAwZLzZ0kzt07F0gAGwg3Th2FdhHAD2EWB+gTuFVBs4a3IzB5WqgAjh1cqXSGaRwZyFmiLYWYHthnYcUHIAZQaRKDhx4WeF7ytchOHcBJ8tOGzh/QUoG6uy4agBrhG4Q+E7hScnuFxBIzpXJpyjQcwFeap4TUEXhi5o679mOlkKFt+IodB + +7ta6dqZY3hC4YUEqBoEZ7bgRfYeJovhMckOFOy74TXJ1Bk4T+GHOM4aEHhBgEZ6wrh64agCbhxQZBGTBMEagBwRVQQhE0RyEVeHvsQ/pG6n60buP6xuTlrDa12OHPEzbB8+AkjEQPkO3aihXdqlxYBBjtbjfARgL8BvA9ALcAWOMOgb7PB4Lq8F2OInmf4riO3t8HLG+3qhj6gbOlxYAwqEKBwgcrvh/AE6nVADAwh4Tt/7PesYYiH/kN8AkAWM9 + +kI9j9W78nhT7cWkExAqgN/rzoQW0wFNAwBhIaYYFhpISmYy6GfnLqAQfjAY6kAkgBeiaAxNp8DOAmAP0BCAzAPoDW4eXJIDBh4wOiDi+dPlQCAQlaGDYQq2fmWHoBoXjbbVhFiiX4ng9KtVgkIJoMWC4BkrlfoEBcrhACAAWCDXyumtMEchylrX5usi0T3IcBK0byG3Oa0uhFRG3+lhFjm/+t365BvfhtFLRiQatHeS4keh6l2WHssET+DXm1Fqh + +RIJJCah8RI6TqeTLmebUCXuIaFnB6AMVGlR5UZVHVRtUfVG7ojUZBYH+oykf5CeZkQ6EfB5vnZEs2PwRQq3+itp0BdQDNLd5iMD0J6EG0vpqChe+jkizJhOo7k97whgfiFEQOeYJsiR+GIeZ4lSDMTxCmI20B0in4VFr/jsibyGMD4hsDhlEHuJIRpSw+QKr56pm8Evy4o+Ztr1Eiw++P1HY+2kYirEOZ1otbIOaQO/hL0EALpH6RhkcZEtRZ+tg + +A1RyxEtAYwkMPPqkw/MheDeoLYLgB7SbQPhCMxdynbGwgmAFdZacD4PD7GcBPuqLxeOKj9x4m6XlT4peAAjXbsO5KgZBuQVKr/BsxjIq7HKQZXm3AcxdSE57Ve4NrV6+6yoS9HrBSjsNLQhjzhpLGgLdqOzvOANOB57A3dhK5MCFAMuAB4mQNiBCABwHDE2hFkXaFWRC4tC4M2ToRb67eVvm6Ej6itgcizYU0HLjne20Ntx4a0ZmHBrE8TA/aoWv + +vjp5juP/vp50x1YK742qJEI6SJOcAou5EgdnrPpRSZ4HlBUcQsfu4p+8AYWGb6eUSbYbWcsdtY0hSsYX63uxflYpMhtZnyHBa5soXSxynrN4bbyudFHKxaVAd06503slXTSBv8XbJLh82n3KOB2clNqtBVQS4GdObmgFqsBtuACAO483swBrMpACHL4wPgVUF5ai2uNorapWutpo8mPKEEDOCED/F/xACY7JAJQ2naKgJzshAmF0UCYHLWa8cg7L + +wJ54TnIcAxmsgmVyqCagDoJnrJgnYJuCfgmEJGWqIm5a82vlpLaQ2k5qUJ5WjQlzhKQeGJMSrfq64aRqdus45sF0d/G/xMcv/GAJwCWwnqBYCZwncJMCXwkCJ7AUIkiJvTign1yaCU5rSJOCTxhyJHAEQmKJ6csolkJRWuolramibQnF2t0g9GKhWSjh5V2ecWm67mJ2J9HI4o/P9Lt2uvkujVxKsUwLLguDLbgzASJHACWhDwfaHwxtof0QVJXc + +dqYmqXwejEOR5eGfCJApphVDqQU0bsau+G0FpAJwFUPyCpuyFhTHEuAUXCGoctMf6r/koHODCagloDJAyQaMOVL7x1YLnxsiSmORgIWgyfZ4teEil+KG8HLsmrGJXcdfHkhJ7rMK7AhUQN7rASXO0C4A5RMuAAg9ALgBTAmvqQAzApaPZgHA2Scg5V2FnB1G4QlyUwJe4/QFnovAkgBDp4MDShejMARgF7hAghAHABQA8QG8LsQuHoAL/JBUaJBX + +JEgJ8Dpg1UTN4O48phuwVAFkkCBQKLuNbi7o96uBBoppKhikgQgKfkQO4DwGuzLg+gBejtAQIOUQUAUwJ8DNEQgMqqOgtwD0otR8bq9EdRXUVSFlhcoMDjPxVYa/E1hw0TvD6g9jCnCsQ5GL9QGiDYZ/FNh6AG8BMAjQA7gAgGqga7rR6wPqmkAhqcak6J2lnokuuMRthETmPfhnZmiFqVakmpg/mh5nOq5tJEJJuAnh75x8+CCFFxsvh1j+SkFu + +3Zt82NicELBBjsCmgp4KTbi4MUKTClwpCKUikop5SZ3HIWCMcb7WhBCqJ71JixvZGIuzSaRAGg6YY2DqpeMUXyjAXELJCfY9BFJCaw/kVTERONMcFGTJD7usZJO0ZiIj2mhvANacQEFqXBlwx3G848xMGJeBPCvJpAAHJyfsSFqUnnuLE+e3Kgj7SxAXg/FemMqbOkq6BDirG4+6sRLqaxz3DrEFJRSSUllJyDvawmxXYJZ42qJ3OpBnQE8LhD2x + +jscJTV4FAj5Ayg+FlH5fMHsQl60O8ID7HkOzQixxaxDmDrFqACAA8D0AW6KbGvpN6abGIsV3kxBuwA8BRpEQr6coAOxJzEkCTQYmKH7GCEFohmEAAGYHHL0PsZirE+NDl7GyswcXdaEqLDuHH0+kcYz5cODnAjBiw8EOAgCxb8KqD00jCspDDp8kKOmPp2sKtQHCwvtI7ZxsjnG5rB25skky4rKJ9Fa0rEFJBxm5cYlxCAgMQY7QZsGfBnfJ0Ovr + +5PBh/lUnQiJvsjFzG5/uJ7OOugq9DOwXpkLaN6Qqud5MQxkHrDykjCgISzArac/bRhrpp2kemCeLxQAkikONDjQ7LJiHgBwPnPoJI+fJ0DpRF8YulQS2UaxZnJnDnG5AxEAPGmEAYKRCnJp0KbCnwpiKcimiptKTboSpZhFKncWaGfd5ypXUrbZvxLhvWE1mH7p4brAAILzzqAjosQBPhHAAABUYQJalMARqW8AhyA2cWjPgzIDkxvAMAHaDpAE2 + +W5i4AMaHxjDZE2QCBjgI9M0SSAvWW6lMAUSaalxKXWX+C7ZXTP1lDZBqaNnGpE2VNliAM4LNnzZJwPoBLZ+4CtlrZB2YNmbZ+ANtlnZTTPtkEJ2iXM5M8dqRhEGJjqWdHSieQWaInZWQH9l9ZE2cNnupt2ViD3ZrAPBhzZC2S9mDZy2atksAn2QNnfZv2XtlXZgOShGepEbvdHnOMbn6l5KbDoGk361oJ9Gjp6ENzF6h1AtsCr+8qvkQ3JdyQ8lP + +JLyY6BvJHyRkBfJrcTmnmZuCkjHWRjoTZnOh/ca6GORn1gkglWIsKVh46IiL9QEYTeKQSFKnMIkIqg/4uGFXiI7v5krxQUWvFdpUXHHCkYJfKxArCiWSzEzIS0LhrSUloFpD0Ms+nQTMsTwI+zzpK+ill1SaWcekNe4JrlFIBd8QK6o+3FjumG8/FmF4Kp7/GrEUO4Gaen5E56cUm3ApSUbFIZd6bZCGoKuREgbwkMNhm4ZsFAqC8W1oIskAcXtN + +DrkZRusBmSx3/DF5HplDk/w0Znsbir0OzGebphxT1rbrkmOXlxkMoexjbkG51cJhCiovbJQRleTykTJNRHuRnHLMWcWfy05nJm9GfohHjL5I21LvMClw7CgcFXMHbNGl1GpwQY6SAy4OUSnkzAGnrK+WaZZmVJ7cdUnZpyOjC62RDSbjIYxQFsqDowtkJsSvwFXlMznetMAYjcICilqAOI00H5lRh5uR2mW5wWVMkLwLuZaDJCtsf7AsxBhhAF8G + +GEKXBJZbnkcnyyweby7FhmKTSlMCuKQgD4p4wISmYAxKaSnkplKdSk/J/qeikgQnUdVk9RtWdhD1Z+Djxr0h9trU6tZ9ToQFusIckB5QA3wNYDEAwQKQBoAO2b1mI5bTJjnPZE2YEB6APdOfTKFi2YNmCAIWG3z/uJEmIXIekhSsAyFchfDmKFKwFoXY5A2WoVsAGheHTWFiOTZRt8IHqPIHREHkdGc8hieKG4RkoYYUcA4hSYXSFTAOYUKFOhUo + +VPZ2hbYUIA6hd0GOFURTYW6FuICh53R3qWP7l2z0a1EBpSmaFyfRiUVPDqQ7dgbjHBp+bGnYp6AACDYA/QMZKnkOvmwCtAuDCMBe4MwAHiOAAeC8DOAFHlaHS5bcTY6WRD+bUmFpZeh/lNuFCiWBxAjenMDTAskCea1petBnAZIVoAXyygVoEbmwc0hpTFm51MeMlBZzOt4LYQNNDWB4sloK7Aci0fiLIqQleXzpemyxZIZe5KqdS4UQeBYclLyI + +JktZgmPsf56nuW6b7DcFYXPHkDRieUQ6ycePtF6oqx1v7FE+W1IBl0ZRnAxk0+qXtT7Eqr0Vl6D5TPrl6O6MsNUg/sJxdYJwaBhK+LYiNxbJB3FS+SL51eldhcKKZRvG5a/R2+eUDGIvEDjHt2oglXFaR/XkwLlEu6LgyEAAeHADW4RmekKmRpmY/n9FHcYMUFpNkXC7M2n+U0lSgLzvfSTRg7sRAK2lVmEKI4eZKhB2w00HWDQFy8TsUPiexTLa + +6MYwBELeQWIseCiMLMfSWbuB8URyYYadP7m5O+Ydy4nJUsc1LFOpYVwVuwtIQnn8F97oIUWK2qe1ku26wA7j2FygEwDyF52RNkRlygFGWVxcrIa59ikZdGXw5F2fGWJlNqetJcmkHpkE+F2QQQXQ5JElmXplvWZmVplSZah6U56RYsE05OcdkX05uRW0DK6SkZcpvQ9NFo4Y2G5Fzlnq+RL8ANKxoC7gXo+gA0pboXuM0Re45RLUTPMhAPEAAgy3 + +j0WilfRVW55pvRVKWy57+cWmNJpaQqXMsUdPxArQsdFrlEghsKaBlwZ8ETA6w+pRLYxh8BfsUhZ1oHHAkQt9jsT4iqYarTEQeFssiQwqcMeBCs8Fmrlt4LxQumulqfkQUrpqDk3mrWt8TLHdR3pV6Z1ZAJdbbKx/XoekUOVPn7GmKAcQ3nwl3eSHFkOaXoxn95aJa9YcZscRVTPlGkA4jeZ2cJGrFA35RbG/lGSH/jklMmavmNlYqUkm0l3bDKCf + +R6oNFziKIpngayQumRUWGO9ANr63A2IC8C9l9+fmlqma5RC75pr+T3Fy5fcSWl7ezSZlKHlGSKcT60DCrYhni+Gu7mBhZceTGbFIyW2mBRcBU+JxhuEo8AJAG0KWDC2G8I+xEaosrFlWMvEFqBjAoFQHngVV8UQWIBG6T8Vu0OfshV+lQJQGW1hjIUIWyun7u2au0MZU0wXZb3M6BZAWIPCAE5QYtkBdZIvNmVP6ZopeQpVGZRNkZVwdNlUyFE2X + +lXMABVdEANanhvtGg5h0RkHHRnfqdE5BUOaYnJVUTKlUI5g2ZVVZVLoDVWDZdVQ1VFV4bqc4xJ1Ob6lcVCmYm68VMGIpFh6cRBRAEWEUX5Yng4lUwI35AIM0QzAMAMY7i5SlYJ7rlK5ZuUoxvcWjFyle5UVatQbjmsKZOk8YMnM0JVtd7cwd0ImHtQt5f76BZD5SaWGe2Loai0mn5dPq2MROJMCvuQuq56vFdGu6Xh5YVeclyO2WbcCaADSnPYXo + +2IM4AUAmALcAIKDSoQCOgp5N8AwAxALgzlZvyawUwVFyVilMCCABuzYgXuMQzKAl5M0RYMMaKWikAtRCuAu4cAN0VYp1NXSlsFkqZwUK2J5q9QNZvUsCV4BgZaX4JVs0UlXoA4hagDfuAzqrXq1wOakF5lXhb/onRMHsWW9VKtch5q1sqtElQGc1ZkUyRKoTkXLV3ImVCqZRVKSSlw3ZUermgu1fkTo1mNQgDY1uNfjWE1xNaTXk1lNcuUYKoLrQ + +bnVKlRuVqV29qjGjFV/hQqzxzsa7Cnw6qH+l+hQDPKD75PiJhCnikIX9UBZ47oDXD6dKhMDlmPEFhAJRmIfbkKgTsA2A7ETwMwhMys+gRn5Y6IQFUulBBe8XMFnxbTXrpnpZSHi1F7sYKDJgJWhVn5qsaCWt5qeXKI6x+1YdXHVd+denPgyGaKCCMuYKNQtusydrCl576dPnCl9eaT6N5a6b7F66s9drH5E/QMuCXku6JeQxoQIO0A55q9V2DOAe + +YARxlQX4iAjnwYUHvUPuXEMeDqgAyRKpPKpGUfVAZ+AFRm4Vx9fhXk+xKqHE95jXgPnkVrPpRV5e8EGXX1Ip4DKCJRDBK1geZ9dQRmkQtMnyRSZSzBSWyZYvtxU0l+vHuZF47ZQopDcTsE77o27tU/V9lN5lfU31d9Q/XsNClRuVnVRvtHWXVsdWJ7y5WlQPFK5QCGYxawBOjzbYUwBQMiYsIahsm326xZwo++WxTAWGlaGpO6IFGGEOgPYUWU7l + +M5sWWMD4aXpE6UEhyWUFWixG+qclwVKDYynrA3tVjU41eNQTWXkRNSTVk1FNVTUsFItb55i1iFSPX4E0VRPXlFDIUGUVqIZSIWdZvPANUXZsOfiArAvTBNmlVUTIMAj0FQDABvoUZVACI52ANUCBF6YCFiA5A2Q9SkAq8suAexJsd2q1V8IHk3Bi5OWtHHZCTeVVfZvPCk3EAaTYNkZNGaFk2EAOTU00FNOhUU2VgJTbEW4g5TZU3VNtTcfS5VjT + +SQD5NzAC018hLVWkFtVwod4UQ53VbKwllbrLDmJNG2V02jovTQNn9NJwIM3DNyzTuSFNxTY6ClN0zRNmzNBADU2xFCzeU0EA+ACM2rNokbdFeps1T6nW1a+SxlNe3JrdBbq12iKoBONMPLTbVKVqUU92kpusCM1zNazXs1nNdzW81y4PzWC1HRCKXh1hvg5IXVRLe8HWZ25fC4SNiueXjg4ccLdAw4CSCFJiMCmAkD115oHnU0WhdbAW7FJdcoYh + ++YmKQgwCmmcsmiqCEOUiKQ7sIbQZh4jAvBhQ8ip3XfKl8XY1McUFWHmwVEefBU1ZEtaPXhNL8Tj6Re59QCoQZWQPPWfAB1UdUnViGS/VSg/iGeIM04ikhCs6dJm+nfmdeZ3kokIGS3mYVUJe3kwlFGUl74qJFeCV95SDWRWDMFFe9ZDMTwKNH+UJoMK3jUahOawSt6oFK3gW7FSvn9SoLQo6S+dJfQ1rVc5F9V4sE6ezlpEaEJ7XrA4wOURjeIwB + +QBbojoKdWr2UdQMWqVX5upWUtspWMVAWhFgaBJYpoBiyWM8xbhJXQwSK1ClQIsGrYLxEYUvF3lANfZXrxjlbIguVP+fO6YhvECRqz6Y0SqC+VirUSG2NS6SFVFhGWSWHR5OrWE3S1v3LLXTROAY7ZtZcTTilug0zcc0RFVhYkUVVrtJlX2gOVeU12FDhSMRvtg2T+4xo4hc4V6Fr2VEB4562YNmSAoQJIARoU+GTn/NyZWakPtpAE+0dNl2a+1Y5 + +77VEyft1VQTm/t8Rf+3YdgHY6DAdyHqB0pF4He9n455TTB3MAcHQYAIdh2c1XuFrVZ4XtVOzQbU4RzqXhEkSnwI+3llsZS+3EAThUNUftVVaNUEdsRfYVEdYnQNlAdIHToUuF1HZB0E59HYx36AzHUDnTV8wfKGvyj0UqFyZskaRXyR8YV9IFtKYBFG747YqKa/AvHki01xh5HilCABKUSkkpcAGSnW4FKVSmNtVNkI0ttMdW21x1N1QnVf51vvM + +l2tEsjpDwWyNgTHv1lkBUZ/Q0Qty06N1xg5XmsOkKTCrCNFTWBneorb8Z+CxDYpBbKIrbIq/4hSmMCCw8TM6VKtgeccmQVHxXD791Moo43hV/HDn6x5erfKkGtSKmCUX1kGenmFJmednnWtt6WbEMyY0HvkzFpxMVSutauH4KdA7kWD600YDR62UZLXaBnoqA3aa35EF+Vfk35nwMvVGs43ShmBIpEKViiZyjRjB/1n6IkALJk+QzRzJ0Gmt2wlD + +OFA3QlL/DA3pMyXog0IN6XqiUM+6JZG3M+NKi1S58jiDl2vlN8H5BewZEHwYO5MVBm0nClDVSV05EcQzlJE+RbHRKg6MCJXu175Bw2924ZSyl1x7KZyncpvKfymCpwqfHph1gyivb+dJLcI1ktVmW/kyll/uF1uhMkH/ACip4AohAkWLrZA/Il4NchYUf9N76LxWjQaXtpvLfO1W5F3oVC1wPiD2wxc0WWV7w9rKM84+mE/JeBYiIrLu2ZRbpY12 + +91zXafXfFXpae1eIsqbwWVOvXcnlgZxrWnnrAGeZenP1p3evUnmmMLlA9JgTrd33CCoDJA/pCWefCJth9et1JoXrRCVglhPn61fdEDT91BtiJUxkA9dtS9YRtqDVG0cZdEPjDZwTykaA58p5jYga9X4lr1/BV9sj0+6nFcZ0qhPFbQ300n0R3Cwwv3ttUNtRPSi0SA9AJDrYgcAEYD4AzUfT256xLfQZjKQXd3EhdGlbdVdt1vkWCtUjIn0kKev9 + +ed6KK6iPoKgcS3ShDzxxufsrWV2xbL1GlfLQcWVw6GNBrkY6BaK2kwxnkDbFeJJJGa/4rdqX36ghvSLEHtttEe1tdlvWbaf1QSEWDc0F7err9eUTVLSjwZUE7DeQ4cLtwfxoZV/ESAlsoXQRyocl7KxywzstqF0NrhXSesedu3Jpy37s4Ba1R2V65V0CA0gMxyKA0NpoDWrpgM+22A2bV4D5tahFJ2Hhazz5lHVXEZFlHri6mly8A4gO1yyA0nKo + +D6A1QMWBbsjgOce+AxTkzVltcC1wGNtbnE0NzXjd0hpJSiZ4KIJIlpmQMl6hW2d9joIQC24MGVMAGhg/dQaCNzPYF0iNwXWI2aVu5dpVSg7KH9gR+IjPrSPsBGBrhpI+gnSjENuoeCLDJpudo379uja95OVikMRBhQcFrlJrtMrRSg2qcjc/3Ktr/fY0el6ZkPWoB3/YpghetvZgGADAhQrXBld7XNEA5AzgUPa1uiZs0cd2zfrWdVhtRwN8dbrE + +UO6dcoaP71l81TX1yDS1bQ3R6SmWo4FgJXYczqDGwL8DLgWg+gD9AHsdbino7QJoB+dYLuKXP5kpaI1FpVLdYOSNyFHWDUKp3CeDHgQGiy2RZMtOGbnQIsEV6pd/g+l0Lt7lvmCpYjrV94RDgFXixTQ40LEP1dhBW/03xmrZukRVqQ/L6ag3XY1mDR2Ae/GK15frqkLRpAUnIx2xVSRLzRII9nRgjDAyDmlDzA3rW7SuzUbWcDG0VCMwjEg3p2ND + +CoQ2UtDTZRj0tlqAAGYMlvID2wMwGkPEyH5mgL8CUG7fbUqEAQgHRC3AmALbgvAAScuC24hAL8Bk1FAA0oagnzgS0mZrPWKXKVZg8KNDF0pRf4Seyw6sQctUGhrSrFsTNsMSM15ZWlbK+yEcO2Vcve6aPloUb/mgD5UMybn9FxRWLOw/PpsTc+5XbyDtI8mH5UPD+7allixTXRLHm9JBQylC11JYm7ZZDwHAAcAAIHAAvAQLhABVZSzFSHf9P1KY + +0ZDdIQemGtMfURXR9rebH3dCtGV3lwNlPvGOhtgPWxnA9mfaD32cdEPqNvGLKCyYAoZo7uoWj+woGjSZmbWFjZtU/gUr5t0LXETxtpiJ1TbVAeEMMQAPo36MBjQY0YPjGTbQF0SlrbeP2WDU/YnVAWJJHmDfYfcKlH0y6pbwDBhNNKQTngp2NaSS907dL2ztxdfL0IFBzNtz/eyQsmHJOqtjK03IBxri72j3dUe7v9rw+11HgvFKqXlQ4it8My1s + +VTe1QD97eEacATINgD6FKZd+McAv464X0S/Zgs5g5o8lGjEAIRciP5EDI0yMsjbI+0AcjXIzyN8js3v6AHNNwD+OxFqRYC1SDGRTIN1jWYwzm71Sg32jalHuUlDbVNzHSN424wEICXkXuACAXouDLgCX59RPoAVA/QLUQ4gMwM4DyVgo48HijEuU/kWZI43UkjFO5XdU2DRVv5T4UuWCAGKDzehqVKlC8Go0V8ag5ZWaNu/X4NajB/buO6jowEhD + +fWAydvHGjDyouqjpGhkyrMxk6WrhVp/bhZBXjbxYg5qtXxW6N01NKYkmKZ2WTUQVALI98C24OmSGOecCFYF7hjovfl2Y++6ehWxjiY/GPYVautA0J9mukn3wNGY4g0kT/TFHEUmw+Xl7Zdpk71aGkkhPBCjRNk67GV9ovmj3r5VwhrCqZofseZw421ZOx0T6/v5OBTwU1MOR1Q47MMSTwxZ8HST0/W6Gti1CmzTKo6FOuMqTvANxCtJ+gmH52QuY + +Fv0bFOk74My9+kwEMOVWkoH2Jh40LrmWjlkzoZCs92jKD00gybV17t14wgG3jyNckMRTDMAOj4ar45e3vj/w7kPCFc0cpr50ocsWyrhocu3I7aBAyRJfTP096x/TAMzmXgTWzZhHrAUEzBPcdTqRAAMTTEyxNsTHEy8BcTPE3xMCTmE8bUQAIM79P/TycoDOYjDQxh4GdcSSsHXOwtaxkM5wiqplvQGFPcN9D1I6HWOdeSfkQAgDwPoDKAIwMqqY + +Mw3ruiDGjoI6CNKkgC8CGD/DZdUmDI/TUlXVFLRz3SjNLbKNl1Lzk8I8sYDtNN861KGv0awG/VNOjKPg9p7bjq8YZNA1owIWNMmxYxZNSAYAXz7ljgPvcrq2c6H6hH4qUS5MI1JvaHkeTx7aQWm9ckWQX5EOALgy7ofSlfnBjotRwUpDD04mFkTUY/6UxjfXQlOysW3XF6fdJPqlNJ56U+mMpzxFcn2md2Yyg0xxWfaz4Fj1KEWPzAJY5lBljDNB + +WNC+5DRxVZtC1T5NtDCgzcJNjGbuhAOkaENtVMF7Jd87c56wMHOhzMwOHP9jL5tMOijw42P2STg04sMyTMo8ixnQBxK9D2IWIkO1JwHmfoK1YIUIp6ajYyQZM6j5s7/R3G1oLvjeQYA/JjXDwPhYzpIyk8orWN+Ba5PXTLw7dMntX/THMiI7CuPX6tKsUANTRWqXkPK1EAIADYIBXTeGPtgM5gLEC9nSQzgodDNrScM8iAIz3fvjbczvM/zNGAgs + +8LOizDSuLOSzGzqiPrA0C5AsW1I/uTNSRILc3MBNtM4SOSQ7cxgZN2WFIrT3zewHZ0287M5yXp5AeHMAg6W6LgAB4mAMsDfAUwIQD0ApAMuAcAAeAP1SzIkzLPreIk/MNST888NNK5b0NShq5wrOzqnlm+cm36CmyNMBeDQyVZVrTJsxblmzFyoVM9Wv1iVM115Uzcq2TTs9skx0DYAfotgj8/DVr6To/7OrpcmQPVJDBkJcktzLPNlkO41RZeSO + +gl6pTWhTKAfdMhDaIWnQ/zPXYnMO9pDrnMJjPrThXpzKY0HEEVwbf93Bt2U2dQcO0cSyQlzHBCZPWL5kyV5lT1kw4uVTa1NWMo91fVQ2LVubTLhkxJI7BS/eF3fXaltE6L8C0CbU6EvhLkSwcBszQk3LPyLx/oosWDCw520TjM/StDhRvC2NDy+Tsy4MngW888i2wpzAo3aTUvbpPrTB85tMLtUjHHD75X1UV5meorZO3FS2XXjrl8Hs14sJDSNY + +PXvz7wwzB8GHKM9MADk9f/O3tH08AvKaoch0FgzRM27LdO2PJjyqaudpjwDOIK2CuF04M8TOoA0K7CuMBcC2B76JkEyQDwzlQzx0QA9cbwunk/C4IvCLoi+IuSL0i7jNELEgIiuEzAM2iswrcK7KEZG2IxTO4jrSzTPgtybn/1EeO6tMXSQ48X9FltmaTkkclk9UwIbsmIHAAAgB7EIAu4xANiDYg4wLcD9A/E+GitAgk2ILCTDPRHUQiMw+JMzz + +A0/HVDTiy26G+VGcLb574HNPVPL9CRJIwnmM0OqNGLU7SbnGz/1TuNHzli5bOGj1s9FEySNcwD6C+QrDhpYajuWfG5hwsXEOOjvjM6O+Lfnp5Oo11DV6MGOFQN8DiznwJjaHgMSzvofzoZoHC5gvy01lpTSU+yretHQr63JjEfWT6/dhFekuZjafSUt5TPSNxlzJXEBXMfGpU8GsC+P2I0sNzNY2bjETdfc15S1Aq7L5bLN8LulUjvwF2LDL6a5m + +uPmOa91OGrU831Mmrko7ZkuhWOmKqJQmsGXA7EpJCy0Doy4/hr8iU0AbPeDJi56tF1psz6t0Mz5T9VtIqkcAHXz9k6+zCKnMMGlRre7k/Oezzww413jn/Z8uqlTda5nxzMVX/PZDAC/gGAjd+ugBzSbsi7Lpy6I/CvgjbrEhsobpdGhtYrLfvan9mSC53ZGJg3rKvyrBwIqvKrqq+quarjoNqu0rNQ+sBYbqG5CvQj6G/UPsrFCzAZcrNU2C0b5J + +UhZ0dzR4PYga4Ts7Ot6SC6xJUXobALbjEAMwIQDW4iYCDpZ59AGHC1EAIAHi4MUwKuu5pLPfqun+W5YrN2ZmMZaAGg+hprgoFzk8v149XEGKgMy8VPsuGzHqkpjYAyQF/4nLJwwr0drBo66qVzNs0Rq9rdc0KyjpSEEYoPz58f+svLqrQmvQVro77Puj3k56MhLBjlujjAMACMD3ADwAVx5rptqBupRGMPxX/9pa1nPlrzeRktVrWS3H0ZzcJYn2 + +htBS/nNhtQPUXNlLeY+ALebXa1XMLQgW47P1zYUxQ0tLvGzm38baveRPWjk0eXUl5LM78Agykm0wKpb6W5lscLky9mnTLiMeYOjj8y5z3ylRVqtBcQqKO1hg+zg0SABCvblzT8xLdstMaNqFi5tubsIa1bmLD65CJhQSQGAOLIpMMraYhtpc7O/4vmz+ySWv63DVgVV04jUatb87EsFr+W2p4lrvw3LVxV0TbDuxNc0cIEcBxbLnQiDIcrHjZi8G + +EKUGFbrMju6aqOyIOoAmO06I6+eG01VlDMMxIBEbsE+sDSbsm/JuKbhAMptwAqm9NsabWmwxv+FeO4xEE73rGjtpyJOwGJk7ZC/p2ULRE9Qvo9tC/bW8A5xZ0MaS7SLhgir/SxoPQKs2/kTeAW6EM1TAcaAHiY2F6LUTfAhAA0qaAjoA7j9ALcePOU2k8823Tz627PNmrKixatK52qPWkpup9g85azAhLZsLw6/SIxXrxi6tO3rPLYfMdWvq+XNW + +zfm4Gumj9s7XM9btjIlEqp92s8seeXs+L7qt6Dh/2ZZQS0lvlZ5BZoDYgMAAcDW4MwGgo5b98aBsaghFsrpJLPw1e0YVFW0ZypzmJtku1r9GXksNb9WyiXNruU0PltrI+e1uR73a6WOx7Ia/2tkNfW43O1jku7VNmdhGOD6jbn6JCSCQzU1NsepFuLklcL6wJ8AF7ReyXsr+si/pvmRRq1Ln27pq6F3mrXPWotdc4MLlIuriYQ6Qstd2qdugoTLX + +sgj9Rs497HDCIQr2YsQ1hqA822GAoifbG7S7OKQntOdMeLQO8/Mg7me8Bt3TBa1XvYi386hW/zWQ/LWwb0lkrUdZEgPjuoAActbLWi8ct4YqaHABtoDOeBwQdMBVosQd2i5B8UPhG8C5TuILeK8gsEriM5rva7uu/ruG7xu6bvm7lu3xJ0r6AJQdlyRB+At0H1CWytU50gw5ayD+I9Lv19NYAzNz6wrGnSzr9AxKsDz/ZdvukA3wPQAO49ANW39A + +3E5CC/AkgA0ojAQIBwCXkB+8tuSlq26S1H7bPe21GbO6826BqbeIRZru7kSBzQwp2/nyQFZ8Oo1d4N61/sbTnm3uN60lSz9bVL4NcsF1LjKonHA+CttMWaz4W9Gs2NwO2nvxuGe/4uZ+fs60PJbElZ8D0AMaBwAxoBwCCkRzQTVHNxL4WUDDQ79e/FOZLTe5WtpLyU63tvduS2mOMOmU6n3NlxS73sYl+U1iXNIMR2ZN/WCKPYtJHzKlVOUlqwcE + +v8bcu7xVdD6nmANn2rDeOy/AJ6urvb7ZRxUdVHGkZY4rbg46YN27syxtvKLCy1fu0tOOvwRzAYfiVC82n6GoZnr5MtsbDcG4x6vhHHmz/tRHuEjG0XlMQvEdYhE/KdjvbathdNG9EFYBuJDmfuDuV7byIIZNHr0y1nvTiVTgciHvO5Ly50sKyituyBPBQc4nWPHicV0BJ0ScMHA5tisEbSdjTsoLsHhACfAehwYdGHAeCYcqqFQOYeWH1h7Ydc7Y + +6pX4DaHAaSf4nEK5SccbMh4RNyHxEyrz8b/yIvviMpJXl2+IU2y9qcLUq/kTEAtwDwDfAO/gkjgp2QLbgVALuOQDW4MAG0U6bkuQwabrhm1KPGb3bXMAekb8Jk6qoLx7hKsQbgyuMXrXxwctkiFQDpDYA/IL8f3bdlY9sBqN+0Rhx7oayzEzuDKpoZ2TVo6pLLInvpAcRbni6nveL3sy10W9CB0iejWyh0Vsw7U9aVutM7R2nNVbOS7iYd7GU42t + +/d0oun0o1uY5iUs+bkCIwXI5o/HuEEiR/GeVjoNmQ3crue1cIL7E603Yhw78PQTbVdPeqflFTAvoDxA1uKoBHVMi/YeKVZx7LMv5cy9cdbb91YTIMyJMtMCNgd8zsbHbfMAchwaXXGPyNWN28Gd6eFi3QyPuuZoJA2L/mzH7A+cwCHAkkNXVAeBV2R3CdvLAS4icddn9ZDuFbkGxE0IqAK5+NzR4QT7ZN0FlkpaJ8AExAAwXu9OpaWWrHWhHsdCI + +5x0VDbA11UojjG82ELhsFwpYaWouxyvi70pzPsBzDOR0OrHN2sVDuW6qNtVXpG+5Kszn+RLUS3AzACtmnkcoJadiTp+5ccO7F+07u3H3BrdC582sMsjQaAB2YJL7YIX+ykEdkKTBhhK04cumLXq/eth7/LVxAmCwtiTA9t764meEYauXKAnEVjWmfQHAG68ug77y4BcPjyqOTp3QFYbFP/LMG4CuYnYZRIAvAF6I6CaHrTWaK+X/lzmVMDnbCwNc + +d7B5Dn7NeM8FcBXALbWVAtUp9h7UXQ21cJTR7ZX8EXdVadtU1G054PMSApMNiC4M7AuUSc5h+0P3H7668atn7W6+I1LDys924+IADUTCJkzDXmZazedQcSGCp3IbmSG2/YhpbjWlw9s6XQikENYQiexe7hDLMXctzoTUxQKpnmR5FsZntl3Adg7+a+8Mn4u+KfCon0GxgeeX2B95d6ppOYUMnXVJ2FcsSiI8naFl+F9UPc75qWdcSndZTiPNDA56 + +uqtz3JoMkMNjVOPBxdU2+KZ7HEgLcC4AbAL8BCAuAOMB9zwpUKPOHIo7bsbrtV7afbrCuVjqYQMbfTCsoEljWBun2yriwRZrFYlFd66l5uNHLZi6GejXAavJDnDu+BPoHTts6eNiy7OrhhP9sNUn4/nMB4e2vz9lxtdAXW13jpF9+fm5eRNHl1BfALkI6xsYjgVxCPojoV1hfhXV1x354XVQxKECn0txLfSHz15yuvXg241sbBvMqplkyiYYpjbV + +l5vlc6HEgLbhe4QgO0AUAF6LbjW4bwA7gvAQIDwC3AZ5LgAXotwA7itTFV8YNrnCi7DcSjSN/VcLzjV05Emg/wb+l2Qf0CZ7KjcQOANIQjYCpfynvpz8fubIZ9qMU3/5CVBXeawn3ARrYXERpBw1sQ9B/lswHLT3FqmMIiBQO7azezWDo0HmZn6ez7NZ7gSx6PvXxR0wIvAygEYBQAtuAcCYAIMuXtR5X/a5UDJtFbtdxTSc60cVr5Wx0cU4XRwG + +11r2c30e1nAxwSNDH7GU2ejHLZzsiHFxcO0iJ3qw4m1iQxd5PGMIK0JCFOkA65PtDrdlCOvyD3JpGNdL4jHwZWMLN6KsDLkw4DfoA3d73f93g9wJcn71p4jfXVk/WF3bb37IV2depUBqlSw2w81DqZGSQBxuL7qzv2aXd6yNfv2LOocWhwAhGPw3LJo2mEyt3BTVgDoKe1lF/ndlwBc83jl2PePAE94WdXtkFwCONhCGxADxlywAoCrZUxBhvhl9 + +hVw88PQpW4VgTTB9hflD6APSdRXjJ5bfW3tt/beO3zt67fu3nt97f8nyRugCcPNgEI8a3SV00NULeI2Kl21tDcOcv37mQARJOhvLOsBWP9xACSF95JeTYAmANiAPABwCMDlEbADx4IA2sDAC4AbJdDd6rlV2ZmCXID8Jfn74D5fuQPlCk5WzAw7OjDTQ9eMv1LIADWRgmIQUm6sDX1OkNeYP5N9g+emVoJ6FVpcak8AvjLMaAdpO0lBHfP3c6d+d + +d1HN03e5HLd/Adt3iWx3d57+RL5fLgkgH31e4FHsPeyxm12Ap4s8Gkw/2909TPdlbJZ11IpTNW2lN1b/R4Us97W98XOtbJpAJCFPiiqH7ow8kBFRdR/W03OGPbS/xuO1Cp2tAXu4HNtVY2m+xqfrAnT90/4AvT0A/VXQl4Hfyz7PXafuHFCv22We5GHmRmQ8lzNMtwxEKk/Kg6Tx/thH6d7edhnUyRaAvlEwORz9cWIsZd2lbQN45MIm/RQ/G9VD + +2tfc3uW7zdDPQUmPWoHyS+gdw7OQzE1ALWJxABYJDuKgAXox9JIBr0RgPuDtofDxbfYJdLwy9MvLL+ERUnUM8we4r0E2wdK3hK/Y8UAjj84+uP7j549CCPj34/qPCHugA0vnL+oDcvI9Ly9PXejy9cGPb185aDHtDSW3y7IqnVaZIx61NsCjbF9oecN6wKQD6Ap5A7i8leh+MB+4l5FAA8ACppgCrA/zk8/w3NV2E91XVg6HdY6kfjtAgMJ4ApCr + +QLLa1cpPN9jMghHKFiTcYPIe6csK928Rs+OIxcNjeYhR9jWASKsVDKDKgteEKzytS3MQSYvsJ/Gs+LsW34utdzT4UetRSSdlmfAzAMoAwA0wAcAGh/T+FOj3PLPurcQk95PUN7895M+QllWzWvdHVZ70dIlTa4McNnmWSs/NnYPSzAjQk8ccirvWb5lA5vLyFJSrFhb0aTeEg680sHPurzReEjzxQqfuW0KO1TbVyYLY/Nvrb+28ELuq1Mv+3My6 + +89KLc8zcdRPCFokC7xaLgRxCGy/QBy9uY95zSGLJxsTdp3d21C9Z370cZBOtFXlhDXLyL99uF4QGvTT7JtT3V0N3DXdi/5HyAbQ+4U9MmAqzF46zFN8Fe12S+YHM0fBuupbTKgCTkbL8dcrADHwKp8vYj/Lc4Xkj6wfEbvhcDF2vDr4QBOvLr268evXr7duELhF8x/EArHyFzkXXG2XYS7hzzyvDbVmyOdzkHp1hhb5bC6JW5uZt9a8SAHuPuink + +bwK0BxWmAHcm7ozRDGg8ANRLUQbsUNyccOHr72tv+vwd4G+qLzSVZ6IQCmP5SeYOizya8QBxCNYdAZ4J0Cng+8xneh7eT1O58OYhA8bR7QlBiiYoKl9U+of3IgTqqHi13+vpnlD5W9ZncW63f1vqa53cZc+ALgzF7MwNiBXoXb2GOuVKWJJcDv5RUO/omo750cVnbe7A31r+Sws8NbRS3O+lL6WOUu1QcXydCuk0vrsDJfKX4CHzHqPYseDnc+5d + +ov3jCK7Vmvn9xoP4tlrzGkFXkj+V+Vf1Xz6+9Tfr+++bnn79ueyTUD3/BEcJ4DFw4NONyfgJA2z9d5B9S/t8foPwe2l3/HRkzJioshb5XkiInW0Q/SKZ4zRXEwItnXeQ+OH08OrX+H5HkDP+L2NA6QAe7XtvjlHx+OsPOqew8NxIdKTkHAb2Q7j7A/4yh3oA2PwDl4/UQAT92g5O0mWXXXHxABSPIr4jNGf2ACZ9mfDShZ/cl1n7Z91EDnwq9xKp + +P7j/4/hP7o8ET+j0p8nvBc3TPMz6nymBv3HjlY92ddh1t9lFO3xAD9A3wIKVQABwMWgcgfvGwC1EPAEYBwA3wDGi4M5VyucCNLn04dBPMuWA8dt534vPfsfEGy23e2ZihDK6Lg7j1cQB8PFnykJEJduhHQezef3ld556YrvmbyXfHIJ4z95JAub9u132P0YfGkc+LNd6YfVl+zc2X0W1W95Htb2/PFfRz6ilMCQgFujxADuAr4CYtX9n4TTtcFpJ + +NfCKi1/4+bXwvcdfE74G3zPa94s+zvLa33ugQUCOH9Awkfxu8LQW73m8J/e771toCU+8OupX9Y3PuRrL9+743fSFrOtIdJ+ci21Kxf6X/l/h3+ccI3bn3b9uHKN/ZldXsZj+zqpgPieuzAj37mBC2YcGyhE3V24m8ff3+xMkAnevUtCtXeGlz5OzRdzK13/UMCYhy3sFU8Prn9cXhXsEfguRtbHX8+NPtdRblS99Uix9JCgx1TrogDYOtT8cVoRs + +ePrTtk9Br87QNr9M9B7cPHgb8jfib8zfnz86PqgDkAfJ9Ykjxt5vm086pqtUhNp+gSPKl9tqk+9+5tt9zblxhS/v0B8uMuA2+r7cBxkz11znMNTvo7sv3judPrE8gloPNgprj5AfHJvlDigcNakKgUBboHsNLs/8Ijl99j5i158YNNAvxHL4Uwih9tkmghrWGrlsvoDsM/lFscotQ8EToR9OLNX9oHIzQwLmgd3LrACMftAMgRsuBrcNbgOBAM5v + +Ab4C1drCMdahgCCytgDeOvdcJAAEC/AdQCrauL8dbgZ1htukcjXk3YG0n8hDhlNsAYrY8MGK0B8AM4BsQA7hbcM0Rj2A8BcADwAVVO0B+gO0AoAEMtBARPMeprv9jvjb8g7gf8Pnkf8KFI1Q/sO+JQXtrYVIpaZn4HXpFQK1BsYCo5r1kH9IXiH9oXtaMXthzo3dIdNB+AyZO1kPtAfii9xGGWZ0MEACVWl2B3Jtmdiwg5ciPmWFQXr5lRniktxn + +o3tZ7lM81OIvc8KrVs6zh39O9vWdu/iMd+9nl5rYPcYwaspBFgT5sjRvu82TAtUmBJmBaiKyNmAMQw26At8gLLMkLlvotZGCRgjtq2VYXkQgEkHzoToEt9vvqKoFQLtwdhP24EzvMDgfvacnNuMDoPpMCOrE59VzsICA7s0C3nq4c2gRkccvtZcfuLOsNIuYZjdMVJ3zn3w8/DLstgpZ0nYuKRyZO2JrnuQtTqDmdRONq1vEHMBElsS869hK52Hg + +M5r0CLcPASIUNmrrU6fordVnOwMVbho8IACL9BQXECqLuvxwANVBi8HAA92FEATgBrEAiOmAMgNGw1ePUAGAN2ZTJGTdKKBUBnQS6DoQGPIRAPxhjIukAHRI/8oPlxIPQZBlnsuURHQdF9PmO6COmIGD0gC8BCWrDdwwZ6Dnsj6CGgZSg4wZGD9AImDR+qKUUwaa1nstbgxAVmCoAF6C7Xof9B1AGDswVGC4NtWp8wYWCJZu4D/QRGCywfoAg2Eq + +C3QSbF6wQWCEwdWcc5qiQqwc9lJFsiUCTCRMewekAxhM0RcBMPg3QcwAimqNUCDHrRlQPutFQJpBVip0sH0FOD4QFZIXqKWZ2oH0lE4CA5bQUYA2AAYBzQT0ACAAWgzYi6pDcn5whwXVFEHIQU3QcGASACX5i1gUB3Fg+CTgO+kEEC+DErEDoEAJItcAJoBggFgFPwRRRn6B498APkRSAMoBmMAAAKPfD6BWCF2MK8Dr1EYAAASn9Ap9GUA6aDHw + +EEOghFsTghaUUXGAoCQhqEMvBrYP4w6YNPIiKWaANgOw+p9B1wQvEd6pZz/BAEK1eY8iIA76X06IvCtBov1Xox9FlOUBkvBdgC3QuE2YAbwBF4cq2/Bv4P/BhDmLwf4zEWCAGaIB4KXsIeTFSYQGCAskI1e8YhqiU9EbB2vEyGk9Uf4F6FkhjAAUhLoHe6PhHAAj9Ghul1GY4nUUrQQAA=== +``` +%% \ No newline at end of file diff --git a/DOCS/Алексей/Board.md b/DOCS/Алексей/Board.md index b7a24e8..102b856 100644 --- a/DOCS/Алексей/Board.md +++ b/DOCS/Алексей/Board.md @@ -17,6 +17,7 @@ kanban-plugin: board ## feature client Unity - [ ] отправлять сигнал на пересчет хэша с саб частью +- [ ] Добавить обновление инструктора, если он перелогинился ## feature client QT diff --git a/DOCS/Алексей/DataParser scheme.md b/DOCS/Алексей/DataParser scheme.md new file mode 100644 index 0000000..838e287 --- /dev/null +++ b/DOCS/Алексей/DataParser scheme.md @@ -0,0 +1,559 @@ +--- + +excalidraw-plugin: parsed +tags: [excalidraw] + +--- +==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠== You can decompress Drawing data with the command palette: 'Decompress current Excalidraw file'. For more info check in plugin settings under 'Saving' + + +# Excalidraw Data + +## Text Elements +ClientAutorization ^VP4aCm8p + +processing ^XJHW1025 + +ClientDeAutorization ^dBwEqoCb + +processing ^W3ieXrfA + +ToCLientMessage ^v5aqMTXe + +processing ^dIWpvau8 + +QueryToDB ^Ro4wHLcF + +processing ^tuNDziyy + +ClientMessage ^pEoup1w5 + +processing ^fVYO6Em7 + +данные от клиента ^E2CD89aJ + +в базу данных ^olioYzgA + +данные от клиента ^ZEwq2uVu + +данные от клиента ^zj1G56iU + +XMLParser ^ZWT5PNQ5 + +данные к клиенту ^XxzS7VZe + +ClientNotify ^iY8WShfV + +данные от клиента ^AZWoh3Ia + +processing ^sfpZYChL + +XMLFileDataParse ^rET3swBI + +формирует список файлов который приходит от клиента, +По идее должен просто возвращать список файлов + ^rvQai49h + +данные от клиента ^bC0PoVR9 + +только чтение ^EaenlE5W + +XMLAnswer ^xmqRa6Fi + +в TempFile возврат в байтах ^Py9za7Dg + +только чтение ^k4AV3S0f + +только запись ^S9N6oXDR + +xmlAnswer_authorization ^5GyrdxnT + +только запись ^jK6PP8XP + +ClientServerGUI ^2lyG7rdH + +Client ^rGTmYWLU + +ClientServerGUI ^xQWPHEVF + +Client ^rWsmQE2w + +Client ^kGFe01ri + +DB ^RoTCuGzo + +Client ^w55vspaF + +Client ^Lzkq8TfG + +ClientServerGUI ^6Nu6FkAI + +Client ^qYxPhLRc + +Unity ^X0KjhPzB + +DB ^w8JAyq9g + +Client ^ZoRAG9Ib + +ClientServerGUI ^k645SyJr + +Client ^2vva3Bd0 + +xmlAnswer_deAuthorization ^UXR9CfWY + +только запись ^CnjXQlAm + +ClientServerGUI ^8BUAeFwB + +Client ^BmbWvpya + +чтение ^69aP2rix + +Запись ^U9GYdGmN + +xmlAnswer_ClientQueryToDB_ListInstructors ^LLp3lgIT + +только запись ^ThqH7jSe + +ClientServerGUI ^rjgnwLFX + +DB ^DakCgRQD + +xmlAnswer_ClientQueryToDB_ListGroups ^Mrvm1TqY + +только запись ^8P9TNJF5 + +ClientServerGUI ^Mq26fjrs + +DB ^7wWmNCfa + +xmlAnswer_ClientQueryToDB_ListTrainees ^zuumjGQc + +только запись ^pWK0CMZ6 + +ClientServerGUI ^6yfoQphQ + +DB ^jnYmT7cC + +xmlAnswer_ClientQueryToDB_ListComputers ^obEhnJ4C + +только запись ^ciJWK6tY + +ClientServerGUI ^KBD3ykLr + +DB ^v9mcSZea + +xmlAnswer_ClientQueryToDB_ListClassrooms ^xIiqWq6d + +только запись ^yCQnUSL4 + +ClientServerGUI ^VUdvthq0 + +DB ^0itCdiQZ + +xmlAnswer_ClientQueryToDB_ListTasks ^6kSPB3Su + +только запись ^bZorPy2Q + +ClientServerGUI ^cr87o4PC + +DB ^wSDyWoUo + +xmlAnswer_message ^m1sAU72o + +только запись ^Zi14EIuF + +Client ^xwvVrDeC + +ClientServerGUI ^kNHbDI28 + +xmlAnswer_task ^HAZn7zFg + +только запись ^yF3lVLJF + +Client ^5Fpoud1O + +ClientServerGUI ^AVh7Q5Nz + +xmlAnswer_notify ^TP1o3ZrS + +только запись ^70wIsPDi + +Client ^vfZLTL8C + +ClientServerGUI ^IMueNsMc + +xmlAnswer_currentVersion ^RCnaFXqy + +только запись в файл ^upDqfirT + +Client ^ZcSZuU8l + +универсальный конструктор для ответов в XML + ^RcsoPGsH + +ReadTempFile ^UpOMxS5S + +createVersionListXmlAnswer ^uRIhHTin + +НЕ НА МЕСТЕ ^3uyWjgxI + +saveVersionToFile ^DEH45jEC + +%% +## Drawing +```compressed-json +N4KAkARALgngDgUwgLgAQQQDwMYEMA2AlgCYBOuA7hADTgQBuCpAzoQPYB2KqATLZMzYBXUtiRoIACyhQ4zZAHoFAc0JRJQgEYA6bGwC2CgF7N6hbEcK4OCtptbErHALRY8RMpWdx8Q1TdIEfARcZgRmBShcZQUebQB2bR4aOiCEfQQOKGZuAG1wMFAwYogSbgY4AEcAfQBWAHFcAAkALRb6gBUADQAzABlKjoBJbAApfRTiyFhEcsDsKI5lYMmS + +zG5nABYeONr4gEYdgA4ATk2ANgu9/hKYDYBmHe0ABniL8/3N583a5/37m6QCgkdTcHjfBInKFHeLxE48E7nGG1QFSBCEZTSbjnE7ac7PAnPD7Pe61fa1c58AqQazLcSoZ6o5hQUhsADWCAAwmx8GxSOUAMT7BDC4WrSCaXDYNnKVlCDjEbm8/kSFnWZhwXCBLLiiA9Qj4fAAZVgKwkgg8uuZrI5AHUQZIwUyWeyECaYGb0Bayqi5ZiOOEcmh9qi2 + +JrsGo7sGCajZcI4ENiEHULkALqonrkDKJ7gcISG1GEBVYcq4Z66uUKgPMZNFKbQeD0+7UgC+TIQCGI3H2Rx4vxO8XO8UZ1IYTFYnG7cNRjBY7A4ADlOGJuCd9v9YWdzoXmAARNJQTvcHoEMKozTCBUAUWCGSyyfyU0K1JKM3p0CwUHFJTKEgAagACpsuCcvoRxwBAL5ti+db1r+6BGAAYkMkiIZgOIAEIIAuHYwLgbCSFeMD3Ec37TI2pakKyVBQ + +dS6ajkIcDELgh5dsG8T3EOBzbOctQ/KiRAcGyub5vgAlsNKR5oCe+BhAU0HFLBpRseggHAaB4G6m+5SHpgX6ousaBbM8RzaLUZL7OcnEkUcmxHCio5RqgzgIrisJXEcpI8G8pKosCxCgux5wJLUJz2QcsIcZsJGopI6KYl+aB9qitKeiO9bWq6Sp8oKooikg55SjKlaKjyOWquQHAalqmT6aO+qGu6noQN6XbOjaCD2gFjpJe1rpNe+rUVsI/qBt + +2obhpG3YxqOcaMYmD70fWma4NmKl5gWo5FsQJYSLg+zDfKxDVsmG1iaOYRSagRz7M8iLwkc26jrOE5cOxmwzuO85LhwK5oL29zfEibw7vuwSscep4IOel7EDe6S1YtqKMcxEPsZxsKfDwvH8aOgnCWgZ3iZJKkyWeo66Yl6CckQtUAIJCFAfKEEYLHzhWlAdJ+5Q04Q9OM8zrNQOzGacFARos/S4Ki1kiGrQaTkOfWlN00QyhvegYhZEwuqzsL7i + +qxiGsQPoJDECsqJ6FkuBFkwOYSPQVR1I0rTtN0/SDCM4y6sz/gEFzek87TWQM0zpAs2zk4pQLABK4SS9wLJCNDeO2008VYsGSS1PJNxKfBEBIShaGYdhuH4YRxGkai2l7VRbBUAZDw8PsCTRa8fZWT2nFPfWTkuWS2ibG8vG1IDd32ecvclP5gWoPc2j7BFva1DdFJL+FsUZ1T667FCA7mfZJz3PESslKl9LpSUmUctlKroEK+VioV0pzQqd86ZV + +1XanVy0GsappBo8h9BdF0doHROlAR1Aa5Qhq+hGpIE641RxhilFNaMV9IBzQTEmPIS0SgrTWiJTacFiyGXQLgZI8CjpILQLBciswkqtnbFdD4tkT6DmnpAF67M0Dj0+nOTgP0/qoDHmPYej0uGlD3AeK6ZMU71gvEdeGd5sh5Bgi+Bh75KZkWUuULoowmi2lun2SCT4Wx0WRkxFiV0l4Y1Pj2OyYUBJFgJqgImeMJIclJlDVEcA2BFjUWgR8UwQl + +TEwcUZ4L58HFDCcUBeS8N59jXh8eIm9NG7zMvvU+q9Qonxzk+VMli8ahCgNyfQpsZCdgAgEnUhNRLOi1FADC20izKG4PQjAt5ar23QI7GoDRmhtE6L0AYwwxgTEBJAHoEkhDJmeC8HgmwTihWeL8Vy4IiTwimRAZQuAILBh2fqTA1TalUzOsw0cmRiAtIVG04h50MpRFIFAOm9cKBxVwOtBpVyFRvOop8lSEAtTUV1EEC8FA5FQ1zgUfOQKDFGJM + +bULSFFVTcybkZE+CzLIHHHs8HgMJyRn0gP3cEiQhzvFPiZP4OI/IQIwS8fYYUBwXDuvkreGJM68GJcCpYaU+q3zKvfCAj88q6klK/EqH8Krqk1D/XUDUAEeiAZaAVnV6W8DVTA80wC2qjj9IgsahyUGTVgNNTBuy5Q4KRvVLMCBekeNITtchwL7iHSrEa9xPyModhUjiTYmx/hjwtTwycwYATPS+kI5cUt7iknuP8ZxW0ZHgyhbJBRJQlHXm6feP + +BVjUa2I4kOHE5lESUhcUJB5xNvGQ3TTXbmEg4CsjEDWe5vpOYNvQE2iSgY231TFhLIwUsLUzNlvLfAit616UNurcoWtDz8gEfrAgM7jam2IObAqo4rZRFtqQXphdkKoXQicLCOEEB4QIkREiPtw5+3wAHKmEBu0ttYEsXUuBY7xyHYnUgycK0IHTpyne2cYWKS2kCgAmkMOmuAADSdNzYtHoPQdWmA+h9BjpgXAPR6AosYegeYiw6S6nIc4JlCy3 + +jeSJCRAN8RwRSP7o8WoSRj43SZXCYc5IpGzx6rwbySRCSHDJSSQ4PK4rAexLifEhJiSkm41SesF9uAWpvlyIVuUn5bsUUVN+pVlSf1lTVHUGZ/7aq9Lqq0YD1XdUgU86BgDYGWeoaNGsyD6yoIjGajBsYrULTzba1a9rvkkJ/GQ0smx3XHU9Z02u89Lk+tsfceEp9sb4oEa9bsSIMvfRjd2U4OIj7Y1BrInxdbRxZrhjmoJKYNFPi0TpdFmi9ESB + +uRQK8lQ2Cck0GYqYCkpj0MgAXJoV4eh7mUNgOD9xKBsCvL9Wo+BzijAALJXl0XF4F7zevFAsVMGJEAUY2JUnYrinxyRhXiBWtxjqSi8hJrWuSO284QfKG1jrXWes11RegHRGLnIbzxPCD4Zw2VvA+o5B4+LtBQhIiZFLZx2Wjl42CEkLxoQkU7p5UK4P6wSYSmCHlym0Cqes9Kh+eVn4Vd01KjTMqqpytqgqszjmdWqqga6Lqc9FPX2s+Zlqzn9U + +INoagEMJq0HeZFzNes2D/PBP24Q4LVatrhb2si6hHq3P1NCwIX1KPh7/HXDjkooaNY4py9G369JgYErjfcI3Q2U0IDRqgeRMNlHVZtfWQ7zuTuY0DaFGEV2lf1juzW6SviKadogLzWq+5Q6C0jlwdtFBH1Bz5lkOPAtw5CxFv2rIg7h0yygHLU2E7uA8pVmrY286dZLvMCuqv5R12bt1Dum2AZ91QZg/BxD+BkOoY4OhzD2HcO3oxEWf2UeY8Z4Q + +PH7PieP1ftYD+tAScM2QEEoB7e3ZQNPdhS9iQI2xu7gm1Nmbc3sALaW6t/D74QUN1IxsWE0OeJHCOK8ZLfYeyolJXxIex9YRbJbpOIKRucgQNULU8cuVbpEgmVoRLJTgfgE0wDeUSNic1UycRUKdtNM1qdYZMC1R6djNf4CFmdlUnM2d7MOcNUUC1M+c4FBc/BDVNcRcJpxcnJboLUZdcE5cMw7UHVvUwtnVSxzgothdYtvseAEtr5dc0B8QlkW5 + +exzcNYdgUCTdhF6QOMvg7dsYpFCBHdndXcKtYYVFEZ1EnxBsGwCMPxA4pkhsgVbR7g+YuhSAeg6ZtswBdtih9tvdC17EyRbJTgjgg8tdHlbsvE01yZ6x/FAkHwXw4kwAIlEjokpkEikiYDF594bokQzgx5DholikQ9SlylKlWIalAlg8ecmlblHB306EXwukEYsgD1oNYMEMkMUM0MMMsMcM8MjlZl5kXhXhvgW4fgkReJvhooLgdk9kDkRdBMCR + +vIPJwRkDiVplCATliByi6kvVDRpDIBrkaj7lQjGkXl/kG5AVKiDi/l3lLi65QVURwUG5IiEAwNnw4IHCnCEAXC3Db9GtbDRwyNDhEgVlsZOJ39opj5j4f8NgW4F5ksT5kReIrITgiQ6VbMGU/hmUR5QdxNt8kpCc+VL4MDadyctNxU8CjoCCv4GcTN6oyDmoGCqDwEMTNV2cOR6CBd6wDVhdRcPNTUOCpcShuDPcCF+CQswihsVcKF4gxDPUbsdc + +roEQ4Q0sdhlDuwI16x1C8s0A4Q1lHpdCStU0ysojM0TCPcAsvdrEfci1BwVk389gLV8YriIBQ8Xip0n0X1e131k9U9G1m1vT2ki8C8Uci8S8FZy8PTV051apa9I0Xl698BoyJBm8LZt0xZ287YgUj9xtJtpsKBZt5tFsVs1tQw70J8H0o8vTW0fTRxP0mY45l96Q18AMgN8cs4+w3i4Vyg+gMITgFwAArCgTQfASDOmODfYNkUYAcqoAAVVGAfT+ + +IkCI2Uz+1Xn/3EWRNeHMnxXtwgCYz7FYxPiWSJAJFXh4xoIE02T+B2GGNWI5XbNQBxDxEJCJGALJFAJSiJJUxJIMwkFFXygpMlXwNJOgBpOIKZ0ahZws0oJ5w6k5z41oN52gv51gsgB5M9T5JKE83QUly4L8x4JTHl3FJdO2l2goWrkYI11rAaLi2bD6xYWO3xADRPgo3VODFqDUKjUXB1NQGPhAMBiUOTTBid3dOMPdyaJqziUsI21+2awLnoFq + +FwEqGW26CQFoj23zSOynHsUTWPi+BCN2MlNdIiJNNeL33Aw+PKEUuUtUq6BwIazRQBPrHIUemhzWUDTfxhH92/wh0xShxh3o04M8gJGCKRw1SXgWRPjCiHHMlYruj3KgKpmSjrO/PQPZPUz/LJLFRfmKhAqyrAqM3lVMygvINZxAWZJsy5y1RQqZJKAwpYKwsgBwol04N83jFlyIr4KCwEO11KGlOBRODlJYIVJalkN4EmO8jCk+HYpFyHGUI0O7 + +FCk+HfzugtX0JEsMIj0UXNMktFMgF8OO1tNxRhwMtTkrROM8Xu3D3K2Vijw6C6z6HTygGW0DGiAcogHIBT3useueteprHeoVQHQTiShHTFnDLLzQAr0/GTM1ljMXXjOXSTMbxTLNjTPrDbz3QPV7P7KHJHLHInKnJnMqHnMXLLPHw4En0DgkAes5Cetqn+uYEBujgbO/WbL/XX1dLTnxPmM7IsveJ/CBUQkqCaAwg6COAAgAHlZz6hqhqhJb6Bqg + +mg4MByjA2Q1cKZvtNsHjASpwFllk+IoQVrLgKQeVf8F4YQ1q38qVu4LzWTICeaMi4DpqcikDDgvy0CGRfzypsrALcq9NqSirGcSqlVGSuS4LqDWSkKHMyqYKKr6qhdMK2CvNBT8KOrCK0xuqiFLqnVyLgV3D1dosWCJCCMpCGKLpxqkQSJ6NksQ1uLuwl4FreKv9XhPKjTRKzK3ds09rzCBtmtZKmt6sWt0BiAhhbQ4B6BP1SINLvCtKbTdLkt9K + +nTXEXS3TO7RwYjc1gl4jNEkiolClUjd67CnasiEDcjkCCjNKSlmQSi1AyizkXTmRqjWk6ijLHiFQjjX7Rqn6zjbiQgJT37iBziPl/7KIdb6wnjIUzKuyD8R6x6J6p6lyftB61huxwQh57IdzPKl5aU/LnIW44hYQ7oewSR8U1wwr6xkdMSmVTgcSAC8TJMCSPb+UMrMCALKcdNgKqTQLCDv5g76TSqw60KWprMEK7MI6OTarw70LE7Grk7cK2rZo + +CL9q9QSKc6hC87cAMJhrTpBDFTjsHSaUCQpETcssm7LclqEQTJTh1qDCxKdqJLVEVHDqdLi1ERAYvhl6Lq36rqw8XdtrXwqyAyaygz9UO1qau1gm31QnlpgaV8Jqwzx1J1I9p0Ua4btYEatSmAkbYaTY0aPrMaO8D1hbRbxapaZa5aFalaVa1aNaPNyzKbKyInn0om+0lMl8QbUAWzzqt9GHeaClPDnsrKJAhBiBZzahnA2BqhmBbRqh1aoBsATg + +2AOxqhzhZykHPqEAFhVzda+FsYNyLhHoE0iRT4YTMV9nQd1x7JAZvI7d0SucryhNbzhx7zRwkqpMXzZN3yFNmHiTWHQL2GPqJU8ruGCreHaSSD1jBGVV46BBRGaCarY7ULYXPrZHkwmqIAWrU72r5oM7iKeqAHldhC9pOQdGOlaLvt6L+b9HuAOJQpOK0T4zMtQbLsmXcsLG0BlkDhj5Dd26trbqzTHGzDt6LD+6ta5Kh6C4Y42BNgKAmg+hsBEI + +PCvCwAfDrS/DTtF67cvHrs9GTLrr/H00YHhn0BpXZX5XFWNmJXUG+FPIXhR4zt8VkloS8HnBAYF44QsU38byS1NSZ4IrPgXhQp4RDhLhLhbJEqeaUqlM0qvb/mCrAWgKQX34eHwLiqBHQ6YW9VKqxHeoMrOThGGr0X5HWqhSsFlHLSxSCXSKBrcBdwyX1GaXgweA411wOJfKsnBEVDHhzGRE4D8Q9gtw+X7HBXu6nHK2Dr1WjqF7TqdXV7TKHtOa + +dEJAABFZOUgGAB63cbR30qPNdpgTdtgbdoG/PTp6WPPYvJJyMlJ15NJiAGvTJ43bJxM3J1MgpjMrGoFUZ8ZyZ6Z2Z+ZxZ5ZhAVZ9Z8m+9P09Afdjdrdndusjp+J7pkPbmvp1uPmwZ/fE1iASDSWv8W0fACgHgACc4BAWcnkSkAc4gP8Ac5QJVr7aw+/RuXZ1AANFjX1glPsfFEyckM5/BzikKBEbGMkVQ6x+5vjB2lD14TI+A12vIlAonONyqth7 + +ApNgO1NoOukv+aFiglFtTXNtkyqgtlFot9zbCgU81HF61Cd1R6txt/q4lihUsqioumip8KwqWfYsapUgkMKANFtuurtvW3tzQ3iAGEePQux9ehxsd4V2rUVoege5y1zguKAIQBcXcSwGAO4Ge1VuejVzGLVs6pD7x0atexdvxM5OIp8NIuw/eq+qro+jJST527IxA2Ty+2e6+spAwUo05Co2zn+5pF+9pWzw4obx+55V5P+r5F065YBu4ihLbR4/ + +ACFF441wWnSVL9LwgTLq1lByAchZLVj65uEMkAcZLPc0ldcPETi4+CkClBHFAqhvCxlbE1lehh8rlaN8+WNknDqJT8k/2mnMFtN/hzTzN7T7NiRqqxCxFoRoztFkz5qsznzJR9OlRhXXq4ysil1XAWjpz4Xb+8a8yYeUkM4LigL4ME4IL2lh6Tj26YdyL0dqrHu3ghiKd1xu0g4TBnlZ02z0rm6006YIJntEJjmb65p6s6Jk98WM9sGsdUvZJu61 + +Jo2GMjJ3WZ9g2O9t91vD9opqDHDvDgjojkjsjngCjqjmjsfcD4X19Np8+eD9m/9Hpts6A3fdDyy9biQBcfATkbAACJoNkUgZwJoSWwGegQCTQPoI4SWoYDZlc78tc2yNHPiXzyKtZHjt1i5gAq54NW5vcp7nYRIa84TO8sTD7qmZ8mTYx75z81Kz237rKAF5TwH/Kn2wqog9NsHwzyHuF+ChF/NqRwthH41fk9g8z1H3F9HtRnx3OnH+oBt1AEup + +sDzy6FSETN4NcaYtlsNXgQcanvhEiMkWENU4S0rMr8S6Lre2Lvu+L8Vvbz3rtK8eMfYCgZFKCKZSwhSuDUgI0XcIQIwZ4H0BEB/g4As5DgF0GeBXgjAkgbAOti1oMdlWhREoC43RiatZ2hlErguwF7mV3eAtewuUDgBP9GIL/Opq+Dv6Jd9u2IBENoG54f438yWRuq63daQgvW7+UNisj9bgFWSQaPEHCAdKPRtgewChiUHeZMM6+LDRTk3wB5U4 + +uGKbYHup0hZ6gGSWbKzH3yjqw8VBLmZgsWzFwp1x+0uCtqz2WjT9Rq2PUsE0AX6E8ro9kGEDYw7ZPsKe88YrNvx4ocsRcHEVLIsXC6bUR2EoXauOyMHID2eqA/LugPOq6s+q/PQ1oLxsJPpp8L1N6soA+pfUIO0eYOAkIBpJDpeIZUGokwV7Xslet7FXhIAfbq8EymvYoegG16WxdeWZcoN7197+9A+wfUPs8HD4ARI+0fWPmBwrKpD4hjNZmnB1 + +ZpNlf0TvIrr00fKocBm/Wbsg7G/6/9/+gA4AaAPAGQDoBsAujnfkW5McuM2gONEbXyTgkSQGfPsCxnXDY5a6j0TfqJx3xEghwCaIhp5GYynM3mjtQNv8DjSBp9cpIQNJwNQISCoe/3HKjIOTb6Y2+4LCCiHW76qDI61VAfkizqoyMmCvJEttiwn6WdAh0yEwXqzMF7Ruh+PGLBS1Lor9xqa8bYBxDuYuDuAnkffqgAOBDhbmJ/OCBF3P5RdmeAQ6 + +/h72VjkDIWD/PUH+Gw7nArw+gWUtlzVYFpp2XEAIk4mEEb4V6fPLAdEM5qb0pKO9erHvRSJqinw5Ge1vcKXjDgnhfYF4fVkNyLxbcXw3FHxH+DtccunXW+lUi2IP1+uE3T+sN0X4NE0gqiA9A0L94B8g+IfMPhHyj4x9vweoAYhsAWQkgDaJ3QNJZCJA7AqeDRWYjvg4SDhHEJkFYmXwaLHJeuOxC5OXQgYf0xuzoppHN1AYjcbiAKcsQt3AYlBI + +Gq3fmrMPQA9ABRktIUSKN24UCIA5CCYpCF4gHDNwyyE4bdDMjLJbmdiP4FMRuHUNXu+Id7q8L6ZfcaQP3b2sKkTYt9QW4IkHhp1IJadyqPfERmoLhEGdB+8PZEUnV0EKMy2lqNHlZwx6EtZ+pYUYJYL1ar8NSTKYtIiVmr/BaRH4mTMlhBin9jSrIpnqYSv6Z02eEojnjiGP6nw9yvPGfuEQNZGFChBA1prWW5LhNPS6EmJgQjiaF4L2ENRXoE2V + +6zoSh8NMoTky175Mde1sT9tZXmF/8ABQA0gCALAEQCoBMAq3r0Jt6BlF8wwzpoh1uzIdJhbvGYbAwgBXgeAnIXcKcFwDPjNh/xRQT2NRwMYfg+KQ4H8BihMDewLwMcbdxIZTx8+EVXSYvVRIttooxokQVG0JL19VxmmYEZw1BGB0O+oPXceD33EwiWSx4qHtCK0EojLxpbNOpPzvHYi+quIihHBhfF9U3xwYfEIDGHBsJZqw4WkeCCJT4obotjHw + +Yzz8FCtwJ4o7SiEJOpL0MBerKIShJIlPpAALCCAAGEEAC8IHVMADSIIAFYQVAIAD4QQAEIgqAQAFwggAbhBAAHCDNS6pHUmqWL1SG1SGpLU9qV1L6mDThpo04MrLzyERkoaUZO9sEB6CKC9YL7O9kzAgg1C6JevF0r7B4nNMJpTU1qZ1J6kDShpI0/iWwEbKCSOarZR2mJKGZ8jgEbASDEYGUAF1Na1ha1pQL4TP4P8nwBHK8Csiyj9yDwXSd8Hh + +AGT38Rk6cSLkDRJA4CSyIHKfDSTl8CcvzH8vGzb7riQRqneQa5J3FQsPJcdA8bp374niER0jVFueLkaBS0RBg28ZiOs7Z1EJUpezsCj6DRTjKsUkXKFHBBLJa6s1bSZ21eiLU+EVdBkavAZ4gTcpl/KSgVPnpoCSp4Q+dshICZC9mmgAJhBUAgARhAapgAdhBAAwiCoBzpjUwAKIgY0qPIbJNkWyrZ9UpqXbMWnxNz2sTeXitNERrTKhrpBAJtMo + +k7SA5e02ibuiOm2cTpjTVIY7LNmWzrZ7soYQ9LZqjDOam+F3iBjQ7iTMOLQK8BQEqA8AhAf4IQJ2OUkbAvgwUIHNbVXicQewZtB4KfASA3MPx9GDiOn3CrcDTJ+8fFHbkRy44bJeM9KpIITbN9iZQPLcQoMgqUzkW1M+FuoPhFw8DxxnEfqZzH4o82ZIUjmfeJra8zcAC4AWYxSnD0YEQwmExvXSShLJfxfEO6GuGSSKzsBXddkTFwglWkoJRUrG + +DjB57yjuZ+rPxhVL1nVTXZU0q6bNNukLSwm4vYBZNMukzSbp807IUtMIlXtVpN7XJhtK2ka8G8YcsMBHMzKd5jpDTKmjAounTTrpc0u6SzVTkjDV8z053q9JznvT8BEgIwAOX2D1AKQhAUDv9O0R7duxGwHBoDnfwGkzgsY7jjpNbgb8dCaSFuCYjtpzwewcQMyX3MskMNHyS4/4X81HmEzx5TkkmVPLJmKDFUfkjKnp2jr9RTxK84fqwRZn6DhS + +hgrqoFi5mmDa2AEI+RXSSxdwz5M1KkcGFOC/iyGK8BKo/KVHPywJqs3LpKL9znZA8WshUTrIFZALyg1suBRQogX2yzpICtJeAsQUeyCJ3sy9vkLQWFCMFQcrBeUJwVkSfseCg6ZHLqHRziFTTUhaAvgWULIF7TASQh3oXjCs5O+JhRhz5EtBbQHQWoABAXArtSBjlZBl2LIxrxoct3OEnDP+AoEDymwaHB8CsjDxUSMIJkf6yjp/5tC9kSyX8CXg + +oFRBT5ZRYcHyRHxzuUieTg30FRjzpB+iyecKghGd93JpinNrTN8lWLDormHQaPz0GbyHF7MpxcYJs5/yIpwKGOB4sSzHY75UIJZHxG/GhRaR8VL/L4uZHZSlZEASrBEucbBD3BM7TWUVwiHGVypus2IfomWx9AAIWoMII+3QpYTaV9KxlXGUKU5DmOuIWyFCGMbIhuMUM0dEUt9nQ1SJxsTBSHIqHVLoAtS9ModIaV/yY5JCtlQypYCcr7eXSx3h + +nJEmu8BlXI4ehAC6CYAjARoeIH+BaAfUEuFc/6KZDHgxUxx5kOKqsqbnSZYlPwC7Csl4jIzIqCy5lAmjfzDxkSOMsQTGzskEy1xei3ArILBHvLtxxi5QRDy8nQ9xGvfSxfTKH5MygV68kFXhQs6dU35VbFxTiNrZGh4VMhK6HGnxQfA2Kfi4WX8O1JuCViW4BMVDI2pn8n5F/F+flKiUc9ip2rUqZEMVGAKaVEgVJT1PSXDTzZmSlpa1O6lTqOpM + +6/JaGRQXFK/Z6C9aeUulVVLjY4cupQQsx49DY5UeCdQutyVLr7pj07pWMOEkBg+lHZaYcwqNWTNOQCAK8H0CgCaAjQdMGjjHElo9BagmAXcNUHuCVA4+WzYjOjRtbXRLgQxCYiG10LDwM+jwIvmOPfwIhESmigvo8wJAl8XmWYweX00r6vk5MH5ctOIO0WAipBjkmNc5LU5GKZ53yqHuYo0HJr/JF44FVeOCkYiIVxaxXLZxhW4AOgC/JftwCpa4 + +Cm2IuRECxStFQzTGfCeni4Jln8ZksU8TKaEtHUEqLSIrG/q5xtW6IC4hASDEcFtBGhJALYxAXVyCEfySVGswdfEr/lUqjWjYiScZtM3mbLNikpyrar4pMoEgRIcyEymPJvAMWTGCEGcBSz0Ztgu5KeL6vJCQhkVsVNJIRusmLjbJAI9NU8t0UvK6NBi+NdPKhH/K1UrGpeZoMYKArEemLZHvmvRGFr8WJa8KbWx4XclYYBPV8eNQQJVyOB/nZlvP + +BpHKbeKewILSspQIdrgJXatkYSqs4oC7NoQslXeopXVpfBY66mOkKXDCwegdwXds03iEbbCAW2pBZ7Ll6irIaG60pXe1KF14ZVa6GiQevokSBX176z9d+t/WIR/1gG4DaBvA3HrVVEgPbWwE23baU516nVS9JQ5vTBlLC9AHTGGUER7gQwXAOXMfz/Q3gvAuNASguCnyW4KGtJKOPhnyZEZlwX1T3P5UWSB5aWjRRlqo1ZbMqOW2jRKEpJyDDFfD + +cmUoL3FUyU1pWumcvIBXaCqtWLexeW3BVFqsRUK1xfvL/AVqpNKyf3CZEAlSzeEIubyL+KhDRROIihTTdSu00s8+Nk7Wzb7gHWFdFt2sgBdSuXboAJ1YChBVQqgXjTsl5Ci9R0rwmntjty0s7eKqKGyqpV123dTpHlUY1ahhCxpRTT+2W6Hd1u9pVerTl0Lb1co+9YwqfVQ6jVmwIQAOU5DMBlA8QDoDAIwjLZmA+gWWguCGArtIMspbzTWIfx/Y + +WU0OZLIEUuArINwJwikBg0P764RFcSyhhFV1HttHhGO4baGpFzvDzRnwS0b8OHkKdqNzyhnfiqZ1xrDMjGorZmp04LyfJtO5jUiMq1rykeG82rVvN42i7OZAm6FbW1tCiaiR7nAsZWr9ScYDgDGZKXuSbUiJOKvwSyArKAkd08VOujkdJTFYAz7+0OlqD0DgAtBIMnISQPzLFF9rP5BXOdgkrN1JLn0FXXurEga7qjNR9XerDqLuG96DR/eqyVMF + +NEfC7co+oNL8JtH7Z8AxRbrnfVzHnJXxLo4sX/NG53Iv6DB0sVNwfF1jKxFxasdrSr1XJluzxaBq5sw7MBgDoB8A/zIr00rq9SyPYYiHEQkgNdA2vuLCSu5rguedepZOuGJ1dzFFBIF7rQze4U7IAFyzRQ8vsn/lo1jO2NS5NZ2JqOdc8rnb8vX3FaKt/O7fdVt32KN999WrOsfol2aMug0uzzipH7nDxfg2M+tYwMV0W4+2NGFeHBK12IHv9r8t + +WXlxxArIKQQ4xzZgMSUxCLdLTEXlLx23YSSjdvaZPhNXWFKiJBQyqbkyu2I1Q5sq6oQqvqXB70Aqe9PZnuz25789he6oMXtL3l6UETS1IZL0qPAoHe6c8HaJINV4CjVV4XAJkHwBXhagZ+mQ4DIEVGQR4i8YYrCEeDLJ8UjczFO/hoFf45x75eyL6pPhSdbua4QStjkH0WGVxkahyX7Qnmt8Cti+jNhvsPGwiYeZW9jR4YClcagpBavFgEaPVEtN + +GA5UI0LP1HDg9gOIXrUruii/ij4p5QcGNpZGTbQJOmvXQdmJWG69KDm8labpW1FGOpbU3qYABkQbqW1NQCABxEA6lDTBps68oDSfpOMmWTbJuqRyZXW5C11Yq/2d7u3W+7kauC/ae0cPVcHmq4xqPNyYZNMnWT7J5qdHtoVdMeld6iYfqqT2GqjNhAI0NUBXa2hvp+wJMiu2WznBZItoeoMtnwBS6ZD8fEjH9i2DyHDjsIBvX5wpAZ9jjCQW6MAU + +8o3Rksvq5/H51C2nkYJ2KynVyl8iUb8ZOitcTwB6AnAEAAaFTm8sFCaBUzPATQJ9j+PuGfli8nneVta3ZqBdNW3w2Cu3lEnd5gmgapoGeD4iKz1FclvpspYkjWEXkd/AEVmrUZfx/qQ438HbV4mwl3a6bbpq5FkD/9FAvkTwAnT1B4gpAYgBYKgOQTCpc2+kWslJ5DrKVI66FKIYXNLmVza55He6a+F7C7IduItL2GGIXdK59kQM38CjE9hQziYr + +vdwJb3RU38BKVLWYaHmJmR5U+wmamfTOZmNxzOn4w4aY3FmWNrhgE5I2X3WLKzXhwXaCuF11nD9DZk/bzObMKSCRI1DrVWrYFwhUSA55DYNrcH/ATj6uvZQ7lxX4nlZPayJZufVmYwB2e5vI2VMPOIGij8Qo0EwFnD1BZyrZ+qqyv+3pChLpAES2JaO0FKXdp24iUAsaMUTJTr7O7bKYe3oBCAxp00+aaMCWm6Y1p20zMwdNOnuJJ63bdJeEtMBR + +L4lmkDMdj26qE9EOhY02IgCbBOQ9QYWF0A6CIRNgdMPoM4DpgYQOAnIeIC0Awj1BhILpyDTsxcqVz0G7wMWWvA0mfnbglcr4EkDshjwhwuy5Q8jJhB7DbIlwUkHxGBjqL4z1OpM6BajUDh9g2AKhF8c3FrjcAtQYgEcB6A9A4LKFlw6Wb+X9WONzM8E6zNrMH6GtgR0tfheeBRTC64hC/eJu7NMVPWXwBEI/svnSaeUT+qWPRkRkjEUjMQtI+BLq + +ydm5zvIwA6QE6D6BIMtoPoOsw3PvytzpJri+ip4vDqCjOA3OXyOusdBbr91lrbOb4WzLK5qOR40EQdWfA/h/caKCxiWTXMCr9GIq/ob4x/4pqPWshgiFwZEaqdE+x5XToasHBmrWZ74wvtgtL7edJWxC3QXgub7PDtisa0LpvHYWprMJx8RIGbPSGiLujGKZXTtwAEgc34nGw4Olm8VLI4IX4Wkm8GdqJzU2wk4ftm2vXdz71ik/AapNT50hnJqS + +89QUs1GlLdRkpQ0cu3qXmjN2pvFpcD2KrOjXlny35YCtBWQrYViK1FZitxWxjoe5pWnjclOXtVsxhhe5YNOLGC42ATkAuCMBGABglQE4DHBaAUBcAQECgAuFjt/hHLbnOYAlYT5MdyMZwe1rdHJF4a7oCurK0ZGWQLx+VsYilHkQxZPd9RSQBKYGmjONXI2fTBM+Gsy1IXCbgocCxmcixQX59/5XMz0HzOFmu+dNzu9zqGtU3QTnG3NdxshNT9xd + +M1vOs2fLULXCR515flfqk3kg1kOIREhfMcHeRyeYtmiyx2+CeRnBOK2W1pv8Gvyzr3Ii64ZqBSYAzT/vK8H+CVZPWbNL146nGNOAIh9zy2kQ7gM8uv3bQ79z+xeezvdw8QpID4KSEHCnLYjJd5yHZFMgV3dDbwau76p/N8DewN0TReYdqsgXadbDHu5BdavQXybELPq9PZLNr7O7/x1eYzbnsQm6tUJ5xdNaa2zWRN694i3zdsTXKnWt0Q+31oxm + +/iViFVi4LiaYty2CTuuxWySb/v4gAHmV+PUtt8Ya2bLz1GS3JbTspDNbujuy9dfktCmEmIpj3WKerym3O2VEgOW0atsdGD0od8O5HcqDR3Y78dxO8nZaCp2rLYetIcY9kv2WzHIOmPdqbj1c03L8xoO55egxshNgkGfYDAEkArtdwlQOAKtn2BQDKgzgAshBu2ZZ2krRkHsG5DEScFjgaWU42g+ihmQCUtkX4NsHhCdyvzc8Eq7RnKvE8qrg+tu9 + +9wjXJncojVkm/3bYYdWurPVuh+WYQuDW3Dw1me6NbYfjWsLk16E/Kbs4r3ngQNpEe2fqKb3lr29sIw3TtLXKt+cR03AOF/G3R7zNdMc3I9vt5TVRcXfZz5uftzBbQBeldlJJojmIkB+u3+7pVUfwygHWjkBz9ausfP9AXzngIx0fsg3fN5GDiIJl0PDwLgZwbiP6ZIj1Og1TTgTq0/2Vzx0b5F4NFjfugvGSHk+sh032GctXXlZNunBTaLPzOGHQ + +JssyCYrNb7WHO+vNTWZWf+GuH7NjRi6mbPOmebj9TrQmkpBv5yQm1xwYklpFhQEb/wPcuNs/3MX8Vd93texby47m1HILkPHxcKNGOfbn1SS2tt1vmOvZBt1BeduNsBymjdjlo7do3TQbIAhTJVVhyGCJPknqT9J5k+ye5P8nbAAJ17Z1smv6yNCp6VE8zmJ61ugBigH+BjhwYEA9QBAPcCyfPBlA+wDgBQGWzKBRgktHgPP3itFO3TTHO1mmOHjK + +koSq8KGbDbqfEhNwnwF/ZhuKuJBOncNyq8iF6cUuCbSnGl6TbauChxn3V3q5Teme07J7cz+hwnTQtcvvDPL68SKVClL2eHmz9222ec4dm4XBz6lkc/8W/Ap4At2V+I+vG7WUcKpSkKMSOuc0TrTzvTTu9ed2EjVbIeoIhAQB/Bw4Vmjrs9Y4v0jF6BwfV0hIQOPZQHEk19++8/eEBoHJT57gmhIhKLzISxaI2odLtYvG3cIZt32Fbeo3y86yjGyS + +4E5kuFxeN4C5S87v9vibtLvLdmYZe0Px37LmZ4w9pvMvZ3nLjFhhb30TX+XkKxrVjybPPB8ACJzra3Q3jRR5NW1peCe/ZYiICsAnSyDLYm3yOWLU5ok0rZUcAeMWCE/IyB6XbGu2dhjnRya5FXcqrXVRn2VY83X2vbHDg+x60ctslB3XNthN0m5TdpuM3WbnN3m4LdFuQ3fQrW9QtB3+3elsb484AclrMBNACAODMQH0BFvMARoW0OcA4BwY+gST + ++IHTBCMluoNH1A7oeRXgUg3gkxGEFZH9M/AMGAeWRRxmhttvSrFwTt4cwINohW7vbqww/A/fweDoozgFj1cWaLMpnjHydzTeQqsf6bYJpZ8zeXc7ywp/H2azkH4cudH38WQ50LNFl7AVDJ9pXQiAk9dsVNiSbGN8Kyk33tdmr+9zOemWyH5KQKaVh0E5BCB6gRgYN9/f+d/u39JIS5x9YPNfW43Rqm73d4e/Butj/Cg7n/hgKolXgaSCyK8DK/60 + +j4tgluM3b+FPdAYNAuAoOCJ1VyiHQF9uzToo8AsOvBuQd9Q7o+QimXM7ob7M6Yfj2WHHH6s0u8cU4WZvhYAT4oJKjtbBHKkU+AOAvvv7znYIG49RZERf4gtQRG9+EoVsZHol9I34ABKA8b5DXen5psezKPlBlfF7UzydsNu2vVLJttXhpeokuv321tg9BF6i8xe4v9QBL0l5S9pey9mXvz1HjV+dLI3N61y3qezlxOJJ+gJoOZAAj1AFwuZyoPoE + +qDfS2QLQaoDHEqBshJahTnLyjtERv4X8dwpEHZBxP+m+OlIO6FkeyLfA40tXjt9I56ckear+Ntr1gQHfdeE2I7yZwx88nU3KfLH8n4zPY+ojJvDPtm+s5hWaBbo5+l58t73eIn1wgMckC2x2/iPAHgvzQmklCpaSVX45h5yrMq4PvgbSkt5xIFf61B6A1UL+78+s0vedXb+o91Im0+8XvvYXo1Rv63+ag8eS3y77B4Hb/5h/BDer3dDK/kpwQ90F + +2rn6R8aoiXUIQj/DIi2gFulql+7xtYYV+VDgPY/YCagN51+ZisN4x0TfjT6t+mFizarOArp35Nm64MJ62I2MN5C2QjLHz6g0jatxR7eLcHOJIOinmq7KeGro85EqBuio53cnEHL7/y2jnEIBeduvp7GK1RsKa1GNrp7pqWevmbZ+6qNIb74KOlibA++Yyv76B+wfqH7h+kftH4O+RnmzoRuQXi5ZzG+pj94FwMAE0AdAPQPoALg5wDHArs9QBhC6 + +BkgJUAcA+gHBhXgxALC4r+y5JnZlusHpIgJA+1j8C2Qp8JcCuqpdssg0CXGD8CBoqJM075+ZVg15F+uNiX5kefbtS5UeRPlAEio1fmO5k+E7hPYIBGakgE2KtPj4b0+Iuh357yK9j2C9+S3hJr9YUmpLZfALKJSJEBvAD6qT+KOHxBkgayKiof6/LMdaneS/ud7p2T7ld49katJUBHA+gfPzPexJgwGAu55G/gsBzmqB7guRqn0ADBQwT0DFuvCq + +v5/Y9AnsJf4a4Kc7RQYWtlbrKltM27BBIxOo4QAT3H/6Y2RHkAHNepHjj51WVLmPIQBdLkO4k+nyhTL/GNMg34jeWQXO45Bi7jxo8e/GoK48yRQUNQLe4rrYgXAcaGkhCUtQS2ynB57nwjNO/qEmjX2Sngv6sW9AQC6nYIXEiBQyJ/p9a6eHpN7YGeZrkE7GePARY58B66gIG6+C6DupSm9nmIH3aUcugC6B+gYYHGBpgeYFNAlgdYG2B9gcoHsB + +FruE5amQkvHru+/Sp76YcxAJLRNA9wH+CcgtQBAaKhjAEMBsAs5M8AYQfQHABJ4qwU4Glurrjsb/YxwDQI3OJIJIgIeGfEh4JA3kJwhYwvLLh7sQRfA3aiOWyBi7F+VMH07LiAzvVbd2aZr3YJBbDEPYj2sAZzr1+zHt8FpByAXYqoBU3vWZM+sJsK4cKJQY4H9+kmvu7K67kFZA+BA5vRhDmsINjit0YvpOYK2D9mmF3+SXECjnAC4EIDnAiEGy + +B0wsfKMHqegLrsofA0wQr7aB1YbWH1hjYWnYGa7pocA9gQ8HdyBoeAQ6o1OzgHxCJA7cvaHbAjoW058Y3GHsL4O/5lj4gBMQWX4CgFDn3aQB9hvR6pBg3ukFfBiAdGHZBKAVx58unDrx7cOs3kUEWC4If1ydahwI9B7AG8JRZj+MnsOjfAIxOdwlh8too6S+/aggT0YHYZ97AOeKgJa2WITqY4GOZIYJYmODlnra8B1rjSHWOqvPSH6+Djg55uuQ + +egeiyh8oYqHKhfQKqH2oGoVqE6heofUye2/nsE76OmplG5u+D6v0zdh5QJLRgGXQMtgUA6bjwALgmwMoA3I1QGwAACPAH+DQe2XolYwa5GDsDrKewEgREMt3AGjWhUOLoRwEzQTL7GSrJB07hBhft26eh4mq15gB5OE8E0e9Lg/DJBYYc4YRhrLlPbnhvwZeG8uaAYCFi6fHsz74W+wAY5taG9qUErWDdB8KhaKUvWp24X4fEbDoIQckhUB7Qbe6 + +dBKBngIVhgMnyIh+mAABAQGMcLAIthyjrpTcQ+IFp6/yOng2JgemHMlGpRmGBsL6hMygi6aSpkCI7wg6upEZThXLEkBTw6kbdCaRyMhcEAB2NqcHEOoAYM7gB8QZX4s6h4WPajeJ4ZGFnhx4TGFM2cYe35rOhQcmGEWm7uz6CynWhdieQPwAxZjgjgo8CbeYUfliWQxxusgARCjj/rARn8jlF/AnYV9bEhYbqSHQKJIdwGu6iluZ7KW9Rjr7WeQg + +Y67m2ogS3gshHrhxGcgXETxFwAfEQJFCRIkfijiRQoY9GMRrvpoEe+bERIDxA1QEW4AQHAIgBwYHQJBgxwWzl0BsA+wHBhpI9bJJHFO0kcJiscBwBRgpYGMqcGw2fHI3rZECaDijpYToddDtuukd076RUQV6FGR/UQ/A9AJkNgAEgQYT149AWzFCBWRiIuNG2R07vZEt+sYVeHORN4UCGYBHkfNZiuezr5Erea0UopwS9gtwhbWfYAiGkBvFLIo/ + +AvwKzFoh1ARiGqev+rfxP2z7gXAQCKtJIAAQRgNoyZR4wTiHtheUcVyn+unkjHoALsQORuxHsTB7kx4IDVHWMnFEODfAsZiSjZWIJAESWQzMXHGPcv/nEBrIUIHHGN2CmNVbJUfMX6H/kgsUcDCx5YENEwWI0V8rj2nwRNGZB8sQzZ/B89hw6L2bkUmHlA3ftzbLR8pCRZr8ayBPAvM0njvxLIw8a4J9svEJLbrgCcdIj3OJ3nQEzaWUT7FgRfsZ + +o4GuN0TezlAYAlNAq+EgNvFmolrpr78BGEeRJfRtnk64W2zIdpashEACjFoxGMdF7YxuMbOT4xhMcTEwxe8RwA7xooUxEIxUoUHEQAu4AuBXgnIMdAtAAaLOSLMOEHTCz4FAEIBCAgPhVGbMhobl6CKOwAvAmQAaAKo3MtkChpQgSQJFBMoODNc4KKfGDpH1eekU14XK3oVor3BePgmwE+CaKLEJsvXicD9etfuGHwBp4Q3FTRF4YrFOR8YYz6ru + +94cmHLYqYdMplBx8uGgBox8IXYDm7+BiojwBKLLonRKnmWHPOt/olHxuRwKMB0wMANHbtIXsdiGcWvsddGBx5/gXAUAOiXokGJEcUDL/YTKAcGcc9wmtT4uicZii52dodyzEJJkKQniaCyDdBQg6PncKY+BcbjJbhxkSKiMJXXvuEMajLqNFN+dcbLFU+Y0dNETes0fkHzRjZh5GHyT4X/KreZ2JjAS2A5vNQNBchKMScYhAT+Dz+88Yv6Lx3sSY + +krxZiWwGq+sHJhIPREgE75KWGvu7oqWsQoIFYRwgYyHOuf0dfEeuQCSAlgJECVAmz4sCfAmIJNEdbxK+bSVqou+YOgHaxOACaQBXgHQPcDMAFABhADhPIvH7OAqJCxiPARIMsiaSHENsius/wCVYBEnHKcp16rLEuHcAWCWZCnwiJIGhwgkQXGYV8Vyi2ynwtykOwRJ/MVgS5athvRqky8STXFjRSSWmopJPwQrEzRSsYIkNEqbpsDMQuAM4Bsgo + +dlADEAMcG/gDkcGIhCS0RoCMF7+R+sCEbOyYQuArBPcQI6rRXnIfzXKFFvWqUgJsbt68Ua4HdAKEgMKom0BdSdObxRgBghjXWzEDwB9A9ABLCvuHAKMDOAktDHCUcYIX/pbCoKEYl/uN3LxB5+EEaC5QRUeFxF9AiEAaAIAu4CxAJ2HKtrbBxdKianBA5qVEDqqYQChE8qNAssjg+VVkKq9J70f0lbqwcthGyq+6mMmdGo1CqqhuNqcammpDqZak + +aqcMeskhegdgAnip9QJKnSpsqfUDypiqcql/gqqbf4IC7piWiLwPYB8BCc/uIB53JFyXsJsIJPF8DHGWkVzh7CtuC2z/2H+LFSD6SIHiBTwwMKcpc8TXpYaRJRMs8HE+0AYVpHhcASy6Ipjfo3Hje3Li3F+GGdBikZm2Kbin4phKcSmkp5KZSk/uqsQtGdx+wAuCiujKYt5phZdAP7jUaUg6pBKs1AjiBK5IJ8CQkR3uiG1JmIfUnGJXyWwh78eq + +evFEhG9MgYip1XLvQYGoSJoguQjaRjqSu1KLaRrEYAB2ldp3aW2w9gp8BQYCQ1BhUi0Gjon1z5JjBqwZuinSJ6I9IQKNsm7J+yYcmhiMyNgBzIKmHpIEgtGC2wkGZTgnFYI+yO8lup0VEiDnCQaI05HIGxHQYPIHnCwa1Ebot/QTcZYtNwViQDJwZgMAhhAxCGUDIuxbJ9ACuw2wyyI6BA+oNkZCIgGDoFGPQoWg3oZ8wmLiDHwYbNt6LELrG8lQ + +0FwDQI5xq8JmIbhj5H2lvG4KYOlmRLwSOm/GCSWkEIpebGy7jpbHk3GOReQdhaLpWKbgA4peKZyAEpRKUcAkpZKRSnbYBQdklFB3vDgHhGu8MfZX2otkrr4gYjt+FoM5II8CqOUUStp3uWIVqnY2Y8H8IEhX3j+moSEgIAAiIG1KAAAiCAAPCD9SjWebLNSXUoACCIIAD8IP1JdZbUgup1ZNUoACcIL1JtShsoyY0mjWY1IjZqAD1mNZ/UjbJtSV + +Uv1JdSkehArUAAADocAgAPggTJv1JVSzUq1JVStJoABsIENLzZjWW1JdZNJqgD6ybUqbL6yjWTVKAAkiA1SHUnSaoAvWf1mDZqAMNljZE2TtnWpEAA1ktZbWR1ndZfWQNlDZo2eNmTZnUk1mzZV2UtkrZa2Y7o26NUttl7ZB2UdknZ52ZdkLZN2XdkPZT2S9nvZn2d9nQ5f2QDnw5wOYfHepRth9Him/qUMm5MQaU45ymRCrRFR4YOa1ntZnWVTm + +/ZsOYDkI502cjkLZqOatnrZbSptk7Z+2agCHZx2VbIE5dUldnE5TJqTnPZb2R9lfZP2TDn/ZcOUDnURqyeoGROzEaF5FRfIpoCcgzwDUiJuuaQlHA+T+DdBoyjbpCQXYjGIIq+cqPtnHHwBKN8B+mbMUooKGZOv3JUJ2Pv04d2amECKfGQ6YkEfKxnkmq+ZFPvXHIWyKf5n8JgWQfrBZy6eFmRZ66bFlbptoreE0pXfvsAx+eSVYIGMpDFzwzxCm + +k+TQ+ZSbwBXMeVsOCyOx3qkaxRHMq2FSi5Wbqlq2Tmgr63R4erAoY5UervGj5ZChtl5K6vsgrUhoplZ4s5FSnZ57qAeo574R6zmGn26Y+TPm26zvmbnih0TpKGPqACYk50wf4PcBGgzwCkGaJzubsYfALcjeb5WaSD8n6ZdkJRgjETwqdx2QtxrAT7wpPLRZHwLdrcFR5uPjHk0aceS5nDp7fLCnvBtcavrJJU6bwkORWeQCELprnJil55q6VFkx + +Zm6fFlZJeFkUE4cKWWgw+BUnih6ZZO/K/q/i1dCiaeQdzp3kdBC8T3lLxhYf3mVZ+UQHEtJEgMqa8mapgKYamk+RAB8FqpvyaCmc+W7qWOfSZXgByPumzm7S6+XhHG+W+YqbNMohXybqmcacF66mLEVMIAJhACAn4AzwDWB3QbALaBwYXQPoD2g9QGAabAmxkgmumRoUCQnGteo9DnCdkLvD6ZJ8MFDNOR/N4HDwHEGEEUJXMRHktefUcXEmRg0b + +ElV+nVqO5SxDMl5n6cdkSgUop6SWikM+ueaFkrpEWWunRZG6XFl/O1KWrFFB7inkliafCH5HhonEHZDyEe0RrDsYtIgGhlWlIGc7VJc8V3ksFnIqKk9BlUWv7oALQA9J0w9QCcBDAPWJqk6u2qRVnNJYLs+oFwgxTHDDFoxaPZO56mf9jecpVpSBTw6Wa2zeFBwEPAIg/hTkaHGHUfh7Eu48FcE9RkeT6HR5pOHEFNW1HlCn5aNDqT4eZx4UkUWK + +6edOmz2s6ew7zpXQZABYF2Rfnl5FeBYUVUpuFkEbJhK7KQWcsuUSbRjxtLAL7nOKmle4WSZwIKklZr6WVmKGA+Sbrq2OUqtrkh90XREUhz0fravRWvrSGfRgyd9EiBVQrhH3sm+eUCGFNMCYXMAZhRYVWFNhXYUOFiyadLCh4bs5bm5f8afkWJQKA0AwAq5pgAcAfDkgnbGZGCDhmQzqnenem2NjxwyO9rC3AdyFIocCnBT3AaJu5SHlFCmGNwVy + +hIur5IhmrUnhREUPB9OlAVPFtHm5lwF7OrPLSxHxWxop5zfpnmopAiZkWucFAJBhwAKadgDxAs5B0AAQA5EIDdYlQEYDYA+APQBHAwkEUWQly9smErFOzlu7PhtiK8AtO3wMXaGxO0bz5UF48fSBIEJEPkiPpNsc+l2x50dua3y+sTMUGpzTJgD6ASZFVCQopANUD1kkgAnjCwUcJwEtlbZXTAdlTAN2WMwvZfPj9lJua9Hcq65J4x/A6yEcqouj + +Odr6+pchRKYKF0puIGshoaWoVPorZe2X7JY5T2V9lueAfkROR+TG6Jp4peUAkp5wABAAQRwF0BlF8pffnOQDetnCSufEAwIGx0MpyyHkCUmsiHRnwPIQ8otdncanARtEg59gtdFIi9RYKZEUQpM+sCzPFrwUnlOG7pYgWTpUYakU+l6RX6Ui6DRIGXBlxAKGXhlkZdGWaAsZfGWJlyZRCWJhHNugDd+5UUekQhKkKvDIqt0BiX1qOHiiU8pt5iiR + +Ka1sdFHi+QEdAb1lXwI2VfpwHjwXoAGhabI1S0OXSYg5ClUpX9ZKlQznSFPqbIXL5DIezlKFTJSoXc5SyU+hqVyldoUaBGyVoG3lEgKMC4AtoEMAdAwkaQAtA1pnBhCAXQEtjgJmwMwAaxt/k4WoJGmYeR2QAee4x8QD8ngzBBL5DcnAVJkOGYuhonk3YehPMYZG2l9CWBYBhlDvHnBheZgWYJFwjB6XAmXpWkm/FyzsrEAlZwUGUhlYZRGVRlMZ + +XGUJlSZQQUYBu6Zzb7AqFrs7uiffpImeKx2CBXiI9eVtZ2QY8SprwOGMIfCYl3ed0UyUxyU7FAobICbRGgMAKMD8gExVL4NlVok2XYCZ+UtUrVzKr0WVh9iackJaayBxB9mQ/sfYal8hviCxVzQVDK12eDmFAEOAFmaWFx6VRAUJsu4cwnDRrxXCmJJ2Fd5kpFJVXwm+l2eYWrEV1VWRW1VlFQ1W0VzVSmWMVQrnunJC3kUylSJ10LJEkGsISWXv + +J+IDfJBByNkVmElWJawUNJcEtuSBo21TQHQR9EaE7wRHSea61QejvTUupZnmGIWeMhTDR0hmqoWWr5l8aMmc5EgfZWOVzlXyBuVy2B5VeVowD5V+VH8UzX54SEWE4XlYoTqYShehZDqGmQKLgCSAQwIhD6ARoC0BdAV4MRze+YlhQBwYWQM4DA6AVc4HOFT+DlbYwN0BCQ0ZZyhqX+at1XGgQkgauZB+JqOnV5dOXbmEWPkNCf2lOZ1XiM4xFhMp + +ZEcJ1kVwlp5boNT6g1BFeDUYFlDFDXkVdVVRU0VTVfRXbprkXeHuRRQbfmzuXVRUXph5QZmF6lo5pWWzUjpLSKDgeRCRAUaIlcVnTV9sX35HVC5ihi4A9wBhDEA5YOtX9qm1VTUyV8vmf5W5gBjwA91fdQPV2Jxoc4A10gZnXKlp4njDbvJN1R/iw4uwZgx+1oiGcX/+FxYAFXFm4XcGkOGVUTYPFP1VXF/V8BfCmA1yRXLF4VM6Qu5zp3HmnUzw + +GdTDX1V1FY1V0VLVaXklFyYbhKZlK0RjUDguyiiY5Z1BcpHN5WMMP65+jBU+mdFwqWp5sFFNdJWD5BUYSW01JroZ6ClbOiZ7z5aEYvkXaNJbzXbR/Nb9FGhTngeg61etQbVG1JtekBNA5tZbVQA1tfLXEligmoGXlatcfka1HlhJIvxMcCcCcgPQOabz1ipclgEJnKdPFWQoWjxy1qeIHnEbggBeBUao0/m3CYyQgq9UXKFpUJi2CBIDaWIVdpVG + +qQps+nYZxJ1cXfUA1R4kgW4VINagVg16BZVXQYAVjHAYQ8QMtj0AK1R0DmARwFAAn4mwDACQYADTumJZyYapmax+Seek+sfYMsihRGsF8AYsiIS3mXJeIVUmMWTBTFFdFSjuTUj1q8ZSY4NUeIeUjlx5V2U7QocJOURw05SDllNo5ZU2z4E5WeUDlXKp0zzlQmEuUWhK5dpVM565XpUBpa+TKZC1u5Xqzb5pTcOWNN1QFU0tNU5eeWm5fDdG56qi + +MbZXUwHAAORdAK7EmSTIb5WsXOAlwCCQ3JUttLaaKisGjr8CUFT8nV0f+VZnQVYFXBXkuH1XcXT6DpZY3Qpv1W8GulHwQ/WfFidaknJ1ZVW35EVrnO43vaXjT41+NATUE3KAITWE2I1wiUXXJhEkTE3V52INxgYwLdbjV7MrySWV7eFGOpHFl2Tcg3MFqDfk1vphTdTWjq1JrSYqmqAIpUWVwheZUaVbNUfHoRS+ZKqbldJcMn+6IzRvnGVIeqZV + +cmtLbyYMtLLYF5LNFuTeWT1RqvoAUA9AB0DxA6XMRxmB64JyBsgQwC2wcAQwGvaOFdtUFXOQdUYJikgmDIFHHCeDBSC4gxaccDsYrwLgnB5EZq6HJVM8dQlFxZjf6EQWe4TlUAsIYflWx1WFfY04Vk0U41pFQLRklBZoLU5Xgt3jb42jA/jdgCBNwTaE3hNBdWXlYB8JuUVLWlRTrFXQNyYiA9gf5Q3n9mcDUiBBaVkES2zxOTWJU/65YRd5aJRq + +kcAYQs5DAmIQByd+4l5P9lqlSVW1WPWsBsxcnoFwjbc20IArbSsl1t75SdUesKWjkaWxEUDxzyRi8AaQNO64Ha31py4U9V/mhDmElhqYBXQmfVmVZ63X1LxV80mKCBYG1A1T9SG34VYbRkUgt9YGC2eNMbVC0JtMLXC0ptxRW1XMVk5LCWN5ZVndCtBtQcsijVvFMP6YeK7VNV5NdZYbqUtvbTMGK+BDeLBK1DNaSWK1sEchFaVC+ZZ5kNsqg67n + +xP0QyVXxozR65ytCrUq1GAKrRhBqtGrVq06tXDYhFodytYs2q1yzTE42VMrQXD3ApAMoDOAQwFAD4AC4H5VGBUAAuBQA5KUIChWRgLH5SRx1edXQ4b+N6r7Cb5F7lQ0z5MWk4MERnobmZ7MQHURB3Mf8lpVpjRfVDO0Rd62xFEziXW2Nnmb82elnCRy7Xtr9X8Xv1bjVG2PtkLXG3QtSbfC0MViLR3HtVQnpm09VVRe4L0smhkFG1BzFLQWmZCTR + +B1kttbYdX1tBcBhD6AmgLaCOweEO21Qdx1DB1YN3Bf21a15QEl0pdaXUjpqZCLqfJDwPcCu1dwvYLi3uJoiGjpqdg4Bp1rteHgQmH1UXcR6pVO7TcXgFLzboqmRjpeZGwFNjd81ntgJkG08JV7S/WcehFRG33tLnRC2xt8bYm2wtybQi3txTFfir7AuzWxXZl07Ak0XFddZQWFlp9n2z2Q/9jZkxdL6WTUUt3baPU5dhIXJXcNIOfEKstq5dSU4d + +NnnzUXx1DUb7OOQKJx3cdvHfx2Cd5wMJ2idRoOJ10wknb9rhpz3RK3MdUrZslrNEADiAJ2PAOHDrApXfH73pQxGuC3ykUQfAZ8lwAEmHMz1UCno+yMmShWZ9Fg6RUY5yjzS6SJPY3XBBZaDjqGd+7eY0oVc+mwysJ7CWOm2dTHg43BtgvWN4/FDneVWCJCWUQXJhB1Wz69xHPquBjiYshlkndSuhW1pNGMl/gyOV3bWUSVpJmcC9gKurB3D5m8RI + +ACFEhe0mpCFvUIWSFVuMFC7wHwHRmhQ9GB96YdXNRKrlA8hdy0GVfLcoX/dJlQKXlANvZZUil1las3sdQKLOQnAthcQD1AhgVI1ZY7bligtwJIAg6U9eDPCABBXHIk3dwQ/lT0jhhxXIqYeyKgz19MTPVJU4w/bJSAYsYdUhXOZg3a5kiofPY7mWd7xdZ3FVovd6XTddPq40ruG3cjXtV83qi19xYIEP43Qg4GF3YtvAMbpq9+0eGiIEORKiHtFV + +baWHiV2rhtV3dRTQSXNlT6IADoIOpVdZmlYOX79h/cf3tN8TFPBFp2MNcqk8rvbV0c1b0f026VnLazk+9ihX71GVAfYK1B9EgAf2MtP8fDHh9/8Sj0YYcAPcD4AygE5WJ9wVaZBWMY8IXwBoXwjxxvApkKI6esw4V5AZx3Aq5D7GcEudyyc27XSIYJhjdP4X2tfY5n19Nhu81oVzpSN2nt99ee2P1SKd8WLON7bN055rnLuAdAzAAtgdAcGIGWEA + +y2PUCSA+wJUD1AnIABAdAGEMyo0gf4DqFHAMcGyAYQRoDHBmAxANjBNAAEMtiSAuAENTrdhdb51ftzAAyml1WZbE1XQPwPckYyaJjvzkiTRb5zxxcWm0Ft1kHfr1ZdW/VS3m6kzUeWdl1QPEJQch7NuzVAT1MyBDAVUEnALAfIMP1W9Pg+U1+DAQ+uxBDGECEP6EUAOEPWgQgFEMsALqZ014a3TbRgFlj/VSUnx6AN714d9JXKqf9tDaoU85Q5b4 + +NjliQwewwcqQ2EMRDf6NkMxDTHb/HADYpZH3lAOeiLTxAA5EJYwDH5ZxBydztbBUiyy/XV1UxewmSBDgZ9O6ktd4aIkBQVmhg82ok8FdcW0J59Zz0fGHDNAUJ5MAf62JFHfT5ld9pVRL3Atc3SUDcDvAw+gCDkGEIMiDYgxINSDMg6GK4A8g3ACKDyg6oPqDmg9oO6D+g950D9IIcmHMAh6WYNgNfVdSKcUhDsWkSyZIKroDgk/Ve669Evu4P+En + +gyb0bxtWfJUitTJmK1H9qlcSP0tZ/W919Na5S/1e9XLRUM8tqoIZU1DgfdZZmVFI6SPn93Q0AMJpyPf0P/g9wMl34AHCpgBwYK7F0BsgMAGwALghALaDogPQKxUVhgVScmPGaMrIr3C6CbCAoDayNdxpSLQfQJmZBLsuGOtSVdlnN2Pbs81/cALN9WVxOZnlUZlo3YwPjdF7SwPP14vTN2p1lVQ8N8Dzw68OiD4g5IPSDsg8Ci/D/wyoNqDJAMCM + +6Deg++2pla7lCP+dMTeXW9VCKtSIFW+KClXT9EVTfKqE5wuymt1JNe3Vxdg4X0HLk1HDm7GpIRkPVFS2XfiVD5E9XMEFwpABWMUAVY2MOnJUOCqQASqjomgoDI4pPGvmh8J5BGjXAooobtL1XZmfcbrUZ3/kto1HU31J7cnld9RVZcNx1dnT325BffSKmAJPA76OCDwgwGMfDwY98NhjSgxGNAj5wFoMxjYI/nUftkTXums+aNbzbMpx2IsNrwtF + +nXWFtpsTRaZS2DkLYuDRY24Mb9w9XiMPd1WU930dDEcIVQTrNRh0kNWHXa6fdZ8d934deTIR38t3/apBCjI5KKPijko9KOyj8owdpKjCpnUMIdLNXBGh9V5Ss0gDAo+gC2gm/hk7xAktAOSkARwHTAmWybgBCOwA5EMBY9erSgknJrvQEHS23EPDI/ieDIaXsYnkIhmsU4EVp3kJgdY15EDodZQPut/5NElHtJcYqNsJrfU6N2NLo8wPIFU3R6O9 + +9C9nFGhjCg+eOAjUY1eMgjsYwYNptHkVAAwjoDT5FphqY9fpZYYivaTHd20X1pIDqUhaEw4BKMTVf6xYxomrFl1karmpbIJyDKAJgfWw1jklZTXb9DY+Yn0TgCbgDxTiU+k4djuwvSwVZ7BUOB0xtLP8Co+efTCDyTNdhqgo+gSQOBIgISfGJEDrxr6EaT7XqJhMJdo+hWENy4+uNC9E3V8XujbAzcPhtnA0phnjAI5GMaD9kzeNxjSNZCN7pZcl + +Xmj9HFKhqbIU/XP3JNCaJibnk23gKmATEU8BO/ukxWBP1j2Dbv2tJIOV0mzlxDZSXHxHLZhEUN20mhOOOmE1zkSAjE/QDMTrE+xOcTK7NxO8T/E1w23T0xn7ZWVfI2x1NjQKMtiyW+gPsAdAIfh2NGtPiiSBwgkRqUmoe7MSxgBqW5EV6WQ8WlZC8CmUvqR5IwdeaUkDeGkY3kDVo43yvNRw430wFieX1OYV5w0wN/NzDoC1jTt7XcOQAbZftADk + +V4JBhWQsGLDr1A4wJUCrmhAFl4NEA5DACzkmAKAJXgMgLxC2gRgEICQYGEEIDVAIBoYngjhg5t25mohKtOK9dqu2xIgqvQFPomTXmk3rgiIPqRWQVZaJVr9Z0TiNSi50xo7FNV0xIANNFTf4PpCgQy0OhDUAPUBWoXQyyqM13YlM3+zTQ9BxHsKQyHNhz8YBHOP9c5aZALlu9ieSFDe5CKolDT0xIDlDqE5UMc5H0zpZ7l5E+UB+zCQ4HNJDwc2k + +PJzjEKnO8NiPaKWsRKPRLQnAHQAuCjAiEFMrxdE7VZBxAz1RTWgEMiTxwjj9dtsABoS8MTxTBweZBX7wODCcaPNBkd117D5HgcPWGFjahVOlw3bfUGTVnRzM2dA02L2jTno9uPdFJsFQb7AQsyLP3AYs+0CSz0s7LOuc8s4rPKzqsxsYazWszrN6zC0z51Gz3kD+0STmHli3bT4mm714tQ2tc4JSSDdWUoN13Wg0FNns9E5rxslSU3qFnI1SNMt2 + +CwAMX9L0cUOPT2Ha/0r5P3TUrVDzJT/3sjwrTyYkjOC4APxpuhZbkwz5QJ2D7ALQFtoSjlQDHBDATQAYhmmK7EaBGgnII8WHVKo+6aokuIIoTaGL+oiMTzcaGZB24dcsV5BqCVfXZmj7oS6080ak+1OzjD8POOmdhMr62OjDA4ZPeSwvZN1XD3MxfMWTO4wLO3zws6LO4A4s8/OOAr8/WDvzSs7OQqzUAGrM/z2s7rMtA+s3ePxjIiZ3EEo4ib0V + +eTUmph44JRQ0W3zz/FW4IsUNGGTxYjijiWNzVZY+gDLYRcucA9AbEzkApT0HagtVZkETtUo9eS9jCFLOQ9j3umQRJCDdRr4UEG+B10Fi7iIKi80VqLweROPrhrUzONbzBi1lVetxwweEHzZi0fNGTnM0nXONKdZfNxI184LNOLD8y4tPzwfi/OhiXi5/N+L385rOBL/805NANES/pPy96NfCNJQwJOg7wg9ReXiad0CzRab8lIDOHwLLs4BFuzIE + +7WNlLXBY92YLFE0h0vdMEdBN29FJUQvstJC89MHVr05UPvT/vZ9PoA7C5wswA3C7wv8LowIIvCLoi3R1ArcE4ws6F6tSwtzFhGWwBNAA5H0DQYuoUaD4A1QEcAcAV4C0CQCb+KSykxLgdJH0YLGLYLieU8A7OleeDJ5DBQ/qLWl39o8MEXKTfycAEh1gy311riWkz1MCxuk/z1vFXpauPA11i3MvsDXo5ZPbLPi1/Pqz+y3/PBLACxCO0pES39K7 + +d3VdrFnpOZan6jwh04B0FjDy32zVqjwPQKvLrg7F1RT47fOaAG8QBQC2ghgeI1I6JSx4NpTXgy5pZTvq/6sLggax2MwSWSMSA3ch8BP7YzQBIDhYJcNo1PmQyMvVNo+TU0ZItTTzRz3SrgoLKsLjx7RhVul7M9Msnz0sdcO2LrcVqsKz3i74v+L+q0EshLHbam3HLnNjwBjtjMl1Vot4aKvCoD2wLNSBFkjpPGrUW05W0ktuTWS2ZduI6Gv4jNWZ + +VLXTwhWDNENUhe706V3NeQ1Qr2CkyMEdgtWXM3xrIKSvkrQwJSvUrtK/SuMrRwMyse2QrZ0l9rLcz0NQzEfawusK8CfoADk9QCuykTA8/s1rguIKsiPQADtxWfp2M0GbBQjTq/pXCVgz/44DEIMQyXJbtFONUwBjdTNkDJjWfWbzxa9vPc9VjTCn0D/UwG3VrnfafPd9Zk1uN2LV884CIQwovEBXgowJyBXgzgJUBCAMcJsAdAzgJwtDA3sDsjLY + +owDBiSAHQB0CXA8tK4T3AvIR0C4A1QFABv8Bs85Mr20kj+0bw1jGrrQNGsJxTAdNFnCRgb+lBksfLp05v1Lr4ExUs01cQ9M1xzyQ60NQAHQOQC2w4QPU0xzNc89RBzCc3ZsObmZM5vmOeQ4uW7kPTUUN5zxC0hOkL+lR/07lSqhXNPr6ANXONDtc80OebIc95tObzc8KU0TrHR+tErBAhYXPAnIMtgtAJs3s0IuUrkkAOkRCSvA2CPHGFCRiqJNv + +X5IYUBo3cCi8/c0rz2w4Wu4bsQQzNAsPPdY0TLpG1WsWLQ0/80Z5m4/8G0biy/RuMbzG6xvsbnG9xu8bPQPxs7d9YEJsibYmxJuS0UmzJtybCm0auGzg/cxU8AJMSP1mzIuMcpjw0WrcucssDcksTxG0Vn5ZNM6wguktSC+S1dtZmxdO5dPs0SN0LlI/gsSWUc8y1kj8Ew9PgrYW/SNv9jI771RbIaeM37ltC3S1cj1E/w3Xl/I5+voA9QMoCS0d + +gXAAdAbID1YkgzgPoAhWEftUAtA+kxtgSL2diEFmQBbVZCIkpwMwGZ9aOrXTcsgMPvY3Q6i5GaN25o1mMSr0QV1vbhhi2Ms+tDowVUr6x8xRu1rNi+ZMNrO49Nsiis22xscbXGzxt8bAmw0TrbdMKJvibmwJJs9A0m6Jt7bim6EuLTJqz2uOc5qymNBdLMed1WMs1OW2Ym5ZYg1Gb99p6uAbMUwXDnAMADMgrscAGk4Zd7s4WHfL/sb8vyZKPb7v + ++7gezCX1L2dogRo4efAk0ncNW3CAKGrwMFpbIVob0vBQv5pOMDLdM9lopmIy9pN0DA22zOFVFw6quUbda/Lv/Flk0rtMbLG6rsLbGu8tta7rnDrt67W2ztsm78m2budr94zL0RLN/rCMK9r49ND0iABFtEN5tar+KeFrbJOLu7WriZugTX217M796rrg2odwK7EMqBiHQx1p2m64QshbEO8zk2OKE5Q3kL6E8etwrEgdju47xAPjuE7gsfcAk7ZO + +zHAU7+kxM0H7lE+h14rkM8wvStmOxACIQkGPoBAMPAGQDMAUfguSbAInZoArsowBoNSdZMTJ0twi8LIrozKyOi5tL6I8qUeU8YgW25GikxzEhFQdapNSr1owwldTMSUYtriLfZLvzy0u2uOy76qzzMcDENV3vCbuu5tsG7220bu7bA+wdvKbwrr54BdlqxmFCyfAsxRfi9aldsN195s6oVtqrm8unRHu8v5er3u0CgDkHABAeKtodsHufLqU5g3f + +bEe5UtZTehwYfxARh/HuweBzVn2nAw6yMRMoQKTVu6SO5LfI19N0KQfGj/iaj5BJeayT3PLnW7u37D+G51OdeZe/vNLjle1LvkbbBwzJ17NGwrtXz3e/weG7xu7JsiHRy5+34qPAI+Fnbk+3FIrEj0MWEKH18nA0/AnCDoQr7bFmvtfLG+2gvez2+4759r+DWusgrqEeDukNkO6fG0lMOwb537X/fCtgHEB1AcwHcB/gAIHX6sgeoHsPakJgzr67 + +yPAHGOzlsSAdgFeCIIowN5YozJkOVs5xA7B3AEoPHOcLl2kWhU6NW+pRFRGiU80cz9Lg+phujm2G9ztFrNB/aWMzNA3vMszjhpWtV7rBzXvsHobZwearO48oCaAzgJyDBLmgAuCS0xALaCcbvgIPi24P2g0RdAhhfQAIJ+gNsn3ANMEMBXgWbkaD3AcGPUDwmeRw+M9rXkTQgT7GNeCAu9hxeAvWzMDVymndUsIcDqSrdB3mzr1bekYh7GDT23mb + ++qW0f1D8Qwlvubdc8ltpD5SHACMw44C5sNDXZTZv1zN9AYCynC6KnMn75eBnNdNgWznPvdpQ4HLQ7xc4etVDcOzSm/7B5a5vintUB5vBDIczKdyndS4Adh9763ROgHEYKMAWFYPWE32H0kZspydaYt4pyKZx22z12YUBcm2CR7rc0bDy87BUdba89yhF7XdgRtvNu80N2/HzBwNYJ1XMxwf1rDe+CeQn0JxCdwnCJ0ifygmAKiehiGJ1eBYnBgLi + +f4nhJ/sDEnpJ+SdKb3a8dtLR4++ctpjnLCcxltN28xxYzjq2WXXMB3s9tqH7q+9sLrHs80flLwp5ZtYL/2yju4Ly5wwsELoK2ft9HF+1DtkLaE6XP37YzX1SWnSO6K3rnPI0wsErIBxsfoAFAIhBHAlQJsBDAqMdseS08QH4tQAowDwA5ulQF2cXeNOw4fM76o9U4mQARHW7+RrcLfKRUKyMjaq2/h86EaLUZvzvaL4Re8f0zB7YGFyrIqCYtZnN + +kSNu5nIJ/mdOdlkxCdQnMJ6WeInMcMieVncaGieucNZ3Wc4nV4Hif4ABJ0ScknZJ6IcdnBR/5Xdnx6RIlBdIQYDCWttgxrAhcC+wwUWQo60dPqupNTNVqpawTksQAcGBhC7g9wDABsgfQGtW7+d473mh7c5z8sQTeXcHZAoKl2pcaXWlx2N/mkIHn20YMWm0vyNo4n8DDgMF/Sc3H35nntrhW7WEc9de7ZEcioou0zMnDo6Uqsrj1e5e1qrhF/Xv + +EXhZ2Rcln8J5RfUXVZzsgMX2Jw2esXTZy2ecXFJyPs9r3cXxfsVYIIiAb8SxE7s1BI5+8lnVwOG6tAT86/yd1jm+xlOQTOK1RMwTLVwAcbnPR2CvbnAzZfuDHJp5pYYTh5x653nD50+cvnkgG+cfnX5z+d/nmLIjt3Rh+3vsXn+KwI2ErA7UChO4mwPUBX5QgJUAWAzANPXnABAABAnAXQH+C5Jgk3H7umLl6JPjw8IOZDRaoZ4GxZGpfcjZG9oq + +7p0UzvMcmdsMpawweCgTB2cMAniR0CfJHcu6kcFnV86lf1nzF42fsXrZ1xf5HuZmImSHnk0F02C5VpIh11+NXA2TiVcrvb1HAJbNWOxSl/QAnA+gNgCG1IQMYeNHph4KfmHRl5HtZT5N5TfU3JXSVsnJ7GVkjLIsVB+R+HdXdPHSY+8DcvvXW0cj4BJuaxj4FriZ21O3FHxzKt0HMR5mfA3CR8NuujJk5Ff2dRF9eGVVMN0xcsXbF82ccXbZ+buA + +LR2wUeXX5q4Ot8UjwNXRt0Ch1Rb3bmhL2DNuyBOFOyX7dTOf6XZh41eXTIp0+hgznR8+vUj268/27ryE/1fX7b04yWsjEgFtc7XkPftcmAR1yddnXF16DMvrGW2ju0TfQ6AeYAQwIQCVAtoJUDnAB4qWMOHqJIkBvknFZEYXATKGceAw0mJuA4gnKdcy+q3kCxgWxeIcGqgERA88dWlxjW8fC7A6dQPpnTfSrcC9lGyqsRXtexDcTbaR4suA6McH + +kv5b8QJBjEA9wGyD7AiEIRAUAnILiluTkAEMCQY9AMQALBduPsjVAgGhl7PALQOI2gaSN5SfHblecUcY1Sih5TgkWm9iDmtzt9SItslwB/ke3NAXJcfbZ0wZfh7TNwHdVz1p0qeJb8c/afSnVBjWCsgBgKnPB3cW7A8BzEp0luIPN9Mg/MAqD/oCanlIf5tZzy5cFvg0oWzueFzDIwNeRb/0fDvHnC15g+Kn2D7aeSneD2UgEPRD+lsQzrp2sfQz + +N5/uScgK7BwCzkRoGl6xrCWlz7whRaCshXReDMCTDzxwJ4WzDZwRFStbmw+1vPbCFSPfh1O831vEbFe/8dq3qahreONWt+Ntv1ut5ZPL3q95FYb3W9zvd73B92yBH3EACfdn3F98BBwA193sB0wd9w/duoOV1CURLr5dbdrTkuDiiqkg56dwL76CbxChsRN9iXgPvty0db7i5xyNrngO5HOpCIO9yN3TW6whMe9XuuFtDNvLeae1DsWyIV4L4rS6 + +eZbJ+e3NZTMAPoD0AkGAEh0wlQPQD5bTQCuzOAQi30AwARgLaAOB/5/q0nJpwK3DPVho/3rgXzbEOBJAzaZbT3Csvg62JVSF1osgFQu+Ed4bCtx62YXZa4PYS7qtyweg3s98Cfa30V7Y87j9j5UBr3Tj9ve73Bcm48ePXj+fdGAl934833gT/fc9Aj96E9plES3HvJjWbRXUY1L+oETmSyUsJUVXwYPbMuXAaMA+2x6iVode7/RRAB/gs5MQD0A6 + +gPc+03nbWk8M3ftz9uWHoB1i84veLxXGc3DS67kUgyix/n49o4/+VZhcQOgmIZJzPsIP9j1Z5fk93l7LfUH6FyXuHtWF5PehX09+Fdujpk+fPXPFVXY9QAK9/c+OPm908+uPh96GLvPPj1fc/PQT/88hP7Z8jc8AcKqbMlHc1AZmeQCS1tbjEwU00Fpi6j5Oe1X05/Vdh76C+PUrrySotf/7jHXk9cBXr8fuUh7NVueITND+kxR30K6aewroxxIG + +tP7T50/dPvT/0+DPwz6M/YrdNa1cNPOd1lvunwjySBkAQz6jGQYPG4QDVAhAIhAcA5plAAKgaB6ysydBx+Gx1RpIKJgSKUG9RilW48AwU7AhM2zFKTX11Qe/X+PkrdYXAoEDdT3ZG+rfGTlj3Pd5nsr+imucmr58++P/j7fd/PALwa/P3BR7q027YLzEtV1btLvCSy0/U720iKJLeQAdK/Tyeuzmh90EV3VYeUDPAagKAmEAK7C0AEv+/qZvpP85 + +9+mFRoB/e9lIjgM++xr5xj3CrIjU8u1nHnd22+hUGOOQHZrkt0EfS3oRwK/9vtB9Eeivpw6O9Db5jxO8i9U71FeQ3MV1fPzvXz0u+/PwT0/e5Xx23KWRP52yP4hcHjN/dQ0UIEOYIOgeX+UOvx03VcmHpSxA+uvfbb9uAJHR2SEbrAb2y09XdIwMcvTB64NcjHcd+gC5vpAPm88Ahb84DFvpb+W+QYlbweInnIdwj1vrgj9lsbX5QOcBsgRoABAY + +Qu11Zf4JVyZDIpxf5mcczzzUcc0a6SL4huKK/wHnuHMzl7o3obtLFTMvH1pcPe7P3W58e9bRG580VrPzYCcXP4N9O/4fNz1fNXgz5ScBGATQD7w9APjWoPhl8QCuwJekGBmWQAJwMwAN6kgAOSS08ILuBwAJgQ+jKUfQHxPkfYTz2vbO/a+YM238jQwI9wTuxr0/jQvispeQE5zUmILevVx8hrH74ZcWb1LVZuxz8D7ZspboQGyDoPZIfFtwPODw + +g+JzaQ7JvMA837kM6n+Q3qdeBuc1Q/n7vV7ucRb25Yw8WnLD9HNsPyp1KfMgG31t+6fqx1efrHhn5zaDFpAABAwAPACC935+zao6LtD0DCC/JnCPZ8QgQnMfayJeSHvUbgdzdo/xnuj7sN19HU8hVpnRj+F+szpj2c/jvMywC2xfC91DeLLiX10DJfqX+I0Zf9AFl85fRoHl+hihX8V+lf5X5V/bNsm5UC1fzYWu8UfBR25PNfcI72eS4ZIBcnDE + +R3fUV7eURrxAvMzs1OdDfdN9x+jfkD+N/eDS58jvnnPr0r9nnuT2nP3T3V8G/HftD8afR3JcyyNULyqpd8FPqOyx1NP+hSj035Mo1eCEAoyvEBGAy2EcDpA0AicCG1RgM4DVv9tUZBBqQ8GU6PAB8D5zr14aGFCo+N/UvAAFPbOs+IXfO1s+WjaF8XsHP2VWLsJsOF6c/Znli8NPSvOahqsLLDRET8k/aX+T+U/uX/l8QAdPypkM/J20z/VfrP3V + ++AvCYxEt8lBV1rHo3ObQYxeQHguo8N5TXcFORQ7GFbPsfnt3k1ZLpN5KxAo2AOxPxAMrABCkswa4uty/vH3B0AJU/zCCz/D6798Iu1UwsqNvrKQ6TKdKMqjiEOtauRb8U2A+OO8vm7Xo2I/6k/osBXpe2h8hX/1VMvY/NazF94f+PwR+E/SXyl/F/9AJl9FWlT8afjshK/icASvmV8a/lV8Wfmz96vkC8e1h4t3Jj2dvJiyw7cIk0mTr38wzHA0D + +/jX1fgCk8bup9sl/q0csno9E/XoCs03h1duklr8g3qU8BkpJ9KlBG9Y7sb8IADb9gEvb89gE78XfvoA3fh78vfosdfXgCtHvpec1rtedXvgitNgOdceAHAAaYH0B6gHABRgCZ84MCcAOAJIBqVgsllRhM8brn8AXgGkgzuAiQLQqD9pntFpW2CtR/2p9dKEn29E/imcojoT4h3iO9xXmO8sPjj8xttRsv/vF9FlmACIAYz9oATV8G/hz8GvsdtfT + +qC9Auh39uwC04CAtC8OUvUE/7pTwKRN6wD3sS1XtnOt3tmP94XBi8KAL/wYALaANQk94dLkPs9LgKd7uozcFfuGtQDhkDdwFkCcgbGt6MH2ISeliRJxIf9PgESBocMYDmYoy9mtnPAc1vB9mpoh8uukmcrAX9dB3kc9y9nEdMfpn98LrMtP/jY85XjuNPAdX8Kvj4D6/uz8zbsasu/DwAX3ia8MahSJp5mGxOviL9m6IbhsYI1NkXjWVsRsN9F/s + +S8Mnk1c/ll0d99oHc+1lqcurjQCd1p70JPvusGAdJ8aGswCMzJIDpAfgBZAfIDFAcoDVAcJFM7ub8kekI8xASbB9gMwA6YLOR6MOoDtDickynLlZB2MGpP8PtYNSmPBF4PpJ1NBGw1wB1F0bOSBpXIJVa+H0CB7jTMcNkF9twmPc0fouMIvmN03/jLsP/lc84vjMCr5pBgD5M4BKAAXoY4H+B9gH4t9AHAAFwMQAByJoAjgI9Z/AfADjto6Mzli+ + +N37jckViJVYvxqk1uvlbgOMpEYarhx8nXucDZzkQDMnhN9RTtM0MgJkJkhIt8sHiaCmaFkI/Njt8AttnN9vgacC5mUM6Hgb9TTgeco3kedjKNp9WHmKcuypaDBhCrU9Ps99IQfl0JAC0BCAJ8ArwEMAhAGPskQX9gTEEGxR4FyxPAqEEoqpZAFDD8kX9P2JeVlp0YfrGcYKpekdhqfVqQaPdDHmF96QRj9Ivuc8pXlY9XAdMDZ3ve0uQTyD9AHyC + +BQecAhQSKCxQRKC4AU38e1gBs5QYVcAKi2xg0HgD61HDZaRA6p5MKP58Acgtbujx9iAYaDsnsr8Nfhg9anjk96np1cqQiU8XgWU8TvhU9mRpQsBWib9K5rwU6nqDsM3hb9BGtKEFzF0BlAHidnAB0BMABQB8AJFBYrEIA/+Ac03UCysffs5AF4GSApKhFAxiCT0oFnV1YxFkgivLn5nVNqNu3uQcxVnp1Bdj9cBgfcVI6gDd/yDHUMPiDcmQUkcs + +1FMDHOu4CGiJyCFwNyCKALyD+QYKDhQaKDxQZKCVgYdslpj2tOquYNbdqED4XjUc0XM9s59rC9tpippG9JP0gYDOCO6lv8MXk+Dw+KQB9wPP88gd7dCgelN/bkqIAEsJC/wKJCuQGMMKphaEnakGZkCFyx3asFAXep4xO3HsBuXr/4D6pcFj6j5cN5sF9L6ihDU/uj8/jlWCsIWDccIayC3AeyDFloRDiIaRC2wR2DKId2DG/uEse1qjUaTsgCKg + +qcog1MiMFDva0YgXxQ0xJpFuTkkDeTqvtCXu+9LgZ+8MFvx9Xum1cRQpuDA3od8xPhHc+rvQCqGkesvgUeCIADwBbwfeDHwc+DXwWyB3weJ0rIKm8hSvw9GnleCAEnTAsTjABagPoA2QNUAAIHBgg/DwBVsPyDcAPEAmgKYNxnkJMhwon4DSKxQZEi3Aj+O7VpnnQVG7MkhyrmOMTRhs84/jGZtnohD9HvX1Art8chugKB0/hhCzHlO4awbh9HIf + +WD/So2CiIc2DWweRDOwVRCewb5DjthZ0efh5MBLsxDJcOxwrts4NagkFpfxFz4kXtsV+IakDFLhP9ygGyAFwE0BNALuBNWtPQJIc695wQaCjzFlNIYdDDYYZEs/TsdUAcNFB/UC2wsVL9DUHIGhq5ItCkUBtFcHFf8C9qZCkfvf8dwo/9hgbEcGQc6M7IdF8HIdY88Ic5CCIU2CSIS2CyIe2CKIV2DqIUPswlki0IliA03oYFCq6pZAblhVYkmuX + +hTjnA1GrG+FSGPxDJIQ1crgTJDFwaQDBASf1tYUftQ7tuDw7q8DQ3vlCb9pG9ZPhABWoUIB2oZ1Duob1C4vAND9gENCRofVDd9ritAwU98RAS99QwegAmgLDoOAI79EIOLCb3vYkpKsqU3gFSgTjMc0NSpZk+zMoZw2Dcw96ptEdAVMQMxKJgfPrqQ/PoPdaZkhCetsrd0Pg4DMPqdDNbudD2YZL0roSUAeAEaA/wP08ugJBhsAJsBJaNICegMoB + +LVGyA4MH+BKgDv4aIWIcIltE1qPqa8sNGwgeKn9C7tnC9pNGeRi0kydh/iA8vbojD9QdcD+Pkt95NnN8FTr6CV4Zt9tvkPBdTvaDemmHdaRrlC9wVuVA0kb8jwTFtf+j6DpmlEBN4UIDVrujsQwSZdygDABEIBAN5Br3MxhoVgaBAHglkFGZMGO7VIxO6lhMIdFEmjGcl5gWDV5n0C5br119nqmcvjuPdmZgXCX/u30ovmdDLnmXDbhhNNK4dXDa + +4fXDG4c3DW4S0B24Z3Du4cLCLdmsCUWgPD37sNp2OBgDhqoTCuIeLZOCB8Aq3CcDBvmcCZfiN8koWN8FzlrDTweuDzwXcDTzvQsNfo8Ctwb0cdfuJ9nQfr9w3rDtzvtU8L4WuDlwRuCVrkAdgwQZ8fYSVC2AC4R8AAqBZyLxBrCicBSANxEKAF0BYYeXctaABcYNHkhDjm4dlqPpR5nsxxdRrBU1GrLp8+jBCdOhYCE/jtDkfkKABuvtCm+gKB0I + +YXDMIU4D3/mzC6wRzCGwVgia4c4A64Q3Cm4eI0CEUQiu4U9DRYT2sM2sECpDpXVETPeYpPHUcOUkUCGEW4ISDLWo69CDDPdiHC+RLUBEIP4hRmBXlX3mME5wQvDNYSjDQDtUjakcQB6kVjDjQnOI3UvlkxJqGYH+k5BG7F+UXEVaJJJlp1OokfVuotTC7/kMty/CZ0rIRWCbIYyDQkcyDwkTK82QVEjIAFXCYkXEi8EYki24R3CUkT5C0kcdsN3K + +38LBhxUSkXkQ5YXIRm3uPCmgZxVgSJL9HXtL8EoevtmkaS8SAYtdyAWSUZeMU9xEbQCeau8CCobfsioVhNNEdojdEfojbQIYjjEaYicwPwCD9uCC25lb8sph0AYAPEBZQp+dRLLOQ4AAOQTCpQB6AC0AcXi38xoddcmOGHCQcEEQHhASg4LqBDdRtjgrkvGJcYZBt4Lu4J1oW6FNoV4iSwU5k9ofAjEgodCTnsdCsfmsjsIWeJcIeXC72tEicEfE + +j8EUcjiEakijBgUckxlu8QgVat+4naQ65NJc/oY9AHBok0EPHP4Oim9s7YqDDeguDCJABflJANl9agOHYGkQUD1YclC3Xt+9hHtajbUfajukeQhPKFWkh5mDh7krjBsZiMjmUbylWipi0KYauE+Xjf9iwb5cIjjAjhliK8GYWK8kEcqtJXiXC0EREjpUXzMSodgjYkbgiEkS3DFUScipQb2DjtqtskAfKCLlkPo8kHco4njmDx4Ue4mgQVZVYfPC + +uEfL8eEYr9/lvrD0oczUdYZlDRPhIjD4W8DTvkyEZPswDMUdijJaLijZyPijCUUzR5WqSj6AOSj5rieCFaktd3YSoiBHmojs3lCCIyvsA2APcAWgD/wxhn78a0roClOvmEoqgGhlSj4F7SHOIUTMjJebnA5RMGeRblN9dfPkMQsNgF8KBnot5kQ31/EQgjn/m31U0Sgj00SyD0EeNNuDl7gi7vuhlAJyAOgFQYY4MKC8Tn0BiABoBYWsqigFjOUJ + +YZWi+fjK4a6Myg7kQn5WTrlk1hliZjlC2jdQT7c20cv9TeoSMrvuvCOAIDoDtDbUgdqkJl4UxigdFvDM5gUMHQTSMPuuU9j4cM0qnmyNAnBxjmMYdpb4aoivYQ/DPLMOAKAEMBmAABBdwBQjopjj1Z5u4EbMgIIsdEksiYZJw2BIJQZXGLJQEW1t4fkWDQCrGi9nkK9DhqF8PmssjcLvHUs/qNtWBrn9QTvn9XOEIAYMUMA4MQhjcAEhiFwChi0M + +X4BIsKciVUbmZEQThjBwfPBm6nfouvo4J+wKlIEMqGYcaokD1Dmol1+hwiLgYUiNYd8jeEX9slEQIi2MUqYzwYU9NfoCjtfsCiNytIipPgw9g0hd9V0Yoj1fsojfbGsk74bndmnqAd7gLuBOJsKChBjgBLVGwBVaClxsAPoBJAGM9xFpoCmODAQFkPScPxAbR5FlFVUcMY0Ksk2lJiB0CyErBDe3ryjLMeZDjOlfUh3kEiU0WFdQMZO8M0ZsinId + +siDsF5ifMYhjkMXTQgsRhjQsUAtP+gOC2/h9DNUbSxb5DUd9URylwoePCwSIV5wOjJdZ4aP8KkdktLUX0gegC0A+gB0Ao+OJC+sEUVHUS68Fwa0jhHvQAocTDi4ccpDfEiFB9Yn7gm8kGiDjstjbcBjo1sacU2usZCZkUh9c4f11FkUFdxlqMDbIeKj7IZKiLoZEiK4QdRrsfBjbsQFj7sehiQsSWjnoQUc6LpcjWvp28wcF2lOvkk1RfmdxVFDF + +C0sUKkdQZli9QTRiUcfxYuAn8jCGiJ9HQRCth0fuDCoX90xjl1iesbKNlsP1jBikNishqNjxsd6D4eheCIQeojH4RIA8rF0Ai3NUBKgDk4ugF08+OmSBSOEaAMkbbVxoeW4k+JPBzJLeQYQCPC9MfCRPApbRFiK5BVhpyjY/tyiLRomddFvLdrMXON6YahCH4EdDgkSdCMgtn9awedjLoTKjOcVLNvMdzi/MXdjUMfzjMMRbdczHL1nxtu52/h9j + +m2L+F1JN+NHBL0Dx4YOBiYWdhjUav13lle8eipUjADEMBlsMnABOstgMogjCqMVJCw1rMFhHuPjJ8cwBp8SeiVkOVs6Msq4uWA4ivgKZBlFtbRCQAmJI8atClqJTDHjtTjvEbTCBUXSDy1pWDVkcXDTseBjM0RgioMcgIucb5j/MYFja8U9j68TwB0Hk3i9uuJof4UDB6EcycxLr/dx4etZDooZtgcSi8MsR8imjl8iLDj8i10WQCe0W7D03v2id + +cf0cTYaCizYUwDioS7i3cR7irwF7jKgD7j9gH7iA8dhRLvrBMsCZuimoetcNETHBOQJTREIF0BKgKxi4wbTsEkOnFDmh5QxFPO0BwKVZfEk6xjYqiM2YmBFFkAaQ+INf8y+vZks4ZSDAvjtiaQWWC7MXfiVkczDmcazDWcRBjeZpgiDiLORpNn+AHpJyAmgDwBJaCuxTUh0BZyMwAVZkLDpegECCjk+MAobhiUAfPBQqIfAVoeAT5YaJcVNKLINo + +go9KMcrjqMdljnUXx9oHr7MsHhRkqILVA/wPXRhCsvDYiT/AEiQFwbQdvDdvrvDKHpzUdwWUpqsR8DasUR0mHl6DLvskSRAKkTEifbi0UZrUncegBGIBk59QKQAqPmpj4wWH8g0HbdsYL8kCGPO18QHiAjRNXQq7tsBXPohQDju6kgfoAF4IW9Vwklfi/0bSDywZoSHMROkLHjh8zsa5idbpzDXOCRwTCWYSLCVYSbCXYSHCXXi6IcdsVpm/cq0V + +aIfkh+ExwaOCIoZwRn8jjAQiYgT6buETuEV+8bgXwiCsV9lDZLTlyRvwjviYbkxsgbCgUXkS/UnudDfoeCsJufCaFp8SmsUf17soCTepKijehh1jhHvUAv9vgBJAPUBJaEYBOQDH0M9EaAn+MwAV2AgBlsBE8NAUHjK7qhwb+ln5OKnwJ52qFBruO/gbmMCl22OYDQipYDZif5dfEXTiAMUKjDscBjjsdWCwMRsj1iTO8OcRgBjCU0BTCawS9idY + +TggLYT7CVABHCYQVnCbmY+iJkiW8dIdSRKnFWUJxDfCXIRbif9jGphjMT8S9sFcaA9zUX0V5quUAWgFTcWgEIBZyEcAhPAv8Vca8T20e8TmbqAc7SYbVHSc6SCpusp7hL3iKysFQypip1AyavBSGJ3dqprVNWSFMiOutcE9HnyiqBn4jBUQzimYeYsdCagjn8cXj2caXjJSTsTZSZYT5SQgBFSUcTf8ScSCjuNjXsVcjDIjXRbmKJcqBLpsREHJh + +5MEUMZ4fATjNs8TZfqrjkYeriUURgSnogCjT9tlDB0cbD72F91XQZ8DDcQ/sMSViScSXiSJBswBCSWwBiSaSTySWRManmlDqiSiT0Ufndg/DHBcAPWFVMTwTALh0s4ZIAQGWLn4eOPB4lnjIkpiIbhsslT0r+r4cTjLYJthhnDLlHsJrlMCk8kKCkuSfGiUfnAjb8b1MtCZmTH8asScyWKStkRKTNALoNqgPQBNWr+sMIJHwjAJBhTEc4AWxDAAv + +wBWTLdsdsBJpQiq0eZIQcAmhESmgApFg3Vq+sPBXkdqD3kW+9Pkb2TF4VESI0r6CQckalWKeY5/AnyoPUoKoKQMKpRyZVjBmkJjKnnIjRMXD12KY01kSW6c87sI9Pvsl8hoSfgrLg24nEDkQ0fFbFUHAjZVwo8BRHJ/h6BOtiwQM/hYlM0EqMIhlC9jTiueqj8FiaBSliYNMViVYtS4S/jIMR/UJQPBTEKWbwzAqhT0KbuBMKX+BsKccS8KQUduC + +ZFigCZyxB/pLj61LIpMTJD8QuPLipfuwjuyZwj3SbRiCRqusJAIbIuYEKC7UggB7so9ltcl1J45CNkRpMnJBEWlTUABlS4AFlScqWTkPsgiSTZIVSapMVSqAeVjngUbDdwXr9wSW6DT4VCSEdg1j0qekAKqaakqqXlTaqaNkiqVJT9PjuiNEUaB+yOcAtEbuBjXjS9s7JjB7WOjMqnFdswyS3k/wRHDQtGxgLYgni8wWAithgj8Y0WZC1CYRsNCd + +ZSM/nhc7KYXiHKbmSs0YYT8VK5SkKR5SFgl5SfKX5TcKWsCYeucS8MQjYX9PGIndgEo4GjoYnZgHgnifRSkCYxSWkf2SlwXCTSsauCzfmDsKsaCSqsR1TZEXVj5ETCT8sfDTxqduiZKVCD0ooIA/fMwAijoJDJFvswMYNUFOKIkghkfz5tIfXJvKPFIj4I+iW9MbFG6t3iEIeXgLUDTC5ieoTaBs30FVvpNJlsgjhSU/jRSVWYYKfmS4KXJs3Kch + +TPKRhSsKThTBcWcj8VIDA1Ngo9AtIuFD3v5M7ZlcwtlGaSOyacCECZDSXidJDcsZ2jygObIBTPrJmpI1kusjVJ6TE1I5soyY6pLdl2st1JpslbJepIAB5EGmkttJpMhskNkRqXpyusIkA1tP6kttPtpjtLpMztJ6kbUjdpHUg9pXtKqkvtP9pnWQmyCJJDp2GNERWUNyJrVPyJ6NKKJJ62i2PVJqeEdKjpDtKdpyOVdp7tPNkntKay3tL9pnUgDp + +mdODpdKlDpHsOEB98MdxnlnxRktDNxRoFqAm71aJ2dm0ISizfC6CW8g+dhD+/2ARImxSpQuMK4gScIOO/ciAIxpTQBTxzz2SxAh8KSAsgyHxC+MR2HeQtJspqeScxBFzZxD1Jciw+zVJ3U1+pHhMioHNISBBpPngnFFSk+PRxMbHwG+pqPipptOg6CBFfMC+Pg65QDjgXyHKpWVJByoDOIA4DNNSLqUfyb5CBwOwBbcr/n4xhpyLmU5OLpw1xKJy + +KKfQUDJgZRoRWO3dPaxe5OEenGxQgegSLAYwxEJxV2JAJIEPc44LuS61hbkxzCuaVQT3q7GCZJoZl7unNOmJupG3pRXkAI3GH3p5lJsxR9PsBR2IleJ2MgpEtPQs4pMySrVXXemgDjQP7ScQEUGaCEsmBpdxN6+2yjtW571ihl73ihf9Ky6bhwAeQDJHy97ECANiDSJr0BDmVhUVOIOSn+IQEPA1jPnAtjNgecDNbgCDLwC2HgZYpwRapB8PHJ6D + +JkRmDI9BpdOYeDWMcZVjO4objPsZUmK3RMmN7pEknuA1sNtA1HALuHY0yQOSDKsXRN2i64H0yoUGCgg8QysNgnUeyPj44WMhS0irgXCJ9UfIxM0ghiwyMkQQVOCvNO5J8xIup8qz68wtMG2ISIgp9lLWJktIuxc0QUZnPyUZoywrRUWPtm55CuWs1FUMjyMw8XDPUpqWLipuulGojqP/MltDMZZvXQAgAFwQQACoIKgBtmYAAEEFQAgABwQXZmAA + +QhBAAEQguzJByezIOZxzLOZVzJuZfm31oIUV+ErbHpefjIEpqNKEp7/TO+mNLEpqQjuZRzNOZFzOuZeNISZk1LqJgCSvATQB+AQs03+o9Ng8Qim4qdGA4Q/uCDy2MxkiIeIU6wFSEuyMkpACSGdqXgWRIn5NOAcnXpOIXCgqNKAPpFlOApVlI6Zek1PpMsQmBuPylRr+JViXa2RupIBAWORlcgutK2sTH2byRmU4gZwBniRtLYRKzL1YjqOOYQhO + +XWT3SZojABcZnAAeoEDOEKirIQAyrNlKbADVZ3RzpE0z0ngm0SpiIbD+E/jIExR8L+ZJ8MhJ8K2hJgTg1ZWrNVZsDLiZTBJAO4ACWgwKDgAcABNANiG3c0ADigGQC96kmBuADAD5gByRAp8qx6sNfgKA97AqJPSEPABtVaZuWhjZcROaI8bIwg4bMFpnTNWAybJ/gvHXSAdqTGBwbJSJcbPSAJoEBOObJLZCbOkZ8dArZqbPSA0rDmWtbPSG8bKb + +h+HybZebP0AiEG+ZRtnbZ8bK7Z5JVQivbPSAj6ELp2bOLZdbITZHBirEYmUQkQ7P0Ac2Aky07O1q2wkc8sbInZwDExR1hBKg2bOYAU/x5A+ABCMSUBVIjKE44+bSB+v+WjZu7NZAhoDCazbHQ8OIBwYFWXk6mVkLgbAAMAzeIYABAGTgVGTFk2RjeIc7IbZXVWa+2bNlAJAB6S0bNA5xABNACADmIZ8EtQJAGWwbAB2gc2FwAI5BHY8HKgCSkAwg + +PIEIyEJ1wAAAAptStQAW8pdgSOcRyFkLUAAAJS6gOODKAfMBagOYB4cwjkCpXgAscvzjkcsyDUc/9njs8WDWYJuHTldwlH6OODFgcOCv0JSCZAVDnBAFSBH5eMqEAOYhH5SmgBs6THCAPjq2wdOT/suwADkSDTLkymhZOJDnvqSmhocxnjAoBYCEARgAPUHkAfsjbBhAYICmctpqrs5kAGATdn0gGGkxCZB6vIUznmct9lCeUIjyQcAAKQdnTObO + +hAWIFsBAAA== +``` +%% \ No newline at end of file diff --git a/DOCS/Алексей/ProcessingSystem scheme.md b/DOCS/Алексей/ProcessingSystem scheme.md new file mode 100644 index 0000000..86b9f6e --- /dev/null +++ b/DOCS/Алексей/ProcessingSystem scheme.md @@ -0,0 +1,124 @@ +--- + +excalidraw-plugin: parsed +tags: [excalidraw] + +--- +==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠== You can decompress Drawing data with the command palette: 'Decompress current Excalidraw file'. For more info check in plugin settings under 'Saving' + + +# Excalidraw Data + +## Text Elements +ClientServerGUI ^6Nu6FkAI + +Client ^qYxPhLRc + +Unity ^X0KjhPzB + +DB ^w8JAyq9g + +processingClientAutorization ^m0XWBAAZ + +clientHandler ^V9sV6vZu + +providerDB ^tql9O4gb + +dataParser ^I5cKWcDb + +processingClientDeAutorization ^cRGk1reW + +clientHandler ^JtKDGDuT + +providerDB ^XRyhU4Ir + +dataParser ^TJscfbbe + +processingClientDeAutorization ^IovF8Dv8 + +%% +## Drawing +```compressed-json +N4KAkARALgngDgUwgLgAQQQDwMYEMA2AlgCYBOuA7hADTgQBuCpAzoQPYB2KqATLZMzYBXUtiRoIACyhQ4zZAHoFAc0JRJQgEYA6bGwC2CgF7N6hbEcK4OCtptbErHALRY8RMpWdx8Q1TdIEfARcZgRmBShcZQUebQB2bR4aOiCEfQQOKGZuAG1wMFAwYogSbghiAHkACQBmADUAYQBWSQAZJsYASTYAVQAGACE2uC5+EthEcsDsKI5lYJTiyExu + +ZwBGHh4ADm1t7Z5++P7a7YA2M9P18cgYNebmuPieePiL9YAWHnXPm4gKEjqbjrV5JWpHD7rfpnaEATnivwKkEkCEIymk3FqzT+1gW4lQ/T+zCgpDYAGsEI02Pg2KRygBiHgAM1hCA+HyWJU0uGwZOUpKEHGIVJpdIk9M0zJ4mk0nMgTMI+HwAGVYIsJIIPHKIMTSRSAOqAyTcPhInUk8kIVUwdXoTVlP4C9EccI5NDXM1sOA8tR3d39Qlm/nCOBd + +Yhu1C5AC6fyZ5AyYe4HCESr+hCFWHKmnWAHFtQKhS7mBGistoPB8bUkQBfIkIBDEYEveIfS5nL5/RgsdhcNAvU1lrusTgAOU4YmBZ1ezVhHwhaeYABE0lAG9wmQQwn9NMIhQBRYIZLIR/LLQpIiYV8qrzBQOUlMoSM4joRnABiZIAgl0IBfq0iYzNIQ4GIXBV0bd14lqKcETObZnjOD0yyIDgySTFN8D+GleTXNAN3wMIClrApS0gR90GfV8P2/b + +VJnxaAsDvP5VjQDZvl2D5mguSEeDOHhmlqWFsTNP1UGcZoPkSZ5XneL4fg+P4AWIIF3S47RaniWF9h2TZhLLFE0QxPs9JKXFbUDMtdUtEVaQZZlWXZbVuV5YNBWFalbIkElrGYb1AiybUFSVa1bR1akHTNKyDSNE0iQtCkQvo+1G0dYRnVdYE/i9H1YGBAM/lc0NwzyQCyzjXAEwg1Bk1TM102ITMJGzap813YgiwjGrMMi+sqp+HYzmaBF4m2Ts + +mGHXteA+UazSHHsxw4Cc+wDOcvkEhS6qXFdcNQfCtzNHc3IPdJMmyEq/mA0DwOBKCYPWOCEKQkoULQtAuqwtgcKqvaED+G87wkRoiFO5UmC7HNeh/R1KAAFUY8ogcIEGwaYCGobNJlOCgZVCCMfFDljLG3wqxVRJMyB/s/IhlEmiAxCyJhtS7KBzAIKm0Vp/QSGIRY/j0LJcHTJhEwkKo6iaVoOkabo+iGEYxk9Ug0XTAg4dvBHgayUHSHByHtVw + +IQoDYAAlcJcfxEkhF+s0UIQapUXRAHUHWJJmiI8ZSNKKqIEqABNRoAA0AFkKFqOAeBHD5lGIQYAH02CMfoeHqQhaKvCQZjmPFtRYsTNh4D5tCGziNOOWEsXZP5RPEpOkneWEhKhZoTg2sslJU1B4PU7ZWw+LEJIe8mpAdozUCxHF5nMuK9UpDyxXQel1nhdZsGSbceT5At3NFBlcGaYhtiZJlAsVFU1SS8KUsi+KEENZTjT7afLUS8pktavxJA6z + +LPW9bBfTyiyJRCphhPKVEo5VKroVqmWeqjV0DZnRmWLeX80CkQpunMeNY6w7R+OsWoGlITHDGt2TgmJprEImgtJavB+iwn6F8Zo5wFzLmCNdPCm5rZlkOvuQ8p0TwXjQegqYXl4Y3AfN7AAjr7TAAAFdoxtsC/jPP+ZYYDICXTAjg26rwQSfBhE9SAL0oHdWQp9Ck30OHuxInVSR0i5FtAUWnYR6B/o5zWJsfouwk7fFhAXfBkkHhVzWB8eEddEI + +N2aE3FuikYpoAkkkTSQlwRJ18bCM4sI/gGUdiaIeZl8SAIEDfGy88ICL2XqvJyG9XJCmKdecgHBfK4H8kxDGp8X4akvtqKKt9Ym8Cfglc+r9OmpQ/ig52WVf7/39AUiAwDipoGjLGeMCARbVQwmmDMucIDZgAFLv0LBlN66yeo4K0iNWonEtgUJ7JiK5s1xrzXHPidY2x7ohP6M3AcD4tqsJ2j9bcbVjpHjOgstREANFsOdto4aej+gGIgEYo50D + +npmL+Rwv68NAaaxaUg2GmL0CI1OoFLGOM8YmhmZjLIxMub4DJhi287MablHpquOkxCWbuEZZzbmvMzT8yiELUgqyfb+2DqHcOkdo5xwTknFO2paTKw4KrfFEBCUBRxIbE2ZsyVoEtpw56Qt7aGSdi7fiVjiie3IhAeIsceA5hkRwRAABpGGvtjb9F6AHNg6wnUjUXE4+imc8luNYvnZo2gpw/Dob454ISMkiWCY8bQjdXmXB+FOJOMT77cC7qcXu + +/dWzwSHlk0e48zTBrQDM7ptTxRMk8dgAMlSXJbxrQvI+CBsANxPsFQZHStT9J6dmx+18Z7tLtMMs0TpP6HPGT/HKokoQzLmaApZFUVlVXenVTZWYfX7PajOtB5ZnFVmWMRSyvVgSwheS8CSLzrmkOMvGwcDzRxPO4CNAuDwAxfLIj8hAkL/kHUBbw48eQBEXiEfRVxYiyLewDv0J1AArSQMijCDCUaegCF0QKaL6tC+68FeLwsRWs5FhjUUWIIgg + +c154YFwYQ8h1D6G/oYIYurZi7jDheM8dsR4GbIStxKNXdkiQU33VqOm44P7/i9KTR8hu/GoTrC4vxTJI8naqfLZPfJA7W2lLrdsBt/Qm2bzanp7yDS/JEtjG03t47+0jstHfDu0nuljrCg5pBaVp3Fm/mWbKf9crTIKgKIqK6MbLNWZumB26mrrDaHusZ0WShhB2ocZuZzon3JIZNAugnIBzVfYtZ5g1DiQnksw7alH9pcOAydUDoLsNXS0dBHRD + +0iNYXTK9UjJiUVfXXOis0riJC9A4P/aGFA1ZOwgKN8bGMSXm3JYTKlJNaXcCHpTamtMWWM3ZazfAXLyhc2IDzJAfMsaCxdEK72Nq7UOuda691nrvW+u2P6rKSt/DKvViNsbuUNVG1NqwHVqA9WdZdEa7J7pXY0ctd7RcI49yNHagALXZL0TtI4ECfmxxQIQQg2ABumB2rOvKyy5zYjwWo2hPHsgDHBcEOx8sQGroJWECSdFXreFCJhZp24P07okP + +N7YC2DzU8azEuTtPcCrUUueDIEAnDwesEz1Tt6eTbUyTtnbu1nxtBfTzKWb7OYF65m+7m34jPSr590Ez50AJCyGEB50Itrqi8cmLDUtnZiDolg9F4j2ViwScvqFyQnJKhPe3L2wZmFY4FQysLY+LbCEszwgf6AODdq0dEDILIzgbPJB68oiINe3KBQbYOzPwwAkbCZQGHigqOKGCiFLW7rtcQuD7ryXyP9fYVR2HNjy+V+r7X+vLHnFsZxSUCnUb + +C4x8OFOcEdCPlBNYutDnCIueIU8WcLNHdwR7CXvCOC0J2zQk0/pdTOSJ7Z0rbp+X4pFcSYk6rltj+XH1Mac03XFuJ2WWN16TN1HTsw8wii81GRnXhQCymWdnyiDFC2d0a1d0gSRV6zIli3gXWBHD9xtx62wSqm+EIQRHumkzjxNCnCjwT24D4k+E0mOD302hYX/TRSowBRz3qzz0WSAhw0hRBFa1gkI07xti62MQ+j712izwmBVUXGY0nTxR+3QF + +kOJS1kW2WmWygGpVJnW3pSgEOwkB2zZWyw5TZi2yOx5TOz5Qu0FWFQRyR1R3R0x2x1x3x0Jw+0VW+2m2UIBy1WBwtlICtnBztmv2hzNUbw9iHwkH0H6ADn1EGE/E/BRyJxEXYzNAp140SGhEiT4h43ggODXzEiGnZ18VoTnFqGbCOEYLblkyGj2DjU+C/RGk2HFyh1QGbm7ivXZDwXBC4gklvynkcwpD00XgQHWFGMsK4SqXfx3lrS11hB1xsx7X + +1yGUN0KRnhN1ikGKtFAMt0nW8zGWgMmSCzgKXUQPmUjDBQgXXTEK3S9x3UqFwM6g9xSwvTQHOAuV4yEhmmfRy3WyfRKDj2oOMjhShB4C0kq1+Wq31UgG4WICBT4TAzPEETLwkA+BzDUAAEVjZmh6A2h+hfBfZehMAYYjAYAzgdlEN7wi8JAmlSQqA/wsMeDms8MBCM04VOIu8bjTEJDAMyxht0A4BSQxBix0xlA1U9DNUlYjAwIbkJsptyhBTPpX + +RRTxTPxJTcYZTSENDSV8Q5x1IfgJMBJoR2RHhagNCtC1s4ldD9D0BggmRp8CsmATCDszCvIvRtR+VLthYN1njIAFUvt8B5SJBFThTWB5hVT1TpSWYtTy1NUgc1DQcAjoSEVDUQjnYYdwjrE6Nyg0TMTsTcT8ShBCTiTSTyTKSJ96JaS2AqAONWIY8zgI1thoIThNIfh4gCjxJD9nhy4wSY9TThDqih0CQWjR5vg4hLg+5aFcFDhwRmcK1hytjhix + +jlyJiuQpizMP99M5iFjWkljQpdiAD1igCB0/9ViIAp0Di7dAsF14Cyxl0XcypIsfSyNShMDtl1gZFHjuBD06ITRg9z0cE6DPi+Mo8TRmdAS313RJITg4VvgZl09mDM82CgMODgV+EkTS9fyUiHTxFyh6hYRmB6gzh6AUchAG8wAm8wAW9eC28ZIoJeIy1kJRC0DxDzEBtkKyw4A2B0wuCLxTwzwClih+gLw1EwB+LlhBKwAxyI0Lll9pyYKPgRLG + +TkJQgoAqR9AuYZAGwZFuKAoWLr4mkoBBh6pRTvyA80hgVhVojYj4jEj7wIBMZsAhAIx+gj9y4mj2ReM8iXgxFZlcA4A/MypCBMBtLdKnYup/yShMgY4TL5guSjdDLPxSA6SURcBnz0CMAhQkqUqQhvYqyayzQggdwKBWDCJMyLVIj0B8LCLiLSLkiXES9yc1hzhEhw8HgHgoJBJBoOy+4Gyr1vh4hHgQkJzLh98BdNgXZwk6EsR2wS5mizQS0NMp + +c78FzDzrJNyRiVy38NyZjNdtdYRf8dj/8jcjyhzgDn4jqzyLyoCrzYDF1HdgIkCLjV1UD8Dbi4F3yMSvz9KAK+oY8yi2dY8X1JpoIqDILUBnheJ+JlNvjvlELSrkzYT4SGs3qyxW8WSYIl8GKh4SMe8EUKN2KatpDFC6ZsVqhrBTsjDcVJsVVsAyaKbggqbwEFsQcCZ5sVsaU6UhtGIbS6ZTpdtjD9tebjtTsPTrCrthVcyoAsScS8SCSiSSSySK + +T5VPsVZAzab6ahRGb9Y4ztV/DAiRCIc0zTU3ZyraNcKJB8BFxCAYBENMB6hcBMB9AJFcAUcYRJAnUUdcBag9x6qIB8qQ0xIpxC54RbouIsR6d4Vq5HgXZ2R+I4IdhS4+i+dekZlFqTRNgZLJyr1+oFL+idNFyNqVyxjtq3Jhij59rDrli+1wCTqnNjytjTza7IBrq8DDj7dgsECndzjuDHy3d0qNk7i4tjZvrUAfyMEeBIqBBXjnZBoAxThd9QK4 + +l2zstKFwblMr0BI5xecYEM8Eb2CeFOD0LlhkSsKGrUjC8USXEJF8BYRKgo5ZQGTVEmtcMbpWT6yfFOSfq+s2L+8ibIAuKeLj7ihxKhKYNhKzxRLQGwBJLpKJy5Lc7ZylLn6bZVL1LNLwIdKeL4rClDLjKhRTLv7IBor8HHA4qiHzRErkrqzUqB7CqsrqGKBaHygA6/girqyEbB9syvIb676H6/boM0i1huztAoR6LJIBNIlmdhMXgI1+JIQNIdIo + +Ie4xq8pdh+IG5r1NgU8L8Rylr86ZcH9drSli7VyYT1yy6NqK75iDrFi9d9zjq1j66zqTzLrm7zz9ibq51ryHcu7Hqe7LinycHXyh6sDlRR68bUs8NlMLgYRk6fiJp1t4UILisc1EIe4QR4m4aqtCbEa6s0KHySh0a37MaP6l4v7Uaf797uaSbFSzAGpSBvD5CabanSR6mmAmmyoWb8YKUiZVsua+SebXT0BDCmYnShbhmIARaycShPSbDvYraba7 + +aHanaXa3b+gPavafaVaPD1bWm2B2nGm5CywDZAc9buAwdDbgiJdQjTaKKIjuH0AeA/ZfY7B6ghAWQmRDYJEMSA4sBcB6hmg/bWGhHWIB5tB2RWx6ElcfhIkOzHghcpxIkLkqdWtVH78Fq0y4HZKpzEH6EDGMW1qhii7xiS715m0dqNctzK67Gm6r4iXB0XNXHq77N3HW6Ix26fHO67yzjws+7Xq8bYFvd1gYZR7x7nFJ7T0CDuBo0QQthZwl7O5/ + +jHScsgTnYC4U9Bpi4ISWCoSD64Tc9gHza+TWNBHL6rUuhmhsAnV9RsBFxH7lFlKimaKMaZIDg8F9gKm8bsJf7JCOKShAGUbQHoHJKIGUGzwQ2YNsXs75KkHIGnXDE0GDAMHQrsGKHiQ8HYr68KGSGs3gmM3SA9DGHmGc2GGcq0qWHGHtR2GSqoSuGLb0BLXrXbX7WBHGqZ81h9F1J6EHh9g56Iker8Ei5m4sQ+2ZIJIh5+c8p2ct9o0LhNIxdMWb + +neBlqBiGWlzSWzHtkLGakrHtzbHdz7GDd3HukNjh0GW6X35rcOXbrjj7q/GwtCn5QgmKGhWd1egInfSdQZ6e5oIJ2LlFWLgwbUm0BoJtHzhM0mCcm/68nUKETkC0aXWSm3XvhThlWUzUJgmfXqnBmSarpcAZEmkwgmaW6FDpt8PCOWABaunVDWbemObtCrSam9DJnRm9tOVJnpmt25mJbvZnnfZXnNB3nPnvnfn/nAWdmAygz0AKOiPqPTJda/CL + +mkygjIdR4Tb63YNmVjYcwyR1hAh9Q22L6O26zGEI1fF0lZwDgEQsnbg1gthWrIlGFppF9XlAkU6hyd9k0rgERThI1PWl3Wj2i0PPgFGejBo5zpdCW67iXjHNrxjS7d24vrGdygq9zj36WYvGXTdmWHGrrPG27b2bzTju6+XwEX3KmMDQn3zDORkDk8DImZ6w1Ikz9FX72EnHkQPnZOJ9h8FwSoPITcn9XkauDqLmTkO3hf2l4cbmLKv8aeSpCKYV + +UQzlTwzsVlw1SjYpTNSFZqbpOIAVuRS1ukYsgNvIyduVDsYEy9SJNlcjTZrTTzT+mdDmPea7SHSGBxmOOOZrx3TzsBZ5ngn/S1b9vDuwyxT1vsdzvozduFOzmlPdUVOrm1OTUMz7msyG2IB6gnUbanV6BPwdlsBfYRWuhcBFxY5JAC4oB6hgWq3ayxJWyac8F+qXkHhDSOzPhdg8FYK40C40lfF0XVqSh06+xM74HcWPFZyCWhenHYuqX4uyWDod + +31cSl6QUuD20uj2ViT3ACXHG63HMuW6Cub3vG7rbygFeWn2HKKvBW3zsxfYxWA8z7JWzbp6dooIjhGEEJFWWxgPqFm5eM+4/OdWkL/7tl8n4P88MLL6z6p8qSr6IAdkoAnVFwcxFwhBRWn7m8X6+DoU4JIlJuvWv3sO9WzRA3eKI2INQ2RKxFI2INo2EHJf6FkHs/UHiR0G1BMGwr82ohC3SHCG5vc2CHyG5uC2i3y26GyxorsqaHcrK26Tq38Bi + +rOGza4dygk+U+0+M+jOPv0jIk9gqd3i0lpxYa7OwXC4JMwTjheqU9bOZMhyJqI1j8TguITTL+9Gb8tMVrZcZ4N2tryXTMljZLvuyrp5cdep1JlvrxZZgFDeHjSAoV1N53tzekAe8gh3K791gmb7OLEkTq77oGuX7KJjdFnBgkC+4FYGpiHQ4pNqEzPHfPxDv4IVoOfrMPkjUNZW9imkEd+iEgyZF8XyJfIbsx2ZSa1Ka+YMjoIJO5QByaWteTvKG + +6ZLZ2amhZ7kx1w4scfuBhfmiR0+6FsJmqg9AFxzFoA9eOeFHHjADx4E8ieJPMnhTyp4093CUnDWuIMkHCCfC8ZEHJcyYpG1l2GnVfpVQgBGBqgTqWELHDJAwAKARgZUPUCDgYk4iHwUgHACDgSJauQ2VjCCyaqsRBo7OcEG8BbApJWsp/FnO4lOB1F8EE5BECcEQhmkPOHcNOlizF44sc6TfSLt/yMby9TGiXFXgyHV6gCMuXSXXpAIvYG8r2PmE + +3v5iOLFcHqj7NAc+wwGvs7e6wXAI7zPCB4/yUrEPNwGmgSZt60INrkcD974hBqh/FTFUWyaDcYOw3VgQsgLyLDY+ZrRYVagDjGwYAkgXoB8C6B0gs+VFHPrRUm4F84IPAjKnwNOFl8wqRrOvoXjDat9K+YIqNrUJjZ4tFK8bcNs9CTYaVO+qbPSqP175GU82pbGKsP2zYYiqGE/YJtP2LZz8aSdPQqkvw4Z1tvBjzCAPcMeHPDXhO/QOs4F84QsN + +IlwF/IwmVw9Vw0ScHIinmUx9xWw8KKdv6HUYzgr07rHYHQj4gf9jI0vH/utTi6tCABaucuiANpYDCB0Z7PpFALAGwD2WgVP0qMN8Y8tSuVvK4u7hfJYCsCsoXAUlgIFNdBoOROFP1w64Po2iZA1VuvQEg503gjCEPjhy5AR8g2Y3V+hwNKZcDIQfw1iiGKW77NDmnTEoOQBabTY6mJADpsc2Zq0cemT3Tmi92UG802Ogtb7kyiiIWF9BAqQwRID8 + +EBCghIQsIREKiGDAYhcQhIZJxB7Lc2mWYo5jrXh4Jk3BBqDwa0S8Ho8KqdI7AG0GiBnAJEUAIQJ+BhiaB9AcAaoJaxkQUBSAGJRRBWXn7VlWRRpBIC2H6oMJJIQHBNKGnZAJAGcu+KEHxFeDM5xRMvYeMuwb4S8Zy+LL/muyy5/8Eu6o6YvL06HajoBB5LLnqPOoDJQJjjOAdexNEQAYCSAkrv4zK5TCBWX7O0e+V3F7E3IYycVvjCnrfsdojCOC + +i8nBBtdBIuwjOvxEGrfpgxpfbPIfQKYXDo+Vw01u2zpEwwdkzAbAEyBlBIB3hEY3Pu/R+F5DcaxfAmoCM4rAjESywUEQJRr58Uq+0I8cnUNjbN8EREIpEe32TaojiAWDdEZE0xH98R+eNIfmQ3xFGTCRs/CtjiJn5MMyR6AFIVFSpG1tcmmnBPlxJ4l8TNAW7a4RxIgAU5GE4aCci1Q0aij4WrlRuMKI+SfI+I0mZ8VCBnbP80kU4NJEWgVErslR + +zQ1XmqKV4UsgBQErUYe0va6iG6/Q6Cfl3gHDCSgiEsYQ+yeq910B6E20bMKNFtQnRL5QgctFKx+JeIgHSgcDTVZB80kRwciQN11b8DGJBrI+mwKQ5Ri3WMY4jLN29aSSmByZfkhUDAgEc5OGgtMft1k5UcNBlKK7nRwLGMc2i1pVjuoLGZaDyx3KE7DM0gA8dvSzKGccoDnELilxK4tcRuK3E7iuxSqPZuR22mUdiOA43wkOKR7uDrmY4tHmemNY + +J8eg9AN8G9noDbAWR9PZwLxn5GEZ4IFyfglxAKKbB58VOI4INQkjWdL8JQZ8V53LivJfOLVF5HkJF5tFXKIXLovgg+QRdsphdVUZuzaGaiaWJUnUVsQgm5duhVuIYfBLqnmiLeloyYdb2mFzdMJ2YLdsghnSNcdo5RTYFBAbhA1fiqkZJkNPBpDRPEOwHRvRKmmhi4O4Yz4a60m4wR8EcYm2GtN5LE0MxQpVbhD3EFnctuGpGHiIPTEKkvZR3H2a + +dD9kKooyspeQTqTWHsyDSymcEA9ypznTLSl017pM3e63TnSvNI2AFX+41jXpFDYHkDNB6hzwe4pSOdt0DnODzmiPA2jDJR7Ah4Z4AUqP7TgBwBVQmiMyhMBRAZByg1MDEOMAYBIwKAgwZXpqKPhHxOQdMEQM0i6Crh9AqoX/iS3/4FA55yVU6IvPSATyCpSXIqcLNmbzzt5S8t8LZkqm11N5C8peSvOcZ9DnpJ8rIDvOXnm5RZx8rec/KXnGxjeg + +Va+afPSCVAzR3LR+Z/KgAvy3wfTQsUoNAU3z0gkCvMXII/lwL9AU2N7ggHtKzynKYCl+d3MLb2SS2lTf+V/PSB7gy2NkvKhSOQUAL9A9kmGKxi3izyeJpIJUAHGBAHBXKvEU/PsHDq0IR5zC6kPgAd5QUTgojJTPI3/bKYR5RgNgAYF7kAkCAVsGXEXHoTKYXeCM4heAu/kdSZ0cAoULPP5AkA456hDeYYuICqgEAAVGBbMiVjEAg4bABqGQtwCa + +BggDElAbYtbSexBg1Ib2KQGUDcgAAFANWoC8AQQIS4JQSCLgABKbUKbGUApgmk0wfxbgCCXkTeAaSsmSEtcrNAYlNGTRXfIpBAKYeTxZFErIyCmwMwSsEfp7EyDOLXFynRubMyIBWLEyjSyAEqgHkNzkywgKALbAaXUYzaCEzQIhhJzMBlQSqOIQ4oQBOKXFIY/2rMEICMAYYsi/APIupJ2g0gCymMmWCcrEgDA9C5xKtIW7+tE2xIT8AsqWUrLj + +EREcAGegcqKhwg35f8NWCAA= +``` +%% \ No newline at end of file diff --git a/DOCS/Алексей/Рефакторинг.md b/DOCS/Алексей/Рефакторинг.md index bef373d..c424ed7 100644 --- a/DOCS/Алексей/Рефакторинг.md +++ b/DOCS/Алексей/Рефакторинг.md @@ -1,2 +1,2 @@ 1. DataParser разделить на подклассы, придумать как скомпоновать. Возможно разделить на формирование ответов и парсинг входящих данных. -2. \ No newline at end of file +2. xmlAnswer_message посредник между ГУИ лежит в processingSystem \ No newline at end of file diff --git a/DOCS/Как умеем принимать на Server.md b/DOCS/Как умеем принимать на Server.md deleted file mode 100644 index 33c4ca5..0000000 --- a/DOCS/Как умеем принимать на Server.md +++ /dev/null @@ -1 +0,0 @@ -- XML файлы с поиском по тегу (DataParser::xmlParser) \ No newline at end of file diff --git a/DOCS/Как умеем принимать, как умеем отправлять!.md b/DOCS/Как умеем принимать, как умеем отправлять!.md new file mode 100644 index 0000000..0fbbc41 --- /dev/null +++ b/DOCS/Как умеем принимать, как умеем отправлять!.md @@ -0,0 +1,8 @@ + +Сервер -> Принимаем +- XML файлы с поиском по тегу (DataParser::xmlParser) + +Участники +RecognizeSystem - система распознавания типа пакета, экземпляр у каждого клиента +ProcessingSystem - система активации процессов (создает результат после распознания действия) 1 штука на всех + diff --git a/ServerLMS/ServerLMS/Systems/dataparser.cpp b/ServerLMS/ServerLMS/Systems/dataparser.cpp index c090aad..fa284ba 100644 --- a/ServerLMS/ServerLMS/Systems/dataparser.cpp +++ b/ServerLMS/ServerLMS/Systems/dataparser.cpp @@ -224,23 +224,6 @@ void DataParser::xmlParser(ClientHandler *client, QByteArray array) processingSystem->processingClientNotify(client, clientNotify); } - else if(xmlReader.name() == "DataInfo") - { - dataInfo = new DataInfo; - - foreach(const QXmlStreamAttribute &attr, xmlReader.attributes()) - { - QString name = attr.name().toString(); - QString value = attr.value().toString(); - - if(name == "path") - dataInfo->path= value.toUtf8(); - - if(name == "size") - dataInfo->size = value.toLong(); - } - - } else { emit sigLogMessage("XmlParser: unrecognized tag"); @@ -255,7 +238,7 @@ void DataParser::xmlFileDataParse(QByteArray array) { QXmlStreamReader xmlReader(array); datas = new QList; - xmlReader.readNext(); // Переходим к первому элементу в файле + xmlReader.readNext(); //Крутимся в цикле до тех пор, пока не достигнем конца документа while(!xmlReader.atEnd()) @@ -591,7 +574,7 @@ QByteArray DataParser::xmlAnswer_currentVersion() return array; } -void DataParser::createVersionListXmlAnswer(QList version) +void DataParser::createVersionListXmlAnswer(QList version) //TODO: переименовать и перебросить в AssetManager { QList listTag; @@ -632,7 +615,7 @@ void DataParser::createVersionListXmlAnswer(QList versio file.close(); } -QByteArray DataParser::readTempFile() +QByteArray DataParser::readTempFile() //TODO: переименовать и перебросить в AssetManager { QByteArray array; QFile fileR(tempFile); @@ -644,13 +627,13 @@ QByteArray DataParser::readTempFile() else { array = fileR.readAll(); - fileR.close(); // Закрываем файл + fileR.close(); } return array; } -void DataParser::saveVersionToFile(StreamingVersionData *streamingVersion) +void DataParser::saveVersionToFile(StreamingVersionData *streamingVersion) //TODO: переименовать и перебросить в AssetManager { QFile file(version); file.open(QFile::WriteOnly); @@ -669,17 +652,17 @@ void DataParser::saveVersionToFile(StreamingVersionData *streamingVersion) file.close(); } -DataInfo *DataParser::getCurrentDataInfo() +DataInfo *DataParser::getCurrentDataInfo() //TODO: переименовать и перебросить в AssetManager { return dataInfo; } -void DataParser::clearCurrentDataInfo() +void DataParser::clearCurrentDataInfo() //TODO: переименовать и перебросить в AssetManager { delete dataInfo; } -QList *DataParser::getDatas() const +QList *DataParser::getDatas() const //TODO: переименовать и перебросить в AssetManager { return datas; } diff --git a/ServerLMS/ServerLMS/Systems/processingsystem.cpp b/ServerLMS/ServerLMS/Systems/processingsystem.cpp index 6813cc9..7338c1b 100644 --- a/ServerLMS/ServerLMS/Systems/processingsystem.cpp +++ b/ServerLMS/ServerLMS/Systems/processingsystem.cpp @@ -124,6 +124,7 @@ void ProcessingSystem::processingClientQueryToDB(ClientHandler *client, ClientQu { QByteArray arrayAnswer; + qDebug() << "ProcessingQueryThread " << QThread::currentThreadId(); switch (clientQueryToDB.typeQuery) { case TypeQueryToDB::TYPE_QUERY_GET_ALL_LISTS: diff --git a/ServerLMS/ServerLMS/Systems/sendsystem.cpp b/ServerLMS/ServerLMS/Systems/sendsystem.cpp index fec9774..3debd94 100644 --- a/ServerLMS/ServerLMS/Systems/sendsystem.cpp +++ b/ServerLMS/ServerLMS/Systems/sendsystem.cpp @@ -27,7 +27,6 @@ void SendSystem::setClient(Client *client,QTcpSocket *socket) isSendStopped = false; } - void SendSystem::sendMessageBlock(QString message) { auto messageBlock = emit sigSendXMLmessage(message); diff --git a/ServerLMS/ServerLMS/providerdblms.cpp b/ServerLMS/ServerLMS/providerdblms.cpp index 99ad8fe..baca6c3 100644 --- a/ServerLMS/ServerLMS/providerdblms.cpp +++ b/ServerLMS/ServerLMS/providerdblms.cpp @@ -1,5 +1,7 @@ #include "providerdblms.h" +#include + ProviderDBLMS::ProviderDBLMS(QWidget *parentWidget, QObject *parent) : QObject(parent), dbLMS(nullptr) @@ -202,7 +204,7 @@ QString ProviderDBLMS::getNameInstructorByLogin(QString login) QList ProviderDBLMS::GetListAllInstructors() { QList listInstructors; - + qDebug() << "ProviderDBLMS " << QThread::currentThreadId(); mtxAccess.lock(); if(! dbLMS->DBisConnected()) diff --git a/ServerLMS/ServerLMS/providerdblms.h b/ServerLMS/ServerLMS/providerdblms.h index 5d73eec..06fcc75 100644 --- a/ServerLMS/ServerLMS/providerdblms.h +++ b/ServerLMS/ServerLMS/providerdblms.h @@ -2,6 +2,7 @@ #define PROVIDERDBLMS_H #include +#include #include "interfacedatabaselms.h" class ProviderDBLMS : public QObject diff --git a/ServerLMS/ServerLMS/serverlmswidget.cpp b/ServerLMS/ServerLMS/serverlmswidget.cpp index a72233e..4e7ec52 100644 --- a/ServerLMS/ServerLMS/serverlmswidget.cpp +++ b/ServerLMS/ServerLMS/serverlmswidget.cpp @@ -80,7 +80,7 @@ ServerLMSWidget::ServerLMSWidget(QWidget *parent) : on_btnStartServer_clicked(); first = true; - qDebug() << "WidgetThread: " << QThread::currentThreadId(); + qDebug() << "MAIN THREAD: " << QThread::currentThreadId(); } void ServerLMSWidget::autorizationHandler(QString login) @@ -97,7 +97,7 @@ void ServerLMSWidget::autorizationHandler(QString login) } } -void ServerLMSWidget::sendNewVersionListToAllClient() +void ServerLMSWidget::sendNewVersionListToAllClient() //Выделить в сервис отправки сервера(не конкретный клиент) { foreach(int idSocket,clientsMap.keys()) { @@ -109,7 +109,7 @@ void ServerLMSWidget::sendNewVersionListToAllClient() } } -void ServerLMSWidget::sendCurrentVersionToAllClient() +void ServerLMSWidget::sendCurrentVersionToAllClient() //Выделить в сервис отправки сервера(не конкретный клиент) { foreach(int idSocket,clientsMap.keys()) { @@ -226,7 +226,7 @@ void ServerLMSWidget::slot_BlockAutorization(bool block) unBlockAutorization(); } -void ServerLMSWidget::slot_AuthChanged() +void ServerLMSWidget::slot_AuthChanged() //Выделить в сервис отправки сервера(не конкретный клиент) { //Проходим все открытые сокеты foreach(int idSocket, clientsMap.keys()) @@ -241,7 +241,7 @@ void ServerLMSWidget::slot_AuthChanged() } } -void ServerLMSWidget::slot_sendPacketToAllClients(PacketType packetType) +void ServerLMSWidget::slot_sendPacketToAllClients(PacketType packetType) //Выделить в сервис отправки сервера(не конкретный клиент) { foreach(int idSocket, clientsMap.keys()) { @@ -272,7 +272,7 @@ void ServerLMSWidget::slot_LanguageChanged(QString language) } -void ServerLMSWidget::slot_msgToClientFromGUI(QString login, QString text) +void ServerLMSWidget::slot_msgToClientFromGUI(QString login, QString text) //Выделить в сервис отправки сервера(не конкретный клиент) { QString textMsg = text; @@ -298,7 +298,7 @@ void ServerLMSWidget::slot_msgToClientFromGUI(QString login, QString text) } } -void ServerLMSWidget::slot_msgToGUIfromClient(QString login, QString text) +void ServerLMSWidget::slot_msgToGUIfromClient(QString login, QString text) //Выделить в сервис отправки сервера(не конкретный клиент) { QString textMsg = text; @@ -355,7 +355,7 @@ void ServerLMSWidget::on_btnStopServer_clicked() } } -void ServerLMSWidget::on_btnTaskSet_clicked() +void ServerLMSWidget::on_btnTaskSet_clicked() //Выделить в сервис отправки сервера(не конкретный клиент) { QString fullNameClient = ui->listWidget_Clients->currentItem()->text(); From e46f5459f1dba78b6d610f5ec2bdf5f83198f24b Mon Sep 17 00:00:00 2001 From: krivoshein Date: Tue, 14 Jan 2025 09:36:01 +0300 Subject: [PATCH 03/13] =?UTF-8?q?fim=20=20=D0=B2=20=D0=BD=D0=B0=D1=87?= =?UTF-8?q?=D0=B0=D0=BB=D0=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../docTasks/fimtaskswidget.cpp | 69 +++++++++---------- .../instructorsandtraineeswidget.cpp | 5 +- .../GUIdataBaseLMS/StaticData/authData.xml | 2 + .../GUIdataBaseLMS/StaticData/settings.xml | 4 ++ .../GUIdataBaseLMS/StaticData/temp.xml | 2 + 5 files changed, 45 insertions(+), 37 deletions(-) create mode 100644 GUIdataBaseLMS/GUIdataBaseLMS/StaticData/authData.xml create mode 100644 GUIdataBaseLMS/GUIdataBaseLMS/StaticData/settings.xml create mode 100644 GUIdataBaseLMS/GUIdataBaseLMS/StaticData/temp.xml diff --git a/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.cpp b/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.cpp index 1e30cce..9aff7d2 100644 --- a/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.cpp +++ b/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.cpp @@ -60,48 +60,45 @@ void FIMtasksWidget::loadTasksAmmFimFromXML() nodeMap.namedItem("changed").nodeValue()); QDomElement malfunctionElement = taskElement.firstChildElement(); - if(malfunctionElement.isNull()) - break; + if(!malfunctionElement.isNull()) + { + do + {/*malfunction*/ + QString name = malfunctionElement.nodeName(); + QDomNamedNodeMap nodeMap = malfunctionElement.attributes(); - do - {/*malfunction*/ - QString name = malfunctionElement.nodeName(); - QDomNamedNodeMap nodeMap = malfunctionElement.attributes(); + if(name == "malfunction") + { + Malfunction malfunction; - if(name == "malfunction") - { - Malfunction malfunction; + malfunction.initialize(nodeMap.namedItem("dmCode").nodeValue(), + nodeMap.namedItem("num").nodeValue(), + nodeMap.namedItem("description").nodeValue()); - malfunction.initialize(nodeMap.namedItem("dmCode").nodeValue(), - nodeMap.namedItem("num").nodeValue(), - nodeMap.namedItem("description").nodeValue()); - - QDomElement signElement = malfunctionElement.firstChildElement(); - if(signElement.isNull()) - break; - - do - {/*malfunctionSign*/ - QString name = signElement.nodeName(); - QDomNamedNodeMap nodeMap = signElement.attributes(); - - if(name == "malfunctionSign") + QDomElement signElement = malfunctionElement.firstChildElement(); + if(!signElement.isNull()) { - MalfunctionSign sign; + do + {/*malfunctionSign*/ + QString name = signElement.nodeName(); + QDomNamedNodeMap nodeMap = signElement.attributes(); - sign.initialize(nodeMap.namedItem("type").nodeValue().toInt(), - nodeMap.namedItem("description").nodeValue()); + if(name == "malfunctionSign") + { + MalfunctionSign sign; - malfunction.addMalfunctionSign(sign); + sign.initialize(nodeMap.namedItem("type").nodeValue().toInt(), + nodeMap.namedItem("description").nodeValue()); + + malfunction.addMalfunctionSign(sign); + } + + }while(! (signElement = signElement.nextSiblingElement()).isNull()); } - - }while(! (signElement = signElement.nextSiblingElement()).isNull()); - - task.addMalfunction(malfunction); - } - - }while(! (malfunctionElement = malfunctionElement.nextSiblingElement()).isNull()); - + task.addMalfunction(malfunction); + } + }while(! (malfunctionElement = malfunctionElement.nextSiblingElement()).isNull()); + } listTaskAmmFim.append(task); } }while (! (taskElement = taskElement.nextSiblingElement()).isNull()); @@ -118,5 +115,5 @@ void FIMtasksWidget::updateListWidget() void FIMtasksWidget::addTaskFimToListWidget(TaskAmmFim taskFim) { - + ui->listWidgetTasks->addItem(taskFim.title); } diff --git a/DB_IaT/InstructorsAndTrainees/instructorsandtraineeswidget.cpp b/DB_IaT/InstructorsAndTrainees/instructorsandtraineeswidget.cpp index 1a66ac1..f4ca390 100644 --- a/DB_IaT/InstructorsAndTrainees/instructorsandtraineeswidget.cpp +++ b/DB_IaT/InstructorsAndTrainees/instructorsandtraineeswidget.cpp @@ -12,6 +12,7 @@ InstructorsAndTraineesWidget::InstructorsAndTraineesWidget(QWidget *parent) : viewerInstructors(nullptr), messangerWidget(nullptr), docTasksWidget(nullptr), + fIMtasksWidget(nullptr), adminMode(false), loginInstructorLoggedInLocal(QStringLiteral("")), nameInstructorLoggedInLocal(QStringLiteral("")) @@ -79,6 +80,7 @@ InstructorsAndTraineesWidget::~InstructorsAndTraineesWidget() deAuthorizationInstructor(loginInstructorLoggedInLocal); delete docTasksWidget; + delete fIMtasksWidget; delete messangerWidget; delete viewerInstructors; delete viewerTrainees; @@ -119,7 +121,8 @@ void InstructorsAndTraineesWidget::updateMyStyleSheet() QString InstructorsAndTraineesWidget::loadStyleSheet() { - QString fileName = ":/resources/css/styleSheetMain.css"; + //QString fileName = ":/resources/css/styleSheetMain.css"; + QString fileName = "./resources/css/styleSheetMain.css"; QFile styleSheetFile(fileName); if (!styleSheetFile.open(QFile::ReadOnly | QFile::Text)) { diff --git a/GUIdataBaseLMS/GUIdataBaseLMS/StaticData/authData.xml b/GUIdataBaseLMS/GUIdataBaseLMS/StaticData/authData.xml new file mode 100644 index 0000000..69f75cd --- /dev/null +++ b/GUIdataBaseLMS/GUIdataBaseLMS/StaticData/authData.xml @@ -0,0 +1,2 @@ + + \ No newline at end of file diff --git a/GUIdataBaseLMS/GUIdataBaseLMS/StaticData/settings.xml b/GUIdataBaseLMS/GUIdataBaseLMS/StaticData/settings.xml new file mode 100644 index 0000000..9aafbf5 --- /dev/null +++ b/GUIdataBaseLMS/GUIdataBaseLMS/StaticData/settings.xml @@ -0,0 +1,4 @@ + + + + diff --git a/GUIdataBaseLMS/GUIdataBaseLMS/StaticData/temp.xml b/GUIdataBaseLMS/GUIdataBaseLMS/StaticData/temp.xml new file mode 100644 index 0000000..40e39ea --- /dev/null +++ b/GUIdataBaseLMS/GUIdataBaseLMS/StaticData/temp.xml @@ -0,0 +1,2 @@ + + From 2f58227e114b1fdf17e174ed8ae9a7cbd627fa43 Mon Sep 17 00:00:00 2001 From: semenov Date: Tue, 14 Jan 2025 09:41:12 +0300 Subject: [PATCH 04/13] test update obsidian --- DOCS/.obsidian/workspace.json | 18 +- DOCS/MainScheme.md | 142 +++++----- DOCS/Алексей/DataParser scheme.md | 340 ++++++++++++------------ DOCS/Алексей/ProcessingSystem scheme.md | 44 +-- 4 files changed, 275 insertions(+), 269 deletions(-) diff --git a/DOCS/.obsidian/workspace.json b/DOCS/.obsidian/workspace.json index 1ee8c5a..46000b6 100644 --- a/DOCS/.obsidian/workspace.json +++ b/DOCS/.obsidian/workspace.json @@ -65,12 +65,14 @@ "id": "9608f84166966ca9", "type": "leaf", "state": { - "type": "excalidraw", + "type": "markdown", "state": { - "file": "MainScheme.md" + "file": "Как умеем принимать, как умеем отправлять!.md", + "mode": "source", + "source": false }, - "icon": "excalidraw-icon", - "title": "MainScheme" + "icon": "lucide-file", + "title": "Как умеем принимать, как умеем отправлять!" } } ], @@ -219,16 +221,16 @@ }, "active": "9608f84166966ca9", "lastOpenFiles": [ + "Порядок сборки Unity билда под сервер.md", + "Образец отправки сообщения с маркером.md", + "Как умеем принимать, как умеем отправлять!.md", + "Алексей/Board.md", "Алексей/DataParser scheme.md", "Алексей/ProcessingSystem scheme.md", "MainScheme.md", - "Как умеем принимать, как умеем отправлять!.md", "AssetManagerScheme.md", - "Образец отправки сообщения с маркером.md", "Что умеем отправлять Server - Client QT.md", - "Порядок сборки Unity билда под сервер.md", "CLIENT SERVER.canvas", - "Алексей/Board.md", "Алексей/Рефакторинг.md", "Алексей/ТЕСТ-КЕЙСЫ.md", "Алексей/Чек лист по переносу.md", diff --git a/DOCS/MainScheme.md b/DOCS/MainScheme.md index 491fd99..05b3183 100644 --- a/DOCS/MainScheme.md +++ b/DOCS/MainScheme.md @@ -312,144 +312,146 @@ vjp5juP/vp50x1YK742qJEI6SJOcAou5EgdnrPpRSZ4HlBUcQsfu4p+8AYWGb6eUSbYbWcsdtY0hSsYX wJ54TnIcAxmsgmVyqCagDoJnrJgnYJuCfgmEJGWqIm5a82vlpLaQ2k5qUJ5WjQlzhKQeGJMSrfq64aRqdus45sF0d/G/xMcv/GAJwCWwnqBYCZwncJMCXwkCJ7AUIkiJvTign1yaCU5rSJOCTxhyJHAEQmKJ6csolkJRWuolramibQnF2t0g9GKhWSjh5V2ecWm67mJ2J9HI4o/P9Lt2uvkujVxKsUwLLguDLbgzASJHACWhDwfaHwxtof0QVJXc -dqYmqXwejEOR5eGfCJApphVDqQU0bsau+G0FpAJwFUPyCpuyFhTHEuAUXCGoctMf6r/koHODCagloDJAyQaMOVL7x1YLnxsiSmORgIWgyfZ4teEil+KG8HLsmrGJXcdfHkhJ7rMK7AhUQN7rASXO0C4A5RMuAAg9ALgBTAmvqQAzApaPZgHA2Scg5V2FnB1G4QlyUwJe4/QFnovAkgBDp4MDShejMARgF7hAghAHABQA8QG8LsQuHoAL/JBUaJBX +dqYmqXwejEOR5eGfCJApphVDqQU0bsau+G0FpAJwFUPyCpuyFhTHEuAUXCGoctMf6r/koHFHQt2QNimGYhVoHHBsiSmORgIWkZrzESKX4obwcuyasYldx18eSEnuswrsCFRA3usBJc7QLgDlEy4ACD0AuAFMCa+pADMClo9mAcDZJyDlXYWcHUbhCnJTAl7j9AWei8CSAEOngwNKF6MwBGAXuECCEAcAFADxAbwuxC4egAt8kFRokGckSAnwOmDV -JEgJ8Dpg1UTN4O48phuwVAFkkCBQKLuNbi7o96uBBoppKhikgQgKfkQO4DwGuzLg+gBejtAQIOUQUAUwJ8DNEQgMqqOgtwD0otR8bq9EdRXUVSFlhcoMDjPxVYa/E1hw0TvD6g9jCnCsQ5GL9QGiDYZ/FNh6AG8BMAjQA7gAgGqga7rR6wPqmkAhqcak6J2lnokuuMRthETmPfhnZmiFqVakmpg/mh5nOq5tJEJJuAnh75x8+CCFFxsvh1j+SkFu +RM3g7jymG7BUAWSQIFAou41uLuj3q4EEimkqKKSBC/J+RA7gPAa7MuD6AF6O0BAg5RBQBTAnwM0RCAyqo6C3APSi1Hxur0R1FdRVIWWFygwOM/FVhr8TWHDRO8PqD2MKcKxDkYv1AaINhn8U2HoAbwEwCNADuACAaqBrutHrA2qaQC6p+qTonaWeiS64xG2EROY9+GdmaImpZqQamD+aHmc6rm0kQkm4CeHvnHz4IIUXGy+HWP5KQW7dm3zY2JwQ -3Zt82NicELBBjsCmgp4KTbi4MUKTClwpCKUikop5SZ3HIWCMcb7WhBCqJ71JixvZGIuzSaRAGg6YY2DqpeMUXyjAXELJCfY9BFJCaw/kVTERONMcFGTJD7usZJO0ZiIj2mhvANacQEFqXBlwx3G848xMGJeBPCvJpAAHJyfsSFqUnnuLE+e3Kgj7SxAXg/FemMqbOkq6BDirG4+6sRLqaxz3DrEFJRSSUllJyDvawmxXYJZ42qJ3OpBnQE8LhD2x +sEGO/yYCnApNuLgxgpEKVCkwpcKQinlJncchYIxxvtaEEKonvUmLG9kYi7NJpEAaDphjYMql4xRfKMBcQskJ9j0EUkJrD+RVMRE40xwUZMkPu6xkk7RmIiPaaG8A1pxAQWpcGXDHcbzjzEwYl4E8K8mkADsnJ+xIWpSee4sT57cqCPtLEBeD8V6YSpk6SroEOKsbj7qxEuprHPcOsQUlFJJSWUnIO9rCbFdglnjaonc6kGdATwuEPbGOxwlNXgUC -jscJTV4FAj5Ayg+FlH5fMHsQl60O8ID7HkOzQixxaxDmDrFqACAA8D0AW6KbGvpN6abGIsV3kxBuwA8BRpEQr6coAOxJzEkCTQYmKH7GCEFohmEAAGYHHL0PsZirE+NDl7GyswcXdaEqLDuHH0+kcYz5cODnAjBiw8EOAgCxb8KqD00jCspDDp8kKOmPp2sKtQHCwvtI7ZxsjnG5rB25skky4rKJ9Fa0rEFJBxm5cYlxCAgMQY7QZsGfBnfJ0Ovr +PkDKD4WUfl8wexCXrQ7wgPseQ7NCLHFrEOYOsWoAIADwPQBbopsY+kXppsYixXeTEG7ADwFGkRCPpygA7EnMSQJNBiYofsYIQWsGYQA/pgccvQ+xmKsT40OXsbKzBxd1oSosO4cfT6RxjPlw4OcCMGLDwQ4CALFvwqoPTSMKykP2nyQg6benawq1AcLC+0jtnGyOcbmsHbmySTLison0VrSsQUkHGblxiXEICAxBjuBmQZ0Ge8nQ6+vk8GH+VSdC -5PBh/lUnQiJvsjFzG5/uJ7OOugq9DOwXpkLaN6Qqud5MQxkHrDykjCgISzArac/bRhrpp2kemCeLxQAkikONDjQ7LJiHgBwPnPoJI+fJ0DpRF8YulQS2UaxZnJnDnG5AxEAPGmEAYKRCnJp0KbCnwpiKcimiptKTboSpZhFKncWaGfd5ypXUrbZvxLhvWE1mH7p4brAAILzzqAjosQBPhHAAABUYQJalMARqW8AhyA2cWjPgzIDkxvAMAHaDpAE2 +Im+yMXMbn+4ns466Cr0M7BemQto3pCq53kxDGQesPKSMKAhLMCNpz9tGGumraR6YJ4vFACSKQ40ONDssmIeAHA+c+gkj58nQOlEXxs6VBLZRrFkcmcOcbkDEQA0aYQBApIKfGngpkKdCmwp8KYKmUpNuiKlmEYqdxZIZ93lKldSttm/EuG9YTWYfunhusAAgvPOoCOixAE+EcAAAFRhApqUwB6pbwCHI9ZxaM+DMgOTG8AwAdoOkAjZbmLgAxofG -W5i4AMaHxjDZE2QCBjgI9M0SSAvWW6lMAUSaalxKXWX+C7ZXTP1lDZBqaNnGpE2VNliAM4LNnzZJwPoBLZ+4CtlrZB2YNmbZ+ANtlnZTTPtkEJ2iXM5M8dqRhEGJjqWdHSieQWaInZWQH9l9ZE2cNnupt2ViD3ZrAPBhzZC2S9mDZy2atksAn2QNnfZv2XtlXZgOShGepEbvdHnOMbn6l5KbDoGk361oJ9Gjp6ENzF6h1AtsCr+8qvkQ3JdyQ8lP +P1kjZAIGOAj0zRJICdZTqUwBRJhqXEptZf4JtldM3WX1k6pg2fqkjZY2WIAzgk2dNknA+gHNn7gC2Utk7ZvWatn4A62UdlNM22QQnaJczkzxWpGEQYm2pZ0dKJ5BZogdlZAX2V1kjZ/Wc6mXZWINdmsA8GFNkzZD2b1nzZi2SwCvZPWe9mfZW2Wdm/ZKEa6kRu90ec4xuXqXkpsOvqTfrWgn0YOnoQ3MXqHUC2wKv7yq+RBclXJNyXckPJjoE8kv -JLyY6BvJHyRkBfJrcTmnmZuCkjHWRjoTZnOh/ca6GORn1gkglWIsKVh46IiL9QEYTeKQSFKnMIkIqg/4uGFXiI7v5krxQUWvFdpUXHHCkYJfKxArCiWSzEzIS0LhrSUloFpD0Ms+nQTMsTwI+zzpK+ill1SaWcekNe4JrlFIBd8QK6o+3FjumG8/FmF4Kp7/GrEUO4Gaen5E56cUm3ApSUbFIZd6bZCGoKuREgbwkMNhm4ZsFAqC8W1oIskAcXtN +JGQG8mtxGacZm4KSMdZGOhFmc6H9xroY5GfWCSCVYiwpWHjoiIv1ARhN4pBIUqcwiQiqD/i4YVeIju3mSvFBRa8W2lRcccKRgl8rECsKxZLMTMhLQuGtJSWgWkPQyz6dBMyxPAj7NOkr6CWXVJJZ+6Q17gmuUUgF3xArqj7cWG6Ybz8WYXjKnv8asRQ7AZh6fkTHpxSbcClJRsXBlXptkIagK5ESBvCQw6GZhmwUCoLxbWgaMNiIkiAKu7GexDOA -DrkZRusBmSx3/DF5HplDk/w0Znsbir0OzGebphxT1rbrkmOXlxkMoexjbkG51cJhCiovbJQRleTykTJNRHuRnHLMWcWfy05nJm9GfohHjL5I21LvMClw7CgcFXMHbNGl1GpwQY6SAy4OUSnkzAGnrK+WaZZmVJ7cdUnZpyOjC62RDSbjIYxQFsqDowtkJsSvwFXlMznetMAYjcICilqAOI00H5lRh5uR2mW5wWVMkLwLuZaDJCtsf7AsxBhhAF8G +Bkxee6ZQ5P8FGTXlBx9DvRnm6YcU9a265Jjl5sZDKHsYW5OudXCYQoqL2yUEZXk8pEyTUS7kZxyzFnFn8lOZyZvRn6IR4y+SNtS7zApcOwoHBVzB2zhpdRqcEGOkgMuDlEp5MwBp6yvmmmmZlSe3HVJ6acjowutkQ0m4yGMUBbKg6MLZCbEr8BV5TM53rTAGI3CAopagDiNNBeZUYcbktppuf5lTJC8A7mWgyQrbH+wLMQYYQBfBhhClwcWW557J -GEKXBJZbnkcnyyweby7FhmKTSlMCuKQgD4p4wISmYAxKaSnkplKdSk/J/qeikgQnUdVk9RtWdhD1Z+Djxr0h9trU6tZ9ToQFusIckB5QA3wNYDEAwQKQBoAO2b1mI5bTJjnPZE2YEB6APdOfTKFi2YNmCAIWG3z/uJEmIXIekhSsAyFchfDmKFKwFoXY5A2WoVsAGheHTWFiOTZRt8IHqPIHREHkdGc8hieKG4RkoYYUcA4hSYXSFTAOYUKFOhUo +8sv7m8uxYaikUpTApikIA2KeMC4pmAPimEpxKaSnkpHyd6nIpIEJ1HlZPUZVnYQ1Wfg48a9Ifba1OjWfU6EBbrCHJAeUAN8DWAxAMECkAaABtmdZsOW0yo592SNmBAegD3Tn0chbNm9ZggCFht8/7iRKCFyHiIUrA4hZIXQ5MhSsCqF6OT1mKFbAMoXh0ZhbDk2UbfCB6jyB0RB5HRnPIYnihuEZKE6FHAEIX6FYhUwBGF0heoWyFd2WoUWFCAEo -VPZ2hbYUIA6hd0GOFURTYW6FuICh53R3qWP7l2z0a1EBpSmaFyfRiUVPDqQ7dgbjHBp+bGnYp6AACDYA/QMZKnkOvmwCtAuDCMBe4MwAHiOAAeC8DOAFHlaHS5bcTY6WRD+bUmFpZeh/lNuFCiWBxAjenMDTAskCea1petBnAZIVoAXyygVoEbmwc0hpTFm51MeMlBZzOt4LYQNNDWB4sloK7Aci0fiLIqQleXzpemyxZIZe5KqdS4UQeBYclLyI +XdBNhaEXmFGhbiAoed0e6lj+5ds9GtRPqXJmhcn0YlFTw6kO3YG4xwQfmRp6KegAAg2AP0DGSp5Dr5sArQLgwjAXuDMAB4jgAHgvAzgBR5Wh4uW3E2Olkdfm1JuaWXrP5TbhQolgcQI3pzA0wLJAnmlaXrQZwGSFaAF8soFaB65sHNIaUxRudTHjJfmczreC2EDTQ1geLJaCuwHItH4iyKkKXl86XpnMWSGbuQqnUuFEJgW7JS8iCZLWYJj7H+ep -JktZgmPsf56nuW6b7DcFYXPHkDRieUQ6ycePtF6oqx1v7FE+W1IBl0ZRnAxk0+qXtT7Eqr0Vl6D5TPrl6O6MsNUg/sJxdYJwaBhK+LYiNxbJB3FS+SL51eldhcKKZRvG5a/R2+eUDGIvEDjHt2oglXFaR/XkwLlEu6LgyEAAeHADW4RmekKmRpmY/n9FHcYMUFpNkXC7M2n+U0lSgLzvfSTRg7sRAK2lVmEKI4eZKhB2w00HWDQFy8TsUPiexTLa +7mum+wbBWFzR5A0bHlEOsnHj7ReqKsdb+xRPltS/pVGUZw0ZNPql7U+xKq9FZePeUz65ejujLDVIP7PsXWCcGgYSvi2IucWyQlxbPki+dXpXYXCsmUbxuWv0WvnlAxiLxA4x7dqIJVxWkf15MC5RLui4MhAAHhwA1uHpnpCpkYZk35XRR3E9FOaTZFwuzNi/lNJUoC8730k0YO7EQCtpVZhCiOHmSoQdsNNB1gYBcvHrFD4psUy2ujGMARC3kFiL -6MYwBELeQWIseCiMLMfSWbuB8URyYYadP7m5O+Ydy4nJUsc1LFOpYVwVuwtIQnn8F97oIUWK2qe1ku26wA7j2FygEwDyF52RNkRlygFGWVxcrIa59ikZdGXw5F2fGWJlNqetJcmkHpkE+F2QQQXQ5JElmXplvWZmVplSZah6U56RYsE05OcdkX05uRW0DK6SkZcpvQ9NFo4Y2G5Fzlnq+RL8ANKxoC7gXo+gA0pboXuM0Re45RLUTPMhAPEAAgy3 +HgojCzFUlm7gfFEcmGGnTe5uTvmHcuByVLHNSxTqWGsFbsLSEx5XBfe48FFiuqnNZLtusAO4VhcoBMAUhcdkjZwZcoChllcXKyGufYiGVhl0OSdlRlMZRanrSXJpB6ZB7hdkHYF4OSRKplSZZ1kpliZbGWoepOUkWLBFOTnFpF1ORkVtAyukpGXKb0PTRaOGNhuRs5Z6vkS/ADSsaAu4F6PoANKW6F7jNEXuOUS1EzzIQDxAAIMt7tFApZ0VVuWa -j0WilfRVW55pvRVKWy57+cWmNJpaQqXMsUdPxArQsdFrlEghsKaBlwZ8ETA6w+pRLYxh8BfsUhZ1oHHAkQt9jsT4iqYarTEQeFssiQwqcMeBCs8Fmrlt4LxQumulqfkQUrpqDk3mrWt8TLHdR3pV6Z1ZAJdbbKx/XoekUOVPn7GmKAcQ3nwl3eSHFkOaXoxn95aJa9YcZscRVTPlGkA4jeZ2cJGrFA35RbG/lGSH/jklMmavmNlYqUkm0l3bDKCf +R0WilkuU/n5pjSYWnSlzLFHT8QK0LHRq5RIIbCmgZcGfBEwOsFqUS2MYVAVbFAWdaBxwJELfY7E+IqmGq0xEHhbLIkMKnDHgQrPBZK5bePcUzpDpan64FC6ag6SxweSunvFbtDn5VZ3xdbbKx/XrukUOVPn7GmKAcUbrUZbeSHFkOaXrRld5iJa9YsZscRVR3lGkA4juZ2cJGrFAb5RbEflGSH/hElEmQvk1lQqUkkUl3bDKCfR6oNFziKIpngay -R6oNFziKIpngayQumRUWGO9ANr63A2IC8C9l9+fmlqma5RC75pr+T3Fy5fcSWl7ezSZlKHlGSKcT60DCrYhni+Gu7mBhZceTGbFIyW2mBRcBU+JxhuEo8AJAG0KWDC2G8I+xEaosrFlWMvEFqBjAoFQHngVV8UQWIBG6T8Vu0OfshV+lQJQGW1hjIUIWyun7u2au0MZU0wXZb3M6BZAWIPCAE5QYtkBdZIvNmVP6ZopeQpVGZRNkZVwdNlUyFE2X +QmmcUWGO9ANr63A2IC8AdlV+dmlqmi5RC7ZpD+T3FS5fcQWl7ezSZlI7lGSKcT60DCrYhni+Gs7mBhZceTErFIyU2mBRkBU+JxhuEo8AJAG0KWDC2G8I+xEaospFlWMvEFqBjAAFT7lAVV8bgWIBkFa6Xh5XprBWelvxd6W1hjIbwWyun7u2au04ZU0wnZb3M6BZAWIPCA45QYtkBtZIvGmVP6ZopeRxVyZSNlJVwdKlXiFI2RlXMAWVdEANanhv -lXMABVdEANanhvtGg5h0RkHHRnfqdE5BUOaYnJVUTKlUI5g2ZVVZVLoDVWDZdVQ1VFV4bqc4xJ1Ob6lcVCmYm68VMGIpFh6cRBRAEWEUX5Yng4lUwI35AIM0QzAMAMY7i5SlYJ7rlK5ZuUoxvcWjFyle5UVatQbjmsKZOk8YMnM0JVtd7cwd0ImHtQt5f76BZD5SaWGe2Loai0mn5dPq2MROJMCvuQuq56vFdGu6Xh5YVeclyO2WbcCaADSnPYXo +tGA5h0RkHHRnfqdE5BYOaYmxVUTPFUw5vWcVUpVLoGVW9ZFVVVU5V4bqc4xJ5OZ6ksVMmYm7sVMGIpFh6cRBRAEWEUX5YngglUwLn5AIM0QzAMAMY7C5MlYJ5Ll85SuUoxvcWjGSlm5UVatQbjmsKZOk8YMnM0JVtd7cwd0ImHtQF5f76+Z15fqWGe2Loai0mL5dPq2MROJMCvuQuq54PFdGk6UQVLpalm0p6wLcCaADSnPYXo2IM4AUAmALcAIK -2IM4AUAmALcAIKDSoQCOgp5N8AwAxALgzlZvyawUwVFyVilMCCABuzYgXuMQzKAl5M0RYMMaKWikAtRCuAu4cAN0VYp1NXSlsFkqZwUK2J5q9QNZvUsCV4BgZaX4JVs0UlXoA4hagDfuAzqrXq1wOakF5lXhb/onRMHsWW9VKtch5q1sqtElQGc1ZkUyRKoTkXLV3ImVCqZRVKSSlw3ZUermgu1fkTo1mNQgDY1uNfjWE1xNaTXk1lNcuUYKoLrQ +DSoQCOgp5N8AwAxALgzFZnyQwXgVNKWilMCCABuzYgXuMQzKAl5M0RYMMaKWikAtRCuAu4cAG0VoppNVSmMFoqSwUK2J5q9Q1ZvUn8V4BPpaX5RVs0TFXoAQhagDfuAzvLWK1/2akGZlrhb/onRMHnmXtVctch4K1sqtElQGE1SkUyRKoekWzV3ImVCKZRVKSSlwbZUermg61fkSI1yNQgCo16NZjXY1uNfjWE1xNXOUYKoLrQaHVclcuUKV29qj -bnVKlRuVqV29qjGjFV/hQqzxzsa7Cnw6qH+l+hQDPKD75PiJhCnikIX9UBZ47oDXD6dKhMDlmPEFhAJRmIfbkKgTsA2A7ETwMwhMys+gRn5Y6IQFUulBBe8XMFnxbTXrpnpZSHi1F7sYKDJgJWhVn5qsaCWt5qeXKI6x+1YdXHVd+denPgyGaKCCMuYKNQtusydrCl576dPnCl9eaT6N5a6b7F66s9drH5E/QMuCXku6JeQxoQIO0A55q9V2DOAe +EDFV/hQqzxzsa7Cnw6qF+l+hQDPKBb5PiJhCnikIR9U+Z47t9XD6dKhMDlmPEFhAJRmIdbkKgTsA2A7ETwMwhMys+jhn5Y6IV5X2l2BU8V0FLxeTXoOt8TLHdRbpULXGCgyT8UIVh+arEAlDeYnlyiOsZtXbVu1Zfnnpz4PBmiggjLmCjULbpqAzQXtFOlF5Edd+kt5pGZ3Vec9eQnkAqIGVkA6x/QMuCXku6JeQxoQIO0AZ5C9V2DOAeYARxlQX -YARxlQX4iAjnwYUHvUPuXEMeDqgAyRKpPKpGUfVAZ+AFRm4Vx9fhXk+xKqHE95jXgPnkVrPpRV5e8EGXX1Ip4DKCJRDBK1geZ9dQRmkQtMnyRSZSzBSWyZYvtxU0l+vHuZF47ZQopDcTsE77o27tU/V9lN5lfU31d9Q/XsNClRuVnVRvtHWXVsdWJ7y5WlQPFK5QCGYxawBOjzbYUwBQMiYsIahsm326xZwo++WxTAWGlaGpO6IFGGEOgPYUWU7l +4iAjnwYUIXnPpEwFxDHg6oAMkSqTyoRnEZGFfgBkZ6FaT6YV5PsSqhx7eY17d5hFaz7EVeXvBAF19SKeAygiUQwStYLmZXU4ZpELTJ8kYmUszElkmWL6sV5Jfrx7mReE2UKKQ3E7BO+6No7X31nZTeb5EF9VfU31d9ftWr2Idd0XyVX5opVrl8LipUDxcuUAhmMWsATo822FH/kDImLCGqrJt9ksWcKPvqsXgFOpWhqTuMBRhhDoD2GFl25dOZFl -M5sWWMD4aXpE6UEhyWUFWixG+qclwVKDYynrA3tVjU41eNQTWXkRNSTVk1FNVTUsFItb55i1iFSPX4E0VRPXlFDIUGUVqIZSIWdZvPANUXZsOfiArAvTBNmlVUTIMAj0FQDABvoUZVACI52ANUCBF6YCFiA5A2Q9SkAq8suAexJsd2q1V8IHk3Bi5OWtHHZCTeVVfZvPCk3EAaTYNkZNGaFk2EAOTU00FNOhUU2VgJTbEW4g5TZU3VNtTcfS5VjT +jA+Gl6S2lBIfFk+VosRvqHJ3dUg3w1EgK7Uo1aNRjVY1l5DjV41BNUTUk19BXzW+eAtX3UXu6paFXD1RRQyG+lFav6X8FrWbzxdVJ2ZDn4gKwL0wjZ+VVEyDAI9BUAwAb6KGVQAsOdgDVAPhemAhYv2T1kPUpAKvLLgHsSbHdq5VfCA5NwYsTlrR+2XE2FVb2bzxJNxACk29ZaTRmgZNhAFk0NNeTeoUFNlYEU0RFuIKU3lNlTdU3H06VfU0kAuT -SQD5NzAC018hLVWkFtVwod4UQ53VbKwllbrLDmJNG2V02jovTQNn9NJwIM3DNyzTuSFNxTY6ClN0zRNmzNBADU2xFCzeU0EA+ACM2rNokbdFeps1T6nW1a+SxlNe3JrdBbq12iKoBONMPLTbVKVqUU92kpusCM1zNazXs1nNdzW81y4PzWC1HRCKXh1hvg5IXVRLe8HWZ25fC4SNiueXjg4ccLdAw4CSCFJiMCmAkD115oHnU0WhdbAW7FJdcoYh +cwBNNfIXVVpBDVcKFuFIOa1Wys+ZW6yQ58TStkdNo6N009ZvTScD9NgzYs07k+TYU2OgxTZM0jZ0zQQBVNERXM2lNBAPgBDNyzaJG3RbqeNUepptYvkMZTXtya3QW6tdoiqATjTDy0q1SlYFFPdpKbrA1NbTX01jNczWs17NcuCc13NR0T8lgdYb4OSR1QS3vB5mSI0SlgxUBbg4ccLdAw4CSCFJiMCmAkCV15oBnU0W2dRAUbFedcoYh+YmKQgw -+YmKQgwCmmcsmiqCEOUiKQ7sIbQZh4jAvBhQ8ip3XfKl8XY1McUFWHmwVEefBU1ZEtaPXhNL8Tj6Re59QCoQZWQPPWfAB1UdUnViGS/VSg/iGeIM04ikhCs6dJm+nfmdeZ3kokIGS3mYVUJe3kwlFGUl74qJFeCV95SDWRWDMFFe9ZDMTwKNH+UJoMK3jUahOawSt6oFK3gW7FSvn9SoLQo6S+dJfQ1rVc5F9V4sE6ezlpEaEJ7XrA4wOURjeIwB +CqmfvFtA5rOUiKQ7sIbQZh4jAvBhQ8is3XfKl8TY1McoFUHmrW9jVBX8c5tsE2R+oTS/E4+kXnroT12sX3afAW1TtV7VsGY/VSg/iGeIM04ikhCs6dJk+nfm0OqA1QN4DQfW+xIJWhVglL/G63pMyXvA1wN6XgiUM+SJURXvWQzE8CjR/lCaACt41GoQit3kGK2kIErYxXz5/UsC0KOkvpSW0NC1XOQvVeLCOnM5aRGhDO16wOMDlEY3iMAUAW6I -QBbojoKdWr2UdQMWqVX5upWUtspWMVAWhFgaBJYpoBiyWM8xbhJXQwSK1ClQIsGrYLxEYUvF3lANfZXrxjlbIguVP+fO6YhvECRqz6Y0SqC+VirUSG2NS6SFVFhGWSWHR5OrWE3S1v3LLXTROAY7ZtZcTTilug0zcc0RFVhYkUVVrtJlX2gOVeU12FDhSMRvtg2T+4xo4hc4V6Fr2VEB4562YNmSAoQJIARoU+GTn/NyZWakPtpAE+0dNl2a+1Y5 +6C8NVNkb6h1x1eHVie0uWI2y55eIRYGgSWKaAYsljFMW4SV0MEitQpUCLBq2C8RGFLxl5V9WWV68dZWyIdle/nzumIbxAkas+mNEqg7lXK1Eh1jXOl+VRYSlklhQVcE34EOrdKnhVOAY7ZNZMTRilugkzYc3BFphTEVFVrtMlX2gaVaU2WF1hSMTPtvWT+4xoQhXYWaFj2VEBY5y2b1mSAoQJIARoU+ETm/NcZUam3tpAPe1tNp2U+1o5L7VExvt -77VEyft1VQTm/t8Rf+3YdgHY6DAdyHqB0pF4He9n455TTB3MAcHQYAIdh2c1XuFrVZ4XtVOzQbU4RzqXhEkSnwI+3llsZS+3EAThUNUftVVaNUEdsRfYVEdYnQNlAdIHToUuF1HZB0E59HYx36AzHUDnTV8wfKGvyj0UqFyZskaRXyR8YV9IFtKYBFG747YqKa/AvHki01xh5HilCABKUSkkpcAGSnW4FKVSmNtVNkI0ttMdW21x1N1QnVf51vvM +pVTjlftURT+0Ydf7Y6AAdyHkB3xFIHc9nY5pTZB3MA0HQYCwdu2bVVOF9VS4WNVWzVrU4R9qXhEkSnwHe1FlEZY+3EAthT1WvtJVf1W4dERVYX4dwnT1n/tgHeoX2FFHWB045NHXR36ADHX9mjV8wfKGvyj0UqFSZskfhXyR8YV9J5tKYBFG747YqKa/AvHgi01xh5FilCAOKXikEpcAESnW4JKWSn1tYLkKV35IpS215pojRuWqV0pcjhJAgJDp -l2tEsjpDwWyNgTHv1lkBUZ/Q0Qty06N1xg5XmsOkKTCrCNFTWBneorb8Z+CxDYpBbKIrbIq/4hSmMCCw8TM6VKtgeccmQVHxXD791Moo43hV/HDn6x5erfKkGtSKmCUX1kGenmFJmednnWtt6WbEMyY0HvkzFpxMVSutauH4KdA7kWD600YDR62UZLXaBnoqA3aa35EF+Vfk35nwMvVGs43ShmBIpEKViiZyjRjB/1n6IkALJk+QzRzJ0Gmt2wlD +DwWyNgTEv1lkBUZ/Q0Qhy1aN1xlZXmsOkKTCrCZFTWBneQrbhJewZEHwY25MVEKyFKYwILDxMdpfK2+5+ySBXPFcPh61vFgVR8WAIkqRwWVOerUiqAlhraBnJ5hSannp5FrZelmxDMmNCb54xacTFUTrWrh+CnQO5Fg+tNCA171SaHXnAlXXSfVJ56wMfmn55+Z8Bz1RrEN0IZgSKRClYgmYo0Yw39USCJAMkOyK65e6i0mLdEJbXket5GeCUkZS -OFA3QlL/DA3pMyXog0IN6XqiUM+6JZG3M+NKi1S58jiDl2vlN8H5BewZEHwYO5MVBm0nClDVSV05EcQzlJE+RbHRKg6MCJXu175Bw2924ZSyl1x7KZyncpvKfymCpwqfHph1gyivb+dJLcI1ktVmW/kyll/uF1uhMkH/ACip4AohAkWLrZA/Il4NchYUf9N76LxWjQaXtpvLfO1W5F3oVC1wPiD2wxc0WWV7w9rKM84+mE/JeBYiIrLu2ZRbpY12 +Xvip4VQJZ3kINBFYMzhtzPjSotUufI4iZdD5TfB+Q+Xe/WKQWyt1AkNnnHPknC5DaSVU5EcTTlJEWRbHRKg6MHxWO175Gw292QZQyl1xzKaynspnKdym8p/KfHoB1gyivYNtRLU20ktZmY/nill/q/nW+MkH/ACip4AohAkWLrZA/Il4NchYUf9N76LxGjdqXNpXLbO1m5F3oVC1wPiD2wxc4WWV4FdrKM84+mE/JeBYiIrNu2ZRjpbV3t19XUuk -91zXafXfFXpae1eIsqbwWVOvXcnlgZxrWnnrAGeZenP1p3evUnmmMLlA9JgTrd33CCoDJA/pCWefCJth9et1JoXrRCVglhPn61fdEDT91BtiJUxkA9dtS9YRtqDVG0cZdEPjDZwTykaA58p5jYga9X4lr1/BV9sj0+6nFcZ0qhPFbQ300n0R3Cwwv3ttUNtRPSi0SA9AJDrYgcAEYD4AzUfT256xLfQZjKQXd3EhdGlbdVdt1vkWCtUjIn0kKev9 +yiarU13QV4qfbBR58Fbq07p+rWt0Hpk9b10npaeWen7di9ZZ4osGoLlA9JgThd0NlCoDJAfpMWefDxtfJa61/p7rSb2AZpDt61N5r3WA3+tH3TCV0ZwbRbUvWf3cg0RtLGXRD4w2cE8pGgOfKeY2IqvV+Lq9fwVfZptiPcxUGdKoWxXUN9NJ9EdwsML96rVdbfj1ItEgPQCQ62IHABGA+AM1E09ueoS30GYymHVCNO9UpXnVlLdb5FgrVIyJ9JCn -ed6KK6iPoKgcS3ShDzxxufsrWV2xbL1GlfLQcWVw6GNBrkY6BaK2kwxnkDbFeJJJGa/4rdqX36ghvSLEHtttEe1tdlvWbaf1QSEWDc0F7err9eUTVLSjwZUE7DeQ4cLtwfxoZV/ESAlsoXQRyocl7KxywzstqF0NrhXSesedu3Jpy37s4Ba1R2V65V0CA0gMxyKA0NpoDWrpgM+22A2bV4D5tahFJ2Hhazz5lHVXEZFlHri6mly8A4gO1yyA0nKo +l/Xneiiuoj6CoHLN0oQ88frn7KplWsVS9updy3bFlcOhjQa5GEgW5dpMMZ5zJqKCSTrJfNkTBl9+oHr0ixe7bbQHtZvZSHZ+b9UEhFg3NKLW/c4tdNEl+8ZGVBOw3kOHC7cH8QGVfxEgJbKF0EcqHJeyscsM7LahdDa4V0nrHnbtyact+7OAKtXtleuVdIgPIDMcqgNDa6A1q5YDPtjgMG1+A4bWoRSds4Ws8WZU1VxGuZR64OppcggNIDtcigNJ -D6A1QMWBbsjgOce+AxTkzVltcC1wGNtbnE0NzXjd0hpJSiZ4KIJIlpmQMl6hW2d9joIQC24MGVMAGhg/dQaCNzPYF0iNwXWI2aVu5dpVSg7KH9gR+IjPrSPsBGBrhpI+gnSjENuoeCLDJpudo379uja95OVikMRBhQcFrlJrtMrRSg2qcjc/3Ktr/fY0el6ZkPWoB3/YpghetvZgGADAhQrXBld7XNEA5AzgUPa1uiZs0cd2zfrWdVhtRwN8dbrE +yaAxgPUDFgW7K4DnHgQMk5Y1cbWAtcBmbW5xVDc17ndAaSUomeCiJXl/RJbS3Ed9tSvQCOghALbgQZUwAaFD91BgdWNtAjeP3dxk/eS1s9UpUVYsoUGiaAiM+tI+wEYGuGkj6CdKIQ26h4IsMmG5mjQf3aNr3jZWKQxEGFBwWuUiu2StFKDaoyNL/Qq1v9tjc6XpmX/agE/9imCF5tdmAf14RNUtX6XXtc0T9kDORQ6rW6J6zax2bNmtc1Xa1nA9 -UO6dcoaP71l81TX1yDS1bQ3R6SmWo4FgJXYczqDGwL8DLgWg+gD9AHsdbino7QJoB+dYLuKXP5kpaI1FpVLdYOSNyFHWDUKp3CeDHgQGiy2RZMtOGbnQIsEV6pd/g+l0Lt7lvmCpYjrV94RDgFXixTQ40LEP1dhBW/03xmrZukRVqQ/L6ag3XY1mDR2Ae/GK15frqkLRpAUnIx2xVSRLzRII9nRgjDAyDmlDzA3rW7SuzUbWcDG0VCMwjEg3p2ND +x1usJQ1p1yho/lWWTVtffIMzV1DdHpyZajgWDQ9hzGpmQMvwMuBltyeh7HW4p6O0CaA3ncHXmDwpYI1WDrbcpXBd4jchR1g1Cqdwngx4EBqMtoWTLThm50CLBFeSXYEMpdc7e5b5gqWHa1feUQz+V4sU0ONDxD1XTgXv9N8SHk91VIekPy+moGe21Zg0dgHvx0teX6apC0aQFJyMdrlUkS80aCPZ04I4wMA55QywMa1u0ts061XAxtHQjsI5IPad -CoQ2UtDTZRj0tlqAAGYMlvID2wMwGkPEyH5mgL8CUG7fbUqEAQgHRC3AmALbgvAAScuC24hAL8Bk1FAA0oagnzgS0mZrPWKXKVZg8KNDF0pRf4Seyw6sQctUGhrSrFsTNsMSM15ZWlbK+yEcO2Vcve6aPloUb/mgD5UMybn9FxRWLOw/PpsTc+5XbyDtI8mH5UPD+7allixTXRLHm9JBQylC11JYm7ZZDwHAAcAAIHAAvAQLhABVZSzFSHf9P1KY +zQwqHVlbQ7WWo99ZagABm1JbyA9sDMBpDxMO+ZoC/AlBtoN42hAEIB0QtwJgC24LwAEnLgtuIQC/ABNRQANKGoJ854tBmUz2ClslRYPNtE/YsPT90dUBYSpR9uRW4OWIqL3N6n6MIiSMJ5hvWTRPg0MkmV/g5L3mV0ve6Y3loUR/lgD5UMyYX9xxRWLOw/PpsTc+sir/jtI8mB5WPDu7YllixdXRLEm9jXXDU81ZJYm7pZDwHAAcAAIHAAvAQLhA -0ZDdIQemGtMfURXR9rebH3dCtGV3lwNlPvGOhtgPWxnA9mfaD32cdEPqNvGLKCyYAoZo7uoWj+woGjSZmbWFjZtU/gUr5t0LXETxtpiJ1TbVAeEMMQAPo36MBjQY0YPjGTbQF0SlrbeP2WDU/YnVAWJJHmDfYfcKlH0y6pbwDBhNNKQTngp2NaSS907dL2ztxdfL0IFBzNtz/eyQsmHJOqtjK03IBxri72j3dUe7v9rw+11HgvFKqXlQ4it8My1s +BlZSzB8MMwP1MY1ZDdIXb2ddDeShVetaupA2R9Sfd91Btn3SG1MZYbVn0A99nHRCmjbxiygsmAKDaO7qdo/sKBo4mem1hYmbVP4FKubZC1xEsbaYidUq1QHgjD6AEGMhjYYxGMmD4xnw2zDfnfMN1J/ReuUXVIXciyhmBxORVIQqUfTJKlvAMGE00pBOeCnY1pGL2TtEvdO251MvdAUHM23P97JCyYck6q2krTcgHGuLq6Ot1R7h/1vDq6dBU/9c -VTe1QD97eEacATINgD6FKZd+McAv464X0S/Zgs5g5o8lGjEAIRciP5EDI0yMsjbI+0AcjXIzyN8js3v6AHNNwD+OxFqRYC1SDGRTIN1jWYwzm71Sg32jalHuUlDbVNzHSN424wEICXkXuACAXouDLgCX59RPoAVA/QLUQ4gMwM4DyVgo48HijEuU/kWZI43UkjFO5XdU2DRVv5T4UuWCAGKDzehqVKlC8Go0V8ag5ZWaNu/X4NajB/buO6jowEhD +YxWHbpOQ9wV5DUTQUOy1hlhwBMg2AFoXxl4RpwBATDhfRL9mCzkDmjyUaMQD+FKI/kSMjzI6yPsj7QJyPcjvI/yOze/oHs03A4ExEUJF/zdIPJFsg02N5jNOdrCKZapS7lJQq1Tcz0j6/uMBCAl5F7gAgF6Lgy4AJ+fUT6AFQP0C1EOIDMDOAklUKOPBIowuX8Ncw5YOTjnwdOMz9boeIT4UuWCAFKDKo7wCsoew3BpdcY/McMGjh/UePGjowEhD -fWAydvHGjDyouqjpGhkyrMxk6WrhVp/bhZBXjbxYg5qtXxW6N01NKYkmKZ2WTUQVALI98C24OmSGOecCFYF7hjovfl2Y++6ehWxjiY/GPYVautA0J9mukn3wNGY4g0kT/TFHEUmw+Xl7Zdpk71aGkkhPBCjRNk67GV9ovmj3r5VwhrCqZofseZw421ZOx0T6/v5OBTwU1MOR1Q47MMSTwxZ8HST0/W6Gti1CmzTKo6FOuMqTvANxCtJ+gmH52QuY +fWAydvGWjDyouqDpGhkyrMxo6Wrhlp/bhZD3jjxYg7KtrxfgUU1FKYkmyZ6WTUQVArI98C24GmVGPw9MYwqVC9OXZj6fjI9UhUdCOFat0pjoJfH2+tmY5rrJ9sDQlPfdlE/0xRxFJn3l5eGXaZO9WhpJITwQo0TZOuxVfT7o19FDdNXZtMuBrCKZofseZw4q1ZOxMTfkwM2BTwU9MMQivnSZkTjfRXJNBdM4ysNSgrYtQps0yqOhQ7j6k66qtJ+g -Fv0bFOk74My9+kwEMOVWkoH2Jh40LrmWjlkzoZCs92jKD00gybV17t14wgG3jyNckMRTDMAOj4ar45e3vj/w7kPCFc0cpr50ocsWyrhocu3I7aBAyRJfTP096x/TAMzmXgTWzZhHrAUEzBPcdTqRAAMTTEyxNsTHEy8BcTPE3xMCTmE8bUQAIM79P/TycoDOYjDQxh4GdcSSsHXOwtaxkM5wiqplvQGFPcN9D1I6HWOdeSfkQAgDwPoDKAIwMqqY +mH52QuYNv3LF6jXv0BD+k0ENWVWkoH2Jh40Jrn2jlkzoZCs92jKD00gyZV07tD4wgFPjAVakOBeb45FOD1Nvee0qxuQ1NFqpf4y1kSAymvnShyxbKuGhy7cjtqEDJEv9OAz3rMDOgz6ZTBMbNmEesDwTiExx12pEACxNsTHE1xM8TLwHxMCTQkyJN4TutRACQzQMyDPJyYM1iNNDGHrp1xJKwdc681jGTTnCKimW9AYUDwwMMbAvwP7V2deSfkQA -Mw3ruiDGjoI6CNKkgC8CGD/DZdUmDI/TUlXVFLRz3SjNLbKNl1Lzk8I8sYDtNN861KGv0awG/VNOjKPg9p7bjq8YZNA1owIWNMmxYxZNSAYAXz7ljgPvcrq2c6H6hH4qUS5MI1JvaHkeTx7aQWm9ckWQX5EOALgy7ofSlfnBjotRwUpDD04mFkTUY/6UxjfXQlOysW3XF6fdJPqlNJ56U+mMpzxFcn2md2Yyg0xxWfaz4Fj1KEWPzAJY5lBljDNB +gDwPoDKAIwMqqYMw3ruiDGjoI6CNKkgC8DGDUlcuVmDDPeKMSTJ1WS2s9EnuNPIs6VObGrtp8H8E7GJzKhR7CJ0BjAiMc06Mp+D2ngeOrxhkz9WjApY0ybljFk1IBgBfPtWOA+9yurZzofqEfipRLk1DWG9geR5OHtBBUb1yRhBfkQ4AuDLuh9Kp+ZGP81zBWkOxjiYdRMAD6uohX29SU7Kwx9cXj60k+aU3HkZTlPllPwNOU2dQcO0cSyTZ9rPi -WNC+5DRxVZtC1T5NtDCgzcJNjGbuhAOkaENtVMF7Jd87c56wMHOhzMwOHP9jL5tMOijw42P2STg04sMyTMo8ixnQBxK9D2IWIkO1JwHmfoK1YIUIp6ajYyQZM6j5s7/R3G1oLvjeQYA/JjXDwPhYzpIyk8orWN+Ba5PXTLw7dMntX/THMiI7CuPX6tKsUANTRWqXkPK1EAIADYIBXTeGPtgM5gLEC9nSQzgodDNrScM8iAIz3fvjbczvM/zNGAgs +WPUoZY/MAVjmUFWMM0NY0L6kNTFRm1TVPkx0OKDNwm2MZu6EA6RoQq1bQVMl3zuznrA0c7HMzA8c8OMvmPnWKPSTEowsOBdFLTKPW+J8SyyvQ9iFiIDtScC5n6CtWCFCKeek2MkGTRo/bO/0dxtaC743kOAPyYNw8D4WM6SGpPKKljVgWuTd068MPTR7WbZvjqc+wpD1tvV+OS1X0/gFAjd+ugCAA2CAV03hj7YDOsC/AvZ0cM4KEIza0sjPIgqM -8LOizDSuLOSzGzqiPrA0C5AsW1I/uTNSRILc3MBNtM4SOSQ7cxgZN2WFIrT3zewHZ0287M5yXp5AeHMAg6W6LgAB4mAMsDfAUwIQD0ApAMuAcAAeAP1SzIkzLPreIk/MNST888NNK5b0NShq5wrOzqnlm+cm36CmyNMBeDQyVZVrTJsxblmzFyoVM9Wv1iVM115Uzcq2TTs9skx0DYAfotgj8/DVr6To/7OrpcmQPVJDBkJcktzLPNlkO41RZeSO +93742gs8LOizRgOLOSz0sw0qyz8sxs5oj6wEgsILRtSP40zUkUC3dzfjUzNEjkkP3MYGTdlhSK0b83sDWdNvLzMslyeQHhzAIOlui4AAeJgDLA3wFMCEA9AKQDLgHAAHiD9Cs8dVKzo/TUlqzLPRf6azHbRNMKKXEErnCs7OgeUr5IrfoKbI0wNqMTtBudbOfVh45fMXKRUz1a/WpU2XUVTNyrZNez9nliHYYIUBV0fzkNWvoej4c4ulSZy6bDUG -gl6pTWhTKAfdMhDaIWnQ/zPXYnMO9pDrnMJjPrThXpzKY0HEEVwbf93Bt2U2dQcO0cSyQlzHBCZPWL5kyV5lT1kw4uVTa1NWMo91fVQ2LVubTLhkxJI7BS/eF3fXaltE6L8C0CbU6EvhLkSwcBszQk3LPyLx/oosWDCw520TjM/StDhRvC2NDy+Tsy4MngW888i2wpzAo3aTUvbpPrTB85tMLtUjHHD75X1UV5meorZO3FS2XXjrl8Hs14sJDSNY +QpyT3Ms86WQ7hlFl5I6CXqxNaFMoBT0wzB8GIjD8Ni1HXfHnxTOc0fV5L6Y/nOUZuKlhWfdOYyn1Gd+Y0g0xxNcxwQmTzi+ZMle5U9ZMeLVU2tT1j1fV3P4jlDb3PcmZMaSOwUv3sd312xbROi/AtAp1MGOcS3wKJLBwDzNiTGi2ovreqswF1Tjo0wpNy5Q8+FEiLY0PL5ezbgyeCHzzyLbCnMcjcZUbTeozbMm5dsxcpSMccFvkvVRXmZ65d47c -PXvz7wwzB8GHKM9MADk9f/O3tH08AvKaoch0FgzRM27LdO2PJjyqaudpjwDOIK2CuF04M8TOoA0K7CuMBcC2B76JkEyQDwzlQzx0QA9cbwunk/C4IvCLoi+IuSL0i7jNELEgIiuEzAM2iswrcK7KEZG2IxTO4jrSzTPgtybn/1EeO6tMXSQ48X9FltmaTkkclk9UwIbsmIHAAAgB7EIAu4xANiDYg4wLcD9A/E+GitAgk2ILCTDPRHUQiMw+JMzz +VIZdeOuXwBzQS0kMw1KQ3/Ovj6S2iEfjnBR9Pfj4C9JYy1v0+gDKaoch0HQz5M27LdO2PJjyqaudpjwDOsK/CuF0MMxTOoAKK2iuMBqC2B76JcEyQAoz1Q5x0QA9cSIunkYixItSLMi3IsKLSi0TOULf07nbYruK0iv4rqK+iuyhGRjiO0zeI3VOMzoLcm7/9RHjupjF0kOPEaD4y6mk5JzJSPVMCG7JiBwAAIAexCALuMQDYg2IOMC3A/QMJPho -A0/HVDTiy26G+VGcLb574HNPVPL9CRJIwnmM0OqNGLU7SbnGz/1TuNHzli5bOGj1s9FEySNcwD6C+QrDhpYajuWfG5hwsXEOOjvjM6O+Lfnp5Oo11DV6MGOFQN8DiznwJjaHgMSzvofzoZoHC5gvy01lpTSU+yretHQr63JjEfWT6/dhFekuZjafSUt5TPSNxlzJXEBXMfGpU8GsC+P2I0sNzNY2bjETdfc15S1Aq7L5bLN8LulUjvwF2LDL6a5m +rQKJNiC4k7T1B1/U0vPjjMk8NOR18kxvNuh7lRnC2+e+BzRNTK/QkTqjpaVsr7IZ861Y3LDi4tyOz5o87PRRMki3MA+gviV1rEaw17kBLgFbdPzpno6Et+enkycl+jq6gGMGOFQN8CyznwJjaHgKSzvr/zr8J+WNgReMAvvTmc8mPIVCU6hVFLKUwXOQlWY4G2lzafXWUVzeU73k9I7GZaD1zTs43MWThkFGsC+P2B0sdzDY2bgUT9fc14i1Uq7L -uPmOa91OGrU831Mmrko7ZkuhWOmKqJQmsGXA7EpJCy0Doy4/hr8iU0AbPeDJi56tF1psz6t0Mz5T9VtIqkcAHXz9k6+zCKnMMGlRre7k/Oezzww413jn/Z8uqlTda5nxzMVX/PZDAC/gGAjd+ugBzSbsi7Lpy6I/CvgjbrEhsobpdGhtYrLfvan9mSC53ZGJg3rKvyrBwIqvKrqq+quarjoNqu0rNQ+sBYbqG5CvQj6G/UPsrFCzAZcrNU2C0b5J +5HLN8JunUjvwF2JTLQlXmsFrRa31OZpjPZaun+q5RrNWZmMVazgwmsGXA7EpJIy0DoG4/hr8iU0BbO+Duo7Ys51ts8GuQid5W9VtIqkcAFPz9k6+zCKnMP6lnxuYcLEJD7o78uqtz4+q1HgvFAqU11jmQmNelYK2AtXtfBXNFzSbsi7LpyGIxisQjbrNhu4bpdPhvErLftan9mmC53ZGJg3uquarBwNqu6r+q4avGrjoKatsrdQ+sDEbeG0iswjB -UhZ0dzR4PYga4Ts7Ot6SC6xJUXobALbjEAMwIQDW4iYCDpZ59AGHC1EAIAHi4MUwKuu5pLPfqun+W5YrN2ZmMZaAGg+hprgoFzk8v149XEGKgMy8VPsuGzHqkpjYAyQF/4nLJwwr0drBo66qVzNs0Rq9rdc0KyjpSEEYoPz58f+svLqrQmvQVro77Puj3k56MhLBjlujjAMACMD3ADwAVx5rptqBupRGMPxX/9pa1nPlrzeRktVrWS3H0ZzcJYn2 +G40OCr9CzAYiryPc5Zdr1DSgXKDGbvYga4Xs2ut6Sm6+epsAtuMQAzAhANbiJgIOmnn0AYcLUQAgAeLgxTAe66LkMGdq2KXaLp67KOWgBoPoaa48Bc5Mr92PVxBioDMvFTnLlsx6pKY2AMkBf+58ztNztA61xANzHxoDUyY7s63Oez144OlLjB+i2CJr3lcmtBz4viq1d1sG8clyOrUUknpZW6OMAwAIwPcAPABXCWum2gK6GaTRnFenN1Z6U42v -htBS/nNhtQPUXNlLeY+ALebXa1XMLQgW47P1zYUxQ0tLvGzm38baveRPWjk0eXUl5LM78Agykm0wKpb6W5lscLky9mnTLiMeYOjj8y5z3ylRVqtBcQqKO1hg+zg0SABCvblzT8xLdstMaNqFi5tubsIa1bmLD65CJhQSQGAOLIpMMraYhtpc7O/4vmz+ySWv63DVgVV04jUatb87EsFr+W2p4lrvw3LVxV0TbDuxNc0cIEcBxbLnQiDIcrHjZi8G +sqBS7H1Nr3QiUut5MDSXP5LcJQSblzGfRluFjKJSz5HQoa66rDrzS2Ottz1U6L5ibEc8zPF93Qzdph+OMXTCrVIMkpv5EuW/luFb/C4svppyy8f6rLko2vO2Dl1ahh/S8oBdMis6IQzS3ryIQPAiZpiC3ZrTajahbebvm7CGBrFlZ+u6MYUOF2Jh9qMAHS+J00JQWl3s7/hDbP7JJZgbe7p/OBzLw3Y3pbj02WvlbGMJVsobYVWhsRVkTRLUzRkC -EKUGFbrMju6aqOyIOoAmO06I6+eG01VlDMMxIBEbsE+sDSbsm/JuKbhAMptwAqm9NsabWmwxv+FeO4xEE73rGjtpyJOwGJk7ZC/p2ULRE9Qvo9tC/bW8A5xZ0MaS7SLhgir/SxoPQKs2/kTeAW6EM1TAcaAHiY2F6LUTfAhAA0qaAjoA7j9ALcePOU2k8823Tz627PNmrKixatK52qPWkpup9g85azAhLZsLw6/SIxXrxi6tO3rPLYfMdWvq+XNW +5X4DaHAcWy50ogyHKx42YvBi8l2hW6zCBeO96wE7acsTtOiOvuRs1VFQ4jMSA1G0hPrAF6CptqbGm1punkOm3psGbRm5xteFFO4xG6a+O6IOoAdOwGIM7tCzp0ML5E0wso9LC5bW8ARxbNuBp7SLhhyrYy4MPQKK2+sDeAW6AM1TAcaAHiY2F6LUTfAhAA0qaAjoA7j9AWgyouqzO24jErzskw6sbLTq3Lnao1aSm6n2DzvNMCELmwvAb95sw9td -zfm4Gumj9s7XM9btjIlEqp92s8seeXs+L7qt6Dh/2ZZQS0lvlZ5BZoDYgMAAcDW4MwGgo5b98aBsaghFsrpJLPw1e0YVFW0ZypzmJtku1r9GXksNb9WyiXNruU0PltrI+e1uR73a6WOx7Ia/2tkNfW43O1jku7VNmdhGOD6jbn6JCSCQzU1NsepFuLklcL6wJ8AF7ReyXsr+si/pvmRRq1Ln27pq6F3mrXPWotdc4MLlIuriYQ6Qstd2qdugoTLX +4r6494nDCIbL1BbZo0Nuhb4WRFvRrx08DvmC4Q+RoqOU6Qlst1X8ymshLYFd6MZrmW70sxLBjp8CaA2IDAAHA1uDMBoKJW/fFlbGoIRbK61a78NADcUw1t1biU/Wtx9TW0t1k+AbdhXtb2U+n2Vz+U32v958eyFtNzC0KNtRb42ySWrB0S8vmEY4PtJvvRcwIJBtTnMzSMupFuLkmCL6wJXvV7te/Xsmbt+YNPmbx65ZsuhWOoByGwuUpqP2matm -sgj9Rs497HDCIQr2YsQ1hqA822GAoifbG7S7OKQntOdMeLQO8/Mg7me8Bt3TBa1XvYi386hW/zWQ/LWwb0lkrUdZEgPjuoAActbLWi8ct4YqaHABtoDOeBwQdMBVosQd2i5B8UPhG8C5TuILeK8gsEriM5rva7uu/ruG7xu6bvm7lu3xJ0r6AJQdlyRB+At0H1CWytU50gw5ayD+I9Lv19NYAzNz6wrGnSzr9AxKsDz/ZdvukA3wPQAO49ANW39A +4N3avbicv0teyKP1Wz0e9tOnDsvZixDW3vYsikwCiJiFA73i7due0V07ntVdbo37kw7yQ5n6pLCOy3vYiQC29Md7F7QCP5DmG/+OU7umgHLWy1ovHLeGKmhwAbaAzkQeoAJB0wFWi5B3aLUHpQ+EZoLzOxgvkrWC5StozRuybtm7Fu1bs27duw7tO7FC1xsSAtB/QdkHcC8wfUJAq2TkyDDlnIMEjKuw301grM3PrCsadGusMDSqxPNdlJ+6QDfA -3E5CC/AkgA0ojAQIBwCXkB+8tuSlq26S1H7bPe21GbO6826BqbeIRZru7kSBzQwp2/nyQFZ8Oo1d4N61/sbTnm3uN60lSz9bVL4NcsF1LjKonHA+CttMWaz4W9Gs2NwO2nvxuGe/4uZ+fs60PJbElZ8D0AMaBwAxoBwCCkRzQTVHNxL4WUDDQ79e/FOZLTe5WtpLyU63tvduS2mOMOmU6n3NlxS73sYl+U1iXNIMR2ZN/WCKPYtJHzKlVOUlqwcE +9AA7j0Albf0D8TkIL8CSADSiMBAgHAJeQr+zu4evmRA02Lnu79q2dVR17PYpOBqbeIRZru7kSBzQwn+/nwgFZ8Ko2R7ly2+uctF8x1aOLDSz9ZNLYWy+kMqmhnZMOj5gvbVa02yfAc3T+e8lvxuqW+Ev/LYc+0Pl7QlZ8D0AMaBwAxoBwACkJzATUnNpLxENsZAwWS4AM5LY9X3tGcuc5ibFLg+9A3D75Sx2u5j4+z2vIlBU6iXNISR2ZN/WCKO4 -v8bcu7xVdD6nmANn2rDeOy/AJ6urvb7ZRxUdVHGkZY4rbg46YN27syxtvKLCy1fu0tOOvwRzAYfiVC82n6GoZnr5MtsbDcG4x6vhHHmz/tRHuEjG0XlMQvEdYhE/KdjvbathdNG9EFYBuJDmfuDuV7byIIZNHr0y1nvTiVTgciHvO5Ly50sKyituyBPBQc4nWPHicV0BJ0ScMHA5tisEbSdjTsoLsHhACfAehwYdGHAeCYcqqFQOYeWH1h7Ydc7Y +uMq7S3D1oCnc42NK7S+VcLq77FT0Pqe4A2fbMN47L8AnqBuxik1HdRw0caRljttujjys8vN7bq8+svrzvh1ss46/BHMBh+JULzafoahvevky2xsNy7jNi//v+bgB8eMyYUbceUxCqR28tHcp2OAdq210/r3AVyB38uoHpa83tvIghp0cZzI9Z9MYb0VdCsQAtB1jy50aK9ysE8NB2LuS85JxXSUnjO7GUsSSIxABs72C7B4QAnwMYemH5hwHiWHK -6pX4DaHAaSf4nEK5SccbMh4RNyHxEyrz8b/yIvviMpJXl2+IU2y9qcLUq/kTEAtwDwDfAO/gkjgp2QLbgVALuOQDW4MAG0U6bkuQwabrhm1KPGb3bXMAekb8Jk6qoLx7hKsQbgyuMXrXxwctkiFQDpDYA/IL8f3bdlY9sBqN+0Rhx7oayzEzuDKpoZ2TVo6pLLInvpAcRbni6nveL3sy10W9CB0iejWyh0Vsw7U9aVutM7R2nNVbOS7iYd7GU42t +qhUA2Hdhw4dOHwu2Oo47CmhwFknFJ4itUncu0KsK7yhxRMq8a+/8ib7bQL0mkkmwqtUvaAiyqv5ExALcA8A3wDv4JIwKdkC24FQC7jkA1uDACNFl++4dmbnhxZuWZ9+825zAHpG/CZOqqD8e4SrEB4Objj60CcXLZxhUA6Q2APyCgnb24aMJHLOl1wp74617POVSxxkdeLLytr0LFGBeDVJ+iW4UfBLwcw13FhaB1iejWGh1Vt/DGIHWuFLPe7Vu -/d0oun0o1uY5iUs+bkCIwXI5o/HuEEiR/GeVjoNmQ3crue1cIL7E603Yhw78PQTbVdPeqflFTAvoDxA1uKoBHVMi/YeKVZx7LMv5cy9cdbb91YTIMyJMtMCNgd8zsbHbfMAchwaXXGPyNWN28Gd6eFi3QyPuuZoJA2L/mzH7A+cwCHAkkNXVAeBV2R3CdvLAS4icddn9ZDuFbkGxE0IqAK5+NzR4QT7ZN0FlkpaJ8AExAAwXu9OpaWWrHWhHsdCI +1kgx490tbIx5Utfd7a7KzdbqWbUtFjCBCIwXIto1FuZUrS8sfMqqArOsKD/S62McLfaCHDvw9BKtXU9ep0UVMC+gPEDW4qgDtXKLW2yKWu7xLa4fM9wjSetunmMQzIky0wJWsu6PC8nWfoVnlpMqNFfOoOebj9s9tRnenrct0Mj7rmaCQLiy7NEacJ4BLuWQUNnvxb58VDs/LZISgfIBmJxq1v1qUUjtYHYromOgL6Oz+OY70TXNHhBPtk3QWWSl -5x0VDbA11UojjG82ELhsFwpYaWouxyvi70pzPsBzDOR0OrHN2sVDuW6qNtVXpG+5Kszn+RLUS3AzACtmnkcoJadiTp+5ccO7F+07u3H3BrdC582sMsjQaAB2YJL7YIX+ykEdkKTBhhK04cumLXq/eth7/LVxAmCwtiTA9t764meEYauXKAnEVjWmfQHAG68ug77y4BcPjyqOTp3QFYbFP/LMG4CuYnYZRIAvAF6I6CaHrTWaK+X/lzmVMDnbCwNc +onygTEAOhe706lpZZMdaESx2IjbHVUPsDLVaiMSH6APheYXilgoeVluI60Oir/ow1PDS7C+m68gxUO5bqoq1W73jzEaZPOIetwMwALZp5HKAOnNq9fvOnt+66cy5WOr8a582sMsjQa3vWYKfoxcAcR/spBHZCkwYYetPi9m0/qNgnsexCf/y3cCYLC2JMF20AbWR7ca+mZfBY3AXgSx577tP8xEvFnUFyfj9cPfLifVbQ0Xge/jBB8ScvAF6I6B6 -d7B5Dn7NeM8FcBXALbWVAtUp9h7UXQ21cJTR7ZX8EXdVadtU1G054PMSApMNiC4M7AuUSc5h+0P3H7668atn7W6+I1LDys924+IADUTCJkzDXmZazedQcSGCp3IbmSG2/YhpbjWlw9s6XQikENYQiexe7hDLMXctzoTUxQKpnmR5FsZntl3Adg7+a+8Mn4u+KfCon0GxgeeX2B95d6ppOYUMnXVJ2FcsSiI8naFl+F9UPc75qWdcSndZTiPNDA56 +HzTWaJhXEV+mXMDnbKwPsdPB6Dm7NxMzFeRXfzRWUAtZE0qebHU20SNTRTZX8HHdZaatU1GC58JfoApMNiC4M7AuUSs5Lh8P1uH0lx4ePHHu94eOrrx9Xo+If9Y/2t4TMYy0Z12lzZ6ncuuZIY79iGvuN2LH67GdCKIQ1hCJREQ4Kwsxv55d3hmZcN8tuXaJzBu/zXl/BvKoZ/afD+XFZ8ANBXKFz9OBlEgA0PXhJEtddN+zHQiMJXLJx36UXNQx -uqtz3JoMkMNjVOPBxdU2+KZ7HEgLcC4AbAL8BCAuAOMB9zwpUKPOHIo7bsbrtV7afbrCuVjqYQMbfTCsoEljWBun2yriwRZrFYlFd66l5uNHLZi6GejXAavJDnDu+BPoHTts6eNiy7OrhhP9sNUn4/nMB4e2vz9lxtdAXW13jpF9+fm5eRNHl1BfALkI6xsYjgVxCPojoV1hfhXV1x354XVQxKECn0txLfSHz15yuvXg241sbBvMqplkyiYYpjbV +KHint14TmMX2Vy0OMLPS/VNr7gyXQ2NU48NF177vwOKZnH6ALcC4AbAL8BCAuAOMBjzfJcKO7noo1JO2rsl6dVT9Ph3YNORPlnz6zAk8eUY1gvp9sq4sIWfRWJRXeoZd7jxl9cvvbs1wGryQFw7vgT6aez+fXj6SbhjP92Z7NaIHNXdtdpbu15Bf7XPl3jozbW6aCuIXl7dAM3t6AFCN8bmI1FeQjGI3FekXT1+RfIj7J9Rci76wIrdgj316RO/X -l5vlc6HEgLbhe4QgO0AUAF6LbjW4bwA7gvAQIDwC3AZ5LgAXotwA7itTFV8YNrnCi7DcSjSN/VcLzjV05Emg/wb+l2Qf0CZ7KjcQOANIQjYCpfynvpz8fubIZ9qMU3/5CVBXeawn3ARrYXERpBw1sQ9B/lswHLT3FqmMIiBQO7azezWDo0HmZn6ez7NZ7gSx6PvXxR0wIvAygEYBQAtuAcCYAIMuXtR5X/a5UDJtFbtdxTSc60cVr5Wx0cU4XRwG +iu/9dira+2nOLrTdmTKJhimKtWXmFV4YcSAtuF7hCA7QBQAXotuNbhvADuC8BAgPALcBnkuABei3ADuB1ONXpg3cfqL9+ftvPHh27OP43TCsFBRCYKCnCeZK/fsjDXSEI2B6XapyGd03Vy9NdBrTN/+QlQV3msJ9wWGl0OuzqtuDCTxjCCtCQhrXpaVq4moIFBbtfN5D4C3zw74yprRe2Eum9cO5EtZrWx5TX5ELwMoBGAUALbgHAmACDKN7Yef/ -11r2c30e1nAxwSNDH7GU2ejHLZzsiHFxcO0iJ3qw4m1iQxd5PGMIK0JCFOkA65PtDrdlCOvyD3JpGNdL4jHwZWMLN6KsDLkw4DfoA3d73f93g9wJcn71p4jfXVk/WF3bb37IV2depUBqlSw2w81DqZGSQBxuL7qzv2aXd6yNfv2LOocWhwAhGPw3LJo2mEyt3BTVgDoKe1lF/ndlwBc83jl2PePAE94WdXtkFwCONhCGxADxlywAoCrZUxBhvhl9 +P2VAyeRXHXne1nO9HNZ2mMU49Z291D7xc4w5jHzZ11sT7va6BDsZZd8XDtI2d2sPxtYkEHDWxD0J+WzActKJl1jU610sbHZt2xdr78Y4MviMfBlYy838q4MNTDUNxAAT3U9zPdz3UlxjcyXbV14c43nV3jd6CvxgcQgIOdzfAlGGd81DKZGSQBxxb1i7v2F3768Xfv2LOjsWhwAhGPwvLVo2mGStbBTVgDom11lFC3pRxielb3l2AqPAq9+WdADB -hVw88PQpW4VgTTB9hflD6APSdRXjJ5bfW3tt/beO3zt67fu3nt97f8nyRugCcPNgEI8a3SV00NULeI2Kl21tDcOcv37mQARJOhvLOsBWP9xACSF95JeTYAmANiAPABwCMDlEbADx4IA2sDAC4AbJdDd6rlV2ZmCXID8Jfn74D5fuQPlCk5WzAw7OjDTQ9eMv1LIADWRgmIQUm6sDX1OkNeYP5N9g+emVoJ6FVpcak8AvjLMaAdpO0lBHfP3c6d+d +J3LdzRUZcsAKAi2VMSEbQZVYUiPYj7yWOF0E+wdkXlQ+gBsnyVxycu3btx7de3Pt37cB3QdyHdh3Yp8kboAwjzYAyPRt3QuxJomyvvML4q3/Ib7Vt3ORKjSTobxrrAVuA8iF95JeTYAmANiAPABwCMDlEbADx4IA2sDAC4AjJSjcWrTV0ZlX7rV2je9FLp223LDui927GoccCpdQcn9tayMtSyH/VkYJiEFJWLE19TpTXpD4zfkPnposmTxiiqH7 -d1HN03e5HLd/Adt3iWx3d57+RL5fLgkgH31e4FHsPeyxm12Ap4s8Gkw/2909TPdlbJZ11IpTNW2lN1b/R4Us97W98XOtbJpAJCFPiiqH7ow8kBFRdR/W03OGPbS/xuO1Cp2tAXu4HNtVY2m+xqfrAnT90/4AvT0A/VXQl4Hfyz7PXafuHFCv22We5GHmRmQ8lzNMtwxEKk/Kg6Tx/thH6d7edhnUyRaAvlEwORz9cWIsZd2lbQN45MIm/RQ/G9VD +ow8kJiFrtc6K2IR+Iaiw8G9+Zylshzn/cPfeTP94ilMCYV8uCSA/fV7gUeC97LGvjy93izwafD90e1nrTPVt5zza81u4mZS82cVL8JRMfMZvW9Mf9bl0FU/Fwt81vniKEVF1FkNtU5NtZtFtxOdcXUXA6RhD957wv8VWNkfv6n6wIM/DP+AKM+wPY4/A/xPmi/ud37Cl9ZnAk4UZBbnYpkBpcaTLcG0cawBT0cu/7Ue35vRn8RxU8BZFoPeUTA5H -2tfc3uW7zdDPQUmPWoHyS+gdw7OQzE1ALWJxABYJDuKgAXox9JIBr0RgPuDtofDxbfYJdLwy9MvLL+ERUnUM8we4r0E2wdK3hK/Y8UAjj84+uP7j549CCPj34/qPCHugA0vnL+oDcvI9Ly9PXejy9cGPb185aDHtDSW3y7IqnVaZIx61NsCjbF9oecN6wKQD6Ap5A7i8leh+MB+4l5FAA8ACppgCrA/zk8/w3NV2E91XVg6HdY6kfjtAgMJ4ApCr +P1xYidly3eiqACG5H+LLl0mt5n0G8LeeXot7hT0yYCtM+vT8F6hsy3Z19NGoX/41gkO4qABejH0kgGvRGA+4O2gSPzt9gmcv3L7y/8v4RKwcDmJK5RtJ2Kj69dUrHjxQBePPj348BPQT0IKhP4T4Y8Ie6AOy8iv6gGK8j0Er4JuKHOV9h55XVSzTlFtGu2UavwHVGWcgPXM4KOH7yq4uf5EpAPoCnkDuByXGH4wH7iXkUADwAKmmAKsD/OPz/ceY -QLLa1cpPN9jMghHKFiTcYPIe6csK928Rs+OIxcNjeYhR9jWASKsVDKDKgteEKzytS3MQSYvsJ/Gs+LsW34utdzT4UetRSSdlmfAzAMoAwA0wAcAGh/T+FOj3PLPurcQk95PUN7895M+QllWzWvdHVZ70dIlTa4McNnmWSs/NnYPSzAjQk8ccirvWb5lA5vLyFJSrFhb0aTeEg680sHPurzReEjzxQqfuW0KO1TbVyYLY/Nvrb+28ELuq1Mv+3My6 +3CD4k9LDY0yk/fsESFd4UagSKtCMtj/Xk832MyFEcoWBd7EfJdZl0ZPKRYSMXCOIxb0w0DWSQDWASKsVDKDKgteEKwytS3MQRtPqJ73eF7JR4Pe/z5R1lu+TFe8wDKAMANMAHABoeM+91T0/ZWCwY7WvdzP299/yLPAx8s9DHUJWs+ZTo+2XNbPBY52d9bgPSzAjQ1TyW9AwTvoZBH2lb5u132P0UaTeEH9zVPdLrF9mvsXml4pkhw0KPJvWdyYO -89KLc8zcdRPCFokC7xaLgRxCGy/QBy9uY95zSGLJxsTdp3d21C9Z370cZBOtFXlhDXLyL99uF4QGvTT7JtT3V0N3DXdi/5HyAbQ+4U9MmAqzF46zFN8Fe12S+YHM0fBuupbTKgCTkbL8dcrADHwKp8vYj/Lc4Xkj6wfEbvhcDF2vDr4QBOvLr268evXr7duELhF8x/EArHyFzkXXG2XYS7hzzyvDbVmyOdzkHp1hhb5bC6JW5uZt9a8SAHuPuink +A+fAfbwO9TAQ7+G/R3/nbHcjTLxyg8IWiQLvFouBHEIYr9AHL27L3nNJYsnGtNyCfIvL5x9t0Gv9fa0VeWEM8t4v6e6TRAa9NHkckvuZ9Dvkv7DxBecPYt2AoTFC69FPS3+J+CuEnUK5ddapbTKgCTkgryx8rAbHwKqSv8MxwdkrCE9wfyvaMx69evPr98B+v3wAG9Bv9ACG8jEL2+Id63V16x/sfJr0xfCrLF5c8/dxna+ymdA89xf+nWGKvlPP -bwK0BxWmAHcm7ozRDGg8ANRLUQbsUNyccOHr72tv+vwd4G+qLzSVZ6IQCmP5SeYOizya8QBxCNYdAZ4J0Cng+8xneh7eT1O58OYhA8bR7QlBiiYoKl9U+of3IgTqqHi13+vpnlD5W9ZncW63f1vqa53cZc+ALgzF7MwNiBXoXb2GOuVKWJJcDv5RUO/omo750cVnbe7A31r+Sws8NbRS3O+lL6WOUu1QcXydCuk0vrsDJfKX4CHzHqPYseDnc+5d +jtbm6O37DesAe4+6KeRvArQHFaYAVybujNEMaDwA1EtRBuzI3Nx1udR3Ky/89rLgH/HdazTkdedIQCmP5SeYJizya8QBxCNYdAZ4J0CngAayh8l3OIZwSuk/2zXcViGKJih6Xf9/i8L+IAaBvvzRH3nskfSrX3ftvPoz0+F7qof08Zc+ALgzn72IFegjvHw/ZUpYt0I+zt72S0mO5L3e7O+971Z3WcLvDZ6s+tbh96u+drhI92vbPm77s/bv7kHw -ov3jCK7Vmvn9xoP4tlrzGkFXkj+V+Vf1Xz6+9Tfr+++bnn79ueyTUD3/BEcJ4DFw4NONyfgJA2z9d5B9S/t8foPwe2l3/HRkzJioshb5XkiInW0Q/SKZ4zRXEwItnXeQ+OH08OrX+H5HkDP+L2NA6QAe7XtvjlHx+OsPOqew8NxIdKTkHAb2Q7j7A/4yh3oA2PwDl4/UQAT92g5O0mWXXXHxABSPIr4jNGf2ACZ9mfDShZ/cl1n7Z91EDnwq9xKp +5iEDxiV7ZfOX4CFL7SPdY93va+5dr/3jCPbU3r4N7i0uvBhxZ+s7DX01+2dm59JU+fu2358Afnu0B9HbqD3/BEcJ4DFxYNZNyfgJAdT9d5B9S/sCfEPubzHsTJ5l0A5JAUSB17DbsJ9eNkVxMCLad3eYUltsPHb5S8Uf1LzNMWxXMFO9o7st4CONhUC8wI7kP2QcBPZDuPsAgTiHegANxIdITlk/UQBT92gjJ6StUbXBzRseF6AFZ/YANn3Z8NKD -P7j/4/hP7o8ET+j0p8nvBc3TPMz6nymBv3HjlY92ddh1t9lFO3xAD9A3wIKVQABwMWgcgfvGwC1EPAEYBwA3wDGi4M5VyucCNLn04dBPMuWA8dt534vPfsfEGy23e2ZihDK6Lg7j1cQB8PFnykJEJduhHQezef3ld556YrvmbyXfHIJ4z95JAub9u132P0YfGkc+LNd6YfVl+zc2X0W1W95Htb2/PFfRz6ilMCQgFujxADuAr4CYtX9n4TTtcFpJ +n2yXOfrn3UQef2r3Eq0/pP+T+U/5j/Lsibmn9t/ib03w30czDjymCAPHji4/Wdzh/odCXTt+gD9A3wDyVQABwMWgcgfvGwC1EPAEYBwA3wDGi4MDVzd+Kzd327tRvcl0k+xvil3xDMtt3tmYoQyum4NY9XEAfDRZ8pCRAR72b0h+vbyX2i+l3u76W97vZb+/LHvLyFJQLFtb4fGkc+LNd6Ef4G1Y0o/rbwWfF7oc15M1f2WwY5CAW6PEAO4CvgJi -NfCKi1/4+bXwvcdfE74G3zPa94s+zvLa33ugQUCOH9Awkfxu8LQW73m8J/e771toCU+8OupX9Y3PuRrL9+743fSFrOtIdJ+ci21Kxf6X/l/h3+ccI3bn3b9uHKN/ZldXsZj+zqpgPieuzAj37mBC2YcGyhE3V24m8ff3+xMkAnevUtCtXeGlz5OzRdzK13/UMCYhy3sFU8Prn9cXhXsEfguRtbHX8+NPtdRblS99Uix9JCgx1TrogDYOtT8cVoRs +tf3/e18DYAy/n4xTRRV3vomM7xtS73ifelPZjR95s9dr7Z1XPpYdS5dBx/B7wn+UyR7xW8p/1b+e/tz8Pec83vWn7V86ftuar9Rcb/h99IWa6/B375iLbUoV/VfzX+/vvn9E8S52NzYM6Lil0NexmP7MqmA+t67MC/fuYELZhwbKDTePbOb8+dXlr50IrHiaCFJR8NOsIcPt4s3/lDATEM29fKqj8qvntdMfg38ELHBUGXqjsmXg1l8DkSdmPhAB -ePrTtk9Br87QNr9M9B7cPHgb8jfib8zfnz86PqgDkAfJ9Ykjxt5vm086pqtUhNp+gSPKl9tqk+9+5tt9zblxhS/v0B8uMuA2+r7cBxkz11znMNTvo7sv3judPrE8gloPNgprj5AfHJvlDigcNakKgUBboHsNLs/8Ijl99j5i158YNNAvxHL4Uwih9tkmghrWGrlsvoDsM/lFscotQ8EToR9OLNX9oHIzQwLmgd3LrACMftAMgRsuBrcNbgOBAM5v +tUlx8RCrR1ihqx8cAW+84RgEppXrBM2foJ8OfhwMnmIb87QCb9M9MHdAnpb9rfrb97fmL9HUvgCoOjL8FTnL8/rre9R7hsErzp9FSsJW8m3uDdyFqd9dfud8uMFX9+gPlxlwO30I7iON6en+8hptG9pRl1dpSk8gloPNgL3P5I0bIcsdiocNakAgVJbkQ9JrvTci7uU8dGgcx8YNNAvxHL55kitcubodMpGMA9ivrn8QLltdSPmj9/lrADOLDNMb -Ab4C1drCMdahgCCytgDeOvdcJAAEC/AdQCrauL8dbgZ1htukcjXk3YG0n8hDhlNsAYrY8MGK0B8AM4BsQA7hbcM0Rj2A8BcADwAVVO0B+gO0AoAEMtBARPMeprv9jvjb8g7gf8Pnkf8KFI1Q/sO+JQXtrYVIpaZn4HXpFQK1BsYCo5r1kH9IXiH9oXtaMXthzo3dIdNB+AyZO1kPtAfii9xGGWZ0MEACVWl2B3Jtmdiwg5ciPmWFQXr5lRniktxn +WDdBcfigC6wmgCmPrAN0AMuBrcNbgOBAM5IgdED9dkQCyhurUtbsnYcylRdahkp8IgVECYgfKdhNmXZTbrwDo2IUYClGA51/qbwTEJjBtRmusAYuA8MGK0B8AM4BsQA7hbcM0Rj2A8BcADwAVVO0B+gO0AoAJMsFAQvMZhhG8/nmf8Enm78Y3psty8I1Q/sO+JlQJo4VIpaZn4HXpFQK1BsYIBdTASU9zAWU8YzjH9uLuF0OdG7oAds8YGTMFsh1 -o3tZ7lM81OIvc8KrVs6zh39O9vWdu/iMd+9nl5rYPcYwaspBFgT5sjRvu82TAtUmBJmBaiKyNmAMQw26At8gLLMkLlvotZGCRgjtq2VYXkQgEkHzoToEt9vvqKoFQLtwdhP24EzvMDgfvacnNuMDoPpMCOrE59VzsICA7s0C3nq4c2gRkccvtZcfuLOsNIuYZjdMVJ3zn3w8/DLstgpZ0nYuKRyZO2JrnuQtTqDmdRONq1vEHMBElsS869hK52Hg +kntIsheA1QIK03AZDtXLqw8C/p09Czoe1fAdg4a0uukggbFMN7kN8FnoN9+vp38RvnvdhjgfdYSr382zqfcpjlPs8vNbB7jADVlICcCE9haML3myYpqkwIoAIWtrcKQAeAG8AOAPoBfgFuh6ADMAyilugXgCYc4AGIdWoooUogBuJdBBrAm8MFBt4o5MLGAwpAOMsp8OKYh/vFZUnlJIwCSjTA6Snhoy6go0nhLXgzsLbB2FJssNgU6YzKqZcwfv -M5r0CLcPASIUNmrrU6fordVnOwMVbho8IACL9BQXECqLuvxwANVBi8HAA92FEATgBrEAiOmAMgNGw1ePUAGAN2ZTJGTdKKBUBnQS6DoQGPIRAPxhjIukAHRI/8oPlxIPQZBlnsuURHQdF9PmO6COmIGD0gC8BCWrDdwwZ6Dnsj6CGgZSg4wZGD9AImDR+qKUUwaa1nstbgxAVmCoAF6C7Xof9B1AGDswVGC4NtWp8wYWCJZu4D/QRGCywfoAg2Eq +pkonpHclAaf9qDP58nvjjJkTq/1HXjSNYym3UGvAtgChN4t2oJXV6CJxc3LKHp9PppdfjPjowGK88iij6NROGKlY2qqgX7h8Cb3uABqoMXg4AHuwogCcANYgER0wBkAigb8R6gAwBuzKZIGbpRQKgBGDIwdCAx5CIB+MMZF0gA6JP/pH8uJLGDQMvdlyiGGDUXp8wYwR0w0wekAXgPi00bjmC4wfdlEwUMDKUMWC8wfoAywWP0BSpWCz6vdlrcI9 -C3QSbF6wQWCEwdWcc5qiQqwc9lJFsiUCTCRMewekAxhM0RcBMPg3QcwAimqNUCDHrRlQPutFQJpBVip0sH0FOD4QFZIXqKWZ2oH0lE4CA5bQUYA2AAYBzQT0ACAAWgzYi6pDcn5whwXVFEHIQU3QcGASACX5i1gUB3Fg+CTgO+kEEC+DErEDoEAJItcAJoBggFgFPwRRRn6B498APkRSAMoBmMAAAKPfD6BWCF2MK8Dr1EYAAASn9Ap9GUA6aDHw +96wVAB4wZ68DzimDcwQ2D8wRAtq1C2C2wXLN0NkGCTYl2DWwfdkg2Gs1swSOCSwQmDl3m1tUSP2D7sgosOtrT4fUouD0gGMJmiLgJh8NGDmAAU1+qgQYouNr0EgBo4c8htAAFA+h9wfCArJPPgJGJRoPTlsZuEEGCjAGwADAD6CegAQAC0GbFboCZ53kNyp1wXVFEHDgVowcGASACX5cwEGDQIUJ0TgM+kEEPFsSAACAgdAgAFFrgBNAMEAsAvBD -EEOghFsTghaUUXGAoCQhqEMvBrYP4w6YNPIiKWaANgOw+p9B1wQvEd6pZz/BAEK1eY8iIA76X06IvCtBov1Xox9FlOUBkvBdgC3QuE2YAbwBF4cq2/Bv4P/BhDmLwf4zEWCAGaIB4KXsIeTFSYQGCAskI1e8YhqiU9EbB2vEyGk9Uf4F6FkhjAAUhLoHe6PhHAAj9Ghul1GY4nUUrQQAA=== +ozs/RAnvgB3XsoBmMAAAKPfD6BYiF2MK8BL1EYAAASn9Ap9GUA6aDHwpAHwhuACIhaUTXGAoDYh+gTzAVEKaOwTBbBNYNPIsKWaAOUXtKp9B1wQvCAys71Qh6EJ+ug6iIAz6R06IvH9Bxt1Xox9BVOUBj84T7E0AW6CImzAGxBDsUQhqwBQhaEMIcxeGAmsiwQAzRFfBS9gDyQqTCAwQDMhxr3jENUSno+gC3BOzGyGI9Uf4F6DMhjAEshLoCe66 + +/HAAj9BRul1GY4nUUrQQAA== ``` %% \ No newline at end of file diff --git a/DOCS/Алексей/DataParser scheme.md b/DOCS/Алексей/DataParser scheme.md index 838e287..bab96e2 100644 --- a/DOCS/Алексей/DataParser scheme.md +++ b/DOCS/Алексей/DataParser scheme.md @@ -216,344 +216,344 @@ dS6ajkIcDELgh5dsG8T3EOBzbOctQ/KiRAcGyub5vgAlsNKR5oCe+BhAU0HFLBpRseggHAaB4G6m+5SH qxiGsQPoJDECsqJ6FkuBFkwOYSPQVR1I0rTtN0/SDCM4y6sz/gEFzek87TWQM0zpAs2zk4pQLABK4SS9wLJCNDeO2008VYsGSS1PJNxKfBEBIShaGYdhuH4YRxGkai2l7VRbBUAZDw8PsCTRa8fZWT2nFPfWTkuWS2ibG8vG1IDd32ecvclP5gWoPc2j7BFva1DdFJL+FsUZ1T667FCA7mfZJz3PESslKl9LpSUmUctlKroEK+VioV0pzQqd86ZV -1XanVy0GsappBo8h9BdF0doHROlAR1Aa5Qhq+hGpIE641RxhilFNaMV9IBzQTEmPIS0SgrTWiJTacFiyGXQLgZI8CjpILQLBciswkqtnbFdD4tkT6DmnpAF67M0Dj0+nOTgP0/qoDHmPYej0uGlD3AeK6ZMU71gvEdeGd5sh5Bgi+Bh75KZkWUuULoowmi2lun2SCT4Wx0WRkxFiV0l4Y1Pj2OyYUBJFgJqgImeMJIclJlDVEcA2BFjUWgR8UwQl +1XanVy0GsappBo8h9BdF0doHROlAR1Aa5Qhq+hGpIE641RxhilFNaMV9IBzQTEmPIS0SgrTWiJTacFiyGXQLgZI8CjpILQLBciswkqtnbFdD4tkT6DmnpAF67M0CAxDM9L6nAfp/VQIcTYx9XgwkwaUPcB4rpkxTvWC8R14Z3myHkGCL4GHvkpmRZS5QuijCaLaW6fZIJPhbHRZGTEWJXSXpxTySJh4cSOAJIsBNUBEzxhJDkpMoaojgGwIsGi0C -TEwcUZ4L58HFDCcUBeS8N59jXh8eIm9NG7zMvvU+q9Qonxzk+VMli8ahCgNyfQpsZCdgAgEnUhNRLOi1FADC20izKG4PQjAt5ar23QI7GoDRmhtE6L0AYwwxgTEBJAHoEkhDJmeC8HgmwTihWeL8Vy4IiTwimRAZQuAILBh2fqTA1TalUzOsw0cmRiAtIVG04h50MpRFIFAOm9cKBxVwOtBpVyFRvOop8lSEAtTUV1EEC8FA5FQ1zgUfOQKDFGJM +PimOEqYmDijPBfPg4okTigLyXhvPsa8PjxE3to3eZl96n1XqFE+OcnypmsXjUIUBuT6FNjITsAFgk6kJqJZ0WooAYW2kWZQ3B6EYFvLVe26BHY1AaM0NonRegDGGGMCYgJIA9AkkIZMzwXg8AkaFZ4vxXLgiJPCWZEBlC4AgsGPZ+pMB1IaVTM6zDRyZGIO0hUnTiHnQylEUgUA6b1woHFXA61mk3IVB86i3yVIQC1NRXUQQLwUAUVDXOBR84gqM -bULSFFVTcybkZE+CzLIHHHs8HgMJyRn0gP3cEiQhzvFPiZP4OI/IQIwS8fYYUBwXDuvkreGJM68GJcCpYaU+q3zKvfCAj88q6klK/EqH8Krqk1D/XUDUAEeiAZaAVnV6W8DVTA80wC2qjj9IgsahyUGTVgNNTBuy5Q4KRvVLMCBekeNITtchwL7iHSrEa9xPyModhUjiTYmx/hjwtTwycwYATPS+kI5cUt7iknuP8ZxW0ZHgyhbJBRJQlHXm6feP +SYsxtQtIUVVNzJuRkT7LMsgccezweAwnJGfSA/dwSJCHO8U+Jk/g4j8hAjBLx9hhQHBcO6RSt4YkzrwUloKlhpT6rfMq98ICPzyrqSUr8SofwquqTUP9dQNQAR6IBlohWdUZbwDVMDzTALaqOP0iCxrHJQZNWA00ZHYIWngjMWYEADO8aQna5DQX3EOlWE1Xi/kZQ7CpHEmxNj/DHjInhk5gwAkEXOYRy4pb3FJPcf4YVQbyP8bJJRJQVHXj6feW -BVjUa2I4kOHE5lESUhcUJB5xNvGQ3TTXbmEg4CsjEDWe5vpOYNvQE2iSgY231TFhLIwUsLUzNlvLfAit616UNurcoWtDz8gEfrAgM7jam2IObAqo4rZRFtqQXphdkKoXQicLCOEEB4QIkREiPtw5+3wAHKmEBu0ttYEsXUuBY7xyHYnUgycK0IHTpyne2cYWKS2kCgAmkMOmuAADSdNzYtHoPQdWmA+h9BjpgXAPR6AosYegeYiw6S6nIc4JlCy3 +1DFbFozERxIcOJzKIkpO4oSTziZ+Mhummu3MJBwFZGIGsjzfSc0begZtElAztvqmLCWRgpYyPmbLeW+BFYNr0obdW5QtaHn5J9N55gCCzuNqbYg5sCqjitlEW2pABmF2QqhdCJwsI4QQHhAiRESI+3Dn7fAAcqYQB7a21gSxdS4FjvHYdidSDJ0rQgdO3Kd7ZzhYpLaIKACaQw6a4AANJ03Ni0eg9B1aYD6H0GOmBcA9HoGixh6B5iLDpLqchzgW -jeSJCRAN8RwRSP7o8WoSRj43SZXCYc5IpGzx6rwbySRCSHDJSSQ4PK4rAexLifEhJiSkm41SesF9uAWpvlyIVuUn5bsUUVN+pVlSf1lTVHUGZ/7aq9Lqq0YD1XdUgU86BgDYGWeoaNGsyD6yoIjGajBsYrULTzba1a9rvkkJ/GQ0smx3XHU9Z02u89Lk+tsfceEp9sb4oEa9bsSIMvfRjd2U4OIj7Y1BrInxdbRxZrhjmoJKYNFPi0TpdFmi9ESB +XLLeN5IkJFA3xHBFwiA/dHi1CSMfG6LK4TDnJMx2ePVeDeSSISQ4FKSSHD5XFUD2JcT4kJMSUkfGqT1gvtwGRN8uQityk/Hdyiipv1KsqT+8qao6gzP/XVXp9VWjAZq7qkCXnQMAbAmz1DRo1mQfWVBEYLUYNjHKHBSN6r2sdT6n8ZDSybA9cdL1PTa7z2ub6+x9x4Sn2xoS5dr1uxIiy99WN3ZTg4iPtjFN4MYX1tHFmuGObQkpi0U+HROlMXaI -uRQK8lQ2Cck0GYqYCkpj0MgAXJoV4eh7mUNgOD9xKBsCvL9Wo+BzijAALJXl0XF4F7zevFAsVMGJEAUY2JUnYrinxyRhXiBWtxjqSi8hJrWuSO284QfKG1jrXWes11RegHRGLnIbzxPCD4Zw2VvA+o5B4+LtBQhIiZFLZx2Wjl42CEkLxoQkU7p5UK4P6wSYSmCHlym0Cqes9Kh+eVn4Vd01KjTMqqpytqgqszjmdWqqga6Lqc9FPX2s+Zlqzn9U +MRIO5FAryVDYJyTQFipgKSmPQyABcmhXh6HuZQ2AEP3EoGwK8v1aj4HOKMAAslefRCXQWfP68UKxUx4kQBRnYlSDiuKfHJGFeIlbPFOpKLyEmda5J7bzlB8oHWus9b6zXdF6A9FYuchvPE8IPhnA5W8D6jkHiEu0FCEiJk0tnE5aOATYISQvGhCRTunlQqQ/rNJhKYI+VqbQBpuzsqH55WflVgzMrtNyqqgq2qSrLMub1eqqBroupzxU9fOzVmWp -INoagEMJq0HeZFzNes2D/PBP24Q4LVatrhb2si6hHq3P1NCwIX1KPh7/HXDjkooaNY4py9G369JgYErjfcI3Q2U0IDRqgeRMNlHVZtfWQ7zuTuY0DaFGEV2lf1juzW6SviKadogLzWq+5Q6C0jlwdtFBH1Bz5lkOPAtw5CxFv2rIg7h0yygHLU2E7uA8pVmrY286dZLvMCuqv5R12bt1Dum2AZ91QZg/BxD+BkOoY4OhzD2HcO3oxEWf2UeY8Z4Q +ucNQg2hYiJpoL82Ima9ZrW4LCYdwhDrfkkIiy60sqLqGes800lXAg/Vo+Hv8dceOShho1nivLMbfr0mBkS+N9wTcjbkeVtN5NlGwzUYjPN9ZjuFrO5jINoUYQ3erT4x70kAkUy7RAXmtV9yh0FpHLgHaKDPqDnzLI8eBbhyFiLAdWQh0jpllAOWptJ3cD5SrNWxsF062XfrNd1fyibu3bqPdNsAyHpg3BxDyH8CofQxwTD2HcP4fvRiIs/to+x8z -PH7PieP1ftYD+tAScM2QEEoB7e3ZQNPdhS9iQI2xu7gm1Nmbc3sALaW6t/D74QUN1IxsWE0OeJHCOK8ZLfYeyolJXxIex9YRbJbpOIKRucgQNULU8cuVbpEgmVoRLJTgfgE0wDeUSNic1UycRUKdtNM1qdYZMC1R6djNf4CFmdlUnM2d7MOcNUUC1M+c4FBc/BDVNcRcJpxcnJboLUZdcE5cMw7UHVvUwtnVSxzgothdYtvseAEtr5dc0B8QlkW5 +wgBPOek9fp/awP9aAk4ZsgIJYD29uzgZe/Ct7EgxsTd3FNmbc2FvYCWyt9bhH3xgobuRjYsJYc8SOEcV4qW+w9lROSviQ9j5YRbJbpOIKRecgQtUZECceVbpEgWVoRLJTgfhE1wD+UyNScNUKcxUqc9NM1adYYsC1RGczNf4CFWdVVXMOcnMuctVUDNMBc4Fhc/BjVtcxczUJcnJborVAsbV5c7VVoldQ9nVdoKFzgYtRd4tfseAktr59c0B8RVk -exzcNYdgUCTdhF6QOMvg7dsYpFCBHdndXcKtYYVFEZ1EnxBsGwCMPxA4pkhsgVbR7g+YuhSAeg6ZtswBdtih9tvdC17EyRbJTgjgg8tdHlbsvE01yZ6x/FAkHwXw4kwAIlEjokpkEikiYDF594bokQzgx5DholikQ9SlylKlWIalAlg8ecmlblHB306EXwukEYsgD1oNYMEMkMUM0MMMsMcM8MjlZl5kXhXhvgW4fgkReJvhooLgdk9kDkRdBMCR +W5exLcNYdhI16wzcREbdwRHoOFHdZEwYEBC1FEYZVFasHwGsnwGwiMPxA5ZkRsQVbR7g+YuhSAeg6ZdswB9tihDtfd7Fi0nFbJYQYpU4q0ddnl7tfEKs3cSggkQkLCnxEkwBolki4lZkkiUjYDF594bokQzgx5Dg4kyl6x8AKkqkalWJ6kQkhC+dWl7lHBP06EXxekEYsgj1YN4MkMUM0MMMsMcM8MCMTkFklkXhXhvgW4fgkReJvhooLg9kDkjk -vIPJwRkDiVplCATliByi6kvVDRpDIBrkaj7lQjGkXl/kG5AVKiDi/l3lLi65QVURwUG5IiEAwNnw4IHCnCEAXC3Db9GtbDRwyNDhEgVlsZOJ39opj5j4f8NgW4F5ksT5kReIrITgiQ6VbMGU/hmUR5QdxNt8kpCc+VL4MDadyctNxU8CjoCCv4GcTN6oyDmoGCqDwEMTNV2cOR6CBd6wDVhdRcPNTUOCpcShuDPcCF+CQswihsVcKF4gxDPUbsdc +xERMCRvIPJwQUDSU5lCAzliAqjGlvVDQZDIBbl6jHlwiWk3lAUG5gUajjiAVPkbi65wVURIUG5oiEAINnw4JHDnCEBXD3C79ms7DRwKNDhEgThahsZHFvhUtYTf8NgW4F5YTMlT5eIrITgiQGUHMmU/hWUR5wcpMd8kpicBVL5MD6dKddNJV8CjpCCv4mdzN6pyDmpGDqDwFsTtVOcOQGChd6wjVRcBFvNzVODpcShZdgtlpQtlcIiRtIs9p4hxC -roEQ4Q0sdhlDuwI16x1C8s0A4Q1lHpdCStU0ysojM0TCPcAsvdrEfci1BwVk389gLV8YriIBQ8Xip0n0X1e131k9U9G1m1vT2ki8C8Uci8S8FZy8PTV051apa9I0Xl698BoyJBm8LZt0xZ287YgUj9xtJtpsKBZt5tFsVs1tQw70J8H0o8vTW0fTRxP0mY45l96Q18AMgN8cs4+w3i4Vyg+gMITgFwAArCgTQfASDOmODfYNkUYAcqoAAVVGAfT+ +vU7s9croEQ4QMsdgVDux1DTchFFwCs0A4QNlHpsZmNCBncjD3jTDs1Wi6s0wbFUZ/CMZS1389gZF8ZbiIAHta0I9KtlZo830+1P0U808m0W0gyuli9C80di9S8FYK9p13km8JBa8l0o0G98B11m8zYLZd0xYO87YQVj9JtptZsKB5tFtls1sNtQwH1J8n0Azwy21gzRxv0mY44V96R18gMQNCcs4+xPiEVyg+gMITgFwAArCgTQfAaDOmBDfYNkU -IkCI2Uz+1Xn/3EWRNeHMnxXtwgCYz7FYxPiWSJAJFXh4xoIE02T+B2GGNWI5XbNQBxDxEJCJGALJFAJSiJJUxJIMwkFFXygpMlXwNJOgBpOIKZ0ahZws0oJ5w6k5z41oN52gv51gsgB5M9T5JKE83QUly4L8x4JTHl3FJdO2l2goWrkYI11rAaLi2bD6xYWO3xADRPgo3VODFqDUKjUXB1NQGPhAMBiUOTTBid3dOMPdyaJqziUsI21+2awLnoFq +YccqoAAVVGCfUBIkBIzUwB1XgALHiuHxHyUJX0NYz7A4xPlWSJAJFXn41oOE22T+B2DGI2K5T7NQBxDxEJCJBALJDAJSlJPU3JOMwkHFXympOlQIIpOgHpJIJZ0ajZ2syoL5w6m50EzoP50QsF2QsgH5K9UFJKB83QSl24PjF4JTAVylM9O2hENBWriYK11rGaIS2bAGxYVO3xEDRPioy1ODEhJUK0NXHjV4kBmUK2gtOMMj3dzMNtISKG1ay23+ -FwEqGW26CQFoj23zSOynHsUTWPi+BCN2MlNdIiJNNeL33Aw+PKEUuUtUq6BwIazRQBPrHIUemhzWUDTfxhH92/wh0xShxh3o04M8gJGCKRw1SXgWRPjCiHHMlYruj3KgKpmSjrO/PQPZPUz/LJLFRfmKhAqyrAqM3lVMygvINZxAWZJsy5y1RQqZJKAwpYKwsgBwol04N83jFlyIr4KCwEO11KGlOBRODlJYIVJalkN4EmO8jCk+HYpFyHGUI0O7 +1awLnoFqFwEqFW26CQFogOwdJOynAxnxThy+BD3OLDx9NQEUUHMP0GTUo0q0s3L+xa3rHIUelhw2SDXfxhEDx/yh2xRhzh0Yy4M8gJDcRRy1SXmWRPjCiHHMm4run0OgKpmSlbMAowK5K0xAspIlRfmKigqypgtM0VQswQooPZxATZPsx5x1SwtZJKDwtYIIsgCIsly4ICzIrlwov4KITMuENdVwBOEVNYOVJajkN4BmO8jCk+F4rESHAEoNLEVC -FCk+HfzugtX0JEsMIj0UXNMktFMgF8OO1tNxRhwMtTkrROM8Xu3D3K2Vijw6C6z6HTygGW0DGiAcogHIBT3useueteprHeoVQHQTiShHTFnDLLzQAr0/GTM1ljMXXjOXSTMbxTLNjTPrDbz3QPV7P7KHJHLHInKnJnMqHnMXLLPHw4En0DgkAes5Cetqn+uYEBujgbO/WbL/XX1dLTnxPmM7IsveJ/CBUQkqCaAwg6COAAgAHlZz6hqhqhJb6Bqg +k+A/zuhkXNMMMkr9MzQ93MO9xKD8NO2LUxlS2PhMtCNu3C03yiNdw31sJfQ6B6z6AzygFW0DGiFwNws7UDgkAes5CetqleprHeqVUHQTiSlHTFjjPLzQEr0/CzJTNqjr3TNXUzOTPQBb1zPrHbwPSPRHLHMnOnNnPnMXOXMqDXI3NrInw4Cn2+vQF+v+qyEBuYGBujnbN/S7IA1uq317JgL3y8Ne2+PKEQkqCaAwg6COAAgAHkVz6hqhqhJb6Bqg -mg4MByjA2Q1cKZvtNsHjASpwFllk+IoQVrLgKQeVf8F4YQ1q38qVu4LzWTICeaMi4DpqcikDDgvy0CGRfzypsrALcq9NqSirGcSqlVGSuS4LqDWSkKHMyqYKKr6qhdMK2CvNBT8KOrCK0xuqiFLqnVyLgV3D1dosWCJCCMpCGKLpxqkQSJ6NksQ1uLuwl4FreKv9XhPKjTRKzK3ds09rzCBtmtZKmt6sWt0BiAhhbQ4B6BP1SINLvCtKbTdLkt9K +mgENxyjA2QNcKZftttniQSpxlk1kJE1w7JLgKQ+U/8F5pEMT38aVu47yOSoCiSpc4CcjED8iUCAL0CGRgLypsrwLcrDM6SirmcSqVUWTeSUKaCOSMLnMyqkKKr6qRd8LxdfMRTSL5pOr7SQsBCwtddSg5SKEPDNdYtWDJCiNpC2KLoxqkQSJGNUtQ09Tuwl55rrcidYDPKytLSbrrSatZLNEnxhtrDdFnKrCC5iAhhbQ4B6Bv1SIdKfC9K/cjqjL -nTXEXS3TO7RwYjc1gl4jNEkiolClUjd67CnasiEDcjkCCjNKSlmQSi1AyizkXTmRqjWk6ijLHiFQjjX7Rqn6zjbiQgJT37iBziPl/7KIdb6wnjIUzKuyD8R6x6J6p6lyftB61huxwQh57IdzPKl5aU/LnIW44hYQ7oewSR8U1wwr6xkdMSmVTgcSAC8TJMCSPb+UMrMCALKcdNgKqTQLCDv5g76TSqw60KWprMEK7MI6OTarw70LE7Grk7cK2rZo +Tr3SPFPTvSrTRw4jc0wkXwMj7DYkSl0jtFMjXhsiEC8jkDCiSlij7syiDAKjzlqjerai3lTjGiDiZSMAFQ36uln6BBXl3kHiQhpSXj7igVgHKIdb6xXjoUbrrLBb2tx7J7p7HK7qn9gxwQh57JzJvgewl56U/LnIW44hYQ7oewSRCU1wwr6xUccSWVTh8TADCSZNiSPbBUMqsCwLqd9NILaToKiDv5g6mTSqw6cKWo7M0LHMI7uTarw7cLE7Grk7 -CL9q9QSKc6hC87cAMJhrTpBDFTjsHSaUCQpETcssm7LclqEQTJTh1qDCxKdqJLVEVHDqdLi1ERAYvhl6Lq36rqw8XdtrXwqyAyaygz9UO1qau1gm31QnlpgaV8Jqwzx1J1I9p0Ua4btYEatSmAkbYaTY0aPrMaO8D1hbRbxapaZa5aFalaVa1aNaPNyzKbKyInn0om+0lMl8QbUAWzzqt9GHeaClPDnsrKJAhBiBZzahnA2BqhmBbRqh1aoBsATg +iK2rZoeCM7KLs6QGtp87QUMIhrTpLrRr7FXS6UCRmMzcctm7RFyQEQTJTg1qJKN7pKbT1EJT9qC0nSS1ERAYvgV6wiP6a0nHXxGze1mzIzDUvqX1AywmQaC8wbxrYyJ0p0o8Z00aIBUzdYmAMz4b0acyPr0n8ycaQVhbRbxapaZa5aFalaVa1aNbvM6zqaGzabX0myP1wnVNl94nuzQjt8WGliBz99IMEH0AhBiAVzahnA2BqhmBbRqh1aoBsATg -2AOxqhzhZykHPqEAFhVzda+FsYNyLhHoE0iRT4YTMV9nQd1x7JAZvI7d0SucryhNbzhx7zRwkqpMXzZN3yFNmHiTWHQL2GPqJU8ruGCreHaSSD1jBGVV46BBRGaCarY7ULYXPrZHkwmqIAWrU72r5oM7iKeqAHldhC9pOQdGOlaLvt6L+b9HuAOJQpOK0T4zMtQbLsmXcsLG0BlkDhj5Dd26trbqzTHGzDt6LD+6ta5Kh6C4Y42BNgKAmg+hsBEI +2AOxqhzgVzUHtzAKAdHhgoDapjE0iRT54TsVsYMduKewQ1vIHcsSecHzRNnzhxXzRwkrZMvyFNfzlM2GySOHoKuH8mpU8q+GCqBGGTSCtiRG1V47/7ULaCarY7sKoWIAGrkwmqIAWrU72r063G5kqK/6861c9pOR9HulmLftWLBnZCroOJQpITMSo1stwbrt6X8sW60AJEDhj5jcO7NqYiJQdre6d7+6FKtalLGs2t0AY42BNgKAmg+hsBEJPDvC -PCvCwAfDrS/DTtF67cvHrs9GTLrr/H00YHhn0BpXZX5XFWNmJXUG+FPIXhR4zt8VkloS8HnBAYF44QsU38byS1NSZ4IrPgXhQp4RDhLhLhbJEqeaUqlM0qvb/mCrAWgKQX34eHwLiqBHQ6YW9VKqxHeoMrOThGGr0X5HWqhSsFlHLSxSCXSKBrcBdwyX1GaXgweA411wOJfKsnBEVDHhzGRE4D8Q9gtw+X7HBXu6nHK2Dr1WjqF7TqdXV7TKHtOa +wBfCPHDrDKk1l7TKAnzL3j4GfwQVJXpXZX5XUHRW1huASIF4iRzILtCU0lj5jnnJAYF44QcV38nzS0dSICOTjcXhQp4RDhLhLhbJErHaUrVM0qvafmCq/mILAX35+HYLirhHQ7IWDVKrJHeoMqeSxHkWvNCLhTLVMWgs9qcXNHqKdHcBdxiW8XLpTseB411wOJfKNCG6kpHgrH6R4D8Q9gtxuWgm+WZLXHS2jtVWDLzsTqHc/GLrc716u6UmX0AB -dEJAABFZOUgGAB63cbR30qPNdpgTdtgbdoG/PTp6WPPYvJJyMlJ15NJiAGvTJ43bJxM3J1MgpjMrGoFUZ8ZyZ6Z2Z+ZxZ5ZhAVZ9Z8m+9P09Afdjdrdndusjp+J7pkPbmvp1uPmwZ/fE1iASDSWv8W0fACgHgACc4BAWcnkSkAc4gP8Ac5QJVr7aw+/RuXZ1AANFjX1glPsfFEyckM5/BzikKBEbGMkVQ6x+5vjB2lD14TI+A12vIlAonONyqth7 +FZOUgGAB63cPRkM6PZdpgNdtgDd2J8WeJ6WfPEvJJhMhdnJ9JxGtM1tldA2NJjG/J7GzvI9UZ8ZyZ6Z2Z+ZxZ5ZhAVZ9Zymx9UM9AHd1d9dzd1szp1fVAbpkotOR21uAZ/mg/YZiAaDSWv8W0fACgHgACc4BAFcnkSkcc4gP8cc5QBVn7Gwh/RuXWtln4YHMeIlPsQlEyckR1geEhyEkHMkHYHQ6hmeSAt8mA0++Aqai+go1AknKNyqzhnAuNgOx -ApNgO1NoOukv+aFiglFtTXNtkyqgtlFot9zbCgU81HF61Cd1R6txt/q4lihUsqioumip8KwqWfYsapUgkMKANFtuurtvW3tzQ3iAGEePQux9ehxsd4V2rUVoege5y1zguKAIQBcXcSwGAO4Ge1VuejVzGLVs6pD7x0atexdvxM5OIp8NIuw/eq+qro+jJST527IxA2Ty+2e6+spAwUo05Co2zn+5pF+9pWzw4obx+55V5P+r5F065YBu4ihLbR4/ +NoOxkv+CFygxFzTTNzkyqnNxFvN01IUjgot1Rjq7FvUXF7Vvq0sGshi4upiqwhLcuillUlSbZMKQNBt+u6Nc3YcTtnLVeBtkeM0xx+d5xnu4dwV+SsVxS4etDqAIQBcXcSwGAO4We5V+ezx464y6dte66p7W6reu03e4+/etIkrxrE+528+pAqToo3S8pZkcotQSoi5T05kOojpd+kak4rr3+qzl+wB8Bn5T025K4r5CBp4x/F4/AKFXViloc1UR -ACFF441wWnSVL9LwgTLq1lByAchZLVj65uEMkAcZLPc0ldcPETi4+CkClBHFAqhvCxlbE1lehh8rlaN8+WNknDqJT8k/2mnMFtN/hzTzN7T7NiRqqxCxFoRoztFkz5qsznzJR9OlRhXXq4ysil1XAWjpz4Xb+8a8yYeUkM4LigL4ME4IL2lh6Tj26YdyL0dqrHu3ghiKd1xu0g4TBnlZ02z0rm6006YIJntEJjmb65p6s6Jk98WM9sGsdUvZJu61 +L5LwgVL01uLiAchVLdjJEMeOEMkAcVLU8hE9cPEHj0kKeN4JHVA2hki5lPE9lJhkT5Kkkz2snDqeTqk/2unYFpNoRtT1NjT9N6Rqq9CuF0R/ThRlFpR1q0UrBNR8zxXHOz+mi/qqjuz0XEautivPials4VAix4ME4fzw0h6Nj26ftsL7aodr3Pg/NR0tVrxg4bBvlD0vFudgrxM8oaJtpjmVPEJ99ftZaUGmDk94X8dMvZJ/01Jo2edG9zJ+9xvW -Jo2GMjJ3WZ9g2O9t91vD9opqDHDvDgjojkjsjngCjqjmjsfcD4X19Np8+eD9m/9Hpts6A3fdDyy9biQBcfATkbAACJoNkUgZwJoSWwGegQCTQPoI4SWoYDZlc78tc2yNHPiXzyKtZHjt1i5gAq54NW5vcp7nYRIa84TO8sTD7qmZ8mTYx75z81Kz237rKAF5TwH/Kn2wqog9NsHwzyHuF+ChF/NqRwthH41fk9g8z1H3F9HtRnx3OnH+oBt1AEup +XiQJ9tvQp19mDTD7D3D/Dwj4jngUj8jyj8fYDgXiMpfNmzs/9QDHpnmsDZDwbRb9ABcfATkbAACJoNkUgZwJoSWwGegQCTQPoI4SWoYDZhABYHc+j1AVeTYDHPiTzyKjZTjnZs5g4C5wGK5/Q27nYRIR8sTF8yTZ715+TMxj5/81Kt7720VWN77/Kn2wq4g5NgHvT4H6FyO6q7N2R3NqH/N5qwt/zUzrFkdpHrR6zvaeoGt1AUupsI4oxtzsYq7z -sDzy6FSETN4NcaYtlsNXgQcanvhEiMkWENU4S0rMr8S6Lre2Lvu+L8Vvbz3rtK8eMfYCgZFKCKZSwhSuDUgI0XcIQIwZ4H0BEB/g4As5DgF0GeBXgjAkgbAOti1oMdlWhREoC43RiatZ2hlErguwF7mV3eAtewuUDgBP9GIL/Opq+Dv6Jd9u2IBENoG54f438yWRuq63daQgvW7+UNisj9bgFWSQaPEHCAdKPRtgewChiUHeZMM6+LDRTk3wB5U4 +4cxtt3gQcEn+eEiMkWETU8SjagdiAarT3be+rIVmLkVuL/V7nq8eMfYCgVFKCWZAelShDUgI0XcIQIwZ4PoEQP8OAFcjgF0GeBXgjAkgbAJti1q0dFWN9SAAdXHbZdNW51PLuHksqwoFuNlV9Df0Yh386mr4C/sCRcrYgEQ2gFnp/nfypYm6hDZwM60hBusP8gbCEl6wgC3dg0eIOEK6UejbA9ggnSAC81YaV92GcnX5gpzr5AsG+ILOCiHVb62Y -uGKbYHup0hZ6gGSWbKzH3yjqw8VBLmZgsWzFwp1x+0uCtqz2WjT9Rq2PUsE0AX6E8ro9kGEDYw7ZPsKe88YrNvx4ocsRcHEVLIsXC6bUR2EoXauOyMHID2eqA/LugPOq6s+q/PQ1oLxsJPpp8L1N6soA+pfUIO0eYOAkIBpJDpeIZUGokwV7Xslet7FXhIAfbq8EymvYoegG16WxdeWZcoN7197+9A+wfUPs8HD4ARI+0fWPmBwrKpD4hjNZmnB1 +YWUdcHmm0OgeZoe7BFOiZxlwI8R+lnEaqj1LBNAp+WPMavZBhD2MW2upHzha1KzMsrc1jDiOlhWIhd9+VPQdi41p5dV6e+ldGBOxy5asRqHPX0ryzQYSAZ8L1N6soHybkB+ezTYIUzRZqntoy4NRJpLwvbS8kyyvTWPL3rwo0r2qvS2Or0LLlAXebvD3l7x95+9ngAfACEHxD5h8gO9ZEDjHmDghCgaYQi3mwA7JdNOaPZRDnzUd4YD6Ar/d/p/2 -ZpNlf0TvIrr00fKocBm/Wbsg7G/6/9/+gA4AaAPAGQDoBsAujnfkW5McuM2gONEbXyTgkSQGfPsCxnXDY5a6j0TfqJx3xEghwCaIhp5GYynM3mjtQNv8DjSBp9cpIQNJwNQISCoe/3HKjIOTb6Y2+4LCCiHW76qDI61VAfkizqoyMmCvJEttiwn6WdAh0yEwXqzMF7Ruh+PGLBS1Lor9xqa8bYBxDuYuDuAnkffqgAOBDhbmJ/OCBF3P5RdmeAQ6 +/6/9/+gA4AaAPAHUd78O2AHLxm0DxooQG4MeEiBJCcc+w7GdcLjjrqPQjaNzQTK3CJBDhE0pDTyGxiObPNEOnwRePbiDSG5SQQaJgTJ3e5ZRhBX3GnLwwTa/cVOYLPUMyQUEaptO0dfqN30h7MEBSMPDFkPxLZ09JS5bPFjoL2g1CMecWUlmXTn7Y9/o5IbYBxGuZWCNYtkDfuCDXBWQvg01Pfqmk55VZ+WkXU/tF0c74CwWV/CQD0D/AYdzgV4f -/h72VjkDIWD/PUH+Gw7nArw+gWUtlzVYFpp2XEAIk4mEEb4V6fPLAdEM5qb0pKO9erHvRSJqinw5Ge1vcKXjDgnhfYF4fVkNyLxbcXw3FHxH+DtccunXW+lUi2IP1+uE3T+sN0X4NE0gqiA9A0L94B8g+IfMPhHyj4x9vweoAYhsAWQkgDaJ3QNJZCJA7AqeDRWYjvg4SDhHEJkFYmXwaLHJeuOxC5OXQgYf0xuzoppHN1AYjcbiAKcsQt3AYlBI +QAqXS4qsGe47QIi4lSw+DDGfg1AVtUgBFc5KCSUrsfXK6JFtElGF4Jd2OHDhThfYc4Y1l9b/B40tw/FHxH+D1c56jXSpPfRa6P19iWPABj/RJZWE0g6iI9IUPd6e9vevvf3oH2D6h9vweoYYhsGWQkg1k+3INJZCJA7BiezRBYrvg4SDgewXwXsBJnDZ/wdiexS5KJDn69cHk3XQxh10uJAMRueLMbjmJBRQCZuc3OBugLQ4si2RHIhUlMKBI/Dy -Gq3fmrMPQA9ABRktIUSKN24UCIA5CCYpCF4gHDNwyyE4bdDMjLJbmdiP4FMRuHUNXu+Id7q8L6ZfcaQP3b2sKkTYt9QW4IkHhp1IJadyqPfERmoLhEGdB+8PZEUnV0EKMy2lqNHlZwx6EtZ+pYUYJYL1ar8NSTKYtIiVmr/BaRH4mTMlhBin9jSrIpnqYSv6Z02eEojnjiGP6nw9yvPGfuEQNZGFChBA1prWW5LhNPS6EmJgQjiaF4L2ENRXoE2V +E0xSELxEWEcIzgoYvuCd2WR8Q0sxw/hLMT2GWp7uDDR7sjnxxhtXuggkHp9xyrvD42RmcQX91U5kF1O5VNvuI1kGd9dOII1cQZzYJGdVBg/dQWZ00FwiBuspAlhQlGD6DMxY1I3IiEHAnweBY4cwRGg34sop4BIVLCDHJEu5KR4XY/naR5EeCi0zpAcIxlPj6E2ep4r0vl38G3U9EYZUJrzy3bNMeeQvAhCLyLynsoaUvYJjLznQI1tYt7Mwdk0f -6zoSh8NMoTky175Mde1sT9tZXmF/8ABQA0gCALAEQCoBMAq3r0Jt6BlF8wwzpoh1uzIdJhbvGYbAwgBXgeAnIXcKcFwDPjNh/xRQT2NRwMYfg+KQ4H8BihMDewLwMcbdxIZTx8+EVXSYvVRIttooxokQVG0JL19VxmmYEZw1BGB0O+oPXceD33EwiWSx4qHtCK0EojLxpbNOpPzvHYi+quIihHBhfF9U3xwYfEIDGHBsJZqw4WkeCCJT4obotjHw +Z5M1e1sIpuUH6Fv8P+X/H/qQD/4ACgBIAsASbzqFm8YmrNNoezWt5c0EOfTJDsUhQ5DMmR6AK8DwE5C7hTguAS8TWIxQEDzW8hdHExh+CEpDgfwEIu2OxS9gXgEiBEEpg/xTxs+EVHSSdQxINtoo6okoHwN5RfMgK0bBvrXxnFKcvhTff7kuMB4riZBHfMHl33hZ1V5GYIpOioOUZw99kGgmEQQi0GGMERFCBDFeNzoYjZqFDYcGwhmp+c8RglcG -Yzz8FCtwJ4o7SiEJOpL0MBerKIShJIlPpAALCCAAGEEAC8IHVMADSIIAFYQVAIAD4QQAEIgqAQAFwggAbhBAAHCDNS6pHUmqWL1SG1SGpLU9qV1L6mDThpo04MrLzyERkoaUZO9sEB6CKC9YL7O9kzAgg1C6JevF0r7B4nNMJpTU1qZ1J6kDShpI0/iWwEbKCSOarZR2mJKGZ8jgEbASDEYGUAF1Na1ha1pQL4TP4P8nwBHK8Csiyj9yDwXSd8Hh +iSkJQ3QHGjg38dTxcEn9M6PuMdp4IQFTshRs7GCaKICHwT0AgAFhBAADCCABeEFamABpEEACsIKgEAB8IIACEQVAIAC4QQANwggADhAuprU/qc1L571CWp7U7qX1MGmjSJpU0maVGWPYQ0Je8ZGGomSvbBAegPwvWFkLSZMwIIuQiiRr09K+x2JzTeaZ1J6kDThp40yadNNaHtCYOcHe7PxPfKCS9WDhcoMAjYDQYjAygQuprRsJmtIAW3F/J/k+ -AGT38Rk6cSLkDRJA4CSyIHKfDSTl8CcvzH8vGzb7riQRqneQa5J3FQsPJcdA8bp374niER0jVFueLkaBS0RBg28ZiOs7Z1EJUpezsCj6DRTjKsUkXKFHBBLJa6s1bSZ21eiLU+EVdBkavAZ4gTcpl/KSgVPnpoCSp4Q+dshICZC9mmgAJhBUAgARhAapgAdhBAAwiCoBzpjUwAKIgY0qPIbJNkWyrZ9UpqXbMWnxNz2sTeXitNERrTKhrpBAJtMo +BI5XgVkR8axh0nfB4Qx8MkIZMuD9jgwQaJIPAVWQg5T4mSYvvwIjZV8HJNfEQc5J+7zjvh8FTyXHVXFadYWfkiHtuN76GcC2xnA8WKQiluDYRPVKCbFNBR9AEpn9JKZdnBCrI66M1TSWYNehZT541dIcGkkp6FTnBEXVwaVPca8iKpS9KqUgPZ61STCC7coIACYQVAIAEYQZqYAHYQQAMIgqAe6R1MACiILNOjyWybZDsp2W1M6luyNpovLaWeyS -k7SA5e02ibuiOm2cTpjTVIY7LNmWzrZ7soYQ9LZqjDOam+F3iBjQ7iTMOLQK8BQEqA8AhAf4IQJ2OUkbAvgwUIHNbVXicQewZtB4KfASA3MPx9GDiOn3CrcDTJ+8fFHbkRy44bJeM9KpIITbN9iZQPLcQoMgqUzkW1M+FuoPhFw8DxxnEfqZzH4o82ZIUjmfeJra8zcAC4AWYxSnD0YEQwmExvXSShLJfxfEO6GuGSSKzsBXddkTFwglWkoJRUrG +G7TL2aTA6UdKyYnS0h0AMMORP3RXS8WN0xpvUM9l2zHZzs/2VB0t4dCbe8HAMHb13wO8BaokiAC0CvAUBKgPAIQH+CEDrcFJ0MjYF8GCgg5raq8TiBcxT6nwEgmfN8WBMBh8oWBpk/eISgdwjjrJY4uyelSEExtqZPDWcYHTcmLjwWjMhFszIkaszNx/kuRki05m7juZ+4kisW3Io6yy2Qs7QZWwXDiz2KU4RjAiDEwr9nxQmfQpoQWpYi7oa4NW -DjB57yjuZ+rPxhVL1nVTXZU0q6bNNukLSwm4vYBZNMukzSbp807IUtMIlXtVpN7XJhtK2ka8G8YcsMBHMzKd5jpDTKmjAounTTrpc0u6SzVTkjDV8z053q9JznvT8BEgIwAOX2D1AKQhAUDv9O0R7duxGwHBoDnfwGkzgsY7jjpNbgb8dCaSFuCYjtpzwewcQMyX3MskMNHyS4/4X81HmEzx5TkkmVPLJmKDFUfkjKnp2jr9RTxK84fqwRZn6DhS +d+M7oazD+1I7WYBIXrqseIfEVnqvWNkoDTZKQ8oM7MenLSXpa092XdN9mLSnpK016etLiGbTEhO0mPntPDkIBDpCvEiTHLOnxyCyXea6Q0xpovpYFS056atLelcSPpHNPOd9ILndDi5qHUuUYHHL7B6gFIQgIBwhlD0G5m3DYPg2Bwf4TSZwQMRxyoEkRW4V3B3N5F7DrhCUdtOeD2DiBmTR5lk5hu+XjE0hI2zw4VLPLeHzyXJdMpeT8OVTSCAR -hgrqoFi5mmDa2AEI+RXSSxdwz5M1KkcGFOC/iyGK8BKo/KVHPywJqs3LpKL9znZA8WshUTrIFZALyg1suBRQogX2yzpICtJeAsQUeyCJ3sy9vkLQWFCMFQcrBeUJwVkSfseCg6ZHLqHRziFTTUhaAvgWULIF7TASQh3oXjCs5O+JhRhz5EtBbQHQWoABAXArtSBjlZBl2LIxrxoct3OEnDP+AoEDymwaHB8CsjDxUSMIJkf6yjp/5tC9kSyX8CXg +m8kHvYqYJKC++aLAfkfKhEnyNG58mKZWwAjXzK6KWLuPfLJF3sGWYiU4K+MoYrwEq6s2Cd3X/Hmc4B+si7EHiZb5yZ2n9EUVAtwm0KUFcChhRgqQX5KFphS9BYgoDmYTxewc3BbDTwnGwI5xC6OfhL+xxyLpCc/IUnOoVNNSlD0+hRUqYXZzuJVvNfJ0Nt6cKhJvQtDi0FtAdBagAEBcIu1wFNZ5JdYjYGvFhwYzESaM/4KgTPJx9EQlkB3EaRhC -oFRBT5ZRYcHyRHxzuUieTg30FRjzpB+iyecKghGd93JpinNrTN8lWLDormHQaPz0GbyHF7MpxcYJs5/yIpwKGOB4sSzHY75UIJZHxG/GhRaR8VL/L4uZHZSlZEASrBEucbBD3BM7TWUVwiHGVypus2IfomWx9AAIWoMII+3QpYTaV9KxlXGUKU5DmOuIWyFCGMbIhuMUM0dEUt9nQ1SJxsTBSHIqHVLoAtS9ModIaV/yY5JCtlQypYCcr7eXSx3h +78aGtBf/F8C36WS/gS8VAjZMpDzDDgRSI+Ed2YxPDq+OmacZYtpmioJBzfDyc4ozaOL2+MjbeT3yCmKMQpsPNOtCIFlRSTxF888aChjiBLksp2D+VCFWR8QZql2DfvFW/xhKfwoXX+Uf12qRTYB5U4CV4MQGZLkBFlXJdMGjxdBVsfQACFqDCBETPqkQl9KyvZWcqkaNS+IagAkQkDDaZjZEHxkfFjpal0NPBWHJjlNLMhD7Uhe0rzKXSulUE5OT -nJEmu8BlXI4ehAC6CYAjARoeIH+BaAfUEuFc/6KZDHgxUxx5kOKqsqbnSZYlPwC7Csl4jIzIqCy5lAmjfzDxkSOMsQTGzskEy1xei3ArILBHvLtxxi5QRDy8nQ9xGvfSxfTKH5MygV68kFXhQs6dU35VbFxTiNrZGh4VMhK6HGnxQfA2Kfi4WX8O1JuCViW4BMVDI2pn8n5F/F+flKiUc9ip2rUqZEMVGAKaVEgVJT1PSXDTzZmSlpa1O6lTqOpM +QsMRsqOVLAIVefGg6sK+JHCgST0JLkAyJAXQTAEYCNDxA/wLQfJrFzEWuVTIY8GKnpPMhxV9lDwOEHiEuy2R0lEJXiDjKLTLIcinLd/MPDRKkzbJAg75jPMclzy8CHwucf8oXG2K/hQPbyeyQ3FOKtxiglgsoL3GhS4V3i7qoIXhGVsjQ6KylipHjQaL1wGJPFWPEJEkgtwIYx8etQpEJKqRNPEqYAqy4Gyzq9KiBYyqkp5KYFBS4aUUqmn2ySlM -6/JaGRQXFK/Z6C9aeUulVVLjY4cupQQsx49DY5UeCdQutyVLr7pj07pWMOEkBg+lHZaYcwqNWTNOQCAK8H0CgCaAjQdMGjjHElo9BagmAXcNUHuCVA4+WzYjOjRtbXRLgQxCYiG10LDwM+jwIvmOPfwIhESmigvo8wJAl8XmWYweX00r6vk5MH5ctOIO0WAipBjkmNc5LU5GKZ53yqHuYo0HJr/JF44FVeOCkYiIVxaxXLZxhW4AOgC/JftwCpa4 +6spXOsGWLqqlMZLCee1DkpD9phCyOYr1RpqrzpGqzpZQu6VU1dVEgOhUNPnX9T11wylhbxK6EWquFIk61egEmacgEAV4PoFAE0BGg6YlHGOJLR6C1BMAu4aoPcEqDh9I+WzaPpwNGLTEA2ppYeCnwfJ6SP8+kzJEYuYH3k8+9zcTE81HF9NPypfH8iSD/IVpE19k5NVTIsVpqF5ynGxQzOBUg9AR8g3Ne5hLVuL0WagvmUeMpUWckVfilFbgA6BT -Cm2IuRECxStFQzTGfCeni4Jln8ZksU8TKaEtHUEqLSIrG/q5xtW6IC4hASDEcFtBGhJALYxAXVyCEfySVGswdfEr/lUqjWjYiScZtM3mbLNikpyrar4pMoEgRIcyEymPJvAMWTGCEGcBSz0Ztgu5KeL6vJCQhkVsVNJIRusmLjbJAI9NU8t0UvK6NBi+NdPKhH/K1UrGpeZoMYKArEemLZHvmvRGFr8WJa8KbWx4XclYYBPV8eNQQJVyOB/nZlvP +8Z+FrdETeMRBcU9Rj4wnvPAp6ZSFqahctHlPiV1Tbq5KgVrSPfV4DIZl/D9aUGgxHBbQRoSQCyOgENcypesmlZVLHXsKslgTUscJK+KlzCAZmizVZr/D1z1laANcG5GtYHdLybwVFqxghCtjvIjGbYCeSnjhrNhkIbFbFUyRF8LhfTXDZ8spnfK/aNM+vpmvplSCi1DiuQWzP+EuKeNXM/vjzM8WHjh+Qm0fhWzE3CK+SsMTHtePsTOIdkIaOWZ5 -BpHKbeKewILSspQIdrgJXatkYSqs4oC7NoQslXeopXVpfBY66mOkKXDCwegdwXds03iEbbCAW2pBZ7Ll6irIaG60pXe1KF14ZVa6GiQevokSBX176z9d+t/WIR/1gG4DaBvA3HrVVEgPbWwE23baU516nVS9JQ5vTBlLC9AHTGGUER7gQwXAOXMfz/Q3gvAuNASguCnyW4KGtJKOPhnyZEZlwX1T3P5UWSB5aWjRRlqo1ZbMqOW2jRKEpJyDDFfD +A357AbWey1Ar2p/H9q/xFKhFVSvs3+5R1uXCdQfwakNDnqS4YWD0DuDISX0wQ1bYQHW2HsRVYvdCdtPlX1LUhrS69oROaWqrztOQ09RQqPRfqf1f6gDUBsQggawNEGqDTBtqEpzp8jQnbXtuYU8SxlbCzfD9N5pvqPNJmumLMoIj3AhguAfzeg2uhvA2B8aIlBcDvktwu5HqvSRjPIZGTEtw8qEHovHm8DJ5NG6eZONeE/LGNViwrSxuK0QrNOG8 -cmUoL3FUyU1pWumcvIBXaCqtWLexeW3BVFqsRUK1xfvL/AVqpNKyf3CZEAlSzeEIubyL+KhDRROIihTTdSu00s8+Nk7Wzb7gHWFdFt2sgBdSuXboAJ1YChBVQqgXjTsl5Ci9R0rwmntjty0s7eKqKGyqpV123dTpHlUY1ahhCxpRTT+2W6Hd1u9pVerTl0Lb1co+9YwqfVQ6jVmwIQAOU5DMBlA8QDoDAIwjLZmA+gWWguCGArtIMspbzTWIfx/Y +srVvPZnFrwRMKyEfVvhWnzhNvi3OiLNwB+ai6HWxKWNQhKB4TIX48JbwjETeRXxUIaKJxCUJaamVf8wdQBMy6M9HN82qCTkqnXMrkFK6tBQgqGV8lImy6/pWbsYWYLhV2CrdSHIVW7qCFRClVUr3O1kKOl92sfoRR6VzTZ1tu4pUDtGWwdxl+c3pr9MtXcKTNmwIQOOU5DMBlA8QDoGAIwirZmA+gWWguCGCLtoM1YkRZA2m7R82UsOVLLZE4EQk -WU0OZLIEUuArINwJwikBg0P764RFcSyhhFV1HttHhGO4baGpFzvDzRnwS0b8OHkKdqNzyhnfiqZ1xrDMjGorZmp04LyfJtO5jUiMq1rykeG82rVvN42i7OZAm6FbW1tCiaiR7nAsZWr9ScYDgDGZKXuSbUiJOKvwSyArKAkd08VOujkdJTFYAz7+0OlqD0DgAtBIMnISQPzLFF9rP5BXOdgkrN1JLn0FXXurEga7qjNR9XerDqLuG96DR/eqyVMF +NwawikFgxuXM87GGSoTj60VFHCl4Ko9HYNvjWaibhnwXUQ8Knmydqd5i2nRKBpKfDrFgjZeb8OXFMy81oPKRmCrdAlbKtXOstbCuPnqMq1yPQsJW1tCSbURUsGTawh4wHAmM6Ul+XqSVmQlfglkVeOrqN2a7ipxXM/vSKM0NzS5zAHoHABaDQZOQkgMWdyJ13wC5t1U7JSbKf0Si+6ESaUZV1lGwHGsCow4c2xOFd6rJUwXvdqP73BoHhBojLkaO -NEfC7co+oNL8JtH7Z8AxRbrnfVzHnJXxLo4sX/NG53Iv6DB0sVNwfF1jKxFxasdrSr1XJluzxaBq5sw7MBgDoB8A/zIr00rq9SyPYYiHEQkgNdA2vuLCSu5rguedepZOuGJ1dzFFBIF7rQze4U7IAFyzRQ8vsn/lo1jO2NS5NZ2JqOdc8rnb8vX3FaKt/O7fdVt32KN999WrOsfol2aMug0uzzipH7nDxfg2M+tYwMV0W4+2NGFeHBK12IHv9r8t +a61JdibXWtpaL66jdv6FBsg60nG6PEoJ+Y4boWJmE3JZubxNzdMq/0/6/9ABsWXJKcpurVwqyeYYiAPIkhVd/WqgS3FbhrhmeFe1ZOuGxnhUfWBIQcWynxBPcMthi8cUmpH0pqGN4+9NYvOn3Zq59a8hfRxvK1ca19wUjfTzoE0NaptAu6tcLMrZdB61rnC1rMRpQky8RU4aJUjLVG4rv5PLHTf/KHUgGKpOICEhSAkTgHXNv8pbahJbKW7eV3PV -WXlxxArIKQQ4xzZgMSUxCLdLTEXlLx23YSSjdvaZPhNXWFKiJBQyqbkyu2I1Q5sq6oQqvqXB70Aqe9PZnuz25789he6oMXtL3l6UETS1IZL0qPAoHe6c8HaJINV4CjVV4XAJkHwBXhagZ+mQ4DIEVGQR4i8YYrCEeDLJ8UjczFO/hoFf45x75eyL6pPhSdbua4QStjkH0WGVxkahyX7Qnmt8Cti+jNhvsPGwiYeZW9jR4YClcagpBavFgEaPVEtN +pmhLmQYTN1NS7CckLyVXsMmHuo9TdrIk+7KJEgePYnuT2p709me7PdUFz357C99TS9b0vSOITMjoKE1c+omWvqplVq8VhACvC4BMg+AK8LUAP38G0GAOZwCPEXiL8OIhMwlGbQeAf4SB3+DQ7+XsiJaT4Z9DGWuFEq4541WWkxV8tAqprDDTG1ySYdY2r6QVbOwtczo5lQrS1B88tVvsR7RShdlbcch4fn63zhwewHEN5wiXRRXxR8a8oOBG2krx -GA5UI0LP1HDg9gOIXrUruii/ij4p5QcGNpZGTbQJOmvXQdmJWG69KDm8labpW1FGOpbU3qYABkQbqW1NQCABxEA6lDTBps68oDSfpOMmWTbJuqRyZXW5C11Yq/2d7u3W+7kauC/ae0cPVcHmq4xqPNyYZNMnWT7J5qdHtoVdMeld6iYfqqT2GqjNhAI0NUBXa2hvp+wJMiu2WznBZItoeoMtnwBS6ZD8fEjH9i2DyHDjsIBvX5wpAZ9jjCQW6MAU +tRUrWREfcFALaVhs8dQbsgNijAh6Afqb1JGmAAZECGm9TUAgAcRB+pk0iaUuokA4n8ThJkk2SdakUmN1CQp3XUvwVKr91V2z3cbG913aKj2qgPdHmpMEmiTpJ8k11PenA7w9oOr0uDvt4DHY9QxwgIQCNDVBF2toEGfsEzKLtVs5wWSLaHqCrZ8AouovVuQj6kZMaik5yNsDj7BFYQlweEAPOYz9wJE1GW6CAU8o3RBRyhrRS/i87hbryOIbiPGt -8o3Rksvq5/H51C2nkYJ2KynVyl8iUb8ZOitcTwB6AnAEAAaFTm8sFCaBUzPATQJ9j+PuGfli8nneVta3ZqBdNW3w2Cu3lEnd5gmgapoGeD4iKz1FclvpspYkjWEXkd/AEVmrUZfx/qQ438HbV4mwl3a6bbpq5FkD/9FAvkTwAnT1B4gpAYgBYKgOQTCpc2+kWslJ5DrKVI66FKIYXNLmVza55He6a+F7C7IduItL2GGIXdK59kQM38CjE9hQziYr +8iU7h9y+zhjwB6AnAEAgaRTn8sFCaBIzPATQN9hTZsbl9lh9nRVra2vHeNHilRrzsrVZ1BdKPHRpoGeBIiczjFa0crDJYn7/UXkD/JjJmq0ZXxAaYIn8B7WwntNiSybYkgHqurGRJmngJOnqDxBSAxAPQcAaRMjqgxY8UKPEZ1YcHBjBcEczADHMTm9B0xqGeIqMi3D5hdkE5Y4nEzHc9z9kBIG6b9E9hPTbYlvVorr3RV38RKdLSRu0ND7TFmVR -vdwJb3RU38BKVLWYaHmJmR5U+wmamfTOZmNxzOn4w4aY3FmWNrhgE5I2X3WLKzXhwXaCuF11nD9DZk/bzObMKSCRI1DrVWrYFwhUSA55DYNrcH/ATj6uvZQ7lxX4nlZPayJZufVmYwB2e5vI2VMPOIGij8Qo0EwFnD1BZyrZ+qqyv+3pChLpAES2JaO0FKXdp24iUAsaMUTJTr7O7bKYe3oBCAxp00+aaMCWm6Y1p20zMwdNOnuJJ63bdJeEtMBR +yZGejOxnRBk+hnbcaZ0c7StBa5femd3m5nqt7i2rQWYcN86fFLh5FbRXLOyTkRw1TrY2voFwhW1fhpKGhtU2ssxEmfPiOjphMFS4TmspJSOxSUOaDgPbUkLebB3+NfBGJ+qX9uepGgmAs4eoCuUrP1UrdQQxoZxdIDcXeL+2x3bke3Uu6CjaTIo8jWu0boyjvJxOegCVMqm1TGprUzqb1MGmjTbE37VEKEtcWmAPFvizSB6Mg6zVUeiHfKffVDHN -L4lmkDMdj26qE9EOhY02IgCbBOQ9QYWF0A6CIRNgdMPoM4DpgYQOAnIeIC0Awj1BhILpyDTsxcqVz0G7wMWWvA0mfnbglcr4EkDshjwhwuy5Q8jJhB7DbIlwUkHxGBjqL4z1OpM6BajUDh9g2AKhF8c3FrjcAtQYgEcB6A9A4LKFlw6Wb+X9WONzM8E6zNrMH6GtgR0tfheeBRTC64hC/eJu7NMVPWXwBEI/svnSaeUT+qWPRkRkjEUjMQtI+BLq +gnIeoMLC6AdBEImwOmH0GcB0wMIHATkPEBaAYR6gwkaY5szIyzG4tQ8KeDLLXhqTGLLGJuV8CSB2RlhKJdYkwNu4wh5htkS4KSD4jAwDFPKEM+TInHhnhBA4fYNgCoT5axBNfXALUGIBHAegPQO488YsOgq1xwI1q9xvX3vHN9Xi7fcWcQuibkLzweKWLpRHv7Z+FdDFTlldZfAEQV+p+Syj5SvzCL3kIlNeW2CP7MTummkf2eFYf6hzQx0gJ0H0 -ydm5zvIwA6QE6D6BIMtoPoOsw3PvytzpJri+ip4vDqCjOA3OXyOusdBbr91lrbOb4WzLK5qOR40EQdWfA/h/caKCxiWTXMCr9GIq/ob4x/4pqPWshgiFwZEaqdE+x5XToasHBmrWZ74wvtgtL7edJWxC3QXgub7PDtisa0LpvHYWprMJx8RIGbPSGiLujGKZXTtwAEgc34nGw4Olm8VLI4IX4Wkm8GdqJzU2wk4ftm2vXdz71ik/AapNT50hnJqS +DQZbQfQdZtObs1ATZtc5hi4uZKKsWPiZY0uSdY6BnWLrrWwzaIoC1Wn0chx04PZAoHgmqB0UdjKsmBtDgzl4h8Nf/kmqMCVi6Mghq+Z5SnGKZdG3KOVcqtxmCtJmRnWmfuPsb2r9BIm4FNcVQW+NvM+HoJqcNNaa1KK8s3wbQsGMJdrCB3IARBx4qUbCslltY0pC4MHxDgvtT2YHUv7kl1Ku6/RYXNGz0TkCp/UtuCGUnqYjQ8S4HJwUna2T52uS -89QUs1GlLdRkpQ0cu3qXmjN2pvFpcD2KrOjXlny35YCtBWQrYViK1FZitxWxjoe5pWnjclOXtVsxhhe5YNOLGC42ATkAuCMBGABglQE4DHBaAUBcAQECgAuFjt/hHLbnOYAlYT5MdyMZwe1rdHJF4a7oCurK0ZGWQLx+VsYilHkQxZPd9RSQBKYGmjONXI2fTBM+Gsy1IXCbgocCxmcixQX59/5XMz0HzOFmu+dNzu9zqGtU3QTnG3NdxshNT9xd +3exIWlGt0FpyAC+y1UQAHLTlwgC5bcseWvLPlvywFaCv6Wr1Kt56hKbD1fSmL1luU/9KGPYBOQC4IwEYAGCVATgMcFoBQFwBAQKAC4UO3+DMuD05gZpqPoQKMgso4+FG7EQSFuhspOOEiBeCTsDFUoCiqLFgb6cBj+n8QgZ4leTr6ZFXz4ZxnLaBW/Mxnosf5jNQmaTMpmWrwFjKpmaePd2czFN/eTVsPmwWabjh/nfTdcOM3ngda8ayXSP3Sbpr -M1vOs2fLULXCR515flfqk3kg1kOIREhfMcHeRyeYtmiyx2+CeRnBOK2W1pv8Gvyzr3Ii64ZqBSYAzT/vK8H+CVZPWbNL146nGNOAIh9zy2kQ7gM8uv3bQ79z+xeezvdw8QpID4KSEHCnLYjJd5yHZFMgV3dDbwau76p/N8DewN0TReYdqsgXadbDHu5BdavQXybELPq9PZLNr7O7/x1eYzbnsQm6tUJ5xdNaa2zWRN694i3zdsTXKnWt0Q+31oxm +Da7sL8ApCAFHoLZxjK+MDS/BDzlguCN2Y127XtZlhWs4df0QFxMAapj3leD/AKtrrus264vSDGnAEQj1yIvLfTTe3L719sbHfaR2zHu4eIC7sGkHB3LKBWkq0+/i2W4M8Ul9YuxFQfPsDewN0XDTZPRslWOrZir81Gebu42ar+NwC4Ta6s92SbmFEhwPaq1D3oLI9sKeKWPElm9909iTXPdZsSybxLyu1rdEfkRLCZr4tK+ZAuBkWRbR98I9rpnO -/iViFVi4LiaYty2CTuuxWySb/v4gAHmV+PUtt8Ya2bLz1GS3JbTspDNbujuy9dfktCmEmIpj3WKerym3O2VEgOW0atsdGD0od8O5HcqDR3Y78dxO8nZaCp2rLYetIcY9kv2WzHIOmPdqbj1c03L8xoO55egxshNgkGfYDAEkArtdwlQOAKtn2BQDKgzgAshBu2ZZ2krRkHsG5DEScFjgaWU42g+ihmQCUtkX4NsHhCdyvzc8Eq7RnKvE8qrg+tu9 +666LCON+7LZYuf22Lhlji8ZZOtiXNt6eWqMJdEtx3ZVB2oOXkZ3UyWY5Ot4iS0sUsG3n2eQ89ZrD9sB2g7IdsOxHelbR2Wgsdx2+0cEtKORLJl1R4+slPu2ZT5q6PZDqd7ochgbITYNBn2AwBJAi7XcJUDgDrZ9gIAyoM4HLKwbzT+TUEqcBChKYViLHHtjneihmQiUwa8YvCGT7enBMmV+jDlcEf5XgzOh2jXoapnY2qrvyvG6BTqsNWmrXd7M8 -9wjXJncojVkm/3bYYdWurPVuh+WYQuDW3Dw1me6NbYfjWsLk16E/Kbs4r3ngQNpEe2fqKb3lr29sIw3TtLXKt+cR03AOF/G3R7zNdMc3I9vt5TVRcXfZz5uftzBbQBeldlJJojmIkB+u3+7pVUfwygHWjkBz9ausfP9AXzngIx0fsg3fN5GDiIJl0PDwLgZwbiP6ZIj1Og1TTgTq0/2Vzx0b5F4NFjfugvGSHk+sh032GctXXlZNunBTaLPzOGHQ +TceNgWybEFwe6iypt1a4LRZwWUNZ+PT3vrgU6s00UmuL2XOAJ4MPg0/kO4eH8u7jK+Nuixja6XZ8i6LYm16b9r5/c+/YWOu2gs9i7cSTREsQwDR2M25+/iFftxXIJcjydV/desmbSA1z/QLc54B0cz7v15HZRg4giZFDw8C4GcCDNg2SIxTmNbvYRDghB5WqeG9hZDSUMEQPN6u2+dDMfn5OrT/B/+cIegten1hh46Bawcr6KHCdSC9Q7Gej3wpt -JssyCYrNb7WHO+vNTWZWf+GuH7NjRi6mbPOmebj9TrQmkpBv5yQm1xwYklpFhQEb/wPcuNs/3MX8Vd93texby47m1HILkPHxcKNGOfbn1SS2tt1vmOvZBt1BeduNsBymjdjlo7do3TQbIAhTJVVhyGCJPknqT9J5k+ye5P8nbAAJ17Z1smv6yNCp6VE8zmJ61ugBigH+BjhwYEA9QBAPcCyfPBlA+wDgBQGWzKBRgktHgPP3itFO3TTHO1mmOHjK +Nie98dLPT3jTVZ+zu1xvGJpKQ7+LEXioOAb8wokN/4PoVG0/yKLz+hE+I5uvInMYrz9Ge/auryO4J7F9yTyvqFK2mTCTFk5rcVXa2Mh8lrk9mXMfkK+ToT8J5E+iexP4niT5J6k7YBuOdXqt0PbnKsuFz+ytlqHUMYoB/gY4CGBAPUAQD3AEnzwZQPsA4AUBVsygUYJLR4CT8Qrid+DcneugusPgw8NUsfAhLv5CnC8YkJuE+C379J4a6p9lfBt5 -koSq8KGbDbqfEhNwnwF/ZhuKuJBOncNyq8iF6cUuCbSnGl6TbauChxn3V3q5Teme07J7cz+hwnTQtcvvDPL68SKVClL2eHmz9222ec4dm4XBz6lkc/8W/Ap4At2V+I+vG7WUcKpSkKMSOuc0TrTzvTTu9ed2EjVbIeoIhAQB/Bw4Vmjrs9Y4v0jF6BwfV0hIQOPZQHEk19++8/eEBoHJT57gmhIhKLzISxaI2odLtYvG3cIZt32Fbeo3y86yjGyS +XkQDT98+ccpzEvW7nDLp41eatAW+nGZshzHX7v0uRnEI/jWPfgs76/dZ4ka8FZZs1mfryz9zZ4eDD2RDhHNxa7w7CmrXREFKEHDsCrsGERHT+4+yVNPtTu1lF9kFGyHqCIQEAfwcODZsNEKvZz6Jcq6q+gnqvv7J7s9xe/2BXvtzG3chFwWeWKKV4kJN4L4cgdbAEXRbuECW77BlvKnFeOPgjaxcov7oJxxp1TtKuzzG31V0lwziIct8hnLMgZzS -4E5kuFxeN4C5S87v9vibtLvLdmYZe0Px37LmZ4w9pvMvZ3nLjFhhb30TX+XkKxrVjybPPB8ACJzra3Q3jRR5NW1peCe/ZYiICsAnSyDLYm3yOWLU5ok0rZUcAeMWCE/IyB6XbGu2dhjnRya5FXcqrXVRn2VY83X2vbHDg+x60ctslB3XNthN0m5TdpuM3WbnN3m4LdFuQ3fQrW9QtB3+3elsb484AclrMBNACAODMQH0BFvMARoW0OcA4BwY+gST +/As7jRn+Zuh/zLZciaZnI1/AP8clmvAg0mSaKIptX5Lwl3fN+kEVhReWRhbY245/CaotCaaLUtk6iK9kfCjnrXPDx1q6RYCXnb0nnRxJaO1yqcJxus7TXhNe63TH5r1vOUZUvMDA3wb0N+G9WyRvo3sb+N4m+TcoIBTij6T22RGWeuX1QT31yE8lrMBNACABDMQH0BJvMARoW0OcA4AIY+gET+IHTHcMpu4NYV6Pmxg2PmQqUMxGEFZEKfsZkrV2 -+IHTBCMluoNH1A7oeRXgUg3gkxGEFZH9M/AMGAeWRRxmhttvSrFwTt4cwINohW7vbqww/A/fweDoozgFj1cWaLMpnjHydzTeQqsf6bYJpZ8zeXc7ywp/H2azkH4cudH38WQ50LNFl7AVDJ9pXQiAk9dsVNiSbGN8Kyk33tdmr+9zOemWyH5KQKaVh0E5BCB6gRgYN9/f+d/u39JIS5x9YPNfW43Rqm73d4e/Butj/Cg7n/hgKolXgaSCyK8DK/60 +NReVdBsXKOSFbi4FW4uA1utDhVlD2GZpecML3iaRNCS7bugUmrizRZhS68kgXfJWZyl726ockeYLZH1lwhd33aNp7OQVh5O9WWJYl7s78amqIkME9V+CIZjz5yVkpJsYdw/KTu52tiPJRUOw9wIaOsFxJWHQTkEIHqBGAXXD96bU/fVbTFPxj7w3d8/c0hO9vB3o7y66/eCG+E/+WAhiVeCZILIrwQp/rSPjGCW4mX9K1qkBgkD4Cg4LGc3LQcU7 -j4tgluM3b+FPdAYNAuAoOCJ1VyiHQF9uzToo8AsOvBuQd9Q7o+QimXM7ob7M6Yfj2WHHH6s0u8cU4WZvhYAT4oJKjtbBHKkU+AOAvvv7znYIG49RZERf4gtQRG9+EoVsZHol9I34ABKA8b5DXen5psezKPlBlfF7UzydsNu2vVLJttXhpeokuv321tg9BF6i8xe4v9QBL0l5S9pey9mXvz1HjV+dLI3N61y3qezlxOJJ+gJoOZAAj1AFwuZyoPoE +iruhtD45Iq9G5qvxh8l+27a+duCPpNul+TY6/9vqbLL8e715Hf4sRrPwkqOLvYdUtQow4ZK3N94c7GCLa7v8pjOTQhGD+e7+V4/cVd0XfgV3sTzVPVeSf0AB7NRxIFF9YL1bBrlT3dUKMaeTHCl7T4bYKaaqrHEANzx5688+f6gfngL0F5C8F7wvrr6PBL46Y5zPpEe9hZ7aLkueMB+gJoOZAAj1AFwiZyoPoEqAgy2QLQaoDHEqBshJa6TpO5ad -qDfS2QLQaoDHEqBshJahTnLyjtERv4X8dwpEHZBxP+m+OlIO6FkeyLfA40tXjt9I56ckear+Ntr1gQHfdeE2I7yZwx88nU3KfLH8n4zPY+ojJvDPtm+s5hWaBbo5+l58t73eIn1wgMckC2x2/iPAHgvzQmklCpaSVX45h5yrMq4PvgbSkt5xIFf61B6A1UL+78+s0vedXb+o91Im0+8XvvYXo1Rv63+ag8eS3y77B4Hb/5h/BDer3dDK/kpwQ90F +XimQwcU8ZxEl79V7nISeIIkdEdyIwkQfOXxIDU/y/1OivVMWu8YoxvNOsbBwHG029+Ytuen6Ppr6Q6x/kOe3uPnq8PY+P9WvjlHjl8hduiH6lnfCes43X+B/BIS8s7hDN5kdy7rBXbTJKFQ0mSvD7u79bzAYM0jeZjylEFPf1qD0Bqo99h57Zu593uKQVkZjB8/E/Pufn/r8yMv81Do8QXtY5HT2wAL8JiGeXu6IU8pRx/z6ifuG3B8xfjxEPuLt -2rn6R8aoiXUIQj/DIi2gFulql+7xtYYV+VDgPY/YCagN51+ZisN4x0TfjT6t+mFizarOArp35Nm64MJ62I2MN5C2QjLHz6g0jatxR7eLcHOJIOinmq7KeGro85EqBuio53cnEHL7/y2jnEIBeduvp7GK1RsKa1GNrp7pqWevmbZ+6qNIb74KOlibA++Yyv76B+wfqH7h+kftH4O+RnmzoRuQXi5ZzG+pj94FwMAE0AdAPQPoALg5wDHArs9QBhC6 +EJlpK+Euyr+ftp3Trxm2Hmj7EOVfjS692gzjj7DOePtzoDuhPkO6DWfXuPzoAmgOuC0eN4tjCqKzci2arCTPl2wtwGhmA48e0rnx6UWfZsOqSO9+lPCcQ13hJ5myUnjPoRCbri7Z6uh2lkbHaMvlXhGO8vn36Hq2QkpZY0ljkej2+jvs76u+7vp77e+vvv77G+tnjPr2eT6pZZOeNli+7lAMAE0AdAPQPoALg5wDHCLs9QBhDqBkgJUAcA+gAhhX -BkgJUAcA+gHBhXgxALC4r+y5JnZlusHpIgJA+1j8C2Qp8JcCuqpdssg0CXGD8CBoqJM075+ZVg15F+uNiX5kefbtS5UeRPlAEio1fmO5k+E7hPYIBGakgE2KtPj4b0+Iuh357yK9j2C9+S3hJr9YUmpLZfALKJSJEBvAD6qT+KOHxBkgayKiof6/LMdaneS/ud7p2T7ld49katJUBHA+gfPzPexJgwGAu55G/gsBzmqB7guRqn0ADBQwT0DFuvCq +gxAMC5beSLKm7Re6bo9DBQO/MGpBEsRlH5WmYqtIgluQaBiTbAcVhlYp+lbrlYFeGBl/7vkWfmgSYOmmES7/+KPkX71Wrbo17z6zXkvqEeQzsR74+4zoO6TOiKow79ezfvRTcuEhAvbt+Y3qs7jUgaHdA+QbHuGi8AYangFo4oCrdCCO21gEKc+G3gOYMix7sORq0lQEcCaBk/Kd5PO53udi8Qj0Pm4C+EBvv53eGAn0A9BfQT0BWeZ/ke4A45Av -v5/Y9AnsJf4a4Kc7RQYWtlbrKltM27BBIxOo4QAT3H/6Y2RHkAHNepHjj51WVLmPIQBdLkO4k+nyhTL/GNMg34jeWQXO45Bi7jxo8e/GoK48yRQUNQLe4rrYgXAcaGkhCUtQS2ynB57nwjNO/qEmjX2Sngv6sW9AQC6nYIXEiBQyJ/p9a6eHpN7YGeZrkE7GePARY58B66gIG6+C6DupSm9nmIH3aUcugC6B+gYYHGBpgeYFNAlgdYG2B9gcoHsB +MLf4a4C8pcUEWglZx8ngT8DeBZTi/5JAb/kjY4ucVug4/+9btgQYe7TgQ7ABkgqAEdu4AV26dWYAekGwBBPvQ6Na7Lkw7N+g1EN61sN4hcDxomSGJSD+qhF6bghSsior3QEiIc6rerQVP6Cekti863k4wWiafOi2pq6MBsnstrye2RsyaSWzuqdpy+l2sUb8BFrrp4m26gZoHaBugfoGGBTQMYGmB5gZYGyBW2u66+Obtpb4e23rv0y2+aHMQCS0 -FruE5amQkvHru+/Sp76YcxAJLRNA9wH+CcgtQBAaKhjAEMBsAs5M8AYQfQHABJ4qwU4Glurrjsb/YxwDQI3OJIJIgIeGfEh4JA3kJwhYwvLLh7sQRfA3aiOWyBi7F+VMH07LiAzvVbd2aZr3YJBbDEPYj2sAZzr1+zHt8FpByAXYqoBU3vWZM+sJsK4cKJQY4H9+kmvu7K67kFZA+BA5vRhDmsINjit0YvpOYK2D9mmF3+SXECjnAC4EIDnAiEGy +TQPcB/gnILUCAGYoYwBDAbACuTPAGEH0BwAyeCabEYtgcr6gkxwCQL7OJIA4GKKnHOZAkMMWlPBYwXLDB7sQefGXZBoAZpl61uBLlcECgTdr+aYeNXg/CJmPQMmapmuHlAH4e1Ltj5vBe8p160OFagNZTOSAarjN+iwfS4LO0/MUGjeKzpLIxawIZcDTeT8utZtmsILjj0eLQWEZa67QQdagulzgXDnAC4EIDnAiEGyB0wYfIMFCeLzmcofAtAVM -B0wsfKMHqegLrsofA0wQr7aB1YbWH1hjYWnYGa7pocA9gQ8HdyBoeAQ6o1OzgHxCJA7cvaHbAjoW058Y3GHsL4O/5lj4gBMQWX4CgFDn3aQB9hvR6pBg3ukFfBiAdGHZBKAVx58unDrx7cOs3kUEWC4If1ydahwI9B7AG8JRZj+MnsOjfAIxOdwlh8too6S+/aggT0YHYZ97AOeKgJa2WITqY4GOZIYJYmODlnra8B1rjSHWOqvPSH6+Djg55uuQ +GcGJmsWGlh5YZWEAO0fJRhKEQ8Fv5BomAZ6qrGRkLjwJARoVm7SGxkj6xIOYUCg4vmE8t/51uDdg/COhLds6Go+DwV6FgBPoS1592Twe8F2GcAV8F02PwXkGuoqAVuYTugIfYiHAj0HsAbwLZnZAdq3wOMRHc2Yb2anOFAaAaIEjGPWETBCRjK6K2Rll44qOcdkwHYh4sMo6mWattUpKe+jtJaqepIYuicmJRmY46eylibZChIoWKEShfQFKEOos -egeiyh8oYqHKhfQKqH2oGoVqE6heofUye2/nsE76OmplG5u+D6v0zdh5QJLRgGXQMtgUA6bjwALgmwMoA3I1QGwAACPAH+DQe2XolYwa5GDsDrKewEgREMt3AGjWhUOLoRwEzQTL7GSrJB07hBhft26eh4mq15gB5OE8E0e9Lg/DJBYYc4YRhrLlPbnhvwZeG8uaAYCFi6fHsz74W+wAY5taG9qUErWDdB8KhaKUvWp24X4fEbDoIQckhUB7Qbe6 +ofKGKhyoa0am8cgeBFARkER64W+0ptzSTKqgRICS0/+qyoUA4bjwALgmwMoB3I1QGwBf8PAH+CEAgfmm6WmXYcIZ7AyBKQwYygaPqEw4ppPARkgGyH6LluAQXl5BB6fqjaZ+lwYuHXBMQYX4xsxfm26PBGPs8EV+3bruEBhGQcy6HhFHrkHIBh/PsAgR7WhNZLBcYTO5lB64FqLhaGUuCFeG9Pux5o4PgWkjEBoRm+F7WB7rP5Qypch76YAAEIAY -dBKBngIVhgMnyIh+mAABAQGMcLAIthyjrpTcQ+IFp6/yOng2JgemHMlGpRmGBsL6hMygi6aSpkCI7wg6upEZThXLEkBTw6kbdCaRyMhcEAB2NqcHEOoAYM7gB8QZX4s6h4WPajeJ4ZGFnhx4TGFM2cYe35rOhQcmGEWm7uz6CynWhdieQPwAxZjgjgo8CbeYUfliWQxxusgARCjj/rARn8jlF/AnYV9bEhYbqSHQKJIdwGu6iluZ7KW9Rjr7WeQg +xw4AtWEoh6rNxD4gqLLv6C+Xzs9jTBaHJFHRR2GJMIqhc/um5dhJkCshA+MsicrmQOdgOBJAxoVCByRfPhOFzwGLrVHv+yNucGw+ddjn4I+LTtpGrhzGjh5AqeHqzq+hlfqZEMugYXX6FmIYTkHTOTfqeH7AqFoUFKkGFt2DpeDuJCQphESo8AbRvkXO6WQLppsivhYtnK4S2zzolHL8fwA2HpRGrqRHK2eITPoKeUvkSGsmRrup5khprshFK+Fj -Y67m2ogS3gshHrhxGcgXETxFwAfEQJFCRIkfijiRQoY9GMRrvpoEe+bERIDxA1QEW4AQHAIgBwYHQJBgxwWzl0BsA+wHBhpI9bJJHFO0kcJiscBwBRgpYGMqcGw2fHI3rZECaDijpYToddDtuukd076RUQV6FGR/UQ/A9AJkNgAEgQYT149AWzFCBWRiIuNG2R07vZEt+sYVeHORN4UCGYBHkfNZiuezr5Erea0UopwS9gtwhbWfYAiGkBvFLIo/ +qr5HoDEZyBMRLEWxEcRGEFxE8RfEeyHqO8gRZZSmXrrREH+BcPEDVASbgBAcAiAAhgdA0GDHDPAK5F0BsA+wAhiZI1bJF4ZOYLmJg7c6fBiRpYhMnFbOmMftXq5EiaHiiZYZoSjpZWykXU6FeakRawaRmNrV4mQ2AASCxBMbE1YR8UIIkHmGyQVmyteZfpQ41+NDhNETOU0WfIzRvwXNFjWF4TGFt+zkYNjjeLKNorgSpgrwG8OMtlCELUOGj8C/ -AvwKzFoh1ARiGqev+rfxP2z7gXAQCKtJIAAQRgNoyZR4wTiHtheUcVyn+unkjHoALsQORuxHsTB7kx4IDVHWMnFEODfAsZiSjZWIJAESWQzMXHGPcv/nEBrIUIHHGN2CmNVbJUfMX6H/kgsUcDCx5YENEwWI0V8rj2nwRNGZB8sQzZ/B89hw6L2bkUmHlA3ftzbLR8pCRZr8ayBPAvM0njvxLIw8a4J9svEJLbrgCcdIj3OJ3nQEzaWUT7FgRfsZ +ATMQfZHOojrmHT+m3mFHGaQxkAIq0kgABBGAejPFGnRIwXWEpR4CnLZXRdEegDOx45K7HuxHYYVHqSpkKFT2Q2MLT5buzpsPCw4mMscqKGw4DdzoucQBshQgQ4Lgzd+lIAVYvcC4TzEPwPQHzECxOkVPogBG4U8FbhKQX6GjRfbh8GZB8AdkFKxYYaO5zRzNotHoWbNgvz9g0iLiJeReFtUH6khFvfrggciuP7Wxk/rbHIhXsUq4+xl0ViHNMAAl -o4GuN0TezlAYAlNAq+EgNvFmolrpr78BGEeRJfRtnk64W2zIdpashEACjFoxGMdF7YxuMbOT4xhMcTEwxe8RwA7xooUxEIxUoUHEQAu4AuBXgnIMdAtAAaLOSLMOEHTCz4FAEIBCAgPhVGbMhobl6CKOwAvAmQAaAKo3MtkChpQgSQJFBMoODNc4KKfGDpH1eekU14XK3oVor3BePgmwE+CaKLEJsvXicD9etfuGHwBp4Q3FTRF4YrFOR8YYz6ru +NBi+6AKvEWorAXo5SWJIbJY8BT4nrYoRyvsbZq+CMUjEoxnnujGYx2MbjH4xRwITHWebRvUKbxG2lyGOefRs56BxEALuALgV4JyDHQLQIGgrkizDhB0wc+BQBCAQgM975RoVuqESKahC8AhskqpnwEiCilCDHBmMLIbEgG9szG5etTtW4hBNkuEHZaxcWKhI+VXhXE18dXicANepfkkHl+w0SZGGRe4b1b2GWQYrHOG7caT5zRq2K35OR5LC5GSy -94cmHLYqYdMplBx8uGgBox8IXYDm7+BiojwBKLLonRKnmWHPOt/olHxuRwKMB0wMANHbtIXsdiGcWvsddGBx5/gXAUAOiXokGJEcUDL/YTKAcGcc9wmtT4uicZii52dodyzEJJkKQniaCyDdBQg6PncKY+BcbjJbhxkSKiMJXXvuEMajLqNFN+dcbLFU+Y0dNETes0fkHzRjZh5GHyT4X/KreZ2JjAS2A5vNQNBchKMScYhAT+Dz+88Yv6Lx3sSY +DuLnaZ2oJvLobWBKiPBEoUuodEnOIUW/pORBUSPQL+RwKMB0wMAMHZdInscMELx34b7HMWe/gHFwxqieomaJJwO0zWBO5qCSp2JAmxxHCq1BU4geR3Jgkcs+DHs6aKgmGD43QUIJD6HC0PgXFE4Rcbn6gUFCQdBUJZLuuEDR3oUNHbhkAf6FjR5kd15E+w7s1rN+V8gCFQSSUhMQd6ihttE1BscRvyUg/egOB0sVsQiE5h4ttRYJR3sfolLxTgli -krxZiWwGq+sHJhIPREgE75KWGvu7oqWsQoIFYRwgYyHOuf0dfEeuQCSAlgJECVAmz4sCfAmIJNEdbxK+bSVqou+YOgHaxOACaQBXgHQPcDMAFABhADhPIvH7OAqJCxiPARIMsiaSHENsius/wCVYBEnHKcp16rLEuHcAWCWZCnwiJIGhwgkQXGYV8Vyi2ynwtykOwRJ/MVgS5athvRqky8STXFjRSSWmopJPwQrEzRSsYIkNEqbpsDMQuAM4Bsgo +Y/xkHKkb1Cpvkp66OGtpwFw0+8W9GaeivirwCBJQKfFHov8f/GAJwCaAlz4ECVAkwJxEbdIvobSeZbm+pqsoFe2JiXMBXgHQPcDMAFABhBx2g5mC4Yk7GI8BEgEiOpIcQuyFQL/AmVpjJscdyhXrN63rHPAVBZkKfAPiDHoiAcxc4e+RPKKBK8qFIfbHaGaRTkrcFYef2FmpixAUkZFMJrwQ3EwB+4Z8HkezRKG6bAzELgDOAbIL7ZQAxADHDv44 -dlADEAMcG/gDkcGIhCS0RoCMF7+R+sCEbOyYQuArBPcQI6rRXnIfzXKFFvWqUgJsbt68Ua4HdAKEgMKom0BdSdObxRgBghjXWzEDwB9A9ABLCvuHAKMDOAktDHCUcYIX/pbCoKEYl/uN3LxB5+EEaC5QRUeFxF9AiEAaAIAu4CxAJ2HKtrbBxdKianBA5qVEDqqYQChE8qNAssjg+VVkKq9J70f0lbqwcthGyq+6mMmdGo1CqqhuNqcammpDqZak +5AhiIQktEaADB6/m3Ek+IsqgELgkYfM48ul4Qvxb8LyjhZDxH5AP682Q/quBZ2ihIDByJ/Hn2ahRQxkhgnWzEDwB9A9ABLCnuHAKMDOAktDHBkc/wfmHF69zgNiPONYYZQ8cIlEwKpRkwVdHC+EAPyqIQBoAgC7gLEBHaCqt0fqmGpxqVEAGqYQFBHcAHgRKpEgUqhSAyqkNLvFa2jShybkhp0uqqCB30ST46q7jkHFsqBqcEBWppqYaqu2H8ZHp -aqcMeskhegdgAnip9QJKnSpsqfUDypiqcql/gqqbf4IC7piWiLwPYB8BCc/uIB53JFyXsJsIJPF8DHGWkVzh7CtuC2z/2H+LFSD6SIHiBTwwMKcpc8TXpYaRJRMs8HE+0AYVpHhcASy6Ipjfo3Hje3Li3F+GGdBikZm2Kbin4phKcSmkp5KZSk/uqsQtGdx+wAuCiujKYt5phZdAP7jUaUg6pBKs1AjiBK5IJ8CQkR3uiG1JmIfUnGJXyWwh78eq +8hf0uskSAgqfUDCpoqeKn1AkqdKmypf4PKlKJRYp2Gloi8D2AfAfHIHiieIHnspRUbCMPBTsLpg1HoU8wvbgNsL9p/ixU8akiB4g4fp4EpIXydn6RB5ODTp5aoKS6GN8/USvLgWtcZLE7hLCWZFNxFkUilWEKKWikYpWKTil4pBKUSkkpN7tNHcJFKfsALgXLlGG0pGsU5HOcQiWNTgg5IHXSzeM1EjjRK5IJ8DRQTKSSrTxa3rPFOGqqVxDLCPY -evFEhG9MgYip1XLvQYGoSJoguQjaRjqSu1KLaRrEYAB2ldp3aW2w9gp8BQYCQ1BhUi0Gjon1z5JjBqwZuinSJ6I9IQKNsm7J+yYcmhiMyNgBzIKmHpIEgtGC2wkGZTgnFYI+yO8lup0VEiDnCQaI05HIGxHQYPIHnCwa1Ebot/QTcZYtNwViQDJwZgMAhhAxCGUDIuxbJ9ACuw2wyyI6BA+oNkZCIgGDoFGPQoWg3oZ8wmLiDHwYbNt6LELrG8lQ +Ovy/hS5r/LQGUXFKKVcZXIfQVcT4C5D1p6Ovy60oR1JsRgAbaeH7Awdyszynw+BodilETXCaLEGSYu1zkG6Yv1w9Itov0ggopAJsnbJuyWZZZG2AIsjqYukh+K2QDbA7jrgpwFXZYIhyPaniq0VEiCbCwaMGonI2xGaLJihxKUFpiDRP1wWitBgWKUGxAHQaTcFCCwbQMbBrAwFc38SJaLsNsBIiOgL3n9bOAnybDgeRj0OFr2mnHGJi4gx8EGyz -0FwDQI5xq8JmIbhj5H2lvG4KYOlmRLwSOm/GCSWkEIpebGy7jpbHk3GOReQdhaLpWKbgA4peKZyAEpRKUcAkpZKRSnbYBQdklFB3vDgHhGu8MfZX2otkrr4gYjt+FoM5II8CqOUUStp3uWIVqnY2Y8H8IEhX3j+moSEgIAAiIG1KAAAiCAAPCD9SjWebLNSXUoACCIIAD8IP1JdZbUgup1ZNUoACcIL1JtShsoyY0mjWY1IjZqAD1mNZ/UjbJtSV +eSNkn6NRFwCQLZxgXHGKBJhpNzEhJvtNwyABHTuClFaBkdLH9OMKeCoJJjcQinNxlkcikxmi6Zimcg2KbilHA+KYSnEpu2MT5pJc0S7zoBV0AzG58OwFs41BFdvw4XpGWLgnlJvHjbFVJc8bonpYohvGj1JiRtHiAAIiC9SgAAIggADwgY0vVn2yXUoNKAAgiCAA/CBjSHWb1K3qNWc1KAAnCAjSvUpbKEmOJvVkdSQ2agBdZ9WWNIuyvUo1JjSg -Uv1JdSkehArUAAADocAgAPggTJv1JVSzUq1JVStJoABsIENLzZjWW1JdZNJqgD6ybUqbL6yjWTVKAAkiA1SHUnSaoAvWf1mDZqAMNljZE2TtnWpEAA1ktZbWR1ndZfWQNlDZo2eNmTZnUk1mzZV2UtkrZa2Y7o26NUttl7ZB2UdknZ52ZdkLZN2XdkPZT2S9nvZn2d9nQ5f2QDnw5wOYfHepRth9Him/qUMm5MQaU45ymRCrRFR4YOa1ntZnWVTm +0sHprS1AAAA6HAIAD4IESZjSjUl1I9SjUriaAAbCCTSs2fVm9SHWTiaoA5sr1K2y5svVnNSgAJIgzUv1J4mqAN1m9Z/WagCDZI2WNlbZt0XVlNZLWW1mdZPWX1kDZw2aNnjZA0g1nTZF2QtlLZK2QMrm6zUptk7Ze2QdlHZp2edlzZV2Tdl3ZD2U9mvZ72Z9kQ5P2X9kw5gOdvGdJ+RvBFu6B6kfE6QvqUMlCBAaTZ4vowOc1mtZ7WeTnfZUOf9m -/ZsOYDkI502cjkLZqOatnrZbSptk7Z+2agCHZx2VbIE5dUldnE5TJqTnPZb2R9lfZP2TDn/ZcOUDnURqyeoGROzEaF5FRfIpoCcgzwDUiJuuaQlHA+T+DdBoyjbpCQXYjGIIq+cqPtnHHwBKN8B+mbMUooKGZOv3JUJ2Pv04d2amECKfGQ6YkEfKxnkmq+ZFPvXHIWyKf5n8JgWQfrBZy6eFmRZ66bFlbptoreE0pXfvsAx+eSVYIGMpDFzwzxCm +w5k2QjlzZSOctmrZ8CnboY5u2agD7Zh2U7K45rUhdkE5RJkTmPZL2W9kfZX2ZDm/Z0OQDlERxqssm9GMabDGZRpcpoCcgzwPUiBu2aVYnfuz+DdD4yRbg+lXYTphIqec4PlnHHwG1pMRE6OiiPIWSZOqEFo2zmV1G5abmVcb06kSYCqjpg0euJxJqQVAGsJtfn1aTRG3hAALpuAOikRZUWaulxZG6QQahh5KWWb7AAfpkkGCxjClJ4MI8diC/e9Q -k+TQ+ZSbwBXMeVsOCyOx3qkaxRHMq2FSi5Wbqlq2Tmgr63R4erAoY5UervGj5ZChtl5K6vsgrUhoplZ4s5FSnZ57qAeo574R6zmGn26Y+TPm26zvmbnih0TpKGPqACYk50wf4PcBGgzwCkGaJzubsYfALcjeb5WaSD8n6ZdkJRgjETwqdx2QtxrAT7wpPLRZHwLdrcFR5uPjHk0aceS5nDp7fLCnvBtcavrJJU6bwkORWeQCELprnJil55q6VFkx +UlBMZyVmnE8pZAe+GRGtFuqljwmqX7GYhDSUtp0Ka2Rbr8WaRtepB6UuSHqS+0EewHKe9ObL6M5SEVew8mfqWercJgaYHqm6E+ZUrvxVETDH9G38eE50wf4PcBGgzwPpFKJ1ic/gfAPcoeYpWwBI8nxWKdnZDUY4xKcIHcD4czEbg+xgxZd+R8KGzzhQKWQkgp7mXcGeZBNtXGGR46TpyTpPmdX62GbCQeFzp9YFnk55y6dFmxZ66QlmpJDNs36Y -Zm6fFlZJeFkUE4cKWWgw+BUnih6ZZO/K/q/i1dCiaeQdzp3kdBC8T3lLxhYf3mVZ+UQHEtJEgMqa8mapgKYamk+RAB8FqpvyaCmc+W7qWOfSZXgByPumzm7S6+XhHG+W+YqbNMohXybqmcacF66mLEVMIAJhACAn4AzwDWB3QbALaBwYXQPoD2g9QGAabAmxkgmumRoUCQnGteo9DnCdkLvD6ZJ8MFDNOR/N4HDwHEGEEUJXMRHktefUcXEmRg0b +cqWfWzJhrHsB5spGsHfqviNdMCaeQ8IUVkzxJWW+k1JGYTi7d5VWf+GCmuJsKZ0mYprdFCmtJqKYMm4prTnS+c+VwHnayqu9FL5rOUbbs5VCs/FsFNJiKb0mjJjvkrJn8SoHxpqlv/H4AzwDWB3QbALaAIYXQPoD2g9QP/qbAUxrAlqhmThIorG5eo9CbCdkLvDGZJ8LswIg2/KiQCiikazEEJwQY5nzwYeWV5/+FVgAFR5QAQ/B6RkKTvJQFQIv -ElV+nVqO5SxDMl5n6cdkSgUop6SWikM+ueaFkrpEWWunRZG6XFl/O1KWrFFB7inkliafCH5HhonEHZDyEe0RrDsYtIgGhlWlIGc7VJc8V3ksFnIqKk9BlUWv7oALQA9J0w9QCcBDAPWJqk6u2qRVnNJYLs+oFwgxTHDDFoxaPZO56mf9jecpVpSBTw6Wa2zeFBwEPAIg/hTkaHGHUfh7Eu48FcE9RkeT6HR5pOHEFNW1HlCn5aNDqT4eZx4UkUWK +5lwpssUy7JJfOqFmop2eUumRZK6TFlrp8WY86T2SFnNEBKmSVJolB8YXy6cQxtHawzUXGBvyBo2VpSBzE7Pg0ltBdsR0EXO8/uUAtAbQnTD1AJwEMB9YOiTz5d5lWT+lPWjYSuYgo7RTHCdF3RZ6H25r3oDgEguICRCUgUVnfKNsThQcBDwrhR3qxGwREcHweLUWcHIewSeHkXGNwSAVgpw6VXHRJm4bEl1xI0VOmJJM6QkUnySReFloF+eZgXZF -6edOmz2s6ew7zpXQZABYF2Rfnl5FeBYUVUpuFkEbJhK7KQWcsuUSbRjxtLAL7nOKmle4WSZwIKklZr6WVmKGA+Sbrq2OUqtrkh90XREUhz0fravRWvrSGfRgyd9EiBVQrhH3sm+eUCGFNMCYXMAZhRYVWFNhXYUOFiyadLCh4bs5bm5f8afkWJQKA0AwAq5pgAcAfDkgnbGZGCDhmQzqnenem2NjxwyO9rC3AdyFIocCnBT3AaJu5SHlFCmGNwVy +x4TZGoBi7PgX2pyUSbS15hpIz4mxhFpSBqEEiFPEVJwUQAod5s2gMU95hiWlHLxHISwERMo+XJ73RBIfq5PRhrq7rcBvSQr5muAyZSFoRavoQCaF2hcwC6F+hYYXGFpheYVzJBlqiV2eUMf440R++eoUQADQDAATmmABwAsO+UZflGQYOGZA+qd6XaY4ujrEI6KiLcBxCf4KBH4FaoKos7kGhUUMHk2SELt+RfpK1A4VHFARaPoDpZxUOkAq8njm -hIur5IhmrUnhREUPB9OlAVPFtHm5lwF7OrPLSxHxWxop5zfpnmopAiZkWucFAJBhwAKadgDxAs5B0AAQA5EIDdYlQEYDYA+APQBHAwkEUWQly9smErFOzlu7PhtiK8AtO3wMXaGxO0bz5UF48fSBIEJEPkiPpNsc+l2x50dua3y+sTMUGpzTJgD6ASZFVCQopANUD1kkgAnjCwUcJwEtlbZXTAdlTAN2WMwvZfPj9lJua9Hcq65J4x/A6yEcqouj +qwF0KYnn1x9xYFkIFiKay7NEFANBhwASadgDxAK5B0AAQ45EIC9YlQEYDYA+APQBHAwkJ8WN+KseUCoB0xTSmU+N8tGDqkBINC5yyD+g3miq3eZ5A0orebK4Ce9BfPHgSrwHqIsFpAY0mYA+gJmRVQ0KKQDVAbZJICJ4wsFHDol9QiWVllOyUwBVljMDWUL4dZYbkz5IqnuS+M3fieQ6hiZUIUGODOeybu64hT6knqK+b7oyFJES+hNldMOWWtl1 -Odr6+pchRKYKF0puIGshoaWoVPorZe2X7JY5T2V9lueAfkROR+TG6Jp4peUAkp5wABAAQRwF0BlF8pffnOQDetnCSufEAwIGx0MpyyHkCUmsiHRnwPIQ8otdncanARtEg59gtdFIi9RYKZEUQpM+sCzPFrwUnlOG7pYgWTpUYakU+l6RX6Ui6DRIGXBlxAKGXhlkZdGWaAsZfGWJlyZRCWJhHNugDd+5UUekQhKkKvDIqt0BiX1qOHiiU8pt5iiR +ZbWV54Zvg5675qyTb7fx+KecAAQAEEcBdA+RUKUO5RkPabZw/LiRYbByMvannkZdhsh7R50bhosCexqcCLCYDn2B10zGBcH6lUQf2mR5h/BPomlEKfQnixjCVaV3FFpSnlyxaeQrEZ5TpS6XEAbpR6VelPpZoB+lAZUGUhlpKVwkl5jNhVZ/FMNO+UtwcSrha8ADrCmWnU94muAreNBS+l0F/Ou+kZhXwPrGFlGukto8FRJrbLNSEOXibcF7BbSY -Ka1sdFHi+QEdAb1lXwI2VfpwHjwXoAGhabI1S0OXSYg5ClUpX9ZKlQznSFPqbIXL5DIezlKFTJSoXc5SyU+hqVyldoUaBGyVoG3lEgKMC4AtoEMAdAwkaQAtA1pnBhCAXQEtjgJmwMwAaxt/k4WoJGmYeR2QAee4x8QD8ngzBBL5DcnAVJkOGYuhonk3YehPMYZG2l9CWBYBhlDvHnBheZgWYJFwjB6XAmXpWkm/FyzsrEAlZwUGUhlYZRGVRlMZ +8VfFXamEhMEe6kvR5QGIV9JxJW0rTlbOf6lzl8yeUBcVqAMJW9Z/FZREqFpuZyXm5JmqMC4AtoEMAdAXEaQAtA2pghhCAXQCthAJmwMwBqxSiXAlWFIpeeR2QG1t4x8QX8pA7eBX5BcmPlJkIlql29Htw47IcLpzFvef5X2kxsy4YLGOSboR6ERFYjFEWca0FdOlBZs6Q6VWEiFa6Xulnpd6W+l/pYGXBlWBYgH4Vzfi8bRhhRVrGxlYiE+UHkW7 -XGUJlSZQQUYBu6Zzb7AqFrs7uiffpImeKx2CBXiI9eVtZ2QY8SprwOGMIfCYl3ed0UyUxyU7FAobICbRGgMAKMD8gExVL4NlVok2XYCZ+UtUrVzKr0WVh9iackJaayBxB9mQ/sfYal8hviCxVzQVDK12eDmFAEOAFmaWFx6VRAUJsu4cwnDRrxXCmJJ2Fd5kpFJVXwm+l2eYWrEV1VWRW1VlFQ1W0VzVSmWMVQrnunJC3kUylSJ10LJEkGsISWXv +kpp2QI8dCEUgGMIfCZljRQBn2x8dssGtFEgGyAm0RoDACjA/IH0UjqfEPmVBo7FWgJ6VQxgNU/AQ1SNXhxQkWuDsYGyK4iPleylvaEM1pr5V10ckY+IsCU4U+aoOvhRg7w+BpTg4/mK4YOlrhsebPqryUKclVWGqVQ8XpVTxRnSOlzpTlWoV+VRhWFV2FSVXF5SWRGWAVFPktG9x3AL2AyynlPkkaw7KK+KgK2bmUlPp0JUdHZlTFQwV5lbFUMUf -J+IDfJBByNkVmElWJawUNJcEtuSBo21TQHQR9EaE7wRHSea61QejvTUupZnmGIWeMhTDR0hmqoWWr5l8aMmc5EgfZWOVzlXyBuVy2B5VeVowD5V+VH8UzX54SEWE4XlYoTqYShehZDqGmQKLgCSAQwIhD6ARoC0BdAV4MRze+YlhQBwYWQM4DA6AVc4HOFT+DlbYwN0BCQ0ZZyhqX+at1XGgQkgauZB+JqOnV5dOXbmEWPkNCf2lOZ1XiM4xFhMp +2OqfQGYlZEVo63RwQpo7eO2jtiVsBXohwHCF3SQSWIR3qTHK3aM5Va4GVRlSZV8g5latiWV1laMC2V9leDEMBRNeTVRpW5aoVrJs1QXC4AkgEMCIQ+gEaAtAXQFeAEc9vrxYUACGFkDOAb8Y5WWFYLm8DLI2MDdAf4vjMcJuBPlUeTxoxtYmjYMniVDVKR3hapHfJxXpFUfcgRQX69RukfEEl+3mQwlUukFcwmvVtpannsJLcZ9VZV31chW5VaFQ -ZEcJ1kVwlp5boNT6g1BFeDUYFlDFDXkVdVVRU0VTVfRXbprkXeHuRRQbfmzuXVRUXph5QZmF6lo5pWWzUjpLSKDgeRCRAUaIlcVnTV9sX35HVC5ihi4A9wBhDEA5YOtX9qm1VTUyV8vmf5W5gBjwA91fdQPV2Jxoc4A10gZnXKlp4njDbvJN1R/iw4uwZgx+1oiGcX/+FxYAFXFm4XcGkOGVUTYPFP1VXF/V8BfCmA1yRXLF4VM6Qu5zp3HmnUzw +VVYVxVaGXWR4YXNHn5B6UUGaxgidrGuRtjN3AZl5FW6Qb8g4AUSLFwjvRWIhr6Wc6axyiWhw8AaGLgD3AGEMQDlgY1ZI4TVONRiFGJ83JLUgo1dVPR11DdctWNyRkLXQXm7csWlMeTAk5C7VFtfDjRQFzBSC7FJwdi5IeGfkEmAFLmVpFBFsVQBaXFceTEkJ5txQHW+17XnEWkewYQhUR1KFXlXoVmFUVU4Vm6WSkg1EgKgGWJ0ZRDVU+KkAOBnK -GdTDX1V1FY1V0VLVaXklFyYbhKZlK0RjUDguyiiY5Z1BcpHN5WMMP65+jBU+mdFwqWp5sFFNdJWD5BUYSW01JroZ6ClbOiZ7z5aEYvkXaNJbzXbR/Nb9FGhTngeg61etQbVG1JtekBNA5tZbVQA1tfLXEligmoGXlatcfka1HlhJIvxMcCcCcgPQOabz1ipclgEJnKdPFWQoWjxy1qeIHnEbggBeBUao0/m3CYyQgq9UXKFpUJi2CBIDaWIVdpVG +wJllmkFkkSmVYw/CDCTUFJAcVnHR1SbmUt1BZbjVqu+NdApC1JNZyEO6j0eJXEhHqXLyElvAczkklqESzV6e0tbLXy1itcrXpATQGrUa1UAFrWC1hNaLXaVVvrGkx6dlgXDYxMcCcCcgPQOqb91u5s5C5uxwZSAbBxyuFqOsHwK3CXAbphuA/5aLhyQj+bcETLcCs4Xi48oWpaJjGCCZTdAu1LwoaWAVALNHn3B91XYrx5PkvvWwpNpfCl2lwWUg -qQps+nYZxJ1cXfUA1R4kgW4VINagVg16BZVXQYAVjHAYQ8QMtj0AK1R0DmARwFAAn4mwDACQYADTumJZyYapmax+Seek+sfYMsihRGsF8AYsiIS3mXJeIVUmMWTBTFFdFSjuTUj1q8ZSY4NUeIeUjlx5V2U7QocJOURw05SDllNo5ZU2z4E5WeUDlXKp0zzlQmEuUWhK5dpVM565XpUBpa+TKZC1u5Xqzb5pTcOWNN1QFU0tNU5eeWm5fDdG56qi +UlAsGK5YxwGEPECrY9AMNUdA5gEcBQAp+JsAwA0GEDVbpZVXNGaZ6sZXkL8gbH2BwhM1KSKEi3DgV6GSHVUiE5lZWRA1TVUDU+4wN06hICLly5ZWU7QocB2URwXZbdGpNLZek1z47ZWuX1liDfSB9lomJsjXKQRPoSyqsEXvHjlTOVp6qgkhSr6r5HObIXNMeTRWXVAGTUU2dl65UbmblNDbyFm5TYUMacgHAOORdAi7JmQzIp5bMXOAlwOCQXJD -MbZXUwHAAORdAK7EmSTIb5WsXOAlwCCQ3JUttLaaKisGjr8CUFT8nV0f+VZnQVYFXBXkuH1XcXT6DpZY3Qpv1W8GulHwQ/WfFidaknJ1ZVW35EVrnO43vaXjT41+NATUE3KAITWE2I1wiUXXJhEkTE3V52INxgYwLdbjV7MrySWV7eFGOpHFl2Tcg3MFqDfk1vphTdTWjq1JrSYqmqAIpUWVwheZUaVbNUfHoRS+ZKqbldJcMn+6IzRvnGVIeqZV +wkAT5xjrKJFahIfsroOIweJ/lvl+8PgwrG35YcWr1xxa5n/MwFXdVmlZhk9U3FE6fEmxF8BcHWIFmVfWCWNb2jY12NDjU40uNygG40eN8dcrEnhoNfxEV5y0fIR8YzpHDUWCD+au5dsVGLJHJlhWcA20FoDaVn9FrFZA1t1yJf3lyFHBepUdZmlQ2X4tQlbxUaVolTiXINz0fiWiFXqZOXHqlripYjU6+aS3cV5LUS3UNJubQ2jNoxc3gUA9AB0D -cmtLbyYMtLLYF5LNFuTeWT1RqvoAUA9AB0DxA6XMRxmB64JyBsgQwC2wcAQwGvaOFdtUFXOQdUYJikgmDIFHHCeDBSC4gxaccDsYrwLgnB5EZq6HJVM8dQlFxZjf6EQWe4TlUAsIYflWx1WFfY04Vk0U41pFQLRklBZoLU5Xgt3jb42jA/jdgCBNwTaE3hNBdWXlYB8JuUVLWlRTrFXQNyYiA9gf5Q3n9mcDUiBBaVkES2zxOTWJU/65YRd5aJRq +xAyXARwGB64JyBsgQwA2wcAQwLPYWFUXvAkuVcHpRrYMHkbgGQOa9ovAmkJTuoqMegVRaHBV1oWFVO16kWo3YONfDFURJoFPFWd2YFXc171DzUnkBZJjS832l49s0QfN1jbY32NowI43YAzja43uNnjffU4Fc0X8YFFsYenU1VFyUcpG1M1M2Z/1u3GSBWQyLajUl1lSei36a3VQcmFhIKEcAYQK5OAmIQuyde5F5G/s3VYt8TTi3apHdWM0Fw+b -kcAYQs5DAmIQByd+4l5P9lqlSVW1WPWsBsxcnoFwjbc20IArbSsl1t75SdUesKWjkaWxEUDxzyRi8AaQNO64Ha31py4U9V/mhDmElhqYBXQmfVmVZ63X1LxV80mKCBYG1A1T9SG34VYbRkUgt9YGC2eNMbVC0JtMLXC0ptxRW1XMVk5LCWN5ZVndCtBtQcsijVvFMP6YeK7VNV5NdZYbqUtvbTMGK+BDeLBK1DNaSWK1sEchFaVC+ZZ5kNsqg67n +YW0IAxbc0kzF2mYcYJAaWrEYWxEUBs2o6haccBcYUiLWkr2wUI+YzhMPgAVw+TTuc1iolrR7WVxUSTvXXFDrdAWPNxjcfVdep9XbGhOVjV80+tfrQG3/NQbUC3bppeeO7dxbDjVWvOj3MEbMpkJQSp/AEHuopRNZdR+H6ycTQYkuav6awWkRZNcBHwNnjsTWCFuJV0kNKaDQzUMt+ttg0KVbTfy2CtwrUYCitGEOK2St0rbK2UNd0cLX/tWldy0j -xP0QyVXxozR65ytCrUq1GAKrRhBqtGrVq06tXDYhFodytYs2q1yzTE42VMrQXD3ApAMoDOAQwFAD4AC4H5VGBUAAuBQA5KUIChWRgLH5SRx1edXQ4b+N6r7Cb5F7lQ0z5MWk4MERnobmZ7MQHURB3Mf8lpVpjRfVDO0Rd62xFEziXW2Nnmb82elnCRy7Xtr9X8Xv1bjVG2PtkLXG3QtSbfC0MViLR3HtVQnpm09VVRe4L0smhkFG1BzFLQWmZCTR +NulXW0go9wKQDKAzgEMBQA+AAuD2VOgVAALgUAESlCAXlkYACRdgUJGuIsOO/ihqCwj+Tu5MNJ+SFp+DGPJ5enhan4qR3aSHmmtZzZdXdRG9Va1hFXtcnVLtNcfc2rtTrU83Qq71Vu1dVO7Z83etPzf61/NALcG14VD9SgGam/CVt5RtQSodQ0sshp5EkFdec1Vvy+xbe1ptqLQxWZt5dRfmOxBcBhD6AmgLaCOweEKW1vtneZW2ftDKrW18tEgL -B1kttbYdX1tBcBhD6AmgLaCOweEO21Qdx1DB1YN3Bf21a15QEl0pdaXUjpqZCLqfJDwPcCu1dwvYLi3uJoiGjpqdg4Bp1rteHgQmH1UXcR6pVO7TcXgFLzboqmRjpeZGwFNjd81ntgJkG08JV7S/WcehFRG33tLnRC2xt8bYm2wtybQi3txTFfir7AuzWxXZl07Ak0XFddZQWFlp9n2z2Q/9jZkxdL6WTUUt3baPU5dhIXJXcNIOfEKstq5dSU4d +53+dgXYjpaZetU8DRQxodw7W1iuoQybN/HfeKzEShtl7WZxwc1GnBS9eFUJqU7ah5SdefjJ3ztW9Yu0PVY6cp3RFtLs60btQYZ8bbtnrXu16dh7YZ0nt3jaDVzNF7by5OkQTe/7xtxBYbE7RkSsm0mQgXC+2MVIXfCVhd01ZiYARaJS0lgRlLVTW1NElbS2vREHTJUfRWDSfHSFEgER0kdZHRR1Ud5wDR10dRoAx10wTHT9pO2mHVy1KB4tTuVcl -NnnzUXx1DUb7OOQKJx3cdvHfx2Cd5wMJ2idRoOJ10wknb9rhpz3RK3MdUrZslrNEADiAJ2PAOHDrApXfH73pQxGuC3ykUQfAZ8lwAEmHMz1UCno+yMmShWZ9Fg6RUY5yjzS6SJPY3XBBZaDjqGd+7eY0oVc+mwysJ7CWOm2dTHg43BtgvWN4/FDneVWCJCWUQXJhB1Wz69xHPquBjiYshlkndSuhW1pNGMl/gyOV3bWUSVpJmcC9gKurB3D5m8RI +OIBHY8A4cOsAJdAOPemjEq1fNa3kB8JxyXAyyNlZA2AMHaaHVtBKfRIE6Oq6Q0YDyo7Q6SEPQXXeB5aNjqSd/5Ro2XNRhr8w0JdCT7XgVftYY0xF67c82wVIdZZGJZobaDXcqEFtGH+Nq4HpIyy+9vZ3EVhIt6rL8xdW52l183XCXP2ZwNDUP5WqX+FFlS2nwVKF63c0wy9AhVPnYgwULvAfADGTT5qkdOaOXz5DTYvlTlTLVqostnOeUAK9r3dD -ACFEhe0mpCFvUIWSFVuMFC7wHwHRmhQ9GB96YdXNRKrlA8hdy0GVfLcoX/dJlQKXlANvZZUil1las3sdQKLOQnAthcQD1AhgVI1ZY7bligtwJIAg6U9eDPCABBXHIk3dwQ/lT0jhhxXIqYeyKgz19MTPVJU4w/bJSAYsYdUhXOZg3a5kiofPY7mWd7xdZ3FVovd6XTddPq40ruG3cjXtV83qi19xYIEP43Qg4GF3YtvAMbpq9+0eGiIEORKiHtFV +HblPrt/ErkJwCYXEA9QNoEcNP7kOD1pacSAQfAzhbeWBacQNIg3QcId3DrgVmehQ9gHGJCRNsQWvCCo9fTOj2sVOMN2zFJZrZ+b0aY+kBWE9QsT0D1eduYp2QFDXSlWH1cBep2mNGVSkmlVJnbZGDefjRC28AAfTdCDgdnRN0FJTmvX2jx1jCRBbg75UA1BR6NeQHC9aqUt0JNN3go4vogAOggHLcS1y9w/aP2UtU8AWnYwLygxaMYA4Fr1wROvX -baWHiV2rhtV3dRTQSXNlT6IADoIOpVdZmlYOX79h/cf3tN8TFPBFp2MNcqk8rvbV0c1b0f026VnLazk+9ihX71GVAfYK1B9EgAf2MtP8fDHh9/8Sj0YYcAPcD4AygE5WJ9wVaZBWMY8IXwBoXwjxxvApkKI6esw4V5AZx3Aq5D7GcEudyyc27XSIYJhjdP4X2tfY5n19Nhu81oVzpSN2nt99ee2P1SKd8WLON7bN055rnLuAdAzAAtgdAcGIGWEA +S0TlB3RIXyVUhYpUXq85eUAj9IlTh1vdOlV/FclWGHAD3A+AMoDGVjvRsAPQHGBshbREOLcKOsbwKZDcOrrIcDBo5yneb7CrkAsbgSR3FJy+FijZnbKN3wKo249UVfobJ9WjaEUXFtXXo271BjY63WlgdS6009rze61WEu4B0DMAS2B0AIYTpYQCrY9QJID7AlQPUCcgAEB0AYQ3KjSB/gioUcAxwbIBhBGgMcGYDEA2ME0AAQq2JIADURnTkXDW -y2PUCSA+wJUD1AnIABAdAGEMyo0gf4DqFHAMcGyAYQRoDHBmAxANjBNAAEMtiSAuAENTrdhdb51ftzAAyml1WZbE1XQPwPckYyaJjvzkiTRb5zxxcWm0Ft1kHfr1ZdW/VS3m6kzUeWdl1QPEJQch7NuzVAT1MyBDAVUEnALAfIMP1W9Pg+U1+DAQ+uxBDGECEP6EUAOEPWgQgFEMsALqZ014a3TbRgFlj/VSUnx6AN714d9JXKqf9tDaoU85Q5b4 +c0cwDUpzPYems9bLGSBY4LpiE3pdoJaIiBocWkGgJa9RWSrRNmNeA1991bZL0cV0eF02tlwQmBx7sG7NUBPUzIEMBVQScAsB8g5feP3lA+g5WWGDK7MYPAxZg1AAWD1oEIDWDLAJS3lNmdpU1DlsutS14lhjqv2NN/SXJUG9Vjkb0dNC5aWVLl+TdUBODu7BBymD5pO4OWDAGN4O2DgzYoHm973Zb1claeiLTxA45JxY3955ZxDsdRtV+WhQV6YQ -NjliQwewwcqQ2EMRDf6NkMxDTHb/HADYpZH3lAOeiLTxAA5EJYwDH5ZxBydztbBUiyy/XV1UxewmSBDgZ9O6ktd4aIkBQVmhg82ok8FdcW0J59Zz0fGHDNAUJ5MAf62JFHfT5ld9pVRL3Atc3SUDcDvAw+gCDkGEIMiDYgxINSDMg6GK4A8g3ACKDyg6oPqDmg9oO6D+g950D9IIcmHMAh6WYNgNfVdSKcUhDsWkSyZIKroDgk/Ve669Evu4P+En +zp88wsm10WSBMrq7GiQO+XYJxzRiQ/l7UT2kXVePdANGlIRR5nwDujeaV59lpRT1NdanW8autZjW80lAOA3gNPohA9BjEDpA+QOUD1A7QOeiIuowPMDrA+wMkAXAzwN8Dg1L12l9qAcwD7pL9T3Fv1UNZCSoOhaUmWos8LStGgSJaN/1O4z6YL0edC3YvQfty3YP0qVgley0H9JLc0yqVhLWP3tJinjPl1NqDRIDSVRJYd2RDVIdEOGMrLVCNgja -gyb0bxtWfJUitTJmK1H9qlcSP0tZ/W919Na5S/1e9XLRUM8tqoIZU1DgfdZZmVFI6SPn93Q0AMJpyPf0P/g9wMl34AHCpgBwYK7F0BsgMAGwALghALaDogPQKxUVhgVScmPGaMrIr3C6CbCAoDayNdxpSLQfQJmZBLsuGOtSVdlnN2Pbs81/cALN9WVxOZnlUZlo3YwPjdF7SwPP14vTN2p1lVQ8N8Dzw68OiD4g5IPSDsg8Ci/D/wyoNqDJAMCM +lZP2H9+Q8f1qFndeUDH5fnfgD8KmAAhiLsXQGyAwAbAAuCEAtoOiDp9zHYq1cN/wPjI4aRwmoSwgL/Rshnc56Rsgh+cJJ/lBV5dqFVbuxCf4WDDFrbg5Oht1b8w2tUZXV36N+av7VGNaAy13yxHCRnnLD+A2sMbDZAxQNUDNA3QOgoDA3ABMDLA2wMcDpw7wP8Dlwwz2P1+wMwA0eEbWnUd+/0NDaEoxrU32wecNQt7rR0hushzdHnfyk5tfVcRg -6Deg++2pla7lCP+dMTeXW9VCKtSIFW+KClXT9EVTfKqE5wuymt1JNe3Vxdg4X0HLk1HDm7GpIRkPVFS2XfiVD5E9XMEFwpABWMUAVY2MOnJUOCqQASqjomgoDI4pPGvmh8J5BGjXAooobtL1XZmfcbrUZ3/kto1HU31J7cnld9RVZcNx1dnT325BffSKmAJPA76OCDwgwGMfDwY98NhjSgxGNAj5wFoMxjYI/nUftkTXums+aNbzbMpx2IsNrwtF +UcMbn0CIQ7hk3WgGQI/33PWKmTGMUAcYxF7zNbbTDjqkn4q85JoL/bdCCjfwMKPkClFXl37Cx1eO1nVMo1ANyj11ZvUx5NzY9WRFOfS9WTDMFfEWadWbT/G4DBo0QMkDxo9sNmjew5aPWjRw3aPnA3Aw6MXDuFYINUec0eT4OR9wzVV3pXGVIPiJNQQm3yDXbHlJvAdQ4FEc+6gwCO99k1eF0LaeLb+0QRPjnYNC1f7RRFK9YlQiM7doQ3t1GqGD -nXWFtpsTRaZS2DkLYuDRY24Mb9w9XiMPd1WU930dDEcIVQTrNRh0kNWHXa6fdZ8d934deTIR38t3/apBCjI5KKPijko9KOyj8owdpKjCpnUMIdLNXBGh9V5Ss0gDAo+gC2gm/hk7xAktAOSkARwHTAmWybgBCOwA5EMBY9erSgknJrvQEHS23EPDI/ieDIaXsYnkIhmsU4EVp3kJgdY15EDodZQPut/5NElHtJcYqNsJrfU6N2NLo8wPIFU3R6O9 +U025MpJTg0m2ZI9OSUj1I7SP0jjI8yO7aeUUyXPdpNTeNx2CgX448hATtb6FDJIxIC2gS/nE7xAktOOSkARwHTB0wi7MG4AQjsOORDAf3fK3Exsxgv0kCazdxDoy/wPyOmQXGJ5Bfp3FD+GVjdtV4Vp+YndKMJ95XhJiUJ1XYKDE9mfaqNID6o9MNEeaVYX0fVGefsNWjhw7aMnD042cOOj8418WJ1oNVAC3DYg6nUCJXo7NSyKebuN1PiYJr/W7 -9C9nFGhjCg+eOAjUY1eMgjsYwYNptHkVAAwjoDT5FphqY9fpZYYivaTHd20X1pIDqUhaEw4BKMTVf6xYxomrFl1karmpbIJyDKAJgfWw1jklZTXb9DY+Yn0TgCbgDxTiU+k4djuwvSwVZ7BUOB0xtLP8Co+efTCDyTNdhqgo+gSQOBIgISfGJEDrxr6EaT7XqJhMJdo+hWENy4+uNC9E3V8XujbAzcPhtnA0phnjAI5GMaD9kzeNxjSNZCN7pZcl +jaOK30+5BWa52d98iSfaKJrbV0Hi+uAGyCcgygHoHVsiY++1aDzmhF3LmCpgXDGprk+5OxOFQ85BzCNLN3mMFQ4NTHcA+KOD7+9MIKxMIOHJN4kQ+KwkZLBitY7xO/MYSU2M6NLY/V0rtjXZJNvV0kz2OJIFowcM2jxw5wPKTs4wIPqTHcaDV1y4LZDV8UjwIxgEgdfSZPy6M9RCa3ks3tymqDMrp1UxNmLeePAj10Qsktt2rib6zT1NUexINL4y -Xmj9HFKhqbIU/XP3JNCaJibnk23gKmATEU8BO/ukxWBP1j2Dbv2tJIOV0mzlxDZSXHxHLZhEUN20mhOOOmE1zkSAjE/QDMTrE+xOcTK7NxO8T/E1w23T0xn7ZWVfI2x1NjQKMtiyW+gPsAdAIfh2NGtPiiSBwgkRqUmoe7MSxgBqW5EV6WQ8WlZC8CmUvqR5IwdeaUkDeGkY3kDVo43yvNRw430wFieX1OYV5w0wN/NzDoC1jTt7XcOQAbZftADk +g2SVBEvt2ojFIdB1b9sHahPoTlQJhPYTuE/hOETxE6RMYdiyd0bG5R/Ty34dUXegCrYIlvoD7AHQB75hTOmcIahKJIHCDDwFIA/lOQyIOx1mZFIPR50oiWscpsCeUsaSFIRCY7QgDnZiP7gDqLKQlr1wBSMOgFYw4VNqji+igNQVnY1JPzDRfYkVWEpZftDjkV4NBhWQ8GDDr1A4wJUATmFtp6LjkMACuSYA//FeAyAvELaBGAQgNBgYQQgNUC/6 -V4JBhWQsGLDr1A4wJUCrmhAFl4NEA5DACzkmAKAJXgMgLxC2gRgEICQYGEEIDVAIBoYngjhg5t25mohKtOK9dqu2xIgqvQFPomTXmk3rgiIPqRWQVZaJVr9Z0TiNSi50xo7FNV0xIANNFTf4PpCgQy0OhDUAPUBWoXQyyqM13YlM3+zTQ9BxHsKQyHNhz8YBHOP9c5aZALlu9ieSFDe5CKolDT0xIDlDqE5UMc5H0zpZ7l5E+UB+zCQ4HNJDwc2k +2iWpNhlILY/XYwRFddBJTiBJz3+jbLCEHvDazoiDGkVkHRUC9GbRjWnjH6T5NMWX7cMVJNqnvYPxDaTUkONCRg6kNuD9QIFg5Dc0503GziQ8kPgc+7K4PpDVs/GA2zi072WmQ/ZeSCDl9GEEMrTNLW+NSV9Lev369GI2vnG9KTfbPdNjsy4NpDzIG7OMQHs3BPch1EbKYfdKE+gAS0JwB0ALgowIhArKPVdt5guVkHEDTheZWASBosU/9CpYSQCo -PJzjEKnO8NiPaKWsRKPRLQnAHQAuCjAiEFMrxdE7VZBxAz1RTWgEMiTxwjj9dtsABoS8MTxTBweZBX7wODCcaPNBkd117D5HgcPWGFjahVOlw3bfUGTVnRzM2dA02L2jTno9uPdFJsFQb7AQsyLP3AYs+0CSz0s7LOuc8s4rPKzqsxsYazWszrN6zC0z51Gz3kD+0STmHli3bT4mm714tQ2tc4JSSDdWUoN13Wg0FNns9E5rxslSU3qFnI1SNMt2 +qBoS8II7ohP/dqQdDhzZ+WeqKNfI2FxkA67X49+U2AUjpok8u3IDKnagP4zZU4TMyT27aTP7A5M5TP3A1M+0B0zDM1mNWEzM6zPsznM5MY8zfMwLNCzjU6LPfF3kJLN0TEHtRrMp/PuZMw0ezmXYd9x46+0992s5NMpjQvgTUQA0I/iOQjL6F/MQjpTTkbBDoHWp4hza/ZtPhzZJZHOxDoI/IV4j/87kPwT6c4E7EjBHeUCdg+wC0DraNI5UAxwQ -CwAMX9L0cUOPT2Ha/0r5P3TUrVDzJT/3sjwrTyYkjOC4APxpuhZbkwz5QJ2D7ALQFtoSjlQDHBDATQAYhmmK7EaBGgnII8WHVKo+6aokuIIoTaGL+oiMTzcaGZB24dcsV5BqCVfXZmj7oS6080ak+1OzjD8POOmdhMr62OjDA4ZPeSwvZN1XD3MxfMWTO4wLO3zws6LO4A4s8/OOAr8/WDvzSs7OQqzUAGrM/z2s7rMtA+s3ePxjIiZ3EEo4ib0V +wE0BGIapouxGgRoJyDBFxczYEKtzlVw13Q+Mp5Biut+k8OOspwmZBrRIVNUUxq+rfXOGtFdjaHL1EVX3PqNV1Xg6ydYqMqOJVLOsVO59ZPUfXU93Y211adc8wvNUzuADTOrzjgOvP1gm82zMrkHM1ABcze8/zOCzLQMLN31xnc6MoBRKOZ0jelnTNak8XfkSgBzvU9uMtzTfUrJcUdGPjxhjGNRGOdBubeUCrYVcucA9A2EzkBeToXa/PaD37dpr -eTUmph44JRQ0W3zz/FW4IsUNGGTxYjijiWNzVZY+gDLYRcucA9AbEzkApT0HagtVZkETtUo9eS9jCFLOQ9j3umQRJCDdRr4UEG+B10Fi7iIKi80VqLweROPrhrUzONbzBi1lVetxwweEHzZi0fNGTnM0nXONKdZfNxI184LNOLD8y4tPzwfi/OhiXi5/N+L385rOBL/805NANES/pPy96NfCNJQwJOg7wg9ReXiad0CzRab8lIDOHwLLs4BFuzIE +fxAS9jDBLPg/92dhQNpCBnB14fsFuBVBSws/AbC3ZAcLn+dWPPmE7fi5ldpXrKOCgc7YqM3G29SPNKdkix2PSL+fXMMYDbrcTP1giixTPKLqi+75rzTMyzPaLui/ou8zhi4fNOjU9shYIgks8Qyv9r9jC28djnWPFG0+ccPAPzDRSePPzLFREu+Tl49VnXj5EbeMj5zARo4wTm3TvGrTu3eB0fjh8V+MmwgyTtOzlEgOguYLMANgu4L+C6MCELxC -7WNlLXBY92YLFE0h0vdMEdBN29FJUQvstJC89MHVr05UPvT/vZ9PoA7C5wswA3C7wv8LowIIvCLoi3R1ArcE4ws6F6tSwtzFhGWwBNAA5H0DQYuoUaD4A1QEcAcAV4C0CQCb+KSykxLgdJH0YLGLYLieU8A7OleeDJ5DBQ/qLWl39o8MEXKTfycAEh1gy311riWkz1MCxuk/z1vFXpauPA11i3MvsDXo5ZPbLPi1/Pqz+y3/PBLACxCO0pES39K7 +6QsYd0E3suwTbJQhMclJ/VnO7yTQOOR9AsGEqFGg+ANUBHAHAFeAtAwAu/hEsRMUH4D14U+eTGCTHlPDKzyXoQxOIwOBUHg2A4KPDCdgQezGwzNdnWP9ziPvxPhJgk7V7p9tCSJOIDo8+JO4zB9Q0vQB2o3BW6j27Vovbzei7vNDLB88YtHzCdc1Piz4MoN2LOek6UF0edkAXW9a5FTIN/1Tao8DkCKy2oNl1Piy0Vis8MRQC2g2gaw2I6YS4t2b -d3VdrFnpOZan6jwh04B0FjDy32zVqjwPQKvLrg7F1RT47fOaAG8QBQC2ghgeI1I6JSx4NpTXgy5pZTvq/6sLggax2MwSWSMSA3ch8BP7YzQBIDhYJcNo1PmQyMvVNo+TU0ZItTTzRz3SrgoLKsLjx7RhVul7M9Msnz0sdcO2LrcVqsKz3i74v+L+q0EshLHbam3HLnNjwBjtjMl1Vot4aKvCoD2wLNSBFkjpPGrUW05W0ktuTWS2ZduI6Gv4jNWZ +Lus35PKZXJfEAGrRqyeDvTgZrkjEgPHIfCspZKFDV4yAaF8BEriq+GppTviRlMQ96zXwuldHUb2nUrNfHlMiLppfdETDnK89VSxk80HXNLCw1gOaLfSwKuDL+80YsmLZbSG1jLp4TwALT4NauNWd2pKvCv9W1sqt8jf9djBPD3U2rO2TvKe3kSOSYzrMBOes3jUol5QJdOgRzTJdMPR0+YtOIja0+kLoNVyxEM3LP4zB33LxGGwCgr4K0MCQr0K7 -VLXTwhWDNENUhe706V3NeQ1Qr2CkyMEdgtWXM3xrIKSvkrQwJSvUrtK/SuMrRwMyse2QrZ0l9rLcz0NQzEfawusK8CfoADk9QCuykTA8/s1rguIKsiPQADtxWfp2M0GbBQjTq/pXCVgz/44DEIMQyXJbtFONUwBjdTNkDJjWfWbzxa9vPc9VjTCn0D/UwG3VrnfafPd9Zk1uN2LV884CIQwovEBXgowJyBXgzgJUBCAMcJsAdAzgJwtDA3sDsjLY +CvwriK0cDIrT8bv3i+C06nPRpt00CuoLEgDzNCA+gOOT1Ai7BBOOTsxkFq5IJkHkSkVxK46xumwUMGp36Owj8D0Tn+RPEY44TZfRFLCjVaxKNiM3qUCL5rRHkE91xgu3jDtzW2N1Lia5ytdjJ9fIu9jzgIhBViV4KMCcgV4M4CVAQgDHCbAHQM4CYLQwN7B7Iq2KMBwYkgB0AdAlwPLRuE9wEyEdAuANUBQAD/CLPirPCRGUSSksxvB2Myut/UV4 -owDBiSAHQB0CXA8tK4T3AvIR0C4A1QFABv8Bs85Mr20kj+0bw1jGrrQNGsJxTAdNFnCRgb+lBksfLp05v1Lr4ExUs01cQ9M1xzyQ60NQAHQOQC2w4QPU0xzNc89RBzCc3ZsObmZM5vmOeQ4uW7kPTUUN5zxC0hOkL+lR/07lSqhXNPr6ANXONDtc80OebIc95tObzc8KU0TrHR+tErBAhYXPAnIMtgtAJs3s0IuUrkkAOkRCSvA2CPHGFCRiqJNv +qyLlmLFpwIPE2Tj80L2tr3k+asdrlqz+1xDzZbHNmzzgxbPpDHQOQC2w4QLk0xzBgypspDzswnNQAGmwWTabern4MDlV5P7M1NbqWcvBzyI6HPgLjLRHPtN26+gAODps89Tmzhm24MmbWmynP/LSC0hP8h38XAD6FzwJyCrYLQGISJLhUQK5JArpLrErwRgo6xhQvohiTT1RSGFASNWigc0flChF3O9Dk7WGsDD9YxBuDzmM7GuwbSVe2MIbUKUh -X5IYUBo3cCi8/c0rz2w4Wu4bsQQzNAsPPdY0TLpG1WsWLQ0/80Z5m4/8G0biy/RuMbzG6xvsbnG9xu8bPQPxs7d9YEJsibYmxJuS0UmzJtybCm0auGzg/cxU8AJMSP1mzIuMcpjw0WrcucssDcksTxG0Vn5ZNM6wguktSC+S1dtZmxdO5dPs0SN0LlI/gsSWUc8y1kj8Ew9PgrYW/SNv9jI771RbIaeM37ltC3S1cj1E/w3Xl/I5+voA9QMoCS0d +ubtKG5VNobGG1hs4beGwRtEbJG2RvNEFG1Rs0bdG5LQMbTGyxtsbYq8C0nzj8dKtZJN4vZBiRihCE1mTJBQt7V0XwDiteL3fdJvhLrdVsv+x3a1Sa4jMIwJWwLR28B1ALtNWB0ObYC5+OTry+TOt8mMQ25ufzh29/MbleQ+yUZzyE0evoA9QMoCS0FgXAAdAbIE1YkgzgPoCeWPvtUAtAIk1thOVhyRCDJxVkA+JibPHagBl6ddByyAwOIHqFijB -gXAAdAbID1YkgzgPoAhWEftUAtA+kxtgSL2diEFmQBbVZCIkpwMwGZ9aOrXTcsgMPvY3Q6i5GaN25o1mMSr0QV1vbhhi2Ms+tDowVUr6x8xRu1rNi+ZMNrO49Nsiis22xscbXGzxt8bAmw0TrbdMKJvibmwJJs9A0m6Jt7bim6EuLTJqz2uOc5qymNBdLMed1WMs1OW2Ym5ZYg1Gb99p6uAbMUwXDnAMADMgrscAGk4Zd7s4WHfL/sb8vyZKPb7v +rRKOV2/+WEFUrgiw2PCL9K66Ed2Koyyu1LY8yVNpBBMymtEzzxVYQtbnIphvYbuG/huEbxGz0CkbA3fWB9bdMNRu0bmwPRs9AjG9Rujb7G6YsLjs0dxu2c021VU2Ly9sGA5x9kIcCPpcsx+ThBis5ErIEPjL37bu6bTCX7uDkw7Gf6zYTADzIi7HAAxOwXesvY12Lbtt95Vq8CvnAVu2wA27du7FtCRSBBjhZ8QTftypbAahjssoWO5xgpT95qO3 -+7gezCX1L2dogRo4efAk0ncNW3CAKGrwMFpbIVob0vBQv5pOMDLdM9lopmIy9pN0DA22zOFVFw6quUbda/Lv/Flk0rtMbLG6rsLbGu8tta7rnDrt67W2ztsm78m2budr94zL0RLN/rCMK9r49ND0iABFtEN5tar+KeFrbJOLu7WriZugTX217M796rrg2odwK7EMqBiHQx1p2m64QshbEO8zk2OKE5Q3kL6E8etwrEgdju47xAPjuE7gsfcAk7ZO +IOhS9lNgbifeUvyjN1caXXNVW62M1b8GzAVJr6A3Iv1+27azvxA7O+1tc7XW7zs9bVhILvC7g28NuS7rG9Lt5rZiwWvcbp/inWv1a468CWQgBN8NOLGsEI3b2npgcxbuUrk2tt5e1lrMbLO2xavbLCmxDFYdj43eOE1D4/ss9l8I8OuvjY5ca7jrx0pOvM1923p6/b/28QCA7wO6XH3AYOxDsxwUOyJPYjLJQXjHLBIx9vILEtd9sQAiENBj6A0m -zHAU7+kxM0H7lE+h14rkM8wvStmOxACIQkGPoBAMPAGQDMAUfguSbAInZoArsowBoNSdZMTJ0twi8LIrozKyOi5tL6I8qUeU8YgW25GikxzEhFQdapNSr1owwldTMSUYtriLfZLvzy0u2uOy76qzzMcDENV3vCbuu5tsG7220bu7bA+wdvKbwrr54BdlqxmFCyfAsxRfi9aldsN195s6oVtqrm8unRHu8v5er3u0CgDkHABAeKtodsHufLqU5g3f +TwBkAzAH77rkmwLR2aAi7KMCcDbI1QtzGLcIvA4a30xCSwubgaBJilHlMGI15Spcn6cTonRStE7OUzGxRr5O2KjCT4i+vKZ7a7VqOyLyG3ntadlewNui7Q2+Lsjbde+NuntjNkm5WLxc8rvje7ApxQPi8bSfD51sYj6qptPw2jV2Tpu3SJedFu0MbjkHAO/tCtvtvbtbbZq5Ptyb0+9Etclkh9IfxAshz7torizfCC2ZFa+MQsoQXKls6SODBNXF -bEe5UtZTehwYfxARh/HuweBzVn2nAw6yMRMoQKTVu6SO5LfI19N0KQfGj/iaj5BJeayT3PLnW7u37D+G51OdeZe/vNLjle1LvkbbBwzJ17NGwrtXz3e/weG7xu7JsiHRy5+34qPAI+Fnbk+3FIrEj0MWEKH18nA0/AnCDoQr7bFmvtfLG+2gvez2+4759r+DWusgrqEeDukNkO6fG0lMOwb537X/fCtgHEB1AcwHcB/gAIHX6sgeoHsPakJgzr67 +JvvSgdzw/q8StQ+WU6c0lLv/tge0rFWzGumG6exIu07Ui/VsM7ue+nnbtlByLti7Eu8xv0Hoy7kXcb54dNsSDs1OsSPQWYbnXCbf9T8CcIKihtstrt7hW2ybEvVEu6D/a8Wu4hA65TWnLQcxvvvjTPdvuyVU69tOtNs66/vv7n+9/u/7+AP/v/qQByAdPdQaU0lm9j+8FtxpwK3YBXgiCKMAOW701bQJb2cT2wdwRKM+sXpWymshKY5VpYe/9ewP -yPAHGOzlsSAdgFeCIIowN5YozJkOVs5xA7B3AEoPHOcLl2kWhU6NW+pRFRGiU80cz9Lg+phujm2G9ztFrNB/aWMzNA3vMszjhpWtV7rBzXvsHobZwearO48oCaAzgJyDBLmgAuCS0xALaCcbvgIPi24P2g0RdAhhfQAIJ+gNsn3ANMEMBXgWbkaD3AcGPUDwmeRw+M9rXkTQgT7GNeCAu9hxeAvWzMDVymndUsIcDqSrdB3mzr1bekYh7GDT23mb +XPG06q3I3idcU0BugDIGxAMOH9oZcYp9UGzV0wb7h4QeeH9S94dTzjOzPNadygJoDOAnIMYuaAC4JLTEAtoPhu+AQ+PbjfazRF0AUl9ANAn6AJGfcA0wQwFeBRuRoPcAIY9QH8ZhHQg9xv2RNCG3tlr4NBr2hqsyzHxxGKZTf7dtVayi0j7WZZtsZHba1ke957dVeOKbCQ8ptebqmz5vpDVSHACMw44DptKbem7ScGbJg24OMnzJwktPjMfN7MVN -+qW0f1D8Qwlvubdc8ltpD5SHACMw44C5sNDXZTZv1zN9AYCynC6KnMn75eBnNdNgWznPvdpQ4HLQ7xc4etVDcOzSm/7B5a5vintUB5vBDIczKdyndS4Adh9763ROgHEYKMAWFYPWE32H0kZspydaYt4pyKZx22z12YUBcm2CR7rc0bDy87BUdba89yhF7XdgRtvNu80N2/HzBwNYJ1XMxwf1rDe+CeQn0JxCdwnCJ0ifygmAKiehiGJ1eBYnBgLi +fs9U1L99TWEN69zm5AuubyldHNsnjg/ptOzXJwycGATJ4ugBb104SMHrKC/dPpMhAKMD6F13R41aHnDYs2WQ7HVGIhK0hjMdLw9c2FAnJxgtQHtDtmflvdD3c5sdkyJW9O0VdFxgYZHH2jUPPVL1O9n1EHqnVT0F908xVNhiDx08f3Hrx+8efH8oJgA/Hnov8dXggJwYAgnYJxCf7AUJzCdwnHGxNsaT4swtGt7pa7YuiqhzDayXzXPaKpzUKZcl -f4nhJ/sDEnpJ+SdKb3a8dtLR4++ctpjnLCcxltN28xxYzjq2WXXMB3s9tqH7q+9sLrHs80flLwp5ZtYL/2yju4Ly5wwsELoK2ft9HF+1DtkLaE6XP37YzX1SWnSO6K3rnPI0wsErIBxsfoAFAIhBHAlQJsBDAqMdseS08QH4tQAowDwA5ulQF2cXeNOw4fM76o9U4mQARHW7+RrcLfKRUKyMjaq2/h86EaLUZvzvaL4Re8f0zB7YGFyrIqCYtZnN +Y7M2ASNNFlY0xoOxN7a9kf6z+29iYvb8C7bO/zvZxS1nbgcyEOlHoC+EOVHd23csPbWI1HM9nJ269sILac3vmHrOpxQCIQRwJUCbAQwIjGDHktPEB6LUAKMA8AMbpUAlns/nDuzGYm1yMZYvwOrsuLj+bVWncE1ZFQQkXU8bGtz5oVwv47vCyV0kJ9dkAUVLKe0qOU7BB21bGRmo9nvcrtPeY1YI0Z88dxnHxzHBfHSZ/Gi/HVhKmfpnwJ1eCgn+ -kSNu5nIJ/mdOdlkxCdQnMJ6WeInMcMieVncaGieucNZ3Wc4nV4Hif4ABJ0ScknZJ6IcdnBR/5Xdnx6RIlBdIQYDCWttgxrAhcC+wwUWQo60dPqupNTNVqpawTksQAcGBhC7g9wDABsgfQGtW7+d473mh7c5z8sQTeXcHZAoKl2pcaXWlx2N/mkIHn20YMWm0vyNo4n8DDgMF/Sc3H35nntrhW7WEc9de7ZEcioou0zMnDo6Uqsrj1e5e1qrhF/Xv +AOCeQn0J7CcMHfXeLMOVpZw5yyrxRVdA+Bjpprs972IAIc97C3oebq7WMGkcKJoh9etRjEAAhgYQu4PcAwAbIH0CjVa/qYvMVju1W3O7FJ67sv7vF/xeCXwl+9NPmkIP730YcWm4FuRwUC+fDgb56i5LHI7fMIx7p1fYeen5XWUuN2Sey4egVpPfa0XHdWzvINbrXeQe9j9x48cIXbx0hcoXyZ3siYXQJ5md4X2Z7mdEX8J4uPcbXceRdDdbnHeJ -EXhZ2Rcln8J5RfUXVZzsgMX2Jw2esXTZy2ecXFJyPs9r3cXxfsVYIIiAb8SxE7s1BI5+8lnVwOG6tAT86/yd1jm+xlOQTOK1RMwTLVwAcbnPR2CvbnAzZfuDHJp5pYYTh5x653nD50+cvnkgG+cfnX5z+d/nmLIjt3Rh+3vsXn+KwI2ErA7UChO4mwPUBX5QgJUAWAzANPXnABAABAnAXQH+C5Jgk3H7umLl6JPjw8IOZDRaoZ4GxZGpfcjZG9oq +6Sji0pokiVRetWg4mq6NNrL8h4CMdn5J7i07Lt+3PvL7MnhiWYdS+xTVxMy02vt2bY5+tOXLFR2iNVHx3dv3oA655ufbnu55ID7nh58eenn552ixznhV/fvKFuHYhN0NwThgJGEmwPUAn5QgJUAWAzANXXnABAABAnAXQH+AZJ5E6ismnOl9RPyld0OsKxa1p3HzRG2KutYmQ3e/4FoH5K74X/nnUd6cPwOB5UuOS+B3a1wbdl1nuIbPh2Qd+HWn -7p0UzvMcmdsMpawweCgTB2cMAniR0CfJHcu6kcFnV86lf1nzF42fsXrZ1xf5HuZmImSHnk0F02C5VpIh11+NXA2TiVcrvb1HAJbNWOxSl/QAnA+gNgCG1IQMYeNHph4KfmHRl5HtZT5N5TfU3JXSVsnJ7GVkjLIsVB+R+HdXdPHSY+8DcvvXW0cj4BJuaxj4FriZ21O3FHxzKt0HMR5mfA3CR8NuujJk5Ff2dRF9eGVVMN0xcsXbF82ccXbZ+buA +b5cZnOF1mcEXeZ8RdXDPAHwkejlF6elXQRgjlYOB8bfiC3pFQUWmNrkm+GNm75C+FEma9ACcD6A2AArUhAchyScybih52ddr/kww0go6N5jfY38XdmOlzTubjh3iNrF2LWncmPvAR9XU9DV+rkPelO2HwayV3nVXp+Zc3Xzh9GvWXEBRaUJrL11cfJrvh/BXbtX19he4X+FzmeEX+ZzLtNTXG+LMrXUR5X0+5NdO3S51+FjfORKExFJxHjqy0/Np -LR2wUeXX5q4Ot8UjwNXRt0Ch1Rb3bmhL2DNuyBOFOyX7dTOf6XZh41eXTIp0+hgznR8+vUj268/27ryE/1fX7b04yWsjEgFtc7XkPftcmAR1yddnXF16DMvrGW2ju0TfQ6AeYAQwIQCVAtoJUDnAB4qWMOHqJIkBvknFZEYXATKGceAw0mJuA4gnKdcy+q3kCxgWxeIcGqgERA88dWlxjW8fC7A6dQPpnTfSrcC9lGyqsRXtexDcTbaR4suA6McH +XZ4wTeZXNbZSc9r+RwVeFHJV0Ovbd5Vyv1lHEp1B11Xu0+gCjX413d1TXJgLNfzXi18tcXTu64Fsrn2pwFMgomAEMCEAlQLaCVA5wKuKRjhURiSJAP5KvCwueViyjPrgMHJibgOILw3A2iWt5Cpe8XjGoF13Nya1bHoxDse6lex6ZelLZWz6cwDVzX1GBnca7Zdsr483jOvX1x1Le8rWnWwBQAMcAEsRb8QNBjEA9wGyD7AiEIRAUAnIBim3DkAE -kv5b8QJBjEA9wGyD7AiEIRAUAnILiluTkAEMCQY9AMQALBduPsjVAgGhl7PALQOI2gaSN5SfHblecUcY1Sih5TgkWm9iDmtzt9SItslwB/ke3NAXJcfbZ0wZfh7TNwHdVz1p0qeJb8c/afSnVBjWCsgBgKnPB3cW7A8BzEp0luIPN9Mg/MAqD/oCanlIf5tZzy5cFvg0oWzueFzDIwNeRb/0fDvHnC15g+Kn2D7aeSneD2UgEPRD+lsQzrp2sfQz +MDQY9AMQCzBDuIcjVAYGmF7PALQKw1QaAN+YuH8PAOXkV97U4bceUjiIJtKSTArrsAwlwM/km3Wq1Jt432207tT7e2zbeyn1J+ye1Q3m0qdNc6GcwCsgBgB7N9rVJybNxzam8A+hAoD2wDgPvg4Kf+Dwp8OUgdF2yAtXbE5zVdTnNRzOe50N+0bNynnmwA90nQD5UggPYD/oDqnQzQNeArkdyTdqBnIIuwcAK5EaAheDq+SAhQDpodyloF0YQxgk -N5/uScgK7BwCzkRoGl6xrCWlz7whRaCshXReDMCTDzxwJ4WzDZwRFStbmw+1vPbCFSPfh1O831vEbFe/8dq3qahreONWt+Ntv1ut5ZPL3q95FYb3W9zvd73B92yBH3EACfdn3F98BBwA193sB0wd9w/duoOV1CURLr5dbdrTkuDiiqkg56dwL76CbxChsRN9iXgPvty0db7i5xyNrngO5HOpCIO9yN3TW6whMe9XuuFtDNvLeae1DsWyIV4L4rS6 +5c8cAOFbPuxMRo7cy6dflPQyZf9DfN83cXNVl15ki3kw2LfEHUF6QeNbzl5VPD3o95UDj3k99Pez3894vdsgy9xACr3695vfAQcADvd7AdMPveH37qCFdy74syeWa3l9y+vfh5RbnU53SR2oS8QgbOxewl5ty/OW3SJdbfZXMCwS2Ln/Z9E9ktfZ57Or7ztyUeu345+7fcmLTcMnSnzJfE/gjQ5/1c3TeHaudR3agfoD0A0GMEh0wlQPQARbTQIu -eZbJ+e3NZTMAPoD0AkGAEh0wlQPQD5bTQCuzOAQi30AwARgLaAOB/5/q0nJpwK3DPVho/3rgXzbEOBJAzaZbT3Csvg62JVSF1osgFQu+Ed4bCtx62YXZa4PYS7qtyweg3s98Cfa30V7Y87j9j5UBr3Tj9ve73Bcm48ePXj+fdGAl934833gT/fc9Aj96E9plES3HvJjWbRXUY1L+oETmSyUsJUVXwYPbMuXAaMA+2x6iVode7/RRAB/gs5MQD0A6 +zOARC30AwARgLaBWBF57rVXna4NUPljXep70K6zvWoRfphzAsIP5JdnjtWhPC36PunfhVgdCLCo8BcxsYi49cZ7z1+o993kt+9fS3Q9yPdj3floY8z3c9xXKmP5j5Y8b3RgFve2Pu9w48H3PQEfcuP4ZeLO/FINxZ36Tt+pXrmS6UipoG3bkaUmyKL9ylfaryNyncqJpIyuTEA9AOoD6PuN+W2kn4T52vQNkXaU//g4L5C/GB5YMacUYgrmZAkif -gPc+03nbWk8M3ftz9uWHoB1i84veLxXGc3DS67kUgyix/n49o4/+VZhcQOgmIZJzPsIP9j1Z5fk93l7LfUH6FyXuHtWF5PehX09+Fdujpk+fPXPFVXY9QAK9/c+OPm908+uPh96GLvPPj1fc/PQT/88hP7Z8jc8AcKqbMlHc1AZmeQCS1tbjEwU00Fpi6j5Oe1X05/Vdh76C+PUrrySotf/7jHXk9cBXr8fuUh7NVueITND+kxR30K6aewroxxIG +EB/irVFY7cDdg61kkCNp0iEcLXzn54tTR704bHuyPEQaVsRrie42NC3yj1cU073d3TvJ5b11o8fXvY7o97PE91PeHPJj0veeiZz9Y/b31z4493PzjwWeMH4y2iptTDw6rsmZ6ZUCUfk1k64tqaHlMCb0MwT4ibv3Ch5/dKH391E/3jfVwvu9XvyycuinSI2OsbTN25Ue77053p4wA5T5U+EA1T7U+cg9T408cPLT20/fLgEUB2FPmp8U+MPfrgXA -tP7T50/dPvT/0+DPwz6M/YrdNa1cNPOd1lvunwjySBkAQz6jGQYPG4QDVAhAIhAcA5plAAKgaB6ysydBx+Gx1RpIKJgSKUG9RilW48AwU7AhM2zFKTX11Qe/X+PkrdYXAoEDdT3ZG+rfGTlj3Pd5nsr+imucmr58++P/j7fd/PALwa/P3BR7q027YLzEtV1btLvCSy0/U720iKJLeQAdK/Tyeuzmh90EV3VYeUDPAagKAmEAK7C0AEv+/qZvpP85 +kgZAM0+Ix0GERuEA1QIQCIQHAOqZQACoKAd61xUcGzwg4NhJjyKkDmCRRUIVCZBY4BAaStsxhCRdfE74G6EmC3uBwKAPXNl09ecvXhw5c8vTl3y+VTErxc82Pdj3ve3P9z/K8kXFi3K2K7kbfpMluDMS8o+R2WYcBFJX+Ki5Qlxu132nOOqwWHcXzwGoAAJhAIuwtAML2d4TT8L/JsqHwK9u+VIjgPu8Or6xj3DrIxKzq3Prpd1lbjwVBZu621fC -9+mFRoB/e9lIjgM++xr5xj3CrIjU8u1nHnd22+hUGOOQHZrkt0EfS3oRwK/9vtB9Eeivpw6O9Db5jxO8i9U71FeQ3MV1fPzvXz0u+/PwT0/e5Xx23KWRP52yP4hcHjN/dQ0UIEOYIOgeX+UOvx03VcmHpSxA+uvfbb9uAJHR2SEbrAb2y09XdIwMcvTB64NcjHcd+gC5vpAPm88Ahb84DFvpb+W+QYlbweInnIdwj1vrgj9lsbX5QOcBsgRoABAY +BzcBrXNwBu9z+x8Cm3Xiz9BtYzYkzjM93HKxLc57Wz4Pe9jvb5c8DvNz04/H3Te+LOClHjyq+LUda2wu33MfFCBtm7vd8A7jEm6bdv3sL/jcmvhN4i8/3IvnbetJC04OuALI58AsIRVV1HI77ty/g96eMb6QBxvPAAm/OASbym9pv0GBm+riRDzuvdHAK59shbn3WyBGgAEBhATXSlxglnJSMsnFPmz643PVRKzarqBouK+I+1VVQ5s5YWsjb+81 -Qu11Zf4JVyZDIpxf5mcczzzUcc0a6SL4huKK/wHnuHMzl7o3obtLFTMvH1pcPe7P3W58e9bRG580VrPzYCcXP4N9O/4fNz1fNXgz5ScBGATQD7w9APjWoPhl8QCuwJekGBmWQAJwMwAN6kgAOSS08ILuBwAJgQ+jKUfQHxPkfYTz2vbO/a+YM238jQwI9wTuxr0/jQvispeQE5zUmILevVx8hrH74ZcWb1LVZuxz8D7ZspboQGyDoPZIfFtwPODw +32pWAOgb/70AWHHsA6MOuHYFxLHgfkFxs9QfvL9s+9jV4EeUnARgE0Cu8PQHY3sDHpfECLsfntBhRlkACcDMA9ppIDjkktPCC7gcAHoFPo6lH0AkTyH+EfizczjpMon5Z5pcUCPcDNSjBYTY8BeQbp8PuI3msw7vJjkS12fUfm3LpvynHJ4qcuzzIMxvMAbIBA+4hHmzA/0nbX6ECdfyD0PBCnVmyKcjly/SIWep12xOuTnWTyd38m0C7/fQPCp/ -g+JzaQ7JvMA837kM6n+Q3qdeBuc1Q/n7vV7ucRb25Yw8WnLD9HNsPyp1KfMgG31t+6fqx1efrHhn5zaDFpAABAwAPACC935+zao6LtD0DCC/JnCPZ8QgQnMfayJeSHvUbgdzdo/xnuj7sN19HU8hVpnRj+F+szpj2c/jvMywC2xfC91DeLLiX10DJfqX+I0Zf9AFl85fRoHl+hihX8V+lf5X5V/bNsm5UC1fzYWu8UfBR25PNfcI72eS4ZIBcnDE +HO+bA37Q/vbUn0/uZzL+5oDtFpAABAwAPAM89U3sxq85atD0DCBwgJaKjufACO2JgL9A8mZlOnnQ0c3SPbp7+Xx7U4sMN+ncAw58rPHh22+XHHb/3fQfodRnlefXQD59+frDYF/0AwX6F9Gg4X56JRfMX3F8JfSXzM3MblQGl9VhI74DfaTJa5e2onUuFIPbIPU0pp7AgY2/K/ABdY8wI3JH/8PVfGVxE86DCtmy1wLBT1a9/zXP3COlXKT6OdpP -R3fUV7eURrxAvMzs1OdDfdN9x+jfkD+N/eDS58jvnnPr0r9nnuT2nP3T3V8G/HftD8afR3JcyyNULyqpd8FPqOyx1NP+hSj035Mo1eCEAoyvEBGAy2EcDpA0AicCG1RgM4DVv9tUZBBqQ8GU6PAB8D5zr14aGFCo+N/UvAAFPbOs+IXfO1s+WjaF8XsHP2VWLsJsOF6c/Znli8NPSvOahqsLLDRET8k/aX+T+U/uX/l8QAdPypkM/J20z/VfrP3V +2Dxk8s5m/Zx+G9s54t/znMT4k97rYtUSPP7Op2fkMjV4IQDzK8QEYCrYRwOkCgCJwArVGAzgFm9XntkEPA9gPuQfAec49dqRhQ4PrP1Lw+8OjqcLfppM+SjhO87VffvzEBfoz5xQKDLPLb6s9A/9l5CqbP7nzB+VTkP9D/+fcPwj9hfEXxACo/Gmej88AiX8l/Y/uPxl8In4s4yURXMq689yrs215C2CYjzWf3iHapFBcYss0bvqzJu6/qcX5uzt -+AvCYxEt8lBV1rHo3ObQYxeQHguo8N5TXcFORQ7GFbPsfnt3k1ZLpN5KxAo2AOxPxAMrABCkswa4uty/vH3B0AJU/zCCz/D6798Iu1UwsqNvrKQ6TKdKMqjiEOtauRb8U2A+OO8vm7Xo2I/6k/osBXpe2h8hX/1VMvY/NazF94f+PwR+E/SXyl/F/9AJl9FWlT8afjshK/icASvmV8a/lV8Wfmz96vkC8e1h4t3Jj2dvJiyw7cIk0mTr38wzHA0D +4go2ADhPxAUrABBEspq+ldknrPzkczVL+038wgrf5utiH2mUlNbKpIDqGYyk8Jp/o4qDkI3YWx8B2z5LNLydUbHn39Z+ozXv79/2fwt+y/Bnaz6GckH4ZzceRnVhBH++fUf/QBBfQrYj/I/eyAn8nAsX/F/J/mPyl84/6Xw89izFixot3DxP+WcUoIiTFRMThckITJPBikr8ADXlz4j3uNUWfgi9Emt2drXqG8rXj8tEAXz8nbrZtUnpN8LluUc2 -/jX1fgCk8bup9sl/q0csno9E/XoCs03h1duklr8g3qU8BkpJ9KlBG9Y7sb8IADb9gEvb89gE78XfvoA3fh78vfosdfXgCtHvpec1rtedXvgitNgOdceAHAAaYH0B6gHABRgCZ84MCcAOAJIBqVgsllRhM8brn8AXgGkgzuAiQLQqD9pntFpW2CtR/2p9dKEn29E/imcojoT4h3iO9xXmO8sPjj8xttRsv/vF9FlmACIAYz9oATV8G/hz8GvsdtfT +Ps68OPtk9ygMr8/4mr89gJr9tfvoBdfvr9Dfh0dDlnfsbXg/stvr0d6GlG8QUDGYlrjwA4ADTA+gPUA4AKMA5PghgTgBwBJANCtZktYFLzp2E5hFIhDuLCQdQtP8ZDLFpG2MtQ7oDlsqnPbUuJhgd3fuv8Z2gKBAPt78h0k29GViT0VHvGtatuLcQfiH8u3h59Kpvf9H/hj9U/ql93/vj8T7omYjTurEldlO9ynLZBVqJicp4CtZr9G/IpAe6xDd -qC9Auh39uwC04CAtC8OUvUE/7pTwKRN6wD3sS1XtnOt3tmP94XBi8KAL/wYALaANQk94dLkPs9LgKd7uozcFfuGtQDhkDdwFkCcgbGt6MH2ISeliRJxIf9PgESBocMYDmYoy9mtnPAc1vB9mpoh8uukmcrAX9dB3kc9y9nEdMfpn98LrMtP/jY85XjuNPAdX8Kvj4D6/uz8zbsasu/DwAX3ia8MahSJp5mGxOviL9m6IbhsYI1NkXjWVsRsN9F/s +hV9Gft4tgXr4tuLhQB3+DABbQLKETvKJcG9uJcavlJcsrrBJv4pEDdwNEDYgQ6tGMI2IIeriQ/gHUUi3s3I9MmVFjcPi9lARawv3jYd/EnYcQ1rzczLgo9yEg287riccQPqyswPly9mupo8LAWH9miNYCk/in8sfvYC8firdj5kWcLFge9lXtG1tRKsgg2EV9+KDidjcNjBiVgC8WzqlcjXp38T3sodcjjNNbog7clpmgCaatr1MAZVdsAXwFSJN -S8Mnk1c/ll0d99oHc+1lqcurjQCd1p70JPvusGAdJ8aGswCMzJIDpAfgBZAfIDFAcoDVAcJFM7ub8kekI8xASbB9gMwA6YLOR6MOoDtDickynLlZB2MGpP8PtYNSmPBF4PpJ1NBGw1wB1F0bOSBpXIJVa+H0CB7jTMcNkF9twmPc0fouMIvmN03/jLsP/lc84vjMCr5pBgD5M4BKAAXoY4H+B9gH4t9AHAAFwMQAByJoAjgI9Z/AfADjto6Mzli+ +OtXXibZWAX+B2AZwDuAbwCjQPwDBAcIDQ7pJ8gtkNcBQqXJnpswA6YCuRGMCID6/iTFsnDiofpjRV1rP09kCIvA8dFPAY1Gck4bPDZyQIK4TlGiRI+u+R4ZjqUVGsjMALqjNbPm3cqlggNO7q28Oge29g/m58egeD92urgAFwM4BKAFnoY4H+B9gHot9AHAAFwMQBxyJoAjgFdZHASh8LFiqMifpFcDKOU57hDh8LIEUluMr9NkrmsCzbhsCLbhR -N37jckViJVYvxqk1uvlbgOMpEYarhx8nXucDZzkQDMnhN9RTtM0MgJkJkhIt8sHiaCmaFkI/Njt8AttnN9vgacC5mUM6Hgb9TTgeco3kedjKNp9WHmKcuypaDBhCrU9Ps99IQfl0JAC0BCAJ8ArwEMAhAGPskQX9gTEEGxR4FyxPAqEEoqpZAFDD8kX9P2JeVlp0YfrGcYKpekdhqfVqQaPdDHmF96QRj9Ivuc8pXlY9XAdMDZ3ve0uQTyD9AHyC +8rbmz8VunoNGvtUAMgM0JwhN18VQWqDmaC0JzNig9LNlU10HudtjgXTVxTozUvdHN96ro9sZTu5stQaEJ8mHL9hmoNdeWsi90AC0BCAJ8ArwEMAhAC3sgQQD0YcBshR4Oyxslr4FpSmacjuE3NO4KFB9PlS8v8q99O5ic06gbW8E9i3cfvnZ8MZv99/foD8SQcD8yQdBdMBq0sLGtSDaQRQB6QYyDmQayD2QZyDuQaMDONhSkeAFesf/oKC2WGoQ -BQecAhQSKCxQRKC4AU38e1gBs5QYVcAKi2xg0HgD61HDZaRA6p5MKP58Acgtbujx9iAYaDsnsr8Nfhg9anjk96np1cqQiU8XgWU8TvhU9mRpQsBWib9K5rwU6nqDsM3hb9BGtKEFzF0BlAHidnAB0BMABQB8AJFBYrEIA/+Ac03UCysffs5AF4GSApKhFAxiCT0oFnV1YxFkgivLn5nVNqNu3uQcxVnp1Bdj9cBgfcVI6gDd/yDHUMPiDcmQUkcs +Q0OADlVjrs/AYRZPVEpgG2FKCQGlV9QnhPt5Qd386vua9pfgk9efnE8DtgudEngx9nxmVcMAaaCpvjg8N+lEMoFk9sefpy16AR8CXQUw8JADwAugMoBQTs4AOgJgAKAPgBIoEFYhAB/xFmu6gUVoJFtDgvAyQKxUIoJMQIeov0dqs+c2UAmVcrHsAxnlqh8EmoCa3nM9pOu7UWgYKBwigD9zjoH9TAXmDugTqNKQVp1oMMWC6QfoAGQUyDzgCyC2 -1FMDHOu4CGiJyCFwNyCKALyD+QYKDhQaKDxQZKCVgYdslpj2tOquYNbdqED4XjUc0XM9s59rC9tpippG9JP0gYDOCO6lv8MXk+Dw+KQB9wPP88gd7dCgelN/bkqIAEsJC/wKJCuQGMMKphaEnakGZkCFyx3asFAXep4xO3HsBuXr/4D6pcFj6j5cN5sF9L6ihDU/uj8/jlWCsIWDccIayC3AeyDFloRDiIaRC2wR2DKId2DG/uEse1qjUaTsgCKg +QRyCuQRn9QruLMKqoek3Afn8rwskcYXG6c4rt89ltgtRq9LX0gYBAC8wuc5N3nqto7gK0/wKQB9wO394gePsJLheMzXqkCuSueCA+JxCuQGFNORjqFDam6YUCOywwwVpcfwTCQfVDWsDPk1FEbIvVP/Gv9G7o4cU1KcVdAans3DkVN9/hPNXPvmCWlszt3mqhDSwehDywVhDKwbhCawQ3tZdo88LFuEIVxr/8VduNQmMsAQtXvRdiKvMtREMStfZ -qcog1MiMFDva0YgXxQ0xJpFuTkkDeTqvtCXu+9LgZ+8MFvx9Xum1cRQpuDA3od8xPhHc+rvQCqGkesvgUeCIADwBbwfeDHwc+DXwWyB3weJ0rIKm8hSvw9GnleCAEnTAsTjABagPoA2QNUAAIHBgg/DwBVsPyDcAPEAmgKYNxnkJMhwon4DSKxQZEi3Aj+O7VpnnQVG7MkhyrmOMTRhs84/jGZtnohD9HvX1Art8chugKB0/hhCzHlO4awbh9HIf +qkdmzgODiTmR8P7pJcv7i7sZ9nA114i91hzouDBficCHXqx9zgUzU8AfN8IAIeDjwYvczwReCrwWyAbwQx0rIMG81ukud91hG9Ffq6CIAHTBATjABagPoA2QNUAAIAhg3fEDdb7PsBcAPEAmgKINYdp09OwteYSBJSBuKNXMW4NvwwwTIYKClaE0kOJsnkvsJxRi78CdraFNAdddZ2pZcRFr79QLtBDwLn5kZhmGcmlgPckIb2MUITSC0IRhCKwT -WD/So2CiIc2DWweRDOwVRCewb5DjthZ0efh5MBLsxDJcOxwrts4NagkFpfxFz4kXtsV+IakDFLhP9ygGyAFwE0BNALuBNWtPQJIc695wQaCjzFlNIYdDDYYZEs/TsdUAcNFB/UC2wsVL9DUHIGhq5ItCkUBtFcHFf8C9qZCkfvf8dwo/9hgbEcGQc6M7IdF8HIdY88Ic5CCIU2CSIS2CyIe2CKIV2DqIUPswlki0IliA03oYFCq6pZAblhVYkmuX +hDqwfhDXHhYsFOjl957J6NSIZioWOHtwVBsykbWK+JT4P88orIxCmigqleqqxDygGyAFwE0BNALuApWjPQeIcz8u/rACB+i9ZgVsDDQYeDDLFpi8JFJkgh4JxB8eGxhFDKjtlBrYV9YisZPIMO0+KMv8axvS8UZloDN/umDzipmCjAV3ccwUH9QROYDEISFkrCCdCSwWWDMIdhCqwXhCP/ifNn6vdD3ITrFO9q2DGLpT9pjn/VyrDeEKGL9CMWtA -hTjnA1GrG+FSGPxDJIQ1crgTJDFwaQDBASf1tYUftQ7tuDw7q8DQ3vlCb9pG9ZPhABWoUIB2oZ1Duob1C4vAND9gENCRofVDd9ritAwU98RAS99QwegAmgLDoOAI79EIOLCb3vYkpKsqU3gFSgTjMc0NSpZk+zMoZw2Dcw96ptEdAVMQMxKJgfPrqQ/PoPdaZkhCetsrd0Pg4DMPqdDNbudD2YZL0roSUAeAEaA/wP08ugJBhsAJsBJaNICegMoB +CYYae8dgbPsirgB0jlnQD+Tlt10AUlDlwVgCRfkd0vol7caoXVCGoU1CWoW1D1sIyCuoT1DSoWrCUAUsk6HkU9nQXdNqoU0AYdBwANfohABYSC80VqxUxSkB4LYpN4zgNKUbMk2ZxDMGxM+B+9UypnEqgsdcHMvGoMQZZ8G7nI8GgUy9UwZo18QcB809oZDYIes9IPqZDU1oWDIADwAjQH+AGnl0BoMNgBNgJLQOAT0BlAE6o2QAhg/wJUBV/LWD -LVGyA4MH+BKgDv4aIWIcIltE1qPqa8sNGwgeKn9C7tnC9pNGeRi0kydh/iA8vbojD9QdcD+Pkt95NnN8FTr6CV4Zt9tvkPBdTvaDemmHdaRrlC9wVuVA0kb8jwTFtf+j6DpmlEBN4UIDVrujsQwSZdygDABEIBAN5Br3MxhoVgaBAHglkFGZMGO7VIxO6lhMIdFEmjGcl5gWDV5n0C5br119nqmcvjuPdmZgXCX/u30ovmdDLnmXDbhhNNK4dXDa +CzhKsLFr410PjVUHxLP0kCPG0lttq8FljeRC0tWdBDqu9hDpAChgse8RwbDC6ArA1bQSQ8ogB19WTn/dKykvDz2qgCK8PqDfZqN8jQUx9MHnuppvtVc1wS5slKrk8lvokN14e8CI7lVD9wegAYAIhAL+gwMC5mFNisCQIg8Ksh/TNgwwwb6JDaGJg9osE19mpI8uhu98itsUstIQcdfTtTCQKmy8s+qLcTAbnCzAeSCWYbBcsoSXCy4RXCq4TXC6 -4fXDG4c3DW4S0B24Z3Du4cLCLdmsCUWgPD37sNp2OBgDhqoTCuIeLZOCB8Aq3CcDBvmcCZfiN8koWN8FzlrDTweuDzwXcDTzvQsNfo8Ctwb0cdfuJ9nQfr9w3rDtzvtU8L4WuDlwRuCVrkAdgwQZ8fYSVC2AC4R8AAqBZyLxBrCicBSANxEKAF0BYYeXctaABcYNHkhDjm4dlqPpR5nsxxdRrBU1GrLp8+jBCdOhYCE/jtDkfkKABuvtCm+gKB0I +4S0AG4U3CW4Y5DVbvWCwWhfcMPuSB0sL2BR4b5Dazt/UFvFwQs3N+FZYeNN5YVsCBIVL0Ofqdsf5nk9OftuCNYcUdtYZdt0ACiMnXrg9LQV7drQefCJwfk9eEW9tEFjfCdvjqceAGwBXCPgAFQCuReIEYUTgKQBVsBQAKAF0BwYcnctaGID03IUhxjoYclqKdRIQQKMvymI0pdAH1K3g7VuJo7RLruGsSdpV1wIUB9arPJ1HPhBUJJvTtQfqH8jo -YXDMIU4D3/mzC6wRzCGwVgia4c4A64Q3Cm4eI0CEUQiu4U9DRYT2sM2sECpDpXVETPeYpPHUcOUkUCGEW4ISDLWo69CDDPdiHC+RLUBEIP4hRmBXlX3mME5wQvDNYSjDQDtUjakcQB6kVjDjQnOI3UvlkxJqGYH+k5BG7F+UXEVaJJJlp1OokfVuotTC7/kMty/CZ0rIRWCbIYyDQkcyDwkTK82QVEjIAFXCYkXEi8EYki24R3CUkT5C0kcdsN3K +ZVNi4aXDnAOXDK4dXDWGjgi8Ec3Droc5DT7uG1XAZO8noYVhz0lUFvAZFCmLgtRGMkI0K9EwjPOlxdAYRIBagIhAgkKMwy8oe8p4SwiZ4YrDe/jqcSkWUjiABUjUYUpJcQMAQ9uAZlPTP9N7UsWMbESfBtuIGJA+rB4CumpCP/G1FitsnCm7qnCG3D1EIIQVMs4djMIAgf8NHkf9DoazD6wCEiMEREjsEfXDG4bEi+YeMDT7hvCmwXSkK8DkiCiH -38LBhxUSkXkQ5YXIRm3uPCmgZxVgSJL9HXtL8EoevtmkaS8SAYtdyAWSUZeMU9xEbQCeau8CCobfsioVhNNEdojdEfojbQIYjjEaYicwPwCD9uCC25lb8sph0AYAPEBZQp+dRLLOQ4AAOQTCpQB6AC0AcXi38xoddcmOGHCQcEEQHhASg4LqBDdRtjgrkvGJcYZBt4Lu4J1oW6FNoV4iSwU5k9ofAjEgodCTnsdCsfmsjsIWeJcIeXC72tEicEfE +O9e9oW8aIWPEvgJndi3vkjeIUkCoodJcYoVQ04obq4+EXa9R1hdpHXjN8ari69xfmr4lESoi1ERojbQFoidEXoiDETbDIYhqcejp8Dv4h0AYAPEAhQkeceLCuQ4AOORtCpQB6AC0AIXtn8OnpQtkdL7CwcEDZTakfBpSgKNccGclgxMl1v0gZ8O9N+dFob+dq7vwsVofzc1oSy9G3n786YcSClkcZC84QhCeVkEjmiJsiwkZgjIkbXDdkfgi4kZ/ -j8EUcjiEakijBgUckxlu8QgVat+4naQ65NJc/oY9AHBok0EPHP4Oim9s7YqDDeguDCJABflJANl9agOHYGkQUD1YclC3Xt+9hHtajbUfajukeQhPKFWkh5mDh7krjBsZiMjmUbylWipi0KYauE+Xjf9iwb5cIjjAjhliK8GYWK8kEcqtJXiXC0EREjpUXzMSodgjYkbgiEkS3DFUScipQb2DjtqtskAfKCLlkPo8kHco4njmDx4Ue4mgQVZVYfPC +9T7u6MkkY9CqLgvxBwHm5goe9CfIbrtFBnadfevkiN3uf4/FhIAj8pIAQvrUB/bJUjEgTADakbd4X9iaizURaiWkaKpg+j3BOpo3N6MIOFnUZ2JDJtw4ZZCWhEtAUtjLkmDQIcy8ydnMiAzoSDqttmCBUb3chUasiwfusiSgOKjwkVgiokTKj9kTyDMvhYt+diciZtleFCkO8pMTq1Uikl3Bm5MZNgga/cmfkOC+IVNNdUsgCRah8iQ3g2ivkeN8 -uEfL8eEYr9/lvrD0oczUdYZlDRPhIjD4W8DTvkyEZPswDMUdijJaLijZyPijCUUzR5WqSj6AOSj5rieCFaktd3YSoiBHmojs3lCCIyvsA2APcAWgD/wxhn78a0roClOvmEoqgGhlSj4F7SHOIUTMjJebnA5RMGeRblN9dfPkMQsNgF8KBnot5kQ31/EQgjn/m31U0Sgj00SyD0EeNNuDl7gi7vuhlAJyAOgFQYY4MKC8Tn0BiABoBYWsqigFjOUJ +xTm7dzQcfEDYbUdkUaijJaOiiVyJijsUczQBWvij6AISjurlL8EAc2jZEcucLejJ9gVp6V9gGwB7gC0A3+GFMY1EPAooJkgehnigzaoGgxSsmE83BoZgTOGoJEMFBVZgcxoZpoYSugnDdjtiCrrpyi0Zlv8MwTv84Eao8EEcsiTIcKiYLosNYBHHdD0MoBOQB0BSiDHBWQaCc+gMQANAP805USfNuyoLDmwYtRs3BXpi/lrtM7uQVvvFbQXOmPDq -YZWi+fjK4a6Myg7kQn5WTrlk1hliZjlC2jdQT7c20cv9TeoSMrvuvCOAIDoDtDbUgdqkJl4UxigdFvDM5gUMHQTSMPuuU9j4cM0qnmyNAnBxjmMYdpb4aoivYQ/DPLMOAKAEMBmAABBdwBQjopjj1Z5u4EbMgIIsdEksiYZJw2BIJQZXGLJQEW1t4fkWDQCrGi9nkK9DhqF8PmssjcLvHUs/qNtWBrn9QTvn9XOEIAYMUMA4MQhjcAEhiFwChi0M +/mu8x9tDDWEdFD2EXbMSHhwBh7rtptagctlQSRiyMYDp+ThZsd4YaDHFgL9mPgvkO0aL91wTk9nuh5tSMWtoKMfbDNvruDnYXfCIAMOAKAEMBmAABBdwCQjh/sjom2OxgMwig4n7tDYrER0MNJOxxPKll5YwXlsQEYVtyYTiCtAXiDU+pnCDIYsiXgpT1D/gdCE0agihAP+ihgIBjgMbgBQMQuBwMZBi/ANFgDke3DT7oCD4Maci+EIsVz9GLDV+ -X4BIsKciVUbmZEQThjBwfPBm6nfouvo4J+wKlIEMqGYcaokD1Dmol1+hwiLgYUiNYd8jeEX9slEQIi2MUqYzwYU9NfoCjtfsCiNytIipPgw9g0hd9V0Yoj1fsojfbGsk74bndmnqAd7gLuBOJsKChBjgBLVGwBVaClxsAPoBJAGM9xFpoCmODAQFkPScPxAbR5FlFVUcMY0Ksk2lJiB0CyErBDe3ryjLMeZDjOlfUh3kEiU0WFdQMZO8M0ZsinId +P2Awml2lrkvz1CTq2cnkdajtgez8cRrOCpwfld6hFuDYRivt+flrCWMbr02Mc00xfvgCd+jaDntvFiZEeVD5flqdb4cwDygPcBdwHhNWQcQMcAE6o2AKrQEuNgB9AJIB2nuQtjEZaZYCAbVHynJoYjBLDvKujgEyt3kG0jMQKgf9BVAegcQIR790PLMjPEZBDvEdtCnPp0DZhnmZAkYmi/0fTM7MUBiQMWBi/qK5joMR5i1bhYsxfgKDc/tYt9Jn -siDsF5ifMYhjkMXTQgsRhjQsUAtP+gOC2/h9DNUbSxb5DUd9URylwoePCwSIV5wOjJdZ4aP8KkdktLUX0gegC0A+gB0Ao+OJC+sEUVHUS68Fwa0jhHvQAocTDi4ccpDfEiFB9Yn7gm8kGiDjstjbcBjo1sacU2usZCZkUh9c4f11FkUFdxlqMDbIeKj7IZKiLoZEiK4QdRrsfBjbsQFj7sehiQsSWjnoQUc6LpcjWvp28wcF2lOvkk1RfmdxVFDF +mVkjlqjV+M4hCRCm0hwM+0QoWi1QgXX8Ubt51Sbj0AWgH0AOgMHxuIcqlcKlaiFYTFjbUTqd6AJ9jvsb9jxIfesQoPrEA8PXkBsVHFCPvbh0dKNj56oV11IeMjwEZMjtIWBCyFtAj9IT4jyeuysXPnGjLMWtjrMbZj7MTtjnMXtioMe5jM0Zn8LFuhcc/nmj62HKU9Pm9CazsV8/6jT5M+BqjiPpWjBwbKCwnjUjgcSCNYoVwiJcQAsFwcxiD4T0 -C0sUKkdQZli9QTRiUcfxYuAn8jCGiJ9HQRCth0fuDCoX90xjl1iesbKNlsP1jBikNishqNjxsd6D4eheCIQeojH4RIA8rF0Ai3NUBKgDk4ugF08+OmSBSOEaAMkbbVxoeW4k+JPBzJLeQYQCPC9MfCRPApbRFiK5BVhpyjY/tyiLRomddFvLdrMXON6YahCH4EdDgkSdCMgtn9awedjLoTKjOcVLNvMdzi/MXdjUMfzjMMRbdczHL1nxtu52/h9j +k/kcfCLgdUdcsegBKsdVjGRqtg6se0VGsV4MWsW1jxPu8iw3gii9weVjKjPZAugEm5qgJUAknF0BqnuR0yQERwjQIkidasSiVgib9J4OZJnyDCAg4TtV0cKwtpEHk42hrjtmUSFUloSGsXEYy83ERZduUeGjRFltCswTBCGYXBCmYcgiRUetijsJTjtsY5jdsRBi6cTBjDkYmYmeqdij0nn8VUcS8nwqpIDYtQiq7oPDREIOBlBhdgV3jhiJ4UxC -m2L+F1JN+NHBL0Dx4YOBiYWdhjUav13lle8eipUjADEMBlsMnABOstgMogjCqMVJCw1rMFhHuPjJ8cwBp8SeiVkOVs6Msq4uWA4ivgKZBlFtbRCQAmJI8atClqJTDHjtTjvEbTCBUXSDy1pWDVkcXDTseBjM0RgioMcgIucb5j/MYFja8U9j68TwB0Hk3i9uuJof4UDB6EcycxLr/dx4etZDooZtgcSi8MsR8imjl8iLDj8i10WQCe0W7D03v2id +K6qjchjEMBVsMnBKOqtg4olDDq0c8jTXoRirKFyVO8d3jmAL3j10RCQEtgxkJXOywrEaZB/ccOBA8T7jGUYGjV/n0MGXvI9pkVyiw0XNj5kSZjQPjGiIPkgj84Uzsw6j7hM8Q5inMS5i88Ydj6wRA83IQhjHgMPAgYJzitdviB77l2CFBmpJ7TLNCq/hFj1geFDjXpkjKPnAD6vvWjsOpLjF9pa9N4TLj0sXLj6aqlDMGt+NlcZlDkrBbjZaNbir -cf0cTYaCizYUwDioS7i3cR7irwF7jKgD7j9gH7iA8dhRLvrBMsCZuimoetcNETHBOQJTREIF0BKgKxi4wbTsEkOnFDmh5QxFPO0BwKVZfEk6xjYqiM2YmBFFkAaQ+INf8y+vZks4ZSDAvjtiaQWWC7MXfiVkczDmcazDWcRBjeZpgiDiLORpNn+AHpJyAmgDwBJaCuxTUh0BZyMwAVZkLDpegECCjk+MAobhiUAfPBQqIfAVoeAT5YaJcVNKLINo +wLbjKgPbj9gI7jncf7pJ0ZAT59sVinQQw8ysfd4JmrgB4xpUA+MW9iFmsfBF4DnElvECZISqeZcPgEF71naw+wNXpw1N+EVkCaQ8XuO144dscEZvXd70a4i63oo9WXuAVd/vAiQzoKjT8d+iCweZCSgIRxGNn+A2hL68z7ouxDUh0AVyMwAOZg5D6eryDT7suNkTmWcPIa+9D4P/jxYVuNm+iOg7cGsgGfoLiwoVADMjgRjXkURioHokMqMlRBao -go9KMcrjqMdljnUXx9oHr7MsHhRkqILVA/wPXRhCsvDYiT/AEiQFwbQdvDdvrvDKHpzUdwWUpqsR8DasUR0mHl6DLvskSRAKkTEifbi0UZrUncegBGIBk59QKQAqPmpj4wWH8g0HbdsYL8kCGPO18QHiAjRNXQq7tsBXPohQDju6kgfoAF4IW9Vwklfi/0bSDywZoSHMROkLHjh8zsa5idbpzDXOCRwTCWYSLCVYSbCXYSHCXXi6IcdsVpm/cq0V +H+AG6HFCPNgESf4METzBHqDhvqg9d4UxiECSaDBEV6RHNiIiT4VKcz4VxiVQeESgiSESjcQwDEUVyVGIHE59QKQA0PoUjOsTb9g0KV9Y4oiBiGBs18QLH49gDXQ07tsAhkeDRvZtCBNwDi4nERMit8SnCo8bITcDrTCFCe+ilCbGiVCfGjycb+iMACuQtCToSmgHoSDCUYSTCfnjPMYmZWpqQiaqnqIGPHeFlVu2Cfnio0LuFhiACZV8PCVUivCa -aIfkh+ExwaOCIoZwRn8jjAQiYgT6buETuEV+8bgXwiCsV9lDZLTlyRvwjviYbkxsgbCgUXkS/UnudDfoeCsJufCaFp8SmsUf17soCTepKijehh1jhHvUAv9vgBJAPUBJaEYBOQDH0M9EaAn+MwAV2AgBlsBE8NAUHjK7qhwb+ln5OKnwJ52qFBruO/gbmMCl22OYDQipYDZif5dfEXTiAMUKjDscBjjsdWCwMRsj1iTO8OcRgBjCU0BTCawS9idY +Li2EUrCZwTL8NKrdk9ciNljtrcSiWvcSqcra9W0fa9kiUfCcAaIicsfN8JEc91ksa8ToctfC50X0cX9vUBL9vgBJAPUBJaEYBOQDb0k9EaAb+MwBF2AgBVsO49RAf1DU7khxZ+ndBRggOAUMY+cy0GdwP8JnxT4NLMHEcBDloRAjgUtxgqurHiBQFBCE8TtCNRuZiVkWTiKQenjNCU0BtCTHBdCZLR9CcEBDCcYSoAKYTsCuYTEzIMQlUaDcM6kl -TggLYT7CVABHCYQVnCbmY+iJkiW8dIdSRKnFWUJxDfCXIRbif9jGphjMT8S9sFcaA9zUX0V5quUAWgFTcWgEIBZyEcAhPAv8Vca8T20e8TmbqAc7SYbVHSc6SCpusp7hL3iKysFQypip1AyavBSGJ3dqprVNWSFMiOutcE9HnyiqBn4jBUQzimYeYsdCagjn8cXj2caXjJSTsTZSZYT5SQgBFSUcTf8ScSCjuNjXsVcjDIjXRbmKJcqBLpsREHJh +J6YuyhqIR/j9iTci13MSsfpqviBcYC9GKgaiAYaC8JAC0Asbi0AhACuQjgDR4O/nKDQCQqCe/iDjqoYaSFaiaSzSe9NUdEcJ68ZaxgqDXMY+JcBSSRQxS7pSTmYqpCEPK1E9MQ+jGgUKBdIc+iaYa+ialnv8c4Z+jScatiuSagieSXySBSUKSEACKSViffiyzEC5JZqSBa6FcxHCUQJ/ITbgQCEphHFhWjtSVWjhccOCrSaOCibuOD4odASmydLi -5MEUMZ4fATjNs8TZfqrjkYeriUURgSnogCjT9tlDB0cbD72F91XQZ8DDcQ/sMSViScSXiSJBswBCSWwBiSaSTySWRManmlDqiSiT0Ufndg/DHBcAPWFVMTwTALh0s4ZIAQGWLn4eOPB4lnjIkpiIbhsslT0r+r4cTjLYJthhnDLlHsJrlMCk8kKCkuSfGiUfnAjb8b1MtCZmTH8asScyWKStkRKTNALoNqgPQBNWr+sMIJHwjAJBhTEc4AWxDAAv +qWvvDEiVg8UoWcCUCbVcu0Va5ISdUBoSbCT4SYiTmAMiS2AKiT0SZiTmqD1dPkTOiKoU7CSnsJiSyjgtcAGWFpMeUTtDpktd7KBIY4r+DHWJV5SXtXNZiMbgcsszFTSOD4QesYIehmZ95CDooXlBSSAUoUDaSTZ8oERnDWgQsij8WZi9oRZjEySgjpiZoA+BtUB6AFK1z1hhAg+EYBoMPojnACyIYAF+BsyUwcyJl3CSfuZIwcImgNXhTF86nH1X -wBWTLdsdsBJpQiq0eZIQcAmhESmgApFg3Vq+sPBXkdqD3kW+9Pkb2TF4VESI0r6CQckalWKeY5/AnyoPUoKoKQMKpRyZVjBmkJjKnnIjRMXD12KY01kSW6c87sI9Pvsl8hoSfgrLg24nEDkQ0fFbFUHAjZVwo8BRHJ/h6BOtiwQM/hYlM0EqMIhlC9jTiueqj8FiaBSliYNMViVYtS4S/jIMR/UJQPBTEKWbwzAqhT0KbuBMKX+BsKccS8KQUduC +8Y8j8MZcTh8bFi+VGypV4ealiKWk1KWg6kSdE6lT4NKpvkecthfllj0RukS8sZIi9UmRT8mqCSChvOiX9od8fPl1DT8EpcinLm88iBD5LYkS88LIviljKl1LvuEEc+C/gg1HJEaMF+k49hyiwyYZjjjs2NPye0Dj8STiJiZyT/yWmtM0EBSQKQbwDAhBSoKbuAYKX+A4KasSjsafcGCcXjojg4VA2O/jqEThoITJIhTaGCEtSdKDSPp4S4XvhSfC -ZFigCZyxB/pLj61LIpMTJD8QuPLipfuwjuyZwj3SbRiCRqusJAIbIuYEKC7UggB7so9ltcl1J45CNkRpMnJBEWlTUABlS4AFlScqWTkPsgiSTZIVSapMVSqAeVjngUbDdwXr9wSW6DT4VCSEdg1j0qekAKqaakqqXlTaqaNkiqVJT9PjuiNEUaB+yOcAtEbuBjXjS9s7JjB7WOjMqnFdswyS3k/wRHDQtGxgLYgni8wWAithgj8Y0WZC1CYRsNCd +dcT0AJbIuYCyDQ0ggBbsvdkNcoNI05ENlppFnIrXqFT0gHAAIqVFTicm9l7iTbJ4qc1JEqXAS2yYlCMsWaDIOpk8/iVaDJfk9tkqeFTDUulSYqVlThsglTOKQr8FEdVCjQGORzgMojdwEq9TvuID1iteRLyC9DoqI6xESK8kXEN4EPUccTXysAi3vrpjg0dNihhunCjMR+TD8dpTvyaVNmYWnjUEYBSWNiZSwKeZToKbBT4KQziCIRYtHupsSSfu -ZSM/nhc7KYXiHKbmSs0YYT8VK5SkKR5SFgl5SfKX5TcKWsCYeucS8MQjYX9PGIndgEo4GjoYnZgHgnifRSkCYxSWkf2SlwXCTSsauCzfmDsKsaCSqsR1TZEXVj5ETCT8sfDTxqduiZKVCD0ooIA/fMwAijoJDJFvswMYNUFOKIkghkfz5tIfXJvKPFIj4I+iW9MbFG6t3iEIeXgLUDTC5ieoTaBs30FVvpNJlsgjhSU/jRSVWYYKfmS4KXJs3Kch +IgY4r8AqEXFcolLWtlBk99+wc9iziYDjvCSkDfCdwjOEdz9BzkVjUsYcDZ8h2TD4auCIFr+NMRoQ8erslimqaViWqcJjYooIAnfMwBIjpuSTTiDh5hDFMfIKH0e2oQwiUFpcO5N5RP8ZSjmYpMRs4MSswCL4UVSdjjIEa3clqUJMDAcysiQQH8k8Ygj4IZMSkyQBTjKaBSzKbMELKVZSbKQhTkLIDBeNhCQzGBZANXtDZdnIWlF3LhSB8dFiriYR -TPKRhSsKThTBcWcj8VIDA1Ngo9AtIuFD3v5M7ZlcwtlGaSOyacCECZDSXidJDcsZ2jygObIBTPrJmpI1kusjVJ6TE1I5soyY6pLdl2st1JpslbJepIAB5EGmkttJpMhskNkRqXpyusIkA1tP6kttPtpjtLpMztJ6kbUjdpHUg9pXtKqkvtP9pnWQmyCJJDp2GNERWUNyJrVPyJ6NKKJJ62i2PVJqeEdKjpDtKdpyOVdp7tPNkntKay3tL9pnUgDp +TygPbIGTObIupPVkOss1J8TJ1IZsoSZWpNdlWskNJJsk7IRpIAB5ECWkytJxMlsktk/KhpyzZMVpY0mVpqtPVpeJk1pw0l6kOtP6ketINpjUmNpptPayY2XuJVtLgx84IKpsuMBprGJKp7GNPhLFOe6ttPtpatI1pCOW1putPtk+tIayhtJNpA0jNpftMtpbKmtp85JKxlUJhppuI3icAElomuKNAtQHHeyNIow1yhYWN4TUI3kFugmmPdWKdlhI -mdODpdKlDpHsOEB98MdxnlnxRktDNxRoFqAm71aJ2dm0ISizfC6CW8g+dhD+/2ARImxSpQuMK4gScIOO/ciAIxpTQBTxzz2SxAh8KSAsgyHxC+MR2HeQtJspqeScxBFzZxD1Jciw+zVJ3U1+pHhMioHNISBBpPngnFFSk+PRxMbHwG+pqPipptOg6CBFfMC+Pg65QDjgXyHKpWVJByoDOIA4DNNSLqUfyb5CBwOwBbcr/n4xhpyLmU5OLpw1xKJy +WVlioMJEu4DKKpeMYgPM9GBJQWfDd+VMEHAawX1qQBD4wYoPmpSfTTB75NppGfUJxvmTZJP5I5Jf5M2pPXglJWaMP4Ak2QpeX2HAld0N2Smi8ghIlWq0JirxlZN8p1ZOAJgI0QIpY1rRH8zjgPyDCpqVMNSt0XvpxAEfpEVKn6BwlBwmASg8tLDisIdIm+OsIYp4dOyxHGIyJnR1fp79OfpO4PkRX2x1O+GxQgGgSLAYUyqid4mJAlGlOS4QX7gd -KKfQUDJgZRoRWO3dPaxe5OEenGxQgegSLAYwxEJxV2JAJIEPc44LuS61hbkxzCuaVQT3q7GCZJoZl7unNOmJupG3pRXkAI3GH3p5lJsxR9PsBR2IleJ2MgpEtPQs4pMySrVXXemgDjQP7ScQEUGaCEsmBpdxN6+2yjtW571ihl73ihf9Ky6bhwAeQDJHy97ECANiDSJr0BDmVhUVOIOSn+IQEPA1jPnAtjNgecDNbgCDLwC2HgZYpwRapB8PHJ6D +3xIYjbARwsinxJ5blO4owU9MsajJp8cNHaqxC+86SAnpqlJ3xT6PxxRPTpp89Mx8u0PWpqeJ/RxfWBqTgPjQkszsg5VhopRZL4Qd1J+eeyhOUkiGlpNZJopEfRoCb8wNmjSSb+IQEPAkRNegbg0MKcp1uiijLsQKjPnAajMa+n9MVEhh3BKpbjv8HxJ+RwiP+RaRNBpG4PyxWjOUZepD0ZGjJgZYJKYBITnuAQgGiBFHBju70xyQ+SGysscS2i64 -JkRmDI9BpdOYeDWMcZVjO4objPsZUmK3RMmN7pEknuA1sNtA1HALuHY0yQOSDKsXRN2i64H0yoUGCgg8QysNgnUeyPj44WMhS0irgXCJ9UfIxM0ghiwyMkQQVOCvNO5J8xIup8qz68wtMG2ISIgp9lLWJktIuxc0QUZnPyUZoywrRUWPtm55CuWs1FUMjyMw8XDPUpqWLipuulGojqP/MltDMZZvXQAgAFwQQACoIKgBtmYAAEEFQAgABwQXZmAA +GMy0YIxw0iCB8RgiJJt3C8gMOLS0Yrm2AfjxK6VkF0kuVm48T9wZuk9PK2G0ObefKMZpOlPZJX6NZpBlIQC3DMlJDuF42y1jsKqxAqKX+Pm8b8gg8pDLEp2GMAJMoMvpaqWfM0iFvp88IgAgAFwQQACoIKgBumYAAEEFQAgABwQXpmAAQhBAAEQgvTNuifTIGZwzLGZUzJmZ5m31oDuGAI9uCha/9ISJgDKSJFjMVxkp2sZnGM6OczKGZozImZ0z -QhBAAEQguzJByezIOZxzLOZVzJuZfm31oIUV+ErbHpefjIEpqNKEp7/TO+mNLEpqQjuZRzNOZFzOuZeNISZk1LqJgCSvATQB+AQs03+o9Ng8Qim4qdGA4Q/uCDy2MxkiIeIU6wFSEuyMkpACSGdqXgWRIn5NOAcnXpOIXCgqNKAPpFlOApVlI6Zek1PpMsQmBuPylRr+JViXa2RupIBAWORlcgutK2sTH2byRmU4gZwBniRtLYRKzL1YjqOOYQhO +KhpBdLgZ1UN3AV4CaAPwHJmQ/yrpU4BV6CVCrS7kBJQqOy7C7uM46PWJhI4amGhWrWvMZDJrxMz2ycYrkDB2zQxIlkBDRacMg2/pzwOzDMWxviOJx+TITJlNisxa9JL6PDKLmjlK1urgV8SlyNXAcVl12ZmUxhz/Sex7nSFxrTI/SBzFkUnTOSaXoFwAjAB0ZnAAeoH9LihzNBZZepHZZ0DP5O6xWy2JtAbphhy/WGD1DpmWJAZTFMOZ4DPqEXLI -XWT3SZojABcZnAAeoEDOEKirIQAyrNlKbADVZ3RzpE0z0ngm0SpiIbD+E/jIExR8L+ZJ8MhJ8K2hJgTg1ZWrNVZsDLiZTBJAO4ACWgwKDgAcABNANiG3c0ADigGQC96kmBuADAD5gByRAp8qx6sNfgKA97AqJPSEPABtVaZuWhjZcROaI8bIwg4bMFpnTNWAybJ/gvHXSAdqTGBwbJSJcbPSAJoEBOObJLZCbOkZ8dArZqbPSA0rDmWtbPSG8bKb +QArLIFKbAA5ZeRMExS5KLpeoEQgTQAI4XQBNAtIOIA0rFWYTQHoAfQBOAzgDgxfUNdxA0IOA1GDLm8BGfyW0U445aHrS9vyfuH9VFZsYLNO6yB2YXRNXsaIJ5QjHHBKapF7YKum48sLMGJjJOyZIxOMBYxJPxLNP0pq9K4ZXjSuGnEBYOLFCneRgjhC2dnIqCTNVJXbEzCPkB6mZ9NChemhGo76X5Eh3FQIYBLhh8kHAAS0FBQcADgAJoDsQNZmg -h+HybZebP0AiEG+ZRtnbZ8bK7Z5JVQivbPSAj6ELp2bOLZdbITZHBirEYmUQkQ7P0Ac2Aky07O1q2wkc8sbInZwDExR1hBKg2bOYAU/x5A+ABCMSUBVIjKE44+bSB+v+WjZu7NZAhoDCazbHQ8OIBwYFWXk6mVkLgbAAMAzeIYABAGTgVGTFk2RjeIc7IbZXVWa+2bNlAJAB6S0bNA5xABNACADmIZ8EtQJAGWwbAB2gc2FwAI5BHY8HKgCSkAwg +AcUAyAUlRkwNwAYAfMF2SM9IZWTVm9qQyREAP8DI66QBNA9DNTU6TGHZ/SEPA+gAwgfbJLiSLIKAU7MCJbRFnZoaTOOqwBXZI7NnZ47Oeu27JnZY7PGJyFAPZa7PSAkrDKmp7PcGs7Orh7nyvZo7P0AiEG2ZZ8HvZ67KKOXbOyJZ7P0Az6CBpW7M/Z17KPZEmSYMNRFfZ6QAWw0mUkyU3CsCoHP0A43GRRNhBKgW7OYATfx5A+AHcMSUAFsukglc -PIEIyEJ1wAAAAptStQAW8pdgSOcRyFkLUAAAJS6gOODKAfMBagOYB4cwjkCpXgAscvzjkcsyDUc/9njs8WDWYJuHTldwlH6OODFgcOCv0JSCZAVDnBAFSBH5eMqEAOYhH5SmgBs6THCAPjq2wdOT/suwADkSDTLkymhZOJDnvqSmhocxnjAoBYCEARgAPUHkAfsjbBhAYICmctpqrs5kAGATdn0gGGkxCZB6vIUznmct9lCeUIjyQcAAKQdnTObO +2ik5Yt5hagKHMNAHjVV2L+AhIGOhh6hL0LgiDwmAufwYABAGTgNGUTQrVV9cMHIvZ0YTEGW7NlAJAA6Sy7M45xABNACAEWIL7N45q2DYAO0AWwuAGnIQTHCkJAApwSkAwgPIGIy9x1wAAAAo5StQAq+tdgNOepzOxAABKXUBxwZQD5gLUBzAJTmqc7lK8AczlecbTlmQPTmfEK9l7sjkDVwrsruQ5wxxwYsDhwd+hKQTIASc4IAqQfxwBlQgCLEf -hAWIFsBAAA== +xzU0dtmOw4QDkdW2C8SOzl2AcchmmMcnU0BJyicn9TU0STlU8UFALAQgCMAB6g8gSdzkLMIDBADLklNIdnMgAwDwc+kAEUzEzoZd5AZcrLmIPGjzhEGtnCSWfTabOhBWIFsBAAA= ``` %% \ No newline at end of file diff --git a/DOCS/Алексей/ProcessingSystem scheme.md b/DOCS/Алексей/ProcessingSystem scheme.md index 86b9f6e..f453659 100644 --- a/DOCS/Алексей/ProcessingSystem scheme.md +++ b/DOCS/Алексей/ProcessingSystem scheme.md @@ -77,48 +77,50 @@ jlyJiuQpizMP99M5iFjWkljQpdiAD1igCB0/9ViIAp0Di7dAsF14Cyxl0XcypIsfSyNShMDtl1gZFHju TkJQgoAqR9AuYZAGwZFuKAoWLr4mkoBBh6pRTvyA80hgVhVojYj4jEj7wIBMZsAhAIx+gj9y4mj2ReM8iXgxFZlcA4A/MypCBMBtLdKnYup/yShMgY4TL5guSjdDLPxSA6SURcBnz0CMAhQkqUqQhvYqyayzQggdwKBWDCJMyLVIj0B8LCLiLSLkiXES9yc1hzhEhw8HgHgoJBJBoOy+4Gyr1vh4hHgQkJzLh98BdNgXZwk6EsR2wS5mizQS0NMp -c78FzDzrJNyRiVy38NyZjNdtdYRf8dj/8jcjyhzgDn4jqzyLyoCrzYDF1HdgIkCLjV1UD8Dbi4F3yMSvz9KAK+oY8yi2dY8X1JpoIqDILUBnheJ+JlNvjvlELSrkzYT4SGs3qyxW8WSYIl8GKh4SMe8EUKN2KatpDFC6ZsVqhrBTsjDcVJsVVsAyaKbggqbwEFsQcCZ5sVsaU6UhtGIbS6ZTpdtjD9tebjtTsPTrCrthVcyoAsScS8SCSiSSSySK +c78FzDzrJNyRiVy38NyZjNdtdYRf8dj/8jcjyhzgDn4jqzyLyoCrzYDF1HdgIkCLjV1UD8Dbi4F3yMSvz9KAK+oY8yi2dY8X1JpoIqDILUBnheJ+JlNvjvlELSrkzYT4SGtnqmTcMbpWT6LLgh4SMe8EUKN2KatpDFC6ZsVqhrBTsjDcVJsVVsAyaKbggqbwEFsQcCZ5sVsaU6UhtGIbS6ZTpdtjD9tebjtTsPTrCrthVcyoAsScS8SCSiSSSySK T5VPsVZAzab6ahRGb9Y4ztV/DAiRCIc0zTU3ZyraNcKJB8BFxCAYBENMB6hcBMB9AJFcAUcYRJAnUUdcBag9x6qIB8qQ0xIpxC54RbouIsR6d4Vq5HgXZ2R+I4IdhS4+i+dekZlFqTRNgZLJyr1+oFL+idNFyNqVyxjtq3Jhij59rDrli+1wCTqnNjytjTza7IBrq8DDj7dgsECndzjuDHy3d0qNk7i4tjZvrUAfyMEeBIqBBXjnZBoAxThd9QK4 -l2zstKFwblMr0BI5xecYEM8Eb2CeFOD0LlhkSsKGrUjC8USXEJF8BYRKgo5ZQGTVEmtcMbpWT6yfFOSfq+s2L+8ibIAuKeLj7ihxKhKYNhKzxRLQGwBJLpKJy5Lc7ZylLn6bZVL1LNLwIdKeL4rClDLjKhRTLv7IBor8HHA4qiHzRErkrqzUqB7CqsrqGKBaHygA6/girqyEbB9syvIb676H6/boM0i1huztAoR6LJIBNIlmdhMXgI1+JIQNIdIo +l2zstKFwblMr0BI5xecYEM8Eb2CeFOD0LlhkSsKGrUjC8USXEJF8BYRKgo5ZQGTVEmt0bIJWT6yfFOSfq+s2L+8ibIAuKeLj7ihxKhKYNhKzxRLQGwBJLpKJy5Lc7ZylLn6bZVL1LNLwIdKeL4rClDLjKhRTLv7IBor8HHA4qiHzRErkrqzUqB7CqsrqGKBaHygA6/girqyEbB9syvIb676H6/boM0i1huztAoR6LJIBNIlmdhMXgI1+JIQNIdIo -Ie4xq8pdh+IG5r1NgU8L8Rylr86ZcH9drSli7VyYT1yy6NqK75iDrFi9d9zjq1j66zqTzLrm7zz9ibq51ryHcu7Hqe7LinycHXyh6sDlRR68bUs8NlMLgYRk6fiJp1t4UILisc1EIe4QR4m4aqtCbEa6s0KHySh0a37MaP6l4v7Uaf797uaSbFSzAGpSBvD5CabanSR6mmAmmyoWb8YKUiZVsua+SebXT0BDCmYnShbhmIARaycShPSbDvYraba7 +Ie4xq8pdh+IG5r1NgU8L8Rylr86ZcH9drSli7VyYT1yy6NqK75iDrFi9d9zjq1j66zqTzLrm7zz9ibq51ryHcu7Hqe7LinycHXyh6sDlRR68bUs8NlMLgYRk6fiJp1t4UILisc1EIe4QR4m4aqtCbEa6s0KHyShW8WSYJT9aD/jDFmK3ruTf7JCOLibptFSzAGpSBvD5CaaSammSAmA2myoWb8YKUiZVsua+SebXT0BDCmYnShbxmIARaycShPSb -aHanaXa3b+gPavafaVaPD1bWm2B2nGm5CywDZAc9buAwdDbgiJdQjTaKKIjuH0AeA/ZfY7B6ghAWQmRDYJEMSA4sBcB6hmg/bWGhHWIB5tB2RWx6ElcfhIkOzHghcpxIkLkqdWtVH78Fq0y4HZKpzEH6EDGMW1qhii7xiS715m0dqNctzK67Gm6r4iXB0XNXHq77N3HW6Ix26fHO67yzjws+7Xq8bYFvd1gYZR7x7nFJ7T0CDuBo0QQthZwl7O5/ +DvYraba7aHanaXa3b+gPavafaVaPD1bOnSRmmem5CywDZAc9buAwdDbgiJdQjTaKKIjuH0AeA/ZfY7B6ghAWQmRDYJEMSA4sBcB6hmg/bWGhHWIB5tB2RWx6ElcfhIkOzHghcpxIkLkqdWtVH78Fq0y4HZKpzEH6EDGcW1qhii7xiS715m0dqNctzK67Gm6r4yXB0XNXHq77N3HW6Ix26fHO67yzjws+7Xq8bYFvd1gYZR7x7nFJ7T0CDuBo0QQt -jHScsgTnYC4U9Bpi4ISWCoSD64Tc9gHza+TWNBHL6rUuhmhsAnV9RsBFxH7lFlKimaKMaZIDg8F9gKm8bsJf7JCOKShAGUbQHoHJKIGUGzwQ2YNsXs75KkHIGnXDE0GDAMHQrsGKHiQ8HYr68KGSGs3gmM3SA9DGHmGc2GGcq0qWHGHtR2GSqoSuGLb0BLXrXbX7WBHGqZ81h9F1J6EHh9g56Iker8Ei5m4sQ+2ZIJIh5+c8p2ct9o0LhNIxdMWb +hZwl7O4KmGBgagTnYC4U9Bpi4ISWCoSD64Tc9gHza+TWNBHL6rUuhmhsAnV9RsBFxH7lFlKimaKSmZIDg8F9gv7qmf796zRAGUbQHoHJKIGUGzww2YN8Xs75KkHIG3XDE0GDAMHQrsGKHiQ8HYr68KGSGc3gms3SA9DGHmG82GGcq0qWHGHtR2GSqoSuGLb0BbX7XHXnWBHGqZ81h9F1J6EHh9g56Iker8Ei5m4sQB2ZIJIh5+c8p2ct9o0LhNIx -neBlqBiGWlzSWzHtkLGakrHtzbHdz7GDd3HukNjh0GW6X35rcOXbrjj7q/GwtCn5QgmKGhWd1egInfSdQZ6e5oIJ2LlFWLgwbUm0BoJtHzhM0mCcm/68nUKETkC0aXWSm3XvhThlWUzUJgmfXqnBmSarpcAZEmkwgmaW6FDpt8PCOWABaunVDWbemObtCrSam9DJnRm9tOVJnpmt25mJbvZnnfZXnNB3nPnvnfn/nAWdmAygz0AKOiPqPTJda/CL +dcWHneBlqBiWWlzKWzHtkLGakrHtzbHdz7GDd3HukNjh0WWmX35rceXbrjj7q/GwtCn5QgmKGxWd1egInfSdQZ6e5oIp2LlVWLgwbUm0BoJtHzhM0mCcm/68nUKETkCyximMbSnvXTh1Xcaf3sJaneSGnygrpcAZEmkwgmaW6FDptCPiOWABa+nVDWbBmObtCrTuaGVZnJm9tOVZn5md2lmJbvZ3nfZPnNBvnfn/nAXgXQWDmAygz0AqOSPaPTJd -mkygjIdR4Tb63YNmVjYcwyR1hAh9Q22L6O26zGEI1fF0lZwDgEQsnbg1gthWrIlGFppF9XlAkU6hyd9k0rgERThI1PWl3Wj2i0PPgFGejBo5zpdCW67iXjHNrxjS7d24vrGdygq9zj36WYvGXTdmWHGrrPG27b2bzTju6+XwEX3KmMDQn3zDORkDk8DImZ6w1Ikz9FX72EnHkQPnZOJ9h8FwSoPITcn9XkauDqLmTkO3hf2l4cbmLKv8aeSpCKYV +a/CbmkygjIdR4TbG3YNmVjYcwyR1hAh9QO2L6u26zGEI1fF0lZwDgEQsnbg1gthWrIlGFppF9XlAkU6hyd9k0rgERThI1fWV3Wj2iMPPgFGejBo5zpdSW67yXjHNrxjS792EvrGdygq9zT3mW4vWXTd2WHGrrPG2772bzTju6hXwE33/WMDQn3zjORkDk8DImZ6w1Ikz9VXH2EnHkwPnZOJ9h8FwSYPITcnjXkauDqLmTUOvW+4l4caqm8acPA3R -UQzlTwzsVlw1SjYpTNSFZqbpOIAVuRS1ukYsgNvIyduVDsYEy9SJNlcjTZrTTzT+mdDmPea7SHSGBxmOOOZrx3TzsBZ5ngn/S1b9vDuwyxT1vsdzvozduFOzmlPdUVOrm1OTUMz7msyG2IB6gnUbanV6BPwdlsBfYRWuhcBFxY5JAC4oB6hgWq3ayxJWyac8F+qXkHhDSOzPhdg8FYK40C40lfF0XVqSh06+xM74HcWPFZyCWhenHYuqX4uyWDod +njmlSRTwzsVlw1SjYpTNSFZqbZOIAQzlT1ukYshNvIzduVDsYEy9SJNlcjTZrTTzThmdDWO9DZm7SHSNXi2ZmOZrx3TzsBZlngn/S1aDuju1uxSNvscLvoy9ulOrmVPdU1O7mNOTUMznmsym2IB6gnUbanV6BPwdlsBfYJWuhcBFxY5JAC4oB6hwWa3ayxJWyac8F+qXkHhDSOzPhdg8FYK40C40lfFsXVqSh06+xM74HCWPFZySWRenH4u6XEuq -31cSl6QUuD20uj2ViT3ACXHG63HMuW6Cub3vG7rbygFeWn2HKKvBW3zsxfYxWA8z7JWzbp6dooIjhGEEJFWWxgPqFm5eM+4/OdWkL/7tl8n4P88MLL6z6p8qSr6IAdkoAnVFwcxFwhBRWn7m8X6+DoU4JIlJuvWv3sO9WzRA3eKI2INQ2RKxFI2INo2EHJf6FkHs/UHiR0G1BMGwr82ohC3SHCG5vc2CHyG5uC2i3y26GyxorsqaHcrK26Tq38Bi +WDo931cSl6Q0uj2MuT2Viz3ACXHG63HsuW6iu73vG7rbygFBWX2HKqvRW3zsxfYpWA8z7ZWzbp6dooIjhGEEJVWWxQPqFm5eM+4AuDWkL/7tl8nEP88MLL6z6p8qSr6IAdkoAnVFwcxFwhBJWn7m8X6+DoU4JIk3hYbKnUJgnFujWg2wqzXo2IMI3c++K6+Y2JeCWc7pf6FkGG+VLiR0G1BMGwrC2ohi3SHCHqvMqYqCHyGx+i2S3K26Gyxorsqa -rOGza4dygk+U+0+M+jOPv0jIk9gqd3i0lpxYa7OwXC4JMwTjheqU9bOZMhyJqI1j8TguITTL+9Gb8tMVrZcZ4N2tryXTMljZLvuyrp5cdep1JlvrxZZgFDeHjSAoV1N53tzekAe8gh3K791gmb7OLEkTq77oGuX7KJjdFnBgkC+4FYGpiHQ4pNqEzPHfPxDv4IVoOfrMPkjUNZW9imkEd+iEgyZF8XyJfIbsx2ZSa1Ka+YMjoIJO5QByaWteTvKG +Hcrq26Ta38BirOGza4dygU+0+M+s+TOvv0jIk9gqd3i0lpwS+Wd7hC4JMwTjheqU97OZMhyJqI1j8TguITT7+9Gb8tMVqsuGeFuy2rUtTMljVLoeyroFc9ep1Nlobw5ZgFjeHjSAsV3N4PtLekAe8kh0q791gmH7OLEkQa77omuP7KJjdFnBgki+4FYGpiHVYpNqErPHfPxBf4IVYOdTCPkjVNY28UOb9NDiEgyZ+sFuBNODroWZSa1Ka+YCjuIN -6ZLZ2amhZ7kx1w4scfuBhfmiR0+6FsJmqg9AFxzFoA9eOeFHHjADx4E8ieJPMnhTyp4093CUnDWuIMkHCCfC8ZEHJcyYpG1l2GnVfpVQgBGBqgTqWELHDJAwAKARgZUPUCDgYk4iHwUgHACDgSJauQ2VjCCyaqsRBo7OcEG8BbApJWsp/FnO4lOB1F8EE5BECcEQhmkPOHcNOlizF44sc6TfSLt/yMby9TGiXFXgyHV6gCMuXSXXpAIvYG8r2PmE +O5QByaWtRTvKH6ZLZ2amhF7ix2W7vc/uBhfmmR2+7OlhaFhMWkD3454U8eMAAnkTxJ5k8KeVPGnnT3cIycNasg+QZIJ8LxkQctzJikbVXZadt+lVCAEYGqBOpYQscMkDAAoBGBlQ9QIOBiTiIfBSAcAIOBInq5DZWMELJqqxEGjs5wQbwFsCklazX9q4PrOovggnIIgTgiEM0l5w7hp08WLfONkS2i6ACjGivUxslzV4MhNe0ArLl0n17wCr2RvG -3v5iOLFcHqj7NAc+wwGvs7e6wXAI7zPCB4/yUrEPNwGmgSZt60INrkcD974hBqh/FTFUWyaDcYOw3VgQsgLyLDY+ZrRYVagDjGwYAkgXoB8C6B0gs+VFHPrRUm4F84IPAjKnwNOFl8wqRrOvoXjDat9K+YIqNrUJjZ4tFK8bcNs9CTYaVO+qbPSqP175GU82pbGKsP2zYYiqGE/YJtP2LZz8aSdPQqkvw4Z1tvBjzCAPcMeHPDXhO/QOs4F84QsN +9j5jN7+YjipXB6s+xwGvs8B77B3usFwDO8zwgeP8nKxDzcBpoEmbetCA65HAA++IQaufxUxVFsmw3UQShUPoFMFkBeZYfHytbLCrUAcY2DAEkC9APgXQOkDnyop59aKxfIvnBCEHYcRBHA5MsG14pRsm+dfESmIlr6F5Y2CDdvopUTaRtnoKbDSn33TZ6Vp+Q/IygW3LYT8yGubbEVQzn7BNF+pbFfjSQZ6FUN+HDBtv4NeYQAnhLwt4R8KP6B1n -IlwF/IwmVw9Vw0ScHIinmUx9xWw8KKdv6HUYzgr07rHYHQj4gf9jI0vH/utTi6tCABaucuiANpYDCB0Z7PpFALAGwD2WgVP0qMN8Y8tSuVvK4u7hfJYCsCsoXAUlgIFNdBoOROFP1w64Po2iZA1VuvQEg503gjCEPjhy5AR8g2Y3V+hwNKZcDIQfw1iiGKW77NDmnTEoOQBabTY6mJADpsc2Zq0cemT3Tmi92UG802Ogtb7kyiiIWF9BAqQwRID8 +A/nGFhpEuAv5GEyuHquGiTg5EU8ymPuK2HhQzt/Q6jGcFem9Y7A6EfEP/sZFl5AD1qCXdoWALVzl0oBjLIYQOgvZ9IEBMA5Ady0Cp+lxhvjAVuVxt5XF3cL5AgVgVlDECksZAlroNByJwpBuXXB9G0RoE5YtWymQSG2UGjX82BZwkEaN24HTDwUHrKbsXwEGQhARL5CviNze4KkTm3TVpucxKDkAOmjTTMS016bM16OAzZ7pzVe6aDeaHHQWlx20 -EBCghIQsIREKiGDAYhcQhIZJxB7Lc2mWYo5jrXh4Jk3BBqDwa0S8Ho8KqdI7AG0GiBnAJEUAIQJ+BhiaB9AcAaoJaxkQUBSAGJRRBWXn7VlWRRpBIC2H6oMJJIQHBNKGnZAJAGcu+KEHxFeDM5xRMvYeMuwb4S8Zy+LL/muyy5/8Eu6o6YvL06HajoBB5LLnqPOoDJQJjjOAdexNEQAYCSAkrv4zK5TCBWX7O0e+V3F7E3IYycVvjCnrfsdojCOC +HoAeOxggVKYIkBBCQhYQiIVEJiFxDBgCQpISkOk5g8VUXTIsTmMgCXNfCCZLwQah8GtE/BmPCqoyOwBtBogZwCRFACECfgYYmgfQHAGqC2sZEFAUgBiUUQVlV+1ZDkUaQSAth+qDCSSCBwTShp2QCQBnLvihB8RXgzOKUXL2Hirt4RUvGcsSwAEbscuIApLlqOmKK9uheoxAQeRy6GjzqAyWCY4xQG3tzREAGAhgLK7+MKuMwkVj+0dHvlTxexNy -i8nBBtdBIuwjOvxEGrfpgxpfbPIfQKYXDo+Vw01u2zpEwwdkzAbAEyBlBIB3hEY3Pu/R+F5DcaxfAmoCM4rAjESywUEQJRr58Uq+0I8cnUNjbN8EREIpEe32TaojiAWDdEZE0xH98R+eNIfmQ3xFGTCRs/CtjiJn5MMyR6AFIVFSpG1tcmmnBPlxJ4l8TNAW7a4RxIgAU5GE4aCci1Q0aij4WrlRuMKI+SfI+I0mZ8VCBnbP80kU4NJEWgVErslR +GMmlb4wp6v7HaIwjgovJwQHXQSPsIzr8RBq36MPkty5BR8Q2Nwi1pPnuGMiYYOyZgNgCZAygkAXwibq/ShTv1/h1/LDimOBF4cAG1fREssFhECVoRjfQvLAwaEIjAJSI1REmwRRoi02xALBliMiY4iR+U/PGvm0n5EjLJJI5flW3xFL8mGlI9ABkKiq0j62uTbTkn0EnCTRJmgHdncM7YrB7gvGLOi1Q0YSjkWrlRuGKI+SfI+I0mb8VCDnaf80k -zQ1XmqKV4UsgBQErUYe0va6iG6/Q6Cfl3gHDCSgiEsYQ+yeq910B6E20bMKNFtQnRL5QgctFKx+JeIgHSgcDTVZB80kRwciQN11b8DGJBrI+mwKQ5Ri3WMY4jLN29aSSmByZfkhUDAgEc5OGgtMft1k5UcNBlKK7nRwLGMc2i1pVjuoLGZaDyx3KE7DM0gA8dvSzKGccoDnELilxK4tcRuK3E7iuxSqPZuR22mUdiOA43wkOKR7uDrmY4tHmemNY +U4NJEWmVFrtVRrQ9XpqJV40sIBUE3Uce2vYGiG6gw5CYV1QGjCSgmEiYU+yeq91cB+Eh0fMNNFtRXRL5cgctFKx+JeIwHegZq3Boh80kRweiUN0NZpjs8lw6Ph1PURxi+B03LSEmMNrd4gRPJKQhTBVTycaOegvMQdyOmkcruOpFQXRzUEViNBDTasboKmY/c6xTKKIkYMB7NjvSzKFccoDXEbitxO4vcQeKPEnjBxSqI5pRzAhEcFOegicR4P1r -J8eg9AN8G9noDbAWR9PZwLxn5GEZ4IFyfglxAKKbB58VOI4INQkjWdL8JQZ8V53LivJfOLVF5HkJF5tFXKIXLovgg+QRdsphdVUZuzaGaiaWJUnUVsQgm5duhVuIYfBLqnmiLeloyYdb2mFzdMJ2YLdsghnSNcdo5RTYFBAbhA1fiqkZJkNPBpDRPEOwHRvRKmmhi4O4Yz4a60m4wR8EcYm2GtN5LE0MxQpVbhD3EFnctuGpGHiIPTEKkvZR3H2a +JlbYaPYEBjzPTmsk+PQegG+Dez0Btg7Ixns4F4xCjCM8EC5PwS4gFFNg8+KnEcEGoSRbOl+EoN+J87lxXk/nFqi8mv5i82irlMLl0XwQfIouhUwuhqO3YdCdRDLKqfqK2IIT8uvQq3CMPQktSrRVvG0TGLtHz8Hw8wndsghnTNcdo5RTYFBAbhA1fiqkZJhNJ65DRPEOwHRuxMr6LSTWR9HgWtOklocYI+CZMRlVTHnDNBGY1bmGSh6yDzu23DUn -dD9kKooyspeQTqTWHsyDSymcEA9ypznTLSl017pM3e63TnSvNI2AFX+41jXpFDYHkDNB6hzwe4pSOdt0DnODzmiPA2jDJR7Ah4Z4AUqP7TgBwBVQmiMyhMBRAZByg1MDEOMAYBIwKAgwZXpqKPhHxOQdMEQM0i6Crh9AqoX/iS3/4FA55yVU6IvPSATyCpSXIqcLNmbzzt5S8t8LZkqm11N5C8peSvOcZ9DnpJ8rIDvOXnm5RZx8rec/KXnGxjeg +DykH5iA5oZFUtDy24KooyspVQVdLQC3cDSQY40pcmqE3SLSIzB6R9wQD2lnpBg2ZkbACqfSvS12EHqrQhng8hSx3YOadFDkJzLu7g65sjwNreD7mc4tGS82x6EBlQZIEKsQE0ASJ0SVPWoDmBhgo5YQiGZUIwD9pBppchM/OHEH64My4UcKRhEULWDkzRG/UeCEJBnCnB/eNQgXOXF85vAZwsETxLOBOHIg0yWIJILxEYTNwLgniT5CLM3YUtQBp -Va+afPSCVAzR3LR+Z/KgAvy3wfTQsUoNAU3z0gkCvMXII/lwL9AU2N7ggHtKzynKYCl+d3MLb2SS2lTf+V/PSB7gy2NkvKhSOQUAL9A9kmGKxi3izyeJpIJUAHGBAHBXKvEU/PsHDq0IR5zC6kPgAd5QUTgojJTPI3/bKYR5RgNgAYF7kAkCAVsGXEXHoTKYXeCM4heAu/kdSZ0cAoULPP5AkA456hDeYYuICqgEAAVGBbMiVjEAg4bABqGQtwCa +U8ASlwqlSzte1U2WbVJy4gKICaE23OgNanWicJtou3gRPmHHwXR/uW4RghPTu8qJoec4A9DZmqtTgTE90PdAkhcZoOu9eGo7M4kIcUaeNXge7KbJwRJyrwb2axS34UVwApUf2nADgCqhNEZlCYCiAyDlBqYGIcYAwCRgUBBgqvHUUfCPicg6YIgZpF0FXD6BVQwAn+eBIKCKLkqp0FRekGkVlSAF6vaCdoqcq6Ksg+i/QG+Fsz1Ta6Oi5RaovUXO -BggDElAbYtbSexBg1Ib2KQGUDcgAAFANWoC8AQQIS4JQSCLgABKbUKbGUApgmk0wfxbgCCXkTeAaSsmSEtcrNAYlNGTRXfIpBAKYeTxZFErIyCmwMwSsEfp7EyDOLXFynRubMyIBWLEyjSyAEqgHkNzkywgKALbAaXUYzaCEzQIhhJzMBlQSqOIQ4oQBOKXFIY/2rMEICMAYYsi/APIupJ2g0gCymMmWCcrEgDA9C5xKtIW7+tE2xIT8AsqWUrLj +MBhkAcxY4vSDOKkJJohRe4r0WqLjYpvQKg4v8XpBKglo/lm4qUWhLrFQzO6W0XEV+LLFqit8MoPUJmLolyS9IFNl5qfdfFmSqAFYr4XFs3JZbf1iEqyX6A9wFbZyXlWpGLMClVityTDFYxbwFFwk0kEqADiTg+4MLTeccAkgKNuq2ijpdSHwBO80ArwIXPPVnCSQNIsNQIWwAMACKASBAK2DLiPyDV2wNGCpYUoCV9SZ0KAoUAov5AkAU5NCcRac -EREcAGegcqKhwg35f8NWCAA= +uICqgEAAVe6bMiVjEAg4bABqNUtwCaBggVCh5SQFbSexBg1Ib2KQGUDcgAAFANWoC8AQQEK8FQSCLgABKbUKbGUApgmk0wYFbgDBX0TeAWK2mRCtcrNAEVOypJdjBvjhK4eTxZFLbzXSmwMwSsKfp7EyDvLPlqnTuYsyIB3LEyrKyAEqmEUdzkywgKALbBZXUYzaGEzQIhhJzMBlQSqJIS8oQBvKPlHE/2rMEICMAYYSy/ACsupJ2g0gKqmMmWCc + +rEgDALS5xMIL2n1Nk2xIT8CqrVUarjEREcAGegcqKhwg35f8NWCAA=== ``` %% \ No newline at end of file From ce82fb32e58218e5325da64fc72d58f854db8e6e Mon Sep 17 00:00:00 2001 From: semenov Date: Tue, 14 Jan 2025 11:16:16 +0300 Subject: [PATCH 05/13] =?UTF-8?q?feat:=20=D0=BE=D1=82=D0=B4=D0=B5=D0=BB?= =?UTF-8?q?=D0=B5=D0=BD=D0=B8=D0=B5=20=D0=BE=D0=B1=D1=89=D0=B8=D1=85=20?= =?UTF-8?q?=D1=80=D0=B0=D1=81=D1=81=D1=8B=D0=BB=D0=BE=D0=BA=20=D0=BF=D0=BE?= =?UTF-8?q?=20=D0=BA=D0=BB=D0=B8=D0=B5=D0=BD=D1=82=D0=B0=D0=BC=20=D0=B2=20?= =?UTF-8?q?=D0=BE=D1=82=D0=B4=D0=B5=D0=BB=D1=8C=D0=BD=D1=8B=D0=B9=20=D1=81?= =?UTF-8?q?=D0=B5=D1=80=D0=B2=D0=B8=D1=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- DOCS/.obsidian/workspace.json | 14 +- DOCS/MainScheme.md | 143 +++++++++--------- ServerLMS/ServerLMS/CMakeLists.txt | 2 + .../ServerLMS/Systems/commonclienthandler.cpp | 140 +++++++++++++++++ .../ServerLMS/Systems/commonclienthandler.h | 39 +++++ .../ServerLMS/Systems/processingsystem.cpp | 13 +- .../ServerLMS/Systems/processingsystem.h | 4 +- .../ServerLMS/Systems/updatecontroller.cpp | 24 +-- .../ServerLMS/Systems/updatecontroller.h | 5 +- ServerLMS/ServerLMS/serverlmswidget.cpp | 136 ++--------------- ServerLMS/ServerLMS/serverlmswidget.h | 12 +- 11 files changed, 299 insertions(+), 233 deletions(-) create mode 100644 ServerLMS/ServerLMS/Systems/commonclienthandler.cpp create mode 100644 ServerLMS/ServerLMS/Systems/commonclienthandler.h diff --git a/DOCS/.obsidian/workspace.json b/DOCS/.obsidian/workspace.json index 46000b6..dbd38c5 100644 --- a/DOCS/.obsidian/workspace.json +++ b/DOCS/.obsidian/workspace.json @@ -65,14 +65,12 @@ "id": "9608f84166966ca9", "type": "leaf", "state": { - "type": "markdown", + "type": "excalidraw", "state": { - "file": "Как умеем принимать, как умеем отправлять!.md", - "mode": "source", - "source": false + "file": "MainScheme.md" }, - "icon": "lucide-file", - "title": "Как умеем принимать, как умеем отправлять!" + "icon": "excalidraw-icon", + "title": "MainScheme" } } ], @@ -221,14 +219,14 @@ }, "active": "9608f84166966ca9", "lastOpenFiles": [ + "AssetManagerScheme.md", + "Как умеем принимать, как умеем отправлять!.md", "Порядок сборки Unity билда под сервер.md", "Образец отправки сообщения с маркером.md", - "Как умеем принимать, как умеем отправлять!.md", "Алексей/Board.md", "Алексей/DataParser scheme.md", "Алексей/ProcessingSystem scheme.md", "MainScheme.md", - "AssetManagerScheme.md", "Что умеем отправлять Server - Client QT.md", "CLIENT SERVER.canvas", "Алексей/Рефакторинг.md", diff --git a/DOCS/MainScheme.md b/DOCS/MainScheme.md index 05b3183..fba2e6e 100644 --- a/DOCS/MainScheme.md +++ b/DOCS/MainScheme.md @@ -80,6 +80,7 @@ Mainthread: *processingSystem *dataParser *MultiThreadServer +* commonClientHandler ^ite9vjus @@ -314,144 +315,146 @@ wJ54TnIcAxmsgmVyqCagDoJnrJgnYJuCfgmEJGWqIm5a82vlpLaQ2k5qUJ5WjQlzhKQeGJMSrfq64aRq dqYmqXwejEOR5eGfCJApphVDqQU0bsau+G0FpAJwFUPyCpuyFhTHEuAUXCGoctMf6r/koHFHQt2QNimGYhVoHHBsiSmORgIWkZrzESKX4obwcuyasYldx18eSEnuswrsCFRA3usBJc7QLgDlEy4ACD0AuAFMCa+pADMClo9mAcDZJyDlXYWcHUbhCnJTAl7j9AWei8CSAEOngwNKF6MwBGAXuECCEAcAFADxAbwuxC4egAt8kFRokGckSAnwOmDV -RM3g7jymG7BUAWSQIFAou41uLuj3q4EEimkqKKSBC/J+RA7gPAa7MuD6AF6O0BAg5RBQBTAnwM0RCAyqo6C3APSi1Hxur0R1FdRVIWWFygwOM/FVhr8TWHDRO8PqD2MKcKxDkYv1AaINhn8U2HoAbwEwCNADuACAaqBrutHrA2qaQC6p+qTonaWeiS64xG2EROY9+GdmaImpZqQamD+aHmc6rm0kQkm4CeHvnHz4IIUXGy+HWP5KQW7dm3zY2JwQ +RM3g7jymG7BUAWSQIFAou41uLuj3q4EEimkqKKSBC/J+RA7gPAa7MuD6AF6O0BAg5RBQBTAnwM0RCAyqo6C3APSi1Hxur0R1FdRVIWWFygwOM/FVhr8TWHDRO8PqD2MKcKxDkYv1AaINhn8U2HoAbwEwCNADuACAaqBrutHrA2qaQC6p+qTonaWeiS64xG2EROY9+GdmaImpZqQamD+aHmc6rm0kQkm4CeHvnHz4klkR4m8MyNMB3aWjhjZt82Ni -sEGO/yYCnApNuLgxgpEKVCkwpcKQinlJncchYIxxvtaEEKonvUmLG9kYi7NJpEAaDphjYMql4xRfKMBcQskJ9j0EUkJrD+RVMRE40xwUZMkPu6xkk7RmIiPaaG8A1pxAQWpcGXDHcbzjzEwYl4E8K8mkADsnJ+xIWpSee4sT57cqCPtLEBeD8V6YSpk6SroEOKsbj7qxEuprHPcOsQUlFJJSWUnIO9rCbFdglnjaonc6kGdATwuEPbGOxwlNXgUC +cELBBjv8mApwKTbi4MYKRClQpMKXCkIp5SZ3HIWCMcb7WhBCqJ71JixvZGIuzSaRAGg6YY2DKpeMUXyjAXELJCfY9BFJCaw/kVTERONMcFGTJZrNtwKxFXqTCWQ5UvvHISBMHIwRmPbAGayKv+JDBPIFkNskEhF8cSFqUnnuLE+e3Kgj7SxAXnLHGwLEP3xSpXUrbbpMasRQ4scWsQ5g6xBSUUklJZScg72sJsV2CWeNqidzqQZ0BPC4Q9sY7HCU -PkDKD4WUfl8wexCXrQ7wgPseQ7NCLHFrEOYOsWoAIADwPQBbopsY+kXppsYixXeTEG7ADwFGkRCPpygA7EnMSQJNBiYofsYIQWsGYQA/pgccvQ+xmKsT40OXsbKzBxd1oSosO4cfT6RxjPlw4OcCMGLDwQ4CALFvwqoPTSMKykP2nyQg6benawq1AcLC+0jtnGyOcbmsHbmySTLison0VrSsQUkHGblxiXEICAxBjuBmQZ0Ge8nQ6+vk8GH+VSdC +1eBQI+QMoPhZR+XzB7EJetDvCA+x5Ds0KHpz3DrFqACAA8D0AW6KbHPpV6abGIsV3kxBuwA8BRpEQz6coAOxJzEkCTQYmKH7GCEFnBmEAf6YHHL0PsZirE+NDl7GyswcXdaEqLDuHH0+kcYz5cODnAjBiw8EC3BWMqwtlK9pxVBxBKgg6ekmoQI6Wvyg2wvtI7ZxsjnG5rB25skky4f0p9GdcyoGRC6hewNo5CAgMQY4QZUGTBnvJ0Ovr5PBh/lU -Im+yMXMbn+4ns466Cr0M7BemQto3pCq53kxDGQesPKSMKAhLMCNpz9tGGumraR6YJ4vFACSKQ40ONDssmIeAHA+c+gkj58nQOlEXxs6VBLZRrFkcmcOcbkDEQA0aYQBApIKfGngpkKdCmwp8KYKmUpNuiKlmEYqdxZIZ93lKldSttm/EuG9YTWYfunhusAAgvPOoCOixAE+EcAAAFRhApqUwB6pbwCHI9ZxaM+DMgOTG8AwAdoOkAjZbmLgAxofG +nQiJvsjFzG5/uJ7OOugq9DOwXpkLaN6Qqud5MQxkHrDykjCgISzATac/bRhrpm2kemCeGjDVIOMd5C0y8wGjZEaACLzq2w+fJ0DpRs6fmHcuByVLHNSxyXI5AxEADGmEAQKSCkJp4KZCnQpsKfCmCplKTboipZhGKkbpxYGFBp0/FmF4ypQ0e/H1hNZh+6eG6wACC886gI6LEAT4RwAAAVGECmpTAHqlvAIcn1nFoz4MyA5MbwDAB2g6QGNluYuA -P1kjZAIGOAj0zRJICdZTqUwBRJhqXEptZf4JtldM3WX1k6pg2fqkjZY2WIAzgk2dNknA+gHNn7gC2Utk7ZvWatn4A62UdlNM22QQnaJczkzxWpGEQYm2pZ0dKJ5BZogdlZAX2V1kjZ/Wc6mXZWINdmsA8GFNkzZD2b1nzZi2SwCvZPWe9mfZW2Wdm/ZKEa6kRu90ec4xuXqXkpsOvqTfrWgn0YOnoQ3MXqHUC2wKv7yq+RBclXJNyXckPJjoE8kv +DGh8Yg2WNkAgY4CPTNEkgN1lOpTAGNmoAegJGicAQHlADfA1gMQDBABCdolP6Zoh1l/g22V0y9ZA2TqnDZ+qWNkTZYgDODTZs2ScD6AC2fuBLZK2Xtn9Z62fgCbZD2U0y7ZV2X1kHZlhMdnIeZ2SsCXZUSahFJ2B0RB5HRnPIYnihuEZKEkSd2VkAQ5PWWNmDZzqe9lYgn2awDwYM2XNl/Z/WYtnLZLAMDl9ZoOeDk7ZL2dDmw5R2RwAnZiORdnA -JGQG8mtxGacZm4KSMdZGOhFmc6H9xroY5GfWCSCVYiwpWHjoiIv1ARhN4pBIUqcwiQiqD/i4YVeIju3mSvFBRa8W2lRcccKRgl8rECsKxZLMTMhLQuGtJSWgWkPQyz6dBMyxPAj7NOkr6CWXVJJZ+6Q17gmuUUgF3xArqj7cWG6Ybz8WYXjKnv8asRQ7AZh6fkTHpxSbcClJRsXBlXptkIagK5ESBvCQw6GZhmwUCoLxbWgaMNiIkiAKu7GexDOA +5KEa6kRu90ec4xuXqXkpsOvqTfrWgn0aXAM0Tnu3bbAq/vKr5EFyVck3JdyQ8mOgTyS8kZAbya3GZpJmbgpIx1kY6GWZzof3GuhjkZ9YJIJViLClYeOiIi/UBGE3ikEhSpzCJCKoP+LhhV4iO4+ZK8UFFrx7aVFxxwpGCXysQKwnFksxMyEtC4a0lJaBaQ9DLPp0EzLE8CPsOycn5zpUEtlEaxDXuCa5RSAXfECuqPtxYSpvJvn4EOKsbj7qxEup -Bkxee6ZQ5P8FGTXlBx9DvRnm6YcU9a265Jjl5sZDKHsYW5OudXCYQoqL2yUEZXk8pEyTUS7kZxyzFnFn8lOZyZvRn6IR4y+SNtS7zApcOwoHBVzB2zhpdRqcEGOkgMuDlEp5MwBp6yvmmmmZlSe3HVJ6acjowutkQ0m4yGMUBbKg6MLZCbEr8BV5TM53rTAGI3CAopagDiNNBeZUYcbktppuf5lTJC8A7mWgyQrbH+wLMQYYQBfBhhClwcWW557J +rFgZ+RKenFJtwKUlGx8GTem2QhqLbkRIG8JDAYZWGbBQKgvFtaBow2IiSIAq7sZ7EM4QGTF415lDk/yUZk+UHH0ODGebphxT1rbrkmOXuxkMoexqHme51cJhCiovbJQRleTykTJNRieRnHLMWcWfzi5nJm9GfohHjL5I21LvMClw7CgcFXMHbBGl1GpwQY6SAy4OUSnkzAGnrK+6aWZmVJ7cdUkZpyOjC62RDSbjIYxQFsqDowtkJsSvwFXlMzne -8sv7m8uxYaikUpTApikIA2KeMC4pmAPimEpxKaSnkpHyd6nIpIEJ1HlZPUZVnYQ1Wfg48a9Ifba1OjWfU6EBbrCHJAeUAN8DWAxAMECkAaABtmdZsOW0yo592SNmBAegD3Tn0chbNm9ZggCFht8/7iRKCFyHiIUrA4hZIXQ5MhSsCqF6OT1mKFbAMoXh0ZhbDk2UbfCB6jyB0RB5HRnPIYnihuEZKE6FHAEIX6FYhUwBGF0heoWyFd2WoUWFCAEo +tMAYjcICilqAOI00N5lRhAea2lB5AWVMkLwseZaDJCtsf7AsxBhhAF8GGEKXDxZbnnsnyyOeYU5HJnDnG4ZZmKQgDYp4wLimYA+KYSnEppKeSkfJ3qcikgQnURVk9R3Fshn3e26b1INZ2AU1kWK6qa1ku26wCHK8552ZdloAW2d1kk5bTDTm/ZY2YEB6APdOfQWF82f1mCAIWG3z/uJEvoUI5hhUwDGFROWYUrA9hXTl9Z1hWwC2F4dP4Uk5NlG3 -XdBNhaEXmFGhbiAoed0e6lj+5ds9GtRPqXJmhcn0YlFTw6kO3YG4xwQfmRp6KegAAg2AP0DGSp5Dr5sArQLgwjAXuDMAB4jgAHgvAzgBR5Wh4uW3E2Olkdfm1JuaWXrP5TbhQolgcQI3pzA0wLJAnmlaXrQZwGSFaAF8soFaB65sHNIaUxRudTHjJfmczreC2EDTQ1geLJaCuwHItH4iyKkKXl86XpnMWSGbuQqnUuFEJgW7JS8iCZLWYJj7H+ep +wgeo8ujms8kHpkHY52QRwV5BZou4XdmWQHzlGFqACYVdMvhcQBhF/WUEUhFIxD9kOFA2REWyhGRqP6LBYuTnGtRPqfJmhcn0YlFTw6kO3YG4xwb/lRp6KegAAg2AP0DGSp5Dr5sArQLgwjAXuDMAB4jgAHgvAzgBR5WhJuW3E2OlkRAW1JeaWXoIFTbhQolgcQI3pzA0wLJAnmVaXrQZwGSFaAF8soFaDe5sHNIaUx/udTHjJ/mczreC2EDTQ1ge -7mum+wbBWFzR5A0bHlEOsnHj7ReqKsdb+xRPltS/pVGUZw0ZNPql7U+xKq9FZePeUz65ejujLDVIP7PsXWCcGgYSvi2IucWyQlxbPki+dXpXYXCsmUbxuWv0WvnlAxiLxA4x7dqIJVxWkf15MC5RLui4MhAAHhwA1uHpnpCpkYZk35XRR3E9FOaTZFwuzNi/lNJUoC8730k0YO7EQCtpVZhCiOHmSoQdsNNB1gYBcvHrFD4psUy2ujGMARC3kFiL +LJaCuwHItH4iyKkEPl86XpmcWSGyeQqnUuFEGwW7JS8iCZLWYJj7H+ep7g/FemyhWFx1ZA0eoUYgSKnj7ReqKsdb+xRPltT/p1GUZy0ZNPql7U+xKq9FZem+Uz65ejujLDBZbxXZAfFUHMflSEr4tiL/FskICVX5IvnV6V2FwnJlG8blr9HP55QMYi8QOMe3aiCVcVpH9eTAuUS7ouDIQAB4cANbj6Z6QqZFGZkBUsUdxKxbmk2RcLszaIFTSVKA -HgojCzFUlm7gfFEcmGGnTe5uTvmHcuByVLHNSxTqWGsFbsLSEx5XBfe48FFiuqnNZLtusAO4VhcoBMAUhcdkjZwZcoChllcXKyGufYiGVhl0OSdlRlMZRanrSXJpB6ZB7hdkHYF4OSRKplSZZ1kpliZbGWoepOUkWLBFOTnFpF1ORkVtAyukpGXKb0PTRaOGNhuRs5Z6vkS/ADSsaAu4F6PoANKW6F7jNEXuOUS1EzzIQDxAAIMt7tFApZ0VVuWa +vO99JNGDuxEAraVWYQojh5kqEHbDTQdYMQXLx9xQ+KPFMtroxjAEQqFncQx4KIwsxwpZu4HxRHJhhp0GeSvpZ5dUlwW8uxYSgEl5iJdhAqF+Djxr0h9trU7NZ9ToQFusDuMEXKATANkVNMT2TmXKAeZZXFyshrn2K5l+ZUTlFlVZWWVRFaEVakYRBibalnR0oskUkSxZaWUFlxOf1ldlDWkLmnOMSaLmeptRUKn1Fgpd2zK6SkZcpvQ9NKGnnmG5 -R0WilkuU/n5pjSYWnSlzLFHT8QK0LHRq5RIIbCmgZcGfBEwOsFqUS2MYVAVbFAWdaBxwJELfY7E+IqmGq0xEHhbLIkMKnDHgQrPBZK5bePcUzpDpan64FC6ag6SxweSunvFbtDn5VZ3xdbbKx/XrukUOVPn7GmKAcUbrUZbeSHFkOaXrRld5iJa9YsZscRVR3lGkA4juZ2cJGrFAb5RbEflGSH/hElEmQvk1lQqUkkUl3bDKCfR6oNFziKIpngay +Mrlnq+RL8ANKxoC7gXo+gA0pboXuM0Re45RLUTPMhAPEAAgy3vMWalixVW7ZpCxXqVm58BQWmNJRaSaXMsUdPxArQsdM7lEghsKaBlwZ8ETA6wzpRLYxh5BU8WBZ1oHHAkQt9jsT4iqYarTEQeFssiQwqcMeBCs8Fvblt44JZnmJZqftGWLpqDpLEF5q6fCVu0OfkiW0h9WTj6ReOJbKzAZpDqYoBxRujRnL5IcWQ5pedGevmUlr1qxmxxFVBBUa -QmmcUWGO9ANr63A2IC8AdlV+dmlqmi5RC7ZpD+T3FS5fcQWl7ezSZlI7lGSKcT60DCrYhni+Gs7mBhZceTErFIyU2mBRkBU+JxhuEo8AJAG0KWDC2G8I+xEaospFlWMvEFqBjAAFT7lAVV8bgWIBkFa6Xh5XprBWelvxd6W1hjIbwWyun7u2au04ZU0wnZb3M6BZAWIPCA45QYtkBtZIvGmVP6ZopeRxVyZSNlJVwdKlXiFI2RlXMAWVdEANanhv +QDiB5nZwkasUAIVFsUhUZIf+NyWSZt+WOWyZibpOVms7CjOXqg0XOIoimeBrJBaZ3RYY70A2vrcDYgLwEuXgFOaWqbXlELjmmwFPcebl9xhaXt7NJmUm+UZIpxPrQMKtiGeL4aCeYGFlx5MTcUjJzaYFFkFT4nGG4SjwAkAbQpYMLYbwj7ERqiywPkRh+oWoGMBYVEZThVXx0ZYgHEVxTqWFKFiZciXW2ysf14Mh6ZVoUtZWZTOau0PZU9lvczoF -tGA5h0RkHHRnfqdE5BYOaYmxVUTPFUw5vWcVUpVLoGVW9ZFVVVU5V4bqc4xJ5OZ6ksVMmYm7sVMGIpFh6cRBRAEWEUX5YngglUwLn5AIM0QzAMAMY7C5MlYJ5Ll85SuUoxvcWjGSlm5UVatQbjmsKZOk8YMnM0JVtd7cwd0ImHtQF5f76+Z15fqWGe2Loai0mL5dPq2MROJMCvuQuq54PFdGk6UQVLpalm0p6wLcCaADSnPYXo2IM4AUAmALcAIK +kBYg8IMzlBi2QB1ki8pZQM6XklVTWVjZNVcHT1VyOf1lNVzAC1XRAA5U37RFTZYdEZBx0Z36nROQe2WmJ7Zp1XdZ1Va7S1V9oA1XQ5g1cNVtV0SVAYjl5ds9GtRSSYpWwUikWHpxEFEARYRRflieDaVTAiAUAgzRDMAwAxjgblmVgnjeWXld5SjG9xaMUaXPlRVq1BuOawpk6TxgyczQlW13tzB3QiYe1BAV/vn5mgVHpYZ7YuhqLSZwV0+rYxE4 -DSoQCOgp5N8AwAxALgzFZnyQwXgVNKWilMCCABuzYgXuMQzKAl5M0RYMMaKWikAtRCuAu4cAG0VoppNVSmMFoqSwUK2J5q9Q1ZvUn8V4BPpaX5RVs0TFXoAQhagDfuAzvLWK1/2akGZlrhb/onRMHnmXtVctch4K1sqtElQGE1SkUyRKoekWzV3ImVCKZRVKSSlwbZUermg61fkSI1yNQgCo16NZjXY1uNfjWE1xNXOUYKoLrQaHVclcuUKV29qj +kwK+5C6rnhCV0ayWURWpZvBbSnrAtwJoANKc9hejYgzgBQCYAtwAgoNKhAI6Cnk3wDADEAuDCVmfJshYRU0paKUwIIAG7NiBe4xDMoCXkzRFgwxopaKQC1EK4C7hwAcxWik81VKXIWipihQrYnmr1KoW/caJdNE4BjtmVVzRJ2agDfuAzibVm1czkzwTVGOVNVY5rZXNWysHZW6wW1sqrtUj+GHq/KPRSodJmyRnFfJHciZUEplFUpJKXALl47Oa -EDFV/hQqzxzsa7Cnw6qF+l+hQDPKBb5PiJhCnikIR9U+Z47t9XD6dKhMDlmPEFhAJRmIdbkKgTsA2A7ETwMwhMys+jhn5Y6IV5X2l2BU8V0FLxeTXoOt8TLHdRbpULXGCgyT8UIVh+arEAlDeYnlyiOsZtXbVu1Zfnnpz4PBmiggjLmCjULbpqAzQXtFOlF5Edd+kt5pGZ3Vec9eQnkAqIGVkA6x/QMuCXku6JeQxoQIO0AZ5C9V2DOAeYARxlQX +B3V+RBTVU1CADTV01DNUzUs1bNRzVc1F5RgqgutBh9UWVt5VZXb2qMRsVX+FCrPHOxrsKfDqoP6X6FAM8oO/k+ImEKeKQh8Nb5njuSNcPp0qEwOWY8QWEAlGYhEeQqBOwDYDsRPAzCEzKz6uGfljohKVbk5pVosb4zQlcPnzXoOt8TLHdROVZrXGCgySiWFVf+arGycmJaBlyiOsQ9VPVL1WAWXpz4AhmiggjLmCjULbpqAzQXtJACYZr6cfnqlJ -4iAjnwYUIXnPpEwFxDHg6oAMkSqTyoRnEZGFfgBkZ6FaT6YV5PsSqhx7eY17d5hFaz7EVeXvBAF19SKeAygiUQwStYLmZXU4ZpELTJ8kYmUszElkmWL6sV5Jfrx7mReE2UKKQ3E7BO+6No7X31nZTeb5EF9VfU31d9ftWr2Idd0XyVX5opVrl8LipUDxcuUAhmMWsATo822FH/kDImLCGqrJt9ksWcKPvqsXgFOpWhqTuMBRhhDoD2GFl25dOZFl +GUxX4A0+diX71AKkelZAOsf0DLgl5LuiXkMaECDtAreRfVdgzgHmAEcZUF+IgI58GFB95L9d3DHg6oAMkSqTykRnv1pPoBmL1anHiUv8eDUSUsVHFViVr5jXhvncVrPrxV5e8EO3X1Ip4DKCJRDBK1iuZA9bhmkQtMnyQHCEmTfn9Sd+XJEbBeokXgzlCikNxOwTvujZHqRMFHVPMQDSA1gNEDenWDKK9lTZG+OdV9V51Ynhbl2VA8dblAIZjFrA -jA+Gl6S2lBIfFk+VosRvqHJ3dUg3w1EgK7Uo1aNRjVY1l5DjV41BNUTUk19BXzW+eAtX3UXu6paFXD1RRQyG+lFav6X8FrWbzxdVJ2ZDn4gKwL0wjZ+VVEyDAI9BUAwAb6KGVQAsOdgDVAPhemAhYv2T1kPUpAKvLLgHsSbHdq5VfCA5NwYsTlrR+2XE2FVb2bzxJNxACk29ZaTRmgZNhAFk0NNeTeoUFNlYEU0RFuIKU3lNlTdU3H06VfU0kAuT +E6PNthTYFAyJiwhqqybfZXFnCj763FJBa6Voak7pQUYYQ6A9jssmIeAHxVYwPhpekYZTOnsFkJUe5FhPBQZBk1EgDHXU1tNfTWM1l5MzWs17NZzXc1MharW+e6tWvUXuDpRRWolqZfe4lVFatoXlVEgATlVVa2bzz4gKwL0xjZHVVEyDAI9BUAwAb6HmVQAJOdgDVAPOemAhY0OQ9SkAq8suAexJsd2pjZBAPgAtNwYoLlrRcSmU1dVIOZU2joNT -cwBNNfIXVVpBDVcKFuFIOa1Wys+ZW6yQ58TStkdNo6N009ZvTScD9NgzYs07k+TYU2OgxTZM0jZ0zQQBVNERXM2lNBAPgBDNyzaJG3RbqeNUepptYvkMZTXtya3QW6tdoiqATjTDy0q1SlYFFPdpKbrA1NbTX01jNczWs17NcuCc13NR0T8lgdYb4OSR1QS3vB5mSI0SlgxUBbg4ccLdAw4CSCFJiMCmAkCV15oBnU0W2dRAUbFedcoYh+YmKQgw +f1l1NGaA02EATTRM1tNjhR02VgXTQgA9NY2X00DNQzcfSNV8IJs3MAUzXyH7RNtbEWY5v+idEweSRQtU9FvPOU3zNywFU3EASzX1krNJwGs0bNJAK03tNnTY6DdNuIL00d0/TQQCDN+zac2bV5zUC2TNokbdFupw5R6kHVMkSqETl+vLwB9pIpRA5AOCceHVpECSPI0SAQtSLVi1EtVLUy1ctcuAK1StR0QalGdYb4OSn1ay3vBFmQ+Xwu+jVbnl -CqmfvFtA5rOUiKQ7sIbQZh4jAvBhQ8is3XfKl8TY1McoFUHmrW9jVBX8c5tsE2R+oTS/E4+kXnroT12sX3afAW1TtV7VsGY/VSg/iGeIM04ikhCs6dJk+nfm0OqA1QN4DQfW+xIJWhVglL/G63pMyXvA1wN6XgiUM+SJURXvWQzE8CjR/lCaACt41GoQit3kGK2kIErYxXz5/UsC0KOkvpSW0NC1XOQvVeLCOnM5aRGhDO16wOMDlEY3iMAUAW6I +44OHHC3QMOAkghSYjApgJAA9eaD11NFk3WkFDxa3XKGIfmJikIMAnGYsxkJHE4ooDYKQiG0GYeIwLwYUPIpT13ypfGz1THPhX55q1svVrppFWCjZNkfrk3b1XRdXkHpv9fXkognwI9XPVr1XBlQNUoP4hniDNOIpIQrOnSYvp35tDq4NAGZ/UENvsTRVq6jFSQ17p+KuQ2hxK+VQ1cVgzDxXvWQzE8CjR/lCaBqt41GoTms5SIpDuwerdJUCNYWE -6C8NVNkb6h1x1eHVie0uWI2y55eIRYGgSWKaAYsljFMW4SV0MEitQpUCLBq2C8RGFLxl5V9WWV68dZWyIdle/nzumIbxAkas+mNEqg7lXK1Eh1jXOl+VRYSlklhQVcE34EOrdKnhVOAY7ZNZMTRilugkzYc3BFphTEVFVrtMlX2gaVaU2WF1hSMTPtvWT+4xoQhXYWaFj2VEBY5y2b1mSAoQJIARoU+ETm/NcZUam3tpAPe1tNp2U+1o5L7VExvt +I0KOkvkKViN51XOTQ1eLG85/RpLeQzLlN5vkTjA5RGN4jAFAFuiOgb1avbZ1yxZZVfm1lTy2GlmxUBaEWBoElimgGLJYxHFuEldDBIrUKVAiwatgvERhS8cBWI1wVevGhVsiBFUoF87piG8QJGrPpjRKoLxCDJ4ZdPUcF5hmE02tJFfxzm22TfgROtL8fk21hjIRmWyun7hilugELe83PZfhSUUBFPVXVUug/VYEX7NwRd0GhF0HWNk/uMaCdnhF -pVTjlftURT+0Ydf7Y6AAdyHkB3xFIHc9nY5pTZB3MA0HQYCwdu2bVVOF9VS4WNVWzVrU4R9qXhEkSnwHe1FlEZY+3EAthT1WvtJVf1W4dERVYX4dwnT1n/tgHeoX2FFHWB045NHXR36ADHX9mjV8wfKGvyj0UqFSZskfhXyR8YV9J5tKYBFG747YqKa/AvHgi01xh5FilCAOKXikEpcAESnW4JKWSn1tYLkKV35IpS215pojRuWqV0pcjhJAgJDp +zhf9lRAjOatn9ZkgKECSAEaFPhXZVzeWVGpoHaQDgdczZB15FaHf1mwd61Qh2FFKHcUW056HY6CYdyHth24gWzX1kM5QOdDlEdzACR0GAZHSjmeGNzWkGTVwofbWPNOEfal4RJEp8Bgd1ZctW5F+RX1nMdfVczlsddhYx19ZGHVh2OFERbh2A5TOSJ3EdpHXSzkdKLcXh3R7qWP6YtdbZm0B1UtGhCfRkAdBoawN1bx4dFPdpKbrAAhUIUiFYhXA -DwWyNgTEv1lkBUZ/Q0Qhy1aN1xlZXmsOkKTCrCZFTWBneQrbhJewZEHwY25MVEKyFKYwILDxMdpfK2+5+ySBXPFcPh61vFgVR8WAIkqRwWVOerUiqAlhraBnJ5hSannp5FrZelmxDMmNCb54xacTFUTrWrh+CnQO5Fg+tNCA171SaHXnAlXXSfVJ56wMfmn55+Z8Bz1RrEN0IZgSKRClYgmYo0Yw39USCJAMkOyK65e6i0mLdEJbXket5GeCUkZS +BEp1uCSlkpo7Ro3stWjZy3mZcBQaWX+SBdb4yQZXuzo6QOkPBbI2BMbA29pxxH9DRCcrc43XGIVeaw6QpMKsICVNYGd79puEl7BkQfBpHkxUQrIUpjAgsPExPtprZGX7JeFfPUSxy6TKLvt2VfGVeIkqcmWVOVFRiWz5B9drEN5hSU3kt5frdelmxDMmNBv5+xacTFUEbWrh+CnQO5Fg+tNDg2L5ZGXG10VueUcKH1+RAAVAFIBZ8Bn1RrOt2IZg -Xvip4VQJZ3kINBFYMzhtzPjSotUufI4iZdD5TfB+Q+Xe/WKQWyt1AkNnnHPknC5DaSVU5EcTTlJEWRbHRKg6MHxWO175Gw292QZQyl1xzKaynspnKdym8p/KfHoB1gyivYNtRLU20ktZmY/nill/q/nW+MkH/ACip4AohAkWLrZA/Il4NchYUf9N76LxGjdqXNpXLbO1m5F3oVC1wPiD2wxc4WWV4FdrKM84+mE/JeBYiIrNu2ZRjpbV3t19XUuk +SKRClY8kEWCGoGMCg1EgiQDJDsiXuXuotJZ3QSVT5cbRRn4lpGUl6ptJJfRnpeFJQz5UlObcz40qLVLnyOItXVBU3wfkM10INikFsrdQfDUsw8lUmWL7jlkuQ0WfoTmQGkiq0NaTAuqGlbI3vk3bb3brA9KYynMprKeymcp3Kbyn8p8eqo256bLfQZjKudVO351v1YXXpdboTJB/wAoqeAKIQJFi62QPyJeDXIWFH/Te+i8Y40ulLaQq3HtweRd6 -yiarU13QV4qfbBR58Fbq07p+rWt0Hpk9b10npaeWen7di9ZZ4osGoLlA9JgThd0NlCoDJAfpMWefDxtfJa61/p7rSb2AZpDt61N5r3WA3+tH3TCV0ZwbRbUvWf3cg0RtLGXRD4w2cE8pGgOfKeY2IqvV+Lq9fwVfZptiPcxUGdKoWxXUN9NJ9EdwsML96rVdbfj1ItEgPQCQ62IHABGA+AM1E09ueoS30GYymHVCNO9UpXnVlLdb5FgrVIyJ9JCn +FQtcD4g9sMXN41leLXayjPOPphPyXgWIiKwmtRITPXzpg3dIUwlcbXCXjdCJZN3l5KupXn9errSBnutt3esCN556ZA2vdV9SeaYwuUD0mBOf3W0DJUMkF+mxZ58CW1v153Umhf1fsQxVENJPjG0ptlDem2I9E5S9bZttDbm2sZdEPjDZwTykaA58p5jYjW9X4rb1/BV9tW0nC5PXyWrqClbi300n0R3Cwwv3jdUjtbPcF0SA9AJDrYgcAEYD4AzU -l/Xneiiuoj6CoHLN0oQ88frn7KplWsVS9updy3bFlcOhjQa5GEgW5dpMMZ5zJqKCSTrJfNkTBl9+oHr0ixe7bbQHtZvZSHZ+b9UEhFg3NKLW/c4tdNEl+8ZGVBOw3kOHC7cH8QGVfxEgJbKF0EcqHJeyscsM7LahdDa4V0nrHnbtyact+7OAKtXtleuVdIgPIDMcqgNDa6A1q5YDPtjgMG1+A4bWoRSds4Ws8WZU1VxGuZR64OppcggNIDtcigNJ +cL3UG71Zo0TtEvd3FS9NlX9Vzt1vkWCtUjIn0kKeyDed6KK6iPoKgcR3ShDzxPufsr+VdxQb1ulirc8WVw6GL51/WmIaTDGecyaigkk6yXzZEw7ffqAu9mUUlkZVb7YXkr1VIfA1BI33Y+xb1f7SrHFVnnThn4c3kOHC7cH8ToVfxEgJbKF0EcqHJeyscsM7LahdDa4V0nrHnbtyact+7OAltYalxKeAwQNEDMciQNDaZA1q6UDPttQOm1nHvQPS -yaAxgPUDFgW7K4DnHgQMk5Y1cbWAtcBmbW5xVDc17ndAaSUomeCiJXl/RJbS3Ed9tSvQCOghALbgQZUwAaFD91BgdWNtAjeP3dxk/eS1s9UpUVYsoUGiaAiM+tI+wEYGuGkj6CdKIQ26h4IsMmG5mjQf3aNr3jZWKQxEGFBwWuUiu2StFKDaoyNL/Qq1v9tjc6XpmX/agE/9imCF5tdmAf14RNUtX6XXtc0T9kDORQ6rW6J6zax2bNmtc1Xa1nA9 +d41bJ2218nQ80zVTzR64OppcvgOEDtcsQNJypA+QNcDFgW7I0DfA27XhuQ5XtUYtcBli25xApbi2/dRcfT0meCiGPkdtE6Jerkt6APQCOghALbiQZUwAaHL94xmO1r9OpZO2b9ujbZVPl9lVKDsof2BH4iM+tI+wEYGuGkj6CdKNw1qZQyX5V+5TjY/0uNr3mFWKQxEGFBwWuUle36tFKDaqmNIAyLHu9ttBANZVlIdn4wDimCF7TdmAUVVplpfk -x1usJQ1p1yho/lWWTVtffIMzV1DdHpyZajgWDQ9hzGpmQMvwMuBltyeh7HW4p6O0CaA3ncHXmDwpYI1WDrbcpXBd4jchR1g1Cqdwngx4EBqMtoWTLThm50CLBFeSXYEMpdc7e5b5gqWHa1feUQz+V4sU0ONDxD1XTgXv9N8SHk91VIekPy+moGe21Zg0dgHvx0teX6apC0aQFJyMdrlUkS80aCPZ04I4wMA55QywMa1u0ts061XAxtHQjsI5IPad +B2zRIHVqkc5AzlDkWp60lyZxF01XEaJFEgyp1usLQ+7XyhXtXEkrB1zokn6DzXtHryZajgWCE9hzOXEWDy4FYMQA/QB7HW4p6O0CaAcXWC7al0BbqU6N+aby0+DBjchR1g1Cqdwngx4EBrit40GaXhm50CLBFeZXQkMVdJ7e5b5gqWCG1femQ2hV4sU0ONB5DZrQUMb6hyWN0lDqAWUPy+moL+3Sp/7QbVYDJTegDzRpAUnIx2N2SRJIjbsiiOtD -zQwqHVlbQ7WWo99ZagABm1JbyA9sDMBpDxMO+ZoC/AlBtoN42hAEIB0QtwJgC24LwAEnLgtuIQC/ABNRQANKGoJ854tBmUz2ClslRYPNtE/YsPT90dUBYSpR9uRW4OWIqL3N6n6MIiSMJ5hvWTRPg0MkmV/g5L3mV0ve6Y3loUR/lgD5UMyYX9xxRWLOw/PpsTc+sir/jtI8mB5WPDu7YllixdXRLEm9jXXDU81ZJYm7pZDwHAAcAAIHAAvAQLhA +MRZ2wdDCnWINKd50ZIMbRyI9nSojGg/MGDDUka51yVKtUxlS5o6VMM3aPbAzAaQ8TJ/maAvwJQaT9tSoQBCAdELcCYAtuC8ABJy4LbiEAvwOzUUADShqCfOzLYZlJdWpeZXr92jZL1eDO/UXVAWEqUfaCVuDliLa9zep+jCIkjCeYP1k0dEN7tvudp6HtLdUb0UFowKgVlQTJiygsm3jXz67qmxNz5jpvIO0jyYSVQCP9dnBWLFDdS6dJkrpJNRE -BlZSzB8MMwP1MY1ZDdIXb2ddDeShVetaupA2R9Sfd91Btn3SG1MZYbVn0A99nHRCmjbxiygsmAKDaO7qdo/sKBo4mem1hYmbVP4FKubZC1xEsbaYidUq1QHgjD6AEGMhjYYxGMmD4xnw2zDfnfMN1J/ReuUXVIXciyhmBxORVIQqUfTJKlvAMGE00pBOeCnY1pGL2TtEvdO251MvdAUHM23P97JCyYck6q2krTcgHGuLq6Ot1R7h/1vDq6dBU/9c +3K1/JYm4ZZDwHAAcAAIHAAvAQLhADlZSzNAMMwP1DLk616usH3UVmJVT759ibYX1UZuKmQ3w9q+Rm1I9zGSj3V9aPfZx0Qjo28Yuj9BQtDOw/Pp6P7CgaPw099slb7Uqhx1YP1Nt12iKpFtpiJ1Q3VAeEsNxjCY0mMpjzgy+bbDyo+4Mb9dSesWPl/1b4PIsoZgcSCVSEKlH0y1pbwDBhNNKQTngp2NaQ69+7Xr02jq8XaNgVhnqiy7cicBrjsi3 -YxWHbpOQ9wV5DUTQUOy1hlhwBMg2AFoXxl4RpwBATDhfRL9mCzkDmjyUaMQD+FKI/kSMjzI6yPsj7QJyPcjvI/yOze/oHs03A4ExEUJF/zdIPJFsg02N5jNOdrCKZapS7lJQq1Tcz0j6/uMBCAl5F7gAgF6Lgy4AJ+fUT6AFQP0C1EOIDMDOAklUKOPBIowuX8Ncw5YOTjnwdOMz9boeIT4UuWCAFKDKo7wCsoew3BpdcY/McMGjh/UePGjowEhD +w/FVEQE0Li4BjbvdnmFDN8ZAO2tn7TANZjFYUH071yA1NFqpRtQ0OGWHAEyDYALhRWXhGnAAhORF9Ev2YLOzZaPJRoxAPzkO14GfyMjAgo8KOij4o5KMwA0o7KP+gztTcCoT+zSh5Od6LS506DbndWNS52sEpn2lieUlA3VNzDyN424wEICXkXuACAXouDLgCAF9RPoAVA/QLUQ4gMwM4DGV8o48GKjV5eO0rjqo54MHDs7ZqN79/lPhS5YIAYYO -fWAydvGWjDyouqDpGhkyrMxo6Wrhlp/bhZD3jjxYg7KtrxfgUU1FKYkmyZ6WTUQVArI98C24GmVGPw9MYwqVC9OXZj6fjI9UhUdCOFat0pjoJfH2+tmY5rrJ9sDQlPfdlE/0xRxFJn3l5eGXaZO9WhpJITwQo0TZOuxVfT7o19FDdNXZtMuBrCKZofseZw4q1ZOxMTfkwM2BTwU9MMQivnSZkTjfRXJNBdM4ysNSgrYtQps0yqOhQ7j6k66qtJ+g +GjeLdAgHIcGl1xj8Tw4FWG97pg+OjASEN9YDJ28a2PfF5dnLkaGTKszE8xBzOWn9uFkD+MvtiDpa2wlxYaikUpYwzGMGONRBUBCj3wLbiaZaY55yr1gXiBMa9DXZj7gTLrfmOz5hYwm0U4JYzn1k+yXhm1l95DexP9MUcRSbb5eXjV3OTvVoaSSE8EKNFeTrsd30+6fYxT3yVDbTLh+dRg03ah+x5nDg3Vk7AJPr+sU/FOJTWw1nVuDuwx4Nrjnw -mH52QuYNv3LF6jXv0BD+k0ENWVWkoH2Jh40Jrn2jlkzoZCs92jKD00gyZV07tD4wgFPjAVakOBeb45FOD1Nvee0qxuQ1NFqpf4y1kSAymvnShyxbKuGhy7cjtqEDJEv9OAz3rMDOgz6ZTBMbNmEesDwTiExx12pEACxNsTHE1xM8TLwHxMCTQkyJN4TutRACQzQMyDPJyYM1iNNDGHrp1xJKwdc681jGTTnCKimW9AYUDwwMMbAvwP7V2deSfkQA +RuO79boa2LUKbNMqjoUl46ZOuqrSfoJh+dkLmA391xQ43398Q7ZNP9948jUnMGGCKxsobuV6MPKqtvq2dQJGPTSPtQTQTVr6/4yCOATH7UeC8UlpRlOb1BVYgPVDBTbUOlVmZXNHKa+dKHLFsq4aHLtyO2gwNmisM/DPesiM8jOtDWE3J2YR6wLhP4TinXakQAQkyJNiTEk1JMvAMk3JMKTSkzRMvNEAOjMIzSM8nIozg5ZSNVFCoTUX9jL0Ti3N -gDwPoDKAIwMqqYMw3ruiDGjoI6CNKkgC8DGDUlcuVmDDPeKMSTJ1WS2s9EnuNPIs6VObGrtp8H8E7GJzKhR7CJ0BjAiMc06Mp+D2ngeOrxhkz9WjApY0ybljFk1IBgBfPtWOA+9yurZzofqEfipRLk1DWG9geR5OHtBBUb1yRhBfkQ4AuDLuh9Kp+ZGP81zBWkOxjiYdRMAD6uohX29SU7Kwx9cXj60k+aU3HkZTlPllPwNOU2dQcO0cSyTZ9rPi +ewikplvQGFP8PzDkDL8Bp1gXTXH5EAIA8D6AygCMDKqmDMN67ogxo6COgjSpIAvATgyZW3lq/Ql0qjak99XctqXRJ7HDqxOlTmx17afB/BOxicyoUewidAYwIjNtOjKwyXEP69F04kMhVloNSjNj4WW5NPTFYu2MejgPvcrq2c6H6hH4qUUFMhNMPiGMEVI3T72k1UY/30s8GWTgC4Mu6H0pAFqY2rUKF4I5mOJhnEzmO7pmunvV5TbFd/WVzBff -WPUoZY/MAVjmUFWMM0NY0L6kNTFRm1TVPkx0OKDNwm2MZu6EA6RoQq1bQVMl3zuznrA0c7HMzA8c8OMvmPnWKPSTEowsOBdFLTKPW+J8SyyvQ9iFiIDtScC5n6CtWCFCKeek2MkGTRo/bO/0dxtaC743kOAPyYNw8D4WM6SGpPKKljVgWuTd068MPTR7WbZvjqc+wpD1tvV+OS1X0/gFAjd+ugCAA2CAV03hj7YDOsC/AvZ0cM4KEIza0sjPIgqM +PnQ9H9SX1lTVc5Q2VTZ1Bw7RxLJDX2s+jY37POjAcyV56C7owzSdjQvqT0yVgjbSPRjvU0SA3CI403aGoJnqcQ3VUhdKXfOKuesCZz2czMC5zC45TZLjGk/NOrjaxUtOHDm4+bPbjAyGH6AcPiNxDitUHARDPItsKczmNvladMezt44HlXTFynzCKKu+N5BOw6A79REau7cVIWM6SCZPKKn09hXBTCAUUMRjcZWbYgTxc+woIDMI0gM1DUE/gHl+ -93742gs8LOizRgOLOSz0sw0qyz8sxs5oj6wEgsILRtSP40zUkUC3dzfjUzNEjkkP3MYGTdlhSK0b83sDWdNvLzMslyeQHhzAIOlui4AAeJgDLA3wFMCEA9AKQDLgHAAHiD9Cs8dVKzo/TUlqzLPRf6azHbRNMKKXEErnCs7OgeUr5IrfoKbI0wNqMTtBudbOfVh45fMXKRUz1a/WpU2XUVTNyrZNez9nliHYYIUBV0fzkNWvoej4c4ulSZy6bDUG +mqRACAA2CAV03hj7YDO+C4QvZ0OM4KF4za0oTPIgxM93742cswrNKzRgCrNqzGsw0pazOsxs7Ej6wCQtELAw1zNDDPM91N0jTXtyaSQs8xgZN2WFIrQQL6mZpU28Us3kkN5AeHMAg6W6LgAB4mAMsDfAUwIQD0ApAMuAcAAeEv26zX1frNi9NScbMpdF/mbP8tfgwopcQ9ucKzs6X5Y/llt+gpsjBpYve7PWjCNbaP2T103rROTPVr9ZNTvda1M3 -QpyT3Ms86WQ7hlFl5I6CXqxNaFMoBT0wzB8GIjD8Ni1HXfHnxTOc0fV5L6Y/nOUZuKlhWfdOYyn1Gd+Y0g0xxNcxwQmTzi+ZMle5U9ZMeLVU2tT1j1fV3P4jlDb3PcmZMaSOwUv3sd312xbROi/AtAp1MGOcS3wKJLBwDzNiTGi2ovreqswF1Tjo0wpNy5Q8+FEiLY0PL5ezbgyeCHzzyLbCnMcjcZUbTeozbMm5dsxcpSMccFvkvVRXmZ65d47c +K3k+HP2eWIdhghQPXVAupVMCwukJzVrUvV/TaWXwVCpSSRlkO4fRZeSOgl6lzXJTCC6RUwDfBiIzQjO6YNFEOFcxQ75TBY7iV1zxDcX3lzpfc3NVjFfe3M1TPSEfDBLP1q5MDzM7gyqaGmLB1Oi+fffflXCZMQS2wUv3h9312eoRHW0C407kv5LhSwcCSzKk5YvmL63kbP7D646fMrT1uehCWet0BKpy+E6UeOeYrmfoK1YIUIp42TYyZdMBLFyl -VIZdeOuXwBzQS0kMw1KQ3/Ovj6S2iEfjnBR9Pfj4C9JYy1v0+gDKaoch0HQz5M27LdO2PJjyqaudpjwDOsK/CuF0MMxTOoAKK2iuMBqC2B76JcEyQAoz1Q5x0QA9cSIunkYixItSLMi3IsKLSi0TOULf07nbYruK0iv4rqK+iuyhGRjiO0zeI3VOMzoLcm7/9RHjupjF0kOPEaD4y6mk5JzJSPVMCG7JiBwAAIAexCALuMQDYg2IOMC3A/QMJPho +Ixxw7+dDVFeZno10gLc6DV1465fLHOE14AwBPFDJYWlMMwFS2jaoL1S3rWQThtdDOwTymqHIdBmM6zOYjqANjyY8qmrnaY8AziitorhdFjNszWKzit4r5C2B76JOEyQBEzBIyTP1xqi6eTqLmi9ou6L+i4YvGLDM9wsSAhKyzPIzZK7iuMBFRSLnaDDlroN1FVPSdXxEoenPOilexdJDjx5g+LNppOSTKU71TAhuyYgcAACAHsQgC7jEA2INiDjA -rQKJNiC4k7T1B1/U0vPjjMk8NOR18kxvNuh7lRnC2+e+BzRNTK/QkTqjpaVsr7IZ861Y3LDi4tyOz5o87PRRMki3MA+gviV1rEaw17kBLgFbdPzpno6Et+enkycl+jq6gGMGOFQN8CyznwJjaHgKSzvr/zr8J+WNgReMAvvTmc8mPIVCU6hVFLKUwXOQlWY4G2lzafXWUVzeU73k9I7GZaD1zTs43MWThkFGsC+P2B0sdzDY2bgUT9fc14i1Uq7L +twP0CKT4aK0DKTYgqpNqNmdRCI7DpmQtPHzBdctN6TboQ+0Zwtvnvgc0/UztMJEJo2WlbK+yE8utWn868uLcTY33MfGGNTJhDzAPoL4ddaxKcPp5iS8+1xzKS570L1Sc+FP81kU1PMlZTAhUDfAWs58CY2h4CUs76iC6/DIVjYEXiwrahbN37pHQlXNFjhU80tF9hJY3OsVtFexUVj7nTWM0NMcV3NHQka+VDMmgc4ZAhzw82HOjzKU2T1dTky8I -5HLN8JunUjvwF2JTLQlXmsFrRa31OZpjPZaun+q5RrNWZmMVazgwmsGXA7EpJIy0DoG4/hr8iU0BbO+Duo7Ys51ts8GuQid5W9VtIqkcAFPz9k6+zCKnMP6lnxuYcLEJD7o78uqtz4+q1HgvFAqU11jmQmNelYK2AtXtfBXNFzSbsi7LpyGIxisQjbrNhu4bpdPhvErLftan9mmC53ZGJg3uquarBwNqu6r+q4avGrjoKatsrdQ+sDEbeG0iswjB +0Mjw45ItscJ4PV1vFN1V2KrLBjkWslrZazNP2ry44fNaTi0y6tHLbq9bliqiUJrBlwOxKSTitA6KeP4a/IlNCuz4Ij4uPezwwiHG9iigqBiYbSKpHAB7475Mh6psLVQfT58cE0grP0ylnpmYI5CuWlw9bT1ZTKZegsQzmC9Jb1DbWRIBzSbsi7LpypI/nT4raI26x4bBG6XREbJG6jlx2FC8IP4zEgNQud2RiYN7aruqwcD6rhq8aumr5q46CWr3 -G40OCr9CzAYiryPc5Zdr1DSgXKDGbvYga4Xs2ut6Sm6+epsAtuMQAzAhANbiJgIOmnn0AYcLUQAgAeLgxTAe66LkMGdq2KXaLp67KOWgBoPoaa48Bc5Mr92PVxBioDMvFTnLlsx6pKY2AMkBf+58ztNztA61xANzHxoDUyY7s63Oez144OlLjB+i2CJr3lcmtBz4viq1d1sG8clyOrUUknpZW6OMAwAIwPcAPABXCWum2gK6GaTRnFenN1Z6U42v +K70PrA5G4RuYjZI9RsczcoQIvUjrE5PMS5EcVLmMFA0xm72IGuOHMcjvwHpI7rOlRehsAtuMQAzAhANbiJgIOs3n0AYcLUQAgAeLgxTAh61mmJdtq6f73lps9ZmYxloAaD6GmuDQWBTp/ejDygewtHRs0yYY1ZKY2AMkBf+zy97Mntvs1xD+z0a26NEY06wmu+NahhqAH6LYKmt9dv41GXBjma8N1hjo3Rkspzea2nMFr+RFujjAMAMROPABXBWu -sqBS7H1Nr3QiUut5MDSXP5LcJQSblzGfRluFjKJSz5HQoa66rDrzS2Ottz1U6L5ibEc8zPF93Qzdph+OMXTCrVIMkpv5EuW/luFb/C4svppyy8f6rLko2vO2Dl1ahh/S8oBdMis6IQzS3ryIQPAiZpiC3ZrTajahbebvm7CGBrFlZ+u6MYUOF2Jh9qMAHS+J00JQWl3s7/hDbP7JJZgbe7p/OBzLw3Y3pbj02WvlbGMJVsobYVWhsRVkTRLUzRkC +m2ZS9WuTRMoFUsNrVeblP1LLawVO1kRU+D1L55PsSrlTfa63OV9mS0Ov1j4AtFtOjY6y2MDzU6/Gs/Ya1D2OdTE87zNHV4w2Ist9TI+Hph+IWb3lizGwL8AgyWm0wLlblW/cAPACi9ssZpuy8f77LaozpNpdxpUVarQXEKijtYYPiEP/dyIQPDaw/MS3bHT9jahYhbYW7CGhrQVeGuQiYUEkAALiyKTDK2mIYGURzv+K6qdQQK3jVJ+SS+mugrv0 -5X4DaHAcWy50ogyHKx42YvBi8l2hW6zCBeO96wE7acsTtOiOvuRs1VFQ4jMSA1G0hPrAF6CptqbGm1punkOm3psGbRm5xteFFO4xG6a+O6IOoAdOwGIM7tCzp0ML5E0wso9LC5bW8ARxbNuBp7SLhhyrYy4MPQKK2+sDeAW6AM1TAcaAHiY2F6LUTfAhAA0qaAjoA7j9AWgyouqzO24jErzskw6sbLTq3Lnao1aSm6n2DzvNMCELmwvAb95sw9td ++CulLwEw1sYwTW6XM1LeARhuIrwHThvoAwgRwHFsudCoMhyseNmLwYapa4VusVO7po07Kg6gAM7Tojr6UrLftan9mTGwRP5EOm3psGbRm4QAmbcAGZsHblm9ZsCbeOazuMR7O96y07actzsBivO/wue10m+KtsT/M9yZrun0W1DEkR+DdXQKR2/kTeAW6Os1TAcaAHiY2F6LUTfAhAA0qaAjoA7j9ALcbvPqN+83NOOrR8/qU2LLm1qN8QNaSm6n -4r6494nDCIbL1BbZo0Nuhb4WRFvRrx08DvmC4Q+RoqOU6Qlst1X8ymshLYFd6MZrmW70sxLBjp8CaA2IDAAHA1uDMBoKJW/fFlbGoIRbK61a78NADcUw1t1biU/Wtx9TW0t1k+AbdhXtb2U+n2Vz+U32v958eyFtNzC0KNtRb42ySWrB0S8vmEY4PtJvvRcwIJBtTnMzSMupFuLkmCL6wJXvV7te/Xsmbt+YNPmbx65ZsuhWOoByGwuUpqP2matm +2DzjtMCEXEBf0awV/e+sxDb874vN1d4+DsxOo68jtxb0eXGsC+j04jvmCaQ+RoqOT9Rluu9ySx7155YU+E0RTuW/W2lbIXZoDYgMAAcDW4MwGgq1b98fVvEQLIhcPNbutY2t1Lzaz2vVz7W7XPdCpY71ulT3a0ZwPWFU10vVTW+b0s75E27FuujmULNt57XY+JljzNbWbhsTg4wLPg+Sm+9FzAgkCNN7bnIy6kW4uSbKWHkTey3tt7K/qYtGz124 -4N3avbicv0teyKP1Wz0e9tOnDsvZixDW3vYsikwCiJiFA73i7due0V07ntVdbo37kw7yQ5n6pLCOy3vYiQC29Md7F7QCP5DmG/+OU7umgHLWy1ovHLeGKmhwAbaAzkQeoAJB0wFWi5B3aLUHpQ+EZoLzOxgvkrWC5StozRuybtm7Fu1bs27duw7tO7FC1xsSAtB/QdkHcC8wfUJAq2TkyDDlnIMEjKuw301grM3PrCsadGusMDSqxPNdlJ+6QDfA +jGnrzq9L2ursvSctdc4MLlJmj9pmrahDd2r26PzorXsjeLsQynvytLyx1ZvLrjlzBdQ9qMAExV78gjsxLP26lsK+wK99PAjcG5n647AMzAO978GkTvwrGC2TvYbuhRIBs7qAAHLWy1ovHLeGKmhwAbaAznQcMHTAVaLMHdouwdW1ASlSsC7SdkLu0LsHhADW7tu/buO7zu67vu7nu97t8SPK5TvK79B2XJMHBC3wfUJIq853VFo5StuU98m9T3iM -9AA7j0Albf0D8TkIL8CSADSiMBAgHAJeQr+zu4evmRA02Lnu79q2dVR17PYpOBqbeIRZru7kSBzQwn+/nwgFZ8Ko2R7ly2+uctF8x1aOLDSz9ZNLYWy+kMqmhnZMOj5gvbVa02yfAc3T+e8lvxuqW+Ev/LYc+0Pl7QlZ8D0AMaBwAxoBwACkJzATUnNpLxENsZAwWS4AM5LY9X3tGcuc5ibFLg+9A3D75Sx2u5j4+z2vIlBU6iXNISR2ZN/WCKO4 +X0s2182c+sKxp06m+oNqra8yuUhdpAN8D0ADuPQD9t/QLJOQgvwJIANKIwECAcAl5M/uXbupW/sctDm1y3WLVmS6FY6EFlCgCsEqbfZEwIHNDBgH+fIQVnwdjV3jQHX617MvDxvfVMhLgyzGtvpIy1Ev6tCtnsVgOZ8bmHCxgI3+Nz1de4nP5byc5GPFbUywLWHk9ADGgcAMaAcAApecxk0FziG4pClQmUxXlobeY3N1j7s+zPlTHbaxPvFTzFX1 -uMq7S3D1oCnc42NK7S+VcLq77FT0Pqe4A2fbMN47L8AnqBuxik1HdRw0caRljttujjys8vN7bq8+svrzvh1ss46/BHMBh+JULzafoahvevky2xsNy7jNi//v+bgB8eMyYUbceUxCqR28tHcp2OAdq210/r3AVyB38uoHpa83tvIghp0cZzI9Z9MYb0VdCsQAtB1jy50aK9ysE8NB2LuS85JxXSUnjO7GUsSSIxABs72C7B4QAnwMYemH5hwHiWHK +uU+HS+X1Srw27wWjbNJSz4cE/Sy5Mf99yBEuMq7Uwtu77vY8tvCL+a1cJfFm203ZFewAVaw3VJ6pbshdnR90e9HGkZY5XbrgwbOaTt29pOHLukz/sCtOOvwRzAYfiVC82NPQhXfdL69sbDcV41aPZHEW7kf2jMmPm2/lMQkUd/LRmEcQWQGnoE1QbX0x55Y7BB8gGVr3e4pBsoKC6DNoL4MwB2FNJOzNHYLd+iocDaHAVjy50uKyStuyBPBweqHH -qhUA2Hdhw4dOHwu2Oo47CmhwFknFJ4itUncu0KsK7yhxRMq8a+/8ib7bQL0mkkmwqtUvaAiyqv5ExALcA8A3wDv4JIwKdkC24FQC7jkA1uDACNFl++4dmbnhxZuWZ9+825zAHpG/CZOqqD8e4SrEB4Objj60CcXLZxhUA6Q2APyCgnb24aMJHLOl1wp74617POVSxxkdeLLytr0LFGBeDVJ+iW4UfBLwcw13FhaB1iejWGh1Vt/DGIHWuFLPe7Vu +J1ycYrvJwIcSAuM/RtULtKzQv0rdC58COHzh64cB47hyqoVAXhz4d+HARwrtjqlfmye6aApxXTcnwpxSOSbOuzAZCLi6wUZMgD+agD/IJ+20C9JpJJsI3VL2oot376wMQC3APAN8A7+CSMCnZAtuBUAu45ANbgwAkxbZtG5DBoHtObwe1EfNucwB6RvwmTqqiQnuEqxDhDZ46+vwnr82cYVAOkNgD8gSJ6Dt2T8Byzp/7CW3NvhzsVYcejL0Sy8q -1kgx490tbIx5Utfd7a7KzdbqWbUtFjCBCIwXIto1FuZUrS8sfMqqArOsKD/S62McLfaCHDvw9BKtXU9ep0UVMC+gPEDW4qgDtXKLW2yKWu7xLa4fM9wjSetunmMQzIky0wJWsu6PC8nWfoVnlpMqNFfOoOebj9s9tRnenrct0Mj7rmaCQLiy7NEacJ4BLuWQUNnvxb58VDs/LZISgfIBmJxq1v1qUUjtYHYromOgL6Oz+OY70TXNHhBPtk3QWWSl +O9FxawVo7s1llsDdOW1Xve9sZeSd47Pe6NY1g/e7mM71IffRXTHo+8PvFj7a5Pu4m5Y/1srHabdKLrHHc+ljDrjsB6FlnW+yypVnpR6gIH7a2ygbH7dPU3Yhw78PQQ3VQvS6carGXPEDW4qgM9UmLQR6ZXfHFizAV3bAJw9sA1hMgzIky0wLWsu6si1XWfoVnjLQLwtjRXxmDbsx6pA7BZ3p5fzdDI+65mgkKEuBzUgDH7A+Z+2tB8GuB8SewbxN -onygTEAOhe706lpZZMdaESx2IjbHVUPsDLVaiMSH6APheYXilgoeVluI60Oir/ow1PDS7C+m68gxUO5bqoq1W73jzEaZPOIetwMwALZp5HKAOnNq9fvOnt+66cy5WOr8a582sMsjQa3vWYKfoxcAcR/spBHZCkwYYetPi9m0/qNgnsexCf/y3cCYLC2JMF20AbWR7ca+mZfBY3AXgSx577tP8xEvFnUFyfj9cPfLifVbQ0Xge/jBB8ScvAF6I6B6 +fBsQrVa6GaNb1J2K50h6G/SeQzRTTBMU7EAOEE+2TdBZZKWifMhNUXC4TRcKWGliKeWpQg3c121og10OzVzzcodMXSgSxfqWllhJuVFJp2XYybBhz1NWnkw5OVqOxUO5bqoN1Rek376q10VMCtRLcDMAS2aeRygYZ1AUB7H+0HuRHluVjq/GufNrDLI0GhqBsNO08XAHEf7KQSMlNp1mfXjZ057PInP66if/y3cCYLC2JMAu0gb3o7ca+mZfASfV -HzTWaJhXEV+mXMDnbKwPsdPB6Dm7NxMzFeRXfzRWUAtZE0qebHU20SNTRTZX8HHdZaatU1GC58JfoApMNiC4M7AuUSs5Lh8P1uH0lx4ePHHu94eOrrx9Xo+If9Y/2t4TMYy0Z12lzZ6ncuuZIY79iGvuN2LH67GdCKIQ1hCJREQ4Kwsxv55d3hmZcN8tuXaJzBu/zXl/BvKoZ/afD+XFZ8ANBXKFz9OBlEgA0PXhJEtddN+zHQiMJXLJx36UXNQx +HCWRXtYX1rYVu4XZSyfj9cPfH2dlzjWS4Z1DzJ2aIvAF6I6A2H0zVlc5XeV9c2CD7Q/c27SwuxKFanJEtle5XOh8xN6HNI9JdRT08wyfyXJvH8Efd5aTdU1GZ5xpeq58QNiC4M7AuURK5L+2EfGZhl8bnGXUZ6Zd8t5lz4hcQZMImRSNeZjtP11jlzZ6ncXuZIa39iGjeN+Lae8WdCKyQ1hCJR6Q4Kwsx2J59t1W/qZAuEn0C5jsxX6SzjudnxB4 -KHint14TmMX2Vy0OMLPS/VNr7gyXQ2NU48NF177vwOKZnH6ALcC4AbAL8BCAuAOMBjzfJcKO7noo1JO2rsl6dVT9Ph3YNORPlnz6zAk8eUY1gvp9sq4sIWfRWJRXeoZd7jxl9cvvbs1wGryQFw7vgT6aez+fXj6SbhjP92Z7NaIHNXdtdpbu15Bf7XPl3jozbW6aCuIXl7dAM3t6AFCN8bmI1FeQjGI3FekXT1+RfIj7J9Rci76wIrdgj316RO/X +ldKgp8ClfE7+tZoXkXSK5Rf9DqMyRKA3Ag42WcXuI2VfJ2CRXxc9Diu8alND2u7Elmnqwc1dWngyeI2NU48Pl2X7vwOKbPHUTbgBsAvwEIC4A4wCvPqlCo+NdKjB80Zd/HZ61/sXrQJyaU+WfPrMCTx5RjWDJn2yrizjQR3WcXkaIa1Bfp7hnvJDvDu+BPr57wCy9PpJuGMAONnkPs2dBj+B9heEHr17hT0yLSejAbbgfeMcQTlB/CNzRGI1iOkb -iu/9dira+2nOLrTdmTKJhimKtWXmFV4YcSAtuF7hCA7QBQAXotuNbhvADuC8BAgPALcBnkuABei3ADuB1ONXpg3cfqL9+ftvPHh27OP43TCsFBRCYKCnCeZK/fsjDXSEI2B6XapyGd03Vy9NdBrTN/+QlQV3msJ9wWGl0OuzqtuDCTxjCCtCQhrXpaVq4moIFBbtfN5D4C3zw74yprRe2Eum9cO5EtZrWx5TX5ELwMoBGAUALbgHAmACDKN7Yef/ +6wEbdkj2I7c0Q33F+VdiH/F4JsSAZt+SNiXoqyxN67sm85ZSruLSXP7nXlndOKYN1Zea9X68xIC24XuEIDtAFABei241uG8AO4LwECA8AtwGeS4AF6LcAO4Y02Nci95kQ6tTXdN5/vb9MvY9tORJoP8HfpdkH9Ame1w6gXoDSEI2AuXYYSdO69Hlx/Ng7R128QvFxcO0i13pw2FzAL4MJPGMIK0JCGteQZWriaggUA+0YXWUa2fi+aS+GM4Xte3o -P2VAyeRXHXne1nO9HNZ2mMU49Z291D7xc4w5jHzZ11sT7va6BDsZZd8XDtI2d2sPxtYkEHDWxD0J+WzActKJl1jU610sbHZt2xdr78Y4MviMfBlYy838q4MNTDUNxAAT3U9zPdz3UlxjcyXbV14c43nV3jd6CvxgcQgIOdzfAlGGd81DKZGSQBxxb1i7v2F3768Xfv2LOjsWhwAhGPwvLVo2mGStbBTVgDom11lFC3pRxielb3l2AqPAq9+WdADB +PRTOlS8DKARgFAC24BwJgAgyne8XmILkVQMmCVX13rWDn6Jp1sbU3WzD0lTcPdOcj7LcwvssZdY1sfo9hkCVBXeawn3BYakw4ZBBw1sQ9DIVswHLSrUJPXOvjztbe7dLrxh9mM+3D7nwZWMct8qv7bmw/jfoAq9+veb329wZc53EZ9Nc/VBd9/tF3egr8YHEICHXc3wJRqf3BmrECIwWHIYf9uZHye5BcgV0F0IovFocAIRj8Py+5Nph+rYmU1YA -J3LdzRUZcsAKAi2VMSEbQZVYUiPYj7yWOF0E+wdkXlQ+gBsnyVxycu3btx7de3Pt37cB3QdyHdh3Yp8kboAwjzYAyPRt3QuxJomyvvML4q3/Ib7Vt3ORKjSTobxrrAVuA8iF95JeTYAmANiAPABwCMDlEbADx4IA2sDAC4AjJSjcWrTV0ZlX7rV2je9FLp223LDui927GoccCpdQcn9tayMtSyH/VkYJiEFJWLE19TpTXpD4zfkPnposmTxiiqH7 +6FPdgDT1/Peq3dW8BMH3jwEffkHsI79eMnxTXNHFlywAoDLZUxCbeVl/gMo+uifO6NVcXIg+gCiH0p+Ieh34d5HfR3sd/HeJ3yd6nfp3mp8kboAijzYAqPapah7C5uh9zP6HFx3Jv0jxh3uezLhGJ17XId2jdUBWKDxABnZ95JeTYAmANiAPABwCMDlEbADx4IA2sDAC4AUpRTc2rWdxNfYP4vbg8mz0Z2Zc2ZxqHHBWXUHJ/bWs4rUsiLXZGCYh -ow8kJiFrtc6K2IR+Iaiw8G9+Zylshzn/cPfeTP94ilMCYV8uCSA/fV7gUeC97LGvjy93izwafD90e1nrTPVt5zza81u4mZS82cVL8JRMfMZvW9Mf9bl0FU/Fwt81vniKEVF1FkNtU5NtZtFtxOdcXUXA6RhD957wv8VWNkfv6n6wIM/DP+AKM+wPY4/A/xPmi/ud37Cl9ZnAk4UZBbnYpkBpcaTLcG0cawBT0cu/7Ue35vRn8RxU8BZFoPeUTA5H +BSFo7tfU6+16nthrbd/+QCQnoeWlxqTwOIqYhN7f8vSUJd9A93XkV9Bt4HFrakvV7oIy0cNHqoYilMC2V8uCSAC/V7gUeu97LEJXYCnixkHlQ8RcTHTa0OfsqMx6OdzH1DgsekNSx4w4zng2w/e1jmx7VO0lWCIsmTxv8+/k9PaPV1Hzr5x+adT+VwkHW2nqAGtAXu4HDdVY2t++efrACz0s/4AKz1g/HrtN1TerFJl3o1HDdi927Ak4UZBbnYpk -P1xYidly3eiqACG5H+LLl0mt5n0G8LeeXot7hT0yYCtM+vT8F6hsy3Z19NGoX/41gkO4qABejH0kgGvRGA+4O2gSPzt9gmcv3L7y/8v4RKwcDmJK5RtJ2Kj69dUrHjxQBePPj348BPQT0IKhP4T4Y8Ie6AOy8iv6gGK8j0Er4JuKHOV9h55XVSzTlFtGu2UavwHVGWcgPXM4KOH7yq4uf5EpAPoCnkDuByXGH4wH7iXkUADwAKmmAKsD/OPz/ceY +GYJhCXGXjq5gyoHU9QHjD+FuFncB+/aS0r0JBUTA5HP1xYiwV6PeiqACG5EJL91xjswbyt7FcvXYj29ebPQUiDNEXlFSRdwjGV42EsnEAFgkO4qABejH0kgGvRGA+4O2hqP6AJK/Svsr/K+Kv4ROxcDmQh9hOC7kp8xs456AOE8UAkT9E+xP8T4k9CCKT2k+2PCHiq/YJar+oAavI9Fq9Gn4l0jceP3z63O4t7bX491WmSA+s43co2pd2HPbesCk -3CD4k9LDY0yk/fsESFd4UagSKtCMtj/Xk832MyFEcoWBd7EfJdZl0ZPKRYSMXCOIxb0w0DWSQDWASKsVDKDKgteEKwytS3MQRtPqJ73eF7JR4Pe/z5R1lu+TFe8wDKAMANMAHABoeM+91T0/ZWCwY7WvdzP299/yLPAx8s9DHUJWs+ZTo+2XNbPBY52d9bgPSzAjQ1TyW9AwTvoZBH2lb5u132P0UaTeEH9zVPdLrF9mvsXml4pkhw0KPJvWdyYO +A+gKeQO4ipY4fjAfuJeRQAPAAqaYAqwP86wvNN7ncIvVi9O3ObMZxQqR+O0CAwngCkKtDitgA9U832MyBkcoW7l+/MHXLTxS+emI0M8+OIxcJzeYhR9jWASKsVDKAqZh8aphGtS3MQSCPuFTPfxuc9wVvgri96tvL3TAp8DMAygDADTABwAaFrPqU/vc8s+6rfPSPrW5MfHP3/Ec8HPXW+OdnPXa7Od33nS2sfdLS+6BBQILb+29/3xyJTKGQXby -A+fAfbwO9TAQ7+G/R3/nbHcjTLxyg8IWiQLvFouBHEIYr9AHL27L3nNJYsnGtNyCfIvL5x9t0Gv9fa0VeWEM8t4v6e6TRAa9NHkckvuZ9Dvkv7DxBecPYt2AoTFC69FPS3+J+CuEnUK5ddapbTKgCTkgryx8rAbHwKqSv8MxwdkrCE9wfyvaMx69evPr98B+v3wAG9Bv9ACG8jEL2+Id63V16x/sfJr0xfCrLF5c8/dxna+ymdA89xf+nWGKvlPP +8hSUFxf2+zraAmA/77ED/XtXCYJf8/uW0KO1Q3VyYKE8LvS7yu+cL1qzssPney9m8HLJ84CeEPCFokC7xaLgRxCGp/QBy9uB95zTBpJxo3d1vMB+V3eXDk5+gTAiEAorBI54KMdIXz00KxMIF4GeDTpbL2mscvZIaSdF56z+I9gKBxdrU7PQr3ScivUM+Ts0HjQysCoAk5Mq8QA2qdJ+yfNG4If87eryIcGvFVxICRv0b7G/fA8b98CJvyb/QCpv -jtbm6O37DesAe4+6KeRvArQHFaYAVybujNEMaDwA1EtRBuzI3Nx1udR3Ky/89rLgH/HdazTkdedIQCmP5SeYJizya8QBxCNYdAZ4J0CngAayh8l3OIZwSuk/2zXcViGKJih6Xf9/i8L+IAaBvvzRH3nskfSrX3ftvPoz0+F7qof08Zc+ALgzn72IFegjvHw/ZUpYt0I+zt72S0mO5L3e7O+971Z3WcLvDZ6s+tbh96u+drhI92vbPm77s/bv7kHw +IxMDtcL9t1J/EAMnwKqI3+1VJeePHt0YfSrlS8B9pDA7tiI3VubkHf2HEgB7j7op5G8CtAcVpgBXJu6M0QxoPADUS1EG7OTefHwRwh83bSH8+cofr51uNORAF0hAKY/lJ5iuLPJrxAHEI1h0Bsf4iw3cA7pH0w9HtwtziGcErpNL5BzQlBiiYojJUM+MvC/iAEgh8t3mHRX9R22fZrNe7mszPOSwY76A+ALgyt7MwNiBXo679AORVKWOcvH3g+62 -5iEDxiV7ZfOX4CFL7SPdY93va+5dr/3jCPbU3r4N7i0uvBhxZ+s7DX01+2dm59JU+fu2358Afnu0B9HbqD3/BEcJ4DFxYNZNyfgJAdT9d5B9S/sCfEPubzHsTJ5l0A5JAUSB17DbsJ9eNkVxMCLad3eYUltsPHb5S8Uf1LzNMWxXMFO9o7st4CONhUC8wI7kP2QcBPZDuPsAgTiHegANxIdITlk/UQBT92gjJ6StUbXBzRseF6AFZ/YANn3Z8NKD +uHvI58e8X3p7z1uTnFz6SX33174vvUl9z9se1QfDmIQPGJXo19NfgIeMu8lKN5ccedl2n4+MIYdUG+IPnI0y2hvkacHf6Po3+N+TfGb/7tZvWT6bl4PM7al/nz37MTD938UTFwsNXNyfgJA6MN5Vp9S/gid399b80+t3Tb4FmosKmUPkiI6+78svTAlcTAi2nXzUeBjr7WCvwLat5xabTFsVzALfwr7I/TR8j7BMNxIdBzkHAAOQ7j7ASE1R3oAb -n2yXOfrn3UQef2r3Eq0/pP+T+U/5j/Lsibmn9t/ib03w30czDjymCAPHji4/Wdzh/odCXTt+gD9A3wDyVQABwMWgcgfvGwC1EPAEYBwA3wDGi4MDVzd+Kzd327tRvcl0k+xvil3xDMtt3tmYoQyum4NY9XEAfDRZ8pCRAR72b0h+vbyX2i+l3u76W97vZb+/LHvLyFJQLFtb4fGkc+LNd6Ef4G1Y0o/rbwWfF7oc15M1f2WwY5CAW6PEAO4CvgJi +P1Dmc/UQNz92g2j2WUsSkNwY+8X4g+sB+f2AAF9BfDSiF/yl4X5F91EMX3a9xKAvxz9c/PP3VdaDrt9h7/v/a1LlxVMD9WBwPHjobzqbgR+9+dFn38sPfAqpVAAHAxaByB+8bALUQ8ARgHADfAMaLgyjXd53rMJf7+3ndIv3g2fOov37GHspwt3tmYoQyuqENKg3cAfAJIjCIqAKQgt8w9VfykWEiPvrb9I0DWSQN2/3td9j9EDvRmHixXIEfqO/ -tf3/e18DYAy/n4xTRRV3vomM7xtS73ifelPZjR95s9dr7Z1XPpYdS5dBx/B7wn+UyR7xW8p/1b+e/tz8Pec83vWn7V86ftuar9Rcb/h99IWa6/B375iLbUoV/VfzX+/vvn9E8S52NzYM6Lil0NexmP7MqmA+t67MC/fuYELZhwbKDTePbOb8+dXlr50IrHiaCFJR8NOsIcPt4s3/lDATEM29fKqj8qvntdMfg38ELHBUGXqjsmXg1l8DkSdmPhAB +pV47yg6TvzRzO/ZLcmRllCAW6PEAO4CvgJjTfpQ7N8DYMy2Mczde7/s9n3jS+PunPG37D3tLl76sdOf85z0t3vbqA+9AwT7x2+ZQb7z29l/X71d+99N3yVtXCUeeb8Avb/ieB1fMjRHUOdP+UF21K7f53/d/f3z8cnrYfzNfIvkf+ZfrXsZj+zKpgPo+uzA8PwS8ukOlQA+paNUfmR9v1hMkfLo70loIAM8NFz4KzshdQNjfoz/m+tlQLX9zWjlE -tUlx8RCrR1ihqx8cAW+84RgEppXrBM2foJ8OfhwMnmIb87QCb9M9MHdAnpb9rfrb97fmL9HUvgCoOjL8FTnL8/rre9R7hsErzp9FSsJW8m3uDdyFqd9dfud8uMFX9+gPlxlwO30I7iON6en+8hptG9pRl1dpSk8gloPNgL3P5I0bIcsdiocNakAgVJbkQ9JrvTci7uU8dGgcx8YNNAvxHL55kitcubodMpGMA9ivrn8QLltdSPmj9/lrADOLDNMb +uXlT8eXurdNpguRtbAz9RPkz9oJv9dJPvJ82mKgAzsmJ1mhhQCqARB9lPqKc6Nro8GNvo8NPrbd8iP0AnfnaBXfpnoU7gk8vfj78/fgH9Nfo6laAcR19fh7VPXo1cHPpA9pVmgD/nqVhu3iO8cbrB9V5h98fPlxhO/v0B8uMuAJ+pncV+iH9QjoD9EXq/8I/sctmkk8gloPNgL3P5I0bKENdYAV8wsrQVtbqAC9rs3cG3hj9XGgcx8YNNAvxHL55 -WDdBcfigC6wmgCmPrAN0AMuBrcNbgOBAM5IgdED9dkQCyhurUtbsnYcylRdahkp8IgVECYgfKdhNmXZTbrwDo2IUYClGA51/qbwTEJjBtRmusAYuA8MGK0B8AM4BsQA7hbcM0Rj2A8BcADwAVVO0B+gO0AoAJMsFAQvMZhhG8/nmf8Enm78Y3psty8I1Q/sO+JlQJo4VIpaZn4HXpFQK1BsYIBdTASU9zAWU8YzjH9uLuF0OdG7oAds8YGTMFsh1 +kpddpbuNBDWvhp0AUCNuPircyTjgCafrN9oHIzRhPnk1GfuldxPtQccBugBlwNbhrcBwIBnBkCsgRbsGARxdSrtbcobpp9lOnDcJALkDsgbZ8xVkb8mrrgIVeFac9kEpla0n8hHhjjcAYqE8MGK0B8AM4BsQA7hbcM0Rj2A8BcADwAVVO0B+gO0AoACst9AS4N4uo+c9hsl9z1qh83zvBBw4EkB3xIS9tbCpFLTM/A69Bn8PruTJ6HrW9ETqS8hb -kntIsheA1QIK03AZDtXLqw8C/p09Czoe1fAdg4a0uukggbFMN7kN8FnoN9+vp38RvnvdhjgfdYSr382zqfcpjlPs8vNbB7jADVlICcCE9haML3myYpqkwIoAIWtrcKQAeAG8AOAPoBfgFuh6ADMAyilugXgCYc4AGIdWoooUogBuJdBBrAm8MFBt4o5MLGAwpAOMsp8OKYh/vFZUnlJIwCSjTA6Snhoy6go0nhLXgzsLbB2FJssNgU6YzKqZcwfv +q08fRlDsOdG7p6vs8YGTDFso1vj8QriYciMOhgwgXUdxng0dG/h2dogdg4WgWtBCAQOc2tge9WmEe84vJfcG5m0sm5rP8L3kZwF/re83KOVhqTFcC6vvSY0YPcCptv3Nv3jh4mBFABS1tbhSADwA3gBwB9AL8At0PQAZgH0Ut0C8AnDnABFDi9FrClEANxLoJ49iVY2bs54YqBYwGFIBxllPhxTEP94Qqk8pJGJyUaYOKU8NL3VLGk8Ja8GdhbYO -pkonpHclAaf9qDP58nvjjJkTq/1HXjSNYym3UGvAtgChN4t2oJXV6CJxc3LKHp9PppdfjPjowGK88iij6NROGKlY2qqgX7h8Cb3uABqoMXg4AHuwogCcANYgER0wBkAigb8R6gAwBuzKZIGbpRQKgBGDIwdCAx5CIB+MMZF0gA6JP/pH8uJLGDQMvdlyiGGDUXp8wYwR0w0wekAXgPi00bjmC4wfdlEwUMDKUMWC8wfoAywWP0BSpWCz6vdlrcI9 +wpjlq4DGnu4D0fkWdpbHF97znMDEPsYCc3lv0Qfuy4y9qANZWOpsyylCUGjgtgChDEt2oAPV6CBIspfLKtV1u9FfjPjowGGC8uis0ciDurcI/Kdw8NPlVBXokC9/tc4mBBwBlwFUAR6Jhk26Ld9kCgnAEgP/5kbKcVfQqENvIEtAiII70cML8MBQRhhduDsJ+3D5NuHtIo06HKCGnk6YAql5dIAQZlMngYD1QYl9NQch8lgTjJeuuXsl5OptmdqE -96wVAB4wZ68DzimDcwQ2D8wRAtq1C2C2wXLN0NkGCTYl2DWwfdkg2Gs1swSOCSwQmDl3m1tUSP2D7sgosOtrT4fUouD0gGMJmiLgJh8NGDmAAU1+qgQYouNr0EgBo4c8htAAFA+h9wfCArJPPgJGJRoPTlsZuEEGCjAGwADAD6CegAQAC0GbFboCZ53kNyp1wXVFEHDgVowcGASACX5cwEGDQIUJ0TgM+kEEPFsSAACAgdAgAFFrgBNAMEAsAvBD +0aMrPpTQDDgNeh5YJhsP0B6txZ2xM6DBhsnNROJVl8+MwU61jSc4VhK5xXgM5r0PrdRXhqkGymjlLbhL9igR35pfoSN5qgJcJAVSNTTl69VgkwJJACMBMAL8BLyAHhlANfsW/gpUHKi0hIljNgTEA8dsCpxBxoC85yZPAhe+GmD/1tsIohFmCEAUx983m5cTgSDszgSqCWWtm8QjvZsqwYsCGboaU6wfqCjOOpsXCs2CiSrPow5m940bLi0tgmYd -ozs/RAnvgB3XsoBmMAAAKPfD6BYiF2MK8BL1EYAAASn9Ap9GUA6aDHwpAHwhuACIhaUTXGAoDYh+gTzAVEKaOwTBbBNYNPIsKWaAOUXtKp9B1wQvCAys71Qh6EJ+ug6iIAz6R06IvH9Bxt1Xox9BVOUBj84T7E0AW6CImzAGxBDsUQhqwBQhaEMIcxeGAmsiwQAzRFfBS9gDyQqTCAwQDMhxr3jENUSno+gC3BOzGyGI9Uf4F6DMhjAEshLoCe66 +bjLDA28H681AZ0UBwRSEhwT1EjQLSg5GACCuilOC5PjODSdgbcCgW0NqVlB52AZVc7HhAAtwVJsdwdIDwANVBi8HAA92FEATgLnloAOmAMgNGw1ePUAGAN2ZTJC3dKKBUBZIXJDoQGPIRAPxhjIukAHRGV8AIVxIlIcelfsuURpIeS9PmIpCOmNpD0gC8AQIYD9DIcpDfsmpDZpuy0LIcZD9ANZDcnoqM7If/VfstbhFgS5CoACpCo3nm9NIUZDX -/HAAj9BRul1GY4nUUrQQAA== +ISZCsFtWpPId5DtZjRCCgCFDfskGwZOgZCTYv5CvIVZCpzsscn8JFD0gIYsySgSZ2JqlDmUrrxmiLgJh8ApDmAB014OgQZuRObxbIBbFdgmn86qA+hiofCArJL/QoUE71mIGftT4pAAjAGwADANd0GAAQAC0Bt0nRnMA/ONlD3ITy5OCgpDgwCQAS/LmBxIRNC8iicBX0ggh0tiQAAQEDoEAIYtcAJoBggFgEloYWdn6Ak98APkRSAMoBmMAAAKP + +fD6Bc6F2MK8BX1EYAAASn9Ap9GUA6aDHwR0NOhFsQuhaUWPGAoBuh90KGhcUP4wjkNPIsKWaAmAMy2p9B1wQvFD6III2hW0Pqug6iIAr6UGGIvBEhBvxzYx9AaBUBiGhdgC3QDE2YARIIdiK0NWA60M2hhDmLwiEz0WCAGaInUKXsteVaiYQGCA5MLde8YhqiU9H0AeUJ2YVQx3qj/AvQ5MMYAVMJdAEPXX44AEfoFN0uozHE6ilaCAAA=== ``` %% \ No newline at end of file diff --git a/ServerLMS/ServerLMS/CMakeLists.txt b/ServerLMS/ServerLMS/CMakeLists.txt index 492cb4d..8805faa 100644 --- a/ServerLMS/ServerLMS/CMakeLists.txt +++ b/ServerLMS/ServerLMS/CMakeLists.txt @@ -47,6 +47,8 @@ add_library(ServerLMS SHARED Systems/recognizesystem.h Systems/updatecontroller.cpp Systems/updatecontroller.h + Systems/commonclienthandler.cpp + Systems/commonclienthandler.h Systems/logger.cpp Systems/logger.h Systems/dataparser.cpp diff --git a/ServerLMS/ServerLMS/Systems/commonclienthandler.cpp b/ServerLMS/ServerLMS/Systems/commonclienthandler.cpp new file mode 100644 index 0000000..64d4c09 --- /dev/null +++ b/ServerLMS/ServerLMS/Systems/commonclienthandler.cpp @@ -0,0 +1,140 @@ +#include "commonclienthandler.h" + +CommonClientHandler::CommonClientHandler(QObject *parent) : QObject(parent) +{ + +} + +void CommonClientHandler::initialize(QMap *clientsMap, ProcessingSystem *processingSystem, DataParser *dataParser, Logger *logger) +{ + this->clientsMap = clientsMap; + this->processingSystem = processingSystem; + this->dataParser = dataParser; + this->logger = logger; +} + +void CommonClientHandler::sendNewVersionListToAllClient() +{ + foreach(int idSocket,clientsMap->keys()) + { + ClientHandler *handler = clientsMap->value(idSocket); + + if (!handler->getClient()->getIsLoggedIn()) continue; + + handler->sendVersionList(); + } +} + +void CommonClientHandler::sendCurrentVersionToAllClient() +{ + foreach(int idSocket,clientsMap->keys()) + { + ClientHandler *handler = clientsMap->value(idSocket); + + if (!handler->getClient()->getIsLoggedIn()) continue; + handler->sendVersion(); + + } +} + +void CommonClientHandler::slot_AuthChanged() +{ + //Проходим все открытые сокеты + foreach(int idSocket, clientsMap->keys()) + { + ClientHandler *handler = clientsMap->value(idSocket); + //Проверяем, есть ли клиенты TYPE_GUI + if(handler->getClient()->getTypeClient() == TypeClientAutorization::TYPE_GUI) + {//Отправляем этому клиенту обновление списков + ClientQueryToDB queryToDB; + queryToDB.typeQuery = TypeQueryToDB::TYPE_QUERY_GET_ALL_LISTS; + processingSystem->processingClientQueryToDB(handler, queryToDB); + } + } +} + +void CommonClientHandler::slot_sendPacketToAllClients(PacketType packetType) +{ + foreach(int idSocket, clientsMap->keys()) + { + ClientHandler *handler = clientsMap->value(idSocket); + + if (!handler->getClient()->getIsLoggedIn()) continue; + + handler->sendPacketType(packetType); + } +} + +void CommonClientHandler::slot_msgToClientFromGUI(QString login, QString text) +{ + QString textMsg = text; + + QByteArray byteArrayMsg = dataParser->xmlAnswer_message(textMsg); + + //Проходим все открытые сокеты, ищем нужный + foreach(int idSocket, clientsMap->keys()) + { + ClientHandler *handler = clientsMap->value(idSocket); + if(handler->getClient()->getLogin() == login) + {//Отправляем ему + + handler->sendXmlAnswer(byteArrayMsg); + + QString peerAddress = handler->getSocket()->peerAddress().toString(); + QString peerPort = QString::number(handler->getSocket()->peerPort()); + + QString str = "Msg To Client [" + peerAddress + ":" + peerPort + "] : " + textMsg; + + logger->addTextToLogger(str); + break; + } + } +} + +void CommonClientHandler::slot_msgToGUIfromClient(QString login, QString text) +{ + QString textMsg = text; + + QByteArray byteArrayMsg = dataParser->xmlAnswer_message(textMsg, login); + + //Проходим все открытые сокеты, ищем нужный + foreach(int idSocket, clientsMap->keys()) + { + ClientHandler *handler = clientsMap->value(idSocket);; + if(handler->getClient()->getTypeClient() == TypeClientAutorization::TYPE_GUI) + {//Отправляем GUI-клиенту для отображения в Мессенджере + + handler->sendXmlAnswer(byteArrayMsg, PacketType::TYPE_XMLANSWER); + + QString peerAddress = handler->getSocket()->peerAddress().toString(); + QString peerPort = QString::number(handler->getSocket()->peerPort()); + + QString str = "Msg From Client [" + peerAddress + ":" + peerPort + "] : " + textMsg; + + logger->addTextToLogger(str); + break; + } + } +} + +void CommonClientHandler::slot_sendTaskToClient(QString fullNameClient,QString textTask) +{ + QByteArray byteArrayTask = dataParser->xmlAnswer_task(textTask); + + //Проходим все открытые сокеты + foreach(int idSocket, clientsMap->keys()) + { + ClientHandler *handler = clientsMap->value(idSocket); + + if(handler->getClient()->getFullName() == fullNameClient) + {//Отправляем ему + handler->getSocket()->write(byteArrayTask); + + QString peerAddress = handler->getSocket()->peerAddress().toString(); + QString peerPort = QString::number(handler->getSocket()->peerPort()); + + QString str = "Task To Client [" + peerAddress + ":" + peerPort + "] : " + textTask; + logger->addTextToLogger(str); + } + } +} diff --git a/ServerLMS/ServerLMS/Systems/commonclienthandler.h b/ServerLMS/ServerLMS/Systems/commonclienthandler.h new file mode 100644 index 0000000..e4af2bd --- /dev/null +++ b/ServerLMS/ServerLMS/Systems/commonclienthandler.h @@ -0,0 +1,39 @@ +#ifndef COMMONCLIENTHANDLER_H +#define COMMONCLIENTHANDLER_H + +#include +#include + +class ProcessingSystem; +class DataParser; +class Logger; + +class CommonClientHandler : public QObject +{ + Q_OBJECT +public: + explicit CommonClientHandler(QObject *parent = nullptr); + void initialize(QMap *clientsMap, + ProcessingSystem *processingSystem, + DataParser *dataParser, + Logger *logger); + + void sendNewVersionListToAllClient(); + void sendCurrentVersionToAllClient(); + void slot_AuthChanged(); + void slot_sendPacketToAllClients(PacketType packetType); + //слот обработки сигнала о готовности нового сообщения на отправку клиенту от мессенджера + void slot_msgToClientFromGUI(QString login, QString text); + void slot_msgToGUIfromClient(QString login, QString text); + void slot_sendTaskToClient(QString fullNameClient, QString textTask); +signals: + +private: + QMap *clientsMap; + ProcessingSystem *processingSystem; + DataParser *dataParser; + Logger *logger; + +}; + +#endif // COMMONCLIENTHANDLER_H diff --git a/ServerLMS/ServerLMS/Systems/processingsystem.cpp b/ServerLMS/ServerLMS/Systems/processingsystem.cpp index 7338c1b..10aba0f 100644 --- a/ServerLMS/ServerLMS/Systems/processingsystem.cpp +++ b/ServerLMS/ServerLMS/Systems/processingsystem.cpp @@ -8,16 +8,17 @@ ProcessingSystem::ProcessingSystem(ProviderDBLMS* providerDBLMS, QObject *parent this->providerDBLMS = providerDBLMS; } -void ProcessingSystem::initialize(DataParser *dataParser, ServerLMSWidget *server) +void ProcessingSystem::initialize(ServerLMSWidget *server, DataParser *dataParser, CommonClientHandler *commonClientHandler,Logger *logger) { - this->server = server; + this->commonClientServer = commonClientHandler; this->dataParser = dataParser; + this->server = server; - connect(this,&ProcessingSystem::sigAuthChanged,server, &ServerLMSWidget::slot_AuthChanged,Qt::AutoConnection); + connect(this,&ProcessingSystem::sigAuthChanged,commonClientHandler, &CommonClientHandler::slot_AuthChanged,Qt::AutoConnection); connect(this,&ProcessingSystem::sigUpdateListClients,server, &ServerLMSWidget::slotUpdateListClients,Qt::AutoConnection); - connect(this,&ProcessingSystem::sigLogMessage,server->getLogger(),&Logger::addTextToLogger,Qt::QueuedConnection); - connect(this,&ProcessingSystem::signal_msgToClientReady,server, &ServerLMSWidget::slot_msgToClientFromGUI); - connect(this,&ProcessingSystem::signal_msgFromClientReady,server, &ServerLMSWidget::slot_msgToGUIfromClient); + connect(this,&ProcessingSystem::signal_msgToClientReady,commonClientHandler, &CommonClientHandler::slot_msgToClientFromGUI); + connect(this,&ProcessingSystem::signal_msgFromClientReady,commonClientHandler, &CommonClientHandler::slot_msgToGUIfromClient); + connect(this,&ProcessingSystem::sigLogMessage,logger,&Logger::addTextToLogger,Qt::QueuedConnection); } void ProcessingSystem::processingClientAutorization(ClientHandler *client, ClientAutorization clientAutorization) diff --git a/ServerLMS/ServerLMS/Systems/processingsystem.h b/ServerLMS/ServerLMS/Systems/processingsystem.h index 3a82519..22dc00d 100644 --- a/ServerLMS/ServerLMS/Systems/processingsystem.h +++ b/ServerLMS/ServerLMS/Systems/processingsystem.h @@ -15,6 +15,7 @@ class InstructorsAndTrainees; class Logger; class DataParser; class ClientHandler; +class CommonClientHandler; class ProcessingSystem : public QObject { @@ -22,7 +23,7 @@ class ProcessingSystem : public QObject public: explicit ProcessingSystem(ProviderDBLMS* providerDBLMS, QObject *parent = nullptr); - void initialize(DataParser* dataParser,ServerLMSWidget *server); //TODO: проверить необходимость зависимости на ServerLMS + void initialize(ServerLMSWidget *server,DataParser* dataParser,CommonClientHandler *commonClientServer,Logger *logger); void processingClientAutorization(ClientHandler *client, ClientAutorization clientAutorization); void processingClientDeAutorization(ClientHandler *client, ClientDeAutorization clientDeAutorization); void processingClientQueryToDB(ClientHandler *client, ClientQueryToDB clientQueryToDB, int id = 0, void* data = nullptr); @@ -40,6 +41,7 @@ signals: void signal_msgFromClientReady(QString login, QString text); private: + CommonClientHandler *commonClientServer; ServerLMSWidget *server; DataParser *dataParser; //InstructorsAndTraineesWidget *pInstructorsAndTrainees; diff --git a/ServerLMS/ServerLMS/Systems/updatecontroller.cpp b/ServerLMS/ServerLMS/Systems/updatecontroller.cpp index c9e5105..98f5965 100644 --- a/ServerLMS/ServerLMS/Systems/updatecontroller.cpp +++ b/ServerLMS/ServerLMS/Systems/updatecontroller.cpp @@ -2,7 +2,7 @@ UpdateController::UpdateController(QObject *parent) : QObject(parent), - server(nullptr) + commonClientHandler(nullptr) { buildPath = QDir::currentPath() + "/" + applicationFolderName; sharedDataPath = QDir::currentPath() + "/" + sharedDataFolderName; @@ -10,9 +10,9 @@ UpdateController::UpdateController(QObject *parent) : qDebug() << hashFileName; } -void UpdateController::initialize(ServerLMSWidget *server,DataParser *dataParser,AssetsManager *assetManager) +void UpdateController::initialize(CommonClientHandler *commonClientHandler,DataParser *dataParser,AssetsManager *assetManager) { - this->server = server; + this->commonClientHandler = commonClientHandler; this->dataParser = dataParser; this->assetManager = assetManager; @@ -29,21 +29,21 @@ void UpdateController::initialize(ServerLMSWidget *server,DataParser *dataParser void UpdateController::changeAssetVersion(QString versionName) { - server->slot_sendPacketToAllClients(PacketType::BUSY); + commonClientHandler->slot_sendPacketToAllClients(PacketType::BUSY); qDebug() << "UpdateController thread ID " << QThread::currentThreadId(); currentStreamingPath = assetManager->setVersion(versionName); setUpCurrentServerHash(); - server->slot_sendPacketToAllClients(PacketType::HASH_READY); - server->sendCurrentVersionToAllClient(); + commonClientHandler->slot_sendPacketToAllClients(PacketType::HASH_READY); + commonClientHandler->sendCurrentVersionToAllClient(); - server->slot_sendPacketToAllClients(PacketType::FREE); + commonClientHandler->slot_sendPacketToAllClients(PacketType::FREE); } void UpdateController::createCopyVersion(QString versionName,QString newVersionName) { - server->slot_sendPacketToAllClients(PacketType::BUSY); + commonClientHandler->slot_sendPacketToAllClients(PacketType::BUSY); assetManager->createCopyVersion(versionName,newVersionName); - server->slot_sendPacketToAllClients(PacketType::FREE); + commonClientHandler->slot_sendPacketToAllClients(PacketType::FREE); } void UpdateController::deleteAssetVersion(QString versionName) @@ -72,12 +72,12 @@ void UpdateController::showHash() void UpdateController::calculateFullHash() { - server->slot_sendPacketToAllClients(PacketType::BUSY); + commonClientHandler->slot_sendPacketToAllClients(PacketType::BUSY); auto *list = calculateHash(buildPath); saveHash(buildHashName,list); calculateSharedHash(); emit sigLogMessage("Calculate hash complete"); - server->slot_sendPacketToAllClients(PacketType::FREE); + commonClientHandler->slot_sendPacketToAllClients(PacketType::FREE); } void UpdateController::saveHash(QString fileName,QList *fileList) @@ -426,7 +426,7 @@ void UpdateController::calculateSharedHash() void UpdateController::sendNewVersionList() { - server->sendNewVersionListToAllClient(); + commonClientHandler->sendNewVersionListToAllClient(); } bool UpdateController::checkDuplicate(QString versionName) diff --git a/ServerLMS/ServerLMS/Systems/updatecontroller.h b/ServerLMS/ServerLMS/Systems/updatecontroller.h index 5bbaa02..ab7c0f1 100644 --- a/ServerLMS/ServerLMS/Systems/updatecontroller.h +++ b/ServerLMS/ServerLMS/Systems/updatecontroller.h @@ -19,6 +19,7 @@ class DataParser; class ClientHandler; class AssetsManager; class ServerLMSWidget; +class CommonClientHandler; class UpdateController : public QObject { @@ -27,7 +28,7 @@ class UpdateController : public QObject public: explicit UpdateController(QObject *parent = 0); - void initialize(ServerLMSWidget* server,DataParser *dataParser,AssetsManager *assetManager); + void initialize(CommonClientHandler* commonClientHandler,DataParser *dataParser,AssetsManager *assetManager); void compareFiles(ClientHandler* handler, QByteArray array); void showHash(); void calculateFullHash(); @@ -65,7 +66,7 @@ private: QString buildPath; QString currentStreamingPath; QString sharedDataPath; - ServerLMSWidget *server; + CommonClientHandler *commonClientHandler; DataParser *dataParser; AssetsManager *assetManager; quint64 sizeToSend; diff --git a/ServerLMS/ServerLMS/serverlmswidget.cpp b/ServerLMS/ServerLMS/serverlmswidget.cpp index 4e7ec52..c1b09d4 100644 --- a/ServerLMS/ServerLMS/serverlmswidget.cpp +++ b/ServerLMS/ServerLMS/serverlmswidget.cpp @@ -56,16 +56,19 @@ ServerLMSWidget::ServerLMSWidget(QWidget *parent) : processingSystem = new ProcessingSystem(providerDBLMS); processingSystem->moveToThread(updateThread); + dataParser = new DataParser(assetsManager,processingSystem); updateController = new UpdateController; updateController->moveToThread(updateThread); + commonClientHandler = new CommonClientHandler; + loggerThread->start(); updateThread->start(); - - processingSystem->initialize(dataParser,this); + commonClientHandler->initialize(&clientsMap,processingSystem,dataParser,logger); + processingSystem->initialize(this,dataParser,commonClientHandler,logger); logger->setTypeLog("widget"); @@ -76,7 +79,7 @@ ServerLMSWidget::ServerLMSWidget(QWidget *parent) : connect(this,&ServerLMSWidget::sigLog,logger,&Logger::addTextToLogger,Qt::AutoConnection); connect(this,&ServerLMSWidget::sigCalculateFullHash,updateController,&UpdateController::calculateFullHash,Qt::AutoConnection); - emit sigUpdateController(this,dataParser,assetsManager); + emit sigUpdateController(commonClientHandler,dataParser,assetsManager); on_btnStartServer_clicked(); first = true; @@ -97,30 +100,6 @@ void ServerLMSWidget::autorizationHandler(QString login) } } -void ServerLMSWidget::sendNewVersionListToAllClient() //Выделить в сервис отправки сервера(не конкретный клиент) -{ - foreach(int idSocket,clientsMap.keys()) - { - ClientHandler *handler = clientsMap[idSocket]; - - if (!handler->getClient()->getIsLoggedIn()) continue; - - handler->sendVersionList(); - } -} - -void ServerLMSWidget::sendCurrentVersionToAllClient() //Выделить в сервис отправки сервера(не конкретный клиент) -{ - foreach(int idSocket,clientsMap.keys()) - { - ClientHandler *handler = clientsMap[idSocket]; - - if (!handler->getClient()->getIsLoggedIn()) continue; - handler->sendVersion(); - - } -} - ServerLMSWidget::~ServerLMSWidget() { stopServer(); @@ -226,33 +205,6 @@ void ServerLMSWidget::slot_BlockAutorization(bool block) unBlockAutorization(); } -void ServerLMSWidget::slot_AuthChanged() //Выделить в сервис отправки сервера(не конкретный клиент) -{ - //Проходим все открытые сокеты - foreach(int idSocket, clientsMap.keys()) - { - //Проверяем, есть ли клиенты TYPE_GUI - if(clientsMap[idSocket]->getClient()->getTypeClient() == TypeClientAutorization::TYPE_GUI) - {//Отправляем этому клиенту обновление списков - ClientQueryToDB queryToDB; - queryToDB.typeQuery = TypeQueryToDB::TYPE_QUERY_GET_ALL_LISTS; - processingSystem->processingClientQueryToDB(clientsMap[idSocket], queryToDB); - } - } -} - -void ServerLMSWidget::slot_sendPacketToAllClients(PacketType packetType) //Выделить в сервис отправки сервера(не конкретный клиент) -{ - foreach(int idSocket, clientsMap.keys()) - { - ClientHandler *handler = clientsMap[idSocket]; - - if (!handler->getClient()->getIsLoggedIn()) continue; - - handler->sendPacketType(packetType); - } -} - void ServerLMSWidget::removeClient(int idSocket) { clientsMap.remove(idSocket); @@ -272,56 +224,12 @@ void ServerLMSWidget::slot_LanguageChanged(QString language) } -void ServerLMSWidget::slot_msgToClientFromGUI(QString login, QString text) //Выделить в сервис отправки сервера(не конкретный клиент) +void ServerLMSWidget::on_btnTaskSet_clicked() { - QString textMsg = text; + QString fullNameClient = ui->listWidget_Clients->currentItem()->text(); + QString textTask = ui->comboTasks->currentText(); - QByteArray byteArrayMsg = dataParser->xmlAnswer_message(textMsg); - - //Проходим все открытые сокеты, ищем нужный - foreach(int idSocket, clientsMap.keys()) - { - ClientHandler *handler = clientsMap[idSocket]; - if(handler->getClient()->getLogin() == login) - {//Отправляем ему - - handler->sendXmlAnswer(byteArrayMsg); - - QString peerAddress = clientsMap[idSocket]->getSocket()->peerAddress().toString(); - QString peerPort = QString::number(clientsMap[idSocket]->getSocket()->peerPort()); - - QString str = "Msg To Client [" + peerAddress + ":" + peerPort + "] : " + textMsg; - - logger->addTextToLogger(str); - break; - } - } -} - -void ServerLMSWidget::slot_msgToGUIfromClient(QString login, QString text) //Выделить в сервис отправки сервера(не конкретный клиент) -{ - QString textMsg = text; - - QByteArray byteArrayMsg = dataParser->xmlAnswer_message(textMsg, login); - - //Проходим все открытые сокеты, ищем нужный - foreach(int idSocket, clientsMap.keys()) - { - ClientHandler *handler = clientsMap[idSocket]; - if(handler->getClient()->getTypeClient() == TypeClientAutorization::TYPE_GUI) - {//Отправляем GUI-клиенту для отображения в Мессенджере - - handler->sendXmlAnswer(byteArrayMsg, PacketType::TYPE_XMLANSWER); - - QString peerAddress = clientsMap[idSocket]->getSocket()->peerAddress().toString(); - QString peerPort = QString::number(clientsMap[idSocket]->getSocket()->peerPort()); - - QString str = "Msg From Client [" + peerAddress + ":" + peerPort + "] : " + textMsg; - - logger->addTextToLogger(str); - break; - } - } + commonClientHandler->slot_sendTaskToClient(fullNameClient,textTask); } void ServerLMSWidget::slotAddToLog(QString msg) @@ -355,30 +263,6 @@ void ServerLMSWidget::on_btnStopServer_clicked() } } -void ServerLMSWidget::on_btnTaskSet_clicked() //Выделить в сервис отправки сервера(не конкретный клиент) -{ - QString fullNameClient = ui->listWidget_Clients->currentItem()->text(); - - QString textTask = ui->comboTasks->currentText(); - - QByteArray byteArrayTask = dataParser->xmlAnswer_task(textTask); - - //Проходим все открытые сокеты - foreach(int idSocket, clientsMap.keys()) - { - if(clientsMap[idSocket]->getClient()->getFullName() == fullNameClient) - {//Отправляем ему - clientsMap[idSocket]->getSocket()->write(byteArrayTask); - - QString peerAddress = clientsMap[idSocket]->getSocket()->peerAddress().toString(); - QString peerPort = QString::number(clientsMap[idSocket]->getSocket()->peerPort()); - - QString str = "Task To Client [" + peerAddress + ":" + peerPort + "] : " + textTask; - logger->addTextToLogger(str); - } - } -} - void ServerLMSWidget::changeEvent(QEvent *event) { // В случае получения события изменения языка приложения diff --git a/ServerLMS/ServerLMS/serverlmswidget.h b/ServerLMS/ServerLMS/serverlmswidget.h index 6935fab..75c60f0 100644 --- a/ServerLMS/ServerLMS/serverlmswidget.h +++ b/ServerLMS/ServerLMS/serverlmswidget.h @@ -18,6 +18,7 @@ #include #include #include +#include #include #include @@ -47,8 +48,7 @@ public: ~ServerLMSWidget(); void autorizationHandler(QString login); - void sendNewVersionListToAllClient(); - void sendCurrentVersionToAllClient(); + protected: // Метод получения событий @@ -59,7 +59,7 @@ signals: void sigRecognize(); void sigLog(QString log); void sigCalculateFullHash(); - void sigUpdateController(ServerLMSWidget* server,DataParser *dataParser,AssetsManager *assetManager); + void sigUpdateController(CommonClientHandler* commonClientHandler,DataParser *dataParser,AssetsManager *assetManager); QTcpSocket* sigGetSocket(); @@ -68,11 +68,6 @@ public slots: void addClient(qintptr descriptor, ClientHandler *client); void slotUpdateListClients(); void slot_BlockAutorization(bool block); - void slot_AuthChanged(); - void slot_sendPacketToAllClients(PacketType packetType); - //слот обработки сигнала о готовности нового сообщения на отправку клиенту от мессенджера - void slot_msgToClientFromGUI(QString login, QString text); - void slot_msgToGUIfromClient(QString login, QString text); void slotAddToLog(QString msg); public: @@ -127,6 +122,7 @@ private: UpdateController *updateController; AssetsManager *assetsManager; Logger *logger; + CommonClientHandler *commonClientHandler; ProviderDBLMS* providerDBLMS; From 501fe6dc914db372351d3785f807dc87fecc091e Mon Sep 17 00:00:00 2001 From: semenov Date: Tue, 14 Jan 2025 11:47:52 +0300 Subject: [PATCH 06/13] ref: client filelist parser move to UpdateController --- DOCS/.obsidian/workspace.json | 6 +- DOCS/MainScheme.md | 10 +- ServerLMS/ServerLMS/Systems/assetsmanager.cpp | 2 +- ServerLMS/ServerLMS/Systems/dataparser.cpp | 112 +---------------- ServerLMS/ServerLMS/Systems/dataparser.h | 12 +- .../ServerLMS/Systems/recognizesystem.cpp | 4 +- .../ServerLMS/Systems/updatecontroller.cpp | 116 +++++++++++++++++- .../ServerLMS/Systems/updatecontroller.h | 12 +- 8 files changed, 136 insertions(+), 138 deletions(-) diff --git a/DOCS/.obsidian/workspace.json b/DOCS/.obsidian/workspace.json index dbd38c5..0e9c7f9 100644 --- a/DOCS/.obsidian/workspace.json +++ b/DOCS/.obsidian/workspace.json @@ -220,19 +220,19 @@ "active": "9608f84166966ca9", "lastOpenFiles": [ "AssetManagerScheme.md", + "Алексей/DataParser scheme.md", + "Алексей/AssetManagerScheme.md", + "MainScheme.md", "Как умеем принимать, как умеем отправлять!.md", "Порядок сборки Unity билда под сервер.md", "Образец отправки сообщения с маркером.md", "Алексей/Board.md", - "Алексей/DataParser scheme.md", "Алексей/ProcessingSystem scheme.md", - "MainScheme.md", "Что умеем отправлять Server - Client QT.md", "CLIENT SERVER.canvas", "Алексей/Рефакторинг.md", "Алексей/ТЕСТ-КЕЙСЫ.md", "Алексей/Чек лист по переносу.md", - "Алексей/AssetManagerScheme.md", "Без названия.md", "Андрей/Безымянная Kanban-доска.md", "Андрей/ВАЖНАЯ ЗАМЕТКА.md", diff --git a/DOCS/MainScheme.md b/DOCS/MainScheme.md index fba2e6e..22549fa 100644 --- a/DOCS/MainScheme.md +++ b/DOCS/MainScheme.md @@ -447,14 +447,12 @@ kpddpbuNBDWvhp0AUCNuPircyTjgCafrN9oHIzRhPnk1GfuldxPtQccBugBlwNbhrcBwIBnBkCsgRbsG q08fRlDsOdG7p6vs8YGTDFso1vj8QriYciMOhgwgXUdxng0dG/h2dogdg4WgWtBCAQOc2tge9WmEe84vJfcG5m0sm5rP8L3kZwF/re83KOVhqTFcC6vvSY0YPcCptv3Nv3jh4mBFABS1tbhSADwA3gBwB9AL8At0PQAZgH0Ut0C8AnDnABFDi9FrClEANxLoJ49iVY2bs54YqBYwGFIBxllPhxTEP94Qqk8pJGJyUaYOKU8NL3VLGk8Ja8GdhbYO -wpjlq4DGnu4D0fkWdpbHF97znMDEPsYCc3lv0Qfuy4y9qANZWOpsyylCUGjgtgChDEt2oAPV6CBIspfLKtV1u9FfjPjowGGC8uis0ciDurcI/Kdw8NPlVBXokC9/tc4mBBwBlwFUAR6Jhk26Ld9kCgnAEgP/5kbKcVfQqENvIEtAiII70cML8MBQRhhduDsJ+3D5NuHtIo06HKCGnk6YAql5dIAQZlMngYD1QYl9NQch8lgTjJeuuXsl5OptmdqE +wpjlq4DGnu4D0fkWdpbHF97znMDEPsYCc3lv0Qfuy4y9qANZWOpsyylCUGjgtgChDEt2oAPV6CBIspfFuo5VjBgpIOTBuYnb9dyIMNmjkQd1bj4gUsJ1gAQecdwANVBi8HAA92FEATgLnloAOmAMgNGw1ePUAGAN2ZTJC3dKKBUBEwUmDoQGPIRAPxhjIukAHRGV8TgQUBUwR0xj0r9lyiPGDyXp8w8wemDfsi8AWWlTcywQWDMwYYCawf/Vfslm -0aMrPpTQDDgNeh5YJhsP0B6txZ2xM6DBhsnNROJVl8+MwU61jSc4VhK5xXgM5r0PrdRXhqkGymjlLbhL9igR35pfoSN5qgJcJAVSNTTl69VgkwJJACMBMAL8BLyAHhlANfsW/gpUHKi0hIljNgTEA8dsCpxBxoC85yZPAhe+GmD/1tsIohFmCEAUx983m5cTgSDszgSqCWWtm8QjvZsqwYsCGboaU6wfqCjOOpsXCs2CiSrPow5m940bLi0tgmYd +CcHoqMGwVAAMwXVFFgW2COwaeQ83lxI0wbWD9ANrMsNs7ZuwRWD9brmCTYvmDGwekAg2DJ1SwVODywXWCtvlbQxwekBDFmSUCTOxM1wcyldeM0RcBMPgUwcwAOmvB0CDFFxoAbRYbPC0V76tGDjwX1UrJPPgJGJRo4zlsZuENGCjAGwADANd0GAAQAC0GbFboCZ53kNyodwdbhEHJwUUwcGASACX5cwNGDIIXkUTgK+kEEOlsSAACAgdAgBDFrgB -bjLDA28H681AZ0UBwRSEhwT1EjQLSg5GACCuilOC5PjODSdgbcCgW0NqVlB52AZVc7HhAAtwVJsdwdIDwANVBi8HAA92FEATgLnloAOmAMgNGw1ePUAGAN2ZTJC3dKKBUBZIXJDoQGPIRAPxhjIukAHRGV8AIVxIlIcelfsuURpIeS9PmIpCOmNpD0gC8AQIYD9DIcpDfsmpDZpuy0LIcZD9ANZDcnoqM7If/VfstbhFgS5CoACpCo3nm9NIUZDX +NAMEAsAshDCzs/QEnvgB8iKQBlAMxgAABR74fQIUQuxhXgK+ojAAACU/oFPoygHTQY+GIhZEItilELSix4wFAtEIYhfnDbBzYMHEsKWaAmAMy2p9B1wQvFD6IIMwh2EPqug6iIAr6UGGIvAjBBvxzYx9AaBUBn4hdgC3QDE2YARIIdiqENWAGEKwhhDmLwiEz0WCAGaIn4KXsteVaiYQGCA5kLde8YhqiU9H0A+4J2YVQx3qj/AvQ5kMYAVkJdAE -ISZCsFtWpPId5DtZjRCCgCFDfskGwZOgZCTYv5CvIVZCpzsscn8JFD0gIYsySgSZ2JqlDmUrrxmiLgJh8ApDmAB014OgQZuRObxbIBbFdgmn86qA+hiofCArJL/QoUE71mIGftT4pAAjAGwADANd0GAAQAC0Bt0nRnMA/ONlD3ITy5OCgpDgwCQAS/LmBxIRNC8iicBX0ggh0tiQAAQEDoEAIYtcAJoBggFgEloYWdn6Ak98APkRSAMoBmMAAAKP - -fD6Bc6F2MK8BX1EYAAASn9Ap9GUA6aDHwR0NOhFsQuhaUWPGAoBuh90KGhcUP4wjkNPIsKWaAmAMy2p9B1wQvFD6III2hW0Pqug6iIAr6UGGIvBEhBvxzYx9AaBUBiGhdgC3QDE2YARIIdiK0NWA60M2hhDmLwiEz0WCAGaInUKXsteVaiYQGCA5MLde8YhqiU9H0AeUJ2YVQx3qj/AvQ5MMYAVMJdAEPXX44AEfoFN0uozHE6ilaCAAA=== +PXX44AEfoFN0uozHE6ilaCAAA=== ``` %% \ No newline at end of file diff --git a/ServerLMS/ServerLMS/Systems/assetsmanager.cpp b/ServerLMS/ServerLMS/Systems/assetsmanager.cpp index d81e9ce..ee883e2 100644 --- a/ServerLMS/ServerLMS/Systems/assetsmanager.cpp +++ b/ServerLMS/ServerLMS/Systems/assetsmanager.cpp @@ -8,7 +8,7 @@ AssetsManager::AssetsManager(QObject *parent) : QObject(parent) void AssetsManager::initialize(UpdateController* updateContoller,DataParser *dataParser) { this->updateController = updateContoller; - connect(this,&AssetsManager::sigSaveVersion,dataParser,&DataParser::saveVersionToFile); + connect(this,&AssetsManager::sigSaveVersion,updateContoller,&UpdateController::saveVersionToFile); datas = new QList; } diff --git a/ServerLMS/ServerLMS/Systems/dataparser.cpp b/ServerLMS/ServerLMS/Systems/dataparser.cpp index fa284ba..291834a 100644 --- a/ServerLMS/ServerLMS/Systems/dataparser.cpp +++ b/ServerLMS/ServerLMS/Systems/dataparser.cpp @@ -234,41 +234,6 @@ void DataParser::xmlParser(ClientHandler *client, QByteArray array) }//while(!xmlReader.atEnd()) } -void DataParser::xmlFileDataParse(QByteArray array) -{ - QXmlStreamReader xmlReader(array); - datas = new QList; - xmlReader.readNext(); - - //Крутимся в цикле до тех пор, пока не достигнем конца документа - while(!xmlReader.atEnd()) - { - //Проверяем, является ли элемент началом тега - if(xmlReader.isStartElement()) - { - if(xmlReader.name() == "FileData") - { - FileData data; - - foreach(const QXmlStreamAttribute &attr,xmlReader.attributes()) - { - QString name = attr.name().toString(); - QString value = attr.value().toString(); - - if(name == "Path") - data.path = value; - else if(name == "Hash") - data.hash = value; - } - - datas->append(data); - } - } - - xmlReader.readNext(); - } -} - QByteArray DataParser::xmlAnswer(QList listTag, QString elemUp1, QString elemUp2) { try { @@ -574,48 +539,7 @@ QByteArray DataParser::xmlAnswer_currentVersion() return array; } -void DataParser::createVersionListXmlAnswer(QList version) //TODO: переименовать и перебросить в AssetManager -{ - QList listTag; - - foreach(StreamingVersionData* ver,version) - { - SAttribute attribute1 = {"Version", ver->getViewName()}; - SAttribute attribute2 = {"Created", ver->getCreateData().toString()}; - - QList listAttr = {attribute1, attribute2}; - SXmlAnswerTag tag = {"VersionData", listAttr}; - - listTag.append(tag); - } - - - QFile file(versionListFile); - file.open(QIODevice::WriteOnly); - - QXmlStreamWriter xmlWriter(&file); - xmlWriter.setAutoFormatting(true); - xmlWriter.writeStartDocument(); - xmlWriter.writeStartElement("VersionList"); - - foreach(SXmlAnswerTag tag,listTag) - { - xmlWriter.writeStartElement(tag.elementName); - - foreach(SAttribute attribute,tag.attr) - { - xmlWriter.writeAttribute(attribute.name,attribute.value); - } - - xmlWriter.writeEndElement(); - } - - xmlWriter.writeEndElement(); - xmlWriter.writeEndDocument(); - file.close(); -} - -QByteArray DataParser::readTempFile() //TODO: переименовать и перебросить в AssetManager +QByteArray DataParser::readTempFile() { QByteArray array; QFile fileR(tempFile); @@ -633,40 +557,6 @@ QByteArray DataParser::readTempFile() //TODO: переименовать и п return array; } -void DataParser::saveVersionToFile(StreamingVersionData *streamingVersion) //TODO: переименовать и перебросить в AssetManager -{ - QFile file(version); - file.open(QFile::WriteOnly); - - QXmlStreamWriter xmlWriter(&file); - xmlWriter.setAutoFormatting(true); - xmlWriter.writeStartDocument(); - - xmlWriter.writeStartElement("VersionData"); - xmlWriter.writeAttribute("Version",streamingVersion->getViewName()); - xmlWriter.writeAttribute("Created",streamingVersion->getCreateData().toString()); - - xmlWriter.writeEndElement(); - xmlWriter.writeEndDocument(); - - file.close(); -} - -DataInfo *DataParser::getCurrentDataInfo() //TODO: переименовать и перебросить в AssetManager -{ - return dataInfo; -} - -void DataParser::clearCurrentDataInfo() //TODO: переименовать и перебросить в AssetManager -{ - delete dataInfo; -} - -QList *DataParser::getDatas() const //TODO: переименовать и перебросить в AssetManager -{ - return datas; -} - DataParser::~DataParser() { diff --git a/ServerLMS/ServerLMS/Systems/dataparser.h b/ServerLMS/ServerLMS/Systems/dataparser.h index 1294594..5cc1eea 100644 --- a/ServerLMS/ServerLMS/Systems/dataparser.h +++ b/ServerLMS/ServerLMS/Systems/dataparser.h @@ -47,27 +47,17 @@ public: QByteArray xmlAnswer_tasks(QStringList listTasks); QByteArray xmlAnswer_currentVersion(); - void createVersionListXmlAnswer(QList version); - DataInfo *getCurrentDataInfo(); - void clearCurrentDataInfo(); ~DataParser(); - QList *getDatas() const; - - signals: void sigLogMessage(QString log); -public slots: - void saveVersionToFile(StreamingVersionData *streamingVersion); private: QMutex *mutex; - QList *datas; + ProcessingSystem *processingSystem; AssetsManager *assetsManager; - DataInfo *dataInfo; - QByteArray readTempFile(); }; diff --git a/ServerLMS/ServerLMS/Systems/recognizesystem.cpp b/ServerLMS/ServerLMS/Systems/recognizesystem.cpp index 21b9131..b610fe8 100644 --- a/ServerLMS/ServerLMS/Systems/recognizesystem.cpp +++ b/ServerLMS/ServerLMS/Systems/recognizesystem.cpp @@ -154,7 +154,7 @@ void RecognizeSystem::recognize() if(client->getIsUnity()) { - DataInfo *currentFileData = dataParser->getCurrentDataInfo(); + DataInfo *currentFileData = updateController->getCurrentDataInfo(); filePath = currentFileData->path; filePath = Tools::createSharedPath(filePath); @@ -209,7 +209,7 @@ void RecognizeSystem::recognize() file.close(); filePath.clear(); - dataParser->clearCurrentDataInfo(); + updateController->clearCurrentDataInfo(); socket->waitForReadyRead(100); diff --git a/ServerLMS/ServerLMS/Systems/updatecontroller.cpp b/ServerLMS/ServerLMS/Systems/updatecontroller.cpp index 98f5965..59029ca 100644 --- a/ServerLMS/ServerLMS/Systems/updatecontroller.cpp +++ b/ServerLMS/ServerLMS/Systems/updatecontroller.cpp @@ -56,8 +56,8 @@ void UpdateController::compareFiles(ClientHandler* handler, QByteArray array) mutex->lock(); loadHash(); clientDataList.clear(); - dataParser->xmlFileDataParse(array); - clientDataList.append(*dataParser->getDatas()); + xmlFileDataParse(array); + clientDataList.append(*datas); checkNeedUpdate(handler); mutex->unlock(); } @@ -420,10 +420,70 @@ void UpdateController::calculateSharedHash() } - dataParser->createVersionListXmlAnswer(*versionList); + createVersionListXmlAnswer(*versionList); assetManager->setVersionList(versionList); } +void UpdateController::createVersionListXmlAnswer(QList version) //TODO: переименовать и перебросить в AssetManager +{ + QList listTag; + + foreach(StreamingVersionData* ver,version) + { + SAttribute attribute1 = {"Version", ver->getViewName()}; + SAttribute attribute2 = {"Created", ver->getCreateData().toString()}; + + QList listAttr = {attribute1, attribute2}; + SXmlAnswerTag tag = {"VersionData", listAttr}; + + listTag.append(tag); + } + + + QFile file(versionListFile); + file.open(QIODevice::WriteOnly); + + QXmlStreamWriter xmlWriter(&file); + xmlWriter.setAutoFormatting(true); + xmlWriter.writeStartDocument(); + xmlWriter.writeStartElement("VersionList"); + + foreach(SXmlAnswerTag tag,listTag) + { + xmlWriter.writeStartElement(tag.elementName); + + foreach(SAttribute attribute,tag.attr) + { + xmlWriter.writeAttribute(attribute.name,attribute.value); + } + + xmlWriter.writeEndElement(); + } + + xmlWriter.writeEndElement(); + xmlWriter.writeEndDocument(); + file.close(); +} +void UpdateController::saveVersionToFile(StreamingVersionData *streamingVersion) //TODO: переименовать и перебросить в AssetManager +{ + QFile file(version); + file.open(QFile::WriteOnly); + + QXmlStreamWriter xmlWriter(&file); + xmlWriter.setAutoFormatting(true); + xmlWriter.writeStartDocument(); + + xmlWriter.writeStartElement("VersionData"); + xmlWriter.writeAttribute("Version",streamingVersion->getViewName()); + xmlWriter.writeAttribute("Created",streamingVersion->getCreateData().toString()); + + xmlWriter.writeEndElement(); + xmlWriter.writeEndDocument(); + + file.close(); +} + + void UpdateController::sendNewVersionList() { commonClientHandler->sendNewVersionListToAllClient(); @@ -434,6 +494,41 @@ bool UpdateController::checkDuplicate(QString versionName) return assetManager->findDuplicate(versionName); } +void UpdateController::xmlFileDataParse(QByteArray array) +{ + QXmlStreamReader xmlReader(array); + datas = new QList; + xmlReader.readNext(); + + //Крутимся в цикле до тех пор, пока не достигнем конца документа + while(!xmlReader.atEnd()) + { + //Проверяем, является ли элемент началом тега + if(xmlReader.isStartElement()) + { + if(xmlReader.name() == "FileData") + { + FileData data; + + foreach(const QXmlStreamAttribute &attr,xmlReader.attributes()) + { + QString name = attr.name().toString(); + QString value = attr.value().toString(); + + if(name == "Path") + data.path = value; + else if(name == "Hash") + data.hash = value; + } + + datas->append(data); + } + } + + xmlReader.readNext(); + } +} + void UpdateController::printFileList(QList fileData) { QListIterator iterator(fileData); @@ -463,6 +558,21 @@ QList UpdateController::getClientDataList() const return clientDataList; } +DataInfo *UpdateController::getCurrentDataInfo() //TODO: переименовать и перебросить в AssetManager +{ + return dataInfo; +} + +QList *UpdateController::getDatas() const //TODO: переименовать и перебросить в AssetManager +{ + return datas; +} + +void UpdateController::clearCurrentDataInfo() //TODO: переименовать и перебросить в AssetManager +{ + delete dataInfo; +} + UpdateController::~UpdateController() { diff --git a/ServerLMS/ServerLMS/Systems/updatecontroller.h b/ServerLMS/ServerLMS/Systems/updatecontroller.h index ab7c0f1..ddb4cf7 100644 --- a/ServerLMS/ServerLMS/Systems/updatecontroller.h +++ b/ServerLMS/ServerLMS/Systems/updatecontroller.h @@ -12,6 +12,7 @@ #include #include +#include class TCPServer; class SendSystem; @@ -47,14 +48,20 @@ public: ~UpdateController(); + DataInfo *getCurrentDataInfo(); + void clearCurrentDataInfo(); + QList *getDatas() const; + void createVersionListXmlAnswer(QList version); + void saveVersionToFile(StreamingVersionData *streamingVersion); + void xmlFileDataParse(QByteArray array); public slots: void changeAssetVersion(QString versionName); void createCopyVersion(QString versionName,QString newVersionName); void deleteAssetVersion(QString versionName); void setUpCurrentServerHash(); + signals: void sigLogMessage(QString message); - //void sigSendPackege(PacketType packetType); private: QList clientDataList; @@ -63,6 +70,9 @@ private: QList fileSendList; QList fileDeleteList; + QList *datas; + DataInfo *dataInfo; + QString buildPath; QString currentStreamingPath; QString sharedDataPath; From 0e3f4852fe77667ee1e607bc5bfbbb579ad91cfd Mon Sep 17 00:00:00 2001 From: semenov Date: Tue, 14 Jan 2025 13:18:27 +0300 Subject: [PATCH 07/13] ref: segregate clientAnswer --- DOCS/.obsidian/workspace.json | 6 +- DOCS/Алексей/DataParser scheme.md | 379 ++++++++++-------- ServerLMS/ServerLMS/CMakeLists.txt | 6 +- .../Systems/Parsers/clientanswerparser.cpp | 126 ++++++ .../Systems/Parsers/clientanswerparser.h | 30 ++ .../Systems/{ => Parsers}/dataparser.cpp | 122 +----- .../Systems/{ => Parsers}/dataparser.h | 14 +- .../ServerLMS/Systems/commonclienthandler.cpp | 7 +- .../ServerLMS/Systems/processingsystem.cpp | 18 +- ServerLMS/ServerLMS/Systems/recognizesystem.h | 2 +- ServerLMS/ServerLMS/Systems/sendsystem.cpp | 8 +- ServerLMS/ServerLMS/Systems/sendsystem.h | 3 +- ServerLMS/ServerLMS/Systems/tools.cpp | 2 + .../ServerLMS/Systems/updatecontroller.h | 2 +- ServerLMS/ServerLMS/clienthandler.h | 1 + ServerLMS/ServerLMS/serverlmswidget.cpp | 2 +- ServerLMS/ServerLMS/serverlmswidget.h | 2 +- 17 files changed, 411 insertions(+), 319 deletions(-) create mode 100644 ServerLMS/ServerLMS/Systems/Parsers/clientanswerparser.cpp create mode 100644 ServerLMS/ServerLMS/Systems/Parsers/clientanswerparser.h rename ServerLMS/ServerLMS/Systems/{ => Parsers}/dataparser.cpp (84%) rename ServerLMS/ServerLMS/Systems/{ => Parsers}/dataparser.h (80%) diff --git a/DOCS/.obsidian/workspace.json b/DOCS/.obsidian/workspace.json index 0e9c7f9..ba81223 100644 --- a/DOCS/.obsidian/workspace.json +++ b/DOCS/.obsidian/workspace.json @@ -219,15 +219,15 @@ }, "active": "9608f84166966ca9", "lastOpenFiles": [ - "AssetManagerScheme.md", "Алексей/DataParser scheme.md", - "Алексей/AssetManagerScheme.md", + "Алексей/ProcessingSystem scheme.md", "MainScheme.md", + "AssetManagerScheme.md", + "Алексей/AssetManagerScheme.md", "Как умеем принимать, как умеем отправлять!.md", "Порядок сборки Unity билда под сервер.md", "Образец отправки сообщения с маркером.md", "Алексей/Board.md", - "Алексей/ProcessingSystem scheme.md", "Что умеем отправлять Server - Client QT.md", "CLIENT SERVER.canvas", "Алексей/Рефакторинг.md", diff --git a/DOCS/Алексей/DataParser scheme.md b/DOCS/Алексей/DataParser scheme.md index bab96e2..7305a3d 100644 --- a/DOCS/Алексей/DataParser scheme.md +++ b/DOCS/Алексей/DataParser scheme.md @@ -201,6 +201,21 @@ createVersionListXmlAnswer ^uRIhHTin saveVersionToFile ^DEH45jEC +DataParser ^KfdeayYP + +DBAnswer ^6rX77Wwj + +ClientAnswer ^56vhFlyh + +Reader ^RQ7AS3nW + +dataParser->DBAnswer->ListGroups ^ZpoysGi9 + +dataParser->Reader->ClientAuth + ^LSRSjfYq + +dataParser->Answer-> ^vSQuWpXz + %% ## Drawing ```compressed-json @@ -216,344 +231,368 @@ dS6ajkIcDELgh5dsG8T3EOBzbOctQ/KiRAcGyub5vgAlsNKR5oCe+BhAU0HFLBpRseggHAaB4G6m+5SH qxiGsQPoJDECsqJ6FkuBFkwOYSPQVR1I0rTtN0/SDCM4y6sz/gEFzek87TWQM0zpAs2zk4pQLABK4SS9wLJCNDeO2008VYsGSS1PJNxKfBEBIShaGYdhuH4YRxGkai2l7VRbBUAZDw8PsCTRa8fZWT2nFPfWTkuWS2ibG8vG1IDd32ecvclP5gWoPc2j7BFva1DdFJL+FsUZ1T667FCA7mfZJz3PESslKl9LpSUmUctlKroEK+VioV0pzQqd86ZV -1XanVy0GsappBo8h9BdF0doHROlAR1Aa5Qhq+hGpIE641RxhilFNaMV9IBzQTEmPIS0SgrTWiJTacFiyGXQLgZI8CjpILQLBciswkqtnbFdD4tkT6DmnpAF67M0CAxDM9L6nAfp/VQIcTYx9XgwkwaUPcB4rpkxTvWC8R14Z3myHkGCL4GHvkpmRZS5QuijCaLaW6fZIJPhbHRZGTEWJXSXpxTySJh4cSOAJIsBNUBEzxhJDkpMoaojgGwIsGi0C +1XanVy0GsappBo8h9BdF0doHROlAR1Aa5Qhq+hGpIE641RxhilFNaMV9IBzQTEmPIS0SgrTWiJTacFiyGXQLgZI8CjpILQLBciswkqtnbFdD4tkT6DmnpAF67M0CAzPtwr6nAfp/WulPGEfxbqgwPFdMmKd6wXiOvDO82Q8gwRfAw98lMyLKXKF0UYTRbS3T7JBJ8LY6LIyYixK6S9OK2T2JSQcH1U5CWIedesvISaQ1kvIkocA2BFlUWgR8UwQl -PimOEqYmDijPBfPg4okTigLyXhvPsa8PjxE3to3eZl96n1XqFE+OcnypmsXjUIUBuT6FNjITsAFgk6kJqJZ0WooAYW2kWZQ3B6EYFvLVe26BHY1AaM0NonRegDGGGMCYgJIA9AkkIZMzwXg8AkaFZ4vxXLgiJPCWZEBlC4AgsGPZ+pMB1IaVTM6zDRyZGIO0hUnTiHnQylEUgUA6b1woHFXA61mk3IVB86i3yVIQC1NRXUQQLwUAUVDXOBR84gqM +TEwcUZ4L58HFDCcUBeS8N59jXh8eIm8NG7zMvvU+q9Qonxzk+VMFi8ahCgNyfQpsZCdgAgEnUhNRLOi1FADC20izKG4PQjAt5ar23QI7GoDRmhtE6L0AYwwxgTEBJAHoEkhDJmeC8HgmwTihWeL8Vy4IiTwimRAZQuAILBh2fqTA1TalUzOsw0cmRiAtIVG0txjTSBQDpvXCgcVcDrQaVchULzqLvJUhALU1FdRBAvBQWRUNc4FHzgC/RhjjG1C0 -SYsxtQtIUVVNzJuRkT7LMsgccezweAwnJGfSA/dwSJCHO8U+Jk/g4j8hAjBLx9hhQHBcO6RSt4YkzrwUloKlhpT6rfMq98ICPzyrqSUr8SofwquqTUP9dQNQAR6IBlohWdUZbwDVMDzTALaqOP0iCxrHJQZNWA00ZHYIWngjMWYEADO8aQna5DQX3EOlWE1Xi/kZQ7CpHEmxNj/DHjInhk5gwAkEXOYRy4pb3FJPcf4YVQbyP8bJJRJQVHXj6feW +hRVU3Mm5GRPgsyyBxx7PB4DCckAiID93BIkIc7xT4mT+DiPyECMEvH2GFAcFw7r5K3hiTOvBCUX24JglqYCuRlXvhAR+eVdSSlfiVD+FV1Sah/rqBqACPRAMtH1cB3VIEZX5TA80wC2qjj9IgsahyUGTVgNNXl2CFp4IzFmBAvSiZbTIaWe4h0qxGtQA6jKHYVI4k2Jsf4Y9eU8MnMGAEz0hGLmXFLe4pJ7j/DCtI8GEKfEwyUd0+81qGJWLRqgW -1DFbFozERxIcOJzKIkpO4oSTziZ+Mhummu3MJBwFZGIGsjzfSc0begZtElAztvqmLCWRgpYyPmbLeW+BFYNr0obdW5QtaHn5J9N55gCCzuNqbYg5sCqjitlEW2pABmF2QqhdCJwsI4QQHhAiRESI+3Dn7fAAcqYQB7a21gSxdS4FjvHYdidSDJ0rQgdO3Kd7ZzhYpLaIKACaQw6a4AANJ03Ni0eg9B1aYD6H0GOmBcA9HoGixh6B5iLDpLqchzgW +xQ4cTmURJSASRYCYeq+R4iSHJSZQxrtzCQcBWRiBrPc30nN63oEbRJQMrb6piwlkYKWvKZmy3lvgRWda9KG3VuULWh5+SfSeeYAg07jam2IObAqo4rZRFtqQXphdkKoXQicLCOEEB4QIkREiPtw5+3wAHKmEAu3NtYEsXUuBY7x0HYnUgycS0BnTuyne2coWKS2gCgAmkMOmuAADSdNzYtHoPQdWmA+h9BjpgXAPR6BIsYegeYiw6S6nIc4BlCy3 -XLLeN5IkJFA3xHBFwiA/dHi1CSMfG6LK4TDnJMx2ePVeDeSSISQ4FKSSHD5XFUD2JcT4kJMSUkfGqT1gvtwGRN8uQityk/Hdyiipv1KsqT+8qao6gzP/XVXp9VWjAZq7qkCXnQMAbAmz1DRo1mQfWVBEYLUYNjHKHBSN6r2sdT6n8ZDSybA9cdL1PTa7z2ub6+x9x4Sn2xoS5dr1uxIiy99WN3ZTg4iPtjFN4MYX1tHFmuGObQkpi0U+HROlMXaI +jeSJCRP18RwRcKJc3WoSRj43QZXCYc5JGOzx6rwbySRCSHBJSSQ4hK4rAexLifEhJiSkm41Ses3K0C8pvgK5UuUn5boUUVN+pUNPSqqrK2q8r/7aq9Lqq0/Kupz0U9fLVgDYGWeoaNGsyD6yoIjGajBsY5Q4KRvVW19qK0/idXtTYrrjrus6bXeelyvU2PuPCU+2NcWLtet2JE6XvpRu7KcHER9saJoQDmuRqbrzpqCSmdRT5NE6VRRo3REgbkUC -MRIO5FAryVDYJyTQFipgKSmPQyABcmhXh6HuZQ2AEP3EoGwK8v1aj4HOKMAAslefRCXQWfP68UKxUx4kQBRnYlSDiuKfHJGFeIlbPFOpKLyEmda5J7bzlB8oHWus9b6zXdF6A9FYuchvPE8IPhnA5W8D6jkHiEu0FCEiJk0tnE5aOATYISQvGhCRTunlQqQ/rNJhKYI+VqbQBpuzsqH55WflVgzMrtNyqqgq2qSrLMub1eqqBroupzxU9fOzVmWp +vJUNgnJNCmKmApKY9DIAFyaFeHoe5lDYDg/cSgbAry/VqPgc4owACyV4dGxcBa87rxRzFTBiRAFG1iVJ5sxv60KMIANls9SUTx1bvFyS23nCD5QWttY611muyL0DaLRc5DeeJ4QfDOCyt4zi+4PFxdoKEJETLJbOKy0cvGwQkheNCEindPKhRByUCTCUwRcqWGlVV6nyoPzys/Uc4riqwylZ9r+xmdQZjM45nVKqoGuhs3xuzAgHNKqcyz+sBraG -ucNQg2hYiJpoL82Ima9ZrW4LCYdwhDrfkkIiy60sqLqGes800lXAg/Vo+Hv8dceOShho1nivLMbfr0mBkS+N9wTcjbkeVtN5NlGwzUYjPN9ZjuFrO5jINoUYQ3erT4x70kAkUy7RAXmtV9yh0FpHLgHaKDPqDnzLI8eBbhyFiLAdWQh0jpllAOWptJ3cD5SrNWxsF062XfrNd1fyibu3bqPdNsAyHpg3BxDyH8CofQxwTD2HcP4fvRiIs/to+x8z +5ommg7zuaZr1ktbg4Ju3CF2s+SQ0LO1yGAsRdQt1bn6kK4EN6xHw9/jrkx4IucIbc1Dmy8I3LaBgZ4pjfcQ3pQ9wyJrSm8nsNlGI0zfWfbOajvcXJGFeI52Hl4yrcm8mysO0QF5rVfcodBaRy4G2igj6g58yyLHgW4chYiz7VkAdQ6ZZQDlqbcd3BCUqzVsbOdOtF36xXZX8o67N26h3TbAM+6oMwfg4h/AyHUMcHQ5h7DuHb0YiLP7SP0f08IDj -wgBPOek9fp/awP9aAk4ZsgIJYD29uzgZe/Ct7EgxsTd3FNmbc2FvYCWyt9bhH3xgobuRjYsJYc8SOEcV4qW+w9lROSviQ9j5YRbJbpOIKRecgQtUZECceVbpEgWVoRLJTgfhE1wD+UyNScNUKcxUqc9NM1adYYsC1RGczNf4CFWdVVXMOcnMuctVUDNMBc4Fhc/BjVtcxczUJcnJborVAsbV5c7VVoldQ9nVdoKFzgYtRd4tfseAktr59c0B8RVk +1nhPH6v2sB/WgJOvjICCQQEBnHWc+xgefHBAFQ2Ru7jGxNqbM3sBzYW8t/D74gUN1IxsWEEOeJHCOK8JLfYeyomJXxIex9YRbJbpOIKROcIAEcVM2Vt8xdEgGVoRLJTgfg40wDlMGRCdqdhVSdtMSgKc9MMC1QjMap6d6pGcedmcQFNUOp2cNV7NoEmcLM+cSgBd3UQwTURcnJboLU/MrVpcbVVo5dg9SEldSxzhItBcYsPseB4tr4dcrdcVtgew -W5exLcNYdhI16wzcREbdwRHoOFHdZEwYEBC1FEYZVFasHwGsnwGwiMPxA5ZkRsQVbR7g+YuhSAeg6ZdswB9tihDtfd7Fi0nFbJYQYpU4q0ddnl7tfEKs3cSggkQkLCnxEkwBolki4lZkkiUjYDF594bokQzgx5Dg4kyl6x8AKkqkalWJ6kQkhC+dWl7lHBP06EXxekEYsgj1YN4MkMUM0MMMsMcM8MCMTkFklkXhXhvgW4fgkReJvhooLg9kDkjk +wDg0NYdhA9w1jdI1fopYlliQGNitSta1Xc00EYM1gkasnwGwCMPxA4pkBsAVbR7g+YuhSAeg6ZNswBttihdtvcbEOIkQfhBxvJLgg9Nd3ErtQ9ndw8/EzkHwXw4kwAIkEjokpl4jEjbpYD94bokQzgx5DholikPFSlylKlWIalAlBD7MmlblHB306EXwukTCoAD1oNYMEMkMUM0MMMsMcM8MjlZl5kXhXhvgW4fgkReJvhooLgdk9kDlc1BMCRvI -xERMCRvIPJwQUDSU5lCAzliAqjGlvVDQZDIBbl6jHlwiWk3lAUG5gUajjiAVPkbi65wVURIUG5oiEAINnw4JHDnCEBXD3C79ms7DRwKNDhEgThahsZHFvhUtYTf8NgW4F5YTMlT5eIrITgiQGUHMmU/hWUR5wcpMd8kpicBVL5MD6dKddNJV8CjpCCv4mdzN6pyDmpGDqDwFsTtVOcOQGChd6wjVRcBFvNzVODpcShZdgtlpQtlcIiRtIs9p4hxC +PJwRkCBFplCATliAyi6ly1DRpDIBrlqj7lQjHlnlXl/kKj9ifkziQgAV79G4rl8AwUw8EA98YVygHCnCXC3D3srCvtRwyNDhEgVlsY7FvgktwSf8NgW4F5wS0lT5eIrITgiQaV1U6U/hGUR4gdxNt5ccUp8dL50DBVNNRUX5Kcjp8DaciDf4CFSDmo4FWc1VbNCdzMWpnN9UEFBdWCPNTUODxcShJcAtlogt5cwiBswsKF4gxD3VLttcroEQ4RUs -vU7s9croEQ4QMsdgVDux1DTchFFwCs0A4QNlHpsZmNCBncjD3jTDs1Wi6s0wbFUZ/CMZS1389gZF8ZbiIAHta0I9KtlZo830+1P0U808m0W0gyuli9C80di9S8FYK9p13km8JBa8l0o0G98B11m8zYLZd0xYO87YQVj9JtptZsKB5tFtls1sNtQwH1J8n0Azwy21gzRxv0mY44V96R18gMQNCcs4+xPiEVyg+gMITgFwAArCgTQfAaDOmBDfYNkU +dhzcNZ/hlSRF6Q4Q1lHpsZGNCBHck1Ii18IBFEKtGjBSSgfDDs/DBwVk389heV8YLiIBrtnjJ0n0X0e130k8U8G0m1PT2lC989EdC9i8FYy83TV1Z1aoa91C698BIyJAm8LZt0xY287ZD9htRtxtJsKBptZt5slsVtQw71x8H1I8PSW0vTRxP0mY44l96RV8ANN8cSd8CkPCHsD9yg+gMITgFwAArCgTQfASDOmODfYNkUYPsqoAAVVGAfVvzmAQ -YccqoAAVVGCfUBIkBIzUwB1XgALHiuHxHyUJX0NYz7A4xPlWSJAJFXn41oOE22T+B2DGI2K5T7NQBxDxEJCJBALJDAJSlJPU3JOMwkHFXympOlQIIpOgHpJIJZ0ajZ2syoL5w6m50EzoP50QsF2QsgH5K9UFJKB83QSl24PjF4JTAVylM9O2hENBWriYK11rGaIS2bAGxYVO3xEDRPioy1ODEhJUK0NXHjV4kBmUK2gtOMMj3dzMNtISKG1ay23+ +AWG5W+1Xn/zHiuHxByXkMhPRT7FYxPiWSJAJFXh41pX40SE2T+B2CGJWKgI5RxDxEJCJGALJFALxJI0gIZKJyFRFXyjFV00lSJMM2/hMwZ0anoNZMYK5yoPPLALUxZPpP5w5JYOFy815K4PjB4JTBl2FKdO2l2goWrnZJoWi3qNi2bB6xYUO3xD9RPgo2VO7FqCUIjXVNXBjV4kBl7H0NdKMNNJUViKfH60sK0Qa1qyaz6VqFwEqEW26CQFoh20s -1awLnoFqFwEqFW26CQFogOwdJOynAxnxThy+BD3OLDx9NQEUUHMP0GTUo0q0s3L+xa3rHIUelhw2SDXfxhEDx/yh2xRhzh0Yy4M8gJDcRRy1SXmWRPjCiHHMm4run0OgKpmSlbMAowK5K0xAspIlRfmKigqypgtM0VQswQooPZxATZPsx5x1SwtZJKDwtYIIsgCIsly4ICzIrlwov4KITMuENdVwBOEVNYOVJajkN4BmO8jCk+F4rESHAEoNLEVC +VRl8IxmxUhy+BCJ2NFOdIiNuxePu2hUewdikpkrkoXJRRsP+O4EeghzWX9TfxhBO2/0cjBziEh3o04M8gJCOBRLniXgWRPjCiHHMnorunt2xw5WSmrPxJ5UJIMxJy0wAolSp2AppxlSpNMwgrIIYIoNoLZzguZMgqQqYJQo1yFzYPQvNV8ywqlxwr4KIWOMdWEL2hOClLKplJalkN4AmO8jCk+EYuDDN3UNejYuDFCk+Hfzul5T1LBhK14oUTd0q -k+A/zuhkXNMMMkr9MzQ93MO9xKD8NO2LUxlS2PhMtCNu3C03yiNdw31sJfQ6B6z6AzygFW0DGiFwNws7UDgkAes5CetqleprHeqVUHQTiSlHTFjjPLzQEr0/CzJTNqjr3TNXUzOTPQBb1zPrHbwPSPRHLHMnOnNnPnMXOXMqDXI3NrInw4Cn2+vQF+v+qyEBuYGBujnbN/S7IA1uq317JgL3y8Ne2+PKEQkqCaAwg6COAAgAHkVz6hqhqhJb6Bqg +3NMgEtKnFUvjWPg0pcQuxC3X10ukkMIj0DgkA6A6z6DTygEW0DGiGwMgHIGT0j1Os5HOtqiuprBuvlX7QTiSmHTFlDNLzQHL0/ATM1mjIXVjOXXjIb0TLNmTPrFbz3QPW7N7IHKHJHLHInKnMqFnPnOLLHw4An2OvQCepeqyDeuYA+ujlrO/QbL/SNI3y3w5Vbl3wMvA07IkEQkqCaAwg6COAAgAHlpz6hqhqh+b6Bqgmg4M+yjA2RVcKYPt1tgV -mgENxyjA2QNcKZftttniQSpxlk1kJE1w7JLgKQ+U/8F5pEMT38aVu47yOSoCiSpc4CcjED8iUCAL0CGRgLypsrwLcrDM6SirmcSqVUWTeSUKaCOSMLnMyqkKKr6qRd8LxdfMRTSL5pOr7SQsBCwtddSg5SKEPDNdYtWDJCiNpC2KLoxqkQSJGNUtQ09Tuwl55rrcidYDPKytLSbrrSatZLNEnxhtrDdFnKrCC5iAhhbQ4B6Bv1SIdKfC9K/cjqjL +vt/L1zlk1w7JLgKRCVf8F4JEkS38KVu4zzUS0DRwIqd5XhF5MiECcjkCPyCdvyMC/yycdNkryTUroBKS5VwLFU6S2TKD8qTb4Luc/boKIBmCyquSShPN0ExdML5paq0x6qBDGqhDCLAVviSL1daxyLJC9jOrWFPIYQeAksg0I1uwl41TLdOV0j7KeLDTys4Ylq1EhLGs1s/jxKC5iAhhbQ4B6BP1SIFKvClKDs1quINq7cHTS0nSXSG7Rx/FAlBL -Tr3SPFPTvSrTRw4jc0wkXwMj7DYkSl0jtFMjXhsiEC8jkDCiSlij7syiDAKjzlqjerai3lTjGiDiZSMAFQ36uln6BBXl3kHiQhpSXj7igVgHKIdb6xXjoUbrrLBb2tx7J7p7HK7qn9gxwQh57JzJvgewl56U/LnIW44hYQ7oewSRCU1wwr6xUccSWVTh8TADCSZNiSPbBUMqsCwLqd9NILaToKiDv5g6mTSqw6cKWo7M0LHMI7uTarw7cLE7Grk7 +QkNFEiolCkUiV7bD0irb4DsikC8jCkCirsiiDASjTlyjU7KinlDjaitLUQDjWlb6OrmQmlfkG5zjL7LjiA363kbjKIlaHinjDTXijL0Bu7e7+6hBiLlYFaO61huxwQh57JzJvgewl5qUXKjIW44hYQ7oewSRcU1wfL4dzzOD6UMTmUADsTJMko8dPzTaA7b4PbnbbrjTAKUr4rPb0rvaSCsrQ7cqYLA6mTvzEL/aSq/BDVI60LY7ODqqE7lq9Q8L -iK2rZoeCM7KLs6QGtp87QUMIhrTpLrRr7FXS6UCRmMzcctm7RFyQEQTJTg1qJKN7pKbT1EJT9qC0nSS1ERAYvgV6wiP6a0nHXxGze1mzIzDUvqX1AywmQaC8wbxrYyJ0p0o8Z00aIBUzdYmAMz4b0acyPr0n8ycaQVhbRbxapaZa5aFalaVa1aNbvM6zqaGzabX0myP1wnVNl94nuzQjt8WGliBz99IMEH0AhBiAVzahnA2BqhmBbRqh1aoBsATg +P7ShxTAUMI2rTpdqC7Ds7SqUCRGNlDMsq6tCmKEQTJThpr9S5q56FrjCBLPcLTs0VL81ERAYvgp7XFlHZ69K3TygKy30Az9V20ibn0/TKzAnlovrl9uqQyx0J0KZgbobQbtZwb6w9ZIaQaTZYbWGEb28D1ObubeaBahaRaxaJapaZa5aPMSyCayyQn/He0lNF9vrUBGyXFmyaG5iWb2zDL2b0AhBiBpzahnA2BqhmBbRqhZaoBsATg2AOxqhzhpz -2AOxqhzgVzUHtzAKAdHhgoDapjE0iRT54TsVsYMduKewQ1vIHcsSecHzRNnzhxXzRwkrZMvyFNfzlM2GySOHoKuH8mpU8q+GCqBGGTSCtiRG1V47/7ULaCarY7sKoWIAGrkwmqIAWrU72r063G5kqK/6861c9pOR9HulmLftWLBnZCroOJQpITMSo1stwbrt6X8sW60AJEDhj5jcO7NqYiJQdre6d7+6FKtalLGs2t0AY42BNgKAmg+hsBEJPDvC +zLCMlziM4b4G+FsZVaxi40iRT5dznJHhgogd1x7JAZvI7dfKOcBMrzhNbyxN7yqZHyZN9HXyFN7aCTHbmGsCkqyT34PaCDQLiC/4+HlUBG+VYKg7CrsqoLwWI7kwo7IAY7RdZHZpuDE7cL+DgstcVHmqKFOQNGOlc6CNKLWaZCroOJQpmLkThreFuq1C0nWLq7lkDhj4Dd66fG+Km6zSW6+s27YGxKLCC4Y42BNgKAmg+hsBEJ3DPCwBvCnGrT1q -wBfCPHDrDKk1l7TKAnzL3j4GfwQVJXpXZX5XUHRW1huASIF4iRzILtCU0lj5jnnJAYF44QcV38nzS0dSICOTjcXhQp4RDhLhLhbJErHaUrVM0qvafmCq/mILAX35+HYLirhHQ7IWDVKrJHeoMqeSxHkWvNCLhTLVMWgs9qcXNHqKdHcBdxiW8XLpTseB411wOJfKNCG6kpHgrH6R4D8Q9gtxuWgm+WZLXHS2jtVWDLzsTqHc/GLrc716u6UmX0AB +ktNqPGdqcXvGDqfEQG+mIARWxWJWpXlnrDqTIByESIF4iRzJPhjFklj4DnnBAYF44QMU39ryC0w16wIDc1PgXhQp4RDhLhLhbJwqWzOUPnYqvnOGWHfm8CAWvawLeHfawW9VGHOoCqRGiqxG7rSqEXpGUW+SsF0WFHZdsXtKCLldcBdxCXlHLpDsS641bFnLGWNCwRHhjHRE4D8Q9gtwOXNWoiJRFqeXeCs1lLFXx7lXJ7NKOqNXUAysEmQmABFZ -FZOUgGAB63cPRkM6PZdpgNdtgDd2J8WeJ6WfPEvJJhMhdnJ9JxGtM1tldA2NJjG/J7GzvI9UZ8ZyZ6Z2Z+ZxZ5ZhAVZ9Zymx9UM9AHd1d9dzd1szp1fVAbpkotOR21uAZ/mg/YZiAaDSWv8W0fACgHgACc4BAFcnkSkcc4gP8cc5QBVn7Gwh/RuXWtln4YHMeIlPsQlEyckR1geEhyEkHMkHYHQ6hmeSAt8mA0++Aqai+go1AknKNyqzhnAuNgOx +OUgGAU63cdR70yPJdpgVdtgddz6vPFp6WXPIvOJ8M+d55JJiAavVJkodJg2K9pMnJ1MxGgFAZoZkZsZiZqZmZuZhABZpZvG+9H09Abdldtdjd6s5p6JtpjxNOUN5mts3rN4iQSDfmv8W0fACgHgACc4BAacnkSkPs4gP8Ps5QaVn4u/Dbb7P1Fjd1vFPsXFEycke1vsHB5i/7MkHYcEN/K5iN+sc26aDI3exA3IlAmKr81Np2n50k2NzhwFunE1v -NoOxkv+CFygxFzTTNzkyqnNxFvN01IUjgot1Rjq7FvUXF7Vvq0sGshi4upiqwhLcuillUlSbZMKQNBt+u6Nc3YcTtnLVeBtkeM0xx+d5xnu4dwV+SsVxS4etDqAIQBcXcSwGAO4We5V+ezx464y6dte66p7W6reu03e4+/etIkrxrE+528+pAqToo3S8pZkcotQSoi5T05kOojpd+kak4rr3+qzl+wB8Bn5T025K4r5CBp4x/F4/AKFXViloc1UR +UWk5NqzSF4R1N0RsO+F9zaOnkqqtFmq4tpRu+pq9O3AIsrOqLMqiQgjKQqii6LqzZMKP1Eusult9idzka6uyyVeEukeXUqxgwl3Wx/ij3Mw1u8S9uwVnVqAIQBcXcSwGAO4IeuVken3a0tSlVqdrRmdud+sBe0w6rJ8VI2wtexSuIzejJS2uAvqvesT/Iirwo5kYotQUos5J0l+6+x+9pZRh+u5J+rRrr04v5P+vrq40bj5f+h/e+x4huZ47Vn8A -L5LwgVL01uLiAchVLdjJEMeOEMkAcVLU8hE9cPEHj0kKeN4JHVA2hki5lPE9lJhkT5Kkkz2snDqeTqk/2unYFpNoRtT1NjT9N6Rqq9CuF0R/ThRlFpR1q0UrBNR8zxXHOz+mi/qqjuz0XEautivPials4VAix4ME4fzw0h6Nj26ftsL7aodr3Pg/NR0tVrxg4bBvlD0vFudgrxM8oaJtpjmVPEJ99ftZaUGmDk94X8dMvZJ/01Jo2edG9zJ+9xvW +FOLhLpLu4Sj+rSy+sM1lZPEM5uEMkAcJLe3YldcPEDj0kKeN4WHMAr1sh9E04TEqhx53E6K+h1TflaTxK2ToC+T+N4Fmk0F3ncFtTag3qDNmF4q7NiRzkvNjCuR/zBx6ZEzjq8t0sCjqzwXZ+rq8yYeUkM4Fijz3NE4dtjUh6JjqRLaIL+anAwd+x4dr3BVsem0g4ZBwlR0rx/a2dw618cssJgJjmB6+p/nxpghKJgvE9/6+Jo6y9o2KMlJ3WJgO -XiQJ9tvQp19mDTD7D3D/Dwj4jngUj8jyj8fYDgXiMpfNmzs/9QDHpnmsDZDwbRb9ABcfATkbAACJoNkUgZwJoSWwGegQCTQPoI4SWoYDZhABYHc+j1AVeTYDHPiTzyKjZTjnZs5g4C5wGK5/Q27nYRIR8sTF8yTZ715+TMxj5/81Kt7720VWN77/Kn2wq4g5NgHvT4H6FyO6q7N2R3NqH/N5qwt/zUzrFkdpHrR6zvaeoGt1AUupsI4oxtzsYq7z +MzJp9lvF9vJqDdDzD7D3D/DwjngYj0j8j0fYDvn7tcJhfam+s39f9dpxmkDbp5D0BiABcfATkbAACJoNkUgZwJofmwGegQCTQPoI4fmoYI1ojFcqywG2yZHPiVz/ytZe1o55HeinsQNC5+3L11Q+Y68kTO8s20N5558uTN84tN7h2qT75778ndh92v77hhNkFpN4HlNvKxkjnaF/htv6H1zXNiqmRgt3ZItpHxRrFkUwsVR3Aeoat1AWzpsfO2tx -4cxtt3gQcEn+eEiMkWETU8SjagdiAarT3be+rIVmLkVuL/V7nq8eMfYCgVFKCWZAelShDUgI0XcIQIwZ4PoEQP8OAFcjgF0GeBXgjAkgbAJti1q0dFWN9SAAdXHbZdNW51PLuHksqwoFuNlV9Df0Yh386mr4C/sCRcrYgEQ2gFnp/nfypYm6hDZwM60hBusP8gbCEl6wgC3dg0eIOEK6UejbA9ggnSAC81YaV92GcnX5gpzr5AsG+ILOCiHVb62Y +HYca7z4Ax8upKQcUn7gGNeyJeejMAmap3Tl0L7l+n4rvlqLgVrboVgFOAK8eMfYCgRFKCKZYSguegODUgI0XcIQIwZ4PoCID/BwBpyHALoM8CvBGBJA2AVbArTuIysj6K1JnujHHbqVVWM9LnnIkW52E/GD/RiE/yqavhr+SnchJSFxBs8P8b+JLJXUwaHMkczrYcK6wDYrIPWM8UhqSDxBwg7Sj0bYHsGIYCdQ2UVJTBJwYbt8fyxJf8j9w4bE4 -YWUdcHmm0OgeZoe7BFOiZxlwI8R+lnEaqj1LBNAp+WPMavZBhD2MW2upHzha1KzMsrc1jDiOlhWIhd9+VPQdi41p5dV6e+ldGBOxy5asRqHPX0ryzQYSAZ8L1N6soHybkB+ezTYIUzRZqntoy4NRJpLwvbS8kyyvTWPL3rwo0r2qvS2Or0LLlAXebvD3l7x95+9ngAfACEHxD5h8gO9ZEDjHmDghCgaYQi3mwA7JdNOaPZRDnzUd4YD6Ar/d/p/2 +uGhBHhs3y04g9rM6bTTpm2045tdOSLfTj5kM7yNR+JbCfmZwrZNBZ+2PK6PZBhAWMm2d7DfvPCKy0sLcJjdGClgWKBdZqwXftsaTp7hc6qI7UeigMxgTstqcHTxqZ0rReI+2RpbRBICnyXVrqygVhvdRA5R5g4cQ96gkIPbiwj2v1UdCXml688p0V7G9oryXQPs5eMNDdOs0gC5N0y5QV3u7097e9fe/vZ4IHwAjB9Q+4fIDqWWSGxDyalNKDlbx -/6/9/+gA4AaAPAHUd78O2AHLxm0DxooQG4MeEiBJCcc+w7GdcLjjrqPQjaNzQTK3CJBDhE0pDTyGxiObPNEOnwRePbiDSG5SQQaJgTJ3e5ZRhBX3GnLwwTa/cVOYLPUMyQUEaptO0dfqN30h7MEBSMPDFkPxLZ09JS5bPFjoL2g1CMecWUlmXTn7Y9/o5IbYBxGuZWCNYtkDfuCDXBWQvg01Pfqmk55VZ+WkXU/tF0c74CwWV/CQD0D/AYdzgV4f +aawcrs8HTpoh2wESUGAX/H/n/wAFACQBYAiAVAJgEbc64ADbbtwC4zaAY0UIDcGPCRAkhWO5kReP7mij60cQ/VEhibVbhEghwcaXBp5EeB7BqG0BA3IvFtz+o9cpIf1KwJpAiCPuHUL7iSVr5u1/mDfOQU30B4t9yCPfCFkI074Q9u+h0PvpoIgDIt4eugxHgzwIQo8tGaPPaF0Mx5kULCsWezmS1lIqQ142wDiJcwcEaxeO9I0armnoyA5xq/An -QAqXS4qsGe47QIi4lSw+DDGfg1AVtUgBFc5KCSUrsfXK6JFtElGF4Jd2OHDhThfYc4Y1l9b/B40tw/FHxH+D1c56jXSpPfRa6P19iWPABj/RJZWE0g6iI9IUPd6e9vevvf3oH2D6h9vweoYYhsGWQkg1k+3INJZCJA7BiezRBYrvg4SDgewXwXsBJnDZ/wdiexS5KJDn69cHk3XQxh10uJAMRueLMbjmJBRQCZuc3OBugLQ4si2RHIhUlMKBI/Dy +8NTxsa087GPguJMJWi438dWPQP8Gh3OBXh9AkpVLvK1HZj17EgRJxDl3VaYCeekAQrlVjiSlcV6yRSrrVnIwvAruDwxgTGj7D7MMkPrf4DGi+HYo+I/wRrsPRKQtdT6bXc+tsWfpRBuuA3XrnP3qJpAVEB6eoR7y94+8/eAfIPiHzD7fg9Q/RDYAshJDLJu2toyyESB2Ak96iMxbsDsMihsIvgvYUTEIL/gbEti5yUSPnX641FvR7o1+tcSm7jdv -E0xSELxEWEcIzgoYvuCd2WR8Q0sxw/hLMT2GWp7uDDR7sjnxxhtXuggkHp9xyrvD42RmcQX91U5kF1O5VNvuI1kGd9dOII1cQZzYJGdVBg/dQWZ00FwiBuspAlhQlGD6DMxY1I3IiEHAnweBY4cwRGg34sop4BIVLCDHJEu5KR4XY/naR5EeCi0zpAcIxlPj6E2ep4r0vl38G3U9EYZUJrzy3bNMeeQvAhCLyLynsoaUvYJjLznQI1tYt7Mwdk0f +6NY24tR0AbzdgGZLFDugBFFiiJRkpNYZ9hi4QBSBvwSELxD2EcIzgaY0HFg1uhmRlkFzWxH8EmJ8c0SDKR7pQzhwCDOmBY/4e9zioyDo2Ug+vjIIU4ZUfaiguEaDxUFiCzxKIyRv325LsEDOEuEfjiOR7j98KU/UYKYKG5dV9ciIQcCfA5FG4MsoabfsGCLQEgksIMKnu4Jp4DteRRXJOn4Iy4YwcQsIbyHxCVHaU8uqo41n4xF5Vl+cwTd0vhIi -Z5M1e1sIpuUH6Fv8P+X/H/qQD/4ACgBIAsASbzqFm8YmrNNoezWt5c0EOfTJDsUhQ5DMmR6AK8DwE5C7hTguAS8TWIxQEDzW8hdHExh+CEpDgfwEIu2OxS9gXgEiBEEpg/xTxs+EVHSSdQxINtoo6okoHwN5RfMgK0bBvrXxnFKcvhTff7kuMB4riZBHfMHl33hZ1V5GYIpOioOUZw99kGgmEQQi0GGMERFCBDFeNzoYjZqFDYcGwhmp+c8RglcG +Zi9D20TY9pE1yFhlAaEZIoWDRKHK9H22TNXtbFfblBP+3/X/v/0AGkBgBoA8AZAOgEm8ehZvV9KLxpDQdaatvEIR0zeGgY2xzvK8DwE5C7hTguAT8b2NwnfZ8QC8BjD8FxSHA/gMUWgQ617AvBZxx8MkO/inhZ9SG5k5VkiRLrRQzRG46AluMBQAjdxv5GTqCL+b6Yjx/3JTgqmvGE4wevALvqpxcy3i0RGIx8fyWfG+ChSb45RgSIoRwYvxOLJf -iSkJQ3QHGjg38dTxcEn9M6PuMdp4IQFTshRs7GCaKICHwT0AgAFhBAADCCABeEFamABpEEACsIKgEAB8IIACEQVAIAC4QQANwggADhAuprU/qc1L571CWp7U7qX1MGmjSJpU0maVGWPYQ0Je8ZGGomSvbBAegPwvWFkLSZMwIIuQiiRr09K+x2JzTeaZ1J6kDThp40yadNNaHtCYOcHe7PxPfKCS9WDhcoMAjYDQYjAygQuprRsJmtIAW3F/J/k+ +oNQIbDg2EA1VAMOFAndUCUuKG6JYxgnci4JYXBCTKP8EsilWaAzCcTBuyRDfGEgQACwggABhBAAvCA9TAA0iCABWEFQCAA+EEABCIKgEABcIIAG4QQABwgg0nqWNK6mC9kh3UvqUNNGkTSZp80xactMDLZDYmeQ89jL0ybBAegSne9vXnKGfYwwrE3dBrydK+xRJITNaQNOGnjSppc0haUtMt5sA6ywwumk2Xt6ZjHeHZJbuUGARsBIMRgZQJnRg -BI5XgVkR8axh0nfB4Qx8MkIZMuD9jgwQaJIPAVWQg5T4mSYvvwIjZV8HJNfEQc5J+7zjvh8FTyXHVXFadYWfkiHtuN76GcC2xnA8WKQiluDYRPVKCbFNBR9AEpn9JKZdnBCrI66M1TSWYNehZT541dIcGkkp6FTnBEXVwaVPca8iKpS9KqUgPZ61STCC7coIACYQVAIAEYQZqYAHYQQAMIgqAe6R1MACiILNOjyWybZDsp2W1M6luyNpovLaWeyS +a/F+xZrZ/B/k+Cw5XgVkQCUxnRTmTvg8IKyfg1slLjc0/qJIHASWT/ZT4aSF7rQ3DaScxBwIyQX5Lk6BTG+APNYkD1hFqcERNBQRhyFCkkVURxqe8ZVR0FPijO+gvETizSmAo+gmU7StlNzShRwQSyUugVJMnNtvOTg+eEiAxjJJe23PELjyJqkai6pyE1Adl22oYCIhBszwdEPQCAAmEFQCABGEC6mAB2EEADCIKgFen9TAAoiArTI8jsl2R7K9 -G7TL2aTA6UdKyYnS0h0AMMORP3RXS8WN0xpvUM9l2zHZzs/2VB0t4dCbe8HAMHb13wO8BaokiAC0CvAUBKgPAIQH+CEDrcFJ0MjYF8GCgg5raq8TiBcxT6nwEgmfN8WBMBh8oWBpk/eISgdwjjrJY4uyelSEExtqZPDWcYHTcmLjwWjMhFszIkaszNx/kuRki05m7juZ+4kisW3Io6yy2Qs7QZWwXDiz2KU4RjAiDEwr9nxQmfQpoQWpYi7oa4NW +m9SBpfs/aRRJyGnsjptEi9qdIQDnTGJGTK9kzAgiWx1etQ5Rk9NqbJDA5bsz2d7PDmDC/pNNG3vTTGHyTQZvTcGRIBaBXgKAlQHgEID/BCAjWcDU1hsC+DBR/sBtVeJxHT7J9T4CQc5gyiHAXMk+1wvyg5P3i4o7c64rHIILoaV96Z1fEEa7X8kUlWZwUlTq3y5kd8eZ8IvmWoLhYaChZenB8aLISniyXxY/BqmEMVzmcFwcs6ilOAP5rgdg6/In -d+M7oazD+1I7WYBIXrqseIfEVnqvWNkoDTZKQ8oM7MenLSXpa092XdN9mLSnpK016etLiGbTEhO0mPntPDkIBDpCvEiTHLOnxyCyXea6Q0xpovpYFS056atLelcSPpHNPOd9ILndDi5qHUuUYHHL7B6gFIQgIBwhlD0G5m3DYPg2Bwf4TSZwQMRxyoEkRW4V3B3N5F7DrhCUdtOeD2DiBmTR5lk5hu+XjE0hI2zw4VLPLeHzyXJdMpeT8OVTSCAR +jsHtzKFmR5IL4HsL1nQTj+bUrlu7lqnpdnGx2bGHxHZ7T1Oe1s/LgUKfTez3pW0r6btP9kvTQ5G0j6dtO+l7ST2QZH6odJomoAgahQ66c6QTkXSleycqhanLulpkO8j0mpoTRQU4K0Fn0naT9KpolzreK+QGXbwQ4KSembNGuQhD7L7B6gFIQgIB3loIyhRA4jYOgz+zv5tSZwf1OuG1oPAbobcTat5F7DrhcUxtKeXEEcmzyXJrwyKkvM+ZV8o2 -m8kHvYqYJKC++aLAfkfKhEnyNG58mKZWwAjXzK6KWLuPfLJF3sGWYiU4K+MoYrwEq6s2Cd3X/Hmc4B+si7EHiZb5yZ2n9EUVAtwm0KUFcChhRgqQX5KFphS9BYgoDmYTxewc3BbDTwnGwI5xC6OfhL+xxyLpCc/IUnOoVNNSlD0+hRUqYXZzuJVvNfJ0Nt6cKhJvQtDi0FtAdBagAEBcIu1wFNZ5JdYjYGvFhwYzESaM/4KgTPJx9EQlkB3EaRhC +vk9eczKFTHj5B0I/mam3CnB06CkPLNuHVPnlVhZg/eOtiKSm4iUp98sUni0BQARn5jnRLF3ARDst6ReWCcTYI0J/zCGK8MKvrKQXVSz+fI02VAr9ynYGWow0IdOxVGGzpgkeVBZtO4UEKsFHC9aVwvwWYKI5EvKidHLIUULZeM6CQGdNoWlCrp/Sm6WnJTJsSHpWcthXU2aVvT6lbS3hcXP+kwchFsk4Ga2UmEFwWgtoDoLUAAgLgF2hAurBZRIE -78aGtBf/F8C36WS/gS8VAjZMpDzDDgRSI+Ed2YxPDq+OmacZYtpmioJBzfDyc4ozaOL2+MjbeT3yCmKMQpsPNOtCIFlRSTxF888aChjiBLksp2D+VCFWR8QZql2DfvFW/xhKfwoXX+Uf12qRTYB5U4CV4MQGZLkBFlXJdMGjxdBVsfQACFqDCBETPqkQl9KyvZWcqkaNS+IagAkQkDDaZjZEHxkfFjpal0NPBWHJjlNLMhD7Uhe0rzKXSulUE5OT +bA14EOKydCVxn/AwC/cR4JsAhwfArIw8fWgfyJl9hHlXwEiHxAxTrh6M1M1AJSB2GHB8kR8Y7oxlQKAisoq8xmU4t+4szIRbM5ThzJyrnjlBULJEVFIFkxSz5Wgi+XHQR7YVEJyUu+ajyn4xw4lCWQ7HdH3hLIMJKSsamkqAk5YtZoVL/FcLghciT+RsgpRAqQnFKJ6wQ8pWqywlVLbZkeLoItj6AAQtQYQW9ndSIl6JpVsqlgDGS6XELUAyybQL -QsMRsqOVLAIVefGg6sK+JHCgST0JLkAyJAXQTAEYCNDxA/wLQfJrFzEWuVTIY8GKnpPMhxV9lDwOEHiEuy2R0lEJXiDjKLTLIcinLd/MPDRKkzbJAg75jPMclzy8CHwucf8oXG2K/hQPbyeyQ3FOKtxiglgsoL3GhS4V3i7qoIXhGVsjQ6KylipHjQaL1wGJPFWPEJEkgtwIYx8etQpEJKqRNPEqYAqy4Gyzq9KiBYyqkp5KYFBS4aUUqmn2ySlM +ZChD6NkQ3GTGSOm6UA1yFdEqhYMqTllDRl0AW6enMmWZzIl6ImZckKlUyq5V6q8+FJLLlAyRFVc8RTgIkBdBMARgI0PED/AtBWGgos5f9FMhjwgqs48yCFTuUPA4QeIf3PYgDwrJeIRMlWpkTZZv5h4CJQFR5KhXeSJBLtHAnX3BGIqgW281FbC3RXqdERqg3xeoJh6oUB++bEJcSsxZkr8RU/I0FSvJYqQY0Ji9cEiQKnkg/hY4DJdXWWJbhUxm -6spXOsGWLqqlMZLCee1DkpD9phCyOYr1RpqrzpGqzpZQu6VU1dVEgOhUNPnX9T11wylhbxK6EWquFIk61egEmacgEAV4PoFAE0BGg6YlHGOJLR6C1BMAu4aoPcEqDh9I+WzaPpwNGLTEA2ppYeCnwfJ6SP8+kzJEYuYH3k8+9zcTE81HF9NPypfH8iSD/IVpE19k5NVTIsVpqF5ynGxQzOBUg9AR8g3Ne5hLVuL0WagvmUeMpUWckVfilFbgA6BT +Mo/gaR5X5LwFJsyBWO0CFNTLZCC1qTbKiG1LOFU0hpYtPdlNLygdSyaWerGkXqOlwZSXme1jknSr2lq2vPQptWML7V90x1R1WznsKr1J6m9YsvvXLLS5gimSeUrklM1RFTvHViM05AIArwfQKAJoCNB0xyOMcfmj0FqCYBdw1Qe4JUAj6rMo+mw/6JcEGLjF/WOpYeMnxuazj38CIACR5Oz43MhMN5YcAXzckPlpMJfN5u+Qr52KV5DimvvCukEu -8Z+FrdETeMRBcU9Rj4wnvPAp6ZSFqahctHlPiV1Tbq5KgVrSPfV4DIZl/D9aUGgxHBbQRoSQCyOgENcypesmlZVLHXsKslgTUscJK+KlzCAZmizVZr/D1z1laANcG5GtYHdLybwVFqxghCtjvIjGbYCeSnjhrNhkIbFbFUyRF8LhfTXDZ8spnfK/aNM+vpmvplSCi1DiuQWzP+EuKeNXM/vjzM8WHjh+Qm0fhWzE3CK+SsMTHtePsTOIdkIaOWZ5 +KgpmVGEWir3lptMVra5EdFNh5drMRYsvQTfIMHvjoluADoLP3n479F+P4xEHRVtGYzDGfCSnhrNZWiIdgSWcRFZs5GVS11Xg+CRqPMLwzRKQoiRaUEgxHBbQRoSQCKIQFNdHGsogIVl0nZ7qnV2ErVopJ1aEA/NAWoLX+DbmIzVwDKBIJa0O6Hk3giLLGXQMeXjjvI9GbYPISni5ryQkIKENjEpk3QPJgnGmUJv44ia9xjiqtWCICmSat50mjxWI -A357AbWey1Ar2p/H9q/xFKhFVSvs3+5R1uXCdQfwakNDnqS4YWD0DuDISX0wQ1bYQHW2HsRVYvdCdtPlX1LUhrS69oROaWqrztOQ09RQqPRfqf1f6gDUBsQggawNEGqDTBtqEpzp8jQnbXtuYU8SxlbCzfD9N5pvqPNJmumLMoIj3AhguAfzeg2uhvA2B8aIlBcDvktwu5HqvSRjPIZGTEtw8qEHovHm8DJ5NG6eZONeE/LGNViwrSxuK0QrNOG8 +K8WRTd5ymztUEu7VEqMWydUtpPx03yLkKpFdqt+JsT+EtkgaNWZ5GKkvCLIjwQ/tytAWn8N1CjVahFqFXoD91sE3CTENSFLhhYPQdbkEyF5PpYh12wgLdsyGarKJZEk1fkJqWUKbVxQj9darXQsSf1zCg9IhuQ2ob0NmGxCNhtw34bCNxG7oTnMnxXa2AN2u7U0yGGrKoN6+CubBv9X74fNdMHZQRHuBDBcAaWpReQkcqcCTRtkMeTsHy33K0kM4 -srVvPZnFrwRMKyEfVvhWnzhNvi3OiLNwB+ai6HWxKWNQhKB4TIX48JbwjETeRXxUIaKJxCUJaamVf8wdQBMy6M9HN82qCTkqnXMrkFK6tBQgqGV8lImy6/pWbsYWYLhV2CrdSHIVW7qCFRClVUr3O1kKOl92sfoRR6VzTZ1tu4pUDtGWwdxl+c3pr9MtXcKTNmwIQOOU5DMBlA8QDoGAIwirZmA+gWWguCGCLtoM1YkRZA2m7R82UsOVLLZE4EQk +vGfJhsnBFJ5fGRQjsJnnOT55kARrWG2a10zeZ4giQPuKZkIrutSK+tTJsbVyaBtWKobTipU2ja1NV8jTWEtfH9qpZU/VLWrms6aMspXVFZCdhMhQTrNJuQEsVLgLRROILcZdbtsPWN0Dto/I7Q1PNlRaQhoqlqedrtkQA6leCjBUssIkPagNLShZSHsIUaqDpT6mOWarjlvqaFVqkZcbG/UTLf1LC6ZfjUA2dST1wenhTHq9VY7pJ5cwDH6qQ5gz -NwawikFgxuXM87GGSoTj60VFHCl4Ko9HYNvjWaibhnwXUQ8Knmydqd5i2nRKBpKfDrFgjZeb8OXFMy81oPKRmCrdAlbKtXOstbCuPnqMq1yPQsJW1tCSbURUsGTawh4wHAmM6Ul+XqSVmQlfglkVeOrqN2a7ipxXM/vSKM0NzS5zAHoHABaDQZOQkgMWdyJ13wC5t1U7JSbKf0Si+6ESaUZV1lGwHGsCow4c2xOFd6rJUwXvdqP73BoHhBojLkaO +A16ATYEID7KchmAygeIB0GgEYRFszAfQMLQXBDAF2kGHsQoqo4bCNmqAJlBDiSy2QeBKyDcMcOCh2QfleudRWdi52Zi7hHEffiZBNEvDAV7wy0Xbk+A2jfhtM0QWLoZmVqJQ1arrZ/B62njj5Ta7meD0U3Yq5tgswJefJFmEqsRvaybYYLToVtbQ+m4llLCM2sJOMBwPQoysKk/ymWWs5ir8F85O7nNe23lW7oi6X9SRxAnRAXGYA9A4ALQSDJyE -a61JdibXWtpaL66jdv6FBsg60nG6PEoJ+Y4boWJmE3JZubxNzdMq/0/6/9ABsWXJKcpurVwqyeYYiAPIkhVd/WqgS3FbhrhmeFe1ZOuGxnhUfWBIQcWynxBPcMthi8cUmpH0pqGN4+9NYvOn3Zq59a8hfRxvK1ca19wUjfTzoE0NaptAu6tcLMrZdB61rnC1rMRpQky8RU4aJUjLVG4rv5PLHTf/KHUgGKpOICEhSAkTgHXNv8pbahJbKW7eV3PV +kCyzpRW65npFuFW46KluXcVUaXVFL1YkVXWrOVwdElcNE+otfUaM33PDXJT4XfZ8IP0Bpfh9otLo6LKTOiqkmxDrjWw9HNIeuTpcsUcSdXDcf6H9J1dchUNjcKETY+sKChbF6UtlAKHA3gYINEHKdMa0fUsl52cVvlDu9baZJbitw1wrPCfUsnXCc7PWpDAkOQ1XH4hnuhfTcbYpa2n7YV5+thp1s3my7etd+xXZeLF19be+uKt/fio/2ot1NoSk -pmhLmQYTN1NS7CckLyVXsMmHuo9TdrIk+7KJEgePYnuT2p709me7PdUFz357C99TS9b0vSOITMjoKE1c+omWvqplVq8VhACvC4BMg+AK8LUAP38G0GAOZwCPEXiL8OIhMwlGbQeAf4SB3+DQ7+XsiJaT4Z9DGWuFEq4541WWkxV8tAqprDDTG1ySYdY2r6QVbOwtczo5lQrS1B88tVvsR7RShdlbcch4fn63zhwewHEN5wiXRRXxR8a8oOBG2krx +leEt11lsp+XQYdZSJ36TEKUVMyAzQKt2aEO2NGFeKfHtwrrrGLmk0nys3UCrt1OIFZBSGWTNSQ8iCnCQHoaYESmCSq30ubwF4PqSF8enpear+0MSAdaexvMDsz2g6AUdehvU3pb1t6O9Xe6oD3r70D7qmue2ZXhOGMSTAU3qyDeXpg0O8q91cmvRACvC4BMg+AK8LUAANaT25yioyCPEXhDFYQDypyTouxkLIV4yYtcCSFyS5qT4O9KyWuC4oY4S -tRUrWREfcFALaVhs8dQbsgNijAh6Afqb1JGmAAZECGm9TUAgAcRB+pk0iaUuokA4n8ThJkk2SdakUmN1CQp3XUvwVKr91V2z3cbG913aKj2qgPdHmpMEmiTpJ8k11PenA7w9oOr0uDvt4DHY9QxwgIQCNDVBF2toEGfsEzKLtVs5wWSLaHqCrZ8AouovVuQj6kZMaik5yNsDj7BFYQlweEAPOYz9wJE1GW6CAU8o3RBRyhrRS/i87hbryOIbiPGt +1gR0XYfPF0JU15HWjeXGxv2Jt4jiJpXU/pV0v7Ej+WuKZfMLbXztdt8lOk6ulm4A+yeR7Rq/OHAOJJ1kB6KLbqPjHlAiuSnCQ0dQNkmPdvuE7Z0fCEHq8lF29AGNJGnTTAAMiCTSRpqAQAOIgY0hafNMvUSBxTUpmU/KcVM9TlToxmJuMdNW9L45icmY1DQYV2qFj7EnPabxCZqnpTsphU0qcGm/SVlZe31eMLg3V6phhAQgEaGqALtbQ0M/YPGQ -8iU7h9y+zhjwB6AnAEAgaRTn8sFCaBIzPATQN9hTZsbl9lh9nRVra2vHeNHilRrzsrVZ1BdKPHRpoGeBIiczjFa0crDJYn7/UXkD/JjJmq0ZXxAaYIn8B7WwntNiSybYkgHqurGRJmngJOnqDxBSAxAPQcAaRMjqgxY8UKPEZ1YcHBjBcEczADHMTm9B0xqGeIqMi3D5hdkE5Y4nEzHc9z9kBIG6b9E9hPTbYlvVorr3RV38RKdLSRu0ND7TFmVR +XaLZzgskW0PUEWz4ADdg+xcsuRirfYtglhn47CEuDwh+EjGfuMskoy3RgC9lG6EllzXP43OeW48qhM5ULzOmvkEXSfsRNO0eAPQE4AgD9QxtpdgoTQA2Z4CaA3smJ6I2FNiOImsTOnPFeiO0Gf60j3+wLBEvJXRLNAzwIkXNuzpEsMDJLEAz6i8jv5rJBU6jLbt9Q/G/giBkBS7rAXN00DAaogYopNY+aeA46eoPEFIDEATBJB5o2QeTFjxQogp8 -yZGejOxnRBk+hnbcaZ0c7StBa5femd3m5nqt7i2rQWYcN86fFLh5FbRXLOyTkRw1TrY2voFwhW1fhpKGhtU2ssxEmfPiOjphMFS4TmspJSOxSUOaDgPbUkLebB3+NfBGJ+qX9uepGgmAs4eoCuUrP1UrdQQxoZxdIDcXeL+2x3bke3Uu6CjaTIo8jWu0boyjvJxOegCVMqm1TGprUzqb1MGmjTbE37VEKEtcWmAPFvizSB6Mg6zVUeiHfKffVDHN +It0bi1iLCdNxm8zADvMPmTBrx9LUZC+E7D59ePJECJhO6dz7ICQXM/GJ7AFnmV4BUhhSCzFhRew9W6xVTFLVeTI2e4hs02ZbMHia1MuutVEbbVKDm1B8hCn2dV0jb39wS8bcZ2nMDrZzzwTScSIW0m6roUOJeHqu3N0amRPnc5r8u22cnqlrm42YduQGe7MYXbfHp+b2rfmJVITWIUaCYCzh6g05BcwMfD2XaLq2l0gLpf0tva49XSqXsdOQWZN/ -gnIeoMLC6AdBEImwOmH0GcB0wMIHATkPEBaAYR6gwkaY5szIyzG4tQ8KeDLLXhqTGLLGJuV8CSB2RlhKJdYkwNu4wh5htkS4KSD4jAwDFPKEM+TInHhnhBA4fYNgCoT5axBNfXALUGIBHAegPQO488YsOgq1xwI1q9xvX3vHN9Xi7fcWcQuibkLzweKWLpRHv7Z+FdDFTlldZfAEQV+p+Syj5SvzCL3kIlNeW2CP7MTummkf2eFYf6hzQx0gJ0H0 +tENQHXMcqHPsHV2e9AN6d9P+nAzwZ0M+GcjPRmRJyOzS6kNMvmWDLkk0vT6uEXumCd7YiAJsE5D1BhYXQDoIhE2B0w+gzgOmBhA4Cch4gLQDCPUGEhaTI+CZ6Ps5DK1Dwp4KsteIZLQtZmvgSQOyAcLhLLEZ1XrGEDsPp3RRcewMPCzv3hO1m1M0nAcPsGwBUIpdEmwULgFqDEAjgPQHoNRaU3fkcTV4xi/ibV0sWxtX+ibVOayPTb06c5jKYbvE -DQZbQfQdZtObs1ATZtc5hi4uZKKsWPiZY0uSdY6BnWLrrWwzaIoC1Wn0chx04PZAoHgmqB0UdjKsmBtDgzl4h8Nf/kmqMCVi6Mghq+Z5SnGKZdG3KOVcqtxmCtJmRnWmfuPsb2r9BIm4FNcVQW+NvM+HoJqcNNaa1KK8s3wbQsGMJdrCB3IARBx4qUbCslltY0pC4MHxDgvtT2YHUv7kl1Ku6/RYXNGz0TkCp/UtuCGUnqYjQ8S4HJwUna2T52uS +JAHDNDnalZlmdZfAEQ0BongykJS/z519GGycMWkueDuTp5i/ueZOV9jvNNx0gJ0H0CQZbQfQJZs+cZ7hbFLBwZSx+ei2VL1L+lX8/FaBsdAQbYN2bRea83mHjIC8aE6cDObq0Z1WZjgUsjOZDhi6JIDq+eT/y9UWBCxPGRgx434Whr0Kphg4rGsTXWz01kCop2WvP7+tA5hizRbhHDmkjo5glakc13pG+1FJmc0dYAG0mFZLygAv9inXM30lmsjt -3exIWlGt0FpyAC+y1UQAHLTlwgC5bcseWvLPlvywFaCv6Wr1Kt56hKbD1fSmL1luU/9KGPYBOQC4IwEYAGCVATgMcFoBQFwBAQKAC4UO3+DMuD05gZpqPoQKMgso4+FG7EQSFuhspOOEiBeCTsDFUoCiqLFgb6cBj+n8QgZ4leTr6ZFXz4ZxnLaBW/Mxnosf5jNQmaTMpmWrwFjKpmaePd2czFN/eTVsPmwWabjh/nfTdcOM3ngda8ayXSP3Sbpr +pSFQYAS3BR5kU19aHa8mFL/JuG2hY54xaaD7U6mKkJVN22LqllyOaQoNOTGq80xxy7MYqHN4Qdlp2vUlZStpWMrWVnK3lYKtFWSrKCF1Sjqdt8KXT0V9ZZXoMOzpOQC4IwEYAGCVATgMcFoBQFwBAQKAC4XO3+AisiU4zazVhgCTOAGjboNIgkLdCZT2tlk+NpElorJS5F8td3Ys4DFLP4hyzIbKs2zfLUS6SLzZiLORav0S6OzPQLsz2YUEbWhb -Da7sL8ApCAFHoLZxjK+MDS/BDzlguCN2Y127XtZlhWs4df0QFxMAapj3leD/AKtrrus264vSDGnAEQj1yIvLfTTe3L719sbHfaR2zHu4eIC7sGkHB3LKBWkq0+/i2W4M8Ul9YuxFQfPsDewN0XDTZPRslWOrZir81Gebu42ar+NwC4Ta6s92SbmFEhwPaq1D3oLI9sKeKWPElm9909iTXPdZsSybxLyu1rdEfkRLCZr4tK+ZAuBkWRbR98I9rpnO +Cm9a6LZvFbXkjrF3a+xYOtGDygc5odadZJGeaLrFIuk2NTWQ4h9b25gFWJa1mfADJ8++wVyqQPHn9t31/kfy0vNYGAUmAf057yvB/hpWkNsLfVPNvQ4EQqlnSkjZTsSBf7tof+4A7MOP4jI3cPEJdwDSDhJEpR24PBdMh6r27bwTu7mswuBU38eKB5v4fcnD2iLv5Me2RamuHjKL/N2/avf7PL24ji9hI+vclspGh+ApCWRxb11cW9Nh9vi/LJ/G -666LCON+7LZYuf22Lhlji8ZZOtiXNt6eWqMJdEtx3ZVB2oOXkZ3UyWY5Ot4iS0sUsG3n2eQ89ZrD9sB2g7IdsOxHelbR2Wgsdx2+0cEtKORLJl1R4+slPu2ZT5q6PZDqd7ochgbITYNBn2AwBJAi7XcJUDgDrZ9gIAyoM4HLKwbzT+TUEqcBChKYViLHHtjneihmQiUwa8YvCGT7enBMmV+jDlcEf5XgzOh2jXoapnY2qrvyvG6BTqsNWmrXd7M8 +grcULcGlmUbBAdHb7Hbdq31Z20v2jb3g/lVDdAeZdkxpwCBwjeoNI3bbKQkyzpaYB6Wy7SQ2O7VDCtmOLLupj7dMj+rPrE9r6qhQ5ebZMSqFqvP21Ms1hp2M7WdnO3nYLtiti7LQUu0Fbz2O3rHpjoG3Y/A0CLWmay6DRsq6ZXGA1Uw6DGyE2CQZ9gMASQAu13CVA4Ay2fYJAMqDOBcyJG+MyRkTM9g3I75zgscFSz/HKr0UMyHinsTDF4QE8jwy -TceNgWybEFwe6iypt1a4LRZwWUNZ+PT3vrgU6s00UmuL2XOAJ4MPg0/kO4eH8u7jK+Nuixja6XZ8i6LYm16b9r5/c+/YWOu2gs9i7cSTREsQwDR2M25+/iFftxXIJcjydV/desmbSA1z/QLc54B0cz7v15HZRg4giZFDw8C4GcCDNg2SIxTmNbvYRDghB5WqeG9hZDSUMEQPN6u2+dDMfn5OrT/B/+cIegten1hh46Bawcr6KHCdSC9Q7Gej3wpt +bS6u0ZLgpIPiP1cBXVnhBO4mh7lC5uTXxNjDma3NYWtLWWHK1zxcLZDqC2uHzFjeztYnN7XSV8tzi4raxvQ8lzdRFcwv0usjqK6NpUFVMRKMDhbdt0PMfRnVlObDbXJ9R+5si4XPNuV5wG7aE70LtlJNEMxIgL2xm3tH+IXR5bfgXW3oH8WnzaQEBf6BgXPAe4sfdOXIOfsHEQTG4eHgXAzg3EZuyRA6eFrfg2wHp4Si9Z024QDNwhgiE1uC7F5x -Nie98dLPT3jTVZ+zu1xvGJpKQ7+LEXioOAb8wokN/4PoVG0/yKLz+hE+I5uvInMYrz9Ge/auryO4J7F9yTyvqFK2mTCTFk5rcVXa2Mh8lrk9mXMfkK+ToT8J5E+iexP4niT5J6k7YBuOdXqt0PbnKsuFz+ytlqHUMYoB/gY4CGBAPUAQD3AEnzwZQPsA4AUBVsygUYJLR4CT8Qrid+DcneugusPgw8NUsfAhLv5CnC8YkJuE+C379J4a6p9lfBt5 ++9m0icwIzOeb8zvmyeN7OsPVr6znxas/Eav7CTY56WySa10ZGddhzoR4rZjOLmjdnXH8XGkpBv5/5U6g4MVLCjk3/gNR53Wo7c3yXobYDmF5A9i0aXHt9tzdiFbjtEKrLn2myy+rsv0SFeJplXvMfhoZz3LEALJzk7ycFOinJTq8GU6MAVOqnSOqJ8Y6hGRX+FAMnHc6Tx2XGYH6ACgH+BjhwYEA9QBAPcBKfPBlA+wDgBQEWzKBRg/NHgDP1Kuk -XkQDT98+ccpzEvW7nDLp41eatAW+nGZshzHX7v0uRnEI/jWPfgs76/dZ4ka8FZZs1mfryz9zZ4eDD2RDhHNxa7w7CmrXREFKEHDsCrsGERHT+4+yVNPtTu1lF9kFGyHqCIQEAfwcODZsNEKvZz6Jcq6q+gnqvv7J7s9xe/2BXvtzG3chFwWeWKKV4kJN4L4cgdbAEXRbuECW77BlvKnFeOPgjaxcov7oJxxp1TtKuzzG31V0lwziIct8hnLMgZzS +byr5G66E6w+DDx5Sx8W0pjMasLxiQm4T4HAeY1EyBnPV4ZxcGRBjPqH9itrZy8ntO1Zr81xawLbxNL2NOK94V1s6kaqb4pkr2Wz/u02K2o7irs67874Rrm8svwKeHbjODbmh+z1rWSSn+yM79Xqjz50a95a/Xy7WL2wlMLZD1BEICAP4OHBC0sGQHZspS8qy1f6PlRCLlG87w/dfuf3hAJB8rS8NxoSIihcyIsWKOTjKrpLjt3CC7dsc7WK+wGo8 -/As7jRn+Zuh/zLZciaZnI1/AP8clmvAg0mSaKIptX5Lwl3fN+kEVhReWRhbY245/CaotCaaLUtk6iK9kfCjnrXPDx1q6RYCXnb0nnRxJaO1yqcJxus7TXhNe63TH5r1vOUZUvMDA3wb0N+G9WyRvo3sb+N4m+TcoIBTij6T22RGWeuX1QT31yE8lrMBNACABDMQH0BJvMARoW0OcA4AIY+gET+IHTHcMpu4NYV6Pmxg2PmQqUMxGEFZEKfsZkrV2 +vpuBoGX90OE6y5Hsk5x3DDii9fsiMrPNn2JwV/1E4f+KO1K79XWu+H6knpX5JqbbvYkBzn8Aytn8a8H9RpJoo5m2wUvHuva36Q+WBEC3Aq3ALV1yB9de/aKXbrYbwH/LVbcRvCmejVj5FZY9tcxvox5EzpY6+ceGnXX86VPaaZtXeOLTvj8Aum8zfZvc3i2fN4W+Lelvy3lb6O/sd6HWuEn8b846k4mGIubj/NZgJoAQBwZiA+gCt5gCNC2hzgHA -NReVdBsXKOSFbi4FW4uA1utDhVlD2GZpecML3iaRNCS7bugUmrizRZhS68kgXfJWZyl726ockeYLZH1lwhd33aNp7OQVh5O9WWJYl7s78amqIkME9V+CIZjz5yVkpJsYdw/KTu52tiPJRUOw9wIaOsFxJWHQTkEIHqBGAXXD96bU/fVbTFPxj7w3d8/c0hO9vB3o7y66/eCG+E/+WAhiVeCZILIrwQp/rSPjGCW4mX9K1qkBgkD4Cg4LGc3LQcU7 +ODH0ByfxA6YuRqtzU6qHvG7BLGFeBSDeATEYQVkZuz8CQalKjFY1lk/h+uiJBBnvVkZ0O8occpxn58Qi6O9/LfvEPB0Cd8w0WszMZms7zmWw4XccP+Xm17Zzw83t7Pt7sr7I1xZyCiOc6+7uLFc/yM/VTRthwnsBN4AJoFH9IRJNjG+EVSPnMl42+fw/tX8v7b74VmwA6CcghA9QIwGwD/ciHNHgH2G78EgnmuaDKb3Vs99e/vfPvoFqnYNceXpE -iruhtD45Iq9G5qvxh8l+27a+duCPpNul+TY6/9vqbLL8e715Hf4sRrPwkqOLvYdUtQow4ZK3N94c7GCLa7v8pjOTQhGD+e7+V4/cVd0XfgV3sTzVPVeSf0AB7NRxIFF9YL1bBrlT3dUKMaeTHCl7T4bYKaaqrHEANzx5688+f6gfngL0F5C8F7wvrr6PBL46Y5zPpEe9hZ7aLkueMB+gJoOZAAj1AFwiZyoPoEqAgy2QLQaoDHEqBshJa6TpO5ad +kSrwNJBZFeBVeFkLVgPHV+4g02TagMHVXAUHAc6u5DWllzWbZdO1+v+uLlzR55duL2Z8uqHox/YeDmWP4tsV1Lb4eJSePWm1KaoznNKcSoWPRbSpFPgDhvgFg7c/ZGKlf4rWhNj60aRu+FLSDx28YgD9A9irDHF7coPuxtdPpNf9rl2/qe+3Gt7Lntjx5+qB0uWmF/tiANF9i/xfEv9QZL6l/S+Zf+9OXyJwcYkA6/Mdcb7HWF+TuReph+gJoOZA -XimQwcU8ZxEl79V7nISeIIkdEdyIwkQfOXxIDU/y/1OivVMWu8YoxvNOsbBwHG029+Ytuen6Ppr6Q6x/kOe3uPnq8PY+P9WvjlHjl8hduiH6lnfCes43X+B/BIS8s7hDN5kdy7rBXbTJKFQ0mSvD7u79bzAYM0jeZjylEFPf1qD0Bqo99h57Zu593uKQVkZjB8/E/Pufn/r8yMv81Do8QXtY5HT2wAL8JiGeXu6IU8pRx/z6ifuG3B8xfjxEPuLt +Aj1AFwHZyoPoEqDQy2QLQaoDHEqBsh+a1Tyu9i9Xh4Ou54iOyBydMk/A4gut+6HVzBKY+54fbi4K18Hc8HmXQ98j1M4l0cZxrsz1E84oWfTvlnfLpd/T6m+M+ZvIrgk3D04/8PNNkslb0dduiAHNvpLX8zt+9b/A/gzFN5yypNypjbdaSbysZLvdXfPrXz+g3+ext/Pv75QZ/rUHoDVQgHYL0LUgJNdQuKQVkRjLp4Mf6efz8GnzUf5P+agMemL/ -EJlpK+Euyr+ftp3Trxm2Hmj7EOVfjS692gzjj7DOePtzoDuhPkO6DWfXuPzoAmgOuC0eN4tjCqKzci2arCTPl2wtwGhmA48e0rnx6UWfZsOqSO9+lPCcQ13hJ5myUnjPoRCbri7Z6uh2lkbHaMvlXhGO8vn36Hq2QkpZY0ljkej2+jvs76u+7vp77e+vvv77G+tnjPr2eT6pZZOeNli+7lAMAE0AdAPQPoALg5wDHCLs9QBhDqBkgJUAcA+gAhhX +6+Ya7b/5AYhwQ4GX53QVXqSjggBflkRF+RMrS5QgxHgp6keHXqzY1+vXtM4HA3NkN4QiVFvR5zuYumtbTeHfsz79+xJlx5Suctnx5/6e9uuDCeNiNjCGKXcue4zql7oo7AmmDgbYqer9igbqeCvjDa+cJ7nf5wuenv7qGevPoMbROyKsarvaUck64uOLrm47G+6Sp44OenriUA1CProH7B+ofuH6R+0frH7x+ifm75Bedrl74J2Zxm6aVy6Tn+ZT -gxAMC5beSLKm7Re6bo9DBQO/MGpBEsRlH5WmYqtIgluQaBiTbAcVhlYp+lbrlYFeGBl/7vkWfmgSYOmmES7/+KPkX71Wrbo17z6zXkvqEeQzsR74+4zoO6TOiKow79ezfvRTcuEhAvbt+Y3qs7jUgaHdA+QbHuGi8AYangFo4oCrdCCO21gEKc+G3gOYMix7sORq0lQEcCaBk/Kd5PO53udi8Qj0Pm4C+EBvv53eGAn0A9BfQT0BWeZ/ke4A45Av +CMAE0AdAPQPoALg5wDHALs9QBhCWBkgJUAcA+gHBhXgxABi57+EgGVa1OFVo9DBQaEvYi2Q8JNsBVe5Alxg/A/qG3Z6OfTiX7Ne/bn1bteLNoNaIBrWj5JUeczpT4PwU7ks7jesmpN4tqi7gx74Bq7oQGD+ZJpz6Um3Pj2Dj+n/pP69Y0/uCB+od0D5AyedLDAoS+dlGSBrIDKs/ab+svtv5Puu/n9baSjWAXB9AMtJUBHA1gTPzAOl/lo7rUvEI -MLf4a4C8pcUEWglZx8ngT8DeBZTi/5JAb/kjY4ucVug4/+9btgQYe7TgQ7ABkgqAEdu4AV26dWYAekGwBBPvQ6Na7Lkw7N+g1EN61sN4hcDxomSGJSD+qhF6bghSsior3QEiIc6rerQVP6Cekti863k4wWiafOi2pq6MBsnstrye2RsyaSWzuqdpy+l2sUb8BFrrp4m26gZoHaBugfoGGBTQMYGmB5gZYGyBW2u66+Obtpb4e23rv0y2+aHMQCS0 +9CMiPulbKP+d2BB46s0wWyCzB8wXB6BBnkDsJf4a4Hc7RQTOp3J+oOqtEG2icQWhY0uhHnS4wBTNmhZC6BFpM5IBdftkFN+bZlT6meIUix4XiDPiLZ4BASiz68OPavs6ZGy3odbK4mgAyiUBh2BcAxoaSNxSQGJdGhYMBTYJS6+ox3oMGsBhrnJbu6kLisGnk6wSKqbBAgSZ5GewgdG6iB4vI+rWWVnu7by8tnu67MS5vj46OqRKFYE2BdgQ4FOB -TQPcB/gnILUCAGYoYwBDAbACuTPAGEH0BwAyeCabEYtgcr6gkxwCQL7OJIA4GKKnHOZAkMMWlPBYwXLDB7sQefGXZBoAZpl61uBLlcECgTdr+aYeNXg/CJmPQMmapmuHlAH4e1Ltj5vBe8p160OFagNZTOSAarjN+iwfS4LO0/MUGjeKzpLIxawIZcDTeT8utZtmsILjj0eLQWEZa67QQdagulzgXDnAC4EIDnAiEGyB0wYfIMFCeLzmcofAtAVM +LgW4EeBXgT4FIsMdrSFKcNZN76umMVqYHA+xAPzRNA9wH+CcgtQEQbqhjAEMBsA05M8AYQfQHACJ4sZn4HVuAQbW7kYxwDqovOJIEEFIe9rCh4JAJWlPBYwySgkHc6PdqJ63Q/dvV7DuGQcEZRsdDhPbUeU9g/Az2c9oUEK6xQfRYbOWAax6iuBAeOYy2k5gc6kBD8giHSKDQb4Fbep9grKAkI8JxARBmITfZlGf8lxAY4onjL6u679h5o5hEwZ3 -GcGJmsWGlh5YZWEAO0fJRhKEQ8Fv5BomAZ6qrGRkLjwJARoVm7SGxkj6xIOYUCg4vmE8t/51uDdg/COhLds6Go+DwV6FgBPoS1592Twe8F2GcAV8F02PwXkGuoqAVuYTugIfYiHAj0HsAbwLZnZAdq3wOMRHc2Yb2anOFAaAaIEjGPWETBCRjK6K2Rll44qOcdkwHYh4sMo6mWattUpKe+jtJaqepIYuicmJRmY46eylibZChIoWKEShfQFKEOos +QAo5wAuBCA5wIhBsgdMOHyLBELlf4rBxdB8CA+4Hs/43GzYa2HthnYUcGWh//qZCjElwAGx9gSWK07OAfEIkD0YqZg24OGdkjcIkOXAjhYUOaQU1oTOy8oGHEWjZuPYU+YYbIIYB7fgx4ghXfmCFlBEIUmESuRARu77WcIfx7oAiISBa8WxuuI42IhwI9B7AG8CJaSec6le4EgXwNsDHc1YSeYm2PHnyZQu/YTp58BD/jSFWuJjmZa2OFjvSFaWs -ofKGKhyoa0am8cgeBFARkER64W+0ptzSTKqgRICS0/+qyoUA4bjwALgmwMoB3I1QGwBf8PAH+CEAgfmm6WmXYcIZ7AyBKQwYygaPqEw4ppPARkgGyH6LluAQXl5BB6fqjaZ+lwYuHXBMQYX4xsxfm26PBGPs8EV+3bruEBhGQcy6HhFHrkHIBh/PsAgR7WhNZLBcYTO5lB64FqLhaGUuCFeG9Pux5o4PgWkjEBoRm+F7WB7rP5Qypch76YAAEIAY +TuY7O2Fno47USbtknoyBbrl7b2eZvr7ZOevIcqGqh6oZqF9A2oXah6hBoUaEmhextaYYRMTlhFxOZdrKFGBSTgm4M0fvjsE+a/NAQZSqFALm48AC4JsDKANyNUBsA//DwB/gsHnl4p+dTt/JmQhDhwgso8fI6Hg4OpHAR9B/3luGJB3VmX4DuozvAHpBxPhR4cuKAY34X64Rswz5BM7pgETeArqCFxh3kbN7se21hrrruqYbCHphUSqP4WOsMHu6 -xw4AtWEoh6rNxD4gqLLv6C+Xzs9jTBaHJFHRR2GJMIqhc/um5dhJkCshA+MsicrmQOdgOBJAxoVCByRfPhOFzwGLrVHv+yNucGw+ddjn4I+LTtpGrhzGjh5AqeHqzq+hlfqZEMugYXX6FmIYTkHTOTfqeH7AqFoUFKkGFt2DpeDuJCQphESo8AbRvkXO6WQLppsivhYtnK4S2zzolHL8fwA2HpRGrqRHK2eITPoKeUvkSGsmRrup5khprshFK+Fj +NBh7sGDrgaIWJ5ecdLHbhgRsnojhxBp5LBFv28EXWHjB7cj5pR+mAABBEGMcDALdhiEetTcQ+IChFUGYHlsHI2w4VMJFRJUZhirCpoV/7YuVoSZCLILcPCD26w8OZDN2A4EkCuh0AbdDmRkAc8HQB48LAFMuaIAEYBhdZt8y/BrkWiboBzDjeHxhd4SUG4Bj4Wx53iQUQP7s+JAb/oZh5ATxa7u0pAL7dgaPnbjMUB3ilFKkJ3nliWQ2ZusjZR7A -qr5HoDEZyBMRLEWxEcRGEFxE8RfEeyHqO8gRZZSmXrrREH+BcPEDVASbgBAcAiAAhgdA0GDHDPAK5F0BsA+wAhiZI1bJF4ZOYLmJg7c6fBiRpYhMnFbOmMftXq5EiaHiiZYZoSjpZWykXU6FeakRawaRmNrV4mQ2AASCxBMbE1YR8UIIkHmGyQVmyteZfpQ41+NDhNETOU0WfIzRvwXNFjWF4TGFt+zkYNjjeLKNorgSpgrwG8OMtlCELUOGj8C/ +fBEaer5tVF/Ag4Q1FGOsQg7YMhwUkyFjGLIQnrWe5ERyGURHrtyG0RPrpJGcg0kbJHyRikRhDKRqkepF6Bggc6YQawkb76xWZgfFbxA1QBW4AQHAIgBwYHQJBgxwzwNORdAbAPsBwYaSFWyaRZGiPpWh+5EOATqd0N5DkyDVp3LMUEONZKWQDbEOBpYjXqX5DOKQZX4LR0BF17bix4ctFRsPQCZDYABIBeFO0i1kuRQgUYXT47RsYUK77RiYRUHJ -ATMQfZHOojrmHT+m3mFHGaQxkAIq0kgABBGAejPFGnRIwXWEpR4CnLZXRdEegDOx45K7HuxHYYVHqSpkKFT2Q2MLT5buzpsPCw4mMscqKGw4DdzoucQBshQgQ4Lgzd+lIAVYvcC4TzEPwPQHzECxOkVPogBG4U8FbhKQX6GjRfbh8GZB8AdkFKxYYaO5zRzNotHoWbNgvz9g0iLiJeReFtUH6khFvfrggciuP7Wxk/rbHIhXsUq4+xl0ViHNMAAl +hIUTCEyu4Ubiyj+J1r+HLmsUdt5n2xPIoTVG1gov4qE8NmWHV0aSPSq/AUsYSF1GqnrJaNGO/gKKYGj3rCjPAUtJIAAQRgOowVRZIePTW4A4Sr5+6rYuJE3G4ArHHxxkHJ/4NhXMUZKmQ3lPZC1aqDHBbgWw8KLFoMXcFiiBxbAibQixayFCCSx/qHP6UgA1oeHdeXwZkGCg6sUcCax5YGgG1qm0QvY9+2AUx5HyE8QmF9+5sS+FVBHPsP7wh5Ab -NBi+6AKvEWorAXo5SWJIbJY8BT4nrYoRyvsbZq+CMUjEoxnnujGYx2MbjH4xRwITHWebRvUKbxG2lyGOefRs56BxEALuALgV4JyDHQLQIGgrkizDhB0wc+BQBCAQgM975RoVuqESKahC8AhskqpnwEiCilCDHBmMLIbEgG9szG5etTtW4hBNkuEHZaxcWKhI+VXhXE18dXicANepfkkHl+w0SZGGRe4b1b2GWQYrHOG7caT5zRq2K35OR5LC5GSy +LLreyrnKRrIE8FxqdBS/n6i7m1LFooVmA2Aa4PuJITfKVRKcchEAx6EeUCgCU0Fr53xHAA/G6+REWZ5fatlj9p9KHthREm+Tlj7YFeygQehkxFMVTFxetMfTGMxzMazFHA7MQF7cRT8S/GGBBMSMKUGFxiDIkxzvLuALgV4JyDHQLQH6jTkMzDhB0wM+BQBCAQgBD4dR4dOaEFeAJHZovAwbPqrnMtkMnxQgSQJFAMo6DM86mKfGDLHl+tkQeHzw -DuLnaZ2oJvLobWBKiPBEoUuodEnOIUW/pORBUSPQL+RwKMB0wMAMHZdInscMELx34b7HMWe/gHFwxqieomaJJwO0zWBO5qCSp2JAmxxHCq1BU4geR3Jgkcs+DHs6aKgmGD43QUIJD6HC0PgXFE4Rcbn6gUFCQdBUJZLuuEDR3oUNHbhkAf6FjR5kd15E+w7s1rN+V8gCFQSSUhMQd6ihttE1BscRvyUg/egOB0sVsQiE5h4ttRYJR3sfolLxTgli +I7n3ES6ZPnGjaxw3j0CjerVF5FFBPkfeF+R8iQFGHROzsFGvhoUdbFnREUZmGLY2YX9ZNBL8qGh+ox8A3bJRS/u/jFSJ8BcB4oZup9FqeuUT84FxBUTcYUARwKMB0wMANnbtIScb2FXx9GGnEbBZ2pnFNRBcG4keJXiScCkS+UWBY/YDKI8pMaezIDBw+S4cdwcJmME4bEgj0ETLY+N0FCB4+dwgT5dxwukeHCaJ4X16iYEiSPFMOvLuPEd+RsY/ -Y/xkHKkb1Cpvkp66OGtpwFw0+8W9GaeivirwCBJQKfFHov8f/GAJwCaAlz4ECVAkwJxEbdIvobSeZbm+pqsoFe2JiXMBXgHQPcDMAFABhBx2g5mC4Yk7GI8BEgEiOpIcQuyFQL/AmVpjJscdyhXrN63rHPAVBZkKfAPiDHoiAcxc4e+RPKKBK8qFIfbHaGaRTkrcFYef2FmpixAUkZFMJrwQ3EwB+4Z8HkezRKG6bAzELgDOAbIL7ZQAxADHDv44 +qlB8YeUEcelQSdGbuXPrOb7AT8uvE1sTnNayYwlkI9FL+Q1D7FaylIAfrC+LAcHFsBDibd4/RivtfHpxXRoDHq+HvvnGGWyQp76fa4ga7YG+FeDDGeqRuPIHURgCd64Ho2Cbgn4JhCcQkz4ZCRQlUJXEc9La+GybG5CRqCYm4V6xMcD6kAV4B0D3AzABQAYQZdtGpdRSJCxiPARIMshGSHENsimS/wF1bWSTHJIgT6ZSkCDnkbQbpFjw4nkJaCJl -5AhiIQktEaADB6/m3Ek+IsqgELgkYfM48ul4Qvxb8LyjhZDxH5AP682Q/quBZ2ihIDByJ/Hn2ahRQxkhgnWzEDwB9A9ABLCnuHAKMDOAktDHBkc/wfmHF69zgNiPONYYZQ8cIlEwKpRkwVdHC+EAPyqIQBoAgC7gLEBHaCqt0fqmGpxqVEAGqYQFBHcAHgRKpEgUqhSAyqkNLvFa2jShybkhp0uqqCB30ST46q7jkHFsqBqcEBWppqYaqu2H8ZHp +ZtATAqyBGCp5IPbA5G1+yJnCp/BvNmlR0eW0f5Hzuu0d37ghB0bFLiubPtx71E2bpsDMQuAM4Bsg2AJyBQAxADHBv4fZHBiIQ/NEaALBF/rx7aJtsZmELg/nldFiORid1Q/KoKkyayOVuPEFa2NmvSAgm/UW5z2JocTyZ3et/OUAIYQNsxA8AfQPQASwH7hwCjAzgPzQxwJHLImf2Q+g/i+JywRWGMuY8DOr3+9UbfFBq0qohAGgCALuAsQBdh6o -8hf0uskSAgqfUDCpoqeKn1AkqdKmypf4PKlKJRYp2Gloi8D2AfAfHIHiieIHnspRUbCMPBTsLpg1HoU8wvbgNsL9p/ixU8akiB4g4fp4EpIXydn6RB5ODTp5aoKS6GN8/USvLgWtcZLE7hLCWZFNxFkUilWEKKWikYpWKTil4pBKUSkkpN7tNHcJFKfsALgXLlGG0pGsU5HOcQiWNTgg5IHXSzeM1EjjRK5IJ8DRQTKSSrTxa3rPFOGqqVxDLCPY +gxbqmGnBAkaVECqqYQIRHcA2qrqpw+/Voap7Jn8Yb7J6xpnDEpy5pl65uWNsQBru+6AHGnhpiadGlqq+MYk4fJokd8n++BcJan1A1qban2p9QI6nOprqX+DupBcfAKJmBaKcKPQ5IAAHkgIHuh7kYkKTsI5iUULjLfAHyjsK24JdDo4f4wVICpIgeIFPDAwkiKzzyxZauSmYEYmlSncuNKdeF1Jt4RiqKJJsc0lPh88eylSunKc2Y8pfKQKlCpIq -Ovy/hS5r/LQGUXFKKVcZXIfQVcT4C5D1p6Ovy60oR1JsRgAbaeH7Awdyszynw+BodilETXCaLEGSYu1zkG6Yv1w9Itov0ggopAJsnbJuyWZZZG2AIsjqYukh+K2QDbA7jrgpwFXZYIhyPaniq0VEiCbCwaMGonI2xGaLJihxKUFpiDRP1wWitBgWKUGxAHQaTcFCCwbQMbBrAwFc38SJaLsNsBIiOgL3n9bOAnybDgeRj0OFr2mnHGJi4gx8EGyz +UcBipEqVKmbYp0Vu4KpCruIxnOPopt7kiU/i7Hgg06k5IEhuqSbiw4tunP732qssp4zJxIWHGkhfibCAHCPYFvzLJQpudp0GowVqJMGOoqwZ6i5iqumqulKNaSrEYANum7pe6f8p4ZbZF4Tgu+ACfQVILopIYX0ShjIY303op0h+iPSACi/J/yYCnApUYjMjYAcyDygWSEErZD1sWiqcDHxWCPshppOqi5KIg7GGSCkg9iEcjrEroiWK7EzsQoaD -eSNkn6NRFwCQLZxgXHGKBJhpNzEhJvtNwyABHTuClFaBkdLH9OMKeCoJJjcQinNxlkcikxmi6Zimcg2KbilHA+KYSnEpu2MT5pJc0S7zoBV0AzG58OwFs41BFdvw4XpGWLgnlJvHjbFVJc8bonpYohvGj1JiRtHiAAIiC9SgAAIggADwgY0vVn2yXUoNKAAgiCAA/CBjSHWb1K3qNWc1KAAnCAjSvUpbKEmOJvVkdSQ2agBdZ9WWNIuyvUo1JjSg +cWUjIYaGtYmoYTc79JoaK0M3M2LgoISZ6YFwZlguw2wyyI6CQ+uNjpkQ4eWmkhkob0ULEoOqYuPqBsCIJNQ9ujXiM46qrcX5z5ixSYek9eoiRSmhGuBP8EXpY8e4rAhN6YykPh96SykjmRJhbEaJidC+ncpuALyn8pgqcKmip4qZKnSp/7lomAZ5Aa7zIhO/LvACxT9vBkaw/drbotwY8KljZJaGR4LDBj7hfHJxOGX6kxoN8VVKimEAIAAiICNK -0sHprS1AAAA6HAIAD4IESZjSjUl1I9SjUriaAAbCCTSs2fVm9SHWTiaoA5sr1K2y5svVnNSgAJIgzUv1J4mqAN1m9Z/WagCDZI2WNlbZt0XVlNZLWW1mdZPWX1kDZw2aNnjZA0g1nTZF2QtlLZK2QMrm6zUptk7Ze2QdlHZp2edlzZV2Tdl3ZD2U9mvZ72Z9kQ5P2X9kw5gOdvGdJ+RvBFu6B6kfE6QvqUMlCBAaTZ4vowOc1mtZ7WeTnfZUOf9m +AAAiCAAPCCzSq2e7KDSE0oACCIIAD8ILNJ7ZI0jepLZXUoACcINNIjSjsjKbimq2f1IXZqAAdmrZs0j7IjSHUrNITShegQrUAAADocAgAPggsprNIdSg0sNIdSEpoABsIAtLPZq2SNJ7Z4pqgD2yI0q7L2yq2V1KAAkiBdSY0pKaoAh2cdmnZqAOdlXZN2QDkgxK2RtlbZO2ftlHZJ2WdmXZ12bdnjSa2Y9lw5b2R9lfZUekXr/ZQOSDlg5EOdDm -w5k2QjlzZSOctmrZ8CnboY5u2agD7Zh2U7K45rUhdkE5RJkTmPZL2W9kfZX2ZDm/Z0OQDlERxqssm9GMabDGZRpcpoCcgzwPUiBu2aVYnfuz+DdD4yRbg+lXYTphIqec4PlnHHwG1pMRE6OiiPIWSZOqEFo2zmV1G5abmVcb06kSYCqjpg0euJxJqQVAGsJtfn1aTRG3hAALpuAOikRZUWaulxZG6QQahh5KWWb7AAfpkkGCxjClJ4MI8diC/e9Q +w5L2QjlI5KOWjkY52Objn45dOUTkk5TOeTn2OEgayFkRNqu+qFpZpuMolpWemWlShT6JTmbZ22btky5hOQzmk5zOfdls5L2RzmfZ32ego85AOcDmoAoOeDleyQuT1Jw5oubKbi56OVjk45eOQTn05xOYzlk5nESXpyhidik5iRoSQCiaAnIM8A1I6bgOn1hbxmRhpIzNJZC10yrBV72s99nEDlSfrI8Dv4oxLmrTyeqvzryxHwSInlJFaqwyZZ1K -UlBMZyVmnE8pZAe+GRGtFuqljwmqX7GYhDSUtp0Ka2Rbr8WaRtepB6UuSHqS+0EewHKe9ObL6M5SEVew8mfqWercJgaYHqm6E+ZUrvxVETDH9G38eE50wf4PcBGgzwPpFKJ1ic/gfAPcoeYpWwBI8nxWKdnZDUY4xKcIHcD4czEbg+xgxZd+R8KGzzhQKWQkgp7mXcGeZBNtXGGR46TpyTpPmdX62GbCQeFzp9YFnk55y6dFmxZ66QlmpJDNs36Y +VeE5ZNPliYNJEUsrr0py7qonzeuzimEVZFhFylvptWZ+kNZv6c1nfeYUXKnSyiIUn69JShj+Lv4vdmgy7x/WUj4vRSUKcwtWw4Co5DBNYd9GcBvuBxycUAaahFBpC2QHpB69uY0qPx+epHo/Z7Sq/HMhlnlDFshAyinqchmuRb6+O/6nrkR68ynfmh64ee8nJOaCeF4em1xu+4ZWf4PcBGgzwG37OJsSc4CDgrcFFDo4GMEARopBWuRh2QlGMMRP -cqWfWzJhrHsB5spGsHfqviNdMCaeQ8IUVkzxJWW+k1JGYTi7d5VWf+GCmuJsKZ0mYprdFCmtJqKYMm4prTnS+c+VwHnayqu9FL5rOUbbs5VCs/FsFNJiKb0mjJjvkrJn8SoHxpqlv/H4AzwDWB3QbALaAIYXQPoD2g9QP/qbAUxrAlqhmThIorG5eo9CbCdkLvDGZJ8LswIg2/KiQCiikazEEJwQY5nzwYeWV5/+FVgAFR5QAQ/B6RkKTvJQFQIv +Ch3HZDgmwnFCaz+R8IPZUOS0SNYhGdeZfoRGl6blkzxred4rMeM8S0lHRbSRyn95r6dVnvpdWV+k/pTWf+kdJtQV0nocnWcGDneLcG8BoefWWXj/Ra+bmgkQlMjrKHmRIWfGYZU2dhkpYiIP6nzZLmgHq2mGpg6bamTptflimEpnaaamjpqmkQxT+RMaq5xsOrl/x3tmMqf5f6lozlpyQgYX2mWpjqYhePviYH46mCQlq4J+AM8A1gd0GwC2gcGF -5lwpssUy7JJfOqFmop2eUumRZK6TFlrp8WY86T2SFnNEBKmSVJolB8YXy6cQxtHawzUXGBvyBo2VpSBzE7Pg0ltBdsR0EXO8/uUAtAbQnTD1AJwEMB9YOiTz5d5lWT+lPWjYSuYgo7RTHCdF3RZ6H25r3oDgEguICRCUgUVnfKNsThQcBDwrhR3qxGwREcHweLUWcHIewSeHkXGNwSAVgpw6VXHRJm4bEl1xI0VOmJJM6QkUnySReFloF+eZgXZF +0D6A9oPUAEGmwC8bUJ/gXQkqKuKCxhsYHwP/LsYKaig4nwc+giBkgOGZcA/GvbkkHWRcscUlKxnkr3E15Pwc5GSJUbB5FwF9BfUn5ZxscwXMpZsa0llZi8ZVmD5H6fVnfpjWX+nguNQQraZhsSrPkGaB7s7H5hHFBrRSOBUuxjFSfqPTqUg9zkHHjZu+bd55RL7p1FRx5QC0B/SdMPUAnAQwF1jepv3ofk6FBGV+YNRwPscUxwpxecXz2KeQgWcE -x4TZGoBi7PgX2pyUSbS15hpIz4mxhFpSBqEEiFPEVJwUQAod5s2gMU95hiWlHLxHISwERMo+XJ73RBIfq5PRhrq7rcBvSQr5muAyZSFoRavoQCaF2hcwC6F+hYYXGFpheYVzJBlqiV2eUMf440R++eoUQADQDAATmmABwAsO+UZflGQYOGZA+qd6XaY4ujrEI6KiLcBxCf4KBH4FaoKos7kGhUUMHk2SELt+RfpK1A4VHFARaPoDpZxUOkAq8njm +uICRCUgNVgfwxoVwXkUHAQ8IUX787RqUWxZ00fS5zR7wUT6lJQRqrFjuDRdUm0edBc3l5ZdFo0l7RRWd0VsFvRez79F3BUPlDF/BaMUyp4xUc6ZhC7GIVaqNUZrTL5WwuL7yFlIHZrLIG/qoXXeIwRoU+pM2doVzZdxWparJMvKnimexnjxGMh5no/nERH8c65fxRvr/FyBpvs5Y0R2uYsblAhACEVhFzABEVRFMRXEUJFSRU8nBWYpTKGnGhMQE -qwF0KYnn1x9xYFkIFiKay7NEFANBhwASadgDxAK5B0AAQ45EIC9YlQEYDYA+APQBHAwkJ8WN+KseUCoB0xTSmU+N8tGDqkBINC5yyD+g3miq3eZ5A0orebK4Ce9BfPHgSrwHqIsFpAY0mYA+gJmRVQ0KKQDVAbZJICJ4wsFHDol9QiWVllOyUwBVljMDWUL4dZYbkz5IqnuS+M3fieQ6hiZUIUGODOeybu64hT6knqK+b7oyFJES+hNldMOWWtl1 +XJuLaQCgNAMAA+aYAHACI7UJqeRsCA4ZkEmrjpqZoy4HMNiQaKSFvdv8U6p6KSbSMCpMqPCZ8AugrEcouLs+R4Zk1HZD5aR6d8HpZ1BW5EbRtSa0XXpGJW3m4mHebPHcOpWQvH4lFhBQCQYcAO2nYA8QNOQdAAEH2RCAnWJUBGA2APgD0ARwMJBjFy8Z+HGk+wG8WnOSrn0k2IrwD07fAlujIV8Iq8KsX+pnkBSjGpcvho4AexSnxCvAtoroUhxA -ZbWV54Zvg5675qyTb7fx+KecAAQAEEcBdA+RUKUO5RkPabZw/LiRYbByMvannkZdhsh7R50bhosCexqcCLCYDn2B10zGBcH6lUQf2mR5h/BPomlEKfQnixjCVaV3FFpSnlyxaeQrEZ5TpS6XEAbpR6VelPpZoB+lAZUGUhlpKVwkl5jNhVZ/FMNO+UtwcSrha8ADrCmWnU94muAreNBS+l0F/Ou+kZhXwPrGFlGukto8FRJrbLNSEOXibcF7BbSY +epgD6A8ZFVDgopANUA1kkgPHjCwUcPdrJCa5RuWApTADuWMwe5XPgHlYeVKWaqa5O4xz+8hHaEEuOaTKV5pFqm/ka5X6sWlKB5yXKkeFkeCeV0wm5eeW7l+5TnjIJDacAWfJ6CZsqWl5QGKnnAAEABBHAXQFMWOlCBWmbZwqrr8rnBrbmmn7kvdmshvRa/OkWEF8WXsKYOC4UiSMYVeRQWfcVBY0WjxaZWiUMF7RZiVMppsXPE9FBZRwWesJZWWU -8VfFXamEhMEe6kvR5QGIV9JxJW0rTlbOf6lzl8yeUBcVqAMJW9Z/FZREqFpuZyXm5JmqMC4AtoEMAdAXEaQAtA2pghhCAXQCthAJmwMwBqxSiXAlWFIpeeR2QG1t4x8QX8pA7eBX5BcmPlJkIlql29Htw47IcLpzFvef5X2kxsy4YLGOSboR6ERFYjFEWca0FdOlBZs6Q6VWEiFa6Xulnpd6W+l/pYGXBlWBYgH4Vzfi8bRhhRVrGxlYiE+UHkW7 +VlVZTWV1lDZU2Utlghe+E2xU+eNbUlq8DVqN29JUlB4eYyaIibU/4iCbTlnJabaaFC5e7HLlsyYtleFqAK7JdSdOZKYgxJlWZUWV1hXqaQxdha45q5X5U4VUROkL+XVC/5awqBekeNZXmVx2ZZXx2KCTBVNpioQhUSAowLgC2gQwB0DKRpAC0AhmcGEIBdAC2AQmbAzAPbEFxKRVXbOl+5HZB4od0FZB8QQCuh6xBT5LCkkVJkEWaXkvdu3G+hxL -kpp2QI8dCEUgGMIfCZljRQBn2x8dssGtFEgGyAm0RoDACjA/IH0UjqfEPmVBo7FWgJ6VQxgNU/AQ1SNXhxQkWuDsYGyK4iPleylvaEM1pr5V10ckY+IsCU4U+aoOvhRg7w+BpTg4/mK4YOlrhsebPqryUKclVWGqVQ8XpVTxRnSOlzpTlWoV+VRhWFV2FSVXF5SWRGWAVFPktG9x3AL2AyynlPkkaw7KK+KgK2bmUlPp0JUdHZlTFQwV5lbFUMUf +nZGjlDFUCLMMwYcxW/kEYd2YGxfiowWDaOZawVqJx0fxUzwglcQDlllZdWW1lmgPWWNlzZa2Vkl7ZWQECe+wGLbRRR9jmGGJ8SodikVG5MfGzqh3nZDL5zIpdwYwh8NpWTZP1mMH7FhcTqxsgmtEaAwAowPyBXF85V8AGV/JVA4PF4VegB3VPwA9VPVk4VzFrgLGGsgcQm5glECxXpZYZbkpdH0GYyd3DuHYW5DoT6LRZKYmXCobVciUAhogTvI5 -2OqfQGYlZEVo63RwQpo7eO2jtiVsBXohwHCF3SQSWIR3qTHK3aM5Va4GVRlSZV8g5latiWV1laMC2V9leDEMBRNeTVRpW5aoVrJs1QXC4AkgEMCIQ+gEaAtAXQFeAEc9vrxYUACGFkDOAb8Y5WWFYLm8DLI2MDdAf4vjMcJuBPlUeTxoxtYmjYMniVDVKR3hapHfJxXpFUfcgRQX69RukfEEl+3mQwlUukFcwmvVtpannsJLcZ9VZV31chW5VaFQ +lvVe3nKJvfnmVsp0ITv7gEo1eNUiVU1TNUSV81S1mypbWctWJCa1SqlbV1lN/L76GIVqk0l5ieUanesCo24yO7zuyVb+F1QhHTZ1RouX+ohlSKYB6eEXxEERphaDE2O/EXZUOO78ZIHQxUxvKXHJipQAmuWOuQCiRV0VbFV8gCVYthJVKVaMBpVGVbjHShKtYrV+F8oUnbNpWcVMK4AkgEMCIQ+gEaAtAXQFeB4cgfvpYUAcGFkDOAGOvWHZVXUW -VVYVxVaGXWR4YXNHn5B6UUGaxgidrGuRtjN3AZl5FW6Qb8g4AUSLFwjvRWIhr6Wc6axyiWhw8AaGLgD3AGEMQDlgY1ZI4TVONRiFGJ83JLUgo1dVPR11DdctWNyRkLXQXm7csWlMeTAk5C7VFtfDjRQFzBSC7FJwdi5IeGfkEmAFLmVpFBFsVQBaXFceTEkJ5txQHW+17XnEWkewYQhUR1KFXlXoVmFUVU4Vm6WSkg1EgKgGWJ0ZRDVU+KkAOBnK +V6jRN0MXkQSS8LkVaqmWjDVQ4lwcgy8J1lOUWyxbXpXmhs1RQmVpZTkQ37tVLfgUFyJ0YQokFZSiZXUqJrKaz6k1oweTWllY1cJWTVYlbNWSVbZYI4j+mYS0U9lMURtVxRuaGYzdwU5ZAb2kxUoOC5E3xdvki1E2efGXVEcQ96TBAKDwAoYuAPcAYQxAOWAvVmnvpVLlH1Ra6NRbmWvUb1W9TvWA1Hch8Yl0iFn3JccdFHYalV0NR/hp1caBnVTR -wJllmkFkkSmVYw/CDCTUFJAcVnHR1SbmUt1BZbjVqu+NdApC1JNZyEO6j0eJXEhHqXLyElvAczkklqESzV6e0tbLXy1itcrXpATQGrUa1UAFrWC1hNaLXaVVvrGkx6dlgXDYxMcCcCcgPQOqb91u5s5C5uxwZSAbBxyuFqOsHwK3CXAbphuA/5aLhyQj+bcETLcCs4Xi48oWpaJjGCCZTdAu1LwoaWAVALNHn3B91XYrx5PkvvWwpNpfCl2lwWUg +HCTNGM2jLjCWo1cJQiaUFnNkiWhhtBU3koqtPj1UcVWZU0n9VD6bxVPp6RvUTFlLdZTXt101eJVzVUlWmGT5dQdEmseoGWYIqQA4MXQOIn8od6GR8hVjB/+YJCoXoZahaakLJMNgfXS1R9TbZrJIgUIFGWnDWrXK5z+fYXshRybOonJSpWcmlptxJ7Xe1vtf7WB1TQMHWh1UAOHV21xpfWmhe5pRgnA+jMTHAnAnID0ABmV9YV7OAzbhwlkC64OL -UlAsGK5YxwGEPECrY9AMNUdA5gEcBQAp+JsAwA0GEDVbpZVXNGaZ6sZXkL8gbH2BwhM1KSKEi3DgV6GSHVUiE5lZWRA1TVUDU+4wN06hICLly5ZWU7QocB2URwXZbdGpNLZek1z47ZWuX1liDfSB9lomJsjXKQRPoSyqsEXvHjlTOVp6qgkhSr6r5HObIXNMeTRWXVAGTUU2dl65UbmblNDbyFm5TYUMacgHAOORdAi7JmQzIp5bMXOAlwOCQXJD +F5aBzFkV4g7cQlGUswNUTKr++irVp8C+4fimRlFrEJiWCkETdDNVMKqJooma0c37Y1cui3nQNTBdPFdFPFbiV8Vz6RYTQYaVjHAYQ8QItj0Aj1R0DmARwFAAn4mwDACQY2DRPmM1X4fsA+ZDsX2UqQ0GdQF8QcGZ7FppchWpVSwPoYO42S51YvXi1elW9WH1QSfC6ClyCuUDAVoFduU7QocFeURwN5SDH9NZ5YM0z4l5RBWHlsetEwPlQmOsjfKY -wkAT5xjrKJFahIfsroOIweJ/lvl+8PgwrG35YcWr1xxa5n/MwFXdVmlZhk9U3FE6fEmxF8BcHWIFmVfWCWNb2jY12NDjU40uNygG40eN8dcrEnhoNfxEV5y0fIR8YzpHDUWCD+au5dsVGLJHJlhWcA20FoDaVn9FrFZA1t1yJf3lyFHBepUdZmlQ2X4tQlbxUaVolTiXINz0fiWiFXqZOXHqlripYjU6+aS3cV5LUS3UNJubQ2jNoxc3gUA9AB0D +QfbjGqmtS/noAjhQqX/xLhTyHuW3+T5UhMEzVuXVAQzTM3XlkFYAXBVIkUm4aN31VHgcAfZF0ALs8ZJMiYVUPkZAlFAWcdwbgQWR5KKwbwDaFp+UIGJ6KFFFacBUV+IDRVC1VfuQVo1RdZLo5Bl4a4qAhuNYTWTxvkXelwNxWRLb5liDcSr1E8TTDpJNKTWk0ZNWTcoA5NeTd3U72S1UU0aRpTXPmsI3GChLDJGsI8AYFOIRXRIkpkWOVjZ52jOV -xAyXARwGB64JyBsgQwA2wcAQwLPYWFUXvAkuVcHpRrYMHkbgGQOa9ovAmkJTuoqMegVRaHBV1oWFVO16kWo3YONfDFURJoFPFWd2YFXc171DzUnkBZJjS832l49s0QfN1jbY32NowI43YAzja43uNnjffU4Fc0X8YFFsYenU1VFyUcpG1M1M2Z/1u3GSBWQyLajUl1lSei36a3VQcmFhIKEcAYQK5OAmIQuyde5F5G/s3VYt8TTi3apHdWM0Fw+b +NGP3q9VS1tUb7orJwaWYXqmspjZUBVVleYUamcrXtmBVD+TYVSlGzQI2v5Baa5WZMGeiqX+2hzQgmqmirbK3+VKrao3+FCoYEXA++gBQD0AHQPECJceHE4HrgnIGyBDAJdBwBDAB9skW0JOVUZD9RgmPpnmQgWUcK0CFILiA9gzJeq7pErCY1778SQLVU+hWyA1VCJBdall1FD8JjWgNzDJ1XdlEDaE2Zl4TW6BM+8DdE0EtfefWDEtiTck2pNow -YW0IAxbc0kzF2mYcYJAaWrEYWxEUBs2o6haccBcYUiLWkr2wUI+YzhMPgAVw+TTuc1iolrR7WVxUSTvXXFDrdAWPNxjcfVdep9XbGhOVjV80+tfrQG3/NQbUC3bppeeO7dxbDjVWvOj3MEbMpkJQSp/AEHuopRNZdR+H6ycTQYkuav6awWkRZNcBHwNnjsTWCFuJV0kNKaDQzUMt+ttg0KVbTfy2CtwrUYCitGEOK2St0rbK2UNd0cLX/tWldy0j +Ok3YAmTdk25N+Ta1mdJo/jSbTF51rMV5hXVLCmIgaDGlF0sW5lQ1IgVrEVV0N2xXBG7FTie8UA2UwkcAYQ05KQmIQQKV95MNB+R02sNXTfwGuZ4BQXBLtK7QgBrtryddVOlgbf8AJA6ee0YBxEUAcx7AMPtqSdOxiuJ7EOwUKQ57hKNfC0ANw1oxVBhZ4fQ7ItYDaxWFt6JQ/owNWJTi04lg1ewWxN1bTFUktdbeS1NtlLdS1ttDNR22ZhO7iBm9 -NulXW0go9wKQDKAzgEMBQA+AAuD2VOgVAALgUAESlCAXlkYACRdgUJGuIsOO/ihqCwj+Tu5MNJ+SFp+DGPJ5enhan4qR3aSHmmtZzZdXdRG9Va1hFXtcnVLtNcfc2rtTrU83Qq71Vu1dVO7Z83etPzf61/NALcG14VD9SgGam/CVt5RtQSodQ0sshp5EkFdec1Vvy+xbe1ptqLQxWZt5dRfmOxBcBhD6AmgLaCOweEKW1vtneZW2ftDKrW18tEgL +lzLT6gmQlDAMEjlWqme7yFf/th7GKLTeoW6V3JZLXvVu7WhFn5ggQ7XxOYevoG8R4Vrw1vlUgbKU2eQjZdJuV+ta4UqB9rY63OtWbhhButHrV60+tyjcKV54+EWx3XN0Fbc1fJYVW7UFw9wKQDKAzgEMBQA+AAuAZVdgVAALgUAJKlCA2VkYDJ+nMdfXOQYNRDhv42arsIvkmZmXiPk0begxzyZfmUVWROdRX5VF1eQiVZBIDcB3uRizp5F0pGLZ -53+dgXYjpaZetU8DRQxodw7W1iuoQybN/HfeKzEShtl7WZxwc1GnBS9eFUJqU7ah5SdefjJ3ztW9Yu0PVY6cp3RFtLs60btQYZ8bbtnrXu16dh7YZ0nt3jaDVzNF7by5OkQTe/7xtxBYbE7RkSsm0mQgXC+2MVIXfCVhd01ZiYARaJS0lgRlLVTW1NElbS2vREHTJUfRWDSfHSFEgER0kdZHRR1Ud5wDR10dRoAx10wTHT9pO2mHVy1KB4tTuVcl +37V12LdF0DV3eeol9FcTYh21tZLQ20UtLbTS0LVPdSvHLVQnt20T+w9UvBUsThkVKQGtFLbqzR8IMR0nx97hyVi1exaCmHFEgBhD6AmgLaCOweEBu375mXCw3it1Ifu0ZOBcG10ddXXRTq+Z0dU8DRQroT6Hv13kA+1Atnnf+KTE7ho3FzwUAVCVvBZHgi1ZtxdagG5tqZdT5gd7FcW19V8XeW2wdeJcNWQANbaS31tjbc21UtrbbS0fh9LZ2XvN -OIBHY8A4cOsAJdAOPemjEq1fNa3kB8JxyXAyyNlZA2AMHaaHVtBKfRIE6Oq6Q0YDyo7Q6SEPQXXeB5aNjqSd/5Ro2XNRhr8w0JdCT7XgVftYY0xF67c82wVIdZZGJZobaDXcqEFtGH+Nq4HpIyy+9vZ3EVhIt6rL8xdW52l183XCXP2ZwNDUP5WqX+FFlS2nwVKF63c0wy9AhVPnYgwULvAfADGTT5qkdOaOXz5DTYvlTlTLVqostnOeUAK9r3dD +yqX+GqptiJ8qzRBUnwKsmZINC5+c1HYw29dqlP10y1BntKEgxwMUrk8dWtT/GwxurVyHKlf5eI3lA2nbp36dhncZ3nApneZ1GglnXTDWdkbhWmgxlrc7VR5rtTHnlAOIAXY8A4cOsCTdytDcEEgwNbdankB8PayXAgJoO5I1HCFliNeJKPFn26nTo+3PRQieZJ8909bEFFoLcL40c2bWqemBNWWcKgjeJwGN4V1hsWE3ndtdUTVze+LY3VD+uXR2 -HblPrt/ErkJwCYXEA9QNoEcNP7kOD1pacSAQfAzhbeWBacQNIg3QcId3DrgVmehQ9gHGJCRNsQWvCCo9fTOj2sVOMN2zFJZrZ+b0aY+kBWE9QsT0D1eduYp2QFDXSlWH1cBep2mNGVSkmlVJnbZGDefjRC28AAfTdCDgdnRN0FJTmvX2jx1jCRBbg75UA1BR6NeQHC9aqUt0JNN3go4vogAOggHLcS1y9w/aP2UtU8AWnYwLygxaMYA4Fr1wROvX +WIhCqgQ14dRDauCziKsr1k1NMfBL6Jqa/HPX0NDXa02bt2jmcC9gC3Ww1q+QpRIBGFvhex2R4wfSYVqtQKsFC7wHwPWyhQrIhgXrNKuU5UOFLlTs3OFtqlrkY9htd5XGt6AOH1U9keSAXR5p9XfEnA8RcQD1AtgQY3kIWKCulb5wBB8D5FBFWgDwgtwcxzLIcdQ2zF+HOD2CsYzFP8prgNWmARC6MvW9U4wnbBMlK97Lki1npuQRr3SJWvcnlsVb -S0TlB3RIXyVUhYpUXq85eUAj9IlTh1vdOlV/FclWGHAD3A+AMoDGVjvRsAPQHGBshbREOLcKOsbwKZDcOrrIcDBo5yneb7CrkAsbgSR3FJy+FijZnbKN3wKo249UVfobJ9WjaEUXFtXXo271BjY63WlgdS6009rze61WEu4B0DMAS2B0AIYTpYQCrY9QJID7AlQPUCcgAEB0AYQ3KjSB/gioUcAxwbIBhBGgMcGYDEA2ME0AAQq2JIADURnTkXDW +RWd0E1BvZ3n11UIWxYCOdLedHLVa3ky0296+QinoM5XdzVHkVXYgTZE1TQ7j1dotZ70Q9FYdu0DdwSXoWR4gAOgg5raq2h9ITF/22VuplPCnC2MKCr48CfYj2bN1Cjq3p9QnXs2IxuuUc1Po//fK1BVqnUTEaddPRIAYYcAPcD4AygDFU19uVaZBmMw2YsR+oe1U5BvApkD6HOs//l5C3cpDK5BfG1RsdxicyWR40N2XjSL7xlmbcF215pdcE3dV -c0cwDUpzPYems9bLGSBY4LpiE3pdoJaIiBocWkGgJa9RWSrRNmNeA1991bZL0cV0eF02tlwQmBx7sG7NUBPUzIEMBVQScAsB8g5feP3lA+g5WWGDK7MYPAxZg1AAWD1oEIDWDLAJS3lNmdpU1DlsutS14lhjqv2NN/SXJUG9Vjkb0dNC5aWVLl+TdUBODu7BBymD5pO4OWDAGN4O2DgzYoHm973Zb1claeiLTxA45JxY3955ZxDsdRtV+WhQV6YQ +YdPjXZlF3bi2QhC3r3lk1u4B0DMAc2B0BwYxZYQCLY9QJID7AlQPUCcgAEB0AYQCqjSB/gRoUcAxwbIBhBGgMcGYDEA2ME0AAQi2JIC4ArVK90yVdQcwBKpuHfz78WKkD8AIp5MrzWEVXLTAaiIfqGVr+oSnlsWCtOlW010dUPf709NX8X03rlIFZM3VAsQmBy7s67NUDnUzIEMBVQScAsB8gh/b/1PoJzeeUpDy7GkOYxmQ00Q5Df6HkMsAdlYs -zp88wsm10WSBMrq7GiQO+XYJxzRiQ/l7UT2kXVePdANGlIRR5nwDujeaV59lpRT1NdanW8autZjW80lAOA3gNPohA9BjEDpA+QOUD1A7QOeiIuowPMDrA+wMkAXAzwN8Dg1L12l9qAcwD7pL9T3Fv1UNZCSoOhaUmWos8LStGgSJaN/1O4z6YL0edC3YvQfty3YP0qVgley0H9JLc0yqVhLWP3tJinjPl1NqDRIDSVRJYd2RDVIdEOGMrLVCNgja +0N2yzS+XDlGrcn3SBzldAO61uzZn0idCA3n0DiCQwM3JDqQqkMQcGQ3qRVD1oEIC1DBQyp1qN1rRaWadAKK3pc08QH2TaWhA182cQjnXHULhSsrf2UDZ3PJi8xe9KC0Qt+8OgzpFpdHRWwlPcSrFANKvQE1hG60SxXHdQIad0QdJbUOaXdiXUNXwdJQDINyDD6IoOQYyg6oPqDmg9oO6DUYrgAGDcAEYMmDZgxYNWDNg3YMODOXXv06J5AcwDAZA -lZP2H9+Q8f1qFndeUDH5fnfgD8KmAAhiLsXQGyAwAbAAuCEAtoOiDp9zHYq1cN/wPjI4aRwmoSwgL/Rshnc56Rsgh+cJJ/lBV5dqFVbuxCf4WDDFrbg5Oht1b8w2tUZXV36N+av7VGNaAy13yxHCRnnLD+A2sMbDZAxQNUDNA3QOgoDA3ABMDLA2wMcDpw7wP8Dlwwz2P1+wMwA0eEbWnUd+/0NDaEoxrU32wecNQt7rR0hushzdHnfyk5tfVcRg +9ddEeD1lMxT1a0bWrJkgtuvkmDggRG73TtOUfMlP9OGS/3Q9MlvoWmtpld/0KtMrWyMADkferVJ9/DSn3lA2zV0MZ9+rdn2qlVps8nlAfldyNQV8wy7UYDpff+D3A7XfgDSKmAHBgLsXQGyAwAbAAuCEAtoOiDSJNnTW5A1V7ZIW9g9wnZqwgBzAybnc0Gf0FUCqlet2ehNVd6FlmfoY1XCJ0/fWaAdIYWF1Rs+bUIO0Wnw/r10+CXcb079Z5pAC -UcMbn0CIQ7hk3WgGQI/33PWKmTGMUAcYxF7zNbbTDjqkn4q85JoL/bdCCjfwMKPkClFXl37Cx1eO1nVMo1ANyj11ZvUx5NzY9WRFOfS9WTDMFfEWadWbT/G4DBo0QMkDxo9sNmjew5aPWjRw3aPnA3Aw6MXDuFYINUec0eT4OR9wzVV3pXGVIPiJNQQm3yDXbHlJvAdQ4FEc+6gwCO99k1eF0LaeLb+0QRPjnYNC1f7RRFK9YlQiM7doQ3t1GqGD +Aj8gyCNgjagxoNaDOg3oOAocIwiOmD5gyQAojtg/YMYd5JXK6ZhzAAV1MtMxbmGQZCso9Cr+3kHtUWa5CsWH1NpjIzr+4l3vPU7FfIk12Rxq9XMBkcRbn0CIQuRnvVkG0Q4x2n5+hg82kAPYxQB9juXh81+Z4OAqSQS0LvGg2j04rxD2jh8J5BOjgZX5SI1ZDrhY7dv7ST6tVvowIPZZoHe8Or9IY+v1hjPwxGNb2TdTGPAjSgyoMJjkI8mMwjaY -U025MpJTg0m2ZI9OSUj1I7SP0jjI8yO7aeUUyXPdpNTeNx2CgX448hATtb6FDJIxIC2gS/nE7xAktOOSkARwHTB0wi7MG4AQjsOORDAf3fK3Exsxgv0kCazdxDoy/wPyOmQXGJ5Bfp3FD+GVjdtV4Vp+YndKMJ95XhJiUJ1XYKDE9mfaqNID6o9MNEeaVYX0fVGefsNWjhw7aMnD042cOOj8418WJ1oNVAC3DYg6nUCJXo7NSyKebuN1PiYJr/W7 +8YMZjyI+cDWDOY+iP01+Y73XkBvPizXfdbNWNQIE46YDAA9HsftV6pr0aJ5Ky0yTSNfRdIy+YRaw41SFv9K5Sx1KdOEdw3K1+E9x36+uaQcna1KPTAPwx6PZ5WY9SoyqNqjGo1qM6jeowaMva7UYaVRu8tVx2oDcozT0KjB7fYTH+RTvED80fZKQBHAdMHTALsmbgBCOwfZEMAs9frfl4Bt9nQiC3BQWdxB4yqpLQLBl7GJ5B4Z9FIEnOjWdX50C -jaOK30+5BWa52d98iSfaKJrbV0Hi+uAGyCcgygHoHVsiY++1aDzmhF3LmCpgXDGprk+5OxOFQ85BzCNLN3mMFQ4NTHcA+KOD7+9MIKxMIOHJN4kQ+KwkZLBitY7xO/MYSU2M6NLY/V0rtjXZJNvV0kz2OJIFowcM2jxw5wPKTs4wIPqTHcaDV1y4LZDV8UjwIxgEgdfSZPy6M9RCa3ks3tymqDMrp1UxNmLeePAj10Qsktt2rib6zT1NUexINL4y +JqQW41UwGbbUV8DYiZUmDeh3XuKa92vVF0b9MXR0URN3FcTUN1kY5dWpjhg1+NIjWY7+OojuY44O4NXSVAC4jVvYPUGJxXb6gJilggVJBDPQSRCQ4eKChPhDjXXO0xJC7QXCRpbIJyDKADgVWyDjmE4yMxDC3A80FTRUyVObD9nX8BZIIVBwjMUQ4KFmFSV7fpPv1HELDZd255Lkm4+hwrZIpixSZ8H3D/7XuLiJDk/6OvDaLQ2q69a/aINuT4Yy -g2SVBEvt2ojFIdB1b9sHahPoTlQJhPYTuE/hOETxE6RMYdiyd0bG5R/Ty34dUXegCrYIlvoD7AHQB75hTOmcIahKJIHCDDwFIA/lOQyIOx1mZFIPR50oiWscpsCeUsaSFIRCY7QgDnZiP7gDqLKQlr1wBSMOgFYw4VNqji+igNQVnY1JPzDRfYkVWEpZftDjkV4NBhWQ8GDDr1A4wJUATmFtp6LjkMACuSYA//FeAyAvELaBGAQgNBgYQQgNUC/6 +TW+TcSP5PwjgU5mOWDIU/+N5ji1fv1FNrcrPnH9ispy2bI5/SR2XBQPRopeUYPRwEYTzDRVMjjqvrEOLZ2yYqqETH0+/G7JpE++XkTyPQJ10K3Q454GtznraDCTlQKJPiTkk9JOyT8k4pPyd6yYX3GBCw/c1LD5QIthmW+gPsAdAUfvVNGNlhkkrAEcIINGjJODv9BDyjKCARbkXwJZCVaVkJwLlSWpHkh51nTFGWeNq/twPejTFVjVnjbw+i1uT -2iWpNhlILY/XYwRFddBJTiBJz3+jbLCEHvDazoiDGkVkHRUC9GbRjWnjH6T5NMWX7cMVJNqnvYPxDaTUkONCRg6kNuD9QIFg5Dc0503GziQ8kPgc+7K4PpDVs/GA2zi072WmQ/ZeSCDl9GEEMrTNLW+NSV9Lev369GI2vnG9KTfbPdNjsy4NpDzIG7OMQHs3BPch1EbKYfdKE+gAS0JwB0ALgowIhArKPVdt5guVkHEDTheZWASBosU/9CpYSQCo +Ig7A1iDMHb8NwdSDRYTrl+0H2RXgkGFZCwYxOvUDjAlQA+aEAM4xYR9kMANOSYAIAleAyAvELaBGAQgJBgYQQgNUB4GPiRiNvdh08aTYw1JQbSquFo8lPyx3LfFGIgWpFZAtj7vQ/00dkQ9cXPT2E901StAw6eWnNpQzuxjDlQ/UB+Ysw59PHlgw0kMRz4HHuwVDEwzHPxgccz9MtMDQ0+VHktGC0Ma1bQ3x2flnQ8I161cA2DNuFOLIBXHNic+H -qBoS8II7ohP/dqQdDhzZ+WeqKNfI2FxkA67X49+U2AUjpok8u3IDKnagP4zZU4TMyT27aTP7A5M5TP3A1M+0B0zDM1mNWEzM6zPsznM5MY8zfMwLNCzjU6LPfF3kJLN0TEHtRrMp/PuZMw0ezmXYd9x46+0992s5NMpjQvgTUQA0I/iOQjL6F/MQjpTTkbBDoHWp4hza/ZtPhzZJZHOxDoI/IV4j/87kPwT6c4E7EjBHeUCdg+wC0DraNI5UAxwQ +MjDZQ1HPpzscyjNmlaM/BUYzEgHzQnAHQAuCjAiEMcrntWFY8A7DktaAQmJBzJuNJt2wOQM5IdkPDXsCiQJC2ZJVw7RUHjdw2Um2TSZaeON5544LMLTV40tM3j4g8+GVtZNdLP7Ass/LP3Ais+0AqzasxrP1gWszrN6zBs88bGzps+bOWz+02b3vdHZrsZuD+I/+HENSSth7l83Ncr4NjgNM8692U7VlOP9j01u1itTI5a5SjrI8q0/9myb5UYL7 -wE0BGIapouxGgRoJyDBFxczYEKtzlVw13Q+Mp5Biut+k8OOspwmZBrRIVNUUxq+rfXOGtFdjaHL1EVX3PqNV1Xg6ydYqMqOJVLOsVO59ZPUfXU93Y211adc8wvNUzuADTOrzjgOvP1gm82zMrkHM1ABcze8/zOCzLQMLN31xnc6MoBRKOZ0jelnTNak8XfkSgBzvU9uMtzTfUrJcUdGPjxhjGNRGOdBubeUCrYVcucA9A2EzkBeToXa/PaD37dpr +Iwj1/TvHR+UdDQyiI2qgHldexeVEo0aXoLnI5gttzjaXc2dzmA+gCdg+wC0C3amo5UAxwQwE0D6I/pguxGgRoJyAuR11VHWJmSJLiCO6LhnAZEjU8zGhmQ90V5RrFhatVVJtbo/VV7VQutZPjTLVQB2kWfo3P2XhAoIGM69UDYtMizy07eOrT941GMmwnGVfNyzCs7gBKzD844BPzJQC/O6z05PrNQAhs5/NmzFsy0BWzgEwdNYjAnnij6J+xZtV -fxAS9jDBLPg/92dhQNpCBnB14fsFuBVBSws/AbC3ZAcLn+dWPPmE7fi5ldpXrKOCgc7YqM3G29SPNKdkix2PSL+fXMMYDbrcTP1giixTPKLqi+75rzTMyzPaLui/ou8zhi4fNOjU9shYIgks8Qyv9r9jC28djnWPFG0+ccPAPzDRSePPzLFREu+Tl49VnXj5EbeMj5zARo4wTm3TvGrTu3eB0fjh8V+MmwgyTtOzlEgOguYLMANgu4L+C6MCELxC +XWaANh4sJhc7WNp+qxe3CIk9Y8LU+zC9X7MdjK9Y2GYzjcucA9A4kzkBlTT0yguVTQ3eYEFwi2PkuFLdQ6z0VWzgITaQgv9YBExBSdUXQKLPwEosLz8bR6FMUH7buHI1o00F0PDtDieN8ze8wLPzTZi0fMWLJ82LN3ji3k3WXz1804suLkfo/NRini2/O+LH8ybMBLP8+FOFNds8v0xTwC6qnYMVA7o7st7nUdU+c6tJ3HDw8CwtlCtxrlEOBzlB -6QsYd0E3suwTbJQhMclJ/VnO7yTQOOR9AsGEqFGg+ANUBHAHAFeAtAwAu/hEsRMUH4D14U+eTGCTHlPDKzyXoQxOIwOBUHg2A4KPDCdgQezGwzNdnWP9ziPvxPhJgk7V7p9tCSJOIDo8+JO4zB9Q0vQB2o3BW6j27Vovbzei7vNDLB88YtHzCdc1Piz4MoN2LOek6UF0edkAXW9a5FTIN/1Tao8DkCKy2oNl1Piy0Vis8MRQC2g2gaw2I6YS4t2b +hK2EZzHfbXETStdxPYRJEw5WkRAoxIDuOVE2j1iNOfRICsL7CzACcL3C7wujA/C4IvCLSM5w2sdAkaaUML6nTa3jjbAE0B9kfQNBjGhRoPgDVARwBwBXgLQBAJv4BLBzEmjdnYgX7klghJ5TwHs5V60CnkMFAJTYJPH2jwvnS142RFk3C2deIyxNMVJA3rvMCgzk6csXjGZbMtQdos1E1XdMTZLPPz2s14s+Lfi/svfzQS7/OYj8qXvY8AcMkAs2 -Lus35PKZXJfEAGrRqyeDvTgZrkjEgPHIfCspZKFDV4yAaF8BEriq+GppTviRlMQ96zXwuldHUb2nUrNfHlMiLppfdETDnK89VSxk80HXNLCw1gOaLfSwKuDL+80YsmLZbSG1jLp4TwALT4NauNWd2pKvCv9W1sqt8jf9djBPD3U2rO2TvKe3kSOSYzrMBOes3jUol5QJdOgRzTJdMPR0+YtOIja0+kLoNVyxEM3LP4zB33LxGGwCgr4K0MCQr0K7 +cPbWWPNBLsXXYVeIVL4NoA2ZlV2OsnTgv539O+TO3tjOU8PN5TAKPEAUAtoLYG6NFOiUvILDHUHN7tY413PoAfqwGsLgQawTOoSWSMSAcch8AGUFaQBH9htBvVgOACrjXgNP5JQ03z2dxG88rFbzoy4KBTTu86i0410y8IN691434orTPkzYt+T2y94vvzRs7quBLwS+PnttwhUdY8AZ7Xz7nLEEwoWrwVA2kuO9WqtaNUNMCgVVDE903vlILfXR -CvwriK0cDIrT8bv3i+C06nPRpt00CuoLEgDzNCA+gOOT1Ai7BBOOTsxkFq5IJkHkSkVxK46xumwUMGp36Owj8D0Tn+RPEY44TZfRFLCjVaxKNiM3qUCL5rRHkE91xgu3jDtzW2N1Lia5ytdjJ9fIu9jzgIhBViV4KMCcgV4M4CVAQgDHCbAHQM4CYLQwN7B7Iq2KMBwYkgB0AdAlwPLRuE9wEyEdAuANUBQAD/CLPirPCRGUSSksxvB2Myut/UV4 +8ufJXy/cUhz306KUa+Z7WIEOurQ/yPtDgM5b2Cd1E1CvijhGAStErJKxwBkrFK1Ss0rV4HSvorEAN9OCRNzegN4rUa4XAUJ+gH2T1AC7BxPztfmZlqrIawf6ztBbndGCWQWmSgzRtORDpN9L4hRCB4MUKfvTft7jYMScDXM3GU8z/jZSlq9DedWshN4HfvKcVhWdB0qr4s9d3/DkAM4CIQ3YleCjAnIFeDOAlQEIAxwmwB0DOA7C0MDewOyItijA -qyLlmLFpwIPE2Tj80L2tr3k+asdrlqz+1xDzZbHNmzzgxbPpDHQOQC2w4QLk0xzBgypspDzswnNQAGmwWTabern4MDlV5P7M1NbqWcvBzyI6HPgLjLRHPtN26+gAODps89Tmzhm24MmbWmynP/LSC0hP8h38XAD6FzwJyCrYLQGISJLhUQK5JArpLrErwRgo6xhQvohiTT1RSGFASNWigc0flChF3O9Dk7WGsDD9YxBuDzmM7GuwbSVe2MIbUKUh +MGJIAdAHQJcCi0LhPcBNAIm7gDVAUAC/zWzTg7OYqS1JRvDmMoLeQ0jtSyINkIp2RHSJhDLyxENe9kPauuBpr0yHPFD25cnPlD4w8yAdA5ALbDhA4zfXMlDjc5HOpztm1AD2baZE5u6muc+SDPlBc2s1OOh6yXPELdnnq3kLQCQBU/5sDi5tWbbmynPpDlQ95uObWc++toD6jUwuKjnaFEXPAnIItgtAohPUuWharkkB2kXCSvCi+tAmFBxiSJG/ -ubtKG5VNobGG1hs4beGwRtEbJG2RvNEFG1Rs0bdG5LQMbTGyxtsbYq8C0nzj8dKtZJN4vZBiRihCE1mTJBQt7V0XwDiteL3fdJvhLrdVsv+x3a1Sa4jMIwJWwLR28B1ALtNWB0ObYC5+OTry+TOt8mMQ25ufzh29/MbleQ+yUZzyE0evoA9QMoCS0FgXAAdAbIE1YkgzgPoCeWPvtUAtAIk1thOVhyRCDJxVkA+JibPHagBl6ddByyAwOIHqFijB +VC+jJUhsKFy8xcPUV8arC0RlCAbt3bzJ6U8P1556ZMtzTkDXWvmLSq5Yunzj6Sb1+T9G4xvMbrG+xucb3G7xv8b9RIJvCbom+Jv80km9JsdAsm/JsGrNs2EtfhPAHAlfdG8ToywKh5JOvwTJuClNjtnkAAoDZArYZti1xm8/1lLL0xnHv9Nprgsyj2C79u0LeCzyN8NjlUeuCjafcKOwDPQ/s19Dkoya1A7/228kfrWW2k7A+9QMoD80XgXAAdAb -rRKOV2/+WEFUrgiw2PCL9K66Ed2Koyyu1LY8yVNpBBMymtEzzxVYQtbnIphvYbuG/huEbxGz0CkbA3fWB9bdMNRu0bmwPRs9AjG9Rujb7G6YsLjs0dxu2c021VU2Ly9sGA5x9kIcCPpcsx+ThBis5ErIEPjL37bu6bTCX7uDkw7Gf6zYTADzIi7HAAxOwXesvY12Lbtt95Vq8CvnAVu2wA27du7FtCRSBBjhZ8QTftypbAahjssoWO5xgpT95qO3 +IItYkgzgPoBZWcftUAtApy2thiLDS23ZmQtcWiFOdnEAcxj6pdKyyAwl9j40JtXoX3aptmi/nXirui6eH6L0qyYuuTh82RuQdXFdiVUbiy1INN1s25KJMbLG2xscbXGzxs9AfG5931g623TAibYm5sASbPQFJsybcmwpshLf87bMdmlnOdvnOTsX21LajAlxyapJHUVWsmSBG4yurtRqhNzJnq+gbwFPq/T0wAMyAuxwABTj13LrJm59vhrTHZGv -IOhS9lNgbifeUvyjN1caXXNVW62M1b8GzAVJr6A3Iv1+27azvxA7O+1tc7XW7zs9bVhILvC7g28NuS7rG9Lt5rZiwWvcbp/inWv1a468CWQgBN8NOLGsEI3b2npgcxbuUrk2tt5e1lrMbLO2xavbLCmxDFYdj43eOE1D4/ss9l8I8OuvjY5ca7jrx0pOvM1923p6/b/28QCA7wO6XH3AYOxDsxwUOyJPYjLJQXjHLBIx9vILEtd9sQAiENBj6A0m +MLEAOcAB7bAEHsh7JW1zGIEyOJnyfKB3IztpqzOwyis7bGH1PbhAy0jX7jno2NNlrEq4KA5tM0zUlTLI28GNi7Xw2W2TbCDdNvrTcu/EAK7C28rvLbau6tsWEWuzrtbbO20bsHbRy1h3GrH/mavgTMSzASWQABFL1O764Lbpxl/xQuKLr6EyK371pmyfnmbPy8aWYrcPaFZ/LIOxANatyTJRNQ7Z6wbUXrEABjtY7xADjt476sfcCE7xOzHCk7py -TwBkAzAH77rkmwLR2aAi7KMCcDbI1QtzGLcIvA4a30xCSwubgaBJilHlMGI15Spcn6cTonRStE7OUzGxRr5O2KjCT4i+vKZ7a7VqOyLyG3ntadlewNui7Q2+Lsjbde+NuntjNkm5WLxc8rvje7ApxQPi8bSfD51sYj6qptPw2jV2Tpu3SJedFu0MbjkHAO/tCtvtvbtbbZq5Ptyb0+9Etclkh9IfxAshz7torizfCC2ZFa+MQsoQXKls6SODBNXF +7XP77x+7KNWt8o1+sx7iEJBj6A39DwBkAzAAn5zkmwGZ2aAC7KMCWDxoxaFcxHlIvB+xJIAdxEuSdQOCJAKDAuUTJN0PI7Nb/CcKtszisXzt+Nk0/ZPSrsq0GP36De6GONrVi82tLLtiwPubbeu9tsG7u2/tsm7va5h39rCIRW6RLFFMPVcCtFABIA9J8FPV5iSavy0Gb9RhEPZLONgf4SAfZBwDAHjrQKmh7m+0OPb7dUbvvR7OWxABqHGh/EBa -JvvSgdzw/q8StQ+WU6c0lLv/tge0rFWzGumG6exIu07Ui/VsM7ue+nnbtlByLti7Eu8xv0Hoy7kXcb54dNsSDs1OsSPQWYbnXCbf9T8CcIKihtstrt7hW2ybEvVEu6D/a8Wu4hA65TWnLQcxvvvjTPdvuyVU69tOtNs66/vv7n+9/u/7+AP/v/qQByAdPdQaU0lm9j+8FtxpwK3YBXgiCKMAOW701bQJb2cT2wdwRKM+sXpWymshKY5VpYe/9ewP +Hye0ys4g+ebaTDgChOmYYFTkDq6uldlCmJL5jwf1OAmg0/j4jTJazUU6LFB5Kvk+Ey8Ru0HMRli2dFXk0b3WLLB35NsHuu/ruG7e28buHbSmwOs/hVu/h2ZYyxI9BVhE9dptUNARCe43bHuwgt+z72wyMR7ny4N0/bLySDHfTe63r7Ar+yYkyHJJ68DMZ9oM2KOW+QByAd0wYBywCQH+ANAdoacBwgfk9WyWe0ZbfE8X209Rh3YBXgiCKMCJWBM/ -XPG06q3I3idcU0BugDIGxAMOH9oZcYp9UGzV0wb7h4QeeH9S94dTzjOzPNadygJoDOAnIMYuaAC4JLTEAtoPhu+AQ+PbjfazRF0AUl9ANAn6AJGfcA0wQwFeBRuRoPcAIY9QH8ZhHQg9xv2RNCG3tlr4NBr2hqsyzHxxGKZTf7dtVayi0j7WZZtsZHba1ke957dVeOKbCQ8ptebqmz5vpDVSHACMw44DptKbem7ScGbJg24OMnzJwktPjMfN7MVN +rTlbrcV2wdweKAczaKrdgmLyYY1u4c3CpojPOPQRea42irVMBzPYbsZezuHjjkbP2Ebg2yEemLo24qsS7lG95Pb9La+tPKAmgM4CcgQS5oALg/NMQC2gHG74AD4tuIjr1EXQOqX0AlCfoC/J9wDTBDAV4AW5Gg9wHBj1ANJmPsCHxq1FHza0+9c4/U8fYUUQLJHVU0S+AAXe3FHp8R71lH9I/R2dNke6OO4Tdc2HOubF1KMMeblQ+UhwAjMOODOb -fs9U1L99TWEN69zm5AuubyldHNsnjg/ptOzXJwycGATJ4ugBb104SMHrKC/dPpMhAKMD6F13R41aHnDYs2WQ7HVGIhK0hjMdLw9c2FAnJxgtQHtDtmflvdD3c5sdkyJW9O0VdFxgYZHH2jUPPVL1O9n1EHqnVT0F908xVNhiDx08f3Hrx+8efH8oJgA/Hnov8dXggJwYAgnYJxCf7AUJzCdwnHGxNsaT4swtGt7pa7YuiqhzDayXzXPaKpzUKZcl +HJwltcnTczycTDfJwKd1Lkff5tNDQW6fugrWzZDvlz3Q6KO0T0K06pf78Q8KfDDop+5vJbEpwYD8n86OlvYrIVYwto7DzRGCjAURQT15NFh4Y3PKjnUgWJKDhtsf/KSbWFCQplgie7nDULWvOdb9FT1vlrdfqr3PDQTfzPDbRbW8cUbyq58eSDlsWTW/H/x4CfAnoJ+CfygmAFCdRisJ1eDwnBgEiconaJ/sAYnWJzieKbEUwOuXRU+xdu1NwVMD -Y7M2ASNNFlY0xoOxN7a9kf6z+29iYvb8C7bO/zvZxS1nbgcyEOlHoC+EOVHd23csPbWI1HM9nJ269sILac3vmHrOpxQCIQRwJUCbAQwIjGDHktPEB6LUAKMA8AMbpUAlns/nDuzGYm1yMZYvwOrsuLj+bVWncE1ZFQQkXU8bGtz5oVwv47vCyV0kJ9dkAUVLKe0qOU7BB21bGRmo9nvcrtPeY1YI0Z88dxnHxzHBfHSZ/Gi/HVhKmfpnwJ1eCgn+ +03LDq+TOexzIi1ZHMtAS9sKHb24ydYTVRzhNGVLI4jsoDR5TgtDnFrfgtNHZEy0fhb7+T+VZ96pxetGt8O9K0WFdC7xN/7/EwAdGHFAIhBHAlQJsBDA5MQsf808QL4tQAowDwBFulQNWfjBlO5aGnAekonUbHe/JSGQAHBGY0zifwMOArI9GC3GqLJZnVXc7ZBWKt4bAu+eETLxi52ZdVLx/Xvyat6REeS78Zz3mJnTdcmcAnvx2mdgnMcBCdZnM -AOCeQn0J7CcMHfXeLMOVpZw5yyrxRVdA+Bjpprs972IAIc97C3oebq7WMGkcKJoh9etRjEAAhgYQu4PcAwAbIH0CjVa/qYvMVju1W3O7FJ67sv7vF/xeCXwl+9NPmkIP730YcWm4FuRwUC+fDgb56i5LHI7fMIx7p1fYeen5XWUuN2Sey4egVpPfa0XHdWzvINbrXeQe9j9x48cIXbx0hcoXyZ3siYXQJ5md4X2Z7mdEX8J4uPcbXceRdDdbnHeJ +aNCcWEuZ/meInV4Mif4AqJ+ieYn2JykeVngh5lU1n1u0PVzFpumCQX2ju1OurBy+0XQWQtJ/f2ZLpqUof7+LXegBwYGELuD3AMAGyB9Az1ef701l8RUdhrfZ8HMVL8ViJdiXEl1JcEzZDpCDdwCKa5wNxb5xXQwbC5f5Q/n4IN7EmTY1EXt7j5x11uvcdx8ekCgVe4Ysgdte9Gf0HDa+2oLL0RzLu2LaF6mcgnWFzhfZnOyIRcInhZ2RfFnpZ1Re -6Sji0pokiVRetWg4mq6NNrL8h4CMdn5J7i07Lt+3PvL7MnhiWYdS+xTVxMy02vt2bY5+tOXLFR2iNVHx3dv3oA655ufbnu55ID7nh58eenn552ixznhV/fvKFuHYhN0NwThgJGEmwPUAn5QgJUAWAzANXXnABAABAnAXQH+AZJ5E6ismnOl9RPyld0OsKxa1p3HzRG2KutYmQ3e/4FoH5K74X/nnUd6cPwOB5UuOS+B3a1wbdl1nuIbPh2Qd+HWn +4nExcatrxR/TdEqVZKMljKVQKvpt9ZrZ6DUA4zy12eILOh+VOVHa69Udsn3+wrXKd8c3hNlXZdg0dvxfI2Dthbx6xFuQr1+5b47ne5wedHnkgCednnF51ec3nzqogMKd4sD/tzDG5zMcCTw3QCglYmwPUDQFQgJUAWAzAOvXnABAABAnAXQH+A9Jyk1pENL35xpPjwNXXsD5H6HmY2PKrRsP2/nvvYKvJBudYF2gXgR1UmOTv5DQcwXdB3BexdCF -b5cZnOF1mcEXeZ8RdXDPAHwkejlF6elXQRgjlYOB8bfiC3pFQUWmNrkm+GNm75C+FEma9ACcD6A2AArUhAchyScybih52ddr/kww0go6N5jfY38XdmOlzTubjh3iNrF2LWncmPvAR9XU9DV+rkPelO2HwayV3nVXp+Zc3Xzh9GvWXEBRaUJrL11cfJrvh/BXbtX19he4X+FzmeEX+ZzLtNTXG+LMrXUR5X0+5NdO3S51+FjfORKExFJxHjqy0/Np +x8dRHzBz5d+ToVwWckXRZxRdln1F8csdmeiYV0275Y11QWCQzkEEA9+IEhn32L5L8Dr73u8+7NdXYw7AnA+gNgC+1IQNodzlW+4Vdmb325ELA+9ADjd43kahN2zjXUUiCtwGOH+JWslJ7QJmN0mPvDwgAsSZAL7243xj5rOa94fFrpe+QfK9D19NPOX6JrSlXp20fWvHzjB83sVtrezCdwnYV4DcRXwN9FcVnYN3JHUlx8CXSOUcE4kuiW0C7mhG -XZ4wTeZXNbZSc9r+RwVeFHJV0Ovbd5Vyv1lHEp1B11Xu0+gCjX413d1TXJgLNfzXi18tcXTu64Fsrn2pwFMgomAEMCEAlQLaCVA5wKuKRjhURiSJAP5KvCwueViyjPrgMHJibgOILw3A2iWt5Cpe8XjGoF13Nya1bHoxDse6lex6ZelLZWz6cwDVzX1GBnca7Zdsr483jOvX1x1Le8rWnWwBQAMcAEsRb8QNBjEA9wGyD7AiEIRAUAnIBim3DkAE +K6G5lOvbeV0Te6HJNzvtk3A55Hhbr9IfUfgx9lbYUgr4O2CuyBl+81e9DU11AAzXc1wtcmAy16tfrXm1y+tvrZp2p1wVlp9+uYAQwIQCVAtoJUDnAcIpjeWhSJIkAo3iBNUYA42x8kmcCcIDiBkCZzLmroSQ8OZBIgYQQiQYblxxwMHmOG7cebz8JSGc7zwR1JqvXYR/BeeTiF99dfHMR+tNo6McNUv5b8QJBjEA9wGyD7AiEIRAUAnIHym4jkAE -MDQY9AMQCzBDuIcjVAYGmF7PALQKw1QaAN+YuH8PAOXkV97U4bceUjiIJtKSTArrsAwlwM/km3Wq1Jt432207tT7e2zbeyn1J+ye1Q3m0qdNc6GcwCsgBgB7N9rVJybNxzam8A+hAoD2wDgPvg4Kf+Dwp8OUgdF2yAtXbE5zVdTnNRzOe50N+0bNynnmwA90nQD5UggPYD/oDqnQzQNeArkdyTdqBnIIuwcAK5EaAheDq+SAhQDpodyloF0YQxgk +MCQY9AMQDTBduPsjVAuGtl7PALQLo2EaoN+PvhLM+QlcEjwYDIczdo2dzW6SxUgDCXA2BZbe5XDJ2HsfbCl0Vf9nstUBXxbup7VDcnBpy1ycZNYKyAGAWc9utxbOp9ZvNzQD6EDMAoD/oBZzNV2XgzhSzYFurNCp17dKnZc6etFp85xQt0Tmp7FvoAlm3/dZAAD2nOwPID2wBgP9C+ae4riwzHswAnIAuwcA05EaCZeCa1VpC+WIX4QrIdTRTMj1 -5c8cAOFbPuxMRo7cy6dflPQyZf9DfN83cXNVl15ki3kw2LfEHUF6QeNbzl5VPD3o95UDj3k99Pez3894vdsgy9xACr3695vfAQcADvd7AdMPveH37qCFdy74syeWa3l9y+vfh5RbnU53SR2oS8QgbOxewl5ty/OW3SJdbfZXMCwS2Ln/Z9E9ktfZ57Or7ztyUeu345+7fcmLTcMnSnzJfE/gjQ5/1c3TeHaudR3agfoD0A0GMEh0wlQPQARbTQIu +9GBDjHAcZbf13cEJivOXDMLTcP/1rd4A0V7oZ/1s0FUt6iUndl4+5fy3nl1LveXKF7Ysj3Y9/laT3097Pfz3i92yDL3EAKvfr3m98BBwAO93sB0w+94fcuoMVxSXGrGFRkenTuZmPLQtjZ+QoMoy+3Zq8QAbGjezlSwQHN23+hw7ff3gO6ufA7hQzQvxPSO9nONHHt80e/aqfTg/tH0O2qcEPGp0ufULCO8k/Dnv+9T3jXW54JPlAMAPoD0AkGAE -zOARC30AwARgLaBWBF57rVXna4NUPljXep70K6zvWoRfphzAsIP5JdnjtWhPC36PunfhVgdCLCo8BcxsYi49cZ7z1+o993kt+9fS3Q9yPdj3floY8z3c9xXKmP5j5Y8b3RgFve2Pu9w48H3PQEfcuP4ZeLO/FINxZ36Tt+pXrmS6UipoG3bkaUmyKL9ylfaryNyncqJpIyuTEA9AOoD6PuN+W2kn4T52vQNkXaU//g4L5C/GB5YMacUYgrmZAkif +h0wlQPQD5bTQAuzOAAi30AwARgLaAShoi/61dRqmTsOOjW+i30j1Q4EkBrpEiPcJQLFlyyKujXOwPb+hwZ4o/Zt4y09ftmUFwW3yrst2NvvHcZwPcJn5WWTUGPlQOPfGPM93Pf1y5j5Y/WPG90YBb39j7vdOPB9z0BH3bjwWPGrVJZDeMXtuypBwGk+k5IFSBwLzV/yE6t+d+oz9yHGvLowcvXKHQlxAB/g05MQD0A6gKc+E3ET6K0f3pN5K3KXz -EB/irVFY7cDdg61kkCNp0iEcLXzn54tTR704bHuyPEQaVsRrie42NC3yj1cU073d3TvJ5b11o8fXvY7o97PE91PeHPJj0veeiZz9Y/b31z4493PzjwWeMH4y2iptTDw6rsmZ6ZUCUfk1k64tqaHlMCb0MwT4ibv3Ch5/dKH391E/3jfVwvu9XvyycuinSI2OsbTN25Ue77053p4wA5T5U+EA1T7U+cg9T408cPLT20/fLgEUB2FPmp8U+MPfrgXA +vIi/IvqL8PF03iZuq5mQLynxDv4wNVuMFagJHEB2aeGUkkzPfN/0tYW1l/Xd2X8j3+387Yy4Lud3GJjLd41ct3MsK3Xlz9d6Pfkyc9nPU9xc9mPS91GK3Ptj9vdPPzj68+uP2tyfcnblKidOJXpuMJhenCS7YJjEPQbApIFt/SUdW3r9/lelLWL/bc4vNR0NcH7/y0ftVXQK+k9TnmT4I1tHwytDudHC55b41PdTw09NPLT208dPXTz08vrAK6rX -kgZAM0+Ix0GERuEA1QIQCIQHAOqZQACoKAd61xUcGzwg4NhJjyKkDmCRRUIVCZBY4BAaStsxhCRdfE74G6EmC3uBwKAPXNl09ecvXhw5c8vTl3y+VTErxc82Pdj3ve3P9z/K8kXFi3K2K7kbfpMluDMS8o+R2WYcBFJX+Ki5Qlxu132nOOqwWHcXzwGoAAJhAIuwtAML2d4TT8L/JsqHwK9u+VIjgPu8Or6xj3DrIxKzq3Prpd1lbjwVBZu621fC +rn5T7BWgFcVs7wkgZAJ0/kxkGNxuEA1QIQCIQHAAGZQACoIgepFHxj1FBs/UaSCiYLHGzfUY3VuPBF0jOpnWUzZkyQd3Xyz9y8VrVBxBcvXIuzMuaPwr9o9IXSXYWX1gCr/c92PDj3vcvPbz+q94n4S760ZHpY9EvEnxMp3agqw7Sbix9xUoiQ3ktXW6utjHqwhICXr7ljfoAzwGoB4JhAAuwtA6Lz2HvLUT+usClVU9+snvZSI4AXvCa+/hzpI4 -BzcBrXNwBu9z+x8Cm3Xiz9BtYzYkzjM93HKxLc57Wz4Pe9jvb5c8DvNz04/H3Te+LOClHjyq+LUda2wu33MfFCBtm7vd8A7jEm6bdv3sL/jcmvhN4i8/3IvnbetJC04OuALI58AsIRVV1HI77ty/g96eMb6QBxvPAAm/OASbym9pv0GBm+riRDzuvdHAK59shbn3WyBGgAEBhATXSlxglnJSMsnFPmz643PVRKzarqBouK+I+1VVQ5s5YWsjb+81 +pBsvt2x5Xfms3lKjiKeOSZ4cFrQt+y/dxpa23crPwqJWt8v0t+mU7PMZzXXzLOj2K9HPTdcO8PPY7888uPx99O8nbDpV486v5IDApKLmmybh+su5k33fAo7fIdQvRmz2d6Hd759WbrQ6y7e7rbt7yMhb9V0QuNXs56cktXznkm+kAKbzwBpvzgBm9ZvOb5Bh5vcIlqfIzMb0X1xvJfVU8SA5wGyBGgAEBhBzXml+wnQpGMmLFkO2x+QOjRsKTN1L -32pWAOgb/70AWHHsA6MOuHYFxLHgfkFxs9QfvL9s+9jV4EeUnARgE0Cu8PQHY3sDHpfECLsfntBhRlkACcDMA9ppIDjkktPCC7gcAHoFPo6lH0AkTyH+EfizczjpMon5Z5pcUCPcDNSjBYTY8BeQbp8PuI3msw7vJjkS12fUfm3LpvynHJ4qcuzzIMxvMAbIBA+4hHmzA/0nbX6ECdfyD0PBCnVmyKcjly/SIWep12xOuTnWTyd38m0C7/fQPCp/ +IqIZVrbDduIcIld6eWB+FSjdzGXeNPAzZPt3fWwRvhn6vc8ddvrxz2/jbyH/29/D6qyUBPrXQCcBGATQG7w9AKTeYOVl8QAuzJekGN2WQAJwMwBpmkgH2T808ILuBwADgQ+jSUfQApO4fsV+EsnOZy6zUz7ZjYiT/AoQ07tyHGV/Oq3KXkJ1vmvL9+D1v38l8yeKXEayVfaniQw3N6nSW5Q9eboQGyDgP9IaQ/QP4p3ZujfSD27eyn6D6+UELSPR -HO+bA37Q/vbUn0/uZzL+5oDtFpAABAwAPAM89U3sxq85atD0DCBwgJaKjufACO2JgL9A8mZlOnnQ0c3SPbp7+Xx7U4sMN+ncAw58rPHh22+XHHb/3fQfodRnlefXQD59+frDYF/0AwX6F9Gg4X56JRfMX3F8JfSXzM3MblQGl9VhI74DfaTJa5e2onUuFIPbIPU0pp7AgY2/K/ABdY8wI3JH/8PVfGVxE86DCtmy1wLBT1a9/zXP3COlXKT6OdpP +DvZP3r5Fv4P0W7n3Lnoc/1+cn/92KeAPI38wBjfdD7HfxvQRT5qaAxxaQAAQMADwBfPxLw0vQui8Lo4G0Jd5whGfEIFxwCxpiXkj1vLW5RWrzMj74eF1e3Q8eefRG13c+fsFzgF7PE26K+D3v1+tOhf4X5F+6NMX/QBxfCX0aBJfUYql/pfmX9l+5frzXtuVAhX12FTvJXydvRTw6xV+LvE0bcoEgl01OtHXtur8DT1XGt7Oe7JqQ9NWvoa11+f3 -2Dxk8s5m/Zx+G9s54t/znMT4k97rYtUSPP7Op2fkMjV4IQDzK8QEYCrYRwOkCgCJwArVGAzgFm9XntkEPA9gPuQfAec49dqRhQ4PrP1Lw+8OjqcLfppM+SjhO87VffvzEBfoz5xQKDLPLb6s9A/9l5CqbP7nzB+VTkP9D/+fcPwj9hfEXxACo/Gmej88AiX8l/Y/uPxl8In4s4yURXMq689yrs215C2CYjzWf3iHapFBcYss0bvqzJu6/qcX5uzt +Sl/a/FPSrQk8A7T6NKOlPOyfutFzoWzx+rfJCxXMw78AzFuDXov2a0pPUx2NdKfsxyp/HvMyDgmEAeyvEBGAi2EcDpAUAicC+1RgM4AFvqk40ux89lPrcHwLnCTbdgE+jj4gDQlpDhtsHO/M+AXiz56PaL5e62+j2az9XsbPs9tBcw/b13D+xnCPyh9I/4ryj9oVaP1F+Y/2P4l/JfEAAT/eZRP6dsk/+X+T9Ff7z8BPhLBpfRdgZUN1av5h6OBc -4go2ADhPxAUrABBEspq+ldknrPzkczVL+038wgrf5utiH2mUlNbKpIDqGYyk8Jp/o4qDkI3YWx8B2z5LNLydUbHn39Z+ozXv79/2fwt+y/Bnaz6GckH4ZzceRnVhBH++fUf/QBBfQrYj/I/eyAn8nAsX/F/J/mPyl84/6Xw89izFixot3DxP+WcUoIiTFRMThckITJPBikr8ADXlz4j3uNUWfgi9Emt2drXqG8rXj8tEAXz8nbrZtUnpN8LluUc2 +xcCQL5yum3JKIAQx9YT984+7wGyoeawEk/ECisAEASwhrK67e/FXh6sD7YAffwP/0rT3/ee4ukOP94vnk8F9+60AbIP2+/DA4XusvX7cMv3XlexH+S3R3VGekb71x5OltLBUwfJ/aH7Yuo/EXxn/0AsX4604/ePzsh5/JwBl9Zfhf3l9k/FP8V/uP4S+4tyvkScWgh/gTEtqQgXoWYqGnaQarAFsO/m8tInja9onna9evsZZOOoCsnXphEeJiftl -Ps68OPtk9ygMr8/4mr89gJr9tfvoBdfvr9Dfh0dDlnfsbXg/stvr0d6GlG8QUDGYlrjwA4ADTA+gPUA4AKMA5PghgTgBwBJANCtZktYFLzp2E5hFIhDuLCQdQtP8ZDLFpG2MtQ7oDlsqnPbUuJhgd3fuv8Z2gKBAPt78h0k29GViT0VHvGtatuLcQfiH8u3h59Kpvf9H/hj9U/ql93/vj8T7omYjTurEldlO9ynLZBVqJicp4CtZr9G/IpAe6xDd +vpANwVr7cvHIoE/XoJ9DfleBjfnsAzfhb99AFb8bfnb9xjpVcsAWU9FPqFVKnpNdygM2YNrjwA4ADTA+gPUA4AKMB1PnBgTgBwBJAOStHkpHV+nomZthK8BHuLsJHWKM9PgI1MBwCrIG2NgUVkNdcKirdclnvZd0agKAYPus8JdJ28BXtF1hZv58RXkn9Dnsl16wG/8P/sT9v/gV9S/lT9//idt7TiWMLVgu9p/AygeOAAp9Lrdt+sjmoqGkdwbI -hV9Gft4tgXr4tuLhQB3+DABbQLKETvKJcG9uJcavlJcsrrBJv4pEDdwNEDYgQ6tGMI2IIeriQ/gHUUi3s3I9MmVFjcPi9lARawv3jYd/EnYcQ1rzczLgo9yEg287riccQPqyswPly9mupo8LAWH9miNYCk/in8sfvYC8firdj5kWcLFge9lXtG1tRKsgg2EV9+KDidjcNjBiVgC8WzqlcjXp38T3sodcjjNNbog7clpmgCaatr1MAZVdsAXwFSJN +HaE4ATC8PUoJcj3uAQf+DABbQHqFPvMP9w9ogCmPsfVgfBQAogTECCOAmthHiXc+euiQFxFBtiZESAAssoCDcJS9qXB4ccfCB9Ckj4cRbnv87JlKtYPmo9tnoK9dngn8Avgc9kLtf8/JtYCC/jl87ASX9KfqbtDVlPkeAJe9tXhfcHPnbgdCJsU6vuy1mRJuFsYDmtIXkZVoXlyUEAYL9sXt8sRfugBnbl9N2PhKV1WnL9uPgDNPXk1cCAQjEq5j -OtXXibZWAX+B2AZwDuAbwCjQPwDBAcIDQ7pJ8gtkNcBQqXJnpswA6YCuRGMCID6/iTFsnDiofpjRV1rP09kCIvA8dFPAY1Gck4bPDZyQIK4TlGiRI+u+R4ZjqUVGsjMALqjNbPm3cqlggNO7q28Oge29g/m58egeD92urgAFwM4BKAFnoY4H+B9gHot9AHAAFwMQBxyJoAjgFdZHASh8LFiqMifpFcDKOU57hDh8LIEUluMr9NkrmsCzbhsCLbhR +652AX+BOAdwDeAfwCjQIIDhAaICo7pMcY7p+tGHkYccZswA6YNOR6MGIDcprjZ6nM1Zu2EWpP8K9YvSmPBF4JZJxEMGw1wJAE6bOSB1XHbhp6uScLjlsJHPlwNcNi28AjvwMGgeA0mgcYChXqYC+3u0CB3jd1fXLgAFwM4BKAJ3oY4H+B9gL4t9AHAAFwMQA+yJoAjgBDZHAR89wlgW06fsADrVrClliCM5YJvlo3ZkCptFAfp6vnV13VrSN5fB1 -8rbmz8VunoNGvtUAMgM0JwhN18VQWqDmaC0JzNig9LNlU10HudtjgXTVxTozUvdHN96ro9sZTu5stQaEJ8mHL9hmoNdeWsi90AC0BCAJ8ArwEMAhAC3sgQQD0YcBshR4Oyxslr4FpSmacjuE3NO4KFB9PlS8v8q99O5ic06gbW8E9i3cfvnZ8MZv99/foD8SQcD8yQdBdMBq0sLGtSDaQRQB6QYyDmQayD2QZyDuQaMDONhSkeAFesf/oKC2WGoQ +8mTju0WTgYcUASQ9f7hkB0hIkIJvmqD4hKwxkHjHwh4Gg985hg8cAWfsoBkr9VTlFtKFkQ91fqqCdTuqCKaBkIFPqjN/9h8D9fhAAWgIQBPgFeAhgEIBJ9gCDsXMYhfWKPAWWF0tKXF6UYNr80UsFrRXGH6dgfh1tZHj+1OXkeN8NhlkVHkf8a1nXs4/lPFz/pE1AvhLNCWnE1KQdSCKALSD6QYyDmQayD2QZyDBgUdsjVuEsgNniN6ftP5tgCXR -Q0OADlVjrs/AYRZPVEpgG2FKCQGlV9QnhPt5Qd386vua9pfgk9efnE8DtgudEngx9nxmVcMAaaCpvjg8N+lEMoFk9sefpy16AR8CXQUw8JADwAugMoBQTs4AOgJgAKAPgBIoEFYhAB/xFmu6gUVoJFtDgvAyQKxUIoJMQIeov0dqs+c2UAmVcrHsAxnlqh8EmoCa3nM9pOu7UWgYKBwigD9zjoH9TAXmDugTqNKQVp1oMMWC6QfoAGQUyDzgCyC2 +A0KjdmTNUUxQfGp5MAbcQgasDMXusDbXpsCVQRAApfuOcRznE8xfik89Qe7cD1kcDpzlk9zQSKNLQYQ9CnlG4xwVgtkdplsO5vHcY9jwAugMoBkTs4AOgJgAKAPgBIoMVYhAL/xnAFZB7fl1EF4GSA3qhFBZwgAoHDmmkzuPH13GK149gBgVOrNnVzJqQcQLtiCxbsgES6hBdmiqEcYwuRskPmYC8wTRtgvrd0iwTSD9AHSCGQecAmQSyC2QRyC/ -QRyCuQRn9QruLMKqoek3Afn8rwskcYXG6c4rt89ltgtRq9LX0gYBAC8wuc5N3nqto7gK0/wKQB9wO394gePsJLheMzXqkCuSueCA+JxCuQGFNORjqFDam6YUCOywwwVpcfwTCQfVDWsDPk1FEbIvVP/Gv9G7o4cU1KcVdAans3DkVN9/hPNXPvmCWlszt3mqhDSwehDywVhDKwbhCawQ3tZdo88LFuEIVxr/8VduNQmMsAQtXvRdiKvMtREMStfZ +/tyCTtqtVCTo7EfntDcAIgERCXJ1taxsSBtXEUU24ksCMMvxcvVpndzUrA57Wn+BSAPuAh/jJc+DnJcFQa/1hfuTcHmqeDA+GxCuQPVMr2naFsYOVJ9cOTI3wQ6sjLkyhIIsM4fwZ/UiPNV1f6qD9eBm58hQKtFIfk8dofkYChZkSD4fm0DAoqqtz5k3VIMEhCSwShCywehCKwVhDqwXwcgJnl0TtszUCIWU1EcKcwgCDfcKTr0sGvlrIc1gFtJg -qkdmzgODiTmR8P7pJcv7i7sZ9nA114i91hzouDBficCHXqx9zgUzU8AfN8IAIeDjwYvczwReCrwWyAbwQx0rIMG81ukud91hG9Ffq6CIAHTBATjABagPoA2QNUAAIAhg3fEDdb7PsBcAPEAmgKINYdp09OwteYSBJSBuKNXMW4NvwwwTIYKClaE0kOJsnkvsJxRi78CdraFNAdddZ2pZcRFr79QLtBDwLn5kZhmGcmlgPckIb2MUITSC0IRhCKwT +X2DaOmsDFQd18o9iOD4ehOCVGhOc3Xv9MFwScC+PqI0BPryF9wYeDF7ieCzwReC2QFeDLOreC6AbD0nQe3MXQejMY9nTB4TjABagPoA2QNUAAIHBgI/DwBlsPSDcAPEAmgK4NbzhICGlihYdVJSB6KCYkhstg4DLrJDHDIoVbROkVHtv+dk2u6M02pZN7ItoDEWk5dHjvP1ILtH8tngfNu3qf9oIXF1E/nBC1VgWDq2pZDSwWhCMIZWDsIWX9nIX -hDqwfhDXHhYsFOjl957J6NSIZioWOHtwVBsykbWK+JT4P88orIxCmigqleqqxDygGyAFwE0BNALuApWjPQeIcz8u/rACB+i9ZgVsDDQYeDDLFpi8JFJkgh4JxB8eGxhFDKjtlBrYV9YisZPIMO0+KMv8axvS8UZloDN/umDzipmCjAV3ccwUH9QROYDEISFkrCCdCSwWWDMIdhCqwXhCP/ifNn6vdD3ITrFO9q2DGLpT9pjn/VyrDeEKGL9CMWtA +bN+6kADCIXFMmLv2UGONilavqz8yRlQ0hfBC8arMFCzUr7t/nO+4FwE0BNALuBPWoPROIeUceIagsT6m6C2QH9CAYUDCCZr9gZugTxnhG4Z8gSENx9MiB24skh0rsy9LLtv8hlupDXPlB9HLgf8loSi09IfB9mgYh9tocZCu8tLsU/kS1DodZDjoXZCqwThDy/idt8GnyDazvFErDq2CpQb4Cy8FscAgazwlfNz9Sju19+fiP9EgWP9YnqVcGARL -CYYae8dgbPsirgB0jlnQD+Tlt10AUlDlwVgCRfkd0vol7caoXVCGoU1CWoW1D1sIyCuoT1DSoWrCUAUsk6HkU9nQXdNqoU0AYdBwANfohABYSC80VqxUxSkB4LYpN4zgNKUbMk2ZxDMGxM+B+9UypnEqgsdcHMvGoMQZZ8G7nI8GgUy9UwZo18QcB809oZDYIes9IPqZDU1oWDIADwAjQH+AGnl0BoMNgBNgJLQOAT0BlAE6o2QAhg/wJUBV/LWD +8HXiNc7yrL86rp7cGrolDvyvx9/buUByoUIBKodVDaofVDEvE1D9gC1C2oZG9nXnLCtwdMddfhNdKlofhidBwBTfohB8GoxC7Om9VXSlIUA4nt4yOqVULgDqot4gsUvKA710LCbRc/C8AOgjzcksoCorjk3cbji59/DiBClHh58BtvP1vPvpDRdptDxdq0DYIaSCgvvtCSgDwAjQH+A2nl0BIMNgBNgPzQuAT0BlABGo2QHBg/wJUAz/DWDUjoIc -CzhKsLFr410PjVUHxLP0kCPG0lttq8FljeRC0tWdBDqu9hDpAChgse8RwbDC6ArA1bQSQ8ogB19WTn/dKykvDz2qgCK8PqDfZqN8jQUx9MHnuppvtVc1wS5slKrk8lvokN14e8CI7lVD9wegAYAIhAL+gwMC5mFNisCQIg8Ksh/TNgwwwb6JDaGJg9osE19mpI8uhu98itsUstIQcdfTtTCQKmy8s+qLcTAbnCzAeSCWYbBcsoSXCy4RXCq4TXC6 +SmoR9xgSxo2ED7CKTvvEAgSeRo2qiCd3hks2xuE9r3qFDeIT19Hbuyc9vtuUogCd8hTjPC5NqN96hqg9Ghot9C5irCMnt/FFfqcC5zlrCqFlG5SHnPCcOlbCdfswDXQawCJADABEILgMDBgPN6pgVgdVKdglkKWZkGOGC4xGrRhMG9FO+rGDpHvGD8YQnCZ+u1oSYS5dj/h8M/PkZCc4SZDqNntCq2gXCi4SXCy4RXCq4TXCWgHXCG4U3DHIaEs6 -4S0AG4U3CW4Y5DVbvWCwWhfcMPuSB0sL2BR4b5Dazt/UFvFwQs3N+FZYeNN5YVsCBIVL0Ofqdsf5nk9OftuCNYcUdtYZdt0ACiMnXrg9LQV7drQefCJwfk9eEW9tEFjfCdvjqceAGwBXCPgAFQCuReIEYUTgKQBVsBQAKAF0BwYcnctaGID03IUhxjoYclqKdRIQQKMvymI0pdAH1K3g7VuJo7RLruGsSdpV1wIUB9arPJ1HPhBUJJvTtQfqH8jo +wSdtGWu3CQFkxQUsBaN/Hu8AnnK8xG3LRCGGnz8bbgVcpYV/cYepL8/ttL8KrpODNfswjUnrVcuPqrCFftq0lwbk8VwQU93CsQ9RwUwjxwYwDnQZucL4XbDygDwA2AM4R8AAqBpyLxBYiicBSAItgKABQAugIDCM7grQ7ziPo8kGsdPAeNRNqKM8vgCxgFwhuBFwlooe+qZMhVpUUtAUmD7jvX4DupH8JdBBDu7lBCs4TBCSQdAjaYZ0D1poXDi4 -ZVNi4aXDnAOXDK4dXDWGjgi8Ec3Droc5DT7uG1XAZO8noYVhz0lUFvAZFCmLgtRGMkI0K9EwjPOlxdAYRIBagIhAgkKMwy8oe8p4SwiZ4YrDe/jqcSkWUjiABUjUYUpJcQMAQ9uAZlPTP9N7UsWMbESfBtuIGJA+rB4CumpCP/G1FitsnCm7qnCG3D1EIIQVMs4djMIAgf8NHkf9DoazD6wCEiMEREjsEfXDG4bEi+YeMDT7hvCmwXSkK8DkiCiH +c4BS4eXDK4bo1UEegjG4azCLoR2Yu2q4CiundCdGNBkOgv485wlYkQhglEzXnSdfZvRCu/v6D4XrUBEIP4gBmPsAk/PED37oOCkAcODx/g81CkcUjiAKUiH4XdAtMtOpNJgWYZIcnUFkBYiT4FYiEospCXgqpC4AkIky9pB8w/pR5Quof9ZphmC3LpnDG9hf9FbqZDlbhYRAkYgjQkSgja4fXCokedDzejwAT4ddD3IYDR99JxQjboa8K3qbcFAQ -O9e9oW8aIWPEvgJndi3vkjeIUkCoodJcYoVQ04obq4+EXa9R1hdpHXjN8ari69xfmr4lESoi1ERojbQFoidEXoiDETbDIYhqcejp8Dv4h0AYAPEAhQkeceLCuQ4AOORtCpQB6AC0AIXtn8OnpQtkdL7CwcEDZTakfBpSgKNccGclgxMl1v0gZ8O9N+dFob+dq7vwsVofzc1oSy9G3n786YcSClkcZC84QhCeVkEjmiJsiwkZgjIkbXDdkfgi4kZ/ +pVASKLCLXuLCaEda9KkUkD2GoH0eGhgDAQhx9Qdtwjjgd7cdaiqcOjoQD8njftZEfIjFEcojbQKoj1EZojtEebCDAqNdY3ufDSoUYcOgDAB4gMqFzznpZpyHAA+yGEVKAPQAWgMi9K/h1CVJti53YYDhCbA8I8UOZchoVqo1kFkgTEj6EVZPmhJoeosgLg4iIPgo8xkRjViYTpDlocLt04RtD4/t4iT5AsiYEWZDbFisjgkUgiwkdXCNkRgjokTs -9T7u6MkkY9CqLgvxBwHm5goe9CfIbrtFBnadfevkiN3uf4/FhIAj8pIAQvrUB/bJUjEgTADakbd4X9iaizURaiWkaKpg+j3BOpo3N6MIOFnUZ2JDJtw4ZZCWhEtAUtjLkmDQIcy8ydnMiAzoSDqttmCBUb3chUasiwfusiSgOKjwkVgiokTKj9kTyDMvhYt+diciZtleFCkO8pMTq1Uikl3Bm5MZNgga/cmfkOC+IVNNdUsgCRah8iQ3g2ivkeN8 +jixnO83AcPUSUAWhHtv48sovIUghl6cCDp9CD3gcUIgXTA/wJIB4vrUB07Fe9uIb2chfpPCsBA81DUcaijlGaiHTuQh7KB+9OWuQNaMK0524rSjoUimIZuvhlmttxhcYSXthkaLcZ+otDuUaTD+XuTDCQS0DBUfhDEfhYDB3vAigkSEjkEeEiZUVsiuQWzC7ZhrtGwfyD8wv7hdhDYkEbvQEAhvSAT3AoDKbJ9DQYZaiNgRus99grCXXq8jFOk2j -xTm7dzQcfEDYbUdkUaijJaOiiVyJijsUczQBWvij6AISjurlL8EAc2jZEcucLejJ9gVp6V9gGwB7gC0A3+GFMY1EPAooJkgehnigzaoGgxSsmE83BoZgTOGoJEMFBVZgcxoZpoYSugnDdjtiCrrpyi0Zlv8MwTv84Eao8EEcsiTIcKiYLosNYBHHdD0MoBOQB0BSiDHBWQaCc+gMQANAP805USfNuyoLDmwYtRs3BXpi/lrtM7uQVvvFbQXOmPDq +sAZOd4oR69vkRftfkT69/kVt8TqMijUUaMB0UZijsUfa08UfQACUQNd+hlG9HauIjioZIiEUW6CqyvsA2APcAWgN/x6poWoh4FFA0kLRUsUEnUghq6VLgIUUcjj+cAfssgeVo6xOCLkg/DEIkY4U59uZsBCgEWGcU4ZGi4Piv0FVhAjs4T4iaYbo9/EfUQhAMnd90MoBOQB0BOMjHBmQcic+gMQANAFS05Uf/NLzqpsVwliFpfBPVTgFV0EfPrRt -/mu8x9tDDWEdFD2EXbMSHhwBh7rtptagctlQSRiyMYDp+ThZsd4YaDHFgL9mPgvkO0aL91wTk9nuh5tSMWtoKMfbDNvruDnYXfCIAMOAKAEMBmAABBdwCQjh/sjom2OxgMwig4n7tDYrER0MNJOxxPKll5YwXlsQEYVtyYTiCtAXiDU+pnCDIYsiXgpT1D/gdCE0agihAP+ihgIBjgMbgBQMQuBwMZBi/ANFgDke3DT7oCD4Maci+EIsVz9GLDV+ +3q186Pt2d5QbWihwfWitgbt8hhhwA0dC9oI6iwiihr/dyMejoV4QaC14UaClvu2jCFl8jsHnwiNvvvDrQf0NSHnRjKMWd93gUujL4dGtngBQAhgMwAAILuA8Ed39laCV1r2n5weBBcB0Ql6VLaO/gSCv/IVZL/D2ttcMAEaH8cQUnDUwSmUpkSRtwEbMiGDr+it+omjyQUBjVZkMBQMeBjcAJBiFwNBjYMX4AIsNsjEMf8D9kZkc+EN8VwDHzDEl -P2Awml2lrkvz1CTq2cnkdajtgez8cRrOCpwfld6hFuDYRivt+flrCWMbr02Mc00xfvgCd+jaDntvFiZEeVD5flqdb4cwDygPcBdwHhNWQcQMcAE6o2AKrQEuNgB9AJIB2nuQtjEZaZYCAbVHynJoYjBLDvKujgEyt3kG0jMQKgf9BVAegcQIR790PLMjPEZBDvEdtCnPp0DZhnmZAkYmi/0fTM7MUBiQMWBi/qK5joMR5i1bhYsxfgKDc/tYt9Jn +kAF5Cg4ZWeN4Nq0Qx9R/vQjmRqOcSnmIj5YRr8uRuwiZwZx8SIlvCjTJxi8Htxi1wRT0NwYJjUdhF5v1vcBdwFJNmQcoMcABGo2ANLQ4uNgB9AJIBenhTtOobW50iF0iSKiZo2jILDSqkjhIIv6lV0hMQygf05/wU29WUX4d9MYnDxkWBD9AXkEIuldCCQQZDY0VTCoEX+jUPpYCLSMBj7MWBiIMVBjnqG5j4MZ5jzdpwDhDh9h3AS7FJagERvIe -mVkjlqjV+M4hCRCm0hwM+0QoWi1QgXX8Ubt51Sbj0AWgH0AOgMHxuIcqlcKlaiFYTFjbUTqd6AJ9jvsb9jxIfesQoPrEA8PXkBsVHFCPvbh0dKNj56oV11IeMjwEZMjtIWBCyFtAj9IT4jyeuysXPnGjLMWtjrMbZj7MTtjnMXtioMe5jM0Zn8LFuhcc/nmj62HKU9Pm9CazsV8/6jT5M+BqjiPpWjBwbKCwnjUjgcSCNYoVwiJcQAsFwcxiD4T0 +xdfIS2d51EVVeYo5ppQbu9ZQfu8GIZ2Nclg7AegC0A+gB0AQ+BxCesOC4LUYx9pYZCgHmvQAPsV9ifsaJCTIMEEXhGJ5uIKvkusSXFqPrbgTRP1j+kd/USPPNEgzvNDwfs4iRFm+jQEdMiT/gKjFsZZiSsv+jVsStR1sQ5itsS5idsXBiPMVmiYkTwB8LlX9vHozpgcLukCpBxcqGvH1zmEFDOznhjrbhi9ibnQi+IVPCYodFChrq685wZ8iEoV2 -k/kcfCLgdUdcsegBKsdVjGRqtg6se0VGsV4MWsW1jxPu8iw3gii9weVjKjPZAugEm5qgJUAknF0BqnuR0yQERwjQIkidasSiVgib9J4OZJnyDCAg4TtV0cKwtpEHk42hrjtmUSFUloSGsXEYy83ERZduUeGjRFltCswTBCGYXBCmYcgiRUetijsJTjtsY5jdsRBi6cTBjDkYmYmeqdij0nn8VUcS8nwqpIDYtQiq7oPDREIOBlBhdgV3jhiJ4UxC +igZut8/brDsAUMVjSsXqNFsBVjjitVjphnVjennJ8XkU7UmARadCsTHsWrF0AK3NUBKgGU4ugI08DOmSACOEaA4kVlUmsSPpt0ZPAnJDeQYQN3CqUd8pILGn5hwAsRXIBZEXRmosFnh6N02qGifRry8pscKheUdGj5sZTDPrvs9fEeTik0ZTi7MdTinMdtiYMfTiEMQdjLepzCGLrdDfnggxvgNR8DzFziPJGKCnEJnkvhLqiXsTksmIegAhgIth -K6qjchjEMBVsMnBKOqtg4olDDq0c8jTXoRirKFyVO8d3jmAL3j10RCQEtgxkJXOywrEaZB/ccOBA8T7jGUYGjV/n0MGXvI9pkVyiw0XNj5kSZjQPjGiIPkgj84Uzsw6j7hM8Q5inMS5i88Ydj6wRA83IQhjHgMPAgYJzitdviB77l2CFBmpJ7TLNCq/hFj1geFDjXpkjKPnAD6vvWjsOpLjF9pa9N4TLj0sXLj6aqlDMGt+NlcZlDkrBbjZaNbir +k4EZ1FsOVEQYZFjRcdajgcd+sW8W3jmAB3it0btwGOP8U7cCyxTET1FFFhIhA8WcME2ruMd/npjRkQZjVntHjXEZGdCcWZjicUnidobnD8wXAj08SBjNsVnjacTnj3MXnjjtnbNwHmBMuYXYJh4EDAnofzC5CKWjwIoENDJGmYsYUPCefisCQoQOCwoVaiIoeLjG0ZbDw6LhELYegC20XFC2MXLjz9grjSFugBfXgCjLfGbiLcVbirwDbjKgHbj9 -wLbjKgPbj9gI7jncf7pJ0ZAT59sVinQQw8ysfd4JmrgB4xpUA+MW9iFmsfBF4DnElvECZISqeZcPgEF71naw+wNXpw1N+EVkCaQ8XuO144dscEZvXd70a4i63oo9WXuAVd/vAiQzoKjT8d+iCweZCSgIRxGNn+A2hL68z7ouxDUh0AVyMwAOZg5D6eryDT7suNkTmWcPIa+9D4P/jxYVuNm+iOg7cGsgGfoLiwoVADMjgRjXkURioHokMqMlRBao +gA7incdHRhEbOjyricYorBIiKnlIj4rDHBOQATR+xpUAqMd6s/MgkhJYud4GTKyVK4uQoRolDgcjtxwqWAXs54AElFkNqQKXl+1o4RiDm7vHCxsS+jlHsZia9mAiNHuZiPLkKiE0R0CKcRgBpyFJs/wH9JOQE0AeAPzQF2OGkOgNORmAPrMHIQBkNXnbNQJm5DfMfPBvKIfAv8Ykt1amKDlZI9t+HhFiCMYDjosWgtIHovDZMlRBaoH+By6ErVSH -H+AG6HFCPNgESf4METzBHqDhvqg9d4UxiECSaDBEV6RHNiIiT4VKcz4VxiVQeESgiSESjcQwDEUVyVGIHE59QKQA0PoUjOsTb9g0KV9Y4oiBiGBs18QLH49gDXQ07tsAhkeDRvZtCBNwDi4nERMit8SnCo8bITcDrTCFCe+ilCbGiVCfGjycb+iMACuQtCToSmgHoSDCUYSTCfnjPMYmZWpqQiaqnqIGPHeFlVu2Cfnio0LuFhiACZV8PCVUivCa +j4Sf4P4SW2H5tV4XnMVmixjoCSt9eEbvD09AIjFzkIibQaRikhsES/CQETDcaQSbYSwDpERIBGIEU59QKQACPrJiKrCuIPhMNkjmCXdsGA+18QHiA9vF7jRPCXQPlD1E1aDCAFSDplAId1tscb1sIfvjjVHviD1ob595CVo9FCeYDlCWnjVCeoTNCdoTdCfoTDCcYTL8Tgi7ZsdNz7gQiCPAMkQIsyZ2wecjvGpdwcMdki+LtQjhcbbce8UASZYU -Li2EUrCZwTL8NKrdk9ciNljtrcSiWvcSqcra9W0fa9kiUfCcAaIicsfN8JEc91ksa8ToctfC50X0cX9vUBL9vgBJAPUBJaEYBOQDb0k9EaAb+MwBF2AgBVsO49RAf1DU7khxZ+ndBRggOAUMY+cy0GdwP8JnxT4NLMHEcBDloRAjgUtxgqurHiBQFBCE8TtCNRuZiVkWTiKQenjNCU0BtCTHBdCZLR9CcEBDCcYSoAKYTsCuYTEzIMQlUaDcM6kl +k8pwQFVkcsHkrshyM4sXjlHZPLlpcYcDZcZ2iOMfET3Kpt8rQTljPCqIjHibcTppPlidwSbijDvUB39vgBJAPUB+aEYBOQOX1G9EaAH+MwAF2AgBFsJ49xAUSjxFszQQBoVUFKo38I2qFBzuAvlcUKfAYQHGh1Af508UmiCmqs+jRrBMiQEeF1W/JBCq6mf9vhsKi/ESoT8ONMTKCbMS9CcEADCUYSoACYShCtT87Zr0R4kTX9VUlkRrPn8B7VkC -J6YuyhqIR/j9iTci13MSsfpqviBcYC9GKgaiAYaC8JAC0Asbi0AhACuQjgDR4O/nKDQCQqCe/iDjqoYaSFaiaSzSe9NUdEcJ68ZaxgqDXMY+JcBSSRQxS7pSTmYqpCEPK1E9MQ+jGgUKBdIc+iaYa+ialnv8c4Z+jScatiuSagieSXySBSUKSEACKSViffiyzEC5JZqSBa6FcxHCUQJ/ITbgQCEphHFhWjtSVWjhccOCrSaOCibuOD4odASmydLi +odiX5DbNDmtSZt7jv8WLDawg3i4XhECWgNTchANOQjgEJ5ykZ18ACXWj73ri8dWDqTfanqSDSQTMgWvcInEOaxPKO1N2jESSCGOhIySbwS+MJt1XgmpCagbSSVovSSI0QTjTMXISd8X3cvriniVsZMSuSU0ANCTySdCXySEAAKTFiftir8R2ZenoXirCaSBXnOPJK8XctxksAR5MIXNcMcsD6Pm4SosWLiLiagC6QoRMoofM1OEWlj3XtvD5cV68 -qWvvDEiVg8UoWcCUCbVcu0Va5ISdUBoSbCT4SYiTmAMiS2AKiT0SZiTmqD1dPkTOiKoU7CSnsJiSyjgtcAGWFpMeUTtDpktd7KBIY4r+DHWJV5SXtXNZiMbgcsszFTSOD4QesYIehmZ95CDooXlBSSAUoUDaSTZ8oERnDWgQsij8WZi9oRZjEySgjpiZoA+BtUB6AFK1z1hhAg+EYBoMPojnACyIYAF+BsyUwcyJl3CSfuZIwcImgNXhTF86nH1X +ECVkxzgV0dnPOCTqgJCToSbCT4ScwBESWwBkSaiT0SZKEUiXWTYUUbiGHsJi8iaqCuFrgA2wjJj8kQ0sOlhS5sDmXEFIQcxEPBM8TEpMQDcM9tmtjqQcfFz1LBLRV7PoSlQVKSSSUtMC2UVy9V8e58jMS8MZCVvjQydmC2SUoSyQbRtjSHYNqgPQBPWv+sMIMHwjAJBgtEc4ARRDAAvwKmTliR2YlJvgjVUrBlvlDWNbBBIsp6pP0H8a4SJYQkCH -8Y8j8MZcTh8bFi+VGypV4ealiKWk1KWg6kSdE6lT4NKpvkecthfllj0RukS8sZIi9UmRT8mqCSChvOiX9od8fPl1DT8EpcinLm88iBD5LYkS88LIviljKl1LvuEEc+C/gg1HJEaMF+k49hyiwyYZjjjs2NPye0Dj8STiJiZyT/yWmtM0EBSQKQbwDAhBSoKbuAYKX+A4KasSjsafcGCcXjojg4VA2O/jqEThoITJIhTaGCEtSdKDSPp4S4XvhSfC +kUDiYsSEw3VDPDY0tKpCKbqZ00mrR9VKfBs0iaDFTmaDPiWQtviauDkif0MCKQM1gSSVDstm6C7vuF8WoSfhNLu04S3tkRcfD4CnIOTYsxI8A5ug9B0cB8pn8Bmo+glRhWMsvj2UQ+S+iWmCTMcyS1nOEdwycnjlsVf8VCZoBfyf+SDeE4FgKaBTdwOBS/wJBSlicMC6CZmTTpnGUA2E/jaxn7FWTH99VgtSN1SUussKRUiTSURizSSRjHZFzAmQ -dcT0AJbIuYCyDQ0ggBbsvdkNcoNI05ENlppFnIrXqFT0gHAAIqVFTicm9l7iTbJ4qc1JEqXAS2yYlCMsWaDIOpk8/iVaDJfk9tkqeFTDUulSYqVlThsglTOKQr8FEdVCjQGORzgMojdwEq9TvuID1iteRLyC9DoqI6xESK8kXEN4EPUccTXysAi3vrpjg0dNihhunCjMR+TD8dpTvyaVNmYWnjUEYBSWNiZSwKeZToKbBT4KQziCIRYtHupsSSfu +fGkEAMjlUcr7kJpHnILsktIi5Ik8JAAFT0gHABgqaFSJcjjkbiS7IoqV1IYqTL80njLj0sfmlMsR/llcdt8ing7JUAIFTEqeGlkqeFS0qZdloqWxTF0RxSRMRAAjQL2RzgHIjdwFq9Z/sgcgSseRDyA9DAqAcxoSLpFh4Hlo2MD8Bt3hI9Wtv6cQfn6SeiZpDgEUGSBifvNa1rD93yU3tPyXnDD8T+TZNoZTAKSZSwKRBSoKYzidkWT01iT91ybH -IgY4r8AqEXFcolLWtlBk99+wc9iziYDjvCSkDfCdwjOEdz9BzkVjUsYcDZ8h2TD4auCIFr+NMRoQ8erslimqaViWqcJjYooIAnfMwBIjpuSTTiDh5hDFMfIKH0e2oQwiUFpcO5N5RP8ZSjmYpMRs4MSswCL4UVSdjjIEa3clqUJMDAcysiQQH8k8Ygj4IZMSkyQBTjKaBSzKbMELKVZSbKQhTkLIDBeNhCQzGBZANXtDZdnIWlF3LhSB8dFiriYR +AYUxFziMMbOsQhvwgskbxcR4cK07kQL8fKVUjiMSOC8sUrUvqVATcqU2SMsXRTK5p2Tq5tpR9cSIixzpuDiCRHlsifCjGqXOTdWNgBBACH5mAOkdSiVnctmBjAmUF5BEkB0iMpgos2EJiQflIcc54KMRs4DmtQCMUkFSXeTkwY8Nk4apTnrov0XJnyjhiWGScwZEdIybpTJifpSdqQBTjKdMFTKeZTLKdBSp8oDBVNvw9LWO6EndtIVrsXfZTmKr -TygPbIGTObIupPVkOss1J8TJ1IZsoSZWpNdlWskNJJsk7IRpIAB5ECWkytJxMlsktk/KhpyzZMVpY0mVpqtPVpeJk1pw0l6kOtP6ketINpjUmNpptPayY2XuJVtLgx84IKpsuMBprGJKp7GNPhLFOe6ttPtpatI1pCOW1putPtk+tIayhtJNpA0jNpftMtpbKmtp85JKxlUJhppuI3icAElomuKNAtQHHeyNIow1yhYWN4TUI3kFugmmPdWKdlhI +Y2SsPC93s9STibQicKR4Sj1CEx3ZNqZ7ZINJVsntkupFKYBpE9kZTD1JEcttlJpPdkvZNNJAAPIgm0h1p4pkdkjsjdUiuUlxEgC1ps0h1petINpkpiNpU0hGkptLGk5tMtpHUhtpdtN2yN2RuJztNvKHCMlKrxLyppcwKpe8KKpB8Ip67tM9p+tMNpbORNpZtPdkFtLWyVtNtp40ntpEdKdp0qhdp86JxWcd1BJboIxR/NA1xRoFqAs7zRpXMV9x -WVlioMJEu4DKKpeMYgPM9GBJQWfDd+VMEHAawX1qQBD4wYoPmpSfTTB75NppGfUJxvmTZJP5I5Jf5M2pPXglJWaMP4Ak2QpeX2HAld0N2Smi8ghIlWq0JirxlZN8p1ZOAJgI0QIpY1rRH8zjgPyDCpqVMNSt0XvpxAEfpEVKn6BwlBwmASg8tLDisIdIm+OsIYp4dOyxHGIyJnR1fp79OfpO4PkRX2x1O+GxQgGgSLAYUyqid4mJAlGlOS4QX7gd +Y8CAidmmrGYJFzy4JG6swVDBIV3H9Rsz1zEkFlowBKEz4wF0uOH7UWI8PhSQFkFqBHdxjxMq0ZpcqyGJq1M0pbNP7uHNOsxxARFJTgONIj13gpo638oKINdWtYy8gEvmBqgRDgmJZLohxxLHh85QQIspPBhRjjjgHyHKpwVJBir9OIA79PDSdlQ+AtdhvcbHGpYaFk3h/1PypgNJV+FwLh2JVN1YNxB/pBXm1+cKONxYBSapHGxQgVgSLA9UxGif -3xIYjbARwsinxJ5blO4owU9MsajJp8cNHaqxC+86SAnpqlJ3xT6PxxRPTpp89Mx8u0PWpqeJ/RxfWBqTgPjQkszsg5VhopRZL4Qd1J+eeyhOUkiGlpNZJopEfRoCb8wNmjSSb+IQEPAkRNegbg0MKcp1uiijLsQKjPnAajMa+n9MVEhh3BKpbjv8HxJ+RwiP+RaRNBpG4PyxWjOUZepD0ZGjJgZYJKYBITnuAQgGiBFHBju70xyQ+SGysscS2i64 +4mJAoJihS1RX7gCgJwYq+0habQURAvbjO4qwQLMRagpp0cKnpZXjb+WtCX2/pJTByZWfJ/cWXp6lIZSrJPWp4xK/Jb4RwaYNxjQ1JTsgY1kopcpLSmTzkeAyINMSmFJepfXU8BJdF4C71L8pI4Mn+IQEPAoRNeglQxiKwpxBi6jOsQWjPnAOjPi2f9NuEAOGoCQDNACmDzVhcRKSh9FOyxTFJ2+BjM0ZEaBMZejKKhldIu+wPnuAusNtAZHETucM -GMy0YIxw0iCB8RgiJJt3C8gMOLS0Yrm2AfjxK6VkF0kuVm48T9wZuk9PK2G0ObefKMZpOlPZJX6NZpBlIQC3DMlJDuF42y1jsKqxAqKX+Pm8b8gg8pDLEp2GMAJMoMvpaqWfM0iFvp88IgAgAFwQQACoIKgBumYAAEEFQAgABwQXpmAAQhBAAEQgvTNuifTIGZwzLGZUzJmZ5m31oDuGAI9uCha/9ISJgDKSJFjMVxkp2sZnGM6OczKGZozImZ0z +MOAIUFXgNiUtGbp3hSoUGOYAeHqsFgnEe/UxFilMnTyOrjsOW6QtYrXksgtkhiCaFjB+vRIWp/RLVinDI8RLJK2hu+OphVmImJ3HlMJeH33pBizzRd+InUp5EBIqVyfqipNO82HmoZPgJvpVCM8p8jMh65DgkQz9I4aEAEAAuCCAAVBBUACMzAAAggqAEAAOCBjMwACEIIAAiEDGZIMXGZkzJmZ8zOWZqzL82KPlSivwn+KFIEgBrGNiJHxPsZQN -KhpBdLgZ1UN3AV4CaAPwHJmQ/yrpU4BV6CVCrS7kBJQqOy7C7uM46PWJhI4amGhWrWvMZDJrxMz2ycYrkDB2zQxIlkBDRacMg2/pzwOzDMWxviOJx+TITJlNisxa9JL6PDKLmjlK1urgV8SlyNXAcVl12ZmUxhz/Sex7nSFxrTI/SBzFkUnTOSaXoFwAjAB0ZnAAeoH9LihzNBZZepHZZ0DP5O6xWy2JtAbphhy/WGD1DpmWJAZTFMOZ4DPqEXLI +KIBINIKhT6HWZ0zLmZizJWZ9VLIJs5Pisu4CvATQB+Assxn+30IDBg4C+Mmih6meWmruueTxQCSWc6bWK7pjXl6hr3xQsNDOFu0vVxAOrgvsILV5akKg0hhMPyZ9NI4ZMiS4ZmLV7uG9IjJOlO3pAjIKaZhM0ApID1u7Rlcg0tOfxo+mxCZaPYot/jOAe1W6Z9J1uRKtOYauzE0UQzOeRLUFwAjACMZnAFOoH9KVqFNAFZEaGFZv9N1MQJTCgt7W -QArLIFKbAA5ZeRMExS5KLpeoEQgTQAI4XQBNAtIOIA0rFWYTQHoAfQBOAzgDgxfUNdxA0IOA1GDLm8BGfyW0U445aHrS9vyfuH9VFZsYLNO6yB2YXRNXsaIJ5QjHHBKapF7YKum48sLMGJjJOyZIxOMBYxJPxLNP0pq9K4ZXjSuGnEBYOLFCneRgjhC2dnIqCTNVJXbEzCPkB6mZ9NChemhGo76X5Eh3FQIYBLhh8kHAAS0FBQcADgAJoDsQNZmg +rGngMQ2MRMgGQox7RXGOTpPGJ2+YrIQAgrPtKbABFZWRIXRzzLhp8Vh6AiECaAeHC6AJoGpBxADFYCzCaA9AD6AJwGcA0dMaxmJK6hwLwSAVkD6iPvRJAvN0wKRaBXSuKRMS6eRsR3MKyQvrK4gNXTWQI/VDY1XmZK8pBBB/xSfxuTPmpr6KxZBgKKZsfx7uH1y0pe+K3plTJ3p0lRoue9k4gR2NXMiSKPcuqlXEU6npZb+P5qgOB8gLPzVJNyLv -AcUAyAUlRkwNwAYAfMF2SM9IZWTVm9qQyREAP8DI66QBNA9DNTU6TGHZ/SEPA+gAwgfbJLiSLIKAU7MCJbRFnZoaTOOqwBXZI7NnZ47Oeu27JnZY7PGJyFAPZa7PSAkrDKmp7PcGs7Orh7nyvZo7P0AiEG2ZZ8HvZ67KKOXbOyJZ7P0Az6CBpW7M/Z17KPZEmSYMNRFfZ6QAWw0mUkyU3CsCoHP0A43GRRNhBKgW7OYATfx5A+AHcMSUAFsukglc +pl8W5Wuqg4gYBFNJzH3NJPmjgwPQB2guAFyaY5PoJXUWwYeDmvIZKL6iBDJUU1cVam9FCIYpzGuAIvWhqfclpUIBGckE9LTS5An84PSLt0NuHnpj5LYZEZwX6OLOKZGlPxZH5L4Zm1KW8LcJLZQ61vxByNdiI8FJS3NTYuvgNbOklKGIlCLZZGpLyRUwhDUXQBaAu4AY29pRCAUSVtAlcKkuWTlgEVhHgEr/D2KBcDM6V4ElSHAGeA+ADKiC4H8Z -2ik5Yt5hagKHMNAHjVV2L+AhIGOhh6hL0LgiDwmAufwYABAGTgNGUTQrVV9cMHIvZ0YTEGW7NlAJAA6Sy7M45xABNACAEWIL7N45q2DYAO0AWwuAGnIQTHCkJAApwSkAwgPIGIy9x1wAAAAo5StQAq+tdgNOepzOxAABKXUBxwZQD5gLUBzAJTmqc7lK8AczlecbTlmQPTmfEK9l7sjkDVwrsruQ5wxxwYsDhwd+hKQTIASc4IAqQfxwBlQgCLEf +McAHZ0XmeAe7Fg5nqVBc23iuqYSX1J2bmqA+nUQgMk29aXNGzcC7AwgskEI503GI5W2H+xycWDYkLSiZPLN6aHvijSyaSEaED22B/HI9UlvRnBSWCfhhNllZVLB4gNjJ4RZzI1hXxMcZNc2ERNaQE5lvUQZ05KrpKDPhpgHOA5oHK5g9g2UAkHLgA0HKGAeyLWwQ6QaW2DEeURNN0k4lPli/cDXAtOhIqpWk2o/gIDRiDFtW2d1UyTNh30zcXGpS -xzU0dtmOw4QDkdW2C8SOzl2AcchmmMcnU0BJyicn9TU0STlU8UFALAQgCMAB6g8gSdzkLMIDBADLklNIdnMgAwDwc+kAEUzEzoZd5AZcrLmIPGjzhEGtnCSWfTabOhBWIFsBAAA= +yHJkDN06xjiIcumLOkJ2LKX6uLPcmpTNzZ5TLJxUZKqZu9Nwh+9O+ZVf1LGEGVr+P4gpQHHEUIa2iQyXGEXCfrNZZOSNbZHHODZITzgUKjJ7ZLmmIyUY1IyT4GYMvazAA8RG6itwU/ee6M8B5DIyQAXJQ8s8x0ygEWEMu2GAeYhm4yEhmLEnXAEychiLxDRH9EAKH7Zg7OHZ0mRjEKmHqJG5PUxKYjugY8GmIGmStwiyFtIeKE7ZR8URYaxCLEUh + +i0oZYgVAgmSm51Ykm4cqXUMDYhY5IKDm4LmUMOboPOApAC6AsIB6eeBJXJloSUZrcF6hpiU3At5IK0LOj1URYSSU1AkCeIvUamCPhQ8JDTL4MbM6Yg8HyQDwnh83cFVJKbIxZabMi5GbLPZWbM8RcyNzB++PghmiX4OopPJZZ21ZxOrw5+D5xGIyU1fx6UWjArjFEZfMNK5RxN6ZHLLzQwbB+MvqB45cQ3WSJFNdp2wIwgIvPrJ74K+MVw1dCUhT + +X4cnPYxtFPOZkDOBpBzScZMDPXYEvKnJMNOQZCbx1YyHNQ56HMw52HNw5WpQI5Wkis5U4RzWT8I3GhDA3ASdSMaQPI4grnPJk90V/B55EfI1LJGckhQUqO+huCnTgngzbmtYrTOppTiLx57DIJ50XPPZ3DLi5BLO0pFTP4ZFPKch5vXuAluwy5Fqyy551PBI4eIpOzPIQmP1AowLp3cpLbO5599LHYsIOnq9M3KWdXJiIJGUYMTXPIyy9FqwnvPy + +S3vJK6N1Nqw99nK2lLwfO6tG7gw3IEgXGTPovGTdEQ3Gm5Xohuhc3NEyFqQHZIQGW5fRFkyyYGcAmKGyQuB0nK6mKlB6mVmIxzFPRR3IeUbhkAkZ3OMybiCu5NyBm5/GTu59mRsyHVEe593Oe5s3CAY73KapFIHoAqEHHQbcObpTK2VkrcDHU0UGoC7kAoGDJXDhrU3bipSmaJIvT0UoJkMUkKW40s0MBoOB3YwPxTcYvvXtwOPI5RKlPx5D8EMB + +8eIzhrNKvZu0NFR1QWwRItL9BPmNOmFIVzEg8NrGL4TFBoLX55X+M55T1PgBzjC6cG42q5jyID6vHM4aWvOoxQ1x4FMdKbOBohbsspIk8iYgV5sBKV5inIcZ6rN+JggX4FmnJ15M5ONZzvAoA5HP/YVHJo5QwDo5CAAY5THIt52hiLipwGK84sQuABuC3iDvI/OuBSmS+uEcQHyjfwXvxGccPh4gGBSF0RkhXScTIIY/dLRZBMPQFEXIj5WAszZz + +NLXpl7N4ZBAtb21TKp59wHahPmMy5w9VMSLcS5qV0xBe1dEzSvqB/ZZXNL5bbMq5wPUF5z6Fr5DXPr54SEb5DBlqwnTgcFZEOGIzZ2KAbgt34ClU8FM3XOAA/NEMrXAm5F3KrEnogrEk/JEyWQAPQi3Ln5kGDHJjjkX5sYk/OzkjLieWg3gXCC351lGBKJ7gAkmeSR5hmXO5fGQuQZmWu55/PaFI3Cv5D3Lsyv9BsyjmV6euhje5/EO/WDgWy8GJ + +xzecMPGoe3DhIpxxsa25MRZAsV7AtIgHALnA+UiDHzQWIWMkvMVfOtl1iWHN00Um4VSQX+LQFylL8FJ7KXphPKCFWYPXp+ArJ5sCNvZxbIE8Um1U23ylBMmTNJG5Iyu4uqgVpP+LLJXlNhBE8GOuSoJieDCPKAX9ME59IQpFYnLdujMyF8IVEuEbO0T6XCPjpM5ykFFzOQJX+XV5UbmpFTzJyJ5BOd4LQH8QMABcGhAHJ2r2K5iC4QCotiShSxVS + +nxOB1eAkjm1Rb8ITaqDld+A/UOq4ZVH6jykXKR5HtIc8ldWoIvGxR7OoOgQpwF/KLWp8yI2pB+MRFQjIJOhDSI+BLn+UEh0gMt/TFBSHmvJqpMYFStOYF5fIMknBPYFuFM8JYDBE5aqh94AAD5NeQM1nAOGLo5q3MlaqjBa0vKoYxVGLJmjGK4xZnM/6ZeQaov1FQCHLzxBe8TJBaj1Cqar9iqVG5ExepyUxeLzoxbGKW5pmLPGfQ9tOXryfNH0A + +zBo7iegJBgWcf9zJRe+Zx9LKyDuKv53foDQ6iXAQocTRg2WMHjpoJRoOiVSS/habhqBhS52MF3JKxt4LAEWfpj2er1IRVHyieSUyvESTixiWEK1phEK96eSy6LvUyn2ZnllCk2zqBZYl5Cq1MdZBrQ5GTzy/CPYh9cOiRchQHoKxaJyYxdSKYxbEJhmuXSEsSGKk0t+Lwxb+Lwxf+LLyoBKlYdExxnqlhPAaMRUPPlpQGR2jmyQpzixUnTSxSnTk + +hF+KwxT+KbiEwA/xakIAJdHSFBYaz+RS8zneHakl2L3QugKdSfmYmYFwqSgWMovpQWa04R0qNDoSHGV1MQ41b6g9FnhRNQrFICpY+LqKzETvFd+IeyMBf4LT2duLoRdmyeGVaLr2TaLd+rWCRaRDczqUfSocO/ISqiR1XDDpsB7BzzDiUwKsMj6l7EOQ5LWB+LI8LhLkxeGKZ4TGKQYtZLCJbZKaxVmLRouiR6VI4g9cAWK0JUWKIViWKoGWr9+h + +o5KIxXZLwxXyLYabuDwAEtBAUHAA4ACaBrEI7FoAHFAMgIKNJMDcAGAHzAgUumyAhYtZIukoERAD/B9OukATQL4LT0tewCpT0hDwPoAMINlKZJUzTqhBVKehVVL40pmDVgOVLfCU1LipUK92pYVKqpSVKymWIwepZVL0gCKxFbkNLOpfoBK4T9dxpU0RmpSyLbLDNKipfoBEIO8j0pekSJpY+gAaWtLGpbNKupZfy9hWdFFpVVKZsPWI7+esInMv + +lKOpbtL9AD/QkUVYQSoG1LmAJP8eQPgBcjElAHKE+QA8J8pjFGfAWoM9LDQHk0MEDgcNNuVJhnMFiSgB94DAIRCGAAQBk4PJkaZqSA98EdKRpY+zL1kdA2pbKASAL9MEpFjLDwLMRfpZjLiAItg2ADtAZsLgAhyDTxh+CQBqcEpAMIDyAxMr8dcAAAAKSQrUAXgCV0dmWB4BkBmQAACUuoDjgygHzAWoDmAjMpZlME14A4sqNS3MtqAfMqRl60vF + +g/KErhN5SJO5JjjgxYHDgt9CUgmQHJlwQBUgHyUbKhAFmIHyQJoKUuyJwgAM6tsDLkSMrsAfZFWYg5IJoJThJlyGgJoFMu5EgKAWAhAEYAp1B5A0MrWwYQGCAHsrma+UuZABgDul9IF7xMllG5dMA9lXspoeQnlCI8kHAACkBRUTmzoQ5iBbAQAA ``` %% \ No newline at end of file diff --git a/ServerLMS/ServerLMS/CMakeLists.txt b/ServerLMS/ServerLMS/CMakeLists.txt index 8805faa..8cd8b7e 100644 --- a/ServerLMS/ServerLMS/CMakeLists.txt +++ b/ServerLMS/ServerLMS/CMakeLists.txt @@ -51,8 +51,10 @@ add_library(ServerLMS SHARED Systems/commonclienthandler.h Systems/logger.cpp Systems/logger.h - Systems/dataparser.cpp - Systems/dataparser.h + Systems/Parsers/dataparser.cpp + Systems/Parsers/dataparser.h + Systems/Parsers/clientanswerparser.cpp + Systems/Parsers/clientanswerparser.h Systems/processingsystem.cpp Systems/processingsystem.h Systems/sendsystem.cpp diff --git a/ServerLMS/ServerLMS/Systems/Parsers/clientanswerparser.cpp b/ServerLMS/ServerLMS/Systems/Parsers/clientanswerparser.cpp new file mode 100644 index 0000000..a9505d8 --- /dev/null +++ b/ServerLMS/ServerLMS/Systems/Parsers/clientanswerparser.cpp @@ -0,0 +1,126 @@ +#include "clientanswerparser.h" + +ClientAnswerParser::ClientAnswerParser(QObject *parent) : QObject(parent) +{ + +} + +void ClientAnswerParser::initialize(DataParser *dataParser) +{ + this->dataParser = dataParser; +} + +QByteArray ClientAnswerParser::authorization(bool result, QString instructorName,QString clientName, QString accessType, QString login) +{ + + QList listTag; + + SAttribute attribute1 = {"Result", result? "true" : "false"}; + SAttribute attribute2 = {"InstructorName", instructorName}; + SAttribute attribute3 = {"ClientName", clientName}; + SAttribute attribute4 = {"AccessType", accessType}; + SAttribute attribute5 = {"Login", login}; + QList listAttr = {attribute1, attribute2, attribute3, attribute4, attribute5}; + SXmlAnswerTag tag = {"ServerAuthorization", listAttr}; + + listTag.append(tag); + + return dataParser->xmlAnswer(listTag); +} + +QByteArray ClientAnswerParser::deAuthorization(bool result, QString login) +{ + QList listTag; + + SAttribute attribute1 = {"Result", result? "true" : "false"}; + SAttribute attribute2 = {"Login", login}; + QList listAttr = {attribute1, attribute2}; + SXmlAnswerTag tag = {"ServerDeAuthorization", listAttr}; + + listTag.append(tag); + + return dataParser->xmlAnswer(listTag); +} + +QByteArray ClientAnswerParser::message(QString text, QString login) +{ + QList listTag; + SAttribute attribute2; + + SAttribute attribute1 = {"Text", text}; + QList listAttr = {attribute1}; + if(login != "") + { + attribute2 = {"Login", login}; + listAttr.append(attribute2); + } + SXmlAnswerTag tag = {"ServerMessage", listAttr}; + + listTag.append(tag); + + return dataParser->xmlAnswer(listTag); +} + +QByteArray ClientAnswerParser::task(QString text) +{ + QList listTag; + + SAttribute attribute1 = {"Text", text}; + QList listAttr = {attribute1}; + SXmlAnswerTag tag = {"ServerTask", listAttr}; + + listTag.append(tag); + + return dataParser->xmlAnswer(listTag); +} + +QByteArray ClientAnswerParser::notify(QString code) +{ + QList listTag; + + SAttribute attribute1 = {"Code", code}; + QList listAttr = {attribute1}; + SXmlAnswerTag tag = {"ServerNotify", listAttr}; + + listTag.append(tag); + + return dataParser->xmlAnswer(listTag); +} + +QByteArray ClientAnswerParser::tasks(QStringList listTasks) +{ + QList listTag; + + foreach(QString task, listTasks) + { + QList listAttr; + + SAttribute attribute1 = {"Head", task}; + SAttribute attribute2 = {"IsComplete", "false"}; + listAttr.append(attribute1); + listAttr.append(attribute2); + + SXmlAnswerTag tag = {"ServerTask", listAttr}; + listTag.append(tag); + } + + return dataParser->xmlAnswer(listTag, "TaskArray", "Tasks"); +} + +QByteArray ClientAnswerParser::currentVersion() +{ + QByteArray array; + QFile fileR(version); + if (!fileR.open(QFile::ReadOnly | QFile::Text)) + { + QString str = "Не удалось открыть файл"; + qDebug() << "xmlAnswer: " << str; + } + else + { + array = fileR.readAll(); + fileR.close(); // Закрываем файл + } + + return array; +} diff --git a/ServerLMS/ServerLMS/Systems/Parsers/clientanswerparser.h b/ServerLMS/ServerLMS/Systems/Parsers/clientanswerparser.h new file mode 100644 index 0000000..141e5d8 --- /dev/null +++ b/ServerLMS/ServerLMS/Systems/Parsers/clientanswerparser.h @@ -0,0 +1,30 @@ +#ifndef CLIENTANSWERPARSER_H +#define CLIENTANSWERPARSER_H + +#include + +#include +#include + + +class ClientAnswerParser : public QObject +{ + Q_OBJECT +public: + explicit ClientAnswerParser(QObject *parent = nullptr); + void initialize(DataParser *dataParser); + + QByteArray authorization(bool result, QString instructorName, QString clientName, QString accessType, QString login); + QByteArray deAuthorization(bool result, QString login); + QByteArray message(QString text, QString login = ""); + QByteArray task(QString text); + QByteArray notify(QString code); + QByteArray tasks(QStringList listTasks); + QByteArray currentVersion(); +signals: + +private: + DataParser *dataParser; +}; + +#endif // CLIENTANSWERPARSER_H diff --git a/ServerLMS/ServerLMS/Systems/dataparser.cpp b/ServerLMS/ServerLMS/Systems/Parsers/dataparser.cpp similarity index 84% rename from ServerLMS/ServerLMS/Systems/dataparser.cpp rename to ServerLMS/ServerLMS/Systems/Parsers/dataparser.cpp index 291834a..1c6b478 100644 --- a/ServerLMS/ServerLMS/Systems/dataparser.cpp +++ b/ServerLMS/ServerLMS/Systems/Parsers/dataparser.cpp @@ -8,6 +8,8 @@ QObject(parent) { this->processingSystem = processingSystem; this->assetsManager = assetManager; + clientAnswer = new ClientAnswerParser; + clientAnswer->initialize(this); mutex = new QMutex; if (!QDir(staticDataFolderName).exists()){ @@ -296,38 +298,6 @@ QByteArray DataParser::xmlAnswer(QList listTag, QString elemUp1, } -QByteArray DataParser::xmlAnswer_authorization(bool result, QString instructorName,QString clientName, QString accessType, QString login) -{ - - QList listTag; - - SAttribute attribute1 = {"Result", result? "true" : "false"}; - SAttribute attribute2 = {"InstructorName", instructorName}; - SAttribute attribute3 = {"ClientName", clientName}; - SAttribute attribute4 = {"AccessType", accessType}; - SAttribute attribute5 = {"Login", login}; - QList listAttr = {attribute1, attribute2, attribute3, attribute4, attribute5}; - SXmlAnswerTag tag = {"ServerAuthorization", listAttr}; - - listTag.append(tag); - - return xmlAnswer(listTag); -} - -QByteArray DataParser::xmlAnswer_deAuthorization(bool result, QString login) -{ - QList listTag; - - SAttribute attribute1 = {"Result", result? "true" : "false"}; - SAttribute attribute2 = {"Login", login}; - QList listAttr = {attribute1, attribute2}; - SXmlAnswerTag tag = {"ServerDeAuthorization", listAttr}; - - listTag.append(tag); - - return xmlAnswer(listTag); -} - bool DataParser::loadBlankXML(QString nameFile, QDomDocument *commonDOM) { QFile blankFile(nameFile); @@ -456,89 +426,6 @@ QByteArray DataParser::xmlAnswer_ClientQueryToDB_ListTasks(bool result, QList listTag; - SAttribute attribute2; - - SAttribute attribute1 = {"Text", text}; - QList listAttr = {attribute1}; - if(login != "") - { - attribute2 = {"Login", login}; - listAttr.append(attribute2); - } - SXmlAnswerTag tag = {"ServerMessage", listAttr}; - - listTag.append(tag); - - return xmlAnswer(listTag); -} - -QByteArray DataParser::xmlAnswer_task(QString text) -{ - QList listTag; - - SAttribute attribute1 = {"Text", text}; - QList listAttr = {attribute1}; - SXmlAnswerTag tag = {"ServerTask", listAttr}; - - listTag.append(tag); - - return xmlAnswer(listTag); -} - -QByteArray DataParser::xmlAnswer_notify(QString code) -{ - QList listTag; - - SAttribute attribute1 = {"Code", code}; - QList listAttr = {attribute1}; - SXmlAnswerTag tag = {"ServerNotify", listAttr}; - - listTag.append(tag); - - return xmlAnswer(listTag); -} - -QByteArray DataParser::xmlAnswer_tasks(QStringList listTasks) -{ - QList listTag; - - foreach(QString task, listTasks) - { - QList listAttr; - - SAttribute attribute1 = {"Head", task}; - SAttribute attribute2 = {"IsComplete", "false"}; - listAttr.append(attribute1); - listAttr.append(attribute2); - - SXmlAnswerTag tag = {"ServerTask", listAttr}; - listTag.append(tag); - } - - return xmlAnswer(listTag, "TaskArray", "Tasks"); -} - -QByteArray DataParser::xmlAnswer_currentVersion() -{ - QByteArray array; - QFile fileR(version); - if (!fileR.open(QFile::ReadOnly | QFile::Text)) - { - QString str = "Не удалось открыть файл"; - qDebug() << "xmlAnswer: " << str; - } - else - { - array = fileR.readAll(); - fileR.close(); // Закрываем файл - } - - return array; -} - QByteArray DataParser::readTempFile() { QByteArray array; @@ -561,3 +448,8 @@ DataParser::~DataParser() { } + +ClientAnswerParser *DataParser::ClientAnswer() const +{ + return clientAnswer; +} diff --git a/ServerLMS/ServerLMS/Systems/dataparser.h b/ServerLMS/ServerLMS/Systems/Parsers/dataparser.h similarity index 80% rename from ServerLMS/ServerLMS/Systems/dataparser.h rename to ServerLMS/ServerLMS/Systems/Parsers/dataparser.h index 5cc1eea..35b421b 100644 --- a/ServerLMS/ServerLMS/Systems/dataparser.h +++ b/ServerLMS/ServerLMS/Systems/Parsers/dataparser.h @@ -4,7 +4,8 @@ #include "Systems/processingsystem.h" #include "Systems/tools.h" #include "Systems/assetsmanager.h" -#include "logger.h" +#include "Systems/logger.h" +#include "Systems/Parsers/clientanswerparser.h" #include "serverlmswidget.h" #include @@ -18,6 +19,7 @@ class ProcessingSystem; class ClientHandler; class AssetsManager; +class ClientAnswerParser; class DataParser : public QObject { @@ -29,8 +31,6 @@ public: void xmlFileDataParse(QByteArray array); QByteArray xmlAnswer(QList listTag,QString elemUp1 = "", QString elemUp2 = ""); - QByteArray xmlAnswer_authorization(bool result, QString instructorName, QString clientName, QString accessType, QString login); - QByteArray xmlAnswer_deAuthorization(bool result, QString login); bool loadBlankXML(QString nameFile, QDomDocument* commonDOM); bool saveDOMtoXML(QString nameFile, QDomDocument* commonDOM); @@ -41,14 +41,11 @@ public: QByteArray xmlAnswer_ClientQueryToDB_ListClassrooms(bool result, QList *listClassrooms); QByteArray xmlAnswer_ClientQueryToDB_ListTasks(bool result, QList *listTasks); - QByteArray xmlAnswer_message(QString text, QString login = ""); - QByteArray xmlAnswer_task(QString text); - QByteArray xmlAnswer_notify(QString code); - QByteArray xmlAnswer_tasks(QStringList listTasks); - QByteArray xmlAnswer_currentVersion(); ~DataParser(); + ClientAnswerParser *ClientAnswer() const; + signals: void sigLogMessage(QString log); @@ -58,6 +55,7 @@ private: ProcessingSystem *processingSystem; AssetsManager *assetsManager; + ClientAnswerParser *clientAnswer; QByteArray readTempFile(); }; diff --git a/ServerLMS/ServerLMS/Systems/commonclienthandler.cpp b/ServerLMS/ServerLMS/Systems/commonclienthandler.cpp index 64d4c09..6012e3e 100644 --- a/ServerLMS/ServerLMS/Systems/commonclienthandler.cpp +++ b/ServerLMS/ServerLMS/Systems/commonclienthandler.cpp @@ -69,7 +69,7 @@ void CommonClientHandler::slot_msgToClientFromGUI(QString login, QString text) { QString textMsg = text; - QByteArray byteArrayMsg = dataParser->xmlAnswer_message(textMsg); + QByteArray byteArrayMsg = dataParser->ClientAnswer()->message(textMsg); //Проходим все открытые сокеты, ищем нужный foreach(int idSocket, clientsMap->keys()) @@ -95,7 +95,7 @@ void CommonClientHandler::slot_msgToGUIfromClient(QString login, QString text) { QString textMsg = text; - QByteArray byteArrayMsg = dataParser->xmlAnswer_message(textMsg, login); + QByteArray byteArrayMsg = dataParser->ClientAnswer()->message(textMsg, login); //Проходим все открытые сокеты, ищем нужный foreach(int idSocket, clientsMap->keys()) @@ -119,7 +119,7 @@ void CommonClientHandler::slot_msgToGUIfromClient(QString login, QString text) void CommonClientHandler::slot_sendTaskToClient(QString fullNameClient,QString textTask) { - QByteArray byteArrayTask = dataParser->xmlAnswer_task(textTask); + QByteArray byteArrayTask = dataParser->ClientAnswer()->task(textTask); //Проходим все открытые сокеты foreach(int idSocket, clientsMap->keys()) @@ -138,3 +138,4 @@ void CommonClientHandler::slot_sendTaskToClient(QString fullNameClient,QString t } } } + diff --git a/ServerLMS/ServerLMS/Systems/processingsystem.cpp b/ServerLMS/ServerLMS/Systems/processingsystem.cpp index 10aba0f..0696d44 100644 --- a/ServerLMS/ServerLMS/Systems/processingsystem.cpp +++ b/ServerLMS/ServerLMS/Systems/processingsystem.cpp @@ -25,7 +25,7 @@ void ProcessingSystem::processingClientAutorization(ClientHandler *client, Clien { if(server->getStateBlockAutorization() == blocked) { - QByteArray arrayAnswer = dataParser->xmlAnswer_notify(NOTIFY_SERVER_BLOCKED); + QByteArray arrayAnswer = dataParser->ClientAnswer()->notify(NOTIFY_SERVER_BLOCKED); client->sendXmlAnswer(arrayAnswer); QString str = QString(arrayAnswer); @@ -49,7 +49,7 @@ void ProcessingSystem::processingClientAutorization(ClientHandler *client, Clien instructorName = providerDBLMS->getMainInstructorName(); traineeName = providerDBLMS->getNameTraineeByLogin(clientAutorization.Login); - arrayAnswer = dataParser->xmlAnswer_authorization(true, instructorName, traineeName, "trainee", clientAutorization.Login); + arrayAnswer = dataParser->ClientAnswer()->authorization(true, instructorName, traineeName, "trainee", clientAutorization.Login); } else if(providerDBLMS->authorizationInstructor(clientAutorization.Login, clientAutorization.Password)) {//Авторизуется инструктор @@ -60,11 +60,11 @@ void ProcessingSystem::processingClientAutorization(ClientHandler *client, Clien instructorName = providerDBLMS->getNameInstructorByLogin(clientAutorization.Login); - arrayAnswer = dataParser->xmlAnswer_authorization(true, instructorName, instructorName, "instructor", clientAutorization.Login); + arrayAnswer = dataParser->ClientAnswer()->authorization(true, instructorName, instructorName, "instructor", clientAutorization.Login); } else {//Никто не авторизовался - arrayAnswer = dataParser->xmlAnswer_authorization(false, "", "", "", ""); + arrayAnswer = dataParser->ClientAnswer()->authorization(false, "", "", "", ""); } client->sendXmlAnswer(arrayAnswer); client->sendVersion(); @@ -80,7 +80,7 @@ void ProcessingSystem::processingClientDeAutorization(ClientHandler *client, Cli { if(server->getStateBlockAutorization() == blocked) { - QByteArray arrayAnswer = dataParser->xmlAnswer_notify(NOTIFY_SERVER_BLOCKED); + QByteArray arrayAnswer = dataParser->ClientAnswer()->notify(NOTIFY_SERVER_BLOCKED); client->sendXmlAnswer(arrayAnswer); QString str = QString(arrayAnswer); @@ -98,7 +98,7 @@ void ProcessingSystem::processingClientDeAutorization(ClientHandler *client, Cli client->getClient()->setLogin(""); emit sigUpdateListClients(); - arrayAnswer = dataParser->xmlAnswer_deAuthorization(true, clientDeAutorization.Login); + arrayAnswer = dataParser->ClientAnswer()->deAuthorization(true, clientDeAutorization.Login); } else if(providerDBLMS->deAuthorizationInstructor(clientDeAutorization.Login)) {//ДеАвторизуется инструктор @@ -106,11 +106,11 @@ void ProcessingSystem::processingClientDeAutorization(ClientHandler *client, Cli client->getClient()->setLogin(""); emit sigUpdateListClients(); - arrayAnswer = dataParser->xmlAnswer_deAuthorization(true, clientDeAutorization.Login); + arrayAnswer = dataParser->ClientAnswer()->deAuthorization(true, clientDeAutorization.Login); } else {//Никто не ДеАвторизовался - arrayAnswer = dataParser->xmlAnswer_deAuthorization(false, ""); + arrayAnswer = dataParser->ClientAnswer()->deAuthorization(false, ""); } client->sendXmlAnswer(arrayAnswer); @@ -259,7 +259,7 @@ void ProcessingSystem::processingClientNotify(ClientHandler *client, ClientNotif //TODO KAV redact //listTasks = pInstructorsAndTrainees->getDbLMS()->getWhatItDoes(client->getClient()->getLogin()); - QByteArray arrayAnswer = dataParser->xmlAnswer_tasks(listTasks); + QByteArray arrayAnswer = dataParser->ClientAnswer()->tasks(listTasks); client->sendXmlAnswer(arrayAnswer); QString str = QString(arrayAnswer); diff --git a/ServerLMS/ServerLMS/Systems/recognizesystem.h b/ServerLMS/ServerLMS/Systems/recognizesystem.h index 8478139..7d5c97c 100644 --- a/ServerLMS/ServerLMS/Systems/recognizesystem.h +++ b/ServerLMS/ServerLMS/Systems/recognizesystem.h @@ -7,7 +7,7 @@ #include #include -#include +#include #include #include diff --git a/ServerLMS/ServerLMS/Systems/sendsystem.cpp b/ServerLMS/ServerLMS/Systems/sendsystem.cpp index 3debd94..29b2324 100644 --- a/ServerLMS/ServerLMS/Systems/sendsystem.cpp +++ b/ServerLMS/ServerLMS/Systems/sendsystem.cpp @@ -12,9 +12,9 @@ void SendSystem::initialize(DataParser *dataParser,Logger *logger) this->logger = logger; connect(this,&SendSystem::sigSendToLogger,logger,&Logger::addTextToLogger,Qt::AutoConnection); - connect(this,&SendSystem::sigSendXMLmessage,dataParser,&DataParser::xmlAnswer_message,Qt::AutoConnection); - connect(this,&SendSystem::sigSendNotify,dataParser,&DataParser::xmlAnswer_notify,Qt::DirectConnection); //потому что возвращает значение - connect(this,&SendSystem::sigSendVersion,dataParser,&DataParser::xmlAnswer_currentVersion,Qt::AutoConnection); + connect(this,&SendSystem::sigSendXMLmessage,dataParser->ClientAnswer(),&ClientAnswerParser::message,Qt::AutoConnection); + connect(this,&SendSystem::sigSendNotify,dataParser->ClientAnswer(),&ClientAnswerParser::notify,Qt::DirectConnection); //потому что возвращает значение + connect(this,&SendSystem::sigSendVersion,dataParser->ClientAnswer(),&ClientAnswerParser::currentVersion,Qt::AutoConnection); qDebug() << "SendSystem thread: " << QThread::currentThreadId(); } @@ -83,7 +83,7 @@ void SendSystem::sendFileBlock(QString path) void SendSystem::sendVersion() { - QByteArray data = dataParser->xmlAnswer_currentVersion(); + QByteArray data = dataParser->ClientAnswer()->currentVersion(); sendXmlAnswer(data); } diff --git a/ServerLMS/ServerLMS/Systems/sendsystem.h b/ServerLMS/ServerLMS/Systems/sendsystem.h index 0f08878..7742e7c 100644 --- a/ServerLMS/ServerLMS/Systems/sendsystem.h +++ b/ServerLMS/ServerLMS/Systems/sendsystem.h @@ -5,13 +5,14 @@ #include #include -#include +#include #include #include #include class DataParser; class FileData; + class SendSystem : public QObject { diff --git a/ServerLMS/ServerLMS/Systems/tools.cpp b/ServerLMS/ServerLMS/Systems/tools.cpp index 3b55145..68de94f 100644 --- a/ServerLMS/ServerLMS/Systems/tools.cpp +++ b/ServerLMS/ServerLMS/Systems/tools.cpp @@ -85,3 +85,5 @@ QString Tools::createFolderPath(QString path) return folderPath; } + + diff --git a/ServerLMS/ServerLMS/Systems/updatecontroller.h b/ServerLMS/ServerLMS/Systems/updatecontroller.h index ddb4cf7..d8037a9 100644 --- a/ServerLMS/ServerLMS/Systems/updatecontroller.h +++ b/ServerLMS/ServerLMS/Systems/updatecontroller.h @@ -10,7 +10,7 @@ #include #include -#include +#include #include #include diff --git a/ServerLMS/ServerLMS/clienthandler.h b/ServerLMS/ServerLMS/clienthandler.h index 8b2f478..7e035b8 100644 --- a/ServerLMS/ServerLMS/clienthandler.h +++ b/ServerLMS/ServerLMS/clienthandler.h @@ -16,6 +16,7 @@ class Logger; class ServerLMSWidget; class UpdateController; class RecognizeSystem; +class ClientAnswerParser; class ClientHandler : public QObject { diff --git a/ServerLMS/ServerLMS/serverlmswidget.cpp b/ServerLMS/ServerLMS/serverlmswidget.cpp index c1b09d4..c943ec0 100644 --- a/ServerLMS/ServerLMS/serverlmswidget.cpp +++ b/ServerLMS/ServerLMS/serverlmswidget.cpp @@ -137,7 +137,7 @@ bool ServerLMSWidget::stopServer() { if(stateServer == started) { - QByteArray arrayAnswer = dataParser->xmlAnswer_notify(NOTIFY_SERVER_END); + QByteArray arrayAnswer = dataParser->ClientAnswer()->notify(NOTIFY_SERVER_END); //Закрываем все открытые сокеты foreach(int idSocket, clientsMap.keys()) diff --git a/ServerLMS/ServerLMS/serverlmswidget.h b/ServerLMS/ServerLMS/serverlmswidget.h index 75c60f0..d5e697e 100644 --- a/ServerLMS/ServerLMS/serverlmswidget.h +++ b/ServerLMS/ServerLMS/serverlmswidget.h @@ -11,7 +11,7 @@ #include #include -#include +#include #include #include #include From b2b445e1f1d7eb361ff4426ec879ec7c97c694f1 Mon Sep 17 00:00:00 2001 From: semenov Date: Tue, 14 Jan 2025 17:05:54 +0300 Subject: [PATCH 08/13] ref: segregate dbAnswer --- DOCS/.obsidian/workspace.json | 6 +- ServerLMS/ServerLMS/CMakeLists.txt | 2 + .../ServerLMS/Systems/Parsers/dataparser.cpp | 103 ++--------------- .../ServerLMS/Systems/Parsers/dataparser.h | 12 +- .../Systems/Parsers/dbanswerparser.cpp | 109 ++++++++++++++++++ .../Systems/Parsers/dbanswerparser.h | 29 +++++ .../ServerLMS/Systems/commonclienthandler.h | 2 +- .../ServerLMS/Systems/processingsystem.cpp | 6 +- 8 files changed, 160 insertions(+), 109 deletions(-) create mode 100644 ServerLMS/ServerLMS/Systems/Parsers/dbanswerparser.cpp create mode 100644 ServerLMS/ServerLMS/Systems/Parsers/dbanswerparser.h diff --git a/DOCS/.obsidian/workspace.json b/DOCS/.obsidian/workspace.json index ba81223..e1402e2 100644 --- a/DOCS/.obsidian/workspace.json +++ b/DOCS/.obsidian/workspace.json @@ -67,10 +67,10 @@ "state": { "type": "excalidraw", "state": { - "file": "MainScheme.md" + "file": "Алексей/DataParser scheme.md" }, "icon": "excalidraw-icon", - "title": "MainScheme" + "title": "DataParser scheme" } } ], @@ -219,9 +219,9 @@ }, "active": "9608f84166966ca9", "lastOpenFiles": [ + "MainScheme.md", "Алексей/DataParser scheme.md", "Алексей/ProcessingSystem scheme.md", - "MainScheme.md", "AssetManagerScheme.md", "Алексей/AssetManagerScheme.md", "Как умеем принимать, как умеем отправлять!.md", diff --git a/ServerLMS/ServerLMS/CMakeLists.txt b/ServerLMS/ServerLMS/CMakeLists.txt index 8cd8b7e..94990ea 100644 --- a/ServerLMS/ServerLMS/CMakeLists.txt +++ b/ServerLMS/ServerLMS/CMakeLists.txt @@ -55,6 +55,8 @@ add_library(ServerLMS SHARED Systems/Parsers/dataparser.h Systems/Parsers/clientanswerparser.cpp Systems/Parsers/clientanswerparser.h + Systems/Parsers/dbanswerparser.cpp + Systems/Parsers/dbanswerparser.h Systems/processingsystem.cpp Systems/processingsystem.h Systems/sendsystem.cpp diff --git a/ServerLMS/ServerLMS/Systems/Parsers/dataparser.cpp b/ServerLMS/ServerLMS/Systems/Parsers/dataparser.cpp index 1c6b478..3a66a04 100644 --- a/ServerLMS/ServerLMS/Systems/Parsers/dataparser.cpp +++ b/ServerLMS/ServerLMS/Systems/Parsers/dataparser.cpp @@ -8,8 +8,12 @@ QObject(parent) { this->processingSystem = processingSystem; this->assetsManager = assetManager; + clientAnswer = new ClientAnswerParser; clientAnswer->initialize(this); + dbAnswer = new DBAnswerParser; + dbAnswer->initialize(this); + mutex = new QMutex; if (!QDir(staticDataFolderName).exists()){ @@ -330,101 +334,7 @@ bool DataParser::saveDOMtoXML(QString nameFile, QDomDocument *commonDOM) return true; } -QByteArray DataParser::xmlAnswer_ClientQueryToDB_ListInstructors(bool result, QList *listInstructors) -{ - QDomDocument commonDOM; - if(! loadBlankXML(":/resources/blankXML/ListInstructors.xml", &commonDOM)) - return QByteArray(); - QDomNode listNode = commonDOM.namedItem("ListInstructors"); - - for(Instructor instructor : *listInstructors) - { - //Инструктор - QDomNode instructorNode = commonDOM.createElement("Instructor"); - listNode.appendChild(instructorNode); - instructorNode.toElement().setAttribute("instructor_id", QString::number(instructor.getID())); - instructorNode.toElement().setAttribute("name", instructor.getName()); - instructorNode.toElement().setAttribute("login", instructor.getLogin()); - instructorNode.toElement().setAttribute("password", instructor.getPassword()); - instructorNode.toElement().setAttribute("is_admin", instructor.getIsAdmin()); - instructorNode.toElement().setAttribute("archived", instructor.getArchived()); - instructorNode.toElement().setAttribute("logged_in", instructor.getLoggedIn()); - } - - saveDOMtoXML("ListInstructors.xml", &commonDOM); - - return commonDOM.toByteArray(); -} - -QByteArray DataParser::xmlAnswer_ClientQueryToDB_ListGroups(bool result, QList *listGroups) -{ - QDomDocument commonDOM; - if(! loadBlankXML(":/resources/blankXML/ListGroups.xml", &commonDOM)) - return QByteArray(); - - QDomNode listNode = commonDOM.namedItem("ListGroups"); - - for(Group group : *listGroups) - { - //Группа - QDomNode groupNode = commonDOM.createElement("Group"); - listNode.appendChild(groupNode); - groupNode.toElement().setAttribute("group_id", QString::number(group.getID())); - groupNode.toElement().setAttribute("name", group.getName()); - } - - saveDOMtoXML("ListGroups.xml", &commonDOM); - - return commonDOM.toByteArray(); -} - -QByteArray DataParser::xmlAnswer_ClientQueryToDB_ListTrainees(bool result, QList *listTrainees) -{ - QDomDocument commonDOM; - if(! loadBlankXML(":/resources/blankXML/ListTrainees.xml", &commonDOM)) - return QByteArray(); - - QDomNode listNode = commonDOM.namedItem("ListTrainees"); - - for(Trainee trainee : *listTrainees) - { - //Обучаемый - QDomNode traineeNode = commonDOM.createElement("Trainee"); - listNode.appendChild(traineeNode); - traineeNode.toElement().setAttribute("trainee_id", trainee.getID()); - traineeNode.toElement().setAttribute("name", trainee.getName()); - traineeNode.toElement().setAttribute("login", trainee.getLogin()); - traineeNode.toElement().setAttribute("password", trainee.getPassword()); - traineeNode.toElement().setAttribute("archived", trainee.getArchived()); - traineeNode.toElement().setAttribute("logged_in", trainee.getLoggedIn()); - traineeNode.toElement().setAttribute("group_trainee", trainee.getGroup().getID()); - traineeNode.toElement().setAttribute("computer_trainee", trainee.getComputer().getID()); - //trainee.setTasks() - } - - saveDOMtoXML("ListTrainees.xml", &commonDOM); - - return commonDOM.toByteArray(); -} - -QByteArray DataParser::xmlAnswer_ClientQueryToDB_ListComputers(bool result, QList *listComputers) -{ - //TODO - return QByteArray(); -} - -QByteArray DataParser::xmlAnswer_ClientQueryToDB_ListClassrooms(bool result, QList *listClassrooms) -{ - //TODO - return QByteArray(); -} - -QByteArray DataParser::xmlAnswer_ClientQueryToDB_ListTasks(bool result, QList *listTasks) -{ - //TODO - return QByteArray(); -} QByteArray DataParser::readTempFile() { @@ -453,3 +363,8 @@ ClientAnswerParser *DataParser::ClientAnswer() const { return clientAnswer; } + +DBAnswerParser *DataParser::DbAnswer() const +{ + return dbAnswer; +} diff --git a/ServerLMS/ServerLMS/Systems/Parsers/dataparser.h b/ServerLMS/ServerLMS/Systems/Parsers/dataparser.h index 35b421b..ed5da78 100644 --- a/ServerLMS/ServerLMS/Systems/Parsers/dataparser.h +++ b/ServerLMS/ServerLMS/Systems/Parsers/dataparser.h @@ -6,6 +6,7 @@ #include "Systems/assetsmanager.h" #include "Systems/logger.h" #include "Systems/Parsers/clientanswerparser.h" +#include "dbanswerparser.h" #include "serverlmswidget.h" #include @@ -20,6 +21,7 @@ class ProcessingSystem; class ClientHandler; class AssetsManager; class ClientAnswerParser; +class DBAnswerParser; class DataParser : public QObject { @@ -34,17 +36,10 @@ public: bool loadBlankXML(QString nameFile, QDomDocument* commonDOM); bool saveDOMtoXML(QString nameFile, QDomDocument* commonDOM); - QByteArray xmlAnswer_ClientQueryToDB_ListInstructors(bool result, QList* listInstructors); - QByteArray xmlAnswer_ClientQueryToDB_ListGroups(bool result, QList *listGroups); - QByteArray xmlAnswer_ClientQueryToDB_ListTrainees(bool result, QList *listTrainees); - QByteArray xmlAnswer_ClientQueryToDB_ListComputers(bool result, QList *listComputers); - QByteArray xmlAnswer_ClientQueryToDB_ListClassrooms(bool result, QList *listClassrooms); - QByteArray xmlAnswer_ClientQueryToDB_ListTasks(bool result, QList *listTasks); - - QByteArray xmlAnswer_currentVersion(); ~DataParser(); ClientAnswerParser *ClientAnswer() const; + DBAnswerParser *DbAnswer() const; signals: void sigLogMessage(QString log); @@ -56,6 +51,7 @@ private: ProcessingSystem *processingSystem; AssetsManager *assetsManager; ClientAnswerParser *clientAnswer; + DBAnswerParser *dbAnswer; QByteArray readTempFile(); }; diff --git a/ServerLMS/ServerLMS/Systems/Parsers/dbanswerparser.cpp b/ServerLMS/ServerLMS/Systems/Parsers/dbanswerparser.cpp new file mode 100644 index 0000000..fffd8be --- /dev/null +++ b/ServerLMS/ServerLMS/Systems/Parsers/dbanswerparser.cpp @@ -0,0 +1,109 @@ +#include "dbanswerparser.h" + + + +DBAnswerParser::DBAnswerParser(QObject *parent) : QObject(parent) +{ + +} + +void DBAnswerParser::initialize(DataParser *dataParser) +{ + this->dataParser = dataParser; +} + +QByteArray DBAnswerParser::listInstructors(bool result, QList *listInstructors) +{ + QDomDocument commonDOM; + if(! dataParser->loadBlankXML(":/resources/blankXML/ListInstructors.xml", &commonDOM)) + return QByteArray(); + + QDomNode listNode = commonDOM.namedItem("ListInstructors"); + + for(Instructor instructor : *listInstructors) + { + //Инструктор + QDomNode instructorNode = commonDOM.createElement("Instructor"); + listNode.appendChild(instructorNode); + instructorNode.toElement().setAttribute("instructor_id", QString::number(instructor.getID())); + instructorNode.toElement().setAttribute("name", instructor.getName()); + instructorNode.toElement().setAttribute("login", instructor.getLogin()); + instructorNode.toElement().setAttribute("password", instructor.getPassword()); + instructorNode.toElement().setAttribute("is_admin", instructor.getIsAdmin()); + instructorNode.toElement().setAttribute("archived", instructor.getArchived()); + instructorNode.toElement().setAttribute("logged_in", instructor.getLoggedIn()); + } + + dataParser->saveDOMtoXML("ListInstructors.xml", &commonDOM); + + return commonDOM.toByteArray(); +} + +QByteArray DBAnswerParser::listGroups(bool result, QList *listGroups) +{ + QDomDocument commonDOM; + if(! dataParser->loadBlankXML(":/resources/blankXML/ListGroups.xml", &commonDOM)) + return QByteArray(); + + QDomNode listNode = commonDOM.namedItem("ListGroups"); + + for(Group group : *listGroups) + { + //Группа + QDomNode groupNode = commonDOM.createElement("Group"); + listNode.appendChild(groupNode); + groupNode.toElement().setAttribute("group_id", QString::number(group.getID())); + groupNode.toElement().setAttribute("name", group.getName()); + } + + dataParser->saveDOMtoXML("ListGroups.xml", &commonDOM); + + return commonDOM.toByteArray(); +} + +QByteArray DBAnswerParser::listTrainees(bool result, QList *listTrainees) +{ + QDomDocument commonDOM; + if(! dataParser->loadBlankXML(":/resources/blankXML/ListTrainees.xml", &commonDOM)) + return QByteArray(); + + QDomNode listNode = commonDOM.namedItem("ListTrainees"); + + for(Trainee trainee : *listTrainees) + { + //Обучаемый + QDomNode traineeNode = commonDOM.createElement("Trainee"); + listNode.appendChild(traineeNode); + traineeNode.toElement().setAttribute("trainee_id", trainee.getID()); + traineeNode.toElement().setAttribute("name", trainee.getName()); + traineeNode.toElement().setAttribute("login", trainee.getLogin()); + traineeNode.toElement().setAttribute("password", trainee.getPassword()); + traineeNode.toElement().setAttribute("archived", trainee.getArchived()); + traineeNode.toElement().setAttribute("logged_in", trainee.getLoggedIn()); + traineeNode.toElement().setAttribute("group_trainee", trainee.getGroup().getID()); + traineeNode.toElement().setAttribute("computer_trainee", trainee.getComputer().getID()); + //trainee.setTasks() + } + + dataParser->saveDOMtoXML("ListTrainees.xml", &commonDOM); + + return commonDOM.toByteArray(); +} + +QByteArray DBAnswerParser::listComputers(bool result, QList *listComputers) +{ + //TODO + return QByteArray(); +} + +QByteArray DBAnswerParser::listClassrooms(bool result, QList *listClassrooms) +{ + //TODO + return QByteArray(); +} + +QByteArray DBAnswerParser::listTasks(bool result, QList *listTasks) +{ + //TODO + return QByteArray(); +} diff --git a/ServerLMS/ServerLMS/Systems/Parsers/dbanswerparser.h b/ServerLMS/ServerLMS/Systems/Parsers/dbanswerparser.h new file mode 100644 index 0000000..26300ad --- /dev/null +++ b/ServerLMS/ServerLMS/Systems/Parsers/dbanswerparser.h @@ -0,0 +1,29 @@ +#ifndef DBANSWERPARSER_H +#define DBANSWERPARSER_H + +#include "dataparser.h" +#include "serverlmswidget.h" + +#include +#include + +class DBAnswerParser : public QObject +{ + Q_OBJECT +public: + explicit DBAnswerParser(QObject *parent = nullptr); + void initialize(DataParser *dataParser); + QByteArray listInstructors(bool result, QList *listInstructors); + QByteArray listGroups(bool result, QList *listGroups); + QByteArray listTrainees(bool result, QList *listTrainees); + QByteArray listComputers(bool result, QList *listComputers); + QByteArray listClassrooms(bool result, QList *listClassrooms); + QByteArray listTasks(bool result, QList *listTasks); +signals: + +private: + DataParser *dataParser; + +}; + +#endif // DBANSWERPARSER_H diff --git a/ServerLMS/ServerLMS/Systems/commonclienthandler.h b/ServerLMS/ServerLMS/Systems/commonclienthandler.h index e4af2bd..a6e471b 100644 --- a/ServerLMS/ServerLMS/Systems/commonclienthandler.h +++ b/ServerLMS/ServerLMS/Systems/commonclienthandler.h @@ -2,7 +2,7 @@ #define COMMONCLIENTHANDLER_H #include -#include +#include "clienthandler.h" class ProcessingSystem; class DataParser; diff --git a/ServerLMS/ServerLMS/Systems/processingsystem.cpp b/ServerLMS/ServerLMS/Systems/processingsystem.cpp index 0696d44..ae055ab 100644 --- a/ServerLMS/ServerLMS/Systems/processingsystem.cpp +++ b/ServerLMS/ServerLMS/Systems/processingsystem.cpp @@ -134,13 +134,13 @@ void ProcessingSystem::processingClientQueryToDB(ClientHandler *client, ClientQu QList listTrainees = providerDBLMS->GetListAllTrainees(); QList listGroups = providerDBLMS->GetListAllGroups(); - arrayAnswer = dataParser->xmlAnswer_ClientQueryToDB_ListInstructors(true, &listInstructors); + arrayAnswer = dataParser->DbAnswer()->listInstructors(true, &listInstructors); client->sendXmlAnswer(arrayAnswer, PacketType::TYPE_XMLANSWER_QUERY_DB__LIST_INSTRUCTORS); - arrayAnswer = dataParser->xmlAnswer_ClientQueryToDB_ListGroups(true, &listGroups); + arrayAnswer = dataParser->DbAnswer()->listGroups(true, &listGroups); client->sendXmlAnswer(arrayAnswer, PacketType::TYPE_XMLANSWER_QUERY_DB__LIST_GROUPS); - arrayAnswer = dataParser->xmlAnswer_ClientQueryToDB_ListTrainees(true, &listTrainees); + arrayAnswer = dataParser->DbAnswer()->listTrainees(true, &listTrainees); client->sendXmlAnswer(arrayAnswer, PacketType::TYPE_XMLANSWER_QUERY_DB__LIST_TRAINEES); break; } From 8f051d100304f192cade6b5d71f5770398478408 Mon Sep 17 00:00:00 2001 From: krivoshein Date: Tue, 14 Jan 2025 17:49:37 +0300 Subject: [PATCH 09/13] =?UTF-8?q?=D1=81=D0=B4=D0=B5=D0=BB=D0=B0=D0=BB=20?= =?UTF-8?q?=D0=B7=D0=B0=D0=B3=D1=80=D1=83=D0=B7=D0=BA=D1=83=20=D0=B8=20?= =?UTF-8?q?=D0=BF=D0=B0=D1=80=D1=81=D0=B8=D0=BD=D0=B3=20=D1=84=D0=B0=D0=B9?= =?UTF-8?q?=D0=BB=D0=B0=20tasksFIM.xml=20(=D0=BB=D0=BE=D0=BA=D0=B0=D0=BB?= =?UTF-8?q?=D1=8C=D0=BD=D0=BE=D0=B3=D0=BE)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../docTasks/doctaskswidget.cpp | 4 + .../docTasks/fimtaskswidget.cpp | 69 +++++++++++++++-- .../docTasks/fimtaskswidget.h | 13 +++- .../docTasks/fimtaskswidget.ui | 70 +++--------------- DB_IaT/InstructorsAndTrainees/resources.qrc | 4 + .../resources/icons/malfunction.png | Bin 0 -> 18153 bytes .../resources/icons/procedure.png | Bin 0 -> 29881 bytes .../resources/icons/sign.png | Bin 0 -> 16990 bytes .../resources/icons/sign.png.bak | Bin 0 -> 2177 bytes .../resources/icons/task.png | Bin 0 -> 2761 bytes DOCS/.obsidian/workspace.json | 53 ++++++------- .../Drawing 2025-01-14 09.44.53.excalidraw.md | 40 ++++++++++ 12 files changed, 156 insertions(+), 97 deletions(-) create mode 100644 DB_IaT/InstructorsAndTrainees/resources/icons/malfunction.png create mode 100644 DB_IaT/InstructorsAndTrainees/resources/icons/procedure.png create mode 100644 DB_IaT/InstructorsAndTrainees/resources/icons/sign.png create mode 100644 DB_IaT/InstructorsAndTrainees/resources/icons/sign.png.bak create mode 100644 DB_IaT/InstructorsAndTrainees/resources/icons/task.png create mode 100644 DOCS/Андрей/Drawing 2025-01-14 09.44.53.excalidraw.md diff --git a/DB_IaT/InstructorsAndTrainees/docTasks/doctaskswidget.cpp b/DB_IaT/InstructorsAndTrainees/docTasks/doctaskswidget.cpp index c783632..23a7f65 100644 --- a/DB_IaT/InstructorsAndTrainees/docTasks/doctaskswidget.cpp +++ b/DB_IaT/InstructorsAndTrainees/docTasks/doctaskswidget.cpp @@ -274,6 +274,10 @@ void DocTasksWidget::addModuleToTreeWidget(Module *module, QTreeWidgetItem* pare { DM* DMmodul = static_cast(module); text = DMmodul->getLangStructRus().techName; + + itemModule->setFlags(itemModule->flags() | Qt::ItemIsUserCheckable); + itemModule->setCheckState(0, Qt::Checked); + itemModule->setIcon(0, QIcon(":/resources/icons/procedure.png")); } itemModule->setText(ColumnsTree::clmn_PMorDM, text); diff --git a/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.cpp b/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.cpp index 9aff7d2..2c3ff25 100644 --- a/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.cpp +++ b/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include "fimtaskswidget.h" #include "ui_fimtaskswidget.h" #include "tasksAmmFim.h" @@ -12,7 +13,10 @@ FIMtasksWidget::FIMtasksWidget(QWidget *parent) : ui->setupUi(this); loadTasksAmmFimFromXML(); - updateListWidget(); + + preparationTreeWidget(); + + fillTree(); } FIMtasksWidget::~FIMtasksWidget() @@ -105,15 +109,66 @@ void FIMtasksWidget::loadTasksAmmFimFromXML() } } -void FIMtasksWidget::updateListWidget() +void FIMtasksWidget::fillTree() { - for(TaskAmmFim taskFim : listTaskAmmFim) - { - addTaskFimToListWidget(taskFim); + for(int i = 0; i < listTaskAmmFim.count(); i++) + {/*Задачи*/ + TaskAmmFim task = listTaskAmmFim.at(i); + + QTreeWidgetItem* itemTask = new QTreeWidgetItem(); + + itemTask->setText(0, task.title); + itemTask->setText(1, QString::number(task.id)); + itemTask->setFlags(itemTask->flags() | Qt::ItemIsUserCheckable); + itemTask->setCheckState(0, Qt::Checked); + itemTask->setIcon(0, QIcon(":/resources/icons/procedure.png")); + + ui->treeWidget->addTopLevelItem(itemTask); + + for (int j = 0; j < task.malfunctionList.count(); j++) + {/*Неисправности*/ + Malfunction malfunction = task.malfunctionList.at(j); + + QTreeWidgetItem* itemMalfunction = new QTreeWidgetItem(); + + itemMalfunction->setText(0, malfunction.description); + itemMalfunction->setFlags(itemMalfunction->flags() | Qt::ItemIsUserCheckable); + itemMalfunction->setCheckState(0, Qt::Checked); + itemMalfunction->setIcon(0, QIcon(":/resources/icons/malfunction.png")); + + itemTask->addChild(itemMalfunction); + + for (int k = 0; k < malfunction.malfunctionSigns.count(); k++) + {/*Сигнализация*/ + MalfunctionSign sign = malfunction.malfunctionSigns.at(k); + + QTreeWidgetItem* itemSign = new QTreeWidgetItem(); + + itemSign->setText(0, sign.description); + //itemSign->setFlags(itemSign->flags() | Qt::ItemIsUserCheckable); + //itemSign->setCheckState(0, Qt::Checked); + itemSign->setIcon(0, QIcon(":/resources/icons/sign.png")); + + itemMalfunction->addChild(itemSign); + } + } } } -void FIMtasksWidget::addTaskFimToListWidget(TaskAmmFim taskFim) +void FIMtasksWidget::preparationTreeWidget() { - ui->listWidgetTasks->addItem(taskFim.title); + ui->treeWidget->setColumnCount(2); + + reSetHeadTreeWidget(); + + ui->treeWidget->setColumnWidth(ColumnsTree::clmn_ID, 20); + ui->treeWidget->setColumnWidth(ColumnsTree::clmn_Title, 500); + + //ui->treeWidget->setColumnHidden(ColumnsTree::clmn_ID, true); +} + +void FIMtasksWidget::reSetHeadTreeWidget() +{ + QStringList listHeaders = {tr("Title"), tr("ID")}; + ui->treeWidget->setHeaderLabels(listHeaders); } diff --git a/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.h b/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.h index 72f3b0d..981bc00 100644 --- a/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.h +++ b/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.h @@ -12,14 +12,21 @@ class FIMtasksWidget : public QWidget { Q_OBJECT +private: + enum ColumnsTree{ + clmn_Title = 0, + clmn_ID + }; + public: explicit FIMtasksWidget(QWidget *parent = nullptr); ~FIMtasksWidget(); -public: +private: void loadTasksAmmFimFromXML(); - void updateListWidget(); - void addTaskFimToListWidget(TaskAmmFim taskFim); + void fillTree(); + void preparationTreeWidget(); + void reSetHeadTreeWidget(); public: diff --git a/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.ui b/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.ui index 2170783..70106c9 100644 --- a/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.ui +++ b/DB_IaT/InstructorsAndTrainees/docTasks/fimtaskswidget.ui @@ -7,7 +7,7 @@ 0 0 400 - 409 + 472 @@ -22,29 +22,14 @@ FIM - - - - - - ID - - - - - - - - - - Type - - - - - - - + + + + + 1 + + + @@ -53,43 +38,6 @@ - - - - - - - - - Title - - - - - - - - - - - - - - - - - - Signs - - - - - - - Malfunctions - - - diff --git a/DB_IaT/InstructorsAndTrainees/resources.qrc b/DB_IaT/InstructorsAndTrainees/resources.qrc index 6c7d1c8..56c11bf 100644 --- a/DB_IaT/InstructorsAndTrainees/resources.qrc +++ b/DB_IaT/InstructorsAndTrainees/resources.qrc @@ -36,5 +36,9 @@ resources/icons/traineeArchive.png resources/icons/traineeFromArchive.png resources/icons/vline.png + resources/icons/sign.png + resources/icons/task.png + resources/icons/procedure.png + resources/icons/malfunction.png diff --git a/DB_IaT/InstructorsAndTrainees/resources/icons/malfunction.png b/DB_IaT/InstructorsAndTrainees/resources/icons/malfunction.png new file mode 100644 index 0000000000000000000000000000000000000000..616daecbed159c772d7f52a4629f2e3897dfd1bc GIT binary patch literal 18153 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 AsQ>@~ literal 0 HcmV?d00001 diff --git a/DB_IaT/InstructorsAndTrainees/resources/icons/sign.png b/DB_IaT/InstructorsAndTrainees/resources/icons/sign.png new file mode 100644 index 0000000000000000000000000000000000000000..842ee2d6f888ffa03110c576795397c026e402e4 GIT binary patch literal 16990 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 literal 0 HcmV?d00001 diff --git a/DB_IaT/InstructorsAndTrainees/resources/icons/task.png b/DB_IaT/InstructorsAndTrainees/resources/icons/task.png new file mode 100644 index 0000000000000000000000000000000000000000..5a4ae16d46e4ae42837712e02d480995726d402b GIT binary patch literal 2761 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 P00000NkvXXu0mjfDf?3) literal 0 HcmV?d00001 diff --git a/DOCS/.obsidian/workspace.json b/DOCS/.obsidian/workspace.json index 46000b6..2d4eecf 100644 --- a/DOCS/.obsidian/workspace.json +++ b/DOCS/.obsidian/workspace.json @@ -53,26 +53,24 @@ "state": { "type": "markdown", "state": { - "file": "Как умеем принимать, как умеем отправлять!.md", + "file": "Андрей/ВАЖНАЯ ЗАМЕТКА.md", "mode": "source", "source": false }, "icon": "lucide-file", - "title": "Как умеем принимать, как умеем отправлять!" + "title": "ВАЖНАЯ ЗАМЕТКА" } }, { - "id": "9608f84166966ca9", + "id": "22bbb58a8df4da9e", "type": "leaf", "state": { - "type": "markdown", + "type": "excalidraw", "state": { - "file": "Как умеем принимать, как умеем отправлять!.md", - "mode": "source", - "source": false + "file": "Андрей/Drawing 2025-01-14 09.44.53.excalidraw.md" }, - "icon": "lucide-file", - "title": "Как умеем принимать, как умеем отправлять!" + "icon": "excalidraw-icon", + "title": "Drawing 2025-01-14 09.44.53.excalidraw" } } ], @@ -219,26 +217,29 @@ "obsidian-kanban:Создать новую доску": false } }, - "active": "9608f84166966ca9", + "active": "22bbb58a8df4da9e", "lastOpenFiles": [ - "Порядок сборки Unity билда под сервер.md", - "Образец отправки сообщения с маркером.md", - "Как умеем принимать, как умеем отправлять!.md", - "Алексей/Board.md", - "Алексей/DataParser scheme.md", - "Алексей/ProcessingSystem scheme.md", - "MainScheme.md", - "AssetManagerScheme.md", - "Что умеем отправлять Server - Client QT.md", - "CLIENT SERVER.canvas", - "Алексей/Рефакторинг.md", - "Алексей/ТЕСТ-КЕЙСЫ.md", - "Алексей/Чек лист по переносу.md", - "Алексей/AssetManagerScheme.md", - "Без названия.md", - "Андрей/Безымянная Kanban-доска.md", "Андрей/ВАЖНАЯ ЗАМЕТКА.md", + "Андрей/Drawing 2025-01-14 09.44.53.excalidraw.md", + "Андрей/Безымянная Kanban-доска.md", + "Алексей/ProcessingSystem scheme.md", + "Алексей/DataParser scheme.md", + "MainScheme.md", + "Алексей/ТЕСТ-КЕЙСЫ.md", + "Как умеем принимать, как умеем отправлять!.md", + "Алексей/Рефакторинг.md", + "Desk.md", + "Образец отправки сообщения с маркером.md", + "Как умеем принимать на Server.md", + "Что умеем отправлять Server - Client QT.md", + "Алексей/Board.md", + "Алексей/Чек лист по переносу.md", + "Без названия.md", + "Алексей/AssetManagerScheme.md", + "CLIENT SERVER.canvas", + "Порядок сборки Unity билда под сервер.md", "Алексей", + "AssetManagerScheme.md", "SERVER/UpdateController.md", "SERVER/Tools.md", "SERVER/SendSystem.md", diff --git a/DOCS/Андрей/Drawing 2025-01-14 09.44.53.excalidraw.md b/DOCS/Андрей/Drawing 2025-01-14 09.44.53.excalidraw.md new file mode 100644 index 0000000..7417c69 --- /dev/null +++ b/DOCS/Андрей/Drawing 2025-01-14 09.44.53.excalidraw.md @@ -0,0 +1,40 @@ +--- + +excalidraw-plugin: parsed +tags: [excalidraw] + +--- +==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠== You can decompress Drawing data with the command palette: 'Decompress current Excalidraw file'. For more info check in plugin settings under 'Saving' + + +# Excalidraw Data + +## Text Elements +Блок ^8Cl4uc6G + +%% +## Drawing +```compressed-json +N4KAkARALgngDgUwgLgAQQQDwMYEMA2AlgCYBOuA7hADTgQBuCpAzoQPYB2KqATLZMzYBXUtiRoIACyhQ4zZAHoFAc0JRJQgEYA6bGwC2CgF7N6hbEcK4OCtptbErHALRY8RMpWdx8Q1TdIEfARcZgRmBShcZQUebQB2bR4aOiCEfQQOKGZuAG1wMFAwYogSbggAdQBOACEKgDEAFmUK3AAtAGsAVgAFAH12ACV6eoAzHP4S2ERywOwojmVglOLI + +TG5neIBmKsnIGA2duMbGrq2ARh4uvYgKEnVuHkatm8kEQmVpbkvGm+sl8SoAAMN2YUFIbA6CAAwmx8GxSOUAMTnBCo1ErEqaXDYDrKCFCDjEWHwxEScHWZhwXCBLKYyCjQj4fAAZVgywkgg89IgYIhUIq90kj1B4MhCDZMA56C5ZRuBM+HHCOTQ5xubGp2DUB1VQJBBUg+OEcAAksQVah8qtICyAHIcFksgBWMAA0lVmBVBqNGhCAPL4IEATQAih + +ADQBdG6jcgZM3cDhCZk3QhErDlXBAnkEolK5gWoqraDwQFbA0AX1BCAQxG+W1OjXO8Xi531RcYLHYXFVVWuBoYTFYnFtnDE3Cq51O53OAA4ujOU8wACJpKA17ijAhhG6aYREgCiwQyWQtVtWhaLZQkM6MQkIADZ9yHOH6Kiz4oNMM5MEGaia2vSUwlhmpAQlQBpgOWkY3EIcDELga61qq2z3jOWwtveQKzi8/ZEBwHQJkm+A3PCuLrmgm74GEBSV + +gUF6lEh6AztC+CNEI2D3gA4jy0yAtAWBQDy6xoM496NPeNw6qgzj1kC2gnGclx9kWdzEA8aCNIk95VDpM7nKhVSnBcVyvO8nyCWgJn9v80ptiUfLiiSCLIuiaJIDuOJ4jmxJws55LkBwVI0pkgnRkyrLsnxsq1qK/IIIKanCpZsXipK0q8nCcr9gqkh5haar9hqOLat8eo3EasFmqeEEQHaDrOm6Hpej6/qBqG4arFG/YxrgcaMYmyb9qmxDphIu + +DnNme7EHlhGDUWYTkaglz3l0PA8HpjR8P2HZDt2qCNLs22Dl2I4cGOaDxOtQI8FUPBbHZkCEMuq6LZR279ruhLEIe6QhRaA3Ef2sHwYh3woWhGFYWhJGpgRaAAyRbBkYxb0IDca6YBZ6CAIgggDcIIAfCCAFwg2aUAAKgJ5R40TPKjJwUAsoQRiAjwD0QLTWT1L1TJScpUwCQAgkQyh7RAwSjKFR2kFA5gEILHwi1AGo8noWS4KmTDxvDRHqqQHy + +pgQ5OY5TBPE38QiK4M4SM4C4JCGjuHqwAEmZXyqkkXQ0ZM9FXkxt4Pk+L5vh+X4/n+AHo8BY2gWwVA3MJ0kHbz+yHGtCTxF097rWtXSNBtNyqep+3xL8/ZvB8ru8NoWz3RcXSXTnek7Au1mLLZKVQk5ZLoCibkYh5uIVUSnflBSgXUrSEtFoyzJpVFmUxf2DkCkKIqL2KUKz+U0WTX4uXKt86qaiVuqsxVprmnkXVT7GCCa6gCNDWm8cQLgyTylN + +M1oBekC8Y8FZVotRoQILiThnJnG4O0uyPDuhA46w5RyAi6HqNa94tjN0vM9YIoMKJbntkWT6B4jx/VmoDIswMEKLSbFsVC6FzhnCBFUdBJQ8Jw3vtrXCSMoQo1wTcOAbBUzZDyBBM8qwHrFCBBBK+qwRHFE0iXa0YA4jV2AXQ+uudzhN0kdBXCoQoCwn0PoNQiEej8LpFrOa9kohSxqMNVMyhuDfwwEQrId9Ki1AaM0VonRegDDYMMMYEwaq02wE + +IC0clpw3WAdnGcQIxJdH0lta0EBlC4DgAfIJhBMA1hMQIkh/9+yZGIDYokdiSGihpFAfm0cKBvFwP1dhRZClVLArUxiL9qk8iCLuCgr1cE0XAFfF+cA4BsgoQ4go0A3gZHKELL4kwGCEAQBQGonlB4+VJMiUYWztmYggCE0CIUTRrn0GyOKw8JA91crs/ZE8jnpBWQPby5z0CjyChPa5IhbnHPqOFTenJ54fIOS445pzxQJULokyANzDkgvXhKSK + +W8AXzOhcC9IgxhCKn3qqZFnyYXpD9EfWApU7J7Nxai/Q9Q6ac0MfgHmOKgVQDuRSumDMmaPBJSixlxzDaVKFiLMWk8oVkq5ekUZUtmkx1aWUiZnKmX7iJBKmpIQ2k0jAoCr56RFWk0jugbyuzmDYAhMyAAGt8Vs8R5kGqNfgIM3B7yYW0F0HOqF07zKMGwAw4z2wEDtt8T2MrhVMvRV9T+uqpq7PxCQVlzMSWRuIGyBAaS0C82SbrYgABZNgI15W + +4E0MEbhVE8GGjTc8+iNQ4RtNIMobEAAKHgTZqC8AbU2i1wJHUAEoeSW2UEmGksxq24DrfdRtd0QS8GHW2ronb/UlE5aCqEBLpacH+g0hkN9LZpl1osL1JRMi5vzdwW2RaoVECTagI9NwOC9RtqQO26pzZ4RvXbGdkA7BOgQPMZgLIr1wEzdmq9ebemFvmTiaWjBSYevwDun+OreRpHmFAm4ISwQGG1TMcxpDmGcKA+9Is+BdH8wQ+ByDeTihQUgv + +wNmTJwgOKguWIAA= +``` +%% \ No newline at end of file From ce337ae6c8fde3317490a276e72a59e23c729416 Mon Sep 17 00:00:00 2001 From: krivoshein Date: Wed, 15 Jan 2025 09:43:40 +0300 Subject: [PATCH 10/13] =?UTF-8?q?=D0=A1=D0=BA=D0=BE=D1=80=D1=80=D0=B5?= =?UTF-8?q?=D0=BA=D1=82=D0=B8=D1=80=D0=BE=D0=B2=D0=B0=D0=BB=20=D0=B2=D1=81?= =?UTF-8?q?=D0=B5=20=D1=84=D0=B0=D0=B9=D0=BB=D1=8B=20CMakeLists.txt=20?= =?UTF-8?q?=D0=B4=D0=BB=D1=8F=20Release64?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- DB_IaT/InstructorsAndTrainees/CMakeLists.txt | 21 ++++++--- DB_LMS/DataBaseLMS/CMakeLists.txt | 48 ++++++++++++++++---- GUIdataBaseLMS/GUIdataBaseLMS/CMakeLists.txt | 4 +- ServerLMS/ServerLMS/CMakeLists.txt | 20 +++++--- TestServerLMS/TestServerLMS/CMakeLists.txt | 4 +- 5 files changed, 71 insertions(+), 26 deletions(-) diff --git a/DB_IaT/InstructorsAndTrainees/CMakeLists.txt b/DB_IaT/InstructorsAndTrainees/CMakeLists.txt index bdf31ae..75a5c22 100644 --- a/DB_IaT/InstructorsAndTrainees/CMakeLists.txt +++ b/DB_IaT/InstructorsAndTrainees/CMakeLists.txt @@ -122,16 +122,25 @@ target_include_directories(InstructorsAndTrainees PUBLIC ${CMAKE_CURRENT_SOURCE_ if(PROJECT_TYPE_DEBUG) target_link_directories(InstructorsAndTrainees PUBLIC ${REPO_PATH}/BUILDS/DB_LMS/Debug64) elseif() - target_link_directories(InstructorsAndTrainees PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../QT/BUILDS/LMS/DB_LMS/Release64) + target_link_directories(InstructorsAndTrainees PUBLIC ${REPO_PATH}/BUILDS/DB_LMS/Release64) endif() target_link_libraries(InstructorsAndTrainees PRIVATE libDataBaseLMS.dll) -add_custom_command(TARGET InstructorsAndTrainees - POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy_if_different - ${REPO_PATH}/BUILDS/DB_IaT/Debug64/libInstructorsAndTrainees.dll - ${REPO_PATH}/BUILDS/GUIdataBaseLMS/Debug64) +if(PROJECT_TYPE_DEBUG) + add_custom_command(TARGET InstructorsAndTrainees + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different + ${REPO_PATH}/BUILDS/DB_IaT/Debug64/libInstructorsAndTrainees.dll + ${REPO_PATH}/BUILDS/GUIdataBaseLMS/Debug64) +elseif() + add_custom_command(TARGET InstructorsAndTrainees + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different + ${REPO_PATH}/BUILDS/DB_IaT/Release64/libInstructorsAndTrainees.dll + ${REPO_PATH}/BUILDS/GUIdataBaseLMS/Release64) +endif() +#Только для TSMP! #install(TARGETS InstructorsAndTrainees DESTINATION ${VEYON_LIB_DIR}) diff --git a/DB_LMS/DataBaseLMS/CMakeLists.txt b/DB_LMS/DataBaseLMS/CMakeLists.txt index c18d4d1..ee0fd13 100644 --- a/DB_LMS/DataBaseLMS/CMakeLists.txt +++ b/DB_LMS/DataBaseLMS/CMakeLists.txt @@ -12,6 +12,14 @@ set(CMAKE_AUTORCC ON) set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON) +if(CMAKE_BUILD_TYPE STREQUAL "Debug") + set(PROJECT_TYPE_DEBUG TRUE) +endif() + +if(PROJECT_TYPE_DEBUG) + add_definitions(-DPROJECT_TYPE_DEBUG) +endif() + find_package(Qt5 COMPONENTS Widgets REQUIRED) find_package(Qt5 COMPONENTS Sql REQUIRED) find_package(Qt5 COMPONENTS LinguistTools REQUIRED) @@ -46,14 +54,34 @@ target_link_libraries(DataBaseLMS PRIVATE Qt5::Sql) target_compile_definitions(DataBaseLMS PRIVATE DATABASELMS_LIBRARY) message("${REPO_PATH}") -add_custom_command(TARGET DataBaseLMS - POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy_if_different - ${REPO_PATH}/BUILDS/DB_LMS/Debug64/libDataBaseLMS.dll - ${REPO_PATH}/BUILDS/TestServerLMS/Debug64) -add_custom_command(TARGET DataBaseLMS - POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy_if_different - ${REPO_PATH}/BUILDS/DB_LMS/Debug64/libDataBaseLMS.dll - ${REPO_PATH}/BUILDS/GUIdataBaseLMS/Debug64) +if(PROJECT_TYPE_DEBUG) + + add_custom_command(TARGET DataBaseLMS + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different + ${REPO_PATH}/BUILDS/DB_LMS/Debug64/libDataBaseLMS.dll + ${REPO_PATH}/BUILDS/TestServerLMS/Debug64) + + add_custom_command(TARGET DataBaseLMS + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different + ${REPO_PATH}/BUILDS/DB_LMS/Debug64/libDataBaseLMS.dll + ${REPO_PATH}/BUILDS/GUIdataBaseLMS/Debug64) +elseif() + + add_custom_command(TARGET DataBaseLMS + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different + ${REPO_PATH}/BUILDS/DB_LMS/Release64/libDataBaseLMS.dll + ${REPO_PATH}/BUILDS/TestServerLMS/Release64) + + add_custom_command(TARGET DataBaseLMS + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different + ${REPO_PATH}/BUILDS/DB_LMS/Release64/libDataBaseLMS.dll + ${REPO_PATH}/BUILDS/GUIdataBaseLMS/Release64) +endif() + + + diff --git a/GUIdataBaseLMS/GUIdataBaseLMS/CMakeLists.txt b/GUIdataBaseLMS/GUIdataBaseLMS/CMakeLists.txt index 4031e01..48ee309 100644 --- a/GUIdataBaseLMS/GUIdataBaseLMS/CMakeLists.txt +++ b/GUIdataBaseLMS/GUIdataBaseLMS/CMakeLists.txt @@ -51,7 +51,7 @@ target_include_directories(GUIdataBaseLMS PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../ if(PROJECT_TYPE_DEBUG) target_link_directories(GUIdataBaseLMS PUBLIC ${REPO_PATH}/BUILDS/DB_IaT/Debug64) elseif() - target_link_directories(GUIdataBaseLMS PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../QT/BUILDS/LMS/DB_IaT/Release64) + target_link_directories(GUIdataBaseLMS PUBLIC ${REPO_PATH}/BUILDS/DB_IaT/Release64) endif() target_link_libraries(GUIdataBaseLMS PRIVATE libInstructorsAndTrainees.dll) @@ -60,6 +60,6 @@ target_include_directories(GUIdataBaseLMS PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../ if(PROJECT_TYPE_DEBUG) target_link_directories(GUIdataBaseLMS PUBLIC ${REPO_PATH}/BUILDS/DB_LMS/Debug64) elseif() - target_link_directories(GUIdataBaseLMS PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../QT/BUILDS/LMS/DB_LMS/Release64) + target_link_directories(GUIdataBaseLMS PUBLIC ${REPO_PATH}/BUILDS/DB_LMS/Release64) endif() target_link_libraries(GUIdataBaseLMS PRIVATE libDataBaseLMS.dll) diff --git a/ServerLMS/ServerLMS/CMakeLists.txt b/ServerLMS/ServerLMS/CMakeLists.txt index 492cb4d..e09d171 100644 --- a/ServerLMS/ServerLMS/CMakeLists.txt +++ b/ServerLMS/ServerLMS/CMakeLists.txt @@ -73,7 +73,7 @@ target_include_directories(ServerLMS PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../DB if(PROJECT_TYPE_DEBUG) target_link_directories(ServerLMS PUBLIC ${REPO_PATH}/BUILDS/DB_LMS/Debug64) elseif() - target_link_directories(ServerLMS PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../BUILDS/LMS/DB_LMS/Release64) + target_link_directories(ServerLMS PUBLIC ${REPO_PATH}/BUILDS/DB_LMS/Release64) endif() target_link_libraries(ServerLMS PRIVATE libDataBaseLMS.dll) @@ -81,8 +81,16 @@ target_link_libraries(ServerLMS PRIVATE libDataBaseLMS.dll) target_compile_definitions(ServerLMS PRIVATE SERVERLMS_LIBRARY) -add_custom_command(TARGET ServerLMS - POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy_if_different - ${REPO_PATH}/BUILDS/ServerLMS/Debug64/libServerLMS.dll - ${REPO_PATH}/BUILDS/TestServerLMS/Debug64) +if(PROJECT_TYPE_DEBUG) + add_custom_command(TARGET ServerLMS + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different + ${REPO_PATH}/BUILDS/ServerLMS/Debug64/libServerLMS.dll + ${REPO_PATH}/BUILDS/TestServerLMS/Debug64) +elseif() + add_custom_command(TARGET ServerLMS + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different + ${REPO_PATH}/BUILDS/ServerLMS/Release64/libServerLMS.dll + ${REPO_PATH}/BUILDS/TestServerLMS/Release64) +endif() diff --git a/TestServerLMS/TestServerLMS/CMakeLists.txt b/TestServerLMS/TestServerLMS/CMakeLists.txt index 0f4c974..9c69ead 100644 --- a/TestServerLMS/TestServerLMS/CMakeLists.txt +++ b/TestServerLMS/TestServerLMS/CMakeLists.txt @@ -46,7 +46,7 @@ target_include_directories(TestServerLMS PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../. if(PROJECT_TYPE_DEBUG) target_link_directories(TestServerLMS PUBLIC ${REPO_PATH}/BUILDS/DB_LMS/Debug64) elseif() - target_link_directories(TestServerLMS PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../QT/BUILDS/LMS/DB_LMS/Release64) + target_link_directories(TestServerLMS PUBLIC ${REPO_PATH}/BUILDS/DB_LMS/Release64) endif() target_link_libraries(TestServerLMS PRIVATE libDataBaseLMS.dll) @@ -54,6 +54,6 @@ target_include_directories(TestServerLMS PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../. if(PROJECT_TYPE_DEBUG) target_link_directories(TestServerLMS PUBLIC ${REPO_PATH}/BUILDS/ServerLMS/Debug64) elseif() - target_link_directories(TestServerLMS PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../QT/BUILDS/LMS/ServerLMS/Release64) + target_link_directories(TestServerLMS PUBLIC ${REPO_PATH}/BUILDS/ServerLMS/Release64) endif() target_link_libraries(TestServerLMS PRIVATE libServerLMS.dll) From f530d1b0f42c762c4f3fa765d0de3487b44df9a3 Mon Sep 17 00:00:00 2001 From: semenov Date: Wed, 15 Jan 2025 09:48:09 +0300 Subject: [PATCH 11/13] hotfix: updateVersion --- DOCS/.obsidian/workspace.json | 4 +- DOCS/Алексей/DataParser scheme.md | 364 +++++++++--------- ServerLMS/ServerLMS/CMakeLists.txt | 2 + ServerLMS/ServerLMS/Data/Client.h | 1 + .../ServerLMS/Systems/Parsers/dataparser.cpp | 239 +----------- .../ServerLMS/Systems/Parsers/dataparser.h | 4 + .../Systems/Parsers/processparser.cpp | 261 +++++++++++++ .../ServerLMS/Systems/Parsers/processparser.h | 30 ++ .../ServerLMS/Systems/recognizesystem.cpp | 2 +- ServerLMS/ServerLMS/Systems/tools.h | 42 +- .../ServerLMS/Systems/updatecontroller.cpp | 14 +- .../ServerLMS/Systems/updatecontroller.h | 3 +- ServerLMS/ServerLMS/serverlmswidget.cpp | 4 +- ServerLMS/ServerLMS/serverlmswidget.h | 2 +- 14 files changed, 533 insertions(+), 439 deletions(-) create mode 100644 ServerLMS/ServerLMS/Systems/Parsers/processparser.cpp create mode 100644 ServerLMS/ServerLMS/Systems/Parsers/processparser.h diff --git a/DOCS/.obsidian/workspace.json b/DOCS/.obsidian/workspace.json index e1402e2..cc288df 100644 --- a/DOCS/.obsidian/workspace.json +++ b/DOCS/.obsidian/workspace.json @@ -219,9 +219,9 @@ }, "active": "9608f84166966ca9", "lastOpenFiles": [ - "MainScheme.md", - "Алексей/DataParser scheme.md", "Алексей/ProcessingSystem scheme.md", + "Алексей/DataParser scheme.md", + "MainScheme.md", "AssetManagerScheme.md", "Алексей/AssetManagerScheme.md", "Как умеем принимать, как умеем отправлять!.md", diff --git a/DOCS/Алексей/DataParser scheme.md b/DOCS/Алексей/DataParser scheme.md index 7305a3d..515fe1a 100644 --- a/DOCS/Алексей/DataParser scheme.md +++ b/DOCS/Алексей/DataParser scheme.md @@ -231,368 +231,368 @@ dS6ajkIcDELgh5dsG8T3EOBzbOctQ/KiRAcGyub5vgAlsNKR5oCe+BhAU0HFLBpRseggHAaB4G6m+5SH qxiGsQPoJDECsqJ6FkuBFkwOYSPQVR1I0rTtN0/SDCM4y6sz/gEFzek87TWQM0zpAs2zk4pQLABK4SS9wLJCNDeO2008VYsGSS1PJNxKfBEBIShaGYdhuH4YRxGkai2l7VRbBUAZDw8PsCTRa8fZWT2nFPfWTkuWS2ibG8vG1IDd32ecvclP5gWoPc2j7BFva1DdFJL+FsUZ1T667FCA7mfZJz3PESslKl9LpSUmUctlKroEK+VioV0pzQqd86ZV -1XanVy0GsappBo8h9BdF0doHROlAR1Aa5Qhq+hGpIE641RxhilFNaMV9IBzQTEmPIS0SgrTWiJTacFiyGXQLgZI8CjpILQLBciswkqtnbFdD4tkT6DmnpAF67M0CAzPtwr6nAfp/WulPGEfxbqgwPFdMmKd6wXiOvDO82Q8gwRfAw98lMyLKXKF0UYTRbS3T7JBJ8LY6LIyYixK6S9OK2T2JSQcH1U5CWIedesvISaQ1kvIkocA2BFlUWgR8UwQl +1XanVy0GsappBo8h9BdF0doHROlAR1Aa5Qhq+hGpIE641RxhilFNaMV9IBzQTEmPIS0SgrTWiJTacFiyGXQLgZI8CjpILQLBciswkqtnbFdD4tkT6DmnpAF67M0CAy4WOOcnAfp/VQP8HumwTjPD4qDA8V0yYp3rBeI68M7zZDyDBF8DD3yUzIspcoXRRhNFtLdPskEnwtjosjJiLErpL04rZKE8R7IIgEkWAmqAiZ4wkhyUmUNURwDYEWdRaBHx -TEwcUZ4L58HFDCcUBeS8N59jXh8eIm8NG7zMvvU+q9Qonxzk+VMFi8ahCgNyfQpsZCdgAgEnUhNRLOi1FADC20izKG4PQjAt5ar23QI7GoDRmhtE6L0AYwwxgTEBJAHoEkhDJmeC8HgmwTihWeL8Vy4IiTwimRAZQuAILBh2fqTA1TalUzOsw0cmRiAtIVG0txjTSBQDpvXCgcVcDrQaVchULzqLvJUhALU1FdRBAvBQWRUNc4FHzgC/RhjjG1C0 +TDCVMTBxRngvnwcUCJxQF5Lw3n2NeHxnHXC0bvMy+9T6r1CifHOT5UxWLxqEKA3J9CmxkJ2ACQSdSE1Es6LUUAMLbSLMobg9CMC3lqvbdAjsagNGaG0TovQBjDDGBMQEkAegSSEMmZ4LweCSNCtI54rlwREnhDMiAyhcAQWDLs/UmBan1KpmdZho5MjEDaQqDpxDzoZSiKQKAdN64UDirgdaTTrkKnedRL5KkIBamorqIIF4KDyKhrnAo+dgWGOM -hRVU3Mm5GRPgsyyBxx7PB4DCckAiID93BIkIc7xT4mT+DiPyECMEvH2GFAcFw7r5K3hiTOvBCUX24JglqYCuRlXvhAR+eVdSSlfiVD+FV1Sah/rqBqACPRAMtH1cB3VIEZX5TA80wC2qjj9IgsahyUGTVgNNXl2CFp4IzFmBAvSiZbTIaWe4h0qxGtQA6jKHYVI4k2Jsf4Y9eU8MnMGAEz0hGLmXFLe4pJ7j/DCtI8GEKfEwyUd0+81qGJWLRqgW +aY2oWkKKqm5k3IyJ8lmWQOOPDZMJyRn0gP3cEiQhzvFPiZP4OI/IQIwS8fYYUBwXDuoUreGJM68GJSCpYaU+q3zKvfCAj88q6klK/EqH8Krqk1D/XUDUAEeiAZaAVnV6W8DVTA80wC2qjj9IgsaRyUGTVgNNTBey5Q4KRvVLMCB+leNITtchIL7iHSrEazxvyModhUjiTYmx/hjwtTwycwYATPS+sI5cUt7iknuP8MKsjwbQtkookoyjry9PvHg6 -xQ4cTmURJSASRYCYeq+R4iSHJSZQxrtzCQcBWRiBrPc30nN63oEbRJQMrb6piwlkYKWvKZmy3lvgRWda9KG3VuULWh5+SfSeeYAg07jam2IObAqo4rZRFtqQXphdkKoXQicLCOEEB4QIkREiPtw5+3wAHKmEAu3NtYEsXUuBY7x0HYnUgycS0BnTuyne2coWKS2gCgAmkMOmuAADSdNzYtHoPQdWmA+h9BjpgXAPR6BIsYegeYiw6S6nIc4BlCy3 +xqM7EcSHDicyiJKRuKEo84mvjIZpprtzCQcBWRiBrA830nN63oEbRJQMrb6piwlkYKWFq5my3lvgRWda9KG3VuULWh5+SfVeeYAg07jam2IObAqo4rZRFtqQfphdkKoXQicLCOEEB4QIkREiPtw5+3wAHKmEAu3NtYEsXUuBY7x0HYnUgydy0IHTpyne2dYWKS2sCgAmkMOmuAADSdNzYtHoPQdWmA+h9BjpgXAPR6CosYegeYiw6S6nIc4JlSy3 -jeSJCRP18RwRcKJc3WoSRj43QZXCYc5JGOzx6rwbySRCSHBJSSQ4hK4rAexLifEhJiSkm41Ses3K0C8pvgK5UuUn5boUUVN+pUNPSqqrK2q8r/7aq9Lqq0/Kupz0U9fLVgDYGWeoaNGsyD6yoIjGajBsY5Q4KRvVW19qK0/idXtTYrrjrus6bXeelyvU2PuPCU+2NcWLtet2JE6XvpRu7KcHER9saJoQDmuRqbrzpqCSmdRT5NE6VRRo3REgbkUC +jeSJCRAN8RwQCP7o8WoSRj43SZXCYc5IBGzx6rwbySRCSHDJSSQ4PK4rAexLifEhJiSkm41SesF9uAWpvlyIVuUn5bqUUVN+pVlSf1lTVHUGZ/7aq9Lqq0YD1XdUgc86BgDYGWeoaNGsyD6yoIjGajBsYrULVzba1a9qfkkJ/GQ0smx3XHU9d02u88rk+rsfceEp9sYbMXa9bsSIMvfRjd2U4OIj7Y2TQgNGqAFEwxUdmkJKZNFPm0TpDFWj9ESF -vJUNgnJNCmKmApKY9DIAFyaFeHoe5lDYDg/cSgbAry/VqPgc4owACyV4dGxcBa87rxRzFTBiRAFG1iVJ5sxv60KMIANls9SUTx1bvFyS23nCD5QWttY611muyL0DaLRc5DeeJ4QfDOCyt4zi+4PFxdoKEJETLJbOKy0cvGwQkheNCEindPKhRByUCTCUwRcqWGlVV6nyoPzys/Uc4riqwylZ9r+xmdQZjM45nVKqoGuhs3xuzAgHNKqcyz+sBraG +uRQK8lQ2Cck0OYqYCkpj0MgAXJoV4eh7mUNgOD9xKBsCvL9Wo+BzijAALJXj0XFkFHzevFEsVMOJEAUa2JUvYrinxyRhXiOWjxjqSi8hJjWuSO284QfKG1jrXWes1zRegXRmLnIbzxPCD4Zw2VvA+o5B4GztBQhIiZFLZx2Wjl42CEkLxoQkU7p5UK4P6wSYSmCHlym0Cqes9Kh+eVn6jglcVWGZPoBfzlbVBVZnHM6tVVA10XU56KevtZ8zLVnP -5ommg7zuaZr1ktbg4Ju3CF2s+SQ0LO1yGAsRdQt1bn6kK4EN6xHw9/jrkx4IucIbc1Dmy8I3LaBgZ4pjfcQ3pQ9wyJrSm8nsNlGI0zfWfbOajvcXJGFeI52Hl4yrcm8mysO0QF5rVfcodBaRy4G2igj6g58yyLHgW4chYiz7VkAdQ6ZZQDlqbcd3BCUqzVsbOdOtF36xXZX8o67N26h3TbAM+6oMwfg4h/AyHUMcHQ5h7DuHb0YiLP7SP0f08IDj +6oQbQsRE00HebETNes2D/OhP24Q4Llatrhb2ii6hHq3ONNCwIX1KPh7/HXDjkooaNa4py9G369JgY8E8nGo3Q29xyL8bWqnsNVGIwC/WQ7ZWTuY0DaFGEV2lf1ju9W6S/iKYdogLzWq+5Q6C0jlwNtFBH1Bz5lkOPAtw5CxFn2rIA6h0yygHLU247uA8pVmrY2c6daLv1iuqv5R12bt1Dum2AZ91QZg/BxD+BkOoY4OhzD2HcO3oxEWf2UeY8Z4Q -1nhPH6v2sB/WgJOvjICCQQEBnHWc+xgefHBAFQ2Ru7jGxNqbM3sBzYW8t/D74gUN1IxsWEEOeJHCOK8JLfYeyomJXxIex9YRbJbpOIKROcIAEcVM2Vt8xdEgGVoRLJTgfg40wDlMGRCdqdhVSdtMSgKc9MMC1QjMap6d6pGcedmcQFNUOp2cNV7NoEmcLM+cSgBd3UQwTURcnJboLU/MrVpcbVVo5dg9SEldSxzhItBcYsPseB4tr4dcrdcVtgew +PH7PieP1ftYD+tASd02QEEoB7e3ZQNPbhS9iQI2xu7gm1Nmbc3sALaW6t/D75QUN1IxsWE0OeJHCOK8ZLfYeyolJXxIex9YRbJbpOIKQecgQNULU8cuVbpEgmVoRLJTgfgE0wDeUSNic1U6dRV8pxVdMpUNMZUqpGcTN6oWdlUnN2d7NOcNUUC1N+c4Ehc/BDVNdRcTVxcnJboLUZdcE5cMw7UHVvUwtnVSxzgosRdYtvseAEtr5dc0B8QVkW5ex -wDg0NYdhA9w1jdI1fopYlliQGNitSta1Xc00EYM1gkasnwGwCMPxA4pkBsAVbR7g+YuhSAeg6ZNswBttihdtvcbEOIkQfhBxvJLgg9Nd3ErtQ9ndw8/EzkHwXw4kwAIkEjokpl4jEjbpYD94bokQzgx5DholikPFSlylKlWIalAlBD7MmlblHB306EXwukTCoAD1oNYMEMkMUM0MMMsMcM8MjlZl5kXhXhvgW4fgkReJvhooLgdk9kDlc1BMCRvI +zcNZjglCRErdnE7J8QBFCBHcU1ndyYlE3dqsHw6snwGwCMPxA4ZkhtgVbR7g+YuhSAeg6ZtswBdtih9tvcC0HFJEBwXETgg8tcnlbsfFU0DCShAlgkTCnwEkwAok4jYkZlYj4iYDF594bokQzgx5DhYlSkQ9ylKlqlWI6lglg9ecWk7lHB306EXwekEYsgD1oNYMEMkMUM0MMMsMcM8Njl5lFkXhXhvgW4fgkReJvhooLhdl9lDkxFBMCRvIPJwR -PJwRkCBFplCATliAyi6ly1DRpDIBrlqj7lQjHlnlXl/kKj9ifkziQgAV79G4rl8AwUw8EA98YVygHCnCXC3D3srCvtRwyNDhEgVlsY7FvgktwSf8NgW4F5wS0lT5eIrITgiQaV1U6U/hGUR4gdxNt5ccUp8dL50DBVNNRUX5Kcjp8DaciDf4CFSDmo4FWc1VbNCdzMWpnN9UEFBdWCPNTUODxcShJcAtlogt5cwiBswsKF4gxD3VLttcroEQ4RUs +kDiVZlCBTliASiGkvVDQpDIAblKiHkgjmlXkAUG4gUyjdj/kPkzi64wVUQIUG4wiEAwNnw4JbD7CEBHDnDb9GsrDRwyNDhEgThahsYHFvhktwSf8NgW4F5wTnFT5eIrIpEeMNUODGVmUR5QdxNt8kpCc+VL4MD8DyctMcDJVadCT6cjN5VTNGpWcLMKDecOouc+MaC+daSBd6TIADURcQxWCvN2CpcSguCbVlo+CQtgihsVcKF4hRDPUbsdcroEQ -dhzcNZ/hlSRF6Q4Q1lHpsZGNCBHck1Ii18IBFEKtGjBSSgfDDs/DBwVk389heV8YLiIBrtnjJ0n0X0e130k8U8G0m1PT2lC989EdC9i8FYy83TV1Z1aoa91C698BIyJAm8LZt0xY287ZD9htRtxtJsKBptZt5slsVtQw71x8H1I8PSW0vTRxP0mY44l96RV8ANN8cSd8CkPCHsD9yg+gMITgFwAArCgTQfASDOmODfYNkUYPsqoAAVVGAfVvzmAQ +4Q0sdglDuwI16wTc1DuA4RpFHpsZtDdDStHjKss16ias0w80jspwMZi0389gLV8ZziIBQ9jTI9A4G0m0e131k9U8PTu0W1vS89xYE4kph0xYS8FZy9J03lG8JAa8F1I0l0DZYz0Bm8LZt0xZ287ZgUj9xtJtpsKBZt5tFsVs1tQw70J8H0o8X0vTOlo4mY45l96Q18AMgN8cs4+xnj4Vyg+gMITgFwAArCgTQfASDOmODfYNkUYAcqoAAVVGAfW+ -AWG5W+1Xn/zHiuHxByXkMhPRT7FYxPiWSJAJFXh41pX40SE2T+B2CGJWKgI5RxDxEJCJGALJFALxJI0gIZKJyFRFXyjFV00lSJMM2/hMwZ0anoNZMYK5yoPPLALUxZPpP5w5JYOFy815K4PjB4JTBl2FKdO2l2goWrnZJoWi3qNi2bB6xYUO3xD9RPgo2VO7FqCUIjXVNXBjV4kBl7H0NdKMNNJUViKfH60sK0Qa1qyaz6VqFwEqEW26CQFoh20s +IkCI2Uz+1Xn/zHiuHxDyQ2XtwgCYz7FYxPhWSJAJFXmRNsySgEy2T+B2AGKWI5XbNQBxDxEJCJGALJFAJSjxJUwJIMwkCwMpx01JKOjpzVEIOM1/gIVIOanoMoPAUvM1Q5w5DoMF3rC5M9R5I81NX5M4L824JTHl1FKdO2l2goWrgYI11rFqLi2bD6xYWO3xADRPgo1VODGBNULyzQGPhAMBkUK2kNLKwq1dyqzNOiIG2aw21+2awLnoFqFwEqGW -VRl8IxmxUhy+BCJ2NFOdIiNuxePu2hUewdikpkrkoXJRRsP+O4EeghzWX9TfxhBO2/0cjBziEh3o04M8gJCOBRLniXgWRPjCiHHMnorunt2xw5WSmrPxJ5UJIMxJy0wAolSp2AppxlSpNMwgrIIYIoNoLZzguZMgqQqYJQo1yFzYPQvNV8ywqlxwr4KIWOMdWEL2hOClLKplJalkN4AmO8jCk+EYuDDN3UNejYuDFCk+Hfzul5T1LBhK14oUTd0q +26CQFoj20tJ90LUxmS2Pi+ECK2PFOdNCP0KeL33A1ePKDkoUqUq6G01fG+0sKgsgHIUemh2kUDTfxhH92/whyxShxh3ow4M8gJCODpUQqXiWRPjCiHHMhYruj3KgKpmSlHCJwZD/PKiJLFRfhp1AvJPAu/iZ2pKVVgrQoZKoMQpZIczILZxAXQuF0wrFz5PNV83jFl0It4KC34O11KElJBROBlOYLlJahkN4DGO8jCk+DYrESHE4st27FCk+Hfzu -3NMgEtKnFUvjWPg0pcQuxC3X10ukkMIj0DgkA6A6z6DTygEW0DGiGwMgHIGT0j1Os5HOtqiuprBuvlX7QTiSmHTFlDNLzQHL0/ATM1mjIXVjOXXjIb0TLNmTPrFbz3QPW7N7IHKHJHLHInKnMqFnPnOLLHw4An2OvQCepeqyDeuYA+ujlrO/QbL/SNI3y3w5Vbl3wMvA07IkEQkqCaAwg6COAAgAHlpz6hqhqh+b6Bqgmg4M+yjA2RVcKYPt1tgV +gtR0LBiNOMpNLhmMM9xKC8OO00rxRh10tTgrUOO8Xu3Dxd2Vijw6C6z6HTygGW0DGiFss5PbXdPQBus5DutqkeprGeoVX7RDJGqLwjLLzQAr0/FXVnVqlr0TPr3wChokDTJeogDbz3QPV7P7KHJHLHInKnJnMqHnMXPLPHw4En3eogE+u+qyF+uYH+vrLYEbKBpbOOq30kw7KKTcOe3MokEQkqCaAwg6COAAgAHlZz6hqhqgRb6Bqgmg4MByjA2Q -vt/L1zlk1w7JLgKRCVf8F4JEkS38KVu4zzUS0DRwIqd5XhF5MiECcjkCPyCdvyMC/yycdNkryTUroBKS5VwLFU6S2TKD8qTb4Luc/boKIBmCyquSShPN0ExdML5paq0x6qBDGqhDCLAVviSL1daxyLJC9jOrWFPIYQeAksg0I1uwl41TLdOV0j7KeLDTys4Ylq1EhLGs1s/jxKC5iAhhbQ4B6BP1SIFKvClKDs1quINq7cHTS0nSXSG7Rx/FAlBL +1cKZ7L79G4/ipwllVlfCFrLgKQeVf8F4YQlq38qVu4Ly55IDsTJdYD0iECsjkDvy0DUrkL1N/yMrsCsq9MwKGdILmcaSqq6SarSqELuctU2S4KSgMLmCsKShPN0FJc8KWqCKLTAsiFTqnUyKQUXD1dotmDxCCNJD6KLphqkQSJ6NksQ0o1Tcl4ZrREv9Xh3KSshKI9DDRK1FxKzKzCpKmt6sWt0BiAhhbQ4B6BP1SJVKPD1LvDTttL7gjqQ93EnS -QkNFEiolCkUiV7bD0irb4DsikC8jCkCirsiiDASjTlyjU7KinlDjaitLUQDjWlb6OrmQmlfkG5zjL7LjiA363kbjKIlaHinjDTXijL0Bu7e7+6hBiLlYFaO61huxwQh57JzJvgewl5qUXKjIW44hYQ7oewSRcU1wfL4dzzOD6UMTmUADsTJMko8dPzTaA7b4PbnbbrjTAKUr4rPb0rvaSCsrQ7cqYLA6mTvzEL/aSq/BDVI60LY7ODqqE7lq9Q8L +XT1rRxIic1QkXxkjrCYlikkitEUjXg0j4DMikCcjik8jbsCiDAiizlSiM7yjXl9jqj9K7iFQn7Ol76BAXk3kriQgxTX7iATjPk/7KJbjrl8BIVHiuyD8B6h6R6x6lyfte61huxwQh57JzJvgewl5aUfLnIW44hYQ7oewSQNk1wQqkcUSCQ0TTgMSACsT2buUnb+VXbMCKcUbqdvbcrfaqSSCA7iqOSWprMmS7MQ63QI6SrOS6qY6GqE6ODmr5oU6 -P7ShxTAUMI2rTpdqC7Ds7SqUCRGNlDMsq6tCmKEQTJThpr9S5q56FrjCBLPcLTs0VL81ERAYvgp7XFlHZ69K3TygKy30Az9V20ibn0/TKzAnlovrl9uqQyx0J0KZgbobQbtZwb6w9ZIaQaTZYbWGEb28D1ObubeaBahaRaxaJapaZa5aPMSyCayyQn/He0lNF9vrUBGyXFmyaG5iWb2zDL2b0AhBiBpzahnA2BqhmBbRqhZaoBsATg2AOxqhzhpz +iKOr/7lchC9oMJ+rToBD5Tjs7SaUCQBETcss676RyQEQTJThlrBLXS27TSO7trIBdrrSi1ERAYvgHTF7P7DLzrytW7XxqzPSAy6z9U3qn0azgmAb88gbpYgzQaJ03SYyjZobtYEyNSmB4bEbUyzZ0z6w0aO8D0+aBahbRbxbJbpbZb5bFblaPMKyyaqyKaIm30QmlMl9ma/119nS05rbW5OzTKXifxgUhBiBZzahnA2BqhmBbRqglaoBsATg2AOx -zLCMlziM4b4G+FsZVaxi40iRT5dznJHhgogd1x7JAZvI7dfKOcBMrzhNbyxN7yqZHyZN9HXyFN7aCTHbmGsCkqyT34PaCDQLiC/4+HlUBG+VYKg7CrsqoLwWI7kwo7IAY7RdZHZpuDE7cL+DgstcVHmqKFOQNGOlc6CNKLWaZCroOJQpmLkThreFuq1C0nWLq7lkDhj4Dd66fG+Km6zSW6+s27YGxKLCC4Y42BNgKAmg+hsBEJ3DPCwBvCnGrT1q +qhzhZzEGIAVyfy/tHhgptaRiE0iRT5ISsVsY0cWKexg1vI57QrudryhM7zhwHzRwEqpNXzZMPyFNmH8TWHyTAKOHcCyT3aKSILeG/5+GVVg6v7GTqDw7A72SIX1npHkxY7IB46Jd5HZp8LhSCFiLvHSKXUQItGukaLvs6L+ndHtTSQgSGNJqyVTHuBJEDhj5Ddm7bGM0jCxKNEnxBtzCdFkGeb0AY42BNgKAmg+hsBEJXD3CwBPCbENKMYDqdLPG -ktNqPGdqcXvGDqfEQG+mIARWxWJWpXlnrDqTIByESIF4iRzJPhjFklj4DnnBAYF44QMU39ryC0w16wIDc1PgXhQp4RDhLhLhbJwqWzOUPnYqvnOGWHfm8CAWvawLeHfawW9VGHOoCqRGiqxG7rSqEXpGUW+SsF0WFHZdsXtKCLldcBdxCXlHLpDsS641bFnLGWNCwRHhjHRE4D8Q9gtwOXNWoiJRFqeXeCs1lLFXx7lXJ7NKOqNXUAysEmQmABFZ +TqX6zqw8/G01oH+WIBBXhXRXxW1npL6xyESIF4iRzIzsNlUlj4jnnJAYF44RsU39bzi11SZ4UTPgXhQp4RDhLhLhbJ4rrakqlMfz0DvnAXfmSTsr35uHKSCq+GirwW9V4KbMw7XbULBHo6kXZG0WBSsFMXHG9QcWVXM78XdxCXvHLpjseA411wOJvL0mhFlDHg6XgwoR8Q9gtwWWV67HNqOWeCGJZXp6tLDqlXrsdGfG1XhKrqKaABFZOUgGAG63 -OUgGAU63cdR70yPJdpgVdtgddz6vPFp6WXPIvOJ8M+d55JJiAavVJkodJg2K9pMnJ1MxGgFAZoZkZsZiZqZmZuZhABZpZvG+9H09Abdldtdjd6s5p6JtpjxNOUN5mts3rN4iQSDfmv8W0fACgHgACc4BAacnkSkPs4gP8Ps5QaVn4u/Dbb7P1Fjd1vFPsXFEycke1vsHB5i/7MkHYcEN/K5iN+sc26aDI3exA3IlAmKr81Np2n50k2NzhwFunE1v +cTRn0qPOdpgRdtgZdqJ4MlfYGuJsdBJ6dpJmdOMmGtJ43DJ5dBGlMk2HJlG/J7M8oYZ0Z8ZyZ6Z2Z+ZxZhAZZ1Zkm+9X09Addhdpdld5KtpvdlmhegMNs6A3fLm/fLVyDEWv8W0fACgHgACc4BAWcnkSkAc4gP8Ac5QCVr7CwtWx/NAANFjF1m3PsDZEyckG1geQh4EoHMkHYcEN/a5vjK2xh1IuA8ak+7IlAlKknDqNh4kr2vAwFvKogxyvUGCx -UWk5NqzSF4R1N0RsO+F9zaOnkqqtFmq4tpRu+pq9O3AIsrOqLMqiQgjKQqii6LqzZMKP1Eusult9idzka6uyyVeEukeXUqxgwl3Wx/ij3Mw1u8S9uwVnVqAIQBcXcSwGAO4IeuVken3a0tSlVqdrRmdud+sBe0w6rJ8VI2wtexSuIzejJS2uAvqvesT/Iirwo5kYotQUos5J0l+6+x+9pZRh+u5J+rRrr04v5P+vrq40bj5f+h/e+x4huZ47Vn8A +NqzKF8qmFgR+FzN9zOOnCpqjF5OrF2ZItwavF0sMsyivO6i7uiQnYoahUgkMKANatquxtzWltqa1eatkeA01aluy6tl9uj3DerlyS+yw1swguKAIQBcXcSwGAO4Ce6Vqeva+VxNRVvSwa5eh7Tpte80ze/e7exI/L+rA+224+xAkT3ItSspZkQotQYo85J05kCo9pZ+wavY1rj+4th+n+wFEB7xm5IB64ihLbO4iBh44yzVwZnSaL2LwgeLg1vli -FOLhLpLu4Sj+rSy+sM1lZPEM5uEMkAcJLe3YldcPEDj0kKeN4WHMAr1sh9E04TEqhx53E6K+h1TflaTxK2ToC+T+N4Fmk0F3ncFtTag3qDNmF4q7NiRzkvNjCuR/zBx6ZEzjq8t0sCjqzwXZ+rq8yYeUkM4Fijz3NE4dtjUh6JjqRLaIL+anAwd+x4dr3BVsem0g4ZBwlR0rx/a2dw618cssJgJjmB6+p/nxpghKJgvE9/6+Jo6y9o2KMlJ3WJgO +AY1oEvEeySKskAcZLPc0ldcPENj0kKeN4BHFA5HBlP4dE1lehx8rlIN8+ENl25NyTzKqnf5nK2TnhuN0FhN8g+FtTER3qNNiRjNxF7TlF3TnzfTxRwzwtlRkinq3AUjizkXQayt8vPiDibHFA4x1t9zpU9/cEW6Lt7Lja93detqgd/NFL1xg4DBnlR07xrLi68I6YQJ/05pjmFPNn19XtZaQGvd2Jvn0dUvI9gJqdW9+M3WK95M5JpG+91vTM9Gq -MzJp9lvF9vJqDdDzD7D3D/DwjngYj0j8j0fYDvn7tcJhfam+s39f9dpxmkDbp5D0BiABcfATkbAACJoNkUgZwJofmwGegQCTQPoI4fmoYI1ojFcqywG2yZHPiVz/ytZe1o55HeinsQNC5+3L11Q+Y68kTO8s20N5558uTN84tN7h2qT75778ndh92v77hhNkFpN4HlNvKxkjnaF/htv6H1zXNiqmRgt3ZItpHxRrFkUwsVR3Aeoat1AWzpsfO2tx +DFDtDjDrDnDvDngAjojkjsfAD7n2sxfBs79Zsjp1snp+D/rbsiQBcfATkbAACJoNkUgZwJoEWwGegQCTQPoI4EWoYNZjZkjNc2yNHPiJz8K6RZj7Z05g4c5wGS5vcs7/jRIG84Te8sTG7qmF8mTQx95r85Kh78TrKH59hyNrhj72N4g779Nv74R6FoH2FyOqRxg7k7N3ChR61AthXTqgy0zvaeoct1AAupsWztH0M4cY7z4Ix6usEQcdzuNeyJee -HYca7z4Ax8upKQcUn7gGNeyJeejMAmap3Tl0L7l+n4rvlqLgVrboVgFOAK8eMfYCgRFKCKZYSguegODUgI0XcIQIwZ4PoCID/BwBpyHALoM8CvBGBJA2AVbArTuIysj6K1JnujHHbqVVWM9LnnIkW52E/GD/RiE/yqavhr+SnchJSFxBs8P8b+JLJXUwaHMkczrYcK6wDYrIPWM8UhqSDxBwg7Sj0bYHsGIYCdQ2UVJTBJwYbt8fyxJf8j9w4bE4 +jFAlap3EnkS+xoL2rELvunu34vuguOAK8eMfYCgFFKCGZbl2SuDUgI0XcIQIwZ4PoEQP8OAWcjgLoZ4K8IwSQbAdbVWrbIlxlZU8XGw7dLsdTHZdUme6rR7Ahy7o2FygR/E/mf0W778UGshBENoDp4f438yWWung2cB2tIQjrd/D6yBKutwCYVUkHiDhB2lHo2wPYBQ1xyBtcSztIvoKnDal9pOALdKkC3ypV9oKYLX7kmzEYA8kKybGviIOb6uY -uGhBHhs3y04g9rM6bTTpm2045tdOSLfTj5kM7yNR+JbCfmZwrZNBZ+2PK6PZBhAWMm2d7DfvPCKy0sLcJjdGClgWKBdZqwXftsaTp7hc6qI7UeigMxgTstqcHTxqZ0rReI+2RpbRBICnyXVrqygVhvdRA5R5g4cQ96gkIPbiwj2v1UdCXml688p0V7G9oryXQPs5eMNDdOs0gC5N0y5QV3u7097e9fe/vZ4IHwAjB9Q+4fIDqWWSGxDyalNKDlbx +s2vJORrm0tQGcu+xncdn3woRNBB+qPYavZBhBWN62l7VznwmKyJlXoWpdGKljmI+c1+zPTppml7YON+2XuQdtTzAFz1R2S9Iyuv2PZp4fqT1ZQCjXIBc8Ka0+B6n4JRojpd2heA9iLyjKJMsmqNc9lLyTIN5Ze2TDdLkxKCPtO85QW3vb0d7O9Xe7vZ4J7wAje9fe/vf9pWUA7R5g4oQv6v4KN6M0Tev6f9KzVg4gY+mcAgZggIdg387+D/J/i/z -aawcrs8HTpoh2wESUGAX/H/n/wAFACQBYAiAVAJgEbc64ADbbtwC4zaAY0UIDcGPCRAkhWO5kReP7mij60cQ/VEhibVbhEghwcaXBp5EeB7BqG0BA3IvFtz+o9cpIf1KwJpAiCPuHUL7iSVr5u1/mDfOQU30B4t9yCPfCFkI074Q9u+h0PvpoIgDIt4eugxHgzwIQo8tGaPPaF0Mx5kULCsWezmS1lIqQ142wDiJcwcEaxeO9I0armnoyA5xq/An +f4f8v+P/P/mRzvyjcNaaALjNoDjRQgNwY8JECSGY59gWM64bHJXUehrhE+KJF4EdwTRENbcfYQ5k8x6YetxEc9T4Hij4j/BPmv5MNrwIjbcD3uvAuTn7UKqSCVOZVVNhIOB6adQexqbCmwT07S582jg7FnD1xYI8KhyPGLMS0Lqj9tB5IbYBxCuYmDeE10AIhiItz10+wZKdyMTxsGk8tqwXCSrvzC58tpuEgHoH+GQ7nArw+gaUkAOS4uNHEfhY -8NTxsa087GPguJMJWi438dWPQP8Gh3OBXh9AkpVLvK1HZj17EgRJxDl3VaYCeekAQrlVjiSlcV6yRSrrVnIwvAruDwxgTGj7D7MMkPrf4DGi+HYo+I/wRrsPRKQtdT6bXc+tsWfpRBuuA3XrnP3qJpAVEB6eoR7y94+8/eAfIPiHzD7fg9Q/RDYAshJDLJu2toyyESB2Ak96iMxbsDsMihsIvgvYUTEIL/gbEti5yUSPnX641FvR7o1+tcSm7jdv +NBl3HbQCp2ERc5J3TABb196RXGIlonIz7Chwhw4cMcL2DLEwAhuReHGiuH65SQgaUlh4Qvob4r6VSerrfU2Ko9v679IlmYTSBqID0uQh3k7xd5u8PeXvH3n72/B6heiGwJZCSFWRwhbhlkIkDsGxFmEpiO+DhIOB7BfBewomO7tBTWIbELkokWzh13uRtdx2zXY4r/W+ROlBuKY4FBRzG6QNJu/Ta3ugFpH0jGR0pCYT8QU7kJRikIXiAsI4RnBf -6NY24tR0AbzdgGZLFDugBFFiiJRkpNYZ9hi4QBSBvwSELxD2EcIzgaY0HFg1uhmRlkFzWxH8EmJ8c0SDKR7pQzhwCDOmBY/4e9zioyDo2Ug+vjIIU4ZUfaiguEaDxUFiCzxKIyRv325LsEDOEuEfjiOR7j98KU/UYKYKG5dV9ciIQcCfA5FG4MsoabfsGCLQEgksIMKnu4Jp4DteRRXJOn4Iy4YwcQsIbyHxCVHaU8uqo41n4xF5Vl+cwTd0vhIi +RtwKErdDMiSJLm9iP4OMR47moaGLKfENdzOGMNwxqBFhk9xL5SdXuIFaNhX2BZfdBBP3aqlIKEaqdfhYjL4S5iYKyDgRjVSHmCKUEQijOUI7rhKXUYUJRgmgxMcNQNyIhBwJ8JgQYMyzhp3OTKKeASGSwgwBKvnVlhKHZYOCKeTgkAejBp70ZT4e5BnoeInafiHKiAoJhz1XaNNoJvPAhPzyiFC9i8h7WIce3iGS86817eIcjQV7WwleFlPoff0f -Zi9D20TY9pE1yFhlAaEZIoWDRKHK9H22TNXtbFfblBP+3/X/v/0AGkBgBoA8AZAOgEm8ehZvV9KLxpDQdaatvEIR0zeGgY2xzvK8DwE5C7hTguAT8b2NwnfZ8QC8BjD8FxSHA/gMUWgQ617AvBZxx8MkO/inhZ9SG5k5VkiRLrRQzRG46AluMBQAjdxv5GTqCL+b6Yjx/3JTgqmvGE4wevALvqpxcy3i0RGIx8fyWfG+ChSb45RgSIoRwYvxOLJf +7P9SAr/d/p/2/6/89eVQg3pEwZpM1IOZvNoRb06FW8YGEAK8DwE5C7hTguAU8aWPRRoCnK2IVHAxh+AbJDgfwGKAQIxwvAWxx8MkO/ini7CwqvYOYfvA2Rz1EczAgcawOHFiNnuntccVG30xvDPuAglYkIPnHfDQ6zJdTspzXGt85BObJOtD2UEHiTOCPODGeK6pj8pqpDYcGwkmrDh3OhPTBjbiJ7vjrBMA2wd+K36p0/xVpACa4Pnq3YvGYEnk -oNQIbDg2EA1VAMOFAndUCUuKG6JYxgnci4JYXBCTKP8EsilWaAzCcTBuyRDfGEgQACwggABhBAAvCA9TAA0iCABWEFQCAA+EEABCIKgEABcIIAG4QQABwgg0nqWNK6mC9kh3UvqUNNGkTSZp80xactMDLZDYmeQ89jL0ybBAegSne9vXnKGfYwwrE3dBrydK+xRJITNaQNOGnjSppc0haUtMt5sA6ywwumk2Xt6ZjHeHZJbuUGARsBIMRgZQJnRg +f41Z4U1AALCCAAGEEAC8IEVMADSIIAFYQVAIAD4QQAEIgqAQAFwggAbhBAAHCDlSipNUgqZz2qGFSSpFU6qXVKamtT2pnUovAXhRwg00J4NaMvEOCA9AFOesHCbeyZgQRLYivApqo1qak1yaT6HqWVMqm1SGpLUtqR1MaFMTTerQ6DmzSfK9NOaHErVsAjYCQYjAygHOirQsLhdRJfCZ/B/k+AI5XgVkW8SSgeAaTvg8IJSSQ1UmdjgwgaJIHARW -a/F+xZrZ/B/k+Cw5XgVkQCUxnRTmTvg8IKyfg1slLjc0/qJIHASWT/ZT4aSF7rQ3DaScxBwIyQX5Lk6BTG+APNYkD1hFqcERNBQRhyFCkkVURxqe8ZVR0FPijO+gvETizSmAo+gmU7StlNzShRwQSyUugVJMnNtvOTg+eEiAxjJJe23PELjyJqkai6pyE1Adl22oYCIhBszwdEPQCAAmEFQCABGEC6mAB2EEADCIKgFen9TAAoiArTI8jsl2R7K9 +RA5T4ziTPgTnuGhsRxnAsccBTMk+1K+CnRVKuNdpiCKq/Uf4QuK05AidOII7cYKXBG/jIR6dMCWoJBR9A/JBlAKednBArJK6k1WSQ21MFcV54ZdIcKkiJFxSSRfbOmU42cGgCFWbgrkVAM8HEjEm5QQAEwgqAQAIwgBUwAOwggAYRBUAu00qYAFEQLqVHjVmazdZ+s4qWVONmjSYmYZYXpGSmlxDb2s0+adLxSGnsfsYYfCbunWlOlfYdEimmbO1 -m9SBpfs/aRRJyGnsjptEi9qdIQDnTGJGTK9kzAgiWx1etQ5Rk9NqbJDA5bsz2d7PDmDC/pNNG3vTTGHyTQZvTcGRIBaBXgKAlQHgEID/BCAjWcDU1hsC+DBR/sBtVeJxHT7J9T4CQc5gyiHAXMk+1wvyg5P3i4o7c64rHIILoaV96Z1fEEa7X8kUlWZwUlTq3y5kd8eZ8IvmWoLhYaChZenB8aLISniyXxY/BqmEMVzmcFwcs6ilOAP5rgdg6/In +l6yDZNs8DsbybItDOmm+doTvnYnc1qR6AFoFeAoCVAeAQgP8EIFQHliNgXwYKEDlNqrxOI5zKPqfASDx8nxQEwGDyiT49g4g2lKRNW2iinC9JT5QcWJzSrCpnhpk8vhZNxn+05xQdBcf93r5/DG+kjBFi33qquT2+UPTvnuNh4MzvJx4kFAuFZkMUpwy/NcDsGn6GD+Me5TUgLJRF3Qd5q8UWbyK/GBdyeSUnatLNSncRsYfEenplMy6KyxZysiQ -jsHtzKFmR5IL4HsL1nQTj+bUrlu7lqnpdnGx2bGHxHZ7T1Oe1s/LgUKfTez3pW0r6btP9kvTQ5G0j6dtO+l7ST2QZH6odJomoAgahQ66c6QTkXSleycqhanLulpkO8j0mpoTRQU4K0Fn0naT9KpolzreK+QGXbwQ4KSembNGuQhD7L7B6gFIQgIB3loIyhRA4jYOgz+zv5tSZwf1OuG1oPAbobcTat5F7DrhcUxtKeXEEcmzyXJrwyKkvM+ZV8o2 +AbP2kDSjpw0k2flKtl9SDpg046SNKDJjTQyE0mIU7IwkuyEAc0pIZkyWnezVpBEv2d4wDn1NupQCn+YdKGknTGJzQ1fCxMulxyOaU3HoQhAHL7B6gFIQgH+zem8sRJy3DYDg0Bzv49SZwQNBsKj43Q24OlbyL2HXAbILafGeuZpKhDaSW5DDduQZK+boynhXA3uTJ37nTirJinGycPLskpsHJDfDTmTMBEsFNx8g9yQvMllLzFc0I1ebgAAgbyS6 -vk9eczKFTHj5B0I/mam3CnB06CkPLNuHVPnlVhZg/eOtiKSm4iUp98sUni0BQARn5jnRLF3ARDst6ReWCcTYI0J/zCGK8MKvrKQXVSz+fI02VAr9ynYGWow0IdOxVGGzpgkeVBZtO4UEKsFHC9aVwvwWYKI5EvKidHLIUULZeM6CQGdNoWlCrp/Sm6WnJTJsSHpWcthXU2aVvT6lbS3hcXP+kwchFsk4Ga2UmEFwWgtoDoLUAAgLgF2hAurBZRIE +SWLuAiGZY4jTcpwR8WQxXhxUL5OUiAHYLJ7mlgBKUsRPtTOwB5LsEAjwb40vmQSv5uC/qfgrAUAKdp8SkBX/MIUQK7Z0Cx2agAhri9UhzpBBW7OSE3sCly0n2VmWyGYK6m208oN/ISWgL/5RCqOSQoukZSYObE26YnKoUQAWgtoDoLUAAgLgZ2NTOyu9KW5kY140OJSdCVBn/AUCB5TYNDg+BWRh4UiGECqUoblU/8XwEiHxGxS1sUCzzDAXMMOC -bA14EOKydCVxn/AwC/cR4JsAhwfArIw8fWgfyJl9hHlXwEiHxAxTrh6M1M1AJSB2GHB8kR8Y7oxlQKAisoq8xmU4t+4szIRbM5ThzJyrnjlBULJEVFIFkxSz5Wgi+XHQR7YVEJyUu+ajyn4xw4lCWQ7HdH3hLIMJKSsamkqAk5YtZoVL/FcLghciT+RsgpRAqQnFKJ6wQ8pWqywlVLbZkeLoItj6AAQtQYQW9ndSIl6JpVsqlgDGS6XELUAyybQL +FIj423ARJ3MeHdzlFWMvucKneEgtZxBM5NkTMcnCDDoMgsHhAFRZzydxHkxed3w2mCEs6uAGOPYsSzHZT5UIFZDIlcVzV6x3CaumYPngHANkFkPcqvz0JeCAum/G+UErlYz0R28sgytlP865Sn0XQZbH0AAhagwgF7V6kEKpU0q6VLAWGihMgWoBJEWA3woY2RDcZAZToh2WDVyXTT4FiC7CTL09nQBUFGZdBU+2qVbSGmLK2lfSo5XnwIO50mOd -ZChD6NkQ3GTGSOm6UA1yFdEqhYMqTllDRl0AW6enMmWZzIl6ImZckKlUyq5V6q8+FJLLlAyRFVc8RTgIkBdBMARgI0PED/AtBWGgos5f9FMhjwgqs48yCFTuUPA4QeIf3PYgDwrJeIRMlWpkTZZv5h4CJQFR5KhXeSJBLtHAnX3BGIqgW281FbC3RXqdERqg3xeoJh6oUB++bEJcSsxZkr8RU/I0FSvJYqQY0Ji9cEiQKnkg/hY4DJdXWWJbhUxm +0346W9ul/dCAF0EwBGAjQ8QP8C0BRp79c5/0UyGPCiotjzIMVBZQ8DhB4hzstkcJUCV4hQyQlSydIkyzfzDwESyMnEqjMe5GTRxL3e5aoseWWS8ZSnT5WqneX6KnJDBb5RTPB5UzE6HfVqrfP3HLzVBCPI0JCukJXQ40oi9cFIkmrkgKBgifmbNVDKXKfRQq7FWtVxVXz8VgS1kQ/LS5yzIljPd+TEt0RxLeplU+qYkvak6zkldS+JROsaU1Tp1t -Mo/gaR5X5LwFJsyBWO0CFNTLZCC1qTbKiG1LOFU0hpYtPdlNLygdSyaWerGkXqOlwZSXme1jknSr2lq2vPQptWML7V90x1R1WznsKr1J6m9YsvvXLLS5gimSeUrklM1RFTvHViM05AIArwfQKAJoCNB0xyOMcfmj0FqCYBdw1Qe4JUAj6rMo+mw/6JcEGLjF/WOpYeMnxuazj38CIACR5Oz43MhMN5YcAXzckPlpMJfN5u+Qr52KV5DimvvCukEu +sgXvbNQkwKxVzsgpa7KQWLSylcqvJmtMVVgSsFtS0dXtIamTrF1p04hagCg7tKrpcHBOYhyTkQBxmnIBAFeD6BQBNARoOmCRxjgi0egtQTALuGqD3BKgAfBAAsFXLTDrolwfoqMW9b6lh4Ufa8i2IJ4AEV4vqnYCnzuYiZHmbcrlNnzfJyZPyZaAvmwK7maZo1GaN7pOLUX8CE1WiuFiPLr5qdU1Sa9NeuJ+V/LQRNM3cRYuBXw8bFHQQfsP24Dq -KgpmVGEWir3lptMVra5EdFNh5drMRYsvQTfIMHvjoluADoLP3n479F+P4xEHRVtGYzDGfCSnhrNZWiIdgSWcRFZs5GVS11Xg+CRqPMLwzRKQoiRaUEgxHBbQRoSQCKIQFNdHGsogIVl0nZ7qnV2ErVopJ1aEA/NAWoLX+DbmIzVwDKBIJa0O6Hk3giLLGXQMeXjjvI9GbYPISni5ryQkIKENjEpk3QPJgnGmUJv44ia9xjiqtWCICmSat50mjxWI +j+s5LVtpcGii3ChVOPeeNFL5m5ZG1/GZLFPBujWMPx3bPFfYMSmmFlYlIkSS+sICQYjgtoI0JIFpGStNRB2e+SEtS6z10pG+V+dyKHUwo8xnEszRZqs02ahJSDFheQjXBuQzWm3Y8m8GRb7lIcSyusd5HozbBdyU8X1RsMhCwroqziDPv2LkXhr2BbtJRZjNo0TjzJcageZ8NJk6KU148gxV8u42ZrflEPHNfPLzXKNC1XVJmbgEYW1UaEspc8XY -K8WRTd5ymztUEu7VEqMWydUtpPx03yLkKpFdqt+JsT+EtkgaNWZ5GKkvCLIjwQ/tytAWn8N1CjVahFqFXoD91sE3CTENSFLhhYPQdbkEyF5PpYh12wgLdsyGarKJZEk1fkJqWUKbVxQj9darXQsSf1zCg9IhuQ2ob0NmGxCNhtw34bCNxG7oTnMnxXa2AN2u7U0yGGrKoN6+CubBv9X74fNdMHZQRHuBDBcAaWpReQkcqcCTRtkMeTsHy33K0kM4 +iRD5zyBLne8fPE8judZRFkR4Cvxsa6bO1+mglT2sc3ErwB0HSAWSo80UrYl1MWoUuGFg9A7gsEp9CEN22EB9tO7LlYL0QkirRelKzCYkKlUey108vNBb7KPWvqusH6r9T+r/WIQANQGkDWBog2VDsFU+HbWwD20HaI5TQlpbetIX3ryFMxJ9fAMNV0w+lBEe4EMFwA5zKO10N4DQLjQ24Lgy/FuGXLtWKT5MKky4Clo0mNzpFukkoMcqYYUbDJkL -vGfJhsnBFJ5fGRQjsJnnOT55kARrWG2a10zeZ4giQPuKZkIrutSK+tTJsbVyaBtWKobTipU2ja1NV8jTWEtfH9qpZU/VLWrms6aMspXVFZCdhMhQTrNJuQEsVLgLRROILcZdbtsPWN0Dto/I7Q1PNlRaQhoqlqedrtkQA6leCjBUssIkPagNLShZSHsIUaqDpT6mOWarjlvqaFVqkZcbG/UTLf1LC6ZfjUA2dST1wenhTHq9VY7pJ5cwDH6qQ5gz +YvhjJo0Sg6NJWwzOoqY1DyWNlWseSuIq3OSZ5JitybmqUbtU2tvfBHn+FLXSbUAQJf3CZDfEqaw0YibyI+KhDRROIChHxZtv8WkiLFzjXtc5vcGDrolvikdegHqVpKCF4C9CmE1nVjqGl6Sx3VdsiHjTohOSvJSe2NjbqHtpSmVeUpe2VKe+wO09bbtSW/yHd16mHXetc0dK9VSO7oYas2BCABynIZgMoHiAdBf+GEZbMwH0AS0FwQwGdpBhLFML -A16ATYEID7KchmAygeIB0GgEYRFszAfQMLQXBDAF2kGHsQoqo4bCNmqAJlBDiSy2QeBKyDcMcOCh2QfleudRWdi52Zi7hHEffiZBNEvDAV7wy0Xbk+A2jfhtM0QWLoZmVqJQ1arrZ/B62njj5Ta7meD0U3Yq5tgswJefJFmEqsRvaybYYLToVtbQ+m4llLCM2sJOMBwPQoysKk/ymWWs5ir8F85O7nNe23lW7oi6X9SRxAnRAXGYA9A4ALQSDJyE +QGD+P7CymhzJZbI9AoEhuFWEUh0Gey/XJwsDxbK54rcIkJKKX4mQCdso0NWIguFKjA0Ko24XWuuWKLblhWzncVpxm87B5ry0QULtZ0oURdXGlyeLv+X8bAVgmlQe1oR62gxNCIqWEiNYScYDg1LBFTMMPkoqBZwJX4JZHPkxScVSsntgEoFHctrVeiAuMwB6BwAWgkGTkJIBZksjKewS33LLJc1dNlWb8q3Ztty4CihRJXEUeEjFH96DhQ+mUa3K -kCyzpRW65npFuFW46KluXcVUaXVFL1YkVXWrOVwdElcNE+otfUaM33PDXJT4XfZ8IP0Bpfh9otLo6LKTOiqkmxDrjWw9HNIeuTpcsUcSdXDcf6H9J1dchUNjcKETY+sKChbF6UtlAKHA3gYINEHKdMa0fUsl52cVvlDu9baZJbitw1wrPCfUsnXCc7PWpDAkOQ1XH4hnuhfTcbYpa2n7YV5+thp1s3my7etd+xXZeLF19be+uKt/fio/2ot1NoSk +fAKjLhU+m4WqKq6T0auFSa+rqPWKNcK2hozrmmLfpMGGDLSIbv1zAnpi+uqYm4rXvAY5jsulCw1cAdAPgHID2OuvSsk0m8Q3BcaSkGNoIEtxW4a4Wno3pWTrgqdve8RdQwu60Mru9OyAIzo7mF8qNAFO5UVuxkxtV95WieYI1Hnsbqtaa7rRmuMWUytxTWgFeYvzWWKI9ajMFV0AV12cVIOk4eL8CRkP6QlHigGScPhVwQZtHavxQlIW0wGiVg4K -leEt11lsp+XQYdZSJ36TEKUVMyAzQKt2aEO2NGFeKfHtwrrrGLmk0nys3UCrt1OIFZBSGWTNSQ8iCnCQHoaYESmCSq30ubwF4PqSF8enpear+0MSAdaexvMDsz2g6AUdehvU3pb1t6O9Xe6oD3r70D7qmue2ZXhOGMSTAU3qyDeXpg0O8q91cmvRACvC4BMg+AK8LUAANaT25yioyCPEXhDFYQDypyTouxkLIV4yYtcCSFyS5qT4O9KyWuC4oY4S +EOZEuBIrEDa2qtBBJt3Pp4JgZJ3cyqgns8EJsyJCd7pQnxN0JYvf3Sk3nQ7rpVT29IQ+0PVVL0AGerPTnrz0F6i9Je6oGXor1V7Np+vOCeUeKOarI57TNpUnofUdCulz6npVeFwCZB8AV4WoOfoC2QS/szgEeIvAGKwhHgkiDFXwqWQrwvRa4EkPkhS0nwj6SktcHxWxxj6TDlGm5dRpMkxqeBpWmw/G3X1b7dFojQEwCanmuGotvG6mXmwE0+Gh -1gR0XYfPF0JU15HWjeXGxv2Jt4jiJpXU/pV0v7Ej+WuKZfMLbXztdt8lOk6ulm4A+yeR7Rq/OHAOJJ1kB6KLbqPjHlAiuSnCQ0dQNkmPdvuE7Z0fCEHq8lF29AGNJGnTTAAMiCTSRpqAQAOIgY0hafNMvUSBxTUpmU/KcVM9TlToxmJuMdNW9L45icmY1DQYV2qFj7EnPabxCZqnpTsphU0qcGm/SVlZe31eMLg3V6phhAQgEaGqALtbQ0M/YPGQ +N1isFQOSCPszIo0idI8NsxHRRHxR8U8oOGm06bEjRuiWT4dN1La0pFurKRtpZ5baIANUqqY1MAAyIPVKqmoBAA4iA1S2prUmdRIFpMMmmTrJ9k0VM5PLrkJnu2o7AvqMzSilzRx7TpH3WZCOjfhsY4HKfQ8nGTzJtkxyfKnx7ZjOq5PddP1XLHDVhAQgEaGqAztbQT0/YAjRnbLZzgskW0PUGWz4B5dOxwPhkM+nORtgSy447CCyPOcKQzHU4wkF -XaLZzgskW0PUEWz4ADdg+xcsuRirfYtglhn47CEuDwh+EjGfuMskoy3RgC9lG6EllzXP43OeW48qhM5ULzOmvkEXSfsRNO0eAPQE4AgD9QxtpdgoTQA2Z4CaA3smJ6I2FNiOImsTOnPFeiO0Gf60j3+wLBEvJXRLNAzwIkXNuzpEsMDJLEAz6i8jv5rJBU6jLbt9Q/G/giBkBS7rAXN00DAaogYopNY+aeA46eoPEFIDEATBJB5o2QeTFjxQogp8 +ujAF3KN0ZLClufzOdItp5HENxDH2+RmdCiyNeGx4A9ATgCAANGX1jWChNAaZngJoE+z/Gd9byzfYuJJl2GAR08mRrPL43Qmj9sJk/bLtXmaBngsI7rVRWNFGaCMkmzebIS8jv5lJNLMKa4tRWWQzgxxv4K2oSPf69Nv+zluSOs7jKTNPSngOOnqDxBSAxADQdAeSlpGDg7bSlqSryO5iuh+YiAGuZgAbmtzGgnYx9NYVGQp9cwuyHPULShjhwO3P -It0bi1iLCdNxm8zADvMPmTBrx9LUZC+E7D59ePJECJhO6dz7ICQXM/GJ7AFnmV4BUhhSCzFhRew9W6xVTFLVeTI2e4hs02ZbMHia1MuutVEbbVKDm1B8hCn2dV0jb39wS8bcZ2nMDrZzzwTScSIW0m6roUOJeHqu3N0amRPnc5r8u22cnqlrm42YduQGe7MYXbfHp+b2rfmJVITWIUaCYCzh6g05BcwMfD2XaLq2l0gLpf0tva49XSqXsdOQWZN/ +OfZGDN/A3RPYcM9kbrnt7Iqb+KKYOOMPyKHh8+wUGmYzNZmXh9G344xrX0lmN9jh4XZWcMXVmNx7h0xZLph5wnGZPVVs4JLhEDU+tIR0gXCGrWRGVkES9XYuGPnx99lU2g3VScJM/jiTDmuA16LHihRjzqrfI6DvupGgmAs4eoLOXbNR1ndEgEIaJdIDiXJL52rJT7tFV+67tqTaU8HtaMt4w9hEiQMadNPmnLT1p20/acdPOnaJIO4IbUPkuKWp -tENQHXMcqHPsHV2e9AN6d9P+nAzwZ0M+GcjPRmRJyOzS6kNMvmWDLkk0vT6uEXumCd7YiAJsE5D1BhYXQDoIhE2B0w+gzgOmBhA4Cch4gLQDCPUGEhaTI+CZ6Ps5DK1Dwp4KsteIZLQtZmvgSQOyAcLhLLEZ1XrGEDsPp3RRcewMPCzv3hO1m1M0nAcPsGwBUIpdEmwULgFqDEAjgPQHoNRaU3fkcTV4xi/ibV0sWxtX+ibVOayPTb06c5jKYbvE +LNILVdHPN4p6ljyOguJsE5D1BhYXQDoIhE2B0w+gzgOmBhA4Cch4gLQDCPUGEiumoNxGd0w+c9NoN3gXMteFJOyP9wA0SyFZOtyHAbKSQdapPjCDmG2RLgpIPiMDFkVcpEzwbd49BfMMDh9g2AKhCop+OChcAtQYgEcB6A9AULmFwXehZBOoXpBdWtw1mo8PosvDLW6XVYqIstnngvk3OmIUv0Sbr9jFB1l8ARBP795TKHlEfLU3eQbcp5bYGxfi -JAHDNDnalZlmdZfAEQ0BongykJS/z519GGycMWkueDuTp5i/ueZOV9jvNNx0gJ0H0CQZbQfQJZs+cZ7hbFLBwZSx+ei2VL1L+lX8/FaBsdAQbYN2bRea83mHjIC8aE6cDObq0Z1WZjgUsjOZDhi6JIDq+eT/y9UWBCxPGRgx434Whr0Kphg4rGsTXWz01kCop2WvP7+tA5hizRbhHDmkjo5glakc13pG+1FJmc0dYAG0mFZLygAv9inXM30lmsjt +nXy8uO/Jc8wscovrSAnQfQJBltB9BVmu5u+f+NJMHnpER5gdRSZQOwC7pt1+649eeuSHYNxkBeE8dODrcdhdazK9QJytLC4SixQqxqj/xjUhtZDBELg0I2JVILaMlM0osavNXszbVggshdsM1bk1ZZ2gsNbBOjWITjWya4fu8OtbZrK8rOq2ZZlLXet/k0unPQAJA4a12Nu8aptESWRwQao5xFYK/0fyf9xuri+9Z4uHn+LP15A5O2t3CWZxTK6o -pSFQYAS3BR5kU19aHa8mFL/JuG2hY54xaaD7U6mKkJVN22LqllyOaQoNOTGq80xxy7MYqHN4Qdlp2vUlZStpWMrWVnK3lYKtFWSrKCF1Sjqdt8KXT0V9ZZXoMOzpOQC4IwEYAGCVATgMcFoBQFwBAQKAC4XO3+AisiU4zazVhgCTOAGjboNIgkLdCZT2tlk+NpElorJS5F8td3Ys4DFLP4hyzIbKs2zfLUS6SLzZiLORav0S6OzPQLsz2YUEbWhb +SEOUsrrslal8VQUqwlw1d1MqvCXpYwVdGvLPlvywFaCshWwrEVqKzFZQQ1KVVPgjRZ+hmPMS5jiBhY/HLctp6C42ATkAuCMBGABglQE4DHBaAUBbFwrBcLHb/AOWeWcwOKzBqNZsKzg+w26KiIJC3QWUgZ4+NMqwa4pT6UWuuVGcBgxmtCjVgNowxqv3c6rBN7ubBczORYEL3OgCnmZ6AFmiz1fWmw4eXFDX+roums/vrrOKCGzrNxU6CpdStmS1 -Cm9a6LZvFbXkjrF3a+xYOtGDygc5odadZJGeaLrFIuk2NTWQ4h9b25gFWJa1mfADJ8++wVyqQPHn9t31/kfy0vNYGAUmAf057yvB/hpWkNsLfVPNvQ4EQqlnSkjZTsSBf7tof+4A7MOP4jI3cPEJdwDSDhJEpR24PBdMh6r27bwTu7mswuBU38eKB5v4fcnD2iLv5Me2RamuHjKL/N2/avf7PL24ji9hI+vclspGh+ApCWRxb11cW9Nh9vi/LJ/G +3N/Oitb4RrW5q0iHEDeL3kjbDrj46jt8E8jGD4j+J2c3NvnNkj4BYy664AeBSYBzTjvK8H+AlavWpZit0JfiFOCuJVb7mv6yZTPOcT77toR+8/dBtZ2jI3cPEIdyDSDg/gtbQM2/lLs8KKU2RSuyiWAu0DewN0cCywNy1mGH47d+C61deFIX5OfVym4TOpuskx7u+sXbhYl3NapdadNm0Wvmuibl72jXm3YjOWWtboO9zEfDMfHI3zIFwPE7FJiU -grcULcGlmUbBAdHb7Hbdq31Z20v2jb3g/lVDdAeZdkxpwCBwjeoNI3bbKQkyzpaYB6Wy7SQ2O7VDCtmOLLupj7dMj+rPrE9r6qhQ5ebZMSqFqvP21Ms1hp2M7WdnO3nYLtiti7LQUu0Fbz2O3rHpjoG3Y/A0CLWmay6DRsq6ZXGA1Uw6DGyE2CQZ9gMASQAu13CVA4Ay2fYJAMqDOBcyJG+MyRkTM9g3I75zgscFSz/HKr0UMyHinsTDF4QE8jwy +cXEphKodp9a/vZHQJatoSzZZEtiWmAEl1O4EJ1u2XVHd1pS8KeqOinJpG6uBcbfu2m2WjTeZ7fKte2dHUaYdiO1HZjtx2E7FAJOy0BTtWWo9NQlRwpbUd6OodZ05y6xNcvCGC40GNkJsEgz7AYAkgGdruEqBwBVs+wb/pUGcCFlIN0GzZmDZ7BuQ+LHBY4GlgNp5zooZkG3J6sGLwhI+2h7gMVdoxlWRHlVhM3jYjWAm2GRNlq98ZIftXOr3V3qx -bS6u0ZLgpIPiP1cBXVnhBO4mh7lC5uTXxNjDma3NYWtLWWHK1zxcLZDqC2uHzFjeztYnN7XSV8tzi4raxvQ8lzdRFcwv0usjqK6NpUFVMRKMDhbdt0PMfRnVlObDbXJ9R+5si4XPNuV5wG7aE70LtlJNEMxIgL2xm3tH+IXR5bfgXW3oH8WnzaQEBf6BgXPAe4sfdOXIOfsHEQTG4eHgXAzg3EZuyRA6eFrfg2wHp4Si9Z024QDNwhgiE1uC7F5x +TecNoWR75Z7fTQ5cP022+U9oUp5Jl2FhiLzwLrVHVhjLWrrq14ulCu7A4Md5c9fhxro4yPjbo756ttOdPuy25z8twzdfbLG325gtoYvTO24k0QLEdmkk0rbhzf3VtUS9Wxqy81atSAtz/QPc54Dq1uzN9vY/YkEyaHh4FwCcxNQIHRQ7VZTySdsEqe1zUbSy9G8Gkxv3RXjzTvLW04ODE2u7K+8m8WdGeDO9FThzjWM7330OD99ZlmzNbntHiObz -+9m0icwIzOeb8zvmyeN7OsPVr6znxas/Eav7CTY56WySa10ZGddhzoR4rZjOLmjdnXH8XGkpBv5/5U6g4MVLCjk3/gNR53Wo7c3yXobYDmF5A9i0aXHt9tzdiFbjtEKrLn2myy+rsv0SFeJplXvMfhoZz3LEALJzk7ycFOinJTq8GU6MAVOqnSOqJ8Y6hGRX+FAMnHc6Tx2XGYH6ACgH+BjhwYEA9QBAPcBKfPBlA+wDgBQEWzKBRg/NHgDP1Kuk +wF02Rc4dsyLxCaBQ2vG2sjbkk7nMKDlf+BYqZzpz8+/LekcuDZHYMgSyHkpOdMCjutw7Z7bxlVGoFqlm7Q5Q0tNGg9uEqxweoVW2PwnkT6J7E/ieJOrwyTowKk/SeR6Pbsl2odqd9u6mA7FCn5y+ooB/gY4cGBAPUAQD3BEnzwZQPsA4AUBlsygUYCLR4AD9YrmToPrBs8gJAPgw8RUsfCBLcc4XJT4kJuE+Cv6EQKNxCrU9KtyaKryIJp3g4+MN -byr5G66E6w+DDx5Sx8W0pjMasLxiQm4T4HAeY1EyBnPV4ZxcGRBjPqH9itrZy8ntO1Zr81xawLbxNL2NOK94V1s6kaqb4pkr2Wz/u02K2o7irs67874Rrm8svwKeHbjODbmh+z1rWSSn+yM79Xqjz50a95a/Xy7WL2wlMLZD1BEICAP4OHBC0sGQHZspS8qy1f6PlRCLlG87w/dfuf3hAJB8rS8NxoSIihcyIsWKOTjKrpLjt3CC7dsc7WK+wGo8 +WCXHTyww8u6ddWer5DgZ4Caq0YWKH1Luh+NbwuMOCLTZ2Z/NddsdnLOXZy52vbWdlq9GvwKePzb5cCOFB+1+uq8CBw7BYXJ98R74skc3yLnDWYSTdZ6Vsh6giEBAH8HDi2bque5mR5ZG0oHA5XIRP+6E+BSHvj3p7wgGA/QGJ1TlJEeueZHmIRG+4eckiO6teBwg83+I61tU/BrovqLmLhEFjeyMQXK39V8nO05JtdOybZD/p1S/JfAnhn4jMlyN -vpuBoGX90OE6y5Hsk5x3DDii9fsiMrPNn2JwV/1E4f+KO1K79XWu+H6knpX5JqbbvYkBzn8Aytn8a8H9RpJoo5m2wUvHuva36Q+WBEC3Aq3ALV1yB9de/aKXbrYbwH/LVbcRvCmejVj5FZY9tcxvox5EzpY6+ceGnXX86VPaaZtXeOLTvj8Aum8zfZvc3i2fN4W+Lelvy3lb6O/sd6HWuEn8b846k4mGIubj/NZgJoAQBwZiA+gCt5gCNC2hzgHA +ZpfduGHU1phyKS8msOWX+AJExeMbobx4XNatXSLdxH0gCscHyyNLfbVn2kj51mHi84/s3uotCj3+186pNKunXKrx1/dT1sinKj12uo7dol5mOG2yCgpRbesfh7gUXrn1364DdBuQ3YbiN1G5jeeOHX226T80p1MuX9Tqe88yLWYCaAEAcGYgPoBjeYAjQtoc4BwDgx9BIn8QOmIEbjfxWUaxrQ8ivApBvAxiMIKyIGZ+DoNwlwi+u4W7njFuLgpb -ODH0ByfxA6YuRqtzU6qHvG7BLGFeBSDeATEYQVkZuz8CQalKjFY1lk/h+uiJBBnvVkZ0O8occpxn58Qi6O9/LfvEPB0Cd8w0WszMZms7zmWw4XccP+Xm17Zzw83t7Pt7sr7I1xZyCiOc6+7uLFc/yM/VTRthwnsBN4AJoFH9IRJNjG+EVSPnMl42+fw/tX8v7b74VmwA6CcghA9QIwGwD/ciHNHgH2G78EgnmuaDKb3Vs99e/vfPvoFqnYNceXpE +i4OW+y3VXcX+DkVCe4TQJo0PiFwUD1fmbzNm32H1t1Q8qodvFn2FnjYzYUFTOgV/b/wwveeA5AOHo73d/FgneK7OZewPXfxQYtggk0o54+XfsuB4ptNG7w3ckYuuLmQXVz6woasFYdBOQQgeoEYDYDnvKDl76V+/pJADg73G+BV4+/KBreNvW3nb3eYmUSa/8MBKRCB8X4wFYvWtI+LoJbhJffVgMLAXAUHCU785OD/SUh9buCh8vBuIr93Z+zxq -kSrwNJBZFeBVeFkLVgPHV+4g02TagMHVXAUHAc6u5DWllzWbZdO1+v+uLlzR55duL2Z8uqHox/YeDmWP4tsV1Lb4eJSePWm1KaoznNKcSoWPRbSpFPgDhvgFg7c/ZGKlf4rWhNj60aRu+FLSDx28YgD9A9irDHF7coPuxtdPpNf9rl2/qe+3Gt7Lntjx5+qB0uWmF/tiANF9i/xfEv9QZL6l/S+Zf+9OXyJwcYkA6/Mdcb7HWF+TuReph+gJoOZA +Kvtkqm4Nbw+gnyZY1hrdmqZv0vprzDpl91XmsKcSoKPCi9qVCgfmdBNLeyOFM/LKSxv67mWxI/m98fuLH934K+JO/gTZt1J7dpJ/QBc/Ml+tzVwp+1dKfNLer29up8Nc2OD09nxz859c/1B3Pnn7z758r0BfTP1Q3n60x9varrPj6oO+ef0BNBzIAEeoAuDzOVB9AlQJ6WyBaDVAY4lQNkCLQyfBecdq8UyCDingDbovLqx88CTxDgh7oQnMEsl7 -Aj1AFwHZyoPoEqDQy2QLQaoDHEqBsh+a1Tyu9i9Xh4Ou54iOyBydMk/A4gut+6HVzBKY+54fbi4K18Hc8HmXQ98j1M4l0cZxrsz1E84oWfTvlnfLpd/T6m+M+ZvIrgk3D04/8PNNkslb0dduiAHNvpLX8zt+9b/A/gzFN5yypNypjbdaSbysZLvdXfPrXz+g3+ext/Pv75QZ/rUHoDVQgHYL0LUgJNdQuKQVkRjLp4Mf6efz8GnzUf5P+agMemL/ +4ypf6nZbwg0YetpN2aQphqtyh5rdQ/MCHVxt309Je1eqviPmmwR7ptEe0fE1pr7TMbMUfT9LZ26BfpWfjuyWwRjZ/8D+DAleZzH5Qu88b9jnnEwVGSaK5Of0/ePC5q+z192MyUtP5kegNVBftPOL3b12A8z5ncCJhPCsh9x656Vn9agI/zUEjyW97ucd7bf/IDEOCHA0vd0WL+Sn984hA/uu31WjZg/jw4P2LrL7jdB+tOS+qHol9YZJeD3s/w9i -6+Ya7b/5AYhwQ4GX53QVXqSjggBflkRF+RMrS5QgxHgp6keHXqzY1+vXtM4HA3NkN4QiVFvR5zuYumtbTeHfsz79+xJlx5Suctnx5/6e9uuDCeNiNjCGKXcue4zql7oo7AmmDgbYqer9igbqeCvjDa+cJ7nf5wuenv7qGevPoMbROyKsarvaUck64uOLrm47G+6Sp44OenriUA1CProH7B+ofuH6R+0frH7x+ifm75Bedrl74J2Zxm6aVy6Tn+ZT +l+25bc5+u3efnt6R59uxfs2Yc264DR52I2MEIr5yNLCsLjeamnv69isDpx5+c7Fgz4Fs/HqlwIkVkLP5ua8/qJ6KumthoqaOhAWq7RM/PjUZGO6lsL66u5jjKZy8bRhUr6WqZIb6DKJvmb4W+Vvjb52+Dvmr4kBzrtr7BONnnr6cSMAE0AdAPQPoALg5wDHAzs9QBhCiBkgJUAcA+gHBhXgxAMC5juhGBnZZO4DnBrBQsIITqrwYRpcDe+npjyrG -CMAE0AdAPQPoALg5wDHALs9QBhCWBkgJUAcA+gHBhXgxABi57+EgGVa1OFVo9DBQaEvYi2Q8JNsBVe5Alxg/A/qG3Z6OfTiX7Ne/bn1bteLNoNaIBrWj5JUeczpT4PwU7ks7jesmpN4tqi7gx74Bq7oQGD+ZJpz6Um3Pj2Dj+n/pP69Y0/uCB+od0D5AyedLDAoS+dlGSBrIDKs/ab+svtv5Puu/n9baSjWAXB9AMtJUBHA1gTPzAOl/lo7rUvEI +0eboGhSIyLr6qh+6Xo053+93g/54e+Lk1a1uS+lYbhsyfr05w+2igj5DOWfun6/+E9rS6TOhfrPYgqzLgvY9g5fhv69eVfgFIS2XwCyjoiI3klA+qcAUu7Pyt0CI6nW4spxY7uadpv4reBcH0CK0lQEcDiBA/K/b2a79pgHnkmbh86W6+Aed4SAZQWyAVBVQe+4emuAnMJf4a4GcrMUUWplYBoWAlxg/AVgRU4X+0HhkbX+YMsLaR+IPkmZQWYPt -9CMiPulbKP+d2BB46s0wWyCzB8wXB6BBnkDsJf4a4Hc7RQTOp3J+oOqtEG2icQWhY0uhHnS4wBTNmhZC6BFpM5IBdftkFN+bZlT6meIUix4XiDPiLZ4BASiz68OPavs6ZGy3odbK4mgAyiUBh2BcAxoaSNxSQGJdGhYMBTYJS6+ox3oMGsBhrnJbu6kLisGnk6wSKqbBAgSZ5GewgdG6iB4vI+rWWVnu7by8tnu67MS5vj46OqRKFYE2BdgQ4FOB +W5uBifq/6Yeafj/6f+uHoEE/+KPgzbo+BfjCYRBwmqAF9UXXhWwXiFwHGjOIw3o35ggEZpkFNgyLv6g0+P4GK7d+Xaoz51Bp2LxCPQjQe0q5Gglhz7ieFnqEylGUnlrbCqXuhq4UB66lQGmOIvrQHaWljgwGW2b2qIHiBkgdIGyB8gU0CKBygaoHqBvAco4wh3ttDpWeggbr6tBA9CLRNA9wH+CcgtQJAbMhjAEMBsAs5M8AYQfQHABJ41esuTaB -LgW4EeBXgT4FIsMdrSFKcNZN76umMVqYHA+xAPzRNA9wH+CcgtQEQbqhjAEMBsA05M8AYQfQHACJ4sZn4HVuAQbW7kYxwDqovOJIEEFIe9rCh4JAJWlPBYwySgkHc6PdqJ63Q/dvV7DuGQcEZRsdDhPbUeU9g/Az2c9oUEK6xQfRYbOWAax6iuBAeOYy2k5gc6kBD8giHSKDQb4Fbep9grKAkI8JxARBmITfZlGf8lxAY4onjL6u679h5o5hEwZ3 +CbroHkYxwFgLvmJII9AAywwRsC/uCQPFpTwWMC4r1gVdinw12gaLGb12FbssH42j/qmbpmHdhsHhsvdv3a+BAuv4Ff+o9kEGHBEzlCbT2DLtj6RBuPqAGxu7Lt15FB8QV0KK6AJCPCcQJ1rRb0Yj4lxDY4jdHkEb882gt59+noQP4H8wKOcALgQgOcCIQbIHTD+8NQRgH/BGyh8Bs+5Kv9YGqBcAmFJhKYWmHdBiVmKE9gQ8BSCXAPrH2DJYRTkZ -QAo5wAuBCA5wIhBsgdMOHyLBELlf4rBxdB8CA+4Hs/43GzYa2HthnYUcGWh//qZCjElwAGx9gSWK07OAfEIkD0YqZg24OGdkjcIkOXAjhYUOaQU1oTOy8oGHEWjZuPYU+YYbIIYB7fgx4ghXfmCFlBEIUmESuRARu77WcIfx7oAiISBa8WxuuI42IhwI9B7AG8CJaSec6le4EgXwNsDHc1YSeYm2PHnyZQu/YTp58BD/jSFWuJjmZa2OFjvSFaWs +AY8Cob6YpuyhmpJ96GDmFBYOWWjjYoyuoS04uBPzIQ6d2xDsV4YeHwtsGVeeHm27WhBwUYpHB+fmYpY+5HjM5te5QJoD7At5u6HXB3Djbi8Qy8DSx2Q4UgSBfA2wNtzhhctkSZSuMsggT0YOYT/Z4BSjkdraOvjro4aOMluZ61Qdln46p2EQhdqrqYpsY4Sm1ARqrIqJSvq4YhGnkwEQAxAAyFMhLIWyGcgHIVyE8hfIQKFKm1ls+E+O9lvwFBOZ -TuY7O2Fno47USbtknoyBbrl7b2eZvr7ZOevIcqGqh6oZqF9A2oXah6hBoUaEmhextaYYRMTlhFxOZdrKFGBSTgm4M0fvjsE+a/NAQZSqFALm48AC4JsDKANyNUBsA//DwB/gsHnl4p+dTt/JmQhDhwgso8fI6Hg4OpHAR9B/3luGJB3VmX4DuozvAHpBxPhR4cuKAY34X64Rswz5BM7pgETeArqCFxh3kbN7se21hrrruqYbCHphUSqP4WOsMHu6 +Cp0p0hEACLTgG1KhQCBuPAAuCbAygLcjVAbAI/w8Af4G+5Bemdh+5ih0hnsBIERDEpIBozHL8BxA+pHARkg6yKkFusRbokB1O9gZl69hfCDl5x+IqBxjrBL/l4E9OTblh7w+lDpn7UONofOF2hnhszbLh9Miw4l+oARo5LO8IhX5ehUmtX7Bg64HcGBoI5mkHzwR4S8Eo41gakjIBEElu5Rh3QpoGxhEXMCiW+mAABCQGMcH/wZhTPqlzcQ+IEJ6 -NBh7sGDrgaIWJ5ecdLHbhgRsnojhxBp5LBFv28EXWHjB7cj5pR+mAABBEGMcDALdhiEetTcQ+IChFUGYHlsHI2w4VMJFRJUZhirCpoV/7YuVoSZCLILcPCD26w8OZDN2A4EkCuh0AbdDmRkAc8HQB48LAFMuaIAEYBhdZt8y/BrkWiboBzDjeHxhd4SUG4Bj4Wx53iQUQP7s+JAb/oZh5ATxa7u0pAL7dgaPnbjMUB3ilFKkJ3nliWQ2ZusjZR7A +4B62gv4AOWrIFHBRmGOMKChgWjar/YXHMshfeXMq+bmQxdinxKhGRjkFui0wUkBX+cxPMEIeuDv2F4uT/gn5KRDGlsHv+QQbsGA8lLupGduIQcR50uDoQZEFqRkSAHRBpFsO6E+XDsdgXYnkD8CbKjkaxYuRwYBkSnGfEReFnOV4Yto8WUUX8C5hCrtGSquXJp+EaKf4SpYIhvukbYyqJtip5m2OlglZZCUviRHLYZEXAAURVETRF0RGyIxFkhWE -fBEaer5tVF/Ag4Q1FGOsQg7YMhwUkyFjGLIQnrWe5ERyGURHrtyG0RPrpJGcg0kbJHyRikRhDKRqkepF6Bggc6YQawkb76xWZgfFbxA1QBW4AQHAIgBwYHQJBgxwzwNORdAbAPsBwYaSFWyaRZGiPpWh+5EOATqd0N5DkyDVp3LMUEONZKWQDbEOBpYjXqX5DOKQZX4LR0BF17bix4ctFRsPQCZDYABIBeFO0i1kuRQgUYXT47RsYUK77RiYRUHJ +RSFOWrSq64I6N0oRHxA1QDG4AQHAIgBwYHQJBgxw8zl0BsA+wHBjOIZbMxE6BrEcJg0csfFIgpY8MhlZ5yvvi3oZECaLijpYkHrjolWaXuVYZeEfmiCN2skch4ioPQCZDYABIMaFPCPVlBpQg5oU3zTh1XhWbaR9XvVqQmekZj5kehkTj5MyG4YtbbhQ/KvaWRfZmIjkM3kPJo0sKtgxaoqziHCq/AxMbT5ce4rjx4/Bvfj5H9+H0i+qf88tJIAA -hIUTCEyu4Ubiyj+J1r+HLmsUdt5n2xPIoTVG1gov4qE8NmWHV0aSPSq/AUsYSF1GqnrJaNGO/gKKYGj3rCjPAUtJIAAQRgOowVRZIePTW4A4Sr5+6rYuJE3G4ArHHxxkHJ/4NhXMUZKmQ3lPZC1aqDHBbgWw8KLFoMXcFiiBxbAibQixayFCCSx/qHP6UgA1oeHdeXwZkGCg6sUcCax5YGgG1qm0QvY9+2AUx5HyE8QmF9+5sS+FVBHPsP7wh5Ab +QRgJozhRfwZjDW494U0G/WLQYv6GqpsQOTmxlsWWH/EWUcFQuIQ4Fgyfmj5sPDQ4ykte6aGw4Kdyo2cQNIhtsH5iGagEVVvf61RuXgKAMxRwEzHlgjUaQ4ThLUTsFsaAQVpFzh/Maj6CxGPn1EixA0WLHEW+wFzZSxWgvZz9gxtCJFgRu9jxHzRHnBLbrga7p8Fd+m7mgGLymYbbHZhMUUgYieT4eUDv8U0Nz4QAE8Waj6O8IYY6IhZ0dXjKeBgq -LLreyrnKRrIE8FxqdBS/n6i7m1LFooVmA2Aa4PuJITfKVRKcchEAx6EeUCgCU0Fr53xHAA/G6+REWZ5fatlj9p9KHthREm+Tlj7YFeygQehkxFMVTFxetMfTGMxzMazFHA7MQF7cRT8S/GGBBMSMKUGFxiDIkxzvLuALgV4JyDHQLQH6jTkMzDhB0wM+BQBCAQgBD4dR4dOaEFeAJHZovAwbPqrnMtkMnxQgSQJFAMo6DM86mKfGDLHl+tkQeHzw +p7m2BrvKZGuB6EDEgxYMU56Qx0MbOSwx8MYjGfR48RwCTxATjeqJ6/tv9EGm7lsCi7gC4FeCcgx0C0ABos5PMw4QdMLPgUAQgEIA3eaUeszChCVl7HVsLwP6z8q8fLZBR8UIOVGYwqhsSCPQtgeJEluFMQ4HSR88LTGrBD8BD6FemcSV49AZXpcGThnUTh7tR3/lOG2htZvaHNex+sAEDuoActixBmgb2YOKx2HPSSI48MpqPBSUO/jz8I8DbjK6 -I7n3ES6ZPnGjaxw3j0CjerVF5FFBPkfeF+R8iQFGHROzsFGvhoUdbFnREUZmGLY2YX9ZNBL8qGh+ox8A3bJRS/u/jFSJ8BcB4oZup9FqeuUT84FxBUTcYUARwKMB0wMANnbtIScb2FXx9GGnEbBZ2pnFNRBcG4keJXiScCkS+UWBY/YDKI8pMaezIDBw+S4cdwcJmME4bEgj0ETLY+N0FCB4+dwgT5dxwukeHCaJ4X16iYEiSPFMOvLuPEd+RsY/ +K0RK5EmhQQAYlBWnkcCjAdMDADR2nSNbFT+mAUPHbR8UQDZL+0ibInyJnsWwpMoSygTwHMgME94NhtrDnbxajLDgwHOYihJoXG/3ssKqS3ognF9htVizqDh4bHgkHQBCeOHPK1kvzpcxbUeIKUJZCYR5/+JcScEz2jLs6Hix+wOvJXBYEokFnYmMOLY0s01G3GUg1wgOBEgIiXrGRhvwUolZhd4cPEgh8rn/a7REgBr7SWUITz5gcnKsdELxp0Zu -qlB8YeUEcelQSdGbuXPrOb7AT8uvE1sTnNayYwlkI9FL+Q1D7FaylIAfrC+LAcHFsBDibd4/RivtfHpxXRoDHq+HvvnGGWyQp76fa4ga7YG+FeDDGeqRuPIHURgCd64Ho2Cbgn4JhCcQkz4ZCRQlUJXEc9La+GybG5CRqCYm4V6xMcD6kAV4B0D3AzABQAYQZdtGpdRSJCxiPARIMshGSHENsimS/wF1bWSTHJIgT6ZSkCDnkbQbpFjw4nkJaCJl +rnRK8WBFrx10e0Zbxj8c/GvxHAO/GbAn8f2Sz4v8f/GAJGEV44VJjllr54R8OgRHOxBcKQBXgHQPcDMAFABhCp2EiWDZSILGI8BEgkiNJIcQOyAQL/AxVspIMccDo3r0WokXPBZWZkKfA3i9kYiBSRDOtbSUgpyl5z5I6bhMRJxckT3KdOY4TD5lapCX4EaR+cTV6Fx4JrpGlxdCQkgQA/rpsDMQuAM4BsgodlADEAMcG/gDkcGIhAi0RoNUET+F -ZtATAqyBGCp5IPbA5G1+yJnCp/BvNmlR0eW0f5Hzuu0d37ghB0bFLiubPtx71E2bpsDMQuAM4Bsg2AJyBQAxADHBv4fZHBiIQ/NEaALBF/rx7aJtsZmELg/nldFiORid1Q/KoKkyayOVuPEFa2NmvSAgm/UW5z2JocTyZ3et/OUAIYQNsxA8AfQPQASwH7hwCjAzgPzQxwJHLImf2Q+g/i+JywRWGMuY8DOr3+9UbfFBq0qohAGgCALuAsQBdh6o +cVElVxC4G6GjRPNpy72ceymco0WjkZSDZGi7vSDXG8IGeEzedPr3E9+l9obGGqCGHdbMQPAH0D0AEsIe4cAowM4Ai0McIRwkJFIuRyAC4/nt6T++5mxyyGdanP5xR+AWUnoA1Kn0CIQBoAgC7gLELYrqq+0Uao0qWqcEC6pUQGyphAMnvSy4g7IvyqnwgqgbZauleFupSmovnuorSUEVbaDUJ6mZ5Gpmqdqlmp+qeyq4Rv0Tr6LGhEVyn1APKXyk -gxbqmGnBAkaVECqqYQIRHcA2qrqpw+/Voap7Jn8Yb7J6xpnDEpy5pl65uWNsQBru+6AHGnhpiadGlqq+MYk4fJokd8n++BcJan1A1qban2p9QI6nOprqX+DupBcfAKJmBaKcKPQ5IAAHkgIHuh7kYkKTsI5iUULjLfAHyjsK24JdDo4f4wVICpIgeIFPDAwkiKzzyxZauSmYEYmlSncuNKdeF1Jt4RiqKJJsc0lPh88eylSunKc2Y8pfKQKlCpIq +Cp9QEKkipYqX+ASpvkVmJg2xaIvA9gHwBxz+4t7ocnbJcwmwjDwbgqcbthzJHMJKi1bF6Lv4mlE4myEpkB77AwcDrTxUxc+jgnyRi+n4pc6xLs1EvKQ9nnFWhSPrTbUJk9rQmF+tRLCnwpiKcimop6KZinYpuKbKn4p5wdEELgbLiSkr2FkUXQJBw1BFKV0CIApoz83FJiZtxccZ8DRQVKd3GzeqAWykm6EUSGEly0Xqomqpq9PyIGxGBk+A70eK -UcBipEqVKmbYp0Vu4KpCruIxnOPopt7kiU/i7Hgg06k5IEhuqSbiw4tunP732qssp4zJxIWHGkhfibCAHCPYFvzLJQpudp0GowVqJMGOoqwZ6i5iqumqulKNaSrEYANum7pe6f8p4ZbZF4Tgu+ACfQVILopIYX0ShjIY303op0h+iPSACi/J/yYCnApUYjMjYAcyDygWSEErZD1sWiqcDHxWCPshppOqi5KIg7GGSCkg9iEcjrEroiWK7EzsQoaD +YKJiiDchWncu1KDWnWESIHiAe+FgckjIgFBklxUGdXDUh0Gd9PEmMG8Yl1zdIpon0jAo8yYsnLJqyY6JzI2AAsgqYCki+K2Q1bFcI5OXcYKQHI9LLyqRUSIBsJBonqscirEeotGLbEfXhgAsGSGU1zf0HBrwZcGlxDwaZiUwvWD3EUKKebqJhqgpYzsNsJIiOgt3kFobADydDiRaUtpFpZGzHMJi4gx8L6z7plUcH7l4FwFgJtsnnGGK1pqAC2mx -cWUjIYaGtYmoYTc79JoaK0M3M2LgoISZ6YFwZlguw2wyyI6CQ+uNjpkQ4eWmkhkob0ULEoOqYuPqBsCIJNQ9ujXiM46qrcX5z5ixSYek9eoiRSmhGuBP8EXpY8e4rAhN6YykPh96SykjmRJhbEaJidC+ncpuALyn8pgqcKmip4qZKnSp/7lomAZ5Aa7zIhO/LvACxT9vBkaw/drbotwY8KljZJaGR4LDBj7hfHJxOGX6kxoN8VVKimEAIAAiICNK ++dMT8l1uOZt4kwh+Mn2lLiA6fsFUJOkTQlCxZcQKIwpmZpOlIpnICilopRwBilYpOKdthnB8JiunUecSXXEhGu8IdbH2vCc+RZJJ6S3BjwaWMgmf6Osd8G5J6AXemwgCqWPBKpsUSeaJGBRoAAiIFVKAAAiCAAPCDNSFWTrLlSdUoACCIIAD8IM1KNZVUhOqlZBUoACcII1JVSaskya0mFWaVLdZqAM1kVZzUobJVSeUs1J1S9umArUAAADocAgA -AAAiCAAPCCzSq2e7KDSE0oACCIIAD8ILNJ7ZI0jepLZXUoACcINNIjSjsjKbimq2f1IXZqAAdmrZs0j7IjSHUrNITShegQrUAAADocAgAPggsprNIdSg0sNIdSEpoABsIAtLPZq2SNJ7Z4pqgD2yI0q7L2yq2V1KAAkiBdSY0pKaoAh2cdmnZqAOdlXZN2QDkgxK2RtlbZO2ftlHZJ2WdmXZ12bdnjSa2Y9lw5b2R9lfZUekXr/ZQOSDlg5EOdDm +PggzJs1J5S5UpVJ5SdJoABsIG1JjZFWVVKNZtJqgAqyVUlrIqyFWQVKAAkiAFSNUvSaoALWW1kdZqAF1m9Z/WctmGp5WdVm1Z9WU1mtZ7WZ1k9ZfWQNm1SlWSNmHZk2dNmzZbug7pLZq2etmbZ22XtkHZ42cdmnZ52ZdnXZd2Q9lPZgOa9nvZoOV9lzx+7CdGG2jSQHqupqIfEKh6nqUerep7ttUI/ZNWXVkNZ+OS9nA5H2WDlDZkOeNnQ5M2XNm -w5L2QjlI5KOWjkY52Objn45dOUTkk5TOeTn2OEgayFkRNqu+qFpZpuMolpWemWlShT6JTmbZ22btky5hOQzmk5zOfdls5L2RzmfZ32ego85AOcDmoAoOeDleyQuT1Jw5oubKbi56OVjk45eOQTn05xOYzlk5nESXpyhidik5iRoSQCiaAnIM8A1I6bgOn1hbxmRhpIzNJZC10yrBV72s99nEDlSfrI8Dv4oxLmrTyeqvzryxHwSInlJFaqwyZZ1K +x6C2ctlrZqABtlbZ+sqjlFSh2RjnMmWOVdm3Z92Y9nPZQOW9kg5n2ehHTGVIS65hpgdoRGaAnIM8B1I3rsmlGxd3kZCZasMjm7npF2IxhsKTnH97Rxx8EdbDE1Og3JaSzcoYbUxOWl8mWZFhh4H1utmYdGJqwSdzGaRoKS5lFxC4QAH6RKdOOneZuAAim+Z/mbOnBZC6VBkrhg0YwnRBjvlFlE+C0UFLYMc7hrrbk4UuuBN69pGI4spc3jekK2+S -VeE5ZNPliYNJEUsrr0py7qonzeuzimEVZFhFylvptWZ+kNZv6c1nfeYUXKnSyiIUn69JShj+Lv4vdmgy7x/WUj4vRSUKcwtWw4Co5DBNYd9GcBvuBxycUAaahFBpC2QHpB69uY0qPx+epHo/Z7Sq/HMhlnlDFshAyinqchmuRb6+O/6nrkR68ynfmh64ee8nJOaCeF4em1xu+4ZWf4PcBGgzwG37OJsSc4CDgrcFFDo4GMEARopBWuRh2QlGMMRP +XllY2BWU+ljxZ6sArC5TSpCE4KruvNmd5tSeQH1JFOSY4yqgejTkoKHqRL6ae/skzlR4duh3kZKmvjrkCB+ESE6zJT7gFZ/g9wEaDPAqfnEF+RHpvsYfAFci+aI2QBBclAyEDnZCUYgxLbibczkaqEok9xoJyUstfkfAN2vuS4nJm+oQVoc6nacvqbB2cb2kf+/aXsEFxUeeCluZkKWOlmEE6UnlTpfmTOmBZc6SFl2ahFuza55a6XV6dmO4VWwm -Ch3HZDgmwnFCaz+R8IPZUOS0SNYhGdeZfoRGl6blkzxred4rMeM8S0lHRbSRyn95r6dVnvpdWV+k/pTWf+kdJtQV0nocnWcGDneLcG8BoefWWXj/Ra+bmgkQlMjrKHmRIWfGYZU2dhkpYiIP6nzZLmgHq2mGpg6bamTptflimEpnaaamjpqmkQxT+RMaq5xsOrl/x3tmMqf5f6lozlpyQgYX2mWpjqYhePviYH46mCQlq4J+AM8A1gd0GwC2gcGF +BS8MPAHp+8m/qPi5dHsBl0xzlelnW+sf3G5ZqWIiDN5D4Sqmt56AKqZ8mGpoKZamU8awXqmApkKZ8+snrCGARSISPnU5l0RY6qgcppAC3RzoT6nVC3BfyaamIabDp+2scjMkJRpmi/H4AHXswB3QbALaBwYXQPoD2g9QOAabA2xkAlumIXmwoYqDeo9AbCdkLvDqZJ8DswIgZIHllTeHECglkxYfpTGmZ0fkOJf5biYTYNRo4dD4io3gapGApFoc -0D6A9oPUAEGmwC8bUJ/gXQkqKuKCxhsYHwP/LsYKaig4nwc+giBkgOGZcA/GvbkkHWRcscUlKxnkr3E15Pwc5GSJUbB5FwF9BfUn5ZxscwXMpZsa0llZi8ZVmD5H6fVnfpjWX+nguNQQraZhsSrPkGaB7s7H5hHFBrRSOBUuxjFSfqPTqUg9zkHHjZu+bd55RL7p1FRx5QC0B/SdMPUAnAQwF1jepv3ofk6FBGV+YNRwPscUxwpxecXz2KeQgWcE +ClOZYBWHnDpoQaOkwmCeXClwFKeYgVBZ86aFmRJy6euH7AdinEnialft6HWRYiPIaaElrJNTsY7nAGilWlIJ8naxKAVQXZZ7Kf/rGa+7oaotAjNHTD1AJwEMA9YiifKlN5caC3liZBYcChdFMcD0V9FA9r5H3m/xA5wlWlIFPBxZNbE4UHAQ8K4VL8FIMPCeFJMZf6zBlUfB44uzgWpiuBhLqEXdpgBb4mgmAScTIjOfMRAUjp7mVCkpFPmdOkBZ -uICRCUgNVgfwxoVwXkUHAQ8IUX787RqUWxZ00fS5zR7wUT6lJQRqrFjuDRdUm0edBc3l5ZdFo0l7RRWd0VsFvRez79F3BUPlDF/BaMUyp4xUc6ZhC7GIVaqNUZrTL5WwuL7yFlIHZrLIG/qoXXeIwRoU+pM2doVzZdxWparJMvKnimexnjxGMh5no/nERH8c65fxRvr/FyBpvs5Y0R2uYsblAhACEVhFzABEVRFMRXEUJFSRU8nBWYpTKGnGhMQE +mRSgV4pvhgSml+M7OAEqQrKJZATBoUhT5pJnHLO7ZJXkXklDF9BSMWMFxWdx7ghMIcQHkhh0eq5k5g+U6mQ0IEYyqCIrSeiG6W9ObY6EAmhdoW6F+hYYXGFpheYWjJvqcq5XxCenDrzGd8bZ6cSDQDABbmmABwDsOQCfMUKZXwGZBOq5IEvw0p9uVRwvJ3om2JoihwIBYao0otbm/uUUN7mM6HEP0QF2ugieE3QpxaThRqXxtZmk2/yX8Y5xU4Xc -XJuLaQCgNAMAA+aYAHACI7UJqeRsCA4ZkEmrjpqZoy4HMNiQaKSFvdv8U6p6KSbSMCpMqPCZ8AugrEcouLs+R4Zk1HZD5aR6d8HpZ1BW5EbRtSa0XXpGJW3m4mHebPHcOpWQvH4lFhBQCQYcAO2nYA8QNOQdAAEH2RCAnWJUBGA2APgD0ARwMJBjFy8Z+HGk+wG8WnOSrn0k2IrwD07fAlujIV8Iq8KsX+pnkBSjGpcvho4AexSnxCvAtoroUhxA +UfK8Ra5nPFUBckVmEFAJBhwAUadgDxAs5B0AAQA5EIDdYlQEYDYA+APQBHAwkKgWteJbHkWzFzfNgXxJtHkqQnhTHs3GYipIIQUNqoiEgQmsVKNCV9xt6TbHASrwLcKjFJWVHiYA+gAjRVQUKKQDVA3tpIAJ4wsFHBd5BZUWV0wJZUwDlljMJWXz41ZVrlyecIbkqmQHjHX67kUoVC6Opgvs6kiFkqmPnupjAV6njsshXWXFlyyU2UVlVZbniL5g -epgD6A8ZFVDgopANUA1kkgPHjCwUcPdrJCa5RuWApTADuWMwe5XPgHlYeVKWaqa5O4xz+8hHaEEuOaTKV5pFqm/ka5X6sWlKB5yXKkeFkeCeV0wm5eeW7l+5TnjIJDacAWfJ6CZsqWl5QGKnnAAEABBHAXQFMWOlCBWmbZwqrr8rnBrbmmn7kvdmshvRa/OkWEF8WXsKYOC4UiSMYVeRQWfcVBY0WjxaZWiUMF7RZiVMppsXPE9FBZRwWesJZWWU +TqGk0h4aWvnlAGKecAAQAEEcBdABRfyUW5zkFkbZw3LvsoDBQqk5AMCcwgMRkgNYayiDidcvcanACwrA51hSJCcV+5baVZmB5NmcaVv+QBa1EgFFCbOHgF4zpAXhJ3hrUT2ljpcQDOlrpe6WelmgN6W+l/pYGU/FaBZR7RBqUeukcucsavCwqhdiXnKEEHqrECyOlNeLXG6ZXXnXhD8nxA5lgaHmXIlUePIVayBUoDn0mhqWxUcVbWVxWk5l2p2V -VlVZTWV1lDZU2Utlghe+E2xU+eNbUlq8DVqN29JUlB4eYyaIibU/4iCbTlnJabaaFC5e7HLlsyYtleFqAK7JdSdOZKYgxJlWZUWV1hXqaQxdha45q5X5U4VUROkL+XVC/5awqBekeNZXmVx2ZZXx2KCTBVNpioQhUSAowLgC2gQwB0DKRpAC0AhmcGEIBdAC2AQmbAzAPbEFxKRVXbOl+5HZB4od0FZB8QQCuh6xBT5LCkkVJkEWaXkvdu3G+hxL +CFS8eUCj5YhXQFeyE+ZvGS+MhTPkU0PFZxVKFN8aoWr56hT0qjAuALaBDAHQLRGkALQDaZwYQgF0BLYvScwCSxe+ZYU46zgPCAsYdkEdZuMfECLJ4MVga+T7J0iAc6Rm6oXR5ah8Zo4EyRupRJxDhhoUQ6/JYRQKCmhhZpzGTy5pRxqWl0eRClQVeajBUOlTpS6VulHpV6U+lfpQGXZFTobkUSAG4VhYRlRRbLHsJGzjWGbk5GfWoYmMCW3GHcGM -nZGjlDFUCLMMwYcxW/kEYd2YGxfiowWDaOZawVqJx0fxUzwglcQDlllZdWW1lmgPWWNlzZa2Vkl7ZWQECe+wGLbRRR9jmGGJ8SodikVG5MfGzqh3nZDL5zIpdwYwh8NpWTZP1mMH7FhcTqxsgmtEaAwAowPyBXF85V8AGV/JVA4PF4VegB3VPwA9VPVk4VzFrgLGGsgcQm5glECxXpZYZbkpdH0GYyd3DuHYW5DoT6LRZKYmXCobVciUAhogTvI5 +IfA0V1BdvyLecxVSIHuetEaAwAowPyCDFMjgxXASRSZ85QMm5RIBsgnVd1X4l6yaKFrgLGKiaw4k2nvbOV0htuSV0QkUKpAWwUCBbdhwPh/nN2riWcVBVcFiOGhVVxT4maKfidFUgVgSWBVxVTxYkUvF0BaqEpV8FWlVIVmVWhU5VQZQwlrhBVUBRYFI7jgU1OOwOMT1yk1KyiPiz8qm5JZjRZ5EZl9efKlfAg1cxW6xKJfng6O6joalyWGNf479 -lvVe3nKJvfnmVsp0ITv7gEo1eNUiVU1TNUSV81S1mypbWctWJCa1SqlbV1lN/L76GIVqk0l5ieUanesCo24yO7zuyVb+F1QhHTZ1RouX+ohlSKYB6eEXxEERphaDE2O/EXZUOO78ZIHQxUxvKXHJipQAmuWOuQCiRV0VbFV8gCVYthJVKVaMBpVGVbjHShKtYrV+F8oUnbNpWcVMK4AkgEMCIQ+gEaAtAXQFeB4cgfvpYUAcGFkDOAGOvWHZVXUW +5AhRELCVlOY0agRBJVdFElN0QqbAoGlVpU6VfIPpXLYhlcZWjApleZVx0clV9Ho1r4ZjWWeuueuX65o1RQiSAQwIhD6ARoC0BdAV4NhwG+klhQBwYWQM4CQ6FlSAlWFluUKXYwN0O/geMhwqYEuVq1bDjRQ5zAGYkxdgegmPJiwU+T+Frad/m3Kz/pcU/MERbvlAVucY5mgFkeXdUQV1pYlXx5dpS9UIV6VchWoV2VRhWLpvxflXoAG4Y7XhlgNd -V6jRN0MXkQSS8LkVaqmWjDVQ4lwcgy8J1lOUWyxbXpXmhs1RQmVpZTkQ37tVLfgUFyJ0YQokFZSiZXUqJrKaz6k1oweTWllY1cJWTVYlbNWSVbZYI4j+mYS0U9lMURtVxRuaGYzdwU5ZAb2kxUoOC5E3xdvki1E2efGXVEcQ96TBAKDwAoYuAPcAYQxAOWAvVmnvpVLlH1Ra6NRbmWvUb1W9TvWA1Hch8Yl0iFn3JccdFHYalV0NR/hp1caBnVTR +LEWRbCes7BgFjN3BplkRvaR48shkcnkasNRz4wlBsW0XLmHRQXA8AKGLgD3AGEMQDlgfVdK4DVuZYiWghQhgLUXmxdaXXl1OiZbngJBwMXLZp8LrDb0sK1R/j61CaBgzWJUHuVGHFWLgsE+5t3NgnW1uULbWnVABedX2ZwBS7WgVg6dn4JFPUWEG2lz1XBV+171ShVZV6FblVZ5lcaX4tMANWNFkpKkH4T0YZBTs4awYfPvbOcedg34O4PcbXnNV -HCTNGM2jLjCWo1cJQiaUFnNkiWhhtBU3koqtPj1UcVWZU0n9VD6bxVPp6RvUTFlLdZTXt101eJVzVUlWmGT5dQdEmseoGWYIqQA4MXQOIn8od6GR8hVjB/+YJCoXoZahaakLJMNgfXS1R9TbZrJIgUIFGWnDWrXK5z+fYXshRybOonJSpWcmlptxJ7Xe1vtf7WB1TQMHWh1UAOHV21xpfWmhe5pRgnA+jMTHAnAnID0ABmV9YV7OAzbhwlkC64OL +CNf1VI1NdQ7GKOYIXwFTxjJXjUGOQlZQEiVZ7CiHiVaIfQHElk+dBG4AQtSLVi1EtVLVNAMtXLVQACtWfHQhXtj9HKFf0WoXiZBcEfExwJwJyA9AFpq3XOQ6buVE0pncVZCRaNrB8CtwNYWcmY8s1b6pt+AitjCIy2DqZnqlb5D2Bt+h9lFpW1QRQvq/5nDP+V8CPaTcUOZPwrEVu1QKV1E4Wm9UkUNmtRNBh+WMcBhDxAy2PQDdVHQOYBHAUACf -F5aBzFkV4g7cQlGUswNUTKr++irVp8C+4fimRlFrEJiWCkETdDNVMKqJooma0c37Y1cui3nQNTBdPFdFPFbiV8Vz6RYTQYaVjHAYQ8QItj0Aj1R0DmARwFAAn4mwDACQY2DRPmM1X4fsA+ZDsX2UqQ0GdQF8QcGZ7FppchWpVSwPoYO42S51YvXi1elW9WH1QSfC6ClyCuUDAVoFduU7QocFeURwN5SDH9NZ5YM0z4l5RBWHlsetEwPlQmOsjfKY +ibAMAJBjH1osX8WgBsmbXEF5I1LWF8QHwXGUa6XwFFp0pYIHw4ZeKkk1UtFmZQ3nZlyNbXUlJz6d4ISAhZXOWll1QDtChwrZRHDtlhqVE0Nl85WWVxNLZUuU1lIDeDQ9lQmHxG7KtkLGWCF4DUTUSAYlavFk1EhVJVSFlNdPnKq1Qik2Nl6TbPiZNbZcuXa5q5QQ1657rmpWGqnIBwADkXQDOwI00yEeXyZRkFN5KZ23BuBS2g4orB46dAq+X2R5 -QfbjGqmtS/noAjhQqX/xLhTyHuW3+T5UhMEzVuXVAQzTM3XlkFYAXBVIkUm4aN31VHgcAfZF0ALs8ZJMiYVUPkZAlFAWcdwbgQWR5KKwbwDaFp+UIGJ6KFFFacBUV+IDRVC1VfuQVo1RdZLo5Bl4a4qAhuNYTWTxvkXelwNxWRLb5liDcSr1E8TTDpJNKTWk0ZNWTcoA5NeTd3U72S1UU0aRpTXPmsI3GChLDJGsI8AYFOIRXRIkpkWOVjZ52jOV +dHcaJAr5YgkYqldAIiIe35TPXmGHadI1GlsjdcUXVtxddX3F+Ho8Ue1D1TaWaNZhNo2/aejQY1GNJjWY3KAFjVY3fVq4SGV/VTEQ43jR2INxg2k2PIenzwWuiekUYgkR/pZ1BJvDV0VH1tXVMVoTfe7hN9RuUAKVfFdxV0mapqgDsVilQJUARpTcPlU5Y5dA205khajR1NSquMYqmOLXyb4tWLTzXL50yapXENwKPoAUA9AB0DxAsXNhxyB64JyB -NGP3q9VS1tUb7orJwaWYXqmspjZUBVVleYUamcrXtmBVD+TYVSlGzQI2v5Baa5WZMGeiqX+2hzQgmqmirbK3+VKrao3+FCoYEXA++gBQD0AHQPECJceHE4HrgnIGyBDAJdBwBDAB9skW0JOVUZD9RgmPpnmQgWUcK0CFILiA9gzJeq7pErCY1778SQLVU+hWyA1VCJBdall1FD8JjWgNzDJ1XdlEDaE2Zl4TW6BM+8DdE0EtfefWDEtiTck2pNow +sgQwNWwcAQwEvYWFytVZWMpgmAmXmQymbAEAe4NC+SZpxwOxivAtVQ/lhU1dt5V12vlZgmW1FmT+XDhLMd3IRVYZWc0KN9kq7W8xYKTc3qNj1dvUlAjzbo36NhjaMDGN2AKY3mNljdY1Lp4WXkWImhRTLFx1k7hSxts2DImWYiQ5ielIg5rFZAwtl6TXnXpn9eIntF1zhIBHAGELOQ/xiECsm7emeXKnf1jFUNXNBI1X00FwWbTm0IAebTUltVEz -Ok3YAmTdk25N+Ta1mdJo/jSbTF51rMV5hXVLCmIgaDGlF0sW5lQ1IgVrEVV0N2xXBG7FTie8UA2UwkcAYQ05KQmIQQKV95MNB+R02sNXTfwGuZ4BQXBLtK7QgBrtryddVOlgbf8AJA6ee0YBxEUAcx7AMPtqSdOxiuJ7EOwUKQ57hKNfC0ANw1oxVBhZ4fQ7ItYDaxWFt6JQ/owNWJTi04lg1ewWxN1bTFUktdbeS1NtlLdS1ttDNR22ZhO7iBm9 +TQ3/ACQJlo7FmsRFA2sHEYvB6kZTiIoaEKWp2GgW/DV+Wf5Kwfs0EOwVSdWGl6HgBVyNlrcvWKNNrQ8V2tufmElLh3tfWAutzze62et3rR82+t3zdnm/V4dZOSAlYkqVZ3QcRglmSIJFaiq7+oHiIr+NF9oE2I1JbSjXDqJAd+FvhWNS+E4RhLUOXiminsiE0B5LWL4bxtTR0lN4XLTy18tfrhhCCtwraK3itODQdHiwONanaUhXTcpW6qQgYRH3 -lzLT6gmQlDAMEjlWqme7yFf/th7GKLTeoW6V3JZLXvVu7WhFn5ggQ7XxOYevoG8R4Vrw1vlUgbKU2eQjZdJuV+ta4UqB9rY63OtWbhhButHrV60+tyjcKV54+EWx3XN0Fbc1fJYVW7UFw9wKQDKAzgEMBQA+AAuAZVdgVAALgUAJKlCA2VkYDJ+nMdfXOQYNRDhv42arsIvkmZmXiPk0begxzyZfmUVWROdRX5VF1eQiVZBIDcB3uRizp5F0pGLZ +ApAMoDOAQwFAD4AC4GZVSBUAAuBQA2KUIDBWRgE74sRB+RxBu+b+N6rzC75BKW5KKrXYXXi4xFoZatKXqgnkxDTmbWT1VMIa0t2Y7fJFz1U7X8nhFKkZHVztwFSvU3Va9dc0rtjXmu2eZm7W62vNXre82fNfraHUBtf1ZFlSxJVaG0+hp8ECSqGDkQllMUJBUcWXtb9ZQX5BBmpdZ75xsT0oYQ+gJoC2gjsHhAFtCLXAZItpbY7Hlt7LeUDedvnf -37V12LdF0DV3eeol9FcTYh21tZLQ20UtLbTS0LVPdSvHLVQnt20T+w9UvBUsThkVKQGtFLbqzR8IMR0nx97hyVi1exaCmHFEgBhD6AmgLaCOweEBu375mXCw3it1Ifu0ZOBcG10ddXXRTq+Z0dU8DRQroT6Hv13kA+1Atnnf+KTE7ho3FzwUAVCVvBZHgi1ZtxdagG5tqZdT5gd7FcW19V8XeW2wdeJcNWQANbaS31tjbc21UtrbbS0fh9LZ2XvN +51Y6cmRlH7GTwNFBKhfDoPUQtSrbkp46maTgyhGfHZcl8YBxRjY3+E9bs0jteoRI2z1IRfPVTigFfI3zt1ravXOZ7tep3HBmnQbEQA2nS80etbzT61fNmFcGXz2eRWM14VTXBeIcQfYO3BaxCWYwJYm95SZCecj7ZK7rR+1CF1vtGtuiX4+H4d452ZmJYJUlNi8WU2awzSaTXiFaQnA3SVU+RIB4dBHUR0kdZHecAUdVHUaA0ddMHR32uWjhCErl -yqX+GqptiJ8qzRBUnwKsmZINC5+c1HYw29dqlP10y1BntKEgxwMUrk8dWtT/GwxurVyHKlf5eI3lA2nbp36dhncZ3nApneZ1GglnXTDWdkbhWmgxlrc7VR5rtTHnlAOIAXY8A4cOsCTdytDcEEgwNbdankB8PayXAgJoO5I1HCFliNeJKPFn26nTo+3PRQieZJ8909bEFFoLcL40c2bWqemBNWWcKgjeJwGN4V1hsWE3ndtdUTVze+LY3VD+uXR2 +18SyW3xRDeMXlAOILYo8A4cOsBxdOOmen9Es1ZtbnkB8MxyXAFxhl5dhXnAD7Yah9IgQE6dpFRhHK1tBpJw9g4LcJts6SQFVs6P+QaV/lxzSnFEJJwOV5qRKjeQkqdjXbT0hJ3Uf/4keceUAE/NA3X9X4lBPqSlyxcWlzLxZbjQ/VRtLHmCCOqU/NXmZZrKZ/VBdoSmcC9gaXcCHDVADRTTsFfBSUbVCavZwX8F2IMFC7wHwCRkk+ipP+1ARgHaO -WIhCqgQ14dRDauCziKsr1k1NMfBL6Jqa/HPX0NDXa02bt2jmcC9gC3Ww1q+QpRIBGFvhex2R4wfSYVqtQKsFC7wHwPWyhQrIhgXrNKuU5UOFLlTs3OFtqlrkY9htd5XGt6AOH1U9keSAXR5p9XfEnA8RcQD1AtgQY3kIWKCulb5wBB8D5FBFWgDwgtwcxzLIcdQ2zF+HOD2CsYzFP8prgNWmARC6MvW9U4wnbBMlK97Lki1npuQRr3SJWvcnlsVb +XFKhJdU2TlDOdOXs15QFr1KV33SpU4dDdbOQnAJhcQD1AkgdQ24o5aeHHAEHwM4VXlq4HEDG0N0JIga1hMXplJQlYa4XKGoHrCpY9jDDj1I1OMHAQrFYjUa2Sdv5X/meBrMZT3U9URf4kXNFpYz3BBajSz29RUKWFlzWoAZ14AtV9d41HJODLZ1C9Yveiai94aIgSZErjaUBfB0vQE1f1VdT/XItf9aPEq9T6IADoILxWNZ/FbWUU00/QS069shH -RWd0E1BvZ3n11UIWxYCOdLedHLVa3ky0296+QinoM5XdzVHkVXYgTZE1TQ7j1dotZ70Q9FYdu0DdwSXoWR4gAOgg5raq2h9ITF/22VuplPCnC2MKCr48CfYj2bN1Cjq3p9QnXs2IxuuUc1Po//fK1BVqnUTEaddPRIAYYcAPcD4AygDFU19uVaZBmMw2YsR+oe1U5BvApkD6HOs//l5C3cpDK5BfG1RsdxicyWR40N2XjSL7xlmbcF215pdcE3dV +r0+sZypSz0Yx3gL4AdQvi6lktlTSd2yqNTVS0QdNLcqblAi/Uy1Ml1ISvku9FbcCgYYcAPcD4AygNpXUN1lTbisYX1jhoBoU+jaxvApkHw4Ose/l5ARxYVK5CHGwEttwicAjaaxCYWpaI1E9HAiT3/VZPdO0nNi9aHll9MVR1Fl9G9ZX1b19zfWC7gHQMwALYHQHBj2lhAMtj1AkgPsCVA9QJyAAQHQBhCMqNIH+B8hRwDHBsgGEEaAxwZgMQDYw -YdPjXZlF3bi2QhC3r3lk1u4B0DMAc2B0BwYxZYQCLY9QJID7AlQPUCcgAEB0AYQCqjSB/gRoUcAxwbIBhBGgMcGYDEA2ME0AAQi2JIC4ArVK90yVdQcwBKpuHfz78WKkD8AIp5MrzWEVXLTAaiIfqGVr+oSnlsWCtOlW010dUPf709NX8X03rlIFZM3VAsQmBy7s67NUDnUzIEMBVQScAsB8gh/b/1PoJzeeUpDy7GkOYxmQ00Q5Df6HkMsAdlYs +TQABDLYkgLgB9UB7afV19xKRfW89ZVVRxkgGOKcbg1ivUL2oqv/R3HJaGWU0WudKRvt4yyK3Si2nepSZ/LoATTWk3VAIQsBybsy7NUB3UzIEMBVQScAsB8g9fRr2zlqTTE1WD87DYMYQdgzoRQAjg9aBCALgywBWpuTUPD5N/ZbRjFNBNcS3ARe/Rb1VNkldb2dGjOQ00eDzTZYO1C1g6Bz+DDg04N/ooQ24OdNX3SoXYdtIQ3X56/NPEADkolu/ -0N2yzS+XDlGrcn3SBzldAO61uzZn0idCA3n0DiCQwM3JDqQqkMQcGQ3qRVD1oEIC1DBQyp1qN1rRaWadAKK3pc08QH2TaWhA182cQjnXHULhSsrf2UDZ3PJi8xe9KC0Qt+8OgzpFpdHRWwlPcSrFANKvQE1hG60SxXHdQIad0QdJbUOaXdiXUNXwdJQDINyDD6IoOQYyg6oPqDmg9oO6DUYrgAGDcAEYMmDZgxYNWDNg3YMODOXXv06J5AcwDAZA +3YB0OG/g/ulLPun/9e3PJhDg9tL4SlpapOs37wODFs2flflUzqldA4YdXs6pPbn1B5M7ac1L1SnQu0NdcRXgNWltzV7WeZJA2QMPolA5BjUDtA/QOMDzA6wOOiuABwNwAXAzwN8DAg0IMiDYgxIN9dP1b83HtzAJgVR1l9XLEuI2Dpmk8yZINroDgg4LiaS9OgxGFPtQ/QYMj9oXf/X5l8lfS3MmjLbP3YtvJnCMz9c/Tk1YlYDft0ktolaIUH9E -9ddEeD1lMxT1a0bWrJkgtuvkmDggRG73TtOUfMlP9OGS/3Q9MlvoWmtpld/0KtMrWyMADkferVJ9/DSn3lA2zV0MZ9+rdn2qlVps8nlAfldyNQV8wy7UYDpff+D3A7XfgDSKmAHBgLsXQGyAwAbAAuCEAtoOiDSJNnTW5A1V7ZIW9g9wnZqwgBzAybnc0Gf0FUCqlet2ehNVd6FlmfoY1XCJ0/fWaAdIYWF1Rs+bUIO0Wnw/r10+CXcb079Z5pAC +lUf2pDOPjOUwjSI3i0ojjveUN6mlQ/f3lAm+T534AtCpgBwYM7F0BsgMAGwALghALaDogRCfR0oxB+U8awy6sZKI7AHCP/3SI+3ITzSIrvhCQkxS/EkAahfDtsj6tTyTTFID+Wm3YTtprbmb5mkVTT3RFpZhHm2t4Fc12Lh+Fm12bD5AzsN7DdAwwNMDLA2wMgoZwxcO8D/AyQA3Dog+IOGdWFcZHRBzAKZ3DdNRLHXr2/0HlYbIyo231QeoLY2x -Aj8gyCNgjagxoNaDOg3oOAocIwiOmD5gyQAojtg/YMYd5JXK6ZhzAAV1MtMxbmGQZCso9Cr+3kHtUWa5CsWH1NpjIzr+4l3vPU7FfIk12Rxq9XMBkcRbn0CIQuRnvVkG0Q4x2n5+hg82kAPYxQB9juXh81+Z4OAqSQS0LvGg2j04rxD2jh8J5BOjgZX5SI1ZDrhY7dv7ST6tVvowIPZZoHe8Or9IY+v1hjPwxGNb2TdTGPAjSgyoMJjkI8mMwjaY +jmwJKu7nYzKVL0f1g/Wm351GbYRjEcYbpqmBGldeCOvtRg+z7111I8uQZjFAFmPv9TcpCDVsA4J/aJo7Q0si8Qko4fCeQZFXl1zUW1Zg5gWpmW8YHVepQaHHVWo8Hl865zcp2XNyPqsMOtdzdBVmEFo9sNUDNAzaOHD9oycNOj3Ay6PXD5wMIMej9wyHXejQ0XkX4+ZkeRaAt7FAgSilgMJNQxt5FfAFaabwKFCC9ffe/Uptg/bL3yshg2P2PhE/ -8YMZjyI+cDWDOY+iP01+Y73XkBvPizXfdbNWNQIE46YDAA9HsftV6pr0aJ5Ky0yTSNfRdIy+YRaw41SFv9K5Sx1KdOEdw3K1+E9x36+uaQcna1KPTAPwx6PZ5WY9SoyqNqjGo1qM6jeowaMva7UYaVRu8tVx2oDcozT0KjB7fYTH+RTvED80fZKQBHAdMHTALsmbgBCOwfZEMAs9frfl4Bt9nQiC3BQWdxB4yqpLQLBl7GJ5B4Z9FIEnOjWdX50C +aq6ft3NfP0c1qHVzW41nuv+Em9whcvFQNuIzA2ndFNaf2qQ9wHSMMjTIyyNsjHI1yOnauFWzUZD63d+OATEyUvlTJrJb92GmBcLaAr+8TvEAi0A5KQBHAdMHTAzsvrgBCOwA5EMAg9krfG6gJT+JgIwgKmb9LOKPdTMImQf3t3DCNLFPbGtj/0IJ0+FGCSqMW109eV0AUHiQOMPwpXlT1m5inc7WLD9PcsP6jdXvdUTj6w212nDnA6uNXDboxuO3 -JqQW41UwGbbUV8DYiZUmDeh3XuKa92vVF0b9MXR0URN3FcTUN1kY5dWpjhg1+NIjWY7+OojuY44O4NXSVAC4jVvYPUGJxXb6gJilggVJBDPQSRCQ4eKChPhDjXXO0xJC7QXCRpbIJyDKADgVWyDjmE4yMxDC3A80FTRUyVObD9nX8BZIIVBwjMUQ4KFmFSV7fpPv1HELDZd255Lkm4+hwrZIpixSZ8H3D/7XuLiJDk/6OvDaLQ2q69a/aINuT4Yy +Dno5IO2N0QVACvDU8sVUhtwY1NTcKGbv+5XtrcVeNLuJEDDh7hC3WInud9bQXWPxuAGyCcgygDIFlsOY/RUQjq3d85FjPPsFOhT4U+/2zCoUDFQcIwJEOA4xMwk23sYnkMJMHmaDohS/eN0E4j2JcPZSBdjskxMNPCCk14mzDmA8xrF9I46X3aTTPRX2rtZo+ymOjRk5cOujgg2ZNbjXo/11RBeRdnL55x42IipZ9GASCt91Ve40JoM3VwpBUvk5 -TW+TcSP5PwjgU5mOWDIU/+N5ji1fv1FNrcrPnH9ispy2bI5/SR2XBQPRopeUYPRwEYTzDRVMjjqvrEOLZ2yYqqETH0+/G7JpE++XkTyPQJ10K3Q454GtznraDCTlQKJPiTkk9JOyT8k4pPyd6yYX3GBCw/c1LD5QIthmW+gPsAdAUfvVNGNlhkkrAEcIINGjJODv9BDyjKCARbkXwJZCVaVkJwLlSWpHkh51nTFGWeNq/twPejTFVjVnjbw+i1uT +xYvjIYdFP5jeYQQEU04yesybdu00dED5GIw0lYjkDcB0QTEEWd3gdMleUAkT9AGRMUTVEzRN0TCAAxNwATEyxP0l6vnW24TmHU70VDG5XFMQAy2Apb6A+wB0CW+5Y9IbOKwBHCDGB5+dFriTLGMyggE25B43D14+lZA0CWmrqQFIVMWqVwDmpSI0OFao8ZKoD0wzI1PKdmVgOtT4eSClGjTXaEkadnUy1UlARZftADkV4JBhWQsGKjr1A4wJUBbm -Ig7A1iDMHb8NwdSDRYTrl+0H2RXgkGFZCwYxOvUDjAlQA+aEAM4xYR9kMANOSYAIAleAyAvELaBGAQgJBgYQQgNUB4GPiRiNvdh08aTYw1JQbSquFo8lPyx3LfFGIgWpFZAtj7vQ/00dkQ9cXPT2E901StAw6eWnNpQzuxjDlQ/UB+Ysw59PHlgw0kMRz4HHuwVDEwzHPxgccz9MtMDQ0+VHktGC0Ma1bQ3x2flnQ8I161cA2DNuFOLIBXHNic+H +hAIF61EA5DACzkmAG/xXgMgLxC2gRgEICQYGEEIDVAoBgokPDHPSNMFV2MKe22qdbEiD3jimmEb7OiILqRWQCY8COXhq00t2vjG0++NMFn45E31lWQ94MbseQ/YNQA9QFaglD2tpkMWDLsyBxbsfg+7Oez8YN7OwhXKuuS9l5INENFNe5HEOYjCQ+b1aWFLcf3SF9TbS3lA5g14M5DPg27MBDIc4xBhzGHWUOENbLX92ZtAECcAdAC4KMCIQoyub -MjDZQ1HPpzscyjNmlaM/BUYzEgHzQnAHQAuCjAiEMcrntWFY8A7DktaAQmJBzJuNJt2wOQM5IdkPDXsCiQJC2ZJVw7RUHjdw2Um2TSZaeON5544LMLTV40tM3j4g8+GVtZNdLP7Ass/LP3Ais+0AqzasxrP1gWszrN6zBs88bGzps+bOWz+02b3vdHZrsZuD+I/+HENSSth7l83Ncr4NjgNM8692U7VlOP9j01u1itTI5a5SjrI8q0/9myb5UYL7 +kNtzgFZBxAXYdmWgEAaFlPXQyWPKNem9kSI5AhlAn3ovlAw++X2qMNdJNT1pM/qXkzRzegNUzIeY1NXVzU7FUrD8VZBWtdXU+zP7AnM9zP3AvM+0ACzQsyLNmEYsxLNSzMs1sbyzis8rOqzQ048Oc94dd5A6zSus4qgemdQlms+bcetU12FBcm3NFoI2tN5Zts0r1ltDsywWwjpI0v3uDxI7i3wjqI0BN1Jx00PmJzpLUkOH9dOfA1TlXVESN0tJ -Iwj1/TvHR+UdDQyiI2qgHldexeVEo0aXoLnI5gttzjaXc2dzmA+gCdg+wC0C3amo5UAxwQwE0D6I/pguxGgRoJyAuR11VHWJmSJLiCO6LhnAZEjU8zGhmQ90V5RrFhatVVJtbo/VV7VQutZPjTLVQB2kWfo3P2XhAoIGM69UDYtMizy07eOrT941GMmwnGVfNyzCs7gBKzD844BPzJQC/O6z05PrNQAhs5/NmzFsy0BWzgEwdNYjAnnij6J+xZtV +I3Avkjpc3f0RdEgJ2D7ALQPtrMjlQDHBDATQIYjmmM7EaBGgnIO4ExhllXsaYxsMs2Mrwawjbg2stuGZBz0xclF5BqnlfKO6tSo1VWM64nT2OBVfY0aF1TIqOa1RV9hiX0rztM/gMdTvbm11bzO8zzO4AfM4fOOAx8/WCnzks7OTSzUALLNXzSsyrMtAaszuPDTLoQvY24LCT14WdpRaB7QJxTYpqu+NRe3CIkAYbC3ceOda0WhcqY5InlAy2OnL -XWaANh4sJhc7WNp+qxe3CIk9Y8LU+zC9X7MdjK9Y2GYzjcucA9A4kzkBlTT0yguVTQ3eYEFwi2PkuFLdQ6z0VWzgITaQgv9YBExBSdUXQKLPwEosLz8bR6FMUH7buHI1o00F0PDtDieN8ze8wLPzTZi0fMWLJ82LN3ji3k3WXz1804suLkfo/NRini2/O+LH8ybMBLP8+FOFNds8v0xTwC6qnYMVA7o7st7nUdU+c6tJ3HDw8CwtlCtxrlEOBzlB +nAPQJRM5AkU4i3ALSesUmot4XeXPoAUS9jCxLYQ6D17GUNpWP3QhwJ6qBLDYv9BAem5EIu1FIi7KMDtO1ZVNTzciyFUydYRfPNDjVrUCZLDyjeovjjBAxo1Tj9YDotczeiwYsW+R846KmL585YuXzCszYu3zlk2HV+KCIM/MEMAA1/ZRjI2jsXa6EvRjy/ziY0+MAL1s+tN5jds0iWo1H7Wh3ft2ET+HhD6I3t0nTKC8TX4lC0of3i+53dBGkL5C -hK2EZzHfbXETStdxPYRJEw5WkRAoxIDuOVE2j1iNOfRICsL7CzACcL3C7wujA/C4IvCLSM5w2sdAkaaUML6nTa3jjbAE0B9kfQNBjGhRoPgDVARwBwBXgLQBAJv4BLBzEmjdnYgX7klghJ5TwHs5V60CnkMFAJTYJPH2jwvnS142RFk3C2deIyxNMVJA3rvMCgzk6csXjGZbMtQdos1E1XdMTZLPPz2s14s+Lfi/svfzQS7/OYj8qXvY8AcMkAs2 +zACUL1C7QujA9C4wvMLyHVt2c1v7df281t/VSPELhGGwBNAA5H0DQY/IUaD4A1QEcAcAV4C0Bf8b+JyC8jIoaxG31YwewjShJszF54MnkMFD+op4Rv2jwXhRJGm1+M1H5VTvYzVOiY+CXbXhsyk4X2mlYeTgNBJq87pO9LjrUQMlAEy+YsXzcszMs3zdi3fMazTi+uE8Ar0gGMx1cQe4vsyh9nj2cikRsoMnpFao8C4CuyxbOrRBQf5MNzgU+UDx -cPbWWPNBLsXXYVeIVL4NoA2ZlV2OsnTgv539O+TO3tjOU8PN5TAKPEAUAtoLYG6NFOiUvILDHUHN7tY413PoAfqwGsLgQawTOoSWSMSAcch8AGUFaQBH9htBvVgOACrjXgNP5JQ03z2dxG88rFbzoy4KBTTu86i0410y8IN691434orTPkzYt+T2y94vvzRs7quBLwS+PnttwhUdY8AZ7Xz7nLEEwoWrwVA2kuO9WqtaNUNMCgVVDE903vlILfXR +AFALaCSBFDVjoJLwXUks5GyvYWNQrEAOauWrC4NasNDA4DkjEgbHIfDN+F+ddAwyFK2CQk+1KyTHFTdiYD6OJw7ftWBF1U93K1TbK01FzDNM01MaTo40Ok9Lmi4AFtdIqxYtWLEq7Yv2Lhbf6219ziz9N2T0ddFlqkq8AAMlLEY9yqwgQjg2OLUs022oGroiVbOpGxbSE0nLddSxU7TFa2iVPoB0zt1EtCc2b1gT50y0nJDd7JBGYLb2qyCwr8K0 -8ufJXy/cUhz306KUa+Z7WIEOurQ/yPtDgM5b2Cd1E1CvijhGAStErJKxwBkrFK1Ss0rV4HSvorEAN9OCRNzegN4rUa4XAUJ+gH2T1AC7BxPztfmZlqrIawf6ztBbndGCWQWmSgzRtORDpN9L4hRCB4MUKfvTft7jYMScDXM3GU8z/jZSlq9DedWshN4HfvKcVhWdB0qr4s9d3/DkAM4CIQ3YleCjAnIFeDOAlQEIAxwmwB0DOA7C0MDewOyItijA +MCIryK6ivormK0cDYrb3VHi7Txc8yUUjbrojrCBWrPLNCA+gAOT1AM7OhMmr0rUyg5IJkJkQtwd0HPx4MIZsFCeqb+tsI/AdwrKMS2aOD42n0u1VyiCN8A8TM6lezXJMe0M812kL11M4vMqLy87gPdLa857UbzrM5ADOAiEMWJXgowJyBXgzgJUBCAMcJsAdAzgOQtDA3sLsjLYowDBiSAHQB0CXAUtE4T3AhIR0C4A1QFADn86s4e1PDiyzusN9 -MGJIAdAHQJcCi0LhPcBNAIm7gDVAUAC/zWzTg7OYqS1JRvDmMoLeQ0jtSyINkIp2RHSJhDLyxENe9kPauuBpr0yHPFD25cnPlD4w8yAdA5ALbDhA4zfXMlDjc5HOpztm1AD2baZE5u6muc+SDPlBc2s1OOh6yXPELdnnq3kLQCQBU/5sDi5tWbbmynPpDlQ95uObWc++toD6jUwuKjnaFEXPAnIItgtAohPUuWharkkB2kXCSvCi+tAmFBxiSJG/ +csRvCWMOuvfXl4KyEI4Z1pwE3EPjLnSCOLd3a8P3HLIC2F1gLy3E7N+zOc67OBz+Q1AAdA5ALbDhAyTZpvZz91LkO6b7swZtZkxm6TmRzUQyeQxDcc+GTxDk69iP79M6+guUtac2f2YRmc6ZtNl/s74N6b1m0ZtFz+DVh2UjgM86twA+hc8Ccgy2C0AiEuS2mmf9ZTptw/uZPngxhQrolIgD1VneCX8d4isPNvlchGPM7NNUWMN1Rkw7Bv/51XbO -VC+jJUhsKFy8xcPUV8arC0RlCAbt3bzJ6U8P1556ZMtzTkDXWvmLSq5Yunzj6Sb1+T9G4xvMbrG+xucb3G7xv8b9RIJvCbom+Jv80km9JsdAsm/JsGrNs2EtfhPAHAlfdG8ToywKh5JOvwTJuClNjtnkAAoDZArYZti1xm8/1lLL0xnHv9Nprgsyj2C79u0LeCzyN8NjlUeuCjafcKOwDPQ/s19Dkoya1A7/228kfrWW2k7A+9QMoD80XgXAAdAb +3zD6k/V2aTXS1zEaLzM1otdT2G7hv4bhG8Rukb5G5RvUbtRLRv0bjG8xsi0rG+xucb3G9Kt8bD84stIxQm/INiI9kJxHyE4Ne5Mt+x8mXTJBWhCtNSOhy0AsqbyS46sDruC7AtkjXBRAv4Lf7dv2m9u/UnNupIet5vUtx6nb3cmN21dtgrLLQRNlzRE8Cj1AygCLRqBcAB0BsgPViSDOA+gEFa2+1QC0CqTG2GwsbJEICHFWQN4jJscd9epXSMs/ -IItYkgzgPoBZWcftUAtApy2thiLDS23ZmQtcWiFOdnEAcxj6pdKyyAwl9j40JtXoX3aptmi/nXirui6eH6L0qyYuuTh82RuQdXFdiVUbiy1INN1s25KJMbLG2xscbXGzxs9AfG5931g623TAibYm5sASbPQFJsybcmwpshLf87bMdmlnOdvnOTsX21LajAlxyapJHUVWsmSBG4yurtRqhNzJnq+gbwFPq/T0wAMyAuxwABTj13LrJm59vhrTHZGv +CGxiFTfejq212Ei+/nZeDS08ImtCi+FU6jFrY1tmlqiyhttbWax1s5rXWzhtMieGwRtEbJG2RsUbPQFRtDd9YKNt0wDG0xubALGz0BsbDGzNs8bDi/fOazj8+ZyKr5nY5NExi/BYyTUCbViYplYJPqtw1deSmOgug/v90wAcyDOxwAsToF1HbwTb/WqbUIzYKER5wKbtsA5u5bspbooYgRo4CfON0eiNrAOC4gOO0yh4737v23tjiPUO0jD3Y3Gt -MLEAOcAB7bAEHsh7JW1zGIEyOJnyfKB3IztpqzOwyis7bGH1PbhAy0jX7jno2NNlrEq4KA5tM0zUlTLI28GNi7Xw2W2TbCDdNvrTcu/EAK7C28rvLbau6tsWEWuzrtbbO20bsHbRy1h3GrH/mavgTMSzASWQABFL1O764Lbpxl/xQuKLr6EyK371pmyfnmbPy8aWYrcPaFZ/LIOxANatyTJRNQ7Z6wbUXrEABjtY7xADjt476sfcCE7xOzHCk7py +MrGo/2MKLrS8ou18yG7yuob/K9mts9bXd1sc7vW9zsDbfOwLuOiwu6LsTbU29LtcbsuyWtGdZa3Kvr+sg0eON90YAeYAEM0XZ3rg+9uGb7MVVe2v67Mvdbtvjdu+P3Qjf49hPvhVScCv/joK2iO7d8c/ctubZ0yTXPLeI68vXTF3egBA7IO8QBg7EOwzH3A0O7Dsxw8O6pM4LX4xcvMt+Ez93/bD8eUCIQkGPoCAMPAGQDMA9vguSbAlHZoAzsow -7XP77x+7KNWt8o1+sx7iEJBj6A39DwBkAzAAn5zkmwGZ2aAC7KMCWDxoxaFcxHlIvB+xJIAdxEuSdQOCJAKDAuUTJN0PI7Nb/CcKtszisXzt+Nk0/ZPSrsq0GP36De6GONrVi82tLLtiwPubbeu9tsG7u2/tsm7va5h39rCIRW6RLFFMPVcCtFABIA9J8FPV5iSavy0Gb9RhEPZLONgf4SAfZBwDAHjrQKmh7m+0OPb7dUbvvR7OWxABqHGh/EBa +IIM4r7E23WtwKSCSAeiE5qYH/DwpW5TSl4ffKViR3hZJH0rqo1Bvxr4PiyueJSa93Icrqk3TvcrDOyntM7aG2sMYb0KUXvjb4u5NuS702+XtzbUg84syDbw+ZHKrjk7QJMUN4heMnwePKGJOqibc51/zug95F51Ru3GFblHALfs8todlbtKbuY72sD7H406vpLEAAOSCH+gMIeCbHnceVNz8IIZm1rgxEyhecfuxpKYMDFekkQHP3rYmlTUaxVMx -Hye0ys4g+ebaTDgChOmYYFTkDq6uldlCmJL5jwf1OAmg0/j4jTJazUU6LFB5Kvk+Ey8Ru0HMRli2dFXk0b3WLLB35NsHuu/ruG7e28buHbSmwOs/hVu/h2ZYyxI9BVhE9dptUNARCe43bHuwgt+z72wyMR7ny4N0/bLySDHfTe63r7Ar+yYkyHJJ68DMZ9oM2KOW+QByAd0wYBywCQH+ANAdoacBwgfk9WyWe0ZbfE8X209Rh3YBXgiCKMCJWBM/ +rMfhJ3QbeXkgeKTGAwhuXVSG+mstTOB2nss7Ge11OEHYuxLtS7HG+QfzLxnY/Nbhiq9WvBglIFKFozF45JsnpPwJwhz0QIz3vPjfe/avKppy++2DrhqaOtkB+NS5sTrj21OsL77spBNzrV0yf03TvNLfv37j+8/v4Ar+9+of7X+7uvpHZ+2uUQr0WzId2AV4IgijAnluWMCTQiaWjrIy/MH02RY8NMqrI8mI1aQHfeicI9zj0Lqs9hE81TBgbRM4 -rTlbrcV2wdweKAczaKrdgmLyYY1u4c3CpojPOPQRea42irVMBzPYbsZezuHjjkbP2Ebg2yEemLo24qsS7lG95Pb9La+tPKAmgM4CcgQS5oALg/NMQC2gHG74AD4tuIjr1EXQOqX0AlCfoC/J9wDTBDAV4AW5Gg9wHBj1ANJmPsCHxq1FHza0+9c4/U8fYUUQLJHVU0S+AAXe3FHp8R71lH9I/R2dNke6OO4Tdc2HOubF1KMMeblQ+UhwAjMOODOb +tQkz8BzHufGtW3n1ZxDUw4dJ7Th2osuH9rQKuTjSVX6KaAzgJyB2LmgAuAi0xALaAkbvgIPhKiQOrURdAZJfQAAJ+gPMn3ANMEMBXgIbkaD3AcGPUCIm/h9XtazpkT1r17cseCBG93qusvRtkiOXlwqM0/WtybXBwptrRYh1FMnbDq6AtD7/m9E2Bb2mwHO2D7s5UhwAjMOOAmbxJ2WVBbec7VwGAVJ/Ohhzh0/SD2bBdgU0DlsQzkez7eR+5toL -HJwltcnTczycTDfJwKd1Lkff5tNDQW6fugrWzZDvlz3Q6KO0T0K06pf78Q8KfDDop+5vJbEpwYD8n86OlvYrIVYwto7DzRGCjAURQT15NFh4Y3PKjnUgWJKDhtsf/KSbWFCQplgie7nDULWvOdb9FT1vlrdfqr3PDQTfzPDbRbW8cUbyq58eSDlsWTW/H/x4CfAnoJ+CfygmAFCdRisJ1eDwnBgEiconaJ/sAYnWJzieKbEUwOuXRU+xdu1NwVMD +eIxgtvLWCwZTH7js3SfZD5m7nOWbAQ5SfUnOSz9vn7zvZCsyHEYKMD6F93VY3u7rESspNDQYk4rKGNrJ3HqhYUNsm6CM7ms2GZpW0MPjz5tZPPrHsiygN/MdW8mu7Hw4wceM7k8u1stdLM9CnKAFx1ceBntx/cePH8oJgAvHjou8dXgnxwYA/HfxwCf7AQJyCdgnvG5QdyrI0XXv4VK2/nJ5IySZqupJHk/SB2QqWeVMHbeg0W3KbEh6dsEn52xi -03LDq+TOexzIi1ZHMtAS9sKHb24ydYTVRzhNGVLI4jsoDR5TgtDnFrfgtNHZEy0fhb7+T+VZ96pxetGt8O9K0WFdC7xN/7/EwAdGHFAIhBHAlQJsBDA5MQsf808QL4tQAowDwBFulQNWfjBlO5aGnAekonUbHe/JSGQAHBGY0zifwMOArI9GC3GqLJZnVXc7ZBWKt4bAu+eETLxi52ZdVLx/Xvyat6REeS78Zz3mJnTdcmcAnvx2mdgnMcBCdZnM +1fbUC5UlyFjZ1f1T746/ycjlqC8nPj5BI7JWYTF2wy3fbn3YeuELapwDvlAFAIhBHAlQJsBDAwMZ0ci08QJYtQAowDwBhulQFmf9+yOx7sl2LcHeHrIi/APOIz4+ntwMV4VECTTTKsWJMhKXlcTtxmkiwyvk7se/IsoH2o33a6jRfUvNen2Bz6fM7fp51uYbeyEGfXHoZw8cxwTx5Gdxorx2YQxncZ98dXgvx/gD/HgJ8CegnFB1ZNyrrNTQcbpd -aNCcWEuZ/meInV4Mif4AqJ+ieYn2JykeVngh5lU1n1u0PVzFpumCQX2ju1OurBy+0XQWQtJ/f2ZLpqUof7+LXegBwYGELuD3AMAGyB9Az1ef701l8RUdhrfZ8HMVL8ViJdiXEl1JcEzZDpCDdwCKa5wNxb5xXQwbC5f5Q/n4IN7EmTY1EXt7j5x11uvcdx8ekCgVe4Ysgdte9Gf0HDa+2oLL0RzLu2LaF6mcgnWFzhfZnOyIRcInhZ2RfFnpZ1Re +B2xkBS1gTXI4gHfRrAAh7exSlYwFZzwdhLfB/5HlAcGBhC7g9wDABsgfQL1UyplewPE27o/ZIf2z0hxOcSADF0xcsXbF+/2gWkIEJO0YiWqYEMNzYn8DDgl53CdTH4irUudj5hwEWjtVhwKCU7b54OOJ7rGsnu3VfK8cfp7wsZ5mBnlx6Bd3H4F5BdRnuyHBdfHCZ8hdJnKZ+hfgn6BXKs1xwR441Y2x3PMSa7sm141UcqJsDh672dfC1JHeJykf -4nExcatrxR/TdEqVZKMljKVQKvpt9ZrZ6DUA4zy12eILOh+VOVHa69Udsn3+wrXKd8c3hNlXZdg0dvxfI2Dthbx6xFuQr1+5b47ne5wedHnkgCednnF51ec3nzqogMKd4sD/tzDG5zMcCTw3QCglYmwPUDQFQgJUAWAzAOvXnABAABAnAXQH+A9Jyk1pENL35xpPjwNXXsD5H6HmY2PKrRsP2/nvvYKvJBudYF2gXgR1UmOTv5DQcwXdB3BexdCF +9rZy1hOn7v4yfsATv4WOsgTEDYd3gTnm0vtgdpR6vsQAU5zOdznC55IBLnK52ucbnW578ofbKHSPsELPTSeuERpWJsD1AW+UICVAFgMwBF15wAQCVzXQH+CxJrE8757GCl2MEcQDnGsIJaJpwqKn+ifdNMK9NK2gnCdsBzJPPniBwV7IHVXfn3EJ+lwNb0zS7caNMzAF6ztAXDl/GeIXiZ6hepnGFwst5mzCcG1Bj+F9oLnk8LloOORFICRdjm7Y -x8dRHzBz5d+ToVwWckXRZxRdln1F8csdmeiYV0275Y11QWCQzkEEA9+IEhn32L5L8Dr73u8+7NdXYw7AnA+gNgC+1IQNodzlW+4Vdmb325ELA+9ADjd43kahN2zjXUUiCtwGOH+JWslJ7QJmN0mPvDwgAsSZAL7243xj5rOa94fFrpe+QfK9D19NPOX6JrSlXp20fWvHzjB83sVtrezCdwnYV4DcRXwN9FcVnYN3JHUlx8CXSOUcE4kuiW0C7mhG +vnLRzVF3/o0Xy3sbsOwJwPoDYAYtSECiH+g7ic1n+J2pv8XV+4DfA3oN7F3jN8XbRk5IkiNFSfkyJ++tVqgOPvA4aXHC3uDzfGBGsmHA+kD71LTp8T0JrNh/Huw+eo2mvNbGa+vX/npo4BfQpJ1whdIXKF8mdoXaZ3Lsyr4sRRHPzLueXRN0KdShonpwisBseR4V7RWRXUN9FdhNzBRAC7Tw6+UCZHXZdPt8nyC3PvpX068d1ZX866KdvajV81dP -K6G5lOvbeV0Te6HJNzvtk3A55Hhbr9IfUfgx9lbYUgr4O2CuyBl+81e9DU11AAzXc1wtcmAy16tfrXm1y+tvrZp2p1wVlp9+uYAQwIQCVAtoJUDnAcIpjeWhSJIkAo3iBNUYA42x8kmcCcIDiBkCZzLmroSQ8OZBIgYQQiQYblxxwMHmOG7cebz8JSGc7zwR1JqvXYR/BeeTiF99dfHMR+tNo6McNUv5b8QJBjEA9wGyD7AiEIRAUAnIHym4jkAE +dbVyYCdX3VycC9X/V19N7rFawes39rLUQsyHmAEMCEAlQLaCVA5wAuLTVrEVIiJA75IRVhGFwEygmnRiTQJwgOIDSnrcKWorFVhFIEGp49ZhyMPLHU5hBuZ9lhwgcHNUjXBv1bKa4hv7HjN84d/nuB3pP4HtRODoxwUS/FvxAkGMQD3AbIPsCIQhEBQCcgiKa8OQAQwJBj0AxAGUFz0ByNUBAa/ns8AtAFDWBpXXAR4st55y2/HWrbcJ0l3pZ1KY -MCQY9AMQDTBduPsjVAuGtl7PALQLo2EaoN+PvhLM+QlcEjwYDIczdo2dzW6SxUgDCXA2BZbe5XDJ2HsfbCl0Vf9nstUBXxbup7VDcnBpy1ycZNYKyAGAWc9utxbOp9ZvNzQD6EDMAoD/oBZzNV2XgzhSzYFurNCp17dKnZc6etFp85xQt0Tmp7FvoAlm3/dZAAD2nOwPID2wBgP9C+ae4riwzHswAnIAuwcA05EaCZeCa1VpC+WIX4QrIdTRTMj1 +q3bbamgDCyafjdoMJHByzieJLUV0VkxXaR0+hZzJJzKc6b5J/Kf4AoQMwCsgBgGHNq3kp54Nn3tUBZuX3tXNfc1gd9/oBsnmJZyd9ljm7HOpXB3YUoebBt0UcinK+0wHpDGc0/fOzpJ8FsUnn97fdsA997Vd81vTc6swAnIDOwcAs5EaC+eDQ+SAhQ8IK+KcQQJFtHvrh1tDjHADhb33Pl/Q7acfl9p6J3OJsa5pc53MG66fbHPOjV1qT9O4Zeqd -9GBDjHAcZbf13cEJivOXDMLTcP/1rd4A0V7oZ/1s0FUt6iUndl4+5fy3nl1LveXKF7Ysj3Y9/laT3097Pfz3i92yDL3EAKvfr3m98BBwAO93sB0w+94fcuoMVxSXGrGFRkenTuZmPLQtjZ+QoMoy+3Zq8QAbGjezlSwQHN23+hw7ff3gO6ufA7hQzQvxPSO9nONHHt80e/aqfTg/tH0O2qcEPGp0ufULCO8k/Dnv+9T3jXW54JPlAMAPoD0AkGAE +y7Qdes3R19CnV3td+FYN3Tdy3dt3Hd2yBd3EAD3d93A98BBwAw93sB0wY9xPduo7l9hVyrh5d5cTTH6weeE3c0w/Xh30RyKO8QPrD9c5ZWZf3u1nMN/WefbeC8OfNnrFa2cIjd2+Tk4l+Sk9vjlL26nNvbMD+f2uPl202e/TJc3VcAxDdTAD6A9AJBhBIdMJUD0A8W00AzszgAwt9AMAEYC2gGgdudSteS2uBNDHlOCTMYwx5rpDgSQJWnG0kop/ -h0wlQPQD5bTQAuzOAAi30AwARgLaAShoi/61dRqmTsOOjW+i30j1Q4EkBrpEiPcJQLFlyyKujXOwPb+hwZ4o/Zt4y09ftmUFwW3yrst2NvvHcZwPcJn5WWTUGPlQOPfGPM93Pf1y5j5Y/WPG90YBb39j7vdOPB9z0BH3bjwWPGrVJZDeMXtuypBwGk+k5IFSBwLzV/yE6t+d+oz9yHGvLowcvXKHQlxAB/g05MQD0A6gKc+E3ET6K0f3pN5K3KXz +NFbW8mIv3n2oSMPSL0e86cvnTS2gOyd1Ox+e07qa9+cl3hx2XeuHh1+4dAXEj5UB130j83et3qcvI+KPyj/3dGAg9+o8j3Wj+Pc9Ak93o8+jcqwCV3XeF9ulXQr+k3pNyoUjwlqDx8lWoKXAaDLdwtBu8asxhnnYap/gs5MQD0A6gNM/g3VZ+Ie27Tj/btxShEW88fPXzxnHI3Vlc0NmQqynxDv4s1S2MBrAJPxG1PwUmiJb9jT+xRh7g7QscOni -vIi/IvqL8PF03iZuq5mQLynxDv4wNVuMFagJHEB2aeGUkkzPfN/0tYW1l/Xd2X8j3+387Yy4Lud3GJjLd41ct3MsK3Xlz9d6Pfkyc9nPU9xc9mPS91GK3Ptj9vdPPzj68+uP2tyfcnblKidOJXpuMJhenCS7YJjEPQbApIFt/SUdW3r9/lelLWL/bc4vNR0NcH7/y0ftVXQK+k9TnmT4I1tHwytDudHC55b41PdTw09NPLT208dPXTz08vrAK6rX +cVVvJxOlxtc7H9h56fDP3pyDzl3Jx/pNdTUzzM+N3cz3I+d3joss+qPQ9xs/aP2z7o/pnmF1rMQq40w3tTUGmZ5DeLYLSMTHhz8kGK993e7Le97e93asH3I8VIcuP1V/FfQLw+6q8ILR03cs63Ap/PtPLhR5dPQTZR+gDxPiT8k+pP6T5k/ZPuT/k9Ar2NUlfoPrR/zVAzJIGQA5PwMZBjkbhANUCEAiEBwAWmUAAqDf7Ktc5CKlfrIymkgomExx -rn5T7BWgFcVs7wkgZAJ0/kxkGNxuEA1QIQCIQHAAGZQACoIgepFHxj1FBs/UaSCiYLHGzfUY3VuPBF0jOpnWUzZkyQd3Xyz9y8VrVBxBcvXIuzMuaPwr9o9IXSXYWX1gCr/c92PDj3vcvPbz+q94n4S760ZHpY9EvEnxMp3agqw7Sbix9xUoiQ3ktXW6utjHqwhICXr7ljfoAzwGoB4JhAAuwtA6Lz2HvLUT+usClVU9+snvZSI4AXvCa+/hzpI4 +UPw4CVbjwnkAr2WQ810J3h+fhYyudPq15D5U7aB9teWhi7Vc3CPzPaZceZbXSy+rPajxo+j3Wzzs/cv11zwAStyuw5MPXdiBXZnKIvaReHA7nIiR3kTnRid7L/8+c5PP/t1qzPAagK/GEAM7C0A/Pb9kE2OP0N4C8KIhEaO8VIjgJO8ND7+AWnVir6zy6yhCdeXImswVBjgtwGMyTfVjphyBt4v7D2V2cP1h2te2HCe/TdDPHSy1sMzxlyaOx5Zl -pBsvt2x5Xfms3lKjiKeOSZ4cFrQt+y/dxpa23crPwqJWt8v0t+mU7PMZzXXzLOj2K9HPTdcO8PPY7888uPx99O8nbDpV486v5IDApKLmmybh+su5k33fAo7fIdQvRmz2d6Hd759WbrQ6y7e7rbt7yMhb9V0QuNXs56cktXznkm+kAKbzwBpvzgBm9ZvOb5Bh5vcIlqfIzMb0X1xvJfVU8SA5wGyBGgAEBhBzXml+wnQpGMmLFkO2x+QOjRsKTN1L +6W+93Kz2s+Vvmzzo9T3EJ4/N8lRjwK/mMAIe4zib4NFCDBhgfd8CXjSbf2/cHsJT2v/P874PvKvKt0Ov7TFa+yegN2r348NGerz2dqe2Vz5voArr6QDuvPAJ6/OA3r76/+vkGIG8LiEp9UmOvLt+Odw36AOcBsgRoABAYQLV2JdwJuyQDIhxoFiacBovTJKII49RbcEpa/wFtUZe8l4wI4vrDzMKEzGd6seQb+L98kB5FM8c0PvX544dkvv5xS9j -IqIZVrbDduIcIld6eWB+FSjdzGXeNPAzZPt3fWwRvhn6vc8ddvrxz2/jbyH/29/D6qyUBPrXQCcBGATQG7w9AKTeYOVl8QAuzJekGN2WQAJwMwBpmkgH2T808ILuBwADgQ+jSUfQApO4fsV+EsnOZy6zUz7ZjYiT/AoQ07tyHGV/Oq3KXkJ1vmvL9+D1v38l8yeKXEayVfaniQw3N6nSW5Q9eboQGyDgP9IaQ/QP4p3ZujfSD27eyn6D6+UELSPR +PojxM/QpV4PuUnARgE0B28PQAY38DrpfEAzs7npBhhlkACcDMAWRpIADkItPCC7gcADIEPoClH0BMTgHx5dazCzjhc5n89ww14CPcJrscH5j6irQk1bMCQsP0rw8+yvEN/vcK3h90rfqbp9/ScIPjJ/puhAbIA/ebdJX9Kev3sp+/cVfzAFV83L/99HOAPg5fdugTgpyR9BPfZ+nNhPZgwFulf592SdBzAQxxvNf4W5MktHHH20cCX4dV0WkAAED -DvZP3r5Fv4P0W7n3Lnoc/1+cn/92KeAPI38wBjfdD7HfxvQRT5qaAxxaQAAQMADwBfPxLw0vQui8Lo4G0Jd5whGfEIFxwCxpiXkj1vLW5RWrzMj74eF1e3Q8eefRG13c+fsFzgF7PE26K+D3v1+tOhf4X5F+6NMX/QBxfCX0aBJfUYql/pfmX9l+5frzXtuVAhX12FTvJXydvRTw6xV+LvE0bcoEgl01OtHXtur8DT1XGt7Oe7JqQ9NWvoa11+f3 +AA8ABzxC97Gn9l20PQXE1eIvXpS2IinhZkMJib9NclpnWnGzYMPMPFW0sE6f/uYc3537pyS/tLM4UI/7XRb24efvXU9Z9dAtn/Z8UNTn/QAufbn0aAefjot5++f/n4F/BfIzRxuVA4X+mG1v093ma2TPPTCcrbOQfMozTJF+XhBhJ6eEb7hpDHY80FDj8keFfqS+puYt3jwlfhPQ55E/hziCwR/DluJYkO9fxsJA85X0D7b0DnDZ24/0/Tt+Ctzf -Sl/a/FPSrQk8A7T6NKOlPOyfutFzoWzx+rfJCxXMw78AzFuDXov2a0pPUx2NdKfsxyp/HvMyDgmEAeyvEBGAi2EcDpAUAicC+1RgM4AFvqk40ux89lPrcHwLnCTbdgE+jj4gDQlpDhtsHO/M+AXiz56PaL5e62+j2az9XsbPs9tBcw/b13D+xnCPyh9I/4ryj9oVaP1F+Y/2P4l/JfEAAT/eZRP6dsk/+X+T9Ff7z8BPhLBpfRdgZUN1av5h6OBc +zr86s757I1eCEAAyvEBGAy2EcDpAP/CcBi1RgM4DBvkLyHzuULuQfCOcfE2UVhQf3tjC1s+8ATqiL0ZpqF6tj53Ad3fxrZqNU7Si4+/Gfz70zdqdIjx+8lv33zZ92fDn4D/A/7n558QAEPzJlQ/PAEF8hfcPwj+Rf+j1rN0l2Zx6G0Uqu1jiXMtAqFIkrxZyjiRQ7GPePZfwS/DWG7/1/wdxkVE/EBCsAENiu2ry3WT+KvfFw7sN12AAX9F/ShwF -xcCQL5yum3JKIAQx9YT984+7wGyoeawEk/ECisAEASwhrK67e/FXh6sD7YAffwP/0rT3/ee4ukOP94vnk8F9+60AbIP2+/DA4XusvX7cMv3XlexH+S3R3VGekb71x5OltLBUwfJ/aH7Yuo/EXxn/0AsX4604/ePzsh5/JwBl9Zfhf3l9k/FP8V/uP4S+4tyvkScWgh/gTEtqQgXoWYqGnaQarAFsO/m8tInja9onna9evsZZOOoCsnXphEeJiftl +OQv6pTDgs+R55PASfqONg4sN1FjxRgDHYVi91L6l+I03v2l9b+6X9U8991dDv6XdmfJl59+u/QFz99/fnv/QDOfPLSD9g/uyP78nAfnwF9B/MP6F/w/EX7s97jWs8YuxfI3fZxRQEfe/MNr+yViaTw6Sb8DE/z7ah88XALxh+xX6rw69ANP7dcs+P2Jcz9/Hvkd9XuBFQOkbcoHlbYIAKL9n4hL89gNL9ZfvoB5for9lfo0cv/pPtShqOcYnvfFg -vpANwVr7cvHIoE/XoJ9DfleBjfnsAzfhb99AFb8bfnb9xjpVcsAWU9FPqFVKnpNdygM2YNrjwA4ADTA+gPUA4AKMB1PnBgTgBwBJAOStHkpHV+nomZthK8BHuLsJHWKM9PgI1MBwCrIG2NgUVkNdcKirdclnvZd0agKAYPus8JdJ28BXtF1hZv58RXkn9Dnsl16wG/8P/sT9v/gV9S/lT9//idt7TiWMLVgu9p/AygeOAAp9Lrdt+sjmoqGkdwbI +7MChMzL1ceAHAAaYH0B6gHABRgLx84MCcAOAJIBkViMlfIjuc8Vn8AXgM4gtuOCQpQu38VDAloa2AtQL2sm9JJiJ0pFum8qbpm9WVkS9CEltc7fsXcp/iM8Z/u+9Wel98gLlv8d/tD8Q/mF8j/kj8gPossdTmZ0m3sc8JolxxkgpN0G1lPA9rM/p4AiwCnWK/U+3h2sckqCMc/sUEAbugAKAHfwYALaAuQjt5S/jbMFXiktjBk7EgZk4DdwC4C3A -HaE4ATC8PUoJcj3uAQf+DABbQHqFPvMP9w9ogCmPsfVgfBQAogTECCOAmthHiXc+euiQFxFBtiZESAAssoCDcJS9qXB4ccfCB9Ckj4cRbnv87JlKtYPmo9tnoK9dngn8Avgc9kLtf8/JtYCC/jl87ASX9KfqbtDVlPkeAJe9tXhfcHPnbgdCJsU6vuy1mRJuFsYDmtIXkZVoXlyUEAYL9sXt8sRfugBnbl9N2PhKV1WnL9uPgDNPXk1cCAQjEq5j +Q0N6MFWI4ehdx2xBx1PgESAlMrlFDcHC9UXEVNjDme8ybtGtI9oIDkBtTc73rTcAUlytsBlgcjLqntZ/uM95AdClFAYH9g/rD9VAYj9+bvNsFdossp3vy85YmiIvTL6xkvoidO+rwBDcNjBqxvc8s/nLc5XmX8vAWdtP/urdsPmPsNbsBMuvmlcEhBldwHoa92ksa8MAJsB8AYQD8AMQDSAeQDKAdQDaIkCt91hFt/plFthfjIcwZswA6YLOR6ML -652AX+BOAdwDeAfwCjQIIDhAaICo7pMcY7p+tGHkYccZswA6YNOR6MGIDcprjZ6nM1Zu2EWpP8K9YvSmPBF4JZJxEMGw1wJAE6bOSB1XHbhp6uScLjlsJHPlwNcNi28AjvwMGgeA0mgcYChXqYC+3u0CB3jd1fXLgAFwM4BKAJ3oY4H+B9gL4t9AHAAFwMQA+yJoAjgBDZHAR89wlgW06fsADrVrClliCM5YJvlo3ZkCptFAfp6vnV13VrSN5fB1 +QC71mC5TgEkAYjhOZu3vRhKnkgRF4IpJNNP6w1wBf40bOSBmhq+YESEn0nyOndhGlp8s7jIshAbncphrPNZOoZ9cgbTMeVgUCjjrICq+k9VnWrgAFwM4BKAMXoY4H+B9gJYt9AHAAFwMQAByJoAjgC9Z1AVF9H5ha00fnF8w2ujBKnKqIoPrko29mkk6MmEYwrjl9EjgMDPAQV8K/qkc1uifdhvtUAMgPUIAhDV8BQUKC6aA0I7Nnk0uTjHNOvr4 -8mTju0WTgYcUASQ9f7hkB0hIkIJvmqD4hKwxkHjHwh4Gg985hg8cAWfsoBkr9VTlFtKFkQ91fqqCdTuqCKaBkIFPqjN/9h8D9fhAAWgIQBPgFeAhgEIBJ9gCDsXMYhfWKPAWWF0tKXF6UYNr80UsFrRXGH6dgfh1tZHj+1OXkeN8NhlkVHkf8a1nXs4/lPFz/pE1AvhLNCWnE1KQdSCKALSD6QYyDmQayD2QZyDBgUdsjVuEsgNniN6ftP5tgCXR +9AAUR90ABU1MrhA9XtjBNQnn5s4HhYNxQfTRlTrN8/tq7cFvr0pCAJ8ArwEMAhALXsrgbBpTEJ6xR4AywfgMRlO5oGgtqmcAl4K/pqxMn8bzhuAbTps1rvoP8s+lpc9PpCCWlnTcjPpIDXvgz1CgYiDCBv0sUQWiCMQfoAsQTiDzgHiCCQUSCSQeH89nlrNb1pWt3hrmcRRsGgn/pqt/CkFdclOCQOOJYDM/rrEQli/9qzmh9FbhT9CTrT9kRvT9 -A0KjdmTNUUxQfGp5MAbcQgasDMXusDbXpsCVQRAApfuOcRznE8xfik89Qe7cD1kcDpzlk9zQSKNLQYQ9CnlG4xwVgtkdplsO5vHcY9jwAugMoBkTs4AOgJgAKAPgBIoMVYhAL/xnAFZB7fl1EF4GSA3qhFBZwgAoHDmmkzuPH13GK149gBgVOrNnVzJqQcQLtiCxbsgES6hBdmiqEcYwuRskPmYC8wTRtgvrd0iwTSD9AHSCGQecAmQSyC2QRyC/ +H7uAs+fm2dNXtkd5PDv0uzj19ntuz81Qca8NQV44qfvAsonpgCMHvVcG6jwAugMoBfjs4AOgJgAKAPgBIoNFYhAPfwm5m6hkYrisD8gvAyQEjUIoMMQ4eui8DvjwockJF4Q1vK0EZkVYJJjAc03itc1ghcVRAQBQHarm8Yivm8xxpS9i3q8UHmqiD0QRQBMQdiDcQfiDCQcSDSQTUCMzlrMiqtHUVds29jsHm4R4MMNqUpc9UvhRU3Cn7EGioh9r -/tyCTtqtVCTo7EfntDcAIgERCXJ1taxsSBtXEUU24ksCMMvxcvVpndzUrA57Wn+BSAPuAh/jJc+DnJcFQa/1hfuTcHmqeDA+GxCuQPVMr2naFsYOVJ9cOTI3wQ6sjLkyhIIsM4fwZ/UiPNV1f6qD9eBm58hQKtFIfk8dofkYChZkSD4fm0DAoqqtz5k3VIMEhCSwShCywehCKwVhDqwXwcgJnl0TtszUCIWU1EcKcwgCDfcKTr0sGvlrIc1gFtJg +ATWCEkLwdc/nRdImly0/wKQB9wCX8OLoAtuLpCMP/ou8G6suDPeKRCuQD71TWBjhaMjJJ9/KeCA1s6CLwR4xS3HsAbwWi5R6oV0qov6Ds7hscnwSwtgwWdUJ/gsMTPvCDRnkUCLPiUCtGv+CEwUmCQIWmDwIZmCT/o/MAhIeNqQf144HEGpvhinVNWmvdRENWNo5nEdn/mCNIbvWDyfj4DlbsA0PHut0bllrcewQ9s+wcR8BweTUFgbldZwfOCO7 -X2DaOmsDFQd18o9iOD4ehOCVGhOc3Xv9MFwScC+PqI0BPryF9wYeDF7ieCzwReC2QFeDLOreC6AbD0nQe3MXQejMY9nTB4TjABagPoA2QNUAAIHBgI/DwBlsPSDcAPEAmgK4NbzhICGlihYdVJSB6KCYkhstg4DLrJDHDIoVbROkVHtv+dk2u6M02pZN7ItoDEWk5dHjvP1ILtH8tngfNu3qf9oIXF1E/nBC1VgWDq2pZDSwWhCMIZWDsIWX9nIX +kuCVwWuC2QBuCaOlZA7XhJ49Qd00pwbE8gZnTBPjjABagPoA2QNUAAIHBhzfDwBVsNiDcAPEAmgNQdWFkU9snIg49SCxQO5ill8BOl1zwWxhBqhioposb8FRj5VzfstdKbhkCYLKP8XwQ/BbfmGCDLj+d5ITIDnfnID5/tClIMKpDAIYmDgISmDQIemCIIZXtdxjnk5Vgp0qQTH8SWKrsCUHWFOEBeNfhiekrOnc8VijZC7AelE0xhAA2QAuAmgJ -bN+6kADCIXFMmLv2UGONilavqz8yRlQ0hfBC8arMFCzUr7t/nO+4FwE0BNALuBPWoPROIeUceIagsT6m6C2QH9CAYUDCCZr9gZugTxnhG4Z8gSENx9MiB24skh0rsy9LLtv8hlupDXPlB9HLgf8loSi09IfB9mgYh9tocZCu8tLsU/kS1DodZDjoXZCqwThDy/idt8GnyDazvFErDq2CpQb4Cy8FscAgazwlfNz9Sju19+fiP9EgWP9YnqVcGARL +oBdwCK1x6BRD5bvZCeQUfdPNEDMzoRdCroS4tdTgfkAcEl0zgNWwv8Bx4bWNxDaobcJ6obJtNqnMIOxhHtMElHsOHuJDx2nHsx/nYcF5nsc+oXJC3vozMPvsUCRoSpD4wRND1IdNDNIRmDj/otCtZufVz/kDUbIjiACwSl8fFrwsT0o1ZHoCz5zZjvdFNnl95XtyDvAQWNMPva90AT7M4rt/9l+rcsZ9jq8vIXrcCjqADSPuADOfpADEoUIBkoal -8HXiNc7yrL86rp7cGrolDvyvx9/buUByoUIBKodVDaofVDEvE1D9gC1C2oZG9nXnLCtwdMddfhNdKlofhidBwBTfohB8GoxC7Om9VXSlIUA4nt4yOqVULgDqot4gsUvKA710LCbRc/C8AOgjzcksoCorjk3cbji59/DiBClHh58BtvP1vPvpDRdptDxdq0DYIaSCgvvtCSgDwAjQH+A2nl0BIMNgBNgPzQuAT0BlABGo2QHBg/wJUAz/DWDUjoIc +D0oZlDXPDlD9gHlCCoVFCrll+1mjrFCnXpg8ZDk0BUdBwApfohBSYc89jykjVhSm8AqUBip9kgHFuVAZlBzAVY/WPHwMZtNEmAeMQTIIsRVPgTMNSpp9tSiCCOnmCCuHve9QwTCCGblIDyXlWZzPi79fwfWB63n+BMnl0BIMNgBNgCLRCAT0BlABao2QHBg/wJUAx/JBCeXo/N7GqB85YjeJ9fogQLxltsrnmYCzyJmkb/lYDmYdidWYYMD2YcMD -SmoR9xgSxo2ED7CKTvvEAgSeRo2qiCd3hks2xuE9r3qFDeIT19Hbuyc9vtuUogCd8hTjPC5NqN96hqg9Ghot9C5irCMnt/FFfqcC5zlrCqFlG5SHnPCcOlbCdfswDXQawCJADABEILgMDBgPN6pgVgdVKdglkKWZkGOGC4xGrRhMG9FO+rGDpHvGD8YQnCZ+u1oSYS5dj/h8M/PkZCc4SZDqNntCq2gXCi4SXCy4RXCq4TXCWgHXCG4U3DHIaEs6 +j7kSdn7mWUogM19aTh3CuNpV9WvtKCAHoU05QQADewSz8AniB0JypiE0htz9YHkN8pTl3Ch3BgDnbgaDOPjgDygDABEIM/0OBrXNqGoVgsBAHg6LJqEMGADCmxKDId5Me8O5htVH8ow9fQeVtRIaCD2oeCCtjjMNEYW0tJ/hGCtJgiChoUiCnWpAA44QnCk4SnC04RnCWgFnCc4XnD5oY4tBbv81i4Rj9ZRHRw64YbN9vlXCxbBwQU3HeEbIZRC5 -wSdtGWu3CQFkxQUsBaN/Hu8AnnK8xG3LRCGGnz8bbgVcpYV/cYepL8/ttL8KrpODNfswjUnrVcuPqrCFftq0lwbk8VwQU93CsQ9RwUwjxwYwDnQZucL4XbDygDwA2AM4R8AAqBpyLxBYiicBSAItgKABQAugIDCM7grQ7ziPo8kGsdPAeNRNqKM8vgCxgFwhuBFwlooe+qZMhVpUUtAUmD7jvX4DupH8JdBBDu7lBCs4TBCSQdAjaYZ0D1poXDi4 +3g2DHIZT8vHuOC9pmPsxwW5COzsLDx4d2cfIVb1p4YSMqrjSYCEex9V4fN8uPheY2AI4R8AAqBZyLxAjCicBSAA9EKAF0AroX7d7KPQCPTAUgkgKcAtDvNQdKE8DxRnWENwPWEeFNH1SYrStFrg+C2oeqMKuopEEYQKA3wRICUYeHDTPpHDFIdHDkQf/CjQPHDnAInDk4anCKGqAjwEbnDtIcTDH5kG1tAfdddAflhCeD5B0TopoawvPxnQbZEpX -c4BS4eXDK4bo1UEegjG4azCLoR2Yu2q4CiundCdGNBkOgv485wlYkQhglEzXnSdfZvRCu/v6D4XrUBEIP4gBmPsAk/PED37oOCkAcODx/g81CkcUjiAKUiH4XdAtMtOpNJgWYZIcnUFkBYiT4FYiEospCXgqpC4AkIky9pB8w/pR5Quof9ZphmC3LpnDG9hf9FbqZDlbhYRAkYgjQkSgja4fXCokedDzejwAT4ddD3IYDR99JxQjboa8K3qbcFAQ +v30kxrYCh3um0IlhIBagIhBAkMMx9gI74PAUcsW4XWcgXg3UokTEjiAHEi94XdBeVLWoVMuGYEZteUmxPIiT4IojbImVEMXHMFjimkDHwfH5tEV1C34e+CDRrtcC3u992pnP8Y4SUAAEVYigEbYj04ZnDs4Y4iiYUe1FlkvCyYZGUTnlcJ06u28gWiYDoxsfIvgIRUASEzCZXhyCm4VyD7oRzCtpmqlx9pcttulkd8PkLDCPjq4xYZb0oJn5DoIj -pVASKLCLXuLCaEda9KkUkD2GoH0eGhgDAQhx9Qdtwjjgd7cdaiqcOjoQD8njftZEfIjFEcojbQKoj1EZojtEebCDAqNdY3ufDSoUYcOgDAB4gMqFzznpZpyHAA+yGEVKAPQAWgMi9K/h1CVJti53YYDhCbA8I8UOZchoVqo1kFkgTEj6EVZPmhJoeosgLg4iIPgo8xkRjViYTpDlocLt04RtD4/t4iT5AsiYEWZDbFisjgkUgiwkdXCNkRgjokTs +wA2EaQAOESMxuEbaBeEfwjBETmBUAXtEtYZFtj1vFDnVh0AYAPEBYIqucJLLOR3ph15KAPQAWgB88o/oU82JiG9zYSDgobNrUj4ADDxRtjhdkt6Ikum+sMXredmnqb8SdjqFLftn1CXs0tMCD1DQ4U+9P4a1sFIdGC+lmcdY4RYjAETYiQEf0iIEU4jhkXmZ/RtH9Axkc8SiokF/pBm5rIaZD76uoMr4d+5O/PJtLZm51WqlaC8/ugA6YH+BJAK5 -jixnO83AcPUSUAWhHtv48sovIUghl6cCDp9CD3gcUIgXTA/wJIB4vrUB07Fe9uIb2chfpPCsBA81DUcaijlGaiHTuQh7KB+9OWuQNaMK0524rSjoUimIZuvhlmttxhcYSXthkaLcZ+otDuUaTD+XuTDCQS0DBUfhDEfhYDB3vAigkSEjkEeEiZUVsiuQWzC7ZhrtGwfyD8wv7hdhDYkEbvQEAhvSAT3AoDKbJ9DQYZaiNgRus99grCXXq8jFOk2j +9agOHZp3rUFZ3uX9NkWd4G6jKi5USMpFUR9DErO5RN3o8AwcEclcYNVCmxMijrjPUUbSKHtwYeHsvYZVsr3uMNYYSKgCUT08QwTkCnagI9+oWjC33j/CYwdSjOkbSjukfSi7EYyjBkWSCI/o/NBdmMiQjuPoCkM2oLxp6DUEVbgu4Hmc2QX0Dcvr887IW/90Pkq8Rgbg0J9n/8afiq9+Ye2dgHqdNRYSADTkcUcjXrldvkb8iRaP8jZyICiByMCi -sAZOd4oR69vkRftfkT69/kVt8TqMijUUaMB0UZijsUfa08UfQACUQNd+hlG9HauIjioZIiEUW6CqyvsA2APcAWgN/x6poWoh4FFA0kLRUsUEnUghq6VLgIUUcjj+cAfssgeVo6xOCLkg/DEIkY4U59uZsBCgEWGcU4ZGi4Piv0FVhAjs4T4iaYbo9/EfUQhAMnd90MoBOQB0BOMjHBmQcic+gMQANAFS05Uf/NLzqpsVwliFpfBPVTgFV0EfPrRt +uWmCj6ABCjKrjz980TVc3kQcCPkdgDzzG6V9gGwB7gC0Bb+NQ0g1EPAooMwD2Onj9qoaMFMjMi5zyBe10UTed0blA5RMGeQLlEtdQNhp8gQX7Cake2k87m6diXkjDSXoYiBocYjKUYKtYwU4xPbvuhlAJyAOgNfcY4PiDfjn0BiABoAPmsyj+NnmYOyrmC5BvF8MeFWMobBeN3FNqsMkOspe3lWCssrvc1kYkiNka3C+Qe3CshhwBwdKdpFai5D+ -3q186Pt2d5QbWihwfWitgbt8hhhwA0dC9oI6iwiihr/dyMejoV4QaC14UaClvu2jCFl8jsHnwiNvvvDrQf0NSHnRjKMWd93gUujL4dGtngBQAhgMwAAILuA8Ed39laCV1r2n5weBBcB0Ql6VLaO/gSCv/IVZL/D2ttcMAEaH8cQUnDUwSmUpkSRtwEbMiGDr+it+omjyQUBjVZkMBQMeBjcAJBiFwNBjYMX4AIsNsjEMf8D9kZkc+EN8VwDHzDEl +QVKd0MRDoB4ZEMZQR19eTh5DuvuU0cRiqCU5v19fNl45avnhjMMYwiL9oaCWEcOAKAEMBmAABBdwLAiG/n9ha2Cxg8slg5ZNHlZZEes0ZJIxxHKsekMUd6DLvqPNtmg/CA4U/Cg4dkCTSh6jMDoI9Iwd/CMYUpCsYWYQhAA+ihgE+iX0eCp30V9Qv0X4BIsEMi/0Zcjn5gvwuhk5VXrof424vH1sGBjgsEXdDs0bgjOYXmj2wRE9OwbzDBzi2C/M -kAF5Cg4ZWeN4Nq0Qx9R/vQjmRqOcSnmIj5YRr8uRuwiZwZx8SIlvCjTJxi8Htxi1wRT0NwYJjUdhF5v1vcBdwFJNmQcoMcABGo2ANLQ4uNgB9AJIBenhTtOobW50iF0iSKiZo2jILDSqkjhIIv6lV0hMQygf05/wU29WUX4d9MYnDxkWBD9AXkEIuldCCQQZDY0VTCoEX+jUPpYCLSMBj7MWBiIMVBjnqG5j4MZ5jzdpwDhDh9h3AS7FJagERvIe +Qz8tXociFQZKYwHovtVQcE91QbPDBvvQiOwdT8RzivCmMWvDzzPcBdwDRN8QdQMcABao2AArQouNgB9AJIACnkVCoUWD0BiIJhNuFkZf3LIi4BimUK0mMQEgQJ1oDnSt1EXijAwdJ1XUUn55Oo0i6eo79C3m0jMYR0j70YLMDMc+jX0SZjP0d+iLMeGiswY/Nj+itCOUawl6DgxUYjsvc7OmZCk0WCAE2l0NUIbBiB+qEiJUabCVzIap6AD0AWgH -xdfIS2d51EVVeYo5ppQbu9ZQfu8GIZ2Nclg7AegC0A+gB0AQ+BxCesOC4LUYx9pYZCgHmvQAPsV9ifsaJCTIMEEXhGJ5uIKvkusSXFqPrbgTRP1j+kd/USPPNEgzvNDwfs4iRFm+jQEdMiT/gKjFsZZiSsv+jVsStR1sQ5itsS5idsXBiPMVmiYkTwB8LlX9vHozpgcLukCpBxcqGvH1zmEFDOznhjrbhi9ibnQi+IVPCYodFChrq685wZ8iEoV2 +0AOgD7xyIX1hnnLQUcEQ5CvMbRCgZmdiLsVdjt1j70n1iFBBqn7hXgIijTICeECsg1jqOOUiKouPVqord8HUdVtginUjCUfBtz0S98eYntd0YYNjtMcNiDsPpjDMRNiFwB+izMT+jLMQtszfM/NhMPgV3gAyCyLvj8tuNIp4jisj4MZmj8vkhjkkW3D80bsiMSvsj54kgsjkXiU2fr5DqMegB0sZliORstgcsV0V8sSEMisSVjWPjsi+0Ues2Sqe -igZut8/brDsAUMVjSsXqNFsBVjjitVjphnVjennJ8XkU7UmARadCsTHsWrF0AK3NUBKgGU4ugI08DOmSACOEaA4kVlUmsSPpt0ZPAnJDeQYQN3CqUd8pILGn5hwAsRXIBZEXRmosFnh6N02qGifRry8pscKheUdGj5sZTDPrvs9fEeTik0ZTi7MdTinMdtiYMfTiEMQdjLepzCGLrdDfnggxvgNR8DzFziPJGKCnEJnkvhLqiXsTksmIegAhgIth +sX1KWcugDG5qgJUBknF0AUnsR0yQLhwjQK4ilamVi/sFOjJ4E3I7yDCAzgIiiYSA6DjaHMRXIL0N2IHedsUQ+dSdmJ10gZoiAKC6j9PugM+nmaF9ETtclGq+8owb6iqUeu0dqJjjxscZiccaZjpsb+jCcUD1XFp6EVVheIJbPB8pzJrtBxKWDBwAEi/+tvdacYO8jscO8X1EMBlsMnBSOstgwordDOQYhiPMY9itpoRFC8cXjmAKXjJ0atw6ODWx -k4EZ1FsOVEQYZFjRcdajgcd+sW8W3jmAB3it0btwGOP8U7cCyxTET1FFFhIhA8WcME2ruMd/npjRkQZjVntHjXEZGdCcWZjicUnidobnD8wXAj08SBjNsVnjacTnj3MXnjjtnbNwHmBMuYXYJh4EDAnofzC5CKWjwIoENDJGmYsYUPCefisCQoQOCwoVaiIoeLjG0ZbDw6LhELYegC20XFC2MXLjz9grjSFugBfXgCjLfGbiLcVbirwDbjKgHbj9 +OEn4R/sc+ZXfMOBrcTrprUdtU1LtUiNEZgR3cVJD4ce/DZIZejvUQHitMaYi/4RjjRsVjjw8bjio8QTi6gXmYH7vpCL/iEY6LEDAUEeY8xJHWpSwZtYQSjpQ3MRXjjtkkjnHt5jx9r2ii0TfiNXp2VJgfKCx4UADHljzjYGjWjoIorjlcarirwOrjKgJrj9gNrjdcRhM54ffiS0cvDBfkwijgUaCY4AM1EeF0BKgFhjJUQHckkH7FsYMPA3KNwoO -gA7incdHRhEbOjyricYorBIiKnlIj4rDHBOQATR+xpUAqMd6s/MgkhJYud4GTKyVK4uQoRolDgcjtxwqWAXs54AElFkNqQKXl+1o4RiDm7vHCxsS+jlHsZia9mAiNHuZiPLkKiE0R0CKcRgBpyFJs/wH9JOQE0AeAPzQF2OGkOgNORmAPrMHIQBkNXnbNQJm5DfMfPBvKIfAv8Ykt1amKDlZI9t+HhFiCMYDjosWgtIHovDZMlRBaoH+By6ErVSH +2l6tYcI9BLWH2AW9Fw0TmASgKpnZAdqmPpAQQgM1ju1jh/kGDHvmejx8U1tJ8RpiKUYHjb0f6jdiLOQ2Nn+BGaJyAmgDwARaDOxtUh0BZyMwBpZnNCa+uSDFlgeNoTgZDSivG9D4IFcwWpl9jwjbh+bEWCgltWCIrufiqITFMxPL7MYmnhkqILVA/wDPwp4rV9jCT/AzCa5wpQYRih4TydnNqRjpgcqC5gb2caEf2cwCZYSRANYTzCTFD3kXLjCI -j4Sf4P4SW2H5tV4XnMVmixjoCSt9eEbvD09AIjFzkIibQaRikhsES/CQETDcaQSbYSwDpERIBGIEU59QKQACPrJiKrCuIPhMNkjmCXdsGA+18QHiA9vF7jRPCXQPlD1E1aDCAFSDplAId1tscb1sIfvjjVHviD1ob595CVo9FCeYDlCWnjVCeoTNCdoTdCfoTDCcYTL8Tgi7ZsdNz7gQiCPAMkQIsyZ2wecjvGpdwcMdki+LtQjhcbbce8UASZYU +oxB4nPqBSACB8eMdaDdfkGhHgNsxo7gQwO2viA/fIN5TcY3Rq2Cj0eytCBNwFjZ+AfaiLDo/DXcUpiEYdCDVMXkD1MV/C2CTPjhoejicODwS+CQIShCSISxCRITo8WviM5M/NbhPZEN4ODVNCeZCzGNqVDuDBjgkfssWYfTi2YYzir8czifMXT8+Kmdl1cr1lERr5jZ+rMSicqQiy0Q8tyMRFiDXu4SSSrQju0VMTAsUsS1ZCsSZcWOdmEevCJAP -k8pwQFVkcsHkrshyM4sXjlHZPLlpcYcDZcZ2iOMfET3Kpt8rQTljPCqIjHibcTppPlidwSbijDvUB39vgBJAPUB+aEYBOQOX1G9EaAH+MwAF2AgBFsJ49xAUSjxFszQQBoVUFKo38I2qFBzuAvlcUKfAYQHGh1Af508UmiCmqs+jRrBMiQEeF1W/JBCq6mf9vhsKi/ESoT8ONMTKCbMS9CcEADCUYSoACYShCtT87Zr0R4kTX9VUlkRrPn8B7VkC +UAD9vgBJAPUARaEYBOQO71s9EaBj+MwAZ2AgBlsIY86AcVCZqr0x9fndAAQv7tKniWh9uO/h4+KfAYQAtNjaneDWsbiioccnEFIs+C4ccpEU/L1iM/M0ivwVHCqiWYiMANwSmgLwS4CfUThCcEBRCeISoAJIScisj8i6nHjY/vBCanNe5gSjj9ZCD0StsUlBqxnDMzcdnj2QYdjowvnielC0AQbi0AhALOQjgNR4EkRfjxiQu8noc6t+SWLUhSSK -odiX5DbNDmtSZt7jv8WLDawg3i4XhECWgNTchANOQjgEJ5ykZ18ACXWj73ri8dWDqTfanqSDSQTMgWvcInEOaxPKO1N2jESSCGOhIySbwS+MJt1XgmpCagbSSVovSSI0QTjTMXISd8X3cvriniVsZMSuSU0ANCTySdCXySEAAKTFiftir8R2ZenoXirCaSBXnOPJK8XctxksAR5MIXNcMcsD6Pm4SosWLiLiagC6QoRMoofM1OEWlj3XtvD5cV68 +TkpkspJRBniTWIFRO5jsUQSaQxFYhCSCdvl0ZgsJCqkVDCXcecVJIQwTeHg1tBnvb8yUf7jNMajjZ8UKsuCbUSCSYISiSQgASSc0TV8bKstZiVjFseMiQjHsBfoaNdU8Te0BZHJh5MMU19sSEiRiTO8X2pfjJSZto0aht0x9s5DH8Yz9QsS/jFQTMD9bpFj5gXziYUlcSbiXcSHiYwNmAM8S2AK8T3iZ8SUWHQjkySCh9gbLjCJiwjCylQtcAMmF -ECVkxzgV0dnPOCTqgJCToSbCT4ScwBESWwBkSaiT0SZKEUiXWTYUUbiGHsJi8iaqCuFrgA2wjJj8kQ0sOlhS5sDmXEFIQcxEPBM8TEpMQDcM9tmtjqQcfFz1LBLRV7PoSlQVKSSSUtMC2UVy9V8e58jMS8MZCVvjQydmC2SUoSyQbRtjSHYNqgPQBPWv+sMIMHwjAJBgtEc4ARRDAAvwKmTliR2YlJvgjVUrBlvlDWNbBBIsp6pP0H8a4SJYQkCH +uMSgSD8gm8zIKDJACJl8wSDawCvDU8O5qDUp+Cw8k+PqQ/vFD1dBEiQL3tiAG5GcpwSQUhO2EPjp5tw9X4cUTauhPirScjifUZUTf4faS/FGINqgPQARWlesMIN7wjAJBhBEc4BaRDAAvwB6TBbp9N2Ub6TVwGQxdlFVVFNJjE8eOn0pvMsiuSVGTlUTGSJSTRCUMRIANUh3DDUmBTmmjctzAnyoiQAKok7msTdbqA8hTlFi+cSODfUpBS0moxjV -kUDiYsSEw3VDPDY0tKpCKbqZ00mrR9VKfBs0iaDFTmaDPiWQtviauDkif0MCKQM1gSSVDstm6C7vuF8WoSfhNLu04S3tkRcfD4CnIOTYsxI8A5ug9B0cB8pn8Bmo+glRhWMsvj2UQ+S+iWmCTMcyS1nOEdwycnjlsVf8VCZoBfyf+SDeE4FgKaBTdwOBS/wJBSlicMC6CZmTTpnGUA2E/jaxn7FWTH99VgtSN1SUussKRUiTSURizSSRjHZFzAmQ +TmcTzzCt9bPnlCT8GJds3HZAHkiFpMkqYEcrODDHgCl0dvv4Uxyc/gPVEJEqMMI0KbrQSnUTn1R8QXcPTojjDRtuTp8baSsSXPjNAIeTjyVrw5AueTLybuBryX+BbyS0TPSY/NkCYBj0fvPcHCj6w98Ypp1YliZj4JvZ5upyT00asjRic3CgKbmjJiRAA1ZFzA8QSakEAGdkLsork6pMHJush1Jw5Gq9VZKgBLKXABrKbZTscvdlZiZrInKQVIXK -fGkEAMjlUcr7kJpHnILsktIi5Ik8JAAFT0gHABgqaFSJcjjkbiS7IoqV1IYqTL80njLj0sfmlMsR/llcdt8ing7JUAIFTEqeGlkqeFS0qZdloqWxTF0RxSRMRAAjQL2RzgHIjdwFq9Z/sgcgSseRDyA9DAqAcxoSLpFh4Hlo2MD8Bt3hI9Wtv6cQfn6SeiZpDgEUGSBifvNa1rD93yU3tPyXnDD8T+TZNoZTAKSZSwKRBSoKYzidkWT01iT91ybH +V2CDkdrcucaz8qESkMPCQN9NQegALKekBPKdqlvKfZS/KT1lnKdhSAZjASWEUaB+yOcA2EbuA+Xht8wbJjB9hAAcCnGPBpwHgxoSDcldilYFaMLkFZRiVs74XJjB8exSM3s/DVyZTMQ4SUTYQfkCp8TaSGvENjsSSJTONmJTTyZJSryTeS7ybNidIYstXunPcaQZrpSzvRwkEaK8IMSn8E6s6CzvmmjtCf0CEMeKSq8Q9Civk2D9iZAsgsW2D4sY -AYUxFziMMbOsQhvwgskbxcR4cK07kQL8fKVUjiMSOC8sUrUvqVATcqU2SMsXRTK5p2Tq5tpR9cSIixzpuDiCRHlsifCjGqXOTdWNgBBACH5mAOkdSiVnctmBjAmUF5BEkB0iMpgos2EJiQflIcc54KMRs4DmtQCMUkFSXeTkwY8Nk4apTnrov0XJnyjhiWGScwZEdIybpTJifpSdqQBTjKdMFTKeZTLKdBSp8oDBVNvw9LWO6EndtIVrsXfZTmKr +sTCEXh8OcUz90yeFiUKVRioqTRjfUiQiTiVgD2SlqxQooIBjfMwAgjhESZqicwMYCkFgSMkgCkWCAXKEsJhGqyg9lMpd6WO3pCCSncZyeDQLUEP8OKfQTT0WICVJqiS6Zn7j+Kf1SBYu0ihqaJSTyRJSyglJSZKXJT7ycRZAYMTiKHmawVQnZ1XJiyTTznMdr2mfi9qXoTNpjtFTBhAAdZIKYVZOVIKso1kCpAyYypKNkmTEVITsnVl6pENl9ZI1 -Y2SsPC93s9STibQicKR4Sj1CEx3ZNqZ7ZINJVsntkupFKYBpE9kZTD1JEcttlJpPdkvZNNJAAPIgm0h1p4pkdkjsjdUiuUlxEgC1ps0h1petINpkpiNpU0hGkptLGk5tMtpHUhtpdtN2yN2RuJztNvKHCMlKrxLyppcwKpe8KKpB8Ip67tM9p+tMNpbORNpZtPdkFtLWyVtNtp40ntpEdKdp0qhdp86JxWcd1BJboIxR/NA1xRoFqAs7zRpXMV9x +JAAPIg/UgFptJjVkasg1SJOTvxfNOakAtKFpItPpMYtIakVUklpNUmlpstLykCtKVpDWX6ysxPVpAGOupgsNCpYWIlUD1O2JC6xnh2CzoRWtJ1pwtNFpkOQlpUtJ1kMtMqyctMVptUmVp1tLVpNKg1pSWKgJKWNwpnEkBRItGFxRoFqADb3+prEV2UAiwZhIo28gL9ScKJdhIg0VDBIR3DXRRN3pYAkx0kQBGVKnCUoJW1XmIz3m4wFkCPRnFNNJ -Y8CAidmmrGYJFzy4JG6swVDBIV3H9Rsz1zEkFlowBKEz4wF0uOH7UWI8PhSQFkFqBHdxjxMq0ZpcqyGJq1M0pbNP7uHNOsxxARFJTgONIj13gpo638oKINdWtYy8gEvmBqgRDgmJZLohxxLHh85QQIspPBhRjjjgHyHKpwVJBir9OIA79PDSdlQ+AtdhvcbHGpYaFk3h/1PypgNJV+FwLh2JVN1YNxB/pBXm1+cKONxYBSapHGxQgVgSLA9UxGif +AFBzePuLzenS2tJFRMEpe5MdCJ9QLhfihEBT5JjR4VBTulgMU0XkHCks1VxM+gk4OSHyxOXaw5p95VIE5JjjJBhIpoccG+QHlOsphqS3pxAB3p2qRuWR+XfIK7nxEmX2yMaZM8hFCP7BgT0HB0WOHBsWJip2rD/oh9ISsAv1+2cdMyp5xPQAJGxQgYgSLA1DS9We3w4Ikb3qc6mU2sFcn2YyzT22tgT24AIXDMwanjitdL6CkXkAIjdKZBrVMDhx -4mJAoJihS1RX7gCgJwYq+0habQURAvbjO4qwQLMRagpp0cKnpZXjb+WtCX2/pJTByZWfJ/cWXp6lIZSrJPWp4xK/Jb4RwaYNxjQ1JTsgY1kopcpLSmTzkeAyINMSmFJepfXU8BJdF4C71L8pI4Mn+IQEPAoRNeglQxiKwpxBi6jOsQWjPnAOjPi2f9NuEAOGoCQDNACmDzVhcRKSh9FOyxTFJ2+BjM0ZEaBMZejKKhldIu+wPnuAusNtAZHETucM +6IhBrdKUmBfXQOFpPDBSOJaRKOIGpaOPCCFJI0BmgDjQz81IpEUCEiPMjWpvRI2cMRLWU5430pO1IzR0ZP6qWh2rYOAUOpjYMw+NfxCAh4BsJr0HdmhhTpOhqREZtiHEZ84EkZw32PpuBi0OlIHPp/vkQpuryVBFGLcJU8J2JnhLixsjLEZ1dEUZ0jLepcUMHRnEnuAssNtAxHHdu7/WyQeSFKsvDSm0mDIO+5GFCgwUAng/vTCghFWvhRU198iM -MOAIUFXgNiUtGbp3hSoUGOYAeHqsFgnEe/UxFilMnTyOrjsOW6QtYrXksgtkhiCaFjB+vRIWp/RLVinDI8RLJK2hu+OphVmImJ3HlMJeH33pBizzRd+InUp5EBIqVyfqipNO82HmoZPgJvpVCM8p8jMh65DgkQz9I4aEAEAAuCCAAVBBUACMzAAAggqAEAAOCBjMwACEIIAAiEDGZIMXGZkzJmZ8zOWZqzL82KPlSivwn+KFIEgBrGNiJHxPsZQN +ky0Qrm2Alj0wSWMyvBHHlk0LjWbp6NJ4ebdIIZ2NLhBfVJ7p5DLtJ/dJsa11znoxON2sdhX8ukRkUM61JCU5DBFchgPrhOeMbhRlNfGUUmNo+hO2mT6EAAuCCAAVBBUAA0zAAAggqAEAAOCBNMwACEIIAAiECaZhqWaZrTI6Z3TP6ZgzLs2WtDnoQBCVEwLUvpjtLupztPfxkVP0Z0VK8cwzPaZXTN6ZAzPSphwN1hRoN3AV4CaAPwE5m9f3bJiV -KIBINIKhT6HWZ0zLmZizJWZ9VLIJs5Pisu4CvATQB+Assxn+30IDBg4C+Mmih6meWmruueTxQCSWc6bWK7pjXl6hr3xQsNDOFu0vVxAOrgvsILV5akKg0hhMPyZ9NI4ZMiS4ZmLV7uG9IjJOlO3pAjIKaZhM0ApID1u7Rlcg0tOfxo+mxCZaPYot/jOAe1W6Z9J1uRKtOYauzE0UQzOeRLUFwAjACMZnAFOoH9KVqFNAFZEaGFZv9N1MQJTCgt7W +nYUxFSLS7kCJQHHTFCIfFOAFIBrkFGEkxN50pASSA1qRTT+BpmRuBQrl0pLHSkQSb2XJNWw6p5PXbpvUN9xn4MzW34MJppwSoZ0hJoZ9c2Up8hIIuOxVcgTNP3x3FFpSpgIsh1kH9QXeyGJA70qZPDKrq+zGwJXNJMGETS9AuAEYA8jM4AN1F3pU8TpotLOroDLKPppOQ2KvjL1oudK0Of62fx19NfxGxJdpejLdpuxLAJzLIQAdLN5KbAEZZ/hP -rGngMQ2MRMgGQox7RXGOTpPGJ2+YrIQAgrPtKbABFZWRIXRzzLhp8Vh6AiECaAeHC6AJoGpBxADFYCzCaA9AD6AJwGcA0dMaxmJK6hwLwSAVkD6iPvRJAvN0wKRaBXSuKRMS6eRsR3MKyQvrK4gNXTWQI/VDY1XmZK8pBBB/xSfxuTPmpr6KxZBgKKZsfx7uH1y0pe+K3plTJ3p0lRoue9k4gR2NXMiSKPcuqlXEU6npZb+P5qgOB8gLPzVJNyLv +7RgRIbqPQEQgTQGw4XQBNA6IOIAwrGWYTQHoAfQBOAzgAAxSO2+JqMXRUybhopOulBJZj37gpaHLSS8ERAHc0y0yiM0Mj61iJSpF+AHFBGGcXjUZipA7Yuun+hwLJdOthwp64gIhZndJfeeNNSZBNMGpcLLyqyP04g1JLWhtJIWiRgUu4NamxZcyPgCoYR8gba0JZyH3se+STJWjiDG6dTIjSPQB2guAEsalZOOx8XQIYbvlvIcKK+8/hX7g1wlK -pl8W5Wuqg4gYBFNJzH3NJPmjgwPQB2guAFyaY5PoJXUWwYeDmvIZKL6iBDJUU1cVam9FCIYpzGuAIvWhqfclpUIBGckE9LTS5An84PSLt0NuHnpj5LYZEZwX6OLOKZGlPxZH5L4Zm1KW8LcJLZQ61vxByNdiI8FJS3NTYuvgNbOklKGIlCLZZGpLyRUwhDUXQBaAu4AY29pRCAUSVtAlcKkuWTlgEVhHgEr/D2KBcDM6V4ElSHAGeA+ADKiC4H8Z +cjDSZQ2DHOYAkPKoK1SEWMOAbGNdM9ZNqS84JSLgI2wEKZcJN0+D3wxpCTJDZJKMtJJDIxJJiKEpESVjZ1DNLqtNPwK/qAZBF6WZp6GmrSWX1zZi9PFR0YQLgJqi6ALQF3AOG15KIQBOAygFtAqcLYu4Tn/4UqTBQF/EKCBcEo6V4GxSHAGeA+AFCiC4FsZMcDLZ9nmeAW7GfZkwlfZFiEv4DgLyuwpP9c1QCI6iEDomYrX5o/rhnYGEFkg4HJr0 -McAHZ0XmeAe7Fg5nqVBc23iuqYSX1J2bmqA+nUQgMk29aXNGzcC7AwgskEI503GI5W2H+xycWDYkLSiZPLN6aHvijSyaSEaED22B/HI9UlvRnBSWCfhhNllZVLB4gNjJ4RZzI1hXxMcZNc2ERNaQE5lvUQZ05KrpKDPhpgHOA5oHK5g9g2UAkHLgA0HKGAeyLWwQ6QaW2DEeURNN0k4lPli/cDXAtOhIqpWk2o/gIDRiDFtW2d1UyTNh30zcXGpS +jzluxPxUzC/rFfKnjLqZ2yMDSFqRJq51NI56qnxK9tO7mOgmZQGDGV094yvpZGO0ZmxPFhfXyep72z2JKtz1SZHPxKH9JVOGVP2ZjZKMA57MvZc2C5g4gzvZD7NIAT7J2MqaVFCBDCWUMNPxABOjdBzHBKekoncqCWh0oGQSkxaDGi8ayGYBWh0RAY+nMYCkl/cXpgeSRS1iZU7PiZ+DNnZ3VLDhW5NIZO5N7pfqPLiVewRZvxwTZiIiTZISndZz -yHJkDN06xjiIcumLOkJ2LKX6uLPcmpTNzZ5TLJxUZKqZu9Nwh+9O+ZVf1LGEGVr+P4gpQHHEUIa2iQyXGEXCfrNZZOSNbZHHODZITzgUKjJ7ZLmmIyUY1IyT4GYMvazAA8RG6itwU/ee6M8B5DIyQAXJQ8s8x0ygEWEMu2GAeYhm4yEhmLEnXAEychiLxDRH9EAKH7Zg7OHZ0mRjEKmHqJG5PUxKYjugY8GmIGmStwiyFtIeKE7ZR8URYaxCLEUh +igeCDawnpOLL6JXGHrCZjwjJwxOJZAFOno7wLx60bz7WR1O48aBjfSBXGFEu9GK4T4DFCFxjx6gd0kR8wWsI5nPg+wJCs5tGRtwkGX2wn92oMOolgyUYi4yLXE4yS2N2I1WAPQcGDLZIQErZOGWdExOD98/wydYfDn98Y8EmIlGVkIyyAzcNuDG6PCjcZEYmYyjyFjEHGSqIXXANE7BgzEzBkAY63L4MJWJEyaSyNB5wFIAXQFhA+TxAJ5zLIw/D -i0oZYgVAgmSm51Ykm4cqXUMDYhY5IKDm4LmUMOboPOApAC6AsIB6eeBJXJloSUZrcF6hpiU3At5IK0LOj1URYSSU1AkCeIvUamCPhQ8JDTL4MbM6Yg8HyQDwnh83cFVJKbIxZabMi5GbLPZWbM8RcyNzB++PghmiX4OopPJZZ21ZxOrw5+D5xGIyU1fx6UWjArjFEZfMNK5RxN6ZHLLzQwbB+MvqB45cQ3WSJFNdp2wIwgIvPrJ74K+MVw1dCUhT +NYaVYxrscMw46ziFLs/oV4mAwVhpoZFbgGSF/cHIg+YIw0HghSEOEIHm7gHJKwZimJwZL8JkawbKxpHdI/BXdIjZg0N3JHnPZ6tQIUpQ9KW2cCPnu4Rhk2QxHBqh+LC500DcYpFJS+0XKJZS9KqZA2l2K5DxAk1eO5pVLKw+4FKniy7Bp5AsJhk+TiWE6SH1wWEM5xTtPCpd9NlMD9NX26FO+m9PJjpn9Jwp39PPMn7O/Zv7P/ZgHOA5OhTA58nK -X4cnPYxtFPOZkDOBpBzScZMDPXYEvKnJMNOQZCbx1YyHNQ56HMw52HNw5WpQI5Wkis5U4RzWT8I3GhDA3ASdSMaQPI4grnPJk90V/B55EfI1LJGckhQUqO+huCnTgngzbmtYrTOppTiLx57DIJ50XPPZ3DLi5BLO0pFTP4ZFPKch5vXuAluwy5Fqyy551PBI4eIpOzPIQmP1AowLp3cpLbO5599LHYsIOnq9M3KWdXJiIJGUYMTXPIyy9FqwnvPy +EyqMWrGB8KbGZDA3ApgWsqrDVGubhXhkgiy7Zc8BfI6LIqs+50IqZnNGCZTgng6bjOw47LyJCmIKJwPNBZnuPBZc7OIZfFNc5AlLSZy7IyZpa285SuyfJJVS3SXKMTx4JFaer1yx5GbKXcFGENONOL/JsXPw5DrJseAjLVRlLL5EURHS5JXEK4WXNFE9WH15TiEN5boOYZUwHB6ZvJRmOwm7gVXIEg2ohvocGX1EiYkQyy3I9CqGQaIwKA655bO6 -S3vJK6N1Nqw99nK2lLwfO6tG7gw3IEgXGTPovGTdEQ3Gm5Xohuhc3NEyFqQHZIQGW5fRFkyyYGcAmKGyQuB0nK6mKlB6mVmIxzFPRR3IeUbhkAkZ3OMybiCu5NyBm5/GTu59mRsyHVEe593Oe5s3CAY73KapFIHoAqEHHQbcObpTK2VkrcDHU0UGoC7kAoGDJXDhrU3bipSmaJIvT0UoJkMUkKW40s0MBoOB3YwPxTcYvvXtwOPI5RKlPx5D8EMB +5PRDwyyYGcAOKFyQeh2FepAg4OWCDG5z5Am5nnAhJGhgQIjGUjE9Bn0oi3NuQrBgQya3IEyG3J4ygmTAYwmXG4omVhuP9IgAFIHoAqEHHQRcPTpB+U5krcArU0UEgCNzNthd3JzKGBJyCF2DSJJMSikLwC8gziG2SBGkWOuPzMg7GGWK7jAV6e5FRpbVMKJ9SLB5nKyc5pKIXZ0LMxJfdP6iXnIjRQ9MtByLK3x5eEBCIYhWpO1gXc2PKxZpPNWU -8eIzhrNKvZu0NFR1QWwRItL9BPmNOmFIVzEg8NrGL4TFBoLX55X+M55T1PgBzjC6cG42q5jyID6vHM4aWvOoxQ1x4FMdKbOBohbsspIk8iYgV5sBKV5inIcZ6rN+JggX4FmnJ15M5ONZzvAoA5HP/YVHJo5QwDo5CAAY5THIt52hiLipwGK84sQuABuC3iDvI/OuBSmS+uEcQHyjfwXvxGccPh4gGBSF0RkhXScTIIY/dLRZBMPQFEXIj5WAszZz +7NOJ55TibGL8kEZeCOOp4+wF52GNVcpApTJe7AMyOyR0pL9XCgQJE0ZIsOQpyzPxGnHL55JAQoFtZJm+2sKF+wnK35FADg5P7EQ5yHKGAqHIQA6HMw5cvNX5qMUeZf3lWULDQWRZTObZe3BvymSUD64tl15zJFKhYmGhcJ4V4aZnLQYC/EIqpDGLpVygDBdBLs5r8OAFhDKLuBiJc5i7JvRpx085C0JZR9wEKhPpL95jkx0p0cWC5mLO5U71woqh -NLXpl7N4ZBAtb21TKp59wHahPmMy5w9VMSLcS5qV0xBe1dEzSvqB/ZZXNL5bbMq5wPUF5z6Fr5DXPr54SEb5DBlqwnTgcFZEOGIzZ2KAbgt34ClU8FM3XOAA/NEMrXAm5F3KrEnogrEk/JEyWQAPQi3Ln5kGDHJjjkX5sYk/OzkjLieWg3gXCC351lGBKJ7gAkmeSR5hmXO5fGQuQZmWu55/PaFI3Cv5D3Lsyv9BsyjmV6euhje5/EO/WDgWy8GJ +jC3ZOApJZbIjj595WI5L6RT57KXfSkSCwM8SC0QZTj1+FVie8PEHPyxQGkk5aTo5JgqS65wDL50GRoM9XKn5q3Mfoc/JQybXKb5nXIrZkGErJlRnb5LojkuzchcQkWg3gXCAH50xB7K+pDuCGRA4whWz/gk/PgylyDYycYjr5bBmTEi/IG4/GVOInBk2w0gta5ghir+QMxkC/niBO/rwcZ81DW4cJFZpIZn7JmmUOsvYDRetAltx/GHrGuJkroCn -xzecMPGoe3DhIpxxsa25MRZAsV7AtIgHALnA+UiDHzQWIWMkvMVfOtl1iWHN00Um4VSQX+LQFylL8FJ7KXphPKCFWYPXp+ArJ5sCNvZxbIE8Um1U23ylBMmTNJG5Iyu4uqgVpP+LLJXlNhBE8GOuSoJieDCPKAX9ME59IQpFYnLdujMyF8IVEuEbO0T6XCPjpM5ykFFzOQJX+XV5UbmpFTzJyJ5BOd4LQH8QMABcGhAHJ2r2K5iC4QCotiShSxVS +1p4QqjVK0mB10oTKn49iD/55grRplgtB5jvNAF87Jd5DgvYJTgvh5UEPDqbG2JxuyhuM/rNmisyKTKZjFLQGhAB52EIbhRPNCFAEneBE8CiOyXKEZ1+P3p5HM266Iuo5mJSxmVnRioOIHHMqzSmBID1cJ2ZNdpxt3dp4pzoRWIt2ZA6I+pL6haAgSBgAzAHqAhAER24SLBsdYQioQiR2SjlSeBTwCiiWyABgdYgxmFeQhseIqGI7CF3RVMBD41/I -nxOB1eAkjm1Rb8ITaqDld+A/UOq4ZVH6jykXKR5HtIc8ldWoIvGxR7OoOgQpwF/KLWp8yI2pB+MRFQjIJOhDSI+BLn+UEh0gMt/TFBSHmvJqpMYFStOYF5fIMknBPYFuFM8JYDBE5aqh94AAD5NeQM1nAOGLo5q3MlaqjBa0vKoYxVGLJmjGK4xZnM/6ZeQaov1FQCHLzxBe8TJBaj1Cqar9iqVG5ExepyUxeLzoxbGKW5pmLPGfQ9tOXryfNH0A +WRDzF10Qqn/52DJbp07Ic54PNDZkPPDZrvPxpxcVhZK7IHpWTKhOEZVHpULlrYTB0iMNnLbiqWBE2GLIJ5ebJJ+BbJxg58LXpwFPjJUeFRgQaQZUzgAAAfHTzmmr6Lg5l7NDUp6K+Ob6L/RWk1AxfnNgxaTlqnmlgtDsMQ/3FFpmOS4SdGWSKRWRSKxWXFjQxVRzwxRhAO4VGLmQAXM5ALSKFWUDM+gHwMdcT0BIMDBdD+eWE6wsjNG9B2xGBKvc -zBo7iegJBgWcf9zJRe+Zx9LKyDuKv53foDQ6iXAQocTRg2WMHjpoJRoOiVSS/habhqBhS52MF3JKxt4LAEWfpj2er1IRVHyieSUyvESTixiWEK1phEK96eSy6LvUyn2ZnllCk2zqBZYl5Cq1MdZBrQ5GTzy/CPYh9cOiRchQHoKxaJyYxdSKYxbEJhmuXSEsSGKk0t+Lwxb+Lwxf+LLyoBKlYdExxnqlhPAaMRUPPlpQGR2jmyQpzixUnTSxSnTk +A1m9cj6E+saMEyxjhT40CllJNcXllhABr8A1KfnJHoKXSNLte9nhSej7OfTFEmRDymkbjSdRZGy9RdGyDRZky42dhcEBeTDBXuQVZpopoSGONp9SFNF1sfPScIToSEMZ6oDcBdxIhVTycxeyoXeD6KsRb6KQhPE1o6WQLWsLxzcxY+K/6EwBnxbUJXxXbScRYVELuHCpKQJbDkxQsyBWRmTSRVsSMxRACbeh7TuOXeLvRd+LvkL+KfRS+KWym+KJ -hF+KwxT+KbiEwA/xakIAJdHSFBYaz+RS8zneHakl2L3QugKdSfmYmYFwqSgWMovpQWa04R0qNDoSHGV1MQ41b6g9FnhRNQrFICpY+LqKzETvFd+IeyMBf4LT2duLoRdmyeGVaLr2TaLd+rWCRaRDczqUfSocO/ISqiR1XDDpsB7BzzDiUwKsMj6l7EOQ5LWB+LI8LhLkxeGKZ4TGKQYtZLCJbZKaxVmLRouiR6VI4g9cAWK0JUWKIViWKoGWr9+h +wcljheXwLzzPyk52MPQugHNTlDo3NNoe6pkkF3pDAsw1VuKQVoSA4VSBMQT9wQU5uIFKKfmUso5RaiY3RAvxbOdOKrBW8KNycwT7BRAKl2VALnBdAjqabdd5qT6FYcBfDqYWC0NDFJtHcfjzD2WKjKzvCKltJ6oopGawbxei0PxeakvxQWKfRSGLPxfeLfRcZLj6cBKExaARwJYwKb6UKyWBRz9yPuwKKaMhL0JZZLzGTrDpwW4RwAEtAQUHAA4A -o5KIxXZLwxXyLYabuDwAEtBAUHAA4ACaBrEI7FoAHFAMgIKNJMDcAGAHzAgUumyAhYtZIukoERAD/B9OukATQL4LT0tewCpT0hDwPoAMINlKZJUzTqhBVKehVVL40pmDVgOVLfCU1LipUK92pYVKqpSVKymWIwepZVL0gCKxFbkNLOpfoBK4T9dxpU0RmpSyLbLDNKipfoBEIO8j0pekSJpY+gAaWtLGpbNKupZfy9hWdFFpVVKZsPWI7+esInMv +CaBbEF2ZoAHFAMgKJVJMDcAGAHzAVkngzZxT1ZIipkIfCX0hDwKLUpxQaVUaClKGiGlKMIPFLrBasAspSYScpekATUsjDCpVYTUpekATQMnsipT/AiOtVLyifSQ6pVVLEwasMWpSVL9AKnDxnh1LAhmlLEIJBKz4L1KGpfoABpezisSsNK0pY+h7qRVLspX1LGpQvzphbxkbsJNL0gHNhNuRMKRuNILVpfoAgGN8iLCCVBCpcwAa/jyB8AIEYkoN -lKOpbtL9AD/QkUVYQSoG1LmAJP8eQPgBcjElAHKE+QA8J8pjFGfAWoM9LDQHk0MEDgcNNuVJhnMFiSgB94DAIRCGAAQBk4PJkaZqSA98EdKRpY+zL1kdA2pbKASAL9MEpFjLDwLMRfpZjLiAItg2ADtAZsLgAhyDTxh+CQBqcEpAMIDyAxMr8dcAAAAKSQrUAXgCV0dmWB4BkBmQAACUuoDjgygHzAWoDmAjMpZlME14A4sqNS3MtqAfMqRl60vF +xAkgKPAjBWuAjuNFLjpayBDQFY1H9CxgW1Km5a1puRopdt4DAKO4GAAQBk4ARkE0E8yg7DtLBWHIS5gLDBCpbKASAE/i82DDLDwNMQhpdDLiAMtg2ADtA5sLgARyKyxLUCQAycEpAMIDyB0MoGdcAAAAKfc7UAToGXYSmUUypZC1AAACUuoDjgygHzAWoDmAxMrJl5414AnMuc4NMrMgDMueIvUpqlroFTh7ZWpBlijjgxYHDgz9CUgmQExlwQBU -g/KErhN5SJO5JjjgxYHDgt9CUgmQHJlwQBUgHyUbKhAFmIHyQJoKUuyJwgAM6tsDLkSMrsAfZFWYg5IJoJThJlyGgJoFMu5EgKAWAhAEYAp1B5A0MrWwYQGCAHsrma+UuZABgDul9IF7xMllG5dMA9lXspoeQnlCI8kHAACkBRUTmzoQ5iBbAQAA +gN8V9KhAGmIN8TJoEUv1BvykZgm+GjkAsrsAA5DisJZLJoiTjRlH6jJoWMt00IKAWAhAEYAN1B5Av0o2wYQGCAVsuyayUuZABgH2l9IHXpMcnKQdMCtlNstQe1HiCI8kHAACkE0UxmzoQliBbAQAA=== ``` %% \ No newline at end of file diff --git a/ServerLMS/ServerLMS/CMakeLists.txt b/ServerLMS/ServerLMS/CMakeLists.txt index 94990ea..7a79015 100644 --- a/ServerLMS/ServerLMS/CMakeLists.txt +++ b/ServerLMS/ServerLMS/CMakeLists.txt @@ -57,6 +57,8 @@ add_library(ServerLMS SHARED Systems/Parsers/clientanswerparser.h Systems/Parsers/dbanswerparser.cpp Systems/Parsers/dbanswerparser.h + Systems/Parsers/processparser.cpp + Systems/Parsers/processparser.h Systems/processingsystem.cpp Systems/processingsystem.h Systems/sendsystem.cpp diff --git a/ServerLMS/ServerLMS/Data/Client.h b/ServerLMS/ServerLMS/Data/Client.h index 32246cb..1dfebb1 100644 --- a/ServerLMS/ServerLMS/Data/Client.h +++ b/ServerLMS/ServerLMS/Data/Client.h @@ -30,6 +30,7 @@ public: void setLogin(QString login) { this->login = login; + isLoggedIn = true; fullName = "Name: " + name + " IP: " + address + " port : " + port + " login: " + login; } QString getLogin() diff --git a/ServerLMS/ServerLMS/Systems/Parsers/dataparser.cpp b/ServerLMS/ServerLMS/Systems/Parsers/dataparser.cpp index 3a66a04..e8dbbfb 100644 --- a/ServerLMS/ServerLMS/Systems/Parsers/dataparser.cpp +++ b/ServerLMS/ServerLMS/Systems/Parsers/dataparser.cpp @@ -11,9 +11,13 @@ QObject(parent) clientAnswer = new ClientAnswerParser; clientAnswer->initialize(this); + dbAnswer = new DBAnswerParser; dbAnswer->initialize(this); + processParser = new ProcessParser; + processParser->initialize(processingSystem); + mutex = new QMutex; if (!QDir(staticDataFolderName).exists()){ @@ -22,223 +26,7 @@ QObject(parent) qDebug() << "ParserThread: " << QThread::currentThreadId(); } -void DataParser::xmlParser(ClientHandler *client, QByteArray array) -{ - QXmlStreamReader xmlReader(array); - xmlReader.readNext(); // Переходим к первому элементу в файле - - //Крутимся в цикле до тех пор, пока не достигнем конца документа - while(!xmlReader.atEnd()) - { - //Проверяем, является ли элемент началом тега - if(xmlReader.isStartElement()) - { - //Анализируем теги - if(xmlReader.name() == "ClientAutorization") - {//Запрос авторизации от клиента - - ClientAutorization clientAutorization; - - /*Перебираем все атрибуты тега*/ - foreach(const QXmlStreamAttribute &attr, xmlReader.attributes()) - { - QString name = attr.name().toString(); - QString value = attr.value().toString(); - //addTextToLogger(name + ": " + value); - - if(name == "Login") - clientAutorization.Login = value; - else if(name == "Password") - clientAutorization.Password = value; - else if(name == "NumberOfScreen") - clientAutorization.NumberOfScreen = value.toInt(); - else if(name == "TypeClient") - clientAutorization.TypeClient = (TypeClientAutorization)value.toInt(); - } - - processingSystem->processingClientAutorization(client, clientAutorization); - } - else if(xmlReader.name() == "ClientDeAutorization") - {//Запрос ДеАвторизации от клиента - - ClientDeAutorization clientDeAutorization; - - /*Перебираем все атрибуты тега*/ - foreach(const QXmlStreamAttribute &attr, xmlReader.attributes()) - { - QString name = attr.name().toString(); - QString value = attr.value().toString(); - //addTextToLogger(name + ": " + value); - - if(name == "Login") - clientDeAutorization.Login = value; - } - - processingSystem->processingClientDeAutorization(client, clientDeAutorization); - } - else if(xmlReader.name() == "ToClientMessage") - {//Отправка сообщения Клиенту - - ToClientMessage toClientMessage; - - /*Перебираем все атрибуты тега*/ - foreach(const QXmlStreamAttribute &attr, xmlReader.attributes()) - { - QString name = attr.name().toString(); - QString value = attr.value().toString(); - //addTextToLogger(name + ": " + value); - - if(name == "id") - toClientMessage.id = value.toInt(); - else if(name == "Text") - toClientMessage.Text = value; - else if(name == "Login") - toClientMessage.Login = value; - } - - processingSystem->processingToClientMessage(client, toClientMessage); - } - else if(xmlReader.name() == "QueryToDB") - {//Запрос к базе данных от клиента - - ClientQueryToDB queryToDB; - int id = 0; - Instructor instructor; - Trainee trainee; - Group group; - void* data = nullptr; - - /*Перебираем все атрибуты тега*/ - foreach(const QXmlStreamAttribute &attr, xmlReader.attributes()) - { - QString name = attr.name().toString(); - QString value = attr.value().toString(); - //addTextToLogger(name + ": " + value); - - if(name == "TypeQuery") - queryToDB.typeQuery = (TypeQueryToDB)value.toInt(); - else if(name == "id") - id = value.toInt(); - else - { - switch (queryToDB.typeQuery) - { - case TypeQueryToDB::TYPE_QUERY_NEW_INSTRUCTOR: - case TypeQueryToDB::TYPE_QUERY_EDIT_INSTRUCTOR: - if(name == "instructor_id") - instructor.setID(value.toInt()); - else if(name == "name") - instructor.setName(value); - else if(name == "login") - instructor.setLogin(value); - else if(name == "password") - instructor.setPassword(value); - else if(name == "is_admin") - instructor.setIsAdmin(value.toInt()); - else if(name == "archived") - instructor.setArchived(value.toInt()); - else if(name == "logged_in") - instructor.setLoggedIn(value.toInt()); - break; - case TypeQueryToDB::TYPE_QUERY_NEW_TRAINEE: - case TypeQueryToDB::TYPE_QUERY_EDIT_TRAINEE: - if(name == "trainee_id") - trainee.setID(value.toInt()); - else if(name == "name") - trainee.setName(value); - else if(name == "login") - trainee.setLogin(value); - else if(name == "password") - trainee.setPassword(value); - else if(name == "archived") - trainee.setArchived(value.toInt()); - else if(name == "logged_in") - trainee.setLoggedIn(value.toInt()); - else if(name == "group_trainee") - { - Group group(value.toInt(), ""); - trainee.setGroup(group); - } - else if(name == "computer_trainee") - { - Computer computer(value.toInt(), "", "", Classroom()); - trainee.setComputer(computer); - } - break; - case TypeQueryToDB::TYPE_QUERY_NEW_GROUP: - case TypeQueryToDB::TYPE_QUERY_EDIT_GROUP: - if(name == "group_id") - group.setID(value.toInt()); - else if(name == "name") - group.setName(value); - break; - }; - } - } - - switch (queryToDB.typeQuery) - { - case TypeQueryToDB::TYPE_QUERY_NEW_INSTRUCTOR: - case TypeQueryToDB::TYPE_QUERY_EDIT_INSTRUCTOR: - data = &instructor; - break; - case TypeQueryToDB::TYPE_QUERY_NEW_TRAINEE: - case TypeQueryToDB::TYPE_QUERY_EDIT_TRAINEE: - data = &trainee; - break; - case TypeQueryToDB::TYPE_QUERY_NEW_GROUP: - case TypeQueryToDB::TYPE_QUERY_EDIT_GROUP: - data = &group; - break; - }; - - processingSystem->processingClientQueryToDB(client, queryToDB, id, data); - } - else if(xmlReader.name() == "ClientMessage") - {//Сообщение от клиента - - ClientMessage clientMessage; - - /*Перебираем все атрибуты тега*/ - foreach(const QXmlStreamAttribute &attr, xmlReader.attributes()) - { - QString name = attr.name().toString(); - QString value = attr.value().toString(); - //addTextToLogger(name + ": " + value); - - if(name == "Text") - clientMessage.Text = value; - } - - processingSystem->processingFromClientMessage(client, clientMessage); - } - else if(xmlReader.name() == "ClientNotify") - {//Уведомление от клиента - - ClientNotify clientNotify; - - /*Перебираем все атрибуты тега*/ - foreach(const QXmlStreamAttribute &attr, xmlReader.attributes()) - { - QString name = attr.name().toString(); - QString value = attr.value().toString(); - - if(name == "Code") - clientNotify.Code = value; - } - - processingSystem->processingClientNotify(client, clientNotify); - } - else - { - emit sigLogMessage("XmlParser: unrecognized tag"); - } - - } - xmlReader.readNext(); // Переходим к следующему элементу файла - }//while(!xmlReader.atEnd()) -} QByteArray DataParser::xmlAnswer(QList listTag, QString elemUp1, QString elemUp2) { @@ -334,8 +122,6 @@ bool DataParser::saveDOMtoXML(QString nameFile, QDomDocument *commonDOM) return true; } - - QByteArray DataParser::readTempFile() { QByteArray array; @@ -354,11 +140,6 @@ QByteArray DataParser::readTempFile() return array; } -DataParser::~DataParser() -{ - -} - ClientAnswerParser *DataParser::ClientAnswer() const { return clientAnswer; @@ -368,3 +149,15 @@ DBAnswerParser *DataParser::DbAnswer() const { return dbAnswer; } + +ProcessParser *DataParser::getProcessParser() const +{ + return processParser; +} + +DataParser::~DataParser() +{ + +} + + diff --git a/ServerLMS/ServerLMS/Systems/Parsers/dataparser.h b/ServerLMS/ServerLMS/Systems/Parsers/dataparser.h index ed5da78..f933dd8 100644 --- a/ServerLMS/ServerLMS/Systems/Parsers/dataparser.h +++ b/ServerLMS/ServerLMS/Systems/Parsers/dataparser.h @@ -7,6 +7,7 @@ #include "Systems/logger.h" #include "Systems/Parsers/clientanswerparser.h" #include "dbanswerparser.h" +#include "processparser.h" #include "serverlmswidget.h" #include @@ -22,6 +23,7 @@ class ClientHandler; class AssetsManager; class ClientAnswerParser; class DBAnswerParser; +class ProcessParser; class DataParser : public QObject { @@ -40,6 +42,7 @@ public: ClientAnswerParser *ClientAnswer() const; DBAnswerParser *DbAnswer() const; + ProcessParser *getProcessParser() const; signals: void sigLogMessage(QString log); @@ -52,6 +55,7 @@ private: AssetsManager *assetsManager; ClientAnswerParser *clientAnswer; DBAnswerParser *dbAnswer; + ProcessParser *processParser; QByteArray readTempFile(); }; diff --git a/ServerLMS/ServerLMS/Systems/Parsers/processparser.cpp b/ServerLMS/ServerLMS/Systems/Parsers/processparser.cpp new file mode 100644 index 0000000..7a94451 --- /dev/null +++ b/ServerLMS/ServerLMS/Systems/Parsers/processparser.cpp @@ -0,0 +1,261 @@ +#include "processparser.h" + +ProcessParser::ProcessParser(QObject *parent) : QObject(parent) +{ + +} + +void ProcessParser::initialize(ProcessingSystem *processingSystem) +{ + this->processingSystem = processingSystem; +} + +void ProcessParser::read(ClientHandler *client, QByteArray array) +{ + QXmlStreamReader xmlReader(array); + + xmlReader.readNext(); // Переходим к первому элементу в файле + + //Крутимся в цикле до тех пор, пока не достигнем конца документа + while(!xmlReader.atEnd()) + { + //Проверяем, является ли элемент началом тега + if(xmlReader.isStartElement()) + { + //Анализируем теги + if(xmlReader.name() == "ClientAutorization") + {//Запрос авторизации от клиента + + clientAuth(xmlReader,client); + } + else if(xmlReader.name() == "ClientDeAutorization") + {//Запрос ДеАвторизации от клиента + + clientDeAuth(xmlReader,client); + } + else if(xmlReader.name() == "ToClientMessage") + {//Отправка сообщения Клиенту + + toClientMessage(xmlReader,client); + } + else if(xmlReader.name() == "QueryToDB") + {//Запрос к базе данных от клиента + + queryToDb(xmlReader,client); + } + else if(xmlReader.name() == "ClientMessage") + {//Сообщение от клиента + + clientMessage(xmlReader,client); + } + else if(xmlReader.name() == "ClientNotify") + {//Уведомление от клиента + + clientNotify(xmlReader,client); + } + else + { + emit sigLogMessage("XmlParser: unrecognized tag"); + } + + } + xmlReader.readNext(); // Переходим к следующему элементу файла + }//while(!xmlReader.atEnd()) +} + +void ProcessParser::clientAuth(QXmlStreamReader &xmlReader,ClientHandler *client) +{ + ClientAutorization clientAutorization; + + /*Перебираем все атрибуты тега*/ + foreach(const QXmlStreamAttribute &attr, xmlReader.attributes()) + { + QString name = attr.name().toString(); + QString value = attr.value().toString(); + //addTextToLogger(name + ": " + value); + + if(name == "Login") + clientAutorization.Login = value; + else if(name == "Password") + clientAutorization.Password = value; + else if(name == "NumberOfScreen") + clientAutorization.NumberOfScreen = value.toInt(); + else if(name == "TypeClient") + clientAutorization.TypeClient = (TypeClientAutorization)value.toInt(); + } + + processingSystem->processingClientAutorization(client, clientAutorization); +} + +void ProcessParser::clientDeAuth(QXmlStreamReader &xmlReader,ClientHandler *client) +{ + ClientDeAutorization clientDeAutorization; + + /*Перебираем все атрибуты тега*/ + foreach(const QXmlStreamAttribute &attr, xmlReader.attributes()) + { + QString name = attr.name().toString(); + QString value = attr.value().toString(); + //addTextToLogger(name + ": " + value); + + if(name == "Login") + clientDeAutorization.Login = value; + } + + processingSystem->processingClientDeAutorization(client, clientDeAutorization); +} + +void ProcessParser::toClientMessage(QXmlStreamReader &xmlReader,ClientHandler *client) +{ + ToClientMessage toClientMessage; + + /*Перебираем все атрибуты тега*/ + foreach(const QXmlStreamAttribute &attr, xmlReader.attributes()) + { + QString name = attr.name().toString(); + QString value = attr.value().toString(); + //addTextToLogger(name + ": " + value); + + if(name == "id") + toClientMessage.id = value.toInt(); + else if(name == "Text") + toClientMessage.Text = value; + else if(name == "Login") + toClientMessage.Login = value; + } + + processingSystem->processingToClientMessage(client, toClientMessage); +} + +void ProcessParser::queryToDb(QXmlStreamReader &xmlReader,ClientHandler *client) +{ + ClientQueryToDB queryToDB; + int id = 0; + Instructor instructor; + Trainee trainee; + Group group; + void* data = nullptr; + + /*Перебираем все атрибуты тега*/ + foreach(const QXmlStreamAttribute &attr, xmlReader.attributes()) + { + QString name = attr.name().toString(); + QString value = attr.value().toString(); + //addTextToLogger(name + ": " + value); + + if(name == "TypeQuery") + queryToDB.typeQuery = (TypeQueryToDB)value.toInt(); + else if(name == "id") + id = value.toInt(); + else + { + switch (queryToDB.typeQuery) + { + case TypeQueryToDB::TYPE_QUERY_NEW_INSTRUCTOR: + case TypeQueryToDB::TYPE_QUERY_EDIT_INSTRUCTOR: + if(name == "instructor_id") + instructor.setID(value.toInt()); + else if(name == "name") + instructor.setName(value); + else if(name == "login") + instructor.setLogin(value); + else if(name == "password") + instructor.setPassword(value); + else if(name == "is_admin") + instructor.setIsAdmin(value.toInt()); + else if(name == "archived") + instructor.setArchived(value.toInt()); + else if(name == "logged_in") + instructor.setLoggedIn(value.toInt()); + break; + case TypeQueryToDB::TYPE_QUERY_NEW_TRAINEE: + case TypeQueryToDB::TYPE_QUERY_EDIT_TRAINEE: + if(name == "trainee_id") + trainee.setID(value.toInt()); + else if(name == "name") + trainee.setName(value); + else if(name == "login") + trainee.setLogin(value); + else if(name == "password") + trainee.setPassword(value); + else if(name == "archived") + trainee.setArchived(value.toInt()); + else if(name == "logged_in") + trainee.setLoggedIn(value.toInt()); + else if(name == "group_trainee") + { + Group group(value.toInt(), ""); + trainee.setGroup(group); + } + else if(name == "computer_trainee") + { + Computer computer(value.toInt(), "", "", Classroom()); + trainee.setComputer(computer); + } + break; + case TypeQueryToDB::TYPE_QUERY_NEW_GROUP: + case TypeQueryToDB::TYPE_QUERY_EDIT_GROUP: + if(name == "group_id") + group.setID(value.toInt()); + else if(name == "name") + group.setName(value); + break; + }; + } + } + + switch (queryToDB.typeQuery) + { + case TypeQueryToDB::TYPE_QUERY_NEW_INSTRUCTOR: + case TypeQueryToDB::TYPE_QUERY_EDIT_INSTRUCTOR: + data = &instructor; + break; + case TypeQueryToDB::TYPE_QUERY_NEW_TRAINEE: + case TypeQueryToDB::TYPE_QUERY_EDIT_TRAINEE: + data = &trainee; + break; + case TypeQueryToDB::TYPE_QUERY_NEW_GROUP: + case TypeQueryToDB::TYPE_QUERY_EDIT_GROUP: + data = &group; + break; + }; + + processingSystem->processingClientQueryToDB(client, queryToDB, id, data); +} + +void ProcessParser::clientMessage(QXmlStreamReader &xmlReader,ClientHandler *client) +{ + ClientMessage clientMessage; + + /*Перебираем все атрибуты тега*/ + foreach(const QXmlStreamAttribute &attr, xmlReader.attributes()) + { + QString name = attr.name().toString(); + QString value = attr.value().toString(); + //addTextToLogger(name + ": " + value); + + if(name == "Text") + clientMessage.Text = value; + } + + processingSystem->processingFromClientMessage(client, clientMessage); +} + +void ProcessParser::clientNotify(QXmlStreamReader &xmlReader,ClientHandler *client) +{ + ClientNotify clientNotify; + + /*Перебираем все атрибуты тега*/ + foreach(const QXmlStreamAttribute &attr, xmlReader.attributes()) + { + QString name = attr.name().toString(); + QString value = attr.value().toString(); + + if(name == "Code") + clientNotify.Code = value; + } + + processingSystem->processingClientNotify(client, clientNotify); +} + + diff --git a/ServerLMS/ServerLMS/Systems/Parsers/processparser.h b/ServerLMS/ServerLMS/Systems/Parsers/processparser.h new file mode 100644 index 0000000..41046a1 --- /dev/null +++ b/ServerLMS/ServerLMS/Systems/Parsers/processparser.h @@ -0,0 +1,30 @@ +#ifndef PROCESSPARSER_H +#define PROCESSPARSER_H + +#include +#include +#include +#include + +class ProcessParser : public QObject +{ + Q_OBJECT +public: + explicit ProcessParser(QObject *parent = nullptr); + void initialize(ProcessingSystem *processingSystem); + void read(ClientHandler *client, QByteArray array); + + +signals: + void sigLogMessage(QString text); +private: + ProcessingSystem *processingSystem; + void clientAuth(QXmlStreamReader &xmlReader,ClientHandler *client); + void clientDeAuth(QXmlStreamReader &xmlReader,ClientHandler *client); + void toClientMessage(QXmlStreamReader &xmlReader,ClientHandler *client); + void queryToDb(QXmlStreamReader &xmlReader,ClientHandler *client); + void clientMessage(QXmlStreamReader &xmlReader,ClientHandler *client); + void clientNotify(QXmlStreamReader &xmlReader,ClientHandler *client); +}; + +#endif // PROCESSPARSER_H diff --git a/ServerLMS/ServerLMS/Systems/recognizesystem.cpp b/ServerLMS/ServerLMS/Systems/recognizesystem.cpp index b610fe8..8e30805 100644 --- a/ServerLMS/ServerLMS/Systems/recognizesystem.cpp +++ b/ServerLMS/ServerLMS/Systems/recognizesystem.cpp @@ -28,7 +28,7 @@ void RecognizeSystem::initialize(UpdateController *updateController,DataParser* connect(this,&RecognizeSystem::sigChangeVersion,updateController,&UpdateController::changeAssetVersion,Qt::AutoConnection); connect(this,&RecognizeSystem::sigDeleteVersion,updateController,&UpdateController::deleteAssetVersion,Qt::AutoConnection); connect(this,&RecognizeSystem::sigCopyVersion,updateController,&UpdateController::createCopyVersion,Qt::AutoConnection); - connect(this,&RecognizeSystem::sigXmlParser,dataParser,&DataParser::xmlParser,Qt::DirectConnection); + connect(this,&RecognizeSystem::sigXmlParser,dataParser->getProcessParser(),&ProcessParser::read,Qt::DirectConnection); qDebug() << "Recognize init thread ID " << QThread::currentThreadId(); } diff --git a/ServerLMS/ServerLMS/Systems/tools.h b/ServerLMS/ServerLMS/Systems/tools.h index 4a8eb54..f78fff9 100644 --- a/ServerLMS/ServerLMS/Systems/tools.h +++ b/ServerLMS/ServerLMS/Systems/tools.h @@ -12,29 +12,29 @@ #define TCP_READ_TIMEOUT 5000 -static QString staticDataFolderName = "StaticData"; -static QString applicationFolderName = "Application"; -static QString sharedDataFolderName = "SharedData"; -static QString streamingAssetsFolderName = "StreamingAssets"; -static QString tempFile = staticDataFolderName + "/save.xml"; -static QString version = staticDataFolderName + "/version.xml"; -static QString versionListFile = staticDataFolderName + "/versionList.xml"; -static QString hashFileName = staticDataFolderName + "/serverHash.xml"; -static QString buildHashName = staticDataFolderName + "/buildHash.xml"; -static QString buildDataPath = "/Application/RRJLoader/RRJ_Data/"; +static const QString staticDataFolderName = "StaticData"; +static const QString applicationFolderName = "Application"; +static const QString sharedDataFolderName = "SharedData"; +static const QString streamingAssetsFolderName = "StreamingAssets"; +static const QString tempFile = staticDataFolderName + "/save.xml"; +static const QString version = staticDataFolderName + "/version.xml"; +static const QString versionListFile = staticDataFolderName + "/versionList.xml"; +static const QString hashFileName = staticDataFolderName + "/serverHash.xml"; +static const QString buildHashName = staticDataFolderName + "/buildHash.xml"; +static const QString buildDataPath = "/Application/RRJLoader/RRJ_Data/"; -static QString baseNameVersion = "base";//может вынести комманды куда нибудь? +static const QString baseNameVersion = "base";//может вынести комманды куда нибудь? -static QString commandTryBaseDelete = "BASEDELETETRY"; -static QString commandTryActiveDelete = "TRYACTIVEDELETE"; -static QString commandTryCopyWithSameNames = "SAMENAMES"; -static QString commandGetServerDataList = "GETSERVERDATALIST"; -static QString commandCheckVersionList = "CHECKVERSIONLIST"; -static QString commandReadyClient = "READY"; -static QString commandDisableClient = "DISABLE"; -static QString commandDuplicateVerName = "DUPLICATEVERNAME"; -static QString commandHashCompleteClient = "HASHSENDCOMPLETE"; -static QString commandUpdateFilesClient = "update"; +static const QString commandTryBaseDelete = "BASEDELETETRY"; +static const QString commandTryActiveDelete = "TRYACTIVEDELETE"; +static const QString commandTryCopyWithSameNames = "SAMENAMES"; +static const QString commandGetServerDataList = "GETSERVERDATALIST"; +static const QString commandCheckVersionList = "CHECKVERSIONLIST"; +static const QString commandReadyClient = "READY"; +static const QString commandDisableClient = "DISABLE"; +static const QString commandDuplicateVerName = "DUPLICATEVERNAME"; +static const QString commandHashCompleteClient = "HASHSENDCOMPLETE"; +static const QString commandUpdateFilesClient = "update"; class Tools { public: diff --git a/ServerLMS/ServerLMS/Systems/updatecontroller.cpp b/ServerLMS/ServerLMS/Systems/updatecontroller.cpp index 59029ca..7a548c1 100644 --- a/ServerLMS/ServerLMS/Systems/updatecontroller.cpp +++ b/ServerLMS/ServerLMS/Systems/updatecontroller.cpp @@ -10,7 +10,7 @@ UpdateController::UpdateController(QObject *parent) : qDebug() << hashFileName; } -void UpdateController::initialize(CommonClientHandler *commonClientHandler,DataParser *dataParser,AssetsManager *assetManager) +void UpdateController::initialize(CommonClientHandler *commonClientHandler,DataParser *dataParser,AssetsManager *assetManager,Logger *logger) { this->commonClientHandler = commonClientHandler; this->dataParser = dataParser; @@ -19,6 +19,8 @@ void UpdateController::initialize(CommonClientHandler *commonClientHandler,DataP sizeToSend = 0; assetManager->initialize(this,dataParser); + connect(this,&UpdateController::sigLogMessage,logger,&Logger::addTextToLogger,Qt::AutoConnection); + calculateFullHash(); currentStreamingPath = assetManager->setVersion("base"); setUpCurrentServerHash(); @@ -244,7 +246,7 @@ bool UpdateController::checkNeedUpdate(ClientHandler *handler) fileSendList = *forSend; emit sigLogMessage(log); - printFileList(*forSend); + //printFileList(*forSend); handler->sendMessageBlock(log); needUpdate = true; @@ -270,7 +272,7 @@ bool UpdateController::checkNeedUpdate(ClientHandler *handler) fileDeleteList = *forDelete; emit sigLogMessage(log); - printFileList(*forDelete); + //printFileList(*forDelete); handler->sendMessageBlock(log); needUpdate = true; } @@ -558,17 +560,17 @@ QList UpdateController::getClientDataList() const return clientDataList; } -DataInfo *UpdateController::getCurrentDataInfo() //TODO: переименовать и перебросить в AssetManager +DataInfo *UpdateController::getCurrentDataInfo() { return dataInfo; } -QList *UpdateController::getDatas() const //TODO: переименовать и перебросить в AssetManager +QList *UpdateController::getDatas() const { return datas; } -void UpdateController::clearCurrentDataInfo() //TODO: переименовать и перебросить в AssetManager +void UpdateController::clearCurrentDataInfo() { delete dataInfo; } diff --git a/ServerLMS/ServerLMS/Systems/updatecontroller.h b/ServerLMS/ServerLMS/Systems/updatecontroller.h index d8037a9..611ef2f 100644 --- a/ServerLMS/ServerLMS/Systems/updatecontroller.h +++ b/ServerLMS/ServerLMS/Systems/updatecontroller.h @@ -21,6 +21,7 @@ class ClientHandler; class AssetsManager; class ServerLMSWidget; class CommonClientHandler; +class Logger; class UpdateController : public QObject { @@ -29,7 +30,7 @@ class UpdateController : public QObject public: explicit UpdateController(QObject *parent = 0); - void initialize(CommonClientHandler* commonClientHandler,DataParser *dataParser,AssetsManager *assetManager); + void initialize(CommonClientHandler* commonClientHandler,DataParser *dataParser,AssetsManager *assetManager,Logger *logger); void compareFiles(ClientHandler* handler, QByteArray array); void showHash(); void calculateFullHash(); diff --git a/ServerLMS/ServerLMS/serverlmswidget.cpp b/ServerLMS/ServerLMS/serverlmswidget.cpp index c943ec0..f52eb00 100644 --- a/ServerLMS/ServerLMS/serverlmswidget.cpp +++ b/ServerLMS/ServerLMS/serverlmswidget.cpp @@ -72,14 +72,14 @@ ServerLMSWidget::ServerLMSWidget(QWidget *parent) : logger->setTypeLog("widget"); - connect(updateController,&UpdateController::sigLogMessage,logger,&Logger::addTextToLogger); + connect(dataParser,&DataParser::sigLogMessage,logger,&Logger::addTextToLogger); connect(this,&ServerLMSWidget::sigUpdateController,updateController,&UpdateController::initialize,Qt::DirectConnection); connect(this,&ServerLMSWidget::sigLog,logger,&Logger::addTextToLogger,Qt::AutoConnection); connect(this,&ServerLMSWidget::sigCalculateFullHash,updateController,&UpdateController::calculateFullHash,Qt::AutoConnection); - emit sigUpdateController(commonClientHandler,dataParser,assetsManager); + emit sigUpdateController(commonClientHandler,dataParser,assetsManager,logger); on_btnStartServer_clicked(); first = true; diff --git a/ServerLMS/ServerLMS/serverlmswidget.h b/ServerLMS/ServerLMS/serverlmswidget.h index d5e697e..545d822 100644 --- a/ServerLMS/ServerLMS/serverlmswidget.h +++ b/ServerLMS/ServerLMS/serverlmswidget.h @@ -59,7 +59,7 @@ signals: void sigRecognize(); void sigLog(QString log); void sigCalculateFullHash(); - void sigUpdateController(CommonClientHandler* commonClientHandler,DataParser *dataParser,AssetsManager *assetManager); + void sigUpdateController(CommonClientHandler* commonClientHandler,DataParser *dataParser,AssetsManager *assetManager,Logger *logger); QTcpSocket* sigGetSocket(); From f339e35aafe40567aacce83f7af4b0d20f8d9ec3 Mon Sep 17 00:00:00 2001 From: semenov Date: Wed, 15 Jan 2025 10:00:51 +0300 Subject: [PATCH 12/13] ref: add obsidian and static to gitignore --- DOCS/.obsidian/app.json | 1 - DOCS/.obsidian/appearance.json | 3 - DOCS/.obsidian/community-plugins.json | 4 - DOCS/.obsidian/core-plugins.json | 30 - DOCS/.obsidian/graph.json | 22 - .../obsidian-excalidraw-plugin/data.json | 788 ------------------ .../obsidian-excalidraw-plugin/main.js | 10 - .../obsidian-excalidraw-plugin/manifest.json | 12 - .../obsidian-excalidraw-plugin/styles.css | 1 - .../.obsidian/plugins/obsidian-kanban/main.js | 153 ---- .../plugins/obsidian-kanban/manifest.json | 11 - .../plugins/obsidian-kanban/styles.css | 1 - DOCS/.obsidian/types.json | 27 - DOCS/.obsidian/workspace.json | 251 ------ .../GUIdataBaseLMS/StaticData/authData.xml | 2 - .../GUIdataBaseLMS/StaticData/settings.xml | 4 - .../GUIdataBaseLMS/StaticData/temp.xml | 2 - 17 files changed, 1322 deletions(-) delete mode 100644 DOCS/.obsidian/app.json delete mode 100644 DOCS/.obsidian/appearance.json delete mode 100644 DOCS/.obsidian/community-plugins.json delete mode 100644 DOCS/.obsidian/core-plugins.json delete mode 100644 DOCS/.obsidian/graph.json delete mode 100644 DOCS/.obsidian/plugins/obsidian-excalidraw-plugin/data.json delete mode 100644 DOCS/.obsidian/plugins/obsidian-excalidraw-plugin/main.js delete mode 100644 DOCS/.obsidian/plugins/obsidian-excalidraw-plugin/manifest.json delete mode 100644 DOCS/.obsidian/plugins/obsidian-excalidraw-plugin/styles.css delete mode 100644 DOCS/.obsidian/plugins/obsidian-kanban/main.js delete mode 100644 DOCS/.obsidian/plugins/obsidian-kanban/manifest.json delete mode 100644 DOCS/.obsidian/plugins/obsidian-kanban/styles.css delete mode 100644 DOCS/.obsidian/types.json delete mode 100644 DOCS/.obsidian/workspace.json delete mode 100644 GUIdataBaseLMS/GUIdataBaseLMS/StaticData/authData.xml delete mode 100644 GUIdataBaseLMS/GUIdataBaseLMS/StaticData/settings.xml delete mode 100644 GUIdataBaseLMS/GUIdataBaseLMS/StaticData/temp.xml diff --git a/DOCS/.obsidian/app.json b/DOCS/.obsidian/app.json deleted file mode 100644 index 9e26dfe..0000000 --- a/DOCS/.obsidian/app.json +++ /dev/null @@ -1 +0,0 @@ -{} \ No newline at end of file diff --git a/DOCS/.obsidian/appearance.json b/DOCS/.obsidian/appearance.json deleted file mode 100644 index 4be7969..0000000 --- a/DOCS/.obsidian/appearance.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "theme": "obsidian" -} \ No newline at end of file diff --git a/DOCS/.obsidian/community-plugins.json b/DOCS/.obsidian/community-plugins.json deleted file mode 100644 index 38e5774..0000000 --- a/DOCS/.obsidian/community-plugins.json +++ /dev/null @@ -1,4 +0,0 @@ -[ - "obsidian-excalidraw-plugin", - "obsidian-kanban" -] \ No newline at end of file diff --git a/DOCS/.obsidian/core-plugins.json b/DOCS/.obsidian/core-plugins.json deleted file mode 100644 index 436f43c..0000000 --- a/DOCS/.obsidian/core-plugins.json +++ /dev/null @@ -1,30 +0,0 @@ -{ - "file-explorer": true, - "global-search": true, - "switcher": true, - "graph": true, - "backlink": true, - "canvas": true, - "outgoing-link": true, - "tag-pane": true, - "properties": false, - "page-preview": true, - "daily-notes": true, - "templates": true, - "note-composer": true, - "command-palette": true, - "slash-command": false, - "editor-status": true, - "bookmarks": true, - "markdown-importer": false, - "zk-prefixer": false, - "random-note": false, - "outline": true, - "word-count": true, - "slides": false, - "audio-recorder": false, - "workspaces": false, - "file-recovery": true, - "publish": false, - "sync": false -} \ No newline at end of file diff --git a/DOCS/.obsidian/graph.json b/DOCS/.obsidian/graph.json deleted file mode 100644 index 42a46ec..0000000 --- a/DOCS/.obsidian/graph.json +++ /dev/null @@ -1,22 +0,0 @@ -{ - "collapse-filter": true, - "search": "", - "showTags": false, - "showAttachments": false, - "hideUnresolved": false, - "showOrphans": true, - "collapse-color-groups": true, - "colorGroups": [], - "collapse-display": true, - "showArrow": false, - "textFadeMultiplier": 0, - "nodeSizeMultiplier": 1, - "lineSizeMultiplier": 1, - "collapse-forces": true, - "centerStrength": 0.518713248970312, - "repelStrength": 10, - "linkStrength": 1, - "linkDistance": 250, - "scale": 1, - "close": true -} \ No newline at end of file diff --git a/DOCS/.obsidian/plugins/obsidian-excalidraw-plugin/data.json b/DOCS/.obsidian/plugins/obsidian-excalidraw-plugin/data.json deleted file mode 100644 index 4c4d44b..0000000 --- a/DOCS/.obsidian/plugins/obsidian-excalidraw-plugin/data.json +++ /dev/null @@ -1,788 +0,0 @@ -{ - "folder": "Excalidraw", - "cropFolder": "", - "annotateFolder": "", - "embedUseExcalidrawFolder": false, - "templateFilePath": "Excalidraw/Template.excalidraw", - "scriptFolderPath": "Excalidraw/Scripts", - "fontAssetsPath": "Excalidraw/CJK Fonts", - "loadChineseFonts": false, - "loadJapaneseFonts": false, - "loadKoreanFonts": false, - "compress": true, - "decompressForMDView": false, - "onceOffCompressFlagReset": true, - "onceOffGPTVersionReset": true, - "autosave": true, - "autosaveIntervalDesktop": 60000, - "autosaveIntervalMobile": 30000, - "drawingFilenamePrefix": "Drawing ", - "drawingEmbedPrefixWithFilename": true, - "drawingFilnameEmbedPostfix": " ", - "drawingFilenameDateTime": "YYYY-MM-DD HH.mm.ss", - "useExcalidrawExtension": true, - "cropPrefix": "cropped_", - "annotatePrefix": "annotated_", - "annotatePreserveSize": false, - "previewImageType": "SVGIMG", - "allowImageCache": true, - "allowImageCacheInScene": true, - "displayExportedImageIfAvailable": false, - "previewMatchObsidianTheme": false, - "width": "400", - "height": "", - "overrideObsidianFontSize": false, - "dynamicStyling": "colorful", - "isLeftHanded": false, - "iframeMatchExcalidrawTheme": true, - "matchTheme": false, - "matchThemeAlways": false, - "matchThemeTrigger": false, - "defaultMode": "normal", - "defaultPenMode": "never", - "penModeDoubleTapEraser": true, - "penModeSingleFingerPanning": true, - "penModeCrosshairVisible": true, - "renderImageInMarkdownReadingMode": false, - "renderImageInHoverPreviewForMDNotes": false, - "renderImageInMarkdownToPDF": false, - "allowPinchZoom": false, - "allowWheelZoom": false, - "zoomToFitOnOpen": true, - "zoomToFitOnResize": true, - "zoomToFitMaxLevel": 2, - "linkPrefix": "📍", - "urlPrefix": "🌐", - "parseTODO": false, - "todo": "☐", - "done": "🗹", - "hoverPreviewWithoutCTRL": false, - "linkOpacity": 1, - "openInAdjacentPane": true, - "showSecondOrderLinks": true, - "focusOnFileTab": true, - "openInMainWorkspace": true, - "showLinkBrackets": true, - "allowCtrlClick": true, - "forceWrap": false, - "pageTransclusionCharLimit": 200, - "wordWrappingDefault": 0, - "removeTransclusionQuoteSigns": true, - "iframelyAllowed": true, - "pngExportScale": 1, - "exportWithTheme": true, - "exportWithBackground": true, - "exportPaddingSVG": 10, - "exportEmbedScene": false, - "keepInSync": false, - "autoexportSVG": false, - "autoexportPNG": false, - "autoExportLightAndDark": false, - "autoexportExcalidraw": false, - "embedType": "excalidraw", - "embedMarkdownCommentLinks": true, - "embedWikiLink": true, - "syncExcalidraw": false, - "experimentalFileType": false, - "experimentalFileTag": "✏️", - "experimentalLivePreview": true, - "fadeOutExcalidrawMarkup": false, - "loadPropertySuggestions": true, - "experimentalEnableFourthFont": false, - "experimantalFourthFont": "Virgil", - "addDummyTextElement": false, - "zoteroCompatibility": false, - "fieldSuggester": true, - "compatibilityMode": false, - "drawingOpenCount": 0, - "library": "deprecated", - "library2": { - "type": "excalidrawlib", - "version": 2, - "source": "https://github.com/zsviczian/obsidian-excalidraw-plugin/releases/tag/2.7.2", - "libraryItems": [] - }, - "imageElementNotice": true, - "mdSVGwidth": 500, - "mdSVGmaxHeight": 800, - "mdFont": "Virgil", - "mdFontColor": "Black", - "mdBorderColor": "Black", - "mdCSS": "", - "scriptEngineSettings": {}, - "defaultTrayMode": true, - "previousRelease": "2.7.2", - "showReleaseNotes": true, - "showNewVersionNotification": true, - "latexBoilerplate": "\\color{blue}", - "taskboneEnabled": false, - "taskboneAPIkey": "", - "pinnedScripts": [], - "customPens": [ - { - "type": "default", - "freedrawOnly": false, - "strokeColor": "#000000", - "backgroundColor": "transparent", - "fillStyle": "hachure", - "strokeWidth": 0, - "roughness": 0, - "penOptions": { - "highlighter": false, - "constantPressure": false, - "hasOutline": false, - "outlineWidth": 1, - "options": { - "thinning": 0.6, - "smoothing": 0.5, - "streamline": 0.5, - "easing": "easeOutSine", - "start": { - "cap": true, - "taper": 0, - "easing": "linear" - }, - "end": { - "cap": true, - "taper": 0, - "easing": "linear" - } - } - } - }, - { - "type": "highlighter", - "freedrawOnly": true, - "strokeColor": "#FFC47C", - "backgroundColor": "#FFC47C", - "fillStyle": "solid", - "strokeWidth": 2, - "roughness": null, - "penOptions": { - "highlighter": true, - "constantPressure": true, - "hasOutline": true, - "outlineWidth": 4, - "options": { - "thinning": 1, - "smoothing": 0.5, - "streamline": 0.5, - "easing": "linear", - "start": { - "taper": 0, - "cap": true, - "easing": "linear" - }, - "end": { - "taper": 0, - "cap": true, - "easing": "linear" - } - } - } - }, - { - "type": "finetip", - "freedrawOnly": false, - "strokeColor": "#3E6F8D", - "backgroundColor": "transparent", - "fillStyle": "hachure", - "strokeWidth": 0.5, - "roughness": 0, - "penOptions": { - "highlighter": false, - "hasOutline": false, - "outlineWidth": 1, - "constantPressure": true, - "options": { - "smoothing": 0.4, - "thinning": -0.5, - "streamline": 0.4, - "easing": "linear", - "start": { - "taper": 5, - "cap": false, - "easing": "linear" - }, - "end": { - "taper": 5, - "cap": false, - "easing": "linear" - } - } - } - }, - { - "type": "fountain", - "freedrawOnly": false, - "strokeColor": "#000000", - "backgroundColor": "transparent", - "fillStyle": "hachure", - "strokeWidth": 2, - "roughness": 0, - "penOptions": { - "highlighter": false, - "constantPressure": false, - "hasOutline": false, - "outlineWidth": 1, - "options": { - "smoothing": 0.2, - "thinning": 0.6, - "streamline": 0.2, - "easing": "easeInOutSine", - "start": { - "taper": 150, - "cap": true, - "easing": "linear" - }, - "end": { - "taper": 1, - "cap": true, - "easing": "linear" - } - } - } - }, - { - "type": "marker", - "freedrawOnly": true, - "strokeColor": "#B83E3E", - "backgroundColor": "#FF7C7C", - "fillStyle": "dashed", - "strokeWidth": 2, - "roughness": 3, - "penOptions": { - "highlighter": false, - "constantPressure": true, - "hasOutline": true, - "outlineWidth": 4, - "options": { - "thinning": 1, - "smoothing": 0.5, - "streamline": 0.5, - "easing": "linear", - "start": { - "taper": 0, - "cap": true, - "easing": "linear" - }, - "end": { - "taper": 0, - "cap": true, - "easing": "linear" - } - } - } - }, - { - "type": "thick-thin", - "freedrawOnly": true, - "strokeColor": "#CECDCC", - "backgroundColor": "transparent", - "fillStyle": "hachure", - "strokeWidth": 0, - "roughness": null, - "penOptions": { - "highlighter": true, - "constantPressure": true, - "hasOutline": false, - "outlineWidth": 1, - "options": { - "thinning": 1, - "smoothing": 0.5, - "streamline": 0.5, - "easing": "linear", - "start": { - "taper": 0, - "cap": true, - "easing": "linear" - }, - "end": { - "cap": true, - "taper": true, - "easing": "linear" - } - } - } - }, - { - "type": "thin-thick-thin", - "freedrawOnly": true, - "strokeColor": "#CECDCC", - "backgroundColor": "transparent", - "fillStyle": "hachure", - "strokeWidth": 0, - "roughness": null, - "penOptions": { - "highlighter": true, - "constantPressure": true, - "hasOutline": false, - "outlineWidth": 1, - "options": { - "thinning": 1, - "smoothing": 0.5, - "streamline": 0.5, - "easing": "linear", - "start": { - "cap": true, - "taper": true, - "easing": "linear" - }, - "end": { - "cap": true, - "taper": true, - "easing": "linear" - } - } - } - }, - { - "type": "default", - "freedrawOnly": false, - "strokeColor": "#000000", - "backgroundColor": "transparent", - "fillStyle": "hachure", - "strokeWidth": 0, - "roughness": 0, - "penOptions": { - "highlighter": false, - "constantPressure": false, - "hasOutline": false, - "outlineWidth": 1, - "options": { - "thinning": 0.6, - "smoothing": 0.5, - "streamline": 0.5, - "easing": "easeOutSine", - "start": { - "cap": true, - "taper": 0, - "easing": "linear" - }, - "end": { - "cap": true, - "taper": 0, - "easing": "linear" - } - } - } - }, - { - "type": "default", - "freedrawOnly": false, - "strokeColor": "#000000", - "backgroundColor": "transparent", - "fillStyle": "hachure", - "strokeWidth": 0, - "roughness": 0, - "penOptions": { - "highlighter": false, - "constantPressure": false, - "hasOutline": false, - "outlineWidth": 1, - "options": { - "thinning": 0.6, - "smoothing": 0.5, - "streamline": 0.5, - "easing": "easeOutSine", - "start": { - "cap": true, - "taper": 0, - "easing": "linear" - }, - "end": { - "cap": true, - "taper": 0, - "easing": "linear" - } - } - } - }, - { - "type": "default", - "freedrawOnly": false, - "strokeColor": "#000000", - "backgroundColor": "transparent", - "fillStyle": "hachure", - "strokeWidth": 0, - "roughness": 0, - "penOptions": { - "highlighter": false, - "constantPressure": false, - "hasOutline": false, - "outlineWidth": 1, - "options": { - "thinning": 0.6, - "smoothing": 0.5, - "streamline": 0.5, - "easing": "easeOutSine", - "start": { - "cap": true, - "taper": 0, - "easing": "linear" - }, - "end": { - "cap": true, - "taper": 0, - "easing": "linear" - } - } - } - } - ], - "numberOfCustomPens": 0, - "pdfScale": 4, - "pdfBorderBox": true, - "pdfFrame": false, - "pdfGapSize": 20, - "pdfGroupPages": false, - "pdfLockAfterImport": true, - "pdfNumColumns": 1, - "pdfNumRows": 1, - "pdfDirection": "right", - "pdfImportScale": 0.3, - "gridSettings": { - "DYNAMIC_COLOR": true, - "COLOR": "#000000", - "OPACITY": 50 - }, - "laserSettings": { - "DECAY_LENGTH": 50, - "DECAY_TIME": 1000, - "COLOR": "#ff0000" - }, - "embeddableMarkdownDefaults": { - "useObsidianDefaults": false, - "backgroundMatchCanvas": false, - "backgroundMatchElement": true, - "backgroundColor": "#fff", - "backgroundOpacity": 60, - "borderMatchElement": true, - "borderColor": "#fff", - "borderOpacity": 0, - "filenameVisible": false - }, - "markdownNodeOneClickEditing": false, - "canvasImmersiveEmbed": true, - "startupScriptPath": "", - "openAIAPIToken": "", - "openAIDefaultTextModel": "gpt-3.5-turbo-1106", - "openAIDefaultVisionModel": "gpt-4o", - "openAIDefaultImageGenerationModel": "dall-e-3", - "openAIURL": "https://api.openai.com/v1/chat/completions", - "openAIImageGenerationURL": "https://api.openai.com/v1/images/generations", - "openAIImageEditsURL": "https://api.openai.com/v1/images/edits", - "openAIImageVariationURL": "https://api.openai.com/v1/images/variations", - "modifierKeyConfig": { - "Mac": { - "LocalFileDragAction": { - "defaultAction": "image-import", - "rules": [ - { - "shift": false, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": false, - "result": "image-import" - }, - { - "shift": true, - "ctrl_cmd": false, - "alt_opt": true, - "meta_ctrl": false, - "result": "link" - }, - { - "shift": true, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": false, - "result": "image-url" - }, - { - "shift": false, - "ctrl_cmd": false, - "alt_opt": true, - "meta_ctrl": false, - "result": "embeddable" - } - ] - }, - "WebBrowserDragAction": { - "defaultAction": "image-url", - "rules": [ - { - "shift": false, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": false, - "result": "image-url" - }, - { - "shift": true, - "ctrl_cmd": false, - "alt_opt": true, - "meta_ctrl": false, - "result": "link" - }, - { - "shift": false, - "ctrl_cmd": false, - "alt_opt": true, - "meta_ctrl": false, - "result": "embeddable" - }, - { - "shift": true, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": false, - "result": "image-import" - } - ] - }, - "InternalDragAction": { - "defaultAction": "link", - "rules": [ - { - "shift": false, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": false, - "result": "link" - }, - { - "shift": false, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": true, - "result": "embeddable" - }, - { - "shift": true, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": false, - "result": "image" - }, - { - "shift": true, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": true, - "result": "image-fullsize" - } - ] - }, - "LinkClickAction": { - "defaultAction": "new-tab", - "rules": [ - { - "shift": false, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": false, - "result": "active-pane" - }, - { - "shift": false, - "ctrl_cmd": true, - "alt_opt": false, - "meta_ctrl": false, - "result": "new-tab" - }, - { - "shift": false, - "ctrl_cmd": true, - "alt_opt": true, - "meta_ctrl": false, - "result": "new-pane" - }, - { - "shift": true, - "ctrl_cmd": true, - "alt_opt": true, - "meta_ctrl": false, - "result": "popout-window" - }, - { - "shift": false, - "ctrl_cmd": true, - "alt_opt": false, - "meta_ctrl": true, - "result": "md-properties" - } - ] - } - }, - "Win": { - "LocalFileDragAction": { - "defaultAction": "image-import", - "rules": [ - { - "shift": false, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": false, - "result": "image-import" - }, - { - "shift": false, - "ctrl_cmd": true, - "alt_opt": false, - "meta_ctrl": false, - "result": "link" - }, - { - "shift": true, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": false, - "result": "image-url" - }, - { - "shift": true, - "ctrl_cmd": true, - "alt_opt": false, - "meta_ctrl": false, - "result": "embeddable" - } - ] - }, - "WebBrowserDragAction": { - "defaultAction": "image-url", - "rules": [ - { - "shift": false, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": false, - "result": "image-url" - }, - { - "shift": false, - "ctrl_cmd": true, - "alt_opt": false, - "meta_ctrl": false, - "result": "link" - }, - { - "shift": true, - "ctrl_cmd": true, - "alt_opt": false, - "meta_ctrl": false, - "result": "embeddable" - }, - { - "shift": true, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": false, - "result": "image-import" - } - ] - }, - "InternalDragAction": { - "defaultAction": "link", - "rules": [ - { - "shift": false, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": false, - "result": "link" - }, - { - "shift": true, - "ctrl_cmd": true, - "alt_opt": false, - "meta_ctrl": false, - "result": "embeddable" - }, - { - "shift": true, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": false, - "result": "image" - }, - { - "shift": false, - "ctrl_cmd": true, - "alt_opt": true, - "meta_ctrl": false, - "result": "image-fullsize" - } - ] - }, - "LinkClickAction": { - "defaultAction": "new-tab", - "rules": [ - { - "shift": false, - "ctrl_cmd": false, - "alt_opt": false, - "meta_ctrl": false, - "result": "active-pane" - }, - { - "shift": false, - "ctrl_cmd": true, - "alt_opt": false, - "meta_ctrl": false, - "result": "new-tab" - }, - { - "shift": false, - "ctrl_cmd": true, - "alt_opt": true, - "meta_ctrl": false, - "result": "new-pane" - }, - { - "shift": true, - "ctrl_cmd": true, - "alt_opt": true, - "meta_ctrl": false, - "result": "popout-window" - }, - { - "shift": false, - "ctrl_cmd": true, - "alt_opt": false, - "meta_ctrl": true, - "result": "md-properties" - } - ] - } - } - }, - "slidingPanesSupport": false, - "areaZoomLimit": 1, - "longPressDesktop": 500, - "longPressMobile": 500, - "doubleClickLinkOpenViewMode": true, - "isDebugMode": false, - "rank": "Bronze", - "modifierKeyOverrides": [ - { - "modifiers": [ - "Mod" - ], - "key": "Enter" - }, - { - "modifiers": [ - "Mod" - ], - "key": "k" - }, - { - "modifiers": [ - "Mod" - ], - "key": "G" - } - ], - "showSplashscreen": true -} \ No newline at end of file diff --git a/DOCS/.obsidian/plugins/obsidian-excalidraw-plugin/main.js b/DOCS/.obsidian/plugins/obsidian-excalidraw-plugin/main.js deleted file mode 100644 index ce69e69..0000000 --- a/DOCS/.obsidian/plugins/obsidian-excalidraw-plugin/main.js +++ /dev/null @@ -1,10 +0,0 @@ -"use strict";var obsidian_module=require("obsidian"),state=require("@codemirror/state"),view=require("@codemirror/view");const INITIAL_TIMESTAMP=Date.now();var LZString=function(){var r=String.fromCharCode,o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",n="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$",e={};function t(r,o){if(!e[r]){e[r]={};for(var n=0;n>>8,n[2*e+1]=s%256}return n},decompressFromUint8Array:function(o){if(null==o)return i.decompress(o);for(var n=new Array(o.length/2),e=0,t=n.length;e>=1}else{for(t=1,e=0;e>=1}0==--l&&(l=Math.pow(2,h),h++),delete u[c]}else for(t=s[c],e=0;e>=1;0==--l&&(l=Math.pow(2,h),h++),s[p]=f++,c=String(a)}if(""!==c){if(Object.prototype.hasOwnProperty.call(u,c)){if(c.charCodeAt(0)<256){for(e=0;e>=1}else{for(t=1,e=0;e>=1}0==--l&&(l=Math.pow(2,h),h++),delete u[c]}else for(t=s[c],e=0;e>=1;0==--l&&(l=Math.pow(2,h),h++)}for(t=2,e=0;e>=1;for(;;){if(m<<=1,v==o-1){d.push(n(m));break}v++}return d.join("")},decompress:function(r){return null==r?"":""==r?null:i._decompress(r.length,32768,function(o){return r.charCodeAt(o)})},_decompress:function(o,n,e){var t,i,s,u,a,p,c,l=[],f=4,h=4,d=3,m="",v=[],g={val:e(0),position:n,index:1};for(t=0;t<3;t+=1)l[t]=t;for(s=0,a=Math.pow(2,2),p=1;p!=a;)u=g.val&g.position,g.position>>=1,0==g.position&&(g.position=n,g.val=e(g.index++)),s|=(u>0?1:0)*p,p<<=1;switch(s){case 0:for(s=0,a=Math.pow(2,8),p=1;p!=a;)u=g.val&g.position,g.position>>=1,0==g.position&&(g.position=n,g.val=e(g.index++)),s|=(u>0?1:0)*p,p<<=1;c=r(s);break;case 1:for(s=0,a=Math.pow(2,16),p=1;p!=a;)u=g.val&g.position,g.position>>=1,0==g.position&&(g.position=n,g.val=e(g.index++)),s|=(u>0?1:0)*p,p<<=1;c=r(s);break;case 2:return""}for(l[3]=c,i=c,v.push(c);;){if(g.index>o)return"";for(s=0,a=Math.pow(2,d),p=1;p!=a;)u=g.val&g.position,g.position>>=1,0==g.position&&(g.position=n,g.val=e(g.index++)),s|=(u>0?1:0)*p,p<<=1;switch(c=s){case 0:for(s=0,a=Math.pow(2,8),p=1;p!=a;)u=g.val&g.position,g.position>>=1,0==g.position&&(g.position=n,g.val=e(g.index++)),s|=(u>0?1:0)*p,p<<=1;l[h++]=r(s),c=h-1,f--;break;case 1:for(s=0,a=Math.pow(2,16),p=1;p!=a;)u=g.val&g.position,g.position>>=1,0==g.position&&(g.position=n,g.val=e(g.index++)),s|=(u>0?1:0)*p,p<<=1;l[h++]=r(s),c=h-1,f--;break;case 2:return v.join("")}if(0==f&&(f=Math.pow(2,d),d++),l[c])m=l[c];else{if(c!==h)return null;m=i+i.charAt(0)}v.push(m),l[h++]=i+m.charAt(0),i=m,0==--f&&(f=Math.pow(2,d),d++)}}};return i}();"function"==typeof define&&define.amd?define(function(){return LZString}):"undefined"!=typeof module&&null!=module?module.exports=LZString:"undefined"!=typeof angular&&null!=angular&&angular.module("LZString",[]).factory("LZString",function(){return LZString}); -let REACT_PACKAGES = `!function(){var e,t;e=this,t=function(e){function M(e){return null!==e&&"object"==typeof e&&"function"==typeof(e=te&&e[te]||e["@@iterator"])?e:null}function t(e,t,n){this.props=e,this.context=t,this.refs=oe,this.updater=n||ne}function n(){}function r(e,t,n){this.props=e,this.context=t,this.refs=oe,this.updater=n||ne}function o(e,t,n){var r,o={},u=null,a=null;if(null!=t)for(r in void 0!==t.ref&&(a=t.ref),void 0!==t.key&&(u=""+t.key),t)ae.call(t,r)&&!ie.hasOwnProperty(r)&&(o[r]=t[r]);var i=arguments.length-2;if(1===i)o.children=n;else if(1>>1,o=e[r];if(!(0>>1;rt)||e&&!q());){var r,o=R.callback;"function"==typeof o?(R.callback=null,P=R.priorityLevel,r=o(R.expirationTime<=t),t=v(),"function"==typeof r?R.callback=r:R===i(C)&&l(C),y(t)):l(C),R=i(C)}var u,a=null!==R||(null!==(u=i(E))&&_(d,u.startTime-t),!1);return a}finally{R=null,P=n,$=!1}}function q(){return!(v()-de")?l.replace("",n.displayName):l}while(1<=u&&0<=i);break}}}finally{xo=!1,Error.prepareStackTrace=t}return(n=n?n.displayName||n.name:"")?Q(n):""}function $(e){switch(e.tag){case 5:return Q(e.type);case 16:return Q("Lazy");case 13:return Q("Suspense");case 19:return Q("SuspenseList");case 0:case 2:case 15:return e=j(e.type,!1);case 11:return e=j(e.type.render,!1);case 1:return e=j(e.type,!0);default:return""}}function q(e){if(null!=e){if("function"==typeof e)return e.displayName||e.name||null;if("string"==typeof e)return e;switch(e){case co:return"Fragment";case so:return"Portal";case po:return"Profiler";case fo:return"StrictMode";case yo:return"Suspense";case vo:return"SuspenseList"}if("object"==typeof e)switch(e.$$typeof){case ho:return(e.displayName||"Context")+".Consumer";case mo:return(e._context.displayName||"Context")+".Provider";case go:var n=e.render;return e=(e=e.displayName)?e:""!==(e=n.displayName||n.name||"")?"ForwardRef("+e+")":"ForwardRef";case bo:return null!==(n=e.displayName||null)?n:q(e.type)||"Memo";case ko:n=e._payload,e=e._init;try{return q(e(n))}catch(e){}}}return null}function K(e){var n=e.type;switch(e.tag){case 24:return"Cache";case 9:return(n.displayName||"Context")+".Consumer";case 10:return(n._context.displayName||"Context")+".Provider";case 18:return"DehydratedFragment";case 11:return e=(e=n.render).displayName||e.name||"",n.displayName||(""!==e?"ForwardRef("+e+")":"ForwardRef");case 7:return"Fragment";case 5:return n;case 4:return"Portal";case 3:return"Root";case 6:return"Text";case 16:return q(n);case 8:return n===fo?"StrictMode":"Mode";case 22:return"Offscreen";case 12:return"Profiler";case 21:return"Scope";case 13:return"Suspense";case 19:return"SuspenseList";case 25:return"TracingMarker";case 1:case 0:case 17:case 2:case 14:case 15:if("function"==typeof n)return n.displayName||n.name||null;if("string"==typeof n)return n}return null}function Y(e){switch(typeof e){case"boolean":case"number":case"string":case"undefined":case"object":return e;default:return""}}function X(e){var n=e.type;return(e=e.nodeName)&&"input"===e.toLowerCase()&&("checkbox"===n||"radio"===n)}function G(e){var n,t,r=X(e)?"checked":"value",l=Object.getOwnPropertyDescriptor(e.constructor.prototype,r),a=""+e[r];if(!e.hasOwnProperty(r)&&void 0!==l&&"function"==typeof l.get&&"function"==typeof l.set)return n=l.get,t=l.set,Object.defineProperty(e,r,{configurable:!0,get:function(){return n.call(this)},set:function(e){a=""+e,t.call(this,e)}}),Object.defineProperty(e,r,{enumerable:l.enumerable}),{getValue:function(){return a},setValue:function(e){a=""+e},stopTracking:function(){e._valueTracker=null,delete e[r]}}}function Z(e){e._valueTracker||(e._valueTracker=G(e))}function J(e){var n,t,r;return!(!e||(n=e._valueTracker)&&(t=n.getValue(),r="",(e=r=e?X(e)?e.checked?"true":"false":e.value:r)===t||(n.setValue(e),0)))}function ee(n){if(void 0===(n=n||("undefined"!=typeof document?document:void 0)))return null;try{return n.activeElement||n.body}catch(e){return n.body}}function ne(e,n){var t=n.checked;return g({},n,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:null!=t?t:e._wrapperState.initialChecked})}function te(e,n){var t=null==n.defaultValue?"":n.defaultValue,r=null!=n.checked?n.checked:n.defaultChecked,t=Y(null!=n.value?n.value:t);e._wrapperState={initialChecked:r,initialValue:t,controlled:"checkbox"===n.type||"radio"===n.type?null!=n.checked:null!=n.value}}function re(e,n){null!=(n=n.checked)&&B(e,"checked",n,!1)}function le(e,n){re(e,n);var t=Y(n.value),r=n.type;if(null!=t)"number"===r?(0===t&&""===e.value||e.value!=t)&&(e.value=""+t):e.value!==""+t&&(e.value=""+t);else if("submit"===r||"reset"===r)return void e.removeAttribute("value");n.hasOwnProperty("value")?oe(e,n.type,t):n.hasOwnProperty("defaultValue")&&oe(e,n.type,Y(n.defaultValue)),null==n.checked&&null!=n.defaultChecked&&(e.defaultChecked=!!n.defaultChecked)}function ae(e,n,t){if(n.hasOwnProperty("value")||n.hasOwnProperty("defaultValue")){var r=n.type;if(("submit"===r||"reset"===r)&&null==n.value)return;n=""+e._wrapperState.initialValue,t||n===e.value||(e.value=n),e.defaultValue=n}""!==(t=e.name)&&(e.name=""),e.defaultChecked=!!e._wrapperState.initialChecked,""!==t&&(e.name=t)}function oe(e,n,t){"number"===n&&ee(e.ownerDocument)===e||(null==t?e.defaultValue=""+e._wrapperState.initialValue:e.defaultValue!==""+t&&(e.defaultValue=""+t))}function ue(e,n,t,r){if(e=e.options,n){n={};for(var l=0;l>>=0)?32:31-(iu(e)/su|0)|0}function Re(e){switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return 4194240&e;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return 130023424&e;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 1073741824;default:return e}}function De(e,n){var t=e.pendingLanes;if(0===t)return 0;var r,l=0,a=e.suspendedLanes,o=e.pingedLanes,u=268435455&t;if(0!==u?0!==(r=u&~a)?l=Re(r):0!==(o&=u)&&(l=Re(o)):0!==(u=t&~a)?l=Re(u):0!==o&&(l=Re(o)),0===l)return 0;if(0!==n&&n!==l&&0==(n&a)&&((o=n&-n)<=(a=l&-l)||16===a&&0!=(4194240&o)))return n;if(0!=(4&l)&&(l|=16&t),0!==(n=e.entangledLanes))for(e=e.entanglements,n&=l;0>=r,a-=r,Xi=1<<32-uu(n)+a|t<u?(i=o,o=null):i=o.sibling;var s=y(n,o,t[u],r);if(null===s){null===o&&(o=i);break}f&&o&&null===s.alternate&&d(n,o),e=h(s,e,u),null===a?l=s:a.sibling=s,a=s,o=i}if(u===t.length)p(n,o);else if(null===o)for(;uu?(i=o,o=null):i=o.sibling;var c=y(n,o,s.value,r);if(null===c){null===o&&(o=i);break}f&&o&&null===c.alternate&&d(n,o),e=h(c,e,u),null===a?l=c:a.sibling=c,a=c,o=i}if(s.done)p(n,o);else if(null===o)for(;!s.done;u++,s=t.next())null!==(s=g(n,s.value,r))&&(e=h(s,e,u),null===a?l=s:a.sibling=s,a=s);else{for(o=m(n,o);!s.done;u++,s=t.next())null!==(s=v(o,n,u,s.value,r))&&(f&&null!==s.alternate&&o.delete(null===s.key?u:s.key),e=h(s,e,u),null===a?l=s:a.sibling=s,a=s);f&&o.forEach(function(e){return d(n,e)})}return E&&vt(n,u),l}function w(e,n,t,r){if("object"==typeof(t="object"==typeof t&&null!==t&&t.type===co&&null===t.key?t.props.children:t)&&null!==t){switch(t.$$typeof){case io:e:{for(var l=t.key,a=n;null!==a;){if(a.key===l){if((l=t.type)===co){if(7===a.tag){p(e,a.sibling),(n=o(a,t.props.children)).return=e,e=n;break e}}else if(a.elementType===l||"object"==typeof l&&null!==l&&l.$$typeof===ko&&Mt(l)===a.type){p(e,a.sibling),(n=o(a,t.props)).ref=Lt(e,a,t),n.return=e,e=n;break e}p(e,a);break}d(e,a),a=a.sibling}e=t.type===co?((n=za(t.props.children,e.mode,r,t.key)).return=e,n):((r=Na(t.type,t.key,t.props,null,e.mode,r)).ref=Lt(e,n,t),r.return=e,r)}return u(e);case so:e:{for(a=t.key;null!==n;){if(n.key===a){if(4===n.tag&&n.stateNode.containerInfo===t.containerInfo&&n.stateNode.implementation===t.implementation){p(e,n.sibling),(n=o(n,t.children||[])).return=e,e=n;break e}p(e,n);break}d(e,n),n=n.sibling}(n=La(t,e.mode,r)).return=e,e=n}return u(e);case ko:return w(e,n,(a=t._init)(t._payload),r)}if(Eo(t))return b(e,n,t,r);if(H(t))return k(e,n,t,r);Tt(e,t)}return"string"==typeof t&&""!==t||"number"==typeof t?(t=""+t,(n=null!==n&&6===n.tag?(p(e,n.sibling),o(n,t)):(p(e,n),_a(t,e.mode,r))).return=e,u(e=n)):p(e,n)}return w}function Rt(){os=as=ls=null}function Dt(e,n){n=rs.current,s(rs),e._currentValue=n}function Ot(e,n,t){for(;null!==e;){var r=e.alternate;if((e.childLanes&n)!==n?(e.childLanes|=n,null!==r&&(r.childLanes|=n)):null!==r&&(r.childLanes&n)!==n&&(r.childLanes|=n),e===t)break;e=e.return}}function It(e,n){(os=as=null)!==(e=(ls=e).dependencies)&&null!==e.firstContext&&(0!=(e.lanes&n)&&(_=!0),e.firstContext=null)}function Ut(e){var n=e._currentValue;if(os!==e)if(e={context:e,memoizedValue:n,next:null},null===as){if(null===ls)throw Error(S(308));as=e,ls.dependencies={lanes:0,firstContext:e}}else as=as.next=e;return n}function Vt(e){null===us?us=[e]:us.push(e)}function At(e,n,t,r){var l=n.interleaved;return null===l?(t.next=t,Vt(n)):(t.next=l.next,l.next=t),n.interleaved=t,Wt(e,r)}function Wt(e,n){e.lanes|=n;var t=e.alternate;for(null!==t&&(t.lanes|=n),e=(t=e).return;null!==e;)e.childLanes|=n,null!==(t=e.alternate)&&(t.childLanes|=n),e=(t=e).return;return 3===t.tag?t.stateNode:null}function Bt(e){e.updateQueue={baseState:e.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,interleaved:null,lanes:0},effects:null}}function Ht(e,n){e=e.updateQueue,n.updateQueue===e&&(n.updateQueue={baseState:e.baseState,firstBaseUpdate:e.firstBaseUpdate,lastBaseUpdate:e.lastBaseUpdate,shared:e.shared,effects:e.effects})}function Qt(e,n){return{eventTime:e,lane:n,tag:0,payload:null,callback:null,next:null}}function jt(e,n,t){var r,l=e.updateQueue;return null===l?null:(l=l.shared,(0!=(2&F)?(null===(r=l.pending)?n.next=n:(n.next=r.next,r.next=n),l.pending=n,is):(null===(r=l.interleaved)?(n.next=n,Vt(l)):(n.next=r.next,r.next=n),l.interleaved=n,Wt))(e,t))}function $t(e,n,t){var r;null!==(n=n.updateQueue)&&(n=n.shared,0!=(4194240&t))&&(r=n.lanes,r&=e.pendingLanes,He(e,n.lanes=t|=r))}function qt(e,n){var t=e.updateQueue,r=e.alternate;if(null!==r&&t===(r=r.updateQueue)){var l=null,a=null;if(null!==(t=t.firstBaseUpdate)){do{var o={eventTime:t.eventTime,lane:t.lane,tag:t.tag,payload:t.payload,callback:t.callback,next:null}}while(null===a?l=a=o:a=a.next=o,null!==(t=t.next));null===a?l=a=n:a=a.next=n}else l=a=n;t={baseState:r.baseState,firstBaseUpdate:l,lastBaseUpdate:a,shared:r.shared,effects:r.effects},e.updateQueue=t}else null===(e=t.lastBaseUpdate)?t.firstBaseUpdate=n:e.next=n,t.lastBaseUpdate=n}function Kt(e,n,t,r){var l,a,o=e.updateQueue,u=(ss=!1,o.firstBaseUpdate),i=o.lastBaseUpdate;if(null!==(f=o.shared.pending)&&(o.shared.pending=null,a=(l=f).next,(l.next=null)===i?u=a:i.next=a,i=l,null!==(c=e.alternate))&&(f=(c=c.updateQueue).lastBaseUpdate)!==i&&(null===f?c.firstBaseUpdate=a:f.next=a,c.lastBaseUpdate=l),null!==u){for(var s=o.baseState,i=0,c=a=l=null,f=u;;){var d=f.lane,p=f.eventTime;if((r&d)===d){null!==c&&(c=c.next={eventTime:p,lane:0,tag:f.tag,payload:f.payload,callback:f.callback,next:null});e:{var m=e,h=f,d=n,p=t;switch(h.tag){case 1:if("function"==typeof(m=h.payload)){s=m.call(p,s,d);break e}s=m;break e;case 3:m.flags=-65537&m.flags|128;case 0:if(null==(d="function"==typeof(m=h.payload)?m.call(p,s,d):m))break e;s=g({},s,d);break e;case 2:ss=!0}}null!==f.callback&&0!==f.lane&&(e.flags|=64,null===(d=o.effects)?o.effects=[f]:d.push(f))}else p={eventTime:p,lane:d,tag:f.tag,payload:f.payload,callback:f.callback,next:null},null===c?(a=c=p,l=s):c=c.next=p,i|=d;if(null===(f=f.next)){if(null===(f=o.shared.pending))break;f=(d=f).next,d.next=null,o.lastBaseUpdate=d,o.shared.pending=null}}if(null===c&&(l=s),o.baseState=l,o.firstBaseUpdate=a,o.lastBaseUpdate=c,null!==(n=o.shared.interleaved))for(o=n;i|=o.lane,(o=o.next)!==n;);else null===u&&(o.shared.lanes=0);Qs|=i,e.lanes=i,e.memoizedState=s}}function Yt(e,n,t){if(e=n.effects,(n.effects=null)!==e)for(n=0;n<\\/script>",e=e.removeChild(e.firstChild)):"string"==typeof r.is?e=o.createElement(t,{is:r.is}):(e=o.createElement(t),"select"===t&&(o=e,r.multiple?o.multiple=!0:r.size&&(o.size=r.size))):e=o.createElementNS(e,t),e[Li]=n,e[Ti]=r,Ls(e,n,!1,!1),n.stateNode=e;e:{switch(o=ye(t,r),t){case"dialog":c("cancel",e),c("close",e),a=r;break;case"iframe":case"object":case"embed":c("load",e),a=r;break;case"video":case"audio":for(a=0;aYs&&(n.flags|=128,wl(i,!(r=!0)),n.lanes=4194304)}else{if(!r)if(null!==(e=nr(o))){if(n.flags|=128,r=!0,null!==(t=e.updateQueue)&&(n.updateQueue=t,n.flags|=4),wl(i,!0),null===i.tail&&"hidden"===i.tailMode&&!o.alternate&&!E)return p(n),null}else 2*y()-i.renderingStartTime>Ys&&1073741824!==t&&(n.flags|=128,wl(i,!(r=!0)),n.lanes=4194304);i.isBackwards?(o.sibling=n.child,n.child=o):(null!==(t=i.last)?t.sibling=o:n.child=o,i.last=o)}if(null!==i.tail)return n=i.tail,i.rendering=n,i.tail=n.sibling,i.renderingStartTime=y(),n.sibling=null,t=C.current,f(C,r?1&t|2:1&t),n}return p(n),null;case 22:case 23:return O=Bs.current,s(Bs),r=null!==n.memoizedState,null!==e&&null!==e.memoizedState!==r&&(n.flags|=8192),r&&0!=(1&n.mode)?0!=(1073741824&O)&&(p(n),6&n.subtreeFlags)&&(n.flags|=8192):p(n),null;case 24:case 25:return null}throw Error(S(156,n.tag))}function xl(e,n,t){switch(wt(n),n.tag){case 1:return h(n.type)&&(s(b),s(v)),65536&(e=n.flags)?(n.flags=-65537&e|128,n):null;case 3:return Zt(),s(b),s(v),tr(),0!=(65536&(e=n.flags))&&0==(128&e)?(n.flags=-65537&e|128,n):null;case 5:return er(n),null;case 13:if(s(C),null!==(e=n.memoizedState)&&null!==e.dehydrated){if(null===n.alternate)throw Error(S(340));Pt()}return 65536&(e=n.flags)?(n.flags=-65537&e|128,n):null;case 19:return s(C),null;case 4:return Zt(),null;case 10:return Dt(n.type._context),null;case 22:case 23:return O=Bs.current,s(Bs),null;default:return null}}function El(n,t){var e=n.ref;if(null!==e)if("function"==typeof e)try{e(null)}catch(e){w(n,t,e)}else e.current=null}function Cl(n,t,e){try{e()}catch(e){w(n,t,e)}}function Nl(e,n){if(Ei=Su,Dn(e=Rn())){if("selectionStart"in e)var t={start:e.selectionStart,end:e.selectionEnd};else e:if((a=(t=(t=e.ownerDocument)&&t.defaultView||window).getSelection&&t.getSelection())&&0!==a.rangeCount){var t=a.anchorNode,r=a.anchorOffset,l=a.focusNode,a=a.focusOffset;try{t.nodeType,l.nodeType}catch(e){t=null;break e}var o,u=0,i=-1,s=-1,c=0,f=0,d=e,p=null;n:for(;;){for(;d!==t||0!==r&&3!==d.nodeType||(i=u+r),d!==l||0!==a&&3!==d.nodeType||(s=u+a),3===d.nodeType&&(u+=d.nodeValue.length),null!==(o=d.firstChild);)p=d,d=o;for(;;){if(d===e)break n;if(p===t&&++c===r&&(i=u),p===l&&++f===a&&(s=u),null!==(o=d.nextSibling))break;p=(d=p).parentNode}d=o}t=-1===i||-1===s?null:{start:i,end:s}}else t=null;t=t||{start:0,end:0}}else t=null;for(Su=!(Ci={focusedElem:e,selectionRange:t}),T=n;null!==T;)if(e=(n=T).child,0!=(1028&n.subtreeFlags)&&null!==e)e.return=n,T=e;else for(;null!==T;){n=T;try{var m,h,g,y,v=n.alternate;if(0!=(1024&n.flags))switch(n.tag){case 0:case 11:case 15:break;case 1:null!==v&&(m=v.memoizedProps,h=v.memoizedState,y=(g=n.stateNode).getSnapshotBeforeUpdate(n.elementType===n.type?m:Ar(n.type,m),h),g.__reactInternalSnapshotBeforeUpdate=y);break;case 3:var b=n.stateNode.containerInfo;1===b.nodeType?b.textContent="":9===b.nodeType&&b.documentElement&&b.removeChild(b.documentElement);break;case 5:case 6:case 4:case 17:break;default:throw Error(S(163))}}catch(e){w(n,n.return,e)}if(null!==(e=n.sibling)){e.return=n.return,T=e;break}T=n.return}return v=Os,Os=!1,v}function zl(e,n,t){var r=n.updateQueue;if(null!==(r=null!==r?r.lastEffect:null)){var l,a=r=r.next;do{}while((a.tag&e)===e&&(l=a.destroy,(a.destroy=void 0)!==l)&&Cl(n,t,l),(a=a.next)!==r)}}function Pl(e,n){if(null!==(n=null!==(n=n.updateQueue)?n.lastEffect:null)){var t,r=n=n.next;do{}while((r.tag&e)===e&&(t=r.create,r.destroy=t()),(r=r.next)!==n)}}function _l(e){var n,t=e.ref;null!==t&&(n=e.stateNode,e.tag,e=n,"function"==typeof t?t(e):t.current=e)}function Ll(e){var n=e.alternate;null!==n&&(e.alternate=null,Ll(n)),e.child=null,e.deletions=null,e.sibling=null,5===e.tag&&null!==(n=e.stateNode)&&(delete n[Li],delete n[Ti],delete n[Fi],delete n[Ri],delete n[Di]),e.stateNode=null,e.return=null,e.dependencies=null,e.memoizedProps=null,e.memoizedState=null,e.pendingProps=null,e.stateNode=null,e.updateQueue=null}function Tl(e){return 5===e.tag||3===e.tag||4===e.tag}function Ml(e){e:for(;;){for(;null===e.sibling;){if(null===e.return||Tl(e.return))return null;e=e.return}for(e.sibling.return=e.return,e=e.sibling;5!==e.tag&&6!==e.tag&&18!==e.tag;){if(2&e.flags)continue e;if(null===e.child||4===e.tag)continue e;e=(e.child.return=e).child}if(!(2&e.flags))return e.stateNode}}function Fl(e,n,t){var r=e.tag;if(5===r||6===r)e=e.stateNode,n?(8===t.nodeType?t.parentNode:t).insertBefore(e,n):(8===t.nodeType?(n=t.parentNode).insertBefore(e,t):(n=t).appendChild(e),null==(t=t._reactRootContainer)&&null===n.onclick&&(n.onclick=Jn));else if(4!==r&&null!==(e=e.child))for(Fl(e,n,t),e=e.sibling;null!==e;)Fl(e,n,t),e=e.sibling}function Rl(e,n,t){var r=e.tag;if(5===r||6===r)e=e.stateNode,n?t.insertBefore(e,n):t.appendChild(e);else if(4!==r&&null!==(e=e.child))for(Rl(e,n,t),e=e.sibling;null!==e;)Rl(e,n,t),e=e.sibling}function Dl(e,n,t){for(t=t.child;null!==t;)Ol(e,n,t),t=t.sibling}function Ol(e,n,t){if(ou&&"function"==typeof ou.onCommitFiberUnmount)try{ou.onCommitFiberUnmount(au,t)}catch(e){}switch(t.tag){case 5:L||El(t,n);case 6:var r=M,l=Is;M=null,Dl(e,n,t),Is=l,null!==(M=r)&&(Is?(e=M,t=t.stateNode,(8===e.nodeType?e.parentNode:e).removeChild(t)):M.removeChild(t.stateNode));break;case 18:null!==M&&(Is?(e=M,t=t.stateNode,8===e.nodeType?tt(e.parentNode,t):1===e.nodeType&&tt(e,t),Je(e)):tt(M,t.stateNode));break;case 4:r=M,l=Is,M=t.stateNode.containerInfo,Is=!0,Dl(e,n,t),M=r,Is=l;break;case 0:case 11:case 14:case 15:if(!L&&null!==(r=t.updateQueue)&&null!==(r=r.lastEffect)){l=r=r.next;do{var a=(o=l).destroy,o=o.tag}while(void 0===a||0==(2&o)&&0==(4&o)||Cl(t,n,a),(l=l.next)!==r)}Dl(e,n,t);break;case 1:if(!L&&(El(t,n),"function"==typeof(r=t.stateNode).componentWillUnmount))try{r.props=t.memoizedProps,r.state=t.memoizedState,r.componentWillUnmount()}catch(e){w(t,n,e)}Dl(e,n,t);break;case 21:Dl(e,n,t);break;case 22:1&t.mode?(L=(r=L)||null!==t.memoizedState,Dl(e,n,t),L=r):Dl(e,n,t);break;default:Dl(e,n,t)}}function Il(t){var r,e=t.updateQueue;null!==e&&((t.updateQueue=null)===(r=t.stateNode)&&(r=t.stateNode=new Ds),e.forEach(function(e){var n=ka.bind(null,t,e);r.has(e)||(r.add(e),e.then(n,n))}))}function Ul(e,n,t){if(null!==(t=n.deletions))for(var r=0;r