From 2d6d48245f029b29680ccbac61d8f197dff14032 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 16 Nov 2023 11:13:38 +0000 Subject: [PATCH 01/81] create python file --- src/nanopyx/core/transform/esrrf3D.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 src/nanopyx/core/transform/esrrf3D.py diff --git a/src/nanopyx/core/transform/esrrf3D.py b/src/nanopyx/core/transform/esrrf3D.py new file mode 100644 index 00000000..e69de29b From 22b129552b7a45252606c7a496435ee5bffbf429 Mon Sep 17 00:00:00 2001 From: HannahSHeil Date: Thu, 16 Nov 2023 11:29:13 +0000 Subject: [PATCH 02/81] test --- src/nanopyx/core/transform/esrrf3D.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/nanopyx/core/transform/esrrf3D.py b/src/nanopyx/core/transform/esrrf3D.py index e69de29b..73d17dc6 100644 --- a/src/nanopyx/core/transform/esrrf3D.py +++ b/src/nanopyx/core/transform/esrrf3D.py @@ -0,0 +1 @@ +# hello world \ No newline at end of file From b9a0da68cd58c09221fd4594a922971b2cca9901 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 30 Nov 2023 16:27:47 +0000 Subject: [PATCH 03/81] Update SRMetrics.ipynb --- notebooks/SRMetrics.ipynb | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/notebooks/SRMetrics.ipynb b/notebooks/SRMetrics.ipynb index 33cb8bc3..a95d0811 100644 --- a/notebooks/SRMetrics.ipynb +++ b/notebooks/SRMetrics.ipynb @@ -667,7 +667,11 @@ ] } ], - "metadata": {}, + "metadata": { + "language_info": { + "name": "python" + } + }, "nbformat": 4, "nbformat_minor": 5 } From ccd7a87541d887465ddcb8374cb969f3a015057d Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Wed, 13 Dec 2023 17:01:42 +0000 Subject: [PATCH 04/81] initial implementation of 3D interpolator --- src/nanopyx/core/transform/esrrf3D.py | 28 ++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/src/nanopyx/core/transform/esrrf3D.py b/src/nanopyx/core/transform/esrrf3D.py index 73d17dc6..0fc8f354 100644 --- a/src/nanopyx/core/transform/esrrf3D.py +++ b/src/nanopyx/core/transform/esrrf3D.py @@ -1 +1,27 @@ -# hello world \ No newline at end of file +import numpy as np +from ._le_interpolation_catmull_rom import ShiftAndMagnify + +class ESRRF3D: + def __init__(self): + pass + + def interpolate_image_3d(self, image, magnification_xy: int = 4, magnification_z: int = 4): + interpolator = ShiftAndMagnify() + + xy_interpolated = interpolator.run(image, 0, 0, magnification_xy, magnification_xy) + + xyz_interpolated = interpolator.run(np.transpose(xy_interpolated, axes=[1, 0, 2]).copy(), 0, 0, magnification_z, 1) + + return np.transpose(xyz_interpolated, axes=[1, 0, 2]).copy() + + def run(self, image, magnification_xy: int = 4, magnification_z: int = 4, radius: int = 4, sentivity: int = 1, doIntensityWeighting: bool = True): + + interpolated_image = self.interpolate_image_3d( + image, + magnification_xy=magnification_xy, + magnification_z=magnification_z + ) + + output = interpolated_image + + return output From b682bbda96351d2eabdd9030572dc702b8701eeb Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Wed, 13 Dec 2023 17:05:59 +0000 Subject: [PATCH 05/81] initial testing notebook for 3desrrf --- tests/notebooks/esrrf3d.ipynb | 103 ++++++++++++++++++++++++++++++++++ 1 file changed, 103 insertions(+) create mode 100644 tests/notebooks/esrrf3d.ipynb diff --git a/tests/notebooks/esrrf3d.ipynb b/tests/notebooks/esrrf3d.ipynb new file mode 100644 index 00000000..0507eb5e --- /dev/null +++ b/tests/notebooks/esrrf3d.ipynb @@ -0,0 +1,103 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import stackview\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "from tifffile import imread, imwrite\n", + "\n", + "from nanopyx.core.transform.esrrf3D import ESRRF3D" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d857b8c5a7f9403994958e5c8302a4a1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=50, width=50),)),)), IntSlider(value=8, descri…" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "img = imread(\"/Users/bsaraiva/Code/NanoPyx/sphere.tif\")\n", + "stackview.slice(img)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Querying the Agent...\n", + "Agent: ShiftMagnify_catmull_rom using OpenCL_Apple M1 ran in 0.02212087499999882 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_catmull_rom using OpenCL_Apple M1 ran in 0.007699542000011661 seconds\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ebd9c576fc6f48b3869068886d1aff50", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=17, des…" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "esrrf = ESRRF3D()\n", + "int_img = esrrf.run(img, magnification_xy=2, magnification_z=2)\n", + "\n", + "stackview.slice(int_img)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "nanopyxdev", + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 836413a225483a93aa3b211b5b9095f71b014c0d Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Wed, 13 Dec 2023 17:43:55 +0000 Subject: [PATCH 06/81] added a LE class for eSRRF 3D and added unthreaded calling 3D gradients --- src/nanopyx/core/transform/_interpolation.pyx | 10 ++ src/nanopyx/core/transform/_le_esrrf3d.pyx | 54 +++++++ tests/notebooks/esrrf3d.ipynb | 132 +++++++++++++++--- 3 files changed, 180 insertions(+), 16 deletions(-) create mode 100644 src/nanopyx/core/transform/_le_esrrf3d.pyx diff --git a/src/nanopyx/core/transform/_interpolation.pyx b/src/nanopyx/core/transform/_interpolation.pyx index dc39126f..0a30a30b 100644 --- a/src/nanopyx/core/transform/_interpolation.pyx +++ b/src/nanopyx/core/transform/_interpolation.pyx @@ -5,6 +5,8 @@ cimport numpy as np import cython +from ._le_interpolation_catmull_rom import ShiftAndMagnify as ShiftMagnify_CR + cdef extern from "_c_interpolation_catmull_rom.h": float _c_cr_interpolate "_c_interpolate" (float *image, float row, float col, int rows, int cols) @@ -18,3 +20,11 @@ def cr_interpolate(img_stack, row, col): img_stack = np.array(img_stack, dtype=np.float32) return _cr_interpolate(img_stack, row, col) +def interpolate_3d(image, magnification_xy: int = 5, magnification_z: int = 5): + interpolator = ShiftMagnify_CR() + + xy_interpolated = interpolator.run(image, 0, 0, magnification_xy, magnification_xy) + + xyz_interpolated = interpolator.run(np.transpose(xy_interpolated, axes=[1, 0, 2]).copy(), 0, 0, magnification_z, 1) + + return np.transpose(xyz_interpolated, axes=[1, 0, 2]).copy() \ No newline at end of file diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx new file mode 100644 index 00000000..389bcf6f --- /dev/null +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -0,0 +1,54 @@ +import numpy as np + +cimport numpy as np + +from ._interpolation import interpolate_3d +from .__interpolation_tools__ import check_image, value2array +from ...__liquid_engine__ import LiquidEngine + +cdef extern from "_c_gradients.h": + void _c_gradient_3d(float* pixels, float* GcArray, float* GrArray, float* GsArray, int frame, int w, int h) nogil + +class eSRRF3D(LiquidEngine): + """ + eSRRF 3D using the NanoPyx Liquid Engine and running as a single task. + """ + + def __init__(self, clear_benchmarks=False, testing=False): + self._designation = "eSRRF_3D" + super().__init__(clear_benchmarks=clear_benchmarks, testing=testing, + opencl_=False, unthreaded_=True, threaded_=False, threaded_static_=False, + threaded_dynamic_=False, threaded_guided_=False) + self._default_benchmarks = {'OpenCL': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 0.6182407079995755, 0.6122367919997487, 0.6093217500001629], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 0.3028541249987029, 0.2802749999991647, 0.2996904169995105]}, 'Threaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.06756008299999, 11.480632083001183, 11.368770667000717], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.490110000000641, 2.6822768330002873, 2.5428189579997706]}, 'Threaded_dynamic': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.366981125000166, 9.478710332999981, 10.355995709000126], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.020473291999224, 2.0464198749996285, 2.1126812500006054]}, 'Threaded_guided': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.59399004199986, 9.394610874998762, 10.42694429200128], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.1240765410002496, 2.1175940839984833, 2.127043415999651]}, 'Threaded_static': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.325379959000202, 11.439641291000953, 12.059574375000011], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.4486127919990395, 2.5282963329991617, 2.7061019579996355]}, 'Unthreaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 50.56610608399933, 50.84249891699983, 51.47774041699995], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 10.916643833001217, 11.070652250000421, 11.099240584000654]}} + + def run(self, float[:, :, :] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None): + image = check_image(image) + return self._run(image, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, sensitivity=sensitivity, doIntensityWeighting=doIntensityWeighting, run_type=run_type) + + def _run_unthreaded(self, float[:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Unthreaded"): + + cdef int n_frames, n_rows, n_cols + n_frames, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2] + cdef float[:, :, :] image_interpolated = interpolate_3d(image, magnification_xy, magnification_z) + + cdef float[:, :, :] gradients_s = np.zeros_like(image) + cdef float[:, :, :] gradients_r = np.zeros_like(image) + cdef float[:, :, :] gradients_c = np.zeros_like(image) + + cdef int f + + with nogil: + for f in range(n_frames): + _c_gradient_3d(&image[f, 0, 0], &gradients_c[f, 0, 0], &gradients_r[f, 0, 0], &gradients_s[f, 0, 0], f, n_rows, n_cols) + + gradients_s_interpolated = interpolate_3d(gradients_s, magnification_xy, magnification_z) + gradients_r_interpolated = interpolate_3d(gradients_r, magnification_xy, magnification_z) + gradients_c_interpolated = interpolate_3d(gradients_c, magnification_xy, magnification_z) + + return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated) + + + + + + diff --git a/tests/notebooks/esrrf3d.ipynb b/tests/notebooks/esrrf3d.ipynb index 0507eb5e..b363b8d7 100644 --- a/tests/notebooks/esrrf3d.ipynb +++ b/tests/notebooks/esrrf3d.ipynb @@ -2,27 +2,27 @@ "cells": [ { "cell_type": "code", - "execution_count": 9, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import stackview\n", "import numpy as np\n", "from matplotlib import pyplot as plt\n", - "from tifffile import imread, imwrite\n", + "from tifffile import imread\n", "\n", - "from nanopyx.core.transform.esrrf3D import ESRRF3D" + "from nanopyx.core.transform._le_esrrf3d import eSRRF3D" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d857b8c5a7f9403994958e5c8302a4a1", + "model_id": "a535ece0caca4dbea8c7e15550a1ed2f", "version_major": 2, "version_minor": 0 }, @@ -30,35 +30,63 @@ "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=50, width=50),)),)), IntSlider(value=8, descri…" ] }, - "execution_count": 10, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "img = imread(\"/Users/bsaraiva/Code/NanoPyx/sphere.tif\")\n", + "img = imread(\"/Users/bsaraiva/Code/NanoPyx/sphere.tif\").astype(np.float32)\n", "stackview.slice(img)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_catmull_rom using OpenCL_Apple M1 ran in 0.02212087499999882 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.02018916599999998 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_catmull_rom using OpenCL_Apple M1 ran in 0.007699542000011661 seconds\n" + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.008580707999999992 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.006610375000000168 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.007144500000000109 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.006712958999999907 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.0072913330000001775 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.00699012500000018 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.007410958999999995 seconds\n", + "Agent: eSRRF_3D using Unthreaded ran in 0.14057000000000008 seconds\n" ] - }, + } + ], + "source": [ + "esrrf = eSRRF3D()\n", + "int_img, grad_r_int, grad_c_int, grad_s_int = esrrf.run(img, magnification_xy=2, magnification_z=2, run_type=\"Unthreaded\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ebd9c576fc6f48b3869068886d1aff50", + "model_id": "802e41b17ba1449faa749153c05bb483", "version_major": 2, "version_minor": 0 }, @@ -66,17 +94,89 @@ "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=17, des…" ] }, - "execution_count": 11, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "esrrf = ESRRF3D()\n", - "int_img = esrrf.run(img, magnification_xy=2, magnification_z=2)\n", - "\n", "stackview.slice(int_img)" ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2bfc423b8c8a4cddb4b02ab36e42ac88", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=17, des…" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stackview.slice(grad_r_int)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d295bb80e0f94be188c1b2898c6cddc6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=17, des…" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stackview.slice(grad_c_int)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7408ae3df5e7430ca00fa5fe137dc011", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=17, des…" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stackview.slice(grad_s_int)" + ] } ], "metadata": { From 6d7e130fcf76a3dbfbba832dd5e221ca59afcd0e Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Thu, 14 Dec 2023 10:13:10 +0000 Subject: [PATCH 07/81] removed old python version --- src/nanopyx/core/transform/esrrf3D.py | 27 --------------------------- 1 file changed, 27 deletions(-) delete mode 100644 src/nanopyx/core/transform/esrrf3D.py diff --git a/src/nanopyx/core/transform/esrrf3D.py b/src/nanopyx/core/transform/esrrf3D.py deleted file mode 100644 index 0fc8f354..00000000 --- a/src/nanopyx/core/transform/esrrf3D.py +++ /dev/null @@ -1,27 +0,0 @@ -import numpy as np -from ._le_interpolation_catmull_rom import ShiftAndMagnify - -class ESRRF3D: - def __init__(self): - pass - - def interpolate_image_3d(self, image, magnification_xy: int = 4, magnification_z: int = 4): - interpolator = ShiftAndMagnify() - - xy_interpolated = interpolator.run(image, 0, 0, magnification_xy, magnification_xy) - - xyz_interpolated = interpolator.run(np.transpose(xy_interpolated, axes=[1, 0, 2]).copy(), 0, 0, magnification_z, 1) - - return np.transpose(xyz_interpolated, axes=[1, 0, 2]).copy() - - def run(self, image, magnification_xy: int = 4, magnification_z: int = 4, radius: int = 4, sentivity: int = 1, doIntensityWeighting: bool = True): - - interpolated_image = self.interpolate_image_3d( - image, - magnification_xy=magnification_xy, - magnification_z=magnification_z - ) - - output = interpolated_image - - return output From 228d12c46f971ec294da0102f81130713cdfa50c Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Thu, 14 Dec 2023 11:38:23 +0000 Subject: [PATCH 08/81] fixed a bug with gradients calculation --- src/include/_c_gradients.c | 4 +- src/include/_c_gradients.h | 2 +- src/nanopyx/core/transform/_le_esrrf3d.pyx | 10 +-- tests/notebooks/esrrf3d.ipynb | 80 +++++++++++++++------- 4 files changed, 59 insertions(+), 37 deletions(-) diff --git a/src/include/_c_gradients.c b/src/include/_c_gradients.c index 13cdd488..8c022443 100644 --- a/src/include/_c_gradients.c +++ b/src/include/_c_gradients.c @@ -66,13 +66,13 @@ void _c_gradient_roberts_cross(float* image, float* imGc, float* imGr, int rows, // as in https://www.nature.com/articles/s41592-022-01669-y#MOESM1 // 3D Gradient calculation -void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int slice, +void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int slices, int rows, int cols) { float ip0, ip1, ip2, ip3, ip4, ip5, ip6, ip7; int z_i, y_i, x_i; - for (z_i = 0; z_i < slice - 1; z_i++) { + for (z_i = 0; z_i < slices - 1; z_i++) { for (y_i = 0; y_i < rows - 1; y_i++) { for (x_i = 0; x_i < cols - 1; x_i++) { ip0 = image[z_i * rows * cols + y_i * cols + x_i]; diff --git a/src/include/_c_gradients.h b/src/include/_c_gradients.h index 132e6bdd..d8b37c1f 100644 --- a/src/include/_c_gradients.h +++ b/src/include/_c_gradients.h @@ -9,7 +9,7 @@ void _c_gradient_2point(float* image, float* imGc, float* imGr, int rows, void _c_gradient_roberts_cross(float* image, float* imGc, float* imGr, int rows, int cols); -void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int slice, +void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int slices, int rows, int cols); #endif diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 389bcf6f..f5329924 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -27,7 +27,7 @@ class eSRRF3D(LiquidEngine): def _run_unthreaded(self, float[:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Unthreaded"): - cdef int n_frames, n_rows, n_cols + cdef int n_slices, n_rows, n_cols n_frames, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2] cdef float[:, :, :] image_interpolated = interpolate_3d(image, magnification_xy, magnification_z) @@ -38,8 +38,7 @@ class eSRRF3D(LiquidEngine): cdef int f with nogil: - for f in range(n_frames): - _c_gradient_3d(&image[f, 0, 0], &gradients_c[f, 0, 0], &gradients_r[f, 0, 0], &gradients_s[f, 0, 0], f, n_rows, n_cols) + _c_gradient_3d(&image[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_frames, n_rows, n_cols) gradients_s_interpolated = interpolate_3d(gradients_s, magnification_xy, magnification_z) gradients_r_interpolated = interpolate_3d(gradients_r, magnification_xy, magnification_z) @@ -47,8 +46,3 @@ class eSRRF3D(LiquidEngine): return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated) - - - - - diff --git a/tests/notebooks/esrrf3d.ipynb b/tests/notebooks/esrrf3d.ipynb index b363b8d7..afd5abbb 100644 --- a/tests/notebooks/esrrf3d.ipynb +++ b/tests/notebooks/esrrf3d.ipynb @@ -22,7 +22,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a535ece0caca4dbea8c7e15550a1ed2f", + "model_id": "05a649fb55604690808ac2e9a2d3e044", "version_major": 2, "version_minor": 0 }, @@ -51,31 +51,32 @@ "text": [ "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.02018916599999998 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.012334040999999907 seconds\n", + "Run type OpenCL_Apple M1 was delayed in the previous run. Delay factor: 1.7529847925129785, Delay probability: 0.5972204257605743\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.008580707999999992 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.00982595900000005 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.006610375000000168 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.006617333999999975 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.007144500000000109 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.008517166000000298 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.006712958999999907 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.006548749999999881 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.0072913330000001775 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.008693249999999875 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.00699012500000018 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.006634458000000176 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.007410958999999995 seconds\n", - "Agent: eSRRF_3D using Unthreaded ran in 0.14057000000000008 seconds\n" + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.008609124999999995 seconds\n", + "Agent: eSRRF_3D using Unthreaded ran in 0.15845375000000006 seconds\n" ] } ], "source": [ "esrrf = eSRRF3D()\n", - "int_img, grad_r_int, grad_c_int, grad_s_int = esrrf.run(img, magnification_xy=2, magnification_z=2, run_type=\"Unthreaded\")" + "int_img, grad_r_int, grad_c_int, grad_s_int = esrrf.run(img, magnification_xy=2, magnification_z=6, run_type=\"Unthreaded\")" ] }, { @@ -85,13 +86,8 @@ "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "802e41b17ba1449faa749153c05bb483", - "version_major": 2, - "version_minor": 0 - }, "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=17, des…" + "(102, 100, 100)" ] }, "execution_count": 4, @@ -100,7 +96,7 @@ } ], "source": [ - "stackview.slice(int_img)" + "int_img.shape" ] }, { @@ -111,12 +107,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2bfc423b8c8a4cddb4b02ab36e42ac88", + "model_id": "57d7098b2c8149c8868e2b5de908f96f", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=17, des…" + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=51, des…" ] }, "execution_count": 5, @@ -125,7 +121,7 @@ } ], "source": [ - "stackview.slice(grad_r_int)" + "stackview.slice(int_img)" ] }, { @@ -136,12 +132,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d295bb80e0f94be188c1b2898c6cddc6", + "model_id": "f088508721134531a4193f80cecd3d64", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=17, des…" + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=51, des…" ] }, "execution_count": 6, @@ -150,7 +146,7 @@ } ], "source": [ - "stackview.slice(grad_c_int)" + "stackview.slice(grad_r_int)" ] }, { @@ -161,12 +157,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7408ae3df5e7430ca00fa5fe137dc011", + "model_id": "31b7671963274ef791272d3fc76e931f", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=17, des…" + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=51, des…" ] }, "execution_count": 7, @@ -174,9 +170,41 @@ "output_type": "execute_result" } ], + "source": [ + "stackview.slice(grad_c_int)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e97bdf92fedf497295078b2ff40e65c0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=51, des…" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "stackview.slice(grad_s_int)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 4d3e9cd94f189a0c6ca2b5c035bd0b04518df524 Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Thu, 14 Dec 2023 13:33:46 +0000 Subject: [PATCH 09/81] changed 3d interpolation to calculate interpolations on xz and yz and then average those 2 --- src/nanopyx/core/transform/_interpolation.pyx | 5 ++- tests/notebooks/esrrf3d.ipynb | 39 ++++++++++++------- 2 files changed, 27 insertions(+), 17 deletions(-) diff --git a/src/nanopyx/core/transform/_interpolation.pyx b/src/nanopyx/core/transform/_interpolation.pyx index 0a30a30b..d6236340 100644 --- a/src/nanopyx/core/transform/_interpolation.pyx +++ b/src/nanopyx/core/transform/_interpolation.pyx @@ -25,6 +25,7 @@ def interpolate_3d(image, magnification_xy: int = 5, magnification_z: int = 5): xy_interpolated = interpolator.run(image, 0, 0, magnification_xy, magnification_xy) - xyz_interpolated = interpolator.run(np.transpose(xy_interpolated, axes=[1, 0, 2]).copy(), 0, 0, magnification_z, 1) + yz_interpolated = np.transpose(interpolator.run(np.transpose(xy_interpolated, axes=[1, 0, 2]).copy(), 0, 0, magnification_z, 1), axes=[1, 0, 2]).copy() + xz_interpolated = np.transpose(interpolator.run(np.transpose(xy_interpolated, axes=[2, 1, 0]).copy(), 0, 0, 1, magnification_z), axes=[2,1,0]).copy() - return np.transpose(xyz_interpolated, axes=[1, 0, 2]).copy() \ No newline at end of file + return np.mean(np.array([yz_interpolated, xz_interpolated]), axis=0) \ No newline at end of file diff --git a/tests/notebooks/esrrf3d.ipynb b/tests/notebooks/esrrf3d.ipynb index afd5abbb..785497c4 100644 --- a/tests/notebooks/esrrf3d.ipynb +++ b/tests/notebooks/esrrf3d.ipynb @@ -22,7 +22,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "05a649fb55604690808ac2e9a2d3e044", + "model_id": "bf0fe048b134440e94635d2436edd45b", "version_major": 2, "version_minor": 0 }, @@ -51,26 +51,35 @@ "text": [ "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.012334040999999907 seconds\n", - "Run type OpenCL_Apple M1 was delayed in the previous run. Delay factor: 1.7529847925129785, Delay probability: 0.5972204257605743\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.020079792000000207 seconds\n", + "Run type OpenCL_Apple M1 was delayed in the previous run. Delay factor: 2.875227950099236, Delay probability: 0.5893735987032526\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.00982595900000005 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.011560082999999999 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.019907625000000095 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.006617333999999975 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.007537125000000255 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.010370582999999822 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.008517166000000298 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.008787583000000154 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.006548749999999881 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.006866916999999972 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.008693249999999875 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.00900195799999981 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.009124541999999902 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.006634458000000176 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.016188042000000014 seconds\n", + "Run type OpenCL_Apple M1 was delayed in the previous run. Delay factor: 2.3387598180117055, Delay probability: 0.558085032547207\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.01791374999999995 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.008609124999999995 seconds\n", - "Agent: eSRRF_3D using Unthreaded ran in 0.15845375000000006 seconds\n" + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.009524540999999775 seconds\n", + "Agent: eSRRF_3D using Unthreaded ran in 0.31416999999999984 seconds\n" ] } ], @@ -107,7 +116,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "57d7098b2c8149c8868e2b5de908f96f", + "model_id": "be83c05cce8243d79c9d6ca168e3aa9f", "version_major": 2, "version_minor": 0 }, @@ -132,7 +141,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f088508721134531a4193f80cecd3d64", + "model_id": "c825d80b082f434f971c5cb042b9e057", "version_major": 2, "version_minor": 0 }, @@ -157,7 +166,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "31b7671963274ef791272d3fc76e931f", + "model_id": "a7892ae9ab6c44aeaaf51866326daefd", "version_major": 2, "version_minor": 0 }, @@ -182,7 +191,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e97bdf92fedf497295078b2ff40e65c0", + "model_id": "4cf284ab5c2c44f9a83b19c534b050f4", "version_major": 2, "version_minor": 0 }, From e197a105a4d2d5ca1f353fa90d618f8fbf6cc07c Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 14 Dec 2023 13:35:23 +0000 Subject: [PATCH 10/81] added rgc3D --- .../_c_sr_radial_gradient_convergence.c | 77 +++++++++++++++++++ 1 file changed, 77 insertions(+) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 41d3a1fe..afe5e591 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -68,3 +68,80 @@ float _c_calculate_rgc(int xM, int yM, float* imIntGx, float* imIntGy, int colsM return RGC; } + +double _c_calculate_dk3D(float Gx, float Gy, float Gz, float dx, float dy, float dz, float distance) { + float Dk = sqrtf((Gy * dz - Gz * dy) * (Gy * dz - Gz * dy) + (Gz * dx - Gx * dz) * (Gz * dx - Gx * dz) + (Gx * dy - Gy * dx) * (Gx * dy - Gy * dx)) / sqrt(Gx * Gx + Gy * Gy + Gz * Gz); + if (isnan(Dk)) { + Dk = distance; + } + Dk = 1 - Dk / distance; + return Dk; +} + +float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSS, float sensitivity) { + + float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, distance, distanceWeight, GdotR, Dk; + + float xc = (xM + 0.5) / magnification; + float yc = (yM + 0.5) / magnification; + float zc = (sliceM + 0.5) / magnification; + + float RGC = 0; + float distanceWeightSum = 0; + + int _start = -(int)(Gx_Gy_MAGNIFICATION * fwhm); + int _end = (int)(Gx_Gy_MAGNIFICATION * fwhm + 1); + + int _start_z = -(int)(Gz_MAGNIFICATION * fwhm_z); + int _end_z = (int)(Gz_MAGNIFICATION * fwhm_z + 1); + + for (int k = _start_z; k < _end_z; k++) { + vz = (int)(Gz_MAGNIFICATION * zc) + k; + vz /= Gz_MAGNIFICATION; + + if (0 < vz && vz <= slicesM - 1) { + for (int j = _start; j < _end; j++) { + vy = (int)(Gx_Gy_MAGNIFICATION * yc) + j; + vy /= Gx_Gy_MAGNIFICATION; + + if (0 < vy && vy <= rowsM - 1) { + for (int i = _start; i < _end; i++) { + vx = (int)(Gx_Gy_MAGNIFICATION * xc) + i; + vx /= Gx_Gy_MAGNIFICATION; + + if (0 < vx && vx <= colsM - 1) { + dx = vx - xc; + dy = vy - yc; + dz = vz - zc; + distance = sqrt(dx * dx + dy * dy + dz * dz); + + if (distance != 0 && distance <= tSO) { + Gx = imIntGx[(int)(vy * magnification * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification * Gz_MAGNIFICATION)]; + Gy = imIntGy[(int)(vy * magnification * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification * Gz_MAGNIFICATION)]; + Gy = imIntGz[(int)(vy * magnification * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification * Gz_MAGNIFICATION)]; + + distanceWeight = _c_calculate_dw(distance, tSS); + distanceWeightSum += distanceWeight; + GdotR = Gx*dx + Gy*dy + Gz*dz; + + if (GdotR < 0) { + Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz, distance); + RGC += Dk * distanceWeight; + } + } + } + } + } + } + } + } + RGC /= distanceWeightSum; + + if (RGC >= 0 && sensitivity > 1) { + RGC = pow(RGC, sensitivity); + } else if (RGC < 0) { + RGC = 0; + } + + return RGC; +} From 872e5f7959c52138986e21cd3fe68adbb40bf2e3 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 14 Dec 2023 13:37:34 +0000 Subject: [PATCH 11/81] added rgd3D and dk3D --- src/include/_c_sr_radial_gradient_convergence.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/include/_c_sr_radial_gradient_convergence.h b/src/include/_c_sr_radial_gradient_convergence.h index b99e11b8..107dac10 100644 --- a/src/include/_c_sr_radial_gradient_convergence.h +++ b/src/include/_c_sr_radial_gradient_convergence.h @@ -9,4 +9,9 @@ double _c_calculate_dk(float Gx, float Gy, float dx, float dy, float distance); float _c_calculate_rgc(int xM, int yM, float* imIntGx, float* imIntGy, int colsM, int rowsM, int magnification, float Gx_Gy_MAGNIFICATION, float fwhm, float tSO, float tSS, float sensitivity); +double _c_calculate_dk3D(float Gx, float Gy, float Gz, float dx, float dy, float dz, float distance); + +float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSS, float sensitivity); + + #endif From d6c292385d24d9d1e1a3d807bdc39ebd86a94343 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 14 Dec 2023 13:41:17 +0000 Subject: [PATCH 12/81] added z magnification --- src/include/_c_sr_radial_gradient_convergence.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index afe5e591..c891c9a8 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -78,13 +78,13 @@ double _c_calculate_dk3D(float Gx, float Gy, float Gz, float dx, float dy, float return Dk; } -float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSS, float sensitivity) { +float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSS, float sensitivity) { float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, distance, distanceWeight, GdotR, Dk; - float xc = (xM + 0.5) / magnification; - float yc = (yM + 0.5) / magnification; - float zc = (sliceM + 0.5) / magnification; + float xc = (xM + 0.5) / magnification_xy; + float yc = (yM + 0.5) / magnification_xy; + float zc = (sliceM + 0.5) / magnification_z; float RGC = 0; float distanceWeightSum = 0; @@ -116,9 +116,9 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn distance = sqrt(dx * dx + dy * dy + dz * dz); if (distance != 0 && distance <= tSO) { - Gx = imIntGx[(int)(vy * magnification * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification * Gz_MAGNIFICATION)]; - Gy = imIntGy[(int)(vy * magnification * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification * Gz_MAGNIFICATION)]; - Gy = imIntGz[(int)(vy * magnification * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification * Gz_MAGNIFICATION)]; + Gx = imIntGx[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; + Gy = imIntGy[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; + Gy = imIntGz[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; distanceWeight = _c_calculate_dw(distance, tSS); distanceWeightSum += distanceWeight; From 95b4f196e4f9abff6ac4800af0903df2b4c74299 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 14 Dec 2023 14:30:15 +0000 Subject: [PATCH 13/81] split weighting in XY and Z separately --- .../_c_sr_radial_gradient_convergence.c | 37 ++++++++++++++++--- .../_c_sr_radial_gradient_convergence.h | 8 +++- 2 files changed, 39 insertions(+), 6 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index c891c9a8..a7f17163 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -69,6 +69,22 @@ float _c_calculate_rgc(int xM, int yM, float* imIntGx, float* imIntGy, int colsM return RGC; } +double _c_calculate_dw3D(double distance_xy, double distance_z, double tSS, double tSS_z) { + float D_weight_xy, D_weight_z, D_weight; + D_weight_xy = (distance_xy * exp((-distance_xy * distance_xy) / tSS)); + D_weight_z = (distance_z * exp((-distance_z * distance_z) / tSS_z)); + D_weight = (D_weight_xy + D_weight_z) / 2; + return pow(D_weight, 4); +} + +double _c_calculate_dw_xy(double distance_xy, double tSS) { + return pow((distance_xy * exp((-distance_xy * distance_xy) / tSS)), 4); +} + +double _c_calculate_dw_z(double distance_z, double tSS_z) { + return pow((distance_z * exp((-distance_z * distance_z) / tSS_z)), 4); +} + double _c_calculate_dk3D(float Gx, float Gy, float Gz, float dx, float dy, float dz, float distance) { float Dk = sqrtf((Gy * dz - Gz * dy) * (Gy * dz - Gz * dy) + (Gz * dx - Gx * dz) * (Gz * dx - Gx * dz) + (Gx * dy - Gy * dx) * (Gx * dy - Gy * dx)) / sqrt(Gx * Gx + Gy * Gy + Gz * Gz); if (isnan(Dk)) { @@ -78,9 +94,9 @@ double _c_calculate_dk3D(float Gx, float Gy, float Gz, float dx, float dy, float return Dk; } -float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSS, float sensitivity) { +float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) { - float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, distance, distanceWeight, GdotR, Dk; + float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, distance, distance_xy, distance_z, distanceWeight, distanceWeight_xy, distanceWeight_z, GdotR, Dk; float xc = (xM + 0.5) / magnification_xy; float yc = (yM + 0.5) / magnification_xy; @@ -88,6 +104,8 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn float RGC = 0; float distanceWeightSum = 0; + float distanceWeightSum_xy = 0; + float distanceWeightSum_z = 0; int _start = -(int)(Gx_Gy_MAGNIFICATION * fwhm); int _end = (int)(Gx_Gy_MAGNIFICATION * fwhm + 1); @@ -114,19 +132,27 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn dy = vy - yc; dz = vz - zc; distance = sqrt(dx * dx + dy * dy + dz * dz); + distance_xy = sqrt(dx * dx + dy * dy); + distance_z = dz; + + if (distance != 0 && distance_xy <= tSO && distance_z <= tSO_z) { - if (distance != 0 && distance <= tSO) { Gx = imIntGx[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; Gy = imIntGy[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; Gy = imIntGz[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; - distanceWeight = _c_calculate_dw(distance, tSS); + distanceWeight = _c_calculate_dw3D(distance_xy, distance_z, tSS, tSS_z); + + distanceWeight_xy = _c_calculate_dw_xy(distance_xy, tSS); distanceWeight_z = _c_calculate_dw_z(distance_z, tSS_z); + distanceWeightSum += distanceWeight; + distanceWeightSum_xy += distanceWeight_xy; + distanceWeightSum_z += distanceWeight_z; GdotR = Gx*dx + Gy*dy + Gz*dz; if (GdotR < 0) { Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz, distance); - RGC += Dk * distanceWeight; + RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; } } } @@ -135,6 +161,7 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn } } } + RGC /= distanceWeightSum; if (RGC >= 0 && sensitivity > 1) { diff --git a/src/include/_c_sr_radial_gradient_convergence.h b/src/include/_c_sr_radial_gradient_convergence.h index 107dac10..79b01851 100644 --- a/src/include/_c_sr_radial_gradient_convergence.h +++ b/src/include/_c_sr_radial_gradient_convergence.h @@ -9,9 +9,15 @@ double _c_calculate_dk(float Gx, float Gy, float dx, float dy, float distance); float _c_calculate_rgc(int xM, int yM, float* imIntGx, float* imIntGy, int colsM, int rowsM, int magnification, float Gx_Gy_MAGNIFICATION, float fwhm, float tSO, float tSS, float sensitivity); +double _c_calculate_dw3D(double distance_xy, double distance_z, double tSS, double tSS_z) { + +double _c_calculate_dw_xy(double distance_xy, double tSS); + +double _c_calculate_dw_z(double distance_z, double tSS_z); + double _c_calculate_dk3D(float Gx, float Gy, float Gz, float dx, float dy, float dz, float distance); -float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSS, float sensitivity); +float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity); #endif From 77e042fa00a6572d71f9936f773c30e49d877b3a Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Thu, 14 Dec 2023 14:48:26 +0000 Subject: [PATCH 14/81] added rgc calculation to 3desrrf --- .../_c_sr_radial_gradient_convergence.c | 2 +- .../_c_sr_radial_gradient_convergence.h | 4 +- src/nanopyx/core/transform/_le_esrrf3d.pyx | 45 ++++++++++++++++--- 3 files changed, 41 insertions(+), 10 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index a7f17163..b0f10cf9 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -139,7 +139,7 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn Gx = imIntGx[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; Gy = imIntGy[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; - Gy = imIntGz[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; + Gz = imIntGz[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; distanceWeight = _c_calculate_dw3D(distance_xy, distance_z, tSS, tSS_z); diff --git a/src/include/_c_sr_radial_gradient_convergence.h b/src/include/_c_sr_radial_gradient_convergence.h index 79b01851..24533528 100644 --- a/src/include/_c_sr_radial_gradient_convergence.h +++ b/src/include/_c_sr_radial_gradient_convergence.h @@ -9,7 +9,7 @@ double _c_calculate_dk(float Gx, float Gy, float dx, float dy, float distance); float _c_calculate_rgc(int xM, int yM, float* imIntGx, float* imIntGy, int colsM, int rowsM, int magnification, float Gx_Gy_MAGNIFICATION, float fwhm, float tSO, float tSS, float sensitivity); -double _c_calculate_dw3D(double distance_xy, double distance_z, double tSS, double tSS_z) { +double _c_calculate_dw3D(double distance_xy, double distance_z, double tSS, double tSS_z); double _c_calculate_dw_xy(double distance_xy, double tSS); @@ -17,7 +17,7 @@ double _c_calculate_dw_z(double distance_z, double tSS_z); double _c_calculate_dk3D(float Gx, float Gy, float Gz, float dx, float dy, float dz, float distance); -float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity); +float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity); #endif diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index f5329924..316fa84f 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -9,6 +9,9 @@ from ...__liquid_engine__ import LiquidEngine cdef extern from "_c_gradients.h": void _c_gradient_3d(float* pixels, float* GcArray, float* GrArray, float* GsArray, int frame, int w, int h) nogil +cdef extern from "_c_sr_radial_gradient_convergence.h": + float _c_calculate_rgc3D(float xM, float yM, float sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int _magnification_xy, int _magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) nogil + class eSRRF3D(LiquidEngine): """ eSRRF 3D using the NanoPyx Liquid Engine and running as a single task. @@ -25,24 +28,52 @@ class eSRRF3D(LiquidEngine): image = check_image(image) return self._run(image, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, sensitivity=sensitivity, doIntensityWeighting=doIntensityWeighting, run_type=run_type) - def _run_unthreaded(self, float[:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Unthreaded"): + def _run_unthreaded(self, float[:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Unthreaded"): + + cdef float sigma = radius / 2.355 + cdef float fwhm = radius + cdef float tSS = 2 * sigma * sigma + cdef float tSO = 2 * sigma + 1 + cdef float sigma_z = radius_z / 2.355 + cdef float fwhm_z = radius_z + cdef float tSS_z = 2 * sigma_z * sigma_z + cdef float tSO_z = 2 * sigma_z + 1 + cdef float Gx_Gy_Gz_MAGNIFICATION = 2.0 + cdef int _magnification_xy = magnification_xy + cdef int _magnification_z = magnification_z + cdef int _doIntensityWeighting = doIntensityWeighting cdef int n_slices, n_rows, n_cols n_frames, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2] - cdef float[:, :, :] image_interpolated = interpolate_3d(image, magnification_xy, magnification_z) + + cdef float[:, :, :] image_interpolated = interpolate_3d(image, _magnification_xy, _magnification_z) + + cdef int n_slices_mag, n_rows_mag, n_cols_mag + n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] cdef float[:, :, :] gradients_s = np.zeros_like(image) cdef float[:, :, :] gradients_r = np.zeros_like(image) cdef float[:, :, :] gradients_c = np.zeros_like(image) - cdef int f + cdef int sM, rM, cM; with nogil: _c_gradient_3d(&image[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_frames, n_rows, n_cols) - gradients_s_interpolated = interpolate_3d(gradients_s, magnification_xy, magnification_z) - gradients_r_interpolated = interpolate_3d(gradients_r, magnification_xy, magnification_z) - gradients_c_interpolated = interpolate_3d(gradients_c, magnification_xy, magnification_z) + cdef float[:, :, :] gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_z*Gx_Gy_Gz_MAGNIFICATION) + cdef float[:, :, :] gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_z*Gx_Gy_Gz_MAGNIFICATION) + cdef float[:, :, :] gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_z*Gx_Gy_Gz_MAGNIFICATION) + + cdef float[:, :, :] rgc_map = np.zeros_like(image_interpolated) + + with nogil: + for sM in range(_magnification_z*2, n_slices_mag - _magnification_z*2): + for rM in range(_magnification_xy*2, n_rows_mag - _magnification_xy*2): + for cM in range(_magnification_xy*2, n_cols - _magnification_xy*2): + if _doIntensityWeighting: + rgc_map[sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) * image_interpolated[sM, rM, cM] + else: + rgc_map[sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated) + return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map) From 5e9559d6f53454d8548a8ab68fbd235b73534fee Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 14 Dec 2023 14:50:18 +0000 Subject: [PATCH 15/81] test single distance weight --- src/include/_c_sr_radial_gradient_convergence.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index b0f10cf9..1350c28e 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -152,7 +152,8 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn if (GdotR < 0) { Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz, distance); - RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; + // RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; + RGC += Dk * distanceWeightSum; } } } @@ -161,7 +162,7 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn } } } - + RGC /= distanceWeightSum; if (RGC >= 0 && sensitivity > 1) { From 3baa396f5b364d3dd28281ccfb97d954834c12bd Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 14 Dec 2023 14:52:47 +0000 Subject: [PATCH 16/81] back to 2 component weight --- src/include/_c_sr_radial_gradient_convergence.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 1350c28e..b68a25b5 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -152,8 +152,8 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn if (GdotR < 0) { Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz, distance); - // RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; - RGC += Dk * distanceWeightSum; + RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; + // RGC += Dk * distanceWeightSum; } } } From 1a6b7cdefa499e057ebf64d44d5b2d5abbb80c25 Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Thu, 14 Dec 2023 14:55:47 +0000 Subject: [PATCH 17/81] more bugfixing --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 2 +- tests/notebooks/esrrf3d.ipynb | 174 ++++----------------- 2 files changed, 29 insertions(+), 147 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 316fa84f..b02c18e9 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -69,7 +69,7 @@ class eSRRF3D(LiquidEngine): with nogil: for sM in range(_magnification_z*2, n_slices_mag - _magnification_z*2): for rM in range(_magnification_xy*2, n_rows_mag - _magnification_xy*2): - for cM in range(_magnification_xy*2, n_cols - _magnification_xy*2): + for cM in range(_magnification_xy*2, n_cols_mag - _magnification_xy*2): if _doIntensityWeighting: rgc_map[sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) * image_interpolated[sM, rM, cM] else: diff --git a/tests/notebooks/esrrf3d.ipynb b/tests/notebooks/esrrf3d.ipynb index 785497c4..2e1db1c1 100644 --- a/tests/notebooks/esrrf3d.ipynb +++ b/tests/notebooks/esrrf3d.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -16,25 +16,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "bf0fe048b134440e94635d2436edd45b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=50, width=50),)),)), IntSlider(value=8, descri…" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "img = imread(\"/Users/bsaraiva/Code/NanoPyx/sphere.tif\").astype(np.float32)\n", "stackview.slice(img)" @@ -42,168 +26,55 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Consider adding default arguments to the njit implementation to trigger early compilation\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.020079792000000207 seconds\n", - "Run type OpenCL_Apple M1 was delayed in the previous run. Delay factor: 2.875227950099236, Delay probability: 0.5893735987032526\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.011560082999999999 seconds\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.019907625000000095 seconds\n", - "Consider adding default arguments to the njit implementation to trigger early compilation\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.007537125000000255 seconds\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.010370582999999822 seconds\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.008787583000000154 seconds\n", - "Consider adding default arguments to the njit implementation to trigger early compilation\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.006866916999999972 seconds\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.00900195799999981 seconds\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.009124541999999902 seconds\n", - "Consider adding default arguments to the njit implementation to trigger early compilation\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.016188042000000014 seconds\n", - "Run type OpenCL_Apple M1 was delayed in the previous run. Delay factor: 2.3387598180117055, Delay probability: 0.558085032547207\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.01791374999999995 seconds\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.009524540999999775 seconds\n", - "Agent: eSRRF_3D using Unthreaded ran in 0.31416999999999984 seconds\n" - ] - } - ], + "outputs": [], "source": [ "esrrf = eSRRF3D()\n", - "int_img, grad_r_int, grad_c_int, grad_s_int = esrrf.run(img, magnification_xy=2, magnification_z=6, run_type=\"Unthreaded\")" + "int_img, grad_r_int, grad_c_int, grad_s_int, rgc_img = esrrf.run(img, magnification_xy=2, magnification_z=6, run_type=\"Unthreaded\")" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(102, 100, 100)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "int_img.shape" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "be83c05cce8243d79c9d6ca168e3aa9f", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=51, des…" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "stackview.slice(int_img)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c825d80b082f434f971c5cb042b9e057", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=51, des…" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "stackview.slice(grad_r_int)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a7892ae9ab6c44aeaaf51866326daefd", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=51, des…" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "stackview.slice(grad_c_int)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4cf284ab5c2c44f9a83b19c534b050f4", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=51, des…" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "stackview.slice(grad_s_int)" ] @@ -213,7 +84,18 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "stackview.slice(rgc_img)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "stackview.slice(int_img)" + ] } ], "metadata": { From 2bb83f3f15c7e5197cc82437444c20b9eb9e77e4 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 14 Dec 2023 15:08:35 +0000 Subject: [PATCH 18/81] correct colon --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index b02c18e9..432f7b14 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -55,7 +55,7 @@ class eSRRF3D(LiquidEngine): cdef float[:, :, :] gradients_r = np.zeros_like(image) cdef float[:, :, :] gradients_c = np.zeros_like(image) - cdef int sM, rM, cM; + cdef int sM, rM, cM with nogil: _c_gradient_3d(&image[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_frames, n_rows, n_cols) From 89ec3b38a38f323703e146ae091f2ac4ab090e2f Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 14 Dec 2023 15:11:45 +0000 Subject: [PATCH 19/81] make sure magnification is int --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 432f7b14..78169956 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -38,7 +38,7 @@ class eSRRF3D(LiquidEngine): cdef float fwhm_z = radius_z cdef float tSS_z = 2 * sigma_z * sigma_z cdef float tSO_z = 2 * sigma_z + 1 - cdef float Gx_Gy_Gz_MAGNIFICATION = 2.0 + cdef int Gx_Gy_Gz_MAGNIFICATION = 2 cdef int _magnification_xy = magnification_xy cdef int _magnification_z = magnification_z cdef int _doIntensityWeighting = doIntensityWeighting From ad47df5bf27cdc1a9dba60a6e774eda486c85461 Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Thu, 14 Dec 2023 15:13:45 +0000 Subject: [PATCH 20/81] defaulted magnification to ints --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 432f7b14..78169956 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -38,7 +38,7 @@ class eSRRF3D(LiquidEngine): cdef float fwhm_z = radius_z cdef float tSS_z = 2 * sigma_z * sigma_z cdef float tSO_z = 2 * sigma_z + 1 - cdef float Gx_Gy_Gz_MAGNIFICATION = 2.0 + cdef int Gx_Gy_Gz_MAGNIFICATION = 2 cdef int _magnification_xy = magnification_xy cdef int _magnification_z = magnification_z cdef int _doIntensityWeighting = doIntensityWeighting From c7f61f64c8d36bbbfd5830aeaa5e2c2afda2ca54 Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Thu, 14 Dec 2023 15:33:15 +0000 Subject: [PATCH 21/81] added handling of timepoints --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 61 ++++++++++++---------- tests/notebooks/esrrf3d.ipynb | 11 +++- 2 files changed, 43 insertions(+), 29 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 78169956..053a1ccd 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -3,7 +3,6 @@ import numpy as np cimport numpy as np from ._interpolation import interpolate_3d -from .__interpolation_tools__ import check_image, value2array from ...__liquid_engine__ import LiquidEngine cdef extern from "_c_gradients.h": @@ -24,11 +23,16 @@ class eSRRF3D(LiquidEngine): threaded_dynamic_=False, threaded_guided_=False) self._default_benchmarks = {'OpenCL': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 0.6182407079995755, 0.6122367919997487, 0.6093217500001629], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 0.3028541249987029, 0.2802749999991647, 0.2996904169995105]}, 'Threaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.06756008299999, 11.480632083001183, 11.368770667000717], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.490110000000641, 2.6822768330002873, 2.5428189579997706]}, 'Threaded_dynamic': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.366981125000166, 9.478710332999981, 10.355995709000126], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.020473291999224, 2.0464198749996285, 2.1126812500006054]}, 'Threaded_guided': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.59399004199986, 9.394610874998762, 10.42694429200128], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.1240765410002496, 2.1175940839984833, 2.127043415999651]}, 'Threaded_static': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.325379959000202, 11.439641291000953, 12.059574375000011], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.4486127919990395, 2.5282963329991617, 2.7061019579996355]}, 'Unthreaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 50.56610608399933, 50.84249891699983, 51.47774041699995], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 10.916643833001217, 11.070652250000421, 11.099240584000654]}} - def run(self, float[:, :, :] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None): - image = check_image(image) - return self._run(image, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, sensitivity=sensitivity, doIntensityWeighting=doIntensityWeighting, run_type=run_type) + def run(self, image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None): + if image.dtype != np.float32: + image = image.astype(np.float32) + if len(image.shape) == 4: + return self._run(image, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, sensitivity=sensitivity, doIntensityWeighting=doIntensityWeighting, run_type=run_type) + elif len(image.shape) == 3: + image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2])) + return self._run(image, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, sensitivity=sensitivity, doIntensityWeighting=doIntensityWeighting, run_type=run_type) - def _run_unthreaded(self, float[:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Unthreaded"): + def _run_unthreaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Unthreaded"): cdef float sigma = radius / 2.355 cdef float fwhm = radius @@ -43,37 +47,38 @@ class eSRRF3D(LiquidEngine): cdef int _magnification_z = magnification_z cdef int _doIntensityWeighting = doIntensityWeighting - cdef int n_slices, n_rows, n_cols - n_frames, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2] + cdef int n_frames, n_slices, n_rows, n_cols + n_frames, n_slices, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2], image.shape[3] - cdef float[:, :, :] image_interpolated = interpolate_3d(image, _magnification_xy, _magnification_z) + cdef float[:, :, :, :] rgc_map = np.zeros((n_frames, n_slices*magnification_z, n_rows*magnification_xy, n_cols*magnification_xy), dtype=np.float32) + cdef float[:, :, :] image_interpolated, gradients_s, gradients_r, gradients_c, gradients_s_interpolated, gradients_r_interpolated, gradients_c_interpolated - cdef int n_slices_mag, n_rows_mag, n_cols_mag - n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] + cdef int f, n_slices_mag, n_rows_mag, n_cols_mag, sM, rM, cM - cdef float[:, :, :] gradients_s = np.zeros_like(image) - cdef float[:, :, :] gradients_r = np.zeros_like(image) - cdef float[:, :, :] gradients_c = np.zeros_like(image) + for f in range(n_frames): - cdef int sM, rM, cM + image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) + n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] - with nogil: - _c_gradient_3d(&image[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_frames, n_rows, n_cols) + gradients_s = np.zeros_like(image[0]) + gradients_r = np.zeros_like(image[0]) + gradients_c = np.zeros_like(image[0]) - cdef float[:, :, :] gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_z*Gx_Gy_Gz_MAGNIFICATION) - cdef float[:, :, :] gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_z*Gx_Gy_Gz_MAGNIFICATION) - cdef float[:, :, :] gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_z*Gx_Gy_Gz_MAGNIFICATION) + with nogil: + _c_gradient_3d(&image[f, 0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices, n_rows, n_cols) - cdef float[:, :, :] rgc_map = np.zeros_like(image_interpolated) + gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_z*Gx_Gy_Gz_MAGNIFICATION) + gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_z*Gx_Gy_Gz_MAGNIFICATION) + gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_z*Gx_Gy_Gz_MAGNIFICATION) - with nogil: - for sM in range(_magnification_z*2, n_slices_mag - _magnification_z*2): - for rM in range(_magnification_xy*2, n_rows_mag - _magnification_xy*2): - for cM in range(_magnification_xy*2, n_cols_mag - _magnification_xy*2): - if _doIntensityWeighting: - rgc_map[sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) * image_interpolated[sM, rM, cM] - else: - rgc_map[sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + with nogil: + for sM in range(_magnification_z*2, n_slices_mag - _magnification_z*2): + for rM in range(_magnification_xy*2, n_rows_mag - _magnification_xy*2): + for cM in range(_magnification_xy*2, n_cols_mag - _magnification_xy*2): + if _doIntensityWeighting: + rgc_map[f, sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) * image_interpolated[sM, rM, cM] + else: + rgc_map[f, sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map) diff --git a/tests/notebooks/esrrf3d.ipynb b/tests/notebooks/esrrf3d.ipynb index 2e1db1c1..e7ba8c09 100644 --- a/tests/notebooks/esrrf3d.ipynb +++ b/tests/notebooks/esrrf3d.ipynb @@ -85,7 +85,16 @@ "metadata": {}, "outputs": [], "source": [ - "stackview.slice(rgc_img)" + "stackview.slice(rgc_img[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "stackview.slice(np.mean(rgc_img, axis=0))" ] }, { From 415a79b410bc7fade92e13d8ba5950beac3788c4 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 14 Dec 2023 15:56:16 +0000 Subject: [PATCH 22/81] change to isotropic calculation --- .../_c_sr_radial_gradient_convergence.c | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index b68a25b5..81d04620 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -69,12 +69,14 @@ float _c_calculate_rgc(int xM, int yM, float* imIntGx, float* imIntGy, int colsM return RGC; } -double _c_calculate_dw3D(double distance_xy, double distance_z, double tSS, double tSS_z) { - float D_weight_xy, D_weight_z, D_weight; - D_weight_xy = (distance_xy * exp((-distance_xy * distance_xy) / tSS)); - D_weight_z = (distance_z * exp((-distance_z * distance_z) / tSS_z)); - D_weight = (D_weight_xy + D_weight_z) / 2; - return pow(D_weight, 4); +double _c_calculate_dw3D(double distance, double tSS) { +// (double distance_xy, double distance_z, double tSS, double tSS_z) +// float D_weight_xy, D_weight_z, D_weight; +// D_weight_xy = (distance_xy * exp((-distance_xy * distance_xy) / tSS)); +// D_weight_z = (distance_z * exp((-distance_z * distance_z) / tSS_z)); +// D_weight = (D_weight_xy + D_weight_z) / 2; +// return pow(D_weight, 4); + return pow((distance * exp((-distance * distance) / tSS)), 4); } double _c_calculate_dw_xy(double distance_xy, double tSS) { @@ -135,13 +137,13 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn distance_xy = sqrt(dx * dx + dy * dy); distance_z = dz; - if (distance != 0 && distance_xy <= tSO && distance_z <= tSO_z) { + if (distance != 0 && distance_xy <= tSO ) { // && distance_z <= tSO_z) { Gx = imIntGx[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; Gy = imIntGy[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; Gz = imIntGz[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; - distanceWeight = _c_calculate_dw3D(distance_xy, distance_z, tSS, tSS_z); + distanceWeight = _c_calculate_dw3D(distance, tSS); distanceWeight_xy = _c_calculate_dw_xy(distance_xy, tSS); distanceWeight_z = _c_calculate_dw_z(distance_z, tSS_z); @@ -152,8 +154,8 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn if (GdotR < 0) { Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz, distance); - RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; - // RGC += Dk * distanceWeightSum; + // RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; + RGC += Dk * distanceWeightSum; } } } From f4390fddf2b378c396d70e13efd50b6535a11f1d Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Fri, 15 Dec 2023 17:36:24 +0000 Subject: [PATCH 23/81] latest iteration --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 26 ++++++++++++---------- 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 053a1ccd..c3eb91be 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -51,7 +51,7 @@ class eSRRF3D(LiquidEngine): n_frames, n_slices, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2], image.shape[3] cdef float[:, :, :, :] rgc_map = np.zeros((n_frames, n_slices*magnification_z, n_rows*magnification_xy, n_cols*magnification_xy), dtype=np.float32) - cdef float[:, :, :] image_interpolated, gradients_s, gradients_r, gradients_c, gradients_s_interpolated, gradients_r_interpolated, gradients_c_interpolated + cdef float[:, :, :] image_interpolated, gradients_s, gradients_r, gradients_c, gradients_s_interpolated, gradients_r_interpolated, gradients_c_interpolated, padded cdef int f, n_slices_mag, n_rows_mag, n_cols_mag, sM, rM, cM @@ -60,25 +60,27 @@ class eSRRF3D(LiquidEngine): image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] - gradients_s = np.zeros_like(image[0]) - gradients_r = np.zeros_like(image[0]) - gradients_c = np.zeros_like(image[0]) + gradients_c = np.zeros((n_slices*Gx_Gy_Gz_MAGNIFICATION+2, n_rows*Gx_Gy_Gz_MAGNIFICATION+2, n_cols*Gx_Gy_Gz_MAGNIFICATION+2), dtype=np.float32) + gradients_r = np.zeros((n_slices*Gx_Gy_Gz_MAGNIFICATION+2, n_rows*Gx_Gy_Gz_MAGNIFICATION+2, n_cols*Gx_Gy_Gz_MAGNIFICATION+2), dtype=np.float32) + gradients_s = np.zeros((n_slices*Gx_Gy_Gz_MAGNIFICATION+2, n_rows*Gx_Gy_Gz_MAGNIFICATION+2, n_cols*Gx_Gy_Gz_MAGNIFICATION+2), dtype=np.float32) + + padded = np.pad(interpolate_3d(image[f], Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION), ((1,1), (1,1), (1,1)), 'edge') with nogil: - _c_gradient_3d(&image[f, 0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices, n_rows, n_cols) + _c_gradient_3d(&padded[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices*Gx_Gy_Gz_MAGNIFICATION+2, n_rows*Gx_Gy_Gz_MAGNIFICATION+2, n_cols*Gx_Gy_Gz_MAGNIFICATION+2) - gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_z*Gx_Gy_Gz_MAGNIFICATION) - gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_z*Gx_Gy_Gz_MAGNIFICATION) - gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_z*Gx_Gy_Gz_MAGNIFICATION) + gradients_s_interpolated = interpolate_3d(gradients_s[1:1+n_slices*Gx_Gy_Gz_MAGNIFICATION, 1:1+n_rows*Gx_Gy_Gz_MAGNIFICATION , 1:1+n_cols*Gx_Gy_Gz_MAGNIFICATION].copy(), _magnification_xy, _magnification_z) + gradients_r_interpolated = interpolate_3d(gradients_r[1:1+n_slices*Gx_Gy_Gz_MAGNIFICATION, 1:1+n_rows*Gx_Gy_Gz_MAGNIFICATION , 1:1+n_cols*Gx_Gy_Gz_MAGNIFICATION].copy(), _magnification_xy, _magnification_z) + gradients_c_interpolated = interpolate_3d(gradients_c[1:1+n_slices*Gx_Gy_Gz_MAGNIFICATION, 1:1+n_rows*Gx_Gy_Gz_MAGNIFICATION , 1:1+n_cols*Gx_Gy_Gz_MAGNIFICATION].copy(), _magnification_xy, _magnification_z) with nogil: - for sM in range(_magnification_z*2, n_slices_mag - _magnification_z*2): - for rM in range(_magnification_xy*2, n_rows_mag - _magnification_xy*2): - for cM in range(_magnification_xy*2, n_cols_mag - _magnification_xy*2): + for sM in range(0, n_slices_mag): + for rM in range(0, n_rows_mag): + for cM in range(0, n_cols_mag): if _doIntensityWeighting: rgc_map[f, sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) * image_interpolated[sM, rM, cM] else: rgc_map[f, sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map) + return np.asarray(image_interpolated), np.asarray(gradients_r), np.asarray(gradients_c),np.asarray(gradients_s), np.asarray(rgc_map) From 8a751e15596fe459e59483c1f54c56d041241193 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 15 Dec 2023 18:29:51 +0000 Subject: [PATCH 24/81] pad only in one side --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index c3eb91be..16aa02d7 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -60,18 +60,18 @@ class eSRRF3D(LiquidEngine): image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] - gradients_c = np.zeros((n_slices*Gx_Gy_Gz_MAGNIFICATION+2, n_rows*Gx_Gy_Gz_MAGNIFICATION+2, n_cols*Gx_Gy_Gz_MAGNIFICATION+2), dtype=np.float32) - gradients_r = np.zeros((n_slices*Gx_Gy_Gz_MAGNIFICATION+2, n_rows*Gx_Gy_Gz_MAGNIFICATION+2, n_cols*Gx_Gy_Gz_MAGNIFICATION+2), dtype=np.float32) - gradients_s = np.zeros((n_slices*Gx_Gy_Gz_MAGNIFICATION+2, n_rows*Gx_Gy_Gz_MAGNIFICATION+2, n_cols*Gx_Gy_Gz_MAGNIFICATION+2), dtype=np.float32) + gradients_c = np.zeros((n_slices*Gx_Gy_Gz_MAGNIFICATION+1, n_rows*Gx_Gy_Gz_MAGNIFICATION+1, n_cols*Gx_Gy_Gz_MAGNIFICATION+1), dtype=np.float32) + gradients_r = np.zeros((n_slices*Gx_Gy_Gz_MAGNIFICATION+1, n_rows*Gx_Gy_Gz_MAGNIFICATION+1, n_cols*Gx_Gy_Gz_MAGNIFICATION+1), dtype=np.float32) + gradients_s = np.zeros((n_slices*Gx_Gy_Gz_MAGNIFICATION+1, n_rows*Gx_Gy_Gz_MAGNIFICATION+1, n_cols*Gx_Gy_Gz_MAGNIFICATION+1), dtype=np.float32) - padded = np.pad(interpolate_3d(image[f], Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION), ((1,1), (1,1), (1,1)), 'edge') + padded = np.pad(interpolate_3d(image[f], Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION), ((0,1), (0,1), (0,1)), 'edge') with nogil: - _c_gradient_3d(&padded[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices*Gx_Gy_Gz_MAGNIFICATION+2, n_rows*Gx_Gy_Gz_MAGNIFICATION+2, n_cols*Gx_Gy_Gz_MAGNIFICATION+2) + _c_gradient_3d(&padded[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices*Gx_Gy_Gz_MAGNIFICATION+1, n_rows*Gx_Gy_Gz_MAGNIFICATION+1, n_cols*Gx_Gy_Gz_MAGNIFICATION+1) - gradients_s_interpolated = interpolate_3d(gradients_s[1:1+n_slices*Gx_Gy_Gz_MAGNIFICATION, 1:1+n_rows*Gx_Gy_Gz_MAGNIFICATION , 1:1+n_cols*Gx_Gy_Gz_MAGNIFICATION].copy(), _magnification_xy, _magnification_z) - gradients_r_interpolated = interpolate_3d(gradients_r[1:1+n_slices*Gx_Gy_Gz_MAGNIFICATION, 1:1+n_rows*Gx_Gy_Gz_MAGNIFICATION , 1:1+n_cols*Gx_Gy_Gz_MAGNIFICATION].copy(), _magnification_xy, _magnification_z) - gradients_c_interpolated = interpolate_3d(gradients_c[1:1+n_slices*Gx_Gy_Gz_MAGNIFICATION, 1:1+n_rows*Gx_Gy_Gz_MAGNIFICATION , 1:1+n_cols*Gx_Gy_Gz_MAGNIFICATION].copy(), _magnification_xy, _magnification_z) + gradients_s_interpolated = interpolate_3d(gradients_s[0:n_slices*Gx_Gy_Gz_MAGNIFICATION, 0:n_rows*Gx_Gy_Gz_MAGNIFICATION , 0:n_cols*Gx_Gy_Gz_MAGNIFICATION].copy(), _magnification_xy, _magnification_z) + gradients_r_interpolated = interpolate_3d(gradients_r[0:n_slices*Gx_Gy_Gz_MAGNIFICATION, 0:n_rows*Gx_Gy_Gz_MAGNIFICATION , 0:n_cols*Gx_Gy_Gz_MAGNIFICATION].copy(), _magnification_xy, _magnification_z) + gradients_c_interpolated = interpolate_3d(gradients_c[0:n_slices*Gx_Gy_Gz_MAGNIFICATION, 0:n_rows*Gx_Gy_Gz_MAGNIFICATION , 0:n_cols*Gx_Gy_Gz_MAGNIFICATION].copy(), _magnification_xy, _magnification_z) with nogil: for sM in range(0, n_slices_mag): @@ -82,5 +82,5 @@ class eSRRF3D(LiquidEngine): else: rgc_map[f, sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - return np.asarray(image_interpolated), np.asarray(gradients_r), np.asarray(gradients_c),np.asarray(gradients_s), np.asarray(rgc_map) + return np.asarray(padded), np.asarray(gradients_r), np.asarray(gradients_c),np.asarray(gradients_s), np.asarray(rgc_map) From 83ed9328cb7ed59084a55e76714c4d8bbd353536 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 15 Dec 2023 18:50:08 +0000 Subject: [PATCH 25/81] chage output and put back for debugging --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 16aa02d7..46f6658e 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -82,5 +82,5 @@ class eSRRF3D(LiquidEngine): else: rgc_map[f, sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - return np.asarray(padded), np.asarray(gradients_r), np.asarray(gradients_c),np.asarray(gradients_s), np.asarray(rgc_map) + return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map) From 80f4c06842408ed799c63de7d1481a0dbdc28aa3 Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Mon, 18 Dec 2023 13:40:18 +0000 Subject: [PATCH 26/81] added more variations of 3d esrrf --- src/include/_c_gradients.c | 19 ++ src/include/_c_gradients.h | 2 + .../_c_sr_radial_gradient_convergence.c | 100 ++++++++ .../_c_sr_radial_gradient_convergence.h | 1 + src/nanopyx/core/transform/_le_esrrf3d.pyx | 30 +-- tests/notebooks/esrrf3d.ipynb | 221 ++++++++++++++++-- 6 files changed, 337 insertions(+), 36 deletions(-) diff --git a/src/include/_c_gradients.c b/src/include/_c_gradients.c index 8c022443..4ddf530e 100644 --- a/src/include/_c_gradients.c +++ b/src/include/_c_gradients.c @@ -1,3 +1,4 @@ +#include void _c_gradient_radiality(float* image, float* imGc, float* imGr, int rows, int cols) { @@ -93,3 +94,21 @@ void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int sli } } } + +void _c_gradient_2_point_3d(float* image, float* imGc, float* imGr, float* imGs, int slices, int rows, int cols) { + int s_i, y_i, x_i, s0, y0, x0; + + for (s_i=0; s_i 0 ? s_i - 1 : 0; + y0 = y_i > 0 ? y_i - 1 : 0; + x0 = x_i > 0 ? x_i - 1 : 0; + imGc[s_i*rows*cols + y_i*cols + x_i] = image[s_i*rows*cols + y_i*cols + x_i] - image[s_i*rows*cols + y_i*cols + x0]; + imGr[s_i*rows*cols + y_i*cols + x_i] = image[s_i*rows*cols + y_i*cols + x_i] - image[s_i*rows*cols + y0*cols + x_i]; + imGs[s_i*rows*cols + y_i*cols + x_i] = image[s_i*rows*cols + y_i*cols + x_i] - image[s0*rows*cols + y_i*cols + x_i]; + + } + } + } +} \ No newline at end of file diff --git a/src/include/_c_gradients.h b/src/include/_c_gradients.h index d8b37c1f..fb946bf4 100644 --- a/src/include/_c_gradients.h +++ b/src/include/_c_gradients.h @@ -12,4 +12,6 @@ void _c_gradient_roberts_cross(float* image, float* imGc, float* imGr, int rows, void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int slices, int rows, int cols); +void _c_gradient_2_point_3d(float* image, float* imGc, float* imGr, float* imGs, int slices, int rows, int cols); + #endif diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 81d04620..137da1f9 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -1,4 +1,5 @@ #include +#include double _c_calculate_dw(double distance, double tSS) { return pow((distance * exp((-distance * distance) / tSS)), 4); @@ -175,3 +176,102 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn return RGC; } + +float _c_get_bound_value(float* im, int slices, int rows, int cols, int s, int r, int c){ + int _s = s > 0 ? s : 0; + _s = _s < slices - 1 ? _s : slices - 1; + int _r = r > 0 ? r : 0; + _r = _r < rows - 1 ? _r : rows - 1; + int _c = c > 0 ? c : 0; + _c = _c < cols - 1 ? _c : cols - 1; + + return im[_s * rows * cols + _r * cols + _c]; +} + +float _c_calculate_dk_3d(float dx, float dy, float dz, float Gx, float Gy, float Gz, float Gmag, float distance) { + float G1 = dy*Gz - dz*Gy; + float G2 = dz*Gx - dx*Gz; + float G3 = dx*Gy - dy*Gx; + float cross_product = sqrt(G1*G1 + G2*G2 + G3*G3)/Gmag; + + if (isnan(cross_product)) { + cross_product = distance; + } + + cross_product = 1 - cross_product / distance; + + return cross_product; +} + +float _c_calculate_rgc_3d(int cM, int rM, int sM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSS, float sensitivity) { + float xc = (cM + 0.5) / magnification_xy; + float yc = (rM + 0.5) / magnification_xy; + float zc = (sM + 0.5) / magnification_z; + + float RGC = 0; + float distanceWeightSum = 0; + + float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, distance, distanceWeight, GdotR, Gmag, Dk; + + int xy_start = -(int) ((float) Gx_Gy_MAGNIFICATION * (float) fwhm); + int xy_end = (int)((float) Gx_Gy_MAGNIFICATION*(float) fwhm+1); + + int z_start = - (int) fwhm_z; + int z_end = (int) fwhm_z +1; + + float vxy_offset = 0.5; + int vxy_ArrayShift = 1; + + + for (int j=xy_start; j<=xy_end;j++) { + vy = ((float) ((int) (Gx_Gy_MAGNIFICATION*yc)) + j)/(float) Gx_Gy_MAGNIFICATION; + if (vy > 0 && vy < rowsM) { + for (int i=xy_start; i<=xy_end;i++) { + vx = ((float) ((int) (Gx_Gy_MAGNIFICATION*xc)) + i)/(float) Gx_Gy_MAGNIFICATION; + if (vx > 0 && vx < colsM) { + for (int k=z_start; k<=z_end;k++) { + vz = ((float) ((int) (zc)) + k); + if (vz > 0 && vz < slicesM) { + dx = vx - xc; + dy = vy - yc; + dz = vz - zc; + distance = sqrt(dx * dx + dy * dy + dz * dz); + + if (distance != 0 && distance <= tSO) { + + Gx = _c_get_bound_value(imIntGx, slicesM, rowsM, colsM, Gx_Gy_MAGNIFICATION*(vx - vxy_offset) + vxy_ArrayShift, Gx_Gy_MAGNIFICATION*(vy - vxy_offset), vz); + Gy = _c_get_bound_value(imIntGy, slicesM, rowsM, colsM, Gx_Gy_MAGNIFICATION*(vx - vxy_offset), Gx_Gy_MAGNIFICATION*(vy - vxy_offset) + vxy_ArrayShift, vz); + Gz = _c_get_bound_value(imIntGz, slicesM, rowsM, colsM, Gx_Gy_MAGNIFICATION*(vx - vxy_offset), Gx_Gy_MAGNIFICATION*(vy - vxy_offset), vz); + + distanceWeight = distance * exp(-(distance*distance)/(float) tSS); + distanceWeight = distanceWeight * distanceWeight * distanceWeight * distanceWeight; + distanceWeightSum += distanceWeight; + GdotR = (Gx*dx + Gy*dy + Gz*dz); + + if (GdotR < 0) { + Gmag = sqrt(Gx*Gx + Gy*Gy + Gz*Gz); + Dk = _c_calculate_dk_3d(dx, dy, dz, Gx, Gy, Gz, Gmag, distance); + RGC += Dk * distanceWeight; + } + + } + } + } + } + + } + + } + } + + RGC = RGC / distanceWeightSum; + + if (RGC >= 0) { + RGC = pow(RGC, sensitivity); + } else { + RGC = 0; + } + + return RGC; + +} \ No newline at end of file diff --git a/src/include/_c_sr_radial_gradient_convergence.h b/src/include/_c_sr_radial_gradient_convergence.h index 24533528..371e6889 100644 --- a/src/include/_c_sr_radial_gradient_convergence.h +++ b/src/include/_c_sr_radial_gradient_convergence.h @@ -19,5 +19,6 @@ double _c_calculate_dk3D(float Gx, float Gy, float Gz, float dx, float dy, float float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity); +float _c_calculate_rgc_3d(int cM, int rM, int sM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSS, float sensitivity); #endif diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 46f6658e..2d4e759d 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -3,13 +3,14 @@ import numpy as np cimport numpy as np from ._interpolation import interpolate_3d +from ._le_interpolation_catmull_rom import ShiftAndMagnify from ...__liquid_engine__ import LiquidEngine cdef extern from "_c_gradients.h": - void _c_gradient_3d(float* pixels, float* GcArray, float* GrArray, float* GsArray, int frame, int w, int h) nogil + void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int slices, int rows, int cols) nogil cdef extern from "_c_sr_radial_gradient_convergence.h": - float _c_calculate_rgc3D(float xM, float yM, float sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int _magnification_xy, int _magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) nogil + float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) nogil class eSRRF3D(LiquidEngine): """ @@ -34,6 +35,8 @@ class eSRRF3D(LiquidEngine): def _run_unthreaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Unthreaded"): + interpolator = ShiftAndMagnify() + cdef float sigma = radius / 2.355 cdef float fwhm = radius cdef float tSS = 2 * sigma * sigma @@ -57,30 +60,29 @@ class eSRRF3D(LiquidEngine): for f in range(n_frames): - image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) + image_interpolated = interpolator.run(image[f], 0, 0, magnification_xy, magnification_xy) n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] - gradients_c = np.zeros((n_slices*Gx_Gy_Gz_MAGNIFICATION+1, n_rows*Gx_Gy_Gz_MAGNIFICATION+1, n_cols*Gx_Gy_Gz_MAGNIFICATION+1), dtype=np.float32) - gradients_r = np.zeros((n_slices*Gx_Gy_Gz_MAGNIFICATION+1, n_rows*Gx_Gy_Gz_MAGNIFICATION+1, n_cols*Gx_Gy_Gz_MAGNIFICATION+1), dtype=np.float32) - gradients_s = np.zeros((n_slices*Gx_Gy_Gz_MAGNIFICATION+1, n_rows*Gx_Gy_Gz_MAGNIFICATION+1, n_cols*Gx_Gy_Gz_MAGNIFICATION+1), dtype=np.float32) + gradients_c = np.zeros((n_slices, n_rows, n_cols), dtype=np.float32) + gradients_r = np.zeros((n_slices, n_rows, n_cols), dtype=np.float32) + gradients_s = np.zeros((n_slices, n_rows, n_cols), dtype=np.float32) - padded = np.pad(interpolate_3d(image[f], Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION), ((0,1), (0,1), (0,1)), 'edge') with nogil: - _c_gradient_3d(&padded[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices*Gx_Gy_Gz_MAGNIFICATION+1, n_rows*Gx_Gy_Gz_MAGNIFICATION+1, n_cols*Gx_Gy_Gz_MAGNIFICATION+1) + _c_gradient_3d(&image[f, 0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices, n_rows, n_cols) - gradients_s_interpolated = interpolate_3d(gradients_s[0:n_slices*Gx_Gy_Gz_MAGNIFICATION, 0:n_rows*Gx_Gy_Gz_MAGNIFICATION , 0:n_cols*Gx_Gy_Gz_MAGNIFICATION].copy(), _magnification_xy, _magnification_z) - gradients_r_interpolated = interpolate_3d(gradients_r[0:n_slices*Gx_Gy_Gz_MAGNIFICATION, 0:n_rows*Gx_Gy_Gz_MAGNIFICATION , 0:n_cols*Gx_Gy_Gz_MAGNIFICATION].copy(), _magnification_xy, _magnification_z) - gradients_c_interpolated = interpolate_3d(gradients_c[0:n_slices*Gx_Gy_Gz_MAGNIFICATION, 0:n_rows*Gx_Gy_Gz_MAGNIFICATION , 0:n_cols*Gx_Gy_Gz_MAGNIFICATION].copy(), _magnification_xy, _magnification_z) + gradients_s_interpolated = interpolator.run(gradients_s, 0, 0, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION) + gradients_r_interpolated = interpolator.run(gradients_r, 0, 0, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION) + gradients_c_interpolated = interpolator.run(gradients_c, 0, 0, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION) with nogil: for sM in range(0, n_slices_mag): for rM in range(0, n_rows_mag): for cM in range(0, n_cols_mag): if _doIntensityWeighting: - rgc_map[f, sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) * image_interpolated[sM, rM, cM] + rgc_map[f, sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) * image_interpolated[sM, rM, cM] else: - rgc_map[f, sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + rgc_map[f, sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map) + return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s), np.asarray(rgc_map) diff --git a/tests/notebooks/esrrf3d.ipynb b/tests/notebooks/esrrf3d.ipynb index e7ba8c09..0f111e72 100644 --- a/tests/notebooks/esrrf3d.ipynb +++ b/tests/notebooks/esrrf3d.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -16,9 +16,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "937a94c42bbf44dc8a4b803d1786926e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=50, width=50),)),)), IntSlider(value=8, descri…" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "img = imread(\"/Users/bsaraiva/Code/NanoPyx/sphere.tif\").astype(np.float32)\n", "stackview.slice(img)" @@ -26,82 +42,243 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(17, 50, 50)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "img.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.015112290999999889 seconds\n", + "Run type OpenCL_Apple M1 was delayed in the previous run. Delay factor: 1.3600333738131474, Delay probability: 0.26507060779187813\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.02325162500000033 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.026502666000000286 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.02414062500000025 seconds\n", + "Agent: eSRRF_3D using Unthreaded ran in 7.447977541 seconds\n" + ] + } + ], "source": [ "esrrf = eSRRF3D()\n", - "int_img, grad_r_int, grad_c_int, grad_s_int, rgc_img = esrrf.run(img, magnification_xy=2, magnification_z=6, run_type=\"Unthreaded\")" + "int_img, grad_r_int, grad_c_int, grad_s_int, rgc_img = esrrf.run(img, magnification_xy=8, magnification_z=1, run_type=\"Unthreaded\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(17, 400, 400)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "int_img.shape" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0becfe87eb474ab6a0b999945b29e1ac", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=400, width=400),)),)), IntSlider(value=8, desc…" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "stackview.slice(int_img)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6ecca5f25dce4813aaa16c6a673d20a2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=800, width=800),)),)), IntSlider(value=8, desc…" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "stackview.slice(grad_r_int)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "371c15dc20ec4a0297a53c913510cab8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=800, width=800),)),)), IntSlider(value=8, desc…" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "stackview.slice(grad_c_int)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "255c971ca99343d79ed64a8a79e19db2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=50, width=50),)),)), IntSlider(value=8, descri…" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "stackview.slice(grad_s_int)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6a30ff953bb64fcc8c19aff7ab97688b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=400, width=400),)),)), IntSlider(value=8, desc…" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "stackview.slice(rgc_img[0])" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2cc3d1daf7bb4854a28f0ab5b271eff3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=400, width=400),)),)), IntSlider(value=8, desc…" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "stackview.slice(np.mean(rgc_img, axis=0))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "697c1bd716fc43f38461a3068800ae29", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=400, width=400),)),)), IntSlider(value=8, desc…" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "stackview.slice(int_img)" ] From b98c0c3a7c90f84068c725d2a4cef0db55841359 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Mon, 18 Dec 2023 15:42:37 +0000 Subject: [PATCH 27/81] fixes index acess in gradients --- src/include/_c_sr_radial_gradient_convergence.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 137da1f9..115f1c36 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -103,7 +103,7 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn float xc = (xM + 0.5) / magnification_xy; float yc = (yM + 0.5) / magnification_xy; - float zc = (sliceM + 0.5) / magnification_z; + float zc = (sliceM) / magnification_z; float RGC = 0; float distanceWeightSum = 0; @@ -138,11 +138,11 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn distance_xy = sqrt(dx * dx + dy * dy); distance_z = dz; - if (distance != 0 && distance_xy <= tSO ) { // && distance_z <= tSO_z) { + if (distance != 0 && distance_xy <= tSO ) { - Gx = imIntGx[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; - Gy = imIntGy[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; - Gz = imIntGz[(int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION) + (int)(vz * magnification_z * Gz_MAGNIFICATION)]; + Gx = imIntGx[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; + Gy = imIntGy[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; + Gz = imIntGz[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; distanceWeight = _c_calculate_dw3D(distance, tSS); From 17a31ffdaf9fabd128091276ab1baaff4da0dd3d Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Mon, 18 Dec 2023 17:32:14 +0000 Subject: [PATCH 28/81] slices in RGC can access up to slicesM - 2 --- src/include/_c_sr_radial_gradient_convergence.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 115f1c36..20616a0f 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -120,7 +120,7 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn vz = (int)(Gz_MAGNIFICATION * zc) + k; vz /= Gz_MAGNIFICATION; - if (0 < vz && vz <= slicesM - 1) { + if (0 < vz && vz <= slicesM - 2) { for (int j = _start; j < _end; j++) { vy = (int)(Gx_Gy_MAGNIFICATION * yc) + j; vy /= Gx_Gy_MAGNIFICATION; From 9ce22e98f562d7fdf7d92523c2deefa1e6f7c47c Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Tue, 19 Dec 2023 15:23:01 +0000 Subject: [PATCH 29/81] new iteration --- .../_c_sr_radial_gradient_convergence.c | 63 ++++++++++--------- src/nanopyx/core/transform/_le_esrrf3d.pyx | 34 ++++++++-- 2 files changed, 61 insertions(+), 36 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 20616a0f..301af39d 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -77,7 +77,7 @@ double _c_calculate_dw3D(double distance, double tSS) { // D_weight_z = (distance_z * exp((-distance_z * distance_z) / tSS_z)); // D_weight = (D_weight_xy + D_weight_z) / 2; // return pow(D_weight, 4); - return pow((distance * exp((-distance * distance) / tSS)), 4); + return pow((distance * exp(-(distance * distance) / tSS)), 4); } double _c_calculate_dw_xy(double distance_xy, double tSS) { @@ -97,13 +97,24 @@ double _c_calculate_dk3D(float Gx, float Gy, float Gz, float dx, float dy, float return Dk; } +float _c_get_bound_value(float* im, int slices, int rows, int cols, int s, int r, int c){ + int _s = s > 0 ? s : 0; + _s = _s < slices - 1 ? _s : slices - 1; + int _r = r > 0 ? r : 0; + _r = _r < rows - 1 ? _r : rows - 1; + int _c = c > 0 ? c : 0; + _c = _c < cols - 1 ? _c : cols - 1; + + return im[_s * rows * cols + _r * cols + _c]; +} + float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) { float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, distance, distance_xy, distance_z, distanceWeight, distanceWeight_xy, distanceWeight_z, GdotR, Dk; float xc = (xM + 0.5) / magnification_xy; float yc = (yM + 0.5) / magnification_xy; - float zc = (sliceM) / magnification_z; + float zc = (sliceM + 0.5) / magnification_z; float RGC = 0; float distanceWeightSum = 0; @@ -116,21 +127,19 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn int _start_z = -(int)(Gz_MAGNIFICATION * fwhm_z); int _end_z = (int)(Gz_MAGNIFICATION * fwhm_z + 1); - for (int k = _start_z; k < _end_z; k++) { - vz = (int)(Gz_MAGNIFICATION * zc) + k; - vz /= Gz_MAGNIFICATION; + + for (int j = _start; j <= _end; j++) { + vy = ((float) ((int) (Gx_Gy_MAGNIFICATION*yc)) + j)/(float) Gx_Gy_MAGNIFICATION; - if (0 < vz && vz <= slicesM - 2) { - for (int j = _start; j < _end; j++) { - vy = (int)(Gx_Gy_MAGNIFICATION * yc) + j; - vy /= Gx_Gy_MAGNIFICATION; + if (0 < vy && vy < rowsM - 1) { + for (int i = _start; i <= _end; i++) { + vx = ((float) ((int) (Gx_Gy_MAGNIFICATION*xc)) + i)/(float) Gx_Gy_MAGNIFICATION; - if (0 < vy && vy <= rowsM - 1) { - for (int i = _start; i < _end; i++) { - vx = (int)(Gx_Gy_MAGNIFICATION * xc) + i; - vx /= Gx_Gy_MAGNIFICATION; + if (0 < vx && vx < colsM - 1) { + for (int k = _start_z; k <= _end_z; k++) { + vz = ((float) ((int) (zc)) + k); - if (0 < vx && vx <= colsM - 1) { + if (0 < vz && vz < slicesM - 1) { dx = vx - xc; dy = vy - yc; dz = vz - zc; @@ -138,11 +147,14 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn distance_xy = sqrt(dx * dx + dy * dy); distance_z = dz; - if (distance != 0 && distance_xy <= tSO ) { + if (distance != 0 && distance <= tSO ) { - Gx = imIntGx[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; - Gy = imIntGy[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; - Gz = imIntGz[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; + Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz*magnification_z*Gz_MAGNIFICATION, Gx_Gy_MAGNIFICATION*magnification_xy*vy, magnification_xy*Gx_Gy_MAGNIFICATION *vx); + Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz*magnification_z*Gz_MAGNIFICATION, magnification_xy*Gx_Gy_MAGNIFICATION * vy, magnification_xy*Gx_Gy_MAGNIFICATION * vx); + Gz = _c_get_bound_value(imIntGz, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, magnification_xy*vz*Gz_MAGNIFICATION, magnification_xy*Gx_Gy_MAGNIFICATION * vy, magnification_xy*Gx_Gy_MAGNIFICATION * vx); + //Gx = imIntGx[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; + //Gy = imIntGy[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; + //Gz = imIntGz[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; distanceWeight = _c_calculate_dw3D(distance, tSS); @@ -156,7 +168,7 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn if (GdotR < 0) { Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz, distance); // RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; - RGC += Dk * distanceWeightSum; + RGC += (Dk * distanceWeightSum); } } } @@ -168,25 +180,16 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn RGC /= distanceWeightSum; - if (RGC >= 0 && sensitivity > 1) { + if (RGC >= 0) { RGC = pow(RGC, sensitivity); - } else if (RGC < 0) { + } else { RGC = 0; } return RGC; } -float _c_get_bound_value(float* im, int slices, int rows, int cols, int s, int r, int c){ - int _s = s > 0 ? s : 0; - _s = _s < slices - 1 ? _s : slices - 1; - int _r = r > 0 ? r : 0; - _r = _r < rows - 1 ? _r : rows - 1; - int _c = c > 0 ? c : 0; - _c = _c < cols - 1 ? _c : cols - 1; - return im[_s * rows * cols + _r * cols + _c]; -} float _c_calculate_dk_3d(float dx, float dy, float dz, float Gx, float Gy, float Gz, float Gmag, float distance) { float G1 = dy*Gz - dz*Gy; diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 2d4e759d..582cdeb9 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -1,6 +1,8 @@ import numpy as np +import math cimport numpy as np +from libc.math cimport floor from ._interpolation import interpolate_3d from ._le_interpolation_catmull_rom import ShiftAndMagnify @@ -56,11 +58,13 @@ class eSRRF3D(LiquidEngine): cdef float[:, :, :, :] rgc_map = np.zeros((n_frames, n_slices*magnification_z, n_rows*magnification_xy, n_cols*magnification_xy), dtype=np.float32) cdef float[:, :, :] image_interpolated, gradients_s, gradients_r, gradients_c, gradients_s_interpolated, gradients_r_interpolated, gradients_c_interpolated, padded - cdef int f, n_slices_mag, n_rows_mag, n_cols_mag, sM, rM, cM + cdef int f, n_slices_mag, n_rows_mag, n_cols_mag, sM, rM, cM, z0 + + cdef float rgc_val, zcof for f in range(n_frames): - image_interpolated = interpolator.run(image[f], 0, 0, magnification_xy, magnification_xy) + image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] gradients_c = np.zeros((n_slices, n_rows, n_cols), dtype=np.float32) @@ -80,9 +84,27 @@ class eSRRF3D(LiquidEngine): for rM in range(0, n_rows_mag): for cM in range(0, n_cols_mag): if _doIntensityWeighting: - rgc_map[f, sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) * image_interpolated[sM, rM, cM] + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + zcof = (sM + 0.5) / _magnification_z + if (zcof < 0): + z0 = 0 + elif (zcof >= n_slices-1): + z0 = n_slices-2 + else: + z0 = floor(zcof) + z0 = z0 * _magnification_z + rgc_map[f, z0, rM, cM] = rgc_val * image_interpolated[z0, rM, cM] else: - rgc_map[f, sM, rM, cM] = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - - return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s), np.asarray(rgc_map) + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + zcof = (sM + 0.5) / _magnification_z + if (zcof < 0): + z0 = 0 + elif (zcof >= n_slices-1): + z0 = n_slices-2 + else: + z0 = floor(zcof) + z0 = z0 * _magnification_z + rgc_map[f, z0, rM, cM] = rgc_val + + return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map) From 7c301eab81826b2fafbc5ca203733bf9ae26f8a2 Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Wed, 20 Dec 2023 11:05:06 +0000 Subject: [PATCH 30/81] minor bugfix to gradient calculation --- src/include/_c_gradients.c | 26 +++++++++++++--------- src/nanopyx/core/transform/_le_esrrf3d.pyx | 4 ++-- 2 files changed, 17 insertions(+), 13 deletions(-) diff --git a/src/include/_c_gradients.c b/src/include/_c_gradients.c index 4ddf530e..a4b7b5a3 100644 --- a/src/include/_c_gradients.c +++ b/src/include/_c_gradients.c @@ -71,19 +71,23 @@ void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int sli int rows, int cols) { float ip0, ip1, ip2, ip3, ip4, ip5, ip6, ip7; - int z_i, y_i, x_i; + int z_i, y_i, x_i, z_1, y_1, x_1; - for (z_i = 0; z_i < slices - 1; z_i++) { - for (y_i = 0; y_i < rows - 1; y_i++) { - for (x_i = 0; x_i < cols - 1; x_i++) { + for (z_i = 0; z_i < slices; z_i++) { + for (y_i = 0; y_i < rows; y_i++) { + for (x_i = 0; x_i < cols; x_i++) { + + z_1 = z_i >= slices - 1 ? slices - 1 : z_i + 1; + y_1 = y_i >= rows - 1 ? rows - 1 : y_i + 1; + x_1 = x_i >= cols - 1 ? cols - 1 : x_i + 1; ip0 = image[z_i * rows * cols + y_i * cols + x_i]; - ip1 = image[z_i * rows * cols + y_i * cols + x_i + 1]; - ip2 = image[z_i * rows * cols + (y_i + 1) * cols + x_i]; - ip3 = image[z_i * rows * cols + (y_i + 1) * cols + x_i + 1]; - ip4 = image[(z_i + 1) * rows * cols + y_i * cols + x_i]; - ip5 = image[(z_i + 1) * rows * cols + y_i * cols + x_i + 1]; - ip6 = image[(z_i + 1) * rows * cols + (y_i + 1) * cols + x_i]; - ip7 = image[(z_i + 1) * rows * cols + (y_i + 1) * cols + x_i + 1]; + ip1 = image[z_i * rows * cols + y_i * cols + x_1]; + ip2 = image[z_i * rows * cols + y_1 * cols + x_i]; + ip3 = image[z_i * rows * cols + y_1 * cols + x_1]; + ip4 = image[z_1 * rows * cols + y_i * cols + x_i]; + ip5 = image[z_1 * rows * cols + y_i * cols + x_1]; + ip6 = image[z_1 * rows * cols + y_1 * cols + x_i]; + ip7 = image[z_1 * rows * cols + y_1 * cols + x_1]; imGc[z_i * rows* cols + y_i * cols + x_i] = (ip1 + ip3 + ip5 + ip7 - ip0 - ip2 - ip4 - ip6) / 4; imGr[z_i * rows* cols + y_i * cols + x_i] = diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 582cdeb9..69f59a5c 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -26,7 +26,7 @@ class eSRRF3D(LiquidEngine): threaded_dynamic_=False, threaded_guided_=False) self._default_benchmarks = {'OpenCL': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 0.6182407079995755, 0.6122367919997487, 0.6093217500001629], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 0.3028541249987029, 0.2802749999991647, 0.2996904169995105]}, 'Threaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.06756008299999, 11.480632083001183, 11.368770667000717], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.490110000000641, 2.6822768330002873, 2.5428189579997706]}, 'Threaded_dynamic': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.366981125000166, 9.478710332999981, 10.355995709000126], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.020473291999224, 2.0464198749996285, 2.1126812500006054]}, 'Threaded_guided': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.59399004199986, 9.394610874998762, 10.42694429200128], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.1240765410002496, 2.1175940839984833, 2.127043415999651]}, 'Threaded_static': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.325379959000202, 11.439641291000953, 12.059574375000011], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.4486127919990395, 2.5282963329991617, 2.7061019579996355]}, 'Unthreaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 50.56610608399933, 50.84249891699983, 51.47774041699995], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 10.916643833001217, 11.070652250000421, 11.099240584000654]}} - def run(self, image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None): + def run(self, image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None): if image.dtype != np.float32: image = image.astype(np.float32) if len(image.shape) == 4: @@ -106,5 +106,5 @@ class eSRRF3D(LiquidEngine): z0 = z0 * _magnification_z rgc_map[f, z0, rM, cM] = rgc_val - return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map) + return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c),np.asarray(gradients_s), np.asarray(rgc_map) From e087c7fe7955ac1b0c0fc8fb4eb192679eae551e Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Wed, 20 Dec 2023 12:24:47 +0000 Subject: [PATCH 31/81] corrected zo in RGC --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 69f59a5c..aa9141ee 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -85,26 +85,26 @@ class eSRRF3D(LiquidEngine): for cM in range(0, n_cols_mag): if _doIntensityWeighting: rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - zcof = (sM + 0.5) / _magnification_z + zcof = (sM) / _magnification_z if (zcof < 0): z0 = 0 elif (zcof >= n_slices-1): - z0 = n_slices-2 + z0 = n_slices-1 else: z0 = floor(zcof) z0 = z0 * _magnification_z rgc_map[f, z0, rM, cM] = rgc_val * image_interpolated[z0, rM, cM] else: rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - zcof = (sM + 0.5) / _magnification_z + zcof = (sM) / _magnification_z if (zcof < 0): z0 = 0 elif (zcof >= n_slices-1): - z0 = n_slices-2 + z0 = n_slices-1 else: z0 = floor(zcof) z0 = z0 * _magnification_z rgc_map[f, z0, rM, cM] = rgc_val - return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c),np.asarray(gradients_s), np.asarray(rgc_map) + return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map) From 0db9ca288eebfe570cad37699b4575b81b311a2f Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Wed, 20 Dec 2023 14:08:14 +0000 Subject: [PATCH 32/81] interpolate before computing gradient --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 56 +++++++++++----------- 1 file changed, 29 insertions(+), 27 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index aa9141ee..c5590c62 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -52,11 +52,11 @@ class eSRRF3D(LiquidEngine): cdef int _magnification_z = magnification_z cdef int _doIntensityWeighting = doIntensityWeighting - cdef int n_frames, n_slices, n_rows, n_cols + cdef int n_frames, n_slices, n_rows, n_cols, n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum n_frames, n_slices, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2], image.shape[3] cdef float[:, :, :, :] rgc_map = np.zeros((n_frames, n_slices*magnification_z, n_rows*magnification_xy, n_cols*magnification_xy), dtype=np.float32) - cdef float[:, :, :] image_interpolated, gradients_s, gradients_r, gradients_c, gradients_s_interpolated, gradients_r_interpolated, gradients_c_interpolated, padded + cdef float[:, :, :] image_interpolated, gradients_s, gradients_r, gradients_c, gradients_s_interpolated, gradients_r_interpolated, gradients_c_interpolated, padded, img_dum cdef int f, n_slices_mag, n_rows_mag, n_cols_mag, sM, rM, cM, z0 @@ -67,17 +67,19 @@ class eSRRF3D(LiquidEngine): image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] - gradients_c = np.zeros((n_slices, n_rows, n_cols), dtype=np.float32) - gradients_r = np.zeros((n_slices, n_rows, n_cols), dtype=np.float32) - gradients_s = np.zeros((n_slices, n_rows, n_cols), dtype=np.float32) + gradients_c = np.zeros((n_slices, n_rows*Gx_Gy_Gz_MAGNIFICATION, n_cols*Gx_Gy_Gz_MAGNIFICATION), dtype=np.float32) + gradients_r = np.zeros((n_slices, n_rows*Gx_Gy_Gz_MAGNIFICATION, n_cols*Gx_Gy_Gz_MAGNIFICATION), dtype=np.float32) + gradients_s = np.zeros((n_slices, n_rows*Gx_Gy_Gz_MAGNIFICATION, n_cols*Gx_Gy_Gz_MAGNIFICATION), dtype=np.float32) + img_dum = interpolator.run(image[f], 0, 0, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION) + n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum = img_dum.shape[0], img_dum.shape[1], img_dum.shape[2] with nogil: - _c_gradient_3d(&image[f, 0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices, n_rows, n_cols) + _c_gradient_3d(&img_dum[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices, n_rows_mag_dum, n_cols_mag_dum) - gradients_s_interpolated = interpolator.run(gradients_s, 0, 0, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION) - gradients_r_interpolated = interpolator.run(gradients_r, 0, 0, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION) - gradients_c_interpolated = interpolator.run(gradients_c, 0, 0, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION, _magnification_xy*Gx_Gy_Gz_MAGNIFICATION) + gradients_s_interpolated = interpolator.run(gradients_s, 0, 0, _magnification_xy, _magnification_xy) + gradients_r_interpolated = interpolator.run(gradients_r, 0, 0, _magnification_xy, _magnification_xy) + gradients_c_interpolated = interpolator.run(gradients_c, 0, 0, _magnification_xy, _magnification_xy) with nogil: for sM in range(0, n_slices_mag): @@ -85,26 +87,26 @@ class eSRRF3D(LiquidEngine): for cM in range(0, n_cols_mag): if _doIntensityWeighting: rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - zcof = (sM) / _magnification_z - if (zcof < 0): - z0 = 0 - elif (zcof >= n_slices-1): - z0 = n_slices-1 - else: - z0 = floor(zcof) - z0 = z0 * _magnification_z - rgc_map[f, z0, rM, cM] = rgc_val * image_interpolated[z0, rM, cM] + # zcof = (sM) / _magnification_z + # if (zcof < 0): + # z0 = 0 + # elif (zcof >= n_slices-1): + # z0 = n_slices-1 + # else: + # z0 = floor(zcof) + # z0 = z0 * _magnification_z + rgc_map[f, sM, rM, cM] = rgc_val * image_interpolated[sM, rM, cM] else: rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - zcof = (sM) / _magnification_z - if (zcof < 0): - z0 = 0 - elif (zcof >= n_slices-1): - z0 = n_slices-1 - else: - z0 = floor(zcof) - z0 = z0 * _magnification_z - rgc_map[f, z0, rM, cM] = rgc_val + # zcof = (sM) / _magnification_z + # if (zcof < 0): + # z0 = 0 + # elif (zcof >= n_slices-1): + # z0 = n_slices-1 + # else: + # z0 = floor(zcof) + # z0 = z0 * _magnification_z + rgc_map[f, sM, rM, cM] = rgc_val return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map) From ed385fd3880ee2c30d920cbe70424dce3c0682e2 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Mon, 22 Jan 2024 14:14:42 +0000 Subject: [PATCH 33/81] sort pixel referencing prblem --- src/include/_c_sr_radial_gradient_convergence.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 301af39d..296f8982 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -149,9 +149,13 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn if (distance != 0 && distance <= tSO ) { - Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz*magnification_z*Gz_MAGNIFICATION, Gx_Gy_MAGNIFICATION*magnification_xy*vy, magnification_xy*Gx_Gy_MAGNIFICATION *vx); - Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz*magnification_z*Gz_MAGNIFICATION, magnification_xy*Gx_Gy_MAGNIFICATION * vy, magnification_xy*Gx_Gy_MAGNIFICATION * vx); - Gz = _c_get_bound_value(imIntGz, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, magnification_xy*vz*Gz_MAGNIFICATION, magnification_xy*Gx_Gy_MAGNIFICATION * vy, magnification_xy*Gx_Gy_MAGNIFICATION * vx); + // Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, Gx_Gy_MAGNIFICATION * magnification_xy * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); + // Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); + // Gz = _c_get_bound_value(imIntGz, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, magnification_xy * vz * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); + + Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); + Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); + Gz = _c_get_bound_value(imIntGz, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); //Gx = imIntGx[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; //Gy = imIntGy[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; //Gz = imIntGz[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; From c0ad80d64c0d46739615767ad86b996eae31e686 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Mon, 22 Jan 2024 14:55:10 +0000 Subject: [PATCH 34/81] rename intermediate magnification --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 28 +++++++++++++--------- 1 file changed, 17 insertions(+), 11 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index c5590c62..2726e545 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -47,7 +47,7 @@ class eSRRF3D(LiquidEngine): cdef float fwhm_z = radius_z cdef float tSS_z = 2 * sigma_z * sigma_z cdef float tSO_z = 2 * sigma_z + 1 - cdef int Gx_Gy_Gz_MAGNIFICATION = 2 + cdef int Gx_Gy_MAGNIFICATION = 2 cdef int _magnification_xy = magnification_xy cdef int _magnification_z = magnification_z cdef int _doIntensityWeighting = doIntensityWeighting @@ -64,29 +64,35 @@ class eSRRF3D(LiquidEngine): for f in range(n_frames): - image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) + # image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) + image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] - gradients_c = np.zeros((n_slices, n_rows*Gx_Gy_Gz_MAGNIFICATION, n_cols*Gx_Gy_Gz_MAGNIFICATION), dtype=np.float32) - gradients_r = np.zeros((n_slices, n_rows*Gx_Gy_Gz_MAGNIFICATION, n_cols*Gx_Gy_Gz_MAGNIFICATION), dtype=np.float32) - gradients_s = np.zeros((n_slices, n_rows*Gx_Gy_Gz_MAGNIFICATION, n_cols*Gx_Gy_Gz_MAGNIFICATION), dtype=np.float32) + gradients_c = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) + gradients_r = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) + gradients_s = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) - img_dum = interpolator.run(image[f], 0, 0, Gx_Gy_Gz_MAGNIFICATION, Gx_Gy_Gz_MAGNIFICATION) + img_dum = interpolator.run(image[f], 0, 0, Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) + # img_dum = interpolate_3d(image[f], Gx_Gy_MAGNIFICATION, _magnification_z) n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum = img_dum.shape[0], img_dum.shape[1], img_dum.shape[2] with nogil: _c_gradient_3d(&img_dum[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices, n_rows_mag_dum, n_cols_mag_dum) - gradients_s_interpolated = interpolator.run(gradients_s, 0, 0, _magnification_xy, _magnification_xy) - gradients_r_interpolated = interpolator.run(gradients_r, 0, 0, _magnification_xy, _magnification_xy) - gradients_c_interpolated = interpolator.run(gradients_c, 0, 0, _magnification_xy, _magnification_xy) + # gradients_s_interpolated = interpolator.run(gradients_s, 0, 0, _magnification_xy, _magnification_xy) + # gradients_r_interpolated = interpolator.run(gradients_r, 0, 0, _magnification_xy, _magnification_xy) + # gradients_c_interpolated = interpolator.run(gradients_c, 0, 0, _magnification_xy, _magnification_xy) + + gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy, _magnification_z) + gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy, _magnification_z) + gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy, _magnification_z) with nogil: for sM in range(0, n_slices_mag): for rM in range(0, n_rows_mag): for cM in range(0, n_cols_mag): if _doIntensityWeighting: - rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) # zcof = (sM) / _magnification_z # if (zcof < 0): # z0 = 0 @@ -97,7 +103,7 @@ class eSRRF3D(LiquidEngine): # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val * image_interpolated[sM, rM, cM] else: - rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_Gz_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) # zcof = (sM) / _magnification_z # if (zcof < 0): # z0 = 0 From fe25568e5e6e7b25b1461092c632177eb9697098 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Mon, 22 Jan 2024 14:55:26 +0000 Subject: [PATCH 35/81] commented unused variables for debugging --- .../_c_sr_radial_gradient_convergence.c | 130 +++++++++--------- 1 file changed, 65 insertions(+), 65 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 296f8982..06f0962a 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -114,7 +114,7 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn float xc = (xM + 0.5) / magnification_xy; float yc = (yM + 0.5) / magnification_xy; - float zc = (sliceM + 0.5) / magnification_z; + float zc = (sliceM) / magnification_z; float RGC = 0; float distanceWeightSum = 0; @@ -126,7 +126,6 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn int _start_z = -(int)(Gz_MAGNIFICATION * fwhm_z); int _end_z = (int)(Gz_MAGNIFICATION * fwhm_z + 1); - for (int j = _start; j <= _end; j++) { vy = ((float) ((int) (Gx_Gy_MAGNIFICATION*yc)) + j)/(float) Gx_Gy_MAGNIFICATION; @@ -156,17 +155,18 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); Gz = _c_get_bound_value(imIntGz, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - //Gx = imIntGx[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; - //Gy = imIntGy[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; - //Gz = imIntGz[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; + // Gx = imIntGx[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; + // Gy = imIntGy[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; + // Gz = imIntGz[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; distanceWeight = _c_calculate_dw3D(distance, tSS); - distanceWeight_xy = _c_calculate_dw_xy(distance_xy, tSS); distanceWeight_z = _c_calculate_dw_z(distance_z, tSS_z); + // distanceWeight_xy = _c_calculate_dw_xy(distance_xy, tSS); + // distanceWeight_z = _c_calculate_dw_z(distance_z, tSS_z); distanceWeightSum += distanceWeight; - distanceWeightSum_xy += distanceWeight_xy; - distanceWeightSum_z += distanceWeight_z; + // distanceWeightSum_xy += distanceWeight_xy; + // distanceWeightSum_z += distanceWeight_z; GdotR = Gx*dx + Gy*dy + Gz*dz; if (GdotR < 0) { @@ -210,75 +210,75 @@ float _c_calculate_dk_3d(float dx, float dy, float dz, float Gx, float Gy, float return cross_product; } -float _c_calculate_rgc_3d(int cM, int rM, int sM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSS, float sensitivity) { - float xc = (cM + 0.5) / magnification_xy; - float yc = (rM + 0.5) / magnification_xy; - float zc = (sM + 0.5) / magnification_z; +// float _c_calculate_rgc_3d(int cM, int rM, int sM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSS, float sensitivity) { +// float xc = (cM + 0.5) / magnification_xy; +// float yc = (rM + 0.5) / magnification_xy; +// float zc = (sM + 0.5) / magnification_z; - float RGC = 0; - float distanceWeightSum = 0; +// float RGC = 0; +// float distanceWeightSum = 0; - float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, distance, distanceWeight, GdotR, Gmag, Dk; +// float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, distance, distanceWeight, GdotR, Gmag, Dk; - int xy_start = -(int) ((float) Gx_Gy_MAGNIFICATION * (float) fwhm); - int xy_end = (int)((float) Gx_Gy_MAGNIFICATION*(float) fwhm+1); +// int xy_start = -(int) ((float) Gx_Gy_MAGNIFICATION * (float) fwhm); +// int xy_end = (int)((float) Gx_Gy_MAGNIFICATION*(float) fwhm+1); - int z_start = - (int) fwhm_z; - int z_end = (int) fwhm_z +1; +// int z_start = - (int) fwhm_z; +// int z_end = (int) fwhm_z +1; - float vxy_offset = 0.5; - int vxy_ArrayShift = 1; +// float vxy_offset = 0.5; +// int vxy_ArrayShift = 1; - for (int j=xy_start; j<=xy_end;j++) { - vy = ((float) ((int) (Gx_Gy_MAGNIFICATION*yc)) + j)/(float) Gx_Gy_MAGNIFICATION; - if (vy > 0 && vy < rowsM) { - for (int i=xy_start; i<=xy_end;i++) { - vx = ((float) ((int) (Gx_Gy_MAGNIFICATION*xc)) + i)/(float) Gx_Gy_MAGNIFICATION; - if (vx > 0 && vx < colsM) { - for (int k=z_start; k<=z_end;k++) { - vz = ((float) ((int) (zc)) + k); - if (vz > 0 && vz < slicesM) { - dx = vx - xc; - dy = vy - yc; - dz = vz - zc; - distance = sqrt(dx * dx + dy * dy + dz * dz); +// for (int j=xy_start; j<=xy_end;j++) { +// vy = ((float) ((int) (Gx_Gy_MAGNIFICATION*yc)) + j)/(float) Gx_Gy_MAGNIFICATION; +// if (vy > 0 && vy < rowsM) { +// for (int i=xy_start; i<=xy_end;i++) { +// vx = ((float) ((int) (Gx_Gy_MAGNIFICATION*xc)) + i)/(float) Gx_Gy_MAGNIFICATION; +// if (vx > 0 && vx < colsM) { +// for (int k=z_start; k<=z_end;k++) { +// vz = ((float) ((int) (zc)) + k); +// if (vz > 0 && vz < slicesM) { +// dx = vx - xc; +// dy = vy - yc; +// dz = vz - zc; +// distance = sqrt(dx * dx + dy * dy + dz * dz); - if (distance != 0 && distance <= tSO) { +// if (distance != 0 && distance <= tSO) { - Gx = _c_get_bound_value(imIntGx, slicesM, rowsM, colsM, Gx_Gy_MAGNIFICATION*(vx - vxy_offset) + vxy_ArrayShift, Gx_Gy_MAGNIFICATION*(vy - vxy_offset), vz); - Gy = _c_get_bound_value(imIntGy, slicesM, rowsM, colsM, Gx_Gy_MAGNIFICATION*(vx - vxy_offset), Gx_Gy_MAGNIFICATION*(vy - vxy_offset) + vxy_ArrayShift, vz); - Gz = _c_get_bound_value(imIntGz, slicesM, rowsM, colsM, Gx_Gy_MAGNIFICATION*(vx - vxy_offset), Gx_Gy_MAGNIFICATION*(vy - vxy_offset), vz); - - distanceWeight = distance * exp(-(distance*distance)/(float) tSS); - distanceWeight = distanceWeight * distanceWeight * distanceWeight * distanceWeight; - distanceWeightSum += distanceWeight; - GdotR = (Gx*dx + Gy*dy + Gz*dz); - - if (GdotR < 0) { - Gmag = sqrt(Gx*Gx + Gy*Gy + Gz*Gz); - Dk = _c_calculate_dk_3d(dx, dy, dz, Gx, Gy, Gz, Gmag, distance); - RGC += Dk * distanceWeight; - } - - } - } - } - } +// Gx = _c_get_bound_value(imIntGx, slicesM, rowsM, colsM, Gx_Gy_MAGNIFICATION*(vx - vxy_offset) + vxy_ArrayShift, Gx_Gy_MAGNIFICATION*(vy - vxy_offset), vz); +// Gy = _c_get_bound_value(imIntGy, slicesM, rowsM, colsM, Gx_Gy_MAGNIFICATION*(vx - vxy_offset), Gx_Gy_MAGNIFICATION*(vy - vxy_offset) + vxy_ArrayShift, vz); +// Gz = _c_get_bound_value(imIntGz, slicesM, rowsM, colsM, Gx_Gy_MAGNIFICATION*(vx - vxy_offset), Gx_Gy_MAGNIFICATION*(vy - vxy_offset), vz); + +// distanceWeight = distance * exp(-(distance*distance)/(float) tSS); +// distanceWeight = distanceWeight * distanceWeight * distanceWeight * distanceWeight; +// distanceWeightSum += distanceWeight; +// GdotR = (Gx*dx + Gy*dy + Gz*dz); + +// if (GdotR < 0) { +// Gmag = sqrt(Gx*Gx + Gy*Gy + Gz*Gz); +// Dk = _c_calculate_dk_3d(dx, dy, dz, Gx, Gy, Gz, Gmag, distance); +// RGC += Dk * distanceWeight; +// } + +// } +// } +// } +// } - } +// } - } - } +// } +// } - RGC = RGC / distanceWeightSum; +// RGC = RGC / distanceWeightSum; - if (RGC >= 0) { - RGC = pow(RGC, sensitivity); - } else { - RGC = 0; - } +// if (RGC >= 0) { +// RGC = pow(RGC, sensitivity); +// } else { +// RGC = 0; +// } - return RGC; +// return RGC; -} \ No newline at end of file +// } \ No newline at end of file From 06d80cdbd58bf8b7fed3360396cc3ce0e2f6c53e Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Mon, 22 Jan 2024 17:15:25 +0000 Subject: [PATCH 36/81] corrected referencing pixels for rgc --- .../_c_sr_radial_gradient_convergence.c | 159 ++++++++++-------- 1 file changed, 86 insertions(+), 73 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 06f0962a..7c82dab1 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -112,6 +112,91 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, distance, distance_xy, distance_z, distanceWeight, distanceWeight_xy, distanceWeight_z, GdotR, Dk; + float xc = (xM + 0.5) / magnification_xy; + float yc = (yM + 0.5) / magnification_xy; + float zc = (sliceM + 0.5) / magnification_z; + + float RGC = 0; + float distanceWeightSum = 0; + float distanceWeightSum_xy = 0; + float distanceWeightSum_z = 0; + + int _start = -(int)(Gx_Gy_MAGNIFICATION * fwhm); + int _end = (int)(Gx_Gy_MAGNIFICATION * fwhm + 1); + + int _start_z = -(int)(Gz_MAGNIFICATION * fwhm_z); + int _end_z = (int)(Gz_MAGNIFICATION * fwhm_z + 1); + + for (int j = _start; j <= _end; j++) { + vy = ((float) ((int) (Gx_Gy_MAGNIFICATION*yc)) + j)/(float) Gx_Gy_MAGNIFICATION; + + if (0 < vy && vy < rowsM - 1) { + for (int i = _start; i <= _end; i++) { + vx = ((float) ((int) (Gx_Gy_MAGNIFICATION*xc)) + i)/(float) Gx_Gy_MAGNIFICATION; + + if (0 < vx && vx < colsM - 1) { + for (int k = _start_z; k <= _end_z; k++) { + vz = ((float) ((int) (zc)) + k); + + if (0 < vz && vz < slicesM - 1) { + dx = vx - xc; + dy = vy - yc; + dz = vz - zc; + distance = sqrt(dx * dx + dy * dy + dz * dz); + distance_xy = sqrt(dx * dx + dy * dy); + distance_z = dz; + + if (distance != 0 && distance <= tSO ) { + + // Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, Gx_Gy_MAGNIFICATION * magnification_xy * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); + // Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); + // Gz = _c_get_bound_value(imIntGz, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, magnification_xy * vz * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); + + Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); + Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); + Gz = _c_get_bound_value(imIntGz, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); + // Gx = imIntGx[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; + // Gy = imIntGy[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; + // Gz = imIntGz[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; + + distanceWeight = _c_calculate_dw3D(distance, tSS); + + // distanceWeight_xy = _c_calculate_dw_xy(distance_xy, tSS); + // distanceWeight_z = _c_calculate_dw_z(distance_z, tSS_z); + + distanceWeightSum += distanceWeight; + // distanceWeightSum_xy += distanceWeight_xy; + // distanceWeightSum_z += distanceWeight_z; + GdotR = Gx*dx + Gy*dy + Gz*dz; + + if (GdotR < 0) { + Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz, distance); + // RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; + RGC += (Dk * distanceWeightSum); + } + } + } + } + } + } + } + } + + RGC /= distanceWeightSum; + + if (RGC >= 0) { + RGC = pow(RGC, sensitivity); + } else { + RGC = 0; + } + + return RGC; +} + +float _c_calculate_rgc3D_dev(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) { + + float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, distance, distance_xy, distance_z, distanceWeight, distanceWeight_xy, distanceWeight_z, GdotR, Dk; + float xc = (xM + 0.5) / magnification_xy; float yc = (yM + 0.5) / magnification_xy; float zc = (sliceM) / magnification_z; @@ -195,6 +280,7 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn + float _c_calculate_dk_3d(float dx, float dy, float dz, float Gx, float Gy, float Gz, float Gmag, float distance) { float G1 = dy*Gz - dz*Gy; float G2 = dz*Gx - dx*Gz; @@ -209,76 +295,3 @@ float _c_calculate_dk_3d(float dx, float dy, float dz, float Gx, float Gy, float return cross_product; } - -// float _c_calculate_rgc_3d(int cM, int rM, int sM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSS, float sensitivity) { -// float xc = (cM + 0.5) / magnification_xy; -// float yc = (rM + 0.5) / magnification_xy; -// float zc = (sM + 0.5) / magnification_z; - -// float RGC = 0; -// float distanceWeightSum = 0; - -// float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, distance, distanceWeight, GdotR, Gmag, Dk; - -// int xy_start = -(int) ((float) Gx_Gy_MAGNIFICATION * (float) fwhm); -// int xy_end = (int)((float) Gx_Gy_MAGNIFICATION*(float) fwhm+1); - -// int z_start = - (int) fwhm_z; -// int z_end = (int) fwhm_z +1; - -// float vxy_offset = 0.5; -// int vxy_ArrayShift = 1; - - -// for (int j=xy_start; j<=xy_end;j++) { -// vy = ((float) ((int) (Gx_Gy_MAGNIFICATION*yc)) + j)/(float) Gx_Gy_MAGNIFICATION; -// if (vy > 0 && vy < rowsM) { -// for (int i=xy_start; i<=xy_end;i++) { -// vx = ((float) ((int) (Gx_Gy_MAGNIFICATION*xc)) + i)/(float) Gx_Gy_MAGNIFICATION; -// if (vx > 0 && vx < colsM) { -// for (int k=z_start; k<=z_end;k++) { -// vz = ((float) ((int) (zc)) + k); -// if (vz > 0 && vz < slicesM) { -// dx = vx - xc; -// dy = vy - yc; -// dz = vz - zc; -// distance = sqrt(dx * dx + dy * dy + dz * dz); - -// if (distance != 0 && distance <= tSO) { - -// Gx = _c_get_bound_value(imIntGx, slicesM, rowsM, colsM, Gx_Gy_MAGNIFICATION*(vx - vxy_offset) + vxy_ArrayShift, Gx_Gy_MAGNIFICATION*(vy - vxy_offset), vz); -// Gy = _c_get_bound_value(imIntGy, slicesM, rowsM, colsM, Gx_Gy_MAGNIFICATION*(vx - vxy_offset), Gx_Gy_MAGNIFICATION*(vy - vxy_offset) + vxy_ArrayShift, vz); -// Gz = _c_get_bound_value(imIntGz, slicesM, rowsM, colsM, Gx_Gy_MAGNIFICATION*(vx - vxy_offset), Gx_Gy_MAGNIFICATION*(vy - vxy_offset), vz); - -// distanceWeight = distance * exp(-(distance*distance)/(float) tSS); -// distanceWeight = distanceWeight * distanceWeight * distanceWeight * distanceWeight; -// distanceWeightSum += distanceWeight; -// GdotR = (Gx*dx + Gy*dy + Gz*dz); - -// if (GdotR < 0) { -// Gmag = sqrt(Gx*Gx + Gy*Gy + Gz*Gz); -// Dk = _c_calculate_dk_3d(dx, dy, dz, Gx, Gy, Gz, Gmag, distance); -// RGC += Dk * distanceWeight; -// } - -// } -// } -// } -// } - -// } - -// } -// } - -// RGC = RGC / distanceWeightSum; - -// if (RGC >= 0) { -// RGC = pow(RGC, sensitivity); -// } else { -// RGC = 0; -// } - -// return RGC; - -// } \ No newline at end of file From 93d6175fae01b34704e9439ed4b4fa5adb94bbce Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Mon, 22 Jan 2024 17:15:48 +0000 Subject: [PATCH 37/81] create developer eSRRF3D_dev function --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 102 +++++++++++++++++++++ 1 file changed, 102 insertions(+) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 2726e545..d329822c 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -13,6 +13,7 @@ cdef extern from "_c_gradients.h": cdef extern from "_c_sr_radial_gradient_convergence.h": float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) nogil + float _c_calculate_rgc3D_dev(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) nogil class eSRRF3D(LiquidEngine): """ @@ -116,3 +117,104 @@ class eSRRF3D(LiquidEngine): return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map) +class eSRRF3D_dev(LiquidEngine): + """ + eSRRF 3D using the NanoPyx Liquid Engine and running as a single task. + """ + + def __init__(self, clear_benchmarks=False, testing=False): + self._designation = "eSRRF_3D" + super().__init__(clear_benchmarks=clear_benchmarks, testing=testing, + opencl_=False, unthreaded_=True, threaded_=False, threaded_static_=False, + threaded_dynamic_=False, threaded_guided_=False) + self._default_benchmarks = {'OpenCL': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 0.6182407079995755, 0.6122367919997487, 0.6093217500001629], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 0.3028541249987029, 0.2802749999991647, 0.2996904169995105]}, 'Threaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.06756008299999, 11.480632083001183, 11.368770667000717], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.490110000000641, 2.6822768330002873, 2.5428189579997706]}, 'Threaded_dynamic': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.366981125000166, 9.478710332999981, 10.355995709000126], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.020473291999224, 2.0464198749996285, 2.1126812500006054]}, 'Threaded_guided': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.59399004199986, 9.394610874998762, 10.42694429200128], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.1240765410002496, 2.1175940839984833, 2.127043415999651]}, 'Threaded_static': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.325379959000202, 11.439641291000953, 12.059574375000011], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.4486127919990395, 2.5282963329991617, 2.7061019579996355]}, 'Unthreaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 50.56610608399933, 50.84249891699983, 51.47774041699995], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 10.916643833001217, 11.070652250000421, 11.099240584000654]}} + + def run(self, image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None): + if image.dtype != np.float32: + image = image.astype(np.float32) + if len(image.shape) == 4: + return self._run(image, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, sensitivity=sensitivity, doIntensityWeighting=doIntensityWeighting, run_type=run_type) + elif len(image.shape) == 3: + image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2])) + return self._run(image, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, sensitivity=sensitivity, doIntensityWeighting=doIntensityWeighting, run_type=run_type) + + def _run_unthreaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Unthreaded"): + + interpolator = ShiftAndMagnify() + + cdef float sigma = radius / 2.355 + cdef float fwhm = radius + cdef float tSS = 2 * sigma * sigma + cdef float tSO = 2 * sigma + 1 + cdef float sigma_z = radius_z / 2.355 + cdef float fwhm_z = radius_z + cdef float tSS_z = 2 * sigma_z * sigma_z + cdef float tSO_z = 2 * sigma_z + 1 + cdef int Gx_Gy_MAGNIFICATION = 2 + cdef int _magnification_xy = magnification_xy + cdef int _magnification_z = magnification_z + cdef int _doIntensityWeighting = doIntensityWeighting + + cdef int n_frames, n_slices, n_rows, n_cols, n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum + n_frames, n_slices, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2], image.shape[3] + + cdef float[:, :, :, :] rgc_map = np.zeros((n_frames, n_slices*magnification_z, n_rows*magnification_xy, n_cols*magnification_xy), dtype=np.float32) + cdef float[:, :, :] image_interpolated, gradients_s, gradients_r, gradients_c, gradients_s_interpolated, gradients_r_interpolated, gradients_c_interpolated, padded, img_dum + + cdef int f, n_slices_mag, n_rows_mag, n_cols_mag, sM, rM, cM, z0 + + cdef float rgc_val, zcof + + for f in range(n_frames): + + # image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) + image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) + n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] + + gradients_c = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) + gradients_r = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) + gradients_s = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) + + img_dum = interpolator.run(image[f], 0, 0, Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) + # img_dum = interpolate_3d(image[f], Gx_Gy_MAGNIFICATION, _magnification_z) + n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum = img_dum.shape[0], img_dum.shape[1], img_dum.shape[2] + + with nogil: + _c_gradient_3d(&img_dum[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices, n_rows_mag_dum, n_cols_mag_dum) + + # gradients_s_interpolated = interpolator.run(gradients_s, 0, 0, _magnification_xy, _magnification_xy) + # gradients_r_interpolated = interpolator.run(gradients_r, 0, 0, _magnification_xy, _magnification_xy) + # gradients_c_interpolated = interpolator.run(gradients_c, 0, 0, _magnification_xy, _magnification_xy) + + gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy, _magnification_z) + gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy, _magnification_z) + gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy, _magnification_z) + + with nogil: + for sM in range(0, n_slices_mag): + for rM in range(0, n_rows_mag): + for cM in range(0, n_cols_mag): + if _doIntensityWeighting: + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + # zcof = (sM) / _magnification_z + # if (zcof < 0): + # z0 = 0 + # elif (zcof >= n_slices-1): + # z0 = n_slices-1 + # else: + # z0 = floor(zcof) + # z0 = z0 * _magnification_z + rgc_map[f, sM, rM, cM] = rgc_val * image_interpolated[sM, rM, cM] + else: + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + # zcof = (sM) / _magnification_z + # if (zcof < 0): + # z0 = 0 + # elif (zcof >= n_slices-1): + # z0 = n_slices-1 + # else: + # z0 = floor(zcof) + # z0 = z0 * _magnification_z + rgc_map[f, sM, rM, cM] = rgc_val + + return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map) From f6c753c5ed02f17784ed71b6b22789c40355a743 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Tue, 13 Feb 2024 16:01:31 +0000 Subject: [PATCH 38/81] fixed RGC computation --- src/include/_c_sr_radial_gradient_convergence.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 7c82dab1..2f400524 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -172,7 +172,8 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn if (GdotR < 0) { Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz, distance); // RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; - RGC += (Dk * distanceWeightSum); + // RGC += (Dk * distanceWeightSum); // test + RGC += (Dk * distanceWeight); } } } From f2943e4399b6258ca8e0f5325382fd7bf1853a21 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Tue, 13 Feb 2024 16:10:37 +0000 Subject: [PATCH 39/81] updated development function --- src/include/_c_sr_radial_gradient_convergence.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 2f400524..7aa1c99b 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -258,7 +258,8 @@ float _c_calculate_rgc3D_dev(int xM, int yM, int sliceM, float* imIntGx, float* if (GdotR < 0) { Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz, distance); // RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; - RGC += (Dk * distanceWeightSum); + // RGC += (Dk * distanceWeightSum); // test + RGC += (Dk * distanceWeight); } } } From 760922916f14363e77a618f4768800549b9a90fa Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Tue, 13 Feb 2024 16:46:04 +0000 Subject: [PATCH 40/81] added time average still needs some fix --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 23 ++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index d329822c..90d2dfde 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -36,7 +36,7 @@ class eSRRF3D(LiquidEngine): image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2])) return self._run(image, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, sensitivity=sensitivity, doIntensityWeighting=doIntensityWeighting, run_type=run_type) - def _run_unthreaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Unthreaded"): + def _run_unthreaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, framewindow: float = 10,rollingoverlap: float = 5, doIntensityWeighting: bool = True, doRollingAvg: bool = True, run_type="Unthreaded"): interpolator = ShiftAndMagnify() @@ -52,14 +52,19 @@ class eSRRF3D(LiquidEngine): cdef int _magnification_xy = magnification_xy cdef int _magnification_z = magnification_z cdef int _doIntensityWeighting = doIntensityWeighting + cdef int _doRollingAvg = doRollingAvg cdef int n_frames, n_slices, n_rows, n_cols, n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum n_frames, n_slices, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2], image.shape[3] cdef float[:, :, :, :] rgc_map = np.zeros((n_frames, n_slices*magnification_z, n_rows*magnification_xy, n_cols*magnification_xy), dtype=np.float32) + + cdef float[:, :, :, :] avg_rgc_map = np.zeros((n_frames, n_slices*magnification_z, n_rows*magnification_xy, n_cols*magnification_xy), dtype=np.float32) + cdef float[:, :, :] image_interpolated, gradients_s, gradients_r, gradients_c, gradients_s_interpolated, gradients_r_interpolated, gradients_c_interpolated, padded, img_dum cdef int f, n_slices_mag, n_rows_mag, n_cols_mag, sM, rM, cM, z0 + cdef int w, n_windows, start_frame, end_frame cdef float rgc_val, zcof @@ -115,7 +120,21 @@ class eSRRF3D(LiquidEngine): # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val - return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map) + if _doRollingAvg: + + if rollingoverlap > 0: + n_windows = int((n_frames - framewindow) / rollingoverlap) + 1 + else: + n_windows = int(n_frames / framewindow) + + for w in range(n_windows): + + start_frame = w * (int(framewindow) - int(rollingoverlap)) + end_frame = start_frame + int(framewindow) + # do average in the first dimension of rgc_map[start_frame:end_frame ,:,:,:] with numpy + avg_rgc_map[w ,:,:,:] = np.average(rgc_map[start_frame:end_frame ,:,:,:], 0) + + return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map), np.asarray(avg_rgc_map) class eSRRF3D_dev(LiquidEngine): """ From c2890b5f6992117114709d9b837c79e073b6fe25 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Wed, 14 Feb 2024 10:14:40 +0000 Subject: [PATCH 41/81] time average implemented --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 90d2dfde..dafef499 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -132,7 +132,7 @@ class eSRRF3D(LiquidEngine): start_frame = w * (int(framewindow) - int(rollingoverlap)) end_frame = start_frame + int(framewindow) # do average in the first dimension of rgc_map[start_frame:end_frame ,:,:,:] with numpy - avg_rgc_map[w ,:,:,:] = np.average(rgc_map[start_frame:end_frame ,:,:,:], 0) + avg_rgc_map[w,:,:,:] = np.average(rgc_map[start_frame:end_frame,:,:,:], 0) return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map), np.asarray(avg_rgc_map) From 3a9b0e538c56cc9dd89999068cf8dffc26a3d907 Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Wed, 14 Feb 2024 10:41:35 +0000 Subject: [PATCH 42/81] removed _dev version. added placeholder variables to also provide users with intermediary steps --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 114 +++------------------ 1 file changed, 12 insertions(+), 102 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index dafef499..1813104d 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -26,8 +26,11 @@ class eSRRF3D(LiquidEngine): opencl_=False, unthreaded_=True, threaded_=False, threaded_static_=False, threaded_dynamic_=False, threaded_guided_=False) self._default_benchmarks = {'OpenCL': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 0.6182407079995755, 0.6122367919997487, 0.6093217500001629], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 0.3028541249987029, 0.2802749999991647, 0.2996904169995105]}, 'Threaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.06756008299999, 11.480632083001183, 11.368770667000717], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.490110000000641, 2.6822768330002873, 2.5428189579997706]}, 'Threaded_dynamic': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.366981125000166, 9.478710332999981, 10.355995709000126], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.020473291999224, 2.0464198749996285, 2.1126812500006054]}, 'Threaded_guided': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.59399004199986, 9.394610874998762, 10.42694429200128], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.1240765410002496, 2.1175940839984833, 2.127043415999651]}, 'Threaded_static': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.325379959000202, 11.439641291000953, 12.059574375000011], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.4486127919990395, 2.5282963329991617, 2.7061019579996355]}, 'Unthreaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 50.56610608399933, 50.84249891699983, 51.47774041699995], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 10.916643833001217, 11.070652250000421, 11.099240584000654]}} + self._gradients_c_interpolated = None + self.keep_gradients = False - def run(self, image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None): + def run(self, image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None, keep_gradients=False): + self.keep_gradients = keep_gradients if image.dtype != np.float32: image = image.astype(np.float32) if len(image.shape) == 4: @@ -93,6 +96,9 @@ class eSRRF3D(LiquidEngine): gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy, _magnification_z) gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy, _magnification_z) + if self.keep_gradients: + self._gradients_c_interpolated = gradients_c_interpolated.copy() + with nogil: for sM in range(0, n_slices_mag): for rM in range(0, n_rows_mag): @@ -136,104 +142,8 @@ class eSRRF3D(LiquidEngine): return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map), np.asarray(avg_rgc_map) -class eSRRF3D_dev(LiquidEngine): - """ - eSRRF 3D using the NanoPyx Liquid Engine and running as a single task. - """ - - def __init__(self, clear_benchmarks=False, testing=False): - self._designation = "eSRRF_3D" - super().__init__(clear_benchmarks=clear_benchmarks, testing=testing, - opencl_=False, unthreaded_=True, threaded_=False, threaded_static_=False, - threaded_dynamic_=False, threaded_guided_=False) - self._default_benchmarks = {'OpenCL': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 0.6182407079995755, 0.6122367919997487, 0.6093217500001629], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 0.3028541249987029, 0.2802749999991647, 0.2996904169995105]}, 'Threaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.06756008299999, 11.480632083001183, 11.368770667000717], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.490110000000641, 2.6822768330002873, 2.5428189579997706]}, 'Threaded_dynamic': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.366981125000166, 9.478710332999981, 10.355995709000126], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.020473291999224, 2.0464198749996285, 2.1126812500006054]}, 'Threaded_guided': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.59399004199986, 9.394610874998762, 10.42694429200128], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.1240765410002496, 2.1175940839984833, 2.127043415999651]}, 'Threaded_static': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.325379959000202, 11.439641291000953, 12.059574375000011], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.4486127919990395, 2.5282963329991617, 2.7061019579996355]}, 'Unthreaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 50.56610608399933, 50.84249891699983, 51.47774041699995], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 10.916643833001217, 11.070652250000421, 11.099240584000654]}} - - def run(self, image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None): - if image.dtype != np.float32: - image = image.astype(np.float32) - if len(image.shape) == 4: - return self._run(image, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, sensitivity=sensitivity, doIntensityWeighting=doIntensityWeighting, run_type=run_type) - elif len(image.shape) == 3: - image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2])) - return self._run(image, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, sensitivity=sensitivity, doIntensityWeighting=doIntensityWeighting, run_type=run_type) - - def _run_unthreaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Unthreaded"): - - interpolator = ShiftAndMagnify() - - cdef float sigma = radius / 2.355 - cdef float fwhm = radius - cdef float tSS = 2 * sigma * sigma - cdef float tSO = 2 * sigma + 1 - cdef float sigma_z = radius_z / 2.355 - cdef float fwhm_z = radius_z - cdef float tSS_z = 2 * sigma_z * sigma_z - cdef float tSO_z = 2 * sigma_z + 1 - cdef int Gx_Gy_MAGNIFICATION = 2 - cdef int _magnification_xy = magnification_xy - cdef int _magnification_z = magnification_z - cdef int _doIntensityWeighting = doIntensityWeighting - - cdef int n_frames, n_slices, n_rows, n_cols, n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum - n_frames, n_slices, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2], image.shape[3] - - cdef float[:, :, :, :] rgc_map = np.zeros((n_frames, n_slices*magnification_z, n_rows*magnification_xy, n_cols*magnification_xy), dtype=np.float32) - cdef float[:, :, :] image_interpolated, gradients_s, gradients_r, gradients_c, gradients_s_interpolated, gradients_r_interpolated, gradients_c_interpolated, padded, img_dum - - cdef int f, n_slices_mag, n_rows_mag, n_cols_mag, sM, rM, cM, z0 - - cdef float rgc_val, zcof - - for f in range(n_frames): - - # image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) - image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) - n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] - - gradients_c = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) - gradients_r = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) - gradients_s = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) - - img_dum = interpolator.run(image[f], 0, 0, Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) - # img_dum = interpolate_3d(image[f], Gx_Gy_MAGNIFICATION, _magnification_z) - n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum = img_dum.shape[0], img_dum.shape[1], img_dum.shape[2] - - with nogil: - _c_gradient_3d(&img_dum[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices, n_rows_mag_dum, n_cols_mag_dum) - - # gradients_s_interpolated = interpolator.run(gradients_s, 0, 0, _magnification_xy, _magnification_xy) - # gradients_r_interpolated = interpolator.run(gradients_r, 0, 0, _magnification_xy, _magnification_xy) - # gradients_c_interpolated = interpolator.run(gradients_c, 0, 0, _magnification_xy, _magnification_xy) - - gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy, _magnification_z) - gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy, _magnification_z) - gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy, _magnification_z) - - with nogil: - for sM in range(0, n_slices_mag): - for rM in range(0, n_rows_mag): - for cM in range(0, n_cols_mag): - if _doIntensityWeighting: - rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - # zcof = (sM) / _magnification_z - # if (zcof < 0): - # z0 = 0 - # elif (zcof >= n_slices-1): - # z0 = n_slices-1 - # else: - # z0 = floor(zcof) - # z0 = z0 * _magnification_z - rgc_map[f, sM, rM, cM] = rgc_val * image_interpolated[sM, rM, cM] - else: - rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - # zcof = (sM) / _magnification_z - # if (zcof < 0): - # z0 = 0 - # elif (zcof >= n_slices-1): - # z0 = n_slices-1 - # else: - # z0 = floor(zcof) - # z0 = z0 * _magnification_z - rgc_map[f, sM, rM, cM] = rgc_val - - return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map) + def get_gradients(self): + if self._gradients_c_interpolated is None: + print("Gradients not yet calculated") + else: + return self._gradients_c_interpolated, self._gradients_r_interpolated, From 231a9ec6c8c6e2ca5be2c6979e401dd6099fb5e6 Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Wed, 14 Feb 2024 10:48:38 +0000 Subject: [PATCH 43/81] added 3d esrrf method --- src/nanopyx/methods/esrrf_3d/__init__.py | 0 src/nanopyx/methods/esrrf_3d/run.py | 6 ++++++ 2 files changed, 6 insertions(+) create mode 100644 src/nanopyx/methods/esrrf_3d/__init__.py create mode 100644 src/nanopyx/methods/esrrf_3d/run.py diff --git a/src/nanopyx/methods/esrrf_3d/__init__.py b/src/nanopyx/methods/esrrf_3d/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/nanopyx/methods/esrrf_3d/run.py b/src/nanopyx/methods/esrrf_3d/run.py new file mode 100644 index 00000000..a85910e5 --- /dev/null +++ b/src/nanopyx/methods/esrrf_3d/run.py @@ -0,0 +1,6 @@ +from ...core.transform._le_esrrf3d import eSRRF3D +from ...core.transform.sr_temporal_correlations import calculate_eSRRF3d_temporal_correlations + +def run_esrrf3d(img, mag: int = 5, temporal_correlation_window: int = 10): + esrrf_calculator = eSRRF3D() + return calculate_eSRRF3d_temporal_correlations(esrrf_calculator.run(img, mag), temporal_correlation_window) \ No newline at end of file From f7f8f9781786d1659cf7d4829858195b534541a3 Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Wed, 14 Feb 2024 11:02:44 +0000 Subject: [PATCH 44/81] added threaded implementation --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 89 ++++++++++++++++++++++ 1 file changed, 89 insertions(+) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 1813104d..3b295786 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -4,6 +4,8 @@ import math cimport numpy as np from libc.math cimport floor +from cython.parallel import prange + from ._interpolation import interpolate_3d from ._le_interpolation_catmull_rom import ShiftAndMagnify from ...__liquid_engine__ import LiquidEngine @@ -142,6 +144,93 @@ class eSRRF3D(LiquidEngine): return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map), np.asarray(avg_rgc_map) + def _run_threaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, framewindow: float = 10,rollingoverlap: float = 5, doIntensityWeighting: bool = True, doRollingAvg: bool = True, run_type="Threaded"): + + interpolator = ShiftAndMagnify() + + cdef float sigma = radius / 2.355 + cdef float fwhm = radius + cdef float tSS = 2 * sigma * sigma + cdef float tSO = 2 * sigma + 1 + cdef float sigma_z = radius_z / 2.355 + cdef float fwhm_z = radius_z + cdef float tSS_z = 2 * sigma_z * sigma_z + cdef float tSO_z = 2 * sigma_z + 1 + cdef int Gx_Gy_MAGNIFICATION = 2 + cdef int _magnification_xy = magnification_xy + cdef int _magnification_z = magnification_z + cdef int _doIntensityWeighting = doIntensityWeighting + cdef int _doRollingAvg = doRollingAvg + + cdef int n_frames, n_slices, n_rows, n_cols, n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum + n_frames, n_slices, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2], image.shape[3] + + cdef float[:, :, :, :] rgc_map = np.zeros((n_frames, n_slices*magnification_z, n_rows*magnification_xy, n_cols*magnification_xy), dtype=np.float32) + + cdef float[:, :, :] image_interpolated, gradients_s, gradients_r, gradients_c, gradients_s_interpolated, gradients_r_interpolated, gradients_c_interpolated, padded, img_dum + + cdef int f, n_slices_mag, n_rows_mag, n_cols_mag, sM, rM, cM, z0 + cdef int w, n_windows, start_frame, end_frame + + cdef float rgc_val, zcof + + for f in range(n_frames): + + # image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) + image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) + n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] + + gradients_c = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) + gradients_r = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) + gradients_s = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) + + img_dum = interpolator.run(image[f], 0, 0, Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) + # img_dum = interpolate_3d(image[f], Gx_Gy_MAGNIFICATION, _magnification_z) + n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum = img_dum.shape[0], img_dum.shape[1], img_dum.shape[2] + + with nogil: + _c_gradient_3d(&img_dum[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices, n_rows_mag_dum, n_cols_mag_dum) + + # gradients_s_interpolated = interpolator.run(gradients_s, 0, 0, _magnification_xy, _magnification_xy) + # gradients_r_interpolated = interpolator.run(gradients_r, 0, 0, _magnification_xy, _magnification_xy) + # gradients_c_interpolated = interpolator.run(gradients_c, 0, 0, _magnification_xy, _magnification_xy) + + gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy, _magnification_z) + gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy, _magnification_z) + gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy, _magnification_z) + + if self.keep_gradients: + self._gradients_c_interpolated = gradients_c_interpolated.copy() + + with nogil: + for sM in range(0, n_slices_mag): + for rM in prange(0, n_rows_mag): + for cM in range(0, n_cols_mag): + if _doIntensityWeighting: + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + # zcof = (sM) / _magnification_z + # if (zcof < 0): + # z0 = 0 + # elif (zcof >= n_slices-1): + # z0 = n_slices-1 + # else: + # z0 = floor(zcof) + # z0 = z0 * _magnification_z + rgc_map[f, sM, rM, cM] = rgc_val * image_interpolated[sM, rM, cM] + else: + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + # zcof = (sM) / _magnification_z + # if (zcof < 0): + # z0 = 0 + # elif (zcof >= n_slices-1): + # z0 = n_slices-1 + # else: + # z0 = floor(zcof) + # z0 = z0 * _magnification_z + rgc_map[f, sM, rM, cM] = rgc_val + + return rgc_map + def get_gradients(self): if self._gradients_c_interpolated is None: print("Gradients not yet calculated") From 1bcfdd87fb8e305f168ee48feb7a9dc6abcd462d Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Wed, 14 Feb 2024 11:35:15 +0000 Subject: [PATCH 45/81] added time analysis as external function + rolling average --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 50 +++++++++++++--------- 1 file changed, 30 insertions(+), 20 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 3b295786..a60b8f86 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -6,6 +6,8 @@ from libc.math cimport floor from cython.parallel import prange +from .sr_temporal_correlations import calculate_eSRRF_temporal_correlations + from ._interpolation import interpolate_3d from ._le_interpolation_catmull_rom import ShiftAndMagnify from ...__liquid_engine__ import LiquidEngine @@ -15,7 +17,6 @@ cdef extern from "_c_gradients.h": cdef extern from "_c_sr_radial_gradient_convergence.h": float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) nogil - float _c_calculate_rgc3D_dev(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) nogil class eSRRF3D(LiquidEngine): """ @@ -28,6 +29,8 @@ class eSRRF3D(LiquidEngine): opencl_=False, unthreaded_=True, threaded_=False, threaded_static_=False, threaded_dynamic_=False, threaded_guided_=False) self._default_benchmarks = {'OpenCL': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 0.6182407079995755, 0.6122367919997487, 0.6093217500001629], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 0.3028541249987029, 0.2802749999991647, 0.2996904169995105]}, 'Threaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.06756008299999, 11.480632083001183, 11.368770667000717], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.490110000000641, 2.6822768330002873, 2.5428189579997706]}, 'Threaded_dynamic': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.366981125000166, 9.478710332999981, 10.355995709000126], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.020473291999224, 2.0464198749996285, 2.1126812500006054]}, 'Threaded_guided': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.59399004199986, 9.394610874998762, 10.42694429200128], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.1240765410002496, 2.1175940839984833, 2.127043415999651]}, 'Threaded_static': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.325379959000202, 11.439641291000953, 12.059574375000011], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.4486127919990395, 2.5282963329991617, 2.7061019579996355]}, 'Unthreaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 50.56610608399933, 50.84249891699983, 51.47774041699995], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 10.916643833001217, 11.070652250000421, 11.099240584000654]}} + self._gradients_s_interpolated = None + self._gradients_r_interpolated = None self._gradients_c_interpolated = None self.keep_gradients = False @@ -41,7 +44,7 @@ class eSRRF3D(LiquidEngine): image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2])) return self._run(image, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, sensitivity=sensitivity, doIntensityWeighting=doIntensityWeighting, run_type=run_type) - def _run_unthreaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, framewindow: float = 10,rollingoverlap: float = 5, doIntensityWeighting: bool = True, doRollingAvg: bool = True, run_type="Unthreaded"): + def _run_unthreaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Unthreaded"): interpolator = ShiftAndMagnify() @@ -57,7 +60,6 @@ class eSRRF3D(LiquidEngine): cdef int _magnification_xy = magnification_xy cdef int _magnification_z = magnification_z cdef int _doIntensityWeighting = doIntensityWeighting - cdef int _doRollingAvg = doRollingAvg cdef int n_frames, n_slices, n_rows, n_cols, n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum n_frames, n_slices, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2], image.shape[3] @@ -99,6 +101,8 @@ class eSRRF3D(LiquidEngine): gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy, _magnification_z) if self.keep_gradients: + self._gradients_s_interpolated = gradients_s_interpolated.copy() + self._gradients_r_interpolated = gradients_r_interpolated.copy() self._gradients_c_interpolated = gradients_c_interpolated.copy() with nogil: @@ -128,23 +132,9 @@ class eSRRF3D(LiquidEngine): # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val - if _doRollingAvg: - - if rollingoverlap > 0: - n_windows = int((n_frames - framewindow) / rollingoverlap) + 1 - else: - n_windows = int(n_frames / framewindow) - - for w in range(n_windows): - - start_frame = w * (int(framewindow) - int(rollingoverlap)) - end_frame = start_frame + int(framewindow) - # do average in the first dimension of rgc_map[start_frame:end_frame ,:,:,:] with numpy - avg_rgc_map[w,:,:,:] = np.average(rgc_map[start_frame:end_frame,:,:,:], 0) - return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map), np.asarray(avg_rgc_map) - def _run_threaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, framewindow: float = 10,rollingoverlap: float = 5, doIntensityWeighting: bool = True, doRollingAvg: bool = True, run_type="Threaded"): + def _run_threaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Threaded"): interpolator = ShiftAndMagnify() @@ -160,7 +150,6 @@ class eSRRF3D(LiquidEngine): cdef int _magnification_xy = magnification_xy cdef int _magnification_z = magnification_z cdef int _doIntensityWeighting = doIntensityWeighting - cdef int _doRollingAvg = doRollingAvg cdef int n_frames, n_slices, n_rows, n_cols, n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum n_frames, n_slices, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2], image.shape[3] @@ -200,6 +189,8 @@ class eSRRF3D(LiquidEngine): gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy, _magnification_z) if self.keep_gradients: + self._gradients_s_interpolated = gradients_s_interpolated.copy() + self._gradients_r_interpolated = gradients_r_interpolated.copy() self._gradients_c_interpolated = gradients_c_interpolated.copy() with nogil: @@ -231,8 +222,27 @@ class eSRRF3D(LiquidEngine): return rgc_map + def time_analysis(float[:,:,:,:] rgc_map, correlation: str = "AVG", framewindow: float = 10, rollingoverlap: float = 5): + # correlation (str): Type of correlation to calculate. Should be "AVG", "VAR", or "TAC2" + n_frames, n_slices, n_rows, n_cols = rgc_map.shape[0], rgc_map.shape[1], rgc_map.shape[2], rgc_map.shape[3] + + if rollingoverlap: + n_windows = int((n_frames - framewindow) / rollingoverlap) + 1 + else: + n_windows = int(n_frames / framewindow) + + cdef float[:, :, :, :] avg_rgc_map = np.zeros((n_windows, n_slices, n_rows, n_cols), dtype=np.float32) + + for w in range(n_windows): + start_frame = w * (int(framewindow) - int(rollingoverlap)) + end_frame = start_frame + int(framewindow) + # do average in the first dimension of rgc_map[start_frame:end_frame ,:,:,:] with numpy + avg_rgc_map[w,:,:,:] = calculate_eSRRF_temporal_correlations(rgc_map[start_frame:end_frame,:,:,:], correlation) + + return avg_rgc_map + def get_gradients(self): if self._gradients_c_interpolated is None: print("Gradients not yet calculated") else: - return self._gradients_c_interpolated, self._gradients_r_interpolated, + return self._gradients_c_interpolated, self._gradients_r_interpolated, self._gradients_s_interpolated From d1962d98ef8021e38d7657866ff8a5d49f7ce50d Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Wed, 14 Feb 2024 11:49:01 +0000 Subject: [PATCH 46/81] minor changes --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index a60b8f86..0d549dc8 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -65,13 +65,10 @@ class eSRRF3D(LiquidEngine): n_frames, n_slices, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2], image.shape[3] cdef float[:, :, :, :] rgc_map = np.zeros((n_frames, n_slices*magnification_z, n_rows*magnification_xy, n_cols*magnification_xy), dtype=np.float32) - - cdef float[:, :, :, :] avg_rgc_map = np.zeros((n_frames, n_slices*magnification_z, n_rows*magnification_xy, n_cols*magnification_xy), dtype=np.float32) cdef float[:, :, :] image_interpolated, gradients_s, gradients_r, gradients_c, gradients_s_interpolated, gradients_r_interpolated, gradients_c_interpolated, padded, img_dum cdef int f, n_slices_mag, n_rows_mag, n_cols_mag, sM, rM, cM, z0 - cdef int w, n_windows, start_frame, end_frame cdef float rgc_val, zcof @@ -132,7 +129,7 @@ class eSRRF3D(LiquidEngine): # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val - return np.asarray(image_interpolated), np.asarray(gradients_r_interpolated), np.asarray(gradients_c_interpolated),np.asarray(gradients_s_interpolated), np.asarray(rgc_map), np.asarray(avg_rgc_map) + return np.asarray(rgc_map) def _run_threaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Threaded"): @@ -159,12 +156,10 @@ class eSRRF3D(LiquidEngine): cdef float[:, :, :] image_interpolated, gradients_s, gradients_r, gradients_c, gradients_s_interpolated, gradients_r_interpolated, gradients_c_interpolated, padded, img_dum cdef int f, n_slices_mag, n_rows_mag, n_cols_mag, sM, rM, cM, z0 - cdef int w, n_windows, start_frame, end_frame cdef float rgc_val, zcof for f in range(n_frames): - # image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] @@ -220,7 +215,7 @@ class eSRRF3D(LiquidEngine): # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val - return rgc_map + return np.asarray(rgc_map) def time_analysis(float[:,:,:,:] rgc_map, correlation: str = "AVG", framewindow: float = 10, rollingoverlap: float = 5): # correlation (str): Type of correlation to calculate. Should be "AVG", "VAR", or "TAC2" From c770ca2de00a2393e39083bfaec7fdd5d9adb08d Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Wed, 14 Feb 2024 11:56:11 +0000 Subject: [PATCH 47/81] fixed --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 3b295786..a68199a0 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -25,7 +25,7 @@ class eSRRF3D(LiquidEngine): def __init__(self, clear_benchmarks=False, testing=False): self._designation = "eSRRF_3D" super().__init__(clear_benchmarks=clear_benchmarks, testing=testing, - opencl_=False, unthreaded_=True, threaded_=False, threaded_static_=False, + opencl_=False, unthreaded_=True, threaded_=True, threaded_static_=False, threaded_dynamic_=False, threaded_guided_=False) self._default_benchmarks = {'OpenCL': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 0.6182407079995755, 0.6122367919997487, 0.6093217500001629], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 0.3028541249987029, 0.2802749999991647, 0.2996904169995105]}, 'Threaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.06756008299999, 11.480632083001183, 11.368770667000717], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.490110000000641, 2.6822768330002873, 2.5428189579997706]}, 'Threaded_dynamic': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.366981125000166, 9.478710332999981, 10.355995709000126], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.020473291999224, 2.0464198749996285, 2.1126812500006054]}, 'Threaded_guided': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.59399004199986, 9.394610874998762, 10.42694429200128], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.1240765410002496, 2.1175940839984833, 2.127043415999651]}, 'Threaded_static': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.325379959000202, 11.439641291000953, 12.059574375000011], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.4486127919990395, 2.5282963329991617, 2.7061019579996355]}, 'Unthreaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 50.56610608399933, 50.84249891699983, 51.47774041699995], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 10.916643833001217, 11.070652250000421, 11.099240584000654]}} self._gradients_c_interpolated = None From 1c7fafd95ab2d0b3d6c09d75b553c19beffbb523 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Wed, 14 Feb 2024 12:07:43 +0000 Subject: [PATCH 48/81] fix for time_analysis function --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 2eb50218..64cb7c0e 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -217,7 +217,7 @@ class eSRRF3D(LiquidEngine): return np.asarray(rgc_map) - def time_analysis(float[:,:,:,:] rgc_map, correlation: str = "AVG", framewindow: float = 10, rollingoverlap: float = 5): + def time_analysis(self, float[:,:,:,:] rgc_map, correlation: str = "AVG", framewindow: float = 5, rollingoverlap: float = 2): # correlation (str): Type of correlation to calculate. Should be "AVG", "VAR", or "TAC2" n_frames, n_slices, n_rows, n_cols = rgc_map.shape[0], rgc_map.shape[1], rgc_map.shape[2], rgc_map.shape[3] From 4de47e615c628a40762a52334654188f83da0614 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Wed, 14 Feb 2024 18:54:53 +0000 Subject: [PATCH 49/81] added keep interpolated image --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 64cb7c0e..1dd084d8 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -33,6 +33,8 @@ class eSRRF3D(LiquidEngine): self._gradients_r_interpolated = None self._gradients_c_interpolated = None self.keep_gradients = False + self.keep_interpolated = False + self._img_interpolated = None def run(self, image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None, keep_gradients=False): self.keep_gradients = keep_gradients @@ -101,7 +103,10 @@ class eSRRF3D(LiquidEngine): self._gradients_s_interpolated = gradients_s_interpolated.copy() self._gradients_r_interpolated = gradients_r_interpolated.copy() self._gradients_c_interpolated = gradients_c_interpolated.copy() - + + if self.keep_interpolated: + self._img_interpolated = img_dum.copy() + with nogil: for sM in range(0, n_slices_mag): for rM in range(0, n_rows_mag): @@ -188,6 +193,9 @@ class eSRRF3D(LiquidEngine): self._gradients_r_interpolated = gradients_r_interpolated.copy() self._gradients_c_interpolated = gradients_c_interpolated.copy() + if self.keep_interpolated: + self._img_interpolated = img_dum.copy() + with nogil: for sM in range(0, n_slices_mag): for rM in prange(0, n_rows_mag): @@ -241,3 +249,6 @@ class eSRRF3D(LiquidEngine): print("Gradients not yet calculated") else: return self._gradients_c_interpolated, self._gradients_r_interpolated, self._gradients_s_interpolated + + def get_interpolated_image(self): + return self._img_interpolated From 8b5b8b9278e1bd0dbf9ecb6a8a85a9393bc4dc39 Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Thu, 15 Feb 2024 15:28:18 +0000 Subject: [PATCH 50/81] refactored time analysis methods --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 21 +------------------ .../transform/sr_temporal_correlations.py | 19 +++++++++++++++++ src/nanopyx/methods/esrrf_3d/run.py | 4 ++-- 3 files changed, 22 insertions(+), 22 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 1dd084d8..fe2bc9d9 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -225,27 +225,8 @@ class eSRRF3D(LiquidEngine): return np.asarray(rgc_map) - def time_analysis(self, float[:,:,:,:] rgc_map, correlation: str = "AVG", framewindow: float = 5, rollingoverlap: float = 2): - # correlation (str): Type of correlation to calculate. Should be "AVG", "VAR", or "TAC2" - n_frames, n_slices, n_rows, n_cols = rgc_map.shape[0], rgc_map.shape[1], rgc_map.shape[2], rgc_map.shape[3] - - if rollingoverlap: - n_windows = int((n_frames - framewindow) / rollingoverlap) + 1 - else: - n_windows = int(n_frames / framewindow) - - cdef float[:, :, :, :] avg_rgc_map = np.zeros((n_windows, n_slices, n_rows, n_cols), dtype=np.float32) - - for w in range(n_windows): - start_frame = w * (int(framewindow) - int(rollingoverlap)) - end_frame = start_frame + int(framewindow) - # do average in the first dimension of rgc_map[start_frame:end_frame ,:,:,:] with numpy - avg_rgc_map[w,:,:,:] = calculate_eSRRF_temporal_correlations(rgc_map[start_frame:end_frame,:,:,:], correlation) - - return avg_rgc_map - def get_gradients(self): - if self._gradients_c_interpolated is None: + if self._gradients_c_interpolated is None or self._gradients_r_interpolated is None or self._gradients_s_interpolated is None: print("Gradients not yet calculated") else: return self._gradients_c_interpolated, self._gradients_r_interpolated, self._gradients_s_interpolated diff --git a/src/nanopyx/core/transform/sr_temporal_correlations.py b/src/nanopyx/core/transform/sr_temporal_correlations.py index 8496186c..ce56cf07 100644 --- a/src/nanopyx/core/transform/sr_temporal_correlations.py +++ b/src/nanopyx/core/transform/sr_temporal_correlations.py @@ -219,3 +219,22 @@ def calculate_tac2(rad_array): out_array = np.mean(centered[:-nlag] * centered[nlag:], axis=0) return out_array + +def calculate_eSRRF3d_temporal_correlations(rgc_map, correlation: str = "AVG", framewindow: float = 5, rollingoverlap: float = 2): + # correlation (str): Type of correlation to calculate. Should be "AVG", "VAR", or "TAC2" + n_frames, n_slices, n_rows, n_cols = rgc_map.shape[0], rgc_map.shape[1], rgc_map.shape[2], rgc_map.shape[3] + + if rollingoverlap: + n_windows = int((n_frames - framewindow) / rollingoverlap) + 1 + else: + n_windows = int(n_frames / framewindow) + + avg_rgc_map = np.zeros((n_windows, n_slices, n_rows, n_cols), dtype=np.float32) + + for w in range(n_windows): + start_frame = w * (int(framewindow) - int(rollingoverlap)) + end_frame = start_frame + int(framewindow) + # do average in the first dimension of rgc_map[start_frame:end_frame ,:,:,:] with numpy + avg_rgc_map[w,:,:,:] = calculate_eSRRF_temporal_correlations(rgc_map[start_frame:end_frame,:,:,:], correlation) + + return avg_rgc_map \ No newline at end of file diff --git a/src/nanopyx/methods/esrrf_3d/run.py b/src/nanopyx/methods/esrrf_3d/run.py index a85910e5..8cdd81bf 100644 --- a/src/nanopyx/methods/esrrf_3d/run.py +++ b/src/nanopyx/methods/esrrf_3d/run.py @@ -1,6 +1,6 @@ from ...core.transform._le_esrrf3d import eSRRF3D from ...core.transform.sr_temporal_correlations import calculate_eSRRF3d_temporal_correlations -def run_esrrf3d(img, mag: int = 5, temporal_correlation_window: int = 10): +def run_esrrf3d(img, mag: int = 5, correlation="AVG", framewindow=5, rollingoverlap=2): esrrf_calculator = eSRRF3D() - return calculate_eSRRF3d_temporal_correlations(esrrf_calculator.run(img, mag), temporal_correlation_window) \ No newline at end of file + return calculate_eSRRF3d_temporal_correlations(esrrf_calculator.run(img, mag), correlation="AVG", framewindow=5, rollingoverlap=2) \ No newline at end of file From ce390fdc7c641552c5ad50f384b1f6c1f4263469 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 15 Feb 2024 15:52:48 +0000 Subject: [PATCH 51/81] fixed and added docstring --- src/nanopyx/methods/esrrf_3d/run.py | 25 +++++++++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-) diff --git a/src/nanopyx/methods/esrrf_3d/run.py b/src/nanopyx/methods/esrrf_3d/run.py index 8cdd81bf..d46855f1 100644 --- a/src/nanopyx/methods/esrrf_3d/run.py +++ b/src/nanopyx/methods/esrrf_3d/run.py @@ -1,6 +1,27 @@ from ...core.transform._le_esrrf3d import eSRRF3D from ...core.transform.sr_temporal_correlations import calculate_eSRRF3d_temporal_correlations -def run_esrrf3d(img, mag: int = 5, correlation="AVG", framewindow=5, rollingoverlap=2): +def run_esrrf3d(img,**kwargs): + """ + Calculate the eSRRF3D temporal correlations for the given image. + + Args: + img: The input 3D image. + magnification_xy: The magnification factor for the x and y axes. + magnification_z: The magnification factor for the z axis. + radius: The radius for the xy plane. + radius_z: The radius for the z axis. + sensitivity: The sensitivity for the calculation. + doIntensityWeighting: Whether to perform intensity weighting. + run_type: The type of the run. + keep_gradients: Whether to keep the gradients. + keep_interpolated: Whether to keep the interpolated values. + correlation: The type of correlation to use. + framewindow: The window size for frame. + rollingoverlap: The overlap size for rolling. + + Returns: + The calculated eSRRF3D temporal correlations. + """ esrrf_calculator = eSRRF3D() - return calculate_eSRRF3d_temporal_correlations(esrrf_calculator.run(img, mag), correlation="AVG", framewindow=5, rollingoverlap=2) \ No newline at end of file + return calculate_eSRRF3d_temporal_correlations(esrrf_calculator.run(img, **kwargs), **kwargs) \ No newline at end of file From 2a707a2f6d441d3a9d13d33cf45f060a40e74723 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 15 Feb 2024 15:58:43 +0000 Subject: [PATCH 52/81] added keep interp --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index fe2bc9d9..b78229ec 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -36,8 +36,9 @@ class eSRRF3D(LiquidEngine): self.keep_interpolated = False self._img_interpolated = None - def run(self, image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None, keep_gradients=False): + def run(self, image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None, keep_gradients=False, keep_interpolated = False): self.keep_gradients = keep_gradients + self.keep_interpolated = keep_interpolated if image.dtype != np.float32: image = image.astype(np.float32) if len(image.shape) == 4: From 1578ffb27c9cce486a3b18031207a2cb50118a4c Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 15 Feb 2024 15:59:11 +0000 Subject: [PATCH 53/81] added arguments as kwargs --- src/nanopyx/methods/esrrf_3d/run.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/nanopyx/methods/esrrf_3d/run.py b/src/nanopyx/methods/esrrf_3d/run.py index d46855f1..ab6c63d6 100644 --- a/src/nanopyx/methods/esrrf_3d/run.py +++ b/src/nanopyx/methods/esrrf_3d/run.py @@ -1,7 +1,7 @@ from ...core.transform._le_esrrf3d import eSRRF3D from ...core.transform.sr_temporal_correlations import calculate_eSRRF3d_temporal_correlations -def run_esrrf3d(img,**kwargs): +def run_esrrf3d(img,correlation="AVG", framewindow=5, rollingoverlap=2, **kwargs): """ Calculate the eSRRF3D temporal correlations for the given image. @@ -24,4 +24,4 @@ def run_esrrf3d(img,**kwargs): The calculated eSRRF3D temporal correlations. """ esrrf_calculator = eSRRF3D() - return calculate_eSRRF3d_temporal_correlations(esrrf_calculator.run(img, **kwargs), **kwargs) \ No newline at end of file + return calculate_eSRRF3d_temporal_correlations(esrrf_calculator.run(img, **kwargs), correlation=correlation, framewindow=framewindow, rollingoverlap=rollingoverlap) \ No newline at end of file From 0efd4ac139d9e43c495352ef943235490212c966 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 29 Feb 2024 15:48:43 +0000 Subject: [PATCH 54/81] added full stack averaging --- src/nanopyx/core/transform/sr_temporal_correlations.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/nanopyx/core/transform/sr_temporal_correlations.py b/src/nanopyx/core/transform/sr_temporal_correlations.py index ce56cf07..25ceb96b 100644 --- a/src/nanopyx/core/transform/sr_temporal_correlations.py +++ b/src/nanopyx/core/transform/sr_temporal_correlations.py @@ -224,10 +224,14 @@ def calculate_eSRRF3d_temporal_correlations(rgc_map, correlation: str = "AVG", f # correlation (str): Type of correlation to calculate. Should be "AVG", "VAR", or "TAC2" n_frames, n_slices, n_rows, n_cols = rgc_map.shape[0], rgc_map.shape[1], rgc_map.shape[2], rgc_map.shape[3] - if rollingoverlap: - n_windows = int((n_frames - framewindow) / rollingoverlap) + 1 + if framewindow != 0: + if rollingoverlap: + n_windows = int((n_frames - framewindow) / rollingoverlap) + 1 + else: + n_windows = int(n_frames / framewindow) else: - n_windows = int(n_frames / framewindow) + n_windows = 1 + framewindow = n_frames - 1 avg_rgc_map = np.zeros((n_windows, n_slices, n_rows, n_cols), dtype=np.float32) From 03d0f3c378ca64b2db182d0d665410aedeea073e Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 1 Mar 2024 20:58:00 +0000 Subject: [PATCH 55/81] added SRRF calculation iwth z axis --- .../_c_sr_radial_gradient_convergence.c | 23 +++++++++++-------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 7aa1c99b..856a68f8 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -70,16 +70,18 @@ float _c_calculate_rgc(int xM, int yM, float* imIntGx, float* imIntGy, int colsM return RGC; } -double _c_calculate_dw3D(double distance, double tSS) { -// (double distance_xy, double distance_z, double tSS, double tSS_z) -// float D_weight_xy, D_weight_z, D_weight; -// D_weight_xy = (distance_xy * exp((-distance_xy * distance_xy) / tSS)); -// D_weight_z = (distance_z * exp((-distance_z * distance_z) / tSS_z)); -// D_weight = (D_weight_xy + D_weight_z) / 2; -// return pow(D_weight, 4); +double _c_calculate_dw3D_isotropic(double distance, double tSS) { return pow((distance * exp(-(distance * distance) / tSS)), 4); } +double _c_calculate_dw3D(double distance_xy, double distance_z, double tSS, double tSS_z) { + float D_weight_xy, D_weight_z, D_weight; + D_weight_xy = (distance_xy * exp((-distance_xy * distance_xy) / tSS)); + D_weight_z = (distance_z * exp((-distance_z * distance_z) / tSS_z)); + D_weight = (D_weight_xy + D_weight_z) / 2; + return pow(D_weight, 4); +} + double _c_calculate_dw_xy(double distance_xy, double tSS) { return pow((distance_xy * exp((-distance_xy * distance_xy) / tSS)), 4); } @@ -114,7 +116,7 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn float xc = (xM + 0.5) / magnification_xy; float yc = (yM + 0.5) / magnification_xy; - float zc = (sliceM + 0.5) / magnification_z; + float zc = (sliceM) / magnification_z; float RGC = 0; float distanceWeightSum = 0; @@ -159,7 +161,8 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn // Gy = imIntGy[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; // Gz = imIntGz[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; - distanceWeight = _c_calculate_dw3D(distance, tSS); + // distanceWeight = _c_calculate_dw3D_isotropic(distance, tSS); + distanceWeight = _c_calculate_dw3D(distance_xy, distance_z, tSS, tSS_z); // distanceWeight_xy = _c_calculate_dw_xy(distance_xy, tSS); // distanceWeight_z = _c_calculate_dw_z(distance_z, tSS_z); @@ -245,7 +248,7 @@ float _c_calculate_rgc3D_dev(int xM, int yM, int sliceM, float* imIntGx, float* // Gy = imIntGy[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; // Gz = imIntGz[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; - distanceWeight = _c_calculate_dw3D(distance, tSS); + distanceWeight = _c_calculate_dw3D_isotropic(distance, tSS); // distanceWeight_xy = _c_calculate_dw_xy(distance_xy, tSS); // distanceWeight_z = _c_calculate_dw_z(distance_z, tSS_z); From 26fcc4940eef209d22bcc1444b6e899ed9c972b4 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 1 Mar 2024 20:58:09 +0000 Subject: [PATCH 56/81] added 1D interpolation --- src/nanopyx/core/transform/_interpolation.pyx | 27 ++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/src/nanopyx/core/transform/_interpolation.pyx b/src/nanopyx/core/transform/_interpolation.pyx index d6236340..2dada44b 100644 --- a/src/nanopyx/core/transform/_interpolation.pyx +++ b/src/nanopyx/core/transform/_interpolation.pyx @@ -28,4 +28,29 @@ def interpolate_3d(image, magnification_xy: int = 5, magnification_z: int = 5): yz_interpolated = np.transpose(interpolator.run(np.transpose(xy_interpolated, axes=[1, 0, 2]).copy(), 0, 0, magnification_z, 1), axes=[1, 0, 2]).copy() xz_interpolated = np.transpose(interpolator.run(np.transpose(xy_interpolated, axes=[2, 1, 0]).copy(), 0, 0, 1, magnification_z), axes=[2,1,0]).copy() - return np.mean(np.array([yz_interpolated, xz_interpolated]), axis=0) \ No newline at end of file + return np.mean(np.array([yz_interpolated, xz_interpolated]), axis=0) + +def linear_interpolation_1D_z(image, magnification): + # linear interpolator that takes a 3D image and do linear interpolation in a 1D column in the chosen axis + + image_interpolated = np.zeros((image.shape[0] * magnification, image.shape[1], image.shape[2]), dtype=np.float32) + + # for s in range(image.shape[0]): + # for r in range(image.shape[1]): + # for c in range(image.shape[2]): + # image_interpolated[s*magnification:(s+1)*magnification, r, c] = np.linspace(image[s, r, c], image[s+1, r, c], magnification) + + # run over all the planes + for s in range(image.shape[0]-1): + image_interpolated[s*magnification:(s+1)*magnification, :,:] = np.linspace(image[s, :,:], image[s+1, :,:], magnification) + + return image_interpolated + + +def interpolate_3d_zlinear(image, magnification_xy: int = 5, magnification_z: int = 5): + interpolator_xy = ShiftMagnify_CR() + + xy_interpolated = interpolator_xy.run(image, 0, 0, magnification_xy, magnification_xy) + z_interpolated = linear_interpolation_1D_z(xy_interpolated, magnification_z) + + return z_interpolated From 4232425317fa2a3f0a40da64802aa8cf68c2e64b Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 1 Mar 2024 20:58:31 +0000 Subject: [PATCH 57/81] added linear interpolation in z --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index b78229ec..9fe3da40 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -8,7 +8,7 @@ from cython.parallel import prange from .sr_temporal_correlations import calculate_eSRRF_temporal_correlations -from ._interpolation import interpolate_3d +from ._interpolation import interpolate_3d, interpolate_3d_zlinear from ._le_interpolation_catmull_rom import ShiftAndMagnify from ...__liquid_engine__ import LiquidEngine @@ -167,7 +167,10 @@ class eSRRF3D(LiquidEngine): for f in range(n_frames): # image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) - image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) + + # image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) + image_interpolated = interpolate_3d_zlinear(image[f], _magnification_xy, _magnification_z) + n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] gradients_c = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) @@ -185,9 +188,13 @@ class eSRRF3D(LiquidEngine): # gradients_r_interpolated = interpolator.run(gradients_r, 0, 0, _magnification_xy, _magnification_xy) # gradients_c_interpolated = interpolator.run(gradients_c, 0, 0, _magnification_xy, _magnification_xy) - gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy, _magnification_z) - gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy, _magnification_z) - gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy, _magnification_z) + # gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy, _magnification_z) + # gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy, _magnification_z) + # gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy, _magnification_z) + + gradients_s_interpolated = interpolate_3d_zlinear(gradients_s, _magnification_xy, _magnification_z) + gradients_r_interpolated = interpolate_3d_zlinear(gradients_r, _magnification_xy, _magnification_z) + gradients_c_interpolated = interpolate_3d_zlinear(gradients_c, _magnification_xy, _magnification_z) if self.keep_gradients: self._gradients_s_interpolated = gradients_s_interpolated.copy() From 13f22b91d70c4f8fabb84a64950012fbc9be5f2c Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 1 Mar 2024 21:18:49 +0000 Subject: [PATCH 58/81] Added ellipsoidal exclusion shape --- src/include/_c_sr_radial_gradient_convergence.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 856a68f8..ebd9f73f 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -146,9 +146,10 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn dz = vz - zc; distance = sqrt(dx * dx + dy * dy + dz * dz); distance_xy = sqrt(dx * dx + dy * dy); - distance_z = dz; + distance_z = dz*4; - if (distance != 0 && distance <= tSO ) { + // if (distance != 0 && distance <= tSO ) { + if (distance != 0 && distance_xy <= tSO && distance_z <= tSO_z) { // Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, Gx_Gy_MAGNIFICATION * magnification_xy * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); // Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); From 8d96fb781f0c197c98047154847593c87850c233 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 1 Mar 2024 21:30:31 +0000 Subject: [PATCH 59/81] added todo --- src/include/_c_sr_radial_gradient_convergence.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index ebd9f73f..a21fb343 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -116,7 +116,7 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn float xc = (xM + 0.5) / magnification_xy; float yc = (yM + 0.5) / magnification_xy; - float zc = (sliceM) / magnification_z; + float zc = (sliceM + 0.5) / magnification_z; float RGC = 0; float distanceWeightSum = 0; @@ -146,8 +146,8 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn dz = vz - zc; distance = sqrt(dx * dx + dy * dy + dz * dz); distance_xy = sqrt(dx * dx + dy * dy); - distance_z = dz*4; - + distance_z = dz*4; // TODO: need to add a variable voxel aspect ratio = 4 (for instance) to multiply dz + // TODO: check if this is correct. Need to add the real ratio and size of the voxel // if (distance != 0 && distance <= tSO ) { if (distance != 0 && distance_xy <= tSO && distance_z <= tSO_z) { From 5535d17617bb1460edade1844e65a36c6ec707cd Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Mon, 4 Mar 2024 10:29:37 +0100 Subject: [PATCH 60/81] added pixel ratio --- .../_c_sr_radial_gradient_convergence.c | 112 ++---------------- .../_c_sr_radial_gradient_convergence.h | 6 +- 2 files changed, 16 insertions(+), 102 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index a21fb343..e299d45b 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -74,11 +74,11 @@ double _c_calculate_dw3D_isotropic(double distance, double tSS) { return pow((distance * exp(-(distance * distance) / tSS)), 4); } -double _c_calculate_dw3D(double distance_xy, double distance_z, double tSS, double tSS_z) { +double _c_calculate_dw3D(double distance, double distance_xy, double distance_z,double tSS, double tSS_z) { float D_weight_xy, D_weight_z, D_weight; - D_weight_xy = (distance_xy * exp((-distance_xy * distance_xy) / tSS)); - D_weight_z = (distance_z * exp((-distance_z * distance_z) / tSS_z)); - D_weight = (D_weight_xy + D_weight_z) / 2; + D_weight_xy = (exp((-distance_xy * distance_xy) / tSS)); + D_weight_z = (exp((-distance_z * distance_z) / tSS_z)); + D_weight = distance * (D_weight_xy * D_weight_z); return pow(D_weight, 4); } @@ -110,9 +110,9 @@ float _c_get_bound_value(float* im, int slices, int rows, int cols, int s, int r return im[_s * rows * cols + _r * cols + _c]; } -float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) { +float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float ratio_px, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) { - float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, distance, distance_xy, distance_z, distanceWeight, distanceWeight_xy, distanceWeight_z, GdotR, Dk; + float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, dz_real, distance, distance_xy, distance_z, distanceWeight, distanceWeight_xy, distanceWeight_z, GdotR, Dk; float xc = (xM + 0.5) / magnification_xy; float yc = (yM + 0.5) / magnification_xy; @@ -144,9 +144,10 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn dx = vx - xc; dy = vy - yc; dz = vz - zc; - distance = sqrt(dx * dx + dy * dy + dz * dz); + dz_real = dz * ratio_px; + distance = sqrt(dx * dx + dy * dy + dz_real * dz_real); distance_xy = sqrt(dx * dx + dy * dy); - distance_z = dz*4; // TODO: need to add a variable voxel aspect ratio = 4 (for instance) to multiply dz + distance_z = dz_real; // TODO: need to add a variable voxel aspect ratio = 4 (for instance) to multiply dz // TODO: check if this is correct. Need to add the real ratio and size of the voxel // if (distance != 0 && distance <= tSO ) { if (distance != 0 && distance_xy <= tSO && distance_z <= tSO_z) { @@ -163,7 +164,7 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn // Gz = imIntGz[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; // distanceWeight = _c_calculate_dw3D_isotropic(distance, tSS); - distanceWeight = _c_calculate_dw3D(distance_xy, distance_z, tSS, tSS_z); + distanceWeight = _c_calculate_dw3D(distance, distance_xy, distance_z, tSS, tSS_z); // distanceWeight_xy = _c_calculate_dw_xy(distance_xy, tSS); // distanceWeight_z = _c_calculate_dw_z(distance_z, tSS_z); @@ -171,10 +172,10 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn distanceWeightSum += distanceWeight; // distanceWeightSum_xy += distanceWeight_xy; // distanceWeightSum_z += distanceWeight_z; - GdotR = Gx*dx + Gy*dy + Gz*dz; + GdotR = Gx*dx + Gy*dy + Gz*dz_real; if (GdotR < 0) { - Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz, distance); + Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz_real, distance); // RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; // RGC += (Dk * distanceWeightSum); // test RGC += (Dk * distanceWeight); @@ -198,95 +199,6 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn return RGC; } -float _c_calculate_rgc3D_dev(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) { - - float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, distance, distance_xy, distance_z, distanceWeight, distanceWeight_xy, distanceWeight_z, GdotR, Dk; - - float xc = (xM + 0.5) / magnification_xy; - float yc = (yM + 0.5) / magnification_xy; - float zc = (sliceM) / magnification_z; - - float RGC = 0; - float distanceWeightSum = 0; - float distanceWeightSum_xy = 0; - float distanceWeightSum_z = 0; - - int _start = -(int)(Gx_Gy_MAGNIFICATION * fwhm); - int _end = (int)(Gx_Gy_MAGNIFICATION * fwhm + 1); - - int _start_z = -(int)(Gz_MAGNIFICATION * fwhm_z); - int _end_z = (int)(Gz_MAGNIFICATION * fwhm_z + 1); - - for (int j = _start; j <= _end; j++) { - vy = ((float) ((int) (Gx_Gy_MAGNIFICATION*yc)) + j)/(float) Gx_Gy_MAGNIFICATION; - - if (0 < vy && vy < rowsM - 1) { - for (int i = _start; i <= _end; i++) { - vx = ((float) ((int) (Gx_Gy_MAGNIFICATION*xc)) + i)/(float) Gx_Gy_MAGNIFICATION; - - if (0 < vx && vx < colsM - 1) { - for (int k = _start_z; k <= _end_z; k++) { - vz = ((float) ((int) (zc)) + k); - - if (0 < vz && vz < slicesM - 1) { - dx = vx - xc; - dy = vy - yc; - dz = vz - zc; - distance = sqrt(dx * dx + dy * dy + dz * dz); - distance_xy = sqrt(dx * dx + dy * dy); - distance_z = dz; - - if (distance != 0 && distance <= tSO ) { - - // Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, Gx_Gy_MAGNIFICATION * magnification_xy * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - // Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - // Gz = _c_get_bound_value(imIntGz, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, magnification_xy * vz * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - - Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - Gz = _c_get_bound_value(imIntGz, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - // Gx = imIntGx[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; - // Gy = imIntGy[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; - // Gz = imIntGz[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; - - distanceWeight = _c_calculate_dw3D_isotropic(distance, tSS); - - // distanceWeight_xy = _c_calculate_dw_xy(distance_xy, tSS); - // distanceWeight_z = _c_calculate_dw_z(distance_z, tSS_z); - - distanceWeightSum += distanceWeight; - // distanceWeightSum_xy += distanceWeight_xy; - // distanceWeightSum_z += distanceWeight_z; - GdotR = Gx*dx + Gy*dy + Gz*dz; - - if (GdotR < 0) { - Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz, distance); - // RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; - // RGC += (Dk * distanceWeightSum); // test - RGC += (Dk * distanceWeight); - } - } - } - } - } - } - } - } - - RGC /= distanceWeightSum; - - if (RGC >= 0) { - RGC = pow(RGC, sensitivity); - } else { - RGC = 0; - } - - return RGC; -} - - - - float _c_calculate_dk_3d(float dx, float dy, float dz, float Gx, float Gy, float Gz, float Gmag, float distance) { float G1 = dy*Gz - dz*Gy; float G2 = dz*Gx - dx*Gz; diff --git a/src/include/_c_sr_radial_gradient_convergence.h b/src/include/_c_sr_radial_gradient_convergence.h index 371e6889..b9793678 100644 --- a/src/include/_c_sr_radial_gradient_convergence.h +++ b/src/include/_c_sr_radial_gradient_convergence.h @@ -9,7 +9,9 @@ double _c_calculate_dk(float Gx, float Gy, float dx, float dy, float distance); float _c_calculate_rgc(int xM, int yM, float* imIntGx, float* imIntGy, int colsM, int rowsM, int magnification, float Gx_Gy_MAGNIFICATION, float fwhm, float tSO, float tSS, float sensitivity); -double _c_calculate_dw3D(double distance_xy, double distance_z, double tSS, double tSS_z); +double _c_calculate_dw3D_isotropic(double distance, double tSS); + +double _c_calculate_dw3D(double distance, double distance_xy, double distance_z, double tSS, double tSS_z); double _c_calculate_dw_xy(double distance_xy, double tSS); @@ -17,7 +19,7 @@ double _c_calculate_dw_z(double distance_z, double tSS_z); double _c_calculate_dk3D(float Gx, float Gy, float Gz, float dx, float dy, float dz, float distance); -float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity); +float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float ratio_px, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity); float _c_calculate_rgc_3d(int cM, int rM, int sM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSS, float sensitivity); From d4a60878acfdd8fdfa7cfe40c2a3bf0ce833701f Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Mon, 4 Mar 2024 10:30:06 +0100 Subject: [PATCH 61/81] added pixel ratio --- tests/notebooks/esrrf3d.ipynb | 637 ++++++++++++++++++++++++++++++---- 1 file changed, 566 insertions(+), 71 deletions(-) diff --git a/tests/notebooks/esrrf3d.ipynb b/tests/notebooks/esrrf3d.ipynb index 0f111e72..d57c693b 100644 --- a/tests/notebooks/esrrf3d.ipynb +++ b/tests/notebooks/esrrf3d.ipynb @@ -10,6 +10,7 @@ "import numpy as np\n", "from matplotlib import pyplot as plt\n", "from tifffile import imread\n", + "from nanopyx.methods.esrrf_3d.run import run_esrrf3d\n", "\n", "from nanopyx.core.transform._le_esrrf3d import eSRRF3D" ] @@ -18,238 +19,732 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, + "outputs": [], + "source": [ + "# img = imread(\"/Users/avesga/Code/NanoPyx/3D_test_image/sphere_9planes.tif\").astype(np.float32)\n", + "path = \"/Users/avesga/Desktop/3DeSRRF/blinking_test.tif\"\n", + "img = imread(path).astype(np.float32)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "937a94c42bbf44dc8a4b803d1786926e", - "version_major": 2, - "version_minor": 0 - }, "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=50, width=50),)),)), IntSlider(value=8, descri…" + "(21, 9, 50, 50)" ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "img = imread(\"/Users/bsaraiva/Code/NanoPyx/sphere.tif\").astype(np.float32)\n", - "stackview.slice(img)" + "img.shape" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d45a8662548f4443a239f0784edde02f", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "(17, 50, 50)" + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=50, width=50),)),)), IntSlider(value=4, descri…" ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "img.shape" + "# img to analize\n", + "\n", + "# planes = [0, 2, 4, 6, 8]\n", + "# planes = [1, 3, 5, 7]\n", + "# planes = [0, 4, 8]\n", + "planes = [0, 1, 2, 3, 4, 5, 6, 7, 8]\n", + "img4ana = img[:, planes, :, :]\n", + "\n", + "name_save = \"All_planes\"\n", + "\n", + "stackview.slice(img4ana[0])" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Define variables\n", + "\n", + "magnification_xy=2\n", + "magnification_z=2\n", + "radius=2\n", + "radius_z = 2\n", + "ratio_px = 4\n", + "sensitivity=2\n", + "run_type=\"Threaded\"\n", + "correlation=\"AVG\"\n", + "framewindow=0\n", + "rollingoverlap=1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002486208000000545 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0449771127128766, Delay probability: 0.26726405723271807\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002401542000000312 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.017893250000000194 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.6365478090491987, Delay probability: 0.2378729659297821\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011695125000001028 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011303749999999724 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024060419999987204 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002484416000001488 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0442495150144253, Delay probability: 0.26726405723271807\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010758457999999749 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012998707999999581 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1918169081951844, Delay probability: 0.2337475292239949\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01078304199999991 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023923750000012234 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023948339999986246 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.013203583000001018 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.2076226973998954, Delay probability: 0.2378729659297821\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011041207999999969 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011621292000000949 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002386583999999914 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024472079999995344 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.028087379748086, Delay probability: 0.27511712348806283\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01108720800000107 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01838283300000043 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.683443278084913, Delay probability: 0.2378729659297821\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011182875000001147 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002387124999998491 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002433749999998014 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.014426582999998772 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.3194804074561162, Delay probability: 0.2378729659297821\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011199249999997107 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010441291999999436 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002373625000000601 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024152920000020117 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011508708999997452 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011766791999999526 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010249416000000622 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024262909999990256 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024693330000005176 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0361757074721745, Delay probability: 0.14141774947896593\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.02346250000000083 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 2.1459211138176557, Delay probability: 0.2378729659297821\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.02093149999999966 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.914431445663162, Delay probability: 0.2767244691988686\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01131275000000187 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024482080000005624 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024092910000028667 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010204416000000549 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010353000000002055 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010084417000001622 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024864579999999137 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0431296879330099, Delay probability: 0.14715974993365105\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024572499999990782 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0308762205806477, Delay probability: 0.14715974993365105\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012308916999998587 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1257949868311181, Delay probability: 0.2378729659297821\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010267667000000813 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010646582999999765 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023590829999982077 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002518667000000363 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.056642147873658, Delay probability: 0.22281599499441468\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011982542000001928 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011588707999997894 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010028874999999715 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002434792000002517 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023557499999995457 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01683658400000354 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.5399032963312025, Delay probability: 0.2378729659297821\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012299874999996518 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.124967989762793, Delay probability: 0.2767244691988686\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011410333999997135 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0025403750000023706 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.066707587480729, Delay probability: 0.219496407609628\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024707080000041515 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.037454301058429, Delay probability: 0.219496407609628\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.03318462499999697 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 3.0351235990031835, Delay probability: 0.2378729659297821\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012151208999995333 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1113707384762999, Delay probability: 0.2767244691988686\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.015112290999999889 seconds\n", - "Run type OpenCL_Apple M1 was delayed in the previous run. Delay factor: 1.3600333738131474, Delay probability: 0.26507060779187813\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010992665999999929 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024932079999970824 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.046120946297413, Delay probability: 0.2837116618458667\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.02325162500000033 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0025075830000034216 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0521525283433852, Delay probability: 0.2837116618458667\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.026502666000000286 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0369017499999984 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 3.3750983254902267, Delay probability: 0.2378729659297821\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01908216700000054 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.7452882285644846, Delay probability: 0.2767244691988686\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.037486999999998716 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 3.4286263097997596, Delay probability: 0.307282648105079\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002425625000000764 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002453124999995282 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.023703125000004377 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 2.1679290954061465, Delay probability: 0.2378729659297821\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010771042000001785 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011932458000003976 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.094004795944319, Delay probability: 0.22512620904327668\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002367374999998617 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002370208000002094 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.019682124999995665 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.8001614321699533, Delay probability: 0.2378729659297821\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010376625000006356 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011390916999999945 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002413666999999009 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023762080000011565 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 ran in 0.02414062500000025 seconds\n", - "Agent: eSRRF_3D using Unthreaded ran in 7.447977541 seconds\n" + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012113417000001903 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1079142163358928, Delay probability: 0.2378729659297821\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011773040999997875 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011649499999997204 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002408374999994578 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002400624999999934 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011291207999995834 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01088270799999691 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011025957999997615 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002391082999999128 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024326670000007766 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01065154100000143 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011569209000001024 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0106232910000017 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002431207999997298 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024792919999967467 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.038806583904215, Delay probability: 0.21584394058925133\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.013070833000000448 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1954811511938002, Delay probability: 0.2378729659297821\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01237975000000091 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1322734963786951, Delay probability: 0.2767244691988686\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.015589583000000573 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.4258504130128007, Delay probability: 0.307282648105079\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002390999999995813 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002392042000003869 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01202066599999796 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.099431048334352, Delay probability: 0.2378729659297821\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0120369170000032 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.100917393098631, Delay probability: 0.2767244691988686\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011166625000001318 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024072080000010487 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024072920000008935 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011065000000002101 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011760291999998174 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01118149999999929 seconds\n", + "Agent: eSRRF_3D using Threaded ran in 52.68264575 seconds\n" ] } ], "source": [ "esrrf = eSRRF3D()\n", - "int_img, grad_r_int, grad_c_int, grad_s_int, rgc_img = esrrf.run(img, magnification_xy=8, magnification_z=1, run_type=\"Unthreaded\")" + "# int_img, grad_r_int, grad_c_int, grad_s_int, rgc_img = esrrf.run(img, magnification_xy=1, magnification_z=1, radius=3, sensitivity=2, run_type=\"Unthreaded\", doIntensityWeighting=True)\n", + "# rgc_img = esrrf.run(img, magnification_xy=2, magnification_z=2, radius=3, sensitivity=2, run_type=\"Threaded\", doIntensityWeighting=True)\n", + "\n", + "# rgc_img = run_esrrf3d(img, magnification_xy=2, magnification_z=2, radius=3, sensitivity=2, run_type=\"Threaded\", correlation=\"AVG\", framewindow=0, rollingoverlap=1)\n", + "rgc_img = run_esrrf3d(img4ana, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, radius_z =radius_z, ratio_px = ratio_px, sensitivity=sensitivity, run_type=run_type, correlation=correlation, framewindow=framewindow, rollingoverlap=rollingoverlap)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(17, 400, 400)" + "(21, 9, 50, 50)" ] }, - "execution_count": 5, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "int_img.shape" + "img.shape" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0becfe87eb474ab6a0b999945b29e1ac", - "version_major": 2, - "version_minor": 0 - }, "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=400, width=400),)),)), IntSlider(value=8, desc…" + "(1, 18, 100, 100)" ] }, - "execution_count": 6, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "stackview.slice(int_img)" + "rgc_img.shape\n" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from tifffile import imwrite\n", + "\n", + "rgc_img_fiji = rgc_img.squeeze()\n", + "imwrite('/Users/avesga/Desktop/3DeSRRF/test/' + name_save + '.tif', rgc_img_fiji)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "rgc_img.shape\n", + "\n", + "# rgc_img_fiji = np.expand_dims(rgc_img, axis=4)\n", + "# rgc_img_fiji = np.transpose(rgc_img_fiji, (0, 1, 3, 2, 4))\n", + "\n", + "# rgc_img_fiji = np.transpose(rgc_img, (0, 1, 3, 2))\n", + "rgc_img_fiji = rgc_img\n", + "# save the 4D array as a tiff file\n", + "\n", + "from tifffile import imwrite\n", + "\n", + "# # write OME-TIFF\n", + "# imwrite('/Users/avesga/Desktop/rgc_img_0.tif', rgc_img)\n", + "\n", + "# write ImageJ hyperstack\n", + "imwrite('/Users/avesga/Desktop/rgc_img_0.tif', rgc_img_fiji, imagej=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "index 4 is out of bounds for axis 0 with size 1", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[11], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m rgc_img\u001b[38;5;241m.\u001b[39mshape\n\u001b[0;32m----> 2\u001b[0m stackview\u001b[38;5;241m.\u001b[39mslice(\u001b[43mrgc_img\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m]\u001b[49m)\n", + "\u001b[0;31mIndexError\u001b[0m: index 4 is out of bounds for axis 0 with size 1" + ] + } + ], + "source": [ + "rgc_img.shape\n", + "stackview.slice(rgc_img[4])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gradients not yet calculated\n" + ] + } + ], + "source": [ + "esrrf.get_gradients()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'grad_r_int' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[10], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m stackview\u001b[38;5;241m.\u001b[39mslice(\u001b[43mgrad_r_int\u001b[49m)\n", + "\u001b[0;31mNameError\u001b[0m: name 'grad_r_int' is not defined" + ] + } + ], + "source": [ + "stackview.slice(grad_r_int)" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6ecca5f25dce4813aaa16c6a673d20a2", + "model_id": "b6b3bdb0b12448b28fb86947d3decfce", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=800, width=800),)),)), IntSlider(value=8, desc…" + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=342, width=342),)),)), IntSlider(value=4, desc…" ] }, - "execution_count": 7, + "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "stackview.slice(grad_r_int)" + "stackview.slice(grad_c_int)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "371c15dc20ec4a0297a53c913510cab8", + "model_id": "4bba6b7200944fba8da756cca12ea824", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=800, width=800),)),)), IntSlider(value=8, desc…" + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=342, width=342),)),)), IntSlider(value=4, desc…" ] }, - "execution_count": 8, + "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "stackview.slice(grad_c_int)" + "stackview.slice(grad_s_int)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "255c971ca99343d79ed64a8a79e19db2", - "version_major": 2, - "version_minor": 0 - }, "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=50, width=50),)),)), IntSlider(value=8, descri…" + "(9, 342, 342)" ] }, - "execution_count": 9, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "stackview.slice(grad_s_int)" + "grad_r_int.shape" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6a30ff953bb64fcc8c19aff7ab97688b", - "version_major": 2, - "version_minor": 0 - }, "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=400, width=400),)),)), IntSlider(value=8, desc…" + "(9, 171, 171)" ] }, - "execution_count": 10, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "stackview.slice(rgc_img[0])" + "int_img.shape" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rgc_img\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "cannot do a non-empty take from an empty axes.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[20], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mstackview\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mslice\u001b[49m\u001b[43m(\u001b[49m\u001b[43mA\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# # save rgc_img[0] as tiff\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m# from tifffile import imsave\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# imsave('/Users/avesga/Desktop/rgc_img_0.tif', rgc_img[0])\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/envs/nanopyxdev/lib/python3.9/site-packages/stackview/_slice.py:53\u001b[0m, in \u001b[0;36mslice\u001b[0;34m(image, slice_number, axis, display_width, display_height, continuous_update, slider_text, zoom_factor, zoom_spline_order, colormap, display_min, display_max)\u001b[0m\n\u001b[1;32m 50\u001b[0m image \u001b[38;5;241m=\u001b[39m image\u001b[38;5;241m.\u001b[39mget()\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mipywidgets\u001b[39;00m\n\u001b[0;32m---> 53\u001b[0m viewer \u001b[38;5;241m=\u001b[39m \u001b[43m_SliceViewer\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 54\u001b[0m \u001b[43m \u001b[49m\u001b[43mslice_number\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 55\u001b[0m \u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 56\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_width\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 57\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_height\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 58\u001b[0m \u001b[43m \u001b[49m\u001b[43mcontinuous_update\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 59\u001b[0m \u001b[43m \u001b[49m\u001b[43mslider_text\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 60\u001b[0m \u001b[43m \u001b[49m\u001b[43mzoom_factor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzoom_factor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 61\u001b[0m \u001b[43m \u001b[49m\u001b[43mzoom_spline_order\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzoom_spline_order\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 62\u001b[0m \u001b[43m \u001b[49m\u001b[43mcolormap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcolormap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 63\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_min\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdisplay_min\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 64\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_max\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdisplay_max\u001b[49m\n\u001b[1;32m 65\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 66\u001b[0m view \u001b[38;5;241m=\u001b[39m viewer\u001b[38;5;241m.\u001b[39mview\n\u001b[1;32m 67\u001b[0m slice_slider \u001b[38;5;241m=\u001b[39m viewer\u001b[38;5;241m.\u001b[39mslice_slider\n", + "File \u001b[0;32m~/miniforge3/envs/nanopyxdev/lib/python3.9/site-packages/stackview/_slice_viewer.py:27\u001b[0m, in \u001b[0;36m_SliceViewer.__init__\u001b[0;34m(self, image, slice_number, axis, display_width, display_height, continuous_update, slider_text, zoom_factor, zoom_spline_order, colormap, display_min, display_max)\u001b[0m\n\u001b[1;32m 24\u001b[0m slice_number \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(image\u001b[38;5;241m.\u001b[39mshape[axis] \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m 26\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mimage\u001b[38;5;241m.\u001b[39mshape) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m2\u001b[39m: \u001b[38;5;66;03m# and self.image.shape[-1] != 3:\u001b[39;00m\n\u001b[0;32m---> 27\u001b[0m sliced_image \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtake\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mslice_number\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 28\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 29\u001b[0m sliced_image \u001b[38;5;241m=\u001b[39m image\n", + "File \u001b[0;32m~/miniforge3/envs/nanopyxdev/lib/python3.9/site-packages/numpy/core/fromnumeric.py:192\u001b[0m, in \u001b[0;36mtake\u001b[0;34m(a, indices, axis, out, mode)\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[38;5;129m@array_function_dispatch\u001b[39m(_take_dispatcher)\n\u001b[1;32m 96\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtake\u001b[39m(a, indices, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, out\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, mode\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mraise\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[1;32m 97\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 98\u001b[0m \u001b[38;5;124;03m Take elements from an array along an axis.\u001b[39;00m\n\u001b[1;32m 99\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 190\u001b[0m \u001b[38;5;124;03m [5, 7]])\u001b[39;00m\n\u001b[1;32m 191\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 192\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_wrapfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mtake\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindices\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mout\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/nanopyxdev/lib/python3.9/site-packages/numpy/core/fromnumeric.py:59\u001b[0m, in \u001b[0;36m_wrapfunc\u001b[0;34m(obj, method, *args, **kwds)\u001b[0m\n\u001b[1;32m 56\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _wrapit(obj, method, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n\u001b[1;32m 58\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 59\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mbound\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 60\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[1;32m 61\u001b[0m \u001b[38;5;66;03m# A TypeError occurs if the object does have such a method in its\u001b[39;00m\n\u001b[1;32m 62\u001b[0m \u001b[38;5;66;03m# class, but its signature is not identical to that of NumPy's. This\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 66\u001b[0m \u001b[38;5;66;03m# Call _wrapit from within the except clause to ensure a potential\u001b[39;00m\n\u001b[1;32m 67\u001b[0m \u001b[38;5;66;03m# exception has a traceback chain.\u001b[39;00m\n\u001b[1;32m 68\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _wrapit(obj, method, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n", + "\u001b[0;31mIndexError\u001b[0m: cannot do a non-empty take from an empty axes." + ] + } + ], + "source": [ + "stackview.slice(A)\n", + "# # save rgc_img[0] as tiff\n", + "# from tifffile import imsave\n", + "# imsave('/Users/avesga/Desktop/rgc_img_0.tif', rgc_img[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2cc3d1daf7bb4854a28f0ab5b271eff3", + "model_id": "421ef57539b44747801395a886b68c99", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=400, width=400),)),)), IntSlider(value=8, desc…" + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=171, width=171),)),)), IntSlider(value=4, desc…" ] }, - "execution_count": 11, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -260,21 +755,21 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "697c1bd716fc43f38461a3068800ae29", + "model_id": "1b99a04beeaa4488bfadc2fbd5b184f7", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=400, width=400),)),)), IntSlider(value=8, desc…" + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=171, width=171),)),)), IntSlider(value=4, desc…" ] }, - "execution_count": 12, + "execution_count": 53, "metadata": {}, "output_type": "execute_result" } @@ -300,7 +795,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.16" + "version": "3.9.18" } }, "nbformat": 4, From e453507ae43ce1867c50f9ef5674886604548c60 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Mon, 4 Mar 2024 10:55:28 +0100 Subject: [PATCH 62/81] added ratio px in headers --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 29 +++++++++++++--------- 1 file changed, 17 insertions(+), 12 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 9fe3da40..8049c53c 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -16,7 +16,7 @@ cdef extern from "_c_gradients.h": void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int slices, int rows, int cols) nogil cdef extern from "_c_sr_radial_gradient_convergence.h": - float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) nogil + float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float ratio_px, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) nogil class eSRRF3D(LiquidEngine): """ @@ -36,9 +36,10 @@ class eSRRF3D(LiquidEngine): self.keep_interpolated = False self._img_interpolated = None - def run(self, image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None, keep_gradients=False, keep_interpolated = False): + def run(self, image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, ratio_px: float = 4.0, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None, keep_gradients=False, keep_interpolated = False): self.keep_gradients = keep_gradients self.keep_interpolated = keep_interpolated + # TODO: complete and check _run inputs, need to complete variables? if image.dtype != np.float32: image = image.astype(np.float32) if len(image.shape) == 4: @@ -47,7 +48,7 @@ class eSRRF3D(LiquidEngine): image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2])) return self._run(image, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, sensitivity=sensitivity, doIntensityWeighting=doIntensityWeighting, run_type=run_type) - def _run_unthreaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Unthreaded"): + def _run_unthreaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, ratio_px: float = 4.0, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Unthreaded"): interpolator = ShiftAndMagnify() @@ -55,8 +56,10 @@ class eSRRF3D(LiquidEngine): cdef float fwhm = radius cdef float tSS = 2 * sigma * sigma cdef float tSO = 2 * sigma + 1 - cdef float sigma_z = radius_z / 2.355 - cdef float fwhm_z = radius_z + # cdef float sigma_z = radius_z / 2.355 # Old version + # cdef float fwhm_z = radius_z + cdef float sigma_z = radius * ratio_px / 2.355 # Taking voxel size into account + cdef float fwhm_z = radius * ratio_px cdef float tSS_z = 2 * sigma_z * sigma_z cdef float tSO_z = 2 * sigma_z + 1 cdef int Gx_Gy_MAGNIFICATION = 2 @@ -113,7 +116,7 @@ class eSRRF3D(LiquidEngine): for rM in range(0, n_rows_mag): for cM in range(0, n_cols_mag): if _doIntensityWeighting: - rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) # zcof = (sM) / _magnification_z # if (zcof < 0): # z0 = 0 @@ -124,7 +127,7 @@ class eSRRF3D(LiquidEngine): # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val * image_interpolated[sM, rM, cM] else: - rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) # zcof = (sM) / _magnification_z # if (zcof < 0): # z0 = 0 @@ -137,7 +140,7 @@ class eSRRF3D(LiquidEngine): return np.asarray(rgc_map) - def _run_threaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Threaded"): + def _run_threaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, ratio_px: float = 4.0, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Threaded"): interpolator = ShiftAndMagnify() @@ -145,8 +148,10 @@ class eSRRF3D(LiquidEngine): cdef float fwhm = radius cdef float tSS = 2 * sigma * sigma cdef float tSO = 2 * sigma + 1 - cdef float sigma_z = radius_z / 2.355 - cdef float fwhm_z = radius_z + # cdef float sigma_z = radius_z / 2.355 # Old version + # cdef float fwhm_z = radius_z + cdef float sigma_z = radius * ratio_px / 2.355 # Taking voxel size into account + cdef float fwhm_z = radius * ratio_px cdef float tSS_z = 2 * sigma_z * sigma_z cdef float tSO_z = 2 * sigma_z + 1 cdef int Gx_Gy_MAGNIFICATION = 2 @@ -209,7 +214,7 @@ class eSRRF3D(LiquidEngine): for rM in prange(0, n_rows_mag): for cM in range(0, n_cols_mag): if _doIntensityWeighting: - rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) # zcof = (sM) / _magnification_z # if (zcof < 0): # z0 = 0 @@ -220,7 +225,7 @@ class eSRRF3D(LiquidEngine): # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val * image_interpolated[sM, rM, cM] else: - rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) # zcof = (sM) / _magnification_z # if (zcof < 0): # z0 = 0 From 21ce4bab1833a773353bcc1ce23f6219d89f2bb5 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Mon, 4 Mar 2024 10:55:54 +0100 Subject: [PATCH 63/81] corrected starting pixel in rgc3D --- src/include/_c_sr_radial_gradient_convergence.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index e299d45b..462b461a 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -116,7 +116,7 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn float xc = (xM + 0.5) / magnification_xy; float yc = (yM + 0.5) / magnification_xy; - float zc = (sliceM + 0.5) / magnification_z; + float zc = (sliceM + 1) / magnification_z; float RGC = 0; float distanceWeightSum = 0; From a1551a3f6c604fbbdde01938ee2326fca1126f5e Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Mon, 4 Mar 2024 11:09:29 +0100 Subject: [PATCH 64/81] . --- src/include/_c_sr_radial_gradient_convergence.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 462b461a..83170be6 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -147,8 +147,8 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn dz_real = dz * ratio_px; distance = sqrt(dx * dx + dy * dy + dz_real * dz_real); distance_xy = sqrt(dx * dx + dy * dy); - distance_z = dz_real; // TODO: need to add a variable voxel aspect ratio = 4 (for instance) to multiply dz - // TODO: check if this is correct. Need to add the real ratio and size of the voxel + distance_z = dz_real; + // if (distance != 0 && distance <= tSO ) { if (distance != 0 && distance_xy <= tSO && distance_z <= tSO_z) { From c4dcb6a2dc69246791ecf5ba22476f9d76eda392 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Mon, 4 Mar 2024 11:46:21 +0100 Subject: [PATCH 65/81] added comment --- src/include/_c_sr_radial_gradient_convergence.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 83170be6..f6a2183a 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -143,8 +143,8 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn if (0 < vz && vz < slicesM - 1) { dx = vx - xc; dy = vy - yc; - dz = vz - zc; - dz_real = dz * ratio_px; + dz = vz - zc; + dz_real = dz * ratio_px; // This has been already divigy by magnification_z distance = sqrt(dx * dx + dy * dy + dz_real * dz_real); distance_xy = sqrt(dx * dx + dy * dy); distance_z = dz_real; From b259c1fb92fd37b04cd146104a06cebbd1df5b2a Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Tue, 19 Mar 2024 15:38:43 +0000 Subject: [PATCH 66/81] test script --- tests/test_3D_eSRRF/load_analyse.ipynb | 215 +++++++++++++++++++++++++ 1 file changed, 215 insertions(+) create mode 100644 tests/test_3D_eSRRF/load_analyse.ipynb diff --git a/tests/test_3D_eSRRF/load_analyse.ipynb b/tests/test_3D_eSRRF/load_analyse.ipynb new file mode 100644 index 00000000..619170fd --- /dev/null +++ b/tests/test_3D_eSRRF/load_analyse.ipynb @@ -0,0 +1,215 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# This script loads the images from /Users/avesga/Code/radialsym and analyzes them with eSRRF3D\n", + "# test version to have everything working, later on we will use an automatic python script\n", + "\n", + "# agv, 19Mar2023\n", + "\n", + "import os\n", + "\n", + "import stackview\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "from tifffile import imread\n", + "from nanopyx.methods.esrrf_3d.run import run_esrrf3d\n", + "\n", + "from nanopyx.core.transform._le_esrrf3d import eSRRF3D" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# set parameters\n", + "\n", + "path = \"/Users/avesga/Code/radialsym/simulations/FULL_distance_emitters_0.5_px_size_0.02_int_f_1500_offset_200_int_noise_100.tiff\"" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# Load file\n", + "\n", + "img = imread(path).astype(np.float32)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# Define variables for eSRRF\n", + "\n", + "magnification_xy=2\n", + "magnification_z=2\n", + "radius=1\n", + "radius_z = 1\n", + "ratio_px = 1\n", + "sensitivity=2\n", + "run_type=\"Threaded\"\n", + "correlation=\"AVG\"\n", + "framewindow=0\n", + "rollingoverlap=2" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.014986958999998024 seconds\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012834459000004017 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01826745799999685 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.016381292000005487 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.014241874999981974 seconds\n", + "Agent: eSRRF_3D using Threaded ran in 8.917302250000006 seconds\n" + ] + } + ], + "source": [ + "# esrrf3d\n", + "esrrf = eSRRF3D()\n", + "\n", + "rgc_img = run_esrrf3d(img, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, radius_z =radius_z, ratio_px = ratio_px, sensitivity=sensitivity, run_type=run_type, correlation=correlation, framewindow=framewindow, rollingoverlap=rollingoverlap)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'XZ intensity at the center')" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 4, figsize=(12, 3))\n", + "\n", + "ax[0].matshow(img[img.shape[0]//2, :, : ])\n", + "ax[1].plot(img[img.shape[0]//2, img.shape[0]//2, : ])\n", + "ax[2].matshow(img[:,:, img.shape[0]//2])\n", + "ax[3].plot(img[:,img.shape[0]//2, img.shape[0]//2])\n", + "\n", + "ax[0].set_title(\"XY subsampled PSF\")\n", + "ax[1].set_title(\"XY intensity at the center\")\n", + "ax[2].set_title(\"XZ subsampled PSF\")\n", + "ax[3].set_title(\"XZ intensity at the center\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'XZ intensity at the center')" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA98AAAEyCAYAAADjtmPFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydeXgURfrHv9U9Z24SkpBwHyoCCoiIitcCCt7+ZEW8wAtUwIvdVXE9AA9EXURRQV1XUfFYb9cVWMVbERVFRTwAuSGBEHJP5uh+f390d3X1TE8OSAiB+jxPHpKenq7qnqHfrqrv+30ZEREkEolEIpFIJBKJRCKRNBtKS3dAIpFIJBKJRCKRSCSS/R05+JZIJBKJRCKRSCQSiaSZkYNviUQikUgkEolEIpFImhk5+JZIJBKJRCKRSCQSiaSZkYNviUQikUgkEolEIpFImhk5+JZIJBKJRCKRSCQSiaSZkYNviUQikUgkEolEIpFImhk5+JZIJBKJRCKRSCQSiaSZkYNviUQikUgkEolEIpFImhk5+N4PmDp1KhhjKCkpaemuNAsff/wxGGP4+OOPm+yY1jWTSCQSiaQpsWLWa6+91tJdaTYYY5g6dWqTHa854rxEIpHsi8jBt8DFF1+MQCCA33//PeG1++67D4wxvPvuu3j55ZfBGMMTTzzhepxrrrkGXq8XP/zwQ3N3WdLMXHrppWCM8Z+MjAz07dsX//jHPxAOhx37fv755zj11FPRvn17BAIBdOrUCWeeeSZefPFFx37i8cSfdu3a7c1Tk0gkkn2WhsZjIPE+7fbTpUuXvXwGkubg2WefdXyugUAABx98MCZNmoTi4mLHvuvXr8dll12G7t27IxAIoF27djjhhBNw5513OvY76aSTkn5vfv311715ehKJ5ADA09Id2JeYNWsW3nvvPVx99dX48MMP+fZ169Zh+vTpGDlyJM444wwAwPz583HLLbfgnHPOQX5+Pt/366+/xpNPPom//OUv6Nu3714/B0nT4/f78c9//hMAUFZWhtdffx1//etf8c033+Dll18GALz66qs4//zz0a9fP1x//fVo06YN1q1bh08//RRPPfUULrzwQscxTz75ZIwZM8axLRgM7p0Tkkgkkn2cxsTjq666CsOGDXM9zpIlS/Dss8/i6KOP3iv9luwdpk+fjq5du6K2thaff/455s6di/feew8rV65ESkoK1qxZg4EDByIYDOLyyy9Hly5dsG3bNnz33XeYOXMmpk2b5jhehw4dMGPGjIR2CgsL99YpSSSSAwQ5+BbIy8vDzJkzMX78eMyfPx9jx44FAEyYMAFerxcPP/ww33fu3Lno3bs3brzxRr6yqWkarrrqKnTq1KlJ5ViSlsXj8eDiiy/mf0+YMAGDBg3CK6+8glmzZqGwsBBTp05Fr1698NVXX8Hn8znev3379oRjHnzwwY5jSiQSicSmMfH4mGOOwTHHHJNwjG3btmHy5Mno3Lkz5s6du9f6Lml+Tj31VBx55JEAgCuvvBI5OTmYNWsW3n77bVxwwQV46KGHUFVVhRUrVqBz586O97rF5MzMTBmTJRLJXkHKzuO48sorMXjwYPz1r3/Fzp078fLLL2PRokW4++670b59e75fly5dMHXqVLz00kt4//33AQCPPPIIVqxYgblz5yIlJaXOdlavXo2RI0eiXbt2CAQC6NChA0aPHo3y8nIAhlyKMYZnn3024b3Jcq1KSkowatQoZGRkICcnB9dffz1qa2sd+7z//vs47rjjkJWVhbS0NBxyyCG49dZb+euRSAR33HEHBgwYgMzMTKSmpuL444/HRx995DiO1b8HH3wQjz32GLp164aUlBSccsop2LRpE4gId911Fzp06IBgMIizzz4bpaWljmN06dIFZ5xxBv73v/+hX79+CAQC6NWrF9544406r53FsmXLMGLECGRmZiIlJQUnnngivvjii4T9Pv/8cwwcOBCBQADdu3dPmi7QUBRFwUknncSvAwCsXbsWAwcOTBh4A8ZDpEQikUgaR0PjsRu6ruOiiy7Crl278OKLL6JNmzZ17l9ZWYkbbrgBXbp0gd/vR15eHk4++WR89913fJ8uXbrg0ksvTXjvSSedxGOCiKZpuPXWW9GuXTukpqbirLPOwqZNmxz71PcsAADPPPMMhgwZgry8PPj9fvTq1ct1MsGKqR9//DGOPPJIBINBHHbYYTyP+o033sBhhx2GQCCAAQMG4Pvvv3e8/9JLL0VaWhr++OMPDB8+HKmpqSgsLMT06dNBRHVePwDYsmULLr/8cuTn58Pv96N3797417/+lbDf5s2bcc455yA1NRV5eXm48cYbE9K4GsuQIUMAGMoIwIjJHTp0SBh4AzImSySSlkWufMdh5XL3798f11xzDT777DMceeSRmDhxYsK+N954IxYsWIBrrrkGixYtwh133IHRo0djxIgRdbYRiUQwfPhwhMNhXHvttWjXrh22bNmCd999F2VlZcjMzNytvo8aNQpdunTBjBkz8NVXX+GRRx7Brl278NxzzwEAfv75Z5xxxhk4/PDDMX36dPj9fqxZs8YxYK2oqMA///lPXHDBBRg3bhwqKyvx9NNPY/jw4fj666/Rr18/R5sLFixAJBLBtddei9LSUtx///0YNWoUhgwZgo8//hg333wz1qxZgzlz5uCvf/1rQiBevXo1zj//fFx99dUYO3YsnnnmGZx33nlYtGgRTj755KTn+uGHH+LUU0/FgAEDcOedd0JRFP6A8tlnn+Goo44CAPz000845ZRTkJubi6lTpyIWi+HOO+90pArsDmvXrgUA5OTkAAA6d+6MJUuWYPPmzejQoUO976+trU0wyEtPT4ff79+jfkkkEsn+QmPicTx33XUXPvroI9xzzz049thj693/6quvxmuvvYZJkyahV69e2LlzJz7//HP88ssvOOKII3ar//fccw8YY7j55puxfft2zJ49G8OGDcOKFSsQDAYb/CxgKe3OOusseDwe/Oc//8GECROg63rCtVizZg0uvPBCXHXVVbj44ovx4IMP4swzz8S8efNw6623YsKECQCAGTNmYNSoUfjtt9+gKPY6jKZpGDFiBI4++mjcf//9WLRoEe68807EYjFMnz496bkWFxfj6KOPBmMMkyZNQm5uLhYuXIgrrrgCFRUVuOGGGwAAoVAIQ4cOxcaNG3HdddehsLAQzz//vCO1YHdwi8kffPABPvzwQz4wrwtN0xJiciAQQFpa2h71SyKRSBIgiStTpkwhAKSqKi1fvjzpfsuWLSNFUSg7O5uysrKoqKio3mN///33BIBeffXVpPusW7eOANAzzzyT8BoAuvPOO/nfd955JwGgs846y7HfhAkTCAD98MMPRET00EMPEQDasWNH0nZjsRiFw2HHtl27dlF+fj5dfvnlCf3Lzc2lsrIyvt26bn379qVoNMq3X3DBBeTz+ai2tpZv69y5MwGg119/nW8rLy+ngoIC6t+/P9/20UcfEQD66KOPiIhI13U66KCDaPjw4aTrOt+vpqaGunbtSieffDLfds4551AgEKANGzbwbatWrSJVVakhX/+xY8dSamoq7dixg3bs2EFr1qyhe++9lxhjdPjhh/P9nn76aQJAPp+P/vSnP9Htt99On332GWmalnBMAK4/bp+1RCKRHOg0NB5bfPzxx6SqKg0dOtT1HuxGZmYmTZw4sc59OnfuTGPHjk3YfuKJJ9KJJ57I/7ZiVvv27amiooJv//e//00A6OGHHyaihj0LEBmxLZ7hw4dTt27dEvoHgL788ku+bfHixQSAgsGgIw4+8cQTjrhKZMQ7AHTttdfybbqu0+mnn04+n8/x7BD/HHLFFVdQQUEBlZSUOPo0evRoyszM5Ocwe/ZsAkD//ve/+T7V1dXUo0ePhP648cwzzxAA+uCDD2jHjh20adMmevnllyknJ4eCwSBt3ryZiIhWrlxJwWCQAFC/fv3o+uuvp7feeouqq6sTjnniiSe6xmS3z1oikUj2FCk7T0Lbtm0BGGYbffr0SbrfUUcdhauvvhqlpaWYMWNGg1ZUrdnsxYsXo6ampmk6DCTMgF977bUAgPfeew8AkJWVBQB4++23oeu66zFUVeXSaV3XUVpailgshiOPPNIhv7M477zzHCv1gwYNAmA41Xo8Hsf2SCSCLVu2ON5fWFiI//u//+N/Z2RkYMyYMfj+++9RVFTk2scVK1Zg9erVuPDCC7Fz506UlJSgpKQE1dXVGDp0KD799FPoug5N07B48WKcc8456NSpE3//oYceiuHDh7se243q6mrk5uYiNzcXPXr0wK233opjjjkGb775Jt/n8ssvx6JFi3DSSSfh888/x1133YXjjz8eBx10EL788suEY5599tl4//33HT+N6ZNEIpEcKDQ0HgNG+tWFF16InJwcvPDCC45V3brIysrCsmXLsHXr1j3ur8WYMWOQnp7O//7zn/+MgoICHpMb+iwgmnGWl5ejpKQEJ554Iv744w+HPB0AevXq5ch/t2LykCFDHHHQ2v7HH38ktDdp0iT+u7WSHYlE8MEHH7j2j4jw+uuv48wzzwQR8ZhcUlKC4cOHo7y8nD8/vPfeeygoKMCf//xn/v6UlBSMHz8+6fm7MWzYMOTm5qJjx44YPXo00tLS8Oabb/J0hN69e2PFihW4+OKLsX79ejz88MPcIPepp55KOF6XLl0SYvJNN93UqD5JJBJJQ5Cycxc2bdqEO++8E3369MHKlStx//3347bbbku6/8CBAwGAm3/UR9euXTF58mTMmjULCxYswPHHH4+zzjoLF1988W5LzgHgoIMOcvzdvXt3KIrC85LPP/98/POf/8SVV16JW265BUOHDsW5556LP//5z44HlPnz5+Mf//gHfv31V0SjUUe/4xGDOWA/THTs2NF1+65duxzbe/TokVBv++CDDwZg5FO7ld9avXo1AHADHjfKy8sRDocRCoUSrgsAHHLIIfwBqD4CgQD+85//ADCcz7t27eoqLR8+fDiGDx+OmpoaLF++HK+88grmzZuHM844A7/++qsjz6xDhw5J3XklEolEYtCYeExEGDNmDLZt24aFCxc2qnzj/fffj7Fjx6Jjx44YMGAATjvtNIwZMwbdunXb7b7Hxx7GGHr06MFjckOfBb744gvceeedWLp0acIgvby83LHvnsZkRVESzlmMyW7s2LEDZWVlePLJJ/Hkk0+67mOZnG3YsME17h9yyCGu70vGY489hoMPPhgejwf5+fk45JBDEiZaDj74YDz//PPQNA2rVq3Cu+++i/vvvx/jx49H165dHTE4NTVVxmSJRLJXkCvfLlizvgsXLsR5552He+65x3V2eE/4xz/+gR9//BG33norQqEQrrvuOvTu3RubN28GgITAZKFpWoPbiD9GMBjEp59+ig8++ACXXHIJfvzxR5x//vk4+eST+XFfeOEFXHrppejevTuefvppLFq0CO+//z6GDBniulquqqpr28m2UwNMW+rD6scDDzyQMFNt/TRlnpaqqhg2bBiGDRuG448/vt6c7pSUFBx//PF49NFHcdttt2HXrl1YuHBhk/VH0nAuvfTS/aa+79SpU5PeF1o71uqaRBJPY+Lxgw8+iIULF+Kvf/1ro5VEo0aNwh9//IE5c+agsLAQDzzwAHr37u24dzdFXI6nvmeBtWvXYujQoSgpKcGsWbPw3//+F++//z5uvPFGAEiIyy0Zky+++OKkMXnw4MF73I7IUUcdhWHDhuGkk07CoYceWqfCQVVVHHbYYZgyZQpXrC1YsKBJ+yNpGFad9mQTOa2Jjz/+GIwxbmi4P3HSSSfVqzKS7D5y8B3Hm2++iXfeeYc7dc+ePRs+n69BBi+N5bDDDsNtt92GTz/9FJ999hm2bNmCefPmAQB3Zi0rK3O8Z8OGDUmPZ60IW6xZswa6rjsGH4qiYOjQoZg1axZWrVqFe+65Bx9++CF3M3/ttdfQrVs3vPHGG7jkkkswfPhwDBs2LME1valYs2ZNQvD//fffASDpoKl79+4ADIm6NSiO//F6vcjNzUUwGEy4LgDw22+/Ne2JJMFSQ2zbtm2vtNcauPjiixEIBPjnLHLfffeBMYZ3330XL7/8MjdccuOaa66B1+vFDz/80Cz9fO+99/b5koH33nsv3nrrrRZpe+vWrZg6dSpWrFjRoP2//PJLTJ06NeGetr9TU1ODqVOn7pcPaM1NY+LxsmXL8Pe//x2DBg3CPffcs1vtFRQUYMKECXjrrbewbt065OTkOI7Vpk0b1+9vsrgcH3uICGvWrEmIbXU9C/znP/9BOBzGO++8g6uuugqnnXYahg0b5pCiNyW6ridMbtQXk3Nzc5Geng5N05LGZEv51blzZ6xduzYh7suY3DI0NB4DxmQ2Y6zOn+ac7F61ahWmTp26Tw/cX3zxRcyePbvF2m/MM0FjY/j+xOOPP+5aTWpvIQffApWVlbjuuuvQv39/ni9dWFiIu+66C4sWLcKrr77aJO1UVFQgFos5th122GFQFIWX28jIyEDbtm3x6aefOvZ7/PHHkx73sccec/w9Z84cAEY9TAAJpb4AcPdyq11rdlwMjMuWLcPSpUvrPa/dYevWrY7c6YqKCjz33HPo169fUsnggAED0L17dzz44IOoqqpKeH3Hjh0AjHMZPnw43nrrLWzcuJG//ssvv2Dx4sVNeh5Llixx3W5J2xsrqdufmTVrFlJSUnD11Vc7tq9btw7Tp0/HyJEjccYZZ/DKAbfccguKi4sd+3799dd48sknceONN6Jv375J23rqqad2+6Huvffew7Rp03brvc3BbbfdhlAo5NjW0oPvadOmNWrwPW3atANy8D1t2jQ5+G4kjYnHZWVlGD16NFJSUvDSSy/B6/U2qi1N0xJyp/Py8lBYWOgogdW9e3d89dVXiEQifNu7776bUD7M4rnnnkNlZSX/+7XXXsO2bdt4TG7Is4BbTC4vL8czzzzTqHNsDI8++ij/nYjw6KOPwuv1YujQoa77q6qKkSNH4vXXX8fKlSsTXrdiMgCcdtpp2Lp1K1577TW+raamJqlcfXf57LPPHGlzFjImO2loPAaAq666Cs8//7zrj1WC7+ijj66zvUsuuQShUMi1BFx9rFq1CtOmTdtnBt8nnHACQqEQTjjhBL6ttQ2+GxPD9ydaevAtc74FbrvtNmzduhVvvPGGQ6I1ceJEzJ8/HzfccANGjBjhMFDZHT788ENMmjQJ5513Hg4++GDEYjE8//zzPIBZXHnllbjvvvtw5ZVX4sgjj8Snn37qOjtpsW7dOpx11lkYMWIEli5dihdeeAEXXnghH5xMnz4dn376KU4//XR07twZ27dvx+OPP44OHTrguOOOAwCcccYZeOONN/B///d/OP3007Fu3TrMmzcPvXr1ch3o7ikHH3wwrrjiCnzzzTfIz8/Hv/71LxQXF9f5YKEoCv75z3/i1FNPRe/evXHZZZehffv22LJlCz766CNkZGTwHO1p06Zh0aJFOP744zFhwgTEYjHMmTMHvXv3xo8//thk53H22Weja9euOPPMM9G9e3dUV1fjgw8+wH/+8x8MHDgQZ555ZpO11drJy8vDzJkzMX78eMyfP5/n7k+YMAFerxcPP/ww39cqsXPjjTfixRdfBGA8KF911VXo1KlTvSvTjX0I35fxeDwOE0PJgU11dTVSU1NbuhvNRmPi8dVXX43169fj/PPPxxdffOEonyly8cUXu26vrKxEhw4d8Oc//xl9+/ZFWloaPvjgA3zzzTf4xz/+wfe78sor8dprr2HEiBEYNWoU1q5dixdeeIGrseLJzs7Gcccdh8suuwzFxcWYPXs2evTogXHjxgFo2LPAKaecAp/PhzPPPBNXXXUVqqqq8NRTTyEvL69ZVm8DgQAWLVqEsWPHYtCgQVi4cCH++9//4tZbb0Vubm7S991333346KOPMGjQIIwbNw69evVCaWkpvvvuO3zwwQd88n/cuHF49NFHMWbMGCxfvhwFBQV4/vnnkZKS0qTnMXPmTCxfvhznnnsuDj/8cADAd999h+eeew7Z2dm89NmBTmPi8THHHOMw87PYtm0bJk+ejM6dO7vWnxdRVTVpCkRrQ1EUBAKBlu6GZB8hFotB13VuWl0nLeSyvs/x7bffkqqqNGnSJNfXv/76a1IUha677rqE16zSF998802D2vrjjz/o8ssvp+7du1MgEKDs7Gz605/+RB988IFjv5qaGrriiisoMzOT0tPTadSoUbR9+/akpcZWrVpFf/7znyk9PZ3atGlDkyZNolAoxPdbsmQJnX322VRYWEg+n48KCwvpggsuoN9//53vo+s63XvvvdS5c2fy+/3Uv39/evfdd2ns2LHUuXNnvp9VauyBBx5w9NkqsRJfOsXtGnXu3JlOP/10Wrx4MR1++OHk9/upZ8+eCe+NLzVm8f3339O5555LOTk55Pf7qXPnzjRq1ChasmSJY79PPvmEBgwYQD6fj7p160bz5s3j16w+rFJj9fHSSy/R6NGjqXv37hQMBikQCFCvXr3o73//u6PUDJFRoqW+kjb7O7qu0+DBg6lt27ZUUlJCL730EgGgRx55JGHf+++/nwDQ//73PyIimjVrFgGghQsX1ttOXd/bJ554grp160Y+n4+OPPJI+vrrrx3vg0vpGQtN0+ihhx6iXr16kd/vp7y8PBo/fjyVlpY62re+45999hkNHDiQ/H4/de3alebPn+/YLxKJ0NSpU6lHjx7k9/spOzubBg8ezM+ZiBK+s279Gzt2LH344YcEgN54442E67FgwYKEUkTx7Ny5k/7yl79Qnz59KDU1ldLT02nEiBG0YsUKvo/1fzL+J1m5PKvv8T/r1q3j5zJx4kR68803qXfv3uTz+ahXr16un/HmzZvpsssuo7y8PL7f008/nfR84nn++edp4MCBFAwGKSsri44//nhavHixY5/33nuPjjvuOEpJSaG0tDQ67bTTaOXKlY59rHvD5s2b6eyzz6bU1FRq27Yt/eUvf6FYLEZE9vct/ke8f//yyy80cuRIatOmDfn9fhowYAC9/fbbjras++fHH39M11xzDeXm5lJWVlaDz7m10dh4bJXYqu8nGeFwmP72t79R3759KT09nVJTU6lv3770+OOPJ+z7j3/8g9q3b09+v58GDx5M3377bdJSYy+99BJNmTKF8vLyKBgM0umnn+4o99XQZ4F33nmHDj/8cAoEAtSlSxeaOXMm/etf/3L8H7Kuw+mnn57QZ7eY4xbDre/02rVr6ZRTTqGUlBTKz8+nO++8M6FkW/z3mIiouLiYJk6cSB07diSv10vt2rWjoUOH0pNPPunYb8OGDXTWWWdRSkoKtW3blq6//npatGhRo0qN1fe89cUXX9DEiROpT58+lJmZSV6vlzp16kSXXnoprV271rHviSeeSL17967zePszjYnH8WiaRn/605/I4/HQF198Ue/+1ufn9r2tK05a74v/Eb8vTXXftnjppZfoiCOOoLS0NEpPT6c+ffrQ7Nmz+evxz6ZuJes6d+5MlZWVlJKS4jp+2LRpEymKQvfee2+d1+2BBx6gY445hrKzsykQCNARRxyR8Kyc7JnAjfpiuPV/4ueff6aTTjqJgsEgFRYW0syZMxOOVVtbS3fccQd1796dfD4fdejQgf72t785SgvXxVdffUWnnnoqZWVlUUpKCh122GGO60zUuDj5+eef04033kht27allJQUOuecc2j79u18P7d4Id6/d+3aRddffz116NCBfD4fde/ene677z7HPVC8fz700EPUrVs3UhSFvv/++wadsxx8S1qMZA8KkgODlStXktfrpfPOO4/atWtHRx55pGtN3mg0Sn379qXu3bvT6tWrKS0tjUaPHt2gNpINvvv37089evSgmTNn0v33309t27alDh06UCQSISKiL7/8kk4++WQCQM8//zz/sbjyyivJ4/HQuHHjaN68eXTzzTdTamoqDRw4kB+DyPiOH3LIIZSfn0+33norPfroo3TEEUcQY8zxUHDrrbcSY4zGjRtHTz31FP3jH/+gCy64gO677z6+T/zg+/nnnye/30/HH38879+XX35Juq5Tx44daeTIkQnX47TTTqPu3bvXec2++eYb6t69O91yyy30xBNP0PTp06l9+/aUmZlJW7ZsISKioqIimj59OgGg8ePH8/bjH2otfvjhB7rgggsIAD300EN8/6qqKiIyHhr69u1LBQUFdNddd9Hs2bOpW7dulJKS4qgbXFRURB06dKCOHTvS9OnTae7cuXTWWWfx49bH1KlTCQAde+yx9MADD9DDDz9MF154Id188818n+eee44YYzRixAiaM2cOzZw5k7p06UJZWVmOB8axY8dSIBCg3r170+WXX05z586lkSNHEgA+aKuqqqK5c+cSAPq///s/ft4//PADERn/BzIzM6lXr140c+ZMevTRR+mEE04gxphj8sR6qOjVqxedeOKJNGfOHMd3QyJpCho62SzZ/2hoPI7Huqfec889DWon2eC7vji5du1auu666wgA3XrrrfxeWlRURERNe98mIvrf//5HAGjo0KH02GOP0WOPPUaTJk2i8847j+8TP/j+3//+R/369aO2bdvy/r355ptERHTRRRdRfn5+wgD//vvvJ8aYY1LOjQ4dOtCECRPo0UcfpVmzZtFRRx1FAOjdd9/l+yR7JnCjvhh+4oknUmFhIXXs2JGuv/56evzxx2nIkCEEgN577z1+HE3T+ETdDTfcQE888QRNmjSJPB4PnX322XWek3XNfD4fde7cme68806aO3cuXXfddTRs2DC+T2PjZP/+/WnIkCE0Z84c+stf/kKqqtKoUaP4fm+++SZ16NCBevbsyc/bWuiorq6mww8/nHJycujWW2+lefPm0ZgxY4gxRtdffz0/hvUs2atXL+rWrRvdd9999NBDD9X7OVrIwbekxZCDb8mUKVMIAKmqSsuXL0+637Jly0hRFMrOzqasrCwecOsj2eA7JyfHsUr99ttvEwD6z3/+w7dNnDjRdbXss88+IwC0YMECx3Zr5Ubcbs2wfvrpp3zb9u3bye/301/+8he+rW/fvvX+X3BTa6SmprrObE+ZMoX8fj+VlZU52vV4PAmrVfHU1tYmPHStW7eO/H4/TZ8+nW/75ptv6lztjueBBx5IeOiyAEA+n4/WrFnDt/3www8EgObMmcO3XXHFFVRQUOAYkBMRjR49mjIzM6mmpiZp+6tXryZFUej//u//Es5P13UiIqqsrKSsrCwaN26c4/WioiLKzMx0bLfUEeI1ISLq378/DRgwgP+9Y8cO11VCIqKhQ4fSYYcd5lgh0HWdjj32WDrooIP4Nuuh4rjjjkt4eJNImgo5+D6waWg8tvj4449JVVUaOnRogwbqRMkH3w2Jk6+++qqrOqI57tvXX389ZWRk1Hm/dVNlnn766Y5nDovFixe7KvYOP/xwx6prMuJjWyQSoT59+tCQIUMc25M9E7hRVwy3VvGfe+45vi0cDlO7du0cE/vPP/88KYpCn332meP98+bNIwB1qiFisRh17dqVOnfuTLt27XK8ZsVkosbHyWHDhjnef+ONN5Kqqo7nod69e7te97vuuotSU1MdimAioltuuYVUVaWNGzcSkf0smZGR4VhVbyjScE0ikbQYbdu2BWAYKdVV1uKoo47C1VdfjdLSUsyYMQP5+fl71O7555/PKwoAwPHHHw8ADSop+OqrryIzMxMnn3wySkpK+M+AAQOQlpbGKwdY9OrVix8fMJyBDznkEEdbWVlZ+Pnnn12d+XeHMWPGIBwOO0yNXnnlFcRisaR5rxZ+v5+X7dE0DTt37kRaWhoOOeQQfPfdd03SPzeGDRvmyJ09/PDDkZGRwa8TEeH111/HmWeeCSJyXPvhw4ejvLy8zv699dZb0HUdd9xxR0JZIquE1Pvvv4+ysjJccMEFjuOrqopBgwYlfLYAEoyKjj/++AZ9j0pLS/Hhhx9i1KhRqKys5G3t3LkTw4cPx+rVq7FlyxbHe8aNG7ff5EtKJJJ9i4bGYwAoKSnBhRdeiJycHLzwwgt1lnprCA2Jk8lojvt2VlYWqqur8f777+/BWdkMGzYMhYWFjhJ3K1euxI8//lhvTAbgqG6wa9culJeX4/jjj2/WmJyWlubom8/nw1FHHeW4Tq+++ioOPfRQ9OzZ03HthwwZAgCu197i+++/x7p163DDDTcgKyvL8ZoVk3cnTo4fP95RFvL444+Hpml1VosSz+f4449HmzZtHOczbNgwaJqWYII9cuTIOr0wkiHdeyQSSYuwadMm3HnnnejTpw9WrlyJ+++/H7fddlvS/QcOHAjALhWzJ3Tq1MnxtzUQ37VrV73vXb16NcrLy3npnHi2b99eZ1tWe2Jb06dPx9lnn42DDz4Yffr0wYgRI3DJJZdwo6DG0rNnTwwcOBALFizAFVdcAcCoa3v00UejR48edb5X13U8/PDDePzxx7Fu3TpHDeOcnJzd6k9DqO867dixA2VlZXjyySeTOiPHX3uRtWvXQlEU9OrVK+k+1uSH9eAQT0ZGhuPvQCCQEHjjP9tkWGUWb7/9dtx+++2u+2zfvh3t27fnf3ft2rXe40okEkljaUw8JiKMGTMG27Ztw8KFC5NWpmkMDYmTyWiO+/aECRPw73//G6eeeirat2+PU045BaNGjcKIESPq7Y8biqLgoosuwty5c1FTU4OUlBQsWLAAgUAA5513Xr3vf/fdd3H33XdjxYoVjgoM4iCzqenQoUPC8du0aeMwK169ejV++eWXpAPQ+mIygDonenYnTu7p892PP/7Y4PPZ3ZgsB9+SFmNfKRchaRkmTZoEAFi4cCEmT56Me+65BxdeeCG6devW7G0nWz2kuNqzbui6jry8PMcMtkj8TbshbZ1wwglYu3Yt3n77bfzvf//DP//5Tzz00EOYN28errzyynr75MaYMWNw/fXXY/PmzQiHw/jqq68cJYSSce+99+L222/H5ZdfjrvuugvZ2dlQFAU33HADdF3frb40hPquk9X2xRdfzB1549ndyQoLq43nn3/e9YEy3m1+T1ahrbb++te/Yvjw4a77xE+UNFdtZ4kEAJ599tkWLb8jaTkaE48ffPBBLFy4EH/729+S3rsay57GZKBp79t5eXlYsWIFFi9ejIULF2LhwoV45plnMGbMGMyfP7/e97sxZswYPPDAA3jrrbdwwQUX4MUXX8QZZ5yBzMzMOt/32Wef4ayzzsIJJ5yAxx9/HAUFBfB6vXjmmWd4FZjmoCGfia7rOOywwzBr1izXfTt27LhHfdidOLmn36WTTz4ZN910k+vrBx98sOPv3Y3JcvAtkUj2Om+++SbeeecdPPTQQ+jQoQNmz56NxYsXY+LEiVi4cGFLdw9A8hnl7t2744MPPsDgwYObdDCUnZ2Nyy67DJdddhmqqqpwwgknYOrUqXUOvuua9R49ejQmT56Ml156CaFQCF6vF+eff369/Xjttdfwpz/9CU8//bRje1lZGZcl1td2Y/vaEHJzc5Geng5N0zBs2LBGv7979+7QdR2rVq1Cv379ku4DGA9eu9OGG8nO23qo9Xq9TdaWRCKRNJbGxONly5bh73//OwYNGoR77rlnr/azrpgMNO19GwAv8XfmmWdC13VMmDABTzzxBG6//fakCrK64lyfPn3Qv39/LFiwAB06dMDGjRsxZ86cevvx+uuvIxAIYPHixfD7/Xy7W0nexsTZplg17969O3744QcMHTq00cezPreVK1cm/dyaK07W9V2qqqpq9pgsc74lEslepbKyEtdddx369++Pa6+9FoCRY3bXXXdh0aJFePXVV1u4hwZWDeWysjLH9lGjRkHTNNx1110J74nFYgn7N4SdO3c6/k5LS0OPHj0c8rJkfUzWXtu2bXHqqafihRdewIIFCzBixAjH4DkZqqomzBC/+uqrCXlVya5PXX1tzP5u/Ro5ciRef/11rFy5MuH1HTt21Pn+c845B4qiYPr06Qkr+Nb5Dh8+HBkZGbj33nsRjUYb3YYbVv3i+PPOy8vDSSedhCeeeMK1XvPutCWRSCSNoTHxuKysDKNHj0ZKSgpeeukleL3evdrXZDGkOe7b8TFZURSurKorLqempqK8vDzp65dccgn+97//Yfbs2cjJycGpp55ab19UVQVjzJECtn79erz11luu7e+tmAwYz0NbtmzBU089lfBaKBRCdXV10vceccQR6Nq1K2bPnp3QBysmN1ecTHadRo0ahaVLl2Lx4sUJr5WVlSEWi+1We/HIlW+JRLJXue2227B161a88cYbDnnQxIkTMX/+fNxwww0YMWIE0tPTW7CXwIABAwAA1113HYYPHw5VVTF69GiceOKJuOqqqzBjxgysWLECp5xyCrxeL1avXo1XX30VDz/8MP785z83qq1evXrhpJNOwoABA5CdnY1vv/0Wr732GpcC1tXHDz74ALNmzUJhYSG6du2KQYMG8dfHjBnD++I2WeDGGWecgenTp+Oyyy7Dsccei59++gkLFixIkB92794dWVlZmDdvHtLT05GamopBgwYlzYGyruff//53jB49Gl6vF2eeeSZ/AGgI9913Hz766CMMGjQI48aNQ69evVBaWorvvvsOH3zwAUpLS5O+t0ePHvj73/+Ou+66C8cffzzOPfdc+P1+fPPNNygsLMSMGTOQkZGBuXPn4pJLLsERRxyB0aNHIzc3Fxs3bsR///tfDB48uEHSfZFgMIhevXrhlVdewcEHH4zs7Gz06dMHffr0wWOPPYbjjjsOhx12GMaNG4du3bqhuLgYS5cuxebNm/HDDz80qi2JRCJpDI2Jx1dffTXWr1+P888/H1988QW++OIL12M2xEBsd+jXrx9UVcXMmTNRXl4Ov9+PIUOGIC8vr8nv21deeSVKS0sxZMgQdOjQARs2bMCcOXPQr18/HHrooUnfN2DAALzyyiuYPHkyBg4ciLS0NJx55pn89QsvvBA33XQT3nzzTVxzzTUNmsA4/fTTMWvWLIwYMQIXXnghtm/fjsceeww9evRw5F9b7df1TCDS2BjuxiWXXIJ///vfuPrqq/HRRx9h8ODB0DQNv/76K/79739j8eLFSX16FEXB3LlzceaZZ6Jfv3647LLLUFBQgF9//RU///wzHwA3R5wcMGAA5s6di7vvvhs9evRAXl4ehgwZgr/97W945513cMYZZ+DSSy/FgAEDUF1djZ9++gmvvfYa1q9f36BFjHpptD+6RCKR7CbffvstqapKkyZNcn3966+/JkVR6Lrrrkt4zSoj8c033zS4vWSlxh544IGEfRFXDioWi9G1115Lubm5xBhLKPP15JNP0oABAygYDFJ6ejoddthhdNNNN9HWrVv5PsnK6Z144omOMhd33303HXXUUZSVlUXBYJB69uxJ99xzj6NmuFupsV9//ZVOOOEECgaDBCChxEg4HKY2bdpQZmYmhUKhui4Vp7a2lv7yl79QQUEBBYNBGjx4MC1dujShz0RGibZevXqRx+NpUNmxu+66i9q3b0+KojjKzQCgiRMnJuzfuXPnhHMqLi6miRMnUseOHcnr9VK7du1o6NCh9OSTTzbo/P71r39R//79ye/3U5s2bejEE0+k999/37HPRx99RMOHD6fMzEwKBALUvXt3uvTSS+nbb7/l+yQry+T2OX355Zc0YMAA8vl8Cd+ztWvX0pgxY6hdu3bk9Xqpffv2dMYZZ9Brr73G99md775EIpHURWPjsVUSrL6fukhWaqwhcZKI6KmnnqJu3bqRqqoJZb6a8r792muv0SmnnEJ5eXnk8/moU6dOdNVVV9G2bdsc7cX3oaqqii688ELKysoiAK5lx0477TQCkLQGtxtPP/00HXTQQeT3+6lnz570zDPP7NYzQTzJYviJJ55IvXv3Ttg//pmKyCh7NnPmTOrduzePqwMGDKBp06ZReXl5vef2+eef08knn0zp6emUmppKhx9+uKPEKNGexUm3z6moqIhOP/10Sk9PJwCO71llZSVNmTKFevToQT6fj9q2bUvHHnssPfjgg/yZrK5nyYbQKgffjz76KHXu3Jn8fj8dddRRtGzZsiZv495776UjjzyS0tLSKDc3l84++2z69ddfHfuEQiGaMGECZWdnU2pqKp177rkNrj/cUGbMmEEAHMXdm7PdzZs300UXXUTZ2dkUCASoT58+ji+yrut0++23U7t27SgQCNDQoUMT6uHtDrFYjG677Tbq0qULBQIB6tatG02fPt1Rq68p2v7kk0/ojDPOoIKCAgJAb775puP1hrSxc+dOuvDCCyk9PZ0yMzPp8ssvp8rKyj1qOxKJ0E033UR9+vShlJQUKigooEsuuYS2bNnSJG1LDkyi0Sjl5ubS5Zdf3tJdkeznNHdcljF5/4zJRC0Xl2VMlrQE55xzDnXv3r2luyFpQVrd4Pvll18mn89H//rXv+jnn3+mcePGUVZWFhUXFzdpO8OHD6dnnnmGVq5cSStWrKDTTjuNOnXqRFVVVXyfq6++mjp27EhLliyhb7/9lo4++mg69thjm6wPX3/9NXXp0oUOP/xwR6BvrnZLS0upc+fOdOmll9KyZcvojz/+oMWLF9OaNWv4Pvfddx9lZmbSW2+9RT/88AOdddZZ1LVr1wavqiXjnnvuoZycHHr33Xdp3bp19Oqrr1JaWho9/PDDTdr2e++9R3//+9/pjTfecA3yDWljxIgR1LdvX/rqq6/os88+ox49etAFF1ywR22XlZXRsGHD6JVXXqFff/2Vli5dSkcddRQNGDDAcYzdbVtyYPLqq68SAPr4449buiuS/Zi9EZdlTN4/YzJRy8VlGZMle5utW7eS1+ulqVOntnRXJC1Iqxt8H3XUUQ55oqZpVFhYSDNmzGjWdrdv304A6JNPPiEi48bs9Xrp1Vdf5fv88ssvBICWLl26x+1VVlbSQQcdRO+//z6deOKJPNA3Z7s333wzHXfccUlf13Wd2rVr55BZlJWVkd/vp5deemmP2j799NMTVufOPfdcuuiii5qt7fhg25A2Vq1alSBrWbhwITHGEmbEG9O2G19//TUBoA0bNjRp25L9n6+++oqefPJJ6tixI/Xv37+luyPZz2mJuCxj8v4Xk4laLi7LmCxpTv744w96/vnn6cQTT6SUlBSHfF1y4NGq3M4jkQiWL1/usIBXFAXDhg3D0qVLm7Vty70wOzsbALB8+XJEo1FHX3r27IlOnTo1SV8mTpyI008/PcHuvjnbfeedd3DkkUfivPPOQ15eHvr37+9wMFy3bh2KioocbWdmZmLQoEF73Paxxx6LJUuW4PfffwcA/PDDD/j888+5E2Rztm3RkDaWLl2KrKwsh4HEsGHDoCgKli1b1iT9sCgvLwdjDFlZWXu9bUnrZu7cubjmmmuQl5eH5557rqW7I9mPaam4LGPy/h+TG9rO3oqNMiZLdpdPPvkEl1xyCdatW4f58+e71iOXHDi0KrfzkpISaJqG/Px8x/b8/Hz8+uuvzdauruu44YYbMHjwYPTp0wcAUFRUBJ/Px2/CYl+Kior2qL2XX34Z3333Hb755puE15qz3T/++ANz587F5MmTceutt+Kbb77BddddB5/Ph7Fjx/Lju13/PW37lltuQUVFBXr27AlVVaFpGu655x5cdNFFANCsbVs0pI2ioiLk5eU5Xvd4PMjOzm6yfgBAbW0tbr75ZlxwwQXIyMjYq21LWj/PPvssnn322ZbuhuQAoCXisozJB0ZMbmg7eyM2ypgs2RMuvfRSXHrppS3dDck+Qqta+W4pJk6ciJUrV+Lll19u9rY2bdqE66+/HgsWLEAgEGj29kR0XccRRxyBe++9F/3798f48eMxbtw4zJs3r9nb/ve//40FCxbgxRdfxHfffYf58+fjwQcfxPz585u97X2NaDSKUaNGgYgwd+7clu6ORCKR7FPImCxj8t5kb8TkTz/9FGeeeSYKCwvBGEuo4UxEuOOOO1BQUIBgMIhhw4Zh9erVjn1KS0tx0UUXISMjA1lZWbjiiitQVVXVLP2VSCS7T6safLdt2xaqqqK4uNixvbi4uNkkHJMmTcK7776Ljz76CB06dODb27Vrh0gkklCkfU/7snz5cmzfvh1HHHEEPB4PPB4PPvnkEzzyyCPweDzIz89vlnYBoKCgAL169XJsO/TQQ7Fx40YA4Mdvjuv/t7/9DbfccgtGjx6Nww47DJdccgluvPFGzJgxo9nbtmhIG+3atcP27dsdr8diMZSWljZJP6wgv2HDBrz//vt8hn1vtC2RSCSNZW/HZRmTD5yY3NB2mjM27q2YXF1djb59++Kxxx5zff3+++/HI488gnnz5mHZsmVITU3F8OHDUVtby/e56KKL8PPPP+P999/Hu+++i08//RTjx49vVD8kEknz06pk5z6fDwMGDMCSJUtwzjnnADBmhpcsWYJJkyY1aVtEhGuvvRZvvvkmPv7444Si8wMGDIDX68WSJUswcuRIAMBvv/2GjRs34phjjtntdocOHYqffvrJse2yyy5Dz549cfPNN6Njx47N0i4ADB48GL/99ptj2++//47OnTsDALp27Yp27dphyZIl6NevHwCgoqICy5YtwzXXXLNHbdfU1EBRnHNBqqpC1/Vmb9uiIW0cc8wxKCsrw/LlyzFgwAAAwIcffghd1zFo0KA9at8K8qtXr8ZHH32EnJwcx+vN2XZLoes6tm7divT0dDDGWro7Esk+CRGhsrIShYWFCffJlmZvxWUZkw0OpJjc0HaaKzbuzZh86qmn8nz6eIgIs2fPxm233Yazzz4bAPDcc88hPz8fb731FkaPHo1ffvkFixYtwjfffMNz0OfMmYPTTjsNDz74IAoLCxvUDxmTJZL62eOY3HJeb7vHyy+/TH6/n5599llatWoVjR8/nrKyspq8luc111xDmZmZ9PHHH9O2bdv4T01NDd/n6quvpk6dOtGHH35I3377LR1zzDF0zDHHNGk/iMjhrNqc7X799dfk8XjonnvuodWrV9OCBQsoJSWFXnjhBb7PfffdR1lZWfT222/Tjz/+SGeffXaTlDUZO3YstW/fnpc1eeONN6ht27Z00003NWnblZWV9P3339P3339PAGjWrFn0/fffc/fShrQxYsQI6t+/Py1btow+//xzOuiggxpUWqSutiORCJ111lnUoUMHWrFiheM7Fw6H97jtfZVNmzYRAPkjf+RPA342bdrU0v9lXdkbcVnG5P0zJhO1XFzeV2My4HReX7t2LQGg77//3rHfCSecQNdddx0RET399NOUlZXleD0ajZKqqvTGG28kbau2tpbKy8v5j+XgLn/kj/yp/2d3Y3KrWvkGgPPPPx87duzAHXfcgaKiIvTr1w+LFi1KMOPYU6y8npNOOsmx/ZlnnuGmCQ899BAURcHIkSMRDocxfPhwPP74403aDzeaq92BAwfizTffxJQpUzB9+nR07doVs2fP5gYrAHDTTTehuroa48ePR1lZGY477jgsWrRoj3Ph5syZg9tvvx0TJkzA9u3bUVhYiKuuugp33HFHk7b97bff4k9/+hP/e/LkyQCAsWPH4tlnn21QGwsWLMCkSZMwdOhQ/jk88sgje9T21KlT8c477wAAn923+Oijj/j3cHfbjufTTz/FAw88gOXLl2Pbtm148803+aoVABAR7rzzTjz11FMoKyvD4MGDMXfuXBx00EF8n9LSUlx77bX4z3/+w/vy8MMPIy0trcH9SE9PB2DkVYpyPolEYlNRUYGOHTvy/y/7GnsjLsuYvH/GZKDl4vK+FJProjlN52bMmIFp06YlbJcxWSJJzp7GZGbOskkkkgOIhQsX4osvvsCAAQNw7rnnJgy+Z86ciRkzZmD+/Pno2rUrbr/9dvz0009YtWoVf+A59dRTsW3bNjzxxBOIRqO47LLLMHDgQLz44osN7kdFRQUyMzNRXl4uA71EkgT5/0QiOXBgjDli8pdffonBgwdj69atKCgo4PuNGjUKjDG88soruPfeezF//vyENIW8vDxMmzYtaSpAOBxGOBzmf1uDCnmvkUiSs6cxudWtfEskkj1nX8kvk0gkEolEkhzRdE4cfBcXF/NV+d01f/P7/fD7/U3faYlEkpR9y7lFIpG0OOvWrUNRURGGDRvGt2VmZmLQoEFYunQpAGDp0qXIysriA28AGDZsGBRFwbJly5IeOxwOo6KiwvEjkUgkEonEHdF0zsIynbNM/UTzN4vWbsgqkeyvyJVviUTioCXyyyQSiUQiOVCpqqrCmjVr+N/r1q3DihUrkJ2djU6dOuGGG27A3XffjYMOOoinghUWFnJp+qGHHooRI0bwOvDRaBSTJk3C6NGjpRJNItnHkCvfEolkrzFlyhSUl5fzn02bNrV0lyQSiUQiaVG+/fZb9O/fH/379wdgmL/179+fG9zddNNNuPbaazF+/HgMHDgQVVVVrqZzPXv2xNChQ3HaaafhuOOOw5NPPtki5yORSJIjV74lEokDmV8mkUgkEsne46STTkJd/seMMUyfPh3Tp09Puk92dnajDE8lEknLIFe+JRKJA5lfJpFIJBKJRCKRND1y5VsiOQCR+WWS+thaFkKq34PMoLeluyKRSCQSicSFNdsrUVQeRpe2KejQJqWluyNpAK125TscDmPq1KmO+oT7c7sHatsH4jnvjbZlfpmkLspDUQz5x8cY/eRXLd0VSSthf75f7mvtHqhtH4jnLJHUxcot5Rg261Nc/PQyDHnwE5RWR1q6S5IGwKiuJJNm5rHHHsMDDzyAoqIi9O3bF3PmzMFRRx3VoPfuaYHz3aWl2j1Q2z4Qz7ml296bHCjn2dpYs70Kw2Z9gjS/ByunDW/p7hzw7K3/J60xJrdk2wfiObdk2wfiOe9tDpTz3F/474/bMPHF7/jfC68/HocWyM+tudnT/ycttvL9yiuvYPLkybjzzjvx3XffoW/fvhg+fHiCiZNEIpFI9i66OSer6S02NyvZy8iYLJFIJK2LmK47/tZbbj1V0ghabPA9a9YsjBs3Dpdddhl69eqFefPmISUlBf/6179aqksSiUQigT3oloPvAwcZkyUSiaR1ER+j48bikn2UFjFci0QiWL58OaZMmcK3KYqCYcOGYenSpQn7h8NhR56NruvYsGEDAGPpf29itbe32z1Q2z4Qz7mp2iYiVFZWorCwEIrSau0dJC0AH3zLWfQDgtYck8U2ZXzav9tu7ecsY7KkqYlpzhgtY3broEUG3yUlJdA0Dfn5+Y7t+fn5+PXXXxP2nzFjBqZNm+Z6rI4dOzZLH+ujpdo9UNs+EM+5qdretGkTOnTo0AS9kRwoSNn5gcX+EJNbsu0D8Zxbsu3Wfs4yJkuailj8yrccfLcKWkWpsSlTpmDy5Mn87/LycnTq1AnH4XT4UjOgpKUBAPTycuhh2+mPeYwSOcyrgjRTi6FpIOvLSjrAnLOPStAPMo9BmuY4lpJqOD1r5ZX8fUrQD3Q1b6I6gA2bjV9rQvZBzX2Z1wO1bbZx7LQUkLVvOALF7zP29XqhpBilAmKdcsHMviqbdhhtl5Qa/QbAVBXMZ5wjRTW+3Tg14RxFrH77jI9eyckGVVYZu8ZiQI/Oxm7rt0Crqkm4TszrAYTrorbNMfq1qwwUSXRZVLMyjXOsqrH77VGFHVTAvFmQpvPXlDZZ0Et3GdsjUX5OSmrQOEa7PNCWbY7XHedt9tWtT/wzF85L8XmsboCiMbuvPh/vE4UjRn8BqLk5vF2tpJQfT003vossKwPk9xubt2yzv3+A/Vl7PGA+43e9uhp6VbWjm0paKhTz+xLbsIX3SUkJgpn90ITrCqZACZjHq40gpofxOf6L9PT0xGsgkdSBOOjWdYKisBbsjWRfo66YHMgvRGzHTuMFXQMz74OMAXptEqdoReX7NxTm9YGZcUwPhZO+l3nMWJdixA6tsorHHABQAuZ9OqbZMT/uAVbNSHd9r1uflAwjBmg7S+NeZGZ/vPye7YhX1v8xpvBnDb17B7DfNxq/V1bZ10l8dhFjPBE/T6iqHVPMPjOvDxSLup6j1T+rD0ajcdfUbN+KPxSLul8PxnhsY8y4ttb5Mq/5efh9QEGesU+58QwSKyp27xORo+36PnfrO6fmt0Vs01b7GOLxXPrqeD5sxHcREL5HGrleYzUjHTGV8MmuBTImS5oMLT7nW06YtwpaZPDdtm1bqKqK4mLnjba4uBjt2rVL2N/v98Nv3kxFPMwLry8FerkxSFR1j/2QSDqgmwEkTFDMEknUtzvYz2sBmA8CwsAFAFiUgaz3iQNzXQGrNm6oiifAB2GIaKBfNtr7WQMkZtfGtSYBlNRU6DsrjY1Fu6CoxuVXPQpg3ec1DQgbAdNfqwHm4JplZBn71kSNQTIAxhiY6bLHUoI82UPfsZMPOkmnxAE4AKYbbbPSKrDu5oA7FIa+3jTXiQLMPAemMrCgOegNBEDVRv9I04Ay43eProCYSz3gilrjddUL5jevQ3oaqNbYrodqwayHkhQ/YD4ooToChZkB0RysUjQGWOPs9duEyZEk8q0oAVafmMIfbuwHHmHwrfp5YCY9bB87xsDI/E55AlAsV8NaDbr5wMBgfheYCpjfEdUXA2rNdrwp0HXjoZMiESBqPoCyKJSgObkCD8hrTLpYbbMogC3GQ6yHecFUox+KPw0sy+iHEtpi95UpxnsAKFCNcyfw6yuRNBRx9lwjggL5HdqfacqY7FF8zvuuFUcYg86SJCQyle/fUBjz8mPrLHEi3d7PHOwxH38fIAy+ze3EYiB+jLjBd5L3uvVJUcR9HS8K283BNxMG30wYfJvt6WoAzPqdee3rBPF8xWtKdtxkKnQW4duttonBsS2+f1YfHP/y7eYA2PzXOFaSwbfwuROL8fN1fB6qOTGjmP1Mcs2MQGa3Xd/nbr2uKn7hmOQ8nktfwRT7M2nEd5GfDwBiuus1VpkPUKzPQd5PJU1D4sp3C3VE0ihaJOnE5/NhwIABWLJkCd+m6zqWLFmCY445piW6JJFIJBITQaghpecHADImSyQSSesjIedbxutWQYvJzidPnoyxY8fiyCOPxFFHHYXZs2ejuroal112WaOOo1eHnPJwU9IULy+3VoLZT6vrPmAyORfgnAk12xTbdtuXKQxKWqqxbzjskEGT+VbF57VlyaTzc6BIxJYtmRJsFvADEePYFAqBysqNY2gaWKqxcsr8fne5tXiapiyKNAVqkSFph9cLMmWBFCct16sNdQFVVjr66rgm8deNKfxcmKpyqZpeXeNsx1yRZvAD5qq+Hqq15e2qJTdT+Ko/xd9ghOudTHKf8B7xNU0zVtZd3sfVDOmZoEpDuUCxmPvxLDlhbdj4rGCYrLg3qhvnCUOyxr+71jGs/lhYUr9IBNi5K+GcmJQGS5oIMYDLYH5g0CQxmciQR1swxu9jRLotQff5oFdV8fc4JL7WCrElBQb4cg4L+Pn7KBrhcUxJSRFScarte7bfz1Vb8RLseFgwCBY1jqfX1tqrpEwBLKl0MAg9FEp6HIpGbLk5Y459rP6xgB/MVOLpFRX29eH/zzTo1WYbP/4OXYgD9j1edSiexOtn9Y/5fAl9VFKD0EOmwisclwIgSNOtWKSHQs5jmO1waX2FZj/IxGMpuNq0gV5SwtugiPHZaNEY2JoNjrdYKQIAoLbLB2WaKYW/rRVivwaKJnm+sdRr5vNPbNNWu/+McRWimtMG5cd1MTZrQNrin4x2xGvCGDyFBQCA8qONPO/0RSsd103srxXv9fIKR5vWswlFItBrkqRdSCS7icz5bp202OD7/PPPx44dO3DHHXegqKgI/fr1w6JFixIMX+qEKVCCASPYxr/k9wNWLjDZAzKKRHkAY6qaGDeYAuY1A5ym2YO6hIBpS5NEOTMTBoqAEQC1srJ6T8UaoDO//cBB4YgtOw+asvmycnvgqhOgm4PVsnIwM1edCTd8kJ0P7Qrp0HaVC9dD49utY2glO+3d4yYbmMdsR1V5X/g1EwbcAPhAk7T4/HQzONWGAcsBVBPy76yJjvi+CwN/K9/Kuk6AEQQd5xP/PuH9jsmKJHIz3ZzoMA4nytYS96dIFEqbLPONxD8zx/5in3QdzPwOKFZ+4c5dtgRdYTzQUyQKIuN4zOvhD6ZqThto5qDczmOQSBpPvOxcsv/TJDFZIpFIJHuNhJxvGa9bBS1quDZp0iRMmjSpJbsgkUgkkjjiDdckBwYyJkskEknrIX7lWyrVWgetwu28LhLk1dZKp8fDV5/1SNxKK18UdLqZA+YKt7X6nNMGerq5kvrLOsfKJ18993hsuVGo1l75NlesrdXeBJjC+6RHonbyvSI4b/q8/HcqN+XOtWHX1VzSADLleExVbUO4RhC/Is1XrUl3l9czhZ8n8/mglTvrXzJVcUilk0r0hevQUOm04XhqGtv4vLY03euFVtAWAKCss+V7FIvWbaAifB5uLvh2VxMl7arpXEqaZkvSSIe+q8zsk4dL611l+oDh9G4pNTwu/y1V1XZ9Fz4nBnApJ4UjdjsSyR4grnbHB3eJpC70mhqnVNkKuIIEnakqPPmG03WkRwFUy6hy+y5+3+SxnSm2kqwgD8pGUxoeDvN29OpqrgwyUo/M2F9bC9S6xGDB8IpLjcNhW7UVl7pFZtoVCwah+pymYFQbhm7du3WNx02lS0fE8gxjTM+q9dDM5weqrATM9KVkkJvTtuDKreS1RdlRhQCArC82IratmLfPq4c41FzG+eqhWvuZQkxrE9uORaFkGjGNiZJ3VeEpVCzVUGmpOkFzq3tNxOO9Hv86LyuicTUbj/uqymNobMtWYEvce+KJk/YnOrjDdoiHnW4X216CtP+UGRt1gu4mYydCbKtRUSX1DeNfxxojU3iaHPN4eHxmPp997Yn491+v1UD1KRElkkYSn/MtF75bB6178E26HfTMv7lTuZi74+L2nQzm84KZ5aKqe7RByleGM7oWqnXmMlsDU1W1JcU6gWAFHHsQ5mzAZVBHOn8AYLEYLzWGYACxgjZGM7+aAUyx2ybN/dxIJ6hpZlk0oWyWmIPN87F8Pv7QoodqQTGhbJUZgJGVAd0s10HRmHPiwZRK1xzRGSlLfzcOXWFMAuiRKJiYHy6cb7LrkbREmtUnM69d69MNyndG/VmqFnKjSQezJkkCfse5Jzsm4My7d3gIKKKEXxdKrNjHcsjphffxHLVYzM5ZFHPSAYcs30qfUKzArTAoPnPyR9NA5CKhF46hV9ol8JjHC0aw3eElkkagy5VviUQikUj2aeTKd+ukRdzOJRKJRLLvIsZvmfMtkUgkEsm+R3zOt4zXrYPWvfINOCTComEYacKqYh2rntYqLpdZeTzQM4zV1dTvNtlS6riVWy5dD+tO8y0NifsL7SmmIVgyOTppmiHbA4BwGIrpHKuLq6qmBA8Kc3XoZgpzPb4S8IO1N2q26us28vagJ65EM4XZhnUlpfa1FOqGUywGmKu1KV+vtR1a+cnY16kuObm4+ssNxjzexGuoqjwlwPPLemNV3w1rxbkqZp+P1/1a8XZjztVzu02fbfimE9yMzERTNMf3j5+g4jRO8woOqZY7q9C+9buSlgqWlmaeSxX0isRlbNLJYTioBEzppc8LFiG58i3ZLaTbuWS3UFQofQ8FrTRUUM77qiDBranhcU4pKga8xn1dI935HuutmhEj1KIdUAoMAzgW8AE7DGdxrWSn832W1FiQJVuKMr027HRXt96SksLl1MxjK9q0Xbugh82YIEjTLZjXYxt+pgRBNUYc1NasA1tj7JPQmljT25Kxe41/HallYj+JjL4DUMIRZCz82Th2KMTbB2NglnIuFuPXmDuqCxVX1O5dANNsVa+oslOZBLNah6s4ebhkXdtuuZfrUMy0K8YYkG+kfGFXOU/TS3BVt9zshRjPU8iCATuux31GivnZUM8uULcY7ce2l4B5BJNbS5kWFqqpiIMR67rrGveiZXWl6Imu5eLfANTMNKDASJ3AlmK7col4DqKjr6JC8SpAkkxEiWR3iF/5TlpdR7JP0foH38LAOlnFC0M6bOYmq0LgVBR74GnJo9MDULYbjtHajhJnOQ8X6TRpcJWS87xt0bWbdHtgzRTH+xwBwGpH03iZEStAk6aDlMT3OEuYaXEyZzP/LRQC1qyz2wfAoDlcxLlzu6bxQZ04cE7I27aCXDicUHpL7B/zeOxBcdwheD5fejpgBnvjAcT5OhFBt3LfY+6jSit3n/fVjLBMVR2DXsB8IEn23RHKg8RvS/jdOl78TVAoHePso1m2pm029BKzLI3w4KhkGnmCiMagmyXmjPw8nZ+LW94/U1X7vURATEZ5ye4hOqbqLvOIEolEIpFIWpb4yXFNxutWgZSdSyQSicSBGNBjcvQtkUgkEsk+RzTOcE2WGmsdtPqVb3FlN15OLK5aKz7TWKttji0jrg07TbEAUEmpXUc7wXjLXH2OX3UVDc0sGbsl/SKdG5DF95s7dPt8YO1yjd03bTXc2eNwSOqs82W67VwqGqs5roVqr5oT2dJrZ2eEdtylzW77JnNB56ZkOvHVZtL0hJVhfhjrZlGQAxYyV5o3bRXk7brdjwaY51nu8wiF7BriOoGZC/GW9J88Mf5d0CNRpzmba0eTu6Dz1936I9Ti5n8D0HIzwUrLeP8sdCvVQVXjJO9mM8lc4wHoFYYyQMlIN76DdZvqSiSuOFa+ZTCXNBRdA9uyA7DiUixmy4XDYUccY6bUnKmK4UqeDMb4vVWrqAAE92zrGGpWpq3mysoAmY7pRuw1q2lYqjPrmBaWY3pNDSDuIyL8H1D8poouGDTaKCuzXcDrquphSuHVnGw7toVq7WePKvs5gSu4vB6nbNt6XyRiV3PRCST225Q/q5kZUDIMJZRWUpJwLtra9XY7YuWUSBRk5ispKSm2dD0Wc00JgKkOY8EAyEwLUzLSAcv4VFHtKjDCZy1K2nlaViQC1TRxZelpIDPtjjTNUCoCwMo1iFkGtR6PU71W371KlJGbsnYCoB/XDwDgW7/DcFk397W+X9Yzg1ZZaV+/snL7HM3zNP4VUss0p2EryWVJSRMj63y3Tlr94NsY8FqDM/eBkZGLawbgkp08t4qpiu1ULjp4WzJnTZC068TbSTYAE6XNulVKRMjzhqY5Hz6skiSpKaDiErgSL4tmCriMmXSeV2yco/shWIcCo51wFGRKybmcWtPswW/8Q4OLSzpjzN5fzP8W3uv4Pb4UnNUnUWZvBd5NxfZgk8gRtOrDeoggTeMPA87vhj3xoJtJV2p2G1CGkVOtbNjMnfMdcv5YXNt1OKbHw/MA09Ps/LdozJ6M+e4XMNO9XTw2/xzFyYr4EnBCCTd7FwJZuf5EiIUSJ30kkobgzPluwY5IJBKJRCJxRbqdt06k7FwikUgkDqThmkQikUgk+zbx8VmG69ZBq1/5ZqoCInP9V4s43LotYysiEuTFGpi1+uzx2DJrwTGdmaZVrLTM1a07oVazJTXPzrJXOHm96qgtQVLi5jqs1cvMdJD5Pj0StU3PGvC/yFqFVnKy7bYjwnXweBAtyAIAeH/ZyFfe7Vrhmqu0WYQpDGp2G6tB6NWmxE3XuSSOqar7+11Wipmq2p+NZkvXtbIyx+fA9/ebK8gQXOKT1Qonna9wO6T9KmzHV3O1mGIa9DTj2EpqChgZqgC1IB960Xazf0mc8sV23c7R5zOkdwDg9UIxa8frZeUOZQC/lm7Ey9yt3+O3We0L++u14QYpBiQSN6TsXLLb6Jph7gkAjIEsRZHHw+/7LBh0yJm5ZJd0W8VkxWY3t2pzuyVd1spsBZASDoOZ91vFF+aKJjuYM3ja5fP9tR0l5suC8stxX417uLVk4ELss9LMSNOcEnCh3zzdaMeOhNfi23G4jItYkudd5Un7Z8mptfIKnnKmtjVcyPWKCvvpXJSax2K2xDo1yOOmtrPUva+ilNq8Dlo4zGXY5PFANa8xpQa5shAAlHWbjL7U1sLhfA44qr0oXg9/H9U4UxYsh3Xq2QXq9jLj9/KKhCovzOPlaWh6VZV9rYRrxrweqF+tBGCsIop9sb6DWpVxTZW0NChZmcbxdpYK33OFP7PoVdX8mQWHdgfbXGwco2QniGT5EUnTEovP+Zaj71ZB6x58M8XIQxIdyYXXrJskGEOs2Ax4QvkrR7A1A5EeCgGmFF3NSLNLPYVCXNKbOLAxB7KV7jJfa7DHPB7noD1q3oh37nKUB3DsI+Z0u10Cy1U9Li9bnCzw/mKUFdMrq/h+1t6GI3iSUmPCNp4H3z7fLpe2vcQRhBNKpoRCdp68mD/v8yXPi+MPFAxq2xwAQKyTUc5D3VDMJ04oGnNI4XW3vDhdgRL02fvwhw4zoFdWgv1iDLh1TbMH56VlfKKEqWqi9Ny8Jtb5cum4TvZkREqQ99uzowLMymMLR0DWgJt03lfm87lL9AWHc+uz1mvDQMxOCRD7xMT0iZguS41JdgtRah4va5NIJBKJRNLyxBuiysny1oGUnUskEonEgSYEcCk7l0gkEolk3yOh1JgcfLcKWvfKt4s7NV+xVRiX9DK/T6hfLbw/vnZ3/HE9HsQKswEA6totSQveWivVDLDl1MJKNV/JFpeTSOer3VRe6V63mil2vW5RJm6thnr8UHIMObi2pch2DFVsh00iAlm1sePd21GHURtTbBM6xrjkSymvAllmcuLqtWACZtWa1qNRbnSnZmeBWSviMQ16vJzNalZwStdNJYGnJGi+yMAs2ZvgBF6XzMZaTVYK8qFYzuKWM62q2DI14bo6pGvCtRT7x7wefr6ctm3ABGd7z5adRnviqnzCCSu8fcV0z9UtE8C47yazjPssqZu1j5vhm6KAqUyufEt2C/H/lJxJlzQYRUXpqQcje/FaAE6XbdJ0W05dW8tjpRGH675RWZJopzQczntkfa7lin3v1k3jUSUtlccrikSdRqQx2xnb06WT8buuI7Zhk+OwpJMtoU8Wi4TUN37eAKCq9rOCEIhV06WcOhWCbSm2z8tCJ67IYh4PlC4dAQDR9lnwLPvF2KW2FnqtcUxPriE7V305oJSAfZwdRozSyqP8GYSiXjvtS1H5NVbS0sACxnstU1pt5y5XiTzFYohtLbIuUKI0XrwuEGT2jPHr7pC8M8Zd8/VQrW1o+81PcGgC4yT8zOvjqj2Hkaqm2W2LaXqqaj/3kN0X67PRq6oEM13ns4GYwkjVxvcLK1a5n7dE0kTEK9Ok7Lx1IFe+JRKJROJAGq5JJBKJRNIyxDQdEbeUx4T9pOFaa6R1r3yb8BzkUK2wCq0ZBhsAWEgwAxNydaGq3AzGWVLMMnDT4dlk5IprFVV8HzUjjc+cO3Kmdd2oIw6AeY229apq3nZCnnM9Rmdiv9z+plhMMAbTIOY6W+XIGLFEIxkAShtjxZylBBDbZNW11B3KAd6OpoOZS6ja9h32ireqcjMT5vHw1XGtOM5QBgDVhEB6NT+ea565z2fPTkci9gq0eTzm9QjmOUkM1xyN2uZr+o6dUHKNz0ZvY5i1sNoIlCJjZUazamvDnMG2+kQMipXTrWlgKebqdGUVL2nGZ9ZDtVwdIebwO0qy6cS/f2JtcdLMHPkkkKbZZcSSnbPgZ8B0PdHgTyJpIA7DNRnNJRKJRCLZK3z4azEmLPgOtVEdpx9egMcuPCLpvlbON2OmwEbG61ZBqx98i4MS5vXYplnxdaetQWcwYJtpeTxQTBdvvXSXsXMkyt9LoZAtJxMHsDrZRmjCgIliMZBlolafpI4p9bqZO2phixJ7oba2w2zOxX2b9LjtlrS6whhssupqwV1d2FcYMBptWf8K0nVoXIaG7Exga3HiSVh9jUTqkOQlzu45HMHNz4B5vHWnCdRxbAqHeY1zlmY603pVKJYRWk2NLTkUr7Gu2DJvpgA1wufNz0dL6HNd/eMO9T6vYzJBlNy7vU+Pl5ubfXJLqdAjUejSWVWym4gBXBquSRqMriHzha/Ab0WKLeONN5TkaVIexXnvs6qHmGk4FInY9zshzUaM92bjwsETv7PcIDMtFRQ2+hIr3sHdwZOhBIPYflIhACD3P7+7njO/VSsqFNPpWg+HHf3glUY8HsEoVQfxe7kgmbb6Go2hevBBAAD/rgiUr1eZx4ry68O6dACKjUlkdf0miGduyfVjW7aZx46TgJtSfE+H9jydTK8OQbdk0wLi56dV2elVao+uAIDtf2qHvNd+NY5RU1N3ulUy4p3tzc9aPagrsN2QyCNkpyyIDugOJ3zxkIKk3a4C4xW2Kw7zVp5Opqp2pRXzdb2qOu5Z0PwO+/2oHXI4ACD1tx2IrduQcD7M4wFTFGA3LovkwOKLNTtRGzXuCx/+sr3Ofa1Y7VMVhGO6TBNrJcilMYlEIpE4cBiuyWAukUgkEsleISb4Q9UXf2PC4BuQHi2thVa/8g3AsbpqzToDcJafEne3ZnCjUT5zasnPRfk2X5U04SZlGen2aqhYdkxVee1PXtJLNFKLlwonKfFlzeoqhe1AlaZU21r9VRS7NrTDbMZ99ZcJ0nC9usZxrQCAhPqUik+xr4cgv2fBoGBEY7dFGmzztZoa5yw0ABbwc0l2Ql/dVukjEVAyCTmQaEonXDPXVWfRDEUnXgcdppEb83igiTJ2x/HsvtoryrbSgMWbrbl2OIlBn6XOEI5DGmzDOrM8mvh5MY/XPsckx/W0y4dWYpjUUCyadD+JpD4chmty5VsikUgkkr1CRMjjrk9GbuV8+zyGqkKTj32tgv1j8G0hulKnpQJu+cFEzsGPZku4E/e1f2eqyo/PXTzj2qVoDDpqkYDYL699yW2XU1tyrOa0AWUb9cmpuMQevFrvZ8zduT1Zmwrj0moKhRLfQzqsOuXwegFxAG05e4tSLJ0cx+ADbk23z405B/h2fxLrqgPuTu71nlcDYKrK/QAoFnM42QLG589z24U8edLJdXJA/Js0CHJ902dAzJNPcsNkquA/4BjYC5g5PIrPyyeQ6pzEMf/Wq6odufoSye4iBnCZQyZpNKYEWAn4HVUhrMlx0jTbvZt0vo+ansLlyg53b0tSzBTjmABYaiq0HYn+IszjQex4QwLsW74GmiWnrjVjc61LjI7vd0oKn5DXQyHkvv6z8XtjpNTxEmprcyzmmKi2pM1WnEY0xieKaWcpAr+tsd8rHJ5fn1VOKbyaY1Rooeoau7KHFeOJOeIP978BeKpcsvQpikRsKblwPtqadQCAnDXrQOmmn4rH49zXuhaKCtU6T4U5q43wE7C/L9ZChPb7WvvlrCx+bNG1nKkql/NbKVoUjTjl6Dx9gXHJvfV9Mt6oOyX35nvZgN4AgPKD09Dmf6uNXcvK7RTFSASBD34AAMSEWM08HudzlJ7oDC+RxONY+dYJRGRX+onfVxcG35Ar360FKTuXSCQSiQNR6iaDuUQikbQ8mqbh9ttvR9euXREMBtG9e3fcddddDoNXIsIdd9yBgoICBINBDBs2DKtXr27BXksaSzRu+bquCXDNXKzhg285Wd4qaPLB94wZMzBw4ECkp6cjLy8P55xzDn777TfHPrW1tZg4cSJycnKQlpaGkSNHorjYxayrAfAVaWv12ZxVZqkpUDMzoGZmGC7airFirFsycfOHYtHkq4rWcU1zNIfBmXAMx/EiEeMnGjNWtuNqRCsZGcZPVqYxU2v133y/XlYObC4CNheBQrX8fPRQLfRQLTTTPb1eszbzfBljgN8H+H1Q2xdACQa5UYuFdQ30qirHsa1zoEgELBgwfgJ+MK/H+LFqYDPFqPtp1vomTTcczc3rRZoG5vNCCfids8xx11tJSXEax7l8Dq7XXdxH+J00DQgGgGDAMNazapGbr6ttc6DmtoWa2zbxeMm+D/yi6fa5mZ+j2jaH/yg+r6Pf1nfRqikrHoe7zGuacc0iUVAkmpD2IL5H8Xmh+Lxcck+a4e7v9r2TSBqLLg3X9hv2dkyWSCTNw8yZMzF37lw8+uij+OWXXzBz5kzcf//9mDNnDt/n/vvvxyOPPIJ58+Zh2bJlSE1NxfDhw1Fbl+JDsk8RjSsfVlfed2LOd/P1S9J0NLns/JNPPsHEiRMxcOBAxGIx3HrrrTjllFOwatUqpKYacqMbb7wR//3vf/Hqq68iMzMTkyZNwrnnnosvvvii0e2Jg1CmqnxwrG0thpJqDDKVYMCWN+mxhGMATglxguu03VhjOpa4SQNIlDRZOdUOKRjZEi1dd0jTXTrNpd4UjTkHolabsRj07SXmdsYlzczjNV+P1jtQ0yNRIFJuHtqWoFuSMABgPp/tDC9eN0umHYtxSZiYv2wMXM1c64AfiulEz/PaAec5uiCW74KicMkZU1XA/Nz1mpAtbbPO1+sBpZhu7cWCLF7MSYdwreLleIK0n5+jWZaMpabwaybuy3w+uzSeIKt0XrP6XcrrGpjz9pji1ClKJA3EYbgmo3mrZm/HZObx2PdGXQfr3B4AUNY/B22Wm7Fo8za+P8ViPN1Jc5N1C3JLxeflE5gUCnHJtto2B2RWscDOXfAtX2Mf262Ppgu4EgxAq6hIfD0lBSxoer+UVzr2UcxrZsVpPRQSYrYGvdaKM8zxLGHd9x390omnQ2k7XWTawvmLzzdubu4Wmlm5hfl8Ca7gFHZeD0uKr2/aHHcBjDbVvFxeJUSUY6vmZ6B37QB1m/GZxoqKXctlMlWFYkrhS0Z0R9v/GjJ5qqq2r4n5ebCAn/vIaOUVro7pWlmZ7bnCFEBU41ppAzy9QYfaLg8AEOmSC2+RGZNLy/h1csR1TXN83/jn9+1KAEDGt47kOQfcPV3cpmm2+32oFrSHsvMvv/wSZ599Nk4//XQAQJcuXfDSSy/h66+/NtojwuzZs3Hbbbfh7LPPBgA899xzyM/Px1tvvYXRo0fvUfuSvUNjVr4dOd+QBqmthSZfHlu0aBEuvfRS9O7dG3379sWzzz6LjRs3Yvny5QCA8vJyPP3005g1axaGDBmCAQMG4JlnnsGXX36Jr776qqm7I5FIdgMpbzuwcRiuyWDeqpExWSLZPzj22GOxZMkS/P67MYHxww8/4PPPP8epp54KAFi3bh2KioowbNgw/p7MzEwMGjQIS5cudT1mOBxGRUWF40fSssQPvutSn2nxOd9ysrxV0OyGa+XlxkxjdrYx87l8+XJEo1HHzaFnz57o1KkTli5diqOPPjrhGOFwGGFhBtRxc4hzzuamXzoZBlSAw7k7Hmtmk5ueqCofYFDc6qu1ry6YoHHpNZIYlcQZuOlizegkKFmG4ZpeuguguJnfePM2awVZYUZNarMdhymaaNpGzpVvJS3NXsEm3TZdCdXapiZCzW/SAGb1QWX2tQqHXVeGuZN6ViaYteKblQb2+3rzeJq9ChCqtetqKoIaIFn9bKt2e2oKX9EHkSFfh7kab30HRDM3Zva5vBIspiUcLxni9XZgyfRrQnYt8dQUh5pCKze+s0okwL+jSloadKteqqPOt4vZW1zfRDWAWKfd+l3JzIBeVQY3/7+GYMnb5s+fj969e+Pbb7/FZZddhszMTFx33XUAbHnb/Pnz0bVrV9x+++0YPnw4Vq1ahUAgUE8Lkn0Z3bHy3YIdkTQ5zR6TJRJJs3DLLbegoqICPXv2hKqq0DQN99xzDy666CIAQFGRYQacn5/veF9+fj5/LZ4ZM2Zg2rRpzdtxSaNIkJ1rdax8m8++XllqrFXRrINvXddxww03YPDgwejTpw8A4+bg8/mQlZXl2HePbg7WwFBXoHjMgQhp9btKw5ZOW5JoCoUcq3txJ2TsG1dmSslIM16uqEqQhyd1JI8bWDmcsi05spKY/yy2nUyGHZ+bXJdcXslpg12DCgEAmb+UgW3babft1lcIkwwKq1sWD/u6QhicK4yBUsy885oQdMt9vjYMFrVLnYmfqxuWayp1KgTWrDd+J4Kal2v8HgrV6WKvV1aCWZMhCgMjIfXA+jxEaX8kwr9TSjDA3XDF8m38dQhOvULbeqgWCpkTDJ64/378c0v80jCvB2qbLABArHg7lyoyn4+7YJIgRderqkGxZF+++pHytgMbccAtZ9L3H/ZGTCZNsyc4NQ341ZCAZ/y6xnln4/c7ZzWSeNT0dD5Bq4dC0LcJfTLvfbEtW2336mDAjl+67i7RtiYs418z/9Z27IDosM6b83igpBvxPtSnAwAg8NMm6DtL7fMV1UHW/x3ddndXUlKgts0x+r11W2L/xL8V1RE/+GR2erq9XVXBzMlObXsJlz9TOJyYalUXltS8R1fsPMYYvOUsXON0/zbRrLKd35cjpggLGJb7tzBJTbEYtO2GK32b53Y4ZbG7k4dMxL8PzOMBEzxseEUT3f7+xTZvAQAomzZDt2Ku5bdjYn0eFIuBaoxnAr2qyj1tQUgDsBYLoCjCRLqYMqDwUq+KphnPN0ke2xrCv//9byxYsAAvvvgievfujRUrVuCGG25AYWEhxo4du1vHnDJlCiZPnsz/rqioQMeOHXe/k5I9ZndWvv1Sdt6qaFZXpokTJ2LlypV4+eWX9+g4U6ZMQXl5Of/ZtGlTE/VQIpG40RzyNkBK3FoL4uy5NFzbf5AxWSJpvfztb3/DLbfcgtGjR+Owww7DJZdcghtvvBEzZswAALRr1w4AEswSi4uL+Wvx+P1+ZGRkOH4kLUv84Luu1WxrldwyXJNj79ZBs618T5o0Ce+++y4+/fRTdOjQgW9v164dIpEIysrKHDPt9d0c/H6/62siTGF2HU5hxdJy3XZ5g+HKDUA3ZcEJs8zW7Kim2StAcau82q5y1/0BU96dbOXZkryrqmPGlsvdhdlZxwpuffJocXU85u7ezVdzPSoy/jCl0hu3cYk6xWJJ631ytCSSbV5LU+cSfWa6ggOGpJ2viOu6Q57tcJ6PPy+FOZQEmiXx/nWNI/UgtmWby7sTIc1WRzg+Oz0m1O7W+WcjXg89VJuggBBX6/VI1JaXezy24Y1OdtoCOc1p6rreFIkgZhnnGR0z/o37XvLro2mgOgvB101zyNsAKXFrLYgGL3Imff+gJWKyRCJpOmpqargprYWqqtBNVWbXrl3Rrl07LFmyBP369QNgrGQvW7YM11xzzd7urmQ3iZedNybnWxqktg6afPBNRLj22mvx5ptv4uOPP0bXrl0drw8YMABerxdLlizByJEjAQC//fYbNm7ciGOOOabxDYrO3uLgRRjwqrltoZWYsrD4wZ0wUHQ9vDj4TeY4bkmU3fLKSbfzmAN+UMiWWSmmjBi6zvsHiE7WiQNRY4AX5W072rEG8z4vl91RdZJ+WznSJaXApq3GJlEqJvyu+P12nwQZuzi2EycZHDnLVts6AR7rOin2gLYBD/aWkzkR2XUU4vvBEh3WHVhlyuLhbuz2pEYyf4CkWNedkT3ZQTqXgyuF7aBvNQaklMylXMiPJ1EqaOXoq6rrRIHD5b4JaQ55GyAlbq0FR51vGcxbNXs7JispKXZ1Edj+IlCYPclMBIfc3ETNygTaGrnorNbYN7a1CNBtB3FLXi7CPCqXWyfIpK39dSG+WX4mbu7q/KDiRLU9kR8r3g4A8Jr/6h4vlz5bTt3i+3m/LXf06mouQfcUFoCC5iTGdiPlizQNSq4hg0Y0ZkjqAacEWrznR2OA1zg3tTAf2tZic/+oMKEsVIWxnN47t8e2UwoAAAWv/MoXEfR1G5G1Zp1xukT1u61b11VXuRM9S0kBpRnXRP9jY93XWYB5fUJMts+XeTxQ2xkTvZSeAlZhfMaxbcUgS+4tHseS5/u8wrNLnKu5CYXD/BonHsg+d6sfHEVxyN8daRRkP6fwhR0rbu+B7PzMM8/EPffcg06dOqF37974/vvvMWvWLFx++eVmdxluuOEG3H333TjooIO4F0thYSHOOeec3W9YsldJcDtvQM63HHy3Lpp88D1x4kS8+OKLePvtt5Gens5XwTIzMxEMBpGZmYkrrrgCkydPRnZ2NjIyMnDttdfimGOOcTV2kUgkex9R3gYAhx12GDZs2IAZM2Zg7NixDnlbQUEBf19xcTGfcXdDrpi1DsQBtwzmrRsZkyWS/YM5c+bg9ttvx4QJE7B9+3YUFhbiqquuwh133MH3uemmm1BdXY3x48ejrKwMxx13HBYtWiRNUFsRiTnfyRdYrPjs5bJzGa9bA00++J47dy4A4KSTTnJsf+aZZ3DppZcCAB566CEoioKRI0ciHA5j+PDhePzxxxvdFlNVqId0B7YZZh56ZWVizUYAekUllMx0AIbkmddXrsOIzXiZ+OqlOONJOgmO1al8Zp2qq+2ZfcEB3TJQY7GYQ6qs7yoz9onGnKvmVp+SScxFAxjR6dpaYRdWRh0zv9YxYa+us5gtsY5vg0vTG2J3THpSaT9grB5YLu7wenjtcXHl1rg2iTXW+Qx4/LVwk7qLbaqCWY2q2mYwLnXInb+rQk1yj53KUJ8MP24Fml/3rUWOz4B/BxThv5/wnbLqnjtQFCiWSZ2m2ys38aZ7wrkzgpt4okFIeduBjSYH3/sNezMmSySS5iM9PR2zZ8/G7Nmzk+7DGMP06dMxffr0vdcxSZOS4HaeJAYTEd9XGq61LppFdl4fgUAAjz32GB577LE9a0snsF0VgOkmyUIhp8O59XskCsWUsiHOvZJL4qxjCrJ0pjB7wOX12tIjTQNLNcpZ6V0Loe40pGZ6RYUjV9g6hjXAp0gEZA6O1Iw06NV2zi8f3GsayMXd1LXsVPx+VtmvSMT+HATnbrdBp2PyQRhwM8Ycg25xwMgnGARIJ9eJArGUm97WGHyzLdsF+aFzwGpNIIjyfHtAqbj3O/4YZptqYT70HaZ7O2NQCgzZmr5zl9lGyLWsF+nEc9+VAGw38cSTNtsz89dVFRQKJbzukM8JkyzM43G47PO3mdddSQ3aMnVd5xbULCXIJ2tYJOI6gcS8HiCZxL0BSHnbgY0YwGUwb93szZgMAHpNDRRThs08drxQ2mTZ6VUKMyauAVB1DZ+c1MrKAUuma8J8PigppgkU6a6pO3X6k+iW/4o5mRzvYM2EiW+rfKXPC+rd3fh943ZoJabfhnAteaUUVbErocQ7fvNYLTpgC+VJa0LQ27UBAKghI+boJTuhbd7Kj+Hp0N74PeCDbqaIaeUVzmOacnc1Pd0pDbdiPk+Ns6Xj2pp1yDPl5brHI0z+qnZ5UrK9WqCqUK0ynhnGYoZeXmHHLtKhma7v2FnKS36q7QsQW28a8umaLeX2eI0UOYA7ggMAs74XKQEuxdd2lXNpuEP+Djg/M6H0KZAoXefxVpz0FzxZHCgqVEtGbz7vUTQKqjRk7nwRx2pPlKhbn280YvdV00C0+zFZcuAQi5edJ7mHi4/0vM63DNetgmav8y2RSFofUt52YCNl5xKJRCKR7H0i8YZrSXK+RTm65XYuPVpaB6178E06tB0lDmmzatXcrg7xVWzSAK1ou+sh1Bxj1jnSw8hb9Xz3u2Nll8+IarpDDswdyX/43a5dKpieuc3MGqvg5qxzRRU3EmM+n22gFQo5jhFvEOdYqY+TXXMXbXF/hTnUAC47OI7BjdDiXrNWbJnq46v38cez6m5b6DU1jtVfts6ot6lVVbv2hTTNueJtodhGbbxPosGaYHrH/H6wQmOFu3RgHtr8r4bvo2cZ3w1kmjPrP/1u90M4hsPVvDbsqPntKm+3VkDaZIJMp3XSCYqlyPD7oZsrE2INXIR1W9pP9mq7hVYhGMmQDmatfMdiQLcO5qVhvC4paZpd33QPjdikvO3ARoz1MphLJBKJRLJ3SDBcSxKDxe3ScK110ax1viUSiUTS+nCsfEvZuUQikUgke4V42XmyUmNibjhf+ZbhulXQule+Ya1SmjldqmKXKYkUO2pjJxhTWZirlopZIor5vPa+cWZcVm4tUxU7d6imxs7z9noS2xFM0+KNzaz8JKaqPOdJr6p2N0Cz3hOLCjWyydFH19zuehBzkBNyhx150OY5CCvBpDtXgq1Vc9bVKB3FNm618/OiUegxl+uaxDSNeT1QzPxvy/CMIhEo6WauWVW1Y4Wam80V5gMlRk53m/d2glkSaMaAamNVnVm5dUL7zOuxc7vjStZZ5y4awjFV4eXcYLYdbZ8Nj6mI0CurwNKNlXYrRyz+PElX+PeF+XyuufSOt1kqiFpA2WCWRsnNAQpzjWOs3cSvt1HDfPfrfEsObKThmmS3EctTtc0Gmb4bseId8OS1BQBou8rs/GCAm5Yyr8/2szCPodfWQrNMLxXVVguJ6h6xTSs+xu2jtDFUbshMA6sy7tPazl2O9iy/DT0cBpb/bOwTf37MGWepVlBrxZdBc1EfMZ+P3/e1XbuA5aYHSX4eAEDNboPYtiK+f8wsU6lmZgilNpMbMFkKNK2qmpdfs/qspKTYRrS1QrmtWIz74bDUVFt9p2u2+i8W4+VIFcvLJSXIc/f1XWXOHGurRGjAB0+n9ub1UaBt3Gy2GbVjmlgeTvxe8IMJefLx+f1mnNPDunN/44I4z9GK9wFnbr4iloM1FWh6TY3x+QCA9S8ANcPIA1eE9Cq9ttb23InPM7f8fLxeKBQBhGp0EokboolaOKY3auVbl5PlrYJWP/hmqsoHXkp6GvRthrw82UBG8Xl5gCVNg1Zk1MRkxYZjuibc2D0F+VzS63BSJ50PnNXctrwtbVe5Q8bMSVJfmr8vGoMK01BGYUCsbrlwsnPj5mZxpl5WUI03V7P+VUypPqIxaC51ShWf13b8hj0QF83kQLpd89L8DFiXDlBKzdqh5RX8c0IsxgOSkp7Gr7FWWcn7rha2M+qXAqCt1bwNvcr4XUlLta+rTrxtfeMWh6u5Yg3+VRVUaj7kCJMr3ExGJ5D1kSX57JSsTDCPVV87Cgqbn0Ou8VC37bhUdKgyBsL4rQq6+BBhfTawH9pE53vmSZxscBAni+fXQSdeWzUWqt0jqblEYuEwXJODb4lEIpFImh0iQtTM5Q761DoH31bON2OAR5WD79aElJ1LJBKJxIGUnUskEolEsnfRdOKCjaBX5duS7QsAHoVxayQ5Wd46aP0r3x4PFLPsBRSFr4CSIMkWTcqIyLmCzUtNJZaA0Ep2QjElRqLUiXQFaoqxShnq3R6BnzYldizZCqSbWRnpRukQOFetxf0dRm5Jjm2XObMlWg4Jntt/SoUBbcz624oCVNnyL7vNuPbcyn0Jx7dKqKnlVbaBm1DLXAkGAFN+GOrSBsE1RhkXFqrl+1BFpSCxE6Tt1uegMEQON0rB+NeVQN9WbLfjIoVPVtvbOh5TwfWFzs/ArpmONhlAjSExJFFit8Ewkuv0Sgi6qaCApjnaZHFqRKttplimbD67dIn4HbHUBwG/fe56zDbuq6oGc1spl0j2AHHALQ3XJI1BbdOGK3Ni6zbY0l/GoJcZSijF77el5ACXDotlNvm3TiwFJiqRxPJUHvtRRqus5LHLU9gOke6GnJsixnu9xeWIFZsGrKIsua6TYixxm5XWI0iixX4p+bmgXWXGsTVb6cZUlfdXF+TWZMVe4XWK2fFMKytDQskywFCvmaWwWEqQX2PDbNU6uBmba2qgHnqQ8frq9baZKcDjrdgnMGan2EUiPOZpggzbSgVjAT+YUOpLM/sB6984lEAgsQyeprmX/SLiqjNQnImsmG4QJ0lnHg/gNY1t/T7oVpmwyjjtN3+uENLJ3CYdGXOkwbmeV0oKfyaNFW/n56OoqjNFQSJxQczjDpiDb9HVXMRyQVcVBtX8vyxXvlsHrX7wTbEYrx3KvJ6Em6+xT9QegMcPXnmt5kSXcopE7PqeAorPi1jvrgCA4Ort0ErL7BcFqbbVP7capAm1KoU8YEcgFx3Rzf6Jeb12s3ZAMv7VePtWDVVXh/FoDNofG13PUZTnJ0V0co8bLMe2Fjlk+IzMgXUkatRnBxCMREGpRk1YpVsn0GbDLVyvqHJv13oQKd0Fz5fGQwL5/Y5ce1HObed0M55DaKFHosJEgtOd3sordDS9pYhfS9GFnsxBM20Ju9cfDfihi/W/hX7qZo44hUKOiRLAmKTgEx/RaHIvAuuhzuMFU73CuSU0KZE0CGfOdwt2RCKRSCSSA4SoMND21+NgbhmxeRXF9siQ8bpVIGXnEolEInGgO3K+ZTSXSCQSiaS5iQqeT/bKdzLZubGvqjKo5uBbpom1Dlr/yre4yqtp9opzxCkjt+XFgr4YcBiPGTTMIdrzq7FarIfDDhl7gtxbVfnKqNEM49vhskpq99E0FdPsFWwAUHJzoJsr/YgxLhVjqmKfs7Ay6qj9HV+n2sLFfVyPRB0GbrY8P/mDuKMeNgDHtRQl/tGY7W4aiwGmTB1k173WRfMwQYZtKRhI02zH2Pia1qpx7ZnHA7IkYlGyjeWsz4ioXodxxhhY0FiZ1+PN6OKuRVKFQJLBS3wqA6wVbMuYLj8X1lq9vt4ltUHsC0wHduu7E1CAkFz9luwemsz5luwGzOuD3r098NNqc4MCiKpxS0YhuJM7zCR1suXcwjG5o3ZlpX3PVlVbbaXbMRaKvT22eQuUzVvMAxltxOK/z6ZDuZqdBTIrRyjbd3H5th4O2zHIpYKE4vfbqUlCTImt2+CUj1vn6/Hy6ibM6+MqKq5oU+LUcmJ/zb568nOh7bBVeXqVWVEjXk5tSbIt5V+fg6D/9JvdJ+G4nnzj3GsO74BIhtGOv1xD4Gvjs9RcjUCZrbzy+3m8TeiDyzlAVaGa6Wcwzz1mpo8BhpydDu5kHOL3jfY5JrkfMVWFbn03ROdx89iqz2s/L3k8KLl0IAAg7+MiaGvXG/tXVXHjU7VNm4R0QOb329ctST/0UMj53GVtr64GMXkvldSNJTv3KAxe1VrNrnvl26MwqDxbQn7HWgOtfvDtgHSej8M8XoCEqG9JgDPSoJs3VDEnVxycJ8sPtgKYHg4DVjtxUmG+vzVwbZcLtm4Tb8Pan/n9vGxH/KDNKtHBUoLQtpc49qEt2xyDUS411zRhYB9XtkqQ1rsOopO4e1s53WpGGi+/4cj/VuzAS5p9HKaYpV2CAZ4/RaGQo6+2U7lu76NpfLIh6YDfPEdP21zeJytA8n5bfYobWGsVRvDmknKdbDl//ABePJ41gI+/Acbl4xvl6NzSHpKUuYvfz3qv9QCzYTPPV0sKU+zcR1V15thLJLuJOF8kZecSiUQikTQ/UTPgelWF53EnW/kWc74t2bk0XGsdSNm5RCKRSBxIwzWJRCKRSPYu1uDbozJ4lIblfHsURZCd74VOSvaY/WPl281ITNNs2bSqcCkGVddAbZsDANArKm15kGB4ppp1kykSsWXfRK6riclky2QabLGiHfzYSsAPJSfb2EFVwKxVypoaF8k2oO8sdUrazf7Fy7n5+6yVWMb4yrtD2lyXcRosE7i448JeMeb7mSvHTFVBojO3o4+G2lDJNa61tmUboNnXivhpkWPl2DZI84CZy29i3WtLEgbAXeIGuDvKu0Caxk3gxHNnQkpA/H2Mf6cCfqB7R+P3LabDua45VBWOeuvW5yG48Du2u31OTAEzF74drvVx3zn+vYy6m/tJJI3FkfMtZWySBkLRCOjblfYGxmzJs7A6o1fX2LJd0kAw76teD3cl59LhaATaLvueZ0m5mcfDZRkEWxqspKQAZozSdpXbUvFkcmVLCaWqoFVrAAAx4flBzcqyU45UWybOHcSTOFgzr4/Ly6myUpBCR0HVVuUK4b5vHldJSbGvkyh5F+JGrHiH022dN+o0FeXxykrnWrHK/TroGmLbigAAvqJiBMw4S0RAMAAA8HRob1QhAaBVVPBrYMVhXScoAWNfpU0WKMusQhPTgBLDHV2vqgZFjc9Sr64Gtpnn4KLwolAIapHxPvJ5oWZlGS/4vNBNk1vm83Jncb28wo6notrMum6aZldTCceQ88+lxmbhujFVhWI+H1JKACgrM49ny9it75+ak81d/cVnETUvFztOMyqx5L71q13FRNOAmHQ7P1B5+euNmPOhcX/52/BDcE7/9q77WbJzn6pAqWfl28r59qi227mUnbcO9o/BdxJ4LpUm5JTVU+6BKQwwb65KRppxAwbAikpseXOy3GnrNYC7YrNYzC4BpuuggCk7j0QdOd9Wnq+S3Qb6Dktq7iINFweoCgNgD+rshwKXulZx/RZzpy1I0+yBtc/HJxDiB3TWYI8xxicq9MrKBLdzCodBu8yyJx5PUrduKz3AGLDqdhvxOd+wg6q+o8SZx2+OUlnAz/MDKRIxHr54Ozrfbp+z9ZvwWfgCjvx51xJtmga23sgltOTvLBiE0q2z8XtNLX9Q0UP2940pdu67wyFeRMjhZubDDHTNfUKAdFDMkvkH7WuisIbaF0gkCTjqfMuVb4lEIpFIdpvXlm/GljLjmfr17zbXMfi2ZecexZKS119qzJp3k/G6dSBl5xKJRCJxoJEcfEskEolE0hSIq9fROoxURNm5ygffdR/TI+t8tzr2j5Vv5jKHEF8L2VxtVDzMvX61tdro8RgO3DAk6sxcAdXDYacja11tO7ohmLrFYsBW083T63HIqfnqqOBgCoVBUS3JnmlKFonYfQ34gai5QhuL2QZlyTtj/yoam2miLM9c+S7MB/H63+5LqKTpYOZ7lcwM6KY8XZSUW7IsFvAL109xrGpz07PaML9ealpAWDF21l63ji2ei+I31QpZmYgVtAEAeLaWAtbKt9lW0mvCFFuyJnwuCSvTZK/Mx6chUE0NFNVwb6XMNMCq7R0yncgBEDEw83xYMAhwIzv72EyQDzFLWujxgJnyPxaNOeqMx18b135LJI1ADPZSdi7ZbYi4zBgAyFyeEVU6FA5zCTWFNcEFnfFjOA5pSYrF+7mu2epiSxINQ1HGVFNCLcQOy6SSpaYC2ZnGzqoCmA7n0DSeuqXt2mW3o6hc7RUadBAAILhiI6jSTs3icUFhdnwWzofL8AGQ6J4unKclHVX8frDUFN4nngJGOpTUVLMdhbejR6IOdZtyUBdjdyuWC22o+Xn8d237Dvs1pkAxnc+puoY/D4EImhnPHXDJtgKWns7fp5kydnGf+M+SS/bNmOv4XkRjiG3ZmtgehNSDtFTu+u6Qmovye7NNraycO60rKSn29yEWs1MCNA0xyx0fRuoAYJvggoi7UWq7yl0VkFrxdmQ/s934XdiupKTA074tsN71lCT7OXoDJ7RF2Xm9K99Czrci63y3KvaPwbebBJzFDfCsAU0sxp8slWDAlldagypNN/KzXI6RcHz+qxVUPfZAUrixc5dvnRxlx9zOQczxYqoKJSfLeNl8QGDbd9pvCdXa+R1MgRI0AoSSlckfBvRQrSNvnOdXC7nVMB8WKBblQQ1lFTzgONzJhfOFMHBXUlP4ANPO/SY7kFYL5x13LMcgluyJET5gdcljZl4PLxtCmsZl/rStCKr5+Ynl0kionchLuQUDdg5YbZgH74RJGXHSgk9wCDJ16/NnHuhrNvDz4NeSdEAxHxZ0nX/nqLrG0Rc+6OdlbYhfN5aWCrQxvgOKxyN8viGhb3KQJGkaRNm5NFyTSCQSiWT3EQfcyXK4ASDWCLdzMedbkXW+WxVSdi6RSCQSB1J2LpFIJBJJ06A10Ecl4io7r7/UmJSdty5a/8p3MuOz+JVasTa2ubKp19TYq5OwVllFgy1xxdWuo+04noiq8pVU9Oxm7Pv7em7IVZ/7dkLfFY9tDrfTXuG2ZGAsGACVV5r91oCYuYpbXQ2WnmYcIhgAzFVhrbyC95ubknUugFpcavxeG7ZX7CuruOxOCfjd5d7CijXVhm3HUjenUVF9IMrjmZLg6A4YK/aO6221LagCmLnST7Vhe+VbpwR39nj4anwsZrvPM8VWPDh21p2ftUt9dK5sECR/4namsARXffH9gOlmLkjfADhN52pC3Oldz80GLPlf3Mq86LAuDdcku4s0XJPsLmrbHPveWFNjuz3DrlbBPB67Ikdc1QolGDT2MWOYvrPUKSk2ESuaJIPCYdugUpA+8z7V1AA7diS+UVGhWO2LfdQ1brzq//BHAIAWdTqxi30V21bSjOPx5wEAakYGT6/iLuChWig+20DUTufSuFwejNnnID5sMwaHS/yq3xPPzbwOVF5hm7oyBYL7KHcTd1TWqKqu8xmGYjHjesa1A4BL9cMDeoBUY3tgUzlo41Z+zgCg14ad1U8Uq2KNaj8n6Bq/xtr2HXYlEJfvSAK6HVut9zGfz/1awpabWzJ8vWh7Unf7epuuqUFsQ0X9O0r2S8RBcbSOemDWaw2q8y3kfFuPflKp1jpo/YPvBmAMgoQBnjBoYuaAUcnOMrbtKne4U9eHkhrkwVQP1YKFjf8BaomRO0Y+r11SLG4wlLR8lDXAFF+3BlsOd3LdIZHmg+EgoLUz8p7Z7xv5sZk4OWDlfFeFuLSZIpG4vCkl8XeKOs7DalOvqXEtxSbK29U8M4+svMIhy3fNBSfdbsc8htom0ylfL8wHACgV1SAr7yu+Dy4DUz75EgpB37KNXxvLcZ5Cta7pBszr4SVgiMguBxNJzL8Wc8hFp3XHLqoKJcN8wKuo4p+N3YbtVYBoDLrpnk4lO7nkXnS8T2hfYcaTo0TSSBwr33ImXSKRSCSS3ca58p38wcySnTtzvuuv863wle8m6a6kmWl22fl9990HxhhuuOEGvq22thYTJ05ETk4O0tLSMHLkSBQXFzd3VyQSiUTSABoqkZO0PmRMlkgkkr2LGEbryvl2ys6NIVqyGOya8y3jdaugWVe+v/nmGzzxxBM4/PDDHdtvvPFG/Pe//8Wrr76KzMxMTJo0Ceeeey6++OKL3WtIqHvt5mAOwLnyKK5qWhJfc2WZIhG+Aqnm5fJa13pllXPV2fyCaxVVTqmxpYwqMYzRWMDP5XXi/z7m9RiScJgr2MLKt7ViyhgDs+poWy7p4sq9Fmf6JRh1KRu32/s4DMvMY2eYrqQlpbbsTTRWYwqYuKBqOaiqqkPCz/viUpebKcxx7tp2Q97HPB7u3m50yZS3+z28vrabmzeiTjfTWJYhT/TWRuzV4sR3Cafg8qpl8BZzrpDzVXdx5dzng2I6z1IsBt2U/Ls5pkNV+eerh2rjPgMDJRiw65AD3NnesZLOlQDM/o4Ix1LatAFLNa6DtqXIvm6MbDM+iaSROAzX5Pdov2FvxGS9vNLhcO5pZyiUSNOhlZjVPGprbUmxV1B4aZptImn+y3w+qFmG2SSFam11lk52XPL7bQNOoW0HDfkeC1Jp65mAMQYly3JEV3k7vJKHx+NIZeKH8vp4ehdLTQE8psy+rNxw3gagxaLc/Zwrr6IxOwaIknxBLq+kpkI1U6Yih3WGb4sZR3bu4nFSr6lJkOuLcn+WlgqETQVaVZXtWq64xxrm8RgVOmAr9cS4T7GYoz1PB6OOcU3vAqT8sMnY9uF3/HPQGOPqPu4+Hwzw66uVldnH1kSjV48dy0nn+6tZmWDm56TvMJ6/9FCtU3JoPSfEokKsVMCO7GMco6QCsY2m27muQa82nwu3CN850bnd/N3TqQP/vugVVfax479z8l56wNLQCW1Rdu6pT3Yu5nxbSkz5HWsVNNvKd1VVFS666CI89dRTaNOmDd9eXl6Op59+GrNmzcKQIUMwYMAAPPPMM/jyyy/x1VdfNVd3JBKJRNJApOHa/oeMyRKJRNIyONzO68j5dnM7r7/UGOPrWXLw3TpotpXviRMn4vTTT8ewYcNw99138+3Lly9HNBrFsGHD+LaePXuiU6dOWLp0KY4++uiEY4XDYYSFGeAKoY6nuNqoBAOOGWheZioac6xsckh3zuDCaeJCNTV8JRY6OVdOkxmPWCvBVtmqEHFTN8cscTQGXQ+5Hot5zY+lYwH09Zt5v2wS89dZMAglx3igosoqkDljC113zBJb8/r6rjLjfaKRSYI6QFj6tla7FQa1TZZxjIpKft0cuceC4kB8naJmPzTNNnzTNNv4JCUIZhmvhJDQL62qWjBhU+BZtd7Yt448b959j9e1ZJnjbW6r7QJ6VRX0JCXTeDtWnn6PTsD6rWbbHlthIXy/tDgDG+u9qrm6oJWVuXeEKYaiAgAV5AChSGJ/kuSZSyQNwVHnWw6+9wv2WkyWSCQSiQNxUByrI+c7ygffrBGGa0qdsvNNpTVYunYn/F4FJ/fKR4rvgLD72qdplk/g5ZdfxnfffYdvvvkm4bWioiL4fD5kZWU5tufn56OoqMj1eDNmzMC0adNcX2Oqyh0pWXqaIWcDQFUxp4lZMoRBJQBAg11fOhK1K9YrzHaPbsCgxnbmtI25HHJm4TjioJ6pKnd5ZTvLoFnmb271xkUzsJQgYnmG5EqtrHJMJrg5cFsO6FDjXeBMN3Sf13ZChX1N4PWC0k0pXW2tw+DMks1Z0iq91uliK7qWi5I9FjDl91XV/L1KRhrfh3+OogFZJJJwfKuNeGM7oP6BdbxruKubfX0DWsFJX91RBt2agInG7EkSj2Ibq6nOyQlY18+S7sX3yfpOCekSbFMxmN+sLR9/02VK3Tp8iSQJulz53q/YazGZMaj5udAEA0zdlFjr4cT7tbGTnhADAXCJc/XQQxHYbrxXXbHavg+qKphqTnbqOsi82dkVTGBOzsfdy1WVT3DrVdUOqbTotE6mq7keDjvl32JalfW+lJTESyE6lZeV2ZJjxmzpsnCPt85FLchHTU9Dqh/YWglatcY4htBPvboaMCfY1U/KoAvmnuK1tKTfFDCOra/fxJ3btUjEjvdC/ykSteOSqtrXT1WBqJkWZsV9sRoIaQ7ZfmyzId/2bd4CVx9yIt4X3uOaGqesm++r2aFQUbkbvB5XYUTbZqTncXd6xqCkms8rBXlgtaajfMlO+/uoa8APpit8x0LuiO7oqvj5K1aanNeQ7gNATDOMWmE+a/DrGgDrUGDsU7wDWk0lkOS/gWT/Zk9k58kczDXzGV0VBupuC9/jn1+OX7YZ97Prhh6EyScf3PgTkDQpTS4737RpE66//nosWLAAAXNQtadMmTIF5eXl/GfTpk1NclyJRCI5kKiJNKAcD+IeFOTYu1UjY7JEIpG0LA0vNZYoO29MqTG36iRF5SH++45KOfuzL9DkK9/Lly/H9u3bccQRR/Btmqbh008/xaOPPorFixcjEomgrKzMMdNeXFyMdu3auR7T7/fDb60KxqGkpSLSt6ux3/oS6CVxq6V1wRSo7fKM/c1Zbk0wO1Fgz74jvrSU2wpoktVS63hMVaEEzVVK0TQr6OPlypTMdMN0BOYsbnw78RJ1a8Y7HIZni2EygrRUKObxE2peCwYm8f1gqgrFNHhjGelGrW8AVBOyTdHSUkFlZskr0WQNsKXVjhlr43UlJ5ev6FJ1jW0oE4uBTMmi4zNzWdUWz5c0u+66o9yahuRGe27HElITxO189URRhBrnSp3HE4+jle6yr0e8skEoIcd/1zSQVWvUWtUWVvGdKQ+CWUzIvqnGG74xispZdgln+YZdGDn3S1x1QjdMOe3QOvd1GK7Jle9Wzd6OyRKJRHKgUlIVxk2v/YiSqjD6dczCtLN6gzHWiJVvW3be0FJjqlK327k42JfxfN+gyQffQ4cOxU8//eTYdtlll6Fnz564+eab0bFjR3i9XixZsgQjR44EAPz222/YuHEjjjnmmMY1xhQwvw/+34zcWq2kNKm8WLGcRGMx52DNHHRzV27AOcBqa9bL3lVuDEJh5GQnG9zbA0KXF0l31qG2BsK1YS6Do3CEy5fcHLLNRoRDmA6vkShIM923o1E+AGaqClDiIDWZxJpLwFWFy9+pJsTl9/quMlv+pqq8fYezuSXREtrQy8q5+7exX9Tuv+ZyLZMMch2fL/Oa/5Jjf+taMlW1nXMFmPBZi7Jv5jOdXDXNdoRNSbFTD2IxW/aeTKIu5PQ7tgnpDdZECxTG5X4sM8Mh1eR9siYHxBtmvBxdQG2bA8DIx0d9UnvJAcWM934BADzx6R/1Dr41R36aDNatmb0ak4kMPxHBZ8SS9yopKXximfn90HeWAgB0M1WMH8Iq8FBpxLPgW1/z1xx3vVgMZDmmK4xPmOoRIdWKYiArw8pywq6q5i7WDgk4kR0vagRvD4BLjaFrPLg7LDZ4qpAtu0Z1te0gLsacWAxKulFtRMnNgZZtxFlEjePqf2yGb9FGfr5WOpenQ6H9bBCJQrOeXXSNy7Y9eW3tvmRlINLOOGfPd7+bfSbbZV6QzUPTAK+ZvufzgqqtCWeNXz8gTtIPGBpX4WHHcmBHThvofxjnILrPK6mpCA827j3+7TXAWkMxQcJkO/e8UVUeeykc5ufFFGZP3uu2HJ0iUb6Yom3ZZmzTbMdyrFnn/BzF07BiZSQK9dCDjHZqI9BLzO9oVZV9vuZ79QjArAWKnaUJMnnAcFtXd+4ytnl9xuLGdkj2Yz7+bQc+/NX4kH/cXI6Jf+qB/IyA03CtzpxvW3au1LPybR3Tqyh1ys4jgueV28q4ZO/T5IPv9PR09OnTx7EtNTUVOTk5fPsVV1yByZMnIzs7GxkZGbj22mtxzDHHuBq7SCQSiWTPqY3VbTgoosmV7/0GGZMlEolk7xDTnANra+ArhtGGrHx7hJXvZDGYlxqro843EfHa4XUdS7J3aRHLu4ceegiKomDkyJEIh8MYPnw4Hn/88UYfhykMemUVr1OdsBporjaqGWnOWtYWpBuO03DOAvNZaq8XrMZ8H1PsFVBNE0xGGuAozY3VFDimkTnCSnwoVOexmc/nqB/NjdXiVuLFFWkunQ+F3B2/BSm6ZtUn9/n4bHqCsRklXgfm8dirtC5nSJEINGtF1+txyMcbRTIjNPFPUUJuyropGrPrqscSrxnz+PkqBUVj9p1Sq+SmKrGeHeHbbMyEa9uKE665Y/U8GnOu0gsr4lwdESXo5uoOqqoT3N1FCb0S8DtN9FxqrTOvx6hHz8+hkddWsl8TijT8++AwXJMz5fs9TRWTJRKJ5EAmPl5asVQcFEc1AgmprCLW4NunKlDN+mHJV77NgbogO48vNRafXy7j+b7BXhl8f/zxx46/A4EAHnvsMTz22GN7fGyKxZIOgLkjZsjpyu08gDAwhlO+RpEItO2mFFjIMWY+H8AHQnC0n+A47dKW+3kkDtTcYIxh20W9AQAFL/5iD95U1V3Srhk51gCgpKaAmQM8PqBOMnBlPp8xEWDt4+KyzhTGJXHM6+Hu5Hw3j1foh5BbzhjgdRl8M8UeILs448ZfW9cUAzHvWWxTYfbfLgN+IoLjNmj1mxiYdTPcUMLlcY4Bvuh6a+bMUygEvUo4d2EQLV57S7HHPIrgBi8MrN1k7AJKMMjb1EpKHdetzu+i5ICjNtrw0nNy5Xv/plljsiARBmBPakaiXBNpTfIChhxdyTXSZcjrAW01HKv1eOl3PIrKJxiJGI8lzOcT3Ljte71muq7HS83574rq9BFx8y4JBGyXbLeH2Pht5t+O66GoPG7rlZXAH+auwutWOpIeCtmeI2Xl9jkoKpRU06Fc1/m1ihUV2+2U7IRP62y8t72Zu792g33N4m8HmhivXBzHGeMlQnm1El8Aiin11nfstD/Xkp2O68oPEfAjlmLEt+CuSmjmM4a4WMCfQfQkz1VMgRIwU8sK84FyY8JZKymBvtEozWqlGTKPx5HW4Ck0rkOoZzv4vzTScPSaGn6esa1F9nOexwOreLIlpw8N6IqUH402YkXFzucUIcXASivQyisc33XNdfFFsj8RHy+tgXPioBxQE8ferm7nyVbKo2LOd5I639G4lXhZvWTfoMndziUSiUSy7xFuoOyciJwSOTlTLpFIJBJJvcSPba3BeOKg3H0yXJSd1+d2znO+VQVqEtm5mO9t9E/G832BVj34Jp34TKwbeiQKPRI1Zo7dajQzxf4RjxuLGT9Rw5zNqpVNOhkzsLpu1GpWmDFLah3DakM0/zLdrZnPZ6wEu2C4a3vtH1U1ndGDiTsrCgrf3oDCtzcYs65m20pKirESrbDE8zT7RKEQak/ojdoTesPTsRCejoUOIxjHtauusc89vgs+r/FjmavArJdqXR9+XgpYMGj8+Hz8fSw1xTBTUdU41xrdMI6LRI3X4j4bphqz/UpqitFv4XXr2impKYas3etJOAb/Plj9ZIp9zQX5j8OIBsYqNoVCiG3ZBq2kBFpJibWj8WOeCwsGDTOfqmrjnP1+ML8fSjAINTcHam4OmM9rf05iG5oGJS0VSloq1DaZUNtkOj8bl+9WfP/E76hc9ZbE01DZeXxsjslaYxKJRLJPsGXLFlx88cXIyclBMBjEYYcdhm+//Za/TkS44447UFBQgGAwiGHDhmH16tUt2OMDi/jBb7KV72Rx1a3UmJZkoM5zvhXGzdniH/3kyve+SYvkfDcZpAOa5swfZomS3XgczqOCK6vxj5IwMHK0Zx3Dcv30+cCihpRId0iQzEGhIIFz9E/shyiJNgfS8ftY/dRrw9C3Fpm7Mn48isWgtDGc2fVduxLOyzpGYGul85xU1eFM63auIswcZAIA83qdZcVc4JMjaoYtwUsJgJWW8eM5y50JEyFqnHM86bYrKun2tYmZkyEAWEqQl0hjjIGsw7mMO4xJDvv68VJoOjm+A1wyGHd9rMkUK6+ceTxc/qeVRuxzb5MJZq468gmT+E6RbufmW9+LiirDyZ1fD9OlVnwfY4BV8qeq2u6jW2685IAmFG3Y4DtZzppE0hDUtjnQTIdnitlSc4pGeKoQ8/u5ZFevqYG+0aUqhRVjmcLv00pWJr8fa6ZbunFwWz6uZGUCpseLXlPjlHzz45n3Uq8HSoYhEdYrKoWUIPs7r6Sm8r+V7DZQrJhRbpXItKXESkY6kBLkrzv6KJLEdZufjvnMoASDjkosilmNRGmXh9jGLfwcPO0LjcNlpSOWY7SvhGJAiRnvi40JYzUzA3qPDgCAqk4pyPjYGJQ5+skYn/hX8nNRekwBACD7k42IbSvmbQKGU72+wXAsV9LSwLxCKVV+bjqUNMPRXa+o4u71bolUjhAbhav8naIR20F9zTrXfRwO+sLEesx8dvIVFQNW3Pb6+PdLr60VjPKFHpry+JSfA6B0M64XOfvOF0sYs1P2mth3ZdeuXRg8eDD+9Kc/YeHChcjNzcXq1avRxnz2A4D7778fjzzyCObPn4+uXbvi9ttvx/Dhw7Fq1SoEzO+PpPmIj5eabuR3J0xq12Oi5nMMvhuR8x23bzgWP/huwElImh35hC6RSFyRM+z7Fw2d8I4P9HKmXCKRSFqemTNnomPHjnjmmWdw1FFHoWvXrjjllFPQvXt3AEZMnj17Nm677TacffbZOPzww/Hcc89h69ateOutt1q28wcI8YNvncg1hiaLqxEXt/OG5HyrSQzXInGjbTmZvm/Qule+YZipWTPDano6n3GMr+fNYYptGhKqBfQkRmwwzT+sL71o5KWqjlqU1leZESUYY8U7hfMVVabw1VroZPeVEWCZjrXLgbLZmGnWSncl9M9wwzZbD4VsMzCH9FuYNc/MgP6L4e4SE8zK7H3UpNeM1872ePgqvVZUbM/KMwVM0fk1MRpUbCOTDjlg5sqbWlLB67M6Vt6F9yr5ufbqhWnuoldVgYkqeXGa3FIGlJZBSTVnoL0+kGVQI56naKiiWeYz5Fg1tgxTKBRyNZwy0gICzuO1yeSrInpZOXSrDmt5hXMl2mwnftU/VrwjoR27QVsRwVJTQFG7LikExQVf0fH5oPqDQJKFl/qQM+wHLm4PDxKJRCJpWd555x0MHz4c5513Hj755BO0b98eEyZMwLhx4wAA69atQ1FREYYNG8bfk5mZiUGDBmHp0qUYPXp0wjHD4TDCwjNERUVF85/Ifkz8ynJMJ9eJ7/pyvkXZedKcb8GczRJ4xCvXpOx836TVD76haXzARpEILwuFmhB3JBdhPi/Q1shVZluLE12kSbfdpuEcLLOA6aDp94HMASEJX2y1YyF0cwDl6tQaJwW28oxJLM5FOpezsVCtLX2qp8SWIZVOlI2zYJpxzgAQTT4hARjXhlz6zRTG3UMpFuPl2UA6H/Q6SrWZci5E7QG+WloNChj9oOoaUMiWhYlpA1zCVxPikna92u4Td7Q1c+kBwxVVlIjZruvVzokI6/pYFb3i0gDEkl0wrxnTNDAuR7dTEpT0dKBdW2P7xq1Gu1u22SkDTIkrHeZ0dQcAJRiwr4ObzF90mSedn5fi8dhyeU2zpf/CRAtLTQWw+86q4gy7RdeuXe2uxc2wA8Bzzz2H/Px8vPXWW65BXtI6kCvfkt3GdBK3733O744jVUeIRWKalJqV5TymkG6klexMlJHzg5sTn4KE2tX7QtdAunBv9ngcr8UjpgppwgQpT5FSVe6Kre0qA0zJvXEumca+2W14qVIqrwSs9+a0ATPPLWY6dYv94/JqGHL+8HE9AMBw6rb2CWu8X0p1DbybjXa0iipo1sSwJSNPCULdYUxIZ6zbah+79yGg9Ub7enU1f37R129EpinVRrs8eDoa8naqMB3Gw2H+eVH7fChbjMUCikTsErC6Br2qyrwmzs/DcX0AaBs3Oz5fK54qGekgK3VL6J/bMY0DCoscwqS6aj0fej0OqT3zGduV1FRHv+PbiG3eYr9H+N4wnw86rw4T1x/BBZ2B7UlYxh9//IG5c+di8uTJuPXWW/HNN9/guuuug8/nw9ixY1FUZHxW+fn5jvfl5+fz1+KZMWMGpk2btvudkjhImLzWyXUCO1nOtyg796h1r3zHxJVvXhPcuY80XNs3kbJziUSSwDvvvIMjjzwS5513HvLy8tC/f3889dRT/PX6ZtiTEQ6HUVFR4fiRND+NKRcWH7yTzbpLJBKJZO+h6zqOOOII3Hvvvejfvz/Gjx+PcePGYd68ebt9zClTpqC8vJz/bNq0qQl7fOARH2s13Sk75yvUDZCdW3ncyQbqYs43H3zLle9WQatf+Tbcx82ZUqE2p5LdBrop1aZozJaJE0HfZMz4MlXltcD56qGmOWbLef1JLzOMXADb9MvYwf61dJc9ayritrrq8/LZcoYoALMfmmYbt0WifKVVzTAMSygS5f97KRazV54FozJjH3MVoLoGMBeC+TWIxzoHt1Vxs09apWDU5iKhJvGt1gwwU6BXGO9jNSFH/W1rhdtRP11YudV27opbOXa2raSkINbbWIn1/LHNkHajjnQDwFk/2zqcpX7PSLONywTzNTGtgamCrDszHagyztP6vEgnaJZqwesBg2AI59ohW+ruMLLzm6Y1VdXQreukk+lAY9QzFa+VVWsdEFQHugaq2v2BbXPMsANylr2lqIokT6+JJ8FwTQZriUQiaXEKCgrQq1cvx7ZDDz0Ur7/+OgCgXTujjnlxcTEKCgr4PsXFxejXr5/rMf1+P/zCM4Rkz4iPn5pOjm0+VUE4pied1BZl59bgO1m5TzHnO5nsPNFwTcbzfYFWP/h2DH41cKk5VVXZSzik278rCh+wkh7jebuWaFoPh+3BfHxOsSmjZikBnmdLmu2qrldV84GkY6AnOlCLTupWn7xeMMWUVAm52CCdD2o1U+al5uYYpbpgDPb5RIBZngwAFK/Xzv82y6QZB9ES+ydeymRyvoQd67ZLtCcvhLZ1HfCaEwyRiGNgbfWFecVr436DsM5RD9XCs8aUzSnMllxrcRJv14PYnw13ka8OgZnfHaaq9udEOj8c8/vBzO+LXrSdXy+ntN26AzoncdygiC0pJJ2gmq67tYcYQTOwuhi0zRjIxk8oiPJ7EvK1uOdBKGQ7ve8Guq7jyCOPxL333gsA6N+/P1auXIl58+Zh7Nixu33cKVOmYPLkyfzviooKdOzYcfc7KmkQFSGn1pGIHOX1RBJk51KmJmkMAT/UzAwAgF5Z6Ygrloya4jxHrElwPRKFtsvpb6KkpkLJNVJ8tO07eKxmHo+dciZMRBsbzElNhQGqz9kmEXcNJ03nkm2mKlAPPcjYZ0sxT69KFhcpZk6M52Sj/E+GHDzr8w3c60OvqbHjc+kuMPOaUCjEY6GWnQrvxhreL35NzMEQ69kN+MOUg1dWIfDtGmOHrh2BdGMftaQS+oYtvE21TZZx3ToVYNfhxu8xv9HXvE+KgJ1l9klY0untpXxyXs3KtCu0hMM8TsU2CCui5r1DzcoEa2MuSqxZD82KRfH3DOFvNcO4DshvC+zYaVwHU3JvlAC13cv1auMzYKoKWA7rIcEZX7G9V5jPZzvoW9fdkUagQ0uitLLagaLaMVz18ZQ9hxRdEarrWKcXCiWVv6s9je/G+nNzkfdpGfCpaxcaxODBg/Hbb785tv3+++/o3LkzACM1rF27dliyZAkfbFdUVGDZsmW45pprdr9hSYOJf+zTiBwT2D6POfhOYjseE/K4+THqyfn2CHW+iZzxPRq3ai5l5/sGUnYukUgSSDbDvnHjRgDOGXaR4uJi/pobfr8fGRkZjh9J81NZ6xxA1CUlT8xZa5YuSSQSiaQR3Hjjjfjqq69w7733Ys2aNXjxxRfx5JNPYuLEiQAMH6EbbrgBd999N9555x389NNPGDNmDAoLC3HOOee0bOcPEOKVYrE42bnfo/Dtbtgr37bbedKyZOZ2sdQY4JwASMz5bshZSJqbVr/yzTxee0ZbkEPr1cLsaLzRmTmDSlHBPEx4TXzdllVrXEKt5OagctihAIC0xSu5XJsF/GDCjLrxi5681qcJ1YadK94usm7ej6pq2wU8HLal4rEYyHJ9b5sDmMYiWukuV2Mb0SDNcn+3Vtfj+8G8HtuYLn7Vu6560qTzVQelTZa9Gh8Kua6eM4+HS/EpEuGybUBN2BcAdHMWm3k8fNaZeT1Oubp1DoJzvWP137quMd2uQauq9oqK6IIeifJrqUeiTkUDnA7omlhzO+nlca7UWDVUfeb3DLk5ru9jqsrbdKyIiwZtACgWiX9rg5Ez7PsX8YPvqKY7ZtZF5Mq3RCKR7HsMHDgQb775JqZMmYLp06eja9eumD17Ni666CK+z0033YTq6mqMHz8eZWVlOO6447Bo0SJZgWQv4Za2ZW1jzF7RTlo+TFj5tvbR4mbAiQjT/rMKH/xiPDOqCoMiPNNrOvEc8PjBt5Sd7xu0+sG3RCJpem688UYce+yxuPfeezFq1Ch8/fXXePLJJ/Hkk08CcM6wH3TQQbzUmJxh3zeprHXKzuOlaCJubud1ydQlEolEsnc444wzcMYZZyR9nTGG6dOnY/r06XuxVxKLeOWYphNXj6mM1Vs+TMz5Bozf4w3XtpSF8OyX6/nfHbKC/LjxfYg3XJOy832DVj/4VtJSoZtmYKQTz9UVS4gxhdmGYES8fIVeG05YnUwoPSaWerJyjYp3IONLc1UxK5PnhMW6F8Czar2xu2mUpdeGHauvdscV/jCra06TNrG8WbxZl15TY5ttMcXRP/HYVBPi14fX5RZWtnlJLIWBpRlmbkpt2DZ7E0liYCb2lfn9dpkw3heVl+OIds2H55eN5svkfgyvByg0Dbw2bLHbFXLFHX3hC9zEDeeYzweQrXrgBmleT0IddGM13OX6Aby0miZ+H0iHHnExgbPeEwzYpm1xigrhZO2a6arqzF+zvAPM0mpUG3bUmXcQp4hI2L6HyBn2/Qu3le9kuAVnnQBVjr0l9UGE2LoNdnkln89ZjtKKXToJ+d+xOv1GKByGtt3Iy6ZIhKucjPKaZm5yfIyq6wGTMW5kKfZJycmG7jV/TwmCWb4uYff4Z8UI5vEgfY0dW7kfh8fDFXB6eQWYqVhTC/K5N42+bCVi5j3b086IfXpZOfRaY1/64Rcwr6key8pE1bGGyWhgexie340cbKoNQ22Xx68PWd40W3cgZ0eZsT3byMuu7ZINX5ahdFNLq0BWrCn/f/b+PMySozwTxd+IzLPVqb26u3pRt9RCAgmxyUaAAHsYkC2DjWFghsv8NDMehjG+NmBjzTXLPBZ3wNiyGWzrh81ifH3xMsj8jBdsYyMPi0FGCIEkhEBLq1u9L7Uvp85+MiJ+f8SeJ08t3dVdS8f7PPXUqTyZkZGRWRnxfd/7vV/F3APa1wc6vhMAwIbKiJ6W5/HypdX4soVFYGExc3z03B8duAK8XzEC8zH4956Snw8ftfndvaDXSK2W0USJxogppkzKffZ5aDa71280QqQYZGx6Fr4yrO2nmWc586ZQzYaLxmR5WjYza/LISaGAaK9MsWJnJzLZgSTOgR06CgDY/+uHkYgLqDMWsCWQqXauhaCpQyXvMQe7tHMhshXM6237HP/1L7wUN+4fRqNjt7n768h3REmX8nrAxmHLG998ackxbrknYqUhGEBUngUcRWoIbmtMr6UUT7sDMb8gzxnHRmE6+t4RMDXBGgPZpQI7CtWi3fbri7r9dRTWs4xrs9AgwoqsjYwYxwM7N+FTrKNu2rYWEKFDAzj5Zkkl3v/FflBd67PeXVt72b4yZtTgtVK4cAzLeMYuTnrR2EWzBVpRRmuxYGpgZ4rHwRljahdTSDsPtDMmdaxEZBXgHXo5KRSMuAst9/U8v1uvGwDI6DD4oHRqkEol81kErONDXLkH0XEllOOkSejx9lIR3OuNomUdIuuF4GHfPuiOfPc2vrMmZ5fGFhAQEBAQENCN9NTqCq5FhCCOVsr57qadp/dtdeRJ9gwV8UMHRgCgd8636lApF6HaSoLxvUkQBNcCAgICtjkq6ch3srLgWt7JCQ9UtYCAgICAgOWRRTvXBm/kRL5753zbOt9xlL1vM5HBFy3eBvjGt7u/jnwXczSzfwEbgy0f+QYAWpb1kUWz5USFqR+l7PVZ05IVh1kw5lF8TWQ88Y83UU3GTBRSJI5AW9IdoSWEeEJsvSLKhobtUPYsbd53q5n63q2WjfI6UVzBqSmdRnJxd8S03cH+f5yR389XsKZ/S0KteBnj5j6YOuSNhqWyVargmlroljxjqZIdijIn2p3uOt+pqLOmtS1HWdTUfpEV6SPURK0NZR6Qom+aOrh7J2hdRuDZ5JRXoo2kI4HNFkisUwJIz7HU/SWnJgxNnXJhKP9EWEE44kTuDctguVJqWWkIAZc9KunI9zIS5vpfJRcRaHZb8JYHrBrUlg6jO8ZQe+5eAED50TNgk1MAln9np6nIIkkMm6p7X/m+iwb6APUuR7sDtrCgDs5+biMlMsrrdTPHJmfPAWdk+UpOiD2WEJA4p66N2DWBYm8lE5PAhBQ+SggBLcl5kFx9wPwzsaeeNmWwkuMn/c6o0lVsVpZYI8WC6R+EsNTwWg2lv39IbufMzAJ0YABcUb9JXwlEHSvKJUy+VFKu46a8lvLZDqZeKOnbhA9g4Iy8hvxc29LY2x3wM+fk5+MJmC7XRf2ScLofvaDn7+TocVNejI4OQ+hynVlrICHMeMTjO0zKWXLqNJLTZ7pP4paloxGiQZlCp9lqvNk0zxwAU2KOjgwbAV0wZud/GnmsRT3nZormMmbS+8BY9lgI7gi8dn8dsP2QaXxr2jmBYZCl2WeMC/zVw6cxtSSf3XxEjeGczvnWke9izrJavZxvZ77W59H7hrl8c2BbGN+GwpzLSUVqoDuXWxsuUQS3DnSmirdLhU6y35jEpZBrJcNCweQlsekZu7P+p6DUUrJTRr7XtqKx0/4y9NmJMkq5YyTKetTKm+XQraOdY0YRnal8eNMVTXlW/eCtFvD0CfklY93q2UC3MyJjOygxeWyask3KfRC65unCorku0l+2dUQbTcdRIMDnFuQ+udiosJvFR+qlYQzqKLLOE9c4zsVeHhuvp/K6hwYgWirvsJN4166NctruQAzKftDWkFnkyHz8jr0GNX7QfRWipyHMq9Xu8csALRZAymqRWKlYx0kUWfErx8m0ltSJgMsLa8n51pNzLqbQ1vdypckCAgICAgICsgVL+Soi319+YhLv/stHzd/lQoymMrK7It+drMi3/T4r51sb32Eq3xzYFsZ3QEBAQEBvdBnfq6Cdu6XI0iIyAQEBAQEBAT7SU6Ub+Y5o75zvQxMyUHbNrn78x5dcib3DJSzUZYAnXb6spQzqghP5JoRAE3bc/d2cb92fgI3Hlje+SRyDqmizaLY8OvPKB9NuGtUauUGCCxt1BSyVSUfG3UgyT9GmHVeV6S+hIKpPomPrSpOipCdHQ4NGVEwwbtoUncS2x5iJPntR63weZIdU7RRnJ8xxmdfcK9oNJe6m+12r2evV/VZULFGr22hskjiR734jWNcLgjFZ0xywarku24Axqxoex5ay7VKynUg+r9ftNbkuwh7Uf00RFLU6oChsrrp8WgxN9okDou31WUPTFjOZBWk4An2kkLfXqJkFPLHX4PSJUEuTk9so1pZHELBd0SW4tiztXBnfbt3QkCcWsEqQKDJq3fz0GRQUXTgBDKUYhCDasQOAnENcgU/zPnPe9zq9SjDupSMJFQFijIGoNujAAOjzr5fHHT9jKcXqmeftjmWEpZ9rrdIeRTYlLZ8HdDoU4+Cdljm/OUa3I4SscAIATxy210udOdQ9p0OxN+rvnTZQte93I+hZLICoOYDkc4b1JhoNq7DeaNh5tlLAju/mvMuj9Tb2HNfipG2IphU1NXNoHCPaIenqtRfsQ32nnGd3fvkkhFrfUDU2vNF0aNXCSdPrIBoeBgCwhQWrlF6pmGum/f2GKagZZbxWM/RtNjNr1xo0yp4v3bHkzM67lNrjHDq4ZsuJWl2eS0P3qVSyY0liEEV71xVIvIUloYZhKLitokOu2GN2YUeOL0vND9h+6FI7FzbnmzqlxtJG8PFZ+Tz+mxv34WdeehUA9M75Vu89l3YOSEG3RAjv36JtaOfL1xcPuLS4KIJrZ86cwX/4D/8BY2NjKJVKeO5zn4sHH3zQfC+EwPvf/37s2bMHpVIJt9xyCw4fPrz2ExEKumMMCz9yFRZ+5CpjoC6HtNFER4ZBR4YR7RxDtHPM5nap9nudlxQK8icXGwNIdBLweh28XpclP9ptOSHFsfwpFuSEHsm8IlIqyZ9CASTOyZ8oAm80wRtNiGoNvNkCb7ZkDnS7I9spl+VPPmf21TnkgjHwhUWZ/95syfPon0IerQOjaB0YBR3facqJ9ALN56RzghIILuRP0gGfnwefn4eo1WxfxnegeVD+kFxOTlpULhxoqQhEEYSQ9YJFtQrRakkDN6VeTooFOU6MSSp4J4FIOvK+CQ6Si0FyMaKxUZCD++VPX8lco+mn+knfe5F07L2p1pz7IZ0h7kJCcAG+uAQ+tyB/5ufNGINQO67OcdL7SHwDn1DZfkQR9ZfNvTaGc+o5M+11OmCT02CT0+Ye6zHQ/Xbvu3u9xMlNDAiodkW+lzG+nbIoeqEQIt9bG5dsTg4ICAi4jJF2VHO3zrdDO0+nfp2clQ6eK8f6zDZTEzy1r4l8x/7aUYuuZQuuadp5mMs3A9bd+J6fn8fLXvYy5HI5fPGLX8Tjjz+O3/7t38aIEy398Ic/jI9+9KP45Cc/iQceeADlchm33norms3mMi0HBAQEBJwPWilju8N6T8BuflqkJ/MwYW9ZhDk5ICAg4NIgbdwmnuCapZ13R76l8X3VWNlsizKMaaB35FsTPtz9g+Da5sS6085/67d+C/v378enP/1ps+3gwYPmsxACd911F371V38Vr3vd6wAAf/qnf4rx8XF8/vOfx5vf/Oa1nZAQDDwtqVCi0/GjnS512tB0czb6LbhRxdQKodH+vWBa6bPTQ2FVcEN3ktHWDNE2Z19TU5s5UXVKjGI6IcSqlsMRQ3MoylzXzOYcpKw8Y1xk0uwFFyCmf45/hVDkzyzIQ5WwWS+Y6CogReyy6ox3EhBNqVqqgXC1mBPC7GfqkJeKhvLFG81McTDaX7biYfJCvO8FY9Dx5MYPXYnS07OyvcqSpfq5ddWz+uy2lySWJidspJyoSH/mcY7YnFZbN288zq0IXCqKrtMaSJJ4tMosdX6Xqu/BpWOqlzJPpQ0YZf1CAYQkQDc7PuAyRNrLvpzgmn78IkLko8261VYDtg4u+ZwsuKVbO3MlAFA1d7HnXA3MqHm7UrGVK5w5zX0f6jnbY/OkKMf6Ncjm560KtqtU7vTBvLsFN7R03mgYqrRIEquYrQUy0+fUIAQkp0RSyyUrJtpqefOHoYPn85bGzJmZvHWfSKFg1gwQ3KRA0eEhtG+U9y3pjzDwiEwdYyMDmHmRVBMvzgsQrd5eICguqLaVxkNt9yDyVTlQg49OmzmG9FtxUt5sgivV9+LMLMp7xuX2ufnuNRFnoKOSoi6Zeo6zRq094n17wSan5T6dthlD7ojBmnkrlzf0e0SWMk5LRYfSnpgUAlIq2X4vLRl6u1Y1j4YGzXkEY6BKDb0rMVf3yUl/EITI+RpWgFWnuskLs2sk0miasSHTcyZdjJb77PMTHJiXBbpo5z1Kjbk539VWgpmq/D8/kBX5Ttf57hH51sa6RztP/JzvEPneHFj3yPff/d3f4YUvfCH+3b/7d9i1axduvPFG/OEf/qH5/tixY5iYmMAtt9xitg0NDeHFL34x7r///sw2W60WKpWK9wNAGrYLiyBPHgd58jj4oq/srWm6AAy9l+RiQxcGoTIfaWEBbGoabGoaaDRBBwdBBwd703YJNdRlrsqbuYZmF1Q/eLtjqdTOD293wFsy58pVM88Cb7XAFyvyR+cxp2jL0WA/2AuuBXvBtUAuZ+netRrEqbMQp86CV6tyUkg7DNy8ZkV17yrxpSnejIHNL4LNL4LPziH/vWPIf+8YRLMpc8m4MLR5VqnK3LRGo6fcIl9aAq/WwKu1TGOZxDk56XKO4jeegDg3BXFuShre7r3W+6vFTi8ILizFv9322nCp5L3Gx9wznRrgGMuEEEsNlyczFHENOthvaPneuZx9Nf1daxMAkM9eBm0fgKWgt1ogquRNQEB7Dca3yU9zIt9hwt66uKRzckBAQMBljLSfmgth5s/ISeVyHdonVL73aDmPwaJd6+mc7/T8ayPfPWjnzv6a5RZyvjcX1t34Pnr0KD7xiU/g2muvxT/90z/h53/+5/GLv/iL+JM/+RMAwMSE9NaOj497x42Pj5vv0rjzzjsxNDRkfvbv37/e3Q4ICAjYttDGdl55ypelneuFAiGgPcRhArYOwpwcEBAQcGmQSTs3gmtwSo1ZB/iJjHxvYDWR7zTtvNtYD6XGNifWnXbOOccLX/hC/MZv/AYA4MYbb8QPfvADfPKTn8TP/MzPnFeb73vf+3D77bebvyuVipnsRaNhI7UspUSpQEtFEE0bGugHOyXVVz1asqKAs+kZROO75L75XLY6teB+PWlPeVr4+7pYjZK64IZCTmLn/BkUaqKEvABAJPaaRSdB7qhcNHHYCDCv1Vfsg6F/EQLOHDq9UdS2lGz9t/pgo8Z5GXGlg/2mRjdv25QAWi4AikbvjWNsH0fBRXdfBTd118UKDAFA1vYWOnKXjuDr68q4dhBqBdN44n+vqeRZKQnO/eDtTnbkHDBtuJF5QzNMQ1MvhTCUN/2sZvXbfV75/GJ2mwGXHXRpsXI+Qjvhq458xxmTecDWwiWdkwlR6uB67kjNF+r9SL71qI3OECsOSfOSqQXA0K1dCMZAFaNHtNvePG/TyfxnlQ4Pyc2KfsxrdatArfurwDRdvRdcZXNzYmGo0rzKQQpS+JWOjAAjkg5OOgn41Iw9v27OoS7r97poNC3TKYrM+djMLPJfmwIAFAoFJEqtO5obxO5FVcUkoiYNijRbqPzQXgDAudvkWA59LYe+p5RCd7mIhZvkWidqCQzdd9ycR/ep9a+fh6glxyq/uGT7aFTFI6NUDkIR778CAJCcOQc2O2fGx6iJF4vm/oILmxanxkxUa4bCTwix64de2gM9tmvldjdljkSR7ZM8ge2fs02nHoAxQ0M3zyJjNrXMZbI5bbAFZ20ihKPwD7meCK/SbY007Zyn63xnlBo7kZHvDQCxrmggZDvauO4d+e7uQytNOw/W96bAuhvfe/bswbOf/Wxv2/XXX4+/+qu/AgDs3r0bADA5OYk9e2xJhsnJSbzgBS/IbLNQKKBQyFAy1xRg14hyXrQmHyeKwK6Wk1B0+HQmpdkYrlyATcoJjuTziMbkpIYkAVu0dHdzWC6WFGOkcohNKq+veu0Zbyk6d1eXItq9cGi1vJxmkXRfu6RRd7x2AEVH19eQce2ecZn4/TOLgVzOlN4iETUTKYljkCG50IDObx4atP1w+iOaLXtviDWyhbClSqSR7+dup50rbqkxUxqMMTvmcQy6Vz5vtN1Bosqruc+IWXi5ZW3c9pz7JBhAaOyPh3OsaLXAW851qv7TfM5M2FIdXxk0lSVbSo4SgOR6X29Kzdz0NZ9HNKrLsVCIJZlfxqo1CB4SvgMkNO28Lx9jvt7poqG7sDVJ4ZRFufh9DLg4uKRzckBAQMBlDO281n66LsG1FJvsm0dm8M9PSpvjwGgq8u2UIky4QF4d2yvybeZrj3bu1wQP4qmbA+tOO3/Zy16GQ4cOedueeuopXHnllQCk0Mvu3bvxla98xXxfqVTwwAMP4Oabb17v7gQEBARc9tClxcoFOQEvJ6BmvPSEmByyZJm64AGbG2FODggICLg00DGSnGZBpgTXtIHcYQJTS038hz96AN8+LhkZV+/0I99RZI1vN/WrtULOtztdpwXXQgrZ5sC6R75/+Zd/GS996UvxG7/xG3jTm96Eb3/72/jUpz6FT33qUwAklehd73oXPvShD+Haa6/FwYMHcccdd2Dv3r14/etfv/YTUgKYCGmPSB8loC2lQJpSkPaoxoCMOprotVXX7gVZP1tFAJT4FgBEIypi3e4Y1VQAJtLZi/5NcrHZRwgBqlQzMaQiEkdP2n3j2FKg4KiqutF2SjKVtjPPnc/ZiC8XHtXcKKzTyFyPSBIbwc7FJrrNVXSdNFuGFeBeFwS33Y0iEGJVw4mOKHNuwm1GyT3FcDBR8iv2AKekOqtotix9vdUC9PgJYRRLDcU7ikB3SqXWuZfuw+DTisb39JlsWrnLBBjfiYUXSTbF8LdkGgObmrbX6EIL/Olx0Mq+jaa9fw5lXfvEXOp9V9TbpVuq+5E8+0rE81LNlRw+LnMOAgLgR76BNQiu0e7JPGBr4ZLOyUKKbBpaN2w6EX3m1eB9ilL8yJN2LhbCfPbZTd20YJLPm+2CMZVvJVWyo4EBudOuMWBRMYBmZsCmpdK2ZrFF+QTMVdrW7a3i8mipZOYMPT8lZyfM9YoksddVrwPq3C5ILm/TxRi37CdHzZu3nHlBMbzo4CDEuDx37ZpB9J2S8xWZrwEtlYo0WEYyIudqXhjEwjNkmwPflNtGnmrCLGqEwPDfPybbHhtB+1lyPiMHdyNelGlhxXsfs3Pyrh2gaj6yLEBhNW3jGMnpM2a7UbBPEnMPPfo4IWCLam2iFOnjPeNmPHit3pVipY/z/owdxpjDdgQA0lcChhUjb6FiKPKCMcN6o1deAUxMm+3Ys1N+PnqyiyWZXj+m+6Kv3WynkZ/iEOdCBZJtDp2ilY8o2gkHSwmuuTnfM0ttY6y/5WVX4dYbdnttxc5a3o1Y98z5zhBItaXGaNd3ARuHdTe+b7rpJvzN3/wN3ve+9+GDH/wgDh48iLvuugu33Xab2efd7343arUa3va2t2FhYQEvf/nLcc8996CoykOsGoJ303Fdo0QZUJw3QI6elttcQ5hQ87KmqtQYCIFQE5lotvwcIfc4bRR1EptPXi6DqlWqNkC9vrllsHqAxLG3CNAlOlwVbkORF9nXHe3cAV6VE7NoNDzatDGodckMr3/C669L67b7OZNRFIEO9Jt9+PyCbMaZoKiiokcjQxC6T7W6XWx1EnO90egwSE4b38KsEbSxLJgdBwCgI8NqaHimsSwYA5+YVPtkv3CEyosefSCyTo90W65jRu+zWMHwd1KLgHzeLuSE8MaGzcpcQtHu2LEnxLsekbLbPep9Vn9UX3Uplei7T4GoMSHFApA0Q35ZAAA7AevI9/Klxroj34GqtnVxSefkgICAgMsY2nmdi6xYmq1AS4yCecIFGiqCvX+0hP/7tTd0tRW5xrfDVuuV8x1laLRox3uIfG8urLvxDQA/9VM/hZ/6qZ/q+T0hBB/84AfxwQ9+8GKcPiAgICBAIWHc+M505HvZnG+9UKB2oRAm7K2NMCcHBAQEXHxow7cX7VyLqDEuLH08FcHW8HO+7ZzdK/Ktd3fn6yy1cyGECRQFbAwuivF9SUEoiHn+Ihnxg4r4agju/W1oSoCJ6JI+Scs691P7sefzxwAAzIkauzW83SiqYAy8IiluJBdbpdYscawosttTQnGGJlUqGtGsLJEtQp1oqRPJNt9BqabqCG2vRbNRKyWgWmnUoXgRShCpKCrgRNmTxKp1O/+8RvEUMDR8kovBd8o26GzF0uuKBYiGVjy1UWZRrYFogTtHzIeoKDnJ50wUnFACUW+YPhmlW6evBN0ibS5EJwFTUW7KmHkGeL1uxo3kbNTfZQ7wag1Ut7dLUgGpECb6TwCIfVJJFhOzPn3crT3v9idFcSPUqgC7lDqoWt7mOBUdF80WhCMWSKIoUM8DvLJi5fzKOd/MiXzryT8Y3wGrBs+m6rInDhvqNyc0k1YOwMxHRgzTif6IZsuoeUdDg2Bq7hWdNphSHEelYhWmXQqwfo+3244wKrPK2IT69COdMhXnLAssn0Ny8rTXbxLHoP2Dtm1HxFOzkrz3NWN2PkjTmKEo9OOK+jzQZ5XjC3ksPmdY7sMBelK+6wVnwA45rqTZRvTwKXl6ALv59QCA0++QbTzjPx3BYx9+HgCg/zgDVdRwdvoscnML8jz7xiHUQt1NbaONliFS6TUUydux4bWGSQOQ/VLjUyjY9Yh7vR49W71nZmbtfeq0zX2UY6zYiYWCWSMJxmzbjMn1CRzCV6MBaPaiS+HP50H2qtJ6i0s2DUEI4InD6tryXipAFwgxzzObW/DT4tzqMFDPImcQncA53+5IG9+M+2wyN+e7megIdrbxTSkxwm3uHHw+kW/3HFwAUbC9NxRb3/imxLyUydAghHr4aLVujDPeanmGojHQGTc0dDYhJ7I9X7DUdDfvmfaXzQTHj5/y8pBN+ausfF84hnVEzeQglc/t8Ov8KL6w6BnMVPXVM7y8ch82j1obYWzOlkshUWT76hp7jgGvFx+0VESkzkeGh9C+Ql5vUo5ROiVp9LwvD3xfTk4iSYxhDAB41kEAwMwPDwMAxr5XQTQvqeYo5MH3qJy7uSoirX6eiyFUThkfLEEcPdM9fjpXu1pDNCip3ODCUuvTBraejAFvkZWZZ28o5QJC5aMJLowjg/aXQRT1ks8vmJx+wOa9Ue3YcdXdBQc9IfPQEfv/Zvb+suxnQ4EODNj8t3rd5k7uGDPODt5oZlLXRbMFkeaxB1yWcKPcfYWVc77dsiihzndAQEBAQMDqoOfKfKyNb+7oqMBhk3E0O34+dhZiStBhwitN1lPt3OR8223pnG/dR5fSHnDpse5q5wEBAQEBmweuoa3zvpannTuCaxkCLr1wZGoJb/vTB/HY2VBfPiAgICDg8oNVO7d6KVmCawkXTgQ7O/KtjwGyI9+FlNG+HO285EW+gzN9o7H1I99cQGhBrnbHyPIKWNoayecBh+7jCmqlo9VsatpGyVOR0mRcKpjnag0kk46Kqd6vV2TVpc05Uc94r1QXFYU8+LFT5nujVh5FoLt2qHbUInjGEYBzFL8zhbl0e1Hvf2zBhay1rburqOZstB9U54pM1kHqcoyjxSq4VjFlzNDA6eAgjr1e1pt+4uc+DgD4V297G/pnFZ2rkyA6p/rOmIkGL9y0BxMvkZuf9UfzRnBNtNqG6mXuB2NWHZzz3pRy/ZmLTNq9psx1UQGzFM47CZCzaqX2AHuvtZo8Xap69HJekxFxElEnwu7Qzgi1fch4Rni1ZlkaXIAqylz74C7kj6jofqvVJdQWEOBCG9+5iBhvfCdZDe0ca4p8/8c/+jbOLTZx/9Oz+P4Hbr3QbgdsRdAI0diYpOECXRR0NjMrPxCb7oTIEbtk3LxPoRhZJM5JCrKGVswmBNGQpnt3LCuJM3NeEsfm3cvmLSMss+uFHIToFiIVbppPs+XMucJ8zyqVrv7Fu8dBGo7itz5PqYDWSyUdPPfVR0AV80u/68noCBpXy1Sm4rkqiJqXBCGo7pPXkl8Q4M45I7XWESODoDvVmqHTAVH/5zv+XKZUnXp0N8o75LzU2N2HQkGWm8udngVXaxpyZtJWedk3jsbVwwCAwmwL9PtKOFSleYlOOzN9IBoeMkxBUSyAnFHCpy3LHBMdJ11MjW80vgtQ85xYXDLpgrzVAlvIcOoRAqrSxdDu+Old8oPtl2AQLcuKw9PHAcg0B92GSBKbfseYEYxNnrkfABAfPSermkA+l+Z5hkwXMNeWRbNX/Q0iqNsbmjlmaec255sSgkilzSRMOJHv3mt0mSPO/VJjK9T59mjn2vjO230Dk23jESLfAQEBAdsYevLNR9QsCJar2+3SznX1u9WonZ9blEbHUivDiRUQEBAQELDNwbpyvtOCa+cX+U4yIt+rqfOtNV/cc4TqJRuPLR/5Fkmnd651OnIKFaUUqXJjbnsdKygGQk0UmtcaoA8+AQBInAgpLfeZnHM2PdPdF2HLYAn1twY7c0620V+2HmBCZa6v7u/UjO2XadKKtunPNJ8zeeFeHrDgJjJK4pxfX1T2wrbLOIiO4lYawIz2cidgKqpAImpLfNUie84rx9HcI/v4vI/8AgBg70QFvF96lEmzBaIiwXxh0Zx/6J/bGHpMiay1OxBjsm0ytwhRTez1QEUganXVj8hEDIRDoSWRLR8nWi1vvL38aiiBPH1vnPF1mQKsWgNUbjmhxIraeUF30t2GI4wnEt6zHJ53bIo5IRIONGyJOT0O0QOPm7uWbteMiRAgQgAtBFzmMJHvmCIfEW9bFvTE7HrpdZmTU3N1fOreo/ivP3IQV46VL2a3AwICAgICthT0kizfQ3DNzfluGLXz3nHQLNr5SnW+WVbk26Wdh8j3hmPLG9+0r88YJV3GixYmc4xor3ZyFk0cjkonJSClktzWaEC0M2jOnKP1LEkfj2fmALL6h9rQi2sNv3azolqRfD4lruYbgF4/osgYjVF/WRqNqWsk+RzIlfvk5sPH5bZcbChf6HSMkBep1exbpGMdHCSiENqtls+Z80czFVzz59Lwa44qsbJaC2RJGsui07EULGrFxUS9DnLGoRRqKmK5zxi9nkPDNWiZNaL1tdPxnRBuvfEMx4y+p55qeHo3PcbeqQWi0WEAAF9cstQyV0BNP2fpe+conLv108keqYjOT5wxwn0uslXXffE4T71fb4sikMBHDwDQTqwnPlYLgvYytHMv8q3/DdRk/tnvnMSffesE+goR3vfq6y9irwO2JLhSnM6aW91oixDgmj5OI/NOzNrfo5zTyDosubAOyd27wPfItKf4xBR4RamMt1r+8ct1vdlENChpxigUrABnter1XatXazFU7lZWIbZCBduzA0RXLnHPU6+jcP+Tso0rr4BQC2jeL+elaHoBua8+ItsQ3KTPRSPD2P/Z47IP5RJwQM7lpOlc37lpQAUDxMgg6ntkH7/x0T8AANz4oV9A/4ScF2hHIKoqcdlmy8yL/Oq9IMrZRk5PoqRS4kg+n82Ydu+rUifntQZE5aQ8jhLzTiGUGOFQTyhUrQeSM2ctjZ1QP23B3W4O5OC1mjm3vidaxd2tXJJOgdD95q1W5hzqOvvjI1I8lS8sgur1wzOvApTRRB4/Cl5XgYFCATSn0sWcYA6JY1DeAupdpwrYRjC089ga2V75TieS3brAnO+V1M6FEEbfpZASXAvYWATaeUBAQMA2ho5yu7Tzfzk8jdf8f/8FD5/szoP1BNf0ZK62LTUT73dAQEBAQECARFepMZEq3+nmfJsa3MurnQN2XhZCLBP5Vn1Q+7plRgtRZAXZAu18w7G1I9+EguzZBTqpqNmNhi+0oeGU4SJRhGhsyGxnugZkZvs5kIL0OvNayl2p2ueNJuJvPKo2OcJlDnXdRFcF97y2kfJQ81YLcKKeWnCGJEm3YJgTOfWo6EniiXvotk0EHADdMQospjzxzKedGxedELbfbuSWUluHnHMjEoMmRW5CRhvieRXZXaqDq7JngjG/7JceB8Zs7dAoglDlu7gW7FkOOgrebps2+PGTxotNS0VTx1ueQNXo1jU94X5FfPZBlvgaAK6unZaKpp64eTYEB4itf2rbcEqKFQqgA6pcWiEPsaDKlfWXjefcrbdurrGT+DW/3WFwa5w73eYi1BQNSAmuqVD21FILU0st/Nc/eRAP3/Fj3v56vqZOTVKdb6Y97s12YFUEBAQEBAS40EayzfnmHpvMqKCvOedbzuMtx1boyvk2kW/5t5telo8pKCFgQiDY3huPLW18E0ow/6JxjH5dUqc4AGiqbztFNTMGSwR+5bg8vsMAbeRl0ORILgYZlPnXZGExU1XapYBLSrt6qk1+cWQNKGb3J4WCp6qZiSgySuS0rKhOXEi6NwA0moZ2R4Svli0yzs8mpnzqMnyjk+RzlkJGiMmVd+tFe7nJhBqFcF6dBdH52Lt3ym1z89n5+I4xLxJulVX7+owaqketdh0WKh+e1+uZbZN83q+N7dAZu54Jp21aKko6vNqP6BrsjPmUf1fxXNPvVT9JnJNjCHi1vV2qHR0cgEhUvxcrlmZPaE+DX7ehnwFW6VGzPCAgA0ZwLbaRb41qhjiaWSgQ61nXE36jo3/3Nr7zUSBUXbagkffuA6wKtEg6yFz1CW5VsGnUTQ92m89berBotcw7nU9Ogyq17qTVMuehxSLoM66S+wzK92dSzqFwXDrs+dSMcXrKA9T7fdcoxFPH1IlcXQ3iOUQBINqxA0I7TlstOy9970nbHo28d7a+XnbqTJcitvcXIeY8yeSUNz9rpXcUi9YpPDwE0VcEANQPDmPmufL/98Xv/XkAQH+Vof8plVo2PQcMKN2GoQGwp56Wnx+ah1DzXHzFPpCyUgKv1SGUqKJxcPeX7bwqBIhyLJNyH9gpSdUWzKrPC24p5i5F36OGO+rkWXDnU95sGqo7zefM2Jt7Sgji3XK9x3eNQDx2WDbtjrkQ2akJhMjACGCU971gyiOPWyp83lE6b7VMMICWy2j+yLMBAKUHj4LPhDKM2x068p3PUjunxDOmV2N8pyPfrvHdM+db7dt29s1FsnQogwi0802AsEoKCAgI2MZom8i3zfnWGCh0+1+N4Bol6FPlSRrtRP2Wi4XljG/t2Q8ICAgICLic0FXn2xFco8Qa06stNUZT7DOdJ05J91wbabVzdT4991MCxBHV8aVgfG8CbOnIt+ACw59/FImu7+nUvSb5vP0vELYmtGAM9Anl0WbLRxBJHEOUlIBHX5/vIdeIIu88OrJt6ka6VHg4Ht5WK5siDyc6TghIWXqxSb/0KItSAcShhkOLzckD1S9ua566bff4h6MleY7mS56J4nGVAzq3AL6oRGtS9bBN/yIKoo4V7Q6EPudZWdOT5HNAR0XPk8Srf5AZtYb03AMAkkTWbQdsu4IYqjcplQBH6EaLxdDhIfBpFdVodwCedI+De059Lf1lEB35rhHveXHZCvrtxZ2oi7mmpGOV1Mt9gBKvE1wYOj+fX7Dq7IKDqGvjTo3SHh0F9u0GAMSjLfCJKXmcJ/bjC9EEBAA27ysX0a7Jur/YPQW4yqxaIbWujO6WYm00lqGd55dRbg0ICAgICNiu6K7zbWt0eznfHu185Zxvnop8F+LIZ2LCLE+t8Z1Yx7s+v/t9wMZhSxvfQDeV2NKXEq9klLODb0SnSo25edlCCNCqopPlYml8AZKKrB9eNx8aMHRzj3qXYQiJ9HFOf3TpMuQslUlTzflQH6JZaRRzlR9tjlO0ZNFJDE1KcGrP4+aca+ocp+ZaiqcWQVqKtu8o1tJCweSh02LBGs6UGqOSlkuGHkeU40GOFTfjxFkPQ1jnYi8sWpo4IfazLo+WcGOI01LRnqdUBOlT175QMX1diwFK8nmjMi+SxNLJ4DxT7Y6fv78MRLPljHXHMuiEX3ZMOxhkJ6wuAYAuyrxQqrPsedcg0vfedUBEEehgv2mXNKpASPu+7OEKrqUp4eV8hvHt5KdpQ1pHurXR3VyOdh6M78sXnIHNzHqbtCaFUYmGnKN8B6yeJzKcsnFsy3kuVgwtmThzrFFOT3en2QQOHZH7q/m7sHsXREXStEW77alom7KWjz9l1w+EgCrnN4komD5WUZXZ9LShPnuVSDizUinFoqE6u5UwEEWm8kcWoqFBEEUvF9UauK4A0m6blCW+VLXpWrWaWZD3PcVw1aQq9dlSaWbTjsYNF0YpPdk7imhMlfykETAqneDs+ClQpQDPrt5r1NG1g50tVmz1jigCm1b3fmraUtPzOYCqtZPngOd++hsA2u9c79KSdcC329Yh7urbEIJoRPY1ue4AcucWZL9UGVfRbiOZkH3FuQl7n3J50CFV0pVx+VwhlTroBHP0tmiw3wQx2NISspTevWeYMZS+9ZT8WPFV8wO2J0yd79gKrulHiqZyvm2pseVyvq2xDvRWOgcyaOd67ld9oSkKe8DGYcsb3wEBAQEBvWG83zHpyvnOiny7ZVEs7VwZ3Uk27Vw4i8r0OQICAgICAi4HpHO+ORcem8zN+da+qPPJ+U7newNWnE1Px67j3f0+RL43Hlve+I7274OYlVRpWa9RCXE0mr2jlIae7StcA77GB6/VjZK169Huilo7bRBVGFooRW0hRFe02ezrelWd6DSvqTrfRW7Ew3TNUXJ2AkzXyPYiBxGgakaTmQUrYJO6bluHWgu42XPwoydtNCFFCzfiLpSAmD61jCcelCDaLc8vlAK6UIIrgBKM0/dmqWo9/+manbrGeRRZr7enFm9rc2rVcNJXAldiOx4N2730ONf1PJAoMtfLpqb9A7TImkNvF0nH9pfQ7ucKMDVZqzdfhfI9SgU/cejtcWwiQKLRsMr2UYRoTNap1eMkWm3weaUWz4WN+j/yFEQuuy4pV1EZ6bUnIfIdYL3fEUWcop0vl/MdEYKSioxr2nmvnG9XBCZEvgMCAgICLkdog1pHuBOHdu7V+Wa2BvdytPNeFUeyjiE9BNf0nByZ78/nygLWE1ve+OYzc+ZpJ4T4NN4etG5Nk4p2jEHUpPFoDN4U7cg0xZBNY0/vx42iQe8+qPNoijqNHVVNOMZmKl8887octe5kRFLMomOnPIVuU2bNPefOMdlUtQY27yhwasOaC1/JXZdFGxsEqSlHwMy8UXmVJ5Ztn/sxaYTv+fM5a8QXCiDKYCSttqe6bkpluaW+uEDUL/PJDRWQ2WsXncSMsYgjm+Oehk4hcJ0JehsX3vPS5WABQDod/x44VHyo6+FVafCSOAeoHPjy8aoXDTTnyOeRXHcAABAfPm3V9gG0r90LAGAF2b/SD05nXpJgHCTLqhYcQhtBhEIEGygAbqmxbtp5X4bx7dLO0znfWiCm0fbfa3UnBzyonQdEWrtj5xjEmQkA0jGqqciZ6tIAopERmxZmuJrEUL1JnEO0Q9KjeWUpW4elB7TDNzlxym4kBNEznyE/1ptg5ybsV8qRGu0cg1BzpEt79+CoebspS/ozyedBFa2bTU5ZCnoUgRbVPKfWANHQoJ2j9o1bmj0XIMrBTk+fA5ucUmMSgzz7Gnm+hIPrKBoTYH3yGt77F38KAPg/P/c2DClR84FTCUrfPCT/OH0GXDl9o/37IFRUjQ4OAvpePfg4WEZagFDvAlIoGCe9aLdt6cxOWi3eKrZTRZ3XVHM4TmbsHQdRZWR5o+GNu9HU6SSmXCy5b84qxetxj3NeKU57n2x6BMnlEV1zlRyyw0e983h0c3U+c+9i6wCPdoyZEqzuMymSBKKh7l8UgZA4JWd//vjN3/xNvO9978Mv/dIv4a677gIANJtN/Lf/9t/w2c9+Fq1WC7feeis+/vGPY3x8fH1OGrAitOGrDV7O7baIAnFmzvfKpcaYsnP0HJwZ+U7V8e4E2vmmRVglBQQErIjf/M3fBCEE73rXu8y2ZrOJt7/97RgbG0N/fz/e+MY3YnJycuM6GZCJjqGdU5OHthyM2jlxaOdKz8HU+U5Fvuttu6IMlLaAgICAi4fvfOc7+IM/+AM873nP87b/8i//Mv7+7/8en/vc5/D1r38dZ8+exRve8IYN6uXlCT3/WSOb+7Rzr873ymrn2vj+9H3HcW6xYURPsyLflnbuU9SD4Nrmw9aOfAsOXqtnRqRpqWgipunos/a2dg7sBH1Yej97UdRd9XQ6Mix3qdVsNNapzUwoMarbIisSS6hRFhdJYvqBKALcCKymo6+gxg5YUS5xYC9oQ9PReeY+AKxYiFLLBoB43x751excSiVdXfvQIIQWJFmsgCiBk9bzDyL/PakcLxoNQ/3e+/fKuzw6DNJQ7TEGPia922SgDzipaoA2nEW8c62EEuNhjvZKr61otqygC2BFV87YaEU6jUBHs7ME7kgUGQ86q9YyWQa9VMiFEKbmrK49DgBEUe75D57Kbq/RRPRdGW3gQthnV3DEj0hhoFg9i6yT2BSJnF9jXN9jEkVWtMal1gPZdc3PA8tN9P/wD/+Az33ucxgaGsI73vEOvOENb8B99923LucNWB9otfN81F3nm/HuZ5s7XvpSOue7Y2nnQgjzTLqR74SFiT0gICDgYqBareK2227DH/7hH+JDH/qQ2b64uIg/+qM/wt13341XvvKVAIBPf/rTuP766/Gtb30LL3nJSzaqy5cVTM63I7iWRTvvML4qtXPtAH/g2Bze/ZeP4s03SeZkVuSbOLTyI1NVfODvHpd9SeV8h8j3xmNrG9+ApNpmCe+2pTI3AIBzm1tLCaCM0XhmSRo4qp3s5i1lSNRV7q9jWHuGLWNGMdvuQEFLimrnlM8iudgomINx01febNmcZIcy7l6vaTrOGRVYERFE80oFPaLWCItsOQKRJNYgZLp7xOSnk3IZcJ0G2pBtNMFUbjeJIpPzXWAc3r+w9qZpR0K9CaGp3O0OyFlJISOFPKDvTYo2aKhclNh87F3D8lJOT3vGdJaDQxvEgDJQXaX3DPBGt0ouycWWfp9REg1QDhKlbioOqFz70+eQ6Dx39z65ziHBwR1DxaO6p54d12Fgcu5Vnz2qvqs5oJ0xnfXhtoWJfuvD1vm2E79GlqHsLhT0xF9vS2Nb53ozLvPV9AKg1rLPWyfDoA+4TEAIovFdYFdKh2n01En7LiLUo5vr9zuJY+NMZErjoheE4EgcarhRr4669VsAqdPhzimAejdq+rQQgHIaC0KdlDNh3v18bsHMobRQkGUkAVvRZHQI4rSi1qcVsDV9vN2GUPTo6MAVqLxAjk//U4vAiTNyX6XrwhYWLXV9YcGmlj3nWhx/vaSu02QUV31GVb+YmAL/wWE7JLp/B/ehclA6+3/nR28FAFx99ltWhXx4COy6K2Wfnj5jNVYiilOvkWlpA6dGMPI16WCnzRZ4MzUfEmfcqTP+jDn3I5UmJ+zYm8ok2qkuuB2/6Wk7DqlInb43ycueYwIA3rOj9hdJx6QPZOrgACARBR+Q4xRfdQDstFJK77TNc8JU2VA/pYCa9YZod0xQgjAGrtIZZSc1TT3OfEbXire//e34yZ/8Sdxyyy3enPzQQw+h0+nglltuMduuu+46HDhwAPfff3/PObnVaqHljE2lUsncL2B1MLRzR3CNZQiusVXSzn/pVdeiXIjxD4+ewwPH5vCTz5XBskJW5NuJbH/4nidxaFKu7UfK6n9eZ8WGyPeGI9DOAwICesKd6F2sNNH3QqvVQqVS8X4CLi5c0ZW0GFqWB1wLu+QoNTnfjQ5Dhwm4uzedvG+37ncnCRN7QEBAwHrjs5/9LB5++GHceeedXd9NTEwgn89jeHjY2z4+Po6JiYmu/TXuvPNODA0NmZ/9+/evd7e3BSYrTZycrRtmWC/or2MjuCY8HRVb/3t1tPMbD4zg9//9jdjRn0c74fj2MenEy4p8u3W+zy1KZ95z9w3hAz99gzy/Ns5D5HvDse7GN2MMd9xxBw4ePIhSqYRnPOMZ+LVf+zVPfEoIgfe///3Ys2cPSqUSbrnlFhw+fHiZVleA4PZHgRQLUumAc4BKlW8TNa3VIWp18GMnbRsqgkjyedBSCbRU8gQ1eK0O0WgYhWrRSZQHXVIvCZFCbeaHMfvTakmvKxfS+04JSKkoPaJJIr9vt7tpwlGEaGRI/gwNetFPwKpb80oV4rHDYGcmwBQFm+RiEwXl7Y7sc0YUV3ABXmuA1xoQzaY9Tqt567ro6rNIOuCNpvyZmTVjIoQAGegHGegH3zkMvnNYHruwKH+qNVm3c2kJbHIabH7RF3qDiqrnc+onL+n4UYTo1BSiU1PglSUzvoQSkGIBpFhAtHcctFiQNciFMD+SFcEsLTuflz9RJKPRirLt1hollNj91E8WSBxDjI9BjI+BnD4HcvoceK3hPWf6eNrX5z0X7vPqnl9fbxZYpQqu6rx6z4n7zOdi+YxxYa/xAhAm+u0BV3AtTTtPMiZhvX8cEUM7r7dZl8K5+3fNpZ2HyPemwobMyQEBAeuKU6dO4Zd+6Zfwmc98BkUl0rceeN/73ofFxUXzc+rUqZUPuszwZ986gRf/xlfwo//zn/G2P3tw2X21YZtzI99O+U4d+W4l3Kqdr6DFQgjBiw5K1su9hyWDdKU637NVyWb40Oufg2t2DZjz6+8DNhbrTjv/rd/6LXziE5/An/zJn+CGG27Agw8+iLe85S0YGhrCL/7iLwIAPvzhD+OjH/0o/uRP/gQHDx7EHXfcgVtvvRWPP/74ml8qJJ/38641DZxzmxMMgKq8XF6tWapTBhWZDvSDH5Sq0/TIaVNKSzDmKZJrSHVpp+xTuk3BHeo4M3RvvlhJ7datsEkiQGh10wVFDa/WDOWYUJLKVVdGZK4E2qfLWTUdCnVG/4ilqItaPVPxuyclP0m80mSalk8Xa+Z74dD6RRYT2qVMFwomZ5rkcoC6BnZG08D8BkhBGsadvaOIZuZsP3g37Y+k6LamvQylesI5iCpjpqmCmdeu6WmOsr0x5F26/ypzr42hr++HS0P3niNk0td4o+HkiMe4ELlzPdF/6UtfWveJ/vbbbzd/VyqVYIBfZLi1PnOpUmOZkW9mFw99qtRYo826RNZc49sVXOuEnO9NhUs6JwshVbiVEnd20o5817s0Cj1vk4iCN7tTgfyDHSqypo/T2Fe1dh0Larsu8UgIAahK82o0PEqx0VtBZN7bXXRltX6IFM2YPXnEHBft3GnKguoypRpUKcCLmTn0/fVxuU+v69P9pxHiA/vkvsfO4MCvHTLXZ/7jaIToapkHSjqJGR/2+BGMnZRpaXOvuR4AMHRoBNFZSfHmixWQ7z0l2xgcBFXUVH52Evt+Vxpg0RV70bl6NwAgPtRBpOcoPU7ttqFY83odRI0ZiWPE4ztV/6gNyeViQK0T2Oy8vWe9aLDCfUbkuWm5ZNTvo689bJ8xlwLvrlnUfBrvHgffLen0dHoBXM3tvN0B+Z4cV+ZcG2hkny99ijgH8mypjo9Dx8yakCQJxPTyqV4iSSDE+df+fOihhzA1NYUf+qEfci6N4d5778Xv//7v45/+6Z/QbrexsLDgOcUnJyexe/funu0WCgUUtP5QQCYePbVgPj9yarH3jrCUbpvz7df51qlf7py5XORb40VXjeIfvz+BGWVUL1fnm3GBmZr8XxzrtwEkU2os0M43HOtufH/zm9/E6173OvzkT/4kAOCqq67Cn//5n+Pb3/42AOlhv+uuu/Crv/qreN3rXgcA+NM//VOMj4/j85//PN785jevd5cCAgLWiDDRbx90HGO6O/LdvfzXOdsxddXOM4zvtmt8u4JrIfK9mRDm5ICArY9XvepV+P73v+9te8tb3oLrrrsO73nPe7B//37kcjl85StfwRvf+EYAwKFDh3Dy5EncfPPNG9HlbQOtGg4ArU4vl6KEEVxz6OW+4JrcXm2t0fg+OOb9vVzku9JMTLrZWLnQ9X2wvTce6258v/SlL8WnPvUpPPXUU3jmM5+J733ve/jGN76B3/md3wEAHDt2DBMTE16u6NDQEF784hfj/vvvz5zoewpCEIpoZBhsfkH+zZit/+jWyBbc914voyDO5hYQK0+/2L0DdErlSCxW/MijGzFV3ttoaBBE1+xU3nTBuE/31nWqVxBSk79jkAklBqOj+JSY76Pdu4COPDebmbUCMc2WyScg+3aDzEghEq6E1eQXTv3rVD3z9D6Ggp4GcTzahBoBNKHYAvya/aA/kAreXawBHaGNIhv16OsDRlSd0IgCU0qJ3omeGyo1oRAt6dmLHzsGlqVsT6jdnxJbWzwjMu6mLYh2x0S80/vqCDpvNDwvPyDZFSZaoqj+BhkCbF7bUWQi+VzVC/WGy1Uyd6LeVFP0ATD3/q5CKX85hIl++8AtN9Ktdt5bcM2v850sTzv3BNfCzL6ZcEnn5ICAgIuCgYEBPOc5z/G2lctljI2Nme1vfetbcfvtt2N0dBSDg4N45zvfiZtvvjkIoF4g2o7x3UxWML7Vrm5utyu4pnPB3SokUQYzM41n7R7AWDmPWRXR3tHfHcTQxvX0knw3l/ORSR0DAu18M2Hdje/3vve9qFQquO666xBFERhj+PVf/3XcdtttAGDyQcfHx73jlssVvfPOO/GBD3xgvbsaEBDQA2Gi3z4wtPO4m3aelfPt0s71xN3scC+6LbeFyPdWQJiTAwIuD/zu7/4uKKV44xvfiFarhVtvvRUf//jHN7pbWx5tZ07rMBnJ7mUwa0M759Tzdst3po/LUi3PQkQJ/t//fBO+cWQGffkIb7jxiq59dNPTSzIYNZYy0LXvPdDONx7rbnz/xV/8BT7zmc/g7rvvxg033IBHHnkE73rXu7B37178zM/8zHm1uVyeqEgSm1tLqJPf7Auw6frVxIkcuxFpt4QVm5iU2xZLIOpp9epEE2rbcPPMcnm0nyXzxXOPq32XlnqWqzLIyBMHoITYVH53ZCPFiFX0dWHRutlS0NdLz0zI/Dp9nbq8i65H3mqlanvrHalXgzqrnBspFmyklzFTLk1H/0nCbVmWVOTbyy3X41Or2dJjlHaXbXP2JTE11yLa7cwoL6HE0wDgbPmycvYkPLNGdzpvPH1f6WA/iGICsNPnerIFTJ68U/pNdBLDGECWV5ISxGM7ZNuz8/YZEcKyOpyIuOACWNmZekEIE/3WQMcpNbaayLcruNbneM0X6r52QS/aORdSZIauwpsfcPFxqefkNLTeCtmzy/Id5xaM7glvdfzcXv1ed8p8WsaYMO90OtBvjmNz8+YzyeVtyUXGzBzF1XxC8nlQNSdSZzuEsOfMxWYfVq35ub/qM69kMJQGyuBXSJ2W9q4Scksq3/zohGHDkYEBUM2Qa3ds22odE+8eB0oqz76TgOsyXIyZPokk8TRtsCDHUkSROQ8dGoS4QjpURr4t1zTi3BS4W4ZU53B32mALqpRqp23zxs9NIq6pcRscgJiVLLoVS8KxVEm4DJA4zua/qnNH110DrVTFj54wZerYYu+8aS1Ky7SmjqPDkkxMGi0CDthzE2LXN0KY0mC6jJ1/XQx47LDtv8sgzCiLRgcGQPbL0lDi6EmgmQDraPd87Wtf8/4uFov42Mc+ho997GPrd5IAtFLR7lbCjB5KGpp2noudyHdGnW+N1VDONZ6/fxjP3z/c83tt2E+pyLeb7w0EtfPNhHU3vn/lV34F733vew1V7bnPfS5OnDiBO++8Ez/zMz9j8kEnJyexZ88ec9zk5CRe8IIXZLa5bJ5o238R63rUgE/vNQrUcWxrfudi0EH5siaqXiObmTUGPHcFyNKGlN7uUJFFs4n8CTVR9ikDNI4g5tRExVg33TzVhts/V0RNMEc4zH3hmyYcsRinxqZotw1t21P2VpMaHR4yFHVXsIvmc8ZA5/W6GRM9bgau4Js+f780uOlizRr2LnXdqU0tGAMUpSf9OtDXYx0jjnHJmHHj8RuuBh583PbDocuL5eq4u6JlnvCa3xPTj3zeODuyjHN25hyindJAdsdIJB1zrqi/DKhnmXBmBf06iSfc1tVVQsy4koVFJfQHX4TOufZoZEiKu8x2X/b5Ikz0WxN+5DuV850hjuaWGis6oi5zNf9d20twDZB544WMxWvApccln5MDAgICthFc2jkgmWB9GYVwZKUd+dnkfIs07dyfg7Nyt88X2uGtaeduvrf7faCdbzzWvdRYvV4HpX6zURSBK6Pl4MGD2L17N77yla+Y7yuVCh544IGQKxoQEBCwzmg7Od9pyttKkW9KiVkczNdSkW8v59uPDGQZ9QEbgzAnBwQEBJw/Wl3Gdzab1Z1P3Zxvt853V+Q7Q7X8fKGb1pHvHb0i34F2vuFY98j3a1/7Wvz6r/86Dhw4gBtuuAHf/e538Tu/8zv4L//lvwCQEbx3vetd+NCHPoRrr73WlDXZu3cvXv/616/tZIJLSpleWCTZpR5M/WPAE8EihADDkhJXv1rW0Ct8bdaLKGfRrSG4ifiSXGxpcs2WrbOtKNh0aDAlsNXdoBvN1jXJ5f5OtNgRaiM59R/GUtvVeWhfAbxhy7Vk1vfW2ziz0Wn3PEliqeK9vGQdv3a4Flwjmvq/VPWpcTqqrmuw9+hbGjoCj2bLo/kLdY3xzBKYHjNmI+UkF9v2s8qspaLkWeJs3u6p0mRmu3MNXIv/qRriafBWy/d4ZYrxZdHOKUhTUfzdfVL9MeJ1/WWQZIWSPQGXBdpODncaWWrnegGhPfR9+RjNTtsIvWi4C5BGqgxgML43Dy7pnKygU53o4CC4EmMTx06BKjo1b7VSApJ6nhNOapESHs3FpvQjuIBQpa3YzKylBrulxTptW44zikw79vvE0JI9xliSGAq4aDEwPf/RyKcg630UDZrk8uZzcvS42c1d9iaEmFJn4MywxKL+vCy/BVt+dFm6NrVssPgqWV6MnT4rxyK1D+IYQlFfq8+TVPjo2h0oPyEp6OzMhDef2vVDn6FQ81oNbFqKvpKFvJ9ml9EnN62N151Sm+5iX+1P+8umZJhH69f7npm0991jqQlL8XbLsgmxPB2ekOx0QbdvhCBSaRKgBIj1vZFipqLT9qZcnWrH635ZOQ2+tAQ8Lo+Ndu4EpQyoZe4asInRHfnOXre6Szc351tPh5SQLgf4WmjnK8GUElMdSdPObeR73U4ZcJ5Yd+P7937v93DHHXfgF37hFzA1NYW9e/fi537u5/D+97/f7PPud78btVoNb3vb27CwsICXv/zluOeee86rnrBba5rEsWeAa+VzRJF5ORJBjOHC2x3QU2cBACWlCM46iaeorV1J6RrTug2aj5zaoB1jDOkan27ecqZRBU2Lt8aozWXunuhILgaefY28rJPnDG0ZLqVcxKCKRg/q5MFn1Jvmi5WeBqXuuxkP9dnQ2FPHmXrhqv41KZVMbVM2bRcHopOYcSWUeHRyQ/EuFoz6N8ZG5O8Tp71a4drBwI+f8q9BK6nHMehOWZ6BnZ1EZtVZdRyJIptXX+4zCyH3nnk53z1o7Jo6Tpz9XSeKaLfB0lRx/ZHZdtLXAs5N/ViSz4MImyvupizoHD7RbEF0gvEdAHQSSzsHgL9/x8vx1Sen8LtffmrZOt/aQ68Vz7si306edzry3emhRRFw6XGp5+SAgICA7YQs2nkW3IiydnbzVOQ7l2IhrSftXOtfaaRp56HO9+bBuhvfAwMDuOuuu3DXXXf13IcQgg9+8IP44Ac/uN6nDwgICAhwYHK+lSf+uVcMgQmB3/3yU5lq526dbwBGdG0uLbjmRr5TSugh8r15EObkgICAgPNHmnaeFmDTcJ3Z2tmdpATXougiRr5TUfUuwTVdKjfkfG841t34vuQgFKS/LD8zDqEj3FEEqOivaLX9Gs9ejW4VxXWE2kxUuxiDXKGUKk+esRTqyKWgcVvD2lHJ9pXCHbEyTYFzFbUFN9FfQgREJtddgTHQkyqynM+DlpQ4XLVmr4tzQ8UnpSKIirSyjMj3qkGyotN9JjruRoiNoF2SmEisS/33qG5xDm5EWo8VjRxRtrOTXrt25x7RNYc6z9WxPentrkK45uI0W+YeEzCrSO4I94FQwy7wqPXm3E5dbze679QTX64vXZeUJBC6/rcz1tHOMZPiICpVy3JYrIB3utXiAy4/WLVz+3zFywivJCmaui43NrdczndacC3w2i5raFVuXqnYagwAmKJn+3RhRymaRl20btFpmyoYJJeiPjt0ZU11J4SYd7lgDODOOTU0c4jDKI/Tq/ajs2cYAJA/fBaJUsYGt2w0OjRoGGlUrztgKeO96McknwfdJcU4+ey8GRPuqLfb1LPei3E9/9C+PgjFDCOlEsTSkhmDaI9UOK/dMI6+bz0NAOh/yvZ54UeuAgAMHBtCdFxR3DttQ8UX6Wtwxi265qD8oPNUp+fAZufkcYmwc2G7A6oqnZB8Hryq5i4hEI0Oy8/jO0Bqx+RmfQLnfrJqDdRJ76NlSdsnI8NAYuc5I7LLu+d4UiiYVAfEsVVPX1pKpcTZa3RFe23aX0YamqM47yrs80Yjk2bPKxWQ/r5AO9+C6M75Xn3ku0tw7WLSzlNtp2uBB8G1zYMtbXyTKEI0NgKhHmy+VLUGHmvbMlipMmGZtN4MCMZAVK4PcjmbEzW+E6Ky1HVOwMm51fTftjX8IbgtXSYIwJzFrDbanPmDlvsMfd3NB3Yp0X4+uQRvtSz1Op2nrLe7au3GT5D6hxTOAsZsoojHZX68GB4AXVDjUFkyCwpjrDIGqHtA4jjTqSAY81Tadb94rQGg4Z8/bbQ61+LlQGujvZNk56ilx8DpCwCg5eSCRxForBeGVj2dRNZY1znpJJ8z9wZRZCf9KIKo2RJqXo691y1i9jdwHTSdDE0D7uS/CW6o+IIx838RcHmjlXQb33qSzox8O4JrQG/aebNHqTG3jYCAgICAgK2MtnL29OUj1NsMzR6RbzfbarV1vtfT+E6xzjNKjcnfgXa+8Vh3tfOAgICAgM2DNUe+teAa1YJrK9PO06XGsoz6gICAgICArQbtwB4sSrZjq5fauWPU5h21c72dZkW+4/Uzw6KVcr4D7XzTYEtHvgGA7x4Dnj4l//AitM7D5UZMBTfUbzrYbyhkRozM/Z9iDEKropZKlqYkBIiiVGGp6kfV0/Rmxnya+xo8TqLdthQt1U9WrfmR6MQKhoE4Sp5OJN2Lcqf+8SG4VaYtFSVFH37EXjjXQCgBVES3ceUw+hpaEZbaiC1PnOatEqn9XvjtacEwOB7AFC1fw6Xt635DCKO0bq5fXW8WbN3unL2n7n2K8ohGpcgbryxZiqLDInAp6IZ674jrgTErmEdsDW/hshKiyDIl4tg+U7qJ3WOIzs3Iz/ML3riacy8tGcqhYDbFgVAixzMEIC97dBSNPB93R76zItRW7VznfMtndKEun+eBYoylZoKGot5xLjCfqgEeIt+XKQhBtGPMU4f2vnZqg7t0dI+CvgzS7Xnf6fYKBZOKg0bDTh8Zcy+JY5smdeIMIiXAKgoFI9gqHGV2Nr+ISNHNjdhpp2PSvOIr9oFNy3c2uLCCra0WkpNnVD/sGiTeNQI2O+9fGyE2XSuKJI0ZkPO3pvM3mhCHjpj9adlS4JMTcj1UOH4SPPaZeGxuHv2fU6lYhII7FT709fJaihdt5r822NMnAMh0J3myxBtXkpPnoUMD4AuL8rh0FRo93tV69/ORyxs6P19a8vui2fCqXX3t5mOhYAReuaLCgzEwd3+9bxx7grykT7LXxPgoyHH5DLAlO/fr80RDgzYlbXAAQs/ftQbYlLrv6efMVdBvVrv6ErC5IYRAW81nQ6UcJirNLhq6hks7d+t561SuiBIQpXiu59n1jHy7hj0hwEifX+mB9hBcY1zgW0dnUW0leO6+IewdLq1bnwKysaWNb8EFxBNPWzqu4GaSiYb7TR43b1tjFJBGFwAs/NgzMfJtmfMk5uULmi8teTm+Wj1dGzgAwE6f84wmo/LtGnDKGOzKNTZlVGKIrDzqiJrFgGi3TTktU7osn7OGXNKxVPj+MqAmPjYzY9t1y5g5+cueQ0JPjq22l8NtFhmtltdvza3pOzQFPjFlxthVRU9DdBI5cenr0rlScWyO442mP15ZKuyuYZ2hBt8Fx9A1m9RLkQ70m0mVzcyBKOOEDg9B6JyyJPHp3lnq5KlzGTg59lnXJRjMYmHpR67G4P1yYaMp6qQzLJ1LAKJcTi7yoA1x7RhJOZYcR8tKC9mAywNWcM2NfFuvfK/99USeXhyMlvPS+FZU88mlJtqMI6IEO/sLmKg0g+BaQEBAQMCWR8KF8acMFOW6v2epMa0XRfwotDbetdPbN77XL/L96ufuwdcPz2Cp2cFP3LDbcwC4509Hvu9+4ATu+NvHAAC7Bgp44L+/qks5PWB9saWN74CAgICA5WFo57GdTLXiahY9PC24pmnnGiN9eZyYrZsFyKk56bDbO1w0nvWs+uEBAQEBAQFbCW6Ue7AkA3e9BNeMsFpK1VzPwXp+vOX6XfjH70+gmKN46TU71q2v1+8ZxN++/WU9v+8luPa/H580n6eWWmglfF0j8gHd2NrGtxahylKPZhxERVrJ3IKnPq2juINHqkh2yX2ipW4JSpei7SmWRzCiWbRYyIwmZwl9SWq4EgNjfpRSR0DRaXsRXS2gFTlCbrpXvM4tlTuOrdqnG4GNIt+DlSHsZiK7XNjrJNRQ8Q09S+8/tyB/t9tW6R2WAu+dP4uSf+2VoA0lxLa4ZOhpHjshF1vl7qxofbrtHgrirpgbVewBzXxwI8igxEbHR4eAaUtb66lOnoYj9pZmARhRuzQTQo3f4HcnPLE2ACCtNkjdUVvV7Ie+PnCHibGcaGBAQJbg2vI5377gWrfxLf9/Gsb4lkyN/SN9mKzI91UnRL4vTwghU5fM3JYStWxli0169GGdFqbUrXm11k1dBqSKtKtGrdtgzCofEeoIUmY/k0Zt3Okfc/vpqo8LW93EMLaaTe86yLOkIjg5ftaon5Nc3qNYGyX3egP0qivkxhlJP2cLC1a81O1n3rLEBJz1hRB2nTDYbxlmzZahw7vsLVrw80AByLWSrjTCmK0Cw5g/bnq8NRNuaNCngSvwhUX/nlHN7IvAKmqeW1pCtHMnAGD+x54BAJj88Q72/a28HwNfeUJSv53r7Oq3s6YiUWSp7kakNfueCy5MtRIyOmKZj48+aduOu5fHgnHDRhSa2g5Jec8WdyXmeZbpgJndCdjEcGt8D64U+TbLSeJHvhM/8v3x234YrYRJ9fPo0q3ftPHvTvvNDsO3j815+wXj++JjaxvfCq6yuJ5k2GLFUrKHBsCUwQjBDa2bHjoBoiZpoUtzxbGhYUtKuf7HS5XDUi/8XsrVrkGkJ0NEtiyaqDXA9STEhUdrzzL2pPp3aqHAmDXEFxYzFb9JFFkDXbQBbino6fOJdB6LnrgP7AZdUnT0xQp4XS0MepUuy+g/oQRkoB8AcPZHhrH3q7Oy30tVW0LM6TcYs0Yo0RTrVJtqckwvzMx9Hxgw5VNctXBzz1xjP4rAtZL5kRNWlZ4L0yda7rMTchwbw9mUJhHcKJyTYsHmBAIgsVrwJInnVDDHuvvqhevZSUDnHTabNq/dy4F3ntG0EZ7O7w9YEUKIbUe3yqKdR47xnb5mbThranopbXyX5ftW085PzVvjW5cjC7TzgICAgICtDm04x5SgpPRPeuZ8G9o50ctnAN2RbwAoxJfeuNXBeDc3/aET82glHOODBUxW5Bqz3eP6AtYPIWQWEBAQAOCbT8/gh37tS/jCo2c3uivriizBNVeYJR39Tow6eq/ItzS+07Tz/aMlEy3vBNp5QEBAQMAWR0vp/xRiavKze0W+9VwaUWKc10B35HujkKadN9oMX1KU85dfs9NcX6tHKbWA9cPWj3yn6x9nCGLxJUdh0okOikajq7Y1oVZpFISA5BRlqLa8ENiyXdQ0tXIZ0NHVQt4TihPOJXg0Jb1NRbxFu+31uYvG7FwHAJBS0UTb+dyCEe0iRRmF5tVl1Dd1BHmpAWiqVbuTXW+6F/VbR437yxAlGf3d95dHbRQ33X+jJm7rj2uaOBLi173W1DgnOg1Ymjyv11PPQ4964fDHUbDscSXFIrBL1jhHJwGpqLFzo9Y6Wp/LeRFuTfUjUWSoiL37oj44QnfcFZdzmQ2U2me02fL7TbbvC/Tp6Sr+n385ip/70Wfgqh3llQ9YBe5/ehbz9Q6+cXgGP/W8vevS5kaDcWEmWo927iqxcgHXCZ84CwjA1vnWGNWR704q8j3aZxYcIfJ9GYNz0EGV8hVZ2jebmeutVu5EYvQ+bMGqf+s2aKFg3/tpKrpW5ebCsJK896GmPlNiRVKTxLDHuphD6pxyLo1M25rxpXvs0pNFkgCHjsnt+/eCLip1cs1yS4FVKoD6zrSTokrr7dHIsL2UQsEKqwpbPYQtVnpSrQEgGhs1VTi81CWnCgc4s2P1gmeDttT+Tx01Y66ZhGTJXz+YNUsvurcnPCrA5yXVfuhzDwMABu9um3HnUWTXYm6FlDg2rDzebAFCCdR27LEapFCwc3KpCK7mbMGYYROKHmOWRZuneWdeJ8Q+c+22WXfQHaNW7Ldixye+6gDAmsCJzKEJ2KTQhnM+poaK3SvnW0eUCfGJhx2jdn4RO7oKRI7a+ZmFBm793XtRbcnn/Eeu3YEvPT6BZof3jOwHrB+2vvEN+AaMqyCun/6UIaVzf8F5Vw6a4NRQMEmxYCaqqL9sJ33HAPbzwrP7pGnOJE3T7mHE6wmKlkog+3bLjZMzti0n19mUnPKMLgpSUqUCCJFGN1QOmCnxpWn2Od/Id3OVlaEuFis2z6mTOOeEv2DRBqHOT48iEEXD7lx/ALnDqoTHwqIx4LtKn+n2XKeKpvI49wCdjmeQamV25HNeioGHZZwDPb93trHZORAnVaBrf0Ltom6p6t0TTS8nlHjPDilJJ4hoNLoMflnOjJp97Xb/Da5Ls7BGw3c2rKGs3VZCs8Pwqt/+OgBJ4/r1f/PcdWsXsMqk2wFuya+cIwCzbOQ7Zaxrqp3GcCrn+7TK+b5ipM+cI9lGYxgQEBAQcHmi5RjfBcUea/aIDHNHcI0QAqriRe0M2vlGwFU7f/xsxRjeV+8s419ftwuFf4yAZoJWD+dCwPphexjfAQEBlw1+50tPmc86R2k9oL3Z20ksrO0Z390534CveC6EjZRrA/2qMV9wcUe/dF5WmwlaCcM5JbK2f7RkIt+dDCG3gICAgICArQRtfBfiyES+exmnerrVEeaYUrQZ34S0c0stf8nVo/js224GAONcCLTzi49tZ3z7dY6z/0Ho4AAAWJVtF4JbFVOXTnzVflBFU0rOTrgndD5nREO9ppf/vgtRBHFG1SHPonrrNiGjzB51WtfrdqLdHl29aRVbXZq7G5U19cQr1cw2vDEm1ES8dSRWtDumZnX84JPgLk3coZenLshpnnjbRJIYVoJIH6PO3XreVYi/9kj3QGU8D64YnegknsquvnZec6jry6Q4mDHQzAFKDNWct5x7kGIL0LI0bJi6X939ViyMOM5W/OUcfH5BdSdl8KwxPWKr4P/3nVPm83rSuHTkeztFbTsOfcwTXCPZkW/X8aCp6S+8ahRvvmk/PqvGfd+wZNUkynsuhKxVurO/YHK+t9MYBqwNvFYD0YwyQrOp5oQgGpDzMBkcMP/I7My5bAFNnQI1MgyhFoa8UrGin+6710lJSvVM7hoXzByFXTvAT5yWnxkDufEGAEAyXEDu/sdlc4xbxlguNvRiohl0+Rz4tBQQhcMcE+embIqRw0KixSKgUoV4rW6qlOg+02LRVGoBF2adkkxOeWKi0fXXyn0mZ8CUWrepeGIGz1kPQbK3MiGET91T7ZAnnjbRPI+ZpfvcYoh3jwMA2tfsQf7YlNy+VDUK7KLT7u6XPq0jbmv6q8+XJCA6bW14CKRfzZWnzxlGIokigCqmHSH2njhgep3npnsBEBl9InGMaHyX/CMXg08pxqGan9n8or9GyeXNNZp7PUdNqhyJqGHoJcdPIhEZiugBmxoe7XyVkW+9TqUUALMMtGijI98O7Vw7EFzhN2t8h/n7YmPbGd8BAQHbF0IIVJp2AVNpZDulzgfNREe+t8/EY5XLifF6A9IDrilxbk1u97NLU/8fP30Dzi02MbHYxLXj/Rgq5bDY6ODhkwsAJOWcEGKi69tpDAMCAgICLk/4gms68r2S4Jr8WzLBuFU73+DIt0s7d+n0GtoQD2rnFx9b3vgmUeSV2DIe1FzO5CwjlwOckmBsZlbtnkGNJNSWf3LAj5/yxL5M9JISIy4j6nVfTEtB15MEfOEsz1Pv1hHXOdXNVnftSEKz89pdCO44sZenj4jEXosnZsOFOZZQYj36vEdddXebzntOC9q5UXLtwe8vg1WyRd+6cqBrdW/MvPxmFWEXMTHlvni9bqLPQgjbL/e3J8ijnp1dO4wIDzl6wkTnZY62jPq5Ze28yLgW43nONWjslp768jcO2WsUTn33KEKiPOuAfR70mNF8ztZ7TY9jqpa73L5+FOzNimaHe9o4S631iyTYnO/tQ5nuGOXyboqApsT1jHw7aq3FXIQ/fstNAKRXf+dAAYuNDh49vQDARsM1VX07UfcDAgICAi5PuJHvglE776HXpKY9HWHWSz0ruLbBtHM38u04FTTyIfJ9ybD1jW+nLrfgluKDdseqXMJfoHv1sLOQpUDtCI25+xBCIPaMyW1Huo12EAo6phSyGQMUBUowbv4zRcdR6xbc6V+GYeHVeM6Bjg7LzUtVQzVfMxxad5ZDQnABog3xXNy7vrfev+kYjD3GWDtJeK2RuU+aRp/ua9dm9QwU7nvC0N1AqKUr5mK/XxntGRG4iq+OT6i61/k8SEGprz5jP/DYEXVupw1NHTwxCTp2pdy4cwyRul42t2AdRJR6Y0ny0oCJdu2Qbc0t+DXQnT7pv3m7A5rPHJJtiVrbj3Sva+RbGd+dbTTx6EnUjWJrRJQAzFcmdw3xOLVQcGuB7+wv4MhUFY+elu+zvcNFdR6tdr59xjBgbSBxbFSqe84VwqqGo7IEouYxUioBOmXKVTXXKtszc7byRydx6Nzcvocd7xzJ5T2nr/xaGGc8P3Lco0RHx6UoaGGwH1w7NZPE0tiTBFwLour/D85Bd8o1QHLCpsR4oJbayVstQNOmczFo36A/NI0GuKKHC8a869FzIlusINLX1WOeJXHsOYsBSRM3XSqXQa7cJ7cfPw2iHNXt5x9EXFNiq999wpyTxDk7JztjlkxKqjmdnIJ5GwthKO/x7nGIulqbUALo81x/BeKq7Bc9Jdtg07Me/d0o309PA9Ndl+hRxwWNQHXlD2ctFOn1VxyDTU3b/nmDZR3ifMeQ3HRywqrs90thVDo0aNK8eKNpgiN67ICUinxXh4NTcqtB66bkI4qiigz3yolmKdp52tjeeME1+duNfGfTzkPO98VGqPMdEBCwZVBv+ZPCUnP9It8tI7i2fQzHdga1TCM24it2QZgYVdblKXI7BuRi89iMdDjuGVKRb53zHQTXAgICAgI2MertpGfNbg2TG52LViw15tb5lr/9eXfDI9/OnG+vy6GdryAoF7B+2PKRby9am/L+FyTRSQAAePxJREFUageq9B47EWMdES/02SjpiidyqNxOiS8AwJGT9jzEUpTlORwBkELeCqlUa7bMmUsjdtsmOUeoq4dgybj06i69/CAGvyHri0rvsePtX054q1e5stQ+Bs41psfU0LBX8YIxUY3UOQ0dfWjQ1riuWa+5EbvpK9nogCOuk6b9G0EXt4Saey7hXLuularSEuQlCn9//fnMtHUjisi0YSITs3MofVudu1gAW7TecF13nQwOgB+zRT91dEKL94h2Z2WKfy9xIUIBUGCb2UD1lPBgpZlACOFFZc8XWkRlOxnfuhxYKd/9/EcZhrJWKY9XULLb2e8LG+0Z8iPfgXYeEBAQELBZ8T/+7jH88TePgxLgAz99A/7jzVdl7udGvi3tvMd6XKSNb//7Dba9fcG1DNp5EFy7dNjyxjfg5MoydBkm2QfofO0eC8wM49I3iqn9L6IU4Jb+ZQx7rfw9PGRV1YUw9DQ0moa+5p+aGMoeOAfJq/xlrRzq5oALDjor604PdphXE9qrOe5eT7oWdxwb5dC0Wru5ljj2ctW9773885SjgPQYX8G7Vc5Ve4au2GwZ5VI6LGlgSBKQPkWja7WsUrljpHp0dUKNAc+qtS76YS8qd5cTQtMV221zr0k+v3wdbcGNI4BS4p9LjaXOU+86VH/v6gCk6rF7+6dqvMtfBEQQLfC7bVBTke8d/XnMVNtgXKDRYejLX/irbDvmfDfayvjOdRvfy0W+cyusEnYM+LkOe1XOd6jzHQDYtCI5vyjKs7DzIzj3aOVUO13LfRB7pNq06FPVIvIR6GNH5edazVCRSRxDCF0RI/t/Vs9zLni93tMnyebn5Yf5eUMVp8UC6MiIPE2zaWjFbE7uG+3YAaHmKpLLW5p2FIGW5f8Fr9bMuznaZWnYfGnJntPruL0uQ5vmwu4rmNERiUaGQF7wbNnXs9PS+Q45rkTp3hgdFMdBzGs14HFbtlGrgcf31839E6oPgKKAZzk59dgTYu+v44xPpmY8x7VQ66FoatrQ4qHOF+/fa5XjAXCt1eMqk9PIzqfufefMUr7VvSOUgC9WVP/cyjTEnytVP0hEIQ5LhzhrNLqeK9FomAAALRa8tIpeFWm0IjqJKEhHAOuXKRVwAbj3sExB4AK478hsb+Pb0LOpoWj3UjvXc6nJYkj9v2w87bxbcC2Ldt4OtPOLjjXTzu+991689rWvxd69e0EIwec//3nveyEE3v/+92PPnj0olUq45ZZbcPjwYW+fubk53HbbbRgcHMTw8DDe+ta3olrNFt0KCAgI0KirnO+xcsFMJOuV993ahmrnerxKGc4JPX6uwrlRRz/PyHeo833pEebkgICAgLXBVfRebs731c6XF1zTOd/a6I5SWisbTjtfMfKtc9q3zxpos2LNxnetVsPzn/98fOxjH8v8/sMf/jA++tGP4pOf/CQeeOABlMtl3HrrrWg2Lb37tttuw2OPPYYvfelL+MIXvoB7770Xb3vb287rAkgcgxQL8qfXg60VwpXKtqYH84zFBaEEJBdLj7lzXDQ2CtrXJ72eqt6z/qG7d4Hu3iXFU8ol+aO2iaUqRKsF0WqBN1vg07PSs+vS0QlF1F9G1F+WdGtd19TpK4mo+onstRQKYDOzYDOz4EdOgE3PgE3PZNd7TrEAaKEAWiiAXLHHXC/JSaEcks/LmtfqPFxHllPtyJqYOxGN7wS95sru8e51z6JIjrPLJCBURr0JAQiR47VYAV+sQCwtyZ9Gw17vwiK4VpfXEX0dWdixA9GOHYiVcJkZg9R46LE1lHPVBu3vRzQwgGhgQPZV/YhOYu6laDTsM+BEE+zY5BDt2olo106QYhGCCyNAp/udWWceUAm3pOt5NvfGeQYuN+jId7kQYaAoDcq15H1zLvDkRMWL9moYwbVtZHxr2nlfZuRbi6M5kW/eW6DNxc6BtPGdyvneRmO42bHZ5uSAgICAzQ7X+G4vM195db5XKDVm1M417ZxsTuObC2TmfAe180uHNXM1X/3qV+PVr3515ndCCNx111341V/9Vbzuda8DAPzpn/4pxsfH8fnPfx5vfvOb8cQTT+Cee+7Bd77zHbzwhS8EAPze7/0eXvOa1+AjH/kI9u7du6b+CCEQDQ4AAHink03BjSJQlWcLxsBcNUqHrgwAiCKbP+r8o4hm09LnHHVRwQB2ZkK2kYttObKW2jeVk25oVE7pMwgOoq5B5lSrPORG0+aFu7nQCrxSXZ0ieAbNWtPY6bkpQ+WmxSI6B6TBmjsxbYxD0UidQyttt1qAUv4k5ZKlkGmlUUL9nGrdndh/7NJ/d10OSxnOQLaDAQAp9aPyr64GAAw+sQDhlPKyJ8zOWdeUd5LPSZqg2peoKKBIOk7ZMVsuzVU7J7FUW6XXXAmuo42HT3jnMrTEdJ90v3QpNOcaBWOgRUl3w8F9iCqSIshOn/WfATM+dHla/BaFjuSWCzEGizks1DuoNFcf+f7cQ6fwnr/6Pt7zE9fh51/xDO877c3eTmrnmnbel5XzbSLfLu18dSVRdjiR7+G+nMkpN2rnIfJ9ybDp5uQkAatoqq/zHDlpQMbBDPh0agCYmOxq0/uPdJSp493jAIDJnziA8S9IajqbX7Dv0Ha7e64gxKcTq/b0uxtQ72hFdeb1uqFka+ew17f5eVCn3KRJOSsUbMoSY4BQNOwzZ636ueAexdx2wKlAoLRNAIAOyHXC/E/fgNEvy+tFowl8/5DcN6X/odPFNK2f5PMQGeVQ/YOE1cIR3PaV+8rrGoZW7ZbGbPllL4WX4mWvN63RQpME4gb5Xqa1FqLTcm3FG02zHqOFgtHOEdWanavdSjFcz6H2fCQfGdVyU7UEANod0w/uqssT4t8npJ5tGtnUvCgy10zLZfMMsIVFq4he7Ae9Yifgk04CNgiuwb1cXess47vZY39LOw9q5wHLY11DZ8eOHcPExARuueUWs21oaAgvfvGLcf/99wMA7r//fgwPD5tJHgBuueUWUErxwAMPrGd3AgICthnqjjGpI9+VNUS+j83IRdaRqW7Wy3bM+dbjlSW4lpnzrQXXeulhKOxyIt866u22uZ3YA1sZYU4OCAgI6MZqI98tL+db50Rz8AwHs6Gdq+kzbXxveOTbVTvPop2rKHhQO7/4WFfBtYkJ6aUcHx/3to+Pj5vvJiYmsGvXLr8TcYzR0VGzTxqtVgstx5Na0Z5HSJELo07NnXrZLgQ3nk7RTKmbOyrjgPKUO0IcOqoolsl/M5FHRWUGAKLrPY8Mg6hz9oxUA+DqGki5D2xeC7R1i5+JWr23UFwGCCV+ZFkdqyPwrFqz3ttqDZGKZItiwUaC2x0r4JaKqmuPMTl+ymMXAJARdfVS447gmYmQQ3nLl6penwAgGho0bzCulMLTqvWpC5X71uoY+ML35LZiAdFgvzl/dwSEOp5raoVo5hdTkeru8RadxDIjXIbFtVcBADo7y4gflnXAeY/66ySOvWcHVNevXb4OfXNPP4rqPtK5Pikml9qfUAIaxcAqxfy3CkzkOy8j3wCwtIbIt55wqy3fYBdCbMucb0M7Xzbyba/XCK6tQDsfLedNAHGvyvcGbK54so0cGFsZGzEnBwQEBGx2rD7nuzvyrbenndoilfOdjnSnaeiXGq7auSskp6Gj4Ms5IwLWB1tC7fzOO+/EBz7wgewvVf41AD+PGGnaLje/rTp6N13X/ZylyA0AtFSyypYO1UlS1bQyqFJynZm16piD/YYilVbG5GohQ7LKRgFWVdOl660SRFHVeKUCOOqcpv9uSTYoilSrZYz26Io9YGcn/H6kwZhV784p+t7wIKCcHuT4aUPL4vU66KCkjbErxxE9pRZxjpHKqzVEKmebRGrMeqh9p0u/GWX2dscY33RosMupQQsF21fGLCUy1XbmKXMxqFKh5XOWMkmW5Bjk5ytSLbVHf+X1JB4FvufYKujvS0fnQLQiOuCUinP6Syi2ndQ5bM53yY18N1Yf+dbe3rTB3lrlRLzVYATXMnK+o4zI92oF1+KIYrQvj9laG3uGrfGdyzDoA7Yflp2TqfOsdc2rukKF/67TcyR3FaY1XdiZ80gcWwfy0pKZc0YONQFdCWNqxtCO6cAAaLHo9UVUa2aRLNptOQ9ArQ20OjolALeOWVLuU/t3IJST2Djmk8QrTwk1h7NWy6puu1U4hPDUuzVtWztzo7270bpSVkXJPXQYXM+rjpr30N0PwLSwXHqRps7XanabGtf44JUQ2sF9/LRRkXdVzaOBAaNPw2bnutL0BBfG6c6XlnqUvbQlQkGpr7WTpvDX68CDP5BtFwp+SVJ1nazVAty0hhXSq0z50lLRKMTDTT3M6K/t0DL0W84MnV6PHaDSD3XAw1VmB4DFZc4bcMnAufBLbCa9nyFjfEcRio6h2kpYl/Gtlw6adh6nnNhriJtdFGSqnecyaOch8n3Rsa6Pwu7duwEAk5N+ztbk5KT5bvfu3ZiamvK+T5IEc3NzZp803ve+92FxcdH8nDp1aj27HRAQsEXg5XyX1h751hNO+hi3buf2Mr61s6Lbzxpn1PnWRnO8Cnqczvv2aOebqM73dtQ8WCvCnBwQEBDgIx3ZXY3gWiFHEUfUzI1Ziufakb3ZBdeY8On0GiHn+9JhXY3vgwcPYvfu3fjKV75itlUqFTzwwAO4+eabAQA333wzFhYW8NBDD5l9vvrVr4Jzjhe/+MWZ7RYKBQwODno/Gq5ICiBrQtPhIUT79yEa7Ec02A86NCgF05pNiGbLKk8DMMrXahuJc0bd2gOhVu2cEKM+3hWFdlXBVTSTLSzIn/lFEEJACAHN54x6tRtd9YTJXFVrR5BLt+EKwmWpkcvNAmx2Dmx2TlLqtXq6Zgno+tbpfjMG3u6AtzsQlSXQ/jJof1mqeCslcFoqGdV02tcHIYSs5ar6R5pt6ZUWwveIc2EUzKOnThrVcK/fSQfJuUkk5yZNP7qi0M6Y6PtnxPD0OBQKQKFga4G7dHIhQAcHQAcHZP1uLmStdj0uhCIaGvSeB6MKXy6jfeUOtK/cYdXxAfDZOfDZOSST095zZlTTXVEfx+hJP8eZUNF5fvw02Jlz8kfR6YVKuaD5HGhetiU2gQG03qhdYM63Nb79Y9yJtMPEtjHcmsvSzuX/DnPVztXn3AqRbwDYPyqjWVfvKJttmq6+0Q6Mh07M48Zf+xL+4juXt1G4EXNyQEBAwGZGWs17WcE1piPfck7UBmozQ/G8i3aezvneaNq5F/nOKjUW1M4vFdZMO69Wqzhy5Ij5+9ixY3jkkUcwOjqKAwcO4F3vehc+9KEP4dprr8XBgwdxxx13YO/evXj9618PALj++uvxEz/xE/jZn/1ZfPKTn0Sn08E73vEOvPnNb16zqioIRbR/L9iZc/LPKAIZkDTj2rN3Ia4r6taDhz2qmDZOTAktwPlNHCqwXaDTYgHkqivkH6fOgStjUudFA8tQsk13iaGAs4O7EZ+alp9n5nzFbK2WOtAPrvKhbduRNWQJNfu65yZR1J3ffAEQjaaXj23y2gsFk/Mt6vUu41g0m9k0ekpsGkCtYa7Bo+YBvfO7AY9q7l1r+hh9nyLqUeUA6cTQ+ebedVFi9uVLS16fjOJ9rYbcoTNyo3HkCDtO6dJuiqKOHSPgTx2Tuzg0etHL0ejkk1vF1U7vfTSvSQhgG75A6y2b863t47WUGtMlQpaLfAPSAM/HGztRrgfqy6idxzQr8r06tXMAeP9PPRu3XL8LP/Zsm09s2txgx8877n4YC/UO3v1Xj+JNN+3fkD4kjCOixFbPuEjYXHMyAS0V7bxIiUnnYYsVsz0aHDBzmykZqZtQNGedmiRcijBjzvxHjEo6/Zd5JI5quaYD86UlSzHWC+JSCdFOuTYQ84u2+okQHn1YQ3QAqDQfr/xjFiWZEKuofWAvOjukgyp/fEaWGIXSNtHHOrRkrfWRnDiN6MRpuS0XIx7fqfalEIo+ztwylYSAKh0VunPMnEd0EtCSpNwb2nyzZc5Xf+ZO9H1POqdILjZVPQCbpgfAbJdzonyPRFfskfvVG2BT02b8vFQBdz2g9VRc+juc9ZNJ12sbGrlIEqMPQwmx2ibuuAth0gpIsWBp5c4+lrrOl6eRA1LBPGeXxWnV9i5kOGlZpWrWmLRYMIEFvrQEVln9XBVw8ZA2tpfN+VZrAy1GVsxFqLUZmhnRYS24pl/5aQZZ2hi/1PAE13SpMU/tPNT5vlRYc+T7wQcfxI033ogbb7wRAHD77bfjxhtvxPvf/34AwLvf/W68853vxNve9jbcdNNNqFaruOeee1As2rzAz3zmM7juuuvwqle9Cq95zWvw8pe/HJ/61KfW6ZICAgIuFHfeeSduuukmDAwMYNeuXXj961+PQ4cOefs0m028/e1vx9jYGPr7+/HGN76xi9663jDGZMHN+V6D4JqaZJdaKeM7SRvf22PyWU7tPCvne7WCawBwYKwPb37RAS8/3NLON3b85uvLO0IvNqqtBD/y4X/GL3zm4Yt+rjAnBwRcHtis8/JWw5po56nIt631zfHo6QX8v984hs89eAqNNuuinW9mwbWWQ6fXMGrngXZ+0bHmyPcrXvGKZSmZhBB88IMfxAc/+MGe+4yOjuLuu+9e66kzIebmjeAHyeVkzUsAffc9ZWpVCsATChErLQy9mpRKVXpk2IqoOdFc0UtUyzlee8vp8BDEHulxj6otcKUsnlY1NwIw9UY3HdurYy5AhPXm66gryecB9zjtbXMp7cqjLGp1L3JqalLGORtVT6mMmxrhjPnRfiKfCxMNrwobKYgiI+BGHG+waLXMZ9pfNgwFj5XgwlGiN15zRafvguBG4I7EsVVZ19Frxk3NU692O6ce6yELvNEAUe0YNfleahqEgqtaraRacyL9tha36CTZQoD6UlLb3Ci+GWNHfJCWiqDlPDCL88LXv/51vP3tb8dNN92EJEnw3//7f8eP//iP4/HHH0e5LP/ffvmXfxn/8A//gM997nMYGhrCO97xDrzhDW/Afffdd34nXQXcSK6mRq8t8i3vcTvhaCXMeHrT+VsbbTyuF3Sd7yzBtZzJ+XYo96ssNdYLuYw88o1AVj7epcTR6SrOLTZRbc5c9HNttjk5ICDg4mCzzstbDa00022Vdb4Ba6B+6t6j+OIPzhniY7WVYKRPMXt0zvcmi3z7db57086Xo+EHrA+2hNr5inDUVXUpMd5oWmOTUGuoRRHQUUrRWUaOu2gkFJEun0UIyJJS3ebctO0bwzTbYNT5wsUihKZl1RpgWpXbzUPmwuwvGivXiTL97SSWhu0Y3iSfAx0dASDzkY1CqzYcKbFGacrINhTr9EJaU/rSlCxtvLqsMP2ZC1ClPC6aLWt0cgGibh8ZGLBUtV50L8dA1tQuks9Zoz19nHkGCIhWXFXGhmh3/Nz/1DlWgnDo5gBA0EN5HLD3tN1BNKbux1LV0BldJWBXAd30xaXZM3tums9ZWh0XAKwCLylbIay14p577vH+/uM//mPs2rULDz30EH70R38Ui4uL+KM/+iPcfffdeOUrXwkA+PSnP43rr78e3/rWt/CSl7zkvM+9HGpKcK0vH5tnqLImwTX7cC41ExT6tfHtvwu2S6mNuhmvZXK+MyLfaZXW1SK3SSLfG42qYlbU2onRwbhswJh1wLrvY0KMg9grv5hyHBiHrjpWJEmmijbJ5e38y5nXTrxbpkIkE90RP16vg59QJTLjGNGznym/mJoDm57uvh5CDF15xalBCKNIjscOGWohUw71dCM0n7PrA30tlJo5CgB4Zcn0W18jLRZB90oxvM6eYZAjZ+V5zpzzxoppGr3qE4kiM9+XjsyYsXZp/1LTRvaJebR9p6qIpuHn80avRGvJAJDX5KjBe75srQCfi+29Tinc6/a0mj3JxYivkukj7NRZ775zXT622TRtRyMjagBsmoJotmz7hIIW7T0xzyNnEKqiBsnlQctWzwKA1Y5R1xiptRWbmbMpC5yBN3tEDglR0aDzw2adl7ca1hL5tsJk8tkqqt//8P1z3n6TlZYpf6rf95uuzndW5NuhnedDzvclwwYL3wcEBGwFLC7KHMPRUZm7/tBDD6HT6eCWW24x+1x33XU4cOAA7r///p7ttFotVCoV72ctqKuFUTkfY8DU+V674Jo8zi5Ss3K+twMaKgKcqXaelfO9BsG1LIQ63xK6JB4XttZ6QEBAwHpiPeblC52TtyLS0ezlRFbT9bD/3QuvwM6BAsYHC/i/fvyZ+IVXPAOAXEMwI7gmj+0yvjeadp6Z891d5zuUGrv42NKRb0IJwAW4El3x1KOjyES76a4dEFqsg1AZuQZAaNItdJWinGuPMGm3fXG1XrRKN2qpfmvvbnJ2AlFLRZOXiexqzzkplUzt6141x60Il9tvYdXaGQM7N9HVbxM1Hhgw1Ox0/zOp3I7IG5RyevpYzRbwvOlRZGucp9rVfedz89nj4o6pE03mNRs96VkD3IF+TjRoX58VcXFPF0VG9Ic3ml702e+WYjHoF2q6trFOdYhziEaG5bYoAldiOaLV8sXcUvfGi+ILDkR50z+zOUkyn0XRboNNr5ASsUpwzvGud70LL3vZy/Cc5zwHADAxMYF8Po/h4WFv3/HxcUxMTGS0IrFsfeBVwES+CxFyKnK7lpxv3/i2z0wX7XybeH4by0a+M3K+1yC4loVQ51tCMw4AGQXvy3B+BAQEBJwv1mtevtA5eStCG9T9hRhziVyT9xJZTRvqb3nZQbzlZQfN9x/9ymEAklVn1M7VPNgtuLaeV7F2GLVzsZLaeXAYX2yEyHdAQMCyePvb344f/OAH+OxnP3vBbV1ofWCdw1zOxxgsnU+pMTupVJ3Id3qy2S606foyOd/ZauerF1zLwmao8+2yGFZTr/xioOoI+ukoeEBAQMB6Yb3m5Qudk7citEFdLth5sRf1PMtIdVHM6dJjHLoJHZDZbIJruj+tDje56kHtfGOw5d3xPBU9NBDERiIZt6JYxYIR2UIUOWWisqObJqqYJCsLtQFOPWgVOXVKe0BwsJkZs58RzUo96CYCGlEI3Z7O5XUFtuBExFM5yyai3yOCzVXOFnVdcU5kuesYLTyXd+pUZ1w/4ERsnQhtVxmxrOPcKLN3al1SLPXyWykBj1ATwUZGhFm026YUi1fqJo5BVXkXceZcl+id6ZMZK4fl0EP4DQVdeofaXLge7Al9b3rBy+mPIhCq8+BTonHkwl+g73jHO/CFL3wB9957L6644gqzfffu3Wi321hYWPC87JOTk9i9e3fP9gqFAgpu/uMaUXMiuTq/qt5maCfceKaXgyskUlmGdr5dcr4by5QaM5Fv51q10Xy+gmtxhojbpcZM1TJGlovgf+yfj6CVcNz+Y89c9z7UHYO71lo9M2PbwV1sOnMriXPmXUlLBbOfaHcMi8mwzq67BpHSW0lOWMNAdNqe3otpOxcbDRD3vFYzw+aHiyQBe+yQ6ateJ3jvZrc8FbHvfZ0zTK66AqQu847ZuclM9pYnTOrQW02+MmDziyl1cpotiy3atdOWxuQcyXFVJuzocazk3nHFPE3pNreEm9dZYc/v3jNKTP50cuas07gyNAoFO3dxq0FD+/pAB2WJVVFvmNJuot1GV6kuQv05WefatxiSo8fN+azgaKrvan+2sCB3zeft2k9dmxqIrjx3AIjGRo3WjugkRlw2s0RZkiCZlBoBJIpAlaYM6StZ5lxlyTyLJBeDJE1gheplq8F6zssXOidvRbSYjnznAEiGYCfhQMYwpCPfaRj188SlnW/OnG99fu2UB7LVzoPg2sXHlo98kziWE4SeYPN5SQ8n1Ai18Ll5qRxebwDNlnwBCyENb1fUCtK4pKWirFVKifkB1MSVplq7cFXL946D7B1HfGCf1z/zmVBVe5oawZKu5todY6QLLoxxZT57A5FhmKp9dRsuXVl/zxsNqYZOCejQYJfIl+lrLpZ0c0rB2x3wdkeOg7OPabqTSPVuQkALBdBCAaRUBL36StCrr5TXm3FcWvXdbhbG6aCvg5b7EO0YQ7RjLLstqMUWpebH3Dt97e2OeUZInLNjRCnYmXOyfny67rj+0eJ6yuBe7rkQXEAsVuTPQgW81ZIOCt1OWmAt9UwCarGqxtXdh5ZLoAMDoKp+vDt+ka4tfh4QQuAd73gH/uZv/gZf/epXcfDgQe/7H/7hH0Yul8NXvvIVs+3QoUM4efIkbr755vM+73JgXBh6eF9elhrTc9nCKktLrZp2vg1yloUQqHd6lxrLzvm+QME1uvE53zNV+yy0Eu7R6jUabYb/+U+H8NGvHMZiY/1r77qR7+rlbHwHBASsGzbjvLwVoY3LUo4ag7QX282UGutlfDsVU9K0c9fYJgQbLrypu+MGG/KOvkshCK5dMmz5yHdAQMD64+1vfzvuvvtu/O3f/i0GBgZMvtjQ0BBKpRKGhobw1re+FbfffjtGR0cxODiId77znbj55psvmqKqm0dbLsSglGColMN8vYP5ege7BovLHC3hCoksL7i29SefDhPG8OzLdb/qM9XO1efcBUa+N3L8Zpb80FKjw9Bf8K9/qWUN7lorwVAp2wF6vqh5tPNgfAcEBFw4NuO8vBXhRrNzEZECZD0MTitM1u3ABmy0uNmxdb61je0a3xtNOQcs7VxHvvMR9cqf5UPO9yXD1je+KUU0OgwAYHMLhvrDl5ZsWa163dLBk8RGKF0BLyfSmLxQ0hBz3306U5CrJ93ZLTU2r0S14tihfLm09Nj2w6Ewu1FP0W5bKlOka4w73zvlrGjRUvdc+jahxNRBF50E0GU3XBqcemHwxYoXvTWCYnFslSJSdFJDgc8osyYYN+dDu23LL+zaYUTHfOqXEz136HbmPnJqy5IV8hAD8rpopwNeUXQ8QSwrgFBbUi3rxSe4ufZo7ziEFjo7frp73xRIRG26wHLPA/woPluseN+7z8Zydc3TtdbN9mYLyGUbDrwXrXAV+MQnPgFA1hB28elPfxr/+T//ZwDA7/7u74JSije+8Y1otVq49dZb8fGPf/y8z7kS9IRBifXQjvTlMV/vrCryLRyRESBtfG8/wbWGQy1bbeS7c8Glxja+zrdLOwek0yZtfLv5/i4Fb71Qc9q8rCLfQoA3myA5JXba12eou4QSI1rqvvd5vQ5alI4zWi6BLShRUj1X/eBJZP03klwedHhItjE/b/bnjQbgzisqB0sI55mmKRaY7KApw0UYM2XR0tcH1RtdwlOcngDX5Sbj2Mw13C1LJYRPwTcXYbfxWs1sM+W7Om1bwqpeN+NHCLHCpq2WTUVy1jS0KBlnXvcbTXtdKaaZS882ys+MmfQxWiqa83h0bLUvbzYtffsZV4ErWjxvtuw5s+jbgFnnNP7VDSjMy33p958295T2l8HV3Nmr9BwtFm1JT12mrpMY9hrJ5/21nzcw8hrY7JyhjJNiwVL0e8GUoLPzM280zP2jo8MgKuWMLy5BtC+Mc74Z5+WtCGt8R8hHFM0O73IYcy7wrWOzWFLv716R74KJfFvj20S+nf/vja7xDbi0c3lN6Tx2fS3acb/RNPntjK1tfEeRNMLqStXZUQoH0GXMAdJYcXOm0/nEIkmQ+95RAHKCMcZyRLNzcR0DiuRzxkg1EwVj1vhK5WLriV64NU9d6jShEFftBQDQc7MA5OTgTZo6r2poEEIZFqTd8VXcdQ75jlHwadmOuzTupRTu1bF2ctC8vprxcXK6nRroXtu6Nmguzsyj1k4UfZ1ZSvR6G5tbAFmU95qWSyZPDFEE0ifHlVeWwFWdUAF49UhNe6p/YrECohaA3vg6zhNer5v7w9sd3/Ggj3PyC81CqVDo/VyukAffyyDXivNCCMCp2W5qhVPS5ShZC3qV3XBRLBbxsY99DB/72MfO+zxrQd0RW9ML3OE+eU/n6ytThxMuvMe36kQ/mylP73bI+a6r/7GYksyFQ6QNZYcirhcP5ytUFm8K2nkq8p1hXLsGcdb3F4paEFwLCAhYZ2zGeXkrwlDJI2rmxvSc/6UnJvFzf/aQ+TtLtBTwBdf07cnK+d4UkW/VH13+0s33BnxjvJ3wTKd9wPpgy+d8BwQEXB7QBk2fo1A63CcdHKuJfKdFRLZ7nW+jdN5jAtUGNnOcNEZw7bzrfMs2N9J54eZ8A9nGr2t8u+kMT5yr4KV3fgV/8Z0LU/wNtPOAgICAzQm3dndOV+hI/Dn/1Jxlz7zzlddgtJxHFrIE10iW8b0JosjaAaDn+TSVPm18B1w8bO3IN6BobjbSoaO1pMeDTtIUb0MNtvswTWGGVTRFFIFohVSHsk0oAdUR28F+Szd3otlZ0U3BBcgKUU/BGMhTx+XnjBxMEkWWflyrA1qxkhIQYaOyur/87KTpi1ULdV44vejTGUrhpg+KqkZyMdBUdPieF2Tp9Fngi0u+2FtWf5xtOgrOaw0TCaZ9JQhF3xONhh/Fzlk6mTyubqli1RqIisx718g4zJPk9EnT5OR5rGKtoeoXCpaW6KRAgFCHbSGQpv4BsNS5HuNEcjEi1TZfrJgIt4giS6+nFGDrLyS1kXAj3xpriXync7qWpZ1vg8j3ckrngF0MrKvgWqQj35tD7RwAGhksG4927jhefvHPv4uzi028+68exZtu2n/efail6nxfNiAE0dioSQPitZqlMxMKMtAvP7bbHnXYqH476t/pdgFIFha1qVvQ9GJPGNM+zy41XVOIRZJYVlIcm+ocotVKMZRs2pXbV0OdV+y2rvQe1b9oaBBQ/w+iWrM0esZMG+BCMuYAQxHnS1UzZrRUNBR9kSSGMSY4s2NFiHfNemLkjQag1yF6nZOL7ZqGWPVy0WqZz0bEVjenxoe5Ku69onh6jXRuyqeG96DcR0ooVD8XxS9916aZRZGtmMKYrVzipHHRwUGQfjkXs7MTZu53z6FZjS5VXySJZYZFkUf5N6w8xrr77aq/RxGiMTkPN599BQqn5mXbZybMPWOTU/ZYqkRQZ7uHIuDSws357hX51uuF/+OF+/HffvxZPdvSxrcsNaZp51C/Hdr5xtveXQ6ANO08jqQAncyBZwDWVwslwGJLG9+ik0ijM8OAocNDJq9YMGYMnmjHmCn7xKdnu3OYy32WMs6tYU8o6TI8zTHqBV175hj6HlSGu3lJM59K7vTVbTvre8Ap25V5Ymr+owVjICo3THQSr0130renccqvONRx15Hh0qp13jhPGZIGO0ZBG3YRAwB8YbGbOp4+zjWme9DfvUNTKugaut+ik/RuR19nxkJAMObT/812p4+us6ZUNAsGcXbCnNtdLLCJKXuc7TQ0NZxEkV9mTj+7yrBnrvHtpjc4uXl0cACio5wG1ZqhpdE4BsmXgB5r2a0IbdC4kdwRHflurBz5TouIuPXBW9tQcE1Ty3rR5Wzkex0F17RBv4lo51k53b1o5yecaMeFwI22X1bGd0BAQMAmh0s71w7jdKS3sQJzTEPTzlsJ61I7jzdZ5DtddzwrHS0fUTQ4C4rnFxmBdh4QELAloGsn93nGt/TMLtRWEflORbddo6gr53sbTDyWdp7tY9Vq5+sruKby3xKGqSVVLzcldHexMZuina9kfLvfr9d9D7TzgICAgM2Jlqd2rmjnKYe7dl4XezivNQqxG/mW23SA59YbdmPfcAmj5Tz+j5sOrFv/zxddke+Mays4zoSAi4ctHfmG4D0jw6LZ9CKWOtLL5hcs5YsQL1IJALxSzYxw96qrLbgAr0jaWfkHE5ZqlSGKBiA7EhxFILCK3ulrTMOr162F5JLERJxdYTKy/HvDb4O1PUq0jXALExWmQ4PgWgHeFZMDjPCd7gfJ56Uad/o6PLp/5Ai7rbDwJdRLK3DrrxtK+zKLZ30N3p1M10fP6Kt7z1xaebJzUH5WkW9CiR1LL7jfgzERUQhmUyCMaJyiIaap90RzmRgz7AyPcsiYORcHIOj2ennqutyDRUuFGlKR7/lV5HyvjXa+9XO+G4op0It2nhn5VtedO8+c7z1DRRwY7cPJuTre/AffwntefR1+90tPYXqphX/+lVd49+5iQd/XoVIOi43OKgTX1t84vmxp50JIUVAF2tcHccMzAADR6Wkk5ybMd/Ge3QCAuX99FYY+97A8POkYKjL2jcvfEzO2SoRgVmG6kzgq31ZNPLruGlvB4+njYDMzdh8Fky410A+RVdEEsKk9ThoaYOc30YuVpt7ZbH7ebiMkc67x1MxV+hItFkCu2CO/P30uU9nbo8L3EuFyKPqGas65z4DLuAaPYp/L+5R/t219XRnn57Wapd+PDIEfkNcTzS+BndFMsTZYRd1X/Vu3CTlv0li9oxYrmedhMzOAur20VDKpdyZlSwhLw3f65AnEcidtzEnlIzlHuV6nlnlrlMgIuubu/R6g0htIHJvnyxtLSnpWJgm4tNCGpUc7T0e+V2COaRTdUmM68q2em5deswP3vfeV69fxC0R6Wk/Tzt1t6TVRwPpiaxvfWVALSp6io7v5xm5ZDmM8uiWdXLjGjzLaRSfx6ePaqDtzzhr25iCa+SL2TpHKSdSq36LeMJOIydWOc4j2ykUJO3POHsSt8rgr6UxKJVtuC92GoCzpZT/3yrM2fW80Le05nwd0/eDZBWeBpMqcRcu8tPT94Fa5mxAiy5Pp613JGNc0bLDe9HYnh7zr3hIKqvPt9u+F6FMLlMMnzD3tlXsuWi3Qx47avqauC04ZOEKJ3z+9CMvljI4AGAN27ZBfq+chrQovHM+s0Mr7PcZItNvg2F7Gt6aJDzo1mU3kexU5392Ca47a+TaknddXnfPtlFlMlUpZK+KI4s/e+iL8f/7wARydqXlqsUemqvihAyPn1e5aoA3fnQMFLDY62ZHvjFJjboS6vAaV14RxzNc72DlQsH1waOch8h0QEBCweeDlfEdahMyf85sm8r28I7qoIt8JF6aNTcAwz0Sadp5tfGsBua2/BtrMCLTzgICALYHFho58W5/hyJoi33Iy1YZlltq59nJvJ+N7bTnf3PvufHDlWBl//Qsvxb/94Su8RYi+fxcTQghj7O7ol89GPSOynUU7P+nke6+lJuuv/OWjuOnXv4xHTy/YPjjnDKXGAgICAjYPjPG9TKkxsyZYMefbfq9ZVpuhpncWugXXMmjnPZgAAeuL7Rf5dmo494T7nUMxAuDX8061oaOQXZFM/T1jhmat24uGyqZ+NJ+d8ynWPfohrpCRbVJrgqi63K4COzs7aY9xxcCMDpqluIl221CnBKEgVEecLX17RaEzV/m03XbqV9sa66LdXpYin6Zuu9FiLTBGhgch5hcASAVzQyHPooYTapkIzRaQEeWV1DLd8e6xBiwbgcwvAn27ZH9Ghq2qLPMF8wyt21Vmd8+pxyafA681vGMAyVzQauuAI/4WxyB1lSPb8tX0u8ZgJUbAWvfbIqg0LJ1YQ6udL2QYdrVWAkKAPpXzrD25I315zFRbqLcZGBeIKDEUq4FijEaHbYs633rx0DPynVHn+0Jp5xrjg0V85N89H3f85LPxf/6vh3D/0VlUGh0kjIMJkTnprwdaCTfEn50D8r2bSTt3HC+aXnhi1tKP620pnpMlzpjG33z3DADgf/7TIfzZW1+MRod5DNnLinYOeFRkXq8DD/4AAJCk3uNsWvKFh/92yTCoMqnIhIDE6n8+51N6jSr46DCIpvRWamAzs2afLGh1dX5u0jK1CgXQ/XvlDjNzUswVACgB1XN4u2No7x40xXqw36RlueemhYJVSa/Xsynrql1erwOHjjjX3r1M89hWhEjKtfpsWFHUKndzd12i1cS5AFUUf/HMA6CLSqH76EnTF1IsoPny5wMA+h48bhTj3XQ/078oskwtZ4zY/CKIGhPm9j2Lsu7Q8+Mrr4CoqnuQVsEnzrzoVlExoqSK0ZbPGRV5UW+Yc9O+PgiV1kBabfCTZ2wbOgUw6XSz9xwqv0g6EEt2rtbPnDcmXp9pzwom2x0J4/jDfzmGyUoTz9jVj//4kis3tD/tjJzvXoJrK+d82/eadvRuhpreWeiKfGdE9bUzIuR8X1xsfePbKd0ESJo1ABDGrHK3k2PsHRpFiBTVV+fZitl5EL3wFiSTUiw4tYsBN8/XyYHW6uBkaNAoqpP+MsiiLneSUlnXRurznwlWkLclv1jrcgS4x7n5SS5kn9XkicjmH2fkoffKR3b7BGKp4eDcjmuj4Z/foVkDKuc7o8wPosi27aiMiyv3gOp/+Gqt69oIJbbE175xYEpNdp0OROLtaK83Qwnfy3lTH9ncAqheIPRYsJk2kbp/6ny0VASulZMKWaxBaIeJ4KAqF42OjQLK8OBzC1aJnguIiUkzPnpsNGi5BOwYlX/ML5rvWKXq0fzNwlQIkIQD22jdn0U7d+t8u8ZSvZ3gFR/5GsbKeXzxl34EhBAzmYyV80YRu9ZOMFjMGcG1gWKMqaVWV83PrYZf+dz38LmHTgNYTZ3v9RNcS2OoL2ccJFOVFv7V//waBks5/O3bX5aptHqhcA3dMVWXtd7JML4z6nwfn7WRb1lqha+48HJxeLLa1Tbg538HBAQEXG647+lZ/NY9T5q/b756FNfsGtiw/mjnulfnO6XzslrBNUoJ8jFFO+GobbnId++c70A7v7gItPOAgIAtgUqjW3BN53x3mDATHyANoemlFp6cWMLT09IoajnRbW14aoqy/U63t3UnnnbCjeENAHGPsmGu2nmHcdz9wEkzVudbaiwL2vj+wdlFnFlo4IlzFfzd986uW/su9P3sy0coF+SiaSXBNU07PzHrlxlba672RKUJIYRR5T/fdgICAgI2M45OV/HIqYVVR0cnFv0yrmcWNrYGqo5yFxzBte6cb/n3SoJruh3AoZ1v0sj36mjnIef7UmDrR74BRzmbdtXtNrtkRD1JPmcoWuaRjCJDCyaESApY6jhARSKhBM3UZ8wudNGK+MSU6ZNgjtJoDyVrWm0helpSoHitbqlrbjQX+qMAyTlR/8jSoexOxDCyPUG1LCq3A5duRSIKunNMtrFYMcyALhVwp1440C1Mp0FLRSse1rF9JcfPgHfc613mxc64oQUKxr3x6RXVN39njGWXcv4K45MpxEYp6IyqLe+q7bt9SBJAn4dzLw3BjKebmqD7wQUqz5e0+IGnSyCnJ7v7FEUgZUXhB0CqnW0V+TY5307ku5SLjNd5vtZGv2KNuLWev3V0DtfsGjCTSTEXoVyIsdjoGMNIRyeH+7a+8T1X899B5UL2az4X2cj3V5+cwn//m++b79Yr8g3Y+3VsxtK6P3Xv03jDjfvWPUKg86vLhdikG6yU890wxrevel1vM4ytcD6Ros2eWWh0Rb4vJ9o5iWPE+/eDz0qlb16rOxTkVBqXZv2k1LXN/GXefczShYt9linlVvio1xENyeoTWvG6dycdurNDjxbtNtjTx9V15KxqEmOmQgYtFc2awLDcrtqP+rWSQdd33yHzTqd9fQ7tu2mp0zQydG/aXwa0o0uz75aqVjFeCC8lTQuBkihCtH+fbHtqRip5a2hFb+r832uF+JRjiCsaOR56zJ9ttcr30hIKX/yOHAYaWZZhlsI6s0r0IMQfW+e8JCcZKXRoGBiRCuFw0+vUccmxE377qk8ew4txw0ITjNm5k5tFj3Ox3DwvrNUCXDX61Dn0NXZXuXGrrKSOc8bEPNM0MkrzJI7Bk+1BO//Jj34DjQ7D13/lFbhyrLzi/vMpQdTZao9KAZcIvuBaNu08rQOzHIq5CEvNxKwnLjBr66IhPd1mRr4VFf0vHzqNlz5jDDv6V3ifBpwX1vyI3HvvvXjta1+LvXv3ghCCz3/+8+a7TqeD97znPXjuc5+LcrmMvXv34j/9p/+Es2f9KMfc3Bxuu+02DA4OYnh4GG9961tRrVZxXhDSoBWMgbc74PW6/Gk4njZCZX5O0rFUZCFfxLxSAa9UwGZmwWZmbRktAMjnEO0eR7R73FK81UTIG035U1kCZubkjwO+WJE/zZbsV7tjFbxdA1jnLkeRzJk6dc4eq47xHAaKsp2lJG5Kr+h+OuXQupTMnX64beoffYzgQi5ymi2IZgukWAQtyR+Si72SX+ACUCXK0v2mpSKioUFEQ4Myn7uhfpwJi9caEK1Wdz6cvl+MmXEXZyb8cXXvteo3ocRcDy0UQPM5o27ehdSY6XN6452isJN8Xv6o73mtjuTsBJKzE2BzC/Y4QiGEgBACbHoWbG4BbG5BLuLSuf9dN1V+z+t1DHzx+xj44vdBqg2Zv1ZvpBYXAqLdkQ4lQrqV97c4KipPd7BkF5WEEBP9dgW9Jiv2GXrgmPzfdL3d2kivtmRurxZfG1VU5a2c8z1bs9f+6ufsxpteeEXmfq7a+cRiM/O79YDO0T86bd+tT01Wcd/TM+t2Dg3tRCnnI5Prvlq18/QYrMZobqQo7d89uWAWYNqR0+xwJBfxedp0c3JAQMC2xoASPXVFS5fDfMohPFvdWCeEnt9lzjfxtmmYUmP5lc0krYiuj9mske/VqJ2XldP63qem8a7PPnIpupWJfzk8jd+650l8/GtHTMrhdsKaje9arYbnP//5+NjHPtb1Xb1ex8MPP4w77rgDDz/8MP76r/8ahw4dwk//9E97+91222147LHH8KUvfQlf+MIXcO+99+Jtb3vb+V9FQEDAtkcW7RzIVjyfqFhD6oGjsxBCeLU9NSW51krQ6DCT96zzhLdD5Pu63QP4xH/4YVy9sz9zPzfnO61EfqGCay6GS3JM08bsoYmldTuHhjZ8ZeS7N+18KSPynRbty4qYp1FNLT6/e3LBGPPjSvANgJcSsd4Ic3JAQMClhDa+V2sUpdlYMxsc+W4ZtfOoZ51vHflejTioLjdW33K08+55/r+8/CoThHDZapcSjAv83J89hE987Wl8+J5D+IvvnNqQflxMrJl2/upXvxqvfvWrM78bGhrCl770JW/b7//+7+NFL3oRTp48iQMHDuCJJ57APffcg+985zt44QtfCAD4vd/7PbzmNa/BRz7yEezdu/c8LkMhHUHsRbF2a3q7FF99WE39AzEGDEsqGykUDF1YcGGFxBizitmE9FRKz4KmI9HREaP82lMN0xV7M9QvbvtPCeigXGTzxYqhS+kIMACQfMmqnuo2osgq+lJbC5s4JDTBBfjcgtweURAlJkdLRQjFFOCNJiC6X8SCK8qc8CPvun/RUBmioQwlV+isV/1qrdTaSNUBd2tqu+riWn28XAYpKHX0yWnVlj2cloryGrovIFOUjhQLoIrizTX9PV1bnkgjMdo5DL6wuOK1dZ/EUXJ1hOno5Ey2kJ37YmV88xabPE9oA9FVO3f/dif4Kcf4nlpq4fhs3Uy4hZgaKna1lRgV9YgS09alEFxrdhg+fd9xvPb5e3DFSN+6taujCnoC7QU35zttfF9IqbE00vdLY/oiLMAM7Twfo2Ro592Gr5uHXe8k4FxgQTlvdvTnMVNto7qKEmGVlPF9eGoJNx4YBiAj37mISD2CVtJzHC4Um2lOFkmC5PhJQ9+l/f1o/Oh1AIDyQyeRTGSkyzgsHVooQDA5TpreLf9QSuDVajblWQgw/Y512osPXgmhKfBOe+Z8Y6MOvZzbeTjNvjJUbmqUxTW7jh05hoKiqzNCfdVyfb44Br/pBgBA9OgRk24l2m2rnl1ZyrxG0VHvNcHNdpEkPi2bOHRwl2Ku+62o3pL9t4p3W9Y+nEFAUe3Llmqsr5MWCmi/8gUAgOLpCtgThzPb0tfDl6oQjkJ4JlT/4/GdECp9j03PyrSujH0NJVyo30niV5hZCUKYsYz37fWEeAGp8q7XS61XvQCtEfmOGf7yYfAlxRRhzBNNdZ8DlrFG2orQ2iirjnwr2vmVY304MVvHzEZHvjPUztMOd+2UXanUGGBF2eotu5bYjOhWO+++th++chR//fMvxSs+8jUzJ15qVJuJN29PVjZWI+Bi4KJnJiwuLoIQguHhYQDA/fffj+HhYTPJA8Att9wCSikeeOCBzDZarRYqlYr3ExAQcPmg2WHGeB5MGTF7hmSE8ZxDG55Ivay/e3LeMb4jQzuvtRIsKe99fyHuKb5yMfBn95/Ab93zJD70hSfWtd3Z2uqMbzfyXbmIke+00anXJTNL6z+xG9p5IUKfXhClqOGMC29ir7cZlpqJ8WPuG5bGVX0VtPN0NH+u1jaGfX8hNk6ezSS6FubkgICAC8GaaefKiLtGsbDc1KiNgJfzvY6Ca3VDO1+3rq4rVhP5BmzKVK3NNqTed5pRoQMk2wkXVXCt2WziPe95D/79v//3GByUEeSJiQns2rXL70QcY3R0FBMTE5nt3HnnnfjABz6w8glTZccyPZ7pKHiWN9SJNuL0OfV5mQdQR5kFy2zPy892SpHxq5VgypPHbSST0GzhNK97rrCHEoyLc0iuOyBP8ejTsgyYvgbY82tRGhNh98puMduP1Jjp84gEIDrSXyhYsZgeXmV9P3ijAaLPSSiiMVk2i0QUMNdOTMQhncftXHz3OVT+tYGO3hMC0qeE8YoFcCNiw/3fyIh0mNMJU2bNZSXwWt2I5GnxF5KLvX3093z/LlPnVD4rkTm/94ymSrXJzd3XriPt9kRKrK9QQP1lzwKgarJWt4eXHbCTPCHAQEpATEeNT8/bcdE53zqKOVFpoqVpZDlq8ppqrcRELweKsa35eQmM7+8cnzO/V1tTejWYq+lrX14oxeR8s4zI9zoKrqWN72eOD+DJiaV1ox7+2f3HUYgjvOmm/Vbt3KOdLy+A1mgzszgs5yNTvm41VPE07Xyu1jbH9RVi9BdiLNQ7m0Z07ZLPyQEBAdsOOvWrukrauc75vma8H195cmrz5HxH2YJrjAuzz2oF1wCYShdbudQYIO+vrqK8UG9j12Axc7+LhfR8uR45380OQ6PNZLWbTaCId9GM706ngze96U0QQuATn/jEBbX1vve9D7fffrv5u1KpYP/+/V370XzOCHh1KW2vYMB5+2nju5NYFxahlkrE/QdDG1lCEM+YtacTqgnHqGq2EJ2aks111RK39bVXTVEWHNEjkuZFcjGE95U6P+eGMi7mMl5+Xcqe2Ya1MRh7GKxdx+vjjNK7cAzJpjE66PAQmKahuSJz7ri5NrmqtU5ysVWUFwL0SikwRRIGrijmfKlqnSR6PJSw3EpwHSOu4a7F+UxN9zj2nRc5RTufq0KUiua6jMgcQ+/UCECmBCj6f1p0Tz+XopPYtIJyH+KG2i9JlncYbTFo43CgEHdNbFeMSAfL6XkrsqhpSs/dN4R/PjSN6aWW8XD7tHNmIt+DxVxPCtp6QwiB755aACAj1Sfn6qtSjV0NVks7Xy7nu1d5svOB9qJrXLd7/Yzv7xyfwx1/+xgA4LXP32si2v352NAF07Tz9MRed4zv4b68pwewEqotOW67B4uYqDRTke/IEfbbeOP7ks7J6h3Hl5ZQ+Aeplp0Alo7uOG5JuQwoKrLoJDaNS1fPyOeNg5M3mtbpWe4DtOp1vWEcn6LdNs7ULsVs3T31PuVnzjnvdGcuoJFzflsVRTRb2fvrzyLbYSOSBNF3D8lztlp2/1bLzGO0lLHApb64qlH5dhXi4xhEUeFFs2XnCqfyh1mjMApakOdLXngdiFZm/84Thg5O4ljS8QHwuQVT/YUODmDxZnmPh+6T48oXK/Zet1oofudpeR5P8JZ491LDE8V1L7mvT/WV2c/ttp1vS0VLv2cM0eiI/DxQBhtVKXGPHVMn4eY549WqocvT0RFUny/TKWiHo/TgUQAAm5s3bSdnzlqFdb3WiKgZ+/w/PQh9NcxRNReMWSf8aij+WxBrjXzPqffrtaq290bnfGfRzttOne+mw5Zaqc633Md32kebNOd7pC+PXQMFTC21QAjwrN2DmftRlYI3X+9godFZd+M7YRxfOzSN+Xobz9k3hOv3+P1IP1cXanwfmljC6z92HxodhgOjffjfv/yjq7qvFxMXxfjWk/yJEyfw1a9+1XjYAWD37t2Ympry9k+SBHNzc9i9e3dme4VCAYWVyocEBARsW+iXb5pyDriRb7mYayXM5H9r43tqqYWdKhIsaedykpS0cxv5zhvje30WTUIIHJup4cqxsud1PrvYxPSSXYA8dGJ+/YzvVdLOdX86nHeJkl2MUmMacsI/uy4LsD/+5nHzea7eNkZuXyFySo0tX3e70WZGbG24L2dZEasQXNPPzoHRPsmuSLi5r+V8bIzv1S5SLxbCnBwQELBeMMb3KpyKrnP32l2Kdl5tryvba61Yqc63W8WiV3TYRTp3erMKruVjin/+v16BU/N1jPTlMb6MUT3Sl8d8vdOlVL8e+OIPJvDOP/8uAKAvH+GhX/0xL7d+aZ1p5w8cmzX39ORcHSfn6njm+MAFtXmhWPfYu57kDx8+jC9/+csYG/Mrpd58881YWFjAQw89ZLZ99atfBeccL37xi9d8Pu2RBKTnVbTb0uu42ohxGpr+myrTRcslRDt3INq5w+6nz6HKhMkO0e4oplMqS5cDI1EEvlSVP9qbriPuqiyaWyrLlCVTpb2IG5En1CvDxSpVv9SXPn+SgE/PgE/PmJJUgnGQYkEKiA0P+WOrzhMND3eX4tL76HJb+XzX91r8rCu6LLgptyUaDfBWS967ZhO0vywjyc75zDni2Nuu9yXlsqqhzuX4npmAODPhU+o7SVe5ORLHslxaLpZR5oxxBWwptvR2U4pNj2WS+KXJOh2g0wGfnIao1uSPEOYZEFxkPy/6uuPYf7Yc0IF+0IF+RIP9oAMDsm5sqYj8948j//3jQByD9CqrtgXRS+kcsJHvM/OydN2UopznY4pr1At2utKyCqcpwTVrfOeQi5VBuk6R73/8/gRe+dtfx2//70Pe9kdOLnh/P3wyo+bseUI7Hnb0rxD5dup8p43D9RRcGyjEXvncZ+22CzC+CuZJL5yer+OeH1ha9HytbfK0+x3aeVq13HW2ADJaMaMM5pG+/JrytLWxv3OwYBZpx1W98IFizjhAZi/CAma1uNRzckBAwPaGFVxbOSK52OgYAsAzlPHdZnxVhvvFglv5JJdBO9fO6GKOropCXkwpom9W2jkgK4Fct3twWcMbAIYUYy1do3094Kqo19vMC0QAdo7WjIILjXynBdsWLsI1rRVrjnxXq1UcOXLE/H3s2DE88sgjGB0dxZ49e/Bv/+2/xcMPP4wvfOELYIyZnLHR0VHk83lcf/31+Imf+An87M/+LD75yU+i0+ngHe94B9785jefn9I5JSBUUbHSVHMX52mMG9rW6AhaByQVK56chlD/qCSODS0LTRiDrwf7zIBVax6duuf5TT6xMjo491W5e+Wsu5Rx/ZlQS0U26unCV3zPao9a2phJBFH7G3pVFCHSaus1SycjOUuPzmpbcAFCVHuqpjiAbKodYwDkPw3N50CUEr2YX/AcDXp8SKXq0fNsg5qCxx06njNOcHL3CfXzz502iEP9NuOkqWeqvrtExznMGviuEr29PsCkHTBmKO1s3qEZ5nOGZog4shS8ypKl1teWALp9aOc6LztLMXrPcBGESG/1XK2NqSV5/8cHCxgfkPdjutrCFaNyzAoxNVFfV3Bt0M35XieRkW8ckWkP3zu94G3/rjK2NV354RMLWC/MqojyaHmlnG+ldp6R872egmuUEgwWc070QzpEEi6w0OisGKHvhXt+MGFKxAHS6aAVyvsc2nmzw8G5MAsibTDvGiiYSV6L9Q335Rza+co53/r4wWKM0XIe5xabeOysFB/bPVTA5JK8BzNLF49mudnmZBLHINddI/84chzcVabWFGV3m6sKXiiYd57YI/PQycmz5p0ukg4EU07RxIq8CcZ6U3w1dVgrnPeXJV0ayJ4fAKns7Wq/6KYoMU5qvrhk+mTOTYilkQ8PgahFeXJuwlxzNDhoHKpsft7QvVnHOmg03ZruHJNVNAAgSczcGu8ex/RPXA0AKCxy9H/xe7IvnTYi1T8yMAChrtNdM+h+0Pu+Z/t65T6QqjwPm5kFm5rWF2zOz5eWUP5LWR8+c9QIBZvPdiLqcRZcIDJpWjk/QAAAQlh1cBrZ9ZTDXhGtlnffknPKATdBEO1QwRHteO4kYEoMkMSxnSsXKyh+4bTt4A7pkKJ9feA1p7ySSWNUKQ3MKqrrdYnZVac9uOsFGhnNGDAmq5Bsg2nZlhpb2YDWzuDBomQC9RdiVFsJZpZamc70SwFDO48o8lG3w10b56ulJhdy/ny5jsSxDYMu4bpaxXNdl7uTCLz5Rfvxlpcd7LnvfKrNuXobB8ZsxRe9Jts7XMLR6VqXIOxaoTWANDZKxd3FmldYDz74IG688UbceOONAIDbb78dN954I97//vfjzJkz+Lu/+zucPn0aL3jBC7Bnzx7z881vftO08ZnPfAbXXXcdXvWqV+E1r3kNXv7yl+NTn/rU+l1VQEDAtoI23AZL3f7CQhyZmsqn5xuYWJQv2vGBInYq43tKUYLl/tSqnbd92vl653z/4Ixc+J2Z9/MbtTH+n156JQDgyYlKZj3q88Fa1c5bCevKSV5P2jng532PDxaNE+VCqOeuuj0gJ3Qd5XbzrQGfQq5F0sbKBSPpcXZB3p+RvrxDV1995Lu/EJvx1ovNPUMl7DCR74tnfIc5OSAg4FJiLaXGtKEzot6FmpG1GjZQwjju+vJTeO9fPYpPfO1pq5dzgTCCaw7t3I98r15sDdhake/VQs/ZC6s0fP/Xt07gB2cqODS5hN/+308tG8BIU9nTxrh26ujKI5VmckH3vivyfYHG/HpgzZHvV7ziFcsOwmoGaHR0FHffffdaT90T0ciwPHenAzZv6ymb6GmqVrMWxgDnnkc2s+3d4/L7yhJyD0kxMOFEgun4TrQPSG9r/vQc2FnlhV2htiQt9xlPKQGz9bCdOtWCC+N5pVpkpr9sxV8SG62l+ZyJaouUkJf21EZjI2CqXqWrss2WljL7qD247piCyXPJk1p1b9FJwFnNnBNQIi8qYk/7bT1vXWvcDoZTk1OLsDhUbFZ1PdH6GrmpvYlSEYTWuq6dLSxYoRdKrHK4sONk6pqn6oOnz9cFj5auBfeEI7Tiswh0hCHaMQqu6rmKRjMzqm6U5Rn1ojsmYt7u2MgElHiRhvKyk2IBaDnjtsWxHO0ckNTziUoTp+cb5kU7PlQ0QiG1NjOLgEIuMka2K7g2UMyta853O+E4NCHv9dmFphd9PTYjozs/eu1OfOKfn8ZSK8Hp+TquvcA8pHbCzYJobJU531kUrPUWjNHG9kBRlnPbOVDAYqODmaXWeedepQ33+ZqT852PUcxFKOcj1BStTS8YNZ18oBijLy+jMGeU8S1zvtce+XYp5hp7h0vYMaAj3xfP074Z5+SAgIDtCyu4trIRo52ROpI61l/A8dm6YWgth//9+CTu+vJh8/eLDo7ih68cOZ8uG3AuzPzuC65153yv2vhORb43a873WqDvlzaMOReod5hkC2TkwbvR5WorwcMn5/GSq8e69pNt+s9NOhKt51WdUqjLg5YL5ydTNmWq3xQwU21tisj3RS01dknAmDVmXGozoZ5KJ5u0gjJEKV5ixzBwUtKotHK3SwUmpZJHuXKNM1NCa2YO8YwsGcRVf1RD2f1V2wkhxvASXHiOAm93RWkWRD3YubxRRWVLzgOcy4FAG+XZL0Q2v2AMXSKUIbfaYJvudxSZxRzh2SroRKdHl0qGGl59zjj6jklDkh45bijZJGcVwt0yXbQQW2pZlmo9JXZRWW/YvOiUMavHOL5yP8RSFQAs5dA1tgkFoY7zYgUQSjynQVd7/s4m/1o0GtahUiz4jogetPz0Z0I5RMcq6BsnzsH9IPPq2jqJcdJsB+icnyzaOQDsGynhwRPzeOzsIv7x+7I84FVjfSb3t95mRpCtEFOTD5wWXDufyPfZhQZ+/R+fwM/96NV43hXDZvtTk0tmQm8zjplqC7sGi2glzBiOe4dL2DdSwpMTSzi90Lhg41svdCKlVrocdORbRyCKOWpqm7bWuban7osuf7ajP48jUzId4Hyh88Q0jXGu3jGGtZ6kdw0WcWymhqmlFq5WNWb1YmKwlEMpH6HaSkzke9jN+T7PyLfG3uGiud6Nrmt7KUGHBiHcxZleiLpOgPTiVDsyCTHOXqrnXiFsOk/NpgSJpDfNXFPMCSFmbtB0ZjbXRjSg/s+iCGxhobt/3t/czs9RZCtyUOXYjSLrxI0iM//yBScQ4DhIeasFOtCf3XfVrl6j8IEyxIRauzhzG6/VseOBGdl2pWaZzDQC0+d1zu+qdguH4m0o70eOZSqpQzDQolxv8DYAnpoc3fuY/i4LnBlnOomi7jnPUXcXnbahjHedKwO0UDDrODegYK6LC6N2znTZUQVzT539EVnauwlylEs2ba3dtnOsVzZUmL7SYsE+G3GMqBQDziVtVQysQUhSv2/1+1E7hadXUW7sn5/0hSCfnKhcsPHtGtm96nxr43u1tPP0fumSXlsRw2rOXqh1kDCOn/79+/D4uQpKuQj/67++uOs+TKmgxzN2lvH0dA1fOzS9jPEt771em83X/LWqdursHCgiFxF0mECl2Tlv43tSpSI+a3c/Zo60NkXO98YXOwsICAhYASby3cOg1B7Sj3/taRyfrWPfcMnkHGnq+ak5ufguxJEnqlVxBdcU3Xotdb4/9s9H8A+PnsNHv3LE2/7Y2UXv71PK+J9QdOlijmKkL+cJxl0otJE30pdfkfqWXiCM9OXxi6+6Fq99/l48O1X640Khje9RQz1UEeELqPeqHRjXjktDZqHeNsrmOm/bpB04Odfa0N4zVDROGE1hH+nLmWej3iPy/cf3HcPHvybvta5z21/0je+hUg59+dgsNC/kOgMCAgI2E9YiuDZXs5UkABg20K/9/eN48Phcz+OEEPj6U5Lhd91u6Sw7PFk9/04ruHN7oYfgWtMY36szkboj3xfay43HcNlGvo/O1PD4Oek1anQYvnlkxtuXc2Hm2De9UJYj1PcuC9r4PrhDOsN6Rb4Hi7FhO56v4nkrYcbY1nozW5J2vtkguACyhC4EB1eec1rus55nIZBcI0Vkopqtt5kVYaSEgCsPapoerCnMwhGLWRGEGq8ub7WcaG3bRFupU1NUX4fsturf0pJPIzT1snv0w6kb7taE1qI2vNH0Is5uX12vtKY2a7Vu+Zk7tbaJ2U7LSgxs9w5MvURS8nfeNwVMyxetoCmxsqyIb5JkRrNpWYoykIhaER6lHg/0EHEBwCemMPPvZU7kjocX5MbHDttoslI8BwA0Gn5tdke8zjwnjldc9EoxcKjzuu6saLW8OuPmegixojiOin7WvTH0eX0ORe0nzbZ5Nli1BrGaSMQWgX7xDhazX1m63Bggval/8B9/2Bh4uwYKODFbN5kgabXziqGdx8hleMGXA+MC//TYJADgUZXHXWsleM9fPYovPHrO2/fMQgM/fOUIzi7I+7x3qARCiMlr0tTnC4GOfK9EOQe6a3kPlXK4/ceeecF9yEJv4/v8I8LaoH3mrgF89+SCElxLRb6dnH+NM3r8h0uGVqiNdtdpkVWb+/GzFfyPv38cAPDq5+wx+wwUYoz22THfMySjhZZ2fvlEvgMCArY3NO28uoacb/1+3KNSwdqM4y2f/g4e+b9/PDNS/MS5JUwttVDKRbjtxQdwx98+hiNT62B8O0a2FFzrTjXTxrdb/mo5pCPf24N2bnO+nzjn0zV0JFljttZGwgUIAf7ND+3Db97zJJ44V8ErP/I1vPfV1+HHb/BLVupI99U7+/HY2UoXDX3JWZMNlnKYrbXPW/HcrX5zlRJ1W9wEke8tb3wD3YZx1/etNkjJyurHh63KpUhRpz2DrV73FbB77Lf6jnKAWuXLtLMAUEZ5uvQULCWbFApWXXu1p3VLbuncckW/olyYcj8i6Vj6n5sjDVgDj3PfIFT9pqWyyfnmilYWVRsYPqoM5HNT9hqiyDhDRMP/J7bNCoCr63SMX1LIm+PMOAhunBckF4Pm5b0WrZa5dt5qYdcXjwIAOlfvVtfi0yBJn3IadDpSlRS+US7abUOpp4WCVWVdxbPgUdLN/pE5JykVQZV6rnb4RCPDJkdfl6oz3dXpA8WCyTnnM3Oy79sQiytEvl/6jDHs6C/geVcM4f9+7bO9mtk6+qnhCa71qvPdi9KawkMn5o0BObXUwsRiE19+YtIzvDW1Ske2deR1rzK6961j5Fv3ZWyFMmNAd+S719iuB9JGt74n6RIjGt8/vYh9I6WeonEdxo2jwUa+OzbyndfGd7HrPNrJsW+kZCLfGkN9OfM+zBJc+3/+5aj5/L1TC+bZ6S/GGHXGXN/bHUpxfqmVoNlhq6YxbmWw2TnAofWaih2FAsQzrwIA0JPnrIo3rHNZCGHoy7zpK1zbBnssbNX2aHjYpgK125kOckNndinq+bx1Yqccl4aK7b7H1T50cMhsd2nSwlUvL5etAzZJwNRnWiwiefH1AID4gSdks60W2LSKGk1Pm7mS5PNmDuXVKvCEzYU1QxDH2dORq9qtKdHlsnX4cmavkRDE41JpPpmcsurofdbBadKlOHMo1kVAOfR4s9Wbhs610zqrikjvtDmdKkBGhsD+/+2deXwU15Xvf1W9qqVetEstJMQuwAYMsoRsE28YjDO8OPZLbIJtQmznPRs8cRRnIYmNM8955NkzGS9DzIzzMiab4ziJiVcyDvEDE8RiNrMjNgm0S6ilbqnVW933R3Xdrupu7Wq1BOf7+fSHpruWe2+16ta555zfqW+K9EcFDzdnsc4UXbo9Mq4ATxsQzaq5HKprHQxCMBg15wm5ohbDVb9FHi4fNf6KJlGorR2hnkE4a8YwivHd5Q8hJLFew6zPtnjwu30XAUQE11aUF6GzJ4D//PsFuH1BNHb28AVoQL4HvPbJOXxwRNZPqpiSidkFsoJ/dXN8faLBoFY6FwQhfti5f3A539G1wK+EsHO12vnJRu24R6uHKzo7WWkm5FjNuGlqFj6pbsW51i78353nNca3PyjxRevJYc/35V4831azgTtchqp4rq5+o/wGXd7kR6JR2DlBEGOeS+3yQ0uePX5tyomZqdj3g9vxi69erzG8gYgBpmBSeb67VIJrthTDoHO+lfxyhcOXXHjvs3r+/zybGV+YVwAAqHPJfWjoiIQ9A0CBw6Lp43A4FlZXjx6DeBiiFM37yxEfDvfMn4DPz8nHAwuLAEQUb+N5vrefbsHyf9uJr//y016Pp85tn5ydyj+LeL7lh6YcW+9h5wWOFK5srqBWO/dEhZ03dHjxzuHItT18SWV8m/SaaAOnQ762thQ9H+dk1vomCIIYKawq4dPevN8d3QH8w8s7+cJ5pmoB9gefn8XTrZR0MIUPjjTif39wEocuugAAt8/MwdRwffCmTh86vAGcafbgn949jmffOYbd59owGLjxHTaY49b5Dnu+TUPM+b4SPN/K80B7dwAnw57vz03PBqCNJAMiBm5eOKrhtYdKsemBBQCAzy51aJ6nlEgIUQAmhj3RvYWdK55vYOi1vpWFglxrpMpKdI55Mhjfnm9BhGg0ROopMylSy9NkiqwSu92amoy81rUoyIIsUCl4A3Frfwo6nVZwLZ6SerwlZ3X4tiBysTQWkjQr/zxs2qCPrCrHERqT/IFIyHYooqINURhQjXGln4oAnayorlLlVrWDqcTAuEcgqk1K+LoaLiTndsPQGq7ZGghw74BgTYE0UV4JE0+c19QKV66f1NUddzyjhVJikCLiPAiFNNcmGO6z0Nwa6YsinhIMQlDC2FWr5kKKmddYD/n9kTEOBiPHjhOp0BvREQXK7495exAKC8Ep/Q42t0JnD9cy9/ki4fehkMYbz8e7nwiQ8UogJHGxNCVHKB5CLxNejOfboENa2MDyqzyoNrOeT5oDzfn+6wnZA+O0m1Hf0YNtJ5qw57z8G9353VtR4EjBm/su4o294H1Qhz0DkXz1kQg73xfOoSuflNHvtoUZFhj1In/oSGTN1UlZqdj4lfn8/4oKfX2cPm/8WM6n/rSmHdVN7rgidIonOzPViMzUSC13pS8Rz7difMtj7vEF+cOg05ESE1aYbjFwpfdoz/c7h+oRlBgfs88udUTCzs16+IPqsPNwRIsgIDPVhMbOHrR5fBoPD0EQxHjEqBdh0ovwBSV09gRgt8TOHccaOuANhJBi0GHRtCzcMStX831hhgUX2rpx8XI3Fk7OxIXWLuw624Z//etpAMAX5jmxaFo2vjDPCYNORJ7NjMbOHpxucuPpLUe5N/atTy/ig28sGtCCM6AtMwYgrs6LIjw6cM/3lVdqjHuJVZ7vm6dnY8fplhjPNy/vGl7sNht0WDIrFzazHp09QZxscOPaCXL0guLlTrcY+Tl6E1yTPd/Dy/nm1W9sZjjC3vwOyvkeHoIYDhlT5UgrxpuvdBrM1fKDcbCuAVAZ1NxoCoEbMYIhdijk7cKhZUYDxLAhJLk6NCqYSihyXKM3Wr1cUfk2GrgRLR8jbJBJUlyjW308HmKt03FjHjpdZNHA69UaYuqcZaUcWZwFA0Gniyh4h0IRIz/KQI8cNnKDiaesLXl7IDa1ho8n8T4KNit68uQVL0u1Xu4zgI4vzIP9hEve5sQ5uZTaUAiHk8Fg4OqnGuItkoRCkdAz9YJJQGVkq4x5Fl0uDVHlyqKuIS9Nl2KOlE5jEqSwAjsLxsl9ZxJvk2izAbx9qhu7KEKKl4YgiABEYGTKYiaVunYvghKDSS/yet6DIdr4TjHouGcUiOT7Ws0GbrwNxPN98XI3LrV7oRcFrL5xEn78wQn8/lM5peW6IgfPQ48OK1c834p3VPm+2S0bj/HKeAyELl8QR+vlBZzrB2B8mw06XF+cjr+fkT0HifR8R6MI6Jxt6dKEYx+obcfe85EFtj8drMN37yyJ2V9RSc9KM/HQdHVoeSTnWx5jJe9LMfbtKQauhK8gCPICRJCHnYc05eE+qZbvZfeVFuJXu2twtK6Dq8KnmbRjp1xbAMiyGtHY2TOs/PbxDA8BDwaBg8cAxCRxDfKAqpuaojiuuveG2tsHdSy1HgdHECLnYbGh5mpCalVxFXIIuLyv1BW/7KPU0wNx+0H5fW9NVNrXWx/U26odB0JEr0T9rMHP3d2NGIV3AGAMwcam2LbG07dRnUPyB7RzmKgySAaqP6LaTtDrI4vjauXzaAX0cB+U8PjejhmzcK+kN6j7pb7uiA1rj0EZT3XYPhBpU3e39vgjVKd6LGA1G+Dz+HpVPFfys2+cmon/eKg05ntlflSESL+2eR/Otch/J5OzUvF/7p2j8ShPy01DY2cPfvLhSZxsdMOeYkBRhgVH6jrwyOZPcePULHz1hmIU97FA7wuGsCMsBKakmMWt8z3MUmMjXaozGSg534EQ44Kkn5smazi1eHyadAPFwFUW1QF5AeK6onRsP92CA7Xt3PhuVwnwqUPb1Wg938MLO1cWCnJspoiC+xgoNUZh5wRBjGkutMkTcnFm6pBWlBdMTIdeFJBq1GFFWSGm5qRBrxNj8rSUGtSAdiLujapwuNvcQkdMSY17rivg75WHjDqXF4wxldq2bHRnphphNohgLGKYD4UDte0ISQwFjpQBe1hvmprN34+m8Z1nMyMz1YiQxHgtdAB4/e8XAACFGXL7txys4znYahQBsyyriavoKhh0kTy+6LBzZQFEiTq4dUYO348x+YEhTVXORCk31hMIYW84quChiomwmvSacmxWs54/SACRawuAe+ZJ8ZwgiCsFWz+1vk83yff13spnKvf4S5e70eL24VxLFwQB+PycfLy84rqYUG4l9Hx/jby49o+3T8OrD8yH1axHdbMHr++6gH/56HSfbf7x+yfw3PuytoJiMBvjpJoNX3BtQLuNaVIMOj42gByhNykrVQ6ylZimfCbPq45yjijlyJRrBmhLz2XwWuKR35AkMXj8KuPbPPSw8zaPj6uu51jN/Fmhyx8a0DNeIhnXxjeTWEyordTVDamrG4ZPjoB5vWBeL6/DyaJEznidSSZB6vFB6vHFqEsLoiCvGut0YN1esG4v94Aq51degijIYmK6qD9YQYysDofPo/Fohz3SLCRFQuhjOxvrRZcYJG+PrFgeDELQyR50dYh99L6atobbq2lnKASEQhAEAaLDLr9SzJo+8D7qdJHzh8OfNeJugSAkV4ccKSAKshiLKAKMwbL3Aix7L0Dy+WQFdcbg2FYNwReE4AvK2yvnVL10Vit0VmtMu0WjQX7Z0iB1dsqv3hTgw4gpKRDNJl6LM95vRPL2QPJ0QfJ0RSIAol46Wxp0tjR5vzjXCZAjKwSDHjCo0x9CfPyi65Orx5AFgmBdXbJ1IFsIcsRGtBp62MMu6HTQ2dIiqvPjnJo2+Toq+UGDZUp2Gg6vX4L9T9+BDffM4au1aiNLJwpIMehgMxugEwVILDYXLZrdZ2Xju2JyJkryrZiRa4XDYsC6ZSVYWT6Rb+d0mGE2iOj2h/DxqWY0RIWdC4LA3/cnutbQ4cUn1bElPBhj3INdNgCvt8JNU7P4e3U0QKIRBAGznHIk0dFwSTZ/UOJ1XZ+/dy5sZj0aOnpwoDbWk6l4vrPTTEgz6TX56+paoErYeYc3gJ5AKCK2Fh7vu68rwFNLZIX30vCDgkkv8v0O1LoAAHvPX4Y/KCHfbsbUnDS+ii/3RRbVc1iMvHa6evFjJJTdiV6QQhGvY/j9iDACHsoRb9OgG8A048OCQbCAn79GxAurOgekUGSOiv58KIdWtbfP848kgz1eMq9vkrFy4zu+51spCzYtJ35N+8LwonTt5W4cqXMBkD3eG78yH9cU2GO2Xzo7j0cqzS104MGFEzEh3YLfPrIQK8pkLZEj4Yoj8fD4gvjDfjkyrSTPiv9x8xQAUAmuxaqdmwcYhRa9kH8lhJ0LgoD01MjCdkmeFXqdyOezZlXoueJdzrNrowwV43v76Ras//NRtHl83Ph2WIxwhI/vDYT4mHv8Qf5naDMbIjnffYSdn25y4/mtJ/HPfzmFC62ys+ZciweLnv+YK7XnWE2wmQ08cDTZomvjOuwcgNZoUYULs6AkG30Ih3/FuW7cWFJ/Jokqw06tRs64knRMGLYSGqUKU+dfReWKK/vx/F6+XV+d7AV1CHogABaK5C/3tY+MUporEhqnUTvX6Xius6DXR1RRo1H2jeOdkvPhw8cTGCCEr42rU3vdlHDByy4IqhA+IfoGJohAWPlVhDZcjOd5B4KRY6tD6vWGyG9DXVYuXsi2qt3q66nJ11YdO/pa9oVG3V39ew1Bkx6gbgsg53bzFAnVAg8TRG0bw2kXyMqAIIaAUwNu2pjlfPhm2le+d3+oDTL1Z4oIltWshyAISDHqMHeCHQdqXag624bCjPgGP2OMC70snJwJg07E1icXxc07N+l1WHVDMf59+zk8veUY3OE8YXVo8oR0C861dOFMiwc3qAzi6HM+svlTHKvvxC++WorbSuQcunMtHjz6y09xNhyyNxjje7YzUs97qGFdQ+WaAjs+qW7FsXCo/L4Ll+H2BZGVZkT5pAwsmp6N9z9rwI7qVpQWa/vU6pavW5bVCEEQ4LAYedh5qkpEzZ5i4DnaLW6fSmwtMvZrb5uGO2blcYNbEATcPjMXb+ytxUfHG3Hz9Gy+4LFoWhYEQcCSWbnYFV58YUzeRycA65fPQovHr/ndcHE5d/zJ/kBtO64rdPSqWUAQBDHW4LW+ffHnjepw2Pn0Xj3fSth5Nz67JD/3zZ3g6PV8Cydn4sizSxGSGAy6iF7TtRPs+E76DLyxtxYX2rrR2ROIq1/y7uF6dPtDmJydig+/EZmr4wquhVPRzAP0fOfbUzQZCzlRqW7jlYcqivGb3TUw6kXuUMi1mdHs9qGps4cvkjR2xIadA/IiiUkvosMbwOaqGlhMeqSGxzTDYoTVpIdeFBCUGNq7/ci3p/DFHINOgEkvRtTOw57vmrYuuHuCyEwzIt+egrMtHtz76i6+3+/2XcQ7a2/E+neOodsfQppJj4mZFnxuejZEUYA9xQBXdwAd3QGNGO/e85fR6vHhrmvzEzWcGsal8a0IYgVZACLzQ1Jb1mqDK/xeYBIkpr5BiHG3V75T9mMsBIGFSzqxyLYSi87P7X11TGBC3Lrc0fuozxn32L2Ws5K/FxkDWNj4ZgH5OH2gHZtIya7I8USIUvhhkTEElfFjEt9X9vIqJWJiFzLU7ROYpBpLHZRVA4kFNMdQtumtr5E2+TXXVGSRtiqfq8dAff2U6yEygW/DWPQEEntNNddyUKXmRIiqfml+iwO81oLKoy6wEL8GUtS1Vs4jhHwI8r4lNs9s48aNeOGFF9DY2Ii5c+filVdeQVlZ2YgdvyYcdj5QQZWBojbIrar64TdMycKBWhd2nW3Fl68vBCCvhP+qqgYfn2pGrs2Mm6dno76jBwadwFd3+zKeHrt5Ct7YU8s9rw6LQaO0PafAjh2nW7Dhg5PQiyJunpEdEzp+tK6TG6q/rKrBbSW5ONPsxorX9qDF7YNelNuy7BptTc2+EEUBa26dgt/uqcU98ycMeL+RQDH8j9XJD16KeN1tJTkQRQGfm5aF9z9rwM7qlpj6460qzzcgT+SK8a2EmgPyNclOM6HO5UWz26cpM6ZmRp72AXHJLNn4/uvxZpTk1WDzrhoAwKJpcpj+qhuK0eLxYePHZzFH5QV/sKI4pp+Kp0AdpqdQdbYNK3++G7eV5OBnKxcMOd8/2fA5GYErQmeCIBJBEMqzyfj/I+nL893m8eFylx+CIEeexaMwfA9u6vTh0wtydJM6oigeOlGIW8YrPdWIAkcK6lxeHK/v1KSBNXR48dx7J3ja0P3XF2rmam58hyQwxiAIwqBzvvPsZvzxsRtwrqUL+XYz5hU6BrTfWGfNrVOx5tapms9ybSYcqYt4uxs6vDge9i5Hh52nmfT49SPl+OP+S/jdvovYdqKJz6GOVEN44dyAVo8f7V0B5NtTuHq+1Sx/r1Y733KwDk++eYgfP99u5uViZztt8AUlnGn2YNlLn6DDG4BRJ+K9J27S6AA4wsa3S+Vs8PiC+Op/7kW3P4T3nrgpbuTFSDMujW93uJbjTvYu0ItDFgAQjPpXoa/7HoNW+UR535fQXl/H61VFZYjb9fZ9X+MQj/7Gpiv8Gsy+8VCOJwFQfut9tbU/m7a1l89d/ewXb3G2r6jieOM+1BQR1s+5+jqnQhADG2/lPJFyxHC73bDbE3MzefPNN1FZWYlNmzahvLwcL774IpYuXYpTp04hJyen/wMMgAvhsPPirKGFnfeGOlTMqhLMumFqJv7t4zPYdbYNjDGEJIbHfr0fH5+KhHu/fbAOgJwzPJC8MIfFiHV3zcT6d47BH5RQEZUjvubWqTh8yYVPqlvx/bePQBSA79xZgvlF6chINWJqThr+sP8i33776RZ8dLwJ6/70GVo9fpTkWfHrR8q5oTcYvr20BE8tmTHqntdrnPJv8kSjGx3eAD46Lhvft8+UPfo3hSfpQxdd6PAGNDnpiqGtiOm1qwRU1tyifVjItsrG9+5zbTgcLl/j7CcnvmJKJswGEY2dPfjhlqMAgDtm5eLO8MKGIAj49tIS3D2vAJn9jLlyrkMXXRoBt1aPD9/43UFITFZ+Ha+GN6Cak/FBkltCEGOfRM7JQOIXxIGI8X2m2aO5rwHA6XDIeWG6pdf5MSPVCItRh25/CDvPyA92c/rwfPfHNQU21Lm8OFrXoTG+X95WjffDJUFTDDrcG7XIrL7vBsNe9Z5BGt8AML8oHfOL0ofc/vGC4t1u6uzBO4fr8Y9vHOTf5dpi58LrizMwPceKt/ZfwukmD49KUPK9HRYjWj1+LoIWUTqXf1/K9gdrXTgSjpDITDXC5Q1wIbgJ6Sl4fXUZegIhfPFnu/ji/GO3TIkR4LNbjEBbN1yqPPP/OtbIhXc/ONJAxndvOJ1OHD9+HLNmzcLFixdhs9n632mE6OzsRGFh4aif92o999XY55E6N2MMbrcbTqdzhFsX4ac//SkeffRRrF69GgCwadMmvP/++/jFL36B733ve8M+fjAk8dzr4hH2fCvhwABw74LIhDy/KB1GvYhmtw8/2XoSh2pd2HP+MswGEU8tmYF3P2vA4YsufLl0Ap5ZPnvA51tRVoQvlxaizeOLMZJTjDr8fFUpNv7tDLafbsHhSx34yYcn+fd3zs7DrrOtvN2tHj8eDdfBnpVvw28eKedlO4ZCMkKeizIssJr0cPuCKH3uIwRCDKlGuSwNIOdNT85KxbnWLvxwy1FYzXqIgixgdjTsLVfGcVJWKprdPjgsBiyOKmmjPBC88Bc5B0MvCpiV3/fflNmgw60zcvDh0UYAwPfvKsEjN02OyeXrTUxIza0l2bCa9Khp68aO6hYYdSIOXnThN7tr0Oz2YVpOGn70hYH/jsYiyZyTAZqfrpZzj/c+j8acPBoL4kAk7PyXVTXYd6Edv3q4DDazAT9+/zg3dnvL9wbkOacw3YJTYWE2nSho0qAGyzVOO/5yrIlHhwGy1seWg/UAgG8vnYHbSnJiFkvVomJfe30f1i2byUuNRQupERHvdr3Liy2HZCdEqlGHW0pyeOWRaOwWA64vTsfuc5fxaVh8TREoVVTVFdE1tdI5AK52rhjHcybY8afHboA3EMKpRjdCEsPcQge/Vv/v27fgyKUOmA1i3DQG5XxqxXPFmQLIxve3lybeGTEujW9RFFFQIKsJ22y2Ub8JJ/O8V+u5r8Y+j8S5E7m67vf7sX//fqxbt45/JooiFi9ejKqqqrj7+Hw++FQlfTo7+86Xr3NFyozlReUTDZf/efMUZKQa8VBFsWalU12C69+3yyEEogC8dP91WDo7D1+7cRLauvwxJcwGgk4UYvKiFEx6HSqXzMA375iOX++uwb/+tRpGnYgmdw+2HpONQKfdjP919zV4ePOn0IkCbpqahZfun8frV44nRFHAd5aV4IWtJ9HZE0SBIwUvfGmOJhx/0bQsnGvtwruH62P2n5ydysMUf/j5Wfjt3lo8uXhazHb3zp+Ao3Wd8AZCWDAxHZV3TMfkXkIh1Tz732ajJM+G5XPzB7R9b1iMetwzvwCbq2rw9V/u19STzbWZ8LOV8zV9Ho+MhTk5mee+GvuczHOP5z4nck4GEr8grnBbSQ7+eOASOrwBnGjoxFde2400k56LVAKIqQISzdTcNG58z3bahmXsKnP43vOX8cbeWugEAQcvtsMbCGFGrhWP3zKlF00WEZmpRrR1+fFJdSsOX6xCZ9gAJOM7FmUx+62weF26xYCd370trq6OmsUzc7H7XKTcn+IsUIzwNb89gF1ni1AV1lJRohFL8myYnJ2Kcy1dyEoz4l++NBd6nQirTozRggHkUPeKKb3/7pRyYz//5DwutXtR5/Li7+HIC4NOwIW2bvzpQB3yHWbcMCW+/s5IML5nfIIgkkZraytCoRByc6M8jbm5OHnyZNx9NmzYgB/96EcDPgdjwPK5TkiMjbiCaGlxRtybNwD84K5Z+NXuCwiEGKZkp+GOWTmYmiN7OUVRGJLhPVAEQcCDFcV4YOFECIKAI5c6sPVYA6xmAxbPzMXUnDTs/f7tsJoNAy6FMlZ5cOFE3Du/APtr2jG/KD1mAn9k0WTUd/QgM1UWV/GHQqhp68a8QgcerJgIk17u/7UT7Ngw4dq451gyOw9LZg88D14h12bGN+IY80Nh5cKJ2FxVA39IgtWkx6LpWVg0LRtfvK6AHvAIghgRRmNBXOHGqVk49MwSnGvx4EubqnioucWow4Z7rsX0XCtK8vqODPr+XTMxK9+GYIjhrmsHf49WM7tAXhCpc3mx7k9HNN89WDGxV0+mKAp4+/EbcfiSC5t3XeCeWSBSTo2IkGvXOg8eWTS5X8MbAO66Nh8v/bUabl8QaSY9rglfryKVOOlv9tTy95nhyMRUkx5/+9YtI9BymYxw6c9TTW6+8API1U4yUo34r+NN+NZbh5Fq1OHYP905YueNhn5ZBEGMGuvWrUNlZSX/vxLK1xvFWal4ZcV1o9E0DbOcNmy4Z86on1eNWs01WoimN+/5eMRi1HMRlmgKMyx47aHSUW7RyDM914pvLp6OmrYufGvpjAHXYScIghgoo7EgHs3k7DS8/fiNeOdwHSQG3HVtHl+o7o8CR0qMoNdQybGa8cw/zMKe820ISXKIf4gx5NvN+O8L+hYTLcq0oCjTgttn5uClbdWoae2G05GC6wdROeRqoWJyJpZdk4dL7V44HWZ89YbiAe3ndKRg7w8Wc/0WxXHwxG3TMDUnDd5ACO1dfrR1+WHQiXhg4cR+jjg0Vi4sQlNnD7r8QWSlmVCcaYFRL2LZNfm43OVHs9uHnkAo4Yvi49b4NplMWL9+PUym0ZX0T9Z5r9ZzX419Tva5B0pWVhZ0Oh2ampo0nzc1NSEvL/4qtslkGtN9IohEMVJe9LHK1Xi/vBr7nMxzX419TjSDXRCPR1GmBWtvS/797Ws3TcLXbpo05P0tRj3WLZs5gi268jAbdHj1gQVD2jfFqIuJ1rNbDLg/XKd9NJiSnYaNK+fH/a4ww4Ita24clXYI7EqoeUAQRFIoLy9HWVkZXnnlFQCAJEkoKirC2rVrB5Rf1tnZCbvdjo6OjqTl8BHEWIf+TgiC6A+/3w+LxYI//OEPuPvuu/nnq1atgsvlwp///Od+j0H3GoLon+H+nYzf2iYEQSSdyspKvPbaa9i8eTNOnDiBxx57DF1dXVzshSAIgiCIxGM0GrFgwQJs27aNfyZJErZt24aKiooktowgCDXjNuycIIjkc99996GlpQXPPPMMGhsbMW/ePGzdujUm54wgCIIgiMRSWVmJVatWobS0FGVlZXjxxRdpQZwgxhhkfBMEMSzWrl2LtWvXJrsZBEEQBHFVQwviBDH2IeObIAiCIAiCIK4AaEGcIMY2lPNNEARBEARBEARBEAmGjG+CIAiCIAiCIAiCSDAUdk4QRNJQKh12dnYmuSUEMXZR/j6oMihBEImE5mSC6J/hzslkfBMEkTTcbjcAoLCwMMktIYixj9vtht1uT3YzCIK4QqE5mSAGzlDnZIHRUjpBEElCkiTU19fDarVCEIS423R2dqKwsBAXL16EzWYb5RaOXWhc4nMljgtjDG63G06nE6JI2WIEQSQGmpOHDo1LfK7EcRnunEyeb4IgkoYoipgwYcKAtrXZbFfMjXskoXGJz5U2LuTxJggi0dCcPHxoXOJzpY3LcOZkWkInCIIgCIIgCIIgiARDxjdBEARBEARBEARBJBgyvgmCGNOYTCasX78eJpMp2U0ZU9C4xIfGhSAIInHQPTY+NC7xoXGJhQTXCIIgCIIgCIIgCCLBkOebIAiCIAiCIAiCIBIMGd8EQRAEQRAEQRAEkWDI+CYIgiAIgiAIgiCIBEPGN0EQBEEQBEEQBEEkGDK+CYIYs2zcuBHFxcUwm80oLy/H3r17k92kUeXZZ5+FIAiaV0lJCf++p6cHa9asQWZmJtLS0nDvvfeiqakpiS1OHDt27MDy5cvhdDohCAK2bNmi+Z4xhmeeeQb5+flISUnB4sWLUV1drdnm8uXLWLlyJWw2GxwOBx5++GF4PJ5R7AVBEMT4huZlmpcBmpOHAxnfBEGMSd58801UVlZi/fr1OHDgAObOnYulS5eiubk52U0bVWbPno2Ghgb+2rlzJ//um9/8Jt5991289dZb2L59O+rr63HPPfcksbWJo6urC3PnzsXGjRvjfv/888/j5ZdfxqZNm7Bnzx6kpqZi6dKl6Onp4dusXLkSx44dw0cffYT33nsPO3bswNe//vXR6gJBEMS4huZlGZqXaU4eFowgCGIMUlZWxtasWcP/HwqFmNPpZBs2bEhiq0aX9evXs7lz58b9zuVyMYPBwN566y3+2YkTJxgAVlVVNUotTA4A2Ntvv83/L0kSy8vLYy+88AL/zOVyMZPJxN544w3GGGPHjx9nANi+ffv4Nh9++CETBIHV1dWNWtsJgiDGKzQv07wcD5qTBwd5vgmCGHP4/X7s378fixcv5p+JoojFixejqqoqiS0bfaqrq+F0OjF58mSsXLkStbW1AID9+/cjEAhoxqikpARFRUVX3RidP38ejY2NmrGw2+0oLy/nY1FVVQWHw4HS0lK+zeLFiyGKIvbs2TPqbSYIghhP0LwcgeblvqE5uW/I+CYIYszR2tqKUCiE3Nxczee5ublobGxMUqtGn/Lycrz++uvYunUrXn31VZw/fx6LFi2C2+1GY2MjjEYjHA6HZp+rbYwA8P729XtpbGxETk6O5nu9Xo+MjIyrbrwIgiAGC83LMjQv9w/NyX2jT3YDCIIgiPgsW7aMv58zZw7Ky8sxceJE/P73v0dKSkoSW0YQBEEQVx80LxPDhTzfBEGMObKysqDT6WIUQpuampCXl5ekViUfh8OB6dOn48yZM8jLy4Pf74fL5dJsczWOkdLfvn4veXl5MaJAwWAQly9fvurGiyAIYrDQvBwfmpdjoTm5b8j4JghizGE0GrFgwQJs27aNfyZJErZt24aKiooktiy5eDwenD17Fvn5+ViwYAEMBoNmjE6dOoXa2tqrbowmTZqEvLw8zVh0dnZiz549fCwqKirgcrmwf/9+vs3f/vY3SJKE8vLyUW8zQRDEeILm5fjQvBwLzcl9Q2HnBEGMSSorK7Fq1SqUlpairKwML774Irq6urB69epkN23UeOqpp7B8+XJMnDgR9fX1WL9+PXQ6HVasWAG73Y6HH34YlZWVyMjIgM1mwxNPPIGKigosXLgw2U0fcTweD86cOcP/f/78eRw6dAgZGRkoKirCk08+ieeeew7Tpk3DpEmT8PTTT8PpdOLuu+8GAMycORN33nknHn30UWzatAmBQABr167F/fffD6fTmaReEQRBjB9oXqZ5WYHm5GGQbLl1giCI3njllVdYUVERMxqNrKysjO3evTvZTRpV7rvvPpafn8+MRiMrKChg9913Hztz5gz/3uv1sscff5ylp6czi8XCvvjFL7KGhoYktjhxfPzxxwxAzGvVqlWMMbm0ydNPP81yc3OZyWRit99+Ozt16pTmGG1tbWzFihUsLS2N2Ww2tnr1auZ2u5PQG4IgiPEJzcs0LzNGc/JwEBhjLFmGP0EQBEEQBEEQBEFcDVDON0EQBEEQBEEQBEEkGDK+CYIgCIIgCIIgCCLBkPFNEARBEARBEARBEAmGjG+CIAiCIAiCIAiCSDBkfBMEQRAEQRAEQRBEgiHjmyAIgiAIgiAIgiASDBnfBEEQBEEQBEEQBJFgyPgmCIIgCIIgCIIgiARDxjdBEARBEARBEARBJBgyvgmCIAiCIAiCIAgiwZDxTRAEQRAEQRAEQRAJhoxvgiAIgiAIgiAIgkgw/x9g7RWLCWdVXQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the profiles\n", + "\n", + "fig, ax = plt.subplots(1, 4, figsize=(12, 3))\n", + "\n", + "rgc_img = rgc_img.squeeze()\n", + "\n", + "ax[0].matshow(rgc_img[rgc_img.shape[0]//2, :, : ])\n", + "ax[1].plot(rgc_img[rgc_img.shape[0]//2, rgc_img.shape[0]//2, : ])\n", + "ax[2].matshow(rgc_img[:,:, rgc_img.shape[0]//2])\n", + "ax[3].plot(rgc_img[:,rgc_img.shape[0]//2, rgc_img.shape[0]//2])\n", + "\n", + "ax[0].set_title(\"XY subsampled PSF\")\n", + "ax[1].set_title(\"XY intensity at the center\")\n", + "ax[2].set_title(\"XZ subsampled PSF\")\n", + "ax[3].set_title(\"XZ intensity at the center\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "nanopyxdev", + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 86f1a0c80be9859f1d7994c3bd519e60794d5a38 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Tue, 19 Mar 2024 15:39:04 +0000 Subject: [PATCH 67/81] added one-frame case --- .../transform/sr_temporal_correlations.py | 33 +++++++++++-------- 1 file changed, 19 insertions(+), 14 deletions(-) diff --git a/src/nanopyx/core/transform/sr_temporal_correlations.py b/src/nanopyx/core/transform/sr_temporal_correlations.py index 25ceb96b..f33785a0 100644 --- a/src/nanopyx/core/transform/sr_temporal_correlations.py +++ b/src/nanopyx/core/transform/sr_temporal_correlations.py @@ -224,21 +224,26 @@ def calculate_eSRRF3d_temporal_correlations(rgc_map, correlation: str = "AVG", f # correlation (str): Type of correlation to calculate. Should be "AVG", "VAR", or "TAC2" n_frames, n_slices, n_rows, n_cols = rgc_map.shape[0], rgc_map.shape[1], rgc_map.shape[2], rgc_map.shape[3] - if framewindow != 0: - if rollingoverlap: - n_windows = int((n_frames - framewindow) / rollingoverlap) + 1 - else: - n_windows = int(n_frames / framewindow) + if n_frames == 1: + print("Only one frame, no temporal correlations can be calculated") + return rgc_map + else: - n_windows = 1 - framewindow = n_frames - 1 + if framewindow != 0: + if rollingoverlap: + n_windows = int((n_frames - framewindow) / rollingoverlap) + 1 + else: + n_windows = int(n_frames / framewindow) + else: + n_windows = 1 + framewindow = n_frames - 1 - avg_rgc_map = np.zeros((n_windows, n_slices, n_rows, n_cols), dtype=np.float32) + avg_rgc_map = np.zeros((n_windows, n_slices, n_rows, n_cols), dtype=np.float32) - for w in range(n_windows): - start_frame = w * (int(framewindow) - int(rollingoverlap)) - end_frame = start_frame + int(framewindow) - # do average in the first dimension of rgc_map[start_frame:end_frame ,:,:,:] with numpy - avg_rgc_map[w,:,:,:] = calculate_eSRRF_temporal_correlations(rgc_map[start_frame:end_frame,:,:,:], correlation) + for w in range(n_windows): + start_frame = w * (int(framewindow) - int(rollingoverlap)) + end_frame = start_frame + int(framewindow) + # do average in the first dimension of rgc_map[start_frame:end_frame ,:,:,:] with numpy + avg_rgc_map[w,:,:,:] = calculate_eSRRF_temporal_correlations(rgc_map[start_frame:end_frame,:,:,:], correlation) - return avg_rgc_map \ No newline at end of file + return avg_rgc_map \ No newline at end of file From f2e702054223b5791ff3e174ec33f46d1817caca Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Tue, 19 Mar 2024 15:39:35 +0000 Subject: [PATCH 68/81] . --- tests/notebooks/esrrf3d.ipynb | 328 ++++++++++++++++------------------ 1 file changed, 156 insertions(+), 172 deletions(-) diff --git a/tests/notebooks/esrrf3d.ipynb b/tests/notebooks/esrrf3d.ipynb index d57c693b..8ea24d40 100644 --- a/tests/notebooks/esrrf3d.ipynb +++ b/tests/notebooks/esrrf3d.ipynb @@ -54,12 +54,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d45a8662548f4443a239f0784edde02f", + "model_id": "bd77d0d909714305b3da3b3ad9146877", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=50, width=50),)),)), IntSlider(value=4, descri…" + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=50, width=50),)),)), IntSlider(value=2, descri…" ] }, "execution_count": 4, @@ -74,16 +74,17 @@ "# planes = [1, 3, 5, 7]\n", "# planes = [0, 4, 8]\n", "planes = [0, 1, 2, 3, 4, 5, 6, 7, 8]\n", + "planes = [2, 3, 4, 5, 6]\n", "img4ana = img[:, planes, :, :]\n", "\n", - "name_save = \"All_planes\"\n", + "name_save = \"penta_planes\"\n", "\n", "stackview.slice(img4ana[0])" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -97,13 +98,13 @@ "sensitivity=2\n", "run_type=\"Threaded\"\n", "correlation=\"AVG\"\n", - "framewindow=0\n", - "rollingoverlap=1\n" + "framewindow=4\n", + "rollingoverlap=2\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -113,335 +114,308 @@ "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002486208000000545 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0449771127128766, Delay probability: 0.26726405723271807\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013462919999938094 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002401542000000312 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013667919999988953 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.017893250000000194 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.6365478090491987, Delay probability: 0.2378729659297821\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005537709000009272 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011695125000001028 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005368333000006942 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011303749999999724 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0055529999999919255 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024060419999987204 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0014406670000255417 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0737183763267601, Delay probability: 0.30827479597258406\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002484416000001488 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0442495150144253, Delay probability: 0.26726405723271807\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013626660000056745 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010758457999999749 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005570584000025747 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012998707999999581 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1918169081951844, Delay probability: 0.2337475292239949\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.00546837499999242 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01078304199999991 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005385125000003654 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023923750000012234 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.001346041000005016 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023948339999986246 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013441250000028049 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.013203583000001018 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.2076226973998954, Delay probability: 0.2378729659297821\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0054856669999878704 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011041207999999969 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005531832999992048 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011621292000000949 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0056671250000022155 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002386583999999914 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013387089999810087 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024472079999995344 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.028087379748086, Delay probability: 0.27511712348806283\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0014154999999789197 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0555437485651324, Delay probability: 0.4083441962488562\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01108720800000107 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005619042000006402 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01838283300000043 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.683443278084913, Delay probability: 0.2378729659297821\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005384374999977126 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011182875000001147 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0054248330000064016 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002387124999998491 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0014457080000056521 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0780699693954734, Delay probability: 0.4083441962488562\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002433749999998014 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0014555420000021968 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0854032206988269, Delay probability: 0.4083441962488562\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.014426582999998772 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.3194804074561162, Delay probability: 0.2378729659297821\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005476750000013908 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011199249999997107 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005451708000009603 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010441291999999436 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0056754999999952815 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002373625000000601 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0014317499999947358 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0676614355528637, Delay probability: 0.47298380752538954\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024152920000020117 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013645839999867349 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011508708999997452 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005447500000002492 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011766791999999526 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0054912919999878795 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010249416000000622 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005695124999988366 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024262909999990256 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013360419999912665 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024693330000005176 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0361757074721745, Delay probability: 0.14141774947896593\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013282500000002528 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.02346250000000083 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 2.1459211138176557, Delay probability: 0.2378729659297821\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005428874999978461 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.02093149999999966 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.914431445663162, Delay probability: 0.2767244691988686\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.00533270799999741 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01131275000000187 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0054650840000078915 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024482080000005624 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013580829999852995 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024092910000028667 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013807500000098116 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010204416000000549 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005521249999986821 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010353000000002055 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005496458000010307 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010084417000001622 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0054619590000015705 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024864579999999137 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0431296879330099, Delay probability: 0.14715974993365105\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013678329999891048 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024572499999990782 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0308762205806477, Delay probability: 0.14715974993365105\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.001322375000000875 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012308916999998587 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1257949868311181, Delay probability: 0.2378729659297821\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0054277499999955126 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010267667000000813 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005429832999993778 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010646582999999765 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005358250000000453 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023590829999982077 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013385839999955351 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002518667000000363 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.056642147873658, Delay probability: 0.22281599499441468\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013192920000051345 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011982542000001928 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005291875000011714 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011588707999997894 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0058725840000022345 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010028874999999715 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005610667000013336 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002434792000002517 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013294590000043627 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023557499999995457 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.00133658300001116 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01683658400000354 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.5399032963312025, Delay probability: 0.2378729659297821\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005429917000014939 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012299874999996518 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.124967989762793, Delay probability: 0.2767244691988686\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005434542000017473 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011410333999997135 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005645665999992389 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0025403750000023706 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.066707587480729, Delay probability: 0.219496407609628\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013358749999952124 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024707080000041515 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.037454301058429, Delay probability: 0.219496407609628\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013852909999911844 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0341246479897128, Delay probability: 0.41748210296057237\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.03318462499999697 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 3.0351235990031835, Delay probability: 0.2378729659297821\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005482291999982181 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012151208999995333 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1113707384762999, Delay probability: 0.2767244691988686\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005598958000007315 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010992665999999929 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005336875000011787 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024932079999970824 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.046120946297413, Delay probability: 0.2837116618458667\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013741250000123273 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0025075830000034216 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0521525283433852, Delay probability: 0.2837116618458667\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013324999999895226 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0369017499999984 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 3.3750983254902267, Delay probability: 0.2378729659297821\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0056784169999843925 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01908216700000054 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.7452882285644846, Delay probability: 0.2767244691988686\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005745167000014817 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.037486999999998716 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 3.4286263097997596, Delay probability: 0.307282648105079\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005623333000016828 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002425625000000764 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013190420000057657 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002453124999995282 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.001343332999994118 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.023703125000004377 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 2.1679290954061465, Delay probability: 0.2378729659297821\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005645582999989074 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010771042000001785 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005915125000001353 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011932458000003976 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.094004795944319, Delay probability: 0.22512620904327668\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005411417000004803 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002367374999998617 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.001310334000010016 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002370208000002094 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013337500000147884 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.019682124999995665 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.8001614321699533, Delay probability: 0.2378729659297821\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005409624999998641 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010376625000006356 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005467291000002206 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011390916999999945 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005455041999994137 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002413666999999009 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013138749999939137 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023762080000011565 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013297920000070462 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012113417000001903 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1079142163358928, Delay probability: 0.2378729659297821\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005425874999986036 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011773040999997875 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005364249999985304 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011649499999997204 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005818957999991881 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002408374999994578 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013095409999834828 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002400624999999934 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0014537089999748787 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0868255577600243, Delay probability: 0.38837201988393893\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011291207999995834 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005578082999988965 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01088270799999691 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005501291999991054 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011025957999997615 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005426749999998037 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002391082999999128 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013102080000066962 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024326670000007766 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013212499999895044 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01065154100000143 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005330791999995199 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011569209000001024 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005402582999977312 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0106232910000017 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005333500000006097 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002431207999997298 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.00135920799999667 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024792919999967467 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.038806583904215, Delay probability: 0.21584394058925133\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013410420000070644 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.013070833000000448 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1954811511938002, Delay probability: 0.2378729659297821\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0053479579999873295 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01237975000000091 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1322734963786951, Delay probability: 0.2767244691988686\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005340125000003582 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.015589583000000573 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.4258504130128007, Delay probability: 0.307282648105079\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005395708000008881 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002390999999995813 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.001325500000007196 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002392042000003869 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013255419999893547 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01202066599999796 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.099431048334352, Delay probability: 0.2378729659297821\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.00543729200001053 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0120369170000032 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.100917393098631, Delay probability: 0.2767244691988686\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005319667000009076 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011166625000001318 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005410291999993433 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024072080000010487 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013777919999995447 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0315619045992943, Delay probability: 0.4271908108851267\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0024072920000008935 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0014224580000075093 seconds\n", + "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0650036316807867, Delay probability: 0.4271908108851267\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011065000000002101 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0055249170000024606 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011760291999998174 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005654290999984823 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01118149999999929 seconds\n", - "Agent: eSRRF_3D using Threaded ran in 52.68264575 seconds\n" + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005406291000014107 seconds\n", + "Agent: eSRRF_3D using Threaded ran in 33.727187708 seconds\n" ] } ], @@ -456,7 +430,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -465,7 +439,7 @@ "(21, 9, 50, 50)" ] }, - "execution_count": 7, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -476,16 +450,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(1, 18, 100, 100)" + "(9, 10, 100, 100)" ] }, - "execution_count": 8, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -496,7 +470,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -508,17 +482,23 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ + "# From https://imagej.net/plugins/trackmate/scripting/scripting\n", + "# they claim that the default order of the hyperstacks in ImageJ is XYCZT\n", + "\n", + "# The RGC has dimensions (T, Z, X, Y)\n", + "# Found that, to use imwrite('image.tif', rgc_img_fiji, imagej=True), the dimensions have to be (T, Z, C, X, Y)\n", + "\n", "rgc_img.shape\n", "\n", - "# rgc_img_fiji = np.expand_dims(rgc_img, axis=4)\n", - "# rgc_img_fiji = np.transpose(rgc_img_fiji, (0, 1, 3, 2, 4))\n", + "rgc_img_fiji = np.expand_dims(rgc_img, axis=4)\n", + "rgc_img_fiji = np.transpose(rgc_img_fiji, (0, 1, 4, 2, 3))\n", "\n", "# rgc_img_fiji = np.transpose(rgc_img, (0, 1, 3, 2))\n", - "rgc_img_fiji = rgc_img\n", + "# rgc_img_fiji = rgc_img\n", "# save the 4D array as a tiff file\n", "\n", "from tifffile import imwrite\n", @@ -532,19 +512,23 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 30, "metadata": {}, "outputs": [ { - "ename": "IndexError", - "evalue": "index 4 is out of bounds for axis 0 with size 1", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[11], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m rgc_img\u001b[38;5;241m.\u001b[39mshape\n\u001b[0;32m----> 2\u001b[0m stackview\u001b[38;5;241m.\u001b[39mslice(\u001b[43mrgc_img\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m]\u001b[49m)\n", - "\u001b[0;31mIndexError\u001b[0m: index 4 is out of bounds for axis 0 with size 1" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d870a17bc7b14ca28ea2bad9f3b57831", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=5, desc…" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -554,7 +538,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -571,7 +555,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -581,7 +565,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[10], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m stackview\u001b[38;5;241m.\u001b[39mslice(\u001b[43mgrad_r_int\u001b[49m)\n", + "Cell \u001b[0;32mIn[32], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m stackview\u001b[38;5;241m.\u001b[39mslice(\u001b[43mgrad_r_int\u001b[49m)\n", "\u001b[0;31mNameError\u001b[0m: name 'grad_r_int' is not defined" ] } From 2dfac1cf0d32c1e5cc5bc3d5d6234a3e2a831d6f Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Tue, 19 Mar 2024 15:53:54 +0000 Subject: [PATCH 69/81] added blue lines for plotting profiles --- tests/test_3D_eSRRF/load_analyse.ipynb | 70 ++++++++++++++++++-------- 1 file changed, 49 insertions(+), 21 deletions(-) diff --git a/tests/test_3D_eSRRF/load_analyse.ipynb b/tests/test_3D_eSRRF/load_analyse.ipynb index 619170fd..31652f11 100644 --- a/tests/test_3D_eSRRF/load_analyse.ipynb +++ b/tests/test_3D_eSRRF/load_analyse.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -13,6 +13,7 @@ "\n", "import os\n", "\n", + "import matplotlib as mpl\n", "import stackview\n", "import numpy as np\n", "from matplotlib import pyplot as plt\n", @@ -24,18 +25,37 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.set_cmap(\"gray\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# set parameters\n", "\n", - "path = \"/Users/avesga/Code/radialsym/simulations/FULL_distance_emitters_0.5_px_size_0.02_int_f_1500_offset_200_int_noise_100.tiff\"" + "path = \"/Users/avesga/Code/radialsym/simulations/FULL_distance_emitters_1.5_px_size_0.02_int_f_1500_offset_200_int_noise_100.tiff\"" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -46,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -57,7 +77,7 @@ "radius=1\n", "radius_z = 1\n", "ratio_px = 1\n", - "sensitivity=2\n", + "sensitivity=1\n", "run_type=\"Threaded\"\n", "correlation=\"AVG\"\n", "framewindow=0\n", @@ -66,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -76,19 +96,20 @@ "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.014986958999998024 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.05732637500000237 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012834459000004017 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.013857583000003615 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01826745799999685 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.015633874999991804 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.016381292000005487 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01672654099996862 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.014241874999981974 seconds\n", - "Agent: eSRRF_3D using Threaded ran in 8.917302250000006 seconds\n" + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01692379200000005 seconds\n", + "Agent: eSRRF_3D using Threaded ran in 9.336254499999995 seconds\n", + "Only one frame, no temporal correlations can be calculated\n" ] } ], @@ -101,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -110,13 +131,13 @@ "Text(0.5, 1.0, 'XZ intensity at the center')" ] }, - "execution_count": 22, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9YAAAEyCAYAAAAfo0gPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3gWVfbHv28vKe+bHtIooXcMiiwgCijYXVkVG9gb2Pfn2lYUV7GtXUFd17aou+rqrq6AiGJFRBQBC1JCJz1v+tvv74/wzjmTvCEJpEHO53nyPJPJnbl37kzuuXfme84xKKUUBEEQBEEQBEEQBEE4IIyd3QBBEARBEARBEARBOJSRhbUgCIIgCIIgCIIgHASysBYEQRAEQRAEQRCEg0AW1oIgCIIgCIIgCIJwEMjCWhAEQRAEQRAEQRAOAllYC4IgCIIgCIIgCMJBIAtrQRAEQRAEQRAEQTgIZGEtCIIgCIIgCIIgCAeBLKwFQRAEQRAEQRAE4SCQhXUX5+6774bBYEBJSUlnN6VdWLFiBQwGA1asWNFm54z0mSAIgiC0NRG79fbbb3d2U9oNg8GAu+++u83O1x62XhAEoavRbRbWF1xwAex2O3777bdGf3vggQdgMBjwwQcf4M0334TBYMBzzz0X9TxXX301LBYLfvzxx/ZustDOXHTRRTAYDNpPfHw8RowYgb/+9a/w+Xy6sl9++SVOPPFEZGZmwm63IycnB6eeeipef/11XTl+Pv6Tnp7ekZcmCILQpWmpTQYaj9XRfnr16tXBVyC0By+//LLuvtrtdvTv3x9z5sxBYWGhruy2bdtw8cUXIzc3F3a7Henp6TjmmGMwd+5cXbljjz22yefm119/7cjLEwThMMfc2Q3oKB599FF8+OGHuOqqq/DJJ59o+/Pz8zFv3jxMnz4dp5xyCgDglVdewa233oozzjgDaWlpWtlvv/0Wzz//PG6++WaMGDGiw69BaHtsNhv+9re/AQA8Hg/eeecd/PGPf8Tq1avx5ptvAgDeeustnHPOORg5ciSuv/56JCQkID8/H59//jleeOEFnHfeebpzHn/88Zg5c6Zun8Ph6JgLEgRBOARojU2+8sorMWXKlKjnWb58OV5++WUcffTRHdJuoWOYN28eevfuDa/Xiy+//BILFizAhx9+iA0bNsDpdGLz5s048sgj4XA4cMkll6BXr17Yu3cvvv/+ezz44IO45557dOfLysrC/PnzG9WTkZHRUZckCEJ3QHUjnn/+eQVAvfzyy9q+adOmqfj4eLVr1y5tX35+vnI6nercc8/V9gWDQTVy5EjVq1cvVVNT02Ftnjt3rgKgiouLO6zOjuTTTz9VANSnn37aZueM9FlzzJo1S8XExOj2hUIhNXr0aAVA7d69Wyml1ODBg9WQIUOUz+drdI7CwkLd7wDU7NmzD6L1giAI3YOW2uSm2LNnj0pJSVE9e/ZUZWVl7dlUHRG79dZbb3VYnR0NADV37tw2O19Lbf1LL72kAKjVq1fr9t90000KgHr99deVUkpdc801ymw2q23btjU6R0O7PHHiRDVkyJCDuwBBEIQW0G2k4ABw2WWXYdy4cfjjH/+I0tJSvPnmm1iyZAn+8pe/IDMzUyvXq1cv3H333XjjjTewbNkyAMCTTz6JtWvXYsGCBXA6nfutZ9OmTZg+fTrS09Nht9uRlZWFGTNmoKKiAkC9fMlgMODll19udGxTfk0lJSU4++yzER8fj6SkJFx//fXwer26MsuWLcP48ePhdrsRGxuLAQMG4Pbbb9f+7vf7cddddyEvLw8ulwsxMTGYMGECPv30U915Iu175JFH8Mwzz6BPnz5wOp044YQTsHPnTiilcO+99yIrKwsOhwOnn346ysrKdOfo1asXTjnlFHz00UcYOXIk7HY7Bg8ejH//+9/77bsIq1atwrRp0+ByueB0OjFx4kR89dVXjcp9+eWXOPLII2G325Gbm9ukhL+lGI1GHHvssVo/AMCWLVtw5JFHwmq1Niqfmpp6UPUJgiB0V1pqk6MRDodx/vnno7y8HK+//joSEhL2W76qqgo33HADevXqBZvNhtTUVBx//PH4/vvvtTK9evXCRRdd1OjYY489VrMLnFAohNtvvx3p6emIiYnBaaedhp07d+rKNDcfAICXXnoJkyZNQmpqKmw2GwYPHowFCxY0qi9iV1esWIHRo0fD4XBg2LBhmt/yv//9bwwbNgx2ux15eXn44YcfdMdfdNFFiI2NxdatWzF16lTExMQgIyMD8+bNg1Jqv/0HALt378Yll1yCtLQ02Gw2DBkyBH//+98bldu1axfOOOMMxMTEIDU1FTfeeGMj96rWMmnSJAD1igag3i5nZWWhZ8+ejcqKXRYEobPoNlJwAJrv9KhRo3D11Vfjiy++wOjRozF79uxGZW+88UYsWrQIV199NZYsWYK77roLM2bMwLRp0/Zbh9/vx9SpU+Hz+XDttdciPT0du3fvxgcffACPxwOXy3VAbT/77LPRq1cvzJ8/H9988w2efPJJlJeX49VXXwUA/PTTTzjllFMwfPhwzJs3DzabDZs3b9YtRisrK/G3v/0N5557Li6//HJUVVXhxRdfxNSpU/Htt99i5MiRujoXLVoEv9+Pa6+9FmVlZXjooYdw9tlnY9KkSVixYgX+9Kc/YfPmzXjqqafwxz/+sZGB3bRpE8455xxcddVVmDVrFl566SWcddZZWLJkCY4//vgmr/WTTz7BiSeeiLy8PMydOxdGo1GbeHzxxRc46qijAADr16/HCSecgJSUFNx9990IBoOYO3euTr5/IGzZsgUAkJSUBADo2bMnli9fjl27diErK6vZ471eb6Ngc3FxcbDZbAfVLkEQhMOJ1tjkhtx777349NNPcd999+F3v/tds+WvuuoqvP3225gzZw4GDx6M0tJSfPnll/jll19wxBFHHFD777vvPhgMBvzpT39CUVERHn/8cUyZMgVr166Fw+Fo8XxgwYIFGDJkCE477TSYzWa8//77uOaaaxAOhxv1xebNm3HeeefhyiuvxAUXXIBHHnkEp556KhYuXIjbb78d11xzDQBg/vz5OPvss7Fx40YYjfQNJRQKYdq0aTj66KPx0EMPYcmSJZg7dy6CwSDmzZvX5LUWFhbi6KOPhsFgwJw5c5CSkoLFixfj0ksvRWVlJW644QYAQF1dHSZPnowdO3bguuuuQ0ZGBl577TWd3P9AiGaXP/74Y3zyySfaont/hEKhRnbZbrcjNjb2oNolCIKgo7M/mXcGt912mwKgTCaTWrNmTZPlVq1apYxGo0pMTFRut1sVFBQ0e+4ffvihWYlYfn6+AqBeeumlRn9DA/lVRNZ82mmn6cpdc801CoD68ccflVJKPfbYY81KxoPBYCM5c3l5uUpLS1OXXHJJo/alpKQoj8ej7Y/024gRI1QgEND2n3vuucpqtSqv16vt69mzpwKg3nnnHW1fRUWF6tGjhxo1apS2r6E8LBwOq379+qmpU6eqcDislautrVW9e/dWxx9/vLbvjDPOUHa7XW3fvl3b9/PPPyuTydQqKXhxcbEqLi5WmzdvVvfff78yGAxq+PDhWrkXX3xRAVBWq1Udd9xx6s9//rP64osvVCgUanROAFF/ot1rQRAEoeU2OcKKFSuUyWRSkydPjjoOR8PlcjXrptOzZ081a9asRvsnTpyoJk6cqP0esVuZmZmqsrJS2/+vf/1LAVBPPPGEUqpl8wGl6u1bQ6ZOnar69OnTqH0A1Ndff63tW7p0qQKgHA6HzhY+99xzjaTXs2bNUgDUtddeq+0Lh8Pq5JNPVlarVTd/aDgXufTSS1WPHj1USUmJrk0zZsxQLpdLu4bHH39cAVD/+te/tDI1NTWqb9++rZKCf/zxx6q4uFjt3LlTvfnmmyopKUk5HA7NRWDDhg3K4XAoAGrkyJHq+uuvV++9915UV72JEydGtcvR7rUgCMLB0K2k4BGSk5MB1AetGDp0aJPljjrqKFx11VUoKyvD/PnzW/QlNPIGeunSpaitrW2bBgON3lpfe+21AIAPP/wQAOB2uwEA//nPfxAOh6Oew2QyaXLmcDiMsrIyBINBjB49WieHi3DWWWfpvrCPGTMGQH00V7PZrNvv9/uxe/du3fEZGRn4/e9/r/0eHx+PmTNn4ocffkBBQUHUNq5duxabNm3Ceeedh9LSUpSUlKCkpAQ1NTWYPHkyPv/8c4TDYYRCISxduhRnnHEGcnJytOMHDRqEqVOnRj13NGpqapCSkoKUlBT07dsXt99+O8aOHYt3331XK3PJJZdgyZIlOPbYY/Hll1/i3nvvxYQJE9CvXz98/fXXjc55+umnY9myZbqf1rRJEAShO9FSmwzUu0Wdd955SEpKwj/+8Q/d19j94Xa7sWrVKuzZs+eg2xth5syZiIuL037/wx/+gB49emh2uaXzAR7csqKiAiUlJZg4cSK2bt2qk4wDwODBgzF27Fjt94hdnjRpks4WRvZv3bq1UX1z5szRtiNfoP1+Pz7++OOo7VNK4Z133sGpp54KpZRml0tKSjB16lRUVFRoc4gPP/wQPXr0wB/+8AfteKfTiSuuuKLJ64/GlClTkJKSguzsbMyYMQOxsbF49913NReBIUOGYO3atbjggguwbds2PPHEE1rA2RdeeKHR+Xr16tXILt9yyy2tapMgCEJzdCspOADs3LkTc+fOxdChQ7FhwwY89NBDuPPOO5ssf+SRRwIARo8e3aLz9+7dGzfddBMeffRRLFq0CBMmTMBpp52GCy644IBl4ADQr18/3e+5ubkwGo2aH/A555yDv/3tb7jssstw6623YvLkyTjzzDPxhz/8QTfxeOWVV/DXv/4Vv/76KwKBgK7dDeFGGqBJQnZ2dtT95eXluv19+/ZtlE+6f//+AOr9l6OloNq0aRMAYNasWY3+FqGiogI+nw91dXWN+gUABgwYoE1smsNut+P9998HUB8hvHfv3lHl3lOnTsXUqVNRW1uLNWvW4J///CcWLlyIU045Bb/++qvOpysrK6vJCLaCIAgC0RqbrJTCzJkzsXfvXixevLhVaQwfeughzJo1C9nZ2cjLy8NJJ52EmTNnok+fPgfc9ob2x2AwoG/fvppdbul84KuvvsLcuXOxcuXKRgvwiooKXdmDtctGo7HRNXO7HI3i4mJ4PB48//zzeP7556OWKSoqAgBs3749qu0fMGBA1OOa4plnnkH//v1hNpuRlpaGAQMGNHqJ0r9/f7z22msIhUL4+eef8cEHH+Chhx7CFVdcgd69e+vscExMjNhlQRDanW73xTrypnbx4sU466yzcN9990V9o3sw/PWvf8W6detw++23o66uDtdddx2GDBmCXbt2AUAjgxMhFAq1uI6G53A4HPj888/x8ccf48ILL8S6detwzjnn4Pjjj9fO+49//AMXXXQRcnNz8eKLL2LJkiVYtmwZJk2aFPUrt8lkilp3U/tVC4KfNEekHQ8//HCjt8uRn7b0iTKZTJgyZQqmTJmCCRMmNOtD7XQ6MWHCBDz99NO48847UV5ejsWLF7dZe4SWc9FFFx02uWvvvvvuJseFQ53IFzFBiEZrbPIjjzyCxYsX449//GOrVUBnn302tm7diqeeegoZGRl4+OGHMWTIEN343Ra2uSHNzQe2bNmCyZMno6SkBI8++ij+97//YdmyZbjxxhsBoJFt7ky7fMEFFzRpl8eNG3fQ9XCOOuooTJkyBcceeywGDRq0X2WCyWTCsGHDcNttt2lqs0WLFrVpe4SWEclD3tRLmkOJFStWwGAwaMEBDyeOPfbYZtVBwoHRrRbW7777Lv773/9qEa0ff/xxWK3WFgVKaS3Dhg3DnXfeic8//xxffPEFdu/ejYULFwKAFr3U4/Hojtm+fXuT54t8yY2wefNmhMNh3cLCaDRi8uTJePTRR/Hzzz/jvvvuwyeffKJF/X777bfRp08f/Pvf/8aFF16IqVOnYsqUKY2ii7cVmzdvbmTUf/vtNwBockGUm5sLoF42HlnwNvyxWCxISUmBw+Fo1C8AsHHjxra9kCaIqBj27t3bIfUdClxwwQWw2+3afeY88MADMBgM+OCDD/Dmm29qgYuicfXVV8NiseDHH39sl3Z++OGHUaPvdyXuv/9+vPfee51S9549e3D33Xdj7dq1LSr/9ddf4+677240ph3u1NbW4u677z4sJ14dQWts8qpVq3DHHXdgzJgxuO+++w6ovh49euCaa67Be++9h/z8fCQlJenOlZCQEPUZbso2N7Q/Sils3ry5kX3b33zg/fffh8/nw3//+19ceeWVOOmkkzBlyhSdPLwtCYfDjV5cNGeXU1JSEBcXh1Ao1KRdjqi2evbsiS1btjSy/WKXO4eW2mSg/mW1wWDY7097vsz++eefcffdd3fpRfnrr7+Oxx9/vNPqb828oLV2/HDi2WefjZp5qSPoNgvrqqoqXHfddRg1apTmn5yRkYF7770XS5YswVtvvdUm9VRWViIYDOr2DRs2DEajUUs3ER8fj+TkZHz++ee6cs8++2yT533mmWd0vz/11FMAgBNPPBEAGqW7AqBF+Y7UG3mjzQ3eqlWrsHLlymav60DYs2ePzle5srISr776KkaOHNmkhC8vLw+5ubl45JFHUF1d3ejvxcXFAOqvZerUqXjvvfewY8cO7e+//PILli5d2qbXsXz58qj7I3Lz1krcDmceffRROJ1OXHXVVbr9+fn5mDdvHqZPn45TTjlFi7B/6623orCwUFf222+/xfPPP48bb7wRI0aMaLKuF1544YAnax9++CHuueeeAzq2PbjzzjtRV1en29fZC+t77rmnVQvre+65p1surO+55x5ZWB8ArbHJHo8HM2bMgNPpxBtvvAGLxdKqukKhUCNf5dTUVGRkZOjSQOXm5uKbb76B3+/X9n3wwQeNUmhFePXVV1FVVaX9/vbbb2Pv3r2aXW7JfCCaXa6oqMBLL73UqmtsDU8//bS2rZTC008/DYvFgsmTJ0ctbzKZMH36dLzzzjvYsGFDo79H7DIAnHTSSdizZw/efvttbV9tbW2TEvID5YsvvtC5s0UQu6ynpTYZAK688kq89tprUX8iaeiOPvro/dZ34YUXoq6uLmoatOb4+eefcc8993SZhfUxxxyDuro6HHPMMdq+Q21h3Ro7fjjRmQvrbuNjfeedd2LPnj3497//rZNMzZ49G6+88gpuuOEGTJs2TReI5ED45JNPMGfOHJx11lno378/gsEgXnvtNc0wRbjsssvwwAMP4LLLLsPo0aPx+eefR32jGCE/Px+nnXYapk2bhpUrV+If//gHzjvvPG3hMW/ePHz++ec4+eST0bNnTxQVFeHZZ59FVlYWxo8fDwA45ZRT8O9//xu///3vcfLJJyM/Px8LFy7E4MGDoy5iD5b+/fvj0ksvxerVq5GWloa///3vKCws3O+EwWg04m9/+xtOPPFEDBkyBBdffDEyMzOxe/dufPrpp4iPj9d8ou+55x4sWbIEEyZMwDXXXINgMIinnnoKQ4YMwbp169rsOk4//XT07t0bp556KnJzc1FTU4OPP/4Y77//Po488kiceuqpbVbXoU5qaioefPBBXHHFFXjllVc0X/lrrrkGFosFTzzxhFY2kmLmxhtvxOuvvw6gfgJ85ZVXIicnp9kvyq2dXHdlzGazLiCg0L2pqalBTExMZzejXWmNTb7qqquwbds2nHPOOfjqq690aSQ5F1xwQdT9VVVVyMrKwh/+8AeMGDECsbGx+Pjjj7F69Wr89a9/1cpddtllePvttzFt2jScffbZ2LJlC/7xj39oSqqGJCYmYvz48bj44otRWFiIxx9/HH379sXll18OoGXzgRNOOAFWqxWnnnoqrrzySlRXV+OFF15Aampqu3x1tdvtWLJkCWbNmoUxY8Zg8eLF+N///ofbb78dKSkpTR73wAMP4NNPP8WYMWNw+eWXY/DgwSgrK8P333+Pjz/+WHu5f/nll+Ppp5/GzJkzsWbNGvTo0QOvvfYanE5nm17Hgw8+iDVr1uDMM8/E8OHDAQDff/89Xn31VSQmJmrpv7o7rbHJY8eO1QXGi7B3717cdNNN6NmzZ9T86hyTydSkW8KhhtFohN1u7+xmCF2EYDCIcDisBYFukk6KRt6hfPfdd8pkMqk5c+ZE/fu3336rjEajuu666xr9LZL6YfXq1S2qa+vWreqSSy5Rubm5ym63q8TERHXcccepjz/+WFeutrZWXXrppcrlcqm4uDh19tlnq6KioibTbf3888/qD3/4g4qLi1MJCQlqzpw5qq6uTiu3fPlydfrpp6uMjAxltVpVRkaGOvfcc9Vvv/2mlQmHw+r+++9XPXv2VDabTY0aNUp98MEHatasWapnz55auUi6rYcffljX5kiKkYapQ6L1Uc+ePdXJJ5+sli5dqoYPH65sNpsaOHBgo2MbptuK8MMPP6gzzzxTJSUlKZvNpnr27KnOPvtstXz5cl25zz77TOXl5Smr1ar69OmjFi5cqPVZc0TSbTXHG2+8oWbMmKFyc3OVw+FQdrtdDR48WN1xxx26VCtK1acoaS6ly+FOOBxW48aNU8nJyaqkpES98cYbCoB68sknG5V96KGHFAD10UcfKaWUevTRRxUAtXjx4mbr2d9z+9xzz6k+ffooq9WqRo8erb799lvdcYiSeiVCKBRSjz32mBo8eLCy2WwqNTVVXXHFFaqsrExXf+QZ/+KLL9SRRx6pbDab6t27t3rllVd05fx+v7r77rtV3759lc1mU4mJiWrcuHHaNSulGj2z0do3a9Ys9cknnygA6t///nej/li0aFGjVDwNKS0tVTfffLMaOnSoiomJUXFxcWratGlq7dq1WpnI/2TDn6ZSxkXa3vAnPz9fu5bZs2erd999Vw0ZMkRZrVY1ePDgqPd4165d6uKLL1apqalauRdffLHJ62nIa6+9po488kjlcDiU2+1WEyZMUEuXLtWV+fDDD9X48eOV0+lUsbGx6qSTTlIbNmzQlYmMDbt27VKnn366iomJUcnJyermm29WwWBQKUXPW8MfPn7/8ssvavr06SohIUHZbDaVl5en/vOf/+jqioyfK1asUFdffbVKSUlRbre7xdd8KNJamxxJM9XcT1P4fD71f//3f2rEiBEqLi5OxcTEqBEjRqhnn322Udm//vWvKjMzU9lsNjVu3Dj13XffNZlu64033lC33XabSk1NVQ6HQ5188sm6lFctnQ/897//VcOHD1d2u1316tVLPfjgg+rvf/+77v8o0g8nn3xyozZHszvR7Hjkud6yZYs64YQTlNPpVGlpaWru3LmN0pY1fJaVUqqwsFDNnj1bZWdnK4vFotLT09XkyZPV888/ryu3fft2ddpppymn06mSk5PV9ddfr5YsWdKqdFvNzbm++uorNXv2bDV06FDlcrmUxWJROTk56qKLLlJbtmzRlZ04caIaMmTIfs93ONMam9yQUCikjjvuOGU2m9VXX33VbPnI/Yv23O7PVkaOa/jDn5e2GrsjvPHGG+qII45QsbGxKi4uTg0dOlQ9/vjj2t8bzk+jpW3r2bOnqqqqUk6nM+oaYufOncpoNKr7779/v/328MMPq7Fjx6rExERlt9vVEUcc0Wi+3NS8IBrN2fHI/8RPP/2kjj32WOVwOFRGRoZ68MEHG53L6/Wqu+66S+Xm5iqr1aqysrLU//3f/+lS7O6Pb775Rp144onK7XYrp9Ophg0bputnpVpnK7/88kt14403quTkZOV0OtUZZ5yhioqKtHLR7AUfv8vLy9X111+vsrKylNVqVbm5ueqBBx7QjYF8/HzsscdUnz59lNFoVD/88EOz19stFtZCx9PUBEDoHmzYsEFZLBZ11llnqfT0dDV69Oio+WYDgYAaMWKEys3NVZs2bVKxsbFqxowZLaqjqYX1qFGjVN++fdWDDz6oHnroIZWcnKyysrKU3+9XSin19ddfq+OPP14BUK+99pr2E+Gyyy5TZrNZXX755WrhwoXqT3/6k4qJiVFHHnmkdg6l6p/xAQMGqLS0NHX77berp59+Wh1xxBHKYDDojP3tt9+uDAaDuvzyy9ULL7yg/vrXv6pzzz1XPfDAA1qZhgvr1157TdlsNjVhwgStfV9//bUKh8MqOztbTZ8+vVF/nHTSSSo3N3e/fbZ69WqVm5urbr31VvXcc8+pefPmqczMTOVyudTu3buVUkoVFBSoefPmKQDqiiuu0OpvOFmN8OOPP6pzzz1XAVCPPfaYVr66ulopVT8ZGDFihOrRo4e699571eOPP6769OmjnE6nLiduQUGBysrKUtnZ2WrevHlqwYIF6rTTTtPO2xx33323AqB+97vfqYcfflg98cQT6rzzzlN/+tOftDKvvvqqMhgMatq0aeqpp55SDz74oOrVq5dyu926ieCsWbOU3W5XQ4YMUZdccolasGCBmj59ugKgLcaqq6vVggULFAD1+9//XrvuH3/8USlV/z/gcrnU4MGD1YMPPqiefvppdcwxxyiDwaB7MRKZLAwePFhNnDhRPfXUU7pnQxDaipa+TBYOP1pqkxsSGVfvu+++FtXT1MK6OVu5ZcsWdd111ykA6vbbb9fG04KCAqVU247dSin10UcfKQBq8uTJ6plnnlHPPPOMmjNnjjrrrLO0Mg0X1h999JEaOXKkSk5O1tr37rvvKqWUOv/881VaWlqjxftDDz2kDAaD7oVbNLKystQ111yjnn76afXoo4+qo446SgFQH3zwgVamqXlBNJqz4xMnTlQZGRkqOztbXX/99erZZ59VkyZNUgDUhx9+qJ0nFAppL+FuuOEG9dxzz6k5c+Yos9msTj/99P1eU6TPrFar6tmzp5o7d65asGCBuu6669SUKVO0Mq21laNGjVKTJk1STz31lLr55puVyWRSZ599tlbu3XffVVlZWWrgwIHadUc+ZNTU1Kjhw4erpKQkdfvtt6uFCxeqmTNnKoPBoK6//nrtHJH55ODBg1WfPn3UAw88oB577LFm76NSsrAW2glZWAu33XabAqBMJpNas2ZNk+VWrVqljEajSkxMVG63WzOkzdHUwjopKUn3dfk///mPAqDef/99bd/s2bOjfuH64osvFAC1aNEi3f7I1xa+P/JW9PPPP9f2FRUVKZvNpm6++WZt34gRI5r9X4imsoiJiYn6Nvq2225TNptNeTweXb1ms7nRF6aGeL3eRpOp/Px8ZbPZ1Lx587R9q1ev3u9X6oY8/PDDjSZTEQAoq9WqNm/erO378ccfFQD11FNPafsuvfRS1aNHD91iWymlZsyYoVwul6qtrW2y/k2bNimj0ah+//vfN7q+cDislFKqqqpKud1udfnll+v+XlBQoFwul25/RNXA+0QppUaNGqXy8vK034uLi6N+2VNKqcmTJ6thw4bp3uqHw2H1u9/9TvXr10/bF5ksjB8/vtGkTBDaEllYd29aapMjrFixQplMJjV58uQWLcKVanph3RJb+dZbb0VVNbTH2H399der+Pj4/Y650RSVJ598sm7eEWHp0qVR1XbDhw/XfS1tiob2ze/3q6FDh6pJkybp9jc1L4jG/ux45Ov7q6++qu3z+XwqPT1d9+L+tddeU0ajUX3xxRe64xcuXKgA7FfFEAwGVe/evVXPnj1VeXm57m8Ru6xU623llClTdMffeOONymQy6eZEQ4YMidrv9957r4qJidGpeZVS6tZbb1Umk0nt2LFDKUXzyfj4eN3X8JbQbYKXCYLQsSQnJwOoD0i0v7QORx11FK666iqUlZVh/vz5SEtLO6h6zznnHC3yPgBMmDABAFqUVu+tt96Cy+XC8ccfj5KSEu0nLy8PsbGxWoT9CIMHD9bOD9RHzx0wYICuLrfbjZ9++ilqBPsDYebMmfD5fLrgQP/85z8RDAab9DGNYLPZtLQ1oVAIpaWliI2NxYABA/D999+3SfuiMWXKFJ2f6vDhwxEfH6/1k1IK77zzDk499VQopXR9P3XqVFRUVOy3fe+99x7C4TDuuuuuRml5IimUli1bBo/Hg3PPPVd3fpPJhDFjxjS6twAaBfyZMGFCi56jsrIyfPLJJzj77LNRVVWl1VVaWoqpU6di06ZN2L17t+6Yyy+//LDxTRQEoevRUpsMACUlJTjvvPOQlJSEf/zjH/tNd9YSWmIrm6I9xm63242amhosW7bsIK6KmDJlCjIyMnRp3jZs2IB169Y1a5cB6LIAlJeXo6KiAhMmTGhXuxwbG6trm9VqxVFHHaXrp7feeguDBg3CwIEDdX0/adIkAIja9xF++OEH5Ofn44YbboDb7db9LWKXD8RWXnHFFbrUiBMmTEAoFNpvZiV+PRMmTEBCQoLueqZMmYJQKNQoqPT06dP3G3siGhItRxCENmfnzp2YO3cuhg4dig0bNuChhx7CnXfe2WT5I488EgClSjkYcnJydL9HFtnl5eXNHrtp0yZUVFRoqWMaUlRUtN+6IvXxuubNm4fTTz8d/fv3x9ChQzFt2jRceOGFWsCd1jJw4EAceeSRWLRoES699FIA9Tlbjz76aPTt23e/x4bDYTzxxBN49tlnkZ+fr8vPm5SUdEDtaQnN9VNxcTE8Hg+ef/75JqMHN+x7zpYtW2A0GjF48OAmy0RebEQmBA2Jj4/X/W632xsZ1Ib3tikiqQb//Oc/489//nPUMkVFRcjMzNR+7927d7PnFQRBOBBaY5OVUpg5cyb27t2LxYsXN5nFpTW0xFY2RXuM3ddccw3+9a9/4cQTT0RmZiZOOOEEnH322Zg2bVqz7YmG0WjE+eefjwULFqC2thZOpxOLFi2C3W7HWWed1ezxH3zwAf7yl79g7dq1ukwFfAHZ1mRlZTU6f0JCgi7476ZNm/DLL780ubhszi4D2O9LnAOxlQc7x1u3bl2Lr+dA7LIsrIV2oaukSxA6hzlz5gAAFi9ejJtuugn33XcfzjvvPPTp06fd627qq59qkFc1GuFwGKmpqbq3zpyGg3FL6jrmmGOwZcsW/Oc//8FHH32Ev/3tb3jsscewcOFCXHbZZc22KRozZ87E9ddfj127dsHn8+Gbb77RpdBpivvvvx9//vOfcckll+Dee+9FYmIijEYjbrjhBoTD4QNqS0torp8idV9wwQVa1NqGHOiLiAiROl577bWoE8WGUdkP5utxpK4//vGPmDp1atQyDV+CtFfeYkGI8PLLL3daChqhc2mNTX7kkUewePFi/N///V+T41drOVi7DLTt2J2amoq1a9di6dKlWLx4MRYvXoyXXnoJM2fOxCuvvNLs8dGYOXMmHn74Ybz33ns499xz8frrr+OUU06By+Xa73FffPEFTjvtNBxzzDF49tln0aNHD1gsFrz00ktaxpT2oCX3JBwOY9iwYXj00Uejls3Ozj6oNhyIrTzYZ+n444/HLbfcEvXv/fv31/1+IHZZFtaCILQp7777Lv773//iscceQ1ZWFh5//HEsXboUs2fPxuLFizu7eQCafgucm5uLjz/+GOPGjWvThU5iYiIuvvhiXHzxxaiursYxxxyDu+++e78L6/29qZ4xYwZuuukmvPHGG6irq4PFYsE555zTbDvefvttHHfccXjxxRd1+z0ejyYTbK7u1ra1JaSkpCAuLg6hUAhTpkxp9fG5ubkIh8P4+eefMXLkyCbLAPUTqgOpIxpNXXdksmqxWNqsLkEQhAOhNTZ51apVuOOOOzBmzBjcd999HdrO/dlloG3HbgBamrtTTz0V4XAY11xzDZ577jn8+c9/blL9tT9bN3ToUIwaNQqLFi1CVlYWduzYgaeeeqrZdrzzzjuw2+1YunQpbDabtj9aatrW2Nq2+Nqdm5uLH3/8EZMnT271+SL3bcOGDU3et/aylft7lqqrq9vVLouPtSAIbUZVVRWuu+46jBo1Ctdeey2Aen+ue++9F0uWLMFbb73VyS2sJ5Ij2OPx6PafffbZCIVCuPfeexsdEwwGG5VvCaWlpbrfY2Nj0bdvX53cq6k2NlVfcnIyTjzxRPzjH//AokWLMG3aNN3CuClMJlOjt7pvvfVWIx+mpvpnf21tTflo7Zo+fTreeecdbNiwodHfi4uL93v8GWecAaPRiHnz5jX68h653qlTpyI+Ph73338/AoFAq+uIRiQ3b8PrTk1NxbHHHovnnnsuai7iA6lLEAShtbTGJns8HsyYMQNOpxNvvPEGLBZLh7a1KTvSHmN3Q7tsNBo1VdT+bHNMTAwqKiqa/PuFF16Ijz76CI8//jiSkpJw4oknNtsWk8kEg8Ggc83atm0b3nvvvaj1d5RdBurnRLt378YLL7zQ6G91dXWoqalp8tgjjjgCvXv3xuOPP96oDRG73F62sql+Ovvss7Fy5UosXbq00d88Hg+CweAB1ceRL9aCILQZd955J/bs2YN///vfOrnO7Nmz8corr+CGG27AtGnTEBcX14mtBPLy8gAA1113HaZOnQqTyYQZM2Zg4sSJuPLKKzF//nysXbsWJ5xwAiwWCzZt2oS33noLTzzxBP7whz+0qq7Bgwfj2GOPRV5eHhITE/Hdd9/h7bff1qR5+2vjxx9/jEcffRQZGRno3bs3xowZo/195syZWluivQiIximnnIJ58+bh4osvxu9+9zusX78eixYtaiQHzM3NhdvtxsKFCxEXF4eYmBiMGTOmSX+jSH/ecccdmDFjBiwWC0499VTNsLeEBx54AJ9++inGjBmDyy+/HIMHD0ZZWRm+//57fPzxxygrK2vy2L59++KOO+7AvffeiwkTJuDMM8+EzWbD6tWrkZGRgfnz5yM+Ph4LFizAhRdeiCOOOAIzZsxASkoKduzYgf/9738YN25ci+T0HIfDgcGDB+Of//wn+vfvj8TERAwdOhRDhw7FM888g/Hjx2PYsGG4/PLL0adPHxQWFmLlypXYtWsXfvzxx1bVJQiC0FpaY5OvuuoqbNu2Deeccw6++uorfPXVV1HP2ZJgXAfCyJEjYTKZ8OCDD6KiogI2mw2TJk1Campqm4/dl112GcrKyjBp0iRkZWVh+/bteOqppzBy5EgMGjSoyePy8vLwz3/+EzfddBOOPPJIxMbG4tRTT9X+ft555+GWW27Bu+++i6uvvrpFLydOPvlkPProo5g2bRrOO+88FBUV4ZlnnkHfvn11/s6R+vc3L+C01o5H48ILL8S//vUvXHXVVfj0008xbtw4hEIh/Prrr/jXv/6FpUuXNhkbx2g0YsGCBTj11FMxcuRIXHzxxejRowd+/fVX/PTTT9ritj1sZV5eHhYsWIC//OUv6Nu3L1JTUzFp0iT83//9H/773//ilFNOwUUXXYS8vDzU1NRg/fr1ePvtt7Ft27YWfaTYL62KIS4IgtAE3333nTKZTGrOnDlR//7tt98qo9GorrvuukZ/i6RRWL16dYvrayrd1sMPP9yoLBqkRAoGg+raa69VKSkpymAwNEp19fzzz6u8vDzlcDhUXFycGjZsmLrlllvUnj17tDJNpZSbOHGiLs3DX/7yF3XUUUcpt9utHA6HGjhwoLrvvvt0ObGjpdv69ddf1THHHKMcDocC0CjFhs/nUwkJCcrlcqm6urr9dZWG1+tVN998s+rRo4dyOBxq3LhxauXKlY3arFR9mrLBgwcrs9ncotRb9957r8rMzFRGo1GXbgWAmj17dqPyPXv2bHRNhYWFavbs2So7O1tZLBaVnp6uJk+erJ5//vkWXd/f//53NWrUKGWz2VRCQoKaOHGiWrZsma7Mp59+qqZOnapcLpey2+0qNzdXXXTRReq7777TyjSVlijaffr6669VXl6eslqtjZ6zLVu2qJkzZ6r09HRlsVhUZmamOuWUU9Tbb7+tlTmQZ18QBKE5WmuTI2mxmvvZH02l22qJrVRKqRdeeEH16dNHmUymRqmu2nLsfvvtt9UJJ5ygUlNTldVqVTk5OerKK69Ue/fu1dXXsA3V1dXqvPPOU263WwGImnrrpJNOUgCazDEdjRdffFH169dP2Ww2NXDgQPXSSy8d0LygIU3Z8YkTJ6ohQ4Y0Kt9wXqVUfeqvBx98UA0ZMkSzrXl5eeqee+5RFRUVzV7bl19+qY4//ngVFxenYmJi1PDhw3WpNpU6OFsZ7T4VFBSok08+WcXFxSkAuuesqqpK3Xbbbapv377KarWq5ORk9bvf/U498sgj2rxsf/PJ5uiSC+unn35a9ezZU9lsNnXUUUepVatWtXkdn332mTrllFNUjx49FAAtyXuEcDis/vznP6v09HRlt9vV5MmTG+U9OxDuv/9+NXr0aBUbG6tSUlLU6aefrn799Vddmbq6OnXNNdeoxMREFRMTo84888wW5/bdH88++6waNmyYiouLU3Fxceroo4/WJYJvr3obMn/+fAVAl4y9veqODEz8Z8CAAe1eb4Rdu3ap888/XyUmJiq73a6GDh2qGxTa6zkTDn8CgYBKSUlRl1xySWc3RegGtLdd7iybrFTn2eWuYpOV6j52WWyy0N6cccYZKjc3t7ObIXQSXc7HOiKxmDt3Lr7//nuMGDECU6dO3W9I9wOhpqYGI0aMwDPPPBP17w899BCefPJJLFy4EKtWrUJMTAymTp0Kr9d7UPV+9tlnmD17Nr755hssW7YMgUAAJ5xwgs5P4cYbb8T777+Pt956C5999hn27NmDM88886DqBepD6z/wwANYs2YNvvvuO0yaNAmnn346fvrpp3atl7N69Wo899xzjSL8tmfdQ4YMwd69e7WfL7/8skPqLS8vx7hx42CxWLB48WL8/PPP+Otf/6rLsdxez5lw+PPee++huLgYM2fO7OymCIc5HWGXO8smA51nl7uCTQa6j10Wmyy0N3v37sX//vc/XHjhhZ3dFKGz6OyVfUOOOuoonWwwFAqpjIwMNX/+/HarEw3ejofDYZWenq6TAHg8HmWz2dQbb7zRpnUXFRUpAOqzzz7T6rFYLOqtt97Syvzyyy8KgFq5cmWb1q2UUgkJCepvf/tbh9RbVVWl+vXrp5YtW6YmTpyovRlvz7rnzp2rRowYEfVv7X3Nf/rTn9T48eOb/HtHPmfC4cM333yjnn/+eZWdna1GjRrV2c0RugEdbZc70yYr1bl2uSNtslLdyy6LTRbai61bt6rXXntNTZw4UTmdTp2kXOhedKkv1n6/H2vWrNGFQTcajZgyZQpWrlzZYe3Iz89HQUGBrh0ulwtjxoxp83ZEogsmJiYCANasWYNAIKCre+DAgcjJyWnTukOhEN58803U1NRg7NixHVLv7NmzcfLJJzcKc9/edW/atAkZGRno06cPzj//fOzYsaND6v3vf/+L0aNH46yzzkJqaipGjRqli6zYkc+ZcPiwYMECXH311UhNTcWrr77a2c0RDnO6gl3u6LGyM+xyZ9hkoHvZZbHJQnvx2Wef4cILL0R+fj5eeeWVqPm2he5Bl1pYl5SUIBQKIS0tTbc/LS0NBQUFHdaOSF3t3Y5wOIwbbrgB48aNw9ChQ7W6rVYr3G53u9S9fv16xMbGwmaz4aqrrsK7776LwYMHt3u9b775Jr7//nvMnz+/0d/as+4xY8bg5ZdfxpIlS7BgwQLk5+djwoQJqKqqavdr3rp1KxYsWIB+/fph6dKluPrqq3HdddfhlVdeAdBxz5lwePHyyy8jGAziu+++08YNQWgvuoJd7sixsqPtcmfZZKD72WWxyUJ7cdFFF0Ephe3bt7c6c4hweCHptjqR2bNnY8OGDTrfovZmwIABWLt2LSoqKvD2229j1qxZ+Oyzz9q1zp07d+L666/HsmXLYLfb27WuhvAcgsOHD8eYMWPQs2dP/Otf/4LD4WjXusPhMEaPHo37778fADBq1Chs2LABCxcuxKxZs9q1bkEQBKH1dLRd7gybDHRPuyw2WRCE9qZLfbFOTk6GyWRCYWGhbn9hYWGHyioidbVnO+bMmYMPPvgAn376KbKysnR1+/3+RonN26puq9WKvn37Ii8vD/Pnz8eIESPwxBNPtGu9a9asQVFREY444giYzWaYzWZ89tlnePLJJ2E2m5GWltau18xxu93o378/Nm/e3O593aNHDwwePFi3b9CgQZrkrSOeM0EQhIOhK9jljhorO8Mud4ZNBrqnXRabLAhCe9OlvlhbrVbk5eVh+fLlOOOMMwDUv2Fcvnw55syZ02Ht6N27N9LT07F8+XKMHDkSAFBZWYlVq1bh6quvPqhzK6Vw7bXX4t1338WKFSsaJWrPy8uDxWLB8uXLMX36dADAxo0bsWPHDowdO/ag6o5GOByGz+dr13onT56M9evX6/ZdfPHFGDhwIP70pz8hOzu7w665uroaW7ZswYUXXtjufT1u3Dhs3LhRt++3335Dz549AbTvc9YVCIfD2LNnD+Li4mAwGDq7OYLQJVFKoaqqChkZGTAau9S7bgBdwy6391jZlexyR9hkoHvaZbHJYpMFoTkO2iZ3aui0KLz55pvKZrOpl19+Wf3888/qiiuuUG63u81zN1ZVVakffvhB/fDDDwqAevTRR9UPP/ygtm/frpRS6oEHHlBut1v95z//UevWrVOnn3666t27t6qrqzuoeq+++mrlcrnUihUr1N69e7Wf2tparcxVV12lcnJy1CeffKK+++47NXbsWDV27NiDqlcppW699Vb12Wefqfz8fLVu3Tp16623KoPBoD766KN2rTcaPPpoe9Z98803qxUrVqj8/Hz11VdfqSlTpqjk5GRVVFTUrvUqpdS3336rzGazuu+++9SmTZvUokWLlNPpVP/4xz+0Mu31nHUFdu7c2ShXqfzIj/xE/9m5c2dn/8s2SUfY5c6yyUp1nl3uSjZZqcPfLotNFpssP/LT0p8Dtcld6os1AJxzzjkoLi7GXXfdhYKCAowcORJLlixpFEziYPnuu+9w3HHHab/fdNNNAIBZs2bh5Zdfxi233IKamhpcccUV8Hg8GD9+PJYsWXLQvkgLFiwAABx77LG6/S+99BIuuugiAMBjjz0Go9GI6dOnw+fzYerUqXj22WcPql4AKCoqwsyZM7F37164XC4MHz4cS5cuxfHHH9+u9baE9qp7165dOPfcc1FaWoqUlBSMHz8e33zzDVJSUtq1XgA48sgj8e677+K2227DvHnz0Lt3bzz++OM4//zztTLt9Zx1BeLi4gDU+/LFx8d3cmsEoWtSWVmJ7Oxs7f+lK9IRdrmzbDLQeXa5K9vk9qy/s+yy2GSxyYLQHAdrkw1KKdXGbRIEQUBlZSVcLhcqKirEiAtCE8j/iSAIHYGMNYLQPAf7f9L1HLoEQRAEQRAEQRAE4RBCFtaCIAiCIAiCIAiCcBDIwloQBEEQBEEQBEEQDgJZWAuCIAiCIAiCIAjCQSALa0EQBEEQBEEQBEE4CGRhLQiCIAiCIAiCIAgHgSysBUEQuhGhsMJvhVWQTIuCIAiC0Pnkl9TAFwx1djOENqDLLqx9Ph/uvvtu+Hy+blO3XHPH0l3rFro3z32+BSc89jne+m5XZzdFOITojuNld7zmzqy7O16zIKzaWorjHlmBO97d0NlNEdoAg+qiny06M5F9Z9Ut19w9rrmz6+4ousM1Horc9K+1+Pf3u3HxuF6Ye+qQzm5Ot+dQ+T/pjuNld7zmzqy7O15zR9IdrvFQ5Mnlm/Dost9gNRmx+o4pcDktnd2kbs3B/p+02xfrZ555Br169YLdbseYMWPw7bfftldVgiAIQgup9gYBAGU1/k5uidCRiE0WBEHoeuSX1AAA/KEwlvy0t5NbIxws7bKw/uc//4mbbroJc+fOxffff48RI0Zg6tSpKCoqao/qBEEQhBZSJQvrbofYZEEQhK7J1n0LawB474c9ndgSoS0wt8dJH330UVx++eW4+OKLAQALFy7E//73P/z973/Hrbfeut9jw+Ew9uzZowXWqaysbI8m7pdInR1dd2fV25l1d8drbqu6lVKoqqpCRkYGjMYuGy5B6GJU+2Rh3d04GJsM1Nvl3bt3Azh0x8tDqd7uWvehfs1ik4XWopRCfnG19vs3+aUoqPAi3WXvxFYJB0ObL6z9fj/WrFmD2267TdtnNBoxZcoUrFy5slF5n8+nCxaxe/duDB48WPs9Ozu7rZvYYjqrbrlmqbs17Ny5E1lZWW3QGqE7IAvr7kVrbTKwf7t8qI+Xh1K93bXuQ/2axSYLLaW8NoDKfSqyYZkurN9dgfd/3IPLj+nTyS0TDpQ2X1iXlJQgFAohLS1Ntz8tLQ2//vpro/Lz58/HPffc02j/746+BWazDca6oLbP6KNtZTVp2yE7OfqbPd4m2xaKt0U9V9jGuiFMsdz8LivVZzZo25YadqyF3kr646hNsTtI2lGTFUPnZ6HiLNV0HgCwemgiE4yjuq3FtXS4heowVlId3l5J2nZdEvVH3A461ptEb8AcxXXadiCW6jJX02Q7EE/7HVuKdW319UqmdvjD2nZ1JtXhLG5+4m7dXUHHDqRrsJdQX/jd1A7e95a9Tb9Z9ua4te2wme6RtYLaFIyh+26pDmjbvgR6TixVtN+bQvsdBfSc8fNUZ/K2Ur+41+oll5VDU7XtuJ+ob2v6U7+a6yj1gjFE57KU1N/TYMiHzzY9jbi4OAhCS6ny1j/TpTV+KKVgMBiaOUI4lGmtTQaatstjx/4JZrMNykTPjLWIbEyI2RIjTx3DNo0+GlMBIMwC9QRjmC2qpXKmQg+dKslFxzpo7DUGWCXBJmKyNvER0e+msd0Q1v8tbIn+/2EMUB1GP9VtCEev28TmMiF2zX4XbdtLyK5wu2WuoP2K7TeWV+nqCGSRDTWx/gP7H/elOKgOI7uPzNbVMVsXz6SplUdksOuhjnLspi9unKp++sA/8T+Vats1/RK17ZCN2hG7k54nPjcJWVl/+KL3d8Q2Avq5kj+RrtnA4vUavfr0RuYqmnfwe8TnQiYfXTef/1kqfQiGfPhi3WNik4UWk19S/7+T6Xbg7COzsX53Bf7z425ZWB/CtIsUvDXcdtttuOmmm7TfKysrkZ2dDYuywKysCCY6tb+ZSplxsbGFNRv0gvG0iFVGvUHkiypLQTkdk0OLHLAJg30vDbJ8IuFLpTr8yTT4ujeSkathC90YDxksQ4AG5ZBdL/UIpbNrZeW8A2PpeGYH7IVUPnYrXY/JQhMof06Ctu36lV2zi44NJ1M7lJ0q4A+HyaE3FPZa6o+aHJroOL3UbrOJjI6XLfYt1VRHOIfqdu2mxb6BTQpsXgPbT/fE1ztd2+aLewCws0mPl70gsZZTOWWnPjCwmZ/DS8ea12+ldg/vS+fMpGu2F1GbYjbQM1oxkMqEevXQtS++hCZZhkS6R/YA66cqahN/5gyB+jtjCNbXJQsjoTVEfKz9wTBq/CHE2jrdDAhdjKbssi1oghlmmDcXan8rOpEmgKkfbde2g9n0ktDEFiwoosUVACDJrW1aq8gG1PVlx1tpYQS+mGansZTT2Fs5gOxV7E46p7mIXsYqM80hDMxGmL5er2ueYSCN+3U5dF67hxZxhiCNwcF4aquljMqA1R3M66Vt25itN8Sxa2PzF2UjW+VLJBthK3Pr2gob9UgwkbZNbAFpYC+CY/fQy/mQk9rt3kl9aXCRfbIFqZ9qs+g8VtB+v4v2O2r0dtnMriO2jOwsX+yG4mi+E06i8/IFtzJRHb4k9sGkln3oYB8S4KB7HbOW+bCGG7xFYVjYi22Tg+xvyEnncm4tofoyE2AI7rPNYpOFFrK1uP5/sHdyDE4e1gP3/PcnbNhdic1F1eibGtvM0UJXpM2dQJKTk2EymVBYWKjbX1hYiPT09EblbTYb4uPjdT+CIAhC2+MPhuEL0mSyrFrk4Ic7rbXJgNhlQRCEjiASEbx3cgwSY6w4pn8KAGDxeokOfqjS5gtrq9WKvLw8LF++XNsXDoexfPlyjB07tq2rEwRBEFpItU/vflJa42uipHC4IDZZEASha8IX1gBwxD43xl3ldU0dInRx2kUDeNNNN2HWrFkYPXo0jjrqKDz++OOoqanRIpK2hECcBcpsgZn51HqZVNrqoS8tthL2ADat7NH5Y9UckRO1DD+vN5NkX4EYkv943fQ+InUFyYqCaST9tVZSu8v7M3+l7fqJLcfGpe5MSWTbQ/u92VSHqYr5kzMpFffN1UnA6pjfci86T/z39GYskEl+T7wNVUNIlgcAdUnUB66t7F7sJLl5OJakZbHsy1jIzh47JrEPMD+oYAaTg1mZzM5O9SZ8s5vOmerWtS/AfNRjmQ8zTHQfbYiOYhJ237hB2rZ9F0n5QtnUVu5yYKwkuZqjmJ7XkE3/Dsvioecg6GI+3cyXzptBx9sLmKRwn8yMy+cEoSVEclhHKK+VL9bdgbawyQDgTbbDbLHDaibXlpSvaXwN5KRo26Y65uMbYK4vCWR7ACDspPEvzOOlsLgXPPaJhcUcqetJNjpsofHS9QPFtKgaRq5e1hg6v6mWxW9h/s+mdL0vuvKS3TTXUh18rhGMY9fA/G4DCcxOpFJQLO66ZCsk/+QQOw+/Zu5CBiYF5z7B9ZUwt6fNu+hUaWTXYWD+xiE2b2DnCrpJRm0pJrk49wE3e6kdOhe3FOYzzyTYAGArYZLxRKrDvpf5aDM3v9jfKAYLtpO9DxzVX9t2bCcXPB5HJ8jmbNYKFhcnkZ4ZfzK7nwDMVTQe6vqcEWbxdsIx1JcmXwgqFIp2iCA0ibawTqlfWCfF1j/DJdXy0vtQpV0W1ueccw6Ki4tx1113oaCgACNHjsSSJUsaBU8RBEEQOo6qBoGjSkUK3i0QmywIgtC1CIeVtrDus++LdbIsrA952i1qzZw5czBnzpz2Or0gCILQSqoafLGWlFvdB7HJgiAIXYe9lV74gmFYTAZkuuvVD0n7IuGXyEvvQ5YuGw7WoOp/eGoJLpU2MBWscRtJmcM5JFHj0m8AqM4h2Y69jCaY9tVbtG2VTW/webRJWzl96Yn/gSJBhl0sWjNLAWFlE9hUlgLCn0TSI9XAw706h/5mK4+eDozL15SNJFe+HhSExlJJb7r4saFkCkDDU4rU9SepnH0nSa/qWLRvR5H+7Zm1gkVld7BIpMkkswrGseilLCULv3d+J4vu6aZzun+mdhj8dM0BFiXR14dkh03JtgCgtl/0FFbmChZhPJWeDefPBdS+BOrXoJvKxP/GUn2xyKKVI6l8zDaSt/Eo9gDgT6JzeROpD5zsMowsrQeXGkYk4KGgyM6E1tFQCi4La6E1OHfXwGwK6lyPAunRUwv5WZRpI3N38TO7AADWCr2KIoLlV5IyV06kyOMxLIWkYtGX7btpTA6zrBfOveQqZuQuSS6SInuTmTw6iVJKAYBjL0mheVqt6j5ki2JZm0z8f4xJrU0lZNMUy17C5eJVvZg8upzqivmF5Pa2MpYG1KK3KwHWt2Ym/zbsIJvm60Myap6qisvheb9yFzIDm48ZmEuXqYbuoetX2g7F6O81T/ulWNP5vMhWwFKIlXro0Hh6zvg8iN/HStZ/fJ7h2EttMnrILgd6659di4dJ2lm2GQOT7vM0qVy6b6rywRBq2tVPEBqybd/X6pxEp5ZFJ4V9sZZ0mIcmbR68TBAEQeiaNA5eJgtrQRAEQehotmqBy+glXeSLtW9fOkzh0EMW1oIgCN2EKq/+66B8sRYEQRCEjid/X2DAPimkYHFazXBa6+UcJQ2DEwqHBF1WCm7x+GA2G2BkX1h0kTeZtDYwvq+2bS+mBzHQQHLmKKZJpbWQ5F3+kb21bdv2MtoujR432pvLJMjh6JGZeTRMHnmTw6NJA4C5juRGfjfdGh61m0upQkkkY7KwaJYBJrvzsfM497Ko4+yVirWMScdj6Fh7AfURGkSgDjpiEA1LgYcOsZIUzZfKIrqXUTtspfRGzrmVRXf3kKzPN4SiqZqYXM3A+q82XX+vHIV0TfZ8ku7XDCLZuy2f6jDHkuyrbgC5A1gq6Zkxb6X74B1BUeV5hFefizo2hsnmdJHQAViZe4BtO4sE3icJ0eCyubqk+rYGAxIVXGgdVfvGU5fDgoq6gCyshVbhTXXAbLbDXkjjl3UH2Uxuk8DGvIpckjsn/UCZIwDAwGx81RAa/4IxvbRt15fbtO1wOpWJ/ZGycvh7MpcfD8uYwdufSV+G7LtJEswSTyAYox+ra7PoGJ41xFIT3f3IuIWiVwcHkp1QLOOGeTtFLbf4ycbEMfvuTWY2qS9dm4m5nIWteik4zx4RjCdZtDmTbJq9hK7BGKBz1fWge2Spov3chcybyqTqhWSvFYuEbggxObVT35d8vuT8dhv9IYHqqOudQO1mCw7dPWX3y8heFiZ9wty4cskty1xMtl7F0lwkdqP+WQywL4d8fhZwM/k9iwoe8xs9+8HEGISCYpOFlpNfUj8GRVJtRUiOtWFHWS1Kqn3olRx9ri10XeSLtSAIQjch4mPda59PoyysBUEQBKHjaZjDOoIEMDu0kYW1IAhCNyESFTwnqd6Qy8JaEARBEDoWfzCMneX1qo8+Ub5YA5Jy61Cly0rBg3FWwGyFrZpHuGaRqG1McruFZD6heJIEW6r0/oS1GSRjMgZZVOYkJhlXJNdSJpL8mLwkjbIwSZI3nWRF5hoqE4hh7dvNJdgs2mYD1ZC5nGRcISbj8vUmGZh1l4f2s0imQSfV52CSbweTjVn20rHKQtfpT6S6whZqn2Mvtaeh5MzI5O2Wxd9r21Wn5Wnb9mKatJuDLLI3u0dc0mXKJxlXOIsk21x6ZQySzIzfn7iNFHEVAMpHurVtV5Cim5tYpG0Vw6RvG7ZRW3NIQsYjkoczyAXAxKKL8yiwyV9TO7w51AbHr3RtABDqQf0fSCDpm4FJyfi9MDMJvOunevlQMCSDrtA6IsHLeiY6td99wRBsZtP+DhMEAEAgxgRlMcG+l8bRQAaT7hZTRGdDgOSzyV8zKa6N9tf/TtMQe1H0MS2UTfaAy4vNQZLucqmwskef2piY246BuTfxaN/WBgGDzEU0pleOoqwjcRsoUje/Ju+RuVRHE25ggSGZ2jbPxME/dZhrmY1hdryGuT3F7mDuUwCMLE99IIHsuj+VJu5hK8u0wmx07G8kiw7bmQw9k45VrFtNpXSvlYX+EGRyaotHfz9rsmm+FFdNkn5vBrkQhJm9t+yk5yaQRO2wlLHI8Mzlisu/+fzKcyTdN/cX2+icfag8AFhKyf3Nx6LdW5lLWJjJ3rls3VLp181nBKEpNhVW4alPNiMUVoixmpASp3dljCysS+WL9SFJl11YC4IgCG1LJHhZhtsBk9GAUFihrMaPHi5HM0cKgiAIgnAw3PHuerz+7Q4tbNFZo7MbpdRK1qTg8vHkUEQW1oIgCN2EiBQ83mFGgtOKkmofSqtlYS0IgiAI7UlJtQ+LVu0AAEwdkobZx/XF8Cx3o3IiBT+06bIL66DdBFhMMLlpwheyG9nfWRTKAMlkzSVMsuMi2REAuL4v1LbLjyQJkLOQRfpkEiM/i0jJo3w7tlFET38/kguZvCQzs1WwyJ1Mwm4tpEikwQR9+wxeakddPzcdU0HXF0piEUpZdG1zNdXBI30aWRl/JsmWwibqPy4zBlOW+d0kT/G79I+Kcw877/GjqE0eOpc3heRkPPpmoKcb0Qjlklwr5GDywJ0V0YqjLock3rYGkjs7izYetlDfmGvY8+FgLgB9Mqh9bpLQcTcBI4vCzSXlIfZs2CuYRI1J1cPJ1FYAMLJyviyS+sduomutyaVIqSEH3QtzbH2bgkEL8AsEocVEpOCxNjOSYuoX1uW1IjcTWoa9PACz2QSwgNhcGhtIozErEMsyUmylcZe7awGAiU0ezSy9TCiWyvGxNGhnGTeYhNLI3Ha4m5SthIyadSeTO7P5gamM7LK3F7np1J/YrW3y8dlQTWM4v25zDbXD2CBvvHYscx8Cc8MwMeln2Ex2iEdeVwaSUPvdelm9qY76mWcKAXehYvdLsXlAOJa5hDHXr9gN5MZUkUc2unIkzaFCNro/8ZtIIo4GX+Li11OGjooRZPf4fMlWTtdQzeZBtjLa7+3B5kEVdJ3WzZS5QyWy+QGz0aEscuni8zoAUAZ6Jmxsrlabw+4vcwOzsej4Rn8QEPcsYT/8Vlj/v9EzyYnnLhzdZLlI8DKRgh+aSPAyQRCEbkLki3Wc3YzEmHrjLQHMBEEQBKF9+a2gfmHdLzVuv+Xki/WhjSysBUEQugmRL9ZxdgsS5a24IAiCIHQIvxXVqyAGpMfut5wsrA9tZGEtCILQTYjksY5IwQH5Yi0IgiAI7U3ki3X/tOa+WNfb5kpvfdYO4dCiy/pYx67bDbPRhmAm+RM5tpPvjrGWfHxDCeQLXZfBUjJU6f2blIEeZu5Xbd1DflPVg6m+2J9Lte3SMZTuAyA/I0cR+f3YCqh9gUTy1bFuo7Qc/lw6D08PAgDhOPILsxfTmypvKvOvraV3ITwFh6WI/IGqB5Avta2EpcGIJX9hnj5MMT8o7svG/apt5fq+NITIZ8vBUmIoI2tfLdVX28utbcdsID8ob/80Kr95N227yafJwAYWZaVz2kqp/2qz9P7q3C+dp8Pi6bOCLKVZXRr5qrnWkE+ZpYKeGZ7Ww7yTfMWUk87jyaP7G7+RnodG6crAUqZspf4zhJkvHEvNFrOD7m/Yuu++BPXp5ARhf3gDIfj3/d9yKXipLKyFFqKMBiijASEXSweZwMZk5h9rL+Hpr6iM2aNPERW2sVgXzP4onopx/RY6fnR/bdvoje7DrNhwa2AxR4JpLNYFS7fly2XzjHzywwYAHwsuFHaRnXB4o39N4tcXSCCbbq6k/qgYSufkPsncN5ynBisdR3OO+C10fnOD9E66FFvMfjt3Uhqp6p5kK10/kh2rHkR9YKmiPjOz+B6ub8lGVx1BcUlcP9McSrGYJmgQ+8SfSf0fs4v6g/vH8+O5Hef+6mb2nPnSac7nKGVBGFnsHUsljXH8ebAVUL8A+jRtvjSWys0bPb1mKJaeB9POKhjC8oVRiI5SSvOxbm5h7XJYYDYaEAwrlFb7keGW4KKHEvLFWhAEoRtQzSamMVbuYy2TQUEQBEFoLworfaj0BmEyGtCHBUaOhsFgkABmhzCysBYEQegGcBm40WiQ4GWCIAiC0AFEvlb3SnLCZjY1U1r8rA9luqwUXDnsUCZ9Wo6qgSQjiv+MZNphJu8y+qNLaQHA5GGpEbwkPwuwCH08XZRyUv3ujSTF5ZJgA0tjUZPr1rZjtni0bW9/SksRtrLUJDH6AAZcum7dSqnBzKUk3arrHT1llj+driH2F0rNUT2QUoc49pKELGyjW28IszRS5fRPbAyy9Btm/TsYndyLScmNVUxaZYoeoMHfi9JdWEupTSqLZOFcOm30kuxLmWh/wEX3h0vdACDIUrr4kug67HvpPlrzKW2adRf1R8jN2s2uzVzEJO9+lrYrle5J3FZqR9jJUnXV6mXbXH7PnyGegs3mYelF0mh/zPp6Kb3IzoTWwCOCA5CFtdBqQhYjDBajLm2ho5ClfWQy6LCTZLKGWhqreGoqADAwuTC3rdxWqkG9tW2eMgs+enarjszStk1eOqc/mbllFdP4zMddnrYqHEf2AgAs5UyyXEVzCJ6uy1JEcu7K4ZRGylHMJMjMjtk8JC2u6Un2xlFAdfkSyYaZfHQ9XP7OU3kCelcuO6ubp5CM28pSfiZT3UY/1WGpZK5o2TS/MlczO5TPXJjYtXGpNUo8uvaZjeQqxa/Dm0nzF/t2OsZoYVNU7ibArttcS+cJpFNbTWxc4/OJmmxmYxu4uFkqqP/tv5FLWM0wkr2bWHpSSwFJ4H29khEMeoHtEIRGtFQGHkEW1ocu8sVaEAShG1Dlq5/8xu57qZYUU2+4ZWEtCIIgCO3HxhYGLosQkYKXiBT8kEMW1oIgCN0ATQre4Iu1py6AUFg1eZwgCIIgCAdOJNVWSxfWKfLF+pClC0vBrVAmK3wpJGGKzScJU90RPbVtxzYPO5KCAphq9W96uLSbYymsjLqflw9xWW8gHHW/qY5JoJjU11pC8jNfKrXPWqlvn7nQo23XDaIooPY9LBo6k7oHY1j0TCYbVkw+FfsTRSRXdroeLo0KOpi8OjaGlaH3LtZKvZTZsp3OW3kUSfBidlB/cFmfpZrJ1yy0P8jk3NatdE4Di0TK5Wpctg6+adK/I/LHUx/EbKfnxlDDItW66LyhGJICctl2dW8qo3KiS8h4m8wVTErvZ9HMTXq3BGMViwhf5qH9NnIbMJfQuaw8Wnh8/T1SoS777yt0QUgKXv8/mrBv7FIKKK/1a9IzQWiKmF8KYDbaUDeA3HbMNUyKm8TsBxvnvX1oHLWV6W0Jl/Jym2Ni+027mL35XS9t215KNjQmn+wkj/htLPZo26FMkmnXsvGcy9FNJfr5ALeb1UPIjSlmC5Xj7mTx68lNjVPTn6Ju86jlpjoa201Mgm1iWTysFWxuwWwJl+QD+swfnPL+ZN9SfqBjuJQ5GEt9Yyojm4lEmoNxW8f7DMxnlGdEMVv1NirkYJlCsulZsRfRdftY5HAuSQ8z9zM+tzOGeURx5j7AMpTUpbEsHDtIzh9y6tvnT2JR2Vlb+XUHY9icr4q2LR4vDCFZBAmNCYcVNu2TgjeXwzoCBS+TZ+pQo9VfrD///HOceuqpyMjIgMFgwHvvvaf7u1IKd911F3r06AGHw4EpU6Zg06ZNbdVeQRAE4QCIRAWP2ycFN5uMcO9bXIsc/NBFbLIgCELXZbenDrX+ECwmA3om7T8ieATysRbbfKjR6oV1TU0NRowYgWeeeSbq3x966CE8+eSTWLhwIVatWoWYmBhMnToVXq83anlBEASh/YksrGNZ4MJEp6T0ONQRmywIgtB1iQQuy02JhcXUsmWXBC87dGm1lvTEE0/EiSeeGPVvSik8/vjjuPPOO3H66acDAF599VWkpaXhvffew4wZM1pcj7HGC6NRwVJN0hweidqxlSJf+7IpKrOZTRB5NFBAL13iMl1/Jr1BCjEpGo92CqbkVWYWBZvJwq0bdlKZDJKM+Zj0I8wjWzb4BwtkkVTMxM7LZW08QmkgjtrNo5L6MyjqatBJEjV/HOu/YpKD6aJqxpNkzOSjNlh2e3Rt9fdm0T1ZNNHazOhRQ2tzSd5lL2OTeH6ZNiYT60fRzG3FdM2egdSXyV/soWMdehmrzUOPti6COZP18ddKYUf0KOmWSuobI3t+bPkl2nYomfo7xPoPrLyhgQ+rsZbJ1PIo4q0xwOpmUrYQi4IakdgHg82nbBCECJX7IvdGooID9X7WW0tq5Iv1IUxH2WQACGQkQpntsJay6NWpZKPNXrKrtkKSE9t2sAjNCXopJJcvB5iNsjC3Gt+gTG3buYukvAY2rBoKSIKtUsh+hNLJrnIsTMJuZpJjX+8UXTnrL7u07dhNLGo5i3rOo3Mr9uKKu4TFbPVEPdbAomMbuK33MFk4m1xX93NTXQ0yn/Co4oYQGdekn9l+H90jb2/qG/sustdVw8i+O3eQK1tdFs05YsrpPviyyL4r1iRvij4CvJnJ3vl9NJWy+csgqttWQM+NiidJurcHc+OyMbc7Zq/NVXRs3BY6v2Ev2W7/sGxd+7irHXcRDPWkOSaPLO9nrn2GsEIwKLEqhMb8Vtg6/2pAgpcdyrRp8LL8/HwUFBRgypQp2j6Xy4UxY8Zg5cqVUY/x+XyorKzU/QiCIAhtS8PgZQCQsC+2QHmtGO/DkQOxyYDYZUEQhLaCUm21zL8aoOBlZTU+CS56iNGmC+uCgvq8f2lpabr9aWlp2t8aMn/+fLhcLu0nOzs7ajlBEOrxePKxbt2rWLXqUQDABx98oPv7RRddBIPBoPuZNm2arkxZWRnOP/98xMfHw+1249JLL0V1dbWuzLp16zBhwgTY7XZkZ2fjoYceat8LE9qV/UnBy+WL9WHJgdhkQOyyIAhCW9HaHNYAvfQOK8AjL74PKTo9rPBtt92Gm266Sfu9srIS2dnZUAYDlNEASxFN9pWJ5Fa+HCbNKSRpDn9VYGogtTb/RlLtmrF9tW1bWRORnJnMKpBIEmLnTpIV1WXQGyjv+Fw6ZzmL1skjaTKZlDHAIn0COulwbQ4LcBBikc6ZjEsnVTfxaJhUCY/GbQhyiTP9o5qKKTJo2EqRQY2srtp+tB8ALFUssiiP+G3WS9MixK0v0rarh5LUzl5M7Qikk5zMwfrYUEdlEr+nemuYZMy5SR+JVffcsMikoXgW6Z3Jvy1l0aWNPLKtfUu5tu3tQ9fAo74bWLR1fh/MxSxiLaCLomrfS22tzSHpnKmORchl0V8NJRVwGRKRkdwP6/e8j2hMmzYNL730kva7zaaXyp9//vnYu3cvli1bhkAggIsvvhhXXHEFXn/9dQD1/4cnnHACpkyZgoULF2L9+vW45JJL4Ha7ccUVV0StU+jaRKKCx9tJektfrANRjxG6J03ZZZM3CJMpgECCPepxQTuL3MzGXQPLEGHaox+ryydThg9bJdmcMHsBxF2oKgeRzU34hWV8YK4zXmaXHb+R7Qmmu6O21cokx/5sfXAhQ78MbdvsITsRjCM5N7en/hSW+YPPTYLM3jPJd8hFfcntTchG2wbmYuTYW0flrXp3IEsh2fJQEk3iuS3n9o3bcd4+ezHNiRSTuTuZe5dyMCk8s/vWciZhZ+5k9QdF//KmrDQmxfxEL3yKJlHGESPrPtemWvYLk9WzuRZ/fmp7kv2zu6m/bSXUlwBg8LO5TKwjajk+DzXVsYjkRgMMwQbXK3R7QmGFza1MtQUAFpMRCU4LymsDKKn2I0mydhwytOnCOj29PlVQYWEhevSgdFGFhYUYOXJk1GNsNlujSb8gCE2TEpeLlLhcBPeT2sNms2n/jw355ZdfsGTJEqxevRqjR48GADz11FM46aST8MgjjyAjIwOLFi2C3+/H3//+d1itVgwZMgRr167Fo48+KgvrQ5RoUvDEfaljRAp+eHIgNhkQuywIgtAW7CirhS8Yhs1sRHais/kDGMmxNpTXBval3Gr5olzoXNpUCt67d2+kp6dj+fLl2r7KykqsWrUKY8eObcuqBEHYDytWrEBqaioGDBiAq6++GqWl9JVo5cqVcLvd2qIaAKZMmQKj0YhVq1ZpZY455hhYrfQ1YOrUqdi4cSPKy+nLvXDoEC14WcI+KbgELzs8EZssCO1PeeU2/PjzP7Dy+ycAiHuWQERk4H1TY2EyRld0NkUkgNmW4upmSgpdiVZ/sa6ursbmzZu13/Pz87F27VokJiYiJycHN9xwA/7yl7+gX79+6N27N/785z8jIyMDZ5xxRqvqqeuTBLPFrpMOOXaRnFYnbWKyL2spSXZMdQ3kjQkkNbZW0N94RE8/kxUpJj9zFJD0yJtOUi97MdXHI2IbWFTvYALJnHgkzOqeesmZpZquyVpBEiOwdviYJJ1LiBWT2lmYXM2bRm0y1zGZHZcsM3mciUlCuazKuZ0kZgAQdJFMqjqH+iwun/qDS7grR5Bs2/VDIbWvF0Ulte3yaNu+bGqT/We2n7kAmGt5ZHcqDwDWQnpWFJMI8uiq/F7by6m8yU19zCPAGzy8DPUr74vKXiQzc28iGaC3N0WpBQATi8QejOFRZGnTso36ScVSfTUD6mX5wYAX2IhGTJs2DWeeeSZ69+6NLVu24Pbbb8eJJ56IlStXwmQyoaCgAKmpqbpjzGYzEhMTNb/LgoIC9O7dW1cm4qdZUFCAhIQENMTn88Hno/6VgEddi2g+1pGFtXyxPnTpKJsM1NtEZTLo7C+PvszdXwzc1YnZp+pRJO8FgPjtZK8sLOKyoY5JimOYLLeIyvBMEsFs5p5Tqpf4aueponNaeLYI5qMVtOu/N9j43xKYjLqURSevZe5kdre27c1kwYq4Hxib13A7bmRtCsTS/EBRtTDXUPt0tgOAOZbsT20mHWQv9LFjWOT1SrL3irmImEuoTeEYOmddT/pqxjNmOHayCNpMsmrdqZf98wwapr2U2SWYTa5mwRiapyWtZ3M+NkYFWC5gG4tQz226gXVN3EY2f2G311ilf06qh1AsAj6/4JJvyx5qd92A+vI+n4IjMROJOaPw249vIhrintU92XQA/tURJvZPxTdby/D0p5tx5hFZiLF1uveu0AJafZe+++47HHfccdrvET+sWbNm4eWXX8Ytt9yCmpoaXHHFFfB4PBg/fjyWLFkCuz26T5YgCG0LT6EzbNgwDB8+HLm5uVixYgUmT57cbvXOnz8f99xzT7udXzg4IgvrOIkKflghNlkQOpeklAFISB9Y/7K7CcQ9q3sSSbXVrxURwSNcPK4XXv92O3aW1WHBii3449QBbd08oR1otRT82GOPhVKq0c/LL78MADAYDJg3bx4KCgrg9Xrx8ccfo3///m3dbkEQWkifPn2QnJysfdVKT09HUVGRrkwwGERZWZlm+NPT01FYWKgrE/m9qcnBbbfdhoqKCu1n586dUcsJHY9SSgteFse+TCVGFtY1ErzsUEVssiB0fTrDPUvS5nU+WkTw1NZ/sbZbTLjjpMEAgOe/2IodTCUjdF26rK7AubkYZqMN/iyS0AaY479l/VZtW42kaNymAhpgPONydOeM2cWkThUkAQrF0Zt7e3X0CSaXuNl3k0yKR5mO2UaypfKhJGdyb6TyphIa2OLz9+jq8I4i6a3fRbfG5CVZub2AZHDBeGq35Zcd2nY4N5Pa9D3tD2Uz+S+TooWZ/MyA6FE7a3u5dL879lA7YnfT+xmzh/3j80ifu6m/A2l0LiOTzIfjmdxvO5NbDaHr4YRZVFefu0F0VA/VHYph993DoqrvpvsVyCBpc9ChP1cE72BqB5fJW5mEPZZFdVUsUju/TgCwMJ8ZSznV582kwbdiHEXLjd1O/eoorO/LYKjpt+OcXbt2obS0VAteNHbsWHg8HqxZswZ5eXkAgE8++QThcBhjxozRytxxxx0IBAKwWOr7b9myZRgwYEBUGTggAY+6Mt5AWMuFGS3dVrUvCF8wBJs5+rMvCMC+SNhmGwKx9AwZA9Flzf40Fh27hMYv7pIEAGBDozeLpMJBJ42fsb95tG2Vv1vbDhw9UNu27SDbb6gi+xTqwTJdVJMdqs6isYp/S3L9ond7qhxA9sq1gexSTR+3tu3YS/Vx+XP1WIoo7iimuYXJS33ApdPc/Cr2r8ijonMXNVuRXsrMI1abmWuZN41d6xaag/A5RE0f6nue1cRcTnXYmUtcXQbLVlLHXejovvl7kqsXAHiTqJwtlrZNXuYa5WRRt2tpu7a/W9uO2UrX4Eunu2fxkOTdvINFgy+gl8SBE2jx6hugn9fE7CabavQxdzz2jNYOJLk4l8AHkmJgCLJjGJ3lniUqss4lGApj6z73lgORggPA1CFpGNc3CV9tLsV9H/6M5y4c3fxBQqfSpsHLBEFof4IhH6pq9qKqtn6ysH37dqxduxY7duxAdXU1/u///g/ffPMNtm3bhuXLl+P0009H3759MXXqVADAoEGDMG3aNFx++eX49ttv8dVXX2HOnDmYMWMGMjLqJ4LnnXcerFYrLr30Uvz000/45z//iSeeeEKXgkc4dKjy1U+UjQbAyeIrxNnNiLwz9EjKLUEQhDZnxowZOO200zBs2DCcccYZ+OCDD7B69WqsWLGiXesVFVnnsr2sFv5QGA6LCVksPkNrMBgMmHvqEJiMBiz9qRD/XL2j+YOETkUW1oJwiFFZswff/LQQ3/3ydwDA7bffjlGjRuGuu+6CyWTCunXrcNppp6F///649NJLkZeXhy+++EL3NXnRokUYOHAgJk+ejJNOOgnjx4/H888/r/3d5XLho48+Qn5+PvLy8nDzzTfjrrvuEl+uQ5SIDDzWZoaBBVEyGg0SGVwQBKED6Sj3LJvNhvj4eN2P0H78WlCJ6Qu+xrf59cqWTSwiuLGVEcE5/dPicN2kfgCA29/dgM9/Kz74xgrtRpeVggdSXVBmOwJx1EQ7kz0FB/WisqyMOYOkR3GbSOoLAKZij7ZdcTRFJnWtpLd4vv40QIWs9N7BXkgSKMWC/5g9TOLMpOpJX5JczZ9NbeJCy3BOD3Dse1h7i0hOpjJJIqSYbJtHBDVns4GV/QNXjSE5sb2EJs51qUwatkkvfdPa5yQJtdWjn3TXZpH8ikv2zHF0DJey2Tz0NSxk43I12h+MI2lYXW+SmbnWUV8Y/FTe24ckfvGb9L4nYX6PKknexa/JnxA9+re9iEVVTyapHJd/mytJchbIIDmZrYDuYV0O21+sb19tH5JtGZj8z5FPckYzi3xqYBHuXan9MCn1PgSDXnz+9b2oqKjQGcylS5eiORITE7Voo00xfPhwfPHFF82eS+j6VEfxr46QEGNFaY1fApgJzWLbUgSz0QZDLtkkQ5AGMC5rtpTROBqMo/18HAUAQ4h0tiambLZvpXE/7GYRsof0ofYUkPS8th/LMFFG9inMIpL7k2g8j9tOlVl2lND5XfogQzG7qJwvneSczh0kAw47yXbVDCKpcOxO6oM6LsdmkazDDub2VUN2JW492eXafmTruGyaHwsAfje1w7mFbIk/g+xDbTZdA892EvsL2a7KYdSXZjbPiPmFFn8qi+6Jn2XSsDCb3tCxzMGikyu2zjAXeKgd29k4ZKPrMVfQvVPbdmnbJhcFdOKZWcK9SDYdt5UixvN647bq0xjx55RHRlfMrY3baBVlPG0JHeWeJXQs736/G2u2l+OBxb/g39eMw8Z949OBysA5103ui22lNXj3h924ZtH3ePvqsRiYLi9KuiLyxVoQBOEwJ1qqrQgRP2sJYCYIgtB6giE/qqr3oLqm3h9a3LO6JyXV9S+Fvt/hweaiavxWFEm11fqI4A0xGAx4YPowjOmdiGpfEFe8ukaLmyJ0LWRhLQiCcJhT5a1fNPNUWxES9gX3K5Mv1oIgCK2msm4PVn//DL7/8QUA4p7VXSllipN3vt91UDmso2Ezm/D8haPhsJiwo6wW+SXVzR8kdDhdVgoewVpBX1EMAYpyadZF1M6mMj9t0ba9xwzRncv+2zZt27WaRW+OoaACXNZmDpDkikfi5BHClZVFR/VT+wKZFM3cUhQ9+rRq4HPBo1ebYmjALR9Ib7uSvmE+NsnUbi5hCrPI1LG/kJzOzyTLPNK4IRA9kqUyM6m0Rf8OhsvggiwoQ10KSbcMLJImjyLr3EbHhrj0iknIrEyGz6OFB+LoGqylJNHzDNJLYuK2MU0hiyJbN3mQtm0vpoWEN5lFKN1DfeasJrlbyEXtqMmhexL3E8kIw3HRpePhBl8KA7F0ffG/sRQY7JkwsWBSPPq8FtFdydtKoWVoPtbRFtbaF2tZWAv7J5CVBGW2w5tI4yV3MfK7WSaIIj6usXPY9PmzTdU0GfWl0nhbO4rk5rE7aTzn7jlmFo06ZGNZGJhc2lRH7bOEyEaHE2gMD6W5tW0e1bph+/iYXNWP2aIqOq+litmxPR5tu5q5axlYO/xuki87mWsZwmRA+VyBy67t2yhKOQAEnTTvCCZH/0oWs5XaFGDuRopJ5mO3sMwnbF6inKzva+gaTD6W3YO5q1mKGkitE1hml99oDucfmIVomNjLPkOQ6giNYunimB2M2UXSdlMxSelrBpM831pO5zRW6qOq89GR95+lgMny+5Os3LovCrnb2R9THXcgGPJh+S+PiHtWN6W0mp6td9bs0tyrDiSHdVO4nBYMzojHmu3lWL+7An0PII2X0L7IF2tBEITDnP1JwRMiuazli7UgCIIgHBCl7CVcUZUPgZBCjNWETPeBRQRviqH7YiZs2C15ybsisrAWBEE4zKlpkY+1LKwFQRAEobUopVC6z4ZOYQEM+6bF6TJxtAVDM+vVMut3Rw88LHQuXVYKHraZEDabYAwwORSTXYcGkPwb7KGtOWGoth372SbdOf1HUvRILunikbatLDqol0U+NfmYdItFk7ZUMrmuk0X39DLJWQzJpwIsaraZlQEAS4k+cnQE96YabTuYzCJ6biUZGK8jlEJvxypGkmzJ9SOTLPd0a9u+LJK0+ePpGmK30tswY5VeMlUxigYOm4dkd3GbWVTsHiQzM/npPvqZ3M9SRuetY5HGzbVMZlbKo7sz2QuThrl+00eA96aS5Mw4hmRjPAJ60MUlhXSumuGZbD9zP2DBnQxMfsbl32Dyd1sRiyRv0g+spgAd702n/uARRwMJesmkduy+dhiDoah/F4SG1OxzU3Fam/5iXSZ5rIVm8LutCFusiNnGJL7s9byNRfgOJdF4biojG2ZjX3UAwJdJ9se+l85r9ZCt5HJk7obkzSB7ELSzNHKVNPb6ckgeHWYuRpZKLjOm9hgMehebyoFubVuxa41lUcVDLDo3z9ZRdwSLEL6HrptHEbeVUIRwnllEpTIpci010FzBzsOipQPQuRJx1zQuJS8bRf3hLKbzWvZ6tG1DNfVf3WjKLGIppL53sKjtykb3J8zc2IrHUjRzAEj6gY73Dc/Rtk3s+izbmLsbi8Zd14/mY/ZvaW5XfvJgbZtHevf3pbkP72MOz+gBAAE2h4v5lUVAt0bPdmIupPmEPycRwaB8q+qu1PhD8O2bk141sQ8+/qX+Oe6f2nYy8AjD9s3Zf95TiXBYHVQqL6HtkVFAEAThMIe+WJsa/S1hXwo6+WItCIIgCK0nIgN3Wk0Y3SsRg3rUy7UHpLe9D3TflFjYLUZU+4LIL61p/gChQ5GFtSAIwmFOxMc6RnysBUEQBKFNiaTaSoqtt6cPnDkM5x6Vg7OPzN7fYQeE2WTUFu4bRA7e5eiyUnBLeR3MpjDqsultj7WMRexm0TN1sqpSJonIIOkQoI8aGogjubSjgM7FI4RbS0kOZfCSTNLJpMmhRBZZVDEpeBVJj7hcjUvbAzH67jf4SfrL5WSRyJMAEHaQJMnbiyKM27d7qHwZ9YHlow3atueco7Vt90cbqWImIwkdnattV/WlqJbx6/TyPedeur6wlb6C1WUy+TeLPM4xMll9KIbuHY8yymXXdX1JThZiUr6YLUxCF08SOgCwF0SX1fvS6X7ZCkh2yGVzPhZt3VxF110ykvrDWRK9vDJTX9pK6VgepRYArEw+zyOmw0x9GXTQtnMTye7CrvprNUhUcKGF1O77n3OKj7VwEFiqgjCbg1BM+cCjQPtdLCr4bywjBZN7Wwv1kaJtbGIYYlGjubzaUs7saQ8aw7nrjHNDdDseZmMyt7+689cxNwill1XG/+rRtg21NKbX9iO75NjJMn+k0DU4fqJrq8uhPjCH2Fymkl1bKrU75tdi2t+L5NsmFr27YbYJsEwUPCp2uAfNFUJW5jqXxjKR+NzatiFIbbXUMFuVRjbQm8oyetREj4oeu0dv93hmFwPrA38CzQOMQZJwc/c6M5OLw0TPnPsnj7bNM5QYok8/UDaEnp+Ur4p0fzOxDCRh9gwZa+jZMrII6LUDaI7p2FkJQ0g/TxK6D5Ev1kn7XCFGZLsxItvdbvUNy3Thhx0ebNhdgdNHZjZ/gNBhyBdrQRCEw5wa/36k4PtebtX4Q/AGxG9fEARBEFpDJHBZcqy1mZJtw9AMCWDWVZGFtSAIwmGOJgWPErws3m6GaZ9qxSMBzARBEAShVTT8Yt3eRCKD/7S7PoCZ0HXoslJwX1oMQmY7rGUkTzQGeJRLeidg4DJbFj20prc+4qO9iEnFmJzK4Kfj67JJ6mQrJYlWVT/ab6kmKZDzp73Uvm10fu/IXlTmN5J0hZlkOeDWR32u6kXSI/cvLHomkxqHmZzdUk3t5hI6v4vemJmOO0Lbjt1J7QsMpfZxKZqlgkVLN9J5Qgn66KPmIta+niRTs5bT/eLt4NJsZaFr4BJsA4vyzeXl1lLWryzaN4/mzqOLA0BdBsm97Cw6t20HSQfDsaxfWX08Arw3nepL/ZyilQZTSN7PI65yeVsglp5Fa0g/8PHIrjxiOH/+nKu2UH39yU/HtE+ebgjJ10WhZdTsx8faYDAgwWlBSbUf5bV+pLuiR6MXBEtRFcwmPwyVTM5tZ1kySqJPKq17yF4oi/4ZNHrJZoSZXTbV6WXEEXg2jXAsq4/JeINsHuBNpm33ehr/gyy3bIi5k3nT9NdgL2bRw1k5Hjw8yGw5d+Exs/JcIm30MXl1EtkYPkep7U9Sc2OQKgvG0Tn9Ln1fOrdTIKOaIRSRPGYdzVNi3HS8lWU18TE5duyPe6h9OdQOfzzLalLLMrYwub2FZ1YZrZeohtnXPO4SZuG2n8/N2HUrE+0P9cuiMuw+8GPtP++mdgyidtiqqC5vjlvXPi4fV4l0T+1byV773dTn8evJ3aGmXyKCAS/wC4RuSEMf6/amX1osrGYjqnxBbC+rRe/kmOYPEjoE+WItCIJwmFOzbxIbbWENAAniZy0IgiAIB0RECp4Y0zELa4sEMOuyyMJaEAThMGd/PtYAz2UtC2tBEARBaA0RKXhybMdIwQFgWKYsrLsiXVYKbqoLwWQOASxAJ5fchpJY9EcmF7IUkxQq6NBLwbmEimNg/gn2QpIN1/UgaYWjkCacviSSQ4VdJDnmkTdrejC5VTmdpy6Dtm1l+kms2cvkXi7657RWULnqHC4bY1K5MGmYzLVMIswjRxtY/zG5miEYXd5mKyH5UyC+Yd/RdXNJF5dU8wisYHJnUwXJ3ep6uVl5qrw6i+pL+poGDQOLuFrdl+6vc5c+CrhzE8nRgikkrw6n0jaPoFqdzaLBV9L12Auprf4samvZALo/6e9splP2Ste2eRTTBoFmYWT3y8Jk4TzCbi2L0O7cVKZthxLrn6FwsImwp4LQgIgU3BnFxxqQyOBCywjH2RE22eBnElrHhl3ads0wGv+Mfhqf7LtJOl4xlI4FgNgdNMZaymmbZ3CwcNnwXpKVh2NIrmsIMDcmZusdxbQ/kMhciZhNsv60k/b36KNrH5c5B5jM08LsMo9ezc8bjCM7wV2darNpHmD0Mbkzm+PYSshFi8ugeTYIawPXSpOH+lmxDB1czh2M4dlRqP8sLLK3cthYGZrv8E8xtj1kc30smnn1KJJdx27ST/iDzM3ExMYa3jd8LuPNJHvt2EiuWOFEcsUy5JPkOzRugLZdMa6ntu36aju1O5HmDd5MfY5hHkHeuZ7OG06gdrhW0X6w+2Lyh6HEJndbSjtYCg5IALOuSqu+WM+fPx9HHnkk4uLikJqaijPOOAMbN27UlfF6vZg9ezaSkpIQGxuL6dOno7CwsIkzCoIgCO2JPxhGYJ+Pf5NS8H0+qWU1ErzsUEJssiAIQudTWtOxwcsAYFgWLayVpF/tMrRqYf3ZZ59h9uzZ+Oabb7Bs2TIEAgGccMIJqKmhr8Q33ngj3n//fbz11lv47LPPsGfPHpx55plt3nBBEASheWpYoKQYaxNS8MgXa5GCH1KITRYEQehcQmGFsg5OtwUA/dPi6gOYeYPYXlrb/AFCh9AqKfiSJUt0v7/88stITU3FmjVrcMwxx6CiogIvvvgiXn/9dUyaNAkA8NJLL2HQoEH45ptvcPTRR7ddywVBEIRmiaTaspmNMJuiv0uNBFyRhfWhhdhkQRCEzsVT69c8CxM6KHgZQAHMftzpwfrdFeglkcG7BAflY11RUa/rT0ysT7e0Zs0aBAIBTJkyRSszcOBA5OTkYOXKlVGNuM/ng89HPqaVlfv8p4z1Pz43ySocBSxdFvNFsm6lVBLhFDdtm/WOreY68n8xslQehhDt56m3nDvIl4v7BtmLWOqFVHqQreyNUdxOKmMIRZdo8GsA9L7RPB2TP5H8l2K3kg+VLk2Jnf6ZgzF0W23F1KYw86+0767Strkvm5H5CFkKqK5gnFvX1pCTpd2opnbwNGa1PcmfzcT8rWszaX/sJo+2XTGU0na5NjP/rRzaz1OXBZPJP8robSBhZSldwvboX+nMVdRu10/UDu7DZqhhqb7SKH1J8jrWrz1pvy+JPSd7qf/qMqmP66+DfMDr+pH/G48pELRHXwRFfNRVyBf174LAqd2X0i62CRk4QF+sy8TH+pCmLWwy0LRdDltNCJvNsFTSc1I7MkfbtpXSMabq6OOTa4NH93uI2VbuA83HZwNLtcljhRiraXwOu+hY287oaRV5eW9vsiu+YXQN9lL9/4B1B8W3MCWTry1vU5gFBbR6yBbVpbGUk6W0n6fw4nDb7U1j6cMcLNUUm7cn/kDXCQCVI8nH3cR83M0eum67lc5lLSQbFUiiuQxPJ2krYX3MxpDanlSez7X4dZaPoLgzABC3nfzGeYqzpuYs1nIq7++TQidirsyW1CRtm8/ZFHtOqvNyopYJxOrnBo5CFlcmh+oz1XH/fXrOUOqhdlT6YQjK+NkdidhNt9MCSxMvr9uL4ZkubWF96oiMDq1biM4BPwHhcBg33HADxo0bh6FDhwIACgoKYLVa4Xa7dWXT0tJQUFAQ9Tzz58+Hy+XSfrKzs6OWEwRBEFpP9X5yWEeQL9aHPm1lkwGxy4IgCC1Fy2HdgV+rI0T8rNft8nR43UJ0DnhhPXv2bGzYsAFvvvnmQTXgtttuQ0VFhfazc+fO5g8SBEEQWgRFBI+u3ADq37QDQLkELztkaSubDIhdFgRBaCla4LIOTLUVYVhm/cJ6w+5KhMMSwKwrcEBS8Dlz5uCDDz7A559/jqysLG1/eno6/H4/PB6P7g15YWEh0tPTo5wJsNlssNkaP4whixEGsxFhC8l5DD6a9FlrSLJTN4zaYNtD0qaGWLeXatvVLC2ItbyJrzRMSsRTQ+ikaCwwkLcHyX3NTGpe2Y9kVTG7SNqEBlJwx1aSnIXjWToxJk32pzj4EdoWl3YrNn82MgmTZyC1w1FCUm5LNUsLxdrk7enWtk0s3QkAgMnbufyZn4tLwnjfmypZqgwmZzeytGk8vYiNSfFqBpE8K2YDfXEJx+l9S7iszcBk6IF4uu6QjfVfAQX7AXMH8GeRXNCxncvn6fwWNphxiWQggc5vK9PLIgPplPLDztKqGNj9MhQw2fsA+mIUkb2Hm3AxEAROrZbDWr5YH660pU0GmrbLYZsJYbMJ1hKW1omP/7tprA5k0NhpZGNqgEm/AcCXwFyUmM3gUmhrORm1plyPuDRbOantPAVVbX+yH5ZKJu9l8uiGLlq1A1K1bVspjdW1WWTvueyap3GM/8WjbZeMZv3Bxu64bWz8Z/stVdRntcnMJa6crrP0CDonADhK6Rg+d/IMJUm2vZzNTQbRfsU+szhKWN8Y6P6YvEG2TbbUxl7IWQpJam0p03/BC7EvepZCShFkttG5AskshSm7LyHmGmUrpj6ryyUpeIhJ5p27ScLOMdSSLY7ZUaP7G093yZ8tzyByAXD/TO2uGt+b2lQeRDDYYJ4kdAsiqbY6MnBZhH6psbCZjaj2BZFfWoPclNjmDxLalVZ9sVZKYc6cOXj33XfxySefoHfv3rq/5+XlwWKxYPny5dq+jRs3YseOHRg7dmzbtFgQBEFoMdX7XortTwoeCbhS6w/BG5DJ4aGC2GRBEITOpbS641NtRTCbjBiSUf/iZ4Pks+4StOqL9ezZs/H666/jP//5D+Li4jQfLZfLBYfDAZfLhUsvvRQ33XQTEhMTER8fj2uvvRZjx46V6KOCIAidQI3mY920FDzOZobZaEAwrFBe60cPl6PJskLXQWyyIAhC51KyT9Ga1AlfrAFgeJYb3+/wYN2uCpw+MrNT2iAQrVpYL1iwAABw7LHH6va/9NJLuOiiiwAAjz32GIxGI6ZPnw6fz4epU6fi2WefbXXDqjOtMFmtSPmqSNtn8JPcqHooydjsRST5MfhIJsajPwJAIJNkUzwCd4hFjeZSJwPbru1FUqDY77Zr2yqB9ju2U93BRJIKuzaQPC7oZlFPf8rXta/2d/21bauHSaSZDNvAZGYGJj/jMnRnPr21qsum9llq6VhdxFAm6wszCV0gltpqMOvFDcF41mc+OldVTxYVu4zaHcggyRmPyO7tTTIucy2LSF5Esuuwm0Ve5xFXB1A0bqVX7+llflwuyBR7dUl0DT439VPMbpKKmStJcubNIgm780fyOQz0oWfRsoNF+2btMxr0DTQx6VwohsvyWX1H0NcncxWVN1bVlzFKVHChBdTsk+HGWJse7g0GA1LjbNhT4cUeT50srA8ROtImA0DQYQIsJoR7MWlxMdnf6mE9tG0eIZzLtC0VzB0KQNhCz5rFQ3+z7aDo0MFUGp8Vk+vqooUzGXUonn05YmMvz9QQZK46JiYvN5Xp3cnC8WQHa7PJBnAbyl2lLCXU7sLxLKNFMctK4qe2cvck7g4VYjJoSx3tr01mcuUG78pC1dzW0TGOYm4PqT/if6T5lT+L7il3P7MUU39UDSZ7HfczuXfx+U5tP+Y+tVsvteb3IhxLcwXFpODW3RTpnLtMmZiym7vgWaqZmwCrzlTCJOnMxvIsI9YSffsspTTvqBlMLgAxe6O7AnKU2QCF6H8TDm+0L9ad4GMNAEP3+Vmv3yVfrLsCrVpYK9W8T6fdbsczzzyDZ5555oAbJQiCILQNNS2ICg4Auamx2FPhxZaiGuT1TNxvWaFrIDZZEAShcyntxKjgADB8X2TwDXsqEAormIzygqcz6diEa4IgCEKHUqP5WDctBQegBT3ZXNx0AEhBEARBEIjSms5dWOemxMJhMaHWH8JWsd+dzgFFBe8IrFVhmC1hhGNILmRw0EMbs5Ekt1wi7s9JpnPsJKkSoJcbmctJrsWlZd50fXTpCLFrd2vbZceRRJdH4UQT0aFr+7hZGdo09svR1cHl6UY/bfsTqQ9MtUwCtZP6wD+MEsPX5ZB8ikcxte9mcjALDx3OIoGnk+zNwSKshxpIXGrTqC9jWCTwEItE6sgnSVcogc7rSyUJnjHA5OlMTqfsdH4uvQrE0X5DkHWmeT/viNhXHXMNi1rODrEX0vNgZJGRvZkkQeTtqzoqh+1n15BIUkH7drr+knEkCweAxPUkUzOxSODKRPcl6KQG2reTZC0S8VZJjCmhBbQkjzVQ/8UaALYUiWEWomOpDMBsNulsazDNrW07Cmgc5eN2kLkW6MZtAM51u7TtcBpTSoSpXJiN76YAy5xQQ/aNuwxZ9nq0bX8mc0NidVt2szLZVAb65gEmuo6Y1duoWDZJhbm7UdhO/2eufGprIIbGdp4lwu+meQ2PCh5w03nC7F/XUkNlKvrq7Z7NQ22N3cUyp6SR/bZ6WBYQZ3TpaiCGKqwdQXMqRzHLepFKti7kYG5VLto2+vQuJYr1pS+RuV/9Ru5y1UyCbeMZW5gdr+lFdcduJvkrd4kLx7F5BptPBeKpv32p+vmeMYnmKTzyOM8Kw++vuY4eFkNI6e6f0H0o6WQpuMlowNDMeKzeVo71uyvQLy2u+YOEdkO+WAuCIBzGtCTdFgD0lS/WgiAIgtBifMEQqvbFY+qMdFsRIn7W68TPutORhbUgCMJhTCTdlnM/wcsAIHff15udZbWScksQBEEQmqFsn5rBbDQgnistO5gje9WrfRZv2ItAqKHsRuhIuqwU3Fnog9lsQG0OSXVspSTHMXDJBZMIhS3sXYFR/97AWE5fYhSTmPuTSf5jYbJmLh+qHkUh7J1FJO/iWMpIOhRiciN7IYWz5BGgQ3Z99/P6eERyW1EtolEznOTflioWzZz9U9VmMAlemLZ5m2oz3FH3KzYRDzXwz7TUsIjkiXRNsXupb2pzmbyOxVIIMg12zG7WN6w/QsxXJczqtheQJNqXzK5nF0XzBICQi8nnmdQ6wPab65j0nEnjfT2Y/NtLZYJMHhe3hlwDlIvkZwEWadbooH7h0m8AMDBZuY+5H/AI9TxyLJfSV/Ws3w4GvMA6CMJ+iQQvi23Gxzol1oZ4uxmV3iC2ldZgYHr8fssL3Q9zhQ9mE+Dty+S6Oz3atj/DpSsbIRBLYye3sQAQ6EVuMjwatcHCjimk8bNqaIq2HbeRxvawlbnR9KLo1ZwQk2wb7TSHMFcxiTNzvWr4N+8IcgHidplHJw+6WWaMrSSZN7CAgDWZLCI2k0crI11DmO0PsemOL4FF1m4wg6voQ9dXm0Y2I2kDuxcso0cNs/22CrLpdiaDDluprZZSNhdh86uQjeyetZLO49hYqGufiqM2hZ1k4wMpZENj1+/Vtn196F6bK+kaYjdT+7jt5pL0UBxzI2RzIhtz+wo79B1Yk0XX4Spk2VJYfmL+nPF5l+W33TCFmXRd6BZEApclxlhh7MSgYVMGpSE51obCSh+W/lSAU9j6QOhY5Iu1IAjCYUxLo4IbDAbNz3qz+FkLgiAIwn7RApd1kn91BKvZiPOOygYAvPr19mZKC+2JLKwFQRAOY7Q81s0srAHys95SVNNMSUEQBEHo3uTvi0nSw2VvpmT7c/7RPWE2GvDttjL8vKey+QOEdqHLSsGNdUEYTQHEbmaS5V4kTbSyaJFcVhW7k8p7e+vlYNZCmiwaCykKpSGR5D9BJiWy1pLMzFZKMiQe7VSZabumF8mZuKTNUUdyIXN5dKk1AATi6Y2XMvI6mHwtwCRNLLIol1Gby2m/k5X3JVE/cUk6l3+DRbU01rD9cfqgDM7dJKeq6kPX7Y9jsu0y6j9vEtXn3EMyLiOTvPNonby8kbXJWkSSO1sxtSGYpI8+aqphdaeS/IxL0h07SD5eNYAkjPZSFmU+gdrkKKD+8PUl+aK1kM6jmCuCYlHiPUP0slr3b/QsOrZQdPdQMpXTuTUwrJX1fWAUP1ihBWjptprxsQYoMrgEMBOi4U91Imy267JeGILMpYbJl41VND47/TTO+xtEYvYmk12yeWjsNVXSMxjoT65YMbuiZ/Qwl7AsFiwKuZdloeDZRBTLMsLdiriNBfR2k9uPukwWhbyCuRs56f/MP5CkzFYP9ZmjmGyDN5lsnT+GxnxnMfVZ+QAqw+XfIbs+CnUgjknpw3Suily61qQfqZ9qh5PthmJZKAp5hhO6v3smkZw9ZS3Z8SCLeB63ir6WVR/ZU9e+2HUk8w6lUP8ZmWtUIIvmbVx6biylhUIwk8pwObduLsPgmVUcq7fQOVP1c0Qnm3cFkqh9XEpuqqb5lYE918E+PRAMeoGiqE0QDlO+3+EBAIzMdndqOwAgLd6OqUPT8b91e/Hqym14YPrwzm5St0S+WAuCIBzGkBR8/z7WAP9iLQtrQRAEQdgf3++oT6s6KsfduQ3Zx0W/6wUAeG/tbnhqxee/M5CFtSAIwmFKMBSGb1/u3ubSbQH0xXprSTXCYcnJKgiCIAjRKKryYld5HQyGrvHFGgBG90zA4B7x8AbCeO+H3c0fILQ5XVYKHoy3AmYblJFHdyY5jt/NJLolLDIok4Zx6TcAeDNJ9hTsT9Lf2M2U962qH+1XJpKHha30DoLL0MFUY2ELyYgcxUzS5iE5U4BFnLZup4ihAOBPpEirITPdGqOfKuHS8yCLOm0M0iQ4kELS5zomM3P97NG2PcMoYncsi3xtCtC1VQ8imZS5Ri879qZR35jZfTHXUjmzhyRTZifdl9oedE+NLNwpj4LtKKRjfcl0r0NxLDon+wIXNuvfEVkqSRLmZG/t6rKp/w0+2m+upWuwrN5IZUb107YDTA5v4IsOtm3isv+95dp2IpOPAUBdVhxdk536Ocj6yVZCUjvTdoquag/UywuDIf05BaEhNUxi2Vy6LQDITnDAajLCGwhjt6cOybE2PPnJJozLTcb4fsnt2VThEIJHwQ4lkGSWZ1EI9HBT+SAbX0sbZrlwIhq+odnatpEdz92eDMxdxsRctLj0l9skfya1yeKh8dWx3UPtTmbyaOhdcsxVZNe5i1ZtBrNpAZbNwUptisknm1Q+guwvU2DD76Lydalku71JdM5gKptb2PUR1lWATub3RXctq8mh/rZ7qF/5HIJLn0MOOmePL0mOze+ptZhluRhIsn1TnX7eEMgkKbli96sil9oUv43ui6GWzQP6p2vb/BlSJmofl4VbSpiMnNnu2jG52jZ3BwMA606ak9UOJHcvWxHNFYwVNK+s609ztrDFgGBA0hx1J37YJwPvnxqHuE5MtcUxGAw4cWg6ft5biXW7Jad1ZyBfrAVBEA5TIoHLrCYjrObmh3uzyYhe+9IPbi6uxuMf/4YFK7bggSW/tGs7BUEQBOFQIiIDP6Knu3Mb0oB+afUfbiS7R+cgC2tBEITDlNb4V0fI3ednvXj9Xrz4ZT4AoKRKfLUEQRAEIcIP+5Quo3IS9l+wg+nL0maKS1fH02Wl4Mpk0EUYBQBbAb19MVSTzKdmCEmEuOyLRwwFAGsFk/566W/KRhKOuE0knfAMddP+7UyWy2S9Nb1I0mvzkCyLR7nkUVPDTLYUSiHZOQDYv8+nv/UlOVXQySQm7H+ES7eMfqqDR0m3soieYSfJoVy/0HXqIlsmkqyvNoX6KNBH/6iY6lik7ira5tHTvT1I3hVkcjJHAZUx1ZGsjUdbr+5F7YjZQffaVE4yLH8uSagdW/Syeh8b6Lhsm0utK0ZSxFYuk685boi2rZPHMembbf1O2h9Hba1Lo763OEkmxiXigN6dIGxnzyKT7HE5XjiL2hppB/+7IESjet/CuiUy8AgRo/yv73Zp+zx1srAWAEuVH2aTEcFYsiVmJqk26KJ007gdZjleDSwjBwAEcph7DssAYWYy4hCTY3M7bmRuPsF4Jv/m4y07py5rA7M3hiKyH+aG2TriSBrOjzcy2TvPdBG2Mhcl5kLmS6PzGFnzalOoTJAlt1Bs+mJkimqTjX6Jj9VHwfb6aa4QBPW5mZoHTy67R0yV3+NTui9e5qqkcwNjfVmXQXaP2y1LDV2c1dPAXYkdb9lDrlIhO8muTTV0T6uGkw21VNJ5QzHRcwZbt1BIbhVDnWktZdlYfqGo4OER/XXHG6vpOvhzxiXmxlp69rmbXths0s3PhMObQCiMdbs9AIAjukjgsgg9k5ywmAyo9Yewp6IOWQnR3W2E9kG+WAuCIBym1O574daSwGURIl+sAWjycW8gDK+kdxMEQRAE/LK3Et5AGPF2M/o0iMvQ2VhMRvROrn/xtUnk4B2OLKwFQRAOU6oPQAoe+WINADcd3x+mfV+jKri6RBAEQRC6KZHAZaNyEmA0GvZfuBPol1qvOpHUmR1Pl5WChyxGGCxGWFgUTl86TfgsFSR5sheRzCfEImWbPPoHKsykQUb2J0NBMZXJJlm5s4Dq9rvovGYmBzMwNS6XG4WZnCwcSxK12jQ6j9XZQKpuY1FQmbTbUsnk1Swat2M3k0Un0v6Y3aT7MjJJnLGG9geTqC8rh5Ik3ZtI11Y5gLWhXP8OxlnAZHRMas2je8bsJSlVDItwzWWEAdavzk0kRTMG6Tw8wmuYXb8hyCOlkpwQAOpS6LwJ3xZQOSeTVIfpGqoGuLXtuPXseXCT3M2XSPKzUG4Pqoxdv5XJ1ay7PFTGqo8YWT6cRWXfQ/eX39Ogi0VMZ64FptC+59LQ9QZzoWtBPtYtH+r7p8VhRJYLMTYzLh3fGy98vhWlNX54agNIY3Jbofth8AVhMAVgZG5aPNuGzj2pOvozp9KTdL87CsluGj00/gUyyC5x6TTPAGEqI5cms2KZMRKZG1IMtcPs5a5RbEzuQ65XqsGwym28IcCjZbMI1CwGQchJ+7kU2tOPbImBtZVLvk1Msm1k77G8qVQ+yU2TlxMyf9W1dfHOQdp2RQ6dzBeg/1tbGZM7V9J5a3uTDeUuXUZ2zYYQs0M+2l/ej2x68o90rGqw4DAytzNvbgrbz/qV3ZeYfLpWXxqfE1B9zq0eOieLHB6y0XNiL2bPWA7d63ADd6qwm57lmiyaa8Ruo+fSEGBzKjZPi9lShGBYMnV0F7TAZV3MvzpCJHXmpkJZWHc08sVaEA4xyqq34/stb+DLn58BAHzwwQe6vyulcNddd6FHjx5wOByYMmUKNm3apD9HWRnOP/98xMfHw+1249JLL0V1tX4AXrduHSZMmAC73Y7s7Gw89NBD7XthQpujLaxb4WNtNRvxnznjseiyMbCYjHDtm+iW14qftSAIgiB01YjgEfpFFtZFVc2UFNoaWVgLwiFGKORHnCMNAzKPj/r3hx56CE8++SQWLlyIVatWISYmBlOnToXXS18wzj//fPz0009YtmwZPvjgA3z++ee44oortL9XVlbihBNOQM+ePbFmzRo8/PDDuPvuu/H888+3+/UJbUfNvi8qrfliHcGwTxHh3qcC8tSKFFwQBEHo3pRU+7CzrA4GAzAi293ZzYlKv7TIwroaSklUvY6ky0rBLXVBmANB1KWTHNa1hiS9df1IRsSluI6tFN2zcHKG7pxJ6+iLHJfwGBwk+QkkkGTKl0jd42Tyaks+tcPYh6RHdT1I6mVlEvaAnSRMrs0kKUKDh51HE+URzU0l1G4TkwfX9CLZkoEHQWURuJ2lVJ+3F0lWuEQr8VuKpFl0LEXntJaxCKoDWLsBVMbSNVl/oHPZy7iEnb5weZuQcDt20tu0ihHJ2ratgs5jLWNRZ3kEcxed07Kd5NsAYEzP0rbLj6J75P6ukI5PIekbv6feIXSstZhJE9k124qYpNDOJIHl1NZQAoua2iBCvaWOJGiBWOY2wKLG2/ZW0vEscr097wik4wgEA15g+7u68yql8Pjjj+POO+/E6aefDgB49dVXkZaWhvfeew8zZszAL7/8giVLlmD16tUYPXo0AOCpp57CSSedhEceeQQZGRlYtGgR/H4//v73v8NqtWLIkCFYu3YtHn30Ud0CXOgaKKUQCKlGuaoPJN1WQ9z7sglUSGTwbk/YZkbYbNFlSDAxGa+lmMJMB90sQ0IBSbbDCfpAPwYeFM/CxtJ9EXcBIJBOsvCAi0VlziSbwV1jTMx1xrqLXIy41JfbX18as93lejkvl3MrNj5ziTSXf/PsJdxGJfxK+0uHUTuCTQTsDbCmGgJ0bWUV1NbiFH1fxtnof7SsmvrM6qPj69JYZG8y9whvoTGCy8W59N5gor63sqjvyUxiX8uykthL9S/jzCVk70OZFHk8ZiOz3z42zhiZPeRDG9tv8NA5TSz6sW0X9XcgjWx9ZS5FGo/dxbT3AMxFZHNjt1N/hJiN9/chVwbdsxHnhAod+DgrHDps3zevznQ7EG+3NFO6c+idHAOjAajyBlFU5RM3rg6kVV+sFyxYgOHDhyM+Ph7x8fEYO3YsFi9erP3d6/Vi9uzZSEpKQmxsLKZPn47CwsL9nFEQhLYkPz8fBQUFmDJlirbP5XJhzJgxWLlyJQBg5cqVcLvd2qIaAKZMmQKj0YhVq1ZpZY455hhYrTSRmjp1KjZu3IjyckqTwvH5fKisrNT9CB3D5a9+h9898An2ePTpd6oPwMe6IfLFuusiNlkQBKFjKaiof6GS3oUXqzazCb2S9kUGFz/rDqVVC+usrCw88MADWLNmDb777jtMmjQJp59+On766ScAwI033oj3338fb731Fj777DPs2bMHZ555Zrs0XBCExhQU1H95T0tL0+1PS0vT/lZQUIDU1FTd381mMxITE3Vlop2D19GQ+fPnw+VyaT/Z2dlRywltS7UviOW/FqGk2ocFK7bo/lbra326rYZEvlh7JCp4l0NssiAIQsdSWFmvdOjqX4EjAcw2i591h9Kq2dapp56q+/2+++7DggUL8M033yArKwsvvvgiXn/9dUyaNAkA8NJLL2HQoEH45ptvcPTRR7eqYcpogDIaELeJvnoF0t3aNpcZB2NIihFII/lT6lclunP6epAciEvFDD6Sa5nZVxleJsyllA76Z+KSchOTQ+micbMyXGpu26T/cmBIovbVZpNMyuhjUbEtPNIl9YEyk3TLwuTL4ViSjvvj6Bqce0kCVTWUyeoZVg+dM2TW57A1F1E7gg6SloXs7Bh2X3jkcB6hM8Tax6OZK3adxu1Mvt2X5P0GFtFT+fQyVWsVtde+i56hUCJJ50xsoRBgkn77Rlo4esaSLDx2J7Wbt89SSDLHyhG0GLXUNJ3311YSXVZrrqb9Nbkk3TfX0blsZfXPlinI9P9dgNtuuw033XST9ntlZaUsrjuA9bsqNFXrP7/biTmT+moGv3qf64TTejBS8MgXa5GCdzU60iYDESm4GeYKGgutBSSHrcsh+2uupTFL2WmcD8SRCgYATF4axwIs8rPzVxr3LeVUH7fLfjedN2ylMdnqoWfV6CT7qVg0c38C2X37ThrDGxJoIketuYquW+dClkpSbT4nqM6ha4vfTu2rTaNr8CUy9zAjbZuzyaaf3m+9tp1jI9c3ADgqLl/bnl8yjdoXT1M9RyHrA7pdCPE1ArPXXta+2E3UT/4Uuk7bJrKZzjDNJ3h/A3r3KGsF64P+0SOEgx1u2+nRtj2jqLyLuYf53fRsmT3MnY7ZevcGkrCH4ujaGravLoNlWtlKcwhvKnWaraj+vpRVb8f2vV+hwlffDx988AHOO+88rZxSCnPnzsULL7wAj8eDcePGYcGCBejXr59WpqysDNdeey3ef/99GI1GTJ8+HU888QRiY+n5W7duHWbPno3Vq1cjJSUF1157LW655RYIHcuhsrDulxqLZT8XSi7rDuaAg5eFQiG8+eabqKmpwdixY7FmzRoEAgGdBHXgwIHIycnRJKjREPmoILQd6en1Lwgayj0LCwu1v6Wnp6OoqEj392AwiLKyMl2ZaOfgdTTEZrNpktTIj9D+/MjSuvmDYTz32Vbt9wNJt9UQWljLF+uuTFvZZEDssiC0hlA4gDhrCgYmToz6dwkoengRWVinu2zNlOxceAAzoeNo9cJ6/fr1iI2Nhc1mw1VXXYV3330XgwcPRkFBAaxWK9xut648l6BGQ+SjgtB29O7dG+np6Vi+fLm2r7KyEqtWrcLYsWMBAGPHjoXH48GaNWu0Mp988gnC4TDGjBmjlfn8888RCNBiatmyZRgwYAASErpm3sbuyo/7vuSM71sfyOn1b7ejpLr+a1pbSMFd4mPdpWlrmwyIXRaE1pAS3xf9E8cjNSa30d8aBhQdPnw4Xn31VezZswfvvfceAGgBRf/2t79hzJgxGD9+PJ566im8+eab2LNnDwDoAooOGTIEM2bMwHXXXYdHH320Iy9VAFBwyHyxrle+bpaFdYfS6tnWgAEDsHbtWlRUVODtt9/GrFmz8Nlnnx1wA5qSjwZizFAWM4IOFvmaKYS8iSTzsdTQH4xMJlY5OFFXV+xWFiWSSbcCLA+dfQ/5IlT1I8lP7DY6ti6XIpFaS+mNo5VFhDbuoC+CgQGZ2ra5mianNcP1UctNProOHlXcyGRM5hqSV/tdtG1kkbYDPandQSeL7M1eo1T1IplTXRKT0FXSeWqyqT09YvRBkYpGUP8HN5N8KsQk87UpLHInU0VX5pDMPX4bybic2zxUZgjdO3MaReHkUi9/PNUV79f7AysmIatl/WGppfpM1UzKxySI/hF0X5x7qYyBPVuKXWfVcPJX5hFyuZyuLkUfOTKeRRMNs0VPkL0BtdQwiZuLyli3laPOV4ZgqF5Kt337dqxduxaJiYnIycnBDTfcgL/85S/o168fevfujT//+c/IyMjAGWecAQAYNGgQpk2bhssvvxwLFy5EIBDAnDlzMGPGDGRk1F/7eeedh3vuuQeXXnop/vSnP2HDhg144okn8Nhjj0HoWkQW1tccl4sqXxA/7vTghS+24rYTB2nByw5OCi4+1l2ZtrbJQNN22RAKw2AIw5dOdpm72liqacwK2emZ82ZSeVuJ3paYCigYoupL43jtIFLGcFm4qYJlybDT2GvhtjWT7FtctT7KdwTHFnIVC2TQy0LuugUAJuYCUc0ycZjcNKabmKsOnwfwiOdWFjnck8sim7N/KxNrKpdRW63Ur9+V5mjbv+9DL0cBwMgmSQnxJHkuZ+9FVDHZOl8anTc+n+6XQXHXLeZ254ruBlc3qAeV3073s7Y/2W5A7+rEI6zzZ8JYSdtBJsM3VJEcPn4zW9CEqK3cBQDMVYxnE6nNISUVd6ED9PfRxiKaBxKpzxzMjY5HfbeWVQHhxu5ZzQUUnTFjRrMBRX//+983GVD0wQcfRHl5ubzw7kAKK+v/Ubv6wrrPPneNsho/Sqt9SIrt2l/YDxdavbC2Wq3o27cvACAvLw+rV6/GE088gXPOOQd+vx8ej0f3hpxLUKNhs9lgs8nNFoSWUlmzB2t+e0X7/fbbb8ftt9+OWbNm4eWXX8Ytt9yCmpoaXHHFFfB4PBg/fjyWLFkCu52MwKJFizBnzhxMnjxZ8+d68skntb+7XC589NFHmD17NvLy8pCcnIy77rpLUm11MYqqvNhT4YXBAAzPcuPa4/risle/wz9Wbse1k/qhZt+E8mC+WCfsk4JXiI91l6StbTIgdlkQ2oq2DCjau3fvRueI/C3awtrn88Hno7c14tJx8CilDhkfa6fVjKwEB3aV12FTUbUsrDuIg85jHQ6H4fP5kJeXB4vFguXLl2P69OkAgI0bN2LHjh2aBFUQhIMnMb4Xjh89F8GQD5/+8AAqKip0/swGgwHz5s3DvHnzmj5HYiJef/31/dYzfPhwfPHFF23WbqHtWbcv6FK/1FjE2syYPCgVvZNjkF9Sg8Xr96Jmn8ri4NJt1X8hKRcp+CGB2GRBEIB6l4577rmns5txWFHlC6J2n1qjK6fbitAnJRa7yuuwvbQGR/dJav4A4aBp1Wzrtttuw4knnoicnBxUVVXh9ddfx4oVK7B06VK4XC5ceumluOmmm5CYmIj4+Hhce+21GDt27AFFH7VUB2E2B3VyKEsZSXAsldT0kIO2uVRYNfAgr8skybJjL8mKDExKZCylN3pOHlGbR/MuomO5JM5azmTDMSQR8qayqJpbSWru3KaPRFrby4VocOlSyE4XFf/DXm2bS9nKBpFsyciUSf546suqPkw+72fyb6aMOuOYb7Vtm1EvcdoRT1Ltrzz96Q+KycnCLEK4jeqI3cX2s+tRNiat8/HoqPz0dKyjhCb6yqiXdPGIo3XpLCqsl8rxCLa2YpLN1WXQc8IJs+csZKdtHjE07KTnz5tM9ToL9YsSfi4eQd5cxJ4JA3v24+me1u2TVQYDBxx7UDhMiAQuG5HlBlD/UuUPeVl4eOlGvL1mFwUvsx6Ej/W+L9Z1gRC8gRDslgOXlQttS0faZADwJttgttgQ8/FP2r66CYO17bCFxqzYtXu0bT62h90Nxtcw2SJ/HJWLXU/2rXoYkxqX0DyAR+YOOelY1w8kHa9jk0nb179Q+QH09c9Uw+TODSJFm5h8mbuEBeOpnGJjtTeVxmoe1dpaQTbAUcZk8km0HYhjds9A29y6DXCRmxmXfgPAx1VD6bwB+p8PF5Mtqs2iY2xFVLfPRbWEzWRbeBR2HtGdZ1Dh8u+6XOpvc4PMGN50uvd8fmYpILvHs32YKun++nNJZRGMZRlHglTevsND17NvTAT08wxLFdlb664yNEXYRW01FtN5/cxdwbKb9gd6piAY9AK79efhAUV79KDnuLCwECNHjtTKtEdAUcnU0fYU7ftaHW83w3EQLlYdRaa7fi2y2+NtpqTQVrRqtlVUVISZM2di7969cLlcGD58OJYuXYrjjz8eAPDYY49pslKfz4epU6fi2WefbZeGC4IgdHfW7vOvHp7t1vb9flQmHvloI1bl06QxxnbgE4A4mxlGQ33IgMq6gCysuxBikwWha8MDikYW0pGAoldffTUAfUDRvLw8ANEDit5xxx0IBAKwWOpfLDQXUFRcOtqegopDw786Qta+tIK7y+uaKSm0Fa1aWL/44ov7/bvdbsczzzyDZ5555qAaJQiCIOwfpRTW7ar/0jOSfZ3JcDswvm8yvthEwZkORgpuNBrgclhQXhuApy6A1ENkQtEdEJssCJ1PMOxHVfVehEL1iy4JKHr4UqCl2jo07GCGu76dezyysO4oDtrHur2wlNfBbArrpLVV/SiatINFquQyHy7rdq/RS2tqBqRo28YqkkVUDaEo3zYm+TZ6WYRIJv/mEt2Qjer2JbFj46ndzj3sgWayt7JR+qjl8VupnKmGycqZ1MnAIqLWDaHo1WYWQdpZSu329KFbXN2TycZcJOMK+lj/eZk0LExyq7/2+F7X1oUeinSe34uuozCO5NVmC5M4b6B7FySVPIwBul8+JqGzeqh9/Pp5pGwTk1AbvXqpdXUua0dtKOoxYSYr57K+2NXbtW3v4Cxt27aXJN+KRSvlkUEtez3atpMFewo1CBrBI6KGmZyoIo+kYvHLf9W2DU56tux762XrwVD0aLdC92B7aS0q6gKwmo0YkB6n+9sf8rK0hbXJaIDNfHBuA26ntX5hLX7W3Zq4H3bDbLQBaWRLufzbXkx2VcXReM7Hv9pMJpUGYI8hO8OjigeySFIcu4HSg9X1pyBP9jKyywEmMzaEyX3KzCI9G1OYj6GHbGkokcbzhpGieQYRLosGU22bWcR8Yyi6oiNspf/BqkwqE2Lzc3MqzQHMFqor1k5jfZyZ+vgomz7bRFj9rG2/WPM7aqqTzuVMIrcn/0bqpyBT6Afi6bwBRds2lgWF2y2jk+6vI59k4b7M6O5tAGAtZ8EQrVRHbTa1ife3hUVb5xHn+f2t60NzESPL0GEvon71JZO9NqZQXQBg/GWbth3oSc+K0UHPO3cNiMwFK32FWL3lTW23BBQ9fDlUApdFyHTXj7e7ZWHdYXTZhbUgCILQNBH/6iEZ8bA2WDifMDgdcTYzqnxBxFhNMBgMUc7Qctz7/FfLJTK4IAiCjkRnDqZlzEEw7MfHBc9LQNHDGFpYHxoS+8gX670VdQiHFYzGg5sLCM0j0Y8EQRAOQSL+1SOYDDyCw2rCycPr1Q8Hk2orgtsRSbklX6wFQRCE7klBxT4p+CHyxTo93g6jAQiEFIqrReXYEcjCWhAE4RBkY0F9hoGhTcgtzz0qB2ajAX3T4qL+vTW497nkeOrki7UgCILQPSncl4ngUIk1YjYZtZcAIgfvGLqsFFxZTFAmE0yV5Ffj2kDbgUTy07JUk7OTqYa+qATS9BPOmI3FUf9mL6PJoplFzqvLpAmpkaUBse8iX1vHHvLxMjKZZDiGZCIBJhkxsDRLiT/oUz2EHVQHT+Pljyd/Ils5tclWwPytWVtNXuoPcy1t24uZPzjzn7bUkjTEn0I+blurycfoG68+bcYWL/m57dlKPuqWSmqrYh+3DDxlFtvWpU4pon4NJdH18LRYiqcvKaDUZaE4/SBnK6fKzcwnqq4HPTcxWynFB3+efIPIf9zop+sOJrBnroT6XrFURoF09swx+a3Jq09XFjLylGPUZ65Vu6gdI3O17TDz+/O76usLBszAjxC6KZEgKpF0Gg0Zke3G0huPQXLMwUvWXPvGJvGx7t4EclKgzHaYKmjcjv2JYpn4syk6cZjb6CIaq21OvV8w91kNM3UF9+ENpru1bft2D7UnleyEuZqeTVMF2fGgm9rhzSW7ZVBkGwOxVK9jF4unAiDEfMC5/dH5+VbQl6Cgm/7fuJ+vLrUkm3kpE2uHh44NsdgnexMoZssqYy9tuyT5K11bV9dR6rO+PWi+k/8tpViqCTFn6kQWB6WWpbBi4ViMAfolyNJtGVnskyBbZPBJZcjR4NsN80sHt4EsxZmVpVXlhFmKS+5XbWLxcniMk9p+NC8xBFi8HOYnztOHAYBpONlcnsoNrD/482AqYXFX4mKgQl12Si20EYWH2BdrAMhMcGBPhRe7y+twRE70CPJC2yFfrAVBEA5BiiojaT+aXjjnpsRqeagPBvKxloW1IAiC0P0IhUlOfahEBQfo5btEBu8YZGEtCIJwiFHtC+L/23vz8Ljq8+z/njP7opnRvlmS5VW2sVlsMI4JJODgppCGQEiaksCbpskbCk2C0zblfZNAaIvTtFl+aUlIs5D0TSmBNglLCAQMcVhsFoPBeJF3a981mkWznjm/P2bOeZ4jS5ZkaxlJz+e6fF3HR2f5nmXOd7uf+4kmc7NNMyFJK85LwYdECi4IgiAsQPqjSahZDYoFKPU6xt+hQKjJd6xFCj4zFKxuJVrvhc3ugi1OGhwuq7IyabJ1mORMkUaSOQXe7jcfVKV9sk6ScTl6mfQryWThcZb+qYekv4lFLJUHS//E5UI8pYNnX7uxPHwepcgamYLJJH3z0JiHp52kS6kS+jEnqkkuzodIHCzliaOM7kfaR9KrmhdIk6WyCa14Of3nUJLkYx/v/JSprGqS3b8BWvYfo234+VyDdHM8PXTPVCbvyjIZIVjaNBtPq8WWE7X0HLgsDzDL/IaZrN7Xwj4sbJusnW7g0FK6xyUHaPtUgNanWWiAhcvbsvSfRBlt4z9qnulznCD55PBakp5rLK2WfYDSoihhWtbfrExWjCgWKj15GbjPaZsSc7Lx0GesRQq+sMnaFWRtCmzs26m56LtoDVP9qbE6dngppUGyJllFCZhCZuztFB6VqicpL//22lmqQh76ZWH1uyVE0nMLCxPiYUG8vvW9020sR9dUmornbufhXvTNTVRQqJT7WCttU7KcysdCgGLVLC0jC1+LNrL7waTmWQdLs8k06KuLKfXYfwytNZW1M0WhSBkWc5UpYm2nGK1XPWw9qxrt4dNTSgHmVGTRWmq/OEN071MBkud7Wuk5AMBwHQvxqqT9i5pDVCYmC9fYuXmdzlOX2bpZSJ2XhwjSvefndXexelUd8S4y4tXUdvK0kOQ766D3SS1j6cqKnMhkEsDRMQ8pzHH08KvyIids1rkzL1lbLDPWM8nceTMEQRAEAEB3WDdQmZmUHxJjLQiCICxkuo3wq7kjAwdoxrptUDrWM4F0rAVBEOYYPXnDnsqimangg4YUXDrWgiAIwsKjy8hhPbc61oskxnpGKVgpuLdtGDZb1uTKnA7Sy8zXc8dHVz/JfzKlzP0SgHWY5GSqk8YU0mUethUtc1fITIBkXBnmdOkYoPOlSql8rg6SQGVLSS7ESZabf5zRanocZXtp/3SAZqWsCZIuOfpI0qTZmRRa49pkwtdO+3JnbucQ3T/VyaRXGebaGTe/KoqT9gkcYccKZ9kyredy6aydScsUJn9n95U7tQ810n0KHCOZOw8H4C6hgNm9lcvJUkF6B2zM2ZY7n1Y+fpx2tlL51KZqY9kUPqBQuS2mGFTmEK6an0mmlmSEvKzDy0gyyR3nU3W0vXGMTAI4ddpqYQHQbVTwMzNjreexHhyWGOuFjEXVYLFo0Gyjj8lzObYySPWnm0mwTXUVzPLq4VVVtM8xCuVKL6Pvn5KgwR3VP3qco4WFWdm7KPtDdA25gjv76bxczu4cNL/jiRomLw4zV+wU+6bXUd3AQ9OSpcwhnEWNBY7ROVQncwJnTYLoErZDlOrfA4N0j8odZql1MkvbtfYFqdwhel5sE7jb6T/OIbqeeCVry/RRWYcr6PqDb4eMZS7TzrAsBalS3rYyS6ot7Dlqbjoul/072DsUZ1J6Twd1ECKbG41lLim3scwd9g46V9ZPZcq4zG0wHtqnuli7gYXUOfpio663h5OAKt/H+YwegjWXHMEBmrEOJzKIJNIocp27oakwNjJjLQiCMMcgKfjMVPC6edlwSkUyo46ztSAIgiDML7qGZnZAe6rwOm2GT0pHaPR0dsLUIR1rQRCEOUZPXk1TUTQzFXyRy2Z4GIkcXBAEQVhozFUpOEApt9pDw+NsKZwrBSsFT5a4oNpdJokudxO1spcjy+IM+fbccRowy4AdIZLsZDy0nT3KXEYzzJEcJBFy9dIxlZOdtP35i+lcXDrUQ9IhK3M2T9vN5av49WFjObuYpGWqi8Y/uNMldwV39pE0KrycuXJ20fVwuTR3tY4sYuVgsmT/MeYqepX5x5h5M2gsJ5mZt6+dysedO+1MYpX2svvN3EeVFK3n8u/SvSTlsySZpMtLnQoeDgAAWTddnyPC9mFOjlyyZu8miVpqJTm325nke7iCHZNMZBFuIqm/PcrCEnromYRW0zMBAFuCpHNFR+j6hhvoWEo/k815SAqpS+Uy6YL9+QrTTPcMV/CKYkHAbUdoOI2h4TQqZii2Wygs0kU2aHYb7D30TU00BI1l/j3X2PfZygdjrKySAZCoo5AZ96mQsZyqZcdl9Z4SoRmXLHPEj9bR95yHN1nDvH1A310lySTb1SzDhNs832BlmUnsPcxtPEN1PA83ilczGXUPSZl9e6nhMLiZMm5YWV2QcdNxHH0kmU8HqAwVHipDImuWdMZVauNk20jyzKKV4OlmZa1kTts8iQoPT6qiY3o66Xpiy+ieeVqpnrQNMtdtj1mqz9tF/By2CL03rk6ScGsOer4WZuBt7aO60VFE5+AhCtGVQWOZS8SH61n7qMUspY/XUJvK/xY9L7WU1ltaqfJPLl9B5RiIw6KOHoYnzA96wnMvh7VOTdCN/R1htMuM9bQjM9aCIAhzjJ5ZGDnX46xDMmMtCIIgLCA0TZsfM9biDD7tSMdaEARhDqFpGkv7MXOxXoH87NNgTAx6BEEQhIXDwc4IhuJpOKwKFhW7x9+hwKgVZ/AZo2C1pLakCps6wunZxlwaa0k+5ugm6VBkCZPyHGa21ADCK5nkrJ27lDLHTOZYyqXgadaAtYeZW/hKknRlPLRvlpXVxtzI0z665VzaDgCoILlvopJ+uNwt3DVIZbUxh/BUCY2g+Y/S/UiW0XGsMfpBDVfT9Xi76T6HG9grwVRNiWbmcA1AY9I0Xxtda6SerrXs9UFjOcM+RNwVPM1cXfn9Lj5A15Dhrugxun5NoeNY+0hODQDp5eScauW5dx3s+TL5uOYgSV3GTfdArSHZmP8Yyd00Jx2n6AiTB7J3NlVOsrfgYeYiDsDaT/v0XUayf9cAk+svYvJvFsbg6s2NmmZUkfQsRCLJDOL5d3cmJdnFHpmxXuh432qHTXEgsarWWOfspm9bhsX8214/ROs3rjKWHa1ULwAAFwtngqNn5bB20T5akL7JVlYX+4+xbyerM1KVzLl5iOp9LiPneA/2mv6fWEzf4XRV0cjNAQDRFaxt0U1l4vW9tryS1ntZnbmYjuMcoGVXH6sng7T+2CCVJ6uZZfWH+8vpby6qwB2s3RCrpXq26DjLjsIuzX6Ehb6xDCfxenadXVT/cKf3tIc7fJul6jzriKeL7hPPkOJuo3NzaTfPZJKuChrLPEMMxxFi4Wes/eE9FjKWhxeb2zVpLwsVK6cbwsMGVNbmc/Wzb2EmC6gj2nTCvOHRve0AgCubKuBxFGzXaUxqi/UYa+lYTzcyYy0IgjCH0GXgfpcNbod1nK2nDl0KPjQsHWtBEARhYaBmNTy6twMAcN2FteNsXZjUyIz1jCEda0EQhDkEycBnNs4rmJ+JCsVFCi4IgiAsDF453o+ucAJ+lw3vbSoff4cCRJeCd4cTSIuyYlopWD2DpligKRbYmYOdypyeU8UkN7JFSfZVxGTQqVKSleUOStIoLg3i7pTOY+T4mFpMPyDXSbLMzPpYg5bNGDlCNJOjumk9lyzbhkm2pDrM4xpZJ3OdHqDGawk7bqSezu1tZ1K5IRqF4rIsLn1LB9m+bWzUKkv3JV5CUnorc1BNFpvL6mujZWeYuaezfbgDqEn+7eEu53Rtjj5yEx2uY3K/BN0zxTa6FDy2zjyK6AgzJ3Am+eNycyhmGZ2xPZPxu7vZ++el5xOvpHerqJlk6Bpzold4KEGR2R1VGaZ31tNDMjN3C5O0s/eVlzWbf+eymZmbrRQKh5l2BNcJ5L+/gzJjvWDJ1JUBNpcpU0WynL6FrnYKv9KalhjLNlaPZyrITRoAFBZawGsZlUmKs4srjGUewmOS6LLvs7ONvqMDF5cZy/7jtL2eXQEAHKyeVEtHyL1ZNeE4TFlAUksp3Ii7fydZ20TJMBdylhGEO1wHm2l5mKKCYAtzB3MqxEAvy0JhNTeQg266z9Esbedk6ns7C6fiN7zsbXoOXP7deylJzz297N4nmGSbOb07WvuMZWsN7QsgJ5fOk6im98bTTPtki2g9z+zie+kYHaeSnqnqZeFkXdROs7L1powwbXSPHIPmWFlnH8sqw94n7jgffIduJn93kzU+ZDI24ACEecav8zLwa9bVwGmbm+2uMp8DTpuCZCaLzlAC9SP7R8KUcU4z1l//+tdhsVjwhS98wViXSCRw2223obS0FD6fDzfccAO6u7vHPoggCIIwYfQZ65nKYa1TV5KriN9pHxpnS2G2kDpZEARh6kikVfx2XxcA4LoLasbZunCxWCxYXpmbOHurLTS7hZnnnHXH+rXXXsMPfvADrFu3zrT+jjvuwOOPP45HHnkEO3fuREdHB66//vpzLqggCIJAM9YVMzxj/Z6V5bBYgLfbhiROqwCROlkQBGFq2XGwB5FkBrVBNy5eXDLbxTknNjTkyr/n1OA4WwrnwllJwaPRKG666Sb88Ic/xD/8wz8Y64eGhvDjH/8YDz74IK688koAwAMPPIBVq1Zh9+7duPTSSyd8DiWThQKzzGm4hhqSvhaSDWeZHFvh8tkReLqYEziTLnE3b20lybucp8iic2Ajc5lO0Tl8x0l6DnZMe2fIWFaZvJrLweLlZsfMtI+2g4WO5W0n6ZL/BF13spi5ZTPZEpfpuTpoe+6wmSxhUuSTNAPljJA8hLtqOiJm+UvKR8cqevagsZxdSo6ZXOrFJfDOEC27DtPMSWwt6eCyDnb9h0PGcrqCZHrhRpJnFR9izwGAtY2cXbUikqRHV5M0zXuS9uEu394TdD+GG0hO5xik98d/iMqUrGLy+WG6Z9Yoc6ANmDtBlig9l4w7aCyrPnou8Rq6Pk8bba9LxBWVziUsHHoiuhR8Zmesy3xObGgoxmsnB/HswW7cvGnxjJ5fGJuZqJMBQHXbYLHZTN9z+wCri730TvKMFPYwfQvtrSTXBYB0HX2TlTTVj/ZukpVnStk3NkL1YYq5dNsHaLCHu3cHed2gUt1tZ9lALGcI2+GhSLGLmCN0F6uLmRyeS8dN8m8mYbfHaH3GTeVQWTXBXbDd3czVu5SuIZY0l7WfZ+9w03YJUtLDwdrUKtvdwkLCEouo3vOfZPUYC1+LLmHhWnG6HgdzTOZtDsB8nz1HqX0VX0rvgKudZQRhIXWOIAshyNC9tLB40fRymlHk7ULVSeUYXkk3w33C3MFIV9I5bCxMrSjOQghYtg/nUWq/uFq6kNHEf2I+kc1q+M9XTgEAPnhBDZQxwgfnCusbivHTl0/idda3Eaaes5qxvu2223DNNddgy5YtpvV79uxBOp02rW9qakJ9fT127do16rGSySTC4bDpnyAIgjA6PbNkXgYA71udSxn0u/0iJS4kprJOBqReFgRB+NYzh/HysX44rApu3FA3/g4FzobFxQByObljSZmYmS4m3bF+6KGH8MYbb2D79u2n/a2rqwsOhwPBYNC0vrKyEl1dXaMeb/v27QgEAsa/urq5//IKgiBMF92zNGMNAO9bnVPu7D7eL2m3CoSprpMBqZcFQVjY/PrNdvzb80cBAF+/YS0amRnvXKU64EZt0A01q2Fva2i2izNvmZQUvLW1FZ///OfxzDPPwOWamtmSO++8E9u2bTP+Hw6HUVdXB0sqC0s2a3KyDrxBsyTp6qCxzKVo8TqS8nBZGWB26nYfJRdKu59kXBqTYKcWFdP2vaM3IrNuuoXcZdTOHMyHq2i9u4+O4+0kJ1EASBXRPr49p4zl9OJKY9kkJ2OyY/sBsumOvquRDmobfezEmqR7w+VasQpa9h0naV3Gw2TqAHxtVPbY5U1UjhiTj4eYIzm7Nl7uVAO5e3qOkSwr2kSxLJqbuXsyx1X/SZIEKjHzvVSZG2mqlCSJ/PkmK+i583fFxl4bk1ytkd4H20DMWObyb5W9D1yiZouaJWJqGb2n1sToqQ98zXQ/MsVU1qFluWU1lQDeHHVXYZ6iaRozL5v5GevGMi9WVPpwuDuK55t75mxOz/nCdNTJwNj1sj2UhM0Kk7tzqoIanGk/C6k5yhzCWaaKTDV9RwHANkTf8SxzgeZhPxqTbWtMauzoIvfq4cVBY9nZz+oGJh2Ps20cgyyrRpSWuRs0ACgJqrM1C9U/oSYqn4VFoLn6qT5wdtI9CK+mOo2Hk4GFvNU9w9zFS+hcratZpopmGlCLLjNLUy1eOlbpGzz0i7bxt1IbIhFgdX8VXXdRK7s3MXb97Dlak+PPy9j7Y6b/W2LUpoivpHaNq5PJv1nGFu++DlpfQxeR9o/u6M7bMkqKrtN3gs6retjzPUPoIP+bptBxHW2snXIBff88J8PQ1CQg4atznr2tIfzt/7wNALj1PUtx/UWLZrlEU8f6hmK0h+J4/eQgNi8rG38HYdJMasZ6z5496OnpwUUXXQSbzQabzYadO3fiu9/9Lmw2GyorK5FKpRAKhUz7dXd3o6qqatRjOp1O+P1+0z9BEAThdIbiaaTynZqKWZixBoCr87PWvzsw9oynMDNMR50MSL0sCMLC5ccvnkAqk8WWVRX4m6tXznZxphRdDi5x1tPHpDrWV111Ffbt24e9e/ca/zZs2ICbbrrJWLbb7dixY4exT3NzM1paWrBp06YpL7wgCMJCQp+tLvbYZy2f5tVrcjNNv2/uRYIpaISZR+pkQRCEqeV4b05B8dGL6+e8YdlI1jfkOtZvtoSgZs+g2BDOmklJwYuKinDeeeeZ1nm9XpSWlhrrP/WpT2Hbtm0oKSmB3+/HX/3VX2HTpk2Tdh/VbAo0m2JyE03VFY+6bZZJw9x7ThrLkcuWmMv/DjlFR9aSM6SnheRKyQomG2Y/KM8pcopOMsdR7qTJnay5+yWXidlCTGLVZ84Hqy2jMg2fz9xHO0juFq8d/dz2IK139tM94+7YCnPH5vJq7kRdup9kc1z25RwYIVvnsncm/0776Fl4+kmiz6XWsUUka+YyaM3GHDmZy6jqZdal7F7y6x8p6VISTG5exEIAeti9GableDXdGytzAM3aqKz2CJPEOdlPh3137WG6T1yCmPWYZxetQ/TO2T10fabQgpIgbZ+kDkzgWE7WlsnQ8YWFgZ5qazaMy3TW1gZQ5XehK5zAy8f6cGVT5fg7CdPCTNbJAIBsFrBkTUPyPAuFY4i+nYlFVCd5DlM9pJbSegCIs+14PaOwOhRM1ptmUmELc/l2d9I3lTtW25lsmEuOh+tZxgf2PefSZ8Dsbq5kWJ0bZ+fupnInyul8XJ7ubSc58nA1c0xnDuHhRvpdO6K0vmwP3ePBVXReR6dZtu4IUWWkKbSdt4PdS1ZVOmL0H17nOrrpPiVq6F6mgnSfio4wqf+h48ZyZtMajIky+lyOwutDNliXLWHO40N0/7gzPMfG2gHWAboG3na08jZlbdC0v6OH9kmXsFAx/v5VkfO6hZ0v63Mgmxk9rEuYO2iahpZ827Wh1DPO1nOPpio/fE4boskMmrsiWF0jaqSp5qzzWI/Ft7/9bVx77bW44YYbcPnll6Oqqgq//OUvp/o0giAIC47ZymHNsVgsuGx5LjZrX5u4RRc6UicLgiBMjMHhNCJ5x+z6kvnXsbYqFlxYHwQA7BE5+LRwVnmsOb///e9N/3e5XLjvvvtw3333neuhBUEQBEZPRDcum534ah3dkXxghGmgMPtInSwIgnB2nMob7lX6nXDZZyfcarpZ31CMF4704fVTg/jEpsWzXZx5xzl3rKeLjMcG2M3FM0mfmWSHM7xhsbGsOkbERjhINuXqpQZhqpRmf+LldE5vJ0nChhtJ/uPqJkmSMkRyZ0sZHcfeTTJvp4c5nZbQNqqPSZxhlok7EiRXyjKpMHc7zTqY02oFyTn4fUqsJtdKa2L0eEjuND5cTeVzhkjQwCV3AODqo3JkfHRf3R0k6eLunuCSvR7mwOoa/cPFZfgKk2Y72QCbjTmOZkc4JMfqSNrtP8jctYNUJn7/PSfZzBvTcaTK6Tg2JhGM1xWx9XT/uOQ9VU3PJOswi0OyNTQS6m6n6+Dyey6rV1J03Eze3T6TmZ8ffWFsjBnrWe5Yl3hz5++PpcbZUphPKJFhKIqK8IXVxjpvK32/EpXM0XlvO61fSds7W822ybyajrP9ffs6aT13kGYqiayT6p4M+014WXhXmpn88TrJOcjcpFl9w8NxAMAepu++va2f9nHTcRP5GSAAsEeoPjDVxeVURxXtp6wkmXImd2bZOqI1LANGC5Oas/ZK1tyEQJYpwy3Z0Zf5OTztVI8nWfslVUFZQOxRun4rq9+iS6h+K0o3GMvpIlZvJVkbAIB1jCwlA5upneIcYvUpK6vrrRbagYW+cTm3wkKmrNro7cXwGnIXd/WZZf+WMJOkp+hvicW0j2OQ7pm9h8L0QheWI5NWgNcgzGFa8lmGGkrmfnqtsdjQkHufXz8pFvbTwZRLwQVBEITpoTc/Yz2bMdYAUJYflOqPSsdaEARBmB+cmsfx1TprF+UmCttDcQynMuNsLUwW6VgLgiDMEXQpePmsz1jnOtYDMmMtCIIgzBMWQsc64LbDlzds7BoSE9yppmCl4PZICjabAs1Kff9kMdM5qSTTcLSTnMEkFx82OzRqViYvZi6P2WLSUwWbmbyYSa0d/ST/BnN+5BJsLidOVwep3MxJkzuDqiMkZwPn07GKDzBHSyYf5y7p/FpT7BrcpyKjbqOw2aVkDUm9MswhnLu68nMha76XXBqeCpDcK+Wna3IxybdFpf251M7Rx6T0w7Q9l8cpJ9poubLcWE7UkTyfy9sAs9ycu7gnS+jczgG6ViVGz0VjIQNOZu6QWkTOolw66OhlbrTLqEyqk7nlhs0yfL7/0Er2DnWz58scaE3S+Py9V0bI84X5T0+kUKTg+Rlr6VgvKBKLy2CzueBtofqJh0O5xvgmOV8/YixbSs3ZPWzdIWPZzeoJjYWCOTvofPF6+sbyTA32feRMnV1eT+fj9aSfvu32KH3/Vad11O0BINbAJNwsdMkWHt1fgIcMqS6WsaST7lPkvDJj2cWyeIQbqC4uaqH1KgslskdZGydmLqvqtLBlWu9g+3hOhIzlNJN8c8fz8GLauexVuvcq297bRtfDJfmm0KiEeTZM9dJxef1W/CZJ7JPMpdgeYo3+cnpveJ1uZefQmNQ8eh6FDwyX03Mre5W1F1VzvRw7v8ZYzjC3e+6YDraYKaX74T8cQUYVz4m5TstArj1XXzp/peAAUBVw4WhPFJ1DCSwp942/gzBhZMZaEARhDqBpmiEFryiaXSl4ab6BPDicQlZyYQqCIAjzAGPGeh46gnOqA7k2RKfMWE850rEWBEGYA0SSGSTy5kGFIgVXsxrCifQ4WwuCIAhCYRNPqUa41XyWggOsYx2Kj7OlMFkKVgpuG0rAZtWQqiSJgm/XSWM5cT5JvWKrK4xla4J0Os4B8wuTYZJla5wag64OkjQpLJA/4yUpiMLdLC0kt4pXsgZuBXMlZTIpdzeTJZfQNlx6BQBlu3rpuI0ke/I09xjLapDuB3cztzBFU9ZDsiyFXSd3nAabZeL7OntI1myJM9dUp9l+NFNK99IWpQNwR1AOl/Tbhuh+pEvoOHYmI+Qy/NQFS1lZaRvHEJUv7TeXj7toO9vJod2aZNK3JD3ryPkkG8uykAHfceY+z9xruft56Dx6Vs4QHZM7z9tGfLyS1SRlc/bTdtxVXHXSu5IspWdqzcvSVEXGxRYSPXnpaZHTBrdjdh3hHTYFRS4bIokM+qIpBD2O8XcS5jyOwVy9zMOq1DL6lvHvc7aYJL1aNbkq87AWALCGWP0bpW9hNkANW16POXvZ9hE222Kjukf1cGdqqp/cERZuxNzCXW0UPpVYRNcDAKW7uo3l+BK6DsVJ5zCFaDE5e7yersHJ5Nz+18gxPbWEwpu4/NvBsoSEmqjeKj5C6+Pl5t+dg8mwnX2s/rbTudNldCwrk61zabaXDNmRZjN3GS99d+wsjAusfWRhbtzD9WY5bTJA+weO0P6alda7mrvofItKjeVIPZNdv0XPBHF6BzQ/l7SyOraPPXfmDM+fFQC426i+H2aZP+wRFjaWZG0qFkJgHYpBy4oUfC6jO4L7XbZ5X6dV5ftDnWGZsZ5qpGUuCIIwB9Bl4OX+2Z2t1ikVAzNBEARhnqDnsG6Y5/HVAFAjM9bThnSsBUEQ5gC6cVm5rzA61uQMLrM0giAIwtxGn7Gun+cycCBnXgZIjPV0ULBScGgaoGmwMTlUZkm1sexqJ+lWJkCS6Gg9yXycb500HVJtqjOWs0zGlS5ijpZxkvwkS5j8ljlP2tpJmu0MskYuU3ZbmHTNzhqeWQfJi9J+s5xTczE3aiZ3y5STpC7NzmeL0jmsbNYozaROCot/jC+iUTiNndp7lNzMTUMtTGqcrDKP4HFH6oyPDlZ0OGQsZ5mUxtpFTpzxVVW0fpjua7qcyeaO0j0ObVpkLAfeIAlYtoi2t0VGzJoxuWHWT/dDs9F6LU3L7i76uNha+4zlVCOFGUQW0b0PHGdScyb/5k6zWe40mzCXT2HO8tZhJi1jEkt7mIUrtNM7pOWdZq3q6B/Eu+++G1/72tdM61auXIlDhw4BABKJBL74xS/ioYceQjKZxNatW/G9730PlZUkh29pacGtt96K559/Hj6fD7fccgu2b98Om61wPxnzHcO4bJZzWOuU5A3MxBl84ZDxOQCbE4ky+rZ72qmusvZTvawxp2iljb7/yVW1pmNqNpLvmrJYcLdnB313ElXsu8+8BmzM0M/KpNk8NMrCZOH2/uFRt+H1KgCoxVT38ewTGSY3t8XpuFYmZ+fbc7l4NkThSSk/OVGnPSxkKkbXX9RKx4zW0DU7h8yu1jxcidcxwzxMrZWuO1ZH1+Y7Qc8uzrZ3nwyxYzJ5fh890+jFDbQ9C5NK+8z1Bc/Uwh28Neaerrnp3NZBKquPZTXh4QSJNfQ+WRN0P1IB1p5i4VY2Jn3NjPCqGFxLjvPB/XQ/UuXUhkA53TPbIM32xVaVI5NOACcgzFEWinEZANQE81Jw6VhPOdJKFoR5yJo1a/Dss88a/+cd4jvuuAO/+c1v8MgjjyAQCOD222/H9ddfj5deegkAoKoqrrnmGlRVVeHll19GZ2cnbr75Ztjtdtx7770zfi1CDkMKXiAz1mW+fMqtqHSsBUEQhLnNqYH5n8NaR5+xHoqnMZzKwOOQ7uBUIXdSEOYhNpsNVVVVp60fGhrCj3/8Yzz44IO48sorAQAPPPAAVq1ahd27d+PSSy/F7373Oxw4cADPPvssKisrccEFF+Dv//7v8aUvfQl33303HI75bepRqPQYM9aF0bEukRhrQRAEYZ7Qko+xri+Z/zHWfpcdPqcN0WQGnUMJLJVc1lOGxFgLwjzkyJEjqKmpwZIlS3DTTTehpaUFALBnzx6k02ls2bLF2LapqQn19fXYtWsXAGDXrl1Yu3atSRq+detWhMNh7N+/f8xzJpNJhMNh0z9h6qAc1oXVsRYpuCAIgjCXyahZtOWl/QthxhqgWesukYNPKQU7Y50u90KzuWBh6Yd4zGpGoZgXla0PHAjR9o0UuwTAlCYra6dlK4u74qk5HEMsxovF9GhBipOOl7E4nkHaPraM4qI9rRRzpLpoLMN3oN9cvCQ1UGNraLbR1UNxPDwVlK2fpcZKUAyRY5iWU7VBKh9LOZEspcb5cCOV1fc25dnIstReWad5DMZ9gGKg7d2UJiz0J+voWKeo3JZSOoctMkZMMUuPplZQrJNzgLYfXllmLKdYbLe7zxwX5+ile8PTa2TcLJaLxchlHawcHhbLf5yuzVVMzyRST/F8gcMUi6X6aDaXx+oNL6dyA4BtmN4zHuflOM5iyBsoDQtPlaanIstmRk+5tHHjRvz0pz/FypUr0dnZia997Wt497vfjXfeeQddXV1wOBwIBoOmfSorK9HVlUtz0tXVZepU63/X/zYW27dvPy22W5g6DPOyAulYl/rEvGyhYU2kYbVa4RqgdakSFtvMBllSFSwW1UfbONk3FQDUcvrWq27ma8LTwKSpbnUM0jb2VqpDs8VsxoX5g/A43xSru/W0hQCQ8dC3dGQazDQLvXAOUDksLFOTlTVMeTy47wD5dXCvj+H3rKLt2WfcwVJXhlZS475kP6WBKt5Ly1mXWT2UqGYx0CxEw909+hyKyuo9HvPM04VG1lDKK3uYrh+LqY7wHqV4a97OssbNMeCubpaWzHybDVKLgnQ+FgdvSdOxhldQfeo5ETKWVZZS1XuY3g3NTfeJe9DYRoSx+I+zthZrK7hO0TmiTZRyLeOa3bSHwtTROZRAJqvBYVNQVSA+JtNNdcCFoz1RibOeYgq2Yy0Iwtnx/ve/31het24dNm7ciIaGBjz88MNwu91n2PPcuPPOO7Ft2zbj/+FwGHV1dWfYQ5gMhhS8qDAq/VLdvExirAVBEIQ5jG5cVlfshsIm0uYz1ZJya1oQKbggzHOCwSBWrFiBo0ePoqqqCqlUCqFQyLRNd3e3EZNdVVWF7u7u0/6u/20snE4n/H6/6Z8wNSQzKkJ593iRgguCIAjC1HFqYOHksNapyis8OsMyYz2VFOyMtTWWhtWqIM1SaXFZLpd62VWSCMXOo4a/u53kwABgj9LLk/WyxilLHTVcTz8qB5M9qSwdROQCkkZ5uknuG1pGcqOSg+xcTBpmkgCXkywNAGx9JPHiMrNII5XJ30xpOrLcHdhDy5qdp+yg8ilMsqkymZOdparKVAapDEyq5QiZpdbpKtrOxuRo/qPsGli6Dy7xiy2iZ8ol3NGl1BFz9VOZHCzlGpeZ2YdYOqusWVdmYc+Up/Ti6TG4vDpRwWJq2GBlhl2nt5nJDs8jKZrCUqtFG0mO6N8bMpadmrl8XHYHVvbsIO1jLWMSSf6s9e3HkNKNJBqN4tixY/jEJz6B9evXw263Y8eOHbjhhhsAAM3NzWhpacGmTZsAAJs2bcI//uM/oqenBxUVuXRjzzzzDPx+P1avXj2xkwpTSl9+VthutSDIUgPNJroUfDCWgqZpsFgWxij/QkaJpaBYLUgH6HvkOcQG4Vg4U3Jl0FjmcmxP2iwPVsL0TY4zKTM0WrayekwPhQHMKb0yTAacLKX1vmaSKQ+yujvYSiE8Dtae4HUVANgj9F7z6+B1uRIlyXJ8GYXw2LxUN/IUZWkvnS9wmOrM6GLW/ohQ/akM0jbpKqoXUsVmKTgP5RpmaS1NYUm1TC7dzlJPsTAmB0uPZq1gUn+WPkxjv3cuf4/XUB2osFA+wFznWnvIgyPWRPWpu43abakyuh+qm+6Zmz27VCW1o2xD1FawpOia1SC9S+ki1uwd8cni7QhbP2srMCm5k7dN2uk+pauDUDIyyDhXeflorn3XVFU0zpbzhxqZsZ4WZMZaEOYZf/3Xf42dO3fi5MmTePnll/GhD30IVqsVH/vYxxAIBPCpT30K27Ztw/PPP489e/bgk5/8JDZt2oRLL70UAHD11Vdj9erV+MQnPoG33noLTz/9NL785S/jtttug9NZGLOlC42e/Ihyuc9ZMB1YfcY6k9UQjmfG2VoQBGFhcvfdd8NisZj+NTU1GX9PJBK47bbbUFpaCp/PhxtuuOE01VhLSwuuueYaeDweVFRU4G/+5m+Qych3dyoYTmWwIz9A+P7zqsfZev6gm5dJjPXUUrAz1oIgnB1tbW342Mc+hv7+fpSXl+Oyyy7D7t27UV6em0n59re/DUVRcMMNNyCZTGLr1q343ve+Z+xvtVrxxBNP4NZbb8WmTZvg9Xpxyy234J577pmtS1rwGDmsC8hUxWmzGuk6+mNJBApkJl0QBKHQWLNmDZ599lnj/zYbNb/vuOMO/OY3v8EjjzyCQCCA22+/Hddffz1eeuklAICqqrjmmmtQVVWFl19+GZ2dnbj55ptht9tx7733zvi1zDeeO9SDRDqL+hIPzqtdOCFsNcG8FFw61lPKpDrWd99992muvytXrsShQ4cA5EbdvvjFL+Khhx4yNdhHOgxPhGi9Fza7C/YYkx45qOHGHTYT5bTsOcGk0h6zTEp1kxwoy9wcVQdN3BftaTeW08yVOcu2cfeSxMh1kuTBJWqxsawkaSQxtJKkUXbmRGqLmWVSGTdJvFxtJHVyM6m7yoyLuCROYbLrjJfuE3fdTiwlWZWvhTl2J5nMjkmOI/V0XwMH6b4CI1yqmaw+WUrlU9Ikq8p4aXtPJ3cnp2fE5d/WMJNUsWvgsvjAW+S4qtnNr3KWyflU5v6dKWGSeRsd13M8ZCxHV9JzdLYwqVcNPR+NTRpaBknS5j9If8hU0vZKwiylt0bYPaii90N7F7nFctkdl9XrMnJtDMHJQw89NOp6HZfLhfvuuw/33XffmNs0NDTgySefPONxhNFJZbL485++hnWLAvjbP2oaf4cJoBuXlfsKSzFQ6nPkO9YpLCkff3thapnJOhmgbB3cRduUPYKFTHlbSR49XEN1SazBnC/VGWKy8hP0LU2X8/qajuvooLoovoyF5KToG1n0OtXjyeV0rUUsU0VoTdBY9rUxCbFqrpejLHSp+DXKisAl2cMrK4xlN6u7U+VUX1mTVB96OlimEFZf+07S+vAyuk/xpSRhd/Yn2PKIECMfkzz7qH5whFj7gGX48LJ6KFHFYkut9HxdXfQcTedibYDoEuqM8GwqQ43mNpi/lWUEqaR9vLtP0EZlQTr3cbqXvP2XriC5bpbV4zwMjm+fKqZ3zB5loWFRc70cq6P752EqHJUNGjpPUEiiWsY6YRrOGJ5ls9lG9SgZGhrCj3/8Yzz44IO48sorAQAPPPAAVq1ahd27d+PSSy/F7373Oxw4cADPPvssKisrccEFF+Dv//7v8aUvfQl33303HA7HaccVJs6T+3IhFH+8trpgFGEzgT5jPRRPYziVgcchc61TwaSl4GvWrEFnZ6fx78UXXzT+dscdd+Dxxx/HI488gp07d6KjowPXX3/9lBZYEAShkDnYGcaLR/vwwEsnoWkTDIQfB8MR3F9YHWvDwEycwWcNqZMFofA5cuQIampqsGTJEtx0001oaWkBAOzZswfpdBpbtmwxtm1qakJ9fT127doFANi1axfWrl1rGhDbunUrwuEw9u/fP+Y5k8kkwuGw6Z9gJpbM4LlDufSx165bODJwAPC77PA5c51pmbWeOiY9PHEuo26CIAjznf68SWA8rSKSzMDvOneJdK+RaquwOtalXj2XtXSsZwupkwWhsNm4cSN++tOfYuXKlejs7MTXvvY1vPvd78Y777yDrq4uOBwOBINB0z6VlZXo6sopJLq6uk5Tmej/17cZje3bt5+maBHM6DLwhlIP1tQsHBm4TlU+l3XXUAJLy33j7yCMy6Q71vqom8vlwqZNm7B9+3bU19ePO+o2ViWeTCaRTJIcSR9RKzoShs2aNMmNNOZ8rQwzJ2svSZi4BDg9YnZHY/PzrpYQrWeSIS4b466XznYmP1scpGUmRXN2kXOnMkSSLh9z23S20XktGbM7aqyJSc/ZPtZBkmLZuml/7vppj5CkiZcjEyQJXhFz106WkbyNi4jSRXQvvO20fXyR+QensTx/Jsdwds9UNy373iRpXmR9LW1uvgVUvgoqt5VJ/DwdNKoWW1FCZRg0N+ytCZJxWdj+rhBza2fvCn/PbFEqVGQtPRPVTtcTOBhiJ6N9M4ExYmAVsziEv1sZN5NVOth9ZVJKhTnaZ4pzcrWRkkWhMOCzt91DiSnqWOfNywqsY11idKyT42wpTBdTXScDY9fLjpZ+2BQnNKb7527SGS81KXhmBlcvHSsVNMtWLRnajjs5c2l3sozeex7GZU3Qt9rOvu28HnL0MNk1+/2UvNhmLKfrSGptHTbLg70d9O0eXkHXHa2hay17nUKGIiuCxrLvCLUbFFY38PArzcfaH2VU77n6uBM6lcE6QPV7ZL25s+Viknn/WyRZHl5G1+dro/uksnA59/EBYznNZNo85Iw7c7s6qH7i18l1kKUj7mWylO5/opbuR1GK2jJctu3qZG2ZYro39i6SiIO5OKdKWP3LllN+ugZniLUN4ubyubtH/45xt3GeOYW3GzJeGzKZ0Rs073//+43ldevWYePGjWhoaMDDDz8Mt9s96j5TwZ133olt27YZ/w+Hw6irq5u2881FfvP2wpSB61TnO9Yd4gw+ZUxKCq6Puj311FP4/ve/jxMnTuDd7343IpHIhEbdRmP79u0IBALGP/nRC8LCRtM0/L9dJ7G3NTTbRTkr+Oxt1xTlhzSk4EVjDNzMEiV5fwXJZT07TEedDEi9LAjTSTAYxIoVK3D06FFUVVUhlUohFAqZtunu7jaUKFVVVae5hOv/H02touN0OuH3+03/BCKWzOD55pwM/Jq1C0sGrlOdH/DrEin4lDGpjvX73/9+3HjjjVi3bh22bt2KJ598EqFQCA8//PBZF+DOO+/E0NCQ8a+1tfWsjyUIwtznjZZBfOXR/fjiw3tnuyhnhaljPUWVleEKXmAz1mU+ibGeTaajTgakXhaE6SQajeLYsWOorq7G+vXrYbfbsWPHDuPvzc3NaGlpwaZNmwAAmzZtwr59+9DT02Ns88wzz8Dv92P16tUzXv75wqsnB5DMZFFX4l6QMnAAqArkFBMd0rGeMs7JAo6Pur3vfe8zRt34CDkfdRsNp9M5am7cZKUHqs0FZy/JjQbXMtfsfpLcOJi0J1VMMzquDiYXApAuIcdHMFOhZA3JnLn8TPXQuEOWzRR5munjlvUzF85SWlar6ZiubrqGdDX9eJWkWTakMElcksmhPGzWK3IBjao5mQTbfpLKFNmwyFh2d9O+tj66H2k/ScBMUi8XXbONyeyUpFl2nCgj+Zqrm+6/k0n0s0wCq1aTbNt3JGQsa8yFUPVSmexhLi+nRS5V567ZtpD5ozDEHF+LTpAUMMGeC3cEtXCXcya7y9Jq+FpJKqOE6ZlGNpC0vWj3KbqeWgoTSFSxdw8ANHqfuNTdt49GpdUSJsdz0b1RUrnnoqhj6OjnOMd7c8/reF8M8ZQKN3s/5wJ89rZ7Cmass1mtYGOsSxZ4jLWmaQUlH5yKOhkYu17WYnFoigpHBzNBYnWpldWTSoTefR7G5ek118vZAKtDWf3IJeIa+wQ4mAw4Xk9tAh5wkS2m73yskY6ZYfVbUZYdXznDM2TTD+4TJPl29tG1qsyt3/8qDUIkVlJ9zesVHv7jPkJ1d+w8Ht5F33cLy5KR9dF5/YdHmFGxZxFdQ/WP59ToLuRgZdK8rE5iEum0n7Z3t9NxlH469/Aauk7e7lISI/Isa3SfHGF2fczjkWcT4ZldHK107zUreyisaWIfSrFtWNaPw8zJu5Sk4+qI0C17O8nhk410/xzdJElPe+l9tbEBRU2xQBtDCv7Xf/3X+MAHPoCGhgZ0dHTgrrvugtVqxcc+9jEEAgF86lOfwrZt21BSUgK/34+/+qu/wqZNm4xwjauvvhqrV6/GJz7xCXzjG99AV1cXvvzlL+O2224b9XcqTIy+fL3aWOYrqO/4TFJjzFiLFHyqmLQrOGeyo26CIAjj0Z6P9dE04FhvdJytC4+ploKH4mlk8p2AsgJLt2W4gi/AjvVv3u7Ehn94Fi8f7Rt/4xlC6mRBKDza2trwsY99DCtXrsRHPvIRlJaWYvfu3Sgvz8Xsf/vb38a1116LG264AZdffjmqqqrwy1/+0tjfarXiiSeegNVqxaZNm/Dxj38cN998M+65557ZuqR5wVB+AKnYc+4+KHOVRXnPnjdbQ+iPilfKVDCpGetzHXUTBEEYj/ZBGjk93B3BebWBM2xdePDKqWvo3CuqnvzMX7HHDoftnMZCp5zSfIz1VJqX7W0NIZFWcemS0vE3nkUef6sD/bEUXjjah3cxE8uZROpkQSh8HnrooTP+3eVy4b777sN999035jYNDQ148sknp7poC5rBvMIy6F64HetLGkvQVFWEQ10R/N9fvYPvf/yiBTt7P1VMqmOtj7r19/ejvLwcl1122Wmjboqi4IYbbkAymcTWrVvxve9976wKprqssNitCK2mRrUtQRIh+zCTGKmj54rlMiKAJLQAkGgoNpa5eynfxp4hjZG1i2RIannQWI7XkiO56qKX0f82zWJkSpmjNpMt2bqZkyYAaz9zmCwjuZLuAg0AjjBddzLIPgZLyB3UmmRSKtYQT9VQudNFzD1010lj2V5Jkm3LMDWWrQGzlJlL9LmEO+um49r6qYMUXc4kexHa3nWK7qudOanHmipofZSu2RZjjp7ssYfWBk3l83VQ2VU2Gsnl3442kn1pMSqr3UNSeljoepQ0PbxUAzX6PW0sXOGKRmPZ206zlc5e88ylNUT7ZMrpWSeW0XVzx1vuAJ7IO7pn0oXVyZoq2pk7ZXN35AxbToyOUBz3PnkQn9zciPXsdz9dTLUUvCdcmMZlAFDqIyn4VMiiM2oWN//4FcRSKp7/4ntQX+oZf6dZ4mheTRFJpMfZcvqYyToZAKKbGmGzu5BmYVKBg/QbVVkDNV5NdaO7i7538WVjD5jwsBgbc862xmk9l0K72+jcySpWz7K6gYce8bqUy4lV5jSu2cy/M0c77a+yujxaz47FPsWB4aCxPFY2EX6+0EYKJfK10H2ypOn7rzLndV7u4RpzWbnjdSLIMl0Mk/O0o5e+r6lStj8LM+Hu7jzjBs9mEV9JbQ4Hyzhi6aZ6NX5hg6l87hb2vFgIXtZO18Qzp2SZPD1VS99u+wEKuVLYM1GYNFvpY222ahr4ShexLC0tVFYA0Lx0n5zHST6eHaAyRS9YYyx7uuke8zBCYW4QyrvWB0b0FRYSDpuCf7nxfFx330t4an8XHnurAx+8oHb8HYUxmVTHeipG3QRBEM4E71gf6T53KfijezvwxNudiCQy+NmfX3LOxxuPqZaC68eo8BeWDBwgKXha1RBOZBA4x5H/3mgS4Xxc5qN72/FXVy0/5zJOB2k1i5N9uYHAyMg40hlE6mRBEISzQ+9YL2QpOACcVxvA565ajm89cxhf+fU7uHRJKSr9hTeQP1eYn1NegiDMSbJZDZ3MiO7wFMxY67PGb5wahJodXd0yGuFEGrf85FU8/NrEHZETaRXDTPXSF00ifY75xo/k78GSMu84W848LrsV3ry53FQYmHEX9V/tbYemTfx5zSSn+mNG3Hs4Pnsz1oIgCMLZEYrnpeALvGMNALe+ZynWLQognMjg288cnvT+e04NIjS88LxWRuOcXMGnE4uqwaJoKHmBGrVqFUmBUiXcwZJJvMuYzLjPLEu0d5Esy8riIFOVJCWysIa3/QQ5NA+vI3mwbZjO5z1BxxxeTO6j6QqS99q7yT0zvoSk1rYikh0BZlfxtI8ejaeVZu1SAWpcezqYS3WUzYxptI0tQteZLqbzFT1/yFiOvnulsaw66Z4VHaZrS5aZy8pdWrmLp3t/B5WVydO9J9k1MPkZl0FbWcPc1UOSOGtHP5WvimSEGpePhcxunFbmospldGBStsTScmM5XTS687SVhR9Y++g5Wtiz672E3ksr+644TlE4QGxEjkRvO12Txt4Va5xmv7hTbTpA1+DuzM2UZdT5ZzTRG00ipWZhseTMy9oG44glM/A6bchmNXSFE6gOuCYlOe7N/9YjyQwOdoYnHLO942A3dh7uxa5j/di4pAQNpeN3bHUZuMOqIKtpyOQdvWuC7nH2HJuDnbmO9arqwkwHUuJzIDYQx0AsicZz7PzzjvXx3hj2tQ9h3aLgOZZw6jnaQ9+z2Zyxnml8hwZgszqRqqHfEP8O8wwT+ncKAJTjVC84HPWmY/IQG2RZyEsF1YeeU1QXhVfR99b/XJuxbHdRnZll2SayXlJ62DtDtJ5l9OAZM7Ijwp40J317ediYu5c+9qbvNnOjjq6m+soxRNvYmWTZFmcydPZdS7E6lzuKu1hYkavfPKiTCtB1e7tYto4uVv+y36jCroefgz8TjYWTZVkHhMu/uRt5ZlmNscxdugFAc9K1pvwsG4mTZSPpo7JaWOYLCwvNyzTVs21ovTJM9yazmIXHDdC7aGfXo/nM32UeNqawd8gSpDZiya5OugYuT++PwTIP6+T5jD5jHVzAUnAdu1XB32xdiU/8+FXsONQzqdCuN1oGccP3X8ZVTRX48f+6eJpLWvjIjLUgCAVDW964rCbgNnIk652Y7+88hnd9/Tnc/uCbiCYn3pnpZYNLr54YOMOWI8oykCtLSs3i3icPTmifgXyDucTrMFJjnasc/FBXbkCnqUA71nX5uNVnD/aMs+X4jLxXv3qz/ZyPOR0s1I61IAjCfMHoWC9g8zLOJY0lcNut6I0kjQH9ibA/7yVxuOf0fQpVdTadSMdaEISCQY+vrg26saIyN5Pf3B2Bpml46LUWAMBv9nXiuvteMnVudPa2hgzptE4f61i/dnLiHevWQVJNPL2/Gy8fGz+tUl/eHbvE60BlPj9kzzl0rHsiCfRFU1AswMrKovF3mAU+uTln2PfTl04aDuZniz5jvaQ8N6v2+FsdyJyjlH46MHesRQouCIIw19Cly8UyYw0AcNqs2LQ0p7L5w5HecbYmWgZybaXeSNLUkf7Fay248O+fwR5mUrwQKFgpeNpnhWa3IrOIpFSRxSTRCrwTMpZTFUz6zNxDlbRZHjy8go5li9HfbFzSxIcaXCQhc7eQFC26kkl/4zTS5eyn45hkvFXc2ZzOa3IxhdmxGsyVM1VCciVXJzX2uQN3lrmd2gdom+EGOrcjRLKs4c0rjGXuHlr8Dsmdh+tphswRMTceEyX0IVKZp5K9jtw3rUzuZmESP+52bWPSz0QtdRxUJkvzJLk7Ni0PN9BzL3qNJIEAkFxRRcvMPd3Vy5zOWTm4lC9dxLbvIglZlsm/sy7axn+SSdg7qFOXrqd7wd1rASB6IYUW8PfGytIWxRfR/eD7688lkx5dvj6X0VNt1Ra7EXDb8fKxfhzpjmBf+xBaB+Jw263wu2042hPFdfe9hN/dcbkhsx4aTuMj9++C323Da/93iyFjGjljPVGJkz57Xht0oz0Uxz2PH8BvPvduWJWx99VnrEt9Dvicud8nlzdPFn3UeHGZF25HYT7vLasqcH5dEG+1hvC954/h7j9ZM/5OY9CZv1cfXr8IP3rhBPqiKbx4tA/vWVkxzp4zy9HehTljHV8chM3mMoX/8OwMtmFWT7DxEC7dzTrN73EqyMJc2HeOZ/7QFFYfdNDvKb1uMZWDyZcVpmhRWaNZcVNlxWXr1jSTAI+ImeffYV4fOA9TOE9sHbnoutvpGnzHqT5NVFN9n2YyaFuU6iEuI9dstOxm9b4pC4rL3IRz9bAQN1ZHa04m4R6gEDJLcvRBoUgThazxOlOZgFJIY59He2/Y9DeVZTvxHWOSb9YYT7FQHUcX3UsbO1Z0DYVxOUPsGthxuGyfu4vzbVKlZim46wApZNJMSs7l8Olaeo6merkxiEw6ATRDmASJtIr/3tOG9zZVoPYcQqYmSyqTRSzvhyIx1sQVK8rx3KEe7GzuxWevWDqhffSOdSKdRSSZgT/fPv7d/m6EhtP47b7OGcnIUijIjLUgCAVDez4NWW3QjeV574PD3VH85u1cXNtVqyrwxF+9G0vKvYgmM3jpKM0itw4OI6Vm0RdNGUZa8ZSKSL4xaFMs6I+lcLwvhomgz1jf9YHV8LtsONQVwQ/+cOyM++jnLfE6DFfNrvDZx90d6sw1Jgs1vhoALBYL/ubqnE/Dg6+0mFzdJ4suBV9U7MG163K+BL8uMDl4NqvhWA+9Q9FUBtlJmOIJgiAIOR57qwNf/vU7uPc3Ewu3mgwn+mJ4dAwTTN24zGKB0REUgMtX5AatXj81gNgEQ+5a2WAdn8jQ6/P9HeHT9pnPSMdaEISCgc9Y69Lnw90RPJHvWF+7rhrlRU6sr8+NfvawjzjPGa3PfPbljcucNsUYMZ1InHVGzaIj706+dlEAf70113H8xlPN+N7vj465n25eVup1oiovBZ9MLuuXj/WZBgsO6h3rqsKUgetsXlaKTUtKkVKz+O6zR876OPrsfnXAZeTSfPZgT0HJwdtDccTTKmx55YKmwRi8EQRBECaOHlbzTsfQOFtOnr/977fw+Yf24vnm0/0/jBzWbjuUM6jQFhqLSz2oL/EgrWrYdax/3O01TUMrU8n2hE9vk+3vGFpQsdYFKwXPuC3QHBYoTGZXdJIeXrqMpM8ZL8mqHGGSBaV95lEoxwBJdpOlo+eEtbNUP4klJOXlrpXeozT6kike3bnT0UszGpqduV8ykwRtxG95LEfVVDHJmLirpmblbqxsjESjMnHXT46SpIaqp4fuWSZI94U7pKe95lel6BDrnPTQjy95fiOdg5eVfbi48yl3b3UM0g8yyZzDY8tots7ZR8/Q00r3KLmcpN+AWVbPHdYVlgqJO4DauEtrjMpniTGX0XIqR6qYZHbcJV5luf9sLEZXc5jvn3OAyetYyAJ3bLXH6N2P1zGZfN65XZ2HlQGPsV6e71jrnWSPw2pIgo3ZYCaz7mYf9I5QHOfVBoyOd3mRExsbS/DKiQG8dmIAH7vE7Ew8kq5wAmpWg91qQWWRC5+4tAG9kST+9bmj+MZTzYgmMvibrStPk5QP5KX8pT4HqkYp45lIpFX8+U9fQ1rV8Ie/fS9qg+6CdwTXsVgs+OutK3HD91/Gf7/Rhv99xRIsKfeNvyND0zRjhLvK70JN0A2/y4ZwIoP9HWGcXxcEALzdFsI/PHEQN7+rAdeuqznDEacHXQa+tNyHE30xpNQsIon0Oefwngu426OwWdNIl1D9myyhOoNLpXm9p7H6yXnS3FhTV5Cs18Li1RUWZmWq99ix7KwxrhaP7khvG6TZlCTLAOJsCxnL2VMUSqRevMq8f4LXGcwhPEjfZE8LyxgRYg7jpex3yxqWnlNUN/A6N8PqWXcbk0pzR2xWx1hG1O9csuxppgG6xOISjM7o0lv/7lPGcraCJJy8HksX0b3I2uk76DlMsZmZSnMGhnAjvTdFLfRd5LJ35xHKxqJWU7n5+Yr2kIol1UhhIjxcS2FhVfxdTLLsK+6jI+JIrUyiH6JnpAbouJpC7yUPl/O0Redlpo7ppqU/d59bBoYxnMrA45iaboma1fB2W+77sPv4AK5sqjT9nXJYS3w1x2Kx4PIVZfj57hbsPNyLLavN9+3v/udtnOiL4f99aiMcNgWh4bRpYFn3WUllcupBAAgnMmgbjKOuxJxxYb4iM9aCIBQEmqadFmNd6adG55ZVlXDlG0j6ej4bPNqMdS/rWF/SmPNYeGUCM9a6tKk26IaiWGCxWPDFq1fi797fBAD43u+PGbPonNGk4BOdse6NJJFIZ6FmNfz6zXYkMyqO5Ttxhd6xBoD1DcW4qqkCalbDt84iD+bgcBqpfAei0u+CVbEYz2z3ceqM/fCFE3j15ABuf/BN/H/PHpnxkfBj+RmWZRU+FOVjXBdSnLUgCMJUoYdcaRpGNSQ9W072x5DM1yejmWcN5o3LFsKA6GS5YkVusGqkgVkyo+IXr7filRMD2Jd3Am9hs9UAtbl6o+ZBpv3ToEgoVKRjLQhCQTAUTxtmIrqJyQrmhH3NOsoFbnRamRScy8I78jPf+se93OfEhfVBWBUL2kPxceOA2/KV/cgR1s9esRR/cVlOlfH4Wx2n7dcX5R1rSrc1kc4fL///7GnD0Z4oMlkNAbcd1QHXGfYsHHTJ/BNvd45ZkQ7F06Pej86h3DMp8zngyM+8XbokN2Old6wzahY7mazv288exraH3zJJxTVNw8d/9Ar+9N93TUvss974W1rhgz/fKJOOtSAIwuTQNM2YsQaAQ12RM2w9OQ6xdFH72oeQzJjNjIeMGWvpWI9k09JS2BQLTvUP4yTzpGkfjBvCmwP5MDWePQWgjvVIpd477QsnzrpgpeC+thRsNsXkkpkoo8Yld3TWmMmoaqexgmSJ+QdjY9JaD5NZcfkUl2NzZ2oLC/FThmjf8IUkkyrdTRKmrJ+kQ1w+Zu+jfe2D5nGNNJeVMzMFfq0c2xB1DpQovcRqCcndXKeYNM/JJdFMZlxNEjouUVaZ/M4yooGaCbIOB3Mk55J5B5NqKxFajq0m2bZD43Jz5rDey2RYPnb/uqixni2i83K5N2B2Rnf10jukMKkhf9Zces7JLCUneS5nB1t0niTJXWwNyWY8A0yqXmOOkXWz1E0Dl1KH0RGhF82SZZLHKG+45681XThxp1OB7sJd5nMYM9MrKovwwpE++Jw2XMEko3rHmqey4ssdo8xYe502nFcbwFutIew+1o8b1pMz+0ha82VZVHy6VPK6C2vxoxdP4IUjfUikVaOsAM1Yl3odRoz1cN5AbTyDFG76cbwvhv96NZderKmqaEIu5oXAqmo//uT8Gjz2Vgf+5elmPPDJS0x//93+Lnzm/+3B//njJnzmcrPjqD6zX8UGES5dkvv9vX5yEBk1iz2nBhFOZFDssWPb1Stx92P78as323HVqgpDFt4fyzmJA7lKv6F0dInw2XJ01BnrhZFyS7NboVmtpiF5VzvVackaJrV+icyIrKsoRAgjGrjuVtbgstFvKbSSjlV8kBrJjlaafYquIRkwz67Aw3y0IJMZs8a25may7pVUPtVldi3n7QYrcwzPsPdUZRk6nCnaZriBlCauXtbQZG0OBzPCMzlWM9m6bQwDRF7fAmZX8fRKCmXzHCGVDnfIznJXcVa/JVaRy7nrIJNdL6W628qydTiZO7YapHKnAmaZrWuQhT0FRv8e2j0utg3t72DZW3i2GC6T5/fbysLd3PtpENTmY87wQXO4imWYnaOEvhuxGtrHOUjvg4t1FtQiF7IZmauaDENxs4z48BR2rJu76NmkMlns7wjjonpqr+sz1kGRgp+Gz2nDhsXF2H18AC8c7cPifIgin50+kDckG2vGeqRST2asBUEQZhgeX63zrvzAxocurDV1YI2OdSQJNT/o081yKHfqM9asYw3A6Jz/bNfJM84i6zPWi4pPjwlaU+NHld+FeFrFruPmeFEuBfc4bEbHq3sCcdYjpVP/9WorgLkhA+dse98KWBULnm/uPS1vuG4i84Odx0+bQdDl+1UshnRVtR9FLhsiyQwOdIbxXH7/96yswCcubcANF+U6AMeZpwU3T5lKaSGQm2E5onesy0UKLgiCMJLfvN2Jj//oFZOp1WiM7JQ1d09dx/rgiE76GyPk4KH8IJmk2hodfRCCD1C0Mr8KY8Z6QFf35dptPSM61rrabiE5g0vHWhCEgoDHV+tctaoSz9xxOb5y7WrTtmU+ByyWnEFJf0z/kFOHarQYawC4ZVMDXHYFb7cN4Q9H+jAWbQNjz1hbLBZctSo3U7bjIKlUkhkV0fzoe2l+VsQwMJtAnLVe1iX50WF9wGD1HOtYLy7z4iMb6gAA3/ydOalrc76x0x9L4al3ukx/06VjfMbaqliwsZHk4M8dzHWs39uUu/9Vo8Sx8wGKYyzftKZpePXEAJ56pwtPvdOFF470Ij1Bt/F9bUM40RdDXzSFoXgaFguwpNyLonx+4PACmbEWBEEYj397/ihePNqHrz916Izb6R1rd37Q/DDrWEeTGbzTfvaznIfyHcJ3L88pN95sCZn+HtJnrN0yYz0ajfl2yAkmBW9jAyGHOsPIqFnjGeqZWgwpeL5Ofs/KclgsuQ53T2T8dtB8oGCl4M7WQdisTkBhctgikuPY2ciJs4tmnixMhmWPmiWA3EFTGaQfcGIZyclczdTYsw7S+TQPLSeX0vaB4yxWk82AWZjTc7KURsTiFeRy6Ttpnk3hEjTHUAqjkShnrtNMxsXH3Cxs9iTNnHkVJpmysrgIN/NgyjCzKC5Bt46YkTFdXxl1PjynmFSbSWxiDSQhc7czeTqTrnH5dpo5d1pj9Ey5zD3L5HfWlLmBzPdPsJAA5yAtK6xRzSXwGS+X4dN1Z9mMKXdvVYtJ5m3JMGk76xCpbrO8MOun8nk76Vlb2DtkDdN6Ltlzt+be3fnmQDrajDUAwx2cY7MqKPM50RtJoiecRInHYaTWAsjVm8dYA7kO700bG/DjF0/gX3ccweXLy0aVWY8VY62zZVUl/vOVFuw42IO//6AGi8VizFbbrRb488+rKuDCkZ7ohJzB9Qrp2vNr8PBrrUbFNNdmrAHgtvcuxX+92oJXTgwgmszA57TlZnu76Zv3n6+0GCm1AJ5qy/z8L11SimcP9uCXb7TjSE8UVsWCK5bnlAflTLmgw0MC+Iz1joM9+Iv/eN107C9fswp/8e4lY16Hpmn47o6j+PazOTM2vSNfX+KBy25dcDPWml2BZrXCyrIoJGrpm8xl3cOX02CYt5lMcNTKoOmYKeaKzaW1/hOsbmV19/BykjjzjAw840OWhTHxDB2WGB0z1UihJc4WUlYopebfvI2F9Gh21mRighfnO6107jrWnuim8w0vouM6huh9cYZ4uBYLe2LhUBaVqTtYVWcfobqxMHm2SeY9EKL1pRQCw+tfx0l6RnYmyVf76N7YyoPGMncnH7qA7qW/mdoASsZcPtXBZPmszjWFWbFsJ6aQP7aNrZu5wZdS/eBuY+FnCXpHuXM4bweqXnOnysbaNdyp3NWfGXW9JUrPN1vmQ9ZasE3qGSOSSBuznL95uxN/+Z4hrKkJjLqtbhK6eVkZnj3Yje5wEqHhFIIeB+74xV48c6AbD//vTbikcSxX+9GJJjPGsW/aWI8XjvSdZmCmu4LLjPXo6Fk9TrDvJ1cYJDNZnOyPGfd5/eIS/Hpvh9F51lV6i0u9WFLmxbHeGPZ3hFGxcnJ+MT3hBF440ofrLqyFdY5kwpEZa0EQCgJjxjp4+izxaPDZyv5YCpqWm+G0KpZcpzqSRN+IGWsA+MzlS+CwKXj91CB2Hz/dITyVyaIz3zkbbcYayJl7uO1WdA4lDIlTf76zUexxGJ31ylE6fmOhd6yr/C58KC9xVizA8krfmXYrSBYVe1AdcEHTKBd351ACkWTGeEavnhgwzVDoAwmVfnPFq8dZ68Y26xuKEcg3hirzz7VnDBO7Y6xRoMv2qwMuNOQ7TyNnMTjZrIavPX7A6FTbFItRRt1UTzcvkxlrQRAEYG9rCNyS59tnyBChd9RWVxcZ9f7h7ih6IglDDfbKiHCriaAroyr9Tly+ohzW/Le7g5mWUoy1dKxHQ1fOdQwlEM8PWupGZfpcxNttQ8aEiD5jrWf30BWElX4XzqvNDawcOIMcXNM0vHikzzRBAgBfefQdfPGRt/Czl09OzYXNANKxFgShIDBmrEeJax4NSrmVNKTA5T6n0eFuD8VPk4Ln9nPho3mp8r8+d+S043YO5ZwvXXbFmOkeictuNSRmO/Ly5H4WX60zmVzWxux6kRMf3VAHr8OKdy0tM8WWzyX0WQpdzqd3opeUebElL6X/T5Yvt9OYsTZ3rPU4a52rmmj2qWIUEztuAne0J2rE0uvpQb549Urc/SdrjL+PhqZp+NL/vI2f5ivzuz+wGnu+8j78f396Af58cyP++uqc+/lCm7EWBEE4E/rM8IX1QSgW4NmDPXij5fR0VwCPz/WgqSo3WNncFcZv93UZnfNDZxF3rcvAm6r88DhsWFVdZCobwGesRQo+GsVehzHooMvBdQf3ixtyCoIdB3ugZjU4rApWVhXBnlfA9EWpTVbpd2FNTU51dyZp/893n8LHf/wKtj38lrEurWbxYj5k75dvtk3l5U0rhatbcToAqwNJNlvDZbkpJtdysBiAVC1JTkY6RXNZVqqOXCVdRyl9S7qBJE1cmp1l8h8uP4tXUMPbUkb7+vaTrIpLmBQuQxrxg7Yz6S+XI/P9HUPMldTLHT1pjESzM3k1k8xnWb6+DHPKHa6mhqwzxKTP7JozXnMHw9XBXLe7aXm4ke6/NU6aNVuMSdmYJN3CxnbidSTpcgzQvbAy9/N0BW1jZ41iy4jOmO1gCy0vqaE/sPukDLJGNZPgObjDehHdGy7p971Dz3fwEnIC57JuWz+Vm8u6AcDCZrhSQbomJUXvh53NtkWX0O/Adzz3jDTMzQ7XWIwlBR+LCha/rHecK/1O2K0K2kNxNHdFkMrL/ctGdJA/+56cVPnlY/3Y2xrCBXVB42+tRny154xu3FtWVeJ3B7qx41A3Pr9lOQbysd6lzMW+Mt9J7GTv8Fjw2fXFZV7s/Nv3wuso3E/0eJxX68ezB7uNDq3esV5RVYQ/vbgOT+/vxi/faMeX3t8Ej8NmSMeqRnSsrYoFlywuwY5Due/0lbxjnX/uvZEkslkNimIxxXENxdPoi6ZQ6nVgf74ca2sD8OQzApzoi0HNaqdJzA51RfDInjZYFQu+eeP5uO7CnILggxfUmuTrRa6FlW5LiaWgWC3IsN9olmXiQJo5aLPwHDVA9Y3qNc8Qcbdn0/e2jH5H/NfLz+c+xupZF6uL2UBMmoVzKOz41mH6BmtOKpOjLWQqH9g3QOXhaG00kxa6nFzFvW30/nGptf9NCjMbZhkOsgEqX6qEyuc6ReVI1VA4iPMUqWziy0gWDwAZD90bTzt9cxIXUflcJ2j/4WXUDrIymTeXkVt9LOsHawdw6T1vN3CXbkc3czwHoERZW6GJ6k03Uw5ZmKmhLUT3krcPuOs7bxemS+idSXupzvS/Ts7maeYozq8BMMvbM6z95+yje6mydpTmovMlS+zIpM3HW4jondfrL6zFsnIfHtnThn95uhk//9RGKCO+s/qMdX2JByuqirDjUA+auyOmVFln4xSuz1g35TvU6+uL8U57GG+0DOID5+fag0NxSbc1Ho1lXrzZEsKJvhhqi90I539rV6+pxKsnBwwz0kUlblgVC8p9TnQMJdATSRrqrqqAC1kt1y8Yy8CsP5rEPz+d82N56WgfhuJpBNx2vNUaMlKwvtMextGeKJZVjK3gG05l8IvXWnHFinJDyj4byIy1IAizzmAsZcQo144hvx5JZRHNVuqjoxV+F6rzjf638w3kIpfttFnf2qDbqGB/8VqL6W/kCH7mcry3qQIWS04O1TWUMKTgJazxuSo/Cr/rWD+GU2N3vjRNO212vcznhNsxdwdP1uYHOffn42YP5+OrV1QUYfPSMjSUehBJZvDY3g5Ekxkj7UrVCCk4QHLwuhK3qWLV71UmqxnSvp4RqYmO9UZxvC+GWEqFy65gabkXNUE3nDYFKTVrPG/Ob/fljCeubKowOtWjoc9Yh+MiBRcEYWGjZjXszYfXXNRQjM9dtRx2qwUvH+vH1u/8AU+83YFsfio6o2aNwfT6Ug9W5sNrXjjSh9fZzPLxvthpGSTGQ++Yr6ryG2UBzM7gg2JeNi5LyvJx1n1RQ11Q5nNgw+LcjPVwvtNbnx+81OvjE31R42+VfqcxY90yMIxT/ebBNgD4l981G512NavhD4dzA6Z62kydx/a2n7avTlrN4tafv4GvPX4AX/71O2dxtVOHdKwFQZh1HnqNUksF3BMbQSYpeMKQAlf6najJz3i+1ZaboeQycM5HL87JwR9/q9PU6dXjiOrGkaSXFzmNuKIHXzllymGts76hGItLPYilVDy5r2vU4wBAOJ4xZtdLvfOjotfjqo70RBBPqcaM9coqHxTFgps21gPImZjpUvkilw1e5+mz9B9evwhbVlXizvevMqkI7FbFuF96TJceY62/R0d7otjXHgKQk6fbrAqsisUY0R5NDv5k3rH8mrXVp/2N419geawFQRDG4nB3BJFkBl6HFU1VftSVePCPH1qLIpcNR3qiuP3BN3HzT15FNquhcyhhyIgri1yGb8WpvNz4ksYSFLlsULMajvWc3hkbC03TcDAvBV+ZH9jWU0ft7wgjkVbz/3L1bdArM9ZjsaQ8pzQ63hszOtaLinODIFx8oLeVyvOTHfvacve/yGWDx2FD0OMwJiqu+OffY9P2Hdj28F7syisG9fbfpUtyHfbn8uq0l4/2m9Y/+lbHqGlSs1kNf/PIW9iZ75C/dnLgjBMZ003h6gxTacCqwNk9RgycQrNJ3OWRy8Qc4bEbO6kgNV6VVJCWh8fYh7mM2vuoTEqSSdeYY3dqESWid3eRnMkaYw7QIxpjmot+4IlKdn3MWdNpksVQwz9dTOfWWMMzXUfl5uXgEih7jKRb6SLmpsrkXUpkxIghG5KJLaIZJGeIrsmSZval7LfA5XRWNtPjGKR7w2V2agXJy1UnnTi5gu6xSWoOAE31xiJ/1s5B5v5dQfI6C3fbYMt8fdHbFDIQXcOc4ZvpmaRK6bnF6093szbK0TeGZI+9QyqbubMyibj+rDPzRH2aVrOGMcWnLms888aMSsO8LIlKf94oo8hlzCLqHbmx4qQ3NpagodSDU/3D+O2+LtywPueW2zY4dqqtkfz5ZY14/dQgfrbrFC7Pyzt5x9hiseDD6xfhX353GA+/3ooPr1806nF68+EH/lFm1+cqFUVOlPmc6IsmcaAzbDiC6y7vH15fh395+jD2tQ/hdwdyHdmR8dU6xV4HfnTLhlH/Vl7kRH8shZ5IAqu0ImPm/9IlJXh6fzeO9kSh5L+Ja1mo0NJyLw52hnGsN4qrVpEs9Uh3BEd7onBYFVy5qgJnYqFJwVPlXmRtLpPTNq/T4KA6zBYZPasBl/cCQKqMSY3Z9913OGQsD55PrsD8Wwjm0p1lIRg8w0SWKUhUVo+rbHsuLbb3mRUM6XIqn43J1jO1VCZPF7sHrMWpsfbI0HrKjOE/QDNnGgv3cLVSDCIPe7IxFUZsJcnIR7Zx3PupjlIrqH7k4WQam6GzMddt1c/uXwd33WaZRfh7ztoADhb2FFtCv7GR9bKdZzKJsLJnqa0QXU2/OXuUzufqpXMorN2QqqAwA14OW4TOFVtHA2TuU6y+ZvsCgDVO57PFaJmH7dl4eJ2fZURpi827TB2TheKri43wmo9sqMPWNVV44KUT+P7vj+HFo3147eSAkU5yUYkbimLBknKvYTwKAH9yfg00TcNrJwdxuDuC1TUTy47RMZRAJJGBTbFgaX7wdFGx21QX1eQzT1gVC4pGGcgVcugpt473xYwJh/oSD9wOK5aU+4xB6ZEz1vpANleffemPmnDf80dxuDuCzqEEfvlGO375RjtsigWaBnzowlr86cV1+Oi/78bvm3sQTqSN2Py7/2QNPnTfyzjVP4y32oZMoXsAcO+TB/HrvR2wKhZ4HVaEExm8cmIA7115ev3dOjAMn9OG4mmcwJj0jHV7ezs+/vGPo7S0FG63G2vXrsXrr1MKE03T8NWvfhXV1dVwu93YsmULjhw53SBIEAQBAJ7c14mucAJlPic+cP6ZZwg55LjNpeBOQwquV9BjzVhbLBbcmO/oPvw6pcvhhirjsXVNFRaXejAUTxvy4RKf+YN9w/pFsFiAV08M4GTf6CPvvflOyFhlnYtYLBacV5trDD29vwvxtAqHTUFD/r6WeB3447W5zsYPdh4HcLoj+ETgzuvRZAbxfJzjprx8/Fhv1DBNOc/Usc41ukbOhujKgncvL4PfdebZDP84Hevv//7YWbnaTgapkwVBmA6+9/uj+LMf7p5w1gNdaq1Lr3UCbju+sGUFPnhBLvzq13vbjfhqfbbTZbdicd47yapY8P7zqoxZ7EOTiLPWU30tq/DBYct1cXhdtL8jjFBcl4Hbz+ijstChGesoPa+SXPtqNUsDqreVdM8TPZaa+6V84PwaPPWFy7Hv7q148C824mOX5AxaM1kNPqcNd76/CesbiuF32TA4nMYP/3AcmayGuhI3mqr8uHpNbvD712+a5eDvtA/hRy+eAAD884fX4Y/zKrOXjphl5ECuLvziw2/hPf/ye2N2ezqYVMd6cHAQmzdvht1ux29/+1scOHAA3/zmN1FcTD+ib3zjSh7EMgAAK2NJREFUG/jud7+L+++/H6+88gq8Xi+2bt2KRGJhJAYXBGHiaJqGH72Q+yjevKkBTtvEZ2t1KXhfNGXMMlf4XcZotM6ZOqt6p/cV1ultncSMtVWx4NOX5/IgZ/Id+ZFS7uqAG5fn8y7/957RnS25I/h84ry8M7heGS4t98HG8tTedGkDADKSGWvG+kzolXlPOGHIwIucNpKid0fxTgcZl+kszcdqH+01q6J++05ugOT948jAAe4KfnrDc29rCN94+hA++u+7x3QfP1ekThYEYbr4yYsn8fKxfjw1RhhTKpPFz3efMlIq7snPMK4f0bHW0f0qfvN252mznQBJtzcvK0Opz2k4hR+ehDP4wXx8tb6vjh7nu799CIOx3Pc6IMZlZ2Rx3uQ4nMjg7Xxonf68uIJg5Iy1Hl9dUXR6fe512vCuZWXYfv06vPp/t+BfP3YhfvG/L0WF3wWbVcEV+VnmH76QG2y/LG/QeF3eNPSJtzuRUUnh8vT+3Lv5R2uqcP1Fi7A5v/3I+GwAeOytDrx6cgDJjHpGE7RzZVId63/6p39CXV0dHnjgAVxyySVobGzE1VdfjaVLlwLINZK/853v4Mtf/jI++MEPYt26dfiP//gPdHR04Ne//vV0lF8QhDnMaycHsa99CE6bYsTcTpRij8NI73As3zmqLHKhOmj+mJ+ps8o7vQ+91orXTg4YUuLxYqx1brhoEcrYLHWJ9/Tz3bghNzP+33vajJl0DhmXTb5jWcjoswR6h3fFiJzcGxqKsZxVcFWB8QczRlLhp1zWunFZud9pVJxd4QSGUyrcdiuWlpP0cxmLsdbjto71RnGoKwKbYsH7mDx8LPSOdSylmir7jJrF//nlPmha3h13mipxqZMFQZgOEmnVyCmsuz+P5NvPHsaXf/0O/uTfXsR3nj2MU/3DsFhyqbZG49LGUlQHXAgnMvjvN3KDzLxjfeP6OtQG3fjL9+S+X/qMdTObsX72QDdePnZ6pwnIfe9+l+9o6ekedfT/7+8IYyg/Y10sqbbOiMtuNbK06Nk99HaRecY6t03FiLZWVeDMEwVepw0fOL/G9KyubMq1x/QYeL2jfNnyMpR4HeiLJk2d5mfz6U71GW19+0NdEVOGkFgyg3ufPAgAuO09yyacfeZsmFRwwWOPPYatW7fixhtvxM6dO1FbW4u//Mu/xKc//WkAwIkTJ9DV1YUtW7YY+wQCAWzcuBG7du3Cn/7pn552zGQyiWSS4lLC4bwdu80KWK2mVBkc6zDFNA0vpgfMU0RpIxQeCpsp8bTSD5XHOFlYrA+PQ+apt1JsJIzH5Dh76SGmWbySpvDjU6Pa1k0pJgAg66d4AN/eDmM5vpIaeMlqlm5qgM840MhbuojFuUXpGjR2/Rk2Uuc51G0sq8UspQW7BlszSWUBILF+CZX1IEkdE4tppJKnvuDx3bZ+mr3Jso6EvYV+LIkVFI+W8dK919hQkKeNJJyhVebRyeAheqd4ijMlymLhrDwWjsXesTgwHr9v8dO7yOPesyxGxzpM74M9Nfq9B4Asc3vmcebOPrpP/F1RHVRWZ38+3dY8CLL+8Yu5UcnrL6pF6Rix0GOhKBZUFLnQHoobYfGVfidKvA44bApS+bQvY8VY63xkQx12Hu7F/TuP4f6dxwDkUnAEJzia7bJb8b/etRj/8rvDAMx5rHXet7oSQY8dXeEEdh7uwZVN5k6b0bGe5D0odLj0GqCGko7FkjMxu/vxAwBGdwQfD0MKHk4aFWm5z4mgx4EynwN9+d/86hq/aba8scwLiyU3Wz4QS6HU5zTk/JuXlU1oNqOIScWjyYyRE/WnL5/Egc4wAm47/s81qyZ9TRNlOupkYOx6WUmpULKqKTZVdbD0Vy0Um8v9SjRmSBhfZB5k8ByleGOVDaxkDx83loPs+8xTbabY+6Qk6XubGaPRZGeOtDzFFv8enzbdwMbB4rV03bwNkQowzxZWNyRKqG5wDrH6wMZOwtocvC2isNRNSpjiej2svsg6ze9oejG1IWwDdK2et6iO1opHT92VKaN7mQ3SdfL47GQV3Xt3Jx3fwsrqPT7Etjc/a2s/3TMrMyHqeS8575ccZPH77BriSyim3dXG0oKyOHZeX9uOkDrIxurK1AVL6fhxcx1qC1P927+ezld8gMqdYQO3plj+CZpuzhU6h+hevHikD2k1Czv7fp7qj+HHebVZWtXwnWdz4SUrK4vGDKFRFAv+5IIa/GDncSOPNA+5em9TBV76uyuN/+sz2O2hOCKJNFoGhvEX//E63HYr9t71vtMUbi8c6cNbbUNw2RVcf5E5m4Ounmruihj1bXCePbPpoLHMi/ZQHPrPVX9e59cFUeSyoSbgNurBkZMYZ1OfX7GiAoqFrI70kC67VcGfnF+Dn758Eo/sacN7VlagPRTHwc4wFAuMeOoSrwNravzY3xHGy0f7DZXEvz53FN3hJOpLPIbKcLqY1Iz18ePH8f3vfx/Lly/H008/jVtvvRWf+9zn8LOf/QwA0NWVGymqrDQ3GisrK42/jWT79u0IBALGv7q6urO5DkEQ5hiDsRR+35yLc/nzzRM3LePos5UAYLdaUOxxwGKxGM7gwPjy6i2rK4wKIOC249p11fjeTesnFXv1iUsXI+ixo8hlG1XO7LRZDSnTtoffwpstg6a/j0y1NV+oDbpNAxQjO9YA8KGLFsGVbxyfixS8O5Iw7qOe45znslw7opPvdtBovD5r/cTbuY71eG7gOg6bAme+k6THWbeH4vhmfpDl//xx02k51KeS6aiTAamXBWGh085M2iLJjGFMpnPvkweRUrN49/Iy3PWB1YZ6bGR89Uj0elCn/gxeJkGPwwj5OtwdwQMvnQQAxNMqjvfGTtv+354/CgD42CX1pw3U15W4UeSyIaVm8drJQeP4wplZwlReVsVi1NEBtx1/+Jv34le3vcv4e8WIjvTI/0+EEq8DF+Zd3FdX+03P8SMbcvXQM/u7MRhLYcfB3KTg+oZikxnZZcvNcvDjvVFjEucr166edoPYSXWss9ksLrroItx777248MIL8ZnPfAaf/vSncf/99591Ae68804MDQ0Z/1pbW8ffSRCEOU+x14EX/va9+OcPrzOcoicLHxEt9zmh5GdXqtnM13idVafNikdv34zHbt+MPV/egn/7s4uwaWnppMoR8Njx+O2X4bHbLxs1XRQAfGHLcpxfF0RoOI2bfvSKkasRmL8x1haLxZgpAGDkKuUE3Hbc88Hz8MELavCuZZO77wDJ53vCSepY5+8jl2CP7FgDzMCsN4Y3WkI41BWB06YYsrKJ4M/PeugGP3//+AHE0youXlyMG9dPb4d0OupkQOplQVjotIfM7vhcDv7y0T48vb8bVsWCr1y7Gp/c3Ihf3roZN29qwGcvXzryUCZWVftN8c+6jHgsVuZzUb90tB+PMSXnyLjr104O4NUTA7BbLfjMKDOSFovFiLPWpeQTVaUtZHRncCA3UM5VX8VeBzxMZVM2wrj1bGasAYrFv2adeYB7dY0fa2r8SKlZPLq33ZCBbxkRtqXHZb94pA8n+mL4zP/bg7Sq4YoV5dgyTqaPqWBSUvDq6mqsXr3atG7VqlX4n//5HwBAVVVOvtvd3Y3qaroh3d3duOCCC0Y9ptPphNN5emMyWV0E1eaCxuS6PJVCiqWX4ikZuETX3hkyHVNjqTnAJCThFTRi5m1jcm4m73KwNBuqm45jkg1nSNJlTdKyo43kVtkAvaTpJSR3Hrk/Tw/hOTLAtmHy9FIm22ZSdSuTxMXL6MPhZO63FpWuLbWIpTKJsXRZKSpP8nzzjKLCUmlZkiSvdrXTx87BRgO51C5TPnq5oVA5uAza++pJYzl2yWLal/2IvZ1m8yCV5Sa0h6l8XJLIJXjhZdQA97bTs7bG6H1IsZE7Xr6Mh8n92D3m8nIlaZaccdmYwuJAUqzxHy+n6/N00Da6NI9L9OYqFX4Xbtxw9p0P7iLNR0d5nPVEOquVftdZOVJzxnMRD3ocePAvNuKzP9+DF4704VM/ew2/vHUz1i4KzNsZawBYU+vHi0f74LZbxzSE+8iGOmM0erLoMxq9kSS5w+sdaz5jvej0jvWyCh92Hu7Fsd4oXj2Rk8t+4PyaSc1kFLls6I0kEUlkkFGz2JEPrbnrA2uMgZ7pYjrqZGDsetneOQib4kS2iL6FGZZWMMvuGw9/iS6m7f3NJBUGgEQdPRdXe9hYTm9eSxuxzI08BWeimp6vLULf2Az7HWXcLFVmO9Wl8Xo6L29nOEeEbzqY8ZydpUnE8RZj0VJOcn8uR3ZEqOC8HgJTw5hk4QotW/uoLo01UYot3wGWUqvUnC6KM7w4aCy7esf4rrDnxcPX0n6q00xpJuuoAes5RvWk5qHjJytYerKouV7OsnAqLukvamftDtZ+4enUOIlaeu6OIbqvPO1ofMVyY9l/mN4rC5OgJ0vN9yVaT98nZ5jKEW2g++xl6TGRpnfOOjAELcue8RynPZ8Wr8TrwEAshd8f6sWd71+FjJrFPU/kQndu2lhvqJDWLgqM+o0djesurMXXf3sIxR67KZxmNFZW+vCHw734/u+PIcV8LJpHOIX/23O52eoPr19kGljnrKkJYPfxASM8qFg61uPCO9bjDYI4bVYEPXZD5l91Fgo0APj4xnpcvLgYyytOH4j/yIY63PXYfvz8lRa05HOeXzWiY33x4hI4bAq6wglc890XMJxSUVHkxD0fXDMjLvCTmrHevHkzmpubTesOHz6Mhoacs2tjYyOqqqqwY8cO4+/hcBivvPIKNm3aNAXFFQRBILgUvJIt687gigUoHcVMbLbwOm340S0b8O7lZUirGh7dm3PL1jvWI0d85wMX5nNOrqoumpaOpj4YkVKzOJLvBOnvhT5jnTMuO91ATF/36okBI83WzZsaJnV+nsu6dTCOtKrBZVdM5i7ThdTJgiBMB7oU/IaLaqFYgObuCDpCcdz75CEc6oog4Lbjji0rzurYH16/CE1VRRMaTNVnrPU0ipcszk3A8I71O+1D2Hm4F4oF+OwVY8+Y62aaOgGRgo8LrzfPJNvX0Qe1c22vs7u/FosFTVV+Ixc654MX1MBhVXC0J4qUmkVjmddkSgrkfG8uzvs9DadUXFgfxBN/dRkazjAQOZVMqmN9xx13YPfu3bj33ntx9OhRPPjgg/j3f/933HbbbQByN+MLX/gC/uEf/gGPPfYY9u3bh5tvvhk1NTW47rrrpqP8giAsYCqZ+V3lKDPWJV7nqB/n2cRpsxqz9C8e7YOa1TAQm78z1levrsJdH1iNf/zQ2vE3Pgv0UXKA5IF6mo+NS0qwdU0lPr9l+ajvgV4h72sfQkrN4vy6INYtCk7q/P68aikcT+N43p2+scw37bPVgNTJgiBMDx2hXMd6TU3AiHn90v+8jZ+8lDMs+6cb1pniWidDmc+Jp75wOe784/GNHblsvDrgwue35JQIzUwKrntjvH9t9Rk7TyOdwmXGenxqgm448uqjRRPIlKK3YcqLnCbZ+FQR9DhMoVpXNVWMOgv9oQtzqVT/9OI6PPSZS88q3vtsmZQU/OKLL8avfvUr3HnnnbjnnnvQ2NiI73znO7jpppuMbf72b/8WsVgMn/nMZxAKhXDZZZfhqaeegss1uYuyh5OwWS0mCTGX1qaCVHTfSZLfDtfSg0+UmbX0zhDJjdJMvlt0gvZPVJLUgUtts04mWWYuoc5jJJNKNZTRJsydPHwhSb69rRS3wuXUAJAop3vkGGTypkoaZbNFSH4FJh1PcenW4RCV7xDJ7rLlQWPZLFsnyVO6hDteMvmx1fziRhbTdsMVZEYRaCbJFZfJcyl0soz29R6iONPEYoqvVJ1MEtdAPyLuOJqopQ+uLWKWnHFHVZNrd5juf5J9sIt/f4KOu3oRlYN13LjjvC1G18OlfGM5zXKHVgBIMQmjhUnw7CzkwMuei+leMrfxhQ7vTPNlPf9i7QRyUc8G78rHcB/qiuBwdwRZrfBm16cKRbHgk2dpTjdRKotcCA2nkc7LcPXK3Wmz4gef2DDmfktHpMG6+dLJzVYD5lzWA7Hcd3tJ+cyMjM9knQwAWb8XWasTSeYK7tlzylhOsW8nDyvytpF8dmiVuXHra6V6JsFmlHidw+tieyfVjW6WdiddHaRtmFuzs5/qpGwZnZuHa9mGWKjXCNWIwnKUc5l35kKarbPFmeM3Lyurl5QEk6qzUJVYFf3mvR1Ujr73ULuh7C2So8dWkSzcGje3IcCq6WSQ1T9xuiaeZcOaoP25u7bvMNWzmUq6Z/6j1JmxhKlMw8sojMtzkvZVRxhI8bqYZ/hIFNN6e4j+kFVGb6I6++md4XWjLULvRraKXTMbsHQcpSwo1hqzp4OT1eX8efEMIpkiJplnRl224SJkMgmADj+nac93rGuCbrxnRTn2nBrEC0dyv7fPXbUcf3Re1Zl2nzKWVfgMl+hPbGowlEBtg3FEkxn4nDYjjEd3hh6LJWVeOG0Kkvn2b9AtM9bjYVUsaCj14EhPdIIz1rlv29nGV0+EGzfUGYMpW1aP7ofy4fWL8Mdrq0wx4DPFpM947bXX4tprrx3z7xaLBffccw/uueeecyqYIAjCePA8iTyH4qYlpfjqtatx8eKS0Xabdcp8TjRVFeFQVwSP5g1ZCnF2fa5Q4XeaZjBG5tMci1Kvw4gJK/E6TjNLmQhFTpKCdwzlGqNLy2amYw1InSwIwtSSzWrozH/LaovdeG9TBb75TC7TwZZVFfjCVcvPtPuU4rJbcd2FtTjQEcafXVKPoMeBiiIneiJJHO6OoKmqCG+35QZzNjaeub63WRWsqvZjb2sIgJiXTZTPb1mOJ/d14r1N4xt/6YPa5+pZcyYuW1aGy5aVIa1mseEMLvSz0akGzqJjLQiCUChUjGFepigW/Pll0ztLeq5sXlaGQ10RPJaPs56PMvCZgt87h01BYIL5SS0WC5aV+/D6qUF8ZEPdWaXh8OfNLCPJDI7lU8A0ztCMtSAIwlTTG00irWqwKhZUFjlR7XfhyqYKRBMZfOujF8xImAvnWx+5wPT/lVVFuY51VwTDSRWZrIaagGtMc0zOmhrpWE+Wa9fV4Np1NRPa9vx8KNX5eW+V6cCqWPDzv9g4bcc/Vwq2Y21JZ2HJqrAwaY71BOXddPjrjWUuL0p7mJypjcmmYZaWOcJMOszkXUqalt3NdD7Nx9wsmQwusZzJENi3xtFN0l9HDx1zuJ6kbu5OszzY1UnyNQuTMoPdA0snsyytJum5u4eulUukXSm6zgz76ChxJktjs34uds1Rlm/Q1cOcMAE4oiQhcw7SOYZW0vX5jzOH7Nf2GcvpG+kHkamg7ZMlTNIVo+Nz6RWXlHOX1chis0TF30yzVxkvf81pOyuTeqUbSdaULmISumG6Nlc3PR+NxXRwl1GVfajDjdTRc/vMPzWFOa47+llaC3Zc1TZ6fIq9Kzc6a1GTo/59IVHktMHrsCKWUs8qB/JsctmyMvz4xRPoGMrJGqVjffZUjki7Nhnnz21Xr8Cjb3bgs1ecnqJlIpB5WdrIrbqk7HSjtPlA1m1H1uZAloXqWOws88Qpct1Wi6me5OEyRcdHhMXw8CPm8MzDeaz99D3nztKI0/Y8UwPP4OBkdYYyROd2smW1nOTOFtUsr84wh2EeQpUoo3rJdyRkLEdW0gxK0YF+jIbKnLN5PanyDBNhFnPG6hj7ENVJvA4DzNkwSnZ3GsvR81g41VGWj5i5kPNnxOs0HnrEnwNsVFbPMTrm8DK6fu9BCvUCzE7xWZZdxddC7QtrjJ6pymJ4+buRKKdn4gjReu4+X/w2lSnNJKzpepLSjyTtZ9k6WPn4feZ1t1pE22t2BZpl6mNKZ4O2vHFZld9lxMn+5H9dPJtFMrGysggvHOkzDNUAYOOS0gl9989jmVckj/XUc826alzUcOW0SsELnfnxFRAEYVq47777sHjxYrhcLmzcuBGvvvrqbBfJhMViwV0fWIP/fcUSLK+YW52ZSxpLYGMj/+U+6VifLVz6zZ3iJ8K7lpbhnz687qwbWXqMdXsogb58PvKZirEWBEGYavTOam2wMD1KVuT9cQ53R7D7RG4w75JxZOA6ei5rh1WB1zF5hZIwPtUB94yktSpUCnbGWhCE2eUXv/gFtm3bhvvvvx8bN27Ed77zHWzduhXNzc2oqBg/1mam+MjFZ58HezbxOm24oC6I10/lZlZkxvrsqWAmgxONr54q9Bnrt9tCAHLPcbzcrIIgCIUKGZcV5qzjynzu7P0dYQznFRXjxVfrnFcTwI3rF6GuxLOgO3/C9FGwHetUqRtZmwuuw2SxOHAlSfWKWsgVMs1kts4QyZaSpebGjT3MJE1DzIl0EXOXZhLp9CJyjLRGSXbr6CY3zCxz8c0yKRV3/eTyXncrSam0EXGAqQDNmJhcpx10XHucpNNcLp5mkiR3C3MC93EZG5N3MadT/hJELyT5N5fWWSMJcBxDdL40k1prbACQly9006XGcukf2jAaLjd11pLFdHzu3poqJUmX6zDJ1oNhc/mS1fRMufs6f+5h5k5bdJK7yDJHdh+Vw8FCBrgkLlUTNJa5E7i7j66fu5gCZvf5dAktZ9y0v52FKzjzjXaAXFozmQRwHNPGt771LXz605/GJz/5SQDA/fffj9/85jf4yU9+gr/7u7+bvhMvIDYvK5OO9RTAc5jP9H3UZ6xD+bCRJTNoXDbTZJ1WZG1WOFiGjcRKCqNJBkdvUrh76JuqjUjB4mDZJzLMkVtJsTrQRevDK6gOtLOQJE8LuX/zujTD0u/YO6ncWS/LAMLCxGx9VL8DQHwJNdhdXSTb9p5koUhc/r2PMoVE15Ds2BYb3Tl8uJbKwdsong52X1g4lKODZd4ImGcULayu4y7pvrdJFp6ppPXpIP1WUiwEimcvSZZSW8bJ+iHWQSbpZ9Jxz4mhUdcDwPByalN5DlNYW6qO7l/CS8ojZw/L+MLC6HwH6B5H1lG7IbCH2gTpGubYPWgOZTOK5zTPWNpidIHWOL0rPCMNf1dUFwsJyyhQ54kU3JixLtCsGssrfbBY6Jtb5nOicYLfXUWx4J9vPH86iycscObHV0AQhCkllUphz5492LJli7FOURRs2bIFu3btGnWfZDKJcDhs+iecmc3LyCdBOtZnj3nGemZnWYpc5s7kkvK5FZIgCILAaR/UpeDjp1eaDTwOmyn108YlJTL7LBQM0rEWBOE0+vr6oKoqKivNOQIrKyvR1dU16j7bt29HIBAw/tXVzU2J9kxyQV0QnrzKQWKszx4eVz3TUnD/CNn3UomvFgRhDlPoUnAAWFFJqsSJysAFYSYoWCm4kslCQRbZEvrxFD9zxFhOXESpdCxMbeTsIglTJmhuYGXtTKpd6mbrmfynl7mMcmdu5p6ZZSY3XP7NXcGtMebGzcqhDNIsXjpgjlN1dZolaMY52IxI1kPHUv1MHsbldMU0ksddtLm7Z3QZyaD9r7XTJZTTh9TkfD1sljLboszJtZe7WtPzSjLnUy+T4IU2LaJ9I1Qm/hw9HSTdUtn1O3roHg2fx+z/R0jOnMzFPMucurn0K/AmycnUMiq3fYCuR2GdHeVEh7GcWkWu9CpzyHWye8HlY+oI2b+zn0IL0uw5comg7v4NmN3TU8HcsTL8/SwA7rzzTmzbts34fzgcls71ODhsCr58zWq8fmoAFy8eOx+jcGZcdiv8LhvCicykzcvOlZEd6/lsXGbvj8NmzZq+bVk7y37QTd81GwvPUZmKIOswj+drKv3f1UyS5eRykpiH19L3r+w1ch63DNA3MrWUtvccohCy+EoaHLSU03F4OJQ1QuXOlJoVB9wFmsuAM8z11neChXix8CtevzlZCBlYto5UPj0NADhaycla87K6mLUzsn7WdnGam3AqCyUy1SUtTCLO6hv3fqrTXAG67ng9tQ/49IuprjK9AyxcjdWflhH1svcAPZfYKnouDu4GzzNjsPqXS/15aIAjRG0ck2M8Y3gxPXfuIp4sNRsWep56i8596Wpj2Rpl7cIkPVPVTuWzZwGL2VB+zqJ3rCeSvmq2aKoqwjP592ljY+k4WwvCzFGwHWtBEGaPsrIyWK1WdHd3m9Z3d3ejqqpq1H2cTiecTpl1nSx/trEef7axfvwNhTNyfl0Qu4/3o6nKP/7GU8hpUvB5mmpLEIT5TziRRiSfXqymQF3BAZqxLvbY51xGEGF+U3Aday0/wpnJ5EeQWa5eS5ZGDTMZ8wyqjsK2z2TMo6VZZiyhZWjUkc/8Zfj5VDYjqLF92Yhq1sLdung52DFZOaxZXr4R1zBGXuIsLwcbEVVZTk0lw4xeWJkUleW5ZOXOpNnsPS9TmsrEr5NvAwCqSttZ2DkyaZYHkl03N07j95urAviMtZKh86kZek1NzzfN75/5WVvZdln2rPn94MdSM2xW27SejquN8f6pzIyHn1djKgc1Y55dVvj7x54jNz/JqKO/K5m8QY2+ThsxKzAVOBwOrF+/Hjt27MB1110HAMhms9ixYwduv/32KT+fIJwrP7x5A8KJ9IzHWPtYx9putRT0LM/ZYtTL+W+SplAdk+FVTIZXUPw7SquzinnGmn8LLWPUj2qK1R8TaBMoYxzHwuoVXhdYmDFlxpwa2lT/WMZoX1jGqLszGaaG49uoTNHGy83rD5X2NeVH1tiMbmbEjHWGzViPUX+b6pIsPx/VgaZ2AHukCn++7LnxthW/F0p29Psy8hxKhp4jb6dwJZqmslljlms8M8bzUU1tDt5WSo26HgAyGj0Xld0njT0v3gbLpOncmUzGaLdOR508U+jGZcUeOzyOgusiGFy1qgJbVlXgPSsroCgSXy0UDgX3q4lEcpKql3d/48wb7piBwkw3HeNvMm3sGWP96Ibdp9MyxvoDZ1GWs+XQFB5rsu7aL0/huSfCGcoXiUQQCATG3uAs2bZtG2655RZs2LABl1xyCb7zne8gFosZLuGCUEi47Fa47DOfl9RuVeC2WxFPq6gv8cBmnX/WJXq9vPPwv87cSSdbP45u/TB2XVUoHJvh87WPsZ7f76msW8fi1BQdZ7rK+uIEtnlr9NXTVSfPBLpxWSHPVgM5A7Mf3XLxbBdDEE6j4DrWNTU1aG1thaZpqK+vR2trK/z+mZX26bGhM33u2TrvbJ57IV7zVJ1b0zREIhHU1NSMv/FZ8NGPfhS9vb346le/iq6uLlxwwQV46qmnTjM0E4SFjt9tQzytzltH8JqaGhw4cACrV6+es9/LuXTehXruuX7N010nzwRGqq0C71gLQqFScB1rRVGwaNEiI1WP3++f8Q+szmydW65Zzj1RpntU/PbbbxfptyCMQ5HLju5wct4alymKgtraWgBz+3s51867UM89l695rs5U67QVeA5rQSh05p9mTRAEQRBmEH8+znqpGJcJgjDN3HfffVi8eDFcLhc2btyIV199dcqO3RHKxZbLjLUgnB3SsRYEQRCEc+DPL2vEe1eW4+o1EiYhCML08Ytf/ALbtm3DXXfdhTfeeAPnn38+tm7dip6envF3ngAVRU4sKfeioXR+qm8EYbop2I610+nEXXfdNSvpe2br3HLNM8tCPbcgCFPLtetq8MAnL0HQ4xh/4znKQvxeLsRrns1zL8Rrnizf+ta38OlPfxqf/OQnsXr1atx///3weDz4yU9+MiXH/8q1q/HcF9+D962WQUJBOBss2lzOCyAIQsESDocRCAQwNDQ0a/FyglDoyO9EEISJkEql4PF48N///d9GGkwAuOWWWxAKhfDoo4+atk8mk0gmKQWZbtAm3xpBGJtzrZMLdsZaEARBEARBEASgr68PqqqelpmjsrISXV2n55vbvn07AoGA8a+urm6miioICxbpWAuCIAiCIAjCPOLOO+/E0NCQ8a+1tXW2iyQI856CS7clCIIgCIIgCAJRVlYGq9WK7u5u0/ru7m5UVVWdtr3T6Sz4mHFBmG/IjLUgCIIgCIIgFDAOhwPr16/Hjh07jHXZbBY7duzApk2bZrFkgiDoyIy1IAiCIAiCIBQ427Ztwy233IINGzbgkksuwXe+8x3EYjF88pOfnO2iCYIA6VgLgiAIgiAIQsHz0Y9+FL29vfjqV7+Krq4uXHDBBXjqqadOMzQTBGF2kI61IAjTgp7JLxwOz3JJBKFw0X8fkvlSEISJcPvtt+P222+f9H5SJwvC+JxrnSwda0EQpoVIJAIAkuJDECZAJBJBIBCY7WIIgjBPkTpZECbO2dbJFk2GyQVBmAay2Sw6OjpQVFQEi8Uy6jbhcBh1dXVobW2F3++f4RLODPP9Guf79QHTe42apiESiaCmpgaKIn6igiBMD1In55jv1zjfrw8o7DpZZqwFQZgWFEXBokWLJrSt3++ftxWAzny/xvl+fcD0XaPMVAuCMN1InWxmvl/jfL8+oDDrZBkeFwRBEARBEARBEIRzQDrWgiAIgiAIgiAIgnAOSMdaEIRZw+l04q677oLT6Zztokwb8/0a5/v1AQvjGgVBEBbCt26+X+N8vz6gsK9RzMsEQRAEQRAEQRAE4RyQGWtBEARBEARBEARBOAekYy0IgiAIgiAIgiAI54B0rAVBEARBEARBEAThHJCOtSAIgiAIgiAIgiCcA9KxFgRh1rjvvvuwePFiuFwubNy4Ea+++upsF+ms2L59Oy6++GIUFRWhoqIC1113HZqbm03bJBIJ3HbbbSgtLYXP58MNN9yA7u7uWSrxufH1r38dFosFX/jCF4x18+H62tvb8fGPfxylpaVwu91Yu3YtXn/9dePvmqbhq1/9Kqqrq+F2u7FlyxYcOXJkFkssCIIwdUidPLfqLB2pkwunTpaOtSAIs8IvfvELbNu2DXfddRfeeOMNnH/++di6dSt6enpmu2iTZufOnbjtttuwe/duPPPMM0in07j66qsRi8WMbe644w48/vjjeOSRR7Bz5050dHTg+uuvn8VSnx2vvfYafvCDH2DdunWm9XP9+gYHB7F582bY7Xb89re/xYEDB/DNb34TxcXFxjbf+MY38N3vfhf3338/XnnlFXi9XmzduhWJRGIWSy4IgnDuSJ08t+osHamTC6xO1gRBEGaBSy65RLvtttuM/6uqqtXU1Gjbt2+fxVJNDT09PRoAbefOnZqmaVooFNLsdrv2yCOPGNscPHhQA6Dt2rVrtoo5aSKRiLZ8+XLtmWee0a644grt85//vKZp8+P6vvSlL2mXXXbZmH/PZrNaVVWV9s///M/GulAopDmdTu2//uu/ZqKIgiAI04bUyXOrztI0qZMLsU6WGWtBEGacVCqFPXv2YMuWLcY6RVGwZcsW7Nq1axZLNjUMDQ0BAEpKSgAAe/bsQTqdNl1vU1MT6uvr59T13nbbbbjmmmtM1wHMj+t77LHHsGHDBtx4442oqKjAhRdeiB/+8IfG30+cOIGuri7TNQYCAWzcuHHOXKMgCMJoSJ089+osQOrkQqyTpWMtCMKM09fXB1VVUVlZaVpfWVmJrq6uWSrV1JDNZvGFL3wBmzdvxnnnnQcA6OrqgsPhQDAYNG07l673oYcewhtvvIHt27ef9rf5cH3Hjx/H97//fSxfvhxPP/00br31Vnzuc5/Dz372MwAwrmM+vrOCICxspE7OMZeuV+rkwqyTbbN2ZkEQhHnIbbfdhnfeeQcvvvjibBdlymhtbcXnP/95PPPMM3C5XLNdnGkhm81iw4YNuPfeewEAF154Id555x3cf//9uOWWW2a5dIIgCMLZIHXy3GSu1skyYy0IwoxTVlYGq9V6mkNld3c3qqqqZqlU587tt9+OJ554As8//zwWLVpkrK+qqkIqlUIoFDJtP1eud8+ePejp6cFFF10Em80Gm82GnTt34rvf/S5sNhsqKyvn9PUBQHV1NVavXm1at2rVKrS0tACAcR3z7Z0VBEGQOjnHXLleqZMLt06WjrUgCDOOw+HA+vXrsWPHDmNdNpvFjh07sGnTplks2dmhaRpuv/12/OpXv8Jzzz2HxsZG09/Xr18Pu91uut7m5ma0tLTMieu96qqrsG/fPuzdu9f4t2HDBtx0003G8ly+PgDYvHnzaelYDh8+jIaGBgBAY2MjqqqqTNcYDofxyiuvzJlrFARBGA2pk+dWnSV1cgHXybNmmyYIwoLmoYce0pxOp/bTn/5UO3DggPaZz3xGCwaDWldX12wXbdLceuutWiAQ0H7/+99rnZ2dxr/h4WFjm89+9rNafX299txzz2mvv/66tmnTJm3Tpk2zWOpzgzuQatrcv75XX31Vs9ls2j/+4z9qR44c0f7zP/9T83g82s9//nNjm69//etaMBjUHn30Ue3tt9/WPvjBD2qNjY1aPB6fxZILgiCcO1Inz606ayRSJxdGnSwda0EQZo1//dd/1err6zWHw6Fdcskl2u7du2e7SGcFgFH/PfDAA8Y28Xhc+8u//EutuLhY83g82oc+9CGts7Nz9gp9joysxOfD9T3++OPaeeedpzmdTq2pqUn793//d9Pfs9ms9pWvfEWrrKzUnE6ndtVVV2nNzc2zVFpBEISpRerkuVVncaROLow62aJpmjY7c+WCIAiCIAiCIAiCMPeRGGtBEARBEARBEARBOAekYy0IgiAIgiAIgiAI54B0rAVBEARBEARBEAThHJCOtSAIgiAIgiAIgiCcA9KxFgRBEARBEARBEIRzQDrWgiAIgiAIgiAIgnAOSMdaEARBEARBEARBEM4B6VgLgiAIgiAIgiAIwjkgHWtBEARBEARBEARBOAekYy0IgiAIgiAIgiAI54B0rAVBEARBEARBEAThHJCOtSAIgiAIgiAIgiCcA/8/98+17a00QeUAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -141,7 +162,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -150,13 +171,13 @@ "Text(0.5, 1.0, 'XZ intensity at the center')" ] }, - "execution_count": 23, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -170,11 +191,18 @@ "\n", "fig, ax = plt.subplots(1, 4, figsize=(12, 3))\n", "\n", + "gam = 0.3\n", + "\n", "rgc_img = rgc_img.squeeze()\n", "\n", - "ax[0].matshow(rgc_img[rgc_img.shape[0]//2, :, : ])\n", + "ax[0].matshow(rgc_img[rgc_img.shape[0]//2, :, : ], norm=mpl.colors.PowerNorm(gam))\n", + "ax[0].axhline(rgc_img.shape[0]//2, color='blue', linewidth=4, alpha=0.5)\n", + "\n", "ax[1].plot(rgc_img[rgc_img.shape[0]//2, rgc_img.shape[0]//2, : ])\n", - "ax[2].matshow(rgc_img[:,:, rgc_img.shape[0]//2])\n", + "\n", + "ax[2].matshow(rgc_img[:,:, rgc_img.shape[0]//2], norm=mpl.colors.PowerNorm(gam))\n", + "ax[2].axvline(rgc_img.shape[0]//2, color='blue', linewidth=4, alpha=0.5)\n", + "\n", "ax[3].plot(rgc_img[:,rgc_img.shape[0]//2, rgc_img.shape[0]//2])\n", "\n", "ax[0].set_title(\"XY subsampled PSF\")\n", From 5416ea8c58b5fd7624ea22680d21459e4ba1dad6 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 21 Mar 2024 15:31:28 +0000 Subject: [PATCH 70/81] fixes plane referencing --- tests/test_3D_eSRRF/load_analyse.ipynb | 102 +++++++++++++++++++------ 1 file changed, 78 insertions(+), 24 deletions(-) diff --git a/tests/test_3D_eSRRF/load_analyse.ipynb b/tests/test_3D_eSRRF/load_analyse.ipynb index 31652f11..22090f67 100644 --- a/tests/test_3D_eSRRF/load_analyse.ipynb +++ b/tests/test_3D_eSRRF/load_analyse.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 11, + "execution_count": 49, "metadata": {}, "outputs": [], "source": [ @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 50, "metadata": {}, "outputs": [ { @@ -44,18 +44,18 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 59, "metadata": {}, "outputs": [], "source": [ "# set parameters\n", "\n", - "path = \"/Users/avesga/Code/radialsym/simulations/FULL_distance_emitters_1.5_px_size_0.02_int_f_1500_offset_200_int_noise_100.tiff\"" + "path = \"/Users/avesga/Code/radialsym/simulations/PLANES_num_planes_9_distance_emitters_0.5_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 60, "metadata": {}, "outputs": [], "source": [ @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 61, "metadata": {}, "outputs": [], "source": [ @@ -86,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 62, "metadata": {}, "outputs": [ { @@ -96,19 +96,19 @@ "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.05732637500000237 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.004476208000028237 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.013857583000003615 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.004404792000059388 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.015633874999991804 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.007538167000006979 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01672654099996862 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.008300208000036946 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01692379200000005 seconds\n", - "Agent: eSRRF_3D using Threaded ran in 9.336254499999995 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.008426792000022942 seconds\n", + "Agent: eSRRF_3D using Threaded ran in 2.146853041999975 seconds\n", "Only one frame, no temporal correlations can be calculated\n" ] } @@ -122,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 63, "metadata": {}, "outputs": [ { @@ -131,13 +131,13 @@ "Text(0.5, 1.0, 'XZ intensity at the center')" ] }, - "execution_count": 33, + "execution_count": 63, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -162,7 +162,60 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 156, + "metadata": {}, + "outputs": [], + "source": [ + "def render_z(rgc_img, separation_planes, magnification_z):\n", + "\n", + " z_section = np.zeros((rgc_img.shape[1], rgc_img.shape[1], rgc_img.shape[1]))\n", + "\n", + " num_planes = rgc_img.shape[0] // magnification_z\n", + " planes = np.zeros(num_planes)\n", + "\n", + " if num_planes % 2 == 1:\n", + " planes = np.arange(num_planes) * separation_planes * magnification_z\n", + " planes = planes + planes[planes.size//2]\n", + " else:\n", + " # check if separation_planes is even\n", + " if separation_planes * magnification_z % 2 == 0:\n", + " planes = np.arange(num_planes) * separation_planes * magnification_z\n", + " planes = planes + planes[planes.size//2] - 1\n", + " else:\n", + " # print a warning, saying that the planes are not evenly distributed\n", + " print(\"Warning: the planes are not evenly distributed. Use even separation for even number of planes.\")\n", + "\n", + " print(\"Planes chosen are: \", planes)\n", + " for p in range(num_planes):\n", + " \n", + " for m in range(magnification_z):\n", + " z_section[planes[p]-m, :, :] = rgc_img[p*magnification_z+m, :, :]\n", + "\n", + " return z_section" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Planes chosen are: [24 30 36 42 48 54 60 66 72]\n" + ] + } + ], + "source": [ + "separation_planes = 3\n", + "\n", + "rgc_img_Z = render_z(rgc_img, separation_planes, magnification_z)" + ] + }, + { + "cell_type": "code", + "execution_count": 159, "metadata": {}, "outputs": [ { @@ -171,13 +224,13 @@ "Text(0.5, 1.0, 'XZ intensity at the center')" ] }, - "execution_count": 34, + "execution_count": 159, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -196,14 +249,15 @@ "rgc_img = rgc_img.squeeze()\n", "\n", "ax[0].matshow(rgc_img[rgc_img.shape[0]//2, :, : ], norm=mpl.colors.PowerNorm(gam))\n", - "ax[0].axhline(rgc_img.shape[0]//2, color='blue', linewidth=4, alpha=0.5)\n", + "ax[0].axhline(rgc_img.shape[1]//2, color='blue', linewidth=4, alpha=0.5)\n", + "\n", + "ax[1].plot(rgc_img[rgc_img.shape[0]//2, rgc_img.shape[1]//2, : ])\n", "\n", - "ax[1].plot(rgc_img[rgc_img.shape[0]//2, rgc_img.shape[0]//2, : ])\n", + "ax[2].matshow(rgc_img_Z[:,:, rgc_img.shape[2]//2], norm=mpl.colors.PowerNorm(gam))\n", "\n", - "ax[2].matshow(rgc_img[:,:, rgc_img.shape[0]//2], norm=mpl.colors.PowerNorm(gam))\n", - "ax[2].axvline(rgc_img.shape[0]//2, color='blue', linewidth=4, alpha=0.5)\n", + "ax[2].axvline(rgc_img.shape[2]//2, color='blue', linewidth=4, alpha=0.5)\n", "\n", - "ax[3].plot(rgc_img[:,rgc_img.shape[0]//2, rgc_img.shape[0]//2])\n", + "ax[3].plot(rgc_img[:,rgc_img.shape[1]//2, rgc_img.shape[2]//2])\n", "\n", "ax[0].set_title(\"XY subsampled PSF\")\n", "ax[1].set_title(\"XY intensity at the center\")\n", From 67ee90dc547544f88e42a0aa396a1156c8c41728 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 21 Mar 2024 18:42:12 +0000 Subject: [PATCH 71/81] finished figure --- tests/test_3D_eSRRF/load_analyse.ipynb | 169 ++++++++++++++++--------- 1 file changed, 106 insertions(+), 63 deletions(-) diff --git a/tests/test_3D_eSRRF/load_analyse.ipynb b/tests/test_3D_eSRRF/load_analyse.ipynb index 22090f67..8273b3c7 100644 --- a/tests/test_3D_eSRRF/load_analyse.ipynb +++ b/tests/test_3D_eSRRF/load_analyse.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 49, + "execution_count": 104, "metadata": {}, "outputs": [], "source": [ @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 105, "metadata": {}, "outputs": [ { @@ -44,29 +44,34 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 106, "metadata": {}, "outputs": [], "source": [ "# set parameters\n", "\n", - "path = \"/Users/avesga/Code/radialsym/simulations/PLANES_num_planes_9_distance_emitters_0.5_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"" + "path = \"/Users/avesga/Code/radialsym/simulations/PLANES_num_planes_9_distance_emitters_1_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", + "path_full = \"/Users/avesga/Code/radialsym/simulations/FULL_distance_emitters_1_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", + "\n", + "pixel_size = 0.120\n", + "separation_planes = 3" ] }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 107, "metadata": {}, "outputs": [], "source": [ "# Load file\n", "\n", - "img = imread(path).astype(np.float32)" + "img = imread(path).astype(np.float32)\n", + "img_full = imread(path_full).astype(np.float32)" ] }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 108, "metadata": {}, "outputs": [], "source": [ @@ -76,7 +81,7 @@ "magnification_z=2\n", "radius=1\n", "radius_z = 1\n", - "ratio_px = 1\n", + "ratio_px = 4\n", "sensitivity=1\n", "run_type=\"Threaded\"\n", "correlation=\"AVG\"\n", @@ -86,7 +91,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 109, "metadata": {}, "outputs": [ { @@ -96,19 +101,20 @@ "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.004476208000028237 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.004273499999953856 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.004404792000059388 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.004248875000030239 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.007538167000006979 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010090499999932945 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.3019100674040418, Delay probability: 0.12540459203699675\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.008300208000036946 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.008322249999991982 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.008426792000022942 seconds\n", - "Agent: eSRRF_3D using Threaded ran in 2.146853041999975 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.008463457999823731 seconds\n", + "Agent: eSRRF_3D using Threaded ran in 1.3909242500001255 seconds\n", "Only one frame, no temporal correlations can be calculated\n" ] } @@ -117,12 +123,14 @@ "# esrrf3d\n", "esrrf = eSRRF3D()\n", "\n", - "rgc_img = run_esrrf3d(img, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, radius_z =radius_z, ratio_px = ratio_px, sensitivity=sensitivity, run_type=run_type, correlation=correlation, framewindow=framewindow, rollingoverlap=rollingoverlap)\n" + "rgc_img = run_esrrf3d(img, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, radius_z =radius_z, ratio_px = ratio_px, sensitivity=sensitivity, run_type=run_type, correlation=correlation, framewindow=framewindow, rollingoverlap=rollingoverlap)\n", + "\n", + "rgc_img = rgc_img.squeeze()\n" ] }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 110, "metadata": {}, "outputs": [ { @@ -131,13 +139,13 @@ "Text(0.5, 1.0, 'XZ intensity at the center')" ] }, - "execution_count": 63, + "execution_count": 110, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -150,9 +158,9 @@ "fig, ax = plt.subplots(1, 4, figsize=(12, 3))\n", "\n", "ax[0].matshow(img[img.shape[0]//2, :, : ])\n", - "ax[1].plot(img[img.shape[0]//2, img.shape[0]//2, : ])\n", - "ax[2].matshow(img[:,:, img.shape[0]//2])\n", - "ax[3].plot(img[:,img.shape[0]//2, img.shape[0]//2])\n", + "ax[1].plot(img[img.shape[0]//2, img.shape[1]//2, : ])\n", + "ax[2].matshow(img[:,:, img.shape[2]//2])\n", + "ax[3].plot(img[:,img.shape[1]//2, img.shape[2]//2])\n", "\n", "ax[0].set_title(\"XY subsampled PSF\")\n", "ax[1].set_title(\"XY intensity at the center\")\n", @@ -162,7 +170,7 @@ }, { "cell_type": "code", - "execution_count": 156, + "execution_count": 111, "metadata": {}, "outputs": [], "source": [ @@ -171,23 +179,20 @@ " z_section = np.zeros((rgc_img.shape[1], rgc_img.shape[1], rgc_img.shape[1]))\n", "\n", " num_planes = rgc_img.shape[0] // magnification_z\n", - " planes = np.zeros(num_planes)\n", "\n", " if num_planes % 2 == 1:\n", " planes = np.arange(num_planes) * separation_planes * magnification_z\n", - " planes = planes + planes[planes.size//2]\n", + " planes = planes + (rgc_img.shape[1]//2 - planes[planes.shape[0]//2])\n", " else:\n", " # check if separation_planes is even\n", - " if separation_planes * magnification_z % 2 == 0:\n", + " if separation_planes % 2 == 0:\n", " planes = np.arange(num_planes) * separation_planes * magnification_z\n", - " planes = planes + planes[planes.size//2] - 1\n", + " planes = planes + (rgc_img.shape[1]//2 - planes[planes.shape[0]//2]) + 1*magnification_z*separation_planes\n", " else:\n", " # print a warning, saying that the planes are not evenly distributed\n", " print(\"Warning: the planes are not evenly distributed. Use even separation for even number of planes.\")\n", "\n", - " print(\"Planes chosen are: \", planes)\n", " for p in range(num_planes):\n", - " \n", " for m in range(magnification_z):\n", " z_section[planes[p]-m, :, :] = rgc_img[p*magnification_z+m, :, :]\n", "\n", @@ -196,43 +201,34 @@ }, { "cell_type": "code", - "execution_count": 158, + "execution_count": 112, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Planes chosen are: [24 30 36 42 48 54 60 66 72]\n" - ] - } - ], + "outputs": [], "source": [ "separation_planes = 3\n", "\n", - "rgc_img_Z = render_z(rgc_img, separation_planes, magnification_z)" + "rgc_img_Z = render_z(rgc_img, separation_planes, magnification_z)\n", + "img_Z = render_z(img, separation_planes, 1)" ] }, { "cell_type": "code", - "execution_count": 159, + "execution_count": 118, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'XZ intensity at the center')" - ] - }, - "execution_count": 159, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.02 1.02]\n", + "[1.26]\n" + ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAN6CAYAAABfcvo/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydeXxM1/vHP5PJMtlFNksIIragNHaNpFr7vpcqKYraWrW3aq2iSqu22opavrVTbVGKH62dolVLLIldNlkkss79/TF57tw5M5FFMhPyvF8vr8ncOfec55x7J07O/Tyfo5IkSQLDMAzDMAzDMAzDMAzDmBErSwfAMAzDMAzDMAzDMAzDFD94UYphGIZhGIZhGIZhGIYxO7woxTAMwzAMwzAMwzAMw5gdXpRiGIZhGIZhGIZhGIZhzA4vSjEMwzAMwzAMwzAMwzBmhxelGIZhGIZhGIZhGIZhGLPDi1IMwzAMwzAMwzAMwzCM2eFFKYZhGIZhGIZhGIZhGMbs8KIUwzAMwzAMwzAMwzAMY3Z4UYphGOYl4MiRI1CpVDhy5Ih8LDQ0FBUqVLBYTAywdu1aqFQqnD171tKhFArh4eFQqVRYu3ZtgdVJYxYeHl5gdTIMwzBMQcNzr4Jj2rRpUKlUlg6jQOB5TMHDi1IMwzCFBP2nZerfxIkTzRZHSEiIQdv29vaoXbs2vv32W2i1WrPFYQpJkhAUFARPT0/ExMQYfT506FDY2NjgwoULAIz7YupfSEiIeTvBMAzDMEyRgOdeOfOyzb2OHz+OadOmIS4urtDaeFGWLl1aoA/wihvWlg6AYRjmVWfGjBmoWLGiwbGaNWuaNQYfHx/Mnj0bABAdHY1NmzZh9OjRiIqKwqxZs8waixKVSoXly5ejTp06GDt2LNasWSN/duLECaxYsQKffPIJ6tSpAwD47LPPMGjQIJN1bd68Gb/88gsaNWpkjtAZhmEYhimi8Nwreywx95o8eXK+FwWPHz+O6dOnIzQ0FCVKlMhXHQXJe++9h3feeQd2dnbysaVLl8LDwwOhoaGWC+wlhhelGIZhCpk2bdqgXr16Fo3B1dUVffv2ld8PHToU1apVw6JFizBjxgyo1WqLxVajRg2MGzcOX375JUJDQxEcHIz09HQMHjwY5cqVw/Tp0+WyLVq0MFnHP//8gw8++ACBgYGYMWOGuUJnGIZhGKYIwnOv52PuuZe1tTWsrV+NpQe1Wm3Ra/cqwul7DMMwFkSlUmHatGlGxytUqFCoT1s0Gg3q16+PxMREREZGyscvXbqE0NBQVKpUCRqNBqVKlcKAAQMM5N2XLl2CSqXCzz//LB87d+4cVCoVXn/9dYN22rRpg4YNG+YYz+effw4/Pz8MGTIEaWlpmD9/Pv79918sXrwYjo6Ozz03KSkJvXr1go2NDTZv3gxbW9vnln/06BHef/99+Pj4wM7ODqVLl0anTp0MvAHyel2Sk5MxZMgQuLu7w8XFBf369cOTJ08Mypw9exatWrWCh4cH7O3tUbFiRQwYMMCgzNdff40mTZrA3d0d9vb2CAwMxLZt24zaU6lUGDFiBLZu3YoaNWrA3t4ejRs3xj///AMAWL58OSpXrgyNRoOQkBAj34OQkBDUrFkT586dQ5MmTeR4vv/+++eOHXH16lV0794dJUuWhEajQb169QzuB+Ly5cto3rw57O3t4ePjgy+++MLiaQsMwzBM8YbnXjrMOfcy5SlFc5ldu3ahZs2asLOzQ0BAAPbt22dw3rhx4wAAFStWlNMFlfOaDRs2IDAwEPb29ihZsiTeeecd3L1716Atmvf8999/ePPNN+Hg4ICyZcviq6++Mop10aJFCAgIgIODA9zc3FCvXj1s2rRJ/lz0lKpQoQIuX76M//u//zNIZ7x16xZUKhW++eYbozaOHz8OlUqF//3vf88dt+LCq7FcyTAMU4SJj49HdHS0wTEPDw8LRaOHTKyVUugDBw7g1q1beP/991GqVClcvnwZK1aswOXLl3Hy5EmoVCrUrFkTJUqUwNGjR9GxY0cAwLFjx2BlZYWLFy8iISEBLi4u0Gq1OH78OAYPHpxjLBqNBkuXLkWrVq0wbNgwbNq0CV26dEGHDh1yPHfEiBG4cuUKNm7cCD8/vxzLd+vWDZcvX8bIkSNRoUIFREZG4sCBA7hz506+zUtHjBiBEiVKYNq0abh27RqWLVuGiIgI2SQ1MjISLVu2hKenJyZOnIgSJUogPDwcO3bsMKhn4cKF6NixI959912kpaXhp59+Qo8ePfDLL7+gXbt2BmWPHTuGn3/+GcOHDwcAzJ49G+3bt8f48eOxdOlSDBs2DE+ePMFXX32FAQMG4NChQwbnP3nyBG3btkXPnj3Ru3dvbNmyBR9++CFsbW2NFsuUXL58GU2bNkXZsmUxceJEODo6YsuWLejcuTO2b9+OLl26ANAt/r355pvIyMiQy61YsQL29vb5GmOGYRiGyS089ypac6/s+PPPP7Fjxw4MGzYMzs7O+O6779CtWzfcuXMH7u7u6Nq1K65fv47//e9/+Oabb+Rr6OnpCQCYNWsWPv/8c/Ts2RODBg1CVFQUFi1ahGbNmuHvv/82GOcnT56gdevW6Nq1K3r27Ilt27ZhwoQJqFWrFtq0aQMAWLlyJUaNGoXu3bvjo48+QkpKCi5duoRTp06hT58+Jvvw7bffYuTIkXBycsJnn30GAPD29kalSpXQtGlTbNy4EaNHjzY4Z+PGjXB2dkanTp3yPXavFBLDMAxTKKxZs0YCYPIfAUCaOnWq0bm+vr5S//795feHDx+WAEiHDx+Wj/Xv31/y9fXNMY7g4GCpWrVqUlRUlBQVFSVdvXpVGjdunARAateunUHZ5ORko/P/97//SQCko0ePysfatWsnNWjQQH7ftWtXqWvXrpJarZb27t0rSZIknT9/XgIg7d69O8cYid69e0sAJGdnZ+nu3bs5ll+/fr0EQHr//fdzVf+TJ08kANK8efOeWy6314WucWBgoJSWliYf/+qrrwz6vnPnTgmAdObMmee2K45/WlqaVLNmTal58+ZG8dnZ2Um3b9+Wjy1fvlwCIJUqVUpKSEiQj0+aNEkCYFA2ODhYAiDNnz9fPpaamirVqVNH8vLykvty+/ZtCYC0Zs0audxbb70l1apVS0pJSZGPabVaqUmTJpK/v7987OOPP5YASKdOnZKPRUZGSq6urkbxMAzDMExBwHOvojf3kiRJmjp1qsE1kCTddbC1tZVu3LghH7t48aIEQFq0aJF8bN68eSbnDeHh4ZJarZZmzZplcPyff/6RrK2tDY7TvOfHH3+Uj6WmpkqlSpWSunXrJh/r1KmTFBAQ8Ny+0D2mjCcgIEAKDg42KktzsytXrsjH0tLSJA8PD4N7rbjD6XsMwzCFzJIlS3DgwAGDf+bm6tWr8PT0hKenJ6pVq4Z58+ahY8eORjuFKFUsKSkpiI6Ols0rz58/L38WFBSE8+fPIykpCYDuSVfbtm1Rp04dHDt2DIDuCZ5KpcIbb7yR6zjpCViNGjXg4+Pz3LLXr1/Hhx9+KPsz5AZ7e3vY2triyJEjRul1L8LgwYNhY2Mjv//www9hbW2N3377DQDkJ3W//PIL0tPTnxsf8eTJE8THx8tjLfLWW28ZKLtIqt+tWzc4OzsbHb9165bB+dbW1hgyZIj83tbWFkOGDEFkZCTOnTtnMr7Y2FgcOnQIPXv2RGJiIqKjoxEdHY2YmBi0atUKYWFhuH//PgDgt99+Q6NGjdCgQQP5fE9PT7z77rvZ9p9hGIZhCgKeexWdudfzePvttw2UVrVr14aLi4vRnMUUO3bsgFarRc+ePeX5SHR0NEqVKgV/f38cPnzYoLyTk5OBx5etrS0aNGhg0FaJEiVw7949nDlz5oX7BgA9e/aERqPBxo0b5WP79+9HdHS0QSzFHV6UYhiGKWQaNGiAt99+2+CfualQoQIOHDiA/fv3Y+nSpShbtiyioqKg0WgMysXGxuKjjz6Ct7c37O3t4enpKe9eEx8fL5cLCgpCRkYGTpw4gWvXriEyMhJBQUFo1qyZwcSoRo0aKFmyZK5iPHv2LJYsWYKaNWvi1KlT2LBhQ7ZlU1NT0bNnT2RkZGDz5s05eh8QdnZ2mDt3Lvbu3Qtvb280a9YMX331FR49epSr87PD39/f4L2TkxNKly4t+w0EBwejW7dumD59Ojw8PNCpUyesWbMGqampBufRDjYajQYlS5aEp6cnli1bZjD2RPny5Q3eu7q6AgDKlStn8ri4CFemTBmjcatSpQoAGHlQETdu3IAkSfj888/liTb9mzp1KgDIPhkRERFG4wIAVatWNVk3wzAMwxQUPPcqOnOv5yHOZQDAzc0tVw8Ow8LCIEkS/P39jeYkV65cMfDtAnS7IYq+VmJbEyZMgJOTExo0aAB/f38MHz4cf/31Vz57p1vk6tChg4En1caNG1G2bFk0b9483/W+arCnFMMwTBEkMzOzQOtzdHQ0mJA1bdoUr7/+Oj799FN899138vGePXvi+PHjGDduHOrUqQMnJydotVq0bt3awKC6Xr160Gg0OHr0KMqXLw8vLy9UqVIFQUFBWLp0KVJTU3Hs2DHZXygnMjMzMXjwYJQpUwZ//fUXWrZsiTFjxqB9+/Ymt//95JNPcPHiRSxZsgS1a9fO01h8/PHH6NChA3bt2oX9+/fj888/x+zZs3Ho0CHUrVs3xzjzg0qlwrZt23Dy5Ens2bMH+/fvx4ABAzB//nycPHkSTk5OOHbsGDp27IhmzZph6dKlKF26NGxsbLBmzRqDyQyR3c4v2R2XJClfsSuhe2Ds2LFo1aqVyTKVK1d+4XYYhmEYxtzw3Kvw5l7Z8SJzFq1WC5VKhb1795qsx8nJKc9tVa9eHdeuXcMvv/yCffv2Yfv27Vi6dCmmTJlisCNhXujXrx+2bt2K48ePo1atWvj5558xbNgwWFmxPojgRSmGYRgL4ubmhri4OINjaWlpePjwYaG2W7t2bfTt2xfLly/H2LFjUb58eTx58gR//PEHpk+fjilTpshlw8LCjM4nyfOxY8dQvnx5BAUFAdA9xUtNTcXGjRvx+PFjNGvWLFfxfPfdd/j777+xc+dOuLi44Pvvv0e9evUwceJEox3haILQtWtXDBs2LF/99/Pzw5gxYzBmzBiEhYWhTp06mD9/vvyEMK/XJSwsDG+++ab8/unTp3j48CHatm1rUK5Ro0Zo1KgRZs2ahU2bNuHdd9/FTz/9hEGDBmH79u3QaDTYv38/7Ozs5HPWrFmTrz7mxIMHD5CUlGTwpPP69esAkK3he6VKlQAANjY2OT519vX1NXnvXLt2LZ8RMwzDMMyLw3MvHeaee+UXUd1E+Pn5QZIkVKxYUVZ6FwSOjo7o1asXevXqhbS0NHTt2hWzZs3CpEmTjFRuOcUIAK1bt4anpyc2btyIhg0bIjk5Ge+9916BxfsqwMtzDMMwFsTPzw9Hjx41OLZixYoCf1pnivHjxyM9PR0LFiwAoH+CJD6d+vbbb02eHxQUhFOnTuHw4cPyxMjDwwPVq1fH3Llz5TI5cffuXUyZMgUdO3ZE586dAQB16tTBqFGjsHLlSpw6dUouGx4ejkGDBsHX1xerVq3KU38BIDk5GSkpKQbH/Pz84OzsbJBKl9frsmLFCgOvqGXLliEjI0PezeXJkydG41qnTh0AkNtVq9VQqVQGbYSHh2PXrl1562QuycjIwPLly+X3aWlpWL58OTw9PREYGGjyHC8vL4SEhGD58uUmJ+9RUVHyz23btsXJkydx+vRpg8+VvgoMwzAMY2547mXeudeLQg/PxIXErl27Qq1WY/r06UbjJ0kSYmJi8tyWeI6trS1q1KgBSZKe6wnq6OhoFB9hbW0t73K8du1a1KpVq8CUZq8KrJRiGIaxIIMGDcLQoUPRrVs3tGjRAhcvXsT+/fvNsm1xjRo10LZtW6xatQqff/453N3dZY+l9PR0lC1bFr///jtu375t8vygoCDMmjULd+/eNZgANWvWDMuXL0eFChVyNMwEgJEjR0KSJCPDzOnTp2PLli0YOnQozp49C7VajXfeeQdxcXF499138euvv5qsz8nJSZ5giVy/fh1vvfUWevbsiRo1asDa2ho7d+7E48eP8c4778jl8npd0tLS5HqvXbuGpUuX4o033pC3bV63bh2WLl2KLl26wM/PD4mJiVi5ciVcXFxkNVW7du2wYMECtG7dGn369EFkZCSWLFmCypUr49KlSzmOY14pU6YM5s6di/DwcFSpUgWbN2/GhQsXsGLFCgPTdpElS5bgjTfeQK1atfDBBx+gUqVKePz4MU6cOIF79+7h4sWLAHQT7/Xr16N169b46KOP4OjoiBUrVsDX17dQ+sMwDMMwuYHnXuade70o9KDss88+wzvvvAMbGxt06NABfn5++OKLLzBp0iSEh4ejc+fOcHZ2xu3bt7Fz504MHjwYY8eOzVNbLVu2RKlSpdC0aVN4e3vjypUrWLx4Mdq1a2ewiYypGJctW4YvvvgClStXhpeXl4FnVL9+/fDdd9/h8OHD8uIho8ASW/4xDMMUB2jL2DNnzmRbJjMzU5owYYLk4eEhOTg4SK1atZJu3LhR4NsSZ7e97ZEjRwy2Rr53757UpUsXqUSJEpKrq6vUo0cP6cGDBya3T05ISJDUarXk7OwsZWRkyMc3bNggAZDee++9HGPbuXOnBED6+uuvTX6+bds2CYC0YMECSZKkbLd5Vv573phER0dLw4cPl6pVqyY5OjpKrq6uUsOGDaUtW7YYlMvtdaFr/H//93/S4MGDJTc3N8nJyUl69913pZiYGLnc+fPnpd69e0vly5eX7OzsJC8vL6l9+/bS2bNnDdpdvXq15O/vL9nZ2UnVqlWT1qxZk+02ysOHDzc4dvv2bQmANG/ePIPjdO9s3bpVPkb3xNmzZ6XGjRtLGo1G8vX1lRYvXmyyzjVr1hgcv3nzptSvXz+pVKlSko2NjVS2bFmpffv20rZt2wzKXbp0SQoODpY0Go1UtmxZaebMmdLq1atNbu3MMAzDMC8Kz72K3txLkqRcz2UkSTK6DpIkSTNnzpTKli0rWVlZGc0htm/fLr3xxhuSo6Oj5OjoKFWrVk0aPny4dO3aNblMdtdDvJ7Lly+XmjVrJrm7u0t2dnaSn5+fNG7cOCk+Pl4uQ/eYMoZHjx5J7dq1k5ydnSUAUnBwsFFbAQEBkpWVlXTv3r1sRqn4opKkAnA+ZRiGYRjmpSEkJATR0dH4999/LR0KwzAMwzDMK0/dunVRsmRJ/PHHH5YOpcjBnlIMwzAMwzAMwzAMwzCFwNmzZ3HhwgX069fP0qEUSdhTimEYhmEYhmEYhmEYpgD5999/ce7cOcyfPx+lS5dGr169LB1SkYSVUgzDMAzDMAzDMAzDMAXItm3b8P777yM9PR3/+9//oNFoLB1SkYQ9pRiGYRiGYRiGYRiGYRizw0ophmEYhmEYhmEYhmEYxuzwohTDMAzDMAzDMAzDMAxjdnhRimEY5iXkyJEjUKlUOHLkSL7P3bZtW8EHlg0qlQrTpk2T369duxYqlQrh4eFmi6GwEPvGMAzDMAxjCSpUqID27dtbOgyGyRO8KMUwDMNky6ZNm/Dtt99aOgwmn4SEhEClUsn/SpYsifr16+OHH36AVqs1KLtnzx4EBwfDy8sLDg4OqFSpEnr27Il9+/bJZcLDww3qU/5r1KiRubvHMAzDMC89ycnJmDZtWq4fNP7333+YNm3aK/FgL698+eWX2LVrl6XDYAoYa0sHwDAMw+SdZs2a4dmzZ7C1tS3UdjZt2oR///0XH3/8cYHW+9577+Gdd96BnZ1dgdZrCZ49ewZr66L736mPjw9mz54NAIiKisKPP/6IgQMH4vr165gzZw4A4Ouvv8a4ceMQHByMSZMmwcHBATdu3MDBgwfx008/oXXr1gZ19u7dG23btjU45unpaZ4OMQzDMMwrRHJyMqZPnw5A9zApJ/777z9Mnz4dISEhqFChQuEGV8T48ssv0b17d3Tu3NnSoTAFSNGdRTMMwzBGpKSkwNbWFlZWVi/1trJqtRpqtdrSYRQIRf06uLq6om/fvvL7IUOGoGrVqli8eDFmzpwJlUqFmTNnokWLFvj999+Nzo+MjDQ69vrrrxvUyTAMwzAM8zKinFszloFHnmEYpohC3k8//fQTJk+ejLJly8LBwQEJCQnZekotWbIElSpVgr29PRo0aIBjx44hJCTE5JM3rVaLWbNmwcfHBxqNBm+99RZu3Lghfx4SEoJff/0VERERcopWTk/kUlNTMXr0aHh6esLZ2RkdO3bEvXv3jMqZ8pQiH4QjR46gXr16sLe3R61ateQ+7tixA7Vq1YJGo0FgYCD+/vtvo3qvXr2K7t27o2TJktBoNKhXrx5+/vlnk23/9ddf+OSTT+Dp6QlHR0d06dIFUVFRBmXPnj2LVq1awcPDA/b29qhYsSIGDBhgUMaUp9Tff/+NNm3awMXFBU5OTnjrrbdw8uTJQo0jtzg4OKBRo0ZISkpCVFQUoqOjkZCQgKZNm5os7+Xlla92GIZhGKY4k5aWhilTpiAwMBCurq5wdHREUFAQDh8+LJcJDw+XlcbTp0+X51vZeVWuXbsWPXr0AAC8+eabcnlxPvjnn3+iQYMG0Gg0qFSpEn788UejuuLi4vDxxx+jXLlysLOzQ+XKlTF37lyj9P7s2Lt3L4KDg+Hs7AwXFxfUr18fmzZtMihz6tQptG7dGq6urnBwcEBwcDD++usvgzLTpk2DSqXCjRs3EBoaihIlSsDV1RXvv/8+kpOT5XIqlQpJSUlYt26d3O/Q0FD58/v372PAgAHw9vaGnZ0dAgIC8MMPPxi09by5NWM5WCnFMAxTxJk5cyZsbW0xduxYpKamZpuyt2zZMowYMQJBQUEYPXo0wsPD0blzZ7i5ucHHx8eo/Jw5c2BlZYWxY8ciPj4eX331Fd59912cOnUKAPDZZ58hPj4e9+7dwzfffAMAcHJyem6sgwYNwoYNG9CnTx80adIEhw4dQrt27XLd1xs3bqBPnz4YMmQI+vbti6+//hodOnTA999/j08//RTDhg0DAMyePRs9e/bEtWvX5Cdbly9fRtOmTVG2bFlMnDgRjo6O2LJlCzp37ozt27ejS5cuBm2NHDkSbm5umDp1KsLDw/Htt99ixIgR2Lx5MwCdQqhly5bw9PTExIkTUaJECYSHh2PHjh3P7cPly5cRFBQEFxcXjB8/HjY2Nli+fDlCQkLwf//3f2jYsKFZ4nget27dglqtRokSJaDRaGBvb489e/Zg5MiRKFmyZI7nJycnIzo62uCYq6srbGxs8h0TwzAMw7xKJCQkYNWqVejduzc++OADJCYmYvXq1WjVqhVOnz6NOnXqwNPTE8uWLcOHH36ILl26oGvXrgCA2rVrm6yzWbNmGDVqFL777jt8+umnqF69OgDIr4BuLtW9e3cMHDgQ/fv3xw8//IDQ0FAEBgYiICAAgO7/8eDgYNy/fx9DhgxB+fLlcfz4cUyaNAkPHz7M0U907dq1GDBgAAICAjBp0iSUKFECf//9N/bt24c+ffoAAA4dOoQ2bdogMDAQU6dOhZWVFdasWYPmzZvj2LFjaNCggUGdPXv2RMWKFTF79mycP38eq1atgpeXF+bOnQsAWL9+PQYNGoQGDRpg8ODBAAA/Pz8AwOPHj9GoUSOoVCqMGDECnp6e2Lt3LwYOHIiEhAQjG4rczq0ZMyExDMMwRZLDhw9LAKRKlSpJycnJJj87fPiwJEmSlJqaKrm7u0v169eX0tPT5XJr166VAEjBwcFG51avXl1KTU2Vjy9cuFACIP3zzz/ysXbt2km+vr65ivfChQsSAGnYsGEGx/v06SMBkKZOnSofW7NmjQRAun37tnzM19dXAiAdP35cPrZ//34JgGRvby9FRETIx5cvX27Qf0mSpLfeekuqVauWlJKSIh/TarVSkyZNJH9/f6O23377bUmr1crHR48eLanVaikuLk6SJEnauXOnBEA6c+bMc/st9q1z586Sra2tdPPmTfnYgwcPJGdnZ6lZs2aFFocpgoODpWrVqklRUVFSVFSUdOXKFWnUqFESAKlDhw5yuSlTpkgAJEdHR6lNmzbSrFmzpHPnzhnVd/v2bQmAyX/Ka8EwDMMwxZ2MjAyDeZYkSdKTJ08kb29vacCAAfKxqKgoo7nE89i6dWu2/+/SXOro0aPyscjISMnOzk4aM2aMfGzmzJmSo6OjdP36dYPzJ06cKKnVaunOnTvZth8XFyc5OztLDRs2lJ49e2bwGc1ntFqt5O/vL7Vq1cpgjpOcnCxVrFhRatGihXxs6tSpEgCDMZEkSerSpYvk7u5ucMzR0VHq37+/UUwDBw6USpcuLUVHRxscf+eddyRXV1d5Hv28uTVjOTh9j2EYpojTv39/2NvbP7fM2bNnERMTgw8++MDAdPvdd9+Fm5ubyXPef/99gydDQUFBAHQqmvzw22+/AQBGjRplcDwvJuk1atRA48aN5fekKmrevDnKly9vdJxijY2NxaFDh9CzZ08kJiYiOjoa0dHRiImJQatWrRAWFob79+8btDV48GCoVCr5fVBQEDIzMxEREQEAKFGiBADgl19+QXp6eq7iz8zMxO+//47OnTujUqVK8vHSpUujT58++PPPP40k4oURh5KrV6/C09MTnp6eqF69OhYtWoR27doZSNqnT5+OTZs2oW7duti/fz8+++wzBAYG4vXXX8eVK1eM6hw8eDAOHDhg8O+1117Lc2wMwzAM86qiVqvleZZWq0VsbCwyMjJQr149nD9/vtDarVGjhjynA3QbkVStWtVgfrd161YEBQXBzc1NnjNFR0fj7bffRmZmJo4ePZpt/QcOHEBiYiImTpxo5KtJ85kLFy4gLCwMffr0QUxMjFx/UlIS3nrrLRw9etQoTXDo0KEG74OCghATE5Njap0kSdi+fTs6dOgASZIM+tOqVSvEx8cbjXdu5taM+eD0PYZhmCJOxYoVcyxDCxiVK1c2OG5tbZ2tD5RykQeAvHj15MmTfESpi8HKykqWUhNVq1bNdR1iTK6urgCAcuXKmTxOsd64cQOSJOHzzz/H559/brLuyMhIlC1bNtu2xP4HBwejW7dumD59Or755huEhISgc+fO6NOnT7a7BkZFRSE5Odlkn6tXrw6tVou7d+/K8vnCikNJhQoVsHLlSqhUKmg0Gvj7+5v0ierduzd69+6NhIQEnDp1CmvXrsWmTZvQoUMH/PvvvwYTT39/f7z99ts5ts0wDMMwxZl169Zh/vz5uHr1qsGDpdzM7fKLOK8AdHML5fwuLCwMly5dynbnXFObnBA3b94EANSsWTPbMmFhYQB0iz/ZER8fb/Dg9HnzIRcXl2zriYqKQlxcHFasWIEVK1aYLCP2pzDHn8k7vCjFMAxTxCmsJznZ7X4nSVKhtJcbsospp1jpadvYsWPRqlUrk2XFBbuc6lSpVNi2bRtOnjyJPXv2YP/+/RgwYADmz5+PkydP5uivlVsKOw5HR8c8LSC5uLigRYsWaNGiBWxsbLBu3TqcOnUKwcHBue8UwzAMwxRzNmzYgNDQUHTu3Bnjxo2Dl5cX1Go1Zs+eLS/sFAa5md9ptVq0aNEC48ePN1m2SpUqLxQDzcvmzZuHOnXqmCwjzl/yOy+ltvr27ZvtIpjo0cUqqaIFL0oxDMO8Avj6+gLQKYbefPNN+XhGRgbCw8OzNczMCWVaWW5i0Gq1uHnzpoFS6Nq1a/lqOy9QqpyNjU2BK3gaNWqERo0aYdasWdi0aRPeffdd/PTTTxg0aJBRWU9PTzg4OJjs89WrV2FlZWWk+iqMOAqKevXqYd26dXj48GGhtcEwDMMwryLbtm1DpUqVsGPHDoP51NSpUw3K5WWulZ/ypvDz88PTp0/zNWciRfy///5r9MBPLOPi4lKg8zJTfacdnzMzM1nF/ZLCnlIMwzCvAPXq1YO7uztWrlyJjIwM+fjGjRvznY4H6FQ28fHxuSrbpk0bAMB3331ncDynHVwKAi8vL4SEhGD58uUmF1CioqLyXOeTJ0+Mns7R077U1FST56jVarRs2RK7d+9GeHi4fPzx48fYtGkT3njjjedK0AsqjryQnJyMEydOmPxs7969APKWgskwDMMwjF75o/w//NSpU0b/5zo4OAAA4uLiclWvo6NjnsqbomfPnjhx4gT2799v9FlcXJzBXFKkZcuWcHZ2xuzZs5GSkmLwGfU1MDAQfn5++Prrr/H06VOjOvIzLwN0fRf7rVar0a1bN2zfvh3//vtvgbXFmA9WSjEMw7wC2NraYtq0aRg5ciSaN2+Onj17Ijw8HGvXroWfn1++n6oFBgZi8+bN+OSTT1C/fn04OTmhQ4cOJsvWqVMHvXv3xtKlSxEfH48mTZrgjz/+wI0bN16ka7lmyZIleOONN1CrVi188MEHqFSpEh4/fowTJ07g3r17uHjxYp7qW7duHZYuXYouXbrAz88PiYmJWLlyJVxcXNC2bdtsz/viiy9w4MABvPHGGxg2bBisra2xfPlypKam4quvvspzv/IbR25JTk5GkyZN0KhRI7Ru3RrlypVDXFwcdu3ahWPHjqFz586oW7fuC7fDMAzDMMWJ9u3bY8eOHejSpQvatWuH27dv4/vvv0eNGjUMFmrs7e1Ro0YNbN68GVWqVEHJkiVRs2bNbD2b6tSpA7Vajblz5yI+Ph52dnZo3ry5Sb/I7Bg3bhx+/vlntG/fHqGhoQgMDERSUhL++ecfbNu2DeHh4fDw8DB5rouLC7755hsMGjQI9evXR58+feDm5oaLFy8iOTkZ69atg5WVFVatWoU2bdogICAA77//PsqWLYv79+/j8OHDcHFxwZ49e/I2oNDNSw8ePIgFCxagTJkyqFixIho2bIg5c+bg8OHDaNiwIT744APUqFEDsbGxOH/+PA4ePIjY2Ng8t8WYD16UYhiGeUUYMWIEJEnC/PnzMXbsWLz22mv4+eefMWrUKKPdUXLLsGHDcOHCBaxZswbffPMNfH19s12UAoAffvgBnp6e2LhxI3bt2oXmzZvj119/zXfKWl6oUaMGzp49i+nTp2Pt2rWIiYmBl5cX6tatiylTpuS5vuDgYJw+fRo//fQTHj9+DFdXVzRo0AAbN258rkFmQEAAjh07hkmTJmH27NnQarVo2LAhNmzYIO8aaI44ckuJEiWwcuVK/Prrr1izZg0ePXoEtVqNqlWrYt68eUa7KTIMwzAMkzOhoaF49OgRli9fjv3796NGjRrYsGEDtm7diiNHjhiUXbVqFUaOHInRo0cjLS0NU6dOzXZRqlSpUvj+++8xe/ZsDBw4EJmZmTh8+HCeFqUcHBzwf//3f/jyyy+xdetW/Pjjj3BxcUGVKlUwffp0eUOZ7Bg4cCC8vLwwZ84czJw5EzY2NqhWrRpGjx4tlwkJCcGJEycwc+ZMLF68GE+fPkWpUqXQsGFDDBkyJNexKlmwYAEGDx6MyZMn49mzZ+jfvz8aNmwIb29vnD59GjNmzMCOHTuwdOlSuLu7IyAgAHPnzs1XW4z5UEmWdLRlGIZhChWtVgtPT0907doVK1eutHQ4DMMwDMMwDMMwMuwpxTAM84qQkpJi5D30448/IjY2FiEhIZYJimEYhmEYhmEYJhtYKcUwDPOKcOTIEYwePRo9evSAu7s7zp8/j9WrV6N69eo4d+4cbG1tLR0iwzAMwzAMwzCMDHtKMQzDvCJUqFAB5cqVw3fffYfY2FiULFkS/fr1w5w5c3hBimEYhmEYhmGYIgcrpRiGYRiGYRiGYRiGYRizw55SDMMwDMMwDMMwDMMwjNnhRSmGYRiGYRiGYRiGYRjG7PCiFMMwxZLTp0/D1tYWERERlg4FKpUKI0aMMGubR44cgUqlwpEjR+RjoaGhqFChglnjeFlQqVTyv6+//trS4bwSxMXFFYlxbdSoEcaPH2+RthmGYRiek/GcLG8UhblDbtm1a5dBvGfPnjV7DDExMXB0dMRvv/1m9rZzCy9KMQxTLPnss8/Qu3dv+Pr6ysdCQkIM/uMoWbIk6tevjx9++AFardaC0RZd/vvvP0ybNg3h4eGWDqXQ6dKlC9avX4927doZHJ81axY6duwIb29vqFQqTJs2LU/1pqamYsKECShTpgzs7e3RsGFDHDhwwKBMcnIylixZgpYtW6J06dJwdnZG3bp1sWzZMmRmZuaqnc2bN6Nv377w9/eHSqVCSEhInuIEIO/mqNFo4O/vj0WLFhmV2bFjB3r16oVKlSrBwcEBVatWxZgxYxAXF2dQztHREevXr8c333yT5zgKkgkTJmDJkiV49OiRReNgGIYprvCcrGDgOdmLzcnOnDmDESNGICAgAI6Ojihfvjx69uyJ69evmyyv1WqxbNky1KlTB/b29nB3d0fz5s1x8eJFuUy9evWwfv16DB48OF/9LAjc3d0xaNAgfP755xaLISd4UYphmGLHhQsXcPDgQQwdOtToMx8fH6xfvx7r16/H559/joyMDAwcOBCffvqpBSI1LytXrsS1a9fydM5///2H6dOnF4sJUO3atdG3b19Ur17d4PjkyZNx5swZ1K1bN1/1hoaGYsGCBXj33XexcOFCqNVqtG3bFn/++adc5tatWxg5ciQkScInn3yCr7/+GhUrVsSwYcMwYMCAXLWzbNky7N69G+XKlYObm1ue41y+fDkGDRqEgIAALFq0CI0bN8aoUaMwd+5cg3KDBw/GlStX0LdvX3z33Xdo3bo1Fi9ejMaNG+PZs2dyORsbG/Tt2xedO3fOcywFSadOneDi4oKlS5daNA6GYZjiCM/JTMNzsudTGHOyuXPnYvv27XjrrbewcOFCDB48GEePHsXrr7+Of//916j8gAEDMGrUKAQGBmLRokWYMmUKypcvj8jISLmMj48P+vbti8aNG+e9kwXI0KFDcf78eRw6dMiicWSLxDAMU8wYNWqUVL58eUmr1RocDw4OlgICAgyOJSUlST4+PpKjo6OUlpZWKPEAkIYPH14odWfH4cOHJQDS4cOHX6ierVu3Fkg9RR0A0tSpU01+dvv2bUmSJCkqKuq55Uxx6tQpCYA0b948+dizZ88kPz8/qXHjxvKxqKgo6d9//zU6//3335cASGFhYTm2defOHSkzM1OSJEkKCAiQgoODcx1ncnKy5O7uLrVr187g+Lvvvis5OjpKsbGx8jFT98K6deskANLKlSuNPrt9+7bRGJibESNGSL6+vka/ExiGYZjChedkPCfLK4U1J/vrr7+k1NRUg2PXr1+X7OzspHfffdfg+ObNmyUA0o4dO3JV95o1ayQA0pkzZ3IdT0FTs2ZN6b333rNY+8+DlVIMwxQ7du3ahebNm0OlUuVY1sHBAY0aNUJSUhKioqIA6LxwPv74Y5QrVw52dnaoXLky5s6dayQn//rrr9GkSRO4u7vD3t4egYGB2LZtW65i/OKLL2BlZWWQHrVo0SIEBATAwcEBbm5uqFevHjZt2pRjXffu3UPnzp3h6OgILy8vjB49GqmpqUblTPkX/PTTTwgMDISzszNcXFxQq1YtLFy4EACwdu1a9OjRAwDw5ptvyhJ78kTYvXs32rVrhzJlysDOzg5+fn6YOXOmUbpZSEgIatasif/++w9vvvkmHBwcULZsWXz11VdGMaakpGDatGmoUqUKNBoNSpcuja5du+LmzZtyGa1Wi2+//RYBAQHQaDTw9vbGkCFD8OTJE4O64uPjcfXqVcTHx+c4hs/jRTwftm3bBrVabSDr1mg0GDhwIE6cOIG7d+8CADw8PBAQEGB0fpcuXQAAV65cybGtcuXKwcoqf//tHz58GDExMRg2bJjB8eHDhyMpKQm//vqrfMxUWmBe4gR096KTkxPu37+Pzp07w8nJCZ6enhg7dqzB/RMeHi57SixZskROGWzZsiXu3r0LSZIwc+ZM+Pj4wN7eHp06dUJsbKxRey1atEBERAQuXLiQq/gYhmGYgoHnZDwnA4rGnKxJkyawtbU1OObv74+AgACj+cuCBQvQoEEDdOnSBVqtFklJSfmKtX379vjzzz/RoEEDaDQaVKpUCT/++KNBubVr10KlUuHPP//EqFGj4OnpiRIlSmDIkCFIS0tDXFwc+vXrBzc3N7i5uWH8+PGQJMmovRYtWmDPnj0mP7M0vCjFMEyx4v79+7hz5w5ef/31XJ9z69YtqNVqlChRAsnJyQgODsaGDRvQr18/fPfdd2jatCkmTZqETz75xOC8hQsXom7dupgxYwa+/PJLWFtbo0ePHgZ/wJti8uTJmDJlCpYvX46RI0cC0Mm4R40ahRo1auDbb7/F9OnTUadOHZw6deq5dT179gxvvfUW9u/fjxEjRuCzzz7DsWPHcmXsfODAAfTu3Rtubm6YO3cu5syZg5CQEPz1118AgGbNmmHUqFEAgE8//VSW2JOUeu3atXBycsInn3yChQsXIjAwEFOmTMHEiRON2nry5Alat26N1157DfPnz0e1atUwYcIE7N27Vy6TmZmJ9u3bY/r06QgMDMT8+fPx0UcfIT4+3kBWPWTIEIwbNw5NmzbFwoUL8f7772Pjxo1o1aoV0tPT5XI7d+5E9erVsXPnzhzHorD4+++/UaVKFbi4uBgcb9CgAQDkuEhCPkgeHh6FEh/x999/A9B5IygJDAyElZWV/Hl25CfOzMxMtGrVCu7u7vj6668RHByM+fPnY8WKFUZlN27ciKVLl2LkyJEYM2YM/u///g89e/bE5MmTsW/fPkyYMAGDBw/Gnj17MHbsWKPzAwMDAUC+txmGYZjCh+dkPCcjisKczBSSJOHx48cG85eEhAScPn0a9evXx6effgpXV1c4OTmhUqVK2LJlS57qv3HjBrp3744WLVpg/vz5cHNzQ2hoKC5fvmxUduTIkQgLC8P06dPRsWNHrFixAp9//jk6dOiAzMxMfPnll3jjjTcwb948rF+/3uj8wMBAxMXFmazb4lhWqMUwDGNeDh48KAGQ9uzZY/RZcHCwVK1aNSkqKkqKioqSrly5Io0aNUoCIHXo0EGSJEmaOXOm5OjoKF2/ft3g3IkTJ0pqtVq6c+eOfCw5OdmgTFpamlSzZk2pefPmBsehkIqPGTNGsrKyktauXWtQplOnTkYy9tzw7bffSgCkLVu2yMeSkpKkypUrG0m8+/fvL/n6+srvP/roI8nFxUXKyMjItv7nScXF/kuSJA0ZMkRycHCQUlJS5GPBwcESAOnHH3+Uj6WmpkqlSpWSunXrJh/74YcfJADSggULjOol2f+xY8ckANLGjRsNPt+3b5/RcZJSr1mzJtv+EciFBDw/UvGAgACj+0GSJOny5csSAOn777/P9tzU1FSpRo0aUsWKFaX09PRct0nt5iV9b/jw4ZJarTb5maenp/TOO+889/yBAwdKarXa6HsjSabT9/r37y8BkGbMmGFQtm7dulJgYKDRuZ6enlJcXJx8fNKkSRIA6bXXXjMYm969e0u2trYG9x9ha2srffjhh8/tB8MwDFNw8JyM52REUZiTmWL9+vUSAGn16tXysfPnz0sAJHd3d8nb21taunSptHHjRqlBgwaSSqWS9u7da1SPqfQ9X19fCYB09OhR+VhkZKRkZ2cnjRkzxujcVq1aGaS5Nm7cWFKpVNLQoUPlYxkZGZKPj4/JOd7x48clANLmzZvzPR6FBSulGIYpVsTExABAtkbPV69ehaenJzw9PVG9enUsWrQI7dq1ww8//AAA2Lp1K4KCguDm5obo6Gj539tvv43MzEwcPXpUrsve3l7++cmTJ4iPj0dQUBDOnz9v1K4kSRgxYgQWLlyIDRs2oH///gaflyhRAvfu3cOZM2fy1N/ffvsNpUuXRvfu3eVjDg4OudoFpESJEkhKSjLaCS63KPufmJiI6OhoBAUFITk5GVevXjUo6+TkhL59+8rvbW1t0aBBA9y6dUs+tn37dnh4eMhPKpWQ7H/r1q1wdXVFixYtDK5PYGAgnJyccPjwYfmc0NBQSJKE0NDQfPWvIHj27Bns7OyMjms0Gvnz7BgxYgT+++8/LF68GNbW1oUWI8UhStoJjUbz3Dg3bdqE1atXY8yYMfD3989Tu6LxbVBQkME9QfTo0QOurq7y+4YNGwIA+vbtazA2DRs2RFpaGu7fv29UB32nGYZhGPPAczKekxFFYU4mcvXqVQwfPhyNGzc2uAeePn0KQHf/7t69Gx9++CH69OmDP/74A+7u7vjiiy9y3UaNGjUQFBQkv/f09ETVqlVNznUGDhxokObasGFDSJKEgQMHysfUajXq1atn8nz6nhXFuU7hzmIZhmGKKFI2+dQVKlTAypUroVKp5G3vvby85M/DwsJw6dIleHp6mjxfuePGL7/8gi+++AIXLlww8Asw5Zvw448/4unTp1i2bBl69+5t9PmECRNw8OBBNGjQAJUrV0bLli3Rp08fNG3a9Ln9jIiIQOXKlY3arFq16nPPA4Bhw4Zhy5YtaNOmDcqWLYuWLVuiZ8+eaN26dY7nAsDly5cxefJkHDp0CAkJCQafiZ4BPj4+RjG6ubnh0qVL8vubN2+iatWqz12ACQsLQ3x8vME1U6K8PkUBe3t7k14SKSkp8uemmDdvHlauXImZM2eibdu2hRojxZGWlmbys5SUlGzjPHbsGAYOHIhWrVph1qxZeWpTo9EYfc/c3NyMfCgAoHz58gbvaYGqXLlyJo+bqkOSpFx5mjAMwzAFC8/JeE5W1Hj06BHatWsHV1dX2f+ToDlPxYoV5YdggG4xr0OHDtiwYQMyMjJy9cBQnL8ABTPXyW6eA5i+5y0NL0oxDFOscHd3B2D6j1IAcHR0xNtvv53t+VqtFi1atMg2/79KlSoAdH+Md+zYEc2aNcPSpUtRunRp2NjYYM2aNSaNMJs2bYoLFy5g8eLF6NmzJ0qWLGnwefXq1XHt2jX88ssv2LdvH7Zv346lS5diypQpmD59eq76nle8vLxw4cIF7N+/H3v37sXevXuxZs0a9OvXD+vWrXvuuXFxcQgODoaLiwtmzJgBPz8/aDQanD9/HhMmTDAyIFX+Z68ku4lqdmi1Wnh5eWHjxo0mP89u4mopSpcubVK18/DhQwBAmTJljD5bu3YtJkyYgKFDh2Ly5MmFHiOgizMzMxORkZEGk8u0tDTExMSYjPPixYvo2LEjatasiW3btuVZzZXdPZGXsnm5r+Li4grdm4thGIbRw3Oy3MNzMvMRHx+PNm3aIC4uDseOHTOa49B7b29vo3O9vLyQnp6OpKQkAwV3duRlrPMy1zF1Pn3PiuJchxelGIYpVlSrVg0AcPv27Xyd7+fnh6dPnz53kgToZM0ajQb79+83SM9as2aNyfKVK1fGV199hZCQELRu3Rp//PEHnJ2dDco4OjqiV69e6NWrF9LS0tC1a1fMmjULkyZNktO9RHx9ffHvv/8aqUCuXbuWq/7a2tqiQ4cO6NChA7RaLYYNG4bly5fj888/N/m0jzhy5AhiYmKwY8cONGvWTD6e33EHdGN/6tQppKenw8bGJtsyBw8eRNOmTbNV7xQl6tSpg8OHDyMhIcHA7JzMUuvUqWNQfvfu3Rg0aBC6du2KJUuWmDVOADh79qyBMuvs2bPQarVGcd68eROtW7eGl5cXfvvtNzg5OZkt1vxw//59pKWlyYawDMMwTOHDczIdPCcrOqSkpKBDhw64fv06Dh48iBo1ahiVKVOmDEqVKmXyoeKDBw+g0WiM7peiAF3vojjXYU8phmGKFWXLlkW5cuVw9uzZfJ3fs2dPnDhxAvv37zf6LC4uDhkZGQB0Ty1UKpXR9vW7du3Ktu7atWvjt99+w5UrV9ChQwcDnx7yXSBsbW1Ro0YNSJJksHuJSNu2bfHgwQODbY+Tk5NN7mAmIrZpZWWF2rVrA4AsfXd0dASg67sSemqjfFKTlpaGpUuX5thudnTr1g3R0dFYvHix0WfUTs+ePZGZmYmZM2calcnIyDCIs6C2H84t0dHRuHr1KpKTk+Vj3bt3R2ZmpsH1SE1NxZo1a9CwYUMDSfbRo0fxzjvvoFmzZti4cSOsrArnv3Dyl1B6DjRv3hwlS5bEsmXLDMouW7YMDg4OaNeunXzs0aNHaNmyJaysrLB///4i+yRUyblz5wDotoNmGIZhzAPPyXhORhSFOVlmZiZ69eqFEydOYOvWrWjcuHG25/fq1Qt379418PiKjo7G7t270bx580Kbo70I586dg6urKwICAiwdihGslGIYptjRqVMn7Ny5M18eMuPGjcPPP/+M9u3bIzQ0FIGBgUhKSsI///yDbdu2ITw8HB4eHmjXrh0WLFiA1q1bo0+fPoiMjMSSJUtQuXJlg5x8kUaNGmH37t1o27Ytunfvjl27dsHGxgYtW7ZEqVKl0LRpU3h7e+PKlStYvHgx2rVr99ynMR988AEWL16Mfv364dy5cyhdujTWr18PBweHHPs6aNAgxMbGonnz5vDx8UFERAQWLVqEOnXqyE9Z6tSpA7Vajblz5yI+Ph52dnZo3rw5mjRpAjc3N/Tv3x+jRo2CSqXC+vXr8yz9VtKvXz/8+OOP+OSTT3D69GkEBQUhKSkJBw8exLBhw9CpUycEBwdjyJAhmD17Ni5cuICWLVvCxsYGYWFh2Lp1KxYuXCgbjO7cuRPvv/8+1qxZ80LGmuvXr0dERIQ8sTl69Khscvnee+/B19cXALB48WJMnz4dhw8fRkhICACdSWWPHj0wadIkREZGonLlyli3bh3Cw8OxevVquY2IiAh07NgRKpUK3bt3x9atWw1iqF27tjw5zY6jR4/Kpq9RUVFISkqS42zWrJn89PT06dN48803MXXqVEybNg2Azj9h5syZGD58OHr06IFWrVrh2LFj2LBhA2bNmmWQ2tC6dWvcunUL48ePx59//ok///xT/szb2xstWrTI0/iagwMHDqB8+fKoW7eupUNhGIYpVvCcjOdkQNGYk40ZMwY///wzOnTogNjYWGzYsMGgbqX5+6RJk7BlyxZ069YNn3zyCVxdXfH9998jPT0dX375Zb7jL0wOHDiADh06FElPKZhrmz+GYZiiAm3leuzYMYPjwcHBudriNzExUZo0aZJUuXJlydbWVvLw8JCaNGkiff3111JaWppcbvXq1ZK/v79kZ2cnVatWTVqzZo00depUSfzVC8X2w8Tu3bsla2trqVevXlJmZqa0fPlyqVmzZpK7u7tkZ2cn+fn5SePGjZPi4+NzjDciIkLq2LGj5ODgIHl4eEgfffSRvB3v87Yf3rZtm9SyZUvJy8tLsrW1lcqXLy8NGTJEevjwoUH9K1eulCpVqiSp1WqDOv/66y+pUaNGkr29vVSmTBlp/Pjx0v79+43azW7cxXgkSbel8WeffSZVrFhRsrGxkUqVKiV1795dunnzpkG5FStWSIGBgZK9vb3k7Ows1apVSxo/frz04MEDuUxBbT9M2yeb+qfsJ117cavmZ8+eSWPHjpVKlSol2dnZSfXr15f27dtnUObw4cPZtvG82JRQ+zmdT22ZqnPFihVS1apVJVtbW8nPz0/65ptvDLYnprHK7p+pLYpv374tAZDmzZsnH+vfv7/k6OiYbR+ed66yD1u3bjU4bmpL5szMTKl06dLS5MmTTY4bwzAMU3jwnIznZJJUNOZkzzvX1LLJzZs3pS5dukguLi6Svb291Lx5c+n06dMm4zI1//D19ZXatWtnsg/K+ZKpc5V9iIqKMjhuag515coVCYB08OBBk/FZGpUkvcASKcMwzEvKW2+9hTJlymD9+vWWDoV5CVCpVBg3bhzGjx8PR0fHl8YboSgjSRJiYmJw9+5dvP7665g3bx7Gjh1r9jh27dqFPn364ObNmyhdurTZ22cYhinu8JyMyQsv05wsLS0NCQkJ+OmnnzBy5EicOXMG9erVM3scH3/8MY4ePYpz584VSaVU0Ut2ZBiGMQNffvklNm/ejIiICEuHwrwkzJs3D56enmY1GH+ViY+Ph6enJ15//XWLxjF37lyMGDGCF6QYhmEsBM/JmLzysszJfvvtN3h6emLkyJEWiyEmJgarVq3CF198USQXpACAlVIMwzAMkwMHDx6Uf65SpQrKly9vwWheDTIyMnDkyBH5PY8rwzAMwzA58TLNyaKionDx4kX5fcOGDYvkznyWhhelGIZhGIZhGIZhGIZhGLPD6XsMwzAMwzAMwzAMwzCM2eFFKYZhGIZhGIZhGIZhGMbs8KIUwzAMwzAMwzAMwzAMY3asLR0AwzDMi6DVavHgwQM4OzsX2R0lGIZ5eZEkCYmJiShTpgysrPhZHsMwrw48h2IYpjDJ7RyKF6UYhnmpefDgAcqVK2fpMBiGecW5e/cufHx8LB0GwzBMgcFzKIZhzEFOcyhelGIY5qWGtlW9e/cuXFxcLBwNwzCvGgkJCShXrhxv4cwwzCsHz6EYhilMcjuH4kUphmFeakhu7uLiwhMqhmEKDU5tYRjmVYPnUAzDmIOc5lBsjsAwDMMwDMMwDMMwDMOYHV6UYhiGYRiGYRiGYRiGYcwOL0oxDMMwDMMwDMMwDMMwZocXpRiGYRiGYRiGYRiGYRizw4tSDMMwDMMwDMMwDMMwjNnhRSmGYRiGYRiGYRiGYRjG7PCiFMMwDMMwDMMwDMMwDGN2eFGKYRiGYRiGYRiGYRiGMTu8KMUwDMMwDMMwDMMwDMOYHV6UYhiGYRiGYRiGYRiGYcwOL0oxDMMwDMMwDMMwDMMwZocXpRiGYRiGYRiGYRiGYRizw4tSDMMwTLElJT0TkiRZOgyGYRiGYRjGzGi1EtIytJYOo9jDi1IMwzBMsSQyMQX1vziIMVsuWjoUhmEYhmEYxoxkaiW0WXgMLb/5PzxJSrN0OMUaXpRiGIZhiiXXHiUiMTUD5+88sXQoDMMwDMMwjBn59348rj1ORHhMMqb+fNnS4RRreFGKYRiGKZYkpWYAADK0nL7HMAzDMAxTnDhxK0b++eeLD7D3n4cWjKZ4w4tSDMMwTLEkKTUTAJCRyYtSDMMwDMMwxYkTN3WLUr7uDgCAybv+RczTVEuGVGzhRSmGYRimWJKcxkophmEYhmGY4kZ6phZnwmMBAIt610W1Us6ISUrDFE7jswi8KMUwDMMUS56SUkrLu64wDMMwDMMUFy7di0NyWibcHGxQs4wrvu7xGtRWKvx66SF+ufTA0uEVO3hRimEYhimWyEopTt9jGIZhGIYpNhy/oUvda+znDisrFWqWdcXwNysDAD7f9S+iEjmNz5zwohTDMAxTLElipRTDMAzDMEyxg0zOG1dyl4+NeLMyqpd2wZPkdEze9Q8kiR9amgtelHrFmDZtGlQqFaKjoy0dSqFw5MgRqFQqHDlypMDqpDFjGKZ4wUophmEYhmEKixuRifJOv0zRISU9E+cingAAGvt5yMdtra0wv8drsLZSYf/lx/j5IqfxmQtelMqGvn37QqPR4Pr160afzZkzByqVCr/88gt++uknqFQqLF++3GQ9H374IWxsbHDx4sXCDpkpZEJDQ6FSqeR/Li4ueO211zB//nykphpKPP/880+0adMGZcuWhUajQfny5dGhQwds2rTJoJyyPuW/UqVKmbNrDFMseZqqNzrnp2EMwzAMwxQUP54Ix9sLjmLsVv4bsKjx9504pGZo4elsBz9PR4PPapRxwai3/AEAU3ZfRmRCiiVCLHZYWzqAosqCBQvw22+/YejQoTh06JB8/Pbt25gxYwa6deuG9u3bAwDWrVuHiRMnonPnzvD29pbLnj59GitWrMCYMWPw2muvmb0PTMFjZ2eHVatWAQDi4uKwfft2jB07FmfOnMFPP/0EANi6dSt69eqFOnXq4KOPPoKbmxtu376No0ePYuXKlejTp49BnS1atEC/fv0Mjtnb25unQwxTjElOy5R/ztRKsFazYpJhGIZhmBfj4H+PMS1rFzfa4Y0pOihT90xly3wY4off/3uEf+8n4NOd/2Jlv0DOqilkeFEqG7y8vDB37lwMHjwY69atQ//+/QEAw4YNg42NDRYuXCiXXbZsGQICAjB69GhZCZOZmYkhQ4agfPnymDZtmiW6wBQC1tbW6Nu3r/x+2LBhaNiwITZv3owFCxagTJkymDZtGmrUqIGTJ0/C1tbW4PzIyEijOqtUqWJQJ8Mw5kEpqc/QSrBWWzAYhmEYhmFeev65F4+R//sb2iwBdvTTNMQmpaGko+3zT2TMxsmbukWpJn7uJj+3UVvh6x6vocOiP3HwymPsunAfXer6mDPEYgen7z2HQYMGoWnTphg7dixiYmLw008/Yd++ffjiiy9QtmxZuVyFChUwbdo0/O9//8OBAwcAAN999x0uXLiAZcuWwcHB4bnthIWFoVu3bihVqhQ0Gg18fHzwzjvvID4+HgAQHh4OlUqFtWvXGp2rUqlMLnpFR0ejZ8+ecHFxgbu7Oz766COkpBjKDw8cOIA33ngDJUqUgJOTE6pWrYpPP/1U/jwtLQ1TpkxBYGAgXF1d4ejoiKCgIBw+fNigHorv66+/xpIlS1CpUiU4ODigZcuWuHv3LiRJwsyZM+Hj4wN7e3t06tQJsbGGTw0qVKiA9u3b4/fff0edOnWg0WhQo0YN7Nix47ljR5w6dQqtW7eGq6srHBwcEBwcjL/++suo3J9//on69etDo9HAz88v27TL3GJlZYWQkBB5HADg5s2bqF+/vtGCFKBb7GQYpmiQlGa4KMUwDMMwDJNf7j1JxoB1Z/AsPRPNqniijKsGAHAj8qmFI2OIZ2mZ+Psu+UmZXpQCgGqlXPDx21UAAFN3X8ZjTuMrVFgp9RzIK6pu3br48MMPcezYMdSrVw/Dhw83Kjt69Ghs3LgRH374Ifbt24cpU6bgnXfeQevWrZ/bRlpaGlq1aoXU1FSMHDkSpUqVwv379/HLL78gLi4Orq6u+Yq9Z8+eqFChAmbPno2TJ0/iu+++w5MnT/Djjz8CAC5fvoz27dujdu3amDFjBuzs7HDjxg2DhZyEhASsWrUKvXv3xgcffIDExESsXr0arVq1wunTp1GnTh2DNjdu3Ii0tDSMHDkSsbGx+Oqrr9CzZ080b94cR44cwYQJE3Djxg0sWrQIY8eOxQ8//GBwflhYGHr16oWhQ4eif//+WLNmDXr06IF9+/ahRYsW2fb10KFDaNOmDQIDAzF16lRYWVlhzZo1aN68OY4dO4YGDRoAAP755x+0bNkSnp6emDZtGjIyMjB16lSDlMv8cPPmTQCAu7vuF5uvry/++OMP3Lt3Dz4+Oa+qp6SkGBnTOzs7w87O7oXiYhjm+SSn6tP3MjJ5Bz6GYRiGYfJH/LN0vL/mDKISU1G9tAuWvvs6Rm46jwfxKQiLTESDiiUtHSID4GxELNIzJZRx1aB8yecLR4Y0q4T9lx/h0r14TNrxD1b3r8dpfIUEL0rlQEBAAMaOHYvZs2dDrVbj119/hZWVscDM2toaK1asQOPGjdGwYUNYW1vj22+/zbH+//77D7dv38bWrVvRvXt3+fiUKVNeKO6KFSti9+7dAIDhw4fDxcUFS5cuxdixY1G7dm0cOHAAaWlp2Lt3Lzw8PEzW4ebmhvDwcAPFzwcffIBq1aph0aJFWL16tUH5+/fvIywsTF5Iy8zMxOzZs/Hs2TOcPXsW1ta62y0qKgobN27EsmXLDBZerl+/ju3bt6Nr164AgIEDB6JatWqYMGFCtotSkiRh6NChePPNN7F37175F8WQIUMQEBCAyZMn4/fffwegG1NJknDs2DGUL18eANCtWzfUqlUrT2NLC0jx8fHYsmULdu3ahdq1a6Nq1aoAgAkTJmDgwIHw8/ND06ZN8cYbb6Bly5Zo0qSJyXtn9erVRmO5Zs0ahIaG5ikuhmHyhlIplc478DEMwzAMkw/SMrT4cMM5hEU+RSkXDX4IrQcnO2v4ezvj8LUohD1mpVRR4URW6l5jP48cF5is1brd+Np99ycOXY3EtnP30KNeOXOEWezg9L1cQIs2ZcqUQc2aNbMt16BBAwwdOhSxsbGYPXt2rhQ4tICzf/9+JCcnF0zAgJGaa+TIkQCA3377DQBQokQJAMDu3buh1ZpWCKjVanlBSqvVIjY2FhkZGahXrx7Onz9vVL5Hjx4Gyq6GDRsC0O1kSAtSdDwtLQ337983OL9MmTLo0qWL/N7FxQX9+vXD33//jUePHpmM8cKFCwgLC0OfPn0QExOD6OhoREdHIykpCW+99RaOHj0KrVaLzMxM7N+/H507d5YXpACgevXqaNWqlcm6TZGUlARPT094enqicuXK+PTTT9G4cWPs3LlTLjNgwADs27cPISEh+PPPPzFz5kwEBQXB398fx48fN6qzU6dOOHDggMG/vMTEMEz+SEo1NDpnGIZhGIbJC5IkYdKOf3D8ZgwcbdX4IbQ+SrvqNiyq7OUEAAiLTLRkiIyC4/KiVPape0r8vZ0xuoUujW/Gnv/wMP5ZocVWnOFFqRy4e/cupk6dipo1a+Lu3bv46quvnlu+fv36AIB69erlqv6KFSvik08+wapVq+Dh4YFWrVphyZIlsp9UfvH39zd47+fnBysrK9n3qFevXmjatCkGDRoEb29vvPPOO9iyZYvRAtW6detQu3ZtaDQauLu7w9PTE7/++qvJ+JSLPYB+wa1cuXImjz958sTgeOXKlY1WrKtU0f0SoLhFwsLCAAD9+/eXF4vo36pVq5Camor4+HhERUXh2bNnRuMCQFY45QaNRiMvHB09ehR3797FX3/9hUqVKhmUa9WqFfbv34+4uDgcPXoUw4cPR0REBNq3b29kdu7j44O3337b4F/p0qVzHRPDMHlHkiRBKcXpewzDMAzD5I3v/riB7efvQW2lwpJ3X0eNMi7yZ/60KMVKqSLB09QM/HNf9zdsbhelAOCDoIqoU64EElMzMGH7P5AkfpBZ0PCiVA6MGDECALB371706NEDs2bNwq1btwq0jfnz5+PSpUv49NNP8ezZM4waNQoBAQG4d+8eAGQrLczMzDR53BRiHfb29jh69CgOHjyI9957D5cuXUKvXr3QokULud4NGzYgNDQUfn5+WL16Nfbt24cDBw6gefPmJtVVarXprauyO14QX2iKY968eUZqI/rn5OT0wu0QarVaXjgKCgrK0TPKwcEBQUFBWLx4MSZPnownT55g7969BRYPwzD5IyVdC+WvIDY6ZxiGYRgmL2w/dw/fHLwOAJjZqSZCqhpuaERKqcjEVMQnp5s9PsaQM7djkamV4OvugLIl7HN9nnXWbny21lY4ej0KW87eLcQoiye8KPUcdu7ciZ9//lneOe7bb7+Fra2tSaPzF6VWrVqYPHkyjh49imPHjuH+/fv4/vvvAei8nQAgLi7O4JyIiIhs6yMFEXHjxg1otVpUqFBBPmZlZYW33noLCxYswH///YdZs2bh0KFD8u5627ZtQ6VKlbBjxw689957aNWqFd5++22jXfwKihs3bhgtVF2/rvtFr4xbiZ+fHwBdqp+oNqJ/NjY28PT0hL29vdG4AMC1a9cKtiPZQOq5hw8fmqU9hmGy52lqhsH7zGzSmBmGYRiGYUSO34zGxB2XAAAfhvihT8PyRmWcNTb6HfiiOIXP0hy/qfMFblwp9yoporKXE8a11GXXzPzlCu7HcRpfQcKLUtmQmJiIUaNGoW7durIfU5kyZTBz5kzs27cPW7duLZB2EhISkJFh+MdRrVq1YGVlhdTUVAC6BRcPDw8cPXrUoNzSpUuzrXfJkiUG7xctWgQAaNOmDQAgNjbW6BzaTY/aJYWTcqHo1KlTOHHiRI79yg8PHjww8GZKSEjAjz/+iDp16qBUqVImzwkMDISfnx++/vprPH1qLI2NiooCoOtLq1atsGvXLty5c0f+/MqVK9i/f3+B9uOPP/4weZz8vPKSLsgwTOGQnGb4e5eNzhmGYRiGyQ1hjxMxZP05pGdKaF+7tLxYYYrK3s5Z53AKn6U5cStvflIiA96oiEBfNzxNzcCEbZc4ja8A4d33smHy5Ml48OABduzYYZB+Nnz4cKxbtw4ff/wxWrduDWdn5xdq59ChQxgxYgR69OiBKlWqICMjA+vXr4darUa3bt3kcoMGDcKcOXMwaNAg1KtXD0ePHpVVRKa4ffs2OnbsiNatW+PEiRPYsGED+vTpg9deew0AMGPGDBw9ehTt2rWDr68vIiMjsXTpUvj4+OCNN94AALRv3x47duxAly5d0K5dO9y+fRvff/89atSoYXIB6EWpUqUKBg4ciDNnzsDb2xs//PADHj9+jDVr1mR7jpWVFVatWoU2bdogICAA77//PsqWLYv79+/j8OHDcHFxwZ49ewAA06dPx759+xAUFIRhw4YhIyMDixYtQkBAAC5dulRg/ejUqRMqVqyIDh06wM/PD0lJSTh48CD27NmD+vXro0OHDgXWFsMw+UNpcg6w0TnDMAzDMDkTmZiC0DVnkJiSgXq+bvi6x2uwssp+Fzd/LyccvR6F67woZVHiktNw+UECgPwppQBAbaXCvO610WbhMfx5IxqbTt/Buw19CzLMYgsvSpng3LlzWLJkCYYNGyYblxNqtRrff/89GjVqhMmTJ2PhwoUv1NZrr72GVq1aYc+ePbh//z4cHBzw2muvYe/evWjUqJFcbsqUKYiKisK2bduwZcsWtGnTBnv37oWXl5fJejdv3owpU6Zg4sSJsLa2xogRIzBv3jz5844dOyI8PBw//PADoqOj4eHhgeDgYEyfPl02Ig8NDcWjR4+wfPly7N+/HzVq1MCGDRuwdetWHDly5IX6bQp/f38sWrQI48aNw7Vr11CxYkVs3rw5x53oQkJCcOLECcycOROLFy/G06dPUapUKTRs2BBDhgyRy9WuXRv79+/HJ598gilTpsDHxwfTp0/Hw4cPC3RRatWqVdi9eze2bNmCBw8eQJIkVKpUCZ999hkmTJhgsBMhwzCWIclIKcXpewzDMAzDZE9yWgYGrTuL+3HPUNHDESv61YPGxrR3LuHPO/AVCU7djoUkAX6ejvBy0eS7nkqeThjfuhpm/vIfZv16Bc38PVGupEMBRlo8UUmsO2OKABUqVEDNmjXxyy+/WDoU5iUjISEBrq6uiI+Ph4uLS84nMAyAI9ciEbrmjPx+69DGqF+hpAUjYooq/DuGYZhXFf79lnsytRKGbjiHA/89hpuDDXYOa4oKHo45nncuIhbdlp1AaVcNTkx6ywyRMqaY9vNlrD0ejr6NyuOLzrVeqC6tVsI7K07idHgsmvi5Y9MHjXI+qZiS298x7CnFMAzDFDuS0wzT9zLYU4phGIZhmGz44tf/cOC/x7C1tsKq/vVytSAFAJU9dVYvD+NTkJjCO/BZihM3dX5STfw8XrguKysVvupeG1Yq4PjNGEQmFs4mYMUJXpRiGIZhih3i7nsZvPsewzAMwzAm+OHP21jzVzgA4JuedRDom3tltauDDbyc7QAANyLZV8oSxDxNxbXHuvTJRvn0kxKp4OEIZ40NACDhWUYOpZmc4EUphmEYptiRLC5KsVKKYRiGYRiB/ZcfYeav/wEAJrWphna1S+e5jiq0Ax8vSlmEk7d0u85XK+WMko62BVavk53OJ1h80MnkHXZcZooE4eHhlg6BYZhiRJKYvse77zEMwzAMoyAiJgkf/fQ3JAl4t2F5DG5WKV/1VPZywp83ohH2mM3OLcHxm9EAgMZ+BaOSIpw1uqWUJF6UemFYKcUwDMMUO5LTRKUUp+8xDMMwDKPn6PUopKRr8Vq5EpjeMQAqlSpf9fh70w58rJSyBCdu6fykGhdQ6h7hmKWUSkzhRakXhRelGIZhGLOTqZVw+nasxZ4uJaWyUophGIZhmOyJiEkGANT3dYO1Ov9/Nvt7ZaXvPeZFKXPzOCEFt6KSYKUCGhbwohSn7xUcuUrf02q1ePDgAZydnfO9QswwDJMdkiQhMTERZcqUgZUVr5UXB/ZffoRhG88jtEkFTOsYYPb2xcUwNjpnGIZhGEZJRKxuUcrX3eGF6vH30iml7sc9Q1JqhqywYQof2nUvoIwrXO1tCrRuWpTi9L0XJ1ffiAcPHqBcuXKFHQvDMMWcu3fvwsfHx9JhMGbgbtZE796TZIu0nyx4SqWz0TnDMAzDMAoiYpIAAOXdHV+oHjdHW3g42SL6aRpuRj1FbZ8SBRAdkxtoUaqg/aQAVkoVJLlalHJ21kkO27dvD1dXVwBAYqLOqC0tLU1fmbVhdcrPlJ+TEiIzM9PgFYCsxKIyNja6FU21Wg0ASE9PN6hba+LpNp1L7UmSZNCOg4PxavfTp6bllFQXtU+vhDJ2MRZRVUbnmlKb0WcUK9VF/aVxcHTU/VK0tdXvHPDs2TMAQHKy7o+7jAzDL4YYl9in5/WLYqU6KD56VUIx2tnptj2l8ae6UlNTTcanbEeMg/qvHOcXRanEoZ8pZnql/lK7dL8pYxevlTiu9J7KiWOprJ8+ozGjsaT2xHtYWY/YPt3fdI/Qva2MndqhMmKsNO7ZfQ+V7aakpBjUT8fpHOW9KqKsY//+/fLvGubVhxaFnqUX3Hc7L4gTiExO32MYhmEYJgtJknCHlFIlX0wpBehS+KKfxiDsMS9KmZPjtwrH5BwAnDTsKVVQ5GpRiv5g1mg08PLyMviMFkIAoEyZMgD0fxTTjmr0xyodd3FxAQBER0cbfA4Y/7FcokQJuW1A/8cyLcTExcUZxUsLZ/THMr3SwkLlypUN6gB0ajAASEhIMIiD6qI/lumVxiQpKUmug9qhOuiPcvpDnxY8nJx0Ek7l4ggtNlH/aFwfP35s8HnZsmUBAB4eHvK5VCYmRrcSTAsXtIBA78WFLnt7e7kOugYUM0FlqW8UM11DZTviopu4gEULmVSXEhpv6h+Ne2ysbgvP+Ph4AKYXtsRFGXpP8dB403Hldc+uXRpLur5UN7Wv/JnGl64RvadzqV26ZsrFWnGxh+Kh+53Giu4H5f0mLthRjBUqVACgv77ivQ0A7u7uBmUoJrp24sIhxaW8Z+j7HBUVBUA/ZlSW+kvllL8rKHa6N6hfnB5cfKDFqGdpllmUIqNzlQqQJDY6ZxiGYRhGT2RiKlLStVBbqVDWzT7nE3LA39sJJ27F4Hok78BnLu49Scbd2GdQW6lQv0LJAq/fkdP3Cgw2b2EYhmHMDi0KpaRbZjGIjM5dNLqFYU7fYxiGYRiGIJPzsiXsYfMCJucE+UrdYLNzs0Gpe7V9XOVUu4LEmdP3Cow8XZ24uDhZyUCvpCwBgEePHgEwTssjNQSlEdErKUhIYQLolRikKiLFFClJ6D19rlQbialQ9Jn4GhERAQAoXbq0fC4poLJLWyJEFRCVB/TKGVH9QueQGoUUYsq0JqqHXkk5Qu2QcoXUKMp0Q1GJRbGTIojUNmIaH6mPlHXQuW5ubgD0KheKh8aYlDzKn0m1Rv2kc0RlmPJcUTVF/RTT+egcuj+UfaGfSYlF10FUEtG9WrKkfqVcVAbdv38fgH6c6Tgpw5RKQTpGSjV6FdsnIiMjAejHFjBW4NF1oLEU1X7KtElSJIlKNaUiCdCPu/J7Jt6TBPWX2hPTF5XjTtdETOUUUx3pHlKqoOjeEO8rpvhA6XspFkrfS8paFHO1t0H8s3RO32MYhmEYRob8pF7U5JyoTDvwRfKilLmgRakmhZC6B+jT93hR6sVhpRTDMAxjdmgxylKeUrJSyl43oUjn3fcYhmEYhsmClFLlC8BPCtCl7wHA3SfJFrMuKE5IkoQTt7JMzit55FA6f1D63lP2lHph8qxjI4UOqS+UHjcEqSmyMzYn6LhSUaJULynrEJVEhFJtRO2SUkU0hyblBn1OqhhAr4Ah9Yeo9qA6SI1D46D0J6JYRF8sqktULJny2BEVLGKfKB6l4TQpUUiBQ/WKRtwiSuWKaJpNKipqh1Q21F9TCjUaG+WYAMCTJ08M6lKeKxqoU13ieNA54nvAeNypfVF1ZarfFBOdQ/dzTvcQYGyOLxp8i/cq1aUcH/JME73S6BrSdRB9wpTt0PWne0a8DqYUaoR4b4rKNdGvSqmKonMpJvG7Qp+LyjlT7ZgyzmdebSxtdE7pgyXsdb8/Mjh9j2EYhmGYLCLI5LyAlFLujrZwc7DBk+R03Ix6ipplXXM+ick3ETHJeBifAhu1CoG+bjmfkA84fa/gYKUUwzAMY3bkRSkLPC3UaiW5fVf7rJ0uOX2PYRiGYZgs7mSl75Uv6ZhDydyhUqng761L4bvBKXyFzvGs1L265d1gb6vOoXT+YKPzgoMXpRiGYRizQ4tRqRlaaM28IJSsUGdR+h7vvscwDMMwDEFKqQoeBaOUAvRm52G8A1+ho0/dKxw/KQCyeXoiL0q9MHlK37OyspJThShVSZmiJKb6kLG0p6cnAOPt7Sm9SGm2/PDhQwB642dKoxJT3ygOZUoSpWVRWhO9mjKJFtslfHx8AOi3uacULeonpVOJ6UfKfpMZN7VPx6nflOZE6WbKWERDb7EdqlOZCkmxUZqcmNZFdYim4co0NmqfYhRTsKgNpbE9QWXpmolpmRQPGbHTNQX0qWY0FmJsFDv1jdqi8QH0RuqUxkcpcXTtxPQyahPQ309UhmIlM3T6nGInM3/l2FC94vWmOuhzMb1PORb0Sib4dB3E9mmMAf21EE3xacxo/OkcqkMZo5i+R+8pnZXK0Vgqv0Pu7rpf8nRNEhISAOivHV1LOpfM45X9pXaUaYlM8YDS5wDdwlRhPcUy2XbW5MFKpZ9QsNE5wzAMwzAAEJ+cjrhk3Ty6oDylAP2i1HXega9QkSSp0E3OAcBZw0qpgoKVUgzDMIzZUabtmdtXinL/HW2tYZ21zXM6e0oxDMMwDAMgIlb3wNfT2Q4Otnm2YM4WTt8zDzcinyL6aSrsrK1Qp3yJQmuH0veS0zL54eYLkqdvmVqtlpUNsbGxAAzVRqKRNalfSKHh7e0NALh37x4AvVLKlNpKVGKRkoNUJqaMkUUlkGgSTvEolSoE1U9qDtHYm1Qg1F/qoynDbVExQ32imOlzpVJJVMJQX6gPolKMFF3K2KgMqYioToqLFEKkLKI+KmMhJRgpdghRDaNUO5Eii6B6qb807lSO2gD0iiDRcJz6mZ1yyNR9R0bv1E5246+838T7jMbB19fX4H1ERAQAQ3Nzpem5siyNL11LGn9SASpVbqKhvSn1nhJTykDR/J3GQ+yv8l4llRN9j0XTdhpv6guhVDRRLHSM7j/qL/WTjovjBRirq5jigzKFztyLUuQn5WCnhrWV7t7L4N33GIZhGIaBfuc93wJUSQF6pVRETBJS0jOhseFMgcKAUvfqVXCDnXXhjbGjnb7up6kZsk8pk3dYKcUwDMOYnWSlUsrMZufpWf5RNmorWGct1rLROcMwDMMwAHAny0+qfAHtvEd4OtvBRWMNrQTcjjbewZ4pGI7foNQ9j0Jtx85aDdssxT2n8L0YeVJK2djYyOoH8rPRKp4ui0oIUsSQ6oLUGeQPZMqXieoQFTSkvqBXUY0CGKt5xPpJQSP6YgF6xQi9iu3RK0FqJKW3kegdRK90nJQr5HmkVBiJ6ipStyh9p5R9pDiV9dBYUF3kNSSqjMgXSdm+UjWlfE91UB9EJZsyZuoXvZLqh84h5RapoQDAw8PDoD663tQ/GjPRL0wZL6m2KFb6jDydIiMjAejVQErFkOjRJSqV6LqTKki8Hsr6qF2KlfoZFxdnso/KYxQH3U9KJZqyjQcPHmTbLo1vmTJlDOomfzQaH2V/RA8zus40VvRK/VZ+D2hcTX2m7AONqVINRdeV1Humfhcwry6ZWglpGfrfISlmVkrRApS1lQrW6iylFBudMwzDMAwDnZIJACq4F8zOe4RKpUIVb2ecjXiCsMinqF7apUDrZ3Q7LJ+8rVuUalSIJueEk8YasUlpsjUEkz9YKcUwDMOYFTFdz9zpexlZ/lHWait9+h57SjEMwzAMAyCc0vcKWCkFAP7eOmHFjce8A19hcPVRIuKS0+Fgq0ZtH+MNugoaeQe+FF6UehHypJSytbWV1RjZKXkAY8UQKSZIWSGqXZTKGbFeUldQu6TCIaWUUv0hKpJM+U4BelWMUtklqrxEryGqi5QlpMJRevyQ6oP6Q/0W1UXiDoIAULZsWQDGHkpUv+h5pFSWkGqNVEfUPsVDsSu9jJSfK2OlmGj8yUOMrp14bZXHSAEk7hwoKpmU51L91D/Rq4zqFpVSSl8osSy1T32g46b8mmh8xZ0BKVaqg1R+SrUPjTP1m2ISd5ITPdZMeZrRtaHPKA6K73l9oHMpRnql8SdlnNI3iq6zi4vhExqKUfz+iaonZf3UP7r/KB66h5XKNILqpbEy9XuEeXVR7rwHWEIppfsdpFNKcfoewzAMwzB67mQtShXkzntEZS9dZgvvwFc4HL+p+1u6QcWSsFEXvv6GzM45fe/FYKUUwzAMY1ZEDylze0qRKspGqZRio3OGYRiGKfakpGfiUYLuwatvAafvAXqz87BIVkoVBiezTM4bmyF1DwCcsxalOH3vxcizpxQpW8LDwwHo1RCAXhFBKib6jFQQnp6eAPRKClLqKH2ZSAlFZUiNInoLiTt7KX8mFQjVRUoRqoviUqpeSDEi+iCJu4JRG+TTo1RKEaQqIW8rUgbR+FC/TfkiiQosUs5QHTSWynZF/ydxh0Dl+AKmd2MT1SzkS0T+XzQ+oj+VMiZql9ReNEbUB3FXOMDYO0or/GEo7rZInyvrEBVxNA7iToF0TU3tvkexizsV0rjQcWV89DONiejtReNC5ej+UyrW6P7KTgkl7sZIii5ljFQfjTu1Qwo6cfdJ5Tk0/uT/Ju7uSN9Z2pVSuSujuGMfXW8aB+rb83YUpHvTlHqMeXVJFhelzKyUIqNza7XSU4qVUgzDMAxT3LmbZXLubGcNN4eCn59S+l54TDLSMrSwtWaNSEGRkanFqVu6v20a+5lnUYp24ONFqReDvwUMwzCMWREXpSxpdG7Du+8xDMMwDJNFBPlJeTgYiRMKglIuGjjZWSNTKyE8hnfgK0guP0hAYmoGnDXWCChT+H5SAOCk0S1cPmVPqRciT0qp9PR0WWFharcyUmKQgkPcsYwUHKQ+MeU1Q+oOgtQY4i5opBxRqk6oXWqPFFukmBIVTErlCMXi5uZmUD8pSAiqg+JSqm5Ef6LsEP2LAL1ihZQxNFbUPvWT4lQqpUhlQtdCVHuJ10FUuCghpRYpY0T/KxpT8pgC9OoxKkvqKtFDi9pXei7R+IkqJnpPKijqI42P8rpTfaSQonhEtZvo/QRkv9ue6Iv0PB8yilFUgokqL3pVqvtEny8aI1FVRyhVYVRG9Cyj+0q8d5WIuynSe3EXSFJGiuMBGN9ndG3EnfTE+wDQXxNx7JjigcXT9+RFKSuos9L30nn3PYZhGIYp9tBCkW/Jgk/dA3Rz4MpeTrhwNw5hj5+iirdzzicxueJEVupew4ru8vyusHHi9L0CgZVSDMMwjFkx3n3PvAtCGSbS9zJZKcUwDMMwxZ47Wel75Qth5z2iijf7ShUGJ25m+UmZKXUPAJyy0vfY6PzFyJNSKiUlBTdu3ABguOsdIfr9iDvakfpC9ElSqkVEjyFSFZFCR1S7KJUbVA8pdUx5GAF6NZApxQr1i9RV4u5zBPVNqVii9khtQ2oQ6re445myffLjIRUTxSyqf8T2AaB06dIG/RJ9n8hzShxLsU5AryITVUAUM9VBqhjAtEeVsv+ikkpZTrwWonKH1DiiskbZvujdRddEVF+RCkmpZKNzRHmueA+b2lmPVHX0GcVKCiVRfSSqk5Q/k7eSuMsf3RfiOCj7KULXStztUPk9yG5MqH+k0Dp//rxB3co66H4Wx0pUWVEcSj+q3O6UybyaWHz3PYXROe3Mwp5SDMMwDMPI6XuFsPMe4Z+1A18Y78BXYKRnanEmXLeO0MSsi1K6v/MSeVHqhWClFMMwDGNWxHQ9cy9KpVNKsZVKn77Hu+8xDMMwTLHHHEqpyqyUKnAu3YtDclom3BxsUNWMKZFOGt0DflZKvRh59pQSFS1K1QupLEQPH9EnhzxvyDdJiaimoXOpTlL9kOeRKV8oeiXFCimXxN3RSA0FAHFxcQD0ig0qK/r0iOoipVKL+ivGQcdJOUIxk8JHWS+1R2omei+2q1TbUD8eP34MQK9yIXUNjRkpaGg8lHXSOXRN6DMaD1LWUFzKHf2of6TcoXNo/OlcU2aBNH6iykpU0hCmlGPifSZeB3FnPWWdokea6M8kKraUSikaA2qHxo7OFb27qP/KcRCVUnSNCFL9EaZ82AhxzES/KlNqJKqPFFoUM93vdF94eHgAMFRnUX/F3Q3p+yUq9ZQeaqK6Tdx1kXm1sfTue6SKslarYFME0vd2/X0fANC5blmLxcAwDMMwxZ2MTC3uPdH9bVLBvXA8pQDA30v399Tt6CSkZ2pl1TaTf47f0K0NNKrkDisz+UkB+vQ9Njp/MfK0KMUwDMMwL4qRp5RFjc51E8F0C6XvJaakY8zWi8jUSihX0gGBvm4WiYNhGIZhijsP41OQninB1toKpVxM22QUBGVc7eFgq0ZyWiYiYpJROWuRisk/ZHJuztQ9gNP3CgpelmUYhmHMCnlKkWjQ/EopvdG5jRUppSyj1ot/li6rtL787Qr7qzEMwzCMhSA/qXJu9oWqtrGyUskLUTc4he+FSUnPxLkIXXaJOU3OAcCRjc4LhDwppaytrWVzZzIkV6YzKdPhAH1qEKVvZZcKR0bQyjooTYxSksjwmVKD6HOl4TXVI6aeUVoRHad0ImXsnp6eAPRpWpQeSOlMpkzBlX1SlqWYKV2MYqT3lIKmTGeieqgPZcqUMegDpbmRIbXSrFs0YRdT0WjsKJ2Oxk457hQj9ZNSzKgOap/Gh+oAAB8fHwD6dC5KhRRTtMSUTGV74ntxDF1dXQHo7zsldB0pBY3KUuqZGDvVCejT5eh6U6xUhsaI6lJeM/F+orooduq/OKbKcad0OCpL78V7meJRps/R94rao7IUI5UV00gBvcE8XQvqP40RvdJ40D2rvO5UhtrLLtWU7lUaJ2UsdH8px5V59aH0vRL2NniSnG5+o/OsRSAbKytYW9joXLmF8LmIJ9j37yO0qVXaIrEwDMMwTHEmIlY33/UtxNQ9wt/LGZfuxSPs8VO0rlnozb3S/H0nDqkZWng628HP07yqM+csT6mnvCj1QrBSimEYhjErlK5X0jHL3y7dvCqldIVSytJG5+KTtfkHrlskDoZhGIYp7tzJUkqVL8Sd9wj/LLPz65G8A9+LQql7jSu5m/QwLkwofY89pV6MPCmltFqtrIIxpfoQzYpJOUNqHzJzJmUHQYoPQK+cIGPlu3fvAtCrXSIiIgDo1TBK5QjFRMeoXlJ5UBz0nszMAUMVh/JcUn2Q2kTso9JMmpQjVJbUThSXqJwxZe5Mn4ntk6KFxlvZrqgIE82jqb+i6otUb8oY6ZVUP6LRNl07Zex0beiVyohjRn1Qjjspb2hsaAwJUSEkmncrYxZNuqnd7IzQlTFTHTTuVBe1T+0qf9GJ14qM7Ok9XZfsjMfF+gD9eIv3LsVD9z1geO8r+yv2k9pXXm+636leak9UNYp9VarcCHEDASpDxvtUl9Icv1KlSgCAR48eATC+7syrDaXruTva4WZUkuWMzq0URucW85TS/b50d7RFTFIabkY9hSRJZp9UMQzDMExxh9L3KhTiznsEmZ2HPeb0vRfl5M2sRSkzp+4B+vQ9Vkq9GKyUYhiGYcxKsqCUspjRudoK1pRmbqHd95JSdX33dNaluUqS5UzXGYZhGKY4Ex5j3vQ9ALgVnSR7XTJ5I1MrYfWft3Huju6hvrlNzgHAOUsplZqhlZX4TN7Jk1IqPT1dVpYQyi3sSRFBygxSrIgKIlKfiIopQK8cyc7jRvRPUio3yLuGfKmoHVJ3UTykPlGqM6Kjow3qI1WH6JNDMVOcStUNKVdIzSL6AtHYUTw0HkpIuXL16lWDOES/LiWiIoag2EmxJiqYaByUn9GYkJKG2hevHXkSKWOmV9FDSvQUUt4zVJ9SRaOMjcaOVDemvJUoZuonxUHQ2FHMyn7TuaICiOqie4b6oPQ+onNJASXem9Qe3Qfkh6VUTFG9VJaUQ6IvkymFEvWL6qPxFu9z8T4E9ONJ55JCilRP9F5UiCm/M97e3gbn0H1Nr3QfkJeZUn11//59APrvufh7hXm1oUUoNzl9z3JG59ZZSilLTQifpuq+a+5Oeq+71IxM2FrzMyOGYRiGMReSJOFObFb6nhmUUmXd7KGxsUJKuhZ3nzxDRY/CXwh7lbgRmYjx2y7h/J04AEDbWqXMknYpQkopQGfJUMLB9jmlmezI06IUwzAMw7wotPteSUfdgqnZ0/eURudZnlIZFlJKPc1SSrkpJjFpGfykjWEYhmHMSfTTNCSnZUKlAnzc7HM+4QVRW6ng5+mEyw8SEPY4kRelckl6phYrjt7CwoNhSMvUwsnOGp+2rY536peziPWBtdpKXlxMTOFFqfyS50UpUQWjVJ2IqhpSgZCCR6kqAvTqD6ViiI6JO8iJPj20o5zSY4d20FP6XAF65QgpNkgVpFRqUb9IgUPKFfLJIQUL7cJGN71y979y5coZjAP5A1HdoqJF+cWhmEXFEtVFahRTsRNURvRSIt8mUhBR3co6RL8jio3OVe5Yp6wLMPaUonYpHvIyEj2WAONd5+h6ijvKEaSyUirH6JpQTFQ/jYOoalP2he4r5W6GgLEvFZVTKpaoPhpPKkPt0XeDyplStNH1JQ81Go/slEqmPMxIgUax0nE6hz5Xfi9EJZr4/aL7nz4XFYuA/pqJ32NRVUd9UqqhxJ0qTfmrMa8u+vQ93ffO3EoppdG5jaV338vylHLW2MBWbYW0TC1SeVGKYRiGYczKnayd98q42sPOWp1D6YKhirezblEq8ilaBpilyZeayw/iMX7bJVx+oPvbIqSqJ77sUgtlShT+IuLzcLKzQUp6KvtKvQCslGIYhmHMit7o3NbgvblQGp3T7nuZlvKUylKNOdmpYWfNi1IMwzAMYwnCo3UPT33NkLpHVGaz81yRmpGJRX/cwPf/dxMZWgmu9jaY2qEGutQtWyQ2hnGyUyP6qfGOykzuydOilFqtlpUz5Lmj3DlPVNeQUsbdXWc6Rv4xpL4Qd0VTnnPv3j2DsqL6hxQdyhuRYnnw4IHBZ1SXuPub8lxSxoiqGnHnNNG3SRk7nUv9FdUoVAfVrVTnkKpEVKyInkviDnOAXgHz8OFDg5hITSTuykYoVTdUB8VGfSDIc4viE5VT2dUL6JUzdK5SbUPqNYLUN3QPEaIfllJdR0os0dtI3LmOxkG50yIpr0SfMdHvi9pX9ptiFXcGpFdRBUTXW1kHxU5l6TpQX6isKZUV+UIRpESidqhvpOZT3m/ULtVBflcUK42hqH5UXrsbN24Y1C9eh/DwcIP4lN83ur40duwpVbwQjc5T0rXQaiVYWZlnYmFgdJ7lKZVuIbUe7b7nZGcDOxsrJKbqJl8MwzAMw5iPiFjzL0rJO/BFPs2hZPHl7ztPMH7bJXmM2tQshemdAuDlrMnhTPPhpNH9jZ3Ii1L5hpVSDMMwjFlJERalAN2uJfa25pHLZ9BCvZVK3n1PknRqKbWZFsYIeqrmaKeW0wXYU4phGIZhzMudrJ33ypc0n7eTv7fuwe6NyKcWmYMUZZ6lZWL+79fww1+3oZUADydbzOhUE21rlbZ0aEY42uqWVFgplX/ytCil0Wjg4+MDALh16xYAQ+WG6OUjetmQKkP05yFlBaBX5IiePgSpPagOpcJCVDORCodUHqQ2Ef16AL0ihGKi9uk9KTrE3diUPln0GXlJ0bnUHr2KnjuAXtVC/kgEjZ2ovlEqVugcKkPtKv2+lOeK3lPKWEjBQv2i8RUVYkolEZUV1UV0LtVNfRHrUvaHYqfxpXhEjy3lONExUWUk1mkl//Gpb5/UZHTtaIyoT6RyE3elU5ahz+g9XQdSG1GdFIcpTyvR/4ruB3HXO+U9KyrPRE8rUbGmVIjR+Ik+b4T4naFX5T1D7YkqK7p2ov+cMh4aE7oWyt0UmVcbSZKQnG68KPUsPdN8i1JZ6Xs2CqUUoFusUluZJwaC/AecNdbyjnucvscwDMMw5sUSSqlybvawtbZCaoYW9588M8uufy8DJ27GYOKOS4iI0V2TrnXL4vP2NeRdm4sazllKKfIJZfIOK6UYhmEYs5GWqZX9m5w01rK5tzl9pQyMzhWL6RmZEuzM/L/iU1kpZQ07WpRK50UphmEYhjEnd7IWQMqXNN/CkLXaCpU8HHH1USLCIhOL/aJUYko65uy9io2n7gAASrtq8GWXWnizmpeFI3s+TlmTRzY6zz95nn6T2sPLS3dzKD2BRNUHqTHovajcERVEyvpIQSEqNkgVQ0oSUiUBep8rUszQq7gLoCn1j6iUIqj9nLx+AL3ahnYGpP5SHaRUERVFgLFyhcaM+kTKEtFzSlmWFDL0SvGIyjCKi/oMAKVLlzY4h9QvpBQS/ZOUO/eJijhRuUWKobJlywLQ3zuA3pdI3BFQVKrRuIjjAejHU9wpj84hryO6D0iNp+wf9Z92iiP/M4qD+qbc7ZHaI88qitWUIkoZp1LlJu4+SGND10j0OqP7Xgn1gcaZ2hFVd8p7RtwxUVST0X1O7VFflLsuikowipm+k6IPlql7lsaZrivz6vMsTaFQtVFDY6NblDLnDnyyp5TC6BywzA58T2VPKcWiFHtKMQzDMIzZSExJR0ySbn5uTqUUoNuBT7co9RRvVfc2a9tFiaPXozBx+yU8iNf9XdO7QXlMalsNLhqbHM60PI68KPXCsFKKYRiGMRtkcm6jVsFGbQV7WzUSUjIMFqsKG/2ilBVshPQ9c6Pffc+aPaUYhmEYxgJQmpi7oy2czbwIIpudPy6+Zufn7zzB+2vPIFMroXxJB8zpVgtN/DwsHVauceL0vReGF6UYhmEYs0GLUvY2aoNXsyqlFOl7KpVOLZWpleTFKnMiK6XYU4phGIZhLMKdLD8pS6TP+XvTDnyJOZR8NUlOy8CYLReRqZXQKsAb3/SqAwfbl2uJwjlLKUUPGpm8k6crnpaWJqfXUcoQpTUB+rQpSuehVB8xJUg8V2mATGUobUk8TilAlO6j3Gae6qFXSiujV0oZEtP4lDFTvRQ7GW1TzJTGpGyXEFOuqE4qSyla2RmDA/oxoRQoOofqoD4o0wYpLU2EylAdlJJH/ac+AfqxoGsoplGKhu9Kc3oqQ2NFaYGUxiimFyrT2sSUN0I0bae+UOqb8v4QDbWpX/ReTD1Ups9Rv729dXJZSlcjU36qg+IoV66cfO61a9cM2qN+ialwdE3FFEVl7CVLljQYI2dnZ4M6TN0rVIbaE+9hMW1TaVJOaYN0z4oG8zQOZARPcSmvE10TuleV3yflOVSn8rrTtaCxMdU/5tWEFFE04dBkLUqZ01NKaXQOwLKLUuQpZcvpewzDMAxjCUgp5WtGPymispd+Bz6tVoJVMduBb87eq7gdnYRSLhp81f21l25BCtCn7yWyUirf8F+CDMMwjNlIznqK5JC10568KGXG9L30rAVa66yJn03WKymozBZHplZWRTlrrGFnw0ophmEYhjE3d2J1D2nLuzvmULLg8XV3gI1aheS0TDyIL14eq0evR+HHExEAgHk9asPVvuj7R5mCjc5fnDwtRWq1WiOFhSnDaXEbe9E0md6LChclVEZUtyiN1ZVtAcbGyqJZNqlRbt26ZXQu9UMreIqQYorUMKT6IPNs5Vb2VEZUSpFShY6TYoSMv5Wx371716AuU4bqIqKKSlSqeXjocnJJ9ULHldfu4cOHAPSqMjL+pthFQ2rl2JFih1REdA6pYKgvFN/Nmzflc+la0bjSeNI94e7uDkCv+jFldC6agdNnNHZUF71XKnboM7qf6R6hPpH6h+KicVDGTv0UjdbF4zQuSsNv+plUbJ6engZ9EetQ3v/0XaRrRt8vZf3Kz5XXTDT7F9Vu9P2j7x2ZpisNyWkcyZz9/v37Bv2nsaW4lKpKUtNRGeoL8+pDiih7W8P0PUsopayz/KSs1VYAMpFuZqPzJMXkxZE9pRiGYRjGIoRH6+bFFSyQvmejtkJFD0dcf/wUYZFP4eNWPHbgi09Ox/htlwAA/Rv7Isjf08IR5R9alEriRal8w0ophmEYxmzo0/eyFqWyXlPTzbcQozQ6173qFqcyzZy+RzJvO2sr2KitYKtmpRTDMAzDmBvylDL3znuEP6XwFSOz86k//4tHCSmo5OGIiW2qWzqcF4KMzjl9L//kSSklSZKsShHVGEpEdQepIUipQ5DqhJQVgF59QfWTyoKUFKIaRultRJ+RmkP0KaKypNJQeiop+6h8JXUL9YH6RK+kQgH0ahKxDhEaH+obYOzHpfTZAvQKHhoHU2obUe1FMVOM9J6uoXLcSTlDY+bq6gpAP0ak0CGVlRKq98GDBwD017lMmTIG7dH1Fv3ClOdQrGKfSClGiiqlok0cb9GHSrzOSk8pGmdSilGMpFiie4bKKRU9dK/SOIoqO/FaUjnltROvFZWh2EV/KqVCjO5zup/oHNH/ic411W+xfdE7jO5pUpIp66DvEamr6ByqW/THUirUCLo2ynuRebUho3ONjSWVUnqjc+VrupnT95Q77wHQp++ZcSwYhmEYpjiTmqFPmytf0vzpe0CW2fk/xcfs/NdLD7HrwgNYqYD5PV+TH1C+rHD63ovDSimGYRjGbKRlLfxQqhotxJh1UUpraHROiilzG50rd94DoDA6Z6UUwzAMw5iDe0+eQZJ0Cm4PJ+MHqOaAlFLXi4FSKjIhBZN3/QMAGP5mZdQt72bhiF4cTt97cfJsb0+KHVLWKJUbBKkeSBlBZUiFovSWAQz9kkg5QYoMei8qRwhSayjLijuWkRrk0aNHBu+V54r+R6RmERUspNSh8qQkUf4s7rpGr3QuqZCUXlrZjafoJST6MynHRFR1kdqHFCyi+kw5ltQulSHfLVLBmFIoEXStxF3YaEc7Gme6d5SKmbi4OAB61Y+okBIVNKIKR4m4MyGNO6m7RK8z5Tn0Siou0Q+JzlFeMxo/UXkn3rsUB5U3NYbUXxpDqlPcQZE8tgD9PUEqJvKlEqExU+7SKH6P6DMaf+V9DeivqbL/dH+REio6OtqgDI17ZGSkQR8A/ZjQdWdPqeIDqZFsrXXfR3tLGJ2TUsrKUCmVaeK7WZgod94D9At1vCjFMAzDMObhTtbOe+VLOpj8+8Ic+Hvr/t66EfkUkiRZLI7CRpIkTNzxD54kpyOgjAtGNve3dEgFAj1cZKVU/mGlFMMwDGM2yMSb/JNoUSrFEkbngqeUuY3OafJCkxlbVkoxDMMwjFkJj9E93K1ggZ33iArujlBbqfA0NQOPEoztZV4VNp+5i0NXI2FrbYVvetWR5z0vO45ZSqn0TAmpGWzBkB/ypJRSqiRIHWHK24fUJqTQICUHIe6Kp1RtiL479J5WjEnRQa9K7yVxBzE6lxQbVJbUJ0qllKlYAL3qhfpLnkekaBEVJYBe9UL10zliHcpzaUwodlKmkKcRxSUqiYDslVnZ+TBRnUrFEl0jUbFF/SfPJ9rJj9QvpmISd8qjc0nlo1TMiOolqoPK0JjRWNFxpbpO3BGQxp3KkhqLlEXKa5ydtxJdD2pXvC+Ux+ia0TmkkBLHkOJSKpbEcaA4qF1xJ0Eaf0C/A6TozZadx5VSdUbt0bUT1XTUB7ovqC7lkxtSHoq+UHQO1UXfP2U8dP3o2pnyd2NeTWjhh1LnyEfAEul7sqcUpe9ZaPc92VNKXpTiCQ3DMAzDmIOIGMuanAO6h1IV3B1wMyoJYY+forSrfc4nvWTciUnGzF/+AwCMa1kVVbydLRxRwUGKd0BnzWDn9HJ7ZFmCV2N5kmEYhnkpIKWUTdYCjMYSSqmsBVIbweg8w8zpe7RLi7golcZKKYZhGIYxC7TzXnkLLkoBel+psMhXz1cqUyth7NaLSErLRIOKJTHgjYqWDqlAUVup4Jj1kJVT+PJHnpRS1tbWsmLD1I5epNChMqQkEZVBpIog1YVS9UL1lipVCoBeSUHHRTWWUmEhKnboleoQlUNK5Yio1KCypNSh9+LOdVS3sp9KRRlgrMahc6KioiBCY0fKFfI0ovhE7yVluzSeYlmqi64PKXtIQfS8OuhcUlCJO74BgJeXFwC9IkYsSzvb0XulQktUE4k7N1Jc5MNF5cm/SFkfnUtl6ZqR1xLVqRw70TOKrhUpkqgdU15e1F9SzYlqPopLfK8cu+yUgRSPeJ8rVWY0NqKHFn3vxLFU7nooeoiRukmsk+qi2JXfd1LLkVKLxp1exXFRjh2NsylPOubVRvaUylJK0as5U+eM0vfUllJK6b4HstG5DXtKMQzDMIw5ichK3/O10M57RBVvJ+y7DNx4BXfgW/3nLZwOj4WjrRrze7wGtdWr55nlaGeNpLRMXpTKJ6yUYhiGYcwGLUqRSoleaVc+c8agT98jpZS5PaV0i9CklKIFOl6UYhiGYZjCJ1Mr4W6s7qG5JdP3AKCy96u5A9+1R4n4ev91AMDn7WugXEnLjnNhIZudp/CiVH7Ik1JKrVbLCgpSTCiVE6L/Eyk18rKDgOhpQ4oVUfUi+tYAetUFtUeKDYpRVJQo1VGiukqMXVQskcpI2X/yTiJ1FSlpRI8tUgwplSuE6DtFqiOqS9yNThkznSP6AYleWuJ4KKF+U7u0KxopdEj1o1S4UBnyqqJzRW8jsS5lbKJihvpCdZIfE6lzlNedVDxURrx24v2n9CGjsaDrS5+R/5SocjPloSb6M4keYuK5ynuGrgF9Ru1RGRpDKqfcpU70wRJ3YRTHRxm7qFak9zTeYp00psrrJPZLVA+K8ZlSRIr9ZV590uRFKUOVUroZF2JkTynB6Nzc6XtPSSlF6Xs2WYtSZkxlZBiGYZjiyqOEFKRlamGjVqG0qybnEwoRfy9dJkvY48RXZge+tAwtRm++gLRMLZpX80Kv+uUsHVKhQXO5pDRelMoPrJRiGIZhzIacvmctpu+ZZ0FIkiRkCkbnNhZK3yOJt6PsKZX14MCMqjGGYRiGKa5Q6p6Pm4P8kMxSVPRwhJUKSEjJQFSisXDhZeS7P8Lw38MEuDnYYE63Wq/EQlt20KJUIiul8gUvSjEMwzBmQzY6z5r82VibN3VO2Y4NqfgslL5Hu+85i7vvpfOiFMMwDMMUNneydt4rXwRSyjQ2avi667ItXgWz8/N3nmDpkRsAgFldasHL2bJKtMKGFqXYUyp/5Cl9z8rKSk6RonQypdE3peSIJsq0KkrpPVSODLeVxuCURkT1U3uenp4AjM2slWbdVJbSpug9pZOJxuqUigYYG0pTO9QHSu+iuqkvStNq0dCdUq0oRYnSqOi9Ms2K2qFXOpfioT6IZtbK2MW0ORojSnkTzauV4y6mj4nG7/Q5HVeOHV1v0bid6qd+i2MH6NO2xBREd3d3g749ePAAgN5UW5m+R9dZNOOmvoj3hfJcGiMqQ/XTWFIddC7ds4D+fqLYydhbvM8JKqdM2xTTA8WUS7EO5Xvqp5g+J8anjJmg6yimvFJdNB5UJ5VXti9+z2jsxPRBqlP5XSlZsiQA4P79+wbtM68+ZGhOCilanDLXjnNKNZS14GuVYWaFEvkOkFKK1GOpGZy+xzAMwzCFTUTWznuW9pMiKns54XZ0EsIeJ6JpZQ9Lh5NvktMyMGbLRWgloHOdMmhbq7SlQyp05PQ9XpTKF6yUYhiGYcxGmmB0Tr5O5krfS1f4RtGiFCml0s1udK6buMi778mLUqyUYhiGYZjChtL3ioJSCtDtwAe8/EqpOXuv4nZ0Ekq5aDC9Y01Lh2MW2Oj8xciTUkqSJFllIypnAL0Sh5QSpEghNQapLEh1ROoIpbKCjJZJdUKKKTpXVBIpVS/0s6gUEg2myWhbqSwhhYrYDsVIaiNSe5A6RNk+jYWo1KH+k6qL2lcqR+ic6Ohog3q1gvEu1alUStG4i+NKYygaUlPdNNbKekXzcxoPqpPaVbZvynxdeQ71k9QxSnWbqMChOOh60DUU1WXiuCjbo/GmsqS+cnNzA2Boqk0/U3vitSOoD2S8r+yHqB6j9uk4jSmpCpVm5WI7hKhuojFWqqxyMgcXvw/Uf2VsFBPFKI4dlRO/04B+XEmhRteXFFPifae8t+hn0SSeefUhQ3Mb8pTKSt9LN5Ofk4FSiozO1fT7x9xG51mLUnZZ6l3ylOJFKYZhGIYpdCKy0vcqZKXNWRp/L10WQthLvAPf0etR+PFEBABgXo/acHWwyeGMVwNSvSeyUipfsFKKYRiGMRuy0bmQvmcupRTtsKdS6RVSNhb2lHKy003Y5N33eFGKYSxOVFQUPvroI1SrVg329vbw8vJCgwYNMGHCBPmBKQCEhoZCpVLJ/+zs7FClShVMmTLFyAoBgEFZlUoFFxcXBAcH49dffzUqu3btWqPy9G/ixInZxp6SkoLKlSujWrVqJh9gtWnTBq6urrI1QoUKFbJth/6FhobmYxQZpugiSZLsKVWU0vcA4Hpk4kv5wDY+OR3jt10CAPRr7Isgf08LR2Q+OH3vxciTUiolJQV37twBoFd7KLeIz04xQ5AqgtQZSsWMHFCWAoeUSNmpfUhpYUrtRK8EKZNIGURqJOWkgr74pPoQ1VTkMUTEx8cbxKH8mWKkvojqE9GnStkueexQHaJSSVSfKctSv6le6i8dJ7VPiRIlDNoE9D5YVJYUQdQH6pvovaWMhVRNVC/VSWP4+PFjgzqVUP9EZRz1jeo2dd0JUe0lXku67kqVlajWo+ssKrGoPeU9S/0TvbyoTnFMTam7xFipn6SUoskk3RdKZRXVR/2j60rfL7ou1IYpVSN9z8RxFRV7pia19B2ge6V06dIGddFkl64lKagA4+tsyveKeTWRPaWsLbQoldW+jcIfTU1+iGZelEqUd9/L+j2gZk8phikKxMbGol69ekhISMCAAQNQrVo1xMTE4NKlS1i2bBk+/PBDg/+37OzssGrVKgC6/xt3796NmTNn4ubNm9i4caNR/S1atEC/fv0gSRIiIiKwbNkydOjQAXv37kWrVq2Mys+YMQMVK1Y0OFazZvYpMRqNBsuWLUPLli0xe/ZsTJ06Vf7sp59+wr59+7Bo0SKUKVMGAPDtt98azImVLF68GKdOnUKjRo2eM2IM8/LxJDld/n+4XBFJ3/PzdIJKBcQlpyMmKQ0eTnY5n1REuBOTjC9/u4JHCSmo6OGIiW2qWToks+JM6Xu8KJUv8rQoxTAMwzAvgtHue2rLpO+Rn5QyBnManadnauWxcLTN8pRSKKUkSeINABjGQqxevRp37tzBX3/9hSZNmhh8lpCQYPBQD9A9bOvbt6/8ftiwYWjSpAn+97//YcGCBfD29jYoX6VKFYPy3bp1Q40aNbBw4UKTi1Jt2rRBvXr18tSHFi1aoE+fPpg9ezZ69+6NKlWqIC4uDqNHj0b9+vUxbNgwuWznzp1N1vH777/j9OnT6NixI4YOHZqn9hmmqEN+UqVcNNDYqHMobR7sbdUo5+aAO7HJCHv8tEgvSj1NzcCJmzE4ej0Kx8KiEJ6lOrNSAfN7vgYH2+K1zEBzuaep/GAxP+TpbsnIyDBSNylVL/SfNCk0xJ29yNOG3oveM8r6SDFCKpPY2FgAelWIuJOdsj2CzqVzxHJKtY2ocqJ6SSFCZek9KYaUu5HRz6JfDr0n1YnYFqBXhImeSVSW6qY4lOfSZ/RKihhxh0DaLY3Gg94DxmoqenpG7+kJmugPpoSUWeQtJPaJFEXKc8XdBKkdUUlDfk1ly5YFoPf4UtZL7YjqJ3GnOeV1F68RxSOqnuhVqZijMtSOeC4plsh7SVTbAXqlEt3v5cqVMxgPUiYSyrETlVA0RqKqkFSNykm06BFG97W4ox+1J3rJAfrvAF1n8btJfTLVb9HvS7mbI/Nqozc6t4xSiozOra30Cz7WZl4YAwxT9OxtDT2lJEmn2rJR86IUwxQ09+/fx+eff45ff/0VcXFxqFy5MsaMGYMBAwbIZW7evAm1Wm1SHaRUuWeHSqXCG2+8gZMnT+LWrVtGi1Ii1atXh4eHB27evJn3Dj2Hb775Bnv37sXQoUNx6NAhTJw4EVFRUfjtt99MzuOUPHr0CO+99x7Kli2LNWvWFGhcDFMUID+p8kUkdY/w93LCndhk3IhMRGM/d0uHI6PVSrj8IAFHw6Lwf9ejcD7iiYHC3NpKhdd93fB+kwp4vbzbc2p6NdEbnT8/c4wxTfFawmQYhmEsSrqw+55+UcrcSin9H2RkeJ5pxvS9lHT9AxXadY9eAd2ilY36+X80MgyTNx4/foxGjRpBpVJhxIgR8PT0xN69ezFw4EAkJCTg448/BgD4+voiMzMT69evR//+/fPVVnh4OADDTUayIz4+Hk+ePIGfn1+2n1NaPaHceCU7vLy8MGfOHAwZMgQjR47EihUr8PHHH6Nu3brPPU+r1aJv376IiYnB4cOH5YeNDPMqoTc5L2KLUt7O+ONqZJHYge9xQgqOhUXj6PUo/HkjGrFJhnYevu4OaObviSB/DzT2c4ezpniYmpvC2Y7T916EPC1KWVlZyb41opIFMFY9iEoZUlCQokTc2QvQe8tQWXpPCg2qm85RPrEi9Ye4M5+oghHfK9sTVUf06uXlZVC3KfUHtZ/dbnekiqFyStWZKQXU8+JRjjspVGisRE8h0cuL2iD1mbI/VC+pYMg3iK4V1UUqGOUxOpfuDeVOcUqUqhjxnqFzxN0dKQ4qp2yfypCHE9Up9kVUBSnrK1WqlEFZundpjOh+U6ruSGlG7Ynx0HWndt3d3Y36T/cEqcyoffKQunfvHgD9GCvVTnSO6B1G7dFEmK6H8p4VlYgUc3ZeZtR/5X0nepmJ33fqJ8WjTEWiYxS7qHJkXl2KitG5gVIq6+d0E75vhQUtStlaW+m/34pFqNT0TNk0k2GYguGzzz5DZmYm/vnnH/n/5KFDh6J3796YNm0ahgwZAnt7ewwYMADffPMNQkNDMWfOHISEhKBZs2Zo27atwfxDCS0axcfHY9euXdi+fTtq1qyJqlWrGpVNSUlBdHS0zmj5zh1MnjwZmZmZ6N69u8m63377baNjuTVB/uCDD/Djjz9i8eLFKFeuHGbMmJHjObNmzcIff/yB6dOnIygoKFftMMzLRkSsbv7qW0R23iP8yez8caJF2r90Lw6/XHqIo9ejcPWRYQxOdtZo7OeOZv4eaFbFs8iNnSVxlI3OOX0vP/CMl2EYhjEbotG5raWMzpVKqayfMyyQvqdRqKOsrFSwVVshLVPLO/AxTAEjSRK2b9+Onj17QpIkA+VRq1at8NNPP+H8+fNo2rQpvL29cfHiRcyYMQM7d+7E999/j++//x62traYPHkyJk+ebPCgJSkpCZ6ehrtMvfHGG1i3bp1Jb7jVq1dj9erV8nsbGxuMHz8en3zyicnYlyxZgipVquSr3yqVSlY6NW7cOMeNRY4dO4bp06cjJCQEkydPzlebDPMyQDvvlS8iJueEv7fuO3rDAkqp4zei8e7qU6A1b5UKqFXWVVZDve7rxirubKD0vURO38sXeVZKkTpE9O8B9MoIkhSTqojKisoZUokolVLif95UJx0nlQupnUhpAeiVG6QmoadIpBQhNRKpPUx57BDiEyjyMBJ3fVOeJ/ojUR3iWFEflP0mxBx/0dOI6laqvGiMKDbqF4236IdFbSjVKeJn4pjRexpvUswBeoUWqYpolz0RitmUHwMpocRdBql9qps+p3sH0CvORG8nakf051LuQkefUf/EMqJiS6ly8vHxMWiHlELUfxpLUleJ7wG9Yon6RfeZqDoS/coA/bUgBRyNGR2nduhz5fdPLCvuukPjS9eWroNyZ0tR1UfXiGKke5WUZMrvqnifZ7frD/PqIRqd6/2czKyUUhsrpSyRvmcnmKvaWesWpdJ4UYphCpSoqCjExcVhxYoVWLFihckySr/K0qVLY9myZVi6dCnCwsKwf/9+zJ07F1OmTEHp0qUxaNAguaxGo8GePXsA6BTOX331FSIjIw3mKko6deqEESNGIC0tDWfOnMGXX36J5OTkbH2eGjRokGejc2LHjh3Ys2cPatasia1bt2LEiBHZqp9iYmLQu3dvuLm5YePGjTn6TjHMy0xErG5RyreIpe/5eerm3tFP0xCblIaSjrY5nFEwPE3NwLhtlyBJQNPK7uhZrxyC/D3N1v7LDqnbk9IyebOafMBKKYZhGMZsZG90LpnlP3FSapk2OjffQpCslLIx/KPP1toKSAUrpRimgKEHKX379s3WJ6p27dpGx1QqFapUqYIqVaqgXbt28Pf3x8aNGw0WpdRqtUGKXatWrVCtWjUMGTIEP//8s1GdPj4+cvm2bdvCw8MDI0aMwJtvvomuXbu+UD+VJCYmYtSoUQgMDMThw4dRu3ZtfPjhh/j7778NHm4CuodV/fv3x4MHD7Bnzx55wxuGeRVJSs1AVKLuYa1vyaKVguZoZ42yJexxP+4ZbkQ+RYOK5vF0m7v3Ku7HPUPZEvZY/l49thDIIzRemVoJKelaeRMbJnfk6W6ztraWc/BJwUE+PoBeGSV6OtGr+MSFlDpKrxtxpzb6T5OeNpEEmdQxSn8gioXKkvqG6iSlBnntKOOJiooyqE+UN1OfRM8d5Q52BJ1LPlSkAqHdBkm5olTdkKqEYhV37BN35VNC/RR36qM6xd0HqZxSdUPtkJqGXuk6iN5DSsUYKWGoX2IfRM8r5R+dVB+NL8UsKsJEb6nneXpRe3S9qW90vykNO6lf5OFEKjPxVVTdAXo1k+jRJfqdUVx0fyrVRuJuhjQOhHgNleo6+g5QbHQ/Uf9ozExdMxpHcVJK3w36ntOklMZHec+IKjrqC40H9ZuOizt3Avrvm3JMmFcb2VPK2thHyRw7zpEaylrx+9+SSimNtbFSCgBSM9iTgGEKEk9PTzg7OyMzM9OkR1NuqFSpEtzc3PDw4cPnlitdujRGjx6N6dOn4+TJkyZ38VMyZMgQfPPNN5g8eTK6dOlSYIvzkydPxsOHD7F79244Oztj0aJF6NChA+bPn4+JEycalF2wYAF+/fVXjB49Gu3atSuQ9hmmqHInSyVVwsEGrg5Fz5zb39sJ9+OeISwy0SyLUsdvRmP9yQgAwFfda/OCVD5wsFVDpdLtoJyYms6LUnmEdbkMwzCM2UgX0vdsrPV/fJlDqURtGKTvmXkHQECvhLITlFKUzsdKKYYpWNRqNbp164bt27fj33//NfqcHk4CwKlTp0w+LDl9+jRiYmJMmpeLjBw5Eg4ODpgzZ06OZa2trTFmzBhcuXIFu3fvzrF8bjh37hyWLFmCESNGIDAwEADQvn17dOnSBTNnzkRERIRc9syZM5g0aRICAwNzFS/DvOzQznu+RcxPiiCz87DHhW9vkZSagQnbLwEA+jQsj6aVc97ZkzFGpVLByZbNzvNLnpZBMzMzZbUDKTeUPjX0M6kf6JXUGKIfE6k+lP5NpMQghQpNCsQd3uhc5aRBVM+QYkP0VCJFiVJBRLFT/0iholSGmELceQ3QK1VEbx3qpylvJVJckYKFyorjQGobpWKGYhB9kUiZRO/Jv0jsozImUwo4JfQ5qaKUsYo7CFJc5D8lel8BxsogUtWQ2o3ek+rJlB8VKdBEpVDp0qUB6HfEMbXrII0rxST6f9E9QveO8h6jn6ksKZKoLI0hXQdxnEz1X/SyomtG973yutD1Fr2bKC66p01dS4qFYqX3FA9dMxpbOq6MXVRxid8/UfWmvGeonuzUfMyri2h0rlQspWdIQCFbF5CZubXaWCmVYcbd91JzUEqxpxTDFDxz5szB4cOH0bBhQ3zwwQeoUaMGYmNjcf78eRw8eFCeH6xfvx4bN25Ely5dEBgYCFtbW1y5cgU//PADNBoNPv300xzbcnd3x/vvv4+lS5fiypUrqF69+nPLh4aGYsqUKZg7dy46d+78Qv3MzMzE4MGDUapUKXzxxRcGny1cuBA1atTAyJEj8fPPPyM5ORm9evVCeno62rdvjy1btpis09vbGy1atHihuBimqHAna+e98kV09zh/b93fhRfuxkGrlWBlVXgq8q/2XcXdWF3a3qQ21QqtneKAk8YaiakZeJrCu4rnFdbmMQzDMGZBkiQTnlL6iVaaGZRStPBko/SUkhelzJm+Z1opZcvpewxTaHh7e+P06dOYMWMGduzYgaVLl8Ld3R0BAQGYO3euXG7IkCFwcHDAH3/8gd27dyMhIQGenp5o2bIlJk2ahLp16+aqvU8++QTff/895s6di7Vr1z63rL29PUaMGIFp06bhyJEjCAkJyXc/Fy1ahPPnz2Pbtm1GNhPlypXDtGnTMHbsWOzcuRN169bF7du3AQDTp0/Pts7g4GBelGJeGYq6UqpBhZKwtlLhwt04zD9wDeNaFc5i0clbMVh3QqeanNutNpw1RS+V8WXCMSvtMTGVd+DLK7woxTAMw5gFZXocLUqpVCrYqFVIz5TMolSSjc5NpO9lmNXoPAdPqXRWSjFMYeDl5YXFixdj8eLF2ZapVasWvvrqq1zVt3bt2mwXnCpVqmSw0zFgvLuzkqlTp2Lq1Kny+9DQUISGhuYqDiUff/wxPv7442w/HzNmDMaMGZOrmBjmVYQWpcoXsZ33iAoejviyay2M33YJSw7fhI+bA3o3KF+gbSSnZWD8Nl3aXu8G5fGGP6ftvSjyDnycvpdn8rQolZ6eLuegkxGy8gkMpZop03QA/X92lEYkpq9RXYA+FYpy+ynNh9LaxDQ+ZfogQSlJVIbS1yi9i1KjlCbplCYlpm1Rqhulk9E5lOal3D6Y0saoDMVMaVaU3kTjpEwNFGMU05oorYvaVabvUcweHrpfJmLKlVgH9Z/iULYvpnXR9aV4TJ1L54gG13Sup6cnAH2qnNJgnsaMUuwoVjHVkeqiFDVl/+l+o5goDjLnpnGnPtE4APr7RzSQFw3I6b0y5ZHOFQ38qf/0SqmH1DflBJViobGhfovm8OL1V8ZCY0Tt0T0rpgaaQjTHp+/b3bt3jfqrLK9sl1L9xDL0naH3yn5Te9ltl828mig9o5QG5zZqK6RnZurS9woZU0bnpNbKMKOnVHZKKTtr9pRiGIZhmMIkIit9r0IRTd8DgJ71yuFebDK+O3QDk3f9i9KuGoRU9Sqw+r/adw13YpNRxlWDT9ty2l5B4KzR/d30lJVSeYaNzhmGYRizoFyUUqbtkWrKHOl7pozO1bT4bMb0vZyUUuwpxTAMwzAFT3qmFg/idA97fYuoUooY3aIKutYti0ythOEbz+Pyg/gCqffkrRisPR4OAJjDaXsFhqMtLUqxUiqv5Dl9j5QapBIhhRFgbFYsqm9IMUR1kAqD1DLKeklJIUqK6T2pQpRKDrFeUSlFSg1SYSlVGtQPNzc3AMCjR48A6FU4FCOdQ8oepVJLNJgWja1F43el6oXKiookGjPqC6mBlLGT4oyOkVGnqAijumnslMoVap+O0bmk4CE1DNWhVLcRN2/eNKhfNA83pVCj+qh+KkP9pbGie4uukykDelITPXnyxKAvVAe9N6UyE9U+FBepjSgupaKK7g1RPSbefxQX9UEZu2jGT9eQ7je6p0QDdmX9pB4jVdXjx48N2jUF1Ucx0XuKQ7wPKGZl+9RfipXei8ot0dRcWT8p4Ejdx7za0KKTSgWorZSLUln3ilk8pZ6jlDKj0bleKWX4u4w9pRiGYRim8Lj/5BkytRI0NlbwcrazdDjPRaVSYU632ngYn4ITt2IwYO0Z7BzWFGVK5D/TIDlNv9veO/XLoVkVz4IKt9jjREopNjrPM6yUYhiGYcwCqX9s1VYGC5w2sqdT4SuVMmSjdaXRufnaJ2jRiZRRhOwpxUophmEYhilwwmOydt4r6WAwFymq2Fpb4fv3AuHv5YTHCakYsPYMElLynx42b/81RMQko7SrBp+2e/6uoEzeIE8pTt/LO3lWSpHagVQZyu3myQ+JVBX0SkoJb29vAHpFBR1/8OCBXAcpM6guU/5LgLEayVS7pNggtZFYTqmYEf2Q6BxSdNA55A9E/k3k36OsQ2xHVCaRwkbZJypDihEqK/af2iV1DKBXm5CqhlRMVBf1k5Q1VIdSHUSqGlIGkZpJHA9T/kCkthGVQVSXqNih66L8WVRVideIrnN4eLjB58p26Z4Q1UWkJBN9wwBjXyY6l9RW1C69lipVSj6X6qf+0bmiUkocF+qrsg7Rf4rK0DnUN6XaiFRVdL2pD9RP0VxVeX/Sd5Fio8+oPfp+i/ef8tpRHXT/iepGui/IW015LvWbxpkUecyrDZmMK/2kAHOn75HRuT4GtQV339PYiOl77CnFMAzDMIXFndgsk/OSRddPSsTV3gZr3q+PLkuP4+qjRAzfeB4/hNaX50+55fTtWIO0PRdO2ytQ2Og8/7BSimEYhjELlJ5nYy0uSpkvfU9vdG6cPmjO3fdS0rNRStmwUophGIZhCgvaea9CEfeTEvFxc8AP/evD3kaNY2HR+HTHP3naOfNZWibGb7sISQJ61SuHYE7bK3AofS+R0/fyTJ6UUs7OzrI6gpQzShUM/UwqHlIEkZqKVCak1KGd/JR+MqTuIJWFl5dulwFSWVBZUvIov4yk7qBXUe0jelwplVKk6hG9qigOUq6QGoYULaToAv6fvfcOk+yqzvW/zj3T3ZNz0Iw0EsogJF3ACAzIFtlCgAETTDImOMjga4MDl2AbMDhgDD8ExhcEWDjogjAmGBGNEQiDhEA5jDQ5T0/onKp+f1S956xadaq7aqaqZ7p6vc8zT01XnbPT2dXn9N7f+lbq5VQp/S9qFD63Ci6vovFtpB2MrVU50XbG2Su2KNNnFty0aVNyzCOPPFLSB4/3xbL9pj8c41U3Xill1T6UY6+FVJ7Rjr7RdutfRv2oiXyGRH5GWYRyyv6fMhiHSnPGZrRDoUR/K/k/+ethf/Y+W4wV891nTLRj5/21mE9873wfLNTHPEYR5b27rCJPKlV5UQ9leT842u6/D1I6RvQz0lHPDwjfs6FzhZ+L2R9nQynFd6m1PHxwNheCqMsrpTrbwlMqCOpBS0uLfvu3f1sf+chHTnVTGsJTn/pUSdJ3v/vdupXZ0tKid77znXrXu95VtzKD4HSDRanT3eQ8i4s3LNZHXvZY/eZnfqIbb9uljcsW6tpfOqeqc//65vu1rRi296fPjbC9RtCTKKViUapWQikVBEEQzAqJUqpC+N7seEqVh++xMDSbGe9mVEpNhFIqCILTj23btqmlpSX519bWpjPOOEPPf/7zdccdd5QcOzg4qHe+85266KKL1NPTo+XLl+uSSy7R7/3e75VYd7zrXe8qKdP++9jHPjbLPQyanR39RU+p5XMnfM/yS+ev1rufd5Ek6W+/8YC+cPuuGc/58bZ+ffKWwsb7e19wcYTtNYi+xFMqFqVqpSal1MKFC7V+/XpJ0s6dOyWlagkp9VdCsYGqAxUGKhP8Y8hwZ9UX3uMHtQfqJ1QX+NRQtpSqqlARefWRVzlZtQ39QO2BgoZjDxw4UDIWqEGs6ob3vD+SV65wnFWQoIRBmeI9jnifMeR9Wx/j6rPCUR+KFvpis+BxLXymPlQ2jC3jYb20fIY61E/0bzoVjM/25g0HOZc+oODZuHFjcgzZ5nx9tNX7YFnlEMowPzfBK3lstkWORYFF5kbKom+cw+dWZca1YK7SHnyaODYrYyLXinN8ljuvkLLXwfuaMb58d5hvPqOk/a4C30GfmdNfOzt21MM1sl5dQfNijc4tKKdmw1Mqy+i8u7gQxELRbFBJKRWeUkEQzAVe+tKX6tnPframpqZ077336rrrrtPXvvY13Xrrrbrkkks0MTGhX/zFX9R9992nV73qVfrd3/1dDQ4O6u6779bnPvc5Pf/5z9e6detKyrzuuuuS5314/OMfP5vdCpqcXC6fKqWWzT2lFPz6EzZpV/+wPv69h/W2z/9caxZ164lnr8g8thC293Pl89KLLtugp527apZbO3/AU2ogFqVqpmaj8yAIgiA4ERKj8zJPqdkM38NTKm0DC0Gjp0ApxYJY2pbiJkIsSgVBcBpz6aWX6hWveEXy8xVXXKGrr75a1113nT7+8Y/ri1/8on7605/qhhtu0Mte9rKSc0dHR0s2RuFXf/VXE4uPIGgEBwbGNDaZU1tri9YvXXCqm3NSvO2Z52nX0RF95ed79YZ/uk2ff9MT9ajVfWXH/c3N9+uRQ0NavahLb3/uBaegpfOHCN87cWoO31u4cKEWLlyoBQsWaMGCBWprayv719raqtbWVnV3d6u7u1urV6/W6tWrNTY2prGxMR05ckRHjhzR1NSUpqamlMvlkn+Uu2TJEi1ZskQdHR3q6OjQ4OCgBgcHS47N5XKanJxM/g0NDWloaEgjIyMaGRlJ3vft4meLPyafzyufzyfyYcqi7aOjoxodHS1pC+dOTExoYmIi6S9jRn/pU8mFKJ67aNEiLVq0SJs3by75R98Yh0OHDiX/jh07pmPHjml4eFjDw8NJW4H2wcDAgAYGBrRz587kH+f4Merr61NfX582btyojRs36txzz9W5555bIq2mfD9WlOXHp729PfnHOX7c/dwAxu7o0aPJP+ZZb29vyT/K5BzKov8DAwPJ2FEW4+znNO2hfVZ1xFyg3/SN45iP/KOOoaGhsms1Pj6u8fHx5DrzfVi2bJmWLVuWfD4+Pq4DBw7owIEDSbl+jLq6ukpUWXau0mbqgZ6eHvX09CRzmPZRx/Hjx5N/9IGxZP75/jLGlDkxMZHMXcY1lFLzg0rheyxSzarReYZSauwUKKVYEAPGIjylgvnIhz/8YV144YVauHChli5dqssvv1yf+9znks9f/epXa/PmzWXnEf6VxQ033KBzzz1X3d3duuyyy/S9732v5POBgQG9+c1v1ubNm9XV1aVVq1bpqquu0u23354c89///d960YtepDPOOENdXV3auHGj3vKWt5Tce2lfb2+vduzYoec+97nq7e3V+vXr9f/9f/+fJOnOO+/UlVdeqZ6eHm3atKmkb5J0/fXXq6WlRd/73vf0hje8QcuXL9eiRYv0yle+MslWOx1jY2N65zvfqbPPPjtp51vf+tYSpTLHveUtb9HKlSvV19enq6++Wrt2zRwCNB1XXnmlpNSbc+vWrZIKi1We7u7ukkiDIJgtth8uRDmsX7Kg5sx1pxutrS36mxc9RpdvWqqB0Um95lM/1oHjpT6+t23v1/8thu297wUXa/GCCNtrJH1Fo/PBMDqvmbn9bQyCIAjmDOMZoXNSajo+Mdl4TykWvqzROSF0s6mUGquolIrwvWB+8olPfELXXnutLrjgAv3d3/2d3v3ud+uSSy7Rj370oxMu87/+67/05je/Wa94xSv0Z3/2Zzp8+LCe+cxn6q677kqOeeMb36jrrrtOL3zhC/XRj35Uf/AHf6AFCxbo3nvvTY658cYbNTw8rDe96U368Ic/rGc84xn68Ic/rFe+8pVldU5NTelZz3qWNm7cqA984APavHmzfud3fkfXX3+9nvnMZ+ryyy/X+9//fvX19emVr3xlsohj+Z3f+R3de++9ete73qVXvvKVuuGGG3TNNddMa4eQy+V09dVX66//+q/1K7/yK/rwhz+sa665Rh/84Af1kpe8pOTY173udfq7v/s7Pf3pT9df/uVfqqOjQ895znNOZIgTWIQiCQzJdD7zmc9Uncykv7+/ZNO1moW4IKiF7f1z1+Q8i+6ONn3ilZfrzBU92n10RK/99I8Tlc7oxJT+8MZC2N4LL92gK89bfYpb2/z0hKfUCVNT+N7ExETiX8OOlM3OhUcT6gyfDW/btm2SUv8cblJWzYHXDDsoPpMbPj543VgVDX43NkOalHrZ0GZ+tlnhkBFTHl4/1EPf6MuyZcsklXr80A9UWLz67HPUgT+SlHoIUQ9t9L5QtMfe4KmH/vmbv89k5zPK2ffoA9cVHyR8m3h44n1bDg8P3tuJ+vnZjhl+RBs2bJCUelVxnfEcogyMMW0WOsrgWMbSjwPXwUrG/RxkfMny6LMCWg4dOiSpfPxpK69cU/qUlTESqN97SHllnX2P/vPK2DB3snygfJspy383KIPPGWNbD/2kTJ+FkHbZnVrGAG84v9scNCczGZ1P5GbDU6rc6JyQualcXhNTuVnZPR2dyFZKdSVKqViUCuYXX/nKV3ThhRfqxhtvrFuZd911l37yk5/osssukyT92q/9ms4991y94x3v0Be+8IWk3t/8zd/U3/zN3yTnvfWtby0p5/3vf3/iHylJr3/963X22WfrT/7kT7Rjxw6dccYZyWejo6N6xSteoT/+4z+WJL3sZS/TunXr9NrXvlb//M//nCwQXXXVVTrvvPP06U9/uizbXWdnp771rW8l995NmzbprW99q/7jP/5DV199dWZfP/e5z+mb3/ym/uu//ktPetKTkvcvuugivfGNb9QPfvADPfGJT9TPfvYz/dM//ZN+67d+K1Fw/fZv/7Ze/vKX6+c//3nVYzs8PJwonu+77z695S1vkSS96EUvkiRdc801yVj/3//7f/W0pz1NT37yk/Xc5z438Sn1nHvuuSU/b9q0KfnbIQjqwY6in9QZc9hPyrO0p1PXv+Z/6QUf/YHu2n1cv/vPP9U//Ppl+ttvPKCHi2F774iwvVkBT6mh8Unlcnm1tmYreINyQikVBEEQzAosSpV5ShG+NwsLMZMstGYopaTZWwwiPK9MKdWBp1SE7wXziyVLlmjXrl368Y9/XLcyf+EXfiFZkJKkM844Q8973vP09a9/Pdk4WbJkiX70ox+VZIPz2AWpoaEhHTp0SE984hOVz+f105/+tOz4173udcn/lyxZonPPPVc9PT168YtfnLx/7rnnasmSJXr44YfLzn/9619fshn1pje9Se3t7frqV79asY033nijzj//fJ133nklaiPC6r7zne9IUlLGtddeW3L+m9/85oplZ/HOd75TK1eu1Jo1a/TUpz5VW7du1fvf/3694AUvkFQYsx/96Ef6wz/8Q0mF0MTf+I3f0Nq1a/W7v/u7ZSGFkvT5z39e3/jGN5J/N9xwQ01tCoKZ2FYM32sWpRRsWt6jT7zqcnW1t+rb9x3Q6z97m/7xvwu/W973gou1eGGE7c0GhO/l89LwLFpCNANhdB4EQRDMCpWy73UmRuezEb5XWSklFeTu7HQ1kkpKKcYilFLBfONtb3ubvvnNb+pxj3uczj77bD396U/Xy172skxPomo555xzyt571KMepeHhYR08eFBr1qzRBz7wAb3qVa/Sxo0bddlll+nZz362XvnKV+qss85KztmxY4fe8Y536Etf+lJZSBmKX+ju7tbKlStL3lu8eLE2bNhQ5nu1ePHizBA13+7e3l6tXbt2WtXQgw8+qHvvvbesbiACYPv27WptbdWWLVtKPvcqpZl4/etfrxe96EVqbW3VkiVLdOGFF5ZEPkiF/n3gAx/QBz7wAW3fvl3f+ta39Nd//df6yEc+osWLF+sv/uIvSo7/xV/8xTA6DxrKjn6UUj0zHDn3uPSMpfrQrz1Wb7rhNn37vsL3/QWXro+wvVmkq71Vba0tmsrlNTQ2OSvPk81CTSM1OjqahDUR3kUYm5SGGnFTIsTLhy0REkT4D+FN9hhebbiQPde/SmmYUla4kpTudFGvDRnyIW30hXAy2sgr79vQOEKeKIsyKoWA2YcT2uTDtiqFZNl+Ux/94xwfPkfYWtb4EDbJeGM8TT27d++WpMQU24ag+RA7wtp4n3FhHGzbeY85ws4gr4wH/ed4O6aMFfVTrw95GxgYKCnLtoVX+sW5fgzt9fbn0ibfDurzoXlSeq34ztjQRikdO3Zws6479fmxoz38bA3NCR1lp5Lx96GWzHfKsuG6vEcZPhSS8fbhnLZNPiw3aG7GiwtCPjwOf6fx2TQ6N0qplpYWdba3anwyl2TFazSVlVJFT6mJWJQK5hfnn3++7r//fn35y1/Wf/7nf+rzn/+8PvrRj+od73iH3v3ud0tSRTPz6ULtZ+LFL36xnvzkJ+umm27SzTffrL/6q7/S+9//fn3hC1/Qs571LE1NTemqq65Sf3+/3va2t+m8885TT0+Pdu/erVe/+tUl92VJZYl0Znq/Wr+lmcjlcrr44ov1t3/7t5mfb9y4sS71wDnnnKNf/uVfrvr4TZs26bWvfa2e//zn66yzztINN9xQtigVBI1mezF8b/OK5lJKwTMvWqO3P+cC/fmX79Gqvi6987kXnuomzStaWlrU29WuYyMTGhid1OrI51A1sXwXBEEQzAqE53VUCN+bnBWlVHFTxJmtdxcXpWZLoYRSyoYOSqlqazYW6ILgdKOnp0cveclL9JKXvETj4+N6wQteoPe85z364z/+Y3V3d2vp0qXJpqBl+/btmeU9+OCDZe898MADWrhwYYmiaO3atfqt3/ot/dZv/ZYOHDigSy+9VO95z3v0rGc9S3feeaceeOABffrTny4xNv/GN75x8h2uwIMPPqinPe1pyc+Dg4Pau3evnv3sZ1c8Z8uWLfrZz36mX/qlX6q4eCcVFodyuZy2bt1aoo66//7769P4GVi6dKm2bNlSYjYfBLPBseEJHRspbMw3k6eU5zeedKYu2bhYZyzribC9UwCLUmF2Xhs1G52jikBZw6uUmmGjkPAqDG6SGFGjsiJTh5SaZVMGSgpv1o36xCqpUHHwwEL9KDVQCKHSsKoPDKf5DLUPbUdlxPv+eNtG6vFm5dMZoKNAoz/eeBsVlFflZI2N7Zf9nPFHwm3Po62cS330m+tMvVwf20bKR13jjcc51/bbK6X8GHoDdnYUbf+9Ao9XVEiMLW1evTqVsSK7p35v7M14ZO1wemWeV7cxhrxmzRkM/f1cpU+MKXVQtpR+B5jvHMN4e2N/O2aMiVeAeUNzb9Ju1VZcd+r1SjGPfd+rFbO8JYLmY6JC9r00fO/UGJ1LhcWh46OTs6KUyufziVKqyy3QpUbn4UUQzC8OHz5c8jzY2dmpCy64QF/72tc0MTGh7u5ubdmyRceOHdPPf/5zPfrRj5Yk7d27VzfddFNmmT/84Q91++2369JLL5Uk7dy5U//+7/+uZz7zmWpra9PU1JQGBwdLEs+sWrVK69atS+5LWclh8vm8PvShD9V3AAz/8A//oNe85jXJPfm6667T5OSknvWsZ1U858UvfrG++tWv6hOf+IRe//rXl3w2MjKiXC6nnp4ePetZz9Kf/Mmf6O///u8To3NJ+ru/+7u69uFnP/uZ1q9fXxaOt337dt1zzz01hwsGwcmyvb/wLLuyr0sLO5tbl3HZpmUzHxQ0hMTsPBalaqK5v5FBEATBaUNidF6Wfa+l5PNGkmV0LqUG47OhlJqYyqsYRZiE6wEm8BG+F8w3nv70p2vNmjW64oortHr1at177736yEc+ouc85znJZsuv/dqv6W1ve5ue//zn69prr9Xw8LCuu+46PepRj9Ltt99eVuZFF12kZzzjGbr22mvV1dWlj370o5KUhAMODAxow4YN+tVf/VU95jGPUW9vr775zW/qxz/+cZKN77zzztOWLVv0B3/wB9q9e7cWLVqkz3/+85leUPVifHxcv/RLv6QXv/jFuv/++/XRj35UT3rSkypm3pOkX//1X9e//du/6Y1vfKO+853v6Iorrkgy4/3bv/2bvv71r+vyyy/XJZdcope+9KX66Ec/qmPHjumJT3yivvWtb+mhhx6qax++8Y1v6J3vfKeuvvpqPeEJT1Bvb68efvhhffKTn9TY2FhZxsEgaDTbiqF7m5pYJRWcenqLZucDo7EoVQs1K6VQRaDCsDJqFDCoH44fPy4pVVSglEA5ggrDqiS8YgSFBu9TL8odfKts/RyD6sWrQVCb2N0b/k+bqdervFCD0EfrS4X6w/cBvD+W9dGhrYwvCh3vS8RunvXhQu3jvaJIucu4oHpit88e73cCURV59ZNXxdj3UP1wDuPsr7s1wqTttNF7itFvzvWeR/Y9lEiMGaoextbPS9tWyvDeEN7zyY6Z926iPu/DRL30gXGyx9IfHrz93PHeWvYc+us9NSjDlyWl84tyGX/mrvd8YmwPHjyYlJE1F6RytZlXCNp+ML5ZbQyaD4zOvacUP89GyFqW0bkkdRcNx2dDKTVqVFDlSqmip1QYnQfzjDe84Q264YYb9Ld/+7caHBzUhg0bdO211+rtb397cszy5ct100036fd///f11re+VWeeeabe97736cEHH8xclHrKU56iX/iFX9C73/1u7dixQxdccIGuv/76RGW1cOFC/dZv/ZZuvvlmfeELX1Aul9PZZ5+tj370o3rTm94kqXAv+4//+A9de+21et/73qfu7m49//nP1+/8zu/oMY95TEPG4iMf+YhuuOEGveMd79DExIRe+tKX6u///u+nDctrbW3VF7/4RX3wgx/UZz7zGd10001auHChzjrrLP3e7/2eHvWoRyXHfvKTn9TKlSt1ww036Itf/KKuvPJKfeUrX6mr79QLX/hCDQwM6Oabb9a3v/1t9ff3a+nSpXrc4x6n//2//3dJeGIQzAY7ipn3zmiyzHvB6UVPKKVOiFBKBUEQBLMCRuedbiGGBaLZ8JTKMjqXUm+n2VAo2Tr8olRnMhaxKBXML17/+teXhZ1lcdVVV+nOO+8se98rb+zm1ctf/vLMsjo7O5PscNNx/vnnZ3pIeZPy66+/Xtdff33Zcd/97nczy62UTW/hwoX6+Mc/ro9//OMV25RVZkdHh9761rfqrW99a8XzpMKG2Ic+9KGyEMRqTNc3b95c1XFnnnmm3v3udyeqtOl417veFcqpoOEkJufLmy/zXnD60FdclApPqdqoaVGqra0tUfds3bpVUmkmFBQhlbKgoKBAfYH02SooUKTwHmoMzkVlgkLKpuLlWJ8xzWcSQ5Vh/XFQbHilFGVwLj/TB6+skVKFiFeVoZTJ8rTiWO/1w3h4XyirsvJZ5ujfvn37JKUqMK6Lzw4olWf/86o3xpnjrD8QHhA+u16ljIJ2fnA9KWPv3r2SUvUPvmP0wSt6bD2o5/gZ76z+/v6SdqEYk6QNGzaUHOMzBXpPMXvNvMrHZ5LzyjzKsOo6+s18Zv75OUzb6ZNUft3B95OybNvXrl0rKR1nHoypn1e+I4z/pk2bkjLwkGNueC8p3z6rauQaMe6VshIFzUXqKeUXYmYvfK+S0flsejmhxupqby1TPnS0MxaNX6ALgiAIgvnC9v5i+F4opYIG0tNV+JsmFqVqI9uROAiCIAjqTOop5RZiZjF8bzJRSpUbnUtpVrxGQmiez7xn2zU+latbqvggCIIgmO9sJ3wvPKWCBtLbVdiUj0Wp2qhJKTU1NZWoLyr5yUxbWXtpdVmZ5FCReNUFSgqfjczi28SxnIu3FeoQq1hBteWznnk/KvBZyaRUMcNnvn7667PVSamqxXtL+TZ75ZiUKlK8h5DPduezwtkxpHxeGQ/qB/pi/bFQO/nMeNRHW1HU2LZTHufQNvBzZt26dSVl2Xr8GDIOXolg66d/pIb22R/pU1a/UWtRhu8nx/r6rcrLK6Gsist+npXZzmYxtG3kuvqMelaphALN+3GhkPIeT/TR+rAxz3ft2lVSL231vlRW5cU18x5iQXNTSSnVkWTfa/w8mKyQAbC7aHQ+K55SxTqo02JN4Cdz+bJ2BkEQBEFQG6MTU9p/vPD8vSnC94IGgtH5YBid10QopYIgCIJZAYVQR7tflCqG+J5Co/PZNBinDuq0EL4nzY7HVhAEpw+vfvWrlc/ndfnll5/qpgRBU7GjGLrX19WupQuz7S+CoB70FsP3wui8Nmr2lPI+OtYLxmdw8744eP6gHPEKHyn1VEI54jPpoWRBoYTCw5ZnM9NJqfrDZ8Wzx6FqWb16dUm9tMerUHxmN3uMzwKI2gdlVpbKy6teOAblDGOXpajxnj7eSwvfHu+pZVU3fEY7/PX1SiY77ngV8R7l0kbKIrOcVT/RT64N7UCZg2KJ8UaVxTy0/acMn5XOZxS04082Oeqjfl7pP/XZtnMtvK+Y9z3j50OHDsnjvcooi/76zHV2zpZ50RTnv1c98T79l6Tt27dLSucVY+fnkFfuWVNWzqVtlM9YetWhVUQyzxjPyL43P2BBqLOiUqrxC0KVjM67ZlEpNTaNUsqqyManclqg8FsLgiAIgpMBk/NNKxZOm8UyCE4WwvcGYlGqJkIpFQRBEMwKExWVUvgoNV4ZNEEihgrZ92bDU2p0EqPzLE+ptF2zsUgXBPON//mf/1FnZ2eyORPUxqtf/Wpt3rw5+fnw4cPq6enRV7/61VPXqCCYAfykNi2L0L2gsUT43olRk1KqpaUlUX2gWLIKBxQTKGJQM5FBDpUHfja8olaRpKNHj0oq96riZ16z1D74DVEfyg3KhCy1EeVxDqvolOVVVlkKDzKpcSyv1Ifaxntc+X7Y+n02PK+ckVJljM9+WEnlQ3vomwWFDmVwjldILV68ODkHpRTKII71qiuuv83KxhzxijTOIRufnw92l4N6fIY85irtoQw77tRDm3x/vf8WqjN7LuPJNcR3ac2aNSVtZh7aa+2vL21k7tAerpVValXyXaNdtIM2W/8z+oOainagLuN9rhntsl5ePgOl95TKmquAiiorI2PQvFQ0Oi8uUk3MQujcZMXwvdnLvjc2gdF5+b5QS0uLOtpaNDGVj0WpIGgAf/qnf6qXvvSlJdlkgxNn+fLlet3rXqf/83/+j5797Gef6uYEQSYopc6IzHtBg0nC98ZjUaoWQikVBEEQzArjFYzOWaSajUWYykbnp4dSSjLhjJPhKRUE9eSOO+7QN7/5Tb3xjW881U1pKt74xjfq9ttv17e//e1T3ZQgyGR70VNqU2TeCxpMkn0vlFI1EYtSQRAEwawwPpm9KNVeVP1N5GYjfA9PKZdRtbhANHqKlVKSDWcMpVQQ1JNPfepTOuOMM/SEJzzhVDelqTj//PN10UUX6frrrz/VTQmCTHYUw/dCKRU0mp6iUio8pWqjpvA9qTR8R8oOJyIkh9AnwncIL8PwmbA9G15HCBDnEBJGWBmhV4QMYbYsSRs2bJAk7dy5s6R8wgl9CJ4NK6JfhJHRF46hfm8EbY2n+b83tiZUiXZYk26gX4wZEFZF/Xa8fb2UzxhyLCFZHEeZ1vj6wIEDJecQTkW4Hq8YwVOmhXMJnyM8k/poF/PA4j+jvz6sbffu3WXjQOgd14QwSvrLfPDjYd/zY8e8YoyYM/baMTfoL+GD3pSf0DvaZ43WmSOcQzu8ATo/25BTnwyAeUafaB9hfHauMt98mKCfX4w7feRVSq8Vr7SH8aUsf/1tP/gsjM7nBxMVlFKzGb6XGJ23ZRudj82GUqpodN7VMb1SajIXi1JBUE+++MUv6sorrywzOv7JT36iP/3TP9Vtt92moaEhrVmzRk972tP0yU9+Mjnm6NGjevOb36ybbrpJLS0tet7znqe3vOUteuxjH6tPfepTevWrXy1JeupTnypJ+u53v1tSx6tf/Wp997vfLUkYksvl9Pd///f6xCc+oa1bt2rx4sW65ppr9Jd/+ZfJ8y987Wtf03vf+17dfvvtam1t1S/+4i/qAx/4gC688MKkvqc97WmZ/d60aVNJvTOVZcfr7W9/ux566CGdffbZ+vM///OKY3vVVVfpU5/6lPL5fBhJB6cVk1M57TpSeFbdvDw8pYLG0ldUSkX2vdqoeVEqCIIgCE4Esu91lRmdz174HnWUGZ0X2zQrSqni4psfB0jCGSN8Lwjqxu7du7Vjxw5deumlJe8fOHBAT3/607Vy5Ur90R/9kZYsWaJt27bpC1/4QnJMPp/X8573PH3/+9/XG9/4Rp1//vm66aab9KpXveqk2vSGN7xB119/vV7zmtfo2muv1SOPPKKPfOQj+ulPf6pbbrkl2XT77Gc/q1e96lV6xjOeofe///0aHh7Wddddpyc96Un66U9/qs2bN+v888/XZz/72ZLyjx49qt///d/XqlWrkveqKUuSbr75Zr3whS/UBRdcoPe97306fPiwXvOa1yQbwJ7LLrtMH/zgB3X33XfroosuOqlxCYJ6svfYqCZzeXW2t2rNou6ZTwiCkwCj8+HxKU3l8mprjUX6aqhpUSqXyyVqiyy1C0oNVBDcTHnfG4x7pYeUKjFQDPEZyhUUFZRhVS/Ug7oFFQiKEZQ7mDijwpFSRQpt4tUrOHifMq2yxCtV6L9Xm2ASTjts/StXriz5mfr37NkjKVWbWNULyiDKRQXDufQT5Q7tsmX4cQX6gkKIc63qhbGgzRxLuygDNVrO7P7TBq43x1AWY8ZYcQ2tus4be9Mer7Kib1Yhh6rNXgup3DQerLm4V7x583vUXhiN+++BbSP4ucrnjIv9rlRSStFP2o7hOmo3SXr44YdLyvCG776/zC2rTGTM6CeKMOqhPd7U3Jbrjwmam0pKqU48lGbFUyqf2QZUS2MTjV+UGk3C9yoopdojfC8I6s19990nSTrzzDNL3v/BD36gI0eO6Oabb9bll1+evP8Xf/EXyf+/9KUv6Xvf+54+8IEP6A//8A8lSW9605sqKpOq4fvf/77+8R//UTfccINe9rKXJe8/7WlP0zOf+UzdeOONetnLXqbBwUFde+21et3rXqd/+Id/SI571atepXPPPVfvfe979Q//8A9avXq1XvGKVySf5/N5XX311erq6krC6qotS5Le9ra3afXq1fr+97+fPAM85SlP0dOf/vRMk/izzjpLknTPPffEolRwWvHIoULo3salC9QaCwRBgyF8TyqYnS/q7pjm6ADCUyoIgiCYFcYrmIy3J4tSjV+cJCTOh+/h7zQ2CyGEqdF59i0YFVdk3wuC+oE9gw+LY7Ply1/+csmGm+WrX/2q2tvb9aY3vSl5r62tTb/7u797wu258cYbtXjxYl111VU6dOhQ8u+yyy5Tb2+vvvOd70iSvvGNb+jo0aN66UtfWnJcW1ubHv/4xyfHef78z/9cX/7yl3X99dfrggsuqKmsvXv36o477tCrXvWqkmzLV111VVKWh3HFliAITgd+uuOI/ujzP5ckPWp13yluTTAf6GpvSzZbw+y8empSSmWlsrdKElQXXrGB+sOrn/AnylIboVRB9cMxSJC9GkOStm7dWnIM7aGNKDu8GsiWRz0+3T2vjAGKElsWahY+o78cg7KGNtvxZIy8IgiVjR8fFD5Sqgyjn16JhbcWfaJsqxhC5YLyjGPpC55TXBd7Lg8ijDu+SN7bCNWTPZcxoFzajKqGcfcKLftQSX2M84MPPlgyHtRLGVblt2vXLlm82sur3rLaDn5eUS9qsKGhoczjbD3MGe/HxDjYB2bmgvdu8EoxP2elVEXolWD87BWBtMuOO2XQL471qi76Ysd9OsVh0LwkSqlTFL6Xz+eTha+KRuezoJQam0kpNYvKsSCYb3hl7lOe8hS98IUv1Lvf/W598IMf1FOf+lRdc801etnLXpY8G23fvl1r164tURxL0rnnnnvC7XjwwQd17NixktA6C89dPNNceeWVmcfZ50H4z//8T7373e/WH//xH+uFL3xhSZ3VlLV9+3ZJ0jnnnFN2zLnnnqvbb7+97P1KzyRBcCrI5/P6p1u368++fI8mpvI6c0WP3vrM8051s4J5Qk9Xm8aHcxoMX6mqib8EgyAIglmB7Hudpyh8zyb3855SGJ2PzobR+QxKqc7i+5OzoBwLgvkClgJYGUBLS4v+3//7f7r11lv1H//xH/r617+u1772tfqbv/kb3XrrrWULUTPR0tKSGZLuN4FyuZxWrVqlG264IbMc7BzYxPnsZz+bhONb/KbOI488ope//OW66qqrSkIQT6SsWmBcsVIIglPF8Pik/uQLd+qLdxSsT55x4Wr91YseE2FUwazR292uI8MTsShVAzXdfVpaWpIdkKydEP8eN2XUHfyM2gI1ir0xorJAheHVKDwcoEIhG5uU+gyhTPH+Q5SZ5Uflz9m7d6+kVIXE5179Y9UfeOvQT++p5PtiPZ0ohzGkzV5KTlmoU6T0IcNnUkMpQxm8cq59+PC+UJyLDNsrdmyWQPrhFWA+22GWpxL1shtJWfTfq6vYObSKHcZ5x44dksqzwQFKIett5I8B6tmyZUtJ+yx+XlOvz37oM+ll1cnDKm3k1c83Ox+8pxQ7nFw7+on6zHpgeUWU95LydaBYtF5e1EO53mfOe11VGmt7bNDcoFLqLFNKzU74nl30KgvfKyqlxmbD6LxKpVR4SgVB/TjvvIJK4pFHHsn8/AlPeIKe8IQn6D3veY8+97nP6eUvf7n+5V/+Ra973eu0adMmfetb39Lg4GDJItX9999fVs7SpUsT30YL6iPYsmWLvvnNb+qKK64oy7zsj5MKavRf/uVfnraPIyMjesELXqAlS5bon//5n8ueO6stC88olFWWrD5L6bief/7507YxCBrJ1oODetM/3aYH9g+qrbVFf/TM8/S6J58Zz5nBrNLb1SFpJML3aiA8pYIgCIJZYWIy2+i8fZbC9yaNVKqS0flsKqW6KyilZjMbYRDMF9avX6+NGzfqJz/5Scn7R44cKVM2XXLJJZLSzbVnP/vZmpyc1HXXXZccMzU1pQ9/+MNl9WzZskX33XdfYp0gST/72c90yy23lBz34he/WFNTU/rzP//zsjImJyeTTaBnPOMZWrRokd773vdmel7Zet74xjfqgQce0E033VTmnVVLWWvXrtUll1yiT3/608lmsVTwpLrnnnvKzpOk2267TYsXL9aFF16Y+XkQNJqv3rlXz/vILXpg/6BW9nXpc697vH7zF8+KBalg1uktmp0PhVKqamrW6aJcyfoZbx9UGN7LyGff44a4f//+pAyMKPmMHSmUKny+b98+SaXeAKhJUE9xDmXRLn452R0kr+riZs7uFX3wGd0sXrFEW2kHapMsdYr3cvJKLJ+lzqpSKNerXajXZ9Bj/K23USV/JO9ThSzbqm68ZxCKsUplMT72M/uefZ+HMsaD62SNNFGzMa6V+umzPlp8/2Hnzp2Syr3MpHSuMBfpH2306ibOzfKU8hn71q1bJykd00rts3h/Ju9hxjyR0vlGuZxLH/guM1aorezYUZ4fV+YhdXhVlv0/9Wd9n4Lmo5LR+WyF701apZQP32snfG/2lFJd4SkVBLPK8573PN10003K5/PJs+CnP/1pffSjH9Xzn/98bdmyRQMDA/rEJz6hRYsW6dnPfrYk6Vd+5Vd0xRVX6I/+6I+0bds2XXDBBfrCF75QsmADr33ta/W3f/u3esYznqHf+I3f0IEDB/Sxj31MF154YUmm36c85Sl6wxveoPe9732644479PSnP10dHR168MEHdeONN+pDH/qQfvVXf1WLFi3Sddddp1//9V/XpZdeql/7tV/TypUrtWPHDn3lK1/RFVdcoY985CP6yle+os985jN64QtfqJ///Of6+c9/ntTV29ura665puqyJOl973ufnvOc5+hJT3qSXvva16q/v18f/vCHdeGFF5Y950mFBatf+ZVfiQWAYNaZmMrp/V+7T//4/YJa73FnLtNHXvZYrerrnuHMIGgMvV2Fv8UGYlGqasJTKgiCIJgVWGTxnlIswuTy0lQur7YGpWy24YG+DkLpZiP7HiGCZPzzJItSk+EpFQT15LWvfa0+8pGP6JZbbtGTnvQkSYXFof/5n//Rv/zLv2j//v1avHixHve4x+mGG27QmWeeKamwgfKlL31Jb37zm/VP//RPamlp0dVXX62/+Zu/0WMf+9iSOs4//3x95jOf0Tve8Q79/u//vi644AJ99rOf1ec+9zl997vfLTn2Yx/7mC677DJ9/OMf15/8yZ+ovb1dmzdv1ite8QpdccUVyXEve9nLtG7dOv3lX/6l/uqv/kpjY2Nav369nvzkJ+s1r3mNpHQj+POf/7w+//nPl9SzadMmXXPNNVWXJUnPfOYzdeONN+rtb3+7/viP/1hbtmzRpz71Kf37v/97WT/uu+8+3XXXXfq7v/u7E7ouQXCi7D8+qt/53O368baCp9kbfvEs/eEzzk2y+gbBqaCnuCgV4XvVU7OnlPcjsr5IpNVFBYFSyHvK8Oozy0mpUgTlhjd69OoMqw6iTV6J5VVG1lPI9s3Wi8oIdQseU+Czw9n6+YwyOIYdNdQvtu2oWhgTr/rxHkNWqYTKiHMon3bQb6/kylKZeUWOv3ZcH7sThqcT14Z++nO5HiibpNTfivJ4qEIh5ZVCjKmt36vXvAyfc70vVlZ/K/k+eb8u2w/q84ogr77zc9tCH6gHfyyfpc56W/nxZfy9EtBn4bPl8Er59Mkrp8DuCvvPvEKK+Uf/bb9R3tGHrN8FQXMxOZVLjMZ96JzNxjcxlVNba7aC6GSZypF5r6VsN7+7Y/aUUtTR1V5JKVVoW3hKBUF9eexjH6srr7xSH//4x5NFqcc+9rH63Oc+N+O5y5Yt02c+85mS97Zt25Z57Mtf/nK9/OUvL3nv6U9/euaxv/mbv6nf/M3fnLH+pz71qXrqU59a8fNXv/rVevWrXz1jOdWUBS94wQv0ghe8oOS95z//+WXHfexjH0vGNghmix9uPazf/efbdWhwXH1d7fqrFz1Gz7yo3MA/CGabvu6iB3QopaomlpGDIAiChmNVSh1lRuct5rjGLcRQtjc5l9IForHJXGbmrHqCGmsmpdRkLEoFQd1573vfq3/9138tMx4PTozDhw/rH//xH/UXf/EXEboXzAr5fF7XfXerXv6Pt+rQ4LjOW9OnL/3uk2JBKjhtIHwvsu9VT01Kqfb29kRZYZU6gJeTz/bGTcpnUkM5YhUXXoGFcgNFDefyahUt3qvHH8srCg57POVQP4od+uDVVdPdeBkb+otyxCuZsryFyP5HfznXK6Zsv1Eq0UaUMdTDud7TyCq1KINr4RVMnENWuiyVFb5LqH1oB3jvKSlV01G+9wqjn4yLVeYBHg3USx+ojzmb5W1E/xg7+sJY+floz/WeZbTZe3vxPnOZLHlSql6ifNqIz5qvf/369cm51OszVvqsh15tJaXzm7aipvM+UMxhro+9powd8wsfLBRb/lrabJf832aRDJobq/opC99rtUqpxi0IYXTekeHRZheIxiZzFTPj1QOUUt0VlFKds5SNMAjmI49//OMzn7+CE2P58uWZHlNB0AiOjUzoD278mb5xT+E5+QWXrtd7rrlYCzobd88OglrpCU+pmglPqSAIgqDhWAWUNzpvbW1RW2uLpnL5hiqlxosKpc6MrHd2EWpsorGLUiiluioopdojfC8IgiAISrhnz3G96YbbtP3wsDrbWvWuqy/USx+3MRR6wWkHSqkI36uemhelvF+NVUwdOVIwmfPZ1jgGtQfqCBQd1usGXyoUGnjreEUJSgubtc2X5717aDvKjaxzUZCgaqEvnFvNLz7qpw/0CWVLViYz7z/Fud7zBxWKVZdRPuO8devWkvq8PxD9X7Mmlbl6JdratWtLjsXjifptKmHUTpSB+ob6+JlrZ1VWjAUKLJRBjKG/luedd56kNCuerYex8+PBvEShhSrM1o+qiLahZkL9Rf+t2oe54VVlPoMj9XqlnpRmM6QPe/bskcWrnGy2S64FY+RVfd4XKyskyau8KMtnEOTVqsDov/fUAtrBdbBjx1ygPsY3aF4mTOa9rN+jHW2FRanxBhqNYzDelbEo1d7aotaWgtn66OSUFquj7Jh6MbOnVGTfC4K5wObNmxse7hsEgfTA/gE9/6O3aGwyp/VLFui6V1yqR29YcqqbFQSZ4CkVRufVE0qpIAiCoOGw2ORNzqGjrVWjE7lTppRqaWlRd0ebhsenNDbR2MWgaj2lYlEqCIIgCKRv3XtAY5M5Xbx+sT77G4/TkoXlNjJBcLrQE55SNRNG50EQBEHDSZVSM5h75xqnOkjC5ioolAjZG51sbAa+mZRSLJpNhqdUEARBEOjIcEGd/4SzlsWCVHDaE0bntVOTUmp8fDwJCSLsx4bAAWE8fX19kspDjwj7yTKaJHzu0KFDktIwH471oVlZYT8+jIlXysoyrfb98iF4vmwf7iSloWeEpngDbowgKcOGQjFGGE77sugnoWC27YQaLl68uKxcKb0OGGLTdkIjpfIwMo6h/7wSMka4nW3Tz372M0nShRdeKCkNgaOtjIMN3WEsaKOfT4Qv8v4DDzwgqXTu0H/KZezoizczt+fSLwy8/bnevNOey7GEAzJ3GQ/CBjnOj6WUzkXO8WGpXEvqsOF9jCvzjO8Ecwjomw9nteXzveJYvn/0nzJtuC7jSjv27t0rKf1O+OQA9tpy3fv7+0vqDZqX8cnC75QslZKU+kw1MnxvOqWUlIb1sWjUCHK5vEaLSqxKxqwd4SkVBEEQBAn9Q4Xn76U9sSAVnP7EolTtRPheEARB0HBQSvnMezAbIWvTeUpJqVJqrIELY1aFtbDiolSE7zUTuVxOe/bsUV9fXxjyBkFQd/L5vAYGBrRu3bqSzfJm4khxUWpZqKSCOUBvdxid10pNi1L5fD5RVHjVjZQqQFB/AEoOVDbgDbj9/6VUQUKZqC1QbFjVCedyjDc0R53hlSRSqmahTah8qJf3UZBQtn3A5D1UH75e3vcG1LY/KIZQsGzfvl1SqjrxCiopNdpGMbRy5UpJ6bgzhtyoqN/euFAAoUxiLOk3pt28b89FIUMbUTOdddZZklL1D+3cv39/Wdu9sblXszE+jCkqJNt2xsar3rwijz5K6VzwCi0/zxgH2+/e3l5J6bXy886btlOXrZ8x43pyDD/7seN7Z/vlFVDr1q2TJC1btkyStGvXLkmpKsm2gfposzdJ5zVLbeVN4Jl/XiEFzEOL/74HzYs1Os+iM1mIaXz43qlUSg2Pp2V3z2R0Phnhe83Anj17tHHjxlPdjCAImpydO3dqw4YNp7oZDaF/OJRSwdwBpdRAGJ1XTSilgiAIgoZTjdG5JE02VCmFp1SFRSk8pRpodD5SXJTq7mhVa2v2Ah0Ld6GUag7YbFq+fLle9KIXSZLOP/98SenmhoXw+B/+8IeS0g0PziFUf9u2bZKk3bt3J+eyGcEm4Pe//31J6WZBpezElqc85SmSpIsvvlhSuknEpgih/2zSSdKZZ54pKQ0FxxKAzbFPfvKTktLNCzZErrzyyqQMNlTo/1e/+lVJpdl+7bkvfOELk/fo17/9279JOnUh4T5jrc8+y6Yh4f5SmsF4ampK4+MvVT6/tqTMlpa96uz8Z/NzS9n/GXe7+ZSFt3eQyse3nlCfz35t8RvUHHvVVVdJks4991xJ6SY0m7VSer0591nPepak9LvCpumPfvQjSemmqZReE+Y52Z2Z59gX8J2yG8rM0R/84AeSyseQje2nPe1pJW231hd33XWXpPIN5ErZHO11p7zHP/7xSX2f/exnk981zUiilIpFqWAOwKLU2GQhgU+lZ98gpaZFqdbW1uQXKr+cUYNIqe8NNxgUGjwM+Zs1r/YXrVdqoOhYv369pPRmxM2COm1bvKrG3yw4zv7y5sbJjY1f+DxA7Ny5s6StHM/NSkpvNtTPDYZ22LGSSh+a8AqiDG5o9JP2+HbaY+knD32Uz/teoZWltgIecDiGMrlmq1evTo5ds2aNpPQBmXpQ0FD/vn37JJWqnCifB3Mefrkp82DL54yTVeN4ZRQPZTyk+r5ZVRTlogTjXM5hnJln9g8I2sqDuX+gAsqmTKvcop+MKw9JlOGv4XQP2v4YrxCzKi+OpV7vnUU7Kvmz2TYyV+i/V93RHutHRbkRyjJ/GJ/B6Lx9FnyUZvKU6i6+P9ZAo/ORogprQUflRYFEKdVA0/dg9uD3XGtra5lKld+1Fu4t3O/98xCf8zvVPlvwnv8d61+5H2T9AUy93ofT/y7Pqtf3j/sB9fn67X2Bc3nPtxk416qOvdr6VN1bfP/8q1dQ23NaWlrU0tIpqTTaoKWlM3MhKqu+mfqdFdrVyLHy7bPPoZXmIu8zD/w8zLruXlXvj836e4Nzme9+/vE+P9u281mlcffz25dp21TttZuu7f4704wknlIRvhfMAci+JxVC+MKcf2ZCKRUEQRA0HMLyOioanc9e+N6M2fdmQSm1sLPy7TcN3wulVDOxZs2aZLPqC1/4gqRUySGlm2AohnzyCkLfWRxCDWUXln7yk59IShc/nvzkJ0sqD/fO2kTxIfb//d//LSn9A5/NMTbC7ObUPffcI6l8kQD1yUtf+lJJqUKI46xiiE0hFtSwAPDqqrVrC0oiFCZSujmGeopNsK1bt5b0/4wzzpBUujjAhhqbMyxOsHHpk5SwkJiVLAfVGhtotIvrQNut9QT9WrRokb71rTM1PLyspJ7ly0d0zTWvSsbB1kub2exjPqFm85tFbBbaTSvmJNfdh9qzGcecsmPnF1C5rmzk0VY2GO3GFudwvekL85tjv/GNb5SMh+3/JZdcIimd15z74IMPlvyM3YDdlKS/nItyie8f8+s73/mOpNLNYNSEV199taR0zPymMGpH5sPZZ5+dlPHMZz5TUnr9H3nkkZJ6aRfjZOeM3zi8++671cxMTOV0vBgGFUqpYC7Q0daqrvZWjU3mNDAai1LVUPOilFefWAk4NyGvCAKf2Y0HG3uD4xe6z4KGgshnv7MeO9wcKZeyvG8NN0e7Q8cxvEf5PNh4xQqv9oHS77Zw4+TGyvvcTChbSh8MaQdybi+1p4+2T36n09+cwfs1ZfUfaLPfIfL+TbY8+u+9hXz77AMF5dM2buyUj8qIPnl/LKnybiplE+rgdyptv/24+nnGw799KOABmjb5c+g/15I6rHKP+jgW3xHGiHqn817y84wHGu8LlbUjzgOqnyv0k/agULR+bPTb70Dy6r3l7Pfcf88aGT4QnB4kKqUZPaWaO/vesAnfq8RsjEUQBEEQzAWODqP8lBYvKA9BDYLTkb7udo0NjmtoPHylqiGUUkEQBEHDGZ8i810Fc+/2xvsojc/gKTUr2fcmZlZKzUYoYzD7tLW1lW0a2dBpFvTZOGETgBBp8DYHFp+cwm/WscHB53ajhf8Tks6mRaUEHHazpFKoN2WgOmJTkHZaXypULJzrw7YYF9ppN9aAYzgHlQ8bara/wDH0jw1Er5CiTMbD9t+Hy3urBzbF/AaolI5nZ2en2tvbykL+2tra1N7entlfxp1++1cfVpm10eWP9clwuHYcZ0NOGRvmtQ/fp31sDtrNKdrABp8PuaM+Nq+yLBC4dnxH6APHeDsDu1nmExoxV5l/PnzWjhmbcsxnNlAZK1RYflPQtp3P/LyjXT70MCv0j/Kyfhc0E0eKJudLFnSorYIXYxCcbvR2tevQ4LgGw+y8Kmr2lNq8ebOkVBprpbDIsLk58MpNyWc480oWKf0lzC98VB/cDPilzEOBvcF49QVSeK/G8Bn2pPTGRb3cuLlJeQVN1o2AGzU3SX6mLO/HYP2JfPw5N1/ORX3k+2rL5dVLzv1DCmNs4/L5zKt7KAvFDO2wsnluvsjHOWbLli0l4+AVRPb/PJTQDsaGsrwKzd7YfaY+n/0N3y8/P6T0elO/P5dj6Zv9A4Ly/HVl3L1SDBm/fbBhnPlu3H///SVtZg77+SiVq4t4sKEsfs7yFOP7w7jSRj+GKBTtQzN4U06vxGNcsjwO/HdgOtPdoDmYSaXU3job4XtT07YB9dJsKKWq8pSKRakgCIJgnpP4SUXoXjCHwFdqYCwWpaohrOCDIAiChpOG783kKXUqw/eKSqkGLkolRued1SxKhdF5EARBML9JMu+FL08whyAD31AsSlVFTUqpqampRLmCCspmUkM9g0ICFQReU6guvCrD4hUcqDwoGxVGluFhJYUIbfW+SNbMkWNRKKFg8W1E5ZLVdur3/kc+24r34rGf+WxswJjS76zMgXzmpefer4r6rT8Q2Q0x6UQ5hDkj48JYWl8m77OFusdnF/JydtsvDFMxeuQaMd9Q02Upa5gTXk1E/xkrzrVKKe+pRL+85Drrunv1HOofn7mQOphTtu1Z6i0pvUZZakLfdm9cm5VlxtfB+Po5w/veH4v6rWyfMWPe+4xNvk9WhUYbfbaboHlJTMYreCl1zkL43sxG560lxzWCkaK3wMJpFqUYi8lQSjUV+/bt049//GNJ6X1iw4YNyef83uX3P7/DeXbidy7nnnnmmZLSe649h9/LHIvaGVPvrEy6wL2E+zEm5twfL7/8ckmpabdUblJ9zjnnSErvv5TJPYRnOnuf4P/cuxkbFPqYVXOfQlksSQ888ICk9P7DmFx88cWS0ucR2mnvOZzjfSdpj8+knKX+xV+U593zzz+/pD78T3m1SnXGZNGiReruXqDJyUJ7uO+eccYqPfaxZyTXzoY88qxG2xgbf1/mlXYxpvZY2uafZf2zXNazBP3kWdFHOzC29hnCe2r6sEWvQiejt41y8M9Q1O8zKNMH+9zLMyHXjuvKuHMsc8n+vUPYnh9vvsOMJefQJ/td9X6zzG++7/SBccgKueT7hRK/WekfDqVUMPdgUSrC96ojlFJBEARBwxmrWinVOHVQtZ5Sp0v43ngopYIgCIJ5TiilgrlIb3dxUSqUUlVRk1JqcnKybEchKwsbq/nsnHgfKHZfUHpYxRKKHe91Q33eJJSdBKl8Z8grlsB/LpV7N7HbQb203auCrHLGp8u1/j9SaoTIq02F7Hd1vEKHnRt2RayXFm2kLX5Xy4/lbbfdJindjZHSnSLvB0Y9eIh5xZL9Pzs13mCUXU9v9CmlO0TeF4rr67MQ+usgpTu/lMEc8uao9N/u8nGMz8hIZkR2skgRjH+W/cz7XdFfdgg5zl9jKZ2D3riVcWBO02a7u8s5PnMeeJ8yiz+H68q4srtH/X5eWvjMH+OVevZcq5az9QbNy0yhc7MRvoenVKVFqTT7XgOVUjWF74VSqlnxChap/PeyV0hwL/FG2zYbLfcUb4TMMw6/aznX+kPyrOSz0gLncl9GFWShXu47/OwVQ14FIpUbmXOuV+5YtQ145S73HZ5lvGLaluE9E/0zg1chcR1s271C2d8r/TOd9Vj1JuleMVSpDKmywTVt9Kou3wcp7b/3FvXqZ+ad7ZuPjOBnnn/92KHssnBOpSiKSn2Q0vnLe95QnHO5trbf1OsVS74+bwRvj/F/x/Ad4X1vZm7nHW3k+Zux4u8Q/kbg1X4fvXq9UtbzZqF/qDCuoZQK5hKJUioWpaoilFJBEARBwxmbcVGqGL7XwNA5stlVNjon+14DPaWqUko1PpQxCIIgCOYCZN9b1tMxw5FBcPoQ4Xu10dxL60EQBMFpwfgMfk6zopSamD58bzaVUtN5SiVj0cAFumD2WblyZaLGQClkVRk+6y6vqCJQUPA+KhGrtkLFhNoI9QWqG69UxzdKSlUs3juSbLCokinz9ttvT871ShBUINSH+hiFNj5VZOmVUv8nzvEK9u9973sl/bUKWxQpjAnjjE8m6iI8feyYofJBMc3P3jeS9jBOlG3H6r777pOUjqH1jrL1WqW+zXY7MNCrwcFStdnoaLcGByeTcbDqf5/9Frge//qv/yop9fh69KMfLSmdH7YtqPhRmzMOtAOllFUboXxjbLxnKm1GoX/XXXcl56JeQ3GHmu6MM84oaTPHMXYPP/xwUgbHemX+zp07JaXzgvetp9RZZ51V0gfGjO8ECvkrr7xSUul8Q02Oiom5wPeKevBdy/JD5TtCW/lubN++XVnYa8yxXpnYrJB9b0mE7wVziMTofDwWpaqhpkWp1tbW5JcovxytBJmbMA8FXibO59xYOM5KdTFw9GFa/hevN7e2UB7n8DNl0WYrvfahZbTRm6PzM59byaw3yfYhZ5zDjc/W78MBOZcHGsaOG5t90PE3I37m4ZCbMTd8Hsq2bt2anMON08uovdSah2YeXqT0gcI/bFG/D82zD+FcCy/bZzx434ex2XGnv5hE8iDh5etZBuA+5I6ffZgCDxq2XsqnfsrFHJ5+e+NZKz3nXB76vbEq18OHk1qYK/4z5nKWJN3PN4xD6ZMPPeVn23Zvzu/N4Jn3PjRQSucz318fvhA0H+PF+TFj+F6ugZ5SMyiluvCUaqBSCk+p7moWpRo4FkEQBEEwF0iUUrEoFcwh8JQaCKVUVYRSKgiCIGg4M5mMz4Y6KFVKVcq+13ij80QpVYXReYTvNR/e8ybLE9B7+aAU8ceyqJ/lk8NmgPd28n6F1lMKxQibFH7T5jGPeYykdHPMZiPzfpD0z/th+Q0muylJW+m/9w5FHUJZdpPIbyh6lY/3BbL+PN6Hk00Tn9HNew9Z1Q3ls/njX/04ZWXyHR8f1+TkZJlPI23J8sUE7/PqMzj7c2y7/OYuG5eMFfOPeWDL8vX5a+OzA9s++Y1rP1cqZZa2iiE+43r7TVA/ZlnZjynPt4f5x3W2c8ZvMvtXv6HsN7ql8o1KvynsPUct3ivLjmszglIqPKWCuUQPSqnwlKqKmhalOjo6EjWKN4KWyiWwwC98HpK4WXEDyFJJIPm1Siwp/eWMsiTrXG4cPFjxigoLua0916cR9iac9LNSilzbH246qI+4aXhTQ25WUrnpKEok+suY+YcmKb35eYNTr6DhOJRNqIBsm4F2eLPwc889t6Qs2z8eXPzDn1cS2bZTDw9FjBnXyPffK9akVGqOQsobq1M/bfYm21K5GT59qWR0avvj1XyMmVeMUYf9ztAPa6Buy4Qso3OfQMArsvgO+fABKR1PXlHR+QcplHLeADUL2sgx1M91sA901MfvhKD5GZthUaqz6KM01shFKZRSFTIA9nYVw4bGZ8FTahqlVGeE7wVBEASBJJN9LxalgjlEXxid10QopYIgCIKGM1P2va5ZUCmNFcvu6qi0KFVY6G2kKWW6KFX59tueGJ1H+F4zsWLFimTj64EHHpBU6kvEps+mTZuS46V0M2THjh2SyjcR+FlKNwxRjuAD5T2s2ByzodqUd/bZZ0uSzjvvPEnpBsOdd94pKd1EspuGbFzwGSqqH//4x5JSnxxv58CmoZRuaLBZw9jgXcU5bPiw0ShJj3/84yWlm1N+M4p+Z6ms2ARkw44NFL8J5tVfbF5JqT8R5bKhw/XwGX6zQvFbWlrU0tJStsHIZ7QjSxnns83R76uvvlpSuW2Fzf5MPWx0cQ3pp99ws8odrgmbT1wTNtr8JrDd2CNjM9+JDRs2lLSVY+kL/lFWFcQ1o37G22ejy7KPwNeMNlPfE57whJJjuXZsvEvpxiHX4oorriiph/awKcn7tE+Sbr31Vknp5izf2Uc96lGSpDPPPLOk38xtKd1U5tV6wzUboxNTGireNyN8L5hLoJSK8L3qqGlRaseOp+jAgYKygZuGVazwSzhVYRRuZF1dhRvZwYOlf2y0tZUqpiRpamqy+F7h1fsCHT1aeIDhpjg+fmFybnpTLr0ZcEMbGSncaPfvP1DWNx4Ujh0rPJzwEJbPl+5Ud3cXVCmoU2yfxsdLb/p9fYuK7Sl8bh+gbB8K/ZwqtnGkeGyp9JyHgYULe4plpw9DPp0xY8VYjo9PlLRraKhwoxseviQpY3S0s6SN9iHX9vfOO/uK7bFKqVIpu1cKefm2lX6n3kkjxZ8LbeSBrqMDn67SkIfW1vTBoqenMFY7dy5y7Si0i/nHPOjsTJVSlMsDOw8H9J/2MR8GBwfkaW0tfaDjumbJ1Qt9SB/k6a+X3vOd8JJ7qzby0nO+K7Sd93fs6Cjpf1bbvP8Ur5OTpXNnyoQT0ebUj61UTTg2Vmp0a0MdensLY8R8HhsrnW9B85EsSlVQKSWhc7ORfa9CG3qKSqmBBu5qDU9Uk32v0L7xqZzy+XzmH7BBEARB0OwcHS5GI7S2qK87tBTB3AFPqTA6r46avt0jI8uVyxX+8GdxwP7RXCmmfXKy8MezDxHzMehSeUy5/4O+ra23WFapEbr9f7ooU/gDfmyMDCa8lv/RMzVV+MO9o6PQv+HhjrL+FY7jj/Wusj75naCWltI4cBchJin9I93HsLe2sujWUXztLPaR7Cdp2SMj3cW2l8a4p5ljCH1rKx7fWnxNLz/nDg2xOFYa8pXL8TOLCOVhZKOjhXZ4D4vpFqXGxjDMx9C8s9iOUkNz78NhPQWYC/l8b7EdLD51Zr7a8L3UWLxwHQcHC20cHiYUjva0Z46LbQvjnM8vKLYrV9JvsHOWxV1vxs789/Mvl0vHfWKio6T+dA51l7w/OUnonV2MK21b+jPzrKPk86xF6PJFqSk3HhMlP+fz6YIaYzQ5WXgdH48/upudJHyvgkppwSwopWZSa/UVlVKNjP8fKT6cTJd9zy6aTeby6miL70czsGDBgmRDKSsBhfcb4l7lM+cBGyB2swJFEmoXyvJh3D7JiJQmC0H9QrlsznA/8t479M2+0jbvV+TvdXazgnJ5DmIzyKtc/IaMPdeH09NP+pDVdp4r/H3Oe1r5rIi2b94HyT+HeZ8gez3sZlB7e3vF5CV+49finz+9yokx855iUrrJyQan3+jy42CfS3yGQtrsk7b4538pVQYx36ifcWVc2Cz0m9S2fv/8wblZ3mXg55V/9cq9rHNnGmd/De3P/jPOxdbAJ96xZGVxbFYSP6mFHSUb0kFwupOE74VSqipqWpTK5abKFgXszcn/0e9/oXp/KG9IKJX/kezT3XKD88oOKb3B+YcT7wvlbxq2zX4xgFefbS9r59ovqCFfr2ROaWXM/hhuyjwseLNOi5dW+3TJPEj4hzWr1KJeboa0jfr9w2BW1kFeecjkenjfIjsP/I3dGz36hwJvZmr74xdJ/IN8JQNQ2y9/o/dl2OteycPLP+D6TIL2QbrSQ4kvC2y/vemo92hjrLL6Tdv8A7PPXMm5fm5L5Qo95izX0D+c2r7SD9oxNlZu9hs0F6lSqpLJeGHONzR8L/G1ym4Du1rD41OayuXV1oAHYIzOp/OU6mhP652cymsaUVUQBEEQNC1k3lsaoXvBHKMnPKVqInu7OAiCIAjqSGIyXkGlRPgeGfIawUxKKcL3pMY9RCSeUlWE70lpyGEQBEEQzDci814wV2Gjc2Iqr7HJ5s6QWQ9qDs71yg6r3PBqokohQignvKLCfgZWVWI/92VZfKa21A+nVGVjM+d5uXKlMr3hpVVbeVVPluRXylZZeTWJl297NZIfF4tXAnmVT5ZSyKuoUKChsvL1ZpXhpc8ot1BfoaSxbfcqI/DXw0vurcrLq/b83PD9tm3318j3wX9uJf9eRebb6q9dVopof519ZkBff9Z19/3z8ytLKUU5fqx8uGTW9wu8ItLL6L3k3LbdqyYrfVeC5mGmBaFEKdXAGzcPBZUyAHa1t6mzrVXjUzkNjk1q8YLyTJ0nC4tS04XvtRuF1kQsSjUNQ0NDybMDpsmYKEvpfc2HnnFv4Xeo9ZSUsjPpUg/POfw+xhCZ9wnZs+Vy3ycUEDP02267TZJ08cUXS5K2bNmSnIsZM5mRMXSmHRs3biz5Gex9iXsK4Vq7du2SlJpZb968WVKqzrWZfHm+4P7Hcwfncg7jcOBA6i3qzb/9/ZHr4A3ebRkPPfRQSdutgbuFccfk27Zx4cKFWrx4cWJJYJ9Z2tvT42y2YK9IRqlO+VxLlOrMJczdpfJM0RzL+KP6t9l/wT/n0x7mFYb6zBWyJUupobcP+ac9jKX/m8HOId57zGMeUzI2tINjGQcbXUF9zFWu586dOyWl3wd+ts9/fCd8qKv35fQZpm0ZtNlnUibKgL5xPSjLnuP/vmpGUEqFyXkw1+gxCW0GRyfV1Ruy9+moaVGqq6tfHR14HvFHdKf5vKv4Hn+E4xdEaE6px0HWAkulBaz0D/rCcdwcFyxIF5bSRSbOwfC5UC9m4lmLUm2k4J7AHHysWH9p2X5RoNTofbh4bmn4lMeHwtlyfGaYnp7CTXPxYkLjJornpjfWnp5Ceb297cW2tpeU1d1d6EtXV2n7LPSXMZqYOCopffhizHp7J4rtSH0guO69vYXB6usr1L9qVaH+4nNUYnyNubdtCw8MEg8hR4vtKL0etK94zy72F2NzPC0mi6+FMe3paS2+EpJW7ocwMsIYjRSPKXhZtLYWXtvaGLsjybm0IV2UIky19PqnXgfM4fL5zmc9PaW+EO3tpYs3dr5zbFoWi2JHiu2ZLB5Xnm0olztePHai+HOp7wgm8e3t+IWNlhxf6H9hHNPvBmblA8U+cGy+2I70D6l08Q2vsFLfkaD5mGlBqLu9sZ5S+Xw+WRir1AapsLPVPzTeEF+pfD5fldF5S0uLOtpaNDGVj0WpIAiCYN4SSqlgrtLW2qKFnW0aHp/S0NiUlvfOfM58pqZFqY0bv53sgvHHq00nzB+alYwFs9RFHhZ9KGv16tWSyrOicRztkdJdJP4Yp2288j5pZ+1uI7uW3pQTvKcOCxF2cYY2Yc5ZSaGTmpkbM1u3GMXui9/tI3Wu7TfnsMjljVTpE7tAjKVdpPB+T+yQsQPL5+yusZMlpTu9tDHd9TtU0q5LLin036YiZqx4ZUeOn9n1Yu6wG8k42PrYmfRjRhpddu6sKSxjQfpisg/Sb1JSk4p7yZJ0kYh+cy3YEWSuUI9Xl1mVF/2iPq+U8samdleZ7xmLQswhrh2fszNpd+TZGWS8wZvv0pesXT7qZb6tWYORfqmhrE+RnDUWra2tuuUWBU3MTEqpruIizUiDFqUmc3kVk21W9JSSCiF8/UONSeE7NplLNjqm85SSCiF8E1NTmpisrFYM5hajo6NlihW7OcXvee+5x+9f70/oDcGl9Pctv5+5H6K+8L+37XMAv7u5L3iTcMhSTHO/s89Ets3Ux3059RNM76neJNzX5xXFVo1E/d4f0vuR0h6bYdgrUfzmox8HxtiOO/dyr+qmHV5ZPJ3aHay6urW1NdPLlfcYd+8D6VXJXDP7rMGxbA76zUifWTnLJN4be3sjfa5Llpcq34U0SVDpszNzhzKtYqhS27wK3z9jZ71HG/mO8Hzin0ttPdRLXzjGl8lx9vnTR0BQH/Paq+Ds7wqvWqsU5dEMHCkuSi3rqb9yOQgaTW9Xu4bHpzQwVp6wICglPKWCIAiChpManc8QvtcgTynqlyovjElSbzEDXyM8pQjdk6ZXSkmpr9REE4dlBEEQBMF09A8X/pgPo/NgLtIbGfiqpialVFtbW6KUYWXfrs77sDV2BHjfZ4VjF8DGePuwPZQrPtSPOvr7+zPbKZWn9/UZxbJiy2mrVzf5z32mO/t/rxSjn95LAHWWlKps2CFhV9NnVmOnzu4U+X6ze0pZXn3GuFiVG7tN1OfTOVfaKbT/99eO3SWfotfulFFeGmpYGpdPX7jOPtObPYdXyvIeX7a/4HeafXv8rpvdZeNcXhlD31/vA2J3gVFocW7lMM6eknbaev2Oe6XU03Z31XuCMXa0zWfMzFI3em8UvzNNe7JC/9iZpn/eIyVoPsh8x+KTB6PzRoXvjVW5KEUK30aE76EC62xrVXuFxTlIFqUifK9p2Lt3b/I7FuUqHk9S+nuWe+e5554rKVUGo6i9/fbbJaUqWKucRhHs7ynUh3KYex3PHvb/eEddeumlktLf5XjgZD1DoYCmXO633Gu8PyEeU/a+zH2Be8ZVV10lKb3vcZ9CbWUV2zwz0Y577rlHUnp/9P6YVmXl1VTcl2+++WZJ6b3rrLPOkiSdffbZkkr9uBgjVMgPP/ywJOkpT3mKpPSZhWtoVcpcv0c96lEaG1ui7u5C/+wz0/DweIl3GDA36D/PhtyfveoNHyfU31LqHca4oq4Drh3jY1VezC+e1VHke7UT40MdUukzsB2HPXv2SEqfmbnuF1xwgSTp/PPPT87x8405RL08wzEe9m8Wnlm4rsxJxpD2cY61/DjzzDNLyv/Sl74kKZ2TtJGoB+a0fZby3w3Kol6uHXOXeWnP4VjGvxk5iqdUhO8FcxDMzofGY1FqJkIpFQRBEDScVCmVrRBqdPY96m9vbVFba0vF48jA14hdreGiUqrSwpyls624QBzhe0EQBME8JTylgrkMZueNsIRoNmrOvhcEQRAEtTI+NUP2veL741M5TeXy0y4cnQgzGa1Db3dh93ygAUopVGALO2e+9aKkGg+lVFPi/WSk8ixjKCesIklK1RY+05pUriZHbYGCBMUUSiHqsseguvAqYFQfWUlqUHOgXPGZcnmfslGdWA8q6vcZ1GirVyxb9ZXP+sqrV0wzHlap5DP0oXaiPZSFCotx6DUZV2iL933yfmA+YsD2Z2RkROPj42ptLc1oNzk5qfHx8UyPL64R7/Ezx/px8Mp5ewxqozTRSmlEhFeO2/JQ7FCG9/9CfWXVRuC9pKiXOeXV2DZzoE8oQ7999j3GJU2qk+K9s7xiPSs5Et9J5hHH+nq86t96fPlICD5jTH22QRsh4D3ZfLbjZiLxlIrwvWAOkiilxhqXWbpZqGlRqqWlJblJ88vbypd92BohOUhh+eXNDYYbuzV+5lxkyj7NLL/g+UVsQ8F4YPBhUz7bn0+lKpVLvGk7r/6BI8twnLGxIVa2PbSVV3scbWJseKXNPEhSh30Y8g933Jy8oTr95X0rnWbsvNGoD6vyKXql9GGIsfOm8PSB9tkbKw+olMFc8A+SyLcZd1tGlizawlxiHLJu7Dxk+QeLSqF4tj6uI9JyyiAsg3Ooy853vhNeag5cB8IX7XX3bWRe0VYfkmnnG/+nPuYV9fmQSG/eKqXzjjb5tM7+Idg+jHmT10qZKoPmYLK40CRVXhSyxt9jk1NVLdzUwkxG69DbwPA9lFILZzA5l6QOlFKxKBUEQRDMU/ojfC+Yw2AJMRhG5zMSSqkgCIKgoVi1T2WlVLpQMzqRU703RfGUmi7zniT1Er7XkEWponfeDCbnUnhKNSNr165NvGhQlLA5J5VnLGWjgQ0OlDyPfexjJUnnnXeepNJNIsrFf+b++++XVJ59ls0E662EDw4bCGwseK8hvKespyfqIlRbtIlssHgs+XqtYueHP/yhpPKMalYZI0nbtm0rGSfbVjYK8Qf63ve+JyndYONc65vE5hDjT/3PetazJKUeXsAmDn2Tyv0R2WgiYzBjyOad9Zbk//fee6/27u3U0aOlm0aLFh3XkSO3lfm2WryaiXYwZ+gT18mqrR588EFJ6ZxhrjAPeJ/6mcNS6mvGdWez7NZbb5WUbsJdeeWVkkqzzzEnGHc2KZkTDzzwgKT0Wt5xxx0lZUrp94d+cX25NlwXNtHsnGEDj3r5PjGGlG3b7GGM2DClfDZwKYuNONopSeecc46k9LvCeIDfFLeqRupjLvrMzc3CyPhUkvwkwveCuUhPGJ1XTc2LUt5E2cpZ+QXq5ds+fTAPJZs3by4rA5NEb5LNjcUbjFuTTG9o6GXU/he7lc17+Sw3PW/8zcMDN2Irq0d55BUrPBR4BZOV3KNcoT9e6uvT7GbdWCnfG2ryuVfj2Acbmx5ZSh/YUGh5k1KUVbYtvHrDa+plXGxZ/J9+ebWdl8Bnqdwo3887HtK8vNr2lfeYk4whRpu7d++WlJrD2ocTrjfXimOZz8wv/4eGNbb1ijBvDsr79Mk+SPqkA7THm5gzdlad5L9XPuW2v97eCD3rXD++vixrMMp3wtcbNCfVZL5rbW1RZ1urxqdyDTE7H6taKVUM32vAA0QavjfzohTtnJwKT6kgCIJg/oFKqrOtVT1V3DeD4HSD8L3BCN+bkVBKBUEQBA2FRamWloLReCW6Ohq3KFV1+F5348P3FlQVvheeUs1GX19fstHDIr1dkGex3vvusLHC52ySsVlgN1q85YFXirABRJm2fl8v6hreZ1PIZ161/aGNbKhU2pTkOBvWTdu9145ViNif7SYNxzI2PhuyD/O3Gy/eDoK2UoZV5tj37UYLeBsBxtdvMNlNIto+ODiosbExjY11lJwzNjaafJZVh22Lt6vwG8lZG1z+XO/LVem6SOWeTfZ62nN9tmJ7rrdR8JYT9CUrky9l+PGFrCzfwOarzwjuMxdn2SvwGZvx9IFj/Pz2m4VS+l3glY1NNqeZZz4rtZRuSnJNsryymoEjicl5R2xeBnOS3gjfq5qaFqVaW1sTaTS/YG0aUn/TR6njb6SoTriZIHOVUjk4v2i9DxT1Iv22/kD+xuofGKiPNtsbjFdE8Rk3B24GvNI3+3DAe97Q0reDMUR+K6XSbqTe/iHMq5HsL2faTv+Q1jM23Lx4sOQB1j5Q0i+f1plrw7j7Bz7bVurnZuzVMP5hSSqfG7SRMURBhuTZp+iV0rnglXIc6x9C7bne4JP+8nDgP7dKKT82XDvG26dqzlIsMY6MiVd5+fGxDzbMN68EpI3et4nrYevjenrfM//wR7uyJOLelNf/HvCqLAtt9kq9oLlIQ+dap32w7O5o08DoZCLXr28bqjQ6b2D43khxsW1BFeF7LN5F+F4QBEEwH0ky74XJeTBHSRelInxvJmbOSx0EQRAEJ0ESOtc2/S2nu6Pw+cipVEoVw/caEf8/UoNSinbGolQQBEEwHzkSJufBHCddlIrwvZk44fA9lCNWAowSxGcw87JqJOGooqzc1yszbLYxKVVd8GrVH96PyJ8DWQotnynOZxDz6W3pq1Vq0WaUKpzLMfQlK50wY8VnnONVSEh0rULNK2QwevTKIcYfA0hrVom6asOGDbJ4KbSXVUvlmeuYG/4aZSl4mAP0m3H3YQxIpFHU2GvswwV8JkEf6mDPZe4xnrxyvX1qXisb5/p581G+E7zSDq8ctJ/Rf9rulYLe48m2xftPeQk+51qFCt9B6vdphX3a6CzpOXhVl5fAT0clD6uguUgXhKafE5idjzXQU2pGpVR343a1RmrKvldclJqM70azcOutt+pHP/pR1cfffffddasbs+pawCT9lltuqfocb9bs4blr69atFY/huWDnzp1V1wuYY3/nO9+Z9jjCF7NAZX399dfXXP/JMj7+SuXz60vea2nZrR/96DOz1gb7bJzFjh07Mv+fBc9BN9988wm3Z6Y5NR3erN3i37N+n7PBdN8BqdS71XPnnXeW/Nysz1CJUioWpYI5Smp0HuF7MxFKqSAIgqCh4Is004IQWelGJxuplJop+17jFqWGi4tt1WXfK4bvZfjHBEEQBEGzg6fUsgjfC+YofYlPaSilZqImpdT4+HiiqMnybcKXBmUKfkCoIVCWsAuFGsiqrVBmkJKWz7wqBCWH9aKp5GGDKsQbXlpPJa+m8koZj836B/SPNnoPIRQ97ALiW2T7hzLIq0zoG2237aKffnfLK2jYFWLnyO5Cnn322ZJSbyurCLL99Uoa209gB5LxYPyZD1YpxPWjX2RkxCcKI0pvWorqyL7H9aR82oiHF2XacaJ+rgnncB149QaoUvl8Z67SNsabvmVlDqQ+jvVmsfhScY5VyDFH6R/10yfKyvI289cXBZ5XV9Ffn2kvq/9+bngvtaw5SxmVvmdBc4DyaeZFqaIysSGeUlUqpRq4KHViSqlYlAqCIAjmH2TfC6VUMFcJT6nqiex7QRAEQUNBKTWTn1OilGqIp9RUVW1Iwvca6SlVhVIK/62JqeYMy5hP+GQUV/LXBwABAABJREFUQVCJfH5c+fyoe3c85k4wLc36O+bIUGGzc9nC8iQ7QTAXIHxvIML3ZqSmRalcLleWJcsqHPgMhQypj1GuoI5AdcLxVjmD6gOPHZ/u1GdQy0qNSz3enwlQzNgUqj7lLQoRVD4+OxnHW+UM9TEmPn2uTw2clRrX+wF5fNlSOn4okfxNCQUNfaBsxlpK1S5cO+8PRdlgVTDeb4n2MHb0jc/52b5H25gTKJTWrFkjKR1n+kLZUnp99+zZU9Y2+7OfQ7Y+78dEe7imBw4cKDuX6+nHjjK9mi5LZZaVatgeQ5monayqkPJ5RV1Fm+kvdVj/Nf5PvV75yGslXzDbf643baSffA+zVFbeq6rSfA+ag2pNxrvaWZQ69Uqp8amcxiankjbVA8L3FnTOfOttL4bvjYfR+ZyH+2ezpm0P6sknMt81j01BUJGBgYEkwqAZCE+pYK6ThO+NTymfz0+bgXq+E0qpIAiCoKFUuyBEVrrGKKWqa0OPCa0bGqvvotQJhe/FotScZ926ddq5c6f6+vrigTQIgrqTz+c1MDCgdevWneqm1JXIvhfMdVBKTeXyGp3IVZV9eb5S06JUW1tbomBBnWKVSihmUF+sXbtWUqpMQuVBRokstRHv4bFDPT47WFaGLzK0oRRBseLVXfTBqj5825cuXSopVXuh7mHHE+WIVc7gJeQzttFW+o/6hXbYY6gHdYn3lqKP1lPJqmdsH/zPKHouvPDCkj5I6bjecccdklIVlVddeUWRJK1evVpS6tXk1Wxcb/pi+8QNlLagSLJ+X7Y+VEHWFwoPK9RNlI8ah10jxthed65FVmY8WxbzwY4140pmGMplnL3XV5YPG//34+wz2vmybZt9lkXmlffjoj32GNrkVU+UTf/5TqFck9Isj74MriWvqNrsdfdZ//wcDpqLapVS3cXPG2F0ni6MTf9A0N7WqgUdbRqZmNLg6GRdH4ZHJgrf62rC91iUmozwvTlPa2trWWbbIAiCetJMCilIlFJhdB7MURZ2tKmlRcrnC75SsShVmXAXDoIgCBpKsijVVq2nVP3VQdX6WknGV6rOxpSJp1QVDyW0M5RSQRAEwXwjn8+HUiqY87S2tqi3M8zOq6EmpVRLS0uifkDJYVU5/B/VDT+jYLGZw6RUrWEVO6g5eA/1BUoSFBX8jOLClofKx2eq855OFq9UQZHkfYK82seqP2ibV7l4VVdWJjfq835I9AHFGGNod0S8lxSv9NNnHfRqIPseqh7fDu9pZMfQZ4yjHtQ9vNIH5oOUKqXwg6J+rtn27dtL2uGz9UnpPPNZHvnZ+3hYhRoKIK868v32aiQpVWj5ucM53h8ty/PKe5j5dvF9oEw7dt4XypdJ5j6ulW07bfBj5q87MD8tHMs1oT2UZZVZvo+UV+kaBc3F2FR1KqU0+14DlFLFMmdaGJMKvlIHB8bq/gAxXIPReUd4SgVBEATzlMGxySTRRyilgrlMT1e7BsYmG5JAp5kIpVQQBEHQUJIFoVOZfW+qOk8pyabwra8BP/2qxlOqvTWUUkEQBMH8hMx73R2tEfIUzGkapb5vNmJRKgiCIGgo1YbONXJRaqxKXyvJLkrVtx0opbqrUEol4XuT4SkVBEEQzC/6Cd0LlVQwx+npikWpaqgpfC+XyyVhVYRA2TAqIHyIkDBefZgRRujWvJkQn71790pKQ5AI98HomlAwm2ae8nfv3i0pDSey5dtzssKoCJvq7+8vqc8bkfMzx0vl4XLedJAwO8qwbSc8a/ny5ZLS0CcM3zmHNtMu2z/K4FjG3Yc+7tu3r6zthFxhZE1oGiblq1atKmmzrZ961q9fL0k644wzJKWheHyO4b2dM7fcckvJMXzG/CI0jBBA2kl7pNRo3Ibl2T748Drel9KxInyM/nlTco6zIXBcIx+miDk+P9v6PH6OerNw+su1tX3kM3+dCfHjO8IY2pBLvmc+PJBXb2hPGCXfWSkdG8riWOr12KxTzB8fRhg0J9VmvuPzRnhKVZsBUDIPEHWWWrMoRfnTQfheKKWCIAiC+cYRTM7DTyqY4/QVn/mGYlFqWkIpFQRBEDSUalVKDQ3fS9ows0qpr7v+4XtTuXyyS0b500H2vYlcKKWCIAiC+QWZ98LkPJjroL4fiEWpaanZ6BxVhFX5ZB0nVTZg9kbjKGikVOXkVReoelDSYKZu1U585tPbewUNx9lzqQ8FByon1EXU59UotgyOQeWyYMECSakaBeUQfbLjQ3mMBWV4FQzYPvF/FDooY+gLKiCvWLPqFBRaS5culZQq1fy40E5rTk+9GHujamOueOUMCiJbDsegUEOxQxt5ZSx37dqVlME18Ebz3rSbMbQqL64Z/fRzl3bxalVPKJU41ycBOHbsmKTyeWgNwL2Kz9d/4MCBkvft2HHNGDNg3LnuzDv6attCeX4caKMfy507d5aVwbH8TmCOUD9tz1I1ekVa0JyM17ooNXlqlVKNCN8bGk/neG9VSinC90IpFQRBEMwvyLwXJufBXKdR6vtmI5RSQRAEQUNJwvdmyHzXyOx745PVma1LjXmAoKyOtpaqFsYifC8IgiCYr4RSKmgWUMdH+N701KSUam1tTZQ8eB1ZULegGEEZwTkoR1BYoFjJUq6gZvJqDzx9stQ+KGG8MgMVBuegYEJZY89B9YGChXNQu3hFjVUBeV8k+ov6iLK9Usy2EWUMUJZV10ipGkVKx9crdhhnxg6yFGuoa/iMa+lh7Gz9KKNQTKEg4pU+eG8r+3/GkXopn+vAuSjprC8V14K2efUP14VxsIodq/iy9VD+4cOHJaV+YHbMuL70n/JRUzF3aQ9+TNZrbM+ePSXneFUZbaVdViFHvYyV94HKmmfAmNFG+ss8YNyZd9Rv28ec5VjO9ePPq53D/N97WwXNSbIoNYPB94Li52MNNDqvZkGoEeF7aeheR1UeaiilxmNRKgiCIJhnhFIqaBZ6ugrPtmF0Pj2hlAqCIAgayhgqpRmVUnhK1X8hptoQQsmG79XvAWKgqJSqJnRPMuF7sSgVBEEQzDNSpVT2JnkQzBV6uwpzeCDC96alZnkCigrvH2P/j6oCVRP+RCgqUHBM5wuFIgMFBe97pRJKC/t/r7qgPdSDksMqVlDsUIZV89j6gP6jzrH95dV7DFG2VzZlncs5Xv3k1UBSqnZhfFH38D5eT6hxUDDZMlACMVZcG+8d5jPO2bZxLMowVGZcOxRL9lzUPoy39+FCOYUyz3tr2fe8qoxXxpR6bZ+8qs57HPnrzJjatgFz1s9Vf5ydn77t3mupUl+lVJnmPdRoB31AXWU9zLhGqBS9VxtziWyMvL9jx46kDOrz3w3/O4KfmXf2M58pMmhOUPvM7ClVnDOTjVRKzWx03tMAT6mB0cJ3qNZFqcmpMDoPgiAI5hdHhgr3zMi+F8x1eiN8rypCKRUEQRA0lPEqQ+dYMBoZb2T2vSo8pTqLSRrq+ACB6qq3isx7ktTZHp5SQRAEwfykvxi+tyzC94I5Tm+E71VFTUqpqampRIWTpUpCTYIyBIWUV8p4pY4tg8xxfMYr79sMYlKpSoP6K6mqvB+SVXlxjFdqoS7x9aIssiqvjRs3SkrHxvsSeZ8kq7Li/wcPHpSUKli8moxxsN4+qE5Q8fgsdJyDYgZ1kq2f+jiW/oFXH1nFDmNEv7n+1OcVM/aaMRe8cga/Ju85herLwmfeQ8qTlTmQfvAec4b20BfeZ+ykVPHGODOG9MH7QXFtmQ9Sqtazqj1bH+q2LB+wQ4cOSZI2b95c8hntYTxQVNnvGZ/RB68UY456RaItg2vDdbXfJ4tXKErpNWPMvDIxaC7Gas2+1xBPqUKZ1XhKoZQaquPiGEbnfTUqpcZDKRUEQRDMM44Uw/dCKRXMdQjfi0Wp6QmlVBAEQdBQql+UInyvcZ5S1S1KFRbH6im1To3Oq1uUam8NT6kgCIJg/pHL5ROj88i+F8x1GuFT2ozUpJRqaWkp82uyqhefwc5n4eJzFBWoUKwvFIoR1Dcci/rEZl2TSlUvqFhQ+XgFj28nZUqpQqSSp5PHHy+lapZVq1ZJkh566KGS/tMerwKTUo8f2uYVUihLqM9eB1Qu3kuIsnzmtiVLlpR8LqXKJMqv5GVFvdaXyftccc38Od5zydbn5w71cw7XlDqsQs1fI+9pBtRh5wzl+bnjfchQdKEssv1EseShPlRAWdn/vB+Y7wPtYu7YPjGOqI28/5cfW6tk8hkpmX+oqrzqi3HxikEpvWb00887PidzomWm71nQHIxX6eeEUmp8MqdcLq/W1pmz1NXahmrC9xZ2Fn9njdfvAeL4aITvBUEQBMFMHB+dUK4oEl6yMIzOg7lNsigVRufTEkqpIAiCoKFUuyDEopSUqqvqRS1G5zxADNXR6Hwwyb5X3QN2Er7XANVYEARBEJyukHmvt6u9qnt2EJzOhNF5ddSklOrt7dXq1aslpb44VjnBe6g+rP+OlKoyeEVRYVUS+AGhzECpQZmonrw/k22LzTImpWoYjs3yZaINKLV8/d5LKStLmvfH8coQlGHUb72P8BtiTHiljfQXRYtVzFCeV5145Qxles8hqTz7mh8zFEJewSNJK1eulJSOHeeilEKZhFKI9vr/S+kYoUyi/xyX5Wnl/be8PxLXivdtv1G14QdGffv27Ss5lmuFosyWR38py3ss+flmrx3v2ax+UjrPGWfGw46Xz0TI9fVj6v3CbL1APYw//eY4rp1VuVnFmf2MMnjNUiZ6TyuvFAuaC/ycOttmWJQyi1ajE1Na0Fmfh9GpXF6TxW3X6pRSRcP1iSlN5fJqq4Nia3CsMOerDd9jga7ei3NBEARBcDpzZJjMe6GSCuY+WEIMjk8qn8+XZS0PCoRSKgiCIGgo41PVKaXa21rVXlwAGp2sn0rJqo1qMTqX6hfCV6unVHd740zfgyAIguB0BZPzyLwXNAN9RYV8Pi8NNyC7dLMQi1JBEARBQ6nFZDzNwFc/hZBdlKpGKdXV3pqoo+r1ADGQhO9Vq5Qqmr5PTJWpIoMgCIKgWekfjsx7QfPQ3ZE+U4bZeWVqCt/r6enRpk2bJKUhUXv37k0+92E63sTZm1gTEmXD2HxoGQ/jlOVT01vDb2+WTVmEUXGuD3ezEHJWKQSQtmelsCfk78iRIyXHAn0izCnLtBoIDfMhd/TFti8rDNJSKczKhrFRHteKn6mXsDWMsAnNkiobyWeZwfv2eCN75gJlerN8xtZKH71pN3OGNjKW/n3fFlsf7aIPWWGD3gx9w4YNJe8Tzsp8o0wbVunDQDnXm4RnmbQzVv66Uw/tYiwJwZPS8aYtvh4gfI9X23//vaZ8+uTD+Owcp176Qwho0JyM1bgoNTg2WVeFEOGDrS1KlFjT0dLSooWdbRoYndTg2KRW16ENtS5K4aORy0sTU/nE+DwIgiAImplQSgXNREtLi3o623R8dFIDo5NavWjmc+YjoZQKgiAIGkotme+sQqheoHZa2NledSw/i0fDdTI7Z3es2ux7XR3GX6uOoYxBEARBcDoTSqmg2ejrLmzQh9l5ZWpSSk1MTCRqB9QZVrmBWTKqJpRDqIow6faKJavY4Q8GDJC9+oqyvPG1rd+bZHvDb9psFSYcgxKHcikLhRD1ov6wZfj3vOE0ffEqIFs/Y+ZNu1Gl8LlVSnEsbaZ/tIf3qdern6R0XOkv19Cr2WgPahxJ2r9/f0l/vCKIOYNyyCqnUKahsqF/jB399Eo5W/+aNWskpYbeWXPTtm/ZsmXJe7SRPmBwzrELFy6UlJq427YzJoz/nj17StrO/KMdzE87ZyjPm//zvleG2bmMaom5Qbk+CQD12jHDWJ/yvJqMvvk5xHjYcr3qievNzyjIHnroobJ+Ux/9DJqT8Roy3xG+N1LHRamhoi/UwhqM0zl2qF6eUkWlVF+V2fe62lvV0lLwIBidmNKi7jB8DYIgCJqfRCkVi1JBk5CYnceiVEVCKRUEQRA0jFoz36GUGqujp9RIopSqflEKs/N67WrVanTe0tKShDvWcyyCIAiC4HSmf6iYfS/C94ImAfU9Vg5BOTUppQYGBsoUFlaN4j19wHtIobbwqgwpVaig8liyZImkyj5NKG3suYD6ByVLpfZJqbrD+2ChHOrv7y/pt/fLkcr9n5YvX57ZHttfQIlCed4PiDbTTquYoa0on1Ch0G/GhXNoh/X4YVxRDFEvr5zLtWMe2Hq4FpTrlWMomWz/Ocd7NqEysp5lUnp97Dyg/5s3b5YkHTp0qKTNqNxQ6lll3sMPPyxJOnDgQEm5jBFl006rlOJY2kq9QP3016sApfTa8Eq99Nu21ZYppeNL2xk7rwjjmtnvB232/mbey4pz+JkxtG2hLKAMvm9cd6tqZOy8z1rQfNRqMt6IrHNDJnyvWnqKxw7Vweh8KpevOXxPKqjGRidyiSdWEARBEDQ7R4ZRSoVCOGgOeiN8b0ZCKRUEQRA0jJJFqbYasu/VcSFmeKz28D2k1sN1eICwIYDVGp1LdoEulFJBEATB/IDwvVBKBc1Cb4TvzUhNSqnx8fFEMYSfDK9S6gfkPX1QiHgFBedatZP3PUI5gpID5RKv69atS85FKYR3kfcjop6sLGy+jSg4UL9Qn8/sZ5ViZBBD3QW0B9+kLKNdr56irdQLKEqsPxDQX8bK+3Dx6jOu2fd4pf/0k3ag4LHt4nrzGWPG2HBNOc6qYlBcMe7+OqByQg2EUseOu1fZcF29ygm1HXM4q62MoVfXUSZqLEnavn17Sf0c4/sCzEOr1GOucG28L5a/LvaaeWgrZaF6Q7GHL5aUzh/vEUe/aTvtY37SPgvz2nuboaDyfmSWLF+5oLkYS/zSpI62mU3GU6Pz+i3EJEbnNSwILayjUgo/qY62lqoyEEIjTN+DIAiC4HSmfzg8pYLmgg3JWJSqTCilgiAIgoaBH1JnW2tVme+6OuofvjeM0XnHqfGUSv2kOqrO/icZ1VgopYIgCIJ5wORUTsdGip5SsSgVNAk9sSg1IzUppXK5XKL2wK/Gqpz4DHWN913ifZQTq1evllSqtkJdgfrCe0l5zynKlFLvHI5FkcIriiXaYz121q9fLylVgnBspcx91Gv/wKBelCn0wftgeX8o+57vn8+6xnijPrL9Rr2EYo0+eBWW9zGy/0flgoKokucQahwpzViH+sYro3ifOqwqBqUM9axataqkPq+Coszp/In8fGNO8blVKvk/EH3bvXLIHs+14FpxjWg718Ur1rLmDG3iZ47hu0Ed1r+Jsank4ea9xexYoqryWf88u3fvLinTziXO9deE9lD/f/7nf0qSnva0pyXnMlf5PtnfI0FzMT5VXJSqUiHUiJC1VClVw6JUHbPvDYwWvoO1hO5JSlRVoZQKgiAI5gPHRibEY+2SBeEpFTQHfSxKhdF5RUIpFQRBEDQMPKW62qtbEGpEyNrQCWTfI9RveOzk20G2lZoXpRrgrxUEQRAEpyuYnC9e0KH2Knwog2AuQJKbMDqvTE1PyK2trYnqxfsX8bmUKlVQP/A+yiEULCg4rJKI//OKD47P3IZfjvUWQqHBe6hMqA+lSFa9+CGhcvJKHfriVUmMg+3nzp07M8eDcyjTtp3/+/6jjEFllKXy8ufwih8QXlvg+2D7x/VlzFBMURbt3LNnT3Iu14Qx88owQF1n1TZcV8bdezyhLqJMlFV27HzWReYZoDLiOHyqpFTdQzuoz8/hHTt2lLTTlsc40nbGjnNR4eGLZVVufrxRG1K/zxy4a9eu5FzmEf3Lyupo22HVUN7LySvE+Nz7wFm4BnxHUeh5Vd+v/MqvlJRlj9m4cWNJvUHzkS5KVfdw2VvHsDkYKaqdemrIvocpZT3D92rJvCdF+F4QBEEwv+gfKjyXhp9U0EwQvjcQi1IViSXoIAiCoGGMTdYWvreoKNfHU6IepEqpEzE6r8OiVFEptajWRakI3wuCIAjmEf1J5r0I3Quah0ZsuDYbNT0ht7S0JAoOlBVWQeGz2qGkqJSNzCt7bHkoOFC9oGhBDcLnNhsYbUJVgj+Rz2zmM/pZUKzgd4XKiD6hGOI4W4bPrma9suw53idKStU2XqHFObSd42zmQKu8sXh1C/V51ZUtgzHDy8sr43y7LP56+vEl653tN2OBiohxr+RxlOXH5VVNzA3vqUR2RKt28kol69kkpdc/y0trw4YNklLlGWOEyshn0PPZCCVp0aJFJeV6XyZUUCimyFboy7HH+Ax5HGeP9/ONPjAe9IFxoQ/2u8qxvFIv14O5xOdcY9s/2pSVTTJoDlBKdVYpw2/EotTICYTv9RSVUsP1yL6HUqrG8D2UUizsBUEQBEEzcyQy7wVNSF93GJ3PRCilgiAIgoaB0qhak/HFjVBKjdXWBikN9avHA8Tx0RMN3wulVBAEQTB/SJVSsSgVNA/JM2UYnVckFqWCIAiChoHJd193dVL8RixKDZ+QUqp+RueDidF5beEIiVIqFqWCIAiCecARFqVCKRU0Eb2hlJqRmrZtrVExIWCEeUlpqI8P3yL0h9AkQrMId+J9ew51eSNmHxJoQ8Q4FqiX+jg3K2zPG4sTVkX4FCFJ3iCakD0pDUGi3oceeqikbN8ua0xN2xgLxpcxZayoz4bPUR5tBY7xoVK0x4b38d7DDz8sKQ2P8+Gatr8eHxZI6CVlMz42jMyH1hHyxblcOx/mZUMPGUeMtvmZ/vkwSozobf2HDx8uOYdXH4Jnx50xwujbm+TTjt27d0tKwwsJAbX4eU89vl3Mv6xjvdE4Y0fYJCF69lzGxpvB0yf6wPciK3yP+n3oIeOD0bu97vSDNmcZqQfNwcBo4TvWV2XoGotSx+u6KFVUStXkKVX8nVcPT6mx4hicqNF5hO8FQRAE84D+4VBKBc0H9g2xKFWZUEoFQRAEDSNVStW4KFVHifOJKKXqaUrJQ0iti1JdYXQeBEEQzCNQSi3rCaPzoHngmXJ4fEpTufwMR89PanpCbmtrS1QQKByscgRVBcd4lYktR0pVNyhJ7LkoWFB3UDYKGW/A7dviP7M/+/bZ92gT/UNJQpupAwNsa7hNGahNPChXskzCDx06JElatmxZSb30m3MYF1uvV6ChuqF/tMcbY9t2oEzyKiMUNCiZuFaMj4Vr4+ujHajBLL4cr3Zi7nhVnVXtoUCifn+dKYsxsybqHIN6CVVRlppOKjXkxrgbFdHatWslpabl+/fvLzmX42wZlfrJK0pETMTtnGZ8/ZxgnLkOtMeONd8r2sy8pyzayHGMe1ZSAq+EpAz6i/rO9turu+x8DpqLWhdkWJQaHJvU5FRO7VUapE/H8Ilk32NRqg5G5wNJ+N4JKqViUSoIgiCYB/QPF54hQykVNBPWU3RofFKLqrS0mE+EUioIgiBoGEn4XpU34EXmxl0vtRThez01GJ33Fhewxidzmpg6ufC5E12USpVSEb4XBEEQND+pUioWpYLmoau9TR1tBVFEmJ1nU7NSClUEXjeoMKRyFYtPJ8/nKDlQR1iVBMeifsFjCEUF9VH2ihUrknNRt1AeaiZAwcFx1svKq3pQqNAOjkU5grLGqk/4P/UsXbq05GfqoI8HDx5MzqV86kVlQn2oXmif9VSifPrrj+nt7S35mbqs6ob6GDvGlXoZh3Xr1pWd61U2wDmU4a+7HRP6jWLLK7XoE6+2LsaINu/bt09Sqj7z7bOKLc5ds2aNpPS6UgZtzVLmMWa8Mu+Zs15N533JpHL/J6+i8/PSqvAqfc+oh5+9osq2adeuXSX1M97MZepgzKxSinpQ9/lryVihGLNKPe9zFjQvx2sM32tva1VPZ5uGxqd0bGSiLg+miVKqo/pb3gIT6jc8NqXFC098Dwe1WO3Z90IpFQRBEMwfwug8aFZ6u9p1ZHiiLrYQzUgopYIgCIKGUWv2Pam+GfhyuXy6KFWDUqqzvVWdxdDBkzU7Z1esVrl2kn0vjM6DIAiCJmd8MqeB4h/syyJ8L2gyyOo8EItSmdS0bdvR0ZGoL3y2MPt/Xn0GMxQ7PvubVZ/4rGAoNjjHeytZxRCqC8pAVcWxKIR4tSoNyqEeykARhoKEc1GaWO8hxoYyUOGgGPLePlb14n2gvB8Wqiuw4864Ui7KIMpAyYLah3pt272qB3ULnkMoaijDtsdn+aNcxpf6vLeY/Qz1EGUwzngu+TJsWcwVXvGFogyuLfPAqpHoD8d6dRGfo6CyflTMDcYblRfn2mx39n2rLvT9of8+6yH12jJRaHlPMVRNXH/qs3PG9sP+7D2evG+UzfDI/ynXf7/37NmjSnjllW1b0Fyk4XvV324WLejQnmOjdVmUGp1Mf5fWYnQuFcL9xodzSfjficIY1O4pFUbnQRAEwfzgaDHzXmtL4TkgCJqJJANfhO9lEkqpIAiCoGHUmn1Pqq9SamissKDT0iJ1t9e2KIUx+uDYiS8KTeXyiVl6zeF7xfaOhlIqCIIgaHL6i4tSSxZ2qq21ZYajg2BuwXNwhO9lU9MTcmdnZ6L6QVljFT2oSlBQoPJA9WFVFlKayQ3Fh5SqilBu4E+DysV7K+EbZD9DhUFZ1Iv6w9dhz/FqHpQ6ZD/jHN63vlTUQ3/pl/daWr58edn7KEUo33vuMA70EVWK/T/1b9u2TVJ6bRgjPJe8ssj2zyvTUB35TIo2k5pXMdEOjuFclEWMnT2HPqDq4nrQLuqw9QJKoPvvv7+sfHvuokWLJJWqjZgLZNJD7cRcoV3eH8u2xfthcd3x3+Jacl0sKLDwtNq7d6+kch8srzqUyhVRKMC8YipL1UfbvacTbeW6MFZcU9t/2u5VVUA7qIMxlFKlHdeOsQuaj0Qp1XVqwvdQOS3oaFNrjQ+5GKMPn8QDhA39q9novKiUGgulVBAEQdDk9OMntTBUUkHzEeF70xNKqSAIgqBhnIxS6nhdFqWKflKdtS0ISekDBEqnEwGZdkdbS5JNr1rC6DwIgiCYLxwZKtzzI/Ne0IywMRlKqWxqekpvbW0tyVzmQRFx1llnSUpVNygmUBCh6EB9YRVDixcvlpQqNlC9oMJAnUEZNpMZ76EAQhmDGmM6Hxvv7UNZqEC8CsX7U0nliiUyuKF6QXVCGfRFSj2cPLQdlQntsGqg1atXl/SH/qPY4bpwLooZey29MquSDxNtt4oyzkHlRL1eTYfqKQvvv4Qix2cM9HNISpVgzAXvw4QqiKx4VrFH27wPF3OEPmSprFC8cW189kfG1CsHrdqJ8lAOUR/toaysLHWcy3h7by/G0L9vx8Yr87y6iTlCH6y6sJKXGK9cK5/B0P7fj3vQXEwZk/FTtyhVmKe1+klJUk/nyT9AkHmvr7ujzMttJpLwvYkI3wuCIAiaG8L3lobJedCEhKfU9IRSKgiCIGgI9sZ7qrLvpUqp2helOOdksu+dqMm5ZIzOJ2PRNgiCIGhujhTD90IpFTQjyaJUKKUyqekpeWxsLFHuoPawqhOUEXgHoVxBseHVOFkqkKwsX7bMgwcPSir3abLlVFJ/+MyBVrGC8ohyfQZB79PjX6VU1eTHiDIYD/pt1U4+cyDnotBhDBkHyrBtQHm1adMmSanqxmZ7k1IFmx1DVC/Us379+pI2Uy/H2X6jEPP+R9SLQsr7Ukmpugq/K5QzqMx8Vjb8myyUh5rKZ4wDr0KSUrUR/eZnxpc+oWSzc4a2c24lvzOfbTFLbfjII4+U1Ec7+DlL3cc89qon4PvIHLL14uHEHPReYcwlzmHsrEKNOcsr84BzUOzRLquU4zpybiilmpPjxQWZrvZWddYQurZ4Yf2NzntOYFGIB4jhkzA6J3zxxBalInwvCIIgmB8knlKxKBU0ISS7iUWpbEIpFQRBEDSE1E+qNtPSRd31W5QamTjx8L2FRaPzk3mA4NxaM+9Jxuh8Mle2QB8EQRAEzcTRYvjesgjfC5qQUEpNT01PyaOjo4n6xatSpNTbBvUFSg3OQUnBuTYbGHhPG5QZ1SgqvO8RyhSfHYzXLLWVV6bQVp9BDEWJVeOgKqIdPsMZ/c1SG1GuV1lRv8+gZlUxqF7w40JlRplk0EOpkqUU471KGdS8useOHded+rn+jIetx7edNqI6oh1e3YVCLqvtfl55Xyifnc4q1FAxoSaiDK86or9W7VNJeed9ybzHkx1Lxoj+8p3hlbKZQzZjov9uUL4fQ1RXNmMj/fBzkbJQSnHu1q1bJZVmygTO4TNUb5A1plwTPsvKqhjMfQhdW1Tjgkw9w/dQSp2Mp9TwSYTvEcJY6xhIqVIqn5fGp3Lqaq+9D0EQBEEwF+gfLtzzQykVNCPhKTU9oZQKgiAIGsKJZN6TpEV1XJQaOcXZ904qfM8sQoXZeRAEQdDMpJ5Stamrg2AuEOF70xOLUkEQBEFDGBgrLCrVGr5XV6XUSWTfS4zOT+IBYuAkwvc62lqEwHAsfKWCIAiCJibxlIrwvaAJ6YnwvWmp6Sm5paUlCfchRMyGe/mwPcKJCBsiJIhQKH7OConyYWOE+fhQMOuzwbmEuhHWRliRNQf351KuN0X3IVn0EbNswpvsMT7UyoePwfLly5P/+7HACBqD6UohYvb/hGsxvj7Uj+Oo15qG+7E5cOCApPQaUib9tyFwPrTQm4f7sEk77rSZz2ibN8P3pvl2HtAvjuFcHybqx9++59tIHwgvpCzb7x07dpR8RjsYK74jK1euLGm7DU1kfnMO/fXznJ9t+JwfZ/oPhCZSJt9LWy9hc7zyXfXXziYjAJ9QgLHEpJ5zqNeH9dljskJpg7nPiaqEWJQaHJtULpdXa2vLDGdU5uSy7xXaPXISSqnBZAxq3/ltaWlRd3ubRiamQikVBEEQNDVHhiP7XtC89KG+j0WpTEIpFQRBEDSEEw3fY1Eqn0/LOFGGE6VU7UqlBZ3FBf+TUCkNJmqx2uuXpO6i2fnoZCilgiAIguZkdGIq2UQKT6mgGQml1PTU9JTc1dWVqH98OnhJ2rVrV8nxKDl4RWWCgoNXqwpBMYHqw6t9KMubWEvlBtMoUrwaBhWIVex4Y3Vvjk59/tUqjLz6xKqZbL1eUWXHppLKxytn7Lkci4qGMaR/tAsVkldSSeWqF64zSiGO5Vw77pzj1VaAUsab2Nu2U4a/zocPHy7pP8fRLttvzuXVl03beV8qVyrxMyon305UQBbO9Uo1xnDt2rUlfbFqJ+YCc4Z+ofKrpNSTUnN25pWf9xxLGVYpRj28MkZcZ1R0nEMZ1qSd68r1RD3IsX68aa+UGtsfOnRIUrmxfNAcnGj2vc72Vi3oKCiEjo1MaPHCE/eXGD4Jo/MFHSevlDrRhTkomJ1PaDTC94IgCIImBZVUe2tLoigJgmaCqIGT3WxtVkIpFQRBEDQEsu+dyIJMvXylkvC9E3jIXVBcyDo5pdSJG51LaQa+CN8LgiAImpXET6qnMzYqg6aEZ+GxyZwmpuKZzlPTU3JHR0eidkD1cfDgwbLjUFegukD1gRoElQ1KKet1g9rC+++gwsF7afPmzZJKVSf4MdE2r7pZvHixpGz/Gu9HRR8ow/vhoCSxZdl+SKlyjLJRzjAOtu2MBfVSLsdWUhJJ6VgwVngdoWDBJ2jVqlWSpEceeURSel2kcu8g+ofahjJQ1uB1ZdtM//mZc2nz0qVLJaXXVkpVRChwUCJxLb0PFO20vkxekcdYMmbUwbW14w6MjffO8vPBQpu9io1xQG3FnPb+YFK5V5pXJNEHrotV9zHPvacT14p20Cer3KNt1IMykVfO8f22DwrU673jGF/6ybWyc4Z5xLFcs6C5OBmV0OIFHdp3fPSkF6UwOu85IaVUcVHqFGXfk6Su9qJKMsL3giAIgiblyFDhXr8sTM6DJqXHPAcOjU1qScz1EkIpFQRBEDQElFKLagzfk6RFCwo375NdlBo5KaPzOiqlTip8L5RSQRAEQfPSP4xS6sTD9YPgdKajrTXZaAxfqXJqekrO5/OJUorsbN43yYK6w/vhoJzwnj9ZeOWKz+xnVSqUg5oGlQsKDnxs9u/fX3KcVK5QQhGCD5NXnXivKdtGn42uEtaDyXtk0R7GDmULfbTjvmfPnswy6AM/7927t6Te1atXJ2WgjKJ87xPl1WbWl4lzvQ+WbwfXPet6o5zxmQL9sV4VZOEce13tOd57yX7m/ZG8QirLL8v6K9lzfUY5visopqy6zvuLeWUU4+EVc1Jlny++o7TPXx/bX/qHas73m+tO/bYM8DJrf4xXTEmpIo4xsZ8FzcPJKqWkk1+UGkoWpWpvAwtCw3XIvnciC3OFNhRVvOEpFQRBEDQpR4Yi817Q/PR2tWtscjwWpTIIpVQQBEHQEE7U6FxSImvefzw7gUK1pNn3TiB8rw5KKdRiJx6+h1IqFqWCIAiC5iTxlIqQpqCJQTU/GGbnZdT0lDw4OKitW7dKys6C5pUxKJNQWaCKQAXC8VZZgSKIY1B9oNhA7eKVFlJ5Nj9evU+O9VIC6qMe+kD/UJDwSv+zMgeiQvGKEdQneAHZLHQoZnyWOcqg34yZVWGhlAKO9Z5enOv9o6RUAeWvCX3C44lX1GdZ9XnPLsaS62A9nfjsnHPOkZT6bjEOXA/K5rrbcee6Uz6f0QfvU5aVsdGPN9cQtZH3fpLK1VrMXRRzjBVkzRmvlKIenzGSc626jblIPYw75fs5bNV1+Dt5BRj14aHGvPCZI+2xZNDjew5cMz8PpfRaMb7WZyxoHk7G6PzSM5bq/922S9994KDectWjTrgNwyehlFpYVEqNT+Y0lcurrbU289WpXD5Rap14+F5RKTUZ4XtBEARBc0L2vVBKBc0MG5ShlConlFJBEARBQxg4CT+lX75glVpapJ/tPKp9x05cLTU8dvJKKenE1FKYrEsnn31vLJRSQRAEQZMSSqlgPtATi1IVqekpeXJyMlE4oAqxSinUHageUDmh3OBYn60sSyXBMXyGCsN7/lhVDsoQr8RCuYLKA3WGVRtRDqob+ocKxauLUNJYPx3KR+2Cmoj6efVKLntupbI4ljZbtZEfT+ph7FCocH3IYGiVUpTBOHNMf3+/pFTdRRlWBWbLkdLxrZTBzbYXFRM+X7TZX0PYsGFDSXuk1I/IZyZk/HmlPdaXifns5y7j7zNG2rZTD+X5bIPeU4w+2e8Mx1K/Vzl5jy1bP9eIa4F3FX3y9drvCm2jzd5bi1c81fz8s//nXNRX3sOLsrKyDtIHn7kymPvkcvnkpnsiSqlVfd269Iylum37Ed18zz698hc211xGPp/XcHExZ2FX7YtSXe2tammR8vmCYXqtC0vIszvbWpPFpVrpjvC9IAiCoMkJpVQwH+hjUSrC98oIpVQQBEFQd4bGJ8X674mafD/jwkK46s137z+h80cmppI2nEj4XktLixZ0nPiiEJ5aJxq6J1mj8wjfC4IgCJqT/qHCxunSWJQKmphQSlWmpifllpaWRNGQlUENPyAUGahfULKgOvEZ9FAl2XN9BjvO4ViUI1b94bPP+Tby+dKlS8vq3b59e0m9qItQqlA/9eKXZTOwoapCIYb6xWfByxo71CyU5/tH2ShLrEILdRfl0i/KQjnjPaWs6sZ7/HhvKdRGtMOqcbz/kvdW8pnksrysUB2htvHZ2Py4W7XRwYMHS8pnjFD5UJZXIdl+ojKibbSLelCmZbXdZwT0yjHGh3bZOcM889eOev0csh5qzFXGxGfS85kr7fXmXN6jzVxnPKU4DsUc/lG+H7Y+ryr0ykn7HmNDG4PmgQWZjraWJAVurTz9gjV671fv060PH9ax4QktXljb4tahgcL9o6u9VT0nEL4nSQs62jQ8PnVCGfgGx07O5FxKw/dCKRUEQRA0K0n2vQjfC5qYxOg8FqXKCKVUEARBUHds5j27EFwLm1f06NzVfZrM5fWNe2tXS+0rZu5bs7j7hNtwMhn4EqXUSSxKdeEpFUbnQRAEQROSz+fVXwzfW1Lj5lMQzCUI3xuKRakyYlEqCIIgqDsnk3nP8txHr5Uk3fiTnTWfy6LU6kUnnt2R8L3h8dofIAZPwugd0vC9UEoFQRAEzcfw+JTGixsv4SkVNDMRvleZmp6UW1tbk3CbLMNrb2iMGTUhQpyzfv36kuNsqBZhS5RLGT4kic9tKBzhQoQJEfLFuZzDqw3fI5yINnGuD82ClStXSkrDzmzbfHuoj516+muP51jaxDmEy9EuwresObw3wyasijIIm6QMwqus8TRt8qGW1MM1JAQtyySetjMPvFk94Z2UYdtI+BxhcrSRsukT4X322hG+xrG0jbHzRvo27Ix+esNv2k6ZtMvOd982ziXUzR9Hn6ypN9ed+pm7hNEx7+hT1rjzHfFzlTK9Wbytl7ZTHyGPtIPQSML2COez9TAm/MyrHxd7HZgDhIHasMSgOTgyXJifSxac3K7nr16+QR/85gP60SP9evjgoM5a2Vv1uQfqsSjVefKeUotOYlGqC6PzUEoFQRAETQiZ9zrbW08oU24QzBVQzg+E0XkZoZQKgiAI6s6RRIp/crueaxcv0FMeVdgE+Lef7Krp3H3HiuF7i7pOuH6UUiPjtS8KDdYhfC+UUkEQBEEzk2TeW9h5wqH2QTAXQDkf4Xvl1PykjMLCG1FLqeoERQy/WFBDoILCAB2scgUlhleo8PORI0ckpaqgrFTyqDCoj3Z5E3OUNFKqJkH5hHLEK5ZQn6DsseoP2kS/Kxm78zN9yTqGMaQPO3bsKPncjr838PaqH284zvFWnYK6hXHwNwXGjvGxptWUSx9oG2VRj1dsSenc4Drzao+x9VOWVagxJtTnVU2YdjMvrBE5c2HVqlUl9XnTcPprx53r7X/2aive51yrtvJzxfebtlKGN1GX0rHxr97E3NbLmPEZ9TOGqK+8SbmtH7UabfbJAWizVz1K6XWkPK8yDOY+R4sPmUvr4A/xkv91hr5z/0F9/vZd+t9Pf5Q62qrbT6lL+F7niYfvDdQjfK89jM6DIAiC5gWlVGTeC5qd3gjfq0gopYIgCIK6c5TwvTpk0vml81dpRW+nDg6M6fsPHZr5hCL7jdH5ibLgJLLfpUqpE1+YI/ve2ESE7wVBEATNR6KU6gmT86C5SRelYqPRU9P2bVtbW6IC8f5Mkso+Q5niFVN8PjAwIKnUr8krdlB9ZPni+HO9YobPvAoEJY1NQ4/KZ926dZJSFQhtRM2F2iXL44f6vYLE+zNRl/XnoW2oW6gPJQmKKc71Kh0pVZvw6pUqlInKyNbPWHhfqMWLF0tK1W28b5VSlI/6xSrQpHLVmb2WXgFFmxkrriHv82rH3XtleW8lrz7atm1b8n+ORU2FP9VDDz1Ucq6f27btvn9ZfmdSuYJNSscRZZwfO8abV6tU4ntFG2mP91ZjvluWLl0qKZ0rXl3FPPcqK7zU7P/37t0rKfX78kox/72zbWZOVvp+B3MXPKWW1mFRqqOtVY8/c7m+cudebTs0JJ1b3Xn7jxe+c/VRSp3AotTYyZu9J+F7k/EdCYIgCJqP/qH6PS8EwelManQeESKeUEoFQRAEdScJ36vTzueK3sLD6uHB8RmOLJDP55PwvTV1yL43chJG5ye3KBXhe0EQBEHzcmQIpVQsSgXNDc+Dg2F0XkbNT8ooHFBpWD8o1BSoXHzmPJ91DtWLVUl4VYv30kF9gfrIegvRJspH5UR7+DzLYwclCm3F78l7HUFWJjXaRh+8Xw4qJBQsVqmFisxn2fOZ1Xi1ihlUNt5DCNWNz/7H2FlQynjFFNeXV3/tpHRsUFOhUEIpxzXi1V5v2ki/aCPH0nafWZC+SqlCxyvyfBZAX5dt665du0qOoUzO9Sok22/aSJvxp+IaMg/Btt2r+hhfzkXRRF/sPPRqJsbbZxT0KihJ2rNnT8m53v8K+Jm+2flOuV6RR73+fZt1kWuAMg2PtqB5qJfROSzrKczrw0NjMxxZ4OjwRJJietVJGJ2TCehEFqXwDDgZo3MeYCJTSxAEQdCM9CcelLEoFTQ3PA8ORfheGaGUCoIgCOpO4im1oD5KqeU1KqVQSS1d2KGu9hNPMZ1m3ztxpdTJLEotLo7fsZGQegdBEATNRyilgvkC4XvjUzmNhS1DCTU9KU9OTpYpmSyoKFB/eN8llBOocLwKQ0qVKihHUFmg5MBbCa8jXqVUXbJz586SdqA+oX2UiReQlKo4UNmgbkF9w7koPGi7LcN7GvlsfLSDn61yBVC/9Pf3lxzLK3XYrH+ohxiLSqobn7nNqtzon/dhogyORQWzb9++5FzO4dWr6Hz2Q6vGYS4w7suXLy9pD6oyzmVsrR+WVxFRLyocxhnVmc0s6H2euO7e44jj7JgB59JW5jP10jf6ba875zKvOdZnGfTqJ1uO9yxjDFFDUUaWyooyvB8b73ufrCzvJ8aE60Ab/fy233OfsTFrXIO5zZE673wm4XtD1S1K7a9D5j1J6u48mUWpwu/Pk8m+x6LU8PiUxidz6myPvaQgCIKgeYjse8F8wW5SDo1NndSmabMRT7dBEARB3Umz79VLKVUM3xusLnyvHpn3JGlhUSk1fALhe8eLSqlF3Sc+Bn3m3FBLBUEQBM1Gkn0vwveCJqettSVR4IevVCk1bd+2trYmKpMsNQRKCNQmXmWBosOqi6TSDHoolvB08uqiSp43Unm2O+9t472estrgs4FxLN4+3lvJtp1jOQb1CfWjVEENc/DgwbK2e08lzvFZCak/qz/eh8h7/VCGVd14RRZt5Fjv/2XPBa4rr2vXrpWUek2h/rIqJ45FKUS/UTmhyELZA1ax49VO9Jt5iOqI62HHi/q8dxkwzoyhvd5cZ9Re9I968SebDp9d0ftu4W2VpeCyajmp/BryXaIO+13h+vL99X5k9NsryKyiCWUY3zeuGWXTF1+WPcf7fgXNwcj4lMaKfk712vlE1l91+N6xwu+FkzE5l9Lse6MnoZRafBIhjG2tLerrbtfA6KSOjUxoZd+J+2MFQRAEwelGkn2vTolRguB0pre7XSMTUxqIDHwlhFIqCIIgqCvsena0tainsz7S5BVFo/OBscmq4vDxlFp1suF7J5h9b2xySqMThYW5k1FKSeErFQRBEDQn+Xw+VUpF+F4wD+gLs/NMaja6QDGCcsUqR1BIoNRAoYJCgyxxqCRQTljVD4oJVBbe+wZVjFdhSeUZ8lBheFWGV1/Zcr2ChHNRsqCKoW+2zkqZAn0GP++bZaEMfIG8XxNjZpUltB3VEf30KhQ8hlD0WFWQz0zoMwn67H927DiWscHbijGiDMbWXjPgXOrn3EoKOdt/n03Q+4MB7bD1ozZCAUT9Ptsec8aOGfVybVBG8cr7nONVZ7Z/3oeLcWYc/PG2TWvWrCk5l34yZ/089G2wP1MG/ffzwiqlqN9nZPSqOuahVcgxZ/l+++9uMLexmffsnD0ZFi1oV3triyZzefUPjWvt4gXTHp+E753kotTCzsLvi+EalVI2W97JeEpJhUWpXUdGdDwWpYIgCIIm4vjopKZyhWfeyL4XzAcwOx8MpVQJoZQKgiAI6kq9M+9JhQXSWkL4Uk+pkwt3I/Z/tEallM2819Z6cgtzoZQKgiAImpGjxU2shZ1tiTI5CJoZzM4HwlOqhFiUCoIgCOpKvTPvQWJ2XkUGvnpl31vQWfQErFEphapp0UmqpKRYlAqCIAiakyTzXqikgnlCT4TvZVLT03I+n0/CeHxIkpSG4HhDcY4hVIfQJMKossLofEgWoT+U7cPabLkewpgIKyN8DhNpKQ1Bykp5b9tYyTzb1kNZtNmbwtNOH0IlpaFOhw4dyqwfc2kbRoYZOGFj3rybz2kP72eFsfFKH7wBe5YxNf8/fPiwpHR8CcnjZ98XWx9tog9+ntHvrDFjDtA/+u/D96YLF6V8QuGAa7d79+6ycwll86GO3jR8utBHP4/pnw/t5Bx7zSjfG6r70DuSBtgy6S/9oZ8+WQCvK1askJSamdtzGGfqof8+TJa5I6XfH75PWcb5wdzlSJ0z78GKXpRS08+XsckpHSqqqU7a6LyjGLJeo1LqeNHkfFEd1GKMYyxKBUEQBM1E+EkF842+7gjfyyKUUkEQBEFdOdYgpVS14Xu7jhQ2QBZ2tp30g+6JZt9Dlt1XB6XUolBKBUEQBE1ImnkvFqWC+UFv4ikVSilLTU/LnZ2diToEFYw1L/aKEFQXqI9QQ3hTa6t+qaTYgUrqK3uObw/vo2RCuUP7pMop6b3BOmSZpTM23ugZhUqW0bVvq1dTgTdRz1J0eXUT7aF+ys6qwxu6UxbH8LlX/9i2MUa0zY8R51KHlCplUOJUut6cw6udd5QBfLZy5UpJqboIRY+tg7ZSD+2gzZyDqs6qvjiG+qjHj6Efbzt2qAsPHjwoqdws3Buh2/nmDaRRTPE+88DPByk1g8cc/+GHHy45ljL4nO+snbuMCf3nGD+XKZOyssqrpFAM5iaJUqrO6Z2X91QXvrfjcOF7dcayhSdttL6wuCg1PDGlfD5fdXlp+N7Jj0GE7wVBEATNyJHi/XxZnZXVQXC6khidh6dUCaGUCoIgCOpK4zylqgvf29GfLkqdLBivTuXympjKDhHPop7he7EoFQRBEDQj/TwvhFIqmCdE+F42NSml2traErUDqhCrcEBtgqrGqpik1I8GbxnKsmWgusCfyKt82KVG9WHVUbTJe9qgQunv75eUnX7eq7Z49d46vE9Z1qfH99srZWgfyhHUIrYftI1x8P5Tfkyz+s2xqGF4f+/evSU/W8WOVzlRP+NCHfTR+gNxDGV45QzwPt5Dti30C0+ntWvXZraHc61fFPXSHzylli5dKimddyiq9u/fn5zr/c/w8qJ8zqEd1tPJqrWk8vFmrGjfgQMHSn62ZXgfKK8gYr739fUl59IvviuMoT/Hz13bTz92wM/Mc692k1KvMsZky5YtklK1Georr+CT0rHiWtlyg7kP2feWNspTaialVHFRatPyk1+UWmCyAY1MTKmzvbq9nHqG7yWLUsPxABMEQRA0D6lSKhalgvlBbxidZxJKqSAIgqCuoJRavKDenlLVhe9tP1w/pVRne6vaWwuLsiM1+EpF+F4QBEEQTE+SfS+UUsE8gfC9gbEI37PUvIXrfXNsBjvUFaiHvAoCFZBXkliPIVQe/ljK9mosq7DwWf2A9njlkoVyUJ9Y/x2p3NMHZZNVy6AqoT+ofVDIeJ8m1CKStG7dOklpljfK8v2v5H1loR7UPihkUCHhPWS9mHzb6CfX0H9uYay8io4yOJdxsWXQFu93RRlkaaMvKHyy/MCYE5zL3PSZC60yzyuh8IzatWtXSR/pGz5VUqq48l5h1MMrfeQ4W3+Wv1gW9NHOS7JJUh594Rg/Z62XFgop1FWomyiL+cfPjLvNiul9zhg76mesUHJZlRdzn+vqs20Gc5tGKaWqDd/bWVRKbazDopRUUEsNjE3WlIHveFEptWhBHZVSsSgVBEEQNBGRfS+Yb6RKqViUsoRSKgiCIKgrRxvkEbECpdQ02ffy+bwJ3+upeFwtdGN2Pl79A8RA0VOqL5RSQRAEQZBJopSK8L1gntAbRueZ1LyFi4IJhYNVrKDEQCmB+gKFzM6dOyWlyiUUHFYxhAJp+fLlJfVyDvVmqT98uSg5fAYxPKasHxRKFDyLUKHQBz5HDUK9Vuniswui8qFP3pfIqp5Qm6AmYZwZX47N8t7x/l4oU6if/tOO6VRXlE//Ufn4rHjWF8lfR7ycUNuggmFe2GvLnPBzx2e7ox1+PKT0GjAOlMUr59I+e82oj3KZGyjgKqnApHK/K8aVn3fs2FHSjiyVGW2hHr4rXAdUdhxn1W3bt2+XlF4LfL5QtzHuzAPrR+YVccw7r25EDUb7mBf2PdqEZxllcuz69esllWfHtG3P8koL5ia5XD5ZPFlSZ6XUsqJSamRiSsPjk1rYWX4LOzg4ppGJKbW2SOuXLCj7/EQgA99oLUqpkaJSqo6LUiMTUxqfzFXtaxUEQRAEpzNk6w2lVDBf6E2MzmNRyhJPtkEQBEHdOD46oVxx/XVJnT2lejrb1FVckKmkliJ0b+3iBXVbvMHsfGR85vBpSLPvnXz4nlVbhVoqCIIgaAamcnmjrK7vJlYQnK4kSqlYlCqhpqflfD6fqDHwXrIKGq9QQTFSSfXD+3jvSKkiBJXFmWeeKUnatm2bpFRZgfrDKmZQf9BGlCLeY4m245MjpeoOykC5gcoG9Q/1ofqwSjGUM9RXydPHt0dKFTpA+ah7aI/P6GaPZbxRF/ksg7QPhZj1J6KN3tsH1Zf3XrKKLcbEZ6PjOvA5ZVllHMo0+sf4c30p06rabFlSqu4BronPLMd42PpRbVG/V4+hjKIvth1eteb9vxgrr0qyaivazrnWd0lKr5H/zkjlGfu8RxtjVKlv9j3vd1XJF4zrYvtPGf4a+SyMVqHmsxtmZcQM5ibsevZ2tddd0dPS0qIVvV3afXREh4fGMz2j6mlyDgtOKHyP7Hsn/6Dd1tqivu52DYxO6tjIhFb2hQdbEARBMLc5PpJuYkX4XjBfsItS+Xw++VtrvhNKqSAIgqBupFnnTl4hlAUS/0pm5/hJ1XVRCqVUTeF79R0HQiFDKRUEQRA0A/1FlVRfd7s62uJP0mB+QPjeVC6v0YnqFfjNTk1Py1NTU4liBEWHVdugZvL+QIBSwis2rOoHlQtKDX6upDayqhPatGnTJkmp545X8KDosB43PvtbJaWO9yCyZdM/r0xhzLynUFbmPs7x3j6oyagf5ZaUqk58xkLawee8okKz/fcZCxlvVC5ewWMVciizKJ9y8WFirPyY2nO8UscreBhD2s7Ptj7aZNVrUrmCyPab6+rnJOPOuNBme5z3+aK/Xt3E/OaaWl8mr0BCOUZbKdOrDW3bmXdcM66H74tVlHnl2759+ySl48p18d83e929usl/v+k33lpZSinK8yqrYO6CHLkeCqEsCIerJHtOFqWWN2BRary6RampXD5J9btoQX3GYfGCDu3USLLYFQRBEARzmSNDkXkvmH8s7EgjbQbHJhM1/nwnlqWDIAiCusFiUU9XY26yCzoKi1LDFRaIdjQwfK9apZRdMOurk1IqMvAFQRAEzURk3gvmI62tLeErlUFNT8uTk5OJsgEFjVVOoLJAfYEyAlUPygpUGihYrPrDezqhtkB9gh+Q92uy+AxqVollz7G+ROBVNj5zGm0mO5ytH1UN6hbO9aobfrbqENQt3tOHMaWtKGgsKH8olzJ8v4FxySrLqlmkVF2D+ow6HnjggeQYsv0xdlkZ8qS0vzbTmh9v6me8ffY7r2TLgnoYB86lv7wvpdfIe2XRLu91ZcfHtxE1G8f48cfLzGYfZK4yn3w7uO70249X1mde/eXnlP3M94X5xncW5ZYfU3uOV2p5xRRz2yq1KC8rI2EwtyHFbW+DlFKpv1OFRanTIHwPNVNXe6u62uuzOBeLUkEQBEEzcQST8zpn6g2C053ernYNjk1qKBalEkIpFQRBENSNJHyvqzGeUguTULryG/noxJQODBQWg7NM0E+URClVZfhemnmvfg/aLEodHY5FqSAIgmDu0z9UuJ8tjfC9YJ5BNAFJcYJYlAqCIAjqCItSvQ1alJoulG7P0YKycWFnW113XmtdlEoz79VvDBaFUioIgiBoIlBKLYvwvWCeQTRBhO+l1PTEnMvlkhAgzIsxLJbScCVCcgjRwSSb0DvepywbzkRoGSF+lOnD+Hi14YOEWh0/flxSGk5ESBLhRIRZEYonlYc+0QdefRgfYVXWcJv3CFOiftrjxykrnIrwKG9WzbG0mT7YtnGOD7kivM8bz1ujao6lfMLHOGbnzp2S0lA4G7ZIqBf9pC/8zHjQThsCx/99GB3v009vOE64m20jbQba6OeUDV3zxv20wxvfg62DsWJ8K4Wk+bG0c5Z+MCc4lvasW7dOUnpNrUm8N/BnzAhTZE4zplmhf4wrc5fvKH1btWqVpDTMEEN+Wx9t5hzGnRDLrNBDf6182GgwdxlIwvcapJSaJnxvd3FRav2SBXVNsUv43nCN4XuL6hjCGOF7QRAEQTOReEqFUiqYZ/QWlVIRvpcSfwkGQRAEdWOowUqphdOolnYfKS5KLS33yzsZ6Eu1Dw/HR+ubeU+KRakgCIKguYjse8F8hefKgViUSqjpr4a2trZEDYK5tU8LL6WKHNQPKDVQpViFklSqoEC5wSvlowqhTNQp9lzqqaRuoX5e7U66V8ZUMg9HKUIfVqxYkZTBOb5f9AX1i2+vVG4azTneNBq1j1XJ8BnveYXMypUrJUmbN2+WJN13332SSo24KcMbunujb8bDKrmoh3NoB2VyDen/4sWLk3NRU3l1EWWh+qEdhw4dKhkXWz/1cX1RWflraxVqfm5Qr1f5eANyKZ0/tI1XP7+8GszOWW9KjhKNMWS+WWWcb7tXhHCun1PWaJy2oIzy5uxcK+Y0x1tlpG8z15X+o67yc8i22Y93MPdpdPhed0dlpdSu4qLUhjovShGGN1hl7P8AnlJ1VIuxKHU8FqWCIAiCJqB/OLLvBfOT3q7CM10opVJCKRUEQRDUjcaH7xU3LKYN36ufybmUPjxUa0h5fARPqfoppXhox4MjCIIgCOYyoZQK5iuE71W72TkfqOmvhvb29kSpg9IBLxopVZOgbkFBsX//fkmpGgI1Bn46VnXj/Y94pT6vYLJwDPXzs1fS0IcsbyPajNrDewwB9WepXjgHxQo/UyZ9sOoQr6rilf6jXNm6dWtZe1DAUD598Mog1G0cZ6+d99+if16ptXv3bkmlCjk+owyvEOJnlDLWY4sx8uo5FDyMEWPolWu2f/TbK/XoJ4odO3Ycw/jyGYog2uzLtMcyFhxLfznHq/qYn1nHUBZjhJcU9TLHbD2MCfVTFmNLffY7g/KKceS7SJ+sd5RU7u1m8d8d5iOvnGMVXdRLf8JTqnkYHCt8Vxsdvjea4e/UsPC97tpk1mn2vfqNAQ/teHAEQRAEwVymP1mUqt8GThDMBXiuDKPzlPhLMAiCIKgbSfheg5RSCxKj8/Ib+a4jhUXd9UsaE75HWN5MpOF79XvQXt6TKqVyufwMRwdBEATB6cvEVC7xX4zwvWC+0dMVi1Kemv5qmJqaShQOqFOsTwyKFBQZPhtbpSxsNhuZV5+g+vC+OJyTpdzwaisUQlZdY8uUUoUQ/kuci6rKn+uVU1KqLvGKKc5FSeJVQVKqoqEdlMHrnj17JGVncOM9PH0YI591jfbRb9t/MujRL1u+lF5v77Fkj/WZ3HzWQ58NTyrPbsi4o5Dyihp/HaRUCUQfvB8U83H16tUln9tyUUbRNpREjBFjmDVXfV/8d4TvAT/bMshux7nU4z2+KNOqjbx3Fcd6T68s7ynGmX5TPmPj1VdeqWjrQYHmswFSB/Pejnsoo5qXobHCXOprkFJqQQVPqYmpnPYdL8zBjfX2lKrx4YHwvXp6Si0pPrTn8gWz88hWFARBEMxVjg4XnoVbWlLPxCCYLyTPlRG+lxB/GQZBEAR1A9+lnkZn33Phe/uOjSqXlzrbWrWit3zh/2ToNUbnPilDFmn4Xv0etDvbWxPF1uEI4QuCIAjmMPgjLl7Qofa2+HM0mF9E+F45Nf3VMD4+XuZTg1pDShUgZN1CXYHqBKXI8uXLJaWqC+sp5dUW3msJryHqtZ5OPuuaLx9VFZ+j4LDHkN1t7dq1ksr9iHw7s7KG0Sbr/5PVF6uY8tnVOBelllfOWH8g7xmEP5DPvlapXfY9MvRxDVHQeI8vq1jiPfDXnfpRdGX5QXkvJ6+u81nqbP+9EgdlEvV6ry2bhY7x5fpTD8cyhrTdqqNQXjGvUKL5bH+Mg1dwSakCbsOGDZLSOVvJW8xmv0MZx1gwRzmGn7Pa7tVb9JdXr6CiLuuHRX/pP35jHLtmzZqSvqFYlKQDBw6UtMl/7+cjn7rlET2wf0DvueZitba2zHzCaUqjPaUI3xtxSiky761b0l338cOwfDKX1+hELmlDJY4M139RSiqE8A2MToavVA3k83l98Y7dOnf1Il2wrjyLaRAEQTD7JH5SEboXzEN6OmNRyhNL00EQBKeYfD6vv/r6/frn/9mpO3cfO9XNOWEmpnIanSgsNPY1OPueX5RKMu/VOXRPkhZ2tIno14GxmX2lDg0WFmpX1lmxFWbntXP3nuN6y7/+TG/8p9uqUrkFQRAEjYfMexGKHsxHQilVTk1/NeRyuTKPH/uQhzKDY/gM5Q5qDxQmeABZjx3vw0QZ3mNpOlCboNhAKYNyBrWVVdugIkJVgmIEtQfKIUDhYZVaXiHj1S4odDjH+vPQRsbQj2Wl7H9SuR8UGdsgK3NcJfbu3SspHQfaTNmou+iTbaP3oSKjHcfS7yyVVVZmPClV0Hh1mVXooXLycxPFllcQ2bZ7vyvgWO9lZec7CiHKowyfKRC8P5Rl3759ktI5yyvHcu3suYwnqj7GhHbR76zvDm1j/LnOzHuriJKkFStWlPWJ/uzatavkWBRhqA75/ls11HReXfORo8MTiUfSI4eG9JiNSxpSz1Qur3v3HtcFaxc1RI01ZG6ujQrfSzylJqaUz+eT7x2Z9zYsWVjx3BOltbVFvV3tGhid1ODopFb1VT42l8sni0b1DiOMRana2Xus8HtnR/+wth8e1uYVPTOcEQRBEDSa/mL4XpicB/ORvq7C32xDsSiVEEqpIAiCUwx/OEvSwwcHpzny5PjULY/ouR/+vj79w20NKZ8dn+6OVnU0yCOC0LmpXF7jU+kidpJ5rwFKKSk1pRyYwZTy6MiEporZ8ZbVeQc4XZQqT/ARZHN0OF3Au2XroVPYkiAIggBQSi3rCZPzYP7R01V4lg2j85SatrLb29sTdU+WYgl1hff/4Wev4PHZ2qRUMYHKA2UMSg5UGFnKGpQi3rsH9QfqH16tcsN72uD1gw+OV11lZf0D2op3FuegQmJn3yqXUI9Rn89M6H+2SiGUX3yGMoUx4rp4f6ysTHLeS4h+ci59steSY3yWQVRm1ktIKh1rlDecy/zyajOf2dH6WHE9aQdjxTjjG4WyxyqlOMZnsmMOeRWUVVTxf8bMq7joi/fSysrc6Mv0SkTUYPaa+TGjfn5mnDnOqpwYT+aOV5kx333GRHvt/PzySjDmYVZ/aQuv9prMR/YeSz3rth4q96mrF997sPBH+c1379drrjiz7uWzKNUoPykpNTqXCiF8Xe2Fn5PwvSWNWZTq7W6Xjs0stSZ0b/GCDnW213dhbllP4TseRufVc2wk/Z35g4cO6+WP33QKWxMEQRBIqfdihO8F85EkfG98skT1P58JpVQQBMEpxiqlHjnYmEWpfD6vu4t+VbfvOKLxycqLoycKOz6NXJTqaGtVR1sxNLeYgW/fsVHdv6+w+LyhUUqpotn5TEopFqVW9Nb/QXt58eH9yGmwKDUyPpUowk5njhil1A+2HlJuDrQ5CIKg2TkSRufBPIbn5HxeiX3HfCcWpYIgCE4xVin1yKGhhvzhvP/4WKKwGZvMNcRQfQClVINMziHxlRqf0kMHBvXC636gw0PjWre4WxdvWNyQOnuT8L3p/c8ODTbGT0pKd5RPtVLq2MiEfuEvv6Xn/P1/J4tws8kPtx7WF3+6u6pjjw6n1+vI8ITu3Xe8Uc0KgiAIqiTxlAqlVDAPWdDRJqxdH2lghMRcoqa/HKy0jFApm6J+2bJlJa+EHBHyQ6gO4U2YHNtQQEKPCIGzoX1SGorFuYQZ2WN9uCChWNTLK+2zbSMEiVfCpSiL8DXqsmblnMN7hEYRvuVD0yy0kVAoH0ZGfwlzWrlyZXKuDz1ctGhRyfveLPuMM84oq3/nzp0lbfXG2rSHEDFr+E3bOIcxou2+LHu9+T/n+L5Qth9bO+6MGeFknOND3ijbhj5SDmUwDyiDcwhFtGGDBw4cKKmXOYEpOPXyXbGm+MDYcC5zg9A3Pw52fLgmHMv3zofG0WYM8aXysEQ/7owL7SMEk++fPccnEOC6853Jmu/edH++y1b3HjVhkRNT2j8wqrWL66v4uXtP6Zz6n0f6ddmmpRWOPjFmQyklFXyljo9OamR8Su/+j7u1++iIzlrRo8/8xuOS7Hz1ptpMKYcTpVT9F6WWnyZG5w8dGNDR4QkdHZ7Qr//f/9G//OYTtHjh7PiC5PN5vemG23R0eEKXb16qDUunN7a3i1JSIYTvwnWNWbgMgiAIqiOUUsF8pqWlRReuW6w7dx/Tiz72Q739uefrZY87Y17/PRRKqSAIglOMDd+TpIcbEMJ31+6CQoTQtx9v6697HUOJp1RjFyhYeEIpJUl//9LHzrhAcTIsYlHqFIbvLTtNwvcODqT137v3uP73jXfMXt2DY8lCExkXp+PoSKGtF68vLESF2XkQBMGpJ5RSwXznY79+mX7hrOUamZjSn950l157/Y914PjozCc2KTVtKXd0dCSqC5QbVgWB6sWnmUd1gZk3nx8/XvgjyaovvOG0V4ygaKEMq5hB/YF6C4UKShbK3Ldvn6RSFZZXMaHk8ObNtBVlj1VqUS8KHdRH9Mmqi6RS42nO8Yot6uN9FDu27V6xQ5s41pvH0y7bHspHZcW19OqygwcPloyTlF4T6kVBQ32or7jeFtpA/cwRrp1XGVFmltE76rF77723pN/gjdilcuWV7y+vzGWUYrbftJF+Hjp0qKRd9Il5Z03yvTm/r9fPc/oglZuh+7GirSjjrBqKucp4Ui7n8DnfgyxzfOqnvlWrVslilYi2T1I6z/h+237NRwjfW9TdruOjk3r44KCuOHtFXetAKfXcR6/TTT/drR9v69dULq+21vrtyqAi6pul8L2hscnEyHrVovorkyxJ+N5MRufFBZvlDVBKLTPhe6fSGPNwMfvf5uULte3wsL73wCFNTOUalnHRsv3wcPJ/QiWngwWsZ160RnfuPqafbDtS93kfBEEQ1MaRocLv5npnqQ2CucL6JQt0w+ser0/e8og+8PX79Z37D+oZf/c9vff5F+tZF6891c2bdUIpFQRBcArJ5/OJUuqJWwoLUQ83IL787j2FReEXXbZBPZ1tGhid1H119tfBBJxUt42CDHz7jo8K+60lCxr7YIv6ayajcxZsGhG+x8P72GTulBpjsvD2hLOWq6+7XeNTOT24f3CGs+rDNvPdODgw844ii1JPOGuZervaNTg2mZjiB0EQBLPP2ORUsokV4XvBfKa1tUWve/JZ+vLvPkkXrF2kI8MTetMNt+v3//UOHZ/Bw7TZqGk7u7OzM1FsZPnj+LTuKEn6+vokpWoP72dj1ReV1C0+3T1KIas2QtVB+bTRqzA4zvraeO8qPkMNUsmfCTWMVK4IQhlSqT1WMcN7fnx5n1cUNXasaRuvlIG3UX9/IUwHVQpjbHfZ6T8KFj7zO/EopOz79JNyGTPUNoxL1pwBf+28t5dXvVmlFvPL+195ZRrYtqNEou2MEeWjkPK+WFLp3MvqH8oxyuD7YD21qJ/+UQ/v88r7XB97DuPv5yav9MW2lznKq/fS8sox5laWMoP+oIyin3hY4S3lv2O2Hjsmpxsj41N62+d/rmdcuEbPeXT9dy6ODE9orJgJ7xe2LNd/3r2v7uF7R4bGtfto4btz0YbFumzzMn3vgYP6ybYjdfXXGZyl8L0FxUWpPcU+9XW1q7O9sXssqL9mMjo/mBid1/9Be2Fnm7raWzU2mVP/0Lh6GuzdVQlCFFf2demidYv1w4cP6649x3TBukUznHnyWKXUwSpM1o8WQ0SW93Tp0k1LC/N+e/+stDUIgiAoh82CttaWhiurg2Au8KjVffrib1+hD33rAV333a36wk9369aHD+uvX/QYPbHOkROnK1X9JrCm3/zRyh/xdhHJ/5HOz/zxzB+0/PHsy8rC/6HtDb+zFqWma6M9zr7vFxT8opQPV6RPNiSK93x9vj1+8cS+R38qtZ2ybHv9sXzmw7n8cbZ+f65flPLG1HZxhjFhnjBmvr6s61ypzf5934cs033qrzSvOMeOnV0YzKqPeeYXjbLq8W2b6TpI5dfbm5SDn9tZ/fPXwffRXjPfZh+26sNIp5sz/lr5Ba6s609b/EJmpYXEU8k37t2vL/1sj+7YebQhi1IsrKzo7dS5awoLrPXOxIFKatPyhVrU3aHz1/Tpew8cLPkDvx7gtzRb4XsstC3pabzJdrVG54cGCt+3RoTvtbS0aHlPp/YcG1X/0Lg2Lmuch9Z0oAZb3tOpi9Yv0g8fPqy7dx+TLt/Y8Lq3HbZKqekXpcYncxoqKsqWLOzQ5cVFqR9vO6JX/sLmRjYzCIIgqADJOpYu7FBrhFIHgSSps71Vf/iM83Tleav0+//2M20/PKyX/eOP9NorztRbn3muujsaG4VwqqnqLwd8jf793/+9oY0JgmB+MzAwUOLTdjrwSFG1tKN/WP1D43X3P9hXDN1bu3iBzlpZUJPtOjKs0Ymput2A7tlbUABeVFRFrVlcUKjtOz6zUXQtDI7PTva9hU4pNRvy/2qMzvP5fLJgs7IBi1JSwRSWRalTBeF7K/q6EpPau/bUNxS0EiVKqRkWpTA5b2mR+ro7dPnmgnrzJw0w+Q+CIAiq40iyKBWhe0HguWzTMn312ifrL75yr/75f3bok7c8ov9+8KA++JJLdNH60+tvpHpS1V8O69at086dO9XX1zevUxUGQdAY8vm8BgYGtG7dulPdlDKsMuNnO4/qaeetmubo2sHkfM3ibq3s7dLynk4dHhrXbduP1M3snHDAs1cVTP7XLl5QrLu+WT5YsGn0otSCYvY9lFKzkb2nGk+pofEpjU4UVIcr+hrTJmt2fqo4lCilurSyr7D4ds+e4w03EM/n8yWeUjMZnR8rhogsXtChttYWXbJxidpbW7T32Kh2Hx3R+iULGtbWIAiCIJvIvBcE09PT1a73veBiXXXBKr31/92pBw8M6pr/7xa9+ZfP0RufskXts5BYZrap6i+H1tZWbdiwodFtCYJgHnO6KaTAhtL9tAGLUnuKC0PrFnerpaVFv3z+av3rT3bqa3ftrduiFOqSzSsK4V5ri0qpvUfrvCg1htH57ITvoTKbjd3WasL3Dhc9jhZ0tGlhZ2PGYHnxIf7IKVVK4SnVqTNX9GhhZ5uGx6f0yKFBnb2qr2H19g+Nl2Q/nEkpdaS4KLVkQTGLame7Lly3SD/bdUw/2dav9Zesb1hbgyAIgmy4f4XJeRBMz5XnrdbNb1mqP73pTn3trn3665sf0LfvO6C/ffEl2ryi3Kt3LtN8y2xBEAR1xCul6k0SvldUbTzr4jWSpK/fvV9Tufp4bG0v9uGMZYUbGItSBwZGNTmVq3hercyWpxThexNThfGZjUWpaozOMQBvlEpKSneWT5VSanwyp+PF67y8p0ttrS26YG3BNPyu3Y0N4dtWXFzF1P7Q4Jhy03xHMDlfbObH5ZuXSZJ+HCF8QRAEp4T+ocJ9NJRSQTAzy3o69dGXX6q/ffFj1NfVrtt3HNWzPvTf+pf/2XGqm1ZXYlEqCIKgAkeHx5MsMZL0s11H627Gji8SC0VP3LJCfd3tOjgwptu2Hznp8kcnprT3eGHha/PyglJqRW+X2ltblMtXl8GsWtLse40O3yv12lq6sPFG531dqVKq0hw4OJBmemsUKKX6h+p33WoBz6z21hYtLiqQ8Di4a/exhtbN4uqji/VN5vI6OlJ5kZDP7Py4fBO+Uif/3QqCIAhq50hxw2DZLCQpCYJmoKWlRS+4dIO+9uYn6wlnLdPIxJT+6At36jv3HTjVTasbsSgVBEFQAUL3VvR2qrOtVUeHJ+qesW4PnlKLCotSne2tuur81ZKkr92196TL33VkWPl8YaEIP6LW1hatLta3p44hfMmi1CwppWBWPKWKfcrlpeHxqcxjWLBZ0SCTc0laVlzwOlVG55icL+/tTLImXbiuqJTaU59FqVwur7HJ8jFGKXXO6t5koWm6ED6UUoTvSdLjzlymP3zGufqz511Ul7YGQRAEtdEfRudBcEJsWLpQn3vdE/SKJ5whSfo//36XRio8k841YlEqCIKgAoTubVnZqwuKf3jfUccQvuHxSe06UliUOmtlb/L+My8qhPD95137pg1P8mVlHcsi2qblC0sSVaDM2lcns/N8Pp8sSvXNkqcUzMaD7YKOtsTEu5KvFAs2KxsYvreit1D2wRlMvhuFNTmHLUUD/Z399cnm+GdfvkcXvfPrenD/QMn7KKU2Le9JDNYPTaP0Q+W4xMyP5b1d+u2nna3HnbmsLm0NgiAIaiNVSsWiVBDUSmtri/74Wedr3eJu7Toyor//9oOnukl1IRalgiAIKrDtUGFB58wVPbpk4xJJ9V2UemD/oPL5wkIDf2RL0i8+aqV6u9q199iobn3k8Izl3L9vQI/9s2/oHV+6q+yzbWZRyoKHFdn/TpbRiVzigdVwo/MypVTjQwBaWlqSsMRKvlIskDQyfA+F24Hj9TWprxZMzleY+bqq+P+DA2MnHd46Mj6lf/3xTk1M5fW9Bw+VfMZc3rx8YaJGm1YpNcKiVISIBEEQnC6EUioITo6erna96+oLJUmf+N7DesBt4s1FYlEqCIKgAiilNq/o0aM3FHxs7tlbPzPn+/cVyjp3TWnGsu6ONl19yTpJ0r/+eOeM5Xz553s0NpnTd+47WPbZDqMusdRbKTUwVlgAaGkpD6+rNz6z3WzttqaLUtlKqTR8r3HtSRalBqY3+W4UGKyvMGPOgur4VE7HpvF4qobvPXhQIxMFKfrWg4Mln+0whv0r+6pYlMoI3wuCIAhOLWTfC6PzIDhxnn7hGl11wWpN5vL605vuPCXPhPUkFqWCIAgqsK3oKbV5+cJkUWf3kfooiyTpvn2FnY1zVy8q++wll2+UJH3trn06Njz9H/rff6igKNl9dKQstjxRSi0rVUrhYbW3TotShEotXtBREibYCMo8pWZptzXNwJe9KLW76M/FwlEjWNHbqZYWaSqXPyUZ+LKUUl3tbYka6cA0i0TV8PW79yX/f9gsSg2PT+pIcY5tWLZAK1FKVRG+F3/4BEEQnD70E74XSqkgOCnedfWFWtjZph9vO6L/d9uuU92ckyIWpYIgCDLI5/OJ0fnmFT3auDQNd5uYytWljvuLi1LnOaWUJD16w2Kdt6ZP45M5ffGO3RXLODYyoZ+ZkMKHDzl1ST/he6VKqXVLWJSqzyIbiqs1DVyQAR++N1vhWSxKZXlK5fP5ZBHlzJU9ZZ/Xi/a21iR07cDA7IfwsRC23C30EMJ34Hj5IlE+n9dt24/MaMY5MZXTN+/Zn/z88MGh5P8sBvd1t2tRd0dVSqkjZqE0CIIgOPWMjE9pdKLwDDUbofdB0MysX7JAb/nlR0mS3vu1e3W4jhm1Z5tYlAqCIMjgyPCEjhcVMZuW9WhFb5c621qVy5eHvA2OTZ6Ql06yKLW2fFGqpaVFL/lfBbXUv0wTwnfrw4dlFbv2D/nJqZx29md7Sq1ZXFhkq1f4XrIotXgWFqWM0XlPZ5u62hsbLgh93YUH6FseOqTf+5efJko6STo0OK6B0Um1tEiblzduUUqSVi+qvADUaPDN8hkGV/UVrvv+DK+rf7p1u1543Q9mNOO89eHDOj46qUXFxb8DA2OJf9fuo4VFqfVFLzTqn87o/Bjhe7EbHwRBcFqASqqjLfVpDILgxHnNFZt1/tpFOjo8ofd+9b5T3ZwTJhalgiAIMkD1snZxtxZ0tqm1tUXri2qpXSaE7+a79+mid35dn711e03lHxwY0+GhcbW0SOesKl+UkqTnP3a92ltbdO/e48nikueWh0rNoO2i1N5jo5rM5dXZ3lqmYMJTav/AWGJQfjIQBrh2FhalbPjebIZm8QB9w4926N/v2KO/+Mq9yWfMl/VLFqi7o7GLZNMtAA2OTeqfbt2uD37jAX3wGw8kvkr14lAx69/y3gpKqQzlEouqt28/Mm3ZN99dUEk959Frk0Un1Ip+UaoqT6miv9XSMDoPgiA4LThiTM4bHeofBPOB9rZWvef5F6mlRfr87bv0w60zJ0g6HYlFqSAIggx+9Ei/JOni9YuT9zYki1LpAtE3iuFGN9y6o6byUUltXt5TFo4GSxZ2Jln//ttlIgP8pB57RuE4G763vegndcayhWptLX34W9HbpfbWFk3l8tP+YV8t+4433k8J7HjNZvae3u7SXd1v3rtfDx0oXMeHi4snZ63sbXg7UErtz1BKvecr9+jtX7xLH/rWg/rQtx7Up27ZVte6KymlVi7KDil86MCA7t5TMPR/xCjLsrhrzzFJ0hVnr9BZxRBIFlkJ32NheKZFqbHJKQ0XwwWXLAilVBAEwekAmfdmK0FJEMwHLj1jqV72uDMkSW//4p0am5zeLuF0JBalgiAIMvh+cRHoyeesSN5DpWGVUvcX07Dev39AOw5nq5myuI/Me6uzVVLwpGL933+oPLPenqMjevjgkFpblNyMbMayRw6nRu2ettaWZAGpHr5S+4plzI5SKl0cmk2lFAsxZyxbqCvOXi5J+ofvPSwpVUqdtaKxoXuSUUq5BaBdR4Z1408KRpeXFhcpf77raE1lD41NJn80eHK5fPKZX5Ra3ZdmBbR88ad7kv8fGBjL9OMCvj+bl/doS7IoVRhXlFLrnFKqf3g80+ON5ACtLakXWBAEQXBqOTKcKqWCIKgfb33GeVrR26mtB4f0ieKz6VwiFqWCIAgcI+NTuq0YanTF2emiFEop/kCeyuUTxZNUUM5Uy33T+ElZWBS75aHDZWF2P3qkING9eP3iRCn1yMGhxN/q1qKE94K15dn9pNT/qR4Z+ChjVpRSHVYpNXuhWa94whl68y+fo8/95uP1+1edK6mw6LL/+Gii6NnSQJNzYIwPuPC96767VZO5vJ509gr96XPOl6REpVQtL//HH+mpf/WdzNDAoyMTyRz0u9yrikqpg0a9lc/n9e8/KzXp31ZBLTUwOpGYqG9avlBnrSgozrYWj9/jwveWLuxUe2uL8vnsMEZ8SxYv6ChTCQZBEASnhlBKBUFjWLywQ//nuRdIkj787Ye0/fD06vTTjViUCoIgcPx4W7/Gp3Jat7hbZxrly4alBcUR4XvbDg9pbDJVadS2KFVYLMjKvGd5zIYl6utq17GRCd21+1jJZz/ZVlg4+1+bl+mMZT1qa23R0PiU9h8f08RUTt97oKCuetp5qzLLRnWyvQaFVyVYGFhbNFBvJG2tLepsL9y+ZnO3dVVft978y4/ShqULddmmpfpfm5dqfCqnz/1oxykP39tzdET/9pOCd9O1v3SOzluzSC0tBXVSteGZx0YmdMfOozo+Oqmv/Hxv2edkclzR25WMP6xKlFLpAtHtO45qZ/+IFna26cJ1hYXRSiF8zMHlPZ3q6+6YMXyvrbVFW4pj/cD+AV+cth0qlMd3NgiCIDj1JJ5SkXkvCOrO1Y9ZpyedvUJjkzm9/Yt3nVASplNFLEoFQRA4MA+/4uwVJUac3ugclRSLBD96pD8JG5qO0Ykp3be3cO5FxrMqi/a2Vj1hSyFU7PvO1Bw112WblqqzvVVnLCv8Af7wwUH9eFu/BsYmtbynU4/ZsCSz7IvXFxYKbt8xvQH1TIxOTOlIsd+zkX1PSs3OT+Vu68sfv0mS9IWf7koWbM6aRaWUVQj93+8/oompvJ5w1jI97sxl6ulqTxZU795zLLMcz0MH0tDPr91VvijF5+esKl94s0bnPAT9cGthvj7tvFWJWm+mRSmyRLK498ihQY1P5hLPsg1L0kVPVIb37i1flCKMdTaUa0EQBEF1oGJdFuF7QVB3Wlpa9OfXXKTO9lb994OH9OWMDcbTlViUCoIgcGAq/iTjJyWl4Xv7jo1qciqn+/YW1E5PfdQqnbOqV1O5vL77wIEZy79r9zFN5vJa2deVhCNNxy8W2/HfD6a+UsdGJhI/q8s2L5WU+hltPTio79xXaMdTzl1ZMXzpsk3LJBWyop3Mbsq+Yujego42LZol/56FxRC+U5lZ7ekXrtbCzjbt7B/RVC6vhZ1tZVkOGwGhcocGxzQ5ldPA6IT+tZjh7g1P2ZIcd+G6woJntSF8DxrF0U+2HykLD3ywaOp+zuqMRalim4bHpxLfKEJUL1q3WJuLc7NS+N72/sL7m5YXjtu4dIE62lo0OpHTT3ccUS4vdba1lnhZnV9c6Lp3b3n/0nDKxivXgiAIguo4MlTMihrhe0HQEM5c0aPfemrhWfDPvnyPjo3MvFl+OhCLUkEQBIbDg2O6p/hH7hO3lC5KrerrVkdbiyZzee0fGNO9xhfqqgtWS5Ju+mmph04WP91xVJL02I1LqkqJ/ORzVkoqKLF+sq2/WMYR5fMF021Cp1DpbD04pG8XF6WurBC6J0kXrV+kzvZWHR4anzEz2nTgJ7V2cfespXjuLiqlTuWD7cLOdj29eN2lwoPAbPR/eU+X2lpblMtLh4fGdeNPdmlwbFJbVvboKcW5IqVeYvdUuyhllFL5vPT1u/eVfP7Q/spKqYWd7ertKixIYnaOkvC8NX3JgunDFebZDpMpUiooBFmg+vrdhbDYtUu6SxZYCX29b980SqmMtgZBEASnhvCUCoLG86anbtFZK3p0cGBMf3Pz/ae6OVURi1JBEASGHxTNwc9b05dk+IK21pbEM2n3kRHzR/civfjyjZKk/3rg4Izmgj/dWQiXe+wZS6tq0+YV/z979x0eRfG4Afy91EvvhZAQIJQQqjQRCCAdKQIqAhYQURCBnwXsUlREVOwgKAgWEMQG4lexgaAgiihIr4EAIb1Bem5/fySzuZ3d5JKQRng/z8MT5m7LbLnNZXbmXTfc0jEUigLM2rAPWXkF6tC9zuEly2hW/Af4R7ticDLxMuztTGqDlhFnB3u0Dy3qTSPyqSpDDCOriZBzoXFxg0WzWm50GHldQ/X/NZEnBRSdhwHFPYYupGVj9c4YAMCknk00jTYix6m8w/dENpPYp//7T9soJRqtmgUa56CpQ/gycpFbUKg2QLUM9lB7SpXW+BkjnhTpX5IB1adF0bm79s8zAKDrVSh6Sp1KvISc/JLHHyuKYjV8j41SRER1BZ++R1T9nB3s8cLINgCAj/84g39j02q3QuXARikiIisiT6pnM3/D98UQvqMXM9QcocjiP7p7tQiAogBrd58tcx17z6QBgPrEvPKYOyIKIV5mxCRn4ZmvD2D3qaIeU2LoHgAMbtMA/VsFQTykr0tjH3i5lD28TQzh23MmxWYdCgotyMor0L1u3VOqprw5tgO++79oRAYbP1mwpvRs5g9/96Iv1039ay6/SOSYffzHGZxNyYKXiyNGXxeqmUY0SsUkZyEzR9t9Oye/UDeUTmRGTb+xGYCipzsmXyrq9ZSdV4jY4oB/o+F7ANRG3ITMHJxMuIxCiwIPswMaeJnVRsT07Hw16NZaSU+pkn04tmuj4roWPUxAbpQK9HCGj6sjLApwPL6kl1fipVxk5hTAZCrJqCIiotrHnlJENaN7M3+Muq4hFAV4+qv/UFBosT1TLWKjFBFRMUVR1DypHs3LbpT66XDR8LggT2d1CNld3YqCrz/bE6vpuWEtLj0bFzNyYGcC2oWWHXJuzdPsiJdvbQ8A+HLvefxZPIyvc3GjEgB4uThixYTO+GZ6TzzQJwLP39zG5nK7FDdq7TlTdk8pRVFwy7Jd6LrgZ92T2S6mFwW/11TIOQB4mB3VnjK1ycHeDg/e2AyeZgcMah1cY+sNLO6V9uXeouGid98QDpfiIY2Cn7uzmnFlPcQt+VIubn7nd9y4eBv+Kj6PMnPy1cbFGyMD0aqBJyxKUc8/oGg4nKIUZXj5lfLHhOgpl5iZi6PxJU+XNJlMcHGyVxst5SF8OfmFiCvubWfdiNQs0B1dm5Sc3yFSo5TJZCrJlbpYMkTxZELR8sN8XGF21O4TIiKqHYqiIC2LmVJENeXpoa3gaXbAwQsZ+HDXmdquTpnYKEVEVOxsShbOp2XD0d6E663+GLbW0Lvoj2bxx7p1T52+kYFo6O2C1Kz8UrOlRJ5UZLAnXJ0qFgres7k/3r2jo9r7ydPsYJjv0zbUC48PjkTzIONhVtY6FQ//O5V4Wb2DaeRQXAb2xabhUm4BHly7Fy99d0QNRxdPRqvJRqm65J4eTbB/3iBEhdRcI5noKQUAwZ5mTLUKOLcmekuJ4Z5pWXm4c+WfOBqfCUUBVv8eA6BkaF6QpzO8XBzRrziL7OfibDIxHK55oEepuVnWT+ATT5dsGVxyDjYpZQjfudQsKArg7uyga/AaX9xbCih5+qU18fk7YvUEvlNJfPIeEVFdczmvEHnFvTX49D2i6ufv7ownhrQCALz2w1HEFd9ErovYKEVEVOy34qF7HRv5lNpg1NlquJy/uxPuuL7kj2Z7OxMmdm8MAHjpuyO6p5cBRQHlANAx3LtSdRzStgG2PNQLY7uEYd6I1qU+Wa+8vF2d1Ayhnw7Hlzrdd8X5QqLhYdmvJ9WGDvH0vZp48hwVCfIo2ddPD20FN2fj87VPcePSV3vPQ1EUzNqwH4fjMtSGzS0HLyIhM8cqxLyoEalvq6L5th9NRH6hRR0e16yUoXtAyRP4EjJy1J5ZLa0abUWj1LF4bTD5GauQc7nBa3CbYHgXP2FRDAG0FtlAhJ3re0oxT4qIqO4QQ7fNjna6nr1EVD3GdglDx0beuJxXiPmbDtV2dUrFRikiuub9ciQeW48kYHtx76fS8qQAoEczf/w6uw/+fKof/nq6PwZKQ7Ym9miMNg09kZ6dj6e++k/tTQQA3/0Xh3V/xQIArgsrX8i5kWAvM166pR1Gdwy1PXE53NS2AQBg/qaDugYDoKjL/f/+Kxqy9/TQVritU9F6VxX3shHDvq7VnlK1IbJ42FrPZv4Y1q5BqdONaB8CZwc7HI3PxLq/YvHT4XjYmYBP7+uG6xp5o8CiYMOec+pxF3lR7UO94efmhMzcAvwVk4LjCcXvlxEsL54CefBCBg4XP8GylVVPqeub+gEA1v15FulZJRlXMcWNUtYh54LZ0R7L7uyEp26KVIeaWmtV3Oh1OC4DluIwNT55j4io7lHzpNhLiqjG2NmZsGBUW9jbmfD9wYv4uYwb0LWJjVJEdM3KL7Tg2a8PYNLqPbhn9V/qo+dLy5MSwv3cEOhpNhzG5Ghvh8W3dYCjvQk/HU7Ae9tPodCi4LlvDuGBNXuRmVOA6xp5qw1BdcGMvs3QrakvLucVYvKHe/Dt/jhcyi0JND8an4lTSZfh5GCHvpGBmNSzCQDg+4MXcTw+E0nFYdhslKo5/VsF4rMpN2DFhM6lDqcDinLGRNbVM18fAFDUUBUV4ok7ri/KQFvzxxm1l6DoKWVvZ0KflkW9pbYeSbB68l7pDT3dI/zgYXbA8YRLSMgsOidaWDVKDW3bAC2DPJCRU4Bl208CKGrw3H8uDYA25Nxat6Z+uL9XhOF2Ng9yh5uTPVKz8vH6T8cAgE/eIyKqg1LEk/eYJ0VUo1o18MTk4u/uczYeNHxoUW2rWKAJEVE9cDE9Bz8cuojP/z6H/efSAQAezg7IzC2Ar5sT2jUsfwC5kZbBHnhsUCQW/O8wFn53BBv/vYBDxT1HHugTgUcGtICjfd25J+Bob4eld3TC8Ld/w9mULDy4di/Mjna4vXMYbuschs//PgcA6NU8oDhg3BE3NPXDrlPJGP7Ob7AoRePW/d2cbayJqorJZNKEgJflts6h2LTvAgqLexI9WPx0vWHtGuC5bw7iQnoOLhT3drPOgOrXKhBf7D2Hj/84g9yCohwQ0WhlJNDTjDdu74B7P9wDoOhpeZ7mkqc/2tuZMHtQS0z+aA9W/X4a14V54/cTSdj47wUAMOwJZYvZ0R7Pj2yDRz7bh7d/OYHMnAKcTyvKTGjKTCkioiqVejkP6dn5tic0IIaJ88l7RDXv//o3x+b9cTiflo1XthzFhBsaV3pZQZ7mKh+Cy0YpIrqmnE3OQq9XtqplVyd7vHF7B/Ro5o8fDl1EswAPOFRBg9F9vZoiK68Qr/90DIfiMuBkb4fFY9pjePuQK152dfB1c8KGqTfgw50x2HLwImKSs/DhrjOap3Xc1LZkqOKknk2w61QycvIt8Hd3wvK7Ol5xvhVVj+4R/mjo7YLzadkY0iZYDcA3O9pj8ZgO2PjveTja2yEiwA0dG3mr80U394erkz2y8oqeJHldI29NwLqRfq2C8FD/5njjp+Oa/LWS9wPROdwHe86k4v6P/1Zff2ZoK/RrFVSp7RvdMRQHL2Rg5W+nsXpnDAAgxMtc6lMCiYioclb9fhpv/XLiipbhzeF7RDXO1ckB80e0Lr4xGKNGcFTG2snXo3sZUSeVwUYpIrqmhPm6ICLADd6uThjUOgjD2oWoj5ofdV3VZDQJ/9e/OTzMDtj473k8Pjiyyi/gVS3E2wVP3tQKTwyJxM6TyVi+/RT2xabBycEOzQLc1WFgQNGTBoe2a4BLOQV4cXRbNPTWPxmN6gZ7OxOevCkSq3+PwWODIzXvDYgKwoAo48YgD7MjNky9ATFJWYhs4IHGfm5lDhUU/q9fc0Q390czg15VJpMJL93SFot/OIaY5CzkF1rwUP/mGNbuyhprnxwSiUKLgqRLuegQ5o1BrYPLVVciIio/Jwc7eJTyYI3ycHa0LzMHkYiqT/+oINzZrVFRD3XF9vSlqY6b0CbFOoWXiOgqk5GRAS8vL6Snp8PT09P2DABy8gthduSTX4jItspcY4iIrga8vhFRdSrvNabuhJoQEdUQNkgRERERERHVPjZKERERERERERFRjWOjFBERERERERER1Tg2ShERERERERERUY1joxQREREREREREdU4NkoREREREREREVGNY6MUERERERERERHVODZKERERERERERFRjWOjFBERERERERER1Tg2ShERERERERERUY1joxQREREREREREdU4NkoREREREREREVGNY6MUERERERERERHVODZKERERERERERFRjXOo7QoQEV0JRVEAABkZGbVcEyKqj8S1RVxriIjqC36HIqLqVN7vUGyUIqKrWmZmJgAgLCyslmtCRPVZZmYmvLy8arsaRERVht+hiKgm2PoOZVJ464+IrmIWiwUXLlyAh4cHTCZTbVeHiOoZRVGQmZmJkJAQ2Nkx9YCI6g9+hyKi6lTe71BslCIiIiIiIiIiohrHW35ERERERERERFTj2ChFREREREREREQ1jo1SRERERERERERU49goRURERERERERENY6NUkREREREREREVOPYKEVERERERERERDWOjVJERERERERERFTj2ChFREREREREREQ1jo1SRERERERERERU49goRURERERERERENY6NUkREREREREREVOPYKEVERERERERERDWOjVJEREREREREVrZt2waTyYRt27apr02cOBGNGzeutTpdrebNmweTyVTb1agSq1evhslkQkxMTG1Xpd5goxQRERERERFd9USDgdG/J554osbq0adPH826XVxc0K5dO7zxxhuwWCw1Vg8jiqIgOjoaAQEBSE5O1r0/depUODo64t9//wWg3xajf3369Km2+u7cuRPz5s1DWlpata3jSi1duhSrV6+u7WpctRxquwJEREREREREVeW5555DkyZNNK+1adOmRusQGhqKhQsXAgCSkpKwdu1aPPzww0hMTMSCBQtqtC7WTCYTli9fjg4dOmDWrFlYtWqV+t6uXbvw3nvv4ZFHHkGHDh0AAE8//TQmT55suKz169dj8+bN6NatW5nrfOaZZyrdKLhz507Mnz8fEydOhLe3d6WWUZXuuusujB07Fs7OzuprS5cuhb+/PyZOnFh7FbuKsVGKiIiIiIiI6o0hQ4agc+fOtVoHLy8v3HnnnWp56tSpiIyMxNtvv43nnnsO9vb2tVa3qKgozJ49Gy+++CImTpyI3r17Iz8/H/fffz/CwsIwf/58ddoBAwYYLuO///7Dfffdh06dOuG5554rc30ODg5wcKgfTQ/29va1euzqIw7fIyIiIiIiomuCyWTCvHnzdK83bty4Wnu6mM1mdOnSBZmZmUhISFBf379/PyZOnIimTZvCbDYjODgYkyZN0gyt279/P0wmEzZt2qS+9vfff8NkMqFjx46a9QwZMgTXX3+9zfo8++yziIiIwJQpU5CXl4fFixfjwIEDeOedd+Dm5lbmvJcvX8btt98OR0dHrF+/Hk5OTmVOb5QpZTKZMH36dHz99ddo06YNnJ2d0bp1a3z//fea+WbPng0AaNKkiTpc0DrP6ZNPPkGnTp3g4uICX19fjB07FrGxsZp19enTB23atMGhQ4dw4403wtXVFQ0bNsTLL7+sq+vbb7+N1q1bw9XVFT4+PujcuTPWrl2rvi9nSjVu3BgHDx7Er7/+qhnOeOrUKZhMJrz++uu6dezcuRMmkwmffvppmfvtWsFGKSIiIiIiIqo30tPTkZSUpPlXF8TExMBkMmmGof344484deoU7rnnHrz99tsYO3Ys1q1bh5tuugmKogAoGnro7e2N7du3q/Pt2LEDdnZ22LdvHzIyMgAAFosFO3fuRK9evWzWxWw2Y+nSpTh69CimTZuG5557DqNGjcLw4cNtzjt9+nQcPnwYy5YtQ0RERAX3QonffvsN06ZNw9ixY/Hyyy8jJycHt9xyi9ogN3r0aIwbNw4A8Prrr+Pjjz/Gxx9/jICAAADAggULcPfdd6N58+Z47bXX8NBDD+Hnn39Gr169dBlUqampGDx4MNq3b4/FixcjMjISjz/+OL777jt1mvfffx8zZ85EVFQU3njjDcyfPx8dOnTA7t27S92GN954A6GhoYiMjFTr9/TTT6Np06bo0aMH1qxZo5tnzZo18PDwwM0331zpfVef1I8+dEREREREREQA+vfvr3tNNPDUlMLCQrUxLDk5GStXrsSePXswdOhQuLi4qNNNmzYNjz76qGbebt26Ydy4cfjtt98QHR0NOzs79OjRAzt27FCn2bFjB0aOHImNGzdi586dGDx4sNpAFR0dXa46Dhw4EOPGjcPKlSvh4eGBt956y+Y8n3zyCVavXo177rkH48ePL9d6SnP48GEcOnRIbdi68cYb0b59e3z66aeYPn062rVrh44dO+LTTz/FyJEjNU8+PHPmDObOnYsXXngBTz31lPr66NGjcd1112Hp0qWa1y9cuICPPvoId911FwDg3nvvRXh4OFauXIkhQ4YAAL799lu0bt0aGzZsKPc2jBw5Es888wz8/f01wzUB4O6778aUKVNw5MgRREZGAgDy8/Px2WefYfTo0XB1da3YDqun2FOKiIiIiIiI6o0lS5bgxx9/1PyraUeOHEFAQAACAgIQGRmJV155BSNGjNA9pc26gSonJwdJSUlqcPjevXvV96Kjo7F3715cvnwZQFEvo5tuugkdOnRQG6t27NgBk8mEnj17lrue/v7+AIpypkJDQ8uc9tixY3jggQfUbKwr1b9/f01Pq3bt2sHT0xOnTp2yOe+XX34Ji8WCMWPGaHrEBQcHo3nz5ti6datmend3d02jkZOTE7p27apZl7e3N86dO4e//vrrircNAMaMGQOz2azpLbVlyxYkJSXpGrCuZewpRURERERERPVG165daz3ovHHjxnj//fdhsVhw8uRJLFiwAImJiTCbzZrpUlJSMH/+fKxbt06TNQUUDUMUoqOjUVBQgF27diEsLAwJCQmIjo7GwYMHNY1SUVFR8PX1LVcd9+zZgyVLlqBNmzbYvXs3Pvnkk1IbS3JzczFmzBgUFBRg/fr1NnOnyqNRo0a613x8fJCammpz3uPHj0NRFDRv3tzwfUdHR005NDRUl2vl4+OD/fv3q+XHH38cP/30E7p27YpmzZph4MCBGD9+PHr06FGezdHx9vbG8OHDsXbtWjz//PMAiobuNWzYEH379q3UMusjNkoRERERERHRNa2wsLBKl+fm5qYZRtijRw907NgRTz31lGaY3JgxY7Bz507Mnj0bHTp0gLu7OywWCwYPHgyLxaJO17lzZ5jNZmzfvh2NGjVCYGAgWrRogejoaCxduhS5ubnYsWMHRo0aVa76FRYW4v7770dISAh+//13DBw4EI8++iiGDRumybwSHnnkEezbtw9LlixBu3btKr9jrJT2FLvyDLW0WCwwmUz47rvvDJfj7u5e4XW1atUKR48exebNm/H999/jiy++wNKlSzFnzhzNEwkr4u6778aGDRuwc+dOtG3bFps2bcK0adNgZ8dBawIbpYiIiIiIiOia4OPjowvBzsvLQ1xcXLWut127drjzzjuxfPlyzJo1C40aNUJqaip+/vlnzJ8/H3PmzFGnPX78uG5+Mdxsx44daNSokZobFR0djdzcXKxZswbx8fHlCjkHgLfeegv//PMPvvrqK3h6emLZsmXo3LkznnjiCSxbtkwzrWicGT16NKZNm3YFe6Hi5N5NQkREBBRFQZMmTdCiRYsqW5+bmxtuv/123H777cjLy8Po0aOxYMECPPnkk7pebrbqCACDBw9GQEAA1qxZg+uvvx5ZWVlqrhUVYfMcERERERERXRMiIiI0T7EDgPfee6/Ke0oZeeyxx5Cfn4/XXnsNQEnvHbln0BtvvGE4f3R0NHbv3o2tW7eqjVL+/v5o1aoVFi1apE5jS2xsLObMmYMRI0Zg5MiRAIAOHTpg5syZeP/99zVPm4uJicHkyZMRHh6OFStWVGh7q4IYJig3JI4ePRr29vaYP3++bv8piqI+wa8i5HmcnJwQFRUFRVGQn59fZh3l+gkODg4YN24cPvvsM6xevRpt27atsp5m9QV7ShEREREREdE1YfLkyZg6dSpuueUWDBgwAPv27cOWLVvUwO/qFBUVhZtuugkrVqzAs88+Cz8/P/Tq1Qsvv/wy8vPz0bBhQ/zwww84ffq04fzR0dFYsGABYmNjNY1PvXr1wvLly9G4cWObYeUAMGPGDCiKogsrnz9/Pj777DNMnToVe/bsgb29PcaOHYu0tDTccccd+Pbbbw2X5+7urjZuVbVOnToBAJ5++mmMHTsWjo6OGD58OCIiIvDCCy/gySefRExMDEaOHAkPDw+cPn0aX331Fe6//37MmjWrQusaOHAggoOD0aNHDwQFBeHw4cN45513MHToUHh4eJRZx3fffRcvvPACmjVrhsDAQE1m1N1334233noLW7duVRsPqQQbpYiIiIiIiOiacN999+H06dNYuXIlvv/+e0RHR+PHH39Ev379amT9s2fPxrfffou3334b8+bNw9q1azFjxgwsWbIEiqJg4MCB+O677xASEqKbt3v37rC3t4erqyvat2+vvh4dHY3ly5eXq5fU119/jY0bN+LVV1/VBY17eHjgzTffxK233oq33noLDz/8sNprasmSJViyZInhMsPDw6utUapLly54/vnnsWzZMnz//fewWCw4ffo03Nzc8MQTT6BFixZ4/fXX1cynsLAwDBw4ECNGjKjwuqZMmYI1a9bgtddew6VLlxAaGoqZM2fimWeeKXO+OXPm4MyZM3j55ZeRmZmJ3r17axqlOnXqhNatW+Pw4cO44447Klyv+s6klCdFjIiIiIiIiIiIKuy6666Dr68vfv7559quSp3DTCkiIiIiIiIiomqwZ88e/Pvvv7j77rtruyp1EntKERERERERERFVoQMHDuDvv//G4sWLkZSUhFOnTpX6BL9rGXtKERERERERERFVoc8//xz33HMP8vPz8emnn7JBqhTsKUVERERERERERDWOPaWIiIiIiIiIiKjGsVGKiIiIiIiIiIhqHBuliIiIiIiIiOqRxo0bY9iwYbVdDSKb2ChFREREREREVMuysrIwb948bNu2rVzTHzp0CPPmzUNMTEy11qsuevHFF/H111/XdjWoCrBRioiIiIiIiKiWZWVlYf78+RVqlJo/fz4bpeiqxkYpIiIiIiIiIrqm5eTkwGKx1HY1rjlslCIiIiIiIiKqJnl5eZgzZw46deoELy8vuLm5ITo6Glu3blWniYmJQUBAAABg/vz5MJlMMJlMmDdvnuEyV69ejdtuuw0AcOONN6rTy72sfvvtN3Tt2hVmsxlNmzbFRx99pFtWWloaHnroIYSFhcHZ2RnNmjXDokWLyt1A891336F3797w8PCAp6cnunTpgrVr12qm2b17NwYPHgwvLy+4urqid+/e+P333zXTzJs3DyaTCSdOnMDEiRPh7e0NLy8v3HPPPcjKylKnM5lMuHz5Mj788EN1uydOnKi+f/78eUyaNAlBQUFwdnZG69at8cEHH2jWtW3bNphMJqxbtw7PPPMMGjZsCFdXV2RkZJRrm6nqONR2BYiIiIiIiIjqq4yMDKxYsQLjxo3Dfffdh8zMTKxcuRKDBg3Cn3/+iQ4dOiAgIADvvvsuHnjgAYwaNQqjR48GALRr185wmb169cLMmTPx1ltv4amnnkKrVq0AQP0JACdOnMCtt96Ke++9FxMmTMAHH3yAiRMnolOnTmjdujWAoiGDvXv3xvnz5zFlyhQ0atQIO3fuxJNPPom4uDi88cYbZW7b6tWrMWnSJLRu3RpPPvkkvL298c8//+D777/H+PHjAQC//PILhgwZgk6dOmHu3Lmws7PDqlWr0LdvX+zYsQNdu3bVLHPMmDFo0qQJFi5ciL1792LFihUIDAzEokWLAAAff/wxJk+ejK5du+L+++8HAERERAAA4uPj0a1bN5hMJkyfPh0BAQH47rvvcO+99yIjIwMPPfSQZl3PP/88nJycMGvWLOTm5sLJycnW4aSqphARERERERFRtSgoKFByc3M1r6WmpipBQUHKpEmT1NcSExMVAMrcuXPLtdwNGzYoAJStW7fq3gsPD1cAKNu3b1dfS0hIUJydnZVHH31Ufe35559X3NzclGPHjmnmf+KJJxR7e3vl7Nmzpa4/LS1N8fDwUK6//nolOztb857FYlF/Nm/eXBk0aJD6mqIoSlZWltKkSRNlwIAB6mtz585VAGj2iaIoyqhRoxQ/Pz/Na25ubsqECRN0dbr33nuVBg0aKElJSZrXx44dq3h5eSlZWVmKoijK1q1bFQBK06ZN1deodnD4HhEREREREVE1sbe3V3vgWCwWpKSkoKCgAJ07d8bevXurbb1RUVGIjo5WywEBAWjZsiVOnTqlvrZhwwZER0fDx8cHSUlJ6r/+/fujsLAQ27dvL3X5P/74IzIzM/HEE0/AbDZr3jOZTACAf//9F8ePH8f48eORnJysLv/y5cvo168ftm/frhsmOHXqVE05OjoaycnJNofWKYqCL774AsOHD4eiKJrtGTRoENLT03X7e8KECXBxcSlzuVS9OHyPiIiIiIiIqBp9+OGHWLx4MY4cOYL8/Hz19SZNmlTbOhs1aqR7zcfHB6mpqWr5+PHj2L9/v5pnJUtISCh1+SdPngQAtGnTptRpjh8/DqCo8ac06enp8PHxKbXe4r3U1FR4enqWupzExESkpaXhvffew3vvvWc4jbw91bn/qXzYKEVERERERERUTT755BNMnDgRI0eOxOzZsxEYGAh7e3ssXLhQbdipDvb29oavK4qi/t9isWDAgAF47LHHDKdt0aLFFdVB9IJ65ZVX0KFDB8Np3N3dNeXy1Lusdd15552lNoLJGV3sJVX72ChFREREREREVE0+//xzNG3aFF9++aU6rA0A5s6dq5nO+r3yqOj0RiIiInDp0iX079+/UvMCwIEDB9CsWbMyp/H09KzUOkpjtO0BAQHw8PBAYWFhla6LqhczpYiIiIiIiIiqiej5Y93TZ/fu3di1a5dmOldXVwBAWlpauZbr5uZWoemNjBkzBrt27cKWLVt076WlpaGgoKDUeQcOHAgPDw8sXLgQOTk5mvfEtnbq1AkRERF49dVXcenSJd0yEhMTK1VvNzc33Xbb29vjlltuwRdffIEDBw5U2bqoerGnFBEREREREVE1GTZsGL788kuMGjUKQ4cOxenTp7Fs2TJERUVpGmpcXFwQFRWF9evXo0WLFvD19UWbNm1KzWzq0KED7O3tsWjRIqSnp8PZ2Rl9+/ZFYGBgues2e/ZsbNq0CcOGDcPEiRPRqVMnXL58Gf/99x8+//xzxMTEwN/f33BeT09PvP7665g8eTK6dOmC8ePHw8fHB/v27UNWVhY+/PBD2NnZYcWKFRgyZAhat26Ne+65Bw0bNsT58+exdetWeHp64ptvvqnYDkVRY9dPP/2E1157DSEhIWjSpAmuv/56vPTSS9i6dSuuv/563HfffYiKikJKSgr27t2Ln376CSkpKRVeF1UvNkoRERERERERVZOJEyfi4sWLWL58ObZs2YKoqCh88skn2LBhA7Zt26aZdsWKFZgxYwYefvhh5OXlYe7cuaU2SgUHB2PZsmVYuHAh7r33XhQWFmLr1q0VapRydXXFr7/+ihdffBEbNmzARx99BE9PT7Ro0QLz58+Hl5dXmfPfe++9CAwMxEsvvYTnn38ejo6OiIyMxMMPP6xO06dPH+zatQvPP/883nnnHVy6dAnBwcG4/vrrMWXKlHLX1dprr72G+++/H8888wyys7MxYcIEXH/99QgKCsKff/6J5557Dl9++SWWLl0KPz8/tG7dGosWLarUuqh6mRRbaWFERERERERERERVjJlSRERERERERERU49goRURERERERERENY6NUkREREREREREVOPYKEVERERERERERDWOjVJERERERERERFTj2ChFREREREREREQ1zqG2K0BEREREREQ1y2Kx4MKFC/Dw8IDJZKrt6hBRPaMoCjIzMxESEgI7u9L7Q7FRioiIiIiI6Bpz4cIFhIWF1XY1iKiei42NRWhoaKnvs1GKiIiIiIjoGuPh4QGg6A9GT0/PWq4NEdU3GRkZCAsLU681pWGjFBERERER0TVGDNnz9PRkoxQRVRtbw4MZdE61bt68eTCZTEhKSqrtqlSLbdu2wWQyYdu2bVW2TLHPiOjKmEwmTJ8+vbarUW369OmDPn36VOkyTSYT5s2bV6XLpKub0e+5iRMnonHjxrVWJwJWr14Nk8mEPXv21HZVqkVMTAxMJhNWr15dZcsU+ywmJqbKlklERGVjo1SxxMRE/N///R8iIyPh4uKCwMBAdO3aFY8//jguXbqkTjdx4kSYTCb1n7OzM1q0aIE5c+YgJydHt1zraU0mEzw9PdG7d298++23umnFL0Kjf0888USpdc/JyUGzZs0QGRmJvLw83ftDhgyBl5cXLly4AABo3LhxqesR/yZOnFiJvUhEVU2+Ljg4OKBhw4aYOHEizp8/X9vVw4oVK2AymfDhhx/q3tu1axfs7Owwa9YsAGVf46z/8Y8BoupX2e8cVa1Pnz6adbu4uKBdu3Z44403YLFYaqweRhRFQXR0NAICApCcnKx7f+rUqXB0dMS///4LQL8tRv+qupGYiIjoasfhewBSUlLQuXNnZGRkYNKkSYiMjERycjL279+Pd999Fw888ADc3d3V6Z2dnbFixQoAQHp6OjZu3Ijnn38eJ0+exJo1a3TLHzBgAO6++24oioIzZ87g3XffxfDhw/Hdd99h0KBBuumfe+45NGnSRPNamzZtSq2/2WzGu+++i4EDB2LhwoWYO3eu+t66devw/fff4+2330ZISAgA4I033tA0tFl75513sHv3bnTr1q2MPUZENU1cF3JycvDHH39g9erV+O2333DgwAGYzeZaq9e9996LDz/8ELNmzcKwYcPg5+cHAMjPz8f999+PsLAwzJ8/HwDQq1cvfPzxx4bLOX/+PJ588kk0btwYgYGBNVZ/omtdRb9zVIfQ0FAsXLgQAJCUlIS1a9fi4YcfRmJiIhYsWFCjdbFmMpmwfPlydOjQAbNmzcKqVavU93bt2oX33nsPjzzyCDp06AAAePrppzF58mTDZa1fvx6bN2/m9ysiIiIJG6UArFy5EmfPnsXvv/+O7t27a97LyMiAk5OT5jUHBwfceeedannatGno3r07Pv30U7z22msICgrSTN+iRQvN9LfccguioqLw5ptvGjZKDRkyBJ07d67QNgwYMADjx4/HwoULMW7cOLRo0QJpaWl4+OGH0aVLF0ybNk2dduTIkYbL+OGHH/Dnn39ixIgRmDp1aoXWT0TVy/q6MHnyZPj7+2PRokXYtGkTxowZU2v1Ku2PtsWLF+PAgQPYtGkT3NzcAABNmzZF06ZNdcsoLCxE37594eDggE8//RSurq41ug1E17LKfOeoal5eXprvSVOnTkVkZCTefvttPPfcc7C3t6+1ukVFRWH27Nl48cUXMXHiRPTu3duw0R0o+i5m5L///sN9992HTp064bnnnqupqhMREV0V6v3wvfPnz2PSpEkICgqCs7MzWrdujQ8++EAzzcmTJ2Fvb29498rT09NmLwSTyYSePXtCURScOnXKZp1atWoFf39/nDx5smIbY8Prr78OV1dXtUHpiSeeQGJiIpYvXw47u7IP9cWLF3HXXXehYcOGmjuBpTl+/DhuueUWBAcHw2w2IzQ0FGPHjkV6ejqAssf5l5ZHkpSUhDFjxsDT0xN+fn74v//7P92QyB9//BE9e/aEt7c33N3d0bJlSzz11FPq+3l5eZgzZw46deoELy8vuLm5ITo6Glu3btUsR9Tv1VdfxZIlS9C0aVO4urpi4MCBiI2NhaIoeP755xEaGgoXFxfcfPPNSElJ0SyjcePGGDZsGH744Qd06NABZrMZUVFR+PLLL23uPwDYvXs3Bg8eDC8vL7i6uqJ37974/fffddP99ttv6NKlC8xmMyIiIrB8+fJyLZ/qt+joaADQXEfKe/537NgRo0eP1rzWtm1bmEwm7N+/X31t/fr1MJlMOHz4cJl1EX+0rV69Gr/++itOnz6N5557DqNHj8bw4cNtbsv8+fOxfft2vPDCC7j++uttTv/222+jdevWcHV1hY+PDzp37oy1a9eq75eWZVNWFtuaNWvQsmVLmM1mdOrUCdu3b9e8n5mZiYceegiNGzeGs7MzAgMDMWDAAOzdu1edZseOHbjtttvQqFEjODs7IywsDA8//DCys7M1y5o4cSLc3d1x9uxZDBs2DO7u7mjYsCGWLFkCoOgP2L59+8LNzQ3h4eGabQNKhl1t374dU6ZMgZ+fHzw9PXH33XcjNTXV5v7Lzc3F3Llz0axZM7Wejz32GHJzc3XTPfzwwwgICICHhwdGjBiBc+fO2Vw+1R+l/b5u3LhxtQ7zN5vN6NKlCzIzM5GQkKC+vn//fkycOBFNmzaF2WxGcHAwJk2apBlat3//fphMJmzatEl97e+//4bJZELHjh016xkyZEi5rjnPPvssIiIiMGXKFOTl5amN7u+8847a6F6ay5cv4/bbb4ejoyPWr1+vu9Epu3jxIu655x6EhobC2dkZDRo0wM0336wZ1lzR45KVlWXzWrFnzx4MGjQI/v7+cHFxQZMmTTBp0iTNNK+++iq6d+8OPz8/uLi4oFOnTvj888916xNZfRs2bEBUVBRcXFxwww034L///gMALF++HM2aNYPZbEafPn10Q7b79OmDNm3a4O+//0b37t3V+ixbtqzMfSccOXIEt956K3x9fWE2m9G5c2fN+SAcPHgQffv2hYuLC0JDQ/HCCy/U+pBRIqJrUb3uKRUfH49u3bqpvxwDAgLw3Xff4d5770VGRgYeeughAEB4eDgKCwvx8ccfY8KECZVal/iF6uPjY3Pa9PR0pKamIiIiotT35dBvf39/m8sNDAzESy+9hClTpmDGjBl477338NBDD+G6664rcz6LxYI777wTycnJ2Lp1K3x9fcucPi8vD4MGDUJubi5mzJiB4OBgnD9/Hps3b0ZaWhq8vLxs1tXImDFj0LhxYyxcuBB//PEH3nrrLaSmpuKjjz4CUPTlYdiwYWjXrh2ee+45ODs748SJE5qGnIyMDKxYsQLjxo3Dfffdh8zMTKxcuRKDBg3Cn3/+qXaxF9asWYO8vDzMmDEDKSkpePnllzFmzBj07dsX27Ztw+OPP44TJ07g7bffxqxZs3QNmsePH8ftt9+OqVOnYsKECVi1ahVuu+02fP/996XeMQWAX375BUOGDEGnTp0wd+5c2NnZYdWqVejbty927NiBrl27Aij643TgwIEICAjAvHnzUFBQgLlz5+p649G1x+iaU97zPzo6Gp9++qk6X0pKCg4ePAg7Ozvs2LED7dq1A1DUyBIQEIBWrVrZrM8zzzyDdevWYcqUKQgPD4eDgwPeeustm/P98ssvWLBgAQYNGoTZs2fbnP7999/HzJkzceutt6oN1/v378fu3bsxfvx4m/Mb+fXXX7F+/XrMnDkTzs7OWLp0KQYPHow///xTHcY0depUfP7555g+fTqioqKQnJyM3377DYcPH1b/0N2wYQOysrLwwAMPwM/PD3/++SfefvttnDt3Dhs2bNCss7CwEEOGDEGvXr3w8ssvY82aNZg+fTrc3Nzw9NNP44477sDo0aOxbNky3H333bjhhht0Q6ymT58Ob29vzJs3D0ePHsW7776LM2fOqKHTRiwWC0aMGIHffvsN999/P1q1aoX//vsPr7/+Oo4dO4avv/5anXby5Mn45JNPMH78eHTv3h2//PILhg4dWql9THVXZb9zVDdx88jb21t97ccff8SpU6dwzz33IDg4GAcPHsR7772HgwcP4o8//oDJZEKbNm3g7e2N7du3Y8SIEQCKrmV2dnbYt28fMjIy4OnpCYvFgp07d+L++++3WRez2YylS5di0KBBmDZtGtauXYtRo0aVq9F9+vTpOHz4MNasWVPq9z5rt9xyCw4ePIgZM2agcePGSEhIwI8//oizZ89WOjje1rUiISFB/a7xxBNPwNvbGzExMbqbbG+++SZGjBiBO+64A3l5eVi3bh1uu+02bN68WXdt2LFjBzZt2oQHH3wQALBw4UIMGzYMjz32GJYuXYpp06YhNTUVL7/8MiZNmoRffvlFM39qaipuuukmjBkzBuPGjcNnn32GBx54AE5OTrrGMmsHDx5Ejx490LBhQzzxxBNwc3PDZ599hpEjR+KLL77AqFGjABQ1/t14440oKChQp3vvvffg4uJSqX1MRERXQKnH7r33XqVBgwZKUlKS5vWxY8cqXl5eSlZWlqIoinLx4kUlICBAAaBERkYqU6dOVdauXaukpaXpljlhwgTFzc1NSUxMVBITE5UTJ04or776qmIymZQ2bdooFotFMz0A5d5771USExOVhIQEZc+ePcrgwYMVAMorr7yimXbVqlUKAMN/5WWxWJQePXooAJSwsDAlMzPT5jzPPfecAkCZP39+udbxzz//KACUDRs2lDrN6dOnFQDKqlWrdO8BUObOnauW586dqwBQRowYoZlu2rRpCgBl3759iqIoyuuvv64AUBITE0tdb0FBgZKbm6t5LTU1VQkKClImTZqkq19AQIDmOD/55JMKAKV9+/ZKfn6++vq4ceMUJycnJScnR30tPDxcAaB88cUX6mvp6elKgwYNlOuuu059bevWrQoAZevWrYqiFB2j5s2bK4MGDdKcL1lZWUqTJk2UAQMGqK+NHDlSMZvNypkzZ9TXDh06pNjb21fovKCrl7gu/PTTT0piYqISGxurfP7550pAQIDi7OysxMbGqtOW9/zfsGGDAkA5dOiQoiiKsmnTJsXZ2VkZMWKEcvvtt6vTtWvXThk1alS567plyxb1mvXGG2/YnD4+Pl5p0KCBEhwcrMTHx5drHTfffLPSunXrMqeZMGGCEh4erntdXGusifru2bNHfe3MmTOK2WzWbLuXl5fy4IMPlrle8TvF2sKFCxWTyaT5DE+YMEEBoLz44ovqa6mpqYqLi4tiMpmUdevWqa8fOXJEd80U50SnTp2UvLw89fWXX35ZAaBs3LhRfa13795K79691fLHH3+s2NnZKTt27NDUc9myZQoA5ffff1cURVH+/fdfBYAybdo0zXTjx4/X1YeuTuX5zlHasQ4PD1cmTJigluXfc4pS+udQ1rt3byUyMlL9XnXkyBFl9uzZCgBl6NChmmmNPmOffvqpAkDZvn27+trQoUOVrl27quXRo0cro0ePVuzt7ZXvvvtOURRF2bt3r+7zYsu4ceMUAIqHh4fm2luajz/+WAGg3HPPPeVafmpqquH3Q1l5j0t5rxVfffWVAkD566+/ylyvvP/z8vKUNm3aKH379tXVz9nZWTl9+rT62vLlyxUASnBwsJKRkaG+Lr53WU/bu3dvBYCyePFi9bXc3FylQ4cOSmBgoLotRt81+/Xrp7Rt21bzfc1isSjdu3dXmjdvrr720EMPKQCU3bt3q68lJCQoXl5euvrUZ+np6QoAJT09vbarQkT1UHmvMfV2+J6iKPjiiy8wfPhwKIqCpKQk9d+gQYOQnp6uDrsICgrCvn37MHXqVKSmpmLZsmUYP348AgMD8fzzz0NRFM2yL1++jICAAAQEBKBZs2aYNWsWevTogY0bNxrenV65ciUCAgIQGBiIzp074+eff8Zjjz2GRx55xLDuS5YswY8//qj5V14mk0nt6XTDDTdoAtqN7NixA/Pnz0efPn3wzDPPlGsdoifUli1bkJWVVe662SLupgkzZswAAPzvf/8DAPVu6caNG0vtXm1vb692jbdYLEhJSUFBQQE6d+6sGWYj3HbbbZqeXaIb/5133gkHBwfN63l5ebqnnYWEhKh33QCo3eL/+ecfXLx40bCO//77L44fP47x48cjOTlZPS8vX76Mfv36Yfv27bBYLCgsLMSWLVswcuRINGrUSJ2/VatWhllkVL/1798fAQEBCAsLw6233go3Nzds2rQJoaGh6jTlPf/F0D8xRG3Hjh3o0qULBgwYgB07dgAA0tLScODAAXXa8vD19VWHCg8cOLDMaRVFwd133434+Hh8/PHH5Q439/b2xrlz5/DXX3+Vu1623HDDDejUqZNabtSoEW6++WZs2bIFhYWF6np3796tPsXUiPUd9suXLyMpKQndu3eHoij4559/dNNbByJ7e3ujZcuWcHNz02SEtWzZEt7e3oZDw++//344Ojqq5QceeAAODg7qNdPIhg0b0KpVK0RGRmp+L/bt2xcA1KGeYhkzZ87UzC96GFP9cSXfOarKkSNH1O9VkZGReOWVVzBixAhdBID1ZywnJwdJSUlq9IJ8jdu7dy8uX74MoGgY/E033YQOHTqo17gdO3ao8QvlJXqQRUVFaa69Ro4dO4YHHnhAzcYqDxcXFzg5OWHbtm3lGopbXrauFeL71ebNm5Gfn19m/YTU1FSkp6er+1rWr18/Tc8u8f3qlltugYeHh+51+Rrn4OCAKVOmqGUnJydMmTIFCQkJ+Pvvvw3rl5KSgl9++QVjxoxBZmamen1LTk7GoEGDcPz4cfV73P/+9z9069ZN7ZkOAAEBAbjjjjtK3X4iIqoe9bZRKjExEWlpaXjvvffULzri3z333AMAmpyCBg0a4N1330VcXByOHj2Kt956CwEBAZgzZw5WrlypWbbZbFa/uK1atQqtWrVCQkJCqV1+b775Zvz444/49ttv1UyTrKysUnOeunbtiv79+2v+ldeXX36Jb775Bm3atMGGDRvUL19GkpOTMW7cOPj4+GDNmjU2c6eEJk2a4JFHHsGKFSvg7++PQYMGYcmSJWqeVGU1b95cU46IiICdnZ06TOn2229Hjx49MHnyZAQFBWHs2LH47LPPdA1UH374Idq1awez2Qw/Pz8EBATg22+/NayfdWMPUNLgFhYWZvi6/CWxWbNmuobIFi1aAECpj7U/fvw4AGDChAm6c3PFihXIzc1Feno6EhMTkZ2drdsvQNEfqnRtEX84fv7557jpppuQlJQEZ2dn3XTlOf+DgoLQvHlzzR9n0dHR6NWrFy5cuIBTp07h999/h8ViKXejVGFhIe6//36EhITA29tb15ghW7RoEbZs2YLHH3+8Qte4xx9/HO7u7ujatSuaN2+OBx980DCLrSKMPmMtWrRAVlYWEhMTAQAvv/wyDhw4gLCwMHTt2hXz5s3T/RF19uxZTJw4Eb6+vnB3d0dAQAB69+4NALrrj9lsRkBAgOY1Ly8vhIaG6q4pXl5ehn+gyvV2d3dHgwYNSr32AEXXn4MHD+quPeK6JX4vnjlzBnZ2drrhRrz21D9X8p2jqjRu3Bg//vgjtmzZgqVLl6Jhw4ZITEzUZXqmpKTg//7v/xAUFAQXFxcEBASow1qtP2PR0dEoKCjArl27cPToUSQkJKjXOOvrXlRUlM3IAmHPnj1YsmQJ2rRpg927d+OTTz4pddrc3FyMGTMGBQUFWL9+vc3cKcHZ2RmLFi3Cd999h6CgIHV4b2k3ucrL1rWid+/euOWWWzB//nz4+/vj5ptvxqpVq3Q5c+LpgWazGb6+vggICMC7775bLd+vQkJCdPvN1verEydOQFEUPPvss7prnHgytfU1jt+viIjqhnqbKSUaKu68885Sc6JEboo1k8mEFi1aoEWLFhg6dCiaN2+ONWvWaO5o29vba760DRo0CJGRkZgyZYphkGJoaKg6/U033QR/f39Mnz4dN954oy5s+EpkZmZi5syZ6NSpE7Zu3Yp27drhgQcewD///KO5QwYU9VKYMGECLly4gG+++QYhISEVWtfixYsxceJEbNy4ET/88ANmzpypZkEZ/VEliF4H5SEvw8XFBdu3b8fWrVvx7bff4vvvv8f69evRt29f/PDDD7C3t8cnn3yCiRMnYuTIkZg9ezYCAwNhb2+PhQsXGgbLl/ZEn9Jel3vNVYY4N1955RVdxpXg7u6u+zJI17auXbuqT8gaOXIkevbsifHjx+Po0aNqj8iKnP89e/bEzz//jOzsbPz999+YM2eOmsWyY8cOHD58GO7u7jYz6YQ333wT//zzD77++mucP38eDz74INauXWuY87Rr1y48++yz6N69e4WfRNWqVSscPXoUmzdvxvfff48vvvgCS5cuxZw5c9SnYFXF9Uc2ZswYREdH46uvvsIPP/yAV155BYsWLcKXX36JIUOGoLCwEAMGDEBKSgoef/xxREZGws3NDefPn8fEiRN1jee1ce0Biq4/bdu2xWuvvWb4vvwHI5GRK/ksGXFzc9N8r+rRowc6duyIp556SpNNN2bMGOzcuROzZ89Ghw4d4O7uDovFgsGDB2s+Y507d4bZbMb27dvRqFEjBAYGokWLFoiOjsbSpUuRm5uLHTt2aHo6l8W60f3333/HwIED8eijj2LYsGGazCvhkUcewb59+7BkyRLD75pleeihhzB8+HB8/fXX2LJlC5599lksXLgQv/zyi83rcWWPi8lkwueff44//vgD33zzDbZs2YJJkyZh8eLF+OOPP+Du7o4dO3ZgxIgR6NWrF5YuXYoGDRrA0dERq1at0j2MAajd71ezZs0qtUd5s2bNrng9RERUtepto5R4WlBhYWGl7/o1bdoUPj4+iIuLK3O6Bg0a4OGHH8b8+fPxxx9/GD7Fz9qUKVPw+uuv45lnnsGoUaNK/QOqop555hnExcVh48aN8PDwwNtvv43hw4dj8eLFeOKJJzTTvvbaa/j222/x8MMPVzq4tm3btmjbti2eeeYZ7Ny5Ez169MCyZcvwwgsvqOHLaWlpmnnOnDlT6vKOHz+uCfI9ceIELBaLpvu3nZ0d+vXrh379+uG1117Diy++iKeffhpbt25F//798fnnn6Np06b48ssvNftV3CGrauKunPW6jh07BgClBpKKngeenp5lnpsBAQFwcXFRe1ZZO3r06BXUmq52oqHpxhtvxDvvvKN+vity/kdHR2PVqlVYt24dCgsL0b17d9jZ2aFnz55qo1T37t3L9Sj22NhYzJ07FzfffDNuvvlmWCwWfPjhh3jkkUcwdOhQzRDZ1NRUjB07Fu7u7li7dq1mmGx5ubm54fbbb8ftt9+OvLw8jB49GgsWLMCTTz4Js9kMHx8f3bUHKP36Y/QZO3bsGFxdXTW9mRo0aIBp06Zh2rRpSEhIQMeOHbFgwQIMGTIE//33H44dO4YPP/wQd999tzpPdQ6FOn78OG688Ua1fOnSJcTFxeGmm24qdZ6IiAjs27cP/fr1K/N3T3h4OCwWC06ePKnpOcBrz7XF6LOUl5dn83vRlWrXrh3uvPNOLF++HLNmzUKjRo2QmpqKn3/+GfPnz8ecOXPUaY0+v05OTujatSt27NiBRo0aqT0+o6OjkZubizVr1iA+Ph69evUqV33eeust/PPPP/jqq6/g6emJZcuWoXPnznjiiSd0T4QTDeWjR4/GtGnTKrX9ERERePTRR/Hoo4/i+PHj6NChAxYvXqz2zqrocSnvtaJbt27o1q0bFixYgLVr1+KOO+7AunXrMHnyZHzxxRcwm83YsmWLppdueZ7YXBkXLlzA5cuXNb2lbH2/atq0KQDA0dHR5nf/8PBwfr8iIqoj6u3wPXt7e9xyyy344osvcODAAd37YkgGAOzevVvNHbD2559/Ijk5uVxdeWfMmAFXV1e89NJLNqd1cHDAo48+isOHD2Pjxo02py+Pv//+G0uWLMH06dPVbJRhw4Zh1KhReP755zV/jP3111948skn0alTp3LVV5aRkYGCggLNa23btoWdnZ3au8fT0xP+/v66x6ovXbq01OWKx6ELIoNhyJAhAIq67ctETyOxXvEHtPUdt927d2PXrl02t6syLly4gK+++kotZ2Rk4KOPPkKHDh0QHBxsOE+nTp0QERGBV199FZcuXdK9L85Ne3t7DBo0CF9//TXOnj2rvn/48GFs2bKlireErjZ9+vRB165d8cYbbyAnJwdAxc5/8UfaokWL0K5dO7XhKDo6Gj///DP27NlT7qF7M2bMgKIo6mfWzs4Oy5YtQ1JSEp566inNtJMmTcLZs2excuVKhIeHV3CroXn0O1D0x2dUVBQURVGzUCIiIpCeno79+/er08XFxWk+q9Z27dqlyUSJjY3Fxo0bMXDgQNjb26OwsFA3PCUwMBAhISFlXnsURcGbb75Z4W0sr/fee0+T//Luu++ioKBAvWYaGTNmDM6fP4/3339f9152drb6u1AsQ36C4htvvFEFNaerRUREhO73+HvvvVflPaWMPPbYY8jPz1d79Rl9xoDSz8no6Gjs3r0bW7duVa9l/v7+aNWqFRYtWqROY0tsbCzmzJmDESNGYOTIkQCKvnvMnDkT77//Pnbv3q1OGxMTg8mTJyM8PBwrVqyo0PYCQFZWlno9FyIiIuDh4aHpPV3R42LrWpGamqrbr0bfr0wmk2YdMTExmid2VqWCggIsX75cLefl5WH58uUICAjQZABaCwwMRJ8+fbB8+XLDBjrr7/433XQT/vjjD/z555+a99esWVOFW0FEROVRb3tKAcBLL72ErVu34vrrr8d9992HqKgopKSkYO/evfjpp5/URo6PP/4Ya9aswahRo9CpUyc4OTnh8OHD+OCDD2A2m3V/VBnx8/PDPffcg6VLl+Lw4cM2H6E+ceJEzJkzB4sWLVK/5FSW6FYeHByMF154QfPem2++iaioKMyYMQObNm1CVlYWbr/9duTn52PYsGH47LPPDJcZFBSEAQMGGL73yy+/YPr06bjtttvQokULFBQU4OOPP1YbAoXJkyfjpZdewuTJk9G5c2ds375dvctl5PTp0xgxYgQGDx6MXbt2qY8ib9++PQDgueeew/bt2zF06FCEh4cjISEBS5cuRWhoqBpUOmzYMHz55ZcYNWoUhg4ditOnT2PZsmWIiooybAC6Ui1atMC9996Lv/76C0FBQfjggw8QHx9f5p1DOzs7rFixAkOGDEHr1q1xzz33oGHDhjh//jy2bt0KT09PfPPNNwCA+fPn4/vvv0d0dDSmTZuGgoICvP3222jdurXmD266Ns2ePRu33XYbVq9ejalTp1bo/G/WrBmCg4Nx9OhR9aECANCrVy88/vjjAMr3B9tXX32FjRs3YvHixZqhX9dddx0efPBBvPPOO5g4cSK6dOmCZcuW4euvv0a7du2QlZVVaibLgAEDEBQUZPjewIEDERwcjB49eiAoKAiHDx/GO++8g6FDh6rhuWPHjsXjjz+OUaNGYebMmcjKysK7776LFi1aGAbytmnTBoMGDcLMmTPh7OysNp6L4YCZmZkIDQ3Frbfeivbt28Pd3R0//fQT/vrrLyxevBgAEBkZiYiICMyaNQvnz5+Hp6cnvvjiiyoNK5bl5eWhX79+GDNmDI4ePYqlS5eiZ8+eGDFiRKnz3HXXXfjss88wdepUbN26FT169EBhYSGOHDmCzz77DFu2bEHnzp3RoUMHjBs3DkuXLkV6ejq6d++On3/+GSdOnKi27aG6Z/LkyZg6dSpuueUWDBgwAPv27cOWLVvUwO/qFBUVhZtuugkrVqzAs88+Cz8/PzVjKT8/Hw0bNsQPP/yA06dPG84fHR2NBQsWIDY2VnMt69WrF5YvX47GjRvbDCsH9I3uwvz589XP0p49e2Bvb4+xY8ciLS0Nd9xxB7799lvD5bm7u5f6ve/YsWPqZzoqKgoODg746quvEB8fj7Fjx6rTVfS42LpWfPjhh1i6dClGjRqFiIgIZGZm4v3334enp6fam2ro0KF47bXXMHjwYIwfPx4JCQlYsmQJmjVrVi3fR0JCQrBo0SLExMSgRYsWWL9+Pf7991+89957ukgKa0uWLEHPnj3Rtm1b3HfffWjatCni4+Oxa9cunDt3Dvv27QNQ1Oj58ccfY/Dgwfi///s/uLm54b333kN4eDi/XxER1bRqePJfnRIfH688+OCDSlhYmOLo6KgEBwcr/fr1U9577z11mv379yuzZ89WOnbsqPj6+ioODg5KgwYNlNtuu03Zu3evZnkTJkxQ3NzcDNd18uRJxd7eXvM4XgClPkZ83rx5mkcoi0f32nokr+z1119XACiff/654fuvvvqqAkD58ssv1cfn2vpn/Qhx2alTp5RJkyYpERERitlsVnx9fZUbb7xR+emnnzTTZWVlKffee6/i5eWleHh4KGPGjFESEhJ0jzIWj2k/dOiQcuuttyoeHh6Kj4+PMn36dCU7O1ud7ueff1ZuvvlmJSQkRHFyclJCQkKUcePGKceOHVOnsVgsyosvvqiEh4crzs7OynXXXads3rxZ92hqsR/kxy6Lx1pv2LBB87rRsQkPD1eGDh2qbNmyRWnXrp3i7OysREZG6uY1elS2oijKP//8o4wePVrx8/NTnJ2dlfDwcGXMmDHKzz//rJnu119/VTp16qQ4OTkpTZs2VZYtW2b4aHuqn8q6LhQWFioRERFKRESEUlBQUO7zX7jtttsUAMr69evV1/Ly8hRXV1fFyclJ8/kzkpmZqYSGhiodOnRQCgoKdO9nZGQoISEhSseOHZWCggJlwoQJ5br+yJ8Va8uXL1d69eqlfm4iIiKU2bNn6x41+8MPPyht2rRRnJyclJYtWyqffPKJ4edGXKM/+eQTpXnz5up+s65Dbm6uMnv2bKV9+/aKh4eH4ubmprRv315ZunSpZlmHDh1S+vfvr7i7uyv+/v7Kfffdp+zbt0/3yPLSfo/07t1bad26te51ca0RxDnx66+/Kvfff7/i4+OjuLu7K3fccYeSnJysW6Z8Pc/Ly1MWLVqktG7dWnF2dlZ8fHyUTp06KfPnz9fsx+zsbGXmzJmKn5+f4ubmpgwfPlyJjY0t9XH0dHUpz3eOwsJC5fHHH1f8/f0VV1dXZdCgQcqJEyeU8PBwzXcdo99zpV13ZKWd94qiKNu2bdOcb+fOnVNGjRqleHt7K15eXsptt92mXLhwwfCczMjIUOzt7RUPDw/N9emTTz5RACh33XWXzbp99dVXCgDl1VdfNXz/888/VwAor732mqIoSrmub2Xtk6SkJOXBBx9UIiMjFTc3N8XLy0u5/vrrlc8++0wzXXmPS3mvFXv37lXGjRunNGrUSHF2dlYCAwOVYcOGKXv27NGsd+XKlep1MjIyUlm1alWZ11VrFfneJc6JPXv2KDfccINiNpuV8PBw5Z133jFcpvX1VVGKvo/ffffdSnBwsOLo6Kg0bNhQGTZsmO578v79+5XevXsrZrNZadiwofL8888rK1euVAAop0+f1h+geqi8j2unq0tsymWl56KflcVbjtR2VVSFhZbargLVgvJeY0yKUkXpqUTXmMaNG6NNmzbYvHlzbVeFiK4hq1evxj333IO//vpLDb8nIqov+vTpg6SkJMP4DapaGRkZ8PLyQnp6Ojw9PWu7OlRFXvvxGN76+TjcnR2w99kBcHLQJvbkFhRi3Z+xGNwmGEGe5lKWUnVmfvoP/j6Tiu8eioanufSejlT/lPcaU28zpYiIiIiIiIiuJVsOXAQAXMotwO7Tybr3399+CnM3HcQzX1d/w6+iKNhy8CLOp2Vj75nqizSgqxsbpYiIiIiIiIiucqcSL+FofKZa/vlwgm6ajf9eAAD8eiwRl3ILdO9XpbSsfOQWWAAAx6zqRWSNjVJEREREREREV7ktB+MBAB7moueZ/XQ4XvN0zWPxmTieUPTwm7wCC349mqhfiA1/n0nFM1//h/TsfJvTXswoeaLosfiqf+gU1Q9slCKqpJiYGOZJEVGNmzhxIhRFYZ4UEdVL27ZtY54UUSV9f7Bo6N7/9WsOZwc7nEvN1jQGbd53wXD6injtx6P45I+z2Lz/gs1pL6ZbN0qxpxQZY6MUERERERER0VXsQlo29sWmwWQCRnQIQY9m/gCKeksBRflOm/fHAQAm3BAOANh6JAG5BYUVWs+RuKLGpTPJWTanjbNqlDoefwkWS9nPWMsvtODRz/bhlS1HKlQnurqxUYqIiIiIiIjoKvZDca+nzuE+CPQwo1+rQADAz8WNUofiMnAq6TKcHezw6KCWCPRwxqXcAuw8qQ9DL03SpVwkX84DAMSm2G6Uupierf4/O78Q51Kzy5ga+N9/cfhi7zks2XoSecVZVFT/sVGqnLZt2waTyYRt27ZVet7PP/+86itWCpPJhHnz5qnl1atXw2QyISYmpsbqUF3kbSO61vH6VHfw+kSkxetT3cHrE1H9JobiDWodDADoFxkEAPgnNg1Jl3LVXlI3tgyEp9kRA1sXvS+e1lcexy6WDME7W45GKeueUkDZQ/gURcF720+p5ZTixi+q/9goVcesXbsWb7zxRm1XgyqpT58+MJlM6j9fX1906dIFH3zwASwWbWv/N998g969eyMwMBCurq5o2rQpxowZg++//16dJiYmRrM863/dunWr6c2jaxyvT1c3Xp+oPuP16erG6xPRlUm+lIs/T6cAKGmUCvYyo01DTygK8MuRBDUDalj7BprpfjwUj0Ibw+oE6yf7ladRSgSdO9nb6eaX7TyZjIMXMtRy0qXcctWJrn4OtV2Bq0WvXr2QnZ0NJyenal3P2rVrceDAATz00ENVuty77roLY8eOhbOzc5UutzZkZ2fDwaHunrqhoaFYuHAhACAxMREfffQR7r33Xhw7dgwvvfQSAODVV1/F7Nmz0bt3bzz55JNwdXXFiRMn8NNPP2HdunUYPHiwZpnjxo3DTTfdpHktICCgZjaI6jxen+oOXp+K8PpEAq9PdQevT0V4faL66KfD8bAoQJuGngjzdVVf7xcZhAPnM/DutpOITcmGi6M9+kYWDevr1tQPnmYHJF/Ow56YFFzf1M/meqx7OmXmFCA9Kx9ero6lTi+Czrs08cHvJ5LL7Cm13KqXFAAkslHqmlF3fzPVETk5OXBycoKdnR3MZnNtV6fS7O3tYW9vX9vVqBJ1/Th4eXnhzjvvVMtTpkxBy5Yt8c477+D555+HyWTC888/jwEDBuCHH37QzZ+QkKB7rWPHjpplEgG8PtVFdf048PpENYXXp7qnrh8HXp+IKu/74iF4g4t7Pwn9WwXhzZ+P43TSZQBAv1aBcHUqagJwtLdD/1ZB+PKf89hyML5cjVJHL2oblc6mZKGtq1ep04tGqV7NA4obpS4ZTnc4LgPbjyXCzgQ08XfDycTLSMpko9S1gsP3rIjsgnXr1uGZZ55Bw4YN4erqioyMjFIzEZYsWYKmTZvCxcUFXbt2xY4dO9CnTx/06dNHt3yLxYIFCxYgNDQUZrMZ/fr1w4kTJ9T3+/Tpg2+//RZnzpxRuxg3bty4zDrn5ubi4YcfRkBAADw8PDBixAicO3dON51RJkLjxo0xbNgwbNu2DZ07d4aLiwvatm2rbuOXX36Jtm3bwmw2o1OnTvjnn390yz1y5AhuvfVW+Pr6wmw2o3Pnzti0aZPhun///Xc88sgjCAgIgJubG0aNGoXExETNtHv27MGgQYPg7+8PFxcXNGnSBJMmTdJMY5SJ8M8//2DIkCHw9PSEu7s7+vXrhz/++KNa61Ferq6u6NatGy5fvozExEQkJSUhIyMDPXr0MJw+MDCwUuuh+o3XJ16fKlKP8uL1iaoCr0+8PlWkHuXF6xNR+WTm5OP3E0Vh5YPbaBul2jT0RJBnSU/PYe1CNO8PKp5+y8GLUJSyh/ApiqI2Knm5FPWOik0tfQhfZk4+MnMLAAC9WhT1UDyZcAkFhfoA8/d3nFLr3z7MGwCQdImZUtcK9pQy8Pzzz8PJyQmzZs1Cbm5uqV3O3333XUyfPh3R0dF4+OGHERMTg5EjR8LHxwehoaG66V966SXY2dlh1qxZSE9Px8svv4w77rgDu3fvBgA8/fTTSE9Px7lz5/D6668DANzd3cus6+TJk/HJJ59g/Pjx6N69O3755RcMHTq03Nt64sQJjB8/HlOmTMGdd96JV199FcOHD8eyZcvw1FNPYdq0aQCAhQsXYsyYMTh69Cjs7IraMg8ePIgePXqgYcOGeOKJJ+Dm5obPPvsMI0eOxBdffIFRo0Zp1jVjxgz4+Phg7ty5iImJwRtvvIHp06dj/fr1AIrucA0cOBABAQF44okn4O3tjZiYGHz55ZdlbsPBgwcRHR0NT09PPPbYY3B0dMTy5cvRp08f/Prrr7j++utrpB5lOXXqFOzt7eHt7Q2z2QwXFxd88803mDFjBnx9fW3On5WVhaSkJM1rXl5ecHQsvbss1U+8PvH6xOsT1VW8PvH6xOsTUc3783QK8gotaOLvhmaBHpr3TCYT+kYG4dM/z8LNyR59WmqHr/ZqHgCzox3Op2Xj4IUMtGlYeq+nC+k5uJRbAEd7E3o288e3/8WVmSsVX5wn5eHsgJZBHnBxtEd2fiHOpGQhIqDkGh2Xno1N/xblXd3fKwLf/VcUyM5MqWuIQqqtW7cqAJSmTZsqWVlZhu9t3bpVURRFyc3NVfz8/JQuXboo+fn56nSrV69WACi9e/fWzduqVSslNzdXff3NN99UACj//fef+trQoUOV8PDwctX333//VQAo06ZN07w+fvx4BYAyd+5c9bVVq1YpAJTTp0+rr4WHhysAlJ07d6qvbdmyRQGguLi4KGfOnFFfX758uWb7FUVR+vXrp7Rt21bJyclRX7NYLEr37t2V5s2b69bdv39/xWKxqK8//PDDir29vZKWlqYoiqJ89dVXCgDlr7/+KnO75W0bOXKk4uTkpJw8eVJ97cKFC4qHh4fSq1evaquHkd69eyuRkZFKYmKikpiYqBw+fFiZOXOmAkAZPny4Ot2cOXMUAIqbm5syZMgQZcGCBcrff/+tW97p06cVAIb/rI8F1X+8PvH6VJF6GOH1iaoLr0+8PlWkHkZ4faod6enpCgAlPT29tqtCV2DxliNK+OOblUc/+9fw/b/PpCgRT36rvLD5oOH7Uz7ao4Q/vllZ9N3hMtfzy+F4JfzxzcrA135VXi1e51Nf7i91+h3HEpXwxzcr/RdvUxRFUUa8vUMJf3yz8r/9FzTTvfjtISX88c3KbcuKrqnv/XpSCX98s/J/n+4tsz5U95X3GsPhewYmTJgAFxeXMqfZs2cPkpOTcd9992lCI++44w74+PgYznPPPfdo7hpGR0cDKLoLVBn/+9//AAAzZ87UvF6RkM+oqCjccMMNalncFevbty8aNWqke13UNSUlBb/88gvGjBmDzMxMJCUlISkpCcnJyRg0aBCOHz+O8+fPa9Z1//33w2QyqeXo6GgUFhbizJkzAABvb28AwObNm5Gfn1+u+hcWFuKHH37AyJEj0bRpU/X1Bg0aYPz48fjtt9+QkZGhmac66mHtyJEjCAgIQEBAAFq1aoW3334bQ4cOxQcffKBOM3/+fKxduxbXXXcdtmzZgqeffhqdOnVCx44dcfjwYd0y77//fvz444+af+3bt69w3ejqx+sTr08VrYc1Xp+oOvH6xOtTRethjdcnosr591w6AKjD3mQdG/lg/7yBeHJIK8P3xdP4vth7znBonSCenNci2EMNUy+rp1RcejaAoqcAAkCLoKJeXNa5UpdyC7B291kAwP3RRdciP/ei6z2H71072ChloEmTJjanEb+AmzVrpnndwcGh1BwD6y8pANQvX6mpqZWoZVEd7OzsEBERoXm9ZcuW5V6GXCcvr6Ium2FhYYavi7qeOHECiqLg2WefVb9AiH9z584FoA+ctLX9vXv3xi233IL58+fD398fN998M1atWoXc3NK7biYmJiIrK8twm1u1agWLxYLY2Nhqr4e1xo0b48cff8RPP/2E3377DRcvXsTmzZvh7++vmW7cuHHYsWMHUlNT8cMPP2D8+PH4559/MHz4cOTk5Gimbd68Ofr376/5V9qXd6rfeH3i9YnXJ6qreH3i9YnXJ6KapSgK9sWmAQA6hHqXOp2rkwPs7EyG7w2ICoKvmxPiM3Kx9Wii4TQAcKw45Dwy2ANhPkWNUrFlNEqJkPMGukapkrD0r/aeQ2ZuAZr6u6lPBfR3L8rA4vC9awczpQzYustXWaU9vUWxESpXnUqrk626WixFreizZs3CoEGDDKeVv3DaWqbJZMLnn3+OP/74A9988w22bNmCSZMmYfHixfjjjz9s5kOUV3XXw83NDf379y93fTw9PTFgwAAMGDAAjo6O+PDDD7F792707t27/BtF1wxen3h94vWJ6ipen3h94vWJqGadSc5CenY+nBzs0DLYw/YMBpwd7HFLx4Z4f8dprPvzLAZEBRlOp/aUCvJAI7+iRqnzadkotCiwN2jwiivOlAr2Kvrd0CJY2yilKAo+3FV0o+KuG8LVRjM2Sl172FOqksLDwwFA8/QXACgoKNA8oaWirLtFl6cOFosFJ0+e1Lx+9OjRSq+/vERXb0dHR90dKPHPw6NyF8Zu3bphwYIF2LNnD9asWYODBw9i3bp1htMGBATA1dXVcJuPHDkCOzs73V3L6qhHVencuTMAIC4urlrXQ/Ubr0+8PlUHXp+oKvD6xOtTdeD1ia5V+86lAQBah3jCyaHyf9qP7VrUE3Lr0QR12J21QouC4wlFw+5aBnkg2NMMR3sT8gsVXMzI0U0PlPSUCvYUPaWKGqZPJ11GbkEhdp1MxomES3BzssetnUoecuHvUTR8L+VyHgottXfzgWoOG6UqqXPnzvDz88P777+PgoIC9fU1a9ZUujs5UHSXKD09vVzTDhkyBADw1ltvaV5/4403Kr3+8goMDESfPn2wfPlywy8A8iOCyyM1NVV317NDhw4AUGrXb3t7ewwcOBAbN27UfJmNj4/H2rVr0bNnT3h6elZ7PSoiKysLu3btMnzvu+++A1CxIQREMl6feH2qLF6fqLrx+sTrU2Xx+kSk92/x0L32ZQzdK4+IAHd0beILiwJs2HNO935M8mXkFVjg4miPUB8X2NuZ0NC7qAdUaUP44qThe8GeZniYHVBgUXA66TI+3BUDABjdMRQe5pInYvq6OsFkAixKUcMU1X8cvldJTk5OmDdvHmbMmIG+fftizJgxiImJwerVqxEREVGhO3bWOnXqhPXr1+ORRx5Bly5d4O7ujuHDhxtO26FDB4wbNw5Lly5Feno6unfvjp9//ll397G6LFmyBD179kTbtm1x3333oWnTpoiPj8euXbtw7tw57Nu3r0LL+/DDD7F06VKMGjUKERERyMzMxPvvvw9PT0/cdNNNpc73wgsv4Mcff0TPnj0xbdo0ODg4YPny5cjNzcXLL79c4e2qbD3KKysrC927d0e3bt0wePBghIWFIS0tDV9//TV27NiBkSNH4rrrrrvi9dC1i9cnXp8qi9cnqm68PvH6VFm8PhHpqXlSpYScV8S4rmH483QK1v8ViwdvbKYZkifypFoEuavD7MJ8XRGTnIWzKVno1tRPt7x4dfheUaOUyWRCiyAP/H0mFVuPJOLHQ/EAgLtvCNfM52BvB19XJyRfzkPSpVwEeDhf8bZR3cZGqSswffp0KIqCxYsXY9asWWjfvj02bdqEmTNnwmw2V2qZ06ZNw7///otVq1bh9ddfR3h4eKlfqgDggw8+QEBAANasWYOvv/4affv2xbffflvpLtcVERUVhT179mD+/PlYvXo1kpOTERgYiOuuuw5z5syp8PJ69+6NP//8E+vWrUN8fDy8vLzQtWtXrFmzpszw1NatW2PHjh148sknsXDhQlgsFlx//fX45JNP1Kfe1EQ9ysvb2xvvv/8+vv32W6xatQoXL16Evb09WrZsiVdeeUX3NCCiyuD1idenyuD1iWoCr0+8PlUGr09EWvmFFhy4UPSUzNKevFcRQ9o0wLxNh3A+LRs7jieiT8tA9T3rPClBPIHPqKdUTn6h2stJ9JQS8/99JhVLtp6ARQG6R/iheZB+yLK/u7PaKEX1n0mpzZTIeshisSAgIACjR4/G+++/X9vVISJS8fpERHUVr09ENS8jIwNeXl5IT0+v8HBNqn0Hzqdj2Nu/wdPsgH1zB1a6p6m1eZsOYvXOGAxuHYxld3VSX5+25m/877+LeGZoK0yOLsrGW/brSbz03RGM7BCCN8ZqeymeSb6M3q9sg9nRDoefG6zWbdXvpzH/m0PqdMvv6oRBrYN19bhjxR/4/UQyXr+9PUZdF6p7n64O5b3GMFPqCuTk5OjGzn/00UdISUlBnz59aqdSRETg9YmI6i5en4iIrpyaJxXmXSUNUgAwrjjw/KfD8UjMLOmldPSivqdUo+KeUmcNekrFWYWcW9etpdX8Db1d0C8yUDcvAPi5FQ3ZS77ETKlrAYfvXYE//vgDDz/8MG677Tb4+flh7969WLlyJdq0aYPbbruttqtHRNcwXp+IqK7i9YmI6MrtL37yXlXkSQktgz3QsZE39p5NwzNf/4c3i3tAxSRnqe8LYT7Fw/dS9U/rU5+856Udkt3Cav47ujWCg71xHxl/96JGqUQO37smsFHqCjRu3BhhYWF46623kJKSAl9fX9x999146aWX4OTkVNvVI6JrGK9PRFRX8fpERHTl9sUWPXH0Sp+8J3t4QAtMWv0XthyMx7j3/8AjA1qg0KLAy8URgVah46KnVGJmLrLzCuHiZK++dzFDPHnPRbNsf3dntAv1QnxGDsZ2aVRqHfw9in4XJGWyp9S1gI1SV6Bx48bYtGlTbVeDiEiH1yciqqt4fSIiujKXcgtwLKFoSF27MK8qXXZ08wB8fO/1mPLx3/jnbBru/XAPgKKhd9ZD8bxcHeFhdkBmTgFiU7M0Q/tK6ykFAF880B35hRa4OpXeFCF6SjHo/NrATCkiIiIiIiKiq8SB8+lQlKJcpkCPyj21tCzdmvrhy2nd0cjXFXkFFgBAi2B33XSNSnkCX1x60ZC+BgaNUo72dmU2SAFAABulrilslCIiIiIiIiK6SuxTQ86rtpeUtYgAd3w1rTs6NvIGAFzfxE83jciVksPORU+pIM/KNZixp9S1pVzD9ywWCy5cuAAPD48qS/YnIhIURUFmZiZCQkJgZ1extnJen4ioOl3J9QngNYqIqteVXqPo6rSvOOS8qvOkZH7uzvhsyg2ISc5CRICb7v1GfqKnlDbsXDx9z6inVHmITKnkS3mwWBTY2fH3Z31WrkapCxcuICwsrLrrQkTXuNjYWISGhlZoHl6fiKgmVOb6BPAaRUQ1o7LXKLo6qSHnVfjkvdI42NuhWaB+6B4AhPnqe0rlF1rUp+YZZUqVh59bUU+pAouC9Ox8+LjxIRj1WbkapTw8ikLL3NzceJePiKqcoii4fPmyeq2pCDHPTTfdBEdHx6quGhFd4/Lz8/G///2vUtcnoOQa9fTTT8NsLvpyrihKqdMJqampmnJenvYJRD4+PrplyPN4enpqymL9woEDB3TLiIyM1JTT09M15cLCQt088jT+/v6aspub9u765cuXdcvw9vbWlLOztXfd5WXY29tDFh8frynL25+bqx8GkpOToyn7+vpqyhaLRVOOjY3VLSMoKEhTlr8ry71X5GUCQGZmpqYs72cXF+0TrIxek9cr72d5WwH9fpf3q3yu5ufn65bh5aUdPlSec0aua3BwsKYs72ejHkByXTMyMjRleduMjr98XsXExGjK4eHhunnk7ZHrJq/HqKHo5MmTmrJ83smfd/mza73enJwcPPPMM5W+RtHV50zyZZxPy4adCWjbsPqG75VHmE/Rdcg6UyoxMxeKAjjYmeDv5lzarGVycrCDl4sj0rPzkXw5l41S9Vy5GqXELw6TycRGKSKqNpW5voh5HB0d2ShFRNWmst9/xHxms7nMRim5gUFulJHXb9RIIc8j/yErz+PkpP+SL08j/4FdUFCgm8fZWftHh7xeuWzUSCGvV95H8vtGjVK21lueYyivR25Akre1POspT6OU3Ngj72ejRglb65X3s9F5Jy/DVqOU0X63dc6Up1FKXoZcr/I0SsnrLc/xl6eRPxNG+91Wo1R5Pqu2PjPyMo2WYWu9VD8VWhQ89vl+AEVh5G7O5fpzvtqoQeepWVAUBSaTSR26F+RpvqJhd37uTkjPzkdiZh6aBVZJdamO4sBjIiIiIiIiojpu5W+nsPt0Clyd7LFwdNvarg4a+rjAZAKy8gqRfLmoh58IOa/s0D2BYefXjtptWiUiIiK6Blj35jQaAnXmzBlN2d1dm98h96S4dOmSbhly7wu5l0tSUpKm3L59e90yzp8/rynLPUfkYUWAfviaPGxM7lliNIxKHr4kr1eulzw0z2g98jAyo2GD8n6Vt0/ujWOUDyavV55HXqZRjxZ5Hvn4Gm1vXFycpuznp30yltwjS97HgH6Im3yOyD22jIaIJSYmasry/jDqXSbvg7Nnz2rKcs8gBwf9nywVDfU26hkoHxt5H8lDAo3qIvfSlvf7qVOndMsICAjQlBMSEspcplFPKTHk02hYJtVPh+My8OqWYwCAOcOiEO6nDx6vac4O9gj2NCMuPQfHLmbCv5kz4tKLeu1eaaNUABulrhnsKUVERERERERUR+XkF+Khdf8ir9CC/q2CcHuXuvMAjTbFuVZTPv4b3+y7gPiM4ifveV5pT6mihmQ2StV/7ClFREREREREVEe9uuUojsZnwt/dCS/d0rZOZYg9d3NrpFzOw99nUjHj03/gYS5qYqiy4XuZ+h66VL+wpxQRERERERFRHZR6OQ8f/H4aAPDS6HZqY01d0cDLBevv74bpNzaDyQRk5hSor18Jfw8O37tWsFGKiIiIiIiIqA46n5YNiwIEejijf1SQ7RlqgYO9HWYNaok1916PQA9nmExAVIg+C68iGHR+7eDwPSIiIqJqlpqaqgY+yyHHgD6kOjs7W1OWA6aNAsfT0tI0ZTmQWQ6gNgr+lsOj3dy0QbpGgdsicFmQt08OfjYKrU5NTdWU5XBsOejZqB7yPHKgvNF65TB0eR/JQejx8fG6ZcjzBAZqn10uD7MxCuh2dXXVlOWQeqNwfH9/f01ZDkeX1ysfB0Afli6vRw5gl4PPAf0+krfFaB55++S62gqPB/THTg5tlz9DRuTwc/kcOnHihG6ehg0bllkPOSzdaPvlz15ISIimLNfdaFvk/U71V2Jxo0yAR93qIWWkezN/bJvdB8mX8hDm62p7hjKUZEpx+F59x0YpIiIiIiIiojooMfPqaZQCAFcnB7j6Xnkzg3VPKUVR6lSOFlUtDt8jIiIiIiIiqoPURqk6liVV3USjVG6BBZdy9T0Oqf5goxQRERERERFRHXS19ZSqKi5O9nBzKhq6yyF89RuH7xERERFVM19fXzUXSc7+AfQZUT4+PpqynNNjlA+0b98+Tblnz56aclZWVpnrAPTZVhkZGZqyl5eXbh55uXKmjpwHJGdQAfosHzlTKCcnR1OW87MA/T6UM6TkbQP0mVly1pFcV6McH1vLkHOa5G0BbOchyccf0O8zOR8pOTlZU3Z0dNQtQ95HubnaQGF5HqNsK3ke+dyU6wXoc5bkYTnyPirPPpOPv3wc5PMUMN6v1ozy3+RMsKAgbfC0nI8mnx8AkJKSUuYy5fPfaNiSOP5G1wKqX67VRimg6Al8l5OzkHQpF0389Z8lqh/YU4qIiIiIiIioDrqmG6VErlQmn8BXn7FRioiIiIiIiKgOUp++d41lSgHWT+Bjo1R9xkYpIiIiIiIiojpI9JQK9NQPH67vRE+pRGZK1WvMlCIiIiKqZqmpqWpOkJwFBOgzZeQso/JkzAwcOFBTlrOrAgMDNWWjnB65bnKmlJzbA+izqU6fPq0py5k7RrlMcu6UnMsj5xIlJSXpluHu7q4py7lFRuuVs5vksryfjXKZ5H0kZ/zIZTnryGgZISEhmrKc/QQAFy9e1JTlfCR5n8nbBui3T16PfFyMzhl5v8vZTUY5VPJy5fPK09NTU/bw8NAtQ/6MyNlWcpaTvE6j9crniPy5BPT7QK6rfByMPqvya3I95M+h0TkjcqmMjgnVH1l5BeqT567p4XvsKVWvsacUERERERERUR2TlFnUYOniWPIkumuJf3FDXPKlXCiKgq1HEzBp9V/4aFdM7VaMqhR7ShERERERERHVMYmXinrCBXg4G/a6q+/83Yp6fB68kIGRS37HvnPpAIDDcRm4+4bGtVgzqkpslCIiIiIiIiKqYxIyrt0n7wElPaXOpWbjXGo2nOztkFdoQUJmLgotCuztrr2GuvqIjVJERERENUDkwhhl+/j5+WnKly9f1pTlbBs5Y8p6+YKc9ZOWlqYpG2Vbpaena8pyHpQRuS4NGzbUlOWsHzlzBwBcXFw0ZTmHSc76kZdpNI28fUeOHNHNEx4erinLeUheXl6aspzjBAChoaGasnwcjh07pikHBAToliFvv7e3t6YsHztAnxklb7+cuSRPb/SanG0k5zDJOU2Afp/Jx84oh0vOQZL3c1xcnKZslAdmKzNMzumSP1OAPg/KVpYZoD+v4uPjNWX5s2q0DHl75c+QvG1G2VbiOmL0WaD641p+8h4ARAS4w9nBDnYmE+6+IRz39myCG176BYUWBUmXchF0DYa/10dslCIiIiIiIiKqY8ST967VnlK+bk7Y8fiNcHawh5dLUQN3gLszLmbkIC49h41S9QSDzomIiIiIiIjqGNEoFXiNNkoBQKCHWW2QAoBgr6KGqIvpfPJkfcFGKSIiIiIiIqI65lrvKWUk2FM0SumHwtPViY1SRERERERERHWMminFRimV2lMqg3lq9QUzpYiIiIiqmYuLixrEbBRaLZODjeXQZjmAGtCHUMth0vn5+ZqyUQCzHEIuh1QbBS4bvWbt/PnzmrJR0LccDp6UlKQpR0REaMpGwddySLe8DDlMHtDvE3m/yqH0RqHd8rGRp/H399eUPTw8dMtITk7WlMsTbC+vR94nISEhmrK8rYA+lFwO8ZbL5XkkvVx3+TgA+uMth6XL52FiYqJuGfL2y8fOwUH7Z46Pj49uGfL2ycuU6wnoj7ccli4HjxudM/J5JR87+bNr9HAAsZ/laal+YU8pvQZe7ClV37CnFBEREREREVEdYrEobJQyUNJTig2y9QUbpYiIiIiIiIjqkLTsfBRYinrr+bmxUUooyZRio1R9wUYpIiIiIiIiojpE9JLycXWEkwP/bBdET6m49BzDIbZ09WGmFBEREVE18/DwgIuLCwDA29tb976cqWMr/0meHtBn5sh5Qb6+vpqynKcDAAUFBZpyampqmfUAgPT0dE1Z3j4vLy9NuTx/RMj5T3KOj5wXBOhzeWxlXZVnuXL+l7wtANTjKsgZP/I+S0lJ0S3D6FhYM8oUkpcrZyrJ54jRPpOzqi5duqQpy1lXYWFhumXIWV5y/pPRPHLOmHzuGmWmyeRsLnm98v4xynJzd3cvs2yUZSXXTT7+MvlzCOjrLi9Tzu4yOj/Ks4/o6sahe8aCintK5RZYkJ6dD29X/e8lurqwyZWIiIiIiIioDkm8VNTAHeihf7DDtczsaA8f16IHCMRxCF+9wEYpIiIiIiIiojqEPaVKF+xV1EORYef1AxuliIiIiIiIiOoQNkqVLtizaJ8w7Lx+YKYUERERUTW7fPmymt8jZ/AA+rwfOdtJzqDJzs7WLSMuLk5T9vf319XBmlEWjpy7I+fyuLm56eaRlytnKslZT3IZqHimlrx/AH3ujryfjTJ45O2R6yFnORktIzMzs8xlyplCRllXct6XfHyN5snNzdWU5fwnOf/KKFNJ3s/yeShnLMlZUIB+e4OCgnTTyORzT97vcg7VxYsXdctISEjQlOVj5ejoqCkbZWrJ54hcDggI0M0jn3vyfrX1WTYib798nslZX0DJOcOg5/pLbZRyZ6OUTO0pxUapeoE9pYiIiIiIiIjqkAT2lCpVg+In8LFRqn5goxQRERERERFRHcLhe6ULLn4CHzOl6gc2ShERERERERHVIYmX2ChVmmD2lKpXmClFREREVM2cnJzUzCOjfCA5l8nHx0dTlnNp5PwkQJ/TI2dMyblMcgYRoM97knN5jHKJAgMDNWU5D0feNqMMHHk9cl1NJpOmbJSxI2+vXK8ZM2bo5nn99dfLrJu8LUbHLiUlRVO2lSHl6empW4ZMznqSc6sA/T6Q15uenq4pG+UjyeeAnMsk51bJ5yWgPxflc0ReJqA/V+X1yMdSPj+M6iLnMsnrOHfunG4Z8rGQ96FRhph8bsrnjHy85Ww3AIiNjdWU5fwv+TMj7x+q/3ILCpGWVXQdYKaUntooxZ5S9QJ7ShERERERERHVEcmXikL3He1N8HbVN8pe60SjVHp2PrLzCmu5NnSl2ChFREREREREVEdYP3lP7ilKgIezA1ydinoysrfU1Y+NUkRERERERER1BEPOy2YymdTeUnHp2bVcG7pSbJQiIiIiIiIiqiMYcm6b+gQ+hp1f9Rh0TkRERFTNsrOz1UBko/BkOcj85MmTmnLDhg01ZTkY2WgeOZC5sFCbu2E0JEQOepZDnI0Cp+VQ7osXL5ZZVw8PD90yzpw5oyk7OGi/ovr5+WnKQUFBNushB1+/+eabunlycrR/zMjbJ+8Po4B1eT+7ubnpprGWkJCge83d3b3MZcr7FNAHaMvHSg4gNwrLlusqh6PL54h8XAD9PpLPZaOQdnn7ZImJiZqyr6+vbhq5brYC9uXgc6N6yMdBPqcAIC8vT1OW97u8/fI+BWwHrMvbZhSOf+rUKQAMQa+vEjLYKGULw87rD/aUIiIiIiIiIqojEi8VNbTwyXula+DFnlL1BRuliIiIiIiIiOoIZkrZxuF79QcbpYiIiIiIiIjqCDZK2RbsVTQkVx6+dym3QDesluo2ZkoRERERVTN3d3c100bOjwH0+UdyhpScG5OUlKRbhpy7Y2envfeYna19QpFR1o2cuyNnGTVo0EA3j5yzJGf5hISEaMrytgL6nCk5lyclJaXMegKAq6urppyamlrmMgHAx8dHU05OTi5zmXLmEKDPJZKPlZyHZZQBJOdDpaWlacoRERG6eeR9Ih9veXvlLCRAn13k7e1d5jKNzl05d8lsNmvKRjlUcpZXTEyMptyqVSub65WzquT1yJla8nEwWq5cL/lcBvTnnrwM+Rwxqru8HnlbbK0DKPlcycui+qEk6NxsY8prl1FPqZ0nkzDxg78wsUdjPHVTq9JmpTqGPaWIiIiIiIiI6gBFUdSeUoHsKVUqEXSeeCkX+YUWKIqCRd8dQV6hBT8diq/l2lFFsKcUERERERERUR2QkJmLnHwL7EwcvlcWPzcnONqbkF9Y1Ih39GIm9p0r6gF8OvkysvMK4eKkf9ot1T3sKUVERERERERUB+yJKRp63KqBJ8yObFQpjZ2dCYHFwxvj0nPwxk/H1PcUBTgan1narFTHsKcUERERUTWzt7eHvX3RHxdyBpMROXdJzlySc3wAwNHRUVOW83DkXBqjvJzg4GBNWc4cKiws1M0jZ/fIeVjyeo3qLvZNaeuVl2GUKSXPU548KDnLKDAwUFM2yqGSyccmNja2zPflMqDPBUpMTNSU4+LidPPIOVRyppKc7WS0LfL22jo3jfKw5NwpeVvkY2tUVzmrTM4/k7cFAMLDwzXl+HjtcB15HUZZZvI5I2eKyfsY0GeIyeS6Gx3vjIwMTdnLy0tTlrPc5Kwv6+UaZXbR1W3PmaK8uM7hPjampGAvM86nZWPdn2ex71w6zI52aBbojgPnM3A4LgMdwrxru4pUDryKEREREREREdUBf58p6inVqbGvjSlJ5Ept+PscAODuGxoDAA6cz8CRuIzSZqM6hsP3iIiIiIiIiGpZVl4BDl4oakzpxJ5SNjXwLOlFaXa0w/29mqJVg6JehIfjOHzvasFGKSIiIiIiIqJa9m9sGgotChp4mdHQWz9MmbRETymgqJeUv7szIoM9AQCHL2ZAUZTaqhpVABuliIiIiIiIiGrZ38Uh5+wlVT6iUUr0kgKAiAB3ONqbkJlTgPNp2WXNTnUEM6WIiIiIqll6eroaEi0HgxuRQ6nlstHd34SEBE3Zx0f7R40cON28eXPdMuTgZzlQPC0tTTePHGwuB6jn5eVpykZB0XI4tByWLe+zzEz9sIykpCRNWQ6plusBAKGhoZqyp6enppySkqIpy6HegL7u8jLkfWp07OQAebnuRiHdcui4rfWWZ7/LZZlR3eXQbplRWLgc5B4QEKApy+eQPD2gP55ubm6asrxPjQL25X0mB78bBfvLn0X5XJTPKTm03Kguclh5SEhImesASs53+bNCV7c9xXlSDDkvn76RgRjUOgiDWgfD373o94STgx2aBXrgcFwGDsdlItTH1cZSqLaxpxQRERERERFRLbJYFOw9W9woxZDzcnF1csDyuzpjdEdtY3CrYJErxbDzqwEbpYiIiIiIiIhq0bGETGTmFMDVyR6RxY0qVDmtGhT1gjxykY1SVwM2ShERERERERHVoj3FeVLXNfKGgz3/TL8SolGKT+C7OjBTioiIiKiaeXp6qvlMRhk8ct6PnCEjZ9DIGTwAYDabNWU5/8fXVzscxCinRl6PnCkl5/YAQFxcnKbs7e2tKR8+fFhTjoiI0C1D3icNGjTQlOUcHzkfCwAaNWpU5jxG+UByppBRdpM1o1wqeR/J+UDyPEb1sJW7JWcdGS1HPnbyMoz2mVxXeVvkc8goD02exsND28NDzr4C9OeqvN/lc9PofJenkfeHu7u7puzo6KhbhsVi0ZTlXLawsDDdPOfPn9eU/fz8ynzf6JySj6d8/OWy/JkCSvahrRwwunr8fUaEnHPo3pWKbFB0HYpJvoysvAK4OrHZoy5jEywRERERERFRLdpzpujBCgw5v3L+7s4I8HCGogBHL7K3VF3HRikiIiIiIiKiWpKQkYPYlGzYmYqG79GV4xC+qwcbpYiIiIiIiIhqyZ7ioXstgz3hYdYPNaWK4xP4rh4cXElERERUzeLi4tQ8npCQEN37cu6MnPXj46MdziHnBRm9Juf/yNkzRtlGci6RvIzy5DLZ2WnvebZu3VpTNsplkvOg5LrK+VBG+UCy8swjb6+cdSRvi1yuzDLkYwvoc5kuX76sKZcnD0reXvl8SExM1C1D3idy/pOc5ZSenq5bhpz/FR8fX2Y9AX2Wk631yvsDAIKCgjRlOZdMLsufIaO6yp9NeZ8CgL+/v6bs6uqqKcu5XElJSbplpKSklFk3o9w5mTjvcnJybE5LdZ8IOefQvarDJ/BdPdhTioiIiIiIiKiW/C3ypBqzUaqqiLDzI3GZuoZ/qlvYKEVERERERERUCwoKLThUPMSsYyM2SlWViAB3ONnbITO3AOdS+ZTKuoyNUkRERERERES14FxqNvILFTg72KGht4vtGahcHO3t0CzQHQBzpeo6ZkoRERERVTNPT081a+jChQu69wMDAzVld3d3TVnOKZIzaQDAy8tLU5ZzeuTsGaN8JDmn59KlS5qynB8F6DOi5OXKwyaMhlHImUHyNHJOj1GmVlpaWpnlZs2a2ZzHaLnWUlNTda/Jx0bOS5LzkeTjAuj3s3wc5Mwxo9fkfSQzel/Ow2rYsKGmfP78eU3ZaP/I56Kbm5umLO9jwPY5IzPKTZKXK+cyyVlORp87eR65XkbHylbelclk0pTl8wPQH185q0v+nMnnFFCS1WWU2UVXl9PJRedQYz832NmZbExNFRHZwAOH4jJwOC4TA1sH13Z1qBTsKUVERERERERUC2KSihul/F1tTEkV1Sq4qIH3WEJmLdeEysJGKSIiIiIiIqJaUNIo5WZjSqqoRn5FDX3MlKrb2ChFREREREREVAtOJxcNxW3ix0apqhbqUzRs+Xyqfgg01R1slCIiIiIiIiKqBewpVX1CfYp6SiVdykN2XmEt14ZKw2Q8IiIiomqWn58Pe3t7APpwZQDIzNTmXciB0nIQtlHgdGJioqYsB1t7e3uXuU4ASE5O1pTlEGU5PBoACgoKNGVbQdBGYelyCLUcMB0aGmqzHnKgtBxsbrS9toLN5e2X96HRemVyILevr69uGkdHxzLrZRR0LtdN3s/Ozs5lrgPQnyNyXeXQcqNAcnn75dBuo7DwBg0aaMry+S0Tnx1rcki7fB7K+0zeP0bLlR8WIC8T0O8DeRlySH92tn7YkBx0Hh8frynLdW/cuLFuGWKfyeHsdHXJK7DgXHEvniZslKpyXi6O8DA7IDOnAOfTstAs0KO2q0QG2FOKiIiIiIiIqIbFpmbBogCuTvYI9HC2PQNVmOgtFctcqTqLjVJERERERERENUwM3Qv3c4PJZKrl2tRPIleKYed1FxuliIiIiIiIiGrY6eJGqSb+rrVck/qrpFGKYed1FTOliIiIiKqZg4ODmgEk5/QA+hweW/lPcp4OAPj5+WnKcsaUzChPqbCwsMyyUd1t5RLJd/+Nsn1CQkI0ZTlTR94fRnWX9+H58+c1ZTnHB9DnHck5TKmpqZqyUS6TrRwiua5G2y9nLMnrMcpUko+NnAcmZw35+/vrlhEbG6spy/lQ8nqNMqXkfC+57ka9P+Li4jRlOTNMPv7ycQH0+zUhIUFTDgwM1JSN8sDkfSgz+pzJ53dOTo6mLO8joww5eb3yZ9fVVdtAIR8noORYyeunq0tMcnHIOZ+8V23E8D32lKq72FOKiIiIiIiIqIbFJBU1wPLJe9WHw/fqPjZKEREREREREdWwkuF7bJSqLqJR6jyH79VZbJQiIiIiIiIiqkE5+YW4kF7Ueyfcj5lS1UUM30u6lIfsvLKH7FLtYKYUERERUTUrLCxUc2TkPB0A8PDw0JTlDCk5D+fff//VLSMsLKzMOsjZRydOnNBNI2fZyDlERtlGcu6SyM4S5LrLeUGAPmdJroecFyS/b7ReOcsnPj5eN488jZyHJGdoGa330qVLZS5DztySy4A+M8koQ0km7zN5+y0Wi6Ysn1NG08hsnZeAPrtKzumSs50A/T6T87DkvKjyPJVMPpZyHpRRflR2tnY4j5ypFRwcrJtHzoySs8xsrQPQ73f5cyWXGzZsqFuG2M/ycaerR2xKFhQFcHOyR4C77c88VY6XiyM8zA7IzCnA+bQsNAv0sD0T1Sj2lCIiIiIiIiKqQWLoXmN/t3I1vFLlid5SscyVqpPYKEVERERERERUg9Qn7zFPqtox7LxuY6MUERERERERUQ2KSS4aytzEj41S1a2kUYph53URByETERERVTNXV1c1S8gol0nO5cnIyNCU5YwdOevIiJzlI2cq+fr66uaRc6fk7Ju0tDTdPHJmVExMjKYs5zAVFBToliHn/eTk5GjK8vYbZSG5u7uXOY38PqDfj3IOkXys5HoB+owheRly3Y0ygDw9PcucRs46MpKSkqIpK4qiKRvVXd4n8nGQM6SMzl35+Mv73eh4y1lNci6TvB6j3CZ5e/z8/HTTWJM/Y4D+2Mh5X3L2FaDP+5L3kbwMo0wp+XjKx87oXJWJ804+/+jqEZPEnlI1RQzfY0+puolXMSIiIiIiIqIaJBqlmvjzyXvVjcP36jY2ShERERERERHVkJz8QlxIL+rt15jD96qdaJQ6z+F7dVKFhu+5uLhg/PjxAIDWrVsD0D8qFgAuXrwIAPjtt98AlDyyVMwjuvmeOnUKABAbG6vOKx49LB5zu23bNgAlXX9FF1XRrVnumgwA/fr1AwB06NABQEkXWdHl/MyZMwC0jxeOiIgAUPI4WdHlXXQXXrZsGYCS7vSiK/rAgQPVZYjHtYru8Rs3bgSg78Yt5h07dqz6mtiuNWvWADDu6lsTRHdpsX9Ft2ZR56CgIADaIQBJSUkASrp8i6dHGB0b6/et/y/2u/xIYJnczRow7o5dVcRjncXxse6SLuou9pm8/UOGDAEAtGrVCkDJEAHrYQ3ieIvze8SIEQBKPisXLlwAAPz+++8AgCNHjqjziuWJ8zwqKgpAyXkuupOL7uzWdRfHb8eOHQD0+1AM3xgwYIBmXdbHff/+/QBKPiPiEd/lOe6iW3r37t3V9a1cudJwPiIiIiKi+uRMcZ6Uh9kBvm76v2+oaonhe0mX8pCdVwgXJ/1QZKo97ClFREREREREVENOq0P33DQ3bql6eLk4wsO5qNPF+TT2lqprKtRTysnJSQ0mlHsfWRM9JkQPKdHrR/wUvW5EDyLrAETxf6MAS2tGPVdEDw3RQ0T06mjQoAEA6AJGrecV2yOHJIoQRfliIXoSWQdRivXLIZEyMZ11MKFRD6DaJLZX3m6xbUb7vbyspxfLt3W8y1pGTSgrRFLUXT6uIghT7m1lROwHMa04R8XnweicEr35xE95H8rrtV6G+OyVth/FeS22QcxrHfgpPhu2llUWUUfRU+5KtG7dWv0cyyGkQMl1SZCvXXLIrNH2iGuaIH9u5eBS616gpa1H7ANBDkg1Wo/8uZTLckAyUNKjUZDDjOUgYqMAZHmf2Qq3NVqvvI/kMN9z587pltGiRQtNWT6+8vkj72MACAkJ0ZTl/Sx651qTQ6Hl7ZfLRl8q4+LiNGV5n8nziJ681uRjIwfgGgUgy9sjh/XK5115eufK1zB5Pxt97uTer7YCoI1ek/eRvG3y5xLQf97l4y8fBzlkGCi5tmZnZ6s9n6+E2WxWj1V5/gARva8F+VwKDQ21uQz5Myl/3ow+K7YCxo16yB88eFBT7tatm6Ysn19G55t8fsm/9+S6G10r5e2Vzzf5vDeqi/y5lpcpetZbk883OaRbPt5GYeHyfpav0UZB37Z+ByUmJmrKRuH48vbJ1wq5bPS7QT5Wctlov4tRFYJ8nZPPB3l/APrPvrxe+dgaXW/kz4D8OTO6vsp1M/pMWDMKtj9//rymLP/9Ic8jh6kDJZ8BNmhcnWKSi0POOXSvxjT0ccGRi5mITc1Gs8CyP7dUs9hTioiIiIiIiKiG8Ml7NY9P4Ku7KtRTKj09HS+++GKlV/bnn39Wel5B3NExeqytIPJ3xM/y2LVrV4XqIXoifP755xWaDyi5c7NixYoKz1vdxF0m8VPsZ7G9cs8BIxXpMSOOZ2pqarmmr878KCPiLqt8t7U886xfv77C61u3bl25pxWZbOJnVRK9G0TmVVWwPi/EHb/Nmzfr3iMiIiIiqs9O88l7Na7kCXwcvlfXsKcUERERERERUQ05m1LUMBLO4Xs1pqRRij2l6poK9ZQiIqqrDh48aJhbUV5yvkN1McquqQ1y1lNdJmd8EFWUrSe7GhE5SRXpKWurDiKfxigfRs62kfNv5Bwsox7jcmaQrawwo4wd65xPQJ/TY9SzVc59k/OP5Owfo/wxeRo5Y0jOEjNahszWMgB9ppJ8HORlyDlNgP7YyPtIzpwST5q2JmcmydsnZ8kB+uMrr0fOKZLfB/TZXLaWYbT9co6hvA+NMpfk1+RzUd42+bwE9MfO1vludPzlupeWz1nWcuRjJV8zjDJF5Uw4eRo52ywsLEy3DPG9pazRI1R3pVwuGv0R4G77WkZVg8P36i72lCIiIiIiIiKqATn5hcgtKGoA9Xat/A1VqhjRU+o8h+/VOWyUIiIiIiIiIqoBaVlFvens7Uxwd+bApZoSVtxTKulSHrLz9E82p9rDRikiIiIiIiKiGpCWXTR0z8vFESaTqZZrc+3wdHGAR3Ej4Pk09paqS9g0S0RERFTNfHx81PweowwYe3t7TVnOuZOfPhscHKxbhpwHJGfbyGU5TwfQZ+rI+UdGeVhy3eQMLzljyCinx8FB+5VU5G8JcgaRUT6SvA/lZRhl+sl5UPJy5W2TM5gAfd3lfSjncsk5VYA+M0nOkJK3BYDuj9mAgABNOSEhocx6APocJjkfSc768vX11S1DPr5y5pJRDpm8n+X1yPvQ6HjLOUxy3eRlGm2/fOzk42D01Glb2yt/ZuSsN0C/PXI5JCREU64reZRUNdKLe0p5u3DoXk0ymUxo6OOCIxczEZuajWaB+rw7qh3sKUVERERERERUA9KyixqlvJgnVeMYdl43VainVLNmzXDDDTcAAA4fPgwAiI2NVd8Xd7HE3TtxN0m+CyXuEIlWf+vW/9OnTwMouUPSsWNHACVP5RB3OcRdRuu7D+I18VQpUZbrIe5gWN8diomJAVByh0T8bN68OYCSp16I9Yv6nThxQrd+Ma98R1LcjRHrt36iibi7c+nSJc02nDlzBkDJnTqjp29cuHABQMmdGnGXS+wb8VPcZRNl6ztGYvlifeJpV+LpIN27d9fU3foukDju4riK/Sy2T+wHo6eeiDuuYnvFes+ePQug5C6Y2N/ijpX1sRP7XTwRRpTFvKI+Yv9b36EU+0LcXRX7QTwFR9Q9PDwcgPburth/4vwVd+TEHUGxvpMnT2q22fquq7gTKvaVOM/F3U9x50w8hcX6iUapqakAgHbt2gEALl68CABo0qSJZp6dO3cC0N79E59jcT6JuoppxH4+cuQIgJLjIvYDANx4442abRB39cV+EOeh2LfW+068Jo7joUOH8Oeff4KIiIiIqD5jT6naI8LOzzHsvE5hTykiIiIiIiKiGmCdKUU1K8y3uKdUCntK1SVslCIiIiIiIiKqAenFw/e8XZ1quSbXnkbFjVJnU9hTqi6p0PC9wsJCdciSGApmHcQohnQFBgYCKBn6JH6KIULipxxQaP2aGMYkhmKJME4x7Ecexgfoh4eJYVuirmLYlli/dSCmGFokhhyJ4WJiGaIshpmJelqHN8pDr8TQNPFTDCMUP+XQTqBk+JTYLjGcTwz5EttoPRRKTCNPWxp5SJz8f+vtEsdOvC8PcwNKhpjJQ8DEMRJlMY/1usRQL3nYpLwMMa/4aT30UF6+HGwp6izqZ33OiLqL/Sn2jThnRF3FsDnrIXBiHvlclIeNivNBnH/WIaliXjHUTgwbFCGaYv3y5wEo+UzIQ1nFdopjJ7bJ+nwXdRDbI5+r8hBIsQ2iHtbviXNF7Hf5syr2k/VQW7EvxHKNrgUVFRkZqX5+5aBWo9fkEGEx7FGwHposyKGycnir/DmSA1ONliGH11rv49LmkUNy5XNeHjpsRAxZFsRQZcHHx0c3jzhPBTkkuWnTprp55PBW+bonb78cugvot18OiZbDfZs1a6ZbhhwaKwfiGoU3i2GrghjOKohhxoIcmAvot08MuxXEZ14wOv5iaG5pyzR6co987skhufL2y8cW0B87eT/Lx2HBggW6ZTz66KOashwSLe8PQB8SfOrUKU1ZDoCWQ4cBfbCwvP3y9cAoiFicE/Lnq7Kys7PVa4Z83AH9Z07+HMvzGIWly9e1Fi1aaMrie4JgdI2Sg53l/S2HmAP6c0Pen/I1Xgy3tyYHt8vXAvm8Nwr+lq/B8jXK6FyRyZET8mfSKCxb/qzI+1W+/hhd5+Twd/k6bxSBIE8jb791TARgHJYt/x6Tz0P5eBuF1Mv1kLff6FjJ88jHSj5njD6j8jTy9UTeNqO6y/tE/A0jGH1Xl68J8nrk7+FyAD+g3375Oi5/RoyC3sXnuaquUVRz0oqH77GnVM1jo1TdxJ5SRERERERERDUgTe0pxUapmhbmW3RzLD07X832otpXoZ5Sp0+f1t1dtybfzawKIni7tuzZs6fKlykHX1eEfBe0LPJd/soQd4qPHz9+xcuqLfX9Mbq//vprhef56aefKrUu6/OgKs8Jo8dFExERERHVN+nsKVVrXJ0c4O/ujKRLuYhNzYKXq77nMtU89pQiIiIiIiIiqgHp7ClVqxoV95biEL66o0I9pYiI6qojR44Y5kWUl1GG1LVk//79V7yM06dPV0FNqCZUpmfzhQsXynz/1ltv1b1Wmd7OcqaRTM7jMconqkrlyWgrD4vFossJtCb3hJbXK+fyGGXnNWrUSFMWeYiCnKlklFMk543JeThGGWZyho6cHXbixAlNWc6PMqqrnGUl7w+jusv5P3K2kVGmlDyPvJ7y5CPJeXJyRp18zjZo0EC3DHmfyfvZKLNOzhmS6y6v1yhzVM6QkrPK5Oyj8mRAyvMY5ZDJ5P0qb4u8fwDb1yQ5H8qo7vL2yplhck6X0XLkHvlyLp6c5Qbot0c+vvJxMbpmiM+qUb4c1W0lT99j0HltaOTrir1n09goVYewpxQRERERERFRDRBB5+wpVTsYdl73sFGKiIiIiIiIqJoVWhRk5hT1wGSmVO0IK26UimWjVJ3BRikiIiIiIiKiapaRXTI0lY1StYM9peoeZkoRERERVTMHBwc1N8Yop0Z+Tc7lkfODjHh5aZ8iZCtrxuh9OS9HziUykpubqynLeTlyXpBR/p+cESXnEPn5+ZVZTwDIyMjQlG1lTBnVxc3NTVOWc5jkdQD6YyXvVzn/y2j75UwhuSxnbBm9Jh8reb1G+0zeJ3KGmJwxZkTeJ/KxlI8DoM/dkveJvAyjHDK57t7e3pqy/BRqOS8KAMLDwzVl+XgbZTnJGVFyhpR87OS8NECfGSafd2lpaWXWCyg5vkbvUd2VVtwo5e7sAEd79g+pDeF+RZ+386nZKCi0wIHHodbxCBARERERERFVs7QsEXLOXlK1JdDDGU4OdiiwKIhL54MC6oIK9ZRyd3dHaGgoACAgIED3fml35MSdCXFHQ9x1ad68OQBAURR12uPHjwMouesm1ieeVCKeTiOeymF9l0jcIRJ3bBISEgAAhw4d0qynRYsWmp8AcPjwYc1yIyMjAZQ8uUPcwRTbIu7gWD/1R9wZEXcqxZ0TsYzGjRsDKLk78s8//6jzHjt2TPOeuNvTtGlTACX7W+xD67ty4v/ibo6oh9hesS/FnRSxDOvjJZ7EJO7EtmzZUrOd8h0b6ztn4u5VkyZNNHUVdRf1E0/mEscFKLmLlZSUBAC4ePEiAODkyZMASu6ciW0ST84Rywb0d4rE9ol5xR1acefW+nwT+0D+KbZXnG/iDpbRU4fEPGK58t1usW/F092s7xiL81e8JpYhtkWsT0xnfVdQ3GUUr4n90L59ewAlx33nzp0AtHfq+vTpA6DksyI+O+L8F0+SOXfuHICS875Hjx7qMsRxF8dGrE+sR3w2xE/r7RafEbGMgoICfPnllyAiIiIiqq/Si3tKsVGq9tjZmRDm44KTiZdxNiVLzZii2sOeUkRERERERETVTDRK8cl7tYu5UnVLpTOlRI8K8dP6/6KHiughI8awix4lokeHGLduPRZa9MgQP0XvH7EssWzRG0X0nLH+v+jdI/fcEvOKXAKjceJivaJOoizGw4t6iB4m1mPixfrE+n18fDTbKy/bmuhFIn6KnkiiLHrDiHHs1ssQ6xX7We4pJXrBiJ4sRr19RN3EPPI0oizWYZ1TIO9HUVd5rL9YhnVegVG+gfU2iJ/i2Mm9wYCS3l2ih47YTrEe0UNKHDvrnlJiP4r9Ko6dvM/EsbTORRD7TN438vluvT7rbQBKzlm5J5Soh1iH2BbrfSc+b2I94jMhr08s0/qcEdOIHnmi55JYpljWhQsXNMuwzjQR2xEUFASgZB+KecV+EMu2znIQx09sj63ck/KIjIxUz0s5qwLQZ5rIGSDWvR4B4/wK0ZNPEL0DBdGzTpDzPADtNRPQZ7HI2RSAvqeivC0hISGastH2y/kc4pwura7y9IA+J0bOCZGXCegzT+TzU16PnNVhNI2t7JXWrVvrlhEREVFmveTjAJT03BVEj1ZBzvgxup7J55lM3mdyngugPzdjYmJsziOfI/L1OD4+XlM2yiuSzwn5+Ms5MnI9Af353qFDB01Z9Ma0Jp/Pct3lz5nRsRM9RgV5e+XjYpTXIz53ubm52Lhxo+79ilIURT3/5XMW0GfqyJ8VOQ9HPsaAfl/ZyjoyOnfkaeRzQ/RctyZ/Z5DnsXVMAX2mjnwtkHN5jHKZ5EwheZ/J7wPGeUfW5Loa7Xd5n8nHrjzXCnkeeRqjHDK5bvK2yPMYfVbk73ByPWydl4D+PJL3kdH5Ll9f5H0kZ4jJvweNiO8spbF1PQaMPxMyefvk65yt42K0Hvn3nJwPZnS+G/0tRnVfWhYbpeoCNkrVLewpRURERERERFTNRKMUh+/VrjA2StUpFeopdenSJRw9erS66mJoz549VbYscSdh165dNqeV78QSXS327dtnc5rK3vW3/jxW5WfT6M4rEREREVF9UpIppR+xQzVH9JSKZaNUncCeUkRERERERETVLC27KE6Dw/dqVyM/9pSqS9goRURERERERFTN0kWmFIfv1aown6JGqbSsfLX3GtWeSgedExHVJUeOHDEMAq0sW4Gp5Z2moiozdLimh1XXdZs2bartKlAp/vrrL5vTxMXFXfF6fvvttytehlBVIcJ2dnZqeLXRgwTk4GM5lFoO6TYa9mwUWG9NDhM3Cn6Ww8HlBycYPYxADn4WD7gQ5CDws2fP6pbRuHFjTVkOwrZ+sA1gHEgth+/L9TAKnJZfM3oYjC3yPpPrJm+LUdC7fDzlkHJ5HYA+DF1er3zs5IcVAPpzQD7PjOaxJTk5WVM2Ot/lustleRlG4fDyOREWFqYpJyQkaMpGD1WRPxPyPjN6YImtBwjI30WMPjPyMuTzLiAgQDePTJzvpT00iOqmtGxmStUFbs4O8Hd3QtKlPMSmZMGroZftmaja8CpGREREREREVM3UTCkO36t1YcyVqjPYKEVERERERERUzdLU4XsMOq9tjfgEvjqDjVJERERERERE1UhRFKQz6LzOYKNU3cFMKSIiIqJq5urqqubznD59Wvd+SEiIpuzgoP2KdvHiRU3ZKHNGzhQKDg7WlOXMOqP8JDmHSWaUyyPn4+Tl5WnKck5PgwYNdMuQs32ys7PLrGtqaqpuGXI+lLu7e5nrMHpNXo9cD6PsQjl3SM5/kucxygOTs8vknCCj9cq5U/I88rFyctL3zJC3V6670TjbvYkAAFWWSURBVDwyeR/6+vranEc+R+R9Ip//ctmInN0knyNG+VDyPpMztPz8/HTzJCYmasryeSavx9/fX7eM+Ph4TVnePlvnP6DPcqO6Lzu/EPmFRec6M6VqHxul6g72lCIiIiIiIiKqRmLonqO9Ca5O+oc1UM1qxEypOqNCPaWaNGmi3oUSd2eM7piJux3iyTHiDoG4syDuQoi7AtZPIRHLCwoKAlDyNJbw8HAAwJkzZwCU3DGMjY1V5xVP6hBP3xB1FU/fEOsTdzSs76CI7RF3TMQymjZtCgA4d+4cgJKnAp04cULzPgB06dIFQMndLLEtoiyWIbbX+q6I2FfizpHYXnH3MTAwULNfrJ+OIu5IibumoiyOg3jqSVpamma7rZ9wFBMTAwDYtWsXAKBbt24ASu72iLtP4i6s9frF/8V+Ffu9devWAEru1J46dQoAkJKSos4r6iR+ijtHJ0+eBAB89tlnAIBmzZoBANq3bw9Au9/Ffhb7qkWLFpr1ivqIO3nWd+PEk0vkfSN+irvZYr8cOHBAnVcsT+x3sY/EudOuXTsAJef9kSNHAJScO9Z1FU+QEXe99u/fr6mrWJf1XeDmzZsDKDnvxV1WcTdN3In28fEBoL0bmJSUBKDkmIi752I/iDvlYlvEOWx9N1Tsb/H5Ep9J8VOcK0Z3pkUdIyMjARTdmf3pp5900xERERER1QeiUcrLxalST/qkqtXIr+hvmXOp2Si0KLC34zGpLewpRURERERERFSN0pgnVacEeZjhZG+HAouCuPRs2zNQtalwppRo1RVjzK3HTYseOVlZRV3gRA8WkSUgenKInlKip4X1OHnR60P0JhI9h8QYd9HbQ6xX9DCxnkdMI3ofiXqJ3kBt2rTRLNN6u0RPFbF9oreH6NUk1iumt+59ItdV/BQ9iURvJ7G91vkBFy5c0Lwmet3IvcnEOqx7qIlx52K/izqJ9YtlinnFfrEery6WL3rmyD8FsWzr7Rb7SD4nxHaKfSX/tCbWI+ohZxrI81jXS5xHokeQqIfYXnH+iWVb98xLT08HULLvxL6S6yG20TqvQ2yf/J44ZmJZYtliv1tnQMjHTGyXKItpxfZb7xexfWIasV7xU5zLYpnW54yoW2nHW9RV9JySe8EBJcdZ7G+xPlFXUS+x/63PGfkYlSezwhYfHx91OdY9+QQ5e8P6PAD0mRBGmRji+iTYynOQ1wGU9FITxDkgGOVXyOsNDQ3VlEv7nJa1Hjk3Rt5ncr4JUHI+CKKnmyB61pW1XDl7Rl6mnJsDaHvEAvrcGLmuUVFRumXIdZWPt1wPADh79qymfOjQIU1ZzgSRM4EA/Xkkl+XjYHTOWPdqBUp+Xwjy/gH011CZ+IwLosdjWXWTz3f5nJIzYgD9+SxnHsm5KUbTyNtv/Xsf0OcV/X97dxpcV3rfd/53sYNYiR0gCe5ks9mLuqXulmRttmXLkiLbWhw78YynbFfimXFV4qnMOBXZjuOkErsSJxlPuVJjO7HL9tjxElmLtS/tltQtqaXem2zuOwmAAIiVWIjtzouL/8U5//MAF8u9uAD4/bwhH9x7znnOcxaQz3me35Hio2mlZLaMv6ZC14yNgvVttV6XL1/O3jf9NSwlz2v7/WR8W4Vyifwx8BlS/loJ3St9to3Pwwm1t7+/+vPJRnkv930pPopaSo6yXU3Gkm8T/7sldJz9/vo8IH/e278po/x1668Nv78HDx7MWQ+/zGpyqHw9/P6H7i/+vArdx1Zap5RsM1/30L3B749fxt+jQ9dhaH9WWmcoh83XzR87f11Kue9jvq7+Wg6tw2dZreZ8t2OR636PrWNsykZK0Sm1FZSUpLS3qVqXByZ0fWhSe3fvyr0QCoKRUgAAAAAAFJBN32ukU2rLyIad3yFXqpjWNFLqypUr65r/6p9I+rdWrMSyddbCP1U19rTDcqlWcuHChVVt69y5c8G/b9R69jufXnrppaJu3zt//nzsz63Anqb50RI2uuLZZ5/NuY7QG5hC/DUk5fd88+xJsH8ifPr06bys355MvvDCC5LCT4ABAACAnWLERkoxfW/L2Lc4OurGMJ1SxcRIKQAAAAAACmgp6JxOqa2iqzEzdbZ3NPnyNmyeNWdKAcBWNDw8nM1c8Nkk20kor8U7c+bMJtQkN5+xtFV89rOfLXYVdgSff7YePtMoH1ZzfYdGl66Vf7PpRqVSqUTmXpTPsvHZPT5LK1Qvn0vjs34sr9KsJmMoV72kZKaNz9Dx2VW+XlIyu8mfO5bLaUIZOz6nx+cF+dym0HZzZUqFcqn8dvyx8blcoXb3P8uVrRmqS679DW3XZzf57fhMJd/GUvL3ls+jC12zPhvP56z5nL/QNe0z63wOoM/wC93T/HnklwnlDfrr118T/hoKZbf5dvb18Nv1bSotXc+hN6Fjaxqdsul7G89SRX50NmTu8X10ShUVI6UAAAAAACigUd6+t+V00Cm1JdApBQAAAABAAWWDzumU2jJspFTv6DQZt0VEpxQAAAAAAAVknVL1ZEptGe31mU6pqdn57PRKbD46pQAAAAAAKKClTCk6pbaKqvJSNdVkMr4IOy8egs4BAAAKrKKiIhuI7MPDpWSgtg8+9oHUobBwP/XAByD7ddbU1CTW4cOifcD4rl27EssMDw/Hynv27ImV7927FyuHQtr9z3ygtg+LXk0Qvw/+DoWUez4c3IfHhwLHfZuEvhPlg7BXU7fQOeOPtz+evo1aW1tzbtefI6Fge8+32cDAQKwcClj3Aeo+LN0fuwMHDiTW4beze/fuWNlfM6HAcR/+79fpz93Qevy++JByH+Ie+o4/Dv6cun37dmIdFn4eCvDH1pTtlNpF0PlW0lFfpaGJGfWNTutEZ33uBZB3jJQCAAAAAKBAZucXdPdepoOWkVJbS1fjUq4UimNNXevvete71NnZKUk6deqUJOnKlSvZz48cOSJJ2r9/v6SlJ2X2WttLly5JWnpVsL12Nfra2xdffFHSUu+/PTn0r9O9du2apPjTJnua95a3vEXS0lMVe4L30ksvSZLGxsYkxZ862NMUe9pgT1vsydTly5clLb0G1p6SHDt2LLsOewJlTybtdbfnzp2TtPTqWtunvr6+7LJvetObgt+xJ1T2Kmjbx66uruyy9gTGPrOnXFYPexpjr9O1/Y8+dbOnWPaEqL+/X9LSsbJ1WztFX01rf7cnRdY2x48fl7R0nO34R18NbG1gT/OsrtZ2dnytftb+0Vdj23atjnaO2p++ftGnT3bu2f5evXpV0tIxsz+t7m+88UZ22QcffFCSdPDgwdh6rV3t/Lc2tba8efNmdh3+vLb9tyeG9hTUn3fS0vG189ueKr71rW+N1cfO0ehTSHsSbue17Ys9mbbt2ZN4a6foNfP666/H9suO8+HDhyUttb/93O4L0tI5aG1z8eJFffGLXxQAAACw04xF8orIlNpalt7AlxzFis3BSCkAAAAAAApkZLFTqq6qTKUlK0/xxebqbMhM02akVPGsaaTU1NRUdrSFzbGOzme3+dD2p+UD2AiO6IgoSZqYmJAUn89t37FRHjY/3kbG2Dx9G8ERHf1ho11stImNJLFRNrasjSSK5hVYXa0uNkLJRowY21+rZ3Sklq3X183aw5a19oiu25b1dbN1WaZBqO5WV/uujbKyUV+2b37UUTTzwI6Ffdfqatux79p+R+fY29+tHrZ+n3Vg+xvKFrBl7U/brm3P2sz2KZqlYd+xEUq2HfuutYedS9HMBauLtavV2fbX2j2U9WDnip1v1r7WHjYKyvbJ6hNtF9tPW7/V3WcYhPIC/Hnl/7RlQnW3n/l2tuNvn/ssiWjd/fG1Y+RHTvl8iuh2/D1hI06cOJE91qHsBZ+/4vNb/DKhrBWfz/HYY4/FyjYCzLz22muJdTz66KOxsm/j6OjT5fi8Fp8b4+shJfM4/Hlhx82E8mp8Toqvx4kTJxLL7Nu3L1b27e7r6vNspPjoQimZAWIjTE13d3diHTaCz9j5uVw9pKURuebs2bOxsj8fQlk70VGdUnx0rSR1dHQklvFspKa5cOFCrGwjl6P8fdbfQ3wmio2ajPLHyp8zPgMolD3jc4F8G4XuD/7+5+81fh2h+4hfh40UNv7cDdXDzolQpsx6VFRUZK8rn1sjJe85/pr0+x3KJfJ19edfruwfKXlc/fUWykvyeUf+uPtcJl+Wlv4dslxdb9y4ESv7vCAp+W82Xw79LvXnea5Xgvt1hpbx15+/NkLXSq5sp1Cb+Xb214K/zv33peS9frl/uy33eehn0dH0Uvga8ueM3z9/fof+7ehHm/vr3P9u9NlnUrJN/HkVnZlgbDS/8deu/53kr2Up+TvHRpcbf66GfifbOvx+YmuyN+817mKU1FbTsfgGvr4xrqViYaQUAAAAAAAFMjqVeXjbWE3I+VbT2UCmVLGtaaTU9773vRXfKPLqq6/G/twIy/JZj8997nOxP9fDP21Z7vPo9ywPazmhN6eYZ555ZvWVw5Zgoyj8aArz7LPP5lzH+fPn17TNW7du5fzO1772tTWtU4pnZa2XPQm0P8+cObPqZXM9mQYAAAC2K3vzXgN5UlvOUqYUnVLFwkgpAAAAAAAKxKbvNTB9b8uxTqm79+Y0Pj2b49sohDWNlAKArerMmTPBXJj1iubVLed73/veip+HMiB8LtF6rGcd0bde5ou9gdHwBsWdJZSDslOEsmWW4zOW1qu6ujqbX9Te3p743Gfb+JwanykVukf5rCKfw+P3JZSPZG8SNn4kayjLyuff+Lr7rKNQDpgfCeyzfPwyPutKSmZo+bwoyz6M8vvjs53856FcJp+H5Y/DajJ/fDv7HKZQppKfvbBc1qMJ5d75uvscKr+N0IyJXMcmdKz8z/zvS39uhs4Zn0Hoc5lC57fnZzH449/b25tYxmcl+tkV/hwJXas+Q8tvx+dyhfJB/fmNrS2bKcVIqS1nV0WZGqrLNTo1q77RadVVcYw2GyOlAAAAAAAoEJu+R9D51mS5Uj1M4SsKOqUAAAAAACgQMqW2tqVcqeRoYBQenVIAAAAAABTIyCRv39vKeANfcdEpBQAAAABAgYxMEXS+lXXUZ3LeeANfcRB0DgAAUGDDw8PZMOeOjo7E5z4M2Qcb+xc5+CBkKflCg9ra2ljZB2H7QG4pGYbut9Pf359Yxodj+/BoX/bfl6STJ0/GygMDA7Fyd3d3rBwKoB4cHIyVfaB8KKTc823iyz7EXUqGdPtj6Y936CUYPsjbH6vQizx8kLcv+yDsUMD//v37c24nKhT87+saCuX22traYmUfll9XV7fiNiSpqakpVvZt6EPqfbi4lAx/9+vYu3dvYhl/Pvu6+hD3UCC53x9/nfkXTYSuGTufV3Neo/ju3M2MlNq9i5FSWxEjpYqLkVIAAAAAABTA3PyCekYynaR7dyc7R1F8S5lSdEoVw5pGSp08eTL7il57FXj0CZI9bbEnQva0xZ4o2BMaexpir6qNvgb49u3bkpaebtmrie1p34ULFyQtPZWIPlmxpxstLS2Slp5+2JOS5557TpL06KOPxuonSYcPH5YkNTc3S5KuXLkiaelVubY9W6e9qjf6yl57ymH78PLLL8eWsfaxcvRpkz1Fsfa0ulk72KuAbX+j+21PfqyN/BMqq6O1gz1JGxsby37nxo0bkpae7tkTGauHHXc7ttGnfrt3747tl9XHXplr67InmNeuXUts154IWZtYPeznIyMjkpaeLEVfWW3bt/2y/bW6W32sjaNPwewctGXtVce2DqufPfWKPv2yc8bqZMvYE1Bbt/1p+2/rlJbOmUceeUTS0vlmT71sWdtu9LjbK6btabKt316JbX/adRd9cmvr3bNnjyTp0KFDkpba39rUylYvOw7Rutiftj3bJ9uetU/0aayd5xcvXpQknTt3Tk8//bQAAACAnaR3dFpzC2lVlJWooz45cg7FtzRSiqDzYmCkFAAAAAAABXDtTmaAxr7d1SopSRW5NgixkVJj03OauDdX5Nrcf9Y0Uqqqqio7GsfP/ZaWRvPY6Ar7ro36sNEe9j0buRKdi22jPmx0lY2UsZEsfh53dC64rcdGedj2o6M7ouuKjpixUSd+/rmNtrGf+zne0XncVhc/T9y2Zz+39omOVLI6WlaBjTaxZW20j30enRfvR6jYSCk/csjazsrRevoRWrZftg6rsy3rcwuibL32Hf+njUaK/sza10bw2PGwc8XYMYuOMrO6LtdGVg5lZ/hzwcqWy2Hb9yOqovth27f99ueMH/UVHW1ldbL9te3Yuq0cHZFnbHu+jnacfdZA9Dqz8822a9uz79gyNkLKvmd/RvfT2sS+a+uy7/qRkdG6m9D9ZK2OHz+eHaUWyhqxUWHG54JEr8dQWYqPcrNtRkXPbSmZ7yJJR48ejZV9xofPIpGW7mnG34dsdKaxkXcr1e3y5cuxss+zCGVU+FwUn6Phs0kk6eDBg4mfRfn97+npSXwnet5JS+ea8bk5x44dS6zDRnuaXBk4UmYEX5Q//v4c8VkkUrJdfS6OP7ahPJe+vr5Y2UYqm5s3byaW8W3iz/c7d+7Eyn5fJemBBx6IlX0b+es4tP/+2EVHuUrh3yX+/LbRzyZ6LwltQ0r+Lvft7M/v0D3I6hG6/65HfX199t89/lySkvlHuc77UNtdv349VvbXgl+nP0+k5Lnir9FQto0/N/yIbX8d+H2RwllFUf7eGMrU8sfVn5P+3xRS8lzJtV2fFyQls4p8O/tlQvXw/0bxOUSh7fp29teGb4/Q8fb7v9K/c0PbDP3Mt3vovub3x2/H3199fpSUbCO/HV8O3aP89e3P91Dd/b3Pn89+nfbv9Ch/vvtryG83dM2E/n2FrenaUOb4dTftyvFNFEtdVbnqKss0fm9OfWPTOtyavF+icBgpBQAAAABAAVwfynQ67m9OvigBWwe5UsWzpuEJL774ol566aVlPw89+Vsve4LiRwAY/5Q36oUXXlhx3aF9+O53v7uG2q1PNDsL29+Xv/zlDa/DsstefPHFDa9rPeyp+muvvVaU7ZvQW3UAAACA7e764vQ9RkptbR0NVbrQf5c38BUBI6UAAAAAACgAy5Ta30yn1FaWDTsfIex8s208yAUAtoBz584Fsx+Mz5ZbD595YW8PXIuVRnkuJ5SztJL1jLwL5V9569lfbF+vvvpq3tcZynvLJR+jsNd6DUXlyjparfn5+Wymjc/WkpIjRkO5Q1GhjBmfnZar7qvJy7KsPhPKYPI5VP6Y+Uy/UGZdNCNUSraHz2kKZVv5zCR/XwvtbyiTLMofh1B+jz8WPqPM56Kt9LvK+GMXajO/HZ+z5bPiOjs7E+vwOUu+3VeTV+R/v/qMLZ+LJy3/pujl6uqzrqRkm/jj4NcRug/4dvbLhGZs+PwvX/b5i6Hf+/4c8BmNXujcXSnfFVtHOp2OTN+jU2or62jI3Lt6xxgptdkYKQUAAAAAQJ4NT87q7uLb3PbuplNqK+skU6po6JQCAAAAACDPrt3JjODrqK9SVXlyxCO2Dgs6J1Nq89EpBQAAAABAntnUvW6m7m15SyOlyJTabGRKAQAAFFhpaWk2A2dycjLxuc8H8llO/vNUKpVYh89Z8lk+zc3NOevpc2p8xlBVVVViGZ/V4/NxfG5RqO6+TXzmjt//UMaQz1Ty67A3O0f5/fH77zOVQjldPlPLZyyFjrfn29lnLoXkyrvyGVuhbEWff+TbyOc2+eMQ2q7PPwqdM/5nPv/LZ5eFMrV8lpPPJRsYGMhZD3+8/Xnl1yFJJ0+eXHEdPttqNblc/npfTc6jrXc12XAonmzIOW/e2/I66zOZUsOTs5qenWdk2yZipBQAAAAAAHmWHSlFp9SWV19dpurFjihypTbXmkZKNTU1Zd/sYk9Krly5kv3cnsjYWzceeughSdLevXslLb3J57XXXpMkHTt2TFL8KY09GbKnasPDw5KWnv7ZG0zsiUl/f392WXvbi9XpxIkTkqTdu3fH1ml1jz6Fsqca9qTKvltfXx8r2/ds3dGncPY0xbZv+2eszrbO6NtY7OmOveXjjTfekLTUdvbEKPS2HXvyaU+Mbt68KUn61re+JWnpqZ69UeTo0aOSpAMHDmTXYfs9ODgoSbpw4YIk6cknn4ytw+oZfVJoTybtyZG1jb1tx+p+/fp1SdLY2Fh2WXvrjX1nfHw81g5WD3saZOfUrVu3suuwdrcnYFZHO872JNGOYfRpm50D9mTMniLaU1w7vraP/ilctG72NiWru7WRbd+OpZ2P0tITSXsjld++rdvaKXT89+/fL2npurO3vNi1Y9uP1t2uJ/vOSy+9FNsHO3ebmpokLbVP9MmlnW+2n9b+1qZWZ9uH6BNde6pnf05MTOjs2bOJfQMAAAC2q+t3mL63XaRSKXU2VOny4IR6R6d1oKUm90LIC0ZKAQAAAACQZ9eGMg+U9zfTwbEdWNh53xi5UpuJTikAAAAAAPJoenZet8cyswLIlNoe9jRmZp5cGcydBYj8WXfQuU3FiU7JsSlHNo3Hpkn5AD6b3mNTgWzqkrQ05cqmIlnZpgZamKBNY7LpR9LS1C+bimb1sGlbNjXK1hkNPLS/23ZsSphNQfJT7ux7odBIq7vVw+rlp5dFgz6trWy6mP3ppxra1C+rT7Qutj47JvZzm15lU7NsH6LTuexYWPvauuw7FtJp9YmGS1pdbL/9Plj7W4ijfc+3QbSu9l1bh9XL/oxOH7Tv2JQ0m2rn29C2FZ22aeuzOtln9l07LvZndLt+fXa8rf0t+NSOu20jOgXOprbZ+m2/rWztbH9Gj5ntn23H6mb1sf227UWnTVpdbHv+mrB12vfsGo6GeUaPo7R0vlndo9dm9HNpqa1sWuBqQkBzaW9vT0wpjPIBuLmCaaPtZaJTL6Vk4KsPsw0Fs4aCVqN8uKuUDHP1dff7ZvecKLuXLVfX6D1FCgci++mjvh52j4myKaDGBw/7MFcfGCstTUk2/r5hU1jN4cOHE+vo7u6OlX0gdCgAOTo9PVS+du3aiusM1dW3q2/DUAC0Tas2NkV4uc+lZDv7oGk/FdkHJkvJ4+2Pjb8HhNbhr0V/boauh1x19dehD/OWkteMD4327e5DpqWlqdD5ChGemppKRARE+e3488nfb0LtHbpvRV29enXFbUjJa9Yv09bWlljG/8yfk/488OeOlDxn/TJ+nY8//nhiHf5c8NsJTYH3oey+Xf29M3SN+t93/pz1xy70O8rz52zoeOcKx/fLrHSem3379sXKft9C++/P3ei/66XksQ3Vzd8b/bEKBdv7/fH3eS90n8/1+zO0Tl83f575NvLXUGi9/t8L/nfySvf50P0EW8ONxTypuqoyNe5KXgfYeh7Z26C/fvGmXrkxUuyq3FcYKQUAAAAAQB7Zm/e6m3YFO3Sx9bxpX+bB16s3RrSwkOzIR2GsaaTU0NBQ4olJlD15txDq06dPr7i+0CijfPrGN75R0PVvN/bk6rnnnlv1MhaAjZ1luWvz0qVLsT83S+jpLQAAALBdXVscKbWfkPNt44HOOlWWlWh0alZX7kzocGtt7oWwYYyUAgAAAAAgj2z6XncTIefbRXlpiR7ek5nW+8r1keJW5j6y7kwpANhKbt++HcytMD43Yz1CmRYovrWM/gTWajX5P6tRU1OTyLqMslHm0e9H+cyZ0P3Oj0D3+Vs+a8tnEEnJfCCffRPKAfM5PNEMQSmZfeTrISX332c9tbe3x8o+ay60HZ/R5/OypOR9PVfuXSgD0ecS+e360cCh/D2fIeVzi1Yz9cfnX/k2DNXdL+NnRPhzJJT7588Zyy41vg2lZL6TP2f8deePrZQ7G8/nMoXW4TP6fM6a34aUPL4+o9FfD08++WRiHf5Y+Lr7z/02pOR5h63n2h178x4jpbaTx7ob9cK1Yb18Y1gfffPeYlfnvsBIKQAAAAAA8uja0FKmFLYPy5Ui7Hzz0CkFAAAAAECezC+kdXMoM6qOTqnt5bHuRknSmd5xTc3wdsvNQKcUAAAAAAB5cntsWjPzCyovTamrsbrY1cEadDZUqa2uUvMLaZ3qIbpjM5ApBQAAUGBTU1PZbKFQTs3evfHcCp+75LOPfMaUlMyY8TlFPrfGZ+NIUnV1/D9PPi9obGws5zKez8fymTuSdOjQoVjZZxf57KNQppbPPxocHFzx89B6/L74PKhQ3X07++win8O1miwvn7EUyhQK5TtF+br74y8lzyPfZj7LK/S2XJ/L5POQQhli/hrwmVm+rqHz3ec/+TwsX/ZZV5LU0dERK/t2HxgYSCyTq93b2tpi5fPnz+f8jj/+/jzs6upadnuhtkHxXbuTuWb37t6l0pLcmXDYOlKplB7rbtSXTt/Wy9eH9cSBZB4h8ouRUgAAAAAA5Mn1oUzI+T6m7m1L5EptrjWNlHrrW9+qEydOSJL6+vokSWfOnEl8z54y2Btb7G0w9qTEnpgdPXpUUvwNHPZde1OWrd+eINoTDXtiFH2yYk9dLly4IGnpiYjV2T6/ePGipPibXuzJlz2psydy9vMrV65IWnpjykMPPSQp/mTju9/9bmz/Ojs7JSXf/mH7GH1CaW8Z2bNnjyTpgQcekCR99atflbTUdj09PZLiT4fsCZU9mbLtf/jDH5YknTp1KrZ9Wzb6pM6e6tlT1jfeeCP2XfvT3hgUfSpon9lTHdsX/5TL2ir0hMm+a59ZPew4WF3tCV30TS62f/Y0q7m5ObY9+7ltY9++fdll7cmTPbGyt/m8/PLLkpaebr7zne+M7askXb16NbYda3drGztWR44ckbR0nkfb3fbTnkzaedbb2ytp6QmufxoYXdba+/Dhw5KW2si2Y8c2+rYn+8y2a3/ad+wNRXY87Clc9GnoY489FqvPq6++Kmnp/LZ1WBtGj/v+/fslLR3HiYkJPfvss4l9BAAAALYbGym1n06pbclypV6+PlLUetwvGCkFAAAAAECeXF98897+ZjqltqOH9zSoJCX1jk6rb3Q69wLYkDWNlBofH8+OqLBRH9G55TZiw8973707M/zNRr1MTEzEytG50PZ3W6+NbrF12ggPGw1j25SSI3BsJJIta6NObNRRNHvBvmujjWxd9qeNILH9tu9F58lb3W30lm3PZwlYObqs7aftn+2XrcuWsVE40RFitox9Zuu1dVh7GxvRE814sNE0PhfBjoP93O9jdD9thJy11XKZAtERO37/7TMbdWWjkOzntq3oXHtfd/uOH+Xj1xGtk7Wvz3mwZe3z6LG0Za0tbP9t/TaqyPbNnxfRdfj2Ndb+oVFm9ndbh33X9tOW8TkN0c9sJKBlldg6bV/86K8ouxbsOrbt1tXVSVpqK78P0lLOg52boZyLtTp58mR2m/39/YnPfQ7KwYMHY2V/nYTyG2wUmImO2JOWRn+aUD38/dFGjRmfzSEl80mio0tDZZ/NIi2NPjU2ktP488Tft6Tk/vucEF/P0Hd8xofPzfCZOFL8Pi8lc3B8TojP6pCkJ554Ilb2uSGhdvfH78aNG7Gyb49QPo//md+uzwmy6yfKZ9j4bB0blRjlz3ef3+I/Dx07f07Y6E/jz5HQvcbz95JQFpFfjz82vo1C7e7b2W/HRnsv9/0on/WyXrt3787Ww0baRvlz39+TfHv737FSMu/Hnyv+OIeyfjy/Hfs3XZS/r/nfpf48D63DZ/f4EcL+GIXON/+7xK/D30tCdfPXk2/TUB6UX6//jj+H/L1DSt63/HkdukZ9u/tzxO9b6Hetvzf47Vy+fDlWDl2zuTLFQjlU/ven5/cldK76n/l/X/pz118PUvK88r9PQ6P7fQ6Vb2e/v37GhJS83v3x9tsNHTv/b0hsLVfvZO7hvHlve6qpLNPxjnqd6R3TKzeG9SMNnbkXwrpxFwMAAAAAIA8WFtK61J/plDrctvxDD2xtb9rXKIkpfJuBTikAAAAAAPKgd2xaU7PzKi9NMVJqG8vmShF2XnBrmr53+vTpbAD2alho83K+/vWvr3pdPvh8LV566aVVfzf02tYoG07/hS98Iee6rl+/vurtrpWfihNlQ4//7M/+LPj5etpwOwkNi4+6dOlS8O8h1paf+cxn1l0fC95fDxt6Hpqm4UWD+zfKgtZXkqvtVuKvs9DQfgAAAGC7udif+f/D/uYalZcyBmS7emxxpNTrN0c1N7+gMo5lwdCyAAAAAADkwaXFTqkjrUzd284Ot9aqrrJMU7PzOnd7PPcCWLc1jZQCgK3q9OnTsRD51Xx/JaEg4lx8ePJq+PDsfHjxxRdzfmc9+7ed/cEf/EGxq4A8Wc91thGhcOxC8EHfPnDbh2eHwo1DYdhRflRqKFjfh0X7cOhQ8Luvuw+C9iHNPrxfSoZB+xd/2It2jA/olpT4HeADuEOh1T5w2gddr2Yd/tj4EG8f7O5D7KXkiOjoy2ikZJi2lDxWfr2+DUMh7f54+mV8PUIvq/HnlX+Rgj8fpOS56o+dX4e94CjKj+r257Pfl9C17PfHv1gh9CIJfyz8SHW/TOg686P6Q8cmKvTyEf/CGWwdFwcWO6XIk9rWSkpSenRfo569OKjXbo7qZFfyZTzID0ZKAQAAAACQBzZ973BbTY5vYquzjsUrg8mHCcgfOqUAAAAAAMiDyzZSqjU5Sg7by6HWTMcinVKFRacUAAAAAAAbNDI5o8G7mem41qGB7etgC51Sm4FMKQAAgAIbHx/PZtqE8u/2798fK/tsG59l5LN+pGQ+jt+OzzoKZVDlyjYKZTkdPXo0VvZ5OT5jJ5SP4/P1GhsbV6xHKNvI78/NmzdX/FySOjs7Y2Wff+W3Mzk5mViHz2Vqa2uLlX22UWj/fd6RL6dSqZzL+Lr7rKHQm5tztWtFRcWKn0vJLKv29vZYOdRmfplQVldU6M3Kfv/7+/tjZZ9D5fdFSu5PV1fXip9LyXb055BfZmpqKrEOf074jDh/ToWOvx3vUB1RPDZ1r6uhSjWV/Fd7u7NOqWt3JjS/kFZpSfJaxMYxUgoAAAAAgA26NGB5UoSc7wRdDdWqKCvR7Hxat4aTHczIDzqlAAAAAADYoGzIeSudUjtBSUlKB5szo6UuD97N8W2sF51SAAAAAABskHVKHWGk1I5BrlThMdEVwI7wAz/wA6qurpYkvfrqq4nPd+/eHSv7vIba2vg/HnwWh5TMr/DL+DwPq0+Uz5ZoaWmJlU+fPp1YxueT+EwXnzURyqt54403YmWfaeJzNHz7SFJra2usPDAwECuHci18xscDDzwQK/uMj1CuiM888fvn99/niEjSvn37YmV/PgwPDyeW6evri5V7enpWrGuozXz2SGVlZazss1Z8zoiU3P/BwcFY2ef1SJn8oii/f/6c8llDoe36uvnsodD57s8RfxxC2/XHxucA+Swaf1xC6xgbG4uVfZv5a1ta2t/QcV2P6urqbBuFrhWfqZQr28afB1Ly3nD3bvypbn19fazsz5PQOvy9IpRLVFcXf8OUv8/5a9SfO6Ht+P31xz2UqeX3198rQteKb3ffRv7cCOVB+Twgv7/+/Avlcvlrwa8zdKxyZQn5/fc5XVLyWPl7lL/+QvlIvk38/cbvixQ+FlFXrlxZcRtSsp19OZRD5eW6ZkK/TxsaGmLldDq9Yl3970EpeSz8Ovw15eslLV1HoesJxXNpIHOvolNq5zjIG/gKjpFSAAAAAABswPTsvG4MZx42MX1v52CkVOHRKQUAAAAAwAZcHphQOi01VJerpTb5tkdsT4cWO6UuD9ApVSh0SgEAAAAAsAHZN++11iSmk2L7spFSPaNTmp5dedo01odOKQAAAAAANoCQ852pqaZC9VVlSqela3cmcy+ANSPoHMCO8PTTTwcDSc3t27c3sTb5FQrh3igfmusDqUPOnj274e0+//zzG14HNq63t3dHbzcUAh61lvtBKAR9Pe7evZt9GYIPNZaSAds+YNq/fMF/LiWD8334vL/ufZhyiA+2DoV0+3uU/44Pug4F3Hd0dMTKPhzc399D+58rHNy3j5QMnM710ovQsfM/89vxL3QIyRUoHnr5ht8/Xw8fhB4KS/f86I7R0dFY2bdPaDv+pR+hkHLfRj6s27+wIhSw7l++4I+/D233L0CQkueivw5Dv3/9/vmXEviXAYRevuFfoOBfnOHrFQqp37t3r6Rw26A4Lg7QKbUTpVIpHWyt1as3RnRl8K6Od+T+3Ym1YaQUAAAAAAAbcKnfpu/RKbXTZHOlCDsvCDqlAAAAAABYp/mFdLbDgpFSO0/2DXyEnRcEnVIAAAAAAKzTzeFJzcwtqKKsRHt3J6c5Y3s7YJ1SjJQqCDKlAAAACqyioiKbLeTzZKRkTo3P8vFZP6E8KJ/d43OIfMZOKGOpqakpVvb5OKE3Svn1+Iydnp6eWLm7uzuxjpGRkVjZZ0r5zKlQxpLP0PI5VKHsHb9en+XjM8V8+0jJY5crh8x/X0pmF+XKtpKSmUq+Df3+h84Zv967d+/Gyn5/Q23oz+fW1tYV1xmqS39/f6yc61hKyXb257fP0PLXlJTMP/PHP3S++9wpf434bK9bt24l1nHw4MEV69rS0hIrr5RLxlvetgZ7896hlhqVlnBMdppDdEoVFCOlAAAAAABYJ3vz3mGm7u1INlLqzsSMRqfy8wIULKFTCgAAAACAdbpIyPmOVltZpra6zGjMq4yWyjs6pQAAAAAAWCfrlCLkfOc6yBS+giFTCgAAoMDu3bu3YvaLz2Vqb2+PlQcHB2Plvr6+xDqOHTsWK/v8n7Ky+D/7QhlD165di5Wbm5tjZZ+fI0l79uyJlXt7e1dcRyjbZ2ZmZsW6+X2Zn59PrCNXplYoQ8vnHfmcJp9l5OspJdu1pCT+zNdnDIXyofwyfp1+HZI0MDCw4jpC+U/ewsLCip/7eoSyjXy7++Pr1yElM7R8zpY/Lj5jS0oeG78dn9MUOmdyZbf5fCwp2WZ+uxMT8f+w+vwoKdmOjY2NsbI/dv76j243dD5hc6XTaV1Y7JQ61k6n1E51qLVGz18Zyr5lEfnDSCkAAAAAANahf/yexqfnVJJaGk2DnYeRUoVDpxQAAAAAAOtw4XZmlNSB5hpVlpXm+Da2q4MtmVFwVwaTbxTFxtApBQAAAADAOlzoz0wVJU9qZ8uOlBqYCE6pxvqRKQUAAFBgZWVl2QyY3bt3Jz6vr6+PlX1eUGVl5Yrfl5K5Mz5Tx+dUhfKRfIaOz/ZpampKLOOzjHxdfX5QKNvH183n8vhlQvvv/5NQXV0dKzc0NCSW8XlAPqfIt2Eo28jn//j28BlEfp1SMsvIt2EoU8jnEvk28rlcvl6SNDQ0FCv7fKjZ2firz332k5Q8R3ybhrK8fDv6LC//ua+HlMlpi7p69Wqs3NLSsuI6JWnXrl2xss+YCmW3+TY7cOBArOzP5VC2V64sM3/O+Myp6HdCxxWby/KkjpIntaN1N+1SSUqamJnXwPg9tdVX5V4Iq8JdDAAAAACAdbi4OH3vaFvy5RHYOSrKSrSvKdORfWmAXKl8olMKAAAAAIA1SqfTOs/0vftG92Kn1M3h5AhQrB+dUgAAAAAArNGdiRmNTM4qlZIOt9IptdN1NmSm7PWNThe5JjsLnVIAAAAAAKyRvXlv3+5dqq7gzXs7XUdDJquwd4xOqXwi6BwAAKDAZmZmsoHEPkxZSoYV++Dj6enc/wDu6emJlbu7u2NlH57sy5I0NjYWK/tQdh/IHeLrWlNTEyv7gG4p2SY+2LqrqytW7u3tTazD19WvI/S2JN/Ong8PDx07H5adaxuhevjga39sQuHwIyMjsbJvZx+OvpqAfV8Pfyx9ALuUDFT39QoFcff398fK/vj6Y+dDzaVkKP3x48dX3EaoHjdu3IiV/fntg/+l3OH4Pgw+FJbu292H3/vjHbpmbLuhcwOb5+Li1L2jTN27L3QtjpTqHUm+wADrx0gpAAAAAADWyN68d4Q3790XOqxTiul7eUWnFAAAAAAAa3SBN+/dVzoXp+/1MX0vr+iUAgAAAABgjWykFNP37g+djZmRUiOTs5qaYepsvpApBQAAUGALCwvZnKBQBozPsvH5QL4cykLyGVI+l8eXfa6NlMz28Vk3ExMTiWV8VpGvq9/f0P5XV1evWNeZmZlY2ecYSckso1AekOezqZqbm2Nlv7+hPCifKeWzvXw7+32VkjlFfv+HhoYSy/iMJJ9l5OsVOmdu3boVKzc0NKy4TChTzNfN52H5c0qSmpqaYuWpqXg+i89pCmVK+WPjt+PPM5+xJSWPhd//UA6Vz9XybTIwMBArt7W1Jdbhj6+vh7/uamuTHR6ryXdDYQ1PzGjwbubcPEyn1H2hrrJMNRWlmpiZV+/olA7xxsW8YKQUAAAAAABrcHEgM0pqT2O1aisZ63E/SKVS2VypPnKl8oZOKQAAAAAA1sDypI4wSuq+0tWYGdlI2Hn+0CkFAAAAAMAaXOjPTLMkT+r+0lFvb+CbyvFNrBbjDAEAAAqsrKwsmxsUyoK5evVqrNzS0hIr+2wfn30jJXNnJicnY+U33ngjVn744YcT6/A5PLmyb6RkltH0dPzpsa/X2NhYYh25sn18m60m28nn8oTa3ecfjY6OxsqNjY2xst83KZlt5JfxeVF+G1Iy/8rnY4XqXlFRESv74+CPXSgPzGc3+e+Ecsc8v78+/2t4eDjnOnwb+Xr5HCdJqqqqipX9+e7zoHz2Weg7/jrzbRjarq+bX2col8pfZ/74+s9Dx86+EzonsTkuWsh5O51S95POBuuU4trLF0ZKAQAAAACwBkvT95IvXsDO1bk4fY9MqfyhUwoAAAAAgFUam55V31imU4JMqfuLBZ330CmVN3RKAQAAAACwSjZ1r72+Ug3V5Tm+jZ2kM/v2PTKl8oVMKQAAgAKrrKzMZs/47CNJOnToUKw8MDAQK/tlQrlEPv/HZw499NBDsbLPLZKkPXv2xMo+u2lqKvmPcL+e5ubmWNln6rS1tSXWce/evVh5aGgoVvZ5QD5zR0rmAfmMpbt37yaWaW9vX3G9vl6h7Xq51hE6dj6nyOcE1dTUJJa5cOFCrNzV1RUr+/0P5YH5c8TnMt26dStW9u0Vqqs/Z0Lnu28jv4zPpfJlKVl3z+dBhXLIfBv57KZQHpRvZ58H5zO2fD6WlLyO/PXvlwldq/adUB1ReBcXp+4dZerefaezPnMvHZ6c1fTsvKrKS3MsgVy4iwEAAAAAsErnb2depMDUvftPfXWZdlVkOqIIO88POqUAAAAAAFiFdDqtp8/2S5Ie3pN8Eyp2tlQqlc2V6mUKX17QKQUAAAAAwCq8dH1YlwcnVF1eqvc91FHs6qAIlnKlGCmVD3RKAQAAAACwCn/9wk1J0gce7lRtJRHN96POhkyuFNP38oOrCAAAoMAGBwezQeehsGgfwuxDy30gc0dH8um8D/IuK4v/M298fDxWDgUk+2BrH0jtQ5yl3OHofl9CgeN37tyJlevq4uHBPhi6tjaZ4+IDt8fGxmLlUJv5/fNB301NTSt+X0q2s+fbI3T8c9UrFDDf0BCfNtTa2horDw4Oxsp+30J8XTs7O3Ouwweo+4DxVCqVWMaHv/sg9/7+/px19dtpaWmJlf25HArY9+eir2soTL2vry9W9sH+PpQ8tP/e9evXY2V//vuytLT/PuAfhTU5M6fPvtYrSfqJt+wtcm1QLJ1M38srRkoBAAAAAJDDF0/16e69OXU37dJTB5tyL4AdqYPpe3lFpxQAAAAAADnY1L2PvXnvqkbBYWfqYvpeXtEpBQAAAADACm4MTerbl+8olZI+8vie3Atgx1p6+x6dUvlAphQAAECBtba2qqqqatnPZ2ZmYmWfZeOzfoaGhhLrWFhYiJV9Xo5fp8/CkZJZRj7LKpQp5TN0fMbQxMTEivWUpPLy8ljZ5+Tkyi0K8XUNLeO3Y7lfZnh4OFb2uVVSMjPI5//s2rUrVg5lUPn1+nX6DCYpmcPkc4n88Q7lYfn1+mPjs75CfJaTX8YfOymZfzU6Orri5/4ckpJt5I+VP/6hDDX/M9+moQwtf6z8de3b3V9DUjJnLXRsokJtaMuE9guF8T9ezIySevvhZu3dvSvHt7GTWabU0MSMpmfnVVVOtttGcBcDAAAAAGAZCwvpbKfUT7x5X5Frg2JrqC5X9WJH1O0xRkttFJ1SAAAAAAAs4zuX7+jWyJTqKsv0vpPJN3ni/pJKpbKjpXpG6JTaKDqlAAAAAABYxlfO3JYkffCRTlVXMFULkTfwjU0VuSbbH5lSAAAABTY+Pp7NjQplCvm8I5+H43NrQjkyfh0+p8ln3YTygjo64iMApqbi/9gOZSr5XCKfy7Sa/CefS+RzqnybhbJ+/P75NlpNm/kcLp8H1dnZmVjH4OBgrOwzpXxeks+xCtXNb9cfSylzTkX5PKTV8G3m96W9vT1WDrW7z3uqra1dsSwlzxl/HPznoXXkOq/8uRt6U5pv14sXL8bK3d3diWWamppi5bGxsVh59+7dsXIoD8ufI7nysfw1JS3lUoXODeTfzeHM+XRyT0ORa4KtopM38OUNI6UAAAAAAFhG72imU6qrYfkXVuD+YtP3epm+t2F0SgEAAAAAsIy+xdEwHXRKYZGdC4yU2jg6pQAAAAAACLg3N6/Bu5np112LU7aATjKl8oZOKQAAAAAAAmyUVFV5iRp3keGFjGymFNP3NoygcwAAgAIrKSnJBlyHQpv7+/tjZR9i7cOMQ2HpPhx6fn4+Vvah1r4sSXNzc7GyD1yurk6OEvDh4D6U2dcrFJa+sLAQK/vQbr+O1tbWxDquXr0aK/vQ9lDAuN8/f2z8MqFw7YaGePCxD2lPp9Oxst8XKRls79u5t7c353b9en2b+uBvKXle+XX6dfjAfSl5PP3++32TkuHf/hzy2/HHKfQdv06/3dD57tv14MGDsXLoOvOh5D6k37eHb0Mpeaxu37694jZ8eLokDQ0NBbeH/OtZ7HTobKgOBubj/mQjpe5MzGh6dl5V5byVcb0YKQUAAAAAQIBNz+okTwoRjbvKVVmW6U7pH0s+bMDq0SkFAAAAAEBAdKQUYFKplPY0Zs6JUz2jRa7N9kanFAAAAAAAAb2jmZFSXY2MlELcjzyUmSb+e1+/lJiqjdUjUwoAAKDAysrKsvk0oZya5ubmWNnnMvk8IJ/BIyUzdvx2fMZUKB/I59/4HB6f9SQlc4hu3LgRK3d2duZch6+rr4evuy9LyZwpn8sVWqapqSlW9lk/PpfIZ/9IyXb0/zHx+xvKdqqvr4+Vx8bGVqynlMxQ8vXweVGhc8YrKVn5eXXoP10+Y8cfu5s3byaW8fvT1dUVK/tcKt8+kjQzM7PiOn3WUih7yWc1+WMVyhDzbXTt2rVYubu7O1b252GIzz/zQpladnxD9xPklwVZdzB9D87PveOg/vC5K3r15qievTiodx5N5h0iN0ZKAQAAAAAQ0Lv49r0upu/Baamt1E89kemI/t2nLxa5NtsXnVIAAAAAAATY9L1Opu8h4BfefUjlpSk9f2VIL1wdKnZ1tiU6pQAAAAAAcKZm5jU8mZnG2VnPSCkkdTZU66OP75Uk/e7fMVpqPZiEDAAAUGCTk5PZTCOf9SMlM6R8XpDPz/E5PqH1+vwjnzm0mkwpn1fjM5ekZN19DtPk5GRiGc/vn88Qmpubi5V91pWUbLNdu3bFytXVyf9Q+jYYHByMlXt6enJu1+cQDQwMxMo+yymUyzQ6Gn9zkz92dXV1iWX8sfFln10VyqUqLS1dsa4+PymUOeV/5vOhQueMP55DQ/HRBbkyxkL88ffH258PUrLd/Xno2yekvb09VvbHN3Sd9fX1xco+28rX1beXtJRDF7qfIH9slNSuilLVV/NfZ4T9r+8+rL964YaeOTegU7dG9dCehtwLIYuRUgAAAACATfV7X7+kn/y9b+vuvWSn21bRt5gn1dlQFXwYAEjSgZYafejRTIf8f3mG0VJrRacUAAAAAGBT/cE3L+v5K0N69sJg7i8XSY+FnDcydQ8r+9/fc0SS9IVTfbo1knzLKpZHpxQAAAAAYNOMTM5o8G5muuT52+NFrs3yehc7FzrqCTnHyo531OlkV73SaenUrdHcCyCLibEAAACbKJRL5HOZfNbN+Hj8P2179uxJrGN6ejpW9rk0PuvG5wdJUkdHR6w8MjISK4eybfx6LTvL+Eyh1tbWxDr8Mj5zp6Ehns9x+fLlxDp8DlFtbW2s3Nvbm1jGZ/n4ffF5PaFsI9/unZ2dsbI/lqFsI193n8vkj7+UzBXzeUh+uz6nK7ReXzd/7ELnrs+u8vviz20pmZnlc8h8O/vzI7QOn7vl88FC++/315/vIX7/fHaVb7NQlpfPIfOZWl4oy+vGjRvB7W0XlwaW7j9bulNqbHH6HiOlsApH2mp1umdMF/vv6n0ni12b7YORUgAAAACATXOpfymYfkt3Si2OlOpqYKQUcjvSmnkYcqk/+dAHy6NTCgAAAACwaaIjpS4PTGhmLvcbFouhdzFTqoNOKazCkbZMp9TFATql1oJOKQAAAADAprkYGUkyt5DW1TsTK3y7eHpspBTT97AK1il1qf9uYjo4lkenFAAAAABg09hIqfLSTDbaVpzCN3FvTmPTmRy9TkZKYRX2N9eotCSliZn57Cg75EbQOQAAQIFVVlaqqirznxofQC0lA7Z9ALMPUx4eHk6swwcq+5DuycnJFdcpJQOmm5ubY2UfLi1Js7OzK67DbycUlu7bxAeu+0BuH1Ae2q7fTmh/fUi5D8uemIiP3vDh4lKyXX0YuA+i9t+XwuHnUT7EXEq2uw8L92HaobBw3yb+nPHt7j8PrdcHgY+NjSWW8fvrw9JDx8rz4fd+Oz4cPBQWfunSpVi5u7s7VvbHX5Lu3LkTK/vgfr+d0P77c8K3od0rlvtcWgpu9+fwdjA9O6/rQ5nr4B1HWvR35wZ0vm9ceqTIFXOsU6Guskx1VclzH/Aqykq0v3mXLg9M6GL/XUbYrRIjpQAAAAAAm+LanUktpDOdPd93pEWSdP721svg6R3NdJaSJ4W1sLDzi4SdrxqdUgAAAACATWFT9w611ep4R2Z04lacvtc7khkp1cloF6wBYedrR6cUAAAAAGBT2AiSI621Ot6e6ZS6emdC07PJaYrFZNP3uhgphTXIdkoVYKRUOp3ekQHqZEoBAAAUWEVFRTZrKJRLVFpaGisPDQ3FyrkyZ6RkxpDPLsqV4yNJ169fj5V9to/PKQqtx7JujK97T09PYh179+6NlX12ld9fnx8lJdvV1yOkv78/VvY5Rb5NV8Mv4zOHQjlFPhfIZ2b5nCopmSvms4t8/lNoX3z+kW93fw6Fzjvfzv58CGUq1dbWrrgOfxxC54xfhz83fd19PpaUPDaVlZWJ73g+M8sfG/95X19fYh0+u8z/J9NniIXa3drE51NtBzZS6nBbjVrrKtVQXa7RqVldGrirk10NOZbePEzfw3pE38CXT1cHJ/Sh331WH35sj/71jz2U13UXGyOlAAAAAACbwjqljrTWKpVKZUdLXdhiuVI92ZFSTN/D6h1ezJS6MzGj4YnkSyrW629euqnx6Tn9xXdvaHRq7Q9MtjI6pQAAAAAABbewkNal/sxowcOLI0qOtmf+PLfFcqV6RzIjpTobGSmF1aupLMtO+cxnrtRXzmRG9s7ML+hLp5IjMLczOqUAAAAAAAXXOzatqdl5lZem1N2UmVJsYecXtlinVN/iSKlORkphjQ7nOVfq5vCkzvQuTYX+29eSU5q3MzKlAAAACiyaKRXKtvG5S/v374+Vz549Gyvv27cvsY5bt27Fyj63xufUhHKKjh49GitfuXIlVva5VFIyI8nnPTU3N8fKPgtJSuZB+Swrn6nj84Qk6eLFiyvWNZRD5bOb/HdWk+WVK4fo7t3c/ynxx2Jubi5W9sdOktra2mJln93k921wcDCxDn/s/DJ+f33WmZTMQ/Lt4dcpJffP51D5rC+f0xRar89WynX+h+rq98/nUoW267O6fF39OSQlrwl/bPw6Qu1u14jPBdvq7D/p+5trVF6aqfvRtsyx2kojpcanZzV+L3OedpIphTU60larb14YzFun1NNnM/fE/c27dO3OpJ67OKiB8Xtqrcudg7eSe3Pzqiwrzf3FAttedzEAAAAAwLZk4c+HW5eC6Y8tTt+7MTSlyZm54HKbzd68V19VpppKxnFgbfL9Br6vvJF5CcU/fLJbj+5r1EJa+sKp3g2t8789e0Un/+WX9OlXbuX+coHRKQUAAAAAKLhsyHnb0mjH5tpKtdRmRnxslbDznsU8qa5Gpu5h7Wz0Xz46pcanZ/Wdy3ckSe99sF0feqRTkvSZVzY2he+TL9/U3EJav/qpU9mpqsVCpxQAAAAAoOAuZkdKxafg2mip81tkCp/9J72DqXtYB+t0vTWy8dF/3zg/qNn5tA611Ohwa60+9GiXUinphWvDujUylXsFAaNTszrdk5nyPT49p49/8vXEVOzNxFhEAACAArt79242RyeUy+SzbQYGBmLlxsbGWNnnB0nJXCKfNeO3W15enljHzZs3Y+WDBw/m3K7PA8qVhxPK1PJ1Ky2NZ1ysZh0+h8ov4z8P8W3m61FTUyPPZxn5uvlsI/99KZnL5DOXpqeTT7H9z3xdc2WMSdLo6OiK3/Flvw0pmTvl85FC7e7PGd8m/twM5XKdP38+Vm5qaoqV/TlVX1+fWIdv5/b29lg5lMPl28Tncvm6+m1I0sjISKzs29XnX/l9k5baLHRMtrJLA5n2io6UkqRj7XX61qU7W6ZT6sJi5xkjpbAeTTUVaqqp0NDEjC4PTOihPQ3rXtfXzmSm7v3giUyOYHt9lZ462KTvXB7SZ1/t0S+8+/Ca1/nC1SGl01JLbYXGpub09Nl+ffLlW/rI43vXXc+NYKQUAAAAAKCgRidnNXg305l2KDFSKtPZd34LTN+bX0jrb1/NTI1697HWItcG29WR1o3nSs3NL+jpc5mQ8/eeWOo0/9CjXZKkz7y6vil8z18Zyq7zn74384KTf/WZ0+ofK840PjqlAAAAAAAFdXExT6qjvkq1Ljz8eMfWmb733MVB9Y/fU+Oucn3/8bbcCwABh/MQdv7itWGNTM6qcVe53rx/6c2f73+oU2UlKZ3uGcvmtHl3783pD5+9ouGJ5JtHLaPqqUNN+oV3HdLDexo0Nj2nj3/yVFGm8dEpBQAAAAAoqFDIuTmyGAzdOzqt3/jb0/rT71zTty4OamQy+R/qQvublzLTmH/00S5VlPHfZaxPPt7A97WzmVFSP3C8TWWlS+diU02F3nG0RZKyo/q8P/7WVf3rz76hX/30qdjPx6dndepWZur2UwebVVZaov/wE4+ovDSlr565rWfODYRWV1BcZQAAAACAgrJOqcOtyWy2hury7M//6Lmr+rVPndI//K/P622/+bR+7+uXNDu/sCl1vHtvTl883SdJRcvXwc6Q7ZRaZiTTanz1DcuTak989oGHMm/h+9alO8FlbdThV07fjnXuvnBtWAtpqbtpVzYz7YGOev2DJ7slSV9aPP83E0HnAAAABVZeXp4Nb/aB5FIy2DyVSsXKPgjdh4lLybBoH/TsA5h9ELgkNTTEw1h98HkopN0HOfu6zs7OxspHjx5NrOPUqfiT3EOHDsXKLS0tsfLLL7+cWMeJEydiZd+GoUBo344+PHx+fj5W7u/vT6zDh9D7YG8/FWJhIfmfa99mfrv+uEjJMGx/Xvn9DYXD79mzZ8Xt+mD7UFj48PBwrOzb9Pbt24llfJv5c6S1NZ7j4+spJYPOfRv5QPKrV68m1uHrOjk5uWK9pOT57vfPh+F3d3cn1uHb2dfDt3so6N7aKPTCgq3qUv/yI6Uk6U9//in93bl+XRmY0JXBCZ27Pa6bw1P6zS+c1SdfvqV/++GHY1OYCuELr/dqenZBh1pr9Oje9YdTA3aeXx2c0Oz8gspL1zYe6NLAXV0enFB5aUrvOtaS+Px4R+Yed+3OROIzSbo+lLmfzcwv6NOv9Oh/efsBSdLzlzO/+586GH+Bwg+eaNeffPuanjk3oHQ6nfgdWkh0SgEAAAAACury4pv3fMi56Wqs1k8/tT9bTqfT+usXb+o3P39GZ/vG9bH/91v6+e87qF/54ImC/Yf5b17KvLXyo4/v3dT/lGPn6WqoUl1Vmcan5/Sdy3f0zqNrC823UVJvPdSsuqpk5/P+5sxDottj9zQ1M6/qiviDiOt3ljrZ/+qFG9lOKcuTeuuh5tj3nzrYpMqyEvWNTev87bvZTq/NwPQ9AAAAAEDBzM0vZEduHGxJTt8LSaVS+vtv2aev/bP36GNv3qt0Wvqvz17R518vzPSim8OT+vbif9h//LHk6DxgLVKplH78TZnz6E++fW3Ny39lsVPqhx9MTt2TpMZdFWqoznRW2bVl7t6b053FgHMLRH+jZ0wT9+b0uuVJHYqPlKoqL9XbDmc6qr5+PjkquJBWNVLKhh0XI4kdwM63kXuMLRMaYg8AG2X3lvX+G8iWi06/CT1991Pv/HdWs30/xWdqamrFz/02V/OdkpLk80z/Hb9dP90pNH3NT0Xz9fDL+O+HllnN9D3/M78vueqxmu/4bYSmYvnj66d3hY6/b4NcbRTarj9Wfh1+mdBUMf8dX1d//EPL5DqHQvufaxk/JS50vvu6+f1bTZv59frj7b8vrf0cCbWhrde+u9X/n3ZzeEpzC2lVlZeoo75qTcs21VTot3/iUe1prNbvfO2CfuNvT+udx1pUHxg9shGffiUTGP22Q83a01id49tAbj/ztv360+9c09fO3NatkalVn1d37t7Ti9czU6NDeVLmQPMuvXpzVFfvTMRGNtmUvt27yvX2wy363Ou9+usXb+j7j7dpfiGtPY3V2rs7OR3/3cda9cy5AX39/ID+8bsOr2VXN2RVnVI2B31iIjxfEQDyYXx8PJibkWsZSfr85z9fiCoBgKT13Z9sOUn6rd/6rXxXCQCy1nuP2ixXBjP/jzzQXKOSkvVNi/vf3nNYn3m1R1cGJ/Sfvnxe/+pHT+atful0Wp9YfOveRx5nlBTy42h7nd5+uFnfunRHf/ada/rlH3lgVct97Wy/0mnpoT312TDykP3NNXr15mgiV8qm7nU31+hjb9mrz73eq0+9fEtli9een7pn3n0sM8Xwe1eGNXFvTjWVm5P2tKqtdHV16caNG6qrq2NuLYC8S6fTGh8fV1dX15qX5f4EoJA2cn+SuEcBKKyN3qM2y+XFTqnVTt0LqSov1b/5sYf0P/235/XH376qjzy+R4/sbcx+fm8uM8Kwsiw5KjKXL5zq0+WBCVWVl+j9D3euu46A9zNv269vXbqjv/jeDf2THzyqqvLc56flSb13hVFSUmaklCRdvROfvmfT+fY37dK7jraqvb5St8fu6U+/k5lG6KfumYMtNdrXVK0bQ1P69qU7eu8yUwfzbVWdUiUlJdq7l1diAiic9T7d4/4EoNA2MvqAexSAQtvKI6TM1Tx0SknSO4626Mff1KVPvdKjj3/ydX36F9+hK4MT+sPnrugTL97U7PyCupt26XBrrY601erDj+/RAx3Jt0aaywN39e8+f0ZfPZPJ0PnQI12q3aTRIbg/vPdEuzobqtQ7Oq3Pv96rjzy+8r8Jpmfn9c0Lg5KkH8rRKdTdnLme/Eipa4udUt1Nu1RaktJHH9+r//LMJU3PZqYOv/VgeKRUKpXSu4+16v/7znV9/fzApnVKEXQOAAAAACiYK3nqlJKkX/ngg6qvKtOpW2P64P/zTb33P31df/78dd2bW9BCOjNq5Gtn+/V737isf/rfXwmuY2EhrX/3+TP64f/8DX31TL/KSlL62e87oF/P45RAQJLKSkv00091S5L+eBWB589dHNTU7Lz2NFbrwc7lO1SlpZFS1/xIqez0vcznH3vzUkdYV0OV9jUtPyXwPcfaJEnPnO/ftKw6OqUAAAAAAAWTz06p1rpK/fP3Z7J5zvaNK5XKjCj5y3/8Vn334z+oP/9HT+nX/t6DkqTz/eOanEkGxf/taz36/W9c1txCWt9/vFVf/KV36dc/dJJRUiiIn3qyWxWlJXr1xoheuzmy4ne/kp2615Zz2v/+xZFSPSNT2emrknRtKHO97W/KdEodaq3VW/bvliQ9dah5xfW+7XCzyktTujE0lZgWWCh0SgEAAAAACmJ6dl49o5m3BeajU0qS/sET3frF7z+sf/TOg/q7f/Ye/cHPvEVPHWpWW32V3n64RT//joNqqa1UOi2d6xtPLP/StcybzX76qW790c8+qSNttXmpFxDSUlupDzzcIUn6kxVGSy0spLNTSVczda6ltkI1FaVaSGfecClJs/ML6hnJvJXTOq0k6Z+//wE9uq9RP/d9B1dcZ01lmZ44kMmceuZcf8465AOdUgAAAACAgrh2Z1LptFRfVaammoq8rLOkJKX/630P6Fc++KAOLNPRdaKzTlJmNJV3umdMkvSWA7vzUh8gl595+wFJ0qdevqVPvXwr+J1Xbo5o8O491VWW6allcp+iUqlUtuPJcqVuDU9pfiGtyrIStdVVZr/7xIEmffoXv08P782dQWdv4fv6+YGc380HOqUAAAAAAAVxZfCupMwoqc18C+mJxTyeM71jsZ8vLKSzPzvZtfVD4rEzPLavUR9+bI/mFtL6pb98Rb/79IVEZpO9de/dx1tVUba6rpoDLYtv4BvMTLWzN+/ta9qlkpL1XW/vPp7plPr2pTv6u3P9+sLrvfrEizf1p9++qv6x6XWtcyVMmgUAAAAAFMSVxf8s52vq3mrZSCnfKXX1zoQmZuZVWVaiQ5tcJ9y/UqmU/uNPPKrWukr9/jcu67e/fF43h6f0b378Id2bW1Df6JS+dLpPUu637kV1N8VHStmb9yxPaj2Ot9epo75KfWPT+tk/+l7ss8NttWqrr1r3ukPolAIAAAAAFMTSSKnNzW2ykVJne8eVTqezo7Rs6t4DnfUqK2XiEDZPSUlKH//ACe3bXa1f/8xp/cX3buhvXr6lmbmF7HfKSlJ6z/G2Va8z+wa+xc6o64udU/bmvfVIpVL6P37oqH7/G5dVWVaqmspSVVeUqaaiVA3V5ete73LolAIAAAAAFIS9ec+mGW2WQy21Ki9NafzenG4OT2nf4sgR65Q62VW/qfUBzP/8tgPqbKjWP/mLlzU5k3lrXl1VmTrqq/TRN+9dU8fPUqbUZOzPjYyUkqSffKJbP/lE94bWsVp0SgEAAAAACsI6pQ5t8kipirISHWmr05neMZ3pHct2Sr2xOJ3vwU46pVA8732wXc9//AfVP35PHfVVqqlcX9eMdfbeGJrU3PxCNlMq+ua9rY7xigAAAACAvBubntXg3RlJmz9SSormSmXewJdOp/VGz6gkRkqh+OqqynW4tXbdHVKS1F5XpcqyEs0tpHVrZCoWdL5d0CkFAAAAAMi7q4ujpFrrKlVXlf8smlxOdMTfwNc/fk+Dd2dUkpIe6KBTCttfSUlK3YsdUC9dH9bkzLxSKWlfU3WRa7Z6dEoBAAAAAPLOpu4dLNJUomzYeV+mU+r04iipw621qq4oLUqdgHyzqXrfOD8oSeqsr1Jl2fY5v+mUAgAAAADkXbZTqqVYnVKZ6XvXhiY1cW9Op28Rco6dx97A980LA5I29ua9YqBTCgAAAACwIV881asP/M439frN0ezPsp1SrcXplGqurVRrXaXSaels33jkzXsNRakPUAj7Fzt9Lb9tf9P2CTmX6JQCAAAAAGzQ//3VC3qjd0y//InXNL+QlrTUKXWgiG8Ci07hO91LyDl2ngNuZBQjpQAAAAAA941LA3d1ti/zhrszvWP68+evKZ1O68pAplPqUJFGSklLU/ievzykG0NTkqQH6ZTCDuJHRnVvozfvSXRKAQAAAAA24POv9UqS6hZfbf/bXz6vi/13NX5vTqlUcf+T/ODiSKkvv9EnSdrTWK3GXRVFqw+Qb12NVSorSWXL+xkpBQAAAAC4X3zu9Uyn1Mc/eEInOus1OjWrX/rLVyRJXQ3Vqiov3pvAHujIdEpNzy5IYuoedp6y0hLti3T8kikFAAAAANhRFhbS+qvv3dD49Gzs55cXp+6VlaT0/oc69Bs/elKSsqHixZy6Z9uvKF36by8h59iJbHRUQ3W5GnaVF7k2a0OnFAAAAABgRf/nX7+qX/7Ea/qPXz4f+/nnF0dJvf1Iixp3VejJg036sTd1ZT8/2FLcTqny0hIdba/NlhkphZ3IXiaw3fKkJDqlAAAAAAA5fOTxvZKkP/72Vb10fTj788+9nslq+uDDHdmf/Yv3n9CuisyUvWK+ec/YFD5JOrmHTinsPMfa62J/bid0SgEAAAAAVvSOoy36yON7lE5L/+ITr2t2fkFXBid0pndMpSUp/fCDS51SHQ1V+g8fe1TvONKiDz3atcJaN4e9ga+ppkId9VVFrg2Qfx95fI/+/Ucf0S//yPFiV2XNyopdAQAAAADA1verH3xQz5wb0Lnb4/r9b1zO/vzth5u1uyb+RrsPPtKpDz7SudlVDHrP8Tb9+y+d0/tOdiiVSuVeANhmqspL9fef2FfsaqwLnVIAAAAAgJyaair0L//eg/qlv3xFv/O1C2qvr5QkfeDhrdH5tJwjbbV6+dd+SJVlTBQCthquSgAAAADAqvzYm7r0rmOtmplb0I2hKZWWpPS+kx25FyyymsoylZXy319gq+GqBAAAAACsSiqV0r/98YdUXZ4JMn/boWY1ual7ALBadEoBAAAAAFZtX9Mu/fqHHlR1eal+7h0Hil0dANsYmVIAAAAAgDX5qSe79ZNP7CM4HMCGMFIKAAAAALBmdEgB2Cg6pQAAAAAAALDp6JQCAAAAAADApqNTCgAAAAAAAJuOTikAAAAAAABsOjqlAAAAAAAAsOnolAIAAAAAAMCmo1MKAAAAAAAAm45OKQAAAAAAAGw6OqUAAAAAAACw6eiUAgAAAAAAwKajUwoAAAAAAACbjk4pAAAAAAAAbDo6pQAAAAAAALDpyopdAQAAAADA5kqn05KksbGxItcEwE5k9xa71yyHTikAAAAAuM+Mj49Lkvbt21fkmgDYycbHx9XQ0LDs56l0rm4rAAAAAMCOsrCwoJ6eHtXV1SmVShW7OgB2mHQ6rfHxcXV1damkZPnkKDqlAAAAAAAAsOkIOgcAAAAAAMCmo1MKAAAAAAAAm45OKQAAAAAAAGw6OqUAAAAAAACw6eiUAgAAAAAAwKajUwoAAAAAAACbjk4pAAAAAAAAbLr/H7KYqBtzVm0eAAAAAElFTkSuQmCC", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -242,27 +238,74 @@ "source": [ "# Plot the profiles\n", "\n", - "fig, ax = plt.subplots(1, 4, figsize=(12, 3))\n", + "fig, ax = plt.subplots(2, 4, figsize=(12, 9))\n", "\n", "gam = 0.3\n", "\n", - "rgc_img = rgc_img.squeeze()\n", + "ax[0,0].matshow(rgc_img[rgc_img.shape[0]//2, :, : ], norm=mpl.colors.PowerNorm(gam))\n", + "ax[0,0].axhline(rgc_img.shape[1]//2, color='blue', linewidth=4, alpha=0.5)\n", "\n", - "ax[0].matshow(rgc_img[rgc_img.shape[0]//2, :, : ], norm=mpl.colors.PowerNorm(gam))\n", - "ax[0].axhline(rgc_img.shape[1]//2, color='blue', linewidth=4, alpha=0.5)\n", + "ax[0,1].plot(rgc_img[rgc_img.shape[0]//2, rgc_img.shape[1]//2, : ])\n", "\n", - "ax[1].plot(rgc_img[rgc_img.shape[0]//2, rgc_img.shape[1]//2, : ])\n", + "ax[0,2].matshow(rgc_img[:,:, rgc_img.shape[2]//2], norm=mpl.colors.PowerNorm(gam))\n", + "ax[0,2].axvline(rgc_img.shape[2]//2, color='blue', linewidth=4, alpha=0.5)\n", "\n", - "ax[2].matshow(rgc_img_Z[:,:, rgc_img.shape[2]//2], norm=mpl.colors.PowerNorm(gam))\n", + "ax[0,3].plot(rgc_img[:,rgc_img.shape[1]//2, rgc_img.shape[2]//2])\n", "\n", - "ax[2].axvline(rgc_img.shape[2]//2, color='blue', linewidth=4, alpha=0.5)\n", + "ax[1,0].matshow(rgc_img_Z[:,:, rgc_img_Z.shape[2]//2], norm=mpl.colors.PowerNorm(gam))\n", "\n", - "ax[3].plot(rgc_img[:,rgc_img.shape[1]//2, rgc_img.shape[2]//2])\n", + "ax[1,1].matshow(img_Z[:,:, img_Z.shape[2]//2], norm=mpl.colors.PowerNorm(gam))\n", "\n", - "ax[0].set_title(\"XY subsampled PSF\")\n", - "ax[1].set_title(\"XY intensity at the center\")\n", - "ax[2].set_title(\"XZ subsampled PSF\")\n", - "ax[3].set_title(\"XZ intensity at the center\")" + "ax[1,2].matshow(img_full[:,:, img_full.shape[2]//2], norm=mpl.colors.PowerNorm(gam))\n", + "ax[1,3].plot(img_full[:,img_full.shape[1]//2, img_full.shape[2]//2])\n", + "\n", + "ax[0,0].set_title(\"XY subsampled PSF\")\n", + "\n", + "ax[0,2].set_title(\"eSRRF XZ \\n subsampled PSF \\n (squeezed)\")\n", + "\n", + "ax[1,0].set_title(\"eSRRF XZ subsampled \\n right dimensions PSF\")\n", + "ax[1,1].set_title(\"Raw XZ subsampled \\n right dimensions PSF\")\n", + "ax[1,2].set_title(\"Full Raw XZ subsampled \\n right dimensions PSF\")\n", + "ax[1,3].set_title(\"Full Raw XZ intensity \\n at the center\")\n", + "\n", + "# get the distance between peaks in the first plot\n", + "peaks_indices_XY, _ = find_peaks(rgc_img[rgc_img.shape[0]//2, rgc_img.shape[1]//2, : ], height=0.1*rgc_img[rgc_img.shape[0]//2, :].max())\n", + "print((peaks_indices_XY[1:] - peaks_indices_XY[:-1])*pixel_size/magnification_xy)\n", + "\n", + "# get the distance between peaks in the second plot\n", + "peaks_indices_XZ, _ = find_peaks(rgc_img[:,rgc_img.shape[1]//2, rgc_img.shape[2]//2], height=0.1*rgc_img[:, :].max())\n", + "print((peaks_indices_XZ[1:] - peaks_indices_XZ[:-1]) * pixel_size*separation_planes/magnification_z)\n", + "\n", + "# write the distance between peaks the second and forth plot\n", + "ax[0,1].set_title(\"Full Raw XZ subsampled \\n right dimensions PSF \\n (Peaks distance: {}nm)\".format((peaks_indices_XY[1:] - peaks_indices_XY[:-1]) * pixel_size/magnification_z))\n", + "ax[0,3].set_title(\"Full Raw XZ intensity \\n at the center \\n (Peaks distance: {}nm)\".format((peaks_indices_XZ[1:] - peaks_indices_XZ[:-1]) * pixel_size*separation_planes/magnification_z))\n", + "\n", + "\n", + "# elliminate ticks\n", + "for a in ax:\n", + " for b in a:\n", + " b.set_xticks([])\n", + " b.set_yticks([])\n", + "\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.02 1.02]\n", + "[1.26]\n" + ] + } + ], + "source": [ + "from scipy.signal import find_peaks\n" ] }, { From 9717e256e2e40085488853c982cab2439c8db08c Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Thu, 21 Mar 2024 18:47:59 +0000 Subject: [PATCH 72/81] testing different planes --- tests/test_3D_eSRRF/load_analyse.ipynb | 62 +++++++++++--------------- 1 file changed, 26 insertions(+), 36 deletions(-) diff --git a/tests/test_3D_eSRRF/load_analyse.ipynb b/tests/test_3D_eSRRF/load_analyse.ipynb index 8273b3c7..71e6270b 100644 --- a/tests/test_3D_eSRRF/load_analyse.ipynb +++ b/tests/test_3D_eSRRF/load_analyse.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 104, + "execution_count": 119, "metadata": {}, "outputs": [], "source": [ @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 105, + "execution_count": 120, "metadata": {}, "outputs": [ { @@ -44,14 +44,14 @@ }, { "cell_type": "code", - "execution_count": 106, + "execution_count": 155, "metadata": {}, "outputs": [], "source": [ "# set parameters\n", "\n", - "path = \"/Users/avesga/Code/radialsym/simulations/PLANES_num_planes_9_distance_emitters_1_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", - "path_full = \"/Users/avesga/Code/radialsym/simulations/FULL_distance_emitters_1_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", + "path = \"/Users/avesga/Code/radialsym/simulations/PLANES_num_planes_5_distance_emitters_2_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", + "path_full = \"/Users/avesga/Code/radialsym/simulations/FULL_distance_emitters_2_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", "\n", "pixel_size = 0.120\n", "separation_planes = 3" @@ -59,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 107, + "execution_count": 156, "metadata": {}, "outputs": [], "source": [ @@ -71,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 108, + "execution_count": 157, "metadata": {}, "outputs": [], "source": [ @@ -91,7 +91,7 @@ }, { "cell_type": "code", - "execution_count": 109, + "execution_count": 158, "metadata": {}, "outputs": [ { @@ -101,20 +101,19 @@ "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.004273499999953856 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023622910000540287 seconds\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.004248875000030239 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023549580000690185 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010090499999932945 seconds\n", - "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.3019100674040418, Delay probability: 0.12540459203699675\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.008093041999927664 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.008322249999991982 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.007079040999997233 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.008463457999823731 seconds\n", - "Agent: eSRRF_3D using Threaded ran in 1.3909242500001255 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.008440832999895065 seconds\n", + "Agent: eSRRF_3D using Threaded ran in 0.8405347500001881 seconds\n", "Only one frame, no temporal correlations can be calculated\n" ] } @@ -130,7 +129,7 @@ }, { "cell_type": "code", - "execution_count": 110, + "execution_count": 159, "metadata": {}, "outputs": [ { @@ -139,13 +138,13 @@ "Text(0.5, 1.0, 'XZ intensity at the center')" ] }, - "execution_count": 110, + "execution_count": 159, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9YAAAEyCAYAAAAfo0gPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAD57klEQVR4nOydd3gUVRfG3930HtITAiGEmgABQotIkRYQEDWfiIgUBQQCCKgoiNKkKk2FoIKACqIgqLSE0EV6INKREmoSQoBU0vd+f4QZzmx2UyBlk5zf88zzTGbvzD33zmRnz73vPUclhBBgGIZhGIZhGIZhGOapUJe3AQzDMAzDMAzDMAxTkWHHmmEYhmEYhmEYhmGeAXasGYZhGIZhGIZhGOYZYMeaYRiGYRiGYRiGYZ4BdqwZhmEYhmEYhmEY5hlgx5phGIZhGIZhGIZhngF2rBmGYRiGYRiGYRjmGWDHmmEYhmEYhmEYhmGeAXasGYZhGIZhGIZhGOYZYMfawJk2bRpUKhUSEhLK25RSYd++fVCpVNi3b1+JXVPqM4ZhGIZhGIZhmLKgyjjWAwYMgLm5Of777798n82dOxcqlQpbt27F+vXroVKp8O233+q8zsiRI2FiYoJ///23tE1mSpnBgwdDpVLJm62tLfz9/bFgwQJkZmYqyh48eBA9evRA9erVYW5ujpo1a6J3795Yt26dohy9Ht3c3NzKsmkMwzAMwzAMw5QhxuVtQFmxcOFCbN++HSNGjMCePXvk49HR0ZgxYwaCg4PRq1cvAMCaNWvw8ccf4+WXX4arq6tc9tixY/juu+/w/vvvw9/fv8zbwJQ8ZmZmWLFiBQAgMTERv//+Oz744AMcP34c69evBwBs2LABr7/+Opo2bYr33nsP1apVQ3R0NA4cOIDvv/8e/fv3V1yza9euGDhwoOKYhYVF2TSIYRiGYRiGYZgyp8o41i4uLpg3bx6GDx+ONWvWYNCgQQCAUaNGwcTEBEuWLJHLhoaGws/PD+PHj5dnJHNzc/Huu++iZs2amDZtWnk0gSkFjI2NMWDAAPnvUaNGoXXr1vj111+xcOFCeHh4YNq0afD19cWRI0dgamqqOD8+Pj7fNevVq6e4JsMwDMMwDMMwlZsqIwUHgKFDh6Jt27b44IMPcP/+faxfvx5hYWH4/PPPUb16dblcrVq1MG3aNPzyyy+IiIgAAHz11VeIiopCaGgoLC0tC6zn8uXLCA4OhpubG8zNzeHp6Yl+/fohKSkJAHD9+nWoVCqsXr0637kqlUqn456QkIC+ffvC1tYWjo6OeO+995CRkaEoExERgeeffx729vawtrZG/fr1MXnyZPnzrKwsfPbZZwgICICdnR2srKzQrl077N27V3Edyb4vv/wSS5cuRe3atWFpaYlu3brh1q1bEEJg5syZ8PT0hIWFBfr06YMHDx4orlGrVi306tULO3fuRNOmTWFubg5fX19s2rSpwL6TOHr0KLp37w47OztYWlqiQ4cO+Oeff/KVO3jwIFq2bAlzc3P4+PjolfAXFbVajY4dO8r9AABXr15Fy5Yt8znVQN6ADcMwDMMwDMMwVZsqM2MNQF473axZM4wcORJ///03WrRogZCQkHxlx48fj7Vr12LkyJEICwvDZ599hn79+qF79+4F1pGVlYWgoCBkZmZizJgxcHNzw507d7B161YkJibCzs7uqWzv27cvatWqhTlz5uDIkSP46quv8PDhQ/z4448AgHPnzqFXr15o0qQJZsyYATMzM1y5ckXhjCYnJ2PFihV44403MGzYMKSkpGDlypUICgrCsWPH0LRpU0Wda9euRVZWFsaMGYMHDx5g/vz56Nu3Lzp16oR9+/bho48+wpUrV/D111/jgw8+wA8//KA4//Lly3j99dcxYsQIDBo0CKtWrcJrr72GsLAwdO3aVW9b9+zZgx49eiAgIABTp06FWq3GqlWr0KlTJ/z9999o1aoVAODMmTPo1q0bnJ2dMW3aNOTk5GDq1KkK+f7TcPXqVQCAo6MjAMDLywu7d+/G7du34enpWej5GRkZ+YLN2djYwMzM7JnsYhiGYRiGYRjGQBFVkEmTJgkAwsjISERGRuotd/ToUaFWq4WDg4Owt7cXcXFxhV771KlTAoDYsGGD3jLR0dECgFi1alW+zwCIqVOnyn9PnTpVABAvvfSSotyoUaMEAPHvv/8KIYRYtGiRACDu3bunt96cnByRmZmpOPbw4UPh6uoq3n777Xz2OTs7i8TERPm41G/+/v4iOztbPv7GG28IU1NTkZGRIR/z8vISAMTvv/8uH0tKShLu7u6iWbNm8rG9e/cKAGLv3r1CCCE0Go2oW7euCAoKEhqNRi736NEj4e3tLbp27Sofe/nll4W5ubm4ceOGfOz8+fPCyMhIFOXRHjRokLCyshL37t0T9+7dE1euXBGzZ88WKpVKNGnSRC63cuVKAUCYmpqKF154QXz66afi77//Frm5ufmuCUDnputeMwzDMAzDMAxTOahSUnAJJycnAICHhwcaNWqkt1yrVq0wYsQIPHjwAHPmzCnSTKg0Ix0eHo5Hjx6VjMFAvln1MWPGAAC2b98OALC3twcA/Pnnn9BoNDqvYWRkJMuZNRoNHjx4gJycHLRo0QInT57MV/61115TzLC3bt0aQF6EdWNjY8XxrKws3LlzR3G+h4cHXnnlFflvW1tbDBw4EKdOnUJcXJxOG6OionD58mX0798f9+/fR0JCAhISEpCWlobOnTvjwIED0Gg0yM3NRXh4OF5++WXUrFlTPr9hw4YICgrSeW1dpKWlwdnZGc7OzqhTpw4mT56MwMBAbN68WS7z9ttvIywsDB07dsTBgwcxc+ZMtGvXDnXr1sWhQ4fyXbNPnz6IiIhQbMWxiWEYhmEYhmGYikWVc6xv3bqFqVOnolGjRrh16xbmz59fYPmWLVsCAFq0aFGk63t7e2PChAlYsWIFnJycEBQUhKVLl8rrq5+WunXrKv728fGBWq2W1wG//vrraNu2LYYOHQpXV1f069cPv/32Wz4ne82aNWjSpAnMzc3h6OgIZ2dnbNu2Tad91GEFngwa1KhRQ+fxhw8fKo7XqVMnXz7pevXqAXiyflmby5cvAwAGDRokO7zStmLFCmRmZiIpKQn37t1Denp6vn4BgPr16+u8ti7Mzc1l5/fAgQO4desW/vnnH9SuXVtRLigoCOHh4UhMTMSBAwcQEhKCGzduoFevXvkCmHl6eqJLly6Kzd3dvcg2MQzDMAzDMAxTsahyjvXo0aMBADt27MBrr72GWbNm4dq1ayVax4IFC3D69GlMnjwZ6enpGDt2LPz8/HD79m0AyOdsSuTm5ha5Du1rWFhY4MCBA9i1axfeeustnD59Gq+//jq6du0qX/fnn3/G4MGD4ePjg5UrVyIsLAwRERHo1KmTzlluIyMjnXXrOy6EKLL9+pDs+OKLL/LN+kqbtbX1M9cjYWRkJDu/7dq1K3QNtaWlJdq1a4dvvvkGU6ZMwcOHD7Fjx44Ss4cpOoMHD0atWrXK24wSYdq0aXq/Fyo6KpVK/t5lGIZhKi+rV6+GSqXSO3lSkdi3bx9UKhX27dtX3qaUOB07dixQscs8PVXKsd68eTP++usvOaL14sWLYWpqqjN42bPSuHFjTJkyBQcOHMDff/+NO3fuYPny5QCAatWqAcjLm0y5ceOG3utJM7kSV65cgUajUTgWarUanTt3xsKFC3H+/HnMmjULe/bskaN+b9y4EbVr18amTZvw1ltvISgoCF26dMkXXbykuHLlSj5n+7///gMAvQ6Rj48PgDzZuPasr7SZmJjA2dkZFhYW+foFAC5dulSyDdGDpGKIjY0tk/oqAgMGDIC5ubl8nylz586FSqXC1q1bsX79ejmYoC5GjhwJExMT/Pvvv6Vi5/bt2w0+bd7s2bPxxx9/lEvdMTExmDZtGqKioopU/tChQ5g2bVq+77TKzqNHjzBt2rRK+cOLYZiKT1HfyUDeYLVKpSpwK83B7PPnz2PatGkG7ZSvW7cOixcvLrf6i/O7oLjv8crEsmXLdGZeKguqjGOdkpKCsWPHolmzZvL6ZA8PD8ycORNhYWHYsGFDidSTnJyMnJwcxbHGjRtDrVYjMzMTQJ7T6OTkhAMHDijKLVu2TO91ly5dqvj766+/BgD06NEDAPKluwIgR/mW6pVmmqmze/ToURw+fLjQdj0NMTExirXKycnJ+PHHH9G0aVO4ubnpPCcgIAA+Pj748ssvkZqamu/ze/fuAchrS1BQEP744w/cvHlT/vzChQsIDw8v0Xbs3r1b53FpfXtxpOeVnYULF8LS0hIjRoxQHI+OjsaMGTMQHByMXr16yRH2P/74Y9y9e1dR9tixY/juu+8wfvx4+Pv7663r+++/f+pBlO3bt2P69OlPdW5pMGXKFKSnpyuOlbdjPX369GI51tOnT6+SjvX06dPZsWYYxiAp6jsZAN5991389NNPOrfBgwcDANq0aVNgfW+99RbS09Ph5eVVbFvPnz+P6dOnG4xj3b59e6Snp6N9+/bysYrmWBfnPV6ZKE/Husqk25oyZQpiYmKwadMmhZQ5JCQEa9aswbhx49C9e3fY2Ng8Uz179uzB6NGj8dprr6FevXrIycnBTz/9BCMjIwQHB8vlhg4dirlz52Lo0KFo0aIFDhw4oHNEUSI6OhovvfQSunfvjsOHD+Pnn39G//79ZcdjxowZOHDgAHr27AkvLy/Ex8dj2bJl8PT0xPPPPw8A6NWrFzZt2oRXXnkFPXv2RHR0NJYvXw5fX1+dTuyzUq9ePbzzzjs4fvw4XF1d8cMPP+Du3btYtWqV3nPUajVWrFiBHj16wM/PD0OGDEH16tVx584d7N27F7a2ttiyZQsAYPr06QgLC0O7du0watQo5OTk4Ouvv4afnx9Onz5dYu3o06cPvL290bt3b/j4+CAtLQ27du3Cli1b0LJlS/Tu3bvE6qrouLi4YN68eRg+fDjWrFmDQYMGAQBGjRoFExMTLFmyRC4bGhoKPz8/jB8/HuvWrQOQtxzi3XffRc2aNQudUTYxMSm1dpQ1xsbGioCATNUmLS0NVlZW5W0GwzAVnOK8kwMDAxEYGJjvGrGxsZgwYQK8vLwQGhpaYH1GRkZ6lwtWNNRqNczNzcvbDMZAyMnJgUajkYNA66Wco5KXCSdOnBBGRkZi9OjROj8/duyYUKvVYuzYsfk+W7VqlQAgjh8/XqS6rl27Jt5++23h4+MjzM3NhYODg3jhhRfErl27FOUePXok3nnnHWFnZydsbGxE3759RXx8vN50W+fPnxf/+9//hI2NjahWrZoYPXq0SE9Pl8vt3r1b9OnTR3h4eAhTU1Ph4eEh3njjDfHff//JZTQajZg9e7bw8vISZmZmolmzZmLr1q1i0KBBwsvLSy4npdv64osvFDZLqbG0U4np6iMvLy/Rs2dPER4eLpo0aSLMzMxEgwYN8p2rnW5L4tSpU+LVV18Vjo6OwszMTHh5eYm+ffuK3bt3K8rt379fBAQECFNTU1G7dm2xfPlyuc8KQ0q3VRi//PKL6Nevn/Dx8REWFhbC3Nxc+Pr6ik8++UQkJycrygIQISEhhV6zMqPRaETbtm2Fk5OTSEhIEL/88osAIL766qt8ZefPny8AiJ07dwohhFi4cKEAIHbs2FFoPQU9t99++62oXbu2MDU1FS1atBDHjh1TnAcdKdEkcnNzxaJFi4Svr68wMzMTLi4uYvjw4eLBgweK+qVn/O+//xYtW7YUZmZmwtvbW6xZs0ZRLisrS0ybNk3UqVNHmJmZCQcHB9G2bVu5zUKIfM+sLvsGDRok9uzZIwCITZs25euPtWvXCgDi0KFDevvs/v374v333xeNGjUSVlZWwsbGRnTv3l1ERUXJZaT/Se1NX8o4yXbtLTo6Wm5LSEiI2Lx5s/Dz8xOmpqbC19dX5z2+ffu2GDJkiHBxcZHLrVy5Um97tPnpp59Ey5YthYWFhbC3txft2rUT4eHhijLbt28Xzz//vLC0tBTW1tbixRdfFGfPnlWUkb4bbt++Lfr06SOsrKyEk5OTeP/990VOTo4Q4snzpr3R7+8LFy6I4OBgUa1aNWFmZiYCAgLEn3/+qahL+v7ct2+fGDlypHB2dhb29vZFbjPDMExBFOedrE1ubq544YUXhLGxsfjnn38KLS99n0nf/0IU7V0pnae90d+GJfXdLfHLL7+I5s2bC2tra2FjYyMaNWokFi9eLH+u/fu0Q4cO+ezz8vISKSkpwtLSUqcPcevWLaFWq8Xs2bML7LcvvvhCBAYGCgcHB2Fubi6aN2+e7/eyvt8FuijsPd6hQwfh5+cnzp07Jzp27CgsLCyEh4eHmDdvXr5rZWRkiM8++0z4+PgIU1NT4enpKT788ENFit2COHLkiOjRo4ewt7cXlpaWonHjxop+FqJ478qDBw+K8ePHCycnJ2FpaSlefvllER8fL5eT0v3SrUOHDvLnDx8+FO+9957w9PQUpqamwsfHR8ydO1eRQpf+nly0aJGoXbu2UKvV4tSpU4W2t0o41kzZI32RMlWTs2fPChMTE/Haa68JNzc30aJFC515v7Ozs4W/v7/w8fERly9fFtbW1qJfv35FqkOfY92sWTNRp04dMW/ePDF//nzh5OQkPD09RVZWlhBCiEOHDomuXbsKAOKnn36SN4mhQ4cKY2NjMWzYMLF8+XLx0UcfCSsrK9GyZUv5GkLkPeP169cXrq6uYvLkyeKbb74RzZs3FyqVSvGynzx5slCpVGLYsGHi+++/FwsWLBBvvPGGmDt3rlxG27H+6aefhJmZmWjXrp1s36FDh4RGoxE1atQQwcHB+frjxRdfFD4+PgX22fHjx4WPj4/4+OOPxbfffitmzJghqlevLuzs7MSdO3eEEELExcWJGTNmCABi+PDhcv1Xr17Vec1///1XvPHGGwKAWLRokVw+NTVVCJH3Y8Df31+4u7uLmTNnisWLF4vatWsLS0tLkZCQIF8nLi5OeHp6iho1aogZM2aI0NBQ8dJLL8nXLYxp06YJAOK5554TX3zxhViyZIno37+/+Oijj+QyP/74o1CpVKJ79+7i66+/FvPmzRO1atUS9vb2ih+CgwYNEubm5sLPz0+8/fbbIjQ0VAQHBwsAYtmyZUIIIVJTU0VoaKgAIF555RW53f/++68QIu9/wM7OTvj6+op58+aJb775RrRv316oVCrFwIj0Y8HX11d06NBBfP3114png2EY5lkp6jtZG+l7ddasWUWqR59jXdi78urVq2Ls2LECgJg8ebL8fRoXFyeEKNnvbiGE2LlzpwAgOnfuLJYuXSqWLl0qRo8eLV577TW5jLZjvXPnTtG0aVPh5OQk27d582YhhBBvvvmmcHV1zee8z58/X6hUKnHjxo0C+83T01OMGjVKfPPNN2LhwoWiVatWAoDYunWrXEbf7wJdFPYe79Chg/Dw8BA1atQQ7733nli2bJno1KmTACC2b98uXyc3N1d069ZNWFpainHjxolvv/1WjB49WhgbG4s+ffoU2Capz0xNTYWXl5eYOnWqCA0NFWPHjhVdunSRyxT3XdmsWTPRqVMn8fXXX4v3339fGBkZib59+8rlNm/eLDw9PUWDBg3kdksTGWlpaaJJkybC0dFRTJ48WSxfvlwMHDhQqFQq8d5778nXkH5P+vr6itq1a4u5c+eKRYsWFXofhWDHmikl2LFmJk2aJAAIIyMjERkZqbfc0aNHhVqtFg4ODsLe3l5+kRaGPsfa0dFRMbv8559/CgBiy5Yt8rGQkBCdqoa///5bABBr165VHA8LC8t3XBoVPXDggHwsPj5emJmZiffff18+5u/vX+j/gi6VhZWVlc7R6EmTJgkzMzORmJioqNfY2FgxW6qLjIyMfD+moqOjhZmZmZgxY4Z87Pjx4wXOUmvzxRdf5PsxJQFAmJqaiitXrsjH/v33XwFAfP311/Kxd955R7i7uyucbSGE6Nevn7CzsxOPHj3SW//ly5eFWq0Wr7zySr72aTQaIYQQKSkpwt7eXgwbNkzxeVxcnLCzs1Mcl1QNtE+EEKJZs2YiICBA/vvevXv5ZqklOnfuLBo3bqwY1ddoNOK5554TdevWlY9JPxaef/75fD/KGIZhSoqivpMl9u3bJ4yMjETnzp2L5IQLod+xLsq7csOGDToVjKXx3f3ee+8JW1vbAr9zdSkqe/bsqfjdIREeHq5TbdekSRPFbKk+tN9vWVlZolGjRqJTp06K4/p+F+iioPe4NPv+448/yscyMzOFm5ubYuD+p59+Emq1Wvz999+K85cvXy4AFKhiyMnJEd7e3sLLy0s8fPhQ8Zn0Xhai+O/KLl26KM4fP368MDIyUvwm8vPz09nvM2fOFFZWVgo1rxBCfPzxx8LIyEjcvHlTCPHk96Stra1iNrwoVJngZQzDlC1OTk4A8oIEFpTWoVWrVhgxYgQePHiAOXPmwNXV9Znqff311+XI+wDQrl07AChSWr0NGzbAzs4OXbt2RUJCgrwFBATA2tpajrAv4evrK18fAJydnVG/fn1FXfb29jh37pzOCPZPw8CBA5GZmYmNGzfKx3799Vfk5ORgwIABBZ5rZmYGtTrvaz83Nxf379+HtbU16tevj5MnT5aIfbro0qWLHPEfAJo0aQJbW1u5n4QQ+P3339G7d28IIRR9HxQUhKSkpALt++OPP6DRaPDZZ5/J7ZOQ0phFREQgMTERb7zxhuL6RkZGaN26db57CyBfwJ927doV6Tl68OAB9uzZg759+yIlJUWu6/79+wgKCsLly5dx584dxTnDhg2rNGsTGYYxPIr6TgaAhIQE9O/fH46Ojvj555/zfa8Wl6K8K/VRGt/d9vb2SEtLQ0RExDO06gldunSBh4cH1q5dKx87e/YsTp8+Xeh7GchLmSvx8OFDJCUloV27dqX6Xra2tlbYZmpqilatWin6acOGDWjYsCEaNGig6PtOnToBgM6+lzh16hSio6Mxbtw42NvbKz6T3stP864cPny4Ij1pu3btkJubW2BmJdqedu3aoVq1aor2dOnSBbm5ufmCSgcHB8PZ2bnQ61I4Wg7DMCXOrVu3MHXqVDRq1Ahnz57F/PnzMWXKFL3lW7ZsCeBJCrNnoWbNmoq/JSf74cOHhZ57+fJlJCUlwcXFRefn8fHxBdYl1UfrmjFjBvr06YN69eqhUaNG6N69O9566y00adKkUHt00aBBA7Rs2RJr167FO++8AwBYu3Yt2rRpgzp16hR4rkajwZIlS7Bs2TJER0fLOe4BwNHR8ansKQqF9dO9e/eQmJiI7777Dt99953Oa2j3PeXq1atQq9Xw9fXVW0Ya2JB+EGhja2ur+Nvc3DzfC1X73upDSjX46aef4tNPP9VZJj4+HtWrV5f/9vb2LvS6DMMwT0Nx3slCCAwcOBCxsbHYsWOH3iwuxaEo70p9lMZ396hRo/Dbb7+hR48eqF69Orp164a+ffuie/fuhdqjC7VajTfffBOhoaF49OgRLC0tsXbtWpibm+O1114r9PytW7fi888/R1RUlJzJB4DCgSxpPD09812/WrVqiuC/ly9fxoULF/Q6l4W9lwEUOIjzNO/KZ/2Nd/r06SK352ney+xYM6WCoaRLYMqH0aNHAwB27NiBCRMmYNasWejfvz9q165d6nXrm/UTWjnVdaHRaODi4qIYdaZofxkXpa727dvj6tWr+PPPP7Fz506sWLECixYtwvLlyzF06NBCbdLFwIED8d577+H27dvIzMzEkSNH8M033xR63uzZs/Hpp5/i7bffxsyZM+Hg4AC1Wo1x48ZBo9E8lS1FobB+kuoeMGCAHLVWm6cdiJCQ6vjpp590/lDUjsr+LLPHUl0ffPABgoKCdJbRHgShMxYMwzAlSXHeyV9++SV27NiBDz/8UO/3V3F51vcyULLf3S4uLoiKikJ4eDh27NiBHTt2YNWqVRg4cCDWrFlT6Pm6GDhwIL744gv88ccfeOONN7Bu3Tr06tULdnZ2BZ73999/46WXXkL79u2xbNkyuLu7w8TEBKtWrZIzppQGRbknGo0GjRs3xsKFC3WWrVGjxjPZ8DTvymd9lrp27YqJEyfq/LxevXqKv5/mvcyONcMwJcrmzZvx119/YdGiRfD09MTixYsRHh6OkJAQ7Nixo7zNA6B/FNjHxwe7du1C27ZtS9TRcXBwwJAhQzBkyBCkpqaiffv2mDZtWoGOdUEj1f369cOECRPwyy+/ID09HSYmJnj99dcLtWPjxo144YUXsHLlSsXxxMREWSZYWN3FtbUoODs7w8bGBrm5uejSpUuxz/fx8YFGo8H58+fRtGlTvWWAvB9UT1OHLvS1W/qxamJiUmJ1MQzDPA3FeScfPXoUn3zyCVq3bo1Zs2aVqZ0FvZeBkv3uBvKkz71790bv3r2h0WgwatQofPvtt/j000/1qr8Ketc1atQIzZo1w9q1a+Hp6YmbN2/i66+/LtSO33//Hebm5ggPD4eZmZl8XFdq2uK8a0tittvHxwf//vsvOnfuXOzrSfft7Nmzeu9bab0rC3qWUlNTS/W9zGusGYYpMVJSUjB27Fg0a9YMY8aMAZC3nmvmzJkICwvDhg0bytnCPKQcwYmJiYrjffv2RW5uLmbOnJnvnJycnHzli8L9+/cVf1tbW6NOnToKuZc+G/XV5+TkhB49euDnn3/G2rVr0b17d4VjrA8jI6N8o7obNmzIt4ZJX/8UZGtxyuuyKzg4GL///jvOnj2b7/N79+4VeP7LL78MtVqNGTNm5Jt5l9obFBQEW1tbzJ49G9nZ2cWuQxeWlpYA8rfbxcUFHTt2xLfffovY2NgSqYthGKa4FOednJiYiH79+sHS0hK//PILTExMytRWfe+R0vju1n4vq9VqWRVV0LvZysoKSUlJej9/6623sHPnTixevBiOjo7o0aNHobYYGRlBpVIplmZdv34df/zxh876y+q9DOT9Jrpz5w6+//77fJ+lp6cjLS1N77nNmzeHt7c3Fi9enM8G6b1cWu9Kff3Ut29fHD58GOHh4fk+S0xMRE5OzlPVR+EZa4ZhSowpU6YgJiYGmzZtUsh1QkJCsGbNGowbNw7du3eHjY1NOVoJBAQEAADGjh2LoKAgGBkZoV+/fujQoQPeffddzJkzB1FRUejWrRtMTExw+fJlbNiwAUuWLMH//ve/YtXl6+uLjh07IiAgAA4ODjhx4gQ2btwoS/MKsnHXrl1YuHAhPDw84O3tjdatW8ufDxw4ULZF10CALnr16oUZM2ZgyJAheO6553DmzBmsXbs2nxzQx8cH9vb2WL58OWxsbGBlZYXWrVvrXW8k9ecnn3yCfv36wcTEBL1795Zf7EVh7ty52Lt3L1q3bo1hw4bB19cXDx48wMmTJ7Fr1y48ePBA77l16tTBJ598gpkzZ6Jdu3Z49dVXYWZmhuPHj8PDwwNz5syBra0tQkND8dZbb6F58+bo168fnJ2dcfPmTWzbtg1t27YtkpyeYmFhAV9fX/z666+oV68eHBwc0KhRIzRq1AhLly7F888/j8aNG2PYsGGoXbs27t69i8OHD+P27dv4999/i1UXwzBMcSnOO3nEiBG4fv06Xn/9dfzzzz/4559/dF6zKMG4noamTZvCyMgI8+bNQ1JSEszMzNCpUye4uLiU+Hf30KFD8eDBA3Tq1Amenp64ceMGvv76azRt2hQNGzbUe15AQAB+/fVXTJgwAS1btoS1tTV69+4tf96/f39MnDgRmzdvxsiRI4s0ONGzZ08sXLgQ3bt3R//+/REfH4+lS5eiTp06ivXOUv0F/S6gFPc9rou33noLv/32G0aMGIG9e/eibdu2yM3NxcWLF/Hbb78hPDxcb2wctVqN0NBQ9O7dG02bNsWQIUPg7u6Oixcv4ty5c7JzWxrvyoCAAISGhuLzzz9HnTp14OLigk6dOuHDDz/EX3/9hV69emHw4MEICAhAWloazpw5g40bN+L69etFmqQokGLFEGcYhtHDiRMnhJGRkRg9erTOz48dOybUarUYO3Zsvs+kNArHjx8vcn360m198cUX+cpCKyVSTk6OGDNmjHB2dhYqlSpfqqvvvvtOBAQECAsLC2FjYyMaN24sJk6cKGJiYuQy+lLKdejQQZHm4fPPPxetWrUS9vb2wsLCQjRo0EDMmjVLkRNbV7qtixcvivbt2wsLCwsBIF+KjczMTFGtWjVhZ2cn0tPTC+oqmYyMDPH+++8Ld3d3YWFhIdq2bSsOHz6cz2Yh8tKU+fr6CmNj4yKl3po5c6aoXr26UKvVinQrAERISEi+8l5eXvnadPfuXRESEiJq1KghTExMhJubm+jcubP47rvvitS+H374QTRr1kyYmZmJatWqiQ4dOoiIiAhFmb1794qgoCBhZ2cnzM3NhY+Pjxg8eLA4ceKEXGbQoEHCysoq3/V13adDhw6JgIAAYWpqmu85u3r1qhg4cKBwc3MTJiYmonr16qJXr15i48aNcpmnefYZhmEKo7jvZCktVmFbQehLt1WUd6UQQnz//feidu3awsjIKF+qq5L87t64caPo1q2bcHFxEaampqJmzZri3XffFbGxsYr6tG1ITU0V/fv3F/b29gKAztRbL774ogCgN8e0LlauXCnq1q0rzMzMRIMGDcSqVaue6neBNvre4x06dBB+fn75ymv/rhIiL/XXvHnzhJ+fn/xuDQgIENOnTxdJSUmFtu3gwYOia9euwsbGRlhZWYkmTZooUm0K8WzvSl33KS4uTvTs2VPY2NgIAIrnLCUlRUyaNEnUqVNHmJqaCicnJ/Hcc8+JL7/8Uv5dVtDvycIwSMf6m2++EV5eXsLMzEy0atVKHD16tMTr2L9/v+jVq5dwd3cXAOQk7xIajUZ8+umnws3NTZibm4vOnTvny3v2NMyePVu0aNFCWFtbC2dnZ9GnTx9x8eJFRZn09HQxatQo4eDgIKysrMSrr75a5Ny+BbFs2TLRuHFjYWNjI2xsbESbNm0UieBLq15t5syZIwAokrGXVt3SFxPd6tevX+r1Sty+fVu8+eabwsHBQZibm4tGjRopvhRK6zljKj/Z2dnC2dlZvP322+VtCsMwDMMwQoiXX35Z+Pj4lLcZTDlhcGusJYnF1KlTcfLkSfj7+yMoKKjAkO5PQ1paGvz9/bF06VKdn8+fPx9fffUVli9fjqNHj8LKygpBQUHIyMh4pnr379+PkJAQHDlyBBEREcjOzka3bt0U6xTGjx+PLVu2YMOGDdi/fz9iYmLw6quvPlO9QF5o/blz5yIyMhInTpxAp06d0KdPH5w7d65U66UcP34c3377bb4Iv6VZt5+fH2JjY+Xt4MGDZVLvw4cP0bZtW5iYmGDHjh04f/48FixYoMixXFrPGVP5+eOPP3Dv3j0MHDiwvE1hGIZhmCpPbGwstm3bhrfeequ8TWHKi/L27LVp1aqVQjaYm5srPDw8xJw5c0qtTmjNWGs0GuHm5qaQACQmJgozMzPxyy+/lGjd8fHxAoDYv3+/XI+JiYnYsGGDXObChQsCgDh8+HCJ1i2EENWqVRMrVqwok3pTUlJE3bp1RUREhOjQoYM8Y12adU+dOlX4+/vr/Ky02/zRRx+J559/Xu/nZfmcMZWHI0eOiO+++07UqFFDNGvWrLzNYRiGYZgqzbVr18RPP/0kOnToICwtLRWScqZqYVAz1llZWYiMjFSEQVer1ejSpQsOHz5cZnZER0cjLi5OYYednR1at25d4nZI0QUdHBwAAJGRkcjOzlbU3aBBA9SsWbNE687NzcX69euRlpaGwMDAMqk3JCQEPXv2zBfmvrTrvnz5Mjw8PFC7dm28+eabuHnzZpnU+9dff6FFixZ47bXX4OLigmbNmikiK5blc8ZUHkJDQzFy5Ei4uLjgxx9/LG9zGIZhGKZKs3//frz11luIjo7GmjVrdObbZqoGBhUVPCEhAbm5uXB1dVUcd3V1xcWLF8vMjri4OLlebTukz0oCjUaDcePGoW3btmjUqJFct6mpKezt7Uul7jNnziAwMBAZGRmwtrbG5s2b4evri6ioqFKtd/369Th58iSOHz+e77PSbHPr1q2xevVq1K9fH7GxsZg+fTratWuHs2fPlnpfX7t2DaGhoZgwYQImT56M48ePY+zYsTA1NcWgQYPK7DljKherV6/G6tWry9sMhmEYhmEADB48GIMHDy5vMxgDwKAc66pGSEgIzp49q1jzW9rUr18fUVFRSEpKwsaNGzFo0CDs37+/VOu8desW3nvvPURERMDc3LxU69KG5hBs0qQJWrduDS8vL/z222+wsLAo1bo1Gg1atGiB2bNnAwCaNWuGs2fPYvny5Rg0aFCp1s0wDMMwDMMwTNlhUFJwJycnGBkZ4e7du4rjd+/eLVNZhVRXadoxevRobN26FXv37oWnp6ei7qysrHyJzUuqblNTU9SpUwcBAQGYM2cO/P39sWTJklKtNzIyEvHx8WjevDmMjY1hbGyM/fv346uvvoKxsTFcXV1Ltc0Ue3t71KtXD1euXCn1vnZ3d4evr6/iWMOGDWUpelk8ZwzDMAzDMAzDlD4GNWNtamqKgIAA7N69Gy+//DKAvFm/3bt3Y/To0WVmh7e3N9zc3LB79240bdoUAJCcnIyjR49i5MiRz3RtIQTGjBmDzZs3Y9++ffkStQcEBMDExAS7d+9GcHAwAODSpUu4efMmAgMDn6luXWg0GmRmZpZqvZ07d8aZM2cUx4YMGYIGDRrgo48+Qo0aNcqszampqbh69SreeuutUu/rtm3b4tKlS4pj//33H7y8vACU7nNmCGg0GsTExMDGxgYqlaq8zWEYg0QIgZSUFHh4eECtNqixboZhKhH8TmaYwnnmd3I5B0/Lx/r164WZmZlYvXq1OH/+vBg+fLiwt7cv8XzKKSkp4tSpU+LUqVMCgFi4cKE4deqUuHHjhhBCiLlz5wp7e3vx559/itOnT4s+ffoIb29vkZ6e/kz1jhw5UtjZ2Yl9+/aJ2NhYeXv06JFcZsSIEaJmzZpiz5494sSJEyIwMFAEBgY+U71CCPHxxx+L/fv3i+joaHH69Gnx8ccfC5VKJXbu3Fmq9eqCRgUvzbrff/99sW/fPhEdHS3++ecf0aVLF+Hk5CTi4+NLtV4hhDh27JgwNjYWs2bNEpcvXxZr164VlpaW4ueff5bLlNZzZgjcunUrXw5x3njjTfd269at8v6XZRimEsPvZN54K/r2tO9kg5qxBoDXX38d9+7dw2effYa4uDg0bdoUYWFh+QI8PSsnTpzACy+8IP89YcIEAMCgQYOwevVqTJw4EWlpaRg+fDgSExPx/PPPIyws7JnXCIeGhgIAOnbsqDi+atUqOfDBokWLoFarERwcjMzMTAQFBWHZsmXPVC8AxMfHY+DAgYiNjYWdnR2aNGmC8PBwdO3atVTrLQqlVfft27fxxhtv4P79+3B2dsbzzz+PI0eOwNnZuVTrBYCWLVti8+bNmDRpEmbMmAFvb28sXrwYb775plymtJ4zQ8DGxgZA3hp7W1vbcraGYQyT5ORk1KhRQ/5/YRiGKQ34ncwwhfOs72SVEEKUsE0MwzBITk6GnZ0dkpKS+CXOMHrg/xOGYcoC/q5hmMJ51v8TXtDFMAzDMAzDMAzDMM8AO9YMwzAMwzAMwzAM8wywY80wDMMwDMMwDMMwzwA71gzDMAzDMAzDMAzzDLBjzTAMwzAMwzAMwzDPADvWDMMwDMMwDMMwDPMMsGPNMAxThcjVCFyKS4FGw5kWGYZhGKa8SMvMwdV7qeVtBlOCGKxjnZmZiWnTpiEzM7PK1M1tLluqat1M1ebbA1cRtPgANkbeLm9TGIZhGKZKkqsRGPjDMXResB9hZ2PL2xymhDBox3r69Onl5vSUR93c5rKlqtbNVG0uxaUAAM7HJpezJU/HuZgkvPHdEZy8+bC8TWEYhmGYp2Ld0RuIvJH3Hvtk81k8SMsqZ4uYkqDUHOulS5eiVq1aMDc3R+vWrXHs2LHSqophGIYpItLL+15qxRzUWX/sFg5fu4/NJ++UtykMwzAMU2zikzMwP+wSAMDazBj307Iw7a9z5WwVUxKUimP966+/YsKECZg6dSpOnjwJf39/BAUFIT4+vjSqY5gqQ2hoKJo0aQJbW1vY2toiMDAQO3bskD/PyMhASEgIHB0dYW1tjeDgYNy9e1dxjZs3b6Jnz56wtLSEi4sLPvzwQ+Tk5CjK7Nu3D82bN4eZmRnq1KmD1atXl0XzmDIg8VE2ACAhpWI61v/dzZtxT8nILmdLGIZhGKb4zNh6HimZOfD3tMNP77SCkVqFv/6NQdjZuPI2jXlGjEvjogsXLsSwYcMwZMgQAMDy5cuxbds2/PDDD/j4448LPFej0SAmJgZC5AXWSU4ue7miVGdZ111e9ZZn3VWxzc9St4ODAz777DP4+PhAo9Fg9erV6NOnD06dOgU/Pz+MHz8e27Ztw4YNG2BnZ4fRo0fj1VdfxT///AMAyM3NRc+ePeHm5oZDhw4hNjYWAwcOhImJCWbPng0AiI6ORs+ePTFixAisXbsWu3fvxtChQ+Hu7o6goKCS7QimzKnoM9ZX4vMCvaRm5hRSkmEYhmEMi/3/3cPW07FQq4BZrzRGo+p2eLd9bSzbdxVT/jiL1t4OqGZlWt5mMk9JiTvWWVlZiIyMxKRJk+RjarUaXbp0weHDh/OVz8zMVKwzvXPnDnx9feW/a9SoUdImFpnyqpvbzHUXBzs7Oxw5cgSenp5YuXIl1q1bh06dOgEAVq1ahYYNG+LIkSNo06YNdu7cifPnz2PXrl1wdXVF06ZNMXPmTHz00UeYNm0aTE1NsXz5cnh7e2PBggUAgIYNG+LgwYNYtGgRO9aVgMRHjx3rCjhjfT81E/cfDwykZLBjzTAMw1QcMrJz8ekfZwEAQ9p6o1F1OwDA2M51sfP8XVyJT8X0LeewuF+z8jSTeQZK3LFOSEhAbm4uXF1dFcddXV1x8eLFfOXnzJmD6dOn5zvu6OgItVotz1wDeQ6EREpKirxvbm4u76vVT9TtFhYWimtmZGToLJebmyvva0tidUHPpeXT09PlfZVKJe+bmj4ZeUpKSpL33d3dFdelbaJtpfbR69LZTtpWakdWVpbOMvQ6dGCD2mpmZgZ9GBs/eXRofbQ/TExMdJ6bnf1Ewkn70sHBQd6/c+fJ+kkXFxd5n7aZ9gu1RxtaB903MjKS9+/duyfv29vb67wOfX7oudSOatWqyfu0X7R59OiRvE/7mT7L9NmnxyU7cnNzERMTg/T0dAQGBiIyMhLZ2dno0qWLXLZBgwaoWbMmDh8+jDZt2uDw4cNo3Lix4v8zKCgII0eOxLlz59CsWTMcPnxYcQ2pzLhx4/S2B8g/SFYeSgCmYDJzcpGWlfe8pmTkICM7F+YmRoWcZTj8d/dJWhJ2rBmGYZiKxDd7ruDmg0dwtzPH+K715OPmJkb44n9NEBx6CH9ExaBnEw909XUt4EqMoVIqUvDiMGnSJEyYMEH+Ozk5GTVq1ICDg4PCeQGA2Ngn4eipU/rgwQN538nJSd6/f/++4nzqWFInljo21Kmizk9aWpq8r9Fo5H3qSFpZWcn71CmysbGBLuh1tP+mjiLth9TUJz8sqUNHnTh6rrW1tU6b6DVp++l16D6tF1C2iTrj1Jmm9lFoeXodapOzs7POc21tbeV9fX0EKO8XbYelpaW8T53A2rVry/v0eaKDAI6OjvI+XbdM+5g+V7Rt2k42dcBpfbRN9Nmitubm5uLBgwfy/Vy7di18fX0RFRUFU1PTfAMDrq6uiIvLW7cTFxenc9BL+qygMsnJyUhPT883YCWhb5CMMRyk9dUSCamZ8Kxmqae04XE5/sn/F0vBGYZhmIrClfgUfHvgKgBgam8/WJspXbBmNathWPva+Hb/NUzefAYta1WDvSVLwisaJR68zMnJCUZGRvkCJt29exdubm75ypuZmcmBmKSNYRj9GBsbw9HRUXbOR4wYgfPnz5ezVXmDZElJSfJ269at8jaJ0eLhI2U6j4omB5cClwHsWDMMYxhwUFGmMIQQmLz5LLJzBbo0dEGQn+7Z6PFd6qG2sxXupWRixtby/13HFJ8Sd6xNTU0REBCA3bt3y8c0Gg12796NwMDAkq6OYaocKpUKxsbGsjqgUaNGWLJkCdzc3JCVlYXExERFeTqo5ebmpnPQS/qsoDK2trZ6Z6sBHiSrCGjnyUxIrVh5M6kUPJWl4AzDGACenp6YO3cuIiMjceLECXTq1Al9+vTBuXN56ZPGjx+PLVu2YMOGDdi/fz9iYmLw6quvyudLQUWzsrJw6NAhrFmzBqtXr8Znn30ml5GCir7wwguIiorCuHHjMHToUISHh5d5e5nisyHyNo5FP4CFiRGmveSnWI5JyZOE+0OlAjadvIM9F+/qLMcYLqUiBZ8wYQIGDRqEFi1aoFWrVli8eDHS0tLkKOFFQa1WQ61WK6S19Ec9lU1TeS91CLRH+6icmc6eU/kyLUPXtVIngUrM9a2DpVJkfZJeajeglAdTqKNE/xmp1Jj2B7WDSpBpGSr/prZSm6hkW9tWulaclqP1UWk8rZuWoWubqdSa3gcq86bPAF3Dqy0Fp/1Epdr0utQ+un66KGvD9fUTvSbtI7pmHoAi9RxtE30G6LNF7ZaeB+lzjUaDzMxMBAQEwMTEBLt370ZwcDAA4NKlS7h586Y8qBUYGIhZs2YhPj5eXrseEREBW1tbOWhgYGAgtm/frrA3IiKCB8YqAdpS8Io2Yy1FBAeArFxNhVsjzjBM5aN3796Kv2fNmoXQ0FAOKsoAyBvQnrP9AgBgXJe6hS6/CvCqhqHPe+P7v6MxadMZ7BzvADsL3b9LGcOjVPJYv/766/jyyy/x2WefoWnTpoiKikJYWFi+dZsMwxSPxMRE5OTkQKPRyGvYDx48iDfffBN2dnZ45513MGHCBOzduxeRkZEYMmQIAgMD0aZNGwBAt27d4Ovri7feegv//vsvwsPDMWXKFISEhMiDLSNGjMC1a9cwceJEXLx4EcuWLcNvv/2G8ePHl1u7mZJBe8a6IjnWCamZeJCWBTrQz3JwhmEMidzcXKxfvx5paWlFCioKQG9Q0eTkZHnWW19QUV3ZdiQyMzORnJys2JiyZ872C3j4KBsN3Gzw9vPeRTrn/W71UdvJCneTM/E5S8IrFKXiWAPA6NGjcePGDWRmZuLo0aNo3bp1aVXFMFWG3NxcpKenIzU1VZ7537RpE7p27QoAWLRoEXr16oXg4GC0b98ebm5u2LRpk3y+kZERtm7dCiMjIwQGBmLAgAEYOHAgZsyYIZfx9vbGtm3bEBERAX9/fyxYsAArVqzgUfFKQOIjbSl4xXGspfXVNR0s5aAvLAdnGMYQOHPmDKytrWFmZoYRI0Zg8+bN8PX1RVxcXJkEFdXFnDlzYGdnJ2/lmVq0qnL02n1siLwN1eOc1SZGRXO7zE2MMP9/TaBS5cnI916KL/wkxiAo96jg+oiPj4dKpVJIa6kcm8qXaQolGk2aynsB/amg6LXoOVS2Tc+l9emTVNPr65Nja38ZUumvvojaVC6tL7I5PU6vSdNZ6Ru51FcvlZcDyjReVPKsL1WVvhRltJ8ePnwo71MpNy1D7wltm3aEdSqvpufQdlCJPT1Or0XroPdLX7o27X6SoBHmAWX+anq/qE20PklubmNjI0vbNRoN7t27J8vLpPqXLl2KpUuX6rQDALy8vPJJvbXp2LEjTp06VWAZpuLxIC1PCm5tZozUzJwKNWN9+fH66rou1sjMTkZqZg7PWDMMYxDUr18fUVFRSEpKwsaNGzFo0CDs37+/XG3Sl3WHKRuycjT45HHO6jda1USAl+7lnvpoUcsBQ57zxg//RGPypjMIH98etuYsCTd0Sm3GmmEYpjJyLiYJU/88i/sVaLZXQpqxruOSNzhzrwK1QZqxrutqA2vzvDHh5Izsgk5hGIYpE0xNTVGnTh0EBARgzpw58Pf3L/egohxQtHz5/u9ruBKfCidrU3wU1OCprvFhUH14OVoiNikDs7ddKGELmdKAHWuGYZhi8N2Ba1hz+Abm7rhY3qYUmwePHet6ro8d6wo4Y13P1Ro25iwFZxjGcNEVVFRCV1DRM2fOKIKa6goqSq8hleGgoobJjftp+Gr3ZQDAlJ6+sLN8uplmC1MjzA9uAgBYf/wWDvx3r5AzmPLGYKXgdnZ2UKvVCnkwlejSKMs0YjId0dOO7kzlz1SyS2W6VKasL6o1vS79ItQXPp/K0+n1aTRpQNkmOrppbPzkNtH20TZQOTY9TmXQVHJM20OvT6GRtrWl4/QcKpemEnFqB71HVM5Opfc06jaVV9N+pRJsap9231M76P2ldtN7oW+ZAb1HtDytj7aBHqfPD+17QHlf6L2gEcxpW2kbpMjhkhScKVsePo6svfnUHYztXBc1HAqO8GlISLbXc83LKFBR1lgLIfBf/OMZaxebJ2usWQrOMEw5M2nSJPTo0QM1a9ZESkoK1q1bh3379iE8PFwRVNTBwQG2trYYM2aM3qCi8+fPR1xcnM6got988w0mTpyIt99+G3v27MFvv/2Gbdu2lWfTGR0IIfDpn+eQmaPB83Wc0KepxzNdr3VtRwx+rhZWH7qOSZvOIGxcO9iwJNxg4RlrhmGYYpD6WH6coxFYvv9qOVtTPBLlGes8x/pRVi7SKoBzmpCahcRH2VCp8mTs8ox1BbCdYZjKTXx8PAYOHIj69eujc+fOOH78OMLDwzmoaBVl6+lYHPjvHkyN1Zj5ciO9k27FYWL3+qjpYIk7iemYUwHVclUJg52xZhiGMUSoM7fhxG2M6VQXbna6g9YZGlK6rerVLGBpaoRHWbm4l5IJKzPDfhVcJhHBzU2M5BnrFJaCMwxTzqxcubLAzzmoaNUhOSMbMx6nxxrV0QfeTlaFnFE0LE2NMS+4Cd74/gjWHb2JFxu54/m6TiVybaZkMdhfUyqVCiqVSiHRpZJbKo2l0mxankp3Af0RtWkkayprptJkepzaQaW79Di9JrWVjlwVJF+m0OtWr15d3r9y5Yq8T9MwUNk27RsqndaWyUvQPqPychpRXLsc/Yz22f379+V9fdG8qTSb7uuLum1pqVt2m5CQoPibBvOgEdNpHTY2Njrtpuh7Hmj/ScFFAODBgwfyPr0P2v1H5eb6ZOW0DtofMTEx+Wxjyg5pXa+jlSnup2XhuwPX8Flv33K2qnCyczWyI1rN0hTONma4cf8RElIzUauEXv6lRVxy3v9FjWp5//+SDI4da4ZhGMZQ+DL8Eu6lZKK2kxVGdvQp0WsH+jjirTZe+OnIDXz0+2mEj28vDzIzhgNLwRmGYYpByuMZ6zGd6gAA1h27Ic8EGzKJj9dXq1SAnYUJnKzzBpwqQgCz9Oy8wTUL07zBwSdrrDkqOMMwDFP+RN1KxE9HbgAAPn+lEcyMjQo5o/h83KMBPKtZ4E5iOuaxJNwgYceaYRimiAgh5DXJPRq7w8vREhnZGpyLSSrkzPJHWl9tZ2ECI7UKzpJjXQECmKVn5TnWlo8da44KzjAMwxgKObkaTN50BkIArzarjud8SkembWVmLEcJ/+nIDRy6mlDIGUxZY7AaAiEEhBCKiMlOTk8eVCq5pVJfGn2aRtkGlNJkKgmmsnAqv6USZAqVf9P6qNSaXpNGh6YSau3rUzkztZ1Kfqm8mMrCqWyb2kGl0/oigVOZtr4+ptJlQClvp/JlKsWn0nYpkrV2eSqDpvbRiOLUVlovtZtKpQH9905f9HR9wSVofVQ6TttG7yndp/L8O3fuKK7r6emp0ybaN7Q+2h5Jeq7RaHD9+nWddjOlQ3p2LjSP/x1tzI3hZJ0np64IAcCkWfVqlnmR7p1t8r43EyrAjHWGNGNtopyxZik4wzAMU96sPnQd52OTYWdhgsk9G5ZqXc/VcUL/1jWx7uhNfPT7aYS9197g46RUJXjGmmEYpohIM6RqVZ6TJ73M0jJ1D+QYElKqrWqP82k6VaAZ60ePZ6zNJcf68Yx1SgUY0GAYhmEqLzGJ6VgY8R+APKm29G4tTSb1aIDq9ha49SAdX4RfKvX6mKLDjjXDMEwRkRw5azNjqFQqWD2WJj/KMnwH7+Ej3TPWFXGNtRS8jKXgDMMwTHkyfcs5PMrKRQuvani9RY0yqdPG3ARzgxsDyJstP3LtfiFnMGUFO9YMwzBFRHLkJCmypenjGeusijBj/dixttJyrFMNP/CaPik457FmGIZhyotd5+8i/NxdGKtV+PyVRlCrnz1ndVFpV9cZ/VrmOfIf/X5ajkXClC8GK8o3NjZWrBUGlOuZ6ZpaukbV3d1d3tdeF0zXD9O1s7QcXddK1zzT+kxNTeV9aiNds0vXRdP11nStrHbKK5qSia7hpeXoGt67d+/qtJvWTcvTdFHp6ek666LrwelxurYbUKYuo+uCaZ/VqFFDZxl6H2laLLrGmvYZXW9Oy9C17vR+Aso103QNPu1LfSnXaB30XAqtm65Fp9Dnga4xB5TPnL415LTPaRnJPmonUzZIjpwkRbY2y/v/rwhrrBPzScHzvscqwhpr6QeD5FhLwctSMjgqOMMwDFP2PMrKwdS/zgEA3mnnjQZutoWcUfJM7tkQ+/+7hxv3H+GL8EsVIvVnZYdnrBmGYYpIaqbWjHUFWmMtBy/TnrFOyTT4nOj6023lGLztDMMwTOVjya7LuJOYjur2Fnivc91yscHW3ARzXs2ThK86FI3j13VP9DBlBzvWDMMwRUSWgj9e41uR1lgnaq2xlgKsZOVqkGzga5XTs/PUGdoz1tm5Apk5rNxgGIZhyo4LsclYcTAaADDzZT95WVh50LG+C/q28IQQwMSNLAkvbwxWCn7//n2oVCpF+iYqo6ZSX5pSispntVMoUVk0lfhSiTStg8p3qVQ4MTFRp81U7kwlx1TuTKXS2jLjoqSbunfvns7rUmn25cuX5f369evL+1TaTa9Dpe36UmG5uLgobKU20T6rWbOmvE/l5vRaVG5O20n7lbaH3jd6HSqnps8AoLyntE1Uuk+XBtC+p9JuKrGn6dqozJ0+ozdv3tRrE4UuLaB10LbSPqbHpf7Tl1KMKT2kGWsbrTXWFWGtr3a6LXMTI9iYGyMlIwf3UjJhZ2FS0OnlSkaWcsbaivyISc3MkaOFMwzDMExpotEITN58BrkagR6N3NCpgWvhJ5Uyn/T0xf7/7iE6IQ0Ldl7ClF4sCS8veMaaYRimiEgOtJWZUpL8qAKMEGuvsQYqTmTwR9l5/S7NWKvVKs5lzTAMw5Q5vxy/iVM3E2FlamQwa5rtLJ5Iwlf+E43IGywJLy/YsWYYhikiKXJU8Dzn1LICBS978FgK7mD1RKHi+Hhfms02VNK18lgDZJ01O9YMwzBMGXAvJRPzdlwEALzfrT7c7SwKOaPs6NTAFcHN8yThH248LWfTYMoWg5WCZ2dnQ6VS6ZX0Uhk0lV1T+bF2VHEq5aVRnem1qLyYypRpBOnr16/L+35+fvJ+ZuaTWR8asZtKhfVFwdaGStqpVJvaTaXAd+7ckff1yZdpdG3aZ7SfaH9TKTOVJQPKSOzUPirnpudrR+2WoP1K20bvI5VN02eAtpP2vba9VD5Or0vto3bT/qDHacR5eh3aZ/qk7bQMoFxaQNtEJd+0TfS5ka7LUcHLnjStqOBWcrotw3bucjUCSel5z6C95ZP/V0nKbuhrxDOkNdamT/43bcyNEZcMpGRyZHCGYRim9Jm17TySM3LQqLotBj1Xq7zNycdnvXzx9+V7uHYvDYsi/sOkFxuWt0lVjmLPWB84cAC9e/eGh4cHVCoV/vjjD8XnQgh89tlncHd3h4WFBbp06aJY88swDFNR0V5jbSVJwQ08KnhSejak4Nn2RApu+dhRNfSRbSkquCVxrKXBDZ6xZhiGYUqbg5cT8EdUDFQqYPYrjWFUhjmri4qdpQlmv5InCf/+72s4dfNhOVtU9Si2Y52WlgZ/f38sXbpU5+fz58/HV199heXLl+Po0aOwsrJCUFCQYlaOYRimIiJLwc2l4GWPpeAGPuP78LEM3MbcGCZGT772LeSo5gbuWGvlsQbAa6wZhmGYMiEjOxef/nkWADCwjReaeNqXr0EF0MXXFa80qw4NS8LLhWJLwXv06IEePXro/EwIgcWLF2PKlCno06cPAODHH3+Eq6sr/vjjD/Tr16/I9bi4uECtViuksVSiS49TqTCN9KwtD6ZSY32yciprpjJlei0aIZuWoZJjuk9l0NWrV5f3Hz5UjiTRaNlURkxtou2mcmTaNprXlcqFqa36ZN40IjY9Tq+vbQftS33SbiqRprJoGqmcXpP2Gb3v1CZ6TSpNB5QycX1S7fj4eHmfRiGnfU8jw1PpPbWV9mVqaqq8T+8Dvbfa9tH7SO8XjRpPn3HJDs7fW/akPpYdW1ewGetEHeurgSeOaroBv3iFELJ9dI21lHKrIkRkZxiGYSouy/ZdRXRCGlxszPB+UP3CTyhnpvb2xd+XE3AlPhVLdl/GR90blLdJVYYSDV4WHR2NuLg4dOnSRT5mZ2eH1q1b4/DhwzrPyczMRHJysmJjGIYxRCQn7olj/WTG2pAHOh6k5V9fDTyZcTfkvJfS+mpAa4314wBy7FgzDMMwpcXVe6lYvu8qAGBqbz/YmhtuakoJe0tTzHqlEQDg2/1X8e+txPI1qApRoo51XFwcAMDVVZnTzdXVVf5Mmzlz5sDOzk7eaH5ghmGUJCcn4969e4iNjZVn3LVjGHTs2BEqlUqxjRgxQlHm5s2b6NmzJywtLeHi4oIPP/xQMQsPAPv27UPz5s1hZmaGOnXqYPXq1aXatopAaobu4GUaoXQADQ1JCk5TbQEVY8aa2mZu/OSVJd0DloIzDMMwpYEQAp/+cRZZuRp0rO+MFxu7lbdJRSbIzw0v+Xs8loT/i8wcw33PVybKPSr4pEmTMGHCBPnv5ORk1KhRAzk5OVCr1QppLJXDUvk2lfTqi6ANKCXF9FpU5k1lw1SKGxsbK+9T2TCNrk0HD/TJzq9duybve3h4KOyjEbxp+6j8mUqkaRl90bxp3bRvqFSdRkKnUnoqm6YS54Lw9vaW96nMm0L7m9pK20DbRvdp++k9pPdK+zPaB/Q4lWdrLxvQZRN9FvVJ4anUn0q8taXg9+7dk/dp+2if63peMzMzYWlpCRMTE2g0Gjx48ACvvPIKLly4oKhj2LBhmDFjhvw37efc3Fz07NkTbm5uOHToEGJjYzFw4ECYmJhg9uzZAPLUJz179sSIESOwdu1a7N69G0OHDoW7uzuCgoJ09lVVIPWx5FuasaZrftOychQzqoaENCBgozXSbiFHBTfcF67kWJsaqWFM1oc/WWPNUcEZhikf5syZg02bNuHixYuwsLDAc889h3nz5qF+/Ty58PXr1xW/iyi//fYbXnvtNQDK32QSv/zyi2IJ5b59+zBhwgScO3cONWrUwJQpUzB48OCSbxQjs/nUHRy6eh9mxmrMeKmRzvtkyEx7yQ+Hribgv7up+Hr3FXxQAWTsFZ0SnbF2c8sbyaGppqS/pc+0MTMzg62trWJjGEY3bm5usmMtDercunULkZGRinKWlpZwc3OTN/p/tXPnTpw/fx4///wzmjZtih49emDmzJlYunSpPBiyfPlyeHt7Y8GCBWjYsCFGjx6N//3vf1i0aFHZNdYA0V5jrVarngQwM2BJshxV20Tp+FcEKbgcuExr0ILXWDMMU97s378fISEhOHLkCCIiIpCdnY1u3brJExY1atRAbGysYps+fTqsra3zxStatWqVotzLL78sfyYNdr/wwguIiorCuHHjMHToUISHh5dlc6sUiY+yMGvbBQDA2M51UdPRspAzDA8HK1PM7JMnCQ/dfxVnbicVcgbzrJSoY+3t7Q03Nzfs3r1bPpacnIyjR48iMDCwJKtiGIbg4OCg+Hvt2rVwcnJCo0aNMGnSJMVM/+HDh9G4cWPFko2goCAkJyfj3LlzchkaK0Eqoy9WAlD54yVk52pkubfk1AFPApilGXAAM33OaUWQgksRTS1M9DjWLAVnGKacCAsLw+DBg+Hn5wd/f3+sXr0aN2/elAe7jYyMFIPcbm5u2Lx5M/r27ZtPVWlvb68oRxVsPNhd9swLu4j7aVmo62KNYe1ql7c5T02Pxu7o2cQduRqBDzf+i6wcw122VhkothQ8NTUVV65ckf+Ojo5GVFQUHBwcULNmTYwbNw6ff/456tatC29vb3z66afw8PBQjLwVBSEEhBAK6S6V4lLZNF2XTWUaNEI1ANy5c0fnOVQiTSNCUxkwnXHXFzmclqF2UJmyvijdgDLqNP3CpU4RjX5NI0tTm2gdVE5Mo5DTGUwqZ6d1UYm4tvyFBmqi94JG0aZScCq1pnXT49QO2gYqqdZnK31OtK9LsbOzk/f1ybypHJ62jcqp6fVp39N+ofeTSr+17aUSbvpMUJto3dK50vXbtGmDRo0ayZ/3798fXl5e8PDwwOnTp/HRRx/h0qVL2LRpE4C8JQu64iBInxVUJjk5Genp6Qr5usScOXMwffr0fMcrC3RGWnKmAcDK1Aj3ADwy4JRbkuOcz7GW021VPNutHwcvS+EZa4ZhDATpN5r2YLdEZGQkoqKidKasDQkJwdChQ1G7dm2MGDECQ4YMkX976RvsHjdunF5bMjMzFb9VKttgd2ly4voD/HLsFgBg1iuNYWpcovOQZc6Ml/xw+Op9XIxLwTd7r2BC13rlbVKlpdiO9YkTJ/DCCy/If0vrowcNGoTVq1dj4sSJSEtLw/Dhw5GYmIjnn38eYWFhipE3hmGeHSk12g8//KA4Pnz4cHm/cePGcHd3R+fOnXH16lX4+PiUmj364iVUFqQgWWbGakUuaEtTw5ckP9KRB5r+nW7Agdck2821bOfgZQzDGBIajQbjxo1D27ZtFYPdlJUrV6Jhw4Z47rnnFMdnzJiBTp06wdLSEjt37sSoUaOQmpqKsWPHAuDB7rIkO1eDTzbn5azu28ITrbx1D5JUJBytzTCjjx9GrzuFZXuvoJuvKxpVtyv8RKbYFNux7tixY4FpZVQqFWbMmKEInMQwTMmSkJAgz9jTgGm6aN26NQDgypUr8PHxgZubG44dO6YoI8VFkFQXbm5uOmMl2Nra6nyBA3nKDO0gcpUJyXGmMnDgyXprQw4Apk9O/WSNteE6p7KM3UQ5YyD1u7TunWEYpjwJCQnB2bNncfDgQZ2fp6enY926dfj000/zfUaPNWvWDGlpafjiiy9kx/ppqOyD3aXFir+jceluChysTDGpR8PyNqfE6NnYHdsaxWLH2Th8uPE0/gxpW+Fn4g2Rco8Kro+MjAyo1WqFZJbKmunIHY1YTaXc2j/ytdezSCQkJMj7VHJLobJmGoWcypqpXJqWpwMR1AYq9QWU0mvaJhoVnMq/6bWohFhf9HR6fSoPovJoei5tA5VNa0OlzLRvqEqB1kHl1dQOKiO3t7eX92lfUDv0RWoHoNf5o8epPJvWTfuJPg/0fumTgtP7QJ9X7cEo+je9Fu1/GnlckpcJIZCamor09HQ4OTnlc351ERUVBQBwd3cHAAQGBmLWrFmIj4+Hi4sLACAiIgK2trbw9fWVy2zfvl1xnYiIiCodKyFNK4e1hKVZBQhepm+NtSwFrwCDAlq22/Iaa4ZhDITRo0dj69atOHDgADw9PXWW2bhxIx49eoSBAwcWer3WrVtj5syZyMzMhJmZGQ92lxG3HjzCkt3/AQAmv9gQ1axMCzmj4qBSqTCjTyMcuXYfF2KTEbrvKt7rUre8zap08FAFw1QgkpOTkZaWBkdHR9kJv3v3rrwO/erVq5g5cyYiIyNx/fp1/PXXXxg4cCDat2+PJk2aAAC6desGX19fvPXWW/j3338RHh6OKVOmICQkRH4JjxgxAteuXcPEiRNx8eJFLFu2DL/99hvGjx9fPg03AKS1vNZaM9ZWFSBl1SM9M9aSs5phwMHL5DXWJlpKARIVvCAVFcMwTGkhhMDo0aOxefNm7NmzR29qLSBPBv7SSy/B2dm50OtGRUWhWrVq8js5MDBQERgY4MHukkYIgal/nUNGtgatvR0Q3LxgNWBFxNnGDNNe8gMAfL3nMs7H8Lr7koYda4apQDx69AhCCMTHx8sz9vXq1cOvv/4KIG/2fNeuXejWrRsaNGiA999/H8HBwdiyZYt8DSMjI2zduhVGRkYIDAzEgAEDMHDgQMXyDW9vb2zbtg0RERHw9/fHggULsGLFiqqdwzpD94y11eMZa0NeY52hZ8ba0sTwBwX0zbZL9yE7VyCTo5wyDFMOhISE4Oeff8a6detgY2ODuLg4xMXFKYKuAnlLsQ4cOIChQ4fmu8aWLVuwYsUKnD17FleuXEFoaChmz56NMWPGyGV4sLv0CTsbhz0X42FipMKsVxpXuJzVReUlfw9083VFzuMo4dm5/P4sSQxWCq5SqaBSqRQyWyqZpZJvKpmlsmkaQVq6pgSVAdMo0DTSNJXXUMk33adRuqlkmcpv6GwKrVdbdk6l01R2TKNLZ2RkyPu0rdRWKkGmNumLNE5tpX3p4eEh79etq5SLXLt2Tec+PZ/aSiXc1FZ6nLZfO4q2Llup/Ft7xopel/YftY/K6qmt+qJx07rpPn0uaX/TqKDacixqh75InfR+Sc+7g4ODbJ8QAklJSUhKSpKfyRo1amD//v06r0fx8vLKJ/XWpmPHjjh16lSh16oqpOqTgssz1obrWOuLrG1uqpY/F0IY5A+JJzPWynFgSSkA5AUw0w5uxjAMU9qEhoYCyHtfUlatWoXBgwfLf//www/w9PREt27d8l3DxMQES5cuxfjx4yGEQJ06dbBw4UIMGzZMLiMNdo8fPx5LliyBp6dnlR/sLklSMrIxbUteutERHXxQx0X30tHKgEqlwuevNMLR6Ac4F5OMb/dfxehOLAkvKQzWsWYYhjEkCpuxNuQ81pLTnz94WV5bhAAyczQG6Zym64lorlarYG1mjNTMHKRm5sDZhtcSMgxTthR1Gcrs2bMxe/ZsnZ91794d3bt3L/QaPNhdeiyM+A93kzPh5WiJkBfqlLc5pY6LjTmmv+SHcb9GYcnuy+jq64b6bjaFn8gUCkvBGYZhioC+NdaSc2rIwcsyHqfT0pduCzBcObg0Y21umt/pt+EAZgzDMMwzcPZOEtYcug4AmNmnkUEOMJcGfZp6oEtDF2TnCnyw4V/ksCS8RDDYGevatWvD2NgYcXFx8jEqIabREakkmsqJqbwXUEavpnJuWo6OPlK5Lo12XbNmTXm/oMjPutAnLweUsnJ6LSrPpPXRdtNo1LSdNMq0vkjjtN6GDZ+kFnjppZfkfe2AHJcvX5b39+3bJ+9fuHBB3qf9R+2j94hK/am8n7aBlomOjtZ5He1gIFSeTcvRdU9UIk5l1/pk5FQ+T/uPysWldFWAUuKtHVWd3kd9knQalZ0+K5IUXKPRKO4dU7o8iQquXGJSEdJtSc6ppZZzaqRWwdRYjawcjVzG0EjXE3gNeNL3KRmccothGIYpHrkagcmbz0AjgN7+Hmhfr/DAcpUFlSpvLfmx6P04cycJ3x64ViVm60sbnrFmGIYpAtKsqHYea8lZTTPgNdaSFFzXSLyh57KWAq9pDwoAT9QDKQasFmAYhmEMk58OX8fp20mwMTfGp70qT87qouJqa46pvfOihC/ZdRmX76YUcgZTGOxYMwzDFAF9wcuszAxbCq7RiCdScB3OqTQTnJ5lmDKwos1YG2bfM5WTffv2QaVSYePGjeVtSqmhUqkwbdq0Erue1GdU4cYw5UlcUga+3JmXs3pi9wZwsTEv5IzKyavNq+OF+s7IytXgg42nWRL+jBisFPzatWtQq9Wws7OTj1H5Nz1OozhTqa+21JrKd6nEl8p0qfyW4uLiIu8nJCTI+1QGTOXHNCI5lRDT61OptPY51D4qi6ZlaN20Dfoim3t6euosU61aNXm/QYMG8n6dOk8kIc2aNVPYSiOpnz9/Xt6XUkABwI0bN+R9er+oJJ1CI2fri2ZOy1AJtfZ9o89EWlqavK/vflFpNj2XSulpGbpP+/jOnTvyPu1X7Wfx5s2b8j59DqhsnT4DtD+kZQLUTqb0kWZFrfQ61oYppaapqHQ5p5KzbahRzeU11jpslyKDG+psO6OfAQMGYOPGjTh9+jTq1aun+Gzu3LmYNGkStmzZgl69emHw4MFYs2ZNgdfz8vLC9evXS9FipixYvXo1hgwZIv9tZmaGmjVrolu3bvj000/h6uoqf3b9+nVMnz4dBw4cwJ07d2Bvb4969erhhRdewPTp0+VyHTt21Jst48KFC4rfPUzVYebW80jNzEHTGvZ4s1XNwk+opKhUKsx5tQm6LtqPf28lYsXBaIzo4FPeZlVYDNaxZhiGMSRSH6/jzTdjXUEcU0CPY/342CNDXWOtJ481PSbNyDMVh4ULF2L79u0YMWIE9uzZIx+Pjo7GjBkzEBwcjF69egEA3n33XXTp0kXndXbv3o3Vq1ejTZs2ZWI3UzbMmDED3t7eyMjIwMGDBxEaGort27fj7NmzsLS0xJUrV9CyZUtYWFjg7bffRq1atRAbG4uTJ09i3rx5CscayJtYmDNnTr56aFpRpuqw91I8tp2JhZFahVmvNIJabXipJssSNztzfNrLFxM3nsbCiP/QpaFrpU45VpqwY80wDFMEJCl4/jXWj2esDTR4meTwmxmrdf54kNYuZxio/QVJwc0f57bOMNBBAUY/Li4umDdvHoYPH441a9Zg0KBBAIBRo0bBxMQES5YskcsGBgYiMDAw3zViY2MxYcIEeHl5yfmEmcpBjx490KJFCwDA0KFD4ejoiIULF+LPP//EG2+8gUWLFiE1NRVRUVHw8vJSnEuDzUrY2dlhwIABZWI7Y9ikZ+Xi0z/OAgCGPFcLfh52hZxRNXgtwBPbTsdi/3/38OHGf7FxxHMwquIDDk+Dwa6xVqlUUKlUyMnJkTdbW1t5S0lJkTeprEqlglqtljeNRqPY7ty5I2/JycnyRs8xMzOTNwotY21tLW+PHj2SN1omOztb3kxNTeWNnpuRkaHYhBDyZmVlJW8PHz6UN3t7e3nTV7eFhYW80eunpqbKG+2z3NxceaPlaV+kp6crNto+V1dXeTMxMZE3eu9o3bQN9NysrCx5o/eNto32i7GxsbzRunJychS20/43NzeXNwcHB3mj94WWd3R0lDd63NLSUt4SExPljZanfXTz5k3F5uLiIm+0X+m9oPdXXxuYskOSeuvPY22YM9aS06lrxjfvuGFHNdeXxxoAzIwfrw9nx7pCMnToULRt2xYffPAB7t+/j/Xr1yMsLAyff/45qlevXuC5Go0Gb775Jh4+fIh169Yplt7oIiUlBePGjUOtWrVgZmYGFxcXdO3aFSdPnpTL1KpVC4MHD853bseOHdGxY8d8x3NzczF58mS4ubnBysoKL730Em7duqUoc/nyZQQHB8PNzQ3m5ubw9PREv379FBkdVq1ahU6dOsHFxQVmZmbw9fXVOVBQq1Yt9OrVC/v27UOLFi1gYWGBxo0by+uWN23ahMaNG8Pc3BwBAQH5ch4PHjwY1tbWuHbtGoKCgmBlZQUPDw/MmDGjSFlN7ty5g7fffhuurq4wMzODn58ffvjhh3zlbt++jZdffhlWVlZwcXHB+PHjFUuvnoZOnToBeJIZ5OrVq/D09MznVAPKpXsMo81Xey7j9sN0eNiZY3zXeoWfUEXIk4Q3hrWZMU7dTMQPB6MLP4nJB89YMwzDFAEppZN2Hmsrkm5LoxEGJymTgpJZ6snNafF41tdQndP0AgYGpHXXLAWvmKhUKnz77bdo1qwZRo4cib///hstWrRASEhIoefOnDkTe/fuxaxZs/Dcc88VWn7EiBHYuHEjRo8eDV9fX9y/fx8HDx7EhQsX0Lx586eyf9asWVCpVPjoo48QHx+PxYsXo0uXLoiKioKFhQWysrIQFBSEzMxMjBkzBm5ubrhz5w62bt2KxMREOfZIaGgo/Pz88NJLL8HY2BhbtmzBqFGjoNFo8vXFlStX0L9/f7z77rsYMGAAvvzyS/Tu3RvLly/H5MmTMWrUKADAnDlz0LdvX1y6dEkRKyQ3Nxfdu3dHmzZtMH/+fISFhWHq1KnIycnBjBkz9Lb17t27aNOmDVQqFUaPHg1nZ2fs2LED77zzDpKTkzFu3DgAeXFuOnfujJs3b2Ls2LHw8PDATz/9pJD7Pw1Xr14FADg6OgLIW1O/a9cu7NmzR3a6CyI3N1cRHwfIi2lCY7gwlZ//7qbg+wPXAADTXvLLFzOlquNhb4EpPRvi401n8OXOS+jc0AW1nfl/pDjwE8UwDFMIQognUvB8a6yf/J2enWtwL2o51ZaeGWtLOQCYYTrWBc24S7PYGTmGaTtTOH5+fvjggw8wZ84cGBkZYdu2bQpHUBf79+/HzJkz0blzZ3z88cdFqmfbtm0YNmwYFixYIB+bOHHiM9n+4MEDXLhwQQ6k2bx5c/Tt2xfff/89xo4di/PnzyM6OhobNmzA//73P/m8zz77LF97aBDM0aNHo3v37li4cGE+x/rSpUs4dOiQLI339fVFUFAQhg0bhosXL6JmzbwgTNWqVcO7776LAwcOKGbbMzIy0L17d3z11VcA8qT3vXv3xrx58zB27FhFYFLKJ598gtzcXJw5c0Z2bkeMGIE33ngD06ZNw7vvvgsLCwt89913+O+///Dbb7/htddeAwAMGzYM/v7+xerbpKQkJCQkICMjA//88w9mzJgBCwsLed392LFj8dNPP6Fz585o2rQpOnTogBdeeAFdu3ZVBCmVuHjxIpydlTmKBw0ahNWrVxfLLqbiotEIfLL5DHI0Al0auqKbn1t5m2SQvN6yBradicXflxMwceNp/PpuIEvCi4Fh/QIkmJqaQq1WK+RD9GVLRxnv378v79PI39pRk2lkagqVZNFoz/Ra+q5LX0I00ra9vb28T9f7ULkajfatbQeN8k3tpmVoNGm6T8vTlzW1W6V68k+SkvIkbx2N8H3w4EF5XxotlqAjv1RuRu8F7Ut672gEbxrpnUqbafTzxMREeV/fS187wvrDhw/lfSpx0xd5nL6I6bn0nur7sZecnCzv0z6mNjk4OCjOoXbok3TTfqLPn9Sv9B4ypUt6di40jx8jbcfZ3EQNtQrQiDw5uKE51gWtUQaezPpWRCm4vMbaQG1niob0ve7h4YFGjRoVWDYhIQH9+/eHo6Mjfv7550KdcAl7e3scPXoUMTExJRawauDAgYrsFP/73//g7u6O7du3Y+zYsfK7ODw8HC+++KJOhw9QvqeTkpKQnZ2NDh06IDw8HElJSYp3uq+vr2K9eevWrQHkSaUlp5oev3btWj4Z++jRo+V9aQZ627Zt2LVrF/r165fPPiEEfv/9d/Tt2xdCCMX7PygoCOvXr8fJkyfRtm1bbN++He7u7oqBBEtLSwwfPrxYAxnaweq8vLywdu1aeYmAn58foqKiMHPmTGzduhVRUVFYsmQJrK2tsXDhQgwbNkxxfq1atfD9998rjnHgsqrFhshbOH79ISxNjTC9j195m2OwqFQqzA1ugm4L9+PEjYdYfeg63nneu7zNqjAY7BprhmEYQyH1cZ5klepJsC8JlUolz1obYgAzacZX224J6bghSsGFEIUEL+MZ64rOrVu3MHXqVDRq1Ai3bt3C/Pnz9ZYVQmDgwIGIjY3Fjz/+CDe3os84zZ8/H2fPnkWNGjXQqlUrTJs2DdeuXXsm2+vWrav4W6VSoU6dOnLaL29vb0yYMAErVqyAk5MTgoKCsHTpUsUAOQD8888/6NKlC6ysrGBvbw9nZ2dMnjwZAPKVpc4z8GQgvUaNGjqP04FiIG+AuHbt2opjUrozfenK7t27h8TERHz33XdwdnZWbFJqLGkC4caNG6hTp06+gd/69evrvLY+li5dioiICOzduxfnz5+X14Vr2/3TTz8hISEBp0+fxuzZs2FsbIzhw4dj165dirJWVlbo0qWLYvP19S2WTUzF5X5qJubsuAgAGN+lHqrbWxRyRtWmur0FJvdsCAD4IvwiriekFXIGI8GONcMwTCFIMnBrM2OdSgFLAw5gJs1E68oDDRDH2gDThWXmaGSlgC4puwWvsa7wSLOnO3bswGuvvYZZs2bpdXi//PJL7NixAx988EE+J6sw+vbti2vXruHrr7+Gh4cHvvjiC/j5+WHHjh1yGX0qoNzcpx+4WbBgAU6fPo3JkycjPT0dY8eOhZ+fH27fvg0gTw3WuXNnJCQkYOHChdi2bRsiIiIwfvx4APmVd1QJVpTjRQlKVhiSDQMGDEBERITOrW3bts9cD6VVq1bo0qULOnbsiIYNGxaoTDAyMkLjxo0xadIkbN68GQCwdu3aErWHqdjM3n4RiY+y0dDdFkPa1ipvcyoE/VvVxHM+jsjI1mDixtPQaJ79u6QqYFiaRYKpqSmMjIwUMmAKlVRRKa2tra28r51ygb54qNSYysrp6K4+GTWV/uqTONMyVM5OJVTaQTNo3VReRm2l0mTabloH7Rvaf7Rv7ty5I+/TttG6/vrrL3nf3d1dYeu9e/fkfTrKTa9F20f7Iz09Xd6ncngqd6blaXu0Jd8S2j8qaFv1laP9Z2pqqtNu2h4q36Y/wOisCb0ObQOVnQPKdtDnjF6XysepHdIzp/2Diyk99K2vlsibsc40SMe6qFJwQ5yxzigkB7eZFHjNAJUCTOFs3rwZf/31FxYtWgRPT08sXrwY4eHhCAkJUTi8AHD06FF88sknaN26NWbNmvVU9bm7u2PUqFEYNWoU4uPj0bx5c8yaNQs9evQAkLdUS9dvjhs3buSb5QXyIn5ThBC4cuUKmjRpojjeuHFjNG7cGFOmTMGhQ4fQtm1bLF++HJ9//jm2bNmCzMxM/PXXX4rZ6L179z5VGwtDo9Hg2rVr8iw1APz3338A8uTSunB2doaNjQ1yc3P15hOX8PLywtmzZyGEULzPLl269OzGFwEpRVdsbGyZ1McYPoev3sfvJ29DpQJmvdIIxkY8p1gUVCoV5gU3QdDiAzh2/QF+PHwdg9uyJLwwivV0zZkzBy1btoSNjQ1cXFzw8ssv5/uyzMjIQEhICBwdHWFtbY3g4GDFOlqGYZiKhiQF144ILkEjgxsa8hrlQqTgBmn7Y8faxEgFEx0/hlgKXnFJSUnB2LFj0axZM4wZMwZA3prXmTNnIiwsDBs2bJDLJiYmol+/frC0tMQvv/yiGAAuCrm5ufkk1S4uLvDw8FAMSvv4+ODIkSOKQfKtW7fmS6El8eOPPypilGzcuBGxsbGyo56cnJxvMLhx48aK+DHSYC+dWU5KSsKqVauK1cbi8M0338j7Qgh88803MDExQefOnXWWNzIyQnBwMH7//XecPXs23+d0oP3FF19ETEwMNm7cKB979OgRvvvuuxJsAfD3338rYtFIbN++HUDxpedM5SQzJxef/HEGQN4MbPOaBaflY5TUcLDEpB4NAADzwi7hxn2WhBdGsWas9+/fj5CQELRs2RI5OTmYPHkyunXrhvPnz8szj+PHj8e2bduwYcMG2NnZYfTo0Xj11Vfxzz//lEoDGIZhSpuUxzPR+gKTSc5pmgHKqSXHWt8aa2km2BBnfdMLkbGzFLziMmXKFMTExGDTpk0KJVFISAjWrFmDcePGoXv37rCxscGIESNw/fp1vP766/jnn3/0/p4YMGCAzuMpKSnw9PTE//73P/j7+8Pa2hq7du3C8ePHFVHChw4dio0bN6J79+7o27cvrl69ip9//hk+Pj46r+vg4IDnn38eQ4YMwd27d7F48WLUqVNHDpy1Z88ejB49Gq+99hrq1auHnJwc/PTTT7KjCgDdunWDqakpevfujXfffRepqan4/vvv4eLiUiqzrubm5ggLC8OgQYPQunVr7NixA9u2bcPkyZPzRc2mzJ07F3v37kXr1q0xbNgw+Pr64sGDBzh58iR27dqFBw8eAMiLAP7NN99g4MCBiIyMhLu7O3766Se9gduelnnz5iEyMhKvvvqqrBA4efIkfvzxRzg4OMjpv5iqzbf7r+HavTQ4WZthYvcG5W1OheTN1l7YdiYWR649wEe/n8a6oW0MLq2oIVEsxzosLEzx9+rVq+Hi4oLIyEi0b98eSUlJWLlyJdatWyfnFVy1ahUaNmyII0eOoE2bNiVnOcMwTBkhz1jrk4JLM9aZBuicZhfinBpw8LKiytgzDdB2Rj+RkZFYunQpRo0ahZYtWyo+MzIywvLly9GmTRtMmTIFS5YswZEjRwAAv/76K3799Ve919XnWFtaWmLUqFHYuXMnNm3aBI1Ggzp16mDZsmUYOXKkXC4oKAgLFizAwoULMW7cOLRo0QJbt27F+++/r/O6kydPxunTpzFnzhykpKSgc+fOWLZsmexE+vv7IygoCFu2bMGdO3dgaWkJf39/7NixQ/49VL9+fWzcuBFTpkzBBx98ADc3N4wcORLOzs54++23i96pRcTIyAhhYWEYOXIkPvzwQ9jY2GDq1Kn5UoBp4+rqimPHjmHGjBnYtGkTli1bBkdHR/j5+WHevHlyOUtLS+zevRtjxozB119/DUtLS7z55pvo0aMHunfvXmLtmDx5MtatW4f9+/dj7dq1ePToEdzd3dGvXz98+umn8PZmyWpVJzohDd/svQIA+LRXQ9hZFE/pwuShVqswP9gfQYsP4Mi1B1h79AbeCqxV3mYZLM+0xlqSVklrQSMjI5Gdna1Yg9OgQQPUrFkThw8f1ulYZ2ZmKqRY0rrUR48eQa1WK0Y509LSFOdJ0LWvdA2y9ggpXZNKZWEuLi4620evS2VadC0wlaRRyRddW0TX8tIgKNqBUuj6XCpFo6m7qPSJ7tNzqSyLrtWmbaDriOlaXtrHdO10QWuE6bXo+mkKXYtOU4fQ6+pLQUX7mK5Dp+uztUfa6f2lzwTtV9pn1G7aHnqvqeRPX120v+ksjPZ6enpdulSCnk/vBT1fsvtZAuowxUNeY61HCi7NBqdWwDXWFgacbqugHNbAk3RbhjgowOgnICBAb7wMAGjZsqXi+01ftOqiYmpqivnz5xcYcVxiwoQJmDBhguLYvn37FH937NhRfp/269cPs2fP1nktb29vrFy5stA6e/fujd69e+c7LkXcltDXD7oClNWqVUtv4LLatWsjPDy8QJt0nevi4oJvvvlGISXXRc2aNfHnn38W6ZraDB48GIMHDy603HPPPYfnnnuu0HJA/vvHVH6EEPjsz7PIytHg+TpOeMmfU6s9CzUdLfFR9/qYtuU85uy4iI71XVDDoWRVKJWFp17Br9FoMG7cOLRt21bOOxkXFwdTU1OFIwjkjXTGxcXpvM6cOXNgZ2cnb9opIxiGYcobyWGW0mppYy2vsTY8x7rwdFvGinKGxKMCclgDZI21AdrOMAzDlA9//RuDvy8nwNRYjc9fbqQ34j9TdAYG1kKrWg54lJWLj34/XSIZByojT+1Yh4SE4OzZs1i/fv0zGTBp0iQkJSXJm74gIQzDMOVFYeuULQ04j3Vh6bYsDDl4WSGB13iNNcMw5UlRgvp27NgRKpVKsY0YMUJR5ubNm+jZsycsLS3h4uKCDz/8MJ+qY9++fWjevDnMzMxQp04drF69urSbVyFJSs/GzK0XAACjX6iDWk5WhZzBFAW1WoX5/2sCcxM1Dl29j3XHbpa3SQbJU0nBR48eja1bt+LAgQPw9PSUj7u5uSErKwuJiYmKWeu7d+8qUhJRzMzMFBJgiUePHkGlUikks1SyTKXFVHJL5WP0XEAp2aWSYLrv6uoq72dkZMj7VHpO0yPR41SaTUfH6HWoZJmmvAKUUmgq/aXXpe2msmFaB5VXU/k7lRbrk0HT6zs6Osr7NHWU9vm0//RJuOlx2n9U2k3tozJ+2pe0X2hfar+A9MnhaT9RSTptHy1Dny1qhz5bqR20X7VVHDSlC70ulZvT511XeU63VXZkFLJO2cqA81gX1Tk1SMe6EBm7GZGCa6f3YRiGKW2KEtQXyAvqNmPGDPlv+rshNzcXPXv2hJubGw4dOoTY2FgMHDgQJiYm8jKD6Oho9OzZEyNGjMDatWuxe/duDB06FO7u7sXO6V7ZmR92EQmpmajtbIV3O+RPk8c8PbWcrPBhUAPM3Hoes7ddQNeGrnCxNS/8xCpEsWashRAYPXo0Nm/ejD179uQLDhEQEAATExPs3r1bPnbp0iXcvHkTgYGBJWMxwzBMGSOlczLT61g/nrE24OBl+mfbDVdOnVHE4GUAkJnDA00MUxCrV6/OFy+FeTbCwsIwePBg+Pn5wd/fH6tXr8bNmzcRGRmpKGdpaQk3Nzd5s7W1lT/buXMnzp8/j59//hlNmzZFjx49MHPmTCxdulSeuFi+fDm8vb2xYMECNGzYEKNHj8b//vc/LFq0qEzba+icvPlQnkmd9XJjmBnrfncwT8/g52qhcXU7pGXl4q9/Y8rbHIOjWI51SEgIfv75Z6xbtw42NjaIi4tDXFycPDNnZ2eHd955BxMmTMDevXsRGRmJIUOGIDAwkCOCM0wJkJ6ejpiYGNy4cQO3b98GAFy+fFlRpii55Fl2VjwkqbE+B89KllMb8Ix1oVLwHINbMyWn2ypkth0AMlkOzjBMOaMd1Fdi7dq1cHJyQqNGjTBp0iRFUNXDhw+jcePGCsVkUFAQkpOTce7cObkMDQwslTl8+LBeWzIzM5GcnKzYKjM5uRp8svkshABebV4dgT6OhZ/EFBsjtQqvtchTK287U/IpASs6xZKCh4aGAshbL0JZtWqVHMVx0aJFUKvVCA4ORmZmJoKCgrBs2bJiG1atWjWo1WqFLFfKkwgoJcu6pOSAUooMKKW5VKJDpdZUskyl5FT6S49TOS6tj9pNbaU2UCmy9nX1SdX1yY6p3fQ4vSYdqabSZHp9Wp5+8dP+0v6M1k3bSmX51G765U6lm3SftoHKxel1qNxbGyo3p/Jxer/ovaDtpvv02aLn0mtS+TZ9Bug+7WNAKe2mUempY6Pr/qampsLc3Bw2NjbQaDR4+PAhXnnlFVy4cKHIueRZdlZ8nqSs0j0WKa2xNuSo4IWtsdYIICtXY1Aj/OmFDGiYGKlhpFYhVyOQnp0LO3A6FYZhygddQX0BoH///vDy8oKHhwdOnz6Njz76CJcuXcKmTZsA5AX+pU418GRZohT4V1+Z5ORkpKenK37zSMyZMwfTp08v0TYaMqv+uY4LscmwtzTBJy82LG9zKjXdG7lh6l/ncOpmIu4kpqO6ff7nr6pSLMe6KLMZ5ubmWLp0KZYuXfrURjEMoxsnJyfZ4ZYc/Vu3bhUrl7wkO9u1axdcXV3RtGlTzJw5Ex999BGmTZsGU1NThewMABo2bIiDBw9i0aJFVdKxzix0jbUUFdzw5NRFTbcF5M0QG5ZjXbDtAGBurEZaVq5BStkZhqk6SEF9Dx48qDg+fPhweb9x48Zwd3dH586dcfXqVfj4+JSaPZMmTVKkjktOTq60mXfuJKZjYcR/AIBJPRrA0Vr3hBtTMrjYmKNVLQccjX6AHWdiMbQdr2WXeOqo4AzDGA5FzSUPsOzsaZCk4PpmrCtC8DJLPanCTIzUMDHKU4sY2sBA+mNpvb714cCTGXdpHTzDMExZIwX13bt3ryKory5at24NALhy5QqAvMC/2su1pL+lwL/6ytja2uqcrQbyFHe2traKrbLyRdhFpGfnomWtangtoHIOHhgavZq4AwC2nmY5OOWpooKXBcnJyVCr1QppMZXf6otqXVCkZBrhmUIluwkJCTrroJGlaR1UBk3lvfQLTJ9cXBt98mq6TyXFtDy9LpUyU0m6Pqk67RdqK5V/a6+/pe2j16Loi7RN1x7pk4LTttG+p7J9WoY+J4BSZk9tp/eUtpX2Ge0nWh/tJyqr1ydhpwoPaiugjLhOr+Xk5CTvUwk87TOpjtzcXNy7dw9t2rQpVi55lp0VHzkquJ7ZXMlpNTTHFCCzvqb6x1EtTIyQnZsjlzUUCpOxA5Bn2DnlFsMwZY0QAmPGjMHmzZuxb9++fEF9dREVFQUAcHfPc0wCAwMxa9YsxMfHy0vDIiIiYGtrC19fX7nM9u3bFdeJiIjgwMDIG9AOO5f322Xyiw2hVnN2iLIg6LEcPOpWIm49eIQaDpaFn1QF4Blrhqmg3L9/HwDwww8/lLMleVTmnPTSbKi+IFoVYca6IOdUmvVNN7CBgfSsx2usC5ixllQEhmZ7ZWPp0qWoVasWzM3N0bp1axw7dqxEr3/gwAH07t0bHh4eUKlU+OOPPxSfCyHw2Wefwd3dHRYWFujSpUu+wI1PS1FyERclKGRxCQ0NRZMmTeTZxMDAQOzYsaNU69TH3LlzoVKpMG7cuFKvf9q0afnyOjdo0KDU6wXy0pwOGDAAjo6OsLCwQOPGjXHixAn58+I+Z4UF9b169SpmzpyJyMhIXL9+HX/99RcGDhyI9u3bo0mTJgCAbt26wdfXF2+99Rb+/fdfhIeHY8qUKQgJCZHjvIwYMQLXrl3DxIkTcfHiRSxbtgy//fYbxo8fXyL9UpHZczEeGdkaeDlaomkN+/I2p8rgYmOO1t55k0Q7zvKstQQ71gxTAbl37548C169enX5OM0lT6G55Fl2Vnxk51TPjLXV4xnrNAOLCp6rEXIaKn1ScPqZoc1YF5ZuC3gyYMBS8NLj119/xYQJEzB16lScPHkS/v7+CAoKQnx8fInVkZaWBn9/f73xWebPn4+vvvoKy5cvx9GjR2FlZYWgoCC9iqniIOUiPnLkCCIiIpCdnY1u3bopgpaOHz8eW7ZswYYNG7B//37ExMTg1VdffaZ6PT09MXfuXERGRuLEiRPo1KkT+vTpIy/JKY06dXH8+HF8++23sqMnUZr1+/n5ITY2Vt7ouuTSqvfhw4do27YtTExMsGPHDpw/fx4LFixAtWrV5DLFfc5CQ0ORlJSEjh07wt3dXd5+/fVXAHkquV27dqFbt25o0KAB3n//fQQHB2PLli3yNYyMjLB161YYGRkhMDAQAwYMwMCBAxV5r729vbFt2zZERETA398fCxYswIoVK6pkzBNttp7OS/nUs7G7QkHIlD49H8vBt7EcXMZgpeBCCGg0mgLlyLqgX35USgsANWvWlPel2T6pLgkquaVSZhodOjMzU96XUisA+iNFUykzdXgkJ0aCtpVKvml91FZ6XSplpjZRSTT9kUD3qaNEpc/UMaISakAZkZt+RuXSVJ5NI19TWTS11cPDQ+e5tLyzs7O8T6PEa0eGp/1Hr0WfIfqs0AjmtI9p2/Qdp5HK6bIEeq+1U2/QcrT/tR1ibYQQuHfvHtLS0uDm5oY7d+4oPqe55IODgwHkzyXPsrPiU/gaa2O5XK5GwMhApGg0oFdBzqn0maFJ2YsSvEz6LNPABgUqEwsXLsSwYcMwZMgQAHk5dbdt24YffvgBH3/8cYnU0aNHD/To0UPnZ0IILF68GFOmTEGfPn0AAD/++CNcXV3xxx9/oF+/fs9Ud1hYmOLv1atXw8XFpVhBIZ+G3r17K/6eNWsWQkNDceTIEXh6epZKndqkpqbizTffxPfff4/PP/9cPl5abZYwNjbO9xuotOudN28eatSogVWrVsnHqHT7aZ6zwoL61qhRA/v37y/UNi8vr3zvXG06duyIU6dOFXqtqkRKRjb2Xsr7PdqriUchpZmSpnsjN3z251n8ezuJ5eCP4RlrhqlAxMfHIzU1FS4uLvLI7N27d4uVS55lZ8UnM6dgOTUNrmVIs9Z0BtrMuIA11rIU3HBsBwrPYw08uSeGNtteWcjKykJkZKQimKFarUaXLl0KDGZYkkRHRyMuLk5hg52dHVq3bl0qNmjnIi5KUMhnJTc3F+vXr0daWhoCAwPLpE4gT8rcs2fPfMEqS7v+y5cvw8PDA7Vr18abb76Jmzdvlnq9f/31F1q0aIHXXnsNLi4uaNasGb7//nv587J+zphnZ/eFeGTlaFDbyQoN3W0KP4EpUZyszdCmdp4cfDvntAbAjjXDVCgSExOh0WgQGxuL27dvAwDq1asny86AvFzyvXr1QnBwMNq3bw83Nzc5XybAsrOn4cmMtW4Hz8xYDWmS2pDW+kq2WJgYFRjQRRoYMDTn9NFjeywLlILnvcY4eFnpkJCQgNzcXJ3BDKVgh6WNVE9Z2KArF3FRgkI+LWfOnIG1tTXMzMwwYsQIbN68Gb6+vqVap8T69etx8uRJzJkzJ99npVl/69atsXr1aoSFhSE0NBTR0dFo164dUlJSSrXea9euITQ0FHXr1kV4eDhGjhyJsWPHYs2aNQDK9jljSgZJBt6rCcvAywtZDs6ONQADloK7ubnByMhIIeem0mwaKZvKoKlEl66bAZQyZbpPpbz65N9U2k2vW5TI0tRWKgHWlhDRtlKb6JcFvS61lR6ndtNr0r6hEnFqN+0XKhfXXi9Lz6cyan3to5GvaX/Q9cEUahOVb9M2U5u0lwlQ+TjtP3q/6IubStup9F7ffdAn+aZ208jf2lHLqfybSvrpmkUqH5fqcHV1lZccaDQaREdHIykpSdEXRcklz7Kz4lHYWl+VSgULEyODy6f8JCJ4wbmpzQ1UCp6RVbj98hprA+p3puKiLxdxaVG/fn1ERUUhKSkJGzduxKBBg4okHX5Wbt26hffeew8RERGKd3JZQCX/TZo0QevWreHl5YXffvtNbwyPkkCj0aBFixaYPXs2AKBZs2Y4e/Ysli9fjkGDBpVavUzpkJSejQP/5WXy6cky8HKju58bPv3jLE7fTsLN+49Q07Fqy8F5xpphGKYAsnM1yNHkDRLpW2MNEDm1ATl4dMa6ICwNNSp4EdJtsRS8dHFycoKRkZHOYIa61siWBlI9pW2DvlzERQkK+bSYmpqiTp06CAgIwJw5c+Dv748lS5aUap1AnuQ6Pj4ezZs3h7GxMYyNjbF//3589dVXMDY2hqura6nWT7G3t0e9evVw5cqVUm23u7u7HEdEomHDhrIMvayeM6ZkiDh/F1m5GtR1sUZ9N5aBlxeO1mZ4zicvVSzPWrNjzTAMUyB0JrRIDp4BOadPHNOCv+oN3bEuOCo4S8FLE1NTUwQEBGD37t3yMY1Gg927d5dZMENvb2+4ubkpbEhOTsbRo0dLxAYhBEaPHo3Nmzdjz549+XIR06CQEtpBIUsKjUaDzMzMUq+zc+fOOHPmDKKiouStRYsWePPNN+X9smpzamoqrl69Cnd391Jtd9u2bfOlUfvvv//g5eUFoPSfM6Zk2SbLwHm2urx5IgePKWdLyh+DlYI/ePAAarVaIYelcmcqLaZSZCrd1Y5kTc+hUaOpPJhGiqZSYSqRpqOZ1CYKtZvKyKlUODo6WnEOjXhNJc/6ZNsU2lbaBipBplHHaURtek19MmgqCwf0S7vpvaB9Q/uPyrZp3VReTW2lfUnl5frqApTyamq7k5OTvE/l4lRKTdtN+0Nfug199umTwmtDI3vTdtB92mfSvSssGilTMlCHraAAYE8kyYbj4EmOckGptgAiBTewWd+iSME5KnjpM2HCBAwaNAgtWrRAq1atsHjxYqSlpclRwkuC1NRUXLlyRf47OjoaUVFRcHBwQM2aNTFu3Dh8/vnnqFu3Lry9vfHpp5/Cw8MDL7/88jPXHRISgnXr1uHPP/+UcxEDee9eCwsLRVBIBwcH2NraYsyYMYqgkE/DpEmT0KNHD9SsWRMpKSlYt24d9u3bh/Dw8FKrU8LGxkZeQy5hZWUFR0dH+Xhp1f/BBx+gd+/e8PLyQkxMDKZOnQojIyO88cYbpdru8ePH47nnnsPs2bPRt29fHDt2DN999x2+++47AJDzeJfWc8aUHImPsvD3ZUkG7l7O1jBBfm6Y8sdZnL2TjOsJaajlZFX4SZUUg3WsGYZhDIEMMutbUHAUCwNc61uUGV+gos9YG16/VzZef/113Lt3D5999hni4uLQtGlThIWF5Qvy9CycOHECL7zwgvz3hAkTAACDBg3C6tWrMXHiRKSlpWH48OFITEzE888/j7CwsBJZHxwaGgogL64EZdWqVRg8eDCAvKCQarUawcHByMzMRFBQEJYtW/ZM9cbHx2PgwIGIjY2FnZ0dmjRpgvDwcHTt2rXU6iwOpVX/7du38cYbb+D+/ftwdnbG888/jyNHjsiTC6VVb8uWLbF582ZMmjQJM2bMgLe3NxYvXow333xTLlOazxlTcuw8dxc5GoEGbjao42Jd+AlMqeJgZYrnfBzx9+UEbDsTi5AX6pS3SeUGO9YMwzAFUFiqLQkLA1zrW5R0VQCx3YAc66ycJ2vbixK8zJD6vTIyevRojB49utSu37FjxwJVOCqVCjNmzFBkLygpiqL+KUpQyOKycuXKMq+zIPbt21cm9a9fv77Az0uz3b169UKvXr30fl6azxlTcmwh0cAZw6BnY3f8fTkB29mxNkwcHBxgZGSkiJJMX35UrkslwVS6S6W+2udQqTGVKdNRSSmXJaCUY9Oo4FSuSyXfNPAGrZdKs6n0W/scd/cnXxZUFp6dnS3vU6k6rZv2B5W864vyff/+fXmfypqprdoyaFo3ldLTtlJbKfS+0HtK66AScTpLSNtA5d7a9tHI6PrqoH2jz24qT9cnL6ftoZJ8WkZ7ppP+Ta9L7zWtm94L6RnVaDT5ArwwJU961uNUW8YFO6dmj9f6GpJzWpR0VQBg8VgqbkjOKbWlaDPWhiPBZxiGYUqH+6mZOHQ173crRwM3HIL83PDJH2dxLiYZ0Qlp8K6icnAOXsYwDFMAGTlPpOAFIUvBcwzHOS3KGmXgie2GlG5LknYbqVUwMdIvwX8SvMxwbGcYhmFKh/Bzd5GrEfDzsK2yzpshUs3KFG3r5MUx2l6Fo4OzY80wDFMAGUVI+QSQdFsG5JwWJV0VQNZYZ+cUWK4soanCClrbLikJDGm2nWEYhikdtnI0cIOlV+M8te3W01XXsTZYKXhMTAxUKpVCJktltvSHFpVBW1hYyPva8mAq8aXnUykzjb5M5eJU7ktl4VTuS6+jL5I3lWlTCTaglKRT6S+tm0qcb9++Le9TKTOVEFNptz6pdfXq1eV9Ki2mkazp9QGljJra5+LiorM+eo/oPaX9QaXxtC/pubQMlf1bW+sPXkGl+7Td+qLB66uD3hO6BIBKzfU9P9rR3Gnf6lvi8PDhQ3mf3ndqB1P6SBLjoq6xNqSZ00dyVPCKPChQ8PNuLkcFZyk4wzBMZeZeSiaOXHssA2/M66sNjW5+rpi8WYULscm4ei8VPs5VL7Ac/0JnGIYpgIxiOniGtNY3o4hRwQ1ZCl64UuCxFNyAJPgMwzBMyRN2NhYaAfh72qGmo2XhJzBlir0lkYNX0VlrdqwZhmEKoKhyakOMTp1exDXW0oy2Ic22F7nfjQ1vtp1hGIYpeSSJMcvADRcpr/i2KrrO2mCl4GZmZlCr1QqpNZUfU1k4lX9TmSyV4gJKOa4+ma2+qM76IjfTOqisme5TmbE+CbH231RSTNtHJcT0OD3Xzc1N3qf9QdtG7aPScWofbRutS/tvfRG49cnhqXScRhfXt46S9j21jz4PtL+0oZJ5uhygRo0a8j5tT2zsky8DKs3W9/wlJCTI+7RtVFJOZf6A8j7Sa+l7fuk9kuygUnam9MiUHLxCooIbYrqtR8UcFDCkGetMWYJf8PivmQEGjauMZGZmYs6cOZg0aZLiO78y110V21yedVfFNjNF525yBo5dfwAAeJHTbBksQb5u+MToDC7GpeBKfGqVyzNerBnr0NBQNGnSBLa2trC1tUVgYCB27Nghf56RkYGQkBA4OjrC2toawcHBuHv3bokbzTAMU1ZkFNHBM8To1OlFXGNtaYBrrDOKOaBhSBL8ykhmZiamT5+uiDtR2euuim0uz7qrYpuZorPjTCyEAJrXtEd1e4vCT2DKBTtLEzxfhaODF8ux9vT0xNy5cxEZGYkTJ06gU6dO6NOnD86dOwcAGD9+PLZs2YINGzZg//79iImJwauvvloqhjMMw5QF8jrlIgYAMyTHuqhrrC0NMI/1kzRnhc22G96ABsMwDFOySDJwzl1t+Ej3aFsVXGddLCl47969FX/PmjULoaGhOHLkCDw9PbFy5UqsW7cOnTp1AgCsWrUKDRs2xJEjR9CmTZtiGZabmwshhEJCbG5uLu9TKTc9rk/uDCgly1RGqy9COJXyUhlwfHy8vN+gQQN5n8qMqYSYypeppJdKygFlRG0KPZ/KoqlUmEbOpu2hMnRaNy1DbaWjtVTKTSXbgDJ6OL0uvRZtn6Ojo7xPZdv6JNHUbno8KSlJ3re1tZX34+LiFPbRSOAeHk++hGn/0XOcnJzkfSodpxJuek36/NG+oe2kz8OdO3cU9lG5PpWh0+edLkWgz6503YJSEDElh+RsmhUycyqvsTagWd+irlOWHO8cjUBWjgamxuUffqPoSgHDG9AwRJYuXYovvvgCcXFx8Pf3x9dff41WrVqVt1kMwzCFEpOYjhM38n53cTRww6errytMjFS4dDcFl++moK6rTeEnVRKeeo11bm4uNmzYgLS0NAQGBiIyMhLZ2dno0qWLXKZBgwaoWbMmDh8+rNexzszMVDhz2s4mwzBMeVLcdFuGNOtb3HRbQJ79huFYPx7QKGK/Z+cK5GoEjNQ84KTNr7/+igkTJmD58uVo3bo1Fi9ejKCgIFy6dEnvgC5Fo9HIg4Pl8Y6W6izrusur3qpad0VvsxACKSkp8PDw4LSYJYwkKW5Zqxrc7MwLKc2UN3YWJmhX1xl7LsZj25lYjGPHWj9nzpxBYGAgMjIyYG1tjc2bN8PX1xdRUVEwNTXNN7Pp6uqabzaRMmfOHEyfPr3YhjMMw5QFTyTJFTjdViGOtYmRCkZqFXI1AulZubCzMCmwfFkgD2gUUSmQd04urMwMNiZnubFw4UIMGzYMQ4YMAQAsX74c27Ztww8//ICPP/640PNjYmLg6+sLQBn0sawpr7qrYpvLs+6K3uZ9+/ahQ4cOAIAHDx5g6tSp2LlzJ27evAlnZ2e8/PLLmDlzpkIVqEuB9ssvv6Bfv36K606YMAHnzp1DjRo1MGXKFAwePPiZ7a0IcDTwikfPxu7YczEe28/EYlyXeuVtTplR7F8g9evXR1RUFJKSkrBx40YMGjQI+/fvf2oDJk2ahAkTJsh/Jycno0aNGsjOzoZKpVLIfak8mMq06XEqiaZltD+j8mIqtabXovtUlktlvFSGXqdOHXm/Zs2a8j6V8R49elTep3JqQCkvphJkKk+3tn4SXY9KjfVF9qZf1rQ/aCRrev3q1avL+y1btpT33d2V0hsqhz9+/Li8f//+feiC9iWVO9PRYX2yfyoXp+2hSgcHBwed9QLK+1Kv3pN/bnpd+mzQftW3BIDaQSOh076kSxG8vb0VNtHnid5Tagd9BnTJ/jkqeNlQ5HzKBihJltNtFWK7SqWCpYkRUjJz8ChLf4T9suTJoEAhUcHJ7Ho6O9b5yMrKwokTJ6DRaODh4YHY2Fhs3rwZXbp0weHDh3Weo60kk77jbG1toVKpFO8Y+o6m35H0+5x+j1JnQht6vqurq85r0XcdvRatgy7Joe+G+vXry/v0HUgzQWjPWNLr0neGvmU7tG/0LYei7zd6HQo9Tt8lDRs2lPfpEiZtrly5Iu9fvXpV3qdLj+iyLPpOo+8hWjf9LUPP1ddm7fcyfafRzxo3bizv05le+jxcu3ZN3qf3jj5/1Fa6bIzWS+9VQbPK9JwHDx7I+3S5m5mZGRITE2Fubg5jY2NoNBokJSVhwIABuHjxIqysrBATE4OYmBh8+eWX8PX1xY0bNzBixAjExMRg48aNijpXrVqF7t27y3/Tiaro6Gj07NkTI0aMwNq1a7F7924MHToU7u7uCAoK0tuOysCtB48QdSsRKhXQo5Fb4ScwBkEXX1eYGqnx391U/Hc3BfWqyKx1sX+BmJqayo5KQEAAjh8/jiVLluD1119HVlYWEhMTFV8Gd+/eVTii2piZmXFqA4ZhDBYp7VNhzqnkABqWFDzvx29hM9YAYGkmOdaGYb+sFChkxlqtVsHUWI2sHI1BDWoYCgkJCdBoNPDz88PkyZPlgKKurq64ePGiznP0KclMTU2hVqsVDgmNSUHjUFDHkA5Wag8IUgeNDuDSgWd9aRn1xRChS8/atm0r7zdt2lTep07Y7t275f2DBw8q7Ltx44a8Tx15qsSj16J9Q2N6UGeaQttJ0zXSvqDt6dixo7wvqQgk6OD8n3/+Ke9TB1Uf1A46qELvFy1DHVo6uEwHirXTTNJnonPnzvJ+QECAvE8nJehEBM1AQ51juk+fM2oTPa7vPgDKiQEam4X2AR04MDExkfshKytLrvP27duIjIxE+/bt0ahRI/z+++/yOT4+Ppg1axYGDBiAnJwcRZ/Y29vr/b28fPlyeHt7Y8GCBQDyBlgOHjyIRYsWVXrHWpKBt/Z2gIsty8ArCnYWJmhfzwm7LsRj2+lY1OtaNRzrZ14EotFokJmZiYCAAJiYmCheUJcuXcLNmzcRGBj4rNUwDMOUC08CgBU2c2p4M9YZRRwUAACrx5HBDcWxzizi2naAU24VhXfffRevvPJKkcpOmjQJSUlJ8nbr1q1Sto5hKhcFqeiSkpJga2ubT60QEhICJycntGrVCj/88INicODw4cOKGEYAEBQUpFd1UpnYdoZl4BWVFx8Hmtt2JlbxPFdmijVjPWnSJPTo0QM1a9ZESkoK1q1bh3379iE8PBx2dnZ45513MGHCBDg4OMDW1hZjxoxBYGBgsSOCA3kjgWq1WjFySoOsUEkWlTjTEWJtSRcdSaXSJSp7oiPGVH5LR17pDDuVYknR0AGgefPm8j59mOhou3bU8ps3b+r8jJ5D66ZyKDoKS9umT0JHR3mptInKzHr06CHv16pVS2Erlc7Rvtm3b5/OuulIOr1HtIw+yTeV7euLHE7leoDyWaHyb3qP6Ivv+vXr8j6dQYmKipL3aTtpGyi0nbRt2rM09D7SdlPo/aLnS3ZwVPCyochScAPLBZ2Tq0FWbtEda0uzvDJpmYYlBS9sQEMqk5RuWIMahsIPP/wAIO+7T/reunPnTqFqMoZhiof0W69NmzZo1KiRzjIJCQmYOXMmhg8frjg+Y8YMdOrUCZaWlti5cydGjRqF1NRUjB07FkCeQoIujwDyVCfJyclIT09XSPwlKkNw4Bv303D6dhLUKqA7y8ArHJIc/Ep8Kv67m4r6bpV/1rpYjnV8fDwGDhyI2NhY2NnZoUmTJggPD0fXrl0BAIsWLYJarUZwcDAyMzMRFBSEZcuWlYrhDMMwZUFGEdNtGdqsKZWkF0kK/njGOs1A1lgXNVUYLcOOdX4OHjwIb29vtGnTBh999BGaNm2KadOmwcTERP7Rro0+KbgkA6cyaDqISQcM6Y946hBoDyTS9avU0acDn7qcBkA5oEoHMqkdNMYGlU7TgUu6BpkOpmpf9+7du/I+HcCmg+d08JcOeNP+oAPndNCUDtjSNlN5NB2015aC0zqopJ0OFtMBeXovPD09dbaBDhZT+be+lKV0wJtOVABAixYt5H1994XGeaFOIb0v58+fl/epfJved9oGeh1qK20PoFxyQNtB77W+MqampvIkjTSYpU1ycjJ69uwJX19fTJs2TfHZp59+Ku83a9YMaWlp+OKLL/T+jxaFyhAcWJqtfs7HCU7WvGy0omFrboL29Zyx68JdbDsdg/pu9Qs/qYJTLCn4ypUrcf36dWRmZiI+Ph67du2SnWog7yWydOlSPHjwAGlpadi0aROPiDMMU6Epaj5lybHOytUgV1P+kifJMVWplAG+9GH9OOjXo0zDcE6Lmm4LMLxBDUMiLCwMc+bMwaZNm2TnJCEhASkpKXKUcG1YCs4wxSM1NVVey00HByRSUlLQvXt32NjYYPPmzQpnXRetW7fG7du35UEBNzc3xcAOkDfQY2trq3fgqTL8H2/9N8+x7tmEc1dXVHo1qVpycIMNn2pnZwe1Wq0YgaUj23TUkX5Z0BFL7S8bOkKtLwI3PYfWTUc/aXASKi+naRoaNGgg79PRUjoye/bsWYV9+iJh07r1yYap3bSdtJ/0Be2gMw61a9eW92l7qERc2yYa5IPK8mm0cCo31x7FlqAjwTSiJ/1HpG0rKEgKHfmnkWBbt24t71MZPx19p22g95oGQKH10VFrfcsN7t27p7CPLjOgsz90doRGkaV9kJGRgcTERPm52rp1K/r37y9/PnjwYKxZs0ZRX1BQEMLCwuS/Hzx4gDFjxmDLli2yymTJkiUK+0+fPo2QkBAcP34czs7OGDNmDCZOnIiqhhREqzA5taGlfcrIeiIDL8qyASnXtaHMWD9Jt1X4oIAZz1jrJTQ0FKGhoVCpVApH+ttvv80nLWUYpngIIZCRkYGcnBzY2NjolFsnJycjKCgIZmZm+OuvvwoMoCYRFRWFatWqyb9pAwMDsX37dkWZiIiIAmMYVfTgwNfupeJ8bDKM1Cp09+NJuopK54YuMDVW4+q9NFy6m4IGbraFn1SB4Qz2DFPB0Gg0MDU1VTje2nTv3h2xsbHy9ssvvyg+f/PNN3Hu3DlERERg69atOHDggGLNV3JyMrp16wYvLy9ERkbiiy++wLRp0/Ddd9+VWrsMlYysokmStdM+lTePsh9HBC/CjC9geMHLirq2HXjifBtCvxsanp6emDt3Lk6fPq2Q0Pr7++s9Z86cObCzs5O38swrzDCGTEZGBrKzs2FjYyMPYN69e1eeBJDepWlpaVi5ciWSk5MRFxeHuLg4eUnAli1bsGLFCpw9exZXrlxBaGgoZs+ejTFjxsj1jBgxAteuXcPEiRNx8eJFLFu2DL/99hvGjx9f9o0uI7Y9zl3dto4TqlmZFlKaMVRszE3QsV7ehJV0TyszBjtjzTCMbqysrGBlZVVgHmszMzO9yzAuXLiAsLAwHD9+XF7z9vXXX+PFF1/El19+CQ8PD6xduxZZWVn44YcfYGpqCj8/P0RFRWHhwoX5gq5UdjJyihadWq1WwdxEjYxsjUEEMJNzWBdhfTVggMHLitjvwJM28ox1fnr37o3U1FRcuXIFs2bNApCnXvrtt9/wzjvvKNbvSkyaNAkTJkyQ/05OTkaNGjWQlJQElUqlUATR9btUVUYVQVRpRNVLgFL9Q9VMVAlEU09RqMKHXic6Olrev3TpkrxP7aY20RzJBQWapOfTddI0DRcNDEqVcVSlRNtG1Uh0n/YrnQWl6qfTp08rbL18+bLOclSJRq9L1XR0rbI+uSbtG33BXamaTVvuTG2iqd7os0LTm925c0fej4mJ0VkfVbrRZ4v2GX1OaNvoNQH9KcT05b5WqVSyko3WV69ePaxatQqDBw/GyZMn5bRhdF05kPec1qpVCyYmJli6dCnGjx8PIQTq1KmDhQsXYtiwYXJZb29vbNu2DePHj8eSJUvg6emJFStWVOpUW1tPS9HAWQZe0enZxB07z9/FttOxmNC1XqUOvsuONcNUQvbt2wcXFxdUq1YNnTp1wueffy7PcB8+fBj29vaKQDJdunSBWq3G0aNH8corr+Dw4cNo37694kdSUFAQ5s2bh4cPHyry1UpUhgikuihedGojZGRrkJlT/g6e7FhX0BnrzOL0u5TqLIfXWOvixIkTeOGFF+S/MzIyMGPGDNy4cQOrV68uP8MYpoIjDarY2NhAo9EgJiZGTqcF5OUdL2xdaffu3dG9e/dC6+rYsSNOnTr17EZXAC7fTcGluykwMVIhyJdl4BWdzg1dYWqsxrWENFyITYGvR+WVgxusY52SkgK1Wq0Y8aT7dGSbjijTURA6MgsoRyDpKCd1BuiINK1DX9RLuiaVpqCiQSboKD4dsdVOEUXtpSOv+lJM0f7Qt0ZYX320ndRuGh2Vjvprz2rQ9tE6EhMT5X0qVaYjvtRu2jYKvad0FJmuMadp0rRHv+hoOu1/uq6djuLTPtC3lp+OktN9+vzQe0jbRu0BlM+ivpkdei06IyKNsuubse7evTteffVVeHt74+rVq5g8eTJ69OiBw4cPw8jICHFxcYp19UDeiL6Dg4O83jsuLg7e3t6KMtJ6zLi4OJ2OdWWIQKqNEKJYkmQLEyMkIhvpWeXv4KU9dpAti7jW2+BmrIsVFTzP+c4wkEEBQ0IIgW+//RYqlQoqlQpCCNSqVQsvvfQSFi9erPOcyvi/zDBMxUGarW5X1xl2lgUHemMMH2szY7xQ3xnh5+5i25kYdqwZhqk49OvXT95v3LgxmjRpAh8fH+zbtw+dO3cutXr1yUcrMtm5AlKA76I61oBhrPV99DgImVURpeBWBpZu60nwMk639SyEhIRg+/bt+P777zF16lS0aNEC27ZtQ3x8vN5z9P0vS0FFafAlOmhKBxPpICsNrqkdgJN+RgeOdQ3eAcpBTToQSaXZdPD22LFj8j6VfNPyNIDkzZs3FfXRgVMqKabBLKnkW1+QS6rgof1HBzlpXbSfqOSbDvxqx9mgg9z0/tJBcjqoS6NX04F3Knem94SiT/ZPJwW0z6V/X7lyRd6n/UcH/ekAPpWI03bStGx0MoQ+A7Q9t2/flve1o3fT54n2B32u6XNDn92UlJQqEfG4LBBCyGm2WAZeeejZxAPh5+5i+5k4fNCtfqWVg7NjzTCVnNq1a8PJyQlXrlxB586d4ebmlu9HdU5ODh48eCCvy9aX2kP6TBcVPQKpLqiDXBRJsiFFp5Yk3VJ+6sKQo4IbSrotKRq7adEk+PQc5gmhoaEAgKFDhwJ4sm71wIED5WYTwzCMPi7dTcGV+FSYGqnRxZczF1QWOjdwgZmxGtEJaTgfmww/D7vCT6qAGLxjTUdktX/oS9BRZCqPpSPH2tBRR3o+DWZBZd76UmwdOXJE3k9ISJD36WiuvkAqdHQa0D/yT0de6SwAHSWmo6u0DXREiNZH96l0nK7foaOxZ86cUdhKR3b37Nkj79N+ovdC34wFddLocXrv9AVb0TciDShnIM6dO6fTbpq6gsrK6cg4HQGnz4y+e0VHrKl92veazmTQ9tE+o7bS/pCuW1DwMsrt27dx//59OQBQYGAgEhMTERkZiYCAAAB591Cj0cjpyAIDA/HJJ58gOztbri8iIgL169fXO5NUGckkuaBNjQp38CxMDCc6tSTptjIr2oy1nMfaYGasH+exLsaMtSFI8A0NIQTWr1+PWbNm4fjx4zA3N0e1atUUS2y00ScFl75z6HcP3dcXiEtf+ac5R18ZfYG/6HcnfU/S73Nahh4vat3FtY8ep/XR4/qWtdE2aL9X6Gf62kTtoO9NfWX0vWeK2x7tz/TdF9omfferKPdB32xYQW17lvsohJA/45nrZ0OKHN2hvjNszVkGXlmwMjNGpwYu2HE2DttOx7JjzTCMYaDRaJCbmyu/1G/cuIGoqCg4ODjAwcEB06dPR3BwMNzc3HD16lVMnDgRderUkaOHNmzYEN27d8ewYcOwfPlyZGdnY/To0ejXr5+ck7x///6YPn063nnnHXz00Uc4e/YslixZgkWLFpVbu8sDKkcuimzJkKJTF3vG+rFjbQgz1nlr24seFVxeY80z1vkICQnBL7/8grVr1+Ly5ctYt24dEhMTFcHMtNGWgt+5cwe+vr6KwePikJSUVOxzCpKqF8bff//91OeWNXQQWB9Uwm6I0IHponLhwoUSqZvKyIvLrVu3nqlufc91SkqKIi4KU3SEEBwNvBLzYmP3PMf6TCw+DKqccnB2rBmmgpGdna1QREyePBmTJ0/GoEGDEBoaitOnT2PNmjVITEyEh4cHunXrhpkzZypk2mvXrsXo0aPRuXNnqNVqBAcH46uvvpI/t7Ozw86dOxESEoKAgAA4OTnhs88+q4KptoqXssrCgKTgacVeY51XzhBmrDNJdO+iSPANqd8NjUuXLuHhw4d48cUXATyZyfvjjz9gbGyMzMxMhYIGyL+sw9raGufPn4evry9u3bpV4Gx3aSCt8S7rusur3qpad0VvsxACKSkp8gA1U3zOxyYjOiENZsZqdG7IMvDKRqcGLjA3UePG/Uc4F5OMRtUr3wCUwTrW9vb2MDIyUkiBaMAPKrWhATFo4AztHwt0VJXKjqlMmUqT/9/em4dHUaV9/99e0p29Q9ZOIIHIviQsATGCDEokYJwR4fEZFUfGl0dmfIOOMDP64M8HkXGMy+M6g+Cu846IMjNuwAARBVTCFgXCvpNA0lnIvnUn3f37o7uq72rSJL1WJ9yf66qLovpU1TmnKt116v6e7+1K/uMqN+X58+fFdVdu3FTSRaW+gFReLDgwA9L2ucqXSY9FHc9dSbNpGdoXVNZMZeH79u2T1NWVNI3WiULPTaX39Dh03VV+Ujo1wNkEh0Il8/v37xfXqSycXjta3pUhDp0C4CovK32DTWXkzm+v6XHpfU0HzFRyTctoNBpER0fDYrGgtLRUktoDALZs2YLuiI2Nxdq1a69aJjMzs1dFfvyB6Eyt7n5wBzjmWAdDHutWo5uu4KJ5mfx1b5fMbe+5FNzYwVJwZz777DPJ9BYAeOCBBzBixAg8/vjjV/xOdoVSqRSNnqKjowM+6BGQ69zXYpvlPHdvbjNHqr1DiFbfPDxRnJ7E9B0EOfimEgM2HKrggTXDMMy1hDBA7sngDqCu4PIP8NyOWNvnYrcGQbotQQauUioQ0oO57aFBNLc92IiKisKYMWMk2yIiIhAXF3fFdoZhGLmwycBtHkG3j2UZeF8lLyMFm0oM2FhSjsdn9T05eM/CMAzDMNcg7XZJstbtgbX8AzxvItYWi7zmO+4qBTjdFsMwTO+m5FIDymrbEBaiwi0jErvfgemV3DwiAWEhKpTVtuHwpcbud+hlBG3Eura2FkqlUiIJpjJl6ihJ8xhSCfbV3Iup/I0ei0pxqVyavlFx5UJOZcBCShNAKl+mEmAqfXY+nyuJNK03nQNH12mdaHtoP1F5OZUZU7l8RUWFuE5zSwJSKTT9jPYllU7TNtDrSPuM9o0rR1Qqw6fX19mFk+YMpXVylXuU1tVV/kpX+UmpiyntY3pMZ3MX6hhO60pzmtJ20+slHIudR/2POMDrwTxfWs4YBAM8TyPWgO3FQISMMjxhbntPlQI8sHaP7du3u72PVqvFU089JUtKPbnOfS22Wc5zX4ttZhwIMvBbRib22HST6X2Ea9S4ZWQiNh6qwIaScmQM6FtycI5YMwzDuEAYqIX1xoi1m67gYSEqCO+zWmQ2MHPHEZyWCwYJfl9Fq9VixYoVsg165Dj3tdhmOc99LbaZsWG1WsU0Wz9nN/A+T16G7RpvPFTR54JEPLBmGIZxgSNi3cMBniZ4zMvczWOtUCgQYR+Et8qcckvMYd1TpYA6eJQCDMMwjHv8VFaPS/VtiNCoMH04y8D7OjcPT0RYiAoX69pw6KL76RiDmaDVWqjVaiiVSolzM5UNU4kulSXT8s5vQajTIz0WlfhSR0eas5Nup9JnZzm3AE23QGW8VEbuXD/6ppTuQ+XctAztA1du4wkJCeI6lVrT41ApM5UoU7d0Z7dv6oRN2+HKkZzKq6mbN5V80zL0OFQq7ao9V4O2ifYN7QNaJ3o+eh2pnJvWmx7T1dQAeo8BQHKy442sq3uZ9gHNdSq0h56L8Q+OyGnPBnhi2qdO+a+NuxFrW1kVmo2dQRCxFuZY91ApEET5wxmGYRj3EKLVOaOSevwim+m9hGlUmDEyERsOVWBjSQXGpsbIXSWfwRFrhmEYF7g7wAsNpnRbJvci1ray9oi1zPUXXmj0NH94aBBJ8BmGYZieY7E4ZOCCRJjp+9ye2Tfl4DywZhiGcYEwwHPXFTwYIqctdjl3hJsRa9u+8kasjZ1umsaphX6XXynAMAzD9JwfS+tgaGxHlFaNacMSut+B6RNMH56IcI0Kl+rbcLAPycGDVgoeHh4OpVIpkRNT6SuVzFIJMZXoUikzIJUsUykzdcWmsmiKK9kxlWC7cvym8m+K87moNLm1tVVcj4+PF9epJJs6U9N20z5z5ShOj0/71ZU7dv/+/SV1pZ9R6bQreTXtA7pOy9B20u3UaZv2MZVXO+fBo8eiEm4qu6bQY1Gpf2VlpbjeE+dwel/Ra+VcPyoTp1MUaN/Qc9N7l6XggUNwp+6peVmwRE7NFqtYh55GfQHHILwlSOZY91gpoLF957V3mmG1WvtcXkyGYZi+iuAGfivLwK8pQkNUyBmZhC8PlmPjoXKM6yNycK8i1s899xwUCgUeffRRcVt7ezvy8/MRFxeHyMhIzJs3TzJAYBiG6S0Ikm53023JHbGmA3u3ItZ22bjcc6wd/e7eCw2rFTAGwfx2hmEYpnvMFis2ldgG1rePZRn4tcZtfdAd3OOB9b59+/Dmm28iMzNTsn3JkiX46quvsH79euzYsQPl5eWYO3eu1xVlGIYJNEY38ykHS7qtVruUW6Ho+UsBAMQVXGbzsk5Bgu+eFBwAjCwHZxiG6RXsO1+LqiYjokPVmDqEZeDXGtOHJyBCo0J5Qzt+KquXuzo+wSMpeHNzM+bPn4+3334bzzzzjLi9oaEB7777LtauXYtbbrkFAPD+++9j5MiR2L17N2644YYen6O6uhoKhUIiy6WSber+TSWxdXV14jqV5QJSWTR9M0IduCnUlbm8vFxcpzJgekx6PirppVJkWldnWTJ1fqbHopJxZ3fprtpAZd7p6eldbqdO2VSyTOtH2+98XuqYTp26aTkqC6fbqYyf1oNKymn/0XPR60bvB3pM5/NRWSg9Lm037W8q06Zu8FQKTq8Vdfh2JbGn97FzOy5fviyu0/s6KSlJXKf3tXA/9JW3e8GM267ggju1zOZfLSbH/Gp3ZNERYsQ6SKTgPXyhEaJSQKVUwGyxor3TDB1Cut+JYRiGkZUNh2zP1rmj9dCo2fbpWiM0RIWcUUn44kA5Nh6qwIS0fnJXyWs8uovz8/ORl5eHnJwcyfbi4mJ0dHRIto8YMQJpaWkoKirq8lhGoxGNjY2ShWEYJhhwd4AXLOm2BPOxcDfmV9vKC67gcqfbsr/Q6OEca4VCIeaylluGzzAMw3RPp9mCzYdtQYq8TJaBX6sITvCbSipgsfT+gJHbA+t169bhxx9/REFBwRWfGQwGaDQaSaQTsEXeaISPUlBQAJ1OJy6pqanuVolhGMYvuDuwDpZ0W4IUXUif1VPEiHWwmJe5IWMPFuM4hmGuHQoKCjBp0iRERUUhMTERc+bMwYkTJyRleuI9VFpairy8PISHhyMxMRF//OMfJYpIANi+fTsmTJgArVaLIUOG4IMPPvB38/zKnnO1qGk2oV94CKYMie9+B6ZPMm1YAiK1alT0ETm4W09dZWVl+N3vfofCwkKJDNcbli1bhqVLl4r/b2xsRGpqKiIjI6FUKiVfLNTlm0pjqcyWyqad5bdUmuzKXduVfJk6N9PyaWlp4npZWZm4Tt2rab2v5mRNXyrQFxFUUuyqfrROcXFx4jqVWtPytE5U7ky/7Kks2VkKTmXIVOpOj0udvWm9qWs5rR/tD3p9+vVzSEPofVdVVdXl8QFp/7uS0g8aNKjLY9E60ePQ6QC0b+i+PXFqd2bgwIHiOu1/2n/0XhaOa7FYUF9f7/K4jPe0eTqw7pDXnbq3R6zdndtOy3LKLYZhAsWOHTuQn5+PSZMmobOzE0888QRmzpyJo0ePis8JS5YswcaNG7F+/XrodDosXrwYc+fOxQ8//ADA9pyRl5cHvV6PXbt2oaKiAvfffz9CQkLw7LPPAgDOnTuHvLw8/Pa3v8VHH32Ebdu24b/+67+QnJyM3Nxc2drvDYIb+KwxeoSoWAZ+rRIaosKto5Lw2U+XsPFQBbIG9m45uFsD6+LiYlRVVWHChAniNrPZjJ07d+Kvf/0rtmzZApPJhPr6eknUurKyEnq9vstjarXaKwZFDMMwwYBDkuzeHGvA5k4tV+qQVjLH2h0iNMEyx9q9ue2A4yWC3C8FGIa5dti8ebPk/x988AESExNRXFyMadOm9ch7aOvWrTh69Ci+/vprJCUlYdy4cfjTn/6Exx9/HCtWrIBGo8GaNWuQnp6Ol156CQAwcuRIfP/993jllVd65cC6w2zB5sO2gXVeRorMtWHk5raMZHz20yVsKqnAk3kjoVT23pSZbr0imjFjBkpKSnDgwAFxmThxIubPny+uh4SEYNu2beI+J06cQGlpKbKzs31eeYZhGH/ithScDMDlnOsrRqy1bkastUIea7nnWLsfsXbUnaXgDMPIg2B+GhsbC6Bn3kNFRUXIyMiQGJbm5uaisbERR44cEcs4+xrl5ua69C8CgtvDqOjMZdS1diAuQoMbrouVuzqMzNw0NB5RWjUMje34sbSu+x2CGLfCGVFRURgzZoxkW0REBOLi4sTtCxcuxNKlSxEbG4vo6Gg8/PDDyM7OdssRHLA5ZiuVSolzNnV0plJc6gidmJgorlOHZkDq5k0lvtTtmUpradSdRtWpDLq6urrL49Bz0S8z5/nnFFfycQptK+0bVw7RVFJOZcq0TlRmTB2+Kc7O6VQ+TvuM1on2DZXM0/O56j96fCqjpg7a9H5wnppApxDQe4U6jFNpt6vrS6XjtG9cuZbTa0j7ZcCAAXBFbW2tuE6lw5cuXRLXqeJDqCudIsD4ByEnck8HeGqVEiEqBTrMVrR1mBHjx7pdDc8j1kK6Lbkj1vaBdQ/NywAgUssRa4Zh5MNiseDRRx/FlClTxGfinngPGQwGyaBa+Fz47GplGhsb0dbW1uUzY0FBAZ5++mmftM3XCG7gs8booWYZ+DWPIAf/10+XsOFQBSYO6r0vW3x+N7/yyiu4/fbbMW/ePEybNg16vR7/+te/fH0ahmEYvyMM8MI8mOsrp4FZi8nDOdZiui25I9b2Fxpu1F+YH94sc7SdYZhrk/z8fBw+fBjr1q2TuyoAbB5GDQ0N4kJ9gOTE1GnBliM2P5nbM1kGztgQnOH/fbh3u4N7lMeasn37dsn/Q0NDsWrVKqxatcrbQzMMw8hKmwfu1GEhKjS1d8pqoiVEnN11BY/UCuZlMkesBfMyN/KainVnKTjDMAFm8eLF2LBhA3bu3ClRqOn1+m69h/R6Pfbu3Ss5nmBkSss4O4lXVlYiOjrapcIxWD2Mfjhdg4a2DiREaXF9eu+NTDK+ZerQeESFqlHZaERxaR0m9dKotdcDa39hNBqhVColkmAqG6bSWCqlpV8i8fFS+34qDacyWir3pfvTMlRaTGXe1IGbyrTpceiXHq0DlU0DUhdoKoum7aMSZHoOeixhjo/zcaj8m8rC6Zc97WPqdk0l9s7lqESa9hOVf9Pz0fbQ60jdxcPDw8V1KkOnDt90XyrBdi7nyine1XWnUnB6rWl/0GtKj0ll61SCTusASO8bWnfaB4MHDxbX6b0llHEl/2d8hydzfYMh7ZPHEWvBvEzmqK8Q7XdrjrW97hyxZhgmUFitVjz88MP47LPPsH37dqSnp0s+z8rKEr2H5s2bB+BK76Hs7Gz8+c9/RlVVlfisVVhYiOjoaIwaNUoss2nTJsmxCwsLe6V/0Vd2GfhtY/RQ9WKTKsa3aNUqzBylxz9/vIiNhyp67cCaJzYwDMN0gdVqFaPOWjcj1oC85mWeRqzFOdYyR6zdndsO0Gg7D6wZhgkM+fn5+Pvf/461a9ciKioKBoMBBoNBfBmu0+lE76Fvv/0WxcXFeOCBByTeQzNnzsSoUaPwq1/9CgcPHsSWLVvw5JNPIj8/X3zp/9vf/hZnz57FY489huPHj+ONN97Ap59+iiVLlsjWdk8wdppRaJeB57EMnHEiL9MWMNtUUgFzL5WD88CaYRimC4TBHeBmxFoj/8DaF3Os5VREtHsgwXfMsWYpOMMwgWH16tVoaGjA9OnTkZycLC6ffPKJWKY77yGVSoUNGzZApVIhOzsb9913H+6//36sXLlSLJOeno6NGzeisLAQY8eOxUsvvYR33nmn16Xa2nmyBk3GTuijQzGxl+crZnzP1CEJiApVo6rJiP3na7vfIQgJWim4AJUcJycni+vUidmVO7ZzagEqUw4JCRHXqdyXynepRJo6PLtyF6dyXSpfduUm7Sxfpo7Q9BwtLS1dHotK1anEnLaNHpPKnalEnNabSrCpAyU9pjO0X2n7qCyaXgsqo6bSZ3rtXMnqqeya9svV5hFRx3Dar1SeTtvtyqWbXi96z1Gncto2enx6Xudz0HL0HHRqgPP1bWlpEaXsGzZswL333it+brVa8dRTT+Htt99GfX09pkyZgtWrV2Po0KGS8z/88MP46quvoFQqMW/ePLz22muS++LQoUPIz8/Hvn37kJCQgIcffhiPPfYYrhWMZI60W+Zl9nnBckrBvXUFt1pt9Q93c39f4YkEP4JdwRmGCTA9eQHZE++hgQMHXiH1dmb69On46aef3K5jMLFRkIFnJPfqXMWMf9Colcgdrcc/ii9iY0kFJl8X1/1OQQZHrBmml2G1WhESEiJ5yUB54YUX8Prrr2PNmjXYs2cPIiIikJubK3nZM3/+fBw5cgSFhYWi4cqiRYvEzxsbGzFz5kwMHDgQxcXFePHFF7FixQq89dZbfm9fsCAMjFVKBULcSAcSpgkCV3AP81jTFwhy5oMWXcHdSLcVESQ5uBmGYZgrae8wo/CoIANP7qY0c60i3BubSgy9Ug7OA2uG6WWEhoYiKirqitzdgG3Q/eqrr+LJJ5/EHXfcgczMTPztb39DeXk5Pv/8cwDAsWPHsHnzZrzzzjuYPHkypk6dir/85S9Yt26dmNv7o48+gslkwnvvvYfRo0fj7rvvxiOPPIKXX345kE2VFUcuZfe+JsU51p0yuoLbB/XuSsGVSoW4j1yRX6vV6nAFd0sKLhivsRScYRgm2Nh+ohotJjP6x4RhQlqM3NVhgpQpg+OhCwtBTbMR+3qhHDxopeDh4eFQKpUS52YqjXXl3k230wgdIJUpU/kyle9S+TI9H60HPQ6VEFM37n79HHNHqNyZ7kslwIDUOZpKh+kAikrSqVSdtpUel65TmS+tB5VdU+kzlX/T9gNSSTatE+1Leg5XDtm0DJVU0bQS9FxUEk2P6SzHoteX1p3uT8vQPqDQc9B60H379+8vrlOJNz2XM1RKTo9F2+HKbVzYbjabr0i/ce7cORgMBuTk5IjbdDodJk+ejKKiItx9990oKipCTEwMJk6cKJbJycmBUqnEnj17cOedd6KoqAjTpk2T1DM3NxfPP/886urqJPe3gNFolFxb56kYvQ3H4M69walQvj0o8li7/xUfoVWj1WSWbYBqMlsg/Blo2byMYRimT7BBlIHrJc+aDEOxycGT8Ol+mzv4Db1MDs4Ra4bpQxgMBgDS+fHC/4XPDAbDFenT1Go1YmNjJWW6OgY9hzMFBQXQ6XTikpqa6n2DZESUI3s4sJZ1jrXRsznWtn3kjVjT/N+emZfxwJphGCaYaDOZse2YLWXp7ewGznTDbRk2Ofi/D/c+d3AeWDMM4xOWLVuGhoYGcSkrK5O7Sl7hyKXsmRQ8KPJYuznHGnAMUFtkirgb7f2mUAAaN+a2OyLWLAVnGIYJJr45XoW2DjNSY8OQOUAnd3WYIGfKEEEObsKec5e73yGICFopuNlshtVqlUi7dTrHHyN1YqZybOqq7CwPduUETvehsu3YWEdycipZphJd6lpOj0+lxa7cpOm6M1TaTaXutK1VVVXiOpV5UzkulTLT89Fj0n3r6uq63O7sak0dualb+6lTp8T1gQMHdlmeytNpn9E2x8fHoyuoBJlK9en1AYDo6Ghxnd4rtD+oFIn2DW0rXaf3Bq2HKyk9jfg6y6JpH9DrSGXl9Nz0uMK168qNVK+35QCsrKyUXJfKykqMGzdOLEPPCdjk6LW1teL+er3+Cpm58H+hjDNarfaq7uy9DU+l4GEa22BQrnRbVqvVY1dwgLhryxT5pcZl7sgFhZcIHLFmGIYJLgQZeF5GCsvAmW4JUSkxa7Qen+wvw8ZDFbhxcNdjgmCEI9YM04dIT0+HXq/Htm3bxG2NjY3Ys2cPsrOzAQDZ2dmor69HcXGxWOabb76BxWLB5MmTxTI7d+6UzE8vLCzE8OHDu5xf3Rdp89AATHCylmtgbey0iNIpbyLWcg1QhRcaYW72O41Yy5mDm2EYhnHQYuzEN8cFGTi7gTM9Q3AH33zYgE6zfGaw7sIDa4bpZVgsFolR2IULF3DgwAGUlpZCoVDg0UcfxTPPPIMvv/wSJSUluP/++5GSkoI5c+YAAEaOHIlZs2bhwQcfxN69e/HDDz9g8eLFuPvuu5GSYpv7dO+990Kj0WDhwoU4cuQIPvnkE7z22mtYunSpXM0OOPWttpcKujDXypKukDvdFpVCh7sZbQdoPmh56i9K8N10YxdegJgtVhhldGRnGIZhHHx9rBLGTgsGxYVjdEp09zswDIDswXHoFx6Cyy0m7D3Xe9zBeWDNML2M9vZ2lJWV4dKlSwCAJ554AuPHj8fy5csBAI899hgefvhhLFq0CJMmTUJzczM2b94scZf/6KOPMGLECMyYMQO33XYbpk6dKslRrdPpsHXrVpw7dw5ZWVn4/e9/j+XLl0tyXfd16ttsUvyY8JBuSkoRXcE75BncCaZjWrUSajfmKAs45ljLJQX3TIJPHdA5lzXDMExwsPFQBQCbaRnLwJmeEqJSYtYY29TDDSUVMtem5wTtHOvW1lYolUrJXNmKCkfH0vm/dI4rnUPrPK+Vzjml0HJUQkjnBdPz0bm99NxUIku/PGg6JTq3mW53/oyej9aDzklOS0sT1+l8WDo3l9bPVSoyWg/aR1QGPHz4cEldhUGd8/70HLQedM40TUtWU1MjrtM20znING0VTe1F59w7y5OFfMzOx6LzrekcaFfzsGnb6BxrOiebXms6v53OV6fHBKR9QOeH0zn79F6kc+vDw8MxZMgQWCwWnD17Fg0NDZK/E4VCgZUrV2LlypVwRWxsLNauXevycwDIzMzEd999d9UyfZkGe8Q6JsyzgbVc5mXi/GqtZ1/voiu4TOm2hPzf7qTaAgCVUoGwEBXaOmypwuIiu9+HYRiG8R9N7R3YftL2XJPHMnDGTW7LSMbHe8uw+bABK38x2qNgQaAJ/hoyDMPIQF2r7cVQvwg3peAyD6yFaK27c8MFhAG5/BFr93+eBBm7XHVnGIZhHHx9rBKmTgsGJ0RghD6q+x0YhpB9nU0OXttiwu6zvUMOzgNrhmGYLnDMsXYvYi24ghvljlh74AgOOAbWskWshYG12pP54faXAiwFZxiGkZ0NB21K0zyWgTMeoFYpMWuMTemwsaS8m9LBQdBKwWNiYqBSqSRyWip3pbLpuLg4cZ3Khp3lwXQfKpGmUmEquaVyaSpxpuegqbeoVJh+gVCJMz0mlUEDQEJCQpd1pem66PlonmBnqbEAlXNT+TGFHj81NVVcHzNmjLg+dOhQyT6HDx8W148ePdplvak8nbab9jEtT6ESbCq7pnWlknx6DQHp9aKSalcybyoxp9eLlnElz4+JiRHXaX/TOtHtABAWFtblOej1VSod771ouw0GwxXtYnxPfZtdCu7hHGvZI9YeOIIDjki3XFFfo5Buy4OItdw5uBmGYRgbDW0d2HnKJgNnN3DGU27PTMbHe0ttcvA7xiAkyOXgwV07hmEYmai3S8Fj3HQFl3tg7XXEWuNIWyUHnuYPB4BIQQrOEWuGYRhZ2XrEgA6zFcOSIjEsiWXgjGdMTo9FXIQGda0dKDpzufsdZIYH1gzDMF0gSMHdjViLc6xlGpgKkWZP51gLkW7Z8lh76AoOkIg1D6wZhmFkZWOJww2cYTxFTdzBN/UCd3C3QhorVqzA008/Ldk2fPhwHD9+HIBN7vv73/8e69atg9FoRG5uLt544w2J+3JPqaurg1KplLhgU+kr3U5l3VQeTNMLCfXrbn96DirXpVJhKl+m8m8qPa+tdUyypzJg6gCdmJgoqR/9jEIlxdQZncqd6Tmo3Jkek5an9b7uuuu63HfUqFHi+oQJEyR1Sk9PF9dpv9K+dJY/C1BJOpX3076n15FC60el2c6ScirVpuu03dTpnLqW0+kHrhzT6TU5f/68uE5l665c2J2hUnI6zYD2B72X+/fvD8AmDz99+rTL4zKeY7VaPZaC9wu33QN1rR2wWKxQKgM7r0yYG+25K7gQsZZrYO25FDxSK2+0nWEYhgHqWkz4/pRtuiO7gTPekpeRjI/2lGLzEQP+NCe45eBu12z06NGoqKgQl++//178bMmSJfjqq6+wfv167NixA+Xl5Zg7d65PK8wwDONv2jssMNnTPsWEuycFj4u0lTdbHIPzQOJ1xFrudFv2iLXWA/Myoe5yRdsZhmEYYMsRAzotVoxMjsbgBM59yHjH9emxiI/UoL61A7uCXA7u9sBarVZDr9eLixDpa2howLvvvouXX34Zt9xyC7KysvD+++9j165d2L17t88rzjAM4y+EVFtqpULM69xTQlRKMcpd02zsprTvEaK1vTfdlu2FRpgH9RcdzTndFsMwjGw4ZOAcrWa8h8rBNx4Kbndwt7WCp06dQkpKCkJDQ5GdnY2CggKkpaWhuLgYHR0dyMnJEcuOGDECaWlpKCoqwg033NDl8YxGI4xGx8NnY2MjAJvUVqlUurTnpzJj6pickuKYy0Hl28K5utqfyqXpsei5L192vCGhzs1U+msymcR16uhMj0PPS6XCgFSCTPen9aMSaVdSaFcO3NSF3JUrNZU7U4k43Q5I+5LKqF1JsClU1kzXe+IcTs9LtzvLzl3dN1RKTvvS1f1ApwzQc1OZNpX0C/cvIG0b7SMAOHPmjLhO7yF6XagsnCLUw5WjOuM9jvnVGo9ShMRHalHf2oGaJmPATVsceax7Z7qtNq/SbQnmZSwFZxiGkYPLzUYxqsgDa8ZX5GWk4O+7S7HlSCWemWOBRh2ccnC3ajV58mR88MEH2Lx5M1avXo1z587hpptuQlNTEwwGAzQajWS+KAAkJSWJ6YG6oqCgADqdTlxouieGYRg5qG+zO4K7Ob9aIN4uB6+WMWId4WG6LSFC32zqhMUS+JRuRtG8zP0fTc5jzTBMoNm5cyd+/vOfIyXFlqv5888/l3yuUCi6XF588UWxzKBBg674/LnnnpMc59ChQ7jpppsQGhqK1NRUvPDCC4FonttsPmKA2WJFRn8dBsZ1nQqWYdzFJgfXoqGtAz+cqel+B5lw68ll9uzZuOuuu5CZmYnc3Fxs2rQJ9fX1+PTTTz2uwLJly9DQ0CAuNDczwzCMHDQIEeswTwfWNjVKTbOpm5K+x9uIdbS9zVarPHJwb9JtRWjklbEzDHPt0dLSgrFjx2LVqlVdfk59iSoqKvDee+9BoVBg3rx5knIrV66UlHv44YfFzxobGzFz5kwMHDgQxcXFePHFF7FixQq89dZbfm2bJ2w4aJOBs2kZ40tUSgVuy7C7gx8KXndwz5687MTExGDYsGE4ffo0br31VphMJtTX10ui1pWVldDr9S6PodVqr5BEAzZ5rFKplMhpqfSVujJTCTF1zaYyXudyVM7tXE6AyoPj4uLEdSohptJiKg+mcmIqtabHpA7agGv5MiU2NlZcp7JjelwqJ6Z9RqXjtAyVOB89elRcp8Z0VCIP2N6cChw8eFBcp22i7XbVN1SeTu8b6t5NofvSejtD65uQkNDl+ehUAXpu2gZ6Tej940pSTiXz1P3c2eVcp9N1WVcqgafXlyJcU5aC+486IgX3BMfAuvdFrLVqJTQqJUxmCxrbOxEV6tnLBU/xxhXcEbFmKTjDMIFh9uzZmD17tsvPnZ+Bv/jiC9x8882S6XaA7bnU1fPyRx99BJPJhPfeew8ajQajR4/GgQMH8PLLL2PRokXeN8JHVDW1Y885mww8L4MH1oxvuS0jGX8ruoAtRwz4850ZQSkH96pGzc3NOHPmDJKTk5GVlYWQkBBs27ZN/PzEiRMoLS1Fdna21xVlGIYJFN5KwROi7APrpsAPrB2u4J69N1UoFIgOs+3bKIOruTd5rAUZO0vBGYYJRiorK7Fx40YsXLjwis+ee+45xMXFYfz48XjxxRclwYmioiJMmzZN4smSm5uLEydOSPx5KEajEY2NjZLF32w+bIDFCoxNjUFqbHj3OzCMG0waFIuEKC0a2zvxw+nglIO7NbD+wx/+gB07duD8+fPYtWsX7rzzTqhUKtxzzz3Q6XRYuHAhli5dim+//RbFxcV44IEHkJ2d7dK4jGEYJhjxXgpue/iRJWIt5LH2cGANQIxSN7XLIAX3Jt2W6GjOEWuGYYKPDz/8EFFRUVekon3kkUewbt06fPvtt/jNb36DZ599Fo899pj4ucFgQFJSkmQf4f+ufIzk8DDaYJfo/pxl4IwfUCkVuM3uDr4hSOXgbj15Xbx4Effccw8uX76MhIQETJ06Fbt37xaltq+88gqUSiXmzZsHo9GI3NxcvPHGGx5VrKWlBQqFQiKNpTJvKmWmUm4qHXeGvumj+1AZNZUX0zJUrk7LUMkylSlTV2+6Ly3j/PaQyqWp5JtKhV3JkV25pLtyu66srBTXXbmZUyk4dbEGpF/k5eUO63vaJiqjpteFyqLpOu1vWg963aj8mcr5naXj9L6hfUal2rSutB4DBgwQ12tra7ssT9tDpyVcbSoCxZXru7O7uUBXLuRmsxkXL150eQ7Gcxyu4L1wjrUQsfZQCg4A0aFyRqw9l4JHajlizTBM8PLee+9h/vz5VzyrLl26VFzPzMyERqPBb37zGxQUFHQ5XbInLFu2THLcxsZGvw6uKxvbse+87ZnpNpaBM34iLzMFHxZdwNajBhg7x3j0Et6fuDWwXrdu3VU/Dw0NxapVq1waODAMw/QGhDzWvXqOtRcRa8HArLFdhoG1F+Zlgvyd81gzDBNsfPfddzhx4gQ++eSTbstOnjwZnZ2dOH/+PIYPHw69Xi8JiACOAImredmuPIz8xcZDFbBagayB/ZASE9b9DgzjARMH9kNilBZVTUZ8f6oGM0Ymdb9TAAm+Wd8MwzAyU9/mZcTaPsf6crNJojYIBK3iHGtvItb2gbUMEWujGLF2v/6RbF7GMEyQ8u677yIrKwtjx47ttuyBAwegVCpFhVp2djZ27twpUbUVFhZi+PDh6Nevn9/q7A4bS2yKPc5dzfgTpVIhKiKEey6Y8MoV3J8oFAoolUqJ/DY6Olpcp1La1tZWcZ3Ka6jxAyCV5lLnZyq7pq7RLS0tXZah26kMmMrTqSM0hcquqVwZkMqcXbloU5k3rQc9N/3ipX1Dy9B1enwqfab7Hj9+XFJXKp2mbaKybVoPV3J92mYqbafXjt4D9Pi0j51/WOhx6b1C6+3sdN7V+Wh/0LfC9Di0PdRdnNaB3lfO7aDQctTFnV6j8+fPX3F8xrc45lh7FrGOi7DtZzJb0NjWCZ2HA3R3MVusopRacMj2BNG8TMY51p5IwYWXCW0dZpgtVqiU3WdaYBiG8Ybm5macPn1a/P+5c+dw4MABxMbGIi0tDYDtuWL9+vV46aWXrti/qKgIe/bswc0334yoqCgUFRVhyZIluO+++8Rnm3vvvRdPP/00Fi5ciMcffxyHDx/Ga6+9hldeeSUwjeyG8vo2FF+og0LBMnDG/+RlJuODXedReKQSxk5zUMnBg3ZgzTAMIxcOKbhnA+LQEBWiQtVoau9EdbMxYANrmr/Zm4i1w7xMRldwD34o6cuEVlPgU4UxDHPtsX//ftx8883i/4V5zQsWLMAHH3wAwDaV0mq14p577rlif61Wi3Xr1mHFihUwGo1IT0/HkiVLJPOjdTodtm7divz8fGRlZSE+Ph7Lly8PmlRbm+yRw0mDYpEU7drriGF8QVZaPyRFa1HZaMR3J2uQMyp45OA8sGYYhiFYrVavpeAAkBCpRVN7J2qajRiSGNn9Dj5AiLRr1Epovcjv6DAvC2zE2mq1os2LdFtatRIqpQJmixUtRjMPrBmG8TvTp0/vdsrPokWLXA6CJ0yYgN27d3d7nszMTHz33Xce1dHffHWIZeBM4BDk4O//cB4bSyp4YN0TFAoFFAqFRGZMpeBUButK1kzXnaGfnT17VlyPi4vrsgyVB1NpMa0HlSbTelPJMT2ms1SdOltTJ2tXbuZ0fypVr6+vF9dpn9H60ePQ+rlqJz2m83FpPeiPC5UyU1k4NdOgUnpahkr1aV/QetPjU2k2IO0z2j7qVE6vHZVzU9d3Wld6Dnp8uk7rWlVVJa47S9VpP9N20OkBtAxtg3CtLRaLRKrO+Ib2DgtMnbZ7w1PzMsBmYHa2piWgBmaCm3m/8BDJve4ucpmX1baYYLECCoVnLzUUCgUiNCo0tndKovcMwzCMfyirbcXBsnooFcCsMV0bqTGMr7k90zawLjxaifYOs0cv4/0Bm5cxDMMQ6ttsL8XUStsgzVPio+y5rJsCN7AWJOz9vHghABDzsgAPrMvqbC/UkqJCPf6RjBANzHhgzTAM428EA6nJ6XFIjGIZOBMYxqf2Q7IuFM3GTuw8WS13dUR4YM0wDEOoa3HIwL2J+sqRy9rbueEConlZgKXgZbU2w8TUWM9TtUSwMzjDMEzA2CjIwMeyDJwJHNQdfFMQuYMHrRRcq9VCqVRKpMX0IZdKiKks2ZVjNyCVWlMZMN2fSpCpPNjV+aj0l5an61TiTOXYzs7QVIbuXPeu9k9ISOjyHFTK7MpVnZ6bSulduYI715X2pSuHa1oPuk77pry8XFzv379/l3WiknR6XtpftIzz/+vq6sT1pCTHPAzal7S/qTSbSrDpdir1p/L0y5cvi+s6na7L4wPSa0ePRdtH96f3mVDGlSv4ihUr8PTTT0u2DR8+XHR2b29vx+9//3usW7cORqMRubm5eOONNyR9U1paioceegjffvstIiMjsWDBAhQUFFx1ekVfQYhYeyMDB+TJZV3XYqt7bETvjFiXCgPrfuHdlHSNoDLgiDXDMIx/OV/TgpJLDVApFZg1mmXgTGC5LSMZ735/Lqjk4ByxZpg+yOjRo1FRUSEu33//vfjZkiVL8NVXX2H9+vXYsWMHysvLMXfuXPFzs9mMvLw8mEwm7Nq1Cx9++CE++OADLF++XI6mBBxHqi3vor6yDKyFunv5UsDhCh7YwenFOiFi7fnAOlxjj1jzHGuGYRi/IsjAbxwch7hIbTelGca3jE+NQYouFC0mM3YEiRycB9YM0wdRq9XQ6/XiEh8fD8AWpX/33Xfx8ssv45ZbbkFWVhbef/997Nq1S3Ql3bp1K44ePYq///3vGDduHGbPno0//elPWLVqlSS63lfxhSM4AMRH2ga31QGUgteLc6x9JQXv6Nbt1peU1doUQ94MrFkKzjAMExg2sBs4IyNUDi5MSZCboNV1ClJw6jhN5c5UFk7dmqlk1nl+JN2fSoWdHZu7Kk8lwfQcrty7aXlX8nIq9QWkMmxX7tVUzu1KNkwl3FFRUeI67UsqEaf1pnJnivPDNa0T3Z+2lR6LtofKwqn8mO5L611aWiquU7k4ve60X52JiYkR12nfUAk3df+m0nHa3waDoct603uAunrTe4y2DZBKw+l1odexpqZGXKf3qNBWi8UiqSvl1KlTSElJQWhoKLKzs1FQUIC0tDQUFxejo6MDOTk5YtkRI0YgLS0NRUVFuOGGG1BUVISMjAxJG3Nzc/HQQw/hyJEjGD9+fJfnNBqNLqch9CYc85S9lIJH2SPWATUvE1zBfSMF77TY0l8JUWB/45CCezPH2va31coRa4ZhGL9xproZxyoaoVYqkMsycEYm8jKT8c735/D1seCQg3PEmmH6GJMnT8YHH3yAzZs3Y/Xq1Th37hxuuukmNDU1wWAwQKPRSF42ALYXBcKLA4PBIBlUC58Ln7mioKAAOp1OXFJTU33bsADhKyl4ApGCByrq66uXAuEaFVRK28uwQBmYmS1WlNf7LmLdzHOsGYZh/IYQIZw6NN7r3xyG8ZRxqTHoHxOGVpMZ209Udb+Dn+GBNcP0MWbPno277roLmZmZyM3NxaZNm1BfX49PP/3Ur+ddtmwZGhoaxKWsrMyv5/MX9a2+koLbBtbGTkvABnk0j7U3KBQKRIfa5eABMjCraGhDp8WKEJUCSdGep2wRzMtaTSwFZxiG8RcbDtnMZ/MyWAbOyIdCoUCefSrCxhLXwZ9AEbRScLPZDKvVKpHuUjlxbGysuE6dwF25cQNSabIrWTh1dXblFE2lu1QGTWXArtyrqVSWSogB1+7mNNrlShZOZeSupO20rrT9tJ203lSOTevtvA/tc1pv2pe0b1zJsanjNJU40/6j9ab70vMC0ra6knnTqC2V7tP7jF5rYZ4y4Ho6gCvncOe5ybQcvaZUMq7XO6RV9PomJiZeUeerERMTg2HDhuH06dO49dZbYTKZUF9fL2l/ZWWleD69Xo+9e/dKjlFZWXlFnZzRarWSvu6tCK7gOi/fwIdpVIjQqNBiMqOm2SQagvmTWrsreD8vXcEBm4FZXWsHmgI0sBbmVw/oFy5Gyz2B81gzDMP4l5OVTThZ2YwQlQIzWQbOyMxtGcl4a+dZbDtWiTaTGWEa+eTgHLFmmD5Oc3Mzzpw5g+TkZGRlZSEkJATbtm0TPz9x4gRKS0uRnZ0NAMjOzkZJSQmqqhySmsLCQkRHR2PUqFEBr3+gqfNR1Bcg86wD5AzuMC/zfmAd6FzWQg7rAV7MrwaACA0PrBmGYfyJYFo2bWgCdF5Om2IYbxk7QBc0cnAeWDNMH+MPf/gDduzYgfPnz2PXrl248847oVKpcM8990Cn02HhwoVYunQpvv32WxQXF+OBBx5AdnY2brjhBgDAzJkzMWrUKPzqV7/CwYMHsWXLFjz55JPIz8/vExHp7nDMsfZ+cCqm3AqAgZmp04IWu/zZFy8FAp3LuswHqbYAErFmKTjDMIzPsVqt2GiXgd8+lmXgjPwoFArRmX5Dibzu4EErBW9ra4NSqZQ8yFP5MZX0UumuK6dnQCpZLi8vF9epLJeegx6LypoHDBggrjc0NIjrVOJM5eXUHTkiIsJl/err68V1Vy7fVP5bUeG4eVy5UVOZMd3XlVM23ZfKoJ2hx6Lu1bTPqGyb9gHtY9oHdF9ahsqo6bW+Wl3pPlRiTttN5e30fLTPXLmf0+30OHQ7PaazAzw9Fm0T3U7b1NX9RM9FuXjxIu655x5cvnwZCQkJmDp1Knbv3o2EhAQAwCuvvAKlUol58+bBaDQiNzcXb7zxhqTeGzZswEMPPYTs7GxERERgwYIFWLlyZZfn62sIUnBv51gDjpRbgYhYC9FqpcIxKPYGcWDdFigpuOAI7u3A2vZ3xxFrhmEY33Pc0IQz1S3QqJXIGZnU/Q4MEwDyMpPx5s6z+OZYFVpNnQHLZuJM0A6sGYbxjHXr1l3189DQUKxatQqrVq1yWWbgwIHYtGmTr6sW9FitVlEK7gt5mxCxDkQua1pvpRdzlAVEKXh7YAaoQqqtNG8j1pquI9a1LSY89o9DmD85DTePSPTqHAzDMNcqghv49GEJAfEOYZiekNFfh9TYMJTVtuHb49WioVmgYSk4wzCMnfYOC0ydNiWALwzA4iMDN8daSLXli3oDEB+YAhaxrhNSbXk3xzrcRcT6858u4etjlXjy88MwW7pOf3a6qhnfn6rp8jOGYZhrHavVKrqB3z42RebaMIwDhUKB2+wO9ZtklIMHbcQ6LCwMSqVSIo2ljslUPkvlxFSi7OwK7grqhO3KvZo6bVPps6tz0GO6knU7y5dp3akLNHX/pvJfKit35Yzuqk6CLBiQyoxdua3TOgDAhQsXxHUqpafXhbqKU1k0bRuVUYeFOR6oad+4kmZT6Tjd1/kzVw7oPZFjU0k5rSu95+g9Q7fTdXrvAtJr5Mplntab9r8wZSBQuZGvJWrtg1O1UiGmbfIGwbys2g9zrEsuNmBDSTmW5AxDaIgKdS2+My4D6Bxr/0es2zvMYh95LQW3R6xbnQbWZ6qbAQCX6tvww+kaTBuWIPm82diJ/3yzCHWtJmxb+jNclxAJhmEYxsGR8kacv9yK0BAlZrDyhwkybs9IwZs7zmLb8UrZ5OBuR6wvXbqE++67D3FxcQgLC0NGRgb2798vfm61WrF8+XIkJycjLCwMOTk5OHXqlE8rzTAM4w/2n7e99BmSGCl52eIpgqz5uKGxm5LuYbVa8ci6n/DmjrP46qAteuBLN3OASsH9H7G+aDcui9SqvZ7bLpiXOecOFwbWAPDJ/itzrP+/oguobTHBagWOVTRd8TnDMMy1juAGfsuIRPG7lmGChTH9o5EWG472Dgu+OS6PO7hbA+u6ujpMmTIFISEh+Pe//42jR4/ipZdekkRzX3jhBbz++utYs2YN9uzZg4iICOTm5l6Rs5lhGCbY+PqY7Yv4Fh+9iZ84sB/USgXKattQerm1+x3sdJgteOqLw/i0iwEgABSduYxzNTZFyVn7v4IUPMbXEWs3pOCbD1dg7Z7SHpW9VN+GD344h2Zjpzi/OjU23OsXGoJ5WavJLFF1nK5yKHC2HjGIOb9tZTvx9ndnxf+fv+woyzAMw0hl4HkZLANngg+FQiHOrRa8AAKNW6+bnn/+eaSmpuL9998Xt6Wnp4vrVqsVr776Kp588knccccdAIC//e1vSEpKwueff467777bR9VmGKa3Y+q04NP9ZThYVo8/35kBjVpey4cOswU77PkPZ4z0zcA6QqvG+LQY7Dtfhx/O1CAtLq1H+317vAofFl2ARqXEzcMTkRAlzSDw0V7H4PWCfRDoyGHtq4i1e1LwpvYOPPzxT+gwW3F9ej8MSYy6avmVXx3BliOV2Hq0UnyRkeplDmvAEbHutFhh7LQgNESFhtYOcZ770MRInKpqxr9+vIj/uuk6AMBHu0slA+3zNTywZhiGoRy62ICLdW0IC1H57OUzw/iavIxkrN5+Bt8cr0KLsTPgygq3nmS//PJLTJw4EXfddRcSExMxfvx4vP322+Ln586dg8FgQE5OjrhNp9Nh8uTJKCoq6vKYRqMRjY2NkgWwzW01mUxoaWkRl7CwMHGJiYkRF7VaLS60fEhIiGSpqakRl+joaHEJDw8Xl9raWnFpbW0VF+c6Cwutk0KhEJfU1FRxaW5uFhe6r0qlkiz0fFarVVyc+0dY6LlpeywWi7jU19eLS2hoqLjQerS1tYkL7SO6nfZrS0sL9Hq9uERERIgLPS6F9g3tj9jYWHGh56bXtLOzU1zouWj9zGazZKHni4+PFxfar7Tvab+6Oi69l5RKpbjQ/m5oaBAXei7aL0ajEU1NTeJCz033F/4GTCYT2tvbxWXAgAEYMGAAUlJ69xvjEJUC/7v1BNYXX8TRCt9KpT1h//k6NLZ3IjZCg3Gp/brfoYfcODgeAPDD6a5NsaxW6xVmWttPVgMATGbLFRHgmmYjth4xiP+/YI+Ei1JwH5mXRYfafoyaehixLjpzGR1mWzuKL9Rdtayp0yKahO06cxkvF54E4H0OawCI1KgRZf8hFeTfZ2ps/+qjQ7HgxkEAgE/2lcFqtaLNZMabO23R6qlDbNfKVxHr2hYTfiq9el8wDNO72blzJ37+858jJSUFCoUCn3/+ueTzX//615JnEoVCgVmzZknK1NbWYv78+YiOjkZMTAwWLlyI5uZmSZlDhw7hpptuQmhoKFJTU/HCCy/4u2kShGj1jJGJCPOBBwnD+IPRKdEYFBcOY6cF22SQg7s1sD579ixWr16NoUOHYsuWLXjooYfwyCOP4MMPPwQAGAy2h72kJGleu6SkJPEzZwoKCqDT6cQlNTXVk3YwDNPLUCgUGJ8aAwD4sZuB2NV4aesJ5K/9EcZOc/eFr8I3xysBANOHJ0Dlg3RVAlOH2gZru85choUMoBvaOvDWzjOY8tw3mPTnr3Gp3mZwZ7VasZ38GPx9zwXRqRwA1u+/iA6zVYxiX7hsexHniFj72BW8hxHrnaeqxfUfL9RftWzxhTq0mMyI0KigVirQak+N5YuItVKpQGaqzTDyYFkDAOBMle0BdXBiBH4xLgWhIUqcqmrGwx//hF+/vxc1zUb0jwnDkluHAgDOuyHbB4C/FZ3HrS/vwP9uOQFDQztqmo0o+PcxTH3+Gyxe+5Pk+jEM07doaWnB2LFjr5rCctasWaioqBCXjz/+WPL5/PnzceTIERQWFmLDhg3YuXMnFi1aJH7e2NiImTNnYuDAgSguLsaLL76IFStW4K233vJbuyhWq1WU1t6e2btf6jN9G+oOvtH+MiiQuDWwtlgsmDBhAp599lmMHz8eixYtwoMPPog1a9Z4XIFly5ZJonRlZV3PKWQYpu8xIc0WGf7Rw6heeX0b/vLNaWw8VIGtRyq9qss2+/zqnJFJ3ZR0j7EDYhCuUaG2xYTjBpsp1hcHLuHGgm14dtNxlDe0o7bFhI/tkelTVc0ob2iHVq1EYpQW1U1G/Puw7YHGYrHiY7sM/JEZQ6FQ2Ey6LreYRCmzXOZlO086IvLdXU9hEH7rqCQUzM0Qt6fFeR+xBoBx9hc2B8ps9Thtj1wPSYhEdGiI+GC44VAF9pyzGdYtvmWIKF+vbjJeYX52NT744TxOVTXjr9+extTnv8HU57/BmzvOotVkRkx4CCob2WOEYfoqs2fPxjPPPIM777zTZRmtVitR+lFvomPHjmHz5s145513MHnyZEydOhV/+ctfsG7dOpSX2wYGH330EUwmE9577z2MHj0ad999Nx555BG8/PLLfm8fAPxYWo/yhnZEaFSYPjyh+x0YRkaEedbbT1S79VvuC9wSnicnJ2PUqFGSbSNHjsQ///lPAIBerwcAVFZWIjnZkZi7srIS48aN6/KYWq1WkpZIwGg0QqlUStIjUXmxkHIIkKYioqmfaOoiQJoWyVUaL5ryiqZwouej56B1oimUaFoo2gZ6TGdDN5qWi6akol/AtA00HRaVq9P+iI+P77JONPUWrXdDQ4O4PmjQoC63A9J+osel9VOrHbcXTR1FU30J0n9Amp6K1o/2HzUjEu435+MD0hRWtO70WK7SidH2uDJSqqx0DOJoe+hxaKou53RltP+opJteRyoDo31z8qRNNtsX0m1NGGi7t38qrfdo/w3kbeQ/f7yIn3uYV/NsdTPO1rQgRKXATUPju9/BDTRqJa5Pj8X2E9XYdaYGcZEaPPGvErSYzBiWFImsgbH4eG8p1heX4dGcodhun+d9w3VxmDiwH14qPIn3fjiPX4xNwRcHL6G0thVRWjXmTeiPNdvP4FJ9Gy5cbkG9XQruM/My+xxrU6cF7R1mhIa4lv6dr2lBaW0r1EoFOi1WnKpqRkNbB3RhXQ/yd9ql7tOGJWDuhAGwWK3Yc64WU4b4pu/HDogBQCPWtr/1wYm27+7/nj0CabHhUCkViNSqodeFYuaoJCgUCsRGaFDbYsL5mhaM6a/r8viU9g6zKB0fnxaDn0rr0WmxInOADr+bMRS3jEj0icM8wzC9l+3btyMxMRH9+vXDLbfcgmeeeQZxcXEAgKKiIsTExGDixIli+ZycHCiVSuzZswd33nknioqKMG3aNMmza25uLp5//nnU1dVJnhMFnKfl0ectdxGi1beOSrrqbwHDBAOjkqORHh+BczUt2HasEneM6x+wc7s1sJ4yZQpOnDgh2Xby5EkMHDgQgM3ITK/XY9u2beJAurGxEXv27MFDDz3kmxozDNNnGJsaA6XC5hBd2diOpOiuc7C74suDjoH1zpPVHh0DgJiWYXJ6nCiB9iVTBsdj+4lq/HC6BiWXGtBiMmNcagz+9dCN6LBYsOWIAZWNRuw4WY3tJ2yDzunDE/DzsSn4yzencbCsHr/46w8ouWQbKM7LGoBwjRoD48LtA+tW0RXcV1LwSI0aCgVgtdqi1ld7mBIi0BMH9UNFQzsuXG7FgbJ6/GzYlZGN6iYjjpTbHvBuGmr7/JeT0vDLST0zdusJQsT6ZFUTmo2dOGuPWA+256aOj9TikRlDu9x3UFy4bWB9uWcD69NVzbBYgZjwEPzroRtxqqoZrSYzxg7Q8YCaYRjMmjULc+fORXp6Os6cOYMnnngCs2fPRlFREVQqFQwGAxITpWZgarUasbGx4jRKg8EgMQsGHNMuDQZDlwPrgoICPP30017X32KxYlMJy8CZ3oNCoUBeRjL++q1N0RjIgbVbUvAlS5Zg9+7dePbZZ3H69GmsXbsWb731FvLz8wHYGvLoo4/imWeewZdffomSkhLcf//9SElJwZw5c/xRf4ZhejGRWjWGJdnkt+7Osz5b3YzDlxqhUiowPCkKFivw+U+XPKrH18dsCgR/OZ3eOMQWmfj+dA2+OFAOhQJ4Zs4YKJUKaNUqzB1v+9J/9/tz2GfPpT19eCLiI7X4xTjbg0zJpQZoVErcnz0Qj80aDgAYaJdOn6tpQUObb/NYK5UK0QSssc2hAKlrMeHNHWfw0N+LcbrKpiwRItA3DU1wyPtdXM/vT9vKjk6JvsLt3FckRociRRcKq9VWjwv2dF7CwPpqDIqLAOAwhTN1WvDk5yVivnBnTtjl/cOToqBQKDAsKQrjUmN4UM0wDADg7rvvxi9+8QtkZGRgzpw52LBhA/bt24ft27f79by+mmpZXFoHQ2M7okLVuGmYbxVdDOMvRDn4yWo09XBKmy9wK2I9adIkfPbZZ1i2bBlWrlyJ9PR0vPrqq5g/f75Y5rHHHkNLSwsWLVqE+vp6TJ06FZs3b5bIjXtCVFQUlEqlRE5MoW/nqLyXym+dpbJU4kuluFQqTOXFtDyV5dLtXcnYAalUOCYmRlxXKh3vMpydsylUSk9l0ZSQEMcDNJWY0wc6KpGm5V2t0/ZcvnxZXHeW1dN+puej8nZ6zWk9aH9QyTaVQUdERIjrdXWOB3Ta97Qvne8TKnmidaXtiIpypAOi14LK2Wnf03rT6QD0/qGSb9qvzlJ6Kvun9aN9RvuV9ofQBovFgvPnz6O3M2FgPxw3NOHH0jrMzkjufgc7QrR66pB4zBqjx7J/leAfxRexaNp1bg1qTlU2Ya99nq2v51cLjNRHixJjAJg/OU0SDf3lpFS88/057Dpj+5sbFBeO9HjbNX/klqE4V9OCEfoo5N88BCkxjr/1gfZB4KGLDRB80XwlBQdsBmaN7Z1obO9Am8mMp786gs9+ugSj3Yzr0MUGrP9tNors9f7ZsAREh6rx2U+XJPOsa5qN0IWFIESlFOdiT+simu1LxqXFoLzEgC8OlMNssSJCo0JSdPcD+UH2fhfyhG8+YsDfd5diy5HKLqcanKi0fUeM0F89vRjDMAwAXHfddYiPj8fp06cxY8YM6PV6VFVJ3Ys7OztRW1srPpPq9XrJcyXgeM6kz60UV1Mt3WWD/bd25ig9tGqWgTO9gxH6KFyXEIGz1S3YdqwKc8YHJmrtduLY22+/HSUlJWhvb8exY8fw4IMPSj5XKBRYuXIlDAYD2tvb8fXXX2PYsGE+qzDDMH0Lh4FZ/RWfWa1W1LaYJG7awnZhYP2LsSnIy0yGVm1zehbk0j3lla9PwmIFckcn+cw8yxmlUoHswbaodWyEBn+YOVzy+dCkKGQNdLwsnD7cETlPiwvHPx+6EX++M0MyqAZsA3AAOHixHoBNAeDLfODCPOum9k6s3nEG6/aVwdhpwajkaKTF2mToc9/YhRaTGXERGoxKjsZ4+/U8UFoPi8WK7SeqkF2wDTkv70DRmcv4zi4bnzbUvwNrYZ61YPw2ODGyRy9chIG1kMt6h12aX91kFHNhU4SI9TAeWDMM0wMuXryIy5cviwGU7Oxs1NfXo7i4WCzzzTffwGKxYPLkyWKZnTt3SoIUhYWFGD58eJcycF9htlix6bBNjn57Zs9ffDOM3AhycMBmVBoofPcExjAM4wET0mIA2KTOQlqiioY2rN5+BrNe/Q4T/lSIF7dKvR2OVjTibHULNGolZo5OQnRoCGaOtr21/2fxRZfnajF2YvPhCrSabEqJw5casKnEAIUCWHrrcJf7+YL7bxiIgXHhKJib0WVU+ZeTHKkGf9ZD11UhYu0wLvPt/HAhl3VjW4eYtuLpX4zGxkem4sP/cz1iwkNgsDte3zQ0HkqlAiP0UQjXqNBk7ERxaR0e/+chdJituHC5Ffe8vRs1zSZEaFSSFwn+QJhnLaTy6okMHHC8rDh/uRUWixU7TjrSiB2vuFI9JAysOWLNMNcmzc3NOHDgAA4cOAAAOHfuHA4cOIDS0lI0Nzfjj3/8I3bv3o3z589j27ZtuOOOOzBkyBDk5uYCsJkAz5o1Cw8++CD27t2LH374AYsXL8bdd98tmpvee++90Gg0WLhwIY4cOYJPPvkEr732GpYuXerXtu09V4vqJpviyFfmkgwTKAQ5+M4AysHdkoIHEkHyS6W/1MWZynipqzeVB1MJsTN0Hyr9pRJiKiWn0l8KlTLX1DjSzVA3bipxplJkKhUGpDJqKu2mx6LybFfl6RtN2k9UjuxKak2lyLS/qdwecO2WTfehZWhb6floH9PyVNotOGcC0utD2xMbGyupB5Va02tEZVG0TfRYrpzhq6sdD9i0n2hf0npTZ3dnKT29J+g+tD/ovUzbIEjH6d9GbyY9PgL9wkNQ19qBI+UNaDOZ8cAH+0S5MQD8vegCHrllKMI0tmsmRKtvGZ4omo3Nm9AfXx0sxxcHy/FE3sguJWv5a3/E9hPVGKGPwpu/ysJL9gH7L8amYLifB0aTr4vDjj/e7PLz2zOT8UqhzfE9+7o4l+UoabHSCLuvjMsEhIh18YU6nKlugUalxJ0T+kOhUCA9PgJr7svCr97dgw6zVZR2q1VKZA7QYffZWixe+yMqG41Ij49A9uA4rLWnFMseHOfTyHpXjOmvg1IBUSI/JLGHA2t7xLqm2Yh952slUepjFY1iXnIAaGjtEF8sDE3igTXDXIvs378fN9/s+G4XBrsLFizA6tWrcejQIXz44Yeor69HSkoKZs6ciT/96U+S55GPPvoIixcvxowZM6BUKjFv3jy8/vrr4uc6nQ5bt25Ffn4+srKyEB8fj+XLl0tyXfsDIfNG7ugkv39nM4yvGZ4UhcEJEThT3YKvj1XizvED/H7OoB1YMwxzbaBQKDA+rR++OV6FfxRfxFcHy2HstGDsAB3unZyGv357GmW1bdh8pAJ3jh+ANpMZ6/fbotJ3jHPMeb1paAL00aEwNLZjaxfzYbefqBIdt48bmpD3+vdoNnZCpVTg0Rz5p6uEa9TY/LtpANDjdCYRWjUS7LmuAX9ErG3H+8xuCnfT0HhxG2BLCfbOgknYdbpG4hY7Ia0fdp+tRWWjEQoF8OJ/ZGLioFjcnpmMtXtKsWjadT6tZ1dE2I3xhNzhgxMiutnDRnRoCOIiNLjcYsLfii5IPjtWIU1XI8yv7h8TJukXhmGuHaZPn37V9Jdbtmzp9hixsbFYu3btVctkZmbiu+++c7t+ntJptmCzKANnN3Cm96FQKJCXmYLXt53CxkMVARlY8+snhmFkR5CDf7SnFI3tnZiQFoNPfpONX05Kw11ZNom0MJhet68UtS0mpMaG4dZRDrMxlVKBuybavjQ/3S91P+00W/DnjccAAP+RNQDj02LQbLSpAP5jwgDRKExudOEh0Lk5OB5E5oXHRvg2Yh1ll4ILjuNdmcv9bFgClt02UhLNEObNA8DCKemYOMimKLlxcDz+eu8EZNrnP/sbQQ4O9FwKDjjc1jcfsT1UCtH4YwapFPyEwTbQHpbU82MzDMP0BnafrcXlFhP6hYeIHiEM09u4XZSD14jPMv4kaCPWJpMJSqVSIi125SZNJbFUoksdmgGpjJgel0px6TqVJtPy9HxURk6dvOlxqLTYlcu582dULk3l3FQWTR2rqWzYlUSY9hk9Fz0+lbzTY1LZufOxXMnbabu7crV2hsrc6dtf2h7qoE3bQK+t8z70fNT9mx6LSsfpNAEqq6cGIbQ/aBm6L22zM7QeVJJO+4wel55PaPfV3pD3NuhALDU2DG/fP1GM2s7LGoBXvj6JXWcu42x1M97eeRYAsGjaYKhV0neDd2Wl4i/fnMb3p2tQVtuKVLtU+uO9pThV1Yx+4SH4n9tHITREif/dcgKHLzVi6Uz5o9XeMDAuAvvO274v/CUFBwC1UoFbe+iafv11sYiP1CIxSovfz/Tv3PWrMS41Buv2lUGlVLhlTDcoPgI/ltbDbNeR//Zn12HnyWqcrmqCqdMivkQQItbD9dEuj8UwDNMb2Vhik4HPGpOMEBXH4ZjeybCkKAxNjMSpqmZ8fbQS87L8G7XmvxSGYWRnXFoM+oWHIDpUjfcWTEJcpGPuWf+YMEy1m6b8349+RHlDO+Ijtbiriy/HtLhwTBkSB6sVWG83MWto68ArX58CACy5dRh0YSHQqlX4//JG4eNFNyAp2r1UgMEGjVj7y7wMAG4cEt/jaHp0aAh++O+b8Xn+FHFevBzcODgeWrUSWWn93EoTkx7neCl2XXwEsq+LQ1SoGh1mK85UO1Ivijms9RyxZhim79BhtuDfdhn4z9kNnOnl3GZX220s8b87OA+sGYaRnXCNGluWTMO3f5jepQnUf9gH0cJ82f+6Kd3lPOT/nGiTjv9jfxkqG9tx/7t7UNtiwtDESNx7fZqfWiAfaWQQ6M+I9W1jus6V6gqtWiW72U1aXDi+XvozvH3/RLf2G0imBkwblgCFQoGR9qi0MM/aarU6BtZJHLFmGKbvsOvMZdS3diA+UoPr02O734FhghjBHfy7U9V+l4MHrRRcrVZDqVRK3J6p9JnKYKnklspnqYszIJV2Uwk3lYzTfagsl8p1ExMdOWap8zOF1s+V67MzPZFLV1ZWiuu0PVTKTGXrtD9oX1IZNHUzp9uprN653lQyTvehdaKO2nR/WicqiaaS9KqqKnGdXh/aL3Q7ddkGpO7f9L6hUnW6P+0DWg9aV1fTAeh1o+7itA7ODvB0fyrzduUKTu8hoe/p/dkXSIxyHTnOHa1HdKgaje2diA5VY/5k1wPk3NF66MJCUN7Qjltf3oHG9k70Cw/BS/859grpeF/AvxFr2/FUSoWYzqy3kRrrfm5yGrGebk99NiI5CnvP14ovdwyN7Whst5nfDU4Mjjn6DMMwvmCDPfPG7DHJffJ3k7m2GJYUhWFJkThZ2YzCo5VisMYf8F8LwzBBT2iICnfZI9H/Z2q6mGLLVdk7x/cHADS2d2JQXDj+9X+nBMwwK9AMjHUM6nxtXpYxQAetWok7xqb4/NjBzHUJEdCFhSA2QoPJ6TZfi5HJ0oi1EK1Oj49wS2bOMAwTzJg6LdhiN27MYxk400fIy7A522+0p5DzF0EXsRYidkJEj0blaJTPlbmVq3VAGk2ln7l7Dlfl6bqrc10tYu3usVxtd7Xuy77sSTlXJmo9Ke+qTj05Tk+PJVeZnu7vqrxwHYV/+5KJ2dV4bNZwzBiZiBvSu3cn/VX2QHyyrwwZ/XVY86usPj0o1IWHID5Sg5pmExKitN3v4Ab9Y8JwaMVMqFzkre+rRGjV+CJ/ClRKhThH3HlgfVyUgXP+aoZh+g7fn65GY3snEqO0mDSIZeBM3yAvU49Xvj6J707VoKG1w+0MLD0l6AbWgmzXYDDIXBPXUPfqYMFXdaJy52CBysUpVL7tCa72p3LunuCq7wPVl01NTZKpAL5k1apVePHFF2EwGDB27Fj85S9/wfXXX++Xc3WHVq3CjYPje1R2cEIkflp+K7RqpeQFVF/lubmZOFHZ5JdB3rUajR3klIJtWFIkFAqgptmEg2X1eOc7mzt95gD//O0xDMPIwYaDNoOn2zKSoVL2/d9P5tpgSGIURuijcNzQhD3nLvttelvQDaxTUlJQVlYGq9WKtLQ0lJWVXZE2y980NjYiNTU14OeW67xynvtabLOvzm21WtHU1ISUlBQf187GJ598gqVLl2LNmjWYPHkyXn31VeTm5uLEiRMSn4FgxZW5WV8kZ1QSckb1LBUW4xnhGjXS4yJwtqYFC97fi/rWDozQR+G+GwbKXTWGYRif0N5hRuFRm5fP7SwDZ/oYz87NQGKUFgP6ue+90lOCbmCtVCoxYMAAMS9xdHR0wAc9AnKdm9vM5+4p/opUA8DLL7+MBx98EA888AAAYM2aNdi4cSPee+89/Pd//7ffzsswwcrI5GicrWlBfWsH4iI0eGfBRERog+5nlGEYxiN2nqxGk7ET+uhQTEjrJ3d1GManBOKeZvMyhmGuwGQyobi4GDk5OeI2pVKJnJwcFBUVdbmP0WhEY2OjZGGYvsQIvU1qH6JSYM2vsvz61pthGCbQCHl+8zKToWQZOMO4DQ+sGYa5gpqaGpjNZiQlSeXFSUlJLv0PCgoKoNPpxCU1NTUQVWWYgDEvawBuGhqP1+8ez6Y+DMP0OfS6UMRHatgNnGE8JGgH1lqtFk899ZQkF3BfPze3ObBcq+f2F8uWLUNDQ4O4lJWVyV0lhvEpKTFh+H8LJ2N2Bj90MgzT91g2eyR2L5uB8akxcleFYXolCuu1kquHYZgeYzKZEB4ejn/84x+YM2eOuH3BggWor6/HF1980e0xGhsbodPp0NDQINscdoYJdvjvhGGYQMDfNQzTPd7+nQRtxJphGPnQaDTIysrCtm3bxG0WiwXbtm1Ddna2jDVjGIZhGIZhmOCD7UwZhumSpUuXYsGCBZg4cSKuv/56vPrqq2hpaRFdwhmGYRiGYRiGscEDa4ZhuuSXv/wlqqursXz5chgMBowbNw6bN2++wtCMYRiGYRiGYa51eGDNMIxLFi9ejMWLF8tdDYZhGIZhGIYJaniONcMwDMMwDMMwDMN4AQ+sGYZhGIZhGIZhGMYLWArOMIxfEDL5NTY2ylwThglehL8PznzJMIw/4d9khukeb3+TeWDNMIxfaGpqAgCkpqbKXBOGCX6ampqg0+nkrgbDMH0U/k1mmJ7j6W+ywsqvyRmG8QMWiwXl5eWIioqCQqHoskxjYyNSU1NRVlaG6OjoANcwMPT1Nvb19gH+baPVakVTUxNSUlKgVPLsLIZh/AP/Jgcf3N+BpSf97e1vMkesGYbxC0qlEgMGDOhR2ejo6D7/o9LX29jX2wf4r40cqWYYxt/wb3Lwwv0dWLrrb29+k/n1OMMwDMMwDMMwDMN4AQ+sGYZhGIZhGIZhGMYLeGDNMIxsaLVaPPXUU9BqtXJXxW/09Tb29fYB10YbGYZh+LsusHB/B5ZA9DeblzEMwzAMwzAMwzCMF3DEmmEYhmEYhmEYhmG8gAfWDMMwDMMwDMMwDOMFPLBmGIZhGIZhGIZhGC/ggTXDMAzDMAzDMAzDeAEPrBmGkY1Vq1Zh0KBBCA0NxeTJk7F37165q+QRBQUFmDRpEqKiopCYmIg5c+bgxIkTkjLt7e3Iz89HXFwcIiMjMW/ePFRWVspUY+947rnnoFAo8Oijj4rb+kL7Ll26hPvuuw9xcXEICwtDRkYG9u/fL35utVqxfPlyJCcnIywsDDk5OTh16pSMNWYYhvEdfeU3OdjpyTMD4x+6en7xJTywZhhGFj755BMsXboUTz31FH788UeMHTsWubm5qKqqkrtqbrNjxw7k5+dj9+7dKCwsREdHB2bOnImWlhaxzJIlS/DVV19h/fr12LFjB8rLyzF37lwZa+0Z+/btw5tvvonMzEzJ9t7evrq6OkyZMgUhISH497//jaNHj+Kll15Cv379xDIvvPACXn/9daxZswZ79uxBREQEcnNz0d7eLmPNGYZhvKcv/SYHOz15ZmB8j6vnF59iZRiGkYHrr7/emp+fL/7fbDZbU1JSrAUFBTLWyjdUVVVZAVh37NhhtVqt1vr6emtISIh1/fr1Ypljx45ZAViLiorkqqbbNDU1WYcOHWotLCy0/uxnP7P+7ne/s1qtfaN9jz/+uHXq1KkuP7dYLFa9Xm998cUXxW319fVWrVZr/fjjjwNRRYZhGL/Rl3+Tgx3nZwbG97h6fvE1HLFmGCbgmEwmFBcXIycnR9ymVCqRk5ODoqIiGWvmGxoaGgAAsbGxAIDi4mJ0dHRI2jtixAikpaX1qvbm5+cjLy9P0g6gb7Tvyy+/xMSJE3HXXXchMTER48ePx9tvvy1+fu7cORgMBkkbdTodJk+e3GvayDAM0xV9/Tc52HF+ZmB8j6vnF1+j9uvRGYZhuqCmpgZmsxlJSUmS7UlJSTh+/LhMtfINFosFjz76KKZMmYIxY8YAAAwGAzQaDWJiYiRlk5KSYDAYZKil+6xbtw4//vgj9u3bd8VnfaF9Z8+exerVq7F06VI88cQT2LdvHx555BFoNBosWLBAbEdX92xvaSPDMExX9OXf5GCnq2cGxrdc7fnF1/DAmmEYxofk5+fj8OHD+P777+Wuis8oKyvD7373OxQWFiI0NFTu6vgFi8WCiRMn4tlnnwUAjB8/HocPH8aaNWuwYMECmWvHMAzD9EX64jNDMBHo5xeWgjMME3Di4+OhUqmucI2urKyEXq+XqVbes3jxYmzYsAHffvstBgwYIG7X6/UwmUyor6+XlO8t7S0uLkZVVRUmTJgAtVoNtVqNHTt24PXXX4darUZSUlKvbh8AJCcnY9SoUZJtI0eORGlpKQCI7ehr9yzDMExf/U0Odlw9MzC+o7vnF7PZ7NPz8cCaYZiAo9FokJWVhW3btonbLBYLtm3bhuzsbBlr5hlWqxWLFy/GZ599hm+++Qbp6emSz7OyshASEiJp74kTJ1BaWtor2jtjxgyUlJTgwIED4jJx4kTMnz9fXO/N7QOAKVOmXJHu5OTJkxg4cCAAID09HXq9XtLGxsZG7Nmzp9e0kWEYpiv62m9ysNPdMwPjO7p7flGpVD49H0vBGYaRhaVLl2LBggWYOHEirr/+erz66qtoaWnBAw88IHfV3CY/Px9r167FF198gaioKHHOrU6nQ1hYGHQ6HRYuXIilS5ciNjYW0dHRePjhh5GdnY0bbrhB5tp3T1RU1BVzvyIiIhAXFydu783tA2zpwm688UY8++yz+M///E/s3bsXb731Ft566y0AEPNePvPMMxg6dCjS09PxP//zP0hJScGcOXPkrTzDMIyX9KXf5GCnu2cGxnf05PnFl/DAmmEYWfjlL3+J6upqLF++HAaDAePGjcPmzZuvME/pDaxevRoAMH36dMn2999/H7/+9a8BAK+88gqUSiXmzZsHo9GI3NxcvPHGGwGuqf/o7e2bNGkSPvvsMyxbtgwrV65Eeno6Xn31VcyfP18s89hjj6GlpQWLFi1CfX09pk6dis2bN/fZeecMw1w79KXf5GCnJ88MTO9EYbVarXJXgmEYhmEYhmEYhmF6KzzHmmEYhmEYhmEYhmG8gAfWDMMwDMMwDMMwDOMFPLBmGIZhGIZhGIZhGC/ggTXDMAzDMAzDMAzDeAEPrBmGYRiGYRiGYRjGC3hgzTAMwzAMwzAMwzBewANrhmEYhmEYhmEYhvECHlgzDMMwDMMwDMMwjBfwwJphGIZhGIZhGIZhvIAH1gzDMAzDMAzDMAzjBTywZhiGYRiGYRiGYRgv4IE1wzAMwzAMwzAMw3jB/w8WbKFM2Gpy/wAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -170,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": 111, + "execution_count": 160, "metadata": {}, "outputs": [], "source": [ @@ -201,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 112, + "execution_count": 161, "metadata": {}, "outputs": [], "source": [ @@ -213,20 +212,20 @@ }, { "cell_type": "code", - "execution_count": 118, + "execution_count": 162, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[1.02 1.02]\n", - "[1.26]\n" + "[1.98 1.98]\n", + "[]\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -269,7 +268,7 @@ "ax[1,3].set_title(\"Full Raw XZ intensity \\n at the center\")\n", "\n", "# get the distance between peaks in the first plot\n", - "peaks_indices_XY, _ = find_peaks(rgc_img[rgc_img.shape[0]//2, rgc_img.shape[1]//2, : ], height=0.1*rgc_img[rgc_img.shape[0]//2, :].max())\n", + "peaks_indices_XY, _ = find_peaks(rgc_img[rgc_img.shape[0]//2, rgc_img.shape[1]//2, : ], height=0.5*rgc_img[rgc_img.shape[0]//2, :].max())\n", "print((peaks_indices_XY[1:] - peaks_indices_XY[:-1])*pixel_size/magnification_xy)\n", "\n", "# get the distance between peaks in the second plot\n", @@ -292,18 +291,9 @@ }, { "cell_type": "code", - "execution_count": 114, + "execution_count": 163, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1.02 1.02]\n", - "[1.26]\n" - ] - } - ], + "outputs": [], "source": [ "from scipy.signal import find_peaks\n" ] From b2d235679afcb5e4c71ed331adc0b855aacaf7b6 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 22 Mar 2024 14:41:24 +0000 Subject: [PATCH 73/81] gradient declaration improve --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 8049c53c..fca2cd1e 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -174,20 +174,22 @@ class eSRRF3D(LiquidEngine): # image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) # image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) - image_interpolated = interpolate_3d_zlinear(image[f], _magnification_xy, _magnification_z) + image_interpolated = interpolate_3d_zlinear(image[f,:,:,:], _magnification_xy, _magnification_z) n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] - gradients_c = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) - gradients_r = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) - gradients_s = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) - img_dum = interpolator.run(image[f], 0, 0, Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) # img_dum = interpolate_3d(image[f], Gx_Gy_MAGNIFICATION, _magnification_z) + # img_dum = interpolate_3d_zlinear(image[f], Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) + n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum = img_dum.shape[0], img_dum.shape[1], img_dum.shape[2] + gradients_c = np.zeros((n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum), dtype=np.float32) + gradients_r = np.zeros((n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum), dtype=np.float32) + gradients_s = np.zeros((n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum), dtype=np.float32) + with nogil: - _c_gradient_3d(&img_dum[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices, n_rows_mag_dum, n_cols_mag_dum) + _c_gradient_3d(&img_dum[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum) # gradients_s_interpolated = interpolator.run(gradients_s, 0, 0, _magnification_xy, _magnification_xy) # gradients_r_interpolated = interpolator.run(gradients_r, 0, 0, _magnification_xy, _magnification_xy) @@ -236,7 +238,7 @@ class eSRRF3D(LiquidEngine): # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val - return np.asarray(rgc_map) + return np.asarray(rgc_map) #, np.asarray(gradients_s_interpolated), np.asarray(gradients_r_interpolated), np.asarray(image_interpolated) # debug def get_gradients(self): if self._gradients_c_interpolated is None or self._gradients_r_interpolated is None or self._gradients_s_interpolated is None: From c6df103a54264dcc7f960a74fcbcacab91068b3b Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 22 Mar 2024 14:41:40 +0000 Subject: [PATCH 74/81] access slices properly --- src/include/_c_sr_radial_gradient_convergence.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index f6a2183a..8848cfe3 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -116,7 +116,7 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn float xc = (xM + 0.5) / magnification_xy; float yc = (yM + 0.5) / magnification_xy; - float zc = (sliceM + 1) / magnification_z; + float zc = (sliceM) / magnification_z; float RGC = 0; float distanceWeightSum = 0; From 852f9af29bbcba034d896d4bbcf9dcb9fafb5934 Mon Sep 17 00:00:00 2001 From: Bruno Saraiva Date: Fri, 22 Mar 2024 14:49:09 +0000 Subject: [PATCH 75/81] changed 1D interpolator --- src/nanopyx/core/transform/_interpolation.pyx | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/src/nanopyx/core/transform/_interpolation.pyx b/src/nanopyx/core/transform/_interpolation.pyx index 2dada44b..0d4dbcf3 100644 --- a/src/nanopyx/core/transform/_interpolation.pyx +++ b/src/nanopyx/core/transform/_interpolation.pyx @@ -35,14 +35,13 @@ def linear_interpolation_1D_z(image, magnification): image_interpolated = np.zeros((image.shape[0] * magnification, image.shape[1], image.shape[2]), dtype=np.float32) - # for s in range(image.shape[0]): - # for r in range(image.shape[1]): - # for c in range(image.shape[2]): - # image_interpolated[s*magnification:(s+1)*magnification, r, c] = np.linspace(image[s, r, c], image[s+1, r, c], magnification) - - # run over all the planes - for s in range(image.shape[0]-1): - image_interpolated[s*magnification:(s+1)*magnification, :,:] = np.linspace(image[s, :,:], image[s+1, :,:], magnification) + z_coords = np.linspace(0, image.shape[0], image.shape[0]) + new_z_coords = np.linspace(0, image.shape[0], image.shape[0] * magnification) + + for r in image.shape[1]: + for c in image.shape[2]: + slc = image[:, r, c] + image_interpolated[:, r, c] = np.interp(new_z_coords, z_coords, slc) return image_interpolated From ccbbea69e172364c935a7c7e2d7b07e0d797529e Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 22 Mar 2024 15:09:51 +0000 Subject: [PATCH 76/81] corrected for --- src/nanopyx/core/transform/_interpolation.pyx | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/nanopyx/core/transform/_interpolation.pyx b/src/nanopyx/core/transform/_interpolation.pyx index 0d4dbcf3..aefab8a6 100644 --- a/src/nanopyx/core/transform/_interpolation.pyx +++ b/src/nanopyx/core/transform/_interpolation.pyx @@ -38,11 +38,12 @@ def linear_interpolation_1D_z(image, magnification): z_coords = np.linspace(0, image.shape[0], image.shape[0]) new_z_coords = np.linspace(0, image.shape[0], image.shape[0] * magnification) - for r in image.shape[1]: - for c in image.shape[2]: + for r in range(image.shape[1]): + for c in range(image.shape[2]): slc = image[:, r, c] image_interpolated[:, r, c] = np.interp(new_z_coords, z_coords, slc) + return image_interpolated From c7bd3e6835ab336798d4a7a6ae07f82523f7fce0 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 22 Mar 2024 15:32:45 +0000 Subject: [PATCH 77/81] dirty working version --- src/nanopyx/core/transform/_le_esrrf3d.pyx | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index fca2cd1e..63b2312a 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -169,7 +169,7 @@ class eSRRF3D(LiquidEngine): cdef int f, n_slices_mag, n_rows_mag, n_cols_mag, sM, rM, cM, z0 cdef float rgc_val, zcof - + for f in range(n_frames): # image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) @@ -178,16 +178,15 @@ class eSRRF3D(LiquidEngine): n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] - img_dum = interpolator.run(image[f], 0, 0, Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) + # img_dum = interpolator.run(image[f], 0, 0, Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) # img_dum = interpolate_3d(image[f], Gx_Gy_MAGNIFICATION, _magnification_z) - # img_dum = interpolate_3d_zlinear(image[f], Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) + img_dum = interpolate_3d_zlinear(image[f], Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum = img_dum.shape[0], img_dum.shape[1], img_dum.shape[2] gradients_c = np.zeros((n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum), dtype=np.float32) gradients_r = np.zeros((n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum), dtype=np.float32) gradients_s = np.zeros((n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum), dtype=np.float32) - with nogil: _c_gradient_3d(&img_dum[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum) @@ -237,7 +236,7 @@ class eSRRF3D(LiquidEngine): # z0 = floor(zcof) # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val - + return np.asarray(rgc_map) #, np.asarray(gradients_s_interpolated), np.asarray(gradients_r_interpolated), np.asarray(image_interpolated) # debug def get_gradients(self): From c7c3a1d7e92554be2d646b4558be56ea08d4a9ef Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 22 Mar 2024 15:32:56 +0000 Subject: [PATCH 78/81] dirty working version --- src/include/_c_sr_radial_gradient_convergence.c | 2 +- src/nanopyx/core/transform/_interpolation.pyx | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 8848cfe3..da63467f 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -116,7 +116,7 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn float xc = (xM + 0.5) / magnification_xy; float yc = (yM + 0.5) / magnification_xy; - float zc = (sliceM) / magnification_z; + float zc = (sliceM + 0.5) / magnification_z; float RGC = 0; float distanceWeightSum = 0; diff --git a/src/nanopyx/core/transform/_interpolation.pyx b/src/nanopyx/core/transform/_interpolation.pyx index aefab8a6..a426f990 100644 --- a/src/nanopyx/core/transform/_interpolation.pyx +++ b/src/nanopyx/core/transform/_interpolation.pyx @@ -50,7 +50,7 @@ def linear_interpolation_1D_z(image, magnification): def interpolate_3d_zlinear(image, magnification_xy: int = 5, magnification_z: int = 5): interpolator_xy = ShiftMagnify_CR() - xy_interpolated = interpolator_xy.run(image, 0, 0, magnification_xy, magnification_xy) + xy_interpolated = interpolator_xy.run(np.ascontiguousarray(image), 0, 0, magnification_xy, magnification_xy) z_interpolated = linear_interpolation_1D_z(xy_interpolated, magnification_z) return z_interpolated From e0953a23667853cc1d2007775ac05f0674b2e375 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 22 Mar 2024 15:38:57 +0000 Subject: [PATCH 79/81] clean working version --- .../_c_sr_radial_gradient_convergence.c | 13 +--- src/nanopyx/core/transform/_le_esrrf3d.pyx | 62 +------------------ .../transform/sr_temporal_correlations.py | 3 +- 3 files changed, 4 insertions(+), 74 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index da63467f..af141bc5 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -144,24 +144,15 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn dx = vx - xc; dy = vy - yc; dz = vz - zc; - dz_real = dz * ratio_px; // This has been already divigy by magnification_z + dz_real = dz * ratio_px; // This has been already divided by magnification_z distance = sqrt(dx * dx + dy * dy + dz_real * dz_real); distance_xy = sqrt(dx * dx + dy * dy); distance_z = dz_real; - // if (distance != 0 && distance <= tSO ) { if (distance != 0 && distance_xy <= tSO && distance_z <= tSO_z) { - - // Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, Gx_Gy_MAGNIFICATION * magnification_xy * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - // Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - // Gz = _c_get_bound_value(imIntGz, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, magnification_xy * vz * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); Gz = _c_get_bound_value(imIntGz, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - // Gx = imIntGx[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; - // Gy = imIntGy[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; - // Gz = imIntGz[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; // distanceWeight = _c_calculate_dw3D_isotropic(distance, tSS); distanceWeight = _c_calculate_dw3D(distance, distance_xy, distance_z, tSS, tSS_z); @@ -176,8 +167,6 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn if (GdotR < 0) { Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz_real, distance); - // RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; - // RGC += (Dk * distanceWeightSum); // test RGC += (Dk * distanceWeight); } } diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 63b2312a..77ffffd4 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -56,8 +56,6 @@ class eSRRF3D(LiquidEngine): cdef float fwhm = radius cdef float tSS = 2 * sigma * sigma cdef float tSO = 2 * sigma + 1 - # cdef float sigma_z = radius_z / 2.355 # Old version - # cdef float fwhm_z = radius_z cdef float sigma_z = radius * ratio_px / 2.355 # Taking voxel size into account cdef float fwhm_z = radius * ratio_px cdef float tSS_z = 2 * sigma_z * sigma_z @@ -79,8 +77,6 @@ class eSRRF3D(LiquidEngine): cdef float rgc_val, zcof for f in range(n_frames): - - # image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] @@ -89,16 +85,11 @@ class eSRRF3D(LiquidEngine): gradients_s = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) img_dum = interpolator.run(image[f], 0, 0, Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) - # img_dum = interpolate_3d(image[f], Gx_Gy_MAGNIFICATION, _magnification_z) n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum = img_dum.shape[0], img_dum.shape[1], img_dum.shape[2] with nogil: _c_gradient_3d(&img_dum[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices, n_rows_mag_dum, n_cols_mag_dum) - # gradients_s_interpolated = interpolator.run(gradients_s, 0, 0, _magnification_xy, _magnification_xy) - # gradients_r_interpolated = interpolator.run(gradients_r, 0, 0, _magnification_xy, _magnification_xy) - # gradients_c_interpolated = interpolator.run(gradients_c, 0, 0, _magnification_xy, _magnification_xy) - gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy, _magnification_z) gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy, _magnification_z) gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy, _magnification_z) @@ -117,39 +108,20 @@ class eSRRF3D(LiquidEngine): for cM in range(0, n_cols_mag): if _doIntensityWeighting: rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - # zcof = (sM) / _magnification_z - # if (zcof < 0): - # z0 = 0 - # elif (zcof >= n_slices-1): - # z0 = n_slices-1 - # else: - # z0 = floor(zcof) - # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val * image_interpolated[sM, rM, cM] else: rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - # zcof = (sM) / _magnification_z - # if (zcof < 0): - # z0 = 0 - # elif (zcof >= n_slices-1): - # z0 = n_slices-1 - # else: - # z0 = floor(zcof) - # z0 = z0 * _magnification_z + rgc_map[f, sM, rM, cM] = rgc_val return np.asarray(rgc_map) def _run_threaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, ratio_px: float = 4.0, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Threaded"): - interpolator = ShiftAndMagnify() - cdef float sigma = radius / 2.355 cdef float fwhm = radius cdef float tSS = 2 * sigma * sigma cdef float tSO = 2 * sigma + 1 - # cdef float sigma_z = radius_z / 2.355 # Old version - # cdef float fwhm_z = radius_z cdef float sigma_z = radius * ratio_px / 2.355 # Taking voxel size into account cdef float fwhm_z = radius * ratio_px cdef float tSS_z = 2 * sigma_z * sigma_z @@ -171,17 +143,11 @@ class eSRRF3D(LiquidEngine): cdef float rgc_val, zcof for f in range(n_frames): - # image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) - - # image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) image_interpolated = interpolate_3d_zlinear(image[f,:,:,:], _magnification_xy, _magnification_z) n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] - # img_dum = interpolator.run(image[f], 0, 0, Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) - # img_dum = interpolate_3d(image[f], Gx_Gy_MAGNIFICATION, _magnification_z) img_dum = interpolate_3d_zlinear(image[f], Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) - n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum = img_dum.shape[0], img_dum.shape[1], img_dum.shape[2] gradients_c = np.zeros((n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum), dtype=np.float32) @@ -190,14 +156,6 @@ class eSRRF3D(LiquidEngine): with nogil: _c_gradient_3d(&img_dum[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum) - # gradients_s_interpolated = interpolator.run(gradients_s, 0, 0, _magnification_xy, _magnification_xy) - # gradients_r_interpolated = interpolator.run(gradients_r, 0, 0, _magnification_xy, _magnification_xy) - # gradients_c_interpolated = interpolator.run(gradients_c, 0, 0, _magnification_xy, _magnification_xy) - - # gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy, _magnification_z) - # gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy, _magnification_z) - # gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy, _magnification_z) - gradients_s_interpolated = interpolate_3d_zlinear(gradients_s, _magnification_xy, _magnification_z) gradients_r_interpolated = interpolate_3d_zlinear(gradients_r, _magnification_xy, _magnification_z) gradients_c_interpolated = interpolate_3d_zlinear(gradients_c, _magnification_xy, _magnification_z) @@ -216,28 +174,12 @@ class eSRRF3D(LiquidEngine): for cM in range(0, n_cols_mag): if _doIntensityWeighting: rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - # zcof = (sM) / _magnification_z - # if (zcof < 0): - # z0 = 0 - # elif (zcof >= n_slices-1): - # z0 = n_slices-1 - # else: - # z0 = floor(zcof) - # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val * image_interpolated[sM, rM, cM] else: rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - # zcof = (sM) / _magnification_z - # if (zcof < 0): - # z0 = 0 - # elif (zcof >= n_slices-1): - # z0 = n_slices-1 - # else: - # z0 = floor(zcof) - # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val - return np.asarray(rgc_map) #, np.asarray(gradients_s_interpolated), np.asarray(gradients_r_interpolated), np.asarray(image_interpolated) # debug + return np.asarray(rgc_map) def get_gradients(self): if self._gradients_c_interpolated is None or self._gradients_r_interpolated is None or self._gradients_s_interpolated is None: diff --git a/src/nanopyx/core/transform/sr_temporal_correlations.py b/src/nanopyx/core/transform/sr_temporal_correlations.py index f33785a0..f6560407 100644 --- a/src/nanopyx/core/transform/sr_temporal_correlations.py +++ b/src/nanopyx/core/transform/sr_temporal_correlations.py @@ -229,7 +229,7 @@ def calculate_eSRRF3d_temporal_correlations(rgc_map, correlation: str = "AVG", f return rgc_map else: - if framewindow != 0: + if framewindow > 0: if rollingoverlap: n_windows = int((n_frames - framewindow) / rollingoverlap) + 1 else: @@ -243,7 +243,6 @@ def calculate_eSRRF3d_temporal_correlations(rgc_map, correlation: str = "AVG", f for w in range(n_windows): start_frame = w * (int(framewindow) - int(rollingoverlap)) end_frame = start_frame + int(framewindow) - # do average in the first dimension of rgc_map[start_frame:end_frame ,:,:,:] with numpy avg_rgc_map[w,:,:,:] = calculate_eSRRF_temporal_correlations(rgc_map[start_frame:end_frame,:,:,:], correlation) return avg_rgc_map \ No newline at end of file From b8b97951f81d7ecd389ff04947935f3fffcfda85 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 22 Mar 2024 15:39:26 +0000 Subject: [PATCH 80/81] dirty notebooks --- tests/notebooks/esrrf3d.ipynb | 369 ++++++++++++++----------- tests/test_3D_eSRRF/load_analyse.ipynb | 115 ++++---- 2 files changed, 270 insertions(+), 214 deletions(-) diff --git a/tests/notebooks/esrrf3d.ipynb b/tests/notebooks/esrrf3d.ipynb index 8ea24d40..7f7537c0 100644 --- a/tests/notebooks/esrrf3d.ipynb +++ b/tests/notebooks/esrrf3d.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -37,7 +37,7 @@ "(21, 9, 50, 50)" ] }, - "execution_count": 3, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -48,13 +48,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "bd77d0d909714305b3da3b3ad9146877", + "model_id": "41f8b80c99734713ae8542d94f34a908", "version_major": 2, "version_minor": 0 }, @@ -62,7 +62,7 @@ "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=50, width=50),)),)), IntSlider(value=2, descri…" ] }, - "execution_count": 4, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } @@ -84,16 +84,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ "# Define variables\n", "\n", - "magnification_xy=2\n", - "magnification_z=2\n", + "magnification_xy=1\n", + "magnification_z=1\n", "radius=2\n", - "radius_z = 2\n", + "radius_z = 1\n", "ratio_px = 4\n", "sensitivity=2\n", "run_type=\"Threaded\"\n", @@ -104,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 39, "metadata": {}, "outputs": [ { @@ -114,352 +114,390 @@ "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013462919999938094 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011618374999997627 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.7876394100629203, Delay probability: 0.15362317783003085\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013667919999988953 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011809249999998883 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.196533371003347, Delay probability: 0.3408309241242591\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005537709000009272 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011255499999990093 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005368333000006942 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01049608399999613 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0055529999999919255 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012502040999990527 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1659572654757324, Delay probability: 0.38101316068177127\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0014406670000255417 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0737183763267601, Delay probability: 0.30827479597258406\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.006515875000005167 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013626660000056745 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009240916999999627 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005570584000025747 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010658249999991654 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.00546837499999242 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009616374999993127 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005385125000003654 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01197137499998746 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1218511801736744, Delay probability: 0.29834919892019013\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.001346041000005016 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0066248749999999745 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013441250000028049 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.00923270799999898 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0054856669999878704 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011078333000000384 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005531832999992048 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.016503666999994948 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.544868640175262, Delay probability: 0.2983491989201902\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0056671250000022155 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01035854100000222 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013387089999810087 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.006259833000001436 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0014154999999789197 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0555437485651324, Delay probability: 0.4083441962488562\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010261416000005852 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005619042000006402 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010076916999992136 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005384374999977126 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010106750000005604 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0054248330000064016 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010182833000001779 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0014457080000056521 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0780699693954734, Delay probability: 0.4083441962488562\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0068042500000018435 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0014555420000021968 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0854032206988269, Delay probability: 0.4083441962488562\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0099728339999956 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005476750000013908 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009371125000001257 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005451708000009603 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011112291999992863 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0056754999999952815 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009568208999993999 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0014317499999947358 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0676614355528637, Delay probability: 0.47298380752538954\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0061983749999967586 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013645839999867349 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009718000000006555 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005447500000002492 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010413582999987625 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0054912919999878795 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01075566699999797 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005695124999988366 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009886375000007774 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013360419999912665 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.006634583999996835 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013282500000002528 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010288708000004476 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005428874999978461 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009826000000003887 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.00533270799999741 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01008716700000889 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0054650840000078915 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009487999999990393 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013580829999852995 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.00685729200000651 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013807500000098116 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010703500000005306 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005521249999986821 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010051625000002673 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005496458000010307 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010480540999992627 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0054619590000015705 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010506792000001042 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013678329999891048 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.00644358300000647 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.001322375000000875 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009311291000003052 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0054277499999955126 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009785499999992453 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005429832999993778 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010117250000007516 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005358250000000453 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010544667000004893 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013385839999955351 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.006225083000003906 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013192920000051345 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010572874999994042 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005291875000011714 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011251583999992931 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0058725840000022345 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009949417000001404 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005610667000013336 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011891250000005016 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1721747575417882, Delay probability: 0.31805424426260626\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013294590000043627 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.007157417000001942 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.00133658300001116 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01190862500000378 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1965927818048916, Delay probability: 0.15240456203671085\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005429917000014939 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010140958000008027 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005434542000017473 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01101308399999823 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005645665999992389 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011847791000008101 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1702777900103836, Delay probability: 0.14370002496050244\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013358749999952124 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.007982166000005009 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.2251743428895232, Delay probability: 0.15362317783003085\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013852909999911844 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0341246479897128, Delay probability: 0.41748210296057237\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011950166000005424 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1964255873434486, Delay probability: 0.21949640760962807\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005482291999982181 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010167999999993071 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005598958000007315 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009515416999988702 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005336875000011787 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009628374999991252 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013741250000123273 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.007010665999999333 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013324999999895226 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010242375000004245 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0056784169999843925 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010686250000006225 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005745167000014817 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01148866600000531 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1449637985394634, Delay probability: 0.09538048989205275\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005623333000016828 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010850666999999703 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013190420000057657 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.006503917000003412 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.001343332999994118 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009681916999994655 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005645582999989074 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010692250000005288 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005915125000001353 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011679208000003882 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1639532697365171, Delay probability: 0.0953804898920527\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005411417000004803 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010220541999999 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.001310334000010016 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.006419917000002329 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013337500000147884 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009971375000006333 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005409624999998641 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01365233299999602 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.3621969575326864, Delay probability: 0.09906174404462277\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005467291000002206 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012366624999998521 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.2339121049823907, Delay probability: 0.15362317783003085\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005455041999994137 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010759375000006344 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013138749999939137 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0074462919999973565 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013297920000070462 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009730165999997098 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005425874999986036 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010948666000004437 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005364249999985304 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011124666000000616 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005818957999991881 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011276583000011442 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013095409999834828 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.006469042000006198 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0014537089999748787 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0868255577600243, Delay probability: 0.38837201988393893\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009891666999990889 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005578082999988965 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010416167000002474 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005501291999991054 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.035910791999995695 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 3.5845046020251647, Delay probability: 0.15362317783003085\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005426749999998037 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010586583999995014 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013102080000066962 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.007262166999993269 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013212499999895044 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01254154199999391 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.262301299604511, Delay probability: 0.21212683069525057\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005330791999995199 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010822333999996658 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005402582999977312 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01018799999999942 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005333500000006097 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011359999999996262 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1353167255229482, Delay probability: 0.15362317783003085\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.00135920799999667 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.007604958000001716 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1546549809005582, Delay probability: 0.19059030028256213\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013410420000070644 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012101541000006932 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.2119546622599162, Delay probability: 0.2672640572327181\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0053479579999873295 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010868874999999889 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005340125000003582 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012123750000000655 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.2071660735640684, Delay probability: 0.14522852731264677\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005395708000008881 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011626875000004588 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.157692054156099, Delay probability: 0.21212683069525057\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.001325500000007196 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.008129708999987884 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.2343275255571415, Delay probability: 0.24255070001316215\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013255419999893547 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.015464417000004005 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.5407957129639682, Delay probability: 0.3172827755903742\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.00543729200001053 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011209042000004388 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005319667000009076 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01095458400000382 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005410291999993433 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.00973195800000326 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0013777919999995447 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0315619045992943, Delay probability: 0.4271908108851267\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.00897650000000283 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.3622825893205066, Delay probability: 0.29031687843932275\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0014224580000075093 seconds\n", - "Run type Threaded_guided was delayed in the previous run. Delay factor: 1.0650036316807867, Delay probability: 0.4271908108851267\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011002417000000264 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0055249170000024606 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012095250000001556 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.2048893808895609, Delay probability: 0.21212683069525048\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005654290999984823 seconds\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010946042000000489 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.005406291000014107 seconds\n", - "Agent: eSRRF_3D using Threaded ran in 33.727187708 seconds\n" + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010915374999996175 seconds\n", + "Agent: eSRRF_3D using Threaded ran in 5.559033249999999 seconds\n" ] } ], "source": [ "esrrf = eSRRF3D()\n", - "# int_img, grad_r_int, grad_c_int, grad_s_int, rgc_img = esrrf.run(img, magnification_xy=1, magnification_z=1, radius=3, sensitivity=2, run_type=\"Unthreaded\", doIntensityWeighting=True)\n", + "# int_img, grad_r_int, grad_c_int, grad_s_int = esrrf.run(img4ana, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, radius_z =radius_z, ratio_px = ratio_px, sensitivity=sensitivity, run_type=run_type)\n", + "# int_img = esrrf.run(img4ana, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, radius_z =radius_z, ratio_px = ratio_px, sensitivity=sensitivity, run_type=run_type)\n", + "\n", "# rgc_img = esrrf.run(img, magnification_xy=2, magnification_z=2, radius=3, sensitivity=2, run_type=\"Threaded\", doIntensityWeighting=True)\n", "\n", "# rgc_img = run_esrrf3d(img, magnification_xy=2, magnification_z=2, radius=3, sensitivity=2, run_type=\"Threaded\", correlation=\"AVG\", framewindow=0, rollingoverlap=1)\n", - "rgc_img = run_esrrf3d(img4ana, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, radius_z =radius_z, ratio_px = ratio_px, sensitivity=sensitivity, run_type=run_type, correlation=correlation, framewindow=framewindow, rollingoverlap=rollingoverlap)" + "rgc_img = run_esrrf3d(img4ana, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, radius_z =radius_z, ratio_px = ratio_px, sensitivity=sensitivity, run_type=run_type, correlation=correlation, framewindow=framewindow, rollingoverlap=rollingoverlap)\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 40, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(21, 9, 50, 50)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "img.shape" + "# grad_s_int[:,:]" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "# stackview.slice(grad_s_int)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(9, 10, 100, 100)" + "(9, 5, 50, 50)" ] }, - "execution_count": 15, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } @@ -470,7 +508,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ @@ -482,7 +520,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 44, "metadata": {}, "outputs": [], "source": [ @@ -512,33 +550,32 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 45, "metadata": {}, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d870a17bc7b14ca28ea2bad9f3b57831", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=100, width=100),)),)), IntSlider(value=5, desc…" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" + "ename": "NotImplementedError", + "evalue": "Only 2D images are supported(5, 50, 50)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNotImplementedError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[45], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m rgc_img\u001b[38;5;241m.\u001b[39mshape\n\u001b[0;32m----> 2\u001b[0m \u001b[43mstackview\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mslice\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrgc_img\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/nanopyxdev/lib/python3.9/site-packages/stackview/_slice.py:53\u001b[0m, in \u001b[0;36mslice\u001b[0;34m(image, slice_number, axis, display_width, display_height, continuous_update, slider_text, zoom_factor, zoom_spline_order, colormap, display_min, display_max)\u001b[0m\n\u001b[1;32m 50\u001b[0m image \u001b[38;5;241m=\u001b[39m image\u001b[38;5;241m.\u001b[39mget()\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mipywidgets\u001b[39;00m\n\u001b[0;32m---> 53\u001b[0m viewer \u001b[38;5;241m=\u001b[39m \u001b[43m_SliceViewer\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 54\u001b[0m \u001b[43m \u001b[49m\u001b[43mslice_number\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 55\u001b[0m \u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 56\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_width\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 57\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_height\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 58\u001b[0m \u001b[43m \u001b[49m\u001b[43mcontinuous_update\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 59\u001b[0m \u001b[43m \u001b[49m\u001b[43mslider_text\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 60\u001b[0m \u001b[43m \u001b[49m\u001b[43mzoom_factor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzoom_factor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 61\u001b[0m \u001b[43m \u001b[49m\u001b[43mzoom_spline_order\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzoom_spline_order\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 62\u001b[0m \u001b[43m \u001b[49m\u001b[43mcolormap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcolormap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 63\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_min\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdisplay_min\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 64\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_max\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdisplay_max\u001b[49m\n\u001b[1;32m 65\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 66\u001b[0m view \u001b[38;5;241m=\u001b[39m viewer\u001b[38;5;241m.\u001b[39mview\n\u001b[1;32m 67\u001b[0m slice_slider \u001b[38;5;241m=\u001b[39m viewer\u001b[38;5;241m.\u001b[39mslice_slider\n", + "File \u001b[0;32m~/miniforge3/envs/nanopyxdev/lib/python3.9/site-packages/stackview/_slice_viewer.py:30\u001b[0m, in \u001b[0;36m_SliceViewer.__init__\u001b[0;34m(self, image, slice_number, axis, display_width, display_height, continuous_update, slider_text, zoom_factor, zoom_spline_order, colormap, display_min, display_max)\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 29\u001b[0m sliced_image \u001b[38;5;241m=\u001b[39m image\n\u001b[0;32m---> 30\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mview \u001b[38;5;241m=\u001b[39m \u001b[43mImageWidget\u001b[49m\u001b[43m(\u001b[49m\u001b[43msliced_image\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 31\u001b[0m \u001b[43m \u001b[49m\u001b[43mzoom_factor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzoom_factor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 32\u001b[0m \u001b[43m \u001b[49m\u001b[43mzoom_spline_order\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzoom_spline_order\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 33\u001b[0m \u001b[43m \u001b[49m\u001b[43mcolormap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcolormap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 34\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_min\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdisplay_min\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 35\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_max\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdisplay_max\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 37\u001b[0m \u001b[38;5;66;03m# setup user interface for changing the slice\u001b[39;00m\n\u001b[1;32m 38\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mslice_slider \u001b[38;5;241m=\u001b[39m ipywidgets\u001b[38;5;241m.\u001b[39mIntSlider(\n\u001b[1;32m 39\u001b[0m value\u001b[38;5;241m=\u001b[39mslice_number,\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28mmin\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 43\u001b[0m description\u001b[38;5;241m=\u001b[39mslider_text,\n\u001b[1;32m 44\u001b[0m )\n", + "File \u001b[0;32m~/miniforge3/envs/nanopyxdev/lib/python3.9/site-packages/stackview/_image_widget.py:8\u001b[0m, in \u001b[0;36mImageWidget.__init__\u001b[0;34m(self, image, zoom_factor, zoom_spline_order, colormap, display_min, display_max)\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, image, zoom_factor:\u001b[38;5;28mfloat\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1.0\u001b[39m, zoom_spline_order:\u001b[38;5;28mint\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m, colormap:\u001b[38;5;28mstr\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, display_min:\u001b[38;5;28mfloat\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, display_max:\u001b[38;5;28mfloat\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m ((\u001b[38;5;28mlen\u001b[39m(image\u001b[38;5;241m.\u001b[39mshape) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m (\u001b[38;5;28mlen\u001b[39m(image\u001b[38;5;241m.\u001b[39mshape) \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m4\u001b[39m] \u001b[38;5;129;01mand\u001b[39;00m image\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m3\u001b[39m)):\n\u001b[0;32m----> 8\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mOnly 2D images are supported\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mstr\u001b[39m(image\u001b[38;5;241m.\u001b[39mshape))\n\u001b[1;32m 9\u001b[0m height \u001b[38;5;241m=\u001b[39m image\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m*\u001b[39m zoom_factor\n\u001b[1;32m 10\u001b[0m width \u001b[38;5;241m=\u001b[39m image\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m*\u001b[39m zoom_factor\n", + "\u001b[0;31mNotImplementedError\u001b[0m: Only 2D images are supported(5, 50, 50)" + ] } ], "source": [ "rgc_img.shape\n", - "stackview.slice(rgc_img[4])" + "stackview.slice(rgc_img)" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -555,7 +592,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -565,7 +602,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[32], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m stackview\u001b[38;5;241m.\u001b[39mslice(\u001b[43mgrad_r_int\u001b[49m)\n", + "Cell \u001b[0;32mIn[24], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m stackview\u001b[38;5;241m.\u001b[39mslice(\u001b[43mgrad_r_int\u001b[49m)\n", "\u001b[0;31mNameError\u001b[0m: name 'grad_r_int' is not defined" ] } diff --git a/tests/test_3D_eSRRF/load_analyse.ipynb b/tests/test_3D_eSRRF/load_analyse.ipynb index 71e6270b..c613c9b4 100644 --- a/tests/test_3D_eSRRF/load_analyse.ipynb +++ b/tests/test_3D_eSRRF/load_analyse.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 119, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -20,12 +20,14 @@ "from tifffile import imread\n", "from nanopyx.methods.esrrf_3d.run import run_esrrf3d\n", "\n", + "from scipy.signal import find_peaks\n", + "\n", "from nanopyx.core.transform._le_esrrf3d import eSRRF3D" ] }, { "cell_type": "code", - "execution_count": 120, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -44,22 +46,43 @@ }, { "cell_type": "code", - "execution_count": 155, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PLANES_num_planes_5_distance_emitters_1_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\n", + "5 1.0\n" + ] + } + ], "source": [ "# set parameters\n", "\n", - "path = \"/Users/avesga/Code/radialsym/simulations/PLANES_num_planes_5_distance_emitters_2_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", - "path_full = \"/Users/avesga/Code/radialsym/simulations/FULL_distance_emitters_2_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", + "path = \"/Users/avesga/Code/radialsym/simulations/PLANES_num_planes_5_distance_emitters_1_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", + "path_full = \"/Users/avesga/Code/radialsym/simulations/FULL_distance_emitters_1_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", + "\n", + "# path = \"/Users/avesga/Code/radialsym/simulations_below_500nm/PLANES_num_planes_5_distance_planes_[3, 3, 2]_distance_emitters_0.4_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", + "# path_full = \"/Users/avesga/Code/radialsym/simulations_below_500nm/PLANES_num_planes_5_distance_planes_[3, 3, 2]_distance_emitters_0.4_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", + "\n", + "# from the last part of the path, get the number of planes, the separation between planes, and the pixel size\n", + "last_part = os.path.basename(path).split('/')[-1]\n", + "print(last_part)\n", + "\n", + "num_planes = int(last_part.split('num_planes_')[1].split('_')[0])\n", + "distance_emitters = float(last_part.split('distance_emitters_')[1].split('_')[0])\n", + "\n", + "print(num_planes, distance_emitters)\n", "\n", "pixel_size = 0.120\n", - "separation_planes = 3" + "separation_planes = 4" ] }, { "cell_type": "code", - "execution_count": 156, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -71,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 157, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -91,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 158, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -101,20 +124,30 @@ "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023622910000540287 seconds\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023549580000690185 seconds\n", - "Consider adding default arguments to the njit implementation to trigger early compilation\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.008093041999927664 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002717999999999776 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.007079040999997233 seconds\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023541250000000957 seconds\n", "Consider adding default arguments to the njit implementation to trigger early compilation\n", - "Querying the Agent...\n", - "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.008440832999895065 seconds\n", - "Agent: eSRRF_3D using Threaded ran in 0.8405347500001881 seconds\n", - "Only one frame, no temporal correlations can be calculated\n" + "Unexpected error while trying to run Threaded\n", + "while scanning a simple key\n", + " in \"/Users/avesga/.nanopyx/liquid/_le_interpolation_catmull_rom.cpython-39-darwin/ShiftAndMagnify.yml\", line 1510, column 1\n", + "could not find expected ':'\n", + " in \"/Users/avesga/.nanopyx/liquid/_le_interpolation_catmull_rom.cpython-39-darwin/ShiftAndMagnify.yml\", line 1521, column 87\n", + "Please try again with another run type\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'NoneType' object has no attribute 'shape'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[6], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# esrrf3d\u001b[39;00m\n\u001b[1;32m 2\u001b[0m esrrf \u001b[38;5;241m=\u001b[39m eSRRF3D()\n\u001b[0;32m----> 4\u001b[0m rgc_img \u001b[38;5;241m=\u001b[39m \u001b[43mrun_esrrf3d\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmagnification_xy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmagnification_xy\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmagnification_z\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmagnification_z\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mradius\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mradius\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mradius_z\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mradius_z\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mratio_px\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mratio_px\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msensitivity\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msensitivity\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrun_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrun_type\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcorrelation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcorrelation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mframewindow\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mframewindow\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrollingoverlap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrollingoverlap\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 6\u001b[0m rgc_img \u001b[38;5;241m=\u001b[39m rgc_img\u001b[38;5;241m.\u001b[39msqueeze()\n", + "File \u001b[0;32m~/Code/NanoPyx/src/nanopyx/methods/esrrf_3d/run.py:27\u001b[0m, in \u001b[0;36mrun_esrrf3d\u001b[0;34m(img, correlation, framewindow, rollingoverlap, **kwargs)\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;124;03mCalculate the eSRRF3D temporal correlations for the given image.\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;124;03m The calculated eSRRF3D temporal correlations.\u001b[39;00m\n\u001b[1;32m 25\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 26\u001b[0m esrrf_calculator \u001b[38;5;241m=\u001b[39m eSRRF3D()\n\u001b[0;32m---> 27\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mcalculate_eSRRF3d_temporal_correlations\u001b[49m\u001b[43m(\u001b[49m\u001b[43mesrrf_calculator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcorrelation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcorrelation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mframewindow\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mframewindow\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrollingoverlap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrollingoverlap\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Code/NanoPyx/src/nanopyx/core/transform/sr_temporal_correlations.py:225\u001b[0m, in \u001b[0;36mcalculate_eSRRF3d_temporal_correlations\u001b[0;34m(rgc_map, correlation, framewindow, rollingoverlap)\u001b[0m\n\u001b[1;32m 223\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcalculate_eSRRF3d_temporal_correlations\u001b[39m(rgc_map, correlation: \u001b[38;5;28mstr\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAVG\u001b[39m\u001b[38;5;124m\"\u001b[39m, framewindow: \u001b[38;5;28mfloat\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m, rollingoverlap: \u001b[38;5;28mfloat\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m):\n\u001b[1;32m 224\u001b[0m \u001b[38;5;66;03m# correlation (str): Type of correlation to calculate. Should be \"AVG\", \"VAR\", or \"TAC2\"\u001b[39;00m\n\u001b[0;32m--> 225\u001b[0m n_frames, n_slices, n_rows, n_cols \u001b[38;5;241m=\u001b[39m \u001b[43mrgc_map\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m[\u001b[38;5;241m0\u001b[39m], rgc_map\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m], rgc_map\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m2\u001b[39m], rgc_map\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m3\u001b[39m]\n\u001b[1;32m 227\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n_frames \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 228\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mOnly one frame, no temporal correlations can be calculated\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'shape'" ] } ], @@ -129,7 +162,7 @@ }, { "cell_type": "code", - "execution_count": 159, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -138,13 +171,13 @@ "Text(0.5, 1.0, 'XZ intensity at the center')" ] }, - "execution_count": 159, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9YAAAEyCAYAAAAfo0gPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAADrh0lEQVR4nOydeVgV1RvHv/de4LKDCAiIIu7iLpqSueSGpqa/LDU3tNRU0NTK0iy3TLPcMkUrUzPNLW1xAcm1cl/I3VxwB1GRVfZ7fn/gjO9c7rAjKO/neeZ5DnPPnG2GO/c953veVyOEEGAYhmEYhmEYhmEYpkBoS7oBDMMwDMMwDMMwDPMsw4Y1wzAMwzAMwzAMwxQCNqwZhmEYhmEYhmEYphCwYc0wDMMwDMMwDMMwhYANa4ZhGIZhGIZhGIYpBGxYMwzDMAzDMAzDMEwhYMOaYRiGYRiGYRiGYQoBG9YMwzAMwzAMwzAMUwjYsGYYhmEYhmEYhmGYQsCGdSln6tSp0Gg0uH//fkk3pVjYu3cvNBoN9u7dW2RlSmPGMAzDMAzDMAzzNCgzhvWAAQNgaWmJ//77L9tns2fPhkajwdatW7Fu3TpoNBosW7bMZDkjR46Eubk5/v333+JuMlPMDB48GBqNRj7s7e3RsGFDzJ07F6mpqYq8f//9N7p06YKKFSvC0tISlStXRvfu3bF27VpFPloePdzc3J5m1xiGYRiGYRiGeYqYlXQDnhbz5s3D9u3bMWLECOzevVs+HxERgenTp6NXr17o1q0bAGDVqlX46KOP0LNnT1SoUEHOe+TIEXz77bd477330LBhw6feB6bo0ev1+P777wEAsbGx+OWXX/D+++/j6NGjWLduHQBg48aN6NOnDxo1aoR3330X5cqVQ0REBPbv34/vvvsO/fr1U5TZsWNHDBo0SHHOysrq6XSIYRiGYRiGYZinTpkxrF1dXfHFF19g+PDhWLVqFQICAgAAo0aNgrm5ORYuXCjnDQ4ORt26dTFu3Dh5RTIzMxPvvPMOKleujKlTp5ZEF5hiwMzMDAMGDJD/HjVqFJo3b47169dj3rx58PDwwNSpU+Hj44NDhw7BwsJCcX10dHS2MmvWrKkok2EYhmEYhmGY55syIwUHgKFDh6Jly5Z4//338eDBA6xbtw4hISH47LPPULFiRTlflSpVMHXqVPz8888ICwsDAHz99dcIDw9HcHAwrK2tc6zn0qVL6NWrF9zc3GBpaQlPT0/07dsXcXFxAIBr165Bo9Fg5cqV2a7VaDQmDff79++jd+/esLe3R/ny5fHuu+8iJSVFkScsLAwvvfQSHB0dYWtri1q1amHSpEny52lpafj000/h6+sLBwcH2NjYoFWrVtizZ4+iHKl9X331FRYvXoyqVavC2toanTp1ws2bNyGEwIwZM+Dp6QkrKyv06NEDMTExijKqVKmCbt26YefOnWjUqBEsLS3h4+ODzZs35zh2EocPH0bnzp3h4OAAa2trtGnTBv/880+2fH///TeaNWsGS0tLVKtWTVXCn1e0Wi3atm0rjwMAXLlyBc2aNctmVANZEzYMwzAMwzAMw5RtysyKNQB573Tjxo0xcuRI/PXXX2jatCkCAwOz5R03bhzWrFmDkSNHIiQkBJ9++in69u2Lzp0751hHWloa/P39kZqaitGjR8PNzQ23b9/G1q1bERsbCwcHhwK1vXfv3qhSpQpmzZqFQ4cO4euvv8bDhw/x448/AgDOnj2Lbt26oUGDBpg+fTr0ej0uX76sMEbj4+Px/fff480338SwYcOQkJCA5cuXw9/fH0eOHEGjRo0Uda5ZswZpaWkYPXo0YmJiMGfOHPTu3Rvt2rXD3r178eGHH+Ly5ctYtGgR3n//ffzwww+K6y9duoQ+ffpgxIgRCAgIwIoVK/DGG28gJCQEHTt2VO3r7t270aVLF/j6+mLKlCnQarVYsWIF2rVrh7/++gsvvPACAOD06dPo1KkTXFxcMHXqVGRkZGDKlCkK+X5BuHLlCgCgfPnyAAAvLy/s2rULt27dgqenZ67Xp6SkZHM2Z2dnB71eX6h2MQzDMAzDMAxTShFlkIkTJwoAQqfTiePHj6vmO3z4sNBqtcLJyUk4OjqKqKioXMs+efKkACA2btyomiciIkIAECtWrMj2GQAxZcoU+e8pU6YIAOLVV19V5Bs1apQAIP79918hhBDz588XAMS9e/dU683IyBCpqamKcw8fPhQVKlQQb731Vrb2ubi4iNjYWPm8NG4NGzYU6enp8vk333xTWFhYiJSUFPmcl5eXACB++eUX+VxcXJxwd3cXjRs3ls/t2bNHABB79uwRQghhMBhEjRo1hL+/vzAYDHK+R48eCW9vb9GxY0f5XM+ePYWlpaW4fv26fO7cuXNCp9OJvDzaAQEBwsbGRty7d0/cu3dPXL58WXz++edCo9GIBg0ayPmWL18uAAgLCwvx8ssvi08++UT89ddfIjMzM1uZAEwepu41wzAMwzAMwzDPB2VKCi7h7OwMAPDw8EC9evVU873wwgsYMWIEYmJiMGvWrDythEor0qGhoXj06FHRNBjItqo+evRoAMD27dsBAI6OjgCA3377DQaDwWQZOp1OljMbDAbExMQgIyMDTZs2xYkTJ7Llf+ONNxQr7M2bNweQ5WHdzMxMcT4tLQ23b99WXO/h4YH//e9/8t/29vYYNGgQTp48iaioKJNtDA8Px6VLl9CvXz88ePAA9+/fx/3795GUlIT27dtj//79MBgMyMzMRGhoKHr27InKlSvL19epUwf+/v4myzZFUlISXFxc4OLigurVq2PSpEnw8/PDli1b5DxvvfUWQkJC0LZtW/z999+YMWMGWrVqhRo1auDAgQPZyuzRowfCwsIUR37axDAMwzAMwzDMs0WZM6xv3ryJKVOmoF69erh58ybmzJmTY/5mzZoBAJo2bZqn8r29vTF+/Hh8//33cHZ2hr+/PxYvXizvry4oNWrUUPxdrVo1aLVaeR9wnz590LJlSwwdOhQVKlRA3759sWHDhmxG9qpVq9CgQQNYWlqifPnycHFxwbZt20y2jxqswJNJg0qVKpk8//DhQ8X56tWrZ4snXbNmTQBP9i8bc+nSJQBAQECAbPBKx/fff4/U1FTExcXh3r17SE5OzjYuAFCrVi2TZZvC0tJSNn7379+Pmzdv4p9//kHVqlUV+fz9/REaGorY2Fjs378fgYGBuH79Orp165bNgZmnpyc6dOigONzd3fPcJoZhGIZhGIZhni3KnGEdFBQEANixYwfeeOMNzJw5E1evXi3SOubOnYtTp05h0qRJSE5OxpgxY1C3bl3cunULALIZmxKZmZl5rsO4DCsrK+zfvx9//vknBg4ciFOnTqFPnz7o2LGjXO5PP/2EwYMHo1q1ali+fDlCQkIQFhaGdu3amVzl1ul0JutWOy+EyHP71ZDa8eWXX2Zb9ZUOW1vbQtcjodPpZOO3VatWue6htra2RqtWrfDNN99g8uTJePjwIXbs2FFk7WHyzuDBg1GlSpWSbkaRMHXqVNXvhWcdjUYjf+8yDMMwzy8rV66ERqNRXTx5lti7dy80Gg327t1b0k0pctq2bZujYpcpOGXKsN6yZQt+//132aP1ggULYGFhYdJ5WWGpX78+Jk+ejP379+Ovv/7C7du3sXTpUgBAuXLlAGTFTaZcv35dtTxpJVfi8uXLMBgMCsNCq9Wiffv2mDdvHs6dO4eZM2di9+7dstfvTZs2oWrVqti8eTMGDhwIf39/dOjQIZt38aLi8uXL2Yzt//77DwBUDaJq1aoByJKNG6/6Soe5uTlcXFxgZWWVbVwA4OLFi0XbERUkFUNkZORTqe9ZYMCAAbC0tJTvM2X27NnQaDTYunUr1q1bJzsTNMXIkSNhbm6Of//9t1jauX379lIfNu/zzz/Hr7/+WiJ137lzB1OnTkV4eHie8h84cABTp07N9p32vPPo0SNMnTr1ufzhxTDMs09e38lA1mS1RqPJ8SjOyexz585h6tSppdooX7t2LRYsWFBi9efnd0F+3+PPE0uWLDEZeelpUGYM64SEBIwZMwaNGzeW9yd7eHhgxowZCAkJwcaNG4uknvj4eGRkZCjO1a9fH1qtFqmpqQCyjEZnZ2fs379fkW/JkiWq5S5evFjx96JFiwAAXbp0AYBs4a4AyF6+pXqllWZq7B4+fBgHDx7MtV8F4c6dO4q9yvHx8fjxxx/RqFEjuLm5mbzG19cX1apVw1dffYXExMRsn9+7dw9AVl/8/f3x66+/4saNG/Ln58+fR2hoaJH2Y9euXSbPS/vb8yM9f96ZN28erK2tMWLECMX5iIgITJ8+Hb169UK3bt1kD/sfffQR7t69q8h75MgRfPvttxg3bhwaNmyoWtd3331X4EmU7du3Y9q0aQW6tjiYPHkykpOTFedK2rCeNm1avgzradOmlUnDetq0aWxYMwxTKsnrOxkA3nnnHaxevdrkMXjwYABAixYtcqxv4MCBSE5OhpeXV77beu7cOUybNq3UGNatW7dGcnIyWrduLZ971gzr/LzHnydK0rAuM+G2Jk+ejDt37mDz5s0KKXNgYCBWrVqFsWPHonPnzrCzsytUPbt370ZQUBDeeOMN1KxZExkZGVi9ejV0Oh169eol5xs6dChmz56NoUOHomnTpti/f7/JGUWJiIgIvPrqq+jcuTMOHjyIn376Cf369ZMNj+nTp2P//v3o2rUrvLy8EB0djSVLlsDT0xMvvfQSAKBbt27YvHkz/ve//6Fr166IiIjA0qVL4ePjY9KILSw1a9bE22+/jaNHj6JChQr44YcfcPfuXaxYsUL1Gq1Wi++//x5dunRB3bp1MWTIEFSsWBG3b9/Gnj17YG9vjz/++AMAMG3aNISEhKBVq1YYNWoUMjIysGjRItStWxenTp0qsn706NED3t7e6N69O6pVq4akpCT8+eef+OOPP9CsWTN07969yOp61nF1dcUXX3yB4cOHY9WqVQgICAAAjBo1Cubm5li4cKGcNzg4GHXr1sW4ceOwdu1aAFnbId555x1Urlw51xVlc3PzYuvH08bMzEzhEJAp2yQlJcHGxqakm8EwzDNOft7Jfn5+8PPzy1ZGZGQkxo8fDy8vLwQHB+dYn06nU90u+Kyh1WphaWlZ0s1gSgkZGRkwGAyyE2hVStgr+VPh2LFjQqfTiaCgIJOfHzlyRGi1WjFmzJhsn61YsUIAEEePHs1TXVevXhVvvfWWqFatmrC0tBROTk7i5ZdfFn/++aci36NHj8Tbb78tHBwchJ2dnejdu7eIjo5WDbd17tw58frrrws7OztRrlw5ERQUJJKTk+V8u3btEj169BAeHh7CwsJCeHh4iDfffFP8999/ch6DwSA+//xz4eXlJfR6vWjcuLHYunWrCAgIEF5eXnI+KdzWl19+qWizFBrLOJSYqTHy8vISXbt2FaGhoaJBgwZCr9eL2rVrZ7vWONyWxMmTJ8Vrr70mypcvL/R6vfDy8hK9e/cWu3btUuTbt2+f8PX1FRYWFqJq1api6dKl8pjlhhRuKzd+/vln0bdvX1GtWjVhZWUlLC0thY+Pj/j4449FfHy8Ii8AERgYmGuZzzMGg0G0bNlSODs7i/v374uff/5ZABBff/11trxz5swRAMTOnTuFEELMmzdPABA7duzItZ6cnttly5aJqlWrCgsLC9G0aVNx5MgRxXUwERJNIjMzU8yfP1/4+PgIvV4vXF1dxfDhw0VMTIyifukZ/+uvv0SzZs2EXq8X3t7eYtWqVYp8aWlpYurUqaJ69epCr9cLJycn0bJlS7nPQohsz6yp9gUEBIjdu3cLAGLz5s3ZxmPNmjUCgDhw4IDqmD148EC89957ol69esLGxkbY2dmJzp07i/DwcDmP9D9pfKiFjJPabnxERETIfQkMDBRbtmwRdevWFRYWFsLHx8fkPb5165YYMmSIcHV1lfMtX75ctT/GrF69WjRr1kxYWVkJR0dH0apVKxEaGqrIs337dvHSSy8Ja2trYWtrK1555RVx5swZRR7pu+HWrVuiR48ewsbGRjg7O4v33ntPZGRkCCGePG/GB/3+Pn/+vOjVq5coV66c0Ov1wtfXV/z222+KuqTvz71794qRI0cKFxcX4ejomOc+MwzD5ER+3snGZGZmipdfflmYmZmJf/75J9f80veZ9P0vRN7eldJ1xgf9bVhU390SP//8s2jSpImwtbUVdnZ2ol69emLBggXy58a/T9u0aZOtfV5eXiIhIUFYW1ubtCFu3rwptFqt+Pzzz3Mcty+//FL4+fkJJycnYWlpKZo0aZLt97La7wJT5PYeb9Omjahbt644e/asaNu2rbCyshIeHh7iiy++yFZWSkqK+PTTT0W1atWEhYWF8PT0FB988IEixG5OHDp0SHTp0kU4OjoKa2trUb9+fcU4C5G/d+Xff/8txo0bJ5ydnYW1tbXo2bOniI6OlvNJ4X7p0aZNG/nzhw8finfffVd4enoKCwsLUa1aNTF79mxFCF36e3L+/PmiatWqQqvVipMnT+ba3zJhWDNPH+mLlCmbnDlzRpibm4s33nhDuLm5iaZNm5qM+52eni4aNmwoqlWrJi5duiRsbW1F375981SHmmHduHFjUb16dfHFF1+IOXPmCGdnZ+Hp6SnS0tKEEEIcOHBAdOzYUQAQq1evlg+JoUOHCjMzMzFs2DCxdOlS8eGHHwobGxvRrFkzuQwhsp7xWrVqiQoVKohJkyaJb775RjRp0kRoNBrFy37SpElCo9GIYcOGie+++07MnTtXvPnmm2L27NlyHmPDevXq1UKv14tWrVrJ7Ttw4IAwGAyiUqVKolevXtnG45VXXhHVqlXLccyOHj0qqlWrJj766COxbNkyMX36dFGxYkXh4OAgbt++LYQQIioqSkyfPl0AEMOHD5frv3Llisky//33X/Hmm28KAGL+/Ply/sTERCFE1o+Bhg0bCnd3dzFjxgyxYMECUbVqVWFtbS3u378vlxMVFSU8PT1FpUqVxPTp00VwcLB49dVX5XJzY+rUqQKAePHFF8WXX34pFi5cKPr16yc+/PBDOc+PP/4oNBqN6Ny5s1i0aJH44osvRJUqVYSjo6Pih2BAQICwtLQUdevWFW+99ZYIDg4WvXr1EgDEkiVLhBBCJCYmiuDgYAFA/O9//5P7/e+//wohsv4HHBwchI+Pj/jiiy/EN998I1q3bi00Go1iYkT6seDj4yPatGkjFi1apHg2GIZhCkte38nGSN+rM2fOzFM9aoZ1bu/KK1euiDFjxggAYtKkSfL3aVRUlBCiaL+7hRBi586dAoBo3769WLx4sVi8eLEICgoSb7zxhpzH2LDeuXOnaNSokXB2dpbbt2XLFiGEEP379xcVKlTIZrzPmTNHaDQacf369RzHzdPTU4waNUp88803Yt68eeKFF14QAMTWrVvlPGq/C0yR23u8TZs2wsPDQ1SqVEm8++67YsmSJaJdu3YCgNi+fbtcTmZmpujUqZOwtrYWY8eOFcuWLRNBQUHCzMxM9OjRI8c+SWNmYWEhvLy8xJQpU0RwcLAYM2aM6NChg5wnv+/Kxo0bi3bt2olFixaJ9957T+h0OtG7d28535YtW4Snp6eoXbu23G9pISMpKUk0aNBAlC9fXkyaNEksXbpUDBo0SGg0GvHuu+/KZUi/J318fETVqlXF7Nmzxfz583O9j0KwYc0UE2xYMxMnThQAhE6nE8ePH1fNd/jwYaHVaoWTk5NwdHSUX6S5oWZYly9fXrG6/NtvvwkA4o8//pDPBQYGmlQ1/PXXXwKAWLNmjeJ8SEhItvPSrOj+/fvlc9HR0UKv14v33ntPPtewYcNc/xdMqSxsbGxMzkZPnDhR6PV6ERsbq6jXzMxMsVpqipSUlGw/piIiIoRerxfTp0+Xzx09ejTHVWpjvvzyy2w/piQACAsLC3H58mX53L///isAiEWLFsnn3n77beHu7q4wtoUQom/fvsLBwUE8evRItf5Lly4JrVYr/ve//2Xrn8FgEEIIkZCQIBwdHcWwYcMUn0dFRQkHBwfFeUnVQMdECCEaN24sfH195b/v3buXbZVaon379qJ+/fqKWX2DwSBefPFFUaNGDfmc9GPhpZdeyvajjGEYpqjI6ztZYu/evUKn04n27dvnyQgXQt2wzsu7cuPGjSYVjMXx3f3uu+8Ke3v7HL9zTSkqu3btqvjdIREaGmpSbdegQQPFaqkaxu+3tLQ0Ua9ePdGuXTvFebXfBabI6T0urb7/+OOP8rnU1FTh5uammLhfvXq10Gq14q+//lJcv3TpUgEgRxVDRkaG8Pb2Fl5eXuLhw4eKz6T3shD5f1d26NBBcf24ceOETqdT/CaqW7euyXGfMWOGsLGxUah5hRDio48+EjqdTty4cUMI8eT3pL29vWI1PC+UGedlDMM8XZydnQFkOQnMKazDCy+8gBEjRiAmJgazZs1ChQoVClVvnz59ZM/7ANCqVSsAyFNYvY0bN8LBwQEdO3bE/fv35cPX1xe2trayh30JHx8fuXwAcHFxQa1atRR1OTo64uzZsyY92BeEQYMGITU1FZs2bZLPrV+/HhkZGRgwYECO1+r1emi1WV/7mZmZePDgAWxtbVGrVi2cOHGiSNpnig4dOsge/wGgQYMGsLe3l8dJCIFffvkF3bt3hxBCMfb+/v6Ii4vLsX2//vorDAYDPv30U7l/ElIYs7CwMMTGxuLNN99UlK/T6dC8efNs9xZANoc/rVq1ytNzFBMTg927d6N3795ISEiQ63rw4AH8/f1x6dIl3L59W3HNsGHDnpu9iQzDlD7y+k4GgPv376Nfv34oX748fvrpp2zfq/klL+9KNYrju9vR0RFJSUkICwsrRK+e0KFDB3h4eGDNmjXyuTNnzuDUqVO5vpeBrJC5Eg8fPkRcXBxatWpVrO9lW1tbRdssLCzwwgsvKMZp48aNqFOnDmrXrq0Y+3bt2gGAybGXOHnyJCIiIjB27Fg4OjoqPpPeywV5Vw4fPlwRnrRVq1bIzMzMMbIS7U+rVq1Qrlw5RX86dOiAzMzMbE6le/XqBRcXl1zLpbC3HIZhipybN29iypQpqFevHs6cOYM5c+Zg8uTJqvmbNWsG4EkIs8JQuXJlxd+Skf3w4cNcr7106RLi4uLg6upq8vPo6Ogc65Lqo3VNnz4dPXr0QM2aNVGvXj107twZAwcORIMGDXJtjylq166NZs2aYc2aNXj77bcBAGvWrEGLFi1QvXr1HK81GAxYuHAhlixZgoiICDnGPQCUL1++QO3JC7mN07179xAbG4tvv/0W3377rckyjMeecuXKFWi1Wvj4+KjmkSY2pB8Extjb2yv+trS0zPZCNb63akihBj/55BN88sknJvNER0ejYsWK8t/e3t65lsswDFMQ8vNOFkJg0KBBiIyMxI4dO1SjuOSHvLwr1SiO7+5Ro0Zhw4YN6NKlCypWrIhOnTqhd+/e6Ny5c67tMYVWq0X//v0RHByMR48ewdraGmvWrIGlpSXeeOONXK/funUrPvvsM4SHh8uRfAAoDMiixtPTM1v55cqVUzj/vXTpEs6fP69qXOb2XgaQ4yROQd6Vhf2Nd+rUqTz3pyDvZTasmWKhtIRLYEqGoKAgAMCOHTswfvx4zJw5E/369UPVqlWLvW61VT9hFFPdFAaDAa6uropZZ4rxl3Fe6mrdujWuXLmC3377DTt37sT333+P+fPnY+nSpRg6dGiubTLFoEGD8O677+LWrVtITU3FoUOH8M033+R63eeff45PPvkEb731FmbMmAEnJydotVqMHTsWBoOhQG3JC7mNk1T3gAEDZK+1xhR0IkJCqmP16tUmfygae2UvzOqxVNf7778Pf39/k3mMJ0HoigXDMExRkp938ldffYUdO3bggw8+UP3+yi+FfS8DRfvd7erqivDwcISGhmLHjh3YsWMHVqxYgUGDBmHVqlW5Xm+KQYMG4csvv8Svv/6KN998E2vXrkW3bt3g4OCQ43V//fUXXn31VbRu3RpLliyBu7s7zM3NsWLFCjliSnGQl3tiMBhQv359zJs3z2TeSpUqFaoNBXlXFvZZ6tixIyZMmGDy85o1ayr+Lsh7mQ1rhmGKlC1btuD333/H/Pnz4enpiQULFiA0NBSBgYHYsWNHSTcPgPoscLVq1fDnn3+iZcuWRWroODk5YciQIRgyZAgSExPRunVrTJ06NUfDOqeZ6r59+2L8+PH4+eefkZycDHNzc/Tp0yfXdmzatAkvv/wyli9frjgfGxsrywRzqzu/bc0LLi4usLOzQ2ZmJjp06JDv66tVqwaDwYBz586hUaNGqnmArB9UBanDFGr9ln6smpubF1ldDMMwBSE/7+TDhw/j448/RvPmzTFz5syn2s6c3stA0X53A1nS5+7du6N79+4wGAwYNWoUli1bhk8++URV/ZXTu65evXpo3Lgx1qxZA09PT9y4cQOLFi3KtR2//PILLC0tERoaCr1eL583FZo2P+/aoljtrlatGv7991+0b98+3+VJ9+3MmTOq96243pU5PUuJiYnF+l7mPdYMwxQZCQkJGDNmDBo3bozRo0cDyNrPNWPGDISEhGDjxo0l3MIspBjBsbGxivO9e/dGZmYmZsyYke2ajIyMbPnzwoMHDxR/29raonr16gq5l1ob1epzdnZGly5d8NNPP2HNmjXo3LmzwjBWQ6fTZZvV3bhxY7Y9TGrjk1Nb85PfVLt69eqFX375BWfOnMn2+b1793K8vmfPntBqtZg+fXq2lXepv/7+/rC3t8fnn3+O9PT0fNdhCmtrawDZ++3q6oq2bdti2bJliIyMLJK6GIZh8kt+3smxsbHo27cvrK2t8fPPP8Pc3PyptlXtPVIc393G72WtViuronJ6N9vY2CAuLk7184EDB2Lnzp1YsGABypcvjy5duuTaFp1OB41Go9iade3aNfz6668m639a72Ug6zfR7du38d1332X7LDk5GUlJSarXNmnSBN7e3liwYEG2Nkjv5eJ6V6qNU+/evXHw4EGEhoZm+yw2NhYZGRkFqo/CK9YMwxQZkydPxp07d7B582aFXCcwMBCrVq3C2LFj0blzZ9jZ2ZVgKwFfX18AwJgxY+Dv7w+dToe+ffuiTZs2eOeddzBr1iyEh4ejU6dOMDc3x6VLl7Bx40YsXLgQr7/+er7q8vHxQdu2beHr6wsnJyccO3YMmzZtkqV5ObXxzz//xLx58+Dh4QFvb280b95c/nzQoEFyW0xNBJiiW7dumD59OoYMGYIXX3wRp0+fxpo1a7LJAatVqwZHR0csXboUdnZ2sLGxQfPmzVX3G0nj+fHHH6Nv374wNzdH9+7d5Rd7Xpg9ezb27NmD5s2bY9iwYfDx8UFMTAxOnDiBP//8EzExMarXVq9eHR9//DFmzJiBVq1a4bXXXoNer8fRo0fh4eGBWbNmwd7eHsHBwRg4cCCaNGmCvn37wsXFBTdu3MC2bdvQsmXLPMnpKVZWVvDx8cH69etRs2ZNODk5oV69eqhXrx4WL16Ml156CfXr18ewYcNQtWpV3L17FwcPHsStW7fw77//5qsuhmGY/JKfd/KIESNw7do19OnTB//88w/++ecfk2XmxRlXQWjUqBF0Oh2++OILxMXFQa/Xo127dnB1dS3y7+6hQ4ciJiYG7dq1g6enJ65fv45FixahUaNGqFOnjup1vr6+WL9+PcaPH49mzZrB1tYW3bt3lz/v168fJkyYgC1btmDkyJF5mpzo2rUr5s2bh86dO6Nfv36Ijo7G4sWLUb16dcV+Z6n+nH4XUPL7HjfFwIEDsWHDBowYMQJ79uxBy5YtkZmZiQsXLmDDhg0IDQ1V9Y2j1WoRHByM7t27o1GjRhgyZAjc3d1x4cIFnD17VjZui+Nd6evri+DgYHz22WeoXr06XF1d0a5dO3zwwQf4/fff0a1bNwwePBi+vr5ISkrC6dOnsWnTJly7di1PixQ5ki8f4gzDMCocO3ZM6HQ6ERQUZPLzI0eOCK1WK8aMGZPtMymMwtGjR/Ncn1q4rS+//DJbXhiFRMrIyBCjR48WLi4uQqPRZAt19e233wpfX19hZWUl7OzsRP369cWECRPEnTt35DxqIeXatGmjCPPw2WefiRdeeEE4OjoKKysrUbt2bTFz5kxFTGxT4bYuXLggWrduLaysrASAbCE2UlNTRbly5YSDg4NITk7OaahkUlJSxHvvvSfc3d2FlZWVaNmypTh48GC2NguRFabMx8dHmJmZ5Sn01owZM0TFihWFVqtVhFsBIAIDA7Pl9/Lyytanu3fvisDAQFGpUiVhbm4u3NzcRPv27cW3336bp/798MMPonHjxkKv14ty5cqJNm3aiLCwMEWePXv2CH9/f+Hg4CAsLS1FtWrVxODBg8WxY8fkPAEBAcLGxiZb+abu04EDB4Svr6+wsLDI9pxduXJFDBo0SLi5uQlzc3NRsWJF0a1bN7Fp0yY5T0GefYZhmNzI7ztZCouV25ETauG28vKuFEKI7777TlStWlXodLpsoa6K8rt706ZNolOnTsLV1VVYWFiIypUri3feeUdERkYq6jNuQ2JioujXr59wdHQUAEyG3nrllVcEANUY06ZYvny5qFGjhtDr9aJ27dpixYoVBfpdYIzae7xNmzaibt262fIb/64SIiv01xdffCHq1q0rv1t9fX3FtGnTRFxcXK59+/vvv0XHjh2FnZ2dsLGxEQ0aNFCE2hSicO9KU/cpKipKdO3aVdjZ2QkAiucsISFBTJw4UVSvXl1YWFgIZ2dn8eKLL4qvvvpK/l2W0+/J3CiVhvU333wjvLy8hF6vFy+88II4fPhwkdexb98+0a1bN+Hu7i4AyEHeJQwGg/jkk0+Em5ubsLS0FO3bt88W96wgfP7556Jp06bC1tZWuLi4iB49eogLFy4o8iQnJ4tRo0YJJycnYWNjI1577bU8x/bNiSVLloj69esLOzs7YWdnJ1q0aKEIBF9c9Roza9YsAUARjL246pa+mOhRq1atYq9X4tatW6J///7CyclJWFpainr16im+FIrrOWOef9LT04WLi4t46623SropDMMwDMMIIXr27CmqVatW0s1gSohSt8daklhMmTIFJ06cQMOGDeHv75+jS/eCkJSUhIYNG2Lx4sUmP58zZw6+/vprLF26FIcPH4aNjQ38/f2RkpJSqHr37duHwMBAHDp0CGFhYUhPT0enTp0U+xTGjRuHP/74Axs3bsS+fftw584dvPbaa4WqF8hyrT979mwcP34cx44dQ7t27dCjRw+cPXu2WOulHD16FMuWLcvm4bc4665bty4iIyPl4++//34q9T58+BAtW7aEubk5duzYgXPnzmHu3LmKGMvF9Zwxzz+//vor7t27h0GDBpV0UxiGYRimzBMZGYlt27Zh4MCBJd0UpqQoacvemBdeeEEhG8zMzBQeHh5i1qxZxVYnjFasDQaDcHNzU0gAYmNjhV6vFz///HOR1h0dHS0AiH379sn1mJubi40bN8p5zp8/LwCIgwcPFmndQghRrlw58f333z+VehMSEkSNGjVEWFiYaNOmjbxiXZx1T5kyRTRs2NDkZ8Xd5w8//FC89NJLqp8/zeeMeX44dOiQ+Pbbb0WlSpVE48aNS7o5DMMwDFOmuXr1qli9erVo06aNsLa2VkjKmbJFqVqxTktLw/HjxxVu0LVaLTp06ICDBw8+tXZEREQgKipK0Q4HBwc0b968yNsheRd0cnICABw/fhzp6emKumvXro3KlSsXad2ZmZlYt24dkpKS4Ofn91TqDQwMRNeuXbO5uS/uui9dugQPDw9UrVoV/fv3x40bN55Kvb///juaNm2KN954A66urmjcuLHCs+LTfM6Y54fg4GCMHDkSrq6u+PHHH0u6OQzDMAxTptm3bx8GDhyIiIgIrFq1ymS8baZsUKq8gt+/fx+ZmZmoUKGC4nyFChVw4cKFp9aOqKgouV7jdkifFQUGgwFjx45Fy5YtUa9ePbluCwsLODo6Fkvdp0+fhp+fH1JSUmBra4stW7bAx8cH4eHhxVrvunXrcOLECRw9ejTbZ8XZ5+bNm2PlypWoVasWIiMjMW3aNLRq1Qpnzpwp9rG+evUqgoODMX78eEyaNAlHjx7FmDFjYGFhgYCAgKf2nDHPFytXrsTKlStLuhkMwzAMwwAYPHgwBg8eXNLNYEoBpcqwLmsEBgbizJkzij2/xU2tWrUQHh6OuLg4bNq0CQEBAdi3b1+x1nnz5k28++67CAsLg6WlZbHWZQyNIdigQQM0b94cXl5e2LBhA6ysrIq1boPBgKZNm+Lzzz8HADRu3BhnzpzB0qVLERAQUKx1MwzDMAzDMAzz9ChVUnBnZ2fodDrcvXtXcf7u3btPVVYh1VWc7QgKCsLWrVuxZ88eeHp6KupOS0vLFti8qOq2sLBA9erV4evri1mzZqFhw4ZYuHBhsdZ7/PhxREdHo0mTJjAzM4OZmRn27duHr7/+GmZmZqhQoUKx9pni6OiImjVr4vLly8U+1u7u7vDx8VGcq1OnjixFfxrPGcMwDMMwDMMwxU+pWrG2sLCAr68vdu3ahZ49ewLIWvXbtWsXgoKCnlo7vL294ebmhl27dqFRo0YAgPj4eBw+fBgjR44sVNlCCIwePRpbtmzB3r17swVq9/X1hbm5OXbt2oVevXoBAC5evIgbN27Az8+vUHWbwmAwIDU1tVjrbd++PU6fPq04N2TIENSuXRsffvghKlWq9NT6nJiYiCtXrmDgwIHFPtYtW7bExYsXFef+++8/eHl5ASje56w0YDAYcOfOHdjZ2UGj0ZR0cximVCKEQEJCAjw8PKDVlqq5boZhniP4ncwwuVPod3IJO0/Lxrp164RerxcrV64U586dE8OHDxeOjo5FHk85ISFBnDx5Upw8eVIAEPPmzRMnT54U169fF0IIMXv2bOHo6Ch+++03cerUKdGjRw/h7e0tkpOTC1XvyJEjhYODg9i7d6+IjIyUj0ePHsl5RowYISpXrix2794tjh07Jvz8/ISfn1+h6hVCiI8++kjs27dPREREiFOnTomPPvpIaDQasXPnzmKt1xTUK3hx1v3ee++JvXv3ioiICPHPP/+IDh06CGdnZxEdHV2s9QohxJEjR4SZmZmYOXOmuHTpklizZo2wtrYWP/30k5ynuJ6z0sDNmzezxRDngw8+TB83b94s6X9ZhmGeY/idzAcfeT8K+k4uVSvWANCnTx/cu3cPn376KaKiotCoUSOEhIRkc/BUWI4dO4aXX35Z/nv8+PEAgICAAKxcuRITJkxAUlIShg8fjtjYWLz00ksICQkp9B7h4OBgAEDbtm0V51esWCE7Ppg/fz60Wi169eqF1NRU+Pv7Y8mSJYWqFwCio6MxaNAgREZGwsHBAQ0aNEBoaCg6duxYrPXmheKq+9atW3jzzTfx4MEDuLi44KWXXsKhQ4fg4uJSrPUCQLNmzbBlyxZMnDgR06dPh7e3NxYsWID+/fvLeYrrOSsN2NnZAcjaY29vb1/CrWGY0kl8fDwqVaok/78wDMMUB/xOZpjcKew7WSOEEEXcJoZhGMTHx8PBwQFxcXH8EmcYFfj/hGGYpwF/1zBM7hT2/4Q3dDEMwzAMwzAMwzBMIWDDmmEYhmEYhmEYhmEKARvWDMMwDMMwDMMwDFMI2LBmGIZhGIZhGIZhmELAhjXDMAzDMAzDMAzDFAI2rBmGYRiGYRiGYRimELBhzTDPEMHBwWjQoAHs7e1hb28PPz8/7NixQ/48JSUFgYGBKF++PGxtbdGrVy/cvXtXUcaNGzfQtWtXWFtbw9XVFR988AEyMjIUefbu3YsmTZpAr9ejevXqWLly5dPoHvMUyDQIXIxKgMHAkRYZhmEKS27vZQkhBLp06QKNRoNff/1V8VlpeS8npWZg+d8R/H5gmAJSag3r1NRUTJ06FampqWWmbu7z0+VZrNvT0xOzZ8/G8ePHcezYMbRr1w49evTA2bNnAQDjxo3DH3/8gY0bN2Lfvn24c+cOXnvtNfn6zMxMdO3aFWlpaThw4ABWrVqFlStX4tNPP5XzREREoGvXrnj55ZcRHh6OsWPHYujQoQgNDS2azjMlytJ9V+C/YD82HLtZ0k1hGIZ55sntvSyxYMECaDSabNeXlvdypkGg97KDmLH1HL7962qRlcswZQpRSomLixMARFxcXJmpm/v8dHle6i5Xrpz4/vvvRWxsrDA3NxcbN26UPzt//rwAIA4ePCiEEGL79u1Cq9WKqKgoOU9wcLCwt7cXqampQgghJkyYIOrWrauoo0+fPsLf3z9f7SrJ8WXUGfXTceH14Vbx0S+nSropjOD/E4Z5HpHeyxInT54UFStWFJGRkQKA2LJli/zZ03ov5+W75qdD14TXh1tF1YnbxOGrD/JcNsM8LxT2nVxsK9aLFy9GlSpVYGlpiebNm+PIkSPFVRXDlEkyMzOxbt06JCUlwc/PD8ePH0d6ejo6dOgg56lduzYqV66MgwcPAgAOHjyI+vXro0KFCnIef39/xMfHy7PrBw8eVJQh5ZHKUCM1NRXx8fGKgyl93EvIUknceviohFvCMAzzfGH8XgaAR48eoV+/fli8eDHc3NyyXVNc7+WCvJP7vVAZPRt5INMgMPrnE7if+PQVfQzzLFMshvX69esxfvx4TJkyBSdOnEDDhg3h7++P6Ojo4qiOYcoUp0+fhq2tLfR6PUaMGIEtW7bAx8cHUVFRsLCwgKOjoyJ/hQoVEBUVBQCIiopSvLylz6XPcsoTHx+P5ORk1XbNmjULDg4O8lGpUqXCdpUpBu49/qF0+6H6vWQYhmHyjtp7GcjaovXiiy+iR48eJq8trvdyQd7JGo0GM/9XH9VcbHA3PhVj14Ujk/dbM0yeMSuOQufNm4dhw4ZhyJAhAIClS5di27Zt+OGHH/DRRx/leK3BYMCdO3cgRNY/ckmsekl1Pu26S6rekqy7LPa5sHW7u7vjr7/+Qnx8PDZu3IiAgADs27evqJuYbyZOnIjx48fLf8fHx7NxXQqRV6xjk2EwCGi12ff8MQzDMHmnVq1aCA8PR1xcHDZt2iS/ly9fvozdu3fj5MmTT71NBX0n2+jNEDzAFz2++Qd/X76PRbsvYWyHmsXZVIZ5bihywzotLQ3Hjx/HxIkT5XNarRYdOnQwKVlJTU1VOHC6ffu2PMsHoER/mJdU3dxnrjs/vPTSS1i4cCH69OmDtLQ0xMbGKlat7969K8vP3Nzcsm3LkLyG0zzGnsTv3r0Le3t7WFlZqbZDr9dDr9cXuj9M8fEoLQOJqVmeZtMyDLifmApXe8sSbhXDMMyzjYWFBapXrw4A8PX1xdGjR7Fw4UJYWVnhypUr2ZRkvXr1QqtWrbB3795iey8X5p1cs4IdZv6vHsZv+BcLd11CUy8nvFTDuUBlMUxZosgN6/v37yMzM9OkZOXChQvZ8s+aNQvTpk3Ldt7LywtarRYpKSnyOXt7ezmtttL36NGTfYM6nU7xmYWFhcnPDAaDyetpfdbW1ibrpuEQEhIS5LSl5ZMfq2ZmpofZwcFB8TeVyru4uMhpOgZU8qPVPlHy03bTL1nabtr/tLQ0k+XQsUhKSpLTxmEfaP/oFze9hp6ndVAkZYJxnvT0dJN1ZWZmmqzLxsZGUS69v3TM6MuNTujQsmh9FFoOfTZouxMTE+U0ve90XAEoPIPSMaDtpveUtjsuLk6+7uHDh9BoNEhNTYWvry/Mzc2xa9cu9OrVCwBw8eJF3LhxQ97r5efnh5kzZyI6Ohqurq4AgLCwMNjb28sTWn5+fti+fbuivWFhYXIZzLOLtFotcfNhMhvWDMMwRYzBYEBqaiqmTZuGoUOHKj6rX78+5s+fj+7duwMove/l15p44khEDNYdvYl3153E9ndboQK/LxgmR4pFCp4f1KQqOp0OWq1WYfBQA4YaWNSAUzN4AKUxQw0damDZ2dmZzEONW2q40jJp3dRwpUYibZO5ubmifbRcWjcti+ah5+lEBjXwad+oAUfbTfPQNpUrV05OG09k0PapTXhQA1VtAkJtAoHmp2NG2+3k5CSn6VgASgOX9om2W23Cg+an7aDjQY1sNSNZra0AcO/ePZP10QkCel6qLyEhAeXKlYO5uTnS09Px8OFD/P333/jkk0/g4OCAt99+G+PHj4eTkxPs7e0xevRo+Pn5oUWLFgCATp06wcfHBwMHDsScOXMQFRWFyZMnIzAwUP4/GjFiBL755htMmDABb731Fnbv3o0NGzZg27ZtJseLeXYwNqxvPXwEX69yKrkZhmGY3Jg4cSK6dOmCypUrIyEhAWvXrsXevXsRGhoKNzc3kw7LKleuDG9vbwCl+7089dW6CL8ZiwtRCRi99iTWDmsOM12pjdTLMCVOkf93ODs7Q6fTmZSsmPpy0ev1sLe3VxwMw5jGYDAgKioK165dw507dwAAmzdvRseOHQEA8+fPR7du3dCrVy+0bt0abm5u2Lx5s3y9TqfD1q1bodPp4OfnhwEDBmDQoEGYPn26nMfb2xvbtm1DWFgYGjZsiLlz5+L777+Hv7//0+0sU+REZzOs2YEZwzBMYYiOjsagQYNQq1YttG/fHkePHkVoaKj8Xs6N0vxetjTXIXiAL2z1ZjhyLQZf7fyvWOtjmGedIl+xtrCwgK+vL3bt2oWePXsCyDIGdu3ahaCgoKKujmHKFA4ODvLkU2ZmJq5cuYJ27drJn1taWmLx4sVYvHixahleXl7ZJGXGtG3btkScrTDFi6kVa4ZhGKbgLF++PF/5qbJNojS/l72dbfBFrwYIXHsCS/ddQbMq5dC+ToXcL2SYMkixSMHHjx+PgIAANG3aFC+88AIWLFiApKQk2Ut4XkhLS4NWq4Wz8xNnCXTPKd07TL+kYmNj5TSVGQNK+S7NR+XVVHZMZegVK1aU0w8fPpTTVEZNpb9UUk4lztL+GQC4ceOGon1U0k77R/tNUZPGUwkxPU/l0nS/tdpeaLrnm8qgAWWfaLlUOk3Hm7aD3hcqx6Zl2traymkqj6ZjZryPn0LHj7aJ3i9pr7JxWTQ/lY7T8/ReU3UGlXzTPufk/Zu2VW08TLXDeN82w+SGZFjb6s2QmJrBK9YMwzBMrnRt4I6j16pg5YFrGL/hX2wb8xI8y1nnfiHDlDGKZaNEnz598NVXX+HTTz9Fo0aNEB4ejpCQkBwNIYZhGKZ4iU7ImqxpWCnLcSIb1gzDMExemPhKbTT0dEBccjoC155EWgZP7jOMMcXmgSAoKAjXr19HamoqDh8+jObNmxdXVQzDMEwekFasm1TOUqDcfpgVy5phGIZhckJvpsM3/ZrAwcoc/96Mxefbz5d0kxim1FHiXsHVMDc3h1arxdWrV+VzXl5eclpNKk0ly5JzJwkqK6fyYiqLpt6kqUScyr+pBJdeS6W7VNJLy4mJiZHTxnEN6TVUXk1lx1ReTEMzUTk8LZeWQ/tAPXbT8aPjQsfL2Os2lYzTcsuXL2+yfbTddIxpHrVQU3RcaIgyKq+m98H4ejr+1DkelarTNtHxo/dUTVZP5f20HDrGxrJt+vyqSempN3n6XEsSfVP7tBgmJ+4lZhnW9Ss6QKfVIC3TgHuJqRxChWEYhsmVSk7WmNe7Id5edQwrD1zDC95OeKW+e0k3i2FKDewzn2EYpowgrVi7O1jB3SHLmGYHZgzDMExeaV+nAt5pUxUAMGHTKVy7n5TLFQxTdmDDmmEYpgyQaRC4n5iljnCx08OzXJaSg/dZMwzDMPnh/U610KxKOSSmZmDkmhNISc/M/SKGKQOUWil4ZmYmhBAK79BUfkzls9TTM01TiS6glA5TeTGVB9Nyqbds6iGctoNKd6nkOCEhQU5TSa9aXYBSUk09e1NJMa2PQs/funVLTlepUkVOUy/YdJzoGFPpM20D7QOg9H5Ny6J9UpOC0/5QOTOtj0qn1byf0/tDzwPKcb527ZqcVvPcTttNZeR0PKhEnPaN9p+WSe+JsVSdjgG9X1SKT9O0HdK17BWcyQ8PH6Uh0yCg0QDlbS0ee3SNYcOaYRiGyRfmOi0WvdkEXb/+C+cj4zHtj7OY9VqDkm4Ww5Q4vGLNMAxTBpBk4E7WFjDXacmKNUvBGYZhmPzh5mCJBX0bQaMBfj5yE5tP3Mr9IoZ5zmHDmmEYpgwQ/diwdrHLUnpIMUh5xZphGIYpCK1quGBMuxoAgI+3nMGluwm5XMEwzzelVgqenJwMrVarkN+qeVymklkq2aYSZ0Apx42IiJDTVEbs7e1tsj7qxZlKfKm8nHpuprJuKjunEnEqHQeUUmgKlS9TWTStW01qff/+fTlNPWpT+TLtD5U4U6k1bYNxubRNtG56L+hYUhk57bPaeFMZNPU6ruap3bgfdEsALTc2NtbkeVqWmhdx4/GQoM8cbR8db0ApN3dzc5PTdMzoNbRuqU0sBWfyw71shjXvsWYYhmEKx5j2NXD8+kP8ffk+Rq45gd8CW8JGX2rNC4YpVnjFmmEYpgygZlhzLGuGYRimoOi0Gizo2wiudnpcjk7Ex1tOczhQpszChjXDMEwZIDohS/khGdZu9pYwexzLWpKJMwzDMEx+cbbVY9GbjaHTavBr+B2sO3qzpJvEMCVCqdVqZGRkQKvVKqS/1HMzleiqyZKjo6MVZVJpbrVq1eQ0lRpfunRJTlOZMpVt03ZQ+Tf1uk1l1FSyreY5HFDKqGk+KgOmEmfaPk9PTzl9584dOU3l71TyrSYzdnFxkdNUlkzzAOrezan3cCo9p2k1b+tU9k/ro/eUjhmVjht7WKfXUJk3rY+eV4PeEzqWarJwKsmn94puBwCUY0CfPzVv6FQ+L40xzwgz+UFasXa1y3qmzXRauDta4mZMMm49fAQ3B8ucLmcYhmEYVZpXLY/3O9XCFyEXMOX3s2jg6YC6Hg65X8gwzxG8Ys0wDFMGMJaCA1mr1gBwN55XrBmGYZjC8U7rqmhf2xVpGQaMWnMC8SnpuV/EMM8RbFgzDMOUAe4lPjasbZ8Y1lYWWUqK1IxMk9cwDMMwTF7RajWY27shKjpa4fqDR/hw0ylW1zFlCjasGYZhygD3Hq9Ku9o/Maz1ZlmvgJR09jDPMAzDFB5Hawss7t8E5joNdpyJwsoD10q6SQzz1Ci1e6z1ej20Wq1qeKpbt54Eoqd7XGke43BEdJ8vDXektge3cuXKJvPTfbS0ffQ83TdL9zbTmTvjfbf0b7qHl/bjwYMHcpruc6b7qun+abo3l+4xp+dpWyl0LOheY0C5b5zuF6Ztpe2ge69pmrbJOPyYhJ2dncm6aJg1+jwAyj3XdG80DYdFw23R/dA0Tfdx0+eMpuk9pfWq7aM2vp6OGS2L7qGnz5B0nsNtMXklOS0TCalZzxCVgluaZz3rKem8Ys0wDMMUDY0qOeLjV+pg6h/n8Pn282hUyRGNK5fL/UKGecbhFWuGYZjnnPuPZeCW5lrYkfiilo9XrFMzeJKGYRiGKToCXqyCV+q7IT1TIGjtSTxMSsv9IoZ5xmHDmmEY5jmHhtqiagm9uSQF5xVrhmEYpujQaDSY3asBqpS3xu3YZIzfEA6DgfdbM883pVYKbm5uDq1Wq5BEUwkxlSbTsERqsmZAGc6JhuiiPzQ9PDzkdGRkpJymYaioBJvKpak8muan0mIqSzZ26ECvoRLpqKgoOU3l0lQiTceJ1kGl6rQ+2tYKFSrIaSqpphJ52mfjOqgEnt4jtZBotK30PtLQZXTMqPydpmn7qOwaUMrEqYyfyu1p3XSbwO3bt+U0HW/aNyrNplB5Ni3f+F7Tv2lZVKpOz5sK78VScCavyB7BbZX/J5Zmj6Xg7LyMYRiGKWLsLc2xuH8T/G/JAey5eA/L9l/FyLbVcr+QYZ5ReMWaYRjmOed+YpYEz9nYsH68xzqVnZcxDMMwxUBdDwdMf7UuAOCrnRdx+OqDXK5gmGcXNqwZhmGec5LTslakbfRKkZJe3mPNK9YMwzBM8dCnWSW81rgiMg0Co38+KauoGOZ5o9RKwYUQEEIoJMHUk7WaZ2nqSZmmAaVkWU1GTaXCVO5MvT1TiS+VILu5uclp6hGbSpZpu6kEHQCuX79usm4qEadQj9VqHrVpW9Vk8jQPlSLT81RSblxfTEyMnKZ9pVBZOJWh0/Ggsnoq5abX0vtAMe4b/VtNCk6fLTr2VBZOnxl6T+i19Pmh94puUaAeyAHl+NGy6HNDx4C2Q5KRsxScySvSHmpLc+VcKq9YMwzDMMWNRqPBZ/+rh9O343ApOhFj15/Ej281h06ryf1ihnmGyPeK9f79+9G9e3d4eHhAo9Hg119/VXwuhMCnn34Kd3d3WFlZoUOHDrh06VJRtZdhGIbJJ8myYa1TnJedl/GKNcMwDFOMWFuYIXhAE1iZ6/DP5Qf4ehfbBszzR74N66SkJDRs2BCLFy82+fmcOXPw9ddfY+nSpTh8+DBsbGzg7++fo1MxhmHyRkJCAu7du4fIyEhER0cDQLaJq7Zt20Kj0SiOESNGKPLcuHEDXbt2hbW1NVxdXfHBBx9kc8i2d+9eNGnSBHq9HtWrV8fKlSuLtW9M8ZHyeEXa2LCWnZfxijXDMAxTzFR3tcPnr9UDAHy9+xL2/3evhFvEMEVLvqXgXbp0QZcuXUx+JoTAggULMHnyZPTo0QMA8OOPP6JChQr49ddf0bdv3zzXk56eDq1Wq5DT3rhxQ06XL19eTlOJbk6em6k0XM2rOM1DvYhT2TWdJKDyZSohpjJdKl+m5409RVNZuZoEmbaD5qfnqZyYyuepZ27qgZt6wabXUllzXFycoq1Uvkz7QdtK01SOTc9TGTUtk+an94eOJZWd0zzG0DGg946mqeyajiUtl0r3aVvptgI12Tm9n4DyXtDxo88QLUt6rlNSUmBnZwcLCwsYDAZER0fjf//7H86fP6/ow7BhwzB9+nT5bzpWmZmZ6Nq1K9zc3HDgwAFERkZi0KBBMDc3x+effw4AiIiIQNeuXTFixAisWbMGu3btwtChQ+Hu7g5/f38wzxbSirRkSEtIK9a8x5phGIZ5GvyvsSeORDzEz0duYOz6cGwf0wpuDpa5X8gwzwBF6rwsIiICUVFR6NChg3zOwcEBzZs3x8GDB01ek5qaivj4eMXBMIxpHB0dYWNjA3Nzc3kS6ObNmzh+/Lgin7W1Ndzc3OSD7lPfuXMnzp07h59++gmNGjVCly5dMGPGDCxevFieuFi6dCm8vb0xd+5c1KlTB0FBQXj99dcxf/78p9dZpshQ22Ot5xVrhmEY5ikzpbsPfNztEZOUhtE/n0B6Jr+DmOeDIjWspXjLNC6y9DeNxUyZNWsWHBwc5KNSpUpF2SSGKRPQVXkAWLNmDZydnVGvXj1MnDhRsfp98OBB1K9fX/F/6u/vj/j4eJw9e1bOQyfIpDxqE2QAT5KVZlLVpODSHuv0olmxTs3IxINE9vbKMAzDqGNprsOS/k1gpzfD0WsP8VXoxZJuEsMUCSXuFXzixIkYP368/Hd8fDwqVaqEjIwMaLVahTSbet2mMm8qc5X2nQKAq6uroi4qE6eSbCrrpVJjKn+mMmDaJnotlfvSPLReKtc1lldTGTDtH5VLU2h9arJwmocaUrR8Ks2m0mdqjBl7MKdQWTnlwYMnsQrpeNO20ntHpdlqUnoqz6d9MJaC07+pJFutPjUP6/T+qm05oGNDZd20THrfAeV9of2g/aayfFqHdF+kMlq0aIF69erJn/fr1w9eXl7w8PDAqVOn8OGHH+LixYvYvHkzgKwJMFOTX9JnOeWJj49HcnKySS/0s2bNwrRp07KdZ0qe5Ny8gmcUzWrBG0sP4tStODT0dECX+u54rXFFuNqzxI9hGIZRUsXZBnNeb4CRa05g2f6raFrFCR19KuR+IcOUYop0xVoyfO/evas4f/fuXYVRTNHr9bC3t1ccDMPkjmRg//DDD4rzw4cPh7+/P+rXr4/+/fvjxx9/xJYtW3DlypVibc/EiRMRFxcnHzdv3izW+pi8k6LmFdys6FasMw0Cp25lTRb+eysOs3dcQN9vDxW6XIZhGOb5pEt9dwxpWQUA8N6GcNyMeZTzBQxTyilSw9rb2xtubm7YtWuXfC4+Ph6HDx+Gn59fUVbFMGWaxMREedW8YsWKOeZt3rw5AODy5csAsibATE1+SZ/llMfe3l41ZjpPkpVe1Axr6e+i2GOdmPJEeTHpldoAgIgHSTAYhNolDMMwTBlnYpc6aFTJEfEpGQhae4KdaTLPNPmWgicmJso/0IEsh2Xh4eFwcnJC5cqVMXbsWHz22WeoUaMGvL298cknn8DDwwM9e/bMVz2ZmZkwGAyKH/Fq8mUqFba1tZXT1PMyoPTeTGW2VB5MZcpUCk3boebVmpZJpb7UA/nDhw/ltLGEmsqIqdSY9o9Cx4MaMZ6ennI6JiZGTickJJism14bGxsrp6n82FhqTSX3Hh4eJq+hY0bHksqraX1UCh8ZGSmnqQd42g56LR1jAKpGHb2G3jsq3VeT+tP7S+8VrZvKy+k9pP0H1D3I0zR9zmi9ycnJyMjIyNF3ASU8PBwA4O7uDgDw8/PDzJkzER0dLW+XCAsLg729PXx8fOQ827dvV5QTFhbGE2TPKGrhtqQV66L4IROfki6XOcivCj7ffgFCAAmpGXCwMs/laoZhGKYsYmGmxeL+TdD167/w7604fL7tPKb1qJf7hQxTCsn3ivWxY8fQuHFjNG7cGAAwfvx4NG7cGJ9++ikAYMKECRg9ejSGDx+OZs2aITExESEhIdkMH4Zh8k9cXBwSExPh7OwsTzLcvXtXniS4cuUKZsyYgePHj+PatWv4/fffMWjQILRu3RoNGjQAAHTq1Ak+Pj4YOHAg/v33X4SGhmLy5MkIDAyUJ5ZGjBiBq1evYsKECbhw4QKWLFmCDRs2YNy4cSXTcaZQPAm3pbLHughWrBMer1jbWZrD0lwnG+3xyek5XcYwDMOUcSo6WmFe74YAgFUHr2PrqTsl3CKGKRj5Nqzbtm0LIUS2Y+XKlQCyViynT5+OqKgopKSk4M8//0TNmjWLut0MUyZJSkqCEAJ3797FnTtZL56aNWti/fr1ALJWuf/880906tQJtWvXxnvvvYdevXrhjz/+kMvQ6XTYunUrdDod/Pz8MGDAAAwaNEgR99rb2xvbtm1DWFgYGjZsiLlz5+L777/nGNbPKClpOUvB0zINyCykZFtasba3yhJCSavUcWxYMwzDMLnQrnYFjGxbDQDw0S+ncfVeYi5XMEzpo8S9gquRmZkJjUajkNBSea+xzFuCyniNQxBR6TRNU6/RFCplppJqWi6V/lLZMPVeTaXctH1UFg4o5cW0LJqmUnfqdZtKnOk40TSVDRtLkyWolJtKx429glPJPJW9U0/YNA+VUVM5t9o40TGmY0ZDONG+0TYAkI1OQNlXKltXk2BTdQV9Tqi0mzrjo3uR6b2i7a5cubKifdQjPC2XPgN0PKS0g4OD7GHcYDAgKioKcXFx8lhUqlQJ+/btQ254eXllk3ob07ZtW5w8eTLXspjST8pjr99WFqal4ACQlmHI9nl+oCvWAGBvZY7ohFResWYYhmHyxHsda+L49Yc4EhGDUWtO4NfAltkmhBmmNFOkzssYhmGY0ofsvMzM9Io1zVNQEqQVa0tesWYYhmHyj5lOi0VvNoazrQUuRCVgym9nS7pJDJMv2LBmGIZ5jhFCEK/gyq98nVYDc12WGqWwsayfrFizYc0wDMMUjAr2lljYtzE0GmD9sZvYdPxWSTeJYfJMqZWC29raQqvVKqSxVD5LZbZUsk0lwVQeDSjlzM7OznKayrypDJhKoSX5rXE5tH1U1qzm1Zvmp96uAaWMWk0erOZFm/abytOpx3M6ZmrlU4kz7T/NAyg9VqvJpWnd9Dy9X7Rc2gfqsVtNIk+hUnNA6QHexcVFTlMpuZrHeSpVp3J2KsO/ceOGnFbzKk/run79uqJ9tCy18aNl0XtN7y/D5EZ6poC0fVpvQlKnN9MhPTOj0CvWkuTb/rEUXDKspb3XDMMwDJMXWlZ3xrgONTEv7D9M/vU06ld0QC03u9wvZJgShlesGYZhShmP0jIwacvpIpmpTyGhtIxXrOm5lEKG3EpIVa5YS5JwXrFmGIZh8kvQy9XRqoYzUtINGLXmOJJSM3K/iGFKGDasGYZhShkLd13C2sM38FXoxUKXJXkE12gAC132r3y9WdGE3JL2WNsZrVizYc0wDMPkF61WgwV9GsHN3hJX7iVh0pbT2dSTDFPaKLVScCmMF5U+U0k1lXJT6S6VL1P5rDH0GiobphJd6i2cyrSpN25XV1eT5VNJr5qnaNofAIiOjpbT1atXN1kulQFTubSavJr2gcrZaTto+6jncCpFptcCStk7JSkpSU5TiTOV2FPJN5VRq3lVp+NCJeh0/Oh54+vpM0El42ryfupxnj4ndCxpu+k9od7FqddyY/k29Qjv7u4up+m9o+Nn6rk29oTOPB9ciIrH8r8iAAAPklIhhMjmlT8/pDw2mK3MdSbL0Usr1oWVghvtsbaXpODJvMrAMAzD5J/ytnos6tcYfb89hN/C7+AFbyf0b+5V0s1iGFV4xZphGKaUYDAITNp8GhmPN0WnZwokFlL+Jkm81UKWSJ7CUwrpvMx4j7U9r1gzDMMwhaRZFSd82LkWAGDa7+dw5nZcLlcwTMnBhjXDMEwpYf2xmzhxIxbWFjpZtv0wqXCG6ZNQW6a/7qUV69RCh9tir+BM2WDv3r3QaDTYtGlTSTel2NBoNJg6dWqRlSeN2d69e4usTKbsMKxVVXSo44q0TANGrTnB7xWm1FJqpeDp6enQarUKmSyVY1NJI5UQ5ySZpF6aK1SoIKepTJdKbtWk0JUqVZLT1FM5lRD7+PjI6cuXL8tpKtmmsmkAqFixopymEuS7d++a7A+VJtN2qHmcpjJjKqOm8mWan/aZ5gGAR48emSyLyu9pffR6mp+OPZVz0/tIZdd0/KgUnt4rQCkfp9cYS9olqDSejgE9T/tD74+aJ3k1eb7xZ9QrPT1Pof2Txsz4njDPNpkGgS8f76ke37EmVvxzDbdjkxHzKA2Vy1vncrU6khS8uFes1fZYx/MPIMYEAwYMwKZNm3Dq1CnUrFlT8dns2bMxceJE/PHHH+jWrRsGDx6MVatW5Viel5cXrl27VowtZp4GK1euxJAhQ+S/9Xo9KleujE6dOuGTTz5R/Ha7du0apk2bhv379+P27dtwdHREzZo18fLLL2PatGlyvrZt22Lfvn0m6zt//jxq165dfB1iigSNRoO5bzRC10V/4UbMI0zY9C+WDvAt1DYphikOeMWaYRimFJCYkoGYpKxJp4F+Xihnk2WYxiSl5nRZriQ/Xok2FWoLIF7Bi2nFmsNtMaaYN28erK2tMWLECMX5iIgITJ8+Hb169UK3bt0AAO+88w5Wr15t8hg8eDAAoEWLFk+7C0wxMn36dKxevRrffPMNXnzxRQQHB8PPz0+e1L98+TIaN26M0NBQvPnmm/jmm28QGBiI8uXL44svvshWnqenp8nnx8PDo9BtDQ4ORoMGDWBvbw97e3v4+flhx44d8ufvvPMOqlWrBisrK7i4uKBHjx64cOGCoowbN26ga9eusLa2hqurKz744APFJD+QterfpEkT6PV6VK9eHStXrix0258lHKzNsaR/E1jotAg9exc//HOtpJvEMNkotSvWDMMwZYlH6Vk/osx1GujNdChnnaXgiCkqKbiJUFsA8Qpe2D3Wjw1oyaCme6wL64CNef5wdXXFF198geHDh2PVqlUICAgAAIwaNQrm5uZYuHChnNfPzw9+fn7ZyoiMjMT48ePh5eWF4ODgp9Z2pvjp0qULmjZtCgAYOnQoypcvj3nz5uG3337Dm2++ifnz5yMxMRHh4eHw8lI6s6KKNQkHBwcMGDCgWNrq6emJ2bNno0aNGhBCYNWqVejRowdOnjyJunXrwtfXF/3790flypURExODqVOnolOnToiIiIBOp0NmZia6du0KNzc3HDhwAJGRkRg0aBDMzc3x+eefA8iacOratStGjBiBNWvWYNeuXRg6dCjc3d3h7+9fLP0qjTTwdMTkbnXw6W9nMWv7eTSu7IgmlcuVdLMYRqbUrlinpaUhNTUV5ubm8qHRaOQjOTlZPih6vV4+7t27pzhcXFzk4+HDh/IheSAXQsDW1lY+KA4ODvIRGxsrH7Qc2taoqCj5oOVHR0fLh5OTk+J49OiRfKSkpMhHZmamfFhbW8uHmZmZfOh0OvlIS0uTD9omS0tL+aD9oWNmZ2cnH/S8MbTfBoNBPuLj4+WDto+2iY4xvY+0n2rjl5GRIR/p6enyQftpbm6uqEOtHbRurVYrH3QMaH9o+bQd9F45OzvLBx0X2gYzMzNFXympqanyERkZKR+0P3FxcYiLi1NsbWCefR49DotlbZE131neJsuwfpiUpnpNXpAMa6tcVqwLs8c6PdMgS86NV6zTM4W8as4wlKFDh6Jly5Z4//338eDBA6xbtw4hISH47LPPFFujTGEwGNC/f388fPgQa9euRblyOf+4TkhIwNixY1GlShXo9Xq4urqiY8eOOHHihJynSpUq8go4pW3btmjbtm2285mZmZg0aRLc3NxgY2ODV199FTdv3lTkuXTpEnr16gU3NzdYWlrC09MTffv2VWzfWrFiBdq1awdXV1fo9Xr4+PiYnCioUqUKunXrhr1796Jp06awsrJC/fr15X3LmzdvRv369WFpaQlfX1+cPHlScf3gwYNha2uLq1evwt/fHzY2NvDw8MD06dPzFMbo9u3beOutt1ChQgXo9XrUrVsXP/zwQ7Z8t27dQs+ePWFjYwNXV1eMGzdOEZGjILRr1w5AloEJAFeuXIGnp2c2oxpQj9ZSXHTv3h2vvPIKatSogZo1a2LmzJmwtbXFoUOHAADDhw9H69atUaVKFTRp0gSfffYZbt68KW9d2LlzJ86dO4effvoJjRo1QpcuXTBjxgwsXrxY3jq3dOlSeHt7Y+7cuahTpw6CgoLw+uuvY/78+U+1r6WBgS280LWBOzIMAkFrThT6HckwRQmvWDMMw5QCHqVKhnWWAVzusWEd86hwPxpSc9ljXRQr1pIMHABs9VmvFRsLHXRaDTINAvHJGfKEAcNIaDQaLFu2DI0bN8bIkSPx119/oWnTpggMDMz12hkzZmDPnj2YOXMmXnzxxVzzjxgxAps2bUJQUBB8fHzw4MED/P333zh//jyaNGlSoPbPnDkTGo0GH374IaKjo7FgwQJ06NAB4eHhsLKyQlpaGvz9/ZGamorRo0fDzc0Nt2/fxtatWxEbGyv7JAkODkbdunXx6quvwszMDH/88QdGjRoFg8GQbSwuX76Mfv364Z133sGAAQPw1VdfoXv37li6dCkmTZqEUaNGAQBmzZqF3r174+LFiwqfIJmZmejcuTNatGiBOXPmICQkBFOmTEFGRgamT5+u2te7d++iRYsW0Gg0CAoKgouLC3bs2IG3334b8fHxGDt2LIAs3yft27fHjRs3MGbMGHh4eGD16tXYvXt3gcZY4sqVKwCA8uXLA8jaU//nn39i9+7dstGdE5mZmQo/OECWfxTjRZTCkpmZiY0bNyIpKcmkyiIpKQkrVqyAt7e37K/n4MGDqF+/vmL/uL+/P0aOHImzZ8+icePGOHjwIDp06KAoy9/fXx53U0iT9BLPy2S8RqPB7Nfq49ydeETcT8K4DeH4IaAZtFpWRTElD//SYRiGKQU8SssyTq0eG9ZO1kW0Yp2RsxS8KPZYS47LrC10MHvszVyj0cDe0gwPH6UjLjkdbg6WORXBlFHq1q2L999/H7NmzYJOp8O2bdsUhqAp9u3bhxkzZqB9+/b46KOP8lTPtm3bMGzYMMydO1c+N2HChEK1PSYmBufPn4ednR0AoEmTJujduze+++47jBkzBufOnUNERAQ2btyI119/Xb7u008/zdYf6rgyKCgInTt3xrx587IZ1hcvXsSBAwdko83Hxwf+/v4YNmwYLly4gMqVKwMAypUrh3feeQf79+9XrLanpKSgc+fO+PrrrwFkSe+7d++OL774AmPGjIGzs7PJvn788cfIzMzE6dOnZeN2xIgRePPNNzF16lS88847sLKywrfffov//vsPGzZswBtvvAEAGDZsGBo2bJivsY2Li8P9+/eRkpKCf/75B9OnT4eVlZW8737MmDFYvXo12rdvj0aNGqFNmzZ4+eWX0bFjR4XDU4kLFy7AxcVFcS4gIKDI9imfPn0afn5+SElJga2tLbZs2aJwYrtkyRJMmDABSUlJqFWrFsLCwmSHrVFRUQqjGnjiYDcqKirHPPHx8UhOTjbp+HTWrFkKJ27PE3aWWfutey7+B3sv3kPwvisIfLl6STeLYUqvYZ2cnAyNRqOQJ9Ev/AcPHphMUw/NxnIgusdPejEASg/XNE3LojOdtE3Uy3R6+pO9kFTia29vL6ep12jabkDp+Zl6fJZelECWBNtUHbQd1Hs6rY9K5agnato+Cv1xQz12A0qP3PQlRtN0nxMdM3re29vbZFupd3E6FrQcNQ/agNJLOn2Z0meIepOn951Cx4zeL/osST+qjOulHs/pPQSU40/Lomna1uvXr2frjyS9Z54PHqWrrFgXkRRc8v5tjLSSXRjDOj45a1JAimEt4WBlLhvWDKOG9F3n4eGBevXq5Zj3/v376NevH8qXL4+ffvopVyNcwtHREYcPH8adO3eKxGEVAAwaNEjx/f/666/D3d0d27dvx5gxY+T3WGhoKF555RWTBh+gfJfFxcUhPT0dbdq0QWhoKOLi4hTvQx8fH8VKaPPmzQFkSaXpe0Y6f/Xq1Wwy9qCgIDktrUBv27YNf/75J/r27ZutfUII/PLLL+jduzeEEIrfQ/7+/li3bh1OnDiBli1bYvv27XB3d1dMJFhbW2P48OH5msgwXp318vLCmjVr5C0CdevWRXh4OGbMmIGtW7ciPDwcCxcuhK2tLebNm4dhw4Yprq9SpQq+++47xbmieg4AoFatWggPD0dcXBw2bdqEgIAA7Nu3Tzau+/fvj44dOyIyMhJfffUVevfujX/++UfxO7OomThxIsaPHy//HR8fr4hq86xTx90eM3rUw4RfTmHuzovw9SqHFlXL534hwxQjpdawZhiGKUs8kYJnfS07SXusCykFT07LmphS8wqufxzfunBScCnUlvKVwrGsmdy4efMmpkyZgnr16uHMmTOYM2cOJk+ebDKvEAKDBg1CZGQkduzYATc3tzzXM2fOHAQEBKBSpUrw9fXFK6+8gkGDBqFq1aoFbnuNGjUUf2s0GlSvXl3eO+vt7Y3x48dj3rx5WLNmDVq1aoVXX30VAwYMUBjL//zzD6ZMmYKDBw9mm+Q1NqyNJ2mlz4wNJuk8nYwHsibMjfsshTtTC1d27949xMbG4ttvv8W3335rMo80YX79+nVUr149m7PCWrVqmbxOjcWLF6NmzZowMzNDhQoVUKtWrWyTKDVr1sTq1auRmZmJc+fOYevWrZgzZw6GDx8Ob29vhXFuY2OTzVgvSiwsLFC9etaKqa+vL44ePYqFCxdi2bJlAJ746alRowZatGiBcuXKYcuWLXjzzTfh5uaGI0eOKMqTwqxKz7ibm1u20Kt3796Fvb19jmE6TfnIeZ54o6knDkfE4JcTtzD655MIebcVyts+331mSjel1nkZwzBMWUKSgssr1o+l4A+KSAqu5rxMXxQr1kahtiTsOZY1kwvS6umOHTvwxhtvYObMmbh69arJvF999RV27NiB999/P9+ekHv37o2rV69i0aJF8PDwwJdffom6desqwiKpea43djKZH+bOnYtTp05h0qRJSE5OxpgxY1C3bl3cunULQNbe4fbt2+P+/fuYN28etm3bhrCwMIwbNw6AUrEFKJVWeTmfF6dkuSG1YcCAAQgLCzN5tGzZstD1UF544QV06NABbdu2RZ06dXJUJuh0OtSvXx8TJ07Eli1bAABr1qwp0vbkF4PBoOqwTXLGKn3u5+eH06dPK9R8YWFhsLe3l1e8/fz8sGvXLkU5YWFhJvdxlyU0Gg0+61kPNVxtcS8hFRuO3SrpJjFlnFK7Ym1nZweNRqOQHFEnE3QWjkqf6YuRngeUEmT6EqJS6KSkJJN1mJk9GSoqv6VycyoDVpMWUwm6sUdz+jetT01eTF/25uZPJJhU+nz79m2T/aGSNCpLptfSMqlM27h9FJqPysdpW+nMOh0nGrOR1k2hfaDtpuMCKGX8tE20DvqDhT439AVO+0nz0L7RFQG6EkCfP+PnwVhab+oa2gcq9Ze8hBr/4GKebZKNpODlbYvWK7j6HmvJsC6KFWvl/609r1gzObBlyxb8/vvvmD9/Pjw9PbFgwQKEhoYiMDBQYfACwOHDh/Hxxx+jefPmmDlzZoHqc3d3x6hRozBq1ChER0ejSZMmmDlzJrp06QIga+tPbGxstuuuX79ucmX70qVLir+FELh8+TIaNGigOF+/fn3Ur18fkydPxoEDB9CyZUssXboUn332Gf744w+kpqbi999/V6xG79mzp0B9zA2DwYCrV6/Kq9QA8N9//wHIkkubwsXFBXZ2dsjMzMx11dfLywtnzpzJFmLv4sWLhW98HpBCdEVGRj6V+oAsyXWXLl1QuXJlJCQkYO3atdi7dy9CQ0Nx9epVrF+/Hp06dYKLiwtu3bqF2bNnw8rKCq+88goAoFOnTvDx8cHAgQMxZ84cREVFYfLkyQgMDJR/84wYMQLffPMNJkyYgLfeegu7d+/Ghg0bsG3btqfWz9KKlYUOAS9WweRfzyDkbBRGtq1W0k1iyjD5WrGeNWsWmjVrBjs7O7i6uqJnz57ZvixTUlIQGBiI8uXLw9bWFr169comX2EYhmGUJBlJwaUV69jkdGQaCr7qlJKrV3BJCl4Y52WP91hbZd9jDbBhzWQnISEBY8aMQePGjTF69GgAWXteZ8yYgZCQEGzcuFHOGxsbi759+8La2ho///yz6sSrGpmZmYoJaiBrUtzDw0OxqlitWjUcOnRInrwEgK1bt2YLoSXx448/KiZuN23ahMjISNlQj4+PV0zmAllGtlarleuVJvnpynJcXBxWrFiRrz7mh2+++UZOCyHwzTffwNzcHO3btzeZX6fToVevXvjll19w5syZbJ/fu3dPTr/yyiu4c+cONm3aJJ979OiRqoS8oPz1118KvzYS27dvB5B/6XlhiI6OxqBBg1CrVi20b98eR48eRWhoKDp27AhLS0v89ddfeOWVV1C9enX06dMHdnZ2OHDggLwwo9PpsHXrVuh0Ovj5+WHAgAEYNGiQwku7t7e3rGZo2LAh5s6di++//75MxbDOiU51K0CjAf69GYs7scm5X8AwxUS+Vqz37duHwMBANGvWDBkZGZg0aRI6deqEc+fOyStq48aNw7Zt27Bx40Y4ODggKCgIr732Gv75559i6QDDMMzzQLKRFNzROst4ECLLMJX2XOeX1KewYh2fyx5r6XOGkZg8eTLu3LmDzZs3KxRkgYGBWLVqFcaOHYvOnTvDzs4OI0aMwLVr19CnTx/8888/qr8nBgwYYPJ8QkICPD098frrr6Nhw4awtbXFn3/+iaNHjyq8hA8dOhSbNm1C586d0bt3b1y5cgU//fQTqlUzvQLm5OSEl156CUOGDMHdu3exYMECVK9eXXactXv3bgQFBeGNN95AzZo1kZGRgdWrV8uGKpC1WmlhYYHu3bvjnXfeQWJiIr777ju4uroWy6qrpaUlQkJCEBAQgObNm2PHjh3Ytm0bJk2alM1rNmX27NnYs2cPmjdvjmHDhsHHxwcxMTE4ceIE/vzzT1lBNmzYMHzzzTcYNGgQjh8/Dnd3d6xevVrVcVtB+eKLL3D8+HG89tprskLgxIkT+PHHH+Hk5JRjGKqiZvny5aqfeXh4yMZ+Tnh5eeWar23bttlikzNZuNpZoqlXORy99hChZ6MwpKV37hcxTDGQL8M6JCRE8ffKlSvh6uqK48ePo3Xr1oiLi8Py5cuxdu1aOa7gihUrUKdOHRw6dAgtWrQoupYzDMM8RzxKe7wX+rFhba7Twt7SDPEpGYhJSiuwYZ0sG9ZqXsGLItyW6T3WvGLNmOL48eNYvHgxRo0ahWbNmik+0+l0WLp0KVq0aIHJkydj4cKFOHToEABg/fr1WL9+vWq5aoa1tbU1Ro0ahZ07d2Lz5s0wGAyoXr06lixZgpEjR8r5/P39MXfuXMybNw9jx45F06ZNsXXrVrz33nsmy500aRJOnTqFWbNmISEhAe3bt8eSJUtkI7Jhw4bw9/fHH3/8gdu3b8Pa2hoNGzbEjh075N9DtWrVwqZNmzB58mS8//77cHNzw8iRI+Hi4oK33nor74OaR3Q6HUJCQjBy5Eh88MEHsLOzw5QpU7KFADOmQoUKOHLkCKZPn47NmzdjyZIlKF++POrWrYsvvvhCzmdtbY1du3Zh9OjRWLRoEaytrdG/f3906dIFnTt3LrJ+TJo0CWvXrsW+ffuwZs0aPHr0CO7u7ujbty8++eQTRcQRpmzgX9cNR689RMgZNqyZkkMjCuHZ4vLly6hRowZOnz6NevXqYffu3Wjfvj0ePnwIR0dHOZ+XlxfGjh0rO+OgmApgX6lSJVSpUgVarVYho6L7n+meVScnJzlN8xvLhGg9UsgG4EmcQEC5j5vuC6ZeF+m+W1omlafRMmlIB7rn2Xh2mF5P+0r32tJ92FSuRmeD6R4xWofavm2635fu5aXhpYxnm+leZzrmdPzo3mO6H5juYaYyOlomDWFCy6d77ukzZuwVkz7WdJxon+h9oXXQsaF76NXarfbMubu7y2ljJyb0HtFy6fjRsmh9Ur8NBgNu3LiBuLg41ZBpJUl8fDwcHBxKbftKGxM3n8bPR25gXIeaeLdDlrfhtl/uwbUHj7BxhB+aVXHKpQTTDFlxBHsu3sOcXg3Qu1n2UCth5+5i2I/H0KiSI34NLJgDogmb/sWGY7fwgX8tRSzRtYdvYNKW0+hQxxXfBzTLoYSyC/+fME+LwYMHY9OmTdn8zzBlg+f9u+ZmzCO0mrMHWg1w5OMOcGbv4EwBKOz/SYG9ghsMBowdOxYtW7aU405GRUXBwsJCYfAAWTOd1NCkzJo1Sw5D4ODg8FzF2GMYhskrkhTcRv9kZbkoYlnLe6wtin/F2p5XrBmGYZgSoJKTNepXdIBBZE0YM0xJUGDDOjAwEGfOnMG6desK1YCJEyciLi5OPtSchDAMk+Uc8M6dO7h+/bocrsXYM21eHAjeuHEDXbt2hbW1NVxdXfHBBx9kc7Kzd+9eNGnSBHq9HtWrV8fKlSuLtW9lHWMpOAA4WReBYf3YKZmlmemve71ZVn2FiWMdr+IVXN5jnZyR7RqGYRiGKUo618uK+x1yxvRiHsMUNwUKtxUUFIStW7di//798PT0lM+7ubkhLS0NsbGxilXru3fvykHujVELYH/r1i1oNBpUqFBBPkcls1QqTK+ncmrjcERqMm96DQ0PQWXRNL+ajIoaJrT/VL5Nw22Z8mhpqm7qwISWS6XdtK80D5XM0zGj5dN2UMmyWqgp43KpDJuODa2PhsOi0naKmvReTf5N2023AwBKGTqVhVN5Nm0TbSutj0Ll22qhxOgzSsfSOFwZbTu9FzQfdegj9TsqKgrW1tYwNzeHwWDAgwcP8L///Q/nz5/PswPBzMxMdO3aFW5ubjhw4AAiIyMxaNAgmJub4/PPPwcAREREoGvXrhgxYgTWrFmDXbt2YejQoXB3d2cvpMWEcbgtAPK+6iJZsc5lj3VqMeyxtrfK+ptXrBmGYZjipnM9N3wZehEHrtxHXHK6PLnLME+LfK1YCyEQFBSELVu2YPfu3dmcQ/j6+sLc3FwRxP7ixYu4ceNGmQ9izzBFgZubm2xYSxNCN2/exPHjxwFAdiA4b948tGvXDr6+vlixYgUOHDggOwDauXMnzp07h59++gmNGjVCly5dMGPGDCxevFjej7506VJ4e3tj7ty5qFOnDoKCgvD6669j/vz5JdPxMkBSquQV/IlxKhnWhYllnZqr87LHXsELsWL9xLDmcFsMU1pZuXIl769mnmuqudiihqst0jMFdl9gOTjz9MmXYR0YGIiffvoJa9euhZ2dHaKiohAVFSWvyDo4OODtt9/G+PHjsWfPHhw/fhxDhgyBn58fewRnmGJEWrE/fvw40tPT0aFDB/mz2rVro3Llyjh48CAA4ODBg6hfv75CDeLv74/4+HicPXtWzkPLkPJIZZgiNTUV8fHxioPJO5IUnK5Yy3usHxXcsE7OJdyWHMe6UCvWWYaztEItIRnWyemZSCuE4c4wDMMweYHl4ExJki8peHBwMICsWHqUFStWYPDgwQCA+fPnQ6vVolevXkhNTYW/vz+WLFmS74Z5e3tDp9MpfpxT+SyVdVP5LPXibCwFN/5bgsqOaVlUKkw9S1MvcVQSTSXB1OM0lYJT2bmx4aHm5Zu2j8qaqayczkJTmTKFyp1p3dHR0XKaGltVqlSR08ZyfSqLprJr2lcqz6b3jjqyo22i0mm6J1htXOh4G8vq6X2kzwqVeVMJNu2Ds7OznKbe2dXuCa1LTd5P7xWg7BOVfNPniZ6nSBJ9qf8tWrTIlwPBqKgoxX2WPpc+yylPfHw8kpOTs3lhB7IcEU6bNs1km5ncMSkFty78inXKU1ixlvZQG69Y07/jU9LZSyvDMAxTrHSu54ZFuy9j33/38CgtQ6ECY5jiJt9ScFOHZFQDWftnFy9ejJiYGCQlJWHz5s2q+6sZhik40uTGDz/8ULINeQw7IiwcSamPnZeZP/kR8GTFuuBSammPtZWaYf3YeVmmQSA9M//GdUp6JtIeX2e8x1qn1cBOz/usGYZhmKeDj7s9KjlZISXdgH0X75V0c5gyRoG9gjMMU3LExMTIigoak506EKRQB4Jubm7ZvIRLf+eWx97e3uRqNZClarC3t1ccTN4xFW7LySZrxbegK9ZCCNkruF5NCk7OF8QzuLS/WqMBbE2sDNjzPmuGYRjmKaHRaNC57mM5+FmWgzNPl1Krj4iNjYVWq1X8iKdSbup9maapFJdKmQHg9OnTcppKlqnH63LlyslpKsVVk3BTiW9MTIycpvJqKsulsmFjA4V6y6YSZDWv09QLOb2WGlXUuKEycnotdULn5eUlpytXriynjcfyzp07cvq///6T03FxcXJaTe5MpdYUKmFXk95TaB+MPXnTeOi0TfQ8vRe0bjr29HmiMm2aNg5TZepaY0OXXkO3L1AePHggpyVZvRACd+/eRVpaGuzs7LJtJ6AOBHv16gUguwNBPz8/zJw5E9HR0XLdYWFhsLe3h4+Pj5xn+/btirLDwsLYCWExIYTAo3QT4bZssqTTBfUKnpZpgPRvryYF15MwXCnpmbDV5++1IO2vttWbQavVZPvcwcoct2OTEc+GNcMwDPMU6FzPHd/9FYHd56ORmpEph5VkmOKGV6wZ5hkiJiYGaWlpsLW1lSeE7t69my8Hgp06dYKPjw8GDhyIf//9F6GhoZg8eTICAwPlvfQjRozA1atXMWHCBFy4cAFLlizBhg0bMG7cuJLp+HNOSvoTA1jhFfzxHuvE1AykZuTfuVhK2pPJSEuVHxYajQYWj43rlAI4MIt/vGJtb2k6rAmH3Ho+WLx4MapUqQJLS0s0b94cR44cKdLy9+/fj+7du8PDwwMajQa//vqr4nMhBD799FO4u7vDysoKHTp0wKVLl4qk7lmzZqFZs2aws7ODq6srevbsiYsXLyrypKSkIDAwEOXLl4etrS169eqVTdWTX4KDg9GgQQNZ4ePn54cdO3YUa51qzJ49GxqNBmPHji32+qdOnQqNRqM4ateuXez1AsDt27cxYMAAlC9fHlZWVqhfvz6OHTsmf16czxnz9GhcyRGudnokpGbgwOUHuV/AMEUEG9YM8wyRmJgIIQQSEhLklfiaNWti/fr1cp758+ejW7du6NWrF1q3bg03Nzds3rxZ/lyn02Hr1q3Q6XTw8/PDgAEDMGjQIEyfPl3O4+3tjW3btiEsLAwNGzbE3Llz8f3333MM62LiUdoTBQPdC21naQbd41Xg2ALss5Zk4FoNYK7LvposYSl5Bi+QFDyrXcb7qyUkz+C8Yv3ssn79eowfPx5TpkzBiRMn0LBhQ/j7+yuUWYUlKSkJDRs2xOLFi01+PmfOHHz99ddYunQpDh8+DBsbG/j7+yucjBaUffv2ITAwEIcOHUJYWBjS09PRqVMnhXpp3Lhx+OOPP7Bx40bs27cPd+7cwWuvvVaoej09PTF79mwcP34cx44dQ7t27dCjRw85OkNx1GmKo0ePYtmyZWjQoIHifHHWX7duXURGRsrH33//Xez1Pnz4EC1btoS5uTl27NiBc+fOYe7cuQqlYnE+Z8zTQ6vVwL8uewdnnj6lVgru6OgInU6nkH9TeTCV1qp5cb527ZqiTCpHpl6uqRScSnSpp216nsqx1eTiVFpMy6fnjT1I0/roNdR7NZWPUxkwPU+9YNMxU/Pe7e7uLqcdHBzkdKNGjeR0nTp1FG2l40/v0b59++Q0HSfaJiqZpzLve/eeOJmg/ad9oGNBvVbT/gBKmbfkRRtQenqnEnt6X9SupWNDpfD0pUyfgZxk//S5ofeF9o/unZbutYeHhzyuBoMBd+7cQVxcnGIcJQeCaj9QgSzJv7HU25i2bdvi5MmTOeZhigYp1JaluVY2pIGsHwflrM1xPzENMUlpqGBvqVaESahHcPo/ZYyluQ7xKRkFWrF+EsM6F8M6xfSWCab0M2/ePAwbNgxDhgwBkBXnftu2bfjhhx/w0UcfFUkdXbp0QZcuXUx+JoTAggULMHnyZPTo0QMA8OOPP6JChQr49ddf0bdv30LVHRISovh75cqVcHV1xfHjx9G6dWvExcVh+fLlWLt2Ldq1awcgKxpKnTp1cOjQoQKHE+3evbvi75kzZyI4OBiHDh2Cp6dnsdRpTGJiIvr374/vvvsOn332mXy+uPosYWZmZtKxbXHW+8UXX6BSpUpYsWKFfI5uhSvu54x5unSp54bVh65j57kozMysBzMdryUyxQ8/ZQzDMCXMk1Bb2Y3TcoUIuZWbR3AJyYGZlD8/yDGsVaTgDuy87JkmLS0Nx48fV8S112q16NChQ45x7YuSiIgIREVFKdrg4OCA5s2bF0sbJDWQ5Nvi+PHjSE9PV9Rfu3ZtVK5cucjqz8zMxLp165CUlAQ/P7+nUicABAYGomvXrop6gOLv86VLl+Dh4YGqVauif//+uHHjRrHX+/vvv6Np06Z444034OrqisaNG+O7776TP3/azxlTvLzg7YRy1uZ4+CgdR67F5H4BwxQBbFgzDMOUMEmpWau5pgzgJyG3CmJY5xzDWkLaf12QfdxPYlibXrGWDO64QoQMY0qO+/fvIzMz02RceynufXEj1fM02mAwGDB27Fi0bNkS9erVk+u3sLBQOCItqvpPnz4NW1tb6PV6jBgxAlu2bIGPj0+x1imxbt06nDhxArNmzcr2WXHW37x5c6xcuRIhISEIDg5GREQEWrVqhYSEhGKt9+rVqwgODkaNGjUQGhqKkSNHYsyYMVi1ahWAp/ucMcWPmU6Ljj5Z9zKU5eDMU6LUSsHv378PrVarkC9SyTc9nxfpLqDuCZzKlOmXJ/W0TeXIVBZOJeVq3smpVJr2gcqJjdtLvU6ryYupnJh6kKbl0Gvp2NC+0fPUyzlNG3vyVvPK7unpKacvXLggp+kY0HZTqAxaTXpP07TPVNYNKD2gW1tby2kqn6fn6X2nsmo6NlSqTp8Z2h/6nFDofTDuBx0bNdk6fV6l+nKS9jLPFsmPpeA01JaE5MCsIJ7BpZVwtVBbEpLhnVqIFWs7tRVra16xZp4dAgMDcebMGcWe3+KkVq1aCA8PR1xcHDZt2oSAgADFlqri4ubNm3j33XcRFham+D3wNKCS/wYNGqB58+bw8vLChg0bVMM5FgUGgwFNmzbF559/DgBo3Lgxzpw5g6VLlyIgIKDY6mVKjs713LDh2C2EnI3ClO51TUauYJiihFesGYZhShhpj7WVCSm4k23BDWt5xTqXUCN62XlZwb2C577Hmg3rZxFnZ2fodDqTce1N7ZEtDqR6irsNQUFB2Lp1K/bs2aOYJHZzc0NaWlq2sIlFUb+FhQWqV68OX19fzJo1Cw0bNsTChQuLtU4gS3IdHR2NJk2awMzMDGZmZti3bx++/vprmJmZoUKFCsVaP8XR0RE1a9bE5cuXi7Xf7u7uckhJiTp16sgy9Kf1nDFPj5bVnWGrN8Pd+FSE34ot6eYwZQA2rBmGYUqYpMdewa1NSLadimCPtWUeV6wLtsf6cbgtK9Mr1lJc7MRUdl72LGJhYQFfX1/s2rVLPmcwGLBr166nFtfe29sbbm5uijbEx8fj8OHDRdIGIQSCgoKwZcsW7N69W+HQCgB8fX1hbm6uqP/ixYu4ceNGkY+BwWBAampqsdfZvn17nD59GuHh4fLRtGlT9O/fX04/rT4nJibiypUrcHd3L9Z+t2zZMlsYtf/++w9eXl4Aiv85Y54+ejMd2tV2BcDewZmnQ6mVgltZWWWTglPpNN1/QyXLNI+xpIhKf6nUmsqrKVTWS6VStE1Uukul5lSOLTlCAZRyYhcXF0V99DMqR6bX0z5QT9Y0P5UQq52nUuurV6/K6cqVK8vpo0ePymlj2XFkZKScpjJqOpZUJk89nqt5xKby7dTUVDlN7y8th4497Y9xWWpjdv/+fTktOakBlJ7lqUy7SpUqcvr27dtyWq2fdnZ2JusClM8mbSsti7aD5pdk5bRtzLNNTlLwJ3us87/iK61AW1nkbcW6YF7Bcw63Je0bl/rIPHuMHz8eAQEBaNq0KV544QUsWLAASUlJspfwoiAxMRGXL1+W/46IiEB4eDicnJxQuXJljB07Fp999hlq1KgBb29vfPLJJ/Dw8EDPnj0LXXdgYCDWrl2L3377DXZ2dvI7zcHBAVZWVnBwcMDbb7+N8ePHw8nJCfb29hg9ejT8/PwK5aV64sSJ6NKlCypXroyEhASsXbsWe/fuRWhoaLHVKWFnZyfvIZewsbFB+fLl5fPFVf/777+P7t27w8vLC3fu3MGUKVOg0+nw5ptvFmu/x40bhxdffBGff/45evfujSNHjuDbb7/Ft99+CwByHO/ies6YkqFzPTf8/u8dhJyJwsQutXkbHVOslFrDmmEYpqyQkxTc8fFKcGxhnJflIgWX91gXII51fC57rCWjPrkARjtTOujTpw/u3buHTz/9FFFRUWjUqBFCQkKyOXkqDMeOHcPLL78s/z1+/HgAQEBAAFauXIkJEyYgKSkJw4cPR2xsLF566SWEhIQUyf7g4OBgAFkhBikrVqzA4MGDAQDz58+HVqtFr169kJqaCn9/fyxZsqRQ9UZHR2PQoEGIjIyEg4MDGjRogNDQUHTs2LHY6swPxVX/rVu38Oabb+LBgwdwcXHBSy+9hEOHDsmLDcVVb7NmzbBlyxZMnDgR06dPh7e3NxYsWID+/fvLeYrzOWNKhjY1XaA30+JGzCOcj0yAj4d97hcxTAFhw5phGKaEeZSDFFxaCU4oQBzoJ1LwvIbbKvo41pJhXZCymdJDUFAQgoKCiq38tm3bKtQ7xmg0GkyfPh3Tp08v8rpzqlfC0tISixcvxuLFi4us3uXLlz/1OnNi7969T6X+devW5fh5cfa7W7du6Natm+rnxfmcMSWDjd4MbWq6YOe5uwg5E8mGNVOslFrDOiEhARqNRjFLSOW6VKZNPXBTCbaxp2g1yTf1eE0lxbQOKqOmslwqa6ay6+joaDlN5b00v7FzDiptVpMHq3n5prJg2gean/aHyoxp+VSyTOXyVLJt/BmVwFNP3XTMqHSfyrxpP2m7qXybjhP1pk3zUwk2oHwOYmKexC9Uk4jT8VOT8VP5O33maDtcXV1N5qHPBqAcA/qMqz2j9H5JY8BS8OeHJyvWpgzrrP/hhAI4/8qrV3C9WcH3WEt7p+1ZCs4wDMOUQjrXc8syrM9GYXynWiXdHOY5hp2XMQzDlDCPcthjLa0EF8T5V57jWJsX3Ct44uMVa1u9ihT8cd2P0jPztDLIMAzDMEVJ+9oVYKbV4L+7ibhyLzH3CximgLBhzTAMU8JIq7nWJvZYF4kUPI97rAvjFdw2Fym4EAXbw80wDMMwhcHB2hwvVs9Sp7J3cKY4KbVS8HLlykGr1SpkxjY2NnKayoypvJpi7BWcSnOpRJrKmqlEl8p61STVVCrs7u4up9U8ldNyqIdqQCkppjJfKvmm11PZMO0r9XhIpd00T6VKlUzWRdtAJdh0XACl1J3WR53Z0GvoPaLnaX8o9LyaXJx63ba1tVVcT58PKh+nY07LoveRemun+Wm76b2mXtEp9Frje238t4SaZ3Qq15fazVLw5wcp3JaVyT3WWf8Lj9IykWkQ0Gnz7tFUWrG2sshNCv54j3U+V6xTMzKRlml43E7TrxO6Wp6Snpnr6jnDMAzDFDWd67ph/3/3EHo2CoEvVy/p5jDPKbxizTAMU8LkFG5LigMNPJFd5xVJ2p1nr+D5XLGm7bExsdoOAOY6Lcx1WZMB7BmcYRiGKQk61a0AjQY4dSsOtx4+yv0ChikAbFgzDMOUMDmF27Iw08oryvH5dGAmGey57rEu4Iq1JAO3sdDluJIu1f+IHZgxDMMwJYCzrR7NqmQ5QQ49e7eEW8M8r5RaKXhycjK0Wq1Cxku9fFMZLPVETSXYVAYtlSlBZdFqsmPqaZrKsSlUnk7lvfRaDw8POU3l28aeomk71GS+VLZOpcw0TceASpzpeVo39fhNvU/T8aZyb+O20s/oeZqmnrmpF+z4+HiTbaLjR8eC3h8q96bybeNraJ9ofdT7N90mQJ8nKsemcnO18ab9VOuP8fV0nOk19Jmjz410nqXgzw85hdsCsuTgqYmp+XZg9iTcVi5ScHnFOn+Gr9QetRjWElbmOiSkZLBn8GeY1NRUzJo1CxMnTlRsTXme6y6LfS7Justin5mnS+e6bjgSEYPQM1F4+yXvkm4O8xySrxXr4OBgNGjQAPb29rC3t4efnx927Nghf56SkoLAwECUL18etra26NWrF+7e5VkhhmGYnHgkOy9TM6wL5sBMWoHW59kreP4ma3JzXCZhzbGsn3lSU1Mxbdq0bP42nue6y2KfS7Lusthn5unSuZ4bAODo9RhEJ6Tkkpth8k++DGtPT0/Mnj0bx48fx7Fjx9CuXTv06NEDZ8+eBQCMGzcOf/zxBzZu3Ih9+/bhzp07eO2114ql4QzDMM8LsmGtN22gPjGs8ycFz2u4rSdxrPMrBc9qj61KuyWk+nmPNcMwDFNSeDhaoaGnA4QAws7xwh9T9ORLCt69e3fF3zNnzkRwcDAOHToET09PLF++HGvXrkW7du0AACtWrECdOnVw6NAhtGjRIl8Ni4+Ph0ajUUhjqRy2XLlycprKaqmM19jzMpX3UBmxmvyWSnTVyqHcu3fPZDkUKoM2lgdTeTr1PE6l1lQK7ebmZjIPLdfJyUlOU0k0lcWreb6mUmljz+vW1tYwBZWe0/7QOujY0HJonx0dHeU0vb9UCk/7TO+nMbQOOjZU/u3s7Cyn6X2knsfVYvBS+TftM/WqTu87oBx/Oub0uabjQb2tSxJwloI/P8hS8FxWrAsqBTflbZxS0BXrJ1LwnF8lUsgtloKXHIsXL8aXX36JqKgoNGzYEIsWLcILL7xQ0s1iGIZ5qvjXc8O/t+IQciYK/Zt7lXRzmOeMAu+xzszMxMaNG5GUlAQ/Pz8cP34c6enp6NChg5yndu3aqFy5Mg4ePKhqWKempioMC7oHlmEYpiwgOy9TMYClFeH4/ErB5RXrnMVJlgVcsc6zYc0r1iXK+vXrMX78eCxduhTNmzfHggUL4O/vj4sXLyrCSqphMBhw+/ZtACXzjpbqfNp1l1S9ZbXuZ73PQggkJCTAw8ND4R+IKV10ruuGOSEXcfDKA8Q9SoeDdc4+QhgmP+TbsD59+jT8/PyQkpICW1tbbNmyBT4+PggPD4eFhYVipRHIWmlTi/MLALNmzcK0adPy3XCGYZjngUyDkFeKbVSl4Fkv/vyG28qzFPyx4Z2Sz3Bb8h7rXKTg1rxiXaLMmzcPw4YNw5AhQwAAS5cuxbZt2/DDDz/go48+yvX6O3fuwMfHBwBQqVKlYm1rTpRU3WWxzyVZ97Pe55s3b8LT07MIWsMUB1VdbFGrgh0u3k3An+fvopcv3yum6Mi3YV2rVi2Eh4cjLi4OmzZtQkBAAPbt21fgBkycOBHjx4+X/46Pj0elSpXg7u4OrVYrz5IDSnkwlRxTaTGV6xpLwelMJPVYTSXBFCohpp6z6bVULk7T1IM0lSxTSTWV+gJKyTOtm0qTGzRoIKepfJmuOty5c8dkmsqlaVvpOFGZe5MmTeQ0lZQDSvnztWvX5DSVJ9MZW1o3vV+0z1SWSGX/VMJ+6tQpOU1l4VSCbVyumrydto/2h+ahY0Pl3LR8+jzQ+06fN9ofQCn5puOhJpOnz6ixLJ95tqGruGpScMlwzf8e68dewXOJYy3tsU4tYLit3LyC8x7rkiMtLQ3Hjh2DwWCAh4cHIiMjsWXLFnTo0AEHDx40eY2xkkx6r+p0Omg0GtWtPfSdRN+Z9DuLfncCyu9J+h1LI27Qa+g7nqbpe5a+W+l3Mm0TfWfQd4Hxu4R+d9P3IG0fTdPfKfR9SrcG0XcabTeti5bp5+cnp19//XU53axZM0Vbd+/eLaePHj0qpw8dOiSnr169arKtdIwrVqwop+n9pVuY6H1TiyxiDC2LPl9q95e+W+kzRCO+0D7QrYD0WaLvTxrFw/g3mNq2O/p7iT4rtI6kpCQIIZCYmKjYQsaUTvzrueHi3QSEnI1iw5opUvJtWFtYWKB69eoAAF9fXxw9ehQLFy5Enz59kJaWhtjYWMUX3d27dxV7gY3R6/Uc2oBhmDLLo8dyao0GcrxqY+wL6RU8Vym4uSQFz+8e67w5L2MpeMlx//59GAwG1K1bF5MmTZIdilaoUAEXLlwweY2akqx8+fLQarWqnpMjIyPlNDVCqTFifC2dyKSGDTXQ6IQtNc5oufR3hFpYRmoIUSORnjeekFcLm0jDaNapU0dOt2zZ0mT7Ll68KKfPnz8vpyXnr8Z9oO2mkwO0TOO2ens/CR904sQJOU2NYDp+tN/UGKxcubKclpQKgNIQPXfunJy+fPmynKYT7dHR0Yr20WeCjitVNVJjmj4rapPz1OB2d3eX03RRgeanbTJeMDD2hSKhNqFgHAZTeu6Mw5MypY8u9dzw9a5L2P/fPSSlZqiqxRgmvxR6E4jBYEBqaip8fX1hbm6OXbt2yZ9dvHgRN27cUMy2MgzDME+QPYKb61R/kMlS8Hw7L8urV3BJCp7PPdYp7LzsWeGdd97B//73vzzlnThxIuLi4uTj5s2bxdw6hmGYp0dtNzt4lbdGaoYBey/ey/0Chskj+ZqimThxIrp06YLKlSsjISEBa9euxd69exEaGgoHBwe8/fbbGD9+PJycnGBvb4/Ro0fDz88v3x7BgSzpjRBCMYNIZy/prK2afMf4RyqdIaUzr3QmlNahJhWj0GvpzDudyaQzwTlJ0GnbqdSJ7vnx9fWV061btzbZHzoDTvt85coVk/npODVs2FBOV61a1WS9gHI2mErWqLSQrl5QFQOdfad9qFGjBkxx/PhxOX3jxg05TWeqjeVn9DO6CkDvL20TvZ7eaypxo/JtCr2/ajPsxjPhdKWBzoDTsaHyM1Oz+OwV/Pkgt1BbwJM40fmRggshnkjBc/UKLknBDRBC5HnFJSGvhrU5G9YlxQ8//AAAaNeunfxddfv27VzVZAzDMM8rGo0Gneu5Ydm+q9hxJhJdG7jnfhHD5IF8GdbR0dEYNGgQIiMj4eDggAYNGiA0NBQdO3YEAMyfPx9arRa9evVCamoq/P39sWTJkmJpOMOUVVJTU5GUlCRPzGzduhX9+vWTPx88eDBWrVqluMbf3x8hISHy3zExMRg9ejT++OMP+X924cKFCsP+1KlTCAwMxNGjR+Hi4oLRo0djwoQJxdy7skduobaAJ4ZrfryC09BZuUnB9eTz1AxDroa4REKq5Lws5z3W8oo1S8GfOn///Te8vb3RokULfPjhh2jUqBGmTp0Kc3NzjBkzxuQ1alLwBw8eQKPRKCb6qC8IOmGoFm7Q2N8EvYZ+/9CJZyrlpZM+dBKUlksnU2nddPKa5qH1GofBpBOYaiEe6SQtHQ8qNablUlk4DaVIy6R9o5Os1L8MnYAH1Pct0z7QSWfqv8XFxUVO00n1WrVqyWm1PdK0P7Quup/ZuE/0+aAT/bSvdHGDto9ORqstEqg9l2q+XwBl/+jzp7bXW23hh3k26Fw3y7DecyEaKemZeX7vMUxO5MuwXr58eY6fW1paYvHixVi8eHGhGsUwjDpCCJibm8PS0lLxI4vSuXNnrFixQv7b2I9B//79ERkZibCwMKSnp2PIkCEYPnw41q5dCyDrh0unTp3QoUMHLF26FKdPn8Zbb70FR0dHDB8+vPg6VwbJLdQWUDCv4FTWneuKNXFulpqed8Naao8th9sqtYSEhGD9+vUICAiAv78/gCyDzNbWVvYSboyaU1GGYZjnhYaejnCzt0RUfAr+uXwf7etUyP0ihsmFUrtbPy0tDVqtVjEjSGcv6WwsnVmks5R05tP4GrVZSyrrpTOqFLUZWdoOKsGm5avNogLK2XR6Pb2GtlvNezU1tqh0mpZD+0nHic6wv/LKK3KazmADSik4dcRCZ/7pLD6dCabyQzoLXbt2bTlNx4LO9J85c0ZO//vvvybrNYbeFzp+ap696XjQ+0tnyekzQMeSnqfjTfsDQNXbPYU+f7Qd5ubmMDc3z1EKrtfrVWWe58+fR0hICI4ePYqmTZsCABYtWoRXXnkFX331FTw8PLBmzRqkpaXhhx9+gIWFBerWrYvw8HDMmzePDesiRjKsc3KeInsFT827FFySgeu0Gpjrcl6xNtdpoNUABiF5Bs9bXE+pPXndY53fPdxM4QkODkZwcDA0Go3CkF62bJlitZRhGKYsodVmycFXHriGHWei2LBmigSOYM8wzyF79+6Fq6sratWqhZEjRyrCkBw8eBCOjo6yUQ0AHTp0gFarxeHDh+U8rVu3VkzY+Pv74+LFi4p955TU1FTEx8crDiZ38iIFL4hXcNlxmYqncYpGo5FDbuXHM7jsvCwXj6rSCvgj3mP91PH09MTs2bNx6tQphSdn6k/DmFmzZsHBwUE+eLWaYZjnEf+6WQsQf56/i/RM9lvDFJ5Su2LNMEzB6Ny5M1577TV4e3vjypUrmDRpErp06YKDBw9Cp9MhKipKEfccyFIUODk5yWFPoqKiFKFbgCd7AaOiokw6clPbl8nkTH6l4Hl1LiaF2rLKwWCn2Oh1SE7PRFJa3ox3IYTspTw3Kbg1ewUvMbp3747ExERcvnwZM2fOBJC1bWvDhg14++23FaGVJNSk4NbW1tn2WKtB96LScEU5qYuoCoemqYNMuqeWpqmq59GjRybz0HbQ/yE6gWjcN7p3lradKtGoAsnT09NkHqpAUgsrRvdMV6tWzWQeqoQyhiqyqEqKhqGi4bCo2oqOGXU8SsOKUW7duiWnaT+pQsx4D7javafjT58bOk5USUbPq6kXaR76/NC2GofbonvO1fZP0/Gn9el0umzKNKb006xKOTjZWCAmKQ1HImLQsrpzSTeJecZhw5phnjP69u0rp+vXr48GDRqgWrVq2Lt3L9q3b19s9fK+zIKRnBcp+GPDNcOQ5ek7L8aytPKsN8ubYW1vaY77iWmIT86b3Dw1w4D0zKwfknmNY81S8JLh2LFjePnll+W/U1JSMH36dFy/fh0rV64suYYxDMOUIGY6LTr5VMC6ozex40wkG9ZMoSm1hrUUbovOHlOvnzRNZxDV9mEDyllLOjPp7PzkH4nO2tJ9znSmm9ZNV/7UZsPv3r0rp6kTKWOPlHSGlM5Q0xl32r/r16/LaS8vLzlN9yTTcuiMOc1Dy6SzxdLqJZB9Fp/GNaXjTPtH5cd0jGmb6Ew/vSd0bE6ePCmn6Uy6mpdQQLnPnN53tXuk5o2W1kf3tKuFdaPtpu2Ljo5WtM94plyCPlt0/6Pa3vC8ULVqVTg7O+Py5cto37493NzcsrUnIyMDMTEx8r5sNzc3xXMLPHmO1fZu6/X6bE7SmNyRVohzMpZtLHTyHuiE1PQ8GdaP8lAuxc4q6388r57HJVm6RgPYWLDzstKKEALLli2DRqOBRqOBEAJVqlTBq6++igULFpi8htUnDMOUFfzruWHd0ZsIPXsX01+tB602b+EmGcYUpdawZhimaLh16xYePHggywH9/PwQGxuL48ePy/HJd+/eDYPBgObNm8t5Pv74Y6Snp8uTKmFhYahVq5ZqPG+mYEgr1tY5SME1Gg1s9WaIT8lAQkoGXO1Us8rIHrtzWU2WcHhsWMflccValoFbmOX6Q8TSgvdYlxSBgYHYvn07vvvuO0yZMgVNmzbFtm3bsk2uUdTUJzqdDhqNRjE5SiW6dKJZTRJMHVkCykleej116kgnOCtWrCin1WTeag4rqfSZTiJTvxHG2yxom9RCKl25ckVO00loOlFPJ0QjIiLkNB0P+t1K+0bbqhaeDFBOztN+0IlmNRk/nXi/dOmSyT7QMaYhtuh5NWecgLKv9LmhiyNqCwO0b2pjQxcJ6L2i/c9Jrk3Hhk7I07YaP79Sm+Pi4uSyO3TogGnTpqFLly6IiYnBlClTsHPnTty4cQMuLi7o2bMnZsyYoZisv3HjBkaOHIk9e/bA1tYWAQEBmDVrlqK+vXv3Yvz48Th79iwqVaqEyZMnY/Dgwar9YfLGi9XKw05vhnsJqTh58yF8vUwvfDBMXmDnZQzzjGEwGJCeni7/eLx+/TrCw8Nx48YNJCYm4oMPPsChQ4dw7do17Nq1Cz169ED16tXlUDt16tRB586dMWzYMBw5cgT//PMPgoKC0LdvX3k/Xb9+/WBhYYG3334bZ8+exfr167Fw4ULFj22maJCMzZyclwFP9lnn1YGZlC83j90SkoO0vErBE1Ky8uW2vxpgKXhJEhwcjPj4eAwdOhS3b9/Gb7/9hoyMDOzfv7+km8YwzwU6nQ4WFhayYqt169bo0aMHzp49izt37uDOnTv46quvcObMGaxcuRIhISF4++235eszMzPRtWtXpKWl4cCBA1i1ahVWrlyJTz/9VM4TERGBrl274uWXX0Z4eDjGjh2LoUOHIjQ09Kn393lDb6ZD+zpZE2g7TkflkpthcqbUrlg7ODgoZiIBpcyYzkJTyTbFeGaSzqpSRydqjkRoHbQt1JkHnQml5dBr6Qw7nRk3DrdFZ0XpzCmd6Q4PD5fTdGaXSrOPHj1qsn1qjmFou48dOyan6fjR2VtAObt99epVOU3l4/R+UVkxnWWnjlTorD/NQ0OG0TGis/7Gjrbo7Dadcaezv/Re05lumqb5qXybzobT+0DHiYYkM15ZoDPVNFwZfS7p80El8zqdTiF9nzRpEiZNmoSAgAAEBwfj1KlTWLVqFWJjY+Hh4YFOnTphxowZivuxZs0aBAUFoX379tBqtejVqxe+/vprRft27tyJwMBA+Pr6wtnZGZ9++imH2ioGZMM6l5VlyUDOayxraUU5z4a1LAXP44p1Pgx3dl5WcgghsG7dOsycORNHjx6FpaUlypUrp/reBNSl4NI7gb4baFrtHaOWP6fr6XspL3Xkpb68lG9MXuqj7yW6Wk7T9D2u5oiLnqf56QotfW8Zb4Gi7yL6jspL3XQMaLtp3fQ8LYem1cYop8/ych/zcn/zmzZuX36fMwm9Xo9Hjx7J13/yySf44YcfcOjQIbz99tv45Zdf5LzVqlXDzJkzMWDAAGRkZMDMzAw7d+7EuXPn8Oeff6JChQpo1KgRZsyYgQ8//BBTp06FhYUFli5dCm9vb8ydOxdA1gT533//jfnz58uT5kzB6VzPDb+G30HI2Sh83LVOnhyEMowpSq1hzTCMaSwsLODs7AyDwYCYmBjExcUpfiTnZQbbyckJa9euzTFPgwYN8NdffxW6vUzO5CXcFkBiWefR8JXy2enzFpM6v1LwhNS8S83pHuu8ejVniobAwED8/PPPWLNmDS5duoS1a9ciNjZW4czMGGMp+O3bt+Hj46OYqDUFlWyrQf1IGJOTPJ225WlCJ3bVoBPbdPK7qKAT3suXLy/y8ksa6o9FDTpprwadRM8LOeWnkxT55aeffkJSUhL8/PxMfi69s6WJ+4MHD6J+/foKvyr+/v4YOXIkzp49i8aNG+PgwYPo0KGDohx/f3+MHTtWtR2pqamKCRYOgalOm5qusDTX4tbDZJy9E496FR1yv4hhTMCGNcMwTAmSl3BbwJOV4TxLwfMYCkvC/rHUPD45f1JzW8vcDXdpj7VBAGmZhjx7KmcKjxR7/pVXXgHwZJXy119/hZmZGVJTU02qw6jCxdbWFufOnYOPjw9u3ryZ42p3cSDt8X7adZdUvWW17me5z2fPnkXHjh2RkpKCjz/+GFu2bIGPj0+2fPfv38eMGTMU6q+oqCiFUQ0ow1vmlCc+Ph7JyckKpZ0EOyHMO1YWOrSt6YqQs1EIORPFhjVTYEqtYZ2YmAitVqt44cfExMhpKsulM5k0hmROkjM1GTB1vEHl3FRaTGftqaSXzn5S79D0BwqVERl/edP66AwulWJRubTazD2daaVlUrkWbTdtBx2LgwcPymnjmV1jGbsE7TeVP9M6aLupZ3PqwISOE/UWTu8bldgbe8qmqyL0Gvo8Udk1rY/Kv6lnb/qc0XGiY0nrVZPQAcptCdRjOn1G6eoNff6k9pmSpDHPHnkJtwWQPdapxbTH2urxHus8S8HT81w+nTRITstkw/opsmXLFsX3LAAMGTIEtWvXxocffpjNqDaFVquVv2/t7e2futEjUVJ1l8U+l2Tdz2KffX19ER4ejri4OGzatAkBAQHYt2+fwriOj49H165d4ePjg6lTpxZhq03DITDzR+d6blmG9dkovO9fq6SbwzyjlFrDmmEYpiyQl3BbwJOV57xLwSXDunik4PIe7jxIwc11WphpNcgwCCSnZ8IxTzUwRYGdnR3q1aunOGdjY4Py5ctnO88wTMGwsLBA9erVAWQZ2UePHsXChQuxbNkyAFmT7p07d4adnR22bNmi8KPj5uaGI0eOKMozDm+pFgLT3t7e5Go1wCEw80u7Oq4w12lwOToRl6MTUD0v4TcYxgj2Cs4wDFOC5CXcFlAA52XyHuv8SsHzZ7jnNZyXFTswYximjGAwGOT9zfHx8ejUqRMsLCzw+++/KxRoQFZ4y9OnTytUamFhYbC3t5dXvP38/LBr1y7FdWFhYar7uJn8Y29pjpbVsxSEIWfYOzhTMErtirUQAkIIhbMFKtOmklkqC6det43jKdIvMyo7pl9m9Boq5aXtoHJfOutIHfJQOTGtl8qSafnGbaLyPCrDppJi2lYqLablGn+Bm4J6+L5165acpvt5aLuN66PS+Fq1nshnjD1Zm2ofLZeOK62bytml2VtAeU+M+2kq1qRxHfRZoc+QWpxPOt5Uhk1jtNJrqfd4uo0BUI4fjV1KtwCoxeeUxoOl4M8H0spvblJw++IOt2WVz/JT87cibmWuQ0JKBpI55FaJs3fv3nxfo9frMWXKlBJZASupustin0uy7me1zxMnTkSXLl1QuXJlJCQkYO3atdi7dy9CQ0Nlo/rRo0f46aefEB8fL/92cXFxgU6nQ6dOneDj44OBAwdizpw5iIqKwuTJkxEYGCi3Z8SIEfjmm28wYcIEvPXWW9i9ezc2bNiAbdu2Fek4lHU613XD3ov3EHI2CkHtapR0c5hnkFJrWDMMw5QF8hoWS/YKnpo/qXZenZflWwqekr/yecX62Uav1z+VfaGlqe6y2OeSrPtZ7XN0dDQGDRqEyMhIODg4oEGDBggNDUXHjh2xd+9eHD58GABkqbhEREQEqlSpAp1Oh61bt2LkyJHw8/ODjY0NAgICMH36dDmvt7c3tm3bhnHjxmHhwoXw9PTE999/z6G2ipiOPhUwactpnLkdj5sxj1DJyTr3ixiGwIY1wzBMCZFpELJX8NxWfvPtFTyfe6ztJal5agYyMg0w0+W8Uyghn1JzGnKLYRjmeSGnEGht27bNMU66hJeXF7Zv355jnrZt2+LkyZP5bh+Td8rb6vGCtxMOXY1B6NkoDG1VtaSbxBQhefltU1hKrWGt1+sVEmBAKRumch0q46VfYNSbNKCUC6t556ZSayrXpVJcKtmm3qipdJeep/JjKg829uptY2Mjp6lHbSoFpx4daXxN2gfabyqJplJmKlmmY0bHiHoRN/a6TT1h07G8du2ayTZR7OyeOISgsnBaH5VX0/y0LvoMGMvq6bNDnw/aJurBnHpSp2NG01Q6TutW8xxOx9LYuQitj44/rY/2iY4HlcMzzzaJxMO3jT63Pdb5k2rH58NrN/BECi61y9HatOd/mic/5fOKNcMwDFPa6VLPHYeuxiDkDBvWzxuf/HYW9xJS8FGX2sXmnI6dlzEMw5QQknFqYabNNQSVLAXPg1dwIUS+vHYDWZ67rR8bv3mRgyfkVwrOK9YMwzBMKadT3SwfP8dvPER0fEouuZlnhWv3k7Dh2E38eT4asY/ytuWtILBhzTAMU0LkR05tR6TauZGUlglJCJFXKThAPYPnXke+vYI/NqxT2LBmGIZhSinuDlZoVMkRQgCh5+7mfgHzTLDgz/+QaRBoW8sFTas45X5BASm1UvCUlBRotVqFXNfC4ok0kUp6qVSaymqpNFsqU4LKrilUfkvrox6/1STlVC5N5eI0D/VkTfMAkEMzAEqpMZWkX79+3WQ76LWurq5ymsqUqWdqNekzbVOdOnXkNB07QOlJnPablnXnzh2T5dKy1MaS9oeOmRrGe5iorJyOn7Ozs8n66PNAtwNQST6Vz9P7Q8eS5qH1GkvpqSdwWh+VfFPP6PS5lNrNXsGfffLjACw/e6ylcnVaDSzN8z5/am9lhqj4JzLyHOvIp1dwy8er4Y9YCs4wDMOUYrrUc0P4zViEnInEwBZeJd0cppBcjErAb/9m2STvd6qVS+7CUagV69mzZ0Oj0WDs2LHyuZSUFAQGBqJ8+fKwtbVFr169sgW1ZxiGYZ6ErMrLqq9kwD5Ky0SmIWdnOAlkfzWdFMyNvHoGV0jNWQrOMAzDPEf4183yZXPoagweJqXlkpsp7cwLuwghsiZM6lV0yP2CQlBgw/ro0aNYtmwZGjRooDg/btw4/PHHH9i4cSP27duHO3fu4LXXXit0QxmGYZ43EvMRa5oa34m5rFrnx2CnPJGC52xYJ6c/Me7zWoe0fzuFV6wZhmGYUkwVZxvUdrNDpkHgz/O8OPgsc+pWLELP3oVGA4zvWLPY6yuQFDwxMRH9+/fHd999h88++0w+HxcXh+XLl2Pt2rVo164dAGDFihWoU6cODh06hBYtWuS5DktLS2i1WoVEl0qzqayZ4u7uLqdv3bql+IzKdClUiqsmr6WrPtTjtJrncOoJnErSqaSXeqsG1L1Uq8nbqRz5/+3deXhTZdo/8G9O0qRrUrqlLV0oUHYQ2UplEaVScBkXXlccNwZ+rwOOWB19mXFwGUfmxQ1xEHTGZZxXxmVGZxyXSgUFlLJYRMtWtpbSJS3d96Rt8vsjPaf3SXPapgtZen+ui8tjenLOc04CzZPn+9wPjU7T6ywvL5e2aUScxufpdmJiZ+SF3ktajRyQX9+BAwek7dOnT0vb9FppFJy2m14PrWZOn0vj2Eqxa8eq4LSSOH3taGV5GlunbaJoJXDaVnpM+l4MDw93uo8j+nrRdtD3OH1dnE0t4Ci495PWmtb1HKe2FzgTYG6zoq6lFYZA5ee4utSWSKwM3lMUXOzYC6rODnNPeMSaMcaYt1gyKQYnTPXIPGLCzTPie34C80jPbz8JALhx6nAkGwenEjjVpxHrVatW4ZprrkFaWprs8ZycHLS2tsoeHzduHBISEpCdne30WGazGXV1dbI/jDE2FLgyYm3fz97x7amAWb2LS22JehsFpyPivY2a+/vxHGvGGGPeYfEkexx8z6mKXhUNZZ7nQH4Vdp+8AI2gwpq0wR+tBvrQsX7vvfdw6NAhrF+/vsvPTCYTtFqtbL1kwF6Eia7vS61fvx4Gg0H64zgyyhhjvkrsAPc2Tq3vZQEzqcPuchTcvn9PVcH7MiIurWPNI9aMMcY83BhjMJIigmBpt+LrE+U9P4F5FJvNhue/zAMA3DIzHgnhgT08Y2C49Knr/PnzePDBB5GVlSWr5twfa9euRUZGhvT/dXV1iI+Ph0qlgkqlklWWph12Wt2ZRmbz8/OlbceoNR0Np9FfOuJC48V0fxrzptFf+jit/EyPrxRrprFkQB73pVWtafScxn/p8+njdJteD/1yg75+tPo0jd5fdtll0jatLg7IY+vHjh1zely6TaPj9D4pxdxpJJrGv+k+NMJP7xEgv+e0rfS1pjF++jit2E33MRg6Cx7QdtP4t1L1c8fXevTo0dI2vT4a16fPp+errKzs8hjzTtLIby9HloOljnUPI8oujoSLXI2CuzKHW5pjzR1rxhhjHk6lUmHxpGhs+eYMMo+YcN0lse5uEnPB7lMVOFBQBa1GwANXju75CQPEpRHrnJwclJeXY9q0adBoNNBoNNi1axc2bdoEjUYDo9EIi8UiW4oJAMrKyhAdHe30mDqdDnq9XvaHMcaGAlc7qL1dy9rVDrtI38soeIPZ9ai5GAVv5ig4Y4wxL7C4ozr413nl/KWwF7HZbHhhu320+uezExFjCOjhGQPHpY71woULkZubi8OHD0t/ZsyYgWXLlknbfn5+2LFjh/ScvLw8FBYWIjU1dcAbzxhj3kzsIOt7O8daJ44o93aOtYvFy3pZFbzOhfW3RVy8jDHGmDeZEmdArMEfTZZ27D55oecnMI/w5dEy/FRUi0CtGvcvGHVRz+3ScEZISAgmTZokeywoKAjh4eHS48uXL0dGRgbCwsKg1+vxwAMPIDU11aWK4IA9OisIgqxKNR0Jp7FmGr+Nje2MatDIsSMaea6trZW2aaSYRnxp5WZ6PhrHpdFkGuWmsWalatBAZ8TX8Rw0/ky3aeVrGv+mx6FtUqp8TSPHNPJNI+/0vgJAQUGBtD1qVOebNjc31+m5aVvpddMYNH0daHKB3j96v+kxHVMStJq30nuCxvjp607vE92fxtnp69OblIXja00roNOpDDTZQe+fs2rhNptN9tox79PQxyh4j8tt9TkK3jHHupdzuF2JggfwiDVjjDEvolKpkD4pGm99V4DMoyYsmug8fcs8R7vVhhez7KPV981JQkSw877PYOnzOtZKXnrpJVx77bVYunQp5s+fj+joaHz00UcDfRrGGPN69VIHtXcjy+KIco9R7T4WL+ttVXDxCwEuXsYYY8yXiXHwr46VobWdlzn1dJ/+VIKTZQ3Q+2uwYv7Ii37+Pq1jTX3zzTey//f398fmzZuxefPm/h6aMcZ8mqtVwaP09m9ey+q6TyrUmwc3Ct6X5by4Y80YY8zbzBgRhohgLSoaLMg+U4n5YyJ7fhJzi9Z2K17Ksq9b/f8uHyUNFlxM/e5YD5agoCAIgiCL4tK4M604rRTddawUTWPONC5NY+EUjSbT89E4NkWjyTSiS2PKtCo4jRYDQExMjNP20eugz6eVrJUqX9O4M60QTqtU0+fu2rVL2qYVsR2j1mfPnpW2jx496nQ/Gnun7aCV3mmMmr6+StW/6T2j10n3AeQV4Wnsmkb06ftG6TWlaFVwem9om+h7id5j+t4A5NFueh1FRUXSNq2CT9sqVnFvb2+XvUeZ9+kc+e3dP8Wxofa/R8U1zd3u15eoNtBZvMzcZkVLa7tUcKzL8c39iYLzN/6MMca8g1pQ4aoJ0fj7gUJkHjVxx9qD/TOnCAWVTYgI1uKey0a4pQ0DHgVnjA2upqYmFBUVSUvLffrpp7Kf22w2rFu3DjExMQgICEBaWhpOnTol26eqqgrLli2DXq9HaGgoli9fLpvvDgA//fQT5s2bB39/f8THx2PDhg2De2FDkKsd4FiD/Qu+0truO9Z9nWMdotNA/J6nuyW3Khrsy9kNC9Iq7uNI7FhzZVXGGGPeZPEkexx8+9EytFt5qVNPZG5rx6Yd9s+69y8YjSAXBxYGCnesGfMyVqsVOp2uy9riog0bNmDTpk3YunUr9u/fj6CgIKSnp8uSCcuWLcPRo0eRlZWFTz/9FLt378bKlSuln9fV1WHRokVITExETk4OnnvuOTz55JN4/fXXB/36hop2qw2NHYW8XB2xNtW2wNrNL/e+LrclCCppXnZds3IBs/J6exolKqT3RUHEKHiTpY3XYGeMMeY1UkeGQ++vQUWDGTnnqnt+Arvotu0vREltC6L1/liWkuC2dnhsFFytVkMQBJSVlUmP0ZgtjXzTD2k0GutYBZtWXx42bJi07ThS5wyt6qwUwaaRYBottlgs0jaNOztG0GnbaVtpXJpeEz03jYvT2DqNYNNoNj0ObTeNLx88eFDaptFvx2PRCu30XtLYOn2cXg+9r7StNFJOY9O0Uju9lzQ2DcjvOX0+vedK7xuK3kv6utNj0nPT2LnS1AVA/nrR50RERDhtH43PC4IAlUolew3oczZu3IjHH38c119/PQDgnXfegdFoxL/+9S/cdtttOH78ODIzM3Hw4EHMmDEDAPDKK6/g6quvxvPPP4/Y2Fi8++67sFgsePPNN6HVajFx4kQcPnwYL774oqwDzvqu0dL5b1hvO8BRITqoBRVa222oaDAjSu/vdD9xDrTexTnWgD0OXtfS1u2I9YWOOd5GhfM7I3asrTbA0m6FTtPz9AvGGGPM3bQaAWnjjfjoh2JkHjFhVlJYz09iF02TpQ2bvz4NAHhg4WjFaWwXA49YM+ZD8vPzYTKZkJaWJj1mMBiQkpKC7OxsAEB2djZCQ0OlTjUApKWlQRAE7N+/X9pn/vz5si8Q0tPTkZeXJ1vKjDKbzairq5P9YcrEGLhWLfS6k6lRCzB2jBIrzbNubbeipdX+pY6rUXCg58rjVqutbyPW5BddC8+zZowx5kXSO+LgXx41cerKw7y9twAVDRYkhAXilhnxbm0Ld6wZ8yFiekAscCYyGo3Sz0wmE6KiomQ/12g0CAsLk+3j7Bj0HI7Wr18Pg8Eg/YmPd+8/bp5OWmrLxc6vGAcvqXFeGZyucd2XOUZiFU2lyuDVTRa0dcTQXVkf0k8tQCPYUx9cGZwxxpg3uXxMJAL81CiuaUZuMReO9RS1za14bZc9VbsmLRl+avd2bT02Ct7S0gJBEGQf7mklZvptER1Bo/FYx3hvUlKStE1H02gsmsZ3AwMDpe2qqippm8Z1aTyYtom2lY760Ui0UjVyQB6jphWvaaeGtptGuHvTJnoNSrFwWkXcMQpO0ftPI8807qwUjaeRdzpnmF4PfS6Nv9Ntx6g1rf5N26EUEaeUov70/UDvpVJsn56Xvn8cj0Uj8PT+08fptmMFdE+xdu1aZGRkSP9fV1fHnetuNJhdW2pLFBsaAJyrVixgJnbYA/zUffoFow/omGPd4nyOtThaHR6khVbj2vED/NSoN7ehyaI8f5sxxhjzNP5+alwxLhKf55qQecSEKXGh7m4SA/DGnrOobW5FclQwrp863N3N4RFrxnxJdLQ9qkRrE4j/L/4sOjoa5eXlsp+3tbWhqqpKto+zY9BzONLpdNDr9bI/TFlfK3fHhNq/RFKKgotrWLs6Ei7qaS1rcQ3tSBdi4CJ/XsuaMcaYl1o8yb4sbuYRjoN7gsoGM9741r5CTsZVY6AWVD08Y/Bxx5oxH5KUlITo6Gjs2LFDeqyurg779+9HamoqACA1NRU1NTXIycmR9tm5cyesVitSUlKkfXbv3i0bHc/KysLYsWNlhf9Y3/VlLWgAGC5Fwbsfse7L/Gqg5yi4NL/ahcJlokAtL7nFGGPMO10xNhJatYCzFY04Vd5z4WM2uLbuOoNGSzsmDddLS6K5m8dGwQMCAiAIgiyKSz/k0w/3NCqsFOsG5NFwGgmmMWIaf6ax65iYGGmbtom2gz5Oq5bTytc0Auz4bRe9DtomGg+m8XEaK6fXSo9D48i0ejW9FzQSTdtHI870OI5tUoqt03tJo/f02mhkm1bHpvsoVTkvLi52el5A+f7Tx+m0AXoNNOZN4+l0lFfpdaTXYzAYpG3Hgl/0fVpRUSFt09eIHoueo7GxUfZ6nzt3DocPH0ZYWBgSEhKwZs0aPPPMM0hOTkZSUhJ+97vfITY2FjfccAMAYPz48Vi8eDFWrFiBrVu3orW1FatXr8Ztt92G2NhYAMAdd9yBp556CsuXL8djjz2GI0eO4OWXX8ZLL70ENjAa+tgBjjXY/w6U1jqfY93ZsXa9IjhgrwoOKK9jfaGjY23sw4i1WMCsmYuXMcYY8zIh/n6YmxyBnSfKkXnEhDHGEHc3acgqq2vBO9nnAAAPLxorm8bpTjxizZiXsVqtaGlpkb7I+c1vfoNLL70U69atAwA8+uijeOCBB7By5UrMnDkTDQ0NyMzMlH1B8e6772LcuHFYuHAhrr76asydO1e2RrXBYMD27duRn5+P6dOn4+GHH8a6det4qa0B1NcRazEKrjRiLc7dDulD4TIA0Hd09JWqgotR8Ch9H6LgfhwFZ4wx5r3EkdEvjjgv5Moujld2noK5zYoZicOwYExkz0+4SDx2xJox5pxarUZQUBBsNhuamppQW1srm8+sUqnw9NNP4+mnn1Y8RlhYGLZt29bteaZMmYI9e/YMWLuZXF+rgotR8IoGC1pa27us19jvKHigGAVXKF5WJy615XoUXByx5uJljDHGvFHaeCPUggrHS+twrrIRieHKhYjZ4Dhf1YT3DpwHADyS7jmj1QCPWDPGmFtIHWuda5FtQ4Cf1EE1OYmDdx63n8XLFKLg5fX2cxr7MGLNc6wZY4x5s7AgLVKSwgDY17RmF9/Gr06hzWrDvOQIzB4Z7u7myHjsiHVjY2OXOdZ0XiudI03nnyrtA8jnBQ8f3lmSXWku8ciRI6XtyspKaZvOHaaU5vXSbXou2lZHdLkpOteWnoNeDx2xpPON6bc4JSUl0nZycrK0nZ+fL22HhYVJ20rLUQFQLGAVEtI530RpaTDaPjrPmS4BRtG513SOOW2fY1vpPaPbdA4zvX9K10BfI7pN7yud607bQa+NHhOQXxO9l/T9R19rOqdafP9xRUrvJkW2XRxZVqlUiA31x5kLjSipacaICPm35QM1x1o5Cm5/X0f2YcRaqgpu4Y41Y4wx77RkUjT2nqnEF0dMWDl/lLubM6ScLq/Hxz8UAbDPrfY0PGLNGGNuIM6x7ktkO1asDO5kxLqhn8ttdVcV3GazScXLovpTvKyVi5cxxhjzTosm2udZ/1BY4zQ5xgbPS1mnYLUBV00wYmp8qLub0wV3rBljzA36E9kWK4M7K2AmHlffx451aGDniLWlzWFlheZWWNrtj/WleFlnVXCeY80YY8w7GfX+mJYQCgDYfozj4BfLkeJafJZbCpUKeHjRGHc3xymPjYK3trZCEARZhJbGbOmSSDTqSyPUjstt0RhxQUGBtE0jvjTmrRTHpks+lZWVOT0ORePs3U2wp8tk0ZgvbTeNt9MlwOhyUTRuTuPENI6tFC+nUWS6vBSNmjteB41U08fDwzvnPdC4tFJkvqamRtqmkW2lSDXdpsuHOV4HvVYaT6dou6OioqTt8+fPS9v09VFaooy+1pTj4zRyT49LlyWj94a+l8X7arVau1w38x59rQoOdI5Yl9Yqd6z7WrwsMliHYJ0GDeY2nKtsRDJZTkSMgYcG+kGnUSsdQlGAlquCM8YY835LJsXgUGENvsg14a7UEe5uzpDwYtZJAMB1U2IxLlrfw97uwSPWjDHmBg19rAoOALEdS24V1ziJgvexKJpIpVJhVKT9y7xT5Q2yn4mFy/oSAwdoVXDuWDPGGPNe4rJb+/MrUdVo6WFv1l8556qx80Q51IIKD13lmaPVAHesGWPMLaSR5T50gKU51k6i4GI1776OWAPA6Cj7KPVpx451x4i1Ue964TLaJnG0njHGGPNG8WGBmBirh9UGZHEcfNA9/2UeAOC/psUhKcJzlzhz6ZPXk08+iaeeekr22NixY3HixAkA9rjrww8/jPfeew9msxnp6el49dVXYTQaXW6YVquFIAiyiC6Nf9NYM32cxmod0Qg3jXnT2DGNI9OILz0fjWPTCLbSuen+BoNB2qaRbUA5vlxaWipt0/g3jQfTCDE9Lo1w07bSCDttU3V1tdPnOkaOlSpZ021aST0ysnPxdtpWeg10W6laOI3IK1VFB+RVt2lsm94D+prS81VUVEjb9D2gdJ/o+4fG3JWmLgDymDd9j9P7R6cA0POJ1+041YF5l4EoXlZa04yW1nY8/OGPOF3WgFfvnNYZMe9Xx9r+98SxY13WMWId2ccRa7EwWk2T84rjjDHGmLdYPDEaR0vqkHnEhFtnJri7OT7ru9MVyD5bCa1awK/Sknt+ghu5PGI9ceJElJaWSn++/fZb6WcPPfQQ/vOf/+DDDz/Erl27UFJSgptuumlAG8wYY97OarX1qwMcY7CPGDda2rHine/x2U+lyCurx7I/70dlg/2LvL4WLwOA5I6OdZcoeJ1YEbxvI9ahgfYvm2oUlvJijDHGvIUYB//udKWUFmMDy2az4fnt9tHqO1ISMDw0oIdnuJfLn7w0Gg2io6O7PF5bW4s33ngD27Ztw5VXXgkAeOuttzB+/Hjs27cPs2fP7n9rGWPMBzSSqth9KV7m76dGeJAWlY0W7DlVAa1GQIzBH+cqO9MqfV3HGugcsT57oQHtVhvUgj1VIS61ZexDRXCgc8S6tonnozHGGPNuycYQjIoMwpkLjfj6RDmunzrc3U3yOTtPlOOHwhr4+wn45RWev2a4y5/oTp06hdjYWPj7+yM1NRXr169HQkICcnJy0NrairS0NGnfcePGISEhAdnZ2Yoda7PZLIvhijFhi8UCQRAUK3bTSDB9Po0Et7bKvz2iMV16XBqdptWaaZSZRojpcWl0lx6HVqym+9B2021AHv+mMWBapZpGiGmlaaVoO418JyR0xlQczy2ilbxpnNox5k5jzvR+0OfT+LNSZXR6b/z9O0fB6L2g56Kxevpcx/bR6DmtBE4fp+j7hraDXgM9Dt2fvv+UqqXTCD8gvx9KVdLp+4m2SbxujoJ7L3G02k+tgk7Tt1IXsaEBqGy0QC2o8Ood0zAlzoBbXstGQUfnui8ddlF8WCC0GgHmNiuKq5uREG7/97KsTixe1tcR644oOI9YM8YY8wGLJ0Vj89dnkHnExB3rAWa12vD8dnsl8HsuS+rzZ4+LyaVPdCkpKXj77beRmZmJLVu2ID8/H/PmzUN9fT1MJhO0Wq2sUwcARqNRcYkjAFi/fj0MBoP0Jz4+vk8Xwhhj3qKBrGHd3RJ83ZmbHAGtRsALN1+CtAlGROn98e6K2RhrDEHqyHAEal1fDkukFlQYGSFWBu/8gqi8Y8S6L2tYA0Box4h1XXMrrFbnX+4xxhhj3mLxRPvAyTd5F9DMK14MqM+PlOJ4aR1CdBr89+Uj3d2cXnFpSGPJkiXS9pQpU5CSkoLExER88MEHssJgrli7di0yMjKk/6+rq+PONWPMp9X1Y6kt0WOLx+FXVyZLa0MDwPDQAGSumQcAfe6wi0ZHBeOEqR6nyxuwcLwRNput38tt6Ts61lYbUG9uk6LhjDHGmDeaNFyP4aEBKK5pxq6TF6R516x/2tqt0rrVy+clSTVaPF3fP9XBHjkeM2YMTp8+jauuugoWiwU1NTVdosjO5mSLdDqdrDqzSK1WQxAExQrXNKZMY7I0vu0YD6bPp1FoGmWm1a/pcWklaxojp1XEafybRrPpB1wacabRdsf20eM2NHQWEKIRYhpPpxFiGhGm1burqqqkbaVItbPXAkC3X5zQ66DxZ/o4va/0OulrRNtN7xN9nL5W9Ln09XH8WVxcnLRNXwv6XqH3Q6m6e3cV550dn8b5HdunND2AvuccpzKIxKrlSnF+5vmkiuB9XGtaFOBkVLq/HWpRclQIgFKpgFldSxtaWu1/F/sax/L3UyPAT43m1nbUNrVyx5oxxphXU6lUWDwpGm98m48vj5q4Yz1APv6hGGcvNGJYoB+Wz01yd3N6rV/rWDc0NODMmTOIiYnB9OnT4efnhx07dkg/z8vLQ2FhIVJTU/vdUMYY8xUNAzBiPdgcl9y60DFaHeKvcdqh763OedZcwIwxxpj3W9LRmf7qeBksbVz/pr8sbVa8vOMUAOC/Lx/Vr2KsF5tLHetHHnkEu3btQkFBAfbu3Ysbb7wRarUat99+OwwGA5YvX46MjAx8/fXXyMnJwb333ovU1FSuCM4YY0SD2Z5GCOlHgbHBJnasz5Q32GPg0lJbfYuBi3gta8YYY75kWsIwRIboUN/Shr1nKtzdHK/3/sFCFFU3IzJEh7tSR7i7OS5x6VNdUVERbr/9dlRWViIyMhJz587Fvn37pErLL730EgRBwNKlS2E2m5Geno5XX321Tw1TqVRQqVSySDCNxipV9aZxbBqhBuRxaRrVHj68s4ofjZjTqC2NQtOIM4290wgmrfRsMBik7dLSUmk7IiJC1j4a/6bRZNpuGqunsW0aIRajwoC8oja9TzQirlRF3Gg0StuO8VJ6fUoVsul9ou1TujaKVuOmrzttBz2+Y/vo+eh9pe8nev+UovH0uDQKTt8/NPJNj0+PQ+8LIL9u+hz6uihVDhffT1arVXafmPeo94IR6xERgVALKtSb21BWZ0ZZx4i1Ud+/qpxSx5orgzPGGPMBgqDCoglGvLu/EF8eNWHB2Kien8Scara045WdpwEAD1w5ul8JOXdw6VPde++91+3P/f39sXnzZmzevLlfjWKMMV8mzrHuz5JYg02nUSMxLBBnKxpx3FSHvx84DwCIG9a3QpUiMQrOa1kzxhjzFUsmxeDd/YXYfrQMz9xgg1oYmHonQ83f9hWgvN6M4aEBuG1mQs9P8DD9mmPNGGPMdd4wYg0Aozri4L/5KBcH8qsQrNNg5fz+LXkRGmBP0dTyiDVjzMtt2bIFU6ZMgV6vh16vR2pqKr744gvp56+//joWLFgAvV4PlUolS9CJqqqqsGzZMuj1eoSGhmL58uVdEpc//fQT5s2bB39/f8THx2PDhg2DfWnMRSkjw2AI8ENlowUHC6p6fgLror6lFVu+OQMAeDAtGVqN93VTPfZTXX19PVQqFcLDw6XHaByWRndpZJn+Y0QjtoA8zh0WFiZt03g2jf7SiDOt6kxjwErxYBpVp5WyadTXMb5Mz0GPS+Pfp06dcnosGoumMWN6HFpFXKl9NNZM77Fj5JjG5JVi4TTKTPenEWxamTshwfk3U7SiOL1OpcrhjvvRWDh9jlIFc9pWev9olF6peje9r/Rc9L467kdfd/pepOegfw/EX8wDVf2ZXXxi8TK9hxfkSI4KRtaxMpTWtkClAl6+bSpGR4X0/MRuSMXLeI41Y8zLxcXF4Y9//COSk5Nhs9nw17/+Fddffz1++OEHTJw4EU1NTVi8eDEWL16MtWvXOj3GsmXLUFpaiqysLLS2tuLee+/FypUrsW3bNgD2zwiLFi1CWloatm7ditzcXNx3330IDQ3FypUrL+blsm74qQWkjTfin4eKkHnEhNkjw3t+EpN589sCVDe1YmRkEG66dHjPT/BAHtuxZowxX+UNUXCgs4AZAPw6fSwWjjd2s3fvGAJ5jjVjzDdcd911sv//wx/+gC1btmDfvn2YOHEi1qxZAwD45ptvnD7/+PHjyMzMxMGDBzFjxgwAwCuvvIKrr74azz//PGJjY/Huu+/CYrHgzTffhFarxcSJE3H48GG8+OKL3LH2MEsmReOfh4rw5VET1l07AQLHwXutpsmCv+w5CwB4KG0MNGrvG60GOArOGGMXnanOnuYID9b2sKd7zR8TiZERQbg7NRH3Xz5qQI4pRsF5xJox5kva29vx3nvvobGxsdfLzGZnZyM0NFTqVANAWloaBEHA/v37pX3mz58vK0abnp6OvLw8VFdXKx7bbDajrq5O9ocNrrnJEQjUqlFa24Kfimt7fgKTbN11FvXmNoyP0eOayTHubk6feexwiV6vhyAIsoguje7SWDetZE3/4YmJkb8wNLJbVeV8/gOt5Hz+/Hlpm0bHafSZRs9p3Je2g0aqleLEjs9XilTTWDh9nN4npcdpXJreM1q1nLaJRrBpfBuQ3wNaVZzGn+k9oFWx6XNp1FrpH32lCDut4E6vE5C/LjQaT7fpcZXaR68hKqqzyiP9ZUZfK/r+oa8DfQ84Pp9Gz+n7rLy83Ok+YgSco+De61yl/d+BEeFBPezpXhHBOux8ZMGAHlMqXsbrWDPGfEBubi5SU1PR0tKC4OBgfPzxx5gwYUKvnmsymWSfLQD755SwsDCYTCZpn6SkJNk+4hRIk8kkmxZIrV+/Hk899ZSrl8P6wd9PjSvGReGzn0qRecSEqfGh7m6SVyivb8Hbe/MBAA9fNcarR/p5xJoxH/Pkk09Ky9WJf8aNGyf9vKWlBatWrUJ4eDiCg4OxdOlS2RctAFBYWIhrrrkGgYGBiIqKwq9//WvZFw6s7xrMbahosH+RkxAe2MPevofXsWaM+ZKxY8fi8OHD2L9/P+6//37cfffdOHbsmLubhbVr16K2tlb6QweL2OBZMsk+AJZ5pFQ2KMKUvfr1GbS0WjE1PhQLx3v3UmUeO2LNGOu7iRMn4quvvpL+n47UP/TQQ/jss8/w4YcfwmAwYPXq1bjpppvw3XffAbCnDq655hpER0dj7969KC0txV133QU/Pz88++yzF/1afE1hx2h1WJDW44uXDQZex5ox5ku0Wi1Gjx4NAJg+fToOHjyIl19+Ga+99lqPz42Ojpal0wB7aq6qqkpKKEZHR3f58lv8f5pidKTT6bqkDdngWzA2ClqNgILKJuSV1WNctL7nJw1hxTXN2La/EIC9lou3pzE9tmMtCAIEQZBFZpUqgdOIM430dlfJmkZ8aRyZHotGfOlzaTtCQjor5CpFnGnUmkalHdtHz0dj2PQc9Pro4zR2TNHrVIpp03ZUVFRI2zRu7/hGp5Fx2ib6OL1P9B93GtOm94wuQ0Fj2rRTSN8P9FyO95K+jvRe0qg1jeXTe0PbSq9BqeI3nVZAY/E0Fu5YFZxSeo1oW2nU/dy5c4rHEmk0Gqe/cGtra/HGG29g27ZtuPLKKwEAb731FsaPH499+/Zh9uzZ2L59O44dO4avvvoKRqMRU6dOxe9//3s89thjePLJJ2XtZa47V2lfPSAhbOiNVgN0HetW2Gw2r/8lyhhjlNVqlX0u6k5qaipqamqQk5OD6dOnAwB27twJq9WKlJQUaZ/f/va3aG1tlT4LZGVlYezYsYoxcOY+wToN5idH4qvjZcg8YuKOdQ82fXUKlnYrUkeGY87oCHc3p984Cs6YDzp16hRiY2MxcuRILFu2DIWF9m8Dc3Jy0NrairS0NGnfcePGISEhAdnZ2QDshVImT54s+/IqPT0ddXV1OHr06MW9EB90rsr+hU7iEIyBA0BooP2LGUu7FS2t1h72Zowxz7V27Vrs3r0bBQUFyM3Nxdq1a/HNN99g2bJlAOxzoA8fPozTp08DsM/HPnz4sPSF/Pjx47F48WKsWLECBw4cwHfffYfVq1fjtttuQ2xsLADgjjvugFarxfLly3H06FG8//77ePnll5GRkeGei2Y9WizFwU1ubolny69oxD8OFQEAHkkf6+bWDAyPHbFmjPVNSkoK3n77bYwdOxalpaV46qmnMG/ePBw5cgQmkwlarVY2sg7YEyC0UArtVIs/F3+mxGw2y76l5wqkzokj1okeXrhssARp1dAIKrRZbahptiBAG9DzkxhjzAOVl5fjrrvuQmlpKQwGA6ZMmYIvv/wSV111FQBg69atsgJi8+fPB2BPit1zzz0AgHfffRerV6/GwoULIQgCli5dik2bNknPMRgM2L59O1atWoXp06cjIiIC69at46W2PFja+ChoBBVOmOqRX9GIpIih+fu+Jy9lnUS71YYrx0VheqJvpC88tmNtNpshCIIsRk0/qNNtGtOm0WIaZRaP6exnNCocEdEZQ6DxYnoOGuulEV36OK1gToWHdy4YT6PIgLzTQtvX2Njo9Fi0TXSbRsqVKqkrxZRoh4tGtmlE2fH59DWi56MRbnoN9B7TGCjdh8au6etDo9n0+DR679heeiy6H42S08fptdHXl1aVp9dMr4HeM3p82lZAHlVXaje9Vhq/jouLk45RUlLS5RhLliyRtqdMmYKUlBQkJibigw8+6PJ3YiBxBdLeESuCJw7RKLhKpUJooB8qGiyoaWpFjIE71owx7/TGG290+/Mnn3wSTz75ZLf7hIWFYdu2bd3uM2XKFOzZs8fV5jE3CQ3UInVUOPacqkDmERPuXzAwy1X6khOmOvznJ/tn2IcXjXFzawYOR8EZ83GhoaEYM2YMTp8+jejoaFgsFtl8dsBeCKW/hVK4AmnvSEttRQzNjjXAlcEZY4z5tvSJHXHwoxwHd+aF7SdhswHXTI7BxFhDz0/wEtyxZszHNTQ04MyZM4iJicH06dPh5+eHHTt2SD/Py8tDYWEhUlNTAdgLpeTm5soqlWZlZUGv13e7NqdOp4Ner5f9YXLmtnaU1NqTMAlhQzcaJnaseS1rxhhjvmjRRCNUKuDH8zUoqWnu+QlDyOHzNcg6VgZBBTx0le+MVgMeHAX39/eHIAiKFZ1p5JtGcaOiOtc/q6yslB2TVmmmkVuxQITjPrTSNq3ATaPFNJJOK1nTyC09Do07O8axaRw5MjJS2laKldM4MY0aK0XjafvoMWnMmI5kKlVIB+SRdhp/ptdNq1WWlpZK2/Q66f1TiurT+0ej6vQ1dJwzTGP29N4oRbvpsWj76PuPXo/S/aP3iUbBHd+L9NwUPTedWkBj4eI1KFVTfuSRR3DdddchMTERJSUleOKJJ6BWq3H77bfDYDBg+fLlyMjIQFhYGPR6PR544AGkpqZi9uzZAIBFixZhwoQJ+PnPf44NGzbAZDLh8ccfx6pVq3jpjn46X9UMm80+zzgieOhWVxcLmPGINWOMMV8UFeKPGYnDcLCgGl8eNeHeOUnubpLHeGF7HgDgxkvjMDoquIe9vQuPWDPmY4qKinD77bdj7NixuOWWWxAeHo59+/ZJX9a89NJLuPbaa7F06VLMnz8f0dHR+Oijj6Tnq9VqfPrpp1Cr1UhNTcWdd96Ju+66C08//bS7LslnFFZ1LLUVHjSkl5kK5bWsGWOM+TgpDs7VwSX7zlZiz6kK+KlVWJOW7O7mDDiPHbFmjPXNe++91+3P/f39sXnzZmzevFlxn8TERHz++ecD3bQhr6CiY371EF1qS2QQ17LmjjVjjDEflT4xGs98dhwHC6pQ0WBGRPDQTv3ZbDZptPrWmfGI98Eirh7bsdZoNBAEQRZHpnFYuk3jszQGTWO/gDx2TCOt9Fg04kvj2DRaTPehlcNp5JjuT6PjNNZMY+uAPCZO57fSCDeNENNj0WugFavpdVZUVDh9nG7T49OIs2PVbXpuGtu+cOGCtF1dXS1t01gzLYxFI9i03TSSTl9HGq/uLlZPRwPp/aP3lVYnp22lr11MTIy0La47Cdg7niIa86btoOeirw8gf+2Vph/Q9z7dFu+HUmVx5h6FlU2wtFu7jTUVdqxhnTDEO9ahARwFZ4wx5tviwwIxebgBucW1yDpWhttnJbi7SW616+QFHCyohk4j4IErfW+0GuAoOGOM9VtruxU3bdmLn/3pW5TXtyjuVyCuYT2EC5cBQGggFy9jjDHm+xZP4jg4II5WnwQA/Hx2Iox6/x6e4Z24Y80YY/109kIjKhrMaLK0d/vLs7CSo+AAL7fFGGNsaBA71nvPVAzp6U9fHjUht7gWQVq1T6/r7fFRcBrjpbFrWn2ZxolpLNcxCk6rOtPIOD0ujXnTiC7dn8Z9acSZtoPGqGnUmu7juM5vfHy80/1oO2j7jEajtE0jxHSbRqJpnJveVxpxpnF2Gp2n1+l4DlqtnR6XVlKn56AVxel1Kt1Xisa/lV4TQH7PaGV02lYaN6fvARptp+ej97I31czpuRyrgNP7RKPxdNoAjY/Ta2Ce51hpZ/X4T38sxV2pI7rs02614Xw1R8GBzjnWtGPd1m6FRs3f9TLGGPMdoyKDkRwVjFPlDdh5ogw3Xhrn7iZddO3WztHq++YmIdyH55q7/CmmuLgYd955J8LDwxEQEIDJkyfj+++/l35us9mwbt06xMTEICAgAGlpaTh16tSANpoxxjzJsZLOL1oOnquCqbZrHLykphmt7TZo1QJiDAFdfj6UhAbIi5dlfHAYYx7/Ate98i2e+fQYjhTXdvd0xhhjzGsM9Tj4Jz8W41R5A/T+Gvxi3kh3N2dQudSxrq6uxpw5c+Dn54cvvvgCx44dwwsvvCAbCd6wYQM2bdqErVu3Yv/+/QgKCkJ6erpshJMxxnzJ8VJ7kkSlAmw24IsjpV32OdcRA48LC4BaGLpLbQF0HWsLSmqa8fEPxbDagNziWvzl23zc+Op3OF1e38NR3Ovfh4sx+Ykvsfd0Rc87M8YYG7LEjvWukxfQZBlaCcTWditeyrIPsP6/y0dJU8F8lUsd6//93/9FfHw83nrrLcyaNQtJSUlYtGgRRo2yZ+VtNhs2btyIxx9/HNdffz2mTJmCd955ByUlJfjXv/41GO1njDG3stlsOFZqH7G+cepwAMCnPznpWHesYT0ifGgXLgM6R6wbLe14/+B52GzAtIRQbLx1KqbGh6K13YY/fnHCza1UZrPZ8FLWSdSb27D9WFnPT2CMMTZkTYjRIz4sAC2tVuzKu9DzE3zIh98XobCqCRHBWtw7Z4S7mzPoXJpj/cknnyA9PR0333wzdu3aheHDh+OXv/wlVqxYAQDIz8+HyWRCWlqa9ByDwYCUlBRkZ2fjtttu63JMs9ksm6Mqzl21WCwQBEE20k3n7MougswLpvOZ6ZxYQD5PlS7bRB+nSzA1NDQ43Z+i85aV5mRTdAkmuryU4zmUll2iz6HLZ1H0ftA20ePT+bt0XjCdG07vH537C8jvjeP8YRGdO0zPTZezou1QmpdO5zPTufV0vjl9LiC/B3QudWxsrLRN7x+9T/S6lZZ1q63tjKrS66fvJZrkcETbTvej94Yei16f+Dgvt+UZyurMqGq0QC2o8GBaMj4+XIycc9UoqWlGbKj971ZruxUfHLTXVOhuOa6hQk++sf6/fecAAHekJOKGS4djcpwBi17aja+Ol2PvmQpcNipC9tyW1nZ8k3cB85IjEKTr+ivMZrPhsX/+BAD436VTuvweGAjfn6tGQUcCoai6uYe9GWOMDWUqlQqLJ0bjz3vykXnUhCWTY3p+kg9oaW3HKzvto9W/XDAagVqPLe01YFwasT579iy2bNmC5ORkfPnll7j//vvxq1/9Cn/9618BACaTfe4ALaol/r/4M0fr16+HwWCQ/tACXoyxoamougnNlvaed3TRucpGbMg80avKnHUtrVi97RA++bGk2/3EwmWjIoOQGB6EmYn2onWf53aOWm/++jR+LKqF3l8zJL6x7YlaUEHvb/8FW9loQZBWjasn26NyoyKDsSzFvtbns58fh9Xa+SVlS2s77n3rIP77/3KwaYfz2h0HC6rxwfdF+OD7Ipy50OB0n/4SvyQB7O9VxhhjrDuLJ9k70zuPl8PcNvCfbzzRu/sLUVrbghiDP+5IGRpreLvUsbZarZg2bRqeffZZXHrppVi5ciVWrFiBrVu39rkBa9euRW1trfTHsVI2Y2xoOV5ahwXPfYPFL+8e8E7L+s9P4NVvzuBPO3suqPjh90X49KdS/PrDH3G+qrMdlQ1mfPxDEVrb7YkBsXDZhBh7muKaKfZfnm99V4Cv88px+HwNXtl5GgDw+xsmDfnCZSKxMjgAXD05RvZN9oMLkxGs0+BIcR3+eagIgH3Uf/W2H5B91r7ywzcKcbp/5hRJ2/vzq5zuc6qsHive+R4ffn9e1nHvjQZzGz4jX5oUVzcrJpQYY4wxALg0PhRRITrUm9uw93Rlz0/wco3mNrz6tf2zz68WJsPfT93DM3yDS2PyMTExmDBhguyx8ePH45///CcAIDraPuJQVlaGmJjOmENZWRmmTp3q9Jg6nU4W+xWZzWYIgiCLw9J4L43S0ogu3ae3EUD6HBo1pkswKUWZe9MmGhWOiopSbEdhYaG0TZdjolF5GsmmsXAal6axYRpZplF6uswVXVKK7h8X17kkAL02x3bQ49L7V1LSOdJHX2Mac6cxdKVoM30uvZf0cfqaAPKoOlVQUOD03DQKTl87GiOPjIyUtul7g95vpUi54wdvuhQcPQc9N42I03sjvl6+GgV/d/85tFltOFfZhFtf24dtK1KQ2M285MqO9aPjw7pfwqrdasPeM/b4/2c/leI3V4/v9t+IzI4CZOY2K5785CjeuGcmaptbcctr2ThzoRHF1c1YfWWyNL96Qqz9vX/tlBi8svM0imuace9bB6FVC2i32nDdJbG4vmMONgNCA7Q4D/vfo5tnyJNK4cE6/PKKUdiQmYdf/+MnvPldAYYF+mHvmUroNALMbVbkldXjQr0ZkSGd/w40W9plnd4D+VVYlpLY5dwv7ziFrGNlyDpWhv/bX4infjYRU+NDe9Xuz38qRZOlHXHDAlBU3Yx6cxvqmttkXxQwxhhjlCCokD4xGn/bdw6ZR0y4Ypxyf8AXvL23AJWNFiSGB+K/pg+dJcZcGrGeM2cO8vLyZI+dPHkSiYn2Dy5JSUmIjo7Gjh07pJ/X1dVh//79SE1NHYDmMsZ8WbOlHf/+wf6FTHiQFsU1zbh5a7bTSK/VasM72QWYt+FrXPnCNzhY4Hx0UnS0pBZ1LfYv6kpqW/DD+RrFfcvrW/D9uWoAgEZQYceJcnyRW4pV7x7CmQv2Lzbe3luAltZ2qSL4hBj7F13hwTpkrpmHFfOSoNMIsLRbYdTr8PvrJ7p2M3xcaEdHdER4IGaO6FqP4L45Sbh6cjQElT3FsPdMJTSCClvunIbxHekAcfRa9OVRExrMbfBT278wOZBf1eVLLZvNhuwz9uf5qVX48XwNbnz1O7z5bX6v2v1hjj1VdUdKAsKD7F+qFdV0frFXUNGIw928txhjjA1NSzqqg28/ZkJbu28OjgD2pTRf23UGAPBQ2hj4qV1e3dlruXSlDz30EPbt24dnn30Wp0+fxrZt2/D6669j1apVAOwjdGvWrMEzzzyDTz75BLm5ubjrrrsQGxuLG264YTDazxjzIV8cKUW9uQ1xwwLwxYPzMMYYjPJ6M1Zv+0H2S6iougl3/GUf1v37KJos7Whtt+GBbT+gssGe7rC0WfHJjyU4V9mZxvjOIXr1uZPK3aLtR8tgswFT40OxYr59zcXVf/8B356uQKBWjYhgHSoaLPi/fedQ0HGO8TGdyY2IYB1+e80E7HnsCjx+zXi8+4sUaYkpZhc3zJ4wuHlGvNPkgL+fGq8um47vH78KG/5rCm6YGostd07HleOMmDMqHAC6LHX1j44Y+H1zk6ARVCitbelSXCyvrB6VjRYE+Knx9SMLcP3UWNhswNOfHsOL2/O6jXWfvdCAgwXVEFTA0mlxiBtmT72I57DZbLjzjf248dXvkHOu+y96GGOMDS2zksIwLNAP1U2tONDDYIA3+/Pus6hracMYYzCuuyS25yf4EJei4DNnzsTHH3+MtWvX4umnn0ZSUhI2btyIZcuWSfs8+uijaGxsxMqVK1FTU4O5c+ciMzNTsaq2kuDgYAiCIIsp0yrTNH5LKzeHh4dL2zRiCwBBQZ1xUqVoN53jTfenkXQa96Xto7FwGuWmkV0a9aVRacfzUTSyTCPO9LpptJvGpWk76D703tDrofFyuo/j66d0z2hb6T2jbaLTBE6fPu20rfQ+0WPSqDptd2hoqKx9ND5P20HROHtxcbG0LSYwHNtEz11dXe303PT1UXpNAHnMXmm6A32cvtZim6xWKy5c8K1lG97vKAp1y4x4ROn98e4vZiPtxV04XlqHd7LP4b65SahpsuCOP+9HYVUTAvzUeHjRGGw7UIizFxrx0Ac/Yu2Sccj44EccL61DYnggdj68AGpBJcXALxsVjr1nKvF5rj0OLjhZU/rLo/Zii4snReOu1ER8crgExTXNUKmATbddioLKRjzz2XG8mHUSNhtg1OsQHtx1SktUiD9+MW/kIN4x7/XQVcmYkTgM10/t/pduWJAWt8yIxy0kLn7Z6HD85dt87D3T+WVJSU0zvut4je9MScTB/CocKqzBgfwq2TQB8QuWmUlhiBsWiI23TsWoyGC8mHUSm3aeRkltC5alJGDycAM0Dt+yf3Xc/jtoXnIkjHp/xA0LxI9FtVLH+kK9Wdr+w2fH8c/7LxuUquSMMca8j0Yt4KoJRnzwfREyj5i6rHrhCyoazHjzO3sCLOOqsVA7+Yzly1wem7/22muRm5uLlpYWHD9+XFpqS6RSqfD000/DZDKhpaUFX331FcaMGTNgDWaM+Y6PDhXhXz8Uo91qQ35FI/bnV0GlgjQfJzJEh8cWjwMAvJh1EiU1zXjg7z+gsKoJ8WEByFwzD7+YNxKvLpsGfz8Bu09ewNWb9uB4x7znc5VN+CbPXoFTjIqvXTIeQVq1Yhy8pskiRYUXT4xGoFaDPy6djGi9P35//SSkTTDitlkJCPHXoKmjcrlYuIz1XlSIP5ZOj+vSee2NWUnhUAsqFFY1SYXlPv6hGDYbMHtkGOLDAjEzyV6d/YBDATNxlFsc9VapVPjVwmT8/oZJUKnso943vroXl/4+C89+flz23J+KajvObz9254i1vQ0nTJ21KA4V1uCLI85Xw2CMMTY0Le6Ig3951ORy8UxvsOWbM2iytGNKnAHpE409P8HHDJ3QO2PMozSa2/CHz45jzfuHseTl3fjDZ8cAAPOTI6X1nwHgtpnxuCQ+FA3mNvzsT99iz6kKBPip8frPZ0hFzcZF6/H0zyYBAGw2YOG4KNzc0Tl/e28BDp2rQUurFZEhOkwarsdVE+z/2NMlsURfHS9Hm9WGcdEhGBFhP/685Ejs+81C3DnbnmYI1mlkS0eIhcvYxRGs0+CSOHu6JvtMJWqaLPhbtn097KXT7K97itixJnG7tnarVCl8zmj5SMHPZyfirXtmIn2iEXp/Depb2vD67rMor+sstnik2N6xntJx7uEOUfC8jo61OMf7j1+cgKXNd+fRMcYYc82c0REI1mlQVmfG4aIadzdnQJXWNuNv++y/ix9eNHZIJrY8dqXuiooKqFQqWcyWxmQpug+trO34gtLYNo3s0gg2PZZS9WoaIab70Pgxje7SOXs0HhwWFiZrH92Pto/GomlbncWDHdtH1w+nVaZpVWoaqabto5XAaRVsx3PQquA08kzbSttHI/30NaJtolXOafVvei5K6b0ByO8rjbTTc9Dj0teRRq1pVfDhwzurO5eXl0vb9L7Q66GvIQBUVXV+2Kfno9dB2023xX3oa+WNBJUK981Nwmu7zuBkWQNOltnf87fNlFeIFgQV/nDDJPzsT9+iosH+nn/u5ilSASvRzTPioNUI0GoELJkUjfNVzfjHoSLsOVUBfYD9tbhsVDhUKhWunhyDfx0uwee5pfitQxxcrAYufqus5N7LkvDmt/lobbdJhcvYxXPZqAgcKqzBd2cqsP1YGUx1LRgRHohrp9ij5dMTw6BSAfkVjSiva0GU3h8/FtWiwdwGQ4Bfl/cPACwYG4UFY6PQbrXhmk17cMJUj+/PVePqyTGoa2lFQaV9ZHpSrP31Fkesizs61uKI9X1zk/DRoWIUVjXhb/vOYfncpEG/H4wxxjyfTqPGleOi8MmPJcg8YsK0hK7FO73VKztPw9JmxawRYZif7Hsx997gEWvGmFsEaNVYdcVo7HnsSjxw5WgEadVIjgrGwvFdo0OThhukucqrrhgldZ4olUqFGy4djqsnx0ClUiEhPBALO5az+KyjUNmcjvlM88dEIlinQWltC+55+yD2nqnAucpGPPflCew+aY8K99Sxjjb443+WjMeCsZFYMDay233ZwLtstD3K/Z8fS/DV8TJo1QL+dMc0BGjtX2IZAvwwPtreeRZHrbM75mCnjgzvdt6XWlBh5gj7F5/fF9jrKYij1XHDAjCsoxq4WIBNjILnldm/rLs0fhgevso+BWrTjlOobZLXWGCMMTZ0iZ8vMo+Yui2Y6U0KK5vwQUednEfSh+ZoNeDBI9aMsaHBEOCHhxeNxQNXJsMGG7Qa59/3rV0yDstSErpd09rR3ZeNwFfHOxMFYmfM30+NNWnJePbz49h98gJ2n5QXgZszOhxjjc7TEdTyuUk8Gukm0xKGQasRpKj1b68Zj0nD5cmBWUlhOFZahwP5Vbh2SqxUuGzO6PAux3M0Y8Qw/G3fOeQUyjvWk8k5hndMWahraUNNkwWnOlIXY6NDkBAWiL9mn8PEWD3afHTNecYYY667fEwkdBoBhVVNOF5a7xPTyTZ+dRJtVhvmj4mU6pAMRR7bsdbr9RAEQRYDptFdGuml1bX1+s43J41+A8pxbhpzptWelWLDNDpN474UjffSb21ofJu21fG4NIZNK6DTStFKsePKykqn+9B4OUWvn94jWh2bRpcBeVVwen30mmgVbVoZnV4nreJO26dUCdxo7BzNpO12jKrTmDSNYdP96L2h3xjS9wCNfyvF0+nrQyup0+M7xv5pRJ+2j94n+nx6P8T3htXHPqwrdahFKpXKpU41YB+hHhkZhLMXGpEYHiiNMALAL+aNxFUTjPjLnnx8mHMe5jYr5iVH4raZ8Ugbbxyy37Z6C38/NVKSwrDnVAXSJxpxV2pil31SksLw9t4C/COnCBpBkDrJl43uOaI2PdEezztaXItmSztyi+1//2nnPUinQViQFlWNFnx3uhLmNiv8/QQkhAVCLajw8S8vg7+f2unxGWOMDU1BOg0uHxOJ7cfKkHmk1Os71qfK6vHxYfvqOo8sGtoFqz22Y80YY/0lCCr89+Wj8Og/fsKSSTFdfp4YHoTf3zAJjy4ei9Z2G8KCeK1pb/LEdROx/ZgJP5+d6PSLkAVjozA1PhSHz9dIy38Y9TqMjOj5C5rhoQEw6nUoqzPjx6IapyPW4n5VjRbsOGGvHTHGGCLFzLlTzRhjzJnFk6LtHeujJmQsGuvu5vSLuPRo+kQjpsSFurs5bsUda8aYT7tlRjymJYQiIUy5MxXi7zx5wjzb6KhgjI4arfjzAK0aH91/GXaduoC3vivA7pMXcPP0+F6lEVQqFWYkhuGz3FJ8nVeO/Ap7AsqxYx03LAC5xbX4Js8+naA3UwgYY4wNbQvHGaERVDhZ1oDbXs9GUkQwRkYEYUREEJIiAhEfFgidxvO/nD1SXIsvjpigUtkrgQ91Htux1ul0EARBFsulMWqlGC+tSk1jw4A8pkuj1rRiNY1U09g1jSnTODGtIk4jzjSmS2PDNCpdUVEhax+tok2vj7aPHpduK103jS/Tfeg9ozFjev3FxcXStuMHUVoVm94nWkVbqSo2jWnTuD69f/Se0efSCDrd3xF9Pm0HjZXTSuC0ujutnk7PQV87+n6gr5VShW/HquVRUVHSNn0v0teC3if6Oor3wFcKXlwMo6O4szNUCYIKV4yNwhVjo2Bua4fWhXWzpycOw2e5pXi/oyDL8NDOwmUisTJ4VaP999PYaH6vMcYY654h0A/pE6PxWW4p9p2twr6z8imXggqIDQ1AUkQQRoR3drhHhAchPiwQfi78LhtML2zPAwBcf0ksxvAXy57bsWaMMcYGkqvf/ovzrGs6qno7jlYDkM3bB+xrqjPGGGM9efm2qbhvbhIKKhpRUNmIsxWN9u2KRjRa2lFU3Yyi6mbsOSUfiFMLKsQNC8CI8KCOjncgEiOCkBQehLhhAdBcpE53zrkqfJ13AWpBhTVpQ3tutcjjOtbiKJw4GktHZekIndLILd12XOdX6Vh0v94cV6kdrrbPccSxN89x9bqVClzRx+lodHfto+g5lM6ndFylbVf3pxwfH6j75Ooxld4D3b0XXd0Wz+H438GwefNmPPfcczCZTLjkkkvwyiuvYNasWYN2PsY8yYRYPQL81Ghutf/9nRzXtWMtVgYXjYkO7rIPY4wx5kijFjA9cZj0Ja7IZrPhQoMZBRVNUqe7oLIR+R3/39zajnOVTThX2YRdDquaaAQV4sMCMSI8sGOUO0jqgMeGBnS71KQrbDYbnvvSPlp98/Q4jOhF7ZKhwOM61mIstqCgoNv9lCpcU6WlpQPRpG7RaHJ/0ZgyRePVnoJG9AeDY0x+MNDq6f3hWDFdRN+jg3k99fX1MBi6fuDvr/fffx8ZGRnYunUrUlJSsHHjRqSnpyMvL08WZWfMV/mpBVwSb5Aieo7LeQFAXFhnxzosSIvIYF2XfRhjjLHeUqlUiArxR1SIf5elq2w2G8rrzcjvGNnOrxRHuZtQUNkIc5sV+RWN9rogefL+g1YtICE8sKOj3dHx7oiZR+v9IbjQ6f7udCX2na2CVi3ggYXJA3LdvsDjOtaxsbE4f/48bDYbEhIScP78+S7LUg22uro6xMfHX/Rzu+u87jz3ULzmgTq3zWZDfX09YmNjB7h1di+++CJWrFiBe++9FwCwdetWfPbZZ3jzzTfxP//zP4NyTsY8zfTEYVLH2lkUnI5YjzWG8DJtjDHGBo1KpYJR7w+j3h+zR4bLfma12mCqa5E63PkXxJHuRpyvaoal3YrT5Q04Xd51cFKnETrmcgdKc7rFkW6jXif73Waz2fBcx9zqO1ISuiS3hjKP61gLgoC4uDipWJNer7/onR6Ru87N18zn7q3BGKkG7IUCc3JysHbtWukxQRCQlpaG7Oxsp88xm82y4m204Bpj3mpWUjg2f30G8WEBTpdjC/H3Q2igH2qaWrlwGWOMMbcRBBViQwMQGxqAy0ZHyH7WbrWhpKbZHiuv6IiVd2wXVjXB3GZFXlk98srquxw3wE+NxPBAe6w8IggqAD+er0GAnxqrrlBemWMo8riONWPM/SoqKtDe3t6lsr7RaMSJEyecPmf9+vV46qmnLkbzGLto5idH4HfXTsAUJ/OrRXHDAlDT1Ipx3LFmjDHmgdQdc6/jwwIxLzlS9rO2diuKa5qleHlBZZN9u7IRRdXNaG5txwlTPU6Y5J3ue+aMQGQIT3+iuGPNGBsQa9euRUZGhvT/YtydMW+mUqmwfG5St/usnD8KHx0qwuJJ0RepVYwxxtjA0KgFJIYHITE8CHBYitrSZkVRdZOseFpBZSN0GgH/ffko9zTYg3lsx1qn0+GJJ56QrUfs6+fma764huq5eyMiIgJqtRplZWWyx8vKyhAd7bzzoNPpPPZ6GBtMP7skFj+7ZHBqHTDGGGPuotUIGBkZjJGRvOJFb6hsg7lWD2PMa6WkpGDWrFl45ZVXANiX/EpISMDq1at7Vbysrq4OBoMBtbW1bpvDzpin478njLGLgf+tYaxn/f174rEj1owx98rIyMDdd9+NGTNmYNasWdi4cSMaGxulKuGMMcYYY4wxO+5YM8acuvXWW3HhwgWsW7cOJpMJU6dORWZmZpeCZowxxhhjjA113LFmjClavXo1Vq9e7e5mMMYYY4wx5tEEdzeAMcYYY4wxxhjzZtyxZowxxhhjjDHG+oE71owxxhhjjDHGWD/wHGvG2KAQV/Krq6tzc0sY81zi3w9e+ZIxNpj4dzJjPevv72TuWDPGBkV9fT0AID4+3s0tYczz1dfXw2AwuLsZjDEfxb+TGeu9vv5OVtn4a3LG2CCwWq0oKSlBSEgIVCqV033q6uoQHx+P8+fPQ6/XX+QWXhy+fo2+fn3A4F6jzWZDfX09YmNjIQg8O4sxNjj4d7Ln4ft9cfXmfvf3dzKPWDPGBoUgCIiLi+vVvnq93ud/qfj6Nfr69QGDd408Us0YG2z8O9lz8f2+uHq63/35ncxfjzPGGGOMMcYYY/3AHWvGGGOMMcYYY6wfuGPNGHMbnU6HJ554Ajqdzt1NGTS+fo2+fn3A0LhGxhjjf+suLr7fF9fFuN9cvIwxxhhjjDHGGOsHHrFmjDHGGGOMMcb6gTvWjDHGGGOMMcZYP3DHmjHGGGOMMcYY6wfuWDPGGGOMMcYYY/3AHWvGmNts3rwZI0aMgL+/P1JSUnDgwAF3N6lP1q9fj5kzZyIkJARRUVG44YYbkJeXJ9unpaUFq1atQnh4OIKDg7F06VKUlZW5qcX988c//hEqlQpr1qyRHvOF6ysuLsadd96J8PBwBAQEYPLkyfj++++ln9tsNqxbtw4xMTEICAhAWloaTp065cYWM8bYwPGV38merjefGdjgcPb5ZSBxx5ox5hbvv/8+MjIy8MQTT+DQoUO45JJLkJ6ejvLycnc3zWW7du3CqlWrsG/fPmRlZaG1tRWLFi1CY2OjtM9DDz2E//znP/jwww+xa9culJSU4KabbnJjq/vm4MGDeO211zBlyhTZ495+fdXV1ZgzZw78/PzwxRdf4NixY3jhhRcwbNgwaZ8NGzZg06ZN2Lp1K/bv34+goCCkp6ejpaXFjS1njLH+86XfyZ6uN58Z2MBT+vwyoGyMMeYGs2bNsq1atUr6//b2dltsbKxt/fr1bmzVwCgvL7cBsO3atctms9lsNTU1Nj8/P9uHH34o7XP8+HEbAFt2dra7mumy+vp6W3Jysi0rK8t2+eWX2x588EGbzeYb1/fYY4/Z5s6dq/hzq9Vqi46Otj333HPSYzU1NTadTmf7+9//fjGayBhjg8aXfyd7OsfPDGzgKX1+GWg8Ys0Yu+gsFgtycnKQlpYmPSYIAtLS0pCdne3Glg2M2tpaAEBYWBgAICcnB62trbLrHTduHBISErzqeletWoVrrrlGdh2Ab1zfJ598ghkzZuDmm29GVFQULr30Uvz5z3+Wfp6fnw+TySS7RoPBgJSUFK+5RsYYc8bXfyd7OsfPDGzgKX1+GWiaQT06Y4w5UVFRgfb2dhiNRtnjRqMRJ06ccFOrBobVasWaNWswZ84cTJo0CQBgMpmg1WoRGhoq29doNMJkMrmhla577733cOjQIRw8eLDLz3zh+s6ePYstW7YgIyMDv/nNb3Dw4EH86le/glarxd133y1dh7P3rLdcI2OMOePLv5M9nbPPDGxgdff5ZaBxx5oxxgbQqlWrcOTIEXz77bfubsqAOX/+PB588EFkZWXB39/f3c0ZFFarFTNmzMCzzz4LALj00ktx5MgRbN26FXfffbebW8cYY8wX+eJnBk9ysT+/cBScMXbRRUREQK1Wd6kaXVZWhujoaDe1qv9Wr16NTz/9FF9//TXi4uKkx6Ojo2GxWFBTUyPb31uuNycnB+Xl5Zg2bRo0Gg00Gg127dqFTZs2QaPRwGg0evX1AUBMTAwmTJgge2z8+PEoLCwEAOk6fO09yxhjvvo72dMpfWZgA6enzy/t7e0Dej7uWDPGLjqtVovp06djx44d0mNWqxU7duxAamqqG1vWNzabDatXr8bHH3+MnTt3IikpSfbz6dOnw8/PT3a9eXl5KCws9IrrXbhwIXJzc3H48GHpz4wZM7Bs2TJp25uvDwDmzJnTZbmTkydPIjExEQCQlJSE6Oho2TXW1dVh//79XnONjDHmjK/9TvZ0PX1mYAOnp88varV6QM/HUXDGmFtkZGTg7rvvxowZMzBr1ixs3LgRjY2NuPfee93dNJetWrUK27Ztw7///W+EhIRIc24NBgMCAgJgMBiwfPlyZGRkICwsDHq9Hg888ABSU1Mxe/ZsN7e+ZyEhIV3mfgUFBSE8PFx63JuvD7AvF3bZZZfh2WefxS233IIDBw7g9ddfx+uvvw4A0rqXzzzzDJKTk5GUlITf/e53iI2NxQ033ODexjPGWD/50u9kT9fTZwY2cHrz+WUgcceaMeYWt956Ky5cuIB169bBZDJh6tSpyMzM7FI8xRts2bIFALBgwQLZ42+99RbuueceAMBLL70EQRCwdOlSmM1mpKen49VXX73ILR083n59M2fOxMcff4y1a9fi6aefRlJSEjZu3Ihly5ZJ+zz66KNobGzEypUrUVNTg7lz5yIzM9Nn550zxoYOX/qd7Ol685mBeSeVzWazubsRjDHGGGOMMcaYt+I51owxxhhjjDHGWD9wx5oxxhhjjDHGGOsH7lgzxhhjjDHGGGP9wB1rxhhjjDHGGGOsH7hjzRhjjDHGGGOM9QN3rBljjDHGGGOMsX7gjjVjjDHGGGOMMdYP3LFmjDHGGGOMMcb6gTvWjDHGGGOMMcZYP3DHmjHGGGOMMcYY6wfuWDPGGGOMMcYYY/3AHWvGGGOMMcYYY6wf/j9BLwQiJy/M2gAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -169,7 +202,7 @@ }, { "cell_type": "code", - "execution_count": 160, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -191,6 +224,8 @@ " # print a warning, saying that the planes are not evenly distributed\n", " print(\"Warning: the planes are not evenly distributed. Use even separation for even number of planes.\")\n", "\n", + " # TODO: check the shift of the planes, is almost perfect, but maybe not\n", + "\n", " for p in range(num_planes):\n", " for m in range(magnification_z):\n", " z_section[planes[p]-m, :, :] = rgc_img[p*magnification_z+m, :, :]\n", @@ -200,11 +235,11 @@ }, { "cell_type": "code", - "execution_count": 161, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "separation_planes = 3\n", + "separation_planes = 4\n", "\n", "rgc_img_Z = render_z(rgc_img, separation_planes, magnification_z)\n", "img_Z = render_z(img, separation_planes, 1)" @@ -212,20 +247,20 @@ }, { "cell_type": "code", - "execution_count": 162, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[1.98 1.98]\n", + "[2.04]\n", "[]\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -276,8 +311,8 @@ "print((peaks_indices_XZ[1:] - peaks_indices_XZ[:-1]) * pixel_size*separation_planes/magnification_z)\n", "\n", "# write the distance between peaks the second and forth plot\n", - "ax[0,1].set_title(\"Full Raw XZ subsampled \\n right dimensions PSF \\n (Peaks distance: {}nm)\".format((peaks_indices_XY[1:] - peaks_indices_XY[:-1]) * pixel_size/magnification_z))\n", - "ax[0,3].set_title(\"Full Raw XZ intensity \\n at the center \\n (Peaks distance: {}nm)\".format((peaks_indices_XZ[1:] - peaks_indices_XZ[:-1]) * pixel_size*separation_planes/magnification_z))\n", + "ax[0,1].set_title(\"Full Raw XZ subsampled \\n right dimensions PSF \\n (Peaks distance: {}um)\".format((peaks_indices_XY[1:] - peaks_indices_XY[:-1]) * pixel_size/magnification_z))\n", + "ax[0,3].set_title(\"Full Raw XZ intensity \\n at the center \\n (Peaks distance: {}um)\".format((peaks_indices_XZ[1:] - peaks_indices_XZ[:-1]) * pixel_size*separation_planes/magnification_z))\n", "\n", "\n", "# elliminate ticks\n", @@ -288,22 +323,6 @@ "\n", "fig.tight_layout()\n" ] - }, - { - "cell_type": "code", - "execution_count": 163, - "metadata": {}, - "outputs": [], - "source": [ - "from scipy.signal import find_peaks\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 4e0f3c01eade75f121f79cf4eb2e02f5992d4d20 Mon Sep 17 00:00:00 2001 From: agvesga <72971822+agvesga@users.noreply.github.com> Date: Fri, 22 Mar 2024 15:43:33 +0000 Subject: [PATCH 81/81] clean working version --- .../_c_sr_radial_gradient_convergence.c | 13 +--- src/nanopyx/core/transform/_le_esrrf3d.pyx | 62 +------------------ .../transform/sr_temporal_correlations.py | 3 +- 3 files changed, 4 insertions(+), 74 deletions(-) diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index da63467f..af141bc5 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -144,24 +144,15 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn dx = vx - xc; dy = vy - yc; dz = vz - zc; - dz_real = dz * ratio_px; // This has been already divigy by magnification_z + dz_real = dz * ratio_px; // This has been already divided by magnification_z distance = sqrt(dx * dx + dy * dy + dz_real * dz_real); distance_xy = sqrt(dx * dx + dy * dy); distance_z = dz_real; - // if (distance != 0 && distance <= tSO ) { if (distance != 0 && distance_xy <= tSO && distance_z <= tSO_z) { - - // Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, Gx_Gy_MAGNIFICATION * magnification_xy * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - // Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - // Gz = _c_get_bound_value(imIntGz, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, magnification_xy * vz * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); Gz = _c_get_bound_value(imIntGz, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); - // Gx = imIntGx[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; - // Gy = imIntGy[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; - // Gz = imIntGz[(int)(vz * magnification_z * Gz_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION * rowsM * Gx_Gy_MAGNIFICATION) + (int)(vy * magnification_xy * Gx_Gy_MAGNIFICATION * colsM * Gx_Gy_MAGNIFICATION) + (int)(vx * magnification_xy * Gx_Gy_MAGNIFICATION)]; // distanceWeight = _c_calculate_dw3D_isotropic(distance, tSS); distanceWeight = _c_calculate_dw3D(distance, distance_xy, distance_z, tSS, tSS_z); @@ -176,8 +167,6 @@ float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIn if (GdotR < 0) { Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz_real, distance); - // RGC += Dk * (distanceWeightSum_xy + distanceWeightSum_z) / 2; - // RGC += (Dk * distanceWeightSum); // test RGC += (Dk * distanceWeight); } } diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx index 63b2312a..77ffffd4 100644 --- a/src/nanopyx/core/transform/_le_esrrf3d.pyx +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -56,8 +56,6 @@ class eSRRF3D(LiquidEngine): cdef float fwhm = radius cdef float tSS = 2 * sigma * sigma cdef float tSO = 2 * sigma + 1 - # cdef float sigma_z = radius_z / 2.355 # Old version - # cdef float fwhm_z = radius_z cdef float sigma_z = radius * ratio_px / 2.355 # Taking voxel size into account cdef float fwhm_z = radius * ratio_px cdef float tSS_z = 2 * sigma_z * sigma_z @@ -79,8 +77,6 @@ class eSRRF3D(LiquidEngine): cdef float rgc_val, zcof for f in range(n_frames): - - # image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] @@ -89,16 +85,11 @@ class eSRRF3D(LiquidEngine): gradients_s = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) img_dum = interpolator.run(image[f], 0, 0, Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) - # img_dum = interpolate_3d(image[f], Gx_Gy_MAGNIFICATION, _magnification_z) n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum = img_dum.shape[0], img_dum.shape[1], img_dum.shape[2] with nogil: _c_gradient_3d(&img_dum[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices, n_rows_mag_dum, n_cols_mag_dum) - # gradients_s_interpolated = interpolator.run(gradients_s, 0, 0, _magnification_xy, _magnification_xy) - # gradients_r_interpolated = interpolator.run(gradients_r, 0, 0, _magnification_xy, _magnification_xy) - # gradients_c_interpolated = interpolator.run(gradients_c, 0, 0, _magnification_xy, _magnification_xy) - gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy, _magnification_z) gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy, _magnification_z) gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy, _magnification_z) @@ -117,39 +108,20 @@ class eSRRF3D(LiquidEngine): for cM in range(0, n_cols_mag): if _doIntensityWeighting: rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - # zcof = (sM) / _magnification_z - # if (zcof < 0): - # z0 = 0 - # elif (zcof >= n_slices-1): - # z0 = n_slices-1 - # else: - # z0 = floor(zcof) - # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val * image_interpolated[sM, rM, cM] else: rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - # zcof = (sM) / _magnification_z - # if (zcof < 0): - # z0 = 0 - # elif (zcof >= n_slices-1): - # z0 = n_slices-1 - # else: - # z0 = floor(zcof) - # z0 = z0 * _magnification_z + rgc_map[f, sM, rM, cM] = rgc_val return np.asarray(rgc_map) def _run_threaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, ratio_px: float = 4.0, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Threaded"): - interpolator = ShiftAndMagnify() - cdef float sigma = radius / 2.355 cdef float fwhm = radius cdef float tSS = 2 * sigma * sigma cdef float tSO = 2 * sigma + 1 - # cdef float sigma_z = radius_z / 2.355 # Old version - # cdef float fwhm_z = radius_z cdef float sigma_z = radius * ratio_px / 2.355 # Taking voxel size into account cdef float fwhm_z = radius * ratio_px cdef float tSS_z = 2 * sigma_z * sigma_z @@ -171,17 +143,11 @@ class eSRRF3D(LiquidEngine): cdef float rgc_val, zcof for f in range(n_frames): - # image_interpolated = interpolator.run(image[f], 0, 0, _magnification_xy, _magnification_xy) - - # image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) image_interpolated = interpolate_3d_zlinear(image[f,:,:,:], _magnification_xy, _magnification_z) n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] - # img_dum = interpolator.run(image[f], 0, 0, Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) - # img_dum = interpolate_3d(image[f], Gx_Gy_MAGNIFICATION, _magnification_z) img_dum = interpolate_3d_zlinear(image[f], Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) - n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum = img_dum.shape[0], img_dum.shape[1], img_dum.shape[2] gradients_c = np.zeros((n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum), dtype=np.float32) @@ -190,14 +156,6 @@ class eSRRF3D(LiquidEngine): with nogil: _c_gradient_3d(&img_dum[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum) - # gradients_s_interpolated = interpolator.run(gradients_s, 0, 0, _magnification_xy, _magnification_xy) - # gradients_r_interpolated = interpolator.run(gradients_r, 0, 0, _magnification_xy, _magnification_xy) - # gradients_c_interpolated = interpolator.run(gradients_c, 0, 0, _magnification_xy, _magnification_xy) - - # gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy, _magnification_z) - # gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy, _magnification_z) - # gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy, _magnification_z) - gradients_s_interpolated = interpolate_3d_zlinear(gradients_s, _magnification_xy, _magnification_z) gradients_r_interpolated = interpolate_3d_zlinear(gradients_r, _magnification_xy, _magnification_z) gradients_c_interpolated = interpolate_3d_zlinear(gradients_c, _magnification_xy, _magnification_z) @@ -216,28 +174,12 @@ class eSRRF3D(LiquidEngine): for cM in range(0, n_cols_mag): if _doIntensityWeighting: rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - # zcof = (sM) / _magnification_z - # if (zcof < 0): - # z0 = 0 - # elif (zcof >= n_slices-1): - # z0 = n_slices-1 - # else: - # z0 = floor(zcof) - # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val * image_interpolated[sM, rM, cM] else: rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) - # zcof = (sM) / _magnification_z - # if (zcof < 0): - # z0 = 0 - # elif (zcof >= n_slices-1): - # z0 = n_slices-1 - # else: - # z0 = floor(zcof) - # z0 = z0 * _magnification_z rgc_map[f, sM, rM, cM] = rgc_val - return np.asarray(rgc_map) #, np.asarray(gradients_s_interpolated), np.asarray(gradients_r_interpolated), np.asarray(image_interpolated) # debug + return np.asarray(rgc_map) def get_gradients(self): if self._gradients_c_interpolated is None or self._gradients_r_interpolated is None or self._gradients_s_interpolated is None: diff --git a/src/nanopyx/core/transform/sr_temporal_correlations.py b/src/nanopyx/core/transform/sr_temporal_correlations.py index f33785a0..f6560407 100644 --- a/src/nanopyx/core/transform/sr_temporal_correlations.py +++ b/src/nanopyx/core/transform/sr_temporal_correlations.py @@ -229,7 +229,7 @@ def calculate_eSRRF3d_temporal_correlations(rgc_map, correlation: str = "AVG", f return rgc_map else: - if framewindow != 0: + if framewindow > 0: if rollingoverlap: n_windows = int((n_frames - framewindow) / rollingoverlap) + 1 else: @@ -243,7 +243,6 @@ def calculate_eSRRF3d_temporal_correlations(rgc_map, correlation: str = "AVG", f for w in range(n_windows): start_frame = w * (int(framewindow) - int(rollingoverlap)) end_frame = start_frame + int(framewindow) - # do average in the first dimension of rgc_map[start_frame:end_frame ,:,:,:] with numpy avg_rgc_map[w,:,:,:] = calculate_eSRRF_temporal_correlations(rgc_map[start_frame:end_frame,:,:,:], correlation) return avg_rgc_map \ No newline at end of file