From 55661f79f9ba2c8da612762b32db791c9135de3e Mon Sep 17 00:00:00 2001 From: Entscheider <> Date: Wed, 18 May 2016 13:52:32 +0200 Subject: [PATCH] Adding Files --- CMakeLists.txt | 25 + Readme.md | 115 +++++ apps/3DTest/CMakeLists.txt | 10 + apps/3DTest/Readme.md | 39 ++ apps/3DTest/exporter.cpp | 142 +++++ apps/3DTest/exporter.h | 16 + apps/3DTest/main.cpp | 84 +++ apps/3DTest/parser.cpp | 81 +++ apps/3DTest/parser.h | 36 ++ apps/CMakeLists.txt | 6 + apps/SimpleTest/CMakeLists.txt | 10 + apps/SimpleTest/Readme.md | 25 + apps/SimpleTest/main.cpp | 186 +++++++ apps/SuperPixelGui/CMakeLists.txt | 54 ++ apps/SuperPixelGui/UndoManager.h | 58 +++ .../cmake/MacOSXBundleInfo.plist.in | 40 ++ apps/SuperPixelGui/genIcns.sh | 13 + apps/SuperPixelGui/imgwdg.cpp | 196 +++++++ apps/SuperPixelGui/imgwdg.h | 243 +++++++++ apps/SuperPixelGui/main.cpp | 13 + apps/SuperPixelGui/mainwindow.cpp | 487 ++++++++++++++++++ apps/SuperPixelGui/mainwindow.h | 155 ++++++ apps/SuperPixelGui/superpi.icns | Bin 0 -> 326074 bytes apps/SuperPixelGui/superpi.png | Bin 0 -> 132960 bytes apps/SuperPixelGui/superpixelgui.qrc | 5 + apps/SuperPixelGui/utils.cpp | 206 ++++++++ apps/SuperPixelGui/utils.h | 14 + cmake_uninstall.cmake.in | 22 + lib/3rd/ThreadPool.h | 102 ++++ lib/CMakeLists.txt | 25 + lib/Pixel/ClusterSet.cpp | 109 ++++ lib/Pixel/ClusterSet.h | 130 +++++ lib/Pixel/RSlic2.cpp | 130 +++++ lib/Pixel/RSlic2.h | 137 +++++ lib/Pixel/RSlic2Draw.cpp | 112 ++++ lib/Pixel/RSlic2Draw.h | 45 ++ lib/Pixel/RSlic2Util.cpp | 129 +++++ lib/Pixel/RSlic2Util.h | 100 ++++ lib/Pixel/RSlic2_impl.h | 428 +++++++++++++++ lib/RSlic.h | 5 + lib/RSlic2H.h | 12 + lib/RSlic3H.h | 10 + lib/Voxel/ClusterSet.cpp | 115 +++++ lib/Voxel/ClusterSet.h | 133 +++++ lib/Voxel/RSlic3.cpp | 126 +++++ lib/Voxel/RSlic3.h | 237 +++++++++ lib/Voxel/RSlic3Utils.cpp | 107 ++++ lib/Voxel/RSlic3Utils.h | 131 +++++ lib/Voxel/RSlic3_impl.h | 387 ++++++++++++++ lib/priv/Useful.h | 133 +++++ lib/priv/ZeroSlico_p.h | 27 + lib/rslic-config.cmake | 17 + 52 files changed, 5168 insertions(+) create mode 100644 CMakeLists.txt create mode 100644 Readme.md create mode 100644 apps/3DTest/CMakeLists.txt create mode 100644 apps/3DTest/Readme.md create mode 100644 apps/3DTest/exporter.cpp create mode 100644 apps/3DTest/exporter.h create mode 100644 apps/3DTest/main.cpp create mode 100644 apps/3DTest/parser.cpp create mode 100644 apps/3DTest/parser.h create mode 100644 apps/CMakeLists.txt create mode 100644 apps/SimpleTest/CMakeLists.txt create mode 100644 apps/SimpleTest/Readme.md create mode 100644 apps/SimpleTest/main.cpp create mode 100644 apps/SuperPixelGui/CMakeLists.txt create mode 100644 apps/SuperPixelGui/UndoManager.h create mode 100644 apps/SuperPixelGui/cmake/MacOSXBundleInfo.plist.in create mode 100644 apps/SuperPixelGui/genIcns.sh create mode 100644 apps/SuperPixelGui/imgwdg.cpp create mode 100644 apps/SuperPixelGui/imgwdg.h create mode 100644 apps/SuperPixelGui/main.cpp create mode 100644 apps/SuperPixelGui/mainwindow.cpp create mode 100644 apps/SuperPixelGui/mainwindow.h create mode 100644 apps/SuperPixelGui/superpi.icns create mode 100644 apps/SuperPixelGui/superpi.png create mode 100644 apps/SuperPixelGui/superpixelgui.qrc create mode 100644 apps/SuperPixelGui/utils.cpp create mode 100644 apps/SuperPixelGui/utils.h create mode 100644 cmake_uninstall.cmake.in create mode 100644 lib/3rd/ThreadPool.h create mode 100644 lib/CMakeLists.txt create mode 100644 lib/Pixel/ClusterSet.cpp create mode 100644 lib/Pixel/ClusterSet.h create mode 100644 lib/Pixel/RSlic2.cpp create mode 100644 lib/Pixel/RSlic2.h create mode 100644 lib/Pixel/RSlic2Draw.cpp create mode 100644 lib/Pixel/RSlic2Draw.h create mode 100644 lib/Pixel/RSlic2Util.cpp create mode 100644 lib/Pixel/RSlic2Util.h create mode 100644 lib/Pixel/RSlic2_impl.h create mode 100644 lib/RSlic.h create mode 100644 lib/RSlic2H.h create mode 100644 lib/RSlic3H.h create mode 100644 lib/Voxel/ClusterSet.cpp create mode 100644 lib/Voxel/ClusterSet.h create mode 100644 lib/Voxel/RSlic3.cpp create mode 100644 lib/Voxel/RSlic3.h create mode 100644 lib/Voxel/RSlic3Utils.cpp create mode 100644 lib/Voxel/RSlic3Utils.h create mode 100644 lib/Voxel/RSlic3_impl.h create mode 100644 lib/priv/Useful.h create mode 100644 lib/priv/ZeroSlico_p.h create mode 100644 lib/rslic-config.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..7872745 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,25 @@ +cmake_minimum_required(VERSION 2.8.4) +project(RSlic) + +include(CheckCXXCompilerFlag) +CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11) +CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X) + +if(COMPILER_SUPPORTS_CXX11) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") +elseif(COMPILER_SUPPORTS_CXX0X) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x") +else() + message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.") +endif() + +add_subdirectory(apps) +add_subdirectory(lib) + +configure_file( + "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in" + "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" + IMMEDIATE @ONLY) + +add_custom_target(uninstall + COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) diff --git a/Readme.md b/Readme.md new file mode 100644 index 0000000..4aae62a --- /dev/null +++ b/Readme.md @@ -0,0 +1,115 @@ +# Overview +RSlic is a library written in C++ for computing Superpixel and Supervoxel using OpenCV. It based on the Slic-Algorithmus (http://ivrg.epfl.ch/research/superpixels). + +# Features +- Compute Superpixel and Supervoxel +- Support for the zero parameter version of the SLIC algorithm (SLICO) +- Support for custom metrics +- Ability to save any iteration while computing (e.g. SuperPixelGUI makes use of it) + +# Dependency +To build RSlic you need: +- OpenCV +- CMake +- optional: ccmake or cmake-gui for a configuration interface +- C++11 Compiler (e.g. gcc or clang) +- Qt4 or Qt5 for GUI-Apps + +# Installing +Go into the source directory and run: + +``` +$ mkdir build && cd build +$ cmake .. +$ make +$ make install +``` + +Or run *ccmake* if you want to configure somethings before building. (E.g. you can disable thread usage. Or prefer Qt4 over Qt5) + +# Create a project +## CMakeLists +Create a CMakeLists.txt for your project. If your project has the name myproj, the CMakeLists.txt should contains something like: + +``` + find_package(RSlic REQUIRED) +include_directories(${RSLIC_INCLUDE_DIRS}) +add_executable(myproj main.cpp ...) +target_link_libraries(myproj ${RSLIC_LIB}) +``` + +By the way: Your project will (and have to) use C++11 now. + +## Including the files +If you would like to use Superpixel the simplest way would be to import RSlic/RSlic2H.h: + +```cpp +#include +``` + +and if you want to use Supervoxel: + +```cpp +#include +``` +Of course you can use Superpixel and Supervoxel at the same time. + +## Simple introduction RSlic +Executing the Slic-Algorithmus is very simple. Let's say you have a gray image img, want n Superpixel with a special stiffness. Then: + +```cpp +#include +using namespace RSlic::Pixel; +.... +Mat grad = buildGrad(img); //Build the gradient for the algorithm +int w = m.cols; +int h = m.rows; +int step = sqrt(w * h * 1.0 / n); //Calc the step-width +Slic2P slic = Slic2::initialize(img,grad,step,stiffness); //Initialize with the parameter +for (int i=0; i < 10; i++){ //Do 10 Iterations + slic = slic->iterate(); + //slic = slic->iterateZero(); //For the zero parameter version +} +slic = slic->finalize(); +``` + +Now you can work with *slic*. Mainly you want to use +*slic->getClusters()*. See the documentation for more details. + +You're not sure if you have a gray image or a colorful one? + +```cpp +#include +using namespace RSlic::Pixel; +.... +Mat grad = buildGrad(img); //Build the gradient for the algorithms +int w = m.cols; +int h = m.rows; +int step = sqrt(w * h * 1.0 / n); //Calc the step-width +Slic2P slic = Slic2::initialize(img,grad,step,stiffness); //Initialize with the parameter +for (int i=0; i < 10; i++){ //Do 10 Iterations + slic = iteratingHelper(slic, img.type()); + // slic = iteratingHelper(slic, img.type(), true); //For the zero parameter version +} +slic = slic->finalize(); + ``` + +You think that's not simple enough? OK, an easier version: +```cpp +#include +using namespace RSlic::Pixel; +.... +//10-Iterations +Slic2P slic = shutUpAndTakeMyMoney(img, n, hardness, false, 10); +//10-Iterations with Slico +//Slic2P slic = shutUpAndTakeMyMoney(img, n, hardness, true, 10); +``` + +Note that Slic is often intended to be applied on top of LAB images. So you may want to convert your image before using the functions above. (Use OpenCV for this) + +# 3rd Party Code +This library uses the ThreaPool file from https://github.com/progschj/ThreadPool. +The RSlic library uses threads if 'PARALLEL' is enabled in CMakeCache. + +# License +BSD license diff --git a/apps/3DTest/CMakeLists.txt b/apps/3DTest/CMakeLists.txt new file mode 100644 index 0000000..b9c0757 --- /dev/null +++ b/apps/3DTest/CMakeLists.txt @@ -0,0 +1,10 @@ + project(3DTest) + +find_package( OpenCV REQUIRED ) +include_directories ("${3DTest_SOURCE_DIR}/../../lib") +set(CMAKE_INCLUDE_CURRENT_DIR ON) + +set(SOURCE_FILES main.cpp parser.cpp exporter.cpp) +add_executable(3DTest ${SOURCE_FILES}) + +target_link_libraries(3DTest rslic ${OpenCV_LIBS}) diff --git a/apps/3DTest/Readme.md b/apps/3DTest/Readme.md new file mode 100644 index 0000000..d0dac60 --- /dev/null +++ b/apps/3DTest/Readme.md @@ -0,0 +1,39 @@ +# 3DTest + +3DTest is a program which creates a point cloud from several images with Supervoxel. +The export format is ply. + +Additionally, a window appears which shows the result in pictures. +The following keys help navigate through these pictures: + +- a Go a picture backward +- s Go a picture forward +- t Toggle between showing contour in z-direction +- d Show some debug information +- q Close the window + +The following arguments are allowed on the command line: + +- -c Number of Supervoxel (optional) +- -m Stiffness (optional) +- -t Number of threads to be used (optional) +- -0 Use Slico (optional) +- -h Show some help and exit +- -o Output filename for the point cloud. (optional). The points cloud will only exported if a filename is set. +- pictures + +Some command can like this: + +` +./3DTest -c 39000 -m 40 -i 10 -o out.ply pic001.tif pic002.tif +` + +` +./3DTest -0 -o out.ply img/*.tif +` + +or without exporting: + +` +./3DTest img/*.tif +` diff --git a/apps/3DTest/exporter.cpp b/apps/3DTest/exporter.cpp new file mode 100644 index 0000000..eaa73a0 --- /dev/null +++ b/apps/3DTest/exporter.cpp @@ -0,0 +1,142 @@ +#include "exporter.h" +#include +#include +using namespace std; +using namespace RSlic::Voxel; + +// Return coordinates of points which are between clusters +// mask.empty => ignore mask +vector contourVertex(Slic3P p, const Mat &mask) { + Mat_ clusters = p->getClusters().getClusterLabel(); + int w = clusters.size[1]; + int h = clusters.size[0]; + int d = clusters.size[2]; + vector res; + for (int x = 0; x < w - 1; x++) { + for (int y = 0; y < h - 1; y++) { + for (int t = 0; t < d - 1; t++) { + if (clusters.at(y, x, t) != clusters.at(y, x, t + 1) + || clusters.at(y, x, t) != clusters.at(y, x + 1, t) + || clusters.at(y, x, t) != clusters.at(y + 1, x, t)){ + if (!mask.empty() && mask.at(y,x,t) == 0) continue; + res.push_back(Vec3i(x, y, t)); + } + } + } + } + return res; +} + +void exportPLY(const vector &vertex, const string &filename,RSlic::Voxel::MovieCacheP img, const string & comments) { + ofstream out; + out.open(filename); + if (out.fail()) { + cout << "[ERROR] Opening " << filename << " failed" << endl; + return; + } + out << "ply" << endl; + if (!comments.empty()) + out << "comment " <type() == CV_8UC1) color = Vec3b::all(img->at(y,x,z)); + else if (img->type()==CV_8UC3) color = img->at(y,x,z); + int r = color[1] , g = color[0],b = color[2]; + out << x << ' ' << y << ' ' << z + << ' ' << r <<' ' << g << ' ' << b < +template +void showNrIntern(cv::Mat labels, int i, bool tIgnore, Mat &img, T value){ + for (int x = 1; x < img.cols - 1; x++) { + for (int y = 1; y < img.rows - 1; y++) { + if (labels.at(y, x, i) < 0){ + std::cout<<"Fail"; + continue; + } + if ((labels.at(y, x, i) != labels.at(y, x + 1, i) + || labels.at(y, x, i) != labels.at(y, x - 1, i) + || labels.at(y, x, i) != labels.at(y + 1, x, i) + || labels.at(y, x, i) != labels.at(y - 1, x, i)) + && (tIgnore || (labels.at(y, x, i) == labels.at(y, x, i-1) + && labels.at(y, x, i) == labels.at(y, x, i+1) + )) + ) + img.at(y, x) = value; + } + } +} + +// Get a 2-D image visualization +// tIgnore: ignore time-dimension for cluster contour +void showNr(Slic3P p, int i, bool tIgnore) { + auto img = p->getImg()->matAt(i).clone(); + auto labels = p->getClusters().getClusterLabel(); + if (img.type()==CV_8UC3){ + cv::cvtColor(img, img, cv::COLOR_Lab2BGR); + showNrIntern(labels,i,tIgnore,img,Vec3b(255,255,255)); + }else{ + showNrIntern(labels,i,tIgnore,img,255); + } + + imshow("Hi", img); +} +#include + +// Show first image +// and handling for key events +void showFirst(Slic3P p) { + int i = 0; + const int d = p->getImg()->duration(); + bool tIgnore(false); + showNr(p, i, tIgnore); + char c; + do { + c = waitKey(-1); + if (c == 's') { + i = min(i + 1, d - 1); + showNr(p, i, tIgnore); + } + else if (c == 't'){ + tIgnore = !tIgnore; + showNr(p,i,tIgnore); + } + else if (c == 'a') { + i = max(i - 1, 0); + showNr(p, i, tIgnore); + }else if (c=='d'){ + auto labels = p->getClusters().getClusterLabel(); + std::cout<<"Nr. "< set; + auto img = p->getImg()->matAt(i); + for (int x = 1; x < img.cols - 1; x++) { + for (int y = 1; y < img.rows - 1; y++) { + set.insert(labels.at(y,x,i)); + } + } + for (ClusterInt c : set){ + std::cout< +#include + +void exportPLY(const std::vector &vertex, const std::string &filename, RSlic::Voxel::MovieCacheP img, const string &comments = string()); + +std::vector contourVertex(RSlic::Voxel::Slic3P p, const Mat & mask = Mat()); + + +void showNr(RSlic::Voxel::Slic3P p, int i, bool tIgnore); + +void showFirst(RSlic::Voxel::Slic3P p); + +#endif // EXPORTER_H diff --git a/apps/3DTest/main.cpp b/apps/3DTest/main.cpp new file mode 100644 index 0000000..a6e0026 --- /dev/null +++ b/apps/3DTest/main.cpp @@ -0,0 +1,84 @@ +#include +#include +#include <3rd/ThreadPool.h> + +#include "parser.h" +#include "exporter.h" + +using namespace RSlic::Voxel; +using namespace std; + +template +auto measureTime(std::function function) -> std::tuple> { + std::chrono::time_point start, end; + start = std::chrono::system_clock::now(); + T res = function(); + end = std::chrono::system_clock::now(); + return std::make_tuple(res, end - start); +} + +template +auto measureTimeV(std::function function) -> std::chrono::duration { + std::chrono::time_point start, end; + start = std::chrono::system_clock::now(); + function(); + end = std::chrono::system_clock::now(); + return end - start; +} + +MovieCacheP loadFiles(MainSetting *s) { + return std::make_shared(s->filenames); +} + +int main(int argc, char **argv) { + MainSetting *settings = parseSetting(argc, argv); + if (settings == nullptr) return -1; + + MovieCacheP img = loadFiles(settings); + cout << "Width: " << img->width() << ", Height: " << img->height() + << " Duration: " << img->duration() << endl; + auto s = pow(img->width() * img->height() * img->duration() *1.0 / settings->count,0.333); + if (std::min(img->duration(), std::min(img->width(), img->height())) <= s / 2) { + cout << "[Warning] Not enough pictures. At least " << s << " pictures are recommended" << endl; + } + Slic3P slic; + if (settings->threadcount <=0) settings->threadcount=std::thread::hardware_concurrency(); + ThreadPoolP pool = std::make_shared(settings->threadcount); + slic = Slic3::initialize(img, buildGradColor, s, settings->stiffness, pool); + + if (slic.get() == nullptr) { + cout << "[ERROR] Not able to perform the algorithm. May you should play with the parameters." << endl; + return -1; + } + //showFirst(slic); + + // Iteration + std::cout << "* Process: 0 of " << settings->iterations << std::flush; + auto res = measureTimeV([&]() { + for (int i = 0; i < settings->iterations; i++) { + std::cout << '\r' << "* Process: " << i + 1 << " of " << settings->iterations << std::flush; + slic = RSlic::Voxel::iterateHelper(slic,img->type(),settings->slico); + if (slic == nullptr){ + cout << "This image type is not currently supported " << endl; + exit(EXIT_FAILURE); + } + //showFirst(slic); + } + }); + cout<<" - Needed "<type(),slic->finalize); //Cluster finalizing + showFirst(slic); + std::cout << " Finish" << std::endl; + if (!settings->outputfile.empty()) { + cout << "* Exporting " << std::flush; + Mat mask; + stringstream str; + str << "iterations: "<iterations << ", stiffness: "<stiffness <<", count: "<count; + str << ", Slico?: "<< (settings->slico?"true":"false") ; + exportPLY(contourVertex(slic,mask), settings->outputfile,img,str.str()); + std::cout << " Finish" << std::endl; + } + delete settings; +} diff --git a/apps/3DTest/parser.cpp b/apps/3DTest/parser.cpp new file mode 100644 index 0000000..746f049 --- /dev/null +++ b/apps/3DTest/parser.cpp @@ -0,0 +1,81 @@ +#include "parser.h" +#include + +using namespace std; + +bool file_exist(const char *filename) { + struct stat buffer; + return (stat(filename, &buffer) == 0); +} + +ostream &operator<<(ostream &str, const vector &list) { + str << "["; + for (const string s: list) { + str << s << ","; + } + str << "]"; + return str; +} + + +void printHelp(char *name) { + MainSetting *tmp = new MainSetting; + cout << "Program to create Supervoxel from images" << endl; + cout << name << " [-c ...] [-m ...] [-i ...] [-h] [-0] [-t ...] filename1 filename2 ... filename n [-o ...] " << endl; + cout << "-c a: Set the number of Supervoxels to a (a is a number, default " << tmp->count << ")" << endl; + cout << "-m a: Set stiffness to a (a is a number, default " << tmp->stiffness << ")" << endl; + cout << "-i a: Set iteration count to a (a is a number, default " << tmp->iterations << ")" << endl; + cout << "-o a: Set the output ply file to a. If not set, there will be no export." << endl; + cout << "-t a: Set the number of thread to be used. -1 does automatically detecting. (a is a number, default " << tmp->threadcount << ")" << endl; + cout << "-0: Use Slico algorithms. -m will be ignored (default "<< (tmp->slico?"true":"false")<<")" << endl; + cout << "-h: Print this help" << endl; + cout << "filenames: Set the filename of the image to convert (filename is a list the path, required)" << endl; + delete tmp; +} + +MainSetting *parseSetting(int argc, char **argv) { + if (argc < 2) { + std::cout << "[Error] Not enough arguments" << std::endl; + printHelp(argv[0]); + return nullptr; + } + MainSetting *res = new MainSetting(); + for (int i = 1; i < argc; i++) { + if (strcmp(argv[i], "-c") == 0 && i + 1 < argc) { + res->count = atoi(argv[i + 1]); + i++; + } else if (strcmp(argv[i], "-m") == 0 && i + 1 < argc) { + res->stiffness = atoi(argv[i + 1]); + i++; + } else if (strcmp(argv[i], "-i") == 0 && i + 1 < argc) { + res->iterations = atoi(argv[i + 1]); + i++; + } else if (strcmp(argv[i], "-h") == 0) { + delete res; + printHelp(argv[0]); + return nullptr; + } else if (strcmp(argv[i], "-o") == 0 && i + 1 < argc) { + res->outputfile = argv[i + 1]; + i++; + } else if (strcmp(argv[i], "-t") == 0 && i + 1 < argc) { + res->threadcount = atoi(argv[i + 1]); + i++; + } else if (strcmp(argv[i], "-0") == 0) { + res->slico = true; + }else { + char *filename = argv[i]; + if (!file_exist(filename)) { + cout << "[Error] File " << filename << " does not exists" << std::endl; + delete res; + return nullptr; + } + res->filenames.push_back(filename); + } + } + if (res->filenames.empty()){ //FIXME: Check for whitespace and similar + printHelp(argv[0]); + delete res; + return nullptr; + } + return res; +} diff --git a/apps/3DTest/parser.h b/apps/3DTest/parser.h new file mode 100644 index 0000000..931fd55 --- /dev/null +++ b/apps/3DTest/parser.h @@ -0,0 +1,36 @@ +#ifndef PARSER_H +#define PARSER_H + +#include +#include +#include + +bool file_exist(const char *filename); + +std::ostream &operator<<(std::ostream &str, const std::vector &list); + +struct MainSetting { + MainSetting() : count(32400), stiffness(40), + threadcount(-1), iterations(10), slico(false) {} + + std::vector filenames; + std::string outputfile; + int count; + int stiffness; + int iterations; + bool slico; + int threadcount; + + void print() { + std::cout << "[] Iterations " << iterations << std::endl; + std::cout << "[] Count " << count << std::endl; + std::cout << "[] stiffness " << stiffness << std::endl; + std::cout << "[] filenames " << filenames << std::endl; + } +}; + +void printHelp(char *name); + +MainSetting *parseSetting(int argc, char **argv); + +#endif // PARSER_H diff --git a/apps/CMakeLists.txt b/apps/CMakeLists.txt new file mode 100644 index 0000000..7e48e7b --- /dev/null +++ b/apps/CMakeLists.txt @@ -0,0 +1,6 @@ +add_subdirectory(SimpleTest) +add_subdirectory(3DTest) +option(GUI "Compile GUI" ON) +IF(${GUI}) + add_subdirectory(SuperPixelGui) +ENDIF() diff --git a/apps/SimpleTest/CMakeLists.txt b/apps/SimpleTest/CMakeLists.txt new file mode 100644 index 0000000..b4b48b5 --- /dev/null +++ b/apps/SimpleTest/CMakeLists.txt @@ -0,0 +1,10 @@ +project(SimpleTest) + +find_package( OpenCV REQUIRED ) +include_directories ("${SimpleTest_SOURCE_DIR}/../../lib") +set(CMAKE_INCLUDE_CURRENT_DIR ON) + +set(SOURCE_FILES main.cpp) +add_executable(SimpleTest ${SOURCE_FILES}) + +target_link_libraries(SimpleTest rslic ${OpenCV_LIBS}) diff --git a/apps/SimpleTest/Readme.md b/apps/SimpleTest/Readme.md new file mode 100644 index 0000000..5e55562 --- /dev/null +++ b/apps/SimpleTest/Readme.md @@ -0,0 +1,25 @@ +#SimpleTest + +Little application for showing pictures with Superpixel. + +Parameters: + +- -c Number of Superpixel (optional) +- -m Stiffness (optional) +- -i Number of iterations (optional) +- -0 Use Slico. Ignores -i (optional) +- -t Number of threads to be used. +- -h Show help +- Filename of the picture + +For the window following keys are accepted: + +- q Close the Window +- -b Set contour black +- -w Set contour white + +For example: + +- `./SimpleTest -c 400 -m 40 -i 10 pic.png` +- `./SimpleTest -0 pic.png` +- `./SimpleTest pic.png` diff --git a/apps/SimpleTest/main.cpp b/apps/SimpleTest/main.cpp new file mode 100644 index 0000000..1a56dff --- /dev/null +++ b/apps/SimpleTest/main.cpp @@ -0,0 +1,186 @@ +#include +#include +#include +#include <3rd/ThreadPool.h> + +using namespace RSlic; + +inline void showImg(const ClusterSet &cl, const cv::Mat &img, const string &name, bool white) { + int gray = white ? 255 : 0; + Vec3b color = white ? Vec3b(255, 255, 255) : Vec3b(0, 0, 0); + switch (img.type()) { + case CV_8UC3: + //cvtColor(img,res,CV_Lab2BGR); + cv::imshow(name, contourCluster(drawCluster(img, cl), cl, color)); + cv::imshow(name + "orig", contourCluster(img, cl, color)); + break; + case CV_8UC1: + cv::imshow(name, contourCluster(drawCluster(img, cl), cl, gray)); + cv::imshow(name + "orig", contourCluster(img, cl, gray)); + break; + } +} + +inline void showClusters(const ClusterSet &cl, const cv::Mat &img, const std::string &name) { + //cv::Mat res; + showImg(cl, img, name, false); + char key = -1; + while (key != 'q') { + key = cv::waitKey(-1); + if (key == 'b') { + showImg(cl, img, name, false); + } else if (key == 'w') { + showImg(cl, img, name, true); + } + } +} + +#include + +bool file_exist(const char *filename) { + struct stat buffer; + return (stat(filename, &buffer) == 0); +} + +struct MainSetting { + MainSetting() : count(400), stiffness(40), iterations(10), slico(false), threadcount(-1) { + } + + string filename; + int count; + int stiffness; + int iterations; + bool slico; + int threadcount; + + int guessthreadcount() { + if (threadcount <= 0) + return std::thread::hardware_concurrency(); + return threadcount; + } + + void print() { + std::cout << "[] Iterations " << iterations << endl; + std::cout << "[] Count " << count << endl; + std::cout << "[] stiffness " << stiffness << endl; + std::cout << "[] filename " << filename << endl; + std::cout << "[] slico " << slico << endl; + std::cout << "[] threadcount " << threadcount << endl; + } +}; + +void printHelp(char *name) { + MainSetting *tmp = new MainSetting; + cout << "Create Superpixel from an image" << endl; + cout << name << " [-c ...] [-m ...] [-i ...] [-o] [-h] [-t ...] filename " << endl; + cout << "-c a: Set the number of superpixel to a (a is a number, default " << tmp->count << ")" << endl; + cout << "-m a: Set stiffness to a (a is a number, default " << tmp->stiffness << ")" << endl; + cout << "-i a: Set iteration count to a (a is a number, default " << tmp->iterations << ")" << endl; + cout << "-0: Use Slico (zero-parameter variant of Slic, default " << tmp->slico << ", -m will be ignored)" << endl; + cout << "-t a: Set the number of thread to be used to a (a is a number, default " << tmp->threadcount << ")" << endl; + cout << "-h: Print this help" << endl; + cout << "filename: Set the filename of the image to convert (filename is the path)" << endl; + delete tmp; +} + +MainSetting *parseSetting(int argc, char **argv) { + if (argc < 2) { + std::cout << "[Error] Not enough arguments" << std::endl; + printHelp(argv[0]); + return nullptr; + } + MainSetting *res = new MainSetting(); + for (int i = 1; i < argc; i++) { + if (strcmp(argv[i], "-c") == 0 && i + 1 < argc) { + res->count = atoi(argv[i + 1]); + i++; + } else if (strcmp(argv[i], "-m") == 0 && i + 1 < argc) { + res->stiffness = atoi(argv[i + 1]); + i++; + } else if (strcmp(argv[i], "-i") == 0 && i + 1 < argc) { + res->iterations = atoi(argv[i + 1]); + i++; + } else if (strcmp(argv[i], "-0") == 0) { + res->slico = true; + } else if (strcmp(argv[i], "-h") == 0) { + delete res; + printHelp(argv[0]); + return nullptr; + } else + res->filename = argv[i]; + } + if (res->filename.empty()) { //FIXME: Check for whitespace and similar + printHelp(argv[0]); + delete res; + return nullptr; + } + if (!file_exist(res->filename.c_str())) { + cout << "[Error] File " << res->filename << " does not exists" << std::endl; + delete res; + return nullptr; + } + return res; +} + +int main(int argc, char **argv) { + MainSetting *settings = parseSetting(argc, argv); + if (settings == nullptr) return -1; + if (settings->slico) settings->stiffness = 1; +#ifdef DEBUG_ME + settings->print(); +#endif + + auto img = cv::imread(settings->filename, cv::IMREAD_UNCHANGED); + if (img.type() == CV_8UC4) { + cv::cvtColor(img, img, CV_BGRA2BGR); + } + auto grad = buildGrad(img); + + cout << "Image Type: " << getType(img) << ", Gradient: " << getType(grad) << endl; + + auto s = sqrt(img.cols * img.rows / settings->count); + + Slic2P slic; + ThreadPoolP pool = std::make_shared(settings->guessthreadcount()); + Mat img_lab; + + switch (img.type()) { + case CV_8UC3: + cvtColor(img, img_lab, CV_BGR2Lab); // See paper + slic = Slic2::initialize(img_lab, grad, s, settings->stiffness, pool); + break; + case CV_8UC1: + slic = Slic2::initialize(img, grad, s, settings->stiffness, pool); + break; + default: + cout << "This image type is not currently supported " << endl; + return -1; + } + cv::imshow("orig", img); + +#ifdef DEBUG_ME + showClusters(slic->getClusters(), img, "res"); +#endif + // Iteration + std::cout << "* Process: 0 from " << settings->iterations << std::flush; + for (int i = 0; i < settings->iterations; i++) { + std::cout << '\r' << "* Process: " << i + 1 << " from " << settings->iterations << std::flush; + slic = RSlic::Pixel::iteratingHelper(slic,img.type(),settings->slico); +#ifdef DEBUG_ME + showClusters(slic->getClusters(), img, std::string("res_")+std::to_string(i)); +#endif + } + + std::cout << std::endl << "* Finalize Clusters..." << std::flush; + if (img.type() == CV_8UC1){ + distanceGray g; + slic = slic->finalize(g); + }else{ + distanceColor c; + slic = slic->finalize(c); + } + std::cout << " Finish" << std::endl << "* Drawing Clusters..." << std::flush; + std::cout << " Finish" << std::endl << "Press q to quit" << std::endl << std::flush; + delete settings; + showClusters(slic->getClusters(), img, "result"); +} diff --git a/apps/SuperPixelGui/CMakeLists.txt b/apps/SuperPixelGui/CMakeLists.txt new file mode 100644 index 0000000..35bc564 --- /dev/null +++ b/apps/SuperPixelGui/CMakeLists.txt @@ -0,0 +1,54 @@ +project(SuperPixelGui) +cmake_minimum_required(VERSION 2.8.11) + +find_package( OpenCV REQUIRED ) +option(Qt5 "Use Qt5 instead of Qt4 if available" ON) + +set(CMAKE_MODULE_PATH ${SuperPixelGui_SOURCE_DIR}/cmake) + +include_directories ("${SuperPixelGui_SOURCE_DIR}/../../lib") +set(CMAKE_INCLUDE_CURRENT_DIR ON) +set(SOURCE_FILES main.cpp mainwindow.cpp utils.cpp imgwdg.cpp ) + +# OSX-Bundle Settings +IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin") + set(MACOSX_BUNDLE_ICON_FILE superpi.icns) + SET(MACOSX_BUNDLE_BUNDLE_NAME SuperPixelGUI) + set(app_icon ${SuperPixelGui_SOURCE_DIR}/superpi.icns) + set_source_files_properties(${app_icon} PROPERTIES MACOSX_PACKAGE_LOCATION "Resources") +ENDIF() + +# Allowed to use Qt5? +IF(${Qt5}) + find_package(Qt5Widgets) + Set(Qt5_FOUND ${Qt5Widgets_FOUND}) +ELSE (${Qt5}) + Set(Qt5_FOUND false) +ENDIF() + +IF (Qt5_FOUND) + set(CMAKE_AUTOMOC ON) + QT5_ADD_RESOURCES( RES ${SuperPixelGui_SOURCE_DIR}/superpixelgui.qrc) + IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin") + add_executable(SuperPixelGui MACOSX_BUNDLE ${app_icon} ${SOURCE_FILES}) + ELSE() + add_executable(SuperPixelGui ${SOURCE_FILES} ${RES}) + ENDIF() + target_link_libraries(SuperPixelGui rslic ${OpenCV_LIBS} Qt5::Core Qt5::Widgets ) +ELSE (Qt5_FOUND) + find_package(Qt4 COMPONENTS QTCORE QTGUI) + IF (Qt4_FOUND) + INCLUDE(${QT_USE_FILE}) + ADD_DEFINITIONS(${QT_DEFINITIONS}) + QT4_WRAP_CPP(SOURCE_FILES_HEADERS_MOC imgwdg.h mainwindow.h) + QT4_ADD_RESOURCES( RES ${SuperPixelGui_SOURCE_DIR}/superpixelgui.qrc) + IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin") + ADD_EXECUTABLE(SuperPixelGui MACOSX_BUNDLE ${app_icon} ${SOURCE_FILES} ${SOURCE_FILES_HEADERS_MOC}) + ELSE() + ADD_EXECUTABLE(SuperPixelGui ${SOURCE_FILES} ${SOURCE_FILES_HEADERS_MOC} ${RES}) + ENDIF() + TARGET_LINK_LIBRARIES(SuperPixelGui rslic ${OpenCV_LIBS} ${QT_LIBRARIES}) + ENDIF(Qt4_FOUND) +ENDIF(Qt5_FOUND) + +install(TARGETS SuperPixelGui DESTINATION bin) diff --git a/apps/SuperPixelGui/UndoManager.h b/apps/SuperPixelGui/UndoManager.h new file mode 100644 index 0000000..194fe22 --- /dev/null +++ b/apps/SuperPixelGui/UndoManager.h @@ -0,0 +1,58 @@ +#ifndef UNDOMANAGER_H +#define UNDOMANAGER_H + +#include + +// T -> What type +// N -> Length of history +template +class UndoManager { +public: + constexpr UndoManager() noexcept: beg(0),end(0),pos(-1){} + UndoManager(const UndoManager & other): beg(other.beg), end(other.end), pos(other.pos){ + for (int i = 0; i < N; i++) { + array[i] = other.array[i]; + } + } + void pushItem(){ + pos = (pos+1)%N; + end = (pos+1)%N; //Always: pos < end ! + if (beg == end) beg = (beg+1)%N; + } + const T* getItem() const{ + if (validIdx(pos)) + return &array[pos]; + return nullptr; + } + T* getItem(){ + if (validIdx(pos)) + return &array[pos]; + return nullptr; + } + void undo(){ + if (undoAvailable()) pos=(pos-1)%N; + } + void redo(){ + if (redoAvailable()) pos=(pos+1)%N; + } + bool undoAvailable(){ + return validIdx((pos-1)%N); + } + bool redoAvailable(){ + return validIdx((pos+1)%N); + } +protected: + bool validIdx(int idx) const{ + if (idx >= N || idx <0) return false; + if (beg < end){ + return beg<= idx && idx < end; + }else if (end < beg){ + return beg <= idx || idx < end; + } + return false; + } +private: + std::array array; + int beg, end, pos; //beg <= pos + + + + CFBundleDevelopmentRegion + English + CFBundleExecutable + ${MACOSX_BUNDLE_EXECUTABLE_NAME} + CFBundleGetInfoString + ${MACOSX_BUNDLE_INFO_STRING} + CFBundleIconFile + ${MACOSX_BUNDLE_ICON_FILE} + CFBundleIdentifier + ${MACOSX_BUNDLE_GUI_IDENTIFIER} + CFBundleInfoDictionaryVersion + 6.0 + CFBundleLongVersionString + ${MACOSX_BUNDLE_LONG_VERSION_STRING} + CFBundleName + ${MACOSX_BUNDLE_BUNDLE_NAME} + CFBundlePackageType + APPL + CFBundleShortVersionString + ${MACOSX_BUNDLE_SHORT_VERSION_STRING} + CFBundleSignature + ???? + CFBundleVersion + ${MACOSX_BUNDLE_BUNDLE_VERSION} + CSResourcesFileMapped + + LSRequiresCarbon + + NSHumanReadableCopyright + ${MACOSX_BUNDLE_COPYRIGHT} + NSPrincipalClass + NSApplication + NSHighResolutionCapable + + + diff --git a/apps/SuperPixelGui/genIcns.sh b/apps/SuperPixelGui/genIcns.sh new file mode 100644 index 0000000..4b5ad87 --- /dev/null +++ b/apps/SuperPixelGui/genIcns.sh @@ -0,0 +1,13 @@ +mkdir superpi.iconset +sips -z 16 16 superpi.png --out superpi.iconset/icon_16x16.png +sips -z 32 32 superpi.png --out superpi.iconset/icon_16x16@2x.png +sips -z 32 32 superpi.png --out superpi.iconset/icon_32x32.png +sips -z 64 64 superpi.png --out superpi.iconset/icon_32x32@2x.png +sips -z 128 128 superpi.png --out superpi.iconset/icon_128x128.png +sips -z 256 256 superpi.png --out superpi.iconset/icon_128x128@2x.png +sips -z 256 256 superpi.png --out superpi.iconset/icon_256x256.png +sips -z 512 512 superpi.png --out superpi.iconset/icon_256x256@2x.png +sips -z 512 512 superpi.png --out superpi.iconset/icon_512x512.png +sips -z 1024 1024 superpi.png --out superpi.iconset/icon_512x512.png +iconutil -c icns superpi.iconset +rm -r superpi.iconset diff --git a/apps/SuperPixelGui/imgwdg.cpp b/apps/SuperPixelGui/imgwdg.cpp new file mode 100644 index 0000000..43791e5 --- /dev/null +++ b/apps/SuperPixelGui/imgwdg.cpp @@ -0,0 +1,196 @@ +#include "imgwdg.h" +#include "utils.h" +#include + +TripleImageConversion::TripleImageConversion() : img(nullptr), mat(nullptr), data(nullptr) { +} + +void TripleImageConversion::setImg(const QImage &img) { + auto tmp = new QImage(img); + setImg(QPixmap::fromImage(img)); + this->img = tmp; +} + + +void TripleImageConversion::setImg(const QPixmap &px) { + this->pxm = px; + if (img != nullptr) delete img; + img = nullptr; + if (mat != nullptr) delete mat; + mat = nullptr; +} + +void TripleImageConversion::setImg(const cv::Mat &mat) { + auto tmp = new cv::Mat(mat); + setImg(utils::mat2QImage(mat)); + this->mat = tmp; +} + + +QImage TripleImageConversion::getImg() { + if (img == nullptr) { + img = new QImage(pxm.toImage()); + } + return *img; +} + +cv::Mat TripleImageConversion::getMat() { + if (mat == nullptr) { + mat = new cv::Mat(utils::qImage2Mat(getImg())); + } + return *mat; +} + +QPixmap TripleImageConversion::getPixmap() const { + return pxm; +} + +bool TripleImageConversion::isSet() const { + return !pxm.isNull(); +} + + +void TripleImageConversion::clean() { + if (data != nullptr) { + data->decrement(); + if (data->zeroReference()) delete data; + } + if (img != nullptr) delete img; + if (mat != nullptr) delete mat; + img = nullptr; + pxm = QPixmap(); + mat = nullptr; + data = nullptr; +} + +TripleImageConversion::~TripleImageConversion() { + clean(); +} + +void ImgWdg::init() { + this->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + this->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + pitem = new QGraphicsPixmapItem(); + scene = new QGraphicsScene(); + scene->addItem(pitem); + setScene(scene); +} + +ImgWdg::ImgWdg(QWidget *parent) : QGraphicsView(parent) { + init(); +} + +ImgWdg::ImgWdg(ImgWdg *other, QWidget *parent) : QGraphicsView(parent), history(other->history) { + init(); + reloadPixmap(); +} + +void ImgWdg::resizeEvent(QResizeEvent *event) { + QGraphicsView::resizeEvent(event); + this->fitInView(pitem, Qt::KeepAspectRatio); +} + +TripleImageConversion *ImgWdg::currentImage() { + return history.getItem(); +} + +const TripleImageConversion *ImgWdg::currentImage() const { + return history.getItem(); +} + +TripleImageConversion *ImgWdg::createOne() { + history.pushItem(); + history.getItem()->clean(); + return history.getItem(); +} + + +void ImgWdg::reloadPixmap() { + auto current = currentImage(); + if (current == nullptr) return; + pitem->setPixmap(current->getPixmap()); + this->fitInView(pitem, Qt::KeepAspectRatio); +} + +void ImgWdg::showImg(const QImage &img) { + createOne()->setImg(img); + reloadPixmap(); +} + +void ImgWdg::showImg(const QPixmap &px) { + createOne()->setImg(px); + reloadPixmap(); +} + +void ImgWdg::showImg(const cv::Mat &mat) { + createOne()->setImg(mat); + reloadPixmap(); +} + +void ImgWdg::replaceImg(const QImage & img){ + auto item = history.getItem(); + item->clean(); + item->setImg(img); + reloadPixmap(); +} + +void ImgWdg::replaceImg(const QPixmap & img){ + auto item = history.getItem(); + item->clean(); + item->setImg(img); + reloadPixmap(); +} + +void ImgWdg::replaceImg(const cv::Mat & img){ + auto item = history.getItem(); + item->clean(); + item->setImg(img); + reloadPixmap(); +} + + +QImage ImgWdg::getImg() { + auto current = currentImage(); + if (current != nullptr) + return current->getImg(); + return QImage(); +} + +cv::Mat ImgWdg::getMat() { + auto current = currentImage(); + if (current != nullptr) + return current->getMat(); + return cv::Mat(); +} + +QPixmap ImgWdg::getPixmap() const { + auto current = currentImage(); + if (current != nullptr) + return current->getPixmap(); + return QPixmap(); +} + +void ImgWdg::goNext() { + history.redo(); + reloadPixmap(); +} + +void ImgWdg::goPrev() { + history.undo(); + reloadPixmap(); +} + + +bool ImgWdg::hasNext() { + return history.redoAvailable(); +} + +bool ImgWdg::hasPrev() { + return history.undoAvailable(); +} + + +ImgWdg::~ImgWdg() { +} + + diff --git a/apps/SuperPixelGui/imgwdg.h b/apps/SuperPixelGui/imgwdg.h new file mode 100644 index 0000000..96dc71b --- /dev/null +++ b/apps/SuperPixelGui/imgwdg.h @@ -0,0 +1,243 @@ +#ifndef IMGWDG_H +#define IMGWDG_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "UndoManager.h" + +namespace priv { + template + class TripleImageConversionData; + + class TripleImageData { + public: + TripleImageData() : reference(0) { + } + + virtual ~TripleImageData() { + } + + virtual const std::type_info &type_info() const = 0; + + void increment() { + reference++; + } + + void decrement() { + reference--; + } + + bool zeroReference() { + return reference == 0; + } + + int refCount() const{return reference;} + + template + std::unique_ptr & getData(); + + template + const std::unique_ptr & getData() const; + + private: + int reference; + }; + + template + class TripleImageConversionData : public TripleImageData { + public: + TripleImageConversionData(std::unique_ptr && d) { + data = std::move(d); + } + + ~TripleImageConversionData(){ + } + + std::unique_ptr & getData() { + return data; + } + + const std::unique_ptr & getData() const{ + return data; + } + + virtual const std::type_info &type_info() const { + return typeid(T); + } + + private: + std::unique_ptr data; + }; + + + template + std::unique_ptr &TripleImageData::getData() { + static std::unique_ptr nullp; + if (type_info() == typeid(T)) + return static_cast *>(this)->getData(); + return nullp; + } + template + const std::unique_ptr& TripleImageData::getData() const{ + const static std::unique_ptr nullp; + if (type_info() == typeid(T)) + return static_cast *>(this)->getData(); + return nullp; + } +} + +// Automatically convert between QImage, QPixmap and cv::Mat +class TripleImageConversion { + public: + TripleImageConversion(); + + TripleImageConversion(const TripleImageConversion &other) : img(nullptr), mat(nullptr), pxm(other.pxm) { + if (other.img != nullptr) img = new QImage(*other.img); + if (other.mat != nullptr) mat = new cv::Mat(*other.mat); + if (other.data != nullptr) { + data = other.data; + data->increment(); + } + } + + TripleImageConversion &operator=(const TripleImageConversion &other) { + clean(); + pxm = other.pxm.copy(); + if (other.img != nullptr) { + img = new QImage(*other.img); + } + if (other.mat != nullptr) { + mat = new cv::Mat(*other.mat); + } + if (other.data != nullptr) { + data = other.data; + data->increment(); + } + return *this; + } + + void setImg(const QImage &img); + + void setImg(const QPixmap &px); + + void setImg(const cv::Mat &mat); + + bool isSet() const; + + void clean(); + + template + void setMoreData(std::unique_ptr && p) { + if (data != nullptr) { + data->decrement(); + if (data->zeroReference()) delete data; + } + data = new priv::TripleImageConversionData(std::move(p)); + data->increment(); + }; + + template + const std::unique_ptr & moreData() const{ + static std::unique_ptr nullp; + if (data != nullptr) { + return data->getData(); + } + return nullp; + } + + template + std::unique_ptr & moreData() { + static std::unique_ptr nullp; + if (data != nullptr) { + if (data->refCount()>1){ + data->decrement(); + data = new priv::TripleImageConversionData( + std::unique_ptr(new T(*data->getData())) + ); + data->increment(); + } + return data->getData(); + } + return nullp; + } + + QImage getImg(); + + cv::Mat getMat(); + + QPixmap getPixmap() const; + + virtual ~TripleImageConversion(); + + private: + QPixmap pxm; + QImage *img; + cv::Mat *mat; + priv::TripleImageData *data; +}; + +// Show images with history (5 images in history) +class ImgWdg : public QGraphicsView { + Q_OBJECT + public: + explicit ImgWdg(QWidget *parent = nullptr); + + ImgWdg(ImgWdg *other, QWidget *parent = nullptr); + + void showImg(const QImage &img); + + void showImg(const QPixmap &px); + + void showImg(const cv::Mat &mat); + + void replaceImg(const QImage & img); + + void replaceImg(const QPixmap & px); + + void replaceImg(const cv::Mat & mat); + + void reloadPixmap(); + + QImage getImg(); + + cv::Mat getMat(); + + QPixmap getPixmap() const; + + virtual ~ImgWdg(); + + TripleImageConversion *currentImage(); + + const TripleImageConversion *currentImage() const; + + bool hasNext(); + + bool hasPrev(); + + public slots: + void goNext(); + + void goPrev(); + + protected: + TripleImageConversion *createOne(); + + void resizeEvent(QResizeEvent *event); + + private: + void init(); + QGraphicsScene *scene; + QGraphicsPixmapItem *pitem; + UndoManager history; +}; + +#endif // IMGWDG_H diff --git a/apps/SuperPixelGui/main.cpp b/apps/SuperPixelGui/main.cpp new file mode 100644 index 0000000..83a9b99 --- /dev/null +++ b/apps/SuperPixelGui/main.cpp @@ -0,0 +1,13 @@ +#include +#include "mainwindow.h" + +int main(int argc, char **argv) { + QApplication app(argc, argv); + MainWindow w; +#ifndef Q_OS_OSX + QIcon icon(":/superpi.png"); + w.setWindowIcon(icon); +#endif + w.show(); + return app.exec(); +} diff --git a/apps/SuperPixelGui/mainwindow.cpp b/apps/SuperPixelGui/mainwindow.cpp new file mode 100644 index 0000000..5d4a115 --- /dev/null +++ b/apps/SuperPixelGui/mainwindow.cpp @@ -0,0 +1,487 @@ +#include "mainwindow.h" +#include "utils.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0)) +#define QStringLiteral QString +#endif + +struct superpixeldata { + vector slicv; + cv::Mat mat; + bool drawContour = true; + bool fillCluster = false; + int currentIdx = 0; + Vec3b color = Vec3b(0,0,0); + + RSlic::Pixel::Slic2P currentItem(){ + assert(0<= currentIdx && currentIdx <= slicv.size()); + return slicv[currentIdx]; + } +}; + +WorkerObject::WorkerObject(ThreadPoolP p, QObject *parent) : QObject(parent), pool(p) { +} + +void WorkerObject::work(cv::Mat m, SlicSetting *settings, QWidget* tabwdg) { + std::chrono::time_point start, end; + start = std::chrono::system_clock::now(); + + int step = sqrt(m.cols * m.rows / settings->count); + auto grad = RSlic::Pixel::buildGrad(m); + emit message(tr("Initializing Slic ...")); + auto slic = RSlic::Pixel::Slic2::initialize(utils::makeLabIfNecessary(m), grad, step, settings->stiffness, pool); + if (slic.get() == nullptr) { + emit failed(tr("Wrong Parameter"), tr("No Superpixel can be build. May you should play with the parameters")); + return; + } + emit message(tr("Iterating")); + vector iterators; + if (settings->saveIterations) + iterators.reserve(settings->iteration); + for (int i = 0; i < settings->iteration; i++) { + if (settings->slico) + slic = slic->iterateZero(RSlic::Pixel::distanceColor()); + else + slic = slic->iterate(RSlic::Pixel::distanceColor()); + if (settings->saveIterations) + iterators.push_back(slic); + emit message(tr("Iterating %1 of %2").arg(i + 1).arg(settings->iteration)); + emit progress((i + 1) * 100 / (settings->iteration + 1)); + } + emit message(tr("Finalizing ...")); + slic = slic->finalize(RSlic::Pixel::distanceColor()); + + end = std::chrono::system_clock::now(); + std::chrono::duration elapsed_seconds = end-start; + + iterators.push_back(slic); + emit finished(std::move(iterators),tabwdg); + emit message(tr("Needed %1 sec").arg(elapsed_seconds.count())); +} + +MainWindow::MainWindow(QWidget *parent) : + QMainWindow(parent), settings(nullptr) { + qRegisterMetaType(); + qRegisterMetaType("cv::Mat const&"); + qRegisterMetaType("SlicSetting*"); + qRegisterMetaType("shared_ptrconst&"); + qRegisterMetaType>("vectorconst&"); + + this->setWindowTitle(QStringLiteral("SuperPixelGui")); + this->setUnifiedTitleAndToolBarOnMac(true); + this->setAcceptDrops(true); + tabs = new QTabWidget(this); + tabs->setMovable(true); + tabs->setDocumentMode(true); + tabs->setTabsClosable(true); + connect(tabs, SIGNAL(currentChanged(int)), SLOT(updateTitleForIndex(int))); + connect(tabs, SIGNAL(currentChanged(int)), SLOT(updateActions())); + connect(tabs, SIGNAL(tabCloseRequested(int)),SLOT(closeTab(int))); + setCentralWidget(tabs); + + worker = new WorkerObject(std::make_shared(std::thread::hardware_concurrency())); + worker->moveToThread(&workerThread); + workerThread.start(); + + connect(worker, SIGNAL(failed( + const QString &, const QString &)), this, SLOT(onWorkerFailed( + const QString &, const QString &)), Qt::QueuedConnection); + connect(worker, SIGNAL(finished(vector,QWidget*)), this, SLOT(onWorkerFinished(vector,QWidget*)), Qt::QueuedConnection); + connect(worker, SIGNAL(progress(int)), this, SLOT(onWorkerProgress(int)), Qt::QueuedConnection); + connect(worker, SIGNAL(message( + const QString&)), this, SLOT(onWorkerMessage( + const QString &))); + + colorDlg = new QColorDialog(this); + colorDlg->setCurrentColor(QColor(0,0,0)); + connect(colorDlg,SIGNAL(colorSelected(QColor)),SLOT(setDrawColor(QColor))); + + auto style = QApplication::style(); + + QToolBar *bar = this->addToolBar(tr("File")); + QToolBar* viewbar = this->addToolBar(tr("View")); + bar->addAction(style->standardIcon(QStyle::SP_DialogOpenButton), "Load...", this, SLOT(loadImage())); + bar->addAction(style->standardIcon(QStyle::SP_DialogSaveButton), "Save...", this, SLOT(saveImage())); + colorClusterAction = new QAction("Color", this); + colorClusterAction->setCheckable(true); + colorClusterAction->setChecked(true); + connect(colorClusterAction, SIGNAL(triggered(bool)), SLOT(setClusterFill(bool))); + viewbar->addAction(colorClusterAction); + drawContourAction = new QAction("Draw", this); + drawContourAction->setCheckable(true); + colorClusterAction->setChecked(true); + connect(drawContourAction, SIGNAL(triggered(bool)), SLOT(setClusterContour(bool))); + viewbar->addAction(drawContourAction); + viewbar->addAction("Set Color",colorDlg,SLOT(open())); + bar->addSeparator(); + goPrevAction = bar->addAction(style->standardIcon(QStyle::SP_ArrowLeft), "Prev", this, SLOT(goPrev())); + goNextAction = bar->addAction(style->standardIcon(QStyle::SP_ArrowRight), "Next", this, SLOT(goNext())); + bar->addSeparator(); + bar->addAction("Dupl", this, SLOT(duplicate())); + bar->addAction("Close", this, SLOT(closeCurrentTab()));; + slicIdxSlider = new QSlider(Qt::Horizontal); + slicIdxSlider->setTracking(false); + slicIdxSlider->setValue(0); + slicIdxSlider->setMaximum(1); + slicIdxSlider->setEnabled(true); + connect(slicIdxSlider,SIGNAL(valueChanged(int)),this,SLOT(setSlicIdx(int))); + viewbar->addSeparator(); + viewbar->addWidget(slicIdxSlider); + + QDockWidget *dock = new QDockWidget("Slic", this); + settingWdg = new SlicSettingWidget(dock); + connect(settingWdg, SIGNAL(activate()), this, SLOT(doSuperpixel())); + dock->setWidget(settingWdg); + this->addDockWidget(Qt::LeftDockWidgetArea, dock); + + progressbar = new QProgressBar(this); + progressbar->setRange(0, 100); + this->statusBar()->addPermanentWidget(progressbar); + } + +void MainWindow::setSlicIdx(int i){ + auto& data = currentData(); + if (data == nullptr) return; + data->currentIdx = i; + repaintImg(); +} + +void MainWindow::setDrawColor(const QColor & c){ + auto & data = currentDataConst(); + auto oldColor = data->color; + data->color = Vec3b(c.blue(),c.green(),c.red()); + if (data->drawContour && data->color != oldColor) + repaintImg(); +} + +void MainWindow::goNext() { + ImgWdg *imgwdg = qobject_cast(tabs->currentWidget()); + if (imgwdg == nullptr) return; + imgwdg->goNext(); + updateActions(); +} + +void MainWindow::goPrev() { + ImgWdg *imgwdg = qobject_cast(tabs->currentWidget()); + if (imgwdg == nullptr) return; + imgwdg->goPrev(); + updateActions(); +} + +void MainWindow::onWorkerProgress(int i) { + progressbar->setValue(i); +} + +void MainWindow::onWorkerFinished(vector res,QWidget* wdg) { + settingWdg->setEnabled(true); + this->statusBar()->clearMessage(); + progressbar->setValue(0); + + int idx = tabs->indexOf(wdg); + if (idx < 0) return; // Tab was closed while processing + ImgWdg *imgwdg = qobject_cast(wdg); + if (imgwdg == nullptr) return; + tabs->setCurrentIndex(idx); + + cv::Mat m(imgwdg->getMat()); + imgwdg->showImg(m); + auto more = imgwdg->currentImage(); + if (more != nullptr) { + superpixeldata *data = new superpixeldata; + data->mat = m; + data->slicv = std::move(res); + data->currentIdx = data->slicv.size()-1; + data->drawContour = drawContourAction->isChecked(); + data->fillCluster = colorClusterAction->isChecked(); + auto color = colorDlg->currentColor(); + data->color = Vec3b(color.blue(),color.red(),color.green()); + more->setMoreData(std::unique_ptr(data)); + } + repaintImg(); + updateActions(); +} + +void MainWindow::updateActions() { + ImgWdg *imgwdg; + auto & data = currentDataConst(&imgwdg); + if (imgwdg == nullptr) return ; + goNextAction->setEnabled(imgwdg->hasNext()); + goPrevAction->setEnabled(imgwdg->hasPrev()); + slicIdxSlider->setEnabled(false); + + if (data == nullptr) return; + drawContourAction->setChecked(data->drawContour); + colorClusterAction->setChecked(data->fillCluster); + colorDlg->setCurrentColor(QColor(data->color[2],data->color[1],data->color[0])); + if (data->slicv.size() > 1){ + slicIdxSlider->setEnabled(true); + slicIdxSlider->setMaximum(data->slicv.size()-1); + slicIdxSlider->setValue(data->currentIdx); + } +} + +void MainWindow::setClusterFill(bool b) { + auto &data = currentDataConst(); + if (data == nullptr) return; + if (b!=data->fillCluster){ + auto& data = currentData(); + data->fillCluster = b; + repaintImg(); + } +} + +void MainWindow::setClusterContour(bool b) { + auto& data = currentDataConst(); + if (data == nullptr) return; + if (b!=data->drawContour){ + auto &data = currentData(); + data->drawContour = b; + repaintImg(); + } +} + +void MainWindow::onWorkerMessage(const QString &msg) { + this->statusBar()->showMessage(msg); +} + +void MainWindow::onWorkerFailed(const QString &title, const QString &msg) { + QMessageBox::critical(this, title, msg); + progressbar->setValue(0); + settingWdg->setEnabled(true); + this->statusBar()->clearMessage(); +} + +void MainWindow::doSuperpixel() { + ImgWdg *imgwdg = qobject_cast(tabs->currentWidget()); + if (imgwdg == nullptr) { + loadImage(); + return; + } + + if (settings != nullptr) delete settings; + settings = settingWdg->buildSetting(); + auto pixmap = imgwdg->getPixmap(); + if (pixmap.isNull()) { + loadImage(); + return; + } + auto mat = imgwdg->getMat(); + settingWdg->setEnabled(false); + QMetaObject::invokeMethod(worker, "work", Qt::QueuedConnection, Q_ARG(cv::Mat, mat), Q_ARG(SlicSetting *, settings),Q_ARG(QWidget*,imgwdg)); +} + +Vec3b operator+(const Vec3d& a,const Vec3b &b){ + return Vec3b(a[0]+b[0],a[1]+b[1],a[2]+b[2]); +} + +void MainWindow::repaintImg() { + ImgWdg* imgwdg; + auto & data = currentDataConst(&imgwdg); + if (data == nullptr) return; + auto more = imgwdg->currentImage(); + cv::Mat m(data->mat); + Mat grad = RSlic::Pixel::buildGrad(m); + if (data->fillCluster) { + m = RSlic::Pixel::drawCluster(m, data->currentItem()->getClusters()); + } + if (data->drawContour) { + m = RSlic::Pixel::contourCluster(m, data->currentItem()->getClusters(), data->color); + } + more->setImg(m); + imgwdg->reloadPixmap(); +} + +void MainWindow::duplicate() { + ImgWdg *imgwdg = qobject_cast(tabs->currentWidget()); + QString title = tabs->tabText(tabs->currentIndex()); + if (imgwdg == nullptr) return; + ImgWdg *newone = new ImgWdg(imgwdg, this); + tabs->addTab(newone, QStringLiteral("%1+").arg(title)); +} + +void MainWindow::closeCurrentTab() { + int idx = tabs->currentIndex(); + if (idx < 0) return; + auto wdg = this->tabs->widget(idx); + this->tabs->removeTab(idx); + wdg->deleteLater(); +} + + +MainWindow::~MainWindow() { + if (settings != nullptr) delete settings; + workerThread.quit(); + workerThread.wait(); +} + +#include + +void MainWindow::loadImage() { + QString file = QFileDialog::getOpenFileName(this); + if (file.isNull()) return; + addImage(file); +} + +void MainWindow::addImage(const QString &file) { + auto imgwdg = addImgWdg(file); +#define USE_CV +#ifdef USE_CV + cv::Mat m = cv::imread(file.toStdString()); + imgwdg->showImg(m); +#else + QImage img(file); + imgwdg->showImg(img); +#endif +} + +void MainWindow::saveImage() { + QString file = QFileDialog::getSaveFileName(this); + if (file.isNull()) return; + ImgWdg *imgwdg = (ImgWdg *) tabs->currentWidget(); + if (imgwdg == nullptr) return; + imgwdg->getImg().save(file); +} + +ImgWdg *MainWindow::addImgWdg(const QString &title) { + auto imgwdg = new ImgWdg(this); + tabs->addTab(imgwdg, title); + return imgwdg; +} + +void MainWindow::dragEnterEvent(QDragEnterEvent *event) { + if (event->mimeData()->hasImage() || event->mimeData()->hasUrls() || event->mimeData()->hasText()) { + event->acceptProposedAction(); + } +} + +void MainWindow::dropEvent(QDropEvent *event) { + if (event->mimeData()->hasImage()) { + QImage img = qvariant_cast(event->mimeData()->imageData()); + ImgWdg *w = addImgWdg("drop content"); + w->showImg(img); + event->acceptProposedAction(); + } else if (event->mimeData()->hasUrls()) { + auto urls = event->mimeData()->urls(); + for (auto url : urls) { + if (!url.isLocalFile()) continue; + auto filename = url.toLocalFile(); + if (!QFile::exists(filename)) continue; + addImage(filename); + } + event->acceptProposedAction(); + } else if (event->mimeData()->hasText()) { + auto text = event->mimeData()->text(); + if (!QFile::exists(text)) return; + addImage(text); + event->acceptProposedAction(); + } +} + +namespace { + inline QSpinBox *createBox(int min, int max, int def, QWidget *parent = nullptr) { + auto res = new QSpinBox(parent); + res->setMinimum(min); + res->setMaximum(max); + res->setValue(def); + return res; + } + + inline QHBoxLayout *titleMe(QWidget *w, const QString &title, QWidget *parent = nullptr) { + QHBoxLayout *res = new QHBoxLayout(parent); + res->addWidget(new QLabel(title)); + res->addWidget(w); + return res; + } +} + +SlicSettingWidget::SlicSettingWidget(QWidget *parent) : QWidget(parent) { + QPushButton *b = new QPushButton(tr("Do")); + connect(b, SIGNAL(pressed()), this, SIGNAL(activate())); + iterationBox = createBox(1, 1000, 10); + stiffnessBox = createBox(1, 250, 40); + countBox = createBox(10, 1000, 400); + slicoBox = new QGroupBox(tr("No Slico"), this); + slicoBox->setCheckable(true); + saveBox = new QCheckBox(tr("Save Iterations"), this); + saveBox->setChecked(true); + + slicoBox->setLayout(titleMe(stiffnessBox, tr("Stiffness"))); + + QVBoxLayout *lay = new QVBoxLayout(); + lay->addWidget(b); + lay->addLayout(titleMe(iterationBox, tr("Iterations"))); + lay->addLayout(titleMe(countBox, tr("Number of Superpixels"))); + lay->addWidget(slicoBox); + QFrame * line = new QFrame(); + line->setFrameShape(QFrame::HLine); + line->setFrameShadow(QFrame::Sunken); + lay->addWidget(line); + lay->addWidget(saveBox); + lay->addStretch(); + + setLayout(lay); +} + +SlicSetting *SlicSettingWidget::buildSetting() { + SlicSetting *res = new SlicSetting; + res->slico = !slicoBox->isChecked(); + res->iteration = iterationBox->value(); + res->stiffness = stiffnessBox->value(); + res->count = countBox->value(); + res->saveIterations = saveBox->isChecked(); + return res; +} + +void MainWindow::updateTitleForIndex(int idx) { + if (idx < 0) return; + auto name = tabs->tabText(idx); + setWindowTitle(QStringLiteral("%1 - SuperPixelGui").arg(name)); +} + +void MainWindow::closeTab(int idx) { + if (idx < 0) return; + auto wdg = this->tabs->widget(idx); + this->tabs->removeTab(idx); + wdg->deleteLater(); +} + +const std::unique_ptr &MainWindow::currentDataConst(ImgWdg** currentWdg) const{ + if (currentWdg != nullptr) + *currentWdg = nullptr; + ImgWdg *imgwdg = qobject_cast(tabs->currentWidget()); + if (imgwdg == nullptr) return nullp; + if (currentWdg != nullptr) + *currentWdg = imgwdg; + const TripleImageConversion* const more = imgwdg->currentImage(); + if (more == nullptr) return nullp; + return more->moreData(); +} + +std::unique_ptr &MainWindow::currentData(ImgWdg** currentWdg){ + if (currentWdg != nullptr) + *currentWdg = nullptr; + ImgWdg *imgwdg = qobject_cast(tabs->currentWidget()); + if (imgwdg == nullptr) return nullp; + if (currentWdg != nullptr) + *currentWdg = imgwdg; + auto more = imgwdg->currentImage(); + if (more == nullptr) return nullp; + return more->moreData(); +} diff --git a/apps/SuperPixelGui/mainwindow.h b/apps/SuperPixelGui/mainwindow.h new file mode 100644 index 0000000..8850e04 --- /dev/null +++ b/apps/SuperPixelGui/mainwindow.h @@ -0,0 +1,155 @@ +#ifndef MAINWINDOW_H +#define MAINWINDOW_H + +#include +#include +#include +#include +#include <3rd/ThreadPool.h> +#include +#include +#include +#include "imgwdg.h" +#include +#include +#include +#include +#include +#include +#include +#include + +class ImgWdg; +class SlicSettingWidget; +struct SlicSetting; + +Q_DECLARE_METATYPE(RSlic::Pixel::Slic2P) +Q_DECLARE_METATYPE(vector) +Q_DECLARE_METATYPE(cv::Mat) +Q_DECLARE_METATYPE(SlicSetting*) + +// Computes Superpixel in different Thread. +// But communicates with Gui-Thread +class WorkerObject : public QObject { + Q_OBJECT +public: + WorkerObject(ThreadPoolP p, QObject *parent = nullptr); + +public slots: + void work(cv::Mat m, SlicSetting *setting, QWidget* wdg); +signals: + void message(const QString &); + + void progress(int i); + + void finished(vector res, QWidget* wdg); + + void failed(const QString &title, const QString &msg); + +private: + ThreadPoolP pool; +}; + +struct superpixeldata; +class MainWindow : public QMainWindow { + Q_OBJECT +public: + explicit MainWindow(QWidget *parent = nullptr); + + virtual ~MainWindow(); + + signals: + +public slots: + void loadImage(); + + void doSuperpixel(); + + void repaintImg(); + + void goPrev(); + + void goNext(); + + void duplicate(); + + void closeCurrentTab(); + + void addImage(const QString &filename); + + void saveImage(); + +protected: + void dragEnterEvent(QDragEnterEvent *event); + + void dropEvent(QDropEvent *event); + + ImgWdg *addImgWdg(const QString &title); + + std::unique_ptr ¤tData(ImgWdg** currentWdg = nullptr); + const std::unique_ptr ¤tDataConst(ImgWdg** currentWdg = nullptr) const; + +private slots: + void onWorkerMessage(const QString &msg); + + void onWorkerProgress(int i); + + void onWorkerFinished(vector res, QWidget*wdg); + + void onWorkerFailed(const QString &title, const QString &msg); + + void updateTitleForIndex(int idx); + + void closeTab(int idx); + + void updateActions(); + + void setClusterFill(bool); + + void setClusterContour(bool); + + void setSlicIdx(int idx); + + void setDrawColor(const QColor &); + +private: + QTabWidget *tabs; + WorkerObject *worker; + QThread workerThread; + QProgressBar *progressbar; + SlicSetting *settings; + SlicSettingWidget *settingWdg; + QSlider * slicIdxSlider; + QAction *colorClusterAction, *drawContourAction, *goNextAction, *goPrevAction; + std::unique_ptr nullp; + QColorDialog * colorDlg; +}; + +struct SlicSetting { + constexpr SlicSetting() noexcept: slico(false), iteration(10), stiffness(40), count(400), saveIterations(true) {} + + bool slico; + int iteration; + int stiffness; + int count; + + bool saveIterations; +}; + +class SlicSettingWidget : public QWidget { + Q_OBJECT +public: + explicit SlicSettingWidget(QWidget *parent = nullptr); + + SlicSetting *buildSetting(); // Result have to be removed by hand +signals: + void activate(); + +private: + QSpinBox *iterationBox, *stiffnessBox, *countBox; + QGroupBox *slicoBox; + QCheckBox *saveBox; +}; + + +#endif // MAINWINDOW_H diff --git a/apps/SuperPixelGui/superpi.icns b/apps/SuperPixelGui/superpi.icns new file mode 100644 index 0000000000000000000000000000000000000000..4f8309d2802969d9e0adda692b65eace0372f003 GIT binary patch literal 326074 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%0A)a$zq71hd|VoeZvZp$3+y%s!={G~U{n55 z0v=xm_wue^q;`&vzgYhL_@n0uAZb|osaa#8lKG*1B&)ESWJnxL41?>(7Lj1#PkAU^ z=uRcWaGz%U64u?m?3-~Fw*s)h6Hc2ZMMv61V4Ft9rB+ix5?W%uOyBfdzsQqt za!W)6xoru8O;n16h#v(BA#Q%ugQHN(@MaCzOY(8oBdov)(-f&ZxcbE_!b0>*Kk_v0 zl8`aUGcMCwraQgf?Ps8TZE%_Hd|d*$3aaX!)xqtfkE;47Klxts#v8}Y6S!$`a;J0j z?fp*Yi^I;&aNU{h4tlfkvbUIbdo{21GTHAhmKgJvbEX3gJ22N+_MP*udHc^ndC9vO zjQBGD67K9e|A!k_>zdbQ`HNpHC4E@@bJMzkAgTS1{8VtjQ=?cZOgFZe zUs`F|&^euSL#pUr(TX-$T$Uk_Q|Bn)r(uvxcqT0PA`92`hTjn;cF#eepe9WqAqH+s z3>+R>p%rNh8HJS$L3sPJOeN{ID~>fRL&zlCaho)$G$k$yOn^3wynVRXXcc*+oXcB_ zDP?4`DQ7%LDo;w=VnsPheYE+L+`5T}!Y$bfNM%p-!*3xY$g|`$OE@;V68Py&KqDNz z!{8KDN~%Zn!?nT3@-o>)FzUcN?nAMStcN-_@Mc zec0s>Q`0Ctc4c-r|AhJd(&-o~KPNWBatH_p;5DZ=GxUR(v^J|SU8&i)Q(-o?-L@1G z{HT15e#&>X03Tk}e-NFu159p43!t(ob#!>%K1{?Zn3BEL`T%3aW)qkz_`ehZ*G^>z zG~<-JK!Sw5a{mi|fkmL)a$19W#g~W6mFOpe#w8|@xPkbOL{S4oDg+7~pWa~14MPIU zWitHy0H-|T63VIYI z?4O=K7VfxDLI z*>Afj7;H1F=4=W5`Neqk(~ApyNPlz@bq@*v<0n^t>>3lMUxASQTg6Eo#$GK@>5~f= zIHjN#_NvRCvUSPB?S(&rnbX1%W+&q^uEZM`@YE9{BEj?;8A+nUW^$2QA>dVDB~3{Z zaMFskjnfir;b25IDX+**Z+JFtp=+K|rh-%Of*uSU&nQFXw74=zAU5xAAk}vtx zokf@7y|-AdyNpnb_{{g`Fg}cpP~iQaHKYF0skj46un%LtgRviP>2%j{KfJ5a&dYoJ zxCPG{Ca$59tvvWMI*KY+xsWC?1vr~6s*ldkSD#GB7l*6G<7HDF&)3cT_)o`gzxnOO z8*jeLenZ|kh|ZG}%O467wE%aKSwdCw;2U6;!S+qXGho5&O!&Rpxaaf(QGKX<1wH-3 z3dx*FpbE0^ z4BrEY^3#U4v3(^_O`CtoC$$V9B87a8bfxDZ9N8F3aVb8=HU&s-_gH%e^Q^FeN<1e`uFFz>uc|SR`;GPnv3~K!)Cq? zn|eD;`#YWaqRWK5yXbbh7+<{&z=uz#lj={-PG=vD&kx6)>agGIoDJDnr7nxGQev3GznZSUO9=9jBc_5N>Hk8p2kz= zsc9Nxym8^@78`~L#dOqiMp>os;>&Jz(CfJo$Z5dOU!3CQFkV&z@Ok69=d*K@`BnRm zQ2Rgq^dp$Rsvqsonsb!sgVD9-%Q%aC`Rd zJKq`ZUOPaM$%VEPMW-ZVl!qAo?Ucgo@bN%dFqlgztL65JoVnTeA{>C^PXO-QarjH8 z-!KRH*r6f=@+DL0MKIqk34u&r&86gP9?`kCTnX5T>6r>;M3;O?o5?~mGToxL zB?P2MrYWzjvXUg2IzLn<5f2g6QZXX0lwYEmax#)jZA@=|c&Pgb@dQR2Dq4ctNK63~ z=EhMV%svq?O`@eF=d!S16AjpA1zocxLDu^$6k^gnRg$Kjl zc%A2izl;FLH5(d#yVRGMKdJqW{Ezl;HN(@NH}Amw7n4QPAFP`0DL;4f_PWh-!bHEf zsAsboEWBXUS79#IlPUo~)Tb^L6caL;kyrj=`9G-$$O5JcJq?Hs#az*WNofPv1X6Zt z&Q8JVlmp-YkE2KP-#tG1!K`2X)%AnX7!=+$;GIIw9iyEVGzSZdhybP;d}_E+2eD)^ z5r#UQr0MqSWp~~C;_Tt-=r13gzj^bG?pyEP9S(Q)SgnjBr9@AKiNafeGP2ks>CJX% zaqLTiD2IK@|F{eai|5fBfQV{wb0{Uv@j>1Q5)>g|U6?5IK^6?egPdw9#Yrg0MB&Vv z8UzsOvKu%eB2!(67UfFOk%|~-NGOf|)`|WQ09tkpW_l%~APL+{e|Sxk!!dH` z2f#->T6m<31m;S<;HUxk?3o;p7hjUN2K(RL*}41i#l?#gyd=iU2!J4U&u8Z5I{#r_ z>T}MYM*hV7XQKnA*fSUPn`%62W|%DpnCoU2vu5T3-=xQQi=sZCw$C1n#&#cu|1~fF zVE$u#U$8RUL)oV`S@u_bhn3y_rzH?=fVyM!M+-<~yxWEj;;LXSAy~nGa&l7r&cnl> z|Ds;};q7aK!`+6r2iI&v!U|~%gX4`P%tcsZWbGdzkhT|66#57N@&&}yB^Jjxp|GB@ zGV$5b7pq544$t1a^Iq@Gx8EE34)fNufC7=f{1LVRp2JRN=O8Z&8ID1(1P2yf!fqlk zNa%|zaEy>k)a8QCq89w^B``+w5d!Hm-7t5 z_$gMDA!r$H%NaRu(Mvgl0;&vQO0LK=l_%wGp(qE@R$0oxG#h{9VYpBsVLZE_K;+gw z3vmXGi%SIBh|ymhX(_X#?*KB^(rsVDv=L=F*v2Q^4W`c(Fw4&$V+xcKHPfmAT&BE9 z`z)Vh%Z*;IV$Av5f1LuLl=Bkv|HdhE{!w9mmirj_&qhl&=d)>lysFP;4Dama8?v~j zHo)A9qkGo%(zo~LF28ZAH@w#C&R3ZFm&A9N*|Rg4u@@Tv7J8}(n*oagN+=l~6Ck31 zC^^(f<83uAJ4lTB1l`eh%&7lA9X>ewKhK~1!T#RxFW>48F*7i@$B>19f$5o0uosA7 z-+zn`+8}5qieq;-k5JP{K|EPBoL{gcPo4&uMX?6W1x5YY7eAdpeE7xe?YF-*xc$aE zytmY6zoHsJXaiu9IGEp&U-gvol2_`C!UPD58+S7cNP(q5e$*VZaZDEsf*Z_YRAB@n zWrz?sNXHhJ1eVD^p@sJIg+R(+8()HvXSmR53lK#Jy1{f&K=K05ydrO5IbA$)#EFy2 z)21sliI0j&$%;3XJ?Qx0JP`@Eg+MB=&lwqul+s$sq;nNV`R--jWps|RC1^?;_^A*U z$?_SpnH_laM>~thPhnC7g|YEG!t7(!^z6(c`yFT?oQ{Da0|(67cUx6OF!5hFd80mj?e zYPFOnQ5Vpnmn;U<3%2^r`Q#tF0x<9`?XwvE&;qPXtoL*p2x=B!JmxqcdQ)V8tFeza zimE?7J*)oFmtXwoL9_VhZ`~R`0+Wfy+HL=6W}PKO$Owklga_l}RUXhPvb^k%NFdBA zp$&>{0+R((4znPl(=5BF54^@)QF!{xVAwt3Rp#?ge>i*a;1}8l1~>1##hE32HWPW) zoCTKAb@|ybv|Oif0t7Dr=RbaNBdRcHbQUAGFT>z?g*V4bH-lTaFatb83sY)b5&}Vq zc*-VTT;i8>;c`p=DLT_t(`mSA2n``%>{V$2Zs_rJMF>FD+D~!1hD+Y5oYE6L9?ml4 zaDZA|iw9lOC%6&*2QYjIQhaY}W7v?`a{HUp>@734) zH|yi`&zlQI|2;YE&C7Z}J92ycz@$Q9dhqDAOc1oSMJ-r7_w!F_iU0A7FUJ4d z$iC4^vv=RUJGg%Hj%OY7TxbM# z>KK{GC_0LaX2((+h`E9#O#;Ga!pjYqoS-*BazucVKSf7uFo?LoWCE`?&**m2%gKx; z!6hLeE#Q$-V*GCylVF4s4)>I2PU9m`Pt>B%AuwIiiaaB2gjzb0cP?~ddYQlEnaf(z zK{Gv<1o;6k;Y2m%XB;W{^Vy^k07ILCWD=%`6##mNG?dPM5G2ZA_~{E;w%z7xTZQzA z#&)bkEn~Dji7boaL^s;Uvc2N2j;AH;0$^KZ}U%PYmV=+K~VVT1C{_LoaR@rx?^_z)-zuF zsTXth4LF|4dva6VWiJptsKZ1Z9e)nf_85gR)Hx8RF#{=}^iwFr=`Fv&!v7EMfBuW_ z&n|xFz3V$afhBo?kQqfIo2nOJmSY}Y*eM7w&sTXs^JB{)B83qUK|nE- z8T@f(Fw%j-v1-X3{Q-Q01pH3v&{fb^mb|fuD(SmP3Wvk#dG+Lne|~ZM;N}#KV6=Dr zCZ-395P|^452mDEV*Qyyg>}KsVga*ThLz}I;p*Sah(n}OcMxxw$3DgdH@_qZpcUsd1Wi=Ah&+=s>g_N}@)Wd*=_ zKkNNFu*NCOzZlW_==mJeU3WX_=wZ0Qp9_*ooXMd&n4GW~zI0UTC7vqWIUGVZb}f>(2d?N2{Zg$7gTcxYK)^ zJp`kDmk!Cqp9~hAT!G-cfPV@RQv`dIjcvz@-V>cn1j5|HAu@PSkaz(!Krr{dEl@%M zPhk-14LvoI<=Zob0O-M(!H{HQm^4WgC!t}U!X=oLfGh+kU@2otvz3+tZ(ux=9Or)) z5Xlh-V7|nOa^}1W+&m(=u0WIE2_aB2DahOL;P@)AX-oP2bW%@83lK3q0CH>-L!-)Z`bRWo0(-0uMfoe?lz z=;_a4tbRRbDUdJxQE{E7$4(mF0A`Op5(5~+J*#rg^n=BD34rQC4me(iRAn`eLdiOd zd9xm`=j*?7v0UE%uO9s3pX^=h{tq{H2B#}ubGj!maEN0g0_&I&zd!@w2OQUY zC_1Y_p$OAYDZWZWQ=g5`mPdzQOc&G1YG-G+)8XUBsWVtydj$kYAI)GV518TfAMoN2 zv_O?(S!FUO?t?B_o z;R*(}`|ygM12{aztUJ_yHtaC#c1BP7KRG{r@`L&Gzy0=|{oi%vU^%2^kN{bPQ27jl zw6IhBM36cL&q=@J)%umFyzqkv5R*buI1LJv0v0zb+nH7kt3A7g0^$pSh!Qo8HHD>3 znP0FmaW%udF`G9_WL`B#+zdR$7!kylg&34SJ^XC(=+T3-x88iO`^H=Ejk?1j77y$L z?iWyC*m1N6@Fe`wXcHreolZ@G@){Qn#1j}UT_;8*gQg7xV)Tn)I1)Nm6?gz6uE0$2 zEKQ*3ymsbH>XHlDxXjD=C}dIx@Cr<@%V`sE0|V1Sb0zivt9eCaen_8F^pa-@hZ{to zL!?g~c|>9pBq};{>)%$!Z=RcP0wko28Z=BuOGJ9{y^Ifqt7Jfgb*L5)SLC0(-}Ej` zmjW3>zWq&UmGoB$fD#w#e+itO@vPGYhQE0|VfwK*zh3VSR@L#*lX~(Fj5OV?cXwCS z^oZI0h>Z#h)PIIiMr(c}PWZf7cNV=>ceJk0r&!mAgC*O8t9pWh4f8Ih=+>~*kmUe| z>Gg`0J1jKIdeK9jU(eLm;W;J)gfJC+`_|4sx-l9YO$?*Ub7%kwsB~?NNRAK$s&g{2 z?-c=76;Q!v9>KuuoIgowrXJvFt&8^!P+!>fQ>lUkA~_)JD1{RV8i6$o)C`6P79#mv zAygO38A}cQDdnU`&JcD?P?mF^od>9y_&{LA=||oAoTvQc{!bPUAAWxF)>|wczWMI3 z>0u~Q5Ul-?t9>Urk&?^KOF=>qAen-xBR+M$VA^OTOPj6`2Ag2ei-*bac1@$rgZoPh zfv_D=xUUKU3lt@d9Ly{FKW=Li$OT9_0?#;!;nOoGSYlWUScE`SKn|NhB9-z?cpG{? zQq)n#vm7z{TaO?U?IXvfqg{qBk?M#DNB#7daN=$vk)@rz0f%@dg-iDV7(!ee>m#OF zrhp=a()Ud+^YT^o?~F$8|K5`)c3)-BH@coH021X7s_J{E)%b^1UCtw#qBsvoIh!Nm z_p55i=&x07ak9fRuFwE>V#&|+lgWe=P5ae+RIT^M^A(2ybDlTs2giEIpDX|JZ_UR5 zI3Hv+B?4{Sagc!@bK-~@Gs-#pc3CW7c@P60bLRTy_4;(~f+EemnjvLqIgEdZ2x-#* zDiti)F;}Pd8G^Cjtyu+Rj)!dk0U#b0K2T#6ODT|*M zKl^z0@G$KmxPF_ZL-dGhMW!wzm5%E=warX@P|gI8UI#dsjPgf^_vRHGu-(-XymY@d zMlgX_76PWRyTgU4jHw*K$WI9Y%bAn_8`%ohjZ%I!txpL4B_ZJBNCaR!UT{7T%g$w< zmOrIQFz@CeexOBp2}eYVOQD3IJtheNn4g4B#l%fN!r_n9K`>}ifDp)*IpgXou;j=j z1V{tWvPIc}OEgn5^tCRh5bq5Jf1AX<8F>1&h-@W#p#TW=|7eoR{T>W`=u{llX^*C5 z)6W*I@GgdD43DE~Z@1wbkW=|g{z40=*Hfwuv)+o=0AWBzeclCht|Y_4?9}Ouk)K(D z#{(|mYqsODftXK&Fso-gtAXnV2rY(b zjEW$TA^FmLt^gneSY%KVNP-@P6%qXaxdaw>in2gb(UvSwP;NB`CJcxVWej7Sn*uO< zcz!Y8FX2-r^VO0kT+TSn07-zE5k(-5Hb6;X&mj!Xen_;PK3gcp>+_%f)#TvI`?I&+ z{`TP7&D#TCatJ|yf)w*b8NU?-bSfV+Hn2pmi++}F(Ha61PGW)p2Fwl_v4FOqTMU)S zhy;R+COgQ4QNcOA{xUiTPQl&cx=U$@4^1GXECI>4X>vZnB~J-~mL53L$oXGRpM-$r zO_Yfh@2Rk9qJtDd0SMF(0M@6cM1=-`OT%BHM-$jNa$TjIm=e+sNl3`_W*Q@Z@@@(Q zo@IX>m)S54a23E8gMRq}V7t(h$tpfjwheopf4A9LpRX>Ww&K&KXaOt6N6z}!hQ4O2 z0AKlIcFVUwIPaUqfdPX%vtVSvqMkC;@)0mJXKub!&@jBZXNb{Vv5}Y=)<&2xLR0sA zB!E$zl{%Pwp-`c4YwV10IZ}u&*XfZOW{3M3=h;pS7a|xG0_;R&1Yn7RB>_Yeih%9y z7GXwv-&S^Y5;b6fp@SHN5yuxg7om*4(@25b#jH}`entcr@@=W8TP~(-4x|u^W^US; zTW|(q)2H{a>`VvhG)I%u)ya?lVtnJv8?(23+30|!L+AamYLEqi;x?@q6ty+?bh*%f zJ6Y6r>a6-x(1e?~uP{hprOq9UZlg+!Ksdx-Vra_q?CC%*hcvb?%VHx@QH7B$TNKOU zMRuu>Ics2!?&b_UBdSG6px~q|jE8oLB0dpL)FKK%5oIabbTYm5iHr|=Zd8r&Bc6AI zC%HCc9uZDuHc!jq{M`Iv3a1-?o0P`Aj*E>m)!T!??wf;UEGMufulm2Rm^=yoSzZ^4t z!00}46R__Lz+5b_H&bT#up+B+Fd=4oclfMXVOY-5tj8FrC_yt2yDmG%{@Q`(O`tGrp_|GOp(sZxPhwmP z6weB9TL?%y<&iUJ3ra*Hb;&It(5ZAEZS+lXP z?wzrhpSOHZkCyfDO@=pAWD&ZPz4f?v%4F9s86i=bpU)S(2h8hqhIu_`J)#4^yRyl8 zF`QKs_y3?3bVp1N_&CsTIR&p@P3sv0jh_HoVjti%F~zKNdt6yB<`yve98)eQ4#D)U z(X;w5qdR<%)}hz!#B?6|4Y~&dJa88G$(*#v3;4z#!hqaqx@13u#)7j;w9vDr37f*M zYA3cX+6d|J%k?fwpyS6J0nNde9zqlFP!Y`qr12mmrVQ?QcAEq*GowhL5n$w`+AyV} z>G+BSb_KM785^G-oP4=BI(c+*`{rByJMVmJ)E~8P9n!(*h(4YS;|Qi}|H6yQWBV`( zl;ZFwCczVzos`R4w91w%xWI88ffG`qOQ20tgg~KVI`c^`f%wlQDUNQ`GG+7`2uIY@ zX@M4cfe``HO4BqsVF(4w#1+~C@OW16BwT3dmS-(qVM~lxD25?aZ7rt(5f72_7wSLB zb<>sWo$B4%Hr&Dd9o~;wa=IQ?FvMXUG61pI?2ORq?Vcl2BVM^!3l0AD z5kT-;}?Ux%U9KIGCKTX5hSG-lb; zNxDtIwtqJJAS=iT#z)r8u?!HW7@>Jl321#^Il=}{iL45S{TQBXdSOW+#AAZQYg*`# z9*B-u6kzUR#ssixVqK(x&@MP=V1-%0x1JFOw3o-8`V!)@o?;^)ZiaD?R4heMWts_5 zGmt28M4BTBCmtdz>idtrSR5T4p5D3hcJJ0(-x_rXeivCoArd2XHiVEJi<_b?7{rPS ze>`Zy^BMTXMO^DIFkF+g@Ej;G=_SJ-G)o#hwpmn}Rc<)&Hm(3^l*_b%x-A5N$+VZ# zrksVP%Qk_QP3-dpp{vs=9HmztsL)Lr7kWffc8#vQK^BcmQ_>g8NDgi2#Bf0p$@!yy zg}cbl6^{=%S3|fKxh=M7xU9P<6Mo}@mJ#{73RdE_UGX@iPD9||#j8v*>#u!ngxVD( zzWd$u95;r;_1<2!-W_z;PX>OC>y7FRA@GDWj;J?a;7R9veNNZ|e*A=CXF8$dN0*G1 zfI?nlU^7A>Fco0_@AJS1_|XWMi}~5#fCXG3QS)ISZ0F9#eRYp@LW}??#Hi0M$no-V zz!3{DklOjeNp?%4i#)ncYlB|omJ~8F9Y!%-!(%wul`n3t$lEl zW30z+_=!IaZt=Yz2VHt{pLNAKq8ss2&v~VmB{d9jD9FA;OgtJi(tyF1AMAzYzNcwH zflTGHPA{CHn3SkUIb9(Z4e)j0$jNK0F!QM4iJJdST1Nl%@g)>Rd4Zn$Q|BXwXy9nD00!_GD$2ET1v~yh1idumGAsf z(P0Mu$)NVTF75CBaMKHmoq)85xIu+DuXNwI0esF){PA+R^Ut0<`KN5V|KvHSFO0HW z&$`yty%P0db>qe`T3;<-a4EGT`s{zY|h>-!dbeHB?+7Fk8 z4IJZ`cgs61?Uci_?`$~$-=#?Mb`3K8?kZLb;4C24CVDV1lL`!XtTQ-#7{}fkc>(kRm52x|b1T+YRM*7iv({bf= zG^(3v2EP&yj2;C2%n;OxJ&Lr#^|r3nWfMdb;g;G2sd!tD08yxkt1ly|oWM!xTU5kg zjE`GMOI&hOL`fT^6qJ7v8@CPphy+&Xq_SPk*HPa~f#Cekb0n}cWu~=$5;NOlWfUNR zA6bP@dj45{F4CsI6q&H`w+UKELTC$@f-ifw*l)3o^iH??YcHGTS$NOX08H>9&-~lJ zowR___ur{kZ{Dob0{UN8Sqm7{lby$`zp>q|e+^ZCTKD@iUd`RDyHig3?$d9lBMfiU z4I-4mP)>m}c*zf!rMl2qk(YR|rK1h->R;eEv*|eUTW6TiP=zTC^LlkQhEhg)Bm%~E z$5cjPR_Y*(9gQF~NXNw6J-&4HXd-OvZ0Cb9q={wSWklsXlWATY0!A-%OtzInoXa9b zGsu31Q~xnF+7(g{!L>ASyE6eg9Gu3pk&A`!tRecnBLqRz0N4NBec@>#d;{h## z1;vE~uw1Ox70*DpCN*8a5^n1F$uDN4&+c|OlgS{7gtw*D(loCW)y5^7rs45Q?3L+D zN(pSr9BE9Rz%AYMOodP+2^{f_bNA(=2fUZY@v`#?D>lP~6TNBiC__K4etj{Lg* zXrST;NtyiZ*NsO6_|A=?CC$K zN1Oqq5a{;K*w}~B03k5z@-EGS%A{@Q)Fv#)c0R29F1=BUP6O%*Js)Od1`!pD1gN!u zu@V@s1pzZ+-me%jx|5 zbU7G}n(lBX>LMC8Jrxhe)7kMNY;|OT;8Sj3A|*T%C%B#OUonxxPXGqW&deiA&fi0Plwf!^>o*k0}7K zREAtE1CogQ#?8TJI=l~1{n_d1_|MMH{=qYmULwLWKli%#mDulABMf-EgFgs^;KA-Y ztKLbo-q|@vMRpp%)PJl|kSPEih08eMd z+g@oR;2Ik2QUb-zSgQWv#e7!$+VWN5g*z?K(tqWZMWG9GUQPq9#CsYToRrcS#qxio zgJYFA%nq3I(^c3zjF-Flzpx;dFgM1iqJmf`7rUqyIe)n|Hsn7WO z$yvWwpHa8x;Gfg6E|~I+=|>YfCX1{UI~%Gg(})LW$BQ5R@Xt;k{Om{Pi}{T0hOE5$ zwl#evI((WU&_RL46v196!|_Yg1Y9~~bWnOmj8vtAw#<`gMKx^IkRtbK7%laT%gV{< zTR6g~v`w0=xDD_MU%@kdL?`W$MB=V5+=Q*23*P%jm#R78$?Sx1WR4TtaIXbk+?SMK&#rf*CA z;fGcIcUg4!baB5*T7Xl5!|KlYpgP*wtA~qWeYSpBcXvB{XYZhzolL9AnzcampdMzy zdGCVltvkGXD_=#2gflq)%gs83S@OqaB^?c*PmevP7ib?~7D_Veu25Ew)v(t6skY}W?syShKko+8WRmPKCCU2(!aFh`7l-2}jYgB5&8Wzn> z$;8SXQF0Y-XdTQ7pdWjby=wur!Te#VNQiM7uZs0l}JL{nunWp%;pzfT^sX^bhrbi7#K?qG}Y94eZLk$-uk zKRiPK%pZ?u!*@CLHF^jgL~-vh5;g?$#BZMo`rPeDzEv0+fMFs6M&`6-_(2JLT?=Je zui~cAv+oM(C-eEWfBNv@KL+dbXJbA;=6M3Zlx=y6E#R^cNUH*q8{=x{d|jQb$8~ph zQVp&#!k;jL?{g9m)z+Wy!YnN2b1v9sDuC5LrUXOgVvCxi0WfXC+^h!3gysy7#SXqc zEVy9hoFl`~D4^?0JJ_ME%HKQJKc|49g- z%&Wu$139rQIP5K;kzi~25R4?%VPOccz0W2jdpR4iK_ou6X4xW|1^!1&NAiJZb^I{e29APiX>YROFp=4hY(R8zC^Nrqc^5V}uYmK+B(2!_gd7o`=T5hcy7p z-yC+M!eM?a>$r1H4AvmSc*h&`?kn!~8SHrPPfgzMguBa-Ew~)!kAT3)*vt_mgjc*? z)MY=-3Vp$eGa&SBSeki4IzG^`o7RD|WOaoAOigLv0)&FrHmxS>2b1Bt=8##IDL-?g;7N&1xH> zjp+ae0FM`8hhH?911=_YV6rSsjDOu>?%>GodxlC7;@DPCUN8V#@Z@dh@@&Vm;^j;! z$dpX^Xo%Paf*7SUXrAODWAtZT5ghU-Q#*mWdC~-8tfu7d15`7Rp}8Eu?JAUjc}ZNO`4>VS0hvREt`~Q>GCBa$|pl>Ph4WY2wQ>Mjnx2{HlgPGb=8^; z*`96`f?&aHDo!O*5KuU$4G>S(NR}S8Gn`RpPfkzfr;iS2%abE_BJ*uVb|bl|NSlC- zOfgcKitF?FbX16Cv>G!g!cqQ&B3jT0gg`Q43-**hP|PP^tv7p8iJlSy;6@osnj9#w z;zl$9NhMhJ=djOn{CH7~ISt68+!yEb*=+>?3G5%V6hDUm(ouw4gTeF%XBWM9`AZP?XIaa&?JuyWU3Ucj>*M1me{p{P-w~G@ z=4qrCgkM$wNG8hkA@0*c;NUmkS$}?Uzdk=dtp*pp>U{5wYISxPs{{T0?s`-ousU#3 zv)7-kLyKyPO2B6T7~xqRV2HIsePLFCpf*5)HQxnccOa(-qtdd_4#R3l0|-;A6_5xS z49w5^@nR49gO>5YW8fqmU?#;#2~=$xktTA_02LjA03iayg&+W(^kAsq!Evhk4(PO` z13Hobo>pkYh;F2`Y%?2M?ZRqQvrv#oDkW5C#3*74vND0AzM{ddq6onsvkx@|Gf*&D z)jYRKjkp+7@w1~4eTCCUcGC+N zGW2@Q42}1cDm^|qnq55na=Jc0^W8~~I3LmBu_!7Ky>v|Hlp$Qfc#1HvM`7FQ(JofAQqWKLmj-d#`@IiU5#$lA_OKk?yo=n z^lw)0zkiF4bF(^Yeq3EUc~ITCb$z|UE->x#0s)&@MQ5kqlLu(VY`QSQlffp@zWKnnQ{C z_=qpt!J-NR!U`G%g{pUG6wb+m^NF=Z6$Em>aw8a$r&cAW*EmangDs|Lln@%eW*C-D zx`FbB-DE@sg3pN+P%7e6dFDte0I}*wFR*(hVvIT@huLx*A&_HJk zcoYs0f%!f4lw8pS!bZSoAKCzd0a|Xm(k6<4;OP_u$}93PeZOC`dQhJ%=F5{OkEUbx z6tEno9g(-R`O=Y}MGxk;;gwlr?sMp&@1~bhR^qmRk$1rc9_d=VO}Rq=paINhFgY6E@_aVCJ?fs*0`w1Ap23I*u$QQ< z+Nyiq?m}C@w+2IAPopyJCss$k%v(V&vugn4P#I`sK?1A@fLxWtq^HWoBUql&m=|B> z^JqRF{xb}LbdaxQ2z*rmV5y>PAL1$m+#_&){z;_}c<%uUHk*acn!{>@HgLLsy}CYi zN?@nJlE2TgAl-E`nbqga;OdbUh};X)GtRwj};rjjE??p zkzb=7a3s-;69;3UP0q-S7QnG&juiOiO2q=ahbBPtx#({-5arQ83Ia_>Ouj>lVANF-NHjW- z8G|2q3L^}7QX@L5k}|jv4FKg(FtM8I-XtmwDWshMl?4Wla=~O636Y_GO+j%Z!^a`0 zUFZIYBaDN>H5zt1oTWtA!%W$Y0S!-12}2@1)!B)!CG-A5z3BIwG4C#%PA1FKqleQO z_JW#q@^07*6b7m~Holz{kH5t11`@9)xbf*HQlKG)ydsSNB|^Rew(Z|UrL@KY3rgV@ z)zcSoY}N~ zIGK0$o6g<{q2X5a^kk(h3OoC4nF6TMszu2B8WmH#rSzAdD*FxQ`idCiUwl#a=8un$ z|Kj0d@h@MD{Z)*wBLJil<^K@R#yE%&V43g%n}vR}of6z)N^o8+Zr$X)e-03$*YkQn zXahAL1mNo$>(yw!o~{P#X3YEe-Tu1!1ja!t;Ittso&!Va{3~n%{oZ;tft@^klQv^w zJm-L6dlsxCL$D{1nZRl_opPoJJES?G-vfrQrEC4;ZA0kM+0_x^A3q}tUai?zBMgp>-<0_9VmeUzD0;)nIAyWd( z53y|M3W3uCIv-O7Yy$`Y)OIujYzFjOghRN(oKDc3p;<7cT(b9NKHvaH4mUX+pU+Pp zA5NFNf8hJhJ4gLv4iG6KbgLi zSVnL60RXf*m{%bT5T3*(Jb>ZT&AuF$AltD8@>SO_8GSMyFaG%S^dA!IRPmLrZz2Fn zMm|sVp}!BA7Q~cbvuQ{JVbk2Nj*gOnaB|~1f?#hwdGe?_zqY&X^8vl}HH?F(?~b30 zjkqI@_c~s8hbznoyr8qQTx0QEvAc~$0t7>K3QbRT zI`E4?pssnbU#1S30~oHxBA_6G2^B?T&)6Xc$E(booT^sBsey)>b+Xxju*`8*1lL$KirPPGL2i1^DOr22A{k#cu)oMINoh=iJ!g zbY*x~3VbO^t-u#D467NqZ@_&82mlR@SvbIi3MLJZ%h8~jaAF%TA}vmiA5ABZzU1Vl zF{ls>VW5ti1%RBW5WtCEtQ&rV`ojfhJ6>2$BRH-SzZKl#nIKf?W|W*yrVVoBmywD; zG!SSXe!)UYbRNGKzdSh@u){J$Frzi>u7*jGU|MxP1%d}ebyoK$)4|*Q_`1X9fxxr4 z;wm9M{)V$}6(;)rKDv;j4O#VH4f_MadOb{S>qy4M!#A#WFU zMw}3=W`Lbw#CdvC1jFipb3>UQbU7%jdokra2PV9I^-~;8wD#^|i$k(la7mEh?krA% zO9(Cr5ZqlCcPB`22@nXu-4=IucXxOAc)$A(+@J1rb#+foSM{mx)92L8obx>YNZz$u z&rX58=jyxLL_OUt`F=QF6#`6%ir>c>aT|~gq2H@YDZazKhJ})N8h*&fKnpPT0gzK7 zYXlz}lo(`3#5zYIo_^2&3?hv9my@LgAN|@sew;eQE<3da$3_Bz0+#*A)w^VZd41?=C8UvuQf5=) zvgNA7f^uzFjqsPb>UOc!dk!;21l)N$^jIx$hIK7jt5YL))}&N5}NkO=BtjndfnYIT7Ag9Lpj(Q8_p8AIyA|M z{}Gt7N78nCI|;5DInA!W!cBaIg(F$qz4}8~4Y(NcG0N-CxSMX>RVz&+?NWBcjdh`%Y*8j*$Cj97SA2YZCk4tEZ=pa_AcL zP#m=x?Ip;AfIG`0fY$FhbR{vE* zCAd3s?hxw-ti-`t!%hd6xwgewl!w7$LvG#_f1xV%*$$_2q%8ch^zL+INKmw2+hD}x zuaRn2z{Pi9ohdV4Z@ zXjJt36s+o)2`&XUv>x0QQw3)On13NX4cXUEmm9snJ$Z{p*vN$WMA9?AvuKbAX;I`R z%h`3hS&B}($^_1_`JMTpswkqmUJ^Z3oViL@MJKB!%4hxPvzbgRaya}0_N@6VL0u?+*M;P2JOHEH7 z-s;Z!u3YW?xI*YUJ9J*U0O!=T7%i|>6VEUOF(zX4PnF)9qWZfh$&;nwZ7=u<1ngW1 zcdWd{+NWL$8Np*3NzpuQXMG!l^j*k;pG3m8dHehOvbP?${4F*eSVS3y4Zm1_Zoevf z4f>VfR=g^(DuAyx>k}@3gcgRUd;!$T<&d5PyYTjZi71X33h~)ywq-I74BU_tAMaYV zTvm9TyBctic8Lt7Me{f0r>Y2HBSoVAkbX&XhjVQ*`hk=IWe2}#WRyqT;`e%Al3^wh zh}=j|ETy98GIu5iQfJVf_?ZBXqX@}NVLeCWLTbt1OU5}HQyn(@pnr*>mSx`cjZv0O z5P#(G3_MxY9mm!9BlY;Xh1^t+oMrpsdF^TLcx`9sYE8i=nuX@3RQJaQ!B1a{{H^P@2}8@%K>KCYtgRS^I9(unL->yhY0wD7H9t zjv-FzXZi4cqd^f#5NZ}tS0mf*P%Ez?`dCpz8_<`$hjDy6--2;Vg%pJLP}}QfLUEg1z>88 z{0Y~RQWXE<4i9@ab3{K7|2WN|1jr zZmYw3Uyw_QS2l7{_t=XrkN3EH)MT+1niG=3`jx$*v7>1F6vv%zK^1~=Z1)YPBWIsN z3b#y!g5On-2fu71nT7wpjK|q*(Vc1FAfUqVforE$?M@i5r7+| zP(`W_Xy6kCT8-P7N{-9&@TEYgWXU%e@j4ZpILS_BPS;s9lC zr_X3g3~X=37h|e{VWnVDo3~F{k#ON7xG$0+T~N*I#DfrP0_9VfEzZox0Eu%dXFPm8 za@ybrOXu2W$PF`htV2~8ups_lBg&N{+Q1DtBke1uLS_B=y(nHL&kn~AhZYCkox=6> zQOIoqHYj+b@nG1LrwU2oOnyaT_6^38c`w~aUIUpO1O0U~QDJT-Xl? zs$hMJvL8>y<712iOTS;W-^SAB=L@Nf!cmY5C{r4zo%y%J7jF9jeh6@auED{*$YM!t zeR#9(eR+K)sB&SfFq|pJ6y$Q@gPK8&?~)n@MWPxM1(RgAlpoj9D0{@=FMfB>Z|RBCLFOR+I41t*(Jks6rv?_iGBa;Z`&2jRPM1Efdmbay2}Bx)!a#viwk; zzLb3-tZF;iEJlqAXjh<2yLmvTgtFOt*Co>1w>_C8sqr#AGNrlP&0Xo=-y5UBR6^7q z_RO?Jp+@K7PNiD8M3V}*pL4{8B|j*j`6$8H80eURRHx0D;L`S7a8%BhK@)On!eez8 zgJaPvO|Fz?RTdW;2iHD-^N?#!!(VKeR&8c2s;Dhy{KS5hMVj7-&TzsuPLQF}8U5vz zeQk>YLpep$fN0^=n-ZW&2h`{XYP`D-a&+uC5@6`Ub1gx6ZYHM;k}DIM$K*P(A=Hm=d-J798eg z_;6JQ(E{km`$7=2&ay#aeR3$zGc*ib*~!1vsr)*I&ww4?KFS1mG=y1@ zO|=+zf=$$@;wJ{fX$u3)m5xy^suu%6p3r!C7dt=mFSEBV{wdG#>C!{;h3ITEko_md z$tF~uW&4S~m~Q5vg+5`KJaU=Pv9Yy}O}Uf?VE?n}m`W&V`HLI!;j(jutS{tjO!{|y zEpF*GZAnh&`=j=liAc~F)`%YRoiabs5(?Cy{q$P56uV)ybx|<#L|Wtt&&AWhD#;g~ z+f-`EHaIvP2aAq6TqvOJlPQ)5N$y_*_~Q&($ktw=Np&2-nDRS5PN#rTjg0!QW*QuG zSRF6sT>m^6;l-5jZ%i;WAP*OcLn zk|$I--tN;}Cip-J+@p5}Hx8cU*UOFy()Au*iep())l@ZHpz=RsPr|%;PrLWHBl5Vm z@={z``EqVN4oQpqiu&Tz$P)iDu&Q?RkKqpAR@>DwpraDWe>2XuE}TMR@&q?yP&k)y zr8vKK9PG{7sCbKcO+?RIM$d?KaQFPnEMi6qN~j`Z3&M1L00+gx^|K@ozkE^(;Yep9 zZoRFOh_`K3OJ@-MoEC1YL;=@l*Z_X-|0dFr2Wzt*WJk4CeAlT~ zK+lef%IG0(g++)7RQkZBhZxune~--ry-&~Klg5Ps$>A&)%=btFI#Xy6ur;#1S3JFc zC3=8wQ%*6|KtctlE*xK+>KBmP4+o3zO-EJ;6R`Wr^#i^Ft5=-0uqO6h)S**FQ?t+L ziZtOX!p%mESY8PwYqB8q0u4_QD*|HTN7m2Kf9S1P@01X|uvZU_^qy`XCd^;%6}nI~ z$X@QX4}A9CuwL+Cz6S#?F`v`ivggZ`OHim?ZYz*PHi;f&(>zL_FVFV0Ym0|h9-`xNYWB&Ann39wm>QI((?)~7q`dOACUk7*6cTD-rwAy;Rr}*-)!YBBs zs29*mswn>axwJs*V}G2vq3YjaTki5Xmy?e;0OBl8e+A?~(YUUD*-Yq5k%7!aSPmCP z3Meg|lw(DqeGO+Ox@vhWrl(p@@L%I0OpqCr)1ZHo94xoPvvI^`w@u=$vXpkJ#p(CW zI$5y*iKIH68bVk-R_WD=><3A@oftOw9Nzb094o#qPflY!tFSDC zl=MH)zYKMs{xyz4SX?r(PS?RFT!H5Jj0JMa~nwmDq*5AIyoQrBkiqw zkWTSzR2H%gcpjb_UAN3u)V=>4q;5Z{q&%X<>RozTJvOWKPH%*D<&#^XqbS!N;YdQk zE8I#geV6O;`~Ox2o9VPV1)#~_AfmXxB;G*QhsV-wmOTe|X39kwv2NKADM{|*N!3B| z*Q^q}jAf!#su<()J9Oo89|`-$I*0}h?(rtj2QQPidai^GYn00D$D;orNr5z22HmnL z850F&!J}w|*AO(N^~yu};1hmU6x*+FYz*lDqi+Zs%Q3RLi`ghhJe|at+9Z|bun(<_ z++ptRP_(Y!^P-H@<^%>o?cD;%(;CJG=2-)Om`}NjvEEVK<-MK8;wIpeJNur+SH8*<0@{apmMt4pjEwxKVsy`5qTq355(Fts?>q)1IhMu3U%S1TeGt@g8;nKB%w#b!M z`+_pCaOl`3=munvA5J3%^3>CTys@u|_2}Y$(TPm0K)>OMqyiBjP9WiLI2bbMofcvj zsnMzaPI|=xMV%fa2VqiHP$Q*(Xpp>HAI{icaWv)~;hfd_ULAGt*PYb+M|V4i>4Vam zzp1kK9vtdrx<1d7$~&4rOFFm3I*~xUv;ZKyzffY9cd>AMsO!un3)C18Ayfb+Odurg zN1Rh#UBKqqcNkKCnAq9g`FL+63Ha8A0uJJV_z1a2&&WwTtt>59T4OD5%SXY#QVu`v z{ruR9O}R^MGvRbN>T!fX*qG92N*%PfL_B`O*W{jX7!OUsPwLfDmq*dIZMc8p{j z*>D82f#_{VZF1eQ1h# z6}A!6fYXLs73?hMhju1DxE5@xHcByST@l-=HV)lgkakkjL`)b4H`y#YF zIfO1eL~t^;1WB)2SduBa)JN!IggV7XWU+)`^tcKvHt1=>&8I2MSDNb(O60p*iPp(F$F9n_^2zsU03rjKbbI+9LZ zRO1jmOs#U&B){rNWS9t)I8Sl?EEtkq2Grbv)HsJ$Xk2exT!g~S&1eZzKBCU`38l zwL(Z37R5CpijvM~#wM?C$y}GXpNYR0AhB(O>JODT@96Vp_TA113)4%#wC775juKN# zxGR&}4EDDAk#oNYe*iyP(S%0Ogwm0uX?f7Zb zqZCi*hhP%aa!?1vLFLt$*1S&VI*~`titmn})+yYwq1`<|&%uzG=`CR)?5Drmn!DEftxQT=dQo~TQRR7dJ1L= zpj?wW4_TGwr5O|;d+8nMFC(X2!-`ga-_76|;s(VBu1k7nC!jx~Ui!i%8~Wi=tF;>57e-Z1QDqm>kB4x zaDYdBMP)k6{6{0J*1GzNjZ&uSsJi;WvpMnQ*!m8>uLcws0NoXHt_8#QCx5e0IM4L6 zAglMVhk>CiRJiLatUA1egajEJ!`7Li^34(8W8lV6A3jI-r_m1?)-^g*)6RNv`>L`n zH}m7)u_56%kzvjlKxz-<_R`Wdh17pS2W~wYYHsp~fWD{2y&nZTFDsF7nw7aSMXSpe zDegBSox5vxR$|H+yK~?clK4cYd49)2tC@p!K}Hao^w1AP(G_7&SJd%IQ4foQ{Ec{= zDNFfmpaD1JQvw4;b4iByZ|;J~eE8wQXmNRprisQjY91HA98ZIAe)|PZky?u+BDK&HJ<*!$;adRRFZkgbd*(NR@%U|BdBdv0{brn2 znZb8YTl6PtUX31%rk5~&+SDdU8S_;44&gSG(SB}eI@6Qy?S0%t*q2Uo5IX|>|l}Z za1Sqd(ICG{&7wbtYT4dy5$Jm+AHQ(4(RX_KRb8dPf5Mh#6}|01+Cg9 zN)N;t4>ZiqmK}=UlI$B{qg}N|=k3pz z;+BTF(**zaD7o_tcYy-Q*@+&}XzV{e5`xgwWeRbv+IS(NzzEP|D6Zs6uf(B?j+$-V zCz#(W>P@6>AW@$zMP(0leyMx8#0TZw(0xN-q58K`OU=0>sT;T#3I~g#V*P^9KG5Js zRZz-YWYY}fGbq(D35g+wAa)|`#?mU3o9Vu1aBPDJQuHG*zP@1_8LFQ;D$E5&MDu)~ zKhs$msQbcWGsCR^JovrkWs@2M9IBDVHoh#mHuD7!t!dFxO0oHJJf5fhbVXWtFR}Q$ zh@bZLXY9prYSuj$k?GQInblxIbQc9hS@`+~rO{t$v9#q<2b1nNbOyq_qE1+qzy{8= zAO*Mn;re7O(iN-C%F6DYYDj}svh>&g4k)1wM zTvD)?1k#0&>}XTkj|ooz}Qte{lqu0Q(V zsx@PCa}tHMk8UZ|YdMjHipWo^>5cNPB-7o|^{U7$+XV2t@8$7(#8&ydHt{derP`>p zn!~HBFLGdDJMs19B{9u6&1-dk6qj7$iKB^3p;e#Ouf=oj1{^XvIb zer$06$*$A$clQ|-xWfH+7ycpoa$CVCXm16G z?;Iw9wJl;`*2qK`HR(wi**b7|6~IjAKHAm^D}&}KdIJ*P2m)N``c^~um(&{P@KXI_i)_o~cG_b=m2-%gppYp~e>Pb5~*P zP+Vymkih&KPST|t=jr&17YnZ^>C)PTm6XlJ|L?-8M)Ig}UUEhdKurLD(=)t}_v^(H zL=@D93=;k71Qbfm3|elJVgEK71lF~^fJhI8nSSX@mai~)I9E^3ED$pT;y(k5HzB;& zsW86<>uZ08t#$29d4;L$kFiOq@e2TX(s5Yoo}&PelTw9feu;ZiCO}XXB3~3q4hybC zpeu`h^!fPKIYi%CkTqZwp795{MZql>7A0m5GA^60>4mc|Qp zl{K;W8RF0yfM%ZJ$^I*{HVUg#RV?%=XtWzwTq9!5q z;6uB>9`s~Jab}bN>N`rHmtva%bJ=jXX-sm|=LhwH51+elo%T`g2RX|3Vt5JVr4NIr z1`@r{P;wu^q1c9QeAg_NYvSNy2^<4nb$$!ykHL^yM(Nlfs*w%uGoW%R{o733PpId7%id!aCfa|CkN9FM5y-uqpS+ns#z{78!LB5F5tV~! z>FGIu27ip8NXS&#aPHUL8}d?}UOI(&wJxkWpalTW?~qI5fXGn5+DZ*2vr52ks3ffy zD`U6!NAs%pgEUA}E?J+8GamBUk;jhQ>{XNL3p=!#|JjlFbVrf5g&E}+Q`i@Tu#EDj z!~7~4={>4a=#_|ukE-Vbmp!WkXc3NlzuDS(j_o6r;5#(%ABzayuHLjXH$BGNG@bVo z2(LY4()>)W%BjnV`FE#~O4mlnXvz~`-FCyKxl{F(A9S+*x~tdUSj#MQJmo&h2xAtxH0`Gh+!*Jv#rT)G!6RpKH_beQ~?DX_JN)@7`}Oiq%@H{_U%h z%C+1wB;!hXpcAj=IU1~CQ07*R_H^a6u6a{U0giV!JTj^ov~%&8XCzJ~X8ghEG8~F! ztLIT7- zK=d?FacIzUw_`DlB*49SDPKg1W5{c(i=g$||L900ZS!%7#V~H!EYlIun~j?FSzywJ zoFlvYn+TLwUP82%5=v-_Vxqk*hC?E1p~1c&(OHNr--*R~DllP^S;X%2=fIUh0I#I{ zuh=jD_72*j?MKK#(N3divy?!QjYWD5@~+VgmCA>|C8D48j|&0fPNa#92SNO#C-bXp-1O>ZffdWU$@~h zCI0R)9w+#bFO720>TR)5!y}@+S&ufwN~TWp{oqAvDwnm=yRVNti|d{obhW&R#|qM` z&F_5AR*adD5tat^poB>Nm~w#=toSoCEV$M>6pJ!JG@*+8itqdqaZ*0%HT3Z#qlBus zuPmJNez0LCud+WL@{Q>cnocf6*5m?xp<|Sq{u!@M6zm_x&8%CYSn&uiC3T7-6EZ>4 zmfwM>YCG*)Z~Mzlq%q-FZl$OHJ$hjF#UQw%LHMa0&!^PMCQcS$|C?lI#OHqEAyZrX z;j#4od81WW=%{G>B@YU128E~ir1(Z3Rbt__5PzeaI+B8vmX1fm(+(>|r< z&o@nneoOvchy6`P0j1zhr{8gChz|+-GsUCS;jw$+G zLIK<5#$J2%JHvmgwK9F`RNQViri!R3V%&WMCSZ3QB{n*(-cL5A`aU6ZuIeRPLyI#< zPy-i(t3PJ4(yPbhzGEwvO?u%#Ll(ka#n>QLRy-;uJi{1Uy|CyMypoR+DP@Fn5ev}S z_q(Anw82$PoGRVVoE!#rq~byAoDZid9M`!J*Rv?{+FEsW_8za5KDt8`oYSls4CWM- zSh3(Yo?&@#;}HF1Bok7f4HX=t=fm}`;F^Ua#g~c`pY`m|?_F>vpqf4)5cSeIURnCa z)myRG9E+>{34%=beHKxvUab`s0u{>je+@g$R*tMUWU{prxUM1*&{yWvL}W~Je}NTj z$n~>whhT6s%B(_I%`T3?HzVuW5^f!0ZAzDZeC6}YxyoysvNY+pr|%?a`i*I88-Ata zDuFZP%&6D^G_pXTRvQk+D_SW=GR7FWe%)z#CeOPcKXh-(qZ0;tM8L_WQWSD1`CUia zN&8p3E9&accN^&FK9@Yf*tNaG`FH__B!t#xSXRA5YlIV9Iqt}r&sPEzh?Pl@EeOqI^rl08;zY|e0qzM+NVmPKW_?} z4|X$%a-xs%YXFeW^J3V&yKeQ`klITP4=2~PsuotVP5VwGmcZ@NJj3n3`k?P|+IAx7 zert=OCq}Su%!34wVzYWVkv4!}NX@KpvT|K};u(6IP&Dml9W7+!DcD#e)QuEsv(ebVL!-JF9Xo=>G`qyr}&pSYH3MnqqX}Sr(Hw_VxZ09p4OuiQaQ@rCJRJapwb#2|R#)%iJvN1zD7FBhZ}h zgx7BO99+tywR+xe>kpr~V4=YbN6As}^k`@f9${pbx-2sxQ6{|JA@S;}^oHpUZIec> z%I|X*TZ?EMsAjGnAB`Sam(Kamck>B6nOqej(5Jetb{Y*%}MRB3la>9!{#t z4i0Z)VUF%-01p(lrB|EGOyrA85yL<}P&9~8O_P?qcyM>|jY+cXCvPM-5L07G1u#mN z$3*Je=!w`3huSwDKuKCJeCJEk!7doc8$#VRDgZ*_C`ano5k835u(lQ+!O+tak8cee zq`r=b|A|8JzwI2y;@;}Nc@2bS%|r4UTN@*>BI`pJ~u)Kx=KL$M2YBR!X77!|#l6uL<_;h>VA)vO33 zwgI-mO9e`qPedmh#%=H#IWmUf>I*W>%jqm(G+U0;o33n`^0_6N)G74F;>PQvFU?#x zO>U*FC!LY0JQv0-Pt96-5>rFO1EFv2M#4iJsMb4Cad$|N{_hHzDw=DwS+h>{|4f-7 zg?8vX7?~lJQ)lDO37NI}?#Ws0{F@(*_q7~~AZ65?jiF*cte9jJzR9RTewM&p`7*5x zS2ob6U+u0fiJw75(Jq)$McCu-RlO*1BwwdHom7EGs-nCUIDy*QCLZCkj-&_hPseDE z5Z+6O?M9RtNc(rk20Vg1n4jc6s&WQ#)*NB+z@AiC8Yt~s5Dik?a6RYrobYBnd4k_v zUWN2LhGztIKPAV{ei>0-{gVZc=T{f}b0r)iRY@S{$zn^=S=+!ar3811!j-U7jsgWI zfTAy4PkCpUmUPG@g>K?dPmpJ<&-2Z8A5kQHrN=a|cPDh%qCim~YP!?9%e$W6WQh{d z+Fq8;*XPZ;$j!R0+B50fm3K=IFgjbpcTd3Bal8$>(^;ie&l15#sG5r0{8KJ0+eLtZ)fRm4>~+tH^RiUEP%3an$6YomlJJgHVZLhmE>wG51Y zLE~!2^h5dw|ArB_{nwFRj;;L*EKSh^)1=!UW5 zjRL;OD3Brqi7ct5Zpqz};Mwjm*YX-O^|wgW3TN0_RM>*~lJpiSUM*2e`sN%)f$Rz; zQbuP`bBChS92N{DV5JyrrZh_*d3`=oo6c{E;>>bTr>m1XYp+;kkRz~Ef zo8QWj>_f+!Jgc9$V%AFh(?)I4ww}9*R3o*g`NkJC=LO$W`cF4VNRXVnX0Zx?MO%>8 z>Xc5K1k6JWI1o|dga=)D?w<{3hZvH(tCyNm*PQnrBz!N)tun)GO|gMU*F~g4@(4Y8 zV*x`ySnMLrqZ->N5v-8$CF@AS!%*trdLg3iv8SWX^R%(G6D^p|tumbScW z5@xP>9*z+(@4J6ThyOT^9IuHJ)<7VbCqT2Tzc`fL!`h2i@O`otNyVg!MtHi8L-q)@ zNahykYM$`y*osEO-XOz@?x+5KcQqRjYl=)&+g4Yr)&tx`At&7Bp$-g4fW(~7dtM6_ zZRd_lbdt8mpZb`5%aie@cF{szbXsO6dD7)x5@0NCdQ2SXI*f zdn~d)Ucu$rD-ZsUze9L>AlqAz{*-QEKokq|@RZ)z)f)dO(8p1PXB|d6H2d?<2`t;j zP^!gDNa~9>4+cquleBSEQIB``8nN{CPh3Ay5Dz1c5}^z#=&v;>wdlcmUBy&tU7S?WqRrr)VCr|`;$@oyg{BQZ@eC^kDP>THCSikps*+4qvFQrhof4I z9?amLwmH|9o~=(Eyf0*`tDzRN9*<90OVe~^ZUUi=CkpQ6R4YvZj`A)l7#B9B367z} z4=&*@jd!)^B1PBV?JSepPJ-%B0%FNI-=18#ADBA5vLHIy<%W2U+Vw<}&$O&PJogI6 z;bU;)f;oNMjSWn{7(kxa>eg8M*ch1Q^M}SK%7$BI(F7ACU6WQeD^8e@xNWF+D?G+5 z;{D!?1d&(#q^b=v>-dKJ#wFb5ziCJMP1bwvz1+V^d%9n`ut$M$qZo+MrLG$CQF_Ni z$;Z7X8mt2AZIV(>9Jz%DJ6#6g(SCrQQ_Iccp&_f!xsm75vI5VmZM`*_D%;vgKmFS1 zvJKLpFn1-tU<`qXrpt!I1;sw#$k+OP0)$oAC%^fF?tks)@C77RJL8w|VXj;7|&~ zlZD8IP?(U;B^S+_izz;((#pGoQC&#}75S6!sPLIK&0cGYF6pbzA%_2@DC;wavmURN ztygSCxkmeu1GjUWWqpNg(i%%*23}^B3_KS?8h6y)_i9^9D3XqCNcNR3fBtPHMX{bElr+Hk>3{}ky$MX=9@&cm8jV>pb1 zY&Qdy3Yr>{x zo=;?>_Ka~I0l&S>qhtZ~-wjp$ij~W8R@6<$sDD++19weEa3gfXWG42Zo8JM|1D2CW8w0mU zw$kj249Sdy2Alqres>Jtac?OOEJVdI^U_PGXZMsVRq@-rtKsM`2c!f82{17E^Y*u$* z+;Caj_cfLx1Hh~fR)hu;!E4-QArd>{Q+}`9bP@?!BnlmSp-4C{>s2RtuITb#BjsR! z=Mr^ka|?O1N$rXTt)zRc;@XBq)6&0F{`Xq`XLr^(uD6N5cJ6MV?GK{0E~Hg0MDAl= zA@nX6F?N&r87kS`F!SGx3QTmhctj)SMK^Veo z!4&)b+TCc~C_qob^2cO-G79{_A5nGYa~8#E+^3^t~lHjfLaZ-6Hm zBT>NjPQkGmw9PBY60Busb=c|}ERo`t-$F)=?}4E3)`8+bX-&SK`q zFy5Rh`%nvw>-js((JX#v^ zyUrdw4&K*5$2Z3=?{#`T+zz>2Db-`k5Rb1KmgIV@`DU$9c4?JT?BG`2O(P(8w{PG4 zr>CTYr~WXtT{#>s2HTL%5l>G~$K5J}#PnHN+W}v}qaw&Pn1YsXXPNx${Gg18rwCPo zuQQSF~-5eDE}O|)$(!RKPU z-l1ZbEtHpI+Bi+Ce#yc6j~aL~8|56&)q0B7ZbGOUusqBKKP&s1ah!YK=~m zqJ$hkN%05aE6AA+k%l)8nc6%WXqV0VNZ>>Y-%mF&cfg^(@CpgM#RhUv&k82Yhq^mfS1)S zBW%TxnjaAXsV4x28x-Q7qm4HHmp_KmS26E$FH)*`UGi^>CR&9*QLc&C@*gJz=Y#^m zFRg6P+3LdV^nxiYq_N5Fm&LvjWCya3-id>A@OgczZeL_#xn*yx2whxhK`V-MZZi_e z6iehm7XPPf9Yik-`fc=-KYL;N>4m+Qv7b`XQxih_DiSDJmFma%wUtdJi(s&%7EQ`j z6T_P)Os%T3+CT$};!%V@Q@?QV&DZunmsD1$9sK)S^IO>hHit}9wZ!GwgAj8sToe7z zxpCimRFu;P0ClRy#o_-Sr>~hbV7V+UzOw zpXKsrF69ho@%8of#fi#2#+b%=dhaEIHF!UvqjZS*4vFXyYT#RA-#+W8d~M`1s6`qV z0}NFA!K_gX_5d%Rup8EDLyvl*(QWYmb9^WenRmxn=M9XC1W41hNRFBd7Dom7DXqHa zFB2kDDY#Yxk28d7&jVs}BB)5t@jrRnA#WpO4Kav_Qq1OkOU)4#f{D66F$VqEfTi`! z%|L$=!ajJigW_?o;Z>)uhT7~LDQP!>=3mf8@hge$KIjmSTq&qpUu&uS>c2KIaZsb- zm=f)RgE`#NZaHwzSSIH$BzMW*4gaLE3x*Ydf^ytG8<57omx~I1Mi$XE>?=eeRUqDM zi?M2sGsi(OL|Jp={svJc@2r1P8jURby5j$hJOkO0-W+(n%53?FirT zk@8|yDaf0+M!u}{P+X%|oQ}?2RTT$fQnb8ziMZl-MA^s=VlV{RXVrSmrnLn1d%$p2z3k5>N^8tmb1F8QZ`WRP@;D3k-W_0 zN<00Pt0Y15C3SpqGCEc|#XiktHJ9OMSj}8pRUk0iK!cD1)Lsw>{AhYA(RLaJ_ea65 zdaR;g6%i@j!U6-~#0Q9F;Dw}D26)HRKj;+#*Qs}kvRyVCHih$N3%WT zg5Xa5e9Gs(z~|kz*GsGW)qv{D1bV4LVsEPLv+hJ6ydqf>3%@<(PX<7V5Ce+(ujNM_ zen0ws->Ko>C|#Oxbl=C#(j?@wN29&*oh1v4`me#G5SDM_V~_<&!wD7|F*vh zGCc^wPwURHNt9$!faVail1<%KnrE z*|>tg<6xI{`?M|`EcIy4XamRBo>wi)U7x!`Ll=ced|ZDRZ;_opvQ);$`+(}-p=-rB z41M;;qliPJW-`0=7ZWA*@ej(k3w+%b17S3fvxh+fMGQY%%r5fm6hMt)?~{0#?_c5p z`Teet+20%E-l@Ykb+?=m7dHN&T&YDXBbO{i)Yr3y;8^Wwvk-B|!pP|AbC={ZH-Pu} za$Hh6@_doB0z=k~a1yc?ujYJqG$e#c#W(@9P`uGQA=_|EwdbSE#rVplxU`Q&%_QhK zHpBbET@f$NlZh8BU$?gOe<7;2^}{LleFd4zL?9GH0#<+9s|Jh2te9e)->RCv!eRW( zFpvaR4l^gyCI*a>(b0|WWui4QX|jC8<19DFdxcX8p#MuJC;#<#*q1;R+>cmOagcDn zq1+Nw-jHDVfu_hz+z1XPnYNp)U=Vhc$giJ>XlSQA*|}vkYW`WUBk((@cxg&5}HB+$GF~NQUwn=e7+vRTzz5-?BXb}%( zWpRGGOd$0ri$}$JNx40#g z{}$Cm_DKXm)RL&P122gDx$FPYbQN4teqZ;Q8HN~IS~{c~q+HYGVO|y?%1BZ8E zBs1kAYD)qr88yPmzIKyBY?7#+Z>q2C)*By7(wIPY1ca;oHKLNoox-)udZlObE3( z4=PgP^j$6p*(KW4~q zUHU!NnGT!-)~9a#+`NCdwE#Ka6`#h)Z>r&9}{zHk1S zDJ-RbJ7?OL7$~YbsPZ2q1UHi(J-}_ob00(}kGbOG^3%KjT>Gx4_mcC?j_kZ|r zQ5&wb88IBfw}mI#Pd)$k#e)|(mzPvgF4VsgU~xR(nCh#0H2Quk;HzVC;gFI$4yiQ- zx3lKI^H!M4Oz6t1agnR0#d!U-o2Dt;>Z=WQ5{bTaK>`0;r$HxKcukFjrdDtX7?Re7 z?-VBC`~-)Mc&+#R_GDtLYOs&qI0JZD)_zi6)qlz-&CI4ghR^=Gw(T{-q<0XcODd>g zIjoUY(-xl=UNX10o8 zxfsPTZcCfM&rgw7L-u=jy7eVAJXI%qG;$D}D#^x*5gUCYKJz$vdz;GD?>Z#X-6ym~ zl@Vx#%>$+{v7;HVeIfEdESQEiVA-woRn%0_2oWkiP8|*3k#oQ;C43q=sw?sF#$xwR z+KGXifCujl^^GwuYt(xC-EHe+cl*^+(7C8BY9NB*D}Rq@zugqHT-^)|p* zpB7oFyg0`A37E$}uum>x`|V0rGJx#jaz5%82?xV)jCGc$J~6EdCO!Ji?`f7kL~lB^ zT2lS0VmQ~i9*P^~)beDD@wLixX*z>YxA6naYLyyruW~AM9bO6e2)s&J{^OmnYYyS%e(9fM8&3v3+R+pObtUZdB|jWd7q? zwfz+$e6!vpFK26)2!B73vfBvV-A^OKnMjwtzTWh>oD0nh%#@OdA%lM7d~H$li100$ z@8i&NSirU~$24(H!*Ytp8ZM+IghI+<+VXKZ4u#D9)#sMmi$4DkMYB#1azr%O?bTdF zTG-JESbjuc3^3dfo5%%P9Z&8B`WxP4jty!Un)CSzi}5L{$LRO-RtyP|JsH(#G*-ul zMrMA`z5jT)%XiPVggdIfQFUPR@Ib5!+%a9Oxqlvg=DIB!sq;4x4-yLeY)=G^`QdU1 zc_8f}ogVWfj{eV@u&pNA^VqZ3mbSx)pVJK@RE}#_-oJ3%V)c+NcF?*>T0r*_+H9H@ zE5KKwMm+L&9AelWygtSBB;RJO-J|8&Pg$?$}`p=8G9F{jkGex{4L`TT`s zFe#RwBzn`%_-_r|$g0K$Q(!8OT|wOfR!aBTeGX(qKyq~Y#TrzOKMgyhWZ=h}PnA_H!4W|zWQU#C}wfj!$#cPZUePabSH$P3d~qTik(VU4Y9?wHcnZA@Gi&7lsVGs;?r9d~=7j2gmvMF48 zE|b~CKGv06xstLGKjmFN{dHIi`_f!n`$+Bu(I4Nja8j__{*OEYWn55q92wvm6ht=< z=$+d$Y~a1dw$}Te*!?m}H15atL8}5x3}lY}NHAB6fBCaxw*7ie7>#yR4Y%87%IX0u zcOtC3)Z74GVq$D>dM-;3F)7BcxF2d$)1YU6+o#gUf;3Y2(%F&~-dMmzJ0zz=|tl1dOgvM+h>4^!LW{AI6K$P*V=?d^9fa|5{0 zA!}5OQ;TU~xYm=s_*pGmv8D81iD0aZ+^TeCJ3F)AxqPgtBtX@2EOr}g=0cDR+ahhP zq(}*3BCW609#T<7;i7)>Kq=%kHg?z82j)-?Mg$l54&!ak>mz%H1~AKaGV_#c+YI&P zDV&<%x-((}<6r#H9DrYyn1ZeVk#&EWfwG`{=I35}I97scCle3Kp}j~lckkw^6t$bT zTZZ%#D_^?p{sCi0M?b?hXL^+RI}-D<8RhbVcdgJJf7iWhuRU&d%Fa~9)ZY^vYwEI{ zU+i^2tPSk{&_7#m(qmmy5~Z-I`TL$(AIG;$|NZ5IzfNL)??6aa$G@4a=1iIKs&|u; zAHD=KhSt(Up(G`)SNj)`TjCUZ-x%`8ekX-4s^Tit^70?SkXH~HW0(GsX57Y2@YSH$ zx?3>|g}Nr&W-5 zE(cLa!EPIC-Clz*YBvHQ2Nh=8wH44{@2roOoUa({iwDD+)sBO!edk~bmOfim^55CvVZfsn-Q-~K9u zLbb?f>knm+uo7C>p{UK!dZ~{6W-sbNZUa>T7{#=k;@6@+B_FF_9hZn%FI(T;iH>e_ zL$`CbNo4jv7$4a`PFFtc=tWf!QlH2N-5;}dN_F>cTUK(l->H3hvg@!Wthnhz>RV6B zP`B>>Ypb5kC%c7M=!0DWDdn9q28E_idb7#^>uh&L1D;~9l~Wnp4J>rJp?a^ zu2uXI|6a z6SKRiIy*CI6K=~-E@Ix<$5vt!!CzO#5(1^%;{|<~Su=5gsa7dsu!b&$N~Y|?<uNw4y57ORG72L551K>q=9rL82xc^zUeSFf#BGBGs~@}Sk%f&8HeMgGJv zR$I=)cfrp&;8f&nPH4jCSuSSs{TjI0 z^0)@xI+QO*EogmHd(CK&M(71mUAYD#%u z`cKH>V>zIUotY<7RStA}2`f_Uf_*9YOn+q->HxjYzl=m*#;LefRcN7Wpi#-MDX3@z z$?SdbJV(k{@2{oNhc`99QL?voOI!DBQ-Z;jhUl(zOqGI5U#t6x^Nv1XcV&GLBlP}r zK9nlgHdn&uKZL+ZR57JBVof-zoxxa1laKgKBwUXi~o4o z{`YUc=a8mfb?;s*wY%N!mycby(Q9E>Q|;*jqnLucF@2mJ2%=;|Xtlw<6z8?WPN>Gw!88x`)h1XzbgD_r~!E{pfEpj{) z!AY^;Jxo9Lg?Go)LLSWX>8!i}=jyW|hXt71ZV_g@@mqK9>ZL@&+PsUi4n-S}2)?R! zv~R;v*gFsBWmzf~qPNW@T97}k&j!$r3Rny>IpiAk-ed@Q_|F`D3WO%)*ddenVIP^; zALLt<1GxF339XxxVymw`vIqC=H1}hu!eN@K^q_m2Oop&~GY3U!O8S4k{M~ora}zZm z6a6#OBQ5w%@sSl^kM)$N918>eF)iW-a5srhE6-*1veo=9Dr$2iv{lz|q1CbiE}}2> zLmMxxf$Ce}LIBG#HaZ<@j_l>*eA8TnwgA%4r>?o`kR2 zar2ny%2;k15)X!HX#b-;!+3hTUK( z&)YOFZL-za0{5bx68rhKbBPB3PEDbt^i+rq=C&zZOxuZ|5iYm5Ayq*wyj+H7GlY!k zh8*oU8HnutMIRLc+>mDKOQol;ZnwsJP|+W9OBdy^+bruk&^qt@?K7>H)$@w_{^NB= zSYz8*i43A>_YJutkjs;i)OPw}Ri70Cfw&blfDagDD)7WwU`N;wq)`pZYyi!i?EMWP zeKRT_6MAZ9gxivjqM=6ch(Ap`-Q-J0XQXysMF^e1B#3F_Ck+j^f*v7rBz@dcrw3kW zzV3)j+!eDMINuUP72OOZs;JEdzJ*d145%FZt6p3w-sn%9<3pUIG68puNk$QR^&7g3ppiO1`?b34bUvfs=t!c-o-$r$iT%{kl@_rXr}uw*Auy8b_O z2l849=l@v4Z*PR5H!#HGHvufRs8fNNL1_*;9_zLf%aR?aR09U60G}2hoIjJAR0_)P zUwgb9O>9RO0(#LvzuB(ADE^lV#AxSO^fW%TCsBVnF^@SVbgtOz0PN+){XuLn6_Zb<^2IS z^Pufg?O+3jO=cfB>E9e&|3>n(TBq#yZi|q;&V)NUp046PcQWKBTJ#%|z)waR_+I{% z{I3;1wDT%T_CvG2U7HS^Tl4~C$~E*N5M{Vf=*rG%A6Y+ZYt&GG14=-@hi zWxw@QUsmvp82zAD*CdL^{#Ee5@wklPk)%6H_3_P z?N)-_!ZDiWcl-D1{KWlh%`wXwX%e4%j~lj=@kfU-iW;6dtOO>dgPl5GUrBoZWYD(r zJOPx96ofa#+1oLzn}Tm0Pmz!J#zW`rI}4^faS`VmF|^E%R@6WrNORL~``mUXYrx)_ z=W*usl)O3Vi2a|g5cnUclJ+IiG8b?&FAh3^)!w4M`R#W~5}qr1sqz?0cI>1tQRdxIQM^RZye|P(OGUiML=sdy#DX}^P{3{ASVp+y zqmq24RxaX&P965Z9XZ;~$Xpf15&Mv2>%pv%&oFxVg#&5jlZIo)8|W@iM-DOA$J7Fe z%IuS^rCd7JHek#HSlxo()qCGrlbQ^Z16qK>!_%AV%L@_74xB+z4gLO9TK20z&gabrvB}t!XufB3o z2jau2Vp{@!^pN;8mMxt63Xko5SDO5{FR9UM=lWDNqbO`(IAiWSgl(~CdQ1$=aLf1C ztSdpbaP)!7hSuO+1w}t?=Brlh3RD@@-}j>*@KYb=@Zev;n1Z{AGEn+2pRS{O(oIiN z-*8fR*BaSxZHiM5Hpe3M=N`fzQ3Q=X79R34Gg?kAZpxGQ|lmyyRx1V!HuEI@8RY2 z$uf`Zb&?c+A)oIP|5uZg!UG*A3Mlf-9Q_n;mjZ3d$vnz~f99Om7^&MS7V}b82tZZ6 z7wO@tD5m~QcfyLi#h-H@n(2`XRqCGYVMR3GAF5X7el=0VdTa!m?V81@qh`RFxk0;+ z7z>g_@f|z<%i@|^h>_GE$I>WA9f`Ubg05JKMXGiNmHc{l&VouM=gYdpm?uat6cuN3 zIav#~@~zBrBMkYoZvGXVuwd)9kK&`+{ufg4r!Swm08%i&S3lk}jG;5_FSofQ?|CGv zDG?#{Vq;$#NhLNHJN)%e$4=sp7Y}LB=w5#fR5zk=!dhvwy6_ z{+1jZBF1U5N!i~@1Es@(&Lkubudl68lzY(Y8U3*^FAuM1AdxezyesC76C;BMP~Wc1 z&?B;E-oABK6&SyqmK0ZQmxG`B`9m)Sws?lu>P{_MO)Y3gM1Xhti*d9`7_r>2L#*nb zfEa$kJV35!Szh$Q_f4L_)4zrrU6|__h^`BYrIky=TNKam!<2y`&#^>qfa#i2X5B|= z->zpCI7G~Pm<o+uX_p$ zDIwF8Yl_3awEo=I_f%&$tYIm>gSNJcdE~;XnTmpG!@3R847%H#Z&&`serWaPrCq8{XkvC^LEDb4x)M!s<&|{4iOi zq@K=>FTAdHm)o2@5B2=Xy=r$}+hS}Ol-Z3-N~$2?mz=-yf(x0>wbakePV94(KDBT! z?wR*+Q|dd+Pt6%tA|&E>9J#r|!$0(p1Es))muxcwK3L5PT9tXOZr7#3f;RSv7mi&AP;$GWTG(RlZk>jXhZO9%pjv=GAGPgg^N^nPi zdB8ERg9$UkP0E-^4vG2`d8PXVuGSG4B7TgKt5F%Kk-}k&5X2?<;?NgL*SS2V#gV*e znwM-zRSM2b>e4b6T77Dfu#&`+noPdX`(zu2k1bX_YfbVmh!#pG4YenByYQ9UuwdA7 zoQW*t3Adm&w}oavTg_5*KYsNI*qtHd)*i1E0ZV7eBm^J-1@p)r$o{ket_=Rp6Z^4^ z8|VN?P5_zM8Qut=b)7acFwiWKb%7j(GQ1%{JfC16zq^xa?J5NckKXU`K=+pXU27zq z)LEdB>5IkFj(&Xj?{E^?-sDH^qj;TAVT*4xs63*aQmG;KIyA~Fq&?<$k;k6q6NL~6 zHW}(5I9df7>!)*PB_q-Kr{F}j0!6|{ZevSuf!TPhY^THuW*l5D60O8v;h}?W66TbJ zg$My6m@(Z&8VHr=eVPaBX#E>IoN@V4JY+r5ZjJnMsroXw_H}Xu;he|rOYQl+JW;(J ziZ5$U0o}``MKAd;Ei&69s>=ZolRYlb1%G-JCY1&>g3akG!5YMF`k>_b`>uH)tb}#Z zhkXv}qkx|7_agn(?68jU#oNDKGjH6Ccyl6R|Hs^$Ggwp;nWS2~L zdL*2A-scJfc?~XDS*xy?e`ZjAg(-4%D-XvT){BobWy45@jY<=cX3BttI$U+v9IF_e zzr`QdG7w$}%5+^A`0(-J%HQgh<=rz+Q*h(YblJx-l-{Do!SYeH=El&1{Le7k+SxB# z*KDCqynS^D>l-mbbdJP!%q$1IsS)mO&#Kr!8=ITkIvIj6>!Qe|Y*(?#2+>jm2_RBB zQ5abOF6fuCcT@au9~>U~tse3PrLmjA3;wZ2SE314H3IRs&T(JYty1^?JVQ%Fm)`VW zd*BR3grU8%uiN*(uhWng*zzC!QzZ5r)mIS|v*g1~jKcp&nFRGdi&ZMck3e8#9d{cD z6IoG*y2&Ypgp~kf;4zbL$`6@*qLR+or5Z%sX=}aBY6dM>MxbrQ=J~InOZ_Moe$No% z>X4w1ym?%HQ`b3q1O9COa?Iil3XBEDBA-JNq!ArjZZvL-BFLkLHFE-rIiCM2wh>Im z?^<+g(ddfuY_hB@z?4pkI_3V=(7_P%8w!;$nlDa8JA|;KZKTDKD7EzU^<~C7p3}Wm z0VQR#n6GhH>(+C0P-liZV`QEu1$a_AoJQ!-iaO?>6c&%nn*X!0j z)Z5O^XEU!MQ7c_X@=^jhD+%|U3^Rh-+uTz4r7ybQN2&pn?-8nLWJO+l=n3s5$R#CL z!YK9n#~^?F^lz&lcH>cZ>(~t-$DauzzhZq}o9%4+?m4}1RVg|S7r`E!VO!<^@)W9> zA-5u)+c03y@3qt+ODd%&u{YO>Gq5fSsC*T-q=u`5jeA;w)6>%z9SXW2=fF@bVuyA$ zpF_3(&>S^vubGs$sNgpBh=YCcs(JiY53;FbRj+%xQSgy)wF}5iEShg?f@bcCI7?>R z3&jT_-Qmg>y^IXl`r9ttjEAbT?2{hXVdb*$&s26gRB}xXRN{N%)=;nug9f&8B;c#V z4j=H2`rx;vsur)*C+1702>S3k)bZLdqR>8N3tdtOGQsxo3zh*FO<#X)${W~gUtO#{ z^4gbG$~SDBS9^Mt`$r8QbRIA$@oX=N?94wKY>Qg9;tuT$Ym-M|@IpDQTZDqPtUeR@ zMOYHsHxX&*+Q0=LVq#+6O5@_j@2+@JBl<9M<~{$Lg2rClSTom?15;)biB*8DG5>NNjux^_6=`5cVxXSX}i z^%tECJ5#VBo>BV9%0p0!8NLu zCkY*ac>~!FvD3{9AhUV+YG!T-Z7QkBrVc_7t_b}WT;?}y#^k$@>9h#HNS6C3xfE4lcv0^j!V&tMo?$;+i<+nF8 z$qa|kkNsn9PhE{)l^7LMQj%)AIX_2tf>bSMWMGa;+#lsa^u@zT+y0Ba!x$dhH%L{Alr04Y=SJrUO@Y!@APehilb|kOwsWYGv+G`chR`T(NBDf%JTS5CEW7&yX3yNGEdOO zZ{Acuuo_Yz_1NOXr1x~?!@Q_PxgTwQ&&WUj zti_uL_QEy=pEq4PsJL`ClBc=*>@k5)wn#S%Eza)}L4+1`ePuA0ltO$_ z(2(<}%*cxSL|zGroT!$UyH+cEJ#-|DG{67+v_B2}hKT()M0r`uA9z6{SaKi6Zep+f z-~H8oL`#SGw;oIfT7$Kh0Hf3aBqmmks|)X)syE)c@<4O1F6aqA$Tk2#u5|$+s!)hQ z_V!VmH+QVmR1zhghO0FIJ$-_$Cx3RI}$mo zi|Y@Je0G6u*)WYW6;PL8xfyF?1~+`cs!rjfd3Q9c3lc3d18p`d{o1G(MS|2eCQa8<;SrJ!ftUkt8LLV=c1Z zJqQT%01{c(X8Xcm?auI3PT|;>reKF~pd#aUl<#e3h5B0nDDLUDac03N{#Va*fCkfv zH4Cs5@9xS;v?SiAyfMkd>206t3AJ`rI+^Wz`@NwlVpzb0(pM1k?5?QYTSohM< zA1pZx>11+C$DIyBxv4)#rKY(s_~1JGJ$%RE(0eC+p|tk1m=GSJW=Hu+Dn?7!G&`CT8 zCIvf~g_VNomR|!umKt__mynId@llENiNK^KgFjW;gFYaUw}`n61Md4gn^Y$*^Y)*1 z1rh`VjM##VK!r>8!pY5r)AF)YpCcIq2!v(bkwU}ES?C2bI2g!neoIAyjnb*e*Yb$#m;;USC3NmV?yl=82dgDW1dOl zqJ%4Bvqg(T>p{qo+C1qDz~riW(wr}hZmW_%_f8!yX+>>OgTQj5-`HT48;o5SiLY)G zN=!Gy-faEayX!?L4~KU+9WFQy&Q|KfL*1FQdX#_TsMZ!}j*hXu=# z&`aGu^}9}ultgdw-gIfv&S?HIKQK7`dncx?Uao6HK$dR#yyhjc4S7&Z2$ndtquiDv zwhj+EtS6*+?wnK(M3jZ*VJyc78^7~iTiOQ27mfbyl?0i)ZeMp>8tGG7`(?bz_#Wn6 zeK*F8cnvs-cq9IQ7eKd^>E&^HI%|su--&4;&!0f{+&A@qDa;*_avf6>K(EXn@b#=2 z_fUx=R0UPj;HH`@;X=~1BD&7iF3x744-*w~CZN8Lia6cw>&{YYX@tRP9DKQmh(K7v zD>bh+xucm|?j1X)j&1HAZ?M~iP=ZP|dnI$Mt^Nay;T*|)wrkUT>VqGari((J%*-~v zE*oqPZeU4}@bap!aW#G7yuZi)0&8c}!Yk>XW-=)6Hb7%$!X=Cz4fP06if{q%RXbh_ zh};aB;BcnV*xmB*2Oq~C*UBbAKA!`=0^_=8z|B*Sw#ENQz~+)=#*wAbD%%sHjiKw# zmsnB$^qou$XQ8RHTH@QK)#tK{Lp#^jv^16y?uf>PvZ0}NDGsF#-wDFY9sE@rLzIAw zq)P&2(xX8k*{q+$EH`3!qMME3uj8U^h@LK8^=*mSQwHOeR=v*qNBnDr643niU*1~g zfUnQa7Ww&Y@1~r*SagEsu&>#09PsGr7zah)(Zqu~I2o$2MrU|{v-x6bi-?ZZX{0V8!dIyg zBj{On+}!`OO^XFf$})#1HbS?e#I~sXAV<`Xk3(5g0&CM;>)*_VWxt*Oq+jU5w`rlz ziA1=VycrA|n@6h#1kHEzUn=B_>}ttmrEQv4?tK3w;T^v{N~3|7BBC&%&j?)Os4yb; zZu`irgIM@q^<{dAA7>V2g1YX!FeX?=?3mERgcgoX4jEWDCBf@IszW*CI?hJ?K~d91 zK_FxQG{REHCHPmeq-b?&h6`$Sr{CMPDRiF{hx_6h{o`wk!5FlxgJevuZ6`_{&bQeK zO9NNJ@;JynHANejqYT=$LU;gUW=f$zZh~R|wAgKFyR6{u27n9{wGU#McF!}>Mn07J zB=j@-dT{XX42~>yY}U`~X)E+XvSMTfq7!_DsiDCxFX{f`gyt_eyzP!6F3>G!lYJO^ z;#ZixVeiMbqC^j`1|1Z*UQ zXqj1yNds1Etid$#tK7b3*p%`#c6v0sDaP?d$Pi6L{15$$^%WJJCbPZ4m*YA`MtrvA zCtZi;bp)Rqe=uQCQZjoH>g9<59+@kf)r+NE0DEcxYL9+TR@#fw1PVuNv&Hp*T|mB! zJI_q3GR_s)A(lN1UCuxrroK_p6`}~Ca0%8RM50l)cky+LDFY6{j{}VZA8(A`Oj(^3 zJ_)@&;?Xc~AS6lEoycP5+X~O3_}kLhIPQFJ3GxTTDR2C#hf&sqn8DSkK2S)aG|@c9 zi9kB5+3j5Y>#y$l-9!9AQ0+!9*Y9ZCqGiBg?jWqGUwn&@=OjXT#@K z@%;rhTS*;5q|6xnwTIk;9Wy~c|0`cCP&auj%$%AKfPo?H=T$nS$eY`xOBR!fe6;F|e^zowlIXfGIlRwGJE8L`Yj zjq;&^KXD$I=q*RT*s(~M@7_R3Id-3I3}KmSCx-~VFd_nzQlDnt4QDvfQnF;jT~{=c z(;9O_dZ2;cP^plv(#b6>)j=$6+a8!`=~zYy<2tINJxq}A%Cz? zA|>YFq|+az7JNfrUSYvRgT0S7vsq&IUOzDr$`LPC?U)p~M?EOj?2ah)BU7##i9T}? zO??OzPUmma7)Ci_1w+6ld4==aTvUg^4G0|#x+&wphI?c7k)ejOwHo7+3)ozhar zaoii{RzmAEz`e~Z6L?$=10t)L(P>|qRy%jkZhQ1Vfzl!%tt>2_CPhz98wrqM=cw_tna)$5M%BwB| z>Q|harp~4!v)O+=ap6*Ad_3un=uF?B~XJ zo$qxh@l98Pm}i8Grrn7OvdmFV|_)RDm+Wt#+Jp0eX%@%=GA z_PahCeon<9`(3=>Uh!%%OVlj*az6`-kZl?a8JBAbuA}{Iv@@7UT_nr!>1c#s6W9cy zh(Cn!!Zk6@PJzA-qd=Z-vQF&a&Bcv^%~|H90)SvZh$cZFi!W_KFt)_m+z0@he6|hM z-mwjj^}T;_BR_RjObroI(8=%d z*i8>&;7Tl6vv3%z+hCRQ(u35um{iQYfx)g_-;mDy{iGs7(^GS%NS%XS`dMx6ZF^^6MIbXT|trR2CKyB^MVU^?x>;(JGh~4 z2DAUeKXr8qp>zLPBa?^(g#Gj!HlSFFZNJ@??}|nn*xu$dEG(dYumRu&aHb3hIffl- zQ-!t2xOKm)M;7;%&@PlXGGwfWLA&3^aQxyqN>n8{AF7s>H#T(VX+z6^iAgdf_FmGW zH}>sW67G625 z<`+6ED+751cP-pGFGE_cqIQBJubGGIueLp6Kp(EJE!{cUTK~iag$qDzLG#Y^xWqs4 zHBvupyCKz{!zC&SzF^5ZJV(Y++?J<^EVlZ*`VVHy@m9BavL?4X>9BDCPFD9D`Fwe zlr1^h_cWVq)JmF#h49E#hSX z_s-<$BGMoe0rj8#`Ryw_PQ&*ZUEo1|;&%9MG&T+N`FKb3V>=#F9i$o@{^hhWLJ!kA zf&1ClmItVE!eM%>z|a8E?9;S>Rs=%<|s44qyd=~*b#;b}gDi$2cr*bFSi(RE` z=Wfd{jrZ8qF@1F@i{QG(SrbK*1 zJx2#(*#0{ERN}wJcig2 zf9lnOGFy3Qceju^@dY!)6(P>QAC=_zve_k3tfiS{e>lOY#E7S5o4`?-Cho?3j}-0} zFwBzu`?&Awtjl+on;`rt{pzY1jB42Sy`vY*G-ZVzf}5V;m7a?f#AA8fKt-h6A|it} z#01oYd$PGjJ|(fmypSSq3Xp`+;6Z1c{HEy1Jj1M*eB47QsBf~IOn0fV!B6na0udW+7uU0`$aTfpn^hDc z-yH!gxqc7i53FRpdGqGU)kw4jDd@ex`e=@L3M@t}4gp!4`S1ISB-8vcX; zpMF9jAUsgP0RYJ?HWv~_Gm2G09r66|AvKmQsA*Sx+lg`1I_Jp)&%-(tEALw91L=@+%eg1 zmb!=h;R`ZMNqb^{U%Sm|XWq9ZxsP>)g9s0}8{9kIAck`hc`*hBaZugVzOR9GO=-+W?a<@ZPr)1J86jCpgO2ip56;77E{ zLti==LTkT>gShVSFXcTaIY44t&++@8@MlAwRPY`DI%H?W>8woBdaVvs_Uba-qNG)TwhB}{8U|RhH_gRQek!scJ5=clE71shB-X16$0mlD*WFd+_bvhNpNi z>&KMAu=o~K5!sn%-nm`HjK(ZSeBFJBXh7)Lu9oZ}SYv~bsO{|ly}NfDvO8ij8hrh& z0dujiAU+Efo)J@PF*9)86SIeR2DrT-iiet012@t9n5j;XYHN0|{{;)8Eatk0ru)2D zSk8Od2aF^@8xWg`kgQ_Kv;7Ke^Eb_A1`@my$L@Vr}M)By}S}bc3vLUyvplfhofkuzW(chpA|^`8HHnS zFtYGUh%ji49v?F$SsDbtMTvNTm4NNd>)_FcfYxjZ^3;;SPQ&|tuU^z3ZuLq>0MPRA zyWOI{-;QjTyG_Qn8}CG!M6S}A9va>CtePP2eXqcPZno>_Tw1V^17cg5ACesrulZR? zJggG+k#`D)5&lPB^+Co|JJJ?YS%PcTNsL4K_$wAe<#OFw z-zhYQLevi@9$Hh%!B?Fvb8O9zRN$D3($T+;qa7SFVCAB{g;o0442|o@4z`O*U2g&I zqrS#Hqt%=5qRY(T0Bi9v>nbbJ`BSWw$rZsz*(`Zti)d{bK{U8}p5ruwQ>!&O<6~~R z%PsvFS+S2~DpobojElDgM>XT6OVxma)JQ}+>BlV@EL4{2h^&Vw~enkug~wSO#_799PH#OT$jNFi>;qOpr74vZ#hNw9J3y%V zKDTSolvw4;df~|)HEE3+(m=`?yIz1&m;q0?Kv}=9)&k-lC*wjDURXfm1WgrKZP%_+ zp@QaeP}o4Zp#0$YG{i!ab;}6VN)qcG;-_Tsl@nd@ z-X>4*)WHkgcs)(6h5tb?k%{Uo>2G0(yI9|A+3wqZVw!t1q5R)m9puPIi4PrZ>O`c1 zT!gy3xnt;@;p{QF8pMzge)Q9ffO7}A{Obwv{{h`VBEK>7Lu4u{i5!TFv!-9^bc>ql zj8B-eP0&c2NGLM$xLl-J{ykQJ&>VoXcx;$>hT`I+7&!s(5QZ-Crz;MiYq$lp z7Pe&t`HK)5&fwbL4&v`ZNSG)Vn}C7Ad?2^z#qu^2z18)M!;~!0EgnF+gdVBhxK2RZbgc zVBDz3!UI;tjCcqb_$cIK)`amQ(K2j35fG;{jzU0E4)ehAs1lVJ6^H&X(%^_VGBKFs zBXZ_4X!zEk#mxvhg}2D!42&ln-*Bl|6XAXx1rCq`9=7hzK3|f_3pu&kY(emie{8pF*VJZ*?jv~+bQc2EZTkte+JOiaaDg$1{)&O+<Fh4)fD0M?80bEzIgxTUdA@&yG9oW-Lfu!?r znV+B8?T*mG#o51=Mr)!dnO}Kra>AzxP+hA7;+Zt+8OWpg@xxlGKaFI4RC0_DbyVh0aO6{Fp3VwSO3_mvB7DICDFf4Z%`aw0eK-YtIymN6$dIC&LUN z08GutE zfMp~AHnV}XnbNe0Q{2l@;J_%rrhFWRyw1K}maE;Cp64G|IQu$h_0$1q;;BPmSjDpp zU4TU}d)_lZrhl*9mfP?@fG)usb4TQvNpo6=eUT@JN>S!(-EKIO=|;2w=;v}3FPqKz z-9pjtt*&BWAoMmp3OKHk(a5UH($7_X5qERwiP;y{#^58Uc(85$YK z4ZTb~h9X_iQQ#mbfcBa%WaQZwDzbbBO#Dtq&+N0`(X20-y}9&%dxW|(K4;}#XwjF!mPV#NLpeHed69AsXzuF_HGn9E{X2$P* z^0T$qk7n~PT&h;ljnS{b>1ckJOcH85iOc76xP2@q0nQEI`MfE&uCBjBFAhhkV2E#wgUJrMHLF>PRlL1}m3}7Fhn*P;NK?>O0FGAzL zfG`<<4vK$l^UxoJ@*s`|vkz%2NBhP<_7jF*#45nu#iegbA$%JGH*OHhp&Lb+qV&8K zbT1qS#3}%^0>Z0aCNnqOE40^@G0yZTXMVu;KjK< zsM-L~R#JfyPb;d|qu>Ai6SLDfaBnW_({Uz1VSpW7yJ0`OWHAGn$xTQn=*hk7O}YN* ziky5VFXx^!f_K)^QyD z>)xL8O3%Om2aI*~dVyO1E6qgVhac8XPe|sMUWfL-W{PQ`WRCT8V-IW#~Fy(c&&V4!-`uAAwc{ny<%i| z*?JuM4cFK>R0LpWtE+F$FHIKLIc^SLohb?0o(8$;r8D4q|-L#b_U# z+W>}M?0p+K8VRZ5h|uixjI1tX>lZaw+I-IFtcf- zrYW!iOv72fg|}h%b`&^33gmHPU=e2dabfRZso)s2%LC&*8c%^BgZ@E19JX(>+>bZH z*yO{^pTYrG1o#jpW;tx%=rFHTs=1<xWMm8t1tCG7Q)(UHONu@{4Q+|=Kq z^RZ7jJz13#vvbmI7UaAC??d_izkMioZ?vQdJLEwZ0}POpS@WUeEB0zw(=n)MT#^8f z4laP@S2I3NvjPG$YZ3u048iE9GboIII6cOvS>acvAH$d-klAg4ib{*nD8Shw=ux;B z)D&jQPNEXvB-MEw1@@l;Xn>sUk8;|^k;Yz^#Y2Yg^8q;DDiCPcoF(Q+!B(#@@KHf9 z!Hm93+W~J)PE7^P=I`OiV3Ne6fJ4jwqpCBonmH1{MQ%uet&i9nqH&2&3I)D(x!?bA z5njXVy8357mW+XkVg1XG`)(}%2eAPla|uvQ!s(;EOw;@AU!9(QVHW#=H2F&x z&%Ln)z*PX#p*3L#KPm{og4oHqImv_-`RNa9@}2*CK|cMkE^8}+bho~Z`vt%4KOd+I1U3~sRID|<&emuD?eYFKxcmi#yj%m^zuJ3 zqZ6|qQvfjiZ`0xw??yjm*b6^8GYfN}Q}W?EE&0yBdZ0#y)|OL(K#V|(^N*iXK zl!dZ7TF-t4%lwl!0CX%OS7tuGkcTJ@9uu7w0%B|?A2L8R(X2M!ARsP-lW6H|5v-FH z0(6j709G{R;!N?Ur4pRiQDA>5K!%+(&{R=|#hWCZ@uP8O(M}Z{jhZuiGJGoZ>Z~7c zD-ck~rk?_Y*$SW_fYk%wcy*$hoq~Db+xM1VgWf@a9l}Uz#{9S~-U;Gr(&4Vmk^1Hsgd)?ZXuHIh1_xiopZ=E-9G>hhGHjNlb14sh2AO%JOBp?U_ z0mg)}3G4{}ZS%MPvJDQ~0fdFI!x&k?G6sy;$AZBlX_(QhZ|}Xk_PV#q-_I}ecTV10 zx2l(_?ykCZvg)49{N*oyCr_UIEx8^?9EMl%ssA)B(vK`X<0oY8BnD1}Xz!znU3O_(8ymeV zZ%j{JKHq8Ee7_|N%Vh()xTk3WSHPbCsQi|O2+uApg{7Ir@SWf6hyU}hzoRLFoBHTb zKlHUmARb7hyQv&r1}mE`$QmBVWR3;OQn?X;5Hg4L;u!_Vf+h=#2Np$)9is_eMzk~%Hw+Q7vm8)vtQP+SPrYZWe!4KY%MlQ|KXx57!KRtU40PF^o ziqHFF95hAD76*zC>iX?kTv%cp=Y@{C{2!j42`@}ceDuBFe(yuARvocYw0PeMFj$Zn zvu(}UTILL=$e+QgU{(W_0gzS37zRf&!0<7^OaXjcCjg&M6(FUmF92$jZ@3eF>tC-e zE!8`3oRfvlVjq+ibN=`!EPBp<5KzXiiPF(}O`SHjFgGV-U^%??+q>ac{+IW{ul@b& z;qDC#0Ti-Ih15Vm$x%kTNXh^qxezIqD3}u55Ez*b4LQqiml*fOgO*3MavFsZknTZd zvT`wef~hQqVu_J%yp{mR2kta-%qm>fz@w-E-~H!J*ze)IMO$pCMWW!N!k5w)6WA1h zlsU43odopuQTpH)ivo=pF#VLkmO%~`dsI0AK;&`g(n5^@EK|SGp5F%s0Ka zkp@X4#a+OP3Pe~P@u;94!?QLeofhY2wT19(xO=S`e)Vr+2;2zQu5RlKh8hvbMk9(M zyAhC=FG)9)F+uZ9lY^9iDM*xxBH55hHr#}Vr?f~zzQP5rWf1}ncnlRr0C~Lf;wV5u zOn9lvEynE~HzikIRRc#}1Fq-?2&Z0}_!fWGcyil32z z;!lk?DxA13z(xgV(1~eC`;ZO`dwqK953StX{_xC|CZ8Fw>B;CLae&mLC0_hITMwrgpVm*im8Mm4NSp^TRKwC9wj10p~v$lu<$HB5r~RjFe8wX1auOm zm5~U@OIZ!sve^Z~+^0y50D~35(Zab*u0mA}Jai3MGeptTLWkNR?Ri&eD0Ex>uQ=!Y zGt6I?s`ilp3( zIPrx>C;P@$X(xb%3xq20Ks8Vq01s4MCklBaV+_y#Yx`ea)^rG0m&5hzi#n@6&j0f% z&egU4nM;!szvtugbAf~TU{d4NMA^auW4SXrF!F|vvC2^3Gde{4DH#I#xKuLhyNFW*0!)hgw+0O{D zG9(=HQaBm`o;ltyzc*#ATvY>)q6Sdlqa51<`J6Uqe}iIk{_@%OM;7$lAUA~^X72s>vq%}Nb^?@j zalfI;0Jz_p8bdsN;&hGCC zfI=#Mst;3cg0TueP7lD&$HR4XVj-ss&P^_aU;Dea!vFq1y&Znz*YDW&K~tic5n$4V zi;5r9qF~}lc*cVc35rjfGG=1R=qMhIfQV(++=`&OQXXWg84#97@PVovh`7Cx5v_t% z4IFI^XexiO2^#rm9g>0mY>0I0Wc8i~z*4 z4_-Ukz3|kzpNj}tk0l>C&J6~CctcY< z@Ps0)n9*=8S4uO4avH*thKvBGVH6^nD17Z6d1@jo&+n6DahXtssv0$OtE-Ge3;pZ=0 zXzB|=|JAi?*ShI;N9j?bQ|~GRU_6_^eK+o&zO8NN|7iFhck9+n?e^{6+VHI$FHIxZesH%ZO)_^H&Xbd!3wLtNIY@cxvpzr%{36&iH#90_fevE=> z2*j3aBLeD8AVT7g_N);$5yY_IX55YtYl^;KTYg`go_cC`YwH&@QmKIeMkcS-Gywq0 z!?=gd_b~T55qV6UpNNuHg?!i=pwY*Mf3;+s%a>#LEv3EF@7Eb->-TTgcF*6b?M~{e zfW6&rv$p%@%QG`UU+J>X{o3%qh`F*y5MU6n2v9aaREQ5-%Ey$i#aRNg^R|WXy>IS@ z|KqQ{8~)ipxNe33%wY1)rI36Rb_VBRDI~x$h}?<-ku+SKGBD+wBql67;7(_~3)HtyaTDk5Wgwv=d--Vg=n( z1C;@=r%J{b@I&d*Ha3jUEOt(FZ8pcY5W>xyGqp)s*%SR;+48l^)2&vG&vi1qk3xd` zP(&Qsfx>r#fb<<3FE>t3cRAi(Q#%J1>@0!ha8*{&-}xKwg@5#`*TS8fm@_=6ekP41 zO_|td1aEUN{q0bd~_y2fy^UuZH*Dl9j{*>4(A|X$1Il^X!DV;1FIZ6ZK+oLjWG@ zX}}1uG!h~%S;%AL+&3Wk1+WxLHK>77`bm2Sso0fw%xWOEqc|k*MWdaexM_j*@h^4h ztv%~P?>-LYM{E?oPY*C6U?ze!RE4cg$58_KD()=67=YIpV@P3XtQN!JMxe-uU4&dpRY=S*T zKr|MTau*SklMp6P@}oc|lJH`%xE6T?$#DyWDp1wHebxYKzmE2%MOy(p6ykJapypy~P-md<>-z7l>>B5PnOz>xeh z`lCReTKPjYP#FM26>?gl`T}t6f*$s2U&sH-0NA+|YTE8!n-pwgrT6@FtJ#^-*S>7X zUyKRAtD|qd|H!v-?>}?@b_$^K!RX`QOi)ScOz13urTL{$+ma#hf8P#&=dZmNzVVwY zVMoIs)@!$i#Vm@#ihQQnQ`{sTiNr0DKn&+b0I--B5tuRvV6=!5HX^BxL6*Cx5fIU; zYgGdeRs(8mbu@Khg_hal2mrjVE`b>S#@1%|^39v!SKfOs+}z%>6GIDyuXf5nLPILv z&IVApSQDTYO*1ClhW*JzBXvmgH9o$KKrT)l21ggQ+u)bus5@6)!uUHCx_S@VhntjFJ%map5QfszL>1gvRF zc+`AMpRPXftXSTZF?L^>p054m^4ZV*&+okR8KL~I`f-Zss1`m7mQk&OUIUc@;59Lx ze$GqwgqkNar_+CHZ}s2N8i2*n(H20))cXC^`pvC+zr9oYoo`G}Pi~9pnBUvkVU9oc zPB{RC?*K3&0H-oXhk>Bae&{-$4q<3Rn$q^Iot91$+zwy+_4V*uU%3;WeSRu@=wmaX zGf_7~h&mbW-CIQ&uoQq+Q{b9vj|K!N1+KxBDwxpBI3R3s^66)BdozY1EF%ze5(JFH zk4YA-E>#U2R0Dik`|j!UrLPAh1Op0&fB zm6bRWNV}A9;82d5cSOs@$qg= z>jG^4zgC;tz4`vy#cm^9etvSY*01eo1VD;SOwSqsHpsD+1)h)) zf{tRj%^HXpru3nSa1_Ym3KwzV#=7Tb3o{u&OvpUiN-yXi@Cu`fg}7dQ$iewfAmVoNd|~8H@m*-=`XFH;@{btqVx?N{`)e zVso^Hh~hV6Krq@aj*$Qi1x6RG$$Nt5i)eP`IP%x0ro*e#GoO_K@MHRv`G2c#nQW5S z>-DM@p4HX;1}g*LerxLZ<0Y25uYzj+|6wG`-7%%Uf^xsp4=Ymo>l=Mj)NL8Cwr_t&DnRYAUTaCwPXyNeG}=hU2{#XpO zr5{7&r_t3VMcXYca?-|$cB30^y|WR%^!C*-ztjw`esm_Be`-QPk=~8!$Et{n>duV- zDos(gP{n>ckq9dS)Gb+3l0~z)f-#-@#MkQt3=U|RBv~qV@@k-`;raD7DRvaR{JXcd z^-~XCM_R9~_NDy$+R|Dx!_?lozT`n0t;twz)H-3dje=Dxp-pfx7h6qiCk}hCx?#A! zhk#H+jaSiEgN<^8mHrBmV8i~DOh$)(v4JMsSg2^=rrYPGAv^bYQLB|dGe5ud!S?o_ z`S!JI|FOV#6S{8&1oeJhS%~}1F-CaR2*4P<%%Mlgd1oj|QGEbleSJ}1{@byW09&n% z-gm#g{`r@uW-cvv_|8{kWM@!fw%AWhjY7jH;3!XEObe94Wbds`1H^=^K8IGTbwjJ) z4(sY|{rW$-8>Z)1!fPL!4NJ@FahbrQHj>OqMu0&ivT`H9?1dySi|)SS!$tt45Uikb zF=NB%$9n)b!3$nQ$pU1m+;OUb?d{#LvDP54rdv9w;pYT*qT8ndb zceG2VFD~SBUHUb}ku&t#^`i9&UGsU__9tMW_^l-z?Nhsa@HQ6b?{yCvER+3eoTSkf z@lElVfk50^sZd1)Bf<;;A!V-M2jOra*%!|&)qm~g%^!JxW8))2`!)R_Qn?4Lfyw}Q zzzRF*=vS_UP_C7^q2a*ET79;@d%M+bZf&jn}X%60PN5o@m8D;K-r5) z#cI3k3Xl(cThjz_81JOl&f&_BpyfcJhK?C-N+9?8t*~;f7yhNT5Khk4!>=yzWLJhR2yDZMIA4cwrw}COANS4YW zc~~r{p;!HOCAhbH&9HiPJACENTKM<>ZZ*81?Sq$|@5)e!GRhADqW)0S`A9%fsU|fo z(W=;u03rt)0frt0vE6|3rFT^XB2INZTn+Ta2&ULm51#Of=HBVSGc>O+Y-+Krdgju0 zyXv{`s4HsbyVNUr2 zz}!DQh4Lu?#P(R^QQSrXcvj`Jx*&h%h#`~SoSUotlUuhw{x9y{{dw&K_;0imputW6 zJ_z*X48IEQUjvl^uz%g0P!XV?5*GgfKf;J!{ zWkjpX{no(N7W41)-eWJGg>~!d!LLc-Z%V;q09fx`wQGygHAIi1N4f86gFIW~P-whp zJX7$3#i9A+-)~`#86IkX+scIUkL`|DXKkA2r9A@2ryjty3xfkg4Kg)O#0kMsj;w7> zE&S}cbJJhGeft-*C-MK9o16QVz;$hEN)$%rtYCQ!R0cp^8)F{Mj{!cXH2^vUILyx8 z>8i)HIt1gNe*^KP~rPznb)+{;b?&I({5pjcdg zmD{fd8q(Aa&D}N|+BMMEsKDLr@b#~3hHrgsH9Ye|H$4CHRG66L__Zh(5tNJsSX>nw zgB}1*I3k;n6{s)*0E3dy3PcCx*%J*VoodHU7q-W(uWB*;t*>?f06+jqL_t)YZHLp) zy!OJ=i(l1mORMLtjbm|XSbj&VVt3VZrw1Q)wZ20O?5rxK+|YVWX|LFOCz`^BF`m^- z8#H;L$BWG?F8s4TfdJHjH%B@T5-e6vHg|~iAO{WV5a&jOg@Idx_Ef(|2$v@(>py$` z{D=R$x8MHrUw;1iKOMgO^=kZHehZ3|MLlhnVg z@u>PLx>ZUQ9o`obj0=k0;)HpB#0d}45!i4IC*>V|v!RT~FiM+bd)$`h*y+XNGv~f3 zCBG%bzO5hW^xAcHlj0nPqd9Ah6>o1bT;Gt=*Wyj~z%xg0e+p}e*$#e^k6}=`(KQg; zmdk-CCunfq#>h3${wxh+E4EKh2Z#1b&S(T!1b{h@<+KPdYeAs41)lrL%E}itT>1a# zkiy{wfr&!p4c9ynjlq5xliog-Jd1jxQc0r%!eD+gI%m@qt-J$k07Iawx@Voh_SSZI=Nnt$ zgSR%qwfDBdg0>Dmqs4;VY1lLxWGMLfZltD6T1Egtdjnh)ws`SM$m@MC@S}@4V?KkX zyqrBCHF**>Rs z$_{h@oOahy55C)uJ^$nKyeF|7v@fdJoa&kp0BU(xJA`bwA1PvO5ao`MB?N19g=f)W zGs~K|x8tGqnX>D=qFVUe;^OrGd-v{7{L`B^|Jm>PJ>jo^`O6I5@Yek@=R;uX?|)}ATzz{p-27lW%r7@JJpnE9_Zo z!D@PboMzeX2-cNa@dtdQPjZTht6lL`(4ti-Zf#2!pw?dfB@Dd_@QR=Ek?e7(SSLh4 z%a$%i(-5O!abBYUzw6AIXTP(y_Va)FFK_+>k+`bgustDAXb$Rihs1@sd5+N7y~Gz?M)d0`fcd9wWcsD zAcwQ$*^e@;Td{R;P9Hzn))@B9cVqeZ%67kxNnJ6=UMP6=+BvEgWe*(X&-OTm;px3orwrR~>q9dd=&&^A*HQ3x zoV1?76ugvsmmzx%&ofO@x#L^|ydUugEipA5Jldsg@lzPtB0X;nE2hyFg~9t402nyD z>SA;Ypu2&F?Lh7t^D+v#D1Q0D`S~;d^7hR?`qj0Kf1{*t>BlI5qbXRqyax6ajX6>k zK9My*qjwj>SJb=ggx#xezx}kB<)=Tlu+U(bbXz^J9N9BDQxYfaKjMrGph)oJ6hJfz zNPFB)`Xe;d%kNC=Y6bm{e)RYsz7*uuk?El=dK^vKUJGGO%4l<~ZiWHF&X3LMRxB3e zx3$#^H{M+jSKnFJN_KkH5_%9%rbY9{q+CKOdl3V}JZw9KxqZ&w)p+R_eJ+9t8{$t|9W6}Qof)K-4n%^j=7v5*4J z3;IsLv)#!bdTVXtV;VgAZUW~mj4xGz<4!-yrJ)XG7SOz+kYN9{q5~P`RV25 zr(TGVrtl&p?f9Q3m`KdRnUhV4by3S{h(*u326*#!UkFFe0YU`ASc6&z3w;$gA z`daw*Z`}%)U+#uW&uPcNd?QTFa{8cN1Hx4Aun@9}qR>sLQ()5c#}tB{@t_s*tde(y zZs8QS;d?zdhu?5)EeGGQjShuRPoJS%9VTVF8RF19M-{rW;|m{yoSyQ6#R^J6#aQizNQr1{H7eD9n*TL zzS+JkLqO*UG@Be!qxVSf-FxfXY=?`(?tQk!smI0|hjpDz&$c;66;`F->B+Bae>}tZ z49~YT9Kx13JDgS(-IRjwss}$UqodsYk(aOvpQaixovaIs0CCnqkbJ=O1A=L=qeUyx z7%c`{EP|3c=iV_OllT>%!LsV&j1JczKbK|hj%RCqqjeIrmx}eho|$fIWYtl&ugkd zit_gLhLj~nz~g!Lyv)p-&rVO9A#msFM)()syB(GW;diyqV2#z}v6{Wjjvsf`|>x)2(Mg-CaT6Pr%nNmh0u4r;lW={-Q^E3=&hsB{bhJ_wZ45ZWViEc9cJf8ngYd)|Izx4AcAJ#bgXM{A-VZhg>@ za#cM%&P9S*2{8nwHTOBClN?uXY=nRHrBz#ztv;8{z4K|NXFRk`^|E0h(cPlqs1Jww?aE**-eD@pQ2+uFHnm_iVi;K%MnkVB7 z|LDX?#z0uvk>Mgd#t9oLT%7XQ6o8^IJcfW731UEJbn-k3r(39JyAu{K?5L;uDDLoJ zG^sDjv3S03i`rIh@Cjf6y=otf+@Z1A4mUm7wI3rhz5@HugewA74ctc!m|T!nHaTKq zMIo40o{bz5O?1FwJ&_$3EF8#&kS} z?1MBpKyt?vHvN%Cf94 zn`$axZnDw%OTvLOD>qaFl>snRAtxvrIc9Hx9qvBc^gsH2Gc#ZKyiWX^uIsb30u;=H z(idi&T}xTyF`VW&(U-+eGTJVAz+uO@{l~zM&()N z&ugA|n=!TIoN@4zUiT#PJw00P0x2uGF%}$wg*iKk<|8?B_rTimar;RRRfQr2I7`dWCk4te11``lnR|Ydzy7Rq=EG9MPqCqIf%Og zFb=@n>wtUOXpAxs>s|iXrAwEl8;$==P;sZ-zC<|Xp~?Ul?*_1=&gh%3&(8e0H|OW$ z>ivD5*BJ?)xw(U!Ga!u4sem>G;6}kg86P5zb7E!}wA#O%xp)XFk2i}M0U8N74(k*i z?~_+|JFPW<#E5Hyk|asP{c+R~nIbrb0m>U4tZ?j#lp_Sx9l8BS+#JN^V&@}<<5dZy z@!Ml8#7ro-*QTa|zIXDP!ha%R%c~qUP#FN@+YaEP<+)btkNm*=eD{pbmuJBqE?zBI zgk7oUy5AXb*oU=@c@?m40xw_dEu8P!!8}i> z2-R(?8hETV5Kja}zLe{R5HOK-%V_~1W)P@!E=LRtd189I%UA0Y=%Vncw__D zf1W~oRzrtBxxBnQ-)#PjqF3~bwud8~V!tu~PUg!uHW^X$99~oJ|BdG+Cx8C;E-%+O z?l&?=LP4YQQxte~F~pU{f4DNunJdz&iD~_L|5Io+0+Sti`wqTocalKoFF(g zNBM1!#0e{XRotou9I>T!|Xx3pFP*<{KemU=FIN24tilBj(4L8!fXSX z0LmE?$DnbeWfNk=FLS`w#;`)rw}g(~sbzMx@DC+AP^P25)1#rNdSMCx1EAAMLh#Yt zsiIodz!R?lmkcH^R2qDD9(H*_oY6w(Yl8#JBoaH4==I~AHen!6uZZUe0Ns&aY0ziu z^QRXU!t>qkXBB-xzx|}ve$<@mSoxI!FjlX#d>D0_zyCtJ{iz>4bEdXs+P_R26)G4D z#&fG(h$S~fB~~z>5s}r)9L&dKY!su7xbJN2zxvq zjx#Putl%6`Eb8%nJj#hu;|Jfk3C(c#u84U)QV-=sXkt>I_0>my;=K+Q3amk z8=VvxfcXtdA9@@S{E4}_aAj)hPb&JVetw%0@sx!s1K{Mn@co*)!`bWlMeTikI5@;1)CUy4&7@9g6Og%8cNf z(^`g>Ml~w;m}-DVlztef13z^E`FNE5hSEGw$taJhykl`2eOg>hYeV~R1?4rYz3c}oTa zMc|m3uzrjJ#J)dQm~#X%;XH_A>t9Dl{@T4BB;zr~-CN~*IHtuNi(*mB z?e30!FM`FS`o@vgWT-_;;nTj{?aEx<(Py0*P44T+tnDo+G5va*f}2Ki%*sEg228xD z(sxvme0PFH#7G0q20+ApdZ>+5RZGreu&^;&!V@zFT0F2j*rT71Z%afB&zpfAdc*EcC z5lN3YsBJN;BE(VZ_yt#Zf?zmS_JRQOG3Uo;KEbyP79jHQt~;a8&}KsV;VB)ToCvVl zEqY~ZqZT&T;%|MmZU({u zL{529>;Nz_*woiL?Q7yD7gUjGe-|bM1!C?W5J}SS2onKB10d1pjlP0g5RABFGkRGL z!%B3WAfo`UNjB<(Xmj6KTl)iBJ3IfivYgrv1yu$>)?iL}(0E2n@MnMF+_}qbjmwt| zK`1(BtfF%Rz&IuOrI&an_UTKWi&QO}E_{WHp;Tuug%0hy>iv(SYfDK@%D7p%Z6a?R zAMvq06N;icy%VN%{PKi+`v$`i-W~d#t_%wO!jhV|h6*-UYck+!VNFI{k1sz~uBZW* z3LFW-q5H1$O-@)M(}l6lxHeodgNyJ`g&VFi+71AE6>MDwUJ9Q=%owinMv4l^0lOc! zDGU4$U%1ftSGR8cr@y_i@joihckd_PIO0^2=w!XsyuA;X9Ig4;7pJDKyrxfK4(ntR zooUS4&f|#^IECufog#i@D`zhAb)g_IIr#qJnS%8VHeQk$ymcQHryjPWZv4 zrM9*Q{^^X`0lCIAsWJdg_Iq_U@Td4=KYRAx{0K^w+UJ?r^c?>9g6D=rh zNg-4Af)&#NF>7&!#;{l!1uLxqGDNCnKHXT3YYEd@4~+u+!Smx`WJOPh zs|OF({&Bk4W!-c z#`~lr954X#d+&pKV!;T)DNO_Ltd%>s2542LXkXa29yiBAA2-LSz=h{~Vd-4II_m)d z=0F+0xx)y6y{4py6((vwE;b5~-l7lz;RyMNV#L)IX0bG-JHrg*vE+hAjFnfXT|&wb zX;V5J==YsFH?L8EKVPPtu25wFjL-Z2so%M@^r@#cw8hc9r4lVe{;1_}8fl492_@#j zx1PUzoLlQ)mUcV%F~*5^iB}E(FqgW%{FfE}Fr!0%S< zSs;MrhNwi~I9@9Q;N-tmdjB)}+~xOa<$rTdR;>-SWzR*c_MdSnX;~BZU{voV7mVbF zM98gm9|3@%<7c;i;2@v;9d}pPwlwCCUG9zh^FGM)HQV}v)zg||*Ze-GD0D250Ne(|P;mQCwxo($ep^qC+m&=3`~HI9i;KX`4uk8 zCZ8e5MHeW!Az*n0b3d1J1+1WZaG))L^ZB{C)>OUz{la_>vIplFuhhx_IN9%$#>zW< zA4`mxF(kp5uB#$BQ!(%FJOW?aIRKn+N2a52dYYpmbri*U z6f{^wHlagmsL9I3uRbnoG2POI_~plwZUoYP=g;nhrKfsYtf;qqN?tVTy)U6qC~?(; z^KxDV*7DKt_M)RvV50%bh^&dY37+Bx%dCQY^dRz3x>LFlUJ4ea0HcJ(T*S{zOoZQm z;ljrh{1Xv+dajiLaI)Vu?f23vQ&T_lvbO%Yg`HSINipP&o>=km4bqGWyZOyH(4%nK$*ejbSv-Rw3;Lh?8gscRdXmTR0^$2*?W z!nrd~_4T=A+Ru1a#q_M6Q#%C4^zn+9#`Ez`84*M_L>`Wv2(BeeX+rk6D}R$iWJ-Cx zzGCMj-G+QAIP9gYR?qw4_)8c_S3xMlGu>|Zv9o7Cqu_s#XnPTcZ#7o&$^baIuakB> zHQQ`{;gy-0i781?XQs#n1I^qRhZenmt4=3yrTTyt6#Qr4l-VdN%!mVcjp8g|!#dQ3 z^Vm;?6X(^nb>uL|%Xrg5wYJ=@%ZPJq<80jI(3FfZsX$qPJ}87O)S ztNmw~mLrc7_RdK@|BnDOJR=%&4CnLP5BLW#8uyu(HU7!j*@^i^<4xt0*|w*61LVdf zQW*dz^G!NWEo$%oANs<=LfCqME|fD&!9EHQb`j-1jF&r$IY>T1i~#HXQ=%hqJEvp; zH8vBA0Z*HwnanQr!?I4)tDlmuBi3{_KE{rn9O(QrhA*DsentRXNn6if&uNdW3x4^F zhCnf0U};H+q;CJPT}ZslA3HO}2m!K+#C=_)o$fGzMK;9FD>_5vN6(!35d}XofH209 zQz(MQ=56xsUeWOXvoCA)KVRXZA(suj4EYn29+kV&hLpSGL;@KniR*~jPZtmSo#M71 zj}=rNDnN<(65D=7dnlsEFcWo%y>?m@VEziGw9K!q3Lb1dt<2u%Ir6BY^Kq@;p(YyUdAxxgJ1RnQ*W?@m9K)_jMf7{bvXV zT);c4ErB1Iot@Im+-DW-9)LbJNtFR`GF~NolRMgL`+TSKQ=eW~XmS=m0G#_C&f^7B z8fIe9lqce)tvJ900Ot9l?~JM9Bqqk}U{(8(IMLkROoWew;Bh9R8r7qoCO4&F@TGI7 zr{_QXZaY(&v(wZEM`(|uLuT}n#6Vv7WAYsUlN_)%KOwpvH@QMw`1X^bKt97ODk;i0 zhsVsLWu9d@fUkVS!0zkxtvuSnApgS}1^Dpn>@O+lIZqyE|ENUwIM>l}dp2+0orzlQ zi=UXCEf)V-K}mJ)N+tKkZb{kGIK1!^BO0R#&#iOM0-oO-cI6LT@P=_c&x87Xb&~j< z3g;C+?hmWy6pg0Jc~_WL&~1E6^QCob?| zjQ}kB(ZBa9y)olHNX8br;FrvnEOF0cNM!`(wI3h1hxkD^@NDE2QZ=Z{?w!C1O}uYUqRuWuF)^#$y^cw2%-B%RMJXy5bD^mG>pr;obV$csEPx zYX@O@3U)j&J+!#olhQkUyEyR_#4io41(=%EQn{mMn&VJ8dZr%gm}g7Rhsf|BMYK+X z0KnW)7YSXU6iF2XJjWf3Bnm}l0!73U2lA%0L0F=ZylwfPTU-pYt=11K_}pOX_{GLs z(vIKz;)!U#ZLQG%qUQe_EdCqiK*}4st96Gtn?&o`W04XuheUkOC7Md`7^)xRfCX)3 zj!5G$*Ns)p?~VI3fa-1Rr#jTQrWbZ}v@dPMTg_ow#>vkMtF$xWLrO!nuVFfAqP@$;Gq!a!yp>@gaK4IS_^BLkqxak!PU8lWax`r>74>^=q+8#3+M#X%`oQ2eC=2gTE(Pu{^cVmKLZ zAZu_YiwvIKC?*Y2NWcTq2JV>2O}?k{#WQEZM7_?TKr@4s#w%7C04MN$cI)*|eQ0K8 zsxd-)3^eNWY_#oMot8LdD7TnLX(brd2K)0YqHl9_8SE&k6LK3X;_@+Woeckv^(cp4 z-^AojXff}f3G$<8A19iIs)M6}?Hd6n`awn%Uh;^Q^zO3YJ(Y8rE6J3Ch~f&HsLKg@ z`j8K<;U|A6IVSD_4g!#AEC#$dF>$urY`!v>I$p6c7O~^?qVlKFFx3z1?CR-UuIAw! z*TQM|)vah?Hgdplox;T|zKB>{3}BWvzNM1`m*N0%^7|07n;%#LL%;8f=&rBUL!Sw` zF?7t@Y;UB>9>eFOUGQ07R=jiA(S6A6ajb=XpNVx5)K6`U)|eaj>%IG$VC2WJLwX3M zbdKXbDKwTW9#1zZa}gpL-(-~hvVjTe2*5|WLfVZ?1qg|jERN4;F<`e=`?-A)#~`6H z08Z9RMBQG{0>I~ z1|y8_!(O&FLs+|8Ke{sp9=0HlARp5#8|!1tdU~|()J~X~84~!9pe|1&N%0E@1KIlB zlBrJQqZEZksOZPXfb&Pn!-fmM1W=JP1~M2Z@t1&#I1FWu|W%gup2OdhhtyhJ=4jesG(8hzsjfHG^b zrR{*LcgC-YZm(+!fa#4A9@B*IUf*K0xbU8B;p1=ZDXnnbB6OpS{m4 zCk}0ln&646`-ds;q)z|4^4!EkYxH4ad6O^6)A$+Eg0l#lv5nO`;=03wZ(*=@HW%r#$C>5N?Rzrb@EhF}u+(}WV`ip3-E4kB;N_vDv4~a%z{z=yw9fNqI~{$kLh3)09($W@`B2u@_iOMaS`l)k z4m%RYWPpBt4=1;y$!vcrPZY|thXMkxBC)3MKUMp=_5dgbh$2FS4pmzaYo4j+WZ z*g@>)`S52OjqvQm#JqwW4Lo+PG60V6D;?EF-_-p7Q`2gc)>Gf7>@-~e4O_KNG%9+< zQftSHu#`8!xrOI(nlLjT_yC`+hzFI0{15H8&z433t~bNB_RJRrd1!)9KI8fdA3S>U z<#<#jV0C*-`~S1%^QdlhqUqAv9Je~Mz5ay|*}LK>f8OEFwoMzjpwXKxa6O<59?WH0 zgr$syh{y;HwUUBHevcuXJgTz*!tYpIJTKUf6G~o4mD%|yfQO0(X7=zD$KDv6|gb@ z4u1c~DYdCBDbMQTKaI}N0>Fa`iHyma!WbiI^MXkd4v6^zo17832lzRxuW`&KbG>Rs zJ)LX&s73-9F1>Z58P?Q$9*_o#o)pJ3tlrkbMj12X>JZ0*o~;myK)M^Yttn)zAdaeO1Fh{p}j=_R12mG?b3L4+T)AH<~qrmrMbA<91r5wy)_rruv3SWx=ITPR+1wWUQ8HaFX036S^ zxTkHanCD;acAuS-HHwP$21@bsaISu_UPn2gc}gC4xcOXCNlLpu0!Zph*-uP1!b@+= zgry7hu(EL{Y;R!%IF(U%e@K{a%VNOW*Ck|F4{(y4q}3gjySH(Y3jN?^ZRoYIzrAwz zu7PbCgpa~jzW1FUA%@r<&iCH+9xlxQE+GJU*nLXq;poSVF3<8b!ozVpoCG5Ga9MHo z#e}ww0}lE;FuMRgzAxelO{ffjlk?)9y)-#_ahef;VFi0XEm_a$j8Z(Z=ooAue;i4G ziQSk0C+1D~iVy;(B>+0^wH7}9>G|;b$7jN7?`~LGT~klMa~F3zbbx_~m0OK)`v&U{ z1`2&>+K-9=rCia_|LQHB+Yl@9QQhi^)2-`tyHSHhPrP8qtN=SY1EMbjATiZ3E8RmD zhlZ}78~-$QYwo~39D~LOmZppOS$erFBFZ5nJH$A^_Q*hJ8#00D^7}h1`l(Qg`27dd z2V+e9Ki%yHO~GDLaI7}CRtCV}yFRWl&I~zwvE8msJ;40GH*S0n!+p7Gj;tWTotUh^ zE4%)wPDsfZM?siS#WCXO`=>5Xh9CIB<-T9yqZe5i^ zEv3cb2tK0RC_{$+Z>hX|`7f)!M|8(0OBQ3WatGG{ZDL#V|J$0<8mIQ)+ko8wh_#S9 z3_bDro7;Bh6ws5vf1ft}|gV1&mja6-5N zUlH_gz2zqo#v#q_R3m)s&E;_ZQajwddn>GMZ0M_Zo-@)p>=kNvuGhoO_caV(K9}#ui_|Q>rv3^N%^w~aO~QI9w><#Rnt&oumo|g{z-v{ za|LhlRJkRM2*`1BJO~lLm-G7#xGCh4+Y5c~+@l=w-#=$+|hz3avYuGmbb4r!qs>9Y9M7eI@*V(q_Xg}znkxAUBpeD`e*fe zXsQ)~F{lC7udM4+*JC&TpWaRE&5Hq2n};o(HEon2;{}JCFSsX}97-|;nB)2DcRb>G z*g8ipi?V#f`Hc>Ed1eESzL1}@SDtRS`6$qZ(O4%FS{VQ*LmL|d*A6p7DVw>x? zZt5@}Eqy*>w|2W8uD@H4L#jti`(ep(&i~E#8k+kb&#xKoS1+6gQMvtV07H=8|Jt3# zsWA#&s^I%*Vj(Y5Rk203fCJ8 z<4~Yfn1`Wyyz*2A!0~z?`;}%v-vC&g#Q^ZezaM6Td*k(%YVpJ{o|QDm8`-4Av2G?5 zcw~mjQr-qjzX=P#Nnk8isEMPQ55@>+wd>)f*A~O_g-*DB`$kw@TNmyCHOv3d7u{!7 ziuS#4wY1Rg$@Z*xtWB--|KPjLuzGh4hj{Ptl1|+2jC(xKQ75xbW^Gm9wivVdf3GJb z0Y=WSqIX&0!p7oB2DtJsa1t@%XmXS}bn_02C2_f@OPv!49N_F;2c(n4GcC5;;hBkv zHxwM3?*dc?0B`sBI@+dY*~8@}4gc5RuH;B4W6@>?Ry1ZM7GapJL@wYly}&Yf?Bhqq zu|tG1I*t$RnD@VXt!~EgNQ4s)gqgK2N9~|s>m(aoMtIa8m3YjRAOOU?z$}>jlxki+rHNv8 z=lFTt!`4Glq{N9OEXr9Rjt;O6U|AyoPft$rVW6i*W1T!`WdIzncQ&d$&R(3D_>jH; zSS;N0BGZ`N<&5C-|D@&25*vSc3(K#|j?8S&A7NQ88&89drTFd4BJa`DX9OT6;X%FL zl=7Dm(8LJ90MKt&xN{4g@Uibd7Zw)l;e+ef!uo~|#rGQ*ln)nRG~k_Yw8AYdzC#&3 zazj85y}2sm<2wyaMKtVlsE2!klbf5m-qhNMQu?3VXF2MUQ#XuIu>)XS>&N>ixvVgm zfKbpw)2*P#AH(UYGy@6hJ{TU3ej0}~I;2KtX$~_+_lRSZJ}FMKgpP*g=^kd}RnxFx zx>n<(KxZ9((*5e#j^qCZ7tVD$pL}j|Qj6|}ny|HMV51xU5O(>bqGMTgi6k9Ueu4o< zY18U|714%>aOM%xc5_*aVvW4m|;z5aeIO3A;VrSH{8fFU{NffUke;rcMv+ zgt_S%(ILmtI7TLJU2Ev%y+)Xt>xa4JouJv1SdJsOi9NgS!AE`WY9ZoX?eVW%Y)c!f z^)NlFW1*`G8K{9RwH4Z=E6IVxF^cfs;SYTk+W6Vo&EPyI03yjF=r~q40u(U98NOvA zpJ3oP*Li+RCxKsb1P9VR0iS|$(}Z8(Iy}QAt*t%Jvn};%#%Lj6WdLL^`IrXhH2?qV zGnxW;(D{FR9yMlb-|h=Y++f)Q`{F%7F)bPiX`tRPEuSu)cSi;S!~7m60C(8bfZ)sy z81sqA`cnQoFxz${u&|`jfRCRG-}=_A@ZS5^!kPK`(2<3Gl+K3bZ)!1~6!e5XQZuRV z)OTl9<}@u~_fnCpj0fBpd4R*`_|^@r;$GG2{`EB%K{36$#?g>bLi;q=4ejRUd)mT# z#G_rutxlbfcwSS|2R(1%shs%$Ika5;XPUM6T6`^xf>?ByZUskMk(~O=NP(? z&1q|G!Il&~d-^xlYGG5qfodDdbK0ZKb8l*)+l1=3s;9^cceFNSLv=Ft4#w9HMd_*; zxxteo3uq7CCZaq^slW{>;ebmX&nw@YXZAS0V1767anQ1<2JkalF?H{iTi=iCiQX%c zPftxuyeR`aM&=WM4Y`% z9rocbIo`Ne4GfDvIvV4u}gtWIP7sFE=NzC8l%M1iU? z%;WpIXtEux{(t#$w_DpY{7>o#3G3~A-v+Hbq(ueK!;_lrpa=)l?|92C^%lA*;p~2+D70O#nLwrlwoAK=8t)Zg}_V)v&U*W(v8a_-I2Y zdj?qO!Sbt=|HIWcmMT*u<95{T1J{PydQbEIEDWVRofd}(Kvww^XClF1rO0v&$qEHy zKcno5Alr((3Rt+zqPxTh@Di^G71cceNjD$J1LgqTBI}+2hRs=Z$-0e3hu|KB69}jb zfaCkpXs6w!di`TE0QN2byq|Kb!J9QMTxSIQyuI68S^_vu!F(ma^2caIhAwLW3IhPD z3BP3WvXJB=8H0e{HXZzC+AV-lP}gJ>hQKqIXTwK6wj5TqwElzZH?^w1I$fr$#p561 z{qp^T+gk8;n!gRu*AA4c?>23ui8?tA&L1=Kzqnn10;UQu{-+{F2?(zsWk_PgAaSlg zCIWXFIgV$&AOB(VIc*kVU!I)YooO~dA{d6iiFTC%aC}~$^GaT#iB_}up{G~?n4r!8 zF&eYvje4+WpE4!N;PJE31ZP6OtHtT*m!knGcj0+{11Q2=pB?x^!mumokq{AVs4q<^ z*pRyx2G~e|83GE+2&gx9!|a?!13q~+%r7^>+waHGfMN1g{P@-YqX26<2x(0t0jEXz zOoHYPWh%`&j`~iR`rYtB2es*vW%3nWD z7Gy+#-8Ro(nG0`x^o%wRY=rAKZ#|Mv46CS>JK`GPow8_>?U7lNJmR|?PjV=KK2)`W z@>e~aKBrN~;-zO5ka*u@gupHe%7EhzDrD-BG{Bn*P60c~t}+0Q=i8$_@@}49Xg2%y!JWLEq>gBy-r(IYvkWzF zMI8qpQYdq?#ytVJVI_c(h;w^DA}*`vGlnI>e(`=@M0`&o5L1PVQv^X-Z)$rUYXVp! zz=%MaBA8!jhY!86sO@_?Z0Fkbu)eN|)yf_F8sHtXRnmIF126p87yY3Ni1O#t&o}iu zC67E%S3I+=7s_}XzBlGin1vj0Fv39@>3j@IhD@#`+@elhuw*oHx&oKC%y5Ap)?wUe z7l1}SYa9p6LckO4Dg)s7zP`p}z5epkQ`*3OpN+U+5S~eSis^uqA0}~UVS~q9MVbNz z)@FWSDQgTXo}UWrPJQIc#6*kzr#P-9VhjPZRN)i~Kg051q)_5IJxJ%Ol(6GQ z9I>texS!ADB_zS?n#}iI0^BPVm8^rVEL_APo?Iy$bO*J_Vy8e_Bp7!Mgs`+c5kB&X zWvvmYhj%}?7S`7F6pFK!aE(C#F7D<&I$u(9RlDjm9Um;xrDor$Xip zJP+s3FbubN#!L*iG2{=tz*WF_0JxO18wG|#-ozkI2A}QxEaofL>4S_*zTxWPc?Qxf zl90g{{bJ5E(KQ=^DF$vpq81Q#b;IXhnGI*ocf&WoemmSgs z=`v(0-T2(<$#@>2axm9=Dwum+-gPKbjdU4RDBZ_A$)hA_hH382H$bF_&>_1rJsl*U zKP@0Sl(&B(T{Qx5{9YUFl3!g6_S_{Mj~nO5QbAKA9xk>siu=Rq#4Szv3mh>*(GeHC zRQlNAo`Haz8hvg!L|}F;h(aG+@?_~LV&LMYip76JB#-4wS;4gt0b3lX3ekuFqXTRo zoYUHX*R(d^%(-^>;Kq%xA|V8R<&I|!Y{&?>`d0i>dgwtC^cYd6BChCg0fnhej*cWpfo;tA=MjTIIZoAamH^M-0U3@2?6vT%;;GQt%% z2zk1NlTt4PNWy`7j!WLdI{G8e$F12fDp-vG9JWHM{CjGEHapkY-JO`z-neboihIyX zfH!pWgO@>5YUl!yv!lufh z^SQ$_&(DN~GoA45Z{F261vDBkGaDv4nnD@4b4k7mJ%JifBj{-i^^SVb9F;qNW+${J zoK`_npWN#8{#H)wB!w#j;CQ{Qq7BZ}YOg;%G0_?5$&zZVzd$QWZ%IWg1)NjJ21rP8 zs9$lyj+W8~`E5{bI(;t>r1=zZ>4cwg5n;c522SWehFk*WDcrLV0*d%Z0CXjHLQRJS zA$ypQWon?MX@U8-zDLBg$N~$758^qbv%%wY9Zv zM{#d#Y=w!5hGfNVc<#joeL1sX2X&$JofkO=WMGPtIx@!1s!A}!m(W4(fKoVcxhV)H zFaSg|Vo(Cb97W!gCmv-^ojrGFXn-= z92}Ng6~IywzTXz#`Q4e)(a7R1hq3km`rw-|i4rBALm*&183BDEc4e8Izc?M{mh@qv z@2!OQ-@g`SwQ6@#3wQi}evit3ay39tx~J_ZceRp!T}KCZXLrKP{7z_dz-s>TA7c?Q zCON`*?T$X-%cq}DiQ+ezNo~m5m01^P^LAFpG$NLxylCJFg=jsL+At1;uZtYM8{wmu_2sjfD8i_cR@8G ziBZt!Bu_T`{pUv{pBPYO036d-rD3%T%NPKA$`_kD@FGo(F)Hz_ktdFD9P`UdK^2fO zqXiOJVd&*9>D#E^l?HEUnj#j0NOBkp!kw0bcodf{$**zxf&1h&=ScGS~mp|F^qnab_OW*(9nVQ#_=w91; zu%UZn#2-^GYGN`>Pj(BsMyI+w*&5L6>i44JbQpffIOTnLa;(|T^WLsFj`Yn-*Y^VC9Zi4eaXOu|Tk=_qM6-Wkbe*8F>0qBs)BtS}Ra*DcssAhNXG$yl-!3 zG%VJKU{tu@(`Sl%TF}>5o8TV!v=1AhDjMSPs*6LHM$fgS1$+$cZ_3hP;~KkVUN}D$ zCa0Q3PhTB*s|VwE)tl9cVEQ+nhUbi<&BBgw%GQt!*iNe=4OcL#lJKz0VG#!ip?HlU ziw+PmtP(XLlwRB^HR7%Zbm&{S2q?b*g<+s{dWsas zHWZ^A^qUm0)0xl^XDi&kxe?xfZ&fRt*Tekmv_=W?;SA-g+>@^Xy}vftJ)$C?!X#DvaXP)~nh zQK#3px-{YQY z>Q^pzI@2`Z!8Tp8PXTvrYOG;u)Hun6pXKJT5@8n^JQ!ilo@}S1tG`p*DW@I8+>uT! zu!o@+w*d+sZHI{G_eegaP02>U^G9msH7a<;O^cWCG6X?>qL_K4Q*4A3v^~4Qz*PXf zuEP|RRw|B}*`|g(r^3u^J6yk}z0L353KJS3nAK-KT_{4ka>uU*=(#6*bwuH4ai`N^ z*lbDR)63^{zRBrESh~~-FD^}ojtt(3PCc~Sb)BCf=>o6VU#hD@`ImKPH7QgZQ6r)s ztcM$@WkqbdP4GfJgP4#8aGe16w*-~KVGth9XGjqNbbc8MIf^n_q_{X{0eB<Cd0ll$SnNJE@-jjMlx(&arwwj@a=G&TdHq7msDE!X^C}`7^#zhFw`) z@D#s2PG#U64&2`49Fm74l_)KM$54dsbG;9geR39HNbD^|k^E2rzD+XUZg)P|+FBHW z8xKX~31+GcfG1e_``ubE<;C;*3gCmZ`9WN_#ba~#H2ip;c7&)i6$L`UgE1dNc9;eE zr++PnE{@8GL0n89Y5B9n75_2jc_M!&JiJ(}lJB!5r{licBuF0@CQt1eqtSr zVw}M64T(|7i~C8_55>+}pFYEVIKezy1jGe^ZAKO3;(eT6^2wTRov6h7dBk#p6HDRI zd--MdgYzAndat{b>FF^_Knn5Y!xtteCuIO!5$Ip;K{)1s$^bY%FQ{m%+dDf?U1+O| zD(4NaZ195x2JSz{2jDRL(xn)J0qR8M@5+jgiq4DRz7Y6NxaOrKb^)|l1ei#24;KIc z%WyUo{liUa}^pwZSsPG;m0L3pLGyS%9fsqDTKs8&z ztkux^)bPwqJ6yZE7Vg~I*4lt=tqYKG(4NpVf(}C&EMZpIDp=LPBdh^6+n!b{($nX+ zE30)<-%(gPSJNu~W|&UB{BAccdSOeWaWniNCNef6jE+{s^(;nlaiEXje8tZcJaC0; zQfwT%P4Ay$fa_X-83{yBSBv&E@-TrM$XvptAckXwAWW13dDtN3C4s>zvX-f32)w~N zmT8YOL^)8PFLb-}|LoSSmlUiFfXDd)#_(RWsg9U&a#p?1j92VYok83;EejG3rH-$7 zu6zOEEG=cki*a33e&Xmv6CNo&;^`XyEsysoSYXI@A)MV$%GFNgGRWQwwBk(*&yb*y zrx}n-DwoH>v5tI7^E`$&gll;WflL;&dze^}~T0l$OToG`9=qi|lM}>1(nR8HHPYICLsYT7n7J<|+RlQZFt41k-O7PxbJGu&C-k|EHxZwsV; z6}PBdRRc#-1AX(_NCQX|aGHFZj2TZX83j<&3e4b3ZT z?U8mLo3Pq(Y@xne!r-K8>Z+lxK0NfAqz=vE<>uM&_ z6aYynt6^ClLLQJG`M1Q2B=;H@MnIPlxAdd~eQx4V^{}1Ghm@zr#qbEWadjNQJhF)cd0I?u?FB6hSpL1 z){AGhz1GwBEu{S0{jj(+5tc7>?BiB(tqrxLwi<`&ti3XdWo(D1HcYDpW}*X_ex~qg z-wDS?>oE|-J3b0VJ~NJK|HccEF9`Sa!7a-U(jFH_2s*asR*5j%2sbiojz_)&knA}V z{xB-f_#_>-pKCO9ZrjeBf<*VJg(q3c{qJ2F0Q=X?<4nn$@pG3oq{LkHKubbdjo=cX z{<8uLZy*j3>Ie?`-eU*H9i+|3NWda41h&uNpc*M##OSEqTbkW4ULq#+VoGt%V3OHog==W$|LUJy*!k!JJ}a1wmt1bRBaSRBZya7=q@ z<5alx^mJHW?uK{XUeSoaN@(`lI)p|)4Siy$VH8xZs)2je0OxJE(q~wGM-%q7MpXRF z;V+(ThcoANN~N}^(i1n97g6)Mpo!%;fs%_}K*l49aGyy{ z*G@MY?YsT{l%gv~LijNesSJR}RM8J`n-?y0IwECJ2a#f<=u#|+At(k#Ez!52WhY$E`KZJ1TUln)Jcw95MO^K;?c z`K|Ew_jG{Jot3cNml06M7{CzF!78FrxvB=d1~7C{_@&a1%05WxbCTiQd`k*{A}s0? z)||Uhpv8y-&KNGyA4nj=T~i4Xo}qZ5EF!Et&0+Gb%qc$L4dow5 zdxR0>XIpis4+G78Wo6|#-Rj>x!rL7=>7h4w#4%O`HI>}oI};DZ+xKH>{VMmq%~p0)v+G!lxO(ZDBwb0305 zIRPtyG}Evk$|=3b7a{SQPz@!~u&j1TWJsj!hcN<@v@uVGK~N&|dRiCI6zv^_*)6c6 zAEyXjd3hnMuWg6--d@%A!Mid9CPG^~2AZ-S>;p-$^wss0)c|dq;e2}fHngu^K3ny) zu*Ce%OkG3zI+1T_N~iM0GbpU#!wdYI;x<(ud-e{OFrfM8!}&gx&q*9+h({7;IM~oW zZB~Df#Sui$Mn0+8|fFg7C@6AU}JwLOeranj2Kf?2dk*tc9l9ugNtp5qYU zqd+fAO)bj+cwXhH41nYCQch|aH1d3Qq21O1KvMW4xB}(@Jc^0pbHi{km8*q}gCwFP zoLm9`x3vHYM7$V4XG^R&&`6Swi+IYX0J{JTo)S$4c-SbAuAj>C|FidQTXq~tn%>Ub znMfQ-fMgxIrqx~3YqZp(*4! zp#S^L%-uY4Cjf!~2!QFC5pIXy%-lUZ+&yB)jvbTh^f9U>e40#UP@|l%REH{zgi#jJ zL+1Bc1mFZ;#8w_|X8_9TMF0>Dq`WuaSb__!G>~&=fOiM{&HwyZ3xV_9fBT0&>L+BM z`lEq6`e@)p-=Df&2&mmY^3*5%xY9?Wt9;!u(kps)$NKT2Cr|F|KL6srKg;J$e06C{ zKcYXo?~0BqdvTKSgubu*S=7SQL3OT?^+kgFt^i=%nV}(-ws}au=Uz^p@(jQYcL0cS zu3r>9n-3|B0FIyMC_>1Qn%pvhjURvyhoCCl0r)p(XP=AwTW$Z>hg16a8smpl-jA`Y zOW#+AdiaS>C_V$^yY^1b7g&h3PsG3tUhrX7ZUW^=Z{Q#XlO&-evr4n!D2BxWX77P1 zae(>k+*P>?%yshOkqz zZ;Yf{76BMxmo`8c-@FjeCD^g9c=!<+%E2p8`RUaE<==m%-%Zy?1ONE-?%Qv_+3la} zD_XiEu-7vJEClATOyt}2p|(Ju@UM7)kI(U06zVGfiqGN9k@A)&`0oX4u zC0#u8Er2t9T@Y-PBh^vlf$e(G)fxjZh{em0ZiyG6^3>g$yfvOX0KYgpyRQI$_11#C zCC9fP0lcM#eGRwt+dDcSCwdjI&FSQu^Juv3^6@!-3cC)2Eg!>+r2I2D0eL>A#Y4qYj_ERTGhm>v?0Ppr_-PDgL1%2rk ze{uJ&-mJMj;h59{0MN5?dWxworq8%_Z-fV}fMThuRc*tEW>M(6{f~}hJv;d}LbPQP z#3BPO5;pM>z?6m8LMWfAA>4}0v-4~`V2z;e8YJ5yz~q6Jv>O*J76CXp@?C)(1Pqw2 zM_7D`nTr500j>oH9PPrOcB)aDuMS@5>W4c6{?>r*3a~1A@W>vx>G+L*{Wjmc{=_Zm#M_|(^h+v?|P@govTm# zGyVgy`6x_hrt9GIgPn;67Ec{r7j#7@l;+x+lr=WCE5ZAktAclRuKaI!?d%rM>~cijtFp32B@199m8qV+T-1Il;%WV4apHw&XEcn!`@!wOE)z z3L9l&jAG@_00#}uIphpr8h^;f{GOFEu5>=lF+7w)?x6-U9VvVau9#RJwkD~7M;*!? zgA{U-%@wy&GqoRzH`Sqa`Kzqt+Ia4X$(%Q#`O6Qqg-(0j8McG_5AW>${oj4Qd-~n; z-GBYBU+=#9*ROVWbSss`z#aXly+7lnj8(8I&~5(CTEM-7_SXUCd@vjsq>(oj_3G{UUGnSMIX56J1=}lk3R7p zBuepIpZ`-FeoW|4I@evWJG%YPI4~1Sg6pZexpnN=-1b2qvay#+xjfZ9)AFmKyANv>d){$)6eKW)&qQ=*mE-X zTqL>{0iM*wlhX;8C-UifY-#KBfc}y7+vabv+OOwY1$?g0|LL3iQ!240>c#_rchqM6 z^yw(%^}d2GH;pn=wM97^d;zvN@%Bw2bR6ScU%@x|SW$0=qbv_J4*b>G*)OyJ;A4Q> z1;CqW+Mk@4ztYbDKlVoe^eXq_>s`5>J3awA4?TFD9G>TE5+>J4Q&Vx^kmY(nc}%h) z!%<)&H=QznnV^jerK=+rAJcTI&jUL`>$T$z08A7Yx?;Li`}&s>c|U>b=Y@a*+|d_1|N7s4viqO@ z>f!EpdaK}X^cBKC{Xw@^@0|Irz@Fy>G?>mQVuZaVUZVw;$zBJPciP7lzFxI^rO)v7 zS^j-}ljHM$!{_%8{9XKe_cdK{P}$VCxq4?UPF{TI=zk&iB0y?)FA0aeWF$4e)|2NE9-oaq|^z0V#-uEsv!5YZ+P!hm5bS1Mt2ai73afo}B47zBYpe{eJZQnmsL}J9CRWCh(xdWGb7= zElzu$Ugm)|ST<7Ooac@#`*gA1$Lic@{l94`78L7N-u!jfAye!l$-k1t|7@GFyrhemq6cOYQ*h z-T)O!4~F}@;a*q?&LscKUp>%|4n5p`^QWh~|Nf8P?Ed+;|Dult?(QDky|356a#x@a zsXfvyeW(REIvlX-KYS(cxqdE}AJnrLbTokEJuSRWSoo3!o(Xfxg9;4eS7BoW4eQwBNK}?C zPUl1;&cay2PTQcffQ$chm#QTLw@oE;oJC0>)k#}@9N=PRIb9CXS-hP1qXk~L2$0() zR)opwQ@{wY#6oJZc6xU(6Fygsmzp*Bx}XF#&` z^k*#wzS>=UeYCrGcGuq^*z2Le+r_{<@En0iI+n@!$$TbzJ+6MCMt=7EnIQU1_R;C? z7r(x%2QnY|m-FuH>zY1JIyU6Kjjz#hTz6F->neanHf^Nl%QK|4f)q5H)>cEeZ87-Rv@c~I-{~ojdFiL( zW~zMn045CCH6I~7sJhwvqPeGY^|8io3H4*mA5OYm0Q`8z>RLBcQ6BI!z$^fsc@{g| zC6Tg`D(^Ioa{-Qc(o*2R*HXmY)A5deY^Kxq(F-tP%;CX4o$tLlFKwKP!YA50NPY_mVX#jNDhakt94bHklJ0HMR z(fx0{ufQM3QEtZU2U-Lu-TQ&=-l_TR0^prC_l?2a_tjx_K56gHjA-q`ST83D6A3b4 zsW5LKIwmSf@CQU>=_|KfYOYlA<6J^+@$*?WJ~$N%$7IgMEWcHdVsW8&aZx%EQ}R^d zocP8Jz0{Ir@hrV*cNkaBr_~l$F)2+o)b?dTwqDA%DVKC}5nxB!+2d0Fh#hTSSC+P8 z;!(TkA@eY+g@9PX#^=@14v+LhFn{~Mo#{AS={3Vo^>U$acE9`mAN`tP{Yd2QzJ4e6 zgl`eZj)sd;za;{D!yeLnw8lRaO-<7xb7y29rpmHQ9$leqdC-lvaG^qu>A zdfAR%xTM?op5WCG^dnwdd!#!t&@2q~Gp(ZG5wH$WBw>gb3jpkbm)Z%a8@39S@}E*h z6Fh&$%Z?ZU4kx|_drx-&Xh(xs=tFPX&Gs7^9&hpsv^H?BnyMJDiXS*1@WD;u2Kk|K zQ}uXw`@?z{!0iHH9`3hI9qKm~lm7E5Zwnp(Rk+ z!FSq)(2grm=VCbL!>D%2u|I3%U64paUXPW$U$MNpjJzoVA zKI-gRMqPWs-XYx%tD=gF|4{pu1TLa?A?EG>KE)h{(P_e zzOV4l9_p=%sv32qhR00unt8^A&n(13OTM^@r=NOx1SvzQauJ8Mixj@h&PA@3+96)+ zQJSAl&PM=h&S;DS)n**Hb59E}blF(6TeNV>1_S7N+O~1$!?YwXadh3aC9h|7gR_^2 z?`!OSa&q#sFVD~URlsjv0)H>mw+nzD=P>ksS@gqS-nsKBPm_9%VrHJFl1mA&PKSfV z*4bM6na4!WB;tX$qT!%G>5P+od14;kI`(t1!GeGX08zS_kP>>Z5M61@mwa0Da@X6xlgZO>&v#$`>(kxu|M|P!KmGIXY=5S&6rP>vcL?|h zNgpYY^Wvd*ov6dPJ{#tB-R)h^QHh(2I+#o)Pwc-u!2*pPL`W=^F-7Wy$P^13D+&uinojaf3V*&7zikE)m zI$>gZuFfw9QpSl8C(<|rz*;eF!1@;eOGkXk@Lv-XG(Id7&R1FHP((7u&P$>^oWul( zShk$JWP=Sd1qY+}#kiZiNHozKI?2;Crfwq2? z6PvQ2!kLn2+RR@Ol zJ$KCtV^v-daX64qT^xI3+HUHb@C790#`o(c&J&*BdUAUDSMtHP0e<(ozTTzX?Hz!3 z+1f9T^;n(fiSGcoCtmNu3}B;^a+W9|Dv)FsV?MCY|FXT2yE1FXD5 zDp|%LBsksq)8On=Hw5-IU_ODtISoS4q{;2F>Fl`M0AOp$c1^bOa+ZS!lSZWlL%g&% z>BhrM6A^UNaTS?rm)lK~P8Xjpco?qosPCBQY?~9F%I7N-O?-OkoDPu&F%57mU>N7P zBT{y&&sG8XLr3CAhaNxC)rUSV=n0QczrE1Ia(pdLPsrp7fcN!#3w@+au$c zRF?_9Vkt0sE+l2dYjWvZ^g;g&Eyo5uZhc%$1t}h`j#J@iM@gk*a-bEENJe{wxrn5Z zjg)qS7jZz;)gLqc?5Wyq9LTk%v?p%@Jkx@&H|dI6o4cAH{IE$OS$sog9xIL;;}DCG zI!wbZ1C`HYUz&Yi{7W6Sa&YnX=;(+Azz6eHz}p4Ds~+JWhTHbrL*71pwBJ8G^(YzL zoqcWHpawXcmOd;d>Kd}4Khv{keTpRF5IK3Wc*1&eIEl|Da-GscIOi9XV;<1#r|5YQJ(r{LvE} zGZu`#Gcy}~sW*3i_!dSr(l|8P;?;ITPGh^_BeQP~h!U8>G3Ll?j42Y%Ve{L+J$7)nJCq0N7v{7=#te zv>74LJKiue(9a$;QMd{ZV}MURaT%ZvCu~$UuA-R%l&;|e5<2a}f7B7Wd>fY7@O0f* z_-+ml#dEu*hlECqn7lkm>T22xGp?xgBB3MQX2CZL0qV19&6J^AQ`I%2*>WH<_TWV@ z=^Cq?i85kouL8y`_Lw-4du@ubu-Lf{${DTe>3R>)Qm_c{6}^1=ZbsT*h>3Sh?2y&x z%@el(c8v#ZiOnLy2_91HbllvvT$ylhC>ZL32Q`itDj7bZ1am6=SuY#LCz3PCV<9L(KMpt1 zwtV@nV!s^uas)-;833*4nfyPPuL9mK0A7A<-xcDX?g03!B+ugU@E69dz8{N)38hnW zh0cJ-o9IYjy=mu(KhGl1EvW;?1kXTAVnQ~rS&4y_M8+*@76|bSfW-%QDng{nJ4!Od zc57PYEdeSdiP}MXXqOI)Ve)gm@$af}D$h#IEW9{Y3V>3D9o=qfeXInl;X21)$R5t{5kWbRPVb0h18<*iu(M7|^U^mkF{@ z{zD}KIxHZ>DTW7Bg87PClab{976AUz2J%`Ox-4kc%S9YzC!$hj!6c6?&nU|DqB{XD zDn4J399Mde5#TDO>`dl@A-)}u!u07$sQF*wVcc}MCiQro4yE_ezDe4L{4l6`BGy6T zt5*ED5ECpu!jIZQm^e-|@TiykS*l$;QVJ0`FaxKybu3hEvp#X$Me#cyT*inCw(NYx zU**rm0t*NFmlqH!H?G+^4|4FXlQC$iAOPx`ivY2t)Jl#&FG(bXayAed&3)EajdCb= zb`U`$S7ed$2{@m;U37KfNbLdt#(7s zwoQyD>3H#PyEwkRe;20m?he@@dB+S|h5ugoVfb=_YUaBD>O;4e8~wRA)>H7fnwp}>YcoP49RsuV+Sy++LymKFJRNwjC6ZfK-D#>Ql$ zA8OK6*>4`oaNGAN+%fR5rt6X{PdZL+7+uE?)%Pau>ze>dJOqf_Z76i_Rk~dOyxYTZ zsISpU9y~lgdCU)MF!*c}l2_?X45HJV!7@{mGp+IUEfQF+5Xt>b02T;RU3jL8iQYJ) z=k8LIP<(DXWyBis5Jw0L@n0u$m2XUh(qVU~VQ^!g*uzi{{duTqMqB?Ct9$Mk`^9Gl zb(!otERJ)ss^=1FXmiLOm-3~bRo6fbLtH8`>K+2^N3C3dDwiJ;)a1{@fny@15xfY9 z^Z0fT+a)`7F7b_sKPcrsVRgx{=h zL>POwTTbrSy5Eb45=EaB$0NBIp*XX1Lw4NxXFVReZeBI0@mGz zTD)P5pGuI8E%B1~V~&FUUXgFI?eb19j>XW2`AqEKhedAVrWDv~t_0Q^~5%tiEIC^i0ckh}qVyl(99C8xz|5+`EGN1NadTje!3ySa*2rKuA>-1?FaACx)mt8MZK zVG(%m#p!_Xtby;!EP*1vV+c!sfOc7(r=GYXNyH~!`7$4>v`l7`RT;~EqyDH^>iA5* z0l?uo<)PGV?IgI+J0I@rnA9+13zhnOWyHjgy~mz5HuiTYX@}w!7$>hU-3BwLdCF2|K(;WCB+we_ilAR|N5r=eA zQ@ieS*tsChXoJHt9$qsr{e#bASf+WLnM4_ExfFjT`kBe-dvPmA_VTYpV@M$?lDfc8$^_S58lJ~bd zI2M3NbpnWWjJ9_L%TLqWl3mu>Zc^_uph7s(%8mN3;(`8{h;uyv$W;LEeAqNfw6qog z{s@51bRZ$Urttv?xfc$NFRVrODXN6{7dv&EfCtJjOr^t)MLmmdHfWOlAq)16>_0s{ zwj)+;vme4ngXNuJK9EG7iuTu#J6v5db#Za`=vNd$JbEz=(=*uf{&a zPE3&6jMdrALcm)B3U6%s@3ckiN~e65S$(G_UX1XG9y(LeqdYP;%nDKZpZ=0YmvV|v z?Xw!;+e~2rW@sGouZ0i@xFIfOYN8|tAO(W*%4 zJj#Nw`|-S-6Xh7ZvrN~TL-hoy-y=F)y@L`k;TF3OLCVN!pl z1;CY_^greyzypbI0r14TujHj4O*M#VtnrzN1{4vZL|RKoaYeRcm`WNbqDWD}lP$k~y>dlSt^1?aRN136;S z@*V&TvF0B-H!{=YB8F}iTgz@80Md<}49N5+dH3(qH*D8o?bvpMhK&XadFjZDF6iJf z;VXi&BUX=x3SXfO+A`!yL3c^Yn`pVJoNkeB1G8O?i!`sk7Od|$*ILa6hCJ1blkg1~t#wcTbJkX~tKzo%Twzf|n zWG1yM45nZrUg{Alh40d=wt@IK_vd;I@NX_Vbyos83EeX3(=U*_W0Zf8KP=(XZv#9! z`a?o*NiNQUq5pPmYb z98vPFTj@&N`9_CP_)o7RTVmlycEi*S5%uixtWS`&-3HGCkf4m#>&7Bri4C;;B)z)I za)3df$|75-r=JOH6Rd>zh%6B4#97j5I%9#aPSPsfZJ_&NV=MwtEcKmrr!Key;>D+O zBvHrg!8#5ep{A7xP~yDfJK;_E?Gd@MA0b`bP3$m62{lJqwc zP2;OJypagJ#<1AFMJZ1=DP9HEH9)Ig7^nYLE}zZDjuUOMn={Jf`Xts_($Zoh3~)wh^n-RtgyZRRA0GelZpS zvb8gEC481&a@S1xTm+Op+Jk=69|*K<`EVZnUF7VSFz}IO3~?n$eX3`6NN&dy@-a~~ z$1^G+ zwBy%8qw;3=y5v2*2jKYXieCe~T>!jpBYvcIFY4>}c%s(5a#Q&i83Cm;*9On)dp$>K zL}c!SHcyVsXem5mN+@I7Yd7x(1WH<$sjiS*f`_R6*9ds%K*!G1*4{bgi zZJfu%IPm48u*EBP$&qJjq$R75sa@q+mIF>~;awb=)>5u!?D9|wR}rQiPD>gA*4VGM z2&kgM%<)aquBjd3;?V?e-N6i$M~hpluf=DmpMklH<2*GLrei)P`ho>OYxiEa z>hpdbcr{6DkP=niZO8H2;K9~m1rP75({$2(-9&p(!g!Mi#a83sw2wlxqHHX`A4_}b zPA=`n67jcwt0z~apN|;XDhYK}f(z{HSK%);c zOlzA2+Qclr13d2{fWw{uL8qWGQgxlN@{P$NU-_;xZETdO$Fey6SlfJdoddQ~b^p|L z@WVdZzkEz_mLYu&JNN>(IIic0Up%Dat?8D>X2xpe#dli-q`NqJ&9{GD(B+V=bL_&W z{Yr>@l+7SrK_a)%0%M{a=?B0_`7A*8-(Gi@AOH9xivDB5i@3u@5yP#6TWV^uh5X=i z#sPi_(9gXbsNWTD2-MSm@nb+y-GX@xK}36LD|w)&2MsOD()lp$`ZWI;$Y4V18XS{ZG5|Nk86TLXEekB|yX!-^R9`9g`Q;vt>C%jq8iRX_1 zI4fo6$r~rBjT}XaGBe9=D_<&9fB+R|8;i0HLcIj2x|gso0u0~SZ1HXZVYc$w2CL3E z`=muMtjI|wPl=l<=ph({jn~-nTk6Vf9SZ@-DUNoj5)8W$dmsanwn(kfZt-AY^Iv@r z>(oImHsX5RS_F)83T%AyZPGj1FcSR}KlVkQaeTYqasY`{ZhS5{xWQ}{J8gch0w_2# z7a(}VOTwnJ2N!f!XRLANPE$~cs4F_tBl1+^d5iRTRLKkIkMKW=Z5qdS!D zgg?xx_=jNcjqHOckvdL_x+*Vy z8W-j+oB6n-4U%`s0oM~TF7E2@0qf(e>b?zXg*o87>M zLu(s3(1ojfD1IP8tW(+~%KoO^|G?56Hs2h_fNC{&^rLQHQ!SK zy6g~LCmkKoU;C3GgJoR(bCQu5VDofP7L@kJ&Jz(|bxMXkc6Km!47$tD0jIwW%y`S# z#d3W32%>5z0D5JP1-`Zg^luEPh?>FIJRnCN(A8%ENS2g`naJLJ9AEntx zP`dWn!=wGrAL|7Yqo1dG;p;3^UUKr;%Ssw25L`$~uAGy3SZmJJciUs$4U8|4wBx)P z6Hl3sKpFs4hWZ`&aSt$YWE8dATSlD{Lq7CoP~MP+aheZ43RKNv>-29~(!*=%Brw_Z ziw|pQ0LmC!`B-t~sPZgNc+Vi2$q!m1@L3MabdiLz$C_<54AR4NHhh|hvLq-S_P7IW zVdGqqWl)rI=m*hc@=mn1t=go~Dvi18CD~F!3GJF4eYD5fE*zzcg{*MpTV^;cA7k1< zU_AXkX!A>O6q%5N5A--*XuC=1o5ar3$48J+v*&sb0Jr&CEl15Rb)|BKPRh6oNdrV9 zm`WpOhaAXjpl7=d9;caVavG9B6oNdC_CZyLHF{w44#waM)5=hySIzO2cQ5#am)%{v~zYPFrjYPZVU8vcbu@mhk+@(aPQT^z$y?3 z0#|6`wDW^GC8R(HlK@qY)UPJ!n_<#qU1%E#5&!@|07*naR2+zqcs~G??}h{>Cy!Cr zaAAW+2EPbkS{oV>J2YFUW!_~28Zl9(l68qiPi;9|Bo4Mn;?~S8L{Q-;feYTpPI0=h z)4c?ecNO%~vR&VRCX+AxR7+A!t283YQajUXhk>9bb>OgIK#Iw+SRdU^4Da=Xw}eV*-2*XiNVR&%$EX({e@gYH2K*8@+NZ;Z+&yIlahu@?QX9F4yB zip9RGS8D!D4*}L)@Hl4}CFLplZ@Nt0o&Va%KCg1ZCQgxjft~#@=yEF7T*46N+x!f^ z_=|rRJH}JVb+UxNDhp$+1_#zFS;3J*6my{RR&`9nmbh1|WYbkhY&MiCp9O1ShPoz( zDpXxd1H%Hu8}lG?y*=W1VF zr-QOKj@`jDqjhz+E%_l?>0UJ_+DY75xP2Ayt2Ww4jyu$^x=gPCIQmRKA=yrhwM9l3 z7BOf+pvNYUL)X0*M#}N(Ob=dx-rC3K{*soz?LddWP>X6YMQ_4d?_CBdSFk<3j5juY zl-*zlQ5xk<200t1VUnyeUDqH9N8Ez9p8}=-%t{)06PjdqQ`%w&?nZ^mL0MW$+keB$ zhq)nY*z`}GYkN`SfVpnH^*;(di4hwt9=eyNM1v~Jg9EcbT5?&7U(JUtm?hz}3$}J$ zmq;M7=vb65U}n9_{gk}G>;q6;@Kry(2Y5RHQ*^!tc*;wFq;$QO*n|3ZzQ^MnEdwjNhGkI;2yCX`suL6GU7X0ZL(l7b&|Dk>iNVnEt zBUQ(=WXNMUEtD|{91xkKXX92rlUG2@giZpkc>2YX?Q@BaZKPp2e3q{AsR)U$tA>*J zD83XEIOFAUoGQRAr9#;jLVJuz8)dQ1i;-9G zLnZ>+ZC8#gGa?p~U9Ny-529$C_}F#dqDl7D`fhkG-Q@5L=VL6wb=&kC^me7dg>&)1 zhs&Gy2{8U<)O)XC@+TehLjXPkX2N8FxeGKr@j!XZ)b`ErbXpf178j)rpe7>d)gCsn;*9;!e^0|N; zVu6o4TyX-IXS?iW!G6OVi!2pgZ!xOcim*}a5UnXC%7RiG)_}AE3ovr(oJIqQkMN_s zh@pi@o3X%}cx#)DNjEMBp(%<>(a?5?=*b?Uh^Ay!JID!j)+#VPV5Bx$1uYl~ZSfCy zBs4^FG?+}$j*^y5)3uTX+B!*7VcX$nh{Kl($s}FwDxZtnDuMFN@re3G5Yz0^L1eLr zaD-GL$0BT-Z^*PQ>FEClbYM5|GW#%cH3Ad77yA01U)8l2-fsd_YjFpFl-WvWgSt(v znY+SobtNxk=LbEALS^oP-q7+cODrr7nIDpEynip&3)6Vv>i4qyF~GMAfH&LfFX~Iz zbpN-0Q%B(+>qS6g(8%*&*~w_G-H&6{8}?qbvnqj%e9%%oBODsDW zhdf!-$d;sO1GyV26dhwaZJZ4nqv@#YkPf~u%8Oj6DV)xFo2K4bD_A3Cw=Mz#+uTLt zwD?g#aBMz;HVT_DkxOQA*EJe+ltUhHV*CU^joy*scwkR*Db_kPdmH6qAwf3Rj$uF6 z2VxMCNdOt~;f1SymIZKTtdYhJ8Mc{R_qG7B7=H!$0P{;d02t2ztXJbz6}|?1;yVCt z7Ky2Cv~#vr$dc)85sSLfW6EXvm~6MHNvdRd^d>l|C`A{~(sb$DrgH)C;{^Ynm8-V> zo@Tf3S8Rdmvj^e-&#!lTy;1A)2PY?o#=h{JYaV}fEsT`{8oejnWHu3AX9IUXmD%X;qb3;oU&m8~9KC);8gbbz&0neE>Pbt`@$wlSJl9(%>%xS_XKNd|d6NDGuP8_WdPQ z?hAd-|3bF`_-t}}3n1F((zh;|JjPuB*EcKetMOUIlrFxIS*}LydfM2x(B)&uag|KT z$TtX31-q78`8{_PtIW21$+vm*oonxP+rr)p{&oTI;~WP1($(&p-O1gflg}Qr0BECH zcAzMkrAMN6z819fRqzAIg8lA&mV}8vUZe6|5baR)o;L$|ArGA-eOo|A8V&NNJ+!ELDuw6X_5Sgu;64I=8O>Ep6 zSNaYxJ_XQgv0M_OVS|d?8=5pD_wyO>(CDy9Dr`a#ha#sBO*CLUv7uG~BqN0&*d`wO zA~rhM%{*Ah_d2IlxccWgfHAwb68rf;4GeqkT4tS@L^v*$*Wn`%ntd#^dechi)SIr_ zENrD2N=d@mloc;8MFKY+U&V_6H|>Y-n*gsT&mre6d4Ih!-DGvU0Jy1T-j2Nb>Fz(` z|9rRC)&Cb-036pm<+Ey_2I11=DP%eYK0m6bk#n_A;)}_&BbjR6@6ibqgNq%-+LAO_s7)m`~5B7p~dY2 z;N3L#wLbc%|Db;R(}A}TLEa_^cWW$A+g-@=>f)2hs4AW3_ z2hirD?GKj|X&Na@YCEO`<`Fu9KX^^|60){xS-8c zuf3iFqTQ}xu2n8D9S2?WujTURHbt(@lad8t75j8-!x^|spsK2xMjR zWZEx$S;WNJ{TPa)Q=&i=$QA>*&(loMY4NGW5*`uc^rx z+$??X)9nJ_-5;W(|1e|j@9g(qJkTA0>X?-q;t?*!9(Z&^UxQd-%*Q~-8CW8lbgKEyQjS`D%lY>t}*$^cNe$;wV0!Y7!of4=>E>0iq9b@AN zR=_y?+5f<4%U(aq>xclsCx(fiD_85Z^DnkpxA7$zj(p{B@U%hRKMGhIBI{yM8Y03* zS+8Co-_yN{{#*+HFQN|24wu{kRHOD+1k@FKtM#lLmCuB}9vUne$Hz%I%Lg9Vj1@$|Ef1Y{w_sRlzX8 z5BV!5e2gRpevu93Bs@?gHf8}05Y4EO>1>h6QIzn9ECMKG_uAt}N!5m7%)dpaL#3`^m{2g&Y?maB(K#x;_e^|8yUe#pThS@}i?WoExUmL*N8IE^M%p zUP~2!DAG@_-q5{g1ns~b08&k!WD=!BjkNU;FG;c1?OaI$D0B^2IKR8dl|8?3G`R?y_NB{XhtDoP! zyFWTUe*7Tc18@x}^wLRda9ZSPm01p7vYQk^@x#Vvc+62Th~-xShhIJp2utI&BkzeT zfbmnnO|iud)geX6lox4&QDM6cM~O`vU>?YagXRkx%R_0b{X`>OTLf4q6Z=fYE+hyS zUATy*?}DiP+`!k5rd>6EJ)VzN*Wpflc^S5aQC{RiO<@&C`RE)&W>^+J=%F&c*K5_o zX^a19lssBTgUEE#A^`Og$HrCTFs?~BUClakMK9>EFFNDWp5@8$Esw<(q(2JKaWZY^ zfoE?N{;hl1)!_9x{N?ji&tBil zyR*E#1Mu$JdPMsBzuz7GofZMR@4h>}y1e}45kCZ!BN^SY`ufPnD3>Qw_F6K=qp}%z zBDDbux#uLrrepBJZM+jeLXt-~<#Gxx!;JC(;UfdTA{;%SN}@ejTb9&!J#Z%fOPs2*&TWHABS1q&@E`4Y#GkhlcHoO6JG?M7$BdDa30Pud|f3seM?59bYeeI$mb zlGiyke1!`eMW{TNWbg3!OAJ0J&zS7Rn{F7O2mAhTlFr`4jJog<0PV0`)n{49GXMr4 zgs7CXGAJgOF|o@r#|U|CZd>uWjIcbEVFj)dWhuV$(k*$lv4kVe0(iU3xhk1OXeD{O zF@K2n+XcW6X}xKCQ=hCpSo!YnqhFS#ep5rg1jJd_(zfRWe;rdeawdNxw1Yy%DZ`{3 zINkc^4CLP!uI5Q0^R0i&)q%;APK5cQC0$P5n7q;qOnf(A7p`001*uRE6{ZH8%gdtedJakOl- z?)2km-G@sZRuv1(q|-w>b~crx&i1?5g(UE$1<>SOEP0jn8YXQ@Ubt3_QrW-T9?-@v zSSdp@>mLXAm&6JRSQRrE)IYA;>|%;E~!oSNg9yBWKkDjm2cOmb-tff%{MJ{um~ zW_+}1%C5z_32&pe<2WqAo9+O)jdK9vazE8G66yE$8Gu8L^b?R(Um-7gsrIjby*v8* zzyEs{U!Ur0fPT3a{qZ1pu~gp@2rQ`vsi5Kcn*cbx#&WC=};BlrD zi-XCBG+r~jd^U(p8g0wJ6O~PE}L;4q(F5pIQikjIpnH%nhc~?#7P-u%WQI zD!`_H6u^07J-8O5WCZmjkDdLnThmR8fJ1ZIYWd@F=NggpY?3bFY1K7(aUc;3022GE zi?1d}<7Ar{)pn`3T@#N;(#PQ#l7?Ez^6_%yYDcMSnX%Q3%3M>tn&3MY07pkpg{~p= z)eL_ml#khu6#HWidt;yc^{;nF|L_lS-t71LCl7N0Kx2$^M>Dy))vG^;Q2<%eqf@0G@3IMGC&}Hd-KBW)O_NWa?T+vlXu(c{M&90@wOLS-v z0J0{|X7zrMD*H+P65wcqEE&%L(0IHGc%)X>Av4kM4b1v-JHML@T0}K3dC|jX+LdnD z74{Vy6ua)b(<9bv5Y+3r769`9t<2j9_8QLKkx4s>?1Pp%=W`-nPslg=beh5ECu>v|-~EAVE?x6w;VV2@^KYSyNoa^ylnR}?922o^S{+Ujf47~ zQ}!ydj8wr?oY3-xC3zPPDsa5+IGm`WuE%N zAn#k<5nvn~a-B>?*Q6iz8u;uo^KD!iVJC=lY%1|0p#DHk$-$E-<|t|jLpAq99>icL zVxwpYQx@<&}J=OrN zx`S~V7Ja2{c@}=eN_6+pX{o#2Mis^qc6s6HPfn?H)@hXD2M(UYk{DR@^j#+6nc5Ve za%|WN2ZDYv<`)B|bIbx0c4dnVj;zP0a9#x9%S`xuokalUcN}~w%#WQY13v_G@tg%f zYpX0+UH$V702+cxe>)abH7W-ewES%oxBh>j^XB3=zhUe+;&%Y}A)p!r0Ns?__vNwry|4BY>@jLF z1ei$WaVNmTo8JQf)Svq+FMr64kZD~Al`e+As1R;_2cSk)44n#H{F=W|dq6ovMPy!V zgq)nI$*L~VSk(;Rn>v}0Obj-0HMo{OxPePY)h-=7FezMl8S>8o+az4tt#_fcZDJj( z>wt(aPiq`vgpc%EOp}+WJcK`_?guVtSlg9%6FdFi5KH(`1biklJS6X|(Zz!+8z0Kv zW<#O+%OK2EY6uyYx_p#R6kZ& zfAp(gMW6jbee}!6kM%6w(Py8Yoant847r&Yq(qwUv}8C!URV1f6B~mUmgovM^j*+w zG#W7?&4DX*QA(_pWb3kIB<>`P6Fm?&?!#`X2}kO3(_Ijd6<7Mqiw)4^Oih;7a21=& zC3Y}jP-P3BVK-zz(l0WT#lt0CafV$9mOSvDh{^||qQOEZA2bIL5kQm42OV0enhwq6 zSH+YUraWL2K5gF^i@gJz<>}Z#4`T6Uf2nHG9L(aaS@ONC6}QS(x^)qt$vOkzqGHwL z4c5;CD90X*b;v>UFNN*W$Qbk{FbJEnr#yBdqgn*G4B#s@`lX8i2QR~Sn_p_$VgbO* zzN#Io1b(zg6C4YGNHOkE+*UoeT~xs>8c^Cy8}iz^)$~}NCk`*+Z`GM=4NV!Yl_M)r zF`cKg?lV09@clDY^5W=-X8>*&06)Ar-%AhGmtLiCM||7=*XqlEsqNx7yCWw5-)ehw zadC2Xa`JOt0#s*44m;uZK<})Xyqo8-%iXF zW%$|9QOtCp7>97_)b7`~J7HzjU1YJSTCN9|BNW z4}3{rDK=H0oye7`J)l}bsMMu5(Sc;2M$HbJZZ|N^|Fzh-Qd;e9mWAf!d)i2^OXe+r z46E;bs)g5kU(olYfZP7kdFbM4SM$0Tbo>vZ)f-~+|Kf|I$De(si;OG%s_xMj_xsbd zn@ZAuy(mzp3Oc$rvfjIVN5Hlbp1t3=MQ4og_U(s#8zqnh5mVjKX#Jh?CzWaIB0ya3W~gYTfcuf#(IM*G3ZE`gznDl3iS-no1f?li9 zqOS&sT3726uUerdr3z8*Qd(ai>%6^NidU6f2U?Td~;G@JQbIWSn6&_2Huwd<4KV0Qe;J6SySvR5l>Q zwNE=(lf{=m<@l~`;L5)8!Vf-;iYHHuTjU0{A?yYb4yt~viUu93=@*|Rvx|)YSp#&s znJpOPg|lhelbOtK62$Qd<wDKI(%4OvA(27FUDdB#9nfB65FRqk?$C=Y(sv*A@YeMV|=|WIiv; zA^MgIx12N5r@3vH`Lo%+4U&%l&Y#Qkrkup$BLJ>s&bR|$y>^LnR&@kB=peXTFlAvj zAmDLC8=J13@*Ga!x7b|RF(miuZDH>Xf4cy9`Jt$Oa|lWM zmA>b@f5`r*iQl*UKhwOa$@7TG|NN`3c=CU*FVyoQAWz`#EjmNUtLJpOg8OPedt~T? zv5j`D;yKY0VrTHaHI=@7nw0?)oY4p@jBGf_$l?+C9Ru55lcxOyZ^LUkczM?C3yo~Z zvv{Se;tn1n!2>#oXqVw@F-peRVNkBz9@p#&Mqac@F^%7bS^Z4lDj(Gd^9c*rwcC*hY)^LSV}KN7YkH0EHljOgKL|E*;x6S(BWI0flC2bFjbph)5eC?p zkOkyw4}4thM=!?@b2y1-0a(y_62_Rsq#!yzbq=BToF}6oKFh*4CISRf3 zB7ALyIg}s53}0yg??GCP#~pz9XhZoyhg<7Ipqph_GtO!a#S+SA>CNc(Lvyel-jAZa z7o|AVBdSmJw&SyYV}GsuAGG}{_+x$MfBZy~{bTXZzTEAf{oxNMXAd8qsITv}J&0cd z%${FWmZy!RG&5&(*rqJ4PhMzs_!_k6jsBj$iph!0AUHgTPScbP%@P5rJ|f)d;l)Kh zm=qr>+Q8gE*yeCpTQE>NRh}#b-il(xZSn!2?%Fn|=1}9)%#=i3R59$PIHD)NExV`7 zhTYn&ynq}GLN}Y@hiDMJh$_>j0SrqlUc1k!gGvyAlsb;yF!%wzVG%HT&c=uABElMH zQ(VW%Zj%LBGBbD>bFb*|SXRw{lAe&IrVaze@xvQCZO*i#D+jImnHUhziaQq$K28Ha z{b6=(5x_A8TMY@QC8;7%%6v{5i^kg2;3GB!)~@P-`@w|#`XNBQ2jKcAlPs3h78(Hb z{t~xYm8asmST!~%-xf3Ytu(BWdZISl+I%=qyXLo=)S8N0_{tMMeRJid)Z_(y6M3x7 zkIv<*iuWemzBM0x5_@YwK0wFxsqAs1^zgkO6~>dl-tmu)&-XF76f`&r*&n)_l0q{G9QzDP5WYp)=hp6kFhmCwW%~lvjf;Ro@u_f^H@|MH@39E5 zBRgvoV+qr*!$B7h(RtX^+0}->X%S%TCRW*BiJX!J6gJfZpd1w%A7Xc#<2I*tS$_Jj4whnsenDnI|kT?fiDuLsi z5`5sNEh5giQkmDT`0$aw%Ry6`lzN-ig}|!CO}X-XcffwN_-+{Pc0f z2A6af*_=vLSsN}$l@({o3bNRnVMqN{d#XkfUBmvANiO{emyW?#oL9tTs()xumE6~3I^kaw5|>O($n zuzg)I$5}5+yL|}obsO+Uwp)AM?90eYck~~EKK@S<{zuV&`D;!7`i}p97tNLbw@-Ha zzrN7b{+GMsfBJHFa!(h{|N4jB{?4Vgd-wMz%DIy!xSppgw{ad+rzNjVWSk@FTm>(j zb&}KZViZ9ViBIbA?jHam&kZe$2uw&G6s?_QLB4WGBx`}Oi*yK?s>~`@Nz1bMC4ZqZ z=56CUF6k}`%q->B#zX$bU|}1xG;dBIOPvxsWX01)%@1W57#FDTz|xjXSW~{xh?~xI zm1h&HV0Cm3`zh27@wRI7(Wa%UJj#B+j{t!gNP|``+NH``UWQ$Q$wnVExV4pM->@`X zJI)K+j5d{#aI}Rnz|F+s7Iyg028*oK8AIDw?C^&zs$mapVblr_ah{e!x&1UAypqeE z@xx2_2rc^9ibw0QVTG0Ym2-Xy_<}2#1K;uE?jIkY@ex2zj-7&{E4P?NQ7W0)lu`eX zGgdWVnD{gMf`Y45zKSRB`r>^%Hg(X%IAja{O(e!uHQxtw2fz!XH&OAAz(?;ty^oZf z{8*p$AODT|(SQ1P;hwP)6C15E`B@fZwn#I#_jD0OYW(5@OY7Eh*=O1~W2bG>S)LMFk!2D+k73$WafgE_ zR_$k*C`VbRcG!q89a)Gs*x|6CX@ES`z}G-IdKJ_jdcsv&*CX<>mhV z-MdH6zx{Uq+l#ZupWo3-02PIksrMG>7+6ADI%Jau6eknk3>y=oOU=`+I*IWj1AlWs za858fD67;ugYz6I7R`-`f$Qj0jvXUmRiGQKn&SIlo7qhy?M7KV=2w|gmRXnrR7H`I z3~d1WL0&#YFIbE$34q-pvOyscD3xF3%$rp%F^gaWe{(=V;@dW$17Nu-gCAtjPv~%oo)IlY?A!qVG*YtJl zxBX2+`V=1zoa$gAtvE37@q;EIH^22ij7otZ{j4Gj@$VR=bAHWm2|>xu@RT9etXp zGz_Gbx~z#)9bn`Pyj0}q=vXHx)4on(DPnNoMCQHKNUtaCwsL(#NWR(t*Ub{#%Q@7; z5nivSgEqjhJ8UwXVCxB{W0US8H=u#d?Et7PvJeTG{wV@Dl8Gpg<60KBi(UCu9uuCe zRUIZ4*=L;$E36=+E{0FVDxbJ+KhUfOwbC1l0Q_omND);|d{$AcpF2lCwDY7n8lxO% zB-@8oxT<~rMsn+I-~2Bi$<5=pw>(ZGb~qx6k{o(MPoGr*%2aW|J2nCnwhTLq5VDbMm3v9? zir3O1oo*OPGk8X#>oe(|$Vl3i(aaCRCWEDo0{H1UYT*Z|=!QUEtJP7r{KWc8?U zXyc%CRLW%nzP5C+X4AFhYqS;mHn|)}T)np$=S}(ksV@NffhxM^T>0<*=I=E5>#Cnd z=gPkx^t=1y37_@v?&-Vzf4=;~@$dDP+yi|LWr2@#)=rJN@e4(Nj(Q z7vFt%yuZVPfOn3bU7UaVP*2)$vQ;waK`12f1oag=A~Dd&npx0x6c!9eByen8`IGwu z)8NCm0qj$-IzR0*%;nr179*izv7oiYjR{PpaN)NY#kjyqYIZXGHGIkgkZ{ONsTWx8Bf{~N55S|`dp$ZnDtsiNPjX}BlU*e^c z5sHKBhqzRij5TzLr8utdD3^+8T>`Q|OB~y1z&9`f&T`UgrdwBwA1R|)8w32SJXs_$ z5)_j*gtMr0nHP)RNo8bGrl{cY8)dLmbSO%1PRuN59V4 z85e|2!%dXO6%|fSYvKfhlH*J)Am)`>hdznJcLV}Z*rje|iceC3f}4BFBX0W)0Oh>W z^8tPfAn3I3eR4Xq}w z^2_6I?p>Vx{_3Hw=k+asd*AF&HThrMy?1;^J$wJ{)&9Fbe|P%)+uh0W>FLSIw&L>VZjN(e`M;FaRSm=nJ1Xk zmqZ!ZHVF}-I7P?cP`2B=*_Nt_UP=;YyS>N=EXmn6AihF9_h~TXgCK4!1j^^|Th_)- zgTO_jbsNJIwlPt8B$+N&T87vC!~xmL;fI?+q|7{hq=ULH4s$aLUly>N8poOJXro?7 z@Wa%K@-REoQvTs@5Md>Dk#r{MF3M0*6f5HRA@CfooVd`WYO|PXh^0St+7gnWd43JK z9mF|Mb+L|Jf=tqfGFJKRWl5-P^0*4b`RJq!((@Ps_|UAUB|__5gG7);UxZ4?AjX1V zg~2&-`~SJ_0G#NjfEg#MNGM$f4Hjo7yaT}8TApwb;fsDj9v%{&U8H&n`M7Ag!AD`c z`jD*aO^=4%Xl{_dlF#PqRNv}4+V4M@1;9`B4nRMyMOVJ#DSsw@jw@IG-=6P|{`5>& z{`xVWfA_@~$KQQ&aeQ%kb@a`@e0BWn;iKc{fB2K0=6i6ozq{K%xV(3?KfBsOXz7Kf2Prv&*ZK%hM~qMt^kq{Q0AM`@I(cbuthSnu)y2rW~r$77_B2x<8vy zHN9PVLE|iqU6~BgH9^PSpd7{rh%(s*ZqOPu zfx1c?tmO?~qwJ6m0uaVAG1R!QsLik=2|GvzP1-m#-lxtcP0k?dt8;~@`A7M&|L3%$lZP*>sUyV<3x8Ra?3PKfR!i-$BY z07#oME$W0W7R4w`_^+}>8&f}ga9n_n_8^uI7VR2Kg4q@rq(4o3SGuEu8(SNcP9=4C zcBJZjy`rH>`;0Hn91RGD#6A<|uBDXcpJ2*Y!gZ?&U%XxQ1*jCe6u zs^__W2 zaoe9;{{Q;zFZQ2n^1t_)p7z(||Lpf)9^ZL>vFAs#p8nyIH~Jm@#ocfApPt=2ex_Uf zPw$+aoZq>lMZo3$&dJs3)m~Tpn)>w`&HeewvlBfHcyfGn`N^aG{`AHc@dyy-MV=x9 zYM!8yKr`r8Ds1H?2N4Hb)PPSEJ{TA)O{&8$b!Qn(*Oo=Yr6{W~0Z=mS*4Hpy*({B_ zL07QyWmv~1-9@%3gW(_u#J(*lwnG;C!2kxB8|{b)zEaZp7)D8DGC@%0rfA?&qbv?w z_w85>Ib6z5_)8nO<~wwG%vM#}b*Gc=vBwd|+3?+JHDu^VrY{sL zN~SO&u6Qg0!Uu9omGkSEK5wjJQWFoY%_7s`BlxOU`UN+DX+sz<4#GE!L0{Q}wXW3J zM^c8zD2vJ=rXpb!F-A+H94Si@Jo4Ozy=x0T-OHl*~YvG6h3!gDGs?!J3+gsQHU$LIZ;{P~I>xBQ>|>Q_g<{OxadfB5XP{rTf3M|Ylmxxc5Y{y%^9 zr<13b5B8tlyV`$p_w)VHoyRBNUfem=i!x5nFTdL#U4Eyp`aQk#&56#ZXIJ|>Pp?k& zU4YZmOHKOEo}Zpv9)0p~uipde4OC})%B&lu3t{2Oy>-3lc#tWuad3q~E)iE2EKBuB zpn1Z@+X2CIvhjC45r@P@09OagWl5-Bd4I_NFqZ#{HDrx&^SlTkY&D@_9h-C)*|iK7 zSz~Gu(25XkUV`S+Bs&vP%PLF638QTt96kMj7=8ji>Ju7iJ#xkbk`QB>i*!=X$g@0n zZ@?n0T~)0dg{o+B(L|k|zGs^@=qShZlw};T7xZ+O1~rkJwT(*N3NZ93wrW$k0hc{^ zM@(PKBA^s?M!?J1;wq1H;V-47RC|YSaxhZFe+E=++@&A#Dtj$Th-5o3*d~|>vXVvO znHS(?)E@3cew9uFv_8@+yDY#<|b8+wbO^OQ)xaLRJ&X(Boh7+9nz* zCiueoS%?G}-z&Qsz7kh{UkUt%KqvYLKnnnU`D--A8}j^i+|==UJKo<kp-=_i-R`=?)?Jo^Ka|K-Uyy9c{RckiC;@7&#AonD+iy|_Ag zc5!)fc6xPkeyMNyU+zxto}TLEKRRQCc&_c}+11JE^XGaG(8>Pz`1pxl2^0?j>crz* z>P-U@Qz}&`N?jxHzaKldq z>sV{kf0siewrV&LKLlAG5JNT%tUaunApBO?Y+Q473su2&A68I!Tkg{Z4%~F5^-~K`cDv${QX1~0@?)lT4lw;s1 zsJ$HN7SzD_aX5dojr1dV>wT0WRKMU!|KsoSN&j#E%kJoRfBuzk`G2F&`+xs8Pfm7v z+V8vHf3?5=$45v1s@wXX-n+N|w|6g3PS386zq`0NIllaMzt>g&@rfq?)7}0|xn_1P z1g`c>{Q7d>$rGa7IN7?pR# z_%*CpabGV2CP>F%BS8#w8XVMPR*MmJ1dCxX;=YZ&BfemOA?7H%nO2G{ZZCBQ4>`nO zHvZDxP@4#DkS5lavRT0FyO+^zR=Nt^`9_B^-ZW4)IkYziDkoWXaGt2J1{iv>qFvgl zLNjzhgsApw>{eGh4de1pKE)H;eN?d;(&Vr!9~*(EtaM~m>O+)ml$Eor?3L3N?%PpZ zbCkm@xoLJWDFrJl6H-@PwXIP@k+xoB;3mr9&(hPD7$htaVLDYvDYQzb3`E5;D1oCT zyX_F-bZ+)xfn@egJ`-;MeEv-DFHig71_D3Q^ASK*K8tX`Q}`VA1w>r!V>)o`2X=}) z@t3^krd`PCcv9&gE79%Bb;*i2*dvAZc+0zrZxP{XaNJDlPA|NF1Ca_2tx7RD;F*wI;acV@0Rb7$tt z%$<9mLAwC!E1mpXYm?wge}{|3av`|>4m2%LM>x@OLEnUGycJLHa0hM4GJm9OD1rJk z?GWnVARYOUv!m}jXY#N`QCo9h0t5iOxFePdSwY^}IV zuDtQ%rL$-+nG*~{O;0METL|g3mK}mMT9cc-r>vs(WFvR**jb7Ixaqhk6S8~ilv0u6 zun>n^vPfhASO^3n6I3(0DbX|Xl3|JzfbPh95+DI~{$n;g0}U$RjG+ zNw-UMahR=R?Ibjm(Gs><%gW>jX3Z8Ppw0j+wFBVL3orVNE8CLH8Abjf|gpuF!&Q@Ex7R&Ds9Qps@k7vW5Y1{u@DZ2B~NAqV7 zaOAszZU5uVqxn*w_5J+hbgnP?E$8Vi>z()Bk| zkEtr0c``GhN2cJQ_^D5B{Den&0OlvH1dk2cn6A9v0uW>ILH7F$HTZpz4bb#un$Yg! zOc>OSCmBLcR?t2Yng;9mNhW+^YoisqONST%_F%v(OzEL5r&AP)Q$!P!2_o~Ghr8G) z##DlQk4JRio$r7X2`Q~Lm>zkL_O*X;J6{!CwJW z99k!Tq%kqs6JUww%>W6;lWvSYe#lZWOs z3Z0E7&AtW`Ew6!j*QrZCV^!j=Y&6bi=tcsCGN$T8-?*+AhdIjr4fDG51u!R5s zKmbWZK~#wP7qD<7&0h)lLTH_>F|mZWj4p)IrBiGU35OOs6Idnkl!eHb5YI;)$=4_` z;=@L8@tP=%A;2^tu0*9BL1MEZCxn5~4zNjs(}tfkZ5o3t%@AID+q?xJzIcTd%nO3e zNlC5TNh>3<)7*J88DGekM3ukl%cD zw$OKc7MnTm`p*`_xwiD>_~#3~?5DTn)H68rr)U0}M+>G-qd!dsbmD)x+3G8RbA1SS z%Zb~glk7}oTp#bZQ}X+;p#Q?=9wcIP2Xn_2NG+5O9RG}*3b&$^t29{#A;t^OSz0ZI z_?L0D%5NwLyKK^z*i|~l!TbdZ8)1}vA~tc1TZ9P?K*w9zrVl{R(92TVs2&f!0_7uk z9F1gm9fde0Wle+tUudTY&7;eUbl+4S+tMQ}Buy%rX@w^kWo@g7uyDL@ksm8B7>qZn z6ck+w{30-A5;-J2S3J%EhqIpIEH!1?FJ&4jIC?@Wf^)iv#$>6)c+!nm$udANC&3l0 zNQ++ZCPO$vp~ghOkx_MI8eMK~BT3%`jr^9GH)5+TJ|+PAJc;CLLI9i~J^T&;f%n|C zn6dfRB`_F|C6vizIYBX%*gxsg`#u5aYugj)4+Q!2FJ|*&J@Y?Pi{#h*E`Oo@c)`vt z1pn>*`SaV4=7*1O&j&gGjhz1*r#rpZznkx#o-HruvxQdo^UL$Al@9wYwsQA;;Ag|9 zLgeO`TK%)iztY41LGuC*0?u?iKtHo-=dX|O=tDr7OKjKrYQT5~AR71Hs-6~D2qpWh z!2)z>QCttv9>q&9@kpeuswA@bBTz9;123R4WSH#-5w8sLy8;su(|!Ak&HJWevS_yR z1;%-dOB}^rG3>sVRpCRj*-*MBBck{9r<09Htz!7%laR^zy~W5HGqBK7Ao zC>tw!0Lo-QB*AtlJ-t_n6e>neB4S%fq?fic=o3AeKEuL>5EpYyqa{ib4qTij<-C}d^`CQZ9 zrJn38j(01s`VaNof8Z5AJ>#Fr>94fv=XpQ*#pPTt2yhla=K`+gt3eM3^jPhHvjMxg zb_iBFGN{9%2mMO`U5ngr+^vOE|Dx;hfNlys4MPP3k9%r1_Ug;D(s>S0t~8}f0VeTR zSO3n;t7_Jv$lAWqMFn=5`-1NYDrW+?k&(zugEc-uI$-e!C=F(`&d`wt!~k95e~Qw* zU_jj`CZBX>cDe_o63C$K;>guiNaW|8GilN9@fhrVW_ayJY(wM>N+}6WIp8O@lF8uI zm~D0xe&id8TFQy2*D7Q2jrpW*OhGZ?mG4QEwu8#sHK7wJj@>8oQ&F&v0=T`fx;~Q` zEE5&4l9R996z9d^|Jm=vZ5{hkf+qo1m!_ooq8mflK^f@b$ROy7ZKSfD zk%qryD4F&pEEu(p+366VwlR6m-$HP*JHTgvD_FiVmZ=MIib-Hlc114MW=F|@(Q=TX zwBb&GP`MJ;1SnDZ7_JD#AGzP(^(Y?evalX2>-T5Qmul|s^p_I3J>vdUZ$6n9wuLf50n+vVz^@$(8 z=C@m}=js>Q{$J>kz-+nI5B;e_>o-Pb6#TQaCU%;NgOe11Um5{x95`k$tL&%SOrO|@NOCyLx%Z?OdDv^%3=&zi` zsJ7EH0@Dr{)CKhCs&rQLMQ2ukor5YI>Of_FoG2J5M434{ZNzyZfRQB!@{|>my6BQ{ z7YXSxAf^7y87SnWEC5g-xT7$P2?M|Q$s>UMz*hjZ!tuwz_HmXcpw|{;5bRKx%0}Kr zOc2qO3d1ykq2h&zIwY?wC>tIMf-kNC388(uQ{!Y%??Ycs9=)6aNFCQJ@#Uy_sZ#zR zjQkoUrtbTDOnUx-E;C)u_1yo>pJ)d_G!OKJztfLDp06J~7#{s{wmi6XNALO1hTk6F zS{yyN8s6T>(d(l=^XKP!%}+n*vpruu;{!ju<1gpW>wY@uzdF{+U-N|(tNW`pC;kt# z>gU10e5qdySZ*cbN~iyat@6b4`C_x)+&Lart(}&^4S>CbJ-}XeA00e(74f7plqvp# zbE?>B^{m*~Czll{7#%Kpp1~eOZWtQ^=_^VY#%f^eP?Zc7m3#TIY`%GL990#*>cbe9 zRVnx*8X5Ld=1*qR+Cxl<5*@-?&4=K?QCIrk2m^ ztn!VO5f-?OaxyMSP`Az5#x&Y6Ax2J5)6yjcg5>Q9Cw$>pLvCCxrpXEcEei>t31G@+ z2a+a07o^b#%-1nT5*vh9J-T`pwloX`!o6SgvVIng%AFn2_YF zW#rvYalW6V^%r!Z237n~KKEH8rBN{wQc5E(e#k1o&m#b~`uR=s-~p<%B0drnk1WZA ze&hCqm?Ldb8gx$r+Id}&-s7UKo zE-v+c|K(yOhkuLj`pfw*m)pzrLLc&3ZZ6ky>iRa8Ui8QL4|ARR*S5b_{(3&JU2S*s z)ojD$V6Jlk+vT7gfZ! zG+!~hDnfuy`qv~NnJlNtSAvOx{u&57pj8j@{j*%GOPbOnNYS-fhB=_a2xR+?Agr=x z3TXzL7CDxs3w7D$``y+C9ha`wGPyfCgAud&i|R5|C_(al|Rn^>cN2XzpW4bT<)ICmydOD zPtO0=lbyccuhV;S{!jJ#-%~mN;e53`-~&G#_FL$AKOe-_ieHEP7F#{j->x@)44|zu ze)?ynzOvYI+FyUee5=O?>HL*e-;(b6$t@iKEMskPUEH%OGj^^K60kmB>4`jd5@8Gs z42{2NO1nN=X&6_|0ubt2wDc-={y7QkZx=PhNKLABt`6TNAsK0$ldg`SOD6VPL^5Wt zDz6DEe6t&h%4A$wGZ#ZjGESGE(ZGb0m@pKs z1OS@QB~N3e4OmTsMES_-ukKN1LqleWMnI*4|aHm3;;=AQiQiy^N(o;DJZ$nKas!FBLEzm%Lq=v z@dn6Q}pEijbWkkvTq0Nxw7~vKZD% zYQ%ElO1L8>jz*vte=M=M%p?#)0WkisBPI;W1!3@Hy7kMX4`i3=czS-*ahZy3;BTCu zNKvd8il~8TLRNeeV2UV)%1&YxKsg9RSw=}n1o0^HTDHfTECBsZ zfK?`)qdsjUH;Tbnh-$3g#_?QlKJIVQ-{OTX1l&>f%2kEzNlD4Oj(5R<8>aeSOs=aEZ1MJsLQg zJpZGN))q=s5OS2uF&FcVE>Kswa0D^%l;|(Eb0v?dKHjzE> zcaXlNZ^G)6$?O2U_HWtw9{djK=t)-YTo)@FR%DLU7atkt`3HybDh-RUFu7JSBv3t zxmd~hAL!kFy~D3b0rO-{0p_!nKJmNIR{|C~;jejs4g%^xpqe9n$&&%Ct>=0yFz5Nd z&H^xvKGH{kY;$Y2`;Gn^)EEM*BAiI!hU-Gt^eSKQMyp;_|7Z;Sg$%ACpzmn@nNUWP z7lmLhAwfmi3{SqINf{;I**)Bg)O;=Y7ns}2xkd&+f7jqW6X_%f^6Led@H^8%oD7~D zCjr8D)Ye=MshP1y(>0|e2?;Nn1f>;S+grU@3*&=R` z_V&43(+|S&!}sGK z&lVrN|NiXFU;JWt{NKJkfA+Dy^mqHdxBZWG;{Q@7{SO}KUH_-Y^Wy{ksLykq{@2QX zaeiCh0nqDudghPw*K&TfI#OQS{(1>OPF;uj_$gn-J0=8!4u5JMq2y|qZS{0tOMQJZ zXfr=lmr-xJ+OBpRJr3Az=bQOrsTbh8#cx2ZVZ{sdPb5!F!m~AQj*zs?j6C#=W9TvvuFLP9HQy zca1Co6L`-+d63l+P`;8^YC80F1`|bPT$==>Y|HC}Fc|hauVp*hupt1R1nl8jwk0H* zbmsSU8QjyRjiD#_Ms$}NlSw+Zi%}Q+B8>lGL*t8jt-3XsOT#OXX`*Orsfwu4DXFya ziJr)$pO{=kC8)7?01=V%B@;w$-Yx@j!V!ji)nqE7=b1M1rW0e#5rk=z1r(s7+LRSJ zuQg1_%UuS`gVtU$%11c}=I`uf9B}U!Q>6I_kUvu5kNpT4e96NjfFm7z3SdPLg@(~S zaKX$t6S9NelxB&t2UJ&x6w1MqF2@9hKiER55(;`NEAj%m93jHvR!`TbgY&ChQ`}c0 z?x?8xlhsOlzDphfR53b=*DLwj8~7#FRqbQumA@{m`r*O({}Z(xod5Zc-Wi@sz1O?a zieHlh{nz_{>VujmT>5oCZ6fd~4SfiZ=l}XxfHn+<9q$C_-2hDpw!7izXwc(;3}2^_ zLhAym(^Mn9kzc@8Idl>7$phRsp7#?))fV*11Lv;}`$ZmIyaFUSDYVx~ceX7lDDq<` zZ}KI#b>-^7hD|Ry9!!DXB9~+AbOgCUUZdN`Wnud=o1|kft|O>PKt~b-R>|%dMjF>* zzmS>OY`R{@RHA7?7s)8MSBewLn+RfJxnOMXWdj+6&!e0-zBpzNy>+Q~ORQZGJA)l`|<^gMuBt z;1*Xn95z7_J%?OP4CrZbe*{g(UbMk7>cDmchm4Uv(KPmgt1Mg5+JT?T&{5SL0#!6{vV=B42w0yOMJE`xemhIDc0D zKmWPD(XUtiaQ=b~{J78Kw`cRy^N;7xKAA0UKYTPiUvC$O$G7J=|Mk`J{OaJDzVfH{ z{pG}Y=6`g4p<{kpzsvb=wEeFS`se}vVtFoKzmfCTY1pL>!yV}JKw9x1EZ6$XpZ@!> zU##}^%YaJo$zQ!XqY1%$zR|9L_7CPOZU3teEv|;0z5>{Hv#yk1C+P;=x=-V*iWxf$ z?pqZi`oP72#C$$nd%*z|_f#(Y40yb}P&0eWFLK2sYwM1TQC!4K6czGM)9?ivYz1YXCD5U0j$4CGxNyC>O>q1l&}RL;d^?U+p0<);Euf$&8# z%C)4tXyCN-ib^k<;%UrK1N@>%fY5d8%-@70uc8PeqVxfeG!jxul7+0uaE&}1gpNJ{ zd-#zr(J7!OF5Mw5I7S$D(KqankUlXQar6&4Pt_wR`1z}Z^Q~g2@36VirE@olfJie= z!U7h%0d{do3qF)oY{sBBKQe%sGPcW$CqOA%BvN9KE|ihdvIF2gz2_B>s^2}C9p&2r z7Gfi(b%&G+iLUIm7<~PqzNH(ZwB`U1b(3Wit<5co{e6*?HVN3Ld(mL>B6!LFnlX!{ z@2pm{ljZVlv9?9t*A(+RBj3B#zcamGS5a#g$>{ciCVuHYK0A~c^J=UPZ z;n&1LXCJP8#um9H#i^9*k|F#>!MM<2BSd#oU$l*1B^c8E; z)h+6IAxU&nkGaxkng&iOnRnC?Mm|L$yYU5VidQcFcMM~)3_}KdXeK5Y)_B!MNrNnf z%}jvNhN~`tSdbHu1mu(jLm#~cSnLpl{xG0$DOvrI+Z6RKq47T)xNxBcAT5mmOn>C9 zFPZLzascZY|3yszl9PiiuRHOE>BRBRh=k*GD|pg?4IK>JNO7Zy#r~~h^xV@qas4I$>(76f0DS8jy?(#A zy>ZwtX8=0s?*o57*6RO*_urqri}TlRz~zHzj(6_eAC4dH=5Oek|Kf1B;4A!toqw$S zpK9xWF6V!FtS|b?`ET{}eK>y}|6g3G)$5)A`IWx)r{DA0>Gc0_b)c{PZRUDgP>20+ z{@UZ`2*6Cg7r-Guy#=7x|Lpv?K2yVg z_D$hM@SAAA2-e1hF!P0^&_OaG>i}I+L=!5@>_L{bM>5Th(ndbl)>QOJHi5SRb1HOV z{3y3CvKYEo1bZ5bN_mbL`J+3jP6X+3nXX%x*-(_EBWz4fENS4Bl6gm+VUaIR99^ZG zx@Map!cR#0Orn`hw&@$0g|_qBf$hlr4sH@n75>+PQ;>?3~4uXcO8Qn$g+7 z`I_2s_QD4pi4e!tkDHJOOc&eQ{?#{kw9+0gHedsF`TIG z%|NpLGzes2Ek9U8W&s3yaR{PjYeyKcthWwMvL+DFxDWxH*!Pvx!}l!$`k4SMhk+dc zeirz(4l&-po+fg?Zn|g9`Q!NW&s+chRNwf2^Lv}2od4OczB^y(UH|8w>HGe-Zs}9M zI`zLh)^mTo{+HYSPj!rMaTee8*FL>g?N>{^&!+=_a{m0ZFRTCcdU3VZcL6mCz|rd! zzr}%8{%q~bBZ^3W8?ElQ^Et2kX-Y6>`=6D+PyX}EfD*XXt^mD5ee^(Y1>97&$(`6I zaO2KOnN&{KV<)S8(K0BQRu{JS;x#^A_hC*Fc{=u7gnax5n4VDt4qe%q^Z1V^00_hu zqtcL32RH`AP;Apc5|WSDS zQF1~_Gc~n#ctHq_zHbb`r^w6$B)p(rgGqP{Ng1Y3knxcQjP7e6@=2PA#!0}W>_Xc4 z(0=I<&O1VEgYgUuP!Qc{#;c_9MniJ9UI<`Eo9l!Xjp zrIN=oeF-M|6gvQ$ON2!kQk5f}ahmbFC9w3t5RqG#5Iw%k+sB34p0X$;z?~a8T1w@! z6@7cfa?R1$;1Rs#Q+EO=b03PV;vV<1)7(EM0IKT;l3l~*%U1K!i)Z$3OqbD}T2AkMHiZm4A0w-}rv@@VpKF(jn zda+M@`s80Yd)cy;kJR6whXKM4nm8!dZh*G_wd=1*0bBpW5g*mKsgP0B@!DvE6USOz8FB2R}!)`(P6dBc)?Kl(EKKK*{a4IW|oKDyaW7FH!CJ*>1uO|x@D58EM(5fz7p=BZiK3(+($ly%CzPXU(>~z)*jS{=f zmUo>+AAEh?k+z(SgF+bsg~(7m#7>W>ph&$2b4ff=Ok6sf&7rbjWC>1|xDVJ}_i7ZD zBF+7(F6g+=r((1bpyWS10{8|M-QCj0ZP&^0oTkXsaLRzgnEHHu{CXLv8gB`ou4<{Ozue zG(X^EzdrWE7ysnC^_;0W|E*r@(+ond^l4Tg`8aFEfsmuT<(J zb#t(cn^9j1ZR1lE;Dz+iT_Y*LKF-92Op#soOD6%Q?HCZzIh2W!km+xq#Y1H$qLnk5 z_w!Y{nFfG@(xf z(WFlyro&|`H;oa(Rda>RPT2(??J>KF)W(A-%Yr=y#LkNDGws>*#t5rS@Bo)g>4+2p zAr9Cm$7qNq^kx)u$Ves5o75ACjaE8*E$vc<{B6lypAeem6c*A z5&HBO!9Bh*(>Q5}{QZB$7N5+NHEhuN2*FCE>ES79X;Wo?7csiEyNkVyWUu`rfY)t? za?>p{>_gS&PyShK`PZv{Z~d4`{>kj@gZGEa(_ai1AIbU4yFSso{+l~@hvjFR#mVs# z`T5=A^4`%xU;bOli_b502=MZ3rBnL5)%kp-XZf7?f2Ovt_x@S=>k)vy^tYVp#J@E7 zCw%$rueJj8znnjx``2baJLYo!g9x;RK5V?g*INKveOEvy>hwO~pb0cb{@4W2#(+4k zu2%Y7WGibWh+E@Tx&@C49Y#rL=>#|NvX##w4G!@BlMEbhr8Q&GjD+7S7Oe>N@h>(n zJON+`pj+v6Mok7nidPQEU>p!Fe|j}I(iBBxL8(qDo>*mw9;k@1NB}G^Q|OOeI95T?)4krLj-{jT747 z7wCp4$(vBuFMJaoG7u{wr2Lpbs%0sk>W$+P?KH??>+J|x$rs|>o=T_nG#$N-N=sPL zS+0$t4J((0No#Eb#QcL1`W8%-l%fe)A}gxwC?VG+3XF8XMTmYAeI@~paE9DF(~T7@ z{@_GgNwGdDCl4uOz@>f?b%~=_0ES|U$0LB_1HqNP7O0ehldLrC$Vg-xKY&0(z2wbt z7SaslUDqkvRSZmj$cefQ$+llQ%wv2Kl8(})E*m3g@DYy?axXXBUg`<)Z1#r!{_f>U ze!0?KrwPFR{c!$6%Bzb`_xpK&IR78b-um&6-BNM>7Z<-6-jMTW^}jp&;e2*i4f!{h zivu}-zWBE~J)Up1IzKqL8qRgHPs@3|(6871IJD1)d^U3a@`YP{z)^#XUJ~G-pZ4f= z#NS{2^ZtK43c!(XG-;@nzrO6JMKLnv_T>E45Lx~+4d9zO&FAWQfmn93S#yJ(J~%9b zNpMGs#_i4lQm}BO6G~^OoK|75Wu6nW@OzLne;PqrG&pnyYi1;R?NO6}ttJ6_{s$~O zQp~P#{!9uqQP95&d3&3TeE*l6O7kmX2uCk^l-ArqH-k=I`UOiHBTl*mdVoNLgxf)4 zr}MfHpi@9LfpOrbP&jPF;!^xRDP_$q6g~2r4&b zdb&tM1U{pbSFW>hwgl}b=u0Qz7;5SzWlPO!3N%C{5z3b^;Y&@0gJ z)kN;szw;l$>kEkrKbrmU{Ct@G)0tQPr>B?mJ3rU!e)nhdV;%b2+}#b&KV2`jyC-@y zuOIq3;+4MV`pU0<3qUJ;y@xknGXda}eoMLROHCBy>N)JEV|)w$un!JjlK^!j`RxOB z3BT^=xv@47__a)L`!Cm8#(VpJH)y(tzqIq$Cx7_Lj~u?*r2M9xzf=jY_B}`L^4bKT zikGn~pldedtFsuFZK|!Jvm+IqZ!Db^KK-$(r=zpR2WOZraYld-0tF4{0r-xw>^Dru zS%MdSmB14Sr5OxzJaFul2Y@CM8pwjK;(!GXG2|UpEQ@34;Tk|+6Cc#bjlas@6n_;O z_}U=m%uSL;7_`*swUEGTxQTFabp$wC&N}s>L+{ZRl?pDRiP(Y~KK5gn0>ZnhHEQNbwZv+ciaO|7tDTLy(y%$-u zMP`RgMt_Ba-n~zNXvfq0R=ka;_?toj#u)E5N6Ng! z$uEJt1;DpV9l(>+9}@t^EA#|tbmQcKw*bH)K7P zpW&v;89pqFlwjpg_UCf)#5n(_@BL&rJByY7Z1&FVNY0-J>+64XH7tI;UL5L6f5*3G z!<-|K8#JXe~#+J)1w@t`-OS*w1EpG9NCU>f8SEZ#z8#;Ca4I`}4m4Qt$U) z@|8b1|J_D1G$HUoKB>_!V(N1Ma`5H+^%y{gvHI7?{?u9I{Fy7`{DEtwJ?wNSK+|%$ zPt7t^oV9*s@Q@TeOpT@Y0Th--U4eWLBOM{;y_JjZ89A9@9xBYgsO1i#Re|!zuET$x zkqAJHU7D+yVuwYgGzWLDNGK2#lBc&NR9JO8%Anw)DCs^39jgz~=!=O)){aDUS+iIc z2Dy{cDd87NDa9ZH=X~Nxn}ArsdJT;HP1iKhD8$?pEFR^AqN#j9+to7C)&?X2pWqoy zP#tT^}oU>$6_YB!#GjeF^qQgJjkiM z)p9|BZa)7e`qD1clPo?s`gCANBYRxGBLQDkaIY)XBrdc~WtcO|n$(J_YOJ{l2_0_w zg1IfKq9u~KSgou;-EH6lf zUeW}MbE2iJ)gYBgLn=uJD9~RJbC6F!#lS6J#MC)?N=e{qC!cVa0XpFNE4xgmJR!wL z=38FT@y2Sk(mAiUpS@hs-_o+{>{S=nF|QtSQ=Q-F{NvCcEC0WkIRDGbcZMJ8D}SGT z_F#5)`~CUi{Fb)tpA6s8`~Ix_?fmZ^F68`|PtSIXvz?A-X!XBc$@woX?EJUd6o_s9 zwN~bu1Z*~QIe-7uuXe|^!skOi@vgtzIM4Q*^S=~a704^}j@7ajJo8`juD@b6guy2P zYQpqBs`KsyAf*R9 z2Lb7LOZ~ntF(3aS2FJk%!$=FxED?Xt?jWBpuwE--fDlrD$oHT`p01cM$0#Llcnm63 z5ChhT@5-0(#?y6jp_)!K5kgm_zwBDH#9ta@_KO086n_pClOYW*lYmCT4&L!hWSJr8 zg4Y5P+KW;FIvFEvklMDyd+3`O6mrV`oAg^aH>lH5^kq!tO=9^`sZE~<8&2t}^5R2I zpPncK*##y6qXZ?>u6&@&NGumme|CSg$`&nv{V z)sLDiS>b^71)UPhM}XAtn~mx`s7tBszA^@cL?d-k4rA!-NoBF1rL@w>@?QvzOm@&3 zw+iprV#5Yx#DpYeq-CfuZQ_|U@dvD8(yt=01MrrPd25mP$C6LsU)%8eGOq4@Uoj)> z!*S)0^FKZPksQ6Y{T0s6W`5?6^S>kK|M4dehT|XHogc0@^WUy_^8-2mhjRWG>!Zc; z{?YulobOJ&tAh)@6`*(iIsGqBe{iW^@8i9HCIoWGI^QRhez8Xjf4wN^)%q~kV*vR* zzV$B$Xy@+}|MHJ(+2Ysz@RcHucl^`o$LfD}rOyd#65$U5>Zbzv89+Tc(4YP2Slls1 z38Ps8bE@}L0J4(>PdfKx^UV|jT%^ea4F~=-0gzsCnqS#E@)CCZ-i!87^@SF?R+ z5NTpXgj5lkuW&7T%XtyK4Y?T!ih=cY8n{N!p1dJdE~WQKN<>x$#KADq1z)Lj zJd%aHU=e3aOvwApD7T>E;szxv(CaioYZ5Nd6Ty^x4JUYDr*ft;lL;AP5|NoN2?hnc z(`CALNn37|GxG1T+wP`2c^&D3#9my{wXJm%WNnKOT0r4s$pb0qC=5CECuo#4NwZ4L z8~o8n5c8smK-@MFNV#`py8D7yc%v-Q^O$6C*pJ^RYxfQU<@g~W{Z4Aw7p(4Up(Es& z(gn@2C+UErXk3w7XaKvUZIZ46k%tFoT_IqRqt808EIgJ^tX#oODH-H39>=V)-mzgO zc=;D(zj<&lyFCnlrsVI-$9|=P{XQN6)IIJEY%70G`s-l71J3`?<@_Jw{QvQ6_Vnpb zhKol!?3d1eE$4stPjE!=>v(b~Q=R5tp@0maLbEF^b z9kkuQT3jyHI=H7_>shR|1)ycE-VEF@FIa9Cn_<}KM}M!j_)^7>$P(Tv_HATH%C_$o*O1Rz(-I(3F zqccc$($ctrMFXdTOq(%zS~~t#6L}j3obj)pLmM z$`SX_6WmgWT!fTt^5z2??LU+U4QvFgX0H_aDe+^$ej2%iln=xrC zN&)22&7)0rEz3sG;59q~NYvcCo zn|yQrvk#-5aQx-`4N2$EbN_c|@6O)%=wtEy#SG_vdvkv{TYs*V|E>A)lc&Ss?s%B5 zo-LNo4(GSD`oEO(KT&+BrTuQDEqNXO+b-Dd*9&>_(pQIi0dBJ$F0})&IouBVT#x+y zRwwv1Inc*`R6+dGuXYCXdsFiN*u%&Efin@1XdO7zO%5LkaDE|A$-AJ?@Lxg)Z6)|C zK)jT2ATLT6v#==gwQJ!jwq7o7wIeThI%|ze^kZ%+ZJmh*fxH3A1M?O{!ohjUlE6F}Dy)C zcrSB2NM36y`Y^Ron^MY0-jKi5mL{M1_J9YElvWWongAT;5dhm=deD(X0n)XY_F}To zG&-fL(tu$Xj+4I@Oe{+k*9sq8$dE)K&>wjaQL09(yw5-h#lnmofJUqQs|x6UpdSR% zn`i%U2(YW>CQLp;VW*^M{{PfiLhdx@q-8|J6o5`000a>i@ZR16Fd*2U_&%?ba)~Wi9bnM{B(mpttb#WdHnX zt@8nXyO>VH?IE+LHhj>3`UWC}b&M zXr`e>MGOYXA5@}4vq*(RKfwd2VowT!+;H>|Tr9<<%D}ICK^BT%5G-4GliWai4FrP> zYw(t+@^BwUWerV&koO?Phza7j?>!%+&9)R0REQ{pgQn+ea?3)~ic>OrI^+{9y2(%T zfXhy|&K@Utns2^d<|ro_5U$YEL_XSIAa%`(x3*rF(@{6UH`+gH7*iNj)siApwz!jw zh>Xh>Nz)jv3;icn>0}_)h5yQ$rqbXnC#99*R1{^V&P^CaOnpF*#l2)m!WsbW-c|+2 z0OEUXF))QV+vuAq8k{`CQv5`T1tHEspFZ~^0Q2RIaN7}7 zsMt_FLAfZ0?DvpBW3!T^aN~20;K|eVi zPRj6#A7A>DL(S$(3#XTB`mDos+<(1sz=2x1Y5DyXPyRK5@D~NQd;|z_6==p0U~C~9 zGC1JGHL%dy-OxK6YHNV0PQXf^P9Kv1@hi_9frAZ<3#{^EGN9cG5$TIYvrjJ9v!9%v zZvXC_?}A=kYMbrJVzqpD_x91*qvz-E{pJ7u*}Xsei@VFWzpwWyC4+MCbpsEE+6qA# z&Y4Mozj>tOI4IFk18P`Z2PPCYBhHloj5MJtP{^1FgzP{@oqE6n5aKM) z*~|y+*SNyh47ko`v#}XePn+o;WbUr~k=Hfl$Dq%BHfA54@PwO=Oyui&5)Uh`wi zACOo6>HJyw&t{|ZzgRyQ*7rXi)>`==9$(IfbpFpT9xt{hIva3tv{-3Px?3JD&YwNk z@9*BxBY^FEh2z%hpQ-Xn8{D(QtKm$0_d4;oK3@GZ2T*@t zvC6Z5J)F42`1$sy z&z~`gxzO3gPmgXbKi8WI7b-R)wp8nb+qZstak;tuv%h-w-rxQ|Pw)Kce{-^U`}=z2 zLiI8dv9Td#Ofu-J9Dty{!g6e}A$IgOR)QITu#;OvS9YKtsw@JK1trpy5ol=HfoO7} zLyF22lAj=KuBp?{k8|9K_ zWD4BMIgy#RRT(-Ql14cpcf2NHR%S21=P|sONt)Vl+tdAkztfG4CK1&&ISo?`Va-U# zy)K6mxF|T~S9?l39Cda;*<=Vlnv@JC=;1KvuQ#LkIym~sLKpJGK7(vbA{Bv$4v~cl zJF-0}!>B@V9f9nE?`@|K#nXvE*?<7a6n{LwSH5JW5bE%9twTyS273BW7#QCGz!vxd zCjuo1)N$6oaE98Bz;c|>K@q9q0!D8~AN9Z>3Eo{fiHa6@@nS>e3x+I&Fkxx+m@sIf zqDL8kkX?V|(fhIkb^4Be6X4&^X76eU{HvEO|7FR0l@oxvhrO-wy#K=hU3dOJ8fFvc zKWi(0od4x_x5M4Domc+fdG=^H-`*ZB4)wJ^{S5G2r~dD02S7{s;e35IpWV4TTRc3I zPu4m1ohA!<=C7Ng#r>rpb8)~=bAtJSUi;heiGbZ!i*>aNea>I6`so~j+9jii0*}9x z0ItUX_G`8JcR@5~mLpO#Rv!YOIfOp>D;av5kjcc=ph*Y6DWITEy*kNbfDrSC18_rC zi*+6$goFblRHKJJCIJE#ZxTc&kl`Z6(bF+#;Czt?0lXEY^NF)dP1}F+^z`cg{QS}G zR|qOad`9}E-$wC{^MUg|H03H z`uxtH{MWaJ2k#s)YD8cX055S)0>V#6N2Swa47QP`v*>0xO?lX^0p9Njz)}N*`7J{< zNa8{;47r&V0+6rR(`W+E6e6woFcWX7;#B16b(L)BtR4)83Z?XjE&ND~1nl#DVrbVA(M zRY0MqUd)<0Tu(|pMMH!<%>X-2ePDZTsIDHYbmV zqla3}A3e~@^>ooybPfBxRHJ0RbDqw&RiZ{4NpJt_-Q`q3V5VPg@Fxd4BnU?P)^3O`X1e^6cYed#1d>su*nc$FB7@4nfO+7Bq9=&Br zZkg23$y2r(53!7xh$AB;R?{Aw?Sv&d3PZi5rWBQV;9VHW+*~ZqI-~`II{Be6ct@G! zQ;6x6-j~_QC_a;LL4j;_8%TYH;~tn~)DWUg0B=i>*$b*WDXaTvq{v$xCu@^Xwu`WA zEahQVqqN#I)nZ+|LRZ`??8*-~NCG(87|>>hvimy9amVh^K7UB|s=m`lS+a^HFB~cD z2U!F^Mo>Pwk>E<$1xoo^Ujd~4Xoa0fosZUo>}7UnW1=l`rEhz2l$A)7CRkr9p9C@{ zgl$9g1mLEcHSEKzg)evhxc=Gf*N^^oe(}cJ!@bk<;d43vyPNo`#lhw6 z`Q}8={4cfbKYMF-^z?MNxGNv?^hh6H(20KWK7YPj+_^f?-M`Qa?MwZlk6!%K5qy3A zSKIK5;Y97=N|OLyCgBW$Uf7#2w;Qck^(FxAhH0omyLH(I6qSDijf3O|fbek++9Hs@ z;?N+U6qFdP_BGoOf#(xC3otv-FAlIkc891z3wB_%Su3u*2+9F~p*drUSNEn@hZT

4eek2DdubxZG2 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 AXaE2J literal 0 HcmV?d00001 diff --git a/apps/SuperPixelGui/superpi.png b/apps/SuperPixelGui/superpi.png new file mode 100644 index 0000000000000000000000000000000000000000..0ba3d67e53117a99c33556038eebaedfb707dd74 GIT binary patch literal 132960 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

2O{b%~? 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%0Ao2 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 Uw}5UZz{_80;pMNqic+zF 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 literal 0 HcmV?d00001 diff --git a/apps/SuperPixelGui/superpixelgui.qrc b/apps/SuperPixelGui/superpixelgui.qrc new file mode 100644 index 0000000..794a47b --- /dev/null +++ b/apps/SuperPixelGui/superpixelgui.qrc @@ -0,0 +1,5 @@ + + + superpi.png + + diff --git a/apps/SuperPixelGui/utils.cpp b/apps/SuperPixelGui/utils.cpp new file mode 100644 index 0000000..2bcd2cb --- /dev/null +++ b/apps/SuperPixelGui/utils.cpp @@ -0,0 +1,206 @@ +#include "utils.h" +#include +/*cv::Mat utils::qImage2Mat(const QImage & src){ + cv::Mat tmp(src.height(),src.width(),CV_8UC3,(uchar*)src.bits(),src.bytesPerLine()); + cv::Mat result; + cv::cvtColor(tmp, result,CV_RGB2BGR); + return result; +}*/ +//Copied from https://github.com/stereomatchingkiss/blogCodes2/blob/master/libs/openCVToQt.cpp +#include +#include + +#include + + +namespace { + + inline QImage mat_to_qimage_ref_policy(cv::Mat &mat, QImage::Format format) { + return QImage(mat.data, mat.cols, mat.rows, mat.step, format); + } + + inline QImage mat_to_qimage_cpy_policy(cv::Mat const &mat, QImage::Format format) { + return QImage(mat.data, mat.cols, mat.rows, mat.step, format).copy(); + } + +/** +* @brief copy QImage into cv::Mat +*/ + struct qimage_to_mat_cpy_policy { + static cv::Mat start(QImage const &img, int format) { + return cv::Mat(img.height(), img.width(), format, const_cast(img.bits()), img.bytesPerLine()).clone(); + } + }; + +/** +* @brief make Qimage and cv::Mat share the same buffer, the resource +* of the cv::Mat must not deleted before the QImage finish +* the jobs. +*/ + struct qimage_to_mat_ref_policy { + static cv::Mat start(QImage &img, int format) { + return cv::Mat(img.height(), img.width(), format, img.bits(), img.bytesPerLine()); + } + }; + +/** +* @brief generic class for reducing duplicate codes +*/ + template + struct qimage_to_mat { + template + static cv::Mat run(Image &&img, bool swap); + }; + +/** +*@brief transform QImage to cv::Mat +*@param img : input image +*@param swap : true : swap RGB to BGR; false, do nothing +*/ + template + template + cv::Mat qimage_to_mat::run(Image &&img, bool swap) { + if (img.isNull()) { + return cv::Mat(); + } + + switch (img.format()) { + case QImage::Format_RGB888: { + cv::Mat result = Policy::start(img, CV_8UC3); + if (swap) { + cv::cvtColor(result, result, CV_RGB2BGR); + } + return result; + } + case QImage::Format_Indexed8: { + return Policy::start(img, CV_8U); + } + case QImage::Format_RGB32: + case QImage::Format_ARGB32: + case QImage::Format_ARGB32_Premultiplied: { + return Policy::start(img, CV_8UC4); + } + default: + break; + } + + return cv::Mat(); + } + +/** +*@brief copy cv::Mat into QImage +* +*@param mat : input mat +*@param swap : true : swap RGB to BGR; false, do nothing +*/ + QImage mat_to_qimage_cpy(cv::Mat const &mat, bool swap) { + if (!mat.empty()) { + switch (mat.type()) { + + case CV_8UC3 : { + if (swap) { + return mat_to_qimage_cpy_policy(mat, QImage::Format_RGB888).rgbSwapped(); + } else { + return mat_to_qimage_cpy_policy(mat, QImage::Format_RGB888); + } + } + + case CV_8U : { + return mat_to_qimage_cpy_policy(mat, QImage::Format_Indexed8); + } + + case CV_8UC4 : { + return mat_to_qimage_cpy_policy(mat, QImage::Format_ARGB32); + } + + } + } + + return QImage(); + } + +/** +*@brief make Qimage and cv::Mat share the same buffer, the resource +* of the cv::Mat must not deleted before the QImage finish +* the jobs. +* +*@param mat : input mat +*@param swap : true : swap RGB to BGR; false, do nothing +*/ + QImage mat_to_qimage_ref(cv::Mat &mat, bool swap) { + if (!mat.empty()) { + switch (mat.type()) { + + case CV_8UC3 : { + if (swap) { + cv::cvtColor(mat, mat, CV_BGR2RGB); + } + + return mat_to_qimage_ref_policy(mat, QImage::Format_RGB888); + } + + case CV_8U : { + return mat_to_qimage_ref_policy(mat, QImage::Format_Indexed8); + } + + case CV_8UC4 : { + return mat_to_qimage_ref_policy(mat, QImage::Format_ARGB32); + } + + } + } + + return QImage(); + } + +/** +*@brief transform QImage to cv::Mat by copy QImage to cv::Mat +*@param img : input image +*@param swap : true : swap RGB to BGR; false, do nothing +*/ + cv::Mat qimage_to_mat_cpy(QImage const &img, bool swap) { + return qimage_to_mat::run(img, swap); + } + +/** +*@brief transform QImage to cv::Mat by sharing the buffer +*@param img : input image +*@param swap : true : swap RGB to BGR; false, do nothing +*/ + cv::Mat qimage_to_mat_ref(QImage &img, bool swap) { + return qimage_to_mat::run(img, swap); + } +} + +cv::Mat utils::qImage2Mat(const QImage &img) { + return qimage_to_mat_cpy(img, true); +} + +QImage utils::mat2QImage(const cv::Mat &src) { + return mat_to_qimage_cpy(src, true); +} + +/* +cv::Mat utils::qImage2Mat(const QImage &img) +{ + return cv::Mat(img.height(), img.width(), CV_8UC3, + const_cast(img.bits()), + img.bytesPerLine()).clone(); +} + +QImage utils::mat2QImage(const cv::Mat & src){ + //cv::Mat temp; + //cv::cvtColor(src, temp,CV_BGR2RGB); + QImage dest((const uchar *) src.data, src.cols, src.rows, src.step, QImage::Format_RGB888); + dest.bits(); + return dest.rgbSwapped(); +} +*/ +cv::Mat utils::makeLabIfNecessary(const cv::Mat &m) { + cv::Mat res; + if (m.type() == CV_8UC3) { + cv::cvtColor(m, res, CV_BGR2Lab); + } else + res = m; + return res; +} diff --git a/apps/SuperPixelGui/utils.h b/apps/SuperPixelGui/utils.h new file mode 100644 index 0000000..c300e88 --- /dev/null +++ b/apps/SuperPixelGui/utils.h @@ -0,0 +1,14 @@ +#ifndef UTILS_H +#define UTILS_H + +#include +#include + +namespace utils { + cv::Mat qImage2Mat(const QImage &img); + + QImage mat2QImage(const cv::Mat &m); + + cv::Mat makeLabIfNecessary(const cv::Mat &m); +} +#endif // UTILS_H diff --git a/cmake_uninstall.cmake.in b/cmake_uninstall.cmake.in new file mode 100644 index 0000000..491624d --- /dev/null +++ b/cmake_uninstall.cmake.in @@ -0,0 +1,22 @@ +#See http://www.cmake.org/Wiki/CMake_FAQ#Can_I_do_.22make_uninstall.22_with_CMake.3F +if(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") + message(FATAL_ERROR "Cannot find install manifest: @CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") +endif(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") + +file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files) +string(REGEX REPLACE "\n" ";" files "${files}") +foreach(file ${files}) + message(STATUS "Uninstalling $ENV{DESTDIR}${file}") + if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") + exec_program( + "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" + OUTPUT_VARIABLE rm_out + RETURN_VALUE rm_retval + ) + if(NOT "${rm_retval}" STREQUAL 0) + message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}") + endif(NOT "${rm_retval}" STREQUAL 0) + else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") + message(STATUS "File $ENV{DESTDIR}${file} does not exist.") + endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") +endforeach(file) diff --git a/lib/3rd/ThreadPool.h b/lib/3rd/ThreadPool.h new file mode 100644 index 0000000..a0c6d0a --- /dev/null +++ b/lib/3rd/ThreadPool.h @@ -0,0 +1,102 @@ +#ifndef THREAD_POOL_H +#define THREAD_POOL_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//https://github.com/progschj/ThreadPool +class ThreadPool { + public: + ThreadPool(size_t); + template + auto enqueue(F&& f, Args&&... args) + -> std::future::type>; + ~ThreadPool(); + size_t threadcount(){return workers.size();} + private: + // need to keep track of threads so we can join them + std::vector< std::thread > workers; + // the task queue + std::queue< std::function > tasks; + + // synchronization + std::mutex queue_mutex; + std::condition_variable condition; + bool stop; +}; + +// the constructor just launches some amount of workers + inline ThreadPool::ThreadPool(size_t threads) +: stop(false) +{ + for(size_t i = 0;i task; + + { + std::unique_lock lock(this->queue_mutex); + this->condition.wait(lock, + [this]{ return this->stop || !this->tasks.empty(); }); + if(this->stop && this->tasks.empty()) + return; + task = std::move(this->tasks.front()); + this->tasks.pop(); + } + + task(); + } + } + ); +} + +// add new work item to the pool + template +auto ThreadPool::enqueue(F&& f, Args&&... args) + -> std::future::type> +{ + using return_type = typename std::result_of::type; + + auto task = std::make_shared< std::packaged_task >( + std::bind(std::forward(f), std::forward(args)...) + ); + + std::future res = task->get_future(); + { + std::unique_lock lock(queue_mutex); + + // don't allow enqueueing after stopping the pool + if(stop) + throw std::runtime_error("enqueue on stopped ThreadPool"); + + tasks.emplace([task](){ (*task)(); }); + } + condition.notify_one(); + return res; +} + +// the destructor joins all threads +inline ThreadPool::~ThreadPool() +{ + { + std::unique_lock lock(queue_mutex); + stop = true; + } + condition.notify_all(); + for(std::thread &worker: workers) + worker.join(); +} + +typedef std::shared_ptr ThreadPoolP; + +#endif diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt new file mode 100644 index 0000000..634bd7b --- /dev/null +++ b/lib/CMakeLists.txt @@ -0,0 +1,25 @@ +project(RSlic) + + +find_package( OpenCV REQUIRED ) +set(CMAKE_INCLUDE_CURRENT_DIR ON) + +option(PARALLEL "Use Threads" OFF) # Solange Ergebnisse sich unterscheiden pro Durchgang +IF(${PARALLEL}) + add_definitions( -DPARALLEL) +ENDIF() + +set(SOURCE_FILES + Pixel/RSlic2.cpp Pixel/ClusterSet.cpp Pixel/RSlic2Draw.cpp Pixel/RSlic2Util.cpp + Voxel/RSlic3.cpp Voxel/ClusterSet.cpp Voxel/RSlic3Utils.cpp + ) +add_library(rslic STATIC ${SOURCE_FILES}) + +target_link_libraries(rslic ${OpenCV_LIBS}) + +install(TARGETS rslic DESTINATION lib/rslic EXPORT rslic-target) +install(DIRECTORY . DESTINATION include/RSlic + FILES_MATCHING PATTERN "*.h") +install(EXPORT rslic-target DESTINATION lib/rslic) +install(FILES rslic-config.cmake DESTINATION lib/rslic) +# another package example https://github.com/forexample/package-example diff --git a/lib/Pixel/ClusterSet.cpp b/lib/Pixel/ClusterSet.cpp new file mode 100644 index 0000000..1bf5a29 --- /dev/null +++ b/lib/Pixel/ClusterSet.cpp @@ -0,0 +1,109 @@ +#include "clusterset.h" +#include "../priv/Useful.h" + +using namespace RSlic::Pixel; +using RSlic::priv::aSize; + +RSlic::Pixel::ClusterSet::ClusterSet(cv::Mat_ clusters, int clusterCount) + : data{clusters, std::vector(), clusterCount, false} { +} + +Mat_ RSlic::Pixel::ClusterSet::getClusterLabel() const { + return data.clusterLabel; +} + +const vector &RSlic::Pixel::ClusterSet::getCenters() const { + if (!data.centers_calculated) { + refindCenters(); + } + return data.centers; +} + +int RSlic::Pixel::ClusterSet::clusterCount() const noexcept { + return data._clusterCount; +} + +namespace { + inline void setClusterAdjacent(Mat &m, int p1, int p2) { + m.at(p1, p2) = 1; + m.at(p2, p1) = 1; + } +} + +const cv::Mat RSlic::Pixel::ClusterSet::adjacentMatrix() const { + if (!data.adj_calculated) { + refindAdjacent(); + } + return data.adjMatrix; +} + +void RSlic::Pixel::ClusterSet::refindAdjacent() const { + std::lock_guard guard(adjMutex); + if (data.adj_calculated) return; + int size = clusterCount(); + Mat res = Mat::eye(size, size, CV_8UC1); + auto clusterMat = getClusterLabel(); + int w = clusterMat.cols; + int h = clusterMat.rows; + static const int xNeighbour[] = {1, 0, 1}; + static const int yNeighbour[aSize(xNeighbour)] = {0, 1, 1}; + for (int x = 0; x < w - 1; x++) { + for (int y = 0; y < h - 1; y++) { + ClusterInt currentCluster = clusterMat.at(y, x); + for (int i = 0; i < aSize(xNeighbour); i++) { + ClusterInt otherCluster = clusterMat.at(y + yNeighbour[i], x + xNeighbour[i]); + if (currentCluster != otherCluster) { + setClusterAdjacent(res, currentCluster, otherCluster); + } + } + } + } + data.adjMatrix = res; +} + +inline tuple operator+(const tuple &a, const tuple &b) { + return make_tuple(std::get<0>(a) + std::get<0>(b), std::get<1>(a) + std::get<1>(b)); +} + +void RSlic::Pixel::ClusterSet::refindCenters() const { + std::lock_guard guard(centerMutex); + if (data.centers_calculated) return; + + vector centersCounts(data._clusterCount, 0); + vector> centerCoord(data._clusterCount, make_tuple(0l, 0l));//Da Werte länger als sizeof(int) sein kann + + + for (int x = 0; x < data.clusterLabel.cols; x++) { + for (int y = 0; y < data.clusterLabel.rows; y++) { + ClusterInt idx = data.clusterLabel.at(y, x); + if (idx < 0) continue; + centersCounts[idx]++; + centerCoord[idx] = centerCoord[idx] + make_tuple(static_cast(x), static_cast(y)); + } + } + + + for (int i = 0; i < data._clusterCount; i++) { + auto counts = centersCounts[i]; + if (counts == 0) { + data.centers.emplace_back(0, 0); + continue; + } + data.centers.emplace_back(std::get<0>(centerCoord[i]) * 1.0 / counts, std::get<1>(centerCoord[i]) * 1.0 / counts); + } + data.centers_calculated = true; +} + +Mat RSlic::Pixel::ClusterSet::maskOfCluster(ClusterInt idx) const { + int h = data.clusterLabel.rows; + int w = data.clusterLabel.cols; + cv::Mat res = cv::Mat::zeros(h, w, CV_8U); + for (int x = 0; x < w; x++) { + for (int y = 0; y < h; y++) { + if (data.clusterLabel.at(y, x) == idx) + res.at(y, x) = 1; + } + } + return res; +} + diff --git a/lib/Pixel/ClusterSet.h b/lib/Pixel/ClusterSet.h new file mode 100644 index 0000000..6b68963 --- /dev/null +++ b/lib/Pixel/ClusterSet.h @@ -0,0 +1,130 @@ +#ifndef CLUSTERSET2_H +#define CLUSTERSET2_H +#include +#include + +using namespace std; +using namespace cv; + +namespace RSlic{ +namespace Pixel{ +using ClusterInt = int16_t; + +/** +* @brief Representing cluster (also called "Superpixel") with some functionality +*/ + class ClusterSet { + public: + /** + * Constructor for an empty ClusterSet + */ + ClusterSet() : data{cv::Mat(), std::vector(), 0, true, false, cv::Mat()} { + } + + ClusterSet(const ClusterSet &other) : data(other.data) { + } + + ClusterSet(ClusterSet &&other) : data(std::move(other.data)) { + } + + RSlic::Pixel::ClusterSet &operator=(ClusterSet &&other) { + data = std::move(other.data); + return *this; + } + + RSlic::Pixel::ClusterSet &operator=(const ClusterSet &other) { + data = other.data; + return *this; + } + + /** + * Initialize with given centers and cluster-label mat + * @param _centers List with the central points of the clusters + * @param _clusters Mat where _clusters[i,j]=x means that the point i,j belongs to the cluster number x + */ + template, typename std::decay::type>::value + >::type> + ClusterSet(T &&_centers, cv::Mat_ _clusters) + : data{_clusters, std::forward(_centers), 0, true, false, cv::Mat()} { + data._clusterCount = _centers.size(); + } + + /** + * Initialize with given clusters and the cluster's amount. + * The central points will be calculating if necessary. + * @param clusters Mat where clusters[i,j]=x means that the point i,j belongs to the cluster number x + * @param clusterCount the amount of the clusters + * @see getCenters() + */ + ClusterSet(cv::Mat_ clusters, int clusterCount); + + /** + * Returns a mask of the cluster with the number idx. + * @param idx Clusters index + * @return binary mask. + */ + Mat maskOfCluster(ClusterInt idx) const; + + /** + * Returns a Mat m where where m[x,y]=i means that the point x,y belongs to the cluster with the number i + * @return Mat with the cluster label + */ + Mat_ getClusterLabel() const; + + /** + * Returns the central points of the clusters. + * The index indicates the cluster number the central point belongs to. + * This is a lazy-evaluation. + * @return List of central points + */ + const vector &getCenters() const; + + /** + * Returns the amount of clusters. + * @return amount of clusters + */ + int clusterCount() const noexcept; + + /** + * Returns the index of the cluster the point x,y belongs to. + * @param y y-coordinate + * @param x x-coordinate + * @return cluster index + */ + inline ClusterInt at(int y, int x) const { + return data.clusterLabel.at(y, x); + } + + /** + * Returns the adjacent matrix m (type CV_8UC1). + * If m[x,y] == 1 then the cluster with number x + * and the cluster with number y are neighbour. + * It is always m[x,x] == 1 and if m[x,y]==1 + * it means that m[y,x] == 1. + * @return adjacent matrix. + */ + const cv::Mat adjacentMatrix() const; + + private: + struct nonspecial { //for default Copy & Move Construcors + nonspecial(nonspecial &&other) = default; + nonspecial(const nonspecial &other) = default; + nonspecial& operator=(const nonspecial & other) = default; + nonspecial& operator=(nonspecial && other) = default; + + Mat_ clusterLabel; + + mutable vector centers; + int _clusterCount; + mutable bool centers_calculated, adj_calculated; + mutable Mat_ adjMatrix; + } data; + mutable std::mutex centerMutex, adjMutex; + + void refindCenters() const; //computes central points -> data.centers + void refindAdjacent() const; //computes adjacent matrix -> data.adjMatrix + }; +} +} +#endif // CLUSTERSET_H diff --git a/lib/Pixel/RSlic2.cpp b/lib/Pixel/RSlic2.cpp new file mode 100644 index 0000000..fd0a83c --- /dev/null +++ b/lib/Pixel/RSlic2.cpp @@ -0,0 +1,130 @@ +#include "RSlic2.h" + +#include <3rd/ThreadPool.h> +#include +#include +#include +#include + +#include "RSlic2_impl.h" + +#ifndef u_long +#define u_long unsigned long +#endif +#ifndef uint +#define uint unsigned int +#endif + +using RSlic::priv::aSize; +using namespace RSlic; + +Slic2P RSlic::Pixel::Slic2::initialize(const Mat &img, const Mat &grad, int step, int stiffness, ThreadPoolP pool) { + Slic2::Settings *setting = new Slic2::Settings(); + setting->img = img; + setting->step = step; + setting->stiffness = stiffness; + + if (pool.get() == nullptr) + setting->initThreadPool(); + else + setting->pool = pool; + + Slic2 *res = new Slic2(setting); + res->init(grad); + if (res->getClusters().clusterCount() == 0) + return Slic2P(); + return Slic2P(res); +} + +ThreadPoolP RSlic::Pixel::Slic2::threadpool() const { + return setting->pool; +} + +RSlic::Pixel::Slic2::Slic2(Slic2::Settings *s, ClusterSet &&c, const Mat &d) : clusters(std::move(c)), distance(d) { + assert(s != nullptr); + setting = s; + s->__refcount++; +} + +RSlic::Pixel::Slic2::~Slic2() { + int count = --setting->__refcount; + if (count == 0) { + delete setting; + } +} + +namespace { + + template + Vec2i find_local_minimum(const Mat &grad, const Vec2i ¢er) { + auto px = center[0]; + auto py = center[1]; + gtp min_value = std::numeric_limits::infinity(); + cv::Vec2i minPos = center; + for (int x = std::max(px - 1, 0); x < std::min(grad.cols, px + 2); x++) { + for (int y = std::max(0, py - 1); y < std::min(grad.rows, py + 2); y++) { + const gtp currentVal = grad.at(y, x); + if (currentVal < min_value) { + min_value = currentVal; + minPos = Vec2i(x, y); + } + } + } + return minPos; + } + + //find_local_minimum needs a type as template argument. + //find_local_minimum_helper will call find_local_minimum with the right template. + declareCVF_D(find_local_minimum, find_local_minimum_helper, return Vec2i(-1, -1)) + + /** + * Finds the local minimum in a 3x3-neighbourhood. + * @param grad the gradient of the image + * @param p the point + * @return the point with the lowest gradient value. + */ + Vec2i find_local_minimum_(const cv::Mat &grad, const Vec2i &p) { + auto res = ::find_local_minimum_helper(grad.type(), grad, p); + if (res == Vec2i(-1, -1)) return p; + return res; + } +} + +void RSlic::Pixel::Slic2::init(const Mat &grad) { + int s = setting->step; + std::vector centerGrid; + centerGrid.reserve(setting->img.cols / s * setting->img.rows / s); + // initialise the grid and set the its points to the lowest gradient at once + for (int x = s; x < setting->img.cols - s / 2; x += s) { + for (int y = s; y < setting->img.rows - s / 2; y += s) { + Vec2i p(x, y); + centerGrid.push_back(find_local_minimum_(grad, p)); + } + } + + + Mat_ label(setting->img.rows, setting->img.cols, -1); + + distance = Mat_(setting->img.rows, setting->img.cols, DINF); + + clusters = ClusterSet(centerGrid, label); + + max_dist_color = vector(centerGrid.size(), 1); //for slico +} + +int RSlic::Pixel::Slic2::getStep() const { + return setting->step; +} + +int RSlic::Pixel::Slic2::getStiffness() const { + return setting->stiffness; +} + +Mat RSlic::Pixel::Slic2::getImg() const { + return setting->img; +} + + +const RSlic::Pixel::ClusterSet &RSlic::Pixel::Slic2::getClusters() const { + return clusters; +} diff --git a/lib/Pixel/RSlic2.h b/lib/Pixel/RSlic2.h new file mode 100644 index 0000000..93dbcc1 --- /dev/null +++ b/lib/Pixel/RSlic2.h @@ -0,0 +1,137 @@ +#ifndef RSlic2_H +#define RSlic2_H + +#include +#include +#include +#include +#include +#include + +#include "ClusterSet.h" + +using namespace std; +using namespace cv; + +class ThreadPool; + +using ThreadPoolP=shared_ptr; + + +#define DINF std::numeric_limits::infinity() + +namespace RSlic { + namespace Pixel { + + using DistanceFunc=function; + + class Slic2; + + using Slic2P=shared_ptr; + + class Slic2 { + private: + struct Settings; + + public: + + Slic2(const Slic2 &other) = delete; + + Slic2(Slic2 &&other) = default; + + /** + * initialize the algorithm. It build the gradient and set the needed values + * @param img the picture + * @param grad the gradient of the picture. Should be positive. + * @param step how many pixel should belongs (approximately) to a clusters + * @param stiffness the stiffness value + * @param pool ThreadPool for computing parallel. + * @return SharedPointer of the Slic2-Object. (Error -> nullptr) + * @see iterate + */ + static Slic2P initialize(const Mat &img, const Mat &grad, int step, int stiffness, ThreadPoolP pool = ThreadPoolP()); + + ThreadPoolP threadpool() const; + + /** + * Iterating the algorithm. + * @param f the functor with the metrics for the iteration. + * Has to be something like struct Example{..;inline double operator()(const cv::Vec2i &point, const cv::Vec2i &clusterCenter, const cv::Mat &mat, int stiffness, int step){...} ...} + * (stiffness will be passed squared) + * @return a new instance of Slic2 with the results of the iteration. + */ + template + Slic2P iterate(F f) const; + + /** + * Iterating the algorithm with another stiffness. + * @param stiffness the stiffness factor. + * @param f the functor with the metrics for the iteration. + * @return a new instance of Slic2 with the results of the iteration. + * @see iterate + */ + template + Slic2P iterate(int stiffness, F f) const; + + /** + * Iterating the algorithm + * using the zero parameter version of the SLIC algorithm (SLICO) + * @param f the functor with the metrics for the iteration + * @return a new instance of Slic2 with the results of the iteration. + */ + template + Slic2P iterateZero(F f) const; + + + /** + * Enforce connectivity. + * Often this is the last step you want to do. + * But you can do another iteration after here. + * Even if it does not make any sense. + * @param f the functor with the metrics for the iteration + * @return a new instance of Slic2 with the results of the iteration. + */ + template + Slic2P finalize(F f) const; + + /** + * Returns the step value + * @return step value + */ + int getStep() const; + + /** + * Returns the stiffness value + * @return stiffness value + */ + int getStiffness() const; + + /** + * Returns the image + * @return the image + */ + Mat getImg() const; + + /** + * Returns the computed clusters. + * @return computed clusters + */ + const ClusterSet &getClusters() const; + + virtual ~Slic2(); + + private: + ClusterSet clusters; + Settings *setting; + Mat distance; + + vector max_dist_color; // For Slico (square values) + protected: + Slic2(Settings *s, ClusterSet &&clusters = ClusterSet(), const Mat &distance = cv::Mat()); + + void init(const Mat &grad); + }; + + } +} +#endif // RSlic2_H diff --git a/lib/Pixel/RSlic2Draw.cpp b/lib/Pixel/RSlic2Draw.cpp new file mode 100644 index 0000000..36df194 --- /dev/null +++ b/lib/Pixel/RSlic2Draw.cpp @@ -0,0 +1,112 @@ +#include "RSlic2Draw.h" +#include "../priv/Useful.h" + +#ifdef DEBUG_ME +#include +#endif + +#include +#include + +//To compute mean values there have to be a larger type (e.g. int -> long, vec of int -> vec of long) +//To find this type there are this struct. +//To use: LongVariant::type -> long version of T. +namespace priv { + //Default + template::value> + struct LongVariant { + using type = T; + }; + + //To distinguish signed form unsigned + namespace SignedLongTrait { + template::value> + struct SignedTrait { + }; + template + struct SignedTrait { // signed + using type = long; + using cvtype = int16_t; + }; + template + struct SignedTrait { // unsigned + using type = unsigned long; + using cvtype = uint32_t; + }; + } + + //char, short, int, long + template + struct LongVariant { + using type = typename priv::SignedLongTrait::SignedTrait::type; + }; + + namespace VecLongTrait { + template class VT, typename T, int N, bool = std::is_integral::value, bool = std::is_same, Vec>::value> + struct VecLongVariant { + }; + //vec of char, short, int, long + template class VT, typename T, int N> + struct VecLongVariant { + using type = Vec::cvtype, N>; + }; + //vec of double, float + template class VT, typename T, int N> + struct VecLongVariant { + using type = Vec; + }; + } + // Vec<..,..> + template class VT, typename T, int N> + struct LongVariant, false> { + using type = typename VecLongTrait::VecLongVariant::type; + }; + + template + using LongVector = vector::type>; +} + +namespace { + using namespace RSlic::Pixel; + + template + inline tuple, vector> calcMean(const Mat &m, const ClusterSet &set) { + auto n = set.clusterCount(); + priv::LongVector meanValue(n, 0); + vector pixelCount(n, 0); + auto label = set.getClusterLabel(); + for (int x = 0; x < m.cols; x++) { + for (int y = 0; y < m.rows; y++) { + auto idx = label.at(y, x); + if (idx < 0) continue; + meanValue[idx] += m.at(y, x); + pixelCount[idx]++; + } + } + return make_tuple(std::move(meanValue), std::move(pixelCount)); + } + + + template + Mat drawClusterType(const Mat &m, const ClusterSet &set) { + Mat res(m.rows, m.cols, m.type()); + auto label = set.getClusterLabel(); + auto meantuple = calcMean(m, set); + auto &&meanValue = get<0>(meantuple); + auto &&pixelCount = get<1>(meantuple); + for (int x = 0; x < m.cols; x++) { + for (int y = 0; y < m.rows; y++) { + auto idx = label.at(y, x); + res.at(y, x) = meanValue[idx] / pixelCount[idx]; + } + } + return res; + } + + declareCVF_T(drawClusterType, drawClusterType_, return cv::Mat()) +} + +Mat RSlic::Pixel::drawCluster(const Mat &m, const ClusterSet &set) { + return ::drawClusterType_(m.type(), m, set); +} + diff --git a/lib/Pixel/RSlic2Draw.h b/lib/Pixel/RSlic2Draw.h new file mode 100644 index 0000000..2d94bc9 --- /dev/null +++ b/lib/Pixel/RSlic2Draw.h @@ -0,0 +1,45 @@ +#ifndef RSlic2DRAW_H +#define RSlic2DRAW_H + +#include "RSlic2.h" +/* + * Functions for drawing cluster + */ + +namespace RSlic { + namespace Pixel { + /** + * Colorize the cluster by using the mean color. + * @param m the picture + * @param set the ClusterSet + * @return new picutre with colorized cluster + */ + Mat drawCluster(const Mat &m, const ClusterSet &set); + + /** + * Draw the lines around the cluster. color_t have to be right type for the image. + * @param m the picture + * @param set the ClusterSet + * @param color the color for drawing + * @return a new image + */ + template + Mat contourCluster(const Mat &m, const ClusterSet &set, color_t color) { + Mat res = m.clone(); + for (int x = 1; x < m.cols - 1; x++) { + for (int y = 1; y < m.rows - 1; y++) { + int currentLabel = set.at(y, x); + if (set.at(y + 1, x) != currentLabel + || set.at(y - 1, x) != currentLabel + || set.at(y, x + 1) != currentLabel + || set.at(y, x - 1) != currentLabel) { + res.at(y, x) = color; + } + } + } + return res; + } + } +} + +#endif // RSlic2DRAW_H diff --git a/lib/Pixel/RSlic2Util.cpp b/lib/Pixel/RSlic2Util.cpp new file mode 100644 index 0000000..4958573 --- /dev/null +++ b/lib/Pixel/RSlic2Util.cpp @@ -0,0 +1,129 @@ +#include "RSlic2Util.h" + + +string RSlic::Pixel::getType(const Mat &m) { + switch (m.type()) { + case CV_8UC1: + return "CV_8UC1"; + case CV_8UC2: + return "CV_8UC2"; + case CV_8UC3: + return "CV_8UC3"; + case CV_8UC4: + return "CV_8UC4"; + + case CV_8SC1: + return "CV_8SC1"; + case CV_8SC2: + return "CV_8SC2"; + case CV_8SC3: + return "CV_8SC3"; + case CV_8SC4: + return "CV_8SC4"; + + case CV_16UC1: + return "CV_16UC1"; + case CV_16UC2: + return "CV_16UC2"; + case CV_16UC3: + return "CV_16UC3"; + case CV_16UC4: + return "CV_16WUC4"; + + case CV_16SC1: + return "CV_16SC1"; + case CV_16SC2: + return "CV_16SC2"; + case CV_16SC3: + return "CV_16SC3"; + case CV_16SC4: + return "CV_16SC4"; + + case CV_32SC1: + return "CV_32SC1"; + case CV_32SC2: + return "CV_32SC2"; + case CV_32SC3: + return "CV_32SC3"; + case CV_32SC4: + return "CV_32SC4"; + + case CV_32FC1: + return "CV_32FC1"; + case CV_32FC2: + return "CV_32FC2"; + case CV_32FC3: + return "CV_32FC3"; + case CV_32FC4: + return "CV_32FC4"; + + case CV_64FC1: + return "CV_64FC1"; + case CV_64FC2: + return "CV_64FC2"; + case CV_64FC3: + return "CV_64FC3"; + case CV_64FC4: + return "CV_64FC4"; + + default: + return "Unknown"; + } +} + + +Mat RSlic::Pixel::buildGrad(const Mat &mat) { + cv::Mat dx, dy, res; + cv::Mat mat_gray; + switch (mat.type()) { + case CV_8UC3: + cv::cvtColor(mat, mat_gray, cv::COLOR_BGR2GRAY); + break; + case CV_8UC4: + cv::cvtColor(mat, mat_gray, cv::COLOR_BGRA2GRAY); + break; + default: + mat_gray = mat; + } + mat_gray.convertTo(mat_gray, CV_32FC1); + cv::Sobel(mat_gray, dx, -1, 1, 0); + cv::pow(dx, 2, dx); + cv::Sobel(mat_gray, dy, -1, 0, 1); + cv::pow(dy, 2, dy); + cv::sqrt(dx + dy, res); + return res; +} + +template +static RSlic::Pixel::Slic2P shutUpAndTakeMyMoneyType(const Mat &m, int step, int stiffness, bool slico, int iterations) { + F f; + Mat grad = RSlic::Pixel::buildGrad(m); + auto res = RSlic::Pixel::Slic2::initialize(m,grad,step, stiffness); + if (res.get() == nullptr) return res; //error + for (int i=0; i< iterations; i++){ + if (slico) res = res->iterateZero(f); + else res = res->iterate(f); + } + res = res->finalize(f); + return res; +} + + +RSlic::Pixel::Slic2P RSlic::Pixel::shutUpAndTakeMyMoney(const Mat &m, int count, int stiffness, bool slico, int iterations) { + int w = m.cols; + int h = m.rows; + int step = sqrt(w * h * 1.0 / count); + + if (m.type() == CV_8UC3) { + return shutUpAndTakeMyMoneyType(m,step, stiffness,slico,iterations); + } + if (m.type() == CV_8UC4) { + Mat other; + cv::cvtColor(m, other, cv::COLOR_BGRA2BGR); + return shutUpAndTakeMyMoneyType(other,step, stiffness,slico,iterations); + }//TODO: More Types + if (m.type() == CV_8UC1) { + return shutUpAndTakeMyMoneyType(m,step, stiffness,slico,iterations); + } + return nullptr; +} diff --git a/lib/Pixel/RSlic2Util.h b/lib/Pixel/RSlic2Util.h new file mode 100644 index 0000000..d03092f --- /dev/null +++ b/lib/Pixel/RSlic2Util.h @@ -0,0 +1,100 @@ +#ifndef RSlic2UTIL_H +#define RSlic2UTIL_H + +#include "RSlic2.h" +#include "RSlic2_impl.h" + +/* + * Helpful functions for Slic and OpenCV + */ +namespace RSlic { + namespace Pixel { + +/** +* Returns the type of the image as a human readable string (e.g. CV_U8C1, CV_16S3, ...) +* @param m the picture +* @return the type as string +*/ + string getType(const Mat &m); + + + /** + * Builds the gradient needed for Slic2 using Sobel. + * Contains the absolute sum of the derivation of both direction. + * (If needed mat will be convert into a gray value image) + * @param mat the picture + * @return the gradient + */ + Mat buildGrad(const Mat &mat); + + /** + * Function that is described in the paper for computing the metrics (of LAB images) for the algorithm. + */ + struct distanceColor { + + inline double operator()(const cv::Vec2i &point, const cv::Vec2i &clusterCenter, const cv::Mat &mat, int stiffness, int step) { + if (clusterCenter[1] < 0 || clusterCenter[0] < 0) { + return DINF; + } + cv::Vec3b pixel = mat.at(point[1], point[0]); + cv::Vec3b clust_pixel = mat.at(clusterCenter[1], clusterCenter[0]); + int pl = pixel[0], pa = pixel[1], pb = pixel[2]; + int cl = clust_pixel[0], ca = clust_pixel[1], cb = clust_pixel[2]; + double dc = pow(pl - cl, 2) + pow(pa - ca, 2) + pow(pb - cb, 2); + double ds = pow(point[0] - clusterCenter[0], 2) + pow(point[1] - clusterCenter[1], 2); + + return dc / stiffness + ds / (step * step); + } + + }; + + /** + * Function that is described in the paper for computing the metrics (of gray images) for the algorithm. + */ + struct distanceGray { + inline double operator()(const cv::Vec2i &point, const cv::Vec2i &clusterCenter, const cv::Mat &mat, int stiffness, int step) { + if (clusterCenter[1] < 0 || clusterCenter[0] < 0) { + return DINF; + } + int8_t pixel = mat.at(point[1], point[0]); + int8_t clust_pixel = mat.at(clusterCenter[1], clusterCenter[0]); + double dc = abs(pixel - clust_pixel); + double ds = sqrt(pow(point[0] - clusterCenter[0], 2) + pow(point[1] - clusterCenter[1], 2)); + + return pow(dc, 2) / stiffness + pow(ds / step, 2); + } + }; + + /** + * Returns Slic2P without any "complicated" parameter. + * @param m the picture + * @param the amount of Superpixel (approximately) + * @param slico use the slico version? + * @param iterations how many iterations + * @return instance of Slic2 (shared_ptr) where no iterating or something similar is needed. (error -> nullptr) + */ + Slic2P shutUpAndTakeMyMoney(const Mat &m, int count = 400, int stiffness = 40, bool slico = false, int iterations = 10); + + /** + * Heelping for do an iteration by selecting the metrics autmaticly. + * @param slic the Slic2-Object to iterate + * @param type the type of the image (img.type() in OpenCV) + * @param slico using Slico + * @return the result of slic->iterate or slic->iterateZero with the right metrics. + * (May nullptr if type is not supported or any other error occurs) + */ + inline Slic2P iteratingHelper(Slic2P slic, int type, bool slico = false) { + if (type == CV_8UC1) { + distanceGray g; + if (slico) return slic->iterateZero(g); + return slic->iterate(g); + } else if (type == CV_8UC3) { + distanceColor c; + if (slico) return slic->iterateZero(c); + return slic->iterate(c); + } + return Slic2P(); //unsupported type + } + } +} +#endif // RSlic2UTIL_H diff --git a/lib/Pixel/RSlic2_impl.h b/lib/Pixel/RSlic2_impl.h new file mode 100644 index 0000000..d16ba5e --- /dev/null +++ b/lib/Pixel/RSlic2_impl.h @@ -0,0 +1,428 @@ +#ifndef RSlic2_IMPL_H +#define RSlic2_IMPL_H + +#include "RSlic2.h" +#include +#include +#include <3rd/ThreadPool.h> + +#ifndef u_long +#define u_long unsigned long +#endif +#ifndef uint +#define uint unsigned int +#endif + +using namespace RSlic::Pixel; +using RSlic::priv::aSize; + +//Settings that are shared over several instances. +struct RSlic::Pixel::Slic2::Settings { + Settings() : __refcount(0), step(0), stiffness(0) { + } + + Settings(const Settings *other) : + __refcount(0), step(other->step), + img(other->img), stiffness(other->stiffness), pool(other->pool) { + } + + void initThreadPool(int threadcount = -1) { + if (threadcount <= 0) + threadcount = std::thread::hardware_concurrency(); + pool = std::make_shared(threadcount); + } + + Mat img; + int step; + int stiffness; + shared_ptr pool; + + std::atomic __refcount; +}; + + +template +RSlic::Pixel::Slic2P RSlic::Pixel::Slic2::iterate(F f) const { + return iterate(setting->stiffness, f); +} + +namespace RSlic { + namespace Pixel { + namespace priv { + + /** + * In order to share code between iterate and iterateZero we need + * to take out the different parts. + * This is the part from iterate. + */ + template + struct DistNormal { + inline double operator()(const Vec2i &point, const Vec2i ¢er, int clusterIdx) { + return f(point, center, img, stiffness * stiffness, step); + } + + const cv::Mat &img; + F &f; + int stiffness; + int step; + }; + } + } +} +namespace { +#ifdef PARALLEL + + /** + * For doing some parallel computing we have to reduce the results of the threads. + * Instead of iterating over all pixels, we just calculating the computed parts with + * BRect. + */ + struct BRect { + static constexpr uint imax = std::numeric_limits::max(); + struct point { + uint x; + uint y; + }; + point topLeft, bottomRight; + + BRect(uint tx, uint ty, uint bx, uint by) : topLeft{tx, ty}, bottomRight{bx, by} { + } + + BRect() : topLeft{imax, imax}, bottomRight{0, 0} { + } + + void combineWith(const BRect &other) { + topLeft.x = std::min(topLeft.x, other.topLeft.x); + topLeft.y = std::min(topLeft.y, other.topLeft.y); + bottomRight.x = std::max(bottomRight.x, other.bottomRight.x); + bottomRight.y = std::max(bottomRight.y, other.bottomRight.y); + } + }; + +#endif +} +namespace RSlic { + namespace Pixel { + namespace priv { + + /** + * Results of the common iteration algorithm + */ + struct iterateCommonRes { + Mat_ label; + Mat_ dist; + + iterateCommonRes(int w, int h) : label(h, w, -1), dist(h, w, DINF) { + } + + inline double &distAt(int y, int x) { + return dist.at(y, x); + } + + inline ClusterInt &labelAt(int y, int x) { + return label.at(y, x); + } + +#ifdef PARALLEL + BRect calcRect; +#endif + }; + + using iterateCommonResP = unique_ptr; + } + } +} +namespace { + /** + * Executes the Slic-Algorithm. Depending on the functor it computes the Slic or Slico version (or some unknown one ;). + * @param f the functor. Have to be something like struct ExampleF{...; double operator()(const Vec2i& point, const Vec2i & center, int clusterIdx){...} ....} + * @param beg the first cluster for computing + * @param end the last cluster for computing + * @param w the width of the picture + * @param h the height of the picture + * @param centers the central points of the clusters + * @param s the step + * @param pool the threadpool for parallel computing + * @result the results composed of the label Mat, distance Mat and may the rect of calculation + * @see iterate + * @see iterateZero + * @see priv::DistNormal + */ + template + inline RSlic::Pixel::priv::iterateCommonResP iterateCommonIteration(F f, int beg, int end, int w, int h, const vector ¢ers, int s, ThreadPoolP pool) { + RSlic::Pixel::priv::iterateCommonResP result(new RSlic::Pixel::priv::iterateCommonRes(w, h)); + for (int k = beg; k < end; k++) { + auto center = centers[k]; + int px = center[0]; + int py = center[1]; +#ifdef PARALLEL + BRect currentRect(std::max(0, px - s), std::max(0, py - s), std::min(w, px + s + 1), std::min(h, py + s + 1)); + result->calcRect.combineWith(currentRect); +#endif + for (int x = std::max(0, px - s); x < std::min(w, px + s + 1); x++) { + for (int y = std::max(0, py - s); y < std::min(h, py + s + 1); y++) { + Vec2i point(x, y); + double &d = result->distAt(y, x); + double D = f(point, center, k); + if (D < d) { + d = D; + result->labelAt(y, x) = k; + } + } + } + } + return result; + } + +#ifndef PARALLEL + + /** + * Executes the Slic-Algorithm. Depending on the functor it computes the Slic or Slico version (or some unknown one ;). + * @param f the functor. Have to be something like struct ExampleF{...; double operator()(const Vec2i& point, const Vec2i & center, int clusterIdx){...} ....} + * @param clusters the ClusterSet + * @param s the step + * @param pool the threadpool for parallel computing + * @result the results composed of the label Mat and distance Mat + * @see iterate + * @see iterateZero + * @see priv::DistNormal + */ + template + RSlic::Pixel::priv::iterateCommonResP iterateCommon(F f, const ClusterSet &clusters, int s, ThreadPoolP pool) { + auto centers = clusters.getCenters(); + int h = clusters.getClusterLabel().rows; + int w = clusters.getClusterLabel().cols; + int N = centers.size(); + + return iterateCommonIteration(f, 0, N, w, h, centers, s, pool); + } + +#else + +/** + * Executes the Slic-Algorithm. Depending on the functor it computes the Slic or Slico version (or some unknown one ;). + * (Do the parallel computing version) + * @param f the functor. Have to be something like struct ExampleF{...; double operator()(const Vec2i& point, const Vec2i & center, int clusterIdx){...} ....} + * @param clusters the ClusterSet + * @param s the step + * @param pool the threadpool for parallel computing + * @result the results composed of the label Mat and distance Mat + * @see iterate + * @see iterateZero + * @see priv::DistNormal + */ + template + RSlic::Pixel::priv::iterateCommonResP iterateCommon(F f, const ClusterSet &clusters, int s, ThreadPoolP pool) { + auto centers = clusters.getCenters(); + int h = clusters.getClusterLabel().rows; + int w = clusters.getClusterLabel().cols; + RSlic::Pixel::priv::iterateCommonResP result(new RSlic::Pixel::priv::iterateCommonRes(w, h)); + + int N = centers.size(); + int thread_step = N / pool->threadcount(); + std::vector> futures; + futures.reserve(pool->threadcount()); + //Map + + for (int thread_start = 0; thread_start < N; thread_start += thread_step) { + futures.push_back(pool->enqueue([&](int start) { + return iterateCommonIteration(f, start, std::min(start + thread_step, N), w, h, centers, s, pool); + }, thread_start)); + } + //Reduce + for (auto &&fut: futures) { + auto &&thread_result = fut.get(); + //Only use changed parts for reducing + for (int x = thread_result->calcRect.topLeft.x; x < thread_result->calcRect.bottomRight.x; x++) { + for (int y = thread_result->calcRect.topLeft.y; y < thread_result->calcRect.bottomRight.y; y++) { + double dist_thread = thread_result->distAt(y, x); + double &dist_result = result->distAt(y, x); + if (dist_thread < dist_result) { + dist_result = dist_thread; + result->labelAt(y, x) = thread_result->labelAt(y, x); + } + } + } + } + return result; + } + +#endif +} + +template +RSlic::Pixel::Slic2P RSlic::Pixel::Slic2::iterate(int stiffness, F f) const { + int s = setting->step; + int w = setting->img.cols; + int h = setting->img.rows; + + // Setting up the normal Slic + RSlic::Pixel::priv::DistNormal distF{setting->img, f, stiffness, s}; + auto res = ::iterateCommon>(distF, clusters, s, setting->pool); + + // Creating the new instace + Settings *newSetting = setting; + if (setting->stiffness != stiffness) { + newSetting = new Settings(setting); + newSetting->stiffness = stiffness; + } + Slic2 *result = new Slic2(newSetting, ClusterSet(res->label, clusters.getCenters().size()), res->dist); + + return shared_ptr(result); +} + +namespace { + //Update the color-distance-maxima-matrix for slico that will be used for the next iteration. + template + inline void iterateZeroUpdate( + const Mat &img, const Mat &label, + const vector ¢ers, vector &max_dist_color, shared_ptr pool) { + int w = img.cols; + int h = img.rows; + //Update Slico distance maxima +#ifdef PARALLEL + int step = w / pool->threadcount(); + std::vector> results; + results.reserve(pool->threadcount()); + for (int xx = 0; xx < w; xx += step) { + results.push_back(pool->enqueue([&](int xx) { + for (int x = xx; x < std::min(xx + step, w); x++) { +#else + for (int x = 0; x < w; x++) { +#endif + for (int y = 0; y < h; y++) { + ClusterInt nearest_segment = label.at(y, x); + if (nearest_segment == -1) continue; + auto point = centers[nearest_segment]; + int py = point[1]; + int px = point[0]; + auto distColor = RSlic::priv::zero::zeroMetrik(img.at(y, x), img.at(py, px)); + if (max_dist_color.at(nearest_segment) < distColor) { + max_dist_color.at(nearest_segment) = distColor; + } + } + } +#ifdef PARALLEL + }, xx)); + } + for (auto &res: results) {res.get();} +#endif + } + + //For calling without template + declareCVF_T(iterateZeroUpdate, iterateZeroUpdateHelper, + return) +} +namespace RSlic { + namespace Pixel { + namespace priv { + + //Computing with zero + template + struct DistZero { + inline double operator()(const Vec2i &point, const Vec2i ¢er, int clusterIdx) { + return f(point, center, img, max_distance[clusterIdx], step); + } + + const cv::Mat &img; + F f; + const vector &max_distance; + int step; + }; + } + } +} + +//Slico +template +RSlic::Pixel::Slic2P RSlic::Pixel::Slic2::iterateZero(F f) const { + int s = setting->step; + int w = setting->img.cols; + int h = setting->img.rows; + + //Setting up Slico + Pixel::priv::DistZero distF{setting->img, f, max_dist_color, s}; + auto res = ::iterateCommon>(distF, clusters, s, setting->pool); + + auto newClusters = ClusterSet(res->label, clusters.getCenters().size()); + vector new_max_dist_color(max_dist_color); + // + //Update values + ::iterateZeroUpdateHelper(setting->img.type(), setting->img, res->label, newClusters.getCenters(), new_max_dist_color, setting->pool); + + //Creating a new instance + Slic2 *result = new Slic2(setting, std::move(newClusters), res->dist); + result->max_dist_color = std::move(new_max_dist_color); + return shared_ptr(result); +} + +template +RSlic::Pixel::Slic2P RSlic::Pixel::Slic2::finalize(F f) const { + int w = setting->img.cols; + int h = setting->img.rows; + Mat_ finalClusters(h, w, -1); + int currentLabel = 0; + const int lims = (h * w) / (clusters.clusterCount()); + static const int neighboursX[] = {1, 0, -1, 0}; + static const int neighboursY[aSize(neighboursX)] = {0, 1, 0, -1}; + + for (int x = 0; x < w; x++) { + for (int y = 0; y < h; y++) { + //Some unassigned pixel? + if (finalClusters.at(y, x) == -1) { + vector current_points; + current_points.emplace_back(x, y); + finalClusters.at(y, x) = currentLabel; + + //Look transitively for all unassigned neighbors + //set them in current_points and finalCluster + for (int i = 0; i < current_points.size(); i++) { + Vec2i point = current_points[i]; + + for (int neighbour = 0; neighbour < aSize(neighboursX); neighbour++) { + int px = point[0] + neighboursX[neighbour]; + int py = point[1] + neighboursY[neighbour]; + if (px < 0 || px >= w || py < 0 || py >= h) continue; // not in the picture anymore + if (finalClusters.at(py, px) == -1 + && clusters.at(y, x) == clusters.at(py, px)) { + current_points.emplace_back(px, py); + finalClusters.at(py, px) = currentLabel; + } + } + } + + //If there are not enough pixel in the cluster + //look for the best in the environment and conjoin both + if (current_points.size() <= lims >> 2) { + int adjlabel = currentLabel; //best neighbor + double topdist = DINF; //best neighbor value + //finding best neighbor + for (int neighbour = 0; neighbour < 4; neighbour++) { + int px = x + neighboursX[neighbour]; + int py = y + neighboursY[neighbour]; + if (px < 0 || px >= w || py < 0 || py >= h) continue; + ClusterInt label = finalClusters.at(py, px); + if (label >= 0 && label != currentLabel) { + double dist = f(Vec2i(x, y), Vec2i(px, py), setting->img, 1, setting->step); + if (dist < topdist) { + topdist = dist; + adjlabel = label; + } + } + } + //Set pixel to this neighbor + for (const Vec2i point: current_points) { + finalClusters.at(point[1], point[0]) = adjlabel; + } + } else currentLabel++; //Else I've created a new cluster + } + } + } + + Slic2 *result = new Slic2(setting, ClusterSet(finalClusters, currentLabel), distance); + return std::shared_ptr(result); +} + + +#endif // RSlic2_IMPL_H + diff --git a/lib/RSlic.h b/lib/RSlic.h new file mode 100644 index 0000000..ee00205 --- /dev/null +++ b/lib/RSlic.h @@ -0,0 +1,5 @@ +#ifndef RSlicH_H +#define RSlicH_H +#include "RSlic2H.h" +#include "RSlic3H.h" +#endif diff --git a/lib/RSlic2H.h b/lib/RSlic2H.h new file mode 100644 index 0000000..7942b79 --- /dev/null +++ b/lib/RSlic2H.h @@ -0,0 +1,12 @@ +#ifndef RSlic2H_H +#define RSlic2H_H + +#include +#include +#include +#include +#include + +#include <3rd/ThreadPool.h> + +#endif diff --git a/lib/RSlic3H.h b/lib/RSlic3H.h new file mode 100644 index 0000000..84d27be --- /dev/null +++ b/lib/RSlic3H.h @@ -0,0 +1,10 @@ +#ifndef RSlic3H_H +#define RSlic3H_H + +#include <3rd/ThreadPool.h> +#include +#include +#include +#include + +#endif diff --git a/lib/Voxel/ClusterSet.cpp b/lib/Voxel/ClusterSet.cpp new file mode 100644 index 0000000..2f3970c --- /dev/null +++ b/lib/Voxel/ClusterSet.cpp @@ -0,0 +1,115 @@ +#include "ClusterSet.h" +#include "../priv/Useful.h" + +using namespace RSlic::Voxel; +using RSlic::priv::aSize; + +inline tuple operator+(const tuple &a, const tuple &b) { + return make_tuple( + std::get<0>(a) + std::get<0>(b), + std::get<1>(a) + std::get<1>(b), + std::get<2>(a) + std::get<2>(b) + ); +} + +RSlic::Voxel::ClusterSet3::ClusterSet3(cv::Mat_ clusters, int clusterCount) + : data{clusters, vector(), clusterCount, false} { +} + +Mat_ RSlic::Voxel::ClusterSet3::getClusterLabel() const { + return data.clusterLabel; +} + +const vector &RSlic::Voxel::ClusterSet3::getCenters() const { + if (!data.centers_calculated) refindCenters(); + return data.centers; +} + +int RSlic::Voxel::ClusterSet3::clusterCount() const { + return data._clusterCount; +} + +void RSlic::Voxel::ClusterSet3::refindCenters() const { + std::lock_guard guard(mutex); + if (data.centers_calculated) return; + int w = data.clusterLabel.size[1]; + int h = data.clusterLabel.size[0]; + int d = data.clusterLabel.size[2]; + vector centersCounts(data._clusterCount, 0); + vector> centerCoord(data._clusterCount, make_tuple(0l, 0l, 0l)); + + for (int x = 0; x < w; x++) { + for (int y = 0; y < h; y++) { + for (int t = 0; t < d; t++) { + ClusterInt idx = data.clusterLabel.at(y, x, t); + if (idx < 0) continue; + centersCounts[idx] = centersCounts[idx] + 1; + centerCoord[idx] = centerCoord[idx] + make_tuple(static_cast(x), static_cast(y), static_cast(t)); + } + } + } + + for (int i = 0; i < data._clusterCount; i++) { + auto counts = centersCounts[i]; + assert(counts > 0); + /*if (counts == 0) { + centers.push_back(Vec3i(0, 0, 0)); + continue; + }*/ + data.centers.emplace_back( + std::get<0>(centerCoord[i]) / counts, + std::get<1>(centerCoord[i]) / counts, + std::get<2>(centerCoord[i]) / counts); + } + data.centers_calculated = true; +} + +Mat RSlic::Voxel::ClusterSet3::maskOfCluster(ClusterInt idx) const { + int w = data.clusterLabel.size[1]; + int h = data.clusterLabel.size[0]; + int d = data.clusterLabel.size[2]; + cv::Mat res = cv::Mat(3, data.clusterLabel.size, CV_8U); + for (int x = 0; x < w; x++) { + for (int y = 0; y < h; y++) { + for (int t = 0; t < d; t++) { + if (data.clusterLabel.at(y, x, t) == idx) + res.at(y, x, t) = 1; + } + } + } + return res; +} + + +namespace { + inline void setClusterAdjacent(Mat &m, int p1, int p2) { + m.at(p1, p2) = 1; + m.at(p2, p1) = 1; + } +} + +cv::Mat RSlic::Voxel::ClusterSet3::adjacentMatrix() const { + int size = clusterCount(); + Mat res = Mat::eye(size, size, CV_8UC1); + Mat_ clusterMat = getClusterLabel(); + int w = clusterMat.size[1]; + int h = clusterMat.size[0]; + int d = clusterMat.size[2]; + static const int xNeighbour[] = {1, 0, 0, 1, 0, 1, 1}; + static const int yNeighbour[aSize(xNeighbour)] = {0, 1, 0, 1, 1, 0, 1}; + static const int zNeighbour[aSize(xNeighbour)] = {0, 0, 1, 0, 1, 1, 1}; + for (int x = 0; x < w - 1; x++) { + for (int y = 0; y < h - 1; y++) { + for (int t = 0; t < d - 1; t++) { + ClusterInt currentCluster = clusterMat.at(y, x, t); + for (int i = 0; i < aSize(xNeighbour); i++) { + ClusterInt otherCluster = clusterMat.at(y + yNeighbour[i], x + xNeighbour[i], t + zNeighbour[i]); + if (currentCluster != otherCluster) { + setClusterAdjacent(res, currentCluster, otherCluster); + } + } + } + } + } + return res; +} diff --git a/lib/Voxel/ClusterSet.h b/lib/Voxel/ClusterSet.h new file mode 100644 index 0000000..025b927 --- /dev/null +++ b/lib/Voxel/ClusterSet.h @@ -0,0 +1,133 @@ +#ifndef ClUSTERSET3_H +#define ClUSTERSET3_H + +#include +#include + +using namespace std; +using namespace cv; + +namespace RSlic { + namespace Voxel { + using ClusterInt=int; //int32_t + +/** +* @brief Representing cluster (also called "Supervoxel") with some functionality +*/ + class ClusterSet3 { + public: + + ClusterSet3() : data{Mat_(), vector(), 0, false} { + } + + ClusterSet3(ClusterSet3 &&other) : data(std::move(other.data)) { + } + + ClusterSet3(const ClusterSet3 &other) : data(other.data) { + } + + ClusterSet3 &operator=(ClusterSet3 &&other) { + data = std::move(other.data); + return *this; + } + + ClusterSet3 &operator=(const ClusterSet3 &other) { + data = other.data; + return *this; + } + + /** + * Initialize with given centers and cluster-label mat + * @param _centers List with the central points of the clusters + * @param _clusters Mat where _clusters[i,j]=x means that the point i,j belongs to the cluster number x + */ + template, typename std::decay::type>::value + >::type> + ClusterSet3(T &&_centers, cv::Mat_ _clusters) : data{_clusters, std::forward(_centers), 0, true} { + data._clusterCount = data.centers.size(); + } + + /** + * Initialize with given clusters and the cluster's amount. + * The central points will be calculating if necessary. + * @param clusters Mat where clusters[i,j]=x means that the point i,j belongs to the cluster number x + * @param clusterCount the amount of the clusters + * @see getCenters() + */ + ClusterSet3(cv::Mat_ clusters, int clusterCount); + + + /** + * Returns a mask of the cluster with the number idx. + * @param idx Clusters index + * @return binary mask. + */ + Mat maskOfCluster(ClusterInt idx) const; // Binäres Bild. 0 => gehört nicht dazu, 1 => gehört dazu + + + /** + * Returns a Mat m where where m[x,y]=i means that the point x,y belongs to the cluster with the number i + * @return Mat with the cluster label + */ + Mat_ getClusterLabel() const; + + /** + * Returns the central points of the clusters. + * The index indicates the cluster number the central point belongs to. + * This is a lazy-evaluation. + * @return List of central points + */ + const vector &getCenters() const; + + /** + * Returns the amount of clusters. + * @return amount of clusters + */ + int clusterCount() const; + + /** + * Returns the index of the cluster the point x,y belongs to. + * @param y y-coordinate + * @param x x-coordinate + * @return cluster index + */ + inline ClusterInt at(int y, int x, int t) const { + return data.clusterLabel.at(y, x, t); + } + + /** + * Returns the adjacent matrix m (type CV_8UC1). + * If m[x,y] == 1 then the cluster with number x + * and the cluster with number y are neighbor. + * It is always m[x,x] == 1 and if m[x,y]==1 + * it means that m[y,x] == 1. + * @return adjacent matrix. + */ + cv::Mat adjacentMatrix() const; + + private: + struct nonspecial { //For default copy & move constructor + nonspecial(nonspecial &&other) = default; + + nonspecial(const nonspecial &other) = default; + + nonspecial &operator=(const nonspecial &other) = default; + + nonspecial &operator=(nonspecial &&other) = default; + + Mat_ clusterLabel; //3-Dim + + mutable vector centers; + int _clusterCount; + mutable bool centers_calculated; + } data; + + mutable std::mutex mutex; + + void refindCenters() const; + }; + + } +} +#endif diff --git a/lib/Voxel/RSlic3.cpp b/lib/Voxel/RSlic3.cpp new file mode 100644 index 0000000..3b49753 --- /dev/null +++ b/lib/Voxel/RSlic3.cpp @@ -0,0 +1,126 @@ +#include "RSlic3.h" +#include +#include <3rd/ThreadPool.h> +#include +#include "RSlic3_impl.h" +#include + +#ifndef u_long +#define u_long unsigned long +#endif +#ifndef uint +#define uint unsigned int +#endif + +using RSlic::priv::aSize; +using namespace RSlic::Voxel; + + +ThreadPoolP Slic3::threadpool() const { + return setting->pool; +} + +Slic3P Slic3::initialize(const MovieCacheP &img, const GradFunc &grad, int step, int stiffness, ThreadPoolP pool) { + Slic3::Settings *setting = new Slic3::Settings(); + setting->img = img; + setting->step = step; + setting->stiffness = stiffness; + setting->gradFunc = grad; + if (pool.get() == nullptr) + setting->initThread(); + else + setting->pool = pool; + + Slic3 *res = new Slic3(setting); + res->init(); + if (res->clusters.clusterCount() == 0) { + delete res; + return Slic3P(); + } + return Slic3P(res); +} + +RSlic::Voxel::Slic3::Slic3(Settings *s, ClusterSet3 &&set, const Mat &d) : clusters(std::move(set)), distance(d) { + assert(s != nullptr); + setting = s; + s->__refcount++; +} + +RSlic::Voxel::Slic3::~Slic3() { + int count = --setting->__refcount; + if (count == 0) { + delete setting; + } +} + +namespace { + Vec3i find_local_minimum(const MovieCacheP &p, const GradFunc &f, const Vec3i ¢er) { + auto px = center[0]; + auto py = center[1]; + auto pt = center[2]; + int w = p->width(); + int h = p->height(); + int duration = p->duration(); + double min_value = DINF; + cv::Vec3i minPos = center; + for (int x = std::max(px - 1, 0); x < std::min(w, px + 2); x++) { + for (int y = std::max(0, py - 1); y < std::min(h, py + 2); y++) { + for (int t = std::max(0, pt - 1); t < std::min(duration, pt + 2); t++) { + Vec3i point(x, y, t); + auto currentVal = f(p, point); + if (currentVal < min_value) { + min_value = currentVal; + minPos = point; + } + } + } + } + return minPos; + } + +} + +void RSlic::Voxel::Slic3::init() { + int s = setting->step; + int w = setting->img->width(); + int h = setting->img->height(); + int d = setting->img->duration(); + std::vector centerGrid; + centerGrid.reserve(w * h * d / s / s / s); + // initialize the grid and set the minimum of the gradient at once + for (int x = s; x < w - s / 2; x += s) { + for (int y = s; y < h - s / 2; y += s) { + for (int t = s; t < d - s / 2; t += s) { + Vec3i p(x, y, t); + centerGrid.push_back(find_local_minimum(setting->img, setting->gradFunc, p)); + } + } + } + + + int *size = setting->img->sizeArray(); + Mat_ label(3, size, -1); +; + delete size; + clusters = ClusterSet3(centerGrid, label); + + max_dist_color = std::vector(clusters.clusterCount(), 1); //for slico +} + + +int RSlic::Voxel::Slic3::getStep() const { + return setting->step; +} + +int RSlic::Voxel::Slic3::getStiffness() const { + return setting->stiffness; +} + +MovieCacheP RSlic::Voxel::Slic3::getImg() const { + return setting->img; +} + + +const ClusterSet3 &RSlic::Voxel::Slic3::getClusters() const { + return clusters; +} diff --git a/lib/Voxel/RSlic3.h b/lib/Voxel/RSlic3.h new file mode 100644 index 0000000..6fefdd3 --- /dev/null +++ b/lib/Voxel/RSlic3.h @@ -0,0 +1,237 @@ +#ifndef RSlic3_H +#define RSlic3_H + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ClusterSet.h" + + + +using namespace std; +using namespace cv; + +class ThreadPool; + +using ThreadPoolP=shared_ptr; + +#define DINF std::numeric_limits::infinity() + +namespace RSlic { + namespace Voxel { + + /** + * Abstract class for managing the pictures of a sequence for the Supervoxel algorithm. + * (E.g. load and destroy images if memory is low) + * By subclassing it you have to make sure that are pictures have the same type and size. + */ + class MovieCache { + public: + + /** + * Returns the image at the position t + * @param t the position of the image + * @return the image as a Mat. (Empty Mat for an invalid t) + */ + virtual Mat matAt(int t) const = 0; + + /** + * Returns the value of the point x,y from the picture at position t + * (Similar to Mat::at) + * @param y y coordinate + * @param x x coordinate + * @param t position of the image + * @return value of the point + */ + template + inline T at(int y, int x, int t) const { + return matAt(t).at(y, x); + } + + /** + * Returns the value of the point v + * (Equally to MovieCacheP::at(v[1],v[0],v[3])= + * @param v the point + * @return value of the point + */ + template + inline T at(const Vec3i &v) const { + return matAt(v[2]).at(v[1], v[0]); + } + + /** + * Returns the duration (number of images of the sequence) + * @return the duration + */ + virtual int duration() const = 0; + + /** + * Returns the width of *all* images + * @return the width + */ + inline int width() const { + return matAt(0).size[1]; + } + + /** + * Returns the width of *all* images + * @return the height + */ + inline int height() const { + return matAt(0).size[0]; + } + + /** + * Returns the height, width and durations as a tuple + * @returns size tuple + */ + inline tuple sizeTuple() const { + return std::make_tuple(matAt(0).size[0], matAt(0).size[1], duration()); + } + + + /** + * Returns the height, width and durations as an array. + * The array have to be deleted. + * @returns size array + */ + inline int *sizeArray() const { + int *res = new int[3]; + res[0] = matAt(0).size[0]; + res[1] = matAt(0).size[1]; + res[2] = duration(); + return res; + } + + /** + * Returns the type of *all* images + * @returns image type + */ + inline int type() const { + return matAt(0).type(); + } + }; + + using MovieCacheP=shared_ptr; + + + + using DistanceFunc = function; + using GradFunc = function; + + class Slic3; + + using Slic3P = shared_ptr; + + class Slic3 { + private: + struct Settings; + + public: + Slic3(const Slic3 &other) = delete; + + Slic3(Slic3 &&other) = default; + + /** + * initialize the algorithm. It build the gradient and set the needed values + * @param img the MoveCache + * @param a function to calculate the gradient + * @param step how many pixel should belongs (approximately) to a clusters + * @param stiffness the stiffness value + * @param pool ThreadPool for computing parallel. + * @return SharedPointer of the Slic3-Object. (Error -> nullptr) + * @see iterate + */ + static Slic3P initialize(const MovieCacheP &img, const GradFunc &grad, int step, int stiffness, ThreadPoolP pool = ThreadPoolP()); + + + /** + * Iterating the algorithm. + * @param f the functor with the metrics for the iteration. + * Has to be something like struct Example{..; inline double operator()(const cv::Vec3i &point, const cv::Vec3i &clusterCenter, const MovieCacheP &mat, int stiffness, int step){...} ...} + * (stiffness will be passed squared) + * @return a new instance of Slic3 with the results of the iteration. + */ + template + Slic3P iterate(F f) const; + + /** + * Iterating the algorithm with another stiffness. + * @param stiffness the stiffness factor. + * @param f the functor with the metrics for the iteration. + * @return a new instance of Slic3 with the results of the iteration. + * @see iterate + */ + template + Slic3P iterate(int stiffness, F f) const; + + ThreadPoolP threadpool() const; + + /** + * Iterating the algorithm + * using the zero parameter version of the SLIC algorithm (SLICO) + * @param f the functor with the metrics for the iteration + * @return a new instance of Slic3 with the results of the iteration. + */ + template + Slic3P iterateZero(F f) const; + + /** + * Enforce connectivity. + * Often this is the last step you want to do. + * But you can do another iteration after here. + * Even if it does not make any sense. + * @param f the functor with the metrics for the iteration + * @return a new instance of Slic3 with the results of the iteration. + */ + template + Slic3P finalize(F f) const; + + /** + * Returns the step value + * @return step value + */ + int getStep() const; + + /** + * Returns the stiffness value + * @return stiffness value + */ + int getStiffness() const; + + /** + * Returns the MovieCache + * @return the MovieCache + */ + MovieCacheP getImg() const; + + /** + * Returns the computed clusters. + * @return computed clusters + */ + const ClusterSet3 &getClusters() const; + + virtual ~Slic3(); + + + private: + ClusterSet3 clusters; + Settings *setting; + Mat distance; //3-dim + double error; + + vector max_dist_color; + protected: + Slic3(Settings *s, ClusterSet3 &&set = ClusterSet3(), const Mat &distance = Mat()); + + void init(); + }; + } +} +#endif // RSlic3_H diff --git a/lib/Voxel/RSlic3Utils.cpp b/lib/Voxel/RSlic3Utils.cpp new file mode 100644 index 0000000..b429280 --- /dev/null +++ b/lib/Voxel/RSlic3Utils.cpp @@ -0,0 +1,107 @@ +#include +#include +#include "RSlic3Utils.h" +#include "RSlic3_impl.h" + +cv::Mat RSlic::Voxel::SimpleMovieCache::matAt(int t) const { + if (t >= pictures.size()) return Mat(); + return pictures[t]; +} + +int RSlic::Voxel::SimpleMovieCache::duration() const { + return pictures.size(); +} + +RSlic::Voxel::SimpleMovieCache::SimpleMovieCache(const std::vector &_pictures) : pictures(_pictures) { + +} + + +RSlic::Voxel::SimpleMovieCache::SimpleMovieCache(std::vector &&_pictures) : pictures(std::move(_pictures)) { + +} + +RSlic::Voxel::SimpleMovieCache::SimpleMovieCache(const std::vector &filenames) { + for (const string &f: filenames) { + Mat mat = cv::imread(f, cv::IMREAD_COLOR); //TODO: Don't ignore cases where images have not the same size or type + switch (mat.type()) { + case CV_8UC3: + cv::cvtColor(mat, mat, cv::COLOR_BGR2Lab); + break; + } + pictures.push_back(mat); + } +} + +namespace { + template + inline double decolor(const T &color) { + return (double) color; + } + + template<> + inline double decolor(const Vec3b &color) { + return (color[0] * 1.0 + color[1] * 1.0 + color[2] * 1.0 ) / 3.0; + } + + template<> + inline double decolor(const uint8_t &color) { + return (double) color; + } + + template + inline double buildGradIntern(RSlic::Voxel::MovieCacheP const &img, Vec3i const &vec) { + int y = vec[1]; + int x = vec[0]; + int t = vec[2]; + + double dx = decolor(img->at(y, x - 1, t) + img->at(y, x + 1, t)); + dx = dx / 2; + + double dy = decolor(img->at(y - 1, x, t) + img->at(y + 1, x, t)); + dy = dy / 2; + + double dt = decolor(img->at(y, x, t - 1) + img->at(y, x, t + 1)); + dt = dt / 2; + + return sqrt(dx * dx + dy * dy + dt * dt); + } +} + + +double ::RSlic::Voxel::buildGradGray(RSlic::Voxel::MovieCacheP const &img, Vec3i const &vec) { + return ::buildGradIntern(img, vec); +} + +double ::RSlic::Voxel::buildGradColor(RSlic::Voxel::MovieCacheP const &img, const Vec3i &vec) { + return ::buildGradIntern(img, vec); +} + +template +static RSlic::Voxel::Slic3P shutUpAndTakeMyMoneyType(const RSlic::Voxel::MovieCacheP &m, int step, int stiffness, bool slico, int iterations, function grad) { + F f; + auto res = RSlic::Voxel::Slic3::initialize(m,grad,step, stiffness); + if (res.get() == nullptr) return res; //error + for (int i=0; i< iterations; i++){ + if (slico) res = res->iterateZero(f); + else res = res->iterate(f); + } + res = res->finalize(f); + return res; +} + + +RSlic::Voxel::Slic3P RSlic::Voxel::shutUpAndTakeMyMoney(const RSlic::Voxel::MovieCacheP &m, int count, int stiffness, bool slico, int iterations) { + int w = m->width(); + int h = m->height(); + int t = m->duration(); + int step = pow(w * h * t * 1.0 / count, 1.0/3); + + if (m->type() == CV_8UC3) { + return shutUpAndTakeMyMoneyType(m,step, stiffness,slico,iterations, buildGradColor); + } + else if (m->type() == CV_8UC1){ + return shutUpAndTakeMyMoneyType(m,step, stiffness, slico,iterations, buildGradGray); + } + return nullptr; +} diff --git a/lib/Voxel/RSlic3Utils.h b/lib/Voxel/RSlic3Utils.h new file mode 100644 index 0000000..e991b7a --- /dev/null +++ b/lib/Voxel/RSlic3Utils.h @@ -0,0 +1,131 @@ +#ifndef RSlic3UTILS_H +#define RSlic3UTILS_H + +#include "RSlic3.h" + +namespace RSlic { + namespace Voxel { + /** + * Simple MovieCache that just load all images into memory. + */ + class SimpleMovieCache : public MovieCache { + public: + + /** + * Initialize with filenames of all images. + * The images will be converted from BGR to LAB if needed. + * @param filenames list of files + */ + SimpleMovieCache(const std::vector &filenames); + + /** + * Initialize with list of all images. + * @param pictures list of images + */ + SimpleMovieCache(const std::vector &pictures); + + /** + * Initialize with list of all images. (rvalue) + * @param pictures list of images + */ + SimpleMovieCache(std::vector &&pictures); + + virtual Mat matAt(int t) const override; + + virtual int duration() const override; + + /** + * Returns list with all images + * @return list of images + */ + const std::vector &getPictures() const; + + private: + std::vector pictures; + }; + + /** + * Function for computing the gradient of a gray image. + * @param img MovieCacheP + * @param vec the point to compute the gradient + */ + double buildGradGray(const MovieCacheP &img, const Vec3i &vec); + + /** + * Function for computing the gradient of a color image. + * @param img MovieCacheP + * @param vec the point to compute the gradient + */ + double buildGradColor(const MovieCacheP &img, const Vec3i &vec); + + /** + * Function that is described in the paper for computing the metrics (of LAB images) for the algorithm. + */ + struct distanceColor{ + inline double operator()(const cv::Vec3i &point, const cv::Vec3i &clusterCenter, const MovieCacheP &mat, int stiffness, int step){ + if (clusterCenter[1] < 0 || clusterCenter[0] < 0 || clusterCenter[2] < 0) { + return DINF; + } + cv::Vec3b pixel = mat->at(point); + cv::Vec3b clust_pixel = mat->at(clusterCenter); + int pl = pixel[0], pa = pixel[1], pb = pixel[2]; + int cl = clust_pixel[0], ca = clust_pixel[1], cb = clust_pixel[2]; + double dc = sqrt(pow(pl - cl, 2) + pow(pb - cb, 2) + pow(pa - ca, 2)); + double ds = sqrt(pow(point[0] - clusterCenter[0], 2) + pow(point[1] - clusterCenter[1], 2) + pow(point[2] - clusterCenter[2], 2)); + + return sqrt(pow(dc, 2) / stiffness + pow(ds / step, 2)); + } + }; + + /** + * Function which is described in the paper for computing the metrics (of gray images) for the algorithm. + */ + struct distanceGray{ + inline double operator()(const cv::Vec3i &point, const cv::Vec3i &clusterCenter, const MovieCacheP &mat, int stiffness, int step){ + if (clusterCenter[1] < 0 || clusterCenter[0] < 0 || clusterCenter[2] < 0) { + return DINF; + } + int8_t pixel = mat->at(point); + int8_t clust_pixel = mat->at(clusterCenter); + double dc = abs(pixel - clust_pixel); + double ds = sqrt(pow(point[0] - clusterCenter[0], 2) + + pow(point[1] - clusterCenter[1], 2) + + pow(point[2] - clusterCenter[2], 2)); + return /*sqrt(*/pow(dc, 2) / stiffness + pow(ds / step, 2)/*)*/; + + } + }; + +#define slicFunHelper(type, fun) \ + type == CV_8UC3? fun(RSlic::Voxel::distanceColor())\ + : (type == CV_8UC1 ? fun(RSlic::Voxel::distanceGray())\ + : nullptr) + + /** + * Helping for doing an iteration by selecting the metrics automatically. + * @param slic the Slic2-Object to iterate + * @param type the type of the image (img.type() in OpenCV) + * @param slico using Slico + * @return the result of slic->iterate or slic->iterateZero with the right metrics. + * (May nullptr if type is not supported or any other error occurs) + */ + inline Slic3P iterateHelper(Slic3P p, int type, bool slico){ + if (slico){ + return slicFunHelper(type,p->iterateZero); + } + return slicFunHelper(type,p->iterate); + } + + /** + * Returns Slic3P without any "complicated" parameter. + * @param m the moviecache + * @param the amount of Superpixel (approximately) + * @param slico use the slico version? + * @param iterations how many iterations + * @return instance of Slic3 (shared_ptr) where no iterating or something similar is needed. (error -> nullptr) + */ + Slic3P shutUpAndTakeMyMoney(const RSlic::Voxel::MovieCacheP &m, int count = 4000, int stiffness = 40, bool slico = false, int iterations = 10); + } +} + +#endif diff --git a/lib/Voxel/RSlic3_impl.h b/lib/Voxel/RSlic3_impl.h new file mode 100644 index 0000000..06386f2 --- /dev/null +++ b/lib/Voxel/RSlic3_impl.h @@ -0,0 +1,387 @@ +#ifndef RSlic3_IMPL_H +#define RSlic3_IMPL_H + +#include "RSlic3.h" +#include +#include +#include <3rd/ThreadPool.h> + +#ifndef u_long +#define u_long unsigned long +#endif +#ifndef uint +#define uint unsigned int +#endif + +using RSlic::priv::aSize; +using namespace RSlic::Voxel; + + +struct RSlic::Voxel::Slic3::Settings { + Settings() : __refcount(0), step(0), stiffness(0) { + } + + Settings(const Settings *other) : + __refcount(0), step(other->step), distFunc(other->distFunc), pool(other->pool), + img(other->img), stiffness(other->stiffness), gradFunc(other->gradFunc) { + } + + void initThread(int threadcount = -1) { + if (threadcount <= 0) + threadcount = std::thread::hardware_concurrency(); + pool = std::make_shared(threadcount); + } + + ~Settings() { + } + + MovieCacheP img; + int step; + int stiffness; + shared_ptr pool; + DistanceFunc distFunc; + GradFunc gradFunc; + + std::atomic __refcount; +}; + +template +Slic3P RSlic::Voxel::Slic3::iterate(F f) const { + return iterate(setting->stiffness, f); +} + +namespace RSlic { + namespace Voxel { + namespace priv { +/* See RSlic2_impl.h for more information + */ + template + struct DistNormal { + inline double operator()(const Vec3i &point, const Vec3i ¢er, int clusterIdx) { + return f(point, center, img, stiffness * stiffness, step); + } + + const RSlic::Voxel::MovieCacheP img; + F f; + int stiffness; + int step; + }; + } + } +} +namespace { + /* + See RSlic2_impl.h for more information + */ + struct BRect { + static constexpr uint imax = std::numeric_limits::max(); + struct point { + uint x; + uint y; + uint z; + }; + point topFrontLeft, bottomBackRight; + + BRect(uint tx, uint ty, uint tz, uint bx, uint by, uint bz) + : topFrontLeft{tx, ty, tz}, bottomBackRight{bx, by, bz} { + } + + BRect() : topFrontLeft{imax, imax, imax}, bottomBackRight{0, 0, 0} { + } + + void combineWith(const BRect &other) { + topFrontLeft.x = std::min(topFrontLeft.x, other.topFrontLeft.x); + topFrontLeft.y = std::min(topFrontLeft.y, other.topFrontLeft.y); + topFrontLeft.z = std::min(topFrontLeft.z, other.topFrontLeft.z); + bottomBackRight.x = std::max(bottomBackRight.x, other.bottomBackRight.x); + bottomBackRight.y = std::max(bottomBackRight.y, other.bottomBackRight.y); + bottomBackRight.z = std::max(bottomBackRight.z, other.bottomBackRight.z); + } + }; +} +namespace RSlic { + namespace Voxel { + namespace priv { + struct iterateCommonRes { + Mat_ label; + Mat_ dist; + + iterateCommonRes(const cv::Mat::MSize &size) : label(3, size, -1), dist(3, size, DINF) { + } + + inline double &distAt(int y, int x, int t) { + return dist.at(y, x, t); + } + + inline ClusterInt &labelAt(int y, int x, int t) { + return label.at(y, x, t); + } + +#ifdef PARALLEL + BRect calcRect; +#endif + }; + + using iterateCommonResP = unique_ptr; + } + } +} +namespace { + template + inline RSlic::Voxel::priv::iterateCommonResP iterateCommonIteration(F f, int beg, int end, const cv::Mat::MSize &size, const vector ¢ers, int s, ThreadPoolP pool) { + RSlic::Voxel::priv::iterateCommonResP result(new RSlic::Voxel::priv::iterateCommonRes(size)); + const int w = size[1]; + const int h = size[0]; + const int duration = size[2]; + for (int k = beg; k < end; k++) { + auto center = centers[k]; + int px = center[0]; + int py = center[1]; + int pt = center[2]; +#ifdef PARALLEL + BRect currentRect(std::max(0, px - s), std::max(0, py - s), std::max(0, pt - s), + std::min(w, px + s + 1), std::min(h, py + s + 1), std::min(duration, pt + s + 1)); + result->calcRect.combineWith(currentRect); +#endif + for (int x = std::max(0, px - s); x < std::min(w, px + s + 1); x++) { + for (int y = std::max(0, py - s); y < std::min(h, py + s + 1); y++) { + for (int t = std::max(0, pt - s); t < std::min(duration, pt + s + 1); t++) { + Vec3i point(x, y, t); + double &d = result->distAt(y, x, t); + double D = f(point, center, k); + if (D < d) { + d = D; + result->labelAt(y, x, t) = k; + } + } + } + } + } + return result; + } + +#ifndef PARALLEL + +//See RSlic2_impl.cpp + template + RSlic::Voxel::priv::iterateCommonResP iterateCommon(F f, const ClusterSet3 &clusters, int s, ThreadPoolP pool) { + auto &&size = clusters.getClusterLabel().size; + auto centers = clusters.getCenters(); + int N = centers.size(); + return iterateCommonIteration(f, 0, N, size, centers, s, pool); + } + +#else + + //See RSlic2_impl.cpp + template + RSlic::Voxel::priv::iterateCommonResP iterateCommon(F f, const ClusterSet3 &clusters, int s, ThreadPoolP pool) { + auto &&size = clusters.getClusterLabel().size; + auto centers = clusters.getCenters(); + RSlic::Voxel::priv::iterateCommonResP result(new RSlic::Voxel::priv::iterateCommonRes(size)); + int N = centers.size(); + int thread_step = N / pool->threadcount(); + std::vector> futures; + futures.reserve(pool->threadcount()); + //Map + for (int thread_start = 0; thread_start < N; thread_start += thread_step) { + futures.push_back(pool->enqueue([&](int start) { + return iterateCommonIteration(f, start, std::min(start + thread_step, N), size, centers, s, pool); + }, thread_start)); + } + //Reduce + for (auto &&fut: futures) { + auto &&thread_result = fut.get(); + for (int x = thread_result->calcRect.topFrontLeft.x; x < thread_result->calcRect.bottomBackRight.x; x++) { + for (int y = thread_result->calcRect.topFrontLeft.y; y < thread_result->calcRect.bottomBackRight.y; y++) { + for (int t = thread_result->calcRect.topFrontLeft.z; t < thread_result->calcRect.bottomBackRight.z; t++) { + double dist_thread = thread_result->distAt(y, x, t); + double &dist_result = result->distAt(y, x, t); + if (dist_thread < dist_result) { + dist_result = dist_thread; + result->labelAt(y, x, t) = thread_result->labelAt(y, x, t); + } + } + } + } + } + return result; + } + +#endif +} + +template +Slic3P RSlic::Voxel::Slic3::iterate(int stiffness, F f) const { + const int s = setting->step; + + //Set up the normal Slic version + RSlic::Voxel::priv::DistNormal distF{setting->img, f, setting->stiffness, s}; + auto res = ::iterateCommon>(distF, clusters, s, setting->pool); + + //create a new instance + Settings *newSetting = setting; + if (setting->stiffness != stiffness) { + newSetting = new Settings(setting); + newSetting->stiffness = stiffness; + } + Slic3 *result = new Slic3(newSetting, ClusterSet3(res->label, clusters.getCenters().size()), res->dist); + return shared_ptr(result); +} + +namespace { + template + inline void iterateZeroUpdate3( + const MovieCacheP &img, const Mat &label, + const vector ¢ers, vector &max_dist_color, std::shared_ptr pool) { + int w = img->width(); + int h = img->height(); + int d = img->duration(); + //Update Slico distance maxima +#ifdef PARALLEL + std::vector> results; + results.reserve(pool->threadcount()); + int step = w / pool->threadcount(); + for (int x = 0; x < w; x += step) { + results.push_back(pool->enqueue([&](int xx) { + for (int x = xx; x < std::min(xx + step, w); x++) { +#else + for (int x = 0; x < w; x++) { +#endif + for (int y = 0; y < h; y++) { + for (int t = 0; t < d; t++) { + RSlic::Voxel::ClusterInt nearest_segment = label.at(y, x, t); + if (nearest_segment == -1) continue; + auto point = centers[nearest_segment]; + int py = point[1]; + int px = point[0]; + int pt = point[2]; + auto distColor = RSlic::priv::zero::zeroMetrik(img->at(y, x, t), img->at(py, px, pt)); + if (max_dist_color.at(nearest_segment) < distColor) { + max_dist_color.at(nearest_segment) = distColor; + } + } + } +#ifdef PARALLEL + } + }, x)); +#endif + } +#ifdef PARALLEL + for (auto &res: results) {res.get();} +#endif + } + + declareCVF_T(iterateZeroUpdate3, iterateZeroUpdate3Helper, return) +} +namespace RSlic { + namespace Voxel { + namespace priv { + //See RSlic2_impl.cpp + template + struct DistZero { + inline double operator()(const Vec3i &point, const Vec3i ¢er, int clusterIdx) { + return f(point, center, img, max_distance[clusterIdx], step); + } + + const RSlic::Voxel::MovieCacheP img; + F f; + const vector &max_distance; + int step; + }; + } + } +} + +template +Slic3P RSlic::Voxel::Slic3::iterateZero(F f) const { + const int s = setting->step; + //Set up Slico + Voxel::priv::DistZero distF{setting->img, f, max_dist_color, s}; + auto res = ::iterateCommon>(distF, clusters, s, setting->pool); + + //update max_dist_color + ClusterSet3 newClusters(res->label, clusters.getCenters().size()); + vector new_max_dist_color(max_dist_color); + ::iterateZeroUpdate3Helper(setting->img->type(), setting->img, res->label, newClusters.getCenters(), new_max_dist_color, setting->pool); + //creating a new instance + Slic3 *result = new Slic3(setting, std::move(newClusters), res->dist); + result->max_dist_color = std::move(new_max_dist_color); + return shared_ptr(result); +} + +template +Slic3P RSlic::Voxel::Slic3::finalize(F f) const { + int w = setting->img->width(); + int h = setting->img->height(); + int d = setting->img->duration(); + int *size = setting->img->sizeArray(); + Mat_ finalClusters(3, size, -1); + delete size; + int currentLabel = 0; + const int lims = setting->step * setting->step * setting->step;// (h * w * d) / (clusters.clusterCount()); + static const int neighboursX[] = {-1, 0, 1, 0, -1, 1, 1, -1, 0, 0};//{1, 0, 0, -1, 0, 0}; + static const int neighboursY[aSize(neighboursX)] = {0, -1, 0, 1, -1, -1, 1, 1, 0, 0};//{0, 1, 0, 0, -1, 0}; + static const int neighboursZ[aSize(neighboursX)] = {0, 0, 0, 0, 0, 0, 0, 0, -1, 1};//{0, 0, 1, 0, 0, -1}; + + for (int x = 0; x < w; x++) { + for (int y = 0; y < h; y++) { + for (int t = 0; t < d; t++) { + //Some unassigned pixel? + if (finalClusters.at(y, x, t) == -1) { + vector current_points; + current_points.emplace_back(x, y, t); + finalClusters.at(y, x, t) = currentLabel; + + //Look transitive for all unassigned neighbors + //set them in current_points and finalCluster + for (int i = 0; i < current_points.size(); i++) { + Vec3i point = current_points[i]; + for (int neighbour = 0; neighbour < aSize(neighboursX); neighbour++) { + int px = point[0] + neighboursX[neighbour]; + int py = point[1] + neighboursY[neighbour]; + int pt = point[2] + neighboursZ[neighbour]; + if (px < 0 || px >= w || py < 0 || py >= h || pt < 0 || pt >= d) continue; + if (finalClusters.at(py, px, pt) == -1 + && clusters.at(y, x, t) == clusters.at(py, px, pt)) { + current_points.emplace_back(px, py, pt); + finalClusters.at(py, px, pt) = currentLabel; + } + } + } + + //If there are not enough pixel in the cluster + //look for the best in the environment and conjoin both + if (current_points.size() <= lims >> 2) { + int adjlabel = currentLabel; + double topdist = DINF; + + for (int neighbour = 0; neighbour < aSize(neighboursX); neighbour++) { + int px = x + neighboursX[neighbour]; + int py = y + neighboursY[neighbour]; + int pt = t + neighboursZ[neighbour]; + if (px < 0 || px >= w || py < 0 || py >= h || pt < 0 || pt >= d) continue; + ClusterInt label = finalClusters.at(py, px, pt); + if (label >= 0 && label != currentLabel) { + double dist = f(Vec3i(x, y, t), Vec3i(px, py, pt), setting->img, 1, setting->step); + if (dist < topdist) { + adjlabel = label; + topdist = dist; + } + } + } + //Set pixel to this neighbor + for (const Vec3i point: current_points) { + finalClusters.at(point[1], point[0], point[2]) = adjlabel; + } + } else currentLabel++; + } + } + } + } + + Slic3 *result = new Slic3(setting, ClusterSet3(finalClusters, currentLabel), distance); + return std::shared_ptr(result); +} + +#endif // RSlic3_IMPL_H diff --git a/lib/priv/Useful.h b/lib/priv/Useful.h new file mode 100644 index 0000000..448c87e --- /dev/null +++ b/lib/priv/Useful.h @@ -0,0 +1,133 @@ +#ifndef USEFUL_H +#define USEFUL_H +#include +namespace RSlic{ +namespace priv{ + + /** + * Returns the size of an array (compile-time) + */ + template + constexpr std::size_t aSize(T(&)[N]) noexcept { return N;} + + + template + struct cvtp{using type= int;}; //Default + template <> + struct cvtp{using type= int8_t;}; + template <> + struct cvtp{using type= cv::Vec;}; + template <> + struct cvtp{using type= cv::Vec;}; + template <> + struct cvtp{using type= cv::Vec;}; + template <> + struct cvtp{using type= uint8_t;}; + template <> + struct cvtp{using type= cv::Vec2b;}; + template <> + struct cvtp{using type= cv::Vec3b;}; + template <> + struct cvtp{using type= cv::Vec4b;}; + template <> + struct cvtp{using type=uint16_t;}; + template <> + struct cvtp{using type=cv::Vec2w;}; + template <> + struct cvtp{using type=cv::Vec3w;}; + template <> + struct cvtp{using type=cv::Vec4w;}; + template <> + struct cvtp{using type=int16_t;}; + template <> + struct cvtp{using type=cv::Vec2s;}; + template <> + struct cvtp{using type=cv::Vec3s;}; + template <> + struct cvtp{using type=cv::Vec4s;}; + template <> + struct cvtp{using type=int32_t;}; + template <> + struct cvtp{using type=cv::Vec;}; + template <> + struct cvtp{using type=cv::Vec;}; + template <> + struct cvtp{using type=cv::Vec;}; + template <> + struct cvtp{using type=float;}; + template <> + struct cvtp{using type=cv::Vec2f;}; + template <> + struct cvtp{using type=cv::Vec3f;}; + template <> + struct cvtp{using type=cv::Vec4f;}; + template <> + struct cvtp{using type=double;}; + template <> + struct cvtp{using type=cv::Vec2d;}; + template <> + struct cvtp{using type=cv::Vec3d;}; + template <> + struct cvtp{using type=cv::Vec4d;}; +} +} + +// Creates function which calls f with the right template argument based on the type +// f -> template Function, ff -> name of new function, def -> comes after default in switch(type){....; default: def} +#define declareCVF_T(f,ff,def)\ + template \ + inline auto ff(int type, T&&... params) -> typename std::result_of)&(T...)>::type{\ + using namespace RSlic::priv;\ + static_assert(sizeof(float) * CHAR_BIT == 32,"Float Size != 32 Bit");\ + static_assert(sizeof(double) * CHAR_BIT == 64,"Double Size != 64 Bit");\ + switch(type){\ + case CV_8UC1: return f::type>(std::forward(params)...);\ + case CV_8UC2: return f::type>(std::forward(params)...);\ + case CV_8UC3: return f::type>(std::forward(params)...);\ + case CV_8UC4: return f::type>(std::forward(params)...);\ + case CV_8SC1: return f::type>(std::forward(params)...);\ + case CV_8SC2: return f::type>(std::forward(params)...);\ + case CV_8SC3: return f::type>(std::forward(params)...);\ + case CV_8SC4: return f::type>(std::forward(params)...);\ + case CV_16UC1: return f::type>(std::forward(params)...);\ + case CV_16UC2: return f::type>(std::forward(params)...);\ + case CV_16UC3: return f::type>(std::forward(params)...);\ + case CV_16UC4: return f::type>(std::forward(params)...);\ + case CV_16SC1: return f::type>(std::forward(params)...);\ + case CV_16SC2: return f::type>(std::forward(params)...);\ + case CV_16SC3: return f::type>(std::forward(params)...);\ + case CV_16SC4: return f::type>(std::forward(params)...);\ + case CV_32SC1: return f::type>(std::forward(params)...);\ + case CV_32SC2: return f::type>(std::forward(params)...);\ + case CV_32SC3: return f::type>(std::forward(params)...);\ + case CV_32SC4: return f::type>(std::forward(params)...);\ + case CV_32FC1: return f::type>(std::forward(params)...);\ + case CV_32FC2: return f::type>(std::forward(params)...);\ + case CV_32FC3: return f::type>(std::forward(params)...);\ + case CV_32FC4: return f::type>(std::forward(params)...);\ + case CV_64FC1: return f::type>(std::forward(params)...);\ + case CV_64FC2: return f::type>(std::forward(params)...);\ + case CV_64FC3: return f::type>(std::forward(params)...);\ + case CV_64FC4: return f::type>(std::forward(params)...);\ + default: def;\ + }} + +// Same as declareCVF_T, but does not use the depth. +#define declareCVF_D(f,ff,d)\ + template \ + inline auto ff(int type, T&&... params) -> typename std::result_of)&(T...)>::type{\ + using namespace RSlic::priv;\ + static_assert(sizeof(float) * CHAR_BIT == 32,"Float Size != 32 Bit");\ + static_assert(sizeof(double) * CHAR_BIT == 64,"Double Size != 64 Bit");\ + switch(type){\ + case CV_8U: return f::type>(std::forward(params)...);\ + case CV_8S: return f::type>(std::forward(params)...);\ + case CV_16U: return f::type>(std::forward(params)...);\ + case CV_16S: return f::type>(std::forward(params)...);\ + case CV_32S: return f::type>(std::forward(params)...);\ + case CV_32F: return f::type>(std::forward(params)...);\ + case CV_64F: return f::type>(std::forward(params)...);\ + default: d;\ + }} + +#endif // USEFUL_H diff --git a/lib/priv/ZeroSlico_p.h b/lib/priv/ZeroSlico_p.h new file mode 100644 index 0000000..8796094 --- /dev/null +++ b/lib/priv/ZeroSlico_p.h @@ -0,0 +1,27 @@ +#ifndef ZEROSLICO_P_H +#define ZEROSLICO_P_H +#include +#include +namespace RSlic{ +namespace priv { + namespace zero { + + template + inline uint64_t zeroMetrik(T first, T second) { + static_assert(std::is_arithmetic::value==true,"Need arithmetic type in zeroMetrik"); + return pow(first - second, 2); + } + + template + inline uint64_t zeroMetrik(const Vec &first, const Vec &second) { + static_assert(std::is_arithmetic::value==true,"Need arithmetic type in zeroMetrik"); + uint64_t res = 0; + for (int i = 0; i < n; i++) { + res += pow(first[i] - second[i], 2); + } + return res; + } + } +} +} +#endif diff --git a/lib/rslic-config.cmake b/lib/rslic-config.cmake new file mode 100644 index 0000000..7c5d538 --- /dev/null +++ b/lib/rslic-config.cmake @@ -0,0 +1,17 @@ +include(CheckCXXCompilerFlag) +CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11) +CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X) + +if(COMPILER_SUPPORTS_CXX11) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") +elseif(COMPILER_SUPPORTS_CXX0X) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x") +else() + message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.") +endif() + +find_package( OpenCV REQUIRED ) +get_filename_component(SELF_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) +include(${SELF_DIR}/rslic-target.cmake) +get_filename_component(RSLIC_INCLUDE_DIRS "${SELF_DIR}/../../include/RSlic" ABSOLUTE) +SET(RSLIC_LIB rslic ${OpenCV_LIBS})