diff --git a/3rdparty/LICENSE.libcuckoo b/3rdparty/LICENSE.libcuckoo new file mode 100644 index 000000000..9e29b39d8 --- /dev/null +++ b/3rdparty/LICENSE.libcuckoo @@ -0,0 +1,18 @@ +Copyright (C) 2013, Carnegie Mellon University and Intel Corporation + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +--------------------------- + +The third-party libraries have their own licenses, as detailed in their source +files. \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 4bbf0fa4c..ce74e111b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,16 @@ +# cuCIM 21.06.00 (9 Jun 2021) + +## 🐛 Bug Fixes + +- Update `update-vesion.sh` ([#42](https://github.com/rapidsai/cucim/pull/42)) [@ajschmidt8](https://github.com/ajschmidt8) + +## 🛠️ Impovements + +- Update envionment vaiable used to detemine `cuda_vesion` ([#43](https://github.com/rapidsai/cucim/pull/43)) [@ajschmidt8](https://github.com/ajschmidt8) +- Update vesion scipt to emove bump2vesion dependency ([#41](https://github.com/rapidsai/cucim/pull/41)) [@gigony](https://github.com/gigony) +- Update changelog ([#40](https://github.com/rapidsai/cucim/pull/40)) [@ajschmidt8](https://github.com/ajschmidt8) +- Update docs build scipt ([#39](https://github.com/rapidsai/cucim/pull/39)) [@ajschmidt8](https://github.com/ajschmidt8) + # cuCIM 0.19.0 (15 Apr 2021) Initial release of cuCIM including cuClaraImage and [cupyimg](https://github.com/mritools/cupyimg). diff --git a/CMakeLists.txt b/CMakeLists.txt index 06ac08c85..861e6cd37 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -105,6 +105,7 @@ include(ExternalProject) ################################################################################ option(CUCIM_SUPPORT_GDS "Support cufile library" OFF) option(CUCIM_STATIC_GDS "Use static cufile library" OFF) +option(CUCIM_SUPPORT_CUDA "Support CUDA" ON) # Setup CXX11 ABI # : Adds CXX11 ABI definition to the compiler command line for targets in the current directory, @@ -124,6 +125,8 @@ superbuild_depend(openslide) superbuild_depend(catch2) superbuild_depend(cli11) superbuild_depend(json) +superbuild_depend(libcuckoo) +superbuild_depend(boost-header-only) ################################################################################ # Define some names diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 867d38920..334caf926 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -58,18 +58,17 @@ The following instructions are for developers and contributors to cuCIM OSS deve #### Python -cuCIM uses [Black](https://black.readthedocs.io/en/stable/), -[isort](https://readthedocs.org/projects/isort/), and +cuCIM uses [isort](https://readthedocs.org/projects/isort/), and [flake8](http://flake8.pycqa.org/en/latest/) to ensure a consistent code format -throughout the project. `Black`, `isort`, and `flake8` can be installed with +throughout the project. `isort`, and `flake8` can be installed with `conda` or `pip`: ```bash -conda install black isort flake8 +conda install isort flake8 ``` ```bash -pip install black isort flake8 +pip install isort flake8 ``` These tools are used to auto-format the Python code in the repository. Additionally, there is a CI check in place to enforce @@ -78,7 +77,6 @@ automatically format your python code by running: ```bash isort --atomic python/**/*.py -black python ``` ### Get libcucim Dependencies @@ -145,3 +143,9 @@ cp -P python/install/lib/* python/cucim/src/cucim/clara/ cd python/cucim/ python -m pip install . ``` + +For contributors interested in working on the Python code from an in-place +(editable) installation, replace the last line above with +```bash +python -m pip install --editable . +``` diff --git a/Cache Example.ipynb b/Cache Example.ipynb new file mode 100644 index 000000000..ae686fabd --- /dev/null +++ b/Cache Example.ipynb @@ -0,0 +1,531 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "69aeee77", + "metadata": {}, + "outputs": [], + "source": [ + "from cucim import CuImage\n", + "from cucim.clara.cache import calc_preferred_cache_memory\n", + "\n", + "img = CuImage(\"notebooks/input/image.tif\")\n", + "memory_capacity = calc_preferred_cache_memory(img, (256, 256))\n", + "CuImage.cache(\"per_process\", memory_capacity=memory_capacity, record_stat=True)\n", + "#CuImage.cache(\"per_process\", memory_capacity=2048, record_stat=True)\n", + "\n", + "region = img.read_region((0,0), (100,100))\n", + "\n", + "cache = CuImage.cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f2121d1b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'type': 'per_process',\n", + " 'memory_capacity': 2048,\n", + " 'capacity': 5461,\n", + " 'mutex_pool_capacity': 11117,\n", + " 'list_padding': 10000,\n", + " 'extra_shared_memory_size': 100,\n", + " 'record_stat': True}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cache.config" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fbea8f0a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cache hit: 0, chche miss: 1\n" + ] + } + ], + "source": [ + "print(f\"cache hit: {cache.hit_count}, chche miss: {cache.miss_count}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0f60842a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cache hit: 1, chche miss: 1\n", + "items in cache: 1/5461, memory usage in cache: 196608/2147483648\n" + ] + } + ], + "source": [ + "region = img.read_region((0,0), (100,100))\n", + "\n", + "print(f\"cache hit: {cache.hit_count}, chche miss: {cache.miss_count}\")\n", + "print(f\"items in cache: {cache.size}/{cache.capacity}, memory usage in cache: {cache.memory_size}/{cache.memory_capacity}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5453dbcc", + "metadata": {}, + "outputs": [], + "source": [ + "from cucim import CuImage\n", + "img = CuImage(\"notebooks/input/image.tif\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "059d8ba3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['__bool__',\n", + " '__class__',\n", + " '__delattr__',\n", + " '__dict__',\n", + " '__dir__',\n", + " '__doc__',\n", + " '__eq__',\n", + " '__format__',\n", + " '__ge__',\n", + " '__getattribute__',\n", + " '__gt__',\n", + " '__hash__',\n", + " '__init__',\n", + " '__init_subclass__',\n", + " '__le__',\n", + " '__lt__',\n", + " '__module__',\n", + " '__ne__',\n", + " '__new__',\n", + " '__reduce__',\n", + " '__reduce_ex__',\n", + " '__repr__',\n", + " '__setattr__',\n", + " '__sizeof__',\n", + " '__str__',\n", + " '__subclasshook__',\n", + " '_set_array_interface',\n", + " 'associated_image',\n", + " 'associated_images',\n", + " 'cache',\n", + " 'channel_names',\n", + " 'coord_sys',\n", + " 'device',\n", + " 'dims',\n", + " 'direction',\n", + " 'dtype',\n", + " 'is_loaded',\n", + " 'metadata',\n", + " 'ndim',\n", + " 'origin',\n", + " 'path',\n", + " 'raw_metadata',\n", + " 'read_region',\n", + " 'resolutions',\n", + " 'save',\n", + " 'shape',\n", + " 'size',\n", + " 'spacing',\n", + " 'spacing_units']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dir(img._C)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "895db3d2", + "metadata": {}, + "outputs": [], + "source": [ + "from cucim import CuImage\n", + "\n", + "img = CuImage(\"notebooks/input/image.tif\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1800de44", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "430 ns ± 4.64 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "\n", + "img.is_loaded" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3a85c7ff", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "177 ns ± 1.51 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "img._C.is_loaded" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a3872e46", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing ./dist/cucim-0.19.1.dev2-py3-none-manylinux2014_x86_64.whl\n", + "Collecting numpy\n", + " Using cached numpy-1.20.3-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (15.4 MB)\n", + "Collecting click\n", + " Using cached click-8.0.1-py3-none-any.whl (97 kB)\n", + "Installing collected packages: numpy, click, cucim\n", + " Attempting uninstall: numpy\n", + " Found existing installation: numpy 1.20.3\n", + " Uninstalling numpy-1.20.3:\n", + " Successfully uninstalled numpy-1.20.3\n", + " Attempting uninstall: click\n", + " Found existing installation: click 8.0.1\n", + " Uninstalling click-8.0.1:\n", + " Successfully uninstalled click-8.0.1\n", + " Attempting uninstall: cucim\n", + " Found existing installation: cucim 0.19.1.dev2\n", + " Uninstalling cucim-0.19.1.dev2:\n", + " Successfully uninstalled cucim-0.19.1.dev2\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "rasterio 1.2.3 requires click<8,>=4.0, but you have click 8.0.1 which is incompatible.\n", + "cligj 0.7.1 requires click<8,>=4.0, but you have click 8.0.1 which is incompatible.\u001b[0m\n", + "Successfully installed click-8.0.1 cucim-0.19.1.dev2 numpy-1.20.3\n", + "\u001b[33mWARNING: You are using pip version 21.0.1; however, version 21.1.2 is available.\n", + "You should consider upgrading via the '/home/gbae/.virtualenvs/cucim/bin/python -m pip install --upgrade pip' command.\u001b[0m\n" + ] + }, + { + "data": { + "text/plain": [ + "['__bool__',\n", + " '__class__',\n", + " '__delattr__',\n", + " '__dict__',\n", + " '__dir__',\n", + " '__doc__',\n", + " '__eq__',\n", + " '__format__',\n", + " '__ge__',\n", + " '__getattribute__',\n", + " '__gt__',\n", + " '__hash__',\n", + " '__init__',\n", + " '__init_subclass__',\n", + " '__le__',\n", + " '__lt__',\n", + " '__module__',\n", + " '__ne__',\n", + " '__new__',\n", + " '__reduce__',\n", + " '__reduce_ex__',\n", + " '__repr__',\n", + " '__setattr__',\n", + " '__sizeof__',\n", + " '__str__',\n", + " '__subclasshook__',\n", + " '_set_array_interface',\n", + " 'associated_image',\n", + " 'associated_images',\n", + " 'cache',\n", + " 'channel_names',\n", + " 'coord_sys',\n", + " 'device',\n", + " 'dims',\n", + " 'direction',\n", + " 'dtype',\n", + " 'is_loaded',\n", + " 'metadata',\n", + " 'ndim',\n", + " 'origin',\n", + " 'path',\n", + " 'raw_metadata',\n", + " 'read_region',\n", + " 'resolutions',\n", + " 'save',\n", + " 'shape',\n", + " 'size',\n", + " 'spacing',\n", + " 'spacing_units']" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "!pip install --force-reinstall dist/*.whl\n", + "\n", + "dir(img)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5ec0b0d6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "161 ns ± 0.967 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "\n", + "img.is_loaded" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "fcc68767", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on method read_region in module cucim.clara._cucim:\n", + "\n", + "read_region(...) method of cucim.clara.CuImage instance\n", + " read_region(self: cucim.clara._cucim.CuImage, location: List[int] = [], size: List[int] = [], level: int = 0, device: cucim.clara._cucim.io.Device = cpu, buf: object = None, shm_name: str = '', **kwargs) -> object\n", + " \n", + " Returns a subresolution image.\n", + " \n", + " - `location` and `size`'s dimension order is reverse of image's dimension order.\n", + " - Need to specify (X,Y) and (Width, Height) instead of (Y,X) and (Height, Width).\n", + " - If location is not specified, location would be (0, 0) if Z=0. Otherwise, location would be (0, 0, 0)\n", + " - Like OpenSlide, location is level-0 based coordinates (using the level-0 reference frame)\n", + " - If `size` is not specified, size would be (width, height) of the image at the specified `level`.\n", + " - `` Additional parameters (S,T,C,Z) are similar to\n", + " \n", + " - We may not want to support indices/ranges for (S,T,C,Z) for the first release.\n", + " - Default value for level, S, T, Z are zero.\n", + " - Default value for C is -1 (whole channels)\n", + " - `` `device` could be one of the following strings or Device object: e.g., `'cpu'`, `'cuda'`, `'cuda:0'` (use index 0), `cucim.clara.io.Device(cucim.clara.io.CUDA,0)`.\n", + " - `` If `buf` is specified (buf's type can be either numpy object that implements `__array_interface__`, or cupy-compatible object that implements `__cuda_array_interface__`), the read image would be saved into buf object without creating CPU/GPU memory.\n", + " - `` If `shm_name` is specified, shared memory would be created and data would be read in the shared memory.\n", + "\n" + ] + } + ], + "source": [ + "help(img.read_region)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3397aa75", + "metadata": {}, + "outputs": [], + "source": [ + "from cucim import CuImage\n", + "img = CuImage(\"notebooks/input/image.tif\")\n", + "region = img.read_region((1000,1000), (100, 100))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e9595d38", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from PIL import Image\n", + "import numpy as np\n", + "Image.fromarray(np.asarray(region))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "de9a4771", + "metadata": {}, + "outputs": [], + "source": [ + "import cupy as cp\n", + "\n", + "region_cupy = img.read_region((1000,1000), (100, 100), device='cuda')\n", + "vis = cp.asarray(region_cupy)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5a932ac8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Image.fromarray(vis.get())" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "4098b771", + "metadata": {}, + "outputs": [], + "source": [ + "del vis" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "aac6a6fe", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'data': (46733280, False),\n", + " 'strides': None,\n", + " 'descr': [('', '|u1')],\n", + " 'typestr': '|u1',\n", + " 'shape': (10, 10, 3),\n", + " 'version': 3}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b.__array_interface__" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a836258a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: cupy-cuda112 in /home/gbae/.virtualenvs/cucim/lib/python3.8/site-packages (9.0.0)\n", + "Requirement already satisfied: numpy>=1.17 in /home/gbae/.virtualenvs/cucim/lib/python3.8/site-packages (from cupy-cuda112) (1.20.3)\n", + "Requirement already satisfied: fastrlock>=0.5 in /home/gbae/.virtualenvs/cucim/lib/python3.8/site-packages (from cupy-cuda112) (0.6)\n", + "\u001b[33mWARNING: You are using pip version 21.0.1; however, version 21.1.2 is available.\n", + "You should consider upgrading via the '/home/gbae/.virtualenvs/cucim/bin/python -m pip install --upgrade pip' command.\u001b[0m\n" + ] + } + ], + "source": [ + "!pip install cupy-cuda112" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/LICENSE-3rdparty.md b/LICENSE-3rdparty.md index fc899b5be..339840398 100644 --- a/LICENSE-3rdparty.md +++ b/LICENSE-3rdparty.md @@ -231,3 +231,9 @@ libdeflate - https://github.com/ebiggers/libdeflate/blob/master/COPYING - Copyright: Eric Biggers - Usage: Extracting tile image (zlib/deflate compressed)for TIFF file (@cuslide plugin) + +libcuckoo +- License: Apache-2.0 License + - https://github.com/efficient/libcuckoo/blob/master/LICENSE +- Copyright: Carnegie Mellon University and Intel Corporation +- Usage: Using concurrent hash table implementation for cache mechanism. diff --git a/README.md b/README.md index ac0e70447..98bf06c56 100644 --- a/README.md +++ b/README.md @@ -8,6 +8,8 @@ - [GTC 2021 cuCIM: A GPU Image I/O and Processing Toolkit [S32194]](https://www.nvidia.com/en-us/gtc/catalog/?search=cuCIM#/) - [video](https://gtc21.event.nvidia.com/media/cuCIM%3A%20A%20GPU%20Image%20I_O%20and%20Processing%20Toolkit%20%5BS32194%5D/1_fwfxd0iu) +**Release notes** are available on our [wiki page](https://github.com/rapidsai/cucim/wiki/Release-Notes). + ## Install cuCIM ### Conda @@ -28,7 +30,7 @@ ### Notebooks -Please check out our [Welcome](notebooks/Welcome.ipynb) notebook. +Please check out our [Welcome](notebooks/Welcome.ipynb) notebook ([NBViewer](https://nbviewer.jupyter.org/github/rapidsai/cucim/blob/branch-21.06/notebooks/Welcome.ipynb)) #### Downloading sample images diff --git a/VERSION b/VERSION index 1cf0537c3..caccd4086 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.19.0 +21.06.00 diff --git a/benchmarks/main.cpp b/benchmarks/main.cpp index c280a3f44..e3e920436 100644 --- a/benchmarks/main.cpp +++ b/benchmarks/main.cpp @@ -93,7 +93,7 @@ static void test_openslide(benchmark::State& state) state.ResumeTiming(); openslide_t* slide = openslide_open(g_config.input_file.c_str()); - uint32_t* buf = (uint32_t*)cucim_malloc(state.range(0) * state.range(0) * 4); + uint32_t* buf = static_cast(cucim_malloc(state.range(0) * state.range(0) * 4)); int64_t request_location[2] = { 0, 0 }; if (g_config.random_start_location) { diff --git a/benchmarks/primitives.cpp b/benchmarks/primitives.cpp index 49d8d8960..cd47efea7 100644 --- a/benchmarks/primitives.cpp +++ b/benchmarks/primitives.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -160,7 +160,7 @@ static void alloc_pmr(benchmark::State& state) char* arr[30000]; for (int i = 0; i < 30000; i++) { - arr[i] = (char*)cucim_malloc(10); + arr[i] = static_cast(cucim_malloc(10)); arr[i][0] = i; } for (int i = 0; i < 30000; i++) diff --git a/ci/checks/style.sh b/ci/checks/style.sh index 21eb536e2..a52ef4e71 100644 --- a/ci/checks/style.sh +++ b/ci/checks/style.sh @@ -18,7 +18,7 @@ conda activate rapids cd python/cucim # Run isort and get results/return code -ISORT=`isort --recursive --check-only python` +ISORT=`isort --check-only src` ISORT_RETVAL=$? # Run black and get results/return code diff --git a/ci/cpu/build.sh b/ci/cpu/build.sh index 58ff101c8..cf1a4f18d 100755 --- a/ci/cpu/build.sh +++ b/ci/cpu/build.sh @@ -47,9 +47,7 @@ env gpuci_logger "Activate conda env" . /opt/conda/etc/profile.d/conda.sh - - -conda install -c conda-forge conda-build +conda activate rapids gpuci_logger "Check versions" python --version @@ -75,8 +73,7 @@ conda config --set ssl_verify False # /opt/conda/envs/rapids/lib if [ "$BUILD_LIBCUCIM" == 1 ]; then - gpuci_conda_retry build -c conda-forge/label/cupy_rc -c conda-forge -c rapidsai-nightly \ - --python=${PYTHON_VER} \ + gpuci_conda_retry build -c conda-forge -c rapidsai-nightly \ --dirty \ --no-remove-work-dir \ --no-build-id \ @@ -92,7 +89,7 @@ if [ "$BUILD_CUCIM" == 1 ]; then # Set libcucim conda build folder for CPU build export LIBCUCIM_BLD_PATH=${WORKSPACE}/ci/artifacts/cucim/cpu/.conda-bld - gpuci_conda_retry build -c ${LIBCUCIM_BLD_PATH} -c conda-forge/label/cupy_rc -c conda-forge -c rapidsai-nightly \ + gpuci_conda_retry build -c ${LIBCUCIM_BLD_PATH} -c conda-forge -c rapidsai-nightly \ --python=${PYTHON_VER} \ --dirty \ --no-remove-work-dir \ diff --git a/ci/cpu/upload_anaconda.sh b/ci/cpu/upload_anaconda.sh index d18eb4c4b..cc199e8ce 100755 --- a/ci/cpu/upload_anaconda.sh +++ b/ci/cpu/upload_anaconda.sh @@ -39,10 +39,10 @@ gpuci_logger "Starting conda uploads" if [[ "$BUILD_LIBCUCIM" == "1" ]]; then gpuci_logger "Upload libcuCIM" - gpuci_retry anaconda -t ${MY_UPLOAD_KEY} upload -u ${CONDA_USERNAME:-rapidsai} ${LABEL_OPTION} --skip-existing ${LIBCUCIM_FILE} + gpuci_retry anaconda -t ${MY_UPLOAD_KEY} upload -u ${CONDA_USERNAME:-rapidsai} ${LABEL_OPTION} --skip-existing ${LIBCUCIM_FILE} --no-progress fi if [[ "$BUILD_CUCIM" == "1" ]]; then gpuci_logger "Upload cuCIM" - gpuci_retry anaconda -t ${MY_UPLOAD_KEY} upload -u ${CONDA_USERNAME:-rapidsai} ${LABEL_OPTION} --skip-existing ${CUCIM_FILE} + gpuci_retry anaconda -t ${MY_UPLOAD_KEY} upload -u ${CONDA_USERNAME:-rapidsai} ${LABEL_OPTION} --skip-existing ${CUCIM_FILE} --no-progress fi diff --git a/ci/docs/build.sh b/ci/docs/build.sh index e1b559e39..24fe4ee82 100644 --- a/ci/docs/build.sh +++ b/ci/docs/build.sh @@ -14,7 +14,6 @@ export DOCS_WORKSPACE=$WORKSPACE/docs export PATH=/opt/conda/bin:/usr/local/cuda/bin:$PATH export HOME=$WORKSPACE export PROJECT_WORKSPACE=/rapids/cucim -export NIGHTLY_VERSION=$(echo $BRANCH_VERSION | awk -F. '{print $2}') export PROJECTS=(cucim) gpuci_logger "Check environment" @@ -25,14 +24,11 @@ nvidia-smi gpuci_logger "Activate conda env" . /opt/conda/etc/profile.d/conda.sh +conda activate rapids gpuci_logger "Installing cuCIM / Deps / Docs into new env" -gpuci_conda_retry create -n cucim -y -c conda-forge -c conda-forge/label/cupy_rc -c rapidsai-nightly \ +gpuci_conda_retry install -y -c rapidsai-nightly \ rapids-doc-env \ - python=3.8 \ - conda-forge/label/cupy_rc::cupy=9 \ - cudatoolkit=11.2 \ - scikit-image=0.18.1 \ cucim conda activate cucim diff --git a/ci/gpu/build.sh b/ci/gpu/build.sh index c561f9e2c..5f0f59494 100755 --- a/ci/gpu/build.sh +++ b/ci/gpu/build.sh @@ -7,6 +7,8 @@ set -e NUMARGS=$# ARGS=$* +set -x + # apt-get install libnuma libnuma-dev # Arg parsing function @@ -25,6 +27,7 @@ export HOME=$WORKSPACE cd $WORKSPACE export GIT_DESCRIBE_TAG=`git describe --abbrev=0 --tags` export MINOR_VERSION=`echo $GIT_DESCRIBE_TAG | grep -o -E '([0-9]+\.[0-9]+)'` +echo "MINOR_VERSION: ${MINOR_VERSION}" # Get CUDA and Python version export CUDA_VERSION=${CUDA_VERSION:-$(cat /usr/local/cuda/version.txt | egrep -o "[[:digit:]]+.[[:digit:]]+.[[:digit:]]+")} @@ -46,14 +49,17 @@ nvidia-smi gpuci_logger "Activate conda env" . /opt/conda/etc/profile.d/conda.sh +conda activate rapids -conda install -c conda-forge conda-build -y +gpuci_logger "Install dependencies" +gpuci_conda_retry install -y -c rapidsai-nightly \ + "cudatoolkit=${CUDA_VER}.*" \ + "rapids-build-env=$MINOR_VERSION.*" ################################################################################ # BUILD - Build cuCIM ################################################################################ -# We don't use 'rapids' conda environment here. # To use 'conda-forge'-based package installation and to use 'Project Flash' feature, # we fake conda build folder for libcucim to '$WORKSPACE/ci/artifacts/cucim/cpu/conda-bld/' which is # conda build folder for CPU build. @@ -63,8 +69,7 @@ CUCIM_BLD_PATH=/opt/conda/envs/rapids/conda-bld mkdir -p ${CUCIM_BLD_PATH} -gpuci_conda_retry build -c ${LIBCUCIM_BLD_PATH} -c conda-forge/label/cupy_rc -c conda-forge -c rapidsai-nightly \ - --python=${PYTHON_VER} \ +gpuci_conda_retry build -c ${LIBCUCIM_BLD_PATH} -c conda-forge -c rapidsai-nightly \ --dirty \ --no-remove-work-dir \ --croot ${CUCIM_BLD_PATH} \ @@ -76,31 +81,14 @@ gpuci_conda_retry build -c ${LIBCUCIM_BLD_PATH} -c conda-forge/label/cupy_rc -c ################################################################################ # Install cuCIM and its dependencies -gpuci_logger "Install cuCIM and its dependencies" - -gpuci_logger "Install dependencies" -gpuci_conda_retry create -n cucim -y -c conda-forge -c conda-forge/label/cupy_rc -c rapidsai-nightly \ - rapids-doc-env \ - flake8 \ - pytest \ - pytest-cov \ - python=${PYTHON_VER} \ - conda-forge/label/cupy_rc::cupy=9 \ - cudatoolkit=${CUDA_VER} \ - numpy \ - scipy \ - scikit-image=0.18.1 \ - openslide - -conda activate cucim - -gpuci_logger "Installing cuCIM" -gpuci_conda_retry install -y -c ${LIBCUCIM_BLD_PATH} -c ${CUCIM_BLD_PATH} \ +gpuci_logger "Installing cuCIM and its dependencies" +gpuci_conda_retry install -y -c ${LIBCUCIM_BLD_PATH} -c ${CUCIM_BLD_PATH} -c rapidsai-nightly \ + "rapids-build-env=$MINOR_VERSION.*" \ libcucim \ cucim gpuci_logger "Testing cuCIM import" -python -c 'import cucim' +python -c 'import cucim' gpuci_logger "Check versions" python --version diff --git a/ci/release/update-version.sh b/ci/release/update-version.sh index f0bd8c7e9..4cde16922 100755 --- a/ci/release/update-version.sh +++ b/ci/release/update-version.sh @@ -4,55 +4,40 @@ ######################### ## Usage -# bash update-version.sh -# where is either `major`, `minor`, `patch` - -set -e - -# Grab argument for release type -RELEASE_TYPE=$1 - -# Get current version and calculate next versions -CURRENT_TAG=`git tag | grep -xE 'v[0-9\.]+' | sort --version-sort | tail -n 1 | tr -d 'v'` -CURRENT_MAJOR=`echo $CURRENT_TAG | awk '{split($0, a, "."); print a[1]}'` -CURRENT_MINOR=`echo $CURRENT_TAG | awk '{split($0, a, "."); print a[2]}'` -CURRENT_PATCH=`echo $CURRENT_TAG | awk '{split($0, a, "."); print a[3]}'` -NEXT_MAJOR=$((CURRENT_MAJOR + 1)) -NEXT_MINOR=$((CURRENT_MINOR + 1)) -NEXT_PATCH=$((CURRENT_PATCH + 1)) +# bash update-version.sh + + +# Format is YY.MM.PP - no leading 'v' or trailing 'a' +NEXT_FULL_TAG=$1 + +# Get current version +CURRENT_TAG=$(git tag --merged HEAD | grep -xE '^v.*' | sort --version-sort | tail -n 1 | tr -d 'v') +CURRENT_MAJOR=$(echo $CURRENT_TAG | awk '{split($0, a, "."); print a[1]}') +CURRENT_MINOR=$(echo $CURRENT_TAG | awk '{split($0, a, "."); print a[2]}') +CURRENT_PATCH=$(echo $CURRENT_TAG | awk '{split($0, a, "."); print a[3]}' | tr -d 'a') CURRENT_SHORT_TAG=${CURRENT_MAJOR}.${CURRENT_MINOR} -NEXT_FULL_TAG="" -NEXT_SHORT_TAG="" - -# Determine release type -if [ "$RELEASE_TYPE" == "major" ]; then - NEXT_FULL_TAG="${NEXT_MAJOR}.0.0" - NEXT_SHORT_TAG="${NEXT_MAJOR}.0" -elif [ "$RELEASE_TYPE" == "minor" ]; then - NEXT_FULL_TAG="${CURRENT_MAJOR}.${NEXT_MINOR}.0" - NEXT_SHORT_TAG="${CURRENT_MAJOR}.${NEXT_MINOR}" -elif [ "$RELEASE_TYPE" == "patch" ]; then - NEXT_FULL_TAG="${CURRENT_MAJOR}.${CURRENT_MINOR}.${NEXT_PATCH}" - NEXT_SHORT_TAG="${CURRENT_MAJOR}.${CURRENT_MINOR}" -else - echo "Incorrect release type; use 'major', 'minor', or 'patch' as an argument" - exit 1 -fi - -echo "Preparing '$RELEASE_TYPE' release [$CURRENT_TAG -> $NEXT_FULL_TAG]" +CURRENT_LONG_TAG=${CURRENT_MAJOR}.${CURRENT_MINOR}.${CURRENT_PATCH} + +#Get . for next version +NEXT_MAJOR=$(echo $NEXT_FULL_TAG | awk '{split($0, a, "."); print a[1]}') +NEXT_MINOR=$(echo $NEXT_FULL_TAG | awk '{split($0, a, "."); print a[2]}') +NEXT_SHORT_TAG=${NEXT_MAJOR}.${NEXT_MINOR} + +echo "Preparing release $CURRENT_TAG => $NEXT_FULL_TAG" # Inplace sed replace; workaround for Linux and Mac function sed_runner() { sed -i.bak ''"$1"'' $2 && rm -f ${2}.bak } - -# Update version-related files using bump2version -# (Need to execute this before other version updates because this command -# would checks if the git repository is dirty or not) -./run bump_version ${RELEASE_TYPE} - # RTD update sed_runner 's/version = .*/version = '"'${NEXT_SHORT_TAG}'"'/g' docs/source/conf.py sed_runner 's/release = .*/release = '"'${NEXT_FULL_TAG}'"'/g' docs/source/conf.py +sed_runner "s/${CURRENT_LONG_TAG}/${NEXT_FULL_TAG}/g" VERSION +sed_runner "s/${CURRENT_LONG_TAG}/${NEXT_FULL_TAG}/g" python/cucim/VERSION +sed_runner "s/${CURRENT_LONG_TAG}/${NEXT_FULL_TAG}/g" cpp/plugins/cucim.kit.cuslide/VERSION +sed_runner "s#\[Version ${CURRENT_LONG_TAG}\](release_notes/v${CURRENT_LONG_TAG}.md)#\[Version ${NEXT_FULL_TAG}\](release_notes/v${NEXT_FULL_TAG}.md)#g" python/cucim/docs/index.md +sed_runner "s/v${CURRENT_LONG_TAG}/v${NEXT_FULL_TAG}/g" python/cucim/docs/getting_started/index.md +sed_runner "s#cucim.kit.cuslide@${CURRENT_LONG_TAG}.so#cucim.kit.cuslide@${NEXT_FULL_TAG}.so#g" python/cucim/docs/getting_started/index.md +sed_runner "s#cucim.kit.cuslide@${CURRENT_LONG_TAG}.so#cucim.kit.cuslide@${NEXT_FULL_TAG}.so#g" cucim.code-workspace diff --git a/conda/environments/env.yml b/conda/environments/env.yml index 1d461f3ed..6b7191a15 100644 --- a/conda/environments/env.yml +++ b/conda/environments/env.yml @@ -1,9 +1,8 @@ name: cucim channels: - - conda-forge/label/cupy_rc - conda-forge dependencies: - - conda-forge/label/cupy_rc::cupy=9.0.0b3 + - cupy=9 - scikit-image=0.18.1 - openslide - zlib @@ -20,7 +19,5 @@ dependencies: - cmake - automake - make - - gcc_linux-64=9 - - compilers - click - yasm # [x86_64] diff --git a/conda/recipes/cucim/build.sh b/conda/recipes/cucim/build.sh index b9fabc4ca..6755ce257 100644 --- a/conda/recipes/cucim/build.sh +++ b/conda/recipes/cucim/build.sh @@ -3,6 +3,7 @@ CUCIM_BUILD_TYPE=${CUCIM_BUILD_TYPE:-release} echo "Current Folder: ${SRC_DIR}" +echo "CUDA: ${CUDA}" echo "CUDA_VERSION: ${CUDA_VERSION}" echo "PYTHON: ${PYTHON}" diff --git a/conda/recipes/cucim/conda_build_config.yaml b/conda/recipes/cucim/conda_build_config.yaml new file mode 100644 index 000000000..6cae16046 --- /dev/null +++ b/conda/recipes/cucim/conda_build_config.yaml @@ -0,0 +1,4 @@ +c_compiler_version: + - 9 +cxx_compiler_version: + - 9 diff --git a/conda/recipes/cucim/meta.yaml b/conda/recipes/cucim/meta.yaml index cb41249db..0751863f9 100644 --- a/conda/recipes/cucim/meta.yaml +++ b/conda/recipes/cucim/meta.yaml @@ -4,7 +4,7 @@ {% set minor_version = version.split('.')[0] + '.' + version.split('.')[2] %} {% set py_version=environ.get('CONDA_PY', 37) %} {% set python_version=environ.get('PYTHON_VER', '3.7') %} -{% set cuda_version='.'.join(environ.get('CUDA_VERSION', '11.0').split('.')[:2]) %} +{% set cuda_version='.'.join(environ.get('CUDA', '11.0').split('.')[:2]) %} package: name: cucim @@ -16,18 +16,24 @@ source: build: number: {{ GIT_DESCRIBE_NUMBER }} string: cuda_{{ cuda_version }}_py{{ py_version }}_{{ GIT_DESCRIBE_HASH }}_{{ GIT_DESCRIBE_NUMBER }} + script_env: + - CC + - CXX + - CUDAHOSTCXX requirements: build: - cmake >=3.18.0 + - {{ compiler("c") }} - {{ compiler("cxx") }} + - sysroot_linux-64 2.17 host: - cudatoolkit {{ cuda_version }}.* - python {{ python_version }}.* - libcucim {{ version }}.* - click - - conda-forge/label/cupy_rc::cupy=9 - - numpy + - cupy 9.* + - numpy >=1.17.0 - scipy - scikit-image 0.18.1 run: @@ -35,8 +41,8 @@ requirements: - python {{ python_version }}.* - libcucim {{ version }}.* - click - - conda-forge/label/cupy_rc::cupy=9 - - numpy + - cupy 9.* + - {{ pin_compatible('numpy') }} - scipy - scikit-image 0.18.1 # - openslide # skipping here but benchmark binary would needs openslide library diff --git a/conda/recipes/libcucim/conda_build_config.yaml b/conda/recipes/libcucim/conda_build_config.yaml new file mode 100644 index 000000000..6cae16046 --- /dev/null +++ b/conda/recipes/libcucim/conda_build_config.yaml @@ -0,0 +1,4 @@ +c_compiler_version: + - 9 +cxx_compiler_version: + - 9 diff --git a/conda/recipes/libcucim/meta.yaml b/conda/recipes/libcucim/meta.yaml index a23cdd882..475f4bb5a 100644 --- a/conda/recipes/libcucim/meta.yaml +++ b/conda/recipes/libcucim/meta.yaml @@ -3,7 +3,7 @@ {% set version = environ.get('GIT_DESCRIBE_TAG', '0.0.0.dev').lstrip('v') + environ.get('VERSION_SUFFIX', '') %} {% set minor_version = version.split('.')[0] + '.' + version.split('.')[1] %} {% set python_version=environ.get('PYTHON_VER', '3.7') %} -{% set cuda_version='.'.join(environ.get('CUDA_VERSION', '11.0').split('.')[:2]) %} +{% set cuda_version='.'.join(environ.get('CUDA', '11.0').split('.')[:2]) %} package: name: libcucim @@ -19,7 +19,9 @@ build: requirements: build: - cmake >=3.18.0 + - {{ compiler("c") }} - {{ compiler("cxx") }} + - sysroot_linux-64 2.17 - yasm # [x86_64] host: - cudatoolkit {{ cuda_version }}.* @@ -45,4 +47,4 @@ about: license: Apache-2.0 license_family: Apache license_file: LICENSE - summary: libcucim C++ library \ No newline at end of file + summary: libcucim C++ library diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt index c09127c51..7bef1f7e3 100644 --- a/cpp/CMakeLists.txt +++ b/cpp/CMakeLists.txt @@ -38,28 +38,48 @@ endif() add_library(${CUCIM_PACKAGE_NAME} src/core/framework.cpp include/cucim/cuimage.h + include/cucim/cache/image_cache.h + include/cucim/cache/image_cache_config.h + include/cucim/cache/image_cache_manager.h include/cucim/codec/base64.h + include/cucim/codec/hash_function.h include/cucim/codec/methods.h + include/cucim/config/config.h include/cucim/core/framework.h include/cucim/core/plugin.h include/cucim/core/plugin_util.h include/cucim/core/interface.h include/cucim/core/version.h + include/cucim/cpp20/find_if.h include/cucim/dynlib/helper.h include/cucim/filesystem/cufile_driver.h include/cucim/filesystem/file_handle.h include/cucim/filesystem/file_path.h include/cucim/io/device.h + include/cucim/io/device_type.h include/cucim/io/format/image_format.h include/cucim/logger/logger.h include/cucim/logger/timer.h include/cucim/macros/defines.h include/cucim/memory/dlpack.h include/cucim/memory/memory_manager.h + include/cucim/util/cuda.h + include/cucim/util/file.h include/cucim/3rdparty/dlpack/dlpack.h include/cucim/3rdparty/dlpack/dlpackcpp.h src/cuimage.cpp + src/cache/cache_type.cpp + src/cache/image_cache.cpp + src/cache/image_cache_config.cpp + src/cache/image_cache_empty.h + src/cache/image_cache_empty.cpp + src/cache/image_cache_manager.cpp + src/cache/image_cache_per_process.h + src/cache/image_cache_per_process.cpp + src/cache/image_cache_shared_memory.h + src/cache/image_cache_shared_memory.cpp src/codec/base64.cpp + src/config/config.cpp src/core/cucim_framework.h src/core/cucim_framework.cpp src/core/cucim_plugin.h @@ -68,11 +88,14 @@ add_library(${CUCIM_PACKAGE_NAME} src/core/plugin_manager.cpp src/core/version.inl src/filesystem/cufile_driver.cpp + src/filesystem/file_handle.cpp src/io/device.cpp + src/io/device_type.cpp src/io/format/image_format.cpp src/logger/logger.cpp src/logger/timer.cpp - src/memory/memory_manager.cu) + src/memory/memory_manager.cu + src/util/file.cpp) # Compile options set_target_properties(${CUCIM_PACKAGE_NAME} @@ -109,6 +132,7 @@ target_compile_definitions(${CUCIM_PACKAGE_NAME} CUCIM_VERSION_BUILD=${PROJECT_VERSION_BUILD} CUCIM_SUPPORT_GDS=$ CUCIM_STATIC_GDS=$ + CUCIM_SUPPORT_CUDA=$ _GLIBCXX_USE_CXX11_ABI=0 # TODO: create two library, one with CXX11 ABI and one without it. ) @@ -127,6 +151,9 @@ target_link_libraries(${CUCIM_PACKAGE_NAME} PRIVATE deps::abseil deps::gds + deps::libcuckoo + deps::boost-header-only + deps::json ) if (CUCIM_STATIC_GDS) @@ -164,6 +191,7 @@ target_compile_definitions(${CUCIM_PACKAGE_NAME}-header-only CUCIM_VERSION_BUILD=${PROJECT_VERSION_BUILD} CUCIM_SUPPORT_GDS=$ CUCIM_STATIC_GDS=$ + CUCIM_SUPPORT_CUDA=$ CUCIM_HEADER_ONLY=1 ) target_compile_features(${CUCIM_PACKAGE_NAME}-header-only INTERFACE ${CUCIM_REQUIRED_FEATURES}) diff --git a/cpp/cmake/deps/boost-header-only.cmake b/cpp/cmake/deps/boost-header-only.cmake new file mode 100644 index 000000000..67624a201 --- /dev/null +++ b/cpp/cmake/deps/boost-header-only.cmake @@ -0,0 +1,70 @@ +# +# Copyright (c) 2021, NVIDIA CORPORATION. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +if (NOT TARGET deps::boost-header-only) + set(Boost_VERSION 1.75.0) + set(boost_component_list "interprocess" "config" "intrusive" "move" "assert" "static_assert" "container" "core" "date_time" "smart_ptr" "throw_exception" "utility" "type_traits" "numeric/conversion" "mpl" "preprocessor" "container_hash" "integer" "detail") + FetchContent_Declare( + deps-boost-header-only + GIT_REPOSITORY https://github.com/boostorg/boost.git + GIT_TAG boost-${Boost_VERSION} + GIT_SHALLOW TRUE + ) + + FetchContent_GetProperties(deps-boost-header-only) + if (NOT deps-boost-header-only_POPULATED) + message(STATUS "Fetching boost-header-only sources") + FetchContent_Populate(deps-boost-header-only) + message(STATUS "Fetching boost-header-only sources - done") + + message(STATUS "Applying patch for boost-header-only") + find_package(Git) + if(Git_FOUND OR GIT_FOUND) + execute_process( + COMMAND bash -c "${GIT_EXECUTABLE} reset HEAD --hard && ${GIT_EXECUTABLE} apply ${CMAKE_CURRENT_LIST_DIR}/boost-header-only.patch" + WORKING_DIRECTORY "${deps-boost-header-only_SOURCE_DIR}/libs/interprocess" + RESULT_VARIABLE exec_result + ERROR_VARIABLE exec_error + ERROR_STRIP_TRAILING_WHITESPACE + OUTPUT_VARIABLE exec_output + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if(exec_result EQUAL 0) + message(STATUS "Applying patch for boost-header-only - done") + else() + message(STATUS "Applying patch for boost-header-only - failed") + message(FATAL_ERROR "${exec_output}\n${exec_error}") + endif() + endif () + endif () + + add_library(deps::boost-header-only INTERFACE IMPORTED GLOBAL) + + unset(boost_include_string) + # Create a list of components + foreach(item IN LISTS boost_component_list) + set(boost_include_string "${boost_include_string}" "${deps-boost-header-only_SOURCE_DIR}/libs/${item}/include") + endforeach(item) + # https://www.boost.org/doc/libs/1_75_0/doc/html/interprocess.html#interprocess.intro.introduction_building_interprocess + set_target_properties(deps::boost-header-only PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES + "${boost_include_string}" + INTERFACE_COMPILE_DEFINITIONS + BOOST_DATE_TIME_NO_LIB=1 + ) + + set(deps-boost-header-only_SOURCE_DIR ${deps-boost-header-only_SOURCE_DIR} CACHE INTERNAL "" FORCE) + mark_as_advanced(deps-boost-header-only_SOURCE_DIR) +endif () diff --git a/cpp/cmake/deps/boost-header-only.patch b/cpp/cmake/deps/boost-header-only.patch new file mode 100644 index 000000000..e765790f0 --- /dev/null +++ b/cpp/cmake/deps/boost-header-only.patch @@ -0,0 +1,17 @@ +diff --git a/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp b/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp +index 7da31f7..5816de7 100644 +--- a/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp ++++ b/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp +@@ -692,7 +692,11 @@ inline T* rbtree_best_fit:: + void* raw_reuse = reuse; + void* const ret = priv_allocation_command(command, limit_size, prefer_in_recvd_out_size, raw_reuse, sizeof(T)); + reuse = static_cast(raw_reuse); +- BOOST_ASSERT(0 == ((std::size_t)ret % ::boost::container::dtl::alignment_of::value)); ++ // [cuCIM patch] Ignore assert (ret value is not 64-byte-aligned) so not ++ // throw assertion failure when used with libcuckoo. This is not well tested. ++ // ++ // See https://github.com/boostorg/interprocess/issues/50 ++ //BOOST_ASSERT(0 == ((std::size_t)ret % ::boost::container::dtl::alignment_of::value)); + return static_cast(ret); + } + diff --git a/cpp/cmake/deps/boost.cmake b/cpp/cmake/deps/boost.cmake index 721ebcd0b..558740e1e 100644 --- a/cpp/cmake/deps/boost.cmake +++ b/cpp/cmake/deps/boost.cmake @@ -1,5 +1,5 @@ # -# Copyright (c) 2020, NVIDIA CORPORATION. +# Copyright (c) 2020-2021, NVIDIA CORPORATION. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -14,7 +14,7 @@ # if (NOT TARGET deps::boost) - set(Boost_VERSION 1.73.0) + set(Boost_VERSION 1.75.0) set(Boost_BUILD_COMPONENTS container) set(Boost_BUILD_OPTIONS "threading=multi cxxflags=-fPIC runtime-link=static variant=release link=static address-model=64 --layout=system") set(Boost_COMPILE_DEFINITIONS @@ -57,7 +57,7 @@ if (NOT TARGET deps::boost) endif() endif() - find_package(Boost 1.73 CONFIG REQUIRED COMPONENTS ${Boost_BUILD_COMPONENTS} + find_package(Boost 1.75 CONFIG REQUIRED COMPONENTS ${Boost_BUILD_COMPONENTS} HINTS ${deps-boost_BINARY_DIR}/install) # /lib/cmake/Boost-${Boost_VERSION} message(STATUS "Boost version: ${Boost_VERSION}") diff --git a/cpp/cmake/deps/libcuckoo.cmake b/cpp/cmake/deps/libcuckoo.cmake new file mode 100644 index 000000000..78e53252a --- /dev/null +++ b/cpp/cmake/deps/libcuckoo.cmake @@ -0,0 +1,65 @@ +# Apache License, Version 2.0 +# Copyright 2021 NVIDIA Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +if (NOT TARGET deps::libcuckoo) + FetchContent_Declare( + deps-libcuckoo + GIT_REPOSITORY https://github.com/efficient/libcuckoo + GIT_TAG v0.3 + GIT_SHALLOW TRUE + ) + FetchContent_GetProperties(deps-libcuckoo) + if (NOT deps-libcuckoo_POPULATED) + message(STATUS "Fetching libcuckoo sources") + FetchContent_Populate(deps-libcuckoo) + message(STATUS "Fetching libcuckoo sources - done") + + message(STATUS "Applying patch for libcuckoo") + find_package(Git) + if(Git_FOUND OR GIT_FOUND) + execute_process( + COMMAND bash -c "${GIT_EXECUTABLE} reset HEAD --hard && ${GIT_EXECUTABLE} apply ${CMAKE_CURRENT_LIST_DIR}/libcuckoo.patch" + WORKING_DIRECTORY "${deps-libcuckoo_SOURCE_DIR}" + RESULT_VARIABLE exec_result + ERROR_VARIABLE exec_error + ERROR_STRIP_TRAILING_WHITESPACE + OUTPUT_VARIABLE exec_output + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if(exec_result EQUAL 0) + message(STATUS "Applying patch for libcuckoo - done") + else() + message(STATUS "Applying patch for libcuckoo - failed") + message(FATAL_ERROR "${exec_output}\n${exec_error}") + endif() + endif () + endif () + + # Create static library + cucim_set_build_shared_libs(OFF) + add_subdirectory(${deps-libcuckoo_SOURCE_DIR} ${deps-libcuckoo_BINARY_DIR} EXCLUDE_FROM_ALL) + # libcuckoo's CMakeLists.txt is not compatible with `add_subdirectory` method (it uses ${CMAKE_SOURCE_DIR} instead of ${CMAKE_CURRENT_SOURCE_DIR}) + # so add include directories explicitly. + target_include_directories(libcuckoo INTERFACE + $ + ) + + cucim_restore_build_shared_libs() + + add_library(deps::libcuckoo INTERFACE IMPORTED GLOBAL) + target_link_libraries(deps::libcuckoo INTERFACE libcuckoo) + set(deps-libcuckoo_SOURCE_DIR ${deps-libcuckoo_SOURCE_DIR} CACHE INTERNAL "" FORCE) + mark_as_advanced(deps-libcuckoo_SOURCE_DIR) +endif () \ No newline at end of file diff --git a/cpp/cmake/deps/libcuckoo.patch b/cpp/cmake/deps/libcuckoo.patch new file mode 100644 index 000000000..831b63f18 --- /dev/null +++ b/cpp/cmake/deps/libcuckoo.patch @@ -0,0 +1,31 @@ +diff --git a/libcuckoo/cuckoohash_map.hh b/libcuckoo/cuckoohash_map.hh +index 88f1f43..a36c273 100644 +--- a/libcuckoo/cuckoohash_map.hh ++++ b/libcuckoo/cuckoohash_map.hh +@@ -24,6 +24,10 @@ + #include + #include + ++// [cuCIM patch] Include boost interprocess vector/list. ++#include ++#include ++ + #include "cuckoohash_config.hh" + #include "cuckoohash_util.hh" + #include "bucket_container.hh" +@@ -841,8 +845,13 @@ private: + using rebind_alloc = + typename std::allocator_traits::template rebind_alloc; + +- using locks_t = std::vector>; +- using all_locks_t = std::list>; ++ // [cuCIM patch] Use boost::interprocess vector and list for using shared ++ // memory with Boost's interprocess module. This is not a portable solution. ++ // ++ // See [cuCIM patch] https://github.com/efficient/libcuckoo/issues/111 ++ // ++ using locks_t = boost::interprocess::vector>; ++ using all_locks_t = boost::interprocess::list>; + + // Classes for managing locked buckets. By storing and moving around sets of + // locked buckets in these classes, we can ensure that they are unlocked diff --git a/cpp/include/cucim/cache/cache_type.h b/cpp/include/cucim/cache/cache_type.h new file mode 100644 index 000000000..1877b8945 --- /dev/null +++ b/cpp/include/cucim/cache/cache_type.h @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CUCIM_CACHE_CACHE_TYPE_H +#define CUCIM_CACHE_CACHE_TYPE_H + +#include "cucim/macros/api_header.h" + +#include +#include +#include + +namespace cucim::cache +{ + +constexpr std::size_t kCacheTypeCount = 3; +enum class CacheType : uint8_t +{ + kNoCache, + kPerProcess, + kSharedMemory +}; + +// Using constexpr map (https://www.youtube.com/watch?v=INn3xa4pMfg) +struct CacheTypeMap +{ + std::array, kCacheTypeCount> data; + + [[nodiscard]] constexpr CacheType at(const std::string_view& key) const; +}; + +EXPORT_VISIBLE CacheType lookup_cache_type(const std::string_view sv); + +struct CacheTypeStrMap +{ + std::array, kCacheTypeCount> data; + + [[nodiscard]] constexpr std::string_view at(const CacheType& key) const; +}; + +EXPORT_VISIBLE std::string_view lookup_cache_type_str(const CacheType type); + + +} // namespace cucim::cache + +#endif // CUCIM_CACHE_CACHE_TYPE_H diff --git a/cpp/include/cucim/cache/image_cache.h b/cpp/include/cucim/cache/image_cache.h new file mode 100644 index 000000000..f8824be7b --- /dev/null +++ b/cpp/include/cucim/cache/image_cache.h @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CUCIM_CACHE_IMAGE_CACHE_H +#define CUCIM_CACHE_IMAGE_CACHE_H + +#include "cucim/core/framework.h" + +#include "cucim/cache/cache_type.h" +#include "cucim/cache/image_cache_config.h" + +#include +#include +#include + +#include +#include +#include + +namespace cucim::cache +{ + +struct EXPORT_VISIBLE ImageCacheKey +{ + ImageCacheKey(uint64_t file_hash, uint64_t index); + + uint64_t file_hash = 0; /// st_dev + st_ino + st_mtime + ifd_index + uint64_t location_hash = 0; /// tile_index or (x , y) +}; + +struct EXPORT_VISIBLE ImageCacheValue +{ + ImageCacheValue(void* data, uint64_t size, void* user_obj = nullptr); + virtual ~ImageCacheValue(){}; + + operator bool() const; + + void* data = nullptr; + uint64_t size = 0; + void* user_obj = nullptr; +}; + +/** + * @brief Image Cache for loading tiles. + * + * FIFO is used for cache replacement policy here. + * + */ + +class EXPORT_VISIBLE ImageCache : public std::enable_shared_from_this +{ +public: + ImageCache(const ImageCacheConfig& config, CacheType type = CacheType::kNoCache); + virtual ~ImageCache(){}; + + virtual CacheType type() const; + virtual const char* type_str() const; + virtual ImageCacheConfig& config(); + virtual ImageCacheConfig get_config() const; + + /** + * @brief Create a key object for the image cache. + * + * @param file_hash An hash value used for a specific file. + * @param index An hash value to locate a specific index/coordination in the image. + * @return std::shared_ptr A shared pointer containing %ImageCacheKey. + */ + virtual std::shared_ptr create_key(uint64_t file_hash, uint64_t index) = 0; + virtual std::shared_ptr create_value(void* data, uint64_t size) = 0; + + virtual void* allocate(std::size_t n) = 0; + + virtual void lock(uint64_t index) = 0; + virtual void unlock(uint64_t index) = 0; + + virtual bool insert(std::shared_ptr& key, std::shared_ptr& value) = 0; + + virtual uint32_t size() const = 0; + virtual uint64_t memory_size() const = 0; + + virtual uint32_t capacity() const = 0; + virtual uint64_t memory_capacity() const = 0; + virtual uint64_t free_memory() const = 0; + + /** + * @brief Record cache stat. + * + * Stat values would be reset with this method. + * + * @param value Whether if cache stat would be recorded or not + */ + virtual void record(bool value) = 0; + + /** + * @brief Return whether if cache stat is recorded or not + * + * @return true if cache stat is recorded. false otherwise + */ + virtual bool record() const = 0; + + virtual uint64_t hit_count() const = 0; + virtual uint64_t miss_count() const = 0; + + /** + * @brief Attempt to preallocate enough memory for specified number of elements and memory size. + * + * This method is not thread-safe. + * + * @param capacity Number of elements required + * @param memory_capacity Size of memory required in bytes + */ + virtual void reserve(const ImageCacheConfig& config) = 0; + + virtual std::shared_ptr find(const std::shared_ptr& key) = 0; + +protected: + CacheType type_ = CacheType::kNoCache; + ImageCacheConfig config_; +}; + +} // namespace cucim::cache + +#endif // CUCIM_CACHE_IMAGE_CACHE_H diff --git a/cpp/include/cucim/cache/image_cache_config.h b/cpp/include/cucim/cache/image_cache_config.h new file mode 100644 index 000000000..3553c2452 --- /dev/null +++ b/cpp/include/cucim/cache/image_cache_config.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CUCIM_CACHE_IMAGE_CACHE_CONFIG_H +#define CUCIM_CACHE_IMAGE_CACHE_CONFIG_H + +#include "cucim/core/framework.h" + +#include "cucim/cache/cache_type.h" + +namespace cucim::cache +{ + +constexpr uint64_t kOneMiB = 1024UL * 1024; +constexpr std::string_view kDefaultCacheTypeStr = "nocache"; +constexpr CacheType kDefaultCacheType = cucim::cache::CacheType::kNoCache; +constexpr uint64_t kDefaultCacheMemoryCapacity = 1024UL; +constexpr uint32_t kDefaultCacheMutexPoolCapacity = 11117; +constexpr uint32_t kDefaultCacheListPadding = 10000; +constexpr uint32_t kDefaultCacheExtraSharedMemorySize = 100; +constexpr bool kDefaultCacheRecordStat = false; +// Assume that user uses memory block whose size is least 256 x 256 x 3 bytes. +constexpr uint32_t calc_default_cache_capacity(uint64_t memory_capacity_in_bytes) +{ + return memory_capacity_in_bytes / (256UL * 256 * 3); +} + +struct EXPORT_VISIBLE ImageCacheConfig +{ + void load_config(const void* json_obj); + + CacheType type = CacheType::kNoCache; + uint32_t memory_capacity = kDefaultCacheMemoryCapacity; + uint32_t capacity = calc_default_cache_capacity(kOneMiB * kDefaultCacheMemoryCapacity); + uint32_t mutex_pool_capacity = kDefaultCacheMutexPoolCapacity; + uint32_t list_padding = kDefaultCacheListPadding; + uint32_t extra_shared_memory_size = kDefaultCacheExtraSharedMemorySize; + bool record_stat = kDefaultCacheRecordStat; +}; + +} // namespace cucim::cache + +#endif // CUCIM_CACHE_IMAGE_CACHE_CONFIG_H diff --git a/cpp/include/cucim/cache/image_cache_manager.h b/cpp/include/cucim/cache/image_cache_manager.h new file mode 100644 index 000000000..b86a8629e --- /dev/null +++ b/cpp/include/cucim/cache/image_cache_manager.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CUCIM_CACHE_IMAGE_CACHE_MANAGER_H +#define CUCIM_CACHE_IMAGE_CACHE_MANAGER_H + +#include "cucim/core/framework.h" + +#include "cucim/cache/image_cache.h" + +namespace cucim::cache +{ + +constexpr uint32_t kDefaultTileSize = 256; +constexpr uint32_t kDefaultPatchSize = 256; + +uint32_t EXPORT_VISIBLE preferred_memory_capacity(const std::vector& image_size, + const std::vector& tile_size, + const std::vector& patch_size, + uint32_t bytes_per_pixel = 3); + +class EXPORT_VISIBLE ImageCacheManager +{ +public: + ImageCacheManager(); + + ImageCache& cache() const; + std::shared_ptr cache(const ImageCacheConfig& config); + std::shared_ptr get_cache() const; + void reserve(uint32_t new_memory_capacity); + void reserve(uint32_t new_memory_capacity, uint32_t new_capacity); + +private: + std::unique_ptr create_cache() const; + std::unique_ptr create_cache(const ImageCacheConfig& cache_config) const; + + std::shared_ptr cache_; +}; + +} // namespace cucim::cache + +#endif // CUCIM_CACHE_IMAGE_CACHE_MANAGER_H diff --git a/cpp/include/cucim/codec/hash_function.h b/cpp/include/cucim/codec/hash_function.h new file mode 100644 index 000000000..ff586ab1c --- /dev/null +++ b/cpp/include/cucim/codec/hash_function.h @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef CUCIM_HASH_FUNCTION_H +#define CUCIM_HASH_FUNCTION_H + +#include + +namespace cucim::codec +{ + +/** + * @brief splitmix64 hash function with three input values + * + * This function based on the code from https://xorshift.di.unimi.it/splitmix64.c which is released in the public + * domain (http://creativecommons.org/publicdomain/zero/1.0/). + * + * @param x input state value + * @return uint64_t + */ +inline uint64_t splitmix64(uint64_t x) +{ + + uint64_t z = (x += 0x9e3779b97f4a7c15); + z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9; + z = (z ^ (z >> 27)) * 0x94d049bb133111eb; + return z ^ (z >> 31); +} + +/** + * @brief splitmix64 hash function with three input values + * + * This function based on the code from https://xorshift.di.unimi.it/splitmix64.c which is released in the public + * domain (http://creativecommons.org/publicdomain/zero/1.0/). + * + * @param a + * @param b + * @param c + * @return uint64_t + */ +inline uint64_t splitmix64_3(uint64_t a, uint64_t b, uint64_t c) +{ + + uint64_t z = (a += 0x9e3779b97f4a7c15); + z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9; + z = (z ^ (z >> 27)) * 0x94d049bb133111eb; + z = z ^ (z >> 31); + + z += (b += 0x9e3779b97f4a7c15); + z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9; + z = (z ^ (z >> 27)) * 0x94d049bb133111eb; + z = z ^ (z >> 31); + + z += (c += 0x9e3779b97f4a7c15); + z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9; + z = (z ^ (z >> 27)) * 0x94d049bb133111eb; + z = z ^ (z >> 31); + + return z; +} + +} // namespace cucim::codec + +#endif // CUCIM_HASH_FUNCTION_H diff --git a/cpp/include/cucim/config/config.h b/cpp/include/cucim/config/config.h new file mode 100644 index 000000000..bc15aae18 --- /dev/null +++ b/cpp/include/cucim/config/config.h @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CUCIM_CONFIG_CONFIG_H +#define CUCIM_CONFIG_CONFIG_H + +#include "cucim/macros/api_header.h" +#include "cucim/cache/cache_type.h" +#include "cucim/cache/image_cache_config.h" + +#include +#include + +#include +#include + +namespace cucim::config +{ + +constexpr const char* kDefaultConfigFileName = ".cucim.json"; + +class EXPORT_VISIBLE Config +{ +public: + Config(); + + cucim::cache::ImageCacheConfig& cache(); + + std::string shm_name() const; + pid_t pid() const; + pid_t ppid() const; + pid_t pgid() const; + +private: + std::string get_config_path() const; + bool parse_config(std::string& path); + void set_default_configuration(); + + std::string source_path_; + + cucim::cache::ImageCacheConfig cache_; +}; + +} // namespace cucim::config + +#endif // CUCIM_CONFIG_CONFIG_H diff --git a/cpp/include/cucim/cpp20/find_if.h b/cpp/include/cucim/cpp20/find_if.h new file mode 100644 index 000000000..c046ef003 --- /dev/null +++ b/cpp/include/cucim/cpp20/find_if.h @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + + +namespace cucim::cpp20 +{ + +// https://en.cppreference.com/w/cpp/algorithm/find +#if __cplusplus < 202002L +template +constexpr InputIt find_if(InputIt first, InputIt last, UnaryPredicate p) +{ + for (; first != last; ++first) + { + if (p(*first)) + { + return first; + } + } + return last; +} +#else +template +constexpr InputIt find_if(InputIt first, InputIt last, UnaryPredicate p) +{ + return std::find_if(first, last, p); +} +#endif + +} \ No newline at end of file diff --git a/cpp/include/cucim/cuimage.h b/cpp/include/cucim/cuimage.h index b608c4a0c..9e4f0dcc1 100644 --- a/cpp/include/cucim/cuimage.h +++ b/cpp/include/cucim/cuimage.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,19 +17,21 @@ #ifndef CUCIM_CUIMAGE_H #define CUCIM_CUIMAGE_H -#include -#include -#include -#include -#include -#include - #include "cucim/core/framework.h" +#include "cucim/cache/image_cache_manager.h" +#include "cucim/config/config.h" #include "cucim/filesystem/file_path.h" #include "cucim/io/device.h" #include "cucim/io/format/image_format.h" #include "cucim/memory/dlpack.h" +#include +#include +#include +#include +#include +#include + namespace cucim { @@ -67,12 +69,15 @@ class EXPORT_VISIBLE ResolutionInfo std::vector level_dimension(uint16_t level) const; const std::vector& level_downsamples() const; float level_downsample(uint16_t level) const; + const std::vector& level_tile_sizes() const; + std::vector level_tile_size(uint16_t level) const; private: uint16_t level_count_; uint16_t level_ndim_; std::vector level_dimensions_; std::vector level_downsamples_; + std::vector level_tile_sizes_; }; /** @@ -105,6 +110,10 @@ class EXPORT_VISIBLE CuImage : public std::enable_shared_from_this } static Framework* get_framework(); + static config::Config* get_config(); + static cache::ImageCacheManager& cache_manager(); + static std::shared_ptr cache(); + static std::shared_ptr cache(cache::ImageCacheConfig& config); filesystem::Path path() const; @@ -142,16 +151,16 @@ class EXPORT_VISIBLE CuImage : public std::enable_shared_from_this memory::DLTContainer container() const; - CuImage read_region(std::vector location, - std::vector size, + CuImage read_region(std::vector&& location, + std::vector&& size, uint16_t level = 0, - DimIndices region_dim_indices = {}, - io::Device device = "cpu", + const DimIndices& region_dim_indices = {}, + const io::Device& device = "cpu", DLTensor* buf = nullptr, - std::string shm_name = std::string{}); + const std::string& shm_name = std::string{}) const; std::set associated_images() const; - CuImage associated_image(const std::string& name) const; + CuImage associated_image(const std::string& name, const io::Device& device = "cpu") const; void save(std::string file_path) const; @@ -162,12 +171,14 @@ class EXPORT_VISIBLE CuImage : public std::enable_shared_from_this explicit CuImage(); void ensure_init(); - bool crop_image(io::format::ImageMetadataDesc* metadata, - io::format::ImageReaderRegionRequestDesc* request, - io::format::ImageDataDesc* out_image_data) const; + bool crop_image(const io::format::ImageReaderRegionRequestDesc& request, + io::format::ImageDataDesc& out_image_data) const; static Framework* framework_; + // Note: config_ should be placed before cache_manager_ (cache_manager_ depends on config_) + static std::unique_ptr config_; + static std::unique_ptr cache_manager_; mutable Mutex mutex_; cucim::io::format::IImageFormat* image_formats_ = nullptr; @@ -179,8 +190,6 @@ class EXPORT_VISIBLE CuImage : public std::enable_shared_from_this std::set associated_images_; }; - } // namespace cucim - #endif // CUCIM_CUIMAGE_H diff --git a/cpp/include/cucim/filesystem/file_handle.h b/cpp/include/cucim/filesystem/file_handle.h index c735fbc71..3bf2c005b 100644 --- a/cpp/include/cucim/filesystem/file_handle.h +++ b/cpp/include/cucim/filesystem/file_handle.h @@ -37,11 +37,27 @@ enum class FileHandleType: uint16_t #if CUCIM_PLATFORM_LINUX struct CuCIMFileHandle { +# ifdef __cplusplus + EXPORT_VISIBLE CuCIMFileHandle(); + EXPORT_VISIBLE CuCIMFileHandle(int fd, CUfileHandle_t cufile, FileHandleType type, char* path, void* client_data); + EXPORT_VISIBLE CuCIMFileHandle(int fd, + CUfileHandle_t cufile, + FileHandleType type, + char* path, + void* client_data, + uint64_t dev, + uint64_t ino, + int64_t mtime); +# endif int fd; CUfileHandle_t cufile; FileHandleType type; /// 1: POSIX, 2: POSIX+ODIRECT, 4: MemoryMapped, 8: GPUDirect char* path; void* client_data; + uint64_t hash_value; + uint64_t dev; + uint64_t ino; + int64_t mtime; }; #else # error "This platform is not supported!" diff --git a/cpp/include/cucim/io/device.h b/cpp/include/cucim/io/device.h index 94e70a565..c1bd03784 100644 --- a/cpp/include/cucim/io/device.h +++ b/cpp/include/cucim/io/device.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,32 +14,21 @@ * limitations under the License. */ -#ifndef CUCIM_DEVICE_H -#define CUCIM_DEVICE_H +#ifndef CUCIM_IO_DEVICE_H +#define CUCIM_IO_DEVICE_H + +#include "cucim/macros/api_header.h" -#include #include #include +#include "device_type.h" + namespace cucim::io { using DeviceIndex = int16_t; -/** - * Value for each device type follows https://github.com/dmlc/dlpack/blob/v0.3/include/dlpack/dlpack.h - * Naming convention follows PyTorch (torch/include/c10/core/DeviceType.h) - */ -enum class DeviceType : int16_t -{ - kCPU = 1, - kCUDA = 2, - kPinned = 3, - - kCPUShared = 101, /// custom type for CPU-shared memory - kCUDAShared = 102, /// custom type for GPU-shared memory -}; - // Make the following public libraries visible (default visibility) as this header's implementation is in device.cpp // and provided by cucim library. // Without that, a plugin module cannot find the definition of those methods when Device class is used in the plugin @@ -74,4 +63,4 @@ class EXPORT_VISIBLE Device } // namespace cucim::io -#endif // CUCIM_DEVICE_H +#endif // CUCIM_IO_DEVICE_H diff --git a/cpp/include/cucim/io/device_type.h b/cpp/include/cucim/io/device_type.h new file mode 100644 index 000000000..d2c4f4b64 --- /dev/null +++ b/cpp/include/cucim/io/device_type.h @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CUCIM_IO_DEVICE_TYPE_H +#define CUCIM_IO_DEVICE_TYPE_H + +#include "cucim/macros/api_header.h" + +#include +#include +#include + + +namespace cucim::io +{ + +using DeviceIndex = int16_t; + +constexpr std::size_t kDeviceTypeCount = 5; +/** + * Value for each device type follows https://github.com/dmlc/dlpack/blob/v0.3/include/dlpack/dlpack.h + * Naming convention follows PyTorch (torch/include/c10/core/DeviceType.h) + */ +enum class DeviceType : int16_t +{ + kCPU = 1, + kCUDA = 2, + kPinned = 3, + + kCPUShared = 101, /// custom type for CPU-shared memory + kCUDAShared = 102, /// custom type for GPU-shared memory +}; + +// Using constexpr map (https://www.youtube.com/watch?v=INn3xa4pMfg) +struct DeviceTypeMap +{ + std::array, kDeviceTypeCount> data; + + [[nodiscard]] constexpr DeviceType at(const std::string_view& key) const; +}; + +EXPORT_VISIBLE DeviceType lookup_device_type(const std::string_view sv); + +struct DeviceTypeStrMap +{ + std::array, kDeviceTypeCount> data; + + [[nodiscard]] constexpr std::string_view at(const DeviceType& key) const; +}; + +EXPORT_VISIBLE std::string_view lookup_device_type_str(const DeviceType type); + + +} // namespace cucim::io + + +#endif // CUCIM_IO_DEVICE_TYPE_H diff --git a/cpp/include/cucim/io/format/image_format.h b/cpp/include/cucim/io/format/image_format.h index 2644a5562..ba4dc5ba0 100644 --- a/cpp/include/cucim/io/format/image_format.h +++ b/cpp/include/cucim/io/format/image_format.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -39,6 +39,7 @@ struct ResolutionInfoDesc uint16_t level_ndim; int64_t* level_dimensions; float* level_downsamples; + uint32_t* level_tile_sizes; }; struct AssociatedImageInfoDesc @@ -87,27 +88,28 @@ class EXPORT_VISIBLE ImageMetadata ImageMetadataDesc& desc(); ImageMetadata& ndim(uint16_t ndim); - ImageMetadata& dims(const std::string_view& dims); - ImageMetadata& shape(const std::pmr::vector& shape); + ImageMetadata& dims(std::string_view&& dims); + ImageMetadata& shape(std::pmr::vector&& shape); ImageMetadata& dtype(const DLDataType& dtype); - ImageMetadata& channel_names(const std::pmr::vector& channel_names); + ImageMetadata& channel_names(std::pmr::vector&& channel_names); - ImageMetadata& spacing(const std::pmr::vector& spacing); - ImageMetadata& spacing_units(const std::pmr::vector& spacing_units); + ImageMetadata& spacing(std::pmr::vector&& spacing); + ImageMetadata& spacing_units(std::pmr::vector&& spacing_units); - ImageMetadata& origin(const std::pmr::vector& origin); - ImageMetadata& direction(const std::pmr::vector& direction); - ImageMetadata& coord_sys(const std::string_view& coord_sys); + ImageMetadata& origin(std::pmr::vector&& origin); + ImageMetadata& direction(std::pmr::vector&& direction); + ImageMetadata& coord_sys(std::string_view&& coord_sys); // ResolutionInfoDesc ImageMetadata& level_count(uint16_t level_count); ImageMetadata& level_ndim(uint16_t level_ndim); - ImageMetadata& level_dimensions(const std::pmr::vector& level_dimensions); - ImageMetadata& level_downsamples(const std::pmr::vector& level_downsamples); + ImageMetadata& level_dimensions(std::pmr::vector&& level_dimensions); + ImageMetadata& level_downsamples(std::pmr::vector&& level_downsamples); + ImageMetadata& level_tile_sizes(std::pmr::vector&& level_tile_sizes); // AssociatedImageInfoDesc ImageMetadata& image_count(uint16_t image_count); - ImageMetadata& image_names(const std::pmr::vector& image_names); + ImageMetadata& image_names(std::pmr::vector&& image_names); ImageMetadata& raw_data(const std::string_view& raw_data); ImageMetadata& json_data(const std::string_view& json_data); @@ -123,31 +125,33 @@ class EXPORT_VISIBLE ImageMetadata #if _GLIBCXX_USE_CXX11_ABI std::pmr::string dims_{ &res_ }; std::pmr::vector shape_{ &res_ }; - std::pmr::vector channel_names_{ &res_ }; + std::pmr::vector channel_names_{ &res_ }; std::pmr::vector spacing_{ &res_ }; - std::pmr::vector spacing_units_{ &res_ }; + std::pmr::vector spacing_units_{ &res_ }; std::pmr::vector origin_{ &res_ }; std::pmr::vector direction_{ &res_ }; std::pmr::string coord_sys_{ &res_ }; std::pmr::vector level_dimensions_{ &res_ }; std::pmr::vector level_downsamples_{ &res_ }; + std::pmr::vector level_tile_sizes_{ &res_ }; - std::pmr::vector image_names_{ &res_ }; + std::pmr::vector image_names_{ &res_ }; #else std::string dims_; std::pmr::vector shape_{ &res_ }; - std::pmr::vector channel_names_{ &res_ }; + std::pmr::vector channel_names_{ &res_ }; std::pmr::vector spacing_{ &res_ }; - std::pmr::vector spacing_units_{ &res_ }; + std::pmr::vector spacing_units_{ &res_ }; std::pmr::vector origin_{ &res_ }; std::pmr::vector direction_{ &res_ }; std::string coord_sys_; std::pmr::vector level_dimensions_{ &res_ }; std::pmr::vector level_downsamples_{ &res_ }; + std::pmr::vector level_tile_sizes_{ &res_ }; - std::pmr::vector image_names_{ &res_ }; + std::pmr::vector image_names_{ &res_ }; #endif // Memory for raw_data and json_data needs to be created with cucim_malloc(); }; @@ -155,6 +159,7 @@ class EXPORT_VISIBLE ImageMetadata struct ImageDataDesc { DLTensor container; + char* shm_name; }; struct ImageCheckerDesc diff --git a/cpp/include/cucim/memory/dlpack.h b/cpp/include/cucim/memory/dlpack.h index bacc513d5..3145b07b7 100644 --- a/cpp/include/cucim/memory/dlpack.h +++ b/cpp/include/cucim/memory/dlpack.h @@ -27,12 +27,28 @@ class DLTContainer { public: DLTContainer() = delete; - DLTContainer(DLTensor* handle) : tensor_(handle) + DLTContainer(DLTensor* handle, char* shm_name = nullptr) : tensor_(handle), shm_name_(shm_name) { } /** - * Returns a string providing the basic type of the homogenous array in NumPy. + * @brief Return the size of memory required to store the contents of data. + * + * @return size_t Required size for the tensor. + */ + size_t size() + { + size_t size = 1; + for (int i = 0; i < tensor_->ndim; ++i) + { + size *= tensor_->shape[i]; + } + size *= (tensor_->dtype.bits * tensor_->dtype.lanes + 7) / 8; + return size; + } + + /** + * @brief Return a string providing the basic type of the homogenous array in NumPy. * * Note: This method assumes little-endian for now. * @@ -108,7 +124,8 @@ class DLTContainer } private: - DLTensor* tensor_; + DLTensor* tensor_ = nullptr; + char* shm_name_ = nullptr; }; } // namespace cucim::memory diff --git a/cpp/include/cucim/memory/memory_manager.h b/cpp/include/cucim/memory/memory_manager.h index 739735f9b..d2246e9e1 100644 --- a/cpp/include/cucim/memory/memory_manager.h +++ b/cpp/include/cucim/memory/memory_manager.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,11 +17,12 @@ #ifndef CUCIM_MEMORY_MANAGER_H #define CUCIM_MEMORY_MANAGER_H -#include "cucim/io/device.h" +#include "cucim/macros/api_header.h" -#include #include +#include "cucim/io/device.h" + /** * Host memory allocator for exchanged data * @param size Number of bytes to allocate @@ -35,9 +36,7 @@ CUCIM_API void* cucim_malloc(size_t size); */ CUCIM_API void cucim_free(void* ptr); -namespace cucim -{ -namespace memory +namespace cucim::memory { /** @@ -46,7 +45,7 @@ namespace memory struct PointerAttributes { /** - * The type of device + * @brief The type of device */ cucim::io::Device device{}; @@ -58,7 +57,7 @@ struct PointerAttributes }; /** - * A wrapper for cudaPointerGetAttributes() in CUDA. + * @brief A wrapper for cudaPointerGetAttributes() in CUDA. * * Instead of cudaPointerAttributes * @@ -67,7 +66,31 @@ struct PointerAttributes */ CUCIM_API void get_pointer_attributes(PointerAttributes& attr, const void* ptr); +/** + * @brief Move host memory of `size` bytes to a new memory in `out_device`. + * + * Set the pointer of the new memory to `target` and free the host memory previously indicated by `target. + * Do nothing if `out_device` is CPU memory. + * + * @param[in, out] target Pointer to the pointer of the host memory. + * @param size Size of the host memory. + * @param dst_device Destination device of the memory. + * @return `true` if succeed. + */ +bool move_raster_from_host(void** target, size_t size, const cucim::io::Device& dst_device); + +/** + * @brief Move device memory of `size` bytes to a new memory in `out_device`. + * + * Set the pointer of the new memory to `target` and free the device memory previously indicated by `target. + * Do nothing if `out_device` is CUDA memory. + * + * @param[in, out] target Pointer to the pointer of the device memory. + * @param size Size of the device memory. + * @param dst_device Destination device of the memory. + * @return `true` if succeed. + */ +bool move_raster_from_device(void** target, size_t size, const cucim::io::Device& dst_device); -} // namespace memory -} // namespace cucim +} // namespace cucim::memory #endif // CUCIM_MEMORY_MANAGER_H diff --git a/cpp/include/cucim/util/cuda.h b/cpp/include/cucim/util/cuda.h new file mode 100644 index 000000000..f89b1adaf --- /dev/null +++ b/cpp/include/cucim/util/cuda.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// +#ifndef CUCIM_UTIL_CUDA_H +#define CUCIM_UTIL_CUDA_H + +#include + +#define CUDA_TRY(stmt) \ + { \ + cuda_status = stmt; \ + if (cudaSuccess != cuda_status) \ + { \ + fmt::print(stderr, "[Error] CUDA Runtime call {} in line {} of file {} failed with '{}' ({}).\n", #stmt, \ + __LINE__, __FILE__, cudaGetErrorString(cuda_status), cuda_status); \ + } \ + } + +namespace cucim::util +{ + +} // namespace cucim::util + +#endif // CUCIM_UTIL_CUDA_H diff --git a/cpp/include/cucim/util/file.h b/cpp/include/cucim/util/file.h new file mode 100644 index 000000000..48bf109e7 --- /dev/null +++ b/cpp/include/cucim/util/file.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// +#ifndef CUCIM_UTIL_FILE_H +#define CUCIM_UTIL_FILE_H + +#include "cucim/core/framework.h" + +/** + * @brief Utility methods that need to be refactored later. + */ +namespace cucim::util +{ + +EXPORT_VISIBLE bool file_exists(const char* path); + +} // namespace cucim::util + +#endif // CUCIM_UTIL_FILE_H diff --git a/cpp/plugins/cucim.kit.cuslide/VERSION b/cpp/plugins/cucim.kit.cuslide/VERSION index 1cf0537c3..caccd4086 100644 --- a/cpp/plugins/cucim.kit.cuslide/VERSION +++ b/cpp/plugins/cucim.kit.cuslide/VERSION @@ -1 +1 @@ -0.19.0 +21.06.00 diff --git a/cpp/plugins/cucim.kit.cuslide/benchmarks/main.cpp b/cpp/plugins/cucim.kit.cuslide/benchmarks/main.cpp index b1f3c9651..faa8372cb 100644 --- a/cpp/plugins/cucim.kit.cuslide/benchmarks/main.cpp +++ b/cpp/plugins/cucim.kit.cuslide/benchmarks/main.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,16 +16,16 @@ #include "config.h" +#include +#include + +#include +#include #include -#include #include #include - -#include -#include -#include -#include +#include #include "cucim/core/framework.h" #include "cucim/io/format/image_format.h" @@ -86,7 +86,6 @@ static void test_basic(benchmark::State& state) auto handle = image_format->formats[0].image_parser.open(g_config.input_file.c_str()); cucim::io::format::ImageMetadata metadata{}; - metadata.level_count(1).level_downsamples({ 1.0 }).level_ndim(3); image_format->formats[0].image_parser.parse(&handle, &metadata.desc()); cucim::io::format::ImageReaderRegionRequestDesc request{}; @@ -142,7 +141,7 @@ static void test_openslide(benchmark::State& state) state.ResumeTiming(); openslide_t* slide = openslide_open(g_config.input_file.c_str()); - uint32_t* buf = (uint32_t*)cucim_malloc(state.range(0) * state.range(0) * 4); + uint32_t* buf = static_cast(cucim_malloc(state.range(0) * state.range(0) * 4)); int64_t request_location[2] = { 0, 0 }; if (g_config.random_start_location) { diff --git a/cpp/plugins/cucim.kit.cuslide/cmake/deps/boost.cmake b/cpp/plugins/cucim.kit.cuslide/cmake/deps/boost.cmake new file mode 100644 index 000000000..558740e1e --- /dev/null +++ b/cpp/plugins/cucim.kit.cuslide/cmake/deps/boost.cmake @@ -0,0 +1,75 @@ +# +# Copyright (c) 2020-2021, NVIDIA CORPORATION. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +if (NOT TARGET deps::boost) + set(Boost_VERSION 1.75.0) + set(Boost_BUILD_COMPONENTS container) + set(Boost_BUILD_OPTIONS "threading=multi cxxflags=-fPIC runtime-link=static variant=release link=static address-model=64 --layout=system") + set(Boost_COMPILE_DEFINITIONS + BOOST_COROUTINES_NO_DEPRECATION_WARNING=1 + BOOST_ALL_NO_LIB=1 + BOOST_UUID_RANDOM_PROVIDER_FORCE_WINCRYPT=1 + CACHE INTERNAL "Boost compile definitions") + + set(Boost_USE_STATIC_LIBS ON) + set(Boost_USE_MULTITHREADED ON) + set(Boost_USE_STATIC_RUNTIME ON) + + foreach(component_name ${Boost_BUILD_COMPONENTS}) + list(APPEND Boost_BUILD_VARIANTS --with-${component_name}) + endforeach() + + FetchContent_Declare( + deps-boost + GIT_REPOSITORY https://github.com/boostorg/boost.git + GIT_TAG boost-${Boost_VERSION} + GIT_SHALLOW TRUE + ) + FetchContent_GetProperties(deps-boost) + if (NOT deps-boost_POPULATED) + message(STATUS "Fetching boost sources") + FetchContent_Populate(deps-boost) + message(STATUS "Fetching boost sources - done") + endif () + + if (deps-boost_POPULATED AND NOT EXISTS "${deps-boost_BINARY_DIR}/install") + include(ProcessorCount) + ProcessorCount(PROCESSOR_COUNT) + + execute_process(COMMAND /bin/bash -c "./bootstrap.sh --prefix=${deps-boost_BINARY_DIR}/install && ./b2 install --build-dir=${deps-boost_BINARY_DIR}/build --stagedir=${deps-boost_BINARY_DIR}/stage -j${PROCESSOR_COUNT} ${Boost_BUILD_VARIANTS} ${Boost_BUILD_OPTIONS}" + WORKING_DIRECTORY ${deps-boost_SOURCE_DIR} + COMMAND_ECHO STDOUT + RESULT_VARIABLE Boost_BUILD_RESULT) + if(NOT Boost_BUILD_RESULT EQUAL "0") + message(FATAL_ERROR "boost library build failed with ${Boost_BUILD_RESULT}, please checkout the boost module configurations") + endif() + endif() + + find_package(Boost 1.75 CONFIG REQUIRED COMPONENTS ${Boost_BUILD_COMPONENTS} + HINTS ${deps-boost_BINARY_DIR}/install) # /lib/cmake/Boost-${Boost_VERSION} + + message(STATUS "Boost version: ${Boost_VERSION}") + + add_library(deps::boost INTERFACE IMPORTED GLOBAL) + + set_target_properties(deps::boost PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}" + INTERFACE_COMPILE_DEFINITIONS "${Boost_COMPILE_DEFINITIONS}" + INTERFACE_LINK_LIBRARIES "${Boost_LIBRARIES}" + ) + + set(deps-boost_SOURCE_DIR ${deps-boost_SOURCE_DIR} CACHE INTERNAL "" FORCE) + mark_as_advanced(deps-boost_SOURCE_DIR) +endif () \ No newline at end of file diff --git a/cpp/plugins/cucim.kit.cuslide/src/cuslide/cuslide.cpp b/cpp/plugins/cucim.kit.cuslide/src/cuslide/cuslide.cpp index 8be129254..055473892 100644 --- a/cpp/plugins/cucim.kit.cuslide/src/cuslide/cuslide.cpp +++ b/cpp/plugins/cucim.kit.cuslide/src/cuslide/cuslide.cpp @@ -17,21 +17,19 @@ #include "cuslide.h" -#include "cucim/io/format/image_format.h" - #include "cucim/core/framework.h" #include "cucim/core/plugin_util.h" - -#include -//#include "tiffio.h" -//#include "tif_dir.h" +#include "cucim/io/format/image_format.h" #include "tiff/tiff.h" -#include + +#include +#include + +#include #include #include -#include -#include -// #include +#include +#include using json = nlohmann::json; @@ -121,7 +119,18 @@ static bool CUCIM_ABI parser_parse(CuCIMFileHandle* handle, cucim::io::format::I } // Assume that the image has only one main (high resolution) image. - assert(main_ifd_list.size() == 1); + if (main_ifd_list.size() != 1) + { + throw std::runtime_error( + fmt::format("This format has more than one image with Subfile Type 0 so cannot be loaded!")); + } + + // Explicitly forbid loading SVS format (#17) + if (tif->ifd(0)->image_description().rfind("Aperio", 0) == 0) + { + throw std::runtime_error( + fmt::format("cuCIM doesn't support Aperio SVS for now (https://github.com/rapidsai/cucim/issues/17).")); + } // // Metadata Setup @@ -187,6 +196,15 @@ static bool CUCIM_ABI parser_parse(CuCIMFileHandle* handle, cucim::io::format::I level_downsamples.emplace_back(((orig_width / level_ifd->width()) + (orig_height / level_ifd->height())) / 2); } + std::pmr::vector level_tile_sizes(&resource); + level_tile_sizes.reserve(level_count * 2); + for (size_t i = 0; i < level_count; ++i) + { + const auto& level_ifd = tif->level_ifd(i); + level_tile_sizes.emplace_back(level_ifd->tile_width()); + level_tile_sizes.emplace_back(level_ifd->tile_height()); + } + const size_t associated_image_count = tif->associated_image_count(); std::pmr::vector associated_image_names(&resource); for (const auto& associated_image : tif->associated_images()) @@ -204,21 +222,22 @@ static bool CUCIM_ABI parser_parse(CuCIMFileHandle* handle, cucim::io::format::I std::string_view json_data{ json_data_ptr, json_str.size() }; out_metadata.ndim(ndim); - out_metadata.dims(dims); - out_metadata.shape(shape); + out_metadata.dims(std::move(dims)); + out_metadata.shape(std::move(shape)); out_metadata.dtype(dtype); - out_metadata.channel_names(channel_names); - out_metadata.spacing(spacing); - out_metadata.spacing_units(spacing_units); - out_metadata.origin(origin); - out_metadata.direction(direction); - out_metadata.coord_sys(coord_sys); + out_metadata.channel_names(std::move(channel_names)); + out_metadata.spacing(std::move(spacing)); + out_metadata.spacing_units(std::move(spacing_units)); + out_metadata.origin(std::move(origin)); + out_metadata.direction(std::move(direction)); + out_metadata.coord_sys(std::move(coord_sys)); out_metadata.level_count(level_count); out_metadata.level_ndim(level_ndim); - out_metadata.level_dimensions(level_dimensions); - out_metadata.level_downsamples(level_downsamples); + out_metadata.level_dimensions(std::move(level_dimensions)); + out_metadata.level_downsamples(std::move(level_downsamples)); + out_metadata.level_tile_sizes(std::move(level_tile_sizes)); out_metadata.image_count(associated_image_count); - out_metadata.image_names(associated_image_names); + out_metadata.image_names(std::move(associated_image_names)); out_metadata.raw_data(raw_data); out_metadata.json_data(json_data); @@ -284,17 +303,3 @@ void fill_interface(cucim::io::format::IImageFormat& iface) }; // clang-format on } - -// -// -//#include -//#include "fmt/format.h" -// -// -// -// CUCIM_API int foo() -//{ -// std::cout << "Foo!" << std::endl; -//// std::string a = fmt::format(b.getName()); -// return 0; -//} diff --git a/cpp/plugins/cucim.kit.cuslide/src/cuslide/deflate/deflate.cpp b/cpp/plugins/cucim.kit.cuslide/src/cuslide/deflate/deflate.cpp index d58159233..f97ab5965 100644 --- a/cpp/plugins/cucim.kit.cuslide/src/cuslide/deflate/deflate.cpp +++ b/cpp/plugins/cucim.kit.cuslide/src/cuslide/deflate/deflate.cpp @@ -68,6 +68,11 @@ bool decode_deflate(int fd, size_t out_size; libdeflate_zlib_decompress(d, deflate_buf, size /*in_nbytes*/, *dest, dest_nbytes /*out_nbytes_avail*/, &out_size); + if (fd != -1) + { + free(deflate_buf); + } + libdeflate_free_decompressor(d); return true; } diff --git a/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/ifd.cpp b/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/ifd.cpp index 047d9d260..f7d29ac5a 100644 --- a/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/ifd.cpp +++ b/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/ifd.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,14 +16,25 @@ #include "ifd.h" -#include "tiff.h" -#include "cuslide/jpeg/libjpeg_turbo.h" -#include "cuslide/deflate/deflate.h" +#include +#include + +#include +#include +#include #include #include // this is not included in the released library #include -#include + +#include +#include +#include +#include + +#include "cuslide/jpeg/libjpeg_turbo.h" +#include "cuslide/deflate/deflate.h" +#include "tiff.h" namespace cuslide::tiff @@ -113,6 +124,9 @@ IFD::IFD(TIFF* tiff, uint16_t index, ifd_offset_t offset) : tiff_(tiff), ifd_ind image_piece_bytecounts_.end(), &td_stripbytecount_p[0], &td_stripbytecount_p[image_piece_count_]); } + // Calculate hash value with IFD idnex + hash_value_ = tiff->file_handle_.hash_value ^ cucim::codec::splitmix64(index); + // TIFFPrintDirectory(tif, stdout, TIFFPRINT_STRIPS); } @@ -129,7 +143,7 @@ bool IFD::read(const TIFF* tiff, if (request->shm_name) { - device_name = device_name + "[" + request->shm_name + "]"; // TODO: check performance + device_name = device_name + fmt::format("[{}]", request->shm_name); // TODO: check performance } cucim::io::Device out_device(device_name); @@ -139,10 +153,12 @@ bool IFD::read(const TIFF* tiff, int64_t h = request->size[1]; int32_t n_ch = 3; // number of channels + size_t raster_size = w * h * samples_per_pixel_; void* raster = nullptr; - DLTensor* out_buf = request->buf; - if (out_buf && out_buf->data) + bool is_buf_available = out_buf && out_buf->data; + + if (is_buf_available) { // TODO: memory size check if out_buf->data has high-enough memory (>= tjBufSize()) raster = out_buf->data; @@ -152,8 +168,8 @@ bool IFD::read(const TIFF* tiff, { if (!raster) { - raster = cucim_malloc(w * h * samples_per_pixel_); // RGB image - memset(raster, 0, w * h * 3); + raster = cucim_malloc(raster_size); // RGB image + memset(raster, 0, raster_size); } @@ -173,6 +189,14 @@ bool IFD::read(const TIFF* tiff, "Cannot handle the out-of-boundary cases for a non-RGB image or a non-Jpeg/Deflate-compressed image.")); } + // Check if the image format is supported or not + if (!is_format_supported()) + { + throw std::runtime_error(fmt::format( + "This format (compression: {}, sample_per_pixel: {}, planar_config: {}, photometric: {}) is not supported yet!.", + compression_, samples_per_pixel_, planar_config_, photometric_)); + } + if (tif->tif_curdir != ifd_index) { TIFFSetDirectory(tif, ifd_index); @@ -188,9 +212,10 @@ bool IFD::read(const TIFF* tiff, { size_t npixels; npixels = w * h; + raster_size = npixels * 4; if (!raster) { - raster = cucim_malloc(npixels * sizeof(uint32_t)); + raster = cucim_malloc(raster_size); } img.col_offset = sx; img.row_offset = sy; @@ -200,27 +225,57 @@ bool IFD::read(const TIFF* tiff, { if (!TIFFRGBAImageGet(&img, (uint32_t*)raster, w, h)) { - memset(raster, 0, w * h * sizeof(uint32_t)); + memset(raster, 0, raster_size); } } } + else + { + throw std::runtime_error(fmt::format( + "This format (compression: {}, sample_per_pixel: {}, planar_config: {}, photometric: {}) is not supported yet!: {}", + compression_, samples_per_pixel_, planar_config_, photometric_, emsg)); + } TIFFRGBAImageEnd(&img); } + else + { + throw std::runtime_error(fmt::format( + "This format (compression: {}, sample_per_pixel: {}, planar_config: {}, photometric: {}) is not supported yet!: {}", + compression_, samples_per_pixel_, planar_config_, photometric_, emsg)); + } } int ndim = 3; - int64_t* shape = (int64_t*)cucim_malloc(sizeof(int64_t) * ndim); + int64_t* shape = static_cast(cucim_malloc(sizeof(int64_t) * ndim)); shape[0] = h; shape[1] = w; shape[2] = n_ch; - out_image_data->container.data = raster; - out_image_data->container.ctx = DLContext{ static_cast(cucim::io::DeviceType::kCPU), 0 }; - out_image_data->container.ndim = ndim; - out_image_data->container.dtype = metadata->dtype; - out_image_data->container.shape = shape; - out_image_data->container.strides = nullptr; // Tensor is compact and row-majored - out_image_data->container.byte_offset = 0; + // Copy the raster memory and free it if needed. + if (!is_buf_available) + { + cucim::memory::move_raster_from_host(&raster, raster_size, out_device); + } + + auto& out_image_container = out_image_data->container; + out_image_container.data = raster; + out_image_container.ctx = DLContext{ static_cast(out_device.type()), out_device.index() }; + out_image_container.ndim = ndim; + out_image_container.dtype = metadata->dtype; + out_image_container.shape = shape; + out_image_container.strides = nullptr; // Tensor is compact and row-majored + out_image_container.byte_offset = 0; + auto& shm_name = out_device.shm_name(); + size_t shm_name_len = shm_name.size(); + if (shm_name_len != 0) + { + out_image_data->shm_name = static_cast(cucim_malloc(shm_name_len + 1)); + memcpy(out_image_data->shm_name, shm_name.c_str(), shm_name_len + 1); + } + else + { + out_image_data->shm_name = nullptr; + } return true; } @@ -308,15 +363,24 @@ const std::vector& IFD::image_piece_bytecounts() const return image_piece_bytecounts_; } -bool IFD::is_read_optimizable() const +bool IFD::is_compression_supported() const { return (compression_ == COMPRESSION_ADOBE_DEFLATE || compression_ == COMPRESSION_JPEG || - compression_ == COMPRESSION_DEFLATE) && - bits_per_sample_ == 8 && samples_per_pixel_ == 3 && planar_config_ == PLANARCONFIG_CONTIG && + compression_ == COMPRESSION_DEFLATE); +} +bool IFD::is_read_optimizable() const +{ + return is_compression_supported() && bits_per_sample_ == 8 && samples_per_pixel_ == 3 && + planar_config_ == PLANARCONFIG_CONTIG && (photometric_ == PHOTOMETRIC_RGB || photometric_ == PHOTOMETRIC_YCBCR) && !tiff_->is_in_read_config(TIFF::kUseLibTiff); } +bool IFD::is_format_supported() const +{ + return is_compression_supported(); +} + bool IFD::read_region_tiles(const TIFF* tiff, const IFD* ifd, const int64_t sx, @@ -339,6 +403,8 @@ bool IFD::read_region_tiles(const TIFF* tiff, { return read_region_tiles_boundary(tiff, ifd, sx, sy, w, h, raster, out_device); } + cucim::cache::ImageCache& image_cache = cucim::CuImage::cache_manager().cache(); + cucim::cache::CacheType cache_type = image_cache.type(); uint8_t background_value = tiff->background_value_; uint16_t compression_method = ifd->compression_; @@ -377,21 +443,17 @@ bool IFD::read_region_tiles(const TIFF* tiff, const int pixel_format = TJPF_RGB; // TODO: support other pixel format const int pixel_size_nbytes = tjPixelSize[pixel_format]; const size_t tile_raster_nbytes = tw * th * pixel_size_nbytes; - uint8_t* tile_raster = static_cast(cucim_malloc(tile_raster_nbytes)); + uint8_t* tile_raster = nullptr; + if (cache_type == cucim::cache::CacheType::kNoCache) + { + tile_raster = static_cast(cucim_malloc(tile_raster_nbytes)); + } int tiff_file = tiff->file_handle_.fd; - - - // uint32_t nbytes_offset_sx = offset_sx * samples_per_pixel; - // uint32_t nbytes_offset_ex = offset_ex * samples_per_pixel; + uint64_t ifd_hash_value = ifd->hash_value_; uint32_t dest_pixel_step_y = w * samples_per_pixel; - // uint32_t dest_pixel_tile_step_y = dest_pixel_step_y * th; uint32_t nbytes_tw = tw * samples_per_pixel; - // uint32_t nbytes_th = th * samples_per_pixel; - // uint32_t nbytes_offset_sy = offset_sy * nbytes_tw; - // uint32_t nbytes_offset_ey = offset_ey * nbytes_tw; - auto dest_start_ptr = static_cast(raster); // TODO: Current implementation doesn't consider endianness so need to consider later @@ -417,25 +479,47 @@ bool IFD::read_region_tiles(const TIFF* tiff, uint32_t nbytes_tile_index = (tile_pixel_offset_sy * tw + tile_pixel_offset_x) * samples_per_pixel; uint32_t dest_pixel_index = dest_pixel_index_x; + + uint8_t* tile_data = tile_raster; + if (tiledata_size > 0) { - if (compression_method == COMPRESSION_JPEG) + auto key = image_cache.create_key(ifd_hash_value, index); + image_cache.lock(index); + auto value = image_cache.find(key); + if (value) { - cuslide::jpeg::decode_libjpeg(tiff_file, nullptr, tiledata_offset, tiledata_size, jpegtable_data, - jpegtable_count, &tile_raster, out_device); + image_cache.unlock(index); + tile_data = static_cast(value->data); } else { - cuslide::deflate::decode_deflate(tiff_file, nullptr, tiledata_offset, tiledata_size, &tile_raster, - tile_raster_nbytes, out_device); + // Lifetime of tile_data is same with `value` + // : do not access this data when `value` is not accessible. + if (cache_type != cucim::cache::CacheType::kNoCache) + { + tile_data = static_cast(image_cache.allocate(tile_raster_nbytes)); + } + + if (compression_method == COMPRESSION_JPEG) + { + cuslide::jpeg::decode_libjpeg(tiff_file, nullptr, tiledata_offset, tiledata_size, + jpegtable_data, jpegtable_count, &tile_data, out_device); + } + else + { + cuslide::deflate::decode_deflate(tiff_file, nullptr, tiledata_offset, tiledata_size, &tile_data, + tile_raster_nbytes, out_device); + } + value = image_cache.create_value(tile_data, tile_raster_nbytes); + image_cache.insert(key, value); + image_cache.unlock(index); } for (uint32_t ty = tile_pixel_offset_sy; ty <= tile_pixel_offset_ey; ++ty, dest_pixel_index += dest_pixel_step_y, nbytes_tile_index += nbytes_tw) { - // printf("[GB] index_y: %d, offset_x: %d y:%d, %d, %d %d\n", index_y, offset_x, - // ty, dest_pixel_index, nbytes_tile_index, nbytes_tile_pixel_size_x); - memcpy(dest_start_ptr + dest_pixel_index, tile_raster + nbytes_tile_index, nbytes_tile_pixel_size_x); + memcpy(dest_start_ptr + dest_pixel_index, tile_data + nbytes_tile_index, nbytes_tile_pixel_size_x); } } else @@ -447,13 +531,15 @@ bool IFD::read_region_tiles(const TIFF* tiff, memset(dest_start_ptr + dest_pixel_index, background_value, nbytes_tile_pixel_size_x); } } - // printf("\n"); dest_pixel_index_x += nbytes_tile_pixel_size_x; } dest_start_ptr += dest_pixel_step_y * dest_pixel_offset_len_y; } - cucim_free(tile_raster); + if (tile_raster) + { + cucim_free(tile_raster); + } return true; } @@ -492,12 +578,18 @@ bool IFD::read_region_tiles_boundary(const TIFF* tiff, memset(dest_start_ptr, background_value, w * h * pixel_size_nbytes); return true; } + cucim::cache::ImageCache& image_cache = cucim::CuImage::cache_manager().cache(); + cucim::cache::CacheType cache_type = image_cache.type(); uint32_t tw = ifd->tile_width_; uint32_t th = ifd->tile_height_; const size_t tile_raster_nbytes = tw * th * pixel_size_nbytes; - uint8_t* tile_raster = static_cast(cucim_malloc(tile_raster_nbytes)); + uint8_t* tile_raster = nullptr; + if (cache_type == cucim::cache::CacheType::kNoCache) + { + tile_raster = static_cast(cucim_malloc(tile_raster_nbytes)); + } // TODO: revert this once we can get RGB data instead of RGBA uint32_t samples_per_pixel = 3; // ifd->samples_per_pixel(); @@ -566,6 +658,7 @@ bool IFD::read_region_tiles_boundary(const TIFF* tiff, int tiff_file = tiff->file_handle_.fd; + uint64_t ifd_hash_value = ifd->hash_value_; uint32_t dest_pixel_step_y = w * samples_per_pixel; uint32_t nbytes_tw = tw * samples_per_pixel; @@ -634,17 +727,38 @@ bool IFD::read_region_tiles_boundary(const TIFF* tiff, } } - if (compression_method == COMPRESSION_JPEG) + uint8_t* tile_data = tile_raster; + + auto key = image_cache.create_key(ifd_hash_value, index); + image_cache.lock(index); + auto value = image_cache.find(key); + if (value) { - cuslide::jpeg::decode_libjpeg(tiff_file, nullptr, tiledata_offset, tiledata_size, jpegtable_data, - jpegtable_count, &tile_raster, out_device); + image_cache.unlock(index); + tile_data = static_cast(value->data); } else { - cuslide::deflate::decode_deflate(tiff_file, nullptr, tiledata_offset, tiledata_size, &tile_raster, - tile_raster_nbytes, out_device); + // Lifetime of tile_data is same with `value` + // : do not access this data when `value` is not accessible. + if (cache_type != cucim::cache::CacheType::kNoCache) + { + tile_data = static_cast(image_cache.allocate(tile_raster_nbytes)); + } + if (compression_method == COMPRESSION_JPEG) + { + cuslide::jpeg::decode_libjpeg(tiff_file, nullptr, tiledata_offset, tiledata_size, + jpegtable_data, jpegtable_count, &tile_data, out_device); + } + else + { + cuslide::deflate::decode_deflate(tiff_file, nullptr, tiledata_offset, tiledata_size, &tile_data, + tile_raster_nbytes, out_device); + } + value = image_cache.create_value(tile_data, tile_raster_nbytes); + image_cache.insert(key, value); + image_cache.unlock(index); } - if (copy_partial) { uint32_t fill_gap_x = nbytes_tile_pixel_size_x - fixed_nbytes_tile_pixel_size_x; @@ -654,7 +768,7 @@ bool IFD::read_region_tiles_boundary(const TIFF* tiff, for (uint32_t ty = tile_pixel_offset_sy; ty <= fixed_tile_pixel_offset_ey; ++ty, dest_pixel_index += dest_pixel_step_y, nbytes_tile_index += nbytes_tw) { - memcpy(dest_start_ptr + dest_pixel_index, tile_raster + nbytes_tile_index, + memcpy(dest_start_ptr + dest_pixel_index, tile_data + nbytes_tile_index, fixed_nbytes_tile_pixel_size_x); memset(dest_start_ptr + dest_pixel_index + fixed_nbytes_tile_pixel_size_x, background_value, fill_gap_x); @@ -665,7 +779,7 @@ bool IFD::read_region_tiles_boundary(const TIFF* tiff, for (uint32_t ty = tile_pixel_offset_sy; ty <= fixed_tile_pixel_offset_ey; ++ty, dest_pixel_index += dest_pixel_step_y, nbytes_tile_index += nbytes_tw) { - memcpy(dest_start_ptr + dest_pixel_index, tile_raster + nbytes_tile_index, + memcpy(dest_start_ptr + dest_pixel_index, tile_data + nbytes_tile_index, fixed_nbytes_tile_pixel_size_x); } } @@ -681,8 +795,8 @@ bool IFD::read_region_tiles_boundary(const TIFF* tiff, for (uint32_t ty = tile_pixel_offset_sy; ty <= tile_pixel_offset_ey; ++ty, dest_pixel_index += dest_pixel_step_y, nbytes_tile_index += nbytes_tw) { - memcpy(dest_start_ptr + dest_pixel_index, tile_raster + nbytes_tile_index, - nbytes_tile_pixel_size_x); + memcpy( + dest_start_ptr + dest_pixel_index, tile_data + nbytes_tile_index, nbytes_tile_pixel_size_x); } } } @@ -699,8 +813,10 @@ bool IFD::read_region_tiles_boundary(const TIFF* tiff, } dest_start_ptr += dest_pixel_step_y * dest_pixel_offset_len_y; } - - cucim_free(tile_raster); + if (tile_raster) + { + cucim_free(tile_raster); + } return true; } diff --git a/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/ifd.h b/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/ifd.h index a4a0c7328..ffb21bef8 100644 --- a/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/ifd.h +++ b/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/ifd.h @@ -121,6 +121,13 @@ class EXPORT_VISIBLE IFD : public std::enable_shared_from_this std::vector image_piece_offsets_; std::vector image_piece_bytecounts_; + uint64_t hash_value_ = 0; /// file hash including ifd index. + + /** + * @brief Check if the current compression method is supported or not. + */ + bool is_compression_supported() const; + /** * * Note: This method is called by the constructor of IFD and read() method so it is possible that the output of @@ -129,6 +136,11 @@ class EXPORT_VISIBLE IFD : public std::enable_shared_from_this * @return */ bool is_read_optimizable() const; + + /** + * @brief Check if the specified image format is supported or not. + */ + bool is_format_supported() const; }; } // namespace cuslide::tiff diff --git a/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/tiff.cpp b/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/tiff.cpp index ec57f9b92..f35e44891 100644 --- a/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/tiff.cpp +++ b/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/tiff.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,22 +15,23 @@ */ #include "tiff.h" -#include "ifd.h" -#include "cuslide/jpeg/libjpeg_turbo.h" -#include #include -#include -#include -#include -#include +#include +#include #include -#include -#include #include +#include +#include +#include +#include +#include + +#include "cuslide/jpeg/libjpeg_turbo.h" +#include "ifd.h" static constexpr int DEFAULT_IFD_SIZE = 32; @@ -595,11 +596,12 @@ bool TIFF::read_associated_image(const cucim::io::format::ImageMetadataDesc* met std::string device_name(request->device); if (request->shm_name) { - device_name = device_name + "[" + request->shm_name + "]"; // TODO: check performance + device_name = device_name + fmt::format("[{}]", request->shm_name); // TODO: check performance } cucim::io::Device out_device(device_name); uint8_t* raster = nullptr; + size_t raster_size = 0; uint32_t width = 0; uint32_t height = 0; uint32_t samples_per_pixel = 0; @@ -630,9 +632,9 @@ bool TIFF::read_associated_image(const cucim::io::format::ImageMetadataDesc* met width = image_ifd->width(); height = image_ifd->height(); samples_per_pixel = image_ifd->samples_per_pixel(); - uint64_t image_size_in_bytes = width * height * samples_per_pixel; + raster_size = width * height * samples_per_pixel; - raster = static_cast(cucim_malloc(image_size_in_bytes)); // RGB image + raster = static_cast(cucim_malloc(raster_size)); // RGB image // TODO: here we assume that the image has a single strip. uint64_t offset = image_ifd->image_piece_offsets_[0]; @@ -674,9 +676,9 @@ bool TIFF::read_associated_image(const cucim::io::format::ImageMetadataDesc* met width = image_width; height = image_height; samples_per_pixel = 3; // NOTE: assumes RGB image - uint64_t image_size_in_bytes = image_width * image_height * samples_per_pixel; + raster_size = image_width * image_height * samples_per_pixel; - raster = static_cast(cucim_malloc(image_size_in_bytes)); // RGB image + raster = static_cast(cucim_malloc(raster_size)); // RGB image if (!cuslide::jpeg::decode_libjpeg(-1, reinterpret_cast(decoded_buf), 0 /*offset*/, decoded_size, nullptr /*jpegtable_data*/, 0 /*jpegtable_count*/, &raster, @@ -703,18 +705,34 @@ bool TIFF::read_associated_image(const cucim::io::format::ImageMetadataDesc* met // Populate image data const uint16_t ndim = 3; - int64_t* container_shape = (int64_t*)cucim_malloc(sizeof(int64_t) * ndim); + int64_t* container_shape = static_cast(cucim_malloc(sizeof(int64_t) * ndim)); container_shape[0] = height; container_shape[1] = width; container_shape[2] = 3; // TODO: hard-coded for 'C' - out_image_data->container.data = raster; - out_image_data->container.ctx = DLContext{ static_cast(cucim::io::DeviceType::kCPU), 0 }; - out_image_data->container.ndim = ndim; - out_image_data->container.dtype = { kDLUInt, 8, 1 }; - out_image_data->container.shape = container_shape; - out_image_data->container.strides = nullptr; // Tensor is compact and row-majored - out_image_data->container.byte_offset = 0; + // Copy the raster memory and free it if needed. + cucim::memory::move_raster_from_host((void**)&raster, raster_size, out_device); + + auto& out_image_container = out_image_data->container; + out_image_container.data = raster; + out_image_container.ctx = DLContext{ static_cast(out_device.type()), out_device.index() }; + out_image_container.ndim = ndim; + out_image_container.dtype = { kDLUInt, 8, 1 }; + out_image_container.shape = container_shape; + out_image_container.strides = nullptr; // Tensor is compact and row-majored + out_image_container.byte_offset = 0; + + auto& shm_name = out_device.shm_name(); + size_t shm_name_len = shm_name.size(); + if (shm_name_len != 0) + { + out_image_data->shm_name = static_cast(cucim_malloc(shm_name_len + 1)); + memcpy(out_image_data->shm_name, shm_name.c_str(), shm_name_len + 1); + } + else + { + out_image_data->shm_name = nullptr; + } // Populate metadata if (out_metadata_desc && out_metadata_desc->handle) @@ -731,7 +749,6 @@ bool TIFF::read_associated_image(const cucim::io::format::ImageMetadataDesc* met DLDataType dtype{ kDLUInt, 8, 1 }; - // TODO: Do not assume channel names as 'RGB' std::pmr::vector channel_names( { std::string_view{ "R" }, std::string_view{ "G" }, std::string_view{ "B" } }, &resource); @@ -772,6 +789,11 @@ bool TIFF::read_associated_image(const cucim::io::format::ImageMetadataDesc* met level_downsamples.reserve(1); level_downsamples.emplace_back(1.0); + std::pmr::vector level_tile_sizes(&resource); + level_tile_sizes.reserve(level_ndim * 1); // it has only one size + level_tile_sizes.emplace_back(shape[1]); // tile_width + level_tile_sizes.emplace_back(shape[0]); // tile_height + // Empty associated images const size_t associated_image_count = 0; std::pmr::vector associated_image_names(&resource); @@ -780,21 +802,22 @@ bool TIFF::read_associated_image(const cucim::io::format::ImageMetadataDesc* met std::string_view json_data{ json_data_ptr ? json_data_ptr : "" }; out_metadata.ndim(ndim); - out_metadata.dims(dims); - out_metadata.shape(shape); + out_metadata.dims(std::move(dims)); + out_metadata.shape(std::move(shape)); out_metadata.dtype(dtype); - out_metadata.channel_names(channel_names); - out_metadata.spacing(spacing); - out_metadata.spacing_units(spacing_units); - out_metadata.origin(origin); - out_metadata.direction(direction); - out_metadata.coord_sys(coord_sys); + out_metadata.channel_names(std::move(channel_names)); + out_metadata.spacing(std::move(spacing)); + out_metadata.spacing_units(std::move(spacing_units)); + out_metadata.origin(std::move(origin)); + out_metadata.direction(std::move(direction)); + out_metadata.coord_sys(std::move(coord_sys)); out_metadata.level_count(1); out_metadata.level_ndim(2); - out_metadata.level_dimensions(level_dimensions); - out_metadata.level_downsamples(level_downsamples); + out_metadata.level_dimensions(std::move(level_dimensions)); + out_metadata.level_downsamples(std::move(level_downsamples)); + out_metadata.level_tile_sizes(std::move(level_tile_sizes)); out_metadata.image_count(associated_image_count); - out_metadata.image_names(associated_image_names); + out_metadata.image_names(std::move(associated_image_names)); out_metadata.raw_data(raw_data); out_metadata.json_data(json_data); } diff --git a/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/tiff.h b/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/tiff.h index 8d520d42f..8d23f3de4 100644 --- a/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/tiff.h +++ b/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/tiff.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,21 +17,20 @@ #ifndef CUSLIDE_TIFF_H #define CUSLIDE_TIFF_H -#include "types.h" -#include "ifd.h" -//#include - -#include #include #include -#include #include +#include +#include #include #include +#include #include #include -#include + +#include "ifd.h" +#include "types.h" typedef struct tiff TIFF; diff --git a/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/types.h b/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/types.h index 299ee510c..7b0247173 100644 --- a/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/types.h +++ b/cpp/plugins/cucim.kit.cuslide/src/cuslide/tiff/types.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,10 +17,10 @@ #ifndef CUSLIDE_TYPES_H #define CUSLIDE_TYPES_H -#include - #include +#include + namespace cuslide::tiff { diff --git a/cpp/plugins/cucim.kit.cuslide/tests/test_read_region.cpp b/cpp/plugins/cucim.kit.cuslide/tests/test_read_region.cpp index 92590d83f..138218e48 100644 --- a/cpp/plugins/cucim.kit.cuslide/tests/test_read_region.cpp +++ b/cpp/plugins/cucim.kit.cuslide/tests/test_read_region.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,13 +14,16 @@ * limitations under the License. */ -#include +#include + +#include #include -#include "cuslide/tiff/tiff.h" + +#include + #include "config.h" +#include "cuslide/tiff/tiff.h" -#include -#include TEST_CASE("Verify read_region()", "[test_read_region.cpp]") { @@ -44,7 +47,7 @@ TEST_CASE("Verify read_region()", "[test_read_region.cpp]") openslide_t* slide = openslide_open(g_config.get_input_path().c_str()); REQUIRE(slide != nullptr); - auto buf = (uint32_t*)cucim_malloc(test_width * test_height * 4); + auto buf = static_cast(cucim_malloc(test_width * test_height * 4)); openslide_read_region(slide, buf, test_sx, test_sy, 0, test_width, test_height); openslide_close(slide); diff --git a/cpp/src/cache/cache_type.cpp b/cpp/src/cache/cache_type.cpp new file mode 100644 index 000000000..eaadc978e --- /dev/null +++ b/cpp/src/cache/cache_type.cpp @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cucim/cache/cache_type.h" +#include "cucim/cpp20/find_if.h" + + +namespace cucim::cache +{ + +using namespace std::literals::string_view_literals; + +constexpr CacheType CacheTypeMap::at(const std::string_view& key) const +{ + const auto itr = cucim::cpp20::find_if(begin(data), end(data), [&key](const auto& v) { return v.first == key; }); + + if (itr != end(data)) + { + return itr->second; + } + else + { + return CacheType::kNoCache; + } +} + +constexpr std::string_view CacheTypeStrMap::at(const CacheType& key) const +{ + const auto itr = cucim::cpp20::find_if(begin(data), end(data), [&key](const auto& v) { return v.first == key; }); + + if (itr != end(data)) + { + return itr->second; + } + else + { + return "nocache"sv; + } +} + +static constexpr std::array, kCacheTypeCount> cache_type_values{ + { { "nocache"sv, CacheType::kNoCache }, + { "per_process"sv, CacheType::kPerProcess }, + { "shared_memory"sv, CacheType::kSharedMemory } } +}; + +CacheType lookup_cache_type(const std::string_view sv) +{ + static constexpr auto map = CacheTypeMap{ { cache_type_values } }; + return map.at(sv); +} + +static constexpr std::array, kCacheTypeCount> cache_type_str_values{ + { { CacheType::kNoCache, "nocache"sv }, + { CacheType::kPerProcess, "per_process"sv }, + { CacheType::kSharedMemory, "shared_memory"sv } } +}; + +std::string_view lookup_cache_type_str(const CacheType key) +{ + static constexpr auto map = CacheTypeStrMap{ { cache_type_str_values } }; + return map.at(key); +} + +} // namespace cucim::cache \ No newline at end of file diff --git a/cpp/src/cache/image_cache.cpp b/cpp/src/cache/image_cache.cpp new file mode 100644 index 000000000..3cf4099ce --- /dev/null +++ b/cpp/src/cache/image_cache.cpp @@ -0,0 +1,62 @@ +/* + * Apache License, Version 2.0 + * Copyright 2021 NVIDIA Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cucim/cache/image_cache.h" + +#include "cucim/cuimage.h" + +namespace cucim::cache +{ + +ImageCacheKey::ImageCacheKey(uint64_t file_hash, uint64_t index) : file_hash(file_hash), location_hash(index) +{ +} + +ImageCacheValue::ImageCacheValue(void* data, uint64_t size, void* user_obj) : data(data), size(size), user_obj(user_obj) +{ +} + +ImageCacheValue::operator bool() const +{ + return data != nullptr; +} + + +ImageCache::ImageCache(const ImageCacheConfig& config, CacheType type) : type_(type), config_(config){}; + +CacheType ImageCache::type() const +{ + return type_; +} + +const char* ImageCache::type_str() const +{ + return "nocache"; +} + +ImageCacheConfig& ImageCache::config() +{ + return config_; +} + +ImageCacheConfig ImageCache::get_config() const +{ + return config_; +} + + +} // namespace cucim::cache diff --git a/cpp/src/cache/image_cache_config.cpp b/cpp/src/cache/image_cache_config.cpp new file mode 100644 index 000000000..aab471cbc --- /dev/null +++ b/cpp/src/cache/image_cache_config.cpp @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cucim/cache/image_cache_config.h" + +#include +#include + +using json = nlohmann::json; + +namespace cucim::cache +{ + +void ImageCacheConfig::load_config(const void* json_obj) +{ + const json& cache_config = *(static_cast(json_obj)); + + if (cache_config["type"].is_string()) + { + auto cache_type = cache_config.value("type", kDefaultCacheTypeStr); + type = cucim::cache::lookup_cache_type(cache_type); + } + if (cache_config["memory_capacity"].is_number_unsigned()) + { + memory_capacity = cache_config.value("memory_capacity", kDefaultCacheMemoryCapacity); + capacity = calc_default_cache_capacity(kOneMiB * memory_capacity); + } + if (cache_config["capacity"].is_number_unsigned()) + { + capacity = cache_config.value("capacity", calc_default_cache_capacity(kOneMiB * memory_capacity)); + } + if (cache_config["mutex_pool_capacity"].is_number_unsigned()) + { + mutex_pool_capacity = cache_config.value("mutex_pool_capacity", kDefaultCacheMutexPoolCapacity); + } + if (cache_config["list_padding"].is_number_unsigned()) + { + list_padding = cache_config.value("list_padding", kDefaultCacheListPadding); + } + if (cache_config["extra_shared_memory_size"].is_number_unsigned()) + { + extra_shared_memory_size = cache_config.value("extra_shared_memory_size", kDefaultCacheExtraSharedMemorySize); + } + if (cache_config["record_stat"].is_boolean()) + { + record_stat = cache_config.value("record_stat", kDefaultCacheRecordStat); + } +} + +} // namespace cucim::cache \ No newline at end of file diff --git a/cpp/src/cache/image_cache_empty.cpp b/cpp/src/cache/image_cache_empty.cpp new file mode 100644 index 000000000..0cd0a0c5e --- /dev/null +++ b/cpp/src/cache/image_cache_empty.cpp @@ -0,0 +1,106 @@ +/* + * Apache License, Version 2.0 + * Copyright 2021 NVIDIA Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "image_cache_empty.h" + +namespace cucim::cache +{ + +EmptyImageCache::EmptyImageCache(const ImageCacheConfig& config) : ImageCache(config){}; + + +std::shared_ptr EmptyImageCache::create_key(uint64_t, uint64_t) +{ + return std::make_shared(0, 0); +} +std::shared_ptr EmptyImageCache::create_value(void*, uint64_t) +{ + return std::make_shared(nullptr, 0); +} + +void* EmptyImageCache::allocate(std::size_t) +{ + return nullptr; +} + +void EmptyImageCache::lock(uint64_t) +{ + return; +} + +void EmptyImageCache::unlock(uint64_t) +{ + return; +} + +bool EmptyImageCache::insert(std::shared_ptr&, std::shared_ptr&) +{ + return true; +} + + +uint32_t EmptyImageCache::size() const +{ + return 0; +} + +uint64_t EmptyImageCache::memory_size() const +{ + return 0; +} +uint32_t EmptyImageCache::capacity() const +{ + return 0; +} +uint64_t EmptyImageCache::memory_capacity() const +{ + return 0; +} +uint64_t EmptyImageCache::free_memory() const +{ + return 0; +} + +void EmptyImageCache::record(bool) +{ + return; +} + +bool EmptyImageCache::record() const +{ + return false; +} + +uint64_t EmptyImageCache::hit_count() const +{ + return 0; +} +uint64_t EmptyImageCache::miss_count() const +{ + return 0; +} + +void EmptyImageCache::reserve(const ImageCacheConfig&) +{ +} + +std::shared_ptr EmptyImageCache::find(const std::shared_ptr&) +{ + return std::shared_ptr(); +} + +} // namespace cucim::cache diff --git a/cpp/src/cache/image_cache_empty.h b/cpp/src/cache/image_cache_empty.h new file mode 100644 index 000000000..b592c817a --- /dev/null +++ b/cpp/src/cache/image_cache_empty.h @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CUCIM_CACHE_IMAGE_CACHE_EMPTY_H +#define CUCIM_CACHE_IMAGE_CACHE_EMPTY_H + +#include "cucim/cache/image_cache.h" + +namespace cucim::cache +{ + +/** + * @brief Image Cache for loading tiles. + * + * FIFO is used for cache replacement policy here. + * + */ + +class EmptyImageCache : public ImageCache +{ +public: + EmptyImageCache(const ImageCacheConfig& config); + + std::shared_ptr create_key(uint64_t file_hash, uint64_t index) override; + std::shared_ptr create_value(void* data, uint64_t size) override; + + void* allocate(std::size_t n) override; + void lock(uint64_t index) override; + void unlock(uint64_t index) override; + + bool insert(std::shared_ptr& key, std::shared_ptr& value) override; + + uint32_t size() const override; + uint64_t memory_size() const override; + + uint32_t capacity() const override; + uint64_t memory_capacity() const override; + uint64_t free_memory() const override; + + void record(bool value) override; + bool record() const override; + + uint64_t hit_count() const override; + uint64_t miss_count() const override; + + void reserve(const ImageCacheConfig& config) override; + + std::shared_ptr find(const std::shared_ptr& key) override; + +private: + ImageCacheConfig config_; +}; + +} // namespace cucim::cache + +#endif // CUCIM_CACHE_IMAGE_CACHE_EMPTY_H diff --git a/cpp/src/cache/image_cache_manager.cpp b/cpp/src/cache/image_cache_manager.cpp new file mode 100644 index 000000000..81782ba09 --- /dev/null +++ b/cpp/src/cache/image_cache_manager.cpp @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cucim/cache/image_cache_manager.h" + +#include "image_cache_empty.h" +#include "image_cache_per_process.h" +#include "image_cache_shared_memory.h" +#include "cucim/cuimage.h" + +#include +#include + + +namespace cucim::cache +{ + +uint32_t preferred_memory_capacity(const std::vector& image_size, + const std::vector& tile_size, + const std::vector& patch_size, + uint32_t bytes_per_pixel) +{ + // https://godbolt.org/z/9884oh9sG for test + + if (image_size.size() != 2 || tile_size.size() != 2 || patch_size.size() != 2) + { + throw std::invalid_argument( + fmt::format("Please specify arguments with correct size (image_size:{}, tile_size:{}, patch_size:{})!", + image_size.size(), tile_size.size(), patch_size.size())); + } + // Number of tiles (x-axis) + uint32_t tile_accross_count = (image_size[0] + (tile_size[0] - 1)) / tile_size[0]; + + // The maximal number of tiles (y-axis) overapped with the given patch + uint32_t patch_down_count = (patch_size[1] + (tile_size[1] - 1)) / tile_size[1] + 1; + + // (tile_accross_count) x (tile width) x (tile_height) x (patch_down_count) x (bytes per pixel) + uint64_t bytes_needed = + (static_cast(tile_accross_count) * tile_size[0] * tile_size[1] * patch_down_count * bytes_per_pixel); + uint32_t result = bytes_needed / kOneMiB; + + return (bytes_needed % kOneMiB == 0) ? result : result + 1; +} + +ImageCacheManager::ImageCacheManager() : cache_(create_cache()) +{ +} + +ImageCache& ImageCacheManager::cache() const +{ + return *cache_; +} + +std::shared_ptr ImageCacheManager::cache(const ImageCacheConfig& config) +{ + cache_ = create_cache(config); + return cache_; +} + +std::shared_ptr ImageCacheManager::get_cache() const +{ + return cache_; +} + +void ImageCacheManager::reserve(uint32_t new_memory_capacity) +{ + ImageCacheConfig cache_config; + cache_config.memory_capacity = new_memory_capacity; + cache_config.capacity = calc_default_cache_capacity(kOneMiB * new_memory_capacity); + + cache_->reserve(cache_config); +} + +void ImageCacheManager::reserve(uint32_t new_memory_capacity, uint32_t new_capacity) +{ + ImageCacheConfig cache_config; + cache_config.memory_capacity = new_memory_capacity; + cache_config.capacity = new_capacity; + + cache_->reserve(cache_config); +} + +std::unique_ptr ImageCacheManager::create_cache() const +{ + ImageCacheConfig& cache_config = cucim::CuImage::get_config()->cache(); + + return create_cache(cache_config); +} + +std::unique_ptr ImageCacheManager::create_cache(const ImageCacheConfig& cache_config) const +{ + switch (cache_config.type) + { + case CacheType::kNoCache: + return std::make_unique(cache_config); + case CacheType::kPerProcess: + return std::make_unique(cache_config); + case CacheType::kSharedMemory: + return std::make_unique(cache_config); + default: + return std::make_unique(cache_config); + } +} + +} // namespace cucim::cache diff --git a/cpp/src/cache/image_cache_per_process.cpp b/cpp/src/cache/image_cache_per_process.cpp new file mode 100644 index 000000000..f2b36889f --- /dev/null +++ b/cpp/src/cache/image_cache_per_process.cpp @@ -0,0 +1,337 @@ +/* + * Apache License, Version 2.0 + * Copyright 2021 NVIDIA Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "image_cache_per_process.h" + +#include "cucim/memory/memory_manager.h" + +#include + +namespace std +{ + +size_t hash>::operator()( + const std::shared_ptr& s) const +{ + std::size_t h1 = std::hash{}(s->file_hash); + std::size_t h2 = std::hash{}(s->location_hash); + return h1 ^ (h2 << 1); // or use boost::hash_combine +} + +bool equal_to>::operator()( + const std::shared_ptr& lhs, const std::shared_ptr& rhs) const +{ + return lhs->location_hash == rhs->location_hash; +} + +} // namespace std +namespace cucim::cache +{ + +struct PerProcessImageCacheItem +{ + PerProcessImageCacheItem(std::shared_ptr& key, std::shared_ptr& value) + : key(key), value(value) + { + } + + std::shared_ptr key; + std::shared_ptr value; +}; + +PerProcessImageCacheValue::PerProcessImageCacheValue(void* data, uint64_t size, void* user_obj) + : ImageCacheValue(data, size, user_obj){}; +PerProcessImageCacheValue::~PerProcessImageCacheValue() +{ + if (data) + { + cucim_free(data); + data = nullptr; + } +}; + +PerProcessImageCache::PerProcessImageCache(const ImageCacheConfig& config) + : ImageCache(config, CacheType::kPerProcess), + mutex_array_(config.mutex_pool_capacity), + capacity_nbytes_(kOneMiB * config.memory_capacity), + capacity_(config.capacity), + list_capacity_(config.capacity + config.list_padding), + list_padding_(config.list_padding), + mutex_pool_capacity_(config.mutex_pool_capacity), + stat_is_recorded_(config.record_stat), + list_(config.capacity + config.list_padding), + hashmap_(config.capacity){}; + +PerProcessImageCache::~PerProcessImageCache() +{ +} + +const char* PerProcessImageCache::type_str() const +{ + return "per_process"; +} + +std::shared_ptr PerProcessImageCache::create_key(uint64_t file_hash, uint64_t index) +{ + return std::make_shared(file_hash, index); +} +std::shared_ptr PerProcessImageCache::create_value(void* data, uint64_t size) +{ + return std::make_shared(data, size); +} + +void* PerProcessImageCache::allocate(std::size_t n) +{ + return cucim_malloc(n); +} + +void PerProcessImageCache::lock(uint64_t index) +{ + mutex_array_[index % mutex_pool_capacity_].lock(); +} + +void PerProcessImageCache::unlock(uint64_t index) +{ + mutex_array_[index % mutex_pool_capacity_].unlock(); +} + +bool PerProcessImageCache::insert(std::shared_ptr& key, std::shared_ptr& value) +{ + if (value->size > capacity_nbytes_ || capacity_ < 1) + { + return false; + } + + while (is_list_full() || is_memory_full(value->size)) + { + remove_front(); + } + + auto item = std::make_shared(key, value); + bool succeed = hashmap_.insert(key, item); + + if (succeed) + { + push_back(item); + } + else + { + fmt::print(stderr, "{} existing list_[] = {}\n", std::hash{}(std::this_thread::get_id()), (uint64_t)item->key->location_hash); + } + return succeed; +} + +uint32_t PerProcessImageCache::size() const +{ + uint32_t head = list_head_.load(std::memory_order_relaxed); + uint32_t tail = list_tail_.load(std::memory_order_relaxed); + + return (tail + list_capacity_ - head) % list_capacity_; +} + +uint64_t PerProcessImageCache::memory_size() const +{ + return size_nbytes_.load(std::memory_order_relaxed); +} + +uint32_t PerProcessImageCache::capacity() const +{ + return capacity_; +} + +uint64_t PerProcessImageCache::memory_capacity() const +{ + return capacity_nbytes_; +} + +uint64_t PerProcessImageCache::free_memory() const +{ + return capacity_nbytes_ - size_nbytes_.load(std::memory_order_relaxed); +} + +void PerProcessImageCache::record(bool value) +{ + config_.record_stat = value; + + stat_hit_.store(0, std::memory_order_relaxed); + stat_miss_.store(0, std::memory_order_relaxed); + stat_is_recorded_ = value; +} + +bool PerProcessImageCache::record() const +{ + return stat_is_recorded_; +} + +uint64_t PerProcessImageCache::hit_count() const +{ + return stat_hit_.load(std::memory_order_relaxed); +} +uint64_t PerProcessImageCache::miss_count() const +{ + return stat_miss_.load(std::memory_order_relaxed); +} + +void PerProcessImageCache::reserve(const ImageCacheConfig& config) +{ + uint64_t new_memory_capacity_nbytes = kOneMiB * config.memory_capacity; + uint32_t new_capacity = config.capacity; + + if (capacity_nbytes_ < new_memory_capacity_nbytes) + { + capacity_nbytes_ = new_memory_capacity_nbytes; + } + + if (capacity_ < new_capacity) + { + config_.capacity = config.capacity; + config_.memory_capacity = config.memory_capacity; + + uint32_t old_list_capacity = list_capacity_; + + capacity_ = new_capacity; + list_capacity_ = new_capacity + list_padding_; + + list_.reserve(list_capacity_); + list_.resize(list_capacity_); + hashmap_.reserve(new_capacity); + + // Move items in the vector + uint32_t head = list_head_.load(std::memory_order_relaxed); + uint32_t tail = list_tail_.load(std::memory_order_relaxed); + if (tail < head) + { + head = 0; + uint32_t new_head = old_list_capacity; + + while (head != tail) + { + list_[new_head] = list_[head]; + list_[head].reset(); + + head = (head + 1) % old_list_capacity; + new_head = (new_head + 1) % list_capacity_; + } + // Set new tail + list_tail_.store(new_head, std::memory_order_relaxed); + } + } +} + +std::shared_ptr PerProcessImageCache::find(const std::shared_ptr& key) +{ + std::shared_ptr item; + const bool found = hashmap_.find(key, item); + if(stat_is_recorded_) + { + if (found) + { + stat_hit_.fetch_add(1, std::memory_order_relaxed); + return item->value; + } + else + { + stat_miss_.fetch_add(1, std::memory_order_relaxed); + } + } + else + { + if (found) + { + return item->value; + } + } + return std::shared_ptr(); +} + +bool PerProcessImageCache::is_list_full() const +{ + if (size() >= capacity_) + { + return true; + } + return false; +} + +bool PerProcessImageCache::is_memory_full(uint64_t additional_size) const +{ + if (size_nbytes_.load(std::memory_order_relaxed) + additional_size > capacity_nbytes_) + { + return true; + } + else + { + return false; + } +} + +void PerProcessImageCache::remove_front() +{ + while (true) + { + uint32_t head = list_head_.load(std::memory_order_relaxed); + uint32_t tail = list_tail_.load(std::memory_order_relaxed); + if (head != tail) + { + // Remove front by increasing head + if (list_head_.compare_exchange_weak( + head, (head + 1) % list_capacity_, std::memory_order_release, std::memory_order_relaxed)) + { + // fmt::print(stderr, "{} remove list_[{:05}]\n", std::hash{}(std::this_thread::get_id()), head); //[print_list] + std::shared_ptr head_item = list_[head]; + // if (head_item) // it is possible that head_item is nullptr. + // { + size_nbytes_.fetch_sub(head_item->value->size, std::memory_order_relaxed); + hashmap_.erase(head_item->key); + list_[head].reset(); // decrease refcount + break; + // } + } + } + else + { + break; // already empty + } + } +} + +void PerProcessImageCache::push_back(std::shared_ptr& item) +{ + uint32_t tail = list_tail_.load(std::memory_order_relaxed); + while (true) + { + // Push back by increasing tail + if (list_tail_.compare_exchange_weak( + tail, (tail + 1) % list_capacity_, std::memory_order_release, std::memory_order_relaxed)) + { + // fmt::print(stderr, "{} list_[{:05}]={}\n", std::hash{}(std::this_thread::get_id()), tail, (uint64_t)item->key->location_hash); // [print_list] + list_[tail] = item; + size_nbytes_.fetch_add(item->value->size, std::memory_order_relaxed); + break; + } + + tail = list_tail_.load(std::memory_order_relaxed); + } +} + +bool PerProcessImageCache::erase(const std::shared_ptr& key) +{ + const bool succeed = hashmap_.erase(key); + return succeed; +} + +} // namespace cucim::cache diff --git a/cpp/src/cache/image_cache_per_process.h b/cpp/src/cache/image_cache_per_process.h new file mode 100644 index 000000000..67c325fd0 --- /dev/null +++ b/cpp/src/cache/image_cache_per_process.h @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CUCIM_CACHE_IMAGE_CACHE_PER_PROCESS_H +#define CUCIM_CACHE_IMAGE_CACHE_PER_PROCESS_H + +#include "cucim/cache/image_cache.h" + +#include +#include +#include + +namespace std +{ + +template <> +struct hash> +{ + size_t operator()(const std::shared_ptr& s) const; +}; + +template <> +struct equal_to> +{ + bool operator()(const std::shared_ptr& lhs, + const std::shared_ptr& rhs) const; +}; + +} // namespace std + +namespace cucim::cache +{ + +// Forward declarations +struct PerProcessImageCacheItem; + +struct PerProcessImageCacheValue : public ImageCacheValue +{ + PerProcessImageCacheValue(void* data, uint64_t size, void* user_obj = nullptr); + ~PerProcessImageCacheValue() override; +}; + + +/** + * @brief Image Cache for loading tiles. + * + * FIFO is used for cache replacement policy here. + * + */ + +class PerProcessImageCache : public ImageCache +{ +public: + PerProcessImageCache(const ImageCacheConfig& config); + ~PerProcessImageCache(); + + const char* type_str() const override; + + std::shared_ptr create_key(uint64_t file_hash, uint64_t index) override; + std::shared_ptr create_value(void* data, uint64_t size) override; + + void* allocate(std::size_t n) override; + void lock(uint64_t index) override; + void unlock(uint64_t index) override; + + bool insert(std::shared_ptr& key, std::shared_ptr& value) override; + + uint32_t size() const override; + uint64_t memory_size() const override; + + uint32_t capacity() const override; + uint64_t memory_capacity() const override; + uint64_t free_memory() const override; + + void record(bool value) override; + bool record() const override; + + uint64_t hit_count() const override; + uint64_t miss_count() const override; + + void reserve(const ImageCacheConfig& config) override; + + std::shared_ptr find(const std::shared_ptr& key) override; + +private: + bool is_list_full() const; + bool is_memory_full(uint64_t additional_size = 0) const; + void remove_front(); + void push_back(std::shared_ptr& item); + bool erase(const std::shared_ptr& key); + + std::vector mutex_array_; + + std::atomic size_nbytes_ = 0; /// size of cache memory used + uint64_t capacity_nbytes_ = 0; /// size of cache memory allocated + uint32_t capacity_ = 0; /// capacity of hashmap + uint32_t list_capacity_ = 0; /// capacity of list + uint32_t list_padding_ = 0; /// gap between head and tail + uint32_t mutex_pool_capacity_ = 0; /// capacity of mutex pool + + std::atomic stat_hit_ = 0; /// cache hit count + std::atomic stat_miss_ = 0; /// cache miss mcount + bool stat_is_recorded_ = false; /// whether if cache stat is recorded or not + + std::atomic list_head_ = 0; /// head + std::atomic list_tail_ = 0; /// tail + + std::vector> list_; /// circular list using vector + libcuckoo::cuckoohash_map, std::shared_ptr> hashmap_; /// hashmap + /// using + /// libcuckoo +}; + +} // namespace cucim::cache + +#endif // CUCIM_CACHE_IMAGE_CACHE_PER_PROCESS_H diff --git a/cpp/src/cache/image_cache_shared_memory.cpp b/cpp/src/cache/image_cache_shared_memory.cpp new file mode 100644 index 000000000..d09e8d47c --- /dev/null +++ b/cpp/src/cache/image_cache_shared_memory.cpp @@ -0,0 +1,595 @@ +/* + * Apache License, Version 2.0 + * Copyright 2021 NVIDIA Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "image_cache_shared_memory.h" + +#include "cucim/cuimage.h" +#include "cucim/memory/memory_manager.h" + +#include +#include + + +template <> +struct boost::hash +{ + typedef cucim::cache::MapKey argument_type; + typedef size_t result_type; + result_type operator()(argument_type::type& s) const + { + std::size_t h1 = std::hash{}(s->file_hash); + std::size_t h2 = std::hash{}(s->location_hash); + return h1 ^ (h2 << 1); // or use boost::hash_combine + } + + result_type operator()(const argument_type::type& s) const + { + std::size_t h1 = std::hash{}(s->file_hash); + std::size_t h2 = std::hash{}(s->location_hash); + return h1 ^ (h2 << 1); // or use boost::hash_combine + } + + result_type operator()(const cucim::cache::ImageCacheKey& s) const + { + std::size_t h1 = std::hash{}(s.file_hash); + std::size_t h2 = std::hash{}(s.location_hash); + return h1 ^ (h2 << 1); // or use boost::hash_combine + } + + result_type operator()(const std::shared_ptr& s) const + { + std::size_t h1 = std::hash{}(s->file_hash); + std::size_t h2 = std::hash{}(s->location_hash); + return h1 ^ (h2 << 1); // or use boost::hash_combine + } +}; + +template <> +struct std::equal_to +{ + typedef cucim::cache::MapKey argument_type; + + bool operator()(const argument_type::type& lhs, const argument_type::type& rhs) const + { + return lhs->location_hash == rhs->location_hash && lhs->file_hash == rhs->file_hash; + } + + bool operator()(const argument_type::type& lhs, const cucim::cache::ImageCacheKey& rhs) const + { + return lhs->location_hash == rhs.location_hash && lhs->file_hash == rhs.file_hash; + } + + bool operator()(const cucim::cache::ImageCacheKey& lhs, const std::shared_ptr& rhs) const + { + return lhs.location_hash == rhs->location_hash && lhs.file_hash == rhs->file_hash; + } +}; + + +namespace cucim::cache +{ + + +template +struct null_deleter +{ +private: + P p_; + +public: + null_deleter(const P& p) : p_(p) + { + } + void operator()(void const*) + { + p_.reset(); + } + + P const& get() const + { + return p_; + } +}; + + +template +shared_mem_deleter::shared_mem_deleter(std::unique_ptr& segment) + : seg_(segment) +{ +} + +template +void shared_mem_deleter::operator()(T* p) +{ + if (seg_) + { + seg_->destroy_ptr(p); + } +} + +// Apparently, cache requires about 13MiB + (400 bytes per one capacity) for the data structure (hashmap+vector). +// so allocate additional bytes which are 100MiB (exta) + 512(rough estimation per item) * (capacity) bytes. +// Not having enough segment(shared) memory can cause a memory allocation failure and the process can get stuck. +// https://stackoverflow.com/questions/4166642/how-much-memory-should-managed-shared-memory-allocate-boost +static size_t calc_segment_size(const ImageCacheConfig& config) +{ + return kOneMiB * config.memory_capacity + (config.extra_shared_memory_size * kOneMiB + 512 * config.capacity); +} + +template +using deleter_type = boost::interprocess::shared_ptr< + T, + boost::interprocess::allocator< + void, + boost::interprocess::segment_manager, + boost::interprocess::iset_index>>, + boost::interprocess::deleter< + T, + boost::interprocess::segment_manager, + boost::interprocess::iset_index>>>; + +struct ImageCacheItemDetail +{ + ImageCacheItemDetail(deleter_type& key, deleter_type& value) + : key(key), value(value) + { + } + deleter_type key; + deleter_type value; +}; + +SharedMemoryImageCacheValue::SharedMemoryImageCacheValue(void* data, uint64_t size, void* user_obj) + : ImageCacheValue(data, size, user_obj){}; + +SharedMemoryImageCacheValue::~SharedMemoryImageCacheValue() +{ + if (data) + { + if (user_obj) + { + static_cast(user_obj)->deallocate(data); + data = nullptr; + } + } +}; + +SharedMemoryImageCache::SharedMemoryImageCache(const ImageCacheConfig& config) + : ImageCache(config, CacheType::kSharedMemory), + segment_(create_segment(config)), + // mutex_array_(nullptr, shared_mem_deleter(segment_)), + size_nbytes_(nullptr, shared_mem_deleter>(segment_)), + capacity_nbytes_(nullptr, shared_mem_deleter(segment_)), + capacity_(nullptr, shared_mem_deleter(segment_)), + list_capacity_(nullptr, shared_mem_deleter(segment_)), + list_padding_(nullptr, shared_mem_deleter(segment_)), + mutex_pool_capacity_(nullptr, shared_mem_deleter(segment_)), + stat_hit_(nullptr, shared_mem_deleter>(segment_)), + stat_miss_(nullptr, shared_mem_deleter>(segment_)), + stat_is_recorded_(nullptr, shared_mem_deleter(segment_)), + list_head_(nullptr, shared_mem_deleter>(segment_)), + list_tail_(nullptr, shared_mem_deleter>(segment_)) +{ + const uint64_t& memory_capacity = config.memory_capacity; + const uint32_t& capacity = config.capacity; + const uint32_t& mutex_pool_capacity = config.mutex_pool_capacity; + const bool& record_stat = config.record_stat; + + try + { + // mutex_array_.reset(segment_->find_or_construct_it( + // "cucim-mutex")[mutex_pool_capacity]()); + mutex_array_ = + segment_->construct_it("cucim-mutex")[mutex_pool_capacity](); + + size_nbytes_.reset(segment_->find_or_construct>("size_nbytes_")(0)); /// size of cache + /// memory used + capacity_nbytes_.reset( + segment_->find_or_construct("capacity_nbytes_")(kOneMiB * memory_capacity)); /// size of + /// cache + /// memory + /// allocated + + capacity_.reset(segment_->find_or_construct("capacity_")(capacity)); /// capacity + /// of hashmap + list_capacity_.reset( + segment_->find_or_construct("list_capacity_")(capacity + config.list_padding)); /// capacity + /// of + /// list + + list_padding_.reset(segment_->find_or_construct("list_padding_")(config.list_padding)); /// gap + /// between + /// head and + /// tail + + mutex_pool_capacity_.reset(segment_->find_or_construct("mutex_pool_capacity_")(mutex_pool_capacity)); + + stat_hit_.reset(segment_->find_or_construct>("stat_hit_")(0)); /// cache hit count + stat_miss_.reset(segment_->find_or_construct>("stat_miss_")(0)); /// cache miss mcount + stat_is_recorded_.reset(segment_->find_or_construct("stat_is_recorded_")(record_stat)); /// whether if + /// cache stat is + /// recorded or + /// not + + list_head_.reset(segment_->find_or_construct>("list_head_")(0)); /// head + list_tail_.reset(segment_->find_or_construct>("list_tail_")(0)); /// tail + + list_ = boost::interprocess::make_managed_shared_ptr( + segment_->find_or_construct("cucim-list")( + *list_capacity_, ValueAllocator(segment_->get_segment_manager())), + *segment_); + + hashmap_ = boost::interprocess::make_managed_shared_ptr( + segment_->find_or_construct("cucim-hashmap")( + calc_hashmap_capacity(capacity), MapKeyHasher(), MakKeyEqual(), + ImageCacheAllocator(segment_->get_segment_manager())), + *segment_); + } + catch (const boost::interprocess::bad_alloc& e) + { + throw std::runtime_error(fmt::format( + "[Error] Couldn't allocate shared memory (size: {}). Please increase the cache memory capacity.\n", + memory_capacity)); + } +}; + +SharedMemoryImageCache::~SharedMemoryImageCache() +{ + { + // Destroy objects that uses the shared memory object(segment_) + hashmap_.reset(); + list_.reset(); + segment_->destroy("cucim-mutex"); + mutex_array_ = nullptr; + // mutex_array_.reset(); + + // Destroy the shared memory object + segment_.reset(); + } + + bool succeed = remove_shmem(); + if (!succeed) + { + fmt::print(stderr, "[Warning] Couldn't delete the shared memory object '{}'.", + cucim::CuImage::get_config()->shm_name()); + } +} + +const char* SharedMemoryImageCache::type_str() const +{ + return "shared_memory"; +} + +std::shared_ptr SharedMemoryImageCache::create_key(uint64_t file_hash, uint64_t index) +{ + auto key = boost::interprocess::make_managed_shared_ptr( + segment_->find_or_construct(boost::interprocess::anonymous_instance)(file_hash, index), *segment_); + + return std::shared_ptr(key.get().get(), null_deleter(key)); +} +std::shared_ptr SharedMemoryImageCache::create_value(void* data, uint64_t size) +{ + auto value = boost::interprocess::make_managed_shared_ptr( + segment_->find_or_construct(boost::interprocess::anonymous_instance)( + data, size, &*segment_), + *segment_); + + return std::shared_ptr(value.get().get(), null_deleter(value)); +} + +void* SharedMemoryImageCache::allocate(std::size_t n) +{ + // TODO: handling OOM exception + void* temp = nullptr; + try + { + // fmt::print(stderr, "## pid: {} memory_size: {}, memory_capacity: {}, free_memory: {}\n", getpid(), + // memory_size(), memory_capacity(), free_memory()); + // fmt::print( + // stderr, "## pid: {} size_nbytes: {}, capacity_nbytes: {}\n", getpid(), *size_nbytes_, *capacity_nbytes_); + // fmt::print(stderr, "## pid: {}, {} hit:{} miss:{} total:{} | {}/{} hash size:{}\n", getpid(), + // segment_->get_free_memory(), *stat_hit_, *stat_miss_, *stat_hit_ + *stat_miss_, size(), + // *list_capacity_, hashmap_->size()); + + temp = segment_->allocate(n); + } + catch (const std::exception& e) + { + throw std::runtime_error(fmt::format( + "[Error] Couldn't allocate shared memory (size: {}). Please increase the cache memory capacity.\n", n)); + } + + return temp; +} + +void SharedMemoryImageCache::lock(uint64_t index) +{ + // fmt::print(stderr, "# {}: {} {} [{}]- lock\n", + // std::chrono::high_resolution_clock::now().time_since_epoch().count(), + // getpid(), index, index % *mutex_pool_capacity_); + mutex_array_[index % *mutex_pool_capacity_].lock(); +} + +void SharedMemoryImageCache::unlock(uint64_t index) +{ + // fmt::print(stderr, "# {}: {} {} [{}]- unlock\n", + // std::chrono::high_resolution_clock::now().time_since_epoch().count(), getpid(), index, + // index % *mutex_pool_capacity_); + mutex_array_[index % *mutex_pool_capacity_].unlock(); +} + +bool SharedMemoryImageCache::insert(std::shared_ptr& key, std::shared_ptr& value) +{ + if (value->size > *capacity_nbytes_ || *capacity_ < 1) + { + return false; + } + + while (is_list_full() || is_memory_full(value->size)) + { + remove_front(); + } + + auto key_impl = std::get_deleter>>(key)->get(); + auto value_impl = std::get_deleter>>(value)->get(); + auto item = boost::interprocess::make_managed_shared_ptr( + segment_->find_or_construct(boost::interprocess::anonymous_instance)(key_impl, value_impl), + *segment_); + + bool succeed = hashmap_->insert(key_impl, item); + if (succeed) + { + push_back(item); + } + return succeed; +} + +uint32_t SharedMemoryImageCache::size() const +{ + uint32_t head = list_head_->load(std::memory_order_relaxed); + uint32_t tail = list_tail_->load(std::memory_order_relaxed); + + return (tail + *list_capacity_ - head) % *list_capacity_; +} + +uint64_t SharedMemoryImageCache::memory_size() const +{ + return size_nbytes_->load(std::memory_order_relaxed); +} + +uint32_t SharedMemoryImageCache::capacity() const +{ + return *capacity_; +} + +uint64_t SharedMemoryImageCache::memory_capacity() const +{ + // Return segment's size instead of the logical capacity. + return segment_->get_size(); + // return *capacity_nbytes_; +} + +uint64_t SharedMemoryImageCache::free_memory() const +{ + // Return segment's free memory instead of the logical free memory. + return segment_->get_free_memory(); + // return *capacity_nbytes_ - size_nbytes_->load(std::memory_order_relaxed); +} + +void SharedMemoryImageCache::record(bool value) +{ + config_.record_stat = value; + + stat_hit_->store(0, std::memory_order_relaxed); + stat_miss_->store(0, std::memory_order_relaxed); + *stat_is_recorded_ = value; +} + +bool SharedMemoryImageCache::record() const +{ + return *stat_is_recorded_; +} + +uint64_t SharedMemoryImageCache::hit_count() const +{ + return stat_hit_->load(std::memory_order_relaxed); +} +uint64_t SharedMemoryImageCache::miss_count() const +{ + return stat_miss_->load(std::memory_order_relaxed); +} + +void SharedMemoryImageCache::reserve(const ImageCacheConfig& config) +{ + uint64_t new_memory_capacity_nbytes = kOneMiB * config.memory_capacity; + uint32_t new_capacity = config.capacity; + + if ((*capacity_nbytes_) < new_memory_capacity_nbytes) + { + (*capacity_nbytes_) = new_memory_capacity_nbytes; + } + + if ((*capacity_) < new_capacity) + { + config_.capacity = config.capacity; + config_.memory_capacity = config.memory_capacity; + + uint32_t old_list_capacity = (*list_capacity_); + + (*capacity_) = new_capacity; + (*list_capacity_) = new_capacity + (*list_padding_); + + list_->reserve(*list_capacity_); + list_->resize(*list_capacity_); + hashmap_->reserve(new_capacity); + + // Move items in the vector + uint32_t head = (*list_head_).load(std::memory_order_relaxed); + uint32_t tail = (*list_tail_).load(std::memory_order_relaxed); + if (tail < head) + { + head = 0; + uint32_t new_head = old_list_capacity; + + while (head != tail) + { + (*list_)[new_head] = (*list_)[head]; + (*list_)[head].reset(); + + head = (head + 1) % old_list_capacity; + new_head = (new_head + 1) % (*list_capacity_); + } + // Set new tail + (*list_tail_).store(new_head, std::memory_order_relaxed); + } + } +} + +std::shared_ptr SharedMemoryImageCache::find(const std::shared_ptr& key) +{ + MapValue::type item; + auto key_impl = std::get_deleter>>(key)->get(); + const bool found = hashmap_->find(key_impl, item); + if (*stat_is_recorded_) + { + if (found) + { + (*stat_hit_).fetch_add(1, std::memory_order_relaxed); + return std::shared_ptr(item->value.get().get(), null_deleter(item)); + } + else + { + (*stat_miss_).fetch_add(1, std::memory_order_relaxed); + } + } + else + { + if (found) + { + return std::shared_ptr(item->value.get().get(), null_deleter(item)); + } + } + return std::shared_ptr(); +} + +bool SharedMemoryImageCache::is_list_full() const +{ + if (size() >= *capacity_) + { + return true; + } + return false; +} + +bool SharedMemoryImageCache::is_memory_full(uint64_t additional_size) const +{ + if (size_nbytes_->load(std::memory_order_relaxed) + additional_size > *capacity_nbytes_) + { + return true; + } + else + { + return false; + } +} + +void SharedMemoryImageCache::remove_front() +{ + while (true) + { + uint32_t head = (*list_head_).load(std::memory_order_relaxed); + uint32_t tail = (*list_tail_).load(std::memory_order_relaxed); + if (head != tail) + { + // Remove front by increasing head + if ((*list_head_) + .compare_exchange_weak( + head, (head + 1) % (*list_capacity_), std::memory_order_release, std::memory_order_relaxed)) + { + auto& head_item = (*list_)[head]; + if (head_item) // it is possible that head_item is nullptr + { + (*size_nbytes_).fetch_sub(head_item->value->size, std::memory_order_relaxed); + hashmap_->erase(head_item->key); + (*list_)[head].reset(); // decrease refcount + break; + } + } + } + else + { + break; // already empty + } + } +} + +void SharedMemoryImageCache::push_back(cache_item_type& item) +{ + uint32_t tail = (*list_tail_).load(std::memory_order_relaxed); + while (true) + { + // Push back by increasing tail + if ((*list_tail_) + .compare_exchange_weak( + tail, (tail + 1) % (*list_capacity_), std::memory_order_release, std::memory_order_relaxed)) + { + (*list_)[tail] = item; + (*size_nbytes_).fetch_add(item->value->size, std::memory_order_relaxed); + break; + } + + tail = (*list_tail_).load(std::memory_order_relaxed); + } +} + +bool SharedMemoryImageCache::erase(const std::shared_ptr& key) +{ + auto key_impl = std::get_deleter>>(key)->get(); + const bool succeed = hashmap_->erase(key_impl); + return succeed; +} + + +bool SharedMemoryImageCache::remove_shmem() +{ + cucim::config::Config* config = cucim::CuImage::get_config(); + if (config) + { + std::string shm_name = config->shm_name(); + return boost::interprocess::shared_memory_object::remove(shm_name.c_str()); + } + return false; +} + +uint32_t SharedMemoryImageCache::calc_hashmap_capacity(uint32_t capacity) +{ + return std::max((1U << 16) * 4, capacity * 4); +} + +std::unique_ptr SharedMemoryImageCache::create_segment( + const ImageCacheConfig& config) +{ + // Remove the existing shared memory object. + remove_shmem(); + + auto segment = std::make_unique( + boost::interprocess::open_or_create, cucim::CuImage::get_config()->shm_name().c_str(), calc_segment_size(config)); + return segment; +} + +} // namespace cucim::cache diff --git a/cpp/src/cache/image_cache_shared_memory.h b/cpp/src/cache/image_cache_shared_memory.h new file mode 100644 index 000000000..dcf5b560c --- /dev/null +++ b/cpp/src/cache/image_cache_shared_memory.h @@ -0,0 +1,195 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CUCIM_CACHE_IMAGE_CACHE_SHARED_MEMORY_H +#define CUCIM_CACHE_IMAGE_CACHE_SHARED_MEMORY_H + +#include "cucim/cache/image_cache.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + + +namespace cucim::cache +{ + +// Forward declarations +struct ImageCacheItemDetail; + +struct SharedMemoryImageCacheValue : public ImageCacheValue +{ + SharedMemoryImageCacheValue(void* data, uint64_t size, void* user_obj = nullptr); + ~SharedMemoryImageCacheValue() override; +}; + +template +struct shared_mem_deleter +{ + shared_mem_deleter(std::unique_ptr& segment); + void operator()(T* p); + +private: + std::unique_ptr& seg_; +}; + +template +using boost_unique_ptr = std::unique_ptr>; + + +template +using boost_shared_ptr = boost::interprocess::shared_ptr< + T, + boost::interprocess::allocator< + void, + boost::interprocess::segment_manager, + boost::interprocess::iset_index>>, + boost::interprocess::deleter< + T, + boost::interprocess::segment_manager, + boost::interprocess::iset_index>>>; + + +using MapKey = boost::interprocess::managed_shared_ptr; + +using MapValue = + boost::interprocess::managed_shared_ptr; + +using KeyValuePair = std::pair; +using ImageCacheAllocator = + boost::interprocess::allocator; + +using ValueAllocator = std::scoped_allocator_adaptor< + boost::interprocess::allocator>; + +using MapKeyHasher = boost::hash; +using MakKeyEqual = std::equal_to; +using ImageCacheType = + libcuckoo::cuckoohash_map, std::equal_to, ImageCacheAllocator>; +using QueueType = std::vector; + +template +using cache_item_type = boost::interprocess::shared_ptr< + T, + boost::interprocess::allocator< + void, + boost::interprocess::segment_manager< + char, + boost::interprocess::rbtree_best_fit, + 0UL>, + boost::interprocess::iset_index>>, + boost::interprocess::deleter< + T, + boost::interprocess::segment_manager< + char, + boost::interprocess::rbtree_best_fit, + 0UL>, + boost::interprocess::iset_index>>>; + +/** + * @brief Image Cache for loading tiles. + * + * FIFO is used for cache replacement policy here. + * + */ + +class SharedMemoryImageCache : public ImageCache +{ +public: + SharedMemoryImageCache(const ImageCacheConfig& config); + ~SharedMemoryImageCache(); + + const char* type_str() const override; + + std::shared_ptr create_key(uint64_t file_hash, uint64_t index) override; + std::shared_ptr create_value(void* data, uint64_t size) override; + + void* allocate(std::size_t n) override; + void lock(uint64_t index) override; + void unlock(uint64_t index) override; + + bool insert(std::shared_ptr& key, std::shared_ptr& value) override; + + uint32_t size() const override; + uint64_t memory_size() const override; + + uint32_t capacity() const override; + uint64_t memory_capacity() const override; + uint64_t free_memory() const override; + + void record(bool value) override; + bool record() const override; + + uint64_t hit_count() const override; + uint64_t miss_count() const override; + + void reserve(const ImageCacheConfig& config) override; + + std::shared_ptr find(const std::shared_ptr& key) override; + +private: + bool is_list_full() const; + bool is_memory_full(uint64_t additional_size = 0) const; + void remove_front(); + void push_back(cache_item_type& item); + bool erase(const std::shared_ptr& key); + + std::shared_ptr create_cache_item(std::shared_ptr& key, + std::shared_ptr& value); + + static bool remove_shmem(); + + uint32_t calc_hashmap_capacity(uint32_t capacity); + std::unique_ptr create_segment(const ImageCacheConfig& config); + + std::unique_ptr segment_; + + // boost_unique_ptr mutex_array_; + boost::interprocess::interprocess_mutex* mutex_array_ = nullptr; + boost_unique_ptr> size_nbytes_; /// size of cache; + /// memory used + boost_unique_ptr capacity_nbytes_; /// size of cache memory allocated + boost_unique_ptr capacity_; /// capacity of hashmap + boost_unique_ptr list_capacity_; /// capacity of list + boost_unique_ptr list_padding_; /// gap between head and tail + boost_unique_ptr mutex_pool_capacity_; /// capacity of mutex pool + + boost_unique_ptr> stat_hit_; /// cache hit count + boost_unique_ptr> stat_miss_; /// cache miss mcount + boost_unique_ptr stat_is_recorded_; /// whether if cache stat is recorded or not + + boost_unique_ptr> list_head_; /// head + boost_unique_ptr> list_tail_; /// tail + + boost_shared_ptr list_; + boost_shared_ptr hashmap_; +}; + +} // namespace cucim::cache + +#endif // CUCIM_CACHE_IMAGE_CACHE_SHARED_MEMORY_H diff --git a/cpp/src/config/config.cpp b/cpp/src/config/config.cpp new file mode 100644 index 000000000..89010673a --- /dev/null +++ b/cpp/src/config/config.cpp @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cucim/config/config.h" + +#include "cucim/cache/cache_type.h" +#include "cucim/util/file.h" + +#include +#include + +#include +#include +#include + +using json = nlohmann::json; + +namespace cucim::config +{ + +Config::Config() +{ + std::string config_path = get_config_path(); + + bool is_configured_from_file = false; + if (!config_path.empty()) + { + is_configured_from_file = parse_config(config_path); + } + if (is_configured_from_file) + { + source_path_ = config_path; + } + else + { + set_default_configuration(); + } +} + +cucim::cache::ImageCacheConfig& Config::cache() +{ + return cache_; +} + +std::string Config::shm_name() const +{ + return fmt::format("cucim-shm.{}", pgid()); +} + + +pid_t Config::pid() const +{ + return getpid(); +} +pid_t Config::ppid() const +{ + return getppid(); +} +pid_t Config::pgid() const +{ + return getpgid(getpid()); +} + + +std::string Config::get_config_path() const +{ + // Read config file from: + // 1. A path specified by 'CUCIM_CONFIG_PATH' + // 2. (current folder)/.cucim.json + // 3. $HOME/.cucim.json + std::string config_path; + + if (const char* env_p = std::getenv("CUCIM_CONFIG_PATH")) + { + if (cucim::util::file_exists(env_p)) + { + config_path = env_p; + } + } + if (config_path.empty() && cucim::util::file_exists(kDefaultConfigFileName)) + { + config_path = kDefaultConfigFileName; + } + if (config_path.empty()) + { + if (const char* env_p = std::getenv("HOME")) + { + auto home_path = (std::filesystem::path(env_p) / kDefaultConfigFileName).string(); + if (cucim::util::file_exists(home_path.c_str())) + { + config_path = home_path; + } + } + } + return config_path; +} +bool Config::parse_config(std::string& path) +{ + try + { + std::ifstream ifs(path); + json obj = json::parse(ifs, nullptr /*cb*/, true /*allow_exceptions*/, true /*ignore_comments*/); + json cache = obj["cache"]; + if (cache.is_object()) + { + cache_.load_config(&cache); + } + } + catch (const json::parse_error& e) + { + fmt::print(stderr, + "Failed to load configuration file: {}\n" + " message: {}\n" + " exception id: {}\n" + " byte position of error: {}\n", + path, e.what(), e.id, e.byte); + return false; + } + return true; +} +void Config::set_default_configuration() +{ + // Override if the initializer of Config class is not enough. +} + +} // namespace cucim::config \ No newline at end of file diff --git a/cpp/src/cuimage.cpp b/cpp/src/cuimage.cpp index eb2df85dc..6e9854919 100644 --- a/cpp/src/cuimage.cpp +++ b/cpp/src/cuimage.cpp @@ -16,14 +16,22 @@ #include "cucim/cuimage.h" -#include -#include #include -#include +#include +#include -#include "cucim/core/framework.h" +#if CUCIM_SUPPORT_CUDA +# include +#endif #include +#include "cucim/util/cuda.h" +#include "cucim/util/file.h" + + +#define XSTR(x) STR(x) +#define STR(x) #x + namespace cucim { @@ -66,6 +74,8 @@ ResolutionInfo::ResolutionInfo(io::format::ResolutionInfoDesc desc) level_dimensions_.end(), &desc.level_dimensions[0], &desc.level_dimensions[level_count_ * level_ndim_]); level_downsamples_.insert( level_downsamples_.end(), &desc.level_downsamples[0], &desc.level_downsamples[level_count_]); + level_tile_sizes_.insert( + level_tile_sizes_.end(), &desc.level_tile_sizes[0], &desc.level_tile_sizes[level_count_ * level_ndim_]); } uint16_t ResolutionInfo::level_count() const { @@ -98,6 +108,21 @@ float ResolutionInfo::level_downsample(uint16_t level) const } return level_downsamples_.at(level); } +const std::vector& ResolutionInfo::level_tile_sizes() const +{ + return level_tile_sizes_; +} +std::vector ResolutionInfo::level_tile_size(uint16_t level) const +{ + if (level >= level_count_) + { + throw std::invalid_argument(fmt::format("'level' should be less than {}", level_count_)); + } + std::vector result; + auto start_index = level_tile_sizes_.begin() + (level * level_ndim_); + result.insert(result.end(), start_index, start_index + level_ndim_); + return result; +} DetectedFormat detect_format(filesystem::Path path) { @@ -108,6 +133,9 @@ DetectedFormat detect_format(filesystem::Path path) Framework* CuImage::framework_ = cucim::acquire_framework("cucim"); +std::unique_ptr CuImage::config_ = std::make_unique(); +std::unique_ptr CuImage::cache_manager_ = std::make_unique(); + CuImage::CuImage(const filesystem::Path& path) { @@ -228,8 +256,29 @@ CuImage::~CuImage() { if (image_data_->container.data) { - cucim_free(image_data_->container.data); - image_data_->container.data = nullptr; + DLContext& ctx = image_data_->container.ctx; + auto device_type = static_cast(ctx.device_type); + switch (device_type) + { + case io::DeviceType::kCPU: + cucim_free(image_data_->container.data); + image_data_->container.data = nullptr; + break; + case io::DeviceType::kCUDA: + cudaError_t cuda_status; + CUDA_TRY(cudaFree(image_data_->container.data)); + image_data_->container.data = nullptr; + if (cuda_status) + { + fmt::print(stderr, "[Error] Cannot free memory!"); + } + break; + case io::DeviceType::kPinned: + case io::DeviceType::kCPUShared: + case io::DeviceType::kCUDAShared: + fmt::print(stderr, "Device type {} is not supported!", device_type); + break; + } } if (image_data_->container.shape) { @@ -241,6 +290,11 @@ CuImage::~CuImage() cucim_free(image_data_->container.strides); image_data_->container.strides = nullptr; } + if (image_data_->shm_name) + { + cucim_free(image_data_->shm_name); + image_data_->shm_name = nullptr; + } cucim_free(image_data_); image_data_ = nullptr; } @@ -251,6 +305,26 @@ Framework* CuImage::get_framework() return framework_; } +config::Config* CuImage::get_config() +{ + return config_.get(); +} + +cache::ImageCacheManager& CuImage::cache_manager() +{ + return *cache_manager_; +} + +std::shared_ptr CuImage::cache() +{ + return cache_manager_->get_cache(); +} + +std::shared_ptr CuImage::cache(cache::ImageCacheConfig& config) +{ + return cache_manager_->cache(config); +} + filesystem::Path CuImage::path() const { return file_handle_.path == nullptr ? "" : file_handle_.path; @@ -261,7 +335,18 @@ bool CuImage::is_loaded() const } io::Device CuImage::device() const { - return io::Device("cpu"); + if (image_data_) + { + DLContext& ctx = image_data_->container.ctx; + auto device_type = static_cast(ctx.device_type); + auto device_id = static_cast(ctx.device_id); + std::string shm_name = image_data_->shm_name == nullptr ? "" : image_data_->shm_name; + return io::Device(device_type, device_id, shm_name); + } + else + { + return io::Device("cpu"); + } } Metadata CuImage::raw_metadata() const { @@ -471,7 +556,7 @@ memory::DLTContainer CuImage::container() const { if (image_data_) { - return memory::DLTContainer(&image_data_->container); + return memory::DLTContainer(&image_data_->container, image_data_->shm_name); } else { @@ -479,17 +564,14 @@ memory::DLTContainer CuImage::container() const } } -CuImage CuImage::read_region(std::vector location, - std::vector size, +CuImage CuImage::read_region(std::vector&& location, + std::vector&& size, uint16_t level, - DimIndices region_dim_indices, - io::Device device, + const DimIndices& region_dim_indices, + const io::Device& device, DLTensor* buf, - std::string shm_name) + const std::string& shm_name) const { - (void)location; - (void)size; - (void)level; (void)region_dim_indices; (void)device; (void)buf; @@ -514,13 +596,14 @@ CuImage CuImage::read_region(std::vector location, size.insert(size.end(), level_dimension.begin(), level_dimension.end()); } + std::string device_name = std::string(device); cucim::io::format::ImageReaderRegionRequestDesc request{}; int64_t request_location[2] = { location[0], location[1] }; request.location = request_location; request.level = level; int64_t request_size[2] = { size[0], size[1] }; request.size = request_size; - request.device = const_cast("cpu"); + request.device = device_name.data(); // cucim::io::format::ImageDataDesc image_data{}; @@ -541,7 +624,7 @@ CuImage CuImage::read_region(std::vector location, } else // Read region by cropping image { - crop_image(image_metadata_, &request, image_data); + crop_image(request, *image_data); } } catch (std::invalid_argument& e) @@ -652,6 +735,10 @@ CuImage CuImage::read_region(std::vector location, level_downsamples.reserve(1); level_downsamples.emplace_back(1.0); + std::pmr::vector level_tile_sizes(&resource); + level_tile_sizes.reserve(level_ndim * 1); // it has only one size + level_tile_sizes.insert(level_tile_sizes.end(), &size[0], &size[level_ndim]); // same with level_dimension + // Empty associated images const size_t associated_image_count = 0; std::pmr::vector associated_image_names(&resource); @@ -662,21 +749,22 @@ CuImage CuImage::read_region(std::vector location, std::string_view json_data{ "" }; out_metadata.ndim(ndim); - out_metadata.dims(dims); - out_metadata.shape(shape); + out_metadata.dims(std::move(dims)); + out_metadata.shape(std::move(shape)); out_metadata.dtype(dtype); - out_metadata.channel_names(channel_names); - out_metadata.spacing(spacing); - out_metadata.spacing_units(spacing_units); - out_metadata.origin(origin); - out_metadata.direction(direction); - out_metadata.coord_sys(coord_sys); + out_metadata.channel_names(std::move(channel_names)); + out_metadata.spacing(std::move(spacing)); + out_metadata.spacing_units(std::move(spacing_units)); + out_metadata.origin(std::move(origin)); + out_metadata.direction(std::move(direction)); + out_metadata.coord_sys(std::move(coord_sys)); out_metadata.level_count(1); out_metadata.level_ndim(2); - out_metadata.level_dimensions(level_dimensions); - out_metadata.level_downsamples(level_downsamples); + out_metadata.level_dimensions(std::move(level_dimensions)); + out_metadata.level_downsamples(std::move(level_downsamples)); + out_metadata.level_tile_sizes(std::move(level_tile_sizes)); out_metadata.image_count(associated_image_count); - out_metadata.image_names(associated_image_names); + out_metadata.image_names(std::move(associated_image_names)); out_metadata.raw_data(raw_data); out_metadata.json_data(json_data); @@ -688,14 +776,15 @@ std::set CuImage::associated_images() const return associated_images_; } -CuImage CuImage::associated_image(const std::string& name) const +CuImage CuImage::associated_image(const std::string& name, const io::Device& device) const { auto it = associated_images_.find(name); if (it != associated_images_.end()) { io::format::ImageReaderRegionRequestDesc request{}; request.associated_image_name = const_cast(name.c_str()); - request.device = const_cast("cpu"); + std::string device_name = std::string(device); + request.device = device_name.data(); io::format::ImageDataDesc* out_image_data = static_cast(cucim_malloc(sizeof(cucim::io::format::ImageDataDesc))); @@ -733,14 +822,34 @@ void CuImage::save(std::string file_path) const fs << width << "\n" << height << "\n" << 0xff << "\n"; uint8_t* data = static_cast(image_data_->container.data); - size_t data_size = width * height * 3; - for (unsigned int i = 0; (i < data_size) && fs.good(); ++i) + uint8_t* raster = nullptr; + size_t raster_size = width * height * 3; + + const cucim::io::Device& in_device = device(); + if (in_device.type() == cucim::io::DeviceType::kCUDA) + { + cudaError_t cuda_status; + raster = static_cast(cucim_malloc(raster_size)); + CUDA_TRY(cudaMemcpy(raster, data, raster_size, cudaMemcpyDeviceToHost)); + if (cuda_status) + { + cucim_free(raster); + throw std::runtime_error("Error during cudaMemcpy!"); + } + data = raster; + } + + for (unsigned int i = 0; (i < raster_size) && fs.good(); ++i) { fs << data[i]; } fs.flush(); if (fs.bad()) { + if (in_device.type() == cucim::io::DeviceType::kCUDA) + { + cucim_free(raster); + } CUCIM_ERROR("Writing data failed!"); } fs.close(); @@ -764,35 +873,34 @@ void CuImage::ensure_init() CUCIM_VERSION_MAJOR, CUCIM_VERSION_MINOR, CUCIM_VERSION_PATCH) : fmt::format("cucim.kit.cuslide@{}.{}.{}.so", CUCIM_VERSION_MAJOR, CUCIM_VERSION_MINOR, CUCIM_VERSION_PATCH); - struct stat st_buff; - if (stat(plugin_file_path.c_str(), &st_buff) != 0) + if (!cucim::util::file_exists(plugin_file_path.c_str())) { - plugin_file_path = fmt::format( - "cucim.kit.cuslide@{}.{}.{}.so", CUCIM_VERSION_MAJOR, CUCIM_VERSION_MINOR, CUCIM_VERSION_PATCH); + plugin_file_path = fmt::format("cucim.kit.cuslide@" XSTR(CUCIM_VERSION) ".so"); } image_formats_ = framework_->acquire_interface_from_library(plugin_file_path.c_str()); if (image_formats_ == nullptr) { - throw std::runtime_error(fmt::format("Dependent library 'cucim.kit.cuslide@{}.{}.{}.so' cannot be loaded!", - CUCIM_VERSION_MAJOR, CUCIM_VERSION_MINOR, CUCIM_VERSION_PATCH)); + throw std::runtime_error( + fmt::format("Dependent library 'cucim.kit.cuslide@" XSTR(CUCIM_VERSION) ".so' cannot be loaded!")); } } } -bool CuImage::crop_image(io::format::ImageMetadataDesc* metadata, - io::format::ImageReaderRegionRequestDesc* request, - io::format::ImageDataDesc* out_image_data) const +bool CuImage::crop_image(const io::format::ImageReaderRegionRequestDesc& request, + io::format::ImageDataDesc& out_image_data) const { // TODO: assume length of location/size to 2. constexpr int32_t ndims = 2; - if (request->level >= metadata->resolution_info.level_count) + if (request.level >= image_metadata_->resolution_info.level_count) { - throw std::invalid_argument(fmt::format("Invalid level ({}) in the request! (Should be < {})", request->level, - metadata->resolution_info.level_count)); + throw std::invalid_argument(fmt::format("Invalid level ({}) in the request! (Should be < {})", request.level, + image_metadata_->resolution_info.level_count)); } + const cucim::io::Device& in_device = device(); + auto original_img_width = image_metadata_->shape[dim_indices_.index('X')]; auto original_img_height = image_metadata_->shape[dim_indices_.index('Y')]; // TODO: consider other cases where samples_per_pixel is not same with # of channels @@ -801,40 +909,47 @@ bool CuImage::crop_image(io::format::ImageMetadataDesc* metadata, for (int32_t i = 0; i < ndims; ++i) { - if (request->location[i] < 0) + if (request.location[i] < 0) { throw std::invalid_argument( - fmt::format("Invalid location ({}) in the request! (Should be >= 0)", request->location[i])); + fmt::format("Invalid location ({}) in the request! (Should be >= 0)", request.location[i])); } - if (request->size[i] <= 0) + if (request.size[i] <= 0) { - throw std::invalid_argument( - fmt::format("Invalid size ({}) in the request! (Should be > 0)", request->size[i])); + throw std::invalid_argument(fmt::format("Invalid size ({}) in the request! (Should be > 0)", request.size[i])); } } - if (request->location[0] + request->size[0] > original_img_width) + if (request.location[0] + request.size[0] > original_img_width) { throw std::invalid_argument( fmt::format("Invalid location/size (it exceeds the image width {})", original_img_width)); } - if (request->location[1] + request->size[1] > original_img_height) + if (request.location[1] + request.size[1] > original_img_height) { throw std::invalid_argument( fmt::format("Invalid location/size (it exceeds the image height {})", original_img_height)); } - int64_t sx = request->location[0]; - int64_t sy = request->location[1]; - int64_t w = request->size[0]; - int64_t h = request->size[1]; + std::string device_name(request.device); + + if (request.shm_name) + { + device_name = device_name + fmt::format("[{}]", request.shm_name); // TODO: check performance + } + cucim::io::Device out_device(device_name); + + int64_t sx = request.location[0]; + int64_t sy = request.location[1]; + int64_t w = request.size[0]; + int64_t h = request.size[1]; uint64_t ex = sx + w - 1; uint64_t ey = sy + h - 1; uint8_t* src_ptr = static_cast(image_data_->container.data); + size_t raster_size = w * h * samples_per_pixel; - void* raster = cucim_malloc(w * h * samples_per_pixel); // RGB image - auto dest_ptr = static_cast(raster); + void* raster = nullptr; int64_t dest_stride_x_bytes = w * samples_per_pixel; int64_t src_stride_x = original_img_width; @@ -843,23 +958,97 @@ bool CuImage::crop_image(io::format::ImageMetadataDesc* metadata, int64_t start_offset = (sx + (sy * src_stride_x)) * samples_per_pixel; int64_t end_offset = (ex + (ey * src_stride_x)) * samples_per_pixel; - for (int64_t src_offset = start_offset; src_offset <= end_offset; src_offset += src_stride_x_bytes) + switch (in_device.type()) { - memcpy(dest_ptr, src_ptr + src_offset, dest_stride_x_bytes); - dest_ptr += dest_stride_x_bytes; + case cucim::io::DeviceType::kCPU: { + raster = cucim_malloc(raster_size); + auto dest_ptr = static_cast(raster); + for (int64_t src_offset = start_offset; src_offset <= end_offset; src_offset += src_stride_x_bytes) + { + memcpy(dest_ptr, src_ptr + src_offset, dest_stride_x_bytes); + dest_ptr += dest_stride_x_bytes; + } + // Copy the raster memory and free it if needed. + cucim::memory::move_raster_from_host((void**)&raster, raster_size, out_device); + break; } + case cucim::io::DeviceType::kCUDA: { + cudaError_t cuda_status; - out_image_data->container.data = raster; - out_image_data->container.ctx = DLContext{ static_cast(cucim::io::DeviceType::kCPU), 0 }; - out_image_data->container.ndim = metadata->ndim; - out_image_data->container.dtype = metadata->dtype; - out_image_data->container.strides = nullptr; // Tensor is compact and row-majored - out_image_data->container.byte_offset = 0; + if (out_device.type() == cucim::io::DeviceType::kCPU) + { + // cuda -> host at bulk then host -> host per row is faster than cuda-> cuda per row, then cuda->host at + // bulk. + uint8_t* copied_src_ptr = static_cast(cucim_malloc(src_stride_x_bytes * h)); + CUDA_TRY(cudaMemcpy(copied_src_ptr, src_ptr + start_offset, src_stride_x_bytes * h, cudaMemcpyDeviceToHost)); + if (cuda_status) + { + cucim_free(copied_src_ptr); + throw std::runtime_error("Error during cudaMemcpy!"); + } + + end_offset -= start_offset; + start_offset = 0; + + raster = cucim_malloc(raster_size); + auto dest_ptr = static_cast(raster); + for (int64_t src_offset = start_offset; src_offset <= end_offset; src_offset += src_stride_x_bytes) + { + memcpy(dest_ptr, copied_src_ptr + src_offset, dest_stride_x_bytes); + dest_ptr += dest_stride_x_bytes; + } + cucim_free(copied_src_ptr); + } + else + { + CUDA_TRY(cudaMalloc(&raster, raster_size)); + if (cuda_status) + { + throw std::bad_alloc(); + } + auto dest_ptr = static_cast(raster); + CUDA_TRY(cudaMemcpy2D(dest_ptr, dest_stride_x_bytes, src_ptr + start_offset, src_stride_x_bytes, + dest_stride_x_bytes, h, cudaMemcpyDeviceToDevice)); + if (cuda_status) + { + throw std::runtime_error("Error during cudaMemcpy2D!"); + } + // Copy the raster memory and free it if needed. + cucim::memory::move_raster_from_device((void**)&raster, raster_size, out_device); + } + break; + } + case cucim::io::DeviceType::kPinned: + case cucim::io::DeviceType::kCPUShared: + case cucim::io::DeviceType::kCUDAShared: + throw std::runtime_error(fmt::format("Device type {} not supported!", in_device.type())); + break; + } + + auto& out_image_container = out_image_data.container; + out_image_container.data = raster; + out_image_container.ctx = DLContext{ static_cast(out_device.type()), out_device.index() }; + out_image_container.ndim = image_metadata_->ndim; + out_image_container.dtype = image_metadata_->dtype; + out_image_container.strides = nullptr; // Tensor is compact and row-majored + out_image_container.byte_offset = 0; // Set correct shape - out_image_data->container.shape = static_cast(cucim_malloc(sizeof(int64_t) * metadata->ndim)); - memcpy(out_image_data->container.shape, metadata->shape, sizeof(int64_t) * metadata->ndim); - out_image_data->container.shape[0] = h; - out_image_data->container.shape[1] = w; + out_image_container.shape = static_cast(cucim_malloc(sizeof(int64_t) * image_metadata_->ndim)); + memcpy(out_image_container.shape, image_metadata_->shape, sizeof(int64_t) * image_metadata_->ndim); + out_image_container.shape[0] = h; + out_image_container.shape[1] = w; + + auto& shm_name = out_device.shm_name(); + size_t shm_name_len = shm_name.size(); + if (shm_name_len != 0) + { + out_image_data.shm_name = static_cast(cucim_malloc(shm_name_len + 1)); + memcpy(out_image_data.shm_name, shm_name.c_str(), shm_name_len + 1); + } + else + { + out_image_data.shm_name = nullptr; + } return true; } diff --git a/cpp/src/filesystem/cufile_driver.cpp b/cpp/src/filesystem/cufile_driver.cpp index dfea2ea00..23555f2ce 100644 --- a/cpp/src/filesystem/cufile_driver.cpp +++ b/cpp/src/filesystem/cufile_driver.cpp @@ -16,32 +16,25 @@ #include "cucim/filesystem/cufile_driver.h" -#include "fmt/format.h" -#include "cufile_stub.h" - #include -#include -#include #include #include #include -#include #include +#include +#include + #include +#include +#include + +#include "cucim/util/cuda.h" +#include "cufile_stub.h" #define ALIGN_UP(x, align_to) (((uint64_t)(x) + ((uint64_t)(align_to)-1)) & ~((uint64_t)(align_to)-1)) #define ALIGN_DOWN(x, align_to) ((uint64_t)(x) & ~((uint64_t)(align_to)-1)) -#define CUDA_TRY(stmt) \ - { \ - cuda_status = stmt; \ - if (cudaSuccess != cuda_status) \ - { \ - fmt::print(stderr, "[Error] CUDA Runtime call {} in line {} of file {} failed with '{}' ({}).\n", #stmt, \ - __LINE__, __FILE__, cudaGetErrorString(cuda_status), cuda_status); \ - } \ - } namespace cucim::filesystem { @@ -200,7 +193,14 @@ CuFileDriver::CuFileDriver(int fd, bool no_gds, bool use_mmap, const char* file_ file_flags_ = flags; FileHandleType file_type = (flags & O_DIRECT) ? FileHandleType::kPosixODirect : FileHandleType::kPosix; - handle_ = CuCIMFileHandle{ fd, nullptr, file_type, const_cast(file_path_.c_str()), this }; + handle_ = CuCIMFileHandle{ fd, + nullptr, + file_type, + const_cast(file_path_.c_str()), + this, + static_cast(st.st_dev), + static_cast(st.st_ino), + static_cast(st.st_mtim.tv_nsec) }; CUfileError_t status; CUfileDescr_t cf_descr{}; // It is important to set zero! @@ -326,7 +326,7 @@ CuFileDriverInitializer::CuFileDriverInitializer() max_device_cache_size_ = DEFAULT_MAX_CACHE_SIZE; max_host_cache_size_ = DEFAULT_MAX_CACHE_SIZE; - // fmt::print(stderr, "[warning] CuFileDriver cannot be open. Falling back to use POSIX file IO APIs.\n"); + // fmt::print(stderr, "[Warning] CuFileDriver cannot be open. Falling back to use POSIX file IO APIs.\n"); } } CuFileDriverInitializer::~CuFileDriverInitializer() diff --git a/cpp/src/filesystem/file_handle.cpp b/cpp/src/filesystem/file_handle.cpp new file mode 100644 index 000000000..1b3036d94 --- /dev/null +++ b/cpp/src/filesystem/file_handle.cpp @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cucim/filesystem/file_handle.h" + +#include + +#include "cucim/codec/hash_function.h" + +CuCIMFileHandle::CuCIMFileHandle() + : fd(0), + cufile(nullptr), + type(FileHandleType::kUnknown), + path(nullptr), + client_data(nullptr), + hash_value(0), + dev(0), + ino(0), + mtime(0) +{ +} + +CuCIMFileHandle::CuCIMFileHandle(int fd, CUfileHandle_t cufile, FileHandleType type, char* path, void* client_data) + : fd(fd), cufile(cufile), type(type), path(path), client_data(client_data) + +{ + struct stat st; + fstat(fd, &st); + + dev = static_cast(st.st_dev); + ino = static_cast(st.st_ino); + mtime = static_cast(st.st_mtim.tv_nsec); + hash_value = cucim::codec::splitmix64_3(dev, ino, mtime); +} + +CuCIMFileHandle::CuCIMFileHandle(int fd, + CUfileHandle_t cufile, + FileHandleType type, + char* path, + void* client_data, + uint64_t dev, + uint64_t ino, + int64_t mtime) + : fd(fd), cufile(cufile), type(type), path(path), client_data(client_data), dev(dev), ino(ino), mtime(mtime) +{ + hash_value = cucim::codec::splitmix64_3(dev, ino, mtime); +} diff --git a/cpp/src/io/device.cpp b/cpp/src/io/device.cpp index fe40c3dff..d7fbee5fe 100644 --- a/cpp/src/io/device.cpp +++ b/cpp/src/io/device.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,18 +14,20 @@ * limitations under the License. */ -#include "cucim/macros/defines.h" #include "cucim/io/device.h" + #include #include #include + #include +#include "cucim/macros/defines.h" + namespace cucim::io { - Device::Device() { // TODO: consider default case (how to handle -1 index?) @@ -81,28 +83,23 @@ Device::Device(DeviceType type, DeviceIndex index, const std::string& param) DeviceType Device::parse_type(const std::string& device_name) { - (void)device_name; - - // TODO: implement this - return DeviceType::kCPU; + return lookup_device_type(device_name); } Device::operator std::string() const { - static const std::unordered_map device_type_map{ - { DeviceType::kCPU, "cpu" }, { DeviceType::kPinned, "pinned" }, { DeviceType::kCPUShared, "cpu" }, - { DeviceType::kCUDA, "cuda" }, { DeviceType::kCUDAShared, "cuda" }, - }; + std::string_view device_type_str = lookup_device_type_str(type_); + if (index_ == -1 && shm_name_.empty()) { - return fmt::format("{}", device_type_map.at(static_cast(type_))); + return fmt::format("{}", device_type_str); } else if (index_ != -1 && shm_name_.empty()) { - return fmt::format("{}:{}", device_type_map.at(static_cast(type_)), index_); + return fmt::format("{}:{}", device_type_str, index_); } else { - return fmt::format("{}:{}[{}]", device_type_map.at(static_cast(type_)), index_, shm_name_); + return fmt::format("{}:{}[{}]", device_type_str, index_, shm_name_); } } diff --git a/cpp/src/io/device_type.cpp b/cpp/src/io/device_type.cpp new file mode 100644 index 000000000..97331b559 --- /dev/null +++ b/cpp/src/io/device_type.cpp @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cucim/io/device_type.h" +#include "cucim/cpp20/find_if.h" + + +namespace cucim::io +{ + +using namespace std::literals::string_view_literals; + +constexpr DeviceType DeviceTypeMap::at(const std::string_view& key) const +{ + const auto itr = cucim::cpp20::find_if(begin(data), end(data), [&key](const auto& v) { return v.first == key; }); + + if (itr != end(data)) + { + return itr->second; + } + else + { + return DeviceType::kCPU; + } +} + +constexpr std::string_view DeviceTypeStrMap::at(const DeviceType& key) const +{ + const auto itr = cucim::cpp20::find_if(begin(data), end(data), [&key](const auto& v) { return v.first == key; }); + + if (itr != end(data)) + { + return itr->second; + } + else + { + return "cpu"sv; + } +} + +static constexpr std::array, kDeviceTypeCount> device_type_values{ + { { "cpu"sv, DeviceType::kCPU }, + { "cuda"sv, DeviceType::kCUDA }, + { "pinned"sv, DeviceType::kPinned }, + { "cpu_shared"sv, DeviceType::kCPUShared }, + { "cuda_shared"sv, DeviceType::kCUDAShared } } +}; + + +DeviceType lookup_device_type(const std::string_view sv) +{ + static constexpr auto map = DeviceTypeMap{ { device_type_values } }; + return map.at(sv); +} + +static constexpr std::array, kDeviceTypeCount> device_type_str_values{ + { { DeviceType::kCPU, "cpu"sv }, + { DeviceType::kCUDA, "cuda"sv }, + { DeviceType::kPinned, "pinned"sv }, + { DeviceType::kCPUShared, "cpu_shared"sv }, + { DeviceType::kCUDAShared, "cuda_shared"sv } } +}; + +std::string_view lookup_device_type_str(const DeviceType key) +{ + static constexpr auto map = DeviceTypeStrMap{ { device_type_str_values } }; + return map.at(key); +} + +} // namespace cucim::io \ No newline at end of file diff --git a/cpp/src/io/format/image_format.cpp b/cpp/src/io/format/image_format.cpp index 01c4382fc..38009465d 100644 --- a/cpp/src/io/format/image_format.cpp +++ b/cpp/src/io/format/image_format.cpp @@ -50,16 +50,16 @@ ImageMetadata& ImageMetadata::ndim(uint16_t ndim) return *this; } -ImageMetadata& ImageMetadata::dims(const std::string_view& dims) +ImageMetadata& ImageMetadata::dims(std::string_view&& dims) { - dims_ = std::move(dims); + dims_ = dims; desc_.dims = dims_.data(); return *this; } -ImageMetadata& ImageMetadata::shape(const std::pmr::vector& shape) +ImageMetadata& ImageMetadata::shape(std::pmr::vector&& shape) { - shape_ = std::move(shape); + shape_ = shape; desc_.shape = const_cast(shape_.data()); return *this; } @@ -70,16 +70,10 @@ ImageMetadata& ImageMetadata::dtype(const DLDataType& dtype) return *this; } -ImageMetadata& ImageMetadata::channel_names(const std::pmr::vector& channel_names) +ImageMetadata& ImageMetadata::channel_names(std::pmr::vector&& channel_names) { const int channel_len = channel_names.size(); - channel_names_.clear(); - channel_names_.reserve(channel_len); - - for (int i = 0; i < channel_len; ++i) - { - channel_names_.emplace_back(channel_names[i]); - } + channel_names_ = channel_names; desc_.channel_names = static_cast(allocate(channel_len * sizeof(char*))); for (int i = 0; i < channel_len; ++i) @@ -89,23 +83,17 @@ ImageMetadata& ImageMetadata::channel_names(const std::pmr::vector& spacing) +ImageMetadata& ImageMetadata::spacing(std::pmr::vector&& spacing) { - spacing_ = std::move(spacing); + spacing_ = spacing; desc_.spacing = const_cast(spacing_.data()); return *this; } -ImageMetadata& ImageMetadata::spacing_units(const std::pmr::vector& spacing_units) +ImageMetadata& ImageMetadata::spacing_units(std::pmr::vector&& spacing_units) { const int ndim = spacing_units.size(); - spacing_units_.clear(); - spacing_units_.reserve(ndim); - - for (int i = 0; i < ndim; ++i) - { - spacing_units_.emplace_back(spacing_units[i]); - } + spacing_units_ = spacing_units; desc_.spacing_units = static_cast(allocate(ndim * sizeof(char*))); for (int i = 0; i < ndim; ++i) @@ -115,23 +103,23 @@ ImageMetadata& ImageMetadata::spacing_units(const std::pmr::vector& origin) +ImageMetadata& ImageMetadata::origin(std::pmr::vector&& origin) { - origin_ = std::move(origin); + origin_ = origin; desc_.origin = const_cast(origin_.data()); return *this; } -ImageMetadata& ImageMetadata::direction(const std::pmr::vector& direction) +ImageMetadata& ImageMetadata::direction(std::pmr::vector&& direction) { - direction_ = std::move(direction); + direction_ = direction; desc_.direction = const_cast(direction_.data()); return *this; } -ImageMetadata& ImageMetadata::coord_sys(const std::string_view& coord_sys) +ImageMetadata& ImageMetadata::coord_sys(std::string_view&& coord_sys) { - coord_sys_ = std::move(coord_sys); + coord_sys_ = coord_sys; desc_.coord_sys = coord_sys_.data(); return *this; } @@ -148,36 +136,37 @@ ImageMetadata& ImageMetadata::level_ndim(uint16_t level_ndim) return *this; } -ImageMetadata& ImageMetadata::level_dimensions(const std::pmr::vector& level_dimensions) +ImageMetadata& ImageMetadata::level_dimensions(std::pmr::vector&& level_dimensions) { - level_dimensions_ = std::move(level_dimensions); + level_dimensions_ = level_dimensions; desc_.resolution_info.level_dimensions = const_cast(level_dimensions_.data()); return *this; } -ImageMetadata& ImageMetadata::level_downsamples(const std::pmr::vector& level_downsamples) +ImageMetadata& ImageMetadata::level_downsamples(std::pmr::vector&& level_downsamples) { - level_downsamples_ = std::move(level_downsamples); + level_downsamples_ = level_downsamples; desc_.resolution_info.level_downsamples = const_cast(level_downsamples_.data()); return *this; } +ImageMetadata& ImageMetadata::level_tile_sizes(std::pmr::vector&& level_tile_sizes) +{ + level_tile_sizes_ = level_tile_sizes; + desc_.resolution_info.level_tile_sizes = const_cast(level_tile_sizes_.data()); + return *this; +} + ImageMetadata& ImageMetadata::image_count(uint16_t image_count) { desc_.associated_image_info.image_count = image_count; return *this; } -ImageMetadata& ImageMetadata::image_names(const std::pmr::vector& image_names) +ImageMetadata& ImageMetadata::image_names(std::pmr::vector&& image_names) { const int image_size = image_names.size(); - image_names_.clear(); - image_names_.reserve(image_size); - - for (int i = 0; i < image_size; ++i) - { - image_names_.emplace_back(image_names[i]); - } + image_names_ = image_names; desc_.associated_image_info.image_names = static_cast(allocate(image_size * sizeof(char*))); for (int i = 0; i < image_size; ++i) diff --git a/cpp/src/logger/timer.cpp b/cpp/src/logger/timer.cpp index c230f0903..a02738ff4 100644 --- a/cpp/src/logger/timer.cpp +++ b/cpp/src/logger/timer.cpp @@ -54,11 +54,11 @@ void Timer::print(const char* message) { if (message) { - fmt::print(message, elapsed_seconds_); + fmt::print(stderr, message, elapsed_seconds_); } else { - fmt::print(message_, elapsed_seconds_); + fmt::print(stderr, message_, elapsed_seconds_); } } diff --git a/cpp/src/memory/memory_manager.cu b/cpp/src/memory/memory_manager.cu index 7b418ef61..88d17dbd3 100644 --- a/cpp/src/memory/memory_manager.cu +++ b/cpp/src/memory/memory_manager.cu @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,20 +16,14 @@ #include "cucim/memory/memory_manager.h" -#include +#include + #include +#include -#include +#include "cucim/io/device_type.h" +#include "cucim/util/cuda.h" -#define CUDA_TRY(stmt) \ - { \ - cuda_status = stmt; \ - if (cudaSuccess != cuda_status) \ - { \ - fmt::print(stderr, "[Error] CUDA Runtime call {} in line {} of file {} failed with '{}' ({}).\n", #stmt, \ - __LINE__, __FILE__, cudaGetErrorString(cuda_status), cuda_status); \ - } \ - } CUCIM_API void* cucim_malloc(size_t size) { @@ -74,4 +68,53 @@ void get_pointer_attributes(PointerAttributes& attr, const void* ptr) } } +bool move_raster_from_host(void** target, size_t size, const cucim::io::Device& dst_device) +{ + switch (dst_device.type()) + { + case cucim::io::DeviceType::kCPU: + break; + case cucim::io::DeviceType::kCUDA: + cudaError_t cuda_status; + void* host_mem = *target; + void* cuda_mem; + CUDA_TRY(cudaMalloc(&cuda_mem, size)); + if (cuda_status) + { + throw std::bad_alloc(); + } + CUDA_TRY(cudaMemcpy(cuda_mem, host_mem, size, cudaMemcpyHostToDevice)); + if (cuda_status) + { + throw std::bad_alloc(); + } + cucim_free(host_mem); + *target = cuda_mem; + } + return true; +} + +bool move_raster_from_device(void** target, size_t size, const cucim::io::Device& dst_device) +{ + switch (dst_device.type()) + { + case cucim::io::DeviceType::kCPU: { + cudaError_t cuda_status; + void* cuda_mem = *target; + void* host_mem = cucim_malloc(size); + CUDA_TRY(cudaMemcpy(host_mem, cuda_mem, size, cudaMemcpyDeviceToHost)); + if (cuda_status) + { + throw std::bad_alloc(); + } + cudaFree(cuda_mem); + *target = host_mem; + break; + } + case cucim::io::DeviceType::kCUDA: + break; + } + return true; +} + } // namespace cucim::memory \ No newline at end of file diff --git a/cpp/src/util/file.cpp b/cpp/src/util/file.cpp new file mode 100644 index 000000000..7009ae792 --- /dev/null +++ b/cpp/src/util/file.cpp @@ -0,0 +1,14 @@ +#include "cucim/util/file.h" + +#include + +namespace cucim::util +{ + +bool file_exists(const char* path) +{ + struct stat st_buff; + return stat(path, &st_buff) == 0; +} + +} // namespace cucim::util \ No newline at end of file diff --git a/cpp/tests/test_read_region.cpp b/cpp/tests/test_read_region.cpp index 5e9117ac5..691933fe1 100644 --- a/cpp/tests/test_read_region.cpp +++ b/cpp/tests/test_read_region.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,21 +14,19 @@ * limitations under the License. */ -#include +#include #include +#include +#include +#include + #include "config.h" -#include "cucim/io/format/image_format.h" #include "cucim/core/framework.h" -//#include "rmm/mr/host/new_delete_resource.hpp" -//#include -#include "cucim/memory/memory_manager.h" - -#include #include "cucim/io/device.h" +#include "cucim/io/format/image_format.h" +#include "cucim/memory/memory_manager.h" -#include -#include SCENARIO("Verify read_region()", "[test_read_region.cpp]") { @@ -43,7 +41,7 @@ SCENARIO("Verify read_region()", "[test_read_region.cpp]") openslide_t* slide = openslide_open(g_config.get_input_path().c_str()); REQUIRE(slide != nullptr); - auto buf = (uint32_t*)cucim_malloc(test_width * test_height * 4); + auto buf = static_cast(cucim_malloc(test_width * test_height * 4)); int64_t w, h; openslide_get_level0_dimensions(slide, &w, &h); printf("w = %ld h=%ld\n", w, h); diff --git a/cucim.code-workspace b/cucim.code-workspace index fa4cdf08a..849de7318 100644 --- a/cucim.code-workspace +++ b/cucim.code-workspace @@ -31,7 +31,7 @@ "CUCIM_TESTDATA_FOLDER": "${workspaceDirectory}/test_data", // Add cuslide plugin's library path to LD_LIBRARY_PATH "LD_LIBRARY_PATH": "${workspaceDirectory}/build-debug/lib:${workspaceDirectory}/cpp/plugins/cucim.kit.cuslide/build-debug/lib:${workspaceDirectory}/temp/cuda/lib64:${os_env:LD_LIBRARY_PATH}", - "CUCIM_TEST_PLUGIN_PATH": "cucim.kit.cuslide@0.19.0.so" + "CUCIM_TEST_PLUGIN_PATH": "cucim.kit.cuslide@21.06.00.so" }, "cwd": "${workspaceDirectory}", "catch2": { @@ -125,11 +125,30 @@ "__split_buffer": "cpp", "__tree": "cpp", "queue": "cpp", - "stack": "cpp" + "stack": "cpp", + "*.ipp": "cpp", + "hash_map": "cpp", + "hash_set": "cpp", + "filesystem": "cpp", + "__locale": "cpp", + "rope": "cpp", + "__bit_reference": "cpp", + "csetjmp": "cpp", + "strstream": "cpp", + "source_location": "cpp", + "slist": "cpp", + "__functional_base": "cpp", + "__node_handle": "cpp", + "__memory": "cpp", + "*.def": "cpp", + "__mutex_base": "cpp" }, // https://vector-of-bool.github.io/docs/vscode-cmake-tools/settings.html "cmake.buildTask": true, - "cmake.buildDirectory": "${workspaceFolder}/build-debug" + "cmake.buildDirectory": "${workspaceFolder}/build-debug", + "cmake.preferredGenerators": [ + "Unix Makefiles" + ] }, "tasks": { "version": "2.0.0", @@ -139,7 +158,11 @@ "type": "shell", "command": "./run build_local all debug", "options": { - "cwd": "${workspaceFolder}" + "cwd": "${workspaceFolder}", + "env": { + // Workaround the environment variable issue: https://github.com/microsoft/vscode/issues/121470 + "PATH": "${env:PATH}" + } }, "presentation": { "reveal": "always", @@ -191,7 +214,7 @@ }, { "name": "CUCIM_TEST_PLUGIN_PATH", - "value": "cucim.kit.cuslide@0.19.0.so" + "value": "cucim.kit.cuslide@21.06.00.so" } ], "console": "externalTerminal", @@ -219,7 +242,7 @@ }, { "name": "CUCIM_TEST_PLUGIN_PATH", - "value": "cucim.kit.cuslide@0.19.0.so" + "value": "cucim.kit.cuslide@21.06.00.so" } ], "console": "externalTerminal", @@ -250,7 +273,7 @@ }, { "name": "CUCIM_TEST_PLUGIN_PATH", - "value": "cucim.kit.cuslide@0.19.0.so" + "value": "cucim.kit.cuslide@21.06.00.so" } ], "console": "externalTerminal", diff --git a/docs/source/conf.py b/docs/source/conf.py index f5093a9e2..3e02786a9 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -71,9 +71,9 @@ # built documents. # # The short X.Y version. -version = '0.19' +version = '21.06' # The full version, including alpha/beta/rc tags. -release = '0.19.0' +release = '21.06.00' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. diff --git a/examples/cpp/tiff_image/main.cpp b/examples/cpp/tiff_image/main.cpp index bd9586da5..051652285 100644 --- a/examples/cpp/tiff_image/main.cpp +++ b/examples/cpp/tiff_image/main.cpp @@ -43,6 +43,7 @@ int main(int argc, char* argv[]) fmt::print("level_dimensions: ({})\n", fmt::join(resolutions.level_dimensions(), ", ")); fmt::print("level_dimension (level 0): ({})\n", fmt::join(resolutions.level_dimension(0), ", ")); fmt::print("level_downsamples: ({})\n", fmt::join(resolutions.level_downsamples(), ", ")); + fmt::print("level_tile_sizes: ({})\n", fmt::join(resolutions.level_tile_sizes(), ", ")); auto associated_images = image.associated_images(); fmt::print("associated_images: ({})\n", fmt::join(associated_images, ", ")); @@ -74,6 +75,7 @@ int main(int argc, char* argv[]) fmt::print("level_dimensions: ({})\n", fmt::join(resolutions.level_dimensions(), ", ")); fmt::print("level_dimension (level 0): ({})\n", fmt::join(resolutions.level_dimension(0), ", ")); fmt::print("level_downsamples: ({})\n", fmt::join(resolutions.level_downsamples(), ", ")); + fmt::print("level_tile_sizes: ({})\n", fmt::join(resolutions.level_tile_sizes(), ", ")); associated_images = region.associated_images(); fmt::print("associated_images: ({})\n", fmt::join(associated_images, ", ")); diff --git a/notebooks/Basic_Usage.ipynb b/notebooks/Basic_Usage.ipynb index 0220c6267..40ef59ebe 100644 --- a/notebooks/Basic_Usage.ipynb +++ b/notebooks/Basic_Usage.ipynb @@ -22,13 +22,13 @@ "or\n", "```\n", "!pip install pillow\n", - "!pip install numpy scipy scikit-image cupy-cuda110==9.0.0b3 # for cucim dependency\n", + "!pip install numpy scipy scikit-image cupy-cuda110 # for cucim dependency (assuming that CUDA 11.0 is used for CuPy)\n", "```" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -36,8 +36,8 @@ "\n", "# or\n", "\n", - "#!pip install pillow\n", - "#!pip install numpy scipy scikit-image cupy-cuda110==9.0.0b3 # for cucim dependency" + "# !pip install pillow\n", + "# !pip install numpy scipy scikit-image cupy-cuda110 # for cucim dependency (assuming that CUDA 11.0 is used for CuPy)" ] }, { @@ -49,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -67,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -128,6 +128,36 @@ " 16.001211166381836,\n", " 32.00559616088867,\n", " 64.01119232177734\n", + " ],\n", + " \"level_tile_sizes\": [\n", + " [\n", + " 256,\n", + " 256\n", + " ],\n", + " [\n", + " 256,\n", + " 256\n", + " ],\n", + " [\n", + " 256,\n", + " 256\n", + " ],\n", + " [\n", + " 256,\n", + " 256\n", + " ],\n", + " [\n", + " 256,\n", + " 256\n", + " ],\n", + " [\n", + " 256,\n", + " 256\n", + " ],\n", + " [\n", + " 256,\n", + " 256\n", + " ]\n", " ]\n", "}\n", "{\n", @@ -209,6 +239,36 @@ " 16.001211166381836,\n", " 32.00559616088867,\n", " 64.01119232177734\n", + " ],\n", + " \"level_tile_sizes\": [\n", + " [\n", + " 256,\n", + " 256\n", + " ],\n", + " [\n", + " 256,\n", + " 256\n", + " ],\n", + " [\n", + " 256,\n", + " 256\n", + " ],\n", + " [\n", + " 256,\n", + " 256\n", + " ],\n", + " [\n", + " 256,\n", + " 256\n", + " ],\n", + " [\n", + " 256,\n", + " 256\n", + " ],\n", + " [\n", + " 256,\n", + " 256\n", + " ]\n", " ]\n", " },\n", " \"shape\": [\n", @@ -269,31 +329,32 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Read whole slide at the lowest resolution\n", "resolutions = img.resolutions\n", + "level_dimensions = resolutions[\"level_dimensions\"]\n", "level_count = resolutions[\"level_count\"]\n", - "region = img.read_region(location=[0,0], size=resolutions[\"level_dimensions\"][level_count - 1], level=level_count - 1)\n", + "region = img.read_region(location=[0,0], size=level_dimensions[level_count - 1], level=level_count - 1)\n", "\n", "region.save(\"thumbnail.ppm\") # currently, cuCIM can save image with .ppm format." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAATcAAAGdCAIAAAD4x6PtAAEAAElEQVR4nNT9V4xkWZYYCJ5zxZP2zMzNXISHjsjQKUtkVVZ1VVd1d7WoZndvN9lLcprkkrPAYMFZ7ACzC2Kw4mt/Fov92L/BYohZLLHEsNlskk3RqqpYKqsqsyorVWREZESG9gjXwvRTV5z9eObmz83MPTwzu4fYA4fD7NnV7+h77rnYj3sAQESwC4g4ekJExhgiZIwh4ujh8L8lAGCMMca01qPPhMAYQxwWGzWOiEXjYz3uAgOAotYkTJYfNXUUKI/h4AFMabmYdVG4GH95EQ6vXi4zucKHw6gjACgvCU1UHY3tgJbYAU/xkCmUe5nafmk9i8VhAED7J46IbHf8RARgAYCQ7a2PxRGyDR+iBQA7ah8tBywq7oHF0mDGZzca+djsDsGrArettUUVxthkddhPF1OhvERji3YI+h20sFBaFjHZ6wgLcRcAhuMrkxzRPoRBRGPMsC4CADA2fP6xyOnosPdqjwBlpP+4vRzy9RPAEcd8xI6eRaKftv2DoOgREYkMIhJB8Zrt/gLTwAIgACMiQKIhhgDAaDyWAbOM0CJQgXoAwADsLk3uYiACElggJACGSFNYWHm+U4fEOS/oc4SoBZKPFT7KCh+CkJMEfFCzU5+IQ3otMHtEpQUwFEREYBCxmJC1FgAYYwWVWmuBobUWoOCa09FomsApXvGB8yxjZJlZHDLDqT2Wv05F1rHl3seYdp9/XLL/62BVn55lTDYyJD8CACAcX+dJxl/IZAQCIgDGcMi+i3JIdrdZKPVTPKSiFxx742iBgIFFYLvCme3SJxtWQwSwBoiBsbhHwQg4LDMxKaLpVFR+OJoj59wYM7YmnwCOSLdTq5SncCCVjphlMcOJ1vfhKBFxzhlj1lpEJICCXEfsddTaqM1yg38l2PbJ4Jm9T8rST0yonxJ2lcCREPvrFbZHbJlgPz0QIKDdpcB9Pw3HXMhSiwgEhIhASETIykhmsfhPjHCk0+5Tbg0QAFiE/f+JT4xzjOGOLYW1tmzNFU+MMYXeCx9n6cawGkrm3uRPh8CkkBBTq40RdFmO7fIYLOohAiKNyK+YMOC4ejziVoyxQwb5cZHpEF71sfThqdWnjuevSXt/JnxKxfuTMXUgwF375cClGGqZFgBwV+FlAFiiXipVIWB2yPqpKMTAUkm13d9HYdOOWLwlImQIALxU3g4/WgAGhy7M1MmOFpNzDgBZliVJEkXRYQ0dreVJKX30dspEN921MFmzZKOOQyE2C3V3UiMaYyoHmcEfdw5Hr1LuaIx3HKXKxxrPXx8chASH6O2fGKYu0UFLN7Xr8lipVNKOTEpbpjFmEco67f7/ewWHjRdtWBp9ZjT8Qzvdfpl8uG+0iAUOF7Yb59xxnMOrHB3KWuRRcG/qCh9ml5YYAO7/OiS/Ya801PsReeFKs1bvqsr7RPFudQa7jrv9Yypew5EYxzPhr4p+Jgb/nxn2ln2fC+djU+nRdQ0kQERDtvzq99rBocSDCQyBMonuOTcYIwRiE6tasjwJyyKkMG53zVeLu3KaCkLdQ85iOYZtjllkB86uNBdjjLWWcx4EQdkuLbfzcVd7EnnK1Y/4CqaY2pOWd7G/MtlNQYrFTyMoM90xTn+QNP4E8AnaGdP1P1bdQ5boP7s4/cQNTl2Eg1am/JZHJaeS+qTEKLleGQNEYkAEFsESUkHhYyQKQydwIRvRDv/jrjgt/Qca6sS7/pKjTnk0/sLHyxgrNF6t9UEkeljT0+Y+VQEZW8OxFsqyd7TgbIxyRtXKH0ZbSYjIOBCYYslo//4S7fp7ETgQI4sInOyQcY40ijHpVCLv4m+6VlDU/ZTkMaa6H10DGStf/npQC0dp+RNUHw2gzAEPYfCTMx1rYWw8YxXHhjpZwBbbm8gIWaFJ0a5bn/a8j2SMAWAcGQMErZCs5AwJGCBYKmoyQKsNRyaYJDM0N41RTKAFQwDImDaGAIy1lkgbAwBCiKJ9zvlB4y8jffkh7u5ijKQLInLOy+XLL/2ZgnQSMcYagRJ3OOgVjChuBGzsBeAETJ3qJE9lu1BGoBFZjh6O9qYO4iKjNseQY9Qy7YfJlToE9eEIxPM/GxzOZcaWl0rc4SA4ZGrl93UU7oYljv7JABGttUopAOCcS+mOkE9KjohZnnDOLWnhSK3zolZBaVrrQqwxxrgUetfjWpBiUYxz7nmesTZOEmRMSKm0RsSpW6YjdDrKyCcR7GOtxkHFnrn+h7ziw+zSUaNjOzGMDWm7UC8sgAVbuAYQxj3hyAiAEMZJGoYl7UH8b7frA62LT4BDo7f1afDvKL1Mtj/14TOHMTb9Q8p/sp+OvqSjHdSx8vscRSXHbq6V4zhWkzHWKiOly4Ajkjaq8BVxyTRo5JBksRDMkrHGFkQIDJGDUQqAW2td1zGGrLXIOWMsz3MhhNaaWWJCMiEByVhrgQTnh1NimRLGqKL88PCl+AQwidiHFx57L/tMSjhUDRub4ZgEt7tAu2rwWJsjWToqMxpTWW5MjnhUYFKwHzTJqUQy1vhfiVB9ZiOHcJmjwKRG9LGqT5Y/hGGP6TKHqyTPHE8RGEBEnHPP8ZGAGUJinHPGuSHNOE9VahGEKwwQMSy23I2yZACJudJDYr7wbEbMoCNc0KBz4wjXanKlMzSCEDVZYoiCG9iHlocPfqq2OVagTLpHWZByxcMRewwOx5NxWXp0dYhKuywjAQtAiIWvjRDY1CWjvYAH2PPj4fAnIjvZFxwgV3fF8jPgIGT9/wsYvepPT+RQaueg13x4L8OAlXLl3c0PRLTlPdJikxOYURbREhFHDoQaMMkyKWVurO+HRKQzVdhKRmlk3GUO5zKLU1c4aCiPVRzH/X7/6cryiy8+7wY+Q+SW6dwIFGDJkiFW2FAGkT9zCs9cn08Jk3zwKBrcCL2nC6reoPvMERcrPuq+sBwKCimT3L52EckioMWSXV7uCPdDaXx7sUplKEvgMpd6pqIy9Z1NKhVHhzKDfKbyPMbLPmF3tsTs2MdthJW7Hn0u753sdXRET2ZpCPtPApQ5bOEc4hyQDHBAIsiNzmzm+B4yYoxlSSqEEExaa8FYyR20kAziQS9eX13dWNt8cP8RB1atVo0xd+591Jxr/OZv/9bxk4vSFYyhBm1Ig+AWjDFq13vEDtjMG8UqfmyzEPa/9EMKTMXDyYeHIMMzqPSQOYwxTwAo7ISCSo0xiEXg7m6jJR2ViAAsIh9TmMu0WipZuOqnqHlKqVELhdP8IKw6CrYdHSMPqgtHplI4FDOOpLzso4Sjj7QANnUMk1T6caEIdh+NjXD/SRpjHcdRmUaLgpgj5Lvvvv/973+3eWz+7/7B3x0MBp7nOUKaXDnCMVr/7I2fIUF7s7XydJk0HZs/JlCsrq5Wq/WwGnW73a2dzdPnTmuru/3Oc5ee+/yXXhWO0FaBRIvWgpFSplnGmPhkVHo4HIVKJxXmvdWYCPo7IkoM390YlU7tA0q6a3FwyBgqZKkxpqDSfY2WCNVayxgUVHoUwSIEgwlKoF27lwgBLGOiaBPA7mra+4Z9uKg8urXwzOqfhkoPJ+BysSKuYPj1r5lKP7aWYQkZAbE9KiWGAEjAiFlt0dIH736wvbnZaXUZ58oqx3ON0s1m89yZM82ZxvLy6s3rHxBRluQO8tAPSVnf9UxuGGNhVIvjeHl99diJYzrLK7VKt99J8nhhYeFLv/hFvx7FJkYOGg3n3Ngi6n6f+lCclSGiycNro8lOfQufhpUf1GYBR1eshjjW7XdGmD0a01R7b1fWsZIHaG+ntBzztY8ZgIHSrtGowEhbHqtSUOnuk72+Cl6AwIsg7N1TEJYQRoFdnB+oCZdX54jk8XHhcIIc43p7PzEiInYwJkzl0OW+ioiZYgdOCDHywA8Z5ZSguT29lCaIfojJu7prYYfuHhhGrTUiOsJN01RK11oNZJhAskjIGGNaWSEcmxvBWHe78/Duw0f3H7lcBI4HxgJn/SSx1ppcVfzA973BYJAbzQRXSllDgnPf8VWcGq0F47VK5HlBq9ftprFwnYDLJEnavTYDe2J2oTVo/fbf/1/yUGo0zOWpybhkYJEVx1mLiH3kSEC4u/+3XycHgKmkO7nshzwv/zoJZck0teRB77fQVRlj1oKYKlgOZwOlAuPRcyMiB4DhmUDcV3EEQ6qb8BiPtTYCBD4MyR4GlxVFWHG+EYchUHvrMrmaBy3TXwkcRcGeWni0Ys+0iEZfRxSIuza/McaYfVvKo8anNlpaomm/l0gUAIAhEGVZ5rqu5EJrnee567rFriYRIJI2hnPGLGMEXNH607Xlx8vt7XYlCB0UZ06cHnR7OleIiC5zHEfnirQJhNvLO4IxgaI6U/U8r9+L+91uFFU4oO+4aEmpDMhorev1uk7V6ZNn2BKErmNT1azMfPs//uUv/86vytAzlgR3rDVAhgiQGIFFGhnxDGBKONFU+DRWwDPhKKpTEfxUxCpKKRE59uPeIfr0WH0Yp589x9SwEZoIOcQp3qAyqo3q4jAUEUq94J7cJjYV55ADjs7igKV9TGTKFMqsAcaZzqeCZzZVKrCnLxAdFXvGoJiIMSbP8zzPjSHOueu6UsrR8gJMjZgr74SNa0zFuRYCIAQLrCiBBJILo5Qtjk0zq8kWohWISc494WVx5gBbf7r66O7DrbWtWq3GhCyOgLmua7VBYwPXz1KVpmkcx1G9ptJMCOE6Is9zC8Q5N8g6nU6tVkMCk+WSC04WEFNjHNdVyqChgAkGlOZZP+trQdFi/Qtf/4qRAIwM6UI2YoEtyMsIBgz3p304LDfI1AWHTyFLD3o4Kb3yPN8NB+Ku63LOhyfXxuQMlvzCU+XASJaOPX/m6Cdl70iRHmZjIQN7JPTsTaqRG6k8toOMq6kL/QlIdGr7h7dTHluhgxw0r4OoffR8TBTvhl7uU/XLHPBjTZAAAC0Bs7grTIkBQJ5rRsg5GGPIggEjHYdzzkmixUF7sHTvwWC729ra5pZVvNBkmhEzRmuE0A8GKnW52NnZcYRbCcPt7W3XdV3XDXx/Y2OtWok4gDGWrGWG+t1eEATIGBOcW7RKR45vrCXGEYEsGCQrwHVCymKmwAGeGSuF1MS0VfvV2l342L7xjwfPlMBl1bfQZqcWK6Qo7oZVFhJ1nyw9hKKmSp6ybBsGKO+GHI6ej073jqHXXgDTLonuIlYhWxjsnscFO76+ZQqXrijR3vie0DSYPI0x7aUeCgdxgSPWNYa01gW/dBwxdgoZCr/AhC46WqsR7eFuFJ7WushNJaUUQpQHOY1KD5SlhGDRAgAjNgqCHxqqw9LDFCrIWaZyjsJDd/3p2s/feCvtDxZmmoNe3Gw2szR3PFeTzbLMcRxGBETpIBZCMuAI3FjlOE4xjF1/L2eM9Ttdx3GYFMpo6Xhpmto0rVeiQDiabGKtX630er3N1o4WJAXP251qtdJKe7/yN369Ntc0zIKwNO7YY3TwDtZUWTqVtR0uS48Iu0ooDaOsJsAYk2XZbhwvep7nuu7Qx3sQ554c335hvVdr6AeiCZ/QARpvGYcKeVh8LVjMSNe11o6odNRIeTwjjRcAivPohwsQWyLJXcn2SajU2o9Xq6yFam2VUoVlLiUXQhTvbN+aH4oMZXY5WicAGHmPoLRKH49Kd5+Obf8gIhlgjJGxjDHShjGxsbbx6O7jJw+WZqt1ozQo63melJIQjDFMCoFMMA4ASRozAikdBJ4kmSO5tTbPc0T0PI9zzoAYQafdFkKElcogTaTrAYAvhERm09wipETdNHZCP9VqdWddMH7MjxBsO+6Sg1//tW/MLMwqzC2j/bh6IJWOpMJR1I1PRqWTmu0unk+XpUSUZVmBG4wJ13UZY1jkEJxa+pCedj/vIQTt2qWjcP6iGOP7GhkhzajKSJCSGR4gKqrvUSnsiZqy9Bt+ZiOjdI8vHkKlxkxJPPVMWh1TIsaUi7EJHlR91JfWNs/z3VdlHccZCsBph5gnm9rHpPbsLka7ZxJGeDA27F04zC6l0ZOCvVL5KBJjTBhNAhhk9sPrt95/9/rx48cRWdUL8iS1mjzPczx3MBhYax3H0UmGYDnnmdHSdfI8r7ih1jZNU611msZCiGoUaa2RrCcdpZRSSgjhed6IB0kpESCOY4NMem5fZWmeub7HyNb9cHN93YLJTe7Xoq9+42sQ8FFWFVt4jNiuHjCV9QyX6Nkr/ympFKb5eyeBhmcSsJA9QghjDCv//MwR7CL0mC93zytTLjBCkdHDUeGxMZWTuI2d2QHYE5WTgykfxIH9xDA2r8k2oRRUfETLbXJ9xmY99mQqjA2jvEowwXHH1mrqOpeXYvS8/P9jIRbuc/sWniSDQ04JoCjvZfdu3nt6/+kb333j4ukLghi3kCa5EI7neZnKC2+wzpVJcyACi4NBIoQYJBkwsbW1Y5RGRMdxipQIRcSvMSbO0kGaeGGQqlwpxSyR0kSUqryfJgbB87zBYCCljKJIElbcMM+07wfVsBrIMN7u/9//r/831ADWstK7OPrcPw0c9LrH8PkAvjmEgrdKKR3HGR0DAjhqVMOwiYkn+3y8Y9hjDQAAMqL9Hq2ijNZaSpkkSZ7nlSB0XbeQ8kWDxWvbHUZ5k3oUALwrQvdtNe5jOjDBEaicYmJ3ZXdZwPT44TEaxoMt0me+gL2VscMJWms9RxZR5mM0eUg7U5/veiync8P9rdmRsC12pHc/F1giiAgJjFFcYMHVyVoOHBStPlr50fd+HDihJz1rWBj6KBDQChRE5Pu+MSaNEyGESpXkAgkcx+n2e9wTuTJZms5VZ1SWbbdazWZTkyo2dZAxRJSemyQJ59zlQgLjBDpXzJGpUVwKKaVV1I8HmsHa2lo9qDTqM5nKo0pAuTYqi7O0r+NXf+XLc6cXLENNGjkUGS2VNRw455xM4RdQjLHipMm0lZyiVZXxYerqH84OxmpNxSLclRyIWI7Vs7tMZ7x0meVPMvWpIITAUv6Y4sUXZtIw2qA0z6HnClFKWZglZj+MCY0xmYOlBBFTV4FKenW52FQSncoCj7jcRwcqHaYvVsZxHM/zyjLwKAN4ZoGjwIhfTHIWpbIiK47knBHjxLhBD1wTm48+uHv9retVN6LcVtxwcW4eNDVr9cD1EDGO40GvzwBdLgatjslUp9PR1rR6ncZsU6WqWavP1RtkjNVmJqr60vGZDKTLOfcroQLb6nWjmXqmckvUT+I0zwkhzTPpOgTQHwy6/R7yIcYWxjxjLIkznecudwPpz4S1N370xsrTVTLAgSMxQxYAXNctDosXMy3Wf8w0Oxw+8Xs/OoxJlNFnLOfjPeKLL7/X0cuG/dHww5Jg7MQBl1Evw3yKgFxIRCwESxHYNELl3cKF084C4DDMt4gfxX1pJokIYF88Q1FwOOAitQTRMLvkvrN1H9t79AmgzCmKoe3+Ygn3FNyjk99UfjyCg9gWTMj8co+I6AVulqRSulZpZlAQF8Tu3Lh958N7ALjQXFxfX4+imuM4pBQakw1iCyaNB7Wokic5sxS6gawQE44i24p7wpHdOHEcjymgzEjGgAuBwLQWFhzXi0lnKmeO3FhfHWRJHqe2Vo/8IElUHMf1Zg0ZY5z12i0iPDbb2Oq0qs2ZJMl43HelwxlHC9oSAy44Vp3qzesfnj5zJlEJIEopjVFpqgUKzrlW2nEca0EpxQUnMtMiKKfoVjChVR0CYzQ2TQk9TB0jIsTCHTDEk2ecAp8c1qTsHj2fRIWx4Y6otJC01tqCUMr5B3F/bM3uoPeA7d5tccg89z7T+PNdb/A+iXTIC/hYZHPIr+V44/3LMhzn2Io9s9+pb/qgiRyxNUTM8xwYkrEMuDAwaPdf/08/MDlJJg1gnqp6dcbzPMo1kJUctdaOJ/tE29vbx2YXBCFo47ueJez0+sbaLE/7W5tnT57abrci3zPGuI4D1gjG4jxnDJCBNRYZzs3Nra2tudLhUhBAmmfclZ1kAFkiHGkF812vFw9CPzBpLj3PIlig3qAP2jhCRkGY5DF5+OTh4/Z2K5qtZiY3uRYOR8HQFkaWUyyFlDLNMyn3To3TuF32sddw6kt5phA+lGKHFC7GSh+dW4yVLM4NTZ4vm0TNgp4Lr+aI3EaF2f5bOojIFtKPITKGWI6ZtiM7qjyS4e80FFHlTmF3twaG2Xn+50t7Pcawyr8AFCn2doXboSM6ylsfE49jBXBfGp79e1cMrWWcIdPIUnvv1r37tx9srm6eO3M+SfPAC3wvBIC43xWMMwQU3BIpQ7XajFXaKO0IJxnEUkoNlgtkBmpRpEy+0293Ox3pzYdCEhmllRY8M8ojzi26QvTTpCLd+cZ8vV7nnGeDOKiEmVbcFyC4G/jHouqjhw89IK71TBBI10mzLDeaB1IIf2Ntva9ibYwemOMLxyt+BQ1yRAsIwPI8d4WLiL1ez3MDLtAY67quJr3P6/spkOETU+MhJYkMIiN6Vj5emoAxaQn79VjcbzGOSbYyDZdTIhW265gjd1S+JEL3Sb+jrMsIYL+WDhP+1b8+ch0bxtQCsH8ZP32PU3svoJxrrrwaiIgEAjhoRql992fv3r99jxk4d+a8FK6UUkqZ53m325VSZlmGghcPkySxSjNEznmcJpVGXXHAwAVH1BuNPE8XFxcHSV8xk1qdamXIumEgHCeoVKJaDaztdbqh4wkLXNs8TkyWE5FSinG+3W6tbm1oa9Y21xxHAJlBv8uByFjOmOM4p06dunj5cjRTF557+tzZ2dn5ZBC/9dOfpUmCiMVORhFBQRYrYbVwnxJCu91ut9tHQSQ4gvQ6vMAnxq7hmzpKVMNBPxVH42E/zeCuq6p4YgvS3SXL8oZegRYj5bOMyrssYZ/1WCLRvdjXQpbu9r5vT2yPPkdPEIDtqdaw3/X6CYikTP9HKVMe5+5y0WQBxthBe6cHv5ej5qwoVm/3RezfsjLgMvfeh/ef3H9oM8Utc6XrSU8p5fv+YJA4vpdlme+4HFkaJ0qpOE3m5uZUlgshgFOaZYpbYphpxTlP+gMpuO8FvbjnBIGDnCvwmPB9N09Sa6EI8bXWcsQkSciiG/hJliLnvUEsAidBBQKzQayzfGF2TgCYNHddN8ty1/cKF7FwnI2tTQCYm1tYXV5JTcZ8/ju//ztGWMsJeXHnDONMqkwzxixpYMQ5J0akp7/B3Sd27MlB6z8pvaYu/lFgDCcR8cCohkO6KUknXpZIUxMamSE10mhnpbDQhqRCUK47MhqHLB+HMQ8AsP+8FRUnyyfGdiCV4m4IhIW9sziwj+N8QhJ9Zt1pr2dv12TEncry/BAqnWxz9C72Fdgd0WidR0tBRMMcGgDFTgwiZ4CkyWb6vZ++t/xkpR7VorDCgHPE4vxKYdGkaSqEE/pBr9ez1hpDtVqt2+0GnisdTgi5NeudHSfwlVVI5DJR8QPSRpNlnhwMBjazpHQg3TAIKq7f7/YCz7PWWj3MJaC1RcaAszhXJ86cuH7nZm2m6nseKMMRrDZG62K5XNfVygDDPM+FI3OtOZcC2U6nbbkNG9Ev/MpXwGOWWWKEFhlwKjaZyAohtFUWLaPp98FMUikc6rErV/80hFoswhiVsrH3PS7NSjC1p9HXoulygEEBDIr77/Zc56PRICIhWCBDlhCAYXFYdESxHBkSkLFWGyQGFos/JFZ8xf3h+EOrlRGh3c0UawEsoSW0wEa0zYgKMcJGfzTMBrzv4TCb3W6B0QCKMTDgQ2dz6W+yhb3qe62VF3zvOQNe/IGd3ggit0CEsLshUYyBcRT70iYAs8M/MEQWrQUiIsEkA3AYF8SLyxosEDIhuYMZPvzg/l/86z/fWds6dezETK2xs9OW0u33YkRukXX6PUSMe31hrc2V73ogpOGsn6bcdWKrYp0DQHu7zTWv+VEk/IA7oRu6zOOaSyNQWat1L42VwI1OK8v1IMk86SWDFDRIKZVSuVaVaigdLjlWXdcM0mPVmbw9cDUIZX2UNlWYaQ94yF1mgBNk/VjFuQAhUUhCYaEZRCG48Ub/+ls3UHHOpDYGwBIpTpYRcGRDzY7GU4EXuFz62yOeZ/LxkvQa05vGcWmED5NIUhakMLT7YF/eo2l9HDaag7Ssqe1M5VVljlCWrrAnaqYH+o8W14IZ+2moNMJexXKt4sDrQRr+4Zr/SPKXfjVjVSyMv87yMMrMGEuRveX2D4fRgQ8yljHBAEe5MvYu2C3OKiAUZgIZU+xOW22KA2gAUNiWgjtIbH1l49233qXccouB73vSAWBSuJI73W7XEQw4cxyRJAk3BozlXHLpbvV7WZbbTC0cm09N0u93a1EdLeaWuMMRSVvl+2EySCEziGSYdqtBam2r1bK5CbjTrFQ5IOU69H2ttRCMiJRSUkrO+WCQCMdJslQIwZCEEGCs1cZxJRH5XpAkCSIaslrbXOvhNp5RjAlHep003ozbv/v3/yZGXEOKiAgWrSCi4QVvaPduRN339qfnXnkmXRxQbNzbUkaGcte7VWy5ZNHCXshLeaCj/9M4zTPgIHIqTwP3Z/seVaRpxuHUARQit7infEwYjknFkfAs/h80ncnnkyOEKW+OT7KqsVrlxZzs92ODsSZXOsu11tZqYLQ3v1GPYBGssFZYYNq6XFpt8jwFiSmoXCDznDyzAQu3H2386M++/97rP99e2RCOVGCsNXma6SSjPMv7/YWZGSQAY5EzYCQCT3PIrM5UHvqBAGiEFZfAZcIY83RttZP2iZFweC8f8MDdSfq5RO1zCFyDUK1WCWxv0PvMq589c+W8CcV21osdmzrWuhirNEsTwRkC5UZpCRu9beE6WusinJCIHMcRXEouVZ57ris4d4VkZGcqYc0PJbJqtep5HmfMYXwuqn30/g2eG0kIliyRQbIMDEJxWtzuPxpOZA7ZPJ+KDx+rWJnQntkIAOzKWMBuvwMTW9uH1MSSm2e067q/6XFv6lj14ms582CZPssntsYaHys//IFNzxfBSjJznzzk0+X/4fMd1qW9Bid0pNGnPfY01trhygUcUZaqPMuy4hC2dBzXdYukPtYOozhG7QylRHG/PQdgpMAaBGuBW+YZ8fq3vrd06yGzMDs7W51rrra2ULDI8TzhJN3BQnM+6afAkEthmHV8pz8YhEGQxYnVBMZK6ff7fZvnyKjWmLGcDCEhkLG9fockR84YiizLwjAkImap02kFjarjOKdPnLx967YQQilFCGkch67XjCKPGBlrjEHHSa0GQomMozB5JoRgiEqp4sow3/OK9C5F2jpjjOv4jEOuFBHp3BBCrNNO2v29f/C3KGAZaovWIgMqeLop4lwEitK7nsJePzVMj1qd2jgRTZ5TBwA2yeMPp/V9GH+wlDiozUkcHQ0ai5BahqO/IuGVBSpsV0PWwsiOY8gZExxKpFiObB4bzAjoADhomqOVHfuwH/ayS05aqof/HXE85YFpned5qlRWHH/b5XFUtqZGR8+KxdF5bjJtUu0zBzUI4jev3/zgnRvc8hMLJyI/MmkeOp7ruhvd9lbSG5g8AWUc0Nxal1nBBiqzHLfbLRBcuk4vHiABMXrxa1/4tf/idxuLC2SAgfWlYNZ40vnGL37dMdw3FCEPOHcYBlHFAO1sbjMDt9+70V3fYZmdqdSzVPm1aszopV/8heDEwk6easG1sQI5AGhrDBruOcyV6HASaBjxwMnBJCY3YB3ftWCDSsAEEgBD4AzBatcRFc+vhpX15VXSZoQAHEkAScLibxdDxnOX/RWR6CeGfflKpzu4PhbeTIWpdQ/RNseOdExtzZZg9GQsCPbwUX2CpafSBmOZdJ+5Jp9m9Q4Gq6zJtNJaa2uG+8m78rOMZhaGh0UtAmNMMOlxt+5WdDvzjNhcWtt4suYJ97nz5wPXQ0to0XN8T7pnz55ljM3MzKytrVXr9V4Sd+K+ldyQZYJLzzVkc62jqMY5n2k0Fk4ci7Nka2cbOUPEc+fOffkrX86y9PUf/rhY7ahWPX76hF8Jut2u5wXzc8fmm/NzjbnF2XnK9dOlJ4wxbQgE/+d/+IeyEvDABSEMgnT9OM00x2h25sSFcxnplAzzXW+mGjTrWPHQd0QtnDt7ckB6QHoAStYCIyEj5dYrCanU5ITwzjvvmNygpaNsVo3e3Sd4NyNpccTqkxh7EH4++56YMRgbAe0XrYeMb3JAVJKih6vZAPtyO5R/GpPnkzJw9FP5/0HCc+qvuN+vNio/MeahjnmU6U99PrXEqCNEBECLQAwRuRCCcUBGiIUzhEZ6biEh9NAVYpQyLkqeY2tre3N9y/f9Wx/c5MiuXbpktRaOyOPc93yjDWozaHUX6g0T542o1m3vANhcqXhrSzI+U68rlRNneaas0k7FMZm69fN3+vGAFKV5zl3+4aP7n62+FMxUk0z7gR9EwQsvvYie2MoGbpKr3KxubJ45c66XrEbVWrK9febMuepcfW1rc2NnoxZWbt/8MO70HOYEQZDbJNa571WOnz+FyJv6mOu6lUql1pgBgDfffDOmNFZ2c7nX44pc78SJE9UoCuIZrXWv1wsoWFtZ1dpkeXbj1q1rn3uxwB4DwMDA0DoFt+D4uO9d/FUJUipFGo4xejiQF0w7ADP15NpB9DbWR9llManBHjJ02I0oLFPR7qwOzAk0ej5Jk2VSL0uY0a+jHaB9mZ0PThI1thRFSbZ7oe3YMGCCaCdbm+wI9ztmYZpdOjZBQmuM6Q66jIBzLoVwHIejGCWOIGCj12IBGDEOyBWsPFhauvdoe20ncP04jqvVaqPRQASV5VprQ8SEkxEhopSYx7HLped5Gzvb3HejmcZ2u5UO4moUqTidmZlRme52u5FXsaQt147n6sxaC/XZ+pOVJwwoCIJBkvtBIHz386+9evP2zdWlp2krPb5wHCQqqwQgWtJa1xozTuC7vtPtdu/cuT0TVUlpa+jFF19McvVkeSnJ4yRLa7XaL37ta0tLS0HoqdykKk2SrNmcOX36LGOwsbF18+YHjuPNz8/O1GqtVuvccxe31jfiwYCM/vnbP3vx5RcvvHiFOFm0BVOzCBqIEFwNZUT+xIQ6JkhHX8uRP2OIUcbhg4THsOSISsew5yCgkhekvL0zCYVqOkrDM3VWk90RjQytfTQwOT0YbgEPP4wLZDuF1BHRwviAJ3vZJ98O2Ck5+nKVi03Oony3ymSuIyi9xYJKrbXKKqs0IkrucM6LOmTRWotcGGOwiIVmyAw6CpbvPf7p629QamZqTYFMuA4iclmkz825ENqazBju+6dPn86TuL25LZH1ej1wREYmzhWTIoszMtYT0vM8BC44Z9bEeZJw5fs+z3mepAyscIV0peAyG6Raa+G5wpf9fk+lucOCubm5ne4WcGCCA2MW6PyF8+cvX7RWb29u3bvz0YO79xwuXn31i1mWrW1shpUgTft37txxXTeohBsbG7/1O3/jzJlzSTJA5HmeGkMzMzVr4bvf/c7CwuJMs9lqtR4tPdZkZ2dnv/SFL4Glzc114fJKowYSrdWcIxrNGDOARMQMcc4LXC2sp+LWcyolvph8F1Nf00gS7MsoBGwMryZRYp8kmNAZAWBKps+i0EF5WfYXGx/u2Gjo4CxMUwERR2eUobRnAwdIJ9wf4wZlAqZ9VfakDU6RgVN1h0m6YtNyJk5wmcOyLk5hpQfI0tHL29+mBYbW6t3yrDjWm6eKMSaEk+e5kC4CFHd+orLrd5++8b0fzYRRIL1+L67VasyV2hoppe+7g17fD/1M5Z1BPwf6wpdeW2jMvv697zuM7+zsnHnu/L2lR7ExwJAMeFz6jmuMyZLcc2XgeheuXnzz5tszs03dVZSpFy5fvfXhDeYJpRQ3KLmwAvr9vue7VluyUgiR27jVbR8/eQI4A0RCOH/xgu+7yaB3/PjxOx/edhxnZqbpOM7DB4+3dzaff/5qtVpZXV3f2toqkl+fOXPmg1s3Z2cac8cWPOm8/fbbQRBcvXo1DMNWt7O8snbsxPHm3Gy33WnWm6vLK3dufQgcLr5weeHkIjBDZDhZIGJcaq2HJyGLfQHGAMDC8MDWQbLuEL48TaLuo9Kp+uDkh7FmRRknRq0Up7QPkr+lAR2oGI8Jt4+lP4zVGjG2MrmOGh/TJMtEMkaKU+RYKaTxYKVglK/rsKEeZTqjuRyx4lT2RMYKwckiEQHnmdJE5DqeUgoNcS7REAPkuWUMPnz31uOb9+fCRi2sIFm/6VqGCo3hhAy6ceJ7ftyPkWM1itY7Wzs72wsLC/MnT648epSofHltdXFxcWV70wBmSY6O8KJQZblSKsuyalipVConT568c//+8dljaZotrS5XGzObnVa9PoPKxHEMgm3326cqJxBAZXpze8eNfOF5ea667Q4iRmHws++9rk1+4dJzZOzps2eQc+l6N65/UK3Vo0Z9s9PaGbSjKHrluc8i8K2trTfeeGN5efn413/RC/ztza0vf/Ur/X7vx2/+5Jvf/Gaz2YyTLIoiQdje3P7ef/xWrRINevHm9tagO/jN3/2mFcAkM7mSUoIlyZ1Cd4NdjLLFNsL+l7OLbAyADtlQhQN490G6WxkZyng49isc4j06nETLXU72NNnNJPEcqIJPRORM/Wn039rxdGdjUxgvD+NqwhFnOnU8n77iISZDufDuojEEY7Up7E8kdKUDwPJMS+GgBTIWNG1sbL7zs7dJmzzOZ5zIRydPM9eVjKEI3FxlmcqvXXtxa2O7vb4ZRtUsS9IkbVTrGyvLtSDa2diqVCrJIDa5Wl1ecaMgt4Zcsb6x0dlpSS7mGk0Em+nsnffeXm1vNer1wWDgSJnneZZlRTiiG/pXXr5GHBWZVqtTq9SklI1GY3lzNaxGKjccuFVmZ3OnVqtpcrY2d56urHz9V75B1pBOHO5sLK+99uXX+tmgO2gHXshQIGKj0XCl80tf+/psczaNk2azef369adPn546dXJpaWlp6Um70zPGVCvR06WlwU4vPB30O72FuYWdzZ2N1c35UwscAbhlTFhLxphhWoH9EmUMXff/NN1rM/Uh7RL8VJw/RMKNPZxyJLo4R3YI3owhUPnrGP7B0M4soijNMKp298m+UFsyu39Thj62ZGPyc6zYQWtRVCxig4s/BsiRMUCwxADHdjLB0mjLsbyfNjIhjrJE+5di3N6YOotDpg9D1Z2BRQacozDKqkw7jFNuHBKrj5a/82ff+nf/0x93VrddEkKRFG4QVcKoQghbrR1lcgOmOTc702xYME7ob+/sKKWstZwAFT3+8COWKt1PqkHgcl4LQ0+IwHFdKaJKEEXhTKPGBaZ5MtCxRiuRDVrtpNddX1spJmIz9ejhw2o9qs3WZpr1X/qVrxsySmWbm+vt9g7nMopqiLw3SHZaHct5q9/NrUlyBcA+eO+D2bDOFSx9eO/+jTvf+Y9/cePdD2ZnZsFiniqT6tDxXrr24ke37nzw7vXlR08lk599+bOba5try6v9Ts8Vcmtj88qlq2kcX7lyxYvCnIwTRa1ePzfm6coqAPQGA4ugyVptXOmN1naULWQM+Xe1VhzlUz3K+5pU9EYwpsFNNjiJ1WKqJNzziB7BdC7XHft1xEtGOudByD2VFU009QyZM2rBWssPPjo7qfoe1ikbn9Eh5ScbnNRk4AC1/JAuykROAJaIIUNERoBFQmJNTMGbP/7JxvJq6AQn5xYdJmfcSlB1OWODpO+6bl9l9fnZxvzsxoN7F69efrz06PSZU2kvfqhyjph3lWSSW+siJ6JWMmCSERv6Y6V0uoPec8+dk8i6rfbZs2efri7X5mf6g0GapirLsyybmakJIbqdvue6QrLtTussWq1yRzjEULjOiVPHd9odRjaKIp1ki4uLcRxnKrVoDUeVZ2dOn+xs7fz5n/1HQZwBztTq2xubT9aW263ta9eudQBmG80Hd+/12j3Utr25Xa1EcT/5t3/5b37/93+/Xq9zKVWWLR47tby8bIy5ePHiF7/01Z+/9fbTx09r9UYQejfe/eDS1QtB1SciMFYIh7QBBsXNN8VlGUU+4bG3OdqiB4CR7J366g+SsYfYZaPnY/RVbkrQfi9Fud1JEoUJWj2EunbLHEjbMI1gDlF3D+iFii5oKPdGrMGOui4NHmD3nrixxg9hNKWHRZvPPmNQfnI4fCyxTERM8DzPJWeMQGvlcJH04+VHT9aerOZxFgnfRbl44ozONOecWWSSKUIlSLucfDe2JgiC+3fvvXDlaq1eX374kAtQuXFdF0EgaeQiz5JwppaoNDF5VKs8d/FikuXqoV1eeWqTbLbRvH/vbqVRPXvp/E6n7bruypMVQxYRWp2daq3a7fS5z2/d/dCdcS9duPDBjffDMORSeGH42ovX3rvxQbVa2UmTKHSzfPDClavcl5nNL168iATb6xsbK6uXL1754Q9/OFOpn6yeWXr4iFKz/OAJANx572aWZbWZhlHWGtre2GZMvPDCS/Nzx1Y3VrkU9Wpt0O/PNpvnzp/hUgLD5dWV7iDutnunji2k7d4f/bN//rt/+3dnj89bICAwxgySQbfb7ff71lrP8+r1eqVSYYwNb44c7r3tZYS1lkoZuQ57p5N0dBB5l2EqQYlytUMwbCqJP5NEEREOjss9qK9DEHcqLU3anwBA9hnjLHO1sdZGT0bKbdkenjrjg9o/aEajMSMB7d8cKvEvWyTTGBYjAoA8174fZknOkQWOf/fWnQ/fu8kJBPEoiEymSel0kCqlXOlJKQdZ7ESB0irNsmNRpdfrpWleCfidD2879+8ZYwaDxPcqhtARbppbAKjO1NdamxkZ7ojnLl+ZnW9K7jxdWg5c7+T5czs7O1k/DcNQSDY733S489xzz4HFe3fvPn34NE1ThsgsO75w/KMPP3p871HcHRybX2xt7SzMzWut0zh5/vmrdwXrdTqf+cwrCyePoctXNldJAALOH5v7+c/e+vDm7ahaza3FQeK7PpLVWn/2859TSr311ltrG2vdbhcRkcOic3x5ZeUHP3p9a2f7C1/4wt37D7a2tx1XNBr15szM0srTndZ2nug/+Nt/5/vf+k4lCDKTfvvPv/0H/+u/xxCNUUmatDqtzc3NdruNiPV6vUjs6LruVC2SMTZysB/0ZsewaBQnVzbWDmHfuD9eoCg/3XtEJZ/qZCujz6UREwAvYzaMnGa6VAune3oQ9iwBO3GDXdHgyFowxnA+TDvIObdW7wl2YkCABV/A4VoUzI+xPff12HR2V79kLexmJyzTD9Eo19lhTvli/7NQi0YnuRFw6Bsc230hZIDIRK4UcCYYWG2KTLGWrCFtkXMhtLIckaMg0oIx0sxlLjN0692bt969MR81JDKrjY3zahTFWaqsIkaOJ/tpkhhDxvb78XxjTg2SrDeo+qGUPMsyNEwp7XrBYDDw/TDLsjTP4tiwuB94ARqlBTIUSMwom7b7CwsLl166ikj/4Y//w+bm5hW4klnrhK70QpXkKARZVMZUg7DVbQnm1pyasVqC6G7s7Kxvvd9NFhcXhcHt9Y3l1dVB3N/ubi2emTe5Dl03y1IiyPrp6bPn5muz77zz7ksvfOb69euD7iAIPPT40ubT+lzzxV/47JNHj3ut9gvXnm+3d4JK2E06whFfuvxFzt3N7cfLW+tgNFk16HdW1zZ/6StfefTo0c1b77kV98qJ5x88fsAdRIsWLRMMBBAyZWycZkopbSmoRLWZRnFxMiICGWstwMgrse/E6VT9toy0AMAYWktElgho/3HWkniwxYPdz0Q0PK1d4Kwot36Q1leGMeYxJtbLI4Bdat9fe1yXntr+mOVW0GRBS5zzIn8v7D9YM9nO2P8Cyib3aClHl6kOey/NDg6I+DsIRjdPA5TVCCjRekH9xVeDwPM0kZ5v0SqtXUeS0VmWFfcyEbA0y1zh6txw5L7wDFnS1NrYufHOe1k3mw3rjUqt3+l63OEOR8QgCDY2Nmr1uiJLguUpOQCO5zHGjNK1qDqI+0YhRya58L2w2+0tLCx0W13LWK4zKaUfBL7neUSb/c7Nd6+fPnu6tb1Ti+ozs01lDAqoRfWnSyuPHy5VmlUuXbLWEXJ9da1WjzZXNjzfYYK7jpOkKTKan19YXDh+kz6IwqrW1nX8O3fuvvDCC4+XHrW2NldWVmYaDc/zwBEA6JBIw2hzZZ0ZvHPjVtzrnzp7xoIe2IQcYA5ubW1t7my+8tJLxxcX/dCVgRPUgupMgxEyku+/+16tVtNZ2t5pb6+uX7x0NQr8q1cubW5vnTtzdmNj66tf/drTlSdgEQUCw+IuyQIBCr+RtVYp5TjO7l1+exy8gNK1Y4ftqI3pnrv0tvf1QPzZT8bFw8MCg55JTqPCY8QwygNIRDDhB6b9tSZbm9pdsX1fHAEp3HFFVJO1eq+d/arvIayu3O9UhXnyNRA9wyLd64X2rkUiLJzJQBaRANmuHC2IGQHACsmsUZahYZCo3EXuuYG2RueKI3rooGWBdDC3Sw8fSilXny5vLK0KwqZfC6Tba3c454aM0SaPczfwwzAMq9EgzYJqpDhKKdM0JUaEyARTWiulapVIZzrrZ9WokqepkEzliknm1YMsSyjVDBCz9Nyp5+58cEMD+n7txu07ry3U0VJvp8ctu3vnQbvXDgPv6uUraT+hJO7ovhNJI0zOdcV1Kq6TqTzV5sP7d3/79//m7Rs37919oIxteN57b183OkWy928/+NLXFqXvGITHDx+KzHz/W9+xqb506Uraa882qy985tq//7M/OX/twtlzJ6XrzDZrkOs0jte3NpIs5Vasri6fRqiHteVHS7PV6pOV1Vdeeun+ndsvvvy51afrP73zs1/4pa8dXwy+++3v+F6gE33v/v3PfflznDlaacGk67pBEFSrVcZYGIae50kuBOND4Tck1D1FdOwmzjFqnIq9I9SydihXDrHpCn4xhlEfO9r+cBiTqEch8gJKg54++uLm6RETKjictXbElWi4quN7qlN5wWS/iOMOpHG1HBEPuK1wX4O7cpIVmdkIoAipZYUaTZPS2RbHHgHQQrHbnmZFvgImgVljQNudnY2fv/FW3OnVZupR4DfCiFnmcccqHQRBlmXE0HGcOEurrisdN80zJoUF8jxvu7VTr1d7/f7i4mKn3UbEPM91rlzXTVVaXBYqhAAmSIBwuOvX4naXETt14uT6yipHsXDs2J2PHniR/9ZPftZqb3vW8Tyv2WzOH5t7fO/BT3/4I7D00isvX7h6udXpbGxtLz1Z3tze+OpXv/a9733P9/2wUtnY2jTWtjs70Uyj1+/k8WB2po4MlFJvv/VOc6E5SJITi4uuy547fz6QvlLm+OlTg2zgh87c4uzlyxc5R6sVY7IeRqura8tLT0+dP3NsbjHNMmC4vLysc1UNK599+ZVqtfqrv/Jr3/vOt+M4l1J++OGHlWokpPR9v9vrbe/seJ7XS3thGBqjAgwWFxer1WpBHpVKRUo54t12iEvD2L3yex979ZM64Bia7dlTE7sqoxqFRTYpYJ6dNfsgchrTe6F0c+4hgnE0jcMVhkkYqbtZlgFYz/OKZR3eOFRagoOIsxhemYBxQs4Py+97Unw78qGngkTtXp2hAszQ4PDZqC0kS2CAEXIGWrtMosE0y4OgQtoYaxQBs+zWu9c/+Pn7ruWnT58WLvOkl6ms2CAgS1JyrTUKRkQWqJsMgrDi+V6r1WJC5GTq9Wq3261Uo/X1dd/zEFmR/zdPc9hNJpikCRTxcdpkWWaQRTMzWvDa/Nz2w361Wo28IHT9PFeSMM2T2mzjxZdf4Bwp1yvLT+qNmaufeaEf96szlcZ8o1qPHtx9/N3vfqcSRHmeM21/+qOf9AfdhYW5JEnibhyEvnSEsgqBra6ufv+HP7hw4QJlpr21fe3qC9//7vdOnzpz6fKVn7z15pOlJau0I4Q2VkoZ9+JaVFuYW9za2lrZWG93e8eOH6uG9apX317d/OM/+tdnz537zCsvPfjoQ032wfKTxZMn0vbW45WlZq3+3IXnKtVoJ29nOhcCMhUzKQSIer0eRZHW2hgzugAWS5YiABsaKvthDH8OIdSy9Jp0jkDpToayrB4J8PGs2Qd9fSaURX/52Odka2Ofj0KoiGitzfNcCJEkCREW93yMXEqHcJODhnqIPn8U+/yZUGK8YAFp4gbNXTFLjuOkmeIouGVGmdAJ9CDrt3rr6+uzs7OCybQTV9zw9LETRFYyYYwRQjDBk0HiSpkbTQw91wWGjfk5ZTQTPMkyKSUTAoADwzAMBeOGMVdIzThI6XlelmWO41prDVnpup7nbW5vNhZmu/1eL+m5Rg1aO2makmA/e+ttX3ih33zt8y8YBj9/7/0sz63VjLGTJ09G9drjJ4/WW1tCiNRkdc+dm2ueOnXqO3/5vXq1vjA3t7m+kcT9EyeOHz9+3ObZ4uLi6z/58SCLm/Nzj58s+b5/8eLF0A9aW608VQ8ePX7p5Vd8P7x1+4629t79h7Pzi9YwwVhrq7Oxtv7ilRettbOz80+frrz44os7Ozv9Vi8dpA/vPeScA8P3P7gOWnmec/WFq3PHj1WrFa31QmNea60s1WoRgHU9mWaZMcRIAIAQosCoEdIOs0nhnkb2cSlihEIj8TCi0rIwKwsVmvDaFJ9F+cunhDJN0jQn0yFVxoY1lUtxzqWUlUplRKXTlIfxBkfsbdLUHNNDptLkbjT/UXc1CW3ZLi1uhGMAw2T6wIrUp0WrhIyIcmUYcMkdnWiPSeqp93721tLDpfNnz3340VKvH1+5coWf5P049jyPI2MAYTXqdDpeJQBLkovMaMMgTmJOolqvqdzEaXzm1JknT56I0DVkKlEouZirzXRarcivdFWXc4nMbLZ2jh8/3uv1fN8fxP2wGi09fcIcKX3vzNnzr//w+57nMS6rjaZEttlpgeSO67zw2Ve2tzfXVpfn5+fXd7aE5zLPiRr1PM/7/W4/7jmO188GYT1YevLoydOl0PHCMDDWzs42dlpbTugqbsOqv9be7iSDE2fO+o574/3rJ44dbzSaJ06cstYCsXfferuX9mdPzctM33+4FEVRFPpRpU4IRHjz5k3Jxa33blT8wPO89955Hwx99ctfOXPxvOM7VqcbGxuLJ85sbm85oZvGg+6ga5R6+mRlc2ONI2VJJjgnYwsdZCjHkFlrDew5JhljQLTrDiwI+ECH5VQF7ZCSI8Qry9KyQ7TI7IV4QIDO4UR7yCgnE9vTLpSLTZ1PmeUc9LyQn4yxUSaRg0Y1ZgaMdT325KAZHW7TTl+EkScLAGCYGLQMvJj7kHoRkZNhDrq2r3yQyfbg7R//vLvWPn/ibH+n63PXRb76ZFlyUa3WrbVZlhFRkiSkjdYaGBZZZpQ1Tug7nhunaaZVEASr62vKaCklIiIBJ+h1Onma9bu94k31kziMKkXymt6gH1YqQoiwGhog1/eW15allL7v1xozUaM+UBlz5Ye3PxJCpIPY4U6n3btz687xY4tb6xvJIAZDQRDMzS20ur3ltVVl9bWXn3/5c6+89uVXP/v5z3iBa4z61re+tdNuv3fjg1c+/7kv/eJXgDPp+p1OZ25u/ktf/gUvCJTRZ8+eEshu3bgeVcOTJ48vzC60NnfiTlIRPuak02xtZfXf/8d/98ZPfzLTrDuCPfjo7uby6om5hYXZOZ/J2Uq9v9O9df2WSrPuTuuD96+vr665rl+P6mEQgcXPffZVQ1hkljDGli7gHG5JlAF2dcOySDgEJY4odcpYN6ZylinIGJPnuVJq/JKVqVDWqqcObmzQY0rC6AoZxMP4ze7D6Y0XWvQuxZYV3b2zfFiy70eFy0LyEC1337xw3yyeXX5sFjTcNLI03PLSuxFLnDMiKpLiqSyX0kVC0kYCPnm42t7YyQdJ1h0E0jPGMi4AWRRVuRTMEgOrDElXosVBpxuGYZ7n2pLhDAQ3ZDhnRb6vPMmcWpWsFZ6rtSalBqlKASWXvuv18kEURXmeO47T63dTled57nnek5Vlz3OEJ1556Vpz/vjG+vrW+goiVCqV96/fkK6TxTms2h9+6/vb7c7K6urs3Mxv/sY3Q99veFF/Yzve6NUXGiDE7Nz8n//ln//Wb/0WA2wuNj3peNyZOzb3l3/6F77n3b3/YG7x2KunzqVp6gvPnZFWmZWnqxubm4yDL93XX3+9FlYQTL1RPXH6zHf+03crnp8o/uF6C8k8WVuSob945uRv/d5vIjFhseqH3a325vpGEARXz5x/53s/QQ5xewf7+dKdp1Kwm299EH35i+Da69evr6ytffPaNzVjwGRujHAcsPsYelk7K6N9CRmm7AjAwZsrZWN1TCSUmt27jaUoaK0FQK1tkQ3zSD7eQ6TNdDQtKZCjvabyuKdOZrf6OPs5iHsdzl/KLKPMq/5KdPuDwTLGc5XL3YOviGiMQS4IsfD2IJEjXJvnnBjLyRhqb7Z/8vZ1NUgwtzNRVXJHODIMwiAIVlZWoihyhCzCJGZq9c3tTcdxQs9XacYQyZIB47qu4zn9JJZS9jrdZmN2EMeZUlJKBzkAhmGosnxnpyWE8N1ACLG+vl6r1weMZXFSyF7f9+N0UA8q/XZrYf6EJx2dZJapj2596LquX61srq0eq9Xb2zuudC+eO9/rdd792dvLT5+EYegKeeOd6+evXKrO1h+tPYnCaOnR4yD0hBCOI7Y6rXyQJUly8uRJRZCq/O7tu61WyyZq0OkK4Wxmaxqp3ep+81e/UQ2CH37nu9Vq5dSZM47vfe7lV3o73c0nK9VKwDm7duX551663E66Boij5dzZWFvfWd6oVWpM2xvvvu8LZ21zoxKGaZKCJaWU6zjvv3u92+lcu/r8+uamH0ZkARkTAvM8d/kUo69sJZbfLn6C/fNpuuEkNU0VtjC6dHgs02cZuSdV0IOMN9i13yZ/LWTgbt1xo3kXyhtE03MWl4dXyNLdKiVZSuNH0g5Sgw+Hcn6NfQozTVmoEljYjT0SjFsLRU47C0TIldGO72VxIoEJy1zEQauX9OPbH95LBim3KCx43AVL9caMRUgH/SxPvTBI0lQK4fu+soaKOyAYd6VbHJIcpIlwZK5VEIW+71uVZ1lW3Hid5nmWpJVKqLX2PC+O4yzLvMD3HA8RsyzjUjiO8/jJk+bc7PrWph8E3V4ninzXdT03YoxxMACgSfSSNEcNYDFVYGxYqZ45dTrpdXda251uL03Tubm5fhKnVgfV6PT5U8dOLWqThdVIqUxKiZY9uHN/JprRmX7v3bdf+cxnttudubm599/4OScIvPC5y5fev3fbIly9dvnU8eM333lve3MDOROOlw6yPFWQ63q9qq166dWX/YVqJ+3WajWT6mSr9/YP36yJgFu01mog5spBlgqXXbhyefH8uTd+9tNOeydPM0863/zm33j/w1sXr110Aq5MSghCiCJ+Dmnf6eWpltRubqSPF2cO+0iJj2nOIxwuVWe0e8A7yzKlFGNMHEx1e2LnKMh9UDv7eclhPp7Rx6mDObowH1UZqzip/cKRBfJRO0VgKAgxV0owDsB0rrkUQOigNIPc556wkPb7N969vvF0hSwK4THks405nSsHeabyjdbmseOLeWxindaCZpJn1tput1ut1QZJDACc81anjYgL0bxLtrjZWhCqOE3SASIKJq0xoXBdnzNiwDlDZIz5YSClBAaAWGjdiLgwNweMLczObexscyZc5iXdJKYcAOozoe/7JtXzjZm17fUoqihI2tstVoUnTx8n7Y4jZC2sOEJaTa5wHfQ6W620Xmez8zfefSfJsyxLm81mrVLtdfqYwvbm5unFE4/vP3jl85+rBFF+5fL9W3e4ofb65mJjFj3n8cOlrbWNpbv3o0pImR504tALXeEGlQYwQmJAPO7Fa2trNS9affjk6e3HPnN9108HsdYaXJmRydG89uXXwnpVCzh78dyjB3bQ6Xa2d7IsydOUARY3EpC1YM3Yi8bSVsoY1h2OhAf9Okn2MMH9x34apXcRQgwvVeoN+mMDPQQQ8eCz6ocFPe1SCNEUQTpWd0r7I+V+t8FyxqfDZGlp2B+D5CYSxexO5EBZOkrXwqwB4IwRIAADbq0FYzlytNRrd7rbnQd37jrAbJo7XEjponTSNAuEg5ZSrZgU7aQnAqdxbJ47vCL95YePQRlXSAkCGDJH9tKYLFhrozCsBGG30y44tOd5rud1u93AC9BS0otdV7qB30tiIbmx1pDVhQlkqRZV4zgmgm6/V6lUDFGuDWOMGZLcebK61h50Tpw95rpu1Z8Z9DoIRiAEvr+909aSub7jWMzjRAqPCIWU7V7XEawShGTNo6WHjUaDCSyOEOrcIPJU5ShFrtKTZ0+98sXPcybVIFt5tPTw5kfckZqxs5cuvHfrRqvValSqpLQjpMvZTFAzSllgjuv38kFOSviC0DJAyK1DHBR5jtPt95nLDVolcKO99Qf/8L9QYJIsCyqVWzduJIP4+Ox8e7sdp3kvG3zx6190AmFyxZCQCaLRQeI9Hc2Wbu4sHn4yWVpG3ZEsnaDScgZ5xN14WAAoHKVT7NIyIxnDbzzgRMhB45todq+d8sZueYJjpDX5+RPAM+nz6LL68KaQQDBpteHAkm7fc9xAOkuPnrS2WkuPHjvCDV2PYsMcEQY1Bui6bqJz15Euk1mWGmPA5WcvnLtx/8NLp15aOD6vumm32+7vtIWQkgQR7XQ7ju+1+11ErFQq2hpkDKytVCpcCGNMpVKJ40QwninleJ7SGhG7vV4cx0El9MIAkRjBIIktWavt4uJie6dlyEoUC3MLT548YUzMzc17gR+GYbvddkiCpTBwszTO0ywKK7nEh48fzdfrjnC11gTMMuSSuZ5vyJAxx+cWrbWBG+hcmVxVvJAYBj5lJg+DYHtz58b1m2EY3r31ETPAyZo8j2p1h/GqF9RPRZKLuD9wOeOIqU2ZZJZooBNiSJpeuvqCI8WHN27GKnZcf5BnWZ40Ts730sHC4tz61mad13/y1k+fu3LRGlLGLCwubqys1mq1teU1Y8gRovCxuVKS2Ts5VVayylokjhxFu3R0FDzZQ4mj+XTKfpzi3jMoZfzZo9JphvKUtj7W+KDYcqC9J3aoSO/LxAllIjlUGTii92jEYo4y4E/nT9ov+S0JY12USTdeun7nyf2HeZoJZI3G7HxQNxZ8L5DMCcMwTzNCjLXinFerlUF3kOjUDYO5Ewtnn79YPzUb1CKVZX7oOb6TG81trkiHlQpkrNfrBY7b6/U6rZYKAmO053mJyXyH5dqgIWDIXVmZndna3tYmbxTh7ABh4AWBn2WZMSYIvHav6/t+cWjLpCaMotbOTnvQmQ39wA+as/XuYKsZBtxaxnGgc69SQQN5pvJUfe6VzyVJtrq8MjMzk6ZpfbYOHNY3N3u9Xr1aReRmYKUBxwm5sNzhFkglfd8PHCGrLFp7vOq47isvf+bunXsSmc5yrfMHH93xpRxkaQ72/JWLi4uLSRY/eHjn0tUrK8vrYVjb2dw+e+JUM6r+5Ic/2Fzfmj92rJOl7aynmEkT/oWvfK5WqwWPam+88cbm7bsvvvzS4+WVlZWVS+eeC6T/J//q3wZukBJde/GaAGmNRS5UngiHI4wocC/H1Z4IHaFHkUsFj8TTx5Bq9yuVfT1Ty5RlJO3CM3y8Y4dOaCJx0zNhzDIcuXzLVySO2aJTXT6jW0/HrHzEKVWmNlUoNsNVGEa6F1vWexuYB+m6+9qkvYvPdp8wKJLfGtS95NadBx/dvCMs1P2qptyTjid8qynwPSTkrpemKQJnjEsJKss6nQ5aIoaG00AlvUG/2Wz2Br1KpaJVHkVR2/MEiED6WmuTq9najFHGm3G4K5eWnywuLhpmtdZcC0aktDHGdPtKCFFr1HSeM4aIIqpULJFRFiwaQ51OL1OKMQEA66sb881ZnWbcE3Nzc4R2+enSwmwzy2LBMfDDfjywyNbWNipu4AghUXR3OsDYydOnOAES9bpdRXr+2BwJ6PX7Vy5cvv3urWMLCzozm+vr1ZnIkM6Ucnw3zTNjTC2odAbxW2+9ba0NHFcQIhdScKvNpfPn6/ON+lzTEgUznmLnotnaAmf9dvzSZ18ZtDo3PngfiBqzTYPU08mx50594bUvGGYHed8grK6vzc3N4Y799l9+K6hGJ06cOnXipEpSzwsuXb5mGEQzNSKSQmitpesRqQlk28O3Eezh0gEYMobnY9g7aqT801QpMtq2LM5+FcXESCceq78bLQUjUbhbYPq+LcDe7nD5J8aZMZpzSUTGEBfy6dOnJ06cKGQmEtDesRlLRAz3tnCHq1P0aBEBh0RFhEMlBIf3ghdVJnyze7frIiIwVlzNAmAZGABgBAQMgdmhZWyH4fCsaIyIGANrLSAnIo5ARBxJkwEgxpgxVgjH5sAMbq9utlY3nt59IIg3w/pgEFsNrhe5jkQEB5BbUCrPrWGuJDCZtlUv0HESeEGSxY7vVY/NXbx26eYHNxxPnjxzantjMx+kg07Xd3yw2G53PMddmGmm8SB0fMNACTx9/pwnnSQdOI7jCd7vdzmXXHKdZP12P/D9XGeSVcjYza2duWML3W5PcuFIWalW1jbWwZArnTPHT+o8dx2hjDW57sWDZq0aD3q1WlVrnWSpcCQpdXLumM2tSjPGoN/qaKC070Z+AKmqVcPU5HG7e2J2tied/s7OfKPeae10+4Mg9Bgja20QebEahF6YxxlZ1Cb/xje+8c7P3+5ttCphRSDXSnXi7vP1F1WSUq6ZwwbdftWp8AQ3l1YXFxc5g62NtdWny4JzIV10xBe/8iXhOmQss/bOex8wxu7eefB3/+7fXt9c/eDDD1o7mwtzDeAEQs6dPLm0tjrTnLl26hpBkSgQCS3C+NZoQVOGhnEnRDTEq+FxiX0epj083x+LXyaokfAcKpdERAaRlwT1XnhDWSaNkBl7g+5UKv24euBBakChZxuz12Vxfm/IBfZ1si+n5qRZOzkkRNx/g+hhyQF3JR4AgGFgEMoXHzFLiGiH4pQNzWgyiGjIMsYQOAKQ0YhIYAgtIlpNNjMBD1YeLv38xz8PHa/iOL7vD1LVa3VrQd0a02g04rgfBl6WpcDI9T1FQAylG+y0tiLHRyCdp7FRzTMnLj1/Ne313n3v7ebcbNwfRK5vUq21VbkxxrrSIaXQUhRVg2q02e8oo6JKZWdnC4xliHW/0uv1EmOk66ABwRDACiHI2CCoxEmqrNm9ZcwgInBmcsWJMUAmuEFQYDnnorjJzlji8OjxUrVaDcPIKO0yIRiz1mZGk4NZlrnctUpbtIp0c2H+2ovXttbWnzx6nCX5wsJCdbbx3nvvOVISmTPPnecCa5Xae+9edxxndXWtVquBRddyj0siAg4ZKG2NRUIOjUYjz/PQD4hwc3M9mqk352aXnzx1Lc+yLFGKec7Fl55fWVuJ/OCjj24P8vjEqZOO9F75zEuDtK9N2pht/vhHb/h+pddNHj94QkTnnzvzpa98gUkOoJGzXGeSizI9lHBxfIPjEEdJmUoPEptj5ffvJj4Dyf/KqLQ8gvKwdlP77oUpBkGQpmmhfJY12F2SPVJWsanjJJyyHDD1rjkAPHh+wyENRbhmjFnDOHCtLWNMMA4AwNAY5YBIWt0H797cWd1yHE840vFkUI1OnDr3zltv605WcX0ZeINBr9mciZNBVI/yPDe5kVIqA8DIdV2b55CqdrcjIu/spQt5nt+791GjXldZHhAPvLDb7Rsg4twA+Y6bZZnr+gaGMUzW2iQZaGt8KeteyATfSgfIuQ/SKF2J/DxJGWNJkgrXQeDWWgagshQBOGdJlgZhJckzLoSyxnE8YwwYKyUna421qcqJKAwjq7SK88D38zz1KqECm+q0uMMbADiT/SypVCpqMOCca7Rf+eVfJMlXVtY+unErkK6y9tKlSw/uPsjTzFoLYHWaBZ5PuXUYEpEhS5wRQy6F1poZYoy5jsMBtdbckQOVFvZRnucakDlyp9tGwa3Sl69dfu/WB4nOg0o4uzA76LWuXLl84vSpx48f3/3wXrXaaG21hOS1mcqLL12L6hGBAkRkRPsDOPcwih1GApMCaUzdnUqi+xucLo2m9vUxzpeOkd8hjZa/cs6VUo7jFcKzONoysgbHNPhDGp86mcmHZc5nS/64kcFpYHgsu/hvodB+Si6+kUpDo9uJUQIHixy5ZA4jiON0fWu922o3KtXHt+/yRM3PzHHOY5URZ89/5mVNMH/i2P21W/VKKCV3fIe7InKjTCttct/1jLI6y/1K6DgyU4oLEYUV8sSj+w8cx1lozud5Plef3VnbABtL1+FEKVnOeTcZVKvVPFW+44aeb4xBgVblgRPkaZKpPOmlWjJXym6vX/XDfn+QpqnrututTqNed10mGMvzXBkdeD4Cua6bacVdxyo9GAy0ttWwMkj6YIlxSJKEcy49z+QKCYoDg57ngbWCM7BkAYTjMEvIBGpuAZjjktVCSiJUmZZckLHdpDcz01xf2xSO00/688cWOMNmpbq+trK6vBKGYZpnSmvfDxkXnu8NtrYrMvC41JkGBoJLm2uhSbjSIIDre1Ksrq436/XeoIvCuf/R3aoXNryGZTBXn/2lL32l1+/8xZ/8WVSpcSt1rJN+ElXD9k4rSZJaIzI0VG7HRNSezIADvY9H8dnu2VwHbNtYOx11p5b/JHeuHeT+fSaNISLnXGsthCjf47IrVKd7p57BbMq3DA93vXYdcbCbbgiHDHPoaENAW7IicHhEFQrtF3BoBCMCY5LIKpPl2mWOj05rbSsd5LdvfcgAdnZ2Phz0L51/TlT8JNeRcADAq4QguSC2sLDQqa+6XGZxwhjoLDdgcqMBySiNFknptD9QWWqtjvzAEvbzvDE3O+h0mbau46faiGpkAIQjkShkLE3TSrXiuk5vu+Vy1ktjxlFKyQXzA0+bzEhsd/v16hyBRQ6DPPYdN6zV4zTZancCN1h+snL89AkvCrc2O8pirRKlg0Fxii3wfCHE09U1q3QYeKSNMaC1zrIs4IwRK4x8x3FynUsprVFIgEQCmclVN+5sp33uu550wNg6i372gx8bTasrK6EfVOs1MnZjaz1Hc/bS2dn5uXo1kmTvLn/04lc+s3Di+PLaam2m/pMfv/Frv/bLOlFv/ODHCLzX73vSIcR23A18z5EiSxLwnSzPfe5XPFdqE3KnlyWAtsIdSk1uqfVo85GW/X6/weqYCYdcNdBZL0MA5EZKxxgiRCFkplKOQ8ycVD4Pw7qDoeykHUPj/V0c5u8ck14HUumkmB7zTY9Zz1NHBgDWWsdxjNk7q31I0pdJKn2mPjBdnNLeGvD9O1xlBceOlOSxjWYiIiruLENkzDJfcMjt3du3Hj94EgQVTqC1DhzvzMJxneVBtZZCqq1hUsRxTGSs1p3tLccRnda2G4UqVylHTVqGvlKZMtoTkiFwAE/wXJO2VvjuXBT140EYhlk/RukopfxqJctzLiUAdNo7nHNAyHVmwSKCZeT6fq/Xq0TBIB34tUhrnZHpDbrVSq3ZmFl+uuI4jtbKWHv52iVHs1o9AsHjdDB3bJ4LYbJck+30e2matlS70WicOHU8y7KCbgVjWmuDkCRJFNXyPEeiNOlVKpUkS1zX9R0XivOunDdqde67/TxVWW6NiVGisQ8+vOdLx2/IXCb9fj9F7c+Eq+tPT104laMixjCQjVMLsc1nz5wgoueuXe5ngzAIj50+vrO0JgNXEVhruedYjoWlgFzkqLMkrQQhM2SMcRxne3sz5A7nXBJgkj/96L4xhhF3PMdY0sZeOHMuZ2qQdR1HEhkDhgMDzsjsRcOXUf0TW3yjFsaQs0xQRHTQcbSp8DGKTg6i/HXkw5pacjToIhiFjJ0cN5SilEZwlMHY0T5UMf9SfnpOlpNlBKM/YYFbALCE1rKhIC0GzxGLDPfFOMlaspYZrgfZn/2b/3D/xu0HNz+SRFE9GtislfbCRqRURlql/YHR2gqWkxnEPdS2t93aWd8UgtcadaVyYOhXQum5gyy1gF4YKGOCim9JW208wQmMtZqMEkAmyRzGQZs8y0gba0w26KPRSIbIaK2BCy8IM2OMpW4cZww6Kteu7GSpdeTp88/VZpoOlzrJZ6MaI0CkwHVUlvaTvkWbmdRxuUpiFQ+sUa1uR3N0okpQr4NgVjDuyU7c01pxzqrVSErph4FFEIGXMWNdoZjhnjRGC86syqWUKAURBcBO15vHKvWAS0JY39jyuesz6TqO57hz1ZmQCRdgvtFQaeq6bi+Jue97QQWQp4MkkN7xuUUOfGNt89GjR7k1KVmoBH2wIgjavV5mrQYgQx46DkowMMjyzNgkyQZxvtnppblyGeM6CxAjIV2EtNvlAJUg8D3B0QahIyQgB84xNzmwfTbkntWzHw+PSBRTC2MJyjdi717pMK5R7t4CsQ+eofGW9fWj6ABjEy7+F96O0UH4Ed8aEXZ5bqMd2iOqHCNJCLAXHDLGe1hp6ezuDjYNdz6HhdEikQUCzhjg8Ng2Z9Jq+2d/+hc/+9Ebr/43nyGGluE777392c9//vmrV7vbrUcfPQBhmOucOnVyY2uLkTi3cPatN99MB0ncHQgQrnA32zvRTD2oVzZXO8Awt0ZbE6cJcJZmMXCQ3MnBKm2tSo02jiGVanKdIjHF1tbGbLOZJgPgwDhkqV5eejLXaK6vrXNXhrWqAdrZ2a7N1D3Pi/PMlQ4Q9Lu9Wb9mbJ4aVeROFUIwRxiBaZYn3bgShFmee55XrVa4kELIrJf0kjTRSRzHF86cS5KEgyUAKxghMM6MMchZarK40w8rfhQEmVGWgVGpMcZFrrqx7aWDPGWAZPJeu1XzAouQpCkTmMcJcssYKGt6vd79pUcPHz4Kw/D+w4f3Pro76CfNmRnX8Sth+Pjho9DzTaIyZdJBvxcPst4gdB3hOpzz/mDgOJ5Shqz1gjDLMk+Zc6fOap0zBsKTVlGapYjcdYJ+q50R9bfT+kJ9J24fPz3nh6G2ChAYE9bsCwPch8YTnsipqD5Z5nBKGdH/6MFYU1PpXBQenUILxd2kLKN8JUUSE0QskoNprQFY6YzLHu/ZPf+5JyRxGPGkpZRWGwAgIDZNa9/9jFBk8ToyEBFZKvZ0yw3avVFhkRZ0NCSCoTwXiNYA4tBmVanK83R9bW12tlGbqSIicpZbi4wfP3f2b5049faN6y984eXFxcXkW98+tTDfX9v47ne+c/GFF1762heIIRk7f3bhT/7VvwY0q+trly9e3nbbFjBPs8cbq1+6cO70tUvRmUUpRNLt/+v/7z9fnJu/9OLzpxsX0v5gY3vDq0dE9u69+yeaxyTx02dO/vStt6v1WnW2zjnnCNV6dWl9Oe6loROeOr7Y2tgipd65ef3UhfNnnjv36tVXHz9Zmjs25/reB++8JzISuQka87dv32qcnEty9cJLL95//ChOu5fOX3n+xOLS0ydPV1daW506h9XVlZpbYTlEYbXZmJldvPjd17+3ur5y4fmr7aTvR5UKd2yuMNM33n1/fn7Bqjxq1hRof7HGGIs7g16r14iqnZXNtJeAhq32juc5ruBfeuHFM597wSB0V7c++uDDR4+efv4rr65D++ypY9WZBgbu7LGFRw8f/vEf/REYK6WzEQTNuYXADeI4zpP82OwcI9ZpdT2DkR8kg771gzSLZT1sd3u9bl8Amg3V2d45f+bsoNXZ6XWuvvw8SGj181Y3bjabqVLKE0vrK70k7j/4MDPJP/mN/0O3lwShh0RgGCPG2Hh+5hL5HAaHuHkPeQL790XL1tjopHSBwiXS5Xs3UBTpM4tMpKOHRYZSKiU43B8zNOqAilrlO1LL0vKZo6fdmI9nL89YOwXBlyqNgopMwVmsYXz30P1uMmIE1Mq6XFhNpPTdu3e73Z4f+hpofkFy6RqdARFHBoy9+sUvCGU556lRHJnN1E9/+EZ7bfOzn/9cON9USBotMT3oD2ITO5H3pa//Alk8c+2SJvjjP/zjOB184UuvZYxqsw3K9Y+//8NHT5a+8eu/dvHFaxrIYXiGLimkj+7dvfbSiy9cuHT3nZs/evPHjbn5oBJduHp5c3P93bd+7gbOiedOf+bSZV+4f/nv//zswvHv/eC7FHj/4L/8B6nKuRAnTh8zCIrsuUvn7719Y315/cGdu6sb6//kb/8f33r/3e/88LthNfylX//Var3a7/eXdzaWN9eef/55jzu+G9z9+QfHavOdrXZna2dl5cnayioy5vrei1cuWATX9fs7bZ6oH3znu9vb214tmDk5+7kvfjFVWZ7np8+fy/vp+z/5uRd4d6/fsXGWxYnK03o1YkAvff1LH969/f/5f/2PV89dnJubW1vbiC7PzszPciYbjQYwmmnUXnnxhevvvHv61NnZ2VngXKXq3s2P4nZfAPvpG2/Wourp06ejarWX9vxa5aVrlzZa28tvv9uKO5HrqyT+8Y9fv3nzg6hW/YN/9I+ufPZ5w40B8/Dhw0ql6gfRn/7pnzszlceP7/3g9e//7/7b/61hMFOp5CoVghFZKaW1+dHx7a8Exghn6tfRhyHRwW5Q7+jS7lEQXyE/R4lwi68AUGQzKcvugsizLBtdSrXXt6UixfshWn5Zr/64cx7dlTZsAcECWSDmSMvQMmSOTPNsGBLIkHNpLShLwAVZZIre/f5P3v/eT+69c/PG2+9fff5adbYxMDq3JEBwQ0xbpwgEseSh01rZ3Hi6hhrOnj3f6faXHi6hJcGRCXSr7m//nf/FuWsXa4vz7lwdAhd88Td///cun79w8513OArK7fLSk42V1VdefEkbk3NrXZYzpgAVkhP4Zy+eNwKDudoXfumrj9aWF8+fCmdnasfmvFp04YWr1z73iqj5xhe/+jd/U7v467/3N/6r/+Yf3336cKe33Rm0lMoALPfE4tkTr/3Ca4bZp1urv/jNX7r+8O7c2eOzi3MnT5/yAj83mgTMH5ubadaXV1e2Oq23brzbPHH8+u1bq6urp06duvL8tU6vq5SK/CAIfMk4aXP3zkf3Hzw4dnyxm/Urc40XPv8y9yRyqM9UtdVBNfrcL7zGQ2/u+Hxnp5W3e3XpXzh//uZ71//w//nfv/ftH2Kqzp49G/f6jiMuXbxilNUqA7RKZ9IVzIHPf/Gzc/MzfuByzhhQe2Nr68nK7Xfej6T38OHDu08fBqea3/z7v/f8F19Cj7fj7suffynJBhtba7NzM8+/eA1CKeaix73NHmUxpOCzM1fOBfMV7ekfX/+JvxD+43/yX//77/yH3/07v8dcZlFxTojEEXSeHY6Qf32A+wFKiveEbLOiLBvLOdQAQAhRCNhCkO6mGoIiVUy5YkHSI/W43Nokt4ADNIGPZaZDmc3sj1so3MRKqWLMiFjk/ilqaa0ZY4JJneSC+J/80b/tb7V832/3+s1mQzCR55pzIR1pMyW40NaipjzNVtc3KLcPbn907dylM8dP/uzNtwZ5Gs3VpYE8NSQscSTJFRhrLTE0aJFACvalL3zxRz/4YYrw3OVL7/34p4Fw+v3u7Y/uJD5cfv6a7qWt7Z3Z+bmP3r8RL25fvXQ5qlXf+PFPZufnHz9Zmj91PAyjK1evtns7hkFujRDc5qaXJzON+uz8XBOx1++8/867geMuLC7mjM6eOs1q9W/++m+sr6y/8NlXVgc7H9653W/1Vp88bcw1z144i8w9dfrEmTNniGE6SDfXNtcfbx07fTrb6T9dW+dV58qly9vbrbUnyzNz8wxxe3P9o1sf/v2/9bd/8J++G0bR7/2t3025iVXi+I619P3XX/e4+8q1l06cOoXdvL241n684jpOs9mcn5tLNzrMc/7Gr/76V3/rt/8f/93/WVZk2ukFDkNHaGYNx1xryaRkyARTWe5Id3Oz9fDO3d/5jd+qB/WfvvHG81euJszMNZpPnz7dWdugXG9sbLS2dxyLaZp7wv393//9f/etv/yz7347sdYN3Vdf+6xSCgVyh1sH/95/9Q//6F/+8aPVpV/+5V/+F//9P/+//J/+Owvw6OHD06dPO47zSXdb/sqgbDOOmZDlMkJlQ4MzTQdJknAUjDGl1MrKypkzZ4QQxlhARMb48NgbMhj+DYNnqTixxQ3jHBkCUukK0Km9HjTiT8TDpt/VbQwVm/5Ga8/xVJpxROBMW+KcY6I37j9+fPvB47sPOeev/cJXnrt85Sdvv9la2/YjX7hScxCuYwA4F4NB8sf/4o/u3fjwK595tRqEC7Mzg3b/G1/75Vxl/8M//afHZ2df+41fSiDX1jIhM2UYQ86YVbq9shkSf/zRPRtnW4+e+pb5mvXaveMnF2cW5y+cf04YtrPR+un3Xp+rVRerla2PHv18bcurVKSUrut968/+XMV5JQpI5YnNJQhlLRhqt3tb3UEYzWw/3Xj04MHj5adzzdm1J08eXr/DhdM69bQWVAXhnXdubi+t52BOnD1pqd8bqEcf3l2cmxWBp3TOXQDDfN9HgvrMzIPbD+Zrc0/WV4XPTy+eam20fvajN2/cuvPS5z5T8YPuZuuH3/3BTLXGQ6fdbgdzNQZMa40Wv/Dqa//v/+F/XPrw4YwTsF7mh0F06blaJVrf3mnWmxvdp3kvef27PwiDyt/8nd/+s+/85f/0T//Zqecv/c7v/y4QcM5yo3zXzwZJIIS0sPFo9Q//2R++9pnPt3a6G093Ir/29Na9xuzMB//pTSfy00Eceq7bzudsUPF4O2Xf/Yvv3j5+WzLxlWuvDjr5v/in/3zlwaOvfeMXZ441iFnhCM7Z3/tH/6t/+Yf/6t/823/X7vbu3Pno6pXLFy5cQaQitxufhoyIh0SmPQOm4vARXaEHVcR+v1+cNM2yLM/zSqVSiMEbN25cuXLF94e+2UIEFZK2EFAjk3WUz7qQpQB7afYZY4VbuYgtPmS4RHQQvR20Crt+XQsAQGx0zKUAjsJaazPlOo7NFEeWDAZb7ZZBdvfu3boMlu48OD577Ec/fP3v/MHfO3761GZ7Z21jXZOuzVR3uq0XX37Ri/zt7daju4/ufnj352/+9Ld+5RuXTpzZXt9A5E8eP63Vav1+v73Tmj95DEL51V/7ulsPcrAgUVvjcre1tvEXf/KnX/3sFwerO5urm5VqzRjTbXfOPHememJh/tyJXtoP/MqDm/fUIME0S5PB4unjwJE8p9cdUKxu3rixvL5x9erV48ePzR2fnz1z7NGTpTzVD+8/On3iZNKLV+48QIDZ48eMUXmnP+j1Xddtzs1rsutPV4WF+ebs4uLivccPXv3Sa92kxwPeSwZ9k6xur7/65df8MHJQrjxeufnWjY0nG9zy1tb25XOnLl94Tmu9sbm5HfdWNtYuXbg4U6t3NrbuP3rYp/x/87//r03ASZDLGeX2o5v3637NxtnPvv/jY9WmtIjEjFVo6cTCse7W1kf37rFasL69pbM80dl/+d/+42hhdqCTO/fvXbh0MYoiq82t6x+889O3Xrj24ls//fnXvvKLoRPcuH5z6cHD3/j6r2wvrTCBmY/cd86ePfvk/v0A5JNHjxNrXvrMZy2wf/Ev/uXZ4ydzpV/9+lc22tsPlj6q1MOXX/vMcy9eyhnFOkfpMnSyJOUEoSs4Q05Wqcz1PWPU6J7bMfw8yumoSXIaI1Hcvwd7EDJPrVv+ac/HW1wIV3wVQly+fNnzPK01ABTHUketFLru6DB7Ial343VprFi5y/LXT8Bdyo2Mu87BEA23YLDghESoTCC8tDNYWXoC2va73Xa3yxxZlV4+yGZmZrgQl689//7Nm/efPmnOzhY+sMFgEDguI3h45+7K0zWm5en5kzPfqNfnms5M9PK5UyuPl/tJv1Kf+ewvvHbr/Q84YL/Xe/3ffvvEc2cXnjteX2xywSDJl+8/unz6XGdrJ6xHycqqp7UvHPKDIk5ASvnk+n2VmyiaufngwVc+/7mlpUdP1lePnzyexvGJhWMfvPnO1fOXN3c6GRkeehnaza3tzk771rvvv/z8yy7A2XPn89UtpdQrr7wURdHt6zckw8bC3OPllZlqJKphs1Jde7rKatHy9s7p1s6DB/dr9TBWSTRXO3v6XOD5OlfoOcaYqFHvdeLWyuZMFD2682Cx2nAcRxL/+pe++p9+8P3uZnuw1aFMvXj56p3lR++9/d4LX/6M67vZoH/vg9vv/+jnx+dOXLxwBYAx4XW7feaIK9eu3Ll54/27t179/Ofubj3pxIPnrly6+9HDhebC7Ilj4EBnI9l8+PjNP/328WOLv/qrv/7iyQvv/OBNlzlf+dKXr9/8oNmcrc/VPHG+Pltd2V5ByY1kC2dOJKBeePXlzsrWB3dv/cKvfuPs5UsoxCtLD57c/Ghh7hgi1GrRpXMXZcAjP/Ckk1H8cOnhjdt3f+1Xf/36+9cvnD0XLSxwzkBrxxHGKM5xZCx9YnE3FcZaO0rjh+iS2Ov1CglZTiM2ctUWYhZKR2nGHLkjK3T3nsJJ0i2cTOMK9ySh7m7m7vK20o/Dw58HU+nwBAMxhCKYAbhlrY0tm6rbH9xsVGsCGRhrEXKw1VoNLBqlMmW2tnbm5ufbvW6eq8UTi8YoL/Bzk2udqyx1pdvbjImosTi3vrkWCOFLoVM96PZASsd1kRgzYOLUGAOeiCk///z5U+dPS+6+8f0f+tLN4gwRjbI20bWwIoElRoVn5k8/d+a9n/3cd9zMQK/bDx2HgXZDb31rs16vM4NVdHvdQVslA6usgPnFY4HnmDRHZchYLsX66lrNCVOVbw+6tZkZiUypzPF8x/N2uu1KpSqRu8J58vhpvV63VqssrVSC6ky1MldbOLEIEhmXRpkfv/6Ta5df2FndvvX2dR+F0PpYs+lK7+6jB8dOniCOUrhLS0sCYfbY/Fpna+H8qZe++ApzmMP57XevJ1udrJ8HldrTxys1L9LatAa906dPmXQQ+O7K2oqxttmcPffcxbWNzfkTC9pRDx7dr1drva321pN1Xzq1egM4E4GfWeV6fpalSZI4jPsooijqJHEO1iD04l7oup6QWbvnuu5Kr9M4tnDx4uU7733ABlqlmYgC4buSoV/xzz9/IaZ0QLkInDd//s6pk2fSQfreu+82a9Xf/d3fdlxWJOY3pBnwMXSi3Wj7Z9LVPkKahti4m5PkEBVyggr2eVKH9NUbdOFQ0UxEZS10H8Gw8bntsz8JiKg4MF2cGpvMG1TO1rc7aJ7nuXQci1CE2jiuAGPBUpFoHAAsIREhZwCgreXSKfZjwYDDhdAwaHXe/slbDjBUJnBcB7lSSgohPdcyzI0mbfI8l0HwdG21Wq81Gg2jbOi5GinJMsdzEWzS7krkjASTAhw2SOKaH6bxoFlvImKicy5EkmdgQGc5WrIMc50ZZl94+aWkP7h582Zjdn52dn57Zc0onWQZAwyZiFVWXWxWZ+uryyuu4wjudFtdz5VSSubyJ0+ezNUboXQh0YioHMYCr530OecOMWYJjA2rESGsbWwgYqvTFr57bHExzzLO+cb6ltV6ceFYMkgatXqSJIM0kVK4QjquaLfbXhAoUkyKmZmZIAg8z1teWs6StF6dQWNXHi11N3YWZmd1phBxbm5OA61v73hRuLWzzThPdJ7p7PipkwT25Rdf+vCD62dPn3n66LFAxxdet90m5ErbNE1BpSeOH9totX/00zdmF+YvX77seQGTgoTVWuk086TDNWilpOMYIG0pzRPXDz1HIIEgDBwXERMwlqHre4PBoFGJkl5fEOZGt/OUuXK2Ob/y8PGpuWNPnz5d295szM1K6XYHfQ3k+g5Zra1+vPy0OTeXZMZaq3X69/7hH7CwyNRHo2OPo/97EoVNirXDLLK/QlFceB+HBGVJcoH9uDf6eUxLLqnL41Q6fP7xqbQ8pZKI3auCyAlBG8MYM2CEEMYq0saVjtYWqbjWaRi4X8h5AAAD1lpBjAO+8cOfJJ2eS6Lmh0zb2Uaz1+kQUaVS2Wq33IpnrS0OQ3UGsUZijqzX60l/UG82Bkns+j4h9Lu9+dpMFicCWaaV4ZipHJSRQrhM9Pt9N/ANWQ3EGIt7MQC4ga+UchyxsLCQxcn9R49Tq+dm59HYXqebkwk9XxgbBaEVENar6+urURQh8jROfN93XXdrZ1PnaqE5m3R60vKoVlUCM7QZGclF1h5ILtI8Ea6jreFSxnlqgDqdTrVW41w6QmZZZrWO/IrDReHlRsGTJK5VoiiKVlZWmBRCiDiOK5XKzs6W74eB61ljtNaukAxQKFvgZ7fb9f0gSVOvEmkkZc1me4cQB4NBnqZnTp12BHNdF4AcIXVuBWEQBEmSOE5w785Hc41as9lk0nm0/GSjtVmt1aKo1osHlWrou87O1hYZ26g3C6eGMlopJYRwHGd5eXmhMetILhlP8gylk6rcomUAAhgY6zDe6fc0g0q9lg5Sz3Up10opw2BpZbleb7heAIBRWCGlrNXM5QRsMEi7/T4XcOnFi1dfvZpBJrlAREP77vYGgCG2/2eiUgaojLY4xHAiQm2HsnSyy9GO6NjIpmYeGZXcp5Tu5okBOPAw59C3NKpiSWvrOI4tLnIUQ0MXh3EXJLnggGSAAyKASXNJaLVRSt/64Abnstfpdnc6oR80anVmKQor/X6/kMNa60q92ktiKWXaH4Alx3MNUXvQm5ltepUo0bnre9rabrc7Ozvb3tpWWSqE6PY7lWrUT2JQxuUiYg5nzPND4KzT6SCisiaIKtpQp9OpRqFk3FpYWV+rNmZSnfteMEgTa63HZYjcZHmtFiVJgoJzKbI8Z4w5juM4DhGlg5hy7TDOLCHnikMOFiRP46QZ1bTW3TTmUhQug+KasFarlabp/Nwx3/eL9K1aGyI6ceJEp9PJ0yyOYwYQRVGSJEUCpCzLfN8nsloX15Cg67pxHNtM1f2AESRJaoCUNcYY1/WzLJO+lxqVWp1lmYMciKIwCFxPCp5rlSnrCimRGWV1bt788U8uXDx79uzZXNuVlRUhWG51tdG0DIXDjVXJIO33+2EYVqvVPM+11lrZWlTNsqzba9ejapFPxFrLXNlut/3QK9I1VSuRyvJid01rneaKiGq1WpbnvTTu9vu5Nr4XZlne63aOzTYdR/SSuOJXbG4Cz0/TWFbEL/7OLzuRO4h7QgizLzlOKePR/qQ5z4SPS6VTnalIQAY45wYp33UJ4diZmFHNj7sjckj5MfrcU3Gn1RjtbRqthRDKaCGE1poBB2186VGurTYuF9127+njpaTTGbQ6eZw4jrO9vT3bnG82GtGsJxireEGapkopIoqqUaZyRaaXxMQwyTMC4Jx5jjtI4tDze72eYow4OojW2jiOW61Wq9vJ8zyI3PkzJy9cumitXVtZXXn4WFtCojhL4zgWyBzXdTx38fjxldX146dO6jTrd7qDwUClWdzrK7Du7rktB7kHGGujspwThF6Q5pnnuv3BQCmVZxkoE/pBbpRgmCRJrdlIk4EFa5VyGDe5Ukbv7OwEldBaS8ZyzkPH8+cW4jgmY1efPD179mySJJ7jxnG8sbbe6/UqfoVZjKIoT3MGXGU6iiIEzgA0gbVWMN7t9aMQGHAmKMuVFBw4E4xZDUopyYXm2uZKMJSEcZLxIIyq1Yrv5VmmUiMcqRkFlWrc7QjGXcGyJC1ozGUCtd3Z3LScZpvzmcnzRPm+y4OwEoQCWZ7mJs+tMVEYWa2jMCRjGOAom0caJ67rcmSudLjHCzbEGCNtTK4EoeP7vV5PeK7v+1vtlusFYRRorV3XzYwmA2FU2dnYqbkVQuVz2e/2OEE8GDApkHPYZzf+te+fPtONyhHBWoK9C2Os0lPsUpiQpUR7oQ4HuqEmj+oQMEBmEQAM2mKnZHhYjIDjMCYJAUpRCcwasEBcCiIii4goGbeZYZa2VjdAmzzOV58ud1pdRJTIfM5dIa21wnW0sr7vC8ayJHWl40rZ7XaRc+5KQyQDzyJ0Oh3XcXzXI20kF7lWxEU/HiiyudFamyAMa7Vaq9NGwZdXl+vNai/p/fpv/aaUkjR8+P4H3bVNYSjwQo5MMk5ErW5ndn4ut2Ss5ZyrPG9Ete3t7c3NTRl4s8ePdQb90PfzOK1IVxKqLAeAoBJqssBZu932PI8RCE1Wad9xgQiR4jzzozBRuRAiyzKOTLpORoZJobVWaeZ5nspzwZ3iohciiuM4DMP1zc3CHJiZmQGLKjeIaIHCaqi1Xl1f6/R6z1+9CgB5npOxAlkSx2mccKCoUlEqV0qHns9RIKLre1s7O57ntdvtZq1ugYTjGAZZlmmdc0DGWJaZarUqJUcNy09W33/3vZdevnrh/HmdmU6rtbG94ftuY36RCQSGW62twPUQESyGYWgtFFv0WZ4nSTJ3bCHpDwrNQgjRT/oguUWQQrjAdZ5LyYGzQZxGUbS+vl6v13MyuVKMidwahdTtdmuVWuj5whWOJ3faLZMZXzGmrcrTBJIrX3n51LXzGk2qlbN7TKXA8z38H348qkQ9oiydJJ8xIxGJGWMsAyYEEaKxYnRPzBGF5yfaQRnmFhqdxhn5n3CvQUZoi5xgXApQmhQxAqOVw4RJ8+5O66c/ftPhwpee1UYIp1mrW00A4DKW5UkYhlmWITIyRildCUIGkOc5cg6CMSE0me6gb4AaMzPtdrtgEDuddnNulgDCMCSifhIzT6RaWSDpuXEcB54vGJubm7tz9+7c3NxsrdnpdR3PhVzHSWJyFUWR53lzjSYpQ8YSWS6cTm/gAPOl89yZs914IIHNRNUsy2ZmZjDXW+sbi/MLOldxHCuyTuhLz+11ur50arWZpNtHAGOtIa2UwjQlgM6gE0WRlDLTquCyrpCGKdd1rbVcCE5W2+EVbK1WKworRTy2tTY32nFFfzDQZCtYQQ6O45w5ewoYSwY9x/FylUsvzCWbW5iP435OVvguOFIDCmTGmE6vp7XWeT7faDJAa22316vNNtY21oMg8AOv0+lVwurq+mazOdNptdr93pnnzikysc4RkDnS8dxM5YPBoN6o5Tqbm5vTWhORZFJpDRaLPDXC85v1mX488FyXcZ5l2SBNROjl1nApADDpJQ7jeZoJIYpbDAPPb7VabuBrrQLfBc5u37515erVvJ9qkQO33Z0uCi6EkMCtzhq1+sP1jopzoyw5jEsBZvyY2KdA9U8LRfYCJjghGGPQIkcmQRyo8U4OcZeSp9vQ+xzHu2HztqDFXRUfCfhuXQbcAgGQpWGohwFkADpVkePlce5L98ndxybJVh4/1Vl+3K/nec5JouMSYZ4q0BRUQz8KWOZmeY5MgDZIwDjXWhenwxzP86JQGa1zW6/XkyTxOSfH1WQtw+binHSd9k5LMomWAkeCdHJFPZ2FlRCMjXw/zQfNRvPclSsA8M7P3uLIMq0YQRiEPMBut6u0jVwfjPV9N8uyuN1dbMyBNmmSaAIg6rdbzJVetbLV3nJJNJpNZQ1x9Jif9XsPHz0+ceJEpRLVg0qv3fWENNYaay0yLwgVaUN27thCr9dDZIY0IGcEBkG4TpylwpFpljPOlNaEMLsw39ra5si11ojY7/e9wFcmr85UsyxDpLjbXWg2tFaocmYtGu0Ibkm3WjsDL/E8L85SphljrNfpHl84bhH/f7z9Z5dl15keCG5vjrs+XPpMJLwhSNCVJUsldcm02qz53GvNz5vVLS1ppJamJHUXVSSLRdCCIJAw6TMjw1x7/PZ7PpwEmIQhi9Ks2Z8ibtx7wt3n7He/72Oii5LzYFw+y1abNcQoydLlejWejnyMy81WSlmbPp9NTHDj+QJEXNc1LRKDAQLAUZRPxnVdMik8BJ6gpqsxJRFBDYHMuO5NWW0kpgnjpmsZggDAvu91cIGgbbWhWQKsTQnjnICIJObOWE6Rt44QMh1PhjkcItiofjabOWsRRdpZEy1htDM6ZQnjYrXZhuCi8zEEHEEAIEDwNCXhk9z2z72l/3+M1c8XrZ/FEQwRo+iB955jxhCxjSbPvvjZrvRnLvqZMc7nf58v+2UCGnq8AAAAP+mcBQA+TR+MEcYIQMQkAhiib8z7dz58dO+ha/tCJCRCirCQGQBAMM6E7LX2IeRJihAKEBhjEEJ5nuMAnNKM0BhjXdcueC5lZ7XvIcJYpElnNUCwadte9VJKozWWvO5qUWR93RRpao3XTxNmvVJq0OjmaXZh74ABFCGYj6enj08KmS7PznlGTQiMsTRN621JIOIhiESCAEzXgxD7vhcksUonidhsdkyIXKY4IghRr5RgHESw3W4JIU3T7BWTrm4E51ZpjBGiBIQQAaCUWqsjBEwKhIHtXZFn26rknJdlSTnz3oOIpJQhxiH/h1JqrWvbNs/zvb29vu+E4E3TYEabtgYYheCHTgyEUHXdsK0NztqtVh7ECAGhRBbZtmuKJLUgCIQJY3VdI4Q8ALrvOWV5njddN5vNlFIEkLIshWQuAIARoPjhk2PMWS4yLkVtFOKUJ9wjYEP0DCNOvfeb3Q4jlHFpop9l42AcIdiFgFBEFCFPAAUU8eg8iPHJ6fLCdMFk0nU9hbgpK0yJSJK275xzSZ6Z4LdVCREqq4pgzDnFmHgQIYTa69YFlksEYpJn7/z0l/uXDpOjSbAOfDpueIYC8P//XfTT5UGEISBCh8apd05Q9gVpTp+H3LNnzk8+frqjPgvsEMJT+QsAA1VQW4MoGlx/GCYoImONEIl3LkAUQsQYgwAIgMjH5fGJqtoHH3zstBGEJ/P9IdaGZ1lZ1kIICOG6qaSUEhNCUPQhGEsDNcZ4hEIYhEjBWmucFUJgjHmkWmmeSGW0C8EFHwhmRaqbljOm28YSsO2byXw2mu85Yx49PBaMdlqdb5f7kxkGCALw8M6D17KJDb4625hdJwSYJaNtWY/H4+1uXWSFyDLgvNaGUjaQohkhaZ7leQZDlIylc7HZVgGCEIIQgiep6pUgHCBIKV2enU+oJBHqrieEIEqttSF4ZTSkCHLS6i5CwAA1xpRNqa3qVJ+mqbVWa53KhDPSdU4rhYcxNoLzvXnXdX3fgRj7po0+VNtdb814PNbAIY6dj1IIAMDQpcAQOW0YwgkXLgbGuQ9BKXO+WaeEARBSyiFGMQBKqbEqTTKKyY0rVz94/0PJ+HpbR++ioFyK2x98lKbpaDTyxkYaXIiI0+B11beQwijIN771bYLxv/k3/wbYyCmrnROUGeghBQYFGyyBAGJAEIoQ0N4xSoH2WTrWqgMwAOtEXmRQDkQawhmiZFPuPEE2WswFQmhbbq8fXNVat30TAMIAhuhh9NZ7TMhcjk8eHL+wN+WIAhDi0/fsb09NwaC7HPw4n3pNw2eSU34Hkr+MevBlD/42ESJCCGL0EMXgPYA0xvhbKcO/u8f7CRT9ZxD76VchhPgT8uDA++WU6WC894xS730EkHBmnEMIaWtBRBwi77zp+g9/9evV6SolLMEi35tzzndliQgbTybLzRoJJorMW5cilGcZArBv6ugBhpAAGADEEBHJ+75Px2NsbTYelWUZQNDBuRgIiJTQrmnKukoyKSiRkpng89k4nU8CxXsXDpGPMQTt3cnDJ3kicQCZTLJUnp+fIwR+8H9/rygKDqnEVCDiY0ilrNvm4sWLfdt1TXuw2NvUTXA+guiciwAghLSzCCGlFMRokhU6OEhwgIAQEjHxxo7T/GSzHBeF0yYCSCnFjCqtGWNROYoJpBgymo2Lpu9AACGE7XZ76dKlEEDTtfP5vO97BKDWGkIohEhkst1u9/b2uq4TjCOEjNZSSoRJrTqMSacV8U4IQTCq6xoDJDlHCIMYqrJmgk9G47pt6qpKkiSVWd/30AdnncfQO0sJqauKc+qsrTe7zdmSQBScP5jPyrbTwLWmMyA8f+Vy15cQRu89YjgbZ5Dj1dkKC/LCc6+mRe6cu3b9+nq56evGe48kNs5GH2CIQojh7gwxggAczhZGaR9Nq5WNTlCSpGnVdDkTACNtjVIKEYwZzYscEKStFwkfTS+vNpvxeNztdpzLLM8BQH1ZQ4icMhST4/sPr7/2vCyk8vqLMQaf+fhzJIIvROazlKM/aEry7DUJRC4GONwjEIzBB4j+YA/Bp27xT38TDyCEEEMIY4ggRhcdhJAgHGJwxvoYKMUBoBAAoVxrizFCGAcf2k29N51VZ5t7H909fvhobzK7MN3v2y7GCBHZ7qo8zbuu02UDreeM7s0XZV21daWtMkoTEBMqrDHGmCRJmqYZvm+1243nk0hQMisiBOVKJUU2Korz07PD+UIQCjmOKDiEbtx8sZhNTLTaOxcdRhAAuDjaDxCcPT4lBFmjllUpKCvLsu56CghFeJRm3noEMWMwIHi+WY+L0YQya8zeYh6chxAKwUvdIUoa3WOKexVwhNFZRHCte0ppQXDXtgIxFsGkKPq+59nEO+dD2JS7PM9DCN45BCElBGBiraWU9rsqS9LLly9XVdU0TYQQQ0AxolxQzoY2aUSwKIqqqkCIUghrbUSo6nuRpKPxRBmXpCLGWO/KaTHCVHAuY/RN08lU8CRVVvXLZZalk6wQQmw2G0apHE1OTk7aaisxxS4kQkbvh7qJENyoDmOKAc6yDECjo/cMv/Lm622z+/jW+wHEbVW+ePM11NQGAO+H/5g5Ozv7+O6db3/jm0eHh794++eb0/N0JAjG7a42LnApur6nnNZdW6IqzTOUEp5mbe0b1ZvgXbS6t4IwxhhCIAwj064fi9QlqNGtUYogKDkf5XlTd3eX96/euJpO8uN7Dw6m02htVdVN00gKIPvNjPRTsP2Ovszv3kL/+0tlCACOMcAwbOM+Roq+3I/38/eDz3wKf3sBMGS2hk9kqDHGCCNwxkOMAIDOeAQg9BCB6Do7ZvK9t39x74M7qZTPXbjadV3XdYyzEEKnFca47/tUyk4pQRnm7OTkpNeqbes8zyUnwIe6bwhEQiZVUydJEmPEGBWj6XKz9DBWXTvdW0zns77vT09PLxweNbvSaUMx61z/3Csv0SLtgWWSm12rrQI2SiEiAAdHB5vlStU95YwLEbUdZbkPgFPmlA4YeO8DgpCgN954g0nx0a0PXKuAcwljg380hDTJs+GA17QtJFgKrtsWekwYIYz1bTefTsv1tm3bzqo33/raw4/uzufzD29/PBqPISUoPDXH0FpzTkMA2ulharJZrSlnWZZpa+u6jhAoY9M8V1ojAIZIYoyxsXo4fCpjiJCbzYZy7pw7O18RDNuqLmQu+FOqAELI2eBi8N6nSeKMJYw1TWOU8t6vdmWSJLumoRIzzgKI1lkEICUEQzQfT7z33kZBsIqwa000drNez6cFxjhGP5lMPvjgg1Z1F/YurFfnZ8dPTo4f1XU9z0eqaRMqX7j5/PcfP3HBRwCTIh9mSOmo6FTHExkAhJT01kCERqPR8fFxkmcE4brvSU5ICGmattZ2qndaQ2NabSxwe4fzKoRqtyOYjIoCRvTo0aPRaEQTcbrZZIwhRo13CcG/7WPy2Xf7ZwaQ/5CN9FmA/C44fiHoBpVIBBjAMCR0R4AQ+mLuEfjts+izPtzRu2d/aITQcDq11mKMB77R8Id2xsQYESQ2eCklw8RoTSIGxv3i73+6fXImCEUAT6fTzmgbPaSMc84h7KuGMYYQKrcVE5xw5kFEFGlrCGeU0mCNs1YIAUM0ysIIMMZ12wghIEaIEAih9S4tcmOM7vqqaqbjSbDOg+ic8SiM9ucvf+U1i4PxDhOIAPTaUExggL/8+Ttd00kpVav2x7Pdk2XKBORUKaVaRREOECCMldHf/tM/SYr80b37pw8eSUJ038cYmRDKWyCoTFPoQVvVdddShMcijTFaBpIsdZ3CAXjr+r4vZrOqqjihVHDrnI/Ba+eUzjBt2zabjhWwyXRkrVVNLRiXqbDWam07pdq+I5wNA9627RFCVpvoPYYIRUAQbZpGCNn23dATNtYywXebrRBiPp7oXkEfCCHGuBAC5xyg2NYN58x633RdhEAIEX3IksRaq5QyzhmlEsxmozEEMfrACTXGYsSVtywTmNFHdx+HGI+eO+r7HjnAGHPAAQz7zmAYMUaMseA8Y2y73TLGZZo0XaeMRpQwzoczgo+BEeq9T6Q8OTlxMYzygrgwyovb9+9RSvf29kzXFzIlnG3b2kSfi8xp4wFUpm9Vk4+yrBjVVZMluXWhM13VlDHAtmlyIXTUf/bPv3t45QL6HL1meG8H8Kwf0G9MzP4h59JPn/A7St8vBnYEOAYAQEA4gOgCIADygH8XQ/CZB57RoP02SodpJwDgqdzUP3V7sNZG72FEKCDOWNf22836vV+++4/+/Dv/4d/+u2lWzEbjuqzmk3ndtZ3RL7768q5p01SiEFen50mSOG0YpdaF+/fvWxDe+sbXOqWyIu/7HiGglRJCbLfbYjRRXZ+mKUHoRz/60XQ6vXHjhjEGETIajaSUf/f3PxqPp977xWLx5MmT55673mn14b07r3/tjfHB/GxzPp2OvXUM4dXZ+Sgf920XItJKGe26bbl8dMoJzafjpmlSlgTrIIRN2wIAkiy9fP3aBx++P06yjEulVFVVxWTcG51Ox1prpywAoOs6hgnUTggROQk4MoibtsqyLMuyJ49PYoAsldY5wtnjx49fun6zXm0FxiGEgGAgKJvkTdearoUQehjSNEWIVG2DMQYQCiGMs3laaK37vvfWpWm62WxQROPxWCsFIAwQaG8RowNJkCAMfSAIZ0J2dbPblUmSAIQAAIxTQkhV1iEELkXTNNNi1Led9Q4gFCHgnCMXSISCM931nLG+7TKZe+9ZwrW2D24/DATNr++frM6OpgeMYib4+fnZdl2maZokQgoOQ1RK/cU/+au3f/jDqm0iho3qMWdt32GMsyxjhDrnjNbBuul0OoQjIx8JIbuqFGnCILZaE4Caru2c4YmMLu7NF97HGH1vahusSIu26RhijDEXLGG0ajvOebXdXLh66Wvf/YaKmqHf2i0/fdv/XpT+Xqz+bpR+8UviU710gEPCICaAAPVFKcO/50Kfm9YMy1s3bK0xRhACI8QD7LVBFpAYWB82946r4+WTjx9M0tGrr77205/+tCgKx/GLz7/2/vvvr86XVVXd2W4ne1OEULtuMiF3qyWnYjEa9Vp99Kv3hJRNmtRtI6XcrNZc0PFsero8V1pfFhRDOp+MOca2brq+M96tz06zYjRQWDqljHN7R4cf3b/vgd+bzW/96tfP+RdG08IZKzmHxpebbcYSDOGDBw8pwtcuXhWLo0kxartOppnH8HD/EBr38KN7KeWQobqpdsvzrqwLmTocRgczmFDVdXmRdl3XNA2n4tGjR8/ffOHex7ejcd/+o29ZGO/cv/O1r7/18d2PxahgQnZGv/nmmwbBe48eBkom+4uz9erSweHm9IwQ0hmFI8EYT6fTB+UOIDg7WtRtW6SJa521HgE4TJ44oc65LMs2u62BgWQSANACgxOitLbBAwIfPLp79erVrCj6rpvkU6f0arMhCCeToteqadpXXnnl+OTk8uFRpHi3XKdclOvNQPGFGDvnZJoYYyCIrXPZbBQYxgSN89TUuq7agkBnnDEqH88sjGySb3SbYQk6ixPx3GRx+uREpolzjlGac/GDv/mvjLFRNnIxZEmutBaCCCFA9OOkOD85HaWZiopob/veRA8LkU+K/YPJ2ekpjMgEz/MkWuWUSyHKRqnWWsgUQIx43nS1TNMIUc5So5TVfZpmBtu6rG7fvvvCqy9F7zH6rfbns3y7z7SL4GcdOv9B6w99fgARARRj9AACAHGAQyAg+bIj729XvL/5AH3BqRrEGBFGIETvPQaYEuqNffDh3fd/9S7u4zjLYQQU4ct7h81mtz+ZnZ+eXb582UOwa+ru44+YEL1Wkov06EIf9CBDhxFIIXAAlAnvHE+kjQEAkCRJCGE0GXPKgou67yFGu12FIyiSAvpQbkohRAQAItSW9TjJjNIEoeVymWSpsibLMtMrgdhH77wns4Ql/Orly33VPLnz8OzeCaZUpnlj1Pu/vnX54qXTk3PjLFhvCSH3798HzsMQUi6sMxkVXdMOjbROKe3dB+/fmo7HuldcJJOsUNYtFgtGyGw2256vHj18zDN5uHf44x//+OqNq0+W5wkXaSrPzs4iZycnJyb4Is9nIq2aWgU3y0ftRldNLfsUGkwpTbL04OAg6drZaKy6TvAEAViV5ZXLl5VSlPLz83MukxhglhUPHz68fPly37ec8ysHB+9/+AGBSHe92NtHETw5Pp6NJ0KINE03u1KmCSK4qqph0Prw7j1KaZZl3rprV67+/Kc/+x//p3/5f3/ve6vVqiiKxf7e1atXnbEyEXfv3pUEE4YBAHXTPH78hAr+2ldfjzlbN9X5o2NrLaNUEN41Nee0Lqt8VJTb3SjL67JKkmQ+nz98/Gj/4lFVVUWWZzKpNuv3fvqLr371q6PJ+O7duygE27Qquv/xf/7njiIfQrRue7IEIR4cHJyenj733HN5moUQYoTvvPfrGzduTEdz6935+fne3n61q4Pzxrv5/t75arNbbc6OT0ZJDk3UVqVpElEcEvQGORuIMMaIEQ0hhCFAEz3l6oQQEMG/A4HPbp5/aDPp00obQDCIskMIAQCCECzbBgCAwG+4B8/qXcIzUrunBXyA4BNR+MBYGIzqI0QwAuQhBaTalu+8/dN+09AIcyYQgAFEzrkQIjjPOe9UDylxMKaT0XKzTngCI7C9SpLEOeOtQyEyiDkmRmkXfECQJKKxClIis3SoOryxXhuC8EDHdcanTMAhOQIhQojue4qJMhoK1mkls1Q5SyXXWtMIgbOEEGeezjAQwBECEyJhtOp6QgiGOFiHIDDGeGMjgiLh1a5MyJC7gJQ12XzSW+Oc45K1bbtarS4dXeCEGmUjBAYEkSY4AOB8NC5JkkhQo/oIvHUOJ4JQBI3Lsuz05Jzl6aPNKuGigDwTMhBUNnVf10IIR+J0OjVNwwjtteKJxDFEACAjfd/nIoMQUplstyUCqK5rjCgAQCklhNCmH2VZ27ZN0/TWijzNsswbq+s+EZJyZpwjjKuuT7lgjHSqDSFQTPq2XSwWXdNeOjh69913bzx/896D+3k+Ojs/v3D1cl1WCeMwAufcbDw6Oz5lhHIpbAxXnrs+mo17bx8+eDASiVMmOt/UNYSwrKrO9N/4xjcYxLfe/bXutRDixvMvbNr64PLFW7dutWX10nPPP7pzb71ev/LG65Th1emp7rsYI+VicrSfjIuqbrbbrestJWS4JqV0UPwwKc4367LeXbp4EWPsvLfWb7cloTQZpQTjqHy53gTrZnszMU7Pt+u3vv3W4YU9i72H1gOPMY4uwkgQwAihCIP3NkaPMUYAxxgBgp+GJn7GHenZVlP8cpvbz8DyM5u2CwBhgGOIPkSACMDEwj8YpTEOvmQxhAAIQAiBECGEPgIcMVT+/PGTD371gcSUAUIDkIyGEBDGTxNZQkyS5OzsLJ+OISUWRuVtnuSbzYYEwAilCKuuhzFiiDhGhBDtXWuUyFJIMSBYWVOW5ZWLl1Sn6105y3MQI0QkhAAdAACY6Aln3ug8zXTbWWv5OG9Vb7zzMUBKGGOcsmhdtIYChBHSXY8pN84q5yMEXCZlWRbFuNptDvb2yrIkGAspt80OYywxhS5EG4QQrdWIUaUUY4wQYo2BwROEYYCY0YChsTaGkHBhO0UwDghGgnrdjcbj3mgYohSsrZtem3w22SkVnMsR75o2mY17pXTTJGm6M83Vq1fPHj0aJdngL+Wt5omMGGFKTKtDAISJ1XpDEEUAEESHOr/v29Z0GONcJCcnJ/uHR8oYAEBZloLQpukYY5QxG7w39nBx4K2RCccYamucc3FI5bAheE8E7/s+y4rNbpsXRVmWs9HMGSMYpQMl0zmAUMAwK9JO9SGE4DyJkGAMfBiGSRFBaw2EcdCFckTrroWEJpMRTWXV1KpuGSYMYiFEoKhpqkwIZzTDbJgzIcZ6rTAlBFFrrTM2ydKu7xFCnEvt9Nl6JRPOGBOU6d4YZ3maAYKNs6lMbNV6bVAAyujACRV8tTv7x//sn0yPRhbaSKK2hhEBLBzYxQDFENwgFkdP6a2fZIVB+Bku/h+K0i9EbAAIwICcgxBAjGFEWH/5JCZ8wfWHLhEY1EOEYeudcw5D4n1AiADnf/a3fxdatZC5cw4RHHzoneeUmhCsd5wyRuhuV8k08y5apyOCAQQMUZ5muu5NbyJGgrEYI+fce19rLSSTBGFCMCEIob6r53K0O11jAFPKzfAzAAcACC4igrV3eSqtjeflhsQopYyfkH7W241ASVmWaZ4NYkXV9kAbzgUACODIELbeEQBzmbiuG8us2mwF5xDCpq7xJ9WO8lbmiUPQO1CX5d5iYYwBzqMIKBPOOSYYhggam2IKKKqaOsuy3WY7G0/qvmNF0lk9H43rza7bVYSzhPMky3yEna7bpppMpwFCwRmDeQQgy7K2bV0MteoGamRajHutXfDOBUa5MQb4IIWIAUKIYYiEkKqqqq5OJpmPvoMOpWw8n3DGYIhVVex2Ow/BZDLZbrec04BhXZeCUxg5xpQTSmJo+iY4n3Ju1VND4+h8QjkMMUvTgIBxDlor8kJ7b73njEIfYqexspIxB8DABMScGe+sNkIIQhmEkOfcBY8IJZ5RLtu2FSCenJwURYFTYawz0TgVTAjWaYKh8oYQzDlf7cpiPPLeOwDTrFgvV8vz9WgyRpSclyWluCgKhBDHRNXdOBu74B1BreoRAEGZ4D3FBEEPEw4Svmkq0+vNcjVZFBEDiABBBIYYPwkIhwAABEGEEYD4jFbmC+H3+WPtFz7hC+H26QufZp8gOOQUoQgool9q2PfF3wYC6x2RPMaotSaEUExQiAwQUzbv/v3PfdNP0sIbixDKR0XEsHfm3pPH6biggvsYXAiE0QHnQoi2bevNrtxs6+1umK9mSSKESJJEWxshJIya4AMEyujlctnWjeQCRZAnaSoTiklXN04b59zQk4wIeu9b1ZvoHQIg5ZXXFkbEqRCCYkIxToS01iZ51ql+01SNUYBQ85SRg+eTKQgR+QiNs73C8Km0KUkShjAB0DlHOTPBN0ZRzgY8OG2GZ9rgtbMxxsH6wBuLI5hPZ5RSkcjeaEiwEOJsuVwvV4xQAMBwQaVUXzezYowxHigNwAcYYtd12phtXQUIhJRaawBAp5QxJmgLA2zb9qMPb7dthwEONhCIfAinZ2cQwizLeq08iCGEb37t6xyh8wePzh48FgBf2D+4ceVyIhhBAITAOc9GWdO26+2m67qBe0AIyYocUyLSBCF0uH9Q7cpUJoyxgfMwjGfOzs4ghAHEISh1db5klDprCSHGmFp1Zdd0fc+lUEoF5wf7m77v277DjNZ1zTnXSk2yIuOyLqttuduWpXMuQhA8IIT32voAJos9mSbnq5UJvtVdazpAcZpnGOOuVVmWMcaKtGAIM4Q3y1W53UYfvLFSiKeCVYSIpAeXLzoQlVKC4Nlo9vj+IwLxEHSAwRDpAAGKAXgfXQAgIhg+cWP/Mrz83vV5Pvxn2lGflr6fkA3AwMGKEHxpxRvRb7pH6BM/lAiBjQ6iiAPCED3Vv1noO/Wj//pD2+m98RQhZACY7+2tVqu2bSWT3se9vb3VakURLtKsrxrOed21xlmRpZzzvu+buh7nRfTDLPc3IRlN1xaTsfXOee+9LybjYF3wPhFSd723jkJAGA0AKW8hItbaREoAoUVee6NgoJx5bShAQTkKEKGoaprpdG6C77UZFMamVRkTwPkhQrfvO4owJ1RbgwQLCBJGy+2uEAJDaIJvjTLWE86apoEhzvIRhDBAEGJ88xtv3f/4Tr/eccq0sYQQ6EOAwKEIKCaEIIyrvjXGFEIE67TWxWQMMBrMB3bbbSoT59yQXKS73iHgcv7k/Gw/HwtICIjee0Bx0zRjnllrlfMf37v34gsve+NRiN7HZbVjnOeCQwx2XXV4dPDK1efe/cnPo7YIhFRmg0FEJGjv4lE2Hf/9T39qrc2StOtUjDGTmfcWQugJcs4ViVRdxynDAUjKvPeWYKV1VVWScWJD9AFSnE/G2ukYI0U4hNCqHkIIKXbOSSkxRF6ZvutgiIyxRMgYY4QIYhxjbPsuT7OBUdy2LeI4QgAINr2RjAfreCIjBNoqwtiurb/5rW/97//q/zg6OJQ8sb3KZGKtl1JSOnjKeBSic26IkDbRF9PJw7PHz7/wAoTw0cP7e7P5dr3hEDujA6DravUX//S7e5cWGlgHPCHMew8A8iEAGABC8GlXCeHPulr/HvXps1vdZ8iG4HNb6/CpCwBGD0FACEGEogfUkD84GREjNIgMQwAwAuxgeXL+8+//OMH8wsEhl2lnLGGsrCtvbcI4AAgzqpTSWqdp2nWd8a7v+xjj/v7+eDTabbcgxr29PTCIj5zd7LbDTjvK86ODw4SL4HwIQWapMhoy4kC0wQOKA4gyTUIIymhldAARC5ZmmTZ919QRAhf8ttwlSVIURSqT8WgUfZjkBQoxZwJYD0IEEPkYqq7p+p5AFLTNhEykNM5iQqqu9Qisd9vRZEwQQgAihLIsG4/HGGPgA4YIY5wkCYTQe392dpbnOYZou1q74AmjWutBqNm27XCep5RmMhmCN4uiaNvWGlOVpep7ECLwgRDCE0kpFZQNd/chZMB7TwgZlAx5nnddByMy2t68ftMbzyh1xiulKKWMMYhQXdcJF1975fV3//6n3IQEwCRiVzfch4JJEdH54yf3bt95/vmb+bgIIBbjnEvRqn5UFARjEEKWJIQQwtjAoBgI7lYbznlRFOPphCUyn4wo51VVMcZs9JVVCgZHYDIdlXUNMe66jjE2WEzNLxzyNBlqh8GIQ1uTpmlwTlUNjTATUiKScSkx7ZtaIpLKRFujvUGEdKrDANy+87EH4cLVS3/xT//R86+90Jse4RCCa9saRoAhijFKKZMsFXkqk0RbNV8seqdMtG9+8y2DY+tUZxUkkEAkmXzn5+/AiDAkg40zAACgCFEcaHThE4T5P2QY85lq9PMjzGcfGbbPpwRmCBEkCEA4yMgQ+l0w/fwPhAKA3hNCtPdMUN+Zj965tb7/hAKSzYuybQjjgDHCuG66jHAAACDcxaC6fuiVY4wR5ygCgpi3rtxsAACUUmMMHvpMnC4O9hkmuu1M1+d5LgRPmTDRC8bLrjk+OTlYHNS9AjG2bd3YbpQXaVYQYwAm1rled4Mop23aum/3ZvNuuU3GE6d0ZxxHpGs6xkTfdrN8ZEHout64EGPMpOyUlpRh57uucyhAQvLpeMjI6fueR0QgAoQ8fPSISrGYz+eTqaBsINmV653xbvPzXy4mMwkw4Xyw3oIQuhgoZdrYaJyLQUWX57nzoWk6AMB4PLbA+RA4p6kUfd3EANo+GmNyxGJwfan2xtNqXeZSFokcbnkIIcY5Ajh6D13AjGplKeOb7S5fTEIIu7oKzl6aHL379s+oDchFhiDG2IAAI+h228gI5qTv2qYRXIpls7TBW+PHo3HT9hRT4gJ0oWkaTAmmtFFdRkXXtc5Hxhij1BjjYMQECSrLVVPgUYRwVe24FAECYvW1G9e3y1U6GgMAivGoU6rUyge/XZZFkmprhRCAYqu0lNxCAIIDMSCIVN8DBMZZ7r31AVgKJnuzw8X8V79858b1y4+fHM8X4/H+2EA3PpzDu3chxDhhKNKzx6fT0ZQnrG4aSInMM8zgk9PHUsrv/uPvrLabfJwjjm++/PyDO3ePHz2UBmRJulyu+qaToyyC4EKgDFvvfgOkOCiiwacY/W9g/33Zqz6thD+pHxHAEAUQYwg+DEXrP3Qv/bRaJoRZ66P3/a45vvOwXu1ynnIqmqZL88K4ACH01kXngY3YQa/UwCKSlAXrYATAh6ZpBpcQIUSRZkPGjDamVyp8spIkmUwmEMLHDx9Zra9dvIwBvLh/eGH/QCslOAcAFJOpyHKZZ9bauqoG6XPf95TSLElykRxN5izAicxMp7IkRQQ7GDGjCCEYYvDeG6eMO12d91bff/JYRWeC772LFIvJGCWiM9oEn2ZZ13XWu0hQ27aXLl2SQkTnvTK66WAELob9o8OqqgYPAUQwRGgo4RAlPgSEsZSSANi3XVEUEYAYY3CeU9Z1Xdu2AIDBqAkTMpyuGWOt6rXWHOCozGwydc5Z6xMhYIzBBgAQpjRPC8mTYANB6Hy9UtY0ZfXizecuXryY5/m8GLfrHQNIIIIsQC7gCKEPnDIKEA4ARyAxvfPBRxmXhBDKmbLGGAMh5Iy1TTPkccUYuZSMMQDAdDxBERCEMca9Vuvtpu7a0WjkvZdS3rh+nREqKNtttuV2NxmNCcJG6bZtBxuqofQQQkjOrbVWaRC9t45zboP3IXgEAAKcMkpJ1bVP1ueEk3SczY8OOtMdnzx2zhAEvDNlvcvG2dGVC0dXLjhnx3kBELTA1U0jpHTObbarVbne1uWTs5Pbdz+u2gpQmIzSYpa/9NrLYpRgRhHBjLG7d+8H772LQxcdAABhJOgpPv/QmvO/DcbgGa/5p/UwRt57NGQSP/3CMyEOT8EdUQwQfEIABAgaAh1EEvHl/Sebx2fYQxARpTwGqBsFlcMOBu05odEHBAAKseAcWYtjgN45o4xVmEAII4QRgOCcgTBSTpTpI/DIx4Hj2imlrdmWu/39fU7Zk4fHattsH5/HxkxFDk1gkFCEMURlWfetih5E5zkmIQAQo2q6lHIBcIqo7QxFtOna3tudUsXeou56hAjBFCAEKbYxEMFFItd1ownwkrYoOAQQYzSVjVHKGkiwAxESPBqPjdICEWxDhhmKgFJmrEMEM8GdsRjApu+aru3bTnU9hJAJzqRI8sxqkwpZ1bUNfjBGGXzJR3nRd533sen6xiqaSm8dxSRAlCQZ9CEj3HaKQmSMsdYKJrVSCKGmaXqlIIReW2dcr5VytmvaH3z/+wih567fOLn7gHmIAwQ+EIRQRCgiGFEIwPsYTGAW6k39tRdfWx6femUE4+fn5wONzBgzWJB2Xee9t9Zut1urtNKdcyaEACPglA1V0sDOpRHCzsxkljiYAUJsMG2v2i46H3pDI8wIlwBTiPq2C85C74DWCWGC0L7vdHRtNAq4zpleq14rx3GxN6/L6kff/8Hf/O1/PdmsHq7PaCYpRKassffO2MWFw2vPPzfPR2//4IcBhqRIEUU+WGeU9269Xr308gv/2//zf1vt1h89uP3DH/+w7utdtROS/fG3vqW9QYy64H/y9s8gQBgS5xzG9NMSFMY4FMMIwE9zj37v+kxn6PfyluAnSeEIABhiBAAR7CFyPiKCf0+Pd3gZGKgLIWJMg/ZBufd++s764UlOk4RKF6Lytmqauu2yLDPKWGMgxBHDuu8E47pXwTirTde0AwXi4Ohos9n4GBBCACOMMWWMJxJAyCljhMAYQwjKmAhhWVeI4KczeqW8sW3TWKURgDBCFJHXJlgXjeOE1mUFQ/Q2pCLtm5ZjAgEIITR9R6WIGIks2TV1RNDGYL1DCOle5VnW1PVkPgME6RgtjDRNyrrqlHLOIQAIowhjQLF2ttE95YxzPliTDTBDAKquP9jbn8/ns9mMEJJlGcaYURoB6I0e5mzWu8HeIcsyQdmgX0EIlWVJECaERAACwk3Xdl1HCBmNRtY5SVkuk1GaCSpymRilAQB5nhulvXVMCutdCEFKOZnNsiJPkkQy+e677/7d939AMaOYhBAIoc65p6KIIXYAQBxB9MFro9vuxo0bvTYhBMl4jBET2CsFIKScJUlSZJmkLEvTwQZt0D+tt5shPj3JMxdDQEAZDSEkCE9H4/lkCgn2IMosxYwKIRIugnXe+6ZpMEWDDS+EUKm+0Z2O3qCoUEwWkz/5x39x6caVKKhDAAtmrMtk9q1vfevl11/9F//r//qVb3wTMXr37r2TkzNKadu2Xavaurl04dLRYv/5mzdns1mn+8Xh/j/5q388nY4xRYST19987eLFo29/+9vOWe/9hx9+oLWWudw2u2I8btv2/v2HEMJnc+vRJ8yFz6PuHwjXL1vxt9ezoBuWDwF8otH/0nnp0+GP94QQb10MkXNpO+W27a9/+kvmAY1YVw2mPMuyt3/1Dkr4YrEwwXPOBaMhhFKpw719VVUEYYyJC0FKGUBMkvxseS4SOR6Pd7sNwgiAoE1vjJGCRxMxRBaAobjqtcrzUaM0oPjx+elivje0UoQQ3sfgLKMEAKq1GmWFUzYXqVa9oFR1vVEWY00Fz+cTE3znXKc0AjDLMpyI4IO2RggxkmmzKxElw9l4U+6ujS51XYciEphtVmunjYZwNBq1XV9DIIpsudnMeLo3nnaggd73fQ8hDDYIzsuuOjk5EYQObUxjbQihdybWmAkuR7n1HiFab3fcBedMCD6AmInUBR8BQpQEEHutRZLGCEEEkichBEaFNa23brveUEq1Mc5a2xlMWa+Vd5EEqPt+yOPCPhCEqvMWUaK9JRDZYIALkjHvvYsBICgY75WChMToXQSQ0fH+4sHyvO97CILgtOu6ZJSnWaJ7BTECISrVS0QYY54gB2IAkXGOBOus7bsyQiCltNrMBXPGIkaqXgUQEUIguEhQXVdJkmzL3WQ2syQ+Xp4BALJECiiavgEY9cFByf7pv/wXPoTIScwFzpPm/Lyz2js3n88RIi88/4q2Mc/TbLH/0YcfiuX2zr//a4ap63UKCSZYVc17P/0FxNBYm8zGMOGj+XS32w0TeAaQadpJMeKELrLRerU6un755Gc/27twMGlmy+Xy4rVLSinC8MANfGrJFSKAAMCnn/33ry8E+QBRHwGGEMSn9kMIoejil+6lv0l88WE4v6IIOGKm6UOvvQ2UUg+RMnpblVmeJkmiVZ9KSTHCEGmtL1++3PTd0xBUALquwxj7GAOIkGCeyCdnp4wx3fXDd8mSJM/zGGOn+r7vt9utj0GkiYvBQ+Ah4GmivDXRE8mVNQECCHGIwFrLE1k29dCtiQBqa5jgA7G7qirrXN02AABrLYao3uy899pZ6/1qtcIRHMwWmZC75VpQJhlv6yZYB33w2kzz0WwyLbL89PTUeGeda5oGAND23ZOTEwei8Q5CSCnN06yta0GZtXbIxRoMOAGCzvttuTPGuBg8iEZrTqi3dtCLEULW6zWllBBCCDs/X3VdBxDBmHZNq/oeQlhVVdd1QoiiKGKMwfvZbFYURV5kSSIYJ5zTGCOhOIQwyvMsy77y2usvvPBSb03AkFLKOddaU84CiBGAtm0JIT4ExrmHIBuP3v/gw2I0qcuyKAoAIZViV+/ON2tEcIRwcOh2zkUECaPWu6EkiTFaayezKUKIJzIfFURwniXrpoKMIEoQJb1WQwMcYhQQdDAGguQ4WxzuQY4hx4ARWqR8lP3FX/0TzJkOLmK065r7xw+4lHVdJ0ly9+PbXtmUiuP7D+/fuU8pNzZ8eOvDcrXdnm9QQPlkykWCKeGcT6dTZc2T0+O278pyW5aldTr6MEqyv/ve31bnm8f3HiilfQjFNPsf/vk/vnLt8qUrl2/fvTM0An+zuQ0ONfEpij4NUvq9FewXIvBZiH6GqPQsdAdjewTgwNULzn+pvnRI0iAIW2sZ4cCH4L0kQlfd2ePTj299RDEZTcZd0zJMVN9rZfcWM+oRBKFTPeVcCNE1TfBg8NeJMSJGd1VJJKWMKaUoIcMshDDqwdM8C6sNDHGYJax3W4xxiFBbgygZjcdt24UQjLK66xmlGOM0TxBC3gbdKwhhkohGdYzRNJUYId10zrmIsAfxwfHxhQsXdNvN5/Pz1UpKuVwuJeejvBiKwPF0UnWti6HIx+vlcpLmxhieJmVZck7X283ZajlfLCZ50dYNjNFbl6cFhLBpmslksluu9/b2AAyPHz8+3Nv33jNCrXeN6h+dPkmydD6fj2RivFPBFGnm604wXrbNdD7bVjUhJC9GDx49jDFm48IBMJ1MVo+ezEcT5TTASFllrR3JPFhnjOKca2dDhBYE1faJSLtet85leZ5TfnJy0pneWku8f/HylcwAbAOlJELQ2I5LiSJyzjkAHEUHz11/7+7HjTHr9XpeFLPZpNcKMSrTxCiNQ9BdjxBKkoQhqrXW1ilnIwTj8Vh1fd/3IbjZYj5Y+DvvhxCaO7dvd3Vz88ZzVmsQIghQW6Vg6Eyf5zkjGEPECOm1hhh860//2Mbw3q33X3z5JU4Z5/xv/uZvvI+q0zDE9ckZsH5vvjdbzHdNzQQHGHkfy9VGMO6N55yPx2MXnTZ93/enpydXr1713oosabzqjJ5Pp3/0rW+3ZbVenv/kJz8LwF+4ceObf/Kt3WY9m8yasvn5z39eVdU3vv2NvQt7AMWnyRQOxPiJdQOKAMVhTAOfrt8D1M/0kD4D7M/XuhHBCBAEAQeA4EBBgsSS36VcG+5/BOHoPARAUPbBe7fq1Tbhadv3AIDx3hwQjBHGEO1NJwmmPjjvA5cSAKC6jjGmemNjiM4DjIJWDsTxeNI0FWbUGSsIBSFG6zDGlNJtU2FCMKNl06QIDLQShKnW2ga/Xq04E9aYNM3mk+l2s4kAIMZPT584FxIhm7Ia+VE2yu49uL+3txiPcuUtFxxBAhC8enRxeb7MRRKtn+RF07VD/MFqsz44OKh2ZQgBMSql2K7XQ+tVa133HYQQIVBkedN3kjISAAnAOCcSCTB69PjxZDzGlIg8Nc5Ga6ajsYtBpkl03lrvCbx28znvPcdkuOtJKYcb82DkFyBI0rTv+3K789oCgtbrDZXi6PCQEYoQkkmya2vtHSE4xmi14UxACJIsNdYWTHaMQ0wgp7BVfd3wAqd5HtrIOWc4AkZ6oyWBAEUfAk5law3GFHGMCHXOtKpvmoaLpEjkbDZzzhjvBGLr3XaSFe16k6fZeDHTWvdNp6wOAIlEDnXK/nSOImCclNsdpTSRQjtrtNZK5XmeCrnb7SRlSikIcT7KdF+LJOGpODg4SKTkBH/84UcQIx8DpRRj/KtfvuO9d8Y2XZvn+VffenO32SaMBuMoJAiCcZaty5JyhhBZLBa5THab7dAnjyimeX71xvWDw8OT0ydJkngQ82L8T7/7p7/+1bt//dd/feXwws3rNz6UH5joKaURIpGKCH1apHmeG2Pu3r27d2HPWosIBAABBIEP4GmoX4wgwj/Q/z5+CSvw87sxhBBACOEnd4JPHsT4S1TgYGDVI+StY4R64xGEKIJ//6/+3zMxGhcT600+HlnnTNdHbTkiQ2uHYdJpVYxGNnirdIwwz0dnp+dpmtrgrXc6WMpYb3SRpCkT9XaXi8QaEwEIEChvPY6QEkpp3/cwxjzNoovOWG898AFj3DTNZDLrtKrqNh9lTd8RRquuDSGorqcYLxaz3uiiyL33ZVlOJhNKmcC03dYCYoRQpxRLJaJkW20HOwIAgOTCGEMp3W63g3dBno+890kiBqrd4MrJMAlKxRACwh7EyIi11rU9RogSrtvm8v5+XdfZdGxjsErb4IGgDx4/urjYy7lkAIUYd7bFGPtWUYwhJdrZ6WzRNg2P+ORsCTNRda3k/Mblq06btq0jx/cePzy6eJgw4WvFETHGdKrPJjmhtG/atlPJfNo0XRLparWaHB2WVSUQyYsUccgQsusKWg9ijDA4gpBkEMLpZA4j7Pv+/v2HSqmDwwuIwEgQFbRpaogR5Ux1ve91KiQV3IfQNC3AiFAOAPDawAgYIwCAwUYHAMAYgxgNLd/dbochKsvywoULAIDlci0Svq12cpxiyf/sL77rrU6YaNbb//3/+H/N9/ZuvvwiT+RyuVyerYYh3Jtf+ypjrCzL7//Xv4URRBswgJTS89Vmsb8HAEQABm1TygVjzoZW9QDB2f48gNhZtasrRNHBpQsiTQAAXVk35+ugrTPWYdDDcP2Fm3uHhTO2K/vtaqN7s9mt/+n/8s8JwxEGABAIMHgQQgAoBhgAijA+HZUM9+7fveBvWyj9jv7Tp9T8gW2PA4jAA4hxxNzRL91L0SfemUYbTjj04fzkHDg/G42j9yDEvmljjAhAwjkOoO97AAAgOOF5p9Wg9srzUdM0TArjHWE0YgghGWwT1udLp43k3BhDMA4xaqONtwChg/l8vd11SntlGOFOW28dhoRA/DT/Q/cI4SyV1hiGCWFMem+s6mOUkg+27kPU26VLlzebTVXVuUj6skymM0JQmkkbgXU6HxXe+77tKKVN18YYMSUYY+81IYRApKw6P6/SPNvstkKIsiwXkymBsNNa5oWPvmpq3ZvQ6zzNTN85Y+qmwRSb4Feb9d5kxjDqoD86Oup3NXERYOaCk2livUvzoq5rb9q0yJVSMcaBAAxiZIQEbSkhTVm54Lu6xxhXuxokTiDWa4UxXiwWu3oXnA82CCGauiaYEUj29vZWVRVj9NaiCGKAq2r31uuvnx+fjEejx2dPDg8PqBQf3bm9bMrdclNtqxjC3nxhjLG9gZKQQHwMuu1zgiFGjHMXg6rrvBjFGLVSyHrvPY1wNp40fUMIMUrled4phTH21gIfOBWFSDBnDsbAESFE6gRjlOaZC94bE0LAiMYIi8n4xvWbxaR44YUXIMGXrl5Zni7/7u/+TnLRNS1I0S9//W42Ky4eHW1Ol6pV3vv9iwcnZ6ezyXycjmcH45MHjxKBOt0QRghnp+dnu7buvbHAvf7mV1554/Ufv/2jo4PDF958Q23K+x/f+fDjj6hMtNNZls1mE0b4KThjmD5+eDyZzH7+k59/80++FcNQ6oIIAkRPqfYgwmeB+WX75D9kfUo5+ixuY0AIQRhjQBHEGOEwLwXgtxUwAQ6fhuAsCHE4/xDM2tVumhR93yICi1FmjeKYgBAiBBYESDDhzBNoo9fW6U5LnphWQwgjCJigstwZowcedrVZc0GpoEp1hCIXbKc7i7wFblxMHj94vD1fQxeDDs2ujQ5ZEwNEJ+VOYahwtAQ6YClDUlAuqG6bCRcJQJf290CI1WYLbdSVJgadHy95ZHM5Ar2hkgWOu2h3Xa2t6rrWe+ecnYgU++ica7U6W665TKRMN8vN5nwjER2NRj7G8XRqnLPenK3PN1XJ08SDiAg2ylJEjQvGuIwnfdV1Vlvol+slYzR419c1sH6cF1YbQTnBDCOmanX84MnZeptk+WS+YIxp1QEIA0HFYpwwKjHOsuz4yRPMMWFUcsEAGjGp6pblwlGABWnbGluATBRcEsRSxKNyT5ZnOkaOCfWxWm7PHp7szrbLk+3f/+SdW3fufXj/4ezgIiLyg1t3Th6e3P3w7ma5YYxNZzMmBc9EJKhqKpkmmJJiPBoGEkxKiDCIkESci4wFnCI65kkuE++c6rpoXSYSCjGh2AfXNa1AJDR9qHvVtaPF9Kt/8s1Xv/EmxL6uywjB8nyt6/b7/+n/Or73iCJqTZRZrrqOQOi9ixBQKZKsaKr6v/zH//yf/sN/7hr91h998+oL17/1R9+CMXhvl8uzGzduOOtdb08fncGAI8Sn9Ubh4FDUwSZFfvHalas3rwAGNuVyNMp3uw2APp+mX/nWGzQXGtjnX7rxq1//4tZ7H8QIOecyzR89fsKZfP/dD3SjQSQQYIgipshHhzDAEEbvYRzSXAIIXxxd8ex6llf0KSA/cxz9dFI6PIIAxBA5FwBACGAMYPy0ezSgFAcQn0IUwBAZoUZZAADjqdpWb/+XH+wXI8oZ4dQYCwBw2nHOY4zDKGI0GkGMjx89ykTGILbKcs57Z/LxSGltrUUEb7db7y1jrJiMnTYMs+1qDSHMJ+POmW1VwhCFkEopipm1FkU0+AMCjLQxk/nk/v37iWDz8dhbN/AtdK8kpiF4InmvdHCRc75Z7xChTdcSBMfFaFevL9+4Cghsmq4oimZXIoQsjMjHKc+qsqytihglVCKEmEz6pk2wcN5Aji0IPkZjDAJhOp60ZUUphZTZGGKEm+WGUw6cH4m8a0qeEVGITVULyqrz9dHREc3TCCHoHQFQ94owWrYNTySAmHECgO+7BkVgfJBJQgg9OzkdjUba+U6r/cVMa80Ys9r0XautOrh80QbLI+nqRgJqjMGcN20vmFTOds4ZZxPGc5m2VbPZbPLpuDMqSVKIoe4VIphT1rSVars8z/M001YJISKCSZIsd6vRbKydjgH2fT/K80TI7XobrONUCMqUUqvlcj6fE0IIpXVd50XqrYMuYIyVN0qpRCQsQuwjz9PjaiMOJl/9028C70LVffDue8+/8Orf/u3fYoKooF2vL1+7ev/Ova9+9c1b7/8yK7IrN5+jXL7905+BEGejIpVJues60//pv/hTEAxV8NHdh3fu32ecHxxdOHl0Vj3aEIAxpTxjCprHZ8dB++/+5T86XS4/vPuxHPPv/KPvjrIcAViuN1p1h3uLGOPf/+hnb7z5NZkJH+PZ+WOKqDMeRPz9733/pZdeSovcOP3yay9r13PJlFXBOkqpUZ4xFsLAHBz6SfC/eS/9DFA/fXygVQxTA2Mc8lGAL1euDSbxw5zAWcs5Z4w1XetiCCASQuAn3XlrLRNitDf/6MG91fl5yiWwHsbIpCCSp6msqt3A4AU+EIT35vuT0VTXPUX00eNjUeQokZXqW2t0DAbEdbkr28YCFwmAguCEBRwxiMi72KrrBxcWo1nbKBNArx2FlBHqvIcIUw9TRCVhiOB8PqEp9zHyLImc4FFaBXN/eWYxuP3wviPwrNwEhHprl5s1Y+xotpcjRpQTAPd97yFoTWe9jyGQCJ0xFONxltfbHYRwvV6XZRm9f3J6YqI9Pz+LMQTgs/FIa9t2Ki9G2Xh8dOEiQhiEGJyzwTaq1dGu6i2gsNWtkAzCyKXwII7H01wkJAAc44WDQ6VURDCASBAeoutAiLPxZJQXq/NlKmStOkRJ3XdCyoGCX1VVU1Xe6kmeEYAAAESyg0tHMQYEgupa74zuW2uUM8obPZ9Njg73GcWM0hgCjN6oLk9SZyzDTHKu+z7YsDxfDZlRIYRBApGOCgdib01rVGtUr7W11ntflWXQLhepabVxoQPxeLuBnJ+ena/OVtZ6UWSj+fydn73DMe+MJgnj4/T+k4cWhr97+8ceEh/Ru++8/6O//ftqXQrKvvb1r7702otZzgE0773zc2cshHBX11euXfn2n/3x0fWLf/QnXy8KQQnofNd5BSMYywIH2GyrYByGaJLmkzSHESAYp4vpdD755Xvvnm+2l65cM71BHiaYm95UVbXZbO7cuXPt2rWmacqy/OnP3u5VN1AFMYADhUMIYbX5ZHuEfyhr8DPtos+T74flgoUYBOCV14BAj6GO/ku/0/C/GXAIAPDOpUJSSlutrPfWOWst5bzXOsuy0Wh0cnKS5/m4GMEQKWfauwiBsuZ8t/EgVn3ba0UZS5KEc75cLiXhtjcHR4e7rtc+7Jq2KjsMsHEgyfLJZBZi7I1eN9uz3ZIIGmCQnAHr+6pzvR2lEwoFAAREJKiAjA3cVwAA4jQgiBgFGF27fmU6nfZOZaPxZrPN81z3ajab7ZoaJ2JZbmvVeRhN8L3RnLEiy3EEgjIIIeWMMWbanhOaykRyoXtFMdFau+BjjMY5ISXCeLDzgARvyl2nFcYEEOpi6KwGEAbnCUBN0yx3G4dBOhmxRDJGMYbG6G21HUIHYYjBOo4IQ1h3PWPMWnv/4YPhLTIURZxLyfjp6am2FlGSZOnT4W1TUYrTNM3TzFuHQFBtFyHonZpMRlIwKTlFcDKZzCdjjOF8PmeMGaWNMeNxAUCglMYYvXXGmN1ut9ls9uYLCKE1hhManIc+9F1XlmXCBSd0NBoxxjin1tpeq4AhSQQkOCLoY9g2VW8dZpxSXq3L+7du97u2rZ/SDAmjSZ7ceOH5P/uzP7PWwgi0UqvNuqwbBAnGpEhy3Zuu6+q6Pjk/fuXVFxfz6U/efvtf/+t/c//Bg0uXrwQQuWSN7vJptm22mADG2Ha1QR788R//6dtv/7RvWxphvSoFwAyg6LxzTqb5ZLb4xS/e2Ww2u91udb7++x/8Ped8sdiv62Y+n2NGjy5dLMa5cQ5ACGHE+KnhXvTBGcs5/wzq/ntISJ+H6LMXRBFACLXW2prfVfEiAAmiIYTo4MOP7lSPV4nkBgQuebTBG2tDzLIMu1Bud5xzKaVpexeDsm42mxnjNuUuoEg5M0oLxox2CELJRLOrKKJt21oYn6zXNvjJZCKosFa/8urrWZ6sl+cf3/5QOyuL1Magmvb5y9dO7j/KaJKnRQwoBEApD8DbYDADw2ydDwOslDeqDwFwTAomrXeR4m1Zkk+SW+Uob6zqvYUYc4hlRK7XLsRCpgnAMIIo6KbcEYgk4874PM81sNqYVMiublrTYUpcCB6B3tiu6wSgAtP5fK/aldbq8XysIPDRrY9PDxd7DAAAgPJm29ZIMJHIRTHBMUQPQnTb3W46mWAHo/NhMBz3MSJYWRUQRAhJzgkhTVXnUlJKVTA8S6z3FCLfaOiC9yEiiBF1MBpnIYTB+c16x1PJE2n7Ls/TuukIRYIn29160GFGHz5V2znnIowYYwcipFRbwwht23Y6mXhjvXLBe+TjUE91WsUYAYIQg77vOWd11/I8zYr89sd39uaLjCWmN03VcsmUNXmeumCdsyB6kcj1tqSp/Mt/8T/UXVutdn/97/9jLrI0TwLHVV9TLqJx0IZXXnk5ycUPfvS3ly9f/NM//yPEkA/or//df4aAfuObb832po3tog8ZkqtHp++8/U4I0QXEE3n/+IFIRZGl1qhys/3Gt7/xwusvQkoAxcbaalctZrP1+ebk8cn1a9d++pOfX3vp8nq9Pj9fPnfj+atXrxNCHjy49+T8+OBo/+joAKAIQIgeEEKCg59MaD5ZaDhV/sGRE1+G2BijDZYTigC2xkSAogdt1f52MuInLkcBgmGaF5xFABOImqYVQnRtL8epMUY1vTHmytXru+02aAshZIRuVuskSSBC42K6KrckYoRQIDFCgBCCGEMSU5nsVhvGaN10iJHTk1Mm+eC/mmC2qquP7twCANS7LeX0+gvXLz13JSuKs5MT2Jn18qxXulqd7O9dQAB1bYMiIJLAAAEE3qvIGaQYCw688cp670/Pz2AEl25c0706ms/Lsmx1X1eVhdEHjzmgqey2NQrRRtDoXrlIEW5rTSkNMJ6dnV3cv7A+Xzros1Ghu35XV8U4H/yTskSirieESMSjdcaormuSJFHKdMADAvaODhlGPCIY4q6thJRddHtHh7ZuMCYUw6bp9/f2nLFZljVlJaTs2lYIobROhPQYtm0Lk2RbV6MsmxSj9Xo9Xkzqrg0xmAgIwSFGH4B3LmDIOVdKEUaFEJeuXvQhGO9SOXLOzRfTTqkY/Wg0AgA4546OjtbrNYxAGY0xwpRCjMvddm//IB8V9+/fz56m2kFjDKOUUpLIpO97q3Sn1f7+fts3AEMTLR8lypk/+6NvPvfKS2//6McqOOddmmcgRGh65AIBSCmNGW7b9ikLymku2ZUrl65fugJt3Ja7C0dXvvPad4xzP/r+D3vT3Lh2nWb0+vmNF199fluVo9EIIfLGa1+9/fHdalevtqv9ywd5nlsToWDz+bwrO+1B78J0f5Hm8ub1a0Wa/fKnP7t/5z6m5MKVi4BilqQffnhn/scHMk2UVfcfPDg5ezK/OKWUIUgePnx45co14w0k8Oq1ax/f/vDwcB8j5L0nhBpjQICMcR/ds30gAECMf7ACJn6J98pwHPXu6VjLe6+1JZx9ZhIzFMABRRBioJQGF4cQod16s0jGk9HIOOOVCRG+9PKrddk0ZSO50MYx4YhgjsCmaaixVmnEZQhBt0pMxlzgvu+rplNKJyJpmsYRtC23LEsCBN/9y+8+fvBwfXyqrMIBa6cBc1dfuP7y114POAIEL9+4SFyc7U/Xq83Z2dKbUFc1JwgDghGK3j/1GY0BBAi8DyH0ph/v7Xtvc5lE6wiAEOIAEUklDCGBcLvbGasjTTAkmEDg3On5+WQ04kxGTFtrxyLjWVJ3bQiBU7Y+Xe1fPCCMDgYoNgZCCCdYssxpBxABICCEUikjxZtq5XREIiKEECQQAogQoTShxHtLKa3LapIXhBCrzUAq9CA6oxHGwxk+YAgR6PteGT1dzF2IrdZU8CfHx0maMiaUVogiyCnlFBqrmx7BWKRJq3qPgHceYgxAQIS3de1jxJRYbaSUIQQf42a3s96nUhLBA4g2+G1dU8bX2w2u8GKx0FqfLlejvOBZslmtUQRN3xV5qrwWmaj7WmsNOFm12z//1ncnk8lmt8mSPMmyaMP9j+5cObgIfUQhrs7OI8XpLP/Tv/qLGON7b79z58HdzWYzP1xYb/cv7d/79UeSEtjZzaPzm8/fvHFw9U778WazyVi+f+1CMZ2EEDqtd8uVb0NQ9vrVa73XgUbrAkJkU1anp2eH86N6uTPQOua/+d1vJ4xSxL6Z/Nm/+9f/9oP3Pja9N9GXfbssdz/75Ttpyjuv9ib7b7715s0Xnj85ObHGP3r06N7De2maHh8fI4IuXrz40e2Pb968wRg3SjPGvI/Wmy8qU2EI4Pfi9AsPpZ/fgWGIAEJrnXMOEQoI9vHL2fZgsDYJEUNCICIIM8KVUtpansnnr1z78MMPXaNzKQmlUERjjMyzRvUeAuAd4Qxg5G2YzmfGmODD2eny4sVLSilltIeg7lqRp9vd7o033hCCPXnyWLUtEeTlN17JimQxmiBKAALaOghhCODhvYfehslicePmc9bD2x98+Osf/+Lq4aXoQoyIYEwJdyCG6J1S1lqRyNYowEhjdX3aTieT2w/va+8ijjACAiAIYTQaQR8YIZvVOh0Vk8WMSWGc67se+FDW1SQraMSCsr7rLh4e9c5wISjDTdcRyTebTSaT4EPdtuOiwAGMiwzG4H3giWQwWKUbHwcN9HQ+e7w8S0cphSiAMB6P+1YF7wHGddfmSW6cBQAwQq3zIQSEmHFmbz5fbTbVdjfKi91u1/d9kkjvXEAehPjkyROAUZ7n1tr5aGKMiQhyKTrVc86DsYkQXd8vFgvvvXHWOCugVEoNI5ahuB4iAAkhmBAppVMaI9zVjQ/BahPSgDFZbzeLxYJw5kAczaZlWSZZmlD6+tfffLA5zqcFiOHkyWOrneQsyUR78fDihYunj44lzbFC266U+QFgJIYgs3QymTRtpZ/oqwcXk4TNZpMHt++neX77/Q/OH58aaxeLxf3797vH6mvf+lqECCCYpvny0bLc1hjjW7dumWCKxeTo4gUY0cP7j1gilTVSyggwEkhKjhB0xhBCGBPR+Ae372FKWJ4v0lm3raPuR2nmjG3b9vTJyd9872+m02lRFD97+yfZqMjzVNXKOi1TgTEd3A+9986FoUfwJcD7YhDBz9ltf2Hf6JknxMGNEVNih6QIFwkIESAIIgIAhE/7ViFigo0xlHLggbM2OFeWpffWY/jS869+fOvjZr09GC1QBFZbKQTl5Gy98hD4GBKZlmVZjAXBwvqgrdO9Orx4ITjvrdM+dEZhhiMMs73Zcy8895Mf/XC3XXHO/+p//mfpKEUIkABOn5wkSZZlmWn7R3fu3b/1UZJk9967Oz7cm186CgRdefm5k0cnYzkCIaIoXPCMi94aijGKwDunYAQAYgyPLh+enp7CXCLvqs1a1e3+3h6AKPqglZGIHO0f7GzvAap1//TsKiTHxHintO6qem889d6neer6NiDYa5NREqyDAoAQuaB1XaaYScqcNr0yGlgTPfVgLBPCmXUOEEwImaZjoDyMoLcaQYQJU9aMxuNqVwGCQwgewwjQkyen84M9DBEwnnlQFBmGCDNGCAEUqbYjiDKEF9MZZaxq6q7rujSt+3qezr0HmDNjDA3Q99o7F0IwxiilUplEHzilCKG6LAcNGmXMGON8EEL0dTNLCxiigdCjkI7kZr0ZjUbT6XQ0yoe0QmNtAHG9275482ZWpDcn11fr1eHePgPg7kcfz6cLg9o0EXVbdbanaYYBm2d7e3t7qu1Ol+e7tkpH2WQyWa5O3zv/1fHdBxKIYjzqVIcoPV2dLfb3Ll65vCpXX3/zrdq21rmu6YMyH33w4dnJaj6fy5r7GD64/fHXvvZ105rdZjfPRw9Pn/SNLhYTKvHJo0dXDi/gAB/cvvfNr3ztzscfdl0niVBly7mMXazWiknyuLnXKXPnozvz6aLrOufCd77zHZ7Iosju3Lvzo7//4Ve+8jqMAAHsQowAIoKtd4NdC/hcmhmEX6x0+QIa4CePP3udYVMcHoQQD8GiBKFoI4eEDJRh9IzREgJw8C/jnDsXUEQEIhhBBJEx9uLrr/7y578AOiwmM0GYUirNUhN9Wde90dPZjAmulNk7Omh73Rm92+0uXbqknF3tNnv5NMaY53lowcGFg6ZrI4RnJ0+OHz3gnP5P/49/qb2FEEbv12eb//Tv/z+cyauXLyMAl0/OC5E549Msq3ZlpPh8u0wYP7x8BHTsyn44+hpjuODGWc45wMhHr5R2AJwvlwAjZY2PYbFYxMkUAcgYQwDXvYoEGWPSLIXeamsQQsHH4ANmGAGIGKKca2MgQrrzEcQI4CDxQQAmQihjKAgwxCzJtsvV3myOg2vrLcPwhZs3tssVwjhaixHam81tr/LxJEbgjaOUdkpJKYEPUkqtNZeCcLY+XRLB2rYtioJgPCoKylivFWGUMO6MztMMAsAps73XWidJkk/GyluSCh2csQZ5IDnHNnjvow+q6waBTnAOYyylHFxOIwTeWmOM9Y4ncmgxAJEBH2CMIYZE8vF4vKuqpMhN8Bjj3hrGGIuyXnen6+V19xwi4M7tjz547/1H9x/cuHINAai1Ol+tx9PZ1RdvrJ6cEkG1UY8e3M/3Rk2163Q3HhejUbFYzKvV9vat2zJNAYXZJHfBy1F2ujl//etfebJ8EqzLRfbrDz548cUXk5x845tfp4T9+v33Zotpr1V85FbH55f2j6rl+vWXXzm4cHTr3Y8hjMG6H37/B8vrNzKefHTrzt5sz4OIGanrUojEdP1kMgoQYoIrXR/N9ntgEcLffOvrVHBKMScUeHDlwqXNzRePHz159eXXAAwMkwDigBwQvziO8Hc3j/4hB9fhskOgOyQYQGg6ndEE9R42TTW4jroQAAAYDnQoEEA03lFEWSTN2fberY+vHV49OT2+//DhfDEdibzrOpGkECEbfK+VcU5KeeHSxVsffgAInU6n5+fLCGHEYLXdjJI8YXzM87osm6bxEFhvxrPpK6+8fHL86N6d2wH6V9/66s2XXwDOnx+fPPr43vZ8432EGI0ms6Zp9yazqi4Xe3u7esdTbryhEO221WtvfPV7/9ffHgyc7zxvVFO1zXhc9E2LIfLee++lECEELhKPACIQMxJd8Mo444HzXdNKKRGmVd+mWeZBNE5PJ5MEkt1yPR5Pda9ohFrrZJR2zgBGHj16dDSfA+en89l6u02y1BlLAHTG5mnSGw0Yeem1V/NR8bOfvC0AMsYgRtM8U3UvGdetOjk5mR4cME5gCLZT1louhYVRWcMgrtvGOW+tnY+njLHeakCwh8ApjZzfm856ozEhg8898KEzGnCCMVZdX292kss8TQlAhBCt7UCs1cYgCAf6ZNd1GCIfAwCBS+FCwJQECFAEPCKEUEDABJ8W+Ye3Py4m4wjBZDIZFL8vv/zyT3789rvvvjsaFVeuXgLIAQpf/srrvbG5SKwy773768X+gY9wlI36sn589z6wPs0kz+Xi6KDu6rKqLl25RIUo0uL//Hf/4WC2/9WvfqUzzcNHjy5cuHDr1oe//MWvbz73HCc4oogkeesbb3nvy3J7OD9ou3q13VBKsce/+tm7qA+j0ehb3/kjZc1//D//OityktAHx/cwJZcuXbp5/cWubu7c+tBoncnMGeusL4qCEkwIaZq27/smmjRNu675s+/8+a1bt3x0b731lvEmz/P/8l/+859/9zsRRUSgtoZS7JwbPJCetn+e8eYdRG2fV8n8jvbvZ/bSp4MdHyIEPsIAIggQR4D6T9KcPn8hhBCKCEKIIAreb5arjKRd0x7u7ztnyrqSaeII6lQfnKeUHi4W4+nkzse3R3mxaRobfFYUbd+db1eHh4flaltrQzzCGAsh+r5P09wb++4vfokQsN51tjfRueBRjCcnJ7v1BgEwKkZJmivninwcIYIIr1YrmXACyGw2yaS4Zx6cHD958803njx8BBBRbSe4kFMRQEynCxA98KGp6kym23KHfYQRsoSb6Nq+F4x1VSO5SIq8bduikMJzO+yZSu3WG5FPOGNd1yGEtHOQkl4r7SwmMB8Vq9Xq6ODg8ZMnn477tdbGahFFWZZ7e3sfvX/r0s2rAURrLUEYRKB71bZtwgUB8GC+6KxlnHR1A0IUiWxUz7PE6yCLPMZovY8xJkkyGCzE4Muy9NYt8qIsy/Fsqp2FBDvnEi56o4WUVdNkSZoy0TVdhJBw9uTxcZrmSZIM4GSMDcbFhJDoA2OMMbLZbUWSKKW0s4QQAxBjLPgICN6UO8QppmQwQHzjjTdWq9Xp6akQYrFY1HV1/8GDq9cufu3rbzVWG29M5JVuv/5H39LWBIDe+fk7puonRd6uN1ab6d5it9lab9qmuXfv3sGFC6p36WjMsiRSLFk6Xkx/8et3vv71b2w2O2tt0HZXbgCB+uVXatW66EJ0XdcdXTyEEdDI9fP6wa27fdt99P57mFGAwKbcup27euX6+XZ5/fmbk/lsdjCf78//7b/610rrUVGAAHbllmCq+n4+2yPQ5pwQiC3C2/PV44ePAADv8fet1W+99dbVC5c//PWtV998XRklODfR2uApQvDT7fSZ8Ijfwen9vXOaT18LIQwxQoQggE99VRDi/BPl2gDnCEEcYvQAsM4yzpwNgxUy53zY8VXXs5Qns1HTdzE6QDEDkEBU1/WT05NEyM1ms7hw4XS1LMbjum1GWa7qFjiPEN7stqM09zaAELumTTJptNJWqej3r166+vxzHoKyqU6Wy9lsorYNCBC4aKoeYdr4XillnV6dqjRNR+L5TbVlkDardcjMu+/86qWXXiERI4R1b43Tyd6eMT5qIwhFIU7S3Aegut46PUS3Us6ZFM75plMhBFuXCCEMoNd6JHNJ2fZsKaUEjK13W+BDCOFgb79pypRiEOJ0vlDGaevqstJ9nxUFz5JA8aOTE0lZtSlNdOfVWggxJsJbGwly1hBJlVVeKwSh1apDcbAvXXc1IPjx8cM8zYRWQoiCMaXUbr0ZUCqlPErHMcbOqoFx2fc9QNCF4HudpMlHH3186cpl46y3zscAMWr7fjSbMsy01oNb0nw+DzEijKH3MfoIgwseEbKpy11ZvvDyC0mSPH74CElat40xBiA8RNFmSTopRhQgaPwPvve9xf4eJ3Ry8aJ2uum7vtOEkdl4dv7kGGO8XJ7P5wuICMeo7buz9TahMh3nV5+72Tv14fu39mZ72psP3781ne+dnj5p2/q1r7y23m0QwVlReBevXrn+5OGj+WScS1HppsjyfDw6PT89X20ePLz/xrSgmDjrECRV146z/OT+QyLoa6+8+vj8VAf14PH92XRRZLm3BmCMOL7+0nP3Prrbnp9dmO9FiKy2iczW6zUAgAFijGWYnj85m+aTCxcunJ+fL1dnJKCDw8NHDx9CFxgmzntEEGMsut99+ByQ9FsZp5+Z3Pzmeb+N3qdAxQgAQEAMAIIIcYgYIvJbT4IAfOLyMnj8ESwYww5YwXmM0QWfT8YilwEiiVPrglN68Caum9o4uy13AKPj4+NsVBBCrLWcEAIRFjJN077XzgdCqZByW22d8c/ffMECDyW5evMaY2yzXZ8cHz9384ZtlDVe8IQStpcslmerclsG54w38/mcMXL/7n0hOABASpkkYjQuHj16dOXgEvQxoVwy7rRTbTsbFZvVenl2PplNQ4SUkyRP674NEO52O91rjNDgqBBjHI/Hwbq2aVCIrteCcc75pqo/lYMCBFMhCYCpTAaF9LX5tfd//d4QuWlhbPqu69rxQSEJLwR3Epf1DiHUWyV5imIoiqLe7LJEWqVno3Gj+qZrZ3sLUOH7jx4OId+c0K7tXPBDEmkMYbVa2V7lI8E5x+GpoZkQoulaSqlkXPXqzTe+crY8T5lwACGE676bTqeq73tjjDVt1yKETs7P0jSVUhJOvIcAgNVuu95t86J47qXn0zzf7LbpqPAx8jShUljrsiw7Pz2DLlTrbfTh1q1bo9Fot9tdvXr169/6xo9/8vdilPAkCSACF4qiSNNUK1tVpUiS8/Pzr77+xurkzCsHCL790Ufzg31vQ7mrkzy5eeP56XQedGzbtimrvu8m89mbB/s/+dFPgQa615NLk5AX/cnDum6Z4BjQutpCD7WyGljkya9uvbd/eKTaJhHpbrdLGCcAvvzGawG/9t5771OMAYYhekppVTajYqLa7ny9yniap3mWFkIyrbXTmlJKKVdNF72jENleLcbz5ZPz44ePnn/peRBj8B4x4KK31hBIhh4r/Fx1+2yf9kslL7+9Pr/9Dv/cwRMBIxJcDDGSTzfupzsveIpvay0X3DuwWq3aJxtjDAoKU9oF6xyq1iUIkWKGEDLBtapnnAeKYcKPjo5On5zFwU7Oeprioii2251xFnMWnXcwKNVHFylD1tp8Pv7Fr3+JMPjVr371l3/5F5M0resyX4wr01VGH84n29P1w7MHJOIizy+M9znn2ijrDKO004qLdF2Xz7/wwuN7j9u+kzLte50kQtVtynnXtEKIvaMD5Swi7Pjs+GJ2ufM62EAITaQkEB3NDtbnS4RQuy2TPPNDwh4AkDKASK9VwsjQix88xxACOjgXPOBkvV5fPDwiGCNMd6qigh8cXVRtH2jkMEiWHs0OkHd1XXvgueQYAi6oDd7iALT2Xc/yZLNcEYQLKiBEI5kiH7kUvTWUEgJIdH40GsEQfQABghBC0zSccx8ClcJ7jyiBxqyOTyRjvlMRAhdDOi4arQMAPnjEKPFcCIEQStM0Am+9N94yRid7s/3LR8v1uncG6X7b7IbDPKVcaz3KcinFa6+9dvvDj6w2jx8/lmmCGVVtdbpd37pze3Swf75d1n2XJYl1jlIKISQUMZHfv3t/tlhUqltcvvC9//w3z127cX73AXCBU/yr9967eu3G8nT5sbnrvT9Y7ElMxWwBGXBOXb50tD3d9VQ+vndcNSXO+Pf+5gdM8LZuTNe76K7efG40m0aPXnj55ce37npnEKMvvfn67mzLLBiPCkviletXN7vddDwCMUKAg/Z5WjBAonTReWUNtYpSYozOhAQAYIh8iNH4h3fuIwCEYBppQMDdj+/OFtP5hYULHiHAOffmd0lhPjlqIgA+m/X0+Wd+fiQTYwww2GAFFSBE64NIJHQR/aaRDAACv3nZ4GQNQJjP55P5dDQeO298DC664+Pj4LztFXAexogxjgCINAEICimNtfvzBSO03O5gjF3X2eDBJ84PlFKIEcK4KAop0tFo8ou3fyaJvP3ebWjg5nR1cvxku90+PnmCOCYpX5brqzevTfamve4ACAjDsto559I0HaT9jeowZVIm3vu6rKrdJpXJYJPpvRdUKKUIwnmabXZbkSZV2wzEYxCioGS32pwdP8EIGa0pwlIIOPyoIBLBtLd7e3t5ng8q56bvbPCq7xnEMIJ6V5ZlGWMsRqNeK6cdgWSz3CRJ9uTkBBFijHXOtV2XpimG0Gqjuq7vdEAwAgQAGDh3zjmn9JULF+eTqW66GILuFXAeA8gwSdMUYexAFLnc1hUgWCTcWmu0rsry8PAwIhghKLIcg8gw8dYlqSzrqu26YRAq02Q8nXSqZ4xVVWV6M1h4+hDTJFssFlmWWaWXq1WIsdPq8OKF1998/ejiIaLg0qULly9f8t4nSWZMSNMcIFj3Lc3Ex/fvnJ6fFEUGA3z357+69atb9bqGHmKMd9u1Uv31G1evPnejbGoi+cPjRxEApRSE8eLlC/sXDy5cvbzb7Y4fHC/Pzh/ef0QI8S5SRG/fvv3xBx8qpRAki/mhMW65XHntOKbQRYH5pJhGD0BEg+2O1vqFV1++eO1Kp9rNZtNXLY8EefDOz36ue0UQfvDgEQBAmx7C2DRVWZYAgADiarPUtnvqFbyrOCIoxJQLSVkwVmAKI3DGMkIpJgiSGONAFP/d67+ZKji8MAQgRBIgcCESho3TzjnyyZc/4fh+knMKYsQADsEYjeqVt9Z7GEKvTcL40XSv3G4hwCHAEEJwsa3aACJhYLVcTtMxhlAZNZpPt1XpYowx6l5FFyM2mcjOmq0XnIDww+/9IMsyU+qyLEMIP/7+T2689tyVG1edc2meP378OMnTXisuxIuvvcIR6XYVAMFFhxFp+8aGCD1LR9nD2/etteMkxTGEvgcwQEFjhNuqBD6asosYqU4nk4w4UK52JgQp5dnZGXS+qnspJUk5T3i7qQuaMEqUNQHhiIO2Nlo1G0/OVsuz9SpJknmWxRCQCzRGj2HZVSyVMk2VMdBEAiDF5LXXXutsHxEEGLkYgPM5z+q6FgUHmLSdIogoZ7lgAcRWtTmXhBOBZNe2Xd0whGGIScSq7RyjEUEoaOuNY3C9fpIIOU6KSTFbl+VHH3x05drV9CB7dO/ueJR77wnDTdMEbSnlJGIXXFs3lItRPsYRsYi3p+vxdLKtd/ko2y43283GOVdXO5ZIlrBsMnrhjZcFI+lIJIIhgNtdCwBQrVuvt0o7g8w/+qu/vPbc5Z//9Gevvfaac+7+x/d++l9/zAn/ULx38+XnX//aq9PpVPVmNBpRiDGA+7Np3/fKuZPtajbPv/kn3wycYUQYlx++98HJyckVfMND7EO8+8H9ux89+Bf/5J+d3H/84PbDNM2DR1cvXMMxIBJREuu+/sWPf3bzxRfWuy3DLBmlZbPN06zrunRvdPP1l3/+w7cvXbn4+OyYQ2x6vVyuHjw5/uaf/1EmGAngP/6bf4cDWJ6f4aNDgCLhpNcqydLoPIogTxIUo6RsV1eBoFTIrmtOjo9nR3shWEypcxbBQZz9m14RfKaHBH6rV/SbM+qzR9Nni+Fn207DhwQiZwNCKMIYY0QAoviJh2D4BKLPIpsQEpz3wUIId9VOJnwyGnHKFrN5cG42mkQPjDFt3VCMQYiHe/tZks6nMwzhYA8LILxw6fKQEGN6NRDiYIgY4/Fk0rTtYrHPCM94+qff+pO90awv2+jB0f7h6fHZ7VsfM8wvX7w4Ho/H0wkiRDuLGc2ybEi/wxgTQjBCGJK27wezQiklBAER3FvjMeSJBBhxzgXjoyyHIRKIjvb2J5OJEAIThBAqigIzOj/YcyAMMaRaW23McrMumxpAOLDqBnuEEMIQcoMAYIzleS6zNGJUt80oG3VVPcknww4WQqCcni3P53uLCAAGUGAKAsQBYIgJIem4qFR3vllnRS6z9Gx5Prj+MimqqoIA6F5573ulECNEcCo5pGh/f386nUIIq7bBGHPOHzx+dHx68uqbb/A02balg7HIck4Zx7TZbSnGjBAEIqWYECIYv3LpMiN0sVg45y5cujRwa6bTKZOCMSYzuVqdRx8EZcYYhFDf91JKq/Xh4WGe55cuXdo7WJycn3JBIAqcs+eff36cj6fjGSN8NpkOPv2I4Nt37yjd7XabN998I8uyuu909N47zjlCyFq7v7948aUXRtPxL3/5y3d//uv337n19g9/vL84mEwmiOC9/bkxKk9SEGC0HoUoOT9Y7C0fnz65//Dk0eO7H99+5bVX9w8Pm6ZhjEACf/nLX8KAHt1+aDv1ne98ZzIZX3nuWoQhzRPKmQfx1a+88bVvfaOYT2kmnn/9pXQ6aqzujI4ARAQHc+De6PFkEkIQqVjMZvfu3bPOQQiNC4yxT9kIn1d1f+YU+izl6DOQBr8tK/305cMig3320/iSSDAm8bPH16f4RgBGHxih0fu9vb2Pwq8JRN6avfmi73urnAWIc44DGc2mymgfA0FYSrlerwueqq5P8wwY1VU1AUgplRa593Eym3LCCpdhjEWaEE4jii++8sryySkB6LlL15t1GW1cn62XyyVA8O4Ht29cvOxtyEdFU9VDc5oxAYwBBEajjy5cfPj4CSI4mYxSzBZ7+13TQME8CnXbZCKxfQycGGPGo3xb7jCARuk8SXZVuVgsrLKjZOxiGDJFdKmsNVprzDDDtKlL4MN4cuhdXG82UkoQY+dcXhRAYMHpannOGOv+v5T9948kV5YmCl5tWrgMLVLrpCZLkVXVXd39RryewSx2sYsdYP+6xQMedue9HdHT07oUWUXNVMxMpggd4dpNm125P1gyO4tV3TNzEXB4eLibOzzss3PuOd/5vrro9TqqkVEUYAiBNi37dzweDwa9tvlR8SYMAtnIZVo4gc/LqjBFpQR2LScKgDKh082rEjJilIYWbYwSQnhhYLSiFq2bhhBsYdbkhcLYaGjbNgSg2+3Os+VoMk6KxPf91d0dBODodOzbNgGIuo5WklJS1BXCTt1wz3aKqqiqSsuq2+9s7Gwcjo/KpjFQv/7u234neL739P5Xd8h1kCUp59wYU2UlpdRyGcKKSy45xAa4lu1sbgopEQJA67gXJ4vlpSsXFdKHx0cNEF4Y9FeG97+8q4FJ82y+WHR6nbLMT0/z4+eHGzs7vOCUEUYA1Aor8+iLO6urq1u9IUT4k08+uX712qner4q8LHIv8CmlSnCkDEWo44aT49HZeNQbDPb398+mU4CVH3r5MsnT1EOO1Ia6NsRQQLVcTBGCRZEDxzOE2oPBl1/ccQed773/Q0zMxuWd6kL1219/2PDKpRbz7ZpzLuRslITdTiM4tazl9LgsSxbbUBsp5R8MieB3256v4ujlrvMPciF+F6gIAAO0gUgrYCCCUEMEkRL6D8yXvozFQgittVHasqxOp/PC85sLxUXrEfLi2lNVWZbVdV0URTtmroQsiiJNUy0kNkBLWVWVMprYFsAoyzJCSJ5lvuMqIR3H+fzzz5/v7zHbyoq8E3fHp2NVy9XBMHJDpM3B3uF0PJFSI4IRZQCTs/m0MSqtiqjTdW3v+PDQcZykyB3fK+tKKIUxBgAQQmzGVldXs6o0GNmuE0URhshwRQz2LQ8jQilNixwgOFsuGikGw6HrukILL/AZpZTSsBMjQvKq3NnZcZnVizvdQR85VhiGlNLNzU3Hc13XVUoFnt+NYoqx0sIYJbSM47Auq9bo1bbtuuaiEYHtRp6PAMyyrO09OL7X7feMMcyywjDkSvphsMhSg1HU7axurEulgiAIXS/2gt2t3W7cC8Ow5k1W5ogg27bX1tZc15VG7x0dHo1Oo16nrTO5rksoFoLHcSylHKz0mcOIRSzfllqM5tNff/xRVuRC8UWa9IY9iMzli5d6cefBV/dFKRfT5Nk3eweHx6fT0fH4oJI5JqAs89/+9iNCiBv448WkbMrRdAKo+dN/9Wfv/OBdA8CFy5fCOG5EnZcZxPDCpfNS60aKtEj/9b/58xu3bwEDD58dPP36kVJysNq/dOlSr9PZXtkg0qTz5WQ6mifLrC6XxcIQw2wqGi65wAZ4tmOk8iw7sF3PcRHCp6OJ1noymXz88cdFka2sDJTRhJAkSYCBBgJqU8e1Hj96JGoxmy0gIkVdA4IV0gpDhaEXBlEv7gz6heS3336zszY0FEe97tWrVztRbFG8NhgmyyVBFH4rffJqKeefIRV9u8/UL4PkdwpFv/+Sl0f+TqCGaZ7A1if8W1cpaDQAoD3RjQIMYVnIva8fZ2czizHi2hBCUXLR8KLkEKPaKEQw53Vv0OfQLBYL2xDOOXWcJEsxRkEQFFUtlEQE87KOqUcANAY2TeMxG2J0OD6zXcdmFrWtH//ZT3790a9HhyfQ6I2t7dHobHY2GfR7nW4vikMlVJbnru8Ri3X8UHPx6N5DrcE0S3qDfjeIZFl7FtNaG5s2ghNpKKWns4kfR9iivG6YAgTjRslGSW2kY3ucS8KoG/sHBweWIb7jAwzCMCzSIsuSqN9VSkROIKuGEXo6GUkKuv1e5HsEIqElYVQYLesG10pVzXy2ZJ7jdPxGC8ui8+lsEMYOs4jBRZq5rielnC7mkBJD8bLKrt26qbTwiAWVZozdv3/fspxut5sulv1+HwBQ1JVlWQ6zZFlTTGQjNAQQIepajZaVqBFCQslBb1g19dH4rJU48y2HGkggAgA6jtNWCZuyIYRkWYYpHawNLNe5//X9KIpc154ny9feei3shMaYydlo79Fe4EXzRbZIE0iNlOLdd96Io+DJkyfP9/Yu3bx28eplQGGSLMqs3FrZGO0fR37AHFsBjSxc8SqMg+Pj0zCMscZff3lfSn3nwd0Lly56lh04XjpPGlFv7G4AZIq0GR2eDryO4NwJfLcbPN7b6/Q7F3e3Tg6OLeb71B0fHBAFCKI1b0pRKQyRZ8+SpU1tynC3FwzXBltbW0ihL3/71WI6U8isbA8K0HixHwXh6GQyGy8c5ikD5otZXmb//v/177OmABRFJfnVr34l66bX68yL7NqN6wdP94FURINimXq2dTw63rx+8ebbr2kLtUZsLfC+k6++Cto/mOj+Hp717yPcGAOAxhgLrSDEQAGigQ3tF9UjBF9sTSGEbSFJCEEIMQYIJTECdV0LJZus6TiWEAIYo4yOomiRp77vcylsO1TAcM55VRPmeJ4HKXWVOxj0x+OxltJoDTH2PE9z4/p+mVcWocaYs+OT3qCnEIAIMZfVRb3/ZB8rgzFMZwkF+NzWbl7lvh8aAMOoY3uu7fm9XuerT788PT4JLQ9CEwchNKAW3LIZBBAhxJVihFoINk0Tx3FjFBfc8Rxcy8V01iiNCbEd9kIDwbYXi8VwOISNhhACBJNsqblijNVN4zqWKGtsgGvblmU1oCmbWlVVGPiYkDRNLccushyWouP6g15vUaZKyYY3/X6XaOASVizTTthhjClgIMFCSsEbLwpiL0iXSwC05cMsSVu/6rwour2eH4WT+Yxz7roupTRZLC2IETYQ4jzLLIfVRigCFFSNEFVRGq6NMQ5lTdO4ns8YNY0o60YLiak1nc+MMTazjFIIkqJKr16/5gXu356cTccT27aZRZ48fPLm229I0RzuH43HU2vDi6IOxHSRzforw42tNQh01IlW+WoURXleGGKCIIr86Gx0ZtlkMp8OhisS6iyZNbJhNkUElmXZCXtXr92IwnBtd41SiiARJb969eonn30c93u9QT+dLbthND+eSd48Pdzvif6f/cs/M1ADqPaOD5ezKRmsLbMEK+PbAaKkG/V2Ll+8//SxLZwiK6+ev7y9s+qHvoYAUfjme2/99V/8N2PMaDS5/Nq11a01zvlgsJbNsp//3S+jIOyFsc3Qp7/9+Nprt+pKPHr01AC1tbtV8iZ0ukVTr+9sHT/fz9MsXS7tTsfCVj5LgIZaGkLJd5Le39+RfufXfwa3v//kFokvH0EItRQj0nLrAWhzX/Ty9YRRYwzEQAttW3ZrBqEbAQDgnGONEEICaIQxUNooTVyrqGuhVRRFRmiAYFVVcRzPkyVm1EWkaRrXcUXDAQSnkzFh1HWc2Xi6tr3OpUgWizAMdze2Hnx+d2uwTiA6PjlUtSzLwo1spCC27MdPHvGikaJxLJcgkCxSpTXu0bqoo9C3MGmaxvEZ0BBjVNYpxlhowAj1XEaMOk3nhiAkRNDthYQKxeu69ONQLtK8KqXRRV3BRiMIg16HUSiR6Mad0/FoOp7t9lYoJo0QiFEHI4SQy5ioG+ThqsiJgT61rMiTQji+YxjiSHueB5WWDYeAMISVlK7rFk2TV2Xc6xNChGggRa7tVFVRVVVd13lZGIyYYx2enSAAN1bX2st2kiRYA0hZkiR+EFOXNUqUZe10A2wzpGEjGyka3/GJ0k5nME9SIXUchLN8UlTCCZRlOdPpVNuGc+7Znk3tu1/dgxjtru1Sijc213714a9iL/rVX/9CAO77fj/unB4dSo24VL3V7tnhseC3MdIba6vGGCAM1siiDOkXzfb5cnHz6vVGyL/9+c+vXLvi++Hx8fHm5uZymT969Gh7uMWFANr0h0MAkFJKGHXjzdtpWWqEIIQ753eGw+HB/lHv3ObJ6CxJFkHsawivv/76F7/54vO7n1sYBY6by5oiqyyFeP6sLqvQDxCj2Heo7yikCSFlU1mGXLl97e69BzZzO3FfCkMs2xgTDXtu5CkpLIi04AdPnnzx2ZdXrl3/o3ffVVrcf/Twyo0ro/HZzsVdKuEbb7z24Kv7QKiyLKE2z588ffenP8I2q4QgCH4HnC9v/3km4KtPa3H6EsgvO6utQRlQAIIXEhAAI8EVAt+aYfzOEWE7XKqV0ZjhRnBpZN00iODWI8wY03BpeW7U77b1z4o3iBKMcZZlBsKyrlt9o6quLcsSdcOLynBJIKKU2rZte24pGuY6NW/yPO91Otubm998/XB8Os4XWZHkge1jg2xsNUWzu7WrGm4hxiiNvSh0PdHInc2t9eGKRaxerzeIu65lU4TTLCOEMMYcx0GEuJ7HpajrmnPOCDVGcaEq3pRVBVo77bxwHQdCaKQiCLTNUim547qbm5t5nju2bdv2Iknmy0WjBCSwKMs0XU5mE8uyFFAEIYawkQpRUktR8kYD7bmuKOs8zXzPa0UAXdeteKO1TrI0K3JEMKWUIFxnRSs828ZMwmjLPYjjuK5rjDHGuNfrnY7OpNFe4AOgizRrJVvzMgs78fXb1994520FwXKZJPMkm6fYQKigqAXGlNnWbLqQQgOD8ryMok7Z1FxprUHghciA0AtHJyOX2rzmNmEOcWUl5vMps6iQDaW4NaX+9ONPz07Htu2uraz98ue/+vSjT5JJggCGBvX7fYRAzRsp1M7m1trKWr/THQ4GBONep3v54sUvvvjqzpd3HcfJ04TLRqimbArLc4uiWMyWy+USQDieTzbOb/XXVv74T37K65KgFwsg82f/8s/e/eD7wCEVUpXhiyJ78vzZ0+fPyrrqDfqu79SSF7ysZE0dBhiGFl6WeVbke0/3DNdGaKNMK35fNWVWpMPV4a1bty5sncvGi6/u3yt59f5P3++uDOI4bt0GCKOXblwzNlUUaQzDTvz06dNWnvpVVc7vREXwe+Ns4A/luu1W89X9Kvi9HSmEEACkpDEGGgPJt6TAVw4BTPsQJLit8jnMZrZVlVJDoA1U0lRFBQk+nYyYbVdFjhDiyCgI6qoCSlfVvNPpCKEopYAgpXUQBLLhyAApJaO2ZVlFXVNKm0bUnFPLmk6nVVU0jeAKQgMxQGVa2q4rG3nu/O72+vbByVFk+RKy/cND1/d8PxyNJqEfBJ4DIYRKC86ZwyilbVcGWtixrDJLheCu5TWcE2Mg1IQxCOFkNF1bW4FKAwAwAqpqAtcSXISODwBACAOp9p88IxhLLeIwWM6TrK6C1S6upWVZdVM6vl/yhmEW+gHiEhl9eHpUS3H50qVsmfCqjlxHSim5QAQbhAxGAEBjoGt7eZkB0MEYU0aWSWIEdxjjdVMUlQA6DD1KKRCKMmq0llICYxzHoYzVRRl7IbBty7WrvHJd27atsqkgQdFK/3TvpNfrnp2MIIQAQstyqOOO58e9fh8apLX2fL+qa4gQIaQsSyml69oAo7feeWeZpkBpIWRZVWEnfP8n70eduKz56cm42+3/xX/eO9o/mo0nnKtup/+zP/qTDz/66POPP/vej74f9IIsz5tGNE2zmKdFUUxH48HqsEwK3/GVAgRS13aM1v2oN8/mWnHO+XQ6ruv6qy/unB4dD+N479nzzXM7SZkOVta0VgSibDwHtv35l1+tra0EPd83ruXbe8+PHt176FEr6kR7J4dxkV3uX+0E4Sdffnw6Pl5fX//eu+8qYR4dPBUILIvs6wcPRifH733/XQ1MnpfXrlzd3Fy3bAoh+PrefQxMUxSC6FuvvYEpVUZd8Zzx8Sn2o1RL5nrXv//m3U8+ww1FTXlydnru9pXvgO3V4PnS9918axsJAGgx/yqGv1MB/ja0QmP+UZ8FYayBQQAQjIHQDH2rqAIN+E5LxiBotCaUIg2bhksNLMculqnrBVEUZcuMWVRIEQYeFKpq6rATY0IW83m2TGzXI4QQRPOicEL33LlzT+89bLlHrmWLRmKMulGslBp2ehiiNM88z8vTJWEMKJgsEg0bizGlFKY0LfIPP/wIECilbAc7PM+LosgmlCHSTktqo6RWWopGio7tSS5c21dKUUyIgw2Eca87m8+FkNoAx3F2dneLPAUYNlVdwgoq7TgOQmi5nFNKLehO0xHWBBhTNRWX0vF9VaOT6Xhrd2d2kAyHw9j3iyRzHGc+ntgGIUoQo8CoNMssxhA0rVOr63sY4+U8oQ0nhEBgbNuGuDUEgRhjhzLHsgAAxMJ5VQOI8jzvd3s1r6os70Tx2dlpt9vt9/t5nlNC5mni+S5AUIhGNXBldWAwEUJCRoCFT0ejpq4319bLsl7O5p1+L4oiA1SWpX7gSikopQgDqYXtWsvlcpkuLvrOg8cP3dClmNR1Hcddy7N6q30NDUMEUfDw4QPf9z3PXaSLxTzbPXdJcgUN9By/zMrDk/04DkM/2Hu27wfx+vpmkiwwRvPpFGPc6Q7Pzs5m06mRam1tYPtW6LtljYb9vlbgh99/b//ZQTKbL5fL6/GttMirqrAJlQ3/+5//XWcwPJtP5/Pp7sUdhEB30Huyt3/9zVuvX7k+Phu1zmCTs9Hu7uZ777yLLJgX6WdffLE23Lh89VqW88vnL4wOD+fj0S/+7u8BQFUjrt+6GQSB0DzPs43d7SwpfvInP1UuBAQJI4E2oed/eXJSutnpeNTb3JgvFtduXnco+frhgyRNEUK1EIz8Y1vk1fz2JUQhhG2n4yWMf38L+mqD9DvIBwhJKSFGQhsltMtsXvKXb4lebkpf7neNMdAgKWVb1bAsy/M8KeV8uSAWgxhLo1fX1oqqjOPYGNOiKAgCz/PyrMyz0rFt3/WW82VRV8yxXc+r6xppYxpRL7MiyfaefHN8cshlY7DBFiOE9Hudbq/jd0LmO9hhtu8WTUlciyNQGWX73vnz5xmhWirXdSFGlGJMEYeaBC5X0vFcTBEkQAlplCYI13U9WswWReaHQa/X88KAG5U3lQLGcpwgCo0xvUE3LwuIEbPtmnMuBXEsAXRaFhDjqBPWmisKsqocjcc753aFUtP5XGpRFYUWEjtWraXQynVdbHS6mFuU1byhjM2SZcMloVQI0ZRVmqa+71OLAYIhBJxzl1pVUhiuicHdIAJSOYQBpZu8DFyvqWvPdtpmuuM4veHA6UekE0ySBfMcCKGWRgiBENrc3njttVt+4Iahv1wuleAOtso0c12bELS5udrpBH7oYYoM1EJxwrAfesyzxsn0bDExFk7qnHiWAJJ5TqUEN0JCXcny6PSAWpbj+YTaUbcnlambhlq0KMuHDx+2ArYY0yiKoyjqd3u8btIkmUxmR0cnd+/eu3PnTrfbFaIBAERRJCWfzScnR6dAw363+4PvvfvHf/KzeNBjjh3HsWUTTMDBwUFRVASSyPMB1A8ePAAIKiUcSm5cvSKRtkPXc+048DtR/A9/93c8Ly2IAze4evX6xtpGJ+q+88br9+/eWV0fXL52eWtjc2O4urm6tv/sOTLIaJhl2bP9PeizaLPX6cRFUUADCEXL5XzY7+4f7m9tbV65dnlzZ5OrxvHcd997bzKfKaVsysDvru9kqi0mX1Fd+C7nHvxebemVlFhDaAiARimgIYYIYqSMgfRbL/DvBFIIIQawHRunmBgFRN0UWU4wbg0eMSUAwdXV1aOjo1Zox3dcpRTG2A+jwA0C3ycQBU5wuHe4vrratl7bIbiWLNFef7wwEFL2hgPm2FEY2rathWw/rh/5zGEGagWUgdqyabffgdCk2dJ1XSEbqTWycCGbpCoaoOdlljdVVdd1XQMAlstl1dSl5IphvxcT21LApGlaFIWWSinFOYcQUopd1wYA+FGIGSWMeoE/mUwsQgkhABnLplKrXq83HA4JIZs7m8+ePfMDj9elaHiTl67rMs/x42hra2trbR1q49lOXdcGgNF8mhV5xZtWf5kQ4odBI2rLcQzQrUtNLbjn+0opZTSEsG3Dtq5blFIhBCZEAcOVrJVQECiGM1FLYJpaMMKePX0OtJlOp/P5tOGV5TGFNHFoKRrGWj9yCDC8+drNbq9jjDJGaailkZTit99+kxBkIKxls3vh/Hvvf98JfC8KuRAAQaGV0IJSghDo9jqN4ISwu3fvPXr0+N69e4HvdroRgPqdd965cuUKoWxldX00mkAI19fWgiBYX90Ig/jy5cu2bSMEtra2jDHT6TTJs8ePH6+trTnMMlJpaACFN167bdm26zsIaABA3O8t8wxjeG5nGwF4dnb2n/5///Gru3eWaXp0dCSl9BxnNBrFQfjgwYP5bKmUMtIQRHnR3Ltz38ZU1fz89tZ4PKa2ZQfe6++89fY771iO/R/+w3/46KOPRqPx22+//drbbxzNT40xQRDwpjo7PLYs6+KVyxChuNdVSoW+7zgOY1RKOVwdVFXV0rlf3Wp+Z9sJf4fxB38XhP/4nN/D5z+uFy6HxrRzyw2vlVLkJa5fih5BgwwExiggle+6Rqg6LwTnoRNWWW4grrnQAAkh4iCcT+cWJlKK+mxkIPCCME3TXGWhGxZ1eTDfd31nPppQgIo0A26gIRJ1rctCYOiGPqWY2tbxwaHNLJewfhxBTIhFLEqbpvE8B2M8OT3zPEcpBZWC2viOvcyWiCKbOBzIgteAYWoTShhjxGIEGMhs29hYATNbJAajyA873V46nlJMNJeWxcq68j2nzrPA87ABGKJ5sgiiEABglF5bWa2r0rFcoBWzrLqplFK7F86Xebr//DkC0HDZCyIGcVNWxpi0LHzfL5Yp4NKGsJWWwkDXCV9fX6/SgvpBa+C9TBcawY2tzbIssiTVQIWdeDabNXVtG0dByGyL2AQAMFhbA1pXUpZ1td4NA69Tl9VoPsWee+nyxQ//9h82NtbysspPzpjndLvdRV4Fgffa268/uP8wyUqb4XGy1ImENoo64V/91V/yugnjju1YQRwBpS3KHty7zxhr+eOrG+uy4Tdv3nz29JtLly7cuXvvxq0blCLXsjc31i5fulRWza9+9WvHce7fueM7dt2UhLG4H9ei9jwvr8rF/LnnefPlIo4ihKHWWhhjW+7N27fmZ2MEYNwJ//rv/uZ7P/nhm2+9l83T7kY/SRfIwtiyAxI+ePAgjoKttVUl1fH47Ic/ff/N128jhKhDv3n2xPd93/dH49kXd76an53VeXX10uWKN3lZAAxs3z8ZjX3HTaeLW5evfvqb3x4fHrz/wQ+p51CLnZyNMyCpa/U2V773wQ8mk4kBSkiJCIy70ejkrNfrGSGnk4nneZ9++unN1292+x3ELCNlMpribs/23A8++OB0Ot7Z2frOnMvLaNlqNbSFVYxxi7HvQPr347Ax7cbVvKgIASCVopZltBJCEIowgEAr1AbS7763ARgio7QSEkilhDRcAqkCL4yDuOW1Oo5TlyUhpOYNY0zWjYVJ1IkJo5prqI3nuhDCljjiOk6/34+iCBEcRZHn+57nIQCroqzLqnXplFLO5/OiziExjay5agTghuioE2ggqUUsiyotNNR+5K9urlqhg23WKEkYVVIGnt8JQseyjTGc86qqGGNrG+vnL17QXJwcHA47PUapy6gR0qIsXSatOY9t20VRaGCY65R1pYHBEFFCtJC9Xq+u68DzQ8+fnY3rrPBdz0aoXKZAKIvQyA8Ypb1OFxoQuX7HDwkh7QdQSq0MBgShlpnUKMmNksAYCPI8sxgzQFm2XWsZ9rt+FLbm9mEYtoxCqRUg2PJdjaAGpqyrIApd3zNKfX3vge24RyenSoNef+h7IaUUEzReTC3fuvX2rUbVhkLLs4JOtLK2mud5a1Hpum7gh6Ju3nnnvbfffGc5T6q8amXpHt7/uqmaDz/8UGtpoJ5O5lVVGw3Lsrxx60YjyoOjfYBgK4H/xz/76fd++L2f/Ownb773tjKy5k0cdefJ8t7XD/YODiaTycnJydHxSRiGrS6EF7jbO5vPnj2rqtrzAos54/F4b2+vPS8bUUujp9OpFPr48GQ+W169eeOt772diaqSTRzHV69e/dnPfjYYDBihK/1BVdRPv3kihOgPVl57483t3XPUstdW1yejCZTAsezd3W0E9Pj0zCOOjRwKiMMcqFUchwqo1Y1VgBDGGGgDtFndWD85Pc2TFCg9mUze/eH3eytDhUBVVVLKb549FVIKILHNJG9ercd+Jx6+vH2JzO88/up6yWH6DpkJQkgpbStP7YmEMcQEwaxINQSthuC3sRRAAwxQAAAMMAXos19/qou650Xz8dwJw6wqCyGoY0OIpFaNEK5tN0luAFA24ZzrTFiIEMtO0tSycbcbl0XhOA7BrCxLLLXWGlAMtAFSaGBaDm1eFo5rU4qFEEVRaAiIbVmWpcqaUmo5Xl2WFqau63phuHd8kOeF67paGqwBNMAo5ft+VVVQSSml67qAYIPReDpxLJtCZFFGMYYGVXUtEEIIEGAsSqXQpW7C9cEiTwmHquFaKiEaaIhtMwNUEPjlIgUIFaLBGEeWjQF0LeZYdiO45TqTJLEpYxohYwAGQkluVN00lmUFvs8biTEGhDx9/sz2XCPV2uoKBhBCoyFojIEQlotsfHa2ubnJGEOEFFVpM6vmTVFXWZ6vba5BCCnEbQHj8OSUMpbVpcFgdWN1bXPl6uWLglftlS5N8vt3HkBNPMTefPNtO3KTNPnklx/VZeV4bjs4ahMbaZNlmdKaBTZidDybBq5n2aTShdASE8u2XQzB1vbG9s4Go/YsyX77m89Cyzm3uw2AXGbzC9evAgIQQryR48NJllWz2cSy6O3rV8/Ozsqyuv3WG8rAyWQUeZ5NKDDwL/7yv5ZcrG6sv/e9tzEwJ0ennV5cKUFty7Xc2Xjy8S8+vH379ubFXQ01xhgC8Ku//9X58+c3NzcIIdPJ4vjwaD6eWJRN5wvH9W3fz8rinXffdF07nS0+/vjj4XCojVzrDxejCeSYAnxydvrO994NB/7p/Gxlc9Vg8uVXd9fW1laGfcZYDiSFqBzPO2EELFxLDjF9YWViwORskqbp9sXdoiiI1lEcAIjbPmVbv8UYG2Ne1nK/UzR6FaivBl7wYgLGfOdBAEC7OTIIIoQUV1BBpjH5HU/EV8Zi2sCNAOKl6AbRaJaVskAAZ0nqREElpEVpXlaEEIvSMi8YgJDgJM3ibo/zsmkaIwRvGsf2gFQEIqWU4JUQYnVjo2kaozQyoFwu3cDPeV0WhWVbWVFCo5umCoLg8rWri+WyLEtvNeJVzWwHYqSlSutq7+wkDEPXdXndWIhopRzmKGhqzg0ytZAWo0mSBEEAEOr7UeC4CECISZIkEELGmJCScw4QpBhTSmVeFVmhpXLd8Gg8Cf3Ac3ygNeec2hQoPRwOkyQJep28yMbj6cXtXVXX82Le6XQODg56wxVoANSmaWpICfMsI4XtOJQQzrnRRgADCIQMB66XJkullGXZQjQAo7ouf/SjD5aT+Te2jRAqqirwPAtii5J2OicIIowIArApS4opKYMjFAABAABJREFUxoRCGna6JqeIosU8ZZh9md197fUbCBuMsUWadJlsrmwt58vPv/p8+/y5oigwJIEXlnW1sbFlNJyMx07g50XR63Qwo/Nk6RCbl9Xa+k535dx4MT136cp8Mn/44H4yX4DdbWU0AGg0Gr31v/zpsN+TvBotRhrpphGOZWGE4l43yw7PJme3b16XRvcHXaHMaDTKiuL8+fNGSakEw+zmzZsPHj5++403p9Pp6qC/s7MjFF9M0k6nYxQYDodXr173woDz2gkcZYxo5M3bt5PFAiHUNE3gu/fu3Ll06dLbb79d5tX/5//7f0gAom78X/7Lf7ly5YLvuj94//tJkoiGn7tw7sL58z//rz8XeY2V+e0//BLZBrvk2eNvLD8QWh8+O3z69eMrFy+BvksARMZwJTWXkJJWjwYBSCAarqwAjLTWYRhOjo97nY4wGn4bAMErYHmZ7kII29pNmwb/U6wjY/7AjDj8tj7cBl+MMUYYCYCQAcgABDQC2kCtoTZQG6gRxsYYqTXGuMgKz/Js4lJEa97MZjNGEC9LRrAQHEjZ68TMsZXWoRtURSkJZJFPLOI4FtOAaUwI442UUhJCkqq4++jrZZo0TaM1yJPccxzdCCiUrnm2LChybly9NT4aHz87MrWWhVjprQChD/cPkyx7src/ny3LvKKGUUBa5nGu6hLKSZ3MecGRNgzVUkgpGSC2IfkiU1xNR7O8KOqm+WbvGaYIU2K7HgS4LAqbWLBWoFZPnzxxHIfXjeS8qWotlagbCFFRVY2Sk+m4tzIMh739yUkhG/At27nVhXIcm1JqUwYU8Bw/z0uldV4UABnGCCFofXVF103k+lKpSkuhDQAgdL0H9+6enp4mWTpJFn4nbMqSGgA4X4zHdVYBAbWEy3lCDbIwwwBbliMbXhclL0S9qOtZVU2qs/0xkJhodrR3ahumSt565H19//7zb56pWp4enWJITo7PvMhL6uQkGc15Ml3MR6MR1MbCKI7Dg7193w1W+quh51+8eP7KhYuL2ZIi6/ho/Nt/+K0sai90JOKtmOCjR4+01ofPj3nBiyJzA/vdt9+4evWSkM3du3cppZ1OPJ1N8jLnSiZpOk/nlSjf+d5btm95nrPMUg2UQRBDxGuBIMQYB92gEVVd10AbAiDBOEuWf/M3f/Pl3TtcyZrX/+rf/qtGiLPTseBq0Ov/u3/95zzLVvq9N9964+K183EvGPR6eZKkRa4J+v7/8uPNmxdw6Li+gyV2hI0SU56ms6cjvqgDK/760fPZwVnshN1ut+E8K/KyLAmCQCspOUTGQJ2mS6i0hQkyaDpfAoC0Ai3jwhgFgKYUt3aJWmtgkNEv8tjWKQ/CFz8A6Fd/XuL81SzaGCOEwoxCCKE2BGGoDSH0hZtT2y9VraeTAdCAF0bgtfKJc/fXn1TTHNRKa20cDClRSgklg053kaVxHDdVZaRZLBZBt9twXkuFIFQ153l5bn29KArq2mmeJ1na7ffCTnx8cBh5QasbNp1O19bXT0YnftxJ84wxdvnqlYO9fQyRUWow6GVJenh8FHZix/fSspJSurZnU3Z6dOowGnT9oBsdjk4tx46iyGZWv9cbH5/OzybMwK4XIwCzqk7zrBHcj0JCUKMkpkQIQSHymK2lycuCuY4A0vf9qigtTFp3MIgBxjiO42SxrJqaBQ517Ml8cvXipWayFHXjMKts6rDTJYTIsi6TzAuDRkshZVbkiCLbtjGAbuBfu3Xz+PDw9PkBQqjSeri2WsyXxhgv9JIs9cPOo0ePMMUutfpuYBOsjKmk5Bxhy2q06HZjXVVSCIWwxrAxajQaEWxRiKAynu/msnBDh2E0nUy2VraMMdzIRnCMcVVUdVYRwlzPWxaJAYpref3mjbqsT54eiEpgSnzf9wI7yVOIzNa53XPXLmICH3xx7+To2CCcpjmFtlD12sWV19646VM/yzLikel8RgBbX1kr6/r+g3vbG+srKyt1Vf3t3/7tT378R1VTO4HfKrkIzqFWd776YriyJo1eWVl5+vSp67oY4/X1TSnl8fGxMebSpQta69lsQikty7LT6e093dvc3Joni06nwxjRGhRp/vO/+wWDFoQQI5SX2f/t//l/NcRAapSQUMDPfvtZ2dS3X3/NYEwxcwT66//0F10n1EoZALkUCJJK8sH2xiJL++c6t2/fNgBoI6ez2aPHX7/33nstx4hzzqg9nUyePXvmOW5TNiejs3/95/8KQKi0MMYoJdorNUKIcwkhhAADAADULUohhAb+DiDh7/VOv7MMxEI2EBqKsJbGIa4sXnFGfMkTbHNgrbXRmtlWI4Xre1VTR1HUvndLCYQQ5nnquNayyDg0leRCyaquO50OQ1DzBijNAnsJane108jGsimwEPXtdLZgAIW+bzDiCPn9flKU2HFqDKWF3Tg8PjsFAGR5QilOl4nUamVlqJQq80LzRvMGaVWkCYEAUSKhqZTEltXt9kRWnjzbe/Tl3SJJPdvxPA8AkNUlCizpIOTZVuAVZW0RiyDqWK7FHGLZaZ4JrRpe5WmGpCZaQSVFUxmoJTBFU3MlHcvqBKExJi3y8xcunY0my7xglkMsmzK7qeqyLNOytDsRpFRIlVaFwSgMY88Lwm4vy8vZeDabzC3L2ds7WEymSCiCiJEKKm1RNpvPgzB0CYtcJ/SDPM81hlEc52WGEDo+OQEI1kYpbDAxEEiMACGEAA20jsOA87quayFEvkxcy948vxmvdJJsOR6fCd1cuX11uLuWyKzCDQsszAglRDT89s1b61ubdugjTAGETSWRAlDDg4ODjz/++OHjJxeuXP7gJz9WUvKy0UJubm5euXJFSj2ajKnFEIBREDLGlDFe4N+8dfvhN0/G42ndiNuvvTFfLgBGEEKIUVGVhFKA0Y2bt1fW11ZXVz/55JMsyyCEGxsbWmvGWK/XW1tby7KsKArP87rd7srKiud5V65cmU6nDx484Ly2HNu2me97t1+7+ebbb+yc2+4Nun/+b//XvCyEksZAqY2CwPbczc3Nqqo+/vjjZbpYlMnlN240RCPfqoDEjLgW67oezEucV4s8f/jsiYBGI2xRO1tkeVpIrlr9t4ZXAOhLly4NVobzZC4lPzs7M/rFOAtCiDHWso7+IOTA77Vqfv9P31ntt/Fy9JKLmpBvNQS/yxOEwHWcqqowwQiArXO7TVodfrMfemG7r4UYUWRhSkreFGXVcL6ztaOMxogcHR4Oe/2Ei6AbFbzcPz2+HLjzZLkyGK6srFCIhmvr2WKZZdkiSfr9YVmWQGmFwLDb9VU4Ojn2bSedzbphZIypeFOLpmpqhEmRp51OJwzD5TyxLMsJfQP1cGWtkrWWcno2VllpE+JgCjWAAFRVpbEGGEGKMaMuc7XWURTN5/PhcMg511rNJ9M8zzv9HiKwqiqgpWs7ZVlSSmqjtNFtbSAOgtliQRgJbDdN06Ojo93VDUTwPFlSSsMoqOsaYiS1yrLMcRwHOJZtG2P29/chQo7vPX78uBfFRZWFYegGfpZlRZJHcVjXdcUbjEi308FS2ZQApW3XlUrMlzOD4Ol0FEQ+l42CSikh69yxLAxJ1/ezrHA9W0pelnlaZgiD0HYwRdgi5zcupEmSF+kPPvgBoLi/0ZdEFUURx52L2+c/++TTs9NTm9mO6yZJsrm5nSdpJWo/sG2HciD39w/ffu9di1AowaULl++kX1VVNR5P3wzeYA4xPszy1HdcxuwcVADBuq4tyq5euZEl6fpGGEXxdDrpdrtlVWmtHcvmnGsjbcfGGEspd3Z2BoOBZVmj0Wg8ngZBUBTF2tpar9dpY6lt25TSpmkYZmtrq45j27attUYYOb6zsbUxOZtduHxhfHZmu27FC6UUEAYAILW6+cZrom4ODg4Cx13p9bUw6+vr6yvrf//Xf0MQddzANLKpG0SwzVhe8s9/+ylSoN/vf/zb3+ztHdi2e/P2jSzPHdfCEE0mk7W1jWfPnr355pvdbvf49KSNYS04WzkLjPHv62W/CJivKKeAV3iFfxC6EEIMX7zQAAMR0sYIIV4omr9cL3+t65oQYgBABFsusRybMKoxBBgJoxlASilsUQghRVhhrJFJiqzrR4M4rooyDENKiUR00OthDFnoHpweEWEQgEvPBwB0O31ZiWqaerbtdIONrc1FmiSTyfpwZTIZMUoZYwCYitd+HGJpF03tOSHz3aJu7I7PGBNK13X9/PnzxXzuum5RVT3H96njELuoSg1VGIZS6LquSMMZxAyTpmkIs9e3tkXdSK40bzpRnCVpkWZ+J2jDQl2XvKktx7YINQhSm6SLJQbQi8O8Lnzb3TvY9xzXGFM0tcH4bDEfZUknigHnUBloQJ5mq5vrs8VCco4RCaJAaKWUWmYpAajXH0CMhBCW5xBKpRa9uJPnpSiqoqlxHBZZbYyCGHDO3diHSjVNNc8W0+k0DkOHIkop5pAhW9iiFBXD5P2f/vgv/+pvHOZblHzwRz8+SUbP9/cAAOd2dhUyiJi8zF9/9/ZsuphP52Ec+L7/9Nkeb4QROgq8oshc17UoOzk96nSC2jRXL18RQkEILcwiPwi80PFg2ZTPnz7dvbDDqJNnhWVZGMPj4+OtrW3XdqCGvGhmk7mWptOLkyTNymIwGIxHp6vDFcrw82dHvV6PYNie2e252NJFnj179uzZE6WE6zuUUg1gXlae5xBCEETL5XI4HBZ10RqMIYQc31lZH3z66WfD/iCvskby8fEo6oT9ft+yLaUktpjned0gdAnVGBglw0548eL5/W+eV2VOqKU9CkO7XC75pI6N9fzzB8tBPw6iW7dvb2xs9Hq9lcEwSZLn+3s3b93CCPR67ywWi/F01AoUY4pfkubbXfoL1H0LJWOMhgBCiF6p9H5nSO2fiLEaGQQh0kYppQCGjue8osf7yiyNhoASorVWkhNi1Urde/j1qt+VUluMSimqptFae9hHNrKpnZZFVVWDlWHI3HS2aKXQESUSKNu2h4MB1HBzsPLo0zvr6xuS4OlyUdc1Y4wSLIQ4fL6XZZlQUgApl8q2baHBMkujKAQI1pwvi0wb0+l1CSH9zX437hyfnlTLdGtrS9ccCtXrdKkGFoQIQi6EzSzbdYqqFMr4vi+U1FxwXUkh0jQ1xvTiXlFmoePxugHaBJ7vOm4URU1TCaODKFykSbfb1cZYls0cuy5KRAk0QDQNQdiJ/OViGYah63omg1VTxxAgCB1mEUKyssjTzLXteVm2xGvXshElWkhGLQhhVhRRFOV53irfI4SgATZjvU6nqgtDMW945AUscFMNIssXwo7jOCsKZTSzPS0V0wwYgCFhFrJt+8ne86gTI4Rsx1NSrw7XiqIYPz/dPz7onFulDlaNiMMgjPwwCO58+YXWen19vdPpyqw82Nv3Apznqd0dUEpb+4Nbt25NlvPNzfVkOn+699zx7IKrP/+Xf46ISNLkm7Nni8Xi2fOn/X43SfOHD//q2sVrDNJf//JDSllv0J9O59euXZonM1E3vTDef/Z8nizX1jc9z2tR2u/3W6EPQgjG+Pz5877vD4fDZZosl8tOp5NlmdaSYiYbaVlWWZZpmXmBSxjldQMA8ELv4sULvu/7UWBL7vpWq8GfZ8soirQ2g9WV472Ds7Oz1bV1CCGQYLi2GjnBvXv3ZlmmEUzr0g382LaFaLIsO9o/CvrR1vnt0eloc3OzkfVoMo47nZbpRzHpdDpKqePj08lksrax2hJ3CSGEkKqqflc17A8EyVdhCX+Hav87sRcBqJQwxhCKMcRGgbrh5HcphggBoKHGBrxQ5QSGK8koXdvelPOCMVLXdS3F2sb6fDqDBsiaSylj36ulkkY3gjPPoVQu00QDbaBuiuzw2YFP7JPj415vADCJ+13gsHyRYQ2QZQMAjVFVXUiG7cBL06VrsyAKed0ABFtzB6upu4P+xYsXjdS/+sUvHWYhhGzPnxwcO5a70h0CKQjCWZa7tkMoEVrleS610gBVVUURthBJ5jOIEHMs6tiQwDAOZmdj2fDVwdAgIBuugSnqiliM2LbFG9eypdG1krZtIwCXowmmNAqibtRhjM1HU4SJNmZtba0uq9HJaccOoDK+4yJgpOCEYOZYhsM4ipbLJTRUSskQdl3Xx35SZpTgWnCpFeQcAQSkmo8nfuQrDEkYKAxt18lPR33fe+edH/yn//wfwzDkdf3o4ZPzm9sQIEJI2xY/PT3t9HsawZKLZjKdz5eB8Bbj6WKe2m5w76u7nX7cFHkvijEmlNJu2Pns0edRf3Dz5k1YNaKuL1y+/OkXXx4c7vm+H/Y6V3fW7969iyl68vjBcr7wraDIa65NkqXdrjvo9ZuGP3zwoDPoeYHfG/TT+WJ0fKI5CF3fYk4n6Pi+59lekSVVmse+d2Fn1zx/5tg2o1RrGQRBKzXKOW+apg2PzLYAgr1eL0kSy7LadNdzvXk5p5Q6jtNoPpvNqEUsy3JtT0huuRZXXEpu2zYUQAOjtXYDv67rZ8+e9Xu99fNbzLGPRieSC485o/Hp1urmlRtX7969TxiVRqeLubO2efnala8e3BNVgQB+9vWTC5cuYoiJS3cvXhqNTgFGymgtOMYYI+K67t7e3nDYf2nB3LZMlPqutxqErejRP+fj9GrL9MUjEGilGWMAmqIoHMtlmPyOfykCoOWLmW9bN0ZDSpnkyo2846MzlzmaICnls2fPPM/jdU0AVMZoLglCQqqSl7ZtzxZzaltZVUadsN/tpfMFQNKyrLrmvC7LqVLAIIQc19FSKQTCOPK6YQF03Iv7/W5TFUpIx3OVlohg17YDb8MPw6f3HzVN41sOo5Qi3OSV67pYAy4bqBUgBmMMMVoul9hmhFFjoMvsrCwa3bSl8063W4rGYgRjKASIuh3PdvIkBQoEUZgUOYSwaZrxaLSxupbmheO5hBCEEIbQZhZAEBmQLpOWAnZ6crK+sZHnOUM4sN0wDJXgo9m41+u9CKGeR2wLKO153jxP4ziu0oIQYhA0xpyenp7b3ZaSN01DEbUIdSipax4P+wWvRpPTQAdCiJOjw5vXr/Xizulo3OsNuv3Vs/F8EMbGmI3zu4PNlX/41S+TLPXdwLZwNl9+9OFv67qGENqeDyG6duHi2tZKniSz8WxtdxcIrWrZi3sQ06PDAxvCyWw8+WweRZ1kviAMr22ub2xuzvP08uWLZZX9n//h//CGAbLIa1ev/fo3H77z9i0EdZGVjNEfvf8DTIjR+gc/+MH4cPTlJ1/5bmhb7unR8c7FXcbY1tZWXZVFlkedOAiC+WTmeV4bf4QQGGPXdZfLZXuyNk0zm81a7zmlVKfTSZKkKso4iI+OjqJuVDf12tqKgZpzPltMKWYaqE7c5ZwDZBBCwBjbthfzBEJ49epVJWU75dP1/LOzMycOmiP1eP85NOZf/7t/O51MPv7oN1WSzZ1F/qDc2dnRWj/5+hFvqpOj06vXrytjGMFVXuVJGkURQLrl0GOM0zSllEopAQSWZX2Lsd/n0P8BH8T/7jLGEMIaKTBGlm0jjbTU6J9CenudBgAoow2C5y5eCKLQthkFSHPR9oIwREBpBKCWUnLRVDUkiCsBMNLA3L554/bNWxBCADGy7RpD7rDKaGOMbzk2o5RizmsANPGszqAzn0/3nj47PTwyCpRlef/h10VVO7YrG7mYLs4OjoEEDDEtDa94nhZEA2ogMXA6Gk8Wy5PxBGBkjPE7HdvxhFJSyraWowmalxkNvEWeIgSS+VwbqYysVZPVeS14EEeccyNVukjztKjK5uDoBBFaNnUnjrM0TRbL0WjUUpryLMvS1MKk3+kCqVxmMYRXBgNoNLMtZLNac2kkdZnGhlrEIAOUDH0PaKWVIBgSDKGSl8+fy5ZJHMfEYuDbVjjDZJkmx5NxKsWiLiBG2WL5+M79eplVRVGUtROELAzGeVIafnx61I3C1167VRU55LXKs8hzl8slsCxgWVleNGVzund255N7oR9jaj+4e//46PT4+LRIi9D19p4+q2S9fmHbiT3mWcTCAJssSxRQGmpIoOc5W9sbi3RxfHr06Ref/fBH319ZX+10u51O54//+I8xIVprhIBl0e3t7e3t7evXr6Z5UvHm448//vTTT7MsS5Lk7t27df2iBF2WJfhW+K69Nca0phi9Xq/T6bR5r+d5y+WyrbIeHR11Oh3wrYw7hNiyrCAIEIGu7xioqUXaqxJBGGjTjWLXshFClm3nyyTy/Pl86gYu9u1Lr99IeA4cUuimvz68sLvjM4YhUlVz9vSgXqTXr18PO3FV1//5P/7H9HSGS1nMlj6zVdUsp8tkseR1E8dxmwu0ZdiWhKC/rfpCZBD+LoHh99sw/yxKX1SPjQH/yDVMyrQlNgAANEQaAAM1BIC0jHsNCCFGYyjU3V98IrMSQiyk9DvR6WhEIQrD0EjFjSKuS2yrEnw8Hm+tbRRZroyGBlBAKCZJkeV1FXZ7juOU8zk1MAzDNE2N0symWVUu8rQ36K8MhlVeGWOEFmmalmXZCSNGqFbKpjYAABHCOS/z3HNcGxGgNGP2LFmWouGcbw6HSZKsrK8pBADQxphkugQY4dDVxhAAy7zARjuO3eJZCMkY82yPc+5bzr2vH6ysrEitxtMpIvjCufMUY9HU6XLZTp8y2w7j6Msvv+x2u9AAoHUYhnmeu66LAEQA2q5dG26MicPo5Oy0t7ZSl5VphBaSOJZSigFEKRVSNlLYlEmjNTCSi2KZ93s9IEQp5agurcjNyhRCs7u5szFYefjFHSWNpFRpQImNEFpkU8ex0vmi3+/deOO1u3fulIvFoNfP66ZRZrnIEUI2oZHvAYyUkSubK/PlrJEiDsLp0dhhltDKdu33fvTu4dmRlBIY5GArXSwffPP15u5O3lTrm2uizizLSpPq8qXrbUDb3FoDQItaGGPSKusPBkpyG1sHTw+++uJetiyapukPB37oL5fzvE7fev314Ur/+cF+WZbM8cMw3NhcB0DPZrMHDx689tprSqkwDDHGeVlsbGw0zYusRylV1/VsNou9KI5jBRQAYP9wL4haprTK83x9fZ3XglLa1hosy/Jdj1d8uVzagWeMKZfpoNvjWo3mU2I7URQtJ/P5fM6Y7WJmC5NO53e/eRZFkU1ZI4WhaLi6UlVFWZZnp6eUYo2NH/o/+tGP8jzdOX+urCtK6TfffLO7u22MIQy3pGvXdeuaf4fBC4D+1i7xu3bgvx8RX7mPjTEKKAgNUABIZCn27eQaQAZ864sAEDDIGKONAQC0BAatNSakLEukjEedOimv7F5EmEJEFmmCMc6qkrnObDYLw5DzhlISMsc32Kk1q3SH+ZYhq/1BMpvzsgba5IvEY3a/321bHcN+b7Xfn56O0vlSc4kMsiwHIWIMzJIcGdSqRrRqy7brNoJzKSCELrV8zHzLifygamrbdUbTkQIqK4v2JUJJoDQhRAMktVIQCK1aCdLA9SjCtagBgcfjMy/wj06OF4sFhHBzfQMhpKUyjfAsh9k2h4ZLkabp7u75puIUIoYIaCTSYDKZMNuCGLbWZq5rL5dLSmmVFUpISqnneVBqrIGQsihLBYxSSmMzmo+LonBdN+rEQkoWuBIBIQQvuU2o77qu5w3WVi9evSKllFWTz9JqtqQGSCCnxZz6jHnW/uHe5esXg0GIQ/bm++/88I9+9MZrN4hSPiNlkWEAOZd7e4d5XhXLfHo2q6Xg0CRZenx2Cgg+d/4il+LCxXNb57bcjl9k+WwygRgZjPaPjy5dufL67ddCP7hx7epyPhVSGgQxw0+ePymyvCpLjGkl+Wd3vmSuRR1m+07Bq/FiEvaiP/+3/+bKzetBJ15bX1/b2nzzzTe3drZd17Vtd3t7e3V1tdPprK6uthnKoNfP0wx+64rdRqd2XPmFlaMxq8O1frfnOW4cdlYGq0+/eaa1FkJEUdR2bqqqaprGaO0ySoBZW1uZJ/PR2UkymXRsRzV1o8X5KxcvXr2kiHEHnZs/fPfczrYQPJe1Hbi+501H48ePnxDHuvbW6/3dTeQ4RdN8/PlnaVkdHh5LrqTQaZoeHx9bltXmwAihNpi/GkJfcol+H6L/fOqrpfr2SwAIkbZ3SkDbfWmPbgA03+52EUQGIkTa1g2ltDvo5NO55AIpSAgan42iMNzb3ycUKQiiKCqKAmMcR9HZ4TFDmDqBRyxe17yqsec4lNXLLJ3Oe71O2Ok4liW5aJoKaBN5XlrkJlYYIdezjDGO7RKEO2EkueCIVEXZahRRIXzXxRARx2OYGC6rsnRs20jOXAcggyjpUPRsf8/3fYbJMksZY9Sxfd9PyiyKIs+x66qMHY9z3jRcA9AYBRBEjDqUIkJaxXqpuEWpNg2hTAhRV5Xne1LK8Xi8srJW17Vq6l6nCwmmmva9PldCSQEwcDy3aZrWcKmpKoxx0whNSDt8K7SCGBEIN7e31rc3+qen+88PzkYThojlOPM0k0Z7lldzAbTSWlqWpYBxYo8bpYVxKEMAjqej13/4hht51XJZ5gXGeGtjvUqWxLHcKGDMZgo+e/iQugQIU4mqbGrGiG17mBplDHPtzd3tPI2TdHFwcHTuwq6sBMNMar1z7tz6+qMwjt764AcKaosBpRRj9uR00u3F29vbQgguG2BMHMdZllmU5Xn++NGTH//RT1zHm46mH374G6XE93/4I89z0iJzAg9Z1A38tCgBNL7nftuGMWtra+PxuN/vt3y6to+aZRljrJ1HsW1bNPzx0yfXLl9pNY1bdzyCqDFaa91+hrquh8Ph2dnZcDiEBnie14oWLNN0tlgYYwghN27cQIi4CNmOVxTFdDRBCGGLfXb3K9t3dqLdR0++kakGSlNKb926dTQ6nS4XGphBb+i41mwyTpPk8vkLGoLnz597bjCdznd2dgAALdseIWTMHy7bvkRmW8sAr5AB/7sJcAs9pRRBBuhvJ9dwC88W0+1euX1vDQwwtm1zKRmxtdLAwDiOkjTd2twsRFNyAepGKMmbxmFW7AeAyzrNIbMwxRBi27OkEViITuDbnXDa5LQuRF75hPjUappm6MXJdOE4NiFESrmYjB3fW0yXgeshYPrd2CjNfI8grKUykmPGkDZFnkOImW1hAyEywugyTc4mZ1LK1cFQcnF+Z7eu66jbyYocST1djKvAtRgrVYkARBokWSIQwIwqpTbW1qfTKSU4L1LPti2MMi7yLIvjmEiGNE6WS4TIcrlktiV5U2spBWjqyoNOWRadQT/Jk3I2wxhbhDrMUhBppSDQru0JIbI8RxZFlFZN1VsZaoztICCE+T5ECNd1rZR0g6CqysnJWXcYGQvzpkIYlFp+76cf3PnwSyNNaXhRNt1uNwi8L755cvvmrZODw8nBaTFLGqkuXL7WNPx0fNLbGr77vXcMBMcHo6dPn89HkxpAizFK0fs//TFmJMuyX//i519++tmTBw+FEJfOXYr78f7+vpR6dXWdEUsCrpT68s5Xu8Nze8/2p4vw5ms3hJYGgJPjw42NjfHpWDbSdfxz585pYzDFw7Xhn/6Ln+3v76+uDjFBxUnRUj4BxK7rtv/Zpmksy2ovXmmabm5uIgSEaDDGjJGy1BZlnuO2mz2bWU+ePDkZnWysbiCEPNtLF2mn0+FSGQU6UZcwzDnPsmxra4tSqqXK0/zg+Kjb77ih3+l0hBB1WU0Wc6A1NKDXG3TdgKflx598/MMf/jCOgvvHD7Mkfe+9977++tFkMgMApEU+7A+EEEWZNYt09Hy+tbP9xUefTA5Pr92+qZS8fOXKZ59/YowhCCuluBCO47Q1XvPterVHal4hNrQ58Hey3FcXIlhrbYAhBAFltOAUWd96gcMXDMH21kDQ2q60RokIIWA0s21lNFcycAPJRZ6kjmNLo40xaZqGvg8AoQAt54tuEM1GY9eyjTGQEcxMliUY4zIvOlEMCEUEL8dTUVZBFBmtKSFN3VgOk1LyunEcJw4jjLEVkLaEQAmpRYUhoghLpYll5UnqeV7QjetGFJJjh2mCkmWqlOr1elrIdJn4ris410oVaaa0Wszn2hgldFos7biPCcqKMsky4tpa8H63N51OHceRSriu0+1ExSKTgm9sbS5mc1ELz/MC16O2VQvOGDubnHmdKM9zDrUoMiklSLGBYHVjHUNULhKttUGQUFqVGa9qriQAgFJa143tuZ9++un3f/x+WVUagbwqGaaUUq0kULrf6wEA7JBeun7p7t2vkiR5/e23oETnL174+sEj6tkh03/zX//bcDDQgqfzZGfn3F/8p/8ceREi+Oj5cSPq+1/fW10dQhsZbbZ2NijBzyFEiKRZNuh2KcbAaGoR13V5XleLgtrWb375EfMsSmkQBK7rPn/8RGO1vr5OAPrNhx9hSMJupIwhEEkpXctdTGfvvPX2bDG3EOz3+8fHx0HkA2Rsj4WRh7Bpc4d2XNaizLHtpiwAAGWWP3/+PI7j1dXVIPAghK7rGmOKoqiqan//8K233mp7M5xzy7IcxwEAtN48tm2nadrr9RajRafTaYlxhBDLslrxDWMMc+xer6e0tG1baq2MsRzbcRwCYLpMjvYPPM/LlumPvv+DKI6PTo6Ha6vS6AcPHhBC3nz7jdPTEYNYS1WV5bAzCOIIaCMq8YPv/fDTTz+13Kf9teFLPkMbP9uJUAh/p19qXvGeeInJtkAI/pBg78ultTZGAagBaFMMhCF+gdIXSe8rCbOU0hjTvnfLGw6CwA38J19/s7225VHLYY4WElJMMaEYt/W62PVj16cIu64riwZjrJCRSlFKtNaQwjxPqaiJxWxIEKUQYkCo4NzyfUCwS7HkDTSAUaq11kYTBBsllunSohYjpJLcYowrEQw6AMJZmSdVldYlV3I4HE7n48D1kEIEIj8IkDZYA660NAATRhkzWlONlDAYkNlikZYVsR2EsGNZK71+URQKaEpgGEeiqRteObatlFqmGUHYVgopU6e55TocQj8Ijqcjg0Cn37EQ0ZITgMqyLKoSQuh6flEUmBGMCUEEAeR7AZcCIWj7rJaiLOv79+4tlktjoBeG+XwZeb7mgheNMkpJiS2v4g0h5PT4xHPclZWNu4++xraVZwnGEEpYLIvAtu99de/2m29cff2Nr768PxwMvvj4C2bhn77/QVImrXc7wjpPluly0e8Nvvf+9+/evfvJRx9ev36dhl6n08tPF1pBC7Eqr1XDpUWIbQkhHj149Kf/4mea8PO7u5Zw/vIv/0o7OOiGa92+Y1vjhm9ublZVjQBSXCyrWZYnq7APEazrpt/vSl5LoaVoWqsoLdXZ8cn45Nh1XT/uXLp06eDgACE0GAyKomCMtJXe5XK5tbXVshqEEJZl1XXtum4cx8vF0nXd/ef78/n8+dPnnV6HEEJt6ro2MMb3/dFoxBjzfR9h2u330vksmS36w4HNGOe8LEsMkeXYfhwJzrudDmPUcuzh6ur6+jrFsK5r3wtHp6Mb166GYfzJJ58MNzbqpjoZnQHcCqyI999/f5HMZ7OZMWZ9fb2ua9/3W1n5l5j8p3h/LbBbDsJ3/vrdlqlWGCEDjZQCGQgAFkq8QCn6QxtahBDCWEtltFHGWA5zAmd9c6POi4BYRkhIMAKQADjo9CBCkgugDTbAtu2TPA8cn0uOtKYMQwmwwVVTu7YFDcTShJbTYNLyPF3XRRgbBNM0tQmxLYoRyvM8iMIkz6qqCjtxVVWFbBxmh5E3DMPJZFIUhQDqbDG2/WB9fdNo3X4FCCElVRu4iAZCIEyQBBphEMWxbtSyaFRfE2oBWEttoBCEIAXMZDIOQm91fb2s8izPfM+uy0ZpyDnXCJdNTSDCECkuIAVrq6ujxazWomzqSVF4tmUb1OoeQoNG0xEhBCiBIerFUV1WoqmpRefTWdSJa8GVkZxzCABD1LU9yarWmU5qEEWdr59+U5bl+GwyO5vHoX+0d7j39KBppIUIgaQThjWqCcau7fqx3xsMB+trQqL953sYU17Xx8fHx6OTk/F4e3t7fDw6OTgUogEU+aF/+/XbX/zmN3mWFIvZ4f7BpUuXJuPxoigwww6zOW9OZ2fSAIvQOq+skGCEV9dXfvTBD42NT07Ont57JOsm6nXXhquy4b24I7RqmmZ8PMqSdGdnx7ZZ6PvGmKJK1tbW5vMlY8y2bcdx1lc3er3ePE8RAlEUEYJa3pUQQik1m82CIOBcSimXy2VbDUqShFLqWja3OYRwZ2e71+tiSrrdroZASp6mqTIaIdTq4yGCEUSI0tYd7+TsrDfoM0KDIOB1U5blyvpatkyO9vY1QBwZAKFq+LVrVyGESZJOJpMHD+9funRlY2v9+HRkIGCOrbWcTqcbGxuHh4eN4MsiefrkCaV0OU981zNtI+TbOdJXa0jfRlT4EqUvrSv+mU3pi8QYAIiQVsYYgzB+Mbn20ifmO5KfL3pBBjBCecXT8ezTv/rlTn9dVEIp0+320iyjvr0oEj8KD49OBoNBmmYtnZrzZj6bua6LAVRKL5fLOI4JwroRCCHq2o3gBkIlhGc5ymhNkBLSRRhDpCnI66qVkIYQVlVVNPVwY+3qtRuz2eT08ChLUqg0o7bBuFbKdW0jFdBmuVggA1rvQNVwC2CttUAGMepYdpFlrhUsl2kjOJcSQD2ZTgfrQy9wKUOdKNa8IYRkRdUCXgs9OzkrkrzfH7p+KLWCyEjeWDarlGCu8+zocLC15oS+lBwLmY1nsRt7tltzLqWklDLbgq0EuVJt68UNvXm6HKwO1jc3TveOF0czxXUDBCJYaIEJOT07UUa/9tprl85f+t/+3/97r9eRUEitsaYQENu2BOdaGcoIQAYycO3WzW6/9+Xnd4/2D8LQxwQqaKazcRh0mqr2fFeIJkkS23X+zf/l30EI/8//7X/f3d09OhtprR1Knh/sX755fX1lffLsyAgNLXo2nfiet7I2eOt7bwogsyyTyihgHt5/ePT0sBOEAJg4Ds9d2lnf2EDYevjw8a9/81Gepz/7s59evnxJS40pTsql4ziG64O9QzfyCCSgUZRSvxdkde66PkLgZaNiNpsdHR29+eabkoskSQaDQV3XRVGdnJzsbO6EYZjnacuC4EpyKSyLQgg1+Mf9XtM0rV97W3MiCCOEGsFbWTwpZRiGbQnHqNYuIIu7HWNeCLK27AApddM0x0cne3t7u1u7i8WiyPIsyzCEjuNsrm8lSaKUePLsaRj6H/z0x71+BDGqeIUJAQga06rKgXZiDLxoe/73jYl/N7RCCA2CRrXH0tCG7rex9OWTXpVu0LqdnVNCNoIjhnqD/sWLF5bHU6AhIxbURnCOJQ2DQHDRiUNjjO/7Qoizyfjdd9/56vMvGCZAG8u2TKAdxxEND4JguVhAgikhXArHcQxXNmO1lsyymrxgjDnML3nTlqKTJGkE7w36W9vbf/+Lv18ulwwT33a6fggMysrSZk46nQMANjc3EYS8qIoktV2XYKyN0cAgBIGUlcyjIFRCR4EvjEKUGKm63RgyhCkeDHq8qSSA47OR5bjUdZUyGnBqW4zLKIoaoWolgNKuxQwAFqEWoa9fvzlazL6+cw8zfPPyZdrtmlyKqglCP81zhrBNKIcaQWxhZzGd9fv9+XwOCIrj2GaOUUA03GGW5bmHo1PLohpAy2fT6fTk5OTqpevdqJumRdBx+r3O6GgOtXIih2AMtUGUGGQqWT9+/Jg+p1VWBr5rMZaWhRM43d6wzstbt27tnN9aLGZ37n4dBMHx8enk7PTKzavndna3L56HEI5HpxkvfvJHP5Zc3b507Rd/94usqbqDflVkk8n0w59/tH1hZ3N368mzp8fHp67trK6vTkaTbie+cOHC/Xt3ESRSwb29PZtarNvfXNsqsiKKokY0i2QJoWGAaa0HgwEAqJgleZ57KEQISckBAO3oabsFffPNN5umsSir63o8Hq+srBDCAtc7OxlRTNpkuGxKIYTl2FKrtgpjINZKEYTa9BghlKeZ32oyKuk4Tls0aTlPbc7Z0sIaUb+gIiCjtWaUKaUIIxBbm1sbO7vb49NRVbPvv/ez2Wz2+aefWpb16NGjIAjKslxbWQUAQG1aN402kiGEXw2h37nzP4NSA4CR2hij22mbqqpfMgRfHZB7cYV7qZL0UhgCETzcWEsXCSVOlVcSGGIxbDMFFGWYOVFR1tJo23Pn8/n9+/c9z4NCCcWVgYHnI4whA8aYTrerX6hGQAYwhABr4AIECTGOU4sGCS6llrKuhPA6nb7nurbzq1/8Wijp2Z5Samvn3PHzfYswiqjNmK4sDUFV10mS9Gzfsj2hFUSoEQ0AACljU4YxxsbM5zPP8zAhk9FZr9tlBDFm50WWjqbAmLquLWJhRLXQvKgAANh1OmFQCcGldH3v+d7Tfr/rug6jOF0s0SyhCG64MWQoncy6UcyhQhhWvEYEiYYjABEjGkGOTTDsS66S2VJAc+XKlS8/+3J0erYxXJ0nS101eVMYHDiMbG7tXLx05fnzg1/+5kO3Fy+bUmpUVAJCWvEqKVLEQCfw8zxXBtiukyS553lGKs1FoRTCqCob5rDX3np9fWMIqOqsdjfmm7/+xW+ePtmDSF+9ck5BGfR8Ru1ePxKiWY7Hw/5aXTSFrGbV3IZW1Ambsjk+PE6XOeTg7qdf/sm//FMvcBfpQkp5/879rM6FMoQwRIECyvYsSrHnO0LwJFnO0mUQ+o7jIIWvXL10dHba7fY7/R4kmBASRZEQQkp5cnLSZj2O42RJGoahMXB9ffPRg6/jIKaUVk3Tnrj9ft8YgxChFB0cHOzu7raqexjBF2VOCKEBBGFDTFGVLWKlVphgAEBRFEVR9Pv9lvAkhBoMVlr5aIwRhDDLMt/32/SnMk1dlm7gHZ+dKCCD2L/1+q2vvvqqP+xNJpPAj4q64JxzoxQEEGMKoNQKQqhhS6V5UdRFwPy+GP1/D5/AQGSggQhBAKQyxhhisRcZ7++uFyh9odGEEDQvQKtr/tnffgS4otDqhB1dciG4ooBarK5LpYzl+WmWt5mMZTHBuW85FmOi4o7jlE0ttWKEGqla/LefTte8qirbtTVBmeCEUdHwXr/rhgGkWBkzW8yfPXnKCBFKKaVu3LgxOjmzEZlPZ34YOZYtGw4wQjZZLhYrfowMMAhSiykltda8aRgmzLEVF01TSSm9KK55w2seBEHVVEWWrw36bXaEbeaEUZ5l1TJXSjmdUBqtS4UQ2j5/7qOPPxKyuXr1klIKSAUK4VpO0hSW64yTWRQEHrVEI0vJIYQOsYzSGphaS+TZjuPUswRDWNZ1UmZV3QAMtjbWEcGVUFXZ5Hne73XefPON6XT65OkeQgghkuc5hihbZqEVMcdWTFAHiarc3d0ti+b4+JRZDq8bLXm3G0NCGyUBRoiina3185d3JGqAIXd++/X+s6OiKAarnRs3LxKb9AcrQAMG8ej47Mn9h+cuXDydzLKmvPXOzf3D/aO9A1Vplzj5Igv9KM2T195+bfvCVlqlXuACDRmz6qy5e/duzatK1v1+//nz5++8/uZwOKCuXYvachiEkAJSVdXpdEwxW0zna2trcS8CyLRk+rZQ1CaHVVFmWTYYrBhjgNJtI7TT6ew92y/L8vrNa57naQiMMRqouq4dzzXGtLhqa6cIwKIoHM9tizTGmOVy6bouhgghlGVZy09q89JWJkIIUddlW6ddLBa+HwohTo7PLl68aDGGMR6dnEkpiyzXWjdNY1uuUPLp06fdQffa9avdfkcZ2TQVpRQSbIwx0rQ9EQghNBpj/D+IUvOP8kgv9FkIQcZAoCHWv8u2/3ZpAIAxAGMIANJaG23azIQwtrm99fTBY0hgkiSR5Q2Hw9PxqTZ1YDlJmhsufdsmiHDOgdIWwQaC2Xze9cMiz7gUtudalBiCoQFCiKqqoDau44RWWNW1MsCiFFF66eqVO3fvTh8/bicntNaB6yGEXIwcx5mPpqZR2GIr/RWAEbVYmmfZPCOMdeNYYVg2jZHGBtqB2DTCsq22g1KUqWsx13HzMusO+rziRZYXRRGFIUGUK0Ew5SVXOpFSFmnGKO07QZZlLPDzuhqPTuNOCBCYLeYIISCVownnHEozn0wJQy39hRAS2K4GpuKN53llVnTjTiGEKLlspGU7sR/N53NmOwrIy1ev3LlzJ1mWSmiL4rXuCpXg+cNnCII0TyAl3W43mSyarKgbDIzSSK2vbBkdpmU2Op00XHpuUOuKOXZalH4QuK47nc+uXr+yubXeNI1lU2CQVryqs+FK/+133uz2QgDVYjE3wlBADx/vVfPim+qRCdj2xd0wCm7HN05PTn7ykx/5lne8f/qrv/kFhuiv/stf/T/+/f/dYPXgzt033npHGe0E7u7Fc0+ePv7+O9/zo/D111/7m//6V9vbW1wpoeRob7S1tdUAMZnPNjY2jIbj8ZgrgQg2RrXfUptMtR2EyWQWx7HiQmuNEOl2+1VRfvPoGwPB1evXWj6DhoBSqqS0bbvIcs/zbGZJKTFECKIWjQgBrY1SAiFEKWaMtMzYTqfTNM3h4WGbfrd5IkLI9/3nz593u90wDIVQcRwTQgDUXDYMscHq8OHDh9evXm21YyFErh9evnHt8eOHtucKKZnDNNTGvADjizapARAA9D/A2v0DcFWaYKy1VlIiSBBARpk/GEtfXQgAALRpk3gLE9KYR3ceHj7Z7wWdJq9Dz9dGai0hhEIrSJmUGirgBK4BgMsGISIajpV5sd3HyCIUaIMMMMbU7SgdIUopYrFWMjjsD57uPz04Prp47nyyWMq6kVIGcaS0NhDYth04gWgaYqBSirr2ydnZlStXvvrqqyAIfN+vy9y2ba6kKOvd4SoAoAZKAiOldFwrS5auZ0uhlTLIoPl83u/3fdcDXGohOeeQEYkAsZgsmtgPGCbz+VIDhBiVWAMKLc8GGAzXV9Z7K+nx9Os79xlj8yxRDPUG3cnpWWC7jFgAwQZoy7EX4xnQxvH8qqqS6fza1avJdK4wlC4NOuEbr9288/kXTx8flkW9vrHaVKXN2GKx8KK4kvVr77xxeno6O50gAQbx4Gx80tnqvPejdwEABNHZLPn1L37V1IJSy7Ztrvjq6mqe56PJWRxHcSe8fvNKqzYcx908K+fJsqqK8xd2GcYYwMV0/ttffWwTm2qQVplwsSLmjTfeSNPk+Oz4/fffJ4QxwD76uw/vf3lvdXV1bW3FDuxaVa+98RqipObcGF2WZdyLldFAm/nJ9O7du7tXL+6e3zk+PInjmFJIGJ3NFnHUVUqdnhxt7261QiQtA3a5XAaen6ZpEESEEKjbMCv29/fzNNve3WGMCSGEaFZWVgyCRVEAZFomYCulrZRqj8brhhBCGAboBf29LSlBiNtz+GVxNU1zrXWv19Naay3bYnIYhkmSAQDKsuz1eu0FVzS8rmvfD6uq6oQRJHiZpH4YHB0dGqM2d7aNUQaotlxkjAHqxYwohBACjf6HYyl4GU41JKTl50qtADTIxu4/N7ra9nhaoTStpRCi5rxBhriW5di26zhRUChuIAQY1aJGjLbNZYRQWZaA4krysixd13U8FxEMLWp7btnUnHMAAGbU78Y1MiBw3H5ntJhhmy2S5OjkMKtLLwqTMnc8N8uyKIr8IKiauhWL0MBIrfOqfHa4P10m0oCjk+P1zQ1qMWMM0LCpeJqmGsMKmmmZz5IlwIhRmmUZsKkksNPrAqU1BCsbGzUwNTStmG7rceaGAbToYG2ILZZVJaZUa902yuJOJylSFjrxxkoOlb/S8/qdBkGnG7FO8PjokARubZQGpqoqiJEyen1rc2VtlUJAIfBiHxAoJe/24vd++D2/G//Dr359cHIW9QZr21uQErfjQ0qiQW9RZBeuXRnubNx673Wr63mrUQoyfzUseS4kp5ghRLrdbtiN/U4QDzqA4G5voIwuqjyOI4xQlZb/8N/+4a//299BiIXRkpiVrQGyEUAAAAwkPdofX7hy9Xs//sGtd25qqouyPtg/+eyjz33LdZiFCFSG17oMVyKn40GCT0bjp988P3h6uJglQGklG4sRy6JSSozbhgMI/ej44FBL0wnjyA8YY4SQbrdLCGEW2drZfokfY0xLwbUc2wt8ahFEICS4Flxrubu7vbG1qbUmBHmhRyyWFvlkMhFCOI7nOJ5rO6LhRZZLLnjdiIbzuk6S5JXUEba70Bd0HwQBejGbEkVRt9vN8/yljq5t23t7e0myCAJvfX1ViEZr6TgWtUhv0HU8O+5GQosszwmjlFKMcZsOIITalBt8Z0y0rQL9z1SPXvRsMOJGCSURxpiS9hT6gxnvi7dplV2UUkZprTUASBkNoYn63f0HTyeTCTBo0O+qmud5gSxcNbVoZL/Tb+pWZjKzHEcWjRQCatNIoQxMijxwXAgRsSxIyShdxCv9vb093/UGa6tFllOLCSljL6h4I+rGcvybN29KKbmSvU5XIRAEQTJdhn4wS9IwDNspiiRJHMcJotCirEjSKi8kVGEY1rxxPNdGLkIIQxDGcabraZKIUnV7fam0gggBczqe2FL7zPZsu9SiqCts0Xma1HkRBOF4PqnLpmma08npZXLND7zx2Wj93A5DlEsxGo3iIK40ryuxsrZalXmRJwWs4iBczhdrG+vZMqGY2Lbd6Xe3Ll74+Le/4VpAgpjNalGPRqOO31ksFisrK6VIHcyyplhdXW+UPjg8vHD7EoLED71u3Dm3swWNPj07efrk2aXdy5blIIKHw+E3e8+y+cSlnpJSSKW1Rojato24dqmb1VUUdvZPDkbj00sXLjy+//VqPISMjM/mXz/45vzV3Q2ig2F0+83XqR0/398zWnTjDrXZcp4MBr08LyEB69ur7771fUbY02++efTo4Se//XRjaxUTdOPWdYyQEAJTIqVaWVmTUhsG9vb2ikXx+luvAQBabxUAAaU0z/OmqdohbyFEmqYrKytCCNu226s5hJAxluSLfr8PIX769CnAwDZ22w5tqbyt0rJrWy86K8aMx2NCiGNZ2Xxe17XtOm0JhzHWTpm/xE/TNE3TxHG33YtKKaV8MYNm27aU8uDgwHGcVnOs3ceWZel5HsZQYbRM5llaXL9+I/SDxWJmlDDGYIDEK0h7tcBrjIH/7BT47y+tNSYIGGCMEUISRCGE/yRKwSusCP0qox9qROB0MhpGQ9u28iRlCHueV4jKGNAL4yYvLb/VlSfttr6umtB1y7I0iET9LoRGSjmpU8SRgirP0831DSWkZztaSMe2izQDAMR+hDoEIdRwfnp6Evh+t9drGl6nuW1Ro8Tm+upykeZ1o4Bxok5ZVQbBmjee58VBaJCxKJWca90wzynLCgBgBAIu6fZWQtsbdodHB4eTySwti6YqLAP8NT9vKq6k7dKmKhmhkqKlaoRDtFJASyKJBVCzyERT3PnlbziXvqax62ezhRt5PqZFUW1sbd9b3oNQY9fytE7OJoxQbRmO0YXdTexZl29evfvbTyeL6UadBp5LAIJK25RpLQiFo+kpM/js+EgBWJfis48+YTaty2pw4TyEGhO8vrF5/97fTA4mEKDhxhogKAiCup5I0STz5q133/n080+KqlJKw1JDCG1qffrJJ8enRxfOnd9/8I0ryYd/++uq4nXKCUMXLu1qojkww421v/+LjyilH/zpD7GN5ER9/unncRzHcXzpwkWKCQ0wQfjq7WvYop99+jF/XEvRJNPFPE/9Tnj7jdcD10cKU8x6Kz1D4KcffnpydLy+NYQYp8sFAKhthXi+hylBCGCDYhLlZWbbdsuqaQfWeMOlkRWvECHdQbfb7TZNk2Sp53l5WRhjBr2+1hphwjmHULdofPTo0btvv726uvrom8cAwbW1tRZpk8l0c3MTY9zOmsxms06nk+epbdsIQUrpfD5dW1vTWg+Hw1bTqKVSAADaS38LV601s6nrur4bPHvydP9g7/rNawhAALVRGoO2wgtaOTv97fz3/zRGASAAQmWU0gYAigkCCAqN/mBQfpUbYb5jTo5gVhar25uIQKWU4zjEpojReNiPei+q6lyrRZFVopFAO56PMa7r2rbtxXL5fH/v2eH+yXSsKQIEeZ4HtGny0mXW6OxsPBqNT88YoT6zkdRImTLLOedBENR1DQFoJ4At27Zcp6iq8WwshCCEYIggALLhRVG0OixKKd/3KSHGmKasWq2NqBMni/T5872Hj775/O5XaV5orTGABOEgCMqyIBYzUBNCqqbOsowxYjnWLJk3qkEYx3HsUCukdoe5qJEuZkrp6XSqgAEAeJa10uvnVcmNcsPA8TxqW57nUUJcxyrrYpkmBupSVFbgMI88evT1fD69dOmibdtB4BZVroH48R+973c8pfnqYOjZjqz4+Pi0zotvHj1cLGeLxeJv//7nWiHBZV02ZV7lac6req0/pBCc291uquKDDz7AGFNqIUyjsIMgSZbZrRu337z92uXdi4vJQtQyWxRSSt/3T05HdSM4hIssays0kCKhRKfTQwA/f/j83NY5ApFSkishkWw09wIXYzqbLYBCySJ3LPfk5LSuGqPhs2d7k8lMCFFmxfb29v379w/2jxaLRafTCT0/8oP5dNqGVq0BQqgNqm14LIpiPp+3znTdbvf4+FgIMRgMWsfaIAiEEO282GQyaRlLLX0XIRRFUb/fH4/H0+l0fX399u3bQoggCCzL2tjYGI1GSZIIIabTafNtayfLslbPpU192yDWMoHDMAQAMMaGw2HLH55Opy1QXde1LGttZXjp/Llf/MPfKyFfbHe/pUb8T0LyDy8IISbw5dUBIUT+Kebht3cRhABC8DK51whCm9XITGZjBpjtbWMMBVKD/tC3vOdfPTTSRFvrWtZpkfKiFEhSCIAyZVX4vq/qohI1RIgxxqs69AOujGs7yXwJhAodz/M8CEAjhdTKJYzalCFiey4AoFbSD4Oa87JqOo4NKJbQGAyAkh6AFsTHh0ee562sxwAAbIgwujEqiAKKMFcSU3zv/n3L8zAktmUhjRrFMSG2w3zHJlJCpRxmVbxqlIi6Eai4USZy/ctbu7wWvKzWhytQqXSWIIr8yK+NOllOECSKV0YQp9Knx3ur588xQj3LfvbkybUbN86Ojh0A8zwfj8eaAA4VJpB51sr62ixLNjbWjr85LJvy3KWL5y+fW5Zzqep3f/hunfHPPv7KKOC7AaX08qXzk9n45//wS8Ysrcj66ub87Mz1PYZJURSIAy4rguDlKxcwIZhZ7//wg99+9DGAANoUGgoIWiwWz57uPXv42PWDvFFhr4MhsgNvPJ6dzSa9tZXA8wtZmMJ8/NWnN2/fVMIc7h/5lne0d7iyOVxdXX306OveoF8X/PTgBBOytbWNIcqKLHDsW1u30jQVtfjyyy8Hgx4lVy3H1sL4vv/N48cGgA8++InneYLX66sbR4cnK2vDKIo455RSilld51HU0Z5q60BKKQNBb9DHFCkjEUIAGYJx0+jbt2+WZRl3O5PZtNvtKqPbZJVzvr6+TgiZzWa93oDXIvSjumwcx1JKrQyG7QY1iiIv8I0xjFhaa9u25/N5N+5YliWlbC/3rf1CqxERx/FwOIQQxnGc57mslWO5TVNDhHzfz/PcGGNRJqQkhAAD4O8yBDUEAP6zmmV/cBEsjQRKQwQ0ggQiANA/HuRlN/YPIBvjViutrWWFnfjitSvX37iNCUEIWZ6rjI7jGCF07sL53sowK/L9o0PLcngtWmsWbhRzba6k6/s729s729taSCllkiRlWRZZzijFCDm2DaRCBjDLghi1zp9SiDaiVk29zLPJbNoIvkgTCOHO7vnz5893B32hVVXXYRiuraweHBxACJM8K5u6JYtIYEreHBwcAG20VA5lvu1XVQUBaOoSGoChcWzL910NteM7W1sbt2/fVkoFrpct5gSAru/1406ZF20WxDlP01QL7Tuu67qe59m2raTshnHgeqHtTo5Pe53ugyePkWc3QFd1vb66QhHeXt8oi2KwurK5teU4TqfTIYSUddntdw0BXuxLYEpR9Vb6K2srAOrx6Rk0oN8fXrp0CSEshLKYm2elVKaR4vT4DCpsQ1s3qmmax08eUdtq+9thGFKXZVXeygjlWbW/f7hIUkyJ41Ku6jRPPM+zsIMM60W9+XyeN3nQ9W+8fksBU/Nm9/w5x7PPzk7u3bv3yW9+G7helqS/+MUvRpPxzdu3Lly59Nb33vnZv/iTixfPX7tydWUwWF9fD+PAwG9PJGz2Dw/CIH77zXe++OKLjz76aHI6MRpe2L1QlvXJ0SkhL3okT795wuvGfOuw0p7lreQKAKCdGWh1kgghlNL2hJxOp+0msFXfbhukcRxrqQAAtm1jjOuat9S/lkLY6j+8pCUKIbrdbpIkLcXHdd2WUVxVFed8Z2enPX5LMGynsYVomqYyRmVZFgTB2eik/Zz/TJXIvLL+R0CqlNJaA4zAt5oVFW++nVx75SgvKtcv7rdx9VVzKEAJHQ6HW/216d5IKZUlKSF4dnxmESuZLKqaL+uq54eQS1nWFsCMWJXgjmtDKGvehMqpyzxN0yAK86byHZcLbQHMGBNlTSHS1FSCQ0aMNrziGKJBp5vUpW3bk/8/Zf/9JMl1ZgmiV1/XoTNSi1KoKhQ0qFU3W4zenSd239u/79naru2I1/OGvcPtbrIpmgKgAApAaZFaRYZ07Ve+H25WEQRActoNBouK9PAIy/QTnzrfOdPZeDqlEDFMBq1eEARNViAIFDaaQ1k3RVUyj1trlwdLi9l8vsggRmeyDOJoMFyy9iJNM56w+WJqjCkKGXIPY9hNkroqOt1OXhZWa9mIbDpHiFSiSdptBEA5yaE2FGEeBEI2jTGcUEpIzH0EMMbQKN1utStV5+cXG/1BvLy+f3ZCQq/CNo58ZUxIfQvBvQ8/qa0YrCxrCw73DnfWt/f3Dxljo/GF3wsRREmS6EbMFjM/8rnPOPPLsv7k/sd+6A36Kzs7V+9+8PHpxclg0BOlQBo+vPdgZ2eHIAoQera7v3llx/OC99//5dnZaDDs13Udt5LR2bnHQp9xP4z+4q/+vBbV6dFof+9kfjEvioKF3srXesv9DtBNbzAgEAGMcMx2bmwP2l3f98/OT72Jf3XnmjGWI44RXVpahhCGoa+08OKlLMtm83mSJO1uHIZhWZaQAOqxf/s//juoTBTFX/nKV+/du/f97//9t7/97a0rW6vLa7Ju5tNFFCVNU928cevo4PjGjRsvA5qxNk+LPC2WV4ecc2UkIjjNM5f9IoTa7cQYk2ULt5iCKUEIQaPqrEaIYEy1NJ7Hx+PxQkpn9+56VEEQuKTajVaVUosspZwFnu+o8HEcZ4vU5x4wNvSDxXzR6XQsBAihwPO11iCCjLEu6r/99tsrKysQIfdCgACAABgELADQAAAuhYo+laq+bPT8EZQiAACAGEILjNEGGEAR/mPdo09h9VNSaMoQQjChQJgkSU6Oj9rt9srq8OLg2FrIvcAi2I2SoioCn22vb0TUL4rKUZ+jJLYZqJqaU6ahnaTzVq+7yLKEBJUU2Il6YkIZq8vMDUUwxlEY5FVpgZ2nGSJkZ2enTDNR1U55rExzFvgME+15HmVaqk6rLeqaEFLm+dryMsIYhPT49ISE0db6RppmLg77Po/8IKCcUFyWOYBmms4pRhDaYpFOxmNXn4wnIyAtVdDnft0IHvgGoVa344UBgRiySNYNJNBYXUuhpCQWXBwczzCmURDGnjDqfDa9OlxrRjMAgO/zLMuv3GiJRr3x2pv3P3kgihoSfHp6un3zqlGSYg9iwBL+6METadT8/Pyr3/hqf63nvCGfPX72zW9+87fv/coo20jjMb83GM7TNO4knPh+4nt++OOf/OPZxZkXek1Th5HHCFleXm5KI4QAUP76N78ZLvVv37yRLqpHj54iDa01j+7dbw9aVVWenJ0ESRgEnlBKAklCaiAIkliPLoq0VEotD1fDJKiqSlsrrMQMGykow1qrg4P9qBWnaboCzbNnuzdfu8l9lo1TCCGh5PatO7Oz2S9+9suHjx9/57vf9hhvRS0IEY0SJw7sglKe5+12++TkZDweX7t2TTaqaRrmUQBQHMdKKlenYeeUpxQAwPd9pZTWGmOUtFv3Pr7fjtu9pcFkMnOlqZQSEUwpVkphSpwohFLK8ZDcPm2R5S7kLhYLJ0Dh+75D9fHxcSPF0tJSFEWUUmuhBaDTaSkjLQAIIUJIWZbk96FkP7XL9pko+sex6j6G1hpAay3AmFBMX176i5kSl1cEL8yhjMUQWmOm4ylDFGDU6nYwgNU8izGTykgEEKGgViEktpFKSm2JkSrxgmmeHh0ftnrdyqp0MiKc+WFgEaSUAmMxxgDBSbaIvRBUFWaUU68CIi8LaW1eFFldhnHk+SEAqG4kocwoUda10jo9H62tLlMMvNg3Squ6QhCJshwOBpcagqIatroWAgBNr9dlPocIM0rqvPADJpS0BMRBqyrzfr9/en5GKfXCIC8qozQnFADtMQ8CpKBARgMEMcZ1UdV1DS3qdLuFrqWRnVZycTgZRC3eapVK1UZPzs/agx5CRCitLLBKg7KRQn9895OqrhnCiR8lPNEILCbp//k3/+fyyvD1129TRgEAy8vLe3sHEKLR5Gz5ygAQsLKy8rOf/Ky6nrdbcXqRckiUMsz3sjofLWbdXjtflD/+8Y8NBH/97/6602o/+O3HZ2dnpbVpUbaDrkf8eVrvHZ1cnI4Onx89PdjvDVY4YkWRPXr0ODjhg/WlqBPn2SLwKfdJMkh+88kHr736uh+GEGKt7Ae/vbtzfcsL19Mq7fV6dV1ywCixppGU4k6nHUb+6HzsBd7x2Ul72FoerlZVFfmRQbiqKik0JTydpX/zn/7Ld//szxb54srONSmbpmmsNZPRxCmqZPOs1+tRRDnhzGcA2aLKXa5LiAcAqMuqqiq3B0IYbaRw01ptDTRgOFxhmD5/8nRnZ6dIC5AgQpASkjJuDEjTlDGW53mv17PIcs4DFUwmk16na62ty8o1dR2j0O15b23tPH78+OzkfOdqiBBECJ2PRr1uO4yjNJ0nSQIhJIza37f9fpmB/nMPaSSE0AKLEYIIWgPKpn7huQbxS4h/GvoveMOXKLXWMoSl0HUpfvnjnw+jrsxraLRPiYeI0CoDJmy1q+mCYOwWC0XZpEVugLUQZKJqtFxeXyGcUY8HQQClTsfTapoFnk8DTyllhdZSUc5mizmm1I1GAEa1aAAAhLHNzc3R2ZksRb/bm09nGFNkQcz9ssp5HHqeF1I6uRh3uu08zz3KIIEAQeqzWsjZYuF5HvM4Qmg+n0eeHwRBXdc84MiC+Xwa+5F2dC9EAEBVVfmURH4gSjlbzEshCaOtMCCEnJyccN9PkjblLGuKo9Pjm9euUgtBVWtpNIGSohpbS3FdNljoJRo2dW0ZUQgKaPvdro/oxelICV3VdQlEkMRCNQjBd7/yVr/f3X22d+/egzKvoiS89frNTq/LSfTbX/2mFcfjs3OZi1arczGeMd+bZQtrrccIAAZRtLKx/Pq7r0ELVFZ/fPejqNt+9nyvLpXHA+57WTpnwGIINYQIEkKYaCotJKDg9S+9vnl1s5a11MoLuLb27gcfnJ+OulF/NplHfuB5Xl6krX57dXO902vPZ7OVlSGw+uz4rN3qlmXZ7bXLorYWHp2eXLt5pa7rmMVGmbyuOPf3nuyqRjzdfU4IyvM8TdPXXnvt6rUdiBGEYDabFXVBKb1x44bTItNaK6UgBgBZjLFTprbWUkzKsuScu3uykcLzmBvvi1rOp9lwODw5PJpnc1nLnWs7rpniBb4xRqjG0YwcGoUWyKKqqhCAvu8rIaWUvu9DjGQjMCUYoizLtLZJkpR1RQhhnI/H4zDyPc87OztZWVlxb621fdmVfQHUS0Iv+NSI5Pdh/AWHMQZRpLV2DCoMGLX0d3XpZx68hCuE0H0pXJb1VkGGKfYH68OW5BeTjFAqpGUBAxByqztxlGWLVq/bpPlisYAIx62krCtrzdDr9Ab9NE1F05hcTsRUK+WGK9LotCyRBfl01u325mVuCK3KihBSNHVZF4PlYdxtRXFcliWndG1zWJdNmqaU8pWlYSPEvCgTRgDBENrByrAuik4SV1WFKc2aCjZCNMqLPAihwRZi0F8ZFvO0kdIojYStRIMAhtxDxuRlAYz0qbfS7c/ni6oSVdVM87xoylaSxIpzP2h1OrPFXM7GqxvrpjIr/SE3WNSNsdYgyzBP07SiJhdi0F+aL8bGC+q65DRGEFKMzk9PO8RHSiFrCUUB4OVsIY02QP/6l79dX1+tqkZLgwmpyubZg71XXvHeu//bPM/ZOglbyWvfvqO1/ckPf4ogbPNAClEWJeOEIbZ/fxcDvLw6PN7f63a7V25cb7U63//bv7MxWEymGEPeCSDGttSikZaa0A/ScqG1fvpgd31tk3IPYaMFAMDIvPExvnX7lb3dg2vXrkELykX1wx/9I/dDjDHz6PPnTx8/fPLVr37d98MgiBaz+e7u7s7Vq9euXcvnqR8GGmjMccQDCCHywHgyEbZB2PNCnnTWRpPzuB3evHlTKdEddAGys9mMMKytNtZQD1sJgYGj0WgwXEIIAnDZYZJScsoAABghisnkYhoEAeUsK/JWJwHIdvodYZvVa9coJwCAuq5Ho7Oqqvr9PiPU515VlEEQUEQxBCQMmkYaY7wgxFKOJxdxK/E9ZiEA1oZxoLXVVkVRAADIsjSJQ865EGJ3d39paRnjy72UTzeJIIQAIAAQ+NQS7Gemm18IVwQtNBYRrJQClhBErDQvebxf3DG+jOOfCt0IgVpIZUA9K+BJfvr0AEI0mc945AdhaIHWECgEEEKJF8m6QYRqayglUgisrRZykWee5wVh6HlelqZCSmU0ZhRS6nkeVrppROrsJwBumibNF17sN1IEcYgQWFteEXndVLXvRaPxBUJkMp4NlnrT2czzme/7VsnYCzpRpEUTtpN5mfqtOK0yN1jb3Nysqurw8DhbpLEXAaVVIVxrAWJAQv/o5FgIgQDsJp1WlBBCGqmFkucXFzzk2SJd7w6AsQIYqVXoBwBBAwEGkFvUiBowYqEBjbUE1kBbRi7GE2RshJCPKeO+tKa92m9Frf1PHvvcy6s6r0prrQFWar22sa6tEVoghLjPMcaLRYoRPT8/p9Qfj0eBz/sr/e/+y+8qo3/9i99eHJ13o6QqauZ7aZp6iFsEalit76yPzk67vfZbb79rjHn86PlsMpteTDvd1jtffWd/f39+lmXzrK5LCGGWpp7nYc4MNd/8i28Erfj+vceT87N/89ff1Vo+3TuYZfmbr985PxmFLNo/PLh7/6P/5//y/+AeslbPJqkQKgljznlVlB988MGtW7eYxyaTi7jdarcTV1VprYuiCsOwKpuf/OSnSRRHUbT3/Fkcx1/60jvdblcaDfHlygshTAMNtMEYWw0QIqfnJy+1s5WQVVUlUexU+cqyVEYjhCBGnucdH570ej0ATNM0bu7gqk0HDMaYEKLX6wEAhFAAAACUqzbruva8AACwd7Db6/WiKHBBEiEk6ub09LTT6bntNseCQghdTMZhGAaB57SzL/fGjHH9V9de/rwX25+oS6E1xhgELUDGAGwIs/Qz+6WfxepnrgUtsFL5mCqCgpgcFieT8TiOktXhct6UUkpLgAUg8VuuoNcQAAylthezCZC6RTlnrNPt5k01LlKumk4U2SynkCmjESFFWUKpAQCMEMyZNqBUotXvNrKupCjHVTeMs4s5J9SjzBhDGM3rxu/FMOBtPqjrUms97PZEXtZ1TTnJZINiXzKEUXj96g7FxADkBdF0PAsorxYFsZBY1O31p9OpxYgQ7RMvW+SUs1wKKGrfMozx+Gzk+TwvCkpI0zQIQIhgyw8pJhcXF+1+133HM84VRUHgFdOsqkrP9zj1SbuX57kRNQk5sABC+OT+w35/abyYUUA67XYnTqIwmc5n7XZbKKG1WlkazGYz0Oha1hxgYEDLD6tSRswLKJ+cnOlKIwKDgIfdwPO5JUAKWzaS+TzNsze//sbWtc2Dw3h1deXe0wdZlr12541Wv33z1iue53FOt7e3780eYY8ZU3me5wPFEAMYaWh++MMfenEoa9OOYqMMJ3xrfSt7+IByHrSD3cfPPT9Y3VgVQng8sMZ4lDHM2kmrKIqf/OOPbr56e7GYk4pev35dWTOfTz3PcyS+zc1thBDw0Te+9Q1Omcf5zRvXy7K8uJh0Oh3OeSOFtUAKBS2RWoq6CYKAEKa17rY7GGHCqCMzQAjrun4pjOR6sNoaN4zhnDdN1e/367p2CsnOKtpRBaWUz58/X11dJYSladrtJgihoqiappFSc87dFS6LTGOlFEVR+X44Go21tlrLLMu2trYchl/Ig30Wcn8kbP6RHq+jUgIA3Orl5ZMI/umh62c6VBgiaAGCUGt1cHAQRD73WJ5mFBNnAocQslLJoqIIN3Vd1/Xh4WGaZ8P1VecISAjBhGBKkJNNIsQYQymVQvi+/7J954RqnGeBVnZ9fT0MQ6itlSrwfYsQ5hRzVjY1vLQAsFAbn/JikXLKEMbTNBuurbz2xltXr16Nw9BKGzBOANx/9pwayCFu8vLJg4dZms6ncwghJSTw/MV83mq1FosFMDYMQ2NMXdfGmNFopLWumyZIYj8MnGysqGqfcaO0UgpzmjeVMnKeLrS1jDFoLFA68oNOqy2Mpr4HMGKEyVKMT88RwE45llM2Ho89xqWUZVlrrZ8/ed40jVaqaZqqquq6llIzSuM4Hq4sE0zv3/2EQLK8tnzrzq23v/JOd9ifzmfdVhtTAqHV1iyyVBj96PlTqfXm9vbe/vM0nfeXek1TPX/+3Pf9SjTzfMEir7PcjXsJ8ODN26/8q3/1L979yru9XodAnM4W47OpEsAqdHp6LmSTJNH21c3VjeE3v/n14+NjDDAGdHd3//vf//7Dhw+fPHny5S9/2bkGOzK9I6J5nsc57/V6BF7q7vb7faUUgDCKosFg0Ov1Tk7OmqYhCFNMjo9PD/cP8nke+onVwK2hQggd08gVmb7vuwGpa964UtD1k5w9hLOiIYTEcbxYLNrttptDOqAuLy+/ZC8dHx+78wEAQRB4nue0VwAA7rIOjZRSxtjz58+dCfJLjj54ofH9Eiyfno5+vrv7x2enEEJtDHAw1gZDiCGy1n5mEvPZiPrpN3OfzIlBGaU5514Q2FxIKTljUkihZdRu1XUNsWUIpxczwkiZFXEQ+q0YGmutDYKgrCtKSeBH2Wye1YphUjV1yGKPsKYox6OL4XAYh1HV1KoRTVGeL7IoCaeji6aqW+0OJmRRlo1RxijISBz4g3b7+PAIakMs9AcBJdwY0yh1fHHemQ47y0sR8QONTh48nXteXYmLi4skalFACCLbWzsQAN/3tTEa2PF0UlUVwmTQ7oXUt6UsspQxFofRZD5LOOcdP2gnWZp6cQDysqkqxDDzmIagVMIQpK0B1hqMMCaiaS6OjzuDQV4UlLNKNlZbW1er7R4CUCobRIlBoLGW+NxPosOjIw1sEPmI0awsfN+ngVeWJefMCllLVVR5jbX16PHpSfmL2m/5mzsbAICt9Y3dR/vz6RRYC4hBCHX6vfag8+jRo1evXyOQDNr9v/mbvyEAeozPJtPvPfqeVTiMg1TM37r+2mzqzy+mcT+CzEBk3nj9tf9877/WWfOzn763NBwO11fjOM6yRasdFuWs1xtQRpKk/b3/+t84591B9+0vvduUVbff9YKAc3716tWf/eLnw+EgbscQQgsBYx5C5OJi0u51EYFNU52cnOzs7ECEHZCSJDk5PKmqyvf9Tz66t7W+EQcxspBRT2jhMT4ajZaXlwmjjmMAX8SDpmkcOF0s1VoTRMMwPD091lpvbGxYa8MwfEmKcNSik5OTtbU1Rzkariydnp4kSRsgyzzqdmiEEARBSmlRFHVdU8oBANCCpf5gMOxDCJVSQoiqrqIoennlL0QdhH9CYOUzoVUDiBG2VgNjkStT1WdR+scOay2AkGCstcKYQwO2buzce/9DFjADQWkkxJfwJpxVoqGBB4xtBxFgpNJyPp2FnLlfLuccWhBwT+RlqRT3/cYoBolsRBQEFONaCEZoK4qdNTD1OPKJ8BttQAM0MCDutOdZfnpy0gmidL5ohVEvaQecIWOzPFfGAEau3Xzl9PQ0S9OlVncxmSJlmLLZdNELExYExtogiZqq1lJNFnM/DChnCNPta1dHo4vhYIljBq2Jw0hb00h54+o1aU2r086yjHNOIKqtdQbVQivqewQBaHHTVBjjTrszOj/DELY7HQZx5PmIh9oaBFFVNjH1rDaex7QxUmvEKGVsvlgw3yvrKoqSWlRNKhAlUsqk1YEWNZ6iFGhkICVhwG2ts3l6enF8/fr18/OL86MzTGC7F1tr59n8+Ph4+/pOrav11TWGqNXACG2UOjg4aCetGzdurK/XP/nxz0BT/OW//W6rGyet4Pr1q8SSZ8+e7e4/i/woDsNsmj989IQytv3KlbfW38LcHB4ejk7PGPMOHz698+ob3UGfc/7OO28J2VRVFXo+Y7yqKmPNjVs3olYyGo/yPF9fX1fYEIR/9dvfDIdDqZTbW9RKLfX6cRw/e/YsSZL5fO48Kf5fV/+n+XxxfHzMKY9bceQHjqOmlGp12lLKVpxACPM0U0o5Q/FGCiEEIphSCi16mRU/e/aMUurYiG7lBQDg2hMuAltrG9Gsra1pbSml8/ncQffTVEGEkJTaxd4kSV5aY/i+PxpfuIvDF9Zn8AuO38Hnj7OU3IHBy3MMAEBrzSH5wozX/L4MEvh0BFfAWoystRbB9SvbwGfTMluoEgS8MDKv68Ha6itffbd7fXtaF4AgqI0pamxBGATGgkVReJ6XzxZWKIYJIKTWev/0+OxiNJnPfM6TIFG1ElVNKaUQQQCCICCMVlWVl6UN2LjMn+7tHh8fTycXoccjzjkjYRLWuknLvJANDTxAcFlXo9GIY2YaXaYFhajVaqVZ0W230zS1AAhgRuk8s/Isn4/rPLeixgZGXq6ata11bbUSjVWaEEIpiZOoKguoNZSKatPM02w8IdZyxgAAzjLEtX8cPTUvCz8OAcWUUisVM1CVtYeItQBTiigxxhgIpLbGmKPDw8V8DiH0mZ9EcZkXRul+t2eVRRaVRdGUVRSEBKIkjLTW0+kUaqOqRlT6V7/8TSvpHp2cWgym5RwySxg63D/8+Y9/fvj0cO/Rs4Onz8/2D3/6439aGa4OBkPuB7/98IP19fXNzc1ep9OLEqgMtgABY4DpDfqzyWL30f6X3/3K6tryW196PeoGnzy4K2XDCd9Y2bmyfv3eBw/WhusfffTRV7/+5SvXN4USxloLIKasFoJ5ngb29Pxs/+iwkeLq9Wte4Btr73780crq6muvv37z5k0IUTtp10U1mUxDP9zZ2inzcnl5hRBKGK+FjONoZ2f7/v17btFMKRUE0cbGVhzHblWVUtrudmaLuRtsOp6DuTyUo7222+319XVHWvA87/DwsK7rpmnKsnTqH1pLQpBDDmPMWusW6OI4JoS4KO0o+HEYYYhWV1ddBRRFkePlR1F0cXHhQPvfGeo+g93P932QQcQAaKxF0EJgwAtR7P/O4xLiCAIElZEA2Vm+uPH6rf76cFpk55MLgKBSamN76x9/+mPMWa/XU0ICbawxwFiltYFAWyMb4b8IQV4S1UbFrQRjXFYV8TjECBFMA29R5EKIyA8gAEbpTtKK/EgowzxvfXOj3W6vDJetVJSQXrvjB0GQxJizUjSNVidnp6PpRBldNU1VVYvpDBg4G08QgLPFYmVttdZyXmSzPK2tZq2IRt5oPq2tzsoCUeJ4m25/Is+zLMuUUlEcXy7ZaONTxglFlx5YEAOoG5HwQGWlTzkwFhgLAHDKOpwy6sQE66aqKkRooxXyPMBIo2VVVRBCUdVKyrqsrLJAGwbp+ekZUEYJSSwsiwJbgACsy8ojlGLSbXeaomlHyeR8/PMf/wJjOp5PvvVn33rj3Tcr0UwuptPx7MEnD4wxd+9+8IMf/UBrGUXRm2++eevVm2+89ebp+cnp2YmS8tG9R9Wi4IgBAyGEj+4/rrJmeWmFUnrz5o0//4tvf+fPv/H1b3xld++ZtYBABgBWEhzuH7352uvaNGEcLNKZ1vq9997T1iCCtTXc85Q04/G4rGttrVDK9/1Xbt5st9sQwiiIvvG1rx/s7RVZXuZFVVWLxaLX6y0tLSXt9nQ6RRg2Ss7n87feeVspMZ1OJ5PJdDyBECJwiQcHrbW1tdPTU5fOgBeWLU3TPH/+3EVLZ3Xh1qRdiuuUH5x+hVKqqiq3o+OqVkppkiTOpealCoRLmKMo8v1QCBFFycnJiTGmqqperzebzVxj5dOR7NOV5xcWqJ+Ns1+AZAwAsMgihODn6tIveMHvkRwcuK2lhAiponYr8MNinhtjuOc3VY2t+tkPf3RWzA+e7/3bb3330cnHYbud55nXCp7uPicIrw2XjdaEEEBx2QitjCZQlnUcRnErEdZgDxtjyqoyRglpIgS0aFqdNkJUoIYEwf7hQeKH/VaPcLJfliZWdV3XRmFG2+04aEVVUeZN6XdbyGO11sSCVhhVVdXmgZRSMzKrC+L5TDM39ZrNp25NyaNkPp+3wogRnM8XjFLsUQqYUTKMoko0kOCiLBvReEkLKDWdTtuUWACasqIWVGeTHvERo0VV0YDN0wXnPInjKi2AscwnWqvQ8yGmqq7Gs6kXxW6rI/I9YKCsG8Y8j3GMISR40OkihJSRjGDLmdWKUZydzm++duu0lrpWy/3BJFtk03nCWkrIW7dur6yvadlcvX6N0VPOOQmjO2++sbKy9MMf/GBtYzWKWxoaaWSr2yIQrawtP7j3UDWCIh5dT4zR//ijH15cTDqtHmM8nS+sNowRAI0f8KtXr/z8Z7/0eWCVvn37zi9+8Yt33327bqrpfPLsyYE14Dvf+rP7nzy4efMGpVQoeefOHe6zg4MDirEGQEnpcR74PoIQWgAVaEVtYMz4fPx/fPx/dAfdr371q1qr+w8frK6uSi200cqq/aP9QbfHOV9J4uXl5b29vc3NdWgtQLAWjRIyjmMM0fPnz9vdjqMTAQAMsBtbmwZYCCywFhFcNbVbFBFSQgjDOFosFi+TXgZx0zScY/jCQtZa6/u+bGq3booQWmRzQgil/nw+hxglSeLyZxfnHd7sH5bD/nRb5zONnk8/6fAFEZRGWYwsAFZpBgi2f3QL/AsQe9kjRlpqiKFQ0uds59rO+elZnpdGasiZlNLDNPHDo6MjGnipqGjon56ebqyt13Ut6ibwfFHVrfbSXFTTdAEt2FhbJwAKoz3fT9NUGi21whh5ISOYxZwVRQERUcbU88Vyb8AxmYzHhOEwDN2Xa9JpH5+e9Pu9xWwGpY6CsBXGlRTG2l6nl08XK92+zCsAISK4rCvbiLjT8n2/KAoCkUfZoNP2KGPt7snR8fLSks+92IuKomCM1UrOi4wxVtaVzz0q6MvvS0xJVuRGqoj7VioAEZI69Py8qiM/QBiUZa4BWF5dTos50dBoWBSZgUAhk5cFQqjJsl67QymvqkupbougNYYxVpalhaYsy7jVmc1mXhD2er2Tw6MoiJM4Pjk50VJd2d4J/WiRw7psRCUD3+u2exd0opS6tn3dEtQadrdvXFnf3kpnqcvNTk5O1tfXF0Xe6XbrSv793//DO9O3y6bc3r4yHk8tBPv7+7PRFCJ7+7UbWinq0ySJ6rrO87Kp6uf7e8DAX/zTL+68easddl655g2XVtI0/eDXv5F102rH4/H4rXffBtYuD4d1WXmeBxGy1s4n08gPAx5OJhNoLeO8aZputy2lnM6nj3ef9pd63Gd5nsdx3O13Wq2YMUYgmc1mcbs1HCxVVQUAcD6d2SJdLBbQXjZmnf2k1rpq6tPT07W1NddbMsYwxpwwkitMyrK8uLjodrtu/wYh5Pt+UVRRFL3Unq/rWja14wy7uauU8vT0dDgcaqteKnQjjBxcvzAqfpog9IWAehlyf+8EBJFFFkK3MGSB1hr9EZRe9nsh/N3CObQAIySFRAhhTKC1ShsvDje2Nj+++0kQhjxOMKYxtJzzoij6K0tpVYxOzxhji4uJ5/M4jH3meZ63WCy01u12K+QerrRVCgKrbO0zBkXjxzEAoCzL09koDhNhVFlXURR5gMhSCKyapkZJwCkhBC8vD48uzghCs8kEW+hTdm11gzE2XywAgmKWxdyfTCbtdlspVdWVF4d+GAslr2xtF1meZyljLKGeqBugxNqgX+VlFEXFYu6FQWNtu9cVRmmtCcJGKoqJNaYVxRjjrK7mVVHnBRkMB/1uU1Z1XQOFAYCLRZ7EodSqkKpDLPCJrbRuZBSEuagBgqIWw+FQBz5CqBIKeqwyglMOtAEAMEZowCwAvu/PFnPiET8JGiOwIJTSrKobrcJW7AVcNTUnNJ2XR7tnBOqnDx6XRcZC7/j0dPPapgb2yo1X+p0laMiHv/lQaJHli0dPHleqfuX1V9NxqqB9+PTJv/+//49RFF1ML87Pz2/cvHa/vieEODo43b6yIZXcPzzIq9yVeSeHJ6rSk4vZ8cHJ0tKSrARUwMN8fjGbjaav3brd63SrNI9bkU/YeDalmFGEgQVJlCxmc9KlSqnV1dU0Td999+0kSXYP9t/71Xt/9hffXVlbttZqq6SUWktrzWJRteO2u4kxxr7nWWsRwRDCXqdLCNl99nx5ebmRwvM8KSVjzEe+8yx0SWy32xWiVsrtwUCtbRRFw+HwZUvWZbyXXWItXUUahqHHqH2h2dlI4RY/giAQqhmPx263BhHc6XReWh6C34XH34Pl5+cxnw2hn+IAG6UBMNYAhACECEEEyB9G6RdyDq21WimCMcJYSgEMJIQBa9MiD/2AEDoaT3q9HrV2lmZCq6KuCiU8zqhBCKLECxilUspC1Jqg0PcbrYyQomxC5glRN02TNyXzOBACICi1Hq4up7NFI4UyRihJMTNC8tBzKw5+GJZlmWWZlbrXaishfc8v5mnIPVU1EfMghIZySDDGuBGCMNryW6Vs8rIo6yp1apGUYwjrrLJGKaWms/FwsIwhKoQghPhBWBSlMDor8pB5Hud5WURBOEsXhNJGST8MkiQxUp9NLhgmGMOqqfyk7WGwWCyYxxHFk3TueaSsq27UyRdpt9cpmzKKksVi5ox0KUR1XVtrOYJSSkJQUeWe583ms6qpl1aWz8/PldaEkEZUnPOL8ZRFAWSQcCZ1baXmzNt7tssQakWtJIktAZPpJJsvgsSPolgKU5fNaDRO03kY+avr60ur9PrNGwyS47PjMs2PTo/W19cvJiPKyU9+9pPJ6aSTtH/yk5/s7q9CbG+9fufq1auv3LqJELx+9erug4P93YOQx+2k8/4vf4UA/vije/1eLwyCwAs5548fPyzL0vPZYjpb6vWtthghhkkYho2olleWLka4P+z32p1GiWs3rhWiandbxhhtFcYYITCbpVEQClnnee5Ww2ez2XBlCb7cPrVAKbW5ubm3t9dfGnie51JWiC4TV0cGLssSIeCGq03TEMKstdPpdD6fb25uAgAIYc4cta5rzr0syxxn2Gr1QhhJVVXTbrdDP5rP52EclGWJMeacG2AHg4G1+r+nefuFiP3MMxBCgCBCVOsGQWyNNdYAoP+g0ufvodSil08SDK21jawp4QhCDLAs1P/3f/sPXJE4iJEXGKUGrc5iNh2NL/qrw7NsHgTB0IuRNBYY509RS4EoIR5HnGKIxCxnmFgEKy0F1PN05mqMoq6ssp2kMx5PIWWTyWSY9JI4LOuC+qxBljLS8UJZ1k1dR35Q1zVBl1NvKWqttdbaC3zHDQjDUCoFIQYEe0ksrF5kBYY2oh62Fmozn08hwYTRVpxAY5usYhCLpqGMFVp4YeB0YTSwVVXJuun0e0/391fX16Zno3YUB8yDGNa6sRgZiMeTi0GnAyH0oujg5HC43BNlFaIAYyqMthhmadk0zfb29oMH9zj1KKVBEGmtPUY9zyuqXAhhkdVaZ0XZ6/WkVhQTpC0AaFHmiFFldFFksR9AgDUkURRnk2lTZRpptz9wPh1T33v33S9TQB8/fBS3wo3NNSnlz3/xizvvvvHqndcpJL/85c+Ha/0w9E9Pz19/7Y1nz3ZfuXLtZO/kg1//plJl0o7b/Rb3vEdPnv/Lf/1vOOfYICLJ33//74+OdxFFnhd4nieFQhhaa1997fZg2J/NJltXth8/fTKdjl999dVep5+m6a/f+9Xq6iqiJIxDSlmv10UAVk3NGFNWffjR3evXryMCPc9zuShBEAIwOhljjAlnTdMQRnu9nlAN5xwBqJSCFvzyl78kjN68eTMMY2utywERQrPZzFrb6/WUcr7GwBhDKYcQnpycuK2apaUlt2pqLczz/PT0nBCirbpy5YozmyII53ne7faVUsYAa+2Pf/yP3/jGNwgh0+kUU+L7Puf0Ulz/hcmFy0BdfHZOTn8cpW66416iLUQIGSsIglZbbAgxX6xt/9nDofRFDm2ttQAajLEUGhgYeeHps6N7v7wbe1GtjO/76XSWRGHdVACjClqEUC9MdNVQjCilvu/nVWmstQQpreuqCjAHAEBOS1mzgBWidI04UUuGCYbEGlA1QkmjGmWkaLVaUTuABPPAM7WQVW0aGYahIwm5ReROO6mqSihprNXAUkqz2bzf76dZsSjy9srw9GLU6nS77Y4ua6tkleaMUz8ItJGUUmyAkcYKhZQBAOSqIR6vRRO1kryu0jwrZotur+fHsdaaAMgpM0qlReZFobYKE76797zf7WxsrE1mKfNZUaWz2WypM2wnLddanM8yiIm12hiz1B9KKRnz6rpWosEYA2SFEJDAJEmyomQeJ4Tked7kJaUUMpKXpdIQQkgwns/nQRxBiH1GF4vZ1Veu9HstqMDhwcGirBDCeVo0TRO3wrX1lePDk7woljaW3/7Su6cHR4NBL+6FAFkrQJbljLHIj6EGjx8+mufz5bXh6sbQGvg3/7+//cY3vsU5vzgZzU8Wz548J9y+8fabRV7O04US0kIQhqHWyg+9rFp8+atfWeTpcDiAEJ4enQ6HQy319773vfXNdQ30N7/5bSOFtRAzDACYp4v9/f3t7W0/9JwZBISQIGy1kbU0WhM3vgJ2Pp+3OgmEEFqAEHJT0yiJnftTq9XinGKM8zxvmgZC2Ol0tJaf8uHGl8GGEPcl7tyWHNu+3e5KKS00i8WCUtxut9P5IooirS2EECHiIrMxxpmmztMFpdS9owvgTnPzJUoxxp9xc3pZiH46733x2SBCSGqIMTRWIASRAdggZr0/MYl5UeD+boL6Mo+/XK71edZUrUEv7rRdVzMrcpr4JdSe70MLQsr7nW4p68pKCa20ZpYuGGOIYNcr5pwjhpFPgUdzKxtgvChUCPitMErC6WIOMXLY6/f7y2urYTtpJQk1ANWyvpjZstG16LTbWms/DLjvGauMllpII1UQhkmv48eRF/j9waCua6GVRejs+Awom8+yi9MzRwdljEEIgdJWmGKea20xobVSBgJIMPE4DTyDYCVF1lQWo85gACFy021K6Wwxz0Q9zVNkgUeokerWKzeXN9aE1XEYNWW1vLbyb/5v/8P1t+8czccAQZ97nPOqyJ2KmjI6zbOTk6OmqQijBljn/IkQuri4KIp8sZhLKZUx7UE37sbGSIqRrEQn6gAFkzBZWV7qdMNa1hrbYNBZ2t5aWd/Qyg46ba3knTu31zdXEYfzdMYwGXR6X37z7WefPNh/8mx8dkqABUoTi+7fvccp00YKIcI4khYM19YsxLUUTdP02p1eK4n94OTo2PP8q1eu37p9J2l35ovs4Og4abcMsIDirC6n6eK//O333nv//TTPAIKEMy8MqqbuLPXyppBajMbnkEBEkSsardW3br0SJeELxgtihAMDAUCe59V1/VICt91uj0YjVx00TZMkSRzHRVHEcdzr9bIsOzo6mk6nbqYSBMHLSQmE8OXIxC2CuwdO/yFJEjd7c2TAdrvtPFERwW5/FSGglJCyca7HAICiKCaTiRuPS/lS6/MLpixfSAn8dDn5csHNGMMQxhBCjCwEBgFljdJ/OOOFnzYbv3wLZK11citWm8sTIMKIYw2yw8kP/9s/QIi8MBhurGkhZV5gAwAhlDNAUa/XW8zmQGlsgOd5eVl4YTCbzo0xSRRZjHKjiU+ZxwAw6zsbz58+a7IqoL6sakZYlhYAYYNgOptzBHutxOcewUgb44oHp5wmpfQ9xjGRZR23W6USk2wRtxJogW0kBvjw9BRRggk7PT/rdrsIwM31DQu0agQCkOJLC2pjjNbGaoPdb4DTRsmDw8Ovfusbu4cHRVFEzKeUUsYAABCA09NTAKGxetjrvnrr9r17DzBntRKY4YD6RZVu3tjurQ4MJFVezY/Onj18mrQ71jgWKEjnC2NAt9uuqsoYo62JokBoqZSSWrVarTQvfN8nhBCElJJKCWOAkSTL8rwogsSnHDWyYYy1+t2w39JC2ry+dfV6K0n+y9/813/5r//1/+d/+1//+t/81WQyGR2ddTq9qim//OV3D/b2Hz5+8Mpr1zc2NlQN9/cOK1lsb2+Pz8enJ+fHk9G3vvN1iMzPfvpPX3r7yytLqwShk4OThx88JYQ2Rra6rdOzUV2XURz4ofdX/+JfIAqePH/ybPfp17721TAMjVXj8ZhRr91uI4D2DvaGywPmUdmIpmmiILTWjsYXKysrEEI3l8rzPPBCd+MapTGAe3t7vV7vfHwRt5IoCd20MwgCJyFvjEnT1Bjj+6HW+uLifH193VGIIITz+dwY0+933W6qaw4dHx9vbW25oYuLjRBipZSU2vd9rSWmlznO8+fP2+221cbzPN8PjTEO4S4tH41GZV3FcfjCbOrlfuklD+nzsfTzUfDTTR9jDIYEAKCRstBiiKCCVNI/1j36HeIvuYjGAut0RxGEwCIMgLHIamMMgB6hES/zAmpSi7rMC1s22+sbRdMw31ssFk8fP+0O+kEU7T973mm1OaVZms9mC0KIkYb4XEN0Pr5odIMZefJsjxGiGx2SMqQcIe1BrK3N6oqFfLGYyVQjZTZWVg20LPAohMJqCzUDFFp4eHzSS9q5qJN+V3FsLEQQUepl84W1Ns/KIIKv3rp9eni0tbVplcQESQQQJVobRElVlL7vU8/LsswLwqIokFRlWbWS5GT/sBWGVqqmqT2PV3XpHGwHgz40FkIYxcF4PMYYW+F8q0Cta2NMU5TEWoMUIWbr2nav1/vVrz+s64ZBGoeJUXA2m3HKsiLtdDoA2rSp3vnSOxbIu3c/Fsb4YaSE1KK5mBdlWXqx3+93w4BBbKKO18gGYrTSHyIL0ix7/a3XfZ+fHhwlvRbScG1l5Z/+8adbK+srg+WqqqJetLK9nKdZY4TCZu3KJvH8J7sH1zZvdDqdalScnJw8eboHAPj617+6vDyEQP3Zt785XFoDEnz0wb2L0/N+v5+mGQEkm2ZLnf5kPq2KstvvUA9Xqty+tgWxjaMAWWsxY4RPJpN+v2+0RgiFYdjI2omVnJ+fc86TqAUtQhBYAOuy2nu+e/2VGwwzISWnbD5LgziCBK5trGJKnM8AZhhg0EjhUc9N8EXdJFELAdjr9RzPHiE0n6da2zIvGaGMeZ7nKaUXiwxC2DQN5xwhZLW1BjBOrDZFnfucYYgQgO7GXltZ39vbu3LlCmMMYyiEKOsqy7K1lVUAQLvdnu/Ncwv63QF03gjWBTPnAQeBuWz3fmYq8+mmrouF8MW6jAEWAUsAtABoYzHA5o+oZn+mWfzysYUAWmAv1fzR5YeAMGona1c283k2Ho8hwRaCMImPTk+ktfPF4pUbN/wgqJU0DYjbLYSxUIZzn/seY4wRbqwFFvrMj/2kFhUEOAyCypYE4qooEfe0lgBBn9EgDIe9LsbYCFPVpTQayoZyhimV1lxcXKyvrA431rbWNk5OTk7OTjGj1A8gREaZKIrCMJnP55Rzq83W1kZVVaHvSSmttUIIAlFdVaKqEcHQGOLxeZlro7lF/X5/Np/6nudzz8YWJlAZjTRyr80XaRSGg6Wlk5Mjz/OCIMzS3PcCoYQxijI8Go3ibpR02hhDiCGLvOu3b/zin97r+O3z05HPvNXV1TD2ILWNrPOm2trZ6fV6EqiNne37d+/HcasqSgKRkWpteVUim6Z5AfXW1mbcTe5+9JFWan193Wf8+d4zDCxCwED95Nnjle6KUopTNp5OfvX+b7CH+itL/eFgdXX1Bz/4ASFEA7O2tZnEnUePHs3Gkz/76+9cXFxUtWr3uoNBj2CIMIYEGmMopqKsRS2Np4zRqhFV2eRZGSWhBdIYrZQgBAsh+v0+NBACKOrm/v37mBAIYZHn29vbl4FIKq11v9+/uLiAFiGE5vNpHMdhHN26dSsr8sVi0e22q6ZO82xjbd3JalsIhJSEIsqY0vrS+gECSmnoB0Watbod7jNrrQu2jLFWq8UI9Tzf7da4mY1TrHesQEfVdylrlmVuwc1qY6xxEn5LS0suVXbkJO4HAIDFYsE5Dzx/dXnl9PwMfm6L1FoLPgXCl5j6DKA+81MAgDFWWY2shRAQzJz62Z/wifk8bt0vy0JgMdTIuMcGWYNtu9sRUiatVpbnXhhoY4fLKwQzzv3ZfO77/u7u7pOHj+Ik4ZxTirWWYRg6b0kI4fnoFChJrb2xvaNkI0QtRD1fTP0wqKSQUoZ+EEKMqqaZLJiyoe8XTV0qoRDIZVNrWVSlMnrv8CDpdvbPT3JZU0yA1GmaThfzUjSNkrPRmAIEoAnjgAU+ZERoZaRiFnJMGKWMMS8MmO9BDJXVGkMW+JBhAC0ntCmrsiwhhCzwpFZFUUALMIDL/QEFaDGebm9fWVtbgxAqK7r9NkBWaqGMsRgdHZ/O5+np0WlV142Rg9X+v/53/7Kua0qYGxvkTbG+swkoCoJgPp5oqTHAQMOmEqaRXuQpqDHDGhjKMKXY87xZujg8PHRCTRsbG4NB7/bt20qp8/Nzt6XwdPf58fnZ6XhkCUjT9O1339nZvlJVlSNROC/6bqeTRFFTVo+ePrn/6MGiyF5//c71KztNVQkhxrOpsma6mM9ms6ooVNU0dWm0LIqirPKA0XQxD+Mgr9JFOi3y/Oc/+el0NCaIzNN092D/69/82pe+/I4QQisT+CEhpC4bCHHTyEcPHmeL3JWIYRi7BqyrIZeWlgBAjLHhcKiMdmIIbnPNrS1LIazSLwlDWZHPsxQA4MYqnuc5DjBCiHKGKQnjqNVpD4fDKIqWl5fb7XZZltbauq6Pj4+fP38+m82479WiQQRbCFx7yUX7vCykVrVoAIJaa0efcHuz3W7XMfs/TzD6QhCB36ccfaZkhRBSTAghFiMNgTN/QfYPSDR8fv7zslNsILAIWujEDKGFxriHCG5srGECL0YjoHQxzzxCF7N0fX2dMTafzx88eri5tv7mm28WRYEZNcAqo90EWQghhNja2EQGFPP00b37HqGR57eSJI7jWsmkHbPARwh5mGJpYsLrvKyqyjUn8qrMsmw8mbjeQ7/dydK0aRrGmM+9OIwYxFpIYAw0NvA5JxRIXSzSLE2NMYRSZY002pFOCCGO7emkWX3Gy7KkCEuleOAbBJnvaWvSNJ3P55gSrbWS0tFitNaj07OL8bTTayft9v7+btNU0sisyIXWt157PY5agR9VSqRVgQjyPEY97iR5kiQZjS9OR+edTtfzPADQe++99+jJ008++STgnpTSyagTRpumms+n2qpZOs/zHBPS6/UGg0FZltqaMI78yD+/OL9641pR5Ldfv93qt72At7vd3qDv2ollUX3w6w83VjeHg6UizR2PYnt7e2mpf+PWjW6/U9e1lmowGPxff/93F9NJbzDs9XqtVkspFcchQfjdd9++evUKIQRa0O+0+4MOD9h4PAo4Gw6GqpLzWcqoV9c1AABj/Ort24yQMs+V0MaYLMum0+nDhw/7/f7Kykqr1XJbnQ5X7jvrhdaRdivHrszDECILVCNUI/I8d0wGznmr1QqCQCnlaLcQQkppFEWz2cwNXQAAzgDm5e6b20R1VyjLsmkad4WyLOu6dqLYS0tL7uKEkCAIHMXX8zxH5YUQKqV6vZ79fWmyzwPn5U8/c87n+UmXBAkE7QsJQoa/eCfmjx0Q4JfYdpUxAgYCo6VCEIbM4wAjoWEpZFZjbSfno9APhsOVa9dueJ43n8+Hw2FeFAYCpZTnMaOkhcZYlS1mwKhhtzvsdDaGy+l0CqG1yNaiWhR5GEdBFEAIozA0SlOEayGWVpahBRThVhCVRVE3ElgUM1+nJZSaIyIqUeVVzP2IcA4wtoAxBqGNCUdCU2NVXRd1JYCxFBdNneW5lJJARCDyKWv7IZW6zbzJeDyeTfdOjizD4/mUcmaM4Zx7nocI9oPQC0KEsDE2LXKllLs5wiAIPD9f5JhyCzFACFE6WF7O66rV7SwWs2e7Ty0xmOKmaSaTSRQms+l8NppigyxG03R+dLyPGRFaAYCgRYEX+h4L4wBCmGUZobQoy5s3b95+7U4URUEcnZydZkVxcXFxdHS0u/usN+jygLf7nUbLjZ3NrMxc++Ti4kJrvb25+bUvf+Xs5PTZk6dlXlignU3D0enRweEeQuj58+dKqbKotbbQgN1ne6qRFLOiyu/evWuNWltZacVR4PPt7c2trU2M8enJyfj0fGNts9vqVlV1+9VXpWy0lvP5NE3Tn//85/P53OdeFIQUk29/+9sOUQ42YRj6fiiEqsoGAuwsQ8sy39t77lQXmqpuqloJzQhvJx2CqMe4qBvnZBElYVkXThfbtWoxhlm2oBRbqyG0SgmtJcbQKZsBACilbmPxzuuvrayt+r5f13UYhoyxIAoJo5gSwqhSwrkVuo22/f39MAyzLHNrq8+ePftMRxd8KmB+BqVfGPw+3UB6eVzOciAE+g94rv0xhgQE8AVMnd8iAAgAQyhGCN589WaeFlqadrtra00JZxRiq5nvSyllIzjnvUGfMJrOF03TRJ4PjOXc9zxPC4kwANZiQmVZJ1E8mc6STtvxPIjPqrrRWloIeBzWWkopGWXD/gAiUAvRsz3ksX7S1tMFUDqIQ1E3vu8bra02kec/f/L0+vXrdd0ADLW1PuMaWvfF3Fsa5HnueV7kB27dAWNMjEEIQYwZo6ypNARCiCRJzs/PD/cPVldXoyAs80IUlbTQ57x6IWwH0aUYqxWGcra2tiGRQR7TWhNChFFZkXd67W63Ozo+n8wmOrQQAcZYmZUa2K3bO57nPT16trOzvbqxnKb544+fUEQXs3m31/ajyFi7sjJURgvREEbvP3p47do1t+SxtLQ0no0XWfqXf/Xd+XR2eHLs+2HcjqJODAl8+913nj59GgRBEkXlokAIQYjfefOtx8+e3LjxSitqtTvJ2fnJ/v7+sL3s5hmbG9uvvvpaUzZP94+effLEYyyIQiwdew4gaGXTdNu9leFy2A5PTo9aSafX6T978pR6fnvQstYyj5dp3jTNu+++Yy2QRjm23draWtM0JycnjmF7uZtiDKW0rus0TYPQI4R4jC8tLZVlWRSFI986HQZjjO/7o9Go2+26TTRHXWiaJk3TKIpcA6nf7zdN43oHvu9rrQ8PD8Mw7HQ67mO41OmlzG+n0zk/Pw/D0ABbluULDQfPQRQAQAjwPM8Nvc/Ozowxl6JKf8oj5iWCPp0bf/r/v3vepasWGG20AQT8YYbgZ5Lel3BHFkCLLDQvP5mBBgGkrIUQNFaHnVZTCQtxXYuyzBACBlhmdFEU3U6rKsvz8/OyLIE1nLNG1FWRd3p9DIEBhmJWypoBQjDGBiRRXBSFF/iE0dF0sjJYktaM5oumEcvLyxSApqygsQCB2qh2p1OLRlR1O4iLLC+LGjNKPTKez1vtdpqmm5ubRV35rVgoiS2C2mAIldEAAKwMB8hqo6CClPidKAgC3cjFYlEr1Y54b2V4dni81O6W00VEuBdiH9OmaXxADIKXtGSpNMHtduIHAQv8yWSGIc3LHCb+m195ezodG6UFAlILj9Pjg8Nuqz2fL7q9dhy0inlpLAi9EGOc5yUP/KaqIDCtdhzHMQfsyf2nPuNAgdFoxDj3I595nHJGCCmb+le/+o3v83v37m1tbXQ6nawqjdKMsevXr4ZRuBNsF0VxeHywtbMZBDs/+MEPoiB85623Pvzww5s3b8znc2vt4eFhFCab21vXb1+9ce16Ns6X+n2JAKQEWRTyYHYxhRZ2u/0sy4q6stZCbbVssiLTY6UaNb+YX926hhBK3njz8ePHtRLSaIwxuhxUqlrWVdW024mTxq6qCiHS6w2Kojo5OWu1Wr7v16LKsqzT6bi9cEI04yRbzJ3Pt1EaAqClIghba6VS1k3LGG2aBmJUNXWe50tLS24A7vya3KWcpRiEsNVqWWuzLGt12m6KY60N46gsS0opYdQPAy/wsyzrdruuTs6yIgiCl/q63W4XWhCGoYiaLMvW1tastRAh8KlekYuQL4vOL0yGwed+BCG0xlonD+ScZgBAlPyJScxnr2gBtAhZYACwTqzsRToNCBKVQJwm/S7QYH4xL0QdBbFHcJrOCSFRFBVpFrdbrlekrSGEEIhLcPl94DEulQDA1KKhlA/6/cliASguRYMphRidzyZlXgAACKd5XXHMAsqtMsIqDYySkhOKtS2r0vM82VRVVfmUxXE8m82iKGII10VeKwkhtBBqZRbzhUdZ4PlWadtIi6DQwm8nQoiiriLqAQRbnY6QsqjydrtNIcIQNXUdUq6rxgiBDGSEuD8w87i2WghhgKWEt+OWqqRWutdqQ4t6vd7u0V7WlEvLg9XllXyRZot8NptR7DkSDEKAEGStkbL55JNPGlWdnZwHkb+zs+NG54UxTnMAQFiW5Wh8QRjJ8xxRQggpy/ydd96Zz6cPHx1IrbjHNjbWptNx0zRHR0d1XQ2XB0dHR03TXNneWV5ebpomTeeffPJJd9C/c+fOxx9/4pw7tNYe860PjAYIoouLSVEUxGJRNB71nj3d7S0NAMS+RxlhdVn2BoP9w71/+LsfFlXxpa9+pTfojieT/eMjqcXu0fPvtL5DKFJKQwgxhp1O3DTi7t27b731Fue8rsswDCmlH3zwwcnJycbGhgE6DMN2p+NMSo0xSgspJfMDxx9yTR0AgFvpbrVaZVlWs3owGECMBoOBi7eYIccEcq4WbgfVLce47i6l1I1nnZOQG5K7xoT7c/i+/5Jv4JgVzjHZ4RYYq7V2Ys6Hh4eEkO0rO38ISp8Je58fwIBPzWYQRtpaawDCACJkDZRS/fPrUvMZ9BpkL6UfCKOIYIgsY2w2m3m+zzmfzWYIEWBsv9/HGBdp1tQVRJcrCxBC3/cRgsAYqxWEMG4lFkJXpyVJUqRZEkVlWaZFPs9SBS3ECGBECDFKI2ORsTHzAsKosqiSMq8wxkJJxhjDpCkr1QgKEYJQWeP7vqobbIGoapdoYUa11kYqpG2L+R7AtmpUWZtKYAgZwjqvYC2RtlKIMi90I3QtYKN0UUNlNDQKW8hpY7W0plESAEAxaflhU9XTKjcMU4COdvchIhjRo+f7jz96gCzqdvurq2tx3KqKGlmwPFjinOZ1nlULrYSoS0Y93wvu/fbjf/jbvzvYPTDGeD6zQE8mE0pI4HkUE49xrfXKysrNmzeLonj48OGzZ8+2t7ffffsdn/F8kd797d3R6VnkB4PBwPf950+frS6vnBye7O/u3v344yfPnylrNrY22t2uhaCRcu9wf3R2gYx98uCRrGU+yx7fe/TBbz78h7/7gbUAAUwpd0Q8a+B0OqecN1JgykyjqSEPPnrw9NHzeZZ++atf0kAvrwytMZTSOI7jVhLGAfNoqxVvb29/8MEHCKEg8NJ0nmXZcDj89re//fWvf/2b3/j2u+98OUvTMAjc7UEp7Xa7DqIHBwdKKYLQ2cmJlrLX6TDGoiiK49hNTVxF6pp/EEI3cbm4uMjz3O2IO1a9aya5Z5TRrqPrpIxcu8Gd71Jo181SShVFMZvNXr6Lu+c9z3NdqBdrMQZC+5IR9Pl6Ffx+vAW/nwADY602CFy2aY21BgGNwH8Xj/d3ELUAGAwhtFZbCCx8wRw0EACEAD7YPWCWqkKd7B89e7YfBWErjJaXlxXQVVXVZe55np+EnV6XMTYdTzjEqhFpmiZRDIRqjMKxt8hSBmm306nqZjyfLa2tzLK0FrVSCiOEDYi90CN0ejZOopBiJI0mnClrkAW+7xulEcFpkRNCgDYe44SQxWIxXFle5Nl4MgmDIAmjLMuox6uqYpgwTERRqUa0O0mtZK0l49xorZTyvVAZ7ebghBDViFYUY4jyPI+S2EAgpIQYa2vzPAfQepQBx82iNAOy2+8fPH+eJInXCgCEdVVEUXDtxvWyqdrtthbq+3/7g4AGPvEWi4XFmjG2PlybLeaVFBroOPQY8+pSYIyTMDo5OQqTlrU2LzNMqR8HBoKmaR4+vL+8vPzv//2/z7LFeDy+fuNqlqUG2CSJRqNRv99vGimEuDi/mE0XWuiqLvrDvuMq3bp1K88L7vvM4++//9721sZsNK2nVV2LvK4UtFKLdtKyhelE3bqsi6qM2wmEVpSVEIJyYoxJL9IoihSws3L29b/8xnB9aZHOnRxu0zRK68n0fHVtCUKILBVCZVlGCHHaX471eu3aNa21BUApBZFVSnHPM8ZAZK21BGEhRJ5mjLHZZKKU6vf7cRxDjK210/lsMBiUdeW2Z4qiIAg7lzQnZTSdTqWUTk9Ua12WZbfbJeySJf/s2bN+v+8kjtwQ1a1VOPC4c1xsxxgXRZFlWeD5UkotlVKqFg0hZHN7y1qrlHABH2MM7aXf7xfg6ItmKOBFrmqsktACCoECyEAfBf88lAIArEMp0AYA6CyctbXGIItko3YfP//ZD/9pvbfcS3pZWtRSuQZ6Jeu1tbWmKowxcbdVliWmhGLiE4YR6rU7F+cjbIEGVnMilFRCcUIhxLUQRVMErVgDwzmHQoFGUYsQgFprn3ECgGiaWkkaeFIpCKHPfYRQUZWNFMtrK4vpTAsZhmGcJHlZ5NkCIQQVoB7Pi0IjoIAlEMV+IOrGI5QRaoxydO0oiiAmQmmAAKYEEiyVopQCa63SjNBikfrca6QAGEGEAIJJlFRVJYHGPpUMrWysfvCrX88m05WlFc79WtZCiJs3rihoVrfXCfeePdg9PzoHlZKNYh5umqbT6S0Wi1k6W99cf/trb3/4wUflRcoI/+a3v/XLX/4yL2sDdN2URVVt7Gy2ui0I4dWrO48ePbLW+mHACO322gDYVqddS9GURRAEZVNjgBlhH3300crSSprnr9y+nhbp06dPV1bWrDIra2uNbIQQUegDaR/+9tHus13MWdxJaMA49c72T2Ma5WnebXdmi1lv0K+KsmpKFjDTSNBATnjaVIDbjVtbhqqbr9wAACALzs7OO70e9XBVL9wXujXQ84Ld3d2dnR0IISJ4Pp+3Wi3Hv3P369HR0crKCsbY7Xw6qBhlL8knhDi5Iye5oK0SQniBX1UVI/RlplpVlQOk6/Rsb287IgSEsCgKa63neW4Y47wthRCODe5+etkLhBAAcH5+vry8/JJSb7UZjUbA2LquvcBnjHX7PWOMlI2L2BhjCC4FoT6Pxi8uJyGEFmCLlFUSWsgQUABqwKD/z854LbIGXlLvP/NWUsr7Dx4sr660220AbHfQDSK/1+8vr6wMB4MkSQBGXhhEUeQIYhaCvKkaIUaTMUJIGo0wnowuLpt+wGKIoiDAFk/ORge7++Ui45gyhAPKCYB1XUspgbVKSMfGZh6HjEitiqokhHhBMJ5MLEaQYCHl0dGREhIAIIQgnBFKvcBnnEdRdDGfHpyfKopmdVHIxmAYJbGbgDPK3Td0XddnZ2dBEFCPd3u9Woq8LKjHISNeGHS63bjb1sBmRa4hyKp8kk7feOtOb6mzc/PKu1991xijlZC1pJSWeRWHUZZljaxLWRCGECVN09S1IIQ1tSO4wfagAzh+5bUbGpg8z//xBz8s8spFAM55q9MCGGztbK6sLY8uzvb392+++srW1pY0QmtdFKVSl6rtLh/zQo/7HDhKNyfW6oODg9u3by8t9bvdrvsLpmla1hXGJAzDTqcXeJ4S8t13373z+mvM41lZBJ6vhAiDIE8zp2ENtEEAt+MEWlCmWRIm+893957vHh4eSinLvHSGWkrowE+sgeOLqSOsb2xsONEDB7bRaPSS4lOW5YMHD3Z3d11cepk6LhYLN2g5OztzetnHx8fuNnAlohNtcD1bV0y58tLzvJWVFUfudSDxfT8IAvebDILAOg4txm5S5QyIZ7PZfD53wfMlvN3QyDUIOp1OEATufNclppS62tXhEH2qpWQ/p4r0+TEMAEAZc5lRawMBIAgb9c+vSxEA6PcVBt2hIZDQjtJZY/W8KTMjlnbWv/Ttr0WdOCsLp3zXNA2AcDadl0UlhLAQWgggIyenZ/M0nS/S0/Pzpf5SK4iLvLIG5nl5dnLqc04R7sYt0ygjFefcIgggTNotZY2UkjAKGSmVUBgZhGDAZ3VxcHE2zdP7jx9nTT2qMsWx1Kqua8xZaZQNOU6C1lK/lsIVHphTQ1DQ7+iIlwjUCBZaTIt0mi0MAoPhECHsM17nhUjT0fGRqEqAQQOVILahdqaKoBu3hv20qQpVC6iyppimk92D3c2dzas3r779lbdm2TxMwjiOG60Gw6Ver5emc4BAZ6kbhr7v+3lWTsazphI7OzuWoKOLI8SghhZ7RBk9X2R5np+cnLS6HW0tIWR5dRjEQRQH3Odf/9bXPI9DAgfLS61WMhqPLLqUkz4dXVgIhJJN0/SXBhBjC8F4NlVGMkYux4BCGK3bncT3wvF0sn98dHh0NBqPsyK31pZl7iCUpqnVhkBktC7zstcb1Hkd+UGR565CG52dQ2OhAp2k7ZZLyqyStQxYaDWajheD4RIiGGLAfUY5mS2mzigdQnh0dFQURZqm56dnnVZ7Y2395Oh4Op4AY5VS8/kcERy3EkzJ1s428/j5xQggCDFyIxZX0QkhnLicY703jbQWUsqthU0jAUBOqcQx4x02hBCOw+AQiCEqsnypPwy80CgrGzWfLrrtXlXUwECMKLDIGGAtnE6nw+FwZWXF4RwA4JgYn2E4fOE49NPHyzOd6Rl4KdqgjSMV/4mdmC943iLX19XWQmSRBdBYa6AB0BijFfj1L9/zLK2L2mLieb4sGqgAAlZrHbciqVVVlIRRZTUhRCgZck83qlxk7XYbQ0gIcaIv5xcjYODS0tJiMYMYEU7qul5eHuaLNPAC3/cXsxkw1rPQ87zKqlJL6vtpVawOl0ejkQZWCEERjtstyLCuRYRoNp0bbBGjSbebpqkTU7dKZ2UBGDHANkouprNWGHXbHWiNEqIuhCMGAQC0URhAj1MpZRCGWV0ChLpL/dF0EsQRxAhDNDodNU2FOOYRf+udN/eP9nd2dqy10OB/+slP79x61VFV9vf3VjZWEMazPO13lj7+2d2zg/N5lg4Gg9du3T6bnE/L+aQYr26uiFoyRefnizwttNZRp8U57XRaabnAIbt95+Z8NttaX8MYN0oyj5+fXSRByBg7PjuljOVpbqwerg673W6VVx7lBNLxbEQ9zH2mpQl4oKUdjUaFqDa3NxAks8nsFz95vylray31WNyKZCOssFhhrCGykCAURGHVCKVl6HFZ1R7zjbF106RV2lrpNKD+y3/1V9oaAICs1fvv//rmzZvKyPH84vadWy6JdaHebaJcXFysra29VOskCM9mM4xxFEWz2cTzvKqprbUY01ar5TDmIqeUsqoqxojLih33yBWTWmvOfWfs7TpDQRC4l0vZvLR1y/M8SRJnWOr6SW5FjjFPSpllmTMyjqLIvanTEyYYI4SODw9u375tgEUIOa8aAIx9ocNijQIAgBduhuCLmIMvAfwpJEOELpdbgIEEYKT+8CTmC4EK7eV/l1c0EAJ4uQsAIWO8lI2om5vXrx7s7T8/OvrSu185PzqXUmR5GkVRmmcX00nAPapou9cZjS+0BUEQWivjVkIYJQirWiKEtNStICmbWkoZx3GWZdgAjHGjZaqbtGgiK6I4VEUlpdJ1FUURRAj6XkigBrbV7QglrbUckePDI4PBtStX0tGk1WoVebrU7U/TDEkDMRyNzgaDJaU0ZwxC4CPrtboEIlFUhSi73a6HKACAeLwsy298+1v3PrzbiGr9ynaeZkQJA42UTVUXNOJaA4TQ7XfucM4RBotsQQlZGSwLISBGn9z/yFDTXe0bpY0x29d3pmfjZ8+fe3Ho49AQaDkIAO/0k/Ur65kqTmfnFNHQC1+/fY1qNjobPbz/qGmapeWlpqmUUXES4ojP08V4fLa2NgQAZNkCVOjw+OCt19/gnAeR39QSALC8sno+OQ+TWGmNfGKMnk6n3WHHg7yqqoAHHmXzybQQ1ZUr29rYo5NjDUHQaRVp1u13yjxTQmBLtTEY8kWWyrpZZ+s+5wAwIARnBGPoBT4iqGhyDvF4vJiNZ61+GwCwWCzOjk8e3nsYxNEbb93RWgNkEcFGSQsBYXQ6nyECXc5pjEIIWauTJMrzfDweXVxcrK6uMkIppULp2WzmeR7GWCpFHf2dc60lAMAtiDo+EADA87ymEZTSMi+01kv9gVLq8PCw3+8bo9I0HY/H169f9zzPiZU1TePmMVXVOJWsdrvtMCzqRjEuhGikaHc6SZJIISaTCULEWgg+pcbwUt/sMzj6Iyj79AkGAmOssZZYiB0bVxlg/jna9sDx7O3lIozDqn1h/IYBbBrpeZ7RgCPSpFXihyfHxz73lofD0fGpEHUtRRzHUsqszCHDlFIgZegH86x03jVFUTGEX5oOE62qqup32opxTjljzGgrpZTWlE2N2n1GsJKSQliWpYSWGk9ba5xPCQTA2KosjJBBHDZpEXAPYwwAmk8XiBFrbd2UPOAa2ZWN1cliXlcVhcAPPNmI4cry7tHBvMyjMMzSIi0zJeST+w/zLAMADPrDKGkf/uZ9QlAzla+//YafRIsid4llEsQYI4xRlZZJFD/df9ZdGly/fn0yuUjzWRTEhDItdBTGK8O19rDrefz6zesAGNE048X4Bz/5R4hBFAUh8l9/9TVtLTTYi4NGVlVV5XnOGLl69erH9z/88pt3KKfLgy4hRAhx9+OPXnvj9Zs3b87n8263SwhiSdjtdLjnnV+c3v/4E0b4q7deLYvi6tWrh2cH7XZba7v7bG//+UEQBPM0fXT/cVFV+/uHCLKmrKI43N7e3lxfe/r48fHhSSfpxWG493x/cjZWSimhGMGMYAjAZDLp9nsIAd/nRZq1otaTB086g47W+tHDJxiSVpw0jTg6OH71jdsWqqaqEUau2j89Pe33+5gQ0TSUUgitu6k6nc69e/euX7/upBUdE8iRioQQbsrutBEgtHVdz+fzXq/n+sbD4bCu68PDY9/3+90epdTtuwwHS4hgCImrYAEAzsOmqqp79+69YBS3O52O01taXV3VWkt06V3kNLuNtW5dodfruQ+DGbLavmQyXKoTQosQeslqsL8vBfr5EOiwDjGEAFptjAYaWAIZxi9sxv9Qfvv5Q0MAIEDWwBeLcwYgAAE0llI6nkwwhLPzCTdYQZZwX2tdl1lV5wRTaCzzPQst8dk8z8LAe/P27YuTURiGTVkZAyilTVlZa7FLSGrBGJNSc+5XRYkJJBrU83xpfRURXJRVLlQvjJuyDsPQ53RRFMLqVGuKiRXKSMUQWmp3PM6brIAIgQBQxiDBACHiU6ttlERe6O0e7HtBFC+1KMavvXrnaG9fGUMCJrWYiRQyy5BX5sXo4DjioRDig/c/ENQCxvKq+O5ffqeGWgLZagdS6rOzUTuJsaHUouPjiw+OP9AQLA/XqM+ijfDkeJ8zhiwiiHz/H/5BaPX2l15b3ViLWt6dt28/evRo5+b26fFpVVUrS0PHlUEQKmB45OVlBi00oinr6oNf/Zp6tF4UXq+lKg2NkEavraz3uwOEkJHq4GBPG7m2tlYWue/zTrt9fnZ265Xb0/HFYrG4cuVKO+lhyM6Oz1tR+/DglFKWRPFvfvFh3I08TI+fnwIAgsRf/xd/YZG5evPawclxb723urFKE6Z/I6y1FCAEoLN7CIKAU2aMaUWtrMwQwvW0uPvsIIyjr777tfPz84ODAyPU8e7hww8/ufPW68paLZXS2gujW6++dnx83CiJMXaLWhAiRHAtmqXlIcTIAAsA8MOgLMumqQDgGEOEsFISYgwhdA2b9fV1rTXlpK75YrGYzWailmVerC2tIoiQRR9/fG9jY40Q4tqumKJaVNAiznkUJa+++trLdXDgrIO0RggURZkkibWmasog8rWWCCGfe604OTs+k1IuLS29mJU68i2wCEIIgQFKa4R+byj6hfXqi39iAA2A0C3iQgiBtgYAg/45erzAjUUhNBZ8WszQRS1EiFJaCPHOW2/v/+YhtiCg3nQ0Xl5fPjs77fR6QgjICPc9kSptzL/5d/+aGPDJ+78BxiLieWHQbvVPj44doSxsJ3med/2ez72syPM8j4LQaqOF9IkHISSMUa2zonSbgUop6nPViEWRrayszGazXtJGHrFSYoQ4IgZIg5CBwI/ji8lFf9DNFinlDGPY6XW6y4NFlg2HwzzNalEtr69QSnvD3mg2Wd/aWExne4/22+02qq1Ryr2dBMZvhd1BO61yv+0XRY5phAiMWpFFcDaZirK5+9u7zPeidksIgRX95P7dN++8aoyRpTg/O2ukaZrm0cMnQewnYaK1vH7zOue80+l88MEHYRjs7GyfnZ31BgNjzZNnD7/8tS9f2dyans8+/PAuhEAqmc5n/X738PAQY3zj5itXrlzDkEgh+/0+Iais8p///OdXr1y/uLhotTpf/fJXGGanp6dusr+3u6+1jvzIC8KlpaUsy5tG3rl95/rt66dHxwlONjc33/vwlxQTDVQtRFYWJxenySD2W76fBPsP9nzkd+KWH/pCSefb6+x/wjCczmdhGPaizvLa6urSSp7nWus///M/j6LwH378g6PTk+0rO2ub6y+FyFZWhnmeR1FkXniuuGGJW2xyZCMAAOd8sVj4vu8WWVxL0vF1XcfoJc8+7EXGmBJXrn0tpTw5Obl16xZCAGKklNBaI0ckUlYIwZjHOXd0X0qpW83JsswtV2ZZ1jRNFAUYQ2uhqzydzt5Pf/TTv/jrv+j3+/ZFPDTGWABddul6vC+PTwfCP5gGWwuhBRa6OhxBIhr5J3q8n7kW+l1RioD9XZfM3bgIoTov7n7woTOuUkoppREiBoJayaTbef3tt65cu8aZd+fVV5Mwms9m0AIIYX8wuHHrJvW4F4c08PwkmGUp9b3GiEk6JT5VUAvVOA2TpaWlRZG7UXK/28OUcs4pRLpsQsKohadHx5xzwmiaZQhjPwiEEEm7RTmTSkW9lrJmMZtTC6HUsqjGowtR1RvLK7IoF2cXDz/8+OD5rmiaJIoHvT4AoNfrJ36cp7lE1nCEQiJME/lBOpktr654sT+fToxR87xorNbUsICE7QQgBBCxBgojuM+FqDut9tHBMTE8YOFSfyiqOgiC5eXlgAdW6MV4HrIAaCClvHnzprtjOq3WdHzxH//jf3j06OH61hqmqLfUIxwLLQzQWZYJ0ayvr5dlubu7d3Z8iiz0mVfXAkI86A/ffOPtzc3NTqfnvADd1L5s6nmWPnr88PDwsBGVMWo4HIRh8Oabr7/97tuexza31ocrS+ubayvD5aePH1ttqiL3GOl3e6EftVud1958o7PU95PIIGhf5HgeYwAAhBA0kEFKAQoYP9zd/8EPfvDRJ/cgoXsHR5iywI+Oj84ZY77vQwCg1QQBgoDPqdVSK4ERAtbmWdbt9jud3ng8Loqiqpy/qAzD8Pz8HACQZZmzeOp0Om6s4rrQbkbSNI1btbPWamA1sIQzjPFoNNrf37fWEkZfWHLys7PRRx99dHJy4q4shHCt2larpbXl3D86OsIYc+47iEopF4vFwcGB1npra8v5jHyqD4SRBRhACDGE+E/2dR0wrb10KHZbBw5WL/l5fyKWfj4NfglrC1/MS+0lnk+Pjqs0xxZgjDnjWuqzycX+4SH2SFrk/eHSwd6e1tqDuFkU0/PJ8d4BhNAYMJlMiqqUUqfp3Kek0aLSKptNfEgizxdKDYbDMs9d/gAhbMWx0DoOfAC1rGqMMDIAaMMxHiRtRRCmJM9zCOFiPldlvdZb8jBd5FnUTs7Ozvww0E3diqJaNFVTb69cTzrtqqriOPbW6d2LD4osn16M86pkvreRJFroYXeQd9LpbExivxaVAUYsZhqoRtZUEUJRGEWKsEIIKXXTNJzwfn+prhvm8WvXrnmep4Hc3t7+6Ld308nHS73l/tIwCPlb77yxtrZSVnnoB+dVYxoFMAAARFHECH348OErt28Nh0Pf8yCEiGJhlFvRqkX1xptvzGZTxtgwiaMo/tGPflTVotPuJUmCIDYGNI2klAOA8jwPgiCKorIoPc9zXALf97/5zW8Waf6Tn/7Io/756Smj+Or1HULRwcHp3uH+bDZtmubX77/3/vu/GCwP11fXfM6ttpxSxfny+spob0QoxZRgBHTZAACMUgAh1YhWnFCCGiniMJTWMsaMtc/3ds8vRpgin/lVLqwyEAGGiJSiLMs8z1utVpYVFxdPr19/pdVquSkohPb+/fs3b9509JimaTqdjkuzncaCIzkjhBzLihDu1Mycesve3l6WFb/97W9feeUVAAzzeFlXk9l0MBg44RUIYK/Xc+LX9+/fd6HY8zwXsQeDQVEUGxsbVVW5wJPn+Xg8Hg6Wt7a2HmQPer2eU6VVRkL4Mnj+wbT284B6iVlrrQUWQmiMdltnbjjkEfbPY9v/3gkQAPupDTYEh8Ph4ZNdpK1SqrYAINLudF7/8jvUo//pP/znvb29d159QwuJtS0m88fTqe/7WTaHEFqMs7lgBuNGIUpZwKeLKcAgXcyBkkEQWIKKukBBGFIutcIGqLoRFjsjENHIiIeybozWlGJjzGwyjeMYU6obRQDB2pazRScI06xodWJIyXw+txSXjXrlzm1p9Ggy5r6nmrppqlI0iLDpeDaZTQFCF6cXSdg+3TvDEHlJNC7mPParomjSpt1JXsgmhEZrhGCIvaKaf/Dobj/sF4syCKIsy09Pzte21y2A1tor13YwJNPR9O79D9tL8daV9fd/8StR1xvDldHZWa/Xy8pibXtDaz2fz/ePDpdXlhAlAWcGgsPD/ZWVtSxL7z+8t7m5ORwuCdFQSmUtCGZS6Fdv3Xn+fK/f7wJo5vPZlevXFotsMppsrm9mWbZ3vkc9vrS0NB6P1tbWXn/1dieJIz/4q7/6yyePnty8dQNZ9N5vfgEQ7PV6d16/9ezJ89PT482t9es3b+wdHty6dSvLMqShUNIi+Nobr3/v0fcYYcYYBKEX+FJpgpBRmgCoGwEtMxqEcVgqsRRHp+NRVdd+HBmhIUT7z/e3tjYYx4tyTikOuWelevLgoVJmY2srDEMlDYBYaVtVzZ07d9wQ0lobhqFSajKZDAYDSunp6Wmn0+n1elrrJEmKoggi32UNQghCydXrV0Qtv/Odbx0cHAghWq1WFAUWAq21sgZYg7R66YB68+bN8XjMOQ/DME3TIAiKoiCEzGYzSunh4XG73SaEXLt2DRiYZdlsNrt165ZLyI01EEIAXA/Jwce63PjTmPocaKEDsn3BtncnaGMoIRARraz9Q/ulf+wwFsLLRXK3Wnr5JtYyQvutTtbMhJASqEF/qTivoLF5ljFK2+2uFrLJy+VuPy8LSGA6mzNKEcZFXQNrEeJLS30Fjd9JaoZPj49jz2vFsePQxnEcer4pGwIRA3ap1a3KUgihtG6FUV6VAeVOkW+WzmonOR9GGDMWAdsI67RShewkrcPRGcRonmZLg/7Bk2ermxsSaOcmwBi/fvOVAPHf/OrXXhCWZVWlNemTphJlVS1tLwVh0l/pdTodW6t7H39SZjkd9gCkuag9jKy0UIJiVkwOprKRPvNbQUfUskjLMPGVVpPZrNPpBK3wzvrywyeP5/PZG2++drR/tPtsF1qwWCw836+qapYunj179rWvfY1TDAn++te/Tj2+yFJKMQh85nOA4aOnT9LZvNPpRlECrZVSf/zxx3/5l3/5k3/6se/7O1e2giCglJ6fnF5cXGxtbXme9/DJ4zAMoyhqmsaJZbro9M47b1NKMUDf//u/6yz1NrY3KSLDlaXx9OLdL30paEW9Ye/BJ59cu/bKr37x/vLystKaQoYARABYBKu69sIYEei4o5TSsiyt1hiidL6goZ/nOefcef4WaYEtTefp//6//u/vfOWtV+/cRARCCNtt5vujWzdfFVqVeYUJQQifnZ8dHe5//etfdeK6LleklK6trRVFgTG+fv266xI7u0QAgFNIdbuj7o53Yg5Xrlw5Ojra2FrHGGtrIITIojRNm1xgjB38nL97t9u9f//+1atXHadXSrmysmKMyfN8NDrb3NwUQvg8cP7CjjeCEDIGWuuWzuALFaQ/Zlj64nn4suX7ArQGY4whMtZeXuGPTGL+COHQWgsgNC/weXkyhHVVEwADxmMvaZR0i2NrvaUnT5782Ze/sfv8OVQGAVCkmYUAExoEITB2XmT91eU4jmfnF2lVIgQHUbR+4+r3T09XekuqrC2CGEFEaVmWzEBZNzwKsLYKIAnhaDYBCHaorzGUxgathKma0SivyiAICCWNFko2Pve00TwMDo5PLEYQ45D7s8NzaM3B5CH0yeZrN2shQy9cGq787O9+lAQxpjzwwrpqyrwqy5L5TCi5s3El6cWYYsPNu1/70m/ee29laRDGUcjjRw+erq6sE02wRX7AlVLEJ4RQKWWdV0apWT7TVnsBz0Ghkbp+/TrDDBgwHA4ZRtDY2Xw+8Pje3t5kPnNyldpIK2VZlrauxuNxO2mlefr6m69duXKtqqqbN2/t7u7evfvxZDyzWmNGv/e970Fo/+Iv/mI2n7hdrVarbV+w1W7evME5r6rq/PycEDadzn3u3//k/tWrV3d2dpyJVn+4ZAhotCIegQxZgrRVjPNut/s3//E/t6LO7GziBTzkQT9pE4gJY3Vd1nXtU6aNARgBjMM4MkpLrUIvvFgsSlUHrRhrW5VlN25BCA+O9ill2xvbmPBGCUoRRHCe5kIbjCmC4Gc//WlVVSfnp2trK/PpIm4lEEIAJMZYGQ0QJAwThqVWmJLl5WUAwPn5eZqmBuhr1641sgnDUAmNEAIIGWspZ9dfuTGZXFBKAbJaa8IZY6w0NSYEYoAp0lr7oaetanUSiIGFhlCCyCWJp9Nrh3FAEHaFKADg1q1b5+fnRV3cvn0bvpgMvex+fR5Bvx9IP9sScme6NXcLrVEaAAgtshb987pHLykNL9/78qNAABFaLBbT8aSu60ZJKWWapnXZ/P33/tvB8939Z8+TMLp0ayaYeTwrCg1spQTAKEhiS3Fa5Jgz6NFP7t8/fLbbT9rWGAuBRbBuGqVUU9UYQN/zsAHYQgpRO4x9xuMwAghqYIMo3D88kFpJKV1iBhmpZIN9Pi0zRWClhJSySLOmqlWjfOJ5kKqiSaeLo4NjaK2oGwapRyiDtN8fiEZbiDAlK2vLjBMtlc+4TzxqESNkMhnLsv7trz54/nRvf/dwNk6PDo4P9vbX1lauXNt55c4NxLFQ9XQ6/fCDj5TQB3sHw+GKUqbT6WRZ0ZQNAsgYQwjqDwYGwfWNjeHqSq/X21rfcPJZQRAYa8Mkns/n2Tz70Y9+5Pu+FwaMMc49AMDG+lZTyyzLAAAuYrzzpXefPX+yv78HIZRS1nVVVaVDpos/lNJOp3flypX33ntfSfO1r37j/Owiz0pnOqqVANpQgrSWxpjRaAQw0sAur61ubGxMxxNorRtLuhFII4Sj6WlrMaUG2EYKA4CTundEoiSOgdRA6ZAF6XQGjd1Y2xwOhvc+egg05tgzGu4/OxqfzWSlsCUY4MlkEobh//I//7/ffevdsixHZ+dZljWNdIJMjmZkX5BvHZeg3+9fv3792rVrLkF1jeWXt6gj6CZJ4nRwnLhxEAQbGxvtTuIavAihOI7rul5fX39JKnZdaMfjxRhDaF+up0kpl5eXnzx54uQaPgsKaz+dx76MmZ+Zx7jTLukQLx67vpG11qlN/y6WfiY6fz6HfnkaBEC5n0BjjYXghQkHZ3VdR9TXWrtNZQih5zGIEfO9rCoBAEHgN7XwKedxbCDqD5c1BE92n0mtRZpZAjfWtpJuZ+/hk8jzFQYWI0CxFiCbz4e9viprgjBCaD6ft9vtvCzWektIagyQY2kLIfrdziJLPcYhhKcXZxsra/PxxOskhZEIQWIxod75aLy6vGyNjOJW3OnunR+Jut59+GylN5zlFQe0rhvCPRj4VkrsMahV22tPp5Onnzy6urMFCTwen8zn853t7YP9448/eCD1ZWciDNi1G1cQp42SveV+5EdPHzx58vjx82d7VdZUaTUYDoBBid9KZ/nu+W5RF6+9dkc1QlhVyjpQwgsDz/OgBVVVSaEp5Tzwt7Z2rm1de/LsiTEAIvIf/tN//u53v0swK6qa+R7AqKgLP/K/8pUvGain08n1m9fG4xEAAGN8dHDYbrcnk4vTkaqqCmNKKQ15NBlNfeb7vj8crvy3//Z/dfs9n3tnuwfrvT71/clo/M2vfO3x08eD1YHv+5Sy1954M50V2loJTGupP9q9wJReLmEyagBotOSUCSGEkgAAKWovDKTRnHvW2vl8rnSztLQ0zzOhpFKiqqq/+9u/wxhDDI8Pjwkj9+8+2L56xUKDILl6/boyxvf9Nm/XdX10dNTv9xHBABghRH9p4JLby3uPUpd8urv8UvpcWSeUAyFEiFirtYUQQWsviejGGGuE5zGlBEIAQqu18n1ujALAYuzyT2iMstYSQpumwYxoYxDCdV1Rj56OTp3YxSV84CXDHkLoVOZd1+YlXP9g/HsBbKfbclmXQgKMBRaQ373B77/mj3eP7At54MvQCoE1Nk3TpN1CjVHGaG06nVZWlBfzKeN8a9ArlaAIF3XVjpMsz/1Wy4nf3Xv00A3BdnZ2tFSjiwugdOT5PmEGQ0TJ3smRMabFfAgh4SzPcw8APwwwJQghj/K6KJlHLQAWo363FzAeDpeV1kabpf6gaup2p1OJhntM1A0GFkEwHAxGo9HKYJhV1fVbrzw9PwZSh9r8+r33l9pdY0zSbm9ub61e2frl+782wBZ52u91OCYyLZ7eeyyBeuX1G6/euo0NFI1lNBtPZmVdNbL5+jf+ajQdEUrTIt/ZuaqkvvnarTtv3Pnlz345m81+/tOff+c734lbrboQ9z++P8/mnX5bW0N8zn3vdDw6Oj+9efNmHEWqanhMP/zo7lvvvqONxYhgiOD/n7b/bJLsStMEsSOvFq49tMpILaBlFUq0mO6Z2VkOSaOR/HnLj9PcNS53eozdPaW6qgsFkVCJROrQyrW4+kh+OJGBBJBVLbg8lgbz8Lh+3eFx3vOq530eDf/xN79dWFqwbfu//tf/duPqjTRNBeNxHDNW+pE3mg7r9VoQBxDCpaWF2WzmO6FNrSxLmp321tbW559/Xq83gdSCSYSsL774qtvtPnrwuCiqPC8b9dbK0rJgPGGcENJotwQ8721wzhuNxsrKSq/Xy5J0OpoGNEIIaQTjOBZcIA2E4Nii0CKGAkoIARizbTubzR3HiV1faoUIaTQaaZqmOSiyDGmEMZZSN8ImxjCdZh/9/g/TZLa4vLC0tKKUAOd08hlU0Hf8IA4qznq9UzM4ZTyqZVmG60hKyQUPgsCyrLIsEcCWZY1Go0ajcU6MdD7tCcHziS6j2mR29bdMohCawNV444sKEOec88rzPMGF67oUW0mSGOLfH5rc94zlwqB++ODFJYFUXBiQnIEJWNYfr/H+KROFAEAFzv/z7SdzXbfPKl2IqFanEgAAJQLQsyvGnh0dhL5fZMVCu+NQS0hpiPayyez0+Li51A48v5wmtutwKQgiBJG8LN0wWN/agq4luSjTjCmZFxkhGFmYcz4cj2xqAamAkA6mJauUUgRAl1pZUXi+xxgDSjuYtmr1Z3u7URT0jk+7tWaaJhBi23IBJmVV3Hv8MGzWndhLswxbuBTc810B9b1735yNBmmWdRfalmvN59O646fz1HK8MIgpplBpgBClNE1ymzrUoYgA27Zd6f7t//q3//n//H9KxjMFtOO7EoPbb9w6Oj5gJf/VP/wqqsVLy8vIxj9648dFmR+dHjmO4wYuHKONtbWqqlzLNvNZrusNB6OoFh/s7fuWd3xwuLy4eOeVVydrszAMv/zsS4TQ4vLSfD4/PT1eXl6OorA/6juO4/tummcGOG7bdlyPvCJnjC0sLdbjxnQ0+S//5b/Uo3rvtLe7u4cgEVxmWdbtrjUXOq7nKAUg55USjW67ZAWlNqy0lmDcG/QPT5ZXlupuGJFQKi0RqhizIUYIUs+zPDeqxcP+QJQVRdhQ5rqBXyYZ1dALfEWwQqAWBbwq4mZXCBGF4XQyt21bKIkkdKnL7Oro4NB8cqRhNs/joJam6ccff3z52mVqW0IowTgrKy/wjedkjB0cHERRpICs1WpaAs/xAQCMsXa7fXh4uLGxASEUSl6kjoZjxPx4ztsg2HMgMdBaI0SUEhBCIc6ZXAyy31yPEEJI12q1hYWFyWSy5C+aqtH3otkX5zufR8VIaw3htyJOFxaLEAISUGoLIRTS5nBEBKPvxc0Xt3tpuHs+WfNCeI1eeG0QeAoAZJ9rRRr5lm63yzkPfd913aIoZrNZr9/nnGMA60GkShY5noso1Mq2qdYy8IIyz6VWCoAkz548eWKYqbTWGSudwM9ZlZUFpVRDCDECFLthULJKa60gMDV0k31h61x/cjQaGdhXnqe7B3tSKy6EZVlpkUe1OiakzHPA5WK7Va/XEYHQIkVZ7u08LeapjUlV5IwxVpRIA4/aSoHeoC+U5Eoenhw/29mxXcv1nZ/85Mcnp0e//OUvv/7iPgLo7h/uWpjYtmVZBCBNHevOa3cIwhhgz3Fthy6sdGvNaG1tJY7j+WR+7979brcbRVG9Xq+qKkkS27YN+YiU8tKlS/Nkatv24eGhEMLwBqysrGxubk4mk6oqhGQPnzxCFDWbTa2lqViWJfv000/H00lVVQAAYtE0TUejEQS402wNBoOyZJPRlBISBUE9rkVRlOV5XhaEUozp4emJUBwAIJmAGp0dnmgJLm9uYwU9ZPOKAa0wgaanr7SuBJ+nyXgyMTINBsFTVZWFSRiGjbimpZJ5yYtqeNanmEwnE4xQnpWu6zLGKSZVXtiYtOut1YWVx189IAICCZJp8sXdL37x97/strudZqdRa7ZaLYSIlHJ/f386nTLGgiBYXl42nAyc8zRNJ5MJ53wwGBwfH0MIjc7dcwZQfDG5ZmzDkBKafowZl7mgaCGEGAQixngymbiua6zDmHej0bAs6+jo6MJXvWgvFz++mJf+8LIX10Xd2OSlAIDv5KX/wqVfcKAQAKSBhAoAhDGGruNEgUhKBYAUQilNIMpHUyrB8c7++uYGhKBipeLKdRysIZRqsdZMbTcR5fHwbHV1eWl15Wj3SBS8l2ZBEECtUcUmRdntdi+9urm3tzedTpsLnWQ0MSzVaVkwqBxqiYojhAimBWeQksPe6Wa4OU1nlmVxoIo8K6q84sx2HVZyrhUEiGIklOz3+4SgehjOe/3pyTHAKAzjsswt126iZlEUnPNqnnLNEFeSyJKzWrt59c1b3zz+6op7pdfvz/I5Ksof/ehHXJSB5/ZOh2mabiyvYoWePdlZ2VwBFEKEOOfXr1+XuTzc2ycEbW6uF4hLqFTFPdu7sn1lPBxRiGzLMqURIzKvlHRc23FsjND169cOg0N6ejqbjD3Pd8LQj/wgCIQWtVpUq//k0ZOHO3u7GxtrDx49fOuttwixCCGvvfaayd+ePt5Z31xrt9unx2edRnd7e5sgur97uLW1NZtNqG29//77fuhUMkca7O7ur6ysRnGQ5zmv2Nd37+lMU0Wa9cZkNPJdTwnpekF/OICCeoFb8soiVEqBAU6TGSEEuFZVlFBAQpBWAiMklLAIgloBoTpxXSOIIeKCCalt245qkdY6jIPhcOj5TuiGw4PT/37cp55zeHTkeZ7v+NPJXAjpOratLQW06zYMaYNbqxsKhcXFRdd1lVJOzTUgno2NjTRNkyQxXP4YI6WUARgiRIxvQwgTAi5UmJ4zG50TRCBEiqJCCCFIut0usS0AgBKaQKSBNieU53kAnDP1GW8JzqdEv0cRiH/oXS8eXFwphECESK2B0pQQpJ7PkoPvlm3/hK1rrSXQWmuoDN2nWVIqroCuNWqWbzPGEAJpmhqmcNe2DYXU5vo6xjgKQwKRYAxKBaVyKCnL0nKtW2+92mi3HOr4tu84nhf4lNoWpWWabW9sNuqN5eVlKWVW5HGtBgmGhg5HCeo5AMEL+vOSM0xJd3kJubZxs/uHh41WazqfrW9vzYpMEpDxIslSgjCGIAx826FxHH/ws59ev3nDCRwAFALac2wtFSHEdd1urdmMawgTx3OlVk+ePFEaBmG0eWlLAelGTqNbj5vhG++84bj+Tz74ebPT3bq8dfXqZSY453w8HhuN95vXr1oUL3RaGKOvvvwymSbDwUgwAZVuN1qz4QRpQCCybTst8rAWB57PyypLU60lpmR9Y/W1115rN1u//93ver3e2dlJliVS8qgWMVFtb281m/XBYLCxsbG7uz8ej3u9AaVWkqRZVkyn02fPnoVhuPdsJw6j7e1t27Y3N9eT2bTX6xVF7nkOwsDzPI0gxTRNU9/3m836Qnvhndff9qhTj2vJbGaQa5TaFS/DWkgI8jwPY6zh+c6hlFZFSZ4vJoVhLZFSlowppXjFtJBQ6dD1mnGtHoVh4Pmeo5XI0jT0fCAUy1ng+KOzweCk16g1FruLgRf2Tnq//+2Hs/HUFMAMzXy73TZU9IZV8GKjm36pqZPHcWxZloHgmwvSNJ3NZpzzqqqyLAMAmfaJSZIhhBfgYYMlNq51Z2cnSRLTeRJKKqAhhN1u13Yd9YPI9sKsXjASaYq3ZoHvOlvwHGxkJu9Mvq21hvCPKFD8iaW+Y7/n7GQKAhMtrG9vLa2tXrC/lZy5cXjUP4vrNUPBSjExX42UEhOLSzmZzyrBG+2W5bvUsR1iQSaiIJRcAKWRhI0o3nn8ZD4YnRwcddud2Wxm+W7FmE2IjXEURaenp7ZFQcV0xURZQgjcwJsk82anjSxaCt5Z6GJKglrcn45f/+A9YWHsWAUrqrzQUpZVVciqfWlF+rSxtrh98xrECCgtyqrVrN957c7Va1cQ1w52ICXAsk6ODx9/84BClMzmg/FoaX3FCiyBRKZLv1X7j//5f1xaWW4vNjkSs3JuuWRnd1crNewNkIS2ZW+sro0Gwy8/+yL24mbc6ra6w96wSIo8Sau8KJPcUCJApJUWvf4pRuDZsyeMlUILgLTSwrLJysqK6zpB6Me1aGllaTobm1m/qBYHUdhstzY2Nw8Pjp893QEAOI5jiBQ2Nzerqrp+/TomEEK4uro6HA7X19dd1/F9d3fvCQC6qgqzv0eDoYn0LIgthKej8bg/KIqiXq8jRJgUCkHi2I7npkWupeIVk1wUWX5uJBCZ8WvbtiElleCAYkSwRhBTIrWAQEEpkBCwqvhsXk2mOi/4PIFS1MIaxERp2Op0Nza2EDBZIoIQ9nq9L7/8UghRVdXF0LYxJPO/afAPBjFvpk9N8d/3/SiKEID9s97p6SmEMAgCrbVWMM/z+XyuNZTyXDbWGCoAQEpNiIUgURI8e7b7yp3XjKYGpdQ0t3qDfrvbWVtbO2+cAKQhVgBI/b0FjZT4d56CEL7ANmgeo+cY/YuTQmj1bfv1wqwvjoGXLviyhcH54JyCYDydIAsxLi/4S4ltGdq1MiuTeXpyelpJlWRZWmUMKoEAVyLLsul0ur+zW2SZTa1snjiWHboeUlIJ2e/3733xFS+r3ll/nqaNVhMSrLUmGFdZEXi+qJhSCmmguQg9//T4OI5rKysrDx48yKsSUEx869rt67devd0bnDm+o4AOg1hLYGPbIlYQRBpBDpQi0vKs5kJrns44qxxqDc56VV5prYuqsEI36ta3rlyKoqCqKi/wV7fW33r/7dX1lZIVAMKiKDCGQRxmZTYej/3I98Pg0vZmq9VqNZrJbH73o097vcFsluRZubW6jhWykbX7ZPfj33509PRQMum73t7Obq1Wa3c6rutiRCGE165sz6fTKi84k0IwxkpMoNmmXDLHtQyzVpkXw/5ACEGwBSG8fft2kiTHx8f7+/snZ716vYkA9S0PIYwgQQhZNkmz5OGTb5ZWu5BAU0owB3kyTXonPV1KXWog9aA3xIgCiC3LyooKIgIgVhAUvCCOLZVCBHuOY5yn1nppZRlZdG1j3ZiW4SKaz+dCKyYFpERpqLVOkiRPMwviRhgjKS1MojCUUo7m4+P+yazIKiDG05HneaZNb1lWq9U6OjjkZWURW0pJsSVfEOG2LItVRVXms9mEMTadTpMkMWxSSmiKrSiKGo1G6AeOY7Ynsm3b90IIsEk79/YOpDz3gQYWIqUcT4a/+tWv2u0mQij0Qgwwxth1/G63a9qqtm0r+X2U3/fs6EV7MVnxi+vc6T1HMpnT5/xiqckPDfIHRarnJSMAjLrChUeV8HnArIGBCSIIFQQCaiYFKhlB9OTgSBSV1qB3eOpZ7mg0AZRmvHI9B7s2sp3lhYaTzSrB9x/t+NR1XVdCFgLPxghLnXPhhX7JGFCqyIrF5RVF0e9+/+H68jLMKs0EwWgwGNSDyLHttCj8IJiNJs248eUf7kqk3nj99YOjfQUk9CiD3AvoKzeu3P/ivkucaW+80OhAAJNxbrtehufdTlMBWYkCWHhhc60ap8NBf3Fh5fTwCNqEU9Hc6MaNmCiAPNjrnWEbCc050Kuri/u7B6JSnU4XQg20aMQ1pSRFFJyXGTSEwLbtJ493CCF+Lczz8sGDB9euXcsnOSqUjx1igcB2gdbNWsOmloJaKuD6frPV8d3AsdydZ/vUthaW25UUaZYtLllVnsDnQymeE+V53mktDscD04ynlNYbteFs+Ppbb/KKT4aT8dnUW/SKGeMtjjE+ONr3IuvmnVuXr1751T/+pqjKPM+FVnfv3j18fLjUXfr0H+8Gnl+WZTZPIcal5BZ1IcKYWvPZBBGYlOliLWSaO9QZjoaCqyiKlAKD4Thu1CdpFoaxKKp0lkIIPTdI86yx0JlnqeV6nFdBEGVJyqHUujSKQwAjBUHcquPI9uqBEKx/cgqkcrUb1jxCSCWqiEePHj165ZVXIARQaaCgY7msYtQjnJXjQd8PvLBeR5hiTCHASmjPwb2T02aziShCCDWbdQClFBWCEmrHdZwnT58OBoO8Km2bGrMHSmGIBKtYVQlW/eSDH2kINJC+G5ycnDDGHNuDEFJqj0dTw4EGNDbIAaAl/tZWjUGqFzPKF+tPL1o1QufkmJgSzjnFFpKawj+uQAG+m6m+8KRBFQN1ES4/n4kxH8V13aEQAMHA8yHEueTdbldWLJsn2KKNWn1W5X4UBo67uLh4cLA3SieW53bbndl0enp62omb02xmU4sACKR0qQUxpraludAQEgSvbF+ezKbJaOwABKDGAC50FqGSAACEsdAqjuqulgVn8yJZXliEGMzTWb3ZKHkZEC8KwjiMUlBZvqshAEIFtjsfTPu7PdulfsOlnkMCd3W17Srym7/75WwyYowd9wf1pWZv3K+3agACgOHNV26e9U+bi12ghBCqWWs+fvg0T/M7t2MI4XyaYAwRIIaYBwE8m8087Dq+53nBex+8P8+mR70DglG33nyssawkxniapCenp1mR+1FAEFVQzedz23YY54Hvu46fZvM0L3Z3ny0uLNTrdUSR1no2mwEAgFRAaqRBHEZHh4dLS0vZPMnmyZtvvwGgklL2+8NkPP/i7he+60kuiA17vdNGu3np8hbnfG155fLlK5RSjcCPf/TBf+v9bZ6kHqDzfGLZtud5hFgYUYotAGBRFABBy3eL+ejk9CgOIyllHNWVELbrAoTLJCmqUiOotC5ZxQQnhCCCMSUmR9VCFmVGEBZIaYcWQpRlGddrg8mwudBmstq8stFZbKd5fvXK9s6Tp2ma+r6LKLGkZVkWUODJkyftdhtjaLJiQ1rPRbWwsGB7joZQaQg1AgrYCh3tHN6/dy+IopW1ZS8O6q1IIw0AwIhoAJWSVy5fnieJYcFGCBGEITynxifEarV8KSXnHGowm04XOotnvd5kMllfXz8+PjZV5Rd9pWnkPHePLy/6wD8CUtBaK62Agiao4Zzb0CHfu/rFuPelpgs1eKlwzXn/F6OVlZVkOBOY2QJOp1M/DBqd1qQ3MJWYyI6yQZHN5oOjk2ePn1iWlVd5Z2nRjAsdpEkQR049BEykaRoTBwLIOd/Z37u2fRlreXiwT117a3t7OhwC2wZcQUjEcwyK57pmnJ9YFkKgSLO7n3xq+TamiGiYTFNWMCTBcD6Na+06xDDjgnOsgIXhjc0ru4+e/vjf/5xBrXSW88p1KPUsJoRCMF5oz/KUHJ2VsxRTnOSZ5dv1VmtvZ39paYkq0qy3L23BL7/88sMPP7IJHZwNXNcWEtY6ccVFI3ajTrjz6JnlO8QhxEZ1r9Fcqj386hs2LIBUkFKBVMkr6FCq7d7J6fr6+mg4nk9n12/eqKr8rNcjhNy4dZMrFt65M+6NjLbC6Hi4v7/PuXz99utGB4nYBELoOE4lwPr6ejJLPcenEHVazTIvKKONVh0TfXx4bFnWZDL97NPPL29tf/np56vLqzSmQgiLkNdfe+3xvYfne0NrLVVRJq4XVHmllNIIMikmp6eGi0QWHFJHMOHYdpEWGGOotGPZAIAsSRlQ2iICwlIJ23MF5xbCGiri0Ml8sraxsX3lUn80HAwGAgBVQG3BMPKHZz3HIq1WSwhx5fo1IYSJ3imlRnrv6dOnT548ee3N1xzfk0KYQguxqOVaXCuMKJIAC0Q4ePDZ18c7B1QBIMrcTnuHvcZ7bxHPYVIoCLiobItAqEPPLcvSwsjg2AAAWVFYlmVThzHGyqoWRpzz+Tx99PipQVnPk+nS8kKaZdjoYkAFAH7RfEzKCV5owLyYXf4wtYQQAq1takkIKs4gQrZti0Ii8N2I+cUXfO+ZFw0VafC9K8E5pb98zv89U0ohgo9PT6JGPS0LrlVYrwklkzybTqesrFzbmY4nruVqLrAGB7t7mJDBbGTHXlrmru+Z6VhWieW11f546AXuW2+94XnO4dH+ytoah+BsPEyrQgAdNxsKwVmaKAzx81n7dqeVZdlsPFleXInDWmD7zahZFiJnnGkRtqKMpZAoTAGrChsTKFCVMcF1rdGoBONA1tt1rjiiSHCpuAqc4J233r18+cq7779n23aelwvd5elg6iIPlaAZxqEbTIaTYX+0tb4Z+fHjh09+/Yvf1uM6Aohz3u62EIGtTlNqgTDQGhJC0jQNIx9gIIBY21pvdTorKytZln3y8cfpbL61tSWlpI795df3jk9PzKi9Y9mO4+V5bmFrdXnt3XffHw2Gk9E4Dmpag52dPZtarKwwxjev33z2+KkWCiothOCSxfUoL9Ir1y7/5Cc/LvMi9Py15dVue+Ev/uwv7358VzJlYUoQZmnuYho4ru84geMozgHQrCow0AZnE8ehRTHWgCrgYIo0IhgDqXzboRBpLs6OjllRmpoKsShAkCspFPd9v2RFVuVMiyu3r29c33Rafmu9u/3KVafpL28ttxabxMIra8u8YidHx0meGW/ZaDSuXr16/eaNTqdz69atDz744D/+x/8IIdzf3x+NRlVVzWazfn8oFAAaAQmgRhSgr+5+2T88FVlVzvJqWhw82p2ejP7wm496+8PTndOzvYGDCBASMEEAxBoIxkaj0XA4HA6Hru3Y1FFKUWxJJnef7f3qV7/RWm9ubmZZFtdCw8dtemYQ/XAq7dwIL3LRl1rZ9x4YWlMhBEEYACC1orZFLm70Us8Jzh3xd80dAAC+Y6gAAEIQAFBwQQGhlAqEhJIV55qA+4+/EQgwXsrJMI7jqzdvtBvNR/fuW4RWWd6O68QmMq+01FmRrSyvbd+62opqg71TJYXl2JxzCDGy8aNnj5nihKA8rzhQGhOvVsvLIgrCZ4f7FJOKcZ9akrGKl/3JzHItQ2+9v7Pb7XaHw7HlOoPx6Mc/+akA0nWs+WDwozfefvDV16Uozs7OeMn+8b//09r1S+vba8CSAnJJtIYKASLS3Eb4yTeP79y5Q31HQVCrNe7d+3phaWU2mP/27q90WVmuBSmuRbGRQrt69erO3+1Znn1yeLJ1eavIst///vdvv/FmrdYoGWNCYKjHwzGEsOI8z4tpmbzWeZsJ5lJbI+gHQbPZ/Oqrr67fvC40Oz4+LOJSylsIQcYYhPBv//Zvb9++ff3WdQLA+vrmxx9/HEf1g+P95bWVej1mjDnUwRgDLj/79O57770X1oItsl6r1Z49ewYwwhC+9877X3/1FWCKYqvRaExG43uff3H1+rXTw+PBwXFs+SwvXNedj0eu45RadjptDMhkPOO8QshueiGQIAhjJUGZZXEcY4iKovAsWyCKgCznKdDStW2IUaUk0ipLsiTLFFLIRlduXFndWmNaQAs5lMISRI2w0+w4joMBHPaHEKM0zxztjSYjAIDruhDDNE1c182rElu0EnxpaUUplabzhw8fGurQehwFQaCUNJMrleBO4FdFtba0AgCSEIwm4/nZ9NPBxwgBxtgnMN2+un3j1k3iuZblFGUZx3WplSlNAaGQ1icnx3t7ewsLC3/2l38htagYIxaWUgopqU1Mh9YUnC+86IW3/J5ZXlzzYgz7Ygxs2zaXQikJEZJSSS4Q/pN56Q+XfqGO9L1lJt8RQlIqE6kraHmet1QPuFae5xV5HsTRab9n2/aw12+3W6Jk169fz7KsyDPLtsMwJJ69urps29QLg2maNN0orRhyrbTKlBLEtUeTseu6JhCK4zjLsrUrW+lsHlgknaUAAMaY51gQOylL43o0nI0MEeuXn3/lUSfJUuw5kgu35lZlDi1Q8PL6G3f+6Ze/rorKd71EC80UhYhrlZeFUHJra0tVWnJJid0r2G9/9ev3fv6+5TsQwGtXru4dna6tbaQnYzuwsjL3fHeSTk+HZ5Ph6ODo6NLl7YOjA8tyPv3444O9Pdd1FQQKqul0WmTZUmdBliovK+xb1LYsZbGysgPbTK6sba5JxV955ZWHjx/uH+12Op2/+ov/0O/3W91mUVRVVf3VX/318fGREMrE9sPh8G/+5m82t9Zfe/N1raVlWWVW7u3slSVTSimgLYsygieTcRD4Dx8+vLJ5eXlheTIY80poISejqelV/O4ffxsS10W24BxTkomCeJbECkM8Tcc2cCSQ65fWy7Kc9/oIQMG4UsBxHF4xZNtQA16x+XQcNGqT2aTTbCktOWP9fq/b7kAMS1VF9cYsn9LA5kgAqCrJCCGWa0GkvcBVSkkFmgvts7MzvxZqCDDCYRgajbN79+6trK9hrQ1nimnDRlH06quvmtZLmaeH+/uU2FXFnz54jDX2iRM2a2eTfpYWGNPFleUoivr9fpYWkRNQx+4f9vrH/bgeu2HAgQrDkNqkLMu1tbXRaHTSO/OD4NYrt/wwEIpXjO3t7S0uLgZBQChCGBgCflMN+p57g/Dbtsp3jOhlOHnzTFGVpsYrOMeYOp4nSvkta/b3MtLv3vcFH60VAOBFY4XfVo80AAQrdPefPlK5tBQGGmLfURCcHhx5nocdp1avG70d27JGo1GVF0tLSxii0WQMKFQIvPX+m47jjE4HJ/snRKI0zziBUSNqNhtfffk5UaDT6RRlaVkuRpQ6NtcMQp1M0q3l9f1n+xjAWhwOpoNUZpuXt6JmHSGEOHjy9WORMNu2c1X9u//87zNVIAynJ4Pe8cntV1+RJbv7qz8AhUZZ1uw23/3Jm6UsndCFAnz267s6F7btcs6hVjkrUM1+58fvAgghJp99dW82mdsKhX6QzmeWT4FPK85FVl3ZvtpdWPqnf/onZGM/sJcXF+9+9sn1azcdx330zSOHODxnkomClYHrs7TkWrQ2OpvXtrIsH42GV29cZ6x0bP/07KR3ehjH8drq1mg0gkQDADrNBQhRlqVJngAAkmnCK55nZaNZ40BubW1ACAkkvdOzdrtzcHDgh4Fl0bwqQ88fD8e//IdfWsh55cYtqPVsNnv7vbfvP/pmMOq/+eab2Sydno4w01mRF1Q1F7vXr18mFGd58c29rwkjZ6e9GStu3r4Vu97Th49cy6+KwkbERHiOZedJalmk1AIgBJSyXHueZ1EUVEUxSmY49JrLHT/0iqoIAm9hsROGpjYjecWCIIAQQoiV1ru7u77vdzsd04qL43g0GjWbTd8PpZSDwWA+n29srBk0C3wOYABKlGWuIbYsi0Dy9PGz3UdPNVMYYIotCJBtWfNZCrV2sI0xJC6BSFNK0/msqio/cBljAIGgHs7zDNm4u7TY6LajRh0RrADgVWXbtoEfGHS+9TwgvbBSpb71pedsgC8zyO/lpc/t7qLsBBRABCLJ//gU+EsLvH9iGTgFxobntiIKCaEpsZIkyfOcF6XlBdksnTCxuLhYqNTQmY7RZJYm48HQcRyW81uv3N65/7goCkIsiqllU6x4fzRYv7y5tLLy+d3PLEwlk7IStkOU0giorMx+/JMfiZTf++RzDLVr29Pp2PM8SqyFpcW4VVdKW5r098+EKpVSuVRHB/vdS8tS8pOTE87Z/ulxt9EqJQ9sf7O1ftI/vfvhRxtXN6ltIYDbjfagHDDGhGDpZFZvN9J58fmHn0btJqR4f3dvOp0ijdZWl7c2N9e21iokANJVUoqC53n6dPfpez96d3NrHQFw+/btTqcDNHrnnXcsZD24+/V8nlZKYMdyNUa8nE9nrKxarRaiWEjpeK5kUkp5+fJlIxUZxJHrWwbCgpBWUJmwgnNe5uXtOzepbZ30TouqhFDPp4kSCiCwur76i1/84u333m13OkWet1vdetzoH/efPHxMCHEc55NPPmkttP/ijb84PT092Nt3oCXTKufVyWTyxp/9SFAkoCKBc/2V23/4xT8pDN56723q2M8ePFhYXRz3J17oUYCyJLFtWwJJPUsjICW0HKKELHh5486NRreZ53l/PEglu3z9qoLatinS4O5nnwRBsLq6SpChVkAQoulsZtlk49KGlHIyGw96w5WlZaXU0tJSkiRBABFCjUYjDMPj42PLsgyJ0WQyEYIZYdKiyCmnUVTbuLzeaNaGpwMlFC+rLK00AItrC3mSq5JRShWGQkqRVxjbjdjnoqpHcclZvzdcWF1sL3exY1HXIhbmSgIIL4TDIYRGtcmoS70Y2X4PG6j/JI/2ha0+tzh93gp6bqvf8vG+eK8fJsEvVnXP7/hDekGCtQRCCBtZphcspBSyJL5NBdGWDYSkUrsapf0RhWA8Gs8Jslyn3+9f3dxstVoS6DIvs9HctezJZOL7Psc4jMNCVqvLywjCwPFaQZxOZhhBLeR4OLEj5/X3XgNQ2TZtNOtn6TGGusxzjeSP//JnmSwhhAhBVrAsy7A4J2j86OMPN5NLJycnulR/9Vf/niPpEituNojGk8mkXqu98dqtu5/fbSX51tZlhUgFQJInUjDLoZgQTzssLZ/Md6zAiaIAY7i0vCAqRhzCgYBICyk9z2UI/8Pf/4Pvu+ZL+/zLz5aXFwHSUGulBKZup9M5Pe11ljtlWRZlWbJiY3Oz2WxqDbqt9u7BPhNVPWouLi4SqnSitZJVVdkuIgQn84RS20yNaKiWlpZsZLuuK5Ss1SI/9IQQ0leU0sl8UpYloiiKIoOOcajTbnRBBSnCGOOzQR9P4Zvvv6mw7i53qSZffPSZJZHlOrayCSEQaQ21UNLyHWTh7c2N9e0NpVSnEf/u17+xqJNVuUttZBGFQJInGGNMaGdjZWVlCSg9Gg+Wt9c4kEHdtRdiAJ6rFQEgoX719TcHgwFGFAAQhnFZsAcP729ubjqWDYFCGDbrjYO9fT/0IIRCqGa7lee52aX9Ya/WqB8fH3/xxRf/6T/9pyAInjx55PrewlLXCwMpZVakrKyUkkHd92yv1WqxSs4m00cPHvs1N3ZajDEvqh0dHWVJQSkdTYetbstp1pu1aMOmfi2AFJ0Oer7tCAUQxlJKrc+rpFob6WRiBt1e9IroOfAWQqi1fG6Y8Ad2azhTgLEvZfC2CAKAtNIIIQwgABCCfz2HIDQSTD+40nRizOhtEIUZTxVUvh9kitWbzRJQKFXoO0AqxZlUcqnRoq5TSdGN6i4lyXA8LTKplGe7Wus4ivKisBzbSADs7e0VeYWIlc0z3/EVhlladBc79YUWAEpLhTGO6tFkMIrjulIy50Uynbn1QAlVFMVnH35azLKGHWktCaELi4u+7//sZ3/28W/+8OTR0+Zi267VW63W3pNdJqVPfa3h+ur6s/1dWepRP6G2FeCw2aod7u7PiyywnLyq3NCXQF+7filNk06n4zjO/v5BWEaW5xiEdJIkf/3Xf/3NN9988cUXeZEeHx+vrC1rLTWQTDGV6eFwCDUwpBY2IlrrZreNCNZSs7LKk3Rnf+dnP/1zQogQuW3bBGNDjAgAABh5nlfy0rbtySyj2BJKlmWJKTb9GEyR41iEWJgSqVUYRyenpwSRr7/8GnAIJYrCmmScULSwsBC3YqmV1sLCVqfTkVxBTCBAFFt5ksa1gEtFEAJc+q4NoZaSS6AtC9u+02i0eqdnWZl4jgsp9OwgL4u17dWVSxsaQgdiYMM5y7FLFYZZlVkQh45vxGAhQIyxX/ziVz9+7/2lhcU8KyeTiZKgVqsBILTSEOmiYDdv3pxOp0EQAICMZqGJcs3A2tWrV0M/MGWR2WyW5tnq6mpRlZ7nIEQCz0+TxGs35pN5IUoNYWd1sdlunRwdP334BAHolGV3ZRHjpSRJXnn3tbhem0xGju9Rm2qt/+f/1/9su06703nzzTdPjo4N3rDT6VRVacC95n0NPuGlFvTD1ub3wt0L6z0/uYAmhCB9Dvo3qIx/vTLiRcX4B58KQsg411pfu3bt4PAQUTKeTYhFFdALq8saI6aY5VoYQh9bAaQ4Zw4TFhNqlqu8gkp5nlcqITGeZAm0SCWYgMrx3OF0woFyg9CLYgkR1wrYpCJgZWsNIQSF4pzPk0QBPUtmTArPce9/de/rz+89+ebxP/7iN8vLqwtLixCDjBXD2eDtd9/e3L4MAMiSRDFOOIBcC8YBVFvbW52F7q9/85uFxeWV9tKsP1EVJxqzNPUsB2IEKVFKYQCnk4nrut1ud3NrHUBFCNm8tLW/d6il1hI8e/KsFka2bbfb7Vo9Gg4HjWYTACWRkkhhm9guzauUS2YhFHuB1KqUPGrUSyGEEE8ePtp/urO1th77AVQaYcw4H40GhiGxLMuiKLTWUsrhcJgluel+HR4emlEhx7EAAEqpyWR0fHj0+PHjsuKE0K8+/2oymvZ6/ePTEya4FwZlWV6+ejlqRGmVI4QgAOk80UIudhdu3Lix2OnuP90TBbMUBgWzFSyniSxyrBXF8OD06L2f/fjSje0P/uKnG5c33cgDFNqBc/2Vm9izgIWllkzyuBaORgMhWFnmnudApGeTMcawLMsizeaT6fbm1t/93d//zd/8P/+n/+n/MewPm41GMptLISAAQBlkPz04ONBaG61sI6w4GAyuX7/e7Xa11n7onfZOkmy+vb0de1EyS7UESZIl80worTSUChDHLgVXBPXG/aPeSaPVWFpdsl0raniff/nx3tFOJQsv9nNeCC09z7UgPni2W7OD/8Nf/sfT3aNkMLWB3W1263EDQui6PoTYaNKcz5c/x7Qb4wBAvdgj/W48/P1xthcT1IuaE0IIQ0QJIS9GvP+q9VITPX9LAIRWcS0EAPi+XxWllFJmFSFk69rVwemZkhAIBYR0bIIwFpxDiEpWOoHDoFIQ+FFYiUoI0azXkiw7PTyGFL/xZ29l0/nHv/zHpU63FDzJZ8N0nP0u812aJenVy9cePHjQiOpFlvu2w0vOBesuRNM0ffP1t9qN5h8OP8RQSy1uvXZnPB83Ol3fD1555ZWH9x4oLp7cf4CUdmwvy7K1jXWM4RdffNWMa1VZ+lEzSZJ6XDvc2y+KollvwFJsrqzkRzvJaPL4629u3rwxrySOMFT66Ojo9PSU8XJtZRVgpLRYXFmQQLRazel0nBXl008+uX79eujVgEbNTjuZpcP+wKI2AMBy7OOzXlGlOw8fP3n46Kc/+cDBtuKCa1HKXChJKWWMUYaOj4+XOytZlhVpoaCaTCaBGxwfnPz0pz/FBPbGPUdQiNGgN4ii2tramu+H9UZTCS25YgVrNJrT8WyaTC0bCSh3D3ZzltfaNQIJY2w0GtmeWwo+nk6S2VwXcH+HbmysY4w++sPvJ7Mp13J/cMaxfvXVOwJKZGPB1erW+t/+b/9189LW1Zs3LMuqlBiNBrVaDQM4HA4pxa5tEy0QQhgT7SCllOd5nHPHadXrzUat8Xd/93f/9//r/63VaiktbZvmecpFVRRFmuYAADNGG8dxFEWcS5OXCiEMhrbT6TDGLMtijFFk246LKQIAABf2er2yyGzbnk6ni8tLCqAojm3LPTg8iqKg3W4BjIiDIaZRLUyrnBBiObYCWmtVsGrr0jaGeKW79Ntf/uYv//IvicaOZU9mkyiKGGOuaxsvarQqfrieh7XfMc4X2zPfzUiBOVullBSZvo6UUhNE/41W+sNluM+wRTVTlmWd9fv+ki+rihCimSgLQSnt9/vtTufJ4IFDqO0G09nMch0CIWOV5bsTzWrN9uCkNxkOEIQ2ItU8b4YRn58RRB58/sXGxsby0kIynTElJefdTicrUgaBliCIwtfefOPR1w/bjcbopOfajoXt2XC2vLkqKvnRhx8rIUXFNjY2lpeXR9lUCIEwDGshY+V4PAYKUoC0FkWvuCe+evutdz76/SdZMy0FH58eRlHEgaLUshEdnQ0sQhbpyo/ffvd3v/9toOiv//bvly5vDgZDhMjGyuqDR4/yPJdcXL68zSXXEMX1umXZ3e7i/v7uO2+9mxdFWZa+RRjnSZIsLS3lae457qg/fvb4SVLOAVPddgcorZT64osvljdWw4bnEBy6OEkS1/W3ty5n03w06i8uLwEAIj8KggBDOB4O6616I25oojRUKysrjAmoUC2oj0/H48F4eXlVKzSbTuv1+MaN62vrK1/fvz+bT25tXz/ZP1RCTqfTJw921pbXinkB8symNM3TvWd7aZrce3Dvzp07P/sPf5Vk6fGot7yyYju4LHNKbdu2K1YtrS3deu02FwIgjQBot9uHBwciSaMgVEqwvHR9p+KMc2kIr4UQnuOWJROKX7t6hVVlu9nACGpEhRCWY2sImJCbm10zwxmGIWOsKApCCELAUIRhDDmvjDqw6Zfi0C7L0qEu5xxB3Wm393ZSnrNGrZnMUohQVhaiYptXtlhWWJRiQiQWUVgjFEkNmeC5qHJRpmneXl2KgqiQ/P6Dh4oJAjASGhHkWO7J0fHS0pJgHEKogKaUGt23H64LsO73kscXg+QXvS7GlDFGEDYsaFJqiv45X/rSxs5Ll+M4RVEgAgFAGgLXdRHBjVo9nc2JBaECWuv+aDhN5sSxuFRTXkDfLqGaT6ZNP+JarW2thc06RXh/d8+ybJfasmJVlrvUGg3HsyrrLrXbi61ZMvFjP59wz3U552XJXNd78OARQbjVaBCIa1E8Gox93y+y8qvPvw4bkRYKAaiVztOMMdZstnf29hu12snxcdiIKHbyeSGq0rFsl9rJcPrN1w8cx1vf3nr06FHciCM/EBUTWvz5n//5vXv38jx/ur/z0+2fN5vtyWjqEq+Yl73J6M6rtzsLCw8ePVJALy4vJmUKABhPZlEQCSFiP6jHDYxs14ZFwZGGRwfHEKBOp9PXg2F/1IhrjVrj569/gBU62NvtdDpSy2fPdhqNhibC1PTNxImScjQahV5gEas36HU6HQQQAvjel1//9Oc/qWRFMIYACSkxwJKps6PTQW+YphlAMAgC17a3ty+tr69KICUWl69tU4iWV5ZGw/FkOFUQDMYjF9o8yVzHzmViOZaQ6pXX3rh+5xbB1G3ENPIazZoQTGs5mYyqijfCePvaVQkBokRoBSEUnBdF0W42Os1WJfj+8VGr3WBcAgB83zfTi2maAqUBABahq6vLXMlzNhNomGiRmUoz/H0X8i1mT+d5bjLDC9VTpRTESCieFWmaJ2EYAoTKLLEJrdUjoYCP0f7xUafTQQgprQFGZVVBKSDGEmjJ+SyZp3k2mszq9Xqnu3h2dhaGYVYWV29d6zZaT3aeLC4tWaH71YN7165dMQcNpVQoyTn/E2yc/xILurBYM3oOlKnZQoSAEOI7jCo/HKUB/+JODGMMYIQxNhH51vYlpVRRFOP53PI8MyZECAEQItfOtJhDsTPpz6BYuX65gsJ26Ep30YJ4MB4ACudlViEd1huQWhhRLwwqXjYWWq31bn2tTWpe2Ix7/X6SJM1W551333/v/fcxplVRZrO5qng9iCzqONSRCnCmMaZIQ9eyBSvvf/W1EnJlcYVV4qx/5sfR6+++jR2Luh5jQnPpEevs6NSyLDcMWottCmEzjBQXZcnm81QjaIXurErPZkOvUUsYL6We9qcucb68/829xw+u3LzuBu7VW9e8yIsa0frmWhAFs9ns2bNnYRhBBYFERJH5NMOABEFtOJ0WVRmHoQ2xBRBWoMwL23WobQVx1F7o5nkOtJZCGPnNMi8sbEEFyrJkRamEklw+fvx4Pp9PJpOPPvqoyArB5GwyhRDa1B71huk0i8N4MppiSLIkoY6lCZiXs93jXSkZ46WQ0racIit923/j1Te0VJPJRGtdC6O1lfUPPvhgfX19eWNNKlUKpiHACCkhIVCUENd2XNuCSIe1MMnmCikppVAyL4pL29sSoqeHh0lVLKwsuUHYaDRs293b2c/z3HXdIPDieuSHXsXLerPGRFWJCmIAAYYAC6HyrDREAoyxsixt286yLEmShw8f/va3vz0+PmaCcymE4gBpahOtpe3QvMqJTYhNMIFh6HcWO0wyqYWGamGpW1Q5pkhBRW1CHSqlHgxG+wdH49nc9YK43rx+/fpkMnn44P5Cq2lIdt/50XtuPexurbrNCGBQj2uW5UgpDT8oUJp+6+1ekp1eNFdfjHW/l6+e4+yfj4ZfLIsQDBFM8+SlRv/dls7F4+8M4Jw/0EDDc7bFSnCkkaXt3YfPDh7tUEijuDabTjv1Zpqm8yKrNxoQQkDxYDbJWFFxRhVcCRtYg1tvvPa7P/xeUZjkWbPZPjvrLXWW8sms7nqV4txF7/35B/P59Ojo6ObNm1mSHzzaGY/HGoCf/PxnUEEt5D/8v//WgTS2fIotBTQn2o4DJ3QP9vYjx5NJduXG9pOzg+Zyd23j0snp0cJC1yb04YNno954dNQLbTfAFmNskCZLGyvIRhUrHEyhAARZkvGsLIhLsUWpZyPHStP08tYlWbK9J3tM84lIX3nrteWlBaUkgCIrUurYs/GsFjYdy/n8488IIZe2N6XQn33ymUdcF/qnJydxJ8QAUomkFn47Slke12sbW1uOa81ms+Pj48lkfOOV61LKR988ee+99+4/vO9a9qXNy6dHx47jFKzq9XpFmlHsIITa3dbiyiIiKE3neV4e7Z+Me5M4jOv1+rNnuxjAtEgl1LVmjKh+//13HN/Lk3Q6ngGpTw7OLNv1Q+/o4LiYpa24jpReWF5c2lzaOdn3W/XWYgdpoKXqnZ35vhuETlVVvbNBvV4nCCFCNIZZlh3sHd6+fZtQijEui0Jrjak5voGUkiCa53kQeEJJg/oGSo9GkziOMaZpmlZVZYTCqqpaXVuWkhvwndGJLMvy6dOnKysrzWYTY1yyCkLoOJbZ5QihvCqLojARMoFIaw01MCF0JTgmllKqzAvf97EGQOmi4Ek2p5YzGPQcx4nqNQKR0Z4Jw7AsCrPXy7J0A98iSEtw//6927dfQQiYiflzvkLyckZsLZUxUYCgRSgiGLwQBv/A0LRGUGuNFYAAQAURgECT7/jpFytR313q24MBXRwAyPzTEAEAMERaCQIBUFIpWatFFJPA9YokAQDcf/CN5bgOdbJZmsxSybjveg61sAKB7ydlzrX++sv7GGBWMIyp4zhhLRomo3d+9v5gOqqq4icf/Ojzu59xoert1tHRkZb86dPHw8HpfD789S//LsmTNMujuOaHAZd6Op/Ns2kUu6+9dePqza3ljeVZkUoMHS9ggp8cH//qF3/v2TaxMMDoxvWrVZ7Ua5FnO5brAIqlFpPJ6NLmZr/fH0yHxKVFWiCFap5naUAU0qXKJnPPttqL9eWtxe7KgtbagpiXBYIAI0AJcmzqENxpNbUSCKE33nqzKIrT09Pf/eM/WpggAAXncRyLgvOKGSZYpqQT+NMim2bJaDg53NsPPd+2Hc+L4rjpEvubL+9hAP0oFEqcjfqD6ago8suXt5ud9ualtc1LG/V6nSIKNcSQnh71Hj16ctw/Y4o/3nmilIg83waEKixzgTgK7EBr7YRuo1V//OzpvUcP9k4PTsY9gKVrkzybc8WkFoTaW1vbo8lYaw2kKvKUsTKMA40wddyFpcW8rJKsSLIcatBptW/fvmlUrVlVcF5RignCSkgEINTADMQqpaDUBBAoYTrP0nmGIVFCB37UaS+02o1mq+64llLnU+kQQkOoeXR0ZAS8TSHUdz3XdpIkY0yMRpPpdE4ggQpGfkQR1RoiRCAmGiIhFEVUME4xydM0mc3AOdueqjdrACip+MJiJwo82yII6qrMIVCUYsexqIUtmxAEAFBFlbe7LaG41IJYFBFcVCWm5MIcXjRRqIGWgGLrf/6b/2V/9wBqBBQkiEKNIMTguWTTt1aKoD5n8QUQagyNtoX6ji990aN+z8QvzFgCCQDAimitjTIUgAoAhTTgklFKIcBYkWpe7tx7MjwdLK2uDIaj3Sc7V65cMfPstmfP01lUi2vNelnlZVlm05RX3Lc8COGsSLw4qJTwwqC53Jn3R/OjXhQE7bVlbaPW6tLpoB94zqQ3iB1/odtJy/n9h4/2n578u7/467ODo3yS6lKk07njk8ZiY/vVK5ASKcg//Le/dySMa+Er77+uKUrL9MMPP7x9544SenDSm42mjrY1k57laq0LXgIE42Zj/3SfWNglTqB8rEHOU2JRDQl1vUoWJLBuvXrdcZyvPrn/7NlO1IqDho8Q3Lq8FYQOwphVFYRQSTQbzyi18qTYurRxsn/8+9/800p3hRdSVAJQbdsUKSWgfvOn7wELARsd7h9sr22UWd7v95zQJ46jhHQ0+t3vfvfOT953fMdoe9aj2GiWJEkSuP5nn322srK2uroKIfzwww97Z4NZmmxsbGgIsukcSOBqggCuhDwbni0tdd/+0VtO3ZulM8nk7rNdDUiSFRKwxWZzsHfiYgoRcTz3tbfe1Bb8w1efr26ueMRCWiGKMCWO5yqljK5REASU0jxPTScTITQYDDzP29/fX1hYMDZmQkTDoMsY8xwXY4whHA0nGOOsrDzPC6NIKUUoghDOpxOjcGmIpBljpkJpnESe57Ztm/cyIxkG42FiutlshjH2fd94RQBAURS+7yOEsiw7F7OH8OzsjFi00WiYWx0fHimlDKopSRJKqXktQDDLsjgO8zw3QzCe5+nnHEVa6wviv+8tUwFSXH394OtOp7O4uAiMEASE+lzx6TvsRwAAoQBEGgMItARcI4Bt7H6/evSnM12t9QWgAUJ4jkmCEACIEdKQaAWV1hCBIAgUkEmZL1/aGKeJ53mnxyf1RsvxvcFo6HuOSotJkue8CONoa2vrYO+ASKiFCgDRaQm07E1n+ydHf/6Tnz0dpb7lTE56AgEI4eLKYsXLrCqJhkwK2w/eeOfd2fCXv/rVr9ZWVp3Iz0RCfItLnuclRlRpBCGMgkhnhWVZgGBlocCr/ejnP/3ik7tAwTdfe8Nz/PHx8Mu7X6iyCF3P0URKOe4PlhZX7rx5c+fRs/HOQAJY67TSIuVZVbIKuMRCzoMHD2zbHg77YRh0F9rb1y8jBJNkpgGpOM/zslaraa3+8PsP/+Iv/rK13pxNk1anbXtumqaRHc0nU4U1phGCoNFtYoo4kkDJejNOi6nnuW7o+oF3dNZbW1nDAnQWukopU5y7IHdWQFPbQhRTxzobnC0sLxwfHB8cHNRqtXd/9G6z2Xzy7OkZq5BCiAHNtVIqDkKX2Pe//NoKrNNhr1lrXL505Z9+/zF1XY3B2vpmJ+70T067ncWnT59+/NFH03zuNWvdVtvCRAuuoKo4E4xTStMiBwAYrjDP89I0NTXPVqeNEFrbWM+yrNvuGJ+glGKCB0Fguw7UYDIe2rZtuZZtu0yqe/fuvfX22wih+XxOKZ0l867XvSBMMfJTBkNrVA+LojC8m0a28EWGziiK0jQdj8e1Ws0QYTuOMxwOTSGqHtcQQpzLIIj+8PGHP/vZz4DSWZ6FYQgAAAAxJgyFkrltkRe+65kZEoyx0RcGRqzVMCK8zETNQghxwG/cuGGCXgihMtzcWhiVpRdNFGpANdRKS6QBhgAizQHQP8Dx/rCo+0O7RS8zZDMZwIUyKEYuxdHpidTibNBPsrTRaJRJZqSEMMaz2cwOa4xVURRMk6RURxIqgKBr2RhDDXU6mwS+K3n55MmT7UuXnj58hDHUFH/+yef+zjPi2kkyyy13f3//1XffjHzSaXW/3P+8aLf7/X7oBmlVOAhNJ/P5NPXjSAjVG/TbXjicTjRBQiusMEJoa2sLAkAdS0PVWGzHzVoxTvI0C2w3mSZ2ze+0WgihdrdT9BJWVhnLX3vrjb1Hu8PhMKtKz+tcvr714e9/D7R2bffs7OzKzatQgzhuTOczIaXjOoPBKPai7e3ti1MZINJud2VWYQTDyFcEIZtiCAeT8TbSACiIoOtRVTIFJLHgaDqihFRVpRivt5rUsRljgnGtz0c9TVXJIlQIcXx8wjmXQv/1f/gPo8Gg2apXvOwutOphsPtkt8hzBJBtEcEJAjgZzdmYu4G7sbJBsaUljIJQU/1sb3chbsXNRn8yunLt6jdf33csN/IDLXUlKkqxVMrzvCxJlTiviJg/q1LA87yKswvvF0WR2anGhUKMLMcxbLMIoVq9LoXgTJZl3m43lbpydHRUVVVepK7r3rhxzUyHMMa01o7jmHs6jmMM3rbtk5OTer0OEJRSuq57wb4HADCU02bAyNzH2DbGeD6dRVFkaO9/+tOfGqoxw3KslKLUNlwCF+eO0R1Osvm5ODKEQghTDb2QvXhpqmg0fg03slDn8sEvUgH/8LUEIaGVVAogQDGBSgsmXlI/fjE7/dMmqp+zfpplWAwRQgpooZXre27gP3782LIsLmW91WRV5VDLIhQhVHAmEKiQri+0C8UUgnNWpqLSNqm0imt1pBFS8Nmjp2fDvhP4EqKsyOv1eu/45GT/cH1pDWqUJemDr+7vPt45fLYbeD7Qamllud5oxPVamhdagy8/+/Jo/+gf/u4f3nzzTWWTvd7Js6MjrpUSEkMCIWScn416szyZ5/OF5QWpJeeVocMN3eBwd9/QHSZFrinOitxyLT8KFAQYok6jCQF4//33PduZJ9PzGrpGGBAg4N1PPlccxEHdtu2VteXT3ml/OMAQff3lV0EQYIvkVQ4IhBaapfNMFK2F1tHJEYQQaiV4lRbpNJlii3Y6ncXFLrWI7TphI6YUIwQOjw+IhZkUleCuay8vL5asQgSHcdRZ6N5+9Ra20Mr6SsVZVeVB4HU67VdffwVgQC0CIQw8H0jA8opqXGXl7pOdR988ghqVWek6fqvVyRmfpRkXcjKflayqqmo2mRr+TqmVaZBMx2PPcXzXiePQcaz5fAoQLKrSnNfGToxei1FGo7YFIVRKSa0QRWWZz+dzLkQQBEZqSSmxvLR07erVy5cvb25uGv9p7mZ8JgDgOU2xMhZi/lKmg2C2LlASamXiXs/zjLyy67pG4pViCwFMqV0U1fHxMcbYtR2KCSGWbbsIEdt2zR5mTFiWk6apGY7TWqfzzLFcM7ZqVIzNngf/XB8EEcwEN/GtAlJDJbV42YUKACCUgghhhKDSSkqoAYb4X40QvLjjBf+qacYijM1xJZQSUlqOde3mNS6ZMWCTkLiWbSFMAGw32hwo5NmVls/29zY2NlzXVlrO0mQ4GVPHtm1bCuFZduC4ZVaWrBJKWpZz9dL22tJaO26OTnsLCws///O/2NrcjuN4Y2ODserB40dHJ0dpkb7z/nucc89xoYT9k1631iiy8vLVq6sb60+fPp1P5wc7e+lwsriw4Lpup9NxA9cJ3cX15bARJSyvAPfisGIsnSW/+83vvv7mG+rZCkGueK/XO+6dCikdy04nM6wg0eiDn/zEgFG++vLr4XB8sHt08OxQZuz+F9/YyJJShrX46e5OmqYX2vKTyaTgZSGLSpRCi5/82U8vXdteWlrivNJKSaEbjQbGeDAYmG8bIYAtwiWDGJl9ecHRnue54zg3b968fv36u+++u7GxYRIniNHBwX4YhgAqZCHXcxaWulmRm3opwbgWxYEX+JZ3enRaFVUQBP3+0Oj2TmbTWZpwzvu9QRTFhFiiEl9+/rnZlFIro/NrjMHYTxAE4/FYCGGSRjOpo5SqqsoodjPGNIRVVRnzI7bVaDXNV2FIOk29lFJqEWrUQc22uRgQKYpib2/P9E7Pi8Crq7ZtAwDMKHZVVcY1IYQMPe95mM3O3bsxbNd1Hcep1+vdbteY/Xw+T5JkNpslSZIkiZSy3W7HccwYm8/nvu+PRiMzAWP6JSa6vlCR+RN5oglOz4tAGF20W8DLXKDhAzU0v1ADqLTRB35J9ejFu79YN3r+WAEAoEYaAgCQeUMEANRKa40IlhpqoS1syaT81S9+zbm2iYU4WGi0eFphCKXWkuiE54NkUm/WENCI68gL0tHMIpYC2nI8XlaQ4IozRM9rysQiWZZFQdho1CrOAMULa0tZVbq+R7G1/3QviqInB7tnZ2eh5SGh1tpLWZJqLR3HIcSaJPObb955sr+zc7K/utxda3YH/R62SWt5obvYAYRCgJEChw/2Pv79R+1WRzCpJajVImXJMA7Go3mr0RyO+q7rzqZJHES6YlLxV9951QuibJp/9tWXo3QCCPSdME9zgrBgTGj57//TX2GfHp0cLi4tHe4f8ZT1T3rD08HS0tIrr9xGFE1m4/5kdPuVOwpqjCFj7PBwv91u266jlLII5ZzblEKMkywFAJi6hWk22NQx1OTNZlNreHBwsLa8ghASWmVZJoSgFMdxCJRQQtvETibp7375oYXtKuM1P2S8tByqoJpnKXU94rjTLInrweLKkqh47/QMCA21Sudz23NKXv75v/8zRHGSzSEGtSgui8yzHamhhsB4V0yJ2bVSSiGYlNJ1fUKICVmFELbrlmVJbQsChRACUiGEiix3bU9r6FBrPB5TxzYhKMQAIVQUhZFFfvz48ZUrVyzLmk6nvu9XVeV5nuu6nHNifavaoIQ0H4YQQm0nz3OMseu6kqvDw8PJZHLnzh0IzHSL/vjjj7curYVhaGi4jZ+EEBoWpSzLvvzy8zAMb926Ze6PMVZAXsSoFyfCeRj1smV+a6BRFyKOL7ZJwfOZUgMmlBprIDGACGqgINEYCfKv8KUvj7y/i4IQQiAMNNJMVI7nvPXOmwAoz3M5r5LpbDaZ8IqxssQAbl+90u50hqNRvdkoiqLIMseygVZQI1ExbFGAoBJSMwWFIhBpqQPPxwCOesMyKXzLsYhdj+qRExzt7e8/efbRP/3+0traUrs7n021kKPRCEiFNcISqpI1g+izjz7xXQ+UfNwbZUke+OGrr76+urScJnlRFEWV7x0dzKt04+qlWZ4igqMoKiommUyTnFLr5u1br7/+OoSQMXZ8fGzbjk2dux/d/cdf/ObBgwcYkzu3bjfjRlVUf/nn/65ba4VO0G20f/eP//T1118/ffaMSdFdXLhy5UoURXEc53nq1yIv8pZWln3fAxga1CalNPKjzz77Yn//0LZdCDFBSAghOccYQgwAAAYlZ+LJk5OTwWAwGo201r7vHxwcmM3k+/50OrUsK0mSc6JqKT3fxxQ16q16vW70RRFCAEJiWwUruDzngz8+PKSYVEWRZRmldlHxNE09z/PcQEntum4tqhsOEQk0xMhs7guRFfOrcxALAKbiYkLEjz78kFIKlCbYutg8CCGAIEXng5qj/mA4HCKEDHGMARhRSu/cueM4jta63W77vt9sNi8s5yLsNN643++7rmsKRQbnZA615eXlb9EClrW/v+95XrfbfZ6O0gtoQVEURv7UOPlz9qbnWSjG2Hh4+FxZGP1x5JGxSWOophJ2wb3ycqvGBndk1NL0+UHw4u1eapnfa6JCjeC3kzQKIg2RPj8MXjhXIEJc83qzvrK2zFgZeT6rqnSelGVZVFWSZ4++ebC0uPjmm2+urK47cTjPsyzLlFLUdaZFNpxPDXW6lBJCjCESFVNcCiGV1gjC3tHZ/U+/7D077D09HO+ckLxsUccq9RtXb966dCX0PJsSz3cwRFpIrFU+neqK2wottBd8L9w7O24tLRRViSHyff/k6Pjk+Ljb7d64c/v6zRuB7bqYiorlaTafzGeTeRxGGBM/rrXa7UYU18Koqqq8KB3sWpByJpIk2VzbXFtc9W2HF2Wj1nSp61CLV2w2nkRR9MUXXyilEIUrq6sHx0cAo6/v3zffbaPReB47Ec6lbbs/+dFPEDxXubUtF2pwenoqpUaIJEkihLCpgwB2XddIFY5Go93d3VqtppFWUCEEdnaejqej+w++4VIAjaSUEmhTL5gmc6lUfzTMqrLiXGplu3aj1RyMB/N0ZlyKYMxzfJc4RZotLS35Qag1FEKUZWlKVhBC6thpkZuwFjwveF4wACFEhDjfvhgiJaTk4sr25TzJLUIk51CdE9IacV3wfHSrVqtRSjnnURRZjm1ZllGLMO/rOM6FNoRlWVmWKCVetAfGWL1ev0hoTVY5HA6Pjo7Ozs5MbdbEsWtra+PxeJbMJ7Mp55XpzUIIp9OpOebOzs4uXbq0tLQEISSECCVNhqifa0N8z0W91HYuHiiljF6zBBrgc9Zs0z3+9iUAQKURhBJoAbTG51KOfzTi/eE6987P76nht5Mx6EIjHAIFgQYIa4AFhADISn36h0/PHmUIYOYAAN1BSURBVB8utxdkKTC1Lc+pFJtlqSZAYuD6DoTQtex8MCMaOaHf7iwcnRzzikWOV+XFYDxqNBqOZzu+N55MiqLodDpB6I+HI6WUQy0pmAUQAGCUJMSxhZKu7xGEyySXXLjUgkIBADRBkyxZv3H5m6ePK1Fdu3bFtWm328lYubC8IKVMkgxo2I2an/32k8nZ0LODSvBZPg1rseu6b737DnbozpOn/cNTrMH53lIySRKvVgMIblzaEEJ89slncRhhSGqNeprPSGC9/cHbhSoBhJxLz3I/+t0fnjx8opVaW19fXOoSBK9cuzqvCkSQRWk2T+IwUkAqDKfTaegHFOHpcORHYW8y6g8Gy0sLWutWo20ORJOMjcfjL7746tVXX223m2mamkyp0WoyxgaDwfLyIgIQA6wE+N/+l/+6ubR1sHMURVEQeNTC02RKXAtgJDVioprNZm+9+UaZ5If7R42wPkvmfuSfnB0Ti1y5vu0GTnepI7WiNsmr3LKs8WBsU6soiuXl5aIqLya5IIRGltZ13SLLy7KM4xgoaPJV1/eUEpgSpcRoMG40GkpoC5M0TYMgKFhlObapfWCIDKcefa5obEJos++VEnmee4FviO3TNHVt53xQU0qhtGnSIoSU0ISQXq93cHDw6iuvW5Zl+qW1ZqiUevbk6a1bt6qKJ0kShuF8Pp/P5ysrK0KwKIpMeIyIiau/hd9dTHv/sRrv90AHCr6A2FPf5o/nlgwAAEAKjSnSCEopMCAEEFT+YAr8xUT0h0++xHSf8zjA8x+ReUoBgJCGGlHHeuW1O8nZeDqfEmwHri0h0FpTiBDGNPb60/HS2up8Om2vLe88fIyLtGKsXW+dHR67DlYId7vdtCxs7D/d3YOOpZEasSxLRJImUopau2lZVugH4+GIKRnVIhLYbuAXaVYArgrAERRS1IJQ5swCyKbWrVu3srK4/cotguAfPvlwPB75USglhwpOxxOdsul44tq2S22KievalWJAqk8/+phjXeWFiywEIIRIK2i79mg2B2lRa8SfffJpp9MRjPOKQQdqqJqdVs6LsiyRhfMi0wAd9A+3r1+98+prx4dH+zu79+9902zWkyx3a1FvcCYFf/2VO1JxBSSE2LIIxvjk+OT04CSsxeuXLsVRXQo2HPZrUf1isiSO64RYtv1oZWUFIYAxprZVFAWE2rKseqPBmHAsW2v98OEjAEBVFY1GTWhwNugvLHYqzuzQm85nTGjXtWtRLNn52CTn3LWdZ8+edRbaQvCdp0/f/eA9jLFWoCgK13fLsnRdN/QDz/OGw2EURUpI48FGo1GtVsMQJbM5QTT0IwyJEMxDtras8XBaKVZv1sqyNHGs1vrJzrPNtfUkSUpexrQGADCGYZAMeZ5fNCovjEQIEAQRpuiiSHMefCIMAbQpMvE2AIBQUhTFwsLC4uJiVVVS8SzLugvtosqllOubG/+fv/+7d99+xwiBJ8lsa2vTKAhrrZngtm1LyV+MK78XY77cOl7IYIHpj1zY83mh5znzvGE/0QBBBQFQWpvpOQTNC3/I2/tH3u9Pf6CXL6iY5mEcLqwsaAu5kZex0jT0gNJVlrN53gzjfJ40m83xeBzVYoSQbVnj4SgMAi2VQ62iKIIo5BXrtNr9k1NW8jzPq6qitgUQyqv8lbdfayy2Ssnb3U5W5Nfv3Fq/srm4ufTOB+/97K/+zGtGjdWuUw8qwX0/fPLwsWS8FdWIRIorxbWU6pe//OXTR49rtejSxkar3eCaS6hn2UwpBZUmkJgiBwbQOAqhFa8YxriSynY9hFCZV67tSS5qUSylVEC2FltXb10DSFd5QRF2LDv0A8uxMEUFKzY2Nq5euYIAtG13ZXmtEdeA0kZ8FRFo2zYXlSHOW1paihuNy5evQIjzvKiq6vLlyybuNUkR59xxnIWFBfBcIOyFaSnpun5eVDs7O5xzx7Hr9bgsS0IRQBogmOd5HMeB70sufdvRXCWzqalIEYIGg0FVVaZR6di25KIsS6NKZBHKmayqyiR+lFKTyF1MqBuuWq011MD0NhljFFtQAaTho68ffP35vfFwYvK0yWRiSCEPDg6wRU0iBzFK09TkQQCAMAyNuqHhBAMAKKXyPL94BkIYhqExDFP9vrATU5J9XqqBJsRwXTfLMgM8nM/nW1tbtm37vp+m6ebmJgDApNNmcvXiFHjxLDBxwZ8oHb1o0j80pZe+CmOspbqYa2OMCaEI+EFfFb5sWu17d3wOv1cAAqC/A1w0HC4AAgCB0ghiUAl2553X94/+V4UBte3xeKyVakSh51hS6WqWu3FYDmaEAwQt5LiKizxPSRAoiATUfhzlZSGLqtNo/uj26/3JCCISudHh8FBhLXI5m03KLLU9dzwer21tQQi5qPzAIxYCQl6/fRXZlEj0TKLh6QAD+PDuV5Ef+IAAhyKNXrl9Z3V9dTAeMMYoIKxkyLWZhhTbGkMLkiJLEXUghEjpRq3Oq0owaREqtOJKF1w4CM3Gk3qrLpi0LOvk7DgCtcWVRUzRzds3dvZ3vdB3LGeWJrxiFrEQwlrrpfbiXQkmo/Ez+DSohe+99x5E4Pj4kAmBtVYaGplNxUUQBEII6rjj4Wix21Fcebaz8+SpbbvNZhPbECgdx/GzZ88ajRqllFAkBDByI0LBer0uqtK2rEsbm/3js/ksDRrB6WBYazb6vbMg8AghkecjgBXE0HHPzs5WV9eWV1fG1sSUSYb9gUVw3IihQlVVOY4FkJ6ORlEtxpAoqI25jkajhYUFY1QE4c8+vbu2ttFpto6PjynClFIgFRRoMhztP9tZ3VqP3BBCpCFQClScDUbD9dU1znkQBK7nVZwFQYAhmU6nURQxJhgTShVKCZOjIoQcxxFCQIS1BghBIYQ0aZmUZpyaMWautCyrrHLHtRiTEOooCjjnxlUa1YnLly8DABjnvUG/1qhPJpNWqyWUxJRAqF+YdDkPcY2JmqqSsa4XL/jWPp9ngvAFDMLFBS81VAU0BkhDqJSuGNP8W4f7L/Ko37nXH7lEG80Cc0OoNFTYIQKqWquZlkVR5bZn+0GQZtnZaT9NUy2kZoLnJQHIQjh0PNd1G912VpWW7xJKzXlcD6NhfzAdjQ0ZeavWaNYbnuNubqx1Ou2VzbU7b7yGETk9PQVc8qL0bAsjUBY5IRhbRGC1vL0xrwqK8EKzXQvCh/e+GZ0Nfvze++1GWyndaLSm0+lwMPjm/n3OqyvXrxWiTIrctHmVUrZjcc5nkwkhZJbO0iItWQExiWpxWItr7XpRFIyxoiprjTq1CcQgKxJi09PT0yRLkyT57LPPpJRKCqAElIqVVRSEcRBiDKmFgZKmxnt8fNobDIfDMWOiLMskLx48etAfDk6ODmzH2t3dNfXPer1u27YZ6zUt09XV1QsHe1HLAUAxyWybSskxgduXLgElOK86nVaep2EYSsYJwlihmh/zrIiD0PMcLqXtexnLkzyzMKlF0Up3ySG0Xq9TSquKH+4f5WlGITYNUiFEFEWGpxM891eXL1+uhREhZHV19bPPPsuzTEm5/3TnV//wq8XWwo1rN+aTKS+5oQ6K43h7e1spNZvNHM81Aoemelyv10ej0enp6ddffz2ZTLIsMx7YtFguejBGysVomSZJYhy4wRhBCPv9vhCi1+sdHR1hjA3aweT2x8fHzWYTAGBZ1mQyMYIDpqSntTYsgeB5T8X4MEPjqJ8zLagfMPH+CcP5E7814N6Lv50QAmoAIXwJK/5LrO476zuo//M31gBphPR39CyMDrEEsmQFoej1N19DBNquAwhKqyzXQlAUNGpxu3nWHyRZzks+n85s256lc+TZjML+dDhNplBroJTgynF96rg546wS+/uHNnXiIIzjsGAVtKm2aXtpgZfVb3/9m73HT0anpzv3vzl++swnRHNGCHaiANik5EwBnTMuoGZlpbgCiHAp5/O543jdbjewXUejs92Dzc3NNE9M3cKULuIwohgJVrVaLTv0ndCfT2dlWc7ylGkppbQpDqIwYyWT4vBwnxBSVnkYRxLoJM8ajUa9FqWzOZJacjYbTxEAt25fe/W12xurq6YFn6Q5wrTdWZhM57blGijM9vY2xqDTaa4sLriubfry7Xa7VqsRQoIgKMtSceFatul/mDYjQsDgwC6AB0qJTqeNMZzNp47j1KPYJrQW1aGCUINsnLCsopgEQVAIhmwKIARAzedzwGWZ5VDpLMuU1mVZdrvdpU53MhqVeQEhBACdnfU5l2maQ420BIwJ3w+N3aZJ0mw09p7u/bf/+t8eP3wSOO7m+kYchGEYWpZl23atXi/LklIaBIGp0Jrui4HmGa+1t7c3m81qtZpxfSYtl1IKIYqiMIU027bDMAzD0HEcU4Y1G5IQ0mq1HMdZXFxcWVkpy9JwoAjBDo4PvNA7PT2GUOd5TgjpdDq1Ws28BSFICGZZFuccUaLg9yu3CKE/bT4XBvJCKfefN2MJ9EXXh34Pe/QSMMR3ac5eul4K6/32twaRDCGlVCmVFhmTYnFtJYyjrMhLybmSzU7bNKkppceHh2tra0mRJ0UugMYYp2nKq3MME1eyrCrLdWzbFhVL50m73VZAJkXOBO8sdLXWgesFnv/5J58m8+nJ4dEXdz/DQHPO7z9+WGs1pVIYYz8MWSX29vY++/TuvXv3jo6OBJem2tHpdGpBmCXzPM/XtzaFEACqIs3yPJ/Pp+bwTpIEIJjlOca4KnKuFVOyKjIhBGOs3e1aFolqkfkzbm5uxnHcaDYd163yQitxsLffOz09OztrtVrNZhNC7bhWEHi2bV+6dOnw+Hg6nbmuB54f3u12c2FhgYuqKLOtra1erwcAMDgbpZRB/NTr9TzPm83m3bt3XyiBKvOAc76z81QwznlFMYnDKM3mCKGVlZU8zykmgRdiCNutVlGU5xoFWrmuGwSB7/tBEGghoQb37983zUybUEppu9kyyB7XdRcXF43kdpZlRk8AAGBQR67rrq6u3rlz5/LWJccABpK8KArf9c0GMw7ZZKHj8fjx48fGWV20FququnHjRrfbffr0qTEhzrkB05po1rKsi5gTviA9CF7gGbqgubRt25AkAQCMUvjS0pIZNHccp9VqmTjWgDEudr55O9M7vcDZv7Re88P2zJ9o27z45HdKTeS8yayEQC9e+sMc94f2aTykMU6kEVYIAKAhEEgJpDRUCCikAdLAaD5hDRDUUkrbdW5evu5pYmdqftAHTMiiCiTS47TpBASg4WSMfae5vX4w6kWWvdbqAARLyW0NAkwsBB3XIkA2W/Hq+pLjUcULB6BimIdWZDmUhqjRCSuWNqL6tas3X//gvctvvrJwZd1vNO9/vvvg7mMsZV5N3VY85Ln2yDib5mk1703AWYJ7+QIOnBIqhr9+sHc0yBRwq3EaaFwJnpYVhFAKJQDSmBalhApjSYhCdcurW4FbqQjYlLjJLK1ZNi1YQP18UhBAfeJhTLRCNvKSYT4bztbX17dub7JAHBRnZaAZhRJjBqGCSGsJtLx543IcuctL7bKYayim8xFxKaCQul4pZMGqyXw2TdK8YqPpRGhle67jezv7O0KLg4ODZrMJNZhNpkBoKDUBGmo5T4owauWFGo8Sr1abZjOXUqj42dmJH3pff3N/OB0i38olL9Ji9+HeaqPDp2mnHlcsL1RpN0LtYYmhYvyrj+5Glgu0FEAzIDQElmWZ8WOMIcYwjAMuGUBaQ1Ww4vDkUBOFbJjrbPHa8rv/408/+L/8pbMSPjvb3z3Zm07HVVrOBpPpYBLYPtLgaP/g6YMnv/nvvx6fDjWXUKuyTNc319rd1q07NxeWusPxCGJUcVZxxqUoqtKcZQhAJSRSwKhgKKUggVxxSKDQYjodx3GIIZJcYEqEkgJopmQjrCMJKbaqgjFWep6jtQRAcV4Z9B0AQAKNKPkWCwChicYNZtCsHxoOeE6Lq6GZsngeY37XVr9jX0oDTbRAEGItNcbUJrZNrfN+6Yu3vniz79vnv6nMq5WglIoKIgZkJn75X//BQVaelYBCYtHAshhjQa1+eHzkh3F/3G8tttvtVu/0bGNt7ey016o3yslcS4UIhQiVvLQce5al9VqNpzljjEbeWz95R4dIKdV7cvLlH+66rv/Km69qX7eXWpqBbJaLCv7617+pxd725a2V5Y3f//ZDKFSz3tp/useqotGoYQIshza7C8PxJCsYy5kWsua6tmUprbniSZmHUYQpQZQgDebzFGMMNRKMYwAd32OMKaVYmXsWhQTNRQUoXl5dqDXirMyH43E6qwAA169eWljuAhscHB06xEuSZGt9o9/v11tNw8UMAODynCt9NpsZzMqFLgPn3KZWkiRZViwsLHDOP/3007feegtCOJ9Pj4+Pb968OZvNoigAAEzH46hWqzg7OjmuBY12o0kBPjvpCSaLNJtNp2mSe54nKk4IKUtGEMUYQwyyquwudbkUtTh6/PgxJHhxsZvO5gSBhZVlL3B933MChykOECyKwrZdE12bANXMPJkN3ajVOedCsjzPfd93bE9rrRSASg8GA8OQ4nmBqZPVajXD3vCHP/yBcx7HsRd6SZbeunXjnGkAYzPmkqZpt9s1P9q2fc6HpBWlVAmNKRlNxmEYzrO5CXchhEgDrbXn+JzzijMTE5WMxX6gtWaMnZ6edhc7xjnr75KbGOYDY10YfKcI9D1P9qfrt//sghpAjaRWgEKlBIEW4sDifwQh+Me6tP+GhTEuC4YpsgOXOBS5NC2LssqBkPksQZY9zfOTs9Nmsxl6/urisqo41KC7uMCU1Agen5wAghUCTuCXkgsAi4qHQaCFJJZluy6v2Geffnq4czA6G64tr2FIIVNPvn6kS6kZEEBngkXt2v/wf/wfNrfWbELS0agdxmJW6JTVa7V2u5kXmZSyzPl0MNGlkGnmOSTyXB9buuRA66qq1tbWsjydTsZFkQf1iHpWnudSC2CjYT6VUAICGBR26FLblkrXm82Ss/5wUKvFm1vrzSjGWiGpnz7ZyzOeZ8xz/E6rttRpfvLJRx999FGVF1pIA+7J08zUDHzfN8R5hFhKnfNrSylrtdpzrAyMosDgVzjnV65cMRkdQgQA5Po+hNC1ncV219BqMimSbN5d7NQ7DS/yK8VGkyGimDHWbDZNVmb+ZJPJhDHmB4EGQCnR7/evXbsW1+uLi4vNZvNs0B+Nx0ZQFCFEKTYFFROhlWVphKF83+dSaAg8N3AdH2j0nFtEa6T9yPejsLO44IVevVW3PRtgIIEuOXvr3beaneY8m3PO0zRF6BwefDHeaUYRAACm7WTMFQCkFNAQlGVpstnAjzCiDrU82/EcHyhoUEee445GoyzLXNs2eYFB+ZsRdvCcAv7C/L7n/S4CT9OS+eE1f8x2/lk/ZxzvRcR+HvpS+v289I/d6J9/gz9ygZCSWFQpVbCKuvT1t99Y2VqzfYdS6rnuaDSyLMt3PWaiSiltagnGmBQAo26363juJJ1zrYqqpLYNMcqKnBUlhkhKKbVqNpvj3uB456jmxmcnPUJIFNW0kIc7h1ghiqgf+lxViOrOUmdpdak3HAwGQyV0MptLVjmO47quUoBgWqY5hSjwvSxLK15UnCFEtJZhHEII6vXY9R3Gy8l8FsQhdahGhimATpM5tFDBSwH1YDbhWvUGI9f1ZtNkPB5jAJUWYejP5/PJYPyH33747NET3/WgBpZlHR4e3rx501jjcDg08xmm0K+1tm27Vqt9+umnpmsXx7EB4pgSKIRwaWnp4OAgTVPHcU5PTwEAJgyDEF4MWAVuMOr3MMaYkuFkXMoqasbNbntxecFyLakFsel8OvFdx+R4ZkzM1BgXl5fGs6mCSmrBRDVPZ1yJOI7jOA6CyJAPmYaE2QNmVPpiqgtCaDJAM/8JITTEPwBB1/em06lJPk0d1RR7bZtKKa9du7a5udloNAxa0IB1zW2LojBJr8ldjdPzPG88Hu/s7Jjv7SIcNTBg82E8zzONJYxxlqRxGF0Mjl9sfvPVXTjS721v+LIm5fdqvC810QvL+pcY6guVHgUAAPB5tfaHH+jfsH6YHysIAKESAqUUBlpB3V5pv/HB234r1hgMh8MgiKIghkx71K1EJbWwKBkN+rUw6vV6w/EorMUc6mmeEsvSEECMpJRZVgCAEKHz+bwWRpEXYaZ3v3n22UefdrqLRVXWms0iLT75/Udff/6VhbBjYQiVJkASGLfb1LGJaydFJhEwbNSU0jxNCSGTyVhqQRzCkRYUVVBxrWZp0hv0NQSQ4KLKx+Phs2fPqGdLqGbprNGoMcUrziFG03RuR968yi1M5oOpLMTHv7/7i1/9BtvOK2+8/ud/8fPAtYanJ6DklsJKQ4UwpXan0wEAWJZVj+J0Nq/VGmdn/f7ZAGrEK5HM0lajGXg+AAAhlOfpeDy8dOmS4emq1+utViuO4yAI2u22ECJNUzOTzZgoS4Y00kqxqqIUj8ejlc21QlTIJtgh0EJRI2q0G3mem06GTUnJWVVVZuxrZ2+3s7gQRdEbb7yBLNpa7CoIiqJ4+PjRNJnneW6A2QAoSrHB057L1wNg2v2z2UxrneaZhsBYrxDMlDYqXlKbzJJpVqQVLx3PZqLiknEpAIIVL23XiuvRK6+8Mp1OsyRFABKEBeNaKl4xw6JEMUEAGpyw2ca7u7vT6fR8N0opOYcQS3keGwaejwA82Dt0HA8hosQ5FH4ymcxmMwCAaedcgAou7OJ7tvc9//nHzOffYEpSa42gvrAmBIWS3+J4v3fHf63dvjQhVhBwrWxCdcUJogAgXnKHeh//7g/pyViVgnFp27ZLbcdzoUdPeyf1MFRQCYSobXmOp7UejIazyXR9YVVKiQiGEA5Oz1qNpoYAAFWWRbvVKvKyqErX9SvOCSFFlUMCF1a73eWF/mS4uNLxPO/4+LjKxbSfVkmJuOJVgTFeXl4+2NtXStXjuGQMUcC1SKvKok5sBZIr4mLLsYbDflyvaQKYEIwJCCHjUkqppTalaS4FANrQzDqWo7iyKAVA5WVeger67VvbW5c0F+Pjs8+/uBvWY0Dx1rUrj589TWfzn//85+YIB0CZHDVNUyMEWJalGeOEEDqeyzkf9ntxHDuOJ6VM07RWq5mYzQSEhvKn3++HYTgej7e3t4skHY1G4/H45q1bbhBqALIswwRmaVGV5erCEuBqOph989V9xSQmluW7jHNsYcdzD48Pl1aXEEKvvfbK8dmRUpJigimJ6jWlFITafNV5nl5kzgYJNJlMXNc1k59lWRJCiqKIwwgRjAg02GOllEVsY1GO41wM0AghLIuYJifG2KD8KaVJkgAAjO+t1Wom3LggyzazuxDC4XBoWRaxqOM4WZYNBoOtra0sywjC8/n8+PDo0qVLnhf0+33P82qNulJCa23il2a7YcKBF/sr+mX42wunqp8XkP+YjfywFHzxzA+9roJAK2h8qVaCaIwhgdW/YAr8X3gewBfWi88TSDjnECOFVClyK7QUFI1GTUphQh0JdMWZAhpKZWMCIRSVqLIcCFmkmZSy2+3WajVeVYIxgvBsMvWCCCLi2B6E2HHcqmS8YLEVWQpaGsa1sGBFVpVRoxk3W+ubG0KIYX+w8+jZo3vfpIMJ0VACDglQUDuO4/thHNcBQjkvb7316o///GcbGxsUojIvGCs73e6d119rLnQKVuVlSSwah74W52olcRhms7mQvMiz6XAkyip0/TAMMcZZkWoIgiCM/MbXd79+cv8RAtAN3LffewdRdP3GjW6724jrJyenT548McC6LCsmk9nh3j4GkDHm+77ruoaPI89zozX2/NvWlGKTBBrPedG0IIRcuXIlCIL19XUT5nHOty5d2tvbA0ARijCBlkNrjXhxeaHipYa60W68+6N34bnYCQAAWNjyHLfZaZ+enlJK8zwvqgoSDBB0Xds4TyHO4QQmBXUcx/BIUErNWJkp28RxrJRqtVqYEnOKJUkihHIcL0kS0+wxk6KO40RRZNs2IZaU2kAODZ+9IeM1jd/RaNLvD4VQACDDpZBlmeu6xrRM09X3fQBAGIZra2uPHj0yMMDF7sLq0motrLmWjTHu9Xp5mqV5xgTXELS7HTOqbqLo7zRF9Lf/XjSKFy3thzsffNcV/9A6/kR2aYZjjPXDFyfX/vcqF724kAYEYQShRpArjh1S8lJocenyloJKASklV1xIBJQSs8nIIdS2LM65g6liQjAuKsYr5jsuQohoCITkVSWEABiZfANDlKephe2q4lVVAQwqXlmeTWyitQZKYYiiKGq1Wr7t192ahSwMEcYQUogB7J/14rg+GIzm8/nSymJYrwmgb966laapEswipkCAJuOZEEJruNhdODo6cl3Xc908y5LZnFI6G08IRFADx3K0BMPekDoUEUIIBgAgpQlAD+89+PV//5XtOrVW89LlK57nCa7W1zYppVtbW2YeMgiCy5cvm+jLTHiA55AXz/Mwxru7u6Zwch6g2rbhIjHh5WQy6ff7jx49QghFUWQoRcqqunnrVrvdrjUbR0dH4/HQtinGGBOIELBcRyHFFLN9Z2l9JWOlAtJg5Xu9Xi2uA4T3d3bTbL62sW47DgDKcFgroLXWg8HAdz3DMAQAMGZpnNsFT3pZlkEQXKAOMMaNRsN1XcPu57qumdgGz7umUkpDO1aWzGTmcRx7nmeanBhjM0xrMkzP87Isy7IMPlfdNqeDEAI8V0VZXFyEEPKK9fv9PM+zLNvd3W3ENTOnaj4qAOCCz8EktOAFU3xxS79oaT8s7f7/bi8QQq0U0upCnBh9jwzipc7w37YuclT9HFQFz/HKACGACLpx54YE5qMoCHVelVADgrAhgyrz0oIEQYg0kEVlAZTM5lJKzUVgu5JxIYTjOKPBmGrMC15xgW06zVNtoQpUyIYYw3tffnG8u6u5ABohaGFAZqM51mA+nZbsnNwoSZLpdEopLfPcdz2mBLSp0VDwfV8Jube7+/TxY6g1BtAG6ODJ7trK+mg4PNk/XGx1RpOxhqDVaEkugyDkXBZ5ZRE7T1PbsY7Pjs/OjomGNTfwbDdN8oOjMy605weQEAQUZ+Xly9vGGRprxBjX681Go7X3bIdARAgZjUbPLwC1WnQOOZASAKC1RAgY4XrzvTUajfX1dWMz58Ub19EISqBXVlYWFjoml1OCQ62UEgAoDYAEGhC0sLpo+c5sNhOSUYJ6vV6WZSsrK3Ec37t3bzgcWo49nk1b3ZbUSmtt8AAQQqWAZTlKATNnasad8YvCEM8xOgAABLDkCkNS5hUhVlVxpYCUWkpNqa011Bp6XjAajeI41hoqoKU+Hx5ACIVhePnyZYMZHo/H5sup1WoGmzlL5s+3GTIBc1VVs9nMAJuazebR0dG9e/fMmJttuwAgCM+ZSsHLdJZe/OQvbuw/tu3hd9efMJA/egFUF91XrTVQWut/vTLiv3C9+EGRRugFRkMNlUJq/eoWAwIhoKUyGQWEsCxLz/W73QXXtpUQDqY2IlgoAqBt227gY4whABalZvt2u10pZb3WTPNsnqbrm2tCMI3B9vUrXuAihJ49e/bk0ZMkydI0Yxm3iW3bdhQFSgHbdoUQvu9LLbSWvus51DHzLsPJWCKVFYVt2xjArz77EgjNCx77YeQFomKNRmNjbS1LksuXL3tBULLKtm0muNI6zbPpfKalshFZXVhZX93gnFuOHUYBhPDDDz/8zW9+W2RlOkvvfXNfKPHaa68Zojr4fIa+3W6bjC4MQ0PsYLK+4XDo+77ZSfP53MyRGufj+77RZTYA9LOzs2fPnhFCFNC261ScYUqY4CZXZLy0KIUAmGQ4r3LbtZM8oS4lFrY9Z3193bKsjbW16Xg8HoxrtVoYxJZllWUOITTTJFVVMcZYUUKITafUHB/mgDDTKiZ6NCGrcW6ma2IQWsb1OY5jKlVma2ZZZvRgoqgGADBlLeMbDR0RhDAMwwvXSildXl42UQPGOIoiE+FnWVYUhUEFR1FUFMUsmT99+nQ0Gk2n08lkMs/Si1K2qSFfME6YU+b/T3bxzy4Dq9VaQ/jtGfHPW+n/Xt4VaYDVeWQvoRJI33rjjlCCUgwAMNmIOU0ZY0EQ5Hk+m0ygVOloyotKAa0QFFKa3GM6GktDLguRhNr1/SRJZMVC19m+fGl5deXq/5e3/+qy7LrSQ8G5/PbHh02DBEAYEmAVi2Sr1CqZ0pWu7uhu/cd+7e6XHvdB7l6p1CKrWCSLngRAuLRhj99++X5YEYeBdEyAKK2RI0fEOWfvs/eOOdd03/zmt79V63YwHr3z7ruj0Thi0d5oP0vyTbnOh4OYx23VM8a11gj5LEsY4Mf3H64uV21VF+Nssj8FhpXRxOGjyUwA1l3flpWWkgIGbReLBWDsAKqmdYB7YxFh0pmyrx88fsARk5u2XTegwSFYd9WtN+7+xT/5zrfefmd5dvGj//6jH//tj5uuHc2mmFEgYLxzCIIsrtfrsiyPjo5Wq1XoIMUUeeT29/e3261SKpT18zw3xmltg9xfFRIYHYyGB0eHUqsQUCACmCJjVJJEUso4jtuq7VqJMbbGWKe996vtKs3TWjY8YoSQstz2ff/5559raYxSfSut9V3TGq1v3749GAz6vg2+YjBiGBBCKLQTEkL6vj8/P0/TlHMeRVEA617JAMbeAvLYW1dkudXGW7c/2+uattxsV4tlUJKiKDDGaZoD4NVq1XWdA18MByGslbJTqp9Ox1HEQ6HFgZdaBUEN/lGe55TSxWKhlMrzfDgcaq1Hk/H/7d//P/7sL74z2dtP0xxj3HZdABI/RYnyBWv2auu5n/wKnvCuBhuUznrnjH1VW/qVneEbOOPriRXBZ8D+zht3PHVRFlurQ9IPADabjbW+6SQhBJzvmjaKIo+AJ3Hdt62WnmDnXGD9SZLEYQSUeO9jwdbL1fn5+XQy894PRqM/+86fX1xeIgAtVbnZPnj00DhdZDnxPuFxwuOLi7lx9vjOLaklxthqU2+2wywXlImINU0FAM451WuKyeF0j2HmreuaRmuNCBFZEiLGbV31WgFGiMDB8cG733qHYLDaJDy+vFwgTAfD4fHd472D2Xe/+53D6R5xSNb9m2+81XStsTbAUD///PO+75fL5cOHDymljDFK6ZMnT+A6sRm420MzRxC7NE0DjHa5XI7H4yRJQpJpPp+/9dZbgf34epTgFSTAe59lGee8a2Wo/udFaox6fPoYIXjtjdek7Jqmmc1mRVGA88STyWSqe/n44UPBIgBomgYACAKMIRQ7gtsZvvrJkyeffvppcAqklIGSa9eNGULoHddJiF1Da0voUAm+fXBWA9hglz/z3ldVhTFO0xQhFMBeGOPAVxiqqcF0h4cTwEzj8RgAvPez2Ww6nQZTfOvWraqurXPb7Xa5XIbMUwin4To8/rJy/nUtb12gz3Ue3A478bWd/Xn+OvKBtsE5BBaBReAQIAAMznlDOXn3e99uveqMLMuy3NYIiLU+dGNRzCIed50EQg2g3mqexI7i5XajrULYh04xxOm2rrZVSQX3CDDlCBEHyDk3HU8wgovT05/+3d8/ePDgolqUfa36rl1ufN1jDUmSVF3rCXIIOqcYo3JTUWmxcZv5Ukt5cXEuVRee0maz8RghgjEgwTgiuO26um025dp4J40WMXcAVbs1TnV9zzlvek2osICWy9V2uyYUA7jj42PwXvfKaoh4opU6OztbLudHRwdpmo7H4+9+97unp6dh8t/BwQHnPCQ5eSQC82XXdRjTNM0BwDn36NEjIUQxHIg4EoJJ2R0fH3JOQ3ppOV9Yba7zlsQY5xFBCMVxzHgklTLWjkajKIomk9FkMn7jjXt1XQKGOI5jxtuqdsYyJsb5KE/S+/fvG2eN0mdnZ5TSXqv5fP7BBx/NLxbbdbndVnGcHhwcEcL6vg9Q+4B5CP0lWktMkQOrjATsCcOdbDvZOrB1W2mrmqbSWrZtba3WWiZJlOd51TQhPTYej4M7GhyKQB0Wku2U0k7Kvu9DX1vIY1HOCWM73ELoLI/TBLDv+ubDDz9EBH/66afhUoNPHrTiK9jA5yr2V9D2EBo7BB4jj8CFsRFf19lfbWHssQfsEADGjvjbb7xGMmGcnU6nnPO2l5QxEachfRd6l5BgGnkPUHft4e1bo4OZ9VdjFKqq6qV06KrORphI02Kz2hKHCUK/+tWv8jy/ffv2/v5+lIjRbDCYDkIknEQxQigpBtL7tu+llYb4WjaLs4v12eL3v/1Ia/vOt7+ZjHJPcCN7wIhHQsqu73vKmUcQqgJZkSul8kFBGF2u10IIIeL9/cO0SC12lNMoTbK0UEr9/sOPCcLe+3yQIYSsNj/+4d/94ic///zzzx88eBCa0QAgWMh79+6FWkKwKsHCWGuTLD09PQWAruu2223Yp8KMlpAMwxjHcRysVgjb4kCueU0aFDBM1kMIU+X1SpJIa+3BHh0feLBKqSxJI8ZjkXz88ad705lgfLve7O3thcau0Wh0cnJyenr66aefhn5OhFDwVANoKcR7IXzdEU+HVE14PZhH51wIMoOVOzg4EEKEW3DOSa3avg9kEW3bBn1r23aHOgpooZCnDf9ba9u2DXa167rVarUjrwhRcXAJKWPHt28Nh8PXX3+9KIpAzL3Tzx2W6H++UaWYYIwRIoFbxYEHcF/Olv7R7NbTn0fX88o9RtcNNICRQ9gj1xtNUv5n3/m2UVLLTsRJ1bXrujw9P6OI9o2UbUcFvyzXrTdVX1NOzleLdDQY7E2k1piAYERrLZJ4djDTxlgHXSt//MMfnz548pMf/D32QAXXyN974142yAkn2SDzFDuKt33VmG7V1YPZrDcmynJNXTJKIiE++u3vFotNNh7f/uZb/+Lf/9uoyFgcXW7XmDNtjdaaCBrA0KPxQMqexwKDv318NB4OLy8vnUV11fEoMqBJDIBN11RJlF6ez89PLqQ2jx+fIASEkFREb96998233/nu9793eHi4WCyU6hkjoY95l06r6zo0eVOK+76fTCZ5PgjWL47j8Xj85MmT5XIZkitBNxBClFJrNaV4UGQEw2qx7Ntus9kghIyzgBCmpG4bbV2a5oEVxXmDPeR5LkSgbkRt3TBMOOeci9VqU663o9EIABD2nOLBIL+4uHj//ffffvtdjKm13hkP7grdqpQKfaHGmBBJhrSwECxJouGwUKoH7DFFZb1FBHjEeMQwRYC9A8sjRhgOtbgo5oSQcGEBdRCC3uCa7mgBATkpu9Fo0DRVXZdtW0cxH0+G6+22blupVaBoOTk5cd4H/9ZjdHBwEDa1oPlBWgOg9ytZwj+sL3tsWCErbkKL+atnj25ewVf5Vrgx/RTttijvERCCHPjheBin0enF2bJcnC3ON+XaWi1l18qGRDw4tE3TDPKh6mXXtufn50opwmiIu4JsYYxFEhvkjbNemZ/98Me61tvlNk2zsi1r2bRdHTG+uLyMo7TtO+NMPsyLIlNKbZabo6OjruuaurPWMirAo7/47veBIWDom3/23rbaeO+1NkbZNMk3m1q2OhKibzuKyTAvkjReLBZ12xbFMHBYeASEs85I4w04LwiNWPSzf/jF3/7wR/cfPUyydDadUgfTYhhSLxjTyXDy93/3k88+uX///gOHIBjARERJkiRR2vc98phiwkQU7EwIpYwx3/zmN4+PjwFgPp+H1Pe14SJaGgQkSwurdbXdToYjAOj7XsnOGPPZZ58hhBDBxtkAJAaC2771CBmlD/cOq6ryYPu2xgjaugm2yDnjnEOUOOe+9a1vRVGU56kQIooCWgiF9F4wfQAQuG27rgvgwRBLB6vICJVSZkm6M783KCYghOvhXkJ9GAAQQoEgtyzLAPPY9XwSuBrf4r3frNahJzZ0FCVJEkaPI4SOjo5++ctfTqdTAKf7Lpx2x2wUsFNPcS98qfWnqCjyoR+b3Oy7MeZ5c2Lgpdy8X/ayPCIOMCDnwYbOPQAXUkoIIWQcIPedv/xuj7qz1en+0YhxLFWrnW6VPFnOpXXT4XSc5uV8GWMOXY+lurw8Jwyfz88R8hQBctZIUxTDUrc0jxIuDodTLG3BsnfeejvNExqT19+8Z0tV4Ez1qm47womWLfQdtZoCevjpw8PxYcJSSri21hjDKMbgEVjjFaIoEYluFbK4a2SEs0f3T4u0KFfrlLBysVqv1+t6G9xIAmi72dRth6jwDijGGBz1HnmEMfUeDUcTYx3C2Pfmw1/9hmLw1oFHq2VlWr9Z1I9Pzj759LPz+aUHC1epeVRt22rbVlVDCPEItFXWm2B2EAHAPs9TY9Tf/Nf/HvG4qdq+lRQzAoRhtrxcOuPbuluvVhQQQyAYp5h88523CUHOGUwJYESjeF2V62Y7GBX1svr1T3/91ltvKSsJAUJQkmTj4QR7IBgDQsZajCnnEWOMMMwEzQcZYdh6o2VvtcrTTEsVBjooZaqqESKmlINDnApwyBnvLVjttDQUM6udtxCmmAbPM+xB3njd6yB+QVeDOh0eHu4QHc5YgrDs1CAfOgdRlAwGIwwEeYw9Jgh1TVNkeZHlCPmmqd5+683Li7P55XnX1juZBHC7kvXLFOkFWoBuQB1e3iP+XA3a/eyc89YxfHXx3gJjz+tc+7I7wSs6BrvbQxCSOw68JxQhSiYHs7/8l381mBaeQpRGiGDpTKfVbP+AUGq07qou/NWLNEuieFQMhsMhJ1Q2bUJovVpSQCcnJ8fHx1mRZ4N8OByqup8OxhhjwJgyTBDuWwkaqU7leX782q133nsXIZ9xQQEnPGJAwEHf9uEJ3P/sc+Y9w2SzXRFOOGWC8zTOxoMxxfTo8NZyvc6yzCi9P5lOp9PJbGq8w4gKwUajkfeIcsEj4QAO9mbBdHAurHWMMI8RYyyN45OHj370gx99+vuPf/SjH3/22X3G+N27d99991uvvfba3bt3AVPZ90rKruuGeZGm6Ye/++jRo0e72mPodAu4JULIaDS6d+/e/v5+GLKyuFgoZcqy7LsugFpHo1FVVUEKQ0doiNO899Y7hHGUxCxi7733XiISMDaORSixMkwopZeXCxpIgLDvZM+YCPjbKIru3r1dFMVwWAwGg9lsNplMAjYoBMPhi65KrEqxK9AyWGuLLNdaB4cisHnADbIF730IF7XWoQoVnP/Q8hLi8NVqdf/+/dAu568RuSE8JoRQTC4uLsIZwgmFEFmWRVH04PP7s8n0TxT+mwe6G2sHivijR938mEeAcaBrc1cIwTDf7atd06uvazIIgB3j9hUdKTLWeoQYYUrrt7/57sHhkeyUtf6XP/uldj14FzimDqd7Z2dnPTgHviiyummM86Y3RZQ5oHbbrB+didfSiLBHnz3Urv+Lv/gOMRDHcbUtHSBlXd+1rncQenS876S89dYbhNG3CPnVT34BGgDAOoEx0lIyxtIk/viDDx9+/vs4jab7R/kgs7UB5wkGo6WUBlOkvE0HxeLxeVbkiOO+l1EUmd60bYuzrJd91dSU0mExqPqWCX5+frq/v5/Giep62XVRzjop0yS/PL2omzYZDqu22huNuq4pRlk+GDiPCKMI4c8+/XQwHAZHbjgcDofDpqlGo1FIF52dnQVhDWnbgEAK+RKMgTGCUCSl/MlPf/ruu++enJ6u1+vp3sQBeO8AgCB8NXIXEGBMRVRrhTEG5OI4DkNWHNhtXeleem8fPzpJhgIz3HWS0xhZxBhz0mEg3ntnbGDQDkksQsi2KnfIqr7vR6OR7PptVQX/a7PZ5HlOOQuYoQDrpZQaa7uul7IbjUZa21Ag4ZxvVusAPCiKIuwCIfFbFEUgE+y6Tko5Go2klA8fPmSMDQaDkA12zJd1RRAOzq0x5l/+9b8KN35Tl17F5LxKafSrpZ289w6DdeAAEAKCECb4iunzRQfctNovsvJf3QVHiHMesJpMMGf8dG9qlPGWfhx93EpPqZfyavwzIaSqqvF4rKREAIO88NYiDzGNNpsKvG/Lanp0sG62PeZnZ+fEQWhZrMvKCseZyEZxPhpuF6Xtu3xUWGsRI/kgG44Huuwxxi6mjNAYqDMWW++VO7xz9N6ff7u26t69ez/6jz+ggPq+JYz2SufTgWbm/PJiNhkbbQEAeTh59Nho99rdu977oCeM817Jvq3TOMmKgjEmCFPQB2rZOI0xwdN8uizXSTH4F//ir0wn+77/7a9//a/+zf8iQWNMKTNRxKOYl+UGY3r79u2sSI1RIfkRiHk2m810Ot1R6ZVlGdCzsu1YJBBCvVZ/8f3vTYYjhNDBwUHdNgGgA9cGObRZh+avvu9Hg6Fxzlq3v7e3fVBxzr1HlDKt1cnJyVujNxgTcZyCp7JXGF2NxI6iyBintQ7KNp1Om6YJFH5lWQa8UV3XBOGf/vSnb7/9djCeoRg+n88Hg8Fu6ikiOMsyY1TXdXGcokDPi5BSan9/P0SkCKGA0ArUxCHlXlXVaDQKXbIHBwdRFG2328FgMBqNQkHVGeucCxSBQQ53EAL/JzMfoBsLXsp5Dzf8hd3PYWlrEcEEkfCrc476Z9gA4cWeNzyzYex+fcntXYWgX+RQAwBMidSKRyJknK03re689ycPHulWEYQZE5izRvadkpPJZH8yJR503QpM27qp65oSbhHgiA/Gk9l4grQdiGQUZ5cnZ+PxeL5ZYUp+/IO/jYHFLDLavf7WW43qnffg3OrkEkkDAN/7v3yfYkwpabruYrlolUQE93VXiHS2fyi9Q4JhQVPBsXeAYV1vkzTSUtV1fXB4aBEobx99dn+QZPt7h4SQsiwB8GazefT48enFubH20ZNToCx0M282G9XLSPAoFm3fOuecdDGOJ8MJAGSDdG9/OsgLr4333oI3zgnBRqNBkidpkQe4eTA7ATMwnU739/fX67XqZbUtX3/99dFoVBTFwcEBEJwkCWCUZOlgNMSMeow8RoEYeuc0eu/BeeQBrAPrZpPJcrnUWnNBR6NRU1VhhpS1drXa3L59O89ziglCCJBL0ijUMMjVSCXcNB1CJE1z733AZuwgyoHudLVaff/736+qKoqi4XAIACF/W5ZlkiQ75A3GeDwe75p+vPdN07RtG3CRoVIajsUYD4dDhNB6vdZaW+0Y4QHuJ6XcNeg45+I49gg62Qc8lvXmBXNEv8r6aubKfxHQvyvt3kyniST+R8/xPv9U16O4AMA4a70L7E+E0Qeffmal4oS3deO9H+YFAFxeXIQALLQOpnkWJUnTtQ6TbDad3j5yCLI4yaLYSlWk2eJyXownDpNhOnj0yX1kgBF2fHgYxTGJuAP49IOP+qqJ05RE9O6bryGKPFgRc5ZEZV3FlCdcOO0o5aGo4LwBgF514noIF6fMGhNqHhFle+OJNQYhEsexdvb27dsBVuoxSvKsamrKWVnXsYjyLAvcJUmWiijmmBGH2qqmKEBn5HBYVNU2uLjOudVm7ZxjjAV5DfibEBAGLzeUHNM0HQwGcL3Jaq1nsxkACCGatgUAZfRuUlhAIwVluIbdyR0OoRjkbd8gjPu+D2nP+eWCEc4539/ft8YTjDEg7702Juw+T548efz48cXFxY6oIXTABA8WXRMaAkYBjjedTgNUY1fpnc1m4cCg28aYgMUNvWzBPdm59H3fA0CAN6RpGppvJpNJQDXs8JJN0wghdtWppmnCNhHIsnc1ZPhiBeWrJWn/EFt6767HH74ENfTcb8EYe2vBXfHxU4ytNl1Vv/AsX1c994pD7eYrAABAKdXOaqejiFurrTce+9/97rdVWVNPwHhkQNV9tanK1Xo8GFprm66tpLIIW4QJ485B07Udco3Vdd/VXeu9Hw9Hwzi1xrA4shj6qrt8cv7w0/vzi8Wvf/pz7J0liGdJzGPZtJ6gztt0UpRtwwmlgKRSx7dvLy7nSNtqsfXag3GcC8yFcj40fFZt1XWN7nqB6bAYMMZGo9HZyem9O7dfu3s7gFe7Vk6nex5Br2SSZ1wIylme50F/hBDbqsSU9n1PESMenz8+66oanCeEVE314ccfhcG81tqDgyMptVLKIzccD6KIr9frQCkSi8hqgzwGh6z1xrgkiQCcMQohr1Tf9+2DBw/yLAu+cdDMUDkMf98A09nN0sYYC8YDN+f+wawst1mWBYGWUuZ5rrUhhDgL3iOMMcJea6263mkjKOOE5kkaeicAcN+rQFMULFjorQsaFaw9pTQM9gWAAEIItt1eT6AbDK64eQkhgQJ7f39/PB5HURSgCwHkGHZSjOloNAlROsUsidKu64Ik7xTSWn18fBjuaGcnnhL7LyX56JkFX5maDCGEEKeMAkLWgbHIeo5JHCdfmIz4lH4/9ZU3v/vLbjaBtPvmUdpdzfYIxHO79o6mro0x3ro0jinCB7O9NIqdc8Ph0DinrWGCa623ZRkm1S1WS8ypAiet0dY0TcOocM41bdW2LWbUaPf7Dz/+/OPPquV6mOVRFFnvlDUPH58YY1hERZF54gd5kce5MUYZrYz+5a9+Mz+7UFVHHfMK2l5FSXy5XBFCRJQQQmTdri7nod9NS6X6ripLAihs8IE24cMPP+y1qut6vlp2UmprNpsNvubvavsuwCSyOBeY/Zf/8F8efXb/o9998Pj05MnFyf379wUlDLOiKASPw8Bs50zo3grGJLSMhIJkAOKFRpDgzYa2z8FgEGYN2uBFW0sx0VqHowJ/dPhDXNMpkdMnp6HLZLle9X3LGOeU1k1zdnb2+MFDAgQ5BM4HCHFwR+/cuTObzaIoCuAKCAovRCANPjg4CMCJACoK0EXvffB1b3KC7eDcofK5s6tw3f8ZXAy4bqYJbmEABm+32+BTBAELDbqXl5dlWa7X65/85Cfz+Tz4F7uKi39BG/fL1exl8d0N+3nlPrz0PM+eKvyZCMKM0KARVmsank5g70YIffjhh0KI119/Hd3gjHjJhd409M+9lGscA2CM4MqQhuw8cs4RQICxC9QY2k4nk052wlNnLKakKLLtdj2XEgCme5PQirXZbDDlBKFAyTFJRuAhymPjUGc1iXhnlFQqyXJr7bauR+OhV6xalQMcIQcCEaWUVQrF9Jc//8XR3eM0it/+9nuPP/qcAinL0ns0uXO0bipG+C9/9A/JbNhJCZ5I66U1rZacxQiRjCeM0NViuX98TAihiFqtCKF5Etddi7zTWg4GA611td4EVvVmW4o4AgBlNI0ExlQ2fcJj2UsRRayt/vZvfvDO++/+r//bv9VgNpuSYEwAtHaUkMlkVtdlkiQIIcF4mGj2m9/87v3330+SGAAWi8VwODTGOQcOLCMYMHLgtVTeOooJpej87HyyN9Na5nnuva2a2oGPoggQ8hYlSXb65KQr28uzc4yQlF2A3aVput1uJ9MRrcn9+/db1RwcHGhjhrMRJYRw0uur3Qczmg2KawSC01oTRimliODgZAYMvTEmcAsigkPvaEA7BK9bCGGtqet6lxILO7gxJhZRSBS563FVATCEEAG4mrlI0oxS6hGcnJ0mSTKdTnslEULvvPNWKOEEjzQc7l46IPgV14sk/2Zu9Vnj96JTYQyYYOe8c85b4IRhh69oToOhwxjfuXMnjEx+levb5bJeBavx1FyZm1tA2FIizgfDYTEcSGeqvu61qtpGZEmcJIzzKEkQQlmSFkmWiEhco0AZwgRhTIkBr5CvmtqAZYwRhGPKvffrbSkoRx5xzgVlwzRHFvVSbarSSvX48wfZoDi+feuNN97o2n5//3A8nSDBDl+700tppKkWZbOqECJlXb/x5jek0pgS1cuECWoxArzdbodFkaexlr0QzHsfMU4pDch47GF/f386nW63VwN8eykJ44FeJM9zh5FIOEFomA9nw713vvFOiDYpxeVmrbXdbitjTK/kZrPxyDljvffB5XvzzTeDKfPe7+/vX5Frah064IKlCrSDgY2WUiooi+MYeXAOgtvct7Lr5G7CyoPPHxBEI8aDHY7SpC6rNE1Xq1Vodr04ufjs0/tNE1AKNPTohFbYHfXBer0OPCY70xd8Tu99GJsLADeZb4NAh+YYjHG4+Guo09X/O6d9Z2/DQwjAhqByw+Ew+NsPHz5crVbHx8dd14XLC7Dwp6oSX1dYBy/o/35F43zzJCFlE/xEwqgHcOCvHlPIU4eu6AD7fsmJXvHFq7ew9+g5OkwA7QiIASBE/HEc333jtXSQOYwulpeXm1VUZJ6RuMiiJEWI9HWj67ZebWbDcZ5mlFLVdhQQYwyw75VkcSTiaDgagNF9XQkivPGM8KIopLeOgTUm51EcRQLz+eNTrAwBpK0ZTaYeQVVVn97/fO9wj0bcIC+NDYdjD1lW9FYjStq6yZKEUUowHg4GVmnkIUvSvu2sNkrK4EbmWTabTJEHp51VNmzbVEQBkdd0PWMsSWLAHnPmnHPGx1SsL1fgkFIGjE3jOIBvg4UpiqIsS6XU6ekppdx7NB2NL07Pzk/ON8sNJ9SqK1qty8vLAMEHgDgWqm/n87m1NsuyrusA8NWfW9n1ciOE4JTFPE7TzGmLgeheY0DL+SIknBaLRVs3+bCI00gwfu+11xIRg8PeOudAqV477ZBzyHlvvbeEIGPUdG/W9t3NoCkom/fWOB3yK0FhQsIpxAih5SXPcwAIuPzw1meffbZer4OOBfUOgdJ4PA5JteVyGY76yT/8+Ne//VUciyjibdvmeb5ziYPt/dO19CXh3s2w8atloTAlwAhi1CLQ3mlw1rk/NK+F/MEfdab9jfLpq1zHiz7wVEgQQiaH3Xvfed9znGQxEzwr8qpt0mFhwC+3G0zJYDDabDaDoui7DgAoJlEUeW+Rv0JIW2vn83m52WLnJ4PhKC8OxlMMiGCGY1a2tQMLoc3X+Wk+aMvaKI0QitIEMEUIDbJ8Pp8PBrlHiHFe13VAgXhvjVRaq+l0ShBu2xYT4o1N46STfSd7xtj56UnftwRjRiil9HBvHzlfl5WW6vGDh23X1U2DuXAAgaV2tVpRwXvVUc4JIQTRh589jKnAFq0W64jHWZ7cu3cPsyuar1gkYc5acN5Ce+Qvf/nLvb29sDX0fT+fzw8PD0NiM/xBRRw/fvw4yHdg9MOYeu83m83x8THFjGEGDqhH3sJ6vhIs4pRelVIJGeSZ925blvPFIonjpmqqbd02fb2tCcIhxQXX7LjhGvI8n81moSMcIRTYGHZUmiFHvYMZBThRFEVBDELLeEg7wfWkmbqu3Q2O3BDZhmRv6PMOFqwsy+12+41vfGN/f//WrVuhZxWusb67vpwvmyJ6FfH+o7rwiokl450Lm5ezDjwmBMj11NTg9wdeCfQ8rMLNHWL36807f8ltoGsWtl3hFMNu0g7yHmFMMWEeIYvAMDi+d1tZdXi4nwruldHaKucdJp3VVdfmw5HW2huLvPPXsCwCCDk/Hg/zPB8VA+w8gHfG6qYjBtlW9X0PlMTjgfYOUYQ9pohgRDmPfvub31BM5hdzZSwj3Gs7ywYJ5cj7KOZ7swkgZ52OE+GNEQjV1RYRYKmoZWN6WW+2Vdd6TvM8V72cTaZ1uTVGNU3FGJtNp01dD4ri6OB4vd52Rmlnw5iTiAmMycX8QlqjvW37jjFme/3Jr39v6v724W1jjLGWUtx1DQBY65HH5+eXdd1qrZMkQYgMh+N/9s/+GSEkihJKOed8Mpmcn58bY6qm1loro+u2uf3a7aqtECWYUSll27ZN1cYiccYbqTgi1KP1fH368IRjYXuNgQjGMMMBkxBF0bf+/Nu37t5ZLBZg3XQ8a6v29x/+fr1YUkqZoExQwjBhGLBfrldREodkB2OsLMuriXXFaLFYhOxaIFX69NNPP/zww8Fg0LZtgOOHbFNVVYHHDABCPfaNN94Yj8dSdgj5AHTx3rdtGyquu7RwXdff/e53OefWOyZ44HAIs9Xgi07prl7ycp35UuspLXh2L3iVrWEn0nAdkFvvaPDE/PUEgZs71h+9oJfrZ1gEEAIECODKx3l6vqr33oMPN2S9Z0K89e5bD37/SdvUiPIojuquw5TUfSsIizjHxoUWB0wJ4bhrZZ4OlDKq6x1YxkgqRK0UQii0khulsySREGrcpO+7UT5ImMAE8jwxyJ6eL374Nz+glt06Or5czI1RZVlyzgJ6qXcmz3MpJVjLKVDM8jhu2rbsur3ZrNs0GeeXq7Oxn+R5vj+brRaLyWTivZdSltttnuev3b5jlc6yLB8UWZZcXl4OBoNIsL5usIfZ/h4ANF0v4ghjnETRg9/ff/LkyT/7N//cIkhS3itlrfbec8q8hSiKxuNxMMWPHz8OxAu7jRVdTbYvAKAoivB4h1EU3q22tfe+aZqyLKWUk+GIIsyiSHXKW/jodx/tT/YEjrqqDuOoMca97vM02WxXZB29882329ViMppeLFey74sobZpmNB1Zb8L5dwCGoEVhB8+yTBktpdTKTqdTIeIsy4SIEULB2AZQRIgwAwVHAA/fTMMmSWKt1bIHAADsnAvd3jtmBsbY5eXlnTt3nDN1XWtrQkks2NKnpHQnh1+t4ftF66ab+ZUXARTMPUPYOW+sIZj8AQ99M7Z+SeLrppu6Q4q8/IuD/fTOWWOsMc6GII2GZC9CVzxxDjwAOGsEI2/eex0ALi8vL+aXi9XSesejyHuPPNR13fetxS4aJMpZzrm3FgAYJ1KrTbmtqirLEgBHOe2VXG3W1aZyvRpGKVZ2lGSm6Qdxih0uy7rv+5RHoIxT+vJyAR5r533EztcLA55FrOqbpm8jSmNGo4gLwfqmRgAk4q1VTAgp5cHBgew1pQwBphhHnHFKg5QwQiejMb4Gi0qpRRJ3SnqPwHkA6PueCUFjngxST7A1ngNFCqqq82Ggg5GEou12PZ8v14tVKAlWVRWmTsRxrLWx9oo/9tNPP2eMCSGiKEFXwDqvjAz5XkxJkqVFURwdHQ3zYjgcVttadf12s/m7H/7QKa2lauvaKmukwUCyPA8NaDEXbd89ePyo2pZnT06yOGNUVFWzN933yAH2xlnAV+R9eZ5qLXctAaenp1XZGO2cc8FRRwhZqwFc6BMI7mjwV0O+F19Tq4TXrbVK9VHEA32pEOIqsxVF4VswxlmWxXE8n8+V0YRhxoi1uu9bjCFgOa61EXuPwCEMJDTNvFx0/Y31xzXsmUO+yhZgHbbeO4cAAryBEIJ3pt9fc5yGNNJLLgJu5mYRghu97c+uq4nl3lvnrLXmusserk0xvp7SETwR5wwh+PVvvC6tPLp9FFJ/j548OT09deDDhbVKWu+X241B1iPUNHWWRACQRDHGWFlDKR+MRxb8aDwejUZK96rrq9UWtBeEhyGZIaPgHKRx5m2Il6AY5rdfuztfLpRzDrzzPs0zANBSgXWMCUKuMhyMc2PtYrFACFllHj96pLo+pDoBgFKCvOeUBXhNINFVqu+6RrZdnqTVtkxE4oxllFvrrNIxYxR8EscpT5CBX/70F+en57JTFOHhaFQURbneBBokhFCSpYARomQ4GTPGzs7OLi8vP/jgAyFE03RnZ2chRNwxxId+qCRJOGXeewIkjbOPf/f7zXz1Dz/+6S9+8nMtDSEMAHrdf/8vv2+Q9chNJxOESNgORoOiLjdREpdN+fDJwwDH11qDQwTRMB4ieLNCiPV6HZrXw+1fXFys12vOOSVXJL0IEefAORfgTQAQOOmDNQ5MGt5euXXBm23bVmtNKUcIBcUODkWoDAckoLXaORNAv4HDIXgE7pptFD9FWv8KKZgX/frU2p35FYPe554t9JdSQpDzzjmC0BVgA77ovgZ1vYnJQF8ceHzTU735mRdf/pWp9AgQxpgShLFHsOvrc84g78j1Kw6sIz4ZZsd371RVVWR5xEXMo2A9CGdJkbNYaG+ttUprTAlmtG3bUZ4h6wQRs9neqiwbqaI4Jhgo8UkSUUrLdYMxm5fr8eGepZ7EzCNMCe97Za3zIReN3Lf/7L3JaCpYZMFbD13V9lXrrVfKyM54R6qqYZxvt5WUOskSxpjv9b3D27LrKcHW6aapQkZxNBpprZXXjWqV7ilBccQpAqu0IFRKSbnQzstW+lraso0Jox5ZaykhvrVUooSnCFjoow9jbB49eqCMNtY+ePjww48+evDwYRzHq8Vyu95Ox9PbR8ej0Wh/f98DhFmdoZVH9V21LVUvjVSgPXGoWm7mJ+e//+Xv1idz3SqGybaqzhfzN995I51mf/nX/+zuW2/87Cc/M71MsrRsynqzxgDSm9e/+dbx68dxEWGGz8/PCUIB/KS1dQ7atl+vt3Xdbsrtptw2TdP3veD8YH8fvCcYJ1GKPA52jGKGPL64mDdN17Y9xrStO4KolgZ5rHqtpZJdX5dbipkzvu/VgweP+l5Z68OEtShKGBPuqq0czs/Pgz3fRXdBXW/EosZ7G9Iku0m8L1romfUqWveUFX3Knu1ef+7ZPAJASBtDEEbOY0DWGIIphRvZp2fjzJ3qwh/bS15+9eEqHbqauhE8wJsn3y3OqdYaIXLvrdf7Vj548DgbTH7x85/N9vfefO0eEKyU8h4xTgSP3nnrG6cnJ75xjLK2bSMeOedkr/cPDi7ml2kUxSzqTI0ISouBMm6zLmnMaCT2j48uLy/jOJZSbaqSMSaiyFp7fn76Dz9Wt1+7t16vAWCz2SQ8BmMppQhjI3WSZdmgqPsOeUiSpJqvsO9FklhtkiTpZH94fHR2edZr1al+u1oHGk7jLKXYWuucjZOIIsw49RYCdIZSlHCBPeheGmOcQ1XTiJg//vTh3sGM58KAVUoPh8N//a//dd3VDx8+PD07u3v37nvvfbsuq7//+78/Ozn93ve+N51Ow5ONRFRut5TiJEmUUtrINMkjHnd1R+OIATk/O7v/8eegPfKYczabzdI8G01mo/GAMAwU/fTXP23KBiE0Hgw7JWMe1U315vEb33j7zYDXq+t2uVwmSVJu6ySNGOfOOQcuwP3yPDfO9n2vraOURhENli3M4d6JWdu255cXr732WpqmgY2RUwYAwZtjEbu8POcRm06nAFgIsVptDg4OLi8v9/f3Hz9+fHh4GHSSEFLX9Xq9DPxJu77ZYF2e8jxvhmxfb/bo5VpwM//6Ep03xlwx2jjvvBNMOO1R1ZSvHu8+dVdPbQ8vWjuveJcQDs/xD8e6P5zBe+ScEyzByv3wv/7ww9/9nif5J59+frh/MB4OD/b2pezCnI/NdjUZDRFAFseqV8YYRGjb9865KBE8En3XTtMCOW+N41FclQ0mULaVdSaOEgBAYUwOwcELp5RWTT0YDFarFeEsSZK+aTnmEeda9pRSRgjlvG5rKrj1rpM9AWKMCaNQPILOyMM7R/PlZb3ttFJFMiCEYEa3VemRS9OUMap6KWs5ygsBrGkanoqqqjLOKVzRZynplFJS94NJARH687/8bmeVR4A88EgAAQd2u62GwyFG1BhTbsrNalXX9XvvvScEl0aX5UYZPR6PtVVRxK21BFFvnel1udw++eyhbGUIyRygt999d29/aq2dn1+UTb1/OBVJ/Lf/4wcYCOdcxJH3nkXs7W++E2WR0hpIoKvFi8Vqb29Pyi4QtTZNQxgNcKuAkSSEtG0f8kNJkjRVfXR0ZL1x1xNHpZRFUTjnCKMh2xeLKLwbQlOMsTGKc44x5Zwvl+s0TS8vL0Mz43a7PTg4qOu6LMvZbDYcFufn56PJcNd9vjOhr+r3fSUtePa0L8qS7lKzL9HSkDML0YpR1ltIRIpf9K3PXV/5DneaGcKSp1DON08bog4pO4f8t7/z7WJY5Hn8xuuvTcfjWERN11rrtbZKytFo1LY9IFR3IWKh3vsQihhjAPnhcNi2bS+l9a5qSi4oZUwwtgu8syyjlJZlGTADhJBwiJQSrEPOR1G0KbfaO5ZEwIhxV5MXCCEcEewgydJNuV1vN8v1igouhFgsl3EcHx0dxUmyXM1D2SM0bS+Xy/PTM6ttFEWbzebs8gJdge8ZY8wjcBhZhElEW905b9qq7rbND//P/5+s2iRKtNaEoFDSTpLkqgRFyGgyTrJsNJnYwAWDSZ6kGFDbdZFIlHEIEXDeG5/y5INf/dYbjzzu+55H8V9873v7hwcPHz36yU9/+rOf/eyzzz75h1/8zIFzyFvsojwuRkVapIfHhyxm1hsgEAaQ9n07HBaBAI1znuf5ZrMJVxX+FsHnD3XRoigQQsfHxwE0H6gk8jy31pZlKeIoVD5DZiQEon3fB6xyHMe7KksABoeWt4uLi+Pj4ziO9/b2xuNxIOwOZNm7jh94Ju/63Hjta1nPNWBPrVfxnK+ZNPCugcko/XQX+E2n91kf+ivc23OzTS9Z1juGKefUGVuM83ycVas6FbzIC2Ns23R7s1nMedvWbd0EeHckBEfMOI8IQQiGo2Jblg7AI2j6xhu7t3fgDW67hnOOMcIekHeUEWuN1mo0GvZ9R6wOvdGb9Wo8Hqdpao3jkXAOrHe9lLLtUia891ESdVXNGcvipG6adFggj0aj0XZbObBJHrdlPRzFCKFsOLhYXI5Gk/V6PUjz09PTLEm0lK1sjFTDwbhzMqVxXfccEyk1YIQpMsZMD2f1cs0pc8Y6Y4nG3aapyhILoq1arRazyR7FCBHsvPcOjafjuq5//qtf3L11O0Dw79x7zXizLrfDIgPnsUNOuYv1hbW+06bt+8PDw+9+97vr9fr/+M//RRtJCJnuT43Tm2bzw7/7QZzFr919/c7t29oYjPHl6hKwd8gBAsDeaOPAR4nouo4R6r134Cm/4t2L41QpFcLFWLAkigkhLE5Ck522yjiNCBin80HmnKuqbSiZbLdbhBBhFDwwypXRiGAALES8Wq3G43FZ1gFPjzE+Pj4OOV6E0GCQ13V9enoaYAwvSq4+JcbPxnd/4nrqhE+dfGfYX/6lFixCCANobQWjlDInPaqa8tmPviTSfdZ5+FKqi25U9v5wfn8j+EbYGcsIBee8Q6qR/+V//08UhLNYGjcYjp1zTsnBoABvAVyaxuV2W6SF1jokyGTfDobDy/ViMhphY9bLVRQlaZY5541WnNC2brIiB4KllITSTkmttQMfLF7I/V5cXKRJhhBKsryVfdPVERfEek5o07dd3RwfHTnvFUGd7APLAcMMCGDim7a9c+9159x6tbHedZ0EAEFwmqZt28quXyxWd+/etcYTijblOomijMTOOUq4I15bZbVhHjGEu7KmEWuMev29t/JJThKKOMYYVK/zNCVMKKO9Q6vNejwczS8v//N/+I/vf+u9b73/HhW86ZtOSatlEsURimTb/fIffjUaDMpte+fOnbfeevujjz787JNPAbkoimb706brWESAoV51b7359ng83kHbF6t5NsgIpR4B5zz0cFLMhBDhb/fp5591XXf79u2A+NdaX6Gj1psw9sJ7XxQFgEMEe+QQQn3fh17woKIh0/Phh7+/fft2aBkNGWPkYdfuw3kUGJUAIBBBXINboe/7kCK+Gv75DELuKQvx8izOy9dLBP5ZzXxFAMJuWbDeewIIY+otYEso4l+wpU/dzD9GeP1U7uvZhTHGHIOzDjmgJBmk+/uzTz74NEnGyrjQ0GS977puOhldXp6D8+CxtdYj5LxDiDjvQ3ipjLGdFGnmAaq2SdO0ryWN8HBUUMayQXF5eamMEoI5Z/KsaNs24qLr+m3fH+4fBBeu71tMcCCALZdrEUUxigkhShuexKprHIBUhmA8nuTL5TxK43K7vXhyOhwOEy4Wi4UxOpRn1ut1muQQ4dt3MgAA5DAm+bAA6wKfuLXWgd+2NTh3MBiXi7UAQjTSbf/Rrz5493vv3Zrd1mAwBobodrvlUUQ5Wy7Xs7098L4oMozxG994M4qiTsksyfM87/pGME6xSLJ0erBnlKaUnjx81Ky3FxcXWZr0ui/GA+D4/W99m3ICyM1X89FkaKwmjFhvtNHFcGis0n3vETRNE6hxnQNtDaesqZvJZBLyQ3VdF8VQCOGtq7blZ599JoT4+OOP8zz/X/+XfxNm4SDkCSHIw3A4VkpRyr33lNIwI2dvb288HJVlGaLNwLoSOsXn8+UOn7wbb8EYe/z44WQywRgvl8swKRieCaPgi6r7FQzMH13PquJXMNcYY7dL1zhHMbHG/sGW3nRKXxJzfzVb+tQJn95yrmuqAOARttYyjBBCxjvssJzX//l//09KojgpEBOUUuKdYAwT0FqmcVLX9bAopNaEUY+AIGj7bjAeOucmg2EgEAgwl73pjDkXKCR5HJV1Za3dOzg4PT3NB0NrLSM0tCMPBgPkfCt7pY0jKExSHA9HfdNW5TaKojhKCKOOoE5KbzyjlCOCkEcUtbIdFaPlcnm4d2itrdsGUeK9b9u2GIy89wGEbJWOs9ggxxjjhnjlpNEsZtIp2XUZj1LMddl5hwz1joPh8Ff/+q8ssYC9c65qGu99mmeEsED+cHF2/sEHH33/+9+PuYjSxHmPsFeqZ4whRDCQ7WqzvFyZVm2XK9Wp/f3ZpirvfeP1VrW3X7/rsUcEvHW9bBkVgZY6PDfOebBRUqtdkjZs6avF0jkXtDT0soSSJgaktQ4UwePxuGmapqxu3bpFBZW6D2XM7bYajIY3CRMePnzY9/2br78RmlFvFgLW6zXGNAAJAwVEXdd7e3tlWa5Wi7feeiv8lTF9TpHiKXvzJzq6fzR7BF/UpqeCvpef3CGnraGYEEDOII4Y2BtMnzet6LNnfKoKdPPFV7+xl0fPu1uKoshY65FD4AhF6TB78923o4hr1Xvs4ywNCUBjzMXFXGs7HI7bXiljtb2iipmOJwF9frmYv/utbw6nE5Emg1FxMT9vZQ8Ee4yUUkVRBEj6YDAgCKxW3lut5SBPBSNVvXXapEnSN20Sxd57By7OEpEm2hpMiUPgAJqmoZQi5+uy4VR0bY+AYIwHg0FVl0pLgrDqeuTQIBsg60wvI8JAW46pbvsAgrPWNn1HKV0sFuVmW6Q5w1QpRSMhwTVtr6VenS3OHp4wR5DH4PGTJ6eEsDAdq2taRujx8fF4PPy7v//bJ2enHoBR2tZNwgXxQBCmlDZdV0xGy2qdjPODe7dEkbz7Z9/aP94fTccYAyHIGYsQwohiSqx3iGAHHkIA7ABjWpeN1e6K6haQt45HYjQZh07RQIxGCOKc+utOtNFoFHa9NE0fP35cVVWol3adHI0mFLPAwRtePD689c5b74bppuWmaqp2sViEIXRFUYzH4+Pj41u3bs1ms48++mg8Hm82K63lvXv3AmiEELTDzDyVYkU31lPS67+4/qgwv4qS777I3WD9vBnuPesb764qhPohdeQQALqeQPEqeZ3/OSsk3wEHqAhyzjDBv/X+NwF54zRCoFQf2G4AkclkQilXysRxPBgMwlD30N2/2WyG49F6u/35L38ZpwmPBKIkTVMiOGG0GA7SPNNaB4rakGMMWdMQ3oTEbJYnWRwzQgFgOByGx3d06zgpcgu+GA6Y4ExwZy2nLIuT09NTQshgMGj7HhHCk1hbE6dJnmaCMCu161WEacy4lSoWQnDelbU3FhHMBE/zbDweH832wTpnLGCEhGBZzLMEEbo/mX7ws19//LuPurJVvX7zzTcJo9vt1hm7I/scjkf/7t/9u/2DA631gwcPoiiy3mNKleqV6p23UcSLUa7BeALjw2kxGWhnAHtppAOLKULXMx2CoISJ3aE8EKZ6N03jrgfaB7r68MC11gcHB6H/M+QnQ/dp2HaVUicnJ5PJFbxxu91STDabTfhwuP62bQO363a7HY1GYaRi0PZQXNlh0AHgG9/4RmgoHQ6H8/l8x8e7K8M8tW5q4A7O/pQmw59gZl+k3s9q1osM3s0fnHPGO4wD1Mfjm9vJs/fzj7deaFE9YECUUq21dd4DlkZGefKv/u1fSyMZQUZJxq6aBKzxGGOwLsCvCWcee4SQlBJjsl5v0jTDmJRNnQ0KrTUimEfMgm1l65AL3qm3NuI8iSJGSNc03toAPQvCV9c1owScpRgThPq+n6+W0mjn7GIxD63JAboQWEi898poT+FiM3cM0vGwahutNTjne0Ut5p72ZT3KCqsVJxR5n0QxY6yst/PlpRACOy8wTbjgnEtwvTMKGSJ4u60zkT65//jj330kKBdUUMzSJD85OXn84OF2tb64uEjTtOt7wjAXdG9vSjlzFHfe8EiorqceXZycgHOcs2KU54PcOMMEzYeDTvYegQNECMOYtm1vrd9WpfVX5J2BLD+NM2e86rXqdWhAD7SJTdMQQsIGF8dx0zTBK3HOpGnMOXXOvPn2WyKJ67r1Hl1eLpqmK7K8b7vVYrlaLLfrDTgfXgnKJoTo+35/fz/gLtfrddc1WsvQYimECE3ncRxPJpPQGh6ab54NxJ4Sb3hGqV7i5b26jf2yruWzZ/beB2hjAHU6bzAB4/TLuO1f0fp/5e3nuQde7ZeA4LoHwCPQxhTT4a07R3W1tlrVdblYLQNcs67r6xosClt74O/JsixU2ChnslcPHz7Mi0IavVgteRw5BOvNBhMS0N670lye51mWzedzfE2x13UdJ5RigrynmHBKB4NB6JBEHqSUQggjlRCilT1gpMFhRjEleVForbWWGKPA7hXEy2qDMfbOCcaklHeObqlOYgyEMyq4Uspab7XebEprfNs3SBAWR03XFkVheo08nl8syk2FPBKUR0IwzA4ODgLf18HBQTBBJycnga7WI0AInZ+ft7K/dfvozTffRAidnJxgRpQ1mGHpTK8642zbtqqX8/m8bfs0TkIVNPA2IoRCzrbrZJJkeZ4zRoLbMhwOQ18OpXTXaxo6NwKMJhRLwt96Pp8HXvkkSQJHbpZl4/HYex8IBxFCZVmGWstisQiPOohK6KENqODlchnIweF6LG+4650XAM/ozO4awg9/lEjlJTmXf1QbFgrOGGPswTqHCCCKvgARftYB+J+/CLnq/WOEA2CpFWAMjNCYjfbGGCPTN4HVkhASRTFFBAAC/dwV0RlCsu+t9ZxF2riqaaRWcZK0bXtwcACMXKwWPI7iNAl0O0IwAEcQNkqncdLWTRgZeHZx4QCAgMeeYoSdKzfrvelEtQ1FEIwnQ5gh7L2XUmKKRJaUbWPBr1YrgrHqZbXerJdLrbX13hGkwVmKMCHGWq01xaTeVk6b8/NzsMY5E5hNCGaCx8vNWlvT9I3HngpqHWBKCFCK+O9/+/HP/v7n68VmcTHv+34wnjgUBj0gaxSjlGKyWCysNqruT+4/3ts7GI5HnVaO+HyQvf32N5wz6+3qdHGpnNXWgPMZTxIupqNxaCW7HuMLxlkmOCK47bsw2TkgjQBCUGyt1UGTMcZBc7z3xtmA3w6UhXGaIALFMNdaEoJu3Tmu2yr0oyICg1FBOUMEU85ClHu5mIdz7gDxoUnt/Px8u93GcVwUxXa7vW4OUc4Zf43gDZ9/Kmn0lFv7tYd4X+qcL0nNMMzAAvaYUooJUkoh8kXW7K+wSfxjuMd+x4UTEgGYaDAa7BvfeH04KgjFHqw0MpTRAuEgJzw0RkkpASCMJAhIqzwflGVprbXWt12XFQVgzAS34HkktDF114bAyTmnlIqiSAgxHA67rgujNbXWnFLs/LAo6rJKmBikWQiZxsORwLQoCuNsGGpaZHldVnvTWZj/OZvNZrPZ5eUlQggRAgh5gM4oYKQ3mjCqlEIIHe3vF3kWMe69dQDz9QYwGk8njJHHjx9fkYlgRCjnUSJ4lKe5auR//c//54e//YiQK6pOZbQzlmJitYnjOI7jy8vLvmpmw3HgEKWcKaNnB/u3X7s7nU4PDg4mk8luaoP3Hnkc+FaMMZxT761zLsTti8UiEGc+efIolD0RueJACHxO2+3We6+UCkz2YRerqopSGoLPALL13gfKsiiKvPehrIKuMbeBtx5fT3kJqaDwqMO05bZtg3kPZIWU0lDihhvFSfii5YQbhvGp5M1LRHf3yWff+kc1YwjIjoqZEGK9dd5cIQRv5rtuXs0/6gU9350ITW0IWw8UM8EiT7BF4JyZzaZvvHFvuZxTirEHh67c40DSIaUcDoc7Fyv88QgXnez3DvaV0Umeee+1NZSzKEkwJUFDAh0B5xysC4MSAgwtz/P7Dx/M9vcQQhFhMRdaa6MU84ghIqXsZK+bDqzz3ufDgXZ2sVgM0iwXMfGwuLjsuq6q6yTL8kFhvRMiJoRpZwHjTVuLYV5bhSnnhFtlKCac0TzNEMHj/Zlytg1db0WRxlFVVVKr3mrnnOplVzff+bM/35/tzS8u7t+/X1aVMjq4uM4Y1bfe6qra7u/vE0K0tsgho64yQEzwsKH0bScQGWfF4nzx4POH2vqq60OXWXiqANBrlQ2ywWAQwoGiyG7dunVydnrNZ6/Do8YYEPKr1ULKLs/T4bCQUiKEAhqUR4Jy1itpvYsSQSm2VoeWFGUkpqiTbds3i9UcUzQYFcbpwahoujpsBIHOu23b8/PzOI4PDg601t5bY8IY9eWOteum+r0kLv1SpuVrNLz+xnrRZ4zWyF+B3h0A5RwwXKHtnw2mnzr7n36JL1k3h1OEr3bgwSEKyHrUgyWEUOewgYcffv6Tv/3pcDAz2g0n02qz5YQKyjDDvVbpILVW215hSrZ1gxjFGGdF3nT1cDi0Ss3nF9P9vfni4rU7dwd5sVosOCJW6UREl+fzRFxxGgwGA2WNUqpXMh8NrTaml5xQlkQYY29dr6QmRClFHXLaaIQseCFEvS1jwQHAgsUMiygpy9IZmyeZUy5JMm+sQ7CtNhZDUqRKGaRMHqeYgHPWe99LFccppVT1MnjRLGLWe92rtmzzJK+7ejAaUoo71eWj4uHpo0a1URKNZ+O7d29PJhMhBPIeI+oQPHz4cFQMvAVtzbrcVk351ttvhwmi2AMhBKwLzPRlUxfDwWQ8YwjXdZkWqSeobesoTUIokbDYe0QQRghVTZllmXPGIxfmU4Q90WqTZVmg/N9sr3gAB4NByKgFk2iUjiJunLdWd53MsiSMw4iiJJjQEDFqrRmhTdOEjJSU8v79+7du3UrTlJBAge3W6/V6vf77v//7f//v/+9hvlPggr1pM+FaN57NKj3lEn+p9exRN1XGvwDM4L8IuH/useCpB4u8QwS0UZhS5IA++5VfSkW/8n3efGQ3ye9dmGsKFiGwHnmEKULgXfCyZocHjVSZdgiRvu+bvoEoNt4gTzjn2jitDRPCWFuMB53sCaOXi4vxeFzX9e3jW/PVcltXiDDnnAPfKknSDDSq63oyG3dNSy3Ok9Ro45QSQIRIZNdLq4o035loa7xxEAmGAWTXO3CCCQAAa9NIOOc8QJ4XQJAyZjAYblZrpZTTJjI83HWe5xaDNCZN01Jteq+ww33TYggkd6ht69l0mtNYyt4pY62TXR/o2L1HWqrtpiaCjhnLsgQqQ8Ftzy/KPLt157b33luwgALX+yjPrLUWATDU6G5dbkOSBod+S/DS6Luv35Va9X2fpBH1iLGR8YZFIsTJITmnteace+cBIOJis9lkWUIICfP7pLZpmraqAoc44V3XGaUtsVmWtW2bZQmxECQFISSlttZ7b7Mk75omFokxRksV5lMJIRDBhBCPHBMUvDPGIoQODw8xpiH/GRSPEHL33h1l5NX8BEyM87vBSE+pwVNO4k62X6RRNw/5shL+Eg3awYzd9Uhl+KJ37b0HBICcd0Ax9Q4c+vKUwU/lyp69pldfz/d40a5dJrzrMAAgBxgZ5wajoUhi4521drPZOOeW5SrK415JqVXo5S+b2ni3KbeT2dSCK0YDxljXdY9PnlDKxuPpeDwuy7Ku69FkHFqoojRR1kRJHMASSimAKz4LZ3SR53XbYkpD553xLgRaqpcIIR6JSAhGaUjkhrx03/cXF5flZuuM5YTKrs+yzIJ1yGkjCaMB0KO1tk478BjjyWQCgLMkR+D2xhMjJYAPA44IxnmWcc4JZ4jgXsnReMo5X203SZa++613/uqf//N/+df/CmPcNI0xjgChHsmqwRa895TiEGn/2XvvF2kmpQTvQy7RWisEQwgxQjllFF+1m7dtW23LkGk0UjFMjDGhwRBjvK3Kv/u7v3PgldFGadXL8IRDN1LXdXXbMsGH45GIIyHEYj4P3BEAUFUVAE6SJBhP71HolArzY0JDbOjbCmEwpTRN06ZpBoNBQKEEsQnzDhFCR0dHWZaFylmYvPaUr7uT26d+eHXhfCq9+mXXcw+/+evNYHNHW4289w55j7xDX5HY+093019lf7r5LSFV4Jx7//335/O5dleD3HcNjUqpMALIOQhMa6vVKonTzXprnEOEgMdRFNXbMqIstEcGkpEQrVHGHIIoi6RTaZGzSPReWfB5nrdVzSltqgohFDgmgz5IKQGjxWppvQ3/PPJxlhJGCWfj8Xg0GoUKXj4oMCEIY21cr03ILXNCcWDQwJgBNlJFgsWCHY6nxEPfdYv1qtWSchamoVHOOt1ZBIjTum2Usx6jN7/17p133o4mo3gyfuPdd+cXi7OHj1enFw8++P3933706QcfbldLbZXVMqIErMmTGDl/dnJa12VZbs7PTynG2HkKvq8rq7VDAAQnWZokSZ4WgkVWWtnIcrMFAACnrZJaHdw6/uDjT8qyxs57bT7/+JO+bZumObs4f3jyhAiWjYcGvPbOI+Aipph5CwRhQohzBiFvrVaqt1Z3XReKaiG2DLW05XIpRBxFScghRVF0cXGhlArUapvNJnB/hnoMvd4iAwXhiwTpuWr26pL8ci31L1jPPckXHMlr0/rcQ8Irz5lfetP+vuiCbt7h1x21Po/kIoAXvAOE9g/3CMOEkNDNCNiH8jpjLFA/eox61fWd9H2HCAksYev1WnWKMsw5M9ZmWbbZbDabkoywA88ZI4zKrkeMOudbLbngRFIpZZRGWZYtFqswgCR4fUVRdLIP3R5d1xFGMcZ93xfDQadkQAIDwPHx8Xq9Dm3lGONW9rPZvlmvMaOEEGNtL9u96cxbY6Xp6iZNU3C+6zoMkGVZVdfz+bwYDpCHru1ElDDGMh5fri6FYH3b7w+zLCsAI4sBIQTI3r1198n9h//jb/77t95+B5xLRHQ+XzSPHsQ0Ojo4DJD0Rw8fDidjMD7hcRali8vlZrkYjEfj6aTve6mb7XZ7fHzICFVKRVyEaLNt25D71dZMJhMHkBV5HieyapbzBUF4PBwFTavbhjDmnGORcNpQzlOE18tVmmdt2w4Gg77vw0CqruviOF6tVmFanLW2aRprbZKlNweiBRqHsEXmeb7dbiml+/v7WmvAfsd+FCgOdqSeN0X068r9wJ/cgvLyTQQAAJz3gNAXPvknzQK/6bh/XdlgDLBT1KduyFpLMD08Ptg/2p+fLw/2Dh89ejSZjbXWnEeEsDim1nqlJOW06zoeMWNMWZZt23vvI8aZEG3fchsTLkQUxXFMuXAEMcHrrtW9jBgP+5cxJtB2hGkOEWfgrDNWGS143Pey7VrnnJQyzfO279M4xpQ454yzlNGMZG3bbparSIhAh1d37Xy5SLMCE7LebDjnaZIQhE8ePb5963i93uRxAsZa5Lx3nPMIETEZ9ee9lv1gNN425fL0yWg4HGbF3mgSSpSy6vpNE40z770HTwkD5zab7ff/6T89PDgot3VWpDiNvLXC48effv6bv/u5c240namy/9afv1dV1Xq7ipMkz0aD4ZTGKRZJagwY29UdH3AEAAiSJDm/vKCUWu+sd8ZZpHWWJFqqed2kIh5OJxk4wMgaq5SKReTAOw9OaoSQ1bpvu9C7mxW5MSZ4qqGbNEjOgwcPjo6OvPehCPHpx5/NZrPpdOqsAfAIIaV0mqbW+lDI/e1vf/vtb7+X5zmgKySj1prSMBnsy3m2X2G9XFFf/r27Y3dB6VNpJwyhWgeAEbiQo0HP7y+9efCzuaWnjO3XbUsxgEPgkAePwDvkEXYAGBxBFBlwBn71k988+PQhxQIhJLXinEZRElCmlFIgIHXPOddWLdfrvb09pUye54uLy1b2ySC9c+e2t3ZxOR8OC05otdmO8sx7n0bxxemZoCxJMsF4W9UIIS5o2/dBDrKsoJTWdQsINX1nwAEA5TxkL2MheqUQIdZa5KHv+8D80vf9tq5m+3taa+NASql7GccxJYQTrJQ6efIYA753527MuLUWY9T3/XBYlGXpMbIIVIBDKgvet02f5pmnYL2z1mzq6r3vfnt2MAuI/89+//Fnn3z82t27WZZRT95+9x3lLPJY1+2Hv/pNtdoghEQSG2e3Tb13fKiNyYf5J599+v1/8r3Z4ZF1mjh/8uQRpiRKEyEE5eRysSCMzvb3dtXIuq5jEUVR9OTJk1u3bllrHUZVVWVJwilbLBbj8RiRq5ZR1ctys51MJqHrbTAYBFCEtbYoirZtQ7S5WCxCi4K1VogYAAKebL1eE4I4D+T3xHv/s5/9bG9v7+jowHtPGN6BkLS2Iff7rHB+BYv6bED73Hd360Unf65K767qKdf3pvxffRKw9a+gpS+6h6f2gJd8+NWv/tmrBI8dIACwYAkQ4glYNH8y/2//x/8YZCOrTa9kQMOEOUKMMSAQHCHjdNv32+02zwdFUWy3FWFYOpVlGae0Lsu7t+9QBNvV2kg1ngxl17fbSnDOCeWUESCEEA/WWtu2bSCqtOAppWVd5YPRutoaYxAhWZZVVRVwbQFQKhgL3Fw7ipYkS+u6ZlRUVYUAoigq0my1WowGw65vDXhnzOFwVm23aZo45wIGi3EipQTKPELr9RYwaqQUaZKPBlVVRZRfzi+sc1HM67Iq0iwVURIJB151fcojhnDXySIfVk2NEBJCyK7HGKdperFaxHkmvaWc1HWtZBcR4ZwxxL773rt3796z3nVd54jfluXhnVvaqpBcpZQ2VUsQDlWlOI20NYDxZrMhCFFMwqTwqqn39vZk13/68cd5mo3HY+VslMRwPbMwjJkCgJA9stZ//PHHd+7caZpmNBrVda16GUWcCW6t5jyilALgsizzPFdKRRH/9NNPD472w6AK7721V2SxcKPK8upa+lS66Etp6Ze1288NKq8TzgTAgbdX7yJi/ZfPHu3u/E83oa90b9dcjKGY5sBijGb7U8aItbZtu5AsDYysRVGERKL3XkoZit1JkvR9f3JywjnXys4vFmcnp3mSIYRW80Vdt5xzC/7y8rIoiiRLozhmkeiVlEaH8BJjnEQxQRgAVNeHUStd1yEPobi/Wq2Gw2FIKTGEvTYBGJzneQAwWWudsXmaMUoxQnmeB96GoijW240BnxV5nGeV7NJBEbJ8IaWg2h5ZTz3y2lCEMcaDLC83m3Kzvbi48NbmUTrMcpCOexJhjjVQIMSiUVYkiCaIj6LUdjJlIoliZ2yeZRFlqu1iwnTdgrFO6YP9fYpwJFgkGMH44f37/+O//c2T+w8zEec8xRZh4xhiYcJiGLUYYLecUC0VBlSX5XQ85pQN8iKJojATLOQLvvnNbx7tHzRlhbzvmjbQR4YRrKEbBiG0ozsK0KK2bZVSo9EoSRLOeZZlN6eVB5CwUuro6CjUfsOxwdQ/lYb503Ozu1+fmw16xXXz2Js/3HwdXQOwbl5AqHF8IS79Uvmum1fwRz/53M+84MDQj/eMU+2xR856R7BHFCVZ4nsUYGjee06ZMWZ+cTmeTjrVIQLOOUbp+clJlmV9r8JA+HK7HWVFVW27qiYOdXVDEQ6RzHg8LusqShOllNZKJLELo+kxXi6Xg7yw1nqrGWMeIwCPCMIW0jSuqqrrm7JiURQhb43SGFBdNyKOKCW9ck3XBjHCHpBHEeNd3UDsqrbpVy1PYuvM8uGju3fvgsAaY68RJ8w0jZMaYR8niVaac7a/txfAAzGhZ6v5NMn6bZ0mifN+Uy33ZrOIMfDeatN0LSMDjmkvFWGURJQA6vveWwsYx4x6Sjglnel5Ekkwq9XlP/3rvxqMh9baZr3drNeP7j/84Ne//fi3H45GQ5ZEdw4PLPKM8072GOPAo02AxFG0uDjnnM+GE4JI7zByiBBuvY/jFGPcVHUiEh4zzpuICCCYMWaUJowGAQ276maziaLk7t27gR+QU1ZkoW3NGme1NsFPAcBnZ2dXc9BjwTn3cKWicF2KfK4Q7lw/v+vbdFdDhnZEeU8J/4uywS+XZP8CFs9ndA/c9QzVp84TbsKHU12/Tp8948tzvF/q6r/2xRiRfR/jeH9/f3tZ684MJoW2VztxkiQUI+Q8JljEQmp1dHS0WCz29/eVUlpLIYSg1EUpBtRU9f5kksVJmFkUEG2AkUcQaqFJlDLGjNGccyEEpTREPghjZU3bdSKKZNcDwHgw9AiBdUkUU0/Wq9VsMjXglFJZlvW9TLKUYmKkcsYnUYyzbLPZeO9FlCCK66bZOzjYlGUxHgKnTmtECaUUPBoM87brKEJaKq0tEEwRFoTemh0opfq2B20HgyK793ooZlKMnHPRKCHgEcLYEuVtHkfr5QZjyPO8aSqACBPABGIslDZxKpBgg9GgM4oxMpxNBoPB4cHR3/7gBwmPBBPe+F/+9Bd7x/uXqyVhWFmDPT4cziLO6nW5vVi98/77WknjteuVQSTg5lUvQ7G3LEvVdkmSEM6iOEbYU0o3mw2mhHMeJlxMJhMpdegjrarqYG+/LEsAQMhTzjAmoYsNYxSaSKWUSRI9Kx4IoReJYWiR3f0c/Kw/2hnzZddXs3PPe+sL7z7nKp/y6XfL31jPvv6SC/pSCnzlTgP219eGPCCEjHGMMWk05cQj17RVVVUhD5ElcWB5JOTKugKA1ppz1nbNweF+01QhZ5MnqbLGITDOBpkIc42klFlaLOYro52zAIBHgzGntG87Qkia58ZZqZXWsiw3oW0qwNkDf3yWpGkUd02LPBDv0kjEgjGCHXhljceAEISZKAh5pfrwpaH1fLvezGZ754tLlsYO4PLy0jlXNXVrlCjSPtQArROUFUVBGVPWiCQG72PGR3kxygvd9UZpwRgFBMYj500nrfXa+c5aykTddFRECmDR1BIjFEe9c60xiNMA91d9/+nHn0SYOuM7azpwNEnuvP4Gj5O66QARpfSvfvFrp/TDTz5bPzlHjfz53/zwf/x//+Nvf/CT+YPTT37xW+ZwRCOi/I/+2w+aZXny+eOMxtSTPMqSKAWCESUiTYx32lpw7uzkpGva1WK9XZd5PjDGlWVZVVWSJKFkGqoyoa9w14weGgZ/+9vf3rSNzzq3z7Vm+Ho+w3Nl+E9fX8GpflHE6713CLtdv5oH6l+MkHruK19LUPpHb+n6A9dWHYGgVCmFMPLeG2MYI7qX+3t7dVtut1ulTJrGlFIP1lqDGWacKWuODw6Xm3VozrbMLtaLLMsGo+G2qqqmzuM4wO66rkPOB4BE3/cRpm1da6kCZ6y11mrtvccIFUUBiGitKaFd0wghYhE5Y6MkdnFite6N44wZY9q2LdvOIL+/v2+dllKmaYoBlWUZx3Fa5G3XbTYbb/xwODy5OG+6djwcml4qYxjBlIq67xgCzGgnFadINw1QUtV1lufOOQLYKIMBgfNCcC2V1jqJ4q5TPOJSKZ7ENBKNlBhjrVXTy729PYTxYrsF8BRh6gF57LRKomhzcvmb5TYbDorp+ODgoG9ludmqXnMqwCHn3Jtvvilifvv27eV8MX9ykRAesYQxZrHbLJY//dFPKCVW62kx/PR3H6V5dr/r9w4PMCW9lKrvR+PxtiqHw6G37uLs5L333rPWGu1W243sesJoURSXl5dCiMFgwBgL7cE7uhnGBACEfW29XoeBwl9KtII/vCO5DXv0jnTia1l/+qlelFJ9Yb30uQe85Dq+3s0pZFCwB7i2/dZahAgiBntABJIkqaqKgmBxeOhou93OZjPnbJqmZ5dnk+k4TVPvrbU2SmJCSKUqQoinuLeybOsky7Z1tb+/r4yWWmVxEpArjFLdqZxHSVI4a7VzlDMAiDhHHlarlfdoOptt64pyZowJQ0iaqrZaWmsjIhDG3jrVy+l42Bt9NSuFMh5xGgtu4/l8fu/evU8++zgrimE2klpZZWXdr+fr0SBXxmxWy+lkVC7XgzSRSrIscQAUk9PT072jw6YPpO8WEQQYKKd930VRhD2uuppzbgCA0sVmwyNRVnVRFHXbWWsfnZzGWSqiqOs6jhFSJsUMJKSECev7pt+s2ycff/Ywy7IkR43yreIxt1J94+23R4dTwM56N5iMb9++e/74dHOxitNId521LuLs9MmTyWBIGWcWulWJIl5S3vTtpq5m+3uyU3GShk66o8ND5DHB2GGdpilCSDCOCJ5MJgHNDwCBWVcpxQQPfmnwkpqmGQ6HOzlEz9QFd+ncpwQysKiECHZHq/0/J0x77npFlQ7R6XPmGr7EJfgKd/XVHsSNozAAIB9odKjW2jkXhuqBg67rAq2r9340Gm3LdZZldVMeHh1gjLVUZVkWRbbZbEJMsre3lyRRIFjo+74oiqZplFKBE0AIEaUJ4zyO4ygNXPJESh1+MM4ZZ0ej0d7enndOUMYIxYC893EcJ1HECJ1NpoHCJ7hq3nvwnmGSJAmLo+V2E+cZETzNMwd+Op0G8pGHDx/mWWaV7qp6tVhbrfcOD5S2o/1Z7wxOhEjjVsmyLA8ODryxbVVDEDXBHMWdklRwT7ByFgRb983lermuSk9xZxSLI2kNi5NWyzgvyrbhSYo43XSN8a53RlrTGSW15pxzTEZpLhArL1agzDDJIhbJTnHK2qpu2n5dboGRdDR48523k2HRKs2EEDxO0/TW0W1ORZHnYOx4MMzjpN6UoG0eJ/V6W67W1XIt6/7y4iKKIq01eC+E8Ma2bRtg1TfT9YEDKYoia3UACQbTJ6X8y7/8y9Cjt1PI3Q8vjzODDAVJCNmjr9GQ3pTzlzvVT7371Cdveuw+dPy6F89v/KPx51d27l/+aK7e9fjZ75JScs4xQQihQV5U27LelqEWIijTvUTOr1ar0OhkrR0Mc0LIZrm6fXzc1nUYGWSVFpgi54dFwTmfjsZhSsK63Cprmq413kVZ5gklEWeRKIaDKIp23cZt31VV1XVdqCUQQgjC1XbjrWGEKKUIRavtqunqvEitNtiDEKxXXQDuPD47oZwVw2Hf97du3So3G2d8LBLd9lYq1fXlevP44aPFxeVoNpXeprNpbU3VNt77OEmMMdj5hHKnpAWrka1UU8nGEq+xh5jbiEajghdplKd1XV9cXLSy3balI/7uN+7RmBGGHz1+QCkuhrnETic0ujNtEuRn6cp3LTba2TCJgxHOCevKmiPy8Qe/79suieMsy5xzSmvpjAbnCe6V1to2TRfGvTRtXwzHUhmMMUXYGcccng1GclOpbU0dmN7oTkeMI4SWy2VoB8cYc8oYoYQga7W1Wmt5eXn++PHj8OQDxPdHP/rR/v6+/+JEQ/9qU73R9WREjJ/uqf661quc7UUatAskr+JS+4UrfI7HezNTDM+Eo7t891PJ5a/ZeUAOABzCBBBc+b2OMWK19BhzIExwIYRWmnPe9I3xLo3iGIum76KIO2M5ZV1ZG2kSkTx++ChKYmu88W67LeNYyK63nZzkg+12mxY5YRgD2m63k9kUAMpyk4rYGIMNivNks9mEveFqq0ZIObtta57E1jkDnvKrOZkUY0ppEGXQNma8V2o9X4gkVr3ElPR9xzljhLaqF0k0mkzW63USxbmI14vler0WQty7d/fj+59N9vcw4xerFRe862SWxkpqBCCVJRR5D4QgLFhVbvJh4Si+WMwHw6HzqGkajuhmtbHavP/+++eXl3VdO7BN01RVAwAYkFG6rKvD48Nltd2cbW4dHikjLccIE6es7zuGmDPOe6CMY+wx4A9/9bvR6ejozi1jbF3XJ49PYx576xggjInAtFfGgQPnSZyotlFGUsGxdfW2arZllERSKsRIGsW//c1v7ty503VN3Ta9VoPhECGUDwda681mEwb2pGk6nk4CzwMh5OLiom3bt956azQaXXeuOQDwN3KaCPldjvdZaXQ3RuaiG+PYvk6h/TLL30iAwQ0Nuqr6QqjGAA49ebtjnrriMFvO30DrX/WPP28w65e6292Hn19Z8l8w+hY8AGDwBAGyBiHkPfKE9kqWzSYbJA4BYXS9WZZt6TGilM7n84hwbhE0ehLl46QIeL2Tk5PQyFJva4qudClNU9l284tFxPh0NKbgreyTSBirwNu2rc8Wl8AIi4T1TmrLRIwo8QQrQUqvegbztoQ4sggjIF5bY0yRJRFlxIPrVcbEOMl9p3LGdNOkSSRllw6z8f6kaqvJ3ihOk4uLMwCHKAoM+rODQ+/QyeMT06nD6T4nnEdCOdt6s9ENnqRkr0iOJzgX267xFDeqP11cOoo7p5erNXhkrdfWz/YOKGbvf/N95FCzqU8fnsQiWS3WXd09efhEdur3H/6eOFREBcHcYeZ4pAnxmEjrFEDjNEQUx8wDGGmYgvpk/dlPPvj0p7+7+P1jYTDziAM2rWKeuF5h42IaMSbqumaMUaDdpgHpIsSpxVpq5PByvkxEzBG9fHxWr8p+07SL8rOPPj0/vWjKquu6iHMtJcK+6erxdDQcD7xHH3zw0Weffaa13tubhjnUAC7MxXUOnAOECKU82I+b7uJNRs+dcu5k7+sN325qHbqBT0CIAODwz3uEEEGIhB+8R+H6rfXGuKuBhB52yS1/Pfv3hdmjmwYz/H+zafXrcuhfdNvYO4fAA959jTMKE+wxRoho5Rzgg4M9imknW2l0mmWM86ZtkyTZPzyoyupwMtuuNxiTpm1nk8m2qSeTCUKI5UwIUVfbIhsIwQGg77cxF6vVajKZIHCjYsAIXV3OIy76XmMmKGebzXY6HDEmmqaRfWcwYPC9M1jZfDio+y5l3HbaOBdxCiHVQWgmYqWUVWqQZh7j2Wi87du6rkb9ILRcI4T292ZaKmV0mqad7977s29fXl5yzvN80LY9YZQwHkXRo0cPkiQppuPz1dw4uz/ba6s6jzPGedU2w9nkYr7M41FOqNYaeRIl8WcP7jvnzi8urjFY2Wazmc32rdKMDd96661PPvmkqVomaLUtk0GuraGMe4KAo3VVMcYuV8s0SYZp3jZNEedWacaY46CMHA7HgeabCRRxYVSPKTPGiCT2iHVdxyjlnButryZTdG2S5m/ee7NRbVmWaZz0dXd4eCCt0eCUs3VdG2OQ85gAQigdZIwxIBiDC2d44403Atd+ICv06Asi+qxE3bQB/gVjeL9a+eS5QrtzpMP33oh7/XP15anr3H0GIQQIYfAuBKTIY3dja3l5/nbn1n/Zu3rRCV89KggQjMAYEIw5xng6nVrvrHMWfC/laDrBjPIsabRcbTaEs9YolsZ114ZRQmmaeueEEKG5cW9vDyFkrb08vxCMZ0l6/fRx18mu6wIZLwBEUeSMNVovFguttbZWxHHTNFpbhEigMrLWX8yXSTHgSdwquW1ayhmmRGsthMhEHEwrBkQBpTzaXKxSGhc8BW2ttbfv3LLWYkr+yf/1nzZNc+fOHSHE48eP0zSt23a1Wd9/9DDJs1b2zkEeJZNssDlfpjxp29ZjhCmRRhfj4boqy75N8qy3cnq0t3e0Z7E7X196jtJxPj3aS/OECYoZxhg/fPDAWGX6jmKipUyF8NrM53MDXiGfT0bFcBCYoqRW3nvCaJSnNGZMUMJZ27beuQCELOuKCQEAISOwXq+jJEaMYE4hYkgwTEnEBXZ+cXHede2yXGNBh/tTQ9DFalHVdVvVjPA4irRSbd3NL5exSACwVlegoj//8z8HACGEcy6kA27Kz01t3InNU2mYr0Vun4oBb17AznTv9o6QrHrq2JvXufskegYb+IVbw+gLU4afuzk99fqLDOnX9iBCXIH+YEuxx8iD18pj5BnyHjEUN4vqP/2//4MzvkeOUDqZjpq2jdLEORdRwgg1SqVxQhHWWq+2GyI4Y6KTPQR4NyZtXTJCi6IYjYbr9VobGccxxjhiHDk7HgznZ+dMiGQ86LrOSEUIGRQjZbQxppbdo4uL8WyKPSRRvFgsEi681OD88e2jvm/bsurb7nB2QAix2gBGnuC274jgAIApmc/nnLJ8UHQhoDDu7OwsFom1VmnNIhGgiOPZ2IFv2nq5XOZ5OhqN2rpK49g7RAjplFxt1sVoaMF7QhljCOGH9x/cOjzaLFffeO31k5OTJEtDn2fXdVVVHe4fXZ6d912XREII0TRNmmdt307396RWlNLtdhtxYXs1LgYCEWQcBZREcde2cRxbqwEA4zA+C4zSQsQR413XSClZJKIo0lZZ7wBjj0BLhRAqsqxtW+QhKhIXU8fg4YPHGOPBeEQpnY0n8/l8s14TQrIsi9MoShNP8KYq9w9mBOEwgu0pDQmAs92LO5ncwRbgi9r7VBrlT5TSZ6V9Z0LhWmm994QQ7/9gJ3dXtYMcP3U9CCFwFiEE2H9B/p+aBf6sEr6ih/CPoqUIkMdBS4l3iBILVlnnNSKK/H/+n/+vhGdYMGmN9YZwNh2Ny7LsdT8sClW3k9G467osTozSyuhW9kmWSq3bth0PhwRhjDEjOFThouiKK9QoPS4G1bYMPR804YARQ0xKOZiM2rbV2mJKP33ycLI3c9qC83VdY0CzYnh2fspjPhwO8yQlhBgl26bJ4iTA90KOg3PuESxWK8AEUxLnSdnUaZSWZemtb9uWMNp0HaUUMZIPBvmgsOC22+2du7c4oY8ePaKYKKWK4cAhODs/r9sOMToYj7z3URQh51XdRpQh46q2AU4pZwHC7pwbDUYPPr9PKWWYaKmSNA7aCxgVRbZ3eIAo69vOS72dL9+4dYcC9loxhOu6LopiR9vDOW/rJk1TpVTbd2G8UlB7IZj1LkqStm072XvvB3khpZRdN96bnFTzydGMi7ht282m7Pve9toofe+114Z5EaUJ5XRVbicHU21NMcwZoUpdGc9Ad6a1RghZ726GmjcF/aZBu37s/ll9fq60/9H1XDn33gcuEXw9JuMP8nzj/Dvs7i5R9JSiIoQwEIT8U1bq6bj02YtGNwrHXy3m/moL+9C95kKKy2OkpDTeUBFhRr1z737r3U8++IQRHzFR9pIDX69WQoh2WRVJqpQKTDyrxfJ4/8AYk0TxpqkIJQd7e1oqSlDEeZZlFxcXcRw7ayghRmlwvqlqQRkQ6gFYlDRdbZFFBDsE27qKRALgKSYME0fQ2eVZKF3wNL73jW9s6/Lk4my2vxfH8WCQoURgD7rtGaW2VwwTpRQieDQaaeuU0VmaUkopZrLreSq8923bckoJY0zw2WTiMALkB3fuOGfKpvyrv/qrjz74cL1eSymL0XA6nYquZ4I/Pj3ZPzxQSjVltTeeVOutU9paK1V7dHysjHHOFUXRdA1mdDAaYYS2640DzyPhqnI0GErZbcuyN/b4+BhpyzBpui6ibJxlTpvQFRh0IJSCkyShlGpruBDau7quYmswACHEKltvtoDRZDQO4x6Z4MYYafR3v/vdZJRp4xAixpj1cn002//dr35bbcp22xhkPcCffe87URoDRtabrmtC+667XiEYuenQPqUJcEPod4nPp1xK+PrsSjhP3/ehYrcLD+GGZ/uU4tzcMm5+5votD4BDaias56Dt4ct7CK9yw8/dw5490CP8XFIV5xxlDHmECbHWRCLGDHNOCcJtUw2HA2V0JLgz+s+/+R4BdOlRzIWRCmMSM957YBgRQnrdt2U5GgwZI966rqnzNCnLMooipWWWZbLrvCdEUCl7B9b3WLCo73vK2WKxEFGEEQ4MKZTSqiqbqj64ddR0bVnWQrDbd2+fLi5r1Q9mk8/OTw/39tuu5THTxtGIS2nyPGs6abQ9PTt/8+03dS/X61XMRZ7GbdvPJmOZZl3X8TiaHuxfLuYeARUscF5aa08ePLn/6X2EUNN3+9omWUaQLDfb0Wi0nC+M04zQVbmOIy7ypKvq99/81na7Xc9PBuNRudl6BJPJJI5j2fecc07oYrE42NtXSt27+3o+Gn7w+SerzTrhQnuLMBZxpIwGY+M4vqI4RjhOM611WqSbzYZSGucZIrjte9l1SZpW5TYTccQjpXWz3hpwSZHzOKI8Or59VOTDtm0Zj1abTcyjvup++vGPL8/Oj4+PgWDk9XR/L04T4y1YAPCh5ymQbnvvnzx5EqdJnucI/qClLzeJL9LnV7Sir+hLCiECXmJnJ18UP940e7u65i7t5L/w8SsTheq2evY+v5Qn8Ip70otO+MzhOy111zhBCgAo1MeQ084TIMSzj37+u/sf3U9EXNd1nBeEIoRQwoRsuziOt3UlGOeYjPIiYI8MeOMtpkQIAc5iAM45p6xt26ADgUnAe8+Aeue8sTyOeqdYHCmlHPjOaio4cVhqFWXp2dnZsBjO53MWC+t9ng+Wy/nB0SGi2IGdz+ehmWZQZOV605bV4WyfYybbLhaJ915JrY2KIk4ppTi0a2Dvfd/LMBvSgQdGlDGIIERwURQIoV/96lcHBwfW2tV2471HBGdFcblaKGOyIleqD5RO+3t7fdMaqVIeEUI8Agt+OJpgSrabMooiSkiapiePn9Tb8t2331lvVnmeN7KXyLVtq7s+FzFIMy2G2/m8SNJBmhml0zTFHqy1VPBAXNQr2RttEcRpkiXp6aPH06IoV2uBqXGWJ3EISTqjnIXBqHjz3W9ESbQut1EUl+vyN7/6dSZSb50yMhsNLPF/9r3vGGRD72GYdBjc3T9IC0Y3ndhnBexFiaWn3F14hXrMc+PP574OVyLrdnY7KOFN2/7cbrWbF4wQekr+EULY0yst/brWlzWqzzsEwxWdyrXF9xR5jzx4bz1ylHJrvbewOV3+/Ce/TFhslCJCWGuIhySKqYOu6zBnlNKIMrCuqiplzWAy7pX01mEMGCCNE0EZY2y73Ybe4uDRaaUwEIYJBlS3jaPQqH4ymSBGt12DKMHOt10nkrSqa045AFSy62Rvra+7+vbdO2menjx+MhqNqmq7t7fXNM1kMlmtVtYYBvTNu/cefX5/EKegXRwJRMAY5RwghEKXbNN0hJC265q+I4wqo4/v3imbGmNsnRuOR1Twi4uLMOWhKAoRR48ePaq7GhPSdR2mpCiKPM+rbblard55+21CSNer+Xye5UWAFnHOkUPg/Oeffz4ZD+M4DoxNUinlTZIk927f+fzjT6n1e5NpgiixPouEwLRvu8Fg0DRNryThjHPuwEuleBpLrTFAWzdI25RHESXee+X8yeV5NihYEjHGpNbOm9FkqLXebiqCMUXUGRtFERKEZWL/tVtxkVhkCUHOakKId8ijpw3as9p1Uxv/qPg9G68+1x19yhd9RfG+eZKgsc81qiF22OnwrnriPXqO/L9IS7+sdf2yN/DiA6+0FJDzV7B7jBxihDqrjbWAPQDmNNatfvTJg9XFEiFkvOvqhmNCPMEeKKWIEq01cp4SQil13lsMdV0j74ZFwSkD66wxnHNn7KbchgkL1lrZ9YKKvu28sSKJt321f3y02Ww8waJICaVd23rvO20AADnwCElvl+uV8YApGk1GCCEMqG87D1ZKKZWazKZJkuR5vp6vddcfTmbteiuAemc5p0IwANw3LUKIc661NcaEx4IZldY0XesRjCYTB14pFcpLABAqRk3bEkat1WmRY0qo4FEcO/BCiM1mY60dj8cPHz42xlxezMfj8aAoEEIUs77v9ybTy8vLB48fCCHG08lytcoGeSyE1cZbp9punBUp5SDN3mioms5bJxjzCIVcdzYomOCb7VY7m+aZt45h4rRxUlstEUKIcWk0ZrTrOowxjyOlFIBr2z4REXh/xSSYJwrc8Gi6//oxT7g0EjkL3hFCvMM3tfS5QviUoH4p2ftS2aOXnPym5sMXq6DPvfhdwAw3Ng64QkEA8u4L8v8SLYUv2vevS0ufvdwvvnlDS5F3gAAwDpjjAP+6QpgQMHh9ucxE/POf/7Jq6jzNqAPda8aYEKJvOwCo6zZJEgwoz3NpdVmWt/f3N6tlliSCcXDee++0cQicg5CTwBhTRLumDa/zNHYIsiyRzihwUZo0ZZVlWSN7aTRF1CHAQqw26yTPTs/P8jSN43iz2WgpnXPD8bisq6qpOed37twpV5uIskGcuk4KwgZpZq22WoLHBGOEUOiTY4Qa4yilbdcxwZU12jsHVms9yoZhUmv4cNO1k9l4U5Usjsq6qvuumIyiNNHe1V1bVdV4MN6f7S0uLxeLRURF37TI4yLNtpvNeDgijBpjHFgeRZty6zHiEUcILS7ngzwH55G2h+Op61QRJQkXFJNyvQnk3ZxT4x3G2HrHhdBaJ0nStW2apt66KIq6rivrCgAYY946sA4I5pGQUmJE62prlU6LnHIivRXD9Bvvv6uZV05TTpzVghClFEbsBrblj8jSy+XwVRTy5VHoq5z8pk7urDE8D5Jw0zO/8TECABj8Tfn/x7WlL/H7X6yooQnGPaulBIPz3iMXQgzimVWBNg76vl8v108+fyBbSSn1Ds1G47IstbZlWR7s7WOMeyXBWTBaMJ4lCSO0a1rkPOdcWRPqWmFvS0Qiu173UgjhBQWElO55EmvkEcHIQ902UZZijJUyTd8p73kar1YrQnAsxGg0uri4IIRsyjJJkiRJFqvlarHKsrRIUqs0RfjNe6+bXqq2pYBiwRAQrVRgaQLnu7rR2hZFoZRyCEQUNapXRkb8/1/eezbLliSHYZlZ5ph21z47b/ysGwJYECABEUsDAiApkRH6nYpQhCIoE5JC/MAg5QgFQYngLtbN7I577rp2x1VVpj5U97nndvft19e8WUDKeDHT3bdOVp2q9FWVmShQTVUDgDJaKYVaTYopaYWK0Ojz2QS0yob9F69fgSJSSinTy/KTV6+yJH3xzYvUWBQS53tZXs2L/mgoyEVVJlk2nc+evvvs4uw05qe31vaTbNQfcFnvD0ZQO41kgGaz2eHhYVGVIqFyDSLmed7r9WbF3FpbVVWSJLK8zzmZTKwxCinRxjfOey9as4h3LjXaew8KVJZAQh//1vcx00GLEw8ACKzintyma1vXEdJ1dLiR3jY+uKIMdxcBItKxWi+9aLy6RXLds5f/ZQXILZcKEsDOZ4luZBisP7L7RK+HdyWGujpXGZYJS0VnBi1Nq9lf/uX/gwh/8A//6J1P3j+5OJ1X8/NiMjwcxSrUQFI1ZZ4mmlTMYBbDldbarN+blQUAJIlBBTGnbtNUxqjhcJjkmavqpq4JFDsW5xNlQMJo0PeuFgjj8TkR1E31zTdfz2bT4XBYl9XJq5dNU6FSsWoGAOYm3euNpGj+7b/617OLqTHmF59/xgnNfA1aNZ4dB20MEsWEg0opqxV7lxgNwddVkWrVs6kCbOpSaVQaRQIAN0016vWJJdSums1TIdWE0y++ebZ/fKAzLBvyfnx++uTJkyRLf/i3f3jw8Ojw0dH+8UHDjVgcz8fPT14Wrhod7Q/2hmdnpyDoKvfg6PhwuCc+sPMxN2ft3YvXr8AoZfS8LJRS1qYkxMwxobbVxjdOay0AXpgRYqGQeN0s1psZDoex2OTBwR4oEg01OK/4O7/zqSREiaqdQ8R4jb67fYIdWCWPqxrpOrhOi7zxweue3dhMrs9SvyPOzmWYJau3Md57gY0O/UYHHa43Jxg0AXd1qQChEC0tXiQBRC8sXhCVIBKACvJXP/nZZD773d/9va8+//WXv/pCKfPw8Hg+nrHzTdNoUkd7++PziySzSikUUIh1WaU2iZG3JEsnk4kxSdM0vnG9NLM6KYoiydJpMTfG+BBEgzLaGOWFawn94eD8bDyZz4ZHR7VrTs7OBMLTR49fvnzZHw1PTk9HowMRAcbzVyeHo73Z+dh7//4H715Mx7V3tpccjfZNHRKlF2KHKJZ+hsCaVFNVAMAALvj+aJFNvyrK4+NjzwERnfd5np+cnyGiTZPG++ipoiIXfAgh6eUTV+ksOT8bD0bDWAkSAGezGftwsDcCgDRNPXNZlrGSUjyn0cvS+XS21x/4xu0Nh+V0bkjNplPxAViePnkS051Zax07Zt4bDEGR955BPEiapvP5HFnqqjJKiw+LCi6EpJU2xjVNCI6V1OI/+e1P01EelFTe5b00FnTvpVlMvIiK4A0u0hVyupFfuoWGuzHh62h44+Mr5/uv63pFn7eYXUACJhAkibpUtli8G0d/O9f0ujDaxscXXAo+hrsuuRQAhRGAIQABkELGGDfSSMhCQmcXF8pYEJpNp9XF7IvPf5XpVAGiUG6TXFvvfdGUDLI3HAFzMZvneR6cV0o13qEirWxZFAoJWVzdKKWqxsWMWEVdoUaTJtZqVFRL8Cjj8Tjr9cQYz2E8m379zTfvf/jBZHKRZb26rrOkVxVlXdQJ2WGvH5q6KAohGR3uzZtqXhcfvvve9PnrUdpDEURMbZIaq5FC49gHiHtuRLNinvZyQUjTFFjquhYErXXjHBkda0/peLrde/FhVha9Xq+u62zQH8+nmNqYT7Rm//jJk6px4+k0yzJN1Mvy8fj8YH//5cuXIQSrtCYzG0+zJJXAx/sH/Sy/ODsnIqNVLP3oqzpPsyxNY+FWZVU8CZjnee0apfVkPuv1euJDYq1F1VS156ATC6hqbpRSiFIVRdpLL2bTo3cevff9j1hDQAjiOQRDimhROCsmJd5IzesEtp0It9PeRmpcYdHt+NvGKwGhrsXbxXDdMDxTq6WAlvS/C5e+kcG2jB525tLYhoEIYMGlgDHGBS2XIrJ4ARDC+LeIiuJFQ0ZUFBgmF9PDwej05asvfvWF+IAerNKpMk3TeMVnF+ej3iBP8pjUSyGJiAu+qb0xhkNIjFWAdRkTxqaCMJlMDo6PLqYXB8dHJyevkn5+PhnvHx2maToej5lUfzggpRzwy7NXpFRRVMaYw/2jb776Rryg50FvOBmfAwBpRKsYBA2Nen2ZVUfDPQIEZoWkAAkxVmoDFgkBEaumSbKUFTZNE3OOjMfj3qBf1XVMCnFxcbG3twcA3jljDAEyCLDU3pFNSt8E4cq7fNSrvJuWVdbLo+ZMrG7KKktSEsjz/Feff45CibaJsXme97P87OSUmRNrTCz9QkoRlbN5lqRVWYoIGQKANElkebcxzTJmJkQUSJUpyxIRTWI9YBWc9w2QADArzEf9Tz79rqSqYi/ISikNGEIgUEC43MYI24lzd9exbX+dYtwYfFlRqlu4dF3xbtyJWYnLrogAQRVJXSBcxnh3yW1/Fy5dGcf64DY+uHQ+r7jjuNwmls5ldADATsYJjvdRUXMIVpvJ+cVsOo21CScXYxFJe/3pZJIqMz0fl9N5qpJ+nmtlEdGYZDaZImIxGY8GQ980iEjaxtpqoAgUOGCdJo13WZY1TdNP87osg0i87jipy8H+gAmz/uDHP/nJgwePnPPnp2cQWJNpqmI4HM5mU2PM8aOHQXxT1WE+Pxzu5TYPziWkjTGz6TTLMmBJjWUv7DwiOg5VcFmeE4pzbjweHxwcxKkwpIjIcQCAWEYFAtTeZTYpm7pyzoVAWiV5xiSeGRWUZSmEdV3vD/c1qel0Wpdlr9czqKZnY2NMfzhArZQiEYk6M7HW+ybmHOznPaXU+cl57V1AODg4EOdzkygCdl5Z5ZxTRjdVbZUFjhXpApFyEJrQoKXSVzbP/tbv/Y7OLRh0wQsJxsqLgDGoKyKMoOAGh1J3sXtvEWHpwhZl3gaQuicZdolmvbGjm1m8W7Dfjkt398vjh/YwR3vlFxgRkZfZBpfhJRQRrXXc97NaA4BvHIM0ntn58cnF5OQs1I4bn9lsfD55+PBhUzaIOJ/ODAIBWq3nZYlK54M+Oz+Zz/JBXgWn0yQQAIBFlSg9uRgrQDLapsm0LCjToNW8qGrvkiwXkTzr/af/+JcAMOj1NFGSJMPh8OXLl4+fPprPZhj8fn+Y6lQTlZMZACRJEgtqKCJpGAAkMGlVB09EZV2kacoh9Hq9cl4AQGpsXddkFnmhiqIYDEYiEjMMG5s0cQOWJOtlk/lsNBq8Pj2JZTuSJAshaNIi4qqaAPs2DSGQ1R5kNptmWZZYqwBFglJqXpXxJmAIgR3rxKLRVVVx4473DmbT8ag/ePXqRZZljJDmmW+C1lqj9t4HFxj4xfikv9/rH+y9/8mHyTCrg0cT9xWFmeMd6MilMQGAgjsx1Qrh3R2u49KuQxtV6E2vea7o2Cv47yt6tF16bWHyHQN02NkjbiUWEaEQIgbhzu8elsaJJoOIsV6wQgwheGYCyE02Pr84ef56djFRSBJgOp0i42wyPRjtVWVptTGkTJq8PHn95MkT75xzzocARvX3RqeTi6qq+lmeasvepzZm2aryQT6t57Vrsqw32Budnpy74GPeytPTUyKKF5r7vSxmzY4FizSSbwL4cHR05Oom1s+dz+fD4XA2nqVpSoCNd44DEmmllFIQvHMOAZIkiTVsGucAIN65ibJMa+3qhj0bY0IIpAkVNcEnmT0fj2N9+4Wd7DnmjhJmVzXMzCh104iINSYhHdMOxUuwZVkOen0OwddNnucNB7Q6bmgpAlc3CtAYU9QVgyCR46BRK6XK2TzrpXOuwdKzD98f7A3ZokkT5+sAIerMGEVDxHikEeBSl94Xm70lXRrFYtM0ImKMSdM03uDZrtVWlP9Gkxveaoy3fYGVP93UkYDO6Nv/hhCcc0SkySilGKQzIwtlG0JQqAGAfQAATSQiQSQxxtWNVbap6udfvxifnfvGk9B8Mk10ggKJNiJSV1Wv33fAWZbNzsfx/KBKrQdBq2O2WHAhUZp9yJM0OBZk1MqFxig7mUyyvB/jWzFffn84iBst7N1oNGIfiKjxdZKl3PBkMjnY22s9n5iXoK5cLDPjheM9GAX4+PFjHxoA6Pf74/F4Mpk8fPhQEJumYYamaVJjY9p4o7VFpYgA4Oz8fDAaImLtF8GnyMnGmPHFFBH39vZev3o1yHtpmjGKc058MEpzCNZaH4IgFE0NijKbEKKblzHJU1GWpBUROVcbrWPhU2vtZDZlQiAsi/rhw4eTs/PesHfhpu989N7Td94JxI2Ehp02JCIrXAoADMIYT+BsIJubwrUMcHO0q4pueQW8KIqqqhAxSZKYCfG6TtfHs50LviUuhTXh8cYHVxp0uRQAqqoqioKIEpMmSaI1iQhfrXjaWr+LtRciIkDmeJLeps45FJqcjsfnF+K5ms1DHRTgbDYb9Pp1UTfB7x0dnpyd9tNkPp0Nh8MgPJ7PPMqjR0+01pPTc4NkgIL3VieoQCkFwOzjISLRWgcGBkGjy6aezWZ5nuepBRaN5L1nJWR0rH00n5X7o1FZlv28982L57Vzx8fHQfjVyetnz54xc1WUCnVTVr3hYFbM67rOerlb7klmWeacq+taQtBaZ0mKAqM0b+rywYMHRVmen49jysXKNTG/6cuXz4no+Pg47iGTAAp555Ikcc4l2sRDv5V3pW9Yk8qSaVnM5/O90SgR5evaCioC57k/GgJAXdeKIeahr5qakT0HkyTGGN80la+fff+DvQcHXhgVMSGQiARCbLkUYbGKDKtRVrzzxcl7UcjrKqdVpG1hiyj+urkadse5DvdZJ+PWU7BlW2kjMHPTNMUSnHNtIK77eEzxhIgx01qI91yCIwKd2IadKCKrXl2cXEwnNkuDyDvPng3394wxgmCzNO/3ohvsONheVgWnEvvg0cMHDx40TfPrzz6XwACQJEme59oYEQnO12WVGmtIZdpapQnRKC3Oa8Cj/YPMJgSoALVSWqlUm4R0U1Yi8uzp07IsE2OZ+ejg8J0nT2bFXBCevf8eahX5CgD29vbmZdF4N9jfm9TlrKl0Pxs+OKwg1BJq9mm/NxiNPIhObSVOjPrsqy/OZxPUSifWC2ut8yQVHw5GB4ejPXFexXv2LAbJkBIfkAUF2IfZZDqbTpVS+4cHab93OrmgxFSueTU+zwa94f6e8x4UVVUVk+4kWeZ9UEprUiRQlxUiTmZj0Hj8zsODh4eiyaQJkwBJG2hYKNLu3ZerJHHvDLb+9S6AnbusbdKj3ce8Tr1duOdqNuvQ9Ujvy7UAgPb8UAiudURX+r3MfggiCKhAlovdOKeMZsKG/fuffPThdz/SVsdC8f1+P8/7xawk0poUe5+lNsuywHz86OG0KoQwSRIF8uDo8P13341nbkmZxrskTYEwSZLJfKasIa2EMATH4o1RWZbUTcnio49njFFKSeC4B5Mae3F2mlrDzruqnk+mCilL0uFwmCRJos3D4we+cYlRjavyPNfWzptqeHTwzkfvz31j+r1K2BMqayez+evT0xD4fDyeNmVNIVglRg2PDoqmFqUAqfFhPp9LYIXa1Q2wJGSRpZwXWZIiYq/X895rJFfVw17fkPris1+9+OKrZw8fz84nxWT+9PHjuq5//vlngWBeFFVdz6fzYl7Oimo6n71+/bqp69C4Ua8vrsmzxGbm+MlDDwIkPjQCAVGcqxNrW8LofsDFXttmuCktrZPHXVh03TCMyjNGRtr03LfoYiObfBs313ac0PbN15FI55AkIjJz9MeMMUbpfr+fpiksbaS2u9ZTbWNuIQRFICIs6IWVthKYhELjjMeL16fTk0lTlJOLKSImOknyzPsGFZDRJ+dnaS8/enBc17VvXGhcaBwE8I0j0jH1NgAbUjHuzMwABEs94IXjudxY5wIAMpvMZzOtKYSwf3gwmc2MMVVV5UlOiM77JviGQ2/Qr11TFIVBZWL6VUQgVQY3LucX8+ne0eF0PlOoRGSU9+fTmRKIe61NcFVT7h2MmsoN+4M8yafnF4ZML8+j2qzLSmsVvNeaUmPj/nDlmljCPDXWOZfahLRyHCi107qc1xUAeu8T0o2r9/b2EKWpXF2UBPTw4UMRTIyano/7g554V7nK9JOg4IMffNcO0qAkCDNyTAWotT49PT3aP1h4JR1zV2ixE96lovu1eLf4jVvg0pPqeHOtdxqLXMQYXsz3fR0S6JgJG2m+/fy2dCl2AJYv9gYXedl4XbJGiEZ/xJPnedwSiAJsY3creBZ3cEFxAIiJP0KApf0cUzZ/8803VVVpJKtscKGYzhAxFqqI0nE2m2lS3vter5fluSDaNCGNqIBFYsFiJ5z0crA6KAGDHqX0DRHFgjHIYpW21tbexUuweb93Ph5XTV07nyRZHG1808Fg4Jyz1j569KjN1lG7xnNwHGI+4cnFZG+4d3RwWBXlZDIpimIymyZZWjQ1IGaD/qyqk15/Mi+cSH9vj5IElK4Dk02YlE1TYxMWLOpGlC6aWggnVaGypCZJBr2afdzgqaZzcrKf9kc2G5o01M3jowcxUp2m6XA4fPTo0Xw6PXn1opjNAWA2nsyrcjydTGez/QdHNrceAgAgigJk54vp7N/97//H6avXMQjfsiisWbm78NIbjbWVEMkuIGvQRbXyNa5avKgsy/2YXUa7hUVjm12925uCbNomvQXg1V0cEYlnx7TWsaKE1Yvb27FXWJvBlRg3MzMIIBIiEcYcZWJDmDfPnz/XpM7OztDT8eERAydJQkSnp6fGGFd6XzdE9Mtf/1wpFUZ7aZr2hwPnnARWSqFVAGKMql1oJIBWvX4vhNA36WwyYR9SY0XpqEsTpRHROZfmqXMu6+WpCDMorYkhnk2PofwQQjWrR4Nhv9+fz+dkTWZ1w9LPkib4yXxmgBLS88m0n2QK8Xw2Ozo6arzzHAaDPVBATRWEhfB8fIECx3tHQMQg37x6abVJJG0kRBEmElxw7MVm6byulFLlZNxPs7w/8GOOlOXqxlo7ODjIkrSqapZwNhkP8oFWqiqKPM/3hqNiPsvylNl78KnO01HvyfvvNIo9BwWyNDRgMBh8+P4HWZYhXrno3WYVkWWl3fWI6L14T29Egls3ETdi2xIl3QU2vtrbtXhvZOu2j1wnsQAg1uECAGvtSv61ldlZ4dIOfiUiQoKIHICIFGKow/T1xU9//BOspZ/lk9MpO7+/fyDCaS8N4gOIUoqUilWGjo6OnHNJlk7mRS/NJLBCMkh1USqrbJoEkLJaZBWNh5BjxAhEoplHStXeIaLWuvFOa+1CCCGk1nrvfeOIKMlSBgDC6XT69OnT89MzIAzCdfCMMCvmRieDwcA5/+LFi/39/bqszs/P4y7L6PDgu9/9rklsYP/n/+e/y/O8KIq6qPI0i8e69ocj7z2HgCzHx8fj84umabxvDkd73vuaXZKlSqnJxXiU96uyzJPUGNMEP6+rpnG9Xm8ymewPR9boqqriMQyNqi6rPEtjYk4yVIGDVP3uH/5tsVQ0lc1saJxROqoaY4xrmridu86i3bp7K6u8mZTfZBLfV1hkY4z3HpGva6b7r4W8XZXfHdpTHbhM5C2dej7rPa4Mqf26MGCYJTAAq0R9/fwbj6E3HJBVoNW8KgJI1dSDwSAWC+cQsjR99PDhyevXWuvz8/Msy2KKd4WokeazGQDEIqhEFHNSImJVVbPZrCzL+Kc2RzsiMkjculSIeZrGV7Bpsn94QFpbawHg+PAoFh1XSilrYn7aJEmyLHv58uWrFy9d3fz8J3/1/Ouvv/Pxx66shsNham0I4ezs7MU3z//gD/7g008/3dvby/N8Op8dHh/My9m8qWyWkjU6TX7xq88v5lO0Os17p+MLMnpWzIuicCEwSOWa6GUFEBaJmbLPzs4Sbc5OTk9fvEqVcVWdJ2nTNMooQDSJ9uILrpNR/oMf/laDwYlDjUuNvVij4Bdhv7AUuN3cXCSXLApX4z33xRL3AvdL5Cumfvx8z7p0BW4tY7oPdrVil99au7/rzYsIAbY21eLBzhC6ErptDIwo8suff/bFZ198/zvfAydf/upLFGqq+unjh7PZLIu3nI1KksQqXRTFi9evHjx8KFq/fv36/afPuHEWqCgK0GowGp6fn7sQlFKzySTPc/Yhz/NoMCOiMaZs6uhdR984FhdXShVFIQjGGEGM2ZisteV8DkTMnPd786YoqlKZJAgTamPMZ7/4rKqqXpYN+4NHjx7VdV3W1en4oj/sf/3110SUZVkI4b333nv9+rX3fm9vbzweTyZTAuz3+8BSVU1mk16v55qGXRP533FoykoCG0QQ6We5tbZs6vl8fnBwAIEnFxNNyge3v79f1XXtmsFgMJnPSCDJk/7BcHA0evTu04YC6FipmIlAow4hXJ4xEolRPSKSVUqJK3gDRYJbN1S7FHUXPt9o+t274OgO8tvYiXlj3GgXWDFr23dof+muwY7dESy8WSQBrd776P0/+NEfns3GYnB4vD+tZqhgPB4nSRIzqQvAyclJPFv36PhBYm1COjfJ2cmpQiqKQikVOS3PcxQB5uPDo8RYY0zV1KIJtXIcavaew6Isp4AhZUmBD/W8wMBZkjrngFkTAXNTlFab1NokSUIICelh1hvkPd84k9hZMReFSZb2BoPf/7t/5+zsbDqdDvuDfprVRfnxhx89ODqO28VffPGF1vrZs2cmTeJJ+gePHsTyrXHMVVk655Q1aHXhas8hgKR5RkaTUg2H0/GFNiYwQ+CqKDNtU20O9/YXhweJJvNZ1ksn9dwpfvzRs0fvPsVMM3GAuNcPyIsjYqiou4hAuMaigHDlCO8KG/xG1OkWuroXIr8O6L5Qr8TBVgZ90zldb99ly+4VPllWjuv2uOqLSvxHsapyDJOABISY8CgE8bWryOps2O/vjz778tegKe1nKrWTyeT8/DymfqYkGe4fjGfTqqo0KXChKeaJomG/H71N7/2rk9dmeVzealOWpYh4Dnm/n2SZGIWJUcYwgAAxQ11V7Lxi4LLhslEMGNg3jgD7eQ89k0BTVuxDOZ9LYG5caBw3zhjz2WefiSaTpe+8/57JkrOLC2V0vAU6PbsoLyb1vDg/Pyei0WhQ1MXXL76eV/MHD47+7M/+5PHjhycnr3q9PISQKD0cDBSgtbZh8YCVd8oY0qps6oZ96RvRNHpweFHORFPlHSoajgYA4kSSPI9XcPM8VcaIxf0nx73DPbZqMptSLGTqvEaKNg4jxMIFDBJrisVf4j8AgPhxqW9bEbwLFd1Xmx1hhdLeEqMubq7dfdzbx3d3A0OWW6YtNy6/LriuNXpRLp+6CsSwyMYiIghMqAFZGGOK1yBIABLAKHv2+mR/tD+/mDz/7Mvz0zMGsVmKqHq93l6v550rxlNrbUyJYJSGAByC99720yZ4EqiKejgcxtuV2hogUkYXVenqJsuy4Hxms2I+56rqZ7lCinq48a5mD4iMwMwQOMsyBAjMhasBoNfrnY/H8c7Kq4sLZc3Z+UWv1xv2B6k2uU3m0xkJGKUFuOEwPDoYHAx/8YtffP31lzZNDg/23nnnnY8/+Pjs9OJ//Tf/Wzkvh/1+cKwAsywLIJTaJLN1XRez+cHe/sXZGTAfHRxYa09OTohIAvdsmtskJe29T7JcEAAkCAfi8/lY9ZM//Id/FBAE2VjFzMAhrlrMDOxlEURQgPHOXfcAAAkAdI4zoNpID9cZt1uM3tYnugn1rXb9Rgz3IgJWPPDLowIxPTEztxuJd4GuCQrX7zvBmhK+Dja6oCKL/fsrfizGyqwYP3T+cTSyFikIUS2ytixzV8Tj+NoqhlD66tcvvkgPep/83qejp4f5weD0/ASAFUhRVBwAjCp9U/uakVGBNhRPHDTFHIPPUjsY9LxvsizZO9gv67rxrixLYNTaAqMh45qqmE6U0ZVrRFPh6rmvHbA2JoDEoiOjg9G8mje+FpI8TbTWZV0/fvas1xsgqsO9/Z5NE6VevXxx8url0dHh4fFx3u8RERASKgAYTydfP/+GjBw+2HdS5f30nScPE6O/+vJL3/jvfPgJV+Id94aDb16+uLg4M4p8E7OaNBfj8zRNSOu6amYXU543NtBBNjgcjAwpUIAoGNiXtTAXdTErZ5SoH/2DHymFpFgRhODiNW5c5nEXkZg1JqpWEYmpNhSgAqRLVl3+26SsWntqnequo6KuZyRXw407UuB2/LBG891+11teh6TVQN14p26fiSwKAJFdtw93y0BXrc033Ym5rmV3lNc9LncKA1DnvwDLy6vx9Uf7w6ZpRIkX/t5v/wA9/EdFF6/P8iRVRjOEvNfz4uoS4yniAMF7v7c3HBczrVUM5A4He3Vd13Xdz/N4ZwVJjcfjUX9AWpMyR0dHHEIIofFOEJRSVV1rRXFbHADKslRKoVIiQgAoQEq/evFytL+3NxyNpxNRcrh/EE/w/PSnP/3jP/7HdV2PmYFFfADC5yevyIBC+cEPvt8f9afTqTEGCI+Oj3/6V7/48quvvA8mtycX54fHB1rr+XxOWiGhSaywxApXwQXt5Xj/ABEN6XpeKKUCgOOATaOUMtYS166pHz95ysQh5qvaPOEbuAtubivezodayVK9EmXsNr6v8Wz8fTurrwsmaiVcHHH8etMLrNsHCmtHkd741HqooOvxtg26nLzzIKPRyyv/RELMyhdLTed52u/niGKMqlyDWg1Gw6qpv37xddWUQTgIK2Nc8J79uJiS1Sa3VXB18B6ASTnPk8mknM9dUY1PzlxZYWCUYBQ2rroYn1VNHfPZGqU7RdmuHMyITjM7hgB12SCLOA8uVLOCWIglN4k1ZtDrD3qDo6Pjf/kv/+WsmKd5Lory0SDp5U+fPXv3vQ+OHjyaTUtrsveffZBk/Z//8vP/9LMfN+h6B/1Pf//T46cPMVEqSzyICzwYDcu61togiyYVd4MykxIoCeCcI8CYbZSI0OiK/dl0PC2L3t7wk+9+pz0sfXk4oWPR3ALWaXoXmtn41y4VxfJtO/a4+1Dv6JquxETjj3oFewyLtwLmbsrqZiNb/7zepjueNki4rn5vBzH82E3aQkR1XSeJCcEPR6N80EOGoi4cO5smCVmdWg22Kcp5WaAsrgI75zKbxRqqRuksTYuiEB+EMDEmViUajEZVVVVVtdcbCEo8pOEbx86LUqg1O9fL86ZpMpvEsxzG2rqurU3T3E7mM400GgwFYV4WZVFoUnHT5fz8PN5y7GW5Tu0vf/1Zr9//F//sn7MPSZJ88cWvPvvZz1+8fKlS/Yd/9IePHzwEgN55/4uvv3j9+rVSigOkRa/f77P3DGi19mWd2YQCaSQy2rlaKW2ttakZF7NpOdNp4jiY3H7625+SNU2ojdZ+k466R7jpuncb4/IQWwxNr2PYQvbXqdk7MudGaIex2C+Nfmk37e919ucbMa5og3tn8u6QtnPpjSauFVIAEN3yy2SwQsCiUWtR/+Ev/uLFN88Hg0FZV8fHh9bamFNrPp2FJvjGp6R96UIQay0Btik5yeggfDGZDEZDIppOp71ebzAYlJOiqet+lqOAEkhtws7P53OTGlQkhFVT6zSRxZ6RpMqEuPUBkvT6VVODVmVdCdLp6akLfj6fi+Dh4eHp65PG17293oMHDxJKCNTLly9JAEm8hD/9L/7U9q1GEhEQ9avPfv0X/+4vQhCyZjqdjvoDRZAlKbkwtBkGRlToWQmIhHlVjvZHROCA565mDb294Sff+2S4P6q5SQdZUZVKIVyJAgEIAQBdY/Fuh8ugw6ZzaStO0HXr25pyrfXbbrmvY7jOw3yja3rDN9s81G5HdJk9KJ5lQ7yuLNQb4S4cct1AYWmZxLO7sLYvurHrW0PXdYl3UxeOunhB8OLn9fy3fveH//jP/vTZB8+C+JPxeT4aNN7ZPNN5qnIbJCwTICjvPSrK85yUQq2KqozvcnZyGndZ2If5dHb08IHSOvJdTEARQujluSYClvl8zszI0lQ1EbEPrmlEZDQaJUkSGucbVxWFqxtX13mejwbD/dHesD+YjifHB4ff+fgTjXTy8tXP/tNPv/r8SwO2mNW+lsymMdcEsw/BBXZ//ud/Hq+Dx8TW+8NRNS2n4zEKNEUZqiYmLiZAhaSt9sKOg7GWNUhCBw8O+wejQJzkSVEUWr/FWxwrX9d/2fhgK3Pb0FG8X7YRw/Yg0HX29rpPd2vKbF08XATYEJm5qqo8z2+H8bpu7jLKFrqWSdyrWFHy9wsrhgAABAiEQAp9E0xmnWuUoQdPHj98+qSqi5cvX37yg+9URalS7ar69evXNrVVXVlr50XRsEsl9d7PirkxibVWo/bOVeM5AeZ5Ll4+//kver1emqbz6axx3gwNKqq9N4llDv3+MLp5/cS4yoEXsBCYJ5NJvHk3GAyKqkTEpnYQQghilW3K2f5wdHpy4nyttVVK1QkHAWOzwVDX1fz5y9c/RNXULjGklBlfzLRNfMU/+/kvnz59Kl7OXp/0ez2ryCAZRb00q+aF1toaXXs3GIyUNd43pTRmkCaD/N1PPvAQlNGeQ1u5EIBjesdY4Q+QAQBuuG67BDKu037rT3VDG28JVoILt4CuT7dQnNP5JF7aOjw8jHej4Orhu+6T29V9O8q7DHEFVVQv8Z5evBPUzfG5vdMbLUZrR0T80ehVSsVitzFDNzBqUq0krpoyS1MR4QAYT7pV/sVXL371i19apZuq7uf9sixDE5RSCnWSJPE+avD+aP+AgMbTsc0zz2FxvN5aEnDOmTQREVJqUcGhqmKGBxd8OsiqugYAZY0IFmVpszQI11VTVGXT+GkxPz4+vri4mF6MDx8ci8G6roFVNatRGwWIwCZRw+PBR9/54NnTxz/+8Y9fvj5/8fw1iZ5Pi8FgABJ6NiUOZTEbpPmDvQMMXDc+y5KqqnRqlDWUqKZpTC/Jj4fPPnlfKcUQYkabWHR05XyfLCsy0Z25tF3cLVbVlv2PjSbYLnsQ6xJ84zjbPZ4Y19iYoGwXPooPKqWcc4voUb/fhyVzxi3TlRsn6y+z5U3gbrwqnR1R732Mx4QQer1e1KW3cJu78yLLmuorEbk4KZExLoXUcvcVBeKVFEAAlCDeJDZwzEFOAMACkKgnHz578sE7J89fnrx4efH6vCjno3wwnxaPHzyeTibD/siTCrX3jSfUCFRVVZpn7AMixtOIIQRRFKtFGGOC9xDY1U1mbG6SpnEcC+/6QKTTJKmrOu3lDl2eZgQNIhbTmVV60B9Np1ObJIfHR9OLqTc+7/dcVadJNp9Pf/6TX9Rl3YyryevZ8y+eeweJ0YmxBilNEg1olKo8J8ZU80IpJQSUGI2S9bLSNa9OXu8djJJR/uF3PvTEQTwsz+GGwABXkiQjoghsSbxwC7jOsIzStjUXt6viFTeqa2du6fG66FFs0N0fuQ7VjiwKyzvVi+hRpMs2gERXaxjfGm4RPeqyU0y6FfPuIWKsXxYzPnW5dLvwW0fbbdDdPo5JCePnVmMzsuCC5kgud/yW2BgR41/jXUhmVgSKSTG4snr+xTdN0bx6/tI3wSrb7/Vc7X3lUpuFELJeWrMnTQppPp9rpdI0dc5pY1DRfD7vZXlVxS0cSLXRWk+qIh/kzIyKQKh2DRld1bVSumzq84vJ4fHRZDJhhLpyzNzb69e1G4/HaZJXTU1EmbFEIIRlWeaJZeYAKEASBBEzY1xRJYoUATMTh8PhXpqm42puUouIF7Nx3HY6fnT8vU+/73WIJ0ZW5ry7XYrLjRnGe9OlW9pL5wxp+/sKKbb00wrrNptH1FJbGGmLor47tL6odA7baRGJZxi6Qc4teUTfNrSeQ1R3Wus29UbLaTs66Cv6c+WRtgsA8N43TRPP3Fpr4+XvtmVLcIyX8UmUS7qU6GwhAoAxyruaUDvgdJB99L2PfRNmVfH86+eFqxlBgQrArpqBk1kxnft6dLAHgRVgmmYQOLNJ5RoIGI8fIGIQ0EjGJs41VhtpuHFNmqZK4ayqc2WIoagLndjDw8PpdOo4CIBNjU5s5bwnEKMchWCx3+/PxxPfuN5gGADLOhRFMRgNZ/NCCEPdYNqDEBKbI4rJc5RQh8bX3BsNam7qpql8lQ0Hzz5699133yVLsUB7nIoAAks+XKzLVYLehUXvhfC6rt0WUY6IMQFV3Dtt40nd/Y5vGbqGJLQbGdP5pBU/iBhd098sl65McdxXjDNorW3ZdRej+jqJ2A1u1XU9m80uLi6899baXq8Xwzm42Dv1i1o1Kxi4e4gyKmSKqhVkcTPLoinLMrNZcNxU7qd/+ZPJ6TgzaTkpQuO4Cc45VpD3e4mxTVEe7O0rpUgrLyyEjkNRFOfn5+89edZUtQbUSEliQwgBhJlJK++9TbPaNUx4en7mBHqDPhldlKXWugrOec76PREpimJeV66qXVntDUevzs6fPXlnejEWkXiSVmvtqprnFflAAB9//D4pKOqyl2ZCUkvIR73z8cUHn3x4/ORhf9gjIscO1eVZhZjnOrJivG+EnWjRjkca7iuiAVcNro29dJu18lpE2gDNdvz3O+YWc1eLLD7MimkbSurq2e0ovgVo+/LeRzkXw7wbw1pbkGz8BZfgnDs9PX316tWrV6+stQcHB3t7e4PBIM/z5WaMB4DIpRx5FRmWXIpxANHiRYqbcIjtyFkpZXVSl40CtGj+m//qvzas9vJ+oqwO1DRN412SZ5lNTl+fHO7tCyElpqgrD1J754L3jUuVPdrbl8YLs7UmhGCtDSGwQFVVJk2A0HNwIZg8PTk9Tfp9myTn5+eolfPcNE0byajrWsds8doAQDUtZrOZEDx9+vT169e5TYYmC86Nx+PhKH/v6ZPGN15JPCk5Kad//0/++ODoQCQAMgO40CwMMQS45NK4LxrXZcP17i1wj3YjbApGrLRZUVzR/dk9+HK/Y+7ib4Mvl4GouL0LcOWM70Z444BkCXcZ4srnmJcg5iBuJUjLZitdvxF/9x1FpGma6XR6enp6dnYW/zubzbz37eKhbKgXjx1YQ08x520A0YkVwllVmsyg1Y24//y//Bff/e3vP/v4vWk5a7BpxNXepcYG5/tZXhYFsrDzwXkRMYm1afLw6eMquFlT6V4KVjcSBKF2TUwnX3sXQpDAmlRiDLIgANeOG5elKTt/fnaGACqIZhgk2TDN0XM9K4S9UTrL0yxNUmtfvfhGCVCQ2WRKAFmWPX78eDKZoMbf+4O/84/+7E+A5Ef/4Ef9/WEtzrFz7GpXGWOuXUfc/PlbgC1uzvqS/eQnP4nJKGPgsMsb25Ff98sd6X+l9zge3eWrdtLvYvGuS6zr/nQdrETnoh3eugpXL5duWI83AUXE0XxgBmYQQaUMMzSNZwZERaQRl2X5hACjfoidXd5ORun4pSKCQIR1URORVjr4IAhKYxMaCGCTBACCpcm8/O7v/5ZB+vLzL820Kps6Ia2VKqs6T9LJbDrIshdnJypLgkYg+uj73331/MXr6TixNpTVwd5+Xdelc4iYZVme57PZzNVeW1PNKgqiNCuQ+cVF1ss//uD9i/NzxSSBz1++JqJhr0+Is6L01lfzQpMSEaOJGzctisPhwXw+R6V+/etfP354XLvm1199Of7p5P2PPzp4cFyxJ0I0ij2nmXWuIdRwqbsu9aoArIi36NXTfSfxWYfr2KxLUe2HH/zgBzFoBABt7r9v02ZcgRXlH0FHE1cptUxCHdqTA7fAvv5g94V38SRXtkPbs1BtVKlrll+XTHGLOFyxhRBRKRULeyDiYDAYDAbxMzMjEsCGS3zS5rZDELj0vdqS3sYY7z3EYkRqsWnG7IXwk+9+/L/8z//qX//bf/PuO+/+0z/501/++Odnr14jgLXqqHfofQMsxXS2PxjWEhjx4uT05fPng9Hom29e7A2HTVHbNF2EvgQEpfEuCKdp6oKvmqZ2jUrti5cvGUQ7d/bFl4pMaiyyPH7wcD6fN3VtUfVsGthpa/M8Hw6HWZIO8x47fv3ypC6r16cnec967513JyevHr375N2P3g9aCJVnZ1ALQkzysOWUAt8tFcgu1HIdbCSAFYWBy3wurZZqP9wu4TXcTFtci6EdW8s7N857tOIQXvd14y/d39+If739dgG5IzbpBLgRMYRwcXFxdnZWlqXWejAYHBwc9Hq9JZduuIj3xrjCih2+eFCAmROTNo1nx//9f/vfnZ6efvDue3/0o//s9ctXuU4//6tfYOXACTH280ExLz3KxXxCRpfss0H23kcfTiaT6flkOp4YZdI0ZceDXr+czZU1xpiyrhrvtTWB2HOYFjNk0EFbNCIyn89FJEmS0WD41Vdf1a45Pjo43NtnH55/89WzJ08VEgmxlxACEDL6KtQ1NM++9/7f+v0fhgQDssdFfEgJqKWA2mjQblRH25cSrtLMXbTZdvzdNrfrZQtV3HrY6750i+2W+Xi7NsON5Mcb32HjKOG2Ump9eG2EYGHxaz0ajay1MUBlrU3TtN0uvl+I50gApN/P/8k/+6e/+NnPP/vVLyVVtXInp6cvpidUc6ZsrvKKG53Zcj4b7e19+eKrB08eT+rZvJr/nb/3d1Hg5cvXv/zpz+qiPjk7mRbTvb09lsCgTZLM60oCFmWtE80CWhlXeqWViZlWZjOt9cnJSZrZ48PD/dHQN66azS9en7/38B2tlQ8eBEFEONShBEN7h/u/87s/hEQF8ILLjYFYZTQeU8D7n6ibEtVvHO7RQt6siu49h+CKiLq7jFnBswK7oF1xx7u6tOvrQscQasNpXXa9zjroIsdFBhDu/niJQUghucoZYwDIi/fglUINmptQnE9mF9NqWjSVc5Ur6mJeFLVrdJbUvs76vb/39/+oN+gzsxb0jR+fXvyP/8P/NOz1rU6yNC+Kqq7rxoVpMQ/C+aAPAZppSaCUwqKcJ9rs74+EObMmtRkipjYJzs3n88SkRKQAXVOhgrmvggZK9Y/+yT9Ie5kkFMTLle1iWKSbuiGXbp/De6H1LQv09vDfHfMWtG830+c9wk0t5+ue7TLnSjiu6w/AJnraTmHdCMo6ly6mWwgRNRl2PoSAWgUdEFG8aFLivBalUAMLIjHzi1cvnHOkVNrL67qel7Mn7z11oRmfjh8ePSzG83//f/37XtZ/+c3L2WSODLUP1loOMC8LIkJUxXgGLEbpw/2946MDq7RRWhsqZ5XCxWEpa6137JwjBSE4Vuwo1OL+8T//J/n+wIsP4tfdf8FtuReug2+BS982/m+fS99WBYq3DbeeFFpm2W5D87CM98Juvsp2e2yRG20NgXMuSRIUqKoSUxRkUMAQAMCFBgRZWGl0CI5dYDbahBAOnj6IB9Yihj73dabG50Xat6Uv/sNf/d/pKOtleTZLjx89PD093wMMgbWycgbGmNNXr0X8w4cPeln+8PDIVbVBhYHLeWmVRZCqqirXhCwgig9uPp+LYspNfzT8ox/9o3S/V/hCGQOIEASQ27eTtdzz9wh390s3BhTuOqzrkb9ttP+/06UtQ3YvHEJnjqRz5uO6HjfOZvyRIO5G8Mqf4gWGZUbvtlNhhSJBa+u8j+JDRc+ZEZB13CoLbIxhH1xoRAMqBAZDBlGV86KZ12cn52VZ+dqfnV4oIqOTXq+3MNdFpmcXrqwSMlwHC1oxBMchBBYPiKCAldSuIU3TaoYWvvfbn7778YdJP/UYWAkAhBAMIXZkkABw3J26CbneKHoEd2Ott8elbxX/xqDM3wwuvbuN0WJoebJr365E5Lv7NNf1uHFLWUQWJ++vcikuU3jETa92uytuoy96X0a1UFEIAUEFdpqMISWBq6rqZf0QgiipfZ3ZzDnnPce6L8H5aGkjYlNWRVHOZrOYSRgAXFGlOq0nBVRB1ZzpXHwAAFQ0mY3ZoCMGjSYzmOm/9cNPjx49FEJjlOegDHnvUSOE7hvdcodlRy6F+4jHfAtc9FbxdxH+DeDS7dbFLTRqK7C7HAtXDa0tYfEIN+XS1rQOIeAyryoAoADFQpdaMXsvHKsbAUDcxEYWoywCxIPDqCAIA4syWgRFJGY2Q1SCTICxXpssT5aJYDkvyvPZ+cnZyRcvzl+fcR2IMUkSIKxdnfTT7//Op1WoD44PDx4fOQxASBDlV+ySkShc2Rglkmtt++tg4wbVljZ3hB259KZ6+4227u54dg983phLu3qmG33Z2GWro+Aq9e80sq2LeovlbHdfYI1Rd0f4Zm1wDe1uvF1J0t7DZAAA5HWkCLC4Q708tSMIKFcy9MUTBIy8tD9bGUEEClggLI5cYUDnHIfgXTDGJEmi9MKIEGRR5ChEPNg5YiUAgTrFRYXo8k0vw+Ndg2V9PncngL/OMZ5dMN/FENgYrVyNHr2xg3XT8bpHVlal9fpg62R1m907bCSduxtX9wZCeM3GhgAsi9pEr5CWZ3sW7eP5u87dOiFBAA7xmJQCQQRCMCSWQFCJAiKPEMQzc0wlLiB82/3PHZfsDbG3vyYLsRW2v8K9ky7GrNlv7HjjOFYmdJ3Wt1g1b+xuRePBJp6/6Ype1+n9UsZ1FmDUcisalbH18Fp+o+796QW2zlMCLMB0efGal/hXkoAzCgkyI4PCBTIBAAECRCSMse4AyELCCHGCYaHhYfHlcvzUZV9eO6a7O+y4GfOWJPW9wHW0dPcxb8S8uKu5MX/KFkQrw5LO+fhuH9KJl3YZ76bj3vgOb1TLbw/ukYA62YFoZe9xheHjfbl4+3yFRVegPXIQz2W0WULjWsXPCpSgcLwQi4KEIgwAiq9EhrrW9e7bo29clG9TF7Xw9pzelV/unSYXFxpiuAIR33h57UYQWbfN19Rq0Zveuelqzhup/fuFu89Md99ioVejpdptcyWCyh31y+1TeGWvkgDahBJXeAyFQQSlPfeOiLS4KcDtWjMABpbFNdmFEr4cZDseFABg6vyp+0a7u51b4Dcoee8F3tLINSzTB8vy6NzGbN9d6E5l22yF8bp2Szea2g3YbIeN2Nqvd6GGuzD8tywjuhYyLRJ8LfjtukdWTW5ePIKICAoEEDDWnpPFUgoAEkiLU67y4Uqt30vVenUadpyW7YZu1zTbBdvu8FYV6f3iX4crmSNajrqjy7fOVHCVN7ajWvm8ceV25Ja3J5uvG8D1tyhXfyFZt1pp5Xs36IsoJCRCiLhItCSXzaWVlt13FSJcOrqyGJuIj/7wZSBYqK3rJRIYr945W+bRbbkX2043vddd4G+EFn3bknodv5bludaua7ox52371+5XWd5t7x7ladmya+huH8cKzpU2txOx377MuwUsAjvb28iiKcrS2BVaXka54s22LNrRjJfxpMU0RnuWojYlACAkEBIRlnCjS9oIwDeUg+tLv0I2fyPgWzapcDqfREcxGr0xf/wWLt2G65oDd7BpFW+xKuvB3u5k7Yht43i6AgWuHnjYHhW436W6SXhzNdS0Ap2cmpdc+iaEb2yzDbb4pbvP23pgcpdA1ErLlWm8DsMu+DdS1/rg37Z80bA80dq6o7eWEyvGc/t54zvcPdgL9yTSVjznW8ei3x5sopU3sFPHaVyN3l8zY2+xRNob16gr0+8481t48qYG3boN+JuCxX7pSmK+u0zWdYLt7rAu/G43znWjPUa546rEdHt3H+0dQTqbWBG6Ub3fVJT7OvjrEIG/jhi2EMkbFelG/+4ug7wdUEsE7X4J3Iq1uvbt24B1H/V2eFbizNKB1ux/oyHwLcAKi8Jb3pH71qDLz9vV+01V2S628e7YNiL8TU375tRed1dQ9w4ryvl+7dKN5s1v0OBpu16Rm3cRgm9bjO4CK3bQvTh4uIQb9b57478OZote8cfgbsP6FgweeVPG1NvBesCsyyG/qaXCzjHju4uMb/Mt1sVK/GX7Kbe7mJTbH7wd2vvylm/a4wpcVkZaaXovk/VGPOs29sZHVhzmO/rP6zqzW215xwjhG7u44wJ3e79ubDcd0u0e/JbhFjO2QnJwf4L17THnjYanV3K931ps32JybzTQrlbp/nijHjeiXfnaJhm8L6F+I1R4zd7SdiS7E+WtyXddZt2O7Vc8l42P31o+4tX9v7vAXWT0vcOimtPuD2yPMK3Mzo4O/S7SYaMP013pFSQ3XaeNWn3LW2zHvy7dV76uDH69i+uOOt9One4yntvhXxdJ21te12DFaridlOw+tePy7WLrbZm9lfHvMsJdmq3ATtnJumO9kVrYBe0txt19sFs5pvvXm8L6aHehqjf2uD1AssV0X9kNeksO0h19h3W4Tld/y0qpO4bWS7qvF1zv4m3DDXII7mID4NVDPG/EdjvATr4iWAvGfvu2ynWk+UbFcouObvHUOpLrCPdtkOB6F9chXw813Rd0xfobDa4d6ed2qv6mj0TQu3S2ozNzX0rspu3vUcPcnTp3H0lXysANPc83au83CtN1nPc1h7vQ91tSRPdCS9sfuaPFezvY9ZDNir5ah43eznaEN8K/IuZj+3b7ZIXa/po4/RthfWZupIdb3r77MNaX7Nbex03hr/MCvSW4y6rdLGv2jez7Nwr12y3VeoBqxXq5CwWsq7X7lfobXfHtUaKVB+/FEruvl/r/HrNt1/NydSPwW4NruXQLQWz8047RlFtDlwm74dx1O1Bufk56hcPvQnxbLKJbD6+L5NYDa+HWRt29j2Q72nsPld1iDFsa3IjI78gRlxbvjpbYLvC2bc6Wl7oQ/9SNKt0IWhbqftgdz925bl15rpvxf1N017esbb595fYt93ipS68L963AdQ73VSkYuWjzlcU3iSIGWN6NjtI0XkyOzSlqpEVWEREWQgEmgZZzI+YA0gpjBZ16ft2RI0DMroAgIgISL3whIOKST1CJxBR7i2djjoX12YkVwRmXO0MsAECwHBagxIvYLELd7QFZYtsQHBKJz65O19VchFfyJMGmqhDx6UUV9M7MwNVL3zG1bxweXFO3e0XdBVg1DUQEFhkJr7zLYqybln2jGRlxEmC7dSzL19hi+zAuBrDW12VOmKv9bLuyt8TcnmqE68h2RfPL1Y3fW9vJ8fHLc7zbe93y446GcYfy3hyEbBdBADBSj2zILSkxxd3GkbAwLNWRgIjEGi1EtJJ1eh24HfnaXv/2AXeZRwhJAJaiwXu/0IZqQ/43WaGdJTksVrr7lzgTsjkN9/rt8C6tSPyw7E4ACJFB4mwspRje6K5pLJvdZZt1cX8XG/vb15O3hi5nwjXMcjvQKx3cHUSkpSsRWBl32+y67lpd1AIBxGyxggBC0hJtlPcssBTduNCEShAARC2tVhaBRa52ZEABJOzmB4o9Rk142a9CwqVd0OWUjVWMGEFApJXu8RkElEXOkSBMSIooFndgBABBuswgv6ZkRDqpeSmuUZxPBBHptN8cqF9KImQEwFbwAbAwCgIKoQgIYkyIRLhoFVXojt6pBCbEaDeJyDW5YXDl4+68JwiAy2TB3Nod1wIJAGyUC8tcTXJFcCwrWV5ps461O6LdBh77uh8Rc+1+6cbft1gmuwxrx9hMi2JhbSzs0m3LsyJl2vxAuEws2hpLHAl1B4kUrVzkyP+y5RHuGKyyNPdhYRAuGKy9XB6tRJBFioxF3qArOVAAYFl0YjkPvNT/uHy766f6Up2iLGQHdLeyCAmQRdp5kGjfIwog3Sppw1uN9NzICrsRwl2a3aW7Wxu6K/DW65eujBI7zLO5PXdMJrz0spa+BgtcYRiES1m40YjFzrZqx+oj6EjIqARaay0sCTt2GpNQXxGnsvCDu7n0MD4Vi6wsml0+0h7iFxFaONDAsPSx1z1JlnYiloo0GuFRWQACyrVW+xXtumD+q245X+2086c256DsUudbk1ncnl9zUDfCTWuHM5AsXH4IHOcNOwp1vbu3mBpmO7Tvfl/M2cIll25kpy1DWYddRtZGTa5rQAAsohD5+kgDdcM51/e5faiXukUWdA8LjYIKL/PztUZnt0zTZSRpWa0l/ioiCJdKv33TqybWJSkjX5ZMWjFbVadiTGe6+E0W3/KRpe4lwMu6T90xiAhiO/4AQYG6Fl0X81W1Gcs9xipvrYP6Rl7dnY67y/Q2csqsBKI2dn07uEfj4tIvvS+MK7A+p2+yjpgglkToBoYAIj0vEtSKgkV8JWLuxmAjXLUelwNAwMAte2OM/S7GuXSe49dFn7BiaOPaPF0ZZ+TS5WtCG/q6+nhHEaB0rNN1zMtmS5Txf7gsW77mw7fQqUCD3eEBLOLXEGOPAoQALITcxuekEyZ9IzB7udT6ly+67ZHrpes6XSAywKIDZkFEiVVepbtQu8NlfYAIHTq5N6a69+jR5YWSFdhlKN3g3soQV6BrDGxHjstSQutUu47tRr9AZ/pWhtqNzq0IVwYR3GxLdyxQAICFHSZXoaNX23fvluS41OQths5UrLwR0mYrtDvnjJee/Iov3Q5gMTncGhG8DDPtZC52u0uSxHs/nU5ns1ksyhpzO28kg3WtvktfKyp6I9XdHe6Oc0deuAUQACPGXTsOwRFFwy107ze2wY+YaA8A4np476PL180S2tJBS4LtFK/8sv5KIgLISiMpCOyQBJABGUkgEujy4BEjCEXiYiIAYGYPJAyBIeBib3LxgYTjSwEJKCBDAYKQAAmQoIIFchKGoBSKBCFhZEYOEAIELz42EGRBZghAwsvPSOJDE2cSEAVBGQ2EghBLCQeQOGDPgUFQESpikCAMwEIiyEE8KiCN8cVRQRAflyaIX3Qdp0ih44BaefEBAmoUEscOFDAu3pQ0MgQAjhPIspicyylSACQhvhciUtw2WmQ8abOox0UnogCBDHnxQhIgtJPjOZBWaZ79+ssvyrpqvANCVASEQNjKOAZhWBQNU4AQWAEiiwI0pOIHjYQs8bOCuPiLzxB4uVwAgRNt4rojCrMXCXHymf26Z9FSMiIiKiKNjAoUBFCgrtJ/aMMHLUF2zWxmVkot3mJJ/2137SOx65VklIjIzPHHHXVs7A4AcDI7jzXko3fhnBMRpRSi8t7D8qJjfNXYIGbWLorCGGOtrapq3WFoPy89oGtvS60wKhE0TaO1JiJhvpwgkThOY0ztg1LoPWtcqCMRQa2cc0mSMLNzToEiFEItEIQRSISUSGAGohh/ZxKKv0Qc8S1CCKiViMS+GISIgJHZkxCiICqRUHuX53ld1yJiSIHEbPMCQq2punhlwlaoJdowc/waexRCZo+MRIBCgR0IkYqREhHBOFrvG6MskIQQhC7lHQCwY1BgSIUlG2itq6ZO09Q3TiOJSJqm8/k8KrqWttqYc1R91lrvvVKmWzQobvMCgBevlIqkprVumsZaKyIQFvG5GEMyxjRN09J6JBjsZMBYzDBiRNVScOwxIo+/x8dj464NqbUuy1LrBclFPRHpUykFQHVdR+ESq6obY7z3EZUsy16LSPxr9Ae890opYxLvfeSlluZXGK9pmjRNm6aJI49I2gWFjhG3Quotz1+nYNd9w9idtRbn5QyXBeTjhC7fB621IQTvfbRqYgNYShFjDADHX5YvvMqlXUbtjmNb7ny1WEUiQo4rB+2yxTEYkzB7pUwITgEyMyAqoyN9KKVQQAIIhMhXQRCQkXQQH3mMSIfgiDSihCBaEyJGARQHHELQWjfBK62dc5qMJgiOAVgpwxBAESJWdW20VoAEyCEAIgChWuifSJEtfciyTgcDRFJARAlBKUShEJzWNgRnTOJcDaSUVXXlSAGCQpLQBK0X+Zla/cDMmowgB+eBEBFRq7ouI2kSEQktRLjRrSEau3bOaa2994ZUO73sJTJhS6naqpavuiQb6/RFtoxdRMHfUmfLh7isu6e1FrmsVxKnpdVOUb5EiooDAwACaUXDgsbo0mh3ro68HUUMMxPp9pemaZRSzgUiApaIJA4jImdmIImLrpSqqgoAjEni2Fr6jx+igItdR+aPc4h45RXWleoKi25XVPHdq6qKsmBBkJPJBEgU6niehUEUUjyPAoTBsbZKAgRmBFBaI0lnrC7K15You8Kgy5MtD8cZvI5LGYHZa2uC8/FlSCiEYPVi4iSA1ouIFzMbUiBBRATBhZBkadM0wEgCWikILWWI44BEUQu14lkpFYSXXxfqTuHCpoiKNAQRAL08yRAfZARBdsErYxCRG6e1xsBKKRcECJlZIbUzE98l4mcQY4xrnQVERPSNS5Ik8kaUmAzCS0djcW5pMaV8yaW80CTOOWOUiMRiavEM3YJ0eHHcql0IZUzTNGpZzQAAFJJzrv3KzFYnVVNanbjQEFEQb5T17IARFUgAk+i6rpMkqeu6FW2tBI9skKZpURTW2lbIIiLzpXUGHX0eRQMiRolPRHEJgKPzgiIhSjHvvU0T7/2SkZwxSVUVxhgAEMGo1eOEMzPAQnBHLo2qKM5h7CtSOyqK8XAU8BwIFJAExybR7MWzQyFtFRFVVRWF4FLBQkveXeUESxuhlW5xPBu5tMs1zrk0TeOyRv5CV/vG1yjk2RllURH7IAgKqawrqxNBRiFSikNAoiCexcfliQzQyjkAEAltx630jZwZ5yUO9DpZwgjO1doaCaCUUoDAqJBCEwDAaE1MIhJcUEotI5YxzIqVa0hrETFKR++FkCAwiDCIF46OwkKqaRXHUHsXhWIIfqHcfHC+TpIEWBoXlNJkNHpumiaxFpVq6pq0YhRWGK1SDeK914vDo8tDl7yQncH7SMfMbKxlhLqubZqEEJjZKM3MGhfql4gYwTkXDxKiVtH+b9vEUz6RBOuy0lrHEOhiIaxqmkYIjVFVU2utgTFJkrIso0hSSsUdabqiS7VSyjcOFSIiI0MAIVGgGFlElCFXe20Ve4ky3bOLPG+trevaGBOFb+T2Ll0CgHPOWguw8GWUUpEho8CNeiPyZJyEiHDhG7MYY5yLnqfy7JIkib1EWmL2niUS80J2m4VbgagQUUKkPVBKSVh6erhgZq2156BJNd4pJEGQwMpoYHShiXIKhUyiJUAQH8S3Uqk1Flo3XiS0tN02WKH2LgOv82orl+PsxTb/L0YrboQ6WPZjAAAAAElFTkSuQmCC\n", "text/plain": [ - "" + "" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -305,7 +366,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -315,17 +376,17 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -344,14 +405,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'data': (49529488, False), 'strides': None, 'descr': [('', '" + "" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -394,6 +455,88 @@ "Image.fromarray(np_img_arr)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `__cuda_array_interface__` support" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'shape': (3,), 'typestr': '" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import cupy as cp\n", + "from cucim import CuImage\n", + "\n", + "img = CuImage(\"input/image.tif\")\n", + "resolutions = img.resolutions\n", + "level_dimensions = resolutions[\"level_dimensions\"]\n", + "level_count = resolutions[\"level_count\"]\n", + "\n", + "region = img.read_region([0,0], level_dimensions[level_count - 1], level_count - 1, device=\"cuda\")\n", + "\n", + "print(region.device)\n", + "print(region.__cuda_array_interface__)\n", + "\n", + "cupy_arr = cp.asarray(region)\n", + "Image.fromarray(cupy_arr.get())" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -454,7 +597,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.8.5" } }, "nbformat": 4, diff --git a/notebooks/File-access_Experiments_on_TIFF.ipynb b/notebooks/File-access_Experiments_on_TIFF.ipynb index a03b3fc9c..266d74b4a 100644 --- a/notebooks/File-access_Experiments_on_TIFF.ipynb +++ b/notebooks/File-access_Experiments_on_TIFF.ipynb @@ -38,7 +38,7 @@ "\n", "#### 1. Accessing tiles sequentially (left to right, top to bottom) from one TIFF file\n", "\n", - "This can happen when a TIFF file is read from a single thread/process to convert/inference without any optimization.\n", + "This can happen when a TIFF file is read from a single or multi threads/processes to convert/inference without any optimization.\n", "\n", "#### 2. Accessing tiles randomly from one TIFF file\n", "\n", @@ -535,7 +535,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.8.5" } }, "nbformat": 4, diff --git a/notebooks/Using_Cache.ipynb b/notebooks/Using_Cache.ipynb new file mode 100644 index 000000000..5a841b228 --- /dev/null +++ b/notebooks/Using_Cache.ipynb @@ -0,0 +1,927 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "bfef84ba", + "metadata": {}, + "source": [ + "# Using Cache (available since v21.06.00)\n", + "\n", + "## Need for Cache\n", + "\n", + "In many deep learning use cases, small image patches need to be extracted from the large image and they are fed into the neural network. \n", + "\n", + "If the patch size doesn't align with the underlying tile layout of TIFF image (e.g., AI model such as ResNet may accept a particular size of the image [e.g., 224x224] that is smaller than the underlying tile size [256x256]), redundant image loadings for a tile are needed (See the following two figures)\n", + "\n", + "![image](https://user-images.githubusercontent.com/1928522/118344267-333a4f00-b4e2-11eb-898c-8980c8725d32.png)\n", + "![image](https://user-images.githubusercontent.com/1928522/118344294-5238e100-b4e2-11eb-8f3a-4772ef055658.png)\n", + "\n", + "Which resulted in lower performance for unaligned cases as shown in our [GTC 2021 presentation](https://www.nvidia.com/en-us/gtc/catalog/?search=cuCIM#/)\n", + "\n", + "![image](https://user-images.githubusercontent.com/1928522/118344737-c07ea300-b4e4-11eb-9c95-15c2e5022274.png)\n", + "\n", + "\n", + "The proper use of cache improves the loading performance greatly, especially for **inference** use cases and when [accessing tiles sequentially (left to right, top to bottom) from one TIFF file](https://nbviewer.jupyter.org/github/rapidsai/cucim/blob/branch-21.06/notebooks/File-access_Experiments_on_TIFF.ipynb#1.-Accessing-tiles-sequentially-(left-to-right,-top-to-bottom)-from-one-TIFF-file).\n", + "\n", + "On the other hand, if the application [accesses partial tiles randomly from multiple TIFF files](https://nbviewer.jupyter.org/github/rapidsai/cucim/blob/branch-21.06/notebooks/File-access_Experiments_on_TIFF.ipynb#3.-Accessing-partial-tiles-randomly-from-multiple-TIFF-files) (this usually happens for **training** use cases), using a cache could be meaningless." + ] + }, + { + "cell_type": "markdown", + "id": "e952a222", + "metadata": {}, + "source": [ + "## Enabling cache\n", + "\n", + "Currently, cuCIM supports the following three strategies:\n", + "\n", + " - `nocache`\n", + " - `per_process`\n", + " - `shared_memory` (interprocess)\n", + "\n", + "\n", + "**1) `nocache`**\n", + "\n", + "No cache.\n", + "\n", + "By default, this cache strategy is used.\n", + "With this strategy, the behavior is the same as one before `v20.06.00`.\n", + "\n", + "**2) `per_process`**\n", + "\n", + "The cache memory is shared among threads.\n", + "\n", + "**3) `shared_memory`**\n", + "\n", + "The cache memory is shared among processes.\n", + "\n", + "### Getting cache setting\n", + "\n", + "`CuImage.cache()` would return an object that can control the current cache. The object has the following properties:\n", + "\n", + "- `type`: The type (strategy) name\n", + "- `memory_size`: The number of bytes used in the cache memory\n", + "- `memory_capacity`: The maximum number of bytes that can be allocated (used) in the cache memory\n", + "- `free_memory`: The number of bytes available in the cache memory\n", + "- `size`: The number of cache items used\n", + "- `capacity`: The maximum number of cache items that can be created\n", + "- `hit_count`: The cache hit count\n", + "- `miss_count`: The cache miss count\n", + "- `config`: A configuration dictionary that was used for configuring cache.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ac9aa319", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " type: CacheType.NoCache(0)\n", + "memory_size: 0/0\n", + "free_memory: 0\n", + " size: 0/0\n", + " hit_count: 0\n", + " miss_count: 0\n", + " config: {'type': 'nocache', 'memory_capacity': 1024, 'capacity': 5461, 'mutex_pool_capacity': 11117, 'list_padding': 10000, 'extra_shared_memory_size': 100, 'record_stat': False}\n" + ] + } + ], + "source": [ + "from cucim import CuImage\n", + "\n", + "cache = CuImage.cache()\n", + "\n", + "print(f' type: {cache.type}({int(cache.type)})')\n", + "print(f'memory_size: {cache.memory_size}/{cache.memory_capacity}')\n", + "print(f'free_memory: {cache.free_memory}')\n", + "print(f' size: {cache.size}/{cache.capacity}')\n", + "print(f' hit_count: {cache.hit_count}')\n", + "print(f' miss_count: {cache.miss_count}')\n", + "print(f' config: {cache.config}')\n" + ] + }, + { + "cell_type": "markdown", + "id": "f057a11a", + "metadata": {}, + "source": [ + "### Changing Cache Setting\n", + "\n", + "Cache configuration can be changed by adding parameters to `cache()` method.\n", + "\n", + "The following parameters are available:\n", + "\n", + "- `type`: The type (strategy) name. Default to 'no_cache'.\n", + "- `memory_capacity`: The maximum number of mebibytes (`MiB`, 2^20) that can be allocated (used) in the cache memory. Default to `1024`.\n", + "- `capacity`: The maximum number of cache items that can be created. Default to `5461` (= (\\ x 2^20) / (256x256x3)).\n", + "- `mutex_pool_capacity`: The mutex pool size. Default to `11117`.\n", + "- `list_padding`: The number of additional items used for the internal circular queue. Default to `10000`.\n", + "- `extra_shared_memory_size`: The size of additional memory allocation (in MiB) for shared_memory allocator in `shared_process` strategy. Default to `100`.\n", + "- `record_stat`: If the cache statistic should be recorded or not. Default to `False`.\n", + "\n", + "In most cases, `type`(required) and `memory_capacity` are used." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e7d3090d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " type: CacheType.PerProcess(1)\n", + "memory_size: 0/2147483648\n", + "free_memory: 2147483648\n", + " size: 0/10922\n", + " hit_count: 0\n", + " miss_count: 0\n", + " config: {'type': 'per_process', 'memory_capacity': 2048, 'capacity': 10922, 'mutex_pool_capacity': 11117, 'list_padding': 10000, 'extra_shared_memory_size': 100, 'record_stat': False}\n" + ] + } + ], + "source": [ + "from cucim import CuImage\n", + "\n", + "cache = CuImage.cache('per_process', memory_capacity=2048)\n", + "print(f' type: {cache.type}({int(cache.type)})')\n", + "print(f'memory_size: {cache.memory_size}/{cache.memory_capacity}')\n", + "print(f'free_memory: {cache.free_memory}')\n", + "print(f' size: {cache.size}/{cache.capacity}')\n", + "print(f' hit_count: {cache.hit_count}')\n", + "print(f' miss_count: {cache.miss_count}')\n", + "print(f' config: {cache.config}')" + ] + }, + { + "cell_type": "markdown", + "id": "fbd45a9e", + "metadata": {}, + "source": [ + "## Choosing Proper Cache Memory Size\n", + "\n", + "It is important to select the appropriate cache memory size (capacity). Small cache memory size results in low cache hit rates. Conversely, if the cache memory size is too large, memory is wasted.\n", + "\n", + "For example, if the default tile size is 256x256 and the patch size to load is 224x224, the cache memory needs to be large enough to contain at least two rows of tiles in the image to avoid deleting the required cache entries while loading patches sequentially (left to right, top to bottom) from one TIFF file.\n", + "\n", + "![image](https://user-images.githubusercontent.com/1928522/120760720-4cbf2d00-c4c9-11eb-875b-b070203fd8e6.png)\n", + "\n", + "cuCIM provide a utility method (`cucim.clara.cache.preferred_memory_capacity()`) to calculate a preferred cache memory size for the given image (image size and tile size) and the patch size.\n", + "\n", + "Internal logic is available at \n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "bfb70aa4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "image size: [19920, 26420]\n", + "tile size: (256, 256)\n", + "memory_capacity : 74 MiB\n", + "memory_capacity2: 74 MiB\n", + "memory_capacity3: 74 MiB\n", + "= Cache Info =\n", + " type: CacheType.PerProcess(1)\n", + "memory_size: 0/77594624\n", + " size: 0/394\n" + ] + } + ], + "source": [ + "from cucim import CuImage\n", + "from cucim.clara.cache import preferred_memory_capacity\n", + "\n", + "img = CuImage('input/image.tif')\n", + "\n", + "image_size = img.size('XY') # same with `img.resolutions[\"level_dimensions\"][0]`\n", + "tile_size = img.resolutions['level_tile_sizes'][0] # default: (256, 256)\n", + "patch_size = (1024, 1024) # default: (256, 256)\n", + "bytes_per_pixel = 3 # default: 3\n", + "\n", + "print(f'image size: {image_size}')\n", + "print(f'tile size: {tile_size}')\n", + "\n", + "# Below three statements are the same.\n", + "memory_capacity = preferred_memory_capacity(img, patch_size=patch_size)\n", + "memory_capacity2 = preferred_memory_capacity(None, image_size, tile_size, patch_size, bytes_per_pixel)\n", + "memory_capacity3 = preferred_memory_capacity(None, image_size, patch_size=patch_size)\n", + "\n", + "print(f'memory_capacity : {memory_capacity} MiB')\n", + "print(f'memory_capacity2: {memory_capacity2} MiB')\n", + "print(f'memory_capacity3: {memory_capacity3} MiB')\n", + "\n", + "cache = CuImage.cache('per_process', memory_capacity=memory_capacity) # You can also manually set capacity` (e.g., `capacity=500`)\n", + "print('= Cache Info =')\n", + "print(f' type: {cache.type}({int(cache.type)})')\n", + "print(f'memory_size: {cache.memory_size}/{cache.memory_capacity}')\n", + "print(f' size: {cache.size}/{cache.capacity}')\n" + ] + }, + { + "cell_type": "markdown", + "id": "5898b317", + "metadata": {}, + "source": [ + "### Reserve More Cache Memory\n", + "\n", + "If more cache memory capacity is needed in runtime, you can use `reserve()` method.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "61801fe7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "memory_capacity : 30 MiB\n", + "new_memory_capacity: 44 MiB\n", + "\n", + "= Cache Info =\n", + " type: CacheType.PerProcess(1)\n", + "memory_size: 0/31457280\n", + " size: 0/160\n", + "\n", + "= Cache Info (update memory capacity) =\n", + " type: CacheType.PerProcess(1)\n", + "memory_size: 0/46137344\n", + " size: 0/234\n", + "\n", + "= Cache Info (update memory capacity & capacity) =\n", + " type: CacheType.PerProcess(1)\n", + "memory_size: 0/46137344 # smaller `memory_capacity` value does not change this\n", + " size: 0/500\n", + "\n", + "= Cache Info (no cache) =\n", + " type: CacheType.NoCache(0)\n", + "memory_size: 0/0\n", + " size: 0/0\n" + ] + } + ], + "source": [ + "from cucim import CuImage\n", + "from cucim.clara.cache import preferred_memory_capacity\n", + "\n", + "img = CuImage('input/image.tif')\n", + "\n", + "memory_capacity = preferred_memory_capacity(img, patch_size=(256, 256))\n", + "new_memory_capacity = preferred_memory_capacity(img, patch_size=(512, 512))\n", + "\n", + "print(f'memory_capacity : {memory_capacity} MiB')\n", + "print(f'new_memory_capacity: {new_memory_capacity} MiB')\n", + "print()\n", + "\n", + "cache = CuImage.cache('per_process', memory_capacity=memory_capacity)\n", + "print('= Cache Info =')\n", + "print(f' type: {cache.type}({int(cache.type)})')\n", + "print(f'memory_size: {cache.memory_size}/{cache.memory_capacity}')\n", + "print(f' size: {cache.size}/{cache.capacity}')\n", + "print()\n", + "\n", + "cache.reserve(new_memory_capacity)\n", + "print('= Cache Info (update memory capacity) =')\n", + "print(f' type: {cache.type}({int(cache.type)})')\n", + "print(f'memory_size: {cache.memory_size}/{cache.memory_capacity}')\n", + "print(f' size: {cache.size}/{cache.capacity}')\n", + "print()\n", + "\n", + "cache.reserve(memory_capacity, capacity=500)\n", + "print('= Cache Info (update memory capacity & capacity) =')\n", + "print(f' type: {cache.type}({int(cache.type)})')\n", + "print(f'memory_size: {cache.memory_size}/{cache.memory_capacity} # smaller `memory_capacity` value does not change this')\n", + "print(f' size: {cache.size}/{cache.capacity}')\n", + "print()\n", + "\n", + "cache = CuImage.cache('no_cache')\n", + "print('= Cache Info (no cache) =')\n", + "print(f' type: {cache.type}({int(cache.type)})')\n", + "print(f'memory_size: {cache.memory_size}/{cache.memory_capacity}')\n", + "print(f' size: {cache.size}/{cache.capacity}')\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "f8ffe4cb", + "metadata": {}, + "source": [ + "## Profiling Cache Hit/Miss\n", + "\n", + "If you add an argument `record_stat=True` to `CuImage.cache()` method, cache statistics is recorded.\n", + "\n", + "Cache hit/miss count is accessible through `hit_count`/`miss_count` property of the cache object.\n", + "\n", + "You can get/set/unset the recording through `record()` method.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "91587c98", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cache hit: 0, chche miss: 1\n", + "cache hit: 1, chche miss: 1\n", + "cache hit: 2, chche miss: 1\n", + "Is recorded: True\n", + "Is recorded: False\n", + "cache hit: 0, chche miss: 0\n", + "\n", + " type: CacheType.PerProcess(1)\n", + "memory_size: 196608/31457280\n", + "free_memory: 31260672\n", + " size: 1/160\n", + "\n", + " type: CacheType.NoCache(0)\n", + "memory_size: 0/0\n", + "free_memory: 0\n", + " size: 0/0\n" + ] + } + ], + "source": [ + "from cucim import CuImage\n", + "from cucim.clara.cache import preferred_memory_capacity\n", + "\n", + "img = CuImage('input/image.tif')\n", + "memory_capacity = preferred_memory_capacity(img, patch_size=(256, 256))\n", + "cache = CuImage.cache('per_process', memory_capacity=memory_capacity, record_stat=True)\n", + "\n", + "img.read_region((0,0), (100,100))\n", + "print(f'cache hit: {cache.hit_count}, chche miss: {cache.miss_count}')\n", + "\n", + "region = img.read_region((0,0), (100,100))\n", + "print(f'cache hit: {cache.hit_count}, chche miss: {cache.miss_count}')\n", + "\n", + "region = img.read_region((0,0), (100,100))\n", + "print(f'cache hit: {cache.hit_count}, chche miss: {cache.miss_count}')\n", + "\n", + "print(f'Is recorded: {cache.record()}')\n", + "\n", + "cache.record(False)\n", + "print(f'Is recorded: {cache.record()}')\n", + "\n", + "region = img.read_region((0,0), (100,100))\n", + "print(f'cache hit: {cache.hit_count}, chche miss: {cache.miss_count}')\n", + "print()\n", + "\n", + "print(f' type: {cache.type}({int(cache.type)})')\n", + "print(f'memory_size: {cache.memory_size}/{cache.memory_capacity}')\n", + "print(f'free_memory: {cache.free_memory}')\n", + "print(f' size: {cache.size}/{cache.capacity}')\n", + "print()\n", + "\n", + "cache = CuImage.cache('no_cache')\n", + "print(f' type: {cache.type}({int(cache.type)})')\n", + "print(f'memory_size: {cache.memory_size}/{cache.memory_capacity}')\n", + "print(f'free_memory: {cache.free_memory}')\n", + "print(f' size: {cache.size}/{cache.capacity}')\n" + ] + }, + { + "cell_type": "markdown", + "id": "d4b4b55e", + "metadata": {}, + "source": [ + "## Considerations in Multi-threading/processing Environment\n", + "\n", + "\n", + "### `per_process` strategy\n", + "\n", + "#### Cache memory\n", + "\n", + "If used in the multi-threading environment and each thread is reading the different part of the image sequentially, please consider increasing cache memory size than the size suggested by `cucim.clara.cache.preferred_memory_capacity()` to avoid dropping necessary cache items.\n", + "\n", + "If used in the multi-processing environment, the cache memory size allocated can be `(# of processes) x (cache memory capacity)`. \n", + "\n", + "Please be careful not to oversize the memory allocated by the cache.\n", + "\n", + "\n", + "#### Cache Statistics\n", + "\n", + "If used in the multi-processing environment (e.g, using `concurrent.futures.ProcessPoolExecutor()`), cache hit count (`hit_count`) and miss count (`miss_count`) wouldn't be recorded in the main process's cache object.\n", + "\n", + "\n", + "### `shared_memory` strategy\n", + "\n", + "In general, `shared_memory` strategy has more overhead than `per_process` strategy. However, it is recommended that you select this strategy if you want to use a fixed size of cache memory regardless of the number of processes.\n", + "\n", + "Note that, this strategy pre-allocates the cache memory in the shared memory and allocates more memory (as specified in `extra_shared_memory_size` parameter) than the requested cache memory size (capacity) for the memory allocator to handle memory segments.\n", + "\n", + "\n", + "#### Cache memory\n", + "\n", + "Since the cache memory would be shared by multiple threads/processes, you will need to set enough cache memory to avoid dropping necessary cache items.\n" + ] + }, + { + "cell_type": "markdown", + "id": "f5b247db", + "metadata": {}, + "source": [ + "## Setting Default Cache Configuration\n", + "\n", + "The configuration for cuCIM can be specified in `.cucim.json` file and user can set a default cache settings there.\n", + "\n", + "cuCIM finds `.cucim.json` file from the following order:\n", + "\n", + "1. The current folder\n", + "2. `$HOME/.cucim.json`\n", + "\n", + "The configuration for the cache can be specified like below.\n", + "\n", + "```jsonc\n", + "\n", + "{\n", + " // This is actually JSONC file so comments are available.\n", + " \"cache\": {\n", + " \"type\": \"nocache\",\n", + " \"memory_capacity\": 1024,\n", + " \"capacity\": 5461,\n", + " \"mutex_pool_capacity\": 11117,\n", + " \"list_padding\": 10000,\n", + " \"extra_shared_memory_size\": 100,\n", + " \"record_stat\": false\n", + " }\n", + "}\n", + "```\n", + "\n", + "You can write the current cache configuration into the file like below:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1dda19e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"cache\": {\n", + " \"type\": \"nocache\",\n", + " \"memory_capacity\": 1024,\n", + " \"capacity\": 5461,\n", + " \"mutex_pool_capacity\": 11117,\n", + " \"list_padding\": 10000,\n", + " \"extra_shared_memory_size\": 100,\n", + " \"record_stat\": false\n", + " }\n", + "}\n" + ] + } + ], + "source": [ + "import json\n", + "from cucim import CuImage\n", + "\n", + "cache = CuImage.cache()\n", + "config_data = {'cache': cache.config}\n", + "json_text = json.dumps(config_data, indent=4)\n", + "print(json_text)\n", + "\n", + "# Save into the configuration file.\n", + "with open('.cucim.json', 'w') as fp:\n", + " fp.write(json_text)" + ] + }, + { + "cell_type": "markdown", + "id": "60c2d934", + "metadata": {}, + "source": [ + "### Cache Mechanism Used in Other Libraries (OpenSlide and rasterio)\n", + "\n", + "Other libraries have the following strategies for the cache.\n", + "\n", + "- [OpenSlide](https://openslide.org/) \n", + " - 1024 x 1024 x 30 bytes (30MiB) per file handle for cache ==> 160 (RGB) or 120 (ARGB) 256x256 tiles\n", + " - Not configurable\n", + "- [rasterio](https://rasterio.readthedocs.io/en/latest/)\n", + " - 5% of available system memory per process by default (e.g., 32 GB of free memory => 1.6 GB of cache memory allocated).\n", + " - Configurable through [environment module](https://rasterio.readthedocs.io/en/latest/api/rasterio.env.html)\n" + ] + }, + { + "cell_type": "markdown", + "id": "5148543f", + "metadata": {}, + "source": [ + "## Results\n", + "\n", + "cuCIM has a similar performance gain with the aligned case when the patch and tile layout are not aligned.\n", + "\n", + "We compared performance against OpenSlide and rasterio.\n", + "\n", + "For the cache memory size(capacity) setting, we used a similar approach with rasterio (5% of available system memory).\n", + "\n", + "\n", + "### System Information\n", + "\n", + "- OS: Ubuntu 18.04\n", + "- CPU: [Intel(R) Core(TM) i7-7800X CPU @ 3.50GHz](https://www.cpubenchmark.net/cpu.php?cpu=Intel+Core+i7-7800X+%40+3.50GHz&id=3037)\n", + "- Memory: 64GB (G-Skill DDR4 2133 16GB X 4)\n", + "- Storage\n", + " - SATA SSD: [Samsung SSD 850 EVO 1TB](https://www.samsung.com/us/computing/memory-storage/solid-state-drives/ssd-850-evo-2-5-sata-iii-1tb-mz-75e1t0b-am/)\n", + " \n", + "### Experiment Setup\n", + "+ Use read_region() APIs to read all patches (256x256 size each) of a whole slide image (.tif) at the largest resolution level (92,344 x 81,017. Internal tile size is 256 x 256 with 95% JPEG compression quality level) on multithread/multiprocess environment.\n", + " - Original whole slide image (.svs : 1.6GB) was converted into .tif file (3.2GB) using OpenSlide & tifffile library in this experiment (image2.tif).\n", + " * Original image can be downloaded from here(https://drive.google.com/drive/u/0/folders/0B--ztKW0d17XYlBqOXppQmw0M2M , TUPAC-TR-488.svs)\n", + "+ Two different job configurations\n", + " - multithreading: spread workload into multiple threads\n", + " - multiprocessing: spread workload into multiple processes\n", + "+ Two different read configurations for each job configuration\n", + " - unaligned/nocache: (256x256)-patch-reads start from (1,1). e.g., read the region (1,1)-(257,257) then, read the region (257,1)-(513,257), ...\n", + " - aligned: (256x256)-patch-reads start from (0,0). OpenSlide's internal cache mechanism does not affect this case.\n", + "+ Took about 10 samples due to the time to conduct the experiment so there could have some variation in the results.\n", + "+ Note that this experiment doesn’t isolate the effect of system cache (page cache) that we excluded its effect on C++ API benchmark[discard_cache] so IO time itself could be short for both libraries.\n", + "\n", + "### Aligned Case (`per_process`, JPEG-compressed TIFF file)\n", + "\n", + "![image](https://user-images.githubusercontent.com/1928522/120849255-ae63b380-c52a-11eb-80c3-8411990e6c25.png)\n", + "\n", + "\n", + "### Unaligned Case (`per_process`, JPEG-compressed TIFF file)\n", + "\n", + "![image](https://user-images.githubusercontent.com/1928522/120849176-92601200-c52a-11eb-9c38-92e55c3d413a.png)\n", + "\n", + "### Overall Performance of `per_process` Compared with `no_cache` for Unaligned Case\n", + "\n", + "![image](https://user-images.githubusercontent.com/1928522/118345306-494b0e00-b4e8-11eb-88ca-c835c70aa037.png)\n", + "\n", + "\n", + "The detailed data is available [here](https://docs.google.com/spreadsheets/d/1eAqs24p25p6iIzZdUlnWNlk_RsrdRfEkIOYB9Xgu67c/edit?usp=sharing).\n" + ] + }, + { + "cell_type": "markdown", + "id": "d1c665c5", + "metadata": {}, + "source": [ + "\n", + "## Room for Improvement\n", + "\n", + "### Using of a Memory Pool\n", + "\n", + "`per_process` strategy performs better than `shared_memory` strategy, and both strategies perform less than `nocache` strategy when underlying tiles and patches are aligned.\n", + "- `shared_memory` strategy does some additional operations compared with `per_process` strategy, and both strategies have some overhead using cache (such as memory allocation for cache item/indirect function calls)\n", + "\n", + "=> All three strategies (including `nocache`) can have benefited if we allocate CPU/GPU memory for tiles from a fixed-sized cache memory pool (using [RMM](https://docs.rapids.ai/api/rmm/stable/basics.html) and/or [PMR](https://en.cppreference.com/w/cpp/memory/synchronized_pool_resource)) instead of calling malloc() to allocate memory.\n", + "\n", + "### Supporting Generator (iterator)\n", + "\n", + "When patches to read in an image can be determined in advance (inference use case), we can load/prefetch entire compressed/decompressed image data to the memory and provide Python generator(iterator) to get a series of patches efficiently for inference use cases. \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "bf312216", + "metadata": {}, + "source": [ + "## Appendix\n", + "\n", + "### Experiment Code\n", + "\n", + "```python\n", + "#\n", + "# Copyright (c) 2021, NVIDIA CORPORATION.\n", + "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# http://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License.\n", + "#\n", + "\n", + "import concurrent.futures\n", + "from contextlib import ContextDecorator\n", + "from datetime import datetime\n", + "from itertools import repeat\n", + "from time import perf_counter\n", + "\n", + "import numpy as np\n", + "import rasterio\n", + "from cucim import CuImage\n", + "from openslide import OpenSlide\n", + "from rasterio.windows import Window\n", + "\n", + "\n", + "class Timer(ContextDecorator):\n", + " def __init__(self, message):\n", + " self.message = message\n", + " self.end = None\n", + "\n", + " def elapsed_time(self):\n", + " self.end = perf_counter()\n", + " return self.end - self.start\n", + "\n", + " def __enter__(self):\n", + " self.start = perf_counter()\n", + " return self\n", + "\n", + " def __exit__(self, exc_type, exc, exc_tb):\n", + " if not self.end:\n", + " self.elapsed_time()\n", + " print(\"{} : {}\".format(self.message, self.end - self.start))\n", + "\n", + "\n", + "def load_tile_openslide(slide, start_loc, patch_size):\n", + " _ = slide.read_region(start_loc, 0, [patch_size, patch_size])\n", + "\n", + "def load_tile_openslide_chunk(inp_file, start_loc_list, patch_size):\n", + " with OpenSlide(inp_file) as slide:\n", + " for start_loc in start_loc_list:\n", + " region = slide.read_region(start_loc, 0, [patch_size, patch_size])\n", + "\n", + "def load_tile_cucim(slide, start_loc, patch_size):\n", + " _ = slide.read_region(start_loc, [patch_size, patch_size], 0)\n", + "\n", + "def load_tile_cucim_chunk(inp_file, start_loc_list, patch_size):\n", + " try:\n", + " slide = CuImage(inp_file)\n", + " for start_loc in start_loc_list:\n", + " region = slide.read_region(start_loc, [patch_size, patch_size], 0)\n", + " except Exception as e:\n", + " print(e)\n", + "\n", + "identity = rasterio.Affine(1, 0, 0, 0, 1, 0)\n", + "def load_tile_rasterio(slide, start_loc, tile_size):\n", + " _ = np.moveaxis(slide.read([1,2,3],\n", + " window=Window.from_slices((start_loc[0], start_loc[0] + tile_size),(start_loc[1], start_loc[1] + tile_size))), 0, -1)\n", + "\n", + "def load_tile_rasterio_chunk(input_file, start_loc_list, patch_size):\n", + " identity = rasterio.Affine(1, 0, 0, 0, 1, 0)\n", + " slide = rasterio.open(input_file, transform = identity, num_threads=1)\n", + " for start_loc in start_loc_list:\n", + " _ = np.moveaxis(slide.read([1,2,3],\n", + " window=Window.from_slices((start_loc[0], start_loc[0] + patch_size),(start_loc[1], start_loc[1] + patch_size))), 0, -1)\n", + "\n", + "\n", + "def load_tile_openslide_chunk_mp(inp_file, start_loc_list, patch_size):\n", + " with OpenSlide(inp_file) as slide:\n", + " for start_loc in start_loc_list:\n", + " region = slide.read_region(start_loc, 0, [patch_size, patch_size])\n", + "\n", + "def load_tile_cucim_chunk_mp(inp_file, start_loc_list, patch_size):\n", + " slide = CuImage(inp_file)\n", + " for start_loc in start_loc_list:\n", + " region = slide.read_region(start_loc, [patch_size, patch_size], 0)\n", + "\n", + "def load_tile_rasterio_chunk_mp(input_file, start_loc_list, patch_size):\n", + " slide = rasterio.open(input_file, num_threads=1)\n", + " for start_loc in start_loc_list:\n", + " region = np.moveaxis(slide.read([1,2,3],\n", + " window=Window.from_slices((start_loc[0], start_loc[0] + patch_size),(start_loc[1], start_loc[1] + patch_size))), 0, -1)\n", + "\n", + "def experiment_thread(cache_strategy, input_file, num_threads, start_location, patch_size):\n", + " import psutil\n", + " print(\" \", psutil.virtual_memory())\n", + " for num_workers in range(1, num_threads + 1): # range(1, num_threads + 1): # (num_threads,):\n", + " openslide_time = 1\n", + " cucim_time = 1\n", + " rasterio_time = 1\n", + "\n", + " with OpenSlide(input_file) as slide:\n", + " width, height = slide.dimensions\n", + "\n", + " start_loc_data = [(sx, sy)\n", + " for sy in range(start_location, height, patch_size)\n", + " for sx in range(start_location, width, patch_size)]\n", + " chunk_size = len(start_loc_data) // num_workers\n", + " start_loc_list_iter = [start_loc_data[i:i+chunk_size] for i in range(0, len(start_loc_data), chunk_size)]\n", + " with Timer(\" Thread elapsed time (OpenSlide)\") as timer:\n", + " with concurrent.futures.ThreadPoolExecutor(\n", + " max_workers=num_workers\n", + " ) as executor:\n", + " executor.map(\n", + " load_tile_openslide_chunk,\n", + " repeat(input_file),\n", + " start_loc_list_iter,\n", + " repeat(patch_size)\n", + " )\n", + " openslide_time = timer.elapsed_time()\n", + " print(\" \", psutil.virtual_memory())\n", + "\n", + " cache_size = psutil.virtual_memory().available // 1024 // 1024 // 20\n", + " cache = CuImage.cache(cache_strategy, memory_capacity=cache_size, record_stat=True)\n", + " cucim_time = 0\n", + " slide = CuImage(input_file)\n", + " start_loc_data = [(sx, sy)\n", + " for sy in range(start_location, height, patch_size)\n", + " for sx in range(start_location, width, patch_size)]\n", + " chunk_size = len(start_loc_data) // num_workers\n", + " start_loc_list_iter = [start_loc_data[i:i+chunk_size] for i in range(0, len(start_loc_data), chunk_size)]\n", + " with Timer(\" Thread elapsed time (cuCIM)\") as timer:\n", + " with concurrent.futures.ThreadPoolExecutor(\n", + " max_workers=num_workers\n", + " ) as executor:\n", + " executor.map(\n", + " load_tile_cucim_chunk,\n", + " repeat(input_file),\n", + " start_loc_list_iter,\n", + " repeat(patch_size)\n", + " )\n", + " cucim_time = timer.elapsed_time()\n", + " print(f\" hit: {cache.hit_count} miss: {cache.miss_count}\")\n", + " print(\" \", psutil.virtual_memory())\n", + "\n", + " start_loc_data = [(sx, sy)\n", + " for sy in range(start_location, height, patch_size)\n", + " for sx in range(start_location, width, patch_size)]\n", + " chunk_size = len(start_loc_data) // num_workers\n", + " start_loc_list_iter = [start_loc_data[i:i+chunk_size] for i in range(0, len(start_loc_data), chunk_size)]\n", + "\n", + " with Timer(\" Thread elapsed time (rasterio)\") as timer:\n", + " with concurrent.futures.ThreadPoolExecutor(\n", + " max_workers=num_workers\n", + " ) as executor:\n", + " executor.map(\n", + " load_tile_rasterio_chunk,\n", + " repeat(input_file),\n", + " start_loc_list_iter,\n", + " repeat(patch_size)\n", + " )\n", + " rasterio_time = timer.elapsed_time()\n", + "\n", + " print(\" \", psutil.virtual_memory())\n", + " output_text = f\"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')},thread,{cache_strategy},{input_file},{start_location},{patch_size},{num_workers},{openslide_time},{cucim_time},{rasterio_time},{openslide_time / cucim_time},{rasterio_time / cucim_time},{cache_size},{cache.hit_count},{cache.miss_count}\\n\"\n", + " with open(\"experiment.txt\", \"a+\") as f:\n", + " f.write(output_text)\n", + " print(output_text)\n", + "\n", + "def experiment_process(cache_strategy, input_file, num_processes, start_location, patch_size):\n", + " import psutil\n", + " print(\" \", psutil.virtual_memory())\n", + " for num_workers in range(1, num_processes + 1):\n", + " openslide_time = 1\n", + " cucim_time = 1\n", + " rasterio_time = 1\n", + " # (92344 x 81017)\n", + " with OpenSlide(input_file) as slide:\n", + " width, height = slide.dimensions\n", + "\n", + " start_loc_data = [(sx, sy)\n", + " for sy in range(start_location, height, patch_size)\n", + " for sx in range(start_location, width, patch_size)]\n", + " chunk_size = len(start_loc_data) // num_workers\n", + " start_loc_list_iter = [start_loc_data[i:i+chunk_size] for i in range(0, len(start_loc_data), chunk_size)]\n", + "\n", + " with Timer(\" Process elapsed time (OpenSlide)\") as timer:\n", + " with concurrent.futures.ProcessPoolExecutor(\n", + " max_workers=num_workers\n", + " ) as executor:\n", + " executor.map(\n", + " load_tile_openslide_chunk_mp,\n", + " repeat(input_file),\n", + " start_loc_list_iter,\n", + " repeat(patch_size)\n", + " )\n", + " openslide_time = timer.elapsed_time()\n", + " print(\" \", psutil.virtual_memory())\n", + "\n", + " cache_size = psutil.virtual_memory().available // 1024 // 1024 // 20\n", + " if cache_strategy == \"shared_memory\":\n", + " cache_size = cache_size * num_workers\n", + " cache = CuImage.cache(cache_strategy, memory_capacity=cache_size, record_stat=True)\n", + " cucim_time = 0\n", + " slide = CuImage(input_file)\n", + " start_loc_data = [(sx, sy)\n", + " for sy in range(start_location, height, patch_size)\n", + " for sx in range(start_location, width, patch_size)]\n", + " chunk_size = len(start_loc_data) // num_workers\n", + " start_loc_list_iter = [start_loc_data[i:i+chunk_size] for i in range(0, len(start_loc_data), chunk_size)]\n", + "\n", + " with Timer(\" Process elapsed time (cuCIM)\") as timer:\n", + " with concurrent.futures.ProcessPoolExecutor(\n", + " max_workers=num_workers\n", + " ) as executor:\n", + " executor.map(\n", + " load_tile_cucim_chunk_mp,\n", + " repeat(input_file),\n", + " start_loc_list_iter,\n", + " repeat(patch_size)\n", + " )\n", + " cucim_time = timer.elapsed_time()\n", + " print(\" \", psutil.virtual_memory())\n", + "\n", + " rasterio_time = 0\n", + " start_loc_data = [(sx, sy)\n", + " for sy in range(start_location, height, patch_size)\n", + " for sx in range(start_location, width, patch_size)]\n", + " chunk_size = len(start_loc_data) // num_workers\n", + " start_loc_list_iter = [start_loc_data[i:i+chunk_size] for i in range(0, len(start_loc_data), chunk_size)]\n", + "\n", + " with Timer(\" Process elapsed time (rasterio)\") as timer:\n", + " with concurrent.futures.ProcessPoolExecutor(\n", + " max_workers=num_workers\n", + " ) as executor:\n", + " executor.map(\n", + " load_tile_rasterio_chunk_mp,\n", + " repeat(input_file),\n", + " start_loc_list_iter,\n", + " repeat(patch_size)\n", + " )\n", + " rasterio_time = timer.elapsed_time()\n", + "\n", + " print(\" \", psutil.virtual_memory())\n", + " output_text = f\"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')},process,{cache_strategy},{input_file},{start_location},{patch_size},{num_workers},{openslide_time},{cucim_time},{rasterio_time},{openslide_time / cucim_time},{rasterio_time / cucim_time},{cache_size},{cache.hit_count},{cache.miss_count}\\n\"\n", + " with open(\"experiment.txt\", \"a+\") as f:\n", + " f.write(output_text)\n", + " print(output_text)\n", + "\n", + "experiment_thread(\"nocache\", \"notebooks/input/image.tif\", 12, 0, 256)\n", + "experiment_process(\"nocache\", \"notebooks/input/image.tif\", 12, 0, 256)\n", + "experiment_thread(\"per_process\", \"notebooks/input/image.tif\", 12, 0, 256)\n", + "experiment_process(\"per_process\", \"notebooks/input/image.tif\", 12, 0, 256)\n", + "experiment_thread(\"shared_memory\", \"notebooks/input/image.tif\", 12, 0, 256)\n", + "experiment_process(\"shared_memory\", \"notebooks/input/image.tif\", 12, 0, 256)\n", + "\n", + "experiment_thread(\"nocache\", \"notebooks/input/image.tif\", 12, 1, 256)\n", + "experiment_process(\"nocache\", \"notebooks/input/image.tif\", 12, 1, 256)\n", + "experiment_thread(\"per_process\", \"notebooks/input/image.tif\", 12, 1, 256)\n", + "experiment_process(\"per_process\", \"notebooks/input/image.tif\", 12, 1, 256)\n", + "experiment_thread(\"shared_memory\", \"notebooks/input/image.tif\", 12, 1, 256)\n", + "experiment_process(\"shared_memory\", \"notebooks/input/image.tif\", 12, 1, 256)\n", + "\n", + "experiment_thread(\"nocache\", \"notebooks/input/image2.tif\", 12, 0, 256)\n", + "experiment_process(\"nocache\", \"notebooks/input/image2.tif\", 12, 0, 256)\n", + "experiment_thread(\"per_process\", \"notebooks/input/image2.tif\", 12, 0, 256)\n", + "experiment_process(\"per_process\", \"notebooks/input/image2.tif\", 12, 0, 256)\n", + "experiment_thread(\"shared_memory\", \"notebooks/input/image2.tif\", 12, 0, 256)\n", + "experiment_process(\"shared_memory\", \"notebooks/input/image2.tif\", 12, 0, 256)\n", + "\n", + "experiment_thread(\"nocache\", \"notebooks/input/image2.tif\", 12, 1, 256)\n", + "experiment_process(\"nocache\", \"notebooks/input/image2.tif\", 12, 1, 256)\n", + "experiment_thread(\"per_process\", \"notebooks/input/image2.tif\", 12, 1, 256)\n", + "experiment_process(\"per_process\", \"notebooks/input/image2.tif\", 12, 1, 256)\n", + "experiment_thread(\"shared_memory\", \"notebooks/input/image2.tif\", 12, 1, 256)\n", + "experiment_process(\"shared_memory\", \"notebooks/input/image2.tif\", 12, 1, 256)\n", + "\n", + "experiment_thread(\"nocache\", \"notebooks/0486052bb.tiff\", 12, 0, 1024)\n", + "experiment_process(\"nocache\", \"notebooks/0486052bb.tiff\", 12, 0, 1024)\n", + "experiment_thread(\"per_process\", \"notebooks/0486052bb.tiff\", 12, 0, 1024)\n", + "experiment_process(\"per_process\", \"notebooks/0486052bb.tiff\", 12, 0, 1024)\n", + "experiment_thread(\"shared_memory\", \"notebooks/0486052bb.tiff\", 12, 0, 1024)\n", + "experiment_process(\"shared_memory\", \"notebooks/0486052bb.tiff\", 12, 0, 1024)\n", + "\n", + "experiment_thread(\"nocache\", \"notebooks/0486052bb.tiff\", 12, 1, 1024)\n", + "experiment_process(\"nocache\", \"notebooks/0486052bb.tiff\", 12, 1, 1024)\n", + "experiment_thread(\"per_process\", \"notebooks/0486052bb.tiff\", 12, 1, 1024)\n", + "experiment_process(\"per_process\", \"notebooks/0486052bb.tiff\", 12, 1, 1024)\n", + "experiment_thread(\"shared_memory\", \"notebooks/0486052bb.tiff\", 12, 1, 1024)\n", + "experiment_process(\"shared_memory\", \"notebooks/0486052bb.tiff\", 12, 1, 1024)\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/Welcome.ipynb b/notebooks/Welcome.ipynb index f3480a05e..a97345df8 100644 --- a/notebooks/Welcome.ipynb +++ b/notebooks/Welcome.ipynb @@ -10,6 +10,7 @@ "## `cucim.clara` package\n", "\n", "- [Basic Usage](Basic_Usage.ipynb)\n", + "- [Using Cache](Using_Cache.ipynb)\n", "- [Accessing File with GDS](Accessing_File_with_GDS.ipynb)\n", "- [File-access Experiments on TIFF File](File-access_Experiments_on_TIFF.ipynb)\n", "- [Multi-thread and Multi-process Tests](Multi-thread_and_Multi-process_Tests.ipynb)\n", @@ -43,7 +44,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.8.5" } }, "nbformat": 4, diff --git a/notebooks/input/README.md b/notebooks/input/README.md index 681f354db..7e0e22f83 100644 --- a/notebooks/input/README.md +++ b/notebooks/input/README.md @@ -1,22 +1,18 @@ # Test Dataset -TUPAC-TR-488.svs and TUPAC-TR-467.svs are from the dataset -of [Tumor Proliferation Assessment Challenge 2016](http://tupac.tue-image.nl/node/3) (TUPAC16 | MICCAI Grand Challenge) which are publicly -available through [The Cancer Genome Atlas (TCGA)](https://www.cancer.gov/about-nci/organization/ccg/research/structural-genomics/tcga) under [CC BY 3.0 License](https://creativecommons.org/licenses/by/3.0/). +TUPAC-TR-488.svs and TUPAC-TR-467.svs are breast cancer cases from the dataset +of Tumor Proliferation Assessment Challenge 2016 (TUPAC16 | MICCAI Grand Challenge) which are publicly +available through [The Cancer Genome Atlas (TCGA)](https://www.cancer.gov/about-nci/organization/ccg/research/structural-genomics/tcga). - Website: http://tupac.tue-image.nl/node/3 - Data link: https://drive.google.com/drive/u/0/folders/0B--ztKW0d17XYlBqOXppQmw0M2M + - TUPAC-TR-467.svs : https://portal.gdc.cancer.gov/files/575c0465-c4bc-4ea7-ab63-ba48aa5e374b + - TUPAC-TR-488.svs : https://portal.gdc.cancer.gov/files/e27c87c9-e163-4d55-8f27-4cc7dfca08d8 +- License: CC BY 3.0 (https://wiki.cancerimagingarchive.net/display/Public/TCGA-BRCA#3539225f58e64731d8e47d588cedd99d300d5d6) + - See LICENSE-3rdparty file ## Converted files - image.tif : 256x256 multi-resolution/tiled TIF conversion of TUPAC-TR-467.svs - image2.tif : 256x256 multi-resolution/tiled TIF conversion of TUPAC-TR-488.svs - -## How to download test image files - -Execute the following command from the cuCIM's repository root folder: - -```bash -./run download_testdata -``` \ No newline at end of file diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt index 63ad1d358..f1f8170ac 100644 --- a/python/CMakeLists.txt +++ b/python/CMakeLists.txt @@ -1,5 +1,5 @@ # -# Copyright (c) 2020, NVIDIA CORPORATION. +# Copyright (c) 2020-2021, NVIDIA CORPORATION. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -143,17 +143,24 @@ pybind11_add_module(cucim pybind11/cucim_py.h pybind11/cucim_pydoc.h pybind11/cucim_py.cpp - pybind11/io/init.h + pybind11/cache/cache_py.h + pybind11/cache/cache_pydoc.h + pybind11/cache/cache_py.cpp + pybind11/cache/image_cache_pydoc.h + pybind11/cache/image_cache_py.h + pybind11/cache/image_cache_py.cpp + pybind11/io/io_py.h pybind11/io/io_pydoc.h pybind11/io/io_py.cpp pybind11/io/device_pydoc.h pybind11/io/device_py.cpp - pybind11/filesystem/init.h + pybind11/filesystem/filesystem_py.h pybind11/filesystem/filesystem_pydoc.h pybind11/filesystem/filesystem_py.cpp + pybind11/filesystem/cufile_py.h pybind11/filesystem/cufile_pydoc.h pybind11/filesystem/cufile_py.cpp - pybind11/memory/init.h + pybind11/memory/memory_py.h pybind11/memory/memory_pydoc.h pybind11/memory/memory_py.cpp ) diff --git a/python/cucim/.bumpversion.cfg b/python/cucim/.bumpversion.cfg deleted file mode 100644 index 020baf3a0..000000000 --- a/python/cucim/.bumpversion.cfg +++ /dev/null @@ -1,32 +0,0 @@ -[bumpversion] -current_version = 0.19.0 -commit = False -tag = False - -[bumpversion:file:../../VERSION] -search = {current_version} -replace = {new_version} - -[bumpversion:file:VERSION] -search = {current_version} -replace = {new_version} - -[bumpversion:file:../../cpp/plugins/cucim.kit.cuslide/VERSION] -search = {current_version} -replace = {new_version} - -[bumpversion:file:docs/index.md] -search = [Version {current_version}](release_notes/v{current_version}.md) -replace = [Version {new_version}](release_notes/v{new_version}.md) - -[bumpversion:file:docs/getting_started/index.md] -search = v{current_version} -replace = v{new_version} - -[bumpversion:file:docs/getting_started/./index.md] -search = cucim.kit.cuslide@{current_version}.so -replace = cucim.kit.cuslide@{new_version}.so - -[bumpversion:file:../../cucim.code-workspace] -search = cucim.kit.cuslide@{current_version}.so -replace = cucim.kit.cuslide@{new_version}.so diff --git a/python/cucim/CHANGELOG.md b/python/cucim/CHANGELOG.md index c92544121..185797ff2 100644 --- a/python/cucim/CHANGELOG.md +++ b/python/cucim/CHANGELOG.md @@ -1,6 +1,12 @@ # Changelog +## [21.06.00](https://github.com/rapidsai/cucim/wiki/release_notes_v21.06.00) + +- Implement cache mechanism +- Add `__cuda_array_interface`. +- Fix a memory leak in Deflate decoder. + ## 0.19.0 (2021-04-19) - The first release of cuClaraImage + [cupyimg](https://github.com/mritools/cupyimg) as a single project `cuCIM`. diff --git a/python/cucim/VERSION b/python/cucim/VERSION index 1cf0537c3..caccd4086 100644 --- a/python/cucim/VERSION +++ b/python/cucim/VERSION @@ -1 +1 @@ -0.19.0 +21.06.00 diff --git a/python/cucim/docs/getting_started/index.md b/python/cucim/docs/getting_started/index.md index d1af3ac64..188dd341a 100644 --- a/python/cucim/docs/getting_started/index.md +++ b/python/cucim/docs/getting_started/index.md @@ -14,15 +14,15 @@ ## Installation -Please download the latest SDK package (`cuCIM-v0.19.0-linux.tar.gz`). +Please download the latest SDK package (`cuCIM-v21.06.00-linux.tar.gz`). Untar the downloaded file. ```bash -mkdir -p cuCIM-v0.19.0 -tar -xzvf cuCIM-v0.19.0-linux.tar.gz -C cuCIM-v0.19.0 +mkdir -p cuCIM-v21.06.00 +tar -xzvf cuCIM-v21.06.00-linux.tar.gz -C cuCIM-v21.06.00 -cd cuCIM-v0.19.0 +cd cuCIM-v21.06.00 ``` ## Run command @@ -147,7 +147,7 @@ Its execution would show some metadata information and create two files -- `outp ``` $ ./bin/tiff_image notebooks/input/image.tif . [Plugin: cucim.kit.cuslide] Loading... -[Plugin: cucim.kit.cuslide] Loading the dynamic library from: cucim.kit.cuslide@0.19.0.so +[Plugin: cucim.kit.cuslide] Loading the dynamic library from: cucim.kit.cuslide@21.06.00.so [Plugin: cucim.kit.cuslide] loaded successfully. Version: 0 Initializing plugin: cucim.kit.cuslide (interfaces: [cucim::io::IImageFormat v0.1]) (impl: cucim.kit.cuslide) is_loaded: true diff --git a/python/cucim/docs/index.md b/python/cucim/docs/index.md index 8e0e67d08..7f50c9018 100644 --- a/python/cucim/docs/index.md +++ b/python/cucim/docs/index.md @@ -18,7 +18,7 @@ development/index --> # cuCIM Documentation -Current latest version is [Version 0.19.0](release_notes/v0.19.0.md). +Current latest version is [Version 21.06.00](release_notes/v21.06.00.md). **cuCIM** a toolkit to provide GPU accelerated I/O, image processing & computer vision primitives for N-Dimensional images with a focus on biomedical imaging. diff --git a/python/cucim/docs/roadmap/index.md b/python/cucim/docs/roadmap/index.md index ebdf86764..3e78331f9 100644 --- a/python/cucim/docs/roadmap/index.md +++ b/python/cucim/docs/roadmap/index.md @@ -321,7 +321,6 @@ The following list is on the road |:smile:| - The PyPi package embeds CUDA runtime library. - https://github.com/pytorch/pytorch/issues/47268#issuecomment-721996861 - Move to Github Project -- Add `bump2version` command in `run` (version management) - Move `tox` setup from python folder to the project root folder - Setup Conda recipe - Setup automated test cases diff --git a/python/cucim/setup.cfg b/python/cucim/setup.cfg index da00f63dd..2a332d30e 100644 --- a/python/cucim/setup.cfg +++ b/python/cucim/setup.cfg @@ -2,13 +2,16 @@ VCS = git style = pep440 versionfile_source = src/cucim/_version.py -versionfile_build = src/cucim/_version.py +versionfile_build = cucim/_version.py tag_prefix = v parentdir_prefix = cucim- [bdist_wheel] universal = 0 +[egg_info] +egg_base = src + [flake8] max-line-length = 80 ignore = @@ -52,11 +55,11 @@ testpaths = tests [tool:isort] -force_single_line = True +force_single_line = False line_length = 80 known_first_party = cucim default_section = THIRDPARTY forced_separate = test_cucim skip = .tox,.eggs,ci/templates,build,dist,versioneer.py sections = FUTURE,STDLIB,THIRDPARTY,FIRSTPARTY,LOCALFOLDER -multi_line_output = 0 +multi_line_output = GRID diff --git a/python/cucim/setup.py b/python/cucim/setup.py index 47a4260e5..b1cdabad2 100755 --- a/python/cucim/setup.py +++ b/python/cucim/setup.py @@ -5,16 +5,13 @@ import io import sys -from glob import glob -from os.path import basename from os.path import dirname from os.path import join -from os.path import splitext from setuptools import find_packages from setuptools import setup -# import versioneer +import versioneer # Give setuptools a hint to complain if it's too old a version # 24.2.0 added the python_requires option @@ -31,13 +28,11 @@ def read(*names, **kwargs): ) as fh: return fh.read() -# lib_paths = list(map(lambda x: basename(x), glob("src/cucim/clara/*.so*"))) - opts = dict( name='cucim', version=read('VERSION').strip(), # versioneer.get_version(), - # cmdclass=versioneer.get_cmdclass() + cmdclass=versioneer.get_cmdclass(), license='Apache-2.0', description='cuCIM - an extensible toolkit designed to provide GPU accelerated I/O, computer vision & image processing primitives for N-Dimensional images with a focus on biomedical imaging.', # noqa long_description='%s\n%s' % ( @@ -49,14 +44,7 @@ def read(*names, **kwargs): url='https://github.com/rapidsai/cucim', packages=find_packages('src'), package_dir={'cucim': 'src/cucim'}, - py_modules=[splitext(basename(path))[0] for path in glob('src/*.py')], - # If True, the data files [of include_package_data] must be under version - # control or specified via the distutils' MANIFEST.in file - # (https://setuptools.readthedocs.io/en/latest/userguide/datafiles.html) include_package_data=True, - # package_data={ - # '': lib_paths, - # }, zip_safe=False, classifiers=[ # complete classifier list: diff --git a/python/cucim/src/cucim/__init__.py b/python/cucim/src/cucim/__init__.py index e892b7851..2ade85d92 100644 --- a/python/cucim/src/cucim/__init__.py +++ b/python/cucim/src/cucim/__init__.py @@ -31,6 +31,19 @@ """ -from .clara import CuImage -from .clara import __version__ -from .clara import cli +# Try to import cupy first. +# If cucim.clara package is imported first, you may see the following error when running on CUDA 10.x (#44) +# python3: Relink `/usr/lib/x86_64-linux-gnu/libnccl.so.2.8.3' with `/lib/x86_64-linux-gnu/librt.so.1' for IFUNC symbol `clock_gettime' +# Segmentation fault +try: + import cupy +except ImportError: + pass + +try: + from .clara import __version__, CuImage, cli +except ImportError: + from ._version import get_versions + __version__ = get_versions()['version'] + del get_versions + del _version diff --git a/python/cucim/src/cucim/clara/__init__.py b/python/cucim/src/cucim/clara/__init__.py index 542f37118..ea731bbad 100644 --- a/python/cucim/src/cucim/clara/__init__.py +++ b/python/cucim/src/cucim/clara/__init__.py @@ -15,15 +15,11 @@ import os -from . import cli -from . import converter +from . import cli, converter # import hidden methods -from ._cucim import CuImage -from ._cucim import __version__ -from ._cucim import filesystem -from ._cucim import io +from ._cucim import CuImage, __version__, filesystem, io, cache -__all__ = ['cli', 'CuImage', 'filesystem', 'io', 'converter', '__version__'] +__all__ = ['cli', 'CuImage', 'filesystem', 'io', 'cache', 'converter', '__version__'] from ._cucim import _get_plugin_root # isort:skip diff --git a/python/cucim/src/cucim/clara/cache/__init__.py b/python/cucim/src/cucim/clara/cache/__init__.py new file mode 100644 index 000000000..3b1f603c1 --- /dev/null +++ b/python/cucim/src/cucim/clara/cache/__init__.py @@ -0,0 +1,18 @@ +# +# Copyright (c) 2021, NVIDIA CORPORATION. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +from cucim.clara._cucim.cache import CacheType, ImageCache, preferred_memory_capacity + +__all__ = ['CacheType', 'ImageCache', 'preferred_memory_capacity'] diff --git a/python/cucim/src/cucim/skimage/_vendored/_internal.py b/python/cucim/src/cucim/skimage/_vendored/_internal.py index 663631a4d..b6d163a36 100644 --- a/python/cucim/src/cucim/skimage/_vendored/_internal.py +++ b/python/cucim/src/cucim/skimage/_vendored/_internal.py @@ -1,20 +1,15 @@ import cupy import numpy - try: # try importing Cython-based private axis handling functions from CuPy if hasattr(cupy, '_core'): # CuPy 10 renames core->_core - from cupy._core.internal import ( - _normalize_axis_index, - _normalize_axis_indices, - ) # NOQA + from cupy._core.internal import _normalize_axis_index # NOQA + from cupy._core.internal import _normalize_axis_indices # NOQA else: - from cupy.core.internal import ( - _normalize_axis_index, - _normalize_axis_indices, - ) # NOQA + from cupy.core.internal import _normalize_axis_index # NOQA + from cupy.core.internal import _normalize_axis_indices # NOQA except ImportError: # Fallback to local Python implementations diff --git a/python/cucim/src/cucim/skimage/color/tests/test_colorconv.py b/python/cucim/src/cucim/skimage/color/tests/test_colorconv.py index 7eb8cce32..0a2791862 100644 --- a/python/cucim/src/cucim/skimage/color/tests/test_colorconv.py +++ b/python/cucim/src/cucim/skimage/color/tests/test_colorconv.py @@ -22,12 +22,12 @@ from cucim.skimage.color import (combine_stains, convert_colorspace, gray2rgb, gray2rgba, hed2rgb, hsv2rgb, lab2lch, lab2rgb, lab2xyz, lch2lab, luv2rgb, luv2xyz, rgb2gray, - rgb2hed, rgb2hsv, rgb2lab, rgb2luv, - rgb2rgbcie, rgb2xyz, rgb2ycbcr, rgb2ydbdr, - rgb2yiq, rgb2ypbpr, rgb2yuv, rgba2rgb, - rgbcie2rgb, separate_stains, xyz2lab, xyz2luv, - xyz2rgb, ycbcr2rgb, ydbdr2rgb, yiq2rgb, - ypbpr2rgb, yuv2rgb) + rgb2hed, rgb2hsv, rgb2lab, rgb2luv, rgb2rgbcie, + rgb2xyz, rgb2ycbcr, rgb2ydbdr, rgb2yiq, + rgb2ypbpr, rgb2yuv, rgba2rgb, rgbcie2rgb, + separate_stains, xyz2lab, xyz2luv, xyz2rgb, + ycbcr2rgb, ydbdr2rgb, yiq2rgb, ypbpr2rgb, + yuv2rgb) from cucim.skimage.util import img_as_float, img_as_float32, img_as_ubyte diff --git a/python/cucim/src/cucim/skimage/color/tests/test_delta_e.py b/python/cucim/src/cucim/skimage/color/tests/test_delta_e.py index 59e55f4f7..6c92876d1 100644 --- a/python/cucim/src/cucim/skimage/color/tests/test_delta_e.py +++ b/python/cucim/src/cucim/skimage/color/tests/test_delta_e.py @@ -6,7 +6,7 @@ from cupy.testing import (assert_allclose, assert_array_almost_equal, assert_array_equal) -from cucim.skimage._shared.testing import fetch, expected_warnings +from cucim.skimage._shared.testing import expected_warnings, fetch from cucim.skimage.color.delta_e import (deltaE_cie76, deltaE_ciede94, deltaE_ciede2000, deltaE_cmc) diff --git a/python/cucim/src/cucim/skimage/feature/tests/test_canny.py b/python/cucim/src/cucim/skimage/feature/tests/test_canny.py index 69e649f20..d7899a453 100644 --- a/python/cucim/src/cucim/skimage/feature/tests/test_canny.py +++ b/python/cucim/src/cucim/skimage/feature/tests/test_canny.py @@ -77,7 +77,7 @@ def test_mask_none(self): result2 = feature.canny(cp.zeros((20, 20)), 4, 0, 0) self.assertTrue(cp.all(result1 == result2)) - @cp.testing.with_requires("skimage>=1.18") + @cp.testing.with_requires("scikit-image>=0.18") def test_use_quantiles(self): image = img_as_float(cp.asarray(data.camera()[::100, ::100])) diff --git a/python/cucim/src/cucim/skimage/filters/__init__.py b/python/cucim/src/cucim/skimage/filters/__init__.py index 4ea51df50..24c8402a0 100644 --- a/python/cucim/src/cucim/skimage/filters/__init__.py +++ b/python/cucim/src/cucim/skimage/filters/__init__.py @@ -16,9 +16,8 @@ from .thresholding import (apply_hysteresis_threshold, threshold_isodata, threshold_li, threshold_local, threshold_mean, threshold_minimum, threshold_multiotsu, - threshold_niblack, threshold_otsu, - threshold_sauvola, threshold_triangle, - threshold_yen, try_all_threshold) + threshold_niblack, threshold_otsu, threshold_sauvola, + threshold_triangle, threshold_yen, try_all_threshold) __all__ = [ "inverse", diff --git a/python/cucim/src/cucim/skimage/filters/tests/test_edges.py b/python/cucim/src/cucim/skimage/filters/tests/test_edges.py index a866fe73c..26f71cecc 100644 --- a/python/cucim/src/cucim/skimage/filters/tests/test_edges.py +++ b/python/cucim/src/cucim/skimage/filters/tests/test_edges.py @@ -4,7 +4,6 @@ from cupy.testing import assert_allclose, assert_array_almost_equal from numpy.testing import assert_ - from cucim.skimage import filters from cucim.skimage.data import binary_blobs from cucim.skimage.filters.edges import _mask_filter_result diff --git a/python/cucim/src/cucim/skimage/filters/tests/test_thresholding.py b/python/cucim/src/cucim/skimage/filters/tests/test_thresholding.py index d9c380935..d1dddfad4 100644 --- a/python/cucim/src/cucim/skimage/filters/tests/test_thresholding.py +++ b/python/cucim/src/cucim/skimage/filters/tests/test_thresholding.py @@ -14,9 +14,8 @@ from cucim.skimage.color import rgb2gray from cucim.skimage.exposure import histogram from cucim.skimage.filters.thresholding import _cross_entropy # _mean_std, -from cucim.skimage.filters.thresholding import (threshold_isodata, - threshold_li, threshold_local, - threshold_mean, +from cucim.skimage.filters.thresholding import (threshold_isodata, threshold_li, + threshold_local, threshold_mean, threshold_minimum, threshold_multiotsu, threshold_niblack, @@ -245,20 +244,20 @@ def test_threshold_sauvola_iterable_window_size(self): assert_array_equal(ref, out) -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_otsu_camera_image(): camera = util.img_as_ubyte(camerad) assert 101 < threshold_otsu(camera) < 103 -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_otsu_camera_image_histogram(): camera = util.img_as_ubyte(camerad) hist = histogram(camera.ravel(), 256, source_range="image") assert 101 < threshold_otsu(hist=hist) < 103 -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_otsu_camera_image_counts(): camera = util.img_as_ubyte(camerad) counts, bin_centers = histogram(camera.ravel(), 256, source_range="image") @@ -291,7 +290,7 @@ def test_otsu_one_color_image_3d(): assert threshold_otsu(img) == 1 -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_li_camera_image(): image = util.img_as_ubyte(camerad) threshold = threshold_li(image) @@ -381,20 +380,20 @@ def test_li_pathological_arrays(): assert cp.all(cp.isfinite(thresholds)) -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_yen_camera_image(): camera = util.img_as_ubyte(camerad) assert 145 < threshold_yen(camera) < 147 -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_yen_camera_image_histogram(): camera = util.img_as_ubyte(camerad) hist = histogram(camera.ravel(), 256, source_range="image") assert 145 < threshold_yen(hist=hist) < 147 -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_yen_camera_image_counts(): camera = util.img_as_ubyte(camerad) counts, bin_centers = histogram(camera.ravel(), 256, source_range='image') @@ -417,7 +416,7 @@ def test_local_even_block_size_error(): threshold_local(img, block_size=4) -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_isodata_camera_image(): camera = util.img_as_ubyte(camerad) @@ -429,17 +428,17 @@ def test_isodata_camera_image(): assert_array_equal(threshold_isodata(camera, return_all=True), [102, 103]) -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_isodata_camera_image_histogram(): - camera = util.img_as_ubyte(data.camera()) + camera = util.img_as_ubyte(camerad) hist = histogram(camera.ravel(), 256, source_range='image') threshold = threshold_isodata(hist=hist) assert threshold == 102 -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_isodata_camera_image_counts(): - camera = util.img_as_ubyte(data.camera()) + camera = util.img_as_ubyte(camerad) counts, bin_centers = histogram(camera.ravel(), 256, source_range='image') threshold = threshold_isodata(hist=counts) assert threshold == 102 @@ -501,7 +500,7 @@ def test_isodata_moon_image_negative_float(): # fmt: on -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_threshold_minimum(): camera = util.img_as_ubyte(camerad) @@ -513,7 +512,7 @@ def test_threshold_minimum(): assert_array_equal(threshold, 114) -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_threshold_minimum_histogram(): camera = util.img_as_ubyte(camerad) hist = histogram(camera.ravel(), 256, source_range='image') @@ -521,7 +520,7 @@ def test_threshold_minimum_histogram(): assert_array_equal(threshold, 85) -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_threshold_minimum_counts(): camera = util.img_as_ubyte(camerad) counts, bin_centers = histogram(camera.ravel(), 256, source_range='image') @@ -695,7 +694,7 @@ def test_multiotsu_more_classes_then_values(): threshold_multiotsu(img, classes=4) -# @testing.with_requires("skimage>=0.18") +# @testing.with_requires("scikit-image>=0.18") # @pytest.mark.parametrize( # "thresholding, lower, upper", # [ diff --git a/python/cucim/src/cucim/skimage/measure/tests/test_ccomp.py b/python/cucim/src/cucim/skimage/measure/tests/test_ccomp.py index ab65af21d..3bcbc2a67 100644 --- a/python/cucim/src/cucim/skimage/measure/tests/test_ccomp.py +++ b/python/cucim/src/cucim/skimage/measure/tests/test_ccomp.py @@ -55,7 +55,7 @@ def test_basic(self): assert_array_equal(label(self.x, background=9), self.labels_bg_9) def test_random(self): - x = (cp.random.rand(20, 30) * 5).astype(cp.int) + x = (cp.random.rand(20, 30) * 5).astype(int) labels = label(x) n = int(labels.max()) @@ -180,7 +180,7 @@ def test_basic(self): assert self.x[0, 0, 2] == 2, "Data was modified!" def test_random(self): - x = (cp.random.rand(20, 30) * 5).astype(cp.int) + x = (cp.random.rand(20, 30) * 5).astype(int) labels = label(x) n = int(labels.max()) diff --git a/python/cucim/src/cucim/skimage/measure/tests/test_profile.py b/python/cucim/src/cucim/skimage/measure/tests/test_profile.py index eee10dd56..46971a059 100644 --- a/python/cucim/src/cucim/skimage/measure/tests/test_profile.py +++ b/python/cucim/src/cucim/skimage/measure/tests/test_profile.py @@ -4,7 +4,7 @@ from cucim.skimage.measure import profile_line -image = cp.arange(100).reshape((10, 10)).astype(cp.float) +image = cp.arange(100).reshape((10, 10)).astype(float) def test_horizontal_rightward(): diff --git a/python/cucim/src/cucim/skimage/measure/tests/test_regionprops.py b/python/cucim/src/cucim/skimage/measure/tests/test_regionprops.py index b04e95118..1be7dd438 100644 --- a/python/cucim/src/cucim/skimage/measure/tests/test_regionprops.py +++ b/python/cucim/src/cucim/skimage/measure/tests/test_regionprops.py @@ -65,10 +65,10 @@ def test_all_props_3d(): def test_dtype(): - regionprops(cp.zeros((10, 10), dtype=cp.int)) + regionprops(cp.zeros((10, 10), dtype=int)) regionprops(cp.zeros((10, 10), dtype=cp.uint)) with pytest.raises(TypeError): - regionprops(cp.zeros((10, 10), dtype=cp.float)) + regionprops(cp.zeros((10, 10), dtype=float)) with pytest.raises(TypeError): regionprops(cp.zeros((10, 10), dtype=cp.double)) with pytest.raises(TypeError): @@ -76,13 +76,13 @@ def test_dtype(): def test_ndim(): - regionprops(cp.zeros((10, 10), dtype=cp.int)) - regionprops(cp.zeros((10, 10, 1), dtype=cp.int)) - regionprops(cp.zeros((10, 10, 10), dtype=cp.int)) - regionprops(cp.zeros((1, 1), dtype=cp.int)) - regionprops(cp.zeros((1, 1, 1), dtype=cp.int)) + regionprops(cp.zeros((10, 10), dtype=int)) + regionprops(cp.zeros((10, 10, 1), dtype=int)) + regionprops(cp.zeros((10, 10, 10), dtype=int)) + regionprops(cp.zeros((1, 1), dtype=int)) + regionprops(cp.zeros((1, 1, 1), dtype=int)) with pytest.raises(TypeError): - regionprops(cp.zeros((10, 10, 10, 2), dtype=cp.int)) + regionprops(cp.zeros((10, 10, 10, 2), dtype=int)) @pytest.mark.skip('feret_diameter_max not implmented on the GPU') @@ -210,7 +210,7 @@ def test_eccentricity(): eps = regionprops(SAMPLE)[0].eccentricity assert_almost_equal(eps, 0.814629313427) - img = cp.zeros((5, 5), dtype=cp.int) + img = cp.zeros((5, 5), dtype=int) img[2, 2] = 1 eps = regionprops(img)[0].eccentricity assert_almost_equal(eps, 0) @@ -473,7 +473,7 @@ def test_weighted_moments_normalized(): def test_label_sequence(): - a = cp.empty((2, 2), dtype=cp.int) + a = cp.empty((2, 2), dtype=int) a[:, :] = 2 ps = regionprops(a) assert len(ps) == 1 @@ -481,7 +481,7 @@ def test_label_sequence(): def test_pure_background(): - a = cp.zeros((2, 2), dtype=cp.int) + a = cp.zeros((2, 2), dtype=int) ps = regionprops(a) assert len(ps) == 0 @@ -503,7 +503,7 @@ def test_invalid_size(): def test_equals(): - arr = cp.zeros((100, 100), dtype=cp.int) + arr = cp.zeros((100, 100), dtype=int) arr[0:25, 0:25] = 1 arr[50:99, 50:99] = 2 diff --git a/python/cucim/src/cucim/skimage/metrics/tests/test_simple_metrics.py b/python/cucim/src/cucim/skimage/metrics/tests/test_simple_metrics.py index f611f9998..ece45b170 100644 --- a/python/cucim/src/cucim/skimage/metrics/tests/test_simple_metrics.py +++ b/python/cucim/src/cucim/skimage/metrics/tests/test_simple_metrics.py @@ -21,7 +21,7 @@ @pytest.mark.parametrize('dtype', [cp.uint8, cp.float32, cp.float64]) -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_PSNR_vs_IPOL(dtype): """Tests vs. imdiff result from the following IPOL article and code: https://www.ipol.im/pub/art/2011/g_lmii/. @@ -41,11 +41,10 @@ def test_PSNR_vs_IPOL(dtype): https://github.com/scikit-image/scikit-image/pull/4913#issuecomment-700653165 """ p_IPOL = 22.409353363576034 - p = peak_signal_noise_ratio(cam.astype(dtype), cam_noisy.astype(dtype)) - if np.dtype.kind(dtype) == 'f': - assert p.dtype == dtype - else: - assert p.dtype == cp.float64 + p = peak_signal_noise_ratio(cam.astype(dtype), cam_noisy.astype(dtype), + data_range=255) + # internally, mean_square_error always sets dtype=cp.float64 for accuracy + assert p.dtype == cp.float64 assert_almost_equal(p, p_IPOL, decimal=4) diff --git a/python/cucim/src/cucim/skimage/metrics/tests/test_structural_similarity.py b/python/cucim/src/cucim/skimage/metrics/tests/test_structural_similarity.py index 10871a90f..e11141a84 100644 --- a/python/cucim/src/cucim/skimage/metrics/tests/test_structural_similarity.py +++ b/python/cucim/src/cucim/skimage/metrics/tests/test_structural_similarity.py @@ -174,7 +174,7 @@ def test_structural_similarity_multichannel_chelsea(): assert_equal(structural_similarity(Xc, Xc, multichannel=True), 1.0) -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_gaussian_structural_similarity_vs_IPOL(): """Tests vs. imdiff result from the following IPOL article and code: https://www.ipol.im/pub/art/2011/g_lmii/. @@ -200,7 +200,7 @@ def test_gaussian_structural_similarity_vs_IPOL(): assert_almost_equal(mssim, mssim_IPOL, decimal=3) -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_mssim_vs_legacy(): # check that ssim with default options matches skimage 0.11 result mssim_skimage_0pt17 = 0.3674518327910367 diff --git a/python/cucim/src/cucim/skimage/morphology/binary.py b/python/cucim/src/cucim/skimage/morphology/binary.py index c51a6d036..95032a39f 100644 --- a/python/cucim/src/cucim/skimage/morphology/binary.py +++ b/python/cucim/src/cucim/skimage/morphology/binary.py @@ -39,7 +39,7 @@ def binary_erosion(image, selem=None, out=None): """ if out is None: - out = cp.empty(image.shape, dtype=cp.bool) + out = cp.empty(image.shape, dtype=bool) ndi.binary_erosion(image, structure=selem, output=out, border_value=True) return out @@ -74,7 +74,7 @@ def binary_dilation(image, selem=None, out=None): ``[False, True]``. """ if out is None: - out = cp.empty(image.shape, dtype=cp.bool) + out = cp.empty(image.shape, dtype=bool) ndi.binary_dilation(image, structure=selem, output=out) return out diff --git a/python/cucim/src/cucim/skimage/morphology/tests/test_reconstruction.py b/python/cucim/src/cucim/skimage/morphology/tests/test_reconstruction.py index 2bf5cda49..317e0bd3d 100644 --- a/python/cucim/src/cucim/skimage/morphology/tests/test_reconstruction.py +++ b/python/cucim/src/cucim/skimage/morphology/tests/test_reconstruction.py @@ -12,9 +12,9 @@ import numpy as np import pytest from cupy.testing import assert_array_almost_equal +from skimage.morphology import reconstruction as reconstruction_cpu from cucim.skimage.morphology import reconstruction -from skimage.morphology import reconstruction as reconstruction_cpu def test_zeros(): diff --git a/python/cucim/src/cucim/skimage/registration/tests/test_phase_cross_correlation.py b/python/cucim/src/cucim/skimage/registration/tests/test_phase_cross_correlation.py index ee3319f82..02e58ade7 100644 --- a/python/cucim/src/cucim/skimage/registration/tests/test_phase_cross_correlation.py +++ b/python/cucim/src/cucim/skimage/registration/tests/test_phase_cross_correlation.py @@ -5,8 +5,8 @@ from skimage.data import camera from cucim.skimage import img_as_float -from cucim.skimage.data import binary_blobs from cucim.skimage._shared.fft import fftmodule as fft +from cucim.skimage.data import binary_blobs from cucim.skimage.registration._phase_cross_correlation import ( _upsampled_dft, phase_cross_correlation) diff --git a/python/cucim/src/cucim/skimage/restoration/_denoise.py b/python/cucim/src/cucim/skimage/restoration/_denoise.py index 516ba446f..cc61c883c 100644 --- a/python/cucim/src/cucim/skimage/restoration/_denoise.py +++ b/python/cucim/src/cucim/skimage/restoration/_denoise.py @@ -153,7 +153,7 @@ def denoise_tv_chambolle(image, weight=0.1, eps=2.0e-4, n_iter_max=200, >>> x, y, z = np.ogrid[0:20, 0:20, 0:20] >>> mask = (x - 22)**2 + (y - 20)**2 + (z - 17)**2 < 8**2 - >>> mask = mask.astype(np.float) + >>> mask = mask.astype(float) >>> mask += 0.2*np.random.randn(*mask.shape) >>> res = denoise_tv_chambolle(mask, weight=100) diff --git a/python/cucim/src/cucim/skimage/restoration/tests/test_restoration.py b/python/cucim/src/cucim/skimage/restoration/tests/test_restoration.py index 1caeac176..41d1c6414 100644 --- a/python/cucim/src/cucim/skimage/restoration/tests/test_restoration.py +++ b/python/cucim/src/cucim/skimage/restoration/tests/test_restoration.py @@ -96,13 +96,13 @@ def test_unsupervised_wiener(dtype): # cp.testing.assert_allclose(cp.real(deconvolved), np.load(path), rtol=1e-3) -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_image_shape(): """Test that shape of output image in deconvolution is same as input. This addresses issue #1172. """ - point = cp.zeros((5, 5), np.float) + point = cp.zeros((5, 5), float) point[2, 2] = 1.0 psf = ndi.gaussian_filter(point, sigma=1.0) # image shape: (45, 45), as reported in #1172 diff --git a/python/cucim/src/cucim/skimage/segmentation/boundaries.py b/python/cucim/src/cucim/skimage/segmentation/boundaries.py index 6655c4c7e..9052dc0e7 100644 --- a/python/cucim/src/cucim/skimage/segmentation/boundaries.py +++ b/python/cucim/src/cucim/skimage/segmentation/boundaries.py @@ -147,7 +147,7 @@ def find_boundaries(label_img, connectivity=1, mode="thick", background=0): ... [False, False, True, True, True], ... [False, False, True, True, True], ... [False, False, True, True, True]], - ... dtype=cp.bool) + ... dtype=bool) >>> find_boundaries(bool_image) array([[False, False, False, False, False], [False, False, True, True, True], diff --git a/python/cucim/src/cucim/skimage/segmentation/tests/test_join.py b/python/cucim/src/cucim/skimage/segmentation/tests/test_join.py index dde4b5584..af528073c 100644 --- a/python/cucim/src/cucim/skimage/segmentation/tests/test_join.py +++ b/python/cucim/src/cucim/skimage/segmentation/tests/test_join.py @@ -140,7 +140,7 @@ def test_relabel_sequential_int_dtype_overflow(): _check_maps(ar, ar_relab, fw, inv) assert all(a.dtype == cp.uint16 for a in (ar_relab, fw)) assert inv.dtype == ar.dtype - ar_relab_ref = cp.where(ar > 0, ar.astype(cp.int) + offset - 1, 0) + ar_relab_ref = cp.where(ar > 0, ar.astype(int) + offset - 1, 0) assert_array_equal(ar_relab, ar_relab_ref) diff --git a/python/cucim/src/cucim/skimage/transform/__init__.py b/python/cucim/src/cucim/skimage/transform/__init__.py index 02527dd22..fa728720d 100644 --- a/python/cucim/src/cucim/skimage/transform/__init__.py +++ b/python/cucim/src/cucim/skimage/transform/__init__.py @@ -3,8 +3,8 @@ PiecewiseAffineTransform, PolynomialTransform, ProjectiveTransform, SimilarityTransform, estimate_transform, matrix_transform) -from ._warps import (downscale_local_mean, rescale, resize, rotate, swirl, - warp, warp_coords, warp_polar) +from ._warps import (downscale_local_mean, rescale, resize, rotate, swirl, warp, + warp_coords, warp_polar) from .integral import integral_image, integrate from .pyramids import (pyramid_expand, pyramid_gaussian, pyramid_laplacian, pyramid_reduce) diff --git a/python/cucim/src/cucim/skimage/transform/integral.py b/python/cucim/src/cucim/skimage/transform/integral.py index 23f08eb32..7c6f315ad 100644 --- a/python/cucim/src/cucim/skimage/transform/integral.py +++ b/python/cucim/src/cucim/skimage/transform/integral.py @@ -58,7 +58,7 @@ def integrate(ii, start, end): Examples -------- - >>> arr = np.ones((5, 6), dtype=np.float) + >>> arr = np.ones((5, 6), dtype=float) >>> ii = integral_image(arr) >>> integrate(ii, (1, 0), (1, 2)) # sum from (1, 0) to (1, 2) array([3.]) diff --git a/python/cucim/src/cucim/skimage/util/tests/test_random_noise.py b/python/cucim/src/cucim/skimage/util/tests/test_random_noise.py index 40887b755..0bbbf6a30 100644 --- a/python/cucim/src/cucim/skimage/util/tests/test_random_noise.py +++ b/python/cucim/src/cucim/skimage/util/tests/test_random_noise.py @@ -171,7 +171,7 @@ def test_clip_poisson(): assert (cam_poisson2.max() > 1.3) and (cam_poisson2.min() == -1.0) -@cp.testing.with_requires("skimage>=1.18") +@cp.testing.with_requires("scikit-image>=0.18") def test_clip_gaussian(): seed = 42 data = camerad # 512x512 grayscale uint8 diff --git a/python/cucim/src/cucim/time.py b/python/cucim/src/cucim/time.py index 54395da5a..d1a2f8086 100644 --- a/python/cucim/src/cucim/time.py +++ b/python/cucim/src/cucim/time.py @@ -1,4 +1,3 @@ from .skimage._vendored.time import repeat - __all__ = ['repeat'] diff --git a/python/cucim/src/localtest.py b/python/cucim/src/localtest.py index e6c524279..59955dbc8 100644 --- a/python/cucim/src/localtest.py +++ b/python/cucim/src/localtest.py @@ -13,9 +13,9 @@ # limitations under the License. # - import concurrent.futures import json +import os from contextlib import ContextDecorator from time import perf_counter @@ -23,7 +23,7 @@ from cucim import CuImage -input_file = "notebooks/input/image.tif" +input_file = "notebooks/input/image2.tif" img = CuImage(input_file) # True if image data is loaded & available. @@ -62,17 +62,6 @@ # A raw metadata string. print(img.raw_metadata) -# a = np.asarray(img.read_region((10000, 10000), (1000, 1000), 0)) -# print(a.shape) -b = img.read_region((10000, 10000), (1000, 1000), 0) -print(b.metadata) -# import PIL -# from PIL import Image -# b = Image.fromarray(a[:,:,:3]) -# b.save("output.jpg", "JPEG", quality=100) -# import sys -# sys.exit(1) - class Timer(ContextDecorator): def __init__(self, message): @@ -93,10 +82,10 @@ def __exit__(self, exc_type, exc, exc_tb): print("{} : {}".format(self.message, self.end - self.start)) -num_threads = 1 # os.cpu_count() +num_threads = os.cpu_count() -start_location = 0 -tile_size = 256 +start_location = 1 +tile_size = 512 def load_tile_openslide(slide, start_loc, tile_size): @@ -119,7 +108,7 @@ def load_tile_cucim(slide, start_loc, tile_size): count += 1 start_loc_iter = ((w, h) for h in range(start_location, height, tile_size) - for w in range(start_location, width, tile_size)) + for w in range(start_location, width, tile_size)) with Timer(" Thread elapsed time (OpenSlide)") as timer: with concurrent.futures.ThreadPoolExecutor( max_workers=num_workers @@ -136,7 +125,7 @@ def load_tile_cucim(slide, start_loc, tile_size): slide = CuImage(input_file) start_loc_iter = ((w, h) for h in range(start_location, height, tile_size) - for w in range(start_location, width, tile_size)) + for w in range(start_location, width, tile_size)) with Timer(" Thread elapsed time (cuCIM)") as timer: with concurrent.futures.ThreadPoolExecutor( max_workers=num_workers diff --git a/python/pybind11/cache/cache_py.cpp b/python/pybind11/cache/cache_py.cpp new file mode 100644 index 000000000..08f7c3687 --- /dev/null +++ b/python/pybind11/cache/cache_py.cpp @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cache_py.h" +#include "cache_pydoc.h" + +#include + +#include +#include + +#include "image_cache_py.h" +#include "image_cache_pydoc.h" + +using namespace pybind11::literals; +namespace py = pybind11; + +namespace cucim::cache +{ + +void init_cache(py::module& cache) +{ + py::enum_(cache, "CacheType") // + .value("NoCache", CacheType::kNoCache) // + .value("PerProcess", CacheType::kPerProcess) // + .value("SharedMemory", CacheType::kSharedMemory); + + py::class_>(cache, "ImageCache") + .def_property( + "type", &ImageCache::type, nullptr, doc::ImageCache::doc_type, py::call_guard()) + .def_property("config", &py_config, nullptr, doc::ImageCache::doc_type, py::call_guard()) + .def_property( + "size", &ImageCache::size, nullptr, doc::ImageCache::doc_size, py::call_guard()) + .def_property("memory_size", &ImageCache::memory_size, nullptr, doc::ImageCache::doc_memory_size, + py::call_guard()) + .def_property("capacity", &ImageCache::capacity, nullptr, doc::ImageCache::doc_capacity, + py::call_guard()) + .def_property("memory_capacity", &ImageCache::memory_capacity, nullptr, doc::ImageCache::doc_memory_capacity, + py::call_guard()) + .def_property("free_memory", &ImageCache::free_memory, nullptr, doc::ImageCache::doc_free_memory, + py::call_guard()) + .def("record", &py_record, doc::ImageCache::doc_record, py::call_guard(), // + py::arg("value") = py::none()) + .def_property("hit_count", &ImageCache::hit_count, nullptr, doc::ImageCache::doc_hit_count, + py::call_guard()) + .def_property("miss_count", &ImageCache::miss_count, nullptr, doc::ImageCache::doc_miss_count, + py::call_guard()) + .def("reserve", &py_image_cache_reserve, doc::ImageCache::doc_reserve, py::call_guard(), // + py::arg("memory_capacity")); + + cache.def("preferred_memory_capacity", &py_preferred_memory_capacity, doc::doc_preferred_memory_capacity, // + py::arg("img") = py::none(), // + py::arg("image_size") = std::nullopt, // + py::arg("tile_size") = std::nullopt, // + py::arg("patch_size") = std::nullopt, // + py::arg("bytes_per_pixel") = 3, // + py::call_guard()); +} + +bool py_record(ImageCache& cache, py::object value) +{ + if (value.is_none()) + { + return cache.record(); + } + else if (py::isinstance(value)) + { + py::bool_ v = value.cast(); + cache.record(v); + return v; + } + else + { + throw std::invalid_argument(fmt::format("Only 'NoneType' or 'bool' is available for the argument")); + } +} + +py::dict py_config(ImageCache& cache) +{ + ImageCacheConfig& config = cache.config(); + + return py::dict{ + "type"_a = pybind11::str(std::string(lookup_cache_type_str(config.type))), // + "memory_capacity"_a = pybind11::int_(config.memory_capacity), // + "capacity"_a = pybind11::int_(config.capacity), // + "mutex_pool_capacity"_a = pybind11::int_(config.mutex_pool_capacity), // + "list_padding"_a = pybind11::int_(config.list_padding), // + "extra_shared_memory_size"_a = pybind11::int_(config.extra_shared_memory_size), // + "record_stat"_a = pybind11::bool_(config.record_stat) // + }; +} + +void py_image_cache_reserve(ImageCache& cache, uint32_t memory_capacity, py::kwargs kwargs) +{ + cucim::cache::ImageCacheConfig config = cucim::CuImage::get_config()->cache(); + config.memory_capacity = memory_capacity; + + if (kwargs.contains("capacity")) + { + config.capacity = py::cast(kwargs["capacity"]); + } + else + { + // Update capacity depends on memory_capacity. + config.capacity = calc_default_cache_capacity(kOneMiB * memory_capacity); + } + + cache.reserve(config); +} + +py::int_ py_preferred_memory_capacity(const py::object& img, + const std::optional>& image_size, + const std::optional>& tile_size, + const std::optional>& patch_size, + uint32_t bytes_per_pixel) +{ + std::vector param_image; + std::vector param_tile; + std::vector param_patch; + + if (!img.is_none()) + { + const CuImage& cuimg = *img.cast(); + std::vector image_size_vec = cuimg.size("XY"); + param_image.insert(param_image.end(), image_size_vec.begin(), image_size_vec.end()); + std::vector tile_size_vec = cuimg.resolutions().level_tile_size(0); + param_tile.insert(param_tile.end(), tile_size_vec.begin(), tile_size_vec.end()); + + // Calculate pixel size in bytes + // (For example, if axes == "YXC" or "YXS", calculate [bytes per pixel] * [# items inside dims after 'X'] ) + std::string dims = cuimg.dims(); + std::size_t pivot = std::max(dims.rfind('X'), dims.rfind('Y')); + if (pivot == std::string::npos) + { + bytes_per_pixel = 3; + } + else + { + if (pivot < dims.size()) + { + std::vector size_vec = cuimg.size(&dims.c_str()[pivot + 1]); + int64_t item_count = 1; + for (auto size : size_vec) + { + item_count *= size; + } + bytes_per_pixel = (cuimg.dtype().bits * item_count + 7) / 8; + } + } + } + else + { + if (!image_size || image_size->size() != 2) + { + throw std::invalid_argument( + fmt::format("Please specify 'image_size' parameter (e.g., 'image_size=(100000, 100000)')!")); + } + if (!tile_size || tile_size->size() != 2) + { + param_tile = { kDefaultTileSize, kDefaultTileSize }; + } + } + + if (!patch_size || patch_size->size() != 2) + { + param_patch = { kDefaultPatchSize, kDefaultPatchSize }; + } + + return preferred_memory_capacity(!param_image.empty() ? param_image : image_size.value(), // + !param_tile.empty() ? param_tile : tile_size.value(), // + !param_patch.empty() ? param_patch : patch_size.value(), // + bytes_per_pixel); +} + +} // namespace cucim::cache \ No newline at end of file diff --git a/python/pybind11/cache/cache_py.h b/python/pybind11/cache/cache_py.h new file mode 100644 index 000000000..e0b817fcd --- /dev/null +++ b/python/pybind11/cache/cache_py.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATcacheN. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PYCUCIM_CACHE_INIT_H +#define PYCUCIM_CACHE_INIT_H + +#include +#include + +#include + +namespace py = pybind11; + +namespace cucim::cache +{ + +// Forward declaration +class ImageCache; + +void init_cache(py::module& m); + + +bool py_record(ImageCache& cache, py::object value); + +py::dict py_config(ImageCache& cache); + +void py_image_cache_reserve(ImageCache& cache, uint32_t memory_capacity, py::kwargs kwargs); + +py::int_ py_preferred_memory_capacity(const py::object& img, + const std::optional>& image_size, + const std::optional>& tile_size, + const std::optional>& patch_size, + uint32_t bytes_per_pixel); + +} // namespace cucim::cache + + +#endif // PYCUCIM_CACHE_INIT_H diff --git a/python/pybind11/cache/cache_pydoc.h b/python/pybind11/cache/cache_pydoc.h new file mode 100644 index 000000000..67840a40a --- /dev/null +++ b/python/pybind11/cache/cache_pydoc.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef PYCUCIM_CACHE_PYDOC_H +#define PYCUCIM_CACHE_PYDOC_H + +#include "../macros.h" + +namespace cucim::cache::doc +{ + +// py::int_ py_preferred_memory_capacity(const py::object& img, +// const std::optional>& image_size, +// const std::optional>& tile_size, +// const std::optional>& patch_size, +// uint32_t bytes_per_pixel); +PYDOC(preferred_memory_capacity, R"doc( +Returns a good cache memory capacity value in MiB for the given conditions. + +Please see how the value is calculated: https://godbolt.org/z/8vxnPfKM5 + +Args: + img: A `CuImage` object that can provide `image_size`, `tile_size`, `bytes_per_pixel` information. + If this argument is provided, only `patch_size` from the arguments is used for the calculation. + image_size: A list of values that presents the image size (width, height). + tile_size: A list of values that presents the tile size (width, height). The default value is (256, 256). + patch_size: A list of values that presents the patch size (width, height). The default value is (256, 256). + bytes_per_pixel: The number of bytes that each pixel in the 2D image takes place. The default value is 3. + +Returns: + The suggested memory capacity in MiB. +)doc") + +} // namespace cucim::cache::doc +#endif // PYCUCIM_CACHE_PYDOC_H diff --git a/python/pybind11/cache/image_cache_py.cpp b/python/pybind11/cache/image_cache_py.cpp new file mode 100644 index 000000000..df057be17 --- /dev/null +++ b/python/pybind11/cache/image_cache_py.cpp @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "image_cache_py.h" +#include "image_cache_pydoc.h" + +#include + +namespace py = pybind11; + +namespace cucim::cache +{ + +} // namespace cucim::cache \ No newline at end of file diff --git a/python/pybind11/cache/image_cache_py.h b/python/pybind11/cache/image_cache_py.h new file mode 100644 index 000000000..e48053d0e --- /dev/null +++ b/python/pybind11/cache/image_cache_py.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef PYCUCIM_CACHE_IMAGE_CACHE_PY_H +#define PYCUCIM_CACHE_IMAGE_CACHE_PY_H + +#include + +#include + +namespace py = pybind11; + +namespace cucim::cache +{ + + +} // namespace cucim::cache + +#endif // PYCUCIM_CACHE_IMAGE_CACHE_PY_H diff --git a/python/pybind11/cache/image_cache_pydoc.h b/python/pybind11/cache/image_cache_pydoc.h new file mode 100644 index 000000000..7e68ad742 --- /dev/null +++ b/python/pybind11/cache/image_cache_pydoc.h @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2021, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef PYCUCIM_CACHE_IMAGE_CACHE_PYDOC_H +#define PYCUCIM_CACHE_IMAGE_CACHE_PYDOC_H + +#include "../macros.h" + +namespace cucim::cache::doc::ImageCache +{ + +// PYDOC(ImageCache, R"doc( +// Constructor of ImageCache. + +// Args: + +// )doc") + +// virtual CacheType type() const; +PYDOC(type, R"doc( +A Cache type. +)doc") + +// virtual uint32_t size() const = 0; +PYDOC(size, R"doc( +A size of list/hashmap. +)doc") + + +// virtual uint64_t memory_size() const = 0; +PYDOC(memory_size, R"doc( +A size of cache memory used. +)doc") + +// virtual uint32_t capacity() const = 0; +PYDOC(capacity, R"doc( +A capacity of list/hashmap. +)doc") + +// virtual uint64_t memory_capacity() const = 0; +PYDOC(memory_capacity, R"doc( +A capacity of cache memory. +)doc") + +// virtual uint64_t free_memory() const = 0; +PYDOC(free_memory, R"doc( +A cache memory size available in the cache memory. +)doc") + +// virtual void record(bool value) = 0; +// virtual bool record() const = 0; +PYDOC(record, R"doc( +A cache memory size available in the cache memory. +)doc") + +// virtual uint64_t hit_count() const = 0; +PYDOC(hit_count, R"doc( +A cache hit count. +)doc") + +// virtual uint64_t miss_count() const = 0; +PYDOC(miss_count, R"doc( +A cache miss count. +)doc") + +// virtual void reserve(const ImageCacheConfig& config) = 0; +PYDOC(reserve, R"doc( +Reserves more memory if possible. +)doc") + +} // namespace cucim::cache::doc::ImageCache + +#endif // PYCUCIM_CACHE_IMAGE_CACHE_PYDOC_H diff --git a/python/pybind11/cucim_py.cpp b/python/pybind11/cucim_py.cpp index d336bc5e7..5d77be22b 100644 --- a/python/pybind11/cucim_py.cpp +++ b/python/pybind11/cucim_py.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,15 +16,18 @@ #include "cucim_py.h" #include "cucim_pydoc.h" -#include "io/init.h" -#include "filesystem/init.h" +#include +#include +#include #include #include -#include -#include -#include +#include + +#include "cache/cache_py.h" +#include "filesystem/filesystem_py.h" +#include "io/io_py.h" using namespace pybind11::literals; namespace py = pybind11; @@ -62,6 +65,10 @@ PYBIND11_MODULE(_cucim, m) auto m_fs = m.def_submodule("filesystem"); filesystem::init_filesystem(m_fs); + // Submodule: cache + auto m_cache = m.def_submodule("cache"); + cache::init_cache(m_cache); + // Data structures py::enum_(m, "DLDataTypeCode") // .value("DLInt", kDLInt) // @@ -89,9 +96,14 @@ PYBIND11_MODULE(_cucim, m) }, py::call_guard()); - py::class_>(m, "CuImage") // + py::class_>(m, "CuImage", py::dynamic_attr()) // .def(py::init(), doc::CuImage::doc_CuImage, py::call_guard(), // py::arg("path")) // + .def_static("cache", &py_cache, doc::CuImage::doc_cache, py::call_guard(), // + py::arg("type") = py::none()) // + // Do not release GIL + .def_static("_set_array_interface", &_set_array_interface, doc::CuImage::doc__set_array_interface, // + py::arg("cuimg") = py::none()) // .def_property("path", &CuImage::path, nullptr, doc::CuImage::doc_path, py::call_guard()) // .def_property("is_loaded", &CuImage::is_loaded, nullptr, doc::CuImage::doc_is_loaded, py::call_guard()) // @@ -138,7 +150,8 @@ PYBIND11_MODULE(_cucim, m) py::call_guard()) // .def("associated_image", &CuImage::associated_image, doc::CuImage::doc_associated_image, py::call_guard(), // - py::arg("name") = "") // + py::arg("name") = "", // + py::arg("device") = io::Device()) // .def("save", &CuImage::save, doc::CuImage::doc_save, py::call_guard()) // .def("__bool__", &CuImage::operator bool, py::call_guard()) // .def( @@ -146,9 +159,7 @@ PYBIND11_MODULE(_cucim, m) [](const CuImage& cuimg) { // return fmt::format("", cuimg.path()); }, - py::call_guard()) - .def_property("__array_interface__", &get_array_interface, nullptr, doc::CuImage::doc_get_array_interface, - py::call_guard()); + py::call_guard()); // We can use `"cpu"` instead of `Device("cpu")` py::implicitly_convertible(); @@ -183,6 +194,57 @@ pybind11::tuple vector2pytuple(const std::vector& vec) return result; } +std::shared_ptr py_cache(const py::object& type, const py::kwargs& kwargs) +{ + if (py::isinstance(type)) + { + std::string ctype = std::string(py::cast(type)); + + cucim::cache::CacheType cache_type = cucim::cache::lookup_cache_type(ctype); + // Copy default cache config to local + cucim::cache::ImageCacheConfig config = cucim::CuImage::get_config()->cache(); + config.type = cache_type; + + if (kwargs.contains("memory_capacity")) + { + config.memory_capacity = py::cast(kwargs["memory_capacity"]); + } + if (kwargs.contains("capacity")) + { + config.capacity = py::cast(kwargs["capacity"]); + } + else + { + // Update capacity depends on memory_capacity. + config.capacity = cucim::cache::calc_default_cache_capacity(cucim::cache::kOneMiB * config.memory_capacity); + } + if (kwargs.contains("mutex_pool_capacity")) + { + config.mutex_pool_capacity = py::cast(kwargs["mutex_pool_capacity"]); + } + if (kwargs.contains("list_padding")) + { + config.list_padding = py::cast(kwargs["list_padding"]); + } + if (kwargs.contains("extra_shared_memory_size")) + { + config.extra_shared_memory_size = py::cast(kwargs["extra_shared_memory_size"]); + } + if (kwargs.contains("record_stat")) + { + config.record_stat = py::cast(kwargs["record_stat"]); + } + return CuImage::cache(config); + } + else if (type.is_none()) + { + return CuImage::cache(); + } + + throw std::invalid_argument( + fmt::format("The first argument should be one of ['nocache', 'per_process', 'shared_memory'].")); +} + json py_metadata(const CuImage& cuimg) { auto metadata = cuimg.metadata(); @@ -221,6 +283,13 @@ json py_metadata(const CuImage& cuimg) } resolutions_metadata.emplace("level_dimensions", level_dimensions_vec); resolutions_metadata.emplace("level_downsamples", resolutions.level_downsamples()); + std::vector> level_tile_sizes_vec; + level_tile_sizes_vec.reserve(level_count); + for (int level = 0; level < level_count; ++level) + { + level_tile_sizes_vec.emplace_back(resolutions.level_tile_size(level)); + } + resolutions_metadata.emplace("level_tile_sizes", level_tile_sizes_vec); } cucim_metadata.emplace("associated_images", cuimg.associated_images()); return json_obj; @@ -235,63 +304,74 @@ py::dict py_resolutions(const CuImage& cuimg) return py::dict{ "level_count"_a = pybind11::int_(0), // "level_dimensions"_a = pybind11::tuple(), // - "level_downsamples"_a = pybind11::tuple() // + "level_downsamples"_a = pybind11::tuple(), // + "level_tile_sizes"_a = pybind11::tuple() // }; } std::vector level_dimensions_vec; level_dimensions_vec.reserve(level_count); + std::vector level_tile_sizes_vec; + level_tile_sizes_vec.reserve(level_count); for (int level = 0; level < level_count; ++level) { level_dimensions_vec.emplace_back(vector2pytuple(resolutions.level_dimension(level))); + level_tile_sizes_vec.emplace_back(vector2pytuple(resolutions.level_tile_size(level))); } py::tuple level_dimensions = vector2pytuple(level_dimensions_vec); py::tuple level_downsamples = vector2pytuple(resolutions.level_downsamples()); + py::tuple level_tile_sizes = vector2pytuple(level_tile_sizes_vec); return py::dict{ "level_count"_a = pybind11::int_(level_count), // "level_dimensions"_a = level_dimensions, // - "level_downsamples"_a = level_downsamples // + "level_downsamples"_a = level_downsamples, // + "level_tile_sizes"_a = level_tile_sizes // }; } -CuImage py_read_region(CuImage& cuimg, - std::vector location, - std::vector size, - int16_t level, - io::Device device, - py::object buf, - const std::string& shm_name, - py::kwargs kwargs) +py::object py_read_region(const CuImage& cuimg, + std::vector&& location, + std::vector&& size, + int16_t level, + const io::Device& device, + const py::object& buf, + const std::string& shm_name, + const py::kwargs& kwargs) { cucim::DimIndices indices; + if (kwargs) { std::vector> indices_args; - for (auto item : kwargs) { - auto key = std::string(py::str(item.first)); - auto value = py::cast(item.second); + py::gil_scoped_acquire scope_guard; - if (key.size() != 1) - { - throw std::invalid_argument( - fmt::format("Argument name for Dimension should be a single character but '{}' is used.", key)); - } - char key_char = key[0] & ~32; - if (key_char < 'A' || key_char > 'Z') + for (auto item : kwargs) { - throw std::invalid_argument( - fmt::format("Dimension character should be an alphabet but '{}' is used.", key)); + auto key = std::string(py::str(item.first)); + auto value = py::cast(item.second); + + if (key.size() != 1) + { + throw std::invalid_argument( + fmt::format("Argument name for Dimension should be a single character but '{}' is used.", key)); + } + char key_char = key[0] & ~32; + if (key_char < 'A' || key_char > 'Z') + { + throw std::invalid_argument( + fmt::format("Dimension character should be an alphabet but '{}' is used.", key)); + } + + indices_args.emplace_back(std::make_pair(key_char, value)); + + // fmt::print("k:{} v:{}\n", std::string(py::str(item.first)), + // std::string(py::str(item.second))); } - - indices_args.emplace_back(std::make_pair(key_char, value)); - - // fmt::print("k:{} v:{}\n", std::string(py::str(item.first)), - // std::string(py::str(item.second))); } indices = cucim::DimIndices(indices_args); } @@ -299,36 +379,66 @@ CuImage py_read_region(CuImage& cuimg, { indices = cucim::DimIndices{}; } - cucim::CuImage region = cuimg.read_region(location, size, level, indices, device, nullptr, ""); - return region; + + auto region_ptr = std::make_shared( + cuimg.read_region(std::move(location), std::move(size), level, indices, device, nullptr, "")); + + { + py::gil_scoped_acquire scope_guard; + + py::object region = py::cast(region_ptr); + + // Add `__array_interace__` or `__cuda_array_interface__` in runtime. + _set_array_interface(region); + + return region; + } } -py::dict get_array_interface(const CuImage& cuimg) +void _set_array_interface(const py::object& cuimg_obj) { + const auto& cuimg = cuimg_obj.cast(); + // TODO: using __array_struct__, access to array interface could be faster // (https://numpy.org/doc/stable/reference/arrays.interface.html#c-struct-access) // TODO: check the performance difference between python int vs python long later. - const DLTensor* tensor = static_cast(cuimg.container()); + memory::DLTContainer container = cuimg.container(); + + const DLTensor* tensor = static_cast(container); if (!tensor) { - return pybind11::dict(); + return; } - const char* type_str = cuimg.container().numpy_dtype(); + const char* type_str = container.numpy_dtype(); + py::str typestr = py::str(type_str); + + py::tuple data = pybind11::make_tuple(py::int_(reinterpret_cast(tensor->data)), py::bool_(false)); py::list descr; - descr.append(py::make_tuple(""_s, py::str(type_str))); + descr.append(py::make_tuple(""_s, typestr)); py::tuple shape = vector2pytuple(cuimg.shape()); - // Reference: https://numpy.org/doc/stable/reference/arrays.interface.html - return py::dict{ "data"_a = - pybind11::make_tuple(py::int_(reinterpret_cast(tensor->data)), py::bool_(false)), - "strides"_a = py::none(), - "descr"_a = descr, - "typestr"_a = py::str(type_str), - "shape"_a = shape, - "version"_a = py::int_(3) }; + // TODO: depending on container's memory type, expose either array_interface or cuda_array_interface + switch (tensor->ctx.device_type) + { + case kDLCPU: { + // Reference: https://numpy.org/doc/stable/reference/arrays.interface.html + cuimg_obj.attr("__array_interface__") = + py::dict{ "data"_a = data, "strides"_a = py::none(), "descr"_a = descr, + "typestr"_a = typestr, "shape"_a = shape, "version"_a = py::int_(3) }; + } + break; + case kDLGPU: { + // Reference: https://numba.readthedocs.io/en/stable/cuda/cuda_array_interface.html + cuimg_obj.attr("__cuda_array_interface__") = + py::dict{ "data"_a = data, "strides"_a = py::none(), "descr"_a = descr, "typestr"_a = typestr, + "shape"_a = shape, "version"_a = py::int_(3), "mask"_a = py::none(), "stream"_a = 1 }; + } + break; + default: + break; + } } - } // namespace cucim diff --git a/python/pybind11/cucim_py.h b/python/pybind11/cucim_py.h index 1910624bf..14c7dd48c 100644 --- a/python/pybind11/cucim_py.h +++ b/python/pybind11/cucim_py.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,17 +17,27 @@ #ifndef PYCUCIM_CUIMAGE_PY_H #define PYCUCIM_CUIMAGE_PY_H -#include -#include #include -#include +#include +#include using json = nlohmann::json; namespace cucim { +// Forward declarations +class CuImage; +namespace io +{ +class Device; +} +namespace cache +{ +class ImageCache; +} + std::string get_plugin_root(); void set_plugin_root(std::string path); @@ -46,17 +56,19 @@ void set_plugin_root(std::string path); template pybind11::tuple vector2pytuple(const std::vector& vec); +std::shared_ptr py_cache(const py::object& ctype, const py::kwargs& kwargs); + json py_metadata(const CuImage& cuimg); py::dict py_resolutions(const CuImage& cuimg); -CuImage py_read_region(CuImage& cuimg, - std::vector location, - std::vector size, - int16_t level, - io::Device device, - py::object buf, - const std::string& shm_name, - py::kwargs kwargs); -py::dict get_array_interface(const CuImage& cuimg); +py::object py_read_region(const CuImage& cuimg, + std::vector&& location, + std::vector&& size, + int16_t level, + const io::Device& device, + const py::object& buf, + const std::string& shm_name, + const py::kwargs& kwargs); +void _set_array_interface(const py::object& cuimg_obj); } // namespace cucim #endif // PYCUCIM_CUIMAGE_PY_H diff --git a/python/pybind11/cucim_pydoc.h b/python/pybind11/cucim_pydoc.h index c90f47330..1fa4b7af6 100644 --- a/python/pybind11/cucim_pydoc.h +++ b/python/pybind11/cucim_pydoc.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,11 +15,11 @@ */ #ifndef PYCUCIM_CUCIM_PYDOC_H -# define PYCUCIM_CUCIM_PYDOC_H +#define PYCUCIM_CUCIM_PYDOC_H -# include "macros.h" +#include -# include +#include "macros.h" namespace cucim::doc { @@ -64,6 +64,11 @@ Constructor of CuImage. // // ~CuImage(); +// std::shared_ptr CuImage::cache() +PYDOC(cache, R"doc( +Get cache object. +)doc") + // filesystem::Path path() const; PYDOC(path, R"doc( Underlying file path for this object. @@ -171,6 +176,7 @@ Returns a dict that includes resolution information. - level_count: The number of levels - level_dimensions: A tuple of dimension tuples (width, height) - level_downsamples: A tuple of down-sample factors +- level_tile_sizes: A tuple of tile size tuple (tile width, tile_height) )doc") // dlpack::DLTContainer container() const; @@ -221,9 +227,14 @@ Saves image data to the file path. Currently it supports only .ppm file format that can be viewed by `eog` command in Ubuntu. )doc") -// py::dict get_array_interface(const CuImage& cuimg); -PYDOC(get_array_interface, R"doc( -Get an array interface for Python. +// void _set_array_interface(const CuImage& cuimg); +PYDOC(_set_array_interface, R"doc( +Add `__array_interface__` or `__cuda_array_interface__` depending on the memory type. + +Args: + cuimg: CuImage object +Returns: + None )doc") }; // namespace CuImage diff --git a/python/pybind11/filesystem/cufile_py.cpp b/python/pybind11/filesystem/cufile_py.cpp index c42dc1ae9..ba2fccec2 100644 --- a/python/pybind11/filesystem/cufile_py.cpp +++ b/python/pybind11/filesystem/cufile_py.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,17 +16,19 @@ #include "cufile_py.h" #include "cufile_pydoc.h" -#include "../memory/init.h" #include + #include +#include "../memory/memory_py.h" + namespace py = pybind11; namespace cucim::filesystem { -ssize_t fd_pread(const CuFileDriver& fd, py::object obj, size_t count, off_t file_offset, off_t buf_offset) +ssize_t fd_pread(const CuFileDriver& fd, const py::object& obj, size_t count, off_t file_offset, off_t buf_offset) { void* buf = nullptr; size_t memory_size = 0; @@ -49,7 +51,7 @@ ssize_t fd_pread(const CuFileDriver& fd, py::object obj, size_t count, off_t fil py::call_guard(); return fd.pread(buf, count, file_offset, buf_offset); } -ssize_t fd_pwrite(CuFileDriver& fd, py::object obj, size_t count, off_t file_offset, off_t buf_offset) +ssize_t fd_pwrite(CuFileDriver& fd, const py::object& obj, size_t count, off_t file_offset, off_t buf_offset) { void* buf = nullptr; size_t memory_size = 0; diff --git a/python/pybind11/filesystem/cufile_py.h b/python/pybind11/filesystem/cufile_py.h index 2bb847dde..e4a3005c3 100644 --- a/python/pybind11/filesystem/cufile_py.h +++ b/python/pybind11/filesystem/cufile_py.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -26,8 +26,8 @@ namespace py = pybind11; namespace cucim::filesystem { // Note: there would be name conflict with pread/pwrite in cufile_driver.h so prefixed 'fd_'. -ssize_t fd_pread(const CuFileDriver& fd, py::object buf, size_t count, off_t file_offset, off_t buf_offset = 0); -ssize_t fd_pwrite(CuFileDriver& fd, py::object buf, size_t count, off_t file_offset, off_t buf_offset = 0); +ssize_t fd_pread(const CuFileDriver& fd, const py::object& buf, size_t count, off_t file_offset, off_t buf_offset = 0); +ssize_t fd_pwrite(CuFileDriver& fd, const py::object& buf, size_t count, off_t file_offset, off_t buf_offset = 0); } // namespace cucim::filesystem #endif // PYCUCIM_CUFILE_PY_H diff --git a/python/pybind11/filesystem/filesystem_py.cpp b/python/pybind11/filesystem/filesystem_py.cpp index e78a22803..40c9dc2bc 100644 --- a/python/pybind11/filesystem/filesystem_py.cpp +++ b/python/pybind11/filesystem/filesystem_py.cpp @@ -14,14 +14,16 @@ * limitations under the License. */ -#include "init.h" +#include "filesystem_py.h" #include "filesystem_pydoc.h" -#include "cufile_py.h" -#include "cufile_pydoc.h" #include + #include +#include "cufile_py.h" +#include "cufile_pydoc.h" + namespace py = pybind11; namespace cucim::filesystem diff --git a/python/pybind11/filesystem/init.h b/python/pybind11/filesystem/filesystem_py.h similarity index 83% rename from python/pybind11/filesystem/init.h rename to python/pybind11/filesystem/filesystem_py.h index 354359abd..bf6adcff5 100644 --- a/python/pybind11/filesystem/init.h +++ b/python/pybind11/filesystem/filesystem_py.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,7 +16,7 @@ #ifndef PYCUCIM_FILESYSTEM_INIT_H #define PYCUCIM_FILESYSTEM_INIT_H -#include "cucim/filesystem/cufile_driver.h" +#include #include @@ -25,15 +25,16 @@ namespace py = pybind11; namespace cucim::filesystem { +// Forward declaration +class CuFileDriver; + void init_filesystem(py::module& m); std::shared_ptr py_open(const char* file_path, const char* flags, mode_t mode); ssize_t py_pread(const std::shared_ptr& fd, py::object buf, size_t count, off_t file_offset, off_t buf_offset = 0); ssize_t py_pwrite(const std::shared_ptr& fd, py::object buf, size_t count, off_t file_offset, off_t buf_offset = 0); -//bool py_close(const std::shared_ptr& fd); -//bool py_discard_page_cache(const char* file_path); - - +// bool py_close(const std::shared_ptr& fd); +// bool py_discard_page_cache(const char* file_path); } #endif // PYCUCIM_FILESYSTEM_INIT_H diff --git a/python/pybind11/io/device_py.cpp b/python/pybind11/io/device_py.cpp index 3858d7a7f..fbec46333 100644 --- a/python/pybind11/io/device_py.cpp +++ b/python/pybind11/io/device_py.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,6 +17,7 @@ #include "device_pydoc.h" #include + #include namespace py = pybind11; diff --git a/python/pybind11/io/io_py.cpp b/python/pybind11/io/io_py.cpp index 3dfd6c951..d3e4abc7e 100644 --- a/python/pybind11/io/io_py.cpp +++ b/python/pybind11/io/io_py.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,6 +18,7 @@ #include "device_pydoc.h" #include + #include namespace py = pybind11; diff --git a/python/pybind11/io/init.h b/python/pybind11/io/io_py.h similarity index 100% rename from python/pybind11/io/init.h rename to python/pybind11/io/io_py.h diff --git a/python/pybind11/memory/memory_py.cpp b/python/pybind11/memory/memory_py.cpp index e840dc59c..7f5bb7734 100644 --- a/python/pybind11/memory/memory_py.cpp +++ b/python/pybind11/memory/memory_py.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,10 +14,11 @@ * limitations under the License. */ +#include "memory_py.h" #include "memory_pydoc.h" -#include "init.h" #include + #include namespace py = pybind11; @@ -29,15 +30,18 @@ void init_memory(py::module& memory) { } -static size_t calculate_memory_size(std::vector shape, const char* dtype_str) +static size_t calculate_memory_size(const std::vector& shape, const char* dtype_str) { // TODO: implement method to calculate size // https://github.com/pytorch/pytorch/blob/master/torch/tensor.py#L733 (we can take digit part) return 0; } -void get_memory_info( - py::object& buf_obj, void** out_buf, cucim::io::Device* out_device, size_t* out_memory_size, bool* out_readonly) +void get_memory_info(const py::object& buf_obj, + void** out_buf, + cucim::io::Device* out_device, + size_t* out_memory_size, + bool* out_readonly) { if (out_buf == nullptr) { diff --git a/python/pybind11/memory/init.h b/python/pybind11/memory/memory_py.h similarity index 91% rename from python/pybind11/memory/init.h rename to python/pybind11/memory/memory_py.h index 5d7260c5b..a8ec417e6 100644 --- a/python/pybind11/memory/init.h +++ b/python/pybind11/memory/memory_py.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, NVIDIA CORPORATION. + * Copyright (c) 2020-2021, NVIDIA CORPORATION. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,6 +17,7 @@ #define PYCUCIM_MEMORY_INIT_H #include + #include namespace py = pybind11; @@ -26,7 +27,7 @@ namespace cucim::memory void init_memory(py::module& m); -void get_memory_info(py::object& buf_obj, +void get_memory_info(const py::object& buf_obj, void** out_buf, cucim::io::Device* out_device = nullptr, size_t* out_memory_size = 0, diff --git a/run b/run index fde4610cc..fa2cef188 100755 --- a/run +++ b/run @@ -343,6 +343,8 @@ build_local() { local build_type_str="Debug" local prefix=${3:-} + local major_version="$(cat ${TOP}/VERSION | cut -d. -f1)" # major version number + [ "$build_type" = "debug" ] && build_type_str="Debug" [ "$build_type" = "release" ] && build_type_str="Release" [ "$build_type" = "rel-debug" ] && build_type_str="RelWithDebInfo" @@ -369,17 +371,17 @@ build_local() { # We don't need to copy binary if executed by conda-build if [ "${CONDA_BUILD:-}" != "1" ]; then # Copy .so files to pybind's build folder - # we don't need to copy symbolic links. Instead copy only libcucim.so.0 (without symbolic link) - cp ${TOP}/build-$build_type/lib*/libcucim.so.0 ${TOP}/python/cucim/src/cucim/clara/ + # we don't need to copy symbolic links. Instead copy only libcucim.so.${major_version} (without symbolic link) + cp ${TOP}/build-$build_type/lib*/libcucim.so.${major_version} ${TOP}/python/cucim/src/cucim/clara/ cp -P ${TOP}/cpp/plugins/cucim.kit.cuslide/build-$build_type/lib*/cucim* ${TOP}/python/cucim/src/cucim/clara/ # Copy .so files from pybind's build folder to cucim Python source folder # Since wheel file doesn't support symbolic link (https://github.com/pypa/wheel/issues/203), - # we don't need to copy symbolic links. Instead copy only libcucim.so.0 (without symbolic link) + # we don't need to copy symbolic links. Instead copy only libcucim.so.${major_version} (without symbolic link) #find ${TOP}/python/install/lib -maxdepth 1 -type f -exec cp {} ${TOP}/python/cucimrc/cucim/clara\; cp ${TOP}/python/build-$build_type/lib/cucim/_cucim.*.so ${TOP}/python/cucim/src/cucim/clara/ # cp ${TOP}/python/build-$build_type/lib/cucim.*.so ${TOP}/python/cucim/src/cucim/clara/ - # cp ${TOP}/python/build-$build_type/lib/libcucim.so.0 ${TOP}/python/cucim/src/cucim/clara/ + # cp ${TOP}/python/build-$build_type/lib/libcucim.so.${major_version} ${TOP}/python/cucim/src/cucim/clara/ # find ${TOP}/python/build-$build_type/lib -maxdepth 1 -type f -name "lib*.so" -exec cp {} ${TOP}/python/cucim/src/cucim/clara \; fi fi @@ -453,7 +455,7 @@ build_python_package() { repair_wheel_() { local wheel="$1" local dest="${2:-./}" - local PLAT="${3:-manylinux2014-x86_64}" + local PLAT="${3:-manylinux2014_x86_64}" if ! auditwheel show "$wheel"; then @@ -470,6 +472,7 @@ build_python_package_() { local CUCIM_SDK_PATH=${4:-${BUILD_ROOT}/libcucim} local old_opt="$(shopt -op errexit);$(shopt -op nounset)" # save old shopts + local major_version="$(cat ${TOP}/VERSION | cut -d. -f1)" # major version number set -eu # Clear CMakeCache.txt to use the latest options @@ -547,11 +550,11 @@ build_python_package_() { # Copy .so files from pybind's build folder to cucim Python source folder # Since wheel file doesn't support symbolic link (https://github.com/pypa/wheel/issues/203), - # we don't need to copy symbolic links. Instead copy only libcucim.so.0 (without symbolic link) + # we don't need to copy symbolic links. Instead copy only libcucim.so.${major_version} (without symbolic link) #find ${BUILD_ROOT}/cucim/install/lib -maxdepth 1 -type f -exec cp {} ${SRC_ROOT}/python/cucim/src/cucim/clara/ \; cp ${BUILD_ROOT}/cucim/install/lib/_cucim.*.so ${SRC_ROOT}/python/cucim/src/cucim/clara/ cp ${BUILD_ROOT}/cucim/install/lib/cucim.*.so ${SRC_ROOT}/python/cucim/src/cucim/clara/ - cp ${BUILD_ROOT}/cucim/install/lib/libcucim.so.0 ${SRC_ROOT}/python/cucim/src/cucim/clara/ + cp ${BUILD_ROOT}/cucim/install/lib/libcucim.so.${major_version} ${SRC_ROOT}/python/cucim/src/cucim/clara/ find ${BUILD_ROOT}/cucim/install/lib -maxdepth 1 -type f -name "lib*.so" -exec cp {} ${SRC_ROOT}/python/cucim/src/cucim/clara/ \; cd ${SRC_ROOT}/python/cucim @@ -937,88 +940,10 @@ publish_docs() { # Section: Release #================================================================================== -bump_version_desc() { echo 'Bump version (internal use) - -Executes bump2version(https://github.com/c4urself/bump2version) with -a post-processing. -`bump2version` package would be installed if not available. - -Post-processing includes: -- Updating version in *.ipynb files - -Returns: - Outputs executed by bump2version - - Exit code: - exit code returned from bump2version -' -} -bump_version() { - local part=${1:-} - local ret=0 - - if ! command -v bump2version > /dev/null; then - c_echo G "bump2version" W " doesn't exists. Installing " G "bump2version" W "..." - if [ -n "${CONDA_PREFIX}" ]; then - run_command pip3 install bump2version - else - run_command pip3 install --user bump2version - fi - hash -r - fi - - pushd $TOP/python/cucim - - case "$part" in - major|minor|patch) - local current_version="$(bump2version --dry-run --list --allow-dirty $part | grep -Po 'current_version=\K[\d\.]+')" - local new_version="$(bump2version --dry-run --list --allow-dirty $part | grep -Po 'new_version=\K[\d\.]+')" - c_echo W "current_version=" G "${current_version}" - c_echo W "new_version=" G "${new_version}" - - local version_from_tag="$(git tag | grep -xE 'v[0-9\.]+' | sort --version-sort | tail -n 1 | tr -d 'v')" - - # Print error if versions are not in sync. - if [ "${current_version}" != "${version_from_tag}" ]; then - c_echo_err R "version (" W "${current_version}" R ") from VERSION file doesn't match with version (" W "${version_from_tag}" R ") from tag." - c_echo_err W "Please sync those two versions!" - popd - return 1 - fi - - bump2version "$@" - ret=$? - if [ $ret -eq 0 ]; then - local file_name - for file_name in ${TOP}/notebooks/*.ipynb; do - c_echo b "processing " g "${file_name} ..." - sed -ie "s#cucim-${current_version}#cucim-${new_version}#" "${file_name}" - sed -ie "s#cucim ${current_version}#cucim ${new_version}#" "${file_name}" - sed -ie "s#cucim==${current_version}#cucim==${new_version}#" "${file_name}" - sed -ie "s#cuclara-image ${current_version}#cuclara-image ${new_version}#" "${file_name}" - sed -ie "s#cuclara-image-${current_version}#cuclara-image-${new_version}#" "${file_name}" - done - fi - ;; - *) - bump2version "$@" - ret=$? - ;; - esac - - popd - - return $ret -} - update_version_desc() { echo 'Update version Executes ci/release/update-version.sh which updates some version-related -files based on the tag. - -ci/release/update-version.sh internally call - ./run bump_version [major|minor|patch] -to update other version-realted files including VERSION files. +files based on VERSION file. Returns: Outputs executed by update-version.sh @@ -1028,7 +953,9 @@ Returns: ' } update_version() { + local new_version=${1:-} local ret=0 + [ -z "${new_version}" ] && c_echo_err R "Please specify '[new version]' (e.g., '21.06.00')!" && return 1 $TOP/ci/release/update-version.sh "$@" ret=$? diff --git a/scripts/auditwheel_repair.py b/scripts/auditwheel_repair.py index fec5f55bf..f6f4bac65 100644 --- a/scripts/auditwheel_repair.py +++ b/scripts/auditwheel_repair.py @@ -13,13 +13,15 @@ # See the License for the specific language governing permissions and # limitations under the License. -import sys import functools -from os.path import join import glob +import re +import sys +from os.path import join from unittest.mock import patch -from auditwheel.main import main + import auditwheel.elfutils +from auditwheel.main import main from auditwheel.wheeltools import InWheelCtx # How auditwheel repair works? @@ -37,14 +39,14 @@ # # With current implementation, # - `cucim/_cucim.cpython-XX-x86_64-linux-gnu.so` files are in A by 1) -# - `cucim/libcucim.so.0` is in B by 1) -# - `cucim/libcucim.so.0` and `libcudart.so.11.0` are in `needed_libs` by 2) -# - `cucim/cucim.kit.cuslide@0.1.1.so` is in A by 3) +# - `cucim/libcucim.so.??` is in B by 1) +# - `cucim/libcucim.so.??` and `libcudart.so.11.0` are in `needed_libs` by 2) +# - `cucim/cucim.kit.cuslide@??.??.??.so` is in A by 3) # # And only libz and libcudart are considered as external libraries. # To work with cuCIM, we need to -# 1) make `cucim/libcucim.so.0` as Python extension library +# 1) make `cucim/libcucim.so.??` as Python extension library # - Patch elf_is_python_extension : https://github.com/pypa/auditwheel/blob/3.2.0/auditwheel/elfutils.py#L81 # 2) control how to copy external libraries # - Patch copylib: https://github.com/pypa/auditwheel/blob/3.2.0/auditwheel/repair.py#L108 @@ -55,15 +57,15 @@ # Parameters -PYTHON_EXTENSION_LIBRARIES = { - 'cucim/libcucim.so.0' -} +PYTHON_EXTENSION_LIBRARIES = [ + r'cucim/libcucim\.so\.\d{1,2}' +] # 1) auditwheel.elfutils.elf_is_python_extension replacement orig_elf_is_python_extension = auditwheel.elfutils.elf_is_python_extension @functools.wraps(orig_elf_is_python_extension) def elf_is_python_extension(fn, elf): - if fn in PYTHON_EXTENSION_LIBRARIES: + if any(map(lambda x: re.fullmatch(x, fn), PYTHON_EXTENSION_LIBRARIES)): print("[cuCIM] Consider {} as a python extension.".format(fn)) return True, 3 return orig_elf_is_python_extension(fn, elf)