From 60036052411eba4b68eea8e15e2751ddac16689e Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 12:42:12 +0100 Subject: [PATCH 01/27] added affine_transform (3D) --- docs/release_notes.md | 1 + pyclesperanto_prototype/__init__.py | 1 + .../_tier8/_AffineTransform3D.py | 87 ++++++++++++ pyclesperanto_prototype/_tier8/__init__.py | 2 + .../_tier8/_affine_transform.py | 49 +++++++ setup.py | 2 +- tests/test_affine_transform.py | 126 ++++++++++++++++++ 7 files changed, 267 insertions(+), 1 deletion(-) create mode 100644 pyclesperanto_prototype/_tier8/_AffineTransform3D.py create mode 100644 pyclesperanto_prototype/_tier8/__init__.py create mode 100644 pyclesperanto_prototype/_tier8/_affine_transform.py create mode 100644 tests/test_affine_transform.py diff --git a/docs/release_notes.md b/docs/release_notes.md index a7809cac..6c76f092 100644 --- a/docs/release_notes.md +++ b/docs/release_notes.md @@ -39,6 +39,7 @@ results of the GPU-accelerated statistics are dictionaries which contain the sam * `mode_of_proximal_neighbors_map` and alias `mode_of_distal_neighbors_map` * `standard_deviation_of_n_nearest_neighbors_map` * `standard_deviation_of_proximal_neighbors_map` and alias `standard_deviation_of_distal_neighbors_map` +* `affine_transform` (yet without shearing) ### Backwards compatibility breaking changes * `statistics_of_labelled_pixels` and `statistics_of_background_and_labelled_pixels` produce different output now. diff --git a/pyclesperanto_prototype/__init__.py b/pyclesperanto_prototype/__init__.py index 7ebcd0e0..c45284f0 100644 --- a/pyclesperanto_prototype/__init__.py +++ b/pyclesperanto_prototype/__init__.py @@ -4,6 +4,7 @@ from ._tier3 import * from ._tier4 import * from ._tier5 import * +from ._tier8 import * from ._tier9 import * __version__ = "0.6.0" diff --git a/pyclesperanto_prototype/_tier8/_AffineTransform3D.py b/pyclesperanto_prototype/_tier8/_AffineTransform3D.py new file mode 100644 index 00000000..860f3343 --- /dev/null +++ b/pyclesperanto_prototype/_tier8/_AffineTransform3D.py @@ -0,0 +1,87 @@ +import numpy as np +import transforms3d + +class AffineTransform3D: + """ + + Inspired by: https://github.com/imglib/imglib2-realtransform/blob/master/src/main/java/net/imglib2/realtransform/AffineTransform3D.java + + """ + + def __init__(self, transform_as_string : str = None): + self._matrix = transforms3d.zooms.zfdir2aff(1) + + + def scale(self, scale_x: float = None, scale_y: float = None, scale_z: float = None): + """ + Scaling the current affine transform matrix. + """ + if scale_x is not None: + self._concatenate(transforms3d.zooms.zfdir2aff(scale_x, direction=(1, 0, 0), origin=(0, 0, 0))) + if scale_y is not None: + self._concatenate(transforms3d.zooms.zfdir2aff(scale_y, direction=(0, 1, 0), origin=(0, 0, 0))) + if scale_z is not None: + self._concatenate(transforms3d.zooms.zfdir2aff(scale_z, direction=(0, 0, 1), origin=(0, 0, 0))) + + return self + + def rotate(self, axis : int = 2, angle_in_rad : float = 0): + """ + Rotation around a given axis (default: z-axis, meaning rotation in x-y-plane) + + Parameters + ---------- + axis + angle_in_rad + + Returns + ------- + + """ + if axis == 0: + self._concatenate(self._3x3_to_4x4(transforms3d.euler.euler2axangle(angle_in_rad, 0, 0))) + if axis == 1: + self._concatenate(self._3x3_to_4x4(transforms3d.euler.euler2axangle(0, angle_in_rad, 0))) + if axis == 2: + self._concatenate(self._3x3_to_4x4(transforms3d.euler.euler2mat(0, 0, angle_in_rad))) + + return self + + def translate(self, translate_x: float = 0, translate_y: float = 0, translate_z : float = 0): + self._concatenate(np.asarray([ + [1, 0, 0, translate_x], + [0, 1, 0, translate_y], + [0, 0, 1, translate_z], + [0, 0, 0, 1], + ])) + return self + + def shear(self): + raise NotImplementedError("Shearing has not been implemented yet. \n" + "See https://github.com/clEsperanto/pyclesperanto_prototype/issues/90") + + def _3x3_to_4x4(self, matrix): + # I bet there is an easier way to do this. + # But I don't know what to google for :D + # haesleinhuepf + return np.asarray([ + [matrix[0,0], matrix[0,1], matrix[0,2], 0], + [matrix[1,0], matrix[1,1], matrix[1,2], 0], + [matrix[2,0], matrix[2,1], matrix[2,2], 0], + [0, 0, 0, 1] + ]) + + def _concatenate(self, matrix): + self._matrix = np.matmul(matrix, self._matrix) + + def inverse(self): + self._matrix = np.linalg.inv(self._matrix) + return self + + def copy(self): + a_copy = AffineTransform3D() + a_copy._matrix = np.copy(self._matrix) + return a_copy + + def __array__(self): + return self._matrix diff --git a/pyclesperanto_prototype/_tier8/__init__.py b/pyclesperanto_prototype/_tier8/__init__.py new file mode 100644 index 00000000..c46f009b --- /dev/null +++ b/pyclesperanto_prototype/_tier8/__init__.py @@ -0,0 +1,2 @@ +from ._affine_transform import affine_transform +from ._AffineTransform3D import AffineTransform3D \ No newline at end of file diff --git a/pyclesperanto_prototype/_tier8/_affine_transform.py b/pyclesperanto_prototype/_tier8/_affine_transform.py new file mode 100644 index 00000000..4625848d --- /dev/null +++ b/pyclesperanto_prototype/_tier8/_affine_transform.py @@ -0,0 +1,49 @@ +from .._tier0 import plugin_function +from .._tier0 import Image +from .._tier0 import push_zyx +from ._AffineTransform3D import AffineTransform3D + +@plugin_function +def affine_transform(source : Image, destination : Image, transform : AffineTransform3D, linear_interpolation : bool = False): + """ + Applies an affine transform to an image. + + Parameters + ---------- + source + destination + transform + linear_interpolation + + Returns + ------- + + """ + import numpy as np + from .._tier0 import empty_image_like + from .._tier0 import execute + from .._tier1 import copy + + transform_matrix = np.asarray(transform.copy().inverse()) + + gpu_transform_matrix = push_zyx(transform_matrix) + + kernel_suffix = '' + if linear_interpolation: + image = empty_image_like(source) + copy(source, image) + source = image + kernel_suffix = '_interpolate' + + + parameters = { + "input": source, + "output": destination, + "mat": gpu_transform_matrix + } + + execute(__file__, '../clij-opencl-kernels/kernels/affine_transform_' + str(len(destination.shape)) + 'd' + kernel_suffix + '_x.cl', + 'affine_transform_' + str(len(destination.shape)) + 'd' + kernel_suffix, destination.shape, parameters) + + + return destination \ No newline at end of file diff --git a/setup.py b/setup.py index 9c170634..e36d93c7 100644 --- a/setup.py +++ b/setup.py @@ -14,7 +14,7 @@ url="https://github.com/clEsperanto/pyclesperanto_prototype", packages=setuptools.find_packages(), include_package_data=True, - install_requires=["numpy", "pyopencl", "toolz", "scikit-image>=0.18.0", "matplotlib"], + install_requires=["numpy", "pyopencl", "toolz", "scikit-image>=0.18.0", "matplotlib", "transforms3d"], python_requires='>=3.6', classifiers=[ "Programming Language :: Python :: 3", diff --git a/tests/test_affine_transform.py b/tests/test_affine_transform.py new file mode 100644 index 00000000..8b991c34 --- /dev/null +++ b/tests/test_affine_transform.py @@ -0,0 +1,126 @@ +import pyclesperanto_prototype as cle +import numpy as np + +def test_affine_transform_translate(): + source = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + reference = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 1, 1, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + transform = cle.AffineTransform3D() + transform.translate(-1, -1, 0) + + result = cle.affine_transform(source, transform=transform) + + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) + + print(a) + print(b) + + assert (np.array_equal(a, b)) + + +def test_affine_transform_scale(): + source = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + reference = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 1, 1, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 0, 0], + ]])) + + transform = cle.AffineTransform3D() + transform.scale(1, 2, 1) + + result = cle.affine_transform(source, transform=transform) + + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) + + print(a) + print(b) + + assert (np.array_equal(a, b)) + +def test_affine_transform_rotate(): + source = cle.push_zyx(np.asarray([[ + [0, 0, 0, 1, 1], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + reference = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 1, 0, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 0, 0], + ]])) + + transform = cle.AffineTransform3D() + transform.rotate(2, 45.0 * np.pi / 180.0) + + result = cle.affine_transform(source, transform=transform) + + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) + + print(a) + print(b) + + assert (np.array_equal(a, b)) + +def test_affine_transform_rotate_around_center(): + source = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 1, 1], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + reference = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 1, 0, 0], + [0, 0, 1, 0, 0], + ]])) + + transform = cle.AffineTransform3D() + transform.translate(-2.5, -2.5) + transform.rotate(2, 90.0 * np.pi / 180.0) + transform.translate(2.5, 2.5) + + result = cle.affine_transform(source, transform=transform) + + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) + + print(a) + print(b) + + assert (np.array_equal(a, b)) + From ea8498228cee79b45f657a46e47b8e9eb160508f Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 12:48:15 +0100 Subject: [PATCH 02/27] API fine tuning --- pyclesperanto_prototype/_tier8/_AffineTransform3D.py | 2 +- pyclesperanto_prototype/_tier8/_affine_transform.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pyclesperanto_prototype/_tier8/_AffineTransform3D.py b/pyclesperanto_prototype/_tier8/_AffineTransform3D.py index 860f3343..791458ea 100644 --- a/pyclesperanto_prototype/_tier8/_AffineTransform3D.py +++ b/pyclesperanto_prototype/_tier8/_AffineTransform3D.py @@ -8,7 +8,7 @@ class AffineTransform3D: """ - def __init__(self, transform_as_string : str = None): + def __init__(self): self._matrix = transforms3d.zooms.zfdir2aff(1) diff --git a/pyclesperanto_prototype/_tier8/_affine_transform.py b/pyclesperanto_prototype/_tier8/_affine_transform.py index 4625848d..1e1d06c4 100644 --- a/pyclesperanto_prototype/_tier8/_affine_transform.py +++ b/pyclesperanto_prototype/_tier8/_affine_transform.py @@ -4,7 +4,7 @@ from ._AffineTransform3D import AffineTransform3D @plugin_function -def affine_transform(source : Image, destination : Image, transform : AffineTransform3D, linear_interpolation : bool = False): +def affine_transform(source : Image, destination : Image = None, transform : AffineTransform3D = AffineTransform3D(), linear_interpolation : bool = False): """ Applies an affine transform to an image. From 49710ef9a9afc472396674766c7431d3cda58cba Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 12:54:02 +0100 Subject: [PATCH 03/27] enable passing a transform matrix --- pyclesperanto_prototype/_tier8/__init__.py | 5 ++- .../_tier8/_affine_transform.py | 11 ++++-- tests/test_affine_transform.py | 35 +++++++++++++++++++ 3 files changed, 48 insertions(+), 3 deletions(-) diff --git a/pyclesperanto_prototype/_tier8/__init__.py b/pyclesperanto_prototype/_tier8/__init__.py index c46f009b..4bcd7b39 100644 --- a/pyclesperanto_prototype/_tier8/__init__.py +++ b/pyclesperanto_prototype/_tier8/__init__.py @@ -1,2 +1,5 @@ from ._affine_transform import affine_transform -from ._AffineTransform3D import AffineTransform3D \ No newline at end of file +from ._AffineTransform3D import AffineTransform3D +from ._translate import translate + + diff --git a/pyclesperanto_prototype/_tier8/_affine_transform.py b/pyclesperanto_prototype/_tier8/_affine_transform.py index 1e1d06c4..e4900b4f 100644 --- a/pyclesperanto_prototype/_tier8/_affine_transform.py +++ b/pyclesperanto_prototype/_tier8/_affine_transform.py @@ -1,10 +1,13 @@ +from typing import Union + from .._tier0 import plugin_function from .._tier0 import Image from .._tier0 import push_zyx from ._AffineTransform3D import AffineTransform3D +import numpy as np @plugin_function -def affine_transform(source : Image, destination : Image = None, transform : AffineTransform3D = AffineTransform3D(), linear_interpolation : bool = False): +def affine_transform(source : Image, destination : Image = None, transform : Union[np.ndarray, AffineTransform3D] = None, linear_interpolation : bool = False): """ Applies an affine transform to an image. @@ -24,7 +27,11 @@ def affine_transform(source : Image, destination : Image = None, transform : Aff from .._tier0 import execute from .._tier1 import copy - transform_matrix = np.asarray(transform.copy().inverse()) + # we invert the transform because we go from the target image to the source image to read pixels + if isinstance(transform, AffineTransform3D): + transform_matrix = np.asarray(transform.copy().inverse()) + else: + transform_matrix = np.linalg.inv(transform) gpu_transform_matrix = push_zyx(transform_matrix) diff --git a/tests/test_affine_transform.py b/tests/test_affine_transform.py index 8b991c34..7c6eedbe 100644 --- a/tests/test_affine_transform.py +++ b/tests/test_affine_transform.py @@ -62,6 +62,41 @@ def test_affine_transform_scale(): assert (np.array_equal(a, b)) +def test_affine_transform_scale_with_transform_matrix(): + source = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + reference = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 1, 1, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 0, 0], + ]])) + + transform = np.asarray([ + [1, 0, 0, 0], + [0, 2, 0, 0], + [0, 0, 1, 0], + [0, 0, 0, 1], + ]) + + result = cle.affine_transform(source, transform=transform) + + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) + + print(a) + print(b) + + assert (np.array_equal(a, b)) + + def test_affine_transform_rotate(): source = cle.push_zyx(np.asarray([[ [0, 0, 0, 1, 1], From 22cbd2a5b035dd3292fb416d6eb55482ff0987cd Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 13:03:34 +0100 Subject: [PATCH 04/27] added comments --- .../_tier8/_AffineTransform3D.py | 62 ++++++++++++++++++- .../_tier8/_affine_transform.py | 13 ++-- 2 files changed, 68 insertions(+), 7 deletions(-) diff --git a/pyclesperanto_prototype/_tier8/_AffineTransform3D.py b/pyclesperanto_prototype/_tier8/_AffineTransform3D.py index 791458ea..6e304e6a 100644 --- a/pyclesperanto_prototype/_tier8/_AffineTransform3D.py +++ b/pyclesperanto_prototype/_tier8/_AffineTransform3D.py @@ -2,7 +2,11 @@ import transforms3d class AffineTransform3D: - """ + """This class is a convenience class to setup affine transform matrices. + When initialized, this object corresponds to a null transform. Afterwards, + you can append transforms, e.g. by calling `transform.translate(10, 20)`. + + The API aims to be compatible to Imglib2 AffineTransform3D. Inspired by: https://github.com/imglib/imglib2-realtransform/blob/master/src/main/java/net/imglib2/realtransform/AffineTransform3D.java @@ -15,6 +19,20 @@ def __init__(self): def scale(self, scale_x: float = None, scale_y: float = None, scale_z: float = None): """ Scaling the current affine transform matrix. + + Parameters + ---------- + scale_x : float + scaling along x axis + scale_y : float + scaling along y axis + scale_z : float + scaling along z axis + + Returns + ------- + self + """ if scale_x is not None: self._concatenate(transforms3d.zooms.zfdir2aff(scale_x, direction=(1, 0, 0), origin=(0, 0, 0))) @@ -31,11 +49,15 @@ def rotate(self, axis : int = 2, angle_in_rad : float = 0): Parameters ---------- - axis - angle_in_rad + axis : int + axis to rotate around (0=x, 1=y, 2=z) + angle_in_rad : int + angle in radians. To convert degrees to radians us this formula: + angle_in_rad = angle_in_deg * numpy.pi / 180.0 Returns ------- + self """ if axis == 0: @@ -48,6 +70,22 @@ def rotate(self, axis : int = 2, angle_in_rad : float = 0): return self def translate(self, translate_x: float = 0, translate_y: float = 0, translate_z : float = 0): + """Translation along axes. + + Parameters + ---------- + translate_x : float + translation along x-axis + translate_y : float + translation along y-axis + translate_z : float + translation along z-axis + + Returns + ------- + self + + """ self._concatenate(np.asarray([ [1, 0, 0, translate_x], [0, 1, 0, translate_y], @@ -75,10 +113,28 @@ def _concatenate(self, matrix): self._matrix = np.matmul(matrix, self._matrix) def inverse(self): + """Computes the inverse of the transformation. + + This can be useful, e.g. when you want to know the transformation + from image B to image A but you only know the transformation from + A to B. + + Returns + ------- + self + + """ self._matrix = np.linalg.inv(self._matrix) return self def copy(self): + """Makes a copy of the current transform which can then be + manipulated without changing the source. + + Returns + ------- + copy of the current transform + """ a_copy = AffineTransform3D() a_copy._matrix = np.copy(self._matrix) return a_copy diff --git a/pyclesperanto_prototype/_tier8/_affine_transform.py b/pyclesperanto_prototype/_tier8/_affine_transform.py index e4900b4f..f5d55089 100644 --- a/pyclesperanto_prototype/_tier8/_affine_transform.py +++ b/pyclesperanto_prototype/_tier8/_affine_transform.py @@ -13,13 +13,18 @@ def affine_transform(source : Image, destination : Image = None, transform : Uni Parameters ---------- - source - destination - transform - linear_interpolation + source : Image + image to be transformed + destination : Image, optional + image where the transformed image should be written to + transform : 4x4 numpy array or AffineTransform3D object + transform matrix or object describing the transformation + linear_interpolation: bool + not implemented yet Returns ------- + destination """ import numpy as np From 433b7b463f430b17887ae26c931bbd739aa81939 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 13:06:02 +0100 Subject: [PATCH 05/27] added translate --- docs/release_notes.md | 1 + pyclesperanto_prototype/_tier8/_translate.py | 12 ++++++++ tests/test_translate.py | 30 ++++++++++++++++++++ 3 files changed, 43 insertions(+) create mode 100644 pyclesperanto_prototype/_tier8/_translate.py create mode 100644 tests/test_translate.py diff --git a/docs/release_notes.md b/docs/release_notes.md index 6c76f092..7b29444c 100644 --- a/docs/release_notes.md +++ b/docs/release_notes.md @@ -40,6 +40,7 @@ results of the GPU-accelerated statistics are dictionaries which contain the sam * `standard_deviation_of_n_nearest_neighbors_map` * `standard_deviation_of_proximal_neighbors_map` and alias `standard_deviation_of_distal_neighbors_map` * `affine_transform` (yet without shearing) +* `translate` ### Backwards compatibility breaking changes * `statistics_of_labelled_pixels` and `statistics_of_background_and_labelled_pixels` produce different output now. diff --git a/pyclesperanto_prototype/_tier8/_translate.py b/pyclesperanto_prototype/_tier8/_translate.py new file mode 100644 index 00000000..dab43945 --- /dev/null +++ b/pyclesperanto_prototype/_tier8/_translate.py @@ -0,0 +1,12 @@ +from .._tier0 import plugin_function +from .._tier0 import Image + +@plugin_function +def translate(source : Image, destination : Image = None, translate_x : float = 0, translate_y : float = 0, translate_z : float = 0): + from ._AffineTransform3D import AffineTransform3D + from ._affine_transform import affine_transform + + transform = AffineTransform3D() + transform.translate(translate_x, translate_y, translate_z) + + return affine_transform(source, destination, transform) diff --git a/tests/test_translate.py b/tests/test_translate.py new file mode 100644 index 00000000..3ef98092 --- /dev/null +++ b/tests/test_translate.py @@ -0,0 +1,30 @@ +import pyclesperanto_prototype as cle +import numpy as np + +def test_translate(): + source = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + reference = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 1, 1, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + result = cle.translate(source, translate_x=-1, translate_y=-1) + + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) + + print(a) + print(b) + + assert (np.array_equal(a, b)) + From fe884629801fbb450c828ff471fecd1ea6f75b75 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 13:25:14 +0100 Subject: [PATCH 06/27] added rotate --- docs/release_notes.md | 1 + .../_tier8/_AffineTransform3D.py | 39 ++++++++++++- pyclesperanto_prototype/_tier8/__init__.py | 1 + pyclesperanto_prototype/_tier8/_rotate.py | 48 ++++++++++++++++ tests/test_rotate.py | 57 +++++++++++++++++++ 5 files changed, 144 insertions(+), 2 deletions(-) create mode 100644 pyclesperanto_prototype/_tier8/_rotate.py create mode 100644 tests/test_rotate.py diff --git a/docs/release_notes.md b/docs/release_notes.md index 7b29444c..8e4ef24f 100644 --- a/docs/release_notes.md +++ b/docs/release_notes.md @@ -41,6 +41,7 @@ results of the GPU-accelerated statistics are dictionaries which contain the sam * `standard_deviation_of_proximal_neighbors_map` and alias `standard_deviation_of_distal_neighbors_map` * `affine_transform` (yet without shearing) * `translate` +* `rotate` ### Backwards compatibility breaking changes * `statistics_of_labelled_pixels` and `statistics_of_background_and_labelled_pixels` produce different output now. diff --git a/pyclesperanto_prototype/_tier8/_AffineTransform3D.py b/pyclesperanto_prototype/_tier8/_AffineTransform3D.py index 6e304e6a..0de2e4ef 100644 --- a/pyclesperanto_prototype/_tier8/_AffineTransform3D.py +++ b/pyclesperanto_prototype/_tier8/_AffineTransform3D.py @@ -61,9 +61,9 @@ def rotate(self, axis : int = 2, angle_in_rad : float = 0): """ if axis == 0: - self._concatenate(self._3x3_to_4x4(transforms3d.euler.euler2axangle(angle_in_rad, 0, 0))) + self._concatenate(self._3x3_to_4x4(transforms3d.euler.euler2mat(angle_in_rad, 0, 0))) if axis == 1: - self._concatenate(self._3x3_to_4x4(transforms3d.euler.euler2axangle(0, angle_in_rad, 0))) + self._concatenate(self._3x3_to_4x4(transforms3d.euler.euler2mat(0, angle_in_rad, 0))) if axis == 2: self._concatenate(self._3x3_to_4x4(transforms3d.euler.euler2mat(0, 0, angle_in_rad))) @@ -94,6 +94,41 @@ def translate(self, translate_x: float = 0, translate_y: float = 0, translate_z ])) return self + def center(self, shape, undo : bool = False): + """Change the center of the image to the root of the coordinate system + + Parameters + ---------- + shape : iterable + shape of the image which should be centered + undo : bool, optional + if False (default), the image is moved so that the center of the image is in the root of the coordinate system + if True, it is translated in the opposite direction + + Returns + ------- + self + + """ + + presign = 1 + if not undo: + presign = -1 + + if len(shape) == 2: + self.translate( + translate_x = presign * shape[1] / 2, + translate_y = presign * shape[0] / 2 + ) + else: # 3 dimensional image + self.translate( + translate_x = presign * shape[2] / 2, + translate_y = presign * shape[1] / 2, + translate_z = presign * shape[0] / 2 + ) + + return self + def shear(self): raise NotImplementedError("Shearing has not been implemented yet. \n" "See https://github.com/clEsperanto/pyclesperanto_prototype/issues/90") diff --git a/pyclesperanto_prototype/_tier8/__init__.py b/pyclesperanto_prototype/_tier8/__init__.py index 4bcd7b39..d264bc0c 100644 --- a/pyclesperanto_prototype/_tier8/__init__.py +++ b/pyclesperanto_prototype/_tier8/__init__.py @@ -1,5 +1,6 @@ from ._affine_transform import affine_transform from ._AffineTransform3D import AffineTransform3D +from ._rotate import rotate from ._translate import translate diff --git a/pyclesperanto_prototype/_tier8/_rotate.py b/pyclesperanto_prototype/_tier8/_rotate.py new file mode 100644 index 00000000..b9ba5d57 --- /dev/null +++ b/pyclesperanto_prototype/_tier8/_rotate.py @@ -0,0 +1,48 @@ +from .._tier0 import plugin_function +from .._tier0 import Image + +@plugin_function +def rotate(source : Image, destination : Image = None, angle_around_x_in_rad : float = 0, angle_around_y_in_rad : float = 0, angle_around_z_in_rad : float = 0, rotate_around_center=True): + """Rotate the image by given angles. + + Angles are given in radians. To convert degrees in radians, use this formula: + + angle_in_rad = angle_in_deg * numpy.pi / 180.0 + + Parameters + ---------- + source : Image + image to be translated + destination : Image, optional + target image + angle_around_x_in_rad : float + rotation around x axis in radians + angle_around_y_in_rad : float + rotation around y axis in radians + angle_around_z_in_rad : float + rotation around z axis in radians + + Returns + ------- + destination + + """ + from ._AffineTransform3D import AffineTransform3D + from ._affine_transform import affine_transform + + transform = AffineTransform3D() + if rotate_around_center: + transform.center(source.shape) + + if angle_around_x_in_rad != 0: + transform.rotate(0, angle_around_x_in_rad) + if angle_around_y_in_rad != 0: + transform.rotate(1, angle_around_y_in_rad) + if angle_around_z_in_rad != 0: + transform.rotate(2, angle_around_z_in_rad) + + if rotate_around_center: + transform.center(source.shape, undo=True) + + + return affine_transform(source, destination, transform) diff --git a/tests/test_rotate.py b/tests/test_rotate.py new file mode 100644 index 00000000..df7c7d38 --- /dev/null +++ b/tests/test_rotate.py @@ -0,0 +1,57 @@ +import pyclesperanto_prototype as cle +import numpy as np + +def test_affine_transform_rotate(): + source = cle.push_zyx(np.asarray([[ + [0, 0, 0, 1, 1], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + reference = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 1, 0, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 0, 0], + ]])) + + result = cle.rotate(source, angle_around_z_in_rad=45.0 * np.pi / 180.0, rotate_around_center=False) + + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) + + print(a) + print(b) + + assert (np.array_equal(a, b)) + +def test_affine_transform_rotate_around_center(): + source = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 1, 1], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + reference = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 1, 0, 0], + [0, 0, 1, 0, 0], + ]])) + + result = cle.rotate(source, angle_around_z_in_rad=90.0 * np.pi / 180.0, rotate_around_center=True) + + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) + + print(a) + print(b) + + assert (np.array_equal(a, b)) + From 44bacf179601a13cd0219b077e0b0e976f56f748 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 13:25:29 +0100 Subject: [PATCH 07/27] added comments --- pyclesperanto_prototype/_tier8/_translate.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/pyclesperanto_prototype/_tier8/_translate.py b/pyclesperanto_prototype/_tier8/_translate.py index dab43945..ca86b9dc 100644 --- a/pyclesperanto_prototype/_tier8/_translate.py +++ b/pyclesperanto_prototype/_tier8/_translate.py @@ -3,6 +3,26 @@ @plugin_function def translate(source : Image, destination : Image = None, translate_x : float = 0, translate_y : float = 0, translate_z : float = 0): + """Translate the image by a given vector. + + Parameters + ---------- + source : Image + image to be translated + destination : Image, optional + target image + translate_x : float + translation along x axis in pixels + translate_y : float + translation along y axis in pixels + translate_z : float + translation along z axis in pixels + + Returns + ------- + destination + + """ from ._AffineTransform3D import AffineTransform3D from ._affine_transform import affine_transform From e8d9bd87fc4c74fe741244fd646c52ae5215f3f3 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 13:31:09 +0100 Subject: [PATCH 08/27] changed angle parameter unit from radians to degrees --- .../_tier8/_AffineTransform3D.py | 11 ++++---- pyclesperanto_prototype/_tier8/_rotate.py | 25 +++++++++---------- tests/test_affine_transform.py | 4 +-- tests/test_rotate.py | 4 +-- 4 files changed, 22 insertions(+), 22 deletions(-) diff --git a/pyclesperanto_prototype/_tier8/_AffineTransform3D.py b/pyclesperanto_prototype/_tier8/_AffineTransform3D.py index 0de2e4ef..74a8e94e 100644 --- a/pyclesperanto_prototype/_tier8/_AffineTransform3D.py +++ b/pyclesperanto_prototype/_tier8/_AffineTransform3D.py @@ -43,7 +43,7 @@ def scale(self, scale_x: float = None, scale_y: float = None, scale_z: float = N return self - def rotate(self, axis : int = 2, angle_in_rad : float = 0): + def rotate(self, axis : int = 2, angle_in_degrees : float = 0): """ Rotation around a given axis (default: z-axis, meaning rotation in x-y-plane) @@ -51,15 +51,16 @@ def rotate(self, axis : int = 2, angle_in_rad : float = 0): ---------- axis : int axis to rotate around (0=x, 1=y, 2=z) - angle_in_rad : int - angle in radians. To convert degrees to radians us this formula: - angle_in_rad = angle_in_deg * numpy.pi / 180.0 + angle_in_degrees : int + angle in degrees. To convert radians to degrees use this formula: + angle_in_deg = angle_in_rad / numpy.pi * 180.0 Returns ------- self - """ + angle_in_rad = angle_in_degrees * np.pi / 180.0 + if axis == 0: self._concatenate(self._3x3_to_4x4(transforms3d.euler.euler2mat(angle_in_rad, 0, 0))) if axis == 1: diff --git a/pyclesperanto_prototype/_tier8/_rotate.py b/pyclesperanto_prototype/_tier8/_rotate.py index b9ba5d57..ed5d4a51 100644 --- a/pyclesperanto_prototype/_tier8/_rotate.py +++ b/pyclesperanto_prototype/_tier8/_rotate.py @@ -2,12 +2,12 @@ from .._tier0 import Image @plugin_function -def rotate(source : Image, destination : Image = None, angle_around_x_in_rad : float = 0, angle_around_y_in_rad : float = 0, angle_around_z_in_rad : float = 0, rotate_around_center=True): +def rotate(source : Image, destination : Image = None, angle_around_x_in_degrees : float = 0, angle_around_y_in_degrees : float = 0, angle_around_z_in_degrees : float = 0, rotate_around_center=True): """Rotate the image by given angles. - Angles are given in radians. To convert degrees in radians, use this formula: + Angles are given in degrees. To convert radians to degrees, use this formula: - angle_in_rad = angle_in_deg * numpy.pi / 180.0 + angle_in_degrees = angle_in_radians / numpy.pi * 180.0 Parameters ---------- @@ -15,11 +15,11 @@ def rotate(source : Image, destination : Image = None, angle_around_x_in_rad : f image to be translated destination : Image, optional target image - angle_around_x_in_rad : float + angle_around_x_in_degrees : float rotation around x axis in radians - angle_around_y_in_rad : float + angle_around_y_in_degrees : float rotation around y axis in radians - angle_around_z_in_rad : float + angle_around_z_in_degrees : float rotation around z axis in radians Returns @@ -34,15 +34,14 @@ def rotate(source : Image, destination : Image = None, angle_around_x_in_rad : f if rotate_around_center: transform.center(source.shape) - if angle_around_x_in_rad != 0: - transform.rotate(0, angle_around_x_in_rad) - if angle_around_y_in_rad != 0: - transform.rotate(1, angle_around_y_in_rad) - if angle_around_z_in_rad != 0: - transform.rotate(2, angle_around_z_in_rad) + if angle_around_x_in_degrees != 0: + transform.rotate(0, angle_around_x_in_degrees) + if angle_around_y_in_degrees != 0: + transform.rotate(1, angle_around_y_in_degrees) + if angle_around_z_in_degrees != 0: + transform.rotate(2, angle_around_z_in_degrees) if rotate_around_center: transform.center(source.shape, undo=True) - return affine_transform(source, destination, transform) diff --git a/tests/test_affine_transform.py b/tests/test_affine_transform.py index 7c6eedbe..fbad0a2c 100644 --- a/tests/test_affine_transform.py +++ b/tests/test_affine_transform.py @@ -115,7 +115,7 @@ def test_affine_transform_rotate(): ]])) transform = cle.AffineTransform3D() - transform.rotate(2, 45.0 * np.pi / 180.0) + transform.rotate(2, 45.0) result = cle.affine_transform(source, transform=transform) @@ -146,7 +146,7 @@ def test_affine_transform_rotate_around_center(): transform = cle.AffineTransform3D() transform.translate(-2.5, -2.5) - transform.rotate(2, 90.0 * np.pi / 180.0) + transform.rotate(2, 90.0) transform.translate(2.5, 2.5) result = cle.affine_transform(source, transform=transform) diff --git a/tests/test_rotate.py b/tests/test_rotate.py index df7c7d38..99d236f0 100644 --- a/tests/test_rotate.py +++ b/tests/test_rotate.py @@ -18,7 +18,7 @@ def test_affine_transform_rotate(): [0, 0, 0, 0, 0], ]])) - result = cle.rotate(source, angle_around_z_in_rad=45.0 * np.pi / 180.0, rotate_around_center=False) + result = cle.rotate(source, angle_around_z_in_degrees=45.0, rotate_around_center=False) a = cle.pull_zyx(result) b = cle.pull_zyx(reference) @@ -45,7 +45,7 @@ def test_affine_transform_rotate_around_center(): [0, 0, 1, 0, 0], ]])) - result = cle.rotate(source, angle_around_z_in_rad=90.0 * np.pi / 180.0, rotate_around_center=True) + result = cle.rotate(source, angle_around_z_in_degrees=90.0, rotate_around_center=True) a = cle.pull_zyx(result) b = cle.pull_zyx(reference) From 60cbbd6da2c674242882a7b928995a31bf4c0500 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 13:49:23 +0100 Subject: [PATCH 09/27] added scale, deprecated resample --- docs/release_notes.md | 4 ++ pyclesperanto_prototype/_tier1/_resample.py | 6 +++ pyclesperanto_prototype/_tier8/__init__.py | 1 + pyclesperanto_prototype/_tier8/_scale.py | 39 ++++++++++++++ tests/test_scale.py | 59 +++++++++++++++++++++ 5 files changed, 109 insertions(+) create mode 100644 pyclesperanto_prototype/_tier8/_scale.py create mode 100644 tests/test_scale.py diff --git a/docs/release_notes.md b/docs/release_notes.md index 8e4ef24f..a62eca74 100644 --- a/docs/release_notes.md +++ b/docs/release_notes.md @@ -42,6 +42,7 @@ results of the GPU-accelerated statistics are dictionaries which contain the sam * `affine_transform` (yet without shearing) * `translate` * `rotate` +* `scale` ### Backwards compatibility breaking changes * `statistics_of_labelled_pixels` and `statistics_of_background_and_labelled_pixels` produce different output now. @@ -52,6 +53,9 @@ dictionaries,e.g. `stats['area']` instead of `[s.area for s in stats]`. If not p * `n_closest_points` ignores the background position and the distance to labels themselves per default now. Consider passing `ignore_background=False` and `ignore_self=False` to go back to former functionality. +### Deprecation warnings +* `resample` has been deprecated. Use `scale` instead. + ### Bug fixes * `imshow` in 3D caused an error * `push_regionprops_column` didn't actually push diff --git a/pyclesperanto_prototype/_tier1/_resample.py b/pyclesperanto_prototype/_tier1/_resample.py index cebc35dd..31720d9d 100644 --- a/pyclesperanto_prototype/_tier1/_resample.py +++ b/pyclesperanto_prototype/_tier1/_resample.py @@ -30,6 +30,12 @@ def resample(source : Image, destination : Image = None, factor_x : float = 1, f ---------- .. [1] https://clij.github.io/clij2-docs/reference_resample """ + import warnings + warnings.warn( + "Deprecated: pyclesperanto_prototype.resample() is deprecated. Use scale() instead", + DeprecationWarning + ) + import numpy as np source_dimensions = source.shape diff --git a/pyclesperanto_prototype/_tier8/__init__.py b/pyclesperanto_prototype/_tier8/__init__.py index d264bc0c..5865817a 100644 --- a/pyclesperanto_prototype/_tier8/__init__.py +++ b/pyclesperanto_prototype/_tier8/__init__.py @@ -1,6 +1,7 @@ from ._affine_transform import affine_transform from ._AffineTransform3D import AffineTransform3D from ._rotate import rotate +from ._scale import scale from ._translate import translate diff --git a/pyclesperanto_prototype/_tier8/_scale.py b/pyclesperanto_prototype/_tier8/_scale.py new file mode 100644 index 00000000..fe5fd347 --- /dev/null +++ b/pyclesperanto_prototype/_tier8/_scale.py @@ -0,0 +1,39 @@ +from .._tier0 import plugin_function +from .._tier0 import Image + +@plugin_function +def scale(source : Image, destination : Image = None, factor_x : float = 1, factor_y : float = 1, factor_z : float = 1, centered=True): + """Scale the image by given factors. + + Parameters + ---------- + source : Image + image to be translated + destination : Image, optional + target image + factor_x : float + scaling along x + factor_y : float + scaling along y + factor_z : float + scaling along z + centered + + Returns + ------- + destination + + """ + from ._AffineTransform3D import AffineTransform3D + from ._affine_transform import affine_transform + + transform = AffineTransform3D() + if centered: + transform.center(source.shape) + + transform.scale(factor_x, factor_y, factor_z) + + if centered: + transform.center(source.shape, undo=True) + + return affine_transform(source, destination, transform) diff --git a/tests/test_scale.py b/tests/test_scale.py new file mode 100644 index 00000000..6e7184c9 --- /dev/null +++ b/tests/test_scale.py @@ -0,0 +1,59 @@ +import pyclesperanto_prototype as cle +import numpy as np + + +def test_scale_centered(): + source = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + reference = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 1, 1, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + result = cle.scale(source, factor_y=2) + + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) + + print(a) + print(b) + + assert (np.array_equal(a, b)) + + +def test_scale_not_centered(): + source = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + reference = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 1, 1, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 0, 0], + ]])) + + result = cle.scale(source, factor_y=2, centered=False) + + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) + + print(a) + print(b) + + assert (np.array_equal(a, b)) + From 0632faaa67d415a4ad8a52fbafb5a4373b947c27 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 14:01:55 +0100 Subject: [PATCH 10/27] updated comment --- pyclesperanto_prototype/_tier8/_rotate.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pyclesperanto_prototype/_tier8/_rotate.py b/pyclesperanto_prototype/_tier8/_rotate.py index ed5d4a51..5a1f53bf 100644 --- a/pyclesperanto_prototype/_tier8/_rotate.py +++ b/pyclesperanto_prototype/_tier8/_rotate.py @@ -21,6 +21,9 @@ def rotate(source : Image, destination : Image = None, angle_around_x_in_degrees rotation around y axis in radians angle_around_z_in_degrees : float rotation around z axis in radians + rotate_around_center : boolean + if True: rotate image around center + if False: rotate image around origin Returns ------- From 30fd228f20b471a81c1152ac429f83ad4e8f07f8 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 14:02:31 +0100 Subject: [PATCH 11/27] added rigid transform --- docs/release_notes.md | 1 + pyclesperanto_prototype/_tier8/__init__.py | 1 + .../_tier8/_rigid_transform.py | 58 +++++++++++++++++++ tests/test_rigid_transform.py | 30 ++++++++++ 4 files changed, 90 insertions(+) create mode 100644 pyclesperanto_prototype/_tier8/_rigid_transform.py create mode 100644 tests/test_rigid_transform.py diff --git a/docs/release_notes.md b/docs/release_notes.md index a62eca74..db088e17 100644 --- a/docs/release_notes.md +++ b/docs/release_notes.md @@ -43,6 +43,7 @@ results of the GPU-accelerated statistics are dictionaries which contain the sam * `translate` * `rotate` * `scale` +* `rigid_transform` ### Backwards compatibility breaking changes * `statistics_of_labelled_pixels` and `statistics_of_background_and_labelled_pixels` produce different output now. diff --git a/pyclesperanto_prototype/_tier8/__init__.py b/pyclesperanto_prototype/_tier8/__init__.py index 5865817a..a392616a 100644 --- a/pyclesperanto_prototype/_tier8/__init__.py +++ b/pyclesperanto_prototype/_tier8/__init__.py @@ -1,5 +1,6 @@ from ._affine_transform import affine_transform from ._AffineTransform3D import AffineTransform3D +from ._rigid_transform import rigid_transform from ._rotate import rotate from ._scale import scale from ._translate import translate diff --git a/pyclesperanto_prototype/_tier8/_rigid_transform.py b/pyclesperanto_prototype/_tier8/_rigid_transform.py new file mode 100644 index 00000000..20b2fc9a --- /dev/null +++ b/pyclesperanto_prototype/_tier8/_rigid_transform.py @@ -0,0 +1,58 @@ +from .._tier0 import plugin_function +from .._tier0 import Image + +@plugin_function +def rigid_transform(source : Image, destination : Image = None, translate_x : float = 0, translate_y : float = 0, translate_z : float = 0, angle_around_x_in_degrees : float = 0, angle_around_y_in_degrees : float = 0, angle_around_z_in_degrees : float = 0, rotate_around_center=True): + """Translate the image by a given vector and rotate it by given angles. + + Angles are given in degrees. To convert radians to degrees, use this formula: + + angle_in_degrees = angle_in_radians / numpy.pi * 180.0 + + Parameters + ---------- + source : Image + image to be transformed + destination : Image, optional + target image + translate_x : float + translation along x axis in pixels + translate_y : float + translation along y axis in pixels + translate_z : float + translation along z axis in pixels + angle_around_x_in_degrees : float + rotation around x axis in radians + angle_around_y_in_degrees : float + rotation around y axis in radians + angle_around_z_in_degrees : float + rotation around z axis in radians + rotate_around_center : boolean + if True: rotate image around center + if False: rotate image around origin + + Returns + ------- + destination + + """ + from ._AffineTransform3D import AffineTransform3D + from ._affine_transform import affine_transform + + transform = AffineTransform3D() + if rotate_around_center: + transform.center(source.shape) + + if angle_around_x_in_degrees != 0: + transform.rotate(0, angle_around_x_in_degrees) + if angle_around_y_in_degrees != 0: + transform.rotate(1, angle_around_y_in_degrees) + if angle_around_z_in_degrees != 0: + transform.rotate(2, angle_around_z_in_degrees) + + if rotate_around_center: + transform.center(source.shape, undo=True) + + transform.translate(translate_x, translate_y, translate_z) + + return affine_transform(source, destination, transform) diff --git a/tests/test_rigid_transform.py b/tests/test_rigid_transform.py new file mode 100644 index 00000000..c3e23530 --- /dev/null +++ b/tests/test_rigid_transform.py @@ -0,0 +1,30 @@ +import pyclesperanto_prototype as cle +import numpy as np + +def test_rigid_transform(): + source = cle.push_zyx(np.asarray([[ + [0, 0, 0, 1, 1], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + reference = cle.push_zyx(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 1, 0], + [0, 0, 0, 1, 0], + ]])) + + result = cle.rigid_transform(source, translate_x=-1, angle_around_z_in_degrees=90) + + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) + + print(a) + print(b) + + assert (np.array_equal(a, b)) + From 605116591562286697143934596ad87761cf9afd Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 14:13:07 +0100 Subject: [PATCH 12/27] added demo notebook --- README.md | 8 + demo/transforms/affine_transforms.ipynb | 364 +++++++++++++++++++ docs/images/screenshot_affine_transforms.png | Bin 0 -> 115023 bytes 3 files changed, 372 insertions(+) create mode 100644 demo/transforms/affine_transforms.ipynb create mode 100644 docs/images/screenshot_affine_transforms.png diff --git a/README.md b/README.md index b61b2b79..8d082b07 100644 --- a/README.md +++ b/README.md @@ -113,6 +113,14 @@ imsave("result.tif", cle.pull(labeled)) + + + + +[Rotation, scaling, translation, affine transforms](https://github.com/clEsperanto/pyclesperanto_prototype/tree/master/demo/transforms/affine_transforms.ipynb) + + + diff --git a/demo/transforms/affine_transforms.ipynb b/demo/transforms/affine_transforms.ipynb new file mode 100644 index 00000000..5a521879 --- /dev/null +++ b/demo/transforms/affine_transforms.ipynb @@ -0,0 +1,364 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Inspecting 3D image data with pyclesperanto\n", + "This notebook demonstrates how to navigate through 3D images." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pyclesperanto_prototype as cle\n", + "\n", + "cle.select_device('RTX')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2020-11-08T15:12:56.295161Z", + "iopub.status.busy": "2020-11-08T15:12:56.295161Z", + "iopub.status.idle": "2020-11-08T15:12:56.575184Z", + "shell.execute_reply": "2020-11-08T15:12:56.575184Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "from skimage.io import imshow\n", + "\n", + "# Helper function for reading ImageJs ZIP file examples\n", + "import requests\n", + "import zipfile\n", + "from io import BytesIO\n", + "from tifffile import imread\n", + "\n", + "def remote_reader(url):\n", + " \"\"\"generator that returns the first numpy arrays representing \n", + " in a tif in a remote zip.\"\"\"\n", + " response = requests.get(url)\n", + " response.raise_for_status()\n", + " with zipfile.ZipFile(BytesIO(response.content)) as zf:\n", + " for path in zf.filelist:\n", + " with zf.open(path, \"r\") as f:\n", + " # f is a file-like object of type zipfile.ZipExtFile\n", + " # replace imread with any file-reader of your choice\n", + " # that accepts a file-like object as input \n", + " return imread(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Laod example data\n", + "np_array = remote_reader('https://imagej.nih.gov/ij/images/t1-head.zip')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# push it to GPU memory\n", + "input_image = cle.push_zyx(np_array)\n", + "\n", + "cle.imshow(input_image)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Rotation\n", + "For rotating an image, you need to provide angles corresponding to axes." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "rotated = cle.rotate(input_image, angle_around_z_in_degrees=90)\n", + "cle.imshow(rotated)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Images are rotated around their center by default. You can change this by providing an additional parameter. The image will then be rotated around the origin." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "rotated = cle.rotate(input_image, angle_around_z_in_degrees=15, rotate_around_center=False)\n", + "cle.imshow(rotated)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Translation\n", + "Images can be translate by providing translation distances along axes:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "translated = cle.translate(input_image, translate_x=50, translate_y=-50)\n", + "cle.imshow(translated)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scaling\n", + "You can scale the image by providing scaling factors." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "scaled = cle.scale(input_image, factor_x=0.5, factor_y=2)\n", + "cle.imshow(scaled)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Rigid transform\n", + "Rigid transforms allow to do translations and rotations in one shot" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "rigid_transformed = cle.rigid_transform(input_image, translate_x=20, angle_around_z_in_degrees=45)\n", + "cle.imshow(rigid_transformed)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Affine transforms\n", + "To do translation, rotation and scaling in one shot, use affine transforms. [Shearing will be implemented in a future release](https://github.com/clEsperanto/pyclesperanto_prototype/issues/90).\n", + "\n", + "To setup an affine transform, you can do this using a 4x4 transform matrix:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "transform_matrix = np.asarray([\n", + " [1, 0, 0, 50],\n", + " [0, 2, 0, 0],\n", + " [0, 0, 0.5, 0],\n", + " [0, 0, 0, 1]\n", + "])\n", + "transformed_image = cle.affine_transform(input_image, transform=transform_matrix)\n", + "cle.imshow(transformed_image)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternatively, you can configure a transform object and pass it:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "transform = cle.AffineTransform3D()\n", + "transform.translate(50)\n", + "transform.scale(1, 2, 0.5)\n", + "\n", + "transformed_image = cle.affine_transform(input_image, transform=transform)\n", + "cle.imshow(transformed_image)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/images/screenshot_affine_transforms.png b/docs/images/screenshot_affine_transforms.png new file mode 100644 index 0000000000000000000000000000000000000000..58990d96759948967096b4b7558f5488a5316e4f GIT binary patch literal 115023 zcmeFYRaD!}A3lgnS|E6l0zryoUVm*TXzJHdh$cXxNExD7ehp78`Vxy%Mk_!z4yNt?0{{t2@K48ft09_s+<1FtLKfm znmhGF5r>pzJ=GJoM1(_;BF!0&E3h=Xqk!fzD4T3h?@UpdOc4%oc2B42lkKXIoKft! zi3d~7Ok7H4rjuFhxLBOLkx}e7v$50!j=C>q6^AJT`_pl6?U@I!kLgcWjDK?xIyUIW z&H0YYz3-Mhv%JR-UU|z zl-3y|{J)<-+o$`s`O*K+kjMWILp*C}b{D{}3rP%G4j0|XwyVwdu^iAPjGTX`>v>pd z1v3L6FTw8@r0CrLvd_H^c;4^dU%{l#vq~FJ^G#onp)2v^dKDM@1onJA7t4v>cst$D z|KngfP4tv>1APwWvW;St9owq+b{d>3`pzqQ4SjdhX@l1z4cq3ep!|b3pA!k6m#mk; zV+jIN)^8Ks1hEE>(?^^RAqnzmftrvs$qO0@mxO1FgJL~N*OCEjnF(Q?H zcsm9^R2aH;(}~zVVUUl(`_lpj-_2wI^jUL)Nm5PtuD|~prwNzPrvzLQ;Tp#CN#bEb zUb;4lx$+oD+%IW%k>CCseK{xz%KKf*!=^k)lNTK$EKXqRYLXwVBo3m0{AL?I`(L*( z^axGk*JA$bhWy518>VTc_^%s4Kx-1O&CnH@W~4ihk1M-1v3idci6@B5Iqx3 zN)p#F2IB{D(EG~!U8kJO+YVT_&TOndf{4oMym=?md2X2>%bO+etVZx+ixl7A_$%1!0yM8h>W9o90@AG2pOfx25C2ZyptNEBJL*Ge6o3e66!x-)_oXDVc)dYTS!fKozT7CQu6*H(z zegtTpgt08dyLuRDQn22OZ2g({N=;7Q+4|Q8_tVj4znX`y@8!ix<%i_WR6PjwC$Rui-Shs-U%%p|f}ax=wc2bkq0@6GNI^UwCxRyG7$D zp0j2NQt#O_{^ygp7w|(c_|tT+0zvzY=Umjw-?sHAwqfBR8;kMrPChA2Bk>|}ms(4n zPxpV=;z>=;azN%b9?=;($8qQ@k9)!5)7YXAy2!`TA<`v>QR=48-mi_uRm(0%$W7(E z9;c&3RkUwi|`k0t?Imsi?{u&+J*uHaidfryH zd%>|1)nT)ubzp@PIeOyQH%e5=1R(H_UC{pqJw&}Er^?Fds*e2e71JYKM+MRSj3-kD zsND6QcRZi1)S8ZPMsp04P($VGV`pCh3cT81wX9TIE>qb9LMMo8?M_TWRcm@dB>{?h zTJ;q1O9tQor$jl_EaY?R^%e4!uGg^7>Ub<{lp#B zaU*lP^)puyuOiM>;c*ymp}jbjm4T}}N7~xq9yK4A=Qw!|{L+_$J;o1$p!b9KNATM- z`29SNb1z=S=M`%F?^bL{%`g|rwPp%3_x_J``MCX0x;~BNue70GeUwR!wVq#EO>N+J zI3+k3%XFHWkK=E-oyD-`dhDsdg>BoJVYlsgBWUPBnEoty!ZM%1{*_0nDc&9fchADM zY+K;Tt`A$HitjGfI@r7LVJ8}GC2>^)haA9Vaorg3-J0jd@041<2vIUW#tuJ;N>Ei#6xm?<8^I=(V*ic zS_ECI#;EVUJj0XwYw^ zF*h;KX3^*A`CG5Mo}}c|w`neHyqJHJCIebe9%ZsK3VQhs%iYe7g z=#KMkb>J59H@}SDnlo=)RHn$8cX%e^W!UT6Zt!?MJ*LU5Yv}MV6P%~;InI3nl(1L} zxGufYM?H>?Zn@$PoVZ$++!Iyh92AK0WZdsjFiQYJyRC@`R|t)NeZZoZ_f$+*GDI$I z_7El-(A5dGL*=^KKMj>9=HByX1foRj)?--lLnYQ1x%eQn8U0TFbu-Z@)w{}cU}VZ~ zYv-&?P3>8q=TOAr_tqKXcNAyPZ=;xom84aT9SszbMf=G_YmUl>j$B|Uh0R8##`1y{ z3VgC<#JrPoK9l44qh(c{r|CT0;pDCF};*H2<*eWcVCBB%p;N`qW?rMW=mPsc!nO3JQ} zkm?gf*ImXjsxZB|V4G6CMDL}6CM*+}U~0X3TU9U`zbt;`#^iz6$3IsAw_wuw7#91+yMbrjlhdRm*LDEaV1 zf4@#DWucoYihZ3+mN5yE)qSS%;wMnZDv?Yf>MsEBy9g5SJ!m(Mj&^#@?wfWb;<|jQSi2ZW-3nWt&tm&r zNZwqqPLnb1rJVZBeprtz$L@2#%Pvqn#YkQ$S7<8Hj_zxYixu501+nzp*XlqQ!JyCMD(K znXj&4hdyK=x65E0*T2p2FkP{i5EvY;%i zC#zx}#|7XpC=zGrSN!$!esHGSe*C7B_X5U*>pvAZ<&pgStsB^N&wStLvwnes zwtr8!Y%yDPQ(euWHN-#fPvSQQicx+kax-#y&swS8$a5wyQfw~otuTdilC^MvTFD9B zhERt}ZaWU0x}--N=I;Png*NYt*ybbKj?5&oryB$2)_l!Cj;hVPohb4s9YFftJk;Oz za2U2~-Py_3pxjiZ^f#2z=h)fz7nMn~%3*+)D#AYhwE%`whM+=VbnNHG_U5~&c`YgX zOz_N|9^i%qb=D`mu^pt55$IQ$Uj^>}I%B*1C7q$kHwh`SMg}YqwdbzIK`j7+`yQlh z-Q_xLhLjuX{$hd$GvGuw=mvju3mAM<`g^fkC>|uRzXRNQE-4MhbJ4y1%gI!;ZD*}p%>hnb)M(tpMWhW2 z!kZIVo`DDcru;)!lO1g`n%NAfNcwRyo=U?XJ<2a=@vU;)CKb?VMC{?qUgyxB`PAk+M_rML#ptHnb)0%u>3^)`D=Q7E zq@h1N-eQlVkmmb}chp{X8F)!r*-tX_t43JD5_$h|7f!Ls8DB(DsR_a3CPob>erUKw ze!qez6gbg1Pm+ol0j@S@ByjEZa@_m$dzvR@T>`mRKinMc34iso856C7Cax~447Go6jI;(wNG63M2mx{;v`0#m-X)-@5EJ)#y zqM#&uew|bjvkwL4?}QGUzZQ^YRTOWVH}pY4VOs&e7*t&)Oyx-5K ze;Y4WDktK(YBucwm=1Ur;6*PEYm`0Y9gNmU;vOecAVh2LW#6DAh~PqQyjmSWj10LN z53+jN0ooQ3d4^;XHSr<g!a##W2P~~LqwYg>sg7piRL34 zt4^Tu^S>O_OLo%dh3KpbJd3({4#?a;s_~@r8sRhVFuVm)0kjrAIKWq z-~O#VU~k?Bq}El}?Ws)~*-)_v46VAH$Xe1?lEffq-ImNv&Xy>k!x?1Tn3Kc0S6!Y` z3^~G$zagjpNU4-QRn=Z9!gpY(v6dUAZ&;jsgu8v?)XtVHTXp2bd05GP)HXdCBA~2E zhNavM!3}RaHIvoaonj}=i4djkWAY{qV{z$_VHSWI-V=S+4r1*+k zf5m+&$OLmcjg6*NmQC*N;X9r%P(T>?-TM$90uuc>lEV7Tv!fmxTA^Cc{Vg?Tf<<-6 zxQ{qNWDEgMlKihPoyT7(DV@9aLYhM2xMrc$;eup5Hkdsp>0AWZ!0TMVc3UWy)6Vbr zeV5=K;$rfAa*3z-_oqnH&bPz3_hX)uAmI}_1^y=y-9qoh^`TJRPpAhcyMVSnj^|f~FVsWg5Jt9paYuEMe}ePcB?* zw_SJBo^Jm}nXZ0FQE47I9C)7PWRk~U|Csn$#rWk%$dYN#Rli_3h)&RO_?*d@@6r$0 z->7Xro+Bl!`O!Aidk5m1c*^y@R&n9D-r0efega3NxCb;*A04BAvSRFTAa~gar9(P0 zH_lMX{UYoUMiLwY)Dctt?mRT%^e&*M6RcWdN>ML9_;yp6y16tP#k9_q;*-U7G7gXk zO1ry)`hL75lxX_5=E7h&AJetV_ZOz8-s}&AR$A`TYV+?&mWlp$!#EU?%X_s;%WCW2 zbaNBewv(%D6fvzgQFkdT+VpvKhsiz+OmgQ zq$9vjO_d@f_-}V}jnjY~(66dbV;cJVeee4K2|dJP5nHZ08b@fQ>rCry8EU$C-Z5u@ ze+3|ni|RK9hJP#i&~TM+vhk!oVv3~yiH`MQiDotsQI1;Z=}dJy#y#jl%F0HGCIh5Y z1L_r#jdii3Ka6IN;7#-22z*=_(|53`zEPhfupDK&peF+i45-+|M#MP zV}ryUZK!GzLRFL9wmDS>y@O>qWQG*WBV?}7s{D^g{NHa=?bZPHZ3dr|eFLo|`+Ok$ zOx6)@NQh*MFQeX`CPaofHm(bD$DJ=%@sm20VI~K(!DPdE`hEVR%IC(}G{PCXqXyjW-$yUS-MBdE`&dhnd9pdf7LOTF0Uh2j>6ju&DBSsQ9_rKnCNCf zy~5U^ob@GG1?uWOBPVrXEDMq#L}$|%2UI@LlSy;X$oKt=8aoQ;$Y}}Pt)Tmkvvp`E zOwLO!9>f23H3ZMZcB&rSC#7&Z{peE;kZ9>oO<3x{#icc1#`Wo)V^+X}Dre2$=y4UV zWuJI;q0iT_f-j@o#-B^GRb^e;*onK|q*sC{<7?9L_U2!w1K3X4p5j#qQc(NpPac*$ z(kDSFl-Sgt;4&5y6z*pWg6mmlh{h}TRP9}YcL%=bABk?zaP{qjl&wnT3qnQMO4?7+ zHXi=TZM20@de5DM+bZ|`98jZLbJsHlCNf-g@G4IBaIl!NY$m+t`g%l3?pd==w4C~z z@Kq8}-((e3?nU;kY}|6qC=?|-S#yy5Ymb=Y@UUJVFd1O6l3|HLgxP)z;dK4LL|2?X zcq`MHgcr3JMR7vqutO4!sYW3iazdH8Fk>?TMB5$fj<(C^2FA9D7l;5gK;tyaIxA5P zwnqf<$j4gu40tGzz&oIL#2-F=_)eGO$5M&!5=B_DSx?=J|5cAN)5pA59Mf}1mBj&C zI6aUd2C6rhC&Nt|SwWglWpWLa)nbTm24&O_+pVqVj8@y8zl|tG$A_wZ@YsNOiVeC zO+MEYmhTTmG00i03|Igq!GAlY?hw^`J@z!k!?v_K&OK8hP)0FFc~$!fv|2UT8-NR` z4~`VGB2ZkZ?Q>Nlw5CKbZ0;`S+}RqkLLO>!MJs-r4%j4QS?Q;Z5rprG%l@`G^lcOr zO@(Da!C>@3yE~R`J3&HOR+ zP*+TqDSx4Qvu8Tnrw}lnf!Mv7vs1aMex3_{W@Ikw`%fj?CMS5`L5s+)2wmGM)cu6m zfx@{z%dOE(|CS&jbhP-{7g29vG-e)ZkSOGTer)7$n438fquhSF%lWErKZIS!R^lXD zctxn{bAjD(sK~hbG~DkL6uZLh{PGuwdWDj-D8@3Y`K8Yc?%!jh08ela1;$UEpN+na zWy%_1Vm7pRTJ}#O*cvwWBl_|n6B`tV%_9|o`n|=&CO%+LHHC7&tKQP;M}Vo=xlkS7 zkGbPMnPoXtpI?Uq%;gwHThjHI8z_lnbU-*d^07ylOv&UOsNIqk#vy{u_k4fwdJ%$J zf6Rs-gp3xep;#gR@}q^L{njT@0a97mF{)$=rByBF$2(%?*y!prO{JFZ`(VMM$b2?H5kj!ZS&8gF*fxYgisSEs%UFb&b->^b1hv z+cY|)Aom~_$P3Ca3=Sa%od071UUq=J;Tr}BzM_FAA6MT0^ZSRoYr4Zg3R=p-5+b|1cG$4+{ zF#9M}15%)Bkue}YzB&b`^F!nD|fv0doLs~6Sb#)9ekon8^CUZu-Ji!4YM4ap`0{86QWRZ>v z*@`K(ASp5jXeoCg_`;<{BV78<3=lfhyZy=^rH1S+jneaF8-qc)dz;$x^{m3wA7hC{ zD`y0ub0<@~?ig%RYYCd^eSKq#4*6A2uTdkjWN}+<)e3Q?p>^3yj7J!>JgNCIX~-Fei=>Zdd}@ z0}sI=`NWr?e{m0n?MDy+Oq}GRkRnPTP&QhrJb&j`AZQX5Wl4;P=PH1?#(On3Tz9E&rE^o3)E~eH>$~kxI9rRwkD6rI zUPJx&N4r^CycE^~tH46P5(JKb=f7`GU5O-#<_k<}6}Ve!_8HkPmrD+*9^Gm^){Hb# zXqz1&`S^->V>e7|^JG(;6=w773QPm;*zW&`wuMO2CH9Z$EqQYiOT6(SH;h0N>P#mgZeXnUoPKUQPNd;y9Ec7OY$~E1~(A&UQ zK`wGQ809%H@Py)h?HhwXZ-OSi<_)M}=jNF) z*qZ8nW%{*JWh0s76std*GjOEkDzPK1CR?Sc-yqzVS&1sMoTG)9tx-poVY7*qBnS

kXwDz!JS@_n?|H;)`8yFa@&C&wL&p5>S;4B#VD)&q@NM|#wZap2&ko0a#_v+ zLA$`yS{a=%Kj^FtCr8!#N#mEW&O>{gb{ZHpCVb+zhQ5y%_0{1cFA z6IU0i>X$n>wn9YF;_d<+`>O=U@gNtHpA16ac%!e2L@?dDM0{akvW>!dH(|lqfusJC zGTCT2@SOdBE+cjXMD~sOS)~A2n!B`LE>$bwVV}r@^mFx&|@mnKeT&0$YgYom(DvBU3`$7v$DFRe!;j)rIHV&NZ?n8gp*PO6;>rYob z_KY2{DaU^mDQlPT}5XNW(m*Qn-b8{_)KsVNXB^Z(LT0HOiKg8VjAoK>_ zsEzu!jcLcvvB4W^Q97jd_rnwmneAS^w503XQDnFEYeybdtq(hQsge_d>Ug&#Pd^}^ z8K&YUs1zUtRXqprGQ+{`Lcd@&`JkwY5#+%bS#NyD&w%()r!$9jB%O{^4Icn&kTT}8TmG6vz( z!^Y7+K_YeXIqy(-3ih6GeEEF-(bd*|a9t2YQ0lS6F=z~>L1>V8o^w%G=-4j@j7+$N zq&FDt{3KoUnih)#=6{*K&M40OaEZLsN6wM7er}A+)h#gwd9m{TNvdd=)@=&jLdc~= zx#&W@l#m%1+7toG2QjkzZLj`7X9vd)3S|kFwZjT2f9w6Q8)z%cLOJ5a&Xb$iLnrN9 zP)~;eewO8$Vr#%r(F4Z@ppvDp3pMc1e0T^vQf307oF3DNPUy*?P(V(V)siSGXmRsY z2$cjs+(`N_GqpQEhmx+eyo`Eed%p?PA`eS~nCnNcQ?tfGnTpOsTBF(v=PP~nWL+3| zUc?$uCfQfFeCbjkqR(vKrpRpXo zQ+p>>h;*KMuct{rhe)e%HJhX0OtM0LavaDQ4hzl@_rcy^OK}D=&MI%-2|Ted$}I{B zq`*Biz)8(T0iCnE*&B?&9Ll^2n^)-Ig}3bJp#m z!?Ip=5nyu_?cQ8}&w9#X{H@o1k=J>gq*QKPbyQ_}Qv`oJ70vT(7>)+%?b+?upIX_F zH2VbtEOH7~ODyXCgQMhxCBeh<=|VE2?1G^rL!irt?N1yWn%V+7tv!uJ1+tL5#9gyh zMShHRJRtRs-c_3anhRs$S0KBGNN#ULtQPdox3Y)&^b<{BZFZnjg1l0}bRM-C#>1m_ zwq(UF{kLZIRW|%$uhqh07RK;23k`Q2>QbQ!`loC4XWbf$ofEzI7-4+}D5PPenW|M6 zW8J#-n`ue;8!9I}r#zbRkp&vLx1mfTk@9$IS$^5++2_Va0kOFqqUFlK4daA7CH==2y7zyv{rMHG~7 zDKZ3sD+)IIe!cfQ_*}r1C%A6o``i9$=Yz%o_-tY#h|j9#bYfhI3_UEYG3&JscQ+jT z#w42Cg4BRr=*I`hmB~i&!`ejax2rV9>86^+z1_4^4ITbhN-|BWo%fsgA^Z^~BLDMM0_LFVROw@@2P^Ec> z)JwT*-l^XHng~4t*1=3s(2H(lc=b-i0t$~hl<^TWu;p68Tk9XSXI?4b`55$+KiwKG zOir^K|DiGcB_`ICbVIv7Mg#jU$+Cb;u-A#(wvZe{{-bRnDOah4h{wLKoqDw-+OOLa zxF2zgDljk!FV7b6yin(91>4I6k4CKsOGJ)3=ts(mu-|+iHPIAK?X$(42-$cz?)7=)Ij?Ws)1k+N_fW*jDDL9{T`7eW=4asNi%>T5f;1B*<1Pqde8n#c z$!^f)@R;v3)rpxAbx|V7Tney_e`-a3v!?xwm_P1PV7S8cEq8X0GNY3qZ{mIAj+lUU zmnweV1nDwRrfEvhH%~HKR>25-Dohf03gj^EU^i1Uh7*{ffX|@Od-YOCHZN^UiuC2c zEhrNe10K*AB1#i&!4FH2Xo3Av(ImN-R{J_19mc!dNBcG?0(!{PaDkyV8P5Yw!u@$UpM?81{X-o8H!o@V364Ofj^rLt9d6V>OGFvwz z&uM_k)INTib|}J;o;acIUE`aP!TrqI-NH!@1vHOr3!JV?8kx{m!0iLbTE8%0i7*6< zLj;BuezuW+jlYg5jHdRy^%nRkA-T1Dm6R!vhig5lQ;V7WDBQ_{gM&kuA+RYq#tc* z-J&U6hzvU87F2H>Ni7)4KoZVtI|sGuXP;C!-_4ln85{s5RA4AWZqRtc(tO?PHFDE< z=rhzif6l7p(BMN<#+iPxpAQ=X;)T0Fam!v(YM*ivfDovG<~Vi8(&Lm#Z!M~@s>;00 z`udmtPa3o@OG}}7*KXd?g>W&4L{4Pbfs$?5naCotUGOki`MJpIBn~K&EKi2$q0Znd zeI2iCSvN!}-behR+-UIQf{f4Y#^>ul0s=abY!C1;A-p&$BnpdTKaz-x;JHqDlp>{l z%Vw5-%^wQl;2gqn_`OWm4jeh?h7-5C`PVk%<&%Gg5OT&=4&~s)Q|-7ZW?;hg;Y`j7 z=^XXXQ#)1<%D?YyCqdnYGNwPnvzzw{!HHmE<0OGafV`w>Oo_@xs*o=sS{L?f7$h1Q zkG6CZz^51PaZKZk3)wy8n_0;I^5&~iA@r+Wqb?pVHQ0;m5~${iXF3}jMF&Je%og^L z{7yW4M3}-|{yr<1`Zs*`okgM^{ky1`=`UD}pV2MKYb;@O0Gi+0Jv2FGiXp^BKVlQt z8#9!20-5!7+i=)KNo=9?C=%OF)7l^S;1GexW@v1gJYj-k*>~9R1~C5-bAfC)CEsFk zEJeEJ@k0HJ>zs8#e*Sj9z0oV1!nR~j^Srsp08m>aMmB8#pw;Zz!v9kCV`S~|&(l{F z6d~qoV`=vyYoma z6B7+qoZJ?+U$p5pRp8q-5ucqZj5rLR3p4r|P|*jAnR1m8Kec~UlVwde5Hkp7fu4MQ zHqKp%_PGuIz+xYHU`I9(Jy!&<(&BY5#LuBBt2Z3tTQf*P82%gQN@S$&ZI8!ujPKLf z6wgbfMe5a#Qj;+;VlaVTsV%4zl9Pfjml?SZ83&lBxr@l36Ddm z!@tJ!Bq}qzNrizp4vQImq%!AR_s!221Am}(wS#!%i-A_NZ#4$ymCH_0xHD#;gml&6 zD7Z0DSiae5Fznz=m zFr_6}p9wIxr!CaQs0DPG&3{X`C~FJa&pJmGkbQ0jMoh-Dgdte>&=li~w7%c+-DSMZ z_d!w0Hk#TUQ%+E_kKWp7j%BmMGuVb6GDNiWBR&T54Fz6wozG7-WmC;~IID^odvr8Vgp6Y5spYob$DP)V~PBI`rsiYXELFy%RyiKm0o!(DB>qh zVs9iRu~PCam)F=`9P_GnR<5?m`ciIQG&=v$l0)}E7bz$zfWP5rbH$qd1Nj^0ec&@x zyK5?Fc1Lfq0q*A}jER~{))Jr*CR#ip5U&5K@=n;x9yAKZtRV8#Z#SqwNztSfLM0z! zK*`4AeAWun)KP|&20PF(@uKwEN^V+?wEq|ugCBi`GIR!iob6GnI>&ocmkYEi*uk82 z6NCzPJRF>F7cZ5D7>C3*0u=cWD6XRO&PsVcP|Xp*%zuw&a*b%YbzKQ# z`>uhY{+oOe%lVHT3Ca9Pk*gl&TsEz0o<*U7Y!Rl0by6c1oe1k%G}Zmw0naP`?d(=A zSmlf!<8 zBx*`uDrepdDx6<)az9$1Zd8>k#_SLDh7Hz4;Mz%&st%w98iaz_MhkpZ0+md#xDZMP zhnn%WQt%*N&b?c%^TA@rY0bS6dc;>=90y{m2)nGKUYk+gRT-n{;Q|*Dc;_T7h5G{Q zmxl=wRk;2*ko5Y>#Ou2-eFlfSE3{r+ZUEQiHhGk6;H)EPMkB4-9##58nsm;<++XU! zO9Je66pePeebXw)h6$I5nm1DIlC6vG$^7ISosB{QLnfkmfsO3{D2_T!83^Kx_C@1F zO{#w8^qoq=Ftg$t?nd_iNKBSh$rbnw%kBpvg0V(&tRbstZa&>~sU?dSHlDqz!Vk@R zr;nnvaHb_We$m{!aiqmxB z55&gxT;54;kmB((gnh2RgX8!=rb4eeq(%^ZmtI`AANY**-@O=(3T-j4&w;DY!C!2J z6Xl7wm4Mu6cj2Z9e$QT|@76`Cb{NBr1Z9T*2yDbxzoEiu%G&*5#IR*@lFyn;{rJHI zG@o~CqckofXLf_dAZfa-7U+;o`BN7?GdeoYo=}D=K1L+sQKh7S;~+v#1GDh(HwoQu zhgmiK4mv^7?HV<)TN-!{l~@*pcwLok)CfsM`M+cWCy+&}6pU>rKz{Dkv^1T9b4H{g z_x`dqyUaPQw7#t0;PqTOz8GfVu2S~^izENVfL|H?l^}`C8O_^2HO;}DRqQlg?gyGH zPS0K~`fs^Frg3N?14^FKk#8v`K`!wt4?p_T0}!gD<9fsXj}@-dN0l^JDT$bW9qDAI zO6D)0JS&y`(g(;67t1_p!pj97_FH?Ag+Pe?Bv%RT{J*-vu*1L*QO0a3R>LAa`3naU zIw6M(hJ2OY4C6wu?aIp+`NjH*?tM3*9!QNr94XJ6~5i6RHyuoA*;KJMJ2)Zo5BAWZgCe zE2B^ys4I$*DqW}r#`DdJhtR+gy$&x zh2;rRl+e#gr+GHsWzi`@q%BWdz5|XeROPQ2K+O(AE$Q%t^$bUuHKJH%_h07~S4QkG z&j+cHJa2^P50vo++%<@6dDpW#Y2$mPbIMfI)37=?MrFJ@*_GN@!R5>v3uwAlgbhTg z*TQtdK^4&hEZ3~AF90yHoet}Oq3irNoZ6dA*_^xx!cOkfZYZz4Dm2>hd*+{C*d-Ez zOo!cNQ45<1KvCgh`x6dacgdXu59R!%pR|hM-c?nb6bufU;EtbAVta#)T_YY^F7R7T zf2~J_MBi}wJup-=pIXc}P7ux)F{SYbu*v{#nsQT!Fzk~@yd4w^)v75FQqmnD*YGCx$Z6fkq)0IvT`Q?bJld_5FBkuzq}XA1Y-Pf2qWs;SWEZcf zZ5F3?g8!Madqw)G?RxyVV&kd8gb8}>;Xk7rxBl29p*%>>l-)mj6|&MaL#~b$>kq<$ z_>rtsf4HHi$TF^d*EkBuus{AazH|7dD0+@vLT{7Q`S>Z6g1)Foj{RD#tjN<= zR2q>KR#4~-3hDKquJpvx^SILTlmdrYjEhFJ#`ry4l z;eBxss;CEOemHMoK7dR(dgj*)fd0T9xH7ZR^hdmAUB~f|JjxI+Kd8F0l7{lPu>7kc zpOq$#!;(n^-jB}fN*|T^wcCdl>#<^R2Z?`B zpN5CAP9|K5fe;Vf$m9K-ca~9Div@7`Je2h!wL)6V1-*e*tpC)0B;jMEe~z#0Vye5B zfIoiX$@nfmJ3)`B#&X{X6mc~Ai~31wU@VFPDI58Y{wR9!jRm#jwl828(zff_;n#mNrB2Sh}Lxma){V>^Wv&i4Oi^RzF9MHVlDuy_LZ zxLNr3(f4b)FUiFK^UEF^ZVc?#ZPdZ|EHd~cpzKbubr|2g0_`?#GgV5|RKeAvFiA)? zZV^*{d&_HQb01afG@+x7csIGjY8biF@9C`YVCyG;UfmLxS{Zj#Yvrz-0PvyE{ZTQ| zhwE@VfSvggnwZ-XhDrNX4=Q*U`@_b8jEQq`aCI>OVj0)(u1fEkFi_zJT0T3>->>XT zfi+)Fny)xgM{~kE`i_5Az?;$)(S`yp0BWmg{Za`1oEk23*FOpkqyhnCKftayq ze0m4<3RU(PgD<~qxVVx!><~)~Ey+R`SJQkCS4Cs!A7e$KL!gn2igT(0<4mC*BPWk| z47PDh{c|?Q!L&7Mu3SXY*;-vjgAwpxZ3~hBy#j|Xi}|L6W^($eFU*92zE>*+M+oGO zw+qd=LFFnW#qP_Ql38{`TE`Qq9U7OTt_uv@L!NSU`^|2(xlM(Wo_P6Y68zdVC`_Tm zo^qXRmbbg!)Niy_HM<>z3vhZ{6mcGl?Htooo%=}q2BeL&Ecd;#5Nqiv3{T{jHz%@s z#E<%jINeBiu$iN76sWDqNama-_&!*Wt^|Y=zjQ`^L97Qs#@v=_k;t#)m=ItJ6i_9o z?xCSUUi#;&-~Fv#h4r=EZ9B#%C3+lVTsM4lG`v~=WsA^ys)+9D*yA~XuTqBEkjUMa z8_{WKHcWm`7i&=r_xnr*9>e@mc}8_p@oqt3^onh#cd{7t>Sn~>s@LTzw7QUyM8;!i z_@aY@!$uVqt6v&Uow;Yx(S1>PEH40dq@CWs8UbkfKNZ5#m_Sm@SOEDyLU@qOu{ajP zP~EH*M#(?+?P^4ZMQKE?p<*=X;D>08xc|~?;roK12oQAkw3mbd3~cIL4o@U)6#Zr& z79wd8Vmvf_2&g_0B(+-+hxN@wS8*OL_kwdwmF?jJVf^l4jqk`cC>kW@l%5OK>!YNh zi*X^>F(0BeSw51weO&iQw1$#NosAFHk3j9fD-q>Ej69So&%O7mhaKl6YJ|{P!FfTD zZA)cP-MWuVMW43Ege(}&L>TnS5TdvL^DzaQeJqR?DoUEo28Z6{M*Gx969ux=%36|> zRwZ@u1PY6SKEWyYdQ@g0qD%x{17Ac}k@NQ^;!rw9CfkLfL_$@;x?iF|BW>$ZRD{ z=FU~OJygSsa_BHKWb>Wr>>Y&s|L~19EN%;wi>LWtqihebNGc$j_77|hf&}!0mW)ga zXNPhvpRL2naO48*l1_T^LS1B77v`tS+1J@eaFdbS`o8>^h&WA&+4@|kfo~+hH$^^2 zMVW5fp`FjIo!I%L4uc?i_40@H`;H=*j6ZKr#~9EH>;*DO`~weF8{}ca+F$IE00b_` z?sI)t$3oHcjdRFrjfu*k<|7dIQvOxdYU9^uZ)-d3pyFh~ee72xL?I+!e%6usUSeYW zY_Um&`C+{BXpkA2v}k$(+<_vB3H{5S&!v`R+Z7r&7hYrZSZD2Mr2I>SUvA+!sP z0`itpl{)Qt$`1PFlk=pW2*ATKOcNT8`hsF^Yf)$6EMG=rfF_$!zfGwSxHcQ1T#a9Q zF_uGr2G)}LT2V!TQvdSRO&F{E80P70T}g$}aQrEMam~+-k-s{Dgh(2b^Dt;&5c1i!&NkV z!7w%X5Dh{65mFtAK>5wt^=+d{lH&6Hhuf#E>Ah+)XY6pV%Bth=*Nn_eWQT&i#oJVT zpUjF6_Ilbb1y0fHQb}z6I4{!yHUpck8!Ev$maF{kKM~ZKAG^D+`nlSzHHeEIOFcqbOXp9G$D6_NNOw+tlOP~ zej{!o?#bcWxeWp4U6B*&TOakUp=r>l?4cZk<+-TW|APkE_OC{eo6(z3U{;^Zw z$59~*Da&P9{__NG`~QojvkZ%>?b%}5O03P=v!9n#$>-O@;RcXxNUbV!$U zD5-#yl;1q>@%`ifu=if~bzkSX($2KMy^wslfsMlnYOGt|t@wY8!7)*9ImZkDWc%?w z_-6ylpfF13ceCRMp%A=`l)9}04-0lt`_GNzzAV5>C`y=tQ04{yT^0Ed^J|A6_Z#)W zF}~aVZ6EdCp9|5PD=Y01cC_|}kxmvTr$s;+HHDe>`tR(3cGQgtEH$gAFumQ4-{+C+ z1EfS;HNf$u$9q#Wc&R$42%~`xpB6E)nA4VJ=OZq?GkoHu5kN~VjVAFA_}=0gNM zM4ZBgfuAl5;)F5!I2_KhJU|@pQ1%g|e6`(Y5O12QEFkH4(74{Votk`K%GNWghxLZi z*;d7|iYfnOwdO=~Qxa20ej$!BUFDt(@qT7T^eiVf+K<(~B!LD7qbrQHilbUU{_y(h zGI=deP)3$ifJ6NKEWB-!W_vMCHg8k&_+dBeiY;QmGc98s*9_|DV5A0r-Au%H--mZ~ELayVQ#c7zdTMorMolEPf1L0iNt zQP~DH=i9SSB*e1BNwC+e0Ckn@-=6l)qhet1BF^W;aDW6jeCvZ| zi56Z+vuRR|Kv@JJGRyW(9P9hsr7QWwofw-0#EL4Y#>ZKRu0ZQmI955Rpr$JMKqSM+ zh>wPJ{7D@|GOFR{)jX8ZO4%)7J{47%pnk__1#mXLB+;iEmnyKi z<5|*#I-Lf<@&jS=n`guGNL-549J$(kqYtKh*g~wPb)oDHC;eWk2$A3g%Hzy`2@Q<-hqhKI$K1iZsYdQClxbgn8FB7%lqF9xC;g=l6H!v7bxz@pdW?DK>ZJQz-r=vJ@vWc)Ir(ykhKyXkLV4qM?X5j>z~i$_(#rpT#C+6tX4@ za>SkThC^z>q$6~@#JE9kM-3HK^Hz$pPr{-hM|Y*)G)c*Lqg8W&g=fr`zssc!Sg};? zTORd`-0Zkv1x}(#pidJXW;7icGmxy(DVePfs&wAwh38P9oO#SuIcV-fmy;wkYuwVQXd9y!rPr*!E$C z=t9Z*+-?z!^JTBX07D`Z!>l3u1c*y3Kj%#z$INS19axRUu`#(6r${18XTxD9Ug}}1 zXGHT=d!-l0`d(?ta{?@Wl z6@mJNfZKD-LiK5X$Z4p;+0+-lrA9&|lF0ua#vwiYQIWtXA4yxG%)~sC!w*e8DKfY_fF|>lVy^~$=G7Dp0okDs z1MQgw4NuEPW6RN>xzJ}0cLb=Ms@1uGWwuM#wRX^&oiSC~U(OBk_r;7=-;034ODwrd zEUZOL7xtOtsybP=XV8n~01~rRdJBbW!(jWwf`42%@UZSDDoso7&QGG#$?4jJl@6q( z7?v>?B_r3Q{(+fv($|7?1L73ewgC|gx4W7D%{Kyg18}?4>u@9M?e8$%l81v9ybtX{VVlH3tTMN3Z^;`hyBclPZEvfQ$ zjLG0@b5}k&eim=^QdiBGT_r{k7m~8uV1Of*`7R>+^f|Ph_kuVBVdLxt?_VplC-s zb3Md$&pe&z{zk|L1tDPYW9GG&+yxZm-S9fYW%<%w!a4MTNL$L3F;(In1JO|9hQS;2 zh!RTrOOTSNVSXmd%t?nN+f6Z_Zn=&d>3-zf>M%wt_mE$mfQ>U3C>o)d?`?ikF}k2i zxM2hqwy=$)TrE@P70c1VJr|)vxLKAGZyBeSMRUi*@QjMt_Rfv^&jo6fzwS-jOPpa*i1&YS(x>-Aju?gHZUzY zP{kriNP~7DhQJP{+%g}h)?i3Xy!$kWajag$puk<}Z>&XBFpzC_lyP7FHYiyRb;(H@ z`jwcj0GD8w4a|BOO0gRy$a$|QYB>n;a12s?Z-JrVutyk1XS9A<{#zRSUnQjoC$x|l z1y)}isZfzEGM9TPNmLcF=Q(=y{bKhD=haAzo-`a_?lL04Frsq(!(nxoMg)0g8g}OyKWa+NH+`p_wjM71t$7cw5QXgw^7H{vXWi~^CrJ0 zJ}g1rHF}^cJ+`vcxxB4fyqx{?ltUYT=CnWBMUX^l!cZaO4d8c|syTbkwT)ee2f!g( zfVZeiacf1dCeqN_lfqum;!%buk@fhyB1sa=|5+3>fXMrBPyEEc*thgOV8T-zp880t zPY3aE7cFD?h5v*xqhzl0VoK`4A@26OyvM<^gzD43gIUzZ8mvi?Hvq{p;%m)TRk?%@4n~Bw#k1z#On=TLgc*UZ076Jji&zXqA*>k3thhv37DFaj zLRlMdahip_H6;mlkY!K<%B`50;>O`xFz2XRnJtpJtqA3jIZlef`p3Vzr( zZ^ArBTp>ZPovP_c)2ngS?cfpI701ZrG4PQE(BvU9KTmSYT6wdQT+`jri zQ1sWXz5lrR^v=_{$f;onREYu!AedwcS$}jzygODFfot$s)m?Prml!VI$x%;)3x6zusKc!BtB=xV^tzx+XOa%Bb8mPN;E+mPmm4RhXEU%xBYD ze>-soBs=zMY75@)!mkFezU{Qa`%?#8_*Jm5ecr*(DRi&oSk(QM55*F;S!6a}IK_Iz z*5f&t3~Z_Q-3FZ#Gow^iJu#P&&X|Y)K{6eFJA(DYeS-qcQpD}u;vgm?p@m6zUhK)PNMxD?xuxDogOOOY>0~QsSuoS`j z*ok9^?Ml?*B;Gem81Oshj;APDZW9pkNqQEmXt8v)T|$-he6(5`NpV4PmelVI&buT2^7K38&8gMT3HA= zV&;H^2ES=0Q)4Ly0onXy1_+dVa&ChCX|SXV6rf^^&4nr1*Mnc2GPDrve-6jhX}<5j zi1j5!8p^*f+N%3?;_v)vOuy8a%=#B<<~$MOOyv~c`C!PUl9t*7*6pNJ`^(KAlHX5F z|2?FUgISzooKbv0IZ?VCURau+EQljGccuwBF#Di25KaLk(PzoxSvOu_S2ntb( zN)+NC>*`VrZ$uafcTX!yk?Q8_s$JPv%JXnB!)|i(@89*NG{G-K4n9>i6w}}^0q`Ss zS|k$77?GoN!8CdXLvRUUHTds)pgd@H^8 zZG^W2E%*YKA_BezSWsZ;2HKWjieJV;>4uH@SO&E378q7|v`PJUQ8K)#4S)f{En-Lx zoK50!ylM`H{o7HVQd9%jT&kflAxsm6k$RZNkx3ZR7{Ri0XswT%`T4!@`X+uHKmL3H z;d&K8eKkhGhmzwGOtBF5sL%D$5aaEN214;Z_LG23juf#HK6OdR_1b3qmx}C@e539f zI<*)yrHDx~rmUy5&V)YqU$xz_;{xb^fE}`Mr=ej|QS6E2FJMF{a|vNCZPJ9(N;O9& z+(?&~+fe)^PzwBRX%f)I$khYvzP!;CULm<>^e3j&0E?;6BHce6bcuFkh=xf$81!GJ zPw}gIq)xAKeJ;Sf31>sI0elb~kUAABAwp2NeJ8_MgHSnxo*ZU+p$-a|OUT1eWA%Ge zep7hxYeTCBR7oxuxbSWB^sQl$lv^bCniSdsQIbgbVaa@+f&>9}P;J_<;N%!|7ZY^g zE59fg`@STm_8Oa5|E;?0Oqd0n#X2t;t%}|~U@SxP>$oj{9{J0f85je5;4MRh4kE%ppjse`-Z_#w^>qPl8|N4IKqa=L zJ(>4JQG!keHVLv}1Zrfol5Z!})Ur9#RQXAV$u7Tjka%C_KO$DD$3CbRCR1ORTKa%~ zEV95qD3Oes<=lD|QEs*A=F4K*0UBE$hTbVtu_aV2c7j6N?#yG{U45iqBEDnYy(Yq5 zmH7>v;0Q%}3AXn48oD9Ev2PaAn z>}!L9!{qkS%oxWS@irL!a>`aR*Jk{f8!&4dRBL%eJ$&^bS+w5W?7w&gIayEYfqBI& ziudI!P}fSyMYLm?uw9YCC?hqztv7%aZftu>p+HJ8@S~~%LtxZtiGAU7 zN>01%-{L*oc@ItT!$TLy$FMHt+7B|h!jC6ta0u|N5S28C`p!wd&xAz~QwgJJ6x;Sn zKAOP89SRK})q?8@C}21KWU~6aC_#?MW#tjBC-Z`L5nKM+{@(HXuV)>xQl*3`gYkp* z+4zvF=1RCyRF<#jjeXN>RpX3)m0Vnp6u#@tLEQ*(FI^?%x4*`x(LTB=Qbm~Bx9{SK z0h|AnP53J?Xacp@=m!G-u)ZxMLc(H3Hn~JLr(?%xLBM;q=b6Vo3Kn+XBP2@IVa@Qg zE5ftv%Z6!|WTYdPOWmjK*)Ov=^Xj@5d^}qFIw@aLm1$Q$Dd+US8?b($e&uTgNu3r><6vCOd z8(#<_VxEazYpNs1B;G0-NijA<4=0o`$pQ_ z=uB(Vyrn*`f}-T!%yIJ363P8M>6CV3&Ef#_5DMK82Uv(Cb5E^K5UHx`f!=|;a-C}{ zEd5$;5(t`%2?4h3`TySahBh@2sTb=)LwDojq`1?mU!f9dW)bt|JP;0Acu>?JwNd;#6s0 z#*w?YsgDvUTL+}c-LzuLDPg$j+YElGlby=J(!lIc}W->hv0 z>sCyby%Dt--Hq5XRBSs(rj} zQfPZ@?!fvZ)nmOzL;S0|Zb?9F@ud{xb8VhS`&0iW8jIgZwJP*PbPY@Q04JY1J11Z*OIfLCn` z5?-^^L?AnQQ zU%sh65iT|w{_v9JiH7Sv;9A@1Q$cJgjykM^)xr;@in~lBRZXZaFqm-XyVGJFGO)6X zz2D03LX-j`AtZ=lN7@uZ4)L3*3y`oiLz#&rC<=$?j4KkA!N9}(R z%71cwQ9>D#b7?6KB|DO#AgzeWVH*B}l~4XC`Uy%e z@@fL@_wCL^<6h}bdF!bRnh}sxw%1a0KGYdPz{wSqk$L8X>qA*STiNgtv9Jh*uo{az zj3$ucv9cnR(%lj3XvySJy`V!=yvLAvk2xn|UPhqtbxCfcbp13#jCmu^2_-$$>NrmX zdai09`=XZ1))4!4;}nkd(h|G&O#g&O+u0HzDe&;Z_G_IcT0Pxqtgd&u*>;_m*=Ghi zyf6zjZRu))FyM4hUNg#B3Raea;4c3wp%h&L>kkC;S>S8nsbcsc8GiTfXPbcL_`T`} zbNl+M7r*$?n~F-mE14^$e(wZmpi~O$_YIbGhlB2iF}WKg>OjhpJ;b^Kd?ZtlB%H%4 zP?)$xPq8b!oOu0_dQO(%=p);8Q?yDC>!9prCdi~U%(abcJOf(5JyEl$gj>r1CeEXS z){1nyit3COw2LHzU_&K2&E^-s)Q|ir#Z?s*F)f5zQ)EMvgZd6upqrPpfI=(u1mD84@Kl|DyX6J^j0e{w*}-xtp|R zt}5b1%}ulhI8B_2_8^$<#&f*>?ZzMmdsqs(>GV4-y$uXST{p}nlwyB-!Fj>;QqgZ3`^x}Y1eJ9*!gI^xAL=Cs>yLb`{~hN6wi^SG)Lo2w z8SyzewebaC{*Pm~o+W4a3H}_mWx`O!JeCr3UN(;K3O`g72;S;qClNB?ZhULN^I}J6 zSZlT%F62Rs8dvy%@#p8d{y(f>=mbJ~OKsPGuAT_xCUu1n)JbEX2HwIK)&aIKZ_+p}?0B@ECP0X$iA2F3rJGz#o5A9 z=t)aq-~FrVo;~yYM_nH)nGyo!5)jzR$XXE8aUF=pef2&P&|3&1vb`u~K26GyuEQ0w zicn*RcYc46W0uuBwgRN{Csomj^QC1qfaT3v(%y_ph`ES{zv60<+9v0)gj=+9$N)&A zH;vG$)R97`FVf?O1doPHaoUZ2Y5RHM_IxCZLCvUPx9zhp7PI?s!McYMcdm%%t5CJC zu{)P%y%m-3>l<_JLiF#U&o1&azgRy@fLq!7RxS53qSOO!{iV|!M<{JV5G|$6?XJS- zP_!&wk)uOl4u4u(dw$CFaYyPo$yps_T9Hy2WZPibtTedS1FM5-s4WT@XS<7BpA_03?3!($(Sjz(y}=X1HJH4m4$vnys$1s9!7a zt3VW`EYc^sbP~Ftu$=WzYB{(@nBq}FK0hR;2gzU*aQSuWAd*9(OrvbTYg>Y!#MKxs z#w}yX7crEEBO+JM9sQ?~;J-PVqWc4ie>4Me&coeC*zc9l-9>eF1X&JV^S8p0C;Pz; z_5og$%&HhdbhKXpmw_tcA+vYu#xGEA?* zF!IOLsYS@J#c7DRrpqs-yM|e(9m=Fbf zRAQ9iB7y)LYfo-Yl4*45&YI|=WZA3tY7j`<>=W9QoJJs2t7#kygbt>-ZQs(EzCxYU z^F&0BCrtINsF3V0?LODeo9**ywdt$&wGqr!(~A-{kdjeIz|+c|!!H72bqLq@bOsfx3$9Qrn=Xv5pW zRacV1Pz;Z@io#`xMs5xX4m>ls%s!@9OMp9+-n)Y_oxAce-A>6-=`;VC5c{y!Ar;Hm z&2z>{rt*Xu!zOJeZ9Pw0>1&Kn=BmF&9g^`C&Ym=(;+XilG8cK0at_3QE> znxo(F>?*=yP7omq3poNCdcB)>5TckG0FO>@IsW-f{C=K!jj)(%*DgXgNK&i8)}Qcx z_-?&H&yQ>>IT!E2-E|xEZ!eh>&~zlNR>-l$+LgCvwONqEVJhS6R2X`FK)r?im{PKv zceP$$Ydt0qIG@}R1jKvfEpaOzBQwD5jSA*^l!qXL+>z;bF)<&lo)%xI&5}AKakJE< zLA&c|FIkRJB_^|1HL^CHC)EbqPCGv{KKg>+y&W&lZ^r3yBeqwM1 z9~aIo7Z+Q;K8`S2Qj*=v*xBW-7Lis;4ZP_3#)k0WNjU>TB}wP=7nmU8;AtP3x2RT# zV}!TDE!=}~NFM#C@cJ~C4V783TFPi)doXBEs{dbYRr~v}VHYDz@*us*beK@@lIk0N zF;jg>b)TEmeV!LY+mwMqOzXgwP&T$QT0aJB&!sltcQveKsL#~RXz@$!Xw1oNbS!9b zV#58lb+IPu+F4HI=VE&WHIDcF`E+)De)updoKy6W)2(JboY8Nv!tFnU4+_Mqf5xA? z3C)fxa^g~NG|`h~=rL-CdFO?7Ih5dXS`&2BX_n%6JWg?9W8u4t#el2&I2myNYpy2* zIXsjE2^Syjn)VoRhVDngfS^Q-i$*}Y63~3=h-3Ut-Ho3;H>b9o%Dv#ZAdWM`b~LLl z?I)?$Ct>to+&Hy{Vl||-13=!d9!OXIFPO&)j0AX~q9&Ijbt}o$7uGV(>TU z9>L8Cw9i>KxS~$SCX)I~FAQ9x+dFc-Ooe*av((dnQksHV4n&k0iY5q>RcX*sZ94bA zN$_?lly00_@I`@2QI`u>(6J}>KiAw^_mpQG#Qcep;(n9VSOcFwA#~4!UR0hVZs6ZD zRAHNZWLQXE4M7#$`+uQ63^4A$^Pf&@cMlYV=a#CQqs;Z7xWr8CCqWDXd*Hj4h&>hx zFwRFrY=X7LEb0IYSFpe$HPxogBIPQxBgjYh93k=fi2fCmK>4`Oi%Fb2Cu z9LF^?EP;hYr!Psz@K>Df&**fEIdES_jNOwtZ+tkK>{UwqU zC>O>gyjF^REU&PO7Zg!^dtH66Vr1lU9ma&U8ydbJv*Tihsy2D^W*MdJ;nEeu1Ra9}Mu7FU*9?3mNr`}> zqj;^k;&D8Z7zIMw-u=kRxbvR<$Cj&cv`-iF&&-2X@XnruM5u{3jtzy+vBnDQCC(t%zybX5*7)NVb2$;oTX=O zKj9JX?(=ENV>a^3Jb&x0SzP0!e;Mo(fS*P<0Oi>U%Pb3WY5xw*VG{T>woA^?VSug?`n>dWn*lW7c@>Bv;XpGFylp zvyNU9Twy{L53k)&R_nd^DZAh>=cQZU=2F4lP`;D+mF(Zl#m3M3V}au@$`%XG0H`t7 zMqyY(7~0V;W0r2qp5%o=n(NAef2ZN&u1GUA2)+*Ldia?*0jAx1@xv$T^0-yTSSOLg zL7W*wn|8C&F9O9#e2(1`;dl^YjYfbGrMZ%d&%rYN@3h?MfH1=yl0hC93HkbW@QUMR_|2hyD*Q~AO(JklB6&U z&SR{AQABXEs>gJcd5x5UK$eEuZ~7YIWT68G%|z0=66pqUp|c&(tpumc3Yh2x1mpsj zp-Rvhv`Tb@Hpy9Ae8Aer%l#&n#w*3lvOYy-$Esi^PQuSl8}^)>Zvy~l{^W1k4%RA^ z{+6S|>auBZ^^w2Wiyme13eaa7lYrhfK=V6mT~j60uOUylUFk5fGofepFvI?-Ga+q1 z<`(3EjLeVvucU!X9}$r*#qifpK%xvjTIivE!`#BGyMX?}<)Xq<6tz{g(ggw-)wKA7 z`bQKVrAfrov7U9yw(euFeehtbfP{Oirl%36Ok&Wpm*}i|#&24*1X4Fsbh<^<4f*#u za3qZVmQoSh^B9GLxl-rq?|{*p0bBhS>oc0_^yO~5X_Sh`^QacI=@z_yCp@wmWIlUK z<0_e$))qf@j(7u>9OWVwLx1Yo$u_JCx{Beq1=MakH;s!J|F6^&M*C!>FsQ2z7Sa^g z4eB7_3*vs5L_c1rzMDD}MxvNgpMgrBIq76gNl z8ox{>pGWZ=HaEw78fQobv=t`kT5N{cnvhsznvkLzR8^agATH^~?6{Jmu7pR!XpP8o9HX2=SLpAX);bbb%72l1<7YN(KQGX&BIhLeA$jaV^|iNW z+(AODNY6*4w>p0($wzk~a00CXSs@Gt;h1N=URL-IF@`cW1wD(co>YKarsSHH#Rqi%XOM@CB}1J&+I{1AUid2nb?Jr#bWdeJ)O2gaBh~|Mjb7DAy&O4 zkDRHsM8J3rmMqtqAi8)K==-=7M(M4<1wgL_(nyH$tKxX#2x7Gss6mEKTvW>dQPP9CU_c(m zo2&4xtczpIZoUCN6sX~K4d~WG3LGJshnpzU+>a3~icvMd{&!SUy6)6bcvWktj+bJl z=tz9SCEEvt=?=|1X4IXE{+Bsn{`qQg3VJVJzHxD@EXCFv(RO*K`rW2+JT1@QT;^^7 z!DIlTf^?nKhM3F-Yr(ieBL(+kO;lD?w?>EqUP^JX&caou2}Nk2_Caa3i(3I7zT6y~ z2rG_{@ipy!bFLn4q#2wLb?Q@EG&EE|=Y;&#jx0uNN#!#O!Q=HP&?rNWOsDXVWNlZ@ z$+I^|I=pvo%DcEqSuZcsmwx}GGgEb(E5GIwNu1g^-mShY;6Dem!mnM76fQ#^vgOEd zYUxCF$jM2l{Jpv-fjZOAB16uGH)NOK9)cgK$g@cVn@+3!F9RU~F4RAOas{#f#k~X( zyVwpvQrG-@!#g5`j!DEe+2aSQ5-lQ@$$mc4B`kPF> zp*pr!ake?uMZT^mgH{%1kCTT=A^BhGc|R`R+G03@mBXbR2*W}d9j-!^qhQCW)oBf> za&EdHfZXCHS!)SBFHGt-N2M2DGfRDC#Rch!0sbcDE1>bF1?3`|=tXWPMPfH3UYBOv-lvWiaXV5V!*j8${;u}kxLqB>kU zjEq~*-o>Ck9XK9p(Kd?L_`siVJN)`z6@NY)zIcm8id+|bpmV9m;`thLaU`1O@rbdH)rR7jnz{ zY6mTD2=$QEyxPk743CxI8A16!_)1GK(_!nU5nwWy)nT5aKMD7prhk1ujI=eXUDR7& zLf5*k{(9^d+mA$BF;mC{3Y;kM5y4Tn_ZBr$lg0dTOk$zM>Y{|_c*K?H@86d55^lGI zVZ}V|)nUbiL_OMz&GoPHUC?^1jCYYXH zJA-#Z>mF}~X2Te{nP6NB!rz0Ei$86IT8o8QWXfx+Y|K^HQSeHII0#QjzT<{!-ot86 zNr^3H%0KyQ>ICcx5h0Z()PGCSQyzk!C&cP3%i|{PceE-X8ksF=?+dO_Aj*b6FVZv9 zhW!1pgiEs(<#8<7COInNiJGd1P|FNWCSM;lcs@?O7R4^qy$%rd*RA20N@xJCzo=JveAZtOLKJ}|zeesvU2*K*R ziMlFvaXIJiGoUlVZe|&bWchR!T?%t!iqnq>eNAB(?h$xYS+`RSroLM=LfsS+-Tb8K zo(Zzu(n!~!rsp`RBp-GM9D4%Fi#6HjQq@UG&Xz(k=OlWQ1{~Sb=*EdAaV-2 z`dbDjK9MK_f@Oun*LFH;DpO>1((dDqUtPfN2(}Ky3_w7m9mK9!5?lPXavpY# z+LKpTuW`@a;Ntdp6rV%QsxJHMQwZ^{FGEvL=~FhWOUG&I#Po#^qg}HJTJ@7r_s@g@ zYRERBfE0Bb`>Crw+}35H_0JJMz7O>|LfpRU0DDXMup~n=*g+rFfN#sWA~+s*{~&aI zgUtg!PRK|kU%%=P6vdk)jMC}55G8vDysSQT9fbuoDr~lXZ}+8`rVwgeQ=Vl%+qvU| z^VNCXqN#rX2RJavx`3X?x0N7Gv5)zYUtSEa2&Y@Wul2g|Q+^-3tOWjVKyt``jZWr5 ze={XaQbS9P$%X(O4`v{oez^9DXda+fl&}lb7jpm<^6bje*d?4!JaQs81hbBmg@!!N z3#XSwDPm}6m>)x5Bc?ul-1@exBRZ_rqV~p=by^(nR(#9`t9L<#7bsHT{>X&B9LBi` zz?1=b@H$5-q7b5~D`?o%2%UxHiRLq6$$>@HT)`lfHQb!}Z(&5081l;Xi7a%94HC20 z%`5LUiC|^l8lx3ZXdv;Bq&(clk(Iw|nz0`Y-+8ypy*+C}*}vVGLlf#|p!$hC%OrIr z^Q|3`;MpXM+;U^X+#r+XBa`dqZ$0#qqJ)?T50gP3B)E=}CKw$9kxdr~ZH@hL;vwT& zcuC`uIL@K^-3GDs%@P*&874vq3;R5}jDq*?>>4GVn7`6!Ba|=1BiG?>l{>ado}@m1 zmrYq0hMnD`T1Uj3sD-L$O&5ZWov&dB*+`Klz>+f;cY=+0s|Am= zYU##n^%1FI2$n3k{tWctcG??HPHP~MuX{|3+&e;)Af3ojai>N1(D^uvAZUEglgWD} zDz^N7Rs1XTHfH>WkCD+(ljoE#$KAV8Hc>{UN(JfHnVpRYJL-Uf=H*5jyNwJr{YwMU zcSDhIr%({FMN3NNuR@9;T?L-3qq&xH)Zt46(jNN2aK|G@MC@tJRj+wZK5K)E_p5{rhH7*b(?bY&A)KZM7JZi)+&o|&>!7Ds);;BG+H-6 zn}cJhRrRM0CPyEiWQj+FJp*A3Jk-<9Xcv$znZQYi$GKpYQe=r?;?QGYuT2q)JD3pg zq4k7}MV>hPe;|p=t-{NxFPJe+4GW@%5u{+G0#lY=DcnzedP;R|4s-V^BB){X+6!Uv z|IMw2$_)&rjaS;q5~o9PeSY-Z{`;RCvi`N({41ml*RmDFUsXiq6Q;00jzz&kl`s4V zq{ww0QBVKqbmP-iPm0QN>Fg6miZ0sXY}3!carhHR1$CDaaC@DfnMPC)XXdq)Vq2|5 zzO=hwX|)oyqs`ynV-$8ib^AiR_l47@i#hRGRW_=VCnL23N;SSBECfdiZ)qR%M57;I zFW0>ZkT14GNrA|TM6NfAzBsOydmKYz6bip9+y8!nrEP+nr5n>e4M13wKVQO)nUY{{ z-QE?;TOF*%@kkPtelsVD*coN3r|X$)c&s8>_mW4j`|a&P5jXwwXDM)g{d%ieBJJtP z#QjsoJa^Vh1+9n}h!#cY)dwv-_KVX>oAdxRhYD&JL0C$_@MpyS@N)af_fR!bq7Qz; z&Ua?ysG&=}4s;(?xm4rj5vy?dbt)j;g+Z5@E2rnq{g2%}6)>(XF*K(sl_ca|-NJ~% zblkDhWE!vUr%9A>cOaz1k|fM#^0TUL@VJ}AX^ilawkJnC@pju*fH?l>D(kCiKWZ89 zyN*%DJIi@R{|}ueYeo4ERr70=tLEu5GwkOu>a+X?E_q5nOR=`iiVDP3`*#W2 zZ?J{N0+uFXR6)6$#?nD?ps!L_PMZog&{`IN#$?c~_)kNs%_-+1NvVaU$Xn05uM*&p z1}VW&LD@A1MtnJbm7mK+RxZbD`1u>Nhr(C^igKR|ElinE&<~dx9+1hF++Try6# z055=3@hB-taBo`fce+=Ea_-GVysRMYSn^va;d=~GzQmRIYy4v*@XF#_w_u@;?S`+? zPxmjk;%cDnwP6io=uW8+Mc_F}GEs)_TGWD;Adyt)mhfJBWi;#w8TDK>;#Vrx?E`B~ z)A?*t9zPS)=ZWe@f^Jd6UexOh|A&~JG6m|=p~YxovH`PFSN zyFLtf&o5yo{=0D>tl6Cr#3|a$;`ICfCjQr9@Q`5iI-&^pbN8PT^uHrY6Y&)IYBKzh zA|S8=6|*38bvNTkDFhds{U5CF@cX=7nF(`qlJl%U(M~(TqxC>~FOjCy4C7e9tU+PM zMhEq&_OBH61-e}N>L`|i>g^GE%Lonq3{4BwT3UNg#EpSO8KI+a^@AJ#uxM%C5IrzQ6_!k#UDZ^ zsw3{U^+fbN{Ooa@mSsQ12aiI{k$xnVAX%X;Ma1vh}=J8_0 zP1MxR9r~q5$U>Hp9RJA28sGW=f5ujai^9N<+CodlCj}(RlEJza#kC$RW#aBzL^%g< zf8?c>`-myHsh3fs{S?fvp2H=TXiefHz5QB~v_M;H0T(J)D!ls}U>7C}565w;{)ni@ z3#WZL{Z(5JmWGPR>{I8wW{?}WJ zk82HkyCHZ+O%@aV4O#t3y-+Vs?v^p&hw&%b0&A@jAk4`XR+3GD}dkBcn z4aEJ?AeFh2EQ;;PMzMzLWW10F9Uc}v|IO~4b3AyRe=iq>TQEPKseCU(P-Pw{fmN}= z2xbuI#YNYk!)6QjuUCH`hM7ps=yS>a#0l-N(xDfTHrF!1qk4f4s9D;Tvmxt*kac5F0+quw}(7w+P+{la_XUv|Jyq5q| zQK7XOI6xCb-u!5a#F7W?sN~iE&nrW;FxALlD)Wg;29>y%xccEuGcBeFuA#<%B1BNS zg~3@w_b{ba$Bxf+o$J|q`0gX#utPq^DfUc1K04N+lxP8F$`jNxvAh$ph)F0rf1?jy z=(3yoo8FfPO-NwW_|;&5KgW-Xz&B@cKC!GpfQAWO=-0_g)!oFISvXs3=L}D~;k!tk(grX6>HL z<$qjIeP`gN`z8(RF|*Y=_5ZbNe<*eyMh#}xn=BO;{=)wYb_7o=ivL@3{_pXu|Me^c zSMXT$Is6}|K*Qpvz2byQMQwC&s{iK|vfsHQkPodeZsZeV>qM#bX^1TSk{ET{LiN*f zPy4_5a4HA}LZ#621<#*L+SdePtx&1`w&8aP>(ad0-uSTNsI6Ay_>~n34f+Gq1y4wY3rXj3 z^uT*PbTWx3@(uRULI(KBdjtmQNY}$G>qW${L9g!fts);vi-e!m0vrVpqOhCEYDNDD zI{8_He5VqI<@htTn$mls=m-H62>Pb>4z|cI_=e@bLy1PK`r0RO#HIWxR}V^u{NXmR zP^`o}k#17u^q!gf>vIWEPHc7>UyL~*;4zD)Pj&?I!i3U+M5l<%(1krRYCQGwuD`0^#~ zi|@~@$Cq&zAdhXaakmx7OB~x}78e#?XTcG2J>TUWup9XQ5Nv{>2bUeMaR#l9`*t7q zb~K$gcC|`Fdc}{4_zN#-N$b9AxOa536`9N(8_Q@b7ESd7w&c6f?BLOlu>b39H}Cnw zyLmTwEk{@og1P)AZa0BhQtOoL3EZOl;-gGAYaf`$6b`HRJXA^I)xZ-19)1hi_U>;QH7X-aY>7OymqjS>zSoR~ z8;M~TNNUMZd|!9Msb1V7OYyGY^0J zbCt-_=X}dMzYsP){`TsG%3{{KaF+HEUDwz{47XtCe^hsQ4uuGLH|K~@dyd?W4&v>g6Z@g`(>8@k3A$o_ z#~7%AI;tPKMJ+8M&wgIE*0Tv9V2so+01!wfHUv*!mu0Q=cWIIkYpb9&_(3t*{_SZ_W@-|n9MGCSc{{EO?Jj#Hlk(dkMJ+YuZ#Twp{ z(L_l{7c}F<$O0d==p=Fe#D@p`_rzHw9pPWI5DRb?!_b(>c2~;2YzL zlQNP56>meQ1a%wLrj0roeXB^N(8<0ppOe>QS0{VmuJ9d9MX!@nhFAX(c2lZkG2Vq( zJ}J{b_}qtEgWTX~X=XJZe;1K#S>hE9($Oh-EkfNtvu+|NCzYF~dgzrWYYWn#N6E{2 z)34a+;AecvZT@uQE;kB5(S?}zmSsR{JCjP2%2WuT?W zkG6aaG?Ifb#*m9NwIjf{c0U9$IsSSAB4GkBhMUYEH%wnwii!muQ~DcG`xnwQ{~;}1 zh(b8mE7Wv)gM}`bxt%O9%6fw%+Qg47utp7sxA3kQBMP^Oxv8EpGrMx1^y&bq|Eh0g z0Qx6wGQz&n&|}sdY*s&3=D^p-~t$zcGcA#M5-Dk><<)Wcgo1!|l)+JeIw z_EG~(>B;Ch2+bsy{l+co#g)tB{)cpB8|)DCkBag}YLpvBbWshMjf z0)-u%Tpp>$gj?w#}Ng;kmk>7y0rHEZw_ z#peu?v0DP5%fr^UcKyFT$OFP2GgWmHO}}>OgG!&3GX2CeFpPbjr4z-ZbBW?J4j} z$QXtm1dmeBaCxO|Y2+#ruwR**et=t~=Oc>UQug{j#qf7tSgAX*IpAf8q|j_ag%t+M zvTGV@D!`dw6t5ZA#s4-wJtx5doecR90lM!+o`$a=bf}MB_~n|3)o?f681U zHH*LL6#S0{_m6xkZ~St9hHv1O+n@b@oQ+l=2LIV@YbR47dqz^b>L8ALfZot^necEN zZZ_4t;a6s5&b#J9ZQK~S;J4G?#9ICi&A1jr{e&|}IT3QXt9h||p*(Stxb~7)V9fG3 z-7bR&qrDhodqo7?cA{t>(>ugIHy;48$nYV8GKlDnu5E^xXv0LWpz%%lPuJ0vS~ z)!<6%(X%b{1HQB2KO$TqLbZ3fJpdE>uwlb~{?Z z09w2-KpAKhHQBpQb9NzyEcZtb@7{wJ5snUAuVPuN$=|Q5+k|)OIuuM#06rAH}@SDZb5NEAl%GQzbL#x7`j=#CUDKY;ajli=hiR zPl>=YYS-;$f86+HWmvp1f`3G>f=7e)jgG&5|L3g-Q|2NO*k{8;^K_h}03qlL8QwUG zEJv7Qm?|J?O20VBaR3fm5ay#K*qf&-Z-h*CPzg<(B3clnj}xH0^B4ONwN#kL+fUhC z;0m%IKlm2Pu!Y&M`i|#wETceidEuFWLZTa~@6>8r6<@m0^9|xwRqvEaMs>!DhUzud zQKFX>kp#D%M|ru2f-}~9uu?d(Gml(U`{0ciOS@hjOX68 zZ$jrII@WHc-O(P$-$`5_M!6{BThHJ1q$J>CZp-aGYd6IO7Y!+-P~@B@VPJIP{m3pt zPSD9A;9?Ikxc!q()ImnU!%|$KRVRN1;>?@1$_&$>tPqK60wOMnHSCdi6#U~O07|k# z0R|m2lR|Zi@v1rTK9MzychdnrCyC-H0uZN(Cmg_)R$>=}RKLnYtdu}D72ziqX3%Sp zi1qMv0x@if1+Z|a`UUUKIbRfTrxf<#yaBBeDP|BsyBGY-_^Jm?ue=V^{reA}%DEdX z;xuN{DlrRbJO#si{&kW_x_@1gpeY5ys3yxboFh$I;b7hY4o{hl*a@r{W6muF->G~R zMhyN29~KVUW?Q1d;)uXI4%9bGFzxRp0T)Lh^_mR)RZ_B^N=mZpT!KU_h*eS|>d>mf zwrP>Hb(uw!^($-8rYrtrO5l#G@hj#LW&P>h0{HB#7?e=KR8sG-SL4%Dqj9bfS~J4b zEIilG8;_#JI{Vgzk>ZbcNy~6oPh{zr80tg@NpQqy%2q^Y43hdvk2rrBUc#29Bc?8z z;UiO8u$ft<)hd%Re4KUivnlj5hOVLwz7t2J8gKoPKqXslEDiOh3JM|*1%c{hNmiFg zUH-L;0bx7Z@nw#Zqitz1sIyx1hP9N7z~aY=wBa29eI6&_wvMiOG z)2t`I>}P6Plj!K_i1w5BrW|cK>s>8O{=dqna;a-k6A|>o&So|YS&6MzmH^rUejz=A^FQ)Y;> zE6%VoqS&8a+%eO558 zzXvR7J!f!MFa3lMRmfHOl%zQyFQm(UzOw=XMT{g>4dur%z8SwhAldn>3ARHYA66@iqt0w;OrB6>Xm<(la&-HEdvRR&I;r_ z#NU$WQiVo*KxWnT7O?1VFJiijPzOD#k@}DMcKcpIL_yr z+F$|XA;2Cq^slQ=$W90aD)ra>mocONE!F$FoKc5@o&5X#8)FizOi#onCK*;3Atk1? zWb{^^x<;9~D5)gG zmfksWDS$y|b=2rsd9hg(+72gyP@sAbZF?vXhIH*v=m}?MOVEB9At>@0IYjf!%?X`f z*zMQCy(R0*+6uoraY0cL53NA#Kv=SidHaiZGi>)UziS2mmOuHH2rLSGM8ypR zu5bXYuyJsB-!k>RIzjACFD;5K8m2sEaS56n#Q{PLHsw^Lx_V53FZ{HL7= zitnI_aicRdBkQoDfr0z2qvzH5rX*gTzs&ABJd}YkW=5b0&55eUj_nvkP)G4+d8y9~ zi_)ZLiwp*O3@T2?ns@mCE@y-poB)1n2emG?_FA|)u+)3=T(1GrO7US#>Y$2`yQb18 z?^sR@oM!LA_7_0#ciMuC`}XM%4)XUU)Ym;rB&fvcEn)Tq3F)@2l6&M~5*1C~%jMbh znXvq(tzuXjv(0eT(6$5zB;6D2L-d01dTu%qc~j9ky5rXPHsL2VUEEMwW)c`5frj#= zAgGxUap^|V#`y}#GH~Ei$DIp7mst?1eUP#! zv=yUc>1OACt{jsx_YIV4ehV$LN(sCU?;-Dc0`rV(8-~QFgN%sGuv9D=k?>Y>>}n83 zE*V9z6MoJSZmSzjF(jV5TqUGl`+2g;FzZHT(W0MEn3X5pgGr+gVD0j$(uUaq<#7BR zjB(ZIvK7Ov)ar55k03_knE=6O~q@ezcR!4^8aFN z!-}ZTN(dCMAk4}%#E-3{OGqsw?vv?0Xw5|}je6jC*sbnPq=bSe%c%!F-tek?15YLn zA+0I+OcfBXIESHO(4=KoaE>UH>pEWeFc=rwsKuGgq%%O?xs|81s0JDeWO-1sNVkW1 z{TqM{js@-Yuw(Rva~$y|cpU|hYazK0(F_N9%~O$S1S-RXno^4+^p*_q+5kB6F%f@p zCnRMKX}G5qBB{YIDOK)s%MDARTS9}Pb8B>M3F>ZdVwPKk1G z=+CG>gvKr0N9s=9ASU0H%O|a|qW=$@$0@xu&Bp5bxI4Z$E6f|hUV>3p(h**yk`v z4HNvJgQp;A?98WA;Sm(F{}aCnk+e5Mt=m;_X zr3Xj25U{~CP~M`2^Wnx=S3x7>K|<+4Z+$$uV68Fi=9?CmL#LwwGM7Xw&35KV6lxaP z?GGLTC?vG4gx_0J_EW1`aNyDlCxG%rI!1kPeP4yyfd01d?~neC26Ebz%D_K$eN@^p zk)j1xy2<_67@r_B<#*)(8^eI^>4+}tt3xDsZ6t4C{yz%I3VzN?BJa}sKr;U zHnvh{+q(xxL3IBQ`g-j}2>_MM( z8dK05IoJpxvQS@o;hjgCB|fDh=faJYAml6iS(?c4M`5|(%GOWhQ4V3DV0IU2QTB@e zcK+~jD2;abREj+S;Q@8pCX)}R?`XiIF!CbCKc`h6F>REy2pNi_AR(Y^5U8WXfXXXF zs~9a4HmmqHmE>XZ`@tl@|7+2+Dt%)}z7fdifhsvTM$}^iD%te1>@)PMJrx+W0ZXZj z4Y2FPREm_qioDg`jFc!M6{sk^V?P_G$79T#vzp>9Vep7Hmy$&O6?66{;#9e?E zdz+W#rqL=8jrFplRt(zva{74!t2KbU1Oo%f7ecFs3&BziLVx!3@bq2mA42g{|q7D18g{!WnIlADU=s=6Nslga$un$HS2``q=NKjxX z=$3xQRrQ0CG@?rAc#9FNsDV<3FP^H?0Uy1#eK;1uhVs1F>Z9B|y5CczXL&Sdci2_04O5B+bq zvxM4t9+5jtY$79at$T#2$dusZ;>)WVD%TxO*cn*;7{QMf5R2%Wp_C0*s!6|t4gk_p zk}6NyYcNlh-RVfJ=~o-}bBGUj#5xeX^L7Yk>VmU3*ZV)K!tZP^~P&C4@pG5fT(I`c5Mr{_ATcBj2e$y3c_{roM z2exX`tDDXskFWd+SfT@SW*s^5DD9zI_0=H+@v@EMV30T>uO-Fyfoo4vqzR;hvVqQk z{Bh;)-|6fnx}ADk;mj86-YxZPtayI4kgud^jgy$jfsK~so(6UitBC*GZp;v!P{MsU zf_{dGvhijhN@j>OvZ;)z?#d|9SwknYAhBW)D#FWc!(r_A5bLdo65y;H#2Poz{h3WGSeW)dq6@ArdhWz*+n#eQGZnfzEr@94?fex7Jc7#vO(Ae5EjShHIy{TsnMm>exO>^{y&`H#c-~=ycz1OjcJw>pbR-QmMZh^pYIfVYq`W`*I*# zR6Tq>xe!s&;dlZX&L@~6NAkzp`hs-)KqicqQd_@`f>0Zr3PGLXPn((p%X5v0v4R>| zkaW@yuo`H{VZx9J%($m2fn#SZQZ$cdJEF5jCF9)JyKXc|56Y-P^9Hw8a=Vok+m+R+ z@~5j19t-!2lg6T)t>|!Yccghauzli`V8<~Sc4C*#Q?}VvZ}^MB{6sK}oJH#@*%N`j zDJCG(VZ+vdKa@TCC`LXv7KZe;EF|ipL~*R{5kqkc+8Pp}j6hq@yJ*-Ww+`c0aM7woJAPOWg^aUqMKb(cp8g3}!I zAd%ryCMk3YlYB5DjH$3F}Ap0EyOltf`|!-e@{a*}Lj zm_3=00B?Q>;v%-O&_Eb-Q3wpE=BBM)dm55an^6vW3U6$5_LXVWw`O{F z?2La4Pdkq+w-|4y3Kb6dW)+l&gk}7xBl=SjxTm*An(-jT@D)r*TBKaz%tZd8Sa~Sg z;_p?PhXI1u)?a0baAv&h%olptY~sel8-mE}L1lr&m?d=+!3DxTV-VZc4mH3wK_tLy z;>5uhEj?>YycKWG&DGr_BG5%a5UXtYO)k((p)XINqd%-RvBIND5e$$&Ebw9TL;=kR z+=clAP@)R6+d?Og0`JSmeU3Co5taH#6^cz}+GK_k3$U7SBtJ^2?viTe)h()(6BhM& zxBdLFLfT0{`8^$Mm^|0ARY^>C>@z7keAySA$z*S#tYyQ=w(wi;XfNY^YyP_4T7I#HE#;!Z$}JcT+uDN&rG!Y&Z}OEsW`u$J^oPUw8NP+DsC& zfx#%b;1k`+XIM}^bSrtA`yA>U_YmR(+Z;W|R&x{B{GnZ51qCvqBP2h)|uW z1UX$l?`}-Q=F5DRlBjf#z!GYRAG0ueT_L=rKaaX`bYz52sUgFPY67R;R95DzILZoX zMXMa0P6e2yk?_%*PMuAL`+bg`KK<0{W+Zi8gVFXZbh3Ny$F51e6}@7-39J~PeewF6z^hoJ=c%TR*SCXBqK{d7yU2kN^jQ3*ES#u+O8 ztR8WW0+Pbgp|}=9pKjFhJu5HQBIpA!uBvMh8Yklg@$};XckYFrS>BbD(~*GmIVK}| z^M=2~c(}Z8@}{D?j&Z-nX$Zb4v)Lw`&O>JAg0H6lLxdNp67x59?>q7T*hFwPoEFM> zd_Wg^w+rFD%Xfoq%;rU5jUq8?*G}(OBG@0<0%-XBBD%!bM}RB&I9H%xNpF(#ZBUo; z=Sw=|4Z9aiF_yswkjNmO+1d*aSc?{9&W7?fN3CvsU?L{aQD>^pT%fIKqFp$-6Z7Fr zvMxzC!+DiuHQ5o6*Nv8W|66fbO}GnLd6BSwewfzXk|K^+h6(#@TNCX%+9*C#+vvx{ z8e8kl@AI{O(IF_6A)({s&fTczxxwYT!ak2o@|e4!M)uHko>aum3k~Wn$r8s|1C-?AkC9z?YZHr{3?7_gtN_?Haj$i9E- zv*%z+sFb^3`6?1FPV8&GsGP?lZ!u&1ka=lN~RFt!aejqXNgC>!0LC#6JM$&5xR zY9?$2(*WHKvosV#hN6{6oe+$Lni^3G3@?d+YLXLDt-=g{e9?(7Qg!WBVN^F|JFj>Z zX0PZF2L_+w(O3I55L<=fG^vk;t4x<>PADI<#Ht<@=(~IuqY>w2$V2b3VS!PZI#3#@?+nOtF^^7l#4Xk9WSRJCc=)mG5h7dSFKW6| zh9uLahwgwfNF0$)s zn)lUD{6o9cmqck_Iz@T9?CBa5*Di+yPU+@+Zqu|~i%x&4*qO2~KRg&4%}DkcHiP`K z=Thw>J1yx8s=?F9MKu~+{b6vo@X6+~>`=)1{dGQ>-=yIZ7W2W&(tg9Y_GXinncexi zEYb$ecbFuP)~zJBl7@>a?^k*Z#FmgCULnvDN;Wt4GE^=DkjsCkyp-fGiT>!vlN3fD z0=?vIuEXIcI}@N29YWWK>e!Io=gMjJv*v|pPQW`Bt&}?m(b5LY>$#qHBp(Os-$XH< z(i-UxrV`q~w|41W?$iIaYS#>XKBDbcRuURt(@}8x^Dg_m#U)Y;OzJU9El0!=;wBACeeM7hCR>1U^_)_Ywyu-Ef0?919a zI}RTZ^*L9R5?6ZcehQn&&9>>NKnPNWC!0Ayx*&iCZAC>)tEmrDuW!7UG_BvZj)?I1?2V!&fyLh;Aw9j%-8lYx}(eP?KK z3*DHvz@KT-QamT(IXf^sqoBl0wR-&H6)#P@T4`Oa%K!mR7g!#tU_HK%y?*WN^I6s? zIEYzG#BQ442f~N4qpp70wKZopuKzyY(%W->KQR-AZ;*0Wkk1Ti*WnGjb?aFm3d41P z?w>kYaP`Shz=*nvBNpA^ZG z@d8hu0R_5i1}r*=WHgQlJ?^zimoFSNtU%n;Wr06fbAbh} z`~^|-YQFN5*t;^?DEX+VcM*eAzWo4;Ug9v3T>|p8Z|MpVK!o>}hnPw9NDL|VBneXO zD6oM^;Os5^34ZdzoGAlbH`4uA1w31}up4T|4)L#;3STFW(~VFrK=-!SU0!~-cK&sL zyIL&G?_ui?R6_9gwCb~GAKX9q8Khh*(G)YOv9moMe+bDn|BRR6Ul@cR22)DxY6rsW zqdm|vR3*c@yBrjI1B5c$mJVpj11u%)i0)3%rNNNyaB)n;EXx@>qL<+3u}1Mb8t;@F ztOXeITqFVX$T`k?CS|$g6Lr)Vz1nnF#uHOn7sHny57Ws$-}*h@a3NA?W4gMp$*dxEok-i*eRt{t_7 zCB2IZquslC8yWcV^_9{B!C6LWXm+2#xV@how?giz;-~;wQL6wt8HS#g5dZIA&&OwJi*Kk*3Em7~8o-ITU{vnpAolIN-L+RE31a|He)!c#plAjq|riVF@ zzy@)ja18884rB!DsnSKZx+c~-2&5unFU0rgv6eHkeM{}L(#1(h8u2ML#>ulwsJ|Q2 z%xiz}cA{z|JiuOJBW_Qy()5->3(+Z-Znj#rvObKC@>&l(hdB*tp2v|z4FG^uR}{D{ zYQvvjX6QTT=l$9BB4ueMkNx>zS(d-x&waxExs;iSI{px!yVP;rzR?#+fvgB%F06TX zLL>`!Ulma?kM-9%Fh`4fZP?uXU4GwwH;4ZH%f+GQg~gi##7iW)aXzAFCK*KjlGz*K z4<3}Z>u?^XcP>qCq7bDGrmU$jeLUj)q3H^`VKpsL2~@{}qgUhI3AWL9qF_9SrwMr$-+QTC9dIl6e&)r3h0pHh(?ZdL{~Row zh*P>^bmxMvRq;Y~gWNxHT4ZNGW zX&0H9`>3LPQc7ELLyJunX!o|qiJX!A(RgZvsMJ&$3`@cvh~8BSX`a|)IqfBn#3#!? zI+3(#z*25o_YtQvAj7EBkb-2fj$6|!EGQX2m=Xptau4&tT^V?|=(^F(zBe|SP5(O= z2XCkQDsA7Qs#uk*pSZr>mMMQsZZM4fp{aJ)*1@vJ6#-3@lCCURU+epR>R-N(qd+$1 zznT@JY7CTsxE_pvC={)$!yu6s|Dk?V!cj-O%4MpdKjF6Zr_M;GYBIaxI!5723HP&# zBnyNCKv-V%BpQ!bnx@R>UdB6yZS=Xw|IJgzM4raLnb3d?du?B&+cY0$C10e3?dUl% zf`|FBAlmIqKASX3^jmpb=RxcyFXAhBs_j+_^0c>K%#-BoT?4c`(D(Y6y?8=`$lr&) zT!k_ol;j*HeJ*}>9wdLj{{@H&yjc$ExICBTtgaGjGJC@oj(vaq4w~JqSFZq@E=1_i zA7nP=C4f3rnAVum-Plwra`~o08Y zOb*S@Gs48%LtbGMlRpI~p!kZLp67mP=O4}0Pf*Jk8ClfxIInx*vEZ)+ACNHHCm%yZ z`)FM;B?GWRvN*xzWy&bd)p0G0IR5Y{Nrv{5QiAtyZ;fP9qSWt02)MJ=U&xU}7)uFO zfJ&kT>`R3ya<>=<_LA4(n{Pp0j8ZrXICAcQE%2KE)z;&> z@q+()o(<#w5IBf`BT>R}^sWW|(q3N{^z6R7&v|$K6gm06z&&F@Cr+ClDFIZ}9@Mq4 z{!PlMy&j{{kB2`S2FF%hDU*H&!)2wq#F`uHQ`;eTkhM2guwY{p+yP$*8$6d0Vg524 zhnQ?hSi7&PHZlKKMQ(OiA7NPASr9)si9-dTfCp&<@9P}6Qu=NopPXSJm~)s%>a2?m z2nTd!_q&d*XC{AkJov1`?cS;iJX&*&#Q`3~Zb%TW5L)leVDqg8D@vA$-V1y<+fbO_=Y$$o65}Tt9Zm7)(9o=z8KO)IrT8* zXtldBKRd1m(n?B*@t#2AC~ZlcR7GEqQn93enN^mK=~&GFmRAS6WG#WLkY$!^B^=WS z$y|8tUbWXY%|d2c42cpN=ysp;ei>)_1Tu?+;*RXq7pVr6Mr@;dOG;=_8exBSL=+GV z2~v1n()hgaK=PcD&R#&lD!JDh$r#k}m)7*LJ1*sAk&@;Zz#eX~?yce8#Kuy8ebl%{ z{q;G-&P$CuK=u-z91#`c>x%N%G_&N`Nv+Z3-)ZRm`FVcA=3@favCN^BLah{0fxb_W z#9Op7-%ib#&VGuSPDxYO)v9wzvG-8Xti|W_mpY{1$ec>UO=SQ_kuY39*z&!kQtN6r zqywZ+_7e)p-BRG3$fWK+Tv)uI4k;vV0I?I8R<}2#`%H52Fc$<9IJ&S36(M)LK*ivWxZW&`F-A(Mzu|+O(VIHIndc?oRAA9>5CsYu+Zp3$S z1YSPRF2})*U5vH5Ia^kIAA+nnG2;rtD*}&$^lc5YKbgbkx0uj3l__i^t98evz=Qwql$$JHO8p14WBr^;LJ-kRm({)e^B!Bu?bu>^+tWd3_X)9#0+J3#N6{pNaw0;wy zzED}ad#V2~wh_-`&2ke`uGnTt{|udds0(_mq3q*Q-qKQWFqky&i6G|!VWB03YxRU>1cw4MW|Ur zY6Aty3|?b<9C*s8SW=|YSaN>^!N)bzri{B}Lw5Ry`9TG190i1#e$|Ru{sMb-oc7ye zI?T^~wA#y@s0C~B?3&-pLT8*lh3dA|b3YST#I~^-3=@9YD@=@_co8a-==@z%kTH}I z7yqjN6xd~W$HR8>Ot09QV{Cb!{L4H6o2h2S2-8ZEKQ}!8%kNwETe%M7kx;dQL}ju+ z`u*Ry#sE%B>VngM_}=SZl3t4&byT9E09cIOPS5ia!7gO;i6At8Galv%dpxrlDq^v~ zq^c?q^g*5={Pn@k=+=Mu zRVpnrHnxb@6>>Q*La;QV4BfjVRbO&lVxke>@9MJezw1vNa%isW$k5|i?Z|3q={ zBa}^gGBJ}~_4*|-W^am~Nz0|@yB8;hz+cS^bb9+U!Xu+0S{Mx3@c=&4Px+H|%%_d& zDU$X%H99j`O#l?#{#ZGyVAes**<`t5Ojt^Lbt1iIL$5!07DvK58q*7<(gz=ji%W>*D=1&$= zDY;XE5WbH`>NG9Lx|bUMGTipFq6Ec{R8QRQh32P-rB4Jr6^QvXg^f_Dk5*y5P@m3f)J?+Cr6$leAWQ5{MES(#PD|;q|2;8?+(47UA__wFD`LK<4cbgmnE5wntYmo~4&Ly3@oZHpL?WxHKqNa^~Ye-`NJq zX>3fB`@uC_CvNEFy<)U*D`$$wf42;b^bFJRzNyupYy80^V})w;*QTY8_Ei}^MH+yGp(v>;Yp zBs#Im=f!eanG@W=klJQa<%^XZ7m#lI4S%O~*7 zk$@Wb?Gj{DrxfJOK1x7eEQhu+cq>aohQxfWyL^9F; z%FFXc)Q^ZQM^nC!W5G@7>TX$AC+lH6C8YWax~}k|S}{#NJJ-f;FT)3!CLjhkOruMv zGX!+s z%xu3}+dc5=c4B#xMrjWmTcuL%E4g|gmaoi|?Fy<(RvoI}*q$iGpmYKlCA7lA5zN+cVJ`tGYuZ6hAD$mWDIyw@^MH{ahQ8VcrfRC8uiqYF~W z9%8$9I-(b&P4T>wXq!IEhXDI67Mt+DlV8-}+H+25fqKdMHjrd$JHiAK+{<2Y>Vk@8zlC0Z%X6(eU-rV2y6=I&eR!_6jrvzS zZY0Ej_#ec`K+TN%oFQHcojveuBg@_jGn_a|C100ov4Rh2o5LvJ+iBQpB(&Dv^=b3N z805hc8zOSbR)oUWL`Jwl#H+Pc*A87_Q3*O5>Ok3ozix2tD*@Lo->t^4VX5|pykBg7D+|bX@m3H1X<7u3qxPBypXQ*)qLM z;ME@&bhw4MSqG3*zVhRBneDu=kI>=K-_pA^Qk2z1qT|p$r`CagB5*dHS@l$=6}y{c z)59g)vd@Rj;;&>}rf zY(mfd{3K8gdGGHX$4eaF^}DLl+C`~+9#RGfBdF%34<{U)%2$GDA2OU_9+RY;!79u7 z74*f`VXU|NRXEFQr^Kp5ugy~?|4V|>Zi>yQ1OHQBWwDprD7Ylp_X=Ku2Z%iv_!0An&<`>NlCKodPra%AdvC2 z-S<{zH@XS^6xvD(N%{8@YYL(mG92XK4tfY#y9%%#~td-V<-Ie*d66%#_KrT*}l{AvJKhDudRn->TqgxcDe!gn!`T zazJDw3qTLRg`vMQo-*`-sHTnWr7s9D!73fv{Gk67%vmV^kk~ek$`<`0E}$hySgh}% z=^?JJA z{CL|`^w{`^!a%ThhRGC{ue@*?C~ICvkuLVJmklP3fhYA?(Pr>?moB$cesoFefykqtM1QRH9w{(X1&&L_tQ`J>b5{p4Bl-#%02%b zTDO->m#cO`)>?PLAZ4<6Z5>BubF!2(IARku$`gN4(G03u#Hq?>fE-`7csz{=7(&2< zV?Nx6=wU1xVObq5!aTzYrcFHKZD6x9Egl+i=7jJ$Q#oL1@K*KB)o3P?AAzJiKmD0-n z(AgCF-k;aEVFsk9{MybymdPj$bI(mOH|)MhUb|6nIPaCEL~K zz&fSj%Y1Qo!LO8y34UoXr}X-hdhW`UQQ|uTP25Mhw)|3DJ-Id0wCcP6pkl=()3Wo7 z5+6V01~ukctQ&uN-)|eO7C7j`21WHT@lctlO>0u?&iD}fRY!*r(PGhBjwlS3<~td+ zc)mn(jX*ued2TUdHBci})y{7BhohWk2+Y^7HLuxee;`ATPXA;QRUfUd76h}al$&q1 zXbAO<5SQuRHVqeYCD~7`r^#KP#V;!a?#P0l$DYrhOSBsu7VE6%m%BHvC43oSYh%Cg zt0WLXt1WHYyn#A++V%?pEw;e~pGB!91FRBNV9O9}LS>U!W5d2z4TLctmyQIEY(06l znC_j1%n|0%6t%#$`ZhQT3jSfNoja!U#ipmi!m65*@&1uU)(eZGe*Y^QRLfC%5v)2?P>AJeQtZm`VJS63#H(?dwlxSm?E447I=N@ zxo1FHpiJxBz6@NjS2Uj|^ zGBct7IV|=_ zM!aI@7)39eCk3`IDek)31!*-iItf6K;Q$4Lz8oHlrG4fXNkh|doCjxtQ%yagp#%Iq z+4e^{8|V8-dX8AG=U!u1q1wA!i_w)#<+uI|I9JGpm z%>!i|T!f?;g~6qDUpyzGq?6MR2%9In5;hMV?>~NetV#lE=;(H=b}0|6{d6*%OYWssJ(ra4FCfS3SmVFl*^R|1u@e{8+ z7?n9D>tSgmN&BThO2H~b4BVZz>gIZ^$2IkXcFf+XfIqjo_UA+BNMe`?d6BrwC|Gd} zmGe`<+apw~_>o=b{O@!2*=BVgV;fUgjb0iO=IT#Xys3BoMOaK=5L zCX#TI$$=J1b9V0$<1(CFzEe1!@0c#UZCACb;=!r=mixDYM_t!msD)buYq=zE z`>f~vKJ&N4<7H@m2Z!AIA(DU64d3neAXs!RIR*8hGnq0Ki>uI>UNvUp;kRuC0%GD?t* z7f)3xIO2}G8(YwQk{s#uTFvl|CKyCrqf#@@@jm$rGV7EoKbwMN(KQk@g14!7@92zU zc5@VPpZ57>j@L5-8x<=N6-Nut2cf7ZMG*JwPlHavtiyOgV(_(<3s&L zU7Xe!^A2HAr?2Tv#hNIp^+f`X=UOxX#Wi-7Gx{usZHjZ*MS8=XZIUD7<}Df*zStC> zEi>*+Q_K{S>8i%cqVRmVVL}y|QhH0OHZmU}khr3Zy;t69)gV0d3)p z&4WYW@WUBTN(_b21m~YTDpHrD`$7GaV8im33N<7Y4M5TWq?gfXflW!T*XHG;WZESD zYslr=%xRde-jC(LM>WN^1baaty_X!_Ae8-a(jKT!8*Rn4*;<|7Zd)xf|A;fg>99ZO zwng(ESFHojSxja!$NG%ME|RXN?EEbZ1KjtvhLsJweI&-7PQ0_?omNvO#0qu3a*y2~ zDW7ycH9nlsj&;JG+pJX&Ig)$D0ugORF)&pSukHLgr$GIo)tU$`-<9g{1jgOe{P3rD zr%c|J65_bH1~s@*%jKzZAutw;ogyLzN*9ye;tOEHF2kNN&+8KF1^Q-I^O!aZh=6mp zG(%jBa&7{+*0cXQoZI*lm1ZHaBx>&CRJD)?lu z8nVg4oRm%jBw`pWxQyDBRP6d&G;`M+D;$jL3aZaN)Q1%CX#*;ZM%wGR*}iyhx5`W6 z^0gJH^K)yOCN}apMt}BVqpKRAx^8`Z#0c4Y)?oZNBXYOyI*lE4&hmT<1f|EWi0O^v zd#QjO5-_;4OgGAZ*kL#8&T2Gq&l6Fo0&2YkQt`Uy5xNCJB$(I@nveQEW4okQET96V zOn-w)Zud?WN2=uM0>d)qsX>Z52Gi9)q>1Fs73Q+&#TiF;72YCzpZOb-BP#uyJdC-E z^7BiBNq)!ax4c=!?5c%iE}WvN!}DW&>ust?tNZ}j?y7xa6S{c0M18s>u4fEf=6J=I z2!`^)u|UMBJG$e?69pFzv_F<;>ST?HqWq5!ze95q6?GJtl)N8BWyv&x61F~*f&!(f z9j3shk0p*Dk27PgRpNaiI31uv{v6hJE3fb0HFpuTkcDy&BFX9f75OUV+m}Ysy{W~{4R$X-L-AGbJ4p;NU@5B@KI0XYfBe>BO zlHv&%NPPw~n`1LdL_lgHr5URB=)|dTakrdgaj_&Ms0v2$VmW^d6v~};GH6$hB8uuu zRO&W73VSmd2oY`|0jHM}33*|PyN(6wEqMpD-!xQzNZlR*%3Ngd;b5KcGeIn-cHvD* zH0-pyJ||sBsHa?-MkG7OR|D;=IJ?KgA%J|)xok1^mE>y}2MD}RcomWQBmA8>n~-wE z+1Fp1$Nf?j5X|n72yjiXK%DSI_eL(+fYRGmui25jlzJlxz3*h}w${YiBHoxx-->do2;mKY^6O|6FqU`CgE5Qc!W*e#i7qYE9IZEKXd?U&`o@Ls(2ajAPu@Q*67E zFgnlx;isJIuG3pXbhS#nW z#W71un$t(uYG(V57xk;`)nmBlEH1Wju@EsrpeavPhr@BSPR+jcr*hsaU7Ri@eDaE^ zFo}gNv)JJwJ%uIE0tI0UrD}1~Tp4F;a98|DS>9nVxX2SI9?rwJq_X&=WE*8lAoX+F z>RhcU_9^fq))v5d7u*FiuPDoW?~ABx3SU{6dE>t7Zd5v;xpYn_5E%(56FOkwJG25f zSus0|lQN!Bn3cIsff4sbKIfWQ z7Tq;l!dOFi&3IMDf`D9ZciEE&{7@$IP!6R5x*VXdYkEE}V^D>O0BUW^S=Zh1T^tX= z!A9idkTJ(9YNhq5R6k7?UQMk2FD8#_>Bu&nFKj}G_xelY0oEFx)Kdrc39*S`5FF)J zy4+h~o!2D+81F*`1_0j3_1OMe)o}h%1Y)Vm-l_0i++P0LZemB7JQaXWDPHBJvzF~^ z_KPo_W&b(%Gu|x?zE$stjfasPs>|d%En8!kF|IE?L%s>QuVC$Pz3G5=jthN zH2XZE)BbviAwG`7VXMQars5>>9iP+B1w( z*M4{2XZey%z&`mJ4hzYNvrDXho>r7NpP!&u=fZCL4n-|-nf$DPGsjJo-$wtK7Mqyw z?Z?|`ls9YI2h!oGIWzJVYIFtwi`MIiN#chmqgbzrl9(!!M+gQiC% zqE?A&fvTcbG5@MJ56MvhrL-XMeL0gZW7` zN88`mymt7W@G?)J^$99evq`&5mP2t9DQw~SOz|wgg zCzFI;1`}XLTqV|K$S`6Sx+d(`mHze6;FB1W^T;I|Rq_77!m3tKjMQC}3i6(jk}gN& zF;it|-;d#P%vpb0i6I$gG}oGCtjXheY$36znxro(ekdw*lNRHYP5D(wC6THkgEm(K zA>Z`HW;B|59S%kOLK*t3kWE3nbeNJLII^aBHAc0&27mIQ2!SX)QVgG^qTp+$=qM&+ z!cad6U|^te4dgBvDqaxP*fs-7!sGpM5|4^J1QLzOjPw>pgcx5`&=&2I?Zbp2<4f5l zoDn@r#ODd1To6nQ{M|}z{EZ%fVjksfJ zsUhflQq)Ki41p?2uM0sFJ0d?9?Jla2MHECR;&Kj_VTEdDxda$^qJ}C&5C~0v*nUHz zL3!O5AB*LIBk7I6<*?g~+HUqqz3Z)=(gp!ywnL1BjR}FuG44c;C1ZC|39s}kQHq}K zc307og|p*gO#7!r)(9cz$^jS@@qfp>hW-tz70g{p3nDSHMGu4$NTRFlKno_?keG*j zUCxBLK}r%ZuVFDtJ>`;!e2SGFhb~sXYUHxbQAhW639ZB{r18##?qwPmp-{(taw__h;{KnMCXYH;!c;VwodGcN zuULE)U!5O72RyHplx|x-<|7s}fT3}|sXM&h&c3-N3&iUKf?5A_lG)~FR3I*kFABM% zsMe=!v-wlm*h+A*z9L^Xa_q-ovPY7`^Yo&+v2E-NyfD1uahDaTi5}-`Z#7>>6IkKP z#CtR2zoo_!eVre_+rn_)klXUNppI}^x^0J&@k6qS$i{j|$>|)IkfnZ0xh^<2P6`;9 zpMi~1i4IG6QZjZ^4N)LU7f;SB8iuB+v1ZCdQ>A9%S2;bq^dE&ysg#Hy!b)mG4F@*O zTYnVlm|d=XMzcrLnpm7ccA=mN(LA8ZLxQO6)c5kvF}l_CqEa+Z-6?Ws6medy(M|W0 z@P!6ov`_V_$c4Elz_&IA6WCjVD1LVh1!|-M>1YKBJ`POwt8Meb^Kb2*Nbl6G0%O>S z_hUj$TV>9_^|g{&8^n6PjLW8+fa ze=rs9A^D!O$iO}fE~AF|1KEwq5`)ly!K6^SVO<*DjS5tUOi}a%DxsL1`_}72w1|Nm z&p7H})gdzp3hMU$bU5nyLflHl6m$@BiTt01gX=5SLXeUqO)f+tBT>^8Pu~fN{6k>O z;pWgWQ>kNH6D%=h-0S-3jX3|9-2ny_igCUK;RBOATZLSYC|l-jIxfk0ZiyIS2_c74 zJ%6-X{^GOSiyIijTPIwrR5ydgJ@TVG3Gb%;$WnV{`LBm)>AbplZU?^}A5CKaQGw{3 zkf$dg?3(I0%5~a<-T#f)^?KQLc)rE$yt1E+r_pMR_gn_g(!zp>%K@6qX5%ETAW!3^ozeqcZDcyO_)>ZtsWvIj?rNV<;X7)E&)}|VgwYL zDIG_(8HcLi0A4w33zdN59c5W1m5hN7xWQ}+*V-`FP{g` zb6#Q?BM;br^wFImu1y^RF%ZT$bYPx+&v<|a;p@iS+>ZJ1yI<@k>AHt))zsJT%r6eiL)onzR8y;T}bH#Ijk;Ig>Q=tAOLhBcE{0S5QN@i;+ zaZWyorPfTP45A^77ZFe;L=flKE#Yq z#Ye{U5urGXo#R0un{IOEHEv}s&cG;YR~#-x&5DDiMy=Nl#*) zJl`4fdAi-;VA<}h;UB40S{ux zIk8QSF_el1#)%%M;oL5Ea5`%DoF~uN1L020E zRPXsxFJCV0u5rvu?vDKVlw5T8dFS~dL(8@`;dH>wYq-!hVD^^5PeL}1Wgg|91fp8e)-b2ZCrs!Y+s9jo=_)kdH#u6#R#C{SfX^3DhM8=QAH7hcg}e;tjxN?HUBcxa#pC^Hez$zZ~vcBzQ0|i)S#y$>CuM zsjKZ$<>_X>w94r{Yr@yUpAUDvLa~SAUD0RDQ3TXugspT+U9mC<0^vP{XP4bD!Un=? zU|Mq%93@?wF+1u#EaybFTPAW+?Hk2cqNDUDw1$22Te#QM;)jUjJBhE`Omayz4J~H; zleazY0Fx5L_ZfGDQE@<@Sgu|*SYfc^JA71(-opldlAibN{&cZrzlk;*wvLX@8+?}d zn^D&`WpYsxe$THT!fzM=EAe;9(Hy$0zH=ikLSWLR`i=6+gi_6yI^Re#{!813KpcrF z>dNsn*0totR&&qvW%zW5k07PCBCVfks&CD=8YEEt;-45p8q2}ZoFh2Q?010$%-ffV zqH7+{9ZzphWSd_cYJETO(-iy50%u0&q9<*;h_txPh-&cpdwxz>1{^`clL z0h{SaGOOqMo0RJ7j|0p|0ub-VjRlZI>vsn5IH|wLb_MZ)qQnsseR&uH2KzRheoUxM z@o|IksKzN`(E$Aeav+^{xQW2$V5&y;oDNDq@HXec!^bcY>0o-;1dN)#+!Dl7e`N25 z9$6|BdQy#6Z=Lq`FlYwo|}W1IZ;i_tEY)o`ksLK)# zkxPDOa0VTmhraUv&`i|-r^)wQ17MCd&jZVe?o;Q&W8 z(yMoUGIId?@#NqK^uF$>mF}+d;mu(`%{;~*HNq|-g#h42ata39A%o6dt|OILhUK2JM7Wuy<+KIMAt{Iav&-N9%njXw2e8D5DWr*K_Q zc37`I@wtyHqjc5x*ln|!3bW5rcqK;ZeZeh5U3?oR|& zBlPd_dlx9|8?%$)%lFIN3qq|(Sm<=)aBQ<9O#@B{kpooDoQjO<{>j4p5OT}xH>Z9sCW_Zj6cUJT}2)W zD01K&c4vd%HE>t$YxUWC^v59?9uzi&P`e-9!d#Z7&!6krQEXi60{aMU?|9OTdla-v z085aNd>8KmT1^=e6|z)8l!3k#9Hf+c^Op8A~O;oumrP^3}SUhEOfq;gKL1`T}hL9eUbL z{`9VW;A%peby^Ns7ut`~Dt`;&zl(kl3B4N@Ct$@{%M6SKb+GNEbb+2%)fugK`^6lO zJ=pRkpDQUR`Ret2hP9r3Y~5UG%4x+(?xS4EuZhJ;uj`DW?#WMhj!T7CuV=u}hI%p| zZON9C(tc;N8HcC{k}vl%ix?iO&jj{|S|Q}c(C4ow_O|!!(aJlR;%z5s&zsN3Ud=*G zfQnU-WxZYnCQkDxebtGA4hwNPUUGAoU%5(LO}_W>s)?J8yA{`V8%^Ebi{O4+x=ZBY zG5dEk3f!y}!aMiz;>m^G*laN-L^EW0nax;S%XmfIf%@2*7KIVp%!Ge}{bA3#J7a-` zt*X&+>9@`#%K=~ofDrzt-#$AVjUmjt&a0jDI8}L>_qN3)nQ>15AVLhOqIz@T{^%=p zHL(7MxNp_{&i{&j)+K6w3HROHv{W2rIkM-dm^)EB=B9}Z`j2M}GM4zEox5k@XYwDvJzVHa zwtXE=X4b);aZ0PJ*erRoKoqUFe19CEgpL5QO2Ac_h|aYILz8S0PFtczem1#Hpy@2Q zA3YU}Eqyps*2I~cCV%2vb_jO z(3hLvmL38fYu{gdBjDM-65Sq&8Eu(-rUrbqkAbTzyvMF5FmY?*gkTH;-l=e;HMYC5 zGW{^~&GAG7az@x8qu)jXt~+7v)r8X8EbBPPm|U3~XRn{nU2e_a-`>gLr0^MOl_L=Z zD!n+>41uV~TvkHe$!N5!$2bO&cOyDKyzh~jT>2^8BK>(MupU+9KY~RNXwJ5vp9i{` zIkP-b9_ASHut~|4_#G{KKDoLyjz?nDjCw3)uSByA0InoWf(kMr$l<2T zZL(fQlQ4(EFbFDMO3ZLyj>6z;Fh|>Tu9zz*8Uu?<=(E;8s5h7V07{a%)B7pr^O3tJ z#%KZGHsx0Q)9;&Z=VYe|=QQ9(nR7Zwp7awK|2uPpFPs*8Dfo5Ytd4N#%&%*2*yMEG z%P6Pl0`_CQYY=s^-&l$hO0aH1|G*JI# z*&gw34UKA4|8(c;)BktlDI~htW;5z4jOLa}iSGE2=>tfF&>wdD!U`bUe~=b}i1;w! zP`~?}e0%`;2qK14L!dbWdwL6*roE#+HoX_C?QSBLW>+Sc?vb5uUpSgv$beu>ALgfT zdb2OmS9?PxKq^es0R!#~3(?%-B)Jp8jxGD$=-$GG$4UPtWxxpxp+E}Pe}XeJnxq(^I3K$wkA0 z&8)McwH#)@m@2u!KeRt74?#aTJ*()|`rTXRHFE8<)`Te>HcqV473?Ve=q9S$JvT=L zn&^=r6wvT;=0q+Vui2Vmp3LIwZq&E`kOTmS*E-^JZ(^qN=VNv&Hq85DK`eW*>op|a zp4~gzx?$Ap_{Pta(H$~``XMO22qgJFUjl|DkaWrloYIg+c;UJ?P z$FFego4@0`j`BU0>0)pc{8w)Ft|$H;7t3qn4ZpRxJJpBg*P$@!2Xw$>i{vS6?pY&9 z7@n!_wGNJRL z4Uva9zPJ7>)HS~txYt$0Qq34-SX_frldK>`3j2+C;UJv?REMd;@5&XXPvf$KaY18x z5#;J#M+{)(z!JC9Y&KVyGzSy2?i(!+fr-rj*TX$Cou}#ukjF2K0_Nagda${8(cvAi z7(ndX^@d8UatOTXOm7+m#&cWX2y$8)Lc$E)&QP`|szgZ^JWB)Bd=u+Hf43v(CTM z8@>K``xX61HSDcUaC#o~sOkt0S?&x*&g-?Y<*RJ%awo3Aenn;_F@2r}Y;8h30bt}D z)PcQu#F8DT7iU-Vjf!46X%1?*iNk>KbL!-IZKTz@vODE%1CsreqS zZSnk}P9<-i51TN&O>S?;N`)GwLdcc9m8lYYck6Su_5`QcYC=6CCS`5?e zFk_OB(RiM%mjaW+?^)I);5D?X!C@ZaKI_9r{Q%(?W?3>Q#+&IJ@Jy9i_Xyl=?;BQI z;bGoCg5X|jK7)A{D-ei7g^^(iI*8tC)W{U4Sn4F)k02N9)%X*!m#{{d19_umXqa68h23 z5HN{^j=m@zzCB;`7T(phe4rd9aB&R@WdGw&SQhjR)kK^BGDQnl&8&+`Tm(71F%rQ*Pq3B^t5;jv}p)0hpvt?&-g1|11b?(>AT4sji6#AE10(GxIL6e!^70at2b zSAuE?&Lmp!DX~@9&wNu;+Y6$uL4y5JBS*(mfd!cbvJ+Gwekho)y)zLZ`eATfVi4m#r0I-; zZ<(MZia;WEuZbNaf7ZZ)c`^t)3Dm@$^l!Q3S*>v)bAs+jiV{@2hqjlU_DfXpgBVZklL%X zYqLR2jT@E`V_q)5YDj9owdPo^TrlGTmDyhqy%!LCxzOTr9xliWg$yLGhJQjZpx9AJ zdtO3;5>!<)^IJDJI}Zd{3%k^y-S=DppgK$-b*SbnIqRKfs8I(6X7(#5zi%b7{-L~h zkG*lg&F6-`XfNu}H)%vG^Y$~h)-P9YMV|A|um5VV3;@1rRR0j9T)Y+>P+mmD*7Ov? zvk^rL(4{K>d>C{31W3)EzX zAPuF10l(w8cmklm(?9SDgX{l{a?|Cw-FH1!yD8F)flBLRkn`~c18N)fm4ylfBFE0n ze>~hI1!WsYM)1xsEeseqQuu{u$-k$8XtRj(0j7`vGuyj^^Ljp^D=KKK7%UhEPc6dc z8s<8+YA<>cLbCfWc8~`YKj1y|af)bYvaKEs>^1tu^beU$kXrzSKyfsSx}E3a*0m@zTVP|5cU#4Ok0fd0W(8NdY;VfN z@~-xt&fHhy(2mkOWQl8>*@uOTP$f^cFBQLXf4Ts#e6V4y)*=%>Q4>p>PK zMH-w{e{U_*a6Ns+M~9pCE!EQi9Gc5@(nuU1jS<3ResUQDulujsrwd^=C-6BK*p@>j zxD)war)yajmT}Sk@kNw(8y5)QWatkT9Hn*h&#)aHqu&##uwwR2oqeIF`S8f`WVg)a z)8cY=vK&mOkQK~ZgFiz@4=eX3UGE3g{tYbI3m{PUv}TL(tngIkyPLE*;@%1$T^ajd z5e#`j@cC9`E8}4ZKRnP{KX-cHOfFKcHI(yhpRFvG2{P>iNTQ|K$!vKN6aFw`uFSX! zi8v6mEG}8SZ)9r>@Sczp3pjT4xN1+!S>p!?HIn@(rJv5E_AJ}H8yk#ol-W|fC!B$+ zJn^5a46vNR=%m~RU4et&X?L(&9?pgxcScD+Sj0cRaAQo>*J_0F$bmo{f}n>S5`sez z>iS9m51G*2$78hD{~Jsg2%0rRfLZCo&X2@?<>+c^c$H-9lwc`JFu-r87HW1me zhXi?j>i6nHg|9G^!=QS3rF@{o6zJ@t4%_D7ho=`1{A+pfn|+dm!(#p~mDtwUsL}Nw zGVx^^FMeNolc;`HR)*pV8M&TXf4D1;CbxKv*qk3Z)lVKj>R>V8#xV5F4HMByK}HAU zt$!=P%V9y-D);L@?QGBp#!-=*!!l=9JrG9>gyXXee!#=UPNG0bY(Ob~;UKJR@sIHX zRe-6qC${;=03_=JlvW_N0-zdO>xaIECc2v%MZ{3%uPg+>hP`fg+lyivny4f7iD?emKDUte;^#$9{})V6enT^uo|2Q zEJg|(4p6*{WPBt>T=Q+|A(53H+WZM}AwXJq(}tje|Cft&Jzm=TJ3tjZ^6^}`i<@@}2|7D_jjDK-bf90~w zby~^8I^j8p@7LU_qrJ-jL8I1*cg2W6yp)o z6NHv6oBhJ2a8cmszWO&t`_{K~S$sk`YzQ$O(Z2AIK&qG+Oi6zcD?j-z(x4!o3O_tU zOr}8~9W1;3bJZbnQkbY*L#d^yk#spw;O*=!rV?Pl;RVsrAl^6KdDA&b6p>+T)RfSMA+c>}45;u`^CstEB8pDVn?oV4C)ZSO$k zS#QL5U7Iw6m}(IF+zhANcjWmUfGC~)-i_BHMXoZ<=nV8hmk{{wX4~qt-FO!K)M1`BPdN){{t1?2$7|EMepP@g6vo8#rwH$Q z0SdducPFc;7}WhEN3rl6i9SY{U-e(x(}60UIdeDuD#`_11Ve>8_sX%S|Pd})V2D>{GRjHpRifNQ*g8z$;g*`sR?3FId$nVm$p zDg-%%nw%WdbKOUf-%G#Z4go-%K_R0a#&>||8Jt^eu36@36Ht!Nyv(@j)f$ND{}Hl6 z9^3yn>T_EClQT#HWF|NOxIvq_W2-;PgEJ-2(>D=fLZzW^czS3EtAO-Y+|>pKcznfB zlGpfBj4;&bov+jp=-@Ixf3eRbmXQaBM;7HI>nPyJ@n&#D*CRmOPYF?Y)g%gV1KmpM zZDe8-e}B$KwG|%#BI5jfJt~GS`vCA%bnb!?+K6E6`$!m=P7X;CA(i4QC3hi-k~t1|t*cNNpH%bZy4>pCwre*Pmns+aabR4H_R1Ab{IL1azAW`wla73EQ$|r$slJ@Nu3Zgrb}5ox@W? z@gGr|F630Zg3l!>H;X^BAZ=ZQZP2-9Lyn=i6J!LvFXlOG4B&kxtX_qw zAaha29o6P>DJpV&o5%~{RK3BpcI7*trY>7%Jpb^^7YGH2vwZnFcGkD4_5odw$7dt2 zFZO__&nj79D+=HjSlB$auQ+-4t_V+T(>^&@SAV0j3GX`5>Ad~Pvj)Kho{_bnezJyp$uVgf4AECS=nip+n% zfxI6Qf}0r^K0UL7wy;2S&#lHDl&VquU^%vBo3V*a(-+-m5UnTio#*5m>l`0sb@H|6 zxtt|;;(xK_7@u9HVcQ)3aFE@}C2q>oT`v5)M{Z49ZTjgqmm_1rh``2>-kJU*K&)P< zx=q*J{0*uB5&vj&wCRH-^1^}#W7NFiad7ShN7wYgwX$beg|nUK*HH-tQ+)O(hk?Pe z5X8rPjhY#BLj{||Yn6JvghoIGri}Ha%eRvr$@&X;is^vsdw6)KuYt6pin={b?%^v1 zERJE>UQnuI(>lUX4_zcYlT#9UzB(TVlk<<6rQ8)!3$a$hg;nBu05l%^RSA9AnHuylr_$m{*_b`c(K z+0!CgZO(50DH9a)L>>S0qviZ3uY-Uv5cR+{1OYZRQ&6HT7T|T90~IXYOZL<3xUV^l5+h>M#Ek_BM;$1k1D2F zPii01!aOAS&?$X9)~Oeo+umD3tsh__IbfE4C_$L7oqm2OZhe3g3svVIYpFOI!KiK2 zS@9afzG4KNl#JZBo1_m!u$HE;r>Zk`G@P{FWG zX#-43!w^O2LmHWkc5D!A&!os})AKFRE&BqNGxTMIbl4>BC5nHJ# zbPF2h_)^0KxoRs4hhEi>jH2uXOC2o)imV4dG*mcwA~HwmiV;O?0cE&j{U=YjkFu}A zigWrU@4YwrLb(Xu5LfoYsENgaWL|@l`$F^UPg6gmXjZUC#>z!tmkf+ZPjEOE)O{Yd z5ntSG-e95o@Hl~fop$Os6O3*1h4(6$PkzM*FjYQr!Q%&C$h^&~6onkefTAwQi6LIR z{Ek0cD}`P9KS7Y;DNyJVO?|mFeSXL;lNJf_$r!Gm&zgSi#7g$7-m{ofRdQL-c3tc>t(^RZOZ&U-8uSI6jNm#CU1k3D=j_7qO$F)xS?e9@KM3}LgOe@r1e5omap5gs%_-V98D#|+s&}9HQcI3KhT?`zg@zux? zAi5Ku-%xcOu!5^yGKRu=EsB5Qcvm1W{494;aPOngR!9yv3hsXYI#Ll8qr&eUL7e)y zhqY@F#6|DsCEdftHr}Aaee#2j7(-kb{h**~Q3;EEGY}gQ-3PR8kCgY1zc8FL z$+#|m;*-AC$iT)n?|2V}?Y7HPuxZ0c>p#!s>pX#h0ZcMw+K&s>$RKgtd!R>XJox?TcFrN`0;H^;OrOWDJi=Gwp&789@l&-xwx)DFd;5f&i2i94+Fi;ty&ObENk# zWRy8lr7U=wKSqAjOXr#&T56h9R1T$Kc!^}_jg~<^BAI;yBR?7~$zWsG z2#LgYYGbV)r!jzTzWvGnlH_W>Av#%@w_vXi5|sGUl^mfu!jH+O@BZ!&dJsgmA&N#VgHi`3rwYGH#6&&E4tgKeP&jLZ zp$}j`!Q8)8$cl7W9Rq;VB6Y2@O|4=9ixS@AXiothpuvoga7|Lb0Yb`hEx#Cb>%1Ch zno5r?qi6FMnjcHWwbcBKp;yyK;$D{Dj) zQj+5COv?cMOPZA#cxQ3^WvAj{&YDn89PVQbg<|?EX}iMs+>1RD`b~#$mhW2<)hI;d z$ZidywQ_9WzrIKg)3ar9iQOuP-zkR*zUjT91%l(fH3O~bo|ynnfCn3f`ii?+VM@@A zAZy0A6%uhsrL2jBsce9_q8ixUD_0shZ^4u)ADX`m)sCC>qR{aoG2+{V(${I8v%9h( zHED>Xf##3jFk#^mX1>GDhY=o>sle=mBQ7%(D)Ggn-;QsUNhpwlrJUrLx~uwsNIDC@ zD4RA4OD`b}(y*{}r+_pIES*x)UDDmLba!``v_VUkv_Ct!i78Y)mHV5!`9U=mL;#Ykihc@j0B;B3({i%Nl1?KJ46uOXxJeoIq zarIjZUg30_!fy{gO^4XcTKTf2VK>AOdvZ=I%2n50re&d(k(9uYf8VGu_`d~+cY%-Zt zvy*~@x>ZEo%KySj+hjYG)RD-&DEgvKZ>N%a{12g*D9h zL2i)$4~c|i>5MhxG8W!HxaLz5?MF1id`7}TmwMXHMalG|q61ESZA2TgP1vs{1OuJC z66tXVjA0~vaFhgGjzL@+*Rr_=Fy}lbvd`f+!fc1f_A-CpsUO^?l4_faGT%fJ{(2u z<}9LES%}Klm4VcI?B_)2aG3*8qg%a4@S~7roOjGA&7Bfe>QgfYN&K+l zpi1QO|G^J+-==X0&ai&LLBK*N2>2hY#+_NP?G8F*K%lt6@Jl&{Qgu|@13dMu$dyDU z2KZ4&YD2Zh{!B| zjRo0Wyh??FkLjh*ltmEHX$0TDSvJES@3MS5w{pSb^zikej}tD9xy5LiNEmvZKNA&mKJE~pZ#&Kc`A4% z{eHv+(3yTE&%7(ev75-SxgM@R!&k+PKNxr$5-I;0?#F?qzWKYCeDgbokiyW!$~VK( zkAqR6HAC;CmbYO)YXyd83)#4RBN!4}qwx26`7?^n52(~HNhpsKglHYT%jo^Gx#%8q zhE`{YQV-5JYB7HAm&Lfe>SX4^J>?~+7|U7I(bucjWPLLim13ej^wfXS5>!UN?ry9b z@U%+AtqCYiu@XUn#`-V+yJbS7A_Va+Kg#$w8Nj$(>!EAaQKP6Z6a23cr+U=CvgeP_ z?Wyc1nIL#(sy~Prj^TkVg%s+0^!eJ_-$F5n(?KqG$>PQtAX7t8yiHOB= zsgaPMsAWV0S@*4P7=MvSO4CB8i##gM^IXt{kWCH+v;6})bvaySJ?NWi?4R0S3{_QR zeHjnZ5%eilp-7=d`f&?=Z%T)QhSN8UuOYGoO+}!)t&=cOzF$H#Wy^7W6~QcD8jk7p z5u8`!TH<_@zVVXPTpOQ_gVVHtC%a~B&PkDtTemVrX*7;&)vO0E-x*_^1ihAe$-v5P zg@m`w+qT7u|93v{G$Cv)^|X<$Ol)JDQYUKRz@EirU+7pf*nS`vqf>U<;0>slHb&T!o(WJT7wa5!t`swh6je`Rx!^2qd5*M?JGC z`*kYn|CUUh(-1cBwOJe%x}Yk=%5x^pca81delJv+p)S7sQF{+gn&E z&Qs{{C^bK!$fVGd#+t}pq6#t8Rlg($naMiEDv)_!O z|NOy3jM6dNvyB<*?xe&aseMaf$zsoF+zZaaou;fURbYjS*ia;bPYhRiFAU}T3p9ixa(Xz6)rG9(cl9W%g2 z+R%m>77T>hZo&vfi}wIMC4NN4!`)%6nzW>gmp zO9WwyIBP<|R6Hex?CKKtpYx};PeC-ahIt}>{2iR*%6Wp@vpafT?yxLV??6lDv_>x+ z23Hp9w5u2QUa-RbO*ppXR%^H zY8`4LJgM70%%^Xc}12uYU(-pPF6$pig);XBNn+ZLzqAMX(g zCx;WjB(kfk7E;CDq~{xcP2u@z_bVbweABI^B*|l@6EP9-Lk-dN?uXcn{4VHrQ;Twv zB&-Y_Yp_F@5!lFo6r62ep$ zfgz~{v}{BiC5gp9-YvTDLTHHF1m{D-X>I%~9@cuF;Nt5SwTusSV`z?a>Ztd4w0)Qx zie8DD*IeTBH4^R?=n8}{>M7r23^P~wI?dyd2I7pCMuRUd8}t$0B}GGMoJNFFTSx3;dXKgB_r-M9pGi5tx1}6eBa5i^TinlH%4%1MN&n&CJu#NU-Pc*a$2R-TmA;Z{~uL_n;I!Q0=h9 z9CW9fIFw6`hnzOrwh^Bm-6=`4`ZIxtwYe6{+hRC)tfL>#Gm^tap0poScvig6q0JVW zd#RC$HgYEo89=4iwOr*J%f#LT$tgexZCr+V#t>CV%kSg&y~l|1fx~KWtUEFa*bRWM zlWP)<9}1HODNdiFk(h)jq$l^n&f>hK?8P3(UpHfXc*#gVpMXOjI*HIV+m+i+4!&aS z|7yze1!pI)Ri+9oG5RGgW+$?q0z(isIa1RfHYypbxNQ*`JPrK@h&z1?iSEb$xM64W?biMV89Z zT8_~(Y0f9(T>LA$fwseLa8A6G7O7c2LFr3U#n7^a=8il(dWgnYTs6#QQ}HSJ0E?`| zxv8UZdN!MFW7IxGMURT)gGdDV7sEwcpb@!{af9J=y*16ercvVH)1T$Pfi;3RjaWXOqZ}5Q69|=jlt?& z>H0WH;XSh%^Mw?Ba^k)hR1W>o6!%5l_%&nIT>u%7FWm63{5ERS0rmNxNoDSqr4~Yv zE%I3uRQ(zkNe9?zOqp93>EzQk8Eu~@v**~5tJN(ONoN<;F!^aIzOV~7o4FU4^KPZD zD`e;Iu&pW?ytVM~c~j#pbuL&iJ)>f_`aX`8 zjUL=oE3hI!@7>tJ|LZf4q0A$d5DHRT-suOfb6j+p&zzw?W%PIRC%rx_c@lVjwwnpr zAV068PN#%mD_!jT&W)oFy>0Zs54rd%p3qq!j$Venxi=; zDxnEMq+oT3MUZDN^Shkm^KK;nA3WvQudzJ@!i*e&jq%OGgkq5;nisQsiY1UrTd!IL zT^-MNGln<)A7-mYh>YJICwVOOr$ZB}Sb-Zf&)dMmLCUt*wDJvwyz2nfOP-+>=U9JQ z4gq|PoOXyTJM5=ni&cmunl(*N{h|3$ShBg6C?1q_Cw;%A zq_^y|8@X(DpXy~WbJXBl^zYnCZAYc}SR_Vg4={5HEAvDM0|6%!bPpDo;&t05?Z_Ss#nf>c37B#;PWx;3b6^5$U~2mkzA{l|?;%>LeVq1<(U@p){l{Js ze?AVCL$!w;3d}J<7wV2r1Kf0liJq7$8yO`x>u{lOXXGDsc~>g(^6Is01xG<|x<14Q z1%PAz;eR1;yqUdiIbrJ?Qw5yCH*ZY^L*s_+oy@+Q&=_xhC{}eizdA3fbJ1WO8W>CR z>#ewsma#gR#2Drn7C&@iCWcEWPSZc)AI32^uvUQ4V0S^l-Jw&ABB+qakXLMaS@wNOxfHc3?Q86tfm9m>2z<$)DQl=jhhp|$b)aJEJE$4-*{e9vCG5K+6`+X45es-KseK7Zn#(nLP z5yB1YbU{bFpuHNOigb<{kpy7$o|CCj_SLKh?4K-V|#_+gtnX`Uw2X}dJR4R zxI*hq1Mv&=z<-3(g>(g?mcB{;6N$DqpQ)G~f&aEdxQ#>@RX`v8a#U0Zb9w^XU>1Pw znR+#lmbP#O)6>9Z6C>WriV=DcmU4(rn3h?hlnM@dj~_yPssvDI$C$f72J+f*qJeEa z{qp0R>HYhYHGg+-Isv7}e3tGK9kixrW2;=!vCEx@P}qFEA<69!Obf;pnx>7XX4;hZ z_HnQpZpGWz{7Y8<{Yc#wK5Bm0k3(s2 zj3S}krA&W?W!`FTh)ltK*YqW>HuDFLoWSsYdlW<}>9?iO>ZO2j>pV^dci3eUh21Eh zt1l?M06?9`dzwIyO9E8j(PrFOhx;2ePyZk*Pn4F@o6KF!yG9yr(Ng=ErB+k6y6S7T z@b83L76ZWRN*(8|2bl+5G;&F_JpDXP{V-`XuFR=yW@_Q*>>aXDZZs zlAI+$&sMZ^)5*9!-Q9xbNGMurflQS05|9z{UlZwg8%e|Nv6)V=zH?qp=i^7g$4(vF ztW`kCTeQ0A(lp1@t4NB3{?%GK+vNe*gWoUWn z=9ON3m?lm>%H#c{(owgyT`PR>MFN?(br~YjEV_CX^$GJTe2Jo)z<3R0mD}Q3@uC`)dtAP-vCC^C*e8~#?U{y;8chPLGTO+NGqjLZw{BbIwf# zFw(wntQ=} z1ajn{z%-{^O_B?_y178N)?maX1JBoJA|(NA`64&>W|TzbuB~Z-vT14(v}z#bz&ar! z4PIrZmf`e6+Q?w()@0zX-X1|qUAnHv*>#4EE57{a_7ZPvUG4%9nF$$%zt_~haS=hj zd5&KOZ3I)QV=AeTg6ixw54b0Rl%ZcqM5K>919UAa;w_@_t`b|^pby^=XzZd5q^kn? zQpNx7*hZ5Xs|U0|H&ZhxM917Av8Ncuu|O*9q3G?}^~{VWfsHEVAP)5R9u4sV0Ysp2 zff4^^7GE)wBjB*Qa%@!8+Sr5q4#XVqL<{N1^PL9h{}Uk_ypc6hI`~q8CKP?+9o$3^APMJn6m5=QkbW?$wcIA8RQl)?w($rgU-`#eKy} zw5cW$N|9a5JJ$Bo#bh_41A*k9Z-5DOTZ>>hPgt(}&cLmwli|_ri#nq7vTFSShX)q>)ORurNEPKC{k6tq z*!u%jQ!JUdl;bkw1B7&*?*oRvLdRyk+hZvZgFupm>6I@D&_8Jg=?)^Dh$x)M@R9z1 z?V^IiMlcSam?&HDUjhv`KqL*o`Cl@+GQ6E4ZHHQ62M$amPiAS*gNoV-<5*^;lU|_u z#WSyz<{hxxrX7I8w|~)m-FrTTID7^;aZ(gsm-_3mSDZsQH?&`O5b?8%Xqk#v-*x{9 z>F9YAnS#c9`cehnLvJwB=KZsTQJI(0q@VW}ON+YTyPUhS@QyMWiEy-x>J%&mk|O`4 z^Imi+bUz(D`cw>Ngy^(WBR2Z)@+!}LLvRHVT_03$X*`~0`t}yCyVmdv(&31v*SF7J z$4)|Npr$S$P2K#re5l23PX))$@8`R~(jPb^CbQ(=yf&rItr*)(4<%jlIhEFD(xHkr zh!hOi##aA!wJafFO&bd5fJ}9gaLEi-^-J>oa4$`ujF(3s^r@)#$ByaJa@8F*B<$Zm zSzFb`)|OuiOHnM(d5oQSwpcq{5lG!UcpxeLTd%aNBX@LYQ*(v;$#a7K^$RZ8GvpCI=h+%3lzs!m#=xN@guv zCzC%~N?eSt@`EbWG%?LjppQu;-TI0k%FID|@$2V47HWHyagE+KEQLO&=+9-nbWM_w z`RX#ebPJonY9$Y=EPSiUD?f-84rV$})|H%?waQh95$vwFW3xgabd&QM*N9O% zcAo5*7CgdNYcVBr>H-q>`DU$H>Fu=wc(edT!^ump)pzb}1B6-~n0^1WhA=wKd!u#} zK^SNKV3aWHk~iXnkCZwSK&okZhmv3cs)z>0i*jIU@cKnUh-W>XNg%j{&&soou+hB@ zmx!tV@?*a=H1D{0cG51ix`aj|jV)CZX#9XB5T8r95)PQo%FJ^dCpCNo;!?EvZcWWr z>>eKvMvkXXy+uC-;t=sn362>Jkos;VX7HknpAA+c#rSnqwN4n9-6F+`@Evlv$@u4 z3~U4zEA1Y?Lk4~y{ZRA=u+Rn^h)S+N{l5cjovy66lsKFwGU@N@hIF8&%xd;!2rg~a zkJC9T1?f+^ulj8sCcm^6`fy zTh8l(cmT9Q>To~3tMmrZU1dPgAxtg#!Vgm6H zTja+>e~i#;Khcbk={Hi`p+6gNdO~ z`98j}SRftO10Up~fRMgOfC3v5o}t;++Tv0Fb_Lq~oU0b_FFm5#{-<|o>#M}b;45SQ z3GU&i<%U1Yz_T;mD;-{cuPeogDig{0?I!btID4L&5hr#ZjvA=B%?9A;1V)vZivs6( z8becmdhC%7u+B#4zos-3dTId1q9p@|Xkc?RViQwFDhE+ZvI&(^6aol)pH-$Z^q^Ah zXkL*YIc8Csv@lLL3nSxqKtF^kLC4x~5Oon}C*mc@rJ-(t-j*f%3_%w$1LS2T@NwWu z2jsIOz*I+rln^JvV~D-QAFlZcBxY4WPEDU1FnPnQI8MH6NyK&$84wDE(&D8S3BPHL zyN*|wvreHSUfTM1t+3g#&2QD5E`cPEygrgTw!f_Cld9a*lC+&&f&{_dJWT02tCnza?0GaFDg!6VjE-IjjzYjv1z_1$b zfXuRpiAhWH;)R2n7>tV|N&&KcLXxKGz@j*29Z<*rN2nwiQ&{8Zh%YE26{9R0BB9|m_Cq#A<~DokNj@fg1PQ5zpH z>*1w^Zm1Ky%4=v%RQm7%KioU;>FCcKYTj|!#c^gmr#^z#{9HJ7@r!WUdEIjtfIge2 zzo>_Zsa@-(r`LfjvEgZFp*EMY?>WcmMHcG9ck0xR^CA@C%V{FRT_@GPh|&nQWKk4Z z;0-mONB}!`E&GZpi7N0kC*JwPX!~M+EiYqx5g692LQi08z#$?z7`_>NENm{P@5b(- zk31JOOeYc$@1b`KE+rr)M1h_c#(@fiEVc@0Oc|Dr#w}W(Rk(@MAG00i^b${Gp{9UG zvOHkg9-z>U;+7H2hni)c#Gzgfe=~&SUC?Zz1EI3T`wrYk{WZ&629z((s{SV46#l#7 zr4Z;Gf)1z@_r69eq0k;X&&KFJhqRZyNd;}hHW3s5{?hX%I(eGK_MR}dFP^P7M58XJ zBy*}2MT#m;je$Ak5dE}2adBOr)a@2uVXHYw=~G&Lm8Y3;fa4OG=(M7 zV!De_ye&9Wk?DW@vhHJkfh(aFh+?5I(uzh7gY|BQ7ll$Usiv3GVZ4yNv7~o3sP+H2 ze&hZ#Tq(LZ+$;Tr2T3wvwv?V?G+}N3$L02ITP0q(tpyt*iEh@_@G+i@TOs5esRN>I-UJ!|t$xm=ExNQ`twcMqp;in~L*8O7bJNM4A?(ipp(eh`f zJs4)GcJb6>b)EDg87Q=fvRE_kM@2s1QrJ+(LvCwO3_e_leW5SlG|R zkPW^&GakjIkc5ZFQE4kzw}kst^uFU=7zNI!sIR;d=$gzeenOh9sUKQs4{KeC2iX9P zz2nWx-8vy;oHPv$dSJ$4zti!splqz?q=hht0?&OHy9-Lpdv7wh4#_R68X0JF96ZsLO)JuG$VYCGz_hHIVF{M+Ah=)^# zC^S*hACZ{Q$YWZK$U=G7p@N>5>IzaD$Vg$K2)}vh>D9lo6Q(+o6c}f>QFtwVXIX3G zX!1h${+w@S=j;>jX=zIwv~8Q2j^4c`aC+ZxA`WnnpCGs?A9Zl?357PtfJ#bhcuCSR zk5!0)(4nHA4I^*qzEW&H7YiyKm9-Z35-NZBJB-LnbvEqz)5|aY9p>p#Tydu|HO!Vw zg@`fCSI|x!*l+YRbQ!HcAgUXQD=XvWBU?u+jq6o>T6|r&44}h+tbDwnQ&*((BkSq_y}Vb{UCG7VmPob~o?%sb6v=N2fr zC8~ec1mh?B&-c2&IVwPsrwv`RNk)l#vr zMrT;cnUeq=>QXPs4lVBvW^5wmgW+#H-TQsEc4XHh24TMNm zP$bcy<2yLVyomN53_o-S(^#I7$`8>fXn-9mv9!&j(H4s2RMoSO1dq44+o`~T_pR)% zTzL+^43B`g(TlO1L^C!m5WWa*;fv%_s&i+$860~vm&M)z3q;ijhT}A*JVE&e6?xhd zqi09bF$g@xlWEg-*fB=pAJch}0OLIDvHfq2X3bDW&EuaLh}dfrT)k=Xf8}eTh*cT; zz>KC`ei|2&%q6f3)kO?T?kB+qA7st<_F^e`kH0oWO=B}lyTl-BhrR`51+W$eoN@u`?1>+MIJjEF_BC>;oaa~zN@l(SH+8= zyURBH#iAiZybs(ZHY+6;>~5HIFDn)K6ciP*d7qPtyk}{#-nV;-w^54l=prOm201ss zpx;YzE+#=?0s2)#*n>kTkei2bB6;4@7k@myG-JcZZh6Dn#qGEJAtXWeKH3{)MNI!M zPj)zh-5PzwF$OXN)*%@7arc8IgSwR$E0VfV!i^z4scw~~kI4B?Jp%RKaC9o`=&@+H z@LRJpr@>Us7EHa8z6ni4zq~db9}&Cz)Bcg&tO?QpJpxC+!M~0{|6nSHSbBP&r=HknWEc5jwKoP!V_e1-X08&g(Tsf zH2rGOWKkzN8Afj(M^%F`c%;3pUgA9|Yru+j%F39~Q25oiH4WNgYq$9_i(IXRq4Tes%2g4QL4X8}oNP7qDCd6iYCVfJ>10 zrb2WS49G|WmtSC?YfMH2$Kgs<(I}VO@kP(3#&s;A+M6=QDPxC~4Uh_=kyFK4mPdM} zB~qtlV&H`~^PoOZmN9RIaQAP26<|@6L-){%OK`=RlUBMNWECO6C%fx%*9P^>wT9^u(9lD>@laM7Gjz5Z-Cy?(o?y7= zg*vPqTJlmjj-KzA5kv7RX^pX+z z4XdVC(Y{c##MgIlYONKzChU{u1(D;Dy6{0I9yXe#`m&Wo4mx!)+S3@1W<7(}^$xme zMhuJ3xQ+(dZFMulNIkFFCr?P47YZp&<9bjN>B)j##$JTS_Nn?k9_xKglYZ|-_?5uXn%r)4iP zS^fjdcKwOqm$;sTSc~K>rhx~OYIDaV_24pp;mi-325*~8JvF3Z9I0;^$ZGN`Gz?;3 zlFY28+ZdV)?mpX<(u7_1>?dyWv$!?%xJ3cajlwNp>!KEDGx`nO$E^L! z0>)-l@OzoA>L4n=bVpp=yv60yup|L0cA;it3-r5lbdPoA zmp?2>M$5$##7~+uLphY_*s18n|Qh_)|@X9x<$;(~YaCWpmSKMbV z@cJC!KiI2fz)qa0&AJCbg>|JwCW_Q7NCqtOIr&>YU)Hnj7&9qv(d|+#Cb*9EhUDq zRGfF}ef(WDpbMG&1j|JQId1vsfW#^c7rwRtOf_2$*UoZOx_MP;oc|)7Lf0EiuA5+F z8G$s;H4$9a6{}CGH=m|izZvIKlZJ0MMh1L*zIh=rRUI&d3)ND0dPrCDF6&4Q=ma4^ zNUbH3d2HzD0=n12v$}io0!!ZpJdIp4a5GU5d_d7Pk`q$ zU_7fwRI{)W={2OWc9F9&al%bI%Uk46@ZX|kf8LjcZ8ef#gr)DoeZ}%|;Z!fs-!53p zk;J52cw<9&7h?lu1w`tO zlY}zx7$|65$)mwf7;35w(J07Gb^A|5L}iq^Lj&w|pf`*>5XjQmSX~<%5+taUAX4qu zxO*B!O9ew7+e&ypvYm)oDJl)%6U^0Ke`|}&89!!Fj!7DjJtP;fnJYhOdz^pAT9~gg zlFU`~G|QnS*3kT;jDfuoSqfw|zX2goC+x*JhtV*H(VxN!5op%ceXD4jIwF$d1W52| z!7-L0Ahm%992CVYqpmI1pDy3JpdXJ()*0<@N%hT8WAJs6U|QDo{N)h>U?v$5p}yEm@4Zc6 zv}}l^;U@gT;gE=j0gX7eDWx`G%;+c4onNuMe50eNLJRl7#US)GFiV(zd|bw}@zz0$ zXKXc?n~EbU>S&AZF{o^I&S;rWTbOmKDg1-QmS_3~PJp2>vl1G!g*!gVWD&${W1R6d zG>J#CF@xz5s0jQ{i?hwtRVQJ_i4l#L@XqXzCPPjCULG41JzW-;48`hV6_Y6Xq7-Cc zUU@$^u{39QLZhr`sTecueA4aiO238UTd?gM)2BEcWcz^5d)PEplR}E|SzAiX$|9&? ztXN7E+IC66cpG%)U@Z!cfv{vrTq{_zX_UOIGNHqO@s^XYji#%NS=*2%U&e8SKJr*i zDv9Lo&HOS)lE;}U$Q&A*9o5Woi57a2ETWY}BstbXNR*^tfNAYCRF>IY;Z%Jj8JNbp>AP@UJ*5>F_kLe+fVM2)eL1!)W)&IX2;Rtb=a@uibQU1)O0k?mZj37 zVA`mLw1@1D9jN+rib#V9?z&fUOuAGI?5$_;Zh3;2qExu8BSn%Og(;NU%YQnx=c;|^ zeH6aUYUK}EW$Fm){?Ym7n z{Zzw2Ko`Ppi43WpzKauwPqk*u&MDqhNY%)D8BR`AvB~@(R+|Rne9RYZ5TeKf!eI_? zVA|{ARW9;@7Oa}PcCWGZ+yFTL6~%xpr*SJ4EH z>}yh-{SMK%^^mR-AwC66SaOx-Y-rACG7PTfVKdXb1znMsB1ExZao}7lR@iTm)y~gR zfvrDqrMB;Vcx%b5AUr6cb;PF57M6azd}%^jEeF4FW;4iA(TFJ|<n>!kJTVHJ-h zFDyB%@v*&l_R+)kSRCGxjtu1Cy}%0O4>NO|1$0BxV6?3aZegJqdh=~e2Evo6Nm16}@Gl+j;i4ggjjIxEcoDk3gguP`K*d zf+ZCO#=B6!O6t;6DvR%gDbtLuzi}b2BPRbF(P7ZrxG`o0;?=p*nL@?LMV~mI^Rlrz z{4s^f!4V2-{MtVv>VAJSTwC1yP<|!Q@`wy&JRJ6EX-6&*H)iV|caf=xC;j}|7%D7s z_(XI6;b{N&Z%YDmLJM1<3F4a*h%?gDMeTTaRUH%RT>ha8FZ7q@)i>q>;_PJ$i=yH( z!)V+S?|{O?ddW)L8!a+{-mn_`qn)z9$Y8$InxC2@?kCmdb_ewfn)Zs~w$1+acC#`* zrjg_PU+t0#Hy0G_oY7yrpfX3t^sQ6UwxGdj9gf8OY3}+o{ixWE8~zrRT^I>$YPK^t z+E~%dLYZe0wubrQ2DFj9Xw`09FsDrS@E2O2C7vLj%&0R|$n-Ml_tLmh%r=hue)b8` zm3eB^vsnpi5Ux;+e3hIx#BLjzkK&8PRL|qT{XvWYg=%??M7_{+Z@v~&YRs<_i+`8} z3|Say7spL8Lf=^r-GLK;z=_Y_Y?ar9UW@YgVOKM}tw=Wi2&a#2mJ{&W-8OMSeS_yb zZR_Vd)k(+2X*@I9L_%-aRQKTefZs0?jZ>c&6H;jgVm?K2X8-#Z#C1F|aXB$L`z zU3CXQF3rreXkEo|iILyj#Q4(g}N*x$U?tWUPlHc;v^6qKquSQK}o?hU%E5RXLW(H-Q5k#W>w2%3w+Q%bE zcjbXREn^=lY98&kEeE=cBc06 zv%Q(;t_uC%?g3?9rwvXuI{&m-5VJWL5c%TucJngOEiE;T3jTb)RJQe18oeW{7M+Mj zaQ^0Mwn-4=XNMg>4fYF`M9iZx{pkg-c1sh~EM6*H&IxGvmx4yuJ|?m{Y$b)+Fk+U4 zvc=z`={qWaS;^^YLi@PkLoxxRiTH&9&GAw;$+=5UeUu8ySu~-O3O@Q!U-=H$dReHYoA)WvAu*HWt{}FH<0}@k^S`G^G0)lnoma~YKojW${d@iTzZY(4%TSgW&Ahci;bSHQF$*m!UAUf&%%UEmbz8#Y>faDOSjcF*8 zp~IHUd$E4y7-^WXBbvehEC>HFW{n@$avcom8;+ytXiAROS5cn?g3;NYdUAgZfv+qV zSrQW`=M?{uNF>4wI*cs`JR?G-dNJKrUt)S<^}yP<;J|v)q8cGQ!*?P!qh^Q3AH>6K zWELi-DRL-R?#2=Aj{Ru+XRcJi@cYO1n4^A)v{7wACuDGr!{OmV+z96K^xo2}U3n z`i?Ag`ge7Sf>i*O5h_+5=eUsQ0Vj1hh$-&LkbvFE;Sd9u=_BzX(n)0-yq{^#kck6R zi8B!u3B5l_Vg3I z6kj-D!2>!ag#v+ZL6VyE$4Zvuij4X1;bSeB-|akC`c~Su^z9^3-&()QgB<1y*^P*? zvec6V-WdkU1X_SaxO!T@ECNHuCib`)^AfeplLS#{i13^fT^#GBqF0mR)3!x~pO4mS zsm$If^KUg{wfGQ>DxpWDCkk-|AMvCEACsVXKG8^p2lI!nK$=uIF%59cqZNsV_M}+v zreM&L53N%CbuW-KM7RNnDd3%|TMW05)acv_HuiCuZI;R%);S-huPX#Jb0pfulGZA> z{!ZE)$~koLLV2go_P1l=d_0Ti7YPKfGi-S+UvTlgOJiRMg!opaZ-jFrWk~nf^71Ch zQ=+FUQ%8D9(-DB(bM!RqPgD3_yDij7z*@!r<3fNhPU;COLreNQfFC}O2@muP3O@(p zcdj(~DwnQ;^iuB#5wQB+S2}RV1X@G8@WRuqbZYBe25{J!1I7iCFLB9a%G-j|#tORC z&+>>;u=xka7u332$kg7ugfiNz72DBo|E%l)miJ7sh9Nq32M^yuLCVjt7}-2Yb?+BR z3xEiFc6=Vog(UtY96{H6iDaHVk&%AuA;MAfz z_tzbbx@;#C-fL8fSxo8WbsXwL#i+DeEv@_jHQAdQ5|NbV7>F!2Hj$t&t!Z^VRMKhg zBo-jqfopM?LXy6-4}$J*SG}M4X!V5G5aECk|FSSZ^IpYGMU|yC44!Hv8)vKY(Kjv9 z;z};ohR||O!K$MHWnRsWm_IZ}>TpkOyteUXJ{;Re@q@;@huTpu?$gt+PeAHW3Uh(MWk!ZUOYrFaqBl_? zXSYF9b+@vRk#@94;zopZtKrb+spshjS>(!H%-_duASm5U-_*MK=GAK|KP1-pQ5|wR zJFCJHT*A?AHZjWg6&i%$e&GbhPaDyIu;LFOJ7Q0-tAc@22R6@{xmdZ}hxd&L& zKz8GQQ8GvtepXLT^q>6*bAVvpoY$nK$lBxMZQ$=9obdR6BRD$^ve0L$ zXxt3C{3fBFYSJXqO)(^j!->N==9BU|Xjc^#=s3hOTl6%L^jxE6-P`hf!q@D1-OUJ= zB&Y-ma2tEG!%3qa$KcTyP*^_o&O0Pgq-0T$kljJ2tyjTC@(pxkG>bmzTUEgd-;>o6z}PKa(CB5w0VB2`K8nsEQs?fzp3IcbDHP; zsc;WlCybds*HZu1WR;(x;kO7w{ED8)vQ*lMs`I{PR#?+^Gg$j^NM@Q@;bx!M#L=b_{C zsFZ-=QB=End^_bIdPUCgR1#5~K{pGW`J85}{cq-GTBLd%c`F)F{VaxhD-4#%*%plS zIS-w0K-0HPa7|MZ(nm@`R+v7tWPn;SK`PCc7T0w<1*lY2`O$cb zG))sXDmFas*>OIi^AoDXn3&4yKuxERtco_RWt(_@k*K`WyUXw5YJEB>;L7#R9Qky6 z#PwYhujj{^*}*e5mG0Z6>YaOZ2XCs!Cj!&x!t5a89@f9059wPvZ_2T(U4X_ypyKtk zp&TdH6JCsyGGr?V2HxR3>&h{n82AL~~PQY2jY72#}i^((Y^w5jw} zBDj}oN1X>vo>HxE{(qLDgD*J8vpYn2F=2-wJnB@y4KD=3jCC`90i-I%q#Ox<=4vv>%$+iB*d=^60kIn z|4_P~`4HaBJu!=<7iRa2_dmu@KD3n0R8xqjU063|;)n-!h)3m>g;UoyQlM8p`Ir2U zsI!cU@(Z^(NDU1m-3;B049(EpEh!-&5+V%}Lw9$lgrrDF_t4!90tyI-gcA4lfA3oN zJ0IYzmvf%jd;i$&_0#%~31$HdWd75Sfd6(@MsI*RGR0s3XM`+^)8!icFGw9QQSdQk zFwX==C!^4Keel9FA(#-YM2bSy1>kxFjsrvv(4s$41SXU2>(8LyL2l9Xe3XvVJZcxT zw0IoF>mM6u-i?U6X_T`;aL|sg#+Gq3(F-Rj4xW6k9z8A1khHuue4 zt`R_-mhK)H4-yq#XD@j)8waZ$zp?sUfl2dTXFisfwN_X#^pb1q5vjARb5+;N%|{Mj ziB56^O#xW`jrhJv*TI%UbX@J|rDd3;;tW@RH8@BH>0)VQ;zYNSD)far>YtGi{)st$ zK;vaYi$lP=F=sqhlS%HHPl#CVN#w=@*`w}5Z{K6JCKcp<5R^(sE-(8VcSky+qzXg+ zfO;?o-+1e-cpqvVoRT~LxBQ>OD7k)FS6Eh_u2e0lbQ)+|+5-LWj$k+yQdD!5N33PR z(Xp^(Nbzqf)v4Q1>oQM%_H^mc|AM+J9X#e+!X+0514?>aT*|ks?mQlL(&zQQj|ddU ze>{uTdcb7qdx_cPrreMD<#qD)5|(&?F**pQ0=L={D*zZ`KEebLIg&7{Hh2c_>7@}8 z5wCUN@V6t2uoRPo6(X0Lxn6t@7W&@CeiFi?;G*&8|)N z;iKxkt@zicqz_w<+2{ZE0Z~ssfHq|uAKEw3_G0xyE^^#^;(Q3CVjX!ICufbe(=z^MT zDQDQYYIa%zOb(5J%tlsl1uOAQ7&5bfP<9A@Mu(Qfm4MlM+oPuOH)lKS3NncA^F_ay z^mJsWi(_}afjJ9KQ3j#h3$R(#>cbFk`ekqLKti>+DbjJ$tvT=uTe1zXorAvAcpNDE zd3S4sxp{hV@b(~GC|yb<`-;=U>g!IDt(U;h@TBH`Cf839aG8lpsh6u{viEClvIa>Q z53x-poGH)jAJICkYm2bj90H=MEq6w#s*Fjh?{Fw~M zP8yWh{B@p=gfOpk)oprTmw|nfQBNbP9}2dRn(f1BEa4nfw`G^!Xw!HTBrMR4BeFi3 zuTzzx)2M(@Ns~}UhtSlxjZiqN1ElEIQ#xargjU8oLJ+`^!&T%F>nK8#(l8-$%H5yu zb(Oh=3{sD7YDZJd-HY~RBnW3)=q!%RdN{K7%2uKYNRLE)>9>Ghg3ul8UiPLJ-m~mjwn$T zyy-CMmll5CO?oMpGPc*{mA>U|KTZJ>>!VqcoX_6Z8rQuuyGRKWvZa%dTQ&0>K5PMt zkCN4PV~i0D6od`Z7c^V+p3P$0xQ#>q#--UrwL-os)oGN=7H6u?o@d!>h$g1&u8`dZ zQmL~1>+l7;yu!%d&0jZa4SeITEgM&}FPj<2(A0T_6lc%!CWyamE(sVZC6@opRXqi% zBYGB%TL##V+Ot3MZZM~Hk{1O5e{G8sfr^B=Hj+E(qpI~i!ro#an>w_uCJ24CuTk;jKjFf52@@|(W{&u-W7}Hy} z2ls=GQ8_$;3jxI~;!GUFIxgvA_6%?D1z)l$@)H}y;@nvu{r;$cqH-4e+0>>LG5ds& z{H;xTuL+cjj-fxxjZ}SSWI`x<;WNGT{o@4%3g6iwNpB0910L1IuN|;e4STD@^IiVs z>~PIIhM>lk4okzt!a%IB047#$j=21T2orj^28f3>g@73PFNOK(N5pe}y^IvR$R@nJ zS%j`gJ0&1s9>$m@=lYB-@MyFiL#k{f$)H?qr=6NpEYK&|tv7vAto|axUDvCkF6wKx*X zZK2}lEP<19)3AjfJ1q-qDfY+CfNvZp(~^V`^O@c1iKeLZZTecymx76{O&rsW)eHSi z9fF-mMLnIIkmC%6+cX}R4RYb?uZ|ldr{YKq(FIw64_`zA)?jv_tR=-*5T}e)m6=&V ztaeKrtAsnt8Q<1mQQIx}f=`yUW$0-3ibysuR{mtg&YEE_P0%#$HEXFpcFH3UAgJgB zObQkkQvv_G#obF38c!CMRr=bXZD*rx?Wv?I;2EDZI-Em}L=AS-s`&>~nH<6F0?)^P zA5ly~jT&#Rt~Y9b)WX4OG)k*i$S2jsZ|a5)!2qFCYqUS#K^A#RVWi#)H74~0w;>kS zDJON=z}ub6aE6TWH7DPrpwvL>u&>CYAIbvoqW2?52GoH}zn{hS_k=v1mxwRn1^Gmn zqw<(zmp}Q0er(>3D~PcE&R9^b)2J^RfSePkb8XCBrmqAw3;KI9d8M|gm6fo4S|w&h zJaTlUelvPL?xSh>I`Wv2#modHFRrmUU6jX-)nbohZsWNbxifqw>d~~AWrYWkZ*!-$ z<28B(50r<^XzGUVh;S%MR87?P=r&MmQtnB=w)nZPNG(O%QHr@P)LXDO>x7dvCctUG^>FJ|73Y| zpQf>>q*z^}a@n$n&KzLBERrx}JMN3o5$QWPtJ~Asa4iJ}uV_%!!RNacqWZBAJJeLo zJ9Z@cJC2Y@+dnSeX0}4gVJn7`QGN~6pi<9)8#kw~ocQD3^r*s0jq1H=l9SAHvRNvB(9eMo6 ztyZODgzc^MUH35Hf~ESlRtPk-TEX3Z7^f8+$5sF0ePu@^wsID(^4`f)0s|Cr?>7(E zJ|Qb7^L_ZQi$1D_nFu&kkzhTzs$RWzi$UOc`3)7yYteN$McoU+AS9k*s}A@q*EC3g z-~7Np?I9(@>rCstu;S#Y3irMt-&J$=`5 zbU!0#FPn>{<{o0;eSkl-wow$9kcz3je(m>)3WA5N8uHvWNR%r3Z%iv<11()$Qsq2GqFZ)cNulVYj0%2+f511b#3B%onR$77n&h#F& zLC^AA3x7f({O703%CjHk3{n9Z9{0Itwi>%EsWeCjW7$r*aK9&{1HG98kS?uU^}W zdf?H+g&ePrJBLKYGFYQ;QDCUFr#usfP4|HM&}yjU!#fHoc~EiM6dpH1WsS8#rBW}G z?*$f@=NEn&Urs5)K3<&-XgE$E{N|R=cNu-HBMFQXoa*6 zaLF~LnnDaucPob>5j?pc2GRh#h3G-HH-kiXHXi*=Y(6xwUGl~^Ox9u zhp;9VES$cJh(!MY2}MPfMCwFVo(nXy*^N6RtEqrffa_pT11_OMuAQrLG9nEn0C!t_cnXFoD0E%*4*^5^FCX-fwo-D#@NW6$(*opbMsS`1wR(2M`sv*`@9 z9^0T)FvDMd^n46X>Xkp{tAVunc6KZoytjU=&YwJH&AYhGyF~NH3oU1lXE3zoh_#ZM zMpX;aWGe)Zf(tG;j1eEdrc-Fsp(=U*@i2X!wOkl?t(Q8j906}|T$c_wJ^3s>rM zFYyi7Q;O>Ox`Z$(BGmS1N;EU7faJl@mZZ^N>w@>%D#!MsC^4r*P55e@Wjj^inGS+V zsUebiGsPQeXm=;=N(pC0*GCCQsX$Ew2AKgd;?SxtcUeReAVhLVSH}$B4RN#UrFA2@ z0;BgZi5%~X(jU8ViH7>g_BB@a4e!J=*U03)ikUS@}``J$6c};JEWka6;mqK^R*4 zP~NVN)?bN-T3ejZ$Fj|7V(y`#?k?Woi-E0t_Q#;amqMyt((pd3*y>82!Qz#fhH32~ z@iAZ(iVsg++D4)0vXZ(=o2`&i5_?X6JfW@r-aU0)RPlQzs#XJ)9TYIH5yQ-#e#98K zF7y0F1WY~IC3uWaitZu+TY#n+xInX@mEE^NjuBO((F!*@mAi2I)9$M7S6748Yn+Jv zNTu48@0;NGR3`V(=Lf_WC%O=m(-BS?%!krZ3XfXeZWV0R{*SB^rP0?|yeVpHO&KSg z5S4bsXBfN?q?I;UwV?zb;MP(p_lQ40FcM0d5|8y$JqDy;Ts!wCY9YmhS6t#rFKSE#nDGa~soF==G>cU&<=k=JRUH;&EV9 zi?MnfFu-xJ!EGoLS@pVN6+jRD=(^LMl9uriwM1vZc?GbfW~NI|e*Zwv{HncooMTY$ zGI#ircuRru!;jGzS$SDiLwJgqtpj7R?vEj|uW_E&=_Yi^R&szGO1rUu-3_eb?X_Q; zQ#UG0U2Id#+DFRtdD~XGI?|-|8jW60uOpXExfkCq`3_4?`rI-{&eOcj0TS(NZ>rfC zcz>RoAA#IncNleeZ-g^qZeVTf@llrph%kekqmug%^7jAfb4X9v@=)EubquHHN zd-MGXdl{`DgRC9M_@a+#JD93%8R9J+iJoU|`%d$3Nl9A`zk1X0^XPh7I|3p$vjt9s z8qVX?xDy#6>jWGj3Wzq7SK2-SsjH zXalUtao(?w(@j|S+<7CDLoyZnS0YgPF!Yv}o|`!P;d*(nN)YU544@w5CBI&mr=i|q zpK)bEVW)VQ9VNjtP*v+lMvt;I_3TKysoaIq#$yg6yuTiqca<$3o&X!^)jqS(EHgeI z&e;RvbSgrb)a~gKE*da6lNcG@6H(r3tL7kMT$kU*#~pFP;nNRhLh3g@m^*rzwx5_4 zo3tod`91n_0cJ1JBvtaH1k9-JlOx|1>=V$Hb}b0ttAn;!$^dY~M`qPm^4okqKCSqD zgo`7Iv$#bz$B!{OFVc8aHnh9+SW!o*KyC&xnkjvWDs_B2Az>x+aRi=V1G7yye*an3 z?+DyCQI?Ey zqcbsns;ydVGxUq(h7OB!2TRiZ(!PKA%Y+uMM`JXl-RM@TsJ5--v6HYq>cm+IjgqF|z9Ct3S|; z#`Qt}dT=gJ3hb@fdXbdashfO=lT6TJ>@`&7oeyOXuOVX`Y1ULtWhih)=vBxq_TTG= z30e)BQSX+n2z(j-eumM*i;oNoyi6&uDXy+|+UW}eZ{1CLeMgDvkHDuL?>`1~tWY1f zhA*cL=r|K+88?)YWZX>Wtu~&3@xqoFt^)tVOGyTb)#G_XKWJ5Kv zk3QwWd1*&5`&3hC|6?vMAHZFFQ{RFB`#W_@hG7_;4PsVg|3-^{4iqg1pssR@#SS13fbxf z3qnWYfLJO#@owHUG=?OX@l*_#v=Ale-bQD6 zETc?)pAyMJd8|M!)MYJHuE;e)_3kx7PAiM?h^Ph&;j-Tm1QD@@$`#8z;`9B4OQM5h zSyq4rH7gLUveh8IQ;^_N#$LEZFm}b24n_dT{oOAHNon7W^L1Z4bzgVgbh_M}ZDg2v zt^g)xW{q6$$GgKNTn7N{!vOHYfjAG+uJf>Qp9SY01^_=zs@W|F@gl-BWlxutW3&p^ zbeW5H8bE{GeY3=aOaDtn0BeIrh4Zjx>B}LvkzF;p#+jg^#j;l!MOEVCrst2+FJNc! z`CHA%RUgp-2R|Z@NZT15at0ANOw{sd@d%o4c0o|`=ObIANyzAI>H%AiwJcgkvAe2B zK)(E^@l#A8qurlPBa;u}tiR?zdR#JSY1>WcxCACYj5I!mNF<7+5vt`grP2bFFm>TJ z30AP%JA31(Jjo359+M}K7)|7n3^KF|s~u!;=8V6eiZ3zae=71qNp_00`6LxOE;9=D zR}3?@Z`1NFqK}WSI~(j+U+UjBE_8FUcZDo*aSZcJwbL{+u_?RW>o7L^l- z6PtWO=GLjhe$MsqY~&jUqAJ2}2!pu_LuBG4OBsGCoMo z64lD+A{-V+Jx_aR{5E%-8qIuNYP;6f#^Jvk0`N~v!g|AbH7oX8!vd~DeUv^t-L}sM z1`w8J{I}1mR#aOTv~sS^N$ZVF?GNQBN&1T8=%sAjPtJQDD*oq1MG?sOW+DNC0eHJu zwb;oI(&;>s(j$~py?j$>?>|c`8IJ&A-}(Yj_WaG~l+T?y(uF&Ov<1@CQ3~rkHh#4d z5-<7dX^+S(|A7+|1!^q;jGf81ua)6)PYdt)K6>p|y}o((QVt^B$iJNwVe-Loh^crJ zhC4n2l1)(@rB0srkGO0SBgJ_M4t77LN~s$>{4@XThvKVLF*4T=&IbBHrD}8r{O&-Q z_P}%7&u9)NwLRT)c>!&kUP<9{O-X{M3xYcObZ87{MS410m7|wM#T3rQk(X zbUaV2Pcd6Z6ThgHibGKLd#@xVU6mUS%7-@(bLC`u8vE*B#u+}oWTG*RPu3`kOvWQN z$iXHap|pyU^>Yo|InGFz_wjr9d0qYAQ40Iqe`i}Fk!2?$*Egu!bye0PMHHbORshp< zBuavR-B7?E3>H-vU~B*#?*g!b`+d{GtC*C4pL|9fwRrc+TzoRu$U)2T9jRGGd}@AK z*it&Rv6`({bziCoVXv|n_NN=+a>!)c9}M#oo%+_}!cdFeEnxWwXWV7TrivXc&Y zgaBmDS$DyPF?pEHJu)S^LSfAKN7Z5^d}XDgV3eryL_{mhnxUT%nzTtlR(P!x#4V^R zibYhCNG`{=_^y}Yxh__R{Ca6MC! zw)fpO@6!<$N^C{TuQL8`k-GQwd3^DGYV&(~czeSi&j!1w+OaCr80_aU1;zo=~BA1Z7bKguY;awZilj$)A%GQB+s%2Qj2#W5T5ZT6BU5?*?f4kUU#HiWBzD7GrFGJT(FWgzv~O zSyY)9)R@YrkITzCKj!*O8%~8XvD-5OQ}MN5vcB*0@a4$IK@KABnDB9^)7n49tv)bN zegF(D6(5=d{uJXSBH=8H__&dSjEO~pMhFF42NrkmlFqht1>Sa_2IXI2VwoGcSVB%5mMoPWe|w*anV&5j-QGr~og zi2mMH@;WNVLLr0|scjxdpKCpWOB}p4sp~TjIvNXc|D@BOd0F+<7gS=&N$zX|^A0AT z#l*z7oFcVpxmHDBc$cOzo~R=KR&w3TwDRN=U-Q5Y(Qy~V3ry|!+i<(HMR+fA z-uVnz{$!@2u}~<~+1q`sYJNVHVwZAXcr}Lj1DOSXI4@~vE5@WoFy|W_j8MMUQzLg| zc{gu=2DG%RePH)!RjpFBR2#!rAN^| zCx7tCaY7-XB=oE0;UyUp1z)4)cmelyg5tXWs{HBx71}Aey_RM24_=@d4N2gnGg2OB zRLz}`W~8QIEIgbE&@105ztlB3_IOHR_0LmEC0&w-J~xb@;OH?=4Be5lFu*h}u62po zecb1K=dLU}D;@^JazYP{t2_blXt|U|LhsbshQ#;FiB@hi2+TY2< z;%u~%Q44y#k^*@XF|!lVNokuKj8%iqej*WMdYG@qDe5#fhPjOpC)+m-aK> zA!jmLb$!PC;q86`@7sX8=F^53RJrB{z(`g@unTZJTEB^{5@s|K^~}{y;tVCCkKhVQ1m37`xefXtzyve~ zFdQaD>hwW&eA)&8pbst7JQxRED<&Ur zE+4vrM$~=&>uC3y&?ePMLT9()+S|4veRVmIyh?^sp-6_-cxVALrD1B4;~C@1uxhIX z=OFb8+nO4jF8JByMgJ>rvaIpNrn0tP^rYj|WV+xFZ!2K0krUQ|{M-*rQ&EWN%{ems zO5myTbH9b1{sb6ea(_~V4*3;u9<`i=xAfxrf`#2*zj_l+q)des`CMt5 zcyNl+_sE9c@$em=7lDLY*>MaSjG$2)Aum z@_uvxQJ2)_6oEN55kz5yB1LySBz(>utERz@ZT0nHuk$SGFi71vH8GBrbNHR_$dMyQ zu$UX^0@e?qb>74zQO%eJk!G*Tz~YTzB=ry1GPa33<=h?yfxAU-m+q7%tKwz|^?iiz zRH{_6gP)`2>hL?y3EVQMy++}e6MpT^f`-0;S@)%Sk8zRVr zd1)5@nw9!^`WG)Cdt_>dAic~at&;vnQVPi-?8{hCxRtM^L00L`FQ7O*^_e^Kmw&-u zEuI)|{4ZBVQ!)P?>2t%kAZHTRdW?w|`p@6ha2E8JIs=pc4`;&+lD|Sf0wxr<`nc!^!d=$s)h8}t z>ArTCK*3koe^~w-9Aou@p?YzbGc14DjR+%IOWM5X7fO8`9Cj2W7IOosCiaX*Z6cCJ z&pn6zdB3Q#L?UzymcS0ng@^&O{ZI@_t?m{}UYw$vRGG-cqe0)BgsU&Q{3!K)#R5C zOAumNcv;E2N1?qaLik}jv3mdYaFg+&%SZM-^ojOw`S157Cl~{G(j&>?3;QF`lJrT} z0ebCPT|`ep)$(VGM)v`Ci>aPJjk+<)zN@ROf9few$S`KI0P2QU8300pm)!c6mC&Ir_ zs4wZ}3n1$SJ6@6D1!FmK5+0WkCiO(+o{S;*(BF0i8F5k)IYcQ)p+m8FPf`eG8V~2q z-4yOXf}^kL$`_(}JqJ>23zf8w3zderp_n2WQESw+D{+_%^?K>Q7r1pV=dUx1{47#& zlp>d~*`MhhAYZ780jwg8SVNiefY9n-f3X+>LEXmH zjCz#l;C;?ONA%B_0}$y{m+5bTc;v!oT$8iH?P)0V^+h=2)7l6u6iyacBK1KNh8mON z%vdoVqc~3mur6M}n+XYV?_!+KdeqBCeH!W9FJ*$qc*q*o9nzlj9}(z;AML*H(-ocq z^t(VL>g%Qf$Zo>+un!tN?Q7x>1KYy~eBY8%yqXj_2z0)^4kOx90$%#a7t3Q6&{r=5 z0Nw_9BvMqsBoiij>f17{`LnbD6h>Q1hP4}MC7)^(;o>ijUdK+5kF#Z}EhMu06mAC_ zJ#XTh#8`=G^mdakB{-P(s#@zz#mP1dK=i}rxLC0~*hUR_TpcRSmzPa6piv~)*L<=d z)IOu+=in2M84J#&QE$U8Z@wlK_j-Oq+wEPLnodz?M{949k7v2LvV$~anj&vIte0~Mu@q->u=_c-sBoWme#uk73!sDCwEGZHf1)-Nr0E9yhy@;E!34n|sGs?j?ZHV6Ac|~A1h_TY ziI?S(BMi@7VXSI6ziUD8fx*4ZkfgC`asP;Yhy|0)`#;$t3flmp1IsHfgHh+5|pI$PIp<7c6P5# zwUIy`GDGuW8Gu1$0{h)xo4_iDB}00D`w9!Fk6slYoW{%21JGPPFUbrxTQCd@E*%LM@gAN0BZoz0`?ihsIJiVxEtis0ibWEGeNsuJ_bo+9rL}C_pTHMig>&3YKg`Y4+ zg!mP`SRY-R84Q;_hlU`me0TQk#Jyf-IH4KxnCOiq!w2~XMO-a%Jy4W(;tgkly!wzc zPL}IhZc|GXY!~e}`I_|yjo6s^e+s%^b>(TqWKkoss>2+xB#;bZ7`IK4{>L+VzTPi2 zld3yEFncoVnVFpi?>82~d8tufS2DsNNs|d$wo_^K46=!42Qk#UQD=4GHWew~@(lpg z?PkVGJgFt zV8W;JvqMp7Zr9bv64FG)IP)1#L%TIM&%ers@jWpqF! zs{Tw0l-n9Tw(|E2j>o@KjWQbEoEF(F-yX*N2dQQ2O8M}|jB%4Mx8XDw%Et;Jfc^-{ zT+R6j9x|mnu$6UJ@u8N0B{upSdhj$G6W- zl}5Ifl0;7LH=g^+(TJ583WHZZ$|Huw-S0ymf326ee2-%OR`|PO=ndQe@HG#&_PHoh zs-H3$!AV~FnJI=nlVjq9kr&1GnRrH!_b!JE5c)!B0hOYJ++$ zQ#i23?5(TZoh5UIUA?Aqaei6yY5X!$+YdVg#*~hy3Ye03eX~aIfi$k+Qc{?~k^+V1 zIvKTbv-8~x5_$|q0#1N?^c*xQ+nzbm?h(K7@3M^|_@4iV^x^9UD5|LMrG&L1$J$71 zYdnF$0GTg@@l?iHk4klYjBELjoc0redt!^MC0Ybeta%MU%8p$D>fL)bFKH#M{dr)E zV*>!+MZT2gg70~-_u$;B&(hW6O&UkbD=UJ_9R^!BH=7 zd+&+`i8P2H+e}%~sRNivlRgKz**J;Rj$1{8Y*3G+klF6~;#m~wz9E`;mt&hL9**d@ zNB5CR#(VH?*)(z_+;W6R_9tC8;&MiIV4h)wyJ(ZOrD7qym9f!N^1gE_1>R zRG2Uk8v_Iml~(GaG{u%gP#Ey7Z%})}rBby=;=y4=@PR-t4wzOTUD5Yq3||heq@XC| zyW#8-#hX#)^klBqCY*?;{Y0n|i`guzk|#G?R@O;O);0#^XmXHDP&D?4C!ATst$P{I z9iZ_vi?t&Tz%Qi-^#JZn-rN1)2RPYwTla>A=Kd0|Z-A#M8f--7>Cyx6Jh3pLD#K$f zNb?PiCeyji!Gj@jCq)QUabW&P?~W9zqoXJq{Q^}3&PD(W9i;V0(oh|^ABiVZ#hmO9iQjx?FreGtH0m-`9!l4a#5S8$()-kcBe$-qR~ioVIQjTIku;1%+#;I^KL zd4K;s5~k5wW_4fti^V1T#rt1?-|3st2ryf+pKt`njAw78&iU`D6B4nxM8knu(>V6p z{yrsR8|N#Jcf`S2Cx4S2K3wX5X5Ak!g%vkd`%6Y}#d247$STRv9H{q$O86KutWm+s zNI2|yujsQTNfi->6D8P{{`@RPm&dm_wMX=VPf@quDe|W5L}RoAnWdi`x~{2Vvmwnt zDgF%L%#A1wZWgs{u5c!5`(1`I^(pMamBvQNl={LD9J$R}Ij>PV!Iq8&MTb}8H2SFF z9ju#xjFivY{Jw>^Jyhs%M)%(>$#$+(05hd}G{oG`!u5*!W_y#W#ej*7pSP8VO#|TX zh9rhzjLj!XC27NC4w!#3B#BOAk2!3QBVD_UOtS7L@5xwV!UzDsLL&st2#=|JT~I7S zwy`e#dk5ibHY$!#lG}+7hr3775=T}3=eCJ-@KC<)BE zb8{%&d!=5B(YG1S@DtyJQ2;!N7C%kcOwvk=o&F6f3Xvt73VWdqUSK`Z^)t#7reFF;CNxIi!LU)v z&urgnR2ns)*X&nHoHH)L`;lk~ZC#rNRQHe7?f;%~9gpJhL~z*a>C-!FDo8YIeh^lz zr>D&d18QOroPbfRv67iueP~+ad!~vSp)p!#>}zUanmDhem0#Vgm40qFMBB)1 zZ17Tf?E@k^>EBuKHRaZ&k@U&%t*sTiclGd^bwz4l=^t{HyCD-EW8d-G*Vr0%oT)t}7noEC$SgwU-I z`T%h>K&_n+_F7rPb6iHg7V12<3|ot1x}|4bxm_X!M>Hok!Xgdw|McO&r}aeDo$|`! zYnWgJ%ifG#BP5+htU8O+>2^}Fi8JUhM8q5ly={$1iFhb0uZ^IZYPf_5g0^o|3*Dm&SDXWp=?+Hd=H@FRE=8HC@Re6 zNWAJW>dd6`Y36U1%CQYRamFWniGi<*MpnUL=MHb<;yD?~^6P?591lM4XF}!6iakW^ z9Mj0d2~9JY$dXw{kfj*?I*H2fj9_Iu!8Xn6qbb}JKj6sk5_x3$WgrYF%&zX_3|5MC za6vip2!4SH1>T@6I=Dp2%kz7k>pr8*da4lCm5f3h-L#+6T+3{GgZOEcz^FN2Hho0t z0a;tz8c)X@8M@zM0Kf^A9YY_iuqn1WAYvi?iAFPkTgVJCM z7WO07_u~?A74a`A&tg@`WRpYb`M?q5vG3)-#oulQ`8DW#OI10!w86*zxTbLC7UMkP zm6pjyo1+JU7OwR+KYK!ids$F}px5C*tpGtK@01j4v=%8%MB%l5-H8(i5DK|Olr0NE zfgppE9ma48MAgsTWE|acp6IZxA1MKQgGtp+!AjTG2hx$KQ_PAoJt$zRAxra{7`oY) z zDF!6cuFiSAKGFH;gz@iUl$g2I!T$F_(3M`<%8xyY<;+>_{9TeIh}cce8JlIERMC>d zl`ykGNzE)pSS$M)1t(gI@AwlV<7^tQ>O&ayS~$grt5wP}3K!k=#$d^scSz$y&liWJ zzJs9i*#QJL+YI~lXs{iCCVy!M$Q_pB2*YAKp$hYw?Gp8T0jhB7ilO|0m>;@lk$l(h zc0*gGllxCr^4@=ou+C1ul@;wLq93_Z9b>5?8J@4nEMX!rHeU>$y6sRK28XTb3cMzN zXRoFeyCf$(TnIA5{ZQ$zLT!Q+x<9}r6Qx#KG^-MA2~lY4sM*z(e9GMsdA2Y#HKxY( zml12UGGuiRK9tABTUn~a9||Ra#!gC>U@)anLGTaej2K@Q!@l(^H7Ul39T6$=ChZZu znE6;E6PBN-{Ab~DUM;r7;MY{+Tr2(+84$7JH!D%x(;c%ja9Jcs|5YUDt(#F#=%iIR z36<~(8e}EgE6|IZ>64h2UM{3Oodq9E-(L`YD~lX;K6Yy@wmQHHzFJT>CN))&Rf!mp z_}U?3!MDNMc&PCn0?+j@b4II8ZODPapkqtI zZTp~LTxgF*ge(FZ5`u3}9IxvoKiYa7ufw@T$0pFa%aokkA&+RKBaNOM7TnU@5^7fq zD+baaI$y5~NEY6C_Y5RsT|=)%q?IVLQKOYwqvLGklFc*5bGygr?lNVqxZa}dzB_W>njpm3&!{NW~@ElYG|Fs1e)d=oI-sl}Tc`yG6i{7%ecO zUM$yrosajh1__>_)BTo5danqUAm6ddG?7*{gG^Lil>hs(*!=iP&l;({gLaB1K71 zdPE5((GftlKC>(L1f~4NO5>f{>ZPr>>T~8pj1(fa6*s!!*V)6Kl|boD`xh+B8H2vO#*cMNEPzej;;?1OA;hDkfR$wVI|+#eQyWchCOS&v9M-~;KZ|I zquzuaCx#>j$ev5wmpL@Zf%^sVaTz<(}dI?Exk9^G+hzF`{ZM<2_j~!w?Li8a7@_6Jk#^nf+Qa zsRuKQ6PA4{q9={_%Z6hA{?MSF=uM*0b=+8Hlx|@kS<@4uXuO$Olm8@Tjiu%|TZ*q8 z`Bm?Luay2VNjyAVM(g%^jG!}p?gfw-PMcy5YU`xiPp5z(1%0E(h$bME)`Zu1?|_{< z1E}fevxRkakL4m|v!V#xd{jBg~E&8o>}Wbh`r=ULE7WB&*|4W(DxFZ>rwq$ zC|sZizgS=@bdCS_{|ty3|9I3uB)0g7lJ;FegyAYvqf2tYA6eU}lV^++ zO%cYt;diI$maD7+_S^7Ncb^vd2!mCxJ7i!1;^gx!ZVk8VeeW%H-_E(e2uOKzekiB2hy z6*>XLuEKskds4g0!%C|+e?OKJlvKX1_gwqLN7?}?1tIr4R`{r$e+65-y=GN)5cBU& zYhL0Qf%92({_b#&agvkSk^8w4ytF?|AE&>cS0J5MqN($$12%%ZhL=oC)y3;?4un}a zBr{xRNhevoK$lmjOE9wObH4sn?h?i1H|9q_3kE{Lk0!GXWtH%vZFmeMNIv$5P6A`^ z{ls{q((xIDOI=dRr|JMK3V?5_u<%ro!w zH$ODm6Dbp}n*VJ19D&v6i4eGai6A{$cSgBXpIpk+#&iA^g@d9^6XRUzm-+;!M zn`)HY7;vyRYq--#9mm-Y@47BlB5`x&9w)oKIDJeQT~1MKe_im|IX2}t)24`S%Z!{!gI9gfH~ z{+Op);9;xqL=*Ee#iwrf=R@no;9BUyTJTpHooM5{8X~uWarvViEh=XT}LF*4;Y!iukk;n^9z~?ju7@=`E|_uzPSg9ob^eOzFy{ zHyvoudy1t&H0Cy9$;)8LN2N1z=UL90d& zBJTke1@fUC<;4KRyOhQdS~jR4;MR#^Errub*xL-2np-IbD-J+5oNg4B`FISbRlN6G zBeld7mw-jd=_VkN(@x~*=%&_@CQ>lMz;bA2vUk5jdVyzhf23J()xM&df&c(z?a{4W4CS3^E}UUu5(?F z>v5+=tC`YFA3wu_PfuNq$?Qz1Zx$0k;on-i`733%R+O&*disxDxgIx9K;^UC!n_7h48CPyY=M z3~eK{S^0bqy+8??WBO3SipxpR^Tdh*N*SAy+kR`@Q|9grh@85J(BStnDgS8Z z55YARamq`?AFS>(_}E6vvaTK3cht}|Kcw$)rvVA(B2fWW`$KVA>XPm+Qz9Fg$IaE^8TC{wT@9wdmE`hKR(||eeHNA!aOG(_4O>jc3?swB}Xw+kg8V#4YgBQZeA^8G-OJ;x&p0Hca4zCrQYtee#yS9inBU z80a6)QTdA8c3SBX+sXS(`)-cqY6BS);fxv4>_3)T#Q4zAzvrQ$BVwC*ek-x7y@}1& z`_1buH^)Psn(0Dw#S(1v_2|8^=9qa)ikjc+w$w}XsXhult& zjVSWOH18nKB-#ww{!@i|Wg|hDPFr)xvEFy&_Wpca&1&yF6CWPDUJi5Ib2eFC$gaN4im zOTl?qg!cU7_x>TmGZ{u8Os|~4l5rW&8EVCr5@VLO>8v2SpMRtS&BY}r6ndtKPC>?0 z00CV=_Xj7VtLoqF%Kt{OuriGJ>udfHH6mDe3Xm(HF0al^kGD$~px-E|v{bxIvKr}+ z3qHrT0&>2gr2MTf57cXr-7t1$eE4R4?{WNkAoTOvz^SUu-;rue& zO&X)y29JQV_Jy&9W9v=2^Oc3>DYaM+t&nWF^2UNgh>^lu5w33(>z1q~n?9X{bT^$W zH=S96Hil{Pflje+R5PW|CUxKRht7=dx85N|rxZD#rjMrc5XR>0f(FX9ey=1mk^Sol z`VEetI<7y!yX*Aw@%c(rUW3MAqzxgxvkhm*D@imeW{wb+oy>C9=?TJ&Ea9V>NFCv( zU#bFR{LQ|hh&}>x@wMrh_pdtGaz2U6bg;2Y)Frh-!9u?`{N!3&iVG@u=4WJezF;~O z!SFp7{fJu7P$MRR;@3DZ=eSg~x z_eP=MAO4%c>pT_%!*d@TLT`61M!l*5b{^cj)=(hThNv>)fqegAX@k??4PT}P$-u_BD-1BJBQ)^$W(u(3Nh*eU6s2N;cK zzGMNIBwRk8sk$HUzByiYuW2Rh->8cyH_Hy;Tx}_oe zo`tDZjLE;u4gxZ7cNs^46uVT}ujg);iRLnvuK+rw|E9IHv;h~`!-mzidt#wClU@1a zh1hG6aOhH4N_}X3hjcO3+SpYxkA={aOESiF91=8+EW!49!zQ(#RW$ZaXp;)Ams}D( zAMb9?VSnD>k*C4>nu3^-Ck%c0;_GpCAb0Q|bb%PY&hJjYD-6w~cy*FF$6m|~i7-Z$ zf5Y%9CfE9j?V=*k*-fCWSgje?of|c=kHnBGX~BzAU!g9MdQohU%(OFF8^^U4{cuoT zNjEC6Q<*$G?OdU#w8H)68hmMOa3J2M1&rt~Ne{fL17)n?kYscR7}-tr0KgeF+Kky5 zYfKPCh5E~*d7G*kC%XDT4d_hu;hDBqJk+Pzo(+~0y6d}>L~PU1VER`e=m|R zPd0shd^W6p-dVnmpiZYB?Cd`LDC-5XkrX zH_(buXQUR>8HZ*%C>pB8NY+X`;@Ox5K1&O~4<+;)G5fa9G5Od1UuMUB-$;%0(@-d<|bkPzmy5 zZJ>5YDOs%iuH7Y7sWYpXr^{^*CNHzcK_zeUHS7^Cxudd2O288=rQjgV8<*WE{%h{_ z;^^^aJ@G~?%j39b52&5qwFYM88-pozG9+X9t0kH{y3|)|Jv(2Tho+j>xv3;kosqGl zelu-YZJe_JJZwm*MaboPg+X-{Gq49&n>18Or!j6&AtHH(rMytx=wZ79T-}z zQJqWbcar<7S)ebkSJqb%Y8-UbM`K}<028Zf1NK+5v-*m?{Fmq;s-2S2z5w!^>%9b6 zBc=3A>(Pc-$C6wxRa_^w5ltQ%ko(~YbhG#*HV(C{Lu0d!Po0q| z0I{GpdTW+XnmUmF#~j8o42+BHWf80Q1)@LINL)q6&fIU6T0$r{?zP@589If4%|rc!^E` zh$fO2k(huW3o3*svy|=7L@BsMv`>}Vp|{KLAI|dVj%HpR=;1^{o;kjfaF0~DdQzbG1~&$U}mKJ z3gh|lvyf+>wp;()#hhF{$ajc8YJB zk;6RU-PLIxOI#FnG_Y_FaPyzyTB|R~JZ^8}E15bq2?WFu=V&43wv=EY8W9{QB=)B< zt!z+>kqHI#-YEd0!o3fAv0P}DDP;_!yy?GNK^4mRqm)LO_i~8GjssB_$+N*L{j}}e zXgZ6^7Nnb|E$eS*Nu)X%W;pkA-AA@4Yj7QBxTaacx~6s}l~c^)r;Sm@w= z=7yFM68gr12mGy7O+RlCgQfK8c2vp^B_!e=f9}1L!DOGj#72jfVQ*_5Ij4*1?ofu% zktz|egDG3h?N&1G!F0F}pyKJp`;=l4cn_Upy2utZS{uC_(lckn(Q81kKwIbrVBox( z?D$V{Iw>#{&DHy76@f#$WnKb>-0xp)S_S{)DRr>_n+8hpa!*hw3r}j?1gn2h^xFK2YUC#0VYB;n8%n zaKT<6j12A~6hlR%gK~?xS#2qx01!jB)qcxNG`S!fUz>;mfdH0UD`Jf_U%3b-Fcu3L z$hyO-eef~Vs$0nh*lA@69(4&UHKu8?Y+_%T8jWW{bnc(^o1JIqQ0x!nBC#u{f9$z+UUMy<0Z@X=SYFZV>l5Wytk1SMj-$c8juWJ zr%r)kGIaJ~q{|>b)8i?Z9T0=@v|n;tC1>t2A*2iy$7QMn8hFA%jLLhNvbZ@0`cOG1 zTOG}rJ@@zdYUbb)0>s_hnbh;6D+>tu*1qv5I%1ebCcUF)~{ z1Uz=m`p=oz+a-j&KakOAtl2tJjt?Z1X@wB+mu5C7QgW8^C6pTp(!&05?LJhQG)I}< z3rCT^cLT{h`!c^ZPr10+HMv4@v&Haek54N7(wjQ)K-VL{PJB49HRJMB^xwsnlrbB; z#EgYNe5)28e&S8_9$~3&1qkEgFhWTb0wz(Zg{+0FU+3enDh~X3&vc*VO7^-xV+(Zu z2ZW4xilZ#8)(aBbYKS}(T&uOuj8|}1xH~ZT>w7a39Jw=;4&`kU!7{JfxTdwdNfTLC`b_k$)*VIlL_Km6>?%{^%b zuitsRrDYs=fie735~PL1lkA3ZTIfmVo3!clB<;M2RjmspuaK<(q_!~q{!eW`+Rm{S zZ{Cj%1=?ZFX{OzdDkkSx{$*;ZcJ#bn{DBw8XibFg|kq)N3Z~3 zaQ%CHXvo7bmM$^`0hN&<&N8)#Z2wj>o@#MZI|V5eMrlAIv4^pr<+O1UdkID35b@dx zWHggS=2EA% zWzd`5lq};aOiy{iC`Tw(WP6FDoRK_Idu-esFtTI5E=v4u^;Zgyjk7==fi~@wxwU2r zD{&RFZ^r+9)!9=ny=DWcKPWqm-3k`_rqaFq3Dp2I^GtEnj+p=K-~W6mx8QuFGwzc* z^M$R3oEf8&d48%bW@X%k^HSWqiw*`WN^Qmbci<0k7>lJn>4;=O16Y2jAhU~-Ndk{+ zLKcS-bq`G5r-1`-9p+r@c^N@jKerm~@{&z#f-bR}D^Y&>hEla`VYnl`GZsu)y!*Wt z#TSM{-WlzO*v%so*x0KSvIl&&o((6=jHeQKJlYz!dTe9D3O|yc)aSwmTY~|kPL=)@ zEYscc(eb#X%J_K~-N2z0<8PO5W5V#A>;VC@O%j35;>wmCP|V88q&R>j^PmRjF2OKhBt$UEtC>BL8bAwgIh z8U%qhO07BIqusFEb8WTeWCD4X#TPVimqCKp}H!qa_snWqKc>Usyq}iMUk! z)UGUY_Xq{IR%m4@0j=qWo2mCOVT&^$?2(HH7aiRRaZGw`?a`t@kEhdi?b5i8(&% zUv>MnEf~m1ma8^F>e_<11A;3*a%q8M;D|@(V&!xQX`n`F9Ha$tCP4V~82|+IABB}f zI3&?If3hH<4%sX>vdyQn3(eMVzHwSReqSe@fxrk}KyPG0At>1x6Z!s_Pa`vVo!IQ^ z0OyVYOGQ+_6&VaXJ|>Uy-(-u3%6smu(s+a6f}$wdSHgtA*j62XT1GrZt*77!rtvM+ zC&;8ds?_@p+WBIYLLXZEva~@@L63#NKxJ|0*y!7w>f0##HJRU0hN~5oPurFFgtdv7 zT>u4@@(z8<1Qk?j!ibkj%5yJJrQqHekikqQ;o~LSs3}U#=<)UDs3HaGYvj=&x^7Yg zZqa)s%t=8rH1H!R#BukCb;C5BVmroID2ug<`S+3G5H2*uW~;UKqiK-z>z3-OFp$0S zwJ2##R z1j*|sq&<0ttM-k(QRk{Lf<;WBk$gz$Is03Zkc4&`ZP*8|w9f?ehc*DUQm^ISw^pqn zwXZwoq=X82l$EcNTx>o{W)|*nd-K%`=(@SgFMN=#?Usr@)AjbB8cwrSt{$G@{#p26 znKM8?$A;T$Qx)D zPQg}xQ+2SdOE-&+sCO(NPV15o|K)kcmja&PVv-xM`C0`2NPqoVg6jUU-d$(})+y8b zaNAkaB=mTup&^`$2GQTrz(*-Rc~v)7#5=}V+oRlYK!Q{`0J4ZInHR4@9)NX-8mOSS z02Y52c z9~+VD#WKx=sL3!v${o5)_ao=sv9m|mrmv@q6prO!>^~{`Bo}Owt5zY38J8xS!F@6^ zdH?maYyOSff2t} z2o0Y)M%QgixYjp3EkL7HP3ptuoSH*+Ws2?F;8868KSMsL0j{-Hp0}n{KV`r{YKDx| z2(ztoDJbeL5 zR)fS^53a#2F~m<}5NHW&=I99e7n)w?-ef{f%;r|m@5#*A-U;E*CBV_Ysk^USqmjK< zJ2lqM3x28Hk6|SlPP_m9o(-IJ4Ly%u0!h@^-n>7`AjzW^0`eD%`j>;K2srT++c?{M zL(`B+ozaPAw|AK(Rdw}1-IiU~NmvHR5ydvOIBVp{7Yqh(Ob(Ho{ueQ@mH^%^Ctce) z*GIcW0xqX!W?$k9n2qLMKK>9iz-9p@$nv`^4vOJxdS|)1Y&ZnJdRxNc6b`1r8eUvY z5Q<3HJdtW{$HE}Zk~A!H>BV1|)L-ZZ#^`tgDNL*Tty)k_cIz>56`;xEP7~?JP;*a| z?bUBHcmi7>It_zO5mH=vmMF^4&>+}_*_s@D+^ASZcG##TwZ0oIR_?2B6r%m;8Oy}S z!HW1VfUC_v9HX=jiG`|;wyq6x#(1ApKyIl}{s@*ddxDXxO!p4xo+DU<{ z)S}_%P|3*B+1G_(WAXO5KQqRet3@D;gu15P+B>KC2>23Y)i(In{+jv7zj1ywEfEGp zByM6sP!Ht!Q-*s$kp$#~^5MtuKw!}fN)De#v|!H~;WqcQlzDrc*@aiwesw0F z^HwK@-o#-OL(FWb;Qklyw3G)_J!pD(Cr-Y|{UhOIdAT?Ms7tlxN}De^hLm>|fBUI{r?I%X_yVxiM=86LJq~Nn{!B1Bs#rl@XGLo?Y}&ZGLl8 z)Shz>WjLY75&;0ZD68=WLB-PWp!+c_$5NvOcC{1s0ry6K#D?<#W@dWUUcrmKuObxN z$+KqY$Cx$Y8g*yM!yY0jsZz$W*n^0)a|BFSNqthkRNEI;OcmQ}B?@>D@gh=YoX^iQ z0-7ymriQoE=TvtHced3g$;gF(N!AC~JEU2n7V_8H%7fia3Lrg&-w3@oeC9 z>Namir;=}zsAS!m<$qz94j~yrqwRsc=DN-lLy|1Y=TUgyp1{v1s}wWg(XNyETpo2^?xn9$mI#_R#8D&g7t;AAsam@LCMt#AMo?tJ0pmcJov7wVo$r^ z`RV$2UN7<=_eXGBUrABu@@nL0w@IUkUpgx_5{5@s7M4;FY~)l3^sd z69;iIYv?+VWH{Be&>BCaROmK$rZ*?n&5_zxU@o!{51U1s=Th*SNm9VUMNFA2+Pl6w zlR@oYprqVDD^$WnI2W1X{TL0RCSb`qn;2Yxf??8OV4N~G+u1&Gz<(*p%cpzkvM+*b z+#g^=bV1%@Qmx`T6v`mQtc1`DYMTdkuX~X(gL3Q+=P)fVxznJf0-eeV-;IuRQfRyB zT?<2(^FUVgB!~W2J~H$4gP67MMOzZ)_}9nB-yb;5^b)+k*>g1_WnaNI0la0TWMKQt zHVW*+{{70EPnH`q^-XzS@#?*9pS2FN{=)#NHBDiZI7nk_Q_^djlzFF3dJ#g_V`DC3 zzeWT1iJsunkjID_Xg=zZ=_KjFy9e%Tp8D=;W?C zq|M}STdKIS#l%ULNOr#by-OO3JnV+;Pu+lY26r9kngJ%OIGx9WCR?{H)`Y4Sb$<0L zHkE+n*%KZai|Zu~LPXSedL8LHMuDm!u@LVrZB@o3)8m{-Pq(LB&qblu$Py&V*)m2SxY3b5!GnsGs@i`x=w)dngg#i) z{vBeh(@@d$@V&VmQQlL~B@O$AW4=2X>9{{Us(U``kG*ugQ zV+aU>Q8WGiMtwBH%p{rRGUp2Y*Z=xrFCgII#xW7j{bxf<_`-^5N1k#6Tg@xNy1(TQ zw%s56F#9?6;FH$tC7XV>qkX8crQ*mcX;}~~V-}Ib1c7ocPWKe=oqeoMarHxopNT(S zDnayD^PeO))>#b`!9nP>0}4_hO2#Y@81%i5 zJD2HiuI^37FR~|uzV2}9j2;zRQj2tXbB3d)EsRcBaJO=#*7@o0fZt~=IAZwl=8&R%x=It-r*8VNc{A zaIPeU-i9tfB9_v{5<-2NVz**A;Tu{Wrspk^f(ANlv(&WKv3DnQJRZ`@UDV}{KC(3l ztd-3)u$jjY>f=I@Lp-&gRadHZFC+d?;Smd?{T|*_6^c4g>9T^P;e-f3kO(y=DaE6m z{R7>&rD8>fy(M$7fe!}RrOhNaI&Db9o4jeM>=SuXr z8II=Y4^nFzNm;MfWXSIs4yY*V2u4FGKys(xZEw)>?g<*~5Dj0MrGABn&sT$fK}0?) z3;am$B{CmSQ5d*JWiu1ih>sMUsjJxB2)th0x*iX~c^hEtu}u9~K1OtvDQS-JF(%0X z%^LHWhUPA3Je>3rXiVRwB4KphwY1Qm3rOm3YDyo)Q%-6;>rres-NweHlqC8bMSmlQ zUOMRPpEgh&SwUq{+NDT}(IyQ(4f;jKuIJ31#22_JtXRul1P4BCYi)LIzYoV~?eW=Y z3M@$H$|sxd8~3e&vF2kvv0AB~8> z5}uG*Sp~C$xxUQ36zFD?V)`CWV@iuG4I>9bJMe!O>E4ZHK(oczo9}jHSP@1t9g|hL zqu1$^;AD58bJLTDcv>aPzeg5wZE}9$a9S=!|F(uQ;Y#l8J9tG92}m-}OGq+zt1D6L zxw_8M_mD&V9TLViUEi5yG%i;oQC2YXIt++A6i9ottR7g4Gh2mg+*wY%zZ{`)K))9k zK_x|Q`tb?d3GCOcVVR?qO~sld+=oG~|MwH1XNdjdP&~;0F>P?Lut?b@P14bK+P>sY z43{)toZ|sweIkvlvWq}b zx6??oCH3t9(Fn51&caAikln2OV^*oB5@OF&4rdwh`5M7_DVI@uLp#YXtY7X{eU~!S z6&=BCGg+;4#ctauKU<>NXg1iaU_fxV#uza~JnD-9bNduU26SR`Y5US)1Ztk-?G;&M z+(8kkq@@Bj)I~;d3D50&5T1I;Gyeuswm;w3XR4B3vA;J&<9JIgj3tK8&m>fNFb_q_ zeC`{845$qwhz1*Z5pD9H^+&n1OHM(91_ZT3+hPhnzf7vc2{2pRnt)0}G36wKK>l ziprx3<}{5Q?~MnaJ%E+0kld||JN*p(+=1Vm^~jZe@4@xYlkrfuo&?R`_bwgVrURt7pDRfq5y`-cXiY$3 ze(r50ak5duy4J!=lFEPxdL&KixzE9hG?uUNh<)M7|xz5iX^7kaW*qE8+ZIzQnL1| z;pa4aHYo|>p6hOzQKwhH*FofVz}+-F#9ux%VxVXgOaxCRRE##Gmc<8Ri%S)*^%t1xEQm=pewWnI-5D z_g<++{sVq~X`em%ywd7wO&L8aD?PobhMysUE8VduxX0D0(|PCToGTCp&nSmXjv9~0 zVrYbGan5^0O!uBnwSg`xxf~HZYj$AsyR&4tEc%4>$bebs%ez7aNSze@=aX6$`+e9Z2!`kWG9N@4oF z7V~L>nil;CxU0$r?+AR|VMtob!ETNWZ^NI6=9Vh_n5bWFmCC&Ro-VW9i(_2?6@Csu5V5EsDmVFi$<#!fK{*m zuK%&ZqeHO1ZvMN2VtOPe@ zrhK4nYs>H%N3{a~BpkeRUxxmn=9{o?7VJY}97C3nJCFzwYcltUr+&2*yIV{A>vzD2 z-~H6!j!4ipCAyo+b*~yJqBf~o^~NjsuYZB)8<6swn6}60JWXH*I3abcbv?p9BGJXG!DPjecSlvW@~g{%c) zw2P#KBFNq@P-j@GGY#Khy`7YHmoP}wlcm=p=9_{7^qEjvE7IT%wmi^r1r2TJS}9?8 zim=0o;)t_PLQzh+*vHoow5 zjh^HlZxI(}zzOSSN&q&muPKQA>wC^=^#f>1h5n%gZA)ZKiTES&PRbgBJKa1>N=LNE z$}f5nq&~@*reJcv->WvtUScCl{YWo8@A>0P*VMp7hNi-Q4?hsm<>5(sQ43U;flZ&L zjzq}zFLy%kwSYhav#XYVnWx~O)2i8NW}i<9FzbtNs3`7ZS&lEj z-|_C*X}+*?HNx^EL0|5X=u@kLlxpS}P5AFZo8SaLr1^pIJ9La0f&`WDJsM&J7Eo#D z-UJ3hLc%9orrZsI(O+)PPJXSeI(yC7)d&fIPG&|MQV%-GJYvBh;$Oy}wOr5dzP#Lx zzF8|B`~#^>c?C0BsUQc>q1zd?v=ivQpw zg4bWp6%4Gg+rUbDb8&Rgc3t)E-Og;S&3@z_*~rP|W?{3a!|12_`ttJ?@9$0CO=A|V zfb6)D6+7d)asNo*nX79r;pvaSgRj}bO4G->PQ+mqeI`a8ZiAKa_tzNu7Xv#iLdmn~ zUO_q@zY-FVWn(l?VMH^Dd6blwD=)~hl>EX;+mMv48e#9{nQt2NW#8qH%MLXC?6Lmm z_IkYwqj{^hgKKLpRsJ_Z@ST{tsWF`trvpxorJm1EJM%Ebl$kJp+_h%9H6p0Iy!=q6 zz|8Nq;A>+OlX~Vb`>#2Ay1Ke1CKd9Kx0;1jL%4r!7kuBCHv^wvW7!EzOK&TA`L64O z_Uh*>=^K)bk*tP_j@6J;h3T~XSMKD%R~a~TnCSi98)(5163E&!2aBVFZjSo=ZudTn zg6pB5)V;HY1lkwtZ>Ih8iN8q^?MW64VKtHE-s6!n_-#+^&doLmfiYJ8MfiHRUqwa! z^RT-Rqe`ofCuPUm`?5L%FM+FihCX!i9>Xr#V%k@*p+-MmZ z`mJ=6sKf6|1xyB~*ae?_6$Q4;Z;EDS-(Sl|Pgj}csyWx!*AE!~;W?ZCy11I_)|RbS z{Ix*JWct{soH(WBQJ+c1V(wwsrqzQub^z`kJ_KOv=?gRw|g~Y@}VBSqm-An<(zpAF4cdGoK z*K%B{08OeUFc~P!>z!#dfcGhgtek(uKQslt7Mxo;r9g2^Zo4nFR4wyqm~5Dg1Grt} zP>$3A+nhb2|0exF@&8^QbIHdH*a~G!{=aA7|L@-=9~}NtaE>~MGa!@DIKZE>f(Eh* HVHxp%%ca2& literal 0 HcmV?d00001 From b2b8f7655693d82e85ab0cde90ebe4e6caa1f1f4 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 16:02:08 +0100 Subject: [PATCH 13/27] make affine transform compatible with scikit-image --- demo/transforms/affine_transforms.ipynb | 137 +++++++++++++++++- .../_tier8/_affine_transform.py | 35 ++++- 2 files changed, 167 insertions(+), 5 deletions(-) diff --git a/demo/transforms/affine_transforms.ipynb b/demo/transforms/affine_transforms.ipynb index 5a521879..9a9fedcc 100644 --- a/demo/transforms/affine_transforms.ipynb +++ b/demo/transforms/affine_transforms.ipynb @@ -4,8 +4,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Inspecting 3D image data with pyclesperanto\n", - "This notebook demonstrates how to navigate through 3D images." + "# Affine transforms\n", + "This notebook demonstrates how to apply affine transforms to 3D images." ] }, { @@ -332,6 +332,139 @@ "cle.imshow(transformed_image)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Interoperability with scikit-image\n", + "Scikit-image only supports 2D transforms and thus, we pick a slice to transform it:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Programs\\miniconda3\\envs\\beetlesafari\\lib\\site-packages\\skimage\\io\\_plugins\\matplotlib_plugin.py:150: UserWarning: Float image out of standard range; displaying image with stretched contrast.\n", + " lo, hi, cmap = _get_display_range(image)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "

" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# pull image stack from GPU and pick a slice\n", + "image = cle.pull_zyx(input_image)[80]\n", + "\n", + "from skimage.io import imshow\n", + "imshow(image)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now define an affine transform using scikit-image and apply it to the image." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from skimage import transform as tf\n", + "\n", + "# define transform with #scikit image\n", + "transform = tf.AffineTransform(scale=0.5, translation=[10,0])\n", + "\n", + "transformed_image = tf.warp(image, transform.inverse)\n", + "imshow(transformed_image)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we push this single plane image to the GPU and transform it using pyclesperanto" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "image_gpu = cle.push_zyx(image)\n", + "\n", + "# define transform with #scikit image\n", + "from skimage import transform as tf\n", + "transform = tf.AffineTransform(scale=0.5, translation=[10,0])\n", + "\n", + "transformed_image = cle.affine_transform(image_gpu, transform=transform)\n", + "cle.imshow(transformed_image)" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/pyclesperanto_prototype/_tier8/_affine_transform.py b/pyclesperanto_prototype/_tier8/_affine_transform.py index f5d55089..8191148e 100644 --- a/pyclesperanto_prototype/_tier8/_affine_transform.py +++ b/pyclesperanto_prototype/_tier8/_affine_transform.py @@ -4,10 +4,11 @@ from .._tier0 import Image from .._tier0 import push_zyx from ._AffineTransform3D import AffineTransform3D +from skimage.transform import AffineTransform import numpy as np @plugin_function -def affine_transform(source : Image, destination : Image = None, transform : Union[np.ndarray, AffineTransform3D] = None, linear_interpolation : bool = False): +def affine_transform(source : Image, destination : Image = None, transform : Union[np.ndarray, AffineTransform3D, AffineTransform] = None, linear_interpolation : bool = False): """ Applies an affine transform to an image. @@ -31,10 +32,35 @@ def affine_transform(source : Image, destination : Image = None, transform : Uni from .._tier0 import empty_image_like from .._tier0 import execute from .._tier1 import copy + from .._tier0 import create + from .._tier1 import copy_slice - # we invert the transform because we go from the target image to the source image to read pixels + # deal with 2D input images + if len(source.shape) == 2: + source_3d = create([1, source.shape[0], source.shape[1]]) + copy_slice(source, source_3d, 0) + source = source_3d + + # deal with 2D output images + original_destination = destination + copy_back_after_transforming = False + if len(destination.shape) == 2: + destination = create([1, destination.shape[0], destination.shape[1]]) + copy_slice(original_destination, destination, 0) + copy_back_after_transforming = True + + # we invert the transform because we go from the target image to the source image to read pixels if isinstance(transform, AffineTransform3D): transform_matrix = np.asarray(transform.copy().inverse()) + elif isinstance(transform, AffineTransform): + matrix = np.asarray(transform.params) + matrix = np.asarray([ + [matrix[0,0], matrix[0,1], 0, matrix[0,2]], + [matrix[1,0], matrix[1,1], 0, matrix[1,2]], + [0, 0, 1, 0], + [matrix[2,0], matrix[2,1], 0, matrix[2,2]] + ]) + transform_matrix = np.linalg.inv(matrix) else: transform_matrix = np.linalg.inv(transform) @@ -57,5 +83,8 @@ def affine_transform(source : Image, destination : Image = None, transform : Uni execute(__file__, '../clij-opencl-kernels/kernels/affine_transform_' + str(len(destination.shape)) + 'd' + kernel_suffix + '_x.cl', 'affine_transform_' + str(len(destination.shape)) + 'd' + kernel_suffix, destination.shape, parameters) + # deal with 2D output images + if copy_back_after_transforming: + copy_slice(destination, original_destination, 0) - return destination \ No newline at end of file + return original_destination \ No newline at end of file From 4b733e02dc9a0c656951daa9a2c5cc4f93374761 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 16:12:59 +0100 Subject: [PATCH 14/27] added interoperability note --- pyclesperanto_prototype/_tier8/_affine_transform.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyclesperanto_prototype/_tier8/_affine_transform.py b/pyclesperanto_prototype/_tier8/_affine_transform.py index 8191148e..3f0a34e6 100644 --- a/pyclesperanto_prototype/_tier8/_affine_transform.py +++ b/pyclesperanto_prototype/_tier8/_affine_transform.py @@ -18,7 +18,7 @@ def affine_transform(source : Image, destination : Image = None, transform : Uni image to be transformed destination : Image, optional image where the transformed image should be written to - transform : 4x4 numpy array or AffineTransform3D object + transform : 4x4 numpy array or AffineTransform3D object or skimage.transform.AffineTransform object transform matrix or object describing the transformation linear_interpolation: bool not implemented yet From dca5f607b5af9e4350399285ef85857930c384a7 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 18:31:56 +0100 Subject: [PATCH 15/27] WIP: change functionality inside push (breaking change) --- .../_tier0/_plugin_function.py | 4 ++-- pyclesperanto_prototype/_tier3/_exclude_labels.py | 15 +++++++-------- .../_tier3/_exclude_labels_on_edges.py | 10 +++++----- tests/test_absolute.py | 8 ++++---- tests/test_absolute_difference.py | 2 +- tests/test_add_images.py | 10 +++++----- tests/test_add_images_weighted.py | 10 +++++----- tests/test_exclude_labels_on_edges.py | 14 +++++++------- 8 files changed, 36 insertions(+), 37 deletions(-) diff --git a/pyclesperanto_prototype/_tier0/_plugin_function.py b/pyclesperanto_prototype/_tier0/_plugin_function.py index 9423b0b6..44f15c51 100644 --- a/pyclesperanto_prototype/_tier0/_plugin_function.py +++ b/pyclesperanto_prototype/_tier0/_plugin_function.py @@ -7,7 +7,7 @@ from ._create import create_like from ._types import Image, is_image -from ._push import push +from ._push import push_zyx @curry @@ -64,7 +64,7 @@ def worker_function(*args, **kwargs): value = None if is_image(value): - value = push(value) + value = push_zyx(value) # value is now for sure OpenCL, we keep it in case we have to # create another one of the same size any_ocl_input = value diff --git a/pyclesperanto_prototype/_tier3/_exclude_labels.py b/pyclesperanto_prototype/_tier3/_exclude_labels.py index dce977de..fbf35798 100644 --- a/pyclesperanto_prototype/_tier3/_exclude_labels.py +++ b/pyclesperanto_prototype/_tier3/_exclude_labels.py @@ -1,8 +1,7 @@ from pyclesperanto_prototype._tier0 import plugin_function from pyclesperanto_prototype._tier0 import Image -from .._tier0 import push from .._tier0 import push_zyx -from .._tier0 import pull +from .._tier0 import pull_zyx from .._tier0 import create_none from .._tier0 import create_like from .._tier1 import replace_intensities @@ -39,19 +38,19 @@ def exclude_labels(binary_flaglist : Image, label_map_input : Image, label_map_d num_labels = int(binary_flaglist.shape[-1]) - flaglist_np = pull(binary_flaglist) + flaglist_np = pull_zyx(binary_flaglist) - flaglist_np[0] = 0 + flaglist_np[0][0] = 0 count = 1 for i in range(1, num_labels): - if (flaglist_np[i] == 0): - flaglist_np[i] = count + if (flaglist_np[0][i] == 0): + flaglist_np[0][i] = count count = count + 1 else: - flaglist_np[i] = 0 + flaglist_np[0][i] = 0 - label_index_map = push(flaglist_np) + label_index_map = push_zyx(flaglist_np) replace_intensities(label_map_input, label_index_map, label_map_destination) diff --git a/pyclesperanto_prototype/_tier3/_exclude_labels_on_edges.py b/pyclesperanto_prototype/_tier3/_exclude_labels_on_edges.py index e5b1b5ab..b7ad8b9c 100644 --- a/pyclesperanto_prototype/_tier3/_exclude_labels_on_edges.py +++ b/pyclesperanto_prototype/_tier3/_exclude_labels_on_edges.py @@ -1,8 +1,8 @@ from pyclesperanto_prototype._tier0 import execute from pyclesperanto_prototype._tier0 import plugin_function from pyclesperanto_prototype._tier0 import Image -from .._tier0 import pull -from .._tier0 import push +from .._tier0 import pull_zyx +from .._tier0 import push_zyx from .._tier2 import maximum_of_all_pixels from .._tier1 import replace_intensities from .._tier0 import create_like @@ -37,7 +37,7 @@ def exclude_labels_on_edges(label_map_input : Image, label_map_destination : Ima label_indices = range(0, num_labels + 1) - label_index_map = push(np.asarray(label_indices)) + label_index_map = push_zyx(np.asarray(label_indices)) parameters = { "src":label_map_input, @@ -68,14 +68,14 @@ def exclude_labels_on_edges(label_map_input : Image, label_map_destination : Ima - label_indices = pull(label_index_map) + label_indices = pull_zyx(label_index_map) count = 1 for i in range(1, num_labels + 1): if (label_indices[i] > 0): label_indices[i] = count count = count + 1 - label_index_map = push(np.asarray(label_indices)) + label_index_map = push_zyx(np.asarray(label_indices)) replace_intensities(label_map_input, label_index_map, label_map_destination) diff --git a/tests/test_absolute.py b/tests/test_absolute.py index 22fec976..9e95214c 100644 --- a/tests/test_absolute.py +++ b/tests/test_absolute.py @@ -2,7 +2,7 @@ import numpy as np def test_absolute(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [1, -1], [1, -1] ])) @@ -12,14 +12,14 @@ def test_absolute(): print(test2) - a = cle.pull(test2) + a = cle.pull_zyx(test2) assert (np.min(a) == 1) assert (np.max(a) == 1) assert (np.mean(a) == 1) def test_absolute1(): - gpu_a = cle.push(np.asarray([[1, -1], [1, -1]])) + gpu_a = cle.push_zyx(np.asarray([[1, -1], [1, -1]])) gpu_b = cle.create(gpu_a) cle.absolute(gpu_a, gpu_b) - assert np.all(cle.pull(gpu_b) == 1) + assert np.all(cle.pull_zyx(gpu_b) == 1) diff --git a/tests/test_absolute_difference.py b/tests/test_absolute_difference.py index 0bb422b6..bbe3a592 100644 --- a/tests/test_absolute_difference.py +++ b/tests/test_absolute_difference.py @@ -10,7 +10,7 @@ def test_absolute_difference(): reference = np.asarray([[3, 3, 4]]) output = cle.absolute_difference(input2, input1) - result = cle.pull(output) + result = cle.pull_zyx(output) assert np.array_equal(result, reference) diff --git a/tests/test_add_images.py b/tests/test_add_images.py index 41b8e898..1a6a55dc 100644 --- a/tests/test_add_images.py +++ b/tests/test_add_images.py @@ -10,7 +10,7 @@ def test_add_images_weighted_missing_params(): reference = np.asarray([[5, 7, 9]]) output = cle.add_images_weighted(input1, input2) - result = cle.pull(output) + result = cle.pull_zyx(output) assert np.array_equal(result, reference) @@ -19,24 +19,24 @@ def test_add_images_weighted_missing_params(): def test_add_images_weighted_none_output(): output = cle.add_images_weighted(input1, input2, None, 1, 2) - result = cle.pull(output) + result = cle.pull_zyx(output) assert np.array_equal(result, reference) def test_add_images_weighted_named_params(): output = cle.add_images_weighted(input1, input2, None, factor1=1, factor2=2) - result = cle.pull(output) + result = cle.pull_zyx(output) assert np.array_equal(result, reference) def test_add_images_weighted_named_params_missing_params(): output = cle.add_images_weighted(input1, input2, factor1=1, factor2=2) - result = cle.pull(output) + result = cle.pull_zyx(output) assert np.array_equal(result, reference) def test_add_images_weighted_wrong_order_missing_params(): reference = np.asarray([[9, 12, 15]]) output = cle.add_images_weighted(input1, input2, factor2=2, factor1=1) - result = cle.pull(output) + result = cle.pull_zyx(output) assert np.array_equal(result, reference) diff --git a/tests/test_add_images_weighted.py b/tests/test_add_images_weighted.py index 8b43bc3c..fb8c47ac 100644 --- a/tests/test_add_images_weighted.py +++ b/tests/test_add_images_weighted.py @@ -8,7 +8,7 @@ def test_add_images_weighted_missing_parameters(): reference = np.asarray([[5, 7, 9]]) output = cle.add_images_weighted(input1, input2) - result = cle.pull(output) + result = cle.pull_zyx(output) print(result) print(reference) @@ -22,7 +22,7 @@ def test_add_images_weighted_none_output(): reference = np.asarray([[9, 12, 15]]) output = cle.add_images_weighted(input1, input2, None, 1, 2) - result = cle.pull(output) + result = cle.pull_zyx(output) print(result) print(reference) @@ -36,7 +36,7 @@ def test_add_images_weighted_named_parameters(): reference = np.asarray([[9, 12, 15]]) output = cle.add_images_weighted(input1, input2, None, factor1=1, factor2=2) - result = cle.pull(output) + result = cle.pull_zyx(output) print(result) print(reference) @@ -49,7 +49,7 @@ def test_add_images_weighted_wrong_parameter_order(): reference = np.asarray([[9, 12, 15]]) output = cle.add_images_weighted(input1, input2, factor1=1, factor2=2) - result = cle.pull(output) + result = cle.pull_zyx(output) print(result) print(reference) @@ -62,7 +62,7 @@ def test_add_images_weighted_parameters_wrong_order_and_missing(): reference = np.asarray([[9, 12, 15]]) output = cle.add_images_weighted(input1, input2, factor2=2, factor1=1) - result = cle.pull(output) + result = cle.pull_zyx(output) print(result) print(reference) diff --git a/tests/test_exclude_labels_on_edges.py b/tests/test_exclude_labels_on_edges.py index 0f1ab36e..9228ef59 100644 --- a/tests/test_exclude_labels_on_edges.py +++ b/tests/test_exclude_labels_on_edges.py @@ -3,7 +3,7 @@ def test_exclude_labels_on_edges_2d(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [0, 0, 2, 0, 0, 0, 0], [0, 1, 2, 0, 7, 0, 0], @@ -14,7 +14,7 @@ def test_exclude_labels_on_edges_2d(): ])) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 3, 0, 0], @@ -36,7 +36,7 @@ def test_exclude_labels_on_edges_2d(): assert (np.array_equal(a, b)) def test_exclude_labels_on_edges_3d(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [ [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], @@ -61,7 +61,7 @@ def test_exclude_labels_on_edges_3d(): ] ])) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [ [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], @@ -88,8 +88,8 @@ def test_exclude_labels_on_edges_3d(): gpu_output = cle.exclude_labels_on_edges(gpu_input) - a = cle.pull(gpu_output) - b = cle.pull(gpu_reference) + a = cle.pull_zyx(gpu_output) + b = cle.pull_zyx(gpu_reference) print(a) print(b) @@ -111,7 +111,7 @@ def test_exclude_labels_on_edges_blobs(): print("Loaded image size: " + str(image.shape)) # push image to GPU memory - input = cle.push(image) + input = cle.push_zyx(image) print("Image size in GPU: " + str(input.shape)) # process the image From 8c859dcf1460467779d74a0814dfd4347fb5d7f0 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 18:34:42 +0100 Subject: [PATCH 16/27] WIP: change functionality inside push (breaking change) --- pyclesperanto_prototype/_tier9/_push_regionprops.py | 4 ++-- tests/test_squared_difference.py | 2 +- tests/test_subtract_images.py | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/pyclesperanto_prototype/_tier9/_push_regionprops.py b/pyclesperanto_prototype/_tier9/_push_regionprops.py index 23d0593b..54de262c 100644 --- a/pyclesperanto_prototype/_tier9/_push_regionprops.py +++ b/pyclesperanto_prototype/_tier9/_push_regionprops.py @@ -3,7 +3,6 @@ from skimage.measure._regionprops import RegionProperties import numpy as np -from .._tier0 import push def push_regionprops(props : Union[dict, RegionProperties], first_row_index : int = 0): """ @@ -21,6 +20,7 @@ def push_regionprops(props : Union[dict, RegionProperties], first_row_index : in """ from ._statistics_entry import STATISTICS_ENTRY + from .._tier0 import push_zyx num_columns = 36 if isinstance(props, dict): @@ -198,4 +198,4 @@ def push_regionprops(props : Union[dict, RegionProperties], first_row_index : in if hasattr(label_props, 'mean_max_distance_to_centroid_ratio'): matrix[i][STATISTICS_ENTRY.MAX_MEAN_DISTANCE_TO_CENTROID_RATIO.value] = label_props['mean_max_distance_to_centroid_ratio'] - return push(matrix) \ No newline at end of file + return push_zyx(matrix.T) \ No newline at end of file diff --git a/tests/test_squared_difference.py b/tests/test_squared_difference.py index 3d05a90e..bd103620 100644 --- a/tests/test_squared_difference.py +++ b/tests/test_squared_difference.py @@ -10,7 +10,7 @@ def test_squared_difference(): reference = np.asarray([[9, 9, 16]]) output = cle.squared_difference(input2, input1) - result = cle.pull(output) + result = cle.pull_zyx(output) assert np.array_equal(result, reference) diff --git a/tests/test_subtract_images.py b/tests/test_subtract_images.py index ab825f32..d13c81b5 100644 --- a/tests/test_subtract_images.py +++ b/tests/test_subtract_images.py @@ -10,7 +10,7 @@ def test_subtract_images(): reference = np.asarray([[3, 3, 4]]) output = cle.subtract_images(input2, input1) - result = cle.pull(output) + result = cle.pull_zyx(output) assert np.array_equal(result, reference) From a417022e020bf4f25850578aefe4723e728b32c8 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 18:35:56 +0100 Subject: [PATCH 17/27] removed not used legacy test --- tests/te_oki.py | 33 --------------------------------- 1 file changed, 33 deletions(-) delete mode 100644 tests/te_oki.py diff --git a/tests/te_oki.py b/tests/te_oki.py deleted file mode 100644 index d85ac41d..00000000 --- a/tests/te_oki.py +++ /dev/null @@ -1,33 +0,0 @@ -# config -filename = "data/mini-t1-head.tif" - -from skimage.io import imread -import pyclesperanto_prototype as cle -import numpy as np - -# load data and allocate memory for result -fly = imread(filename) -cle_fly = cle.push(fly); - -#print("pulled: ") -#print(cle.pull(cle_fly)) - -background_subtracted_fly = cle.create(cle_fly.shape) - -# subtract background -cle.top_hat_sphere(cle_fly, background_subtracted_fly, 15, 15, 0) - -result = cle.pull(background_subtracted_fly); - -assert (np.min(result) == 0) -assert (np.max(result) != 0) -assert (np.mean(result) != 0) -print("ok top_hat_sphere") - -#print(result) -# show results -#with napari.gui_qt(): -# viewer = napari.Viewer() -# viewer.add_image(result); - - From 6a3abccb359be5d47704b8f4e054601425aec939 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 18:43:46 +0100 Subject: [PATCH 18/27] replace push and pull by push_zyx and pull_zyx --- tests/test_binary_and.py | 12 ++++++------ tests/test_binary_edge_detection.py | 4 ++-- tests/test_binary_not.py | 4 ++-- tests/test_binary_or.py | 6 +++--- tests/test_binary_subtract.py | 6 +++--- tests/test_binary_xor.py | 6 +++--- tests/test_bottom_hat_box.py | 4 ++-- tests/test_bottom_hat_sphere.py | 4 ++-- tests/test_bounding_box.py | 16 ++++++++-------- tests/test_close_index_gaps_in_label_maps.py | 4 ++-- tests/test_connected_components_labeling_box.py | 6 +++--- ...test_connected_components_labeling_diamond.py | 8 ++++---- tests/test_convolve.py | 8 ++++---- tests/test_copy.py | 4 ++-- tests/test_copy_slice.py | 16 ++++++++-------- tests/test_count_touching_neighbors.py | 4 ++-- 16 files changed, 56 insertions(+), 56 deletions(-) diff --git a/tests/test_binary_and.py b/tests/test_binary_and.py index f0892994..b1fdc2d5 100644 --- a/tests/test_binary_and.py +++ b/tests/test_binary_and.py @@ -3,12 +3,12 @@ def test_binary_and_1(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [1, 0], [1, 0] ])) - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [1, 1], [0, 0] ])) @@ -18,7 +18,7 @@ def test_binary_and_1(): print(test2) - a = cle.pull(test2) + a = cle.pull_zyx(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) == 0.25) @@ -26,10 +26,10 @@ def test_binary_and_1(): def test_binary_and_2(): a = np.asarray([[1, 0], [1, 0]]) b = np.asarray([[1, 1], [0, 0]]) - gpu_a = cle.push(a) - gpu_b = cle.push(b) + gpu_a = cle.push_zyx(a) + gpu_b = cle.push_zyx(b) gpu_c = cle.create(gpu_a) cle.binary_and(gpu_a, gpu_b, gpu_c) - result = cle.pull(gpu_c) + result = cle.pull_zyx(gpu_c) assert np.allclose(result, a & b) \ No newline at end of file diff --git a/tests/test_binary_edge_detection.py b/tests/test_binary_edge_detection.py index c3007d87..8e7ff067 100644 --- a/tests/test_binary_edge_detection.py +++ b/tests/test_binary_edge_detection.py @@ -2,7 +2,7 @@ import numpy as np def test_binary_edge_detection(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 0], [0, 1, 1, 1, 1, 0], @@ -15,7 +15,7 @@ def test_binary_edge_detection(): cle.binary_edge_detection(test1, test2) print(test2) - a = cle.pull(test2) + a = cle.pull_zyx(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) - 12 / 36 < 0.001) diff --git a/tests/test_binary_not.py b/tests/test_binary_not.py index 17d43f83..375b1274 100644 --- a/tests/test_binary_not.py +++ b/tests/test_binary_not.py @@ -3,7 +3,7 @@ def test_binary_not(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [1, 1], [1, 0] ])) @@ -12,7 +12,7 @@ def test_binary_not(): cle.binary_not(test1, test2) print(test2) - a = cle.pull(test2) + a = cle.pull_zyx(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) == 0.25) diff --git a/tests/test_binary_or.py b/tests/test_binary_or.py index 237a1fd5..094a59e3 100644 --- a/tests/test_binary_or.py +++ b/tests/test_binary_or.py @@ -2,12 +2,12 @@ import numpy as np def test_binary_or(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [1, 0], [1, 0] ])) - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [1, 1], [0, 0] ])) @@ -17,7 +17,7 @@ def test_binary_or(): print(test2) - a = cle.pull(test2) + a = cle.pull_zyx(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) == 0.75) diff --git a/tests/test_binary_subtract.py b/tests/test_binary_subtract.py index def33d5c..5ea55383 100644 --- a/tests/test_binary_subtract.py +++ b/tests/test_binary_subtract.py @@ -2,12 +2,12 @@ import numpy as np def test_binary_subtract(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [1, 0], [1, 0] ])) - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [1, 1], [0, 0] ])) @@ -17,7 +17,7 @@ def test_binary_subtract(): print(test2) - a = cle.pull(test2) + a = cle.pull_zyx(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) == 0.25) diff --git a/tests/test_binary_xor.py b/tests/test_binary_xor.py index 0642a1e5..c7d21d75 100644 --- a/tests/test_binary_xor.py +++ b/tests/test_binary_xor.py @@ -2,12 +2,12 @@ import numpy as np def test_binary_xor(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [1, 0], [1, 0] ])) - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [1, 1], [0, 0] ])) @@ -17,7 +17,7 @@ def test_binary_xor(): print(test2) - a = cle.pull(test2) + a = cle.pull_zyx(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) == 0.5) diff --git a/tests/test_bottom_hat_box.py b/tests/test_bottom_hat_box.py index cb53a6d5..6cd45ec1 100644 --- a/tests/test_bottom_hat_box.py +++ b/tests/test_bottom_hat_box.py @@ -3,7 +3,7 @@ def test_bottom_hat_sphere(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 50, 50, 50, 0], [0, 50, 100, 50, 0], @@ -16,7 +16,7 @@ def test_bottom_hat_sphere(): print(result) - a = cle.pull(result) + a = cle.pull_zyx(result) assert (np.min(a) == 0) assert (np.max(a) == 50) diff --git a/tests/test_bottom_hat_sphere.py b/tests/test_bottom_hat_sphere.py index bf327a6e..b9aa0ec9 100644 --- a/tests/test_bottom_hat_sphere.py +++ b/tests/test_bottom_hat_sphere.py @@ -3,7 +3,7 @@ def test_bottom_hat_sphere(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 50, 50, 50, 0], [0, 50, 100, 50, 0], @@ -16,7 +16,7 @@ def test_bottom_hat_sphere(): print(result) - a = cle.pull(result) + a = cle.pull_zyx(result) assert (np.min(a) == 0) assert (np.max(a) == 50) diff --git a/tests/test_bounding_box.py b/tests/test_bounding_box.py index 215e256c..0a4bc12d 100644 --- a/tests/test_bounding_box.py +++ b/tests/test_bounding_box.py @@ -3,7 +3,7 @@ def test_bounding_box_2d(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 0, 0], [0, 1, 1, 0, 0], @@ -14,15 +14,15 @@ def test_bounding_box_2d(): bb = cle.bounding_box(test) print(bb) - assert bb[0] == 1 assert bb[1] == 1 + assert bb[0] == 1 - assert bb[3] == 2 assert bb[4] == 2 + assert bb[3] == 2 def test_bounding_box_3d(): - test = cle.push(np.asarray([[ + test = cle.push_zyx(np.asarray([[ [0, 0, 0, 0, 0], [0, 1, 1, 0, 0], [0, 1, 1, 0, 0], @@ -39,10 +39,10 @@ def test_bounding_box_3d(): bb = cle.bounding_box(test) print(bb) - assert bb[0] == 0 + assert bb[2] == 0 assert bb[1] == 1 - assert bb[2] == 1 + assert bb[0] == 1 - assert bb[3] == 1 + assert bb[5] == 1 assert bb[4] == 2 - assert bb[5] == 2 + assert bb[3] == 2 diff --git a/tests/test_close_index_gaps_in_label_maps.py b/tests/test_close_index_gaps_in_label_maps.py index 0b459840..030e8f16 100644 --- a/tests/test_close_index_gaps_in_label_maps.py +++ b/tests/test_close_index_gaps_in_label_maps.py @@ -3,7 +3,7 @@ def test_close_index_gaps_in_label_maps(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [ [1, 2, 3], [1, 6, 6], @@ -12,7 +12,7 @@ def test_close_index_gaps_in_label_maps(): ])) gpu_output = cle.create_like(gpu_input) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [ [1, 2, 3], [1, 4, 4], diff --git a/tests/test_connected_components_labeling_box.py b/tests/test_connected_components_labeling_box.py index 8e476345..c83ed3dc 100644 --- a/tests/test_connected_components_labeling_box.py +++ b/tests/test_connected_components_labeling_box.py @@ -3,7 +3,7 @@ def test_connected_components_labeling_box(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [ [1, 0, 1], [1, 0, 0], @@ -11,7 +11,7 @@ def test_connected_components_labeling_box(): ] ])) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [ [1, 0, 2], [1, 0, 0], @@ -43,7 +43,7 @@ def test_connected_components_labeling_box_blobs(): print("Loaded image size: " + str(image.shape)) # push image to GPU memory - input = cle.push(image) + input = cle.push_zyx(image) print("Image size in GPU: " + str(input.shape)) # process the image diff --git a/tests/test_connected_components_labeling_diamond.py b/tests/test_connected_components_labeling_diamond.py index 654cc781..3ed32283 100644 --- a/tests/test_connected_components_labeling_diamond.py +++ b/tests/test_connected_components_labeling_diamond.py @@ -3,21 +3,21 @@ def test_connected_components_labeling_diamond(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [ [0, 1, 0, 1], [0, 1, 0, 0], [1, 0, 0, 1] ] - ])) + ]).T) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [ [0, 1, 0, 2], [0, 1, 0, 0], [3, 0, 0, 4] ] - ])) + ]).T) gpu_output = cle.connected_components_labeling_diamond(gpu_input) diff --git a/tests/test_convolve.py b/tests/test_convolve.py index 8b330865..84ef7ebd 100644 --- a/tests/test_convolve.py +++ b/tests/test_convolve.py @@ -3,13 +3,13 @@ def test_convolve(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0], [0, 1, 0], [0, 0, 0] ])) - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 1, 0], [1, 2, 1], [0, 1, 0] @@ -20,8 +20,8 @@ def test_convolve(): print(test2) - a = cle.pull(test1) - b = cle.pull(test2) + a = cle.pull_zyx(test1) + b = cle.pull_zyx(test2) assert (np.min(a) == np.min(b)) assert (np.max(a) == np.max(b)) assert (np.mean(a) == np.mean(b)) diff --git a/tests/test_copy.py b/tests/test_copy.py index 56976b68..6901674e 100644 --- a/tests/test_copy.py +++ b/tests/test_copy.py @@ -3,7 +3,7 @@ def test_copy(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [1, 1], [1, 0] ])) @@ -12,7 +12,7 @@ def test_copy(): cle.copy(test1, test2) print(test2) - a = cle.pull(test2) + a = cle.pull_zyx(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) == 0.75) diff --git a/tests/test_copy_slice.py b/tests/test_copy_slice.py index 9cb18f91..ef99ed9e 100644 --- a/tests/test_copy_slice.py +++ b/tests/test_copy_slice.py @@ -3,7 +3,7 @@ def test_copy_slice_from_3d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 4], [0, 4] @@ -12,20 +12,20 @@ def test_copy_slice_from_3d(): [1, 3], [1, 2] ] - ])) + ]).T) test2 = cle.create((2, 2)) cle.copy_slice(test1, test2, 0) print(test2) - a = cle.pull(test2) + a = cle.pull_zyx(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) == 0.75) def test_copy_slice_to_3d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [3, 4], [4, 5] ])) @@ -35,13 +35,13 @@ def test_copy_slice_to_3d(): cle.copy_slice(test1, test2, 0) print(test2) - a = cle.pull(test2) + a = cle.pull_zyx(test2) assert (np.min(a) == 0) assert (np.max(a) == 5) assert (np.mean(a) == 2) def test_copy_slice_to3d_with_one_slice(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [3, 4, 6], [4, 5, 2] ])) @@ -49,14 +49,14 @@ def test_copy_slice_to3d_with_one_slice(): print(test1) print("shape test1 " + str(test1.shape)) - test2 = cle.create((1, 3, 2)) + test2 = cle.create((1, 2, 3)) print("shape test2 " + str(test2.shape)) print(test2) cle.copy_slice(test1, test2, 0) print(test2) - a = cle.pull(test2) + a = cle.pull_zyx(test2) assert (np.min(a) == 2) assert (np.max(a) == 6) assert (np.mean(a) == 4) diff --git a/tests/test_count_touching_neighbors.py b/tests/test_count_touching_neighbors.py index 414c3df3..b3bd4d95 100644 --- a/tests/test_count_touching_neighbors.py +++ b/tests/test_count_touching_neighbors.py @@ -19,8 +19,8 @@ def test_count_touching_neighbors(): neighbor_count_vector = cle.count_touching_neighbors(touch_matrix) - a = cle.pull(neighbor_count_vector) - b = cle.pull(reference) + a = cle.pull_zyx(neighbor_count_vector) + b = cle.pull_zyx(reference) print(a) print(b) From 87293f76080c691c3d47c8473baa4bed9a8d6b35 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 18:51:41 +0100 Subject: [PATCH 19/27] replace push and pull by push_zyx and pull_zyx --- tests/test_crop.py | 4 ++-- tests/test_degrees_to_radians.py | 8 ++++---- tests/test_detect_label_edges.py | 8 ++++---- tests/test_detect_maxima_box.py | 4 ++-- tests/test_detect_minima_box.py | 4 ++-- tests/test_difference_of_gaussian.py | 4 ++-- tests/test_dilate_box.py | 8 ++++---- tests/test_dilate_sphere.py | 8 ++++---- tests/test_divide_images.py | 10 +++++----- tests/test_draw_box.py | 4 ++-- tests/test_draw_line.py | 4 ++-- tests/test_draw_sphere.py | 4 ++-- tests/test_equal.py | 10 +++++----- tests/test_equal_constant.py | 8 ++++---- tests/test_erode_box.py | 8 ++++---- tests/test_erode_sphere.py | 8 ++++---- tests/test_exclude_labels.py | 8 ++++---- tests/test_exponential.py | 8 ++++---- tests/test_extend_labeling_via_voronoi.py | 4 ++-- tests/test_gamma_correction.py | 4 ++-- tests/test_gaussian_blur.py | 4 ++-- tests/test_generate_binary_overlap_matrix.py | 20 ++++++++++---------- tests/test_generate_distance_matrix.py | 4 ++-- tests/test_generate_touch_matrix.py | 6 +++--- 24 files changed, 81 insertions(+), 81 deletions(-) diff --git a/tests/test_crop.py b/tests/test_crop.py index 6c4e4548..1a64db6d 100644 --- a/tests/test_crop.py +++ b/tests/test_crop.py @@ -18,8 +18,8 @@ def test_crop(): result = cle.create(reference) cle.crop(test1, result, 0, 0) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_degrees_to_radians.py b/tests/test_degrees_to_radians.py index ff15d1f0..0fa9211e 100644 --- a/tests/test_degrees_to_radians.py +++ b/tests/test_degrees_to_radians.py @@ -2,17 +2,17 @@ import numpy as np def test_degrees_to_radians(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [180, 0, -90] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [np.pi, 0, -0.5 * np.pi] ])) result = cle.degrees_to_radians(test) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a,b,0.01)) diff --git a/tests/test_detect_label_edges.py b/tests/test_detect_label_edges.py index dc9eb576..41373333 100644 --- a/tests/test_detect_label_edges.py +++ b/tests/test_detect_label_edges.py @@ -3,7 +3,7 @@ def test_detect_label_edges(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [1, 1, 2, 2, 2], [1, 1, 2, 2, 2], [3, 3, 3, 2, 2], @@ -14,7 +14,7 @@ def test_detect_label_edges(): result = cle.create(test) cle.detect_label_edges(test, result) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 1, 1, 0, 0], [1, 1, 1, 0, 0], [1, 1, 1, 1, 1], @@ -24,8 +24,8 @@ def test_detect_label_edges(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(b) diff --git a/tests/test_detect_maxima_box.py b/tests/test_detect_maxima_box.py index 164815e7..f7cf6214 100644 --- a/tests/test_detect_maxima_box.py +++ b/tests/test_detect_maxima_box.py @@ -3,7 +3,7 @@ def test_detect_maxima_box(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [1, 0, 0, 2, 0], @@ -14,7 +14,7 @@ def test_detect_maxima_box(): ])) gpu_output = cle.create_like(gpu_input) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], diff --git a/tests/test_detect_minima_box.py b/tests/test_detect_minima_box.py index 8b6841a5..592ae4cb 100644 --- a/tests/test_detect_minima_box.py +++ b/tests/test_detect_minima_box.py @@ -3,7 +3,7 @@ def test_detect_minima_box(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [6, 6, 6, 6, 6], [5, 6, 6, 4, 6], @@ -14,7 +14,7 @@ def test_detect_minima_box(): ])) gpu_output = cle.create_like(gpu_input) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], diff --git a/tests/test_difference_of_gaussian.py b/tests/test_difference_of_gaussian.py index 140cddae..01f76c7c 100644 --- a/tests/test_difference_of_gaussian.py +++ b/tests/test_difference_of_gaussian.py @@ -3,7 +3,7 @@ def test_difference_of_gaussian(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 100, 0, 0], @@ -16,7 +16,7 @@ def test_difference_of_gaussian(): print(result) - a = cle.pull(result) + a = cle.pull_zyx(result) assert (np.min(a) < -1.15) assert (np.min(a) > -1.18) assert (np.max(a) > 11.9) diff --git a/tests/test_dilate_box.py b/tests/test_dilate_box.py index 15622cc5..223d053b 100644 --- a/tests/test_dilate_box.py +++ b/tests/test_dilate_box.py @@ -3,7 +3,7 @@ def test_dilate_box(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -11,7 +11,7 @@ def test_dilate_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], @@ -24,6 +24,6 @@ def test_dilate_box(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_dilate_sphere.py b/tests/test_dilate_sphere.py index 346a2d38..cd72a77a 100644 --- a/tests/test_dilate_sphere.py +++ b/tests/test_dilate_sphere.py @@ -5,7 +5,7 @@ def test_dilate_sphere(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -13,7 +13,7 @@ def test_dilate_sphere(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 1, 1, 1, 0], @@ -26,6 +26,6 @@ def test_dilate_sphere(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_divide_images.py b/tests/test_divide_images.py index d3dbf838..5aa099ed 100644 --- a/tests/test_divide_images.py +++ b/tests/test_divide_images.py @@ -3,7 +3,7 @@ def test_divide_images(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 4, 6, 8, 0], [0, 4, 6, 8, 0], @@ -11,7 +11,7 @@ def test_divide_images(): [0, 0, 0, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [1, 1, 1, 1, 1], [1, 2, 3, 2, 1], [1, 2, 3, 2, 1], @@ -19,7 +19,7 @@ def test_divide_images(): [1, 1, 1, 1, 1] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 2, 4, 0], [0, 2, 2, 4, 0], @@ -32,6 +32,6 @@ def test_divide_images(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a, b, 0.0001)) diff --git a/tests/test_draw_box.py b/tests/test_draw_box.py index c4270971..f6f9328e 100644 --- a/tests/test_draw_box.py +++ b/tests/test_draw_box.py @@ -17,7 +17,7 @@ def test_draw_box(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_draw_line.py b/tests/test_draw_line.py index 4d5e69c5..004c930a 100644 --- a/tests/test_draw_line.py +++ b/tests/test_draw_line.py @@ -17,7 +17,7 @@ def test_draw_line(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_draw_sphere.py b/tests/test_draw_sphere.py index af72ee6e..c15a715f 100644 --- a/tests/test_draw_sphere.py +++ b/tests/test_draw_sphere.py @@ -17,7 +17,7 @@ def test_draw_sphere(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_equal.py b/tests/test_equal.py index 9023d826..85676808 100644 --- a/tests/test_equal.py +++ b/tests/test_equal.py @@ -3,7 +3,7 @@ def test_equal(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_equal(): [0, 0, 0, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [1, 1, 1, 1, 1], [1, 5, 4, 3, 1], [1, 4, 3, 2, 1], @@ -19,7 +19,7 @@ def test_equal(): [1, 1, 1, 1, 1] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 0, 1, 0, 0], @@ -32,6 +32,6 @@ def test_equal(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) \ No newline at end of file diff --git a/tests/test_equal_constant.py b/tests/test_equal_constant.py index 39f267b4..4e72b49c 100644 --- a/tests/test_equal_constant.py +++ b/tests/test_equal_constant.py @@ -3,7 +3,7 @@ def test_equal_constant(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_equal_constant(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 1, 0], @@ -24,6 +24,6 @@ def test_equal_constant(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_erode_box.py b/tests/test_erode_box.py index a37280ca..5f68acf8 100644 --- a/tests/test_erode_box.py +++ b/tests/test_erode_box.py @@ -3,7 +3,7 @@ def test_erode_box(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], @@ -11,7 +11,7 @@ def test_erode_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -24,6 +24,6 @@ def test_erode_box(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_erode_sphere.py b/tests/test_erode_sphere.py index a344d7e0..1a280d7a 100644 --- a/tests/test_erode_sphere.py +++ b/tests/test_erode_sphere.py @@ -3,7 +3,7 @@ def test_erode_sphere(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], @@ -11,7 +11,7 @@ def test_erode_sphere(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -24,6 +24,6 @@ def test_erode_sphere(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_exclude_labels.py b/tests/test_exclude_labels.py index 9e1c8a8a..1669c8e6 100644 --- a/tests/test_exclude_labels.py +++ b/tests/test_exclude_labels.py @@ -3,7 +3,7 @@ def test_exclude_labels_2d(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [0, 0, 2, 0, 0, 0, 0], [0, 1, 2, 0, 7, 0, 0], @@ -14,7 +14,7 @@ def test_exclude_labels_2d(): ])) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [0, 0, 2, 0, 0, 0, 0], [0, 1, 2, 0, 0, 0, 0], @@ -39,7 +39,7 @@ def test_exclude_labels_2d(): def test_exclude_labels_3d(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [ [0, 0, 2, 0, 0, 0, 0], [0, 1, 2, 0, 7, 0, 0], @@ -51,7 +51,7 @@ def test_exclude_labels_3d(): ] ])) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [ [0, 0, 2, 0, 0, 0, 0], [0, 1, 2, 0, 0, 0, 0], diff --git a/tests/test_exponential.py b/tests/test_exponential.py index 70443025..24303bfb 100644 --- a/tests/test_exponential.py +++ b/tests/test_exponential.py @@ -3,7 +3,7 @@ def test_exponential(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 2, 0], [0, 2, 2, 3, 0], @@ -11,7 +11,7 @@ def test_exponential(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [1, 1, 1, 1, 1], [1, 2.7182817, 2.7182817, 7.389056, 1], [1, 7.389056, 7.389056, 20.085537, 1], @@ -24,7 +24,7 @@ def test_exponential(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a, b, atol=0.00001)) diff --git a/tests/test_extend_labeling_via_voronoi.py b/tests/test_extend_labeling_via_voronoi.py index 3a9f92c5..c01474d1 100644 --- a/tests/test_extend_labeling_via_voronoi.py +++ b/tests/test_extend_labeling_via_voronoi.py @@ -3,7 +3,7 @@ def test_extend_labeling_via_voronoi(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [ [0, 0, 0, 0, 3, 3], [0, 4, 0, 0, 3, 3], @@ -14,7 +14,7 @@ def test_extend_labeling_via_voronoi(): ] ])) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [ [4, 4, 4, 3, 3, 3], [4, 4, 4, 3, 3, 3], diff --git a/tests/test_gamma_correction.py b/tests/test_gamma_correction.py index f99a1aa8..9f7b4239 100644 --- a/tests/test_gamma_correction.py +++ b/tests/test_gamma_correction.py @@ -3,7 +3,7 @@ def test_gamma_correction(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 50, 0, 5, 0], [0, 0, 100, 0, 0], @@ -14,7 +14,7 @@ def test_gamma_correction(): result = cle.create(test) cle.gamma_correction(test, result, 0.5) - a = cle.pull(result) + a = cle.pull_zyx(result) print(a) print(np.mean(a)) diff --git a/tests/test_gaussian_blur.py b/tests/test_gaussian_blur.py index 5e121edb..ae10cd34 100644 --- a/tests/test_gaussian_blur.py +++ b/tests/test_gaussian_blur.py @@ -3,7 +3,7 @@ def test_gaussian_blur(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 100, 0, 0], @@ -16,7 +16,7 @@ def test_gaussian_blur(): print(result) - a = cle.pull(result) + a = cle.pull_zyx(result) assert (np.min(a) > 0) assert (np.max(a) > 15.9) assert (np.max(a) < 16) diff --git a/tests/test_generate_binary_overlap_matrix.py b/tests/test_generate_binary_overlap_matrix.py index 1d2c0b47..e29676a9 100644 --- a/tests/test_generate_binary_overlap_matrix.py +++ b/tests/test_generate_binary_overlap_matrix.py @@ -1,9 +1,9 @@ import pyclesperanto_prototype as cle import numpy as np -def test_generate_touch_matrix_2d(): +def test_generate_binary_overlap_matrix_2d(): - gpu_input1 = cle.push(np.asarray([ + gpu_input1 = cle.push_zyx(np.asarray([ [1, 1, 0, 0, 0], [1, 1, 0, 3, 0], @@ -13,7 +13,7 @@ def test_generate_touch_matrix_2d(): ])) - gpu_input2 = cle.push(np.asarray([ + gpu_input2 = cle.push_zyx(np.asarray([ [1, 1, 2, 2, 2], [1, 1, 2, 2, 2], @@ -24,7 +24,7 @@ def test_generate_touch_matrix_2d(): ])) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [0, 1, 1], [0, 1, 0], @@ -32,7 +32,7 @@ def test_generate_touch_matrix_2d(): [0, 0, 1], [0, 0, 1] - ])) + ]).T) gpu_binary_overlap_matrix = cle.generate_binary_overlap_matrix(gpu_input1, gpu_input2) @@ -45,8 +45,8 @@ def test_generate_touch_matrix_2d(): assert (np.allclose(a, b, 0.01)) -def test_generate_touch_matrix_3d(): - gpu_input1 = cle.push(np.asarray([ +def test_generate_binary_overlap_matrix_3d(): + gpu_input1 = cle.push_zyx(np.asarray([ [ [1, 1, 0, 0, 0], [1, 1, 0, 3, 0], @@ -56,7 +56,7 @@ def test_generate_touch_matrix_3d(): ] ])) - gpu_input2 = cle.push(np.asarray([ + gpu_input2 = cle.push_zyx(np.asarray([ [ [1, 1, 2, 2, 2], [1, 1, 2, 2, 2], @@ -66,7 +66,7 @@ def test_generate_touch_matrix_3d(): ] ])) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [0, 1, 1], [0, 1, 0], @@ -74,7 +74,7 @@ def test_generate_touch_matrix_3d(): [0, 0, 1], [0, 0, 1] - ])) + ]).T) gpu_binary_overlap_matrix = cle.generate_binary_overlap_matrix(gpu_input1, gpu_input2) diff --git a/tests/test_generate_distance_matrix.py b/tests/test_generate_distance_matrix.py index 4068a8d7..1031b0a9 100644 --- a/tests/test_generate_distance_matrix.py +++ b/tests/test_generate_distance_matrix.py @@ -3,7 +3,7 @@ def test_generate_distance_matrix(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 0, 3, 0], @@ -13,7 +13,7 @@ def test_generate_distance_matrix(): ])) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [0., 0. , 0. , 0. , 0. ], [0., 0. , 2.236068 , 2. , 4.2426405 ], [0., 2.236068 , 0. , 2.236068 , 2.236068 ], diff --git a/tests/test_generate_touch_matrix.py b/tests/test_generate_touch_matrix.py index e2b9b374..125ac988 100644 --- a/tests/test_generate_touch_matrix.py +++ b/tests/test_generate_touch_matrix.py @@ -3,7 +3,7 @@ def test_generate_touch_matrix(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [1, 1, 0, 0, 0], [1, 1, 0, 3, 0], @@ -13,7 +13,7 @@ def test_generate_touch_matrix(): ])) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [0, 1, 1, 1, 1], [0, 0, 1, 0, 0], @@ -21,7 +21,7 @@ def test_generate_touch_matrix(): [0, 0, 0, 0, 0], [0, 0, 0, 0, 0] - ])) + ]).T) gpu_touch_matrix = cle.generate_touch_matrix(gpu_input) From 3159089bfcd274199304b7be8027e2fd8f257d3d Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 19:05:26 +0100 Subject: [PATCH 20/27] replace push and pull by push_zyx and pull_zyx --- tests/test_gradient_x.py | 21 ++++++++++----------- tests/test_gradient_y.py | 21 +++++++++++---------- tests/test_greater.py | 20 ++++++++++---------- tests/test_greater_constant.py | 8 ++++---- tests/test_greater_or_equal.py | 20 ++++++++++---------- tests/test_greater_or_equal_constant.py | 8 ++++---- tests/test_histogram.py | 4 ++-- tests/test_invert.py | 8 ++++---- tests/test_jaccard_index.py | 8 ++++---- tests/test_label_spots.py | 8 ++++---- tests/test_labelled_spots_to_pointlist.py | 8 ++++---- tests/test_laplace_box.py | 8 ++++---- tests/test_laplace_diamond.py | 8 ++++---- tests/test_logarithm.py | 8 ++++---- tests/test_mask.py | 10 +++++----- tests/test_mask_label.py | 10 +++++----- tests/test_maximum_box.py | 8 ++++---- tests/test_maximum_image_and_scalar.py | 8 ++++---- tests/test_maximum_images.py | 10 +++++----- tests/test_maximum_of_all_pixels.py | 2 +- tests/test_maximum_sphere.py | 12 ++++++------ tests/test_maximum_x_projection.py | 12 ++++++------ tests/test_maximum_y_projection.py | 12 ++++++------ tests/test_maximum_z_projection.py | 8 ++++---- tests/test_mean_box.py | 8 ++++---- tests/test_mean_of_all_pixels.py | 10 +++++----- tests/test_mean_sphere.py | 8 ++++---- tests/test_mean_x_projection.py | 8 ++++---- tests/test_mean_y_projection.py | 12 ++++++------ tests/test_mean_z_projection.py | 12 ++++++------ tests/test_merge_touching_labels.py | 4 ++-- tests/test_nonzero_maximum_diamond.py | 10 +++++----- tests/test_nonzero_minimum_box.py | 10 +++++----- tests/test_nonzero_minimum_diamond.py | 10 +++++----- 34 files changed, 171 insertions(+), 171 deletions(-) diff --git a/tests/test_gradient_x.py b/tests/test_gradient_x.py index e028f290..a749bbb2 100644 --- a/tests/test_gradient_x.py +++ b/tests/test_gradient_x.py @@ -3,7 +3,7 @@ def test_gradient_x(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 0, 0], [0, 1, 2, 0, 0], @@ -11,20 +11,19 @@ def test_gradient_x(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ - [0, 1, 2, 0, 0], - [0, 1, 2, 0, 0], - [0, 0, 1, 0, 0], - [0, -1, -2, 0, 0], - [0, -1, -3, 0, 0] + reference = cle.push_zyx(np.asarray([ + [0, 0, 0, 0, 0], + [1, 2, -1, -2, 0], + [1, 2, -1, -2, 0], + [1, 3, -1, -3, 0], + [0, 0, 0, 0, 0] ])) result = cle.create(test) cle.gradient_x(test, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) - assert (np.array_equal(a, b)) - + assert (np.array_equal(a, b)) \ No newline at end of file diff --git a/tests/test_gradient_y.py b/tests/test_gradient_y.py index 113bfd43..e7bc2a7d 100644 --- a/tests/test_gradient_y.py +++ b/tests/test_gradient_y.py @@ -3,7 +3,7 @@ def test_gradient_y(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 0, 0], [0, 1, 2, 0, 0], @@ -11,19 +11,20 @@ def test_gradient_y(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ - [0, 0, 0, 0, 0], - [1, 2, -1, -2, 0], - [1, 2, -1, -2, 0], - [1, 3, -1, -3, 0], - [0, 0, 0, 0, 0] + reference = cle.push_zyx(np.asarray([ + [0, 1, 2, 0, 0], + [0, 1, 2, 0, 0], + [0, 0, 1, 0, 0], + [0, -1, -2, 0, 0], + [0, -1, -3, 0, 0] ])) result = cle.create(test) cle.gradient_y(test, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) - assert (np.array_equal(a, b)) \ No newline at end of file + assert (np.array_equal(a, b)) + diff --git a/tests/test_greater.py b/tests/test_greater.py index a2b6c96c..70f72bd5 100644 --- a/tests/test_greater.py +++ b/tests/test_greater.py @@ -3,14 +3,14 @@ def test_greater_2d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 3, 3, 3, 0], [0, 3, 3, 3, 0], @@ -18,7 +18,7 @@ def test_greater_2d(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 1, 0], @@ -29,15 +29,15 @@ def test_greater_2d(): result = cle.create(test1) cle.greater(test1, test2, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) print("ok greater_or_equal") def test_greater_3d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [0, 1, 2, 3, 0], [0, 3, 3, 4, 0] @@ -46,7 +46,7 @@ def test_greater_3d(): [0, 0, 0, 0, 0] ] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [ [0, 3, 3, 3, 0], [0, 3, 3, 3, 0], @@ -56,7 +56,7 @@ def test_greater_3d(): ] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [ [0, 0, 0, 0, 0], [0, 0, 0, 1, 0] @@ -69,8 +69,8 @@ def test_greater_3d(): result = cle.create(test1) cle.greater(test1, test2, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_greater_constant.py b/tests/test_greater_constant.py index 06e6dff2..3d2bc4fe 100644 --- a/tests/test_greater_constant.py +++ b/tests/test_greater_constant.py @@ -3,7 +3,7 @@ def test_greater_constant(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_greater_constant(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], @@ -24,7 +24,7 @@ def test_greater_constant(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_greater_or_equal.py b/tests/test_greater_or_equal.py index 9076741b..da41b4a4 100644 --- a/tests/test_greater_or_equal.py +++ b/tests/test_greater_or_equal.py @@ -3,14 +3,14 @@ def test_greater_or_equal_2d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 3, 3, 3, 0], [0, 3, 3, 3, 0], @@ -18,7 +18,7 @@ def test_greater_or_equal_2d(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [1, 1, 1, 1, 1], [1, 0, 0, 1, 1], [1, 1, 1, 1, 1], @@ -29,15 +29,15 @@ def test_greater_or_equal_2d(): result = cle.create(test1) cle.greater_or_equal(test1, test2, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) def test_greater_or_equal_3d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], @@ -46,7 +46,7 @@ def test_greater_or_equal_3d(): [0, 0, 0, 0, 0] ] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [ [0, 3, 3, 3, 0], [0, 3, 3, 3, 0] @@ -56,7 +56,7 @@ def test_greater_or_equal_3d(): ] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [ [1, 0, 0, 1, 1], [1, 1, 1, 1, 1] @@ -69,8 +69,8 @@ def test_greater_or_equal_3d(): result = cle.create(test1) cle.greater_or_equal(test1, test2, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_greater_or_equal_constant.py b/tests/test_greater_or_equal_constant.py index f491b1c1..692fc967 100644 --- a/tests/test_greater_or_equal_constant.py +++ b/tests/test_greater_or_equal_constant.py @@ -3,7 +3,7 @@ def test_greater_or_equal_constant(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_greater_or_equal_constant(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 1, 0], @@ -24,7 +24,7 @@ def test_greater_or_equal_constant(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_histogram.py b/tests/test_histogram.py index f59279d6..8b93366a 100644 --- a/tests/test_histogram.py +++ b/tests/test_histogram.py @@ -7,13 +7,13 @@ def test_histogram(): [3, 3, 4, 4, 5, 5] ])) - ref_histogram = [1, 2, 3, 4, 2] + ref_histogram = [[1, 2, 3, 4, 2]] my_histogram = cle.histogram(test, num_bins = 5) print(my_histogram) - a = cle.pull(my_histogram) + a = cle.pull_zyx(my_histogram) assert (np.allclose(a, ref_histogram)) def test_histogram_3d(): diff --git a/tests/test_invert.py b/tests/test_invert.py index c0ad08c8..42765420 100644 --- a/tests/test_invert.py +++ b/tests/test_invert.py @@ -3,12 +3,12 @@ def test_grreater_or_equal(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, -6, 0, -3, 0], [0, 1, 2, 3, 0], ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 6, 0, 3, 0], [0, -1, -2, -3, 0], ])) @@ -16,8 +16,8 @@ def test_grreater_or_equal(): result = cle.create(test) cle.invert(test, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_jaccard_index.py b/tests/test_jaccard_index.py index b635dbb2..b41b34d5 100644 --- a/tests/test_jaccard_index.py +++ b/tests/test_jaccard_index.py @@ -3,12 +3,12 @@ def test_jaccard_index_2d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [0, 1, 1, 0, 0], [0, 1, 1, 0, 0] ])) @@ -18,12 +18,12 @@ def test_jaccard_index_2d(): assert j == 0.5 def test_accard_index_3d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [[0, 0, 0], [0, 0, 0]], [[0, 1, 1], [0, 1, 0]] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [[0, 1, 1], [0, 1, 0]], [[0, 1, 1], [0, 1, 0]] ])) diff --git a/tests/test_label_spots.py b/tests/test_label_spots.py index 8a5b15dc..99dff1fa 100644 --- a/tests/test_label_spots.py +++ b/tests/test_label_spots.py @@ -3,7 +3,7 @@ def test_label_spots_2d(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 0, 1, 0], @@ -11,9 +11,9 @@ def test_label_spots_2d(): [0, 0, 1, 0, 0], [0, 0, 0, 0, 1] - ])) + ]).T) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 0, 3, 0], @@ -21,7 +21,7 @@ def test_label_spots_2d(): [0, 0, 2, 0, 0], [0, 0, 0, 0, 4] - ])) + ]).T) gpu_output = cle.label_spots(gpu_input) diff --git a/tests/test_labelled_spots_to_pointlist.py b/tests/test_labelled_spots_to_pointlist.py index b8b895e3..c7fd5d3f 100644 --- a/tests/test_labelled_spots_to_pointlist.py +++ b/tests/test_labelled_spots_to_pointlist.py @@ -3,7 +3,7 @@ def test_labelled_spots_to_pointlist(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 0, 3, 0], @@ -11,16 +11,16 @@ def test_labelled_spots_to_pointlist(): [0, 0, 2, 0, 0], [0, 0, 0, 0, 4] - ])) + ]).T) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [1, 1], [3, 2], [1, 3], [4, 4] - ])) + ]).T) diff --git a/tests/test_laplace_box.py b/tests/test_laplace_box.py index 5874e8b3..dfb0709b 100644 --- a/tests/test_laplace_box.py +++ b/tests/test_laplace_box.py @@ -3,7 +3,7 @@ def test_laplace_box(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -11,7 +11,7 @@ def test_laplace_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, -1, -1, -1, 0], [0, -1, 8, -1, 0], @@ -22,8 +22,8 @@ def test_laplace_box(): result = cle.create(test1) cle.laplace_box(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_laplace_diamond.py b/tests/test_laplace_diamond.py index 4fb77beb..c7e47c4f 100644 --- a/tests/test_laplace_diamond.py +++ b/tests/test_laplace_diamond.py @@ -3,7 +3,7 @@ def test_laplace_diamond(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -11,7 +11,7 @@ def test_laplace_diamond(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, -1, 0, 0], [0, -1, 4, -1, 0], @@ -22,8 +22,8 @@ def test_laplace_diamond(): result = cle.create(test1) cle.laplace_diamond(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_logarithm.py b/tests/test_logarithm.py index 2224d224..0bd335f5 100644 --- a/tests/test_logarithm.py +++ b/tests/test_logarithm.py @@ -3,12 +3,12 @@ def test_logarithm(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [1, 10], [1000, 100] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 2.3026], [6.9078, 4.6052] ])) @@ -16,8 +16,8 @@ def test_logarithm(): result = cle.create(test1) cle.logarithm(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) print(b) diff --git a/tests/test_mask.py b/tests/test_mask.py index 6415bced..3b6d013b 100644 --- a/tests/test_mask.py +++ b/tests/test_mask.py @@ -3,14 +3,14 @@ def test_mask(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 1, 0, 0], @@ -18,7 +18,7 @@ def test_mask(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 2, 0, 0], [0, 0, 3, 0, 0], @@ -29,8 +29,8 @@ def test_mask(): result = cle.create(test1) cle.mask(test1, test2, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_mask_label.py b/tests/test_mask_label.py index b8a24792..c6681552 100644 --- a/tests/test_mask_label.py +++ b/tests/test_mask_label.py @@ -3,14 +3,14 @@ def test_mask_label(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 1, 3, 0], [0, 2, 1, 3, 0], @@ -18,7 +18,7 @@ def test_mask_label(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 2, 0, 0], [0, 0, 3, 0, 0], @@ -29,8 +29,8 @@ def test_mask_label(): result = cle.create(test1) cle.mask_label(test1, test2, result, 1) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_maximum_box.py b/tests/test_maximum_box.py index 00603f8c..72b2184b 100644 --- a/tests/test_maximum_box.py +++ b/tests/test_maximum_box.py @@ -2,7 +2,7 @@ import numpy as np def test_maximum_box(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -10,7 +10,7 @@ def test_maximum_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], @@ -21,8 +21,8 @@ def test_maximum_box(): result = cle.create(test1) cle.maximum_box(test1, result, 1, 1, 0) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_maximum_image_and_scalar.py b/tests/test_maximum_image_and_scalar.py index 05bb95a5..c55b06aa 100644 --- a/tests/test_maximum_image_and_scalar.py +++ b/tests/test_maximum_image_and_scalar.py @@ -3,13 +3,13 @@ def test_maximum_image_and_scalar(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 3, 4, 5, 0], [0, 2, 1, 6, 0], [0, 0, 8, 7, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [2, 3, 4, 5, 2], [2, 2, 2, 6, 2], [2, 2, 8, 7, 2] @@ -18,8 +18,8 @@ def test_maximum_image_and_scalar(): result = cle.create(test1) cle.maximum_image_and_scalar(test1, result, 2) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_maximum_images.py b/tests/test_maximum_images.py index 3c2d7b52..57206fee 100644 --- a/tests/test_maximum_images.py +++ b/tests/test_maximum_images.py @@ -3,14 +3,14 @@ def test_maximum_images(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 1, 3, 0], [0, 2, 1, 3, 0], @@ -18,7 +18,7 @@ def test_maximum_images(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 2, 3, 0], [0, 3, 3, 4, 0], @@ -29,8 +29,8 @@ def test_maximum_images(): result = cle.create(test1) cle.maximum_images(test1, test2, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_maximum_of_all_pixels.py b/tests/test_maximum_of_all_pixels.py index 76270447..7e1a35fd 100644 --- a/tests/test_maximum_of_all_pixels.py +++ b/tests/test_maximum_of_all_pixels.py @@ -20,7 +20,7 @@ def test_maximum_of_all_pixels(): print(result) assert (result == 15) - gpu_input = cle.push(np_input) + gpu_input = cle.push_zyx(np_input) result = cle.maximum_of_all_pixels(gpu_input) print(result) assert (result == 15) diff --git a/tests/test_maximum_sphere.py b/tests/test_maximum_sphere.py index 063d0fa7..a3963cd7 100644 --- a/tests/test_maximum_sphere.py +++ b/tests/test_maximum_sphere.py @@ -2,7 +2,7 @@ import numpy as np def test_maximum_sphere_1(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [1, 1, 1], [1, 2, 1], [1, 1, 1] @@ -11,7 +11,7 @@ def test_maximum_sphere_1(): test2 = cle.create(test) cle.maximum_sphere(test, test2, 1, 1, 1) - a = cle.pull(test2) + a = cle.pull_zyx(test2) assert (np.min(a) == 1) assert (np.max(a) == 2) @@ -19,20 +19,20 @@ def test_maximum_sphere_1(): # print(test) # print(cle.pull(test)) - a = cle.pull(test) + a = cle.pull_zyx(test) assert (np.min(a) == 5) assert (np.max(a) == 5) assert (np.mean(a) == 5) def test_maximum_sphere_2(): - gpu_a = cle.push(np.asarray([[1, 1, 1], [1, 2, 1], [1, 1, 1]])) + gpu_a = cle.push_zyx(np.asarray([[1, 1, 1], [1, 2, 1], [1, 1, 1]])) gpu_b = cle.create(gpu_a) cle.maximum_sphere(gpu_a, gpu_b, 1, 1, 1) - a = cle.pull(gpu_b) + a = cle.pull_zyx(gpu_b) assert np.min(a) == 1 assert np.max(a) == 2 cle.set(gpu_a, 5) - assert np.all(cle.pull(gpu_a) == 5) \ No newline at end of file + assert np.all(cle.pull_zyx(gpu_a) == 5) \ No newline at end of file diff --git a/tests/test_maximum_x_projection.py b/tests/test_maximum_x_projection.py index 35deb98e..c339574e 100644 --- a/tests/test_maximum_x_projection.py +++ b/tests/test_maximum_x_projection.py @@ -3,7 +3,7 @@ def test_maximum_x_projection(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -35,21 +35,21 @@ def test_maximum_x_projection(): [0, 2, 0, 8, 0], [5, 0, 6, 0, 10] ] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [1, 3, 3, 3, 5], [2, 4, 4, 4, 0], [0, 1, 1, 1, 6], [8, 8, 7, 8, 0], [9, 10, 10, 10, 10] - ])) + ]).T) result = cle.create(reference) cle.maximum_x_projection(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_maximum_y_projection.py b/tests/test_maximum_y_projection.py index c0aadc20..f74202e5 100644 --- a/tests/test_maximum_y_projection.py +++ b/tests/test_maximum_y_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_maximum_y_projection(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -34,21 +34,21 @@ def test_maximum_y_projection(): [0, 2, 0, 8, 0], [5, 0, 6, 0, 10] ] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [5, 4, 6, 8, 10], [5, 4, 6, 8, 10], [5, 4, 6, 8, 10], [5, 4, 6, 8, 10], [5, 4, 6, 8, 10] - ])) + ]).T) result = cle.create(reference) cle.maximum_y_projection(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_maximum_z_projection.py b/tests/test_maximum_z_projection.py index b46ee6da..c9156db7 100644 --- a/tests/test_maximum_z_projection.py +++ b/tests/test_maximum_z_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_maximum_z_projection(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -34,15 +34,15 @@ def test_maximum_z_projection(): [0, 2, 0, 8, 0], [5, 0, 6, 0, 10] ] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [9, 8, 10, 7, 10], [8, 9, 10, 7, 10], [8, 10, 7, 9, 10], [8, 9, 7, 10, 10], [9, 7, 10, 8, 10] - ])) + ]).T) result = cle.create(reference) cle.maximum_z_projection(test1, result) diff --git a/tests/test_mean_box.py b/tests/test_mean_box.py index 35e06a78..d35941d2 100644 --- a/tests/test_mean_box.py +++ b/tests/test_mean_box.py @@ -3,7 +3,7 @@ def test_mean_box(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 9, 0, 0], @@ -11,7 +11,7 @@ def test_mean_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], @@ -22,8 +22,8 @@ def test_mean_box(): result = cle.create(test1) cle.mean_box(test1, result, 1, 1, 0) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_mean_of_all_pixels.py b/tests/test_mean_of_all_pixels.py index 68da0b35..0b596050 100644 --- a/tests/test_mean_of_all_pixels.py +++ b/tests/test_mean_of_all_pixels.py @@ -2,7 +2,7 @@ import numpy as np def test_mean_of_all_pixels_3d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [0, 4, 0, 0, 2], [0, 0, 0, 8, 0], @@ -18,7 +18,7 @@ def test_mean_of_all_pixels_3d(): def test_mean_of_all_pixels_2d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 4, 0, 0, 2], [0, 0, 0, 8, 0], [3, 0, 0, 0, 0], @@ -31,7 +31,7 @@ def test_mean_of_all_pixels_2d(): assert s == 1 def test_mean_of_all_pixels_1d(): - test1 = cle.push(np.asarray( + test1 = cle.push_zyx(np.asarray( [0, 8, 0, 0, 2] )) @@ -41,7 +41,7 @@ def test_mean_of_all_pixels_1d(): def test_mean_of_all_pixels_1d_y(): - test1 = cle.push(np.asarray( + test1 = cle.push_zyx(np.asarray( [[0], [8], [0], [0], [2]] )) @@ -50,7 +50,7 @@ def test_mean_of_all_pixels_1d_y(): assert s == 2 def test_mean_of_all_pixels_1d_z(): - test1 = cle.push(np.asarray( + test1 = cle.push_zyx(np.asarray( [[[0]], [[8]], [[0]], [[0]], [[2]]] )) diff --git a/tests/test_mean_sphere.py b/tests/test_mean_sphere.py index 8226b976..3bce9de2 100644 --- a/tests/test_mean_sphere.py +++ b/tests/test_mean_sphere.py @@ -2,7 +2,7 @@ import numpy as np def test_mean_sphere(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 9, 0, 0], @@ -10,7 +10,7 @@ def test_mean_sphere(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 1.8, 0, 0], [0, 1.8, 1.8, 1.8, 0], @@ -21,8 +21,8 @@ def test_mean_sphere(): result = cle.create(test1) cle.mean_sphere(test1, result, 1, 1, 0) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) print(b) diff --git a/tests/test_mean_x_projection.py b/tests/test_mean_x_projection.py index de9b6336..c29567af 100644 --- a/tests/test_mean_x_projection.py +++ b/tests/test_mean_x_projection.py @@ -3,7 +3,7 @@ def test_mean_x_projection(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -35,15 +35,15 @@ def test_mean_x_projection(): [0, 2, 0, 8, 0], [5, 0, 6, 0, 10] ] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0.4, 1.0, 1.8, 0.8, 5.], [1.2, 1.2, 1.6, 2.0, 0.], [0., 0.2, 0.6, 0.2, 6.], [4.8, 3.0, 2.8, 4.4, 0.], [3.6, 5.6, 6.0, 3.8, 10.] - ])) + ]).T) result = cle.create(reference) cle.mean_x_projection(test1, result) diff --git a/tests/test_mean_y_projection.py b/tests/test_mean_y_projection.py index 6187be1b..dd9743ca 100644 --- a/tests/test_mean_y_projection.py +++ b/tests/test_mean_y_projection.py @@ -3,7 +3,7 @@ def test_mean_y_projection(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -35,22 +35,22 @@ def test_mean_y_projection(): [0, 2, 0, 8, 0], [5, 0, 6, 0, 10] ] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [1.8, 1.2, 1.4, 3, 5.8], [1.8, 1.2, 1.4, 3, 5.8], [1.8, 1.2, 1.4, 3, 5.8], [1.8, 1.2, 1.4, 3, 5.8], [1.8, 1.2, 1.4, 3, 5.8], - ])) + ]).T) result = cle.create(reference) cle.mean_y_projection(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) print(b) diff --git a/tests/test_mean_z_projection.py b/tests/test_mean_z_projection.py index 6b654035..37245790 100644 --- a/tests/test_mean_z_projection.py +++ b/tests/test_mean_z_projection.py @@ -3,7 +3,7 @@ def test_mean_z_projection(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -35,22 +35,22 @@ def test_mean_z_projection(): [0, 2, 0, 8, 0], [5, 0, 6, 0, 10] ] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [2, 2, 2.8, 2.2, 4.2], [2, 2, 2.8, 2.2, 4.2], [2, 2.8, 2.2, 2, 4.2], [2, 2, 2.2, 2.8, 4.2], [2, 2.2, 2.8, 2, 4.2] - ])) + ]).T) result = cle.create(reference) cle.mean_z_projection(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_merge_touching_labels.py b/tests/test_merge_touching_labels.py index 783e64fc..7ec90c05 100644 --- a/tests/test_merge_touching_labels.py +++ b/tests/test_merge_touching_labels.py @@ -3,7 +3,7 @@ def test_merge_touching_labels(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [ [1, 1, 0, 0, 0], [0, 2, 2, 0, 3], @@ -12,7 +12,7 @@ def test_merge_touching_labels(): ])) gpu_output = cle.create_like(gpu_input) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [ [1, 1, 0, 0, 0], [0, 1, 1, 0, 2], diff --git a/tests/test_nonzero_maximum_diamond.py b/tests/test_nonzero_maximum_diamond.py index 25388b3a..0c9e6728 100644 --- a/tests/test_nonzero_maximum_diamond.py +++ b/tests/test_nonzero_maximum_diamond.py @@ -2,7 +2,7 @@ import numpy as np def test_nonzero_maximum_diamond(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 2, 0], [0, 2, 2, 3, 0], @@ -10,7 +10,7 @@ def test_nonzero_maximum_diamond(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 2, 3, 0], [0, 3, 3, 4, 0], @@ -22,12 +22,12 @@ def test_nonzero_maximum_diamond(): flag = cle.create((1, 1, 1)) # as nonzero filters don't touch zero values, we need to initialize the result in advance - cle.set(result, 0); + cle.set(result, 0) cle.nonzero_maximum_diamond(test, flag, result) print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a, b, atol=0.00001)) diff --git a/tests/test_nonzero_minimum_box.py b/tests/test_nonzero_minimum_box.py index fe6ead5f..8167e6b3 100644 --- a/tests/test_nonzero_minimum_box.py +++ b/tests/test_nonzero_minimum_box.py @@ -2,7 +2,7 @@ import numpy as np def test_nonzero_minimum_box(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 2, 0], [0, 2, 2, 3, 0], @@ -10,7 +10,7 @@ def test_nonzero_minimum_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], @@ -22,12 +22,12 @@ def test_nonzero_minimum_box(): flag = cle.create((1, 1, 1)) # as nonzero filters don't touch zero values, we need to initialize the result in advance - cle.set(result, 0); + cle.set(result, 0) cle.nonzero_minimum_box(test, flag, result) print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a, b, atol=0.00001)) diff --git a/tests/test_nonzero_minimum_diamond.py b/tests/test_nonzero_minimum_diamond.py index 88ad7968..a5d0a7be 100644 --- a/tests/test_nonzero_minimum_diamond.py +++ b/tests/test_nonzero_minimum_diamond.py @@ -2,7 +2,7 @@ import numpy as np def test_nonzero_minimum_diamond(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 2, 0], [0, 2, 2, 3, 0], @@ -10,7 +10,7 @@ def test_nonzero_minimum_diamond(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 2, 0], @@ -22,13 +22,13 @@ def test_nonzero_minimum_diamond(): flag = cle.create((1, 1, 1)) # as nonzero filters don't touch zero values, we need to initialize the result in advance - cle.set(result, 0); + cle.set(result, 0) cle.nonzero_minimum_diamond(test, flag, result) print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a, b, atol=0.00001)) From f5716a5eff07b56e8ad1ae87d2fd41bdb7edd6bd Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 19:30:08 +0100 Subject: [PATCH 21/27] replace push and pull by push_zyx and pull_zyx --- tests/test_minimum_box.py | 8 ++--- tests/test_minimum_image_and_scalar.py | 8 ++--- tests/test_minimum_images.py | 10 +++--- tests/test_minimum_of_all_pixels.py | 2 +- tests/test_minimum_x_projection.py | 12 +++---- tests/test_minimum_y_projection.py | 12 +++---- tests/test_minimum_z_projection.py | 12 +++---- tests/test_multiply_images.py | 10 +++--- tests/test_multiply_matrix.py | 4 +-- tests/test_n_closest_points.py | 8 ++--- tests/test_nonzero_maximum_box.py | 8 ++--- tests/test_not_equal.py | 10 +++--- tests/test_not_equal_constant.py | 8 ++--- tests/test_onlyzero_overwrite_maximum_box.py | 8 ++--- ...test_onlyzero_overwrite_maximum_diamond.py | 8 ++--- tests/test_paste.py | 4 +-- tests/test_power.py | 8 ++--- tests/test_power_images.py | 10 +++--- tests/test_radians_to_degrees.py | 8 ++--- tests/test_replace_intensities.py | 8 ++--- tests/test_replace_intensity.py | 8 ++--- tests/test_set.py | 6 ++-- tests/test_set_column.py | 10 +++--- tests/test_set_image_borders.py | 8 ++--- .../test_set_nonzero_pixels_to_pixelindex.py | 4 +-- tests/test_set_plane.py | 32 ++++++++++--------- tests/test_set_ramp_x.py | 21 ++++++------ tests/test_set_ramp_y.py | 9 +++--- tests/test_set_ramp_z.py | 20 ++++++------ tests/test_set_row.py | 10 +++--- tests/test_set_where_x_equals_y.py | 8 ++--- tests/test_set_where_x_greater_than_y.py | 12 +++---- tests/test_set_where_x_smaller_than_y.py | 12 +++---- tests/test_smaller.py | 20 ++++++------ tests/test_smaller_constant.py | 8 ++--- tests/test_smaller_or_equal.py | 20 ++++++------ tests/test_smaller_or_equal_constant.py | 8 ++--- tests/test_sobel.py | 8 ++--- tests/test_sorenson_dice_coefficient.py | 8 ++--- tests/test_spots_to_pointlist.py | 10 +++--- tests/test_sum_of_all_pixels.py | 10 +++--- tests/test_sum_x_projection.py | 12 +++---- tests/test_sum_y_projection.py | 12 +++---- tests/test_sum_z_projection.py | 12 +++---- tests/test_threshold_otsu.py | 6 ++-- tests/test_top_hat_box.py | 4 +-- tests/test_top_hat_sphere.py | 4 +-- tests/test_touch_matrix_to_mesh.py | 20 ++++++------ tests/test_transpose_xy.py | 27 ++++++++-------- tests/test_transpose_xz.py | 20 ++++++------ tests/test_transpose_yz.py | 29 +++++++++-------- 51 files changed, 284 insertions(+), 280 deletions(-) diff --git a/tests/test_minimum_box.py b/tests/test_minimum_box.py index ab6df200..5db66eb9 100644 --- a/tests/test_minimum_box.py +++ b/tests/test_minimum_box.py @@ -2,7 +2,7 @@ import numpy as np def test_minimum_box(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], @@ -10,7 +10,7 @@ def test_minimum_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -21,8 +21,8 @@ def test_minimum_box(): result = cle.create(test1) cle.minimum_box(test1, result, 1, 1, 0) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_minimum_image_and_scalar.py b/tests/test_minimum_image_and_scalar.py index ad5f97c9..9feb867f 100644 --- a/tests/test_minimum_image_and_scalar.py +++ b/tests/test_minimum_image_and_scalar.py @@ -3,13 +3,13 @@ def test_minimum_image_and_scalar(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 3, 4, 5, 0], [0, 2, 1, 6, 0], [0, 0, 8, 7, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 2, 2, 2, 0], [0, 2, 1, 2, 0], [0, 0, 2, 2, 0] @@ -18,8 +18,8 @@ def test_minimum_image_and_scalar(): result = cle.create(test1) cle.minimum_image_and_scalar(test1, result, 2) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_minimum_images.py b/tests/test_minimum_images.py index f99a5842..384f63ef 100644 --- a/tests/test_minimum_images.py +++ b/tests/test_minimum_images.py @@ -3,14 +3,14 @@ def test_minimum_images(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 1, 3, 0], [0, 2, 1, 3, 0], @@ -18,7 +18,7 @@ def test_minimum_images(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 3, 0], [0, 2, 1, 3, 0], @@ -29,8 +29,8 @@ def test_minimum_images(): result = cle.create(test1) cle.minimum_images(test1, test2, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_minimum_of_all_pixels.py b/tests/test_minimum_of_all_pixels.py index c3362a58..afa8115f 100644 --- a/tests/test_minimum_of_all_pixels.py +++ b/tests/test_minimum_of_all_pixels.py @@ -20,7 +20,7 @@ def test_minimum_of_all_pixels(): print(result) assert (result == 1) - gpu_input = cle.push(np_input) + gpu_input = cle.push_zyx(np_input) result = cle.minimum_of_all_pixels(gpu_input) print(result) assert (result == 1) diff --git a/tests/test_minimum_x_projection.py b/tests/test_minimum_x_projection.py index 05f65aa7..8af3c8a3 100644 --- a/tests/test_minimum_x_projection.py +++ b/tests/test_minimum_x_projection.py @@ -6,7 +6,7 @@ #@pytest.mark.xfail(raises=cl.RuntimeError) def test_minimum_x_projection(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 0, 0, 0, 1], [0, 2, 0, 8, 1], @@ -38,21 +38,21 @@ def test_minimum_x_projection(): [0, 2, 0, 8, 1], [1, 1, 1, 1, 1] ] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], [1, 1, 1, 1, 1] - ])) + ]).T) result = cle.create(reference) cle.minimum_x_projection(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_minimum_y_projection.py b/tests/test_minimum_y_projection.py index 810b0038..7a155bac 100644 --- a/tests/test_minimum_y_projection.py +++ b/tests/test_minimum_y_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_minimum_y_projection(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 0, 0, 0, 1], [0, 2, 0, 8, 1], @@ -34,21 +34,21 @@ def test_minimum_y_projection(): [0, 2, 0, 8, 1], [1, 1, 1, 1, 1] ] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 1] - ])) + ]).T) result = cle.create(reference) cle.minimum_y_projection(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_minimum_z_projection.py b/tests/test_minimum_z_projection.py index 9c6d7ad6..ff053139 100644 --- a/tests/test_minimum_z_projection.py +++ b/tests/test_minimum_z_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_minimum_z_projection(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 0, 0, 0, 1], [0, 2, 0, 8, 1], @@ -34,21 +34,21 @@ def test_minimum_z_projection(): [0, 2, 0, 8, 1], [1, 1, 1, 1, 1] ] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 1] - ])) + ]).T) result = cle.create(reference) cle.minimum_z_projection(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_multiply_images.py b/tests/test_multiply_images.py index ce40e7ac..7cc6d574 100644 --- a/tests/test_multiply_images.py +++ b/tests/test_multiply_images.py @@ -3,14 +3,14 @@ def test_multiply_images(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 4, 5, 6, 0], [0, 7, 8, 9, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 2, 2, 0], [0, 1, 1, 1, 0], @@ -18,7 +18,7 @@ def test_multiply_images(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 4, 6, 0], [0, 4, 5, 6, 0], @@ -29,8 +29,8 @@ def test_multiply_images(): result = cle.create(test1) cle.multiply_images(test1, test2, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_multiply_matrix.py b/tests/test_multiply_matrix.py index 6a1841dc..3d87e0db 100644 --- a/tests/test_multiply_matrix.py +++ b/tests/test_multiply_matrix.py @@ -12,8 +12,8 @@ def multiply(): b_np = np.random.rand(shape, shape).astype("float32") if target == "gpu": # push arrays to GPU - gpu_a = cle.push(a_np) - gpu_b = cle.push(b_np) + gpu_a = cle.push_zyx(a_np) + gpu_b = cle.push_zyx(b_np) # allocate memory for result on GPU gpu_c = cle.create((shape, shape)) cle.multiply_matrix(gpu_a, gpu_b, gpu_c) diff --git a/tests/test_n_closest_points.py b/tests/test_n_closest_points.py index 654146be..663ba580 100644 --- a/tests/test_n_closest_points.py +++ b/tests/test_n_closest_points.py @@ -29,8 +29,8 @@ def test_n_closest_points(): n_closest_points = cle.n_closest_points(distance_matrix, n=1, ignore_background=False) - a = cle.pull(n_closest_points) - b = cle.pull(reference) + a = cle.pull_zyx(n_closest_points) + b = cle.pull_zyx(reference) print(a) print(b) @@ -69,8 +69,8 @@ def test_n_closest_points_ignore_background(): n_closest_points = cle.n_closest_points(distance_matrix, n=1) - a = cle.pull(n_closest_points) - b = cle.pull(reference) + a = cle.pull_zyx(n_closest_points) + b = cle.pull_zyx(reference) print(a) print(b) diff --git a/tests/test_nonzero_maximum_box.py b/tests/test_nonzero_maximum_box.py index e5d874c4..ee03c9d1 100644 --- a/tests/test_nonzero_maximum_box.py +++ b/tests/test_nonzero_maximum_box.py @@ -2,7 +2,7 @@ import numpy as np def test_nonzero_maximum_box(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 2, 0], [0, 2, 2, 3, 0], @@ -10,7 +10,7 @@ def test_nonzero_maximum_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 3, 3, 0], [0, 3, 4, 4, 0], @@ -28,6 +28,6 @@ def test_nonzero_maximum_box(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a, b, atol=0.00001)) diff --git a/tests/test_not_equal.py b/tests/test_not_equal.py index dd346cd1..c156594f 100644 --- a/tests/test_not_equal.py +++ b/tests/test_not_equal.py @@ -3,14 +3,14 @@ def test_not_equal(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 4, 5, 6, 0], [0, 7, 8, 9, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 2, 2, 0], [0, 1, 1, 1, 0], @@ -18,7 +18,7 @@ def test_not_equal(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 0, 1, 0], [0, 1, 1, 1, 0], @@ -29,8 +29,8 @@ def test_not_equal(): result = cle.create(test1) cle.not_equal(test1, test2, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_not_equal_constant.py b/tests/test_not_equal_constant.py index 92dc162b..17767c05 100644 --- a/tests/test_not_equal_constant.py +++ b/tests/test_not_equal_constant.py @@ -3,7 +3,7 @@ def test_not_equal_constant(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_not_equal_constant(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 0, 1], @@ -24,6 +24,6 @@ def test_not_equal_constant(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_onlyzero_overwrite_maximum_box.py b/tests/test_onlyzero_overwrite_maximum_box.py index e67a7fa0..b0274231 100644 --- a/tests/test_onlyzero_overwrite_maximum_box.py +++ b/tests/test_onlyzero_overwrite_maximum_box.py @@ -2,7 +2,7 @@ import numpy as np def test_onlyzero_overwrite_maximum_box(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -10,7 +10,7 @@ def test_onlyzero_overwrite_maximum_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [1, 2, 3, 3, 3], [2, 1, 2, 3, 4], [4, 2, 3, 4, 5], @@ -24,6 +24,6 @@ def test_onlyzero_overwrite_maximum_box(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_onlyzero_overwrite_maximum_diamond.py b/tests/test_onlyzero_overwrite_maximum_diamond.py index 122b8c78..9cf6aee2 100644 --- a/tests/test_onlyzero_overwrite_maximum_diamond.py +++ b/tests/test_onlyzero_overwrite_maximum_diamond.py @@ -3,7 +3,7 @@ def onlyzero_overwrite_maximum_diamond(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def onlyzero_overwrite_maximum_diamond(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 1, 2, 3, 0], [1, 1, 2, 3, 3], [2, 2, 3, 4, 4], @@ -25,6 +25,6 @@ def onlyzero_overwrite_maximum_diamond(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_paste.py b/tests/test_paste.py index ce33b477..f8623ec7 100644 --- a/tests/test_paste.py +++ b/tests/test_paste.py @@ -23,8 +23,8 @@ def test_paste(): cle.copy(test1, result) cle.paste(test2, result, 1, 2, 0) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_power.py b/tests/test_power.py index 5b62daf6..375a8dda 100644 --- a/tests/test_power.py +++ b/tests/test_power.py @@ -3,7 +3,7 @@ def test_power(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_power(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 4, 9, 0], [0, 4, 9, 16, 0], @@ -24,6 +24,6 @@ def test_power(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_power_images.py b/tests/test_power_images.py index 2253369b..c02f1327 100644 --- a/tests/test_power_images.py +++ b/tests/test_power_images.py @@ -3,14 +3,14 @@ def test_power_images(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 4, 5, 6, 0], [0, 7, 8, 9, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [1, 0, 0, 0, 0], [1, 1, 2, 3, 0], [1, 1, 2, 3, 0], @@ -18,7 +18,7 @@ def test_power_images(): [1, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 1, 1, 1, 1], [0, 1, 4, 27, 1], [0, 4, 25, 216, 1], @@ -29,8 +29,8 @@ def test_power_images(): result = cle.create(test1) cle.power_images(test1, test2, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.allclose(a, b, 0.0001)) diff --git a/tests/test_radians_to_degrees.py b/tests/test_radians_to_degrees.py index 8c5b914a..cb3f69b4 100644 --- a/tests/test_radians_to_degrees.py +++ b/tests/test_radians_to_degrees.py @@ -2,17 +2,17 @@ import numpy as np def test_radians_to_degrees(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [np.pi, 0, -0.5 * np.pi] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [180, 0, -90] ])) result = cle.radians_to_degrees(test) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a,b,0.01)) diff --git a/tests/test_replace_intensities.py b/tests/test_replace_intensities.py index e55ef6cf..ec495737 100644 --- a/tests/test_replace_intensities.py +++ b/tests/test_replace_intensities.py @@ -3,7 +3,7 @@ def test_replace_intensities(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -15,7 +15,7 @@ def test_replace_intensities(): [0, 9, 8, 7, 6, 5] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 9, 8, 7, 0], [0, 8, 7, 6, 0], @@ -28,6 +28,6 @@ def test_replace_intensities(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_replace_intensity.py b/tests/test_replace_intensity.py index 1c4a4116..0a76469b 100644 --- a/tests/test_replace_intensity.py +++ b/tests/test_replace_intensity.py @@ -3,7 +3,7 @@ def test_replace_intensity(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_replace_intensity(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 8, 3, 0], [0, 8, 3, 4, 0], @@ -24,6 +24,6 @@ def test_replace_intensity(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_set.py b/tests/test_set.py index d486dbc9..086de116 100644 --- a/tests/test_set.py +++ b/tests/test_set.py @@ -5,7 +5,7 @@ def test_set(): result = cle.create((5, 5)) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], @@ -17,6 +17,6 @@ def test_set(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_set_column.py b/tests/test_set_column.py index 6b4fc951..030fe263 100644 --- a/tests/test_set_column.py +++ b/tests/test_set_column.py @@ -2,7 +2,7 @@ import numpy as np def test_set_column(): - result = cle.push(np.asarray([ + result = cle.push_zyx(np.asarray([ [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], @@ -10,18 +10,18 @@ def test_set_column(): [3, 3, 3, 3, 3] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4], [3, 3, 3, 3, 3] - ])) + ]).T) cle.set_column(result, 3, 4) print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_set_image_borders.py b/tests/test_set_image_borders.py index c4bce625..4b64e829 100644 --- a/tests/test_set_image_borders.py +++ b/tests/test_set_image_borders.py @@ -3,7 +3,7 @@ def test_set_image_borders(): - result = cle.push(np.asarray([ + result = cle.push_zyx(np.asarray([ [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], @@ -11,7 +11,7 @@ def test_set_image_borders(): [3, 3, 3, 3, 3] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [4, 4, 4, 4, 4], [4, 3, 3, 3, 4], [4, 3, 3, 3, 4], @@ -23,6 +23,6 @@ def test_set_image_borders(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_set_nonzero_pixels_to_pixelindex.py b/tests/test_set_nonzero_pixels_to_pixelindex.py index 3e0c6eda..37814c98 100644 --- a/tests/test_set_nonzero_pixels_to_pixelindex.py +++ b/tests/test_set_nonzero_pixels_to_pixelindex.py @@ -19,8 +19,8 @@ def test_set_nonzero_pixels_to_pixelindex(): result = cle.create(test1) cle.set_non_zero_pixels_to_pixel_index(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_set_plane.py b/tests/test_set_plane.py index c696feb9..c720e413 100644 --- a/tests/test_set_plane.py +++ b/tests/test_set_plane.py @@ -2,7 +2,7 @@ import numpy as np def test_set_plane(): - result = cle.push(np.asarray([ + result = cle.push_zyx(np.asarray([ [ [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], @@ -18,26 +18,28 @@ def test_set_plane(): ] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [ - [3, 4, 3, 3, 3], - [3, 4, 3, 3, 3], - [3, 4, 3, 3, 3], - [3, 4, 3, 3, 3], - [3, 4, 3, 3, 3] + [3, 3, 3, 3, 3], + [3, 3, 3, 3, 3], + [3, 3, 3, 3, 3], + [3, 3, 3, 3, 3], + [3, 3, 3, 3, 3] ], [ - [3, 4, 3, 3, 3], - [3, 4, 3, 3, 3], - [3, 4, 3, 3, 3], - [3, 4, 3, 3, 3], - [3, 4, 3, 3, 3] + [4, 4, 4, 4, 4], + [4, 4, 4, 4, 4], + [4, 4, 4, 4, 4], + [4, 4, 4, 4, 4], + [4, 4, 4, 4, 4] ] ])) cle.set_plane(result, 1, 4) - print(result) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) + + print(a) + print(b) - a = cle.pull(result) - b = cle.pull(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_set_ramp_x.py b/tests/test_set_ramp_x.py index 03a9c67f..611a0376 100644 --- a/tests/test_set_ramp_x.py +++ b/tests/test_set_ramp_x.py @@ -2,7 +2,7 @@ import numpy as np def test_set_ramp_x(): - result = cle.push(np.asarray([ + result = cle.push_zyx(np.asarray([ [ [0, 0, 0], [3, 4, 3], @@ -14,23 +14,24 @@ def test_set_ramp_x(): ] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [ - [0, 0, 0], - [0, 0, 0], - [0, 0, 0] + [0, 1, 2], + [0, 1, 2], + [0, 1, 2] ], [ - [1, 1, 1], - [1, 1, 1], - [1, 1, 1] + [0, 1, 2], + [0, 1, 2], + [0, 1, 2] ] ])) cle.set_ramp_x(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) + print(b) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_set_ramp_y.py b/tests/test_set_ramp_y.py index ea2edb05..888b9cf4 100644 --- a/tests/test_set_ramp_y.py +++ b/tests/test_set_ramp_y.py @@ -2,7 +2,7 @@ import numpy as np def test_set_ramp_y(): - result = cle.push(np.asarray([ + result = cle.push_zyx(np.asarray([ [ [0, 0, 0], [3, 4, 3], @@ -14,7 +14,7 @@ def test_set_ramp_y(): ] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [ [0, 0, 0], [1, 1, 1], @@ -28,9 +28,10 @@ def test_set_ramp_y(): cle.set_ramp_y(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) + print(b) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_set_ramp_z.py b/tests/test_set_ramp_z.py index 31df2ecf..1af4d11f 100644 --- a/tests/test_set_ramp_z.py +++ b/tests/test_set_ramp_z.py @@ -2,7 +2,7 @@ import numpy as np def test_set_ramp_z(): - result = cle.push(np.asarray([ + result = cle.push_zyx(np.asarray([ [ [0, 0, 0], [3, 4, 3], @@ -14,22 +14,22 @@ def test_set_ramp_z(): ] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [ - [0, 1, 2], - [0, 1, 2], - [0, 1, 2] + [0, 0, 0], + [0, 0, 0], + [0, 0, 0] ], [ - [0, 1, 2], - [0, 1, 2], - [0, 1, 2] + [1, 1, 1], + [1, 1, 1], + [1, 1, 1] ] ])) cle.set_ramp_z(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_set_row.py b/tests/test_set_row.py index 868685a0..fd94eb5e 100644 --- a/tests/test_set_row.py +++ b/tests/test_set_row.py @@ -2,7 +2,7 @@ import numpy as np def test_set_row(): - result = cle.push(np.asarray([ + result = cle.push_zyx(np.asarray([ [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], @@ -10,18 +10,18 @@ def test_set_row(): [3, 3, 3, 3, 3] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [3, 3, 3, 4, 3], [3, 3, 3, 4, 3], [3, 3, 3, 4, 3], [3, 3, 3, 4, 3], [3, 3, 3, 4, 3] - ])) + ]).T) cle.set_row(result, 3, 4) print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_set_where_x_equals_y.py b/tests/test_set_where_x_equals_y.py index 6a8c3459..210c889e 100644 --- a/tests/test_set_where_x_equals_y.py +++ b/tests/test_set_where_x_equals_y.py @@ -3,14 +3,14 @@ def test_set_where_x_equals_y(): - result = cle.push(np.asarray([ + result = cle.push_zyx(np.asarray([ [0, 0, 0, 1], [0, 0, 3, 1], [0, 0, 3, 1], [1, 1, 1, 1] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [3, 0, 0, 1], [0, 3, 3, 1], [0, 0, 3, 1], @@ -19,8 +19,8 @@ def test_set_where_x_equals_y(): cle.set_where_x_equals_y(result, 3) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_set_where_x_greater_than_y.py b/tests/test_set_where_x_greater_than_y.py index 651ba7bf..e4ad7a6b 100644 --- a/tests/test_set_where_x_greater_than_y.py +++ b/tests/test_set_where_x_greater_than_y.py @@ -3,24 +3,24 @@ def test_set_where_x_greater_than_y(): - result = cle.push(np.asarray([ + result = cle.push_zyx(np.asarray([ [0, 0, 0, 1], [0, 0, 3, 1], [0, 0, 3, 1], [1, 1, 1, 1] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 1], [3, 0, 3, 1], [3, 3, 3, 1], [3, 3, 3, 1] - ])) + ]).T) cle.set_where_x_greater_than_y(result, 3) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_set_where_x_smaller_than_y.py b/tests/test_set_where_x_smaller_than_y.py index 828a675e..ad0e43bd 100644 --- a/tests/test_set_where_x_smaller_than_y.py +++ b/tests/test_set_where_x_smaller_than_y.py @@ -3,24 +3,24 @@ def test_set_where_x_smaller_than_y(): - result = cle.push(np.asarray([ + result = cle.push_zyx(np.asarray([ [0, 0, 0, 1], [0, 0, 3, 1], [0, 0, 3, 1], [1, 1, 1, 1] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 3, 3, 3], [0, 0, 3, 3], [0, 0, 3, 3], [1, 1, 1, 1] - ])) + ]).T) cle.set_where_x_smaller_than_y(result, 3) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_smaller.py b/tests/test_smaller.py index 5b527f27..8d7adc6c 100644 --- a/tests/test_smaller.py +++ b/tests/test_smaller.py @@ -3,14 +3,14 @@ def test_smaller_2d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 3, 3, 3, 0], [0, 3, 3, 3, 0], @@ -18,7 +18,7 @@ def test_smaller_2d(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 0, 0], [0, 0, 0, 0, 0], @@ -29,8 +29,8 @@ def test_smaller_2d(): result = cle.create(test1) cle.smaller(test1, test2, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) @@ -38,7 +38,7 @@ def test_smaller_2d(): print("ok smaller") def test_smaller_3d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [0, 1, 2, 3, 0], [0, 3, 3, 4, 0] @@ -47,7 +47,7 @@ def test_smaller_3d(): [0, 0, 0, 0, 0] ] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [ [0, 3, 3, 3, 0], [0, 3, 3, 3, 0] @@ -57,7 +57,7 @@ def test_smaller_3d(): ] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [ [0, 1, 1, 0, 0], [0, 0, 0, 0, 0] @@ -70,8 +70,8 @@ def test_smaller_3d(): result = cle.create(test1) cle.smaller(test1, test2, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_smaller_constant.py b/tests/test_smaller_constant.py index 24e4f076..762756f7 100644 --- a/tests/test_smaller_constant.py +++ b/tests/test_smaller_constant.py @@ -3,7 +3,7 @@ def test_smaller_constant(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_smaller_constant(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 0, 1], @@ -24,6 +24,6 @@ def test_smaller_constant(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_smaller_or_equal.py b/tests/test_smaller_or_equal.py index 70572606..87b28743 100644 --- a/tests/test_smaller_or_equal.py +++ b/tests/test_smaller_or_equal.py @@ -3,14 +3,14 @@ def test_smaller_or_equal_2d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 3, 3, 3, 0], [0, 3, 3, 3, 0], @@ -18,7 +18,7 @@ def test_smaller_or_equal_2d(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 0, 1], @@ -29,14 +29,14 @@ def test_smaller_or_equal_2d(): result = cle.create(test1) cle.smaller_or_equal(test1, test2, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) def test_smaller_or_equal_3d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [0, 1, 2, 3, 0], [0, 3, 3, 4, 0] @@ -45,7 +45,7 @@ def test_smaller_or_equal_3d(): [0, 0, 0, 0, 0] ] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [ [0, 3, 3, 3, 0], [0, 3, 3, 3, 0] @@ -55,7 +55,7 @@ def test_smaller_or_equal_3d(): ] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [ [1, 1, 1, 1, 1], [1, 1, 1, 0, 1] @@ -68,8 +68,8 @@ def test_smaller_or_equal_3d(): result = cle.create(test1) cle.smaller_or_equal(test1, test2, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_smaller_or_equal_constant.py b/tests/test_smaller_or_equal_constant.py index 4c789896..a19c1ae7 100644 --- a/tests/test_smaller_or_equal_constant.py +++ b/tests/test_smaller_or_equal_constant.py @@ -3,7 +3,7 @@ def test_smaller_or_equal_constant(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_smaller_or_equal_constant(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 0, 1], @@ -24,6 +24,6 @@ def test_smaller_or_equal_constant(): print(result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_sobel.py b/tests/test_sobel.py index 974309f0..a63f95df 100644 --- a/tests/test_sobel.py +++ b/tests/test_sobel.py @@ -3,7 +3,7 @@ def test_sobel(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -11,7 +11,7 @@ def test_sobel(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1.41, 2, 1.41, 0], [0, 3.16, 2, 3.16, 0], @@ -21,8 +21,8 @@ def test_sobel(): result = cle.create(test1) cle.sobel(test1, result) - a = cle.pull(result) + a = cle.pull_zyx(result) print(a) - b = cle.pull(reference) + b = cle.pull_zyx(reference) assert (np.allclose(a, b, 0.01)) diff --git a/tests/test_sorenson_dice_coefficient.py b/tests/test_sorenson_dice_coefficient.py index ba8b0dd1..258f4424 100644 --- a/tests/test_sorenson_dice_coefficient.py +++ b/tests/test_sorenson_dice_coefficient.py @@ -3,12 +3,12 @@ def test_sorensen_dice_coefficient_2d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [0, 1, 1, 0, 0], [0, 1, 1, 0, 0] ])) @@ -18,12 +18,12 @@ def test_sorensen_dice_coefficient_2d(): assert abs(d - 0.666) < 0.001 def test_sorensen_dice_coefficient_3d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [[0, 0, 0], [0, 0, 0]], [[0, 1, 1], [0, 1, 0]] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [[0, 1, 1], [0, 1, 0]], [[0, 1, 1], [0, 1, 0]] ])) diff --git a/tests/test_spots_to_pointlist.py b/tests/test_spots_to_pointlist.py index c62d0dae..a4ef2840 100644 --- a/tests/test_spots_to_pointlist.py +++ b/tests/test_spots_to_pointlist.py @@ -3,7 +3,7 @@ def test_labelled_spots_to_pointlist(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 0, 1, 0], @@ -13,12 +13,10 @@ def test_labelled_spots_to_pointlist(): ])) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ - [1, 1], - [3, 2], - [1, 3], - [4, 4] + [1, 3, 2, 4], + [1, 1, 3, 4] ])) diff --git a/tests/test_sum_of_all_pixels.py b/tests/test_sum_of_all_pixels.py index 25dd5514..2549f86d 100644 --- a/tests/test_sum_of_all_pixels.py +++ b/tests/test_sum_of_all_pixels.py @@ -2,7 +2,7 @@ import numpy as np def test_sum_of_all_pixels_3d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [0, 4, 0, 0, 2], [0, 0, 0, 8, 0], @@ -18,7 +18,7 @@ def test_sum_of_all_pixels_3d(): def test_sum_of_all_pixels_2d(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 4, 0, 0, 2], [0, 0, 0, 8, 0], [3, 0, 0, 0, 0], @@ -31,7 +31,7 @@ def test_sum_of_all_pixels_2d(): assert s == 20 def test_sum_of_all_pixels_1d(): - test1 = cle.push(np.asarray( + test1 = cle.push_zyx(np.asarray( [0, 4, 0, 0, 2] )) @@ -41,7 +41,7 @@ def test_sum_of_all_pixels_1d(): def test_sum_of_all_pixels_1d_y(): - test1 = cle.push(np.asarray( + test1 = cle.push_zyx(np.asarray( [[0], [4], [0], [0], [2]] )) @@ -50,7 +50,7 @@ def test_sum_of_all_pixels_1d_y(): assert s == 6 def test_sum_of_all_pixels_1d_z(): - test1 = cle.push(np.asarray( + test1 = cle.push_zyx(np.asarray( [[[0]], [[4]], [[0]], [[0]], [[2]]] )) diff --git a/tests/test_sum_x_projection.py b/tests/test_sum_x_projection.py index 99a06235..1865358c 100644 --- a/tests/test_sum_x_projection.py +++ b/tests/test_sum_x_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_sum_x_projection(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -34,21 +34,21 @@ def test_sum_x_projection(): [0, 2, 0, 8, 0], [5, 0, 6, 0, 10] ] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [2, 5, 9, 4, 25], [6, 6, 8, 10, 0], [0, 1, 3, 1, 30], [24, 15, 14, 22, 0], [18, 28, 30, 19, 50] - ])) + ]).T) result = cle.create(reference) cle.sum_x_projection(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_sum_y_projection.py b/tests/test_sum_y_projection.py index 7f940347..41f07a76 100644 --- a/tests/test_sum_y_projection.py +++ b/tests/test_sum_y_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_sum_y_projection(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -34,21 +34,21 @@ def test_sum_y_projection(): [0, 2, 0, 8, 0], [5, 0, 6, 0, 10] ] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [9, 6, 7, 15, 29], [9, 6, 7, 15, 29], [9, 6, 7, 15, 29], [9, 6, 7, 15, 29], [9, 6, 7, 15, 29] - ])) + ]).T) result = cle.create(reference) cle.sum_y_projection(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_sum_z_projection.py b/tests/test_sum_z_projection.py index 69cfb01f..38858f30 100644 --- a/tests/test_sum_z_projection.py +++ b/tests/test_sum_z_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_sum_z_projection(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -34,21 +34,21 @@ def test_sum_z_projection(): [0, 2, 0, 8, 0], [5, 0, 6, 0, 10] ] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [10, 10, 14, 11, 21], [10, 10, 14, 11, 21], [10, 14, 11, 10, 21], [10, 10, 11, 14, 21], [10, 11, 14, 10, 21] - ])) + ]).T) result = cle.create(reference) cle.sum_z_projection(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_threshold_otsu.py b/tests/test_threshold_otsu.py index 6fbb50ac..08451ea7 100644 --- a/tests/test_threshold_otsu.py +++ b/tests/test_threshold_otsu.py @@ -19,13 +19,13 @@ def test_threshold_otsu_against_scikit_image(): # threshold in GPU import pyclesperanto_prototype as cle - gpu_image = cle.push(image) + gpu_image = cle.push_zyx(image) gpu_binary = cle.threshold_otsu(gpu_image) print(str(binary)) - print(str(cle.pull(gpu_binary))) + print(str(cle.pull_zyx(gpu_binary))) # compare import numpy as np - assert(np.allclose(binary, (cle.pull(gpu_binary) > 0))) + assert(np.allclose(binary, (cle.pull_zyx(gpu_binary) > 0))) diff --git a/tests/test_top_hat_box.py b/tests/test_top_hat_box.py index 38ab5ae5..d62a5e8a 100644 --- a/tests/test_top_hat_box.py +++ b/tests/test_top_hat_box.py @@ -3,7 +3,7 @@ def test_top_hat_sphere(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 50, 50, 50, 0], [0, 50, 100, 50, 0], @@ -16,7 +16,7 @@ def test_top_hat_sphere(): print(result) - a = cle.pull(result) + a = cle.pull_zyx(result) assert (np.min(a) == 0) assert (np.max(a) == 50) diff --git a/tests/test_top_hat_sphere.py b/tests/test_top_hat_sphere.py index 3b125be5..eb53b79e 100644 --- a/tests/test_top_hat_sphere.py +++ b/tests/test_top_hat_sphere.py @@ -3,7 +3,7 @@ def test_top_hat_sphere(): - test = cle.push(np.asarray([ + test = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 50, 50, 50, 0], [0, 50, 100, 50, 0], @@ -16,7 +16,7 @@ def test_top_hat_sphere(): print(result) - a = cle.pull(result) + a = cle.pull_zyx(result) assert (np.min(a) == 0) assert (np.max(a) == 50) diff --git a/tests/test_touch_matrix_to_mesh.py b/tests/test_touch_matrix_to_mesh.py index 18521ccc..9fd55385 100644 --- a/tests/test_touch_matrix_to_mesh.py +++ b/tests/test_touch_matrix_to_mesh.py @@ -3,34 +3,34 @@ def test_touch_matrix_to_mesh(): - gpu_touch_matrix = cle.push(np.asarray([ + gpu_touch_matrix = cle.push_zyx(np.asarray([ [0, 0, 0], - [0, 0, 1], - [0, 0, 0] + [0, 0, 0], + [0, 1, 0] ])) - gpu_point_list = cle.push(np.asarray([ - [1, 2], - [4, 5] + gpu_point_list = cle.push_zyx(np.asarray([ + [1, 4], + [2, 5] ])) gpu_output = cle.create([5, 5]) cle.set(gpu_output, 0) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0] - ])) + ]).T) cle.touch_matrix_to_mesh(gpu_point_list, gpu_touch_matrix, gpu_output) - a = cle.pull(gpu_output) - b = cle.pull(gpu_reference) + a = cle.pull_zyx(gpu_output) + b = cle.pull_zyx(gpu_reference) print(a) print(b) diff --git a/tests/test_transpose_xy.py b/tests/test_transpose_xy.py index 63825080..86bff3f3 100644 --- a/tests/test_transpose_xy.py +++ b/tests/test_transpose_xy.py @@ -2,7 +2,7 @@ import numpy as np def test_transpose_xy(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [0, 1], [2, 3] @@ -12,28 +12,29 @@ def test_transpose_xy(): ] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [ - [0, 1], - [4, 5] + [0, 2], + [1, 3] ], [ - [2, 3], - [6, 7] + [4, 6], + [5, 7] ] ])) result = cle.create(test1) cle.transpose_xy(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) + print(b) assert (np.array_equal(a, b)) def test_transpose_xy_3d_generate_output(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 2, 6], [3, 4, 5] @@ -42,14 +43,14 @@ def test_transpose_xy_3d_generate_output(): result = cle.transpose_xy(test1) - a = cle.pull(result) + a = cle.pull_zyx(result) assert (np.min(a) == 1) assert (np.max(a) == 6) assert (np.mean(a) == 3.5) def test_transpose_xy_2d_generate_output(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [1, 2, 6], [3, 4, 5] ])) @@ -65,13 +66,13 @@ def test_transpose_xy_2d_generate_output(): assert (np.mean(a) == 3.5) def test_transpose_xy_1d_generate_output(): - test1 = cle.push(np.asarray( + test1 = cle.push_zyx(np.asarray( [1, 2, 6, 3, 4, 5] )) result = cle.transpose_xy(test1) - a = cle.pull(result) + a = cle.pull_zyx(result) print(a) diff --git a/tests/test_transpose_xz.py b/tests/test_transpose_xz.py index 6b78dabc..bd24fb77 100644 --- a/tests/test_transpose_xz.py +++ b/tests/test_transpose_xz.py @@ -2,7 +2,7 @@ import numpy as np def test_transpose_xz(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [0, 1], [2, 3] @@ -12,7 +12,7 @@ def test_transpose_xz(): ] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [ [0, 4], [2, 6] @@ -25,15 +25,15 @@ def test_transpose_xz(): result = cle.create(test1) cle.transpose_xz(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) assert (np.array_equal(a, b)) def test_transpose_xz_3d_generate_output(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 2, 6], [3, 4, 5] @@ -42,21 +42,21 @@ def test_transpose_xz_3d_generate_output(): result = cle.transpose_xz(test1) - a = cle.pull(result) + a = cle.pull_zyx(result) assert (np.min(a) == 1) assert (np.max(a) == 6) assert (np.mean(a) == 3.5) def test_transpose_xz_2d_generate_output(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [1, 2, 6], [3, 4, 5] ])) result = cle.transpose_xz(test1) - a = cle.pull(result) + a = cle.pull_zyx(result) print(a) @@ -65,13 +65,13 @@ def test_transpose_xz_2d_generate_output(): assert (np.mean(a) == 3.5) def test_transpose_xz_1d_generate_output(): - test1 = cle.push(np.asarray( + test1 = cle.push_zyx(np.asarray( [1, 2, 6, 3, 4, 5] )) result = cle.transpose_xz(test1) - a = cle.pull(result) + a = cle.pull_zyx(result) print(a) diff --git a/tests/test_transpose_yz.py b/tests/test_transpose_yz.py index 7072579b..68a1fd75 100644 --- a/tests/test_transpose_yz.py +++ b/tests/test_transpose_yz.py @@ -2,7 +2,7 @@ import numpy as np def test_transpose_yz(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [0, 1], [2, 3] @@ -12,28 +12,29 @@ def test_transpose_yz(): ] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [ - [0, 2], - [1, 3] + [0, 1], + [4, 5] ], [ - [4, 6], - [5, 7] + [2, 3], + [6, 7] ] ])) result = cle.create(test1) cle.transpose_yz(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) + print(b) assert (np.array_equal(a, b)) def test_transpose_yz_3d_generate_output(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 2, 6], [3, 4, 5] @@ -42,21 +43,21 @@ def test_transpose_yz_3d_generate_output(): result = cle.transpose_yz(test1) - a = cle.pull(result) + a = cle.pull_zyx(result) assert (np.min(a) == 1) assert (np.max(a) == 6) assert (np.mean(a) == 3.5) def test_transpose_yz_2d_generate_output(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [1, 2, 6], [3, 4, 5] ])) result = cle.transpose_yz(test1) - a = cle.pull(result) + a = cle.pull_zyx(result) print(a) @@ -65,13 +66,13 @@ def test_transpose_yz_2d_generate_output(): assert (np.mean(a) == 3.5) def test_transpose_yz_1d_generate_output(): - test1 = cle.push(np.asarray( + test1 = cle.push_zyx(np.asarray( [1, 2, 6, 3, 4, 5] )) result = cle.transpose_yz(test1) - a = cle.pull(result) + a = cle.pull_zyx(result) print(a) From 39507450be2cf183c126ffb669aa554265e274e2 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 19:45:46 +0100 Subject: [PATCH 22/27] partial bugfix (merge from master) of projections --- pyclesperanto_prototype/_tier0/__init__.py | 1 + pyclesperanto_prototype/_tier0/_create.py | 37 ++++++++++++++++++---- 2 files changed, 32 insertions(+), 6 deletions(-) diff --git a/pyclesperanto_prototype/_tier0/__init__.py b/pyclesperanto_prototype/_tier0/__init__.py index ea05b86b..dd5ec4d1 100644 --- a/pyclesperanto_prototype/_tier0/__init__.py +++ b/pyclesperanto_prototype/_tier0/__init__.py @@ -16,6 +16,7 @@ create_2d_yx, create_2d_zx, create_2d_zy, + create_2d_yz, create_none, ) from ._execute import execute diff --git a/pyclesperanto_prototype/_tier0/_create.py b/pyclesperanto_prototype/_tier0/_create.py index f3679196..e6eea203 100644 --- a/pyclesperanto_prototype/_tier0/_create.py +++ b/pyclesperanto_prototype/_tier0/_create.py @@ -52,9 +52,9 @@ def create_matrix_from_pointlists(pointlist1:OCLArray, pointlist2:OCLArray): def create_from_pointlist(pointlist: OCLArray, *args): from .._tier1 import maximum_x_projection - from .._tier0 import pull + from .._tier0 import pull_zyx - max_pos = pull(maximum_x_projection(pointlist)).astype(int) + max_pos = pull_zyx(maximum_x_projection(pointlist)).T.astype(int) max_pos = max_pos[0] if len(max_pos) == 3: # 3D image requested @@ -89,17 +89,42 @@ def create_square_matrix_from_two_labelmaps(labelmap1: OCLArray, labelmap2: OCLA def create_vector_from_square_matrix(square_matrix : OCLArray, *args): return create([1, square_matrix.shape[0]]) + def create_2d_xy(input): - return create([input.shape[2], input.shape[1]]) + if len(input.shape) == 3: + return create([input.shape[2], input.shape[1]]) + else: + return create([input.shape[1], input.shape[0]]) def create_2d_yx(input): - return create([input.shape[1], input.shape[2]]) + if len(input.shape) == 3: + return create([input.shape[1], input.shape[2]]) + else: + return create([input.shape[0], 1]) def create_2d_zy(input): - return create([input.shape[0], input.shape[1]]) + if len(input.shape) == 3: + return create([input.shape[0], input.shape[1]]) + else: + return create([1, input.shape[0]]) + +def create_2d_yz(input): + if len(input.shape) == 3: + return create([input.shape[1], input.shape[0]]) + else: + return create([input.shape[0], 1]) def create_2d_zx(input): - return create([input.shape[0], input.shape[2]]) + if len(input.shape) == 3: + return create([input.shape[0], input.shape[2]]) + else: + return create([1, input.shape[1]]) + +def create_2d_xz(input): + if len(input.shape) == 3: + return create([input.shape[2], input.shape[0]]) + else: + return create([input.shape[1], 1]) def create_none(*args): return None \ No newline at end of file From 5245ff4700e11e098c683566f389beb6cdc75c38 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 19:48:11 +0100 Subject: [PATCH 23/27] replace push and pull by push_zyx and pull_zyx --- pyclesperanto_prototype/_tier0/_pull.py | 2 +- .../_tier1/_maximum_x_projection.py | 4 ++-- ...st_average_distance_of_n_far_off_distances.py | 4 ++-- ...t_average_distance_of_n_shortest_distances.py | 4 ++-- ...est_average_distance_of_touching_neighbors.py | 4 ++-- tests/test_copy_slice.py | 6 +++--- tests/test_histogram.py | 6 +++--- tests/test_maximum_z_projection.py | 4 ++-- tests/test_mean_x_projection.py | 4 ++-- tests/test_standard_deviation_z_projection.py | 12 ++++++------ tests/test_touching_neighbor_count_map.py | 4 ++-- tests/test_transpose_xy.py | 2 +- tests/test_undefined_to_zero.py | 10 +++++----- tests/test_voronoi_labeling.py | 16 ++++++++-------- 14 files changed, 41 insertions(+), 41 deletions(-) diff --git a/pyclesperanto_prototype/_tier0/_pull.py b/pyclesperanto_prototype/_tier0/_pull.py index 0b49f56b..224d4740 100644 --- a/pyclesperanto_prototype/_tier0/_pull.py +++ b/pyclesperanto_prototype/_tier0/_pull.py @@ -16,7 +16,7 @@ def pull(oclarray): Examples -------- >>> import pyclesperanto_prototype as cle - >>> cle.pull(image) + >>> cle.pull_zyx(image) References ---------- diff --git a/pyclesperanto_prototype/_tier1/_maximum_x_projection.py b/pyclesperanto_prototype/_tier1/_maximum_x_projection.py index 57fc44a3..be6b8459 100644 --- a/pyclesperanto_prototype/_tier1/_maximum_x_projection.py +++ b/pyclesperanto_prototype/_tier1/_maximum_x_projection.py @@ -1,9 +1,9 @@ from .._tier0 import execute from .._tier0 import plugin_function from .._tier0 import Image -from .._tier0 import create_2d_zy +from .._tier0 import create_2d_yz -@plugin_function(output_creator=create_2d_zy, categories=['projection']) +@plugin_function(output_creator=create_2d_yz, categories=['projection']) def maximum_x_projection(source : Image, destination_max : Image = None): """Determines the maximum intensity projection of an image along X. diff --git a/tests/test_average_distance_of_n_far_off_distances.py b/tests/test_average_distance_of_n_far_off_distances.py index 31457be6..3fd806a3 100644 --- a/tests/test_average_distance_of_n_far_off_distances.py +++ b/tests/test_average_distance_of_n_far_off_distances.py @@ -21,8 +21,8 @@ def test_average_distance_of_n_far_off_distances(): average_distance_of_n_far_off_distances = cle.average_distance_of_n_far_off_distances(distance_matrix, n=1) - a = cle.pull(average_distance_of_n_far_off_distances) - b = cle.pull(reference) + a = cle.pull_zyx(average_distance_of_n_far_off_distances) + b = cle.pull_zyx(reference) print(a) print(b) diff --git a/tests/test_average_distance_of_n_shortest_distances.py b/tests/test_average_distance_of_n_shortest_distances.py index e9684c07..d25ddc55 100644 --- a/tests/test_average_distance_of_n_shortest_distances.py +++ b/tests/test_average_distance_of_n_shortest_distances.py @@ -21,8 +21,8 @@ def test_average_distance_of_n_shortest_distances(): average_distance_of_n_far_off_distances = cle.average_distance_of_n_shortest_distances(distance_matrix, n=1) - a = cle.pull(average_distance_of_n_far_off_distances) - b = cle.pull(reference) + a = cle.pull_zyx(average_distance_of_n_far_off_distances) + b = cle.pull_zyx(reference) print(a) print(b) diff --git a/tests/test_average_distance_of_touching_neighbors.py b/tests/test_average_distance_of_touching_neighbors.py index 4fa2b5fe..e18a9707 100644 --- a/tests/test_average_distance_of_touching_neighbors.py +++ b/tests/test_average_distance_of_touching_neighbors.py @@ -22,8 +22,8 @@ def test_average_distance_of_touching_neighbors(): average_distance_of_touching_neighbors = cle.average_distance_of_touching_neighbors(distance_matrix, touch_matrix) - a = cle.pull(average_distance_of_touching_neighbors) - b = cle.pull(reference) + a = cle.pull_zyx(average_distance_of_touching_neighbors) + b = cle.pull_zyx(reference) print(a) print(b) diff --git a/tests/test_copy_slice.py b/tests/test_copy_slice.py index ef99ed9e..98a249e5 100644 --- a/tests/test_copy_slice.py +++ b/tests/test_copy_slice.py @@ -77,7 +77,7 @@ def test_copy_slice_to3d_with_one_slice_zyx(): cle.copy_slice(test1, test2, 0) print(test2) - a = cle.pull(test2) + a = cle.pull_zyx(test2) assert (np.min(a) == 2) assert (np.max(a) == 6) assert (np.mean(a) == 4) @@ -91,7 +91,7 @@ def test_copy_slice_mini_y(): cle.copy_slice(gpu_input, gpu_output, 0) print(gpu_output) - a = cle.pull(gpu_output) + a = cle.pull_zyx(gpu_output) assert (np.min(a) == 1) assert (np.max(a) == 4) assert (np.mean(a) == 2.5) @@ -105,7 +105,7 @@ def test_copy_slice_mini_x(): cle.copy_slice(gpu_input, gpu_output, 0) print(gpu_output) - a = cle.pull(gpu_output) + a = cle.pull_zyx(gpu_output) assert (np.min(a) == 1) assert (np.max(a) == 4) assert (np.mean(a) == 2.5) diff --git a/tests/test_histogram.py b/tests/test_histogram.py index 8b93366a..07da7c76 100644 --- a/tests/test_histogram.py +++ b/tests/test_histogram.py @@ -31,7 +31,7 @@ def test_histogram_3d(): print(my_histogram) - a = cle.pull(my_histogram) + a = cle.pull_zyx(my_histogram) assert (np.allclose(a, ref_histogram)) @@ -52,7 +52,7 @@ def test_histogram_3d_2(): print(my_histogram) - a = cle.pull(my_histogram) + a = cle.pull_zyx(my_histogram) assert (np.allclose(a, ref_histogram)) def test_histogram_against_scikit_image(): @@ -64,7 +64,7 @@ def test_histogram_against_scikit_image(): print(str(hist)) - gpu_image = cle.push(image) + gpu_image = cle.push_zyx(image) gpu_hist = cle.histogram(gpu_image, num_bins=256) diff --git a/tests/test_maximum_z_projection.py b/tests/test_maximum_z_projection.py index c9156db7..b8af0e2d 100644 --- a/tests/test_maximum_z_projection.py +++ b/tests/test_maximum_z_projection.py @@ -47,8 +47,8 @@ def test_maximum_z_projection(): result = cle.create(reference) cle.maximum_z_projection(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_mean_x_projection.py b/tests/test_mean_x_projection.py index c29567af..6575b077 100644 --- a/tests/test_mean_x_projection.py +++ b/tests/test_mean_x_projection.py @@ -49,8 +49,8 @@ def test_mean_x_projection(): cle.mean_x_projection(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) print(b) diff --git a/tests/test_standard_deviation_z_projection.py b/tests/test_standard_deviation_z_projection.py index c9b65a01..3f1e8158 100644 --- a/tests/test_standard_deviation_z_projection.py +++ b/tests/test_standard_deviation_z_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_standard_deviation_z_projection(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -34,21 +34,21 @@ def test_standard_deviation_z_projection(): [0, 2, 0, 8, 0], [5, 0, 6, 0, 10] ] - ])) + ]).T) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [3.94, 3.46, 4.21, 3.19, 4.27], [3.46, 3.94, 4.21, 3.19, 4.27], [3.46, 4.21, 3.19, 3.94, 4.27], [3.46, 3.94, 3.19, 4.21, 4.27], [3.94, 3.19, 4.21, 3.46, 4.27] - ])) + ]).T) result = cle.create(reference) cle.standard_deviation_z_projection(test1, result) - a = cle.pull(result) - b = cle.pull(reference) + a = cle.pull_zyx(result) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_touching_neighbor_count_map.py b/tests/test_touching_neighbor_count_map.py index dfab5279..122c7813 100644 --- a/tests/test_touching_neighbor_count_map.py +++ b/tests/test_touching_neighbor_count_map.py @@ -22,8 +22,8 @@ def test_touching_neighbor_count_map(): touching_neighbor_count_map = cle.touching_neighbor_count_map(labels) - a = cle.pull(touching_neighbor_count_map) - b = cle.pull(reference) + a = cle.pull_zyx(touching_neighbor_count_map) + b = cle.pull_zyx(reference) print(a) print(b) diff --git a/tests/test_transpose_xy.py b/tests/test_transpose_xy.py index 86bff3f3..4fbb52f1 100644 --- a/tests/test_transpose_xy.py +++ b/tests/test_transpose_xy.py @@ -57,7 +57,7 @@ def test_transpose_xy_2d_generate_output(): result = cle.transpose_xy(test1) - a = cle.pull(result) + a = cle.pull_zyx(result) print(a) diff --git a/tests/test_undefined_to_zero.py b/tests/test_undefined_to_zero.py index 657aaca7..f89e5239 100644 --- a/tests/test_undefined_to_zero.py +++ b/tests/test_undefined_to_zero.py @@ -3,7 +3,7 @@ def test_undefined_to_zero(): - test1 = cle.push(np.asarray([ + test1 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 0, 0], [0, 1, 1, 0, 0], @@ -11,7 +11,7 @@ def test_undefined_to_zero(): [0, 0, 0, 0, 0] ])) - test2 = cle.push(np.asarray([ + test2 = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], [0, 0, 1, 1, 0], @@ -19,7 +19,7 @@ def test_undefined_to_zero(): [0, 0, 0, 0, 0] ])) - reference = cle.push(np.asarray([ + reference = cle.push_zyx(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 1, 0, 0], @@ -35,8 +35,8 @@ def test_undefined_to_zero(): print(divided_no_nan) - a = cle.pull(divided_no_nan) - b = cle.pull(reference) + a = cle.pull_zyx(divided_no_nan) + b = cle.pull_zyx(reference) print(a) diff --git a/tests/test_voronoi_labeling.py b/tests/test_voronoi_labeling.py index d3fa2497..622d71f9 100644 --- a/tests/test_voronoi_labeling.py +++ b/tests/test_voronoi_labeling.py @@ -3,7 +3,7 @@ def test_voronoi_labeling(): - gpu_input = cle.push(np.asarray([ + gpu_input = cle.push_zyx(np.asarray([ [ [0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0], @@ -14,14 +14,14 @@ def test_voronoi_labeling(): ] ])) - gpu_reference = cle.push(np.asarray([ + gpu_reference = cle.push_zyx(np.asarray([ [ - [1, 1, 1, 2, 2, 2], - [1, 1, 1, 2, 2, 2], - [1, 1, 1, 2, 2, 2], - [3, 3, 3, 4, 4, 4], - [3, 3, 3, 4, 4, 4], - [3, 3, 3, 4, 4, 4], + [1, 1, 1, 3, 3, 3], + [1, 1, 1, 3, 3, 3], + [1, 1, 1, 3, 3, 3], + [2, 2, 2, 4, 4, 4], + [2, 2, 2, 4, 4, 4], + [2, 2, 2, 4, 4, 4], ] ])) From af73012a0bcfb365d04a25469592e84d8731e7be Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 19:54:53 +0100 Subject: [PATCH 24/27] DONE: replace push and pull by push_zyx and pull_zyx --- README.md | 4 ++-- demo/basics/count_blobs.py | 4 ++-- pyclesperanto_prototype/_tier0/_push.py | 2 +- .../_tier1/_write_values_to_positions.py | 4 ++-- pyclesperanto_prototype/_tier2/_maximum_of_all_pixels.py | 4 ++-- pyclesperanto_prototype/_tier2/_minimum_of_all_pixels.py | 4 ++-- .../_tier2/_minimum_of_masked_pixels.py | 4 ++-- pyclesperanto_prototype/_tier2/_sum_of_all_pixels.py | 4 ++-- .../_tier4/_connected_components_labeling_box.py | 8 ++++---- .../_tier4/_extend_labeling_via_voronoi.py | 8 ++++---- .../_tier4/_extend_labels_with_maximum_radius.py | 8 ++++---- 11 files changed, 27 insertions(+), 27 deletions(-) diff --git a/README.md b/README.md index 8d082b07..856cb82b 100644 --- a/README.md +++ b/README.md @@ -53,7 +53,7 @@ image = imread('https://imagej.nih.gov/ij/images/blobs.gif') print("Loaded image size: " + str(image.shape)) # push image to GPU memory -input = cle.push(image) +input = cle.push_zyx(image) print("Image size in GPU: " + str(input.shape)) # process the image @@ -72,7 +72,7 @@ print("Num objects in the image: " + str(num_labels)) print(labeled) # for debugging: save image to disc -imsave("result.tif", cle.pull(labeled)) +imsave("result.tif", cle.pull_zyx(labeled)) ``` ## Example gallery diff --git a/demo/basics/count_blobs.py b/demo/basics/count_blobs.py index 11162ad9..bd469ff8 100644 --- a/demo/basics/count_blobs.py +++ b/demo/basics/count_blobs.py @@ -11,7 +11,7 @@ print("Loaded image size: " + str(image.shape)) # push image to GPU memory -input = cle.push(image) +input = cle.push_zyx(image) print("Image size in GPU: " + str(input.shape)) # process the image @@ -30,4 +30,4 @@ print(labeled) # for debugging: save image to disc -imsave("result.tif", cle.pull(labeled)) +imsave("result.tif", cle.pull_zyx(labeled)) diff --git a/pyclesperanto_prototype/_tier0/_push.py b/pyclesperanto_prototype/_tier0/_push.py index 2878e0a2..062e9154 100644 --- a/pyclesperanto_prototype/_tier0/_push.py +++ b/pyclesperanto_prototype/_tier0/_push.py @@ -20,7 +20,7 @@ def push(any_array): Examples -------- >>> import pyclesperanto_prototype as cle - >>> cle.push(image) + >>> cle.push_zyx(image) References ---------- diff --git a/pyclesperanto_prototype/_tier1/_write_values_to_positions.py b/pyclesperanto_prototype/_tier1/_write_values_to_positions.py index 19039815..6c3be79a 100644 --- a/pyclesperanto_prototype/_tier1/_write_values_to_positions.py +++ b/pyclesperanto_prototype/_tier1/_write_values_to_positions.py @@ -4,7 +4,7 @@ from .._tier0 import create from .._tier0 import create_none from .._tier1 import maximum_x_projection -from .._tier0 import pull +from .._tier0 import pull_zyx @plugin_function(output_creator=create_none) def write_values_to_positions(positions_and_values : Image, destination : Image = None): @@ -28,7 +28,7 @@ def write_values_to_positions(positions_and_values : Image, destination : Image """ if destination is None: - max_pos = pull(maximum_x_projection(positions_and_values)).astype(int) + max_pos = pull_zyx(maximum_x_projection(positions_and_values)).T.astype(int) max_pos = max_pos[0] if len(max_pos) == 4: # 3D image requested diff --git a/pyclesperanto_prototype/_tier2/_maximum_of_all_pixels.py b/pyclesperanto_prototype/_tier2/_maximum_of_all_pixels.py index afd644f1..4eadd09e 100644 --- a/pyclesperanto_prototype/_tier2/_maximum_of_all_pixels.py +++ b/pyclesperanto_prototype/_tier2/_maximum_of_all_pixels.py @@ -1,5 +1,5 @@ from .._tier0 import create -from .._tier0 import pull +from .._tier0 import pull_zyx from .._tier0 import plugin_function from .._tier0 import Image @@ -53,5 +53,5 @@ def maximum_of_all_pixels(source : Image): maximum_x_projection(source, temp) - return pull(temp)[0][0] + return pull_zyx(temp)[0][0] diff --git a/pyclesperanto_prototype/_tier2/_minimum_of_all_pixels.py b/pyclesperanto_prototype/_tier2/_minimum_of_all_pixels.py index 06166517..0a38c204 100644 --- a/pyclesperanto_prototype/_tier2/_minimum_of_all_pixels.py +++ b/pyclesperanto_prototype/_tier2/_minimum_of_all_pixels.py @@ -1,5 +1,5 @@ from .._tier0 import create -from .._tier0 import pull +from .._tier0 import pull_zyx from .._tier0 import plugin_function from .._tier0 import Image @@ -53,5 +53,5 @@ def minimum_of_all_pixels(source : Image): minimum_x_projection(source, temp) - return pull(temp)[0][0] + return pull_zyx(temp)[0][0] diff --git a/pyclesperanto_prototype/_tier2/_minimum_of_masked_pixels.py b/pyclesperanto_prototype/_tier2/_minimum_of_masked_pixels.py index cd4c51d6..e2ca884f 100644 --- a/pyclesperanto_prototype/_tier2/_minimum_of_masked_pixels.py +++ b/pyclesperanto_prototype/_tier2/_minimum_of_masked_pixels.py @@ -5,7 +5,7 @@ from .._tier0 import execute from .._tier1 import transpose_xz from .._tier1 import transpose_yz -from .._tier0 import pull +from .._tier0 import pull_zyx from .._tier1 import copy_slice from .._tier0 import plugin_function @@ -86,5 +86,5 @@ def minimum_of_masked_pixels(source : Image, mask : Image): __minimum_of_masked_pixels_reduction(temp_input, temp_mask, reduced_image, reduced_mask) # return the single pixel value - return (pull(reduced_image)[0])[0] + return (pull_zyx(reduced_image)[0])[0] diff --git a/pyclesperanto_prototype/_tier2/_sum_of_all_pixels.py b/pyclesperanto_prototype/_tier2/_sum_of_all_pixels.py index d0bdeae4..02fca198 100644 --- a/pyclesperanto_prototype/_tier2/_sum_of_all_pixels.py +++ b/pyclesperanto_prototype/_tier2/_sum_of_all_pixels.py @@ -1,5 +1,5 @@ from .._tier0 import create -from .._tier0 import pull +from .._tier0 import pull_zyx from .._tier0 import plugin_function from .._tier0 import Image @@ -53,5 +53,5 @@ def sum_of_all_pixels(source : Image): sum_x_projection(source, temp) - return pull(temp)[0][0] + return pull_zyx(temp)[0][0] diff --git a/pyclesperanto_prototype/_tier4/_connected_components_labeling_box.py b/pyclesperanto_prototype/_tier4/_connected_components_labeling_box.py index a90e3d79..fe48d7f9 100644 --- a/pyclesperanto_prototype/_tier4/_connected_components_labeling_box.py +++ b/pyclesperanto_prototype/_tier4/_connected_components_labeling_box.py @@ -1,5 +1,5 @@ -from .._tier0 import pull -from .._tier0 import push +from .._tier0 import pull_zyx +from .._tier0 import push_zyx from .._tier0 import create_like from .._tier1 import set from .._tier1 import set_non_zero_pixels_to_pixel_index @@ -39,7 +39,7 @@ def connected_components_labeling_box(binary_input : Image, labeling_destination temp1 = create_like(labeling_destination) temp2 = create_like(labeling_destination) - flag = push(np.asarray([[[0]]])) + flag = push_zyx(np.asarray([[[0]]])) set_non_zero_pixels_to_pixel_index(binary_input, temp1) @@ -54,7 +54,7 @@ def connected_components_labeling_box(binary_input : Image, labeling_destination flagged_nonzero_minimum_filter(temp1, flag, temp2) else: flagged_nonzero_minimum_filter(temp2, flag, temp1) - flag_value = pull(flag)[0][0][0] + flag_value = pull_zyx(flag)[0][0][0] set(flag, 0) iteration_count += 1 diff --git a/pyclesperanto_prototype/_tier4/_extend_labeling_via_voronoi.py b/pyclesperanto_prototype/_tier4/_extend_labeling_via_voronoi.py index 7f240132..ba8a2457 100644 --- a/pyclesperanto_prototype/_tier4/_extend_labeling_via_voronoi.py +++ b/pyclesperanto_prototype/_tier4/_extend_labeling_via_voronoi.py @@ -1,7 +1,7 @@ from .._tier0 import Image from .._tier0 import plugin_function -from .._tier0 import push -from .._tier0 import pull +from .._tier0 import push_zyx +from .._tier0 import pull_zyx from .._tier0 import create_like from .._tier1 import copy from .._tier1 import set @@ -37,7 +37,7 @@ def extend_labeling_via_voronoi(labeling_source : Image, labeling_destination : flip = create_like(labeling_destination) flop = create_like(labeling_destination) - flag = push(np.asarray([[[0]]])) + flag = push_zyx(np.asarray([[[0]]])) flag_value = 1 copy(labeling_source, flip) @@ -49,7 +49,7 @@ def extend_labeling_via_voronoi(labeling_source : Image, labeling_destination : onlyzero_overwrite_maximum_box(flip, flag, flop) else: onlyzero_overwrite_maximum_diamond(flop, flag, flip) - flag_value = pull(flag)[0][0][0] + flag_value = pull_zyx(flag)[0][0][0] set(flag, 0) iteration_count += 1 diff --git a/pyclesperanto_prototype/_tier4/_extend_labels_with_maximum_radius.py b/pyclesperanto_prototype/_tier4/_extend_labels_with_maximum_radius.py index 53fa2c30..df36b894 100644 --- a/pyclesperanto_prototype/_tier4/_extend_labels_with_maximum_radius.py +++ b/pyclesperanto_prototype/_tier4/_extend_labels_with_maximum_radius.py @@ -1,7 +1,7 @@ from .._tier0 import Image from .._tier0 import plugin_function -from .._tier0 import push -from .._tier0 import pull +from .._tier0 import push_zyx +from .._tier0 import pull_zyx from .._tier0 import create_like from .._tier1 import copy from .._tier1 import set @@ -14,7 +14,7 @@ def extend_labels_with_maximum_radius(labeling_source : Image, labeling_destinat flip = create_like(labeling_destination) flop = create_like(labeling_destination) - flag = push(np.asarray([[[0]]])) + flag = push_zyx(np.asarray([[[0]]])) flag_value = 1 copy(labeling_source, flip) @@ -26,7 +26,7 @@ def extend_labels_with_maximum_radius(labeling_source : Image, labeling_destinat onlyzero_overwrite_maximum_box(flip, flag, flop) else: onlyzero_overwrite_maximum_diamond(flop, flag, flip) - flag_value = pull(flag)[0][0][0] + flag_value = pull_zyx(flag)[0][0][0] set(flag, 0) iteration_count += 1 From 269922d9c23623c180f80c6ba68d890e7078e327 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 20:05:04 +0100 Subject: [PATCH 25/27] replaced push_zyx calls with push replaced pull_zyx calls with pull --- README.md | 4 +- demo/basics/count_blobs.py | 4 +- demo/napari_gui/napari_.py | 4 +- demo/napari_gui/napari_magicgui.py | 4 +- demo/tribolium_morphometry/tribolium.py | 4 +- pyclesperanto_prototype/_tier0/__init__.py | 4 +- pyclesperanto_prototype/_tier0/_create.py | 4 +- .../_tier0/_plugin_function.py | 4 +- pyclesperanto_prototype/_tier0/_pull.py | 16 +++---- pyclesperanto_prototype/_tier0/_push.py | 16 +++---- .../_downsample_slice_by_slice_half_median.py | 1 - pyclesperanto_prototype/_tier1/_resample.py | 3 +- .../_tier1/_write_values_to_positions.py | 4 +- .../_tier2/_maximum_of_all_pixels.py | 4 +- .../_tier2/_minimum_of_all_pixels.py | 4 +- .../_tier2/_minimum_of_masked_pixels.py | 4 +- .../_tier2/_sum_of_all_pixels.py | 4 +- .../_tier3/_exclude_labels.py | 8 ++-- .../_tier3/_exclude_labels_on_edges.py | 10 ++-- .../_exclude_labels_outside_size_range.py | 5 -- ...exclude_labels_with_values_out_of_range.py | 5 -- pyclesperanto_prototype/_tier3/_histogram.py | 1 - .../_connected_components_labeling_box.py | 8 ++-- .../_tier4/_extend_labeling_via_voronoi.py | 8 ++-- .../_extend_labels_with_maximum_radius.py | 8 ++-- .../_tier8/_affine_transform.py | 4 +- .../_tier9/_artificial_tissue_2d.py | 4 +- .../_centroids_of_background_and_labels.py | 3 -- .../_tier9/_centroids_of_labels.py | 1 - pyclesperanto_prototype/_tier9/_imread.py | 4 +- pyclesperanto_prototype/_tier9/_imshow.py | 4 +- .../_tier9/_label_maximum_extension_map.py | 2 +- .../_label_maximum_extension_ratio_map.py | 2 +- .../_tier9/_label_maximum_intensity_map.py | 2 +- .../_tier9/_label_mean_extension_map.py | 2 +- .../_tier9/_label_mean_intensity_map.py | 2 +- .../_tier9/_label_minimum_intensity_map.py | 2 +- .../_tier9/_label_pixel_count_map.py | 2 +- ..._label_standard_deviation_intensity_map.py | 2 +- .../_tier9/_push_regionprops.py | 4 +- .../_tier9/_push_regionprops_column.py | 6 +-- .../_tier9/_regionprops.py | 6 +-- ...stics_of_background_and_labelled_pixels.py | 2 +- .../_tier9/_statistics_of_labelled_pixels.py | 46 +++++++++---------- .../_tier9/_threshold_otsu.py | 4 +- tests/test_absolute.py | 8 ++-- tests/test_absolute_difference.py | 2 +- tests/test_add_image_and_scalar.py | 2 +- tests/test_add_images.py | 10 ++-- tests/test_add_images_weighted.py | 10 ++-- tests/test_affine_transform.py | 40 ++++++++-------- ...average_distance_of_n_far_off_distances.py | 8 ++-- ...verage_distance_of_n_shortest_distances.py | 8 ++-- ..._average_distance_of_touching_neighbors.py | 8 ++-- tests/test_binary_and.py | 12 ++--- tests/test_binary_edge_detection.py | 4 +- tests/test_binary_not.py | 4 +- tests/test_binary_or.py | 6 +-- tests/test_binary_subtract.py | 6 +-- tests/test_binary_xor.py | 6 +-- tests/test_block_enumerate.py | 4 +- tests/test_bottom_hat_box.py | 4 +- tests/test_bottom_hat_sphere.py | 4 +- tests/test_bounding_box.py | 4 +- tests/test_center_of_mass.py | 2 +- tests/test_centroids_of_labels.py | 16 +++---- tests/test_close_index_gaps_in_label_maps.py | 8 ++-- tests/test_combine_horizontally.py | 10 ++-- tests/test_combine_vertically.py | 10 ++-- tests/test_concatenate_stacks.py | 10 ++-- .../test_connected_components_labeling_box.py | 10 ++-- ...t_connected_components_labeling_diamond.py | 8 ++-- tests/test_convolve.py | 8 ++-- tests/test_copy.py | 4 +- tests/test_copy_slice.py | 24 +++++----- tests/test_count_touching_neighbors.py | 8 ++-- tests/test_crop.py | 8 ++-- tests/test_degrees_to_radians.py | 8 ++-- tests/test_detect_label_edges.py | 8 ++-- tests/test_detect_maxima_box.py | 8 ++-- tests/test_detect_minima_box.py | 8 ++-- tests/test_difference_of_gaussian.py | 4 +- tests/test_dilate_box.py | 8 ++-- tests/test_dilate_box_slice_by_slice.py | 8 ++-- tests/test_dilate_sphere.py | 8 ++-- tests/test_dilate_sphere_slice_by_slice.py | 8 ++-- tests/test_divide_images.py | 10 ++-- tests/test_downsample_xy_half_median.py | 16 +++---- tests/test_draw_box.py | 6 +-- tests/test_draw_line.py | 6 +-- tests/test_draw_sphere.py | 6 +-- tests/test_equal.py | 10 ++-- tests/test_equal_constant.py | 8 ++-- tests/test_erode_box.py | 8 ++-- tests/test_erode_box_slice_by_slice.py | 8 ++-- tests/test_erode_sphere.py | 8 ++-- tests/test_erode_sphere_slice_by_slice.py | 8 ++-- ...lidean_distance_from_label_centroid_map.py | 8 ++-- tests/test_exclude_labels.py | 20 ++++---- tests/test_exclude_labels_on_edges.py | 18 ++++---- .../test_exclude_labels_out_of_size_range.py | 8 ++-- ...exclude_labels_with_values_out_of_range.py | 8 ++-- ...exclude_labels_with_values_within_range.py | 8 ++-- tests/test_exponential.py | 8 ++-- tests/test_extend_labeling_via_voronoi.py | 8 ++-- .../test_extend_labels_with_maximum_radius.py | 16 +++---- tests/test_flag_existing_labels.py | 8 ++-- tests/test_flip.py | 8 ++-- tests/test_gamma_correction.py | 4 +- tests/test_gaussian_blur.py | 4 +- tests/test_generate_angle_matrix.py | 8 ++-- tests/test_generate_binary_overlap_matrix.py | 20 ++++---- tests/test_generate_distance_matrix.py | 8 ++-- ...test_generate_n_nearest_neighbor_matrix.py | 8 ++-- .../test_generate_proximal_neighbor_matrix.py | 16 +++---- tests/test_generate_touch_matrix.py | 8 ++-- tests/test_gradient_x.py | 8 ++-- tests/test_gradient_y.py | 8 ++-- tests/test_gradient_z.py | 8 ++-- tests/test_greater.py | 20 ++++---- tests/test_greater_constant.py | 8 ++-- tests/test_greater_or_equal.py | 20 ++++---- tests/test_greater_or_equal_constant.py | 8 ++-- tests/test_histogram.py | 18 ++++---- tests/test_invert.py | 8 ++-- tests/test_jaccard_index.py | 8 ++-- tests/test_label_maximum_extension_map.py | 16 +++---- .../test_label_maximum_extension_ratio_map.py | 16 +++---- tests/test_label_maximum_intensity_map.py | 20 ++++---- tests/test_label_mean_extension_map.py | 16 +++---- tests/test_label_mean_intensity_map.py | 20 ++++---- tests/test_label_minimum_intensity_map.py | 20 ++++---- tests/test_label_pixelcount_map.py | 16 +++---- tests/test_label_spots.py | 16 +++---- ..._label_standard_deviation_intensity_map.py | 20 ++++---- tests/test_labelled_spots_to_pointlist.py | 8 ++-- tests/test_laplace_box.py | 8 ++-- tests/test_laplace_diamond.py | 8 ++-- tests/test_logarithm.py | 8 ++-- tests/test_mask.py | 10 ++-- tests/test_mask_label.py | 10 ++-- tests/test_maximum_box.py | 8 ++-- ...aximum_distance_of_n_shortest_distances.py | 8 ++-- ..._maximum_distance_of_touching_neighbors.py | 8 ++-- tests/test_maximum_image_and_scalar.py | 8 ++-- tests/test_maximum_images.py | 10 ++-- tests/test_maximum_of_all_pixels.py | 4 +- .../test_maximum_of_touching_neighbors_map.py | 10 ++-- tests/test_maximum_sphere.py | 12 ++--- tests/test_maximum_x_projection.py | 8 ++-- tests/test_maximum_y_projection.py | 8 ++-- tests/test_maximum_z_projection.py | 8 ++-- tests/test_mean_box.py | 8 ++-- tests/test_mean_of_all_pixels.py | 10 ++-- tests/test_mean_of_touching_neighbors_map.py | 10 ++-- tests/test_mean_sphere.py | 8 ++-- tests/test_mean_x_projection.py | 8 ++-- tests/test_mean_y_projection.py | 8 ++-- tests/test_mean_z_projection.py | 8 ++-- tests/test_merge_touching_labels.py | 8 ++-- tests/test_minimum_box.py | 8 ++-- ..._minimum_distance_of_touching_neighbors.py | 8 ++-- tests/test_minimum_image_and_scalar.py | 8 ++-- tests/test_minimum_images.py | 10 ++-- tests/test_minimum_of_all_pixels.py | 4 +- tests/test_minimum_of_masked_pixels.py | 12 ++--- .../test_minimum_of_touching_neighbors_map.py | 10 ++-- tests/test_minimum_x_projection.py | 8 ++-- tests/test_minimum_y_projection.py | 8 ++-- tests/test_minimum_z_projection.py | 8 ++-- tests/test_mode_of_touching_neighbors_map.py | 10 ++-- tests/test_multiply_image_and_coordinate.py | 8 ++-- tests/test_multiply_image_and_scalar.py | 8 ++-- tests/test_multiply_images.py | 10 ++-- tests/test_multiply_matrix.py | 4 +- tests/test_n_closest_points.py | 16 +++---- tests/test_nonzero_maximum_box.py | 8 ++-- tests/test_nonzero_maximum_diamond.py | 8 ++-- tests/test_nonzero_minimum_box.py | 8 ++-- tests/test_nonzero_minimum_diamond.py | 8 ++-- tests/test_not_equal.py | 10 ++-- tests/test_not_equal_constant.py | 8 ++-- tests/test_onlyzero_overwrite_maximum_box.py | 8 ++-- ...test_onlyzero_overwrite_maximum_diamond.py | 8 ++-- tests/test_paste.py | 10 ++-- tests/test_point_index_list_to_mesh.py | 10 ++-- .../test_point_index_list_to_touch_matrix.py | 10 ++-- tests/test_pointlist_to_labelled_spots.py | 16 +++---- tests/test_power.py | 8 ++-- tests/test_power_images.py | 10 ++-- tests/test_push_regionprops_column.py | 4 +- tests/test_radians_to_degrees.py | 8 ++-- tests/test_read_intensities_from_map.py | 10 ++-- tests/test_read_intensities_from_positions.py | 10 ++-- tests/test_reduce_stack.py | 16 +++---- tests/test_regionprops.py | 20 ++++---- tests/test_replace_intensities.py | 10 ++-- tests/test_replace_intensity.py | 8 ++-- tests/test_resample.py | 40 ++++++++-------- tests/test_rigid_transform.py | 8 ++-- tests/test_rotate.py | 16 +++---- tests/test_scale.py | 16 +++---- tests/test_set.py | 6 +-- tests/test_set_column.py | 8 ++-- tests/test_set_image_borders.py | 8 ++-- .../test_set_nonzero_pixels_to_pixelindex.py | 8 ++-- tests/test_set_plane.py | 8 ++-- tests/test_set_ramp_x.py | 8 ++-- tests/test_set_ramp_y.py | 8 ++-- tests/test_set_ramp_z.py | 8 ++-- tests/test_set_row.py | 8 ++-- tests/test_set_where_x_equals_y.py | 8 ++-- tests/test_set_where_x_greater_than_y.py | 8 ++-- tests/test_set_where_x_smaller_than_y.py | 8 ++-- tests/test_smaller.py | 20 ++++---- tests/test_smaller_constant.py | 8 ++-- tests/test_smaller_or_equal.py | 20 ++++---- tests/test_smaller_or_equal_constant.py | 8 ++-- tests/test_sobel.py | 8 ++-- tests/test_sorenson_dice_coefficient.py | 8 ++-- tests/test_spots_to_pointlist.py | 8 ++-- tests/test_squared_difference.py | 2 +- ...ard_deviation_of_touching_neighbors_map.py | 10 ++-- tests/test_standard_deviation_z_projection.py | 8 ++-- ...stics_of_background_and_labelled_pixels.py | 26 +++++------ tests/test_statistics_of_image.py | 2 +- tests/test_statistics_of_labelled_pixels.py | 20 ++++---- tests/test_subtract_image_from_scalar.py | 8 ++-- tests/test_subtract_images.py | 2 +- tests/test_sum_of_all_pixels.py | 10 ++-- tests/test_sum_reduction.py | 4 +- tests/test_sum_x_projection.py | 8 ++-- tests/test_sum_y_projection.py | 8 ++-- tests/test_sum_z_projection.py | 8 ++-- tests/test_threshold_otsu.py | 6 +-- tests/test_top_hat_box.py | 4 +- tests/test_top_hat_sphere.py | 4 +- .../test_touch_matrix_to_adjacency_matrix.py | 8 ++-- tests/test_touch_matrix_to_mesh.py | 10 ++-- tests/test_touching_neighbor_count_map.py | 8 ++-- tests/test_translate.py | 8 ++-- tests/test_transpose_xy.py | 20 ++++---- tests/test_transpose_xz.py | 20 ++++---- tests/test_transpose_yz.py | 20 ++++---- tests/test_undefined_to_zero.py | 10 ++-- tests/test_voronoi_labeling.py | 8 ++-- tests/test_write_values_to_positions.py | 16 +++---- 247 files changed, 1106 insertions(+), 1125 deletions(-) diff --git a/README.md b/README.md index 856cb82b..8d082b07 100644 --- a/README.md +++ b/README.md @@ -53,7 +53,7 @@ image = imread('https://imagej.nih.gov/ij/images/blobs.gif') print("Loaded image size: " + str(image.shape)) # push image to GPU memory -input = cle.push_zyx(image) +input = cle.push(image) print("Image size in GPU: " + str(input.shape)) # process the image @@ -72,7 +72,7 @@ print("Num objects in the image: " + str(num_labels)) print(labeled) # for debugging: save image to disc -imsave("result.tif", cle.pull_zyx(labeled)) +imsave("result.tif", cle.pull(labeled)) ``` ## Example gallery diff --git a/demo/basics/count_blobs.py b/demo/basics/count_blobs.py index bd469ff8..11162ad9 100644 --- a/demo/basics/count_blobs.py +++ b/demo/basics/count_blobs.py @@ -11,7 +11,7 @@ print("Loaded image size: " + str(image.shape)) # push image to GPU memory -input = cle.push_zyx(image) +input = cle.push(image) print("Image size in GPU: " + str(input.shape)) # process the image @@ -30,4 +30,4 @@ print(labeled) # for debugging: save image to disc -imsave("result.tif", cle.pull_zyx(labeled)) +imsave("result.tif", cle.pull(labeled)) diff --git a/demo/napari_gui/napari_.py b/demo/napari_gui/napari_.py index b0d70fcb..ad4060a9 100644 --- a/demo/napari_gui/napari_.py +++ b/demo/napari_gui/napari_.py @@ -11,7 +11,7 @@ viewer.add_image(image, name='blobs') # push image to GPU - input = cle.push_zyx(image) + input = cle.push(image) # process the image sigma = 1 @@ -20,7 +20,7 @@ labels = cle.connected_components_labeling_box(binary) # pull result back - output = cle.pull_zyx(labels) + output = cle.pull(labels) # add it to napari viewer.add_labels(output) diff --git a/demo/napari_gui/napari_magicgui.py b/demo/napari_gui/napari_magicgui.py index 182b6827..07301e38 100644 --- a/demo/napari_gui/napari_magicgui.py +++ b/demo/napari_gui/napari_magicgui.py @@ -9,7 +9,7 @@ def process_image(input: Image, sigma: float = 5) -> Labels: if input: # push image to GPU - input = cle.push_zyx(input.data) + input = cle.push(input.data) # process the image blurred = cle.gaussian_blur(input, sigma_x=sigma, sigma_y=sigma) @@ -17,7 +17,7 @@ def process_image(input: Image, sigma: float = 5) -> Labels: labels = cle.connected_components_labeling_box(binary) # pull result back - output = cle.pull_zyx(labels) + output = cle.pull(labels) return output # load data diff --git a/demo/tribolium_morphometry/tribolium.py b/demo/tribolium_morphometry/tribolium.py index b63444fd..84400293 100644 --- a/demo/tribolium_morphometry/tribolium.py +++ b/demo/tribolium_morphometry/tribolium.py @@ -36,7 +36,7 @@ def workflow(input: Image, sigma=3, threshold : float = 30) -> Labels: if input: # push image to GPU memory and show it - gpu_input = cle.push_zyx(input.data) + gpu_input = cle.push(input.data) # Spot detection # After some noise removal/smoothing, we perform a local maximum detection @@ -86,7 +86,7 @@ def workflow(input: Image, sigma=3, threshold : float = 30) -> Labels: gpu_labels = cle.mask(flip, flap) - output = cle.pull_zyx(gpu_labels) + output = cle.pull(gpu_labels) return output # Start up napari diff --git a/pyclesperanto_prototype/_tier0/__init__.py b/pyclesperanto_prototype/_tier0/__init__.py index dd5ec4d1..0d037c59 100644 --- a/pyclesperanto_prototype/_tier0/__init__.py +++ b/pyclesperanto_prototype/_tier0/__init__.py @@ -22,10 +22,10 @@ from ._execute import execute from ._operations import operation from ._operations import operations -from ._pull import pull from ._pull import pull_zyx -from ._push import push +from ._pull import pull from ._push import push_zyx +from ._push import push from ._plugin_function import plugin_function from ._types import Image from ._cl_info import cl_info diff --git a/pyclesperanto_prototype/_tier0/_create.py b/pyclesperanto_prototype/_tier0/_create.py index e6eea203..f233e204 100644 --- a/pyclesperanto_prototype/_tier0/_create.py +++ b/pyclesperanto_prototype/_tier0/_create.py @@ -52,9 +52,9 @@ def create_matrix_from_pointlists(pointlist1:OCLArray, pointlist2:OCLArray): def create_from_pointlist(pointlist: OCLArray, *args): from .._tier1 import maximum_x_projection - from .._tier0 import pull_zyx + from .._tier0 import pull - max_pos = pull_zyx(maximum_x_projection(pointlist)).T.astype(int) + max_pos = pull(maximum_x_projection(pointlist)).T.astype(int) max_pos = max_pos[0] if len(max_pos) == 3: # 3D image requested diff --git a/pyclesperanto_prototype/_tier0/_plugin_function.py b/pyclesperanto_prototype/_tier0/_plugin_function.py index 44f15c51..9423b0b6 100644 --- a/pyclesperanto_prototype/_tier0/_plugin_function.py +++ b/pyclesperanto_prototype/_tier0/_plugin_function.py @@ -7,7 +7,7 @@ from ._create import create_like from ._types import Image, is_image -from ._push import push_zyx +from ._push import push @curry @@ -64,7 +64,7 @@ def worker_function(*args, **kwargs): value = None if is_image(value): - value = push_zyx(value) + value = push(value) # value is now for sure OpenCL, we keep it in case we have to # create another one of the same size any_ocl_input = value diff --git a/pyclesperanto_prototype/_tier0/_pull.py b/pyclesperanto_prototype/_tier0/_pull.py index 224d4740..930e3814 100644 --- a/pyclesperanto_prototype/_tier0/_pull.py +++ b/pyclesperanto_prototype/_tier0/_pull.py @@ -16,20 +16,18 @@ def pull(oclarray): Examples -------- >>> import pyclesperanto_prototype as cle - >>> cle.pull_zyx(image) + >>> cle.pull(image) References ---------- .. [1] https://clij.github.io/clij2-docs/reference_pull """ - import warnings - warnings.warn( - "Deprecated: The behaviour of `pull()` will change in a future release. Switch to using push_zyx now to prvent issues in the future.", - DeprecationWarning - ) - - return oclarray.get().T - + return oclarray.get() def pull_zyx(oclarray): + import warnings + warnings.warn( + "Deprecated: `pull_zyx()` is now deprecated as it does the same as `pull()`.", + DeprecationWarning + ) return oclarray.get() diff --git a/pyclesperanto_prototype/_tier0/_push.py b/pyclesperanto_prototype/_tier0/_push.py index 062e9154..0871ef03 100644 --- a/pyclesperanto_prototype/_tier0/_push.py +++ b/pyclesperanto_prototype/_tier0/_push.py @@ -20,26 +20,26 @@ def push(any_array): Examples -------- >>> import pyclesperanto_prototype as cle - >>> cle.push_zyx(image) + >>> cle.push(image) References ---------- .. [1] https://clij.github.io/clij2-docs/reference_push """ - import warnings - warnings.warn( - "Deprecated: The behaviour of `push()` will change in a future release. Switch to using push_zyx now to prevent issues in the future.", - DeprecationWarning - ) - if isinstance(any_array, OCLArray): return any_array - transposed = any_array.astype(np.float32).T + transposed = any_array.astype(np.float32) return OCLArray.from_array(transposed) def push_zyx(any_array): + import warnings + warnings.warn( + "Deprecated: `push_zyx()` is now deprecated as it does the same as `push()`.", + DeprecationWarning + ) + if isinstance(any_array, OCLArray): return any_array diff --git a/pyclesperanto_prototype/_tier1/_downsample_slice_by_slice_half_median.py b/pyclesperanto_prototype/_tier1/_downsample_slice_by_slice_half_median.py index ea72de5e..d0bf8260 100644 --- a/pyclesperanto_prototype/_tier1/_downsample_slice_by_slice_half_median.py +++ b/pyclesperanto_prototype/_tier1/_downsample_slice_by_slice_half_median.py @@ -1,6 +1,5 @@ from .._tier1 import copy from .._tier0 import empty_image_like -from .._tier0 import push_zyx from .._tier0 import push from .._tier0 import execute from .._tier0 import plugin_function diff --git a/pyclesperanto_prototype/_tier1/_resample.py b/pyclesperanto_prototype/_tier1/_resample.py index 31720d9d..ad5db234 100644 --- a/pyclesperanto_prototype/_tier1/_resample.py +++ b/pyclesperanto_prototype/_tier1/_resample.py @@ -1,6 +1,5 @@ from .._tier1 import copy from .._tier0 import empty_image_like -from .._tier0 import push_zyx from .._tier0 import push from .._tier0 import execute from .._tier0 import plugin_function @@ -58,7 +57,7 @@ def resample(source : Image, destination : Image = None, factor_x : float = 1, f if destination is None: destination = create(destination_dimensions) - gpu_transform_matrix = push_zyx(transform_matrix) + gpu_transform_matrix = push(transform_matrix) kernel_suffix = '' if linear_interpolation: diff --git a/pyclesperanto_prototype/_tier1/_write_values_to_positions.py b/pyclesperanto_prototype/_tier1/_write_values_to_positions.py index 6c3be79a..79605dc4 100644 --- a/pyclesperanto_prototype/_tier1/_write_values_to_positions.py +++ b/pyclesperanto_prototype/_tier1/_write_values_to_positions.py @@ -4,7 +4,7 @@ from .._tier0 import create from .._tier0 import create_none from .._tier1 import maximum_x_projection -from .._tier0 import pull_zyx +from .._tier0 import pull @plugin_function(output_creator=create_none) def write_values_to_positions(positions_and_values : Image, destination : Image = None): @@ -28,7 +28,7 @@ def write_values_to_positions(positions_and_values : Image, destination : Image """ if destination is None: - max_pos = pull_zyx(maximum_x_projection(positions_and_values)).T.astype(int) + max_pos = pull(maximum_x_projection(positions_and_values)).T.astype(int) max_pos = max_pos[0] if len(max_pos) == 4: # 3D image requested diff --git a/pyclesperanto_prototype/_tier2/_maximum_of_all_pixels.py b/pyclesperanto_prototype/_tier2/_maximum_of_all_pixels.py index 4eadd09e..afd644f1 100644 --- a/pyclesperanto_prototype/_tier2/_maximum_of_all_pixels.py +++ b/pyclesperanto_prototype/_tier2/_maximum_of_all_pixels.py @@ -1,5 +1,5 @@ from .._tier0 import create -from .._tier0 import pull_zyx +from .._tier0 import pull from .._tier0 import plugin_function from .._tier0 import Image @@ -53,5 +53,5 @@ def maximum_of_all_pixels(source : Image): maximum_x_projection(source, temp) - return pull_zyx(temp)[0][0] + return pull(temp)[0][0] diff --git a/pyclesperanto_prototype/_tier2/_minimum_of_all_pixels.py b/pyclesperanto_prototype/_tier2/_minimum_of_all_pixels.py index 0a38c204..06166517 100644 --- a/pyclesperanto_prototype/_tier2/_minimum_of_all_pixels.py +++ b/pyclesperanto_prototype/_tier2/_minimum_of_all_pixels.py @@ -1,5 +1,5 @@ from .._tier0 import create -from .._tier0 import pull_zyx +from .._tier0 import pull from .._tier0 import plugin_function from .._tier0 import Image @@ -53,5 +53,5 @@ def minimum_of_all_pixels(source : Image): minimum_x_projection(source, temp) - return pull_zyx(temp)[0][0] + return pull(temp)[0][0] diff --git a/pyclesperanto_prototype/_tier2/_minimum_of_masked_pixels.py b/pyclesperanto_prototype/_tier2/_minimum_of_masked_pixels.py index e2ca884f..cd4c51d6 100644 --- a/pyclesperanto_prototype/_tier2/_minimum_of_masked_pixels.py +++ b/pyclesperanto_prototype/_tier2/_minimum_of_masked_pixels.py @@ -5,7 +5,7 @@ from .._tier0 import execute from .._tier1 import transpose_xz from .._tier1 import transpose_yz -from .._tier0 import pull_zyx +from .._tier0 import pull from .._tier1 import copy_slice from .._tier0 import plugin_function @@ -86,5 +86,5 @@ def minimum_of_masked_pixels(source : Image, mask : Image): __minimum_of_masked_pixels_reduction(temp_input, temp_mask, reduced_image, reduced_mask) # return the single pixel value - return (pull_zyx(reduced_image)[0])[0] + return (pull(reduced_image)[0])[0] diff --git a/pyclesperanto_prototype/_tier2/_sum_of_all_pixels.py b/pyclesperanto_prototype/_tier2/_sum_of_all_pixels.py index 02fca198..d0bdeae4 100644 --- a/pyclesperanto_prototype/_tier2/_sum_of_all_pixels.py +++ b/pyclesperanto_prototype/_tier2/_sum_of_all_pixels.py @@ -1,5 +1,5 @@ from .._tier0 import create -from .._tier0 import pull_zyx +from .._tier0 import pull from .._tier0 import plugin_function from .._tier0 import Image @@ -53,5 +53,5 @@ def sum_of_all_pixels(source : Image): sum_x_projection(source, temp) - return pull_zyx(temp)[0][0] + return pull(temp)[0][0] diff --git a/pyclesperanto_prototype/_tier3/_exclude_labels.py b/pyclesperanto_prototype/_tier3/_exclude_labels.py index fbf35798..0b2e2e79 100644 --- a/pyclesperanto_prototype/_tier3/_exclude_labels.py +++ b/pyclesperanto_prototype/_tier3/_exclude_labels.py @@ -1,7 +1,7 @@ from pyclesperanto_prototype._tier0 import plugin_function from pyclesperanto_prototype._tier0 import Image -from .._tier0 import push_zyx -from .._tier0 import pull_zyx +from .._tier0 import push +from .._tier0 import pull from .._tier0 import create_none from .._tier0 import create_like from .._tier1 import replace_intensities @@ -38,7 +38,7 @@ def exclude_labels(binary_flaglist : Image, label_map_input : Image, label_map_d num_labels = int(binary_flaglist.shape[-1]) - flaglist_np = pull_zyx(binary_flaglist) + flaglist_np = pull(binary_flaglist) flaglist_np[0][0] = 0 @@ -50,7 +50,7 @@ def exclude_labels(binary_flaglist : Image, label_map_input : Image, label_map_d else: flaglist_np[0][i] = 0 - label_index_map = push_zyx(flaglist_np) + label_index_map = push(flaglist_np) replace_intensities(label_map_input, label_index_map, label_map_destination) diff --git a/pyclesperanto_prototype/_tier3/_exclude_labels_on_edges.py b/pyclesperanto_prototype/_tier3/_exclude_labels_on_edges.py index b7ad8b9c..e5b1b5ab 100644 --- a/pyclesperanto_prototype/_tier3/_exclude_labels_on_edges.py +++ b/pyclesperanto_prototype/_tier3/_exclude_labels_on_edges.py @@ -1,8 +1,8 @@ from pyclesperanto_prototype._tier0 import execute from pyclesperanto_prototype._tier0 import plugin_function from pyclesperanto_prototype._tier0 import Image -from .._tier0 import pull_zyx -from .._tier0 import push_zyx +from .._tier0 import pull +from .._tier0 import push from .._tier2 import maximum_of_all_pixels from .._tier1 import replace_intensities from .._tier0 import create_like @@ -37,7 +37,7 @@ def exclude_labels_on_edges(label_map_input : Image, label_map_destination : Ima label_indices = range(0, num_labels + 1) - label_index_map = push_zyx(np.asarray(label_indices)) + label_index_map = push(np.asarray(label_indices)) parameters = { "src":label_map_input, @@ -68,14 +68,14 @@ def exclude_labels_on_edges(label_map_input : Image, label_map_destination : Ima - label_indices = pull_zyx(label_index_map) + label_indices = pull(label_index_map) count = 1 for i in range(1, num_labels + 1): if (label_indices[i] > 0): label_indices[i] = count count = count + 1 - label_index_map = push_zyx(np.asarray(label_indices)) + label_index_map = push(np.asarray(label_indices)) replace_intensities(label_map_input, label_index_map, label_map_destination) diff --git a/pyclesperanto_prototype/_tier3/_exclude_labels_outside_size_range.py b/pyclesperanto_prototype/_tier3/_exclude_labels_outside_size_range.py index b76254d7..6bfe1d33 100644 --- a/pyclesperanto_prototype/_tier3/_exclude_labels_outside_size_range.py +++ b/pyclesperanto_prototype/_tier3/_exclude_labels_outside_size_range.py @@ -1,13 +1,8 @@ from .._tier0 import plugin_function from .._tier0 import Image from .. import smaller_constant, greater_constant, binary_or -from .._tier0 import push -from .._tier0 import push_zyx -from .._tier0 import pull from .._tier0 import create_none from .._tier0 import create_like -from .._tier1 import replace_intensities -import numpy as np @plugin_function(output_creator=create_none, categories=['label processing', 'in assistant']) def exclude_labels_outside_size_range(input : Image, destination : Image = None, minimum_size : float = 0, maximum_size : float = 100): diff --git a/pyclesperanto_prototype/_tier3/_exclude_labels_with_values_out_of_range.py b/pyclesperanto_prototype/_tier3/_exclude_labels_with_values_out_of_range.py index 8aed43cd..00e8bafb 100644 --- a/pyclesperanto_prototype/_tier3/_exclude_labels_with_values_out_of_range.py +++ b/pyclesperanto_prototype/_tier3/_exclude_labels_with_values_out_of_range.py @@ -1,13 +1,8 @@ from .._tier0 import plugin_function from .._tier0 import Image from .. import smaller_constant, greater_constant, binary_or -from .._tier0 import push -from .._tier0 import push_zyx -from .._tier0 import pull from .._tier0 import create_none from .._tier0 import create_like -from .._tier1 import replace_intensities -import numpy as np @plugin_function(output_creator=create_none, categories=['label processing']) def exclude_labels_with_values_out_of_range(values_vector : Image, label_map_input : Image, label_map_destination : Image = None, minimum_value_range : float = 0, maximum_value_range : float = 100): diff --git a/pyclesperanto_prototype/_tier3/_histogram.py b/pyclesperanto_prototype/_tier3/_histogram.py index 4dd6afb6..1f7fbca9 100644 --- a/pyclesperanto_prototype/_tier3/_histogram.py +++ b/pyclesperanto_prototype/_tier3/_histogram.py @@ -15,7 +15,6 @@ from .._tier0 import execute from .._tier0 import create from .._tier0 import create_none -from .._tier0 import pull from .._tier0 import plugin_function from .._tier0 import Image from .._tier2 import minimum_of_all_pixels diff --git a/pyclesperanto_prototype/_tier4/_connected_components_labeling_box.py b/pyclesperanto_prototype/_tier4/_connected_components_labeling_box.py index fe48d7f9..a90e3d79 100644 --- a/pyclesperanto_prototype/_tier4/_connected_components_labeling_box.py +++ b/pyclesperanto_prototype/_tier4/_connected_components_labeling_box.py @@ -1,5 +1,5 @@ -from .._tier0 import pull_zyx -from .._tier0 import push_zyx +from .._tier0 import pull +from .._tier0 import push from .._tier0 import create_like from .._tier1 import set from .._tier1 import set_non_zero_pixels_to_pixel_index @@ -39,7 +39,7 @@ def connected_components_labeling_box(binary_input : Image, labeling_destination temp1 = create_like(labeling_destination) temp2 = create_like(labeling_destination) - flag = push_zyx(np.asarray([[[0]]])) + flag = push(np.asarray([[[0]]])) set_non_zero_pixels_to_pixel_index(binary_input, temp1) @@ -54,7 +54,7 @@ def connected_components_labeling_box(binary_input : Image, labeling_destination flagged_nonzero_minimum_filter(temp1, flag, temp2) else: flagged_nonzero_minimum_filter(temp2, flag, temp1) - flag_value = pull_zyx(flag)[0][0][0] + flag_value = pull(flag)[0][0][0] set(flag, 0) iteration_count += 1 diff --git a/pyclesperanto_prototype/_tier4/_extend_labeling_via_voronoi.py b/pyclesperanto_prototype/_tier4/_extend_labeling_via_voronoi.py index ba8a2457..7f240132 100644 --- a/pyclesperanto_prototype/_tier4/_extend_labeling_via_voronoi.py +++ b/pyclesperanto_prototype/_tier4/_extend_labeling_via_voronoi.py @@ -1,7 +1,7 @@ from .._tier0 import Image from .._tier0 import plugin_function -from .._tier0 import push_zyx -from .._tier0 import pull_zyx +from .._tier0 import push +from .._tier0 import pull from .._tier0 import create_like from .._tier1 import copy from .._tier1 import set @@ -37,7 +37,7 @@ def extend_labeling_via_voronoi(labeling_source : Image, labeling_destination : flip = create_like(labeling_destination) flop = create_like(labeling_destination) - flag = push_zyx(np.asarray([[[0]]])) + flag = push(np.asarray([[[0]]])) flag_value = 1 copy(labeling_source, flip) @@ -49,7 +49,7 @@ def extend_labeling_via_voronoi(labeling_source : Image, labeling_destination : onlyzero_overwrite_maximum_box(flip, flag, flop) else: onlyzero_overwrite_maximum_diamond(flop, flag, flip) - flag_value = pull_zyx(flag)[0][0][0] + flag_value = pull(flag)[0][0][0] set(flag, 0) iteration_count += 1 diff --git a/pyclesperanto_prototype/_tier4/_extend_labels_with_maximum_radius.py b/pyclesperanto_prototype/_tier4/_extend_labels_with_maximum_radius.py index df36b894..53fa2c30 100644 --- a/pyclesperanto_prototype/_tier4/_extend_labels_with_maximum_radius.py +++ b/pyclesperanto_prototype/_tier4/_extend_labels_with_maximum_radius.py @@ -1,7 +1,7 @@ from .._tier0 import Image from .._tier0 import plugin_function -from .._tier0 import push_zyx -from .._tier0 import pull_zyx +from .._tier0 import push +from .._tier0 import pull from .._tier0 import create_like from .._tier1 import copy from .._tier1 import set @@ -14,7 +14,7 @@ def extend_labels_with_maximum_radius(labeling_source : Image, labeling_destinat flip = create_like(labeling_destination) flop = create_like(labeling_destination) - flag = push_zyx(np.asarray([[[0]]])) + flag = push(np.asarray([[[0]]])) flag_value = 1 copy(labeling_source, flip) @@ -26,7 +26,7 @@ def extend_labels_with_maximum_radius(labeling_source : Image, labeling_destinat onlyzero_overwrite_maximum_box(flip, flag, flop) else: onlyzero_overwrite_maximum_diamond(flop, flag, flip) - flag_value = pull_zyx(flag)[0][0][0] + flag_value = pull(flag)[0][0][0] set(flag, 0) iteration_count += 1 diff --git a/pyclesperanto_prototype/_tier8/_affine_transform.py b/pyclesperanto_prototype/_tier8/_affine_transform.py index 3f0a34e6..f76f1fc3 100644 --- a/pyclesperanto_prototype/_tier8/_affine_transform.py +++ b/pyclesperanto_prototype/_tier8/_affine_transform.py @@ -2,7 +2,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -from .._tier0 import push_zyx +from .._tier0 import push from ._AffineTransform3D import AffineTransform3D from skimage.transform import AffineTransform import numpy as np @@ -64,7 +64,7 @@ def affine_transform(source : Image, destination : Image = None, transform : Uni else: transform_matrix = np.linalg.inv(transform) - gpu_transform_matrix = push_zyx(transform_matrix) + gpu_transform_matrix = push(transform_matrix) kernel_suffix = '' if linear_interpolation: diff --git a/pyclesperanto_prototype/_tier9/_artificial_tissue_2d.py b/pyclesperanto_prototype/_tier9/_artificial_tissue_2d.py index 91355cec..62c7233d 100644 --- a/pyclesperanto_prototype/_tier9/_artificial_tissue_2d.py +++ b/pyclesperanto_prototype/_tier9/_artificial_tissue_2d.py @@ -15,7 +15,7 @@ def artificial_tissue_2d(width: int = 256, height: int = 256, delta_x=24, delta_ ------- """ - from .._tier0 import push_zyx + from .._tier0 import push from .._tier2 import pointlist_to_labelled_spots from .._tier4 import extend_labeling_via_voronoi import numpy as np @@ -51,7 +51,7 @@ def artificial_tissue_2d(width: int = 256, height: int = 256, delta_x=24, delta_ all_y_coords[i] = height # define centroids of cells - pointlist = push_zyx(np.asarray( + pointlist = push(np.asarray( [ all_x_coords, all_y_coords diff --git a/pyclesperanto_prototype/_tier9/_centroids_of_background_and_labels.py b/pyclesperanto_prototype/_tier9/_centroids_of_background_and_labels.py index 1c7897d8..dff56e51 100644 --- a/pyclesperanto_prototype/_tier9/_centroids_of_background_and_labels.py +++ b/pyclesperanto_prototype/_tier9/_centroids_of_background_and_labels.py @@ -1,9 +1,6 @@ -from .._tier2 import maximum_of_all_pixels from .._tier0 import create_none -from .._tier0 import execute from .._tier0 import plugin_function from .._tier0 import Image -from .._tier0 import push @plugin_function(output_creator=create_none) def centroids_of_background_and_labels(source:Image, pointlist_destination :Image = None): diff --git a/pyclesperanto_prototype/_tier9/_centroids_of_labels.py b/pyclesperanto_prototype/_tier9/_centroids_of_labels.py index 53447a26..535f0a37 100644 --- a/pyclesperanto_prototype/_tier9/_centroids_of_labels.py +++ b/pyclesperanto_prototype/_tier9/_centroids_of_labels.py @@ -3,7 +3,6 @@ from .._tier0 import execute from .._tier0 import plugin_function from .._tier0 import Image -from .._tier0 import push @plugin_function(output_creator=create_none) def centroids_of_labels(labels:Image, pointlist_destination :Image = None, include_background :bool = False): diff --git a/pyclesperanto_prototype/_tier9/_imread.py b/pyclesperanto_prototype/_tier9/_imread.py index 1385a68c..4ade9d1a 100644 --- a/pyclesperanto_prototype/_tier9/_imread.py +++ b/pyclesperanto_prototype/_tier9/_imread.py @@ -4,6 +4,6 @@ def imread(filename : str) -> Image: from skimage.io import imread as skimread image = skimread(filename) - from .._tier0 import push_zyx - return push_zyx(image) + from .._tier0 import push + return push(image) diff --git a/pyclesperanto_prototype/_tier9/_imshow.py b/pyclesperanto_prototype/_tier9/_imshow.py index d8f7bd9d..b4198a80 100644 --- a/pyclesperanto_prototype/_tier9/_imshow.py +++ b/pyclesperanto_prototype/_tier9/_imshow.py @@ -1,13 +1,13 @@ from .._tier0 import Image def imshow(image : Image, title : str = None, labels : bool = False, min_display_intensity : float = None, max_display_intensity : float = None, color_map =None): - from .._tier0 import pull_zyx + from .._tier0 import pull from .._tier1 import maximum_z_projection if len(image.shape) == 3: image = maximum_z_projection(image) - image = pull_zyx(image) + image = pull(image) cmap = color_map if labels: diff --git a/pyclesperanto_prototype/_tier9/_label_maximum_extension_map.py b/pyclesperanto_prototype/_tier9/_label_maximum_extension_map.py index 4b7a0eb0..a359c9b9 100644 --- a/pyclesperanto_prototype/_tier9/_label_maximum_extension_map.py +++ b/pyclesperanto_prototype/_tier9/_label_maximum_extension_map.py @@ -1,6 +1,6 @@ from .._tier0 import plugin_function from .._tier0 import Image -from .._tier0 import push_zyx +from .._tier0 import push from .._tier1 import replace_intensities from .._tier1 import set_column diff --git a/pyclesperanto_prototype/_tier9/_label_maximum_extension_ratio_map.py b/pyclesperanto_prototype/_tier9/_label_maximum_extension_ratio_map.py index c13cdd36..940b8b48 100644 --- a/pyclesperanto_prototype/_tier9/_label_maximum_extension_ratio_map.py +++ b/pyclesperanto_prototype/_tier9/_label_maximum_extension_ratio_map.py @@ -1,6 +1,6 @@ from .._tier0 import plugin_function from .._tier0 import Image -from .._tier0 import push_zyx +from .._tier0 import push from .._tier1 import replace_intensities from .._tier1 import set_column diff --git a/pyclesperanto_prototype/_tier9/_label_maximum_intensity_map.py b/pyclesperanto_prototype/_tier9/_label_maximum_intensity_map.py index b0de6a9c..cc51f4f3 100644 --- a/pyclesperanto_prototype/_tier9/_label_maximum_intensity_map.py +++ b/pyclesperanto_prototype/_tier9/_label_maximum_intensity_map.py @@ -1,6 +1,6 @@ from .._tier0 import plugin_function from .._tier0 import Image -from .._tier0 import push_zyx +from .._tier0 import push from .._tier1 import replace_intensities from .._tier1 import set_column diff --git a/pyclesperanto_prototype/_tier9/_label_mean_extension_map.py b/pyclesperanto_prototype/_tier9/_label_mean_extension_map.py index 3ff6c668..3834eab1 100644 --- a/pyclesperanto_prototype/_tier9/_label_mean_extension_map.py +++ b/pyclesperanto_prototype/_tier9/_label_mean_extension_map.py @@ -1,6 +1,6 @@ from .._tier0 import plugin_function from .._tier0 import Image -from .._tier0 import push_zyx +from .._tier0 import push from .._tier1 import replace_intensities from .._tier1 import set_column diff --git a/pyclesperanto_prototype/_tier9/_label_mean_intensity_map.py b/pyclesperanto_prototype/_tier9/_label_mean_intensity_map.py index 67b2d350..11a53980 100644 --- a/pyclesperanto_prototype/_tier9/_label_mean_intensity_map.py +++ b/pyclesperanto_prototype/_tier9/_label_mean_intensity_map.py @@ -1,6 +1,6 @@ from .._tier0 import plugin_function from .._tier0 import Image -from .._tier0 import push_zyx +from .._tier0 import push from .._tier1 import replace_intensities from .._tier1 import set_column diff --git a/pyclesperanto_prototype/_tier9/_label_minimum_intensity_map.py b/pyclesperanto_prototype/_tier9/_label_minimum_intensity_map.py index aac7901f..847c20bc 100644 --- a/pyclesperanto_prototype/_tier9/_label_minimum_intensity_map.py +++ b/pyclesperanto_prototype/_tier9/_label_minimum_intensity_map.py @@ -1,6 +1,6 @@ from .._tier0 import plugin_function from .._tier0 import Image -from .._tier0 import push_zyx +from .._tier0 import push from .._tier1 import replace_intensities from .._tier1 import set_column diff --git a/pyclesperanto_prototype/_tier9/_label_pixel_count_map.py b/pyclesperanto_prototype/_tier9/_label_pixel_count_map.py index c99400f6..4bd9e336 100644 --- a/pyclesperanto_prototype/_tier9/_label_pixel_count_map.py +++ b/pyclesperanto_prototype/_tier9/_label_pixel_count_map.py @@ -1,6 +1,6 @@ from .._tier0 import plugin_function from .._tier0 import Image -from .._tier0 import push_zyx +from .._tier0 import push from .._tier1 import replace_intensities from .._tier1 import set_column diff --git a/pyclesperanto_prototype/_tier9/_label_standard_deviation_intensity_map.py b/pyclesperanto_prototype/_tier9/_label_standard_deviation_intensity_map.py index 191c024c..456e18c1 100644 --- a/pyclesperanto_prototype/_tier9/_label_standard_deviation_intensity_map.py +++ b/pyclesperanto_prototype/_tier9/_label_standard_deviation_intensity_map.py @@ -1,6 +1,6 @@ from .._tier0 import plugin_function from .._tier0 import Image -from .._tier0 import push_zyx +from .._tier0 import push from .._tier1 import replace_intensities from .._tier1 import set_column diff --git a/pyclesperanto_prototype/_tier9/_push_regionprops.py b/pyclesperanto_prototype/_tier9/_push_regionprops.py index 54de262c..c2f11c77 100644 --- a/pyclesperanto_prototype/_tier9/_push_regionprops.py +++ b/pyclesperanto_prototype/_tier9/_push_regionprops.py @@ -20,7 +20,7 @@ def push_regionprops(props : Union[dict, RegionProperties], first_row_index : in """ from ._statistics_entry import STATISTICS_ENTRY - from .._tier0 import push_zyx + from .._tier0 import push num_columns = 36 if isinstance(props, dict): @@ -198,4 +198,4 @@ def push_regionprops(props : Union[dict, RegionProperties], first_row_index : in if hasattr(label_props, 'mean_max_distance_to_centroid_ratio'): matrix[i][STATISTICS_ENTRY.MAX_MEAN_DISTANCE_TO_CENTROID_RATIO.value] = label_props['mean_max_distance_to_centroid_ratio'] - return push_zyx(matrix.T) \ No newline at end of file + return push(matrix.T) \ No newline at end of file diff --git a/pyclesperanto_prototype/_tier9/_push_regionprops_column.py b/pyclesperanto_prototype/_tier9/_push_regionprops_column.py index 5319da76..510a2c4d 100644 --- a/pyclesperanto_prototype/_tier9/_push_regionprops_column.py +++ b/pyclesperanto_prototype/_tier9/_push_regionprops_column.py @@ -2,11 +2,11 @@ def push_regionprops_column(regionprops : Union[list, dict], column : str): - from .._tier0 import push_zyx + from .._tier0 import push import numpy as np if isinstance(regionprops, dict): - return push_zyx(np.asarray([regionprops[column]])) + return push(np.asarray([regionprops[column]])) else: if hasattr(regionprops[0], 'original_label'): labels = [r.original_label for r in regionprops] @@ -21,4 +21,4 @@ def push_regionprops_column(regionprops : Union[list, dict], column : str): else: label = r.label values[label] = r[column] - return push_zyx(np.asarray([values])) + return push(np.asarray([values])) diff --git a/pyclesperanto_prototype/_tier9/_regionprops.py b/pyclesperanto_prototype/_tier9/_regionprops.py index f1654580..470a7866 100644 --- a/pyclesperanto_prototype/_tier9/_regionprops.py +++ b/pyclesperanto_prototype/_tier9/_regionprops.py @@ -26,14 +26,14 @@ def regionprops(labelmap : Image, intensity_image : Image = None, cache : bool = .. [2] https://clij.github.io/clij2-docs/reference_statisticsOfLabelledPixels """ - from .._tier0 import pull_zyx + from .._tier0 import pull if labelmap is None: raise Exception("A label image must be provided") - label_image = pull_zyx(labelmap).astype(int) + label_image = pull(labelmap).astype(int) if intensity_image is not None: - intensity_image = pull_zyx(intensity_image) + intensity_image = pull(intensity_image) # Inspired by: https://forum.image.sc/t/how-to-measure-standard-deviation-of-intensities-with-scikit-image-regionprops/46948/2 import numpy as np diff --git a/pyclesperanto_prototype/_tier9/_statistics_of_background_and_labelled_pixels.py b/pyclesperanto_prototype/_tier9/_statistics_of_background_and_labelled_pixels.py index 3430bf13..d54ad7b7 100644 --- a/pyclesperanto_prototype/_tier9/_statistics_of_background_and_labelled_pixels.py +++ b/pyclesperanto_prototype/_tier9/_statistics_of_background_and_labelled_pixels.py @@ -3,7 +3,7 @@ from .._tier0 import Image from .._tier0 import create_none from .._tier0 import plugin_function -from .._tier0 import pull_zyx +from .._tier0 import pull @plugin_function(output_creator=create_none) def statistics_of_background_and_labelled_pixels(input : Image = None, labelmap : Image = None): diff --git a/pyclesperanto_prototype/_tier9/_statistics_of_labelled_pixels.py b/pyclesperanto_prototype/_tier9/_statistics_of_labelled_pixels.py index 573c8c66..8e95ecf0 100644 --- a/pyclesperanto_prototype/_tier9/_statistics_of_labelled_pixels.py +++ b/pyclesperanto_prototype/_tier9/_statistics_of_labelled_pixels.py @@ -36,7 +36,7 @@ def statistics_of_labelled_pixels(intensity_image : Image = None, label_image : from .._tier1 import paste from .._tier1 import divide_images from .._tier1 import set_plane - from .._tier0 import pull_zyx + from .._tier0 import pull from .._tier1 import power from .._tier2 import maximum_of_all_pixels import numpy as np @@ -138,27 +138,27 @@ def statistics_of_labelled_pixels(intensity_image : Image = None, label_image : # BOUNDING_BOX_HEIGHT = 8 # BOUNDING_BOX_DEPTH = 9 crop(min_per_label, result_vector, measurements_start_x, 10, 0) - bbox_min_x = pull_zyx(result_vector)[0] + bbox_min_x = pull(result_vector)[0] region_props['bbox_min_x'] = bbox_min_x crop(min_per_label, result_vector, measurements_start_x, 12, 0) - bbox_min_y = pull_zyx(result_vector)[0] + bbox_min_y = pull(result_vector)[0] region_props['bbox_min_y'] = bbox_min_y crop(min_per_label, result_vector, measurements_start_x, 14, 0) - bbox_min_z = pull_zyx(result_vector)[0] + bbox_min_z = pull(result_vector)[0] region_props['bbox_min_z'] = bbox_min_z crop(max_per_label, result_vector, measurements_start_x, 11, 0) - bbox_max_x = pull_zyx(result_vector)[0] + bbox_max_x = pull(result_vector)[0] region_props['bbox_max_x'] = bbox_max_x crop(max_per_label, result_vector, measurements_start_x, 13, 0) - bbox_max_y = pull_zyx(result_vector)[0] + bbox_max_y = pull(result_vector)[0] region_props['bbox_max_y'] = bbox_max_y crop(max_per_label, result_vector, measurements_start_x, 15, 0) - bbox_max_z = pull_zyx(result_vector)[0] + bbox_max_z = pull(result_vector)[0] region_props['bbox_max_z'] = bbox_max_z if len(intensity_image.shape) == 2: @@ -186,22 +186,22 @@ def statistics_of_labelled_pixels(intensity_image : Image = None, label_image : # MINIMUM_INTENSITY = 10 # MAXIMUM_INTENSITY = 11 crop(min_per_label, result_vector, measurements_start_x, 8, 0) - region_props['min_intensity'] = pull_zyx(result_vector)[0] + region_props['min_intensity'] = pull(result_vector)[0] crop(max_per_label, result_vector, measurements_start_x, 9, 0) - region_props['max_intensity'] = pull_zyx(result_vector)[0] + region_props['max_intensity'] = pull(result_vector)[0] # MEAN_INTENSITY = 12 # SUM_INTENSITY = 13 # PIXEL_COUNT = 15 crop(sum_per_label, result_vector, measurements_start_x, 7, 0) - region_props['sum_intensity'] = pull_zyx(result_vector)[0] + region_props['sum_intensity'] = pull(result_vector)[0] crop(sum_per_label, sum_dim, measurements_start_x, 3, 0) - region_props['area'] = pull_zyx(sum_dim)[0] + region_props['area'] = pull(sum_dim)[0] paste(sum_dim, label_statistics_image, measurements_start_x, 7, 0) divide_images(result_vector, sum_dim, avg_dim) - region_props['mean_intensity'] = pull_zyx(avg_dim)[0] + region_props['mean_intensity'] = pull(avg_dim)[0] paste(avg_dim, label_statistics_image, measurements_start_x, 6, 0) # SUM_INTENSITY_TIMES_X = 16 @@ -214,9 +214,9 @@ def statistics_of_labelled_pixels(intensity_image : Image = None, label_image : crop(sum_per_label, result_vector, measurements_start_x, 4 + 3, 0) for dim in range(0, 3): crop(sum_per_label, sum_dim, measurements_start_x, 4 + dim, 0) - region_props['sum_intensity_times_' + dim_names[dim]] = pull_zyx(sum_dim)[0] + region_props['sum_intensity_times_' + dim_names[dim]] = pull(sum_dim)[0] divide_images(sum_dim, result_vector, avg_dim) - region_props['mass_center_' + dim_names[dim]] = pull_zyx(avg_dim)[0] + region_props['mass_center_' + dim_names[dim]] = pull(avg_dim)[0] paste(avg_dim, label_statistics_image, measurements_start_x, 3 + dim, 0) if len(intensity_image.shape) == 2: @@ -240,9 +240,9 @@ def statistics_of_labelled_pixels(intensity_image : Image = None, label_image : crop(sum_per_label, result_vector, measurements_start_x, 3, 0) for dim in range(0, 3): crop(sum_per_label, sum_dim, measurements_start_x, dim, 0) - region_props['sum_' + dim_names[dim]] = pull_zyx(sum_dim)[0] + region_props['sum_' + dim_names[dim]] = pull(sum_dim)[0] divide_images(sum_dim, result_vector, avg_dim) - region_props['centroid_' + dim_names[dim]] = pull_zyx(avg_dim)[0] + region_props['centroid_' + dim_names[dim]] = pull(avg_dim)[0] paste(avg_dim, label_statistics_image, measurements_start_x, dim, 0) if len(intensity_image.shape) == 2: @@ -286,25 +286,25 @@ def statistics_of_labelled_pixels(intensity_image : Image = None, label_image : # distance to centroid crop(sum_statistics, sum_dim, measurements_start_x, 0, 0) - region_props['sum_distance_to_centroid'] = pull_zyx(sum_dim)[0] + region_props['sum_distance_to_centroid'] = pull(sum_dim)[0] divide_images(sum_dim, result_vector, avg_dim) - region_props['mean_distance_to_centroid'] = pull_zyx(avg_dim)[0] + region_props['mean_distance_to_centroid'] = pull(avg_dim)[0] # distance to center of mass crop(sum_statistics, sum_dim, measurements_start_x, 1, 0) - region_props['sum_distance_to_mass_center'] = pull_zyx(sum_dim)[0] + region_props['sum_distance_to_mass_center'] = pull(sum_dim)[0] divide_images(sum_dim, result_vector, avg_dim) - region_props['mean_distance_to_mass_center'] = pull_zyx(avg_dim)[0] + region_props['mean_distance_to_mass_center'] = pull(avg_dim)[0] # standard deviation intensity crop(sum_statistics, sum_dim, measurements_start_x, 2, 0) power(sum_dim, result_vector, 0.5) - region_props['standard_deviation_intensity'] = pull_zyx(result_vector)[0] + region_props['standard_deviation_intensity'] = pull(result_vector)[0] crop(max_statistics, result_vector, measurements_start_x, 4, 0) - region_props['max_distance_to_centroid'] = pull_zyx(result_vector)[0] + region_props['max_distance_to_centroid'] = pull(result_vector)[0] crop(max_statistics, result_vector, measurements_start_x, 5, 0) - region_props['max_distance_to_mass_center'] = pull_zyx(result_vector)[0] + region_props['max_distance_to_mass_center'] = pull(result_vector)[0] region_props['mean_max_distance_to_centroid_ratio'] = region_props['max_distance_to_centroid'] / region_props[ 'mean_distance_to_centroid'] diff --git a/pyclesperanto_prototype/_tier9/_threshold_otsu.py b/pyclesperanto_prototype/_tier9/_threshold_otsu.py index 704a03a2..f85b6466 100644 --- a/pyclesperanto_prototype/_tier9/_threshold_otsu.py +++ b/pyclesperanto_prototype/_tier9/_threshold_otsu.py @@ -1,5 +1,5 @@ from .. import minimum_of_all_pixels, maximum_of_all_pixels -from .._tier0 import pull_zyx +from .._tier0 import pull from .._tier1 import greater_constant import numpy as np @@ -49,7 +49,7 @@ def threshold_otsu(input : Image, destination : Image = None): bin_centers = np.arange(256) * range / (255) # Determine histogram on GPU - hist = pull_zyx(histogram(input, num_bins=256, minimum_intensity=minimum_intensity, maximum_intensity=maximum_intensity, determine_min_max=False)) + hist = pull(histogram(input, num_bins=256, minimum_intensity=minimum_intensity, maximum_intensity=maximum_intensity, determine_min_max=False)) # determine threshold using scikit-image threshold = scikit_image_threshold_otsu(hist=(hist, bin_centers)) diff --git a/tests/test_absolute.py b/tests/test_absolute.py index 9e95214c..22fec976 100644 --- a/tests/test_absolute.py +++ b/tests/test_absolute.py @@ -2,7 +2,7 @@ import numpy as np def test_absolute(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [1, -1], [1, -1] ])) @@ -12,14 +12,14 @@ def test_absolute(): print(test2) - a = cle.pull_zyx(test2) + a = cle.pull(test2) assert (np.min(a) == 1) assert (np.max(a) == 1) assert (np.mean(a) == 1) def test_absolute1(): - gpu_a = cle.push_zyx(np.asarray([[1, -1], [1, -1]])) + gpu_a = cle.push(np.asarray([[1, -1], [1, -1]])) gpu_b = cle.create(gpu_a) cle.absolute(gpu_a, gpu_b) - assert np.all(cle.pull_zyx(gpu_b) == 1) + assert np.all(cle.pull(gpu_b) == 1) diff --git a/tests/test_absolute_difference.py b/tests/test_absolute_difference.py index bbe3a592..0bb422b6 100644 --- a/tests/test_absolute_difference.py +++ b/tests/test_absolute_difference.py @@ -10,7 +10,7 @@ def test_absolute_difference(): reference = np.asarray([[3, 3, 4]]) output = cle.absolute_difference(input2, input1) - result = cle.pull_zyx(output) + result = cle.pull(output) assert np.array_equal(result, reference) diff --git a/tests/test_add_image_and_scalar.py b/tests/test_add_image_and_scalar.py index 28b56f10..2c1cd5e6 100644 --- a/tests/test_add_image_and_scalar.py +++ b/tests/test_add_image_and_scalar.py @@ -5,7 +5,7 @@ def test_add_image_and_scalar(): data = np.arange(100).reshape(10, 10) # push an array to the GPU - flip = cle.push(data) + flip = cle.push(data.T) assert flip.shape == (10, 10) assert isinstance(flip, cl.array.Array) # create memory for the output diff --git a/tests/test_add_images.py b/tests/test_add_images.py index 1a6a55dc..41b8e898 100644 --- a/tests/test_add_images.py +++ b/tests/test_add_images.py @@ -10,7 +10,7 @@ def test_add_images_weighted_missing_params(): reference = np.asarray([[5, 7, 9]]) output = cle.add_images_weighted(input1, input2) - result = cle.pull_zyx(output) + result = cle.pull(output) assert np.array_equal(result, reference) @@ -19,24 +19,24 @@ def test_add_images_weighted_missing_params(): def test_add_images_weighted_none_output(): output = cle.add_images_weighted(input1, input2, None, 1, 2) - result = cle.pull_zyx(output) + result = cle.pull(output) assert np.array_equal(result, reference) def test_add_images_weighted_named_params(): output = cle.add_images_weighted(input1, input2, None, factor1=1, factor2=2) - result = cle.pull_zyx(output) + result = cle.pull(output) assert np.array_equal(result, reference) def test_add_images_weighted_named_params_missing_params(): output = cle.add_images_weighted(input1, input2, factor1=1, factor2=2) - result = cle.pull_zyx(output) + result = cle.pull(output) assert np.array_equal(result, reference) def test_add_images_weighted_wrong_order_missing_params(): reference = np.asarray([[9, 12, 15]]) output = cle.add_images_weighted(input1, input2, factor2=2, factor1=1) - result = cle.pull_zyx(output) + result = cle.pull(output) assert np.array_equal(result, reference) diff --git a/tests/test_add_images_weighted.py b/tests/test_add_images_weighted.py index fb8c47ac..8b43bc3c 100644 --- a/tests/test_add_images_weighted.py +++ b/tests/test_add_images_weighted.py @@ -8,7 +8,7 @@ def test_add_images_weighted_missing_parameters(): reference = np.asarray([[5, 7, 9]]) output = cle.add_images_weighted(input1, input2) - result = cle.pull_zyx(output) + result = cle.pull(output) print(result) print(reference) @@ -22,7 +22,7 @@ def test_add_images_weighted_none_output(): reference = np.asarray([[9, 12, 15]]) output = cle.add_images_weighted(input1, input2, None, 1, 2) - result = cle.pull_zyx(output) + result = cle.pull(output) print(result) print(reference) @@ -36,7 +36,7 @@ def test_add_images_weighted_named_parameters(): reference = np.asarray([[9, 12, 15]]) output = cle.add_images_weighted(input1, input2, None, factor1=1, factor2=2) - result = cle.pull_zyx(output) + result = cle.pull(output) print(result) print(reference) @@ -49,7 +49,7 @@ def test_add_images_weighted_wrong_parameter_order(): reference = np.asarray([[9, 12, 15]]) output = cle.add_images_weighted(input1, input2, factor1=1, factor2=2) - result = cle.pull_zyx(output) + result = cle.pull(output) print(result) print(reference) @@ -62,7 +62,7 @@ def test_add_images_weighted_parameters_wrong_order_and_missing(): reference = np.asarray([[9, 12, 15]]) output = cle.add_images_weighted(input1, input2, factor2=2, factor1=1) - result = cle.pull_zyx(output) + result = cle.pull(output) print(result) print(reference) diff --git a/tests/test_affine_transform.py b/tests/test_affine_transform.py index fbad0a2c..ded2b6d9 100644 --- a/tests/test_affine_transform.py +++ b/tests/test_affine_transform.py @@ -2,7 +2,7 @@ import numpy as np def test_affine_transform_translate(): - source = cle.push_zyx(np.asarray([[ + source = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], @@ -10,7 +10,7 @@ def test_affine_transform_translate(): [0, 0, 0, 0, 0], ]])) - reference = cle.push_zyx(np.asarray([[ + reference = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 1, 1, 0, 0], [0, 0, 0, 0, 0], @@ -23,8 +23,8 @@ def test_affine_transform_translate(): result = cle.affine_transform(source, transform=transform) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -33,7 +33,7 @@ def test_affine_transform_translate(): def test_affine_transform_scale(): - source = cle.push_zyx(np.asarray([[ + source = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0], @@ -41,7 +41,7 @@ def test_affine_transform_scale(): [0, 0, 0, 0, 0], ]])) - reference = cle.push_zyx(np.asarray([[ + reference = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], @@ -54,8 +54,8 @@ def test_affine_transform_scale(): result = cle.affine_transform(source, transform=transform) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -63,7 +63,7 @@ def test_affine_transform_scale(): assert (np.array_equal(a, b)) def test_affine_transform_scale_with_transform_matrix(): - source = cle.push_zyx(np.asarray([[ + source = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0], @@ -71,7 +71,7 @@ def test_affine_transform_scale_with_transform_matrix(): [0, 0, 0, 0, 0], ]])) - reference = cle.push_zyx(np.asarray([[ + reference = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], @@ -88,8 +88,8 @@ def test_affine_transform_scale_with_transform_matrix(): result = cle.affine_transform(source, transform=transform) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -98,7 +98,7 @@ def test_affine_transform_scale_with_transform_matrix(): def test_affine_transform_rotate(): - source = cle.push_zyx(np.asarray([[ + source = cle.push(np.asarray([[ [0, 0, 0, 1, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], @@ -106,7 +106,7 @@ def test_affine_transform_rotate(): [0, 0, 0, 0, 0], ]])) - reference = cle.push_zyx(np.asarray([[ + reference = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -119,8 +119,8 @@ def test_affine_transform_rotate(): result = cle.affine_transform(source, transform=transform) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -128,7 +128,7 @@ def test_affine_transform_rotate(): assert (np.array_equal(a, b)) def test_affine_transform_rotate_around_center(): - source = cle.push_zyx(np.asarray([[ + source = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 1, 1], @@ -136,7 +136,7 @@ def test_affine_transform_rotate_around_center(): [0, 0, 0, 0, 0], ]])) - reference = cle.push_zyx(np.asarray([[ + reference = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], @@ -151,8 +151,8 @@ def test_affine_transform_rotate_around_center(): result = cle.affine_transform(source, transform=transform) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_average_distance_of_n_far_off_distances.py b/tests/test_average_distance_of_n_far_off_distances.py index 3fd806a3..b8cf4276 100644 --- a/tests/test_average_distance_of_n_far_off_distances.py +++ b/tests/test_average_distance_of_n_far_off_distances.py @@ -3,7 +3,7 @@ def test_average_distance_of_n_far_off_distances(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], @@ -12,7 +12,7 @@ def test_average_distance_of_n_far_off_distances(): [0, 0, 0, 2, 2, 2] ])) - reference = cle.push_zyx(np.asarray( + reference = cle.push(np.asarray( [[0, 4.2426, 4.2426, 3]] )) @@ -21,8 +21,8 @@ def test_average_distance_of_n_far_off_distances(): average_distance_of_n_far_off_distances = cle.average_distance_of_n_far_off_distances(distance_matrix, n=1) - a = cle.pull_zyx(average_distance_of_n_far_off_distances) - b = cle.pull_zyx(reference) + a = cle.pull(average_distance_of_n_far_off_distances) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_average_distance_of_n_shortest_distances.py b/tests/test_average_distance_of_n_shortest_distances.py index d25ddc55..3b104c0a 100644 --- a/tests/test_average_distance_of_n_shortest_distances.py +++ b/tests/test_average_distance_of_n_shortest_distances.py @@ -3,7 +3,7 @@ def test_average_distance_of_n_shortest_distances(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], @@ -12,7 +12,7 @@ def test_average_distance_of_n_shortest_distances(): [0, 0, 0, 2, 2, 2] ])) - reference = cle.push_zyx(np.asarray( + reference = cle.push(np.asarray( [[0, 3, 3, 3]] )) @@ -21,8 +21,8 @@ def test_average_distance_of_n_shortest_distances(): average_distance_of_n_far_off_distances = cle.average_distance_of_n_shortest_distances(distance_matrix, n=1) - a = cle.pull_zyx(average_distance_of_n_far_off_distances) - b = cle.pull_zyx(reference) + a = cle.pull(average_distance_of_n_far_off_distances) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_average_distance_of_touching_neighbors.py b/tests/test_average_distance_of_touching_neighbors.py index e18a9707..87eb226a 100644 --- a/tests/test_average_distance_of_touching_neighbors.py +++ b/tests/test_average_distance_of_touching_neighbors.py @@ -3,7 +3,7 @@ def test_average_distance_of_touching_neighbors(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], @@ -12,7 +12,7 @@ def test_average_distance_of_touching_neighbors(): [0, 0, 0, 2, 2, 2] ])) - reference = cle.push_zyx(np.asarray( + reference = cle.push(np.asarray( [[0, 3, 3, 3]] )) @@ -22,8 +22,8 @@ def test_average_distance_of_touching_neighbors(): average_distance_of_touching_neighbors = cle.average_distance_of_touching_neighbors(distance_matrix, touch_matrix) - a = cle.pull_zyx(average_distance_of_touching_neighbors) - b = cle.pull_zyx(reference) + a = cle.pull(average_distance_of_touching_neighbors) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_binary_and.py b/tests/test_binary_and.py index b1fdc2d5..f0892994 100644 --- a/tests/test_binary_and.py +++ b/tests/test_binary_and.py @@ -3,12 +3,12 @@ def test_binary_and_1(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [1, 0], [1, 0] ])) - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [1, 1], [0, 0] ])) @@ -18,7 +18,7 @@ def test_binary_and_1(): print(test2) - a = cle.pull_zyx(test2) + a = cle.pull(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) == 0.25) @@ -26,10 +26,10 @@ def test_binary_and_1(): def test_binary_and_2(): a = np.asarray([[1, 0], [1, 0]]) b = np.asarray([[1, 1], [0, 0]]) - gpu_a = cle.push_zyx(a) - gpu_b = cle.push_zyx(b) + gpu_a = cle.push(a) + gpu_b = cle.push(b) gpu_c = cle.create(gpu_a) cle.binary_and(gpu_a, gpu_b, gpu_c) - result = cle.pull_zyx(gpu_c) + result = cle.pull(gpu_c) assert np.allclose(result, a & b) \ No newline at end of file diff --git a/tests/test_binary_edge_detection.py b/tests/test_binary_edge_detection.py index 8e7ff067..c3007d87 100644 --- a/tests/test_binary_edge_detection.py +++ b/tests/test_binary_edge_detection.py @@ -2,7 +2,7 @@ import numpy as np def test_binary_edge_detection(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 0], [0, 1, 1, 1, 1, 0], @@ -15,7 +15,7 @@ def test_binary_edge_detection(): cle.binary_edge_detection(test1, test2) print(test2) - a = cle.pull_zyx(test2) + a = cle.pull(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) - 12 / 36 < 0.001) diff --git a/tests/test_binary_not.py b/tests/test_binary_not.py index 375b1274..17d43f83 100644 --- a/tests/test_binary_not.py +++ b/tests/test_binary_not.py @@ -3,7 +3,7 @@ def test_binary_not(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [1, 1], [1, 0] ])) @@ -12,7 +12,7 @@ def test_binary_not(): cle.binary_not(test1, test2) print(test2) - a = cle.pull_zyx(test2) + a = cle.pull(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) == 0.25) diff --git a/tests/test_binary_or.py b/tests/test_binary_or.py index 094a59e3..237a1fd5 100644 --- a/tests/test_binary_or.py +++ b/tests/test_binary_or.py @@ -2,12 +2,12 @@ import numpy as np def test_binary_or(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [1, 0], [1, 0] ])) - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [1, 1], [0, 0] ])) @@ -17,7 +17,7 @@ def test_binary_or(): print(test2) - a = cle.pull_zyx(test2) + a = cle.pull(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) == 0.75) diff --git a/tests/test_binary_subtract.py b/tests/test_binary_subtract.py index 5ea55383..def33d5c 100644 --- a/tests/test_binary_subtract.py +++ b/tests/test_binary_subtract.py @@ -2,12 +2,12 @@ import numpy as np def test_binary_subtract(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [1, 0], [1, 0] ])) - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [1, 1], [0, 0] ])) @@ -17,7 +17,7 @@ def test_binary_subtract(): print(test2) - a = cle.pull_zyx(test2) + a = cle.pull(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) == 0.25) diff --git a/tests/test_binary_xor.py b/tests/test_binary_xor.py index c7d21d75..0642a1e5 100644 --- a/tests/test_binary_xor.py +++ b/tests/test_binary_xor.py @@ -2,12 +2,12 @@ import numpy as np def test_binary_xor(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [1, 0], [1, 0] ])) - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [1, 1], [0, 0] ])) @@ -17,7 +17,7 @@ def test_binary_xor(): print(test2) - a = cle.pull_zyx(test2) + a = cle.pull(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) == 0.5) diff --git a/tests/test_block_enumerate.py b/tests/test_block_enumerate.py index 01131621..23f4aa44 100644 --- a/tests/test_block_enumerate.py +++ b/tests/test_block_enumerate.py @@ -5,7 +5,7 @@ reference = np.asarray([[0, 1, 0, 2, 0, 0, 3, 4, 0, 0, 5, 0]]) def block_enum(source, blocksize): - flagged_indices = cle.push_zyx(source) + flagged_indices = cle.push(source) max_label = source.shape[1] - 1 block_sums = cle.create([1, int((int(max_label) + 1) / blocksize) + 1]) @@ -15,7 +15,7 @@ def block_enum(source, blocksize): new_indices = cle.create([1, int(max_label) + 1]) cle.block_enumerate(flagged_indices, block_sums, new_indices, blocksize) - return cle.pull_zyx(new_indices) + return cle.pull(new_indices) def test_block_enumerate(): result = block_enum(source, 4) diff --git a/tests/test_bottom_hat_box.py b/tests/test_bottom_hat_box.py index 6cd45ec1..cb53a6d5 100644 --- a/tests/test_bottom_hat_box.py +++ b/tests/test_bottom_hat_box.py @@ -3,7 +3,7 @@ def test_bottom_hat_sphere(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 50, 50, 50, 0], [0, 50, 100, 50, 0], @@ -16,7 +16,7 @@ def test_bottom_hat_sphere(): print(result) - a = cle.pull_zyx(result) + a = cle.pull(result) assert (np.min(a) == 0) assert (np.max(a) == 50) diff --git a/tests/test_bottom_hat_sphere.py b/tests/test_bottom_hat_sphere.py index b9aa0ec9..bf327a6e 100644 --- a/tests/test_bottom_hat_sphere.py +++ b/tests/test_bottom_hat_sphere.py @@ -3,7 +3,7 @@ def test_bottom_hat_sphere(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 50, 50, 50, 0], [0, 50, 100, 50, 0], @@ -16,7 +16,7 @@ def test_bottom_hat_sphere(): print(result) - a = cle.pull_zyx(result) + a = cle.pull(result) assert (np.min(a) == 0) assert (np.max(a) == 50) diff --git a/tests/test_bounding_box.py b/tests/test_bounding_box.py index 0a4bc12d..99114c98 100644 --- a/tests/test_bounding_box.py +++ b/tests/test_bounding_box.py @@ -3,7 +3,7 @@ def test_bounding_box_2d(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 0, 0], [0, 1, 1, 0, 0], @@ -22,7 +22,7 @@ def test_bounding_box_2d(): def test_bounding_box_3d(): - test = cle.push_zyx(np.asarray([[ + test = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 1, 1, 0, 0], [0, 1, 1, 0, 0], diff --git a/tests/test_center_of_mass.py b/tests/test_center_of_mass.py index 6ca610cc..305f29b6 100644 --- a/tests/test_center_of_mass.py +++ b/tests/test_center_of_mass.py @@ -3,7 +3,7 @@ def test_center_of_mass(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [0, 0, 0, 0, 0] diff --git a/tests/test_centroids_of_labels.py b/tests/test_centroids_of_labels.py index 8a7108e1..8fc7880b 100644 --- a/tests/test_centroids_of_labels.py +++ b/tests/test_centroids_of_labels.py @@ -3,13 +3,13 @@ def test_centroids_of_labels(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2], [1, 2, 2], [3, 3, 3] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ # CENTROID_X(25), [0.33333334, 1.6666666, 1.], # CENTROID_Y(26), @@ -19,8 +19,8 @@ def test_centroids_of_labels(): result = cle.centroids_of_labels(labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -30,7 +30,7 @@ def test_centroids_of_labels(): def test_centroids_of_labels_3d(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [ [1, 1, 2], ], [ @@ -40,7 +40,7 @@ def test_centroids_of_labels_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ # CENTROID_X(25), [0.33333334, 1.6666666, 1.], # CENTROID_Y(26), @@ -52,8 +52,8 @@ def test_centroids_of_labels_3d(): result = cle.centroids_of_labels(labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_close_index_gaps_in_label_maps.py b/tests/test_close_index_gaps_in_label_maps.py index 030e8f16..fac3eded 100644 --- a/tests/test_close_index_gaps_in_label_maps.py +++ b/tests/test_close_index_gaps_in_label_maps.py @@ -3,7 +3,7 @@ def test_close_index_gaps_in_label_maps(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [ [1, 2, 3], [1, 6, 6], @@ -12,7 +12,7 @@ def test_close_index_gaps_in_label_maps(): ])) gpu_output = cle.create_like(gpu_input) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [ [1, 2, 3], [1, 4, 4], @@ -24,8 +24,8 @@ def test_close_index_gaps_in_label_maps(): cle.close_index_gaps_in_label_map(gpu_input, gpu_output) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_combine_horizontally.py b/tests/test_combine_horizontally.py index c8011190..388a9673 100644 --- a/tests/test_combine_horizontally.py +++ b/tests/test_combine_horizontally.py @@ -3,24 +3,24 @@ def test_combine_horizontally(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [1, 1], [1, 1] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [2, 2, 2], [2, 2, 2] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1, 1, 2, 2, 2], [1, 1, 2, 2, 2] ])) result = cle.combine_horizontally(test1, test2) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_combine_vertically.py b/tests/test_combine_vertically.py index f5bb3b48..bc75f100 100644 --- a/tests/test_combine_vertically.py +++ b/tests/test_combine_vertically.py @@ -3,16 +3,16 @@ def test_combine_vertically(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [1, 1], [1, 1] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [2, 2], [2, 2] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1, 1], [1, 1], [2, 2], @@ -21,8 +21,8 @@ def test_combine_vertically(): result = cle.combine_vertically(test1, test2) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_concatenate_stacks.py b/tests/test_concatenate_stacks.py index c9d168cb..070c1ddb 100644 --- a/tests/test_concatenate_stacks.py +++ b/tests/test_concatenate_stacks.py @@ -3,14 +3,14 @@ def test_concatenate_stacks(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 1], ],[ [1, 1] ] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [ [2, 2] ], [ @@ -20,7 +20,7 @@ def test_concatenate_stacks(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [1, 1], @@ -37,8 +37,8 @@ def test_concatenate_stacks(): result = cle.concatenate_stacks(test1, test2) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_connected_components_labeling_box.py b/tests/test_connected_components_labeling_box.py index c83ed3dc..fe202490 100644 --- a/tests/test_connected_components_labeling_box.py +++ b/tests/test_connected_components_labeling_box.py @@ -3,7 +3,7 @@ def test_connected_components_labeling_box(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [ [1, 0, 1], [1, 0, 0], @@ -11,7 +11,7 @@ def test_connected_components_labeling_box(): ] ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [ [1, 0, 2], [1, 0, 0], @@ -21,8 +21,8 @@ def test_connected_components_labeling_box(): gpu_output = cle.connected_components_labeling_box(gpu_input) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) @@ -43,7 +43,7 @@ def test_connected_components_labeling_box_blobs(): print("Loaded image size: " + str(image.shape)) # push image to GPU memory - input = cle.push_zyx(image) + input = cle.push(image) print("Image size in GPU: " + str(input.shape)) # process the image diff --git a/tests/test_connected_components_labeling_diamond.py b/tests/test_connected_components_labeling_diamond.py index 3ed32283..a42cc8cf 100644 --- a/tests/test_connected_components_labeling_diamond.py +++ b/tests/test_connected_components_labeling_diamond.py @@ -3,7 +3,7 @@ def test_connected_components_labeling_diamond(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [ [0, 1, 0, 1], [0, 1, 0, 0], @@ -11,7 +11,7 @@ def test_connected_components_labeling_diamond(): ] ]).T) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [ [0, 1, 0, 2], [0, 1, 0, 0], @@ -21,8 +21,8 @@ def test_connected_components_labeling_diamond(): gpu_output = cle.connected_components_labeling_diamond(gpu_input) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_convolve.py b/tests/test_convolve.py index 84ef7ebd..8b330865 100644 --- a/tests/test_convolve.py +++ b/tests/test_convolve.py @@ -3,13 +3,13 @@ def test_convolve(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0], [0, 1, 0], [0, 0, 0] ])) - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 1, 0], [1, 2, 1], [0, 1, 0] @@ -20,8 +20,8 @@ def test_convolve(): print(test2) - a = cle.pull_zyx(test1) - b = cle.pull_zyx(test2) + a = cle.pull(test1) + b = cle.pull(test2) assert (np.min(a) == np.min(b)) assert (np.max(a) == np.max(b)) assert (np.mean(a) == np.mean(b)) diff --git a/tests/test_copy.py b/tests/test_copy.py index 6901674e..56976b68 100644 --- a/tests/test_copy.py +++ b/tests/test_copy.py @@ -3,7 +3,7 @@ def test_copy(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [1, 1], [1, 0] ])) @@ -12,7 +12,7 @@ def test_copy(): cle.copy(test1, test2) print(test2) - a = cle.pull_zyx(test2) + a = cle.pull(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) == 0.75) diff --git a/tests/test_copy_slice.py b/tests/test_copy_slice.py index 98a249e5..037f4fcd 100644 --- a/tests/test_copy_slice.py +++ b/tests/test_copy_slice.py @@ -3,7 +3,7 @@ def test_copy_slice_from_3d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 4], [0, 4] @@ -18,14 +18,14 @@ def test_copy_slice_from_3d(): cle.copy_slice(test1, test2, 0) print(test2) - a = cle.pull_zyx(test2) + a = cle.pull(test2) assert (np.min(a) == 0) assert (np.max(a) == 1) assert (np.mean(a) == 0.75) def test_copy_slice_to_3d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [3, 4], [4, 5] ])) @@ -35,13 +35,13 @@ def test_copy_slice_to_3d(): cle.copy_slice(test1, test2, 0) print(test2) - a = cle.pull_zyx(test2) + a = cle.pull(test2) assert (np.min(a) == 0) assert (np.max(a) == 5) assert (np.mean(a) == 2) def test_copy_slice_to3d_with_one_slice(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [3, 4, 6], [4, 5, 2] ])) @@ -56,13 +56,13 @@ def test_copy_slice_to3d_with_one_slice(): cle.copy_slice(test1, test2, 0) print(test2) - a = cle.pull_zyx(test2) + a = cle.pull(test2) assert (np.min(a) == 2) assert (np.max(a) == 6) assert (np.mean(a) == 4) def test_copy_slice_to3d_with_one_slice_zyx(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [3, 4, 6], [4, 5, 2] ])) @@ -77,7 +77,7 @@ def test_copy_slice_to3d_with_one_slice_zyx(): cle.copy_slice(test1, test2, 0) print(test2) - a = cle.pull_zyx(test2) + a = cle.pull(test2) assert (np.min(a) == 2) assert (np.max(a) == 6) assert (np.mean(a) == 4) @@ -85,13 +85,13 @@ def test_copy_slice_to3d_with_one_slice_zyx(): def test_copy_slice_mini_y(): np_input = np.asarray([[1], [2], [3], [4]]) - gpu_input = cle.push_zyx(np_input) + gpu_input = cle.push(np_input) gpu_output = cle.create((1, 4, 1)) cle.copy_slice(gpu_input, gpu_output, 0) print(gpu_output) - a = cle.pull_zyx(gpu_output) + a = cle.pull(gpu_output) assert (np.min(a) == 1) assert (np.max(a) == 4) assert (np.mean(a) == 2.5) @@ -99,13 +99,13 @@ def test_copy_slice_mini_y(): def test_copy_slice_mini_x(): np_input = np.asarray([[1, 2, 3, 4]]) - gpu_input = cle.push_zyx(np_input) + gpu_input = cle.push(np_input) gpu_output = cle.create((1, 1, 4)) cle.copy_slice(gpu_input, gpu_output, 0) print(gpu_output) - a = cle.pull_zyx(gpu_output) + a = cle.pull(gpu_output) assert (np.min(a) == 1) assert (np.max(a) == 4) assert (np.mean(a) == 2.5) diff --git a/tests/test_count_touching_neighbors.py b/tests/test_count_touching_neighbors.py index b3bd4d95..f32c3c91 100644 --- a/tests/test_count_touching_neighbors.py +++ b/tests/test_count_touching_neighbors.py @@ -3,7 +3,7 @@ def test_count_touching_neighbors(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 0, 3, 3], [1, 1, 2, 3, 3], [0, 2, 2, 2, 0], @@ -11,7 +11,7 @@ def test_count_touching_neighbors(): [4, 4, 0, 5, 5] ])) - reference = cle.push_zyx(np.asarray( + reference = cle.push(np.asarray( [[5, 2, 5, 2, 2, 2]] )) @@ -19,8 +19,8 @@ def test_count_touching_neighbors(): neighbor_count_vector = cle.count_touching_neighbors(touch_matrix) - a = cle.pull_zyx(neighbor_count_vector) - b = cle.pull_zyx(reference) + a = cle.pull(neighbor_count_vector) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_crop.py b/tests/test_crop.py index 1a64db6d..433e06f9 100644 --- a/tests/test_crop.py +++ b/tests/test_crop.py @@ -2,14 +2,14 @@ import numpy as np def test_crop(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 1], [0, 0, 3, 1], [0, 0, 3, 1], [1, 1, 1, 1] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0], [0, 0, 3], [0, 0, 3] @@ -18,8 +18,8 @@ def test_crop(): result = cle.create(reference) cle.crop(test1, result, 0, 0) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_degrees_to_radians.py b/tests/test_degrees_to_radians.py index 0fa9211e..ff15d1f0 100644 --- a/tests/test_degrees_to_radians.py +++ b/tests/test_degrees_to_radians.py @@ -2,17 +2,17 @@ import numpy as np def test_degrees_to_radians(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [180, 0, -90] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [np.pi, 0, -0.5 * np.pi] ])) result = cle.degrees_to_radians(test) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a,b,0.01)) diff --git a/tests/test_detect_label_edges.py b/tests/test_detect_label_edges.py index 41373333..dc9eb576 100644 --- a/tests/test_detect_label_edges.py +++ b/tests/test_detect_label_edges.py @@ -3,7 +3,7 @@ def test_detect_label_edges(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [1, 1, 2, 2, 2], [1, 1, 2, 2, 2], [3, 3, 3, 2, 2], @@ -14,7 +14,7 @@ def test_detect_label_edges(): result = cle.create(test) cle.detect_label_edges(test, result) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 1, 1, 0, 0], [1, 1, 1, 0, 0], [1, 1, 1, 1, 1], @@ -24,8 +24,8 @@ def test_detect_label_edges(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(b) diff --git a/tests/test_detect_maxima_box.py b/tests/test_detect_maxima_box.py index f7cf6214..214ec6fa 100644 --- a/tests/test_detect_maxima_box.py +++ b/tests/test_detect_maxima_box.py @@ -3,7 +3,7 @@ def test_detect_maxima_box(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [0, 0, 0, 0, 0], [1, 0, 0, 2, 0], @@ -14,7 +14,7 @@ def test_detect_maxima_box(): ])) gpu_output = cle.create_like(gpu_input) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], @@ -26,8 +26,8 @@ def test_detect_maxima_box(): cle.detect_maxima_box(gpu_input, gpu_output) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_detect_minima_box.py b/tests/test_detect_minima_box.py index 592ae4cb..8f7989fa 100644 --- a/tests/test_detect_minima_box.py +++ b/tests/test_detect_minima_box.py @@ -3,7 +3,7 @@ def test_detect_minima_box(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [6, 6, 6, 6, 6], [5, 6, 6, 4, 6], @@ -14,7 +14,7 @@ def test_detect_minima_box(): ])) gpu_output = cle.create_like(gpu_input) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], @@ -26,8 +26,8 @@ def test_detect_minima_box(): cle.detect_minima_box(gpu_input, gpu_output) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_difference_of_gaussian.py b/tests/test_difference_of_gaussian.py index 01f76c7c..140cddae 100644 --- a/tests/test_difference_of_gaussian.py +++ b/tests/test_difference_of_gaussian.py @@ -3,7 +3,7 @@ def test_difference_of_gaussian(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 100, 0, 0], @@ -16,7 +16,7 @@ def test_difference_of_gaussian(): print(result) - a = cle.pull_zyx(result) + a = cle.pull(result) assert (np.min(a) < -1.15) assert (np.min(a) > -1.18) assert (np.max(a) > 11.9) diff --git a/tests/test_dilate_box.py b/tests/test_dilate_box.py index 223d053b..15622cc5 100644 --- a/tests/test_dilate_box.py +++ b/tests/test_dilate_box.py @@ -3,7 +3,7 @@ def test_dilate_box(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -11,7 +11,7 @@ def test_dilate_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], @@ -24,6 +24,6 @@ def test_dilate_box(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_dilate_box_slice_by_slice.py b/tests/test_dilate_box_slice_by_slice.py index 38eeeb43..17add593 100644 --- a/tests/test_dilate_box_slice_by_slice.py +++ b/tests/test_dilate_box_slice_by_slice.py @@ -2,7 +2,7 @@ import numpy as np def test_dilate_box_slice_by_slice(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], @@ -24,7 +24,7 @@ def test_dilate_box_slice_by_slice(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], @@ -49,8 +49,8 @@ def test_dilate_box_slice_by_slice(): result = cle.create(test) cle.dilate_box_slice_by_slice(test, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_dilate_sphere.py b/tests/test_dilate_sphere.py index cd72a77a..346a2d38 100644 --- a/tests/test_dilate_sphere.py +++ b/tests/test_dilate_sphere.py @@ -5,7 +5,7 @@ def test_dilate_sphere(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -13,7 +13,7 @@ def test_dilate_sphere(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 1, 1, 1, 0], @@ -26,6 +26,6 @@ def test_dilate_sphere(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_dilate_sphere_slice_by_slice.py b/tests/test_dilate_sphere_slice_by_slice.py index f856cb9a..5cacc1a6 100644 --- a/tests/test_dilate_sphere_slice_by_slice.py +++ b/tests/test_dilate_sphere_slice_by_slice.py @@ -2,7 +2,7 @@ import numpy as np def test_dilate_sphere_slice_by_slice(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], @@ -24,7 +24,7 @@ def test_dilate_sphere_slice_by_slice(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -49,8 +49,8 @@ def test_dilate_sphere_slice_by_slice(): result = cle.create(test) cle.dilate_sphere_slice_by_slice(test, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_divide_images.py b/tests/test_divide_images.py index 5aa099ed..d3dbf838 100644 --- a/tests/test_divide_images.py +++ b/tests/test_divide_images.py @@ -3,7 +3,7 @@ def test_divide_images(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 4, 6, 8, 0], [0, 4, 6, 8, 0], @@ -11,7 +11,7 @@ def test_divide_images(): [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [1, 1, 1, 1, 1], [1, 2, 3, 2, 1], [1, 2, 3, 2, 1], @@ -19,7 +19,7 @@ def test_divide_images(): [1, 1, 1, 1, 1] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 2, 4, 0], [0, 2, 2, 4, 0], @@ -32,6 +32,6 @@ def test_divide_images(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a, b, 0.0001)) diff --git a/tests/test_downsample_xy_half_median.py b/tests/test_downsample_xy_half_median.py index eeabb15a..d1172f91 100644 --- a/tests/test_downsample_xy_half_median.py +++ b/tests/test_downsample_xy_half_median.py @@ -2,28 +2,28 @@ import numpy as np def test_downsample_xy_by_half_median(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [-3, 0, 1, 2], [0, 5, 2, 7], [0, 1, 3, 4], [1, 6, 4, 8] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 2], [1, 4] ])) result = cle.downsample_slice_by_slice_half_median(test1) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) def test_resample_downsample_3d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [-3, 0, 1, 2], [0, 5, 2, 7], @@ -47,7 +47,7 @@ def test_resample_downsample_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 2], [1, 4] @@ -65,8 +65,8 @@ def test_resample_downsample_3d(): result = cle.downsample_slice_by_slice_half_median(test1) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_draw_box.py b/tests/test_draw_box.py index f6f9328e..4b7b1f2c 100644 --- a/tests/test_draw_box.py +++ b/tests/test_draw_box.py @@ -3,7 +3,7 @@ def test_draw_box(): - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 2, 2, 0], [0, 2, 2, 2, 0], @@ -17,7 +17,7 @@ def test_draw_box(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_draw_line.py b/tests/test_draw_line.py index 004c930a..ec7795e3 100644 --- a/tests/test_draw_line.py +++ b/tests/test_draw_line.py @@ -3,7 +3,7 @@ def test_draw_line(): - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [2, 2, 0, 0, 0], [2, 2, 2, 0, 0], [0, 2, 2, 2, 0], @@ -17,7 +17,7 @@ def test_draw_line(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_draw_sphere.py b/tests/test_draw_sphere.py index c15a715f..21bbbfac 100644 --- a/tests/test_draw_sphere.py +++ b/tests/test_draw_sphere.py @@ -3,7 +3,7 @@ def test_draw_sphere(): - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 2, 0, 0], [0, 2, 2, 2, 0], @@ -17,7 +17,7 @@ def test_draw_sphere(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_equal.py b/tests/test_equal.py index 85676808..9023d826 100644 --- a/tests/test_equal.py +++ b/tests/test_equal.py @@ -3,7 +3,7 @@ def test_equal(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_equal(): [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [1, 1, 1, 1, 1], [1, 5, 4, 3, 1], [1, 4, 3, 2, 1], @@ -19,7 +19,7 @@ def test_equal(): [1, 1, 1, 1, 1] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 0, 1, 0, 0], @@ -32,6 +32,6 @@ def test_equal(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) \ No newline at end of file diff --git a/tests/test_equal_constant.py b/tests/test_equal_constant.py index 4e72b49c..39f267b4 100644 --- a/tests/test_equal_constant.py +++ b/tests/test_equal_constant.py @@ -3,7 +3,7 @@ def test_equal_constant(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_equal_constant(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 1, 0], @@ -24,6 +24,6 @@ def test_equal_constant(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_erode_box.py b/tests/test_erode_box.py index 5f68acf8..a37280ca 100644 --- a/tests/test_erode_box.py +++ b/tests/test_erode_box.py @@ -3,7 +3,7 @@ def test_erode_box(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], @@ -11,7 +11,7 @@ def test_erode_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -24,6 +24,6 @@ def test_erode_box(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_erode_box_slice_by_slice.py b/tests/test_erode_box_slice_by_slice.py index 43ab6c83..80ecc41e 100644 --- a/tests/test_erode_box_slice_by_slice.py +++ b/tests/test_erode_box_slice_by_slice.py @@ -2,7 +2,7 @@ import numpy as np def test_erode_box_slice_by_slice(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], @@ -24,7 +24,7 @@ def test_erode_box_slice_by_slice(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], @@ -49,8 +49,8 @@ def test_erode_box_slice_by_slice(): result = cle.create(test) cle.erode_box_slice_by_slice(test, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_erode_sphere.py b/tests/test_erode_sphere.py index 1a280d7a..a344d7e0 100644 --- a/tests/test_erode_sphere.py +++ b/tests/test_erode_sphere.py @@ -3,7 +3,7 @@ def test_erode_sphere(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], @@ -11,7 +11,7 @@ def test_erode_sphere(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -24,6 +24,6 @@ def test_erode_sphere(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_erode_sphere_slice_by_slice.py b/tests/test_erode_sphere_slice_by_slice.py index 258cc1c6..4ce6e045 100644 --- a/tests/test_erode_sphere_slice_by_slice.py +++ b/tests/test_erode_sphere_slice_by_slice.py @@ -2,7 +2,7 @@ import numpy as np def test_erode_sphere_slice_by_slice(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], @@ -24,7 +24,7 @@ def test_erode_sphere_slice_by_slice(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], @@ -49,8 +49,8 @@ def test_erode_sphere_slice_by_slice(): result = cle.create(test) cle.erode_sphere_slice_by_slice(test, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_euclidean_distance_from_label_centroid_map.py b/tests/test_euclidean_distance_from_label_centroid_map.py index 901a5b3c..01e3727d 100644 --- a/tests/test_euclidean_distance_from_label_centroid_map.py +++ b/tests/test_euclidean_distance_from_label_centroid_map.py @@ -3,14 +3,14 @@ def test_euclidean_distance_from_label_centroid_map(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 1, 2], [1, 1, 1, 2], [1, 1, 1, 2], [2, 2, 2, 2] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1.4142135, 1, 1.4142135, 2.3079278], [1, 0, 1, 1.4285713], [1.4142135, 1, 1.4142135, 0.86896616], @@ -21,8 +21,8 @@ def test_euclidean_distance_from_label_centroid_map(): result = cle.euclidean_distance_from_label_centroid_map(labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_exclude_labels.py b/tests/test_exclude_labels.py index 1669c8e6..3269c72a 100644 --- a/tests/test_exclude_labels.py +++ b/tests/test_exclude_labels.py @@ -3,7 +3,7 @@ def test_exclude_labels_2d(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [0, 0, 2, 0, 0, 0, 0], [0, 1, 2, 0, 7, 0, 0], @@ -14,7 +14,7 @@ def test_exclude_labels_2d(): ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [0, 0, 2, 0, 0, 0, 0], [0, 1, 2, 0, 0, 0, 0], @@ -25,12 +25,12 @@ def test_exclude_labels_2d(): ])) - flaglist = cle.push_zyx(np.asarray([[0, 0, 0, 1, 1, 0, 0, 1, 0]])) + flaglist = cle.push(np.asarray([[0, 0, 0, 1, 1, 0, 0, 1, 0]])) gpu_output = cle.exclude_labels(flaglist, gpu_input) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) @@ -39,7 +39,7 @@ def test_exclude_labels_2d(): def test_exclude_labels_3d(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [ [0, 0, 2, 0, 0, 0, 0], [0, 1, 2, 0, 7, 0, 0], @@ -51,7 +51,7 @@ def test_exclude_labels_3d(): ] ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [ [0, 0, 2, 0, 0, 0, 0], [0, 1, 2, 0, 0, 0, 0], @@ -63,12 +63,12 @@ def test_exclude_labels_3d(): ] ])) - flaglist = cle.push_zyx(np.asarray([[0, 0, 0, 1, 1, 0, 0, 1, 0]])) + flaglist = cle.push(np.asarray([[0, 0, 0, 1, 1, 0, 0, 1, 0]])) gpu_output = cle.exclude_labels(flaglist, gpu_input) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_exclude_labels_on_edges.py b/tests/test_exclude_labels_on_edges.py index 9228ef59..fc48f21f 100644 --- a/tests/test_exclude_labels_on_edges.py +++ b/tests/test_exclude_labels_on_edges.py @@ -3,7 +3,7 @@ def test_exclude_labels_on_edges_2d(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [0, 0, 2, 0, 0, 0, 0], [0, 1, 2, 0, 7, 0, 0], @@ -14,7 +14,7 @@ def test_exclude_labels_on_edges_2d(): ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 3, 0, 0], @@ -27,8 +27,8 @@ def test_exclude_labels_on_edges_2d(): gpu_output = cle.exclude_labels_on_edges(gpu_input) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) @@ -36,7 +36,7 @@ def test_exclude_labels_on_edges_2d(): assert (np.array_equal(a, b)) def test_exclude_labels_on_edges_3d(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [ [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], @@ -61,7 +61,7 @@ def test_exclude_labels_on_edges_3d(): ] ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [ [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], @@ -88,8 +88,8 @@ def test_exclude_labels_on_edges_3d(): gpu_output = cle.exclude_labels_on_edges(gpu_input) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) @@ -111,7 +111,7 @@ def test_exclude_labels_on_edges_blobs(): print("Loaded image size: " + str(image.shape)) # push image to GPU memory - input = cle.push_zyx(image) + input = cle.push(image) print("Image size in GPU: " + str(input.shape)) # process the image diff --git a/tests/test_exclude_labels_out_of_size_range.py b/tests/test_exclude_labels_out_of_size_range.py index 6bcb84cc..20f50c08 100644 --- a/tests/test_exclude_labels_out_of_size_range.py +++ b/tests/test_exclude_labels_out_of_size_range.py @@ -3,7 +3,7 @@ def test_exclude_labels_out_of_size_range_2d(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [1, 1, 2, 0, 3, 3], [1, 1, 2, 0, 3, 3], [0, 0, 0, 0, 0, 0], @@ -11,7 +11,7 @@ def test_exclude_labels_out_of_size_range_2d(): [4, 4, 5, 6, 6, 6] ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [1, 1, 0, 0, 2, 2], [1, 1, 0, 0, 2, 2], [0, 0, 0, 0, 0, 0], @@ -21,8 +21,8 @@ def test_exclude_labels_out_of_size_range_2d(): gpu_output = cle.exclude_labels_outside_size_range(gpu_input, gpu_input, minimum_size=4, maximum_size=5) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_exclude_labels_with_values_out_of_range.py b/tests/test_exclude_labels_with_values_out_of_range.py index 1c55a9d8..1fe02dff 100644 --- a/tests/test_exclude_labels_with_values_out_of_range.py +++ b/tests/test_exclude_labels_with_values_out_of_range.py @@ -3,13 +3,13 @@ def test_exclude_labels_with_values_out_of_range_2d(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [0, 1, 2, 3, 4, 5, 6] ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [0, 1, 2, 3, 0, 0, 0] @@ -17,8 +17,8 @@ def test_exclude_labels_with_values_out_of_range_2d(): gpu_output = cle.exclude_labels_with_values_out_of_range(gpu_input, gpu_input, minimum_value_range=0, maximum_value_range=3) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_exclude_labels_with_values_within_range.py b/tests/test_exclude_labels_with_values_within_range.py index 506e918a..90f1f3cc 100644 --- a/tests/test_exclude_labels_with_values_within_range.py +++ b/tests/test_exclude_labels_with_values_within_range.py @@ -3,13 +3,13 @@ def test_exclude_labels_with_values_within_range_2d(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [0, 1, 2, 3, 4, 5, 6] ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [0, 0, 0, 0, 1, 2, 3] @@ -17,8 +17,8 @@ def test_exclude_labels_with_values_within_range_2d(): gpu_output = cle.exclude_labels_with_values_within_range(gpu_input, gpu_input, minimum_value_range=0, maximum_value_range=3) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_exponential.py b/tests/test_exponential.py index 24303bfb..70443025 100644 --- a/tests/test_exponential.py +++ b/tests/test_exponential.py @@ -3,7 +3,7 @@ def test_exponential(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 2, 0], [0, 2, 2, 3, 0], @@ -11,7 +11,7 @@ def test_exponential(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1, 1, 1, 1, 1], [1, 2.7182817, 2.7182817, 7.389056, 1], [1, 7.389056, 7.389056, 20.085537, 1], @@ -24,7 +24,7 @@ def test_exponential(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a, b, atol=0.00001)) diff --git a/tests/test_extend_labeling_via_voronoi.py b/tests/test_extend_labeling_via_voronoi.py index c01474d1..e57ffb44 100644 --- a/tests/test_extend_labeling_via_voronoi.py +++ b/tests/test_extend_labeling_via_voronoi.py @@ -3,7 +3,7 @@ def test_extend_labeling_via_voronoi(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [ [0, 0, 0, 0, 3, 3], [0, 4, 0, 0, 3, 3], @@ -14,7 +14,7 @@ def test_extend_labeling_via_voronoi(): ] ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [ [4, 4, 4, 3, 3, 3], [4, 4, 4, 3, 3, 3], @@ -27,8 +27,8 @@ def test_extend_labeling_via_voronoi(): gpu_output = cle.extend_labeling_via_voronoi(gpu_input) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_extend_labels_with_maximum_radius.py b/tests/test_extend_labels_with_maximum_radius.py index 178fdba9..a2bd7c3b 100644 --- a/tests/test_extend_labels_with_maximum_radius.py +++ b/tests/test_extend_labels_with_maximum_radius.py @@ -3,7 +3,7 @@ def test_extend_labels_with_maximum_radius_2d(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [1, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0], @@ -14,7 +14,7 @@ def test_extend_labels_with_maximum_radius_2d(): ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [1, 1, 0, 0, 2, 2], [1, 1, 0, 0, 2, 2], @@ -27,8 +27,8 @@ def test_extend_labels_with_maximum_radius_2d(): gpu_output = cle.extend_labels_with_maximum_radius(gpu_input, radius=1) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) @@ -36,7 +36,7 @@ def test_extend_labels_with_maximum_radius_2d(): assert (np.array_equal(a, b)) def test_extend_labels_with_maximum_radius_3d(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [ [0, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0], @@ -54,7 +54,7 @@ def test_extend_labels_with_maximum_radius_3d(): ] ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [ [1, 1, 0, 0, 2, 2], [1, 1, 0, 0, 2, 2], @@ -74,8 +74,8 @@ def test_extend_labels_with_maximum_radius_3d(): gpu_output = cle.extend_labels_with_maximum_radius(gpu_input, radius=1) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_flag_existing_labels.py b/tests/test_flag_existing_labels.py index 1e820e8a..a1e049a3 100644 --- a/tests/test_flag_existing_labels.py +++ b/tests/test_flag_existing_labels.py @@ -3,7 +3,7 @@ def test_flag_existing_labels(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [ [1, 2, 3], [1, 6, 6], @@ -11,14 +11,14 @@ def test_flag_existing_labels(): ] ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [0, 1, 1, 1, 0, 0, 1, 1, 1, 1] ])) gpu_output = cle.flag_existing_labels(gpu_input) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_flip.py b/tests/test_flip.py index e02ba2c2..fbe51aba 100644 --- a/tests/test_flip.py +++ b/tests/test_flip.py @@ -2,7 +2,7 @@ import numpy as np def test_flip(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 0, 0], [0, 1, 2, 0, 0], @@ -10,7 +10,7 @@ def test_flip(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 2, 1, 0], [0, 0, 2, 1, 0], @@ -23,7 +23,7 @@ def test_flip(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_gamma_correction.py b/tests/test_gamma_correction.py index 9f7b4239..f99a1aa8 100644 --- a/tests/test_gamma_correction.py +++ b/tests/test_gamma_correction.py @@ -3,7 +3,7 @@ def test_gamma_correction(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 50, 0, 5, 0], [0, 0, 100, 0, 0], @@ -14,7 +14,7 @@ def test_gamma_correction(): result = cle.create(test) cle.gamma_correction(test, result, 0.5) - a = cle.pull_zyx(result) + a = cle.pull(result) print(a) print(np.mean(a)) diff --git a/tests/test_gaussian_blur.py b/tests/test_gaussian_blur.py index ae10cd34..5e121edb 100644 --- a/tests/test_gaussian_blur.py +++ b/tests/test_gaussian_blur.py @@ -3,7 +3,7 @@ def test_gaussian_blur(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 100, 0, 0], @@ -16,7 +16,7 @@ def test_gaussian_blur(): print(result) - a = cle.pull_zyx(result) + a = cle.pull(result) assert (np.min(a) > 0) assert (np.max(a) > 15.9) assert (np.max(a) < 16) diff --git a/tests/test_generate_angle_matrix.py b/tests/test_generate_angle_matrix.py index 9650d167..13a339d0 100644 --- a/tests/test_generate_angle_matrix.py +++ b/tests/test_generate_angle_matrix.py @@ -3,7 +3,7 @@ def test_generate_angle_matrix(): - input = cle.push_zyx(np.asarray([ + input = cle.push(np.asarray([ [5, 0, 4, 0, 3], [0, 6, 0, 0, 0], @@ -12,7 +12,7 @@ def test_generate_angle_matrix(): [8, 0, 9, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0., -45., 90., 45., 45., 0., -45., -90.] ])) @@ -25,8 +25,8 @@ def test_generate_angle_matrix(): angle_from_1 = cle.crop(angle_matrix_degrees, start_x=2, start_y=1, width=8, height=1) - a = cle.pull_zyx(angle_from_1) - b = cle.pull_zyx(reference) + a = cle.pull(angle_from_1) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_generate_binary_overlap_matrix.py b/tests/test_generate_binary_overlap_matrix.py index e29676a9..e32dd4f0 100644 --- a/tests/test_generate_binary_overlap_matrix.py +++ b/tests/test_generate_binary_overlap_matrix.py @@ -3,7 +3,7 @@ def test_generate_binary_overlap_matrix_2d(): - gpu_input1 = cle.push_zyx(np.asarray([ + gpu_input1 = cle.push(np.asarray([ [1, 1, 0, 0, 0], [1, 1, 0, 3, 0], @@ -13,7 +13,7 @@ def test_generate_binary_overlap_matrix_2d(): ])) - gpu_input2 = cle.push_zyx(np.asarray([ + gpu_input2 = cle.push(np.asarray([ [1, 1, 2, 2, 2], [1, 1, 2, 2, 2], @@ -24,7 +24,7 @@ def test_generate_binary_overlap_matrix_2d(): ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [0, 1, 1], [0, 1, 0], @@ -36,8 +36,8 @@ def test_generate_binary_overlap_matrix_2d(): gpu_binary_overlap_matrix = cle.generate_binary_overlap_matrix(gpu_input1, gpu_input2) - a = cle.pull_zyx(gpu_binary_overlap_matrix) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_binary_overlap_matrix) + b = cle.pull(gpu_reference) print(a) print(b) @@ -46,7 +46,7 @@ def test_generate_binary_overlap_matrix_2d(): def test_generate_binary_overlap_matrix_3d(): - gpu_input1 = cle.push_zyx(np.asarray([ + gpu_input1 = cle.push(np.asarray([ [ [1, 1, 0, 0, 0], [1, 1, 0, 3, 0], @@ -56,7 +56,7 @@ def test_generate_binary_overlap_matrix_3d(): ] ])) - gpu_input2 = cle.push_zyx(np.asarray([ + gpu_input2 = cle.push(np.asarray([ [ [1, 1, 2, 2, 2], [1, 1, 2, 2, 2], @@ -66,7 +66,7 @@ def test_generate_binary_overlap_matrix_3d(): ] ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [0, 1, 1], [0, 1, 0], @@ -78,8 +78,8 @@ def test_generate_binary_overlap_matrix_3d(): gpu_binary_overlap_matrix = cle.generate_binary_overlap_matrix(gpu_input1, gpu_input2) - a = cle.pull_zyx(gpu_binary_overlap_matrix) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_binary_overlap_matrix) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_generate_distance_matrix.py b/tests/test_generate_distance_matrix.py index 1031b0a9..f44ba706 100644 --- a/tests/test_generate_distance_matrix.py +++ b/tests/test_generate_distance_matrix.py @@ -3,7 +3,7 @@ def test_generate_distance_matrix(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 0, 3, 0], @@ -13,7 +13,7 @@ def test_generate_distance_matrix(): ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [0., 0. , 0. , 0. , 0. ], [0., 0. , 2.236068 , 2. , 4.2426405 ], [0., 2.236068 , 0. , 2.236068 , 2.236068 ], @@ -26,8 +26,8 @@ def test_generate_distance_matrix(): gpu_pointlist = cle.labelled_spots_to_pointlist(gpu_input) gpu_distance_matrix = cle.generate_distance_matrix(gpu_pointlist, gpu_pointlist) - a = cle.pull_zyx(gpu_distance_matrix) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_distance_matrix) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_generate_n_nearest_neighbor_matrix.py b/tests/test_generate_n_nearest_neighbor_matrix.py index 8ba91fea..cf47d2ea 100644 --- a/tests/test_generate_n_nearest_neighbor_matrix.py +++ b/tests/test_generate_n_nearest_neighbor_matrix.py @@ -3,12 +3,12 @@ def test_generate_n_nearest_neighbors_matrix(): - positions = cle.push_zyx(np.asarray([ + positions = cle.push(np.asarray([ [1, 1, 4, 4], [1, 4, 4, 1] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 0], [0, 1, 0, 0, 1, 0], @@ -25,8 +25,8 @@ def test_generate_n_nearest_neighbors_matrix(): result = cle.touch_matrix_to_mesh(positions, n_nearest_neighbor_matrix, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_generate_proximal_neighbor_matrix.py b/tests/test_generate_proximal_neighbor_matrix.py index d29f3aeb..7731dc23 100644 --- a/tests/test_generate_proximal_neighbor_matrix.py +++ b/tests/test_generate_proximal_neighbor_matrix.py @@ -3,12 +3,12 @@ def test_generate_proximal_neighbors_matrix(): - positions = cle.push_zyx(np.asarray([ + positions = cle.push(np.asarray([ [1, 1, 4, 4], [1, 4, 4, 1] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 0], [0, 1, 0, 0, 1, 0], @@ -25,8 +25,8 @@ def test_generate_proximal_neighbors_matrix(): result = cle.touch_matrix_to_mesh(positions, n_nearest_neighbor_matrix, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -36,12 +36,12 @@ def test_generate_proximal_neighbors_matrix(): def test_generate_distal_neighbors_matrix(): - positions = cle.push_zyx(np.asarray([ + positions = cle.push(np.asarray([ [1, 1, 5, 5], [1, 5, 5, 1] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 0, 0, 1], [0, 0, 1, 1, 0], @@ -57,8 +57,8 @@ def test_generate_distal_neighbors_matrix(): result = cle.touch_matrix_to_mesh(positions, n_nearest_neighbor_matrix, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_generate_touch_matrix.py b/tests/test_generate_touch_matrix.py index 125ac988..f158ebe9 100644 --- a/tests/test_generate_touch_matrix.py +++ b/tests/test_generate_touch_matrix.py @@ -3,7 +3,7 @@ def test_generate_touch_matrix(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [1, 1, 0, 0, 0], [1, 1, 0, 3, 0], @@ -13,7 +13,7 @@ def test_generate_touch_matrix(): ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [0, 1, 1, 1, 1], [0, 0, 1, 0, 0], @@ -25,8 +25,8 @@ def test_generate_touch_matrix(): gpu_touch_matrix = cle.generate_touch_matrix(gpu_input) - a = cle.pull_zyx(gpu_touch_matrix) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_touch_matrix) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_gradient_x.py b/tests/test_gradient_x.py index a749bbb2..c67d96e9 100644 --- a/tests/test_gradient_x.py +++ b/tests/test_gradient_x.py @@ -3,7 +3,7 @@ def test_gradient_x(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 0, 0], [0, 1, 2, 0, 0], @@ -11,7 +11,7 @@ def test_gradient_x(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [1, 2, -1, -2, 0], [1, 2, -1, -2, 0], @@ -22,8 +22,8 @@ def test_gradient_x(): result = cle.create(test) cle.gradient_x(test, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) \ No newline at end of file diff --git a/tests/test_gradient_y.py b/tests/test_gradient_y.py index e7bc2a7d..c94d2b41 100644 --- a/tests/test_gradient_y.py +++ b/tests/test_gradient_y.py @@ -3,7 +3,7 @@ def test_gradient_y(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 0, 0], [0, 1, 2, 0, 0], @@ -11,7 +11,7 @@ def test_gradient_y(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 1, 2, 0, 0], [0, 1, 2, 0, 0], [0, 0, 1, 0, 0], @@ -22,8 +22,8 @@ def test_gradient_y(): result = cle.create(test) cle.gradient_y(test, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_gradient_z.py b/tests/test_gradient_z.py index 3cb8d49f..eebd362e 100644 --- a/tests/test_gradient_z.py +++ b/tests/test_gradient_z.py @@ -2,7 +2,7 @@ import numpy as np def test_gradient_z(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], @@ -24,7 +24,7 @@ def test_gradient_z(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 0, 0, 0, 0], [1, 0, 0, -1, 0], @@ -49,8 +49,8 @@ def test_gradient_z(): result = cle.create(test) cle.gradient_z(test, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_greater.py b/tests/test_greater.py index 70f72bd5..a2b6c96c 100644 --- a/tests/test_greater.py +++ b/tests/test_greater.py @@ -3,14 +3,14 @@ def test_greater_2d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 3, 3, 3, 0], [0, 3, 3, 3, 0], @@ -18,7 +18,7 @@ def test_greater_2d(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 1, 0], @@ -29,15 +29,15 @@ def test_greater_2d(): result = cle.create(test1) cle.greater(test1, test2, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) print("ok greater_or_equal") def test_greater_3d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [0, 1, 2, 3, 0], [0, 3, 3, 4, 0] @@ -46,7 +46,7 @@ def test_greater_3d(): [0, 0, 0, 0, 0] ] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [ [0, 3, 3, 3, 0], [0, 3, 3, 3, 0], @@ -56,7 +56,7 @@ def test_greater_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 0, 0, 0, 0], [0, 0, 0, 1, 0] @@ -69,8 +69,8 @@ def test_greater_3d(): result = cle.create(test1) cle.greater(test1, test2, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_greater_constant.py b/tests/test_greater_constant.py index 3d2bc4fe..06e6dff2 100644 --- a/tests/test_greater_constant.py +++ b/tests/test_greater_constant.py @@ -3,7 +3,7 @@ def test_greater_constant(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_greater_constant(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], @@ -24,7 +24,7 @@ def test_greater_constant(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_greater_or_equal.py b/tests/test_greater_or_equal.py index da41b4a4..9076741b 100644 --- a/tests/test_greater_or_equal.py +++ b/tests/test_greater_or_equal.py @@ -3,14 +3,14 @@ def test_greater_or_equal_2d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 3, 3, 3, 0], [0, 3, 3, 3, 0], @@ -18,7 +18,7 @@ def test_greater_or_equal_2d(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1, 1, 1, 1, 1], [1, 0, 0, 1, 1], [1, 1, 1, 1, 1], @@ -29,15 +29,15 @@ def test_greater_or_equal_2d(): result = cle.create(test1) cle.greater_or_equal(test1, test2, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) def test_greater_or_equal_3d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], @@ -46,7 +46,7 @@ def test_greater_or_equal_3d(): [0, 0, 0, 0, 0] ] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [ [0, 3, 3, 3, 0], [0, 3, 3, 3, 0] @@ -56,7 +56,7 @@ def test_greater_or_equal_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [1, 0, 0, 1, 1], [1, 1, 1, 1, 1] @@ -69,8 +69,8 @@ def test_greater_or_equal_3d(): result = cle.create(test1) cle.greater_or_equal(test1, test2, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_greater_or_equal_constant.py b/tests/test_greater_or_equal_constant.py index 692fc967..f491b1c1 100644 --- a/tests/test_greater_or_equal_constant.py +++ b/tests/test_greater_or_equal_constant.py @@ -3,7 +3,7 @@ def test_greater_or_equal_constant(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_greater_or_equal_constant(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 1, 0], @@ -24,7 +24,7 @@ def test_greater_or_equal_constant(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_histogram.py b/tests/test_histogram.py index 07da7c76..b51a59c5 100644 --- a/tests/test_histogram.py +++ b/tests/test_histogram.py @@ -2,7 +2,7 @@ import numpy as np def test_histogram(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [1, 2, 4, 4, 2, 3], [3, 3, 4, 4, 5, 5] ])) @@ -13,11 +13,11 @@ def test_histogram(): print(my_histogram) - a = cle.pull_zyx(my_histogram) + a = cle.pull(my_histogram) assert (np.allclose(a, ref_histogram)) def test_histogram_3d(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [ [1, 2, 4, 4, 2, 3] ], [ @@ -31,12 +31,12 @@ def test_histogram_3d(): print(my_histogram) - a = cle.pull_zyx(my_histogram) + a = cle.pull(my_histogram) assert (np.allclose(a, ref_histogram)) def test_histogram_3d_2(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [ [1, 2, 4], [4, 2, 3] @@ -52,7 +52,7 @@ def test_histogram_3d_2(): print(my_histogram) - a = cle.pull_zyx(my_histogram) + a = cle.pull(my_histogram) assert (np.allclose(a, ref_histogram)) def test_histogram_against_scikit_image(): @@ -64,11 +64,11 @@ def test_histogram_against_scikit_image(): print(str(hist)) - gpu_image = cle.push_zyx(image) + gpu_image = cle.push(image) gpu_hist = cle.histogram(gpu_image, num_bins=256) - print(str(cle.pull_zyx(gpu_hist))) + print(str(cle.pull(gpu_hist))) - assert (np.allclose(hist, cle.pull_zyx(gpu_hist))) + assert (np.allclose(hist, cle.pull(gpu_hist))) diff --git a/tests/test_invert.py b/tests/test_invert.py index 42765420..c0ad08c8 100644 --- a/tests/test_invert.py +++ b/tests/test_invert.py @@ -3,12 +3,12 @@ def test_grreater_or_equal(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, -6, 0, -3, 0], [0, 1, 2, 3, 0], ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 6, 0, 3, 0], [0, -1, -2, -3, 0], ])) @@ -16,8 +16,8 @@ def test_grreater_or_equal(): result = cle.create(test) cle.invert(test, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_jaccard_index.py b/tests/test_jaccard_index.py index b41b34d5..b635dbb2 100644 --- a/tests/test_jaccard_index.py +++ b/tests/test_jaccard_index.py @@ -3,12 +3,12 @@ def test_jaccard_index_2d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [0, 1, 1, 0, 0], [0, 1, 1, 0, 0] ])) @@ -18,12 +18,12 @@ def test_jaccard_index_2d(): assert j == 0.5 def test_accard_index_3d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [[0, 0, 0], [0, 0, 0]], [[0, 1, 1], [0, 1, 0]] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [[0, 1, 1], [0, 1, 0]], [[0, 1, 1], [0, 1, 0]] ])) diff --git a/tests/test_label_maximum_extension_map.py b/tests/test_label_maximum_extension_map.py index 6521513e..f509afec 100644 --- a/tests/test_label_maximum_extension_map.py +++ b/tests/test_label_maximum_extension_map.py @@ -3,13 +3,13 @@ def test_label_label_maximum_extension_map_2d(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2], [1, 0, 0], [3, 3, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0.74535596, 0.74535596, 0], [0.74535596, 0, 0], [0.5, 0.5, 0] @@ -18,8 +18,8 @@ def test_label_label_maximum_extension_map_2d(): result = cle.label_maximum_extension_map(labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -29,7 +29,7 @@ def test_label_label_maximum_extension_map_2d(): def test_label_label_maximum_extension_map_3d(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [ [1, 1, 2], ], [ @@ -39,7 +39,7 @@ def test_label_label_maximum_extension_map_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0.74535596, 0.74535596, 0], ], [ @@ -52,8 +52,8 @@ def test_label_label_maximum_extension_map_3d(): result = cle.label_maximum_extension_map(labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_label_maximum_extension_ratio_map.py b/tests/test_label_maximum_extension_ratio_map.py index 2d1a5147..d7cf3e93 100644 --- a/tests/test_label_maximum_extension_ratio_map.py +++ b/tests/test_label_maximum_extension_ratio_map.py @@ -3,13 +3,13 @@ def test_label_label_maximum_extension_ratio_map_2d(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2], [1, 0, 2], [3, 3, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1.1396203, 1.1396203, 1], [1.1396203, 0, 1], [1, 1, 0] @@ -18,8 +18,8 @@ def test_label_label_maximum_extension_ratio_map_2d(): result = cle.label_maximum_extension_ratio_map(labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -29,7 +29,7 @@ def test_label_label_maximum_extension_ratio_map_2d(): def test_label_label_maximum_extension_ratio_map_3d(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [ [1, 1, 2], ], [ @@ -39,7 +39,7 @@ def test_label_label_maximum_extension_ratio_map_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [1.1396203, 1.1396203, 1], ], [ @@ -52,8 +52,8 @@ def test_label_label_maximum_extension_ratio_map_3d(): result = cle.label_maximum_extension_ratio_map(labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_label_maximum_intensity_map.py b/tests/test_label_maximum_intensity_map.py index c0bba441..c52e4099 100644 --- a/tests/test_label_maximum_intensity_map.py +++ b/tests/test_label_maximum_intensity_map.py @@ -3,19 +3,19 @@ def test_label_maximum_intensity_map_2d(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [1, 1, 2], [4, 0, 0], [5, 3, 0] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2], [1, 0, 0], [3, 3, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [4, 4, 2], [4, 0, 0], [5, 5, 0] @@ -24,8 +24,8 @@ def test_label_maximum_intensity_map_2d(): result = cle.label_maximum_intensity_map(intensity, labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -36,7 +36,7 @@ def test_label_maximum_intensity_map_2d(): def test_label_maximum_intensity_map_3d(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [ [1, 1, 2], ],[ @@ -46,7 +46,7 @@ def test_label_maximum_intensity_map_3d(): ] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [ [1, 1, 2], ], [ @@ -56,7 +56,7 @@ def test_label_maximum_intensity_map_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [4, 4, 2], ], [ @@ -69,8 +69,8 @@ def test_label_maximum_intensity_map_3d(): result = cle.label_maximum_intensity_map(intensity, labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_label_mean_extension_map.py b/tests/test_label_mean_extension_map.py index d1f4b3d5..cac9f42f 100644 --- a/tests/test_label_mean_extension_map.py +++ b/tests/test_label_mean_extension_map.py @@ -3,13 +3,13 @@ def test_label_label_mean_extension_map_2d(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2], [1, 0, 0], [3, 3, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0.65403885, 0.65403885, 0], [0.65403885, 0, 0], [0.5, 0.5, 0] @@ -18,8 +18,8 @@ def test_label_label_mean_extension_map_2d(): result = cle.label_mean_extension_map(labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -29,7 +29,7 @@ def test_label_label_mean_extension_map_2d(): def test_label_label_mean_extension_map_3d(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [ [1, 1, 2], ], [ @@ -39,7 +39,7 @@ def test_label_label_mean_extension_map_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0.65403885, 0.65403885, 0], ], [ @@ -52,8 +52,8 @@ def test_label_label_mean_extension_map_3d(): result = cle.label_mean_extension_map(labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_label_mean_intensity_map.py b/tests/test_label_mean_intensity_map.py index 889e2e44..d27135dd 100644 --- a/tests/test_label_mean_intensity_map.py +++ b/tests/test_label_mean_intensity_map.py @@ -3,19 +3,19 @@ def test_label_mean_intensity_map_2d(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [1, 1, 2], [4, 0, 0], [5, 3, 0] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2], [1, 0, 0], [3, 3, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [2, 2, 2], [2, 0, 0], [4, 4, 0] @@ -24,8 +24,8 @@ def test_label_mean_intensity_map_2d(): result = cle.label_mean_intensity_map(intensity, labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -36,7 +36,7 @@ def test_label_mean_intensity_map_2d(): def test_label_mean_intensity_map_3d(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [ [1, 1, 2], ],[ @@ -46,7 +46,7 @@ def test_label_mean_intensity_map_3d(): ] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [ [1, 1, 2], ], [ @@ -56,7 +56,7 @@ def test_label_mean_intensity_map_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [2, 2, 2], ], [ @@ -69,8 +69,8 @@ def test_label_mean_intensity_map_3d(): result = cle.label_mean_intensity_map(intensity, labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_label_minimum_intensity_map.py b/tests/test_label_minimum_intensity_map.py index 0125dc49..ee8ac9ae 100644 --- a/tests/test_label_minimum_intensity_map.py +++ b/tests/test_label_minimum_intensity_map.py @@ -3,19 +3,19 @@ def test_label_minimum_intensity_map_2d(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [1, 1, 2], [4, 0, 0], [5, 3, 0] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2], [1, 0, 0], [3, 3, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1, 1, 2], [1, 0, 0], [3, 3, 0] @@ -24,8 +24,8 @@ def test_label_minimum_intensity_map_2d(): result = cle.label_minimum_intensity_map(intensity, labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -36,7 +36,7 @@ def test_label_minimum_intensity_map_2d(): def test_label_minimum_intensity_map_3d(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [ [1, 1, 2], ],[ @@ -46,7 +46,7 @@ def test_label_minimum_intensity_map_3d(): ] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [ [1, 1, 2], ], [ @@ -56,7 +56,7 @@ def test_label_minimum_intensity_map_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [1, 1, 2], ], [ @@ -69,8 +69,8 @@ def test_label_minimum_intensity_map_3d(): result = cle.label_minimum_intensity_map(intensity, labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_label_pixelcount_map.py b/tests/test_label_pixelcount_map.py index f98b52b1..8e34e8d8 100644 --- a/tests/test_label_pixelcount_map.py +++ b/tests/test_label_pixelcount_map.py @@ -3,13 +3,13 @@ def test_label_pixel_count_map(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2], [1, 0, 0], [3, 3, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [3, 3, 1], [3, 0, 0], [2, 2, 0] @@ -18,8 +18,8 @@ def test_label_pixel_count_map(): result = cle.label_pixel_count_map(labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -29,7 +29,7 @@ def test_label_pixel_count_map(): def test_label_pixel_count_map_3d(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [ [1, 1, 2], ], [ @@ -39,7 +39,7 @@ def test_label_pixel_count_map_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [3, 3, 1], ], [ @@ -52,8 +52,8 @@ def test_label_pixel_count_map_3d(): result = cle.label_pixel_count_map(labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_label_spots.py b/tests/test_label_spots.py index 99dff1fa..f85229a2 100644 --- a/tests/test_label_spots.py +++ b/tests/test_label_spots.py @@ -3,7 +3,7 @@ def test_label_spots_2d(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 0, 1, 0], @@ -13,7 +13,7 @@ def test_label_spots_2d(): ]).T) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 0, 3, 0], @@ -25,8 +25,8 @@ def test_label_spots_2d(): gpu_output = cle.label_spots(gpu_input) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) @@ -35,7 +35,7 @@ def test_label_spots_2d(): def test_label_spots_3d(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [ [0, 0, 0, 0, 0], [0, 1, 0, 1, 0], @@ -49,7 +49,7 @@ def test_label_spots_3d(): ] ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [ [0, 0, 0, 0, 0], [0, 1, 0, 2, 0], @@ -65,8 +65,8 @@ def test_label_spots_3d(): gpu_output = cle.label_spots(gpu_input) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_label_standard_deviation_intensity_map.py b/tests/test_label_standard_deviation_intensity_map.py index 184e59b1..b5ef59ff 100644 --- a/tests/test_label_standard_deviation_intensity_map.py +++ b/tests/test_label_standard_deviation_intensity_map.py @@ -3,19 +3,19 @@ def test_label_standard_deviation_intensity_map_2d(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [1, 1, 2], [4, 0, 0], [5, 3, 0] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2], [1, 0, 0], [3, 3, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1.4142, 1.4142, 0], [1.4142, 0, 0], [1, 1, 0] @@ -24,8 +24,8 @@ def test_label_standard_deviation_intensity_map_2d(): result = cle.label_standard_deviation_intensity_map(intensity, labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -36,7 +36,7 @@ def test_label_standard_deviation_intensity_map_2d(): def test_label_standard_deviation_intensity_map_3d(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [ [1, 1, 2], ],[ @@ -46,7 +46,7 @@ def test_label_standard_deviation_intensity_map_3d(): ] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [ [1, 1, 2], ], [ @@ -56,7 +56,7 @@ def test_label_standard_deviation_intensity_map_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [1.4142, 1.4142, 0], ], [ @@ -69,8 +69,8 @@ def test_label_standard_deviation_intensity_map_3d(): result = cle.label_standard_deviation_intensity_map(intensity, labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_labelled_spots_to_pointlist.py b/tests/test_labelled_spots_to_pointlist.py index c7fd5d3f..f1ac306a 100644 --- a/tests/test_labelled_spots_to_pointlist.py +++ b/tests/test_labelled_spots_to_pointlist.py @@ -3,7 +3,7 @@ def test_labelled_spots_to_pointlist(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 0, 3, 0], @@ -13,7 +13,7 @@ def test_labelled_spots_to_pointlist(): ]).T) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [1, 1], [3, 2], @@ -26,8 +26,8 @@ def test_labelled_spots_to_pointlist(): gpu_output = cle.labelled_spots_to_pointlist(gpu_input) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_laplace_box.py b/tests/test_laplace_box.py index dfb0709b..5874e8b3 100644 --- a/tests/test_laplace_box.py +++ b/tests/test_laplace_box.py @@ -3,7 +3,7 @@ def test_laplace_box(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -11,7 +11,7 @@ def test_laplace_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, -1, -1, -1, 0], [0, -1, 8, -1, 0], @@ -22,8 +22,8 @@ def test_laplace_box(): result = cle.create(test1) cle.laplace_box(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_laplace_diamond.py b/tests/test_laplace_diamond.py index c7e47c4f..4fb77beb 100644 --- a/tests/test_laplace_diamond.py +++ b/tests/test_laplace_diamond.py @@ -3,7 +3,7 @@ def test_laplace_diamond(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -11,7 +11,7 @@ def test_laplace_diamond(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, -1, 0, 0], [0, -1, 4, -1, 0], @@ -22,8 +22,8 @@ def test_laplace_diamond(): result = cle.create(test1) cle.laplace_diamond(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_logarithm.py b/tests/test_logarithm.py index 0bd335f5..2224d224 100644 --- a/tests/test_logarithm.py +++ b/tests/test_logarithm.py @@ -3,12 +3,12 @@ def test_logarithm(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [1, 10], [1000, 100] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 2.3026], [6.9078, 4.6052] ])) @@ -16,8 +16,8 @@ def test_logarithm(): result = cle.create(test1) cle.logarithm(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_mask.py b/tests/test_mask.py index 3b6d013b..6415bced 100644 --- a/tests/test_mask.py +++ b/tests/test_mask.py @@ -3,14 +3,14 @@ def test_mask(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 1, 0, 0], @@ -18,7 +18,7 @@ def test_mask(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 2, 0, 0], [0, 0, 3, 0, 0], @@ -29,8 +29,8 @@ def test_mask(): result = cle.create(test1) cle.mask(test1, test2, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_mask_label.py b/tests/test_mask_label.py index c6681552..b8a24792 100644 --- a/tests/test_mask_label.py +++ b/tests/test_mask_label.py @@ -3,14 +3,14 @@ def test_mask_label(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 1, 3, 0], [0, 2, 1, 3, 0], @@ -18,7 +18,7 @@ def test_mask_label(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 2, 0, 0], [0, 0, 3, 0, 0], @@ -29,8 +29,8 @@ def test_mask_label(): result = cle.create(test1) cle.mask_label(test1, test2, result, 1) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_maximum_box.py b/tests/test_maximum_box.py index 72b2184b..00603f8c 100644 --- a/tests/test_maximum_box.py +++ b/tests/test_maximum_box.py @@ -2,7 +2,7 @@ import numpy as np def test_maximum_box(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -10,7 +10,7 @@ def test_maximum_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], @@ -21,8 +21,8 @@ def test_maximum_box(): result = cle.create(test1) cle.maximum_box(test1, result, 1, 1, 0) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_maximum_distance_of_n_shortest_distances.py b/tests/test_maximum_distance_of_n_shortest_distances.py index 2f8e55e2..69f8173d 100644 --- a/tests/test_maximum_distance_of_n_shortest_distances.py +++ b/tests/test_maximum_distance_of_n_shortest_distances.py @@ -3,7 +3,7 @@ def test_maximum_distance_of_n_shortest_distances(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], @@ -12,7 +12,7 @@ def test_maximum_distance_of_n_shortest_distances(): [0, 0, 0, 2, 2, 2] ])) - reference = cle.push_zyx(np.asarray( + reference = cle.push(np.asarray( [[0, 3, 3, 3]] )) @@ -21,8 +21,8 @@ def test_maximum_distance_of_n_shortest_distances(): maximum_distance_of_n_far_off_distances = cle.maximum_distance_of_n_shortest_distances(distance_matrix, n=1) - a = cle.pull_zyx(maximum_distance_of_n_far_off_distances) - b = cle.pull_zyx(reference) + a = cle.pull(maximum_distance_of_n_far_off_distances) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_maximum_distance_of_touching_neighbors.py b/tests/test_maximum_distance_of_touching_neighbors.py index a9f64489..324ae016 100644 --- a/tests/test_maximum_distance_of_touching_neighbors.py +++ b/tests/test_maximum_distance_of_touching_neighbors.py @@ -3,7 +3,7 @@ def test_maximum_distance_of_touching_neighbors(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], [1, 1, 1, 2, 3, 3], @@ -12,7 +12,7 @@ def test_maximum_distance_of_touching_neighbors(): [0, 0, 0, 2, 2, 2] ])) - reference = cle.push_zyx(np.asarray( + reference = cle.push(np.asarray( [[0, 4.031129, 4.031129, 3.1274989]] )) @@ -22,8 +22,8 @@ def test_maximum_distance_of_touching_neighbors(): maximum_distance_of_touching_neighbors = cle.maximum_distance_of_touching_neighbors(distance_matrix, touch_matrix) - a = cle.pull_zyx(maximum_distance_of_touching_neighbors) - b = cle.pull_zyx(reference) + a = cle.pull(maximum_distance_of_touching_neighbors) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_maximum_image_and_scalar.py b/tests/test_maximum_image_and_scalar.py index c55b06aa..05bb95a5 100644 --- a/tests/test_maximum_image_and_scalar.py +++ b/tests/test_maximum_image_and_scalar.py @@ -3,13 +3,13 @@ def test_maximum_image_and_scalar(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 3, 4, 5, 0], [0, 2, 1, 6, 0], [0, 0, 8, 7, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [2, 3, 4, 5, 2], [2, 2, 2, 6, 2], [2, 2, 8, 7, 2] @@ -18,8 +18,8 @@ def test_maximum_image_and_scalar(): result = cle.create(test1) cle.maximum_image_and_scalar(test1, result, 2) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_maximum_images.py b/tests/test_maximum_images.py index 57206fee..3c2d7b52 100644 --- a/tests/test_maximum_images.py +++ b/tests/test_maximum_images.py @@ -3,14 +3,14 @@ def test_maximum_images(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 1, 3, 0], [0, 2, 1, 3, 0], @@ -18,7 +18,7 @@ def test_maximum_images(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 2, 3, 0], [0, 3, 3, 4, 0], @@ -29,8 +29,8 @@ def test_maximum_images(): result = cle.create(test1) cle.maximum_images(test1, test2, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_maximum_of_all_pixels.py b/tests/test_maximum_of_all_pixels.py index 7e1a35fd..858195b8 100644 --- a/tests/test_maximum_of_all_pixels.py +++ b/tests/test_maximum_of_all_pixels.py @@ -15,12 +15,12 @@ def test_maximum_of_all_pixels(): ] ]) - gpu_input = cle.push_zyx(np_input) + gpu_input = cle.push(np_input) result = cle.maximum_of_all_pixels(gpu_input) print(result) assert (result == 15) - gpu_input = cle.push_zyx(np_input) + gpu_input = cle.push(np_input) result = cle.maximum_of_all_pixels(gpu_input) print(result) assert (result == 15) diff --git a/tests/test_maximum_of_touching_neighbors_map.py b/tests/test_maximum_of_touching_neighbors_map.py index 4839e668..48e47494 100644 --- a/tests/test_maximum_of_touching_neighbors_map.py +++ b/tests/test_maximum_of_touching_neighbors_map.py @@ -3,21 +3,21 @@ def test_maximum_of_touching_neighbors_map(): - intensities = cle.push_zyx(np.asarray([ + intensities = cle.push(np.asarray([ [1, 1, 2, 2], [1, 0, 0, 2], [4, 0, 0, 6], [4, 4, 6, 6] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2, 2], [1, 0, 0, 2], [3, 0, 0, 4], [3, 3, 4, 4], ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [4, 4, 6, 6], [4, 0, 0, 6], [6, 0, 0, 6], @@ -27,8 +27,8 @@ def test_maximum_of_touching_neighbors_map(): result = cle.maximum_of_touching_neighbors_map(intensities, labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_maximum_sphere.py b/tests/test_maximum_sphere.py index a3963cd7..063d0fa7 100644 --- a/tests/test_maximum_sphere.py +++ b/tests/test_maximum_sphere.py @@ -2,7 +2,7 @@ import numpy as np def test_maximum_sphere_1(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [1, 1, 1], [1, 2, 1], [1, 1, 1] @@ -11,7 +11,7 @@ def test_maximum_sphere_1(): test2 = cle.create(test) cle.maximum_sphere(test, test2, 1, 1, 1) - a = cle.pull_zyx(test2) + a = cle.pull(test2) assert (np.min(a) == 1) assert (np.max(a) == 2) @@ -19,20 +19,20 @@ def test_maximum_sphere_1(): # print(test) # print(cle.pull(test)) - a = cle.pull_zyx(test) + a = cle.pull(test) assert (np.min(a) == 5) assert (np.max(a) == 5) assert (np.mean(a) == 5) def test_maximum_sphere_2(): - gpu_a = cle.push_zyx(np.asarray([[1, 1, 1], [1, 2, 1], [1, 1, 1]])) + gpu_a = cle.push(np.asarray([[1, 1, 1], [1, 2, 1], [1, 1, 1]])) gpu_b = cle.create(gpu_a) cle.maximum_sphere(gpu_a, gpu_b, 1, 1, 1) - a = cle.pull_zyx(gpu_b) + a = cle.pull(gpu_b) assert np.min(a) == 1 assert np.max(a) == 2 cle.set(gpu_a, 5) - assert np.all(cle.pull_zyx(gpu_a) == 5) \ No newline at end of file + assert np.all(cle.pull(gpu_a) == 5) \ No newline at end of file diff --git a/tests/test_maximum_x_projection.py b/tests/test_maximum_x_projection.py index c339574e..555e998e 100644 --- a/tests/test_maximum_x_projection.py +++ b/tests/test_maximum_x_projection.py @@ -3,7 +3,7 @@ def test_maximum_x_projection(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -37,7 +37,7 @@ def test_maximum_x_projection(): ] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1, 3, 3, 3, 5], [2, 4, 4, 4, 0], [0, 1, 1, 1, 6], @@ -48,8 +48,8 @@ def test_maximum_x_projection(): result = cle.create(reference) cle.maximum_x_projection(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_maximum_y_projection.py b/tests/test_maximum_y_projection.py index f74202e5..91258c1c 100644 --- a/tests/test_maximum_y_projection.py +++ b/tests/test_maximum_y_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_maximum_y_projection(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -36,7 +36,7 @@ def test_maximum_y_projection(): ] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [5, 4, 6, 8, 10], [5, 4, 6, 8, 10], [5, 4, 6, 8, 10], @@ -47,8 +47,8 @@ def test_maximum_y_projection(): result = cle.create(reference) cle.maximum_y_projection(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_maximum_z_projection.py b/tests/test_maximum_z_projection.py index b8af0e2d..306e0d56 100644 --- a/tests/test_maximum_z_projection.py +++ b/tests/test_maximum_z_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_maximum_z_projection(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -36,7 +36,7 @@ def test_maximum_z_projection(): ] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [9, 8, 10, 7, 10], [8, 9, 10, 7, 10], [8, 10, 7, 9, 10], @@ -47,8 +47,8 @@ def test_maximum_z_projection(): result = cle.create(reference) cle.maximum_z_projection(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_mean_box.py b/tests/test_mean_box.py index d35941d2..35e06a78 100644 --- a/tests/test_mean_box.py +++ b/tests/test_mean_box.py @@ -3,7 +3,7 @@ def test_mean_box(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 9, 0, 0], @@ -11,7 +11,7 @@ def test_mean_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], @@ -22,8 +22,8 @@ def test_mean_box(): result = cle.create(test1) cle.mean_box(test1, result, 1, 1, 0) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_mean_of_all_pixels.py b/tests/test_mean_of_all_pixels.py index 0b596050..68da0b35 100644 --- a/tests/test_mean_of_all_pixels.py +++ b/tests/test_mean_of_all_pixels.py @@ -2,7 +2,7 @@ import numpy as np def test_mean_of_all_pixels_3d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [0, 4, 0, 0, 2], [0, 0, 0, 8, 0], @@ -18,7 +18,7 @@ def test_mean_of_all_pixels_3d(): def test_mean_of_all_pixels_2d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 4, 0, 0, 2], [0, 0, 0, 8, 0], [3, 0, 0, 0, 0], @@ -31,7 +31,7 @@ def test_mean_of_all_pixels_2d(): assert s == 1 def test_mean_of_all_pixels_1d(): - test1 = cle.push_zyx(np.asarray( + test1 = cle.push(np.asarray( [0, 8, 0, 0, 2] )) @@ -41,7 +41,7 @@ def test_mean_of_all_pixels_1d(): def test_mean_of_all_pixels_1d_y(): - test1 = cle.push_zyx(np.asarray( + test1 = cle.push(np.asarray( [[0], [8], [0], [0], [2]] )) @@ -50,7 +50,7 @@ def test_mean_of_all_pixels_1d_y(): assert s == 2 def test_mean_of_all_pixels_1d_z(): - test1 = cle.push_zyx(np.asarray( + test1 = cle.push(np.asarray( [[[0]], [[8]], [[0]], [[0]], [[2]]] )) diff --git a/tests/test_mean_of_touching_neighbors_map.py b/tests/test_mean_of_touching_neighbors_map.py index 505e251e..b95f6d4d 100644 --- a/tests/test_mean_of_touching_neighbors_map.py +++ b/tests/test_mean_of_touching_neighbors_map.py @@ -3,21 +3,21 @@ def test_mean_of_touching_neighbors_map(): - intensities = cle.push_zyx(np.asarray([ + intensities = cle.push(np.asarray([ [1, 1, 2, 2], [1, 0, 0, 2], [4, 0, 0, 6], [4, 4, 6, 6] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2, 2], [1, 0, 0, 2], [3, 0, 0, 4], [3, 3, 4, 4], ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [2.333, 2.333, 3, 3], [2.333, 0, 0, 3], [3.666, 0, 0, 4], @@ -27,8 +27,8 @@ def test_mean_of_touching_neighbors_map(): result = cle.mean_of_touching_neighbors_map(intensities, labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_mean_sphere.py b/tests/test_mean_sphere.py index 3bce9de2..8226b976 100644 --- a/tests/test_mean_sphere.py +++ b/tests/test_mean_sphere.py @@ -2,7 +2,7 @@ import numpy as np def test_mean_sphere(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 9, 0, 0], @@ -10,7 +10,7 @@ def test_mean_sphere(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 1.8, 0, 0], [0, 1.8, 1.8, 1.8, 0], @@ -21,8 +21,8 @@ def test_mean_sphere(): result = cle.create(test1) cle.mean_sphere(test1, result, 1, 1, 0) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_mean_x_projection.py b/tests/test_mean_x_projection.py index 6575b077..11823fd1 100644 --- a/tests/test_mean_x_projection.py +++ b/tests/test_mean_x_projection.py @@ -3,7 +3,7 @@ def test_mean_x_projection(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -37,7 +37,7 @@ def test_mean_x_projection(): ] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0.4, 1.0, 1.8, 0.8, 5.], [1.2, 1.2, 1.6, 2.0, 0.], [0., 0.2, 0.6, 0.2, 6.], @@ -49,8 +49,8 @@ def test_mean_x_projection(): cle.mean_x_projection(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_mean_y_projection.py b/tests/test_mean_y_projection.py index dd9743ca..167fd9cd 100644 --- a/tests/test_mean_y_projection.py +++ b/tests/test_mean_y_projection.py @@ -3,7 +3,7 @@ def test_mean_y_projection(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -37,7 +37,7 @@ def test_mean_y_projection(): ] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1.8, 1.2, 1.4, 3, 5.8], [1.8, 1.2, 1.4, 3, 5.8], [1.8, 1.2, 1.4, 3, 5.8], @@ -49,8 +49,8 @@ def test_mean_y_projection(): cle.mean_y_projection(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_mean_z_projection.py b/tests/test_mean_z_projection.py index 37245790..9976b004 100644 --- a/tests/test_mean_z_projection.py +++ b/tests/test_mean_z_projection.py @@ -3,7 +3,7 @@ def test_mean_z_projection(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -37,7 +37,7 @@ def test_mean_z_projection(): ] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [2, 2, 2.8, 2.2, 4.2], [2, 2, 2.8, 2.2, 4.2], [2, 2.8, 2.2, 2, 4.2], @@ -49,8 +49,8 @@ def test_mean_z_projection(): cle.mean_z_projection(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_merge_touching_labels.py b/tests/test_merge_touching_labels.py index 7ec90c05..79f0d5e6 100644 --- a/tests/test_merge_touching_labels.py +++ b/tests/test_merge_touching_labels.py @@ -3,7 +3,7 @@ def test_merge_touching_labels(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [ [1, 1, 0, 0, 0], [0, 2, 2, 0, 3], @@ -12,7 +12,7 @@ def test_merge_touching_labels(): ])) gpu_output = cle.create_like(gpu_input) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [ [1, 1, 0, 0, 0], [0, 1, 1, 0, 2], @@ -24,8 +24,8 @@ def test_merge_touching_labels(): cle.merge_touching_labels(gpu_input, gpu_output) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_minimum_box.py b/tests/test_minimum_box.py index 5db66eb9..ab6df200 100644 --- a/tests/test_minimum_box.py +++ b/tests/test_minimum_box.py @@ -2,7 +2,7 @@ import numpy as np def test_minimum_box(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], @@ -10,7 +10,7 @@ def test_minimum_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -21,8 +21,8 @@ def test_minimum_box(): result = cle.create(test1) cle.minimum_box(test1, result, 1, 1, 0) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_minimum_distance_of_touching_neighbors.py b/tests/test_minimum_distance_of_touching_neighbors.py index 0a3bb33e..e6a25fc5 100644 --- a/tests/test_minimum_distance_of_touching_neighbors.py +++ b/tests/test_minimum_distance_of_touching_neighbors.py @@ -3,7 +3,7 @@ def test_minimum_distance_of_touching_neighbors(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], [1, 1, 1, 2, 3, 3], @@ -12,7 +12,7 @@ def test_minimum_distance_of_touching_neighbors(): [0, 0, 0, 2, 2, 2] ])) - reference = cle.push_zyx(np.asarray( + reference = cle.push(np.asarray( [[0, 3.1274989, 2.933641, 2.933641]] )) @@ -22,8 +22,8 @@ def test_minimum_distance_of_touching_neighbors(): minimum_distance_of_touching_neighbors = cle.minimum_distance_of_touching_neighbors(distance_matrix, touch_matrix) - a = cle.pull_zyx(minimum_distance_of_touching_neighbors) - b = cle.pull_zyx(reference) + a = cle.pull(minimum_distance_of_touching_neighbors) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_minimum_image_and_scalar.py b/tests/test_minimum_image_and_scalar.py index 9feb867f..ad5f97c9 100644 --- a/tests/test_minimum_image_and_scalar.py +++ b/tests/test_minimum_image_and_scalar.py @@ -3,13 +3,13 @@ def test_minimum_image_and_scalar(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 3, 4, 5, 0], [0, 2, 1, 6, 0], [0, 0, 8, 7, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 2, 2, 2, 0], [0, 2, 1, 2, 0], [0, 0, 2, 2, 0] @@ -18,8 +18,8 @@ def test_minimum_image_and_scalar(): result = cle.create(test1) cle.minimum_image_and_scalar(test1, result, 2) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_minimum_images.py b/tests/test_minimum_images.py index 384f63ef..f99a5842 100644 --- a/tests/test_minimum_images.py +++ b/tests/test_minimum_images.py @@ -3,14 +3,14 @@ def test_minimum_images(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 1, 3, 0], [0, 2, 1, 3, 0], @@ -18,7 +18,7 @@ def test_minimum_images(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 3, 0], [0, 2, 1, 3, 0], @@ -29,8 +29,8 @@ def test_minimum_images(): result = cle.create(test1) cle.minimum_images(test1, test2, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_minimum_of_all_pixels.py b/tests/test_minimum_of_all_pixels.py index afa8115f..081e87a6 100644 --- a/tests/test_minimum_of_all_pixels.py +++ b/tests/test_minimum_of_all_pixels.py @@ -15,12 +15,12 @@ def test_minimum_of_all_pixels(): ] ]) - gpu_input = cle.push_zyx(np_input) + gpu_input = cle.push(np_input) result = cle.minimum_of_all_pixels(gpu_input) print(result) assert (result == 1) - gpu_input = cle.push_zyx(np_input) + gpu_input = cle.push(np_input) result = cle.minimum_of_all_pixels(gpu_input) print(result) assert (result == 1) diff --git a/tests/test_minimum_of_masked_pixels.py b/tests/test_minimum_of_masked_pixels.py index 599b3372..f53702e8 100644 --- a/tests/test_minimum_of_masked_pixels.py +++ b/tests/test_minimum_of_masked_pixels.py @@ -5,8 +5,8 @@ def test_minimum_of_masked_pixels_mini_x(): np_input = np.asarray([[1, 2, 3, 4]]) np_mask = np.asarray([[0, 1, 1, 0]]) - gpu_input = cle.push_zyx(np_input) - gpu_mask = cle.push_zyx(np_mask) + gpu_input = cle.push(np_input) + gpu_mask = cle.push(np_mask) result = cle.minimum_of_masked_pixels(gpu_input, gpu_mask) print(result) @@ -16,8 +16,8 @@ def test_minimum_of_masked_pixels_mini_y(): np_input = np.asarray([[1], [2], [3], [4]]) np_mask = np.asarray([[0], [1], [1], [0]]) - gpu_input = cle.push_zyx(np_input) - gpu_mask = cle.push_zyx(np_mask) + gpu_input = cle.push(np_input) + gpu_mask = cle.push(np_mask) result = cle.minimum_of_masked_pixels(gpu_input, gpu_mask) print(result) @@ -50,8 +50,8 @@ def test_minimum_of_masked_pixels(): ] ]) - gpu_input = cle.push_zyx(np_input) - gpu_mask = cle.push_zyx(np_mask) + gpu_input = cle.push(np_input) + gpu_mask = cle.push(np_mask) print("gpu_input") print(gpu_input) diff --git a/tests/test_minimum_of_touching_neighbors_map.py b/tests/test_minimum_of_touching_neighbors_map.py index 14880be8..e26e66ab 100644 --- a/tests/test_minimum_of_touching_neighbors_map.py +++ b/tests/test_minimum_of_touching_neighbors_map.py @@ -3,21 +3,21 @@ def test_minimum_of_touching_neighbors_map(): - intensities = cle.push_zyx(np.asarray([ + intensities = cle.push(np.asarray([ [1, 1, 2, 2], [1, 0, 0, 2], [4, 0, 0, 6], [4, 4, 6, 6] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2, 2], [1, 0, 0, 2], [3, 0, 0, 4], [3, 3, 4, 4], ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1, 1, 1, 1], [1, 0, 0, 1], [1, 0, 0, 2], @@ -27,8 +27,8 @@ def test_minimum_of_touching_neighbors_map(): result = cle.minimum_of_touching_neighbors_map(intensities, labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_minimum_x_projection.py b/tests/test_minimum_x_projection.py index 8af3c8a3..83bc3b49 100644 --- a/tests/test_minimum_x_projection.py +++ b/tests/test_minimum_x_projection.py @@ -6,7 +6,7 @@ #@pytest.mark.xfail(raises=cl.RuntimeError) def test_minimum_x_projection(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 0, 0, 0, 1], [0, 2, 0, 8, 1], @@ -40,7 +40,7 @@ def test_minimum_x_projection(): ] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], @@ -51,8 +51,8 @@ def test_minimum_x_projection(): result = cle.create(reference) cle.minimum_x_projection(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_minimum_y_projection.py b/tests/test_minimum_y_projection.py index 7a155bac..b48d24c3 100644 --- a/tests/test_minimum_y_projection.py +++ b/tests/test_minimum_y_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_minimum_y_projection(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 0, 0, 0, 1], [0, 2, 0, 8, 1], @@ -36,7 +36,7 @@ def test_minimum_y_projection(): ] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], @@ -47,8 +47,8 @@ def test_minimum_y_projection(): result = cle.create(reference) cle.minimum_y_projection(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_minimum_z_projection.py b/tests/test_minimum_z_projection.py index ff053139..5202cc20 100644 --- a/tests/test_minimum_z_projection.py +++ b/tests/test_minimum_z_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_minimum_z_projection(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 0, 0, 0, 1], [0, 2, 0, 8, 1], @@ -36,7 +36,7 @@ def test_minimum_z_projection(): ] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], @@ -47,8 +47,8 @@ def test_minimum_z_projection(): result = cle.create(reference) cle.minimum_z_projection(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_mode_of_touching_neighbors_map.py b/tests/test_mode_of_touching_neighbors_map.py index 9b309146..d9218cd4 100644 --- a/tests/test_mode_of_touching_neighbors_map.py +++ b/tests/test_mode_of_touching_neighbors_map.py @@ -3,21 +3,21 @@ def test_mode_of_touching_neighbors_map(): - intensities = cle.push_zyx(np.asarray([ + intensities = cle.push(np.asarray([ [0, 0, 2, 5], [0, 3, 1, 2], [0, 4, 3, 0], [0, 0, 0, 0] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [0, 0, 2, 5], [0, 3, 1, 2], [0, 4, 3, 0], [0, 0, 0, 0], ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 1, 2], [0, 1, 2, 1], [0, 3, 1, 0], @@ -27,8 +27,8 @@ def test_mode_of_touching_neighbors_map(): result = cle.mode_of_touching_neighbors_map(intensities, labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_multiply_image_and_coordinate.py b/tests/test_multiply_image_and_coordinate.py index b53f61bf..9379ebe3 100644 --- a/tests/test_multiply_image_and_coordinate.py +++ b/tests/test_multiply_image_and_coordinate.py @@ -2,13 +2,13 @@ import numpy as np def test_multiply_image_and_coordinate(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [2, 2, 2, 2, 2] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8] @@ -17,8 +17,8 @@ def test_multiply_image_and_coordinate(): result = cle.create(test1) cle.multiply_image_and_coordinate(test1, result, 0) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_multiply_image_and_scalar.py b/tests/test_multiply_image_and_scalar.py index 359cdfea..d3693ed4 100644 --- a/tests/test_multiply_image_and_scalar.py +++ b/tests/test_multiply_image_and_scalar.py @@ -3,13 +3,13 @@ def test_multiply_image_and_scalar(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [2, 2, 2, 2, 2] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [2, 2, 2, 2, 2], [4, 4, 4, 4, 4] @@ -18,8 +18,8 @@ def test_multiply_image_and_scalar(): result = cle.create(test1) cle.multiply_image_and_scalar(test1, result, 2) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_multiply_images.py b/tests/test_multiply_images.py index 7cc6d574..ce40e7ac 100644 --- a/tests/test_multiply_images.py +++ b/tests/test_multiply_images.py @@ -3,14 +3,14 @@ def test_multiply_images(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 4, 5, 6, 0], [0, 7, 8, 9, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 2, 2, 0], [0, 1, 1, 1, 0], @@ -18,7 +18,7 @@ def test_multiply_images(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 4, 6, 0], [0, 4, 5, 6, 0], @@ -29,8 +29,8 @@ def test_multiply_images(): result = cle.create(test1) cle.multiply_images(test1, test2, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_multiply_matrix.py b/tests/test_multiply_matrix.py index 3d87e0db..6a1841dc 100644 --- a/tests/test_multiply_matrix.py +++ b/tests/test_multiply_matrix.py @@ -12,8 +12,8 @@ def multiply(): b_np = np.random.rand(shape, shape).astype("float32") if target == "gpu": # push arrays to GPU - gpu_a = cle.push_zyx(a_np) - gpu_b = cle.push_zyx(b_np) + gpu_a = cle.push(a_np) + gpu_b = cle.push(b_np) # allocate memory for result on GPU gpu_c = cle.create((shape, shape)) cle.multiply_matrix(gpu_a, gpu_b, gpu_c) diff --git a/tests/test_n_closest_points.py b/tests/test_n_closest_points.py index 663ba580..cf67ed5d 100644 --- a/tests/test_n_closest_points.py +++ b/tests/test_n_closest_points.py @@ -5,7 +5,7 @@ def test_n_closest_points(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], @@ -14,7 +14,7 @@ def test_n_closest_points(): [0, 0, 0, 2, 2, 2] ])) - reference = cle.push_zyx(np.asarray( + reference = cle.push(np.asarray( [[0, 3, 3, 1]] )) @@ -29,8 +29,8 @@ def test_n_closest_points(): n_closest_points = cle.n_closest_points(distance_matrix, n=1, ignore_background=False) - a = cle.pull_zyx(n_closest_points) - b = cle.pull_zyx(reference) + a = cle.pull(n_closest_points) + b = cle.pull(reference) print(a) print(b) @@ -45,7 +45,7 @@ def test_n_closest_points(): def test_n_closest_points_ignore_background(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], @@ -54,7 +54,7 @@ def test_n_closest_points_ignore_background(): [0, 0, 0, 2, 2, 2] ])) - reference = cle.push_zyx(np.asarray( + reference = cle.push(np.asarray( [[3, 3, 1]] )) @@ -69,8 +69,8 @@ def test_n_closest_points_ignore_background(): n_closest_points = cle.n_closest_points(distance_matrix, n=1) - a = cle.pull_zyx(n_closest_points) - b = cle.pull_zyx(reference) + a = cle.pull(n_closest_points) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_nonzero_maximum_box.py b/tests/test_nonzero_maximum_box.py index ee03c9d1..e5d874c4 100644 --- a/tests/test_nonzero_maximum_box.py +++ b/tests/test_nonzero_maximum_box.py @@ -2,7 +2,7 @@ import numpy as np def test_nonzero_maximum_box(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 2, 0], [0, 2, 2, 3, 0], @@ -10,7 +10,7 @@ def test_nonzero_maximum_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 3, 3, 0], [0, 3, 4, 4, 0], @@ -28,6 +28,6 @@ def test_nonzero_maximum_box(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a, b, atol=0.00001)) diff --git a/tests/test_nonzero_maximum_diamond.py b/tests/test_nonzero_maximum_diamond.py index 0c9e6728..be579b59 100644 --- a/tests/test_nonzero_maximum_diamond.py +++ b/tests/test_nonzero_maximum_diamond.py @@ -2,7 +2,7 @@ import numpy as np def test_nonzero_maximum_diamond(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 2, 0], [0, 2, 2, 3, 0], @@ -10,7 +10,7 @@ def test_nonzero_maximum_diamond(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 2, 3, 0], [0, 3, 3, 4, 0], @@ -28,6 +28,6 @@ def test_nonzero_maximum_diamond(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a, b, atol=0.00001)) diff --git a/tests/test_nonzero_minimum_box.py b/tests/test_nonzero_minimum_box.py index 8167e6b3..092e2c06 100644 --- a/tests/test_nonzero_minimum_box.py +++ b/tests/test_nonzero_minimum_box.py @@ -2,7 +2,7 @@ import numpy as np def test_nonzero_minimum_box(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 2, 0], [0, 2, 2, 3, 0], @@ -10,7 +10,7 @@ def test_nonzero_minimum_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], @@ -28,6 +28,6 @@ def test_nonzero_minimum_box(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a, b, atol=0.00001)) diff --git a/tests/test_nonzero_minimum_diamond.py b/tests/test_nonzero_minimum_diamond.py index a5d0a7be..59eb9e7d 100644 --- a/tests/test_nonzero_minimum_diamond.py +++ b/tests/test_nonzero_minimum_diamond.py @@ -2,7 +2,7 @@ import numpy as np def test_nonzero_minimum_diamond(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 2, 0], [0, 2, 2, 3, 0], @@ -10,7 +10,7 @@ def test_nonzero_minimum_diamond(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 2, 0], @@ -28,7 +28,7 @@ def test_nonzero_minimum_diamond(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a, b, atol=0.00001)) diff --git a/tests/test_not_equal.py b/tests/test_not_equal.py index c156594f..dd346cd1 100644 --- a/tests/test_not_equal.py +++ b/tests/test_not_equal.py @@ -3,14 +3,14 @@ def test_not_equal(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 4, 5, 6, 0], [0, 7, 8, 9, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 2, 2, 2, 0], [0, 1, 1, 1, 0], @@ -18,7 +18,7 @@ def test_not_equal(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 0, 1, 0], [0, 1, 1, 1, 0], @@ -29,8 +29,8 @@ def test_not_equal(): result = cle.create(test1) cle.not_equal(test1, test2, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_not_equal_constant.py b/tests/test_not_equal_constant.py index 17767c05..92dc162b 100644 --- a/tests/test_not_equal_constant.py +++ b/tests/test_not_equal_constant.py @@ -3,7 +3,7 @@ def test_not_equal_constant(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_not_equal_constant(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 0, 1], @@ -24,6 +24,6 @@ def test_not_equal_constant(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_onlyzero_overwrite_maximum_box.py b/tests/test_onlyzero_overwrite_maximum_box.py index b0274231..e67a7fa0 100644 --- a/tests/test_onlyzero_overwrite_maximum_box.py +++ b/tests/test_onlyzero_overwrite_maximum_box.py @@ -2,7 +2,7 @@ import numpy as np def test_onlyzero_overwrite_maximum_box(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -10,7 +10,7 @@ def test_onlyzero_overwrite_maximum_box(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1, 2, 3, 3, 3], [2, 1, 2, 3, 4], [4, 2, 3, 4, 5], @@ -24,6 +24,6 @@ def test_onlyzero_overwrite_maximum_box(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_onlyzero_overwrite_maximum_diamond.py b/tests/test_onlyzero_overwrite_maximum_diamond.py index 9cf6aee2..122b8c78 100644 --- a/tests/test_onlyzero_overwrite_maximum_diamond.py +++ b/tests/test_onlyzero_overwrite_maximum_diamond.py @@ -3,7 +3,7 @@ def onlyzero_overwrite_maximum_diamond(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def onlyzero_overwrite_maximum_diamond(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 1, 2, 3, 0], [1, 1, 2, 3, 3], [2, 2, 3, 4, 4], @@ -25,6 +25,6 @@ def onlyzero_overwrite_maximum_diamond(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_paste.py b/tests/test_paste.py index f8623ec7..f001d0bd 100644 --- a/tests/test_paste.py +++ b/tests/test_paste.py @@ -2,17 +2,17 @@ import numpy as np def test_paste(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 1], [0, 0, 3, 1], [0, 0, 3, 1], [1, 1, 1, 1] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [1, 2], ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 1], [0, 0, 3, 1], [0, 1, 2, 1], @@ -23,8 +23,8 @@ def test_paste(): cle.copy(test1, result) cle.paste(test2, result, 1, 2, 0) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_point_index_list_to_mesh.py b/tests/test_point_index_list_to_mesh.py index 80e01be2..670fbbf9 100644 --- a/tests/test_point_index_list_to_mesh.py +++ b/tests/test_point_index_list_to_mesh.py @@ -3,17 +3,17 @@ def test_point_index_list_to_mesh(): - positions = cle.push_zyx(np.asarray([ + positions = cle.push(np.asarray([ [1, 1, 4, 4], [1, 4, 4, 1] ])) - index_list = cle.push_zyx(np.asarray([ + index_list = cle.push(np.asarray([ [2, 3, 4, 1], [3,-1,-1,-1] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 0], [0, 1, 1, 0, 1, 0], @@ -26,8 +26,8 @@ def test_point_index_list_to_mesh(): result = cle.point_index_list_to_mesh(positions, index_list, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_point_index_list_to_touch_matrix.py b/tests/test_point_index_list_to_touch_matrix.py index 01f6e353..cd569864 100644 --- a/tests/test_point_index_list_to_touch_matrix.py +++ b/tests/test_point_index_list_to_touch_matrix.py @@ -3,17 +3,17 @@ def test_point_index_list_to_touch_matrix(): - positions = cle.push_zyx(np.asarray([ + positions = cle.push(np.asarray([ [1, 1, 4, 4], [1, 4, 4, 1] ])) - index_list = cle.push_zyx(np.asarray([ + index_list = cle.push(np.asarray([ [2, 3, 4, 1], [3,-1,-1,-1] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 0], [0, 1, 1, 0, 1, 0], @@ -29,8 +29,8 @@ def test_point_index_list_to_touch_matrix(): result = cle.touch_matrix_to_mesh(positions, touch_matrix, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_pointlist_to_labelled_spots.py b/tests/test_pointlist_to_labelled_spots.py index 417d490f..6ce2c2e8 100644 --- a/tests/test_pointlist_to_labelled_spots.py +++ b/tests/test_pointlist_to_labelled_spots.py @@ -3,13 +3,13 @@ def test_pointlist_to_labelled_spots_2d(): - positions_and_values = cle.push_zyx(np.asarray([ + positions_and_values = cle.push(np.asarray([ [0, 0, 2, 3, 5], [0, 1, 3, 2, 6] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0], [0, 0, 0, 4, 0, 0], @@ -21,8 +21,8 @@ def test_pointlist_to_labelled_spots_2d(): result = cle.pointlist_to_labelled_spots(positions_and_values) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -30,14 +30,14 @@ def test_pointlist_to_labelled_spots_2d(): assert (np.array_equal(a, b)) def test_pointlist_to_labelled_spots_3d(): - positions_and_values = cle.push_zyx(np.asarray([ + positions_and_values = cle.push(np.asarray([ [0, 0, 2, 3, 5], [0, 1, 3, 2, 6], [0, 0, 0, 0, 1] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [1, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0], @@ -59,8 +59,8 @@ def test_pointlist_to_labelled_spots_3d(): result = cle.pointlist_to_labelled_spots(positions_and_values) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_power.py b/tests/test_power.py index 375a8dda..5b62daf6 100644 --- a/tests/test_power.py +++ b/tests/test_power.py @@ -3,7 +3,7 @@ def test_power(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_power(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 4, 9, 0], [0, 4, 9, 16, 0], @@ -24,6 +24,6 @@ def test_power(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_power_images.py b/tests/test_power_images.py index c02f1327..2253369b 100644 --- a/tests/test_power_images.py +++ b/tests/test_power_images.py @@ -3,14 +3,14 @@ def test_power_images(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 4, 5, 6, 0], [0, 7, 8, 9, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [1, 0, 0, 0, 0], [1, 1, 2, 3, 0], [1, 1, 2, 3, 0], @@ -18,7 +18,7 @@ def test_power_images(): [1, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 1, 1, 1, 1], [0, 1, 4, 27, 1], [0, 4, 25, 216, 1], @@ -29,8 +29,8 @@ def test_power_images(): result = cle.create(test1) cle.power_images(test1, test2, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.allclose(a, b, 0.0001)) diff --git a/tests/test_push_regionprops_column.py b/tests/test_push_regionprops_column.py index 60c7ee5a..406f6005 100644 --- a/tests/test_push_regionprops_column.py +++ b/tests/test_push_regionprops_column.py @@ -2,7 +2,7 @@ import numpy as np def test_push_regionprops_column(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [ [4, 4, 2], ], [ @@ -23,7 +23,7 @@ def test_push_regionprops_column(): def test_push_regionprops_column_gpu(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [ [4, 4, 2], ], [ diff --git a/tests/test_radians_to_degrees.py b/tests/test_radians_to_degrees.py index cb3f69b4..8c5b914a 100644 --- a/tests/test_radians_to_degrees.py +++ b/tests/test_radians_to_degrees.py @@ -2,17 +2,17 @@ import numpy as np def test_radians_to_degrees(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [np.pi, 0, -0.5 * np.pi] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [180, 0, -90] ])) result = cle.radians_to_degrees(test) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a,b,0.01)) diff --git a/tests/test_read_intensities_from_map.py b/tests/test_read_intensities_from_map.py index 4e4fa5bd..b9667134 100644 --- a/tests/test_read_intensities_from_map.py +++ b/tests/test_read_intensities_from_map.py @@ -3,27 +3,27 @@ def test_read_intensities_from_map(): - intensities = cle.push_zyx(np.asarray([ + intensities = cle.push(np.asarray([ [1, 2, 3], [4, 5, 6], [7, 8, 9] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [8, 0, 7], [6, 5, 4], [3, 2, 1] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [2, 9, 8, 7, 6, 5, 4, 3, 1] ] )) result = cle.read_intensities_from_map(labels, intensities) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_read_intensities_from_positions.py b/tests/test_read_intensities_from_positions.py index 0ad203ef..29f8510a 100644 --- a/tests/test_read_intensities_from_positions.py +++ b/tests/test_read_intensities_from_positions.py @@ -3,27 +3,27 @@ def test_read_intensities_from_positions(): - intensities = cle.push_zyx(np.asarray([ + intensities = cle.push(np.asarray([ [1, 2, 3], [4, 5, 6], [7, 8, 9] ])) - pointlist = cle.push_zyx(np.asarray([ + pointlist = cle.push(np.asarray([ [0, 1, 0], [0, 2, 2] ] )) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1, 8, 7] ] )) result = cle.read_intensities_from_positions(pointlist, intensities) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_reduce_stack.py b/tests/test_reduce_stack.py index b88fdc77..f83454bf 100644 --- a/tests/test_reduce_stack.py +++ b/tests/test_reduce_stack.py @@ -3,7 +3,7 @@ def test_reduce_offset_0(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [ [0, 0], [0, 5] @@ -22,7 +22,7 @@ def test_reduce_offset_0(): ], ])) - ref = cle.push_zyx(np.asarray([ + ref = cle.push(np.asarray([ [ [0, 0], [0, 5] @@ -35,8 +35,8 @@ def test_reduce_offset_0(): res = cle.reduce_stack(test, reduction_factor=2) - a = cle.pull_zyx(res) - b = cle.pull_zyx(ref) + a = cle.pull(res) + b = cle.pull(ref) print(a) print(b) @@ -45,7 +45,7 @@ def test_reduce_offset_0(): def test_reduce_offset_1(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [ [0, 0], [0, 5] @@ -64,7 +64,7 @@ def test_reduce_offset_1(): ], ])) - ref = cle.push_zyx(np.asarray([ + ref = cle.push(np.asarray([ [ [1, 1], [1, 5] @@ -73,8 +73,8 @@ def test_reduce_offset_1(): res = cle.reduce_stack(test, reduction_factor=3, offset=1) - a = cle.pull_zyx(res) - b = cle.pull_zyx(ref) + a = cle.pull(res) + b = cle.pull(ref) print(a) print(b) diff --git a/tests/test_regionprops.py b/tests/test_regionprops.py index fe35e394..5bfebf82 100644 --- a/tests/test_regionprops.py +++ b/tests/test_regionprops.py @@ -2,19 +2,19 @@ import numpy as np def test_regionprops(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [0, 1, 2], [1, 2, 3], [2, 3, 4] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2], [1, 2, 2], [3, 3, 3] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ #IDENTIFIER(0), [1., 2., 3.], # BOUNDING_BOX_X(1), @@ -97,8 +97,8 @@ def test_regionprops(): result = cle.regionprops(labels, intensity) result_image = cle.push_regionprops(result, first_row_index=1) - a = cle.pull_zyx(result_image) - b = cle.pull_zyx(reference) + a = cle.pull(result_image) + b = cle.pull(reference) print(a) print(b) @@ -106,7 +106,7 @@ def test_regionprops(): assert (np.allclose(a, b, 0.0001)) def test_statistics_of_labelled_pixels_3d(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [ [0, 1, 2], ],[ @@ -116,7 +116,7 @@ def test_statistics_of_labelled_pixels_3d(): ] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [ [1, 1, 2], ], [ @@ -126,7 +126,7 @@ def test_statistics_of_labelled_pixels_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ #IDENTIFIER(0), [1., 2., 3.], # BOUNDING_BOX_X(1), @@ -209,8 +209,8 @@ def test_statistics_of_labelled_pixels_3d(): result = cle.regionprops(labels, intensity) result_image = cle.push_regionprops(result, first_row_index=1) - a = cle.pull_zyx(result_image) - b = cle.pull_zyx(reference) + a = cle.pull(result_image) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_replace_intensities.py b/tests/test_replace_intensities.py index ec495737..9e8f847d 100644 --- a/tests/test_replace_intensities.py +++ b/tests/test_replace_intensities.py @@ -3,7 +3,7 @@ def test_replace_intensities(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,11 +11,11 @@ def test_replace_intensities(): [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [0, 9, 8, 7, 6, 5] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 9, 8, 7, 0], [0, 8, 7, 6, 0], @@ -28,6 +28,6 @@ def test_replace_intensities(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_replace_intensity.py b/tests/test_replace_intensity.py index 0a76469b..1c4a4116 100644 --- a/tests/test_replace_intensity.py +++ b/tests/test_replace_intensity.py @@ -3,7 +3,7 @@ def test_replace_intensity(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_replace_intensity(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 8, 3, 0], [0, 8, 3, 4, 0], @@ -24,6 +24,6 @@ def test_replace_intensity(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_resample.py b/tests/test_resample.py index 5ec6eaf4..35cbe6d6 100644 --- a/tests/test_resample.py +++ b/tests/test_resample.py @@ -2,33 +2,33 @@ import numpy as np def test_resample_downsample_2d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 2, 2], [0, 0, 2, 2], [1, 1, 4, 4], [1, 1, 4, 4] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 2], [1, 4] ])) result = cle.resample(test1, factor_x=0.5, factor_y=0.5) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) def test_resample_upsample_2d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 2], [1, 4] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 2, 2], [0, 0, 2, 2], [1, 1, 4, 4], @@ -37,14 +37,14 @@ def test_resample_upsample_2d(): result = cle.resample(test1, factor_x=2, factor_y=2) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) def test_resample_downsample_3d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [0, 0, 2, 2], [0, 0, 2, 2], @@ -68,7 +68,7 @@ def test_resample_downsample_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 2], [1, 4] @@ -80,14 +80,14 @@ def test_resample_downsample_3d(): result = cle.resample(test1, factor_x=0.5, factor_y=0.5, factor_z=0.5) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) def test_resample_upsample_3d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [0, 2], [1, 4] @@ -97,7 +97,7 @@ def test_resample_upsample_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 0, 2, 2], [0, 0, 2, 2], @@ -124,8 +124,8 @@ def test_resample_upsample_3d(): result = cle.resample(test1, factor_x=2, factor_y=2, factor_z=2) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -139,7 +139,7 @@ def test_resample_upsample_3d(): @pytest.mark.xfail('LINUX and CI', reason='clImages not supported on CI', raises=ValueError) def test_resample_upsample_3d_with_interpolation(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [0, 2] ], [ @@ -147,7 +147,7 @@ def test_resample_upsample_3d_with_interpolation(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 0.5, 1.5, 1.5], ], [ @@ -157,8 +157,8 @@ def test_resample_upsample_3d_with_interpolation(): result = cle.resample(test1, factor_x=2, factor_y=1, factor_z=1,linear_interpolation=True) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_rigid_transform.py b/tests/test_rigid_transform.py index c3e23530..47d66ef2 100644 --- a/tests/test_rigid_transform.py +++ b/tests/test_rigid_transform.py @@ -2,7 +2,7 @@ import numpy as np def test_rigid_transform(): - source = cle.push_zyx(np.asarray([[ + source = cle.push(np.asarray([[ [0, 0, 0, 1, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], @@ -10,7 +10,7 @@ def test_rigid_transform(): [0, 0, 0, 0, 0], ]])) - reference = cle.push_zyx(np.asarray([[ + reference = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], @@ -20,8 +20,8 @@ def test_rigid_transform(): result = cle.rigid_transform(source, translate_x=-1, angle_around_z_in_degrees=90) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_rotate.py b/tests/test_rotate.py index 99d236f0..8cb2c510 100644 --- a/tests/test_rotate.py +++ b/tests/test_rotate.py @@ -2,7 +2,7 @@ import numpy as np def test_affine_transform_rotate(): - source = cle.push_zyx(np.asarray([[ + source = cle.push(np.asarray([[ [0, 0, 0, 1, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], @@ -10,7 +10,7 @@ def test_affine_transform_rotate(): [0, 0, 0, 0, 0], ]])) - reference = cle.push_zyx(np.asarray([[ + reference = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -20,8 +20,8 @@ def test_affine_transform_rotate(): result = cle.rotate(source, angle_around_z_in_degrees=45.0, rotate_around_center=False) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -29,7 +29,7 @@ def test_affine_transform_rotate(): assert (np.array_equal(a, b)) def test_affine_transform_rotate_around_center(): - source = cle.push_zyx(np.asarray([[ + source = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 1, 1], @@ -37,7 +37,7 @@ def test_affine_transform_rotate_around_center(): [0, 0, 0, 0, 0], ]])) - reference = cle.push_zyx(np.asarray([[ + reference = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], @@ -47,8 +47,8 @@ def test_affine_transform_rotate_around_center(): result = cle.rotate(source, angle_around_z_in_degrees=90.0, rotate_around_center=True) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_scale.py b/tests/test_scale.py index 6e7184c9..bcc39695 100644 --- a/tests/test_scale.py +++ b/tests/test_scale.py @@ -3,7 +3,7 @@ def test_scale_centered(): - source = cle.push_zyx(np.asarray([[ + source = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], @@ -11,7 +11,7 @@ def test_scale_centered(): [0, 0, 0, 0, 0], ]])) - reference = cle.push_zyx(np.asarray([[ + reference = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], [0, 0, 1, 1, 0], @@ -21,8 +21,8 @@ def test_scale_centered(): result = cle.scale(source, factor_y=2) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -31,7 +31,7 @@ def test_scale_centered(): def test_scale_not_centered(): - source = cle.push_zyx(np.asarray([[ + source = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0], @@ -39,7 +39,7 @@ def test_scale_not_centered(): [0, 0, 0, 0, 0], ]])) - reference = cle.push_zyx(np.asarray([[ + reference = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], @@ -49,8 +49,8 @@ def test_scale_not_centered(): result = cle.scale(source, factor_y=2, centered=False) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_set.py b/tests/test_set.py index 086de116..d486dbc9 100644 --- a/tests/test_set.py +++ b/tests/test_set.py @@ -5,7 +5,7 @@ def test_set(): result = cle.create((5, 5)) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], @@ -17,6 +17,6 @@ def test_set(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_set_column.py b/tests/test_set_column.py index 030fe263..81931b27 100644 --- a/tests/test_set_column.py +++ b/tests/test_set_column.py @@ -2,7 +2,7 @@ import numpy as np def test_set_column(): - result = cle.push_zyx(np.asarray([ + result = cle.push(np.asarray([ [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], @@ -10,7 +10,7 @@ def test_set_column(): [3, 3, 3, 3, 3] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], @@ -22,6 +22,6 @@ def test_set_column(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_set_image_borders.py b/tests/test_set_image_borders.py index 4b64e829..c4bce625 100644 --- a/tests/test_set_image_borders.py +++ b/tests/test_set_image_borders.py @@ -3,7 +3,7 @@ def test_set_image_borders(): - result = cle.push_zyx(np.asarray([ + result = cle.push(np.asarray([ [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], @@ -11,7 +11,7 @@ def test_set_image_borders(): [3, 3, 3, 3, 3] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [4, 4, 4, 4, 4], [4, 3, 3, 3, 4], [4, 3, 3, 3, 4], @@ -23,6 +23,6 @@ def test_set_image_borders(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_set_nonzero_pixels_to_pixelindex.py b/tests/test_set_nonzero_pixels_to_pixelindex.py index 37814c98..6e18caba 100644 --- a/tests/test_set_nonzero_pixels_to_pixelindex.py +++ b/tests/test_set_nonzero_pixels_to_pixelindex.py @@ -2,14 +2,14 @@ import numpy as np def test_set_nonzero_pixels_to_pixelindex(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 1], [0, 0, 3, 1], [0, 0, 3, 1], [1, 1, 1, 1] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 13], [0, 0, 10, 14], [0, 0, 11, 15], @@ -19,8 +19,8 @@ def test_set_nonzero_pixels_to_pixelindex(): result = cle.create(test1) cle.set_non_zero_pixels_to_pixel_index(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_set_plane.py b/tests/test_set_plane.py index c720e413..01a9c606 100644 --- a/tests/test_set_plane.py +++ b/tests/test_set_plane.py @@ -2,7 +2,7 @@ import numpy as np def test_set_plane(): - result = cle.push_zyx(np.asarray([ + result = cle.push(np.asarray([ [ [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], @@ -18,7 +18,7 @@ def test_set_plane(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], @@ -36,8 +36,8 @@ def test_set_plane(): cle.set_plane(result, 1, 4) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_set_ramp_x.py b/tests/test_set_ramp_x.py index 611a0376..793782dd 100644 --- a/tests/test_set_ramp_x.py +++ b/tests/test_set_ramp_x.py @@ -2,7 +2,7 @@ import numpy as np def test_set_ramp_x(): - result = cle.push_zyx(np.asarray([ + result = cle.push(np.asarray([ [ [0, 0, 0], [3, 4, 3], @@ -14,7 +14,7 @@ def test_set_ramp_x(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 1, 2], [0, 1, 2], @@ -28,8 +28,8 @@ def test_set_ramp_x(): cle.set_ramp_x(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_set_ramp_y.py b/tests/test_set_ramp_y.py index 888b9cf4..490f80a5 100644 --- a/tests/test_set_ramp_y.py +++ b/tests/test_set_ramp_y.py @@ -2,7 +2,7 @@ import numpy as np def test_set_ramp_y(): - result = cle.push_zyx(np.asarray([ + result = cle.push(np.asarray([ [ [0, 0, 0], [3, 4, 3], @@ -14,7 +14,7 @@ def test_set_ramp_y(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 0, 0], [1, 1, 1], @@ -28,8 +28,8 @@ def test_set_ramp_y(): cle.set_ramp_y(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_set_ramp_z.py b/tests/test_set_ramp_z.py index 1af4d11f..7953fede 100644 --- a/tests/test_set_ramp_z.py +++ b/tests/test_set_ramp_z.py @@ -2,7 +2,7 @@ import numpy as np def test_set_ramp_z(): - result = cle.push_zyx(np.asarray([ + result = cle.push(np.asarray([ [ [0, 0, 0], [3, 4, 3], @@ -14,7 +14,7 @@ def test_set_ramp_z(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 0, 0], [0, 0, 0], @@ -28,8 +28,8 @@ def test_set_ramp_z(): cle.set_ramp_z(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_set_row.py b/tests/test_set_row.py index fd94eb5e..d009e9f8 100644 --- a/tests/test_set_row.py +++ b/tests/test_set_row.py @@ -2,7 +2,7 @@ import numpy as np def test_set_row(): - result = cle.push_zyx(np.asarray([ + result = cle.push(np.asarray([ [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], @@ -10,7 +10,7 @@ def test_set_row(): [3, 3, 3, 3, 3] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [3, 3, 3, 4, 3], [3, 3, 3, 4, 3], [3, 3, 3, 4, 3], @@ -22,6 +22,6 @@ def test_set_row(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.allclose(a, b, 0.001)) diff --git a/tests/test_set_where_x_equals_y.py b/tests/test_set_where_x_equals_y.py index 210c889e..6a8c3459 100644 --- a/tests/test_set_where_x_equals_y.py +++ b/tests/test_set_where_x_equals_y.py @@ -3,14 +3,14 @@ def test_set_where_x_equals_y(): - result = cle.push_zyx(np.asarray([ + result = cle.push(np.asarray([ [0, 0, 0, 1], [0, 0, 3, 1], [0, 0, 3, 1], [1, 1, 1, 1] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [3, 0, 0, 1], [0, 3, 3, 1], [0, 0, 3, 1], @@ -19,8 +19,8 @@ def test_set_where_x_equals_y(): cle.set_where_x_equals_y(result, 3) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_set_where_x_greater_than_y.py b/tests/test_set_where_x_greater_than_y.py index e4ad7a6b..c0c2c3de 100644 --- a/tests/test_set_where_x_greater_than_y.py +++ b/tests/test_set_where_x_greater_than_y.py @@ -3,14 +3,14 @@ def test_set_where_x_greater_than_y(): - result = cle.push_zyx(np.asarray([ + result = cle.push(np.asarray([ [0, 0, 0, 1], [0, 0, 3, 1], [0, 0, 3, 1], [1, 1, 1, 1] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 1], [3, 0, 3, 1], [3, 3, 3, 1], @@ -19,8 +19,8 @@ def test_set_where_x_greater_than_y(): cle.set_where_x_greater_than_y(result, 3) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_set_where_x_smaller_than_y.py b/tests/test_set_where_x_smaller_than_y.py index ad0e43bd..6e4bf0b6 100644 --- a/tests/test_set_where_x_smaller_than_y.py +++ b/tests/test_set_where_x_smaller_than_y.py @@ -3,14 +3,14 @@ def test_set_where_x_smaller_than_y(): - result = cle.push_zyx(np.asarray([ + result = cle.push(np.asarray([ [0, 0, 0, 1], [0, 0, 3, 1], [0, 0, 3, 1], [1, 1, 1, 1] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 3, 3, 3], [0, 0, 3, 3], [0, 0, 3, 3], @@ -19,8 +19,8 @@ def test_set_where_x_smaller_than_y(): cle.set_where_x_smaller_than_y(result, 3) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_smaller.py b/tests/test_smaller.py index 8d7adc6c..5b527f27 100644 --- a/tests/test_smaller.py +++ b/tests/test_smaller.py @@ -3,14 +3,14 @@ def test_smaller_2d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 3, 3, 3, 0], [0, 3, 3, 3, 0], @@ -18,7 +18,7 @@ def test_smaller_2d(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 0, 0], [0, 0, 0, 0, 0], @@ -29,8 +29,8 @@ def test_smaller_2d(): result = cle.create(test1) cle.smaller(test1, test2, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) @@ -38,7 +38,7 @@ def test_smaller_2d(): print("ok smaller") def test_smaller_3d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [0, 1, 2, 3, 0], [0, 3, 3, 4, 0] @@ -47,7 +47,7 @@ def test_smaller_3d(): [0, 0, 0, 0, 0] ] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [ [0, 3, 3, 3, 0], [0, 3, 3, 3, 0] @@ -57,7 +57,7 @@ def test_smaller_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 1, 1, 0, 0], [0, 0, 0, 0, 0] @@ -70,8 +70,8 @@ def test_smaller_3d(): result = cle.create(test1) cle.smaller(test1, test2, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_smaller_constant.py b/tests/test_smaller_constant.py index 762756f7..24e4f076 100644 --- a/tests/test_smaller_constant.py +++ b/tests/test_smaller_constant.py @@ -3,7 +3,7 @@ def test_smaller_constant(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_smaller_constant(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 0, 1], @@ -24,6 +24,6 @@ def test_smaller_constant(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_smaller_or_equal.py b/tests/test_smaller_or_equal.py index 87b28743..70572606 100644 --- a/tests/test_smaller_or_equal.py +++ b/tests/test_smaller_or_equal.py @@ -3,14 +3,14 @@ def test_smaller_or_equal_2d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 3, 3, 4, 0], [0, 4, 4, 5, 0], [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 3, 3, 3, 0], [0, 3, 3, 3, 0], @@ -18,7 +18,7 @@ def test_smaller_or_equal_2d(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 0, 1], @@ -29,14 +29,14 @@ def test_smaller_or_equal_2d(): result = cle.create(test1) cle.smaller_or_equal(test1, test2, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) def test_smaller_or_equal_3d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [0, 1, 2, 3, 0], [0, 3, 3, 4, 0] @@ -45,7 +45,7 @@ def test_smaller_or_equal_3d(): [0, 0, 0, 0, 0] ] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [ [0, 3, 3, 3, 0], [0, 3, 3, 3, 0] @@ -55,7 +55,7 @@ def test_smaller_or_equal_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [1, 1, 1, 1, 1], [1, 1, 1, 0, 1] @@ -68,8 +68,8 @@ def test_smaller_or_equal_3d(): result = cle.create(test1) cle.smaller_or_equal(test1, test2, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) diff --git a/tests/test_smaller_or_equal_constant.py b/tests/test_smaller_or_equal_constant.py index a19c1ae7..4c789896 100644 --- a/tests/test_smaller_or_equal_constant.py +++ b/tests/test_smaller_or_equal_constant.py @@ -3,7 +3,7 @@ def test_smaller_or_equal_constant(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0], @@ -11,7 +11,7 @@ def test_smaller_or_equal_constant(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 0, 1], @@ -24,6 +24,6 @@ def test_smaller_or_equal_constant(): print(result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) assert (np.array_equal(a, b)) diff --git a/tests/test_sobel.py b/tests/test_sobel.py index a63f95df..974309f0 100644 --- a/tests/test_sobel.py +++ b/tests/test_sobel.py @@ -3,7 +3,7 @@ def test_sobel(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], @@ -11,7 +11,7 @@ def test_sobel(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1.41, 2, 1.41, 0], [0, 3.16, 2, 3.16, 0], @@ -21,8 +21,8 @@ def test_sobel(): result = cle.create(test1) cle.sobel(test1, result) - a = cle.pull_zyx(result) + a = cle.pull(result) print(a) - b = cle.pull_zyx(reference) + b = cle.pull(reference) assert (np.allclose(a, b, 0.01)) diff --git a/tests/test_sorenson_dice_coefficient.py b/tests/test_sorenson_dice_coefficient.py index 258f4424..ba8b0dd1 100644 --- a/tests/test_sorenson_dice_coefficient.py +++ b/tests/test_sorenson_dice_coefficient.py @@ -3,12 +3,12 @@ def test_sorensen_dice_coefficient_2d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [0, 1, 1, 0, 0], [0, 1, 1, 0, 0] ])) @@ -18,12 +18,12 @@ def test_sorensen_dice_coefficient_2d(): assert abs(d - 0.666) < 0.001 def test_sorensen_dice_coefficient_3d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [[0, 0, 0], [0, 0, 0]], [[0, 1, 1], [0, 1, 0]] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [[0, 1, 1], [0, 1, 0]], [[0, 1, 1], [0, 1, 0]] ])) diff --git a/tests/test_spots_to_pointlist.py b/tests/test_spots_to_pointlist.py index a4ef2840..ab14f21c 100644 --- a/tests/test_spots_to_pointlist.py +++ b/tests/test_spots_to_pointlist.py @@ -3,7 +3,7 @@ def test_labelled_spots_to_pointlist(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 0, 1, 0], @@ -13,7 +13,7 @@ def test_labelled_spots_to_pointlist(): ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [1, 3, 2, 4], [1, 1, 3, 4] @@ -24,8 +24,8 @@ def test_labelled_spots_to_pointlist(): gpu_output = cle.spots_to_pointlist(gpu_input) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_squared_difference.py b/tests/test_squared_difference.py index bd103620..3d05a90e 100644 --- a/tests/test_squared_difference.py +++ b/tests/test_squared_difference.py @@ -10,7 +10,7 @@ def test_squared_difference(): reference = np.asarray([[9, 9, 16]]) output = cle.squared_difference(input2, input1) - result = cle.pull_zyx(output) + result = cle.pull(output) assert np.array_equal(result, reference) diff --git a/tests/test_standard_deviation_of_touching_neighbors_map.py b/tests/test_standard_deviation_of_touching_neighbors_map.py index 26ff55c4..3649dad6 100644 --- a/tests/test_standard_deviation_of_touching_neighbors_map.py +++ b/tests/test_standard_deviation_of_touching_neighbors_map.py @@ -3,21 +3,21 @@ def test_mean_of_touching_neighbors_map(): - intensities = cle.push_zyx(np.asarray([ + intensities = cle.push(np.asarray([ [1, 1, 2, 2], [1, 0, 0, 2], [4, 0, 0, 6], [4, 4, 6, 6] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2, 2], [1, 0, 0, 2], [3, 0, 0, 4], [3, 3, 4, 4], ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0.9660918, 0.9660918, 1.67332, 1.67332], [0.9660918, 0, 0, 1.67332], [1.5916449, 0, 0, 1.264911], @@ -27,8 +27,8 @@ def test_mean_of_touching_neighbors_map(): result = cle.standard_deviation_of_touching_neighbors_map(intensities, labels) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_standard_deviation_z_projection.py b/tests/test_standard_deviation_z_projection.py index 3f1e8158..da9a8fbb 100644 --- a/tests/test_standard_deviation_z_projection.py +++ b/tests/test_standard_deviation_z_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_standard_deviation_z_projection(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -36,7 +36,7 @@ def test_standard_deviation_z_projection(): ] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [3.94, 3.46, 4.21, 3.19, 4.27], [3.46, 3.94, 4.21, 3.19, 4.27], [3.46, 4.21, 3.19, 3.94, 4.27], @@ -47,8 +47,8 @@ def test_standard_deviation_z_projection(): result = cle.create(reference) cle.standard_deviation_z_projection(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_statistics_of_background_and_labelled_pixels.py b/tests/test_statistics_of_background_and_labelled_pixels.py index 60a9f248..40f046af 100644 --- a/tests/test_statistics_of_background_and_labelled_pixels.py +++ b/tests/test_statistics_of_background_and_labelled_pixels.py @@ -2,19 +2,19 @@ import numpy as np def test_statistics_of_background_and_labelled_pixels(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [0, 1, 2], [1, 2, 3], [2, 3, 4] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [0, 0, 1], [0, 1, 1], [2, 2, 2] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ #IDENTIFIER(0), [0., 1., 2.], # BOUNDING_BOX_X(1), @@ -96,8 +96,8 @@ def test_statistics_of_background_and_labelled_pixels(): result = cle.statistics_of_background_and_labelled_pixels(intensity, labels) result_image = cle.push_regionprops(result, first_row_index=0) - a = cle.pull_zyx(result_image) - b = cle.pull_zyx(reference) + a = cle.pull(result_image) + b = cle.pull(reference) print(a) print(b) @@ -106,7 +106,7 @@ def test_statistics_of_background_and_labelled_pixels(): def test_statistics_of_background_and_labelled_pixels_3d(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [ [0, 1, 2], ],[ @@ -116,7 +116,7 @@ def test_statistics_of_background_and_labelled_pixels_3d(): ] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [ [0, 0, 1], ], [ @@ -126,7 +126,7 @@ def test_statistics_of_background_and_labelled_pixels_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ # IDENTIFIER(0), [0., 1., 2.], # BOUNDING_BOX_X(1), @@ -209,8 +209,8 @@ def test_statistics_of_background_and_labelled_pixels_3d(): result = cle.statistics_of_background_and_labelled_pixels(intensity, labels) result_image = cle.push_regionprops(result, first_row_index=0) - a = cle.pull_zyx(result_image) - b = cle.pull_zyx(reference) + a = cle.pull(result_image) + b = cle.pull(reference) print(a) print(b) @@ -221,11 +221,11 @@ def test_statistics_of_background_and_labelled_pixels_3d(): def test_statistics_of_background_and_labelled_pixels_gpu_compare_to_clij2(): from skimage.io import imread - blobs = cle.push_zyx(imread('data/mini_blobs.tif')) - labels = cle.push_zyx(imread('data/mini_blobs_otsu_labels_excluded_edges_imagej.tif')) + blobs = cle.push(imread('data/mini_blobs.tif')) + labels = cle.push(imread('data/mini_blobs_otsu_labels_excluded_edges_imagej.tif')) regionprops = cle.statistics_of_background_and_labelled_pixels(blobs, labels) - table = cle.pull_zyx(cle.transpose_xy(cle.push_regionprops(regionprops))) + table = cle.pull(cle.transpose_xy(cle.push_regionprops(regionprops))) print(table) diff --git a/tests/test_statistics_of_image.py b/tests/test_statistics_of_image.py index 06a06268..c70b6265 100644 --- a/tests/test_statistics_of_image.py +++ b/tests/test_statistics_of_image.py @@ -2,7 +2,7 @@ import numpy as np def test_statistics_of_labelled_pixels(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [0, 1, 2], [1, 2, 3], [2, 3, 4] diff --git a/tests/test_statistics_of_labelled_pixels.py b/tests/test_statistics_of_labelled_pixels.py index 0e8b24c3..8e8a4077 100644 --- a/tests/test_statistics_of_labelled_pixels.py +++ b/tests/test_statistics_of_labelled_pixels.py @@ -3,19 +3,19 @@ def test_statistics_of_labelled_pixels(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [0, 1, 2], [1, 2, 3], [2, 3, 4] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 2], [1, 2, 2], [3, 3, 3] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ #IDENTIFIER(0), [1., 2., 3.], # BOUNDING_BOX_X(1), @@ -101,8 +101,8 @@ def test_statistics_of_labelled_pixels(): result_image = cle.push_regionprops(result, first_row_index=1) - a = cle.pull_zyx(result_image) - b = cle.pull_zyx(reference) + a = cle.pull(result_image) + b = cle.pull(reference) print(a) print(b) @@ -110,7 +110,7 @@ def test_statistics_of_labelled_pixels(): assert (np.allclose(a, b, 0.0001)) def test_statistics_of_labelled_pixels_3d(): - intensity = cle.push_zyx(np.asarray([ + intensity = cle.push(np.asarray([ [ [0, 1, 2], ],[ @@ -120,7 +120,7 @@ def test_statistics_of_labelled_pixels_3d(): ] ])) - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [ [1, 1, 2], ], [ @@ -130,7 +130,7 @@ def test_statistics_of_labelled_pixels_3d(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ # IDENTIFIER(0), [1., 2., 3.], # BOUNDING_BOX_X(1), @@ -217,8 +217,8 @@ def test_statistics_of_labelled_pixels_3d(): result_image = cle.push_regionprops(result, first_row_index=1) - a = cle.pull_zyx(result_image) - b = cle.pull_zyx(reference) + a = cle.pull(result_image) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_subtract_image_from_scalar.py b/tests/test_subtract_image_from_scalar.py index 2ddf6eee..d8c0d60e 100644 --- a/tests/test_subtract_image_from_scalar.py +++ b/tests/test_subtract_image_from_scalar.py @@ -3,13 +3,13 @@ def test_subtract_image_from_scalar(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0], [1, 1], [2, 2] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [5, 5], [4, 4], [3, 3] @@ -18,8 +18,8 @@ def test_subtract_image_from_scalar(): result = cle.create(test1) cle.subtract_image_from_scalar(test1, result, 5) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_subtract_images.py b/tests/test_subtract_images.py index d13c81b5..ab825f32 100644 --- a/tests/test_subtract_images.py +++ b/tests/test_subtract_images.py @@ -10,7 +10,7 @@ def test_subtract_images(): reference = np.asarray([[3, 3, 4]]) output = cle.subtract_images(input2, input1) - result = cle.pull_zyx(output) + result = cle.pull(output) assert np.array_equal(result, reference) diff --git a/tests/test_sum_of_all_pixels.py b/tests/test_sum_of_all_pixels.py index 2549f86d..25dd5514 100644 --- a/tests/test_sum_of_all_pixels.py +++ b/tests/test_sum_of_all_pixels.py @@ -2,7 +2,7 @@ import numpy as np def test_sum_of_all_pixels_3d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [0, 4, 0, 0, 2], [0, 0, 0, 8, 0], @@ -18,7 +18,7 @@ def test_sum_of_all_pixels_3d(): def test_sum_of_all_pixels_2d(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 4, 0, 0, 2], [0, 0, 0, 8, 0], [3, 0, 0, 0, 0], @@ -31,7 +31,7 @@ def test_sum_of_all_pixels_2d(): assert s == 20 def test_sum_of_all_pixels_1d(): - test1 = cle.push_zyx(np.asarray( + test1 = cle.push(np.asarray( [0, 4, 0, 0, 2] )) @@ -41,7 +41,7 @@ def test_sum_of_all_pixels_1d(): def test_sum_of_all_pixels_1d_y(): - test1 = cle.push_zyx(np.asarray( + test1 = cle.push(np.asarray( [[0], [4], [0], [0], [2]] )) @@ -50,7 +50,7 @@ def test_sum_of_all_pixels_1d_y(): assert s == 6 def test_sum_of_all_pixels_1d_z(): - test1 = cle.push_zyx(np.asarray( + test1 = cle.push(np.asarray( [[[0]], [[4]], [[0]], [[0]], [[2]]] )) diff --git a/tests/test_sum_reduction.py b/tests/test_sum_reduction.py index aa888a6b..56943800 100644 --- a/tests/test_sum_reduction.py +++ b/tests/test_sum_reduction.py @@ -6,11 +6,11 @@ reference_2 = np.asarray([[1, 1, 0, 2, 0, 1]]) def sum_reduction(source, blocksize): - flagged_indices = cle.push_zyx(source) + flagged_indices = cle.push(source) block_sums = cle.sum_reduction_x(flagged_indices, blocksize=blocksize) - return cle.pull_zyx(block_sums) + return cle.pull(block_sums) def test_sum_reduction(): diff --git a/tests/test_sum_x_projection.py b/tests/test_sum_x_projection.py index 1865358c..8f7f6450 100644 --- a/tests/test_sum_x_projection.py +++ b/tests/test_sum_x_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_sum_x_projection(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -36,7 +36,7 @@ def test_sum_x_projection(): ] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [2, 5, 9, 4, 25], [6, 6, 8, 10, 0], [0, 1, 3, 1, 30], @@ -47,8 +47,8 @@ def test_sum_x_projection(): result = cle.create(reference) cle.sum_x_projection(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_sum_y_projection.py b/tests/test_sum_y_projection.py index 41f07a76..28fbf427 100644 --- a/tests/test_sum_y_projection.py +++ b/tests/test_sum_y_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_sum_y_projection(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -36,7 +36,7 @@ def test_sum_y_projection(): ] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [9, 6, 7, 15, 29], [9, 6, 7, 15, 29], [9, 6, 7, 15, 29], @@ -47,8 +47,8 @@ def test_sum_y_projection(): result = cle.create(reference) cle.sum_y_projection(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_sum_z_projection.py b/tests/test_sum_z_projection.py index 38858f30..cc1cfc7e 100644 --- a/tests/test_sum_z_projection.py +++ b/tests/test_sum_z_projection.py @@ -2,7 +2,7 @@ import numpy as np def test_sum_z_projection(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 0, 0, 0, 9], [0, 2, 0, 8, 0], @@ -36,7 +36,7 @@ def test_sum_z_projection(): ] ]).T) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [10, 10, 14, 11, 21], [10, 10, 14, 11, 21], [10, 14, 11, 10, 21], @@ -47,8 +47,8 @@ def test_sum_z_projection(): result = cle.create(reference) cle.sum_z_projection(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) diff --git a/tests/test_threshold_otsu.py b/tests/test_threshold_otsu.py index 08451ea7..6fbb50ac 100644 --- a/tests/test_threshold_otsu.py +++ b/tests/test_threshold_otsu.py @@ -19,13 +19,13 @@ def test_threshold_otsu_against_scikit_image(): # threshold in GPU import pyclesperanto_prototype as cle - gpu_image = cle.push_zyx(image) + gpu_image = cle.push(image) gpu_binary = cle.threshold_otsu(gpu_image) print(str(binary)) - print(str(cle.pull_zyx(gpu_binary))) + print(str(cle.pull(gpu_binary))) # compare import numpy as np - assert(np.allclose(binary, (cle.pull_zyx(gpu_binary) > 0))) + assert(np.allclose(binary, (cle.pull(gpu_binary) > 0))) diff --git a/tests/test_top_hat_box.py b/tests/test_top_hat_box.py index d62a5e8a..38ab5ae5 100644 --- a/tests/test_top_hat_box.py +++ b/tests/test_top_hat_box.py @@ -3,7 +3,7 @@ def test_top_hat_sphere(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 50, 50, 50, 0], [0, 50, 100, 50, 0], @@ -16,7 +16,7 @@ def test_top_hat_sphere(): print(result) - a = cle.pull_zyx(result) + a = cle.pull(result) assert (np.min(a) == 0) assert (np.max(a) == 50) diff --git a/tests/test_top_hat_sphere.py b/tests/test_top_hat_sphere.py index eb53b79e..3b125be5 100644 --- a/tests/test_top_hat_sphere.py +++ b/tests/test_top_hat_sphere.py @@ -3,7 +3,7 @@ def test_top_hat_sphere(): - test = cle.push_zyx(np.asarray([ + test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 50, 50, 50, 0], [0, 50, 100, 50, 0], @@ -16,7 +16,7 @@ def test_top_hat_sphere(): print(result) - a = cle.pull_zyx(result) + a = cle.pull(result) assert (np.min(a) == 0) assert (np.max(a) == 50) diff --git a/tests/test_touch_matrix_to_adjacency_matrix.py b/tests/test_touch_matrix_to_adjacency_matrix.py index 1120db98..0594f5f3 100644 --- a/tests/test_touch_matrix_to_adjacency_matrix.py +++ b/tests/test_touch_matrix_to_adjacency_matrix.py @@ -3,7 +3,7 @@ def test_touch_matrix_to_adjacency_matrix(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [0, 0, 0, 0, 0], [1, 0, 0, 0, 0], @@ -13,7 +13,7 @@ def test_touch_matrix_to_adjacency_matrix(): ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [1, 1, 0, 0, 0], [1, 1, 1, 1, 0], @@ -25,8 +25,8 @@ def test_touch_matrix_to_adjacency_matrix(): gpu_touch_matrix = cle.touch_matrix_to_adjacency_matrix(gpu_input) - a = cle.pull_zyx(gpu_touch_matrix) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_touch_matrix) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_touch_matrix_to_mesh.py b/tests/test_touch_matrix_to_mesh.py index 9fd55385..73aea39f 100644 --- a/tests/test_touch_matrix_to_mesh.py +++ b/tests/test_touch_matrix_to_mesh.py @@ -3,13 +3,13 @@ def test_touch_matrix_to_mesh(): - gpu_touch_matrix = cle.push_zyx(np.asarray([ + gpu_touch_matrix = cle.push(np.asarray([ [0, 0, 0], [0, 0, 0], [0, 1, 0] ])) - gpu_point_list = cle.push_zyx(np.asarray([ + gpu_point_list = cle.push(np.asarray([ [1, 4], [2, 5] ])) @@ -17,7 +17,7 @@ def test_touch_matrix_to_mesh(): gpu_output = cle.create([5, 5]) cle.set(gpu_output, 0) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], @@ -29,8 +29,8 @@ def test_touch_matrix_to_mesh(): cle.touch_matrix_to_mesh(gpu_point_list, gpu_touch_matrix, gpu_output) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_touching_neighbor_count_map.py b/tests/test_touching_neighbor_count_map.py index 122c7813..63fdc138 100644 --- a/tests/test_touching_neighbor_count_map.py +++ b/tests/test_touching_neighbor_count_map.py @@ -3,7 +3,7 @@ def test_touching_neighbor_count_map(): - labels = cle.push_zyx(np.asarray([ + labels = cle.push(np.asarray([ [1, 1, 0, 3, 3], [1, 1, 2, 3, 3], [0, 2, 2, 2, 0], @@ -11,7 +11,7 @@ def test_touching_neighbor_count_map(): [4, 4, 0, 5, 5] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [2, 2, 0, 2, 2], [2, 2, 5, 2, 2], [0, 5, 5, 5, 0], @@ -22,8 +22,8 @@ def test_touching_neighbor_count_map(): touching_neighbor_count_map = cle.touching_neighbor_count_map(labels) - a = cle.pull_zyx(touching_neighbor_count_map) - b = cle.pull_zyx(reference) + a = cle.pull(touching_neighbor_count_map) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_translate.py b/tests/test_translate.py index 3ef98092..222bcb10 100644 --- a/tests/test_translate.py +++ b/tests/test_translate.py @@ -2,7 +2,7 @@ import numpy as np def test_translate(): - source = cle.push_zyx(np.asarray([[ + source = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], @@ -10,7 +10,7 @@ def test_translate(): [0, 0, 0, 0, 0], ]])) - reference = cle.push_zyx(np.asarray([[ + reference = cle.push(np.asarray([[ [0, 0, 0, 0, 0], [0, 1, 1, 0, 0], [0, 0, 0, 0, 0], @@ -20,8 +20,8 @@ def test_translate(): result = cle.translate(source, translate_x=-1, translate_y=-1) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) diff --git a/tests/test_transpose_xy.py b/tests/test_transpose_xy.py index 4fbb52f1..9db96878 100644 --- a/tests/test_transpose_xy.py +++ b/tests/test_transpose_xy.py @@ -2,7 +2,7 @@ import numpy as np def test_transpose_xy(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [0, 1], [2, 3] @@ -12,7 +12,7 @@ def test_transpose_xy(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 2], [1, 3] @@ -25,8 +25,8 @@ def test_transpose_xy(): result = cle.create(test1) cle.transpose_xy(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -34,7 +34,7 @@ def test_transpose_xy(): assert (np.array_equal(a, b)) def test_transpose_xy_3d_generate_output(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 2, 6], [3, 4, 5] @@ -43,21 +43,21 @@ def test_transpose_xy_3d_generate_output(): result = cle.transpose_xy(test1) - a = cle.pull_zyx(result) + a = cle.pull(result) assert (np.min(a) == 1) assert (np.max(a) == 6) assert (np.mean(a) == 3.5) def test_transpose_xy_2d_generate_output(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [1, 2, 6], [3, 4, 5] ])) result = cle.transpose_xy(test1) - a = cle.pull_zyx(result) + a = cle.pull(result) print(a) @@ -66,13 +66,13 @@ def test_transpose_xy_2d_generate_output(): assert (np.mean(a) == 3.5) def test_transpose_xy_1d_generate_output(): - test1 = cle.push_zyx(np.asarray( + test1 = cle.push(np.asarray( [1, 2, 6, 3, 4, 5] )) result = cle.transpose_xy(test1) - a = cle.pull_zyx(result) + a = cle.pull(result) print(a) diff --git a/tests/test_transpose_xz.py b/tests/test_transpose_xz.py index bd24fb77..6b78dabc 100644 --- a/tests/test_transpose_xz.py +++ b/tests/test_transpose_xz.py @@ -2,7 +2,7 @@ import numpy as np def test_transpose_xz(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [0, 1], [2, 3] @@ -12,7 +12,7 @@ def test_transpose_xz(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 4], [2, 6] @@ -25,15 +25,15 @@ def test_transpose_xz(): result = cle.create(test1) cle.transpose_xz(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) assert (np.array_equal(a, b)) def test_transpose_xz_3d_generate_output(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 2, 6], [3, 4, 5] @@ -42,21 +42,21 @@ def test_transpose_xz_3d_generate_output(): result = cle.transpose_xz(test1) - a = cle.pull_zyx(result) + a = cle.pull(result) assert (np.min(a) == 1) assert (np.max(a) == 6) assert (np.mean(a) == 3.5) def test_transpose_xz_2d_generate_output(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [1, 2, 6], [3, 4, 5] ])) result = cle.transpose_xz(test1) - a = cle.pull_zyx(result) + a = cle.pull(result) print(a) @@ -65,13 +65,13 @@ def test_transpose_xz_2d_generate_output(): assert (np.mean(a) == 3.5) def test_transpose_xz_1d_generate_output(): - test1 = cle.push_zyx(np.asarray( + test1 = cle.push(np.asarray( [1, 2, 6, 3, 4, 5] )) result = cle.transpose_xz(test1) - a = cle.pull_zyx(result) + a = cle.pull(result) print(a) diff --git a/tests/test_transpose_yz.py b/tests/test_transpose_yz.py index 68a1fd75..d2bef55b 100644 --- a/tests/test_transpose_yz.py +++ b/tests/test_transpose_yz.py @@ -2,7 +2,7 @@ import numpy as np def test_transpose_yz(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [0, 1], [2, 3] @@ -12,7 +12,7 @@ def test_transpose_yz(): ] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [0, 1], [4, 5] @@ -25,8 +25,8 @@ def test_transpose_yz(): result = cle.create(test1) cle.transpose_yz(test1, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -34,7 +34,7 @@ def test_transpose_yz(): assert (np.array_equal(a, b)) def test_transpose_yz_3d_generate_output(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [ [1, 2, 6], [3, 4, 5] @@ -43,21 +43,21 @@ def test_transpose_yz_3d_generate_output(): result = cle.transpose_yz(test1) - a = cle.pull_zyx(result) + a = cle.pull(result) assert (np.min(a) == 1) assert (np.max(a) == 6) assert (np.mean(a) == 3.5) def test_transpose_yz_2d_generate_output(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [1, 2, 6], [3, 4, 5] ])) result = cle.transpose_yz(test1) - a = cle.pull_zyx(result) + a = cle.pull(result) print(a) @@ -66,13 +66,13 @@ def test_transpose_yz_2d_generate_output(): assert (np.mean(a) == 3.5) def test_transpose_yz_1d_generate_output(): - test1 = cle.push_zyx(np.asarray( + test1 = cle.push(np.asarray( [1, 2, 6, 3, 4, 5] )) result = cle.transpose_yz(test1) - a = cle.pull_zyx(result) + a = cle.pull(result) print(a) diff --git a/tests/test_undefined_to_zero.py b/tests/test_undefined_to_zero.py index f89e5239..657aaca7 100644 --- a/tests/test_undefined_to_zero.py +++ b/tests/test_undefined_to_zero.py @@ -3,7 +3,7 @@ def test_undefined_to_zero(): - test1 = cle.push_zyx(np.asarray([ + test1 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 0, 0], [0, 1, 1, 0, 0], @@ -11,7 +11,7 @@ def test_undefined_to_zero(): [0, 0, 0, 0, 0] ])) - test2 = cle.push_zyx(np.asarray([ + test2 = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], [0, 0, 1, 1, 0], @@ -19,7 +19,7 @@ def test_undefined_to_zero(): [0, 0, 0, 0, 0] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 1, 0, 0], @@ -35,8 +35,8 @@ def test_undefined_to_zero(): print(divided_no_nan) - a = cle.pull_zyx(divided_no_nan) - b = cle.pull_zyx(reference) + a = cle.pull(divided_no_nan) + b = cle.pull(reference) print(a) diff --git a/tests/test_voronoi_labeling.py b/tests/test_voronoi_labeling.py index 622d71f9..cbf79873 100644 --- a/tests/test_voronoi_labeling.py +++ b/tests/test_voronoi_labeling.py @@ -3,7 +3,7 @@ def test_voronoi_labeling(): - gpu_input = cle.push_zyx(np.asarray([ + gpu_input = cle.push(np.asarray([ [ [0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0], @@ -14,7 +14,7 @@ def test_voronoi_labeling(): ] ])) - gpu_reference = cle.push_zyx(np.asarray([ + gpu_reference = cle.push(np.asarray([ [ [1, 1, 1, 3, 3, 3], [1, 1, 1, 3, 3, 3], @@ -27,8 +27,8 @@ def test_voronoi_labeling(): gpu_output = cle.voronoi_labeling(gpu_input) - a = cle.pull_zyx(gpu_output) - b = cle.pull_zyx(gpu_reference) + a = cle.pull(gpu_output) + b = cle.pull(gpu_reference) print(a) print(b) diff --git a/tests/test_write_values_to_positions.py b/tests/test_write_values_to_positions.py index df215743..7afe95f7 100644 --- a/tests/test_write_values_to_positions.py +++ b/tests/test_write_values_to_positions.py @@ -3,14 +3,14 @@ def test_write_values_to_positions_2d(): - positions_and_values = cle.push_zyx(np.asarray([ + positions_and_values = cle.push(np.asarray([ [0, 0, 2, 3, 5], [0, 1, 3, 2, 6], [8, 7, 6, 5, 4] ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [8, 0, 0, 0, 0, 0], [7, 0, 0, 0, 0, 0], [0, 0, 0, 5, 0, 0], @@ -24,8 +24,8 @@ def test_write_values_to_positions_2d(): cle.set(result, 0) result = cle.write_values_to_positions(positions_and_values, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) @@ -33,7 +33,7 @@ def test_write_values_to_positions_2d(): assert (np.array_equal(a, b)) def test_write_values_to_positions_3d(): - positions_and_values = cle.push_zyx(np.asarray([ + positions_and_values = cle.push(np.asarray([ [0, 0, 2, 3, 5], [0, 1, 3, 2, 6], [0, 0, 0, 0, 1], @@ -41,7 +41,7 @@ def test_write_values_to_positions_3d(): ])) - reference = cle.push_zyx(np.asarray([ + reference = cle.push(np.asarray([ [ [8, 0, 0, 0, 0, 0], [7, 0, 0, 0, 0, 0], @@ -65,8 +65,8 @@ def test_write_values_to_positions_3d(): cle.set(result, 0) result = cle.write_values_to_positions(positions_and_values, result) - a = cle.pull_zyx(result) - b = cle.pull_zyx(reference) + a = cle.pull(result) + b = cle.pull(reference) print(a) print(b) From 5278039f13f67f8e8dd2436e6b7642d992a81506 Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Sun, 10 Jan 2021 20:59:50 +0100 Subject: [PATCH 26/27] reran all notebooks --- demo/basics/browse_operations.ipynb | 2 +- demo/basics/count_blobs.ipynb | 99 +++---- demo/basics/crop_and_paste_images.ipynb | 134 ++------- demo/basics/multiply_matrices.ipynb | 74 +---- .../multiply_vectors_and_matrices.ipynb | 16 +- .../spots_pointlists_matrices_tables.ipynb | 100 ++----- demo/basics/voronoi_diagrams.ipynb | 106 ++----- demo/neighbors/mesh_between_centroids.ipynb | 96 ++----- .../mesh_between_touching_neighbors.ipynb | 127 ++------- demo/neighbors/mesh_nearest_neighbors.ipynb | 162 +++-------- demo/neighbors/mesh_with_distances.ipynb | 256 +++++------------ demo/neighbors/neighborhood_definitions.ipynb | 42 +-- .../quantitative_neighbor_maps.ipynb | 42 ++- ...riptors_based_on_neighborhood_graphs.ipynb | 2 +- demo/tissues/parametric_maps.ipynb | 147 +++------- .../tissue_neighborhood_quantification.ipynb | 163 +++-------- .../tribolium_morphometry.ipynb | 261 ++++-------------- 17 files changed, 449 insertions(+), 1380 deletions(-) diff --git a/demo/basics/browse_operations.ipynb b/demo/basics/browse_operations.ipynb index 83392c1d..4916be13 100644 --- a/demo/basics/browse_operations.ipynb +++ b/demo/basics/browse_operations.ipynb @@ -468,7 +468,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/demo/basics/count_blobs.ipynb b/demo/basics/count_blobs.ipynb index 1c931012..fd5d6ef8 100644 --- a/demo/basics/count_blobs.ipynb +++ b/demo/basics/count_blobs.ipynb @@ -17,7 +17,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Used GPU: Intel(R) UHD Graphics\n" + "Used GPU: GeForce RTX 2080 Ti\n" ] } ], @@ -43,7 +43,7 @@ "output_type": "stream", "text": [ "Loaded image size: (254, 256)\n", - "Image size in GPU: (256, 254)\n" + "Image size in GPU: (254, 256)\n" ] } ], @@ -71,34 +71,24 @@ "execution_count": 3, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:252: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " warn(\"Non-empty compiler output encountered. Set the \"\n", - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\skimage\\io\\_plugins\\matplotlib_plugin.py:150: UserWarning: Float image out of standard range; displaying image with stretched contrast.\n", - " lo, hi, cmap = _get_display_range(image)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of objects in the image: 63.0\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of objects in the image: 63.0\n" + ] } ], "source": [ @@ -108,8 +98,7 @@ "labeled = cle.connected_components_labeling_box(binary)\n", "\n", "# show result\n", - "cmap = matplotlib.colors.ListedColormap ( np.random.rand ( 256,3))\n", - "imshow(cle.pull(labeled), cmap = cmap)\n", + "cle.imshow(labeled, labels=True)\n", "\n", "# The maxmium intensity in a label image corresponds to the number of objects\n", "num_labels = cle.maximum_of_all_pixels(labeled)\n", @@ -128,24 +117,24 @@ "execution_count": 4, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of objects in the image: 63.0\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of objects in the image: 63.0\n" + ] } ], "source": [ @@ -156,7 +145,7 @@ "\n", "# show result\n", "cmap = matplotlib.colors.ListedColormap ( np.random.rand ( 256,3))\n", - "imshow(cle.pull(labeled), cmap = cmap)\n", + "cle.imshow(labeled, labels=True)\n", "\n", "# The maxmium intensity in a label image corresponds to the number of objects\n", "num_labels = cle.maximum_of_all_pixels(labeled)\n", @@ -176,46 +165,24 @@ "execution_count": 5, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17.\n", - " 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35.\n", - " 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53.\n", - " 54. 55. 56. 57. 58. 59. 60. 61. 62. 63.]\n", - "[ 0. 0. 0. 0. 0. 0. 1. 2. 3. 4. 0. 5. 6. 7. 8. 9. 10. 11.\n", - " 12. 13. 0. 14. 15. 16. 17. 0. 18. 19. 0. 20. 21. 22. 23. 24. 25. 26.\n", - " 0. 0. 0. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 0. 37. 38. 39. 40.\n", - " 0. 41. 42. 43. 44. 45. 0. 0. 0. 0.]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:252: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " warn(\"Non-empty compiler output encountered. Set the \"\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of objects in the image: 45.0\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of objects in the image: 45.0\n" + ] } ], "source": [ @@ -224,7 +191,7 @@ "\n", "# show result\n", "cmap = matplotlib.colors.ListedColormap ( np.random.rand ( 256,3))\n", - "imshow(cle.pull(labels_excl_edges), cmap = cmap)\n", + "cle.imshow(labels_excl_edges, labels=True)\n", "\n", "# The maxmium intensity in a label image corresponds to the number of objects\n", "num_labels = cle.maximum_of_all_pixels(labels_excl_edges)\n", @@ -255,7 +222,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/demo/basics/crop_and_paste_images.ipynb b/demo/basics/crop_and_paste_images.ipynb index 98746604..2e96ab7f 100644 --- a/demo/basics/crop_and_paste_images.ipynb +++ b/demo/basics/crop_and_paste_images.ipynb @@ -21,7 +21,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Used GPU: Intel(R) UHD Graphics\n" + "Used GPU: GeForce RTX 2080 Ti\n" ] } ], @@ -49,29 +49,11 @@ "execution_count": 2, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\skimage\\io\\_plugins\\matplotlib_plugin.py:150: UserWarning: Float image out of standard range; displaying image with stretched contrast.\n", - " lo, hi, cmap = _get_display_range(image)\n" - ] - }, { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -84,9 +66,9 @@ "# load data\n", "image = imread('https://samples.fiji.sc/blobs.png')\n", "\n", - "gpu_image = cle.push_zyx(image)\n", + "gpu_image = cle.push(image)\n", "\n", - "imshow(cle.pull_zyx(gpu_image))" + "cle.imshow(gpu_image)" ] }, { @@ -103,29 +85,11 @@ "execution_count": 4, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:252: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " warn(\"Non-empty compiler output encountered. Set the \"\n" - ] - }, { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -143,7 +107,7 @@ "y = 10\n", "cle.crop(gpu_image, tile, x, y)\n", "\n", - "imshow(cle.pull_zyx(tile))" + "cle.imshow(tile)" ] }, { @@ -161,19 +125,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -188,7 +142,7 @@ "# \"white\" background\n", "cle.set(collage, 255)\n", "\n", - "imshow(cle.pull_zyx(collage))" + "cle.imshow(collage)" ] }, { @@ -205,19 +159,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -229,7 +173,7 @@ "source": [ "cle.paste(tile, collage, 2, 2)\n", "\n", - "imshow(cle.pull_zyx(collage))" + "cle.imshow(collage)" ] }, { @@ -239,19 +183,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -264,7 +198,7 @@ "flip_tile = cle.flip(tile, flip_x=True, flip_y=False)\n", "cle.paste(flip_tile, collage, width + 4, 2)\n", "\n", - "imshow(cle.pull_zyx(collage))" + "cle.imshow(collage)" ] }, { @@ -274,19 +208,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -299,7 +223,7 @@ "flip_tile = cle.flip(tile, flip_x=True, flip_y=True)\n", "cle.paste(flip_tile, collage, width + 4, height + 4)\n", "\n", - "imshow(cle.pull_zyx(collage))" + "cle.imshow(collage)" ] }, { @@ -309,19 +233,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -334,7 +248,7 @@ "flip_tile = cle.flip(tile, flip_x=False, flip_y=False)\n", "cle.paste(flip_tile, collage, 2, height + 4)\n", "\n", - "imshow(cle.pull_zyx(collage))" + "cle.imshow(collage)" ] }, { @@ -361,7 +275,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/demo/basics/multiply_matrices.ipynb b/demo/basics/multiply_matrices.ipynb index 00186c66..d14a9e2f 100644 --- a/demo/basics/multiply_matrices.ipynb +++ b/demo/basics/multiply_matrices.ipynb @@ -22,7 +22,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Used GPU: Intel(R) UHD Graphics\n" + "Used GPU: GeForce RTX 2080 Ti\n" ] } ], @@ -54,8 +54,8 @@ "array1 = np.asarray([[1, 2, 3, 4, 5]])\n", "array2 = np.asarray([[6, 7, 8, 9, 10]])\n", "\n", - "vector1 = cle.push_zyx(array1)\n", - "vector2 = cle.push_zyx(array2)" + "vector1 = cle.push(array1)\n", + "vector2 = cle.push(array2)" ] }, { @@ -82,14 +82,6 @@ " [5.]]\n", "Vector 2: [[ 6. 7. 8. 9. 10.]]\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:252: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " warn(\"Non-empty compiler output encountered. Set the \"\n" - ] } ], "source": [ @@ -128,29 +120,11 @@ "execution_count": 5, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\skimage\\io\\_plugins\\matplotlib_plugin.py:150: UserWarning: Float image out of standard range; displaying image with stretched contrast.\n", - " lo, hi, cmap = _get_display_range(image)\n" - ] - }, { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -160,7 +134,7 @@ } ], "source": [ - "imshow(cle.pull_zyx(matrix))" + "cle.imshow(matrix)" ] }, { @@ -179,36 +153,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[ 2.300576 5.434795 7.2015953 1.9665326 2.7878098 ]\n", - " [ 2.1431756 2.6672165 12.211025 1.9721425 6.0889726 ]\n", - " [ 1.242401 2.8485188 1.1419663 19.148855 15.066084 ]\n", - " [ 0.29924655 22.107227 23.868288 35.846794 18.41019 ]\n", - " [19.919182 32.96476 36.83846 37.116528 7.4400387 ]]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:252: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " warn(\"Non-empty compiler output encountered. Set the \"\n" + "[[ 4.263666 3.1693225 1.5578088 4.3979287 7.979739 ]\n", + " [10.103611 6.284955 15.134996 14.420935 11.526558 ]\n", + " [ 5.338699 19.562077 8.74118 11.574553 17.832518 ]\n", + " [ 7.229021 26.634712 27.240744 7.702599 29.550472 ]\n", + " [23.161533 21.474531 1.0065151 13.321719 39.979126 ]]\n" ] }, { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -226,7 +182,7 @@ "\n", "print(matrix_element_wise_multiplied)\n", "\n", - "imshow(cle.pull_zyx(matrix_element_wise_multiplied))" + "cle.imshow(matrix_element_wise_multiplied)" ] }, { @@ -282,7 +238,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/demo/basics/multiply_vectors_and_matrices.ipynb b/demo/basics/multiply_vectors_and_matrices.ipynb index c55007e4..f75cb940 100644 --- a/demo/basics/multiply_vectors_and_matrices.ipynb +++ b/demo/basics/multiply_vectors_and_matrices.ipynb @@ -47,8 +47,8 @@ "voxel_size = np.asarray([[0.2], [0.2], [0.5]])\n", "print(\"Array shape:\" + str(voxel_size.shape))\n", "\n", - "gpu_voxel_size = cle.push_zyx(voxel_size)\n", - "print(\"GPU array shape:\" + str(voxel_size.shape))\n" + "gpu_voxel_size = cle.push(voxel_size)\n", + "print(\"GPU array shape:\" + str(voxel_size.shape))" ] }, { @@ -75,7 +75,7 @@ ")\n", "print(\"Array shape:\" + str(pointlist.shape))\n", "\n", - "gpu_pointlist = cle.push_zyx(pointlist)\n", + "gpu_pointlist = cle.push(pointlist)\n", "print(\"GPU array shape:\" + str(gpu_pointlist.shape))" ] }, @@ -137,14 +137,6 @@ " [0. 1.2 0.2 0.4]\n", " [4.5 5.5 3. 1. ]]\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:252: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " warn(\"Non-empty compiler output encountered. Set the \"\n" - ] } ], "source": [ @@ -205,7 +197,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/demo/basics/spots_pointlists_matrices_tables.ipynb b/demo/basics/spots_pointlists_matrices_tables.ipynb index 3177ad76..23dd0593 100644 --- a/demo/basics/spots_pointlists_matrices_tables.ipynb +++ b/demo/basics/spots_pointlists_matrices_tables.ipynb @@ -16,14 +16,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Used GPU: gfx902\n" + "Used GPU: GeForce RTX 2080 Ti\n" ] } ], @@ -48,22 +48,12 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -85,9 +75,9 @@ " ]\n", ")\n", "\n", - "spots_image = cle.push_zyx(array)\n", + "spots_image = cle.push(array)\n", "\n", - "imshow(cle.pull_zyx(spots_image))" + "cle.imshow(spots_image)" ] }, { @@ -99,24 +89,14 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -129,7 +109,7 @@ "labeled_spots = cle.connected_components_labeling_box(spots_image)\n", "pointlist = cle.create([3, 5])\n", "cle.labelled_spots_to_pointlist(labeled_spots, pointlist)\n", - "imshow(cle.pull_zyx(pointlist))" + "cle.imshow(pointlist)" ] }, { @@ -141,24 +121,14 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPUAAAD4CAYAAAA0L6C7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAKO0lEQVR4nO3dX6ifBR3H8c+n43GzmYRoQzZRgxJkkMZhoUaRUcw/VFehkDcG56KEiUHmTZB33UQ33QyViv4MQYMo+zNyKqM5PbNp7k8xluKGtUpCJzU969PF+W2c09l2nvPb85zn8cv7BQfP2e/Hbx9k7z3n95z9fo+TCEAd7+l7AIB2ETVQDFEDxRA1UAxRA8Wc18WDnu9VWa01XTw0AEn/0Vt6O8d9uts6iXq11uhj/nQXDw1A0q787oy38e03UAxRA8UQNVAMUQPFEDVQDFEDxRA1UAxRA8UQNVAMUQPFEDVQDFEDxRA1UEyjqG1vsv0n2wdtf6PrUQDGt2TUtickfU/SzZKukXSH7Wu6HgZgPE2O1BslHUxyKMnbkrZK+ny3swCMq0nU6yS9Ou/rw6NfW8D2tO0Z2zPv6Hhb+wAsU2snypJsSTKVZGpSq9p6WADL1CTqI5Iun/f1+tGvARigJlE/J+lDtq+yfb6k2yX9vNtZAMa15BsPJpm1fbek30iakPRwkr2dLwMwlkbvJprkcUmPd7wFQAv4F2VAMUQNFEPUQDFEDRRD1EAxRA0UQ9RAMUQNFEPUQDFEDRRD1EAxRA0U0+gFHWjfkftu6HvCArNr0veEBc7b8EbfExa568M7+55wyoEvnjjjbRypgWKIGiiGqIFiiBoohqiBYogaKIaogWKIGiiGqIFiiBoohqiBYogaKIaogWKIGiiGqIFiloza9sO2j9p+aSUGATg3TY7U35e0qeMdAFqyZNRJnpb0+gpsAdCC1t7OyPa0pGlJWq33tvWwAJaptRNlSbYkmUoyNalVbT0sgGXi7DdQDFEDxTT5kdZPJe2UdLXtw7a/3P0sAONa8kRZkjtWYgiAdvDtN1AMUQPFEDVQDFEDxRA1UAxRA8UQNVAMUQPFEDVQDFEDxRA1UAxRA8W09s4nQ3bkvhv6nrDIum//vu8JC1zw1Nq+Jyxw8J+X9D1hkXsvPtT3hFO2Thw/420cqYFiiBoohqiBYogaKIaogWKIGiiGqIFiiBoohqiBYogaKIaogWKIGiiGqIFiiBoopskF8i63vd32Ptt7bW9eiWEAxtPk9dSzkr6W5Hnb75O02/a2JPs63gZgDEseqZO8luT50edvStovaV3XwwCMZ1nvfGL7SknXSdp1mtumJU1L0mq9t41tAMbQ+ESZ7QslPSrpniRv/P/tSbYkmUoyNalVbW4EsAyNorY9qbmgf5zksW4nATgXTc5+W9JDkvYn+U73kwCciyZH6hsl3SnpJtt7Rh+3dLwLwJiWPFGWZIckr8AWAC3gX5QBxRA1UAxRA8UQNVAMUQPFEDVQDFEDxRA1UAxRA8UQNVAMUQPFEDVQzLLe+eTdanZN+p6wyAVPre17wgL//uTf+p6wwOwDH+x7wiIbdn2l7wmn/OXomV8FzZEaKIaogWKIGiiGqIFiiBoohqiBYogaKIaogWKIGiiGqIFiiBoohqiBYogaKIaogWKaXPVyte1nbb9ge6/tb63EMADjafJ66uOSbkpybHSd6h22f5XkmY63ARhDk6teRtKx0ZeTo4/hvesAAEkNn1PbnrC9R9JRSduS7DrNfaZtz9ieeUfHW54JoKlGUSc5keRaSeslbbS94TT32ZJkKsnUpFa1PBNAU8s6+53kX5K2S9rUyRoA56zJ2e9Lbb9/9PkFkj4j6UDHuwCMqcnZ78sk/cD2hOb+EngkyS+6nQVgXE3Ofr8o6boV2AKgBfyLMqAYogaKIWqgGKIGiiFqoBiiBoohaqAYogaKIWqgGKIGiiFqoBiiBopp8iqtd73zNrzR94RFDv7zkr4nLDD7wAf7nrDAFd/c2feERV554Pq+J5ySsxyOOVIDxRA1UAxRA8UQNVAMUQPFEDVQDFEDxRA1UAxRA8UQNVAMUQPFEDVQDFEDxRA1UEzjqEcXnv+DbS6OBwzYco7UmyXt72oIgHY0itr2ekm3Snqw2zkAzlXTI/V3JX1d0n/PdAfb07ZnbM+8o+NtbAMwhiWjtn2bpKNJdp/tfkm2JJlKMjWpVa0NBLA8TY7UN0r6nO2XJW2VdJPtH3W6CsDYlow6yf1J1ie5UtLtkp5I8qXOlwEYCz+nBopZ1lsEJ3lS0pOdLAHQCo7UQDFEDRRD1EAxRA0UQ9RAMUQNFEPUQDFEDRRD1EAxRA0UQ9RAMUQNFEPUQDHLepXWu9VdH97Z94RF7r34UN8TFtiw6yt9T1jglQeu73vCIld8czh/jv6at854G0dqoBiiBoohaqAYogaKIWqgGKIGiiFqoBiiBoohaqAYogaKIWqgGKIGiiFqoBiiBopp9NLL0bWp35R0QtJskqkuRwEY33JeT/2pJP/obAmAVvDtN1BM06gj6be2d9uePt0dbE/bnrE9846Ot7cQwLI0/fb740mO2P6ApG22DyR5ev4dkmyRtEWSLvLFaXkngIYaHamTHBn996ikn0na2OUoAONbMmrba2y/7+Tnkj4r6aWuhwEYT5Nvv9dK+pntk/f/SZJfd7oKwNiWjDrJIUkfWYEtAFrAj7SAYogaKIaogWKIGiiGqIFiiBoohqiBYogaKIaogWKIGiiGqIFiiBooxkn772dg+++SXmnhoS6RNKT3RWPP2Q1tjzS8TW3tuSLJpae7oZOo22J7ZkjvXMqesxvaHml4m1ZiD99+A8UQNVDM0KPe0veA/8OesxvaHml4mzrfM+jn1ACWb+hHagDLRNRAMYOM2vYm23+yfdD2Nwaw52HbR20P4q2RbV9ue7vtfbb32t7c857Vtp+1/cJoz7f63HOS7Qnbf7D9i763SHMXmrT9R9t7bM909vsM7Tm17QlJf5b0GUmHJT0n6Y4k+3rc9AlJxyT9MMmGvnbM23OZpMuSPD96T/bdkr7Q1/8jz71/9Jokx2xPStohaXOSZ/rYM2/XvZKmJF2U5LY+t4z2vCxpqusLTQ7xSL1R0sEkh5K8LWmrpM/3OWh0iaHX+9wwX5LXkjw/+vxNSfslretxT5IcG305Ofro9Whhe72kWyU92OeOPgwx6nWSXp339WH1+Ad26GxfKek6Sbt63jFhe4+ko5K2Jel1j6TvSvq6pP/2vGO+JS802YYhRo2GbF8o6VFJ9yR5o88tSU4kuVbSekkbbff2NMX2bZKOJtnd14Yz+HiSj0q6WdJXR0/rWjfEqI9Iunze1+tHv4Z5Rs9dH5X04ySP9b3npCT/krRd0qYeZ9wo6XOj57BbJd1k+0c97pG0cheaHGLUz0n6kO2rbJ8v6XZJP+9506CMTkw9JGl/ku8MYM+ltt8/+vwCzZ3kPNDXniT3J1mf5ErN/fl5IsmX+tojreyFJgcXdZJZSXdL+o3mTgA9kmRvn5ts/1TSTklX2z5s+8t97tHckehOzR2B9ow+bulxz2WSttt+UXN/KW9LMogfIw3IWkk7bL8g6VlJv+zqQpOD+5EWgHMzuCM1gHND1EAxRA0UQ9RAMUQNFEPUQDFEDRTzP5/4ZhJuKBAAAAAAAElFTkSuQmCC\n", "text/plain": [ - "" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -170,7 +140,7 @@ "source": [ "distance_matrix = cle.generate_distance_matrix(pointlist, pointlist)\n", "\n", - "imshow(cle.pull_zyx(distance_matrix))" + "cle.imshow(distance_matrix)" ] }, { @@ -182,24 +152,14 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -211,7 +171,7 @@ "source": [ "label_voronoi = cle.voronoi_labeling(spots_image)\n", "\n", - "imshow(cle.pull_zyx(label_voronoi))" + "cle.imshow(label_voronoi)" ] }, { @@ -223,22 +183,12 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -253,7 +203,7 @@ "touch_matrix = cle.create([6,6])\n", "cle.generate_touch_matrix(label_voronoi, touch_matrix)\n", "\n", - "imshow(cle.pull_zyx(touch_matrix))" + "cle.imshow(touch_matrix)" ] }, { @@ -265,13 +215,13 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([[0.],\n", + "cl.Array([[0.],\n", " [0.],\n", " [1.],\n", " [2.],\n", @@ -279,7 +229,7 @@ " [2.]], dtype=float32)" ] }, - "execution_count": 32, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -313,7 +263,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/demo/basics/voronoi_diagrams.ipynb b/demo/basics/voronoi_diagrams.ipynb index 464d01cb..f7e4b4bc 100644 --- a/demo/basics/voronoi_diagrams.ipynb +++ b/demo/basics/voronoi_diagrams.ipynb @@ -14,14 +14,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Used GPU: gfx902\n" + "Used GPU: GeForce RTX 2080 Ti\n" ] } ], @@ -46,32 +46,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\skimage\\io\\_plugins\\matplotlib_plugin.py:150: UserWarning: Float image out of standard range; displaying image with stretched contrast.\n", - " lo, hi, cmap = _get_display_range(image)\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -84,14 +66,14 @@ "# load data\n", "image = imread('https://samples.fiji.sc/blobs.png')\n", "\n", - "gpu_image = cle.push_zyx(image)\n", + "gpu_image = cle.push(image)\n", "\n", - "imshow(cle.pull_zyx(gpu_image))" + "cle.imshow(gpu_image)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -100,22 +82,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -129,12 +101,12 @@ "source": [ "binary = cle.greater_constant(gpu_image, constant=128)\n", "\n", - "imshow(cle.pull_zyx(binary))" + "cle.imshow(binary)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -143,34 +115,14 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:253: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " \"to see more.\", CompilerWarning)\n", - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\skimage\\io\\_plugins\\matplotlib_plugin.py:150: UserWarning: Float image out of standard range; displaying image with stretched contrast.\n", - " lo, hi, cmap = _get_display_range(image)\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -182,7 +134,7 @@ "source": [ "labels = cle.voronoi_labeling(binary)\n", "\n", - "imshow(cle.pull_zyx(labels))" + "cle.imshow(labels, labels=True)" ] }, { @@ -194,30 +146,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 7, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:253: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " \"to see more.\", CompilerWarning)\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAASQAAAEYCAYAAAD1QYs6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAfmElEQVR4nO2dT6wfV3XHv6cBsoAskqaJjGMVg8wi2QSe5S5SIboogWwcFqnMArlSKrMIFUitVAcWsKQVfzZVkYyIcCua1BKgeNUSIiR2JHYUkjhpiCERMbZioVQCdREac7p4M/HN9Z2ZOzP3zzl3zkd6er83b/6cuX++99xz//yImWEYhiGBP6ptgGEYRo8JkmEYYjBBMgxDDCZIhmGIwQTJMAwxmCAZhiGGbIJERB8noheJ6DwRHc/1HMMw2oFyzEMiousA/BzAXwK4AOBJAJ9i5ueTP8wwjGbI5SEdAnCemX/JzL8H8AiAw5meZRhGI7wj0333AnjV+fsCgD9zTyCiYwCOdX/uZLIjKTs7u2aePXu2siXXItm2KTTaLtnm3jZAjH2/YeY/iTkxV5ftPgB3M/PfdH9/GsAhZv7bgfNVrF/p04qIKltyLZJtm0Kj7ZJt9uu0ABvPMvPBmBNzddkuANjn/H0bgIuZnmUYRdEgRkT0ln2a1qvmEqQnARwgov1E9C4ARwCczvQswzAG0CZKWWJIzPwmEX0WwH8BuA7AQ8x8LsezDMPYZchzIyIwM5hZpFfnkiWGNNsIiyGtRrJtU2iyXbKtU7ZVtL16DMkwopDQILaAZKGcgwlSJFZx8mNpvIxYMdIQTzJBGqHvd0vOQEBv66h9REgCc/NeejqLECR3IpcUQnM53MyUmqFaCFUk6ZVFGlobojFECBIgpxC6YtOLUKjS9OcaaZEsShJtag0xo2wS1N5Nixg75p6fAwnptgTBI0KD9MPmEmxba0Phd9A3yiapZZzbHwdk2K2FmMogqTz4c3gk2dYaYgQJqJvRS1uMmrGl1iuEhJidxDRO4d1IFVVRglSLlBns3i8XmoPqS0eF3GtLEIolhuzSmg9SybX9yGJKT3NP2ZcOVZ419x0q7KF7Sohr5MKN2+RmTjr6oqSxvEpbUiLSQ2qh9VnT3Ri6JtRSh54nlTWVSXJl15D2WhDnIZUkd8vmtuxDzxorxEsqhrQWLyX9++V4Nw0epgYb17JpQSqB33rGtKItFziJpIohttwYlMIEqRBDbn3qwmsVYx5b8Do0ITKGVILaBXEsHpTi3oDFNKZIXQZypnvt8lqKzQpSDbZSqHKTosJrzIsctkprvEyQGkVaQZMkADltkZbuMUiyWawgSUokQw5ry0UJYbSyuxyxgtQaNTwEqxhX8Wdea2JLAxSbFCStBdNYRo1dGVI1BltrTDYpSKWpKYDmJV3FGiD5mCBtgNqiVGt4vXY3rXa6a0S0IFmGGkNMlQ0Jm+e5z15ShkuKqZS6JlqQjHRIKXAlGNs2xJDN5gSptAsvKYDekihNLVaWkN49S9K95nvULB9qBKmFSmSkI1TJJYpRj/TGwLerj7+Vtlfs4tpQQkiJC8QiuYKUInUaaC4XsQufJXjxvtCXskWkIA0VMC2toWRK7wbgPs8/Dqz3GEruJpmCofSowZiQ+/WuVH0TJ0hjLx4Sp9jWJnQ8Z+KaYO4SMwo2h6FyIaGCpyZnGZ3jVYY2Goy5bgliBGnui4a2iB3ypvzrpnZxbJ1SXtJY+uaYm6RhH6g5753rfZaIylDMLrVtIgTJ/Srtpdu2AmERGvO0Yr2suWxV6HpiCvwW02Zuucghsms9nKGu3NL7+YgZZVszZyR0bcz93HNS9eu1iFGuUZ+aAWbJI1lLy0WuhjLFfYemXKy6p4TMI6IkRqwRg6Gga6nn1yKVzVJGuqTmwVq71npJJdJl5Bn6vkq7Nn6rIUGoNZDDbW+NHKI/55pSIp3CQ21GkFIl+tJunFYBS7HWqr+PidG1pCyX7v3mPDvF82NZK0rNCFJqQsG7mCFsjZVy7dIGSe8sKY4kZfmHplieiFG2teTK+JjlCVJjFnNZMmFP6jtrmQKQCwkN5NI8MA8pgt4LGBvy3BpbrOhzyNFQxXgekjzXJc9vwkMqSahQ1M74FEiYsJeSml5SqRGtoWF3Sfky1xb1HlKtTJCU6WtZMmHPvU4qWuycw9BIsEQxWsIqD4mIXgHwOwBXALzJzAeJ6CYA/wHgfQBeAfBXzPw/68yUifZYxZpCrOXdS9tZQhhCo8CS82AOKTykv2DmO52JT8cBPM7MBwA83v2dlVYyoyStFeQxSnlKpdO0xbzL0WU7DOBk9/kkgHszPMNYSMpWtcUukSZaTPe1gsQAfkhEZ4noWHfsVma+BADd71tCFxLRMSI6Q0RnVtpgRNJaIH4OucWztHcUmn7SgkCtHWW7i5kvEtEtAB4jov+OvZCZTwA4ASxfyyY9fiGJLXXRSlNaCPy87ONk/f805/EqD4mZL3a/LwP4AYBDAF4joj0A0P2+vNbIgWfnuG2T5BSjrXfbpHid/pInrSwWJCJ6NxHd0H8G8DEAzwE4DeBod9pRAI+uNdJYjnlGV/G7N0srrn99yUmIU/mpvQu3pst2K4AfdAnwDgD/zsz/SURPAjhFRPcD+BWA+9ab+XasksVRcpW3hikAoQo6d6mMf37J943NT81dOHX7IUkTI2n29NQOskokZOOS8q9psayQfIneD0nV0hEhifs2JHoHEtOpNkNpMrdy107T2s/PjZqlI1bJ4rB0ykvNHsXSGfWAnkC3CkGyShZHzXSSXPC1l5+1npnkvPERL0gaCpOEDNeQTsZ8UpUpCWU0BtGCZJUsDksnIwYNoiRWkLRWMnf+R4mM15pOpUiZPqUrdK1N3moiUpBaqGSuKK2diDf1DM3plJPU6dNKeksWJXHD/hozfWh+S2giXap5LxrTSTslp3jkzl+J01UAYYKksZJNzW/xjy8RpKFJcVLTSWM+bg2peSSiy7azsyM2gVLTr3ua8+MisVUDhr3EWt2CXOVJcnenBUQIkoumjC65VqzkAs65hLbDkCJMGtlK4xxC3Fo2TZlR01ZJXtJUOpRekJo7X7Tfv9QzHKLXsonzkLRtnyBFFGoRU7DNYzJiERXU7vG3T+iP1cT1SKTYpA0//fx0HPp7zbMMXYgUJCBceGvsPTN1rCa1u21LhXlImPz7GttDrCD1DHXhUlfEqUoQmlNkrGPKM1qSx9rzaOvet3hB6vEFYYl3MKewhu5tQ755WLNHUQ2kTipsAXFB7TH84e8YYYhdtjE29yd0bm1qi6PUlrx2uqyhVJpKzTtAkYfkM9WFCv0v9ZomY7uYl5QHtYIEXC0U/pCyf06u5xrbRbKXoRnVgtST0xsyrsUqY3oPydJ0F1UxpBChgOjWM9UwtNKEh2RdqPJsXfT9Ed+eNVMVcqTpUO/BHeiRlJdNCBJgQUajDEMxyqldQkuXyakwhj+/T0qdaUaQJKq90RZjntDUdIOSC2ZDdg0hrSFvRpCkJaxRD79L4v8PmCcQc7pkUzse5Fht0NKgTjOCZJRBg+DPmZ+2dvb+3GuHYk9zSSlCkhrzpgRJUsIa9QmVgSU7CqQsS0Nz5uY8I8dcOyl1pylBMoyprpikdXNzA8s5F5f396wtSurnIW2Z0uu2pE+t0DqwEZOPucVoji2xLNmIzzykhYSWrRj10CpGPb53UjNQvcZTWitkJkiGIYSY0cEatkyNHI7dYy4mSEYU2j0QbUhI5yFPbUyI1tptgqQcCYHI2phY5mNsWVaO9DZBMiaxCm+45CwHzQmSeQxh3PSQPlo2BxPLMpRK3+YEqTQShC9mhAZYLkSSV4cbbdGkIJX0kqRVzrH+/hpBkbjFiwlkezQpSFsndpbykvtK6Q6bGJWhdF5PztQmooeI6DIRPeccu4mIHiOil7rfNzr/e5CIzhPRi0R0dy7Dp2gxXjKEWzlLeYQ109XEqF1ilo58B8DHvWPHATzOzAcAPN79DSK6HcARAHd01/wLEV2XzFqBbEHwfGqJksWx2mdSkJj5JwBe9w4fBnCy+3wSwL3O8UeY+Q1mfhnAeQCHEtk6GwmteW5qVdASadsLkD972cSoXZYurr2VmS8BQPf7lu74XgCvOudd6I5dAxEdI6IzRHRmoQ3FGaogNQRPgrfgr1ZPRezmakZeaqRz6qB2qGYE34qZTwA4AQBEJKKEzc2AGvsSS6uM7ujbGoGUsH7LqM9SQXqNiPYw8yUi2gPgcnf8AoB9znm3Abi4xsC1jC1YXHKvqWfkrEShbouEUS/fc1myCVrofkP/k/DORh6WdtlOAzjafT4K4FHn+BEiup6I9gM4AOCJdSauJ7bg9qNUQz8xz8jlwQyNpEnqxvi2zWkIYtPZaJtJD4mIHgbwUQA3E9EFAF8C8BUAp4jofgC/AnAfADDzOSI6BeB5AG8CeICZr2SyPZpSsZZU3phvZ8wuiJK8Bn8SpQSbjHlUGywR0rJmNaJ04uZI0ynbawe4fXLbI+19UyLh3RLbcJaZD8ac2PxM7ZqZu/SZvqDF3Eeal2TopWadaXpP7RoJm+KZoRjRnOtqe70l0j0USK/93sZ6mveQSpPKUzGPZ5yheWBLvEupuMLu7+SQ6r2kiXizglTL7azd/9+akLmVFYj/IkhNaeNPp/A/t0STglRbFLZMibT3nzHWxR2quBpGAV2RnRLetc/wqdWoNSdILYnRUm+nlpdUY3pF7PywMSR180JpGCO8qfHFsBRNBbVri1GO50sJVEsidTqHJnTWoHb5lUAzgmSZaazFFSYbtatDM4JkGKmo4S1JbVD9Wfe5MUEyjAAtxt7WUEqUmhAkDRm6BosjXaVkXlu671IyHdSPsrUuRkvQOkN9i2hJt6GRzRiRmvNu6gUJkJGZWgqWsYytTDSNIaenpFKQtuhCb20GthTcoO7W0z4U4E6dHiJiSDs7O29Vtpgfly0XkBDWXUtPaDrAUHmcg+Z0y7WZnghBmstWdxe0IGtdppZZbCFfcpfBTWzQVoJSrd3Yc7bgHUn0KkJ1SNuGerEstDt6gzaVHtKW0VaAt0DIY9+Kx5QaEySFhIKLW/CONDAkTCZOcagcZTN2CRXyEttqaNi6ozahWEuuTdZawgSpEYYqgPu/XM80hrFu3DxMkJTji0JoFm1sJRgTGPOK1lN6oapGTJAUE7s5WWwlCImOVaC0mCiNY4KkiFAgO8ZbifVoxvZsluQVSbJla+ReMWCjbInI5VGMjdKkLhCh4WuJE1DNw5BBjnwwD0kgQxktYZtVw3Cx1f6NMZWhU4Fmad6LsR1yxMNMkBIxNcTuz0EZI1ZkcoqR5N0FpNkzh9C8JE345bzJ1f4t4MeQ3N9jw+9u3EZivEYiWrurbmXWOIpZYkKnCVIGQgLktiipxEdTYd46ocqsUZRyY4KUCV+A3GOpn7E1tL33mGehRZRKLXcxQUpEyB3XVnG0IL3yurSwbq3kO5ggJaCFQhdCS+stldhyoSGdS5VtEyRDBf7kUMmVF5jfSEkVpdIjgSZIhniGFvZKXT2/1GOWJko17LB5SCtotasmgbHdBUKiJCUP1pYJCfO/apZr85AMcYQGCIaQ4lW43trailzznWo3spsRpFzufY2Mk+QRpGZJHtUWpRx7RZV+p5SCuobmBSkUDK3dmhphtG8Cl2ueWc7y6teH2uk+KUhE9BARXSai55xjXyaiXxPR093PPc7/HiSi80T0IhHdncvwGPyETrVavnYfvySlK8XSGey1vKRSXkXqhjQkRBLKc0xQ+zsA/hnAv3rHv8HMX3UPENHtAI4AuAPAewH8iIg+yMxXEtgaTUxA1K8E5jXVIWXrXDognFuMQuVzTjn17Sqxp9ZaJj0kZv4JgNcj73cYwCPM/AYzvwzgPIBDK+yLJrSR2Vhir/GW+tbERGwda72impSOtyxJI7dO+GVVapqviSF9loie6bp0N3bH9gJ41TnnQncsG2sS21/oGPvjP79lclW8XPct1cV0n1XyGUvLqX+9VJYK0jcBfADAnQAuAfhadzz0psGSQUTHiOgMEZ1ZYsBQH7hkYtce3SlB6ncsMZqTM18kjETFUqNOrGWRIDHza8x8hZn/AOBbuNotuwBgn3PqbQAuDtzjBDMf5Mjv/Paufetz7QTfgiilouRoTo58KRnALvEciSwSJCLa4/z5SQD9CNxpAEeI6Hoi2g/gAIAn1pkY7gvXFiKX1kUpxftJzDdDHpOjbET0MICPAriZiC4A+BKAjxLRndjtjr0C4DMAwMzniOgUgOcBvAnggTUjbEMVQGKBLj3CowVJc1zWoN1r0VI+SUKrTkRvMyIUpM5B6kJWM9iZmznPlTS8nCq9WphKUFFUz8aGZkTN1C49WSt1V6vlrlvMu2kaXp5Di/kpFRGCtLOzUyVQnaPF2OoIT+0RzyHW5Efp9V2aRx9TIWr7EQkFOAVa+utzCU0GbSVGBEx7f9rfTwMiY0ilKDn1X9K91toRamlr2zXFUPqNlX/33BKC1HAMMjqGJMpDao1UnpIUMXKRaFMMfV7MDbz312h7X22IiCG1zNp+u8SKL9GmKXxvxz0+J96Vq0ehMU1zsFlBKlkAloqSxELa2yLJpiUsCbq7+Sgh1LEE6YHtzQpSLWILgkQxaoU1aep7WprFSSImSIUY6jL4lB5q3gop0zTkXa0RJsvvq1hQuyBDwVSg3Ox0Ix2hRsbEZR3mIRUm1IeXtHtBi5QQCT/frDu3DPOQKuBOB3CPGfqZanDc82wawbWYIAnACmV7TMUMrYsXxgSpMlYQ2yeUx2MTNHMiXQAthmQYFaghCBriWSZIRtNI9whKoSVeaYJkLEJDa6uB0jOnJYsRYIJkNIx5R/qwoLaxCKvkOtAmyiZIxiKkxyS0VcQcaEwD67IZswhN5rMZyevIEUfSKEbARj0krZlVmyGvyJ/kFzqnJBrzN+W2xxrfv2eTgmSkZaiFT/ltLtK7iFLQLEbABgVJe4ZJZs5+1XOYEjpXsDTn61ovSWIazH2XzQmSsYwlhT1VxfAL9ZhAbTWWJVWM5mJBbWOS2oXdf667D7a7pa6kyriUJQHu2vkTYqlNJkiGetxCL6lSlqAlMQI2JkgSM89Ij/SN7Kfwv0xgapdRSeV5rU2biiGlHFrdChILfeuM7Z/kIylfUpSVTQmSVa55WHqVZ8k37EogVVnZlCAZ00iZ3Gi8naFN3lrz9jcTQ7Kh4WnmdBWM9JhH2oCHpOm7sIYqfM0COOYRmRiVY+k8LwleUsq6pNZDmrugMzR3pb9PbkK2hr4ypyRTNrl/mzDlZU2Fbi2PVHlIQ18nswR/aDV1CxNjq1+YSnhtc2NEUlphQyapy6xoQRr7ZoZUCZCjwi2p9O51qSt/zvQz1mFxo7cjVpBCW1rkyrQ1opRyfkhKry21XeYlyaVW/uQQU3GC5AtQqUR2M9U9NkauyWpLC5iGyXPGVVJW6FYaDTGCNNTNKZm4fvcwVGBKzdPxBXLsOSW6ZK0UeClo76rlsl+EIO3s7Lz1uXYGxeyEGDo3ly1jAW+bxDiMZAHNVZlLvXNOMZ0c9ieifUT0YyJ6gYjOEdHnuuM3EdFjRPRS9/tG55oHieg8Eb1IRHfHGiOt4IS2tAhNHShpw1BsrVS31jByQlPzF4hoD4A9zPwUEd0A4CyAewH8NYDXmfkrRHQcwI3M/A9EdDuAhwEcAvBeAD8C8EFmvjLyDJbswkqyrUSQP8YGCWkxhaR868ltk9D7n2XmgzEnTnpIzHyJmZ/qPv8OwAsA9gI4DOBkd9pJ7IoUuuOPMPMbzPwygPPYFadRJE/wkmRbjdiakYYSAimprC5h1kxtInofgA8B+CmAW5n5ErArWgBu6U7bC+BV57IL3TH/XseI6AwRnXGOobvfHLOyI7GlNaaRWp6MYaIFiYjeA+B7AD7PzL8dOzVw7JoSwcwnmPmg78pZIdKB5Y9cctWhEg1zlCAR0TuxK0bfZebvd4df6+JLfZzpcnf8AoB9zuW3Abg4xygTpXGGZq+XfD6gI3+k2Krdyy5lf8woGwH4NoAXmPnrzr9OAzjafT4K4FHn+BEiup6I9gM4AOCJuYZJKUhGO9QqSzXESGv9iZmHdBeATwN4loie7o59AcBXAJwiovsB/ArAfQDAzOeI6BSA5wG8CeCBsRG2MSTPJdk6WvPG5m5dZa5YFZlaIkFBiWjQCAmurgQbfKQIgcS08XFtjJjmku3ZNUhZv1e8Q/Swv4iZ2mNobYlLICFNpOePLwhL1ycuRUJDmsqOEuIqXpAA+YV+60jNnyUVKGXF7T/XSJMc4lEin9XuGGnIQloQtWZXqeTSotLkzmc1giStwBtyqR236alVZqW8/xLUCJIhH2s0rsVNk1bSJWc+qxKkWgXeKlo8tdNKonfg79aQM21KvX+ufFYlSIahldA2MhqXdrjkECV1gmReknwsdjLM0P5Wa6n17qm7pCqG/Q195BgijinwksXIxa/Ia+yuLcTuhNO1tpggGdmYK0pb9D7dNOr/nkNtMerxveKldqkUJKkT8YxrGcqrJeIzlteaxWyphyFFjFxCwjTHPpWCZOgSZd8LGDtvqwx5GO7/XCSKkcvSOKIJklGF1BVJk0CPEarIQ96lhvfcRJfN0IuGSiSBqSkCraajumH/nlYzpEU0tegS2VK6qRUkw+ZGbYmWF+y6mCAZWSnpHZlA60e1IMXsAGgYhh5UC1JJ/FEPKUJoXoHREiZIEbjdjhzrkFrFgtnGXJoQpNLbObjCJMlbMsxj1E4TglQLKd6SVUKjFUyQRojpcvjeUg0kdo0k2mTIxwRpgLkVqqYo1RZEw0iFCVKApa17aWHo41cmREYrmCB5rO1qlBIlySJk3TVjKSZIDqkqUk5R8jfzcn9yPdMwSmGCpIBQ1ywkmhJEybwjYw3qBSlVJUxdkVLb5d53atQvxXMNowbqBSkFuVr1teIQ6pqVeK52Wn3/LXifJkiZmVs5/O6Z9OB6j432GSnY9I6RJb/lM2Z71RzdxhzbuoaEx7//Flrz0rSyTe8YTXhIS7wBKd/ymcojKsHQVqpSA+yGPprwkOZW5prf8jnWtcnpxaxpVZfu57z2O8eM7dGEIM2hduXwN5VL+Q2m/X3857n3d4/NuU/sdaFr1n55oLEdNtVlk1AhhvZWStHF8YUudP/+vKHnzOmWxRLaR8q6ckaIzXhIEsRoijVBy9idCdxz3WtKfM3O2POlMjUZ1UhLM4I0Vpk1FPyeUJxpyO41sR33+tKVrvbzpxjzHmOQ8A5aaUaQhkRHkhjF2uJ7LDEVYWl8Z45dqQl1U0t4aj5j6btkE75U8bctMhlDIqJ9RPRjInqBiM4R0ee6418mol8T0dPdzz3ONQ8S0XkiepGI7s75AmNoFKOemNnZc2dwS2XsPZbGm4bELvQTa497fOwnxNQzjV1iPKQ3AfwdMz9FRDcAOEtEj3X/+wYzf9U9mYhuB3AEwB0A3gvgR0T0QWa+ktJwH7/LplmMfCS8QymGPFw/3jWVJmPxsalnrmVIWP2/t5SvsUx6SMx8iZmf6j7/DsALAPaOXHIYwCPM/AYzvwzgPIBDKYyNRZIYGesIjdD1v2O6WqGRxxiPJjWhZ871lLZQrmcN+xPR+wB8CMBPu0OfJaJniOghIrqxO7YXwKvOZRcQEDAiOkZEZ4jozGyrh+0Lfq7JFgpRCdyKPHcKgcRurStK1oW7SrQgEdF7AHwPwOeZ+bcAvgngAwDuBHAJwNf6UwOXX5PizHyCmQ8y88HZVg9glb99XFEaEyYNZWFJwLx1ogSJiN6JXTH6LjN/HwCY+TVmvsLMfwDwLVztll0AsM+5/DYAF9OZbBhX0T7pMrYLp0FgUxAzykYAvg3gBWb+unN8j3PaJwE8130+DeAIEV1PRPsBHADwRDqTw0jMMIk2tYrEbtkclsaVWiNmlO0uAJ8G8CwRPd0d+wKATxHRndjtjr0C4DMAwMzniOgUgOexO0L3QMQI228A/G/3exECCuPN8OwXYFMUjp3XvIMybiYitfYT0WD6aylLCJehP429mKQoMhGdSRlPKo12+wH972D212ftOzSxuNYwjDYwQTIMQwySBOlEbQNWot1+QP87mP31WfUOYmJIhmEYkjwkwzA2jgmSYRhiqC5IRPTxbpuS80R0vLY9sRDRK0T0bLf1ypnu2E1E9BgRvdT9vnHqPqXo1hteJqLnnGOD9pKQLWRcBt5B/DY4jj1DW/moyIcR+9PlwdAeMSV+AFwH4BcA3g/gXQB+BuD2mjbNsP0VADd7x/4JwPHu83EA/1jbTse2jwD4MIDnpuwFcHuXF9cD2N/l0XVC3+HLAP4+cK64dwCwB8CHu883APh5Z6eKfBixP1ke1PaQDgE4z8y/ZObfA3gEu9uXaOUwgJPd55MA7q1oy9tg5p8AeN07PGRv9S1kQgy8wxDi3oGHt/JRkQ8j9g8x2/7aghS1VYlQGMAPiegsER3rjt3KzJeA3cwDcEs16+IYsldbvizeBqcW3lY+6vIh5VZELrUFKWqrEqHcxcwfBvAJAA8Q0UdqG5QQTfmyahucGgS28hk8NXCs+juk3orIpbYgqd2qhJkvdr8vA/gBdl3R1/pdELrfl+tZGMWQvWryhZVtgxPaygeK8iH3VkS1BelJAAeIaD8RvQu7e3GfrmzTJET0btrdXxxE9G4AH8Pu9iunARztTjsK4NE6FkYzZG+VLWSWIG0bnDGGtvKBknwoshVRzVGHLhJ/D3aj9b8A8MXa9kTa/H7sjh78DMC53m4AfwzgcQAvdb9vqm2rY/PD2HWn/w+7Ldf9Y/YC+GKXJy8C+ERt+0fe4d8APAvgma4C7JH6DgD+HLtdlmcAPN393KMlH0bsT5YHtnTEMAwx1O6yGYZhvIUJkmEYYjBBMgxDDCZIhmGIwQTJMAwxmCAZhiEGEyTDMMTw/+UrH3OkXnWaAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -231,7 +165,7 @@ "source": [ "voronoi = cle.detect_label_edges(labels)\n", "\n", - "imshow(cle.pull_zyx(voronoi))" + "cle.imshow(voronoi)" ] }, { @@ -258,7 +192,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.7" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/demo/neighbors/mesh_between_centroids.ipynb b/demo/neighbors/mesh_between_centroids.ipynb index 0a76c138..0a83571c 100644 --- a/demo/neighbors/mesh_between_centroids.ipynb +++ b/demo/neighbors/mesh_between_centroids.ipynb @@ -23,29 +23,11 @@ "execution_count": 2, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\skimage\\io\\_plugins\\matplotlib_plugin.py:150: UserWarning: Float image out of standard range; displaying image with stretched contrast.\n", - " lo, hi, cmap = _get_display_range(image)\n" - ] - }, { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -67,7 +49,7 @@ " [3, 3, 3, 3, 0, 4, 4, 4, 4]\n", "]))\n", "\n", - "imshow(cle.pull(label_map))" + "cle.imshow(label_map, labels=True)" ] }, { @@ -86,16 +68,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[1.5 1.5 6.5 6.5]\n", - " [1.5 6.5 1.5 6.5]]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:252: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " warn(\"Non-empty compiler output encountered. Set the \"\n" + "[[1.5 6.5 1.5 6.5]\n", + " [1.5 1.5 6.5 6.5]]\n" ] } ], @@ -121,10 +95,10 @@ "output_type": "stream", "text": [ "[[0. 0. 0. 0. 0. ]\n", - " [0. 0. 5. 5. 7.0710683]\n", - " [0. 5. 0. 7.071068 5. ]\n", - " [0. 5. 7.071068 0. 5. ]\n", - " [0. 7.071068 5. 5. 0. ]]\n" + " [0. 0. 4.9999995 4.9999995 7.0710673]\n", + " [0. 4.9999995 0. 7.0710673 4.9999995]\n", + " [0. 4.9999995 7.0710673 0. 4.9999995]\n", + " [0. 7.0710673 4.9999995 4.9999995 0. ]]\n" ] } ], @@ -137,7 +111,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Draw mesh between centroids with distance == 5" + "# Draw mesh between centroids with distance <= 5" ] }, { @@ -149,16 +123,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[0. 0. 0. 0. 0.]\n", - " [0. 0. 1. 1. 0.]\n", - " [0. 1. 0. 0. 1.]\n", - " [0. 1. 0. 0. 1.]\n", - " [0. 0. 1. 1. 0.]]\n" + "[[1. 1. 1. 1. 1.]\n", + " [1. 1. 1. 1. 0.]\n", + " [1. 1. 1. 0. 1.]\n", + " [1. 1. 0. 1. 1.]\n", + " [1. 0. 1. 1. 1.]]\n" ] } ], "source": [ - "connection_matrix = cle.equal_constant(distance_matrix, constant=5)\n", + "connection_matrix = cle.smaller_or_equal_constant(distance_matrix, constant=5)\n", "print(connection_matrix)" ] }, @@ -169,17 +143,7 @@ "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -193,7 +157,7 @@ "source": [ "mesh = cle.create_like(label_map)\n", "cle.touch_matrix_to_mesh(centroid_pointlist, connection_matrix, mesh)\n", - "imshow(cle.pull(mesh))" + "cle.imshow(mesh)" ] }, { @@ -213,10 +177,10 @@ "output_type": "stream", "text": [ "[[0. 0. 0. 0. 0.]\n", - " [0. 0. 1. 1. 1.]\n", - " [0. 1. 0. 1. 1.]\n", - " [0. 1. 1. 0. 1.]\n", - " [0. 1. 1. 1. 0.]]\n" + " [0. 0. 0. 0. 1.]\n", + " [0. 0. 0. 1. 0.]\n", + " [0. 0. 1. 0. 0.]\n", + " [0. 1. 0. 0. 0.]]\n" ] } ], @@ -232,17 +196,7 @@ "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -256,7 +210,7 @@ "source": [ "mesh = cle.create_like(label_map)\n", "cle.touch_matrix_to_mesh(centroid_pointlist, connection_matrix, mesh)\n", - "imshow(cle.pull(mesh))" + "cle.imshow(mesh)" ] }, { @@ -290,7 +244,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/demo/neighbors/mesh_between_touching_neighbors.ipynb b/demo/neighbors/mesh_between_touching_neighbors.ipynb index 201dac21..6a6ba77d 100644 --- a/demo/neighbors/mesh_between_touching_neighbors.ipynb +++ b/demo/neighbors/mesh_between_touching_neighbors.ipynb @@ -60,33 +60,11 @@ "execution_count": 3, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:252: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " warn(\"Non-empty compiler output encountered. Set the \"\n", - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\skimage\\io\\_plugins\\matplotlib_plugin.py:150: UserWarning: Low image data range; displaying image with stretched contrast.\n", - " lo, hi, cmap = _get_display_range(image)\n", - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\skimage\\io\\_plugins\\matplotlib_plugin.py:150: UserWarning: Float image out of standard range; displaying image with stretched contrast.\n", - " lo, hi, cmap = _get_display_range(image)\n" - ] - }, { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -98,7 +76,7 @@ "source": [ "# generate an image where the centroid are labelled (labelled spots image)\n", "labelled_spots = cle.pointlist_to_labelled_spots(pointlist)\n", - "imshow(cle.pull_zyx(labelled_spots))" + "cle.imshow(labelled_spots, labels=True)" ] }, { @@ -106,29 +84,11 @@ "execution_count": 4, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:252: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " warn(\"Non-empty compiler output encountered. Set the \"\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -141,8 +101,7 @@ "# extend the spots to make some artificial tissue image (label image)\n", "cells = cle.extend_labeling_via_voronoi(labelled_spots)\n", "\n", - "cmap = matplotlib.colors.ListedColormap ( np.random.rand ( 256,3))\n", - "imshow(cle.pull_zyx(cells), cmap=cmap)" + "cle.imshow(cells, labels=True)" ] }, { @@ -161,13 +120,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[ 13.554028 100. 200. 300. 386.44598 50.\n", - " 150. 250. 350. 13.57647 100. 200.\n", - " 300. 386.42352 50. 150. 250. 350.\n", + "[[ 13.554028 100. 200. 300. 386.44598 50.000004\n", + " 150. 250.00002 350.00003 13.576469 100.00001 200.00002\n", + " 300. 386.4235 50. 150. 249.99998 350.\n", " 13.845719 100. 200. 300. 386.15427 ]\n", - " [ 15.785854 15.711423 15.711423 15.711423 15.785854 39.46\n", - " 39.46 39.46 39.46 79.460785 79.46 79.46\n", - " 79.46 79.460785 119.65166 119.65166 119.65166 119.65166\n", + " [ 15.785855 15.711423 15.711423 15.711423 15.785855 39.460003\n", + " 39.460003 39.460003 39.460003 79.46078 79.46001 79.46001\n", + " 79.46001 79.46078 119.65165 119.65165 119.65165 119.65165\n", " 143.8476 143.92326 143.92326 143.92326 143.8476 ]]\n" ] } @@ -184,17 +143,7 @@ "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -207,7 +156,7 @@ ], "source": [ "touch_matrix = cle.generate_touch_matrix(cells)\n", - "imshow(cle.pull_zyx(touch_matrix))" + "cle.imshow(touch_matrix)" ] }, { @@ -219,17 +168,7 @@ "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -242,7 +181,7 @@ ], "source": [ "mesh = cle.touch_matrix_to_mesh(pointlist, touch_matrix)\n", - "imshow(cle.pull_zyx(mesh))" + "cle.imshow(mesh)" ] }, { @@ -277,19 +216,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -301,7 +230,7 @@ "source": [ "# visualize in a parametric image\n", "parametric_image = cle.replace_intensities(cells, number_of_touching_neighbors_vector)\n", - "imshow(cle.pull_zyx(parametric_image))" + "cle.imshow(parametric_image)" ] }, { @@ -311,19 +240,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -335,7 +254,7 @@ "source": [ "# Alternatively, in very short:\n", "parametric_image = cle.touching_neighbor_count_map(cells)\n", - "imshow(cle.pull_zyx(parametric_image))" + "cle.imshow(parametric_image)" ] }, { @@ -362,7 +281,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/demo/neighbors/mesh_nearest_neighbors.ipynb b/demo/neighbors/mesh_nearest_neighbors.ipynb index a0292041..59dde4bc 100644 --- a/demo/neighbors/mesh_nearest_neighbors.ipynb +++ b/demo/neighbors/mesh_nearest_neighbors.ipynb @@ -1,5 +1,13 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mesh nearest neighbors\n", + "In this notebook, we draw connections between nearest neighbors" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -20,21 +28,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[82.07392 61.743324 24.044563 23.401918 58.83031 14.841625\n", - " 65.728065 20.56742 56.170868 50.251217 92.97353 86.1744\n", - " 21.599112 14.710198 14.923596 92.96172 66.648 21.121948\n", - " 91.87506 96.426445 34.786064 61.918674 54.48577 69.78287\n", - " 18.594513 ]\n", - " [ 8.753924 1.4185699 52.231815 63.972008 74.71437 77.4825\n", - " 60.40445 82.40314 54.29485 39.64036 15.57555 48.74332\n", - " 87.68647 93.11849 38.735508 67.78253 48.96325 35.488842\n", - " 93.80854 83.83424 16.82569 92.00881 22.90601 28.873756\n", - " 2.194068 ]]\n" + "[[70.64917 58.453907 79.61481 16.682678 49.30561 90.39636\n", + " 94.39213 44.35514 62.92819 24.912798 91.58313 54.434746\n", + " 54.09449 76.062 49.854034 51.69231 12.608252 94.22745\n", + " 1.0119599 77.805244 76.59334 98.06172 41.60635 40.601635\n", + " 10.995756 ]\n", + " [98.847496 34.78621 88.91474 86.29059 95.29436 7.6578937\n", + " 99.41172 27.265553 67.24176 76.79497 85.664154 76.840775\n", + " 96.69842 1.8827125 55.086697 48.71459 78.989365 37.168\n", + " 55.665108 49.125397 62.9217 91.91636 61.23606 73.65141\n", + " 83.48591 ]]\n" ] } ], "source": [ - "pointlist = cle.push_zyx(random.random((2,25)) * 100) \n", + "pointlist = cle.push(random.random((2,25)) * 100) \n", "print(pointlist)" ] }, @@ -43,33 +51,11 @@ "execution_count": 3, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:252: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " warn(\"Non-empty compiler output encountered. Set the \"\n", - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\skimage\\io\\_plugins\\matplotlib_plugin.py:150: UserWarning: Low image data range; displaying image with stretched contrast.\n", - " lo, hi, cmap = _get_display_range(image)\n", - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\skimage\\io\\_plugins\\matplotlib_plugin.py:150: UserWarning: Float image out of standard range; displaying image with stretched contrast.\n", - " lo, hi, cmap = _get_display_range(image)\n" - ] - }, { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -80,7 +66,7 @@ ], "source": [ "labelled_spots = cle.pointlist_to_labelled_spots(pointlist)\n", - "imshow(cle.pull_zyx(labelled_spots))" + "cle.imshow(labelled_spots, labels=True)" ] }, { @@ -88,27 +74,9 @@ "execution_count": 4, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:252: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " warn(\"Non-empty compiler output encountered. Set the \"\n" - ] - }, { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -122,27 +90,17 @@ "source": [ "cells = cle.extend_labeling_via_voronoi(labelled_spots)\n", "membranes = cle.detect_label_edges(cells)\n", - "imshow(cle.pull_zyx(membranes))" + "cle.imshow(membranes)" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -155,29 +113,19 @@ ], "source": [ "nearest_neighbors_mesh = cle.draw_mesh_between_n_closest_labels(cells, n=1)\n", - "imshow(cle.pull_zyx(nearest_neighbors_mesh))" + "cle.imshow(nearest_neighbors_mesh)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "metadata": { "scrolled": true }, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -190,27 +138,17 @@ ], "source": [ "two_nearest_neighbors_mesh = cle.draw_mesh_between_n_closest_labels(cells, n=2)\n", - "imshow(cle.pull_zyx(two_nearest_neighbors_mesh))" + "cle.imshow(two_nearest_neighbors_mesh)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -223,29 +161,19 @@ ], "source": [ "three_nearest_neighbors_mesh = cle.draw_mesh_between_n_closest_labels(cells, n=3)\n", - "imshow(cle.pull_zyx(three_nearest_neighbors_mesh))" + "cle.imshow(three_nearest_neighbors_mesh)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 8, "metadata": { "scrolled": true }, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -258,27 +186,17 @@ ], "source": [ "four_nearest_neighbors_mesh = cle.draw_mesh_between_n_closest_labels(cells, n=4)\n", - "imshow(cle.pull_zyx(four_nearest_neighbors_mesh))" + "cle.imshow(four_nearest_neighbors_mesh)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAASAAAAEYCAYAAAD8qitAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYmUlEQVR4nO3dX+glZ33H8fe3uwZNpG5iIcTd2KwYIkHQyCKRSAmJhVSDyUWIES1LUPbG1lQsNnon1AtB1EBLISRKLqRR1kCCF5YQY/Gmi5tuwSZraojVbNiYlCRaeqFd/PbizM8elznneeb5M8/MnM8LfmzOn5ln5pyTZ77f59+YuyMi0sIftD4AEdldqoBEpBlVQCLSjCogEWlGFZCINKMKSESayaqAzOwmM3vazJ4xs7tLHZSI7AZLHQdkZvuA/wD+FDgD/BD4sLs/Ve7wRGTJ9mds+27gGXd/FsDMHgRuATZWQGamUY8iO8jdre/5nBTsIPDc2uMz3XMiIlFyIqAoZnYMOFa7HBGZn5wK6Hng8rXHh7rnfo+73wvcC0rBROT35aRgPwSuNLPDZnYBcAfwSJnDEpFdkBwBufs5M/sL4J+AfcDX3P3JYkcmIouX3A2fVJhSMJGdVKMXTEQkiyogEWlGFZCINKMKSESaUQUkIs2oAhKRZqpPxRBZN7e7sJj19h5LIYqARKQZVUAi0oxSsIXYldSm5nmuH9NeObU/111P8RQBiUgzioAC5hJZLOVKOtbnHRvt1PpcS0VYc//eFQGJSDOqgESkmZ1MwYaEvXMPcacq9B30pUibXu97X2j72H1t2jb2d1E7pdx0znOhCEhEmlEFJCLN7FQKlhIOj9kzsjTbPu/QZzgk9cn9XlO+z9gyU88zxd6+5vT7VAQkIs3sVASUYu9qsn6lKnX1W4qURt7Q9imf3ZCG51D5KcfRt5+UDo/cqGhODdOKgESkGVVAItLMTt2WJ+dcazQmTj083pObYg3ZZ6k0ZNu+N+2/5Pcx9qTZ9een2HGi2/KIyOSoAhKRZnYyBUvtLdlTc9xIbjmpavYEpRiS8ub2suWkLKlTNUo1B4Q+h6mkY0rBRGRyNA6oR+jqmDLOIuWKWGPSbKnR4LnGXBExpWG7xlivlEgsV81G/RIUAYlIM6qARKSZxadgtVOOUhMAcxstx2r8DZlKo+cQsWlKjfFOKXI7NKY0VUMRkIg0s/gIaF3OBMchEUiNq0rtZR1qDC0o9TnUiKrGXKlwT+5SIqHtY8vsi4ZaRUKKgESkGVVAItLMTqVgOYaM1xgrrK2xml6fMSdx1pCzKP2m53JHHY815id3Qf/aFAGJSDOqgESkmZ1PwUK9XH3pVKgXoe+eUmP12qTeD2vbe1sM45/KlJHUMsdKY1J6tFr36K5TBCQizex8BFRKaGW6lKvKmKsC5kxabHGn2dzG8NjocMjdVse8BU+OKXWoKAISkWZUAYlIM4tcETGlYbDkkPhQeaGwdtu+QinBkDJLTaUo+RtqMTFUwgp0oqStiGhml5vZ42b2lJk9aWZ3dc9fYmaPmtlPun8vzjpCEdk5MSnYOeDT7n41cC3wCTO7GrgbeMzdrwQe6x6LiEQbnIKZ2cPA33V/17v7WTO7DPi+u18V2Hb0FCwljajR25Gy9GZuihU6piHl55h66pOSmodSxZSUuVTPXu6s+z61UrBB3fBmdgVwDXACuNTdz3YvvQBcumGbY8CxIeWIyG6IjoDM7PXAPwNfcPeHzOxVdz+w9vor7r61HWguEdAQsVfPIVelbVfX1CtmTiQ39bV3chukcyKGGiPPN20TUuOYU46jT3IjdFf4a4BvA99w94e6p3/RpV50/76YdYQisnNiesEMuB847e5fXnvpEeBo999HgYfLH56ILFkwBTOz9wI/AH4E/LZ7+nOs2oG+BbwZ+Blwu7u/HNjXZFOwTdv37adUipebLpVKI7YdS0w5Q8rMmfKRqlSK1bd9jXFXNT7vIdvE7meITSnY4gciqgKKowooftv17VUBxSnSC7bLpr48RM3/8VMaLc/fbuj2qWX2ib2g1BhdndqNn1JWaBL0FGkumIg0owpIRJpZVBtQ7kjSvv2kTI6sORJ6yDYhNY4ztszc8Uw1RvvGlB9bZs22rtx2odA+c9tQNxxT+jggEZEaVAGJSDOL7AUrFTbG7H8vXB2SRsROZMzdJkXJaSwp3cqx+vY5Zs/ZWGpMxZgSRUAi0swiI6CS+q4qKYO/SpUdem/JKCDWpjK3lZ87+bdGp0CoYbvkmJ1txpyA2iKqW6cISESaUQUkIs0oBeuRsnLdECnD92NX2EttpJ5jA+ae0HcUO0Uh1LC96b05Un5XKdNhpvr9KgISkWZUAYlIM0rBIrUYch8qf6wyU9O32NSn1DSVUO9ObjqVMkVnyD5T3ltq6kyrFE0RkIg0M/sIqEbNPeRKs60BtPaYnCGRSc6aNzH733ZMNT6HGhNPh4z5yS0/NoJKWRxP6wGJiERQBSQizcw+BVuXk16kLjVaY7rB0HKGbL+poXZbSlB76kmphtiR17bKKjPld5MzDaX1lItNFAGJSDOLioBSxDak1pjAN+ZVKdRAmXIsOcc/JLrLbeyu0e1cctXBnG2mGtnEUgQkIs2oAhKRZnYyBasRyqaE5LkpUMr2KeOZcqU0mpZc+TG2/FIjjWOOo9Q4oNhtpkoRkIg0owpIRJrZqRSsVDjbci2YISlUyr7mFL6fb6ylcjftq9SSrVNdPrUGRUAi0swsI6DUK822K0jqSOjY7VOWj+jbf60IJWVkb27Udf5+Nr0vZXLlkM87dlRyjQhkSBQa+rzHmgRdkiIgEWlGFZCINDPLFGxdyv2fhuxz6LZD9h+aFjGk0Tx3/EypqQGx+yw5zie0Tal7ifVpkeKkpIVTbcxWBCQizagCEpFmbOQ1VIoUVnKdndzyU3qPUtKhlFA7RW76WWNp2pSesz4p6+y0mPaQ+nnF9vIO2X+pdM3de3ekCEhEmpl9I3RI7Qa3mlfAsdacWVfjfEpGh9veV6OhNXWfLRr9SxmzkVoRkIg0owpIRJpZfAo2xaHopVKj2PEvqdtv2zb3vTVSiyGTOGMXbi/5+0kZWxR744D156c0zidEEZCINLP4CGhdjYbJGscRe+uZFgurl1K77FCEFXquVCNybtf/FCP4kqIjIDPbZ2anzOw73ePDZnbCzJ4xs2+a2QX1DlNElmhICnYXcHrt8ReBr7j7W4FXgI+VPDARWb6oCsjMDgEfAO7rHhtwA3C8e8sDwK0Vjm8QMwuOBj3/r3TZ638l97ntudA2688POf4a5xTS9x2F/nLFnluN301Iymff4jhTxUZAXwU+A/y2e/xG4FV3P9c9PgMc7NvQzI6Z2UkzO5lzoCKyPMEKyMxuBl509ydSCnD3e939iLsfSdleRJYrphfsOuCDZvZ+4LXAHwL3AAfMbH8XBR0Cnq93mHFSJj/mjI9pbchyntu2Wf/v2mNhQscRu13t3sDc3qmpTLWIPbdWghGQu3/W3Q+5+xXAHcD33P0jwOPAbd3bjgIPVztKEVmknHFAfwM8aGZ/C5wC7i9zSPlSlh4Yc+zFVEaspkRQKfscUk4oAqs9anqbsSYHpy6RMZXf9xCLXw9orAooJXUJ/ZCG9nyklBW7fazc9YCmngKWKifnPGtXQDUujFoPSEQmZ/ZTMUpdXUtdncY0pKE0JRqpIWWtoxpr64wlNHF0iNjJx1NveF6nCEhEmlEFJCLNzD4FC4ldFya3p2WsmelDeo9Sep9az7Cv2UOYOkYqRd/nmZtK1myMb5WiKQISkWYWFQHlrBiX0rUZ2j71qhJ79S/ZtZ5zBRyy9s7ee1O22fR66JhitxlrnE9umUuiCEhEmlEFJCLNLCoF6xNqiK2xTGtug/C2/aemijlpTG4qWbJhO+X7yplwnJq21RiLM9Zo9jEpAhKRZhYZAYXm30zlShEatdz33pITFYc0BA8pK3b7bftMGUEcOp+Sc+tCcrrhh/wu+srs2+dUKQISkWZUAYlIM4tMwYaosWREjfVlSoXfJZeH6PvsYj/HkqOSQ2lbSqqYm67n/AZqpL6tJyFvoghIRJpRBSQizexUCpaTbqWsX7MpLcsJ73N7SGpMR8gdp5M7Fiu2x6vFSoC55eem6VMfO6QISESaWXwEFDs2pOSVIHc8x/nHFvN6SmSTs8JeTDk5S53UXhakxRrZKeXk3nopVqsbJCgCEpFmVAGJSDOLT8H6lFylrm8/pcL3lPEcNe7eOeb+a2h5/7VNv7UaKz+2vs9cCkVAItKMKiARaWanUrBS42/GktIDUnI6Qu31gmKPI7fMGj1aWn61DEVAItLMTkVAfaYycS9lMmnovUNe79t/bFQ05udVaixX6POeytpRrcuvTRGQiDSjCkhEmtnJFCxlPEbKhMsWa8m0uPtmqOG79nihGsvNjmVI2jeVtLAkRUAi0owqIBFpZidTsD65M75rlD9kfZhSM6Bb9LwNkXOerdcD6isrtFJAyp085jQlQxGQiDSzkxFQyfEiKftMKTMkdPWrMfq7ZmN8jat47hin2uWPvZ8pUAQkIs2oAhKRZnYyBVtX4/5PYy3z2vd6qIG8RmpTIw2YUoPxWGJvZrAkioBEpJmdj4D2lGzYq7ki4iY5C8CH3jvFhs6St7jZFrGWjEBqrK4ZWrJl6lGTIiARaUYVkIg0s1MpWI00Y6xVAWND6ZKLxtdYnXCsdXhSUrTQJOUaY736Uub1MkstZD/kux4zbYuKgMzsgJkdN7Mfm9lpM3uPmV1iZo+a2U+6fy+ufbAisiyxKdg9wHfd/W3AO4DTwN3AY+5+JfBY91hEJJpFhKpvAP4NeIuvvdnMngaud/ezZnYZ8H13vyqwryIxbGq4uC2ErTE9I1eNULtk+Sm9OqH95Hy2JaehhPafu8+cicChe43lqjRWrHenMRHQYeAl4OtmdsrM7jOzi4BL3f1s954XgEv7NjazY2Z20sxOphy4iCxXTAR0BPgX4Dp3P2Fm9wC/Av7S3Q+sve8Vd9/aDjSXCKjk3UdTlJrkmXKcpaKe3H0OiWamvFLgpu9g22cy5Pc9lcg7JCcCOgOccfcT3ePjwLuAX3SpF92/L5Y4UBHZHcEKyN1fAJ4zs732nRuBp4BHgKPdc0eBh6scoYgsVjAFAzCzdwL3ARcAzwJ3sqq8vgW8GfgZcLu7vxzYz+gpWErYm2uslCB1yP7QbYaswpiSHqeMe8pNjVt3JKR0iLQ+5hybUrCoCqgUVUBlqQLavI0qoHRTawMSEalip6Zi9Ck13SB2aH+M2CtdzpSNTduFZtOXinpyhWaBh+SumxRbVsoUiE2/m9ipGnOiCEhEmllkBFRylGrOvlK33bZdyriSTfvOPc+aI4yHnFtuW1WNScopSv1uU6LtVtGTIiARaUYVkIg0s8gUbF1K1+WQyZEtutxLKdVVPeb6MSlCjbfnv+/8/+7bpm+fY6UxoVRzTg3TioBEpJnFR0DrciZkbto250rYetJr6JjmbEjDdkqXeo3PKXcS8tSjnT6KgESkGVVAItLMolKwnBA0dzW9knOTckf2pkiZJ5cy/ibFkE6BbccRO/YnppzYUclDfgPb5odtOrbcz6Y1RUAi0owqIBFpZlEp2J6U1GeKoeqQXrJt76t1TH3PhdKU2P2nnEdur2KN40zpeUtNq1pOp0mlCEhEmlnUgmQ1zyVlkfTQ+zZtkzIZNVaNheo3yYkyai/KFRsNpS5+F1v+VCZOb9pnKVqQTEQmRxWQiDQz+0bo2mvitm6k25Mbsseu+he78uKm7ftez22Y7lO7kTk3rQvtJzbtiy0n9N6Sq0WWpAhIRJpRBSQizcw+BUuReyufUkPqh8idYZ8zJmfTccSmOSUXsk9JXWL3H0rhxup1DKkxRadVs4MiIBFpZicjoBS1x6XkKjUyd8hEyND+t21f8oqb0uCcG+GkRLc1IqzQMU2lE2UTRUAi0owqIBFpZidTsJKNeLGTCkseU6ySUwfmVmapBuPcKTgp5ad+RjmdH61SNUVAItLM7Cejnrf/ra/HKjWituRn2yKyWIqcWyulfu4tfiPbjqPkCPoUmowqIpOjCkhEmpllI3TJle9ix2OUamDctP/QNrll9pWdu25Rn6Wkgrmjp3MahFNvkJCy+H5rioBEpBlVQCLSzCxTsFSxvR0pw+SHLNaecpwpKcG6UkP/xwrpc+/TlnI/rtBzKffrqrEofe5nMyWKgESkmZ2KgLaZ0niOnGil9oTK1LJqHkfffkqNBSvZoJt7A4NQZDzlW0xtoghIRJpRBSQizex8ChYKW0uN5xhrrZdNZeakOWNOKalZTm5HwhClUubcjoipp2OKgESkGVVAItJMVApmZp8CPg448CPgTuAy4EHgjcATwJ+7+28qHecgQ8ZexKZYrcfM1OgFS9mudXhfc8WDGvcSK3lL7xrLuLYWjIDM7CDwSeCIu78d2AfcAXwR+Iq7vxV4BfhYzQMVkeWJTcH2A68zs/3AhcBZ4AbgePf6A8CtxY9uQszsd38p2/T9Ddn/0LLP5+5b/1L203fsofMcWl4t6+ex7ZhDn9emzzD0fcV+Nn3HFPMbyv29jCVYAbn788CXgJ+zqnh+ySrletXdz3VvOwMc7NvezI6Z2UkzO1nmkEVkKWJSsIuBW4DDwJuAi4CbYgtw93vd/Yi7H0k+ShFZpJhG6PcBP3X3lwDM7CHgOuCAme3voqBDwPP1DjNd7vo2sfvJNYW0JFVo6kBsg+/5791myMTPFCkNwqXGiuWu2TQnMW1APweuNbMLbfVp3Ag8BTwO3Na95yjwcJ1DFJGlilqU3sw+D3wIOAecYtUlf5BVN/wl3XMfdfdfB/ZTvOruu1rkTsisvX3Nq1qNpRpqjwbOLbPUJM/YfQ/df0w5Q8oca1T9pvem8A2L0s/yrhjrVAGF9527f1VAcduoAtpsUwWkkdAi0syiIqABxzF4P63Xzgld/UpFf33mvsZQSoNxqUbmFtHwkHMvdZ4hioBEZHJUAYlIMzuVgo2Veo31mQ6ZGFpzWH7tFC23kTlHi5RyzI6E2MnYuZSCicjk7FQEtE1ut+9Y+yxZZgu5n922aGjqI4RTGr5rlF1yxHgsRUAiMjmqgESkmZ1PwVqMCQppkUpMLXUb+XeZXOaQjoAh++ozxUb2WErBRGRyVAGJSDM7f1+wUsP0S6o0FD7r9SXLOfeS6XqL8WOtKQISkWZ2PgLqkzKyt+TVa5ejkVKmspLgVL7LKUU96xQBiUgzqoBEpBmlYJnGWk9F8ul7mR5FQCLSzOwjIF3VROZLEZCINKMKSESaUQUkIs2oAhKRZlQBiUgzqoBEpBlVQCLSjCogEWlGFZCINKMKSESaGXsqxn8B/9P9uyR/xLLOaWnnA8s7pzmdzx9vemHUu2IAmNlJdz8yaqGVLe2clnY+sLxzWsr5KAUTkWZUAYlIMy0qoHsblFnb0s5paecDyzunRZzP6G1AIiJ7lIKJSDOjVkBmdpOZPW1mz5jZ3WOWXYKZXW5mj5vZU2b2pJnd1T1/iZk9amY/6f69uPWxDmFm+8zslJl9p3t82MxOdN/TN83sgtbHOISZHTCz42b2YzM7bWbvmfN3ZGaf6n5v/25m/2hmr537d7RntArIzPYBfw/8GXA18GEzu3qs8gs5B3za3a8GrgU+0Z3D3cBj7n4l8Fj3eE7uAk6vPf4i8BV3fyvwCvCxJkeV7h7gu+7+NuAdrM5tlt+RmR0EPgkccfe3A/uAO5j/dwSMGwG9G3jG3Z91998ADwK3jFh+Nnc/6+7/2v33f7P6YR9kdR4PdG97ALi1yQEmMLNDwAeA+7rHBtwAHO/eMrfzeQPwJ8D9AO7+G3d/lRl/R6wGDL/OzPYDFwJnmfF3tG7MCugg8Nza4zPdc7NkZlcA1wAngEvd/Wz30gvApa2OK8FXgc8Av+0evxF41d3PdY/n9j0dBl4Cvt6llfeZ2UXM9Dty9+eBLwE/Z1Xx/BJ4gnl/R7+jRugEZvZ64NvAX7n7r9Zf81W34iy6Fs3sZuBFd3+i9bEUtB94F/AP7n4Nq6k/v5duzew7uphV9HYYeBNwEXBT04MqaMwK6Hng8rXHh7rnZsXMXsOq8vmGuz/UPf0LM7use/0y4MVWxzfQdcAHzew/WaXEN7BqPznQhfswv+/pDHDG3U90j4+zqpDm+h29D/ipu7/k7v8LPMTqe5vzd/Q7Y1ZAPwSu7FrvL2DVkPbIiOVn69pH7gdOu/uX1156BDja/fdR4OGxjy2Fu3/W3Q+5+xWsvo/vuftHgMeB27q3zeZ8ANz9BeA5M7uqe+pG4Clm+h2xSr2uNbMLu9/f3vnM9jtaN+pARDN7P6s2h33A19z9C6MVXoCZvRf4AfAj/r/N5HOs2oG+BbwZ+Blwu7u/3OQgE5nZ9cBfu/vNZvYWVhHRJcAp4KPu/uuGhzeImb2TVaP6BcCzwJ2sLraz/I7M7PPAh1j1wp4CPs6qzWe239EejYQWkWbUCC0izagCEpFmVAGJSDOqgESkGVVAItKMKiARaUYVkIg0owpIRJr5P5pYgt23M5j5AAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -291,7 +209,7 @@ ], "source": [ "ten_nearest_neighbors_mesh = cle.draw_mesh_between_n_closest_labels(cells, n=10)\n", - "imshow(cle.pull_zyx(ten_nearest_neighbors_mesh))" + "cle.imshow(ten_nearest_neighbors_mesh)" ] }, { @@ -318,7 +236,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/demo/neighbors/mesh_with_distances.ipynb b/demo/neighbors/mesh_with_distances.ipynb index e3c768ef..68346bc3 100644 --- a/demo/neighbors/mesh_with_distances.ipynb +++ b/demo/neighbors/mesh_with_distances.ipynb @@ -27,21 +27,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[191.74503 90.11498 180.70862 121.19386 71.90925 84.62808\n", - " 182.3788 95.6364 196.84749 176.95425 144.75409 193.82361\n", - " 112.42955 127.16978 37.90602 74.631096 186.80553 0.409472\n", - " 182.47652 16.401989 30.765274 105.3301 154.22278 78.19475\n", - " 144.3033 ]\n", - " [194.33144 73.40758 146.66458 7.3030534 125.40269 121.36054\n", - " 19.522312 146.65701 10.870085 155.56772 99.07795 80.85451\n", - " 21.268576 19.805975 162.26152 58.635773 1.6762592 37.841335\n", - " 72.946915 87.64162 90.26011 108.98451 141.73877 195.06473\n", - " 180.40976 ]]\n" + "[[196.12617 54.416378 180.27724 18.01228 34.173218 143.53114\n", + " 173.73737 81.73436 58.57614 57.45129 143.90245 65.35432\n", + " 150.35013 104.53445 17.567146 185.51569 46.01085 109.18727\n", + " 148.5126 69.863846 53.523132 39.58763 109.30443 88.31531\n", + " 191.20518 ]\n", + " [162.93413 107.105286 22.920868 39.284813 178.93416 188.87553\n", + " 83.70884 0.6752871 52.01047 107.50955 14.954532 40.057934\n", + " 178.80856 18.444862 6.4243984 168.38733 107.927765 10.054452\n", + " 172.62653 21.282495 110.66594 191.91292 28.895882 24.93193\n", + " 117.0418 ]]\n" ] } ], "source": [ - "pointlist = cle.push_zyx(random.random((2,25)) * 200) \n", + "pointlist = cle.push(random.random((2,25)) * 200) \n", "print(pointlist)" ] }, @@ -50,31 +50,11 @@ "execution_count": 3, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\skimage\\io\\_plugins\\matplotlib_plugin.py:150: UserWarning: Low image data range; displaying image with stretched contrast.\n", - " lo, hi, cmap = _get_display_range(image)\n", - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\skimage\\io\\_plugins\\matplotlib_plugin.py:150: UserWarning: Float image out of standard range; displaying image with stretched contrast.\n", - " lo, hi, cmap = _get_display_range(image)\n" - ] - }, { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -85,7 +65,7 @@ ], "source": [ "labelled_spots = cle.pointlist_to_labelled_spots(pointlist)\n", - "imshow(cle.pull_zyx(labelled_spots))" + "cle.imshow(labelled_spots, labels=True)" ] }, { @@ -95,19 +75,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -118,7 +88,7 @@ ], "source": [ "cells = cle.extend_labeling_via_voronoi(labelled_spots)\n", - "imshow(cle.pull_zyx(cells))" + "cle.imshow(cells)" ] }, { @@ -137,16 +107,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[183.04762 96.28571 184.09932 120.895836 60.794464 83.08477\n", - " 173.61215 98.240715 193.08888 176.25974 144.0355 186.71373\n", - " 97.88094 138.97937 28.525873 64.157394 177.59375 20.607765\n", - " 171.76048 11.921341 35.626587 109.19315 148.0564 80.214485\n", - " 138.51642 ]\n", - " [185.2449 73.25858 134.03603 4.953125 125.25813 114.78278\n", - " 26.905874 152.05547 12.340741 162.96812 93.18893 95.35492\n", - " 23.434101 28.5775 162.26636 43.95828 3.7083333 27.309032\n", - " 64.73782 86.77018 95.64913 107.35959 138.0564 183.49786\n", - " 178.30933 ]]\n" + "[[189.98854 52.685715 178.55363 17.529703 31.070807 114.44774\n", + " 155.88962 80.071655 60.90635 86.40703 145.1698 69.24675\n", + " 159.0331 101. 21.154 179.26253 24.621399 113.03607\n", + " 131.9742 59.95965 55.093807 67.87325 115.62534 87.93841\n", + " 176.29288 ]\n", + " [151.64185 104.057144 27.152275 48.738617 163.30026 179.11778\n", + " 84.58664 4.694704 63.645164 110.69241 21.737526 42.786304\n", + " 181.26714 16.93596 10.964462 168.7841 105.69856 7.753507\n", + " 148.76114 16.076336 132.7204 180.0395 50.449493 29.155592\n", + " 121.37461 ]]\n" ] } ], @@ -162,19 +132,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -185,7 +145,7 @@ ], "source": [ "distance_matrix = cle.generate_distance_matrix(centroids, centroids)\n", - "imshow(cle.pull_zyx(distance_matrix))" + "cle.imshow(distance_matrix)" ] }, { @@ -195,17 +155,7 @@ "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -218,7 +168,7 @@ ], "source": [ "touch_matrix = cle.generate_touch_matrix(cells)\n", - "imshow(cle.pull_zyx(touch_matrix))" + "cle.imshow(touch_matrix)" ] }, { @@ -228,19 +178,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -251,7 +191,7 @@ ], "source": [ "touch_distance_matrix = cle.multiply_images(touch_matrix, distance_matrix)\n", - "imshow(cle.pull_zyx(touch_distance_matrix))" + "cle.imshow(touch_distance_matrix)" ] }, { @@ -261,19 +201,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -284,14 +214,12 @@ ], "source": [ "distance_mesh = cle.touch_matrix_to_mesh(centroids, touch_distance_matrix)\n", - "imshow(cle.pull_zyx(distance_mesh))" + "cle.imshow(distance_mesh)" ] }, { - "cell_type": "code", - "execution_count": 10, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ "# Sepcial meshes\n", "## Mesh of touching neighbors" @@ -299,22 +227,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -327,7 +245,7 @@ ], "source": [ "angle_mesh = cle.touch_matrix_to_mesh(centroids, touch_matrix)\n", - "imshow(cle.pull_zyx(angle_mesh))" + "cle.imshow(angle_mesh)" ] }, { @@ -339,22 +257,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -367,7 +275,7 @@ ], "source": [ "nearest_neighbor_mesh = cle.draw_mesh_between_n_closest_labels(cells, n=1)\n", - "imshow(cle.pull_zyx(nearest_neighbor_mesh))" + "cle.imshow(nearest_neighbor_mesh)" ] }, { @@ -379,24 +287,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -407,7 +305,7 @@ ], "source": [ "close_neighbors_mesh = cle.draw_mesh_between_proximal_labels(cells, maximum_distance=25)\n", - "imshow(cle.pull_zyx(close_neighbors_mesh))" + "cle.imshow(close_neighbors_mesh)" ] }, { @@ -420,24 +318,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -448,7 +336,7 @@ ], "source": [ "distance_mesh = cle.draw_distance_mesh_between_touching_labels(cells)\n", - "imshow(cle.pull_zyx(distance_mesh))" + "cle.imshow(distance_mesh)" ] }, { @@ -461,24 +349,14 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -495,29 +373,19 @@ "\n", "angle_matrix = cle.undefined_to_zero(angle_matrix)\n", "\n", - "imshow(cle.pull_zyx(angle_matrix), cmap='twilight')" + "cle.imshow(angle_matrix, color_map='twilight')" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -529,7 +397,7 @@ "source": [ "angle_touch_matrix = cle.multiply_images(angle_matrix, touch_matrix)\n", "angle_mesh = cle.touch_matrix_to_mesh(centroids, angle_touch_matrix)\n", - "imshow(cle.pull_zyx(angle_mesh), cmap='twilight')" + "cle.imshow(angle_mesh, color_map='twilight')" ] }, { @@ -563,7 +431,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/demo/neighbors/neighborhood_definitions.ipynb b/demo/neighbors/neighborhood_definitions.ipynb index 713515fd..50a133e4 100644 --- a/demo/neighbors/neighborhood_definitions.ipynb +++ b/demo/neighbors/neighborhood_definitions.ipynb @@ -56,7 +56,7 @@ " else:\n", " values[i] = values[i] * 10 + 90\n", "\n", - "measurements = cle.push_zyx(np.asarray([values]))\n", + "measurements = cle.push(np.asarray([values]))\n", "\n", "# visualize measurments in space\n", "example_image = cle.replace_intensities(tissue, measurements)" @@ -77,7 +77,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -107,7 +107,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -139,7 +139,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARIAAAD8CAYAAAC7DitlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABW2klEQVR4nO29fXAc533n+XnYPS8EZoARMCBGBEhCJBBCImzSFCLxSrwVb6VdM4mqpL2kEt2db+07bzm5Ta6SutvbeC9XFe/dbVX2apPLbm0usXeds3Lxrp2yd2WfvCtvpFs6Je9SMqWQNiiRJkSDIkgNiBcNiAHQg5lG3x9PN2YwmJd+eYboIedTNQWgp+eZB/3y7d/zPL8XYVkWHTp06BCEPbvdgQ4dOrQ/HSHp0KFDYDpC0qFDh8B0hKRDhw6B6QhJhw4dAtMRkg4dOgSmZUIihDgrhLgqhJgWQny+Vd/ToUOH3Ue0wo9ECKEBPwb+GjAL/AD4LyzLelf5l3Xo0GHXaZVF8gQwbVnWdcuyNoCvAc+36Ls6dOiwy+gtancIuFnx9yzwZL2dRV/aYmikfmvCoiuar/nW2t0kbPjqI3SBiJo+P7wdq6hBq5yEBYiIyR59c2uTuRxR+30WUALqHY69oPd6O9AlI6r+mAhgT4sO9IJoTbsJIKK4zdq3Q3BKlM/Zh28vWJY14OZjrRKSpgghPgd8DoD9B+HlH9TeMV7giaE3G7b11lefBsNHJ06APnLXxwd3Usz2+OtDM3TYk1kllc5t22yWNJbPZdR954L9qsc4dJ/NEo25F5P5qwflhakSHYgXFTdq8xXVd7vNKWBYYXsl4LzC9hxybL+eviBuuP1oq4Y2t4ADFX8P29u2sCzrS5ZlTVqWNUlffdE7PnSxJR1sG1LFHSICoOkmidPz8ml3L7gCyxcy3j6TaIGy6hZ74n5N0CaovNnbjRyBHkqtEpIfAGNCiEeEEFHgReDbXhtJZBbQ3DzSJj33Tz1x657bd9H4BvHJJUgFbMigJdbUHt1U227com/kNvsG59SKiW7K9s4aMKqu2bYhR+Dz1BIhsSyrBPwa8F3gPeDPLMu67KWN3uE5jnS/j1530F7miaPfkxfBLhJJrUBKsckdh3hqpeEuXYl1IhN3g4lJCeVj7vlb+9ic6pYXaZ7ggqJD38ht+rUFkqyoERPdlCKim2i6SSS+AaeLcigyErC/Dgnk/656iKeKHErEvmV+JJZl/RvLsn7KsqwjlmX9Ay+f7R2eYyQ2Q4yC68+cHLpA5AUP8x0pQJdzDaqIJNYhrVBMdCkUzUimVqSY3KthThPmbzwM0/HyhjxlQfFB3/gtBo5+QL9WnsRxxATd52S5LSCR+AZaRRuRxDqRybtw2oKzgMfR3DYS9ucN5HJDmMQkhzIRgV2cbG3E3tiaJxEB0DEZ6f8J1zjefOcEW+PhzYVuNoFIRs2kaySxjmk/KTfzXZDzuRIQh8TwvOvdk6kV1iZLGOf7vF0cBpD13Lu6zN94GGYitW+aPPZkafN2ekez7I2tAVI0apFkBX3oJrO3DoCXB0KFFVIPaWFCMZ2EV4S86Vy1TXmuRad8h+WBGdQMnc7b7fl9cORQPpQNnYt87/Ac+7nt67NJVuj9VJO7Io48mc7FXJKv4mzP9lcu6asPICdCNd0kklohMuLDUtDljRT1aLp3JdbpPZP1/nhQ+aQ06oiIQ46mF3FiZJ7+2CJJVuqKiMNe1jg0NOO+fy5EpJJIagVeKLoSP0aRQ6K4/ao+DwYw7b6rOzgPvIpcXTPwZ+XlaMl8WKgsknj6I47Grvr+vI7J3tgayzo7L2YdmKj4vRl5QTHfA2lDjp0DEEnfhbT8vTjbU36jzg3XN3Gr9hsu0HSTvrO3WHplqPnOJeRTUhHzt/ZJE74ZuYrfK4cOOsQzSzzc7e1BEqXAoUPvc+PGkab7ehERh0hiHfMzFVbm14Q8djqy/14eFI6YeLVMLrDTcrQfgjuEIV2njVyNfRURGoskklrh470/CtzOQW6S+IX58hNEB07Yr0pT0y0L8S0rRQWR4btEhu+yJ7Nauz+KpL33rA/LpBnNLBc/801ZZD9TBmNHL3Gg92azT9TEERNnArUWkcS6ZxFxqLQyeQE5xzaKv+GFgRTwZsfTWU27iDuBdqj2Ccojj3ML1yNCISRCM/lE/18qa++x7neJnLVXMsZRdkOpFBRNN4kM35UrPRX9C2KNVLefODPf2CT3emGdt53MapBbTMG0P4eusaOXGBvyb4k6RCkwNnSVgaE7O8RE1XLx1uR8kElYkDd3vQnYHPLGf9V+zfj8jgW7nVZ5wVYQCiHZq68pb/MT/X9J5Mxdd2PbXSSSWC+LieJVl2h8g/ippdrtOheyAkxTCzSnpJoUH5XFxPYR8WuJVLNZ0mBKSVNlS6FSTLLAOdR5rt6jyYtQCMmDjiMmvSMKl09suhLrRE5U+ZnkUCYiABtGFGZaFKfikxQfkUit+JoTuafkKIvJLHIupA3pCElICDJ+b8Y2P5NmMTXNmIL11b3bNuVnXMV13XO0sIuIQw4pIlOEy9fEAx0heUBIplbkRZoj2MU6DWv5rq0/598+qNQPRSWpWA5Nb4M7s4QU95A4FPrhvhWSt249SfGKmonR+4X4KQVxOcDmy92sr+5l/s2D7h21doEu1tjf++Fud6MxzhIuyPm8oJO4u0QohGRtJclbbz+tpK0POMBbX34aXo7L8eY9mLFuF7oS62omn88WSXSvhPrYOjFaMQqM9P9kl3vTgFr+Tm0oJuFwSDOBWXgr+zRMFDl5SOYfcROwB1BC450/OF3bZL+ADMIK+epN6HCujBRkPnu95i6ZZ65jojP/eu0l4d2i+rpxwidmFh8J1K5Z0vz5ytSj3vK7IyYhHTLWIhxC4lACLkZ45+JpAIafv0aKHF3UXh5eowsTjfe+eLLxuP88UkwgtIKi6SXW8ntdBekFYeC/+oD5rx6sv2pju3b3/cotolrzeCeNEplnrpNbTmFc7PM+/6KDie4uXYSr5mo/fFSJCRdblPyoGh3poZqjLSZgW5L82XMnRictfrf+uteh56+gYZK2lxtW7CiM2W+NeXPWcbxcg0xqxW2Xd0XUmgxslZhomkkXa2iYXP/6se3HLiFfe86uyqhaHywupilO9TS/8B2P3uHiVuzL/sHbaJhEPQZrlpt0Z70WiHF7+WHMkvdnaDK1woYRJf/GQPC5IbfOgE7kdBD8CtEXxNuWZbnK9tMWQgJAHAY++QHrq3vJXxzwv94eR3q7pjx+RpfHqXd4joIR9XUhVuJ2NSGoqGiaufW0j7GBVnHDXf+WLSYjwDhkjtYewnjhztwgmwvd8o9K07xSvNMWxHcKRiS+wf7+257FxK2IOKzRxdzyvrrnsPLcxGo4s63l92Jc6PO/jF45wdoMJzjPrxg4qQyyeBek+1JIQF3Iu1sxiQPxIol0bsfFFERMvCxJ6rrpOQrYIaoV0DGJ1smOvUGU2ctjZI4FF5BaZG8cgJw9FEi7ewTHE2ukexfZW2c4W41XEXGoJSYxW9zcHO+VXJLixR7vYuJFRBz8iIlz+6cgPr6EMdMnPWZzHtrwICThmiNpRhypsEFXCwzgClJIhoERQ6YFrCIaLxCrc1HF4hsUDDyLiVe/hlJJAyPqWky6tPINWE9AtpGH7NXDSqyRahLpHHndm+u8ke9iARjsbTzM8SsgDl2sMdh7h1whtRU/40Wwk6kVVk7gTUz8iAjI6z6FOzGxFxbiE0vbmxhZwjjTB6/RktW29hISkAdVxYFwrJsJ6K2RXNkNXsQkiGNUqaRRqjER68x5bNvm9QabAuKQ1R8hc0TtMmml45oXjHwXt0v76w5zgoqIQxdrFGJRNvSYr89vSyaVc/GBIJOmtcQkBZzZvlskc7futRYfWcJ4rg9eRnkkcPsJiUomZRKdIDQSE9VelWt56ZrelVgnqcmEP56Fw8ZEY/abY/IPAzgvyOoHyBzyF8ZfTW45JQPcfFI0otxe3A+wzQ9ElYiooiuxjn56nlJJw3itwaqVikvBWXF80QK9BLpJPOEt4DWeWcJ4MQklHf5UXXxUKBzSdo04SmIx5ITc9iulla7ZSW0FDdO3iGyRq/jdAM5FuDM3GKxNm6CT0SDFpGhEeX9OZgEKm4g4ROMbMjvdcw1ywKi6HD5lEE9/RDy14llEHOKpFeLpj+Az6vILP7hCcgJ6J9R5/FSKSStFZLD3TnABAW68NL5zYwk2X+kmt5wK3L5qwioilWi6WVtMFF4Oteby/BJPrchCMXqdlwce7KGNYpxhTthZY2/D941v9GF+Nq/MSexBQtNN4s8uYZzrK5ehCPFhjKTvUvxUnevhf3HfTntZJHGkz0Nqd7vRiK7EOnrIQ9ezXz/c9OJenOu/N525D+lKrMOkEXoRASjmGz9U3NI+QqJDZPIuJ596g94Xs/UT3O4iznxLNL4RejFpxuYr3dIPpIN/Qi4iG4a/1apatIeQ6BA/vcTH+n8IwJHYNL2/kA2VZVI9aRtWMbl+64j7C/xchOzVwy3tT4fdY9OIKmurLYSk7+wtHut9d9u2I7Fp+j51KxTJYOqt/IRSTKbi7n0ISsB5yF72JibrhS6lFQw7qMfw6eNTj9ALycDzHzCi1XaUGtF+wvBnr+3qlHGz5eNQiokXPNa+ya8mWc72B/IhqWazpLEQxrHsveaE9LZWgmKhD7WQZJ6/zgE+aLjPPuYY+9VL3hoehviJpeb7NaEt8oFWcP3tYy3LcbFhxsje2k9+ISWdnYyYsos1nlhjfXUvtwv7+UjheHaFJBumunmClqO6SL1CwikkOvQ9d8t16c4kKzz66+94ar9eDE0rCI1V4ixHeiUL2e/XH95kbxxgaXafLR4V5qECQYkn1raOnVnSyK8mubl6gJurBygQXhFIpFZkIXIV2c5OWxz69BUOHXpfyXVktKB0SLj8SHTghMHJIe85Avayxslff4ObHGT+Dw7Wv2Hscp7LUxkS49I93o9l4fUz0fgGJZ9Lbbpu0t+9uFUHdw2141tXXIFs4jADxz9AoyRXdNx6r5Z0+bLdut1SKSK1uLO6D2CrxKcXp7USGrNXx2BaTuTXShfgh6WZ/ds3jFrl8pwXhLclYTtK/fCR8vzgvu47gAxxWFztl0GdHlA9N+IQHiHRgXHLl4hUcoAPWP/MXvJ/OrB9UtH5T50nxExFGYVTsr5vl0uXY78XXFdifStexi2p3hxpFre3w5pnMdkgGnw58gLMGwdlPhE/eBCUZiJSyYer8ubVdJN9sXJSpnrCUkLj2o3Htgp6G2/0Yeh2cmz8pW4wSxrLs03CCybt43bBjnGpNemdKv88/PTluk1pmOzrvsMGUXKrKc+Coppw5CMZm7R47T9u5WpVwY8WP07x5R55spy0dc04tf3MxhNrO4ZAKp5absWklohUYqK5Nu+vXz6mpnrbBP6FpBZVk4d7dJNovBDYhE90r9DFOrGq6OESGtduHYWLDXJupmDP6GrNtzTdlKU9KjBLGsvZfvcWGoAhpJA59X0zQBwOPX3FVwjECkk2CnI5t1BnWdfId3kbZo5E2ywfSZelVEQAPtb/Q96ZOC1XHNz+l+e3X1xGJo5hC1BieF7Z5Kqumw2fIMle6Z7eSERAPpViFCihYYbkVHrGiG1ZKKpEBOTqUZ4kie4VdEySrLgTEYAcbF7orvnWZhyWRvcSSayXUy86E8xeiFtSlHMCDBh46oOtoasfkqzgPFNyegpw/8BSQSiuvq5IbfUPTIJg/2GWrVWOfH5AWZBfNL4BRnSbmCR781tPz5SHNFaVT696YrJY6FdaolM5JR0Uikgl+VU5sTibOyBF60rA0HkDmIpQTERYGtkrh2hBIp1TFpHUyg7LKQgpLQeA1muysiwdrVREYzcinKs2YWRG7XJv5UpOsjdPmgVS5DyJiIO0R6R1Un1B5swUy69lwi0kACWttStbU/HgIlJJHshGpDgFpJhLUkL9HEeSFZK9MguY8lIaVXSEZBeJxjfseZCFwKkBnPwkznDHYcOItlV9lLYhgdIQjeyt/ZgtEJMu5DyfSnf4WgQSEiHEjBDiR0KIi0KIC/a2PiHEnwshrtk/H1LT1fuT6szuKnDEZI295F9WWOB7BLUTre2Mgdrcp0asJUKicW8KqauwSP4zy7JOVMzufh543bKsMeB1++8O9xhnuKM6N2cHmzZIEXAvacXQ5nngJfv3l4AXWvAdTTHRQ3+izZLGGl0UaI3ZqdTS8ZE1yyut8oXYbR+LB4GgQmIB/04I8bYQ4nP2tkHLspwS8FlATRJQl5jo5HiIS1dPbTkchRGzpLF8McP8PzjItbePt0xMlMW6JRS2VU1JQDaCMdun/KZfy3fJLO8hf6i0O0GfMacty7olhNgH/LkQ4krlm5ZlWUKImoNqW3g+ByAODAXsBtxEFrJenOtn843aPgBBWcr205dp7Nvhqp3pIZl4+TV7w6twTT/O2PFLxNzUonFJF2syU9c522/Cqzleua+z6jMupA+ECkr2KkrO/jsPxsJDJDJ+S9htJ59LwpV4a0TkHlhoKjDRpD+Js/zbonzCgQ6FZVm37J93hBD/GngCmBNCPGxZ1odCiIeBO3U++yXgSwBieNJ658aTAPQN36mbNqAeP149Sv5VhZOK9bgQh+eCNbF0YagsIJW8AtdKx3n08XeUDElMNK7O2c5XKXtjraC9ygnD6veq51ccMUkJWVhM9yEoJVH+Hr9BhC7I55Iw7SH3ihd0yqUhSsLfcagikVkgyYrSQEQTjduL+ylme8ob9QjE1UcR+xYSIUQ3sMeyrBX7978O/K/At4FPA79j//xW08Ys4E9lacel4SGWxocYfvIa+6hfzHrGfERGnMK9qxAfkKU3hhq7qb8K7+VP8ujTwcXkvfc/sdNvopZDp065JCQ0v7Fn7VcO0MVWjJQr8i6C1vKCtXyX67inatbyXWxmu2X/WlBRbktEnOPm/B6A3uE5RmIzxChsnfeggZk3Fw9glrRyHWaHEmCoF5Mgh2AQ+NdCCKedf2FZ1qtCiB8AfyaE+CxwA/hFT63aF+rs9BizqTEmfu4H26qt3WGQ2UtjcvalFRdKI0rSouibvOX5o0uvDcFFmt+ob8B7uZOQgomnf+CjkzB19afdzw/F8bcC4VgnOvKpPFFHTPK2mLn9DgM2s90Uhs2tWrxuKRgxNq90t+66qBQRhzy2oPq3SlKx3Jbvj1M50RGUDaKerJSbiwcoGlHINQgDaIGYhCNob2jS4m/XifrNIE/ciP236vV7t4xQHhcn5Alw4i2asXRuCC7g7WbVgUmYeMa9mEy9PwlZIY+P2+8qIUUhyBBDRw51KsXEjfXRpM3IyF3XYlIqaRgX+lq33O2k9Kz16E3jW0j6Rm4zov2kYaQyyKC8RiEQy1k7678RcX/MdRqLSdsF7TXC8crcrdysw+yM2THkUKpoRFjKJUlkFuqGnS+d9yEi2PtfgKn4TzPxVHMxmbr1MZgW3r/HiYwO4v3qiJEupOCqmPsoQXGmB210yZXrfEtWZuLUHg5WswCkvVslicxCQxGBciqEyoC+HGUfz5yZYnkm4+9/LwH5SHNBcUH4hcRhmnKCmFbimK8jLvcvCfKzcqK3dyS7zYtw6eIQnAvQlxJwDqYSP83Y8UvoNcp0mmhML442j2htNSXkOSqhJiuY02ajt1thhThWp9fDuYCn/zue/ojHut9tvuNWt8rnPc0CBWJcunzKQwcb4AhK3PK9qtM+QgLyH25FjyuX8gKI1fKMfSU5T6ZXg3Sqglfg2ivHifzKXUb7p9Ewt3KR3FndR/F8T/M26lFC3gQhxbjSR2JiZ6H3UknDuNgCEbkXlm+8wMd7fxSoiWbVEn1hCIjrvsSkfYL2HPNZNXGkeDgvFZSEnKtQTPGPepheHMVEY84c5Pp3jpE/F3DZ223Sp12kUBVhWzBiGFf61M6VqRCRkvpzXvNr0Lh2+XhrGjeEr7QI7SMkrcKZzG0Tin/Uw83VAyy9GtyJr10ozvSwZucaLRgxitM9aq0oVZaIyz6pcGpsKYaQBcY90BGSNiSwFdJulOSScKJ7RebVUD0UUzm9lG9slQwcucmoFuLYDSCSucv+3g+b71hBR0g6hB8d+iZu8RA5DgzedD8RvhvkqSsmw0emeQRvXtv3mvjwEvv73ZWBqaQjJB3agkFNejl3scahY1fksnxYqSEmw0emG3pqh4H48BKDvXd8eVV3hKRD29HFGoePXw73JHGFmDgi4qXuzr0mkrnrW0SgIyQdVNOCqNixx3eWZI1RYOzJS2omSVs12Z4FLgoKxEItInvSqxzovxkovuvBFBLb4aj3uSwnH38DEi3wq04Bk6i9SJ2bNIx+H04YwzBqxUSvX+hKx+TRp9/h0Z97x3vwnF5+ZZ66zqGnrmzbFhgnELIE818/yG32N/nALpEyGBmcCdxMGy18KiBl/xwtbqujE4lvUMwrnLp3/HmGkRfUjP23X9dx5yylKa8w5FCTfNiJh0ngv39xu28jFducPgdxW0/A2DF3BeIffeYdVkgy+72x5v4lOuw5sbrjBjr8pKxslzNTLE0NeT8ezr41wg1mvz5G6pdyW0F5oSBucXjofSVNtZ+QOKHbbsmU9z/5+Bs1d/lY/w95J/eUGoei6guv0tHtArL/XiwKHSkYtUz4HI2Dyerh9LHyhnOOqdubJ1XxvRN19gkiJik4fPSypyFBkhUyT18n+/Zhe46iTp8mGj+FU1qO1PEct5cfxsj2yY31zlllYGKT8zrHYKhWbfb4TNVQi/YSEifKNIU8abk6+6WBYemm/uiRv2Svi6dA7/Bc2cXdL81uGCeO8gLuvHQbiYiDc7M0c6qq7Fs9sXAjJinK3sBurh4/YpK2OHTkqq+iUQ+R46HH3+Hm6gHyWXs21glmtEXE7VN4f++HYPtTXE8ckXVhZity35SQ16DLkfH81w+y/txeTzE2tXi/MCrPe4D5oUjmLgf6bwbqRyXhTyMA8Kz9MwXDR68BMLc4SDEnq6gxZV8ocYicukt//wL78b4WfpODzF896PlzW3gJ3b9C45whbkSk1mdq7e8Ig9v+1UrVkEBad1775FCq+tmA3hNZ9se8n796TC+OUjSi7NHNQPMBWxnH8nthyg7X9zq9pkPkzF0+0f+Xnr//3dXHZOKm893l6yPluRnpK+LC4ey6mLhP0gg8C6Qtho/svOMG++egX67Lz6UGSaZW0DSTA3zg++sO8AHa0RLZq4e9f9hrrpFxyhfBLOVxdeWSptcbtsR2C8XZ5nVo4Uxc5ihbH3Ef/amk8kpr1J9MkVQsF+CLdjLaP60khaGGyWD/HLNXXMzD1KMExXM9vHXqSZ4Y2lnv+q33/0r9IfYMZeFyrCHwJCaJkXn6u9W76IdXSM5C5vHrrsbIg/1zypx90iySxaOQ+J1AdZyq0pQnZYNGOHt48jfECeYbQW1EbJOhTiSxHq4JySpKaMGDR0vAhThvIcXkLxc/QXHGjuD20rZHMXFERHVBNgijkJyA3mez7I2t7crae5QCh45e4cbVcXcfUJFMJ17xClNBq1aF1dcTk7TFSH94JiNbioEUkytPB0sE5YhJjm0LC7WIxtVXdXQIh5DsgcxvXd/604+ALJKmX5GDheuDrToj14OEzvbjl5IT42HGRCP7TR/D3npUDkWDtgNla6ZGOozEyDwpLafgy2oTCoe0yGAB3S4xGQYPwBQfyUndRqnzOiISnPz2V6kFtW+V0w7nvXJKUZeTq/u6a1aFUUYohEQFJhqLCoMv9jFH5shPaotJO1xMYSe38+9rl48rrevyQDMDJIpE0t5TAvjhvhGSVrCf2wwcubldTB4kEVFlele3maP2cczC9avHAtd06QAMw+FDP1bqK9KIjpA04QAfyPRzszyYInKF+o5/fttsdBxnYW55n6IvfEAZR0ZH30M6QtKEd5cfk4WtpinHzLSCRFFtlvygoUOV/goz9isXoD03IuJ89WwfKyQDfFmZFZKskGxNsuSQcujoleY7KSYcqzYh5d3lxzBerUgynKU12bkSRSKJdUisU4z3SBf6QO1RjmL1431ZfbMbyP89R1mg3LrIO7gUEZDfNVsa49DxK758SgrEtoRooxDd2m7GdDRKdLHuuc12IXL6bsuWeBvRsUjq8H5hFOOVvu1P4RIwpfiL4pYUEZtI+i6cChC24IgIlOuzJNhZ5KseBvWFxwmNzyGHPG6PRQ7vw8IFuPHmuKeVnJKdXT9nptgoRLeJCEhRWS90+bZObrzu0rdoF+nv350cE/eVRVIgyo9Xj5LqzvnydDXRufRVu+hQvSe5SoexuEWkRrbuSGqF4hn7JsjG5U3rhnpioVe8D/WtAy/u9I6VdsFut949FuS6zsO17x/n0afeabjbnDm49btZai4864UuiOHdMsl52/1ek3h2ftesrVAISfEjdUt+pZLGwnI/C8haqI/0zjSN/t0SEBWlJt2iU1NEHCJOCdCRDYqlnuZFwb0k9nEEJVexzc8QyPlcDiko1TlJVDwcDXjveyd59OmdYrJAeofV4RZHTGK49/Y89PNXuPFNWzFDOPGuuSht2irCEf37yKTFP7rAwM9/gEbJl1NaCY3ccsr1/uneRVLkmHr9p5vfpNUkkDk4/Mqwbg9hPFCc6pHzFNUXsAo39hz+haSaYaSrtpc5ETck4NEnpZiskGSloGYyFiAZWyFK7drNtciZqXJdoSAPH5WZ5OLQ9+wtpd6rXqJ/wyMkX7BnGEdg4OkPPOWi8CoiABtGjM0L3f4DsFJIc97rheBDRCopXugph/mrioXxmmypGRnUx+jEYfgpmUJCpYg4eBUTh+vvPwYzVdG6bo5lHHkN5Tx/Zc22EqfnlXuvtncagRmY1w/Sd+oWXVrzGfsCMVaWvV+1mwvdwU5iDmnJjOB+qbXOnIgXIpNShIqv9dybOrVhwYDZN8foPVEjj6ECVgpJX2Jy+Mi7cKT8t4nGjTft4U+e2qIyCqQsBo7cZP7yQWlp+nX8S0B8svUu8M0In5AATMMSQ2hPNbdM1lf9zcDHh5dkGj2vw5pKnItkhOZiokBEtvEgicg9YqWQpD8WLFeHhrmV+3Wx0C+z7s1gW2nlrH0O6WML3Bw5QH4hJTc4CZPckuaeuMA3I5xCAjAN86WDW5OIw49fU9q8ke1TY84v0DR8W7mIdGgL+mOL9B9d5M7wPvq7F+v6xBzovgnd0pX9J6kROew+330vuxqY8AoJbPMknTXGtsbIDmtmFyUXy301yXFvlvM6IvLAs6/7jus5v0d6Z6AX5p6TS9pLM/tlKtFapGDguP+MgCppH4e0aWSpAZs1s4u1fEjcnvOUhan6pSIzfQ3ip5da0m6HcDCozTGozXH4yLsMP3+tdolSXWbODwPhtkiqmYHZ+Bh9k7fCIyLOsKbeuDYLxfjebd6rQUn15+Qvp8F4o09Zux1agxZgHTxGQVYVfPwS5uPydr3+nWMQRxb1CglNLRIhxB8LIe4IIaYqtvUJIf5cCHHN/vmQvV0IIf6JEGJaCPFDIcRJpb3NwKEnr6Bpu5/8CJAOWCkX+81EZOZxBWyJCJDszTPwcx/ARLHdHgkdPKJjbonKoz/3DoefubwrMTX1cDO0+Qpwtmrb54HXLcsaA163/wb4GWDMfn0O+EM13QTScOiT4VFgzzfuTMSV+3Y9NL1Ess5cy8ChD+XKURjEJE1nRakCsx2yvimgqZBYlvUXQPWA/HngJfv3l4AXKrb/iSU5D6SEEA8H7uUwHPq5soh0sUaXwqGCL5wylfcATS/RlVhvaIkNHP3Av5gELTXhoNJT8z5ggyg3Lo3z/tyo0jSSBWKhEyi/k62DlmU5i9dZwImaGgIqUzLN2tt2IIT4nBDighDiAivz9b9pFA49s9MS0TQT3Wdsga6bkClKN/d7+PTczHlf0nMjIg5bYjJM7cm5anTkHM+4JSOORwl2PJwo41ZhwHK2v2XNr+W7yJkpJW1tEGX28hjMwOb5bmX5Vdbo4s7qPnKFFBv4izNyw+1lb8//wM8Py7IsIYRnP3vLsr4EfAlsF/lqRpGV9Y7V9h/pYg2tu0R+NelpCVjXTRLdK9IT8BBcHzkCuTicx70jkFPlzCtZKNLj2kXei4g4DBwtLwfO6wfrJ2MaAXToHanwFB1GOlDlqvbN495xr94xDHKlOV0sAbMRlkdkadXI+F26AtavXckl2XSun4U4S9kezFHNt2OaicaNG0cgF9l27LNXD5M8eilQcvPKGCOzpLGCP2/cRtxcPCDn8y5Gmu9cgd/TOyeEeNiyrA/toYvjn3sLOFCx37C9zT3DwLjBwNCdpkltYmxA94rrOBtdN0l157Yd+MND78MQzKRHtl1QnK/XCMFiSbJQLPUQyTQWEz8iUk3f+C2W9KGdIjBu0TtcO83CNmGxKRhRjEyftC9n6nyZU5enHm5EutbVOMtOYbMdCYvZHpbjPSTOzHuOfF3Ld8kbJl/lSVqyxXQEz2Jy/fKxcka5aq6AeVT3LSSOiFTOs6kSk5yZYmnKHjj4dNf3KyTfBj4N/I7981sV239NCPE14ElguWII1JgEJM7OE41vkNTcr43HXB7AdK+8KOod8MqasBtDUXKjKQDybwxsvzCGCZ7GcMEWk+H6YhJUREAO//pGb7GELSajsCe1WnfSth6x+Aax0SxrmS6KE7Y5/Vq8HC3sWGhBj0u12DhZ2ephB1zm8wPyl4QsrtaMtXwXxWxPfXEzYHk6w3Kin4FDHzb11bh+9ZgUtxblFKolIg5BxGSDKLPfHysnrApA0+hfIcS/BM4gpxbngN8GXgb+DDgI3AB+0bKsJSGEAP4pcpVnDfhvLMtqmjgwMvlx66ELr/gu1dgsWXC6d9G3Yq+xFxOd+a8elEqtMklWmpqWSeUSrwpMU2Mtv5dYXJ0JXDCimCWd4ss90kJrxSTrDN5TG9hJlnondwqKWdLIz9ii42EYmzl2vWbCoJm5ETanut0/wRPw6DONkzRVs0YXuUKq6YqfppukYrm6S8LXb/wUXKkxXGnU918Q7ZVGIDY5YT184RuB2qgnJkFEpBITjRvfU5xqL8UOq0S1iIAUkiBLz40oGFGM8y1wipslWCkMR9heMOQcWMDcKIeOX9l2k95efhjjnPf/e+x59/MkBWLcWfWWUb+ytu8KSea/dbD8ptdj4EFI2sdFvgm1VnBSvTllE1Eapvqnbk6O8x28Djnc0ioRgdrHXQlBrRwnbeRMcBEBuHFpfGvJ9c7qPl8iAjIbnxv8iAjA4mo/G0S5/s1jzH/zYPk4tDij230jJP3d5YkxXTdJ9ebaI1v4AhRzSZKplfB47IaBWtngdpkbl8ZZLPSTf23AdxvXv3Os6T5+RcRh9ltjzXdSzH3lPhSLb2CWNPZ2r7eHiNjsSax1RKSSe5k71yPL5zItbT+oiOwW941FApCK5djbvR6aiMgOPsmhNlu/SoJ6M5fg5uqBmm85zmbtyH0lJAWizN8I7pHfoUMryZ8bYHpxe1nFFZLkCqnd6ZAC7hshMdHIfvcwnIvIpa4OHcJKSSbxvjp3FGjsJ9Iu3DdCMvutsbLfwbkI128dafIJb+TMFJFx/9nfG7E50+0792wzTLN9L87QomLYZcDmxW7eu/Ex9SJyoqiuLZfcF0Jy4+vj5XgMkCf61TjXv3qMxUKwIK8VkiwW+jFLGl2JNeInltgzvhqozR3MQv4bA8y/dFD5jd/OT7lQMk25IHpQQTGAqQjLs4NNd3VLqaTJJFqn7u0kU9uu2tx4c7xce7Ze+ck8LH8lQ/SXNzxNwG4QrVs7JRbfkKtDk2vks2mYDZBKMc+OujpL/3xoq17NwC/5z8d5APnZ9VgXtwv7/fexAWZJI/9HA9I1foRQXk2Zp66TvXpYjRVRXevYERTwVumwuo0pQT6eJKHQjygS36A4qcngu3uwAhYKi2QTQYHotlc9TDRuXBqHi7h2tJn/4kFXhaNNNEw0VwWYNN2UgW9+VgMNZD3fesW57DKY8188yPzr3qwUjdKWiADsZY19sTnl5RwLRpT8P7f9KQzk/xKmJds49P5KlkHucPzo+WBxQCWa1192lqz9HoMLcdbyXT4/LCmVNMxSWc0iiXWYsO6JwIfCRV6MTlr8blVIzqRBX2ZxWwCficbs1TE45+97+v7WzpKGlQli/M6aL89k5JPJjUu3Qf0I2npMsDU/U8uFvrLMaT+LNXOErpAkx0OB3eXX8l0UjSi8HN/5lE+hxiM1SMEogAREXrjLY/3vbm0y0Zh6fxLyHi1I53x5EYhK0fJ6LCYN35ZJtZA4FBd6ytecFx+ddou1qSkkNntOlecjNnPdvkUEgDjEX1jaKihkorFiqpvoWp7OlItq16LGUMYzZ4B4kYFDH6JRIsYGXaw1LZTusEh6Szy9lL5cy3fJC/IC2+ejqkkRTEyCRNHGkXlsxg2OD13c8fYGUd679ZhME+EGx9LyOyzyO9w5USSRznn6SD0RqaY4XaeGdC3uJyEB1DooJYBTFvH0R3Ql1pVPRm5FmFbeDE5BbZXVJs/A2NFLgZzvFkm7ssLW8l0U3+hxn9woBW999mNMLk2x0huh9zWX8U5ODWI/1ogOnLU4fuTNhrutsZdrt442F5OgIqLjfzilA+MWiYw7RXUrIg7FGTuFQrOHmgchCeH0WA1SqLsJ88BrAmOij1iNUPOgaLpJYmSefGmgPK52hEQlFyB5NNjkXD8LRGMFNojVFZSCEfUmIsB7nx3ha+IG3wGgiPX3XQ4ndHjpf/5FPvOPv+7+y2z2/MIqHxv8UdP9ulhnbOgq7+ujbGYbpL5UsSrjlxJwRZDPDUCquaB4ERGAyIhdPzrR42+oXYP2EJI2Q9NNSBVlur2Qk2QFk3W6Ymt8RIr1QnnCb/mVjLsnVxX/A7/HE/z81t9f+G0PH/6tP+P3rRS/8Y+/6Gr3PS+u0pVY40j3+66/oot1jgxOc61UxzJRkOgnMM5xXxDk9VTdoY7vSpPIXDhmSWOT7sBi0hGSDmiU2EuJKBtcunCqbEnl/LX3b3/3P+e/xH999o/El/is9TG+/I9/rf5Oz1lkjvyENIu+6rt0sS6XSKvHH34mV1uJAVyJkJ+ovTzs1RqpRtNNGF5ls9QdaP4uFMu/HcKBRml7+VGfWG8K3yLiMCz+eyZ+/Qe13zwDE0cuMMidQEWijvZflZajQ4myw1mYMICLO5eHC0ZMSfOabhIZvevPlcGmIyQdlCN+3qpdg8QjPy+ekKtUlUzCxPEfKKkyp2EycegiJCx3viK7SUmWtXDEQ5WIVBIZv+s7urkjJO1K3H22rXuN9QXhsXRAfZ44/r3yHxNw/KnzSktVaphypSeoCXWPKL7R0xIRcYhM3PVVaqUjJO1ICpgs8u7iY2zQuosqDPyMOMMv/vpLUkSeqVcjJITcg/SGrSJywruYhPOR1qE+aWBSjuuL+b1M60d4pHfGtUNaO/Ko+AzHraO73Q33VMbgpAlepmMXiJy4i5cY4o5F0k4MAye2OxAauSQ/WR5hnWBxGh0UkK94GZQd7BZoO+tksL92AbV6PJhCkgKGi5gl9WUazJLG8qsZOB9R69A0jKzRq++8IjtiooCgKRRzbBcRB8cnRVUy63FZhbGV7O+/zX5ue/pMqIc2iWfnSXTLtfMNU84FLM3sh9cChO4ngFNF4qkVSiUNXTcxS5qS6NjllzNl1+pKVJi2aWqKiIORS1Lojd3XQ5xWcenWCXmOMsib3WusT47mDw0DKSZuirvXYhRIlQP6dN307BrfjMH+OZKs+LqGQisk8TNLjHTPlGfobcNh8Mgca0e6uPH98Z35IRrxnDzTe3STaLywtbnaM9CroCy/kWnswFWZr8IvI0C6eUzUzNwIjw2uEaXQdN9WEn1jmf8t3Rv6PP7vLj5GcbZn5zlyfuaoH/fjx/vVcXYbcbl/yl5FQVoh1TWEdN3c2hZEVFL9OfZze1sUuVdCKSR7Tq1ytPfHNd+LskGUDZJP/YCp/E+7c+19ziDepGp9paC4FZPlC5n6xcYrySOPtJ+jnQHG3U17bRpRpm59jONDF2umEmgpFUFqxW/08PlzFiTgtycDWI8VXHr9lPxltMjxQ28Hbu/91SMUr/TUftM5T2mkhVJpbfixWCpxnN7iNLZOEhA/seS6AJmznxcxicUL/FT3Vfn5gEvq4Yj+HZu0+MoFjj/lf3nv0kundi656cCzchjjBV0364pJwYhiLDwEX/Nxg6TwJiYVKzReOX7obddiUumPcuk7p/w5ZiXqbB+H3z4TTEz+/nlrx9O/90yW/TE5jvdSTdFE47a5n6XzPlzmZlAbwZ2gtjdpHBKn53016dYy0fQSH+9tHOT4ljjTXtG/e3tX+akAIgJw/NPnWSHJ9a8fK4vJJJ5FBOTJcOZPNN1kLd8lg5tKGnwlwBglh3sxSeFbRECO+08OXWg6AbtCktk3KyqzeX3a1hMQhyvw+8aH/E9xWSbE139UY/5h+VyGZfsuPPTJKzuc1GIUdgiMicYcg/5EBKQFoVJI8nZ7abZZdH5FBMrDHcfCrhaVmD2sf6z73R2fDUIoLJKuyUetn7rwfytpK0eqbkFxvxjf6FN7AaVoLCYBLJEtdJPM0G2ybx72/tkrNBeUZgJSh//4yyd4VVxyte9TwNlsns2LDcL96zFhkBmSFotjtheIMf/9g40+1ZgSMrGTakaAtJwPicXVzm85D8RoXIrqAe0mMZdzaG1nkahig6hyEWkJOco3YrWBk0FNOYFcnOysDxEBGEeO42uJZ5CEPcB/8sWLvGfJfCWN+Lvd8LH8FJvf9SEiAFNxslP2/+9T9HagIx8COUXtOYxAYty/FdIIXTdJdec8L+d65cH0I/GKY3qqpNJpyWEEdTVJguQ8BdmX6snAgCLi8OgXZ3jWOln3/S88As/mX+f6d5sX3L7njOx2B8JJR0iaYGT75BNtpAWNOysCht3+6O4PM7fQkUIyUvG3Qlfv//SLbzNofbrme8W/hP/43b+q7st2K9PZA0RHSBpgLDxULrOQQpr8qilRFhFVHosLijKz6ZQ9PlsQL/K3v/gVZqz/a9u2LzwNh+ss/fumzdzT25GOkDTCENsvwgQw0YLvGYY9TfxcPKH6xlE1x1CDl77833HO+rflDT8Ls98dq/+BDqHkvhKSNbowzvUpaWvLGqkmjlrLZBL6Ttyif3ARFBexagtK8L0vn+Wi9S/4u92Q/NU7u92jxszSUmFtV5oKiRDij4UQd4QQUxXbviCEuCWEuGi/frbivb8nhJgWQlwVQnzSTSfWi11bVe78sEGUFZLc+OI4ZME4r0BMSg2cqBLI2IegTMDAJz9A06SADAzdkWISNkFp9dpeAv4DTzGSv8He7vVwzRU5OB6pIB8mado2RUArcHOJfAX4p8CfVG3/Py3L+keVG4QQjwEvAseA/cBrQoifsiyr8Z1hwdSNE8RTKxzovUmMDddZsHKkuPHl8e3m/AwY8T4iE3d9RUoa+a7mrvcp5GSk34S54zDw/M7avgNDdzBNjaVsP/iJTFY1PwJlT+E43iq0eSENAz+//TgMHLnJvHEweDExVZSofz0kCJbE6D4RoqYWiWVZfwEsuWzveeBrlmUVLMv6CVLDn3DbGSOX5NqNx7hZOODKOpljHze+Ol77JF6B4pUeuerSKvxWUpvYefNUomkmfZlF9sTdu363BCefhrNi4zdeqJo0coJ5BPpeqJ2UceDYB/4jZVVSK5q7mhTej00KeQzsEKJ8zn3VwzASZI7k14QQP7SHPg/Z24aAmxX7zNrbPLGc7W8qJjfNA2S/ebixv8QUcA6MKx7FxG1JxxTyYvByAU3WtkSq0TSTVDrnTUyyEXV5L3Js927VkU9fR1T8PkkzEDlzl4FPfrBtWFeLgWMf7K7LpBP67+Z4puxXs4dLBttfiO0uBdk4+YWU5y6GBb+n6Q+B/w2w7J+/C/y3XhoQQnwO+BwAQzvdlpez/ZApR+Ie0KQ+LdLP7OUxaeu4jQu5CIbRR/xEc8PKmPHoDp9CXhAzNL/gTkPfafdpkTXNJJlaYSWXZNOINt45G5HCabA9SY+TZ8MLOep7b1YLiBcfjYyM7K5VCL3lGHgTP8ca8yrKzlCn2tkQtqywuixEyNvJUr3W/q2kOjXGSiHJSiwZqLxrM3wJiWVZW3nYhBD/DHjF/vMWcKBi12F7W602vgR8CUB8/PGas2vL2f6t382MRiqWY/Y7Y/7GzldsMTnVREz8xNSkkJOvjaJmn4W+yVsNn8C1iMY2SKVzbNhCks8lt8+d5CJSVHOUL9xqS6KW1TZC7bOfw70LuHNjuhGTFERO3/UsIpETdyleqBPu7wUvguDFEqlFpfOe42yYwF0WtoUI6JCnfnW9WlSKR3Wg3lpeZy3WFT4hEUI8bFnWh/aff4NyiqFvA/9CCPF7yMnWMeCtwL0ElmcHWb6YCZYLYgYMXIiJHxwfk1rJls74ExEHTTPlagbSQtsS2HxEBpE1upFL1BaGWqLnZ1nTMeXrDTF1iLwgJ72Tvd799lP9OeZRICRucYq9Bx0e6khL0FnZ8XKnlYBchHwpXbPur59yFHPL++jqXWuZmDT994QQ/xJZpigthJgFfhs4I4Q4gRzazAC/DGBZ1mUhxJ8B7yIPx682XbFxS0kEExGHmfpiYlwMODEbp7aYpPAtItVEYxv0Dd+RKSffwP8FXy0+QVYPnPmTqiRA8ReXiMU3iMaCTRr3nsmyfM7r+KwCtzdyo9UZv9/r1+ekBOQF+QVpmQRNq2iWdH6yPMJo7/t0tSAdZyjSCIiPP27x/zbJR2JE4JzCLx1nx5yJEv8TkDeTIyZnYOCp5pOrXjBNjaU/UlHLroIgF301BkSe8z6MacRGIepNTPysqKkskqUqPksHUkUiCXWJKz/W/0NXGdG8pBG4rzxbPXGlvJpjlnSMCwqXiR3L5JR6EWkH9pxVP6EajW00HpImql5ehxJhrbQXR6mItIr7Kh+JZy5KxzVyqHe2GoaBx9tERJyhSTuho86vJSyOb7XIQzG+V6mYrKN+4vXBtUgcZmjPMPMwOGvdY3TdLPtq+HUG7MD0oor4ju10hKRVGLCy3JrHvFnSiJy++8Al2SmVNMgU28N6MgieXKqFzDGotL2OkKjGGaMDxmyfcjHZKEQpGFE0vcSeyVU1wYNtwMpyQsZA6Saki+GOUXFEZIbQisntxf1K2+sYhwvI9f6gR6JWDlZDiomul/1AguCIiEM0XsAY7g7vRKEicospipWevbop/TOykXAlLXKGyE6fHDEZIZRW1FuXnlbWVvsIScKAsxq8qjC6FYJfiM3G6wbkpwdgdD6QmFSLiEMkc5fiRI+3qoOVhHyidYeIOOgm6GqEJHJWOswZLwdYuasXHZ1HCv04obKiihd7lFpLoReSgUPSgdYp9rTxt+wawG8M+SvkpAovE34lyF8ZQJvIenLOMk2Ntfzehvtoegkm7lI0evxbJiG9CuqKiEPGgNl4IDGJTyxtedx2fWqdlVyS4isePWmbpVhw/IpO4O9Yn49QHI0QGbnr48N1UDzkCuklBL2ZRfbGdnrgRTVZkyPz9HV4GhkB7NfjVa/46fze7KJ0Ey9Rh+WpDH0n3LnKuxERB00voZ1awjD6mi9lVpzxyC/IC7O40AMXXX2VKzb95FGpoqmIKCAyfneb276mmdL/5dM5AObfPigfVvWuiSpP3ob4FbsZZB+uQJEe+EyRPfGNQEXvTQXnp5pwebbaByeRWiHR7X6dO/vNw+UT6kZpbXM+8dz8Vu1TkKUrL715ynZP3rm/KtntrWOZmGb5BLsVkWqM12pELztCOQmR4fpPteJ0j/xskOVw59g9Z5BIrfgazm1NrLohG/feXx0YNmRGOhfMv36wXFDci3jUYhL319EstQVeBz5VUbZEN4l4SDdRPN/jTtheEK49W8MhJMdPWpH/7xz9/cGCadYLXSy/mmlcKV4HzlicPPL9uu3keIjrlypqqqie0NMhUTFn4gjIhhHdEQLuB+NrfbLPjvWUKVe1d0NxqsdfFLQjIhXHa88vrKLppmtPV08i4jDjcfIhDQNHvTsLzn/nYPBYHB3p9dysy1ncV/UbZysp+Z70akNrpZjfC1Mu55baTUgikx+z0he+pay9O3ODbF7plopebVk0EZFavPP+U5ALVgh7B7aYROMbygTEwTgvhSRyyv+YunilpxwJ64YaIrJFHDgtf42k68fg+BIRkImo3I75ddgzsiqTbXtEWYyTjrz5601yl4BXfbZ9GulWP77z3BdzSZgW7i0qD0IS2jmSIOwbnINByN44AG9E5EX2rAXxAieH3Mp8mYEjN5m/dFCtZVKC/OwAieF5pSICED+1FChSFOSFaJY0NuPd5fwc9WgkIiA//5r8tTjcw/xwD4nx7atYvkUEIG1A3oVVEkBEwI7gPkHw+SQntmcE7DxG2wmynP+G/FHM90hBsS3RYi4JMx5ExCP3pZA4ZA7dJJ9OUippPNbrv/r6AT5gXlcsJDaqRUQlmm6ijd6Vk556vPZEbjMRqWZWvvKzA+TtJ3J8csm/iHggMho8IjlxYp78xYHgnTEo+5ikKrZPoSaVwXkgDsVsjwyniNNS57j73rP1SPf7gUTE4fCxywp6055E4hswYtRO2ehFRCqZZWs1QomIZBoP0RMn5ncnxWMjHDHJ2X9fRG0+FAN5jKdQk8unAfe1RfIQuS3/k6Ck+EhJO+1KJL6BOW6yWeouX5Qtvjg9ES9AJgbZ2nNZKjyLW4IjJnlaZzEEXWlywX1tkbitjeMWpQ5BbYimm+yZWJV/qBSRVxW5fMYLNS2T3kk/S1D3ECc2J0zu/h65r4VENZpe6ohJK6oAlvBXDKwW8UJ52VuXIhI01WOH5nSExCU/Xj0KSDHZM7x6nw8K7zEl4JzCGKqEAWmIjy91RAS2Z7VvER0hccE62ycDo/ECezIKxMSADR8ZwTs0JzE87ytr/X1HAulNO2G0VEzu2+dqfjVJrpRitPd9ohR8t7NOFzdXD+xYpo3GCxhpTTpDeR3b5uyfJdhc6MbIdLMnvUo07r+fbU8JeSzTAWcFjRjMCPKJOKXxJeViEo1vSGcyVQGjGfvlBP5dQM1ciY70eclA5vHrAGRLB+BKpCUTr/elkORXk+QvDEAOpiYe4viRN32t3qyQ5E5hsK6vRzyxJs+JFzFZYOfsfA42M90Y8W7io8Fr7hjZPiLpNpvLMZCOWI5jWUY6EHprIwZviK0lVGO2D/2smlwwDklthegz18kOH5YbruA952ucrZq/8eElBnvLMT83MuNl35xzPjp4mq24MEdAHDKHbpLV98PFYBHTtbivXOQ3zBhLF4fkSchVvDECJ4+/4bm9OwyysNzfdL8tP4hsE9uxlohU40wUxuUY3wvGwkOQF/I77IspklEnKMWZnnKp1BJqH0Opqvaq/67cnqnxSC1p8Fpk5009Cn0v+i9OVkkXaztWAhcL/Sy/nHG/ivWCQSS+wf7+2w13M9GY/f7YlkewK56VVQuaPTSz3z3szip5EGNtTHQZpVnvRs3AySe9iYlbIXHYMGJsznbXftONiFQz3FxMjHxXWcBqXRx2vZogFkpxoUe6XlfmIVU5gZfCvSg5eWCGgVTFP/xyvP7NnJGfGfi090C9WuJRTc5MsfS1oaalTiMv3m0qIJUUiJL9/mF3YnJG1pV20mw0Ir+aJH9uoLlV8iAKiSuVTcPJp9yJyQpJbi4faL5jFTvEJIf7Wrq10IFRaQJXYpZ0Gfbv1kRNexcTs6Sx+Y3u+g5NqsTET46Xyhwy07gTaSdIbgIGPtlcVGIUiOJu1WeDKCU0aRVXBvadhoHj8rv8VLgz0Zj97ph0ea8mA72fkT4y0diGp+H7VqR8I9pNSPZOPmo9cuGrfFQzgqk52e8cdndDxeHkJ90JSY6HuL38sK/+bBgxNqe7/YXiNyON/yFFxiKScpfnxSxpbP5pd/PjqkJMAiSL8l1ORAeeK9/k1XgRkWpMtK2fqpwiTTRmvzwmrykdBn5T9juI53ZTMWlHIRm98CeANOcql1tL7JzoNNG3cngsnRvyNmRIw/Gnzjc8Aet08ZPlEQ+NbsfId8H5Fqy1pQh+0w43zrC1lZXsGx4TBulstxLcEkREHBSsoMR/Y4lUbw6ALtRMzpo1rt2gFFCbNa7hMKed0wjE2CBW8SRYIYmJtiUoJjrzlw/6D7VegEuXTvHo8XfYW8fULHAf+3bMRtgkwuaIzGBWST6XhNfi/pMaObi9qlSIiKIM+sbv97H++Q36Y/5SDLQrie4V1ia72DxfZ27PJaF3SEuyQorclrjMXw0gIg4z8N7lkzsczSDYkKal+HnaN8KI8XD37W0vZnyKiEOp4tUIHTUiopjlf9pkzuA+JRovBK4kEHohcUiyIiuoq3IEmoabq9snUxdJh1NEQGnOWIaLjB354Y7Ne0ZXg9/gbsQkRGUZOkCqN0fkxN3aSZZc0jZCAsihyLi69vJXBlghCcil3rnlfeoaDyl7Rlc5fOjHNd87MjitxlJoJCT3IO6jg3f6+xeIn1jybZm0lZDE2KB3ROFSyCxce/M463R58hdpV/aMrjIyONNworn3bDbQk2mLWkvGOmra7tASUr054pNLvoS+rYSkJWRbU509jCRTK02XC/fF5tRZDJVi0hGRtiDVmys7/XmgIyTIOh9BkyWHnT2jq65XJA59+oq6Mp6OmKQUtfeAk/2Dw5gtXGzNXnLpPl9FR0gASmqqjxn5LoxcUsZ9KJzLUYGmm66dl4JES3doHTe+PA4LMP8PDrZETLKXD/tetesIiY3fdXSzpG8XEIdEEUYJh6fOcJGR/p94+4wqi6TVPAATtwWi3Pj6eDkgsQTzv3tQWfsmOtn3H/EexVxBUyERQhwQQvx7IcS7QojLQohft7f3CSH+XAhxzf75kL1dCCH+iRBiWgjxQyHESf/dCy9mSWfDiMnKZfWsmVQRThRrZ193izM08JvTU4dIwrun5tinL6kTQZVL1w52MCIvWMGOb0gx0Zhb3sfc8j6y3zq80+2hBIuLwZfY8qtJ5m88LAtnBcDN6S0B/6NlWe8IIZLA20KIPwc+A7xuWdbvCCE+D3we+E3gZ4Ax+/Uk8If2TyXsja2xnCJYIFwdjGwf8Uz9aFtnHsUsaWx6KXA9XAQi3szGfMVP5/dh5M2Twv2NmcK7NaKSFLJ2Swn3DmuNcAQkg7T6AM4iUzXOBGi3BVTG2Xhxl7/x/lGZDuLlBjsZUPzTHu68qMmCcD7I3toPU2pMuqaXo2VZHwIf2r+vCCHeA4aA54Ez9m4vIdOw/Ka9/U8sGcRzXgiREkI8bLcTmIfIsXH6Fkuzts+H2zqmzTCAKTDyfbXfzxjBEhQPF0GvkS/DIc/2Sa5cjX2cz44gRSXspCn30/HMdSwsL+dMp2x1JJCWXjWnLdCFMpd5P9SbgzLR0TBdicmNt8fhFZdfmIPNl7vJPrefzJD79ARgV6G8oi5PrieDUwgxAnwCeBMYrBCHLDBo/z4E3Kz42Ky9LbCQOCdiUJtj8JBU4ZvpA+5yK9TDqPo5VWe/VAz0gIqVscVkpmKbY3F4ublm7P2brVrr0Dd6y2svy7xgwTd8mLxppOWQqt0n4jT/fzNsn6dJ1xCPbe2W4JQuxcSv97MB168e4/BR78XQGk1kV79XLSg3ro6Xr4la6QIakQVeiXsSk+zVw8qtN9dCIoRIAN8EfsOyrLtClC8wy7IsIYSnMGIhxOeAzwFEDjYf5NZT8wPdN5k7u8HSKx6LO1f6ONzLeiJpe5jjZDPwa+o7w6RGYqJDv+a/AM2hI1e54Xb5yRlugBSKRldWIzFJ2+3ELe/CrZfghP2U9SImGcr9vQjXs8cAWTf3QP/Nep/awu1qWPV+M3MjbL5mp5sIklo2C7wcZ/HFNP39jc93K0QEXAqJECKCFJGvWpb1r+zNc86QRQjxMOAknrwFVAaxDNvbtmFZ1peAL4FMI1Dvu92Yg4PaHNHnC3JSyg1+zOuLQmbjVkG6CJMVYuKXJmIy/Pi1gF/gEidjmZfhdqWYAEw4230IyLa+FGFSh1KdYU6cnZOzlXdBia0hZHGhhztn97Gv+w618JsLxPncphFVNxRbqEgBUYPsjQMwG2lZNT83qzYC+DLwnmVZv1fx1reBT9u/fxr4VsX2v2mv3pwClv3Mj5honiaoHiJH5vnrzXd0Eut6vQZUnwBVy6tZaj5hDj91uW6aBLdEKdD3d5oMjewMbr6WYXXkcThhSQGIF4MPH0G2Ud2fEWQ/h9meO6XRo9SA/CsDXP/mMTYq8oDIpBb30ox1yVfi5FeTOzbfmRuU8yEtEhFw50fyFPBfA39VCHHRfv0s8DvAXxNCXAOetf8G+DfAdaTW/jPgb3vtlN+EMA+RY+z5S8TPVK28OMOHHMEOZli9X2ftl31tH3rqirILPaoVdt6Uzg04Yb+CHpaZYEuPNZksStEYJpg/j229zn51jOtfP6ZUQMYOvQvPKWsOSpD/RwOsF8rpMRYX02xeDJZrxA1uVm3eAOqd6Wdq7G8Bv+q3Q0GzSumY7O/9kOsTD8GUkKazn1R8tTgvZLr/MDIDpGD4k9eUeqYmWWH9V7Is//OMFGEd+XRX6bDWiod7SZdDmJzaZtfpCmzptZrl38lg/p15SiWN4oWee/KdofFs9TqUqUeBGDNzIzAr7NIFqL3o8wpLSyomMnm3JRf5vtgckRfvymM5Qmu8Xg3Fx3VWqPc1KsHst8YUN9oa8r8/gHG+jitDCwiJkKgxbR0R2bxSZcqlUXfx52BPPJz1ZIvTPWy0KE3kYP+cnGxWLSLOnNUVQi3SHRoTEiEJTgmN67eO7BQRhzTBI1DHZXX7rkRITdtzsGLunGxTwcJyf6BYjJpUDjtLyOFZriMm7UgohGRTQTeu3XgMppssHaQCfMEk9E7I9VZNN33Fr9wLll4ZUm6VrJDEmG6BmVw9N2IgxaojJm1HKITEQrBWIxGzW0poMOPy4vMT53QKeke3B8poKpYpW8EVuHFZXQ6DFZJkXzpc3+NXNQbSMgkwzOnNLHL46ctyPqfDPSE065kmGmt0+apG5gmv/g6T1EzvGItvYCbWZfRvmDgB5OHapeOQsGomeXbLtS8eLy+bO1eKqkjbRitpJaTzwHhE+pa4JJJY57H+d9EooWNy/QFIMRAWQiMk4F9Mrr15vDUdOrHTEqmkK7HGGngXkwt2oOEIwUt6VjJBefhmAIbgWq58bPpO3NrhMn+nMFi/DEOl+36JrSpvyhJEN3t/CjihN3dS001ODl2Qv1ZE3J58/A3eyZ1uTcVDRRx+/LJ0yb+w2z0JRqiEBKSYFIgRc+kLUSDmL5K02cXlso5MV2KNFTdpBabqeBamKN/8FU5lrnD6N0x9M76ivaULQywxxPCT0nV+9h+O7dinIY77uBPK7xcvfj0XRVlMqqoDPjr0LknqlyDVFZXL3EYJNogp8dUx0aXLw7gl84H4zTnjYF+zkb91F00vydKxUy7KriogdEICbLkjOyZqPdbokmHXqg+UjlyhaWCNVKLpJpu6WTvNQEkvXyTNGGZbFqyGpJDDGB/Mvjkmkz74OW5OnFKzwLxGn/fKRQEjEZ54/D94/2wKWPD5vdUYwDTcyI3T9xkZOpDUVjyLilMCZXExTXHKdhg7Yb95gfpF2xuRAJ6DxPD81iY9sQan1sgvpMpziKqcM6sIpZCAFJMoUrXrWSc3ro77d3mvDBirxI4dcVZo3LA1xDGiZTEp6TI5zQLehi5O/o4s9SODU/gWEfDYn1rMIC0gP0McP9HOOjzx+Pd8fJn83FuzTwePM3FWlJA/l/53GW2+9CxExu+yv/+2K0FZNNMsvdEgUn2S8rDO+d5mN38COLtdRLa9nc5tnav89IBsL9e0q54IrZAA2wKlqsVkgbR/dXVM8+rPO5aIBxFx2DZfsmAPY4KMzTOUJzorI5UzBE8s7T+zQJkZZJ+8TL6GdKGrIc6NnKvz/mtQfK2HG8/1cPjxyzVjcRbNNGv2PJpx0cUyuk75QZFDXkc5al/vKeAMJEZqi0g1iVG5X37azuGj4log5ELi4AhKpZjM39oXTFXj7LRKTrgfztSiK7HG8lSPusk9Z2LToBx2r2LVZBQ1zmXO/xlyMYmfWcJ4xYcfTB73w6JX4Hr+GGNPX9ralOMheZ1m4/4tohTl4Vme7ZHeCaSIjLoTkUoSozIWx0j0lf/PALSFkIAUExONLtaYMwflyQlCdT6MU7WXeT3TihUCxytX1dnym0GsGmclp0Tz1I9+xv2K+Hjvj3hLf9qbiBl4n1s5h1wliyOHfiqHEGnKoR5TyO84694SqYWumySG5ykYMYppe+VxJuLrPLWNkIBc0bld2M/yVEZtboXTFr3D/hLo3hNcriC5Zhh1gufEyjTbZ5dExBcGZYH0ykXkzd4qH5Y08CmZ/CmRzilpMhYvEItLa38tLh1DvaYeCIVnqxcKRlSdiKSAZ41wi0grUB1453ijNno/ABPP/yBYA8Cjv/SOux1n8C8iDk4QYouIpz9SJiLVdCXW6EqsEZm86+lzbSckqomENJK3rXAmhWvNuygQfRXezntZa27VTRO8XIZDO04sV+BYKG554IVERalOB01vgQMUqB/atAJnBaBy2VqF5ahoiKBj1rdKHJf8Dr554IVk80q3HC4FIBrbIBrb4IB2U33VtzgwYsmE0WEWE2fy2pmAdZYsSwR6yh//ufNKugd2wapq3xfHW7fDFppuMtI94+kzbSckum6qG+PbF/+GEfMtJtHYBoPMsR9ZU2Ti6R+ojTrNQN/IbfqG74RXTBwRqXVe8hWvSn+YXSBKgb5nb5VXQNKE83g2IgPJ3tZlcY7GN9gf81ZsC9pISEp2DM7e7nUiI3dh2AqWuTzB1hr9Zq4bI9vHWr5r6+VGWKKxDdIsbCvNqGHy6JPvBHcaA9tvpBz92jd8R1b8CxONRKQax7nLg5hcunrKV7equc1+bnJQVmgcL5Zfp4tqEljfC0aKPHr0HQaZI9FdP8bIL9H4BoPa3Lbr2S2hP3yFiiQ9pinnM5KpFUitsJJKUpzucb8q4IhIHQEqLpQT5RbjRTbiG3Ql1nbMfWi6SUrLEaNAlJ2TtVE2GDt+iZsjsryPcbHP+3JrHDhRlOJRQV9mkZyeYnOm9ZnBXePFQnQTq5OjfE6vwFvPPi1/T1s8ceQvPHXtAw6wYcbKJV5rcaIogyrDzKjB2NDVrZs8zSJ0U7P8hB+i8Q36tQVfIgIhFZISGqbdNUc8apFMrbA2XsKY6mv8lEtR/k/d/sdGhE0jQt6IbkWdjg1d3QoirCUglXSxztHeHwOQezrFjdfH3XsP6rDn1CqpOkt8qXSOFd2UsT2zbZh0w5mITbD9fDhOYNVWy2v2z4TgrZGna7eZgCeeKcfjzDHI4mo/+VzSXc3mMxXfExSd8uSzipQLtojEqq65h8ihd5vkVlOBmg9iiTiERkhKaGyY3lMEdiXW0U/Y7r7VcQwpgq94GBEgwuGjl+nCX3rFFDmiz1zi2neOu1rJiJy5K62uBiRTK5gljWVSuycmOsHSVzrHolJgGz0Q8jTM1PbWrC0yI8Co4a3oe8ZCVRLyLQstS/l/G8H7UDwNh45dIUphh4iAHEanyFHq1nxbJppuBhYRACHL0Owu+uRxq/fNfxO4HbOkUTCiGNkW5BeNFzl+6O1ATTgxQwViXP/6sdpfc3aJLg/5YM2SxvJCyrWYDDz5AUlWtpJIzf/Dg+U3veZCSRH8UaQwcGyLcWSBLK/kIvBywO9O1dnuHKcJl+0k4NHH33F1g+dI+bJKNN3kQKx+beMp8cTblmVNumkrNBaJCjTdlKs6uiVrv6pEQd0VZzgUZYPjv3Sem+YBll4eKt/Aur0q5QFNN+nLLGKm5dN3eXpn+MCekVWODG53lNAoEaVA6jc/AuDa1ePyJnIjJqpExGkrjXox8UOqCC9E4BX8rS6lGrzntHeRrShzoPYxjMPE4+69ef1aJY1ExCtts2rjlmh8g3j6o93uhisOaDeJP7u0FYkcf3aJqE9PW003paiM39puQg8bO0SkFmNHL8nCq26WRKvnNsJE0KFsqiiPg9dhSMrDvk6+kSmkD0vlnFACJp70HhKQZpG93e4sWT9+Is2474Sk3Tja+2OYNNhzatXTkKYRfRO3IG1BpsjY0FXXnxt7/BJjv3xJ5sIYpfYNGXYv2zRyFSYImaL7xFHOSqBfFpBxOXEgLYczfhlkzpWY+PETaUaYL4kHhkNDM8oLWwXJHj/2SZlT49p37SzyFyveDLM1cq9xfGgUHI/eyaySocYgc8w08Ih0a7V4pXNJdKjL2CcvsUGMG/FxOI+ym6YtcDxf683dKBSRe8Xe7vUdDpSq6AxtOjQkSoHhZ65JP4sHyRpJF+v7gIRcRPq7F3dsa6WIQEdIOrhgL2vsGV0N7Y3TMsapHYQZYhEBSLLCvu6yR3SrRQQ6QtKhQ31SRTjN9hWZFKEWEYcu1tjXfYdofGc8WCvoCEmHDo1IFOE5O0A0tdud8UYXa+zXbrdcRCAknq1CiHlglXC4JbklLG5UXuj0+d7Qbn2u199DlmUNuGkgFEICIIS44NYdNwy0W3+h0+d7Rbv1WUV/O0ObDh06BKYjJB06dAhMmITkS7vdAY+0W3+h0+d7Rbv1OXB/QzNH0qFDh/YlTBZJhw4d2pRdFxIhxFkhxFUhxLQQ4vO73Z96CCFmhBA/EkJcFEJcsLf1CSH+XAhxzf750C738Y+FEHeEEFMV22r2UUj+iX3cfyiEOBmS/n5BCHHLPs4XhRA/W/He37P7e1UI8cl73V+7DweEEP9eCPGuEOKyEOLX7e1hPs71+qzuWFuWtWsvQAPeBw4DUeAS8Nhu9qlBX2eAdNW2/wP4vP3754F/uMt9/CvASWCqWR+BnwX+LTK/4CngzZD09wvA36mx72P29REDHrGvG20X+vwwcNL+PQn82O5bmI9zvT4rO9a7bZE8AUxblnXdsqwN4GvA87vcJy88D7xk//4S8MLudQUsy/oLYKlqc70+Pg/8iSU5D6SEEA/fk47a1OlvPZ4HvmZZVsGyrJ8ga+M90bLO1cGyrA8ty3rH/n0FeA8YItzHuV6f6+H5WO+2kAwBlUkYZmn8D+4mFvDvhBBvCyE+Z28btCzrQ/v3LDC4O11rSL0+hvnY/5o9DPjjiuFi6PorhBgBPgG8SZsc56o+g6JjvdtC0k6ctizrJPAzwK8KIf5K5ZuWtAlDvQTWDn0E/hA4gsxR9iHwu7vamzoIIRLAN4HfsCzrbuV7YT3ONfqs7FjvtpDcAg5U/D1sbwsdlmXdsn/eAf410tSbc8xU++ed+i3sGvX6GMpjb1nWnGVZpmVZm8A/o2xSh6a/QogI8ob8qmVZ/8reHOrjXKvPKo/1bgvJD4AxIcQjQogo8CLw7V3u0w6EEN1CiKTzO/DXkal7vw182t7t08C3dqeHDanXx28Df9NeVTgFLFeY5rtG1fzB36BcyebbwItCiJgQ4hFgDHhrF/ongC8D71mW9XsVb4X2ONfrs9Jjfa9nkGvMEP8schb5feC3drs/dfp4GDmLfQm47PQT6AdeB64h67T17XI//yXSRC0ix7WfrddH5CrCH9jH/UfAZEj6+//Y/fmhfUE/XLH/b9n9vQr8zC4d49PIYcsPkdlsL9rXcJiPc70+KzvWHc/WDh06BGa3hzYdOnS4D+gISYcOHQLTEZIOHToEpiMkHTp0CExHSDp06BCYjpB06NAhMB0h6dChQ2A6QtKhQ4fA/P9QyrKjV+wA7gAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -151,7 +151,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -163,7 +163,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -175,7 +175,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -187,7 +187,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -219,7 +219,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -231,7 +231,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARIAAAD8CAYAAAC7DitlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAA/UklEQVR4nO29fXAc6X3f+Xn4NKYHg5nFkANiSJBYgktSpHal42pFrbZuVZZ88kUvlcvKScqWy3WSc3Jt7spy2efkbOVU5ez5Khc7d1ZyLjtKrc92pMS2TomsknxWHMlb1jpSsiut5KW0L6QIcsElCQIkZjnQDAbTg272/dHdw8FgXrqnn57pAfpTNYVBo+fpBz3d3/49z/N7EbZtk5CQkBCGfaPuQEJCwviTCElCQkJoEiFJSEgITSIkCQkJoUmEJCEhITSJkCQkJIQmMiERQrxfCHFRCLEohPhEVMdJSEgYPSIKPxIhhAR+APy3wHXg28BP2bb9ivKDJSQkjJyoLJJHgUXbtq/Ytt0APgc8EdGxEhISRowWUbtHgGstv18H3tlt54mZaTu1cCiirnSnQQrLVHMK9ml3lbTTtX3uIrh3jLtIbITSY7S2322PIOzDUtzDaGmYqUjatS1J31MblKri9jrx+nfWbNs+6GfXqISkL0KIJ4EnAVL3F3nLC08PvQ+vM0+pNKOkrVy+oqSddqS00DFI0djxtwo5LEsqO47E7LmPFfByyVHp22acWCodj6TdrXIO6gol1QSeU9dcV/5HcdXvrlENbW4A8y2/H3W3NbFt+2nbts/Ztn1OOzgdUTfGH4nZUUQAMtSQ0hpqX4JgoUbkhkEDHamNj+jFjaiE5NvAKSHEcSFECvgw8OWIjjVypGZimcO/aSSWEjHxY40MQo0MDXSlbWpYaKgVzwY6FStHJruZiMmARCIktm2bwMeB/wi8Cnzetu2XozhWXDDqKRp1tWNsZ1jT2Rpp7qNITKKiRoZNRYLSKiAqxKSBziYZamSa2zLZTfS0oUxQtuopMMdppmgwIpsjsW37K8BXomo/LBVyNCzdtSYGPw2tF5xpSqinSKV73/yB2vdxw3hiUpMZZXMmKjHQmxZPCiPw57uJhoaFOeDwqYFOjc7nK5VukAIsU1KrZnZ+2Cdb9RRU04zRNNHA7EnP1hoZVq0ilinR042Bn0CdPmOakoZrnYQZ7kjpiIPv/Qe0TKIa1rRjoblTxv4tEz/DmEEsk14i0orUrMCT6JYp2Vq7j621+6AckYhowJkI2g3ByFZtRoWBzrI1t+0ml5qF1CxoGUZYpsSod7/oewmP6bbt/dTTDbd9f3gi4sca2fa5mFsmjpg49LNMgghEEMvEQvMlIq3k8hUq5Vzf/bbW7hue9TEDnAPKwOKQjtmDPSMkJpLLxknf+0vNIpOtYbTMe3hDoKDWS2sbmexm3/1zDL6ULLHIUaFM3uf+w7W7nRtZa85LdFoiHsTK8CMmFhplKx+4bdi+vF8p55oPorvVjNql3SCkgUM4otLKCwx9OLXrhcREsmQdH3iYobfMdxj18P2pVSeb7zuJiqpJ07wsK/UziYoKOfLcAcJPoPYSkzAi0k4mW2N9pQDVCSXthab9Ln4MR0iGKCi7eo7ERHKN+5UtzTrzKeomUmvVyR0rPWGskXb6zZkMIlpRWDAql3Q7taVSRABnAjYuItINDXgYx2oZArtaSG5RpGFE4/asCm9yFtRZIx69JmCHNck6KjwxaaBTof/8hl8sU7K1cp+y9iIlDfgfzYdiVwvJuOCJSZBVGr90EpPdLiIefldnEsKTCElMMCP0jG0Vk70iIgAGqfERkTXG2t8kEZI9gsQJ/lMhIuMiRDkqsfX43caa+7rO2IpJIiR7iBQN5XEqcUbDIs+deItJmXvWSBVYGmVnBicmQqJ2Hd5EYiKZZZWUrm6VJeEe42KVaFjMsDbqbnSmCqyw3QqpEwsHs6DEREju3fxhP9/exjyvB/IqTfCPd8bHgaJcHXUXtlOn+1BmDMUkNkLi0U0Q+n2mFwvytRY3+HiipxtUrFzkOTyiGN6EFZQwD5AgFORa6GHO+pKiTH4mvedD6jjDnPHQ6fgJSSt+BMXvRbggX2NBvha7oY6mWdticTwx8V6q0THIU+6bnmAQ/IqJZUksS1JaLXD7xiyXV09SI4OhOHdJOyrmTKYXVsL7g5v4mwupQuhRmcZQnNJiLSQenQRl0KHQHMtM6oP7a0jNQlNg2XgCkuoQ0FexclSsnOMDoUBMPIvBWbVxjpWjEpmYdLJQGkaq+aqUc7yxUuCuF69iSq7eWGB5/fBQxCTMao7ULEdM0iGqLwTJt1p3X4OSx3GZV5NRtCtjFWujwgSWmMxQYk2HTaN/rolOw6FUugH11MC+H36jgS1LUpOZgSKBwflfNde26YTnAGcQjfevxKS64XiVVn1Ez9arGZY5THH6ViTOeR66G3lckYPFIknNIntojerKTPCAvTWcCVa/eBOyhwhkWaSPvgE411pBL3FtZp6tr98X3sLpwlgJiSpSGMxQwtArlNk/0MU0qJgETSkQVEw88XDe998/hYEVcqK7G9WNnC8BaaVezbDKLHPTN5s3fBSEFZNUuhFcTFZwlnuD4onJUfresdmF20jNoqCXtm2fL1xj+ccOU//zA4P1oQ97UkjAuYFSGDtS7QVqI4CYeMF+g0z49hKT9pstqOViobnJpVPKxWTQ7GKeZTIMMakxOfDwMZVuMH10lfXrRX9iUmbwydMqzipPq5ikbQ6euLZtt14PnLnpm5Q+1GD9c4fCDZc6sGeFBKDM/tBj8l5iommWsrSLnpiAN7/h3GCDDHk8Wv931WJSXs8350AGoV7NcM10ChGcLMR3LVRqFtNHnaXl9cUeKzrXFRzMnVs59NCVptXZrcJANwp6idRHG1iW5I3/54iCTjmMxWRrVFhIJbEYncRCpYh4eKsd3qRpGBHphMqlYRWFx7bqKbbqKS6unlbQo+jwXAsOnLnRfac6SpZyD529QoZNUjQCi4hHjgp5WebAz/bob0D2rJBUcFZGVNGepEi1iHgU5aoSAek2nNtrbvSqmT7ZYSb1OsqGEiq/m7wsM/0z7nJ2p1egfiUoI5PdpFad9JVOcZT0mxOIas5kLyA1i+mTK47jWp3BJ1iHxKRew/i7b3T8W/1n/bezZy2SqIi7iACR+2rsdaRmkT70hrPUWh51b7pjISmv55W0lQhJQkeSIU446tVMZD4bqhh0tbITiZDsMYIsdSZisruprGeVtZUIyR4j6LyHU9Iq2MTxppEZSS3kBP+oTIYNiZAkKGbTyFAp50L5kCR0Zt97NpQt+beWRVHBnly1aaBTZv+ouzF0DFJYEX3lDUunvJYHUC4iC8Ulpe15ePWfx4X8TFm575Aq9qSQqHJE2ys4+V4bXYP7Vm7MRXbsU0cujuU8zdEj1yj8ZInzV98OL7g1cAZxSNNg4j0/5MHCK0hMJQ/AWxuzodtoZ88JSQOdZWMu1kmO2pHSCX2PMiK2bx/axOTWajHS4cs+zWKhuDRWIiKlxXFe27bt0WP/GY4577/1zLsdN3c/zmleHpG3bPG2wl83N3tpI03kQKJSMgqRVCzYM0JiuQH11wwnfqO9iHgc8YqJq6i+pyaviTVQRG9Q9mkW88VrkQbsVchRs9Qtf6akwRzLPfd59L3PYiL57jPvcqyTcoedZu79fPTss13b8nLRGuhu4GH/W9lCRjYJvuuFpIGOhWTZ6G5+eyc3ToKiUkTAeYJFNT+ikol0g2JhNVLrKyoR8WM9aVg8+t5nuUOeS985ey+L/FEgDY+8/RuBrDAdw41ivpcEq5vDYcXKRVY/Kf5XVgg2ybBqFX2rcKf9RiEuGemEgqusAzwOeCIS5f+tWkQyskaBUuAh2H7KPPr2Z3mdeVYuH+fUie+xP4QbbCfhHaYH864Wkgq50KbcsKwVTzxAbSFxUDOsiZp9mhWpiHj1f6MQkTBDsPu5xv1tOUXC4p1DidX0Xm2Q2lGwXiW7WkhUYpkyMjHJSGcIE8XSnoUci9gaqUVrgakUEA/HWS+6eZywpNy+eYm1oywLmzikjZgoRSQhOjKyRp47o+5GTzSspphsbqh1QGsnlJAIIZaEEN8XQrwohHjB3XZACPE1IcQl9+fe8/wKQBQJijxUWyNlKz9w+sTdhoHeHC7FGW/uJkprBNRYJD9q2/bDtm2fc3//BPCMbdungGfc3xN2AZYpE9d3F8saj1WwYRHF0OYJ4DPu+88AH4rgGAm7kCgTKcW6kPguIKyQ2MBXhRDfEUI86W4r2rZ9032/AhRDHmNg4jzvIKVFTlbGYonXQlIyCqy7sTRRsFXOsVQ6HtnE8Azhy3UmdCesbfYu27ZvCCFmga8JIS60/tG2bVsI0bEkmSs8TwJM3K+onmobBdZAh7KRj6T9QRmWn4jj1m40n/RBTXEv1LxWnaS+dMBx2c4qrmMAUHfEY6uco5QtMKf39hAdlBnWuCPzSgL1pLTGooC699175VCMiJaAQwmJbds33J+3hBBfBB4FVoUQh23bvimEOAzc6vLZp4GnAVLn3mpvuuvdsmWmWQUF1pC6RckohG5LxRLwsK2Q1slcC2vH8KFVXCrkts3uVxcPbm+sDpAGzYZ0iO/Im2dRkGk+KDkqVCShxERKq7nsayJjGw9kIvHuK69gVkXPKU1o5DHwNymEmAL22bZdcd//DeDXgC8DHwV+3f35JT/teTPgjpCkyLCpTPHz3EHqJreMkY2ygOGLSDudVogMXA/gUpGtcg6qfQo91QEEmC31I/1aKT4EpFLOUSnmIjtPGhYZNmkMOITyRCRFAwuNBjraCIMpu+HdT+1DxRwV5LSpLFerR5hHQhH4ohDCa+ePbNv+cyHEt4HPCyE+BlwFfiJIo5arot6TUtVafY4K6IQWk0GtkpwcbfRuN3QaVMixdf2+YB/cph3p7mLSusrjwwK5W82wzBzzxWuRnS+JSUbWBnJS80TEwyBFCiM2Vkk3AWklwybatMXaengr3WNgIbFt+wpwtsP2EvDeMJ0Cx6UXoMQMEkuJoOSooOlWzwC+bszr99yYvad6hZyvlHWeiMRx8rdGhpWLD4RrxBvytIpJiOHL3WqGq+YCDxy5HInnaK/C6t3IyXtu5604UeXaSIXE8VxNNfvjhxQNZqZLysQk9p6tFrIpKiqYpMasvup7/1l9lRP6YrNWcArDLbltkucOC/I1MrL7kzPOIgLOE/bg6dfDN1THmTQ1pftTCzcHUte5cvVNkS0JZ6j1/N7AierNyQo5WenpOFghN7IaQE4agUxT0IKQokFx+hb56XLofoyNR02JGWcVRgE5Kli61nUCdlKv9c0t0cosqyDhGvc3t1mWbLq/xxmlAlcVkJ5wJmNVYEb7tM9RwZRyx8RrShroNAKdmzL7yXNnaJbJoImN2pHunFFmetP1XB7MlX5shEQ1ee5g6ZKykW/OeUhpMc/gT2fvsxYaJVkgH+fqSC41Mty+eH//HUfElcsP8uYTf91/xwHZT5k1OYNlyWYmur1KXpYhO1hi6NgPbTwsRQrcSoE18nqZeXmNBflaKBFpRWI6VsoYkKHGodNXRt2Nnqgs5NQNFSIyTJf5qJKX52V5oGqRYyMkUVFgbSwci/YyV6+eiDRATmIqWSEahyA+PwwiJnteSBLGAFPj+o35yJp3fJYU1YsZgvU0DPKyHGj/REgS4o9mcuhING7zqqk560Gj7sbQSYQkYSwIk8902NTI7Jphjl8SIUlIiADPv2OvkAhJglrqgNknXicgp469orS9YVEjwxozY5EzNyyJkERAA53vl/4rlq05pRncLde/cnH9hLJ2rSjq3ajMNKCZsYljGZQKuV0vJnvWIS0qGuhcLJ0GnEhWWbgXJzRIjAc4N7uJ5ObGHIabu+O19QXmp6+htwSQBaVCjoqV440/PwJZID9wUzupCsiG9HBNG5w6clFNf9oYdsGwCjkk4y+K3RgrIfGennH1+9gkw2Lp5LZt5VKesnuHzhWWXZdk/z4LFpJVq0ilrUymZWrc3JhjdspJ9yIxfYvKGgUsNG7/WYtHa9X9mffdtf5UhZMMaQCX+X3ZWmS1f0dVdXDUwX1RMnZCUiHXDIKLm6C8tr7Q8+/LJSfqeK6w7MuLspuIeBh1nWt1x78il69QkGtdxaRMnvJGHoDqcwc7Dz+iEJM6kBaBxGQiX2GusBxJ5O8oS5d6Kzkq/i8dI1bDpbESEnArhpHaVpxoMgZ5PkrN6s/9WV2fxZqWPWNx+olIO5VyDvJQlKvbhk8Vcly9sQAraSeDbj+iFBPwJSj5Qll5LpJB002qpkIOCxn6//Ou+biIydgJiYcnKOBcJKMMtiox44iDz7B5y9RYWy9QyzrLg3l578ZZpYhlORe9XxHxqJRzWFkn8dIbi0ecjXXgeqBmHDExIYA29qeOe7X1tk4m8tFkkRu1gLTiLQuHERMNK1ZiEp+zG4JNMiMTkqAi4mGZWlMoGulUMwI5bAGq5ucXQzXj3PhrqBWT5ki0u5hksrVYl8FUxW4Tk10hJKOizP6BRKQdbyUmdkQxBWW6rw75hyfylUBJp8YdFUv4nphMUnOHTaO5pXeNH0mQOQoVVMhxrTQfWkT2LG1Jpvdla5wsLO7aVY0o0dz8aPspM6Mo+VdQdo2QDJNNMiyVjo+6G+NPVTRfd6uZkaUr3G2MQkx2jZBYyKFYJZ18RRIUUBVcunF65GP93YKq6gt+2TVCMgwq5PaWiOQJ750ahLU0S6sLiZgoYNhzJYmQ+MArhLSnhjNHYfrhFaaPrg5VTO6uTCmpiriXMdCHnsYgEZI+NNwvpUaGfKEc2XH0tEEmq9AJ60y4mz978va994fW2HdoY2iCsr6WVx6CHzcv6CipMVgm+DAkSw49aLTllMhRacbNqERPG0xOOTkypWYFdkRrJ5OtkSqUKWUL3K1m4ELAsP4z9rZqglKzyOUrWNlac6l6a+W+aJaHAdbSXDVP8MCxHyjzKWldDYqTc5pqRrUEnFgkXbDQOj4ViwW1fg6tIgJuNvP84M51uXyFlO7E2xSKJQ4sLJN9z22y77kNh3w0cMZ2hjMdkJpFJlsjk62RXbhNeuGNgfvZl/IEVy4/qHQlx1sm3c3WyahWvnavNA9IvzT/KgtKtYtI8xjSag6jGkbKt7drJltDyu39k9JqHiP18A0sU7L+jUOdg/ZO0lVEdvRRs5CahXbyNqYpqS8d8PW5QFQFly6e5c2nv6u0Wc862W2WyZ53SBMMcWWgC2X2R1YrpBNSMzuKSDspveFr7iSTrTUtka7HlBYpvcHB977OgfffcB4j3nW3ANMLfqL62trULPR0g+kzK848imrq8OrLjyhvdrdbJsMmFkIC4Z/0Emugkp4VcoEERGJRLKwitcEvQqmZ5Kar/Xd0SekN9LTR8Zh62iBfKPcVkR19kBYH3/c62XfddnOGBPp4R3L5CsyoTI/mYsKrF6MRk90S1zNqZ77YCAnQs1BzL1I0BhKRTbf48iDHm5kuDSQmQUXEY3Jqk9x0dZugdBsaBW334HtfH8ga6cT0TDmy1Z2okimPQkwkprL0FyaSTTIj9b+JlZB4BBGTFI2BvPgstFAqnqJBfrocSEz0tDGQiLTSKihhRWSsqDsV96JimGLiDaka6JhuGs1BiYOIQEyFBPyLyaDpA1Tkz8yw6VtMVN/4e0pEhkTUYiJd2fBWjyxXBJwUXfpAYmChjVxEIOarNnLb2r/aMWBYi8QjwyZVLdczCnjPWQ8JO+j14PKqA3jv5RjO3cRaSFqRroK3kqMy8Mx7JGUYOpCISALg2/q1mjOFzrXeS1RM5Ei8WDsxNkIC28UkRyUWuVr70eohmpDgl1YLxUKSwugoRnHxhYlHLwIgsUhhxEZEyla+Z4azWjXjOG/JRFD2KmH9Vby5FI8cFUy3okJc6DvZKoT4fSHELSHESy3bDgghviaEuOT+3O9uF0KI3xJCLAohvieEUL/4j38zMWoq5HzFxVTKuWZC54SEsHi+T3GxRsDfqs2/Bt7ftu0TwDO2bZ8CnnF/B/gAcMp9PQl8Wk0344eFDCQOYQPxxoX1lcKONIp7md1cXa+VvkJi2/ZfAe3RWU8An3Hffwb4UMv2z9oOzwF5IcRhRX1tUnOXzEaJQWpXiUNQz9hOWKaEJIftUIibe/+gfiRF27Zvuu9XgKL7/ghwrWW/6+62HQghnhRCvCCEeMG6PYhDWbihgurlZD80jNTQj9mPDDXy3GGGNXJ6JdTkcK2aGWtrRLWbeZTWSNxihUI/PmzbtoUQgX2ibdt+GngaQD/3lsCfr5EZuDBWWE9AC8mmEdxd24viVfH0D4u3dN56/iapUZE5LLn9smiQomL0t77+z+L/wi8932E0+zYQbwzuNj99xnHfT+kN5b5FreKhas7Bu8GjHtLEKYp50B6sCiEO27Z90x263HK33wDmW/Y76m6LBCd7WTDv1rCh1haSspEfuJBVrZrBMuVIfUvy3Ol6zjptt9CY1GtskukqKP9Q/784Jj7NU12Oaf93fSyVvw3ibTvF5uDZ15ljuedHBxGUKEp4DktAWomLmAx69C8DHwV+3f35pZbtHxdCfA54J7DeMgSKBGeupL+QeEtlYU94aaMQuqCV9/lhi0meO+g0SAX0mvQslwyb5PUyAMvWnDMnAvxd/d8zIX6T7/do46k/7XOQP4XzbBeb37V/g6/zoz361cmvwp+oqBaQUU6oxkFM+h5ZCPHHwHuAGSHEdeAf4wjI54UQHwOuAj/h7v4V4IM4BSNrwN+LoM+BUZnwRVVVvGGKiTMPUg49pvZiRQDm5TWQTttHxc+j4r/4k7bfT/MD/hM/4qNf/gVFZVzKqAWklVGLSd+j2rb9U13+9N4O+9rAz4XtVFBKzHRNI6BSRJbXlS9ADQUZwcSc196buKi0XY9fMif4UX4m8Oc8UfF+OvaX+hW+OImIxyjFJLbRvyoYNN9IN1SX5zTqOpsb0cZK6BhDL5akgk9pW/w0fxS6nSgS/sRRRDxG1a9dIyTtWc7ikKPBD0Zdj+Wy8Kj5afson+Ujo+5GR+IqIqNk1whJazTvuIhIQnde5OFRd6EjcfLdiBOjX4BWSIUcOkYiImPOU8/Aw3xy1N3oiIWWWCQd2DUWiceok+AmJOxFdpVFkqGGxIpspj4hIaEzu8YicVy+HZMzRSOSsazqKnseRj0VSZoBiUmBkvJ29zIWksXSyVF3oyejWKXbFRZJq4h4ZFwXqRqTypaAUzSYKyxjkKJUmlHSJkCjrlN3Xe4PHrnVZ+9gJJOD6rCQXH35jFNnZ+0RphdWmNN7u+93wkRyyyg2f8/rZTKKEnVNUkPDIs+doRZ8G1shyVAjRf/gtwybSjNJSSwybJIpXHMSzJTyA7dlmZK79e1Lv7evuk5vmhVKVOZ5feDPBuFPrb/Fr9ivUBO/PZTjBUXl9++JCAB1WL9wiHW3oPKxsxd8icGycS+0wKNkFpBTahM+D1tMYjK0sVtS3vYvkuVXRDwGLVnhp91BC35vVSd3iMg2TMntq4cDC5XEHIqIWGgsWcexTMn/YXySx+x3R37MQQn7/VtIrrz8EL2Mu6vnz2C4dWo6YSI7iojHrY3Z0PN6njXi4YnJMKzSWFgkkrs7vmxvSNIeM5HCCCQiHjkqSoc5HnlZhjw06infcThbVf/erFvVSSqaSSbrDNU65X5t9bSMek7E+05ag/YAPmx8jgv2Gf6VWA99jK23h25iB4N+/w1SXL94qqeIeFw5/xBocOyhC81t3kOxbOW7iojHrY1ZZqduKbdMMmxuyzYfhQt9LISkE61zHJ22D9pmZGIyBSWtANA1xUCnoYwf6uUcdTcbW3amjNQsNzeHiU6DDLXIk2FbaDRIcYd811wsZ4wLlG8c5qmOqaz88dTPwMPT/2XwBnqg08DA/41UY5KVy8chSDlj07FO0IB8nWxAi/XWxiyFqVKgORMvIXo3/xav/BY4eXxqe0lIPMIIR7f2GqQwI6hrU9DvWQOtYuI9iQYRkXaqa3nAEZTDU8uRDdtasdAoUfCV3ChfuBlKTFb+YHqwD/rAqRHjT0xqTLJydX7wjG9pO7CIeJSNPOj4EpN+ItJOa5sqaynHXkiiwBkapSKLkvRydqy7Nz0AfczaoNSqGXJT8RKRJiEs86C5UoLiV0yqGzkoT0Tal25YpqRMHkNPNS3OXgT1tPXa8+pEqRCUmEy27i4kFpN6zREP7zWG3KLIKrPBRAT41PH/aeBj/pao8yX+1sCf94MnJt0mIWtMUl1Rt7w/CJYpqW7knGx8XW50zxoZFB2DjDvYCUsiJAnbKDHDNe7nGvdTMXID5ab9NeNXuS9EH/5A3OZT/FKIFvrTbWWwQYqViw/EJom1ZTqpPbut6KiI+1EhJomQJGzDIEXDSIVKbVB+7DA/DNmPvxL/hY/w2ZCt9KbdKrGQXH/5VLDJ1SFgmZKSUdghJqqc2Ly2wqwWJUKSoJw3/fWLSkpb/1B8mgd5RUFLnfGcCyWm47V6/oyvZd5RYJmSWxuzTT+VKCbZc1QGFpNESMaUOBcnfzH7sLK1tv+a/6yope5k2HS8VseAmxtzka7UDSomiZCMIel8hbcWvjfqbgyFNfF7/Cq/NupuBKculCUKHzaDiEkiJGNGdqbMg9PRmftx5HviP4y6C8EwgTXYunDfWItJEPakH8m4cuDoLacMREI8Kbs/TaDqvN26cB9beUgffQMtxsPRsOxJi6RBijVmnPiHCDKqeW74E1l1XrmeiCRpAaLh4EMhAx3LLa9qy/Y1YBHqLx3AVORPtMycknZUsucskgYplo05DNdd3Uo7X25eL/eNOu6HFxfkeUzm8hUqBAvS60ZOVhIRiZA5lsmcrVEjw+3z9wf78BrbxaPLPvUXD5A9d3vQLjYpb+QxpnQy1CgSTbKtoOwZIVkyFprvjZaYF+99ySwgNWtbvIwfeqV1lNIil69QHjBYz+PgsZvkm3ZzQlTkKZOjQv6sk2FsqXScretdXOuqbB/K+KEM1ecOkn0svJhsbkzS0FJUNMfruChXhxJ31Y09ISRLxsI28eiEaUpMU1Ki4FtM/OSGldKiUCxRWi0MJCbTh0pDS1IUhi/pT/CX4lsA/LMR9yUMnm8JwOnCRV4xH+TuytS9HUzgeogDVKH69YOQJbR1YpmyGRC6rM0xr19T6qQWhF0/R3LNmu8rIq0Y9RQlo9Bz7sRCUiEXKBFNoViCgJNt2ZkyJ/TFQJ8ZNgv6Ev9U/0RTRKLgq/YzkbXdC4nFW4vf5+zZ5zh79jnnsRtGRDxMHOvkpYMKGnOwTMnSxkLP5EpRsistkgaOcKwxQ22A+QmjnmK1PktuurpD4cNESh48covbN2Z9BfGl8xXeNBVNXd1eaFhIzeqbhOeD+lcosEZB/Erko/QoJsQH4S0PfZuXFt+hrsEVqGoHSZ9Ut6JzeeMEACemLg+1tOiuE5IyeVbXZ5W0VVnPUiFLJrvZMTPZIBw8cqvvMCc7Ux6JiADMssotWaRido/4/RX9NzDEv4i8LyeBf2//0e4uLXId6vn9ZA+tKW328sYJUukGc3LZjXaONj3DrhraNEgpE5Eoyc+Umchusi+9M2Xk9KHSyETEY5bVZk6Vdn5b//hQROQngOft32CJ45EfKxDxrkSxjUY9xdLGAiUKkR9rVwlJVPQz84MipUW+UCY/U94mJgeP3YzNnEiBtR2Tzp/RP8ob4guRH/vnJfw7+5f5T/xI5McKgsTi1EPnR92NWJIIiQ+MeorNDRXxrNuR0mqKycFjN5kjeI2UKMlzpykmv61/nKviq7wxhOMWvgpf5MeHcKQEVey6OZKoME3J5sYkk1Nqc8hKaTFfvEaeciwdznJU+Ij+WRaHYIkAPDUPf/+/+RdDOVaCOhKLJACemKimRiY2KxPt/Bh/gS2G6BnyXniedw7veAlK2FVCIrHITffzVQ5HVGKySjGyZNRhiLrMRSu/PAVv/YPo/FHCYiG59PxZyI+6J/Gjr5AIIX5fCHFLCPFSy7anhBA3hBAvuq8PtvztHwkhFoUQF4UQ74uq4+1YSNYoIHGKSUUZaRmVmCwz5xagio+gNIa09Pov7assVK+ySlFpiVVVNEjx0jff4TiTacCM+0qPtl9xwY9F8q+B93fY/s9t237YfX0FQAjxIPBh4CH3M/9SCBGpzW4hWWWWtZYlrpQ0SKUbkYtJmLym3VhmrikoceCLfAhh/3Jk7d+HIyKtVMi5EdTxGO7VmOTV7zzS+Y9ZwomJBpjxSDQdhr5CYtv2X4HvyfongM/Ztm3Ytv0asAg8GqJ/PbFw6n90whMTPUJBsUyJZUVzsa8yOzRroBsVciyVjvNPSp/kIftv8kuKulPEWeL9eQn/yn6x4z5l9mOgXqiDUibPpfNneyeE9sQkiPancYZIh3Dib8rxs8KCEOax93EhxEeAF4B/YNv2HeAI8FzLPtfdbcppkKJCrmdcQUoaIKGh6ZgKQvnbMU2JdH1MVHm+elhorFFghpLv2iUVclho5LkT+vhl9nOtNN/8/adLfwg3YC0/w32/sAXAU78TvN23Ajftj/FmftVXH5xM76NJCFSi4GSV9zPtlnV/evt2E54szl2Xbdu+kqZqSrIz5eAd7UEq3RhKVPCgQvJp4H8HbPfnbwL/Q5AGhBBPAk8CTNx/yPfnvMpgXtlNP6SkAVkGirvph1FPoWkWqXRjpGJSIccto4hRT9GYvvckT9EILCwlZlgudU6eM1Neg//Ned/42Wmeepv/dt8MrNs/xa/5EJFR0xSRcsAPtgpEu5jk2SkgraxNUHUt7DCCMjt1q/lex4ivkNi23YzTEkL8LvD/ub/eAOZbdj3qbuvUxtPA0wCZc2+2/Rz3XtRtcJM3SjExTQn1lHIfE7gnJjqOB2y7v8kmGdaYoWGkmlHOa+v35os0zaIytdNs7paa4BbFbZ/vxeTxEq/bx/gd0f+RPQGs2E/yT/ikr7Y9yuQpECxHTFjK5AcTkVa8eZM694Y+fuZS1iZAgyr5QGLSWnh8FHlJBhISIcRh27Zvur/+OOCt6HwZ+CMhxKeAOeAUoGQ9z5sPCRMiHbWYROGwBo6YeBXkDVJND9gG+rZsb936VVnf+Ri8nD65o6SFZUqMegrL9HdZWKbGKeMS37Qf59+JK133y9gf5yZz/N/8tK92W1EVsOddP/1EqcakU98mrBeBN3zJE/wuM4HyBFVzpmMw38LU0o7h3jAjfTvR918UQvwx8B5gRghxHfjHwHuEEA/jDG2WgL8PYNv2y0KIzwOv4JyOn7NtW9l/pyLPwriKiYeFxjJzFLnF0sbCwHlAO4mPXwFppVbN8Djf5GH7Rb7+xQ/w1N++97dN+yle4cHQDmarzFLkVv8du1CigInEQqNMvmu2uQYpLn2nz8RqEDQGnzwwgaqguuZYJoenlpuWxigFoxvCtn2NKiIlc+7N9pte+IOe+3h+IqpoWHokYgLOcCJKMQE6WhlhGURIWtHTBpNTm9wqHuOfrv4i/5z/WVHPnCduLzFpXyp2qtluz6HrkaG2Q0wspOMnooowItLWzsGzr3Oc1xQ0Foxvifd8x7btc372jYezwggYd8tENWFFBMCo6xh1ncLydeUrLRaakwazZWjSKh6rFH23VSPjplSsIbFokOLV57v4iYyY9MIbY5Fqc1e5yAclJQ30DjlBEuKLhcRC0iDlJLGiGEhEPCrkWKXoOJudfyS2NX/riwe4RsCs9iNgz1ok446mWcrqpIwLBjpl8kisUCkvWymzP7YiMk7saYskaqLyegWYnIo2niiuGOjKRCRS0sDM1qh7MTQSiyQiTFNiVieV5nttZ3Jqc5v/SEIM0CB95g30dINJvcYK845vyC5nzwtJSm9guTVtoqAWsZi0+4IkjI7pcytIzSIn7zmEHTp2jRXzOJTjF5i3xoyytva8kAwjK1mUYiKlhZ5uhLJKVKzYjDOH3u44061884GB25g+t9IxYbZOg6MnFrl+0WfMzpBYpag0KDL2cyQlCpScVMSj7kooatXJyOZMUnojWX0akAw1MmySYZNjj1/g4OPBl1q7iYiHxOLY6QsDpxuorGeVl+RQHVkd20dRmfzQwshbhwdRroREaZkMMkSLyhKxTBnZUE4lnh+Jh8QiR4Xc4y8DsLS6wN2lqZ2rOu5p27ewwXzxWnQd1GDfoQ2K07ea6TIKrMXSszVWQuI5GNXIRC4imnvRTFIDHTzBv2w4hUuimsCMUkwmpzbZ3JjsKibDGMJYpmT9G4fY95YNMtlaLJ3yJKav9AQLxSUowpWLDznDkjqQh2MPXRjouMceusDViz7jeDRgpr5DqErMILG2RXQHFZZlOkd2hyEWLvKT5x60j7/wb7kzpGSYOSo9IyQb6Cxb9052FN6vUU7AtrvPD2sOZKuegsU0rNzbNvFjP0RqZuS5dIOgY5Ai+FDwysWHnCFKSK5ePt178tUVkWNHlny1l6HW/H/6VdQz0JuxR/1YESd8u8jHQkgmzr3VnnnhS0M5Vj8R6cRl42QkFkpUYuItCQ9zErWTiDRJAw87PhXpfGWkouLXGumGivSPFpLrVxe6LwunB7d6clS6lugMIiIQTEhiP9mqihwV9lMeKFdDe8U5VTQiGj458yUxERFwhgTPTcBzE9RfPMDtl++PJN9tP8KKiNNGeOGXWBw9tgSHOoQZa5A+OngZsgo5yuTdoMV7jntBRSQosZojiYIcFTSsUGUV8tzhlja751zS/WCZEi6kwW8N7BXntV4+1IyQPfj24QSljTJtYzsSi0NHlllhDlbuLedkT96mMBX+wVUhh8TCQpKiQY3JyEQE9oBFkmFTSW2W+akIZ+fHmLsvTvkXkVau42SyWVLana60r9DEAZ0GR49ca7rST79lRYmIeHhpScvk2Yw4rGBXWyT7FZbBHGahqHFh67n7YuVk1Yu4iYiHN8wxj8lmOk3VWMhIrRHY5RaJ6ovn9PQPlLY3rmy9eB9bX1ckIibc/rNow+RHkcM0CM7k6Hg7FO5qIVGNxEzEBBwHLZWRBWY0kdISM/YisltIhCQgEpOT05f3ZAh/ZNThjb9QW/7IW6FJGA6JkAxACoP5qWuh41vMCCv17XXitEKzF9i1QhL1hTRJjTl9eSAxadT15qu8lmdzI7qAvrHBhNKqusDMKOsGj4tAeWkpo55ohV26aqPTcD38ok0RMEmNWX2VWxR9e7426jp32/at1lNMZDeVuZL3c5OOJSbcXZtiM+usjoWtXOhFyw7iCt+LTtdUXIqdw/a+DENAPHaVkGhYbiU6ayh5RsB1eNMtTF1ybX2+576dRMRjqzrJFvfiYgYRFR0DiUUKg2JhFRNJqaQueU0mWyOnVyi/y6D6FwfV1n85CeTrzWLaE+kGUtv5HQYp9WGgYyLJoCZwsPWaar++4iAmw7I+OrGrhKRAaWgC0ornY3Jy+jKL6yc67tOo69z14Rm75QYIbmkWlqmRL5R77i8xmzdK6//u9UkvNBynpFK+77G7oacNClOlpkBPTtUoP7HJ7S/cH371RgMetiG93YraqqfY6hABvk+zMOo6mWyNlN7f2nCqFDrndBBB8XM9efuMUkxGKSKwi4SkyK2RiEgrKYwdYrJNQIK42JuSrXqK2zdmyeYrHZ/CfoZvKQxSGFh5SaW8swZwP+YLjkdv+3Hy3EH/OwbX/99TgdvcQdr/UOyuKblrSiot57JQ7O0N6hXI8gRFw/I15AlyPTm3sbN/Q3ESol4MK2dPP2Ix2aphsj9ExeY5lkcuIh6emFimRr2acYYypgwmIh7u56rlHLdvzHL7xqxbJe4Oee4E+p8Lco1MNph37kLhtW03SDuT1Dj6k5fUVZULgCco+QCFti00LDQMdCrkeloQYa6nlDvEjBLDfUTEhVgICTgz4TOUmkF23qsb3t/D1ISNkq3q5GDi0QlXUI4euUYqxETqrL5KJlvrOPfQitTMpiXSj0lqnPo755n+myvBUwmmgcfCTbSU1/IDf7ZGxk0qsd1Si8tDqRNxExCP2A1tdBrbHIm8J4c3/tuW2SwhMLP6Kuhwc6NzlqzCVGkgsZrVV6m9K8PWN+7zNwmbBd4Svu5LEIukFxVyQ1np263ETkja8VycvadGCmNPishEdlOpuXx4allZWx4Lhde4/NhJ7r4w1TsOJwucsSFm3sE1JhOX+gGJzdCmHzkq5AdMTLQbKBTWQg1rhsWJ4iL7zm30HuYcJdAEa0L8GRshSRgfThQXSb/njc5iMgNkR5/eM0EtYyUkjstv7EdjCcD89DWm37+yffCcBxZ2+owkjD9jJSQJ48WsvsqBD91wfskCZ7YSEdmlJI/3hEgpyDUyP1nj+o3e4QMJ/tBpJMu/u50l67iTDBnIzpSduJEkYfTYRMuOC3EUk0RIQmKhscosm8b25LpSs0hna9Sr7vZEUCJhHEqDRkHcxKTvHIkQYl4I8ZdCiFeEEC8LIX7B3X5ACPE1IcQl9+d+d7sQQvyWEGJRCPE9IcQjUf8To6CBTokZloyFHSLioacbTM+UmUg3wvlMmBrVjdzYTjRXLPWWWTpbI5uvMMcymT3oVxQ3/FyZJvAPbNv+rhAiB3xHCPE14GeAZ2zb/nUhxCeATwC/AnwAOOW+3gl82v059ngp/Q10Sob/JDyZbI0abiEpvzdU3a3CVgeqUF05iHHGiXqd1VeDdXyE3NyYo/qNg86VdmgC0uFWbSbSDXL5CkW52vQpKrLKKsVtBaFGzTDSDOg0Rh7169FXSGzbvgncdN9XhBCvAkeAJ4D3uLt9Bvg6jpA8AXzWdmqBPieEyAshDrvthKb9C1Hl0lxmf999gohHO33FpD6xPSS/vHOXrQv3sc591M5kWCi8NnBfhsVS6ThbL9zn/GLi1LLJCjikBxKTfZrFbNERzwybzHQopFNklTVmdsTNjJJ76QW0ZrEq9cdwLN1Ri0kgW1kIsQC8DXgeKLaIwwpQdN8fAVojvq6725QICagVkzL7sZCUjXzIXvUnk61haCb11nD++kTT6vDL1oX7uHzyJCeKi8r7qIKl0nG2yjlY7FAouwqsCDgqew73Dh1Z3pY/pJN4tONFRPt5KHQjirmHqK2TOIiJbyERQmSBLwC/aNv2D4W4d5HYtm0LIQK5KwohngSeBJi4/1CQj27D+1KCiskmGe6Qp2HpzZWWYaCnG5CvUF884GwYsLTD3cUpLpmnOXXkotL+DUqZ/dw+79anWaP3/1QFliZggR1icuBQiaJcZZJaz+jvTngBnRZaIMukiGPteMW3vVCETTJKb84oBUVixV9IhBATOCLyh7Zt/4m7edUbsgghDkMznv8G0Oo0cNTdtg3btp8GngaYPPfmUD7TQcVkkwyrVnGoAtKKnm7QOLrB3cWpcA0tpbnE6MWkQo7bz94fLPViHVicgDMWE+kGDxZeAZzvMKiAtOKk27zT7Fc7OgazrO74TKffc1SokFN+g7ZepyrFRBuhmPhZtRHA7wGv2rb9qZY/fRn4qPv+o8CXWrZ/xF29eQxYVzU/0gu/7vMN9JGKiEdKlYfnUprLqyfVtDUADXRWnnlgsPytJnAhzVsL30PHQMcIJSIeWoecvfO8zjyvM8fytnw3/Y6XoxIq6dYwGaW/jh+L5HHgvwe+L4R40d32vwK/DnxeCPEx4CrwE+7fvgJ8EFgEasDfU9nhXnjp9zslf7bQWDIWhtWVoXJ3cYpr6Xnmp4dT6NwT7CvPPBQ+Z6sJ3332XTz67mfDd6yF/ZSx0MhRUZJV3xOTO+RDt+URRa7XUfmX+Fm1+QbQYdYMgPd22N8Gfi5kv0LROtRZZq6rn8duov7SAUqPbVKQ/Sclw9BA5+rzZzquKsUNPxO0u5FRiMmuDNqzkDRIsUmG/ZSZ1BOHJRVskuHq+QhEZPC59qEzLvlwhl2udNcJSSczUaWY5PRKbIWpvJaPzPt1kwzXXz7lLPSr5MwWj55WO6xJGD67Skh6jTX3Uyanh3ua5PUyBUqxnXy7uzhFIyKTdm294HgEKWTfwxs8cux5tY0mjISYCEm3KRj/+JmwCpPrtaCXyLsCkqJBXi8P3FaUXL98UrlVUiF3z+9FIQ8WX1GySpMwemIiJMOrUjaIABT00o6xcWzzp66EF+V2MmzCIVX1ORN2I7EREoheTDR3gTgInUQEnJsrjlbJwcdfV15SQWLywJHLToYzRRx635UkancXESshgcHEJCoByuu9s9bnB5h3kZrFgr7E6ekf8JbHv0324dthu9nkwGM3ml6dqpGYnDr2iuPWrgBVhb3HHSd2d/yHd+OZ4CIEOgZ5vewrSM/PF1yghKnLnr4qUrMoytUd9WYlFiemLsPjlwE4f/ExArk+uN/exMkfDi0a+NTp81yqng3WzzYOvu/1sfXx8PxhVVp9OgaGWy84zEPRu149Sy+DVOpA14tYConnnep3X9VIzSInK759BnpNGErNoiDXfBWtPnv6Oc7zmL9o4Dyceui8r/4pJ8vgQpKOd0nMXtTI8NLVh9mXbjBf9Iqr7/Si9kvrUNu7+b2cKkGvay/gsPW+8crgGq5PFUQXIRxLIQF/YjKoiEgspGZ1jLfxRCQfYIm3QAl0qBj3gsSkZpGSBjkqgcz4s6efA+D85XeCKTrfsDOOZTAqTp0+zyXOwlLwz6YffoP7GY4rv0rukOfS1QcBuFtPcfXqCQCmD5WY1Gtk2PQtKL2cxdoFBfpf551EpP143jFrZLCQyj1fYysk0OrqrnYMqWOQkTUq5s7o0KAi4lGghNQtykaenF4hRSOUF+TZE89TY5LL+ZPcXZu65016dMuZqxgxp06f51L6Qbgw4f9DeZiZLkXWpyi4Q94JC7ix0PHv6ysF1ikwfajUM3OdZ7X6vZY9QbGasyhaR0HpJyLd2pWKBSXWQuLRyToJO6RJ0SClN2gY905ktxUav+QpI3VLmRt1hk3eWvw+5WKe0kYB05TMTUceSO2bU8de4XL6JHdf9JkO4dAWc6ivORwVa8ywtLrA3Xr/m219pYA1I3fUVB5kpbAV6X7eclMEtApKUBFpRbWgjIWQgHrrRMegxiS4J3BWX1WykhBFLEaOCpmp2sjT6XXiRHGRpXMtKRW7kYcHjv1gKH1SwR3yvkXEo7qW55op0dMN5vRlpZZ0q6DUyIQSkVYy1LCQoZM5jY2QeEQxuapKRKIkjiLiUSissUIPIcnCm9/53bEJeKuQ4/LqyUAi4lEv52ikG8hiNEu6EqvFmlBzDNliNXlDsKCrPbHzIxkmOSrM69diLyJxJ0eF7Lu6+MNocPbx58ZCREwk37rxTl698eBAIuJxt55iaWNBXcfakCGHS37aniHYXNaeFpKw49eEexyeWmbi3A93bH/kvd9Qklgoakwk3736TifDv4LseeYeK4i2p4UEhhfjE4Zx6CPAfOGa4/nqJrQ+9b7zYxGU1xSRhIFJhGQMbtIKuaZDUVyx0Lhy+UF4Ccehrg6XvnCWNWZYY2ZoHpZBqZHhuzfOjbobY8/YTbZ6k44qnnQGenOdHuIZ/1FjkprliogMlwohKpoi8uLOyOMrX3jIeTMDB9/9OnnuxCqfyyrFpC6zAsZGSNrX0C1XAoIKioncVnqz3Y/Ew6lvMtx0de1YLX0FHEGJmZj0EpFtrMHtL9zP7YX7OfX287ERk+O8hjxmsnJ1vv/OCV2JvZB0cxV2nNQkBChhYCKdYUKXALvWkpwpvYGO4+I+KkEpk79njbjUrAymlLFZBbGQ/UWklSW4xFne/Pb4LAffzzVWSIQkDLGcIzHQqZFpxgV4r3acJM96Xx+LO+RZY4Yy+31nlG8YKSpGjjVmWGWWVWYH+l8GZZXZHSLS7JulU2Z/rOrcBmIJXv3mI7Eq+q007MDUqC8eiHQJOG7ExiIx28x4v7Sa/+1POBUlOZ2hT4o5fXiu3cvMYVm9+2xZjrhW5Ggzm1995sxgH1yBl555B2gor2kzCMqGWqbmZKkzofriQV7KHgTg2NkLsbHAoiAWFkn7XMCgVMhxhzyrVpFVq8imkVFWUW/VKvbfSQF+RKSVhqWPbEXn0p+dDVeaokyovCaqecuxF8M1YGpwXdwrGmbi/I9luPrNM7z0zXeEaz/GxEJIVGOZUnlJzmGV+AwiIh41K0PJmqFkzURWjqIVC41L//HsYGU6O/CtP3u3moZCkqE2uJh4ItL1787rpWffwUvPv6PrcH1c2XVComGR0ke72jIoy8yFbqNsRVfbxuPKNx/qn3hpTMlQc+ZLtACrgd5wxi91ePXZR3j12Ud4ZfXB5lzgOLPrhGQcsZCsMjuQNdKJspVX0k4nKuSUWSJxZT9ljh7xmXypPtGcExmEuxemuPLsQ7F12PNLIiQxoEKOhqWPuhu+WDn/wFjU/R0K9QnnXIxn5kilJEKS4JuSNROrydEoyVEhne+xyuKJyC63zvySCEmCL0rWDG9848iesUZyVMhNd5kISkRkB4mQJPiiUs7tGWvEo8jqTqvE1JzzkIjINhIhSUjoQoYap6d/wL60uwrY4myWsJ1ESBISeqBj8HDxr53l4OuJiHRD2LY96j4ghLgNbDBexvMM49VfSPo8LMatz936e8y27YN+GoiFkAAIIV6wbXtsMsyMW38h6fOwGLc+q+hvMrRJSEgITSIkCQkJoYmTkDw96g4EZNz6C0mfh8W49Tl0f2MzR5KQkDC+xMkiSUhIGFNGLiRCiPcLIS4KIRaFEJ8YdX+6IYRYEkJ8XwjxohDiBXfbASHE14QQl9yf+0fcx98XQtwSQrzUsq1jH4XDb7nn/XtCiEdi0t+nhBA33PP8ohDigy1/+0dufy8KId437P66fZgXQvylEOIVIcTLQohfcLfH+Tx367O6c23b9shegAQuAw/gVPM+Dzw4yj716OsSMNO27Z8Bn3DffwL4jRH38UeAR4CX+vUR+CDwHwABPAY8H5P+PgX8ww77PuheHzpw3L1u5Aj6fBh4xH2fA37g9i3O57lbn5Wd61FbJI8Ci7ZtX7FtuwF8DnhixH0KwhPAZ9z3nwE+NLqugG3bfwW80ba5Wx+fAD5rOzwH5IUQh4fSUZcu/e3GE8DnbNs2bNt+DVjEuX6Gim3bN23b/q77vgK8Chwh3ue5W5+7Efhcj1pIjgCtGWSu0/sfHCU28FUhxHeEEE+624q2bd90368Aw0nsGoxufYzzuf+4Owz4/ZbhYuz6K4RYAN4GPM+YnOe2PoOicz1qIRkn3mXb9iPAB4CfE0L8SOsfbccmjPUS2Dj0Efg0cAJ4GLgJ/OZIe9MFIUQW+ALwi7Ztb6ueHtfz3KHPys71qIXkBmyrTHTU3RY7bNu+4f68BXwRx9Rb9cxU9+et0fWwK936GMtzb9v2qm3blm3bd4Hf5Z5JHZv+CiEmcG7IP7Rt+0/czbE+z536rPJcj1pIvg2cEkIcF0KkgA8DXx5xn3YghJgSQuS898DfwCmX/WXgo+5uHwW+NJoe9qRbH78MfMRdVXgMWG8xzUdG2/zBj+OcZ3D6+2EhhC6EOA6cAr41gv4J4PeAV23b/lTLn2J7nrv1Wem5HvYMcocZ4g/izCJfBj456v506eMDOLPY54GXvX4CBeAZ4BLwF8CBEffzj3FM1C2cce3HuvURZxXhd9zz/n3gXEz6+2/c/nzPvaAPt+z/Sbe/F4EPjOgcvwtn2PI94EX39cGYn+dufVZ2rhPP1oSEhNCMemiTkJCwC0iEJCEhITSJkCQkJIQmEZKEhITQJEKSkJAQmkRIEhISQpMISUJCQmgSIUlISAjN/w/uYkIXVHIawwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -243,7 +243,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -255,7 +255,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARIAAAD8CAYAAAC7DitlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAA3WUlEQVR4nO29f3Ak53nf+Xn59k4DAwx3sIMFdrG7JJbcDSlSytIULSqR7ChRYknMVShf3amc5GI5UY65Ossl5ZyS6ahi7/kqFevOsR0ljhMmkSMn/lGyE52V2LlI4Vm2lAppkS6uxJ/mkgT3B3aBxRCzHuwAPdvNN39092xjMD/6x9sz3Zj+VKEw09Pz9js93d953ud93ucRSikKCgoKknDbuDtQUFCQfwohKSgoSEwhJAUFBYkphKSgoCAxhZAUFBQkphCSgoKCxKQmJEKIDwshXhFCnBdCPJ7WcQoKCsaPSCOORAghgT8C/gJwCfgW8JeVUi9qP1hBQcHYScsieQ9wXin1ulKqDfw68GhKxyooKBgzRkrtHgMuBp5fAh7ut/OB+YOqtHwkpa70p00Jx9ZzCm4z3tbSTt/2eRtBusdQ3IZO+9Ttc35o26VU2lWORPdXJ0q23gZ7oJ47t6GUOhxm37SEZChCiMeAxwBKdyzyzmeeGHkfLnCCen1eS1uValNLO91I6WBiUaKdSvs+DhILvTdSmW0k6V/wulipn0yl3ZuNCuzolVTz+Fta2+vFTrX2Zth90xraXAZOBJ4f97Z1UEo9oZR6SCn1kHH4YErdyD8SO3URKXAxp6xxdyG3pCUk3wJOCyFOCiFKwA8AX0npWGNHGjaOLcfdjUQ46O9/i2namFrbNHAwcLS26bd7YuYi5dmW9rYngVSERCllA58E/jPwEvAlpdQLaRwrCxiG/gsb/GFN+taIg8ROQUgAb1BmahGUoIDoFJNgWwvmGrXahjZBkYbNgWpzjE6E0ZDax1NK/Q7wO2m1n5QmFdqO6VkT8U+DNGykJyS+VSI1CotM4dd31FiUMHBoY1Ii+vChn2gYOIkEsFe7Bg5zNCib21TMJo0bVaydeCIoDZvy7DYALcNm59Kh2H3NOhMZ2dqizJqziGNLzKk25pSFNKI7BaVhY07ttRgcWyYe6kjpUGY0ZnYaw5pubCQOMpJlEmYYE9cyGfY+E4sKTRZm1iNfG+XZlve3Hdi2zezytVh97ea2+Rta2tHJPje49mJhsuos7brRpeF4VsQtUXBsOfCXqJ+IBIlrofgiMgprJM1hTTf+cRyMobM5UQQiqmUSpW0TixMHL4aa0Rk2c1eaanPw1FWun48X6nDb/A3vWs3eTNjECImN5DXrVOj9peFQnm1h7dyaEvWHQGFEJEi3aA2jQjpTyb3QPeU7DBuJzXTnea/PGsfKCCsmcds+VTsPuD9EF+u3JiTNKYtShGtBGk4sMblt/galDM8q7XshsZGsOCdjDzWCgmHt7N0WlWGiImX+fSJRaFLpiElSB+owMdHhoDWxOFG7yOr1o7uGLlGQhsPs8jW2VkLFekF1J9MiAvtcSGwkF7lD29RsEgHpRa+hzyitkVH4RsKQxgxMt6DonjKOKyI+pak2U8ffYufqIfaM8gzAUEzNbyY6xijZ10KyziJta7SmexJGaY2kEcmaJYLWiU4RsZE0nKqWtsqz23CkS0ym8iUgPhM5a5M1fMtklLM0+1lEfNIKXtNJeXabqSNvuT/pORUR2OcWSZ5wbMkoRhqONw1bkB3Ks9uYy1d3OfbzRiEkE4QvIqOa7i0IR0lalOU2bbPExvXauLsTi2JoM0HshyjZ/UZJWpRxHbcl2swfrI+5R/HY10KywBols1g5W5BNgiLS2UabxYPrY+pRfPa1kBg4nOQNrWtfCgp04EYv955Clji5E5N9LSQ+p+T5QBh89pCGQ82sjySGpEQ7MzMZeZhV6abBnJZ2hi0RkDi5GuZMhJCAKybL8o1MDXWk4VAy21RlozP1m/YUsIlFlcZI0hP0wxeQEm2maeXK+VtlM3G8zyBrJEiJNtWDjUTHGhUTIyTgXsBLrDJtxr9ZdVk102aLimyyyNoe8SjTokwLM8aS+15Ib4WLidVxuFZojkxMfOHoFpDgr7Kdk9kkA4cqm5Rk/O8mSvpJAydRvhvDcCjPbqeWM6dznFRbzyAmFouss2YusG2Vh+7fcz2M4SQKu6+YTao0hh8bN1+ruwQ/+lclsTG8Sd9e+AKWZnCaL1Zh85DYyMwPdwwcKjRpSmg70XKV9HKwDtyfNtWZBo0bVewI11zl4BbgXgNltmnPlCK3EYWJExK4JSYtc5oGczhO9JMbV0yqZiOSL8QXgbBC4otH8L2DKGGlFlti0o6VyGi/iklZtmLl340iJpWDWx3xiNtGHCZSSMAVExOLbW8gEYcoYlI1G0jiJSvyLROrR1Kg7uFP1FgRB8O7uEvaxSRJ3EqexKQhjVA/RkmSePtCEAxYMwyH6kwj9DHSFJOJFRKATao9b84oDBKTabO1a4l8khvLFxNwc2L4j5O0GfzsusVERymKNBbd6cb3mSAZaN2WZXIneok2huFQm7k1mxP1+y/RpjZTx0FqjaKdKGdrNw7hfkmG0cuPUjLbzHmzIyZtLVGl0hMj32mqO1I1S1PDQbLuhPWdyPNs9N1H13dVm6l3vvu4bUrP4a0zVmVihWSTqrbl4LBbTEpmm0XWUgtJ19Fuv+FcVsUkLyzKtT3TwxXZ1HYt6LymdMaqTPTQRje+mCyyNuaeDGbY6t+0fCaTQpVNGtINXAtOuWeREm2WDl7p+drrEdqZWIskLaR0Mp/rI6lfqGAwvhN2FKVWs0LuhCTrv5KOI2kwl3kxGUYxxEnGpJVazZWQ+CKSFzGJO62cJlGSGhViUhCW3AhJt3jkQUyaVDInJlHPm19wMwruLFX2aq8UpEcuhKTfxZ8XMcn7MCcqTsyQ/oL8knkhGSYWcRZ7tShrWw4+DMfJzk1lURpJX2wkbUpsa7LGiuFV9sm0kEQRiCj7OkgtgWhhaTjVXFslbhBctOGNL/DblBMJSl5FxKRNlU0tK7jLtKiy6UbQZpRs/FR2EXfIEmZ9hl9AfNTUnXlqcmOseUCS4ItJVEH0v8smlU6Eb1j/Sdoi0qRCyylTkxvajtW9ILNCs7Ntk2pki9BPKeHjR8/ayJFZ1WHInJAk9Xv0ExMLEwfJqrOUqP0kjFNMdJSgkF4oeNzvyBeh4JKBfqIyKhEB93sBqMlbIe5Rjx9mQeaclzpikyrQe0W3fz78WJR++CH5FiYtpsc+fM6UkOhyngbFJAsCEqTuzLMkV0d+3Lg5TdIgaNX0Wtw3ShEJ4gvKsJwhvVZcR0mXMEejM+zzvxc//UPUdJv+KvYW5c6PxTgCDrNxZaF/BsZ1+JlsUIucfCZtWpRHVlUv67SY3pW3ZFwiEqTtuEsteyGlg4PctXiyhBW5375oWN6nn6aV6LP3up5GKSgZERKRSqtNKpkTEXD75SBHVjA865X1HE/00xTXJhWAoSIyDH9KX0rX15NUAHyLQif+dSVxRhbHlBEhmSwcR9KS7hectpi4dX6zJ6ZBRhEPlFRAunEciSONTM8q+VbeKMSkEJIxMUoxKdBPWbYyPR0L/jBxNGKSKI5ECLEihPiOEOI5IcQz3rZDQoivCSFe9f5nZ44qY6Qdy6LbGinqBt/CwuwMl7LMqCwmHQFpf1Yp9YBS6iHv+ePAk0qp08CT3vOCgn1FliKWs0Aaka2PAl/0Hn8R+GgKxyjYZ6Sd/CdpUauCwSQVEgV8VQjxrBDiMW/bolLKT7l0FRh9GKmHxMnsBSSlQ0U2c+EfcZC0mE5tnG3STn06fJ6NzF4L+4Gkttn7lVKXhRALwNeEEC8HX1RKKSGE6vVGT3geAyjdkY7W+M6wpqyMdG3NMMqyhYwRfBSVYIEtCF8bx8f3AbStEtcvLXKg2qRaa2hLEeBH+I4qpmaeDTZlVUtIgD/9mwe6KxCkQSIhUUpd9v6vCyG+DLwHWBNCHFVKXRFCHAV6pqpWSj0BPAEw89C9PcVGB76YNLyw5HEzaiskmG3c6RHeHhSXFtO7qg9ev7Rb4G82KjQAc8pidibeZwiW5RhHUF7cCnlBpLx1Y+ah/k4wViWt2JLYQiKEmAFuU0o1vcffB/wU8BXg48BPe/9/S0dHk+AWfrY7IdDjYtxDmV4lDCygjUn9Ro2tRgV2Bt9gNxsVblLBqrr7ScMOVejar/kbrAQ4DgzcAt79IleH4YtIiTYOBm1MjBxFKZdxrWHdM05JLJJF4MtCCL+dX1VK/X9CiG8BXxJCfAJ4E/hY8m4mp0ITQzpjWfkLrohkMSzepM02ZbauRhPZmw33Qrxp2NRtg1qtd02XoHBm5ZdbYlOWrVhBat0JnS1KsULkx4lvnegUk9hCopR6HTjTY3sd+GCSTqXFNC0W5VosMVmSq3t+zZtUQtXG8UUki2UJWpS5dPlE/AZsg5tb09SZ3yUmwQqDWSNO1cOKvBV2HsTxymNl8XMOQreYZDqxURr4YhKWRbnGsnyDEpYXjnXrr8omy/KNgeUYsywi4F5QR44lXI3siUnjepUy28zR6FSfyyplWkPLaJak5Q5HvQJX/b7DJpVcBuqZWFTZ1DLcnsiImmla1ORGT5+JPwZeiFDkaoE1kHCROzrbHEdSlq3MT+9KXTe8bbCzMUfz4Jb2RWhpUaGJLeUex2tJWpHLrDaYo8pmpsWzF77gm1hefuF4vqOJFBJwLyJHGrtMO4nNEvF/nU9wAXDN3bqsUfUS2WSZxEObnDNHgw05j+NIN7Yn48KfJv5njyMmEyskcGtquEJTa0yAxGaBtdgzA6OkTIvjxy5y6bVT4+7KWNEhInn0lXQTV0wmzkfSTZXN3AQWFaSDxNYyo5aHRXxhiCOoEy8kBQVuukc9lkTWCqLFIc5nKISkoEAjLS/ve15pUY5VOqUQkoICzbQo53KY44tInPQIhZAUFKSAWyYiP5aJ5cXsxs2xUghJgVauvXJHp27LpJP1pNs+fra3JImaCiFJgTYm36n/SVadJa0Xk+PFV56/fre2drWmT7QF7MDVc3fl0rTXiYmVi5gUXSkjCyHRTBuTV+r3ANBsVNhgHouSZzbGu2Hd3KslLt44wfn6KRzb4I3ry4nrCTepsOYscvW374KrCUuCeCLic+nc6UyLie3ls9Wdn0NiM89GLkTERmr7jiY6IE0325Q5X98d2NWoVzu5UJZqq6FKOwZxkKw5izQbu79wxza4cmOJhRk33YvEDl0KdIMaDgbXfvtWSD8NwBAwHyE1jO2Jz07vly+dO83xM69m7qbSWXUwGIM0l4NI5iA6c84WQqKRN64vD3x9te6WDV2qrYa6ufqJiI+1Y3Jxxw1vr1SbA+sKN6jSuFEFYOupw71v/g2AEGLSZX0M4tILpzl8/4VO8etxo1tEymznZm1REN1Z8Ash0USd8Pk81q4v4ByUA9fiDBORbpqNClTd1crB4KomFd68vAxXp9wMusPYwBWKIz3ExBZgQ6RAYBuuvXAH28vTTM9sj01Q4qab7Ie/ojuPIpJGrEshJBqoM++Kgx3udDq2wcb1Gq1Z98usykZnuLPGYie/bFgR8Wk2KjizEmk4vHX+mLtxB7gUqRl3mGMLOO6JyY43hIm7ksCGrfOH2ZoC7mEsYqLTjK/QzKWAQHoBc4WQJCSqiPg4ttERivZUCWm4VkRrK9mX3Hn/+UTNwBZwScA88QWkmx13eljeY+fOn+Dj+qLyKyJJHfT9KGZtEtBgLpaIdGPtmLS2yolFRDs76BORQJtXXyimh8eBo9E/1E0hJDFpUuFi/URiEZlIbNcJm/Xi5r3IqyXlWiPpne9CSGKwTZmV+slxd6OgIBSjWEhY/JxGpFesSEFEpuDOe17Ora8hL/hT3aNY81MISQSaVCbLEqkCswq2Eka9BplVHL/7fCZLc+wndMeJDKMQkghMlIgch4P3uoEn1y8t6hGTWcWRu9/IXKTrfmPUIgKFjyQSS7WEZRsGYE5ZlGc1/konrII6e+rarcdHNrjtyA3XOondoCsi43JWTlI6zRbTIz9mYZFEoMYGqyxpb9ecspie2QZAGk7kQLRuyrMtSrUG9dkab2+V4eWI1sS9qhPX4vepUm3izLawvJKeN6/eHn5qeAqO331+rJZIMClzWlOgWSBpOoC47N8zmhKnaue1OluDIgJeNvNqM7aYVKpNpHRvmtpiHWe+QfuIG4S09fLh4WHy9yoOHu9d00caTsdqcpYtbFuys3JocHuG61jNgk8kqZj4VQeyzLgKdRVCEpFSyBW2YegWER8pHaq1BgBtqxQ6UK082+qISLAt/xilBy7j2JLr3zzSe9HdKfqKyJ4+Gg7ScDBOXRsoKHfd/0LmZmd8QYkqJlkvNTEuawQy4iPJY7nDpEjD7iki3ZTMdijfSXm2RckcLHJSOpTMNoc/eIFDH77s/oz4190yHFwOs6qvq03DwZxqc/Deq64fxceA02fOZU5EfAwvpVMUimjc/mRCSEDQYG7cnQiFxOae2itII77zTho2lYNbofcvmW3MKavnMc0pi2qtMVRE9vRBOhz+0AVm338NptBim1aqTZjfceNE7n8587/gRoTVu8Gi2y3KnQrQWWHcfcnM0MZBUmeeUg5S1JWwOHlwhYs3TnScj2GJKiI+vvWyfWMa25Y4ttF3aBS13ekPXqBt6VnMdXC+Qe1YPbOWSC9MrIHh492fxUGy7QV5lWjvsWzCCqiN1CK2ttefcS45yIyQ+LQxaRKv2tcomabF0ZlVrrAUWkx03fjgCkrStgpuYWJ1IkGDwjDsRm9Tgq4VtdMBx3Kv9/vHcVNvWqGO048siAhkUEggP2JSoQkhxUSHiAQpREQ//s2c1ErwrRWJg+P5YoJO0HZAeLYpd/aDvdbPMByMsYsIZFRI4JaY+F/qdAamD3tRoUl9qj1QSHSLSEF66PTr+Fn/pfd/2H7+4zxmXsuskIArJr4L0UZm3kLpRSEiBVGqB/ii4r9nkKjYyLFEsfYi00ISJMvDnZK0MKd6OytLU/riToIsssYai6m0XTB+ghaKg6SE1dNaykqUbjZ6EZIsikmdebat8q6Q8iCO7f2ySH0m8xKrSOxCTCaE4CwRuNe/zpo0OhgaRyKE+IIQYl0I8Xxg2yEhxNeEEK96/+e87UII8XkhxHkhxLeFEA/q7nAbc9dJHScN5mhY1aH7+WKiA19EwJ2GPsGFXIRuF+ijSYUGc5mxRiBcQNq/Bj7cte1x4Eml1GngSe85wEeA097fY8Av6ulmNoky9k0ap+FbIL2iMSs0M2OlVc1G7hyFBckZKiRKqd8H3ura/CjwRe/xF4GPBrb/snJ5CqgKIY5q6muHFmXaY57y2qYcyhrRgVsGsk5pwA1aZTORmESNjO2FNJxdNXUK0iNraRHihsgvKqWueI+vQmegfgy4GNjvkrdtD0KIx4QQzwghnnGuRTfNkxbRdmeERitGfr2aKEjc0g2DRMTHF5Oyl6UzDGVaVNl069Wazb6+nlBtyVaq1sgDPMc/4MdTaz9PIhhnrVAUon6PiQdZSiklhIic8UYp9QTwBID50Dsjv99f7xDnVzgYCejP24e5UX0cjFiOrqiOV19EosTQBP0lkrm+/azQRGLvOn/TtGjKCo7cfVm0KdG0hn/en+Cn+F//0b/d+8I74L7vezbkJ9jLi7/wbjf3yVfg8/8/vPjzXwXgRz71OZ7kz8duF3aLhz/xGpx+zTJxVzEPwsSKXJ/a7Us81oQQR5VSV7yhy7q3/TJwIrDfcW9bKsSZxeleah0UFJ9hwrLGAttWPIdvWDEJM5wZhi8q3WIyaBjUa7uDwbTZYptyX0H5O+bPcEj8W8726cuLD797cGcfgft+Yq/YvPixd3P2N3ZvO/tp9/+PffrH+McPw59+6slOofaw+ALSzwrxBSXr6BATE6uTHkNixwrKE0oNNwaEEMvAf1RKvdN7/v8AdaXUTwshHgcOKaU+I4T4i8AngUeAh4HPK6XeM/SDPPROdfSZ34zceZ9aiBKQ/s0U9oT7ZmOZ7V0m5EXu0LLATRrOQDFZZC2RiARpeJZJlU1M2rHbvbU+BFadpY4o/k/mb3Ja/AhJw+4+0GPb10O872FgGvjAQ3Dft4ZbPsNExCcvlgnEK44etEh7iccfiA88q5R6KExbQ4VECPFruN/xPLAG/CTw/wJfAu4A3gQ+ppR6SwghgH+CO8vTAv66UuqZYZ1IW0iSJnwJnvDXLH3Z0fqJSXCKVxfdi9F0tAeuj+X7xAe1tauDsz8P932qt6D4w5cotFMqc6mbQWJSptXzB2SQ9aFVSEZBUiGB/mKiM2tU3appaSdI92xJGiKSJu/iOyyL/33c3ejLnHqMf8nfTOxIzaOY+D62uEQRkuxEtKTANuVMBe30wnEkUjpenMh6rkQkD5Q852Hydtq5EBPfwhh1tv6MZEhLTneGtSzkaAiD72eYp16ISMbRma83TcZR8mPfCEmw0npeRMSnQlObY7WgYBzsGyEB1x+SNxEpyBd5ClobJftKSGD8SXALCiaRbHsiI1KmhcTxIiUKq6SgYFTsG4vEDfl2zc5emb21HMNMZ4Vtw6mOfRFiQTgcpNZKi/uFfWGRBEXEp+zFWbaY1jYFXKJN1WzgIEOtPYnCBm6MyhLpFSovSIaD5KVXHoQdeGnjQQ4uX2XJjP592UjWrVsJqapmQ1tJ03HlNs6tkLiResOn48psa80k5UdG1sw6LaZjr7nx8QPSfLG7yB2Au/5hgXDlM8fFPPVMB6PpxEHy/Avffatw+g5cf/kI1zkCwJ1nwtU3XrWW9iS6qts15Ez+Ej4HycjQRgVS3g4PYQ4rIj5pJf0psx07j0fJbA98r4XJRe6gznzc7qXKu/gOf0p8dNzdGMhfUu/gn/O/JW6nTWm3iPTgzXP3YmH2dfbbyJ4i4rN+YyGxX2+a1tiqG2bCIpG8vedm94ck3YumSoGVilGo0NQ6zAm22zQrOI4MnVIxivi0KCOZ6/zajTve5EN8lVOc54L4tbH2YxifbcB384XE7bSY5tXX/uRAEfF5/dz9YLjlSn38H8WGUx16fazfWGBhZj2XlkkmhKQXQR9Hr+1x20xLTJC4uTyGCEocC6bpJVMEmPfWFI16LPxn+Tp/m5/jDfEW/2WkR47GZ2ag/E144OB/S9xWkwqvv/knYEuEf5PtWicYQHWH2Wo0a3j9xgK1mXokn4mf9mKctZYzKyQ+SYSjX3ttSrGWXQ8jKCjdqQaGpQ0Iy4Y31JlnY2Ri8r18g59519/j7PPD9x0nZ/8NPPC/JBcQ8ETk8t3QOBCvgSkVWUR8GlYVTEKJSRZEBHIgJGngDo1KqS3oK9NCmjZtxx3z6ixF4bNJdSRCch8v8XOLf5ez68P3HSdnX4IH7tUjIuAORdiY0tZeFBxb0qCKZZYwaQ8VlHGLiNuHAu241dHae1IW5o3fnfoeXrLom/UsC5x9HV44eRcP8Cva2mxS4a2VJW3txcGxJVt2hW3D6WudRE0Rmib5vtILtPPsX/oePvcf3Mc/O96uDOTsL8E/+aFP8Kf5K7Q01jlqMc3rr9wPO9qaTIRvnUiz9/RwFqwRKISkoItL/wHNXin9nP1R+MAP/afIeVqH0abEqy+cCTVDM0ocW1KnRs2s7xITXUFsOshIHElBQTjOvg/e/TPf0C4iDpKXzj2YORHxcWzJ+o2FTpxKVgqi+RRCklOyYtKOkp88BA9887+l4iR//oXv1t5mGly5sZQ5EYFCSHJJHsLndfPZg/BddX2zMqljC2yNNZ+zTiEkOaNMa+JEBOC7GzkSEYAd2Ll6aGLEpBCSHFGmFaqGT0EGsIEtV0y2GpV9LygTKSRtSmxS9UpV6P+CW0xjac44XqFJdQxJfSeFw/dfSN6IHfjz2QKuTrGzMdf7PRFZmMlmZODETf86SNacxc56GMdw/1dlI3Hb/rqgNJyBbk3WjE4p7AOWWKV8pkWLMtfO3RG9gWFfTUOwZR9m9vi1WP1bmFmPVBx+1EyMkFx0bpUkDi6q8x/704lRBWUUaR0rNMeWsGaSqNJwLb8zbs3klfpJbl66ffgbw+r7FmytHGZ2OZyYTM9sdxJdxa3JOyomYmhz0TmBY8vOXy/81xpONXS7oxCRMq1OMfCC9JE4lNmmzDb31F7htiM3+u/cPYwJgw1b5w+zdenwwN1KU21OcAETCzMDi/KGse8tklX6J5PphR+SPMgycZBaw7L7UThXXb6qnhzLcSUO71r8DnhZEc+98N7kofO+8GzB1tV5Zo/s/X5LU21OyfMJDzRa9qVF4udZW2Nhz3L+UO+3JXWr5uUu2Z27rUllJCJiYo1FRI7/mZEfcihpOMTj8M77v6W3wYZga6PaeVqaaudSRGAfWiQNqm4+Bw1sW66RqyuXSFjGaYm8++vf4Nn3fg9nnx7L4XdxCvhN9av7u7TIxgGsWZNqrcEJLmR+CNOPfWWROEhtIjIusjCcefdT3+Ds/zzWLvAx4Gn1OVY4Od6OdHHb8QE+k5jUahuc5I3cigjsMyFJi4oczdqGCs2xi4jPu7/0Dc5+bjzH/hEJv6E+wzf43vF0oA8Sh7sX8zfsGAWFkAyhajao0ujkSk0LN+AsW7Mz3/OZr3L2t0d/3NpX4ct8/+gPXBCbQkgGUDHdaFKJzTQtFlNa45JFEQE3wO7vPfLjIz3m2RPwt/7cz4/0mAXJKYRkAN2lP0tYqYhJk0pRstPng/A0D4+7FwUR2VdCInFilVDshWuN7LUS0hKTNRZTS0adFz4zA+/6pT8Ydzf64k//z957zZ3v9P8KhguJEOILQoh1IcTzgW1nhRCXhRDPeX+PBF77cSHEeSHEK0KID6XV8V74Q5AFM/mNPqjaXwkrFZ/JKkteUbDsXJ2jspT+qXqT5a03WWNRa4lVXbhxSa7YT89sc/jMBQ6fuQDzO4WYEM4i+dfAh3ts/zml1APe3+8ACCHuA34AuN97zz8VQqQeTSSxdw1BKjSpmfXY7U2bw6dgp1MKXV9lqSMoWeDLfBShPpNa+7fjikgQN+hvOjOBaA6yU+S9m8PH1qF6M56YGIBX8aJfqc+8MFRIlFK/D7wVsr1HgV9XSllKqTeA88B7EvRvKP1WxFbZpGbWmTbTW+zmFhRNZ0XuGgtj95s0qbBSP8nfr3+W+9X/wP+hqTuLuFO8PyLhn6nneu7TYE57KoY4tCmxQW2gsB++84orJlUVrlEDmAXmd5hdvsbWjQoN9KQZGBdJfvY+KYT4QeAZ4EeVUpvAMeCpwD6XvG2pMOwmrrJJlU3q5nykQLWw1f38FbmbVLVbEA4GG9SYpx66dombX8XQYik1mONi/daK6b9a/xW4DBvVeW7/1E0Azv5C9HbfBVxRn+Ad/ESoPpi0hxaVT4s2pc45HcbhO68AcO3yAtgSNvpU6KsqMGxm5xu7Nq/fWIAZUg8zSIu4V/8vAv8XoLz//xD4G1EaEEI8BjwGcOCOI5EOHtUKqLGBNB3qVm/zNMiCuRYpuW5WxKRJhXVrEWunRPvgrV/yEu3IwlJnntV67wJR840N+D/dx+2/eZCz3xW+3XcA19Vf5qdCiMi48UUkanj+4WPrOI7kLaMGV7sq9c3f3CMgQdZvLODMuEOctEIN0iLWla+U6nxKIcS/AP6j9/QycCKw63FvW682ngCeACg/9I6QNmF0EfGpsok0bdatxYH7xcnQPU0LicMag9uOgy8mJm7xcT+uxWebMhvM07ZKWDuugGxcvyWYhuHQnNnrvDxB74xg6yzuev8gpk/WuaDu5BfE1tB9DwBX1WP8fT4bqm2fBlVqxPd3xSGuiPhI6XDoSJ238MRk/ia3TbUpzw4fZtdveOd+Jl9iEktIhBBHlVJXvKffD/gzOl8BflUI8bPAEnAa0Dafl9QfUaEJJkPFJA4lLJZYZRX9pR4dDFreV2VR6iS7aWOyai11BKQXti1pXp/ds/21qVNIY/eQwbEl1k4Jxw53WTi2wWnrVf6reh+/IV7vu19ZfZIrLPGP+Kuh2g2ia8GegwwlSg5Si3UppcPB+QatqTLmVPSymg2rimPKzneddYaeLSHErwEfAOaFEJeAnwQ+IIR4AHdoswL8LQCl1AtCiC8BL+JmXvhhpVSmViINEpNlcyVR2xI7NTHxcTBYZYlF1lm5sRw7qXAv8QkrIEFaW2Xex3/lAfUcX//yRzj7P956bVud5UXuSxxgtsYCi8TPVVqnho3EwXBzzfTJfevPzugaokrDiSUi4Ip6kwpr5mIuLBOhVOhRRWqUH3qH+hPP/NLQ/XTOkDSY2+MzudvUsyDLv9nTpJeVkZQ4QhLEnLKYntlmffFO/sHap/k5/ramnrnf/SAx6Z4qdrOb9s6h62ada+x5v04RcRxJe4ClGIWjM6vMjSHx9x+IDzyrlHoozL7ZCFYYA1U2cUw37YA0HJblG9radi/6tVR8JmmRVEQArB0Ta8ektnpJ+0yLg+HWvw0MTYLiEeVctyh7KRVd35ZuEdFJdaaRycp63WTvzI2QGhs4phy5M68gPr54+OHqcX0oTSo0qVBlM/QU7zho3KhSmmlnflo4m2dvhOS1ap1hOPu+6FI3FiYNqkgcbeku8x4IlhX21aK9LCFxMEMGksVhemYbw8iUH3skWJgjyZmbFCkdSlPtcXdjZBRCkhISmxr11MXEnKCLNQ9I7E4hq4psToyYFEKSIqMQk+5YkILxUabVCen3/yZFTHIlJFl1iA3CF5O0FvdJ6SS2SnTM2OSZMq3EMyP+DFD3bJXEoSob+17wcyUkQObydYTBD1RLS0xKZrsY4sTEFwBwgxXj1NYNttGPmlmPLSZuUfpsZ9DL9B05KB+Fg/R+AfJTWHuJVS4So0B1CEpmG8eWkWZyCktkrwBInI510qbUiYjdvY97zRk4lEhXwKdntjFpd2pT19jIZNmKzFokYZLaOMix5+yIygkupCZ+w2ZyHNvY9Tep+A7RYVZEiTZltnclznLf69YGjioiUa2S0lR7j4VUZ54N5r0eycwkRMrU1RQ3I5YvJnmxUJZYZZ3FVMzV6ZntPeHzoxSN8mxrpFUJ42D08GUMws9P02I6dK6aftTMOg2jOjR8vjTV7ltPyUFSZz7Qv1ZH1NJ07A8iExaJQk99V99CyYMPJc3ZHN9fMmrLozzbomRm21cjvcFKHJKKiE9VNgbO5EjDiVSUrUXZLVVLlRblsfhTMiEkusmDoEjs1NZQuP6S0X72vIjIODOuBanKBtMzvYUpyXlsUukIyigD97J7p2nAdchmf6iTdyrVZuaHM0BmRMSnTAtmYPvGdGfb7Eyzk8QqCU0qnQWJJdqpD3n2pUVSMDryIiJhnKujxp8h8oc5ukTEx0HSokx7BEm097VFEjZpckE88iIiMLhO0bipykYnV2te2ddCUpAOeRIQiJeHd9T4w5C8UghJwb7Fj/koSJ/CR1KwL/FnaApc0g5cK4RkzDhOfs3ZLJO1GZpx4meDS1NM9u3QJssXkZ+Vq02J9k4JaTjuX478DllFYmdyLcogJDYOhnY/id+W7aWlBNdflMb52ZdCkuVQ+V4FqGxbYnhioiOoa1xh0kkJxlOUptqRhXUUAWfd11XcoMfudnpdr3FEJfiebgvEz02bRv7XfSUkWRYQgFWWaFyv9nzN9lbuOt7q3TiiYmIhcShhsVhbw0ZSr88Pf2NIyrMtKmYTiYNFSWvkcKNe5WZg/cmBqTbS2PtdGobTNyJ01CLib4tyHoZdn3uFKsJq7hCL+FpMYyO1WyX7RkjyLCJB/DQA/v9hYhKcmQh+fr8msVlru2sx6sOP3Q9zyqI2U991jiVOx1xOSreIANzcKXGzRyDVbYaDtWPuCclPa4o3zDUVVkyiXp/+/mFXwof1gdSZ1150ax8JSTZFpM48Das6sKxmP9zymbKvdVKhOfRzl7AoYeFUJc1G9Bv/RO0i0NsUr9DUIibdIjKIt23J27akGci7sry4krgPvYhyTQX3DYpK0utymJhYMaJWLUqssqS1HGjuhSSrlsg2ZS7eOJG4ZIQ/5PGFaOnglViftyY3cGYlra3wC7mWa4OLhukUk6i87Z3XO4+tpNJ+kmtK9/XoZx5xvAQIEE9AgthIrWKSy+nfYHLdLIpIG5M3rsevy9uPxYPriT7vgrnm5gvp4XsIIg27Y4kMQ2JTZTP20KK+Vhu+0wAurp1I9P5eZPGaArdflmdj6sBGaqsGmTuLxHemZfXLzjoL5hqYcOVG79rEtZl6rDVKftaxsE5Yx5E0NqodyyIuJxbDCV4YJvGasiixwXzimZxcCckki4g5pXdG4uiMvvGxjy9AFoOnRR3H9dckFRHduLEck3dt+Y7aJDM5uRvaTOIXDXjTrtn/7CWsoaHpra3pSA7WgnSxKFFnPlFmtdwJSUH2KWH1LevQtkq0d/KVsHsSsCjRoBo7jD5XQuK6V3M1GptYSlh7HLBtq5TJIU2Bi2+ZxBGTXAlJQb4I5qXNql+kYDdWJzFjNKuxEJKCVPFnc3TM0BSkn6SpI/wRrZJinKCRFedkZ62MOdWOFc26XylERB9pBQFWiJ8zthCShDgYrLHAtrU3YtQwHO1BaQW7yXK6iDQps02L6eE7RmgvSSKooUMbIcQJIcTvCiFeFEK8IIT4lLf9kBDia0KIV73/c952IYT4vBDivBDi20KIB2P3LsO0Makzz4q13FNEwF3Ba061B5bRHIZjG7R3TFpOObeO5qZTAc2COjXbYrba9H5F85k2ISk6VvAaOF4J0ujF03e3Mxwb+FGl1B8KISrAs0KIrwE/BDyplPppIcTjwOPAjwEfAU57fw8Dv+j9zz3bXsEhC5O6FT6026/3GsU62fHXxGxNQQPeWpmhde805dltalJ/Pom0uHJjia1vHnavtCMHYErBVPwb/8BUm0q1yaJc64znzU4g3ORMK0tsL1C+FHvK1qStzecyVEiUUleAK97jphDiJeAY8CjwAW+3LwJfxxWSR4FfVkop4CkhRFUIcdRrJzHdTiBdQVp+1rJBRBGPboaJyc5WGYLxFRti7z4vH2IHaN07zYmD+kLD02KlfpKbz9zuPrGBS8CsgCNmJDG5zXBYWHSXvZfZ7hnO7a6EdkZaXW7cJBETHVZIkEi2shBiGfgu4GlgMSAOV6Gz+ucYELzKL3nbtAgJ6BWTBnM4SBpWNWGvhtNLTHa2yq7VsQVhP8bOy4dYOWUMXZ07LlbqJ7nZqMD5vWLIFnBVwHEJA4Z8R46t7soAH2YtiH9jxBUTP8OarkVxoyCOmOgWEYggJEKIWeDfAZ9WSv2xELcuEqWUEkKoKAcWQjwGPAZw4I4jUd66C19UoorJNmU2qdJ2zM5MyyjwxWRr5bC7wQZ2ordzc+V2XrNPcffieX2dS0CDOa6du8N9ssFgUdwCVg7AMnvE5NCROotyjWlasXwAccQkmNfF8DLMgXuNpJ19XQdRxCTJzMwgQgmJEOIAroj8ilLq33ub1/whixDiKLDubb8MBNd2H/e27UIp9QTwBMD0Q++IJELdRBWTbcqsOYsjFZAg0nC4bf4Gb6/MxG/EhrcvzfAa4xeTJhWu/d4d0QRxBzh/AO51ODDV5r7ai4Ce5M1lWjjInj6TXsXbu4/nP/enWfMiJgywpNxZGSu1Wa4wszYC+FfAS0qpnw289BXg497jjwO/Fdj+g97szXuB67r8I4MIGz7fxhyriPiUEjgcO3hislI/mbytmLQxufrkXbGsKmzg5SneVfu2F0tpacsl2n3DzLPBPBvM0cDwUgT5f4Oo0GSOhpY+pU0/K86knXrt4zAWyfuAvwZ8RwjxnLft7wI/DXxJCPEJ4E3gY95rvwM8ApwHWsBf19nhQfipjnolPHIwWLGWR9WV0WHDzfO3c2VqKZXUAL3wBfv1J+8P7dfpiw1/+Hvv5z1/5veSdyyAb5XEHSJ144vJJtXEbaXJNK1dwWo6Z2YGEWbW5ptAD68ZAB/ssb8CfjhhvxIRHOqsstQ3zmM/sfX8YRoPb1NlM9XjtDF58+l7ycOPdB5q/qZBhSbblJE4IzsH+YxwGoJvmUDJ/SUxmQgxSZttylw6d1q/iMT3tY+cceWojco0rZGWLN13i/Z6LTaao8G0qWe6q2I2tbWlm0a9mlr06zZlLr1w2p3o18m9N3nPPXqHNQWjZ18JyaAVi3M0qJjJzLyq2aBGPbPOt5vnb6edUgzExvWaGxGkkdseuMGDdz6tt9GCsbBvhCTMsufpBEE4NbNO1ROQEm2qZiN2W2ly6c1l7VZJkwo75w9pbRPgvsUXc1ent6A3+0ZIwhJHAGpmfY/TKk6m9ZFw9YD2Jstsw5E487sFk8JECYnhuWGj0EtEwL25smiVHH74QioFmu469hrce1Nbm0c+9Lr2MO2C8bEvZm3iVG0PQ9VsDJw+q9LAMSVNK7wXXxoOJ+RFMMF5WHLROsH15/RMWxx66HJq078Sm9N3vsirO2dgJXl7wXU0BflnXwhJFEwsqmYj1CK9MNZLjTq2KQdOL0vDYVGuUeqajpM4LJsr8PAKAOdee7jnqt++eN/egeU/HtkCvtP3nOPVrTMkqad0+EMXEhdk2k8YOFrD8Ec57euTeyFJwxqRhkNFNkMH8wxyGErDoSY39ohIL87c/TTneBhsMTxWY15x+u5vh+qfdmaJLyRT+a1NZCO1xpAEh9r+/yQrj8chID659pHEFRGJ01mFu+c1T0SqEaZ4a9T3TC1Lw2HabFGTG5HM+DN3P82Ze56CIzdhvs9axiM3xyciuFYJy/HeO/XAW9yxK8tEPtApIiZtTHpXTvRfi8q4Z79yb5HEwcSiLFs07b0XRlQR8alRR5oODatKxWxSSrjG4cydz9JimpWql9vDH/Ic3+H0sVdit6uL0/ec49Wp++DlCLNEVZg/WE+tT2lge4tBk+ZHNbosj2EExcQvqTmo7XHnrs2tkCQd0pRoUzLbtK1bpmS/GZqwVGkgTX3rG8psc1/tRRq1KvUjbna2hZn1Ie8aHafvfJHXpk7x9nMh0yEcuckSo1lYqAO3+Gj8VIag5yYPvr+7L1kQEcj50CYJbm6GW2P1BXNNiwCksUiqQpMTMxc5OrOaOf/C3YvnOfDQHw/fsQp33flHqfdHFzYykYgYOH2HL3GQnUQZt9rT2X5ScmmR6HawLphrmZ+OzHJynVptg6vc3n+HWXjHw3+Ym9W4Ovwhad3gMiMWSDcTa5GA90tvXsy8iGSdCk1m33+t94sGnHnfU7kRkU2qWpyqacU2ZZWJFpKsjC/3A0dnVnsOcR784DdzU3dGZ9KiLFuQaTDRQgKT98uRJsu1N+CdOzAFTMGZDz019mnJsGQ981nWyaWPRCd+asYsIz3HXR7KJJw+9opbfARoMb3LOZxFUdEdZDapTLyQ5IU8iUkQ/yZ1yzy0tWSJ10l7gqrzpUnuhETHUKQ7LDkv5FVMwP3lt5n2Aq30ZYtPip9dXWdB7kkk8z4SpzPhJbWJSFan0MLgi0lesShlrvBUXpzBWSazQqJLOMC9+Uq0PdM6nwISRHoV5PMqKDayU5A9K+iens7rdxOXTA1tdM+g5NnyCEPehzq+/yQLMSY6h1qTJiKQGYtEaBWR/WR9DCPPQx17yGK0UaND0PL6XSQlI0JSkAR/qFNmOzNOzChkZfrVSFhQalJFBPapkExykFmJdi7FJCvEFZNJFhHYp0Iy6YTJxlbQH8Oz8MIy6SIChZAUFCSiEBGXQkgKCnoQJgK3GELeohCSgoIeDFsZnqWkQlmgEJKCgj6U+oTyF8OZvRRCUlDQBwOHaVp70hsW7KUQkoKCAQSngwsR6Y9Qqk/tlFF2QohrwA0S1W8bOfPkq79Q9HlU5K3P/fp7p1LqcJgGMiEkAEKIZ5RSD427H2HJW3+h6POoyFufdfS3GNoUFBQkphCSgoKCxGRJSJ4Ydwcikrf+QtHnUZG3Pifub2Z8JAUFBfklSxZJQUFBThm7kAghPiyEeEUIcV4I8fi4+9MPIcSKEOI7QojnhBDPeNsOCSG+JoR41fs/N+Y+fkEIsS6EeD6wrWcfhcvnvfP+bSHEgxnp71khxGXvPD8nhHgk8NqPe/19RQjxoVH31+vDCSHE7wohXhRCvCCE+JS3PcvnuV+f9Z1rpdTY/gAJvAbcBZSAc8B94+zTgL6uAPNd2/5v4HHv8ePA58bcx+8FHgSeH9ZH4BHgPwECeC/wdEb6exb4Oz32vc+7PkzgpHfdyDH0+SjwoPe4AvyR17csn+d+fdZ2rsdtkbwHOK+Uel0p1QZ+HXh0zH2KwqPAF73HXwQ+Or6ugFLq94G3ujb36+OjwC8rl6eAqhDi6Eg66tGnv/14FPh1pZSllHoDOI97/YwUpdQVpdQfeo+bwEu4JcGyfJ779bkfkc/1uIXkGHAx8PwSgz/gOFHAV4UQzwohHvO2LSqlrniPrwKL4+naQPr1Mcvn/pPeMOALgeFi5vorhFgGvgt4mpyc564+g6ZzPW4hyRPvV0o9CHwE+GEhxPcGX1SuTZjpKbA89BH4ReBu4AHgCvAPx9qbPgghZoF/B3xaKbWrenpWz3OPPms71+MWksvAicDz4962zKGUuuz9Xwe+jGvqrflmqvd/fXw97Eu/Pmby3Cul1pRSjlLqbeBfcMukzkx/hRAHcG/IX1FK/Xtvc6bPc68+6zzX4xaSbwGnhRAnhRAl4AeAr4y5T3sQQswIISr+Y+D7gOdx+/pxb7ePA781nh4OpF8fvwL8oDer8F7gesA0Hxtd/oPvxz3P4Pb3B4QQphDiJHAa+IMx9E8A/wp4SSn1s4GXMnue+/VZ67ketQe5h4f4EVwv8mvAZ8fdnz59vAvXi30OeMHvJ1ADngReBf4LcGjM/fw1XBP1Ju649hP9+og7i/AL3nn/DvBQRvr7b7z+fNu7oI8G9v+s199XgI+M6Ry/H3fY8m3gOe/vkYyf53591naui8jWgoKCxIx7aFNQULAPKISkoKAgMYWQFBQUJKYQkoKCgsQUQlJQUJCYQkgKCgoSUwhJQUFBYgohKSgoSMx/B8+I8s/W4ZSFAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -267,7 +267,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARIAAAD8CAYAAAC7DitlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAxS0lEQVR4nO2de5QkV33fP3dvb9dMzzTTuz07szu7i1aPtZCEIoHWgI0B+TjhoRxb+JyE4MQ2+JAoiYEDPrZBhNie45NzAgkGGxsTyzGYhw0mfooEx2DZGDjhJdkSQhJCK7SrXc3ujKa1ve6Z7uneLt38UVW9NTP9qMet7qru+zmnz/RUV9+6XV317d/93d/9/YRSCoPBYIjDnlF3wGAwZB8jJAaDITZGSAwGQ2yMkBgMhtgYITEYDLExQmIwGGKTmJAIIV4thHhUCHFSCHFnUscxGAyjRyQRRyKEkMB3gX8GnAW+CfyEUuph7QczGAwjJymL5EXASaXU95RSLeDTwO0JHctgMIyYXELtHgbO+P4/C7y418575+dU/tjBhLrSmzZ7sZXU05jQ00wv9vAsgmcTPYZiDzrtU6fP+hFae3mZS+xNpF27lQNb75kQ+bbW9rqh7n9gXSl1IMi+SQnJQIQQdwB3AOSfu8jz771r6H1YZZFqs6SlLZmztbSzq11pY9EkTyuR9j1sJE3yWtss0ECi/4LPkcy5XrUXE2n3mbMLsKFXpKwjz2htrxtbpfLpoPsmNbR5Cjjq+/+Iu62DUuoupdQJpdSJ3IG5hLqRfSTtxEXE4JCXzVF3IbMkJSTfBI4LIa4UQuSB1wN3J3QsgwZsNA3xEm4zKWsEYB9VIyYRSURIlFJt4C3AXwGPAJ9RSj2UxLHSgt3Wf9M4w5rkrREbSVvzTW/RIo/emzJJEfHYR5WirGkVlKlSbYROhOGQ2MdTSn0O+FxS7eugSI26VaDV1OMb8MREp79EDuHm0Y1uERmGgPgpUCdPE1s2qDNNy7bitTfbgIPPsHV2v6Yepo+JjmwtUGeJFY5aZ7Te/HZbxrZQpLQpUNfUo/7oHILoFJEc9tBFxH9siyZFakgZvw+F2Qazx57W0DPYM7+ppR2djLnBNRjLveiPySfw309V9lFplmO1HdVC8URkGNZIEsMaHYxKQHaSw6bEBapyH7Yd7zzlp1rMXXOeiyejhTrsmd9E5mxkLvmp37BMtEXix/v18x7zrHOt9ShFqxa7bc9CCWqlFKkNbUijc8pXlzWSFhHx8K6HRblKWa7HakvmbOauOR/6fXvmN8lPNVMpImAskoEssQLuEPmkfQ0Qz7Hqf283S0WHGZ1V0iYg3chhU5brVOz5yG3InM3ssafZOBUo1gtKW+Sn0j2bZIQkBNfIk7SRPN6+Rkt73YY+ReJbQIGPr3FIk8OObI1kQUD82Bpum/xUi6kjz7B1fj+7YvZyQE4xNX8h9nGGhRGSFDFMa0RnJGsOO5OzS1FoI6naJS1tdWZz/GIylS0B8TA+khTgWSbDnKXRHQ6vO2ZkUijMNpg6+Izzk55REQFjkaQGuy0ZxuSJYzvoHtKYEP44FGYbWMfO09zSK+7DxAjJBOGJiM7p3jytRBbmTRJ52aQgG7SsPOsX44UcjAoztJkgdPsxklrdO0nkZZMCDec5LebnKiPuUTSMkBhCY9EyIqIBv4h0ttFicW5tRD2KjhnaGPrSzwfiTYMaQQmPE73c6P4aNotza6xeXBhyr6JjLJIUIHM2ZasylBiSPK2+cRteZG+BBgUagRypXjzwJFBln5Z2BomvxM7UMMcISUhaxFsJ6kfmbPJWi5KsdqZ+k54CtmhSororPYEnIDLGLExUMUnjWp9elLgQO96nnzXiJ0+L0lw11rGGxWT8jMSkTqEzZaorHd+0Vcei1dUK8cTEifeIL1zer58/cMw5brHzuaSmoDK/mIQZ8nhikvYoV28RX00WI6cXCHNectjkcjbtiMsycjmb/FSL1lY+chuBjpNYy2NAnQJN8lTZvvJT5uxY622KVo0S1YH7SXcpexsZ6dde0u4bdVqgrkWoemGTC+0/aSMzISZFatQkocWkm4O17/60KM1UqW6WQglBcW4DcK6BAg1aM/nQbYTBCAmwznzXIK0m+Z4XSlQxKVnVUL4QTwSCCoknHv739ms7jlAlxbiKSUHWIw0bw4hJcW6jIx5R24hCeq6eEbHOPDWKkXJNhBGTklVFEi1ZkXfDd7MerB2h6WGHJ/79dYtJnNmcLIlJVeYCXT9xIoA9IfAHrOVyNqWZauBjJCkmEy0kFyhFFhGPfmIybdU71kfchW2emAA0sTrPdfg1khSTOGTBb+L5TJDsGgL7Kcj4TvQ8LXI5m/LM5dmcsN9/nhblmQo2UmsU7UTP2tgE+yUZRLe8InmrxT53dsSipe2G9wRFl3PU37alMdxdZ2xJ2md1/MmweqHruyrPVDrffdQ2vZk5nYFvEyskFyhpWw4O28Ukb7VYZDWxpfVJLtkfRtb6cWZRru6aHi5KfRnvdP946IpVSY8dOwZ4YrLI6oh7Eo8CdeoURt2NzOLleAU61mNaydNiae5c19e+F6KdibVIkkJKW3uuj1Fgwt6j4zlhh1FqNS1kTkjSPl62bUmVfZkXE53+kklk0kqtZkpIPBHJiphkfXhgxMQQlMwIyU7xyIKY1CgaMTFMBJkQkl6ikRUxyfowJ0wch42kRT5V8SiG5En9tz1ILKIELdUpaFsOPgjbltgyB2M+XvbngnW+kzyQZ1rDauY0B6QZHFItJGEsjjAh1TZSSyBaUKp2CSnbmY3R6BeiD1Bnetc277truEO7qIKSVRFxqg7WaFCIvTDSK2oO+vKh6CaVQhJ1yBJUTKapU5brnS9lGKJSsecpy/VMi4mk3RmytMgH+p68fWoUOxG+QX0uWRSRnQsyi9Q62y5QCj3kK1Dftj7Li55tI1MlKqkTkrh+j0Fi4rXv/4LX5CJtZOT8EkHJuphYtDrREVHw3udfMtBLVLImIkEWZO5zU0dcoAR0X9fkzx3Tb5W4F5LfxKLO9Mh9UqkSEl3O025i0q/tBTcSdU1uT1qUhLhU7HmW5IrWNrOGX4i6JZHOooiEKRC2jyptJA0KnRQOXvqHsOk2LZpYNLcl30oyx0wvUiMkumdgPDEJ0+7CjtD2BgXq0hnj1yloGwLVKQytql7aqTPt+hOcGzGrIhK2355oNN1PP0091mfvdj0NU1BSIiQikVbjitM09Y6TME+RCtEr0PupuSkOh1kwPM04U8ZW5sQ1qoj48SwKnXjXlcQeWhxTJuJI0kCRmrYi37YtqVOgRlFLe1mn7Zs6zhLSTR+QVvI0hybOKbFIJg/blp1hk7FMskeY2adR4YicY+0kbZnEEhIhxCmgBthAWyl1QgixH/gj4BhwCnidUiqbJdYTxraHUzhcF36H3qRju/ZImi0ScMRkGHOEOoY2P6yUulkpdcL9/07gHqXUceAe93/DmJD2ZQmG0ZCEj+R24GPu848Br03gGIYhk7QlkubkP4bBxBUSBXxeCHGfEOIOd9uiUspLuXQe0FNRasyQ0qYoa5nwj9hIN3wvGeewU5Q8WzM2hu3Edbb+kFLqKSHEAvAFIcR3/C8qpZQQQnV7oys8dwDkn5sNrSlQ13IzFWQdGSH4aNhU3QjMul3gmVNL7C3VKJWr2pyMXoRvVkUkK/6inRUIkiCWkCilnnL/rgkh/gx4EbAqhDiklDonhDgEdE1VrZS6C7gLYObE87qKTdoosx5bSNJshezMn/L040e3vX6pWqQKWFNNZmeifQZ/WY6sCgg4N6STBS1eHMkw8MeqJBVbEllIhBAzwB6lVM19/krgV4G7gTcA73H//oWOjo4DaRWROgUqzTK1apFnN/pfZJeqRS5RpFlyftlkrh2o0HXOLYHgrwSYVbxfdZscLSxyGRLEAo41rHuYGsciWQT+TAjhtfOHSqn/K4T4JvAZIcSbgNPA6+J3Mz0sytVIhcSLspbaX+AWeS6eDfeZLlWdC/FSrk2lnaNc7l7TxS+cWRcQ2D00aJLPhFXix7NOdIpJZCFRSn0PuKnL9grwI3E6lWamqXNUngGcLyJIbRxPRNI4M1GnwNmnjg7esRftHJc2pqkwv01M/BUGx4FevgXbLY+Vtc+pW0xMiHwEJG0kbUpc4Jh8om85xjSLCDgX1MHDMVcju2JSvViiQIN9VDvV57JMG+l6F/o7KGsUMxlfY9GkxAUtw20jJBpYYJVj8gmktDsPcGZniuirspYE2taLtHNsre8bi/VDnoCEyfFRZV8mxSTnzujMsx5r8aBZa6ORozwJOOZuRZYpuYls0kzsoc2YMYpcHmnBs0yinANjkSSApL0rt0laKVDnyOEzo+5GKogrIqPOUqYDr0JgWLL/yQ2GmHhZyuLi5KXVm1tkFETxmRiLxDDx6LQksl4QzSOsmBghMRg0Unfzvk8aRkgMBs1MYvY7IyQGQwI4ZSImxzIxQmLQytOPPrdTt2XSycrqYB0YIUmAFhYPVv4JK/aS1ovJq6978uLV2tq13ThdLbQFbMH5B67KlGmfRCZ3i2YqF2gmhRESzbSweLRyLQC1apF15mmSp0k+8s1vI2mS58zmUU5WrsFu53ji4rHIFe886hS4QInzD1wFWzFLgrgi4nH2geOZEhO4LChx8q1I2syzPlEiAiaORCsNCpysXLNtW7VS6iQIWiqvBCrt6MdGsmovUqtuvyntdo5zm0sszDjpXiTBi5R7dXXOPnD88sY2jhjkQqSGabvis9X95bMPHOfITY9l7qby1gkFiS/xi86+DEQyJ4UREo08cfFY39dXKkuAIyhBbq5eIuLR3LI4s+WEtxdLtb51hf1Ji55+6Ll0/dHdAqYCiMkO66MfZx86zoEbnuwUv84S/oWH3vDPLyySNgUaYxGEFhcjJJoIU4Vv9eIC9pzsuxZnkIjspFYtQsnJl+JfJFinwNrmAhvrJajuHdzQFpATMNVFTNrCtVwCdcl9jyNcjWPTTM80MikosDsdglcI3YiIgxESDVSYd8ShHex02u0c6xfL1GcdC6Ekq53hziqLnRrDQUXEo1YtYs9KZM7uvPfSVh7Wp0K1QxvHZ+KJiec/ieo6aMPGyQNsTAHXklkxAUdQ4tbpHUeMkMQkrIh42O1c52ZvTeWROefCrA9IdTgI7/2Xzj4nVjsdMfGe62DLmR6W17Yz609Ie5nOUWFmbWJQZV8kEdlJc8uivlGILSLaCTuMCcIWnH8oW9PDhsEYIYlIjSJnKkdji8hE0nacsFnM/ZHWvLujxghJBBoUOFW5ctTdMBhSg/k5DUm3WBFDSKbgimu/Y2Y8Esabsh6GT8cISQhqFCfLEpl1Z202Yka97mjzyNUnzRAhYZpYtMi7oQDJl8swQhKCiRKR0iXmDlYAnJo3OsRkVnHw6icyF+maNTwRASceqYVF0mJifCQhWCrHLNvQB2uqSWFW36/03iP/GOv9nogAzB5cZ8/BzcsWShRcEcnqtG+WaO1Yg+WJSZJZ7o1FEoIy66ywpL1da6rJ9EwDYFswWVQKs3XyVotark1ry+LZ8zOh3r/n4Oa2/2XOpliqYc/WaW45My2Xzj8n+NTwFBy5+qSxRIZArxwoSVsmRkhCck35pFZnq19EAKR0btqoYlIs1Tp1dYpzGzC3Qavk3MAXz5cHhsnvObhJsdT9hpc5u2M12ceatNuSrVP7+3co5zhWx8EnMp2Bz9BvhXmSYmKEJCT5gCtsg7BTRDyktCmVqwC0mvnAgWqF2XpHRPzkLafP+4+swRF45juHu1oT/URkVx9zNjJnk7vm6b6CctUND43N7EzaI1qDZGSzkTTc/cKuRO9HKnwkWaxQFheZa3cVkZ3krVYg34k3nOl7TLcK4IEbnuTATU9u/xmZ3wosItvazNlYUy3mnnd++5AoB8dvemBsRAT0Ft1OAzZSWzrIVAgJCKrsG3UnAiFpc235UWQuRvKbXNsZdgQkb7Wwpppdj2lNNSmVqwNFpBsHbniSueed12aXFks1mN9y4kRu+E7qf8Gj4KVjaOvMLKeBqH3RJSapGdrYSCrMk89Airo8Ta6cO8WZzaMd52NQwoqIh2e9NDanabcldjvXc2gUhrzV4sANT9Jqxsu25jE3X6V8uDJWlshO/MODPK1dGdWCCmgbqUVs267vI04GvjoF8jF8J6kREo8WFjWiVfsaJtPUOTSzwjmWAouJjhvfLyhx2zLEx5lq3S7Cfqdstxuz3VlDLMEV3Kg3cFwR8fDEMU9rfEp2ZkVMitQgoJjoEBE/RkTSi9+Zabvptf2Z1fxxHg0Knf2A0DfxZUHSg9e3sP1IpZDAZTHxlDqtU29FalSmWn2FRLeIGLKBl/Vfun8H7ec9H3XmtVaEROWpFRJwxMRzIbaRqbdQumFExBDmpvRExXtPP1FpDxCoOIyVkPhJ83CnJKsUyt0tJl2V7neyyCqrLGpv15AO/BaKjezpCE1LEa7MCAmkU0z83vtu5IE601rFZIkVJG0jJhOCf5YInOu/vWPbqBkYRyKE+IgQYk0I8W3ftv1CiC8IIR5z/+5ztwshxAeFECeFEN8SQrxQd4dtcqk5gS23pNIgCjRiFV3y44kIONPQR3mSEhe0tG3IBjWKqbkHPIIEpP0+8Ood2+4E7lFKHQfucf8HeA1w3H3cAXxYTzcdZBfTbpSEMSvjiolngXRro0gtNVZayaqOdQyJoTsDhUQp9SXgmR2bbwc+5j7/GPBa3/aPK4evASUhxCEdHfWLiJNvYbT5Pm1yQ8s56pSBrJDvc4OWuBBLTKJExu5E5uzUib1hOEQNkV9USp1zn5+HzkD9MHDGt99Zd9suhBB3CCHuFULcaz/d3zTvdnHGdTK1RiBGUYKOJE7phn4i4uGJSYF64MVYBeqUuODUq7VqnbIYUSjIeqLWyM3cz3/lXYm1b0TwMmHPRWwPoFJKCSFCZ7xRSt0F3AVgnXh+z/f3+kCeNRAlvqRBofN+b94+yI3qZ2fymCB4DtmglownImE+o99fItnXc6FZkRqS9jYrZpo6NVnEltsvixZ5as3BC9Z+mV/l3/3GJ3e/cB1c/8r7An6C3Tz8oVuc1cp3wwf/Bh7+9c8D8Na3vZd7+KeR24Xt15c38eqffp00vHMwrIC0VSHEIaXUOXfosuZufwo46tvviLstFEHVMIqYOAW0L39sv6D4j99PWHa2EYagYhJkODMIT1R2ikm/YVC37TY5pq06DQo9BeUXrPexX3yS5R59efjFt/Tv7G1w/S/vFpuHX3cLy/9r+7bltzt/3/n2d/KbL4Yf/No9nULtQfGusV7Xmicok4D/eo8aqi+UGmxMCCGOAf9bKfV89///DlSUUu8RQtwJ7FdKvUMI8c+BtwC3AS8GPqiUetGg9q0Tz1eH7v3jyKZlkFkL72YKKgCeU3OnkzSOiPhpke8rJousxhIRP1XXMilxwc3mGa1dfzj2ir2E3Xae/wvrjzku3krcsLtbu2z7YoD3vRiYBm49Add/c7DlM0hEPCbBMvF+hLsJyDfErfcppU4EaWegkAghPoXzHc8Dq8CvAH8OfAZ4LnAaeJ1S6hkhhAB+C2eWpw78jFLq3kGdsE7coI7c+5kg/e3KICGJe/P7hwA60x30EhP/FK8ubHJa2/TOZ4E6rxQ/oq1dHSz/Olz/tu6C4pnuYYgyjE0bUVYpaxWSYRBXSKC3mOiyIJKgWy6IJEQkSW7kQY6Jnx11N3qyT93B/+TfxnakZlFM4mZACyMk6bzDNNGgkFoRgcvrKJpYbpzIWqZEJAvkaWqZjcnTypSYDDuuKCUZ0uKzc8jhn5lJM17+h3kqRkRSjs58vUkyiuDEsRESuDxuz4qIeJQCxokYDGllrITEW4OQJRExZAsTtNadsRISmMyM9AbDqEmvJzICBepI7IExGgaDQS9jY5F4IgLd58zTTD3ls0uGy0SJQ5kExuLq9YvI5W1OnKXupEJJ4PQ/O8I36cRdk9NGsta8nJCqZFW1VbwbVW7jdN9hfbBoBpqOK9BIbYW0nYvmssY8lVQHoyWN3zoJGmOy0ry8tMCj0i4jZ0ab8DkumRzaBBURj7TdrJJ27Pwho+ZGHuQHxGtH3Y2+/Ji6jt/hPwzlWIOuxzayq4h4rG0uxPbrTVMfWXXDVFgkkmd33VQt8l0TJ4cVEY8itVQMc7JuhbyKz3MNJ3lSfGrUXenLu6vw/XxkqMf0rkvPOvFfv1W71FNEPNY2F1iYWcukZZIKIelG3v066kx3tuWwY0UXFmiMVEyyLCI/zBf5OT7AE+IZ/nrUnenDO2ag8BW4ee6rI+tDnhY2kguU2NgMN6xe21ygPFMJ5TPx0gCMstZyaoXEoxB7cfru9npZO0khaZPDTm2Rr0G8nC/zvht/ieVvD953lCx/Am7+ydEJiJ8m+dAi4lFtlsAikJikQUQgA0KSBI5Vk09USCTtTnkv6ZZtzCLX8wgfWPxPLK8N3neULD8CNz8vHSISF7stqVKiaeWxaA0UlFGLiNMHQ2Jkff3M3069jEea9Mx6lgaWvwcPXXkVN/MHo+6KVuy2ZKNdpJGze1onUVKEJoUREsM27vuxl/HezzrP3z/arvRl+aPwW298Ez/Iv96V02Wc8KwTaXWfHk6DNQJGSAw7OPtZNHul9LP883DrG/8ydJ7WrGK3JRXKlK3KNjHRFcSmg0zGkRgml+WXwi3v+/LEiIiH3ZasbS50FqWmbfbPCIkhM/zKfrj5K18deSzQKDm3uZQ6EQEjJIaM8O45eEElO7MyNjnaAwLQxgkjJIZM8P3VLImIMwzZOr9/YsRkcm1Eg0Ezp5rHAGhu5dk6uR+ArfP7YXaLqdk6uRjlUNPOxAqJl8E9iQjXOtPk3HJSWY1mNYTj8c2r2Th5gF1xhxvAxhRbJYvZg+uxj7Mwk87IwIkWEulW/oWWllgEb12Q7cqI52E3YjLePHrx+9g6tX+3iPipCjbaB5g98nSkYyzMrIUqDj9sJlZIPLx8Et4XFFZQ+qV1tMmxzjzzrBsxGTMqlDn76HHnny36i4jHBmycOsDssWBiMj3TYIkV4PJ6rbQy8ULi4ReUoGISNDfsOvNaa/lOIq8VPwDA8ivhlr/68simgOtM89hDNznCEWX5VBtnCDRFX+skP9XiKE+mWjz8mFmbHQQpc2gjqVEMlYhmlcWJjn/QxfLn4UfFy7j/2z/AUc5wlDNDO7aN5LEHbgpugXTDE6AN2Dg/33WX/FSLa+TJzIgIGIukKxKbIrVtFoeXmzOOL2WFpdTX9j3yCuDvRt2LwSzfCLfwOgBepd5EhfK2UiQPciOnuFL/gXV+dVXBRq7E7HwVcAQE4Bp5UuNBhoMRkj44yZVarLKgzZpYYSnVw5xbvvhl7nvJy1j++qh7Epx18XsA29Iw//lPwt98whkO/Wf+S3oX9q3vpTlrUSpXMzWU2YkZ2oyAVRZpUKCV0to7t3ztyyz/y1H3Ih7Ln4Qvia/yJfFVruZxbe3uObKprS2PcnmdK3kisyICRkgCkcTahnXmWadMI6W/lLd85sssv3fUvUgXEpurF7M37BgGRkgG4OVZnSd+MNFObHJcoJRay+Rl7/g8y/9n1L2IzycW70i1X2ocMELSB//FN02dRVa1H8MmRzNgTZRhU2eaX7rtXaPuRmyW19KTAGhcMUISgjzNRMSkyr7UWiUGQxDGTkiSNmGTEhMTZ+KUklj+4qh70Rsvfmj2eU87853ewzBYSIQQHxFCrAkhvu3btiyEeEoIcb/7uM332ruEECeFEI8KIV6VVMe74YmIDjHp10aeZiI+kxWWOut00sKw+vLb6jTHNk6z8IrTqXTy2siO2E/PNDhw05McuOlJmN8yYkIwi+T3gVd32f4BpdTN7uNzAEKI64HXAze47/ltIUTiCRkk7V03ftKWyTR1SlzQ3u4KSx1BSQOf5Ud5jvqPibX/HBwR8bPwjtMs/2RihwyNjWSdctfXDhxeg9KlaGKSA6acp22ynbdkoJAopb4EPBOwvduBTyulmkqpJ4CTwIti9G8g/QQjaTHJJVivZpWFkftNGhRYZZH3cCcvUa/grZqu9UXgrdJ5/A91f9d9Fj5xmuWf0HO8OLTIs065r7AfuOKcIyYlFazRHDALzG8xe+xpNjaLVNmnpb+jIo6P5C1CiG+5Qx/vLByGbYsfzrrbEiHITdzNWtHRLjhWyT6qiYiJs3K4HEpMGhSoEa26W7e21rm8FuSn+TjXtU/z7iosv9F5ROFGwFZv4rr2aa5rn+57Ay384emerw2DFnlqFANZhweuOMeBq8/AwS2Yv9R7x5KC0iVmjzzNbOlyfNLa5sK28501ogrJh4GrgZuBc8CvhW1ACHGHEOJeIcS97aerod6bpDiEbTctYtKgwAVKVNm37RFFWGoUe17Uh+dOs/BR57H8lXDtXgdcVD/Br/LLofsUl6//wq2h9vdEJMzCTHCGOvuPrDmCspP5S8weXO+srdnJ2uYCqyyyymKoY6aBSEKilFpVStlKqWeB3+Xy8OUp4Khv1yPutm5t3KWUOqGUOpE7UAp87Dg3bFLDkGnqzFNJpG1PTCrMU2F+169jC4sK81yg1HmtRrHzqLKv817/oxfe+4Jw6KWP84tbwS6hvcB5dQd38p5A+3u8Wt0Uav9eLIf4qYsqIh5S2uw/WLksJvOX2HNks6eA+KlslqlsljMnJpE8ekKIQ0qpc+6/Pw54Mzp3A38ohHg/sAQcB74Ru5cuumZjknBk5mmyxAorLGlv2yZH3e1zk3wn2Y0nMoM+T7cFa02WugZphUk9aZPjBush/k69nI+K3rk1CuotnGOJ3+DfBGrXz49xNz/LFaHf140KZcoDBN9GbhPlqEhpMzdfpT5VwJoKv0Cz2ixhW7LzXaedgWdLCPEp4FZgXghxFvgV4FYhxM2AAk4B/x5AKfWQEOIzwMM4C67frJRKXUhhLzGJK1SSdmJi4mGTc1cQr8U6jq5p5joFXsGXuFE9yGc/+TqWf+ryaw21zMNcz9d5caxjnFW/yRHx1sjvb6lf4kFupIlFlRIlql3382ZndP3QyJwdSUTAKYhVo8iqtZhI3JJuhFIBPc0JUjhxnfq+ez86cD/dQ5OdF4yu9r2bfdKwaDJNnYdKN/O+6tv5AD+nre1/xacpi3cG3n/5K/B9L70fYJfDtEB9l5joFhHblrS29Cx9ODSzwr4e4pck3xC33qeUOhFk33QEK4wIv2WiU6QkbRZZzdw4Ny5NLJpYHK7qn235I17P+9U3OCn+pOvrv6Me3yYCv92nrTqFTiY8ia1dRHRSmqmmsrLeTtJ35oaMWRWaHc74/PjXACvqLbyPX4zUludULnEh8BTvKKhulsjPtBKJpNZJOs+ewdCFD/BzfEid5Af5f7yAf9DSZtYDwdKCEZKE8ApwRZ1CNHTnzXxo1F0IhJQ2+amWNj9J2hm71b9pQdKmTAUrpblZDckgaXcKWRVlrZPQedwxQpIgRkwmiwJ1LFq+Ko72xIiJEZKE8cTEOHXTS4F67JkRbwZI7gjyk9iUZBU5xgXEIQNC4q2ryfKN6AWqZfkzjCueAICT5DtKbV1/G70oW5XIYlJnOvW+ttQ6W8fxpltihTM8d9Td6FC7OAtALmczPdMYcW+GTzcB8IqjgbPmptuSAe/azGGTJ9lhy/RMA4sWVUoAlFlPZf7ZVArJOIqIx1GeHEniIi/Sst3enVSk3ZbULs5iTbXIW+M/npe0O76MfjgF0hyLAJyIZceZGk10y1aFCmXsLt9B1+NPtXZZSBXmneGSL6lWGoQlVUIyzgLiZ4kV1lhM3Fy1beeCtduSZoBpyOZWnuZWnsJsAylHf3EmRa6LL6MfnnDUmY4sIh5lq0I1Vxo4LZyfalGU3f02NnLbCu4C9Y5lNCrHfip8JAI1MSLikfRsTquZp74xTX1jOpCI+KlvTGPbsiNE44R0BytRiCsiHiVZ7TuTI3N2TxHpRp0CVUpUKVGnMBJ/SiqEZBLxCm8lRVjx2IknQq1mfmwEJeiQZhiUZLWnXyrO8NLJQVNyI1mGV8UxVUMbQ/rwBGkchjtpERGPAnWYgcbmdGfb7EwNS4MDt0axsyAxTyvxIY+xSAyB8IY7WSXIFO2w8WaIvGGOLhHxsJHUKbgu42QxFokhMPWN6cxaJmkTET8lWcWeya5Ig7FIDCHJomWShXweaRa6IBiLxDC2xIn5MITDWCSGscSboTEMByMkIyZrw4SskLYZmlFSdwunJVkW1AxtRoCXlatFntZWHpmznUcGnZhpQ9JORch4GLzcwd50bRJ4MSXT1BM5P0ZIhswai6xf3F6Qut2W5Fwx0bHWxaJJjdnY7QwbfzxFfqoVWliHEXC2MwI76pqpIEXvdYuKJyZJOJ+NkAyRFZaoXix1fa3dlrTbsrOgK4qoWDSR2ORpMj/nFLvqdbwoFGYbFKQTj9Ekr3XhYbVS4pIvGnfvVAuZ231z9VupPGwR8baFOQ+DloLsFir9YpKEVWKEZEj0ExE/3upc7+8gMfHPTPgvwml31ag113LGyBejWyjWVIuSVXUT97TdY9naCpbvFBGAS1t5LnUJpNqTs2luWRRm69vOTVJTvEEL1QcRk6j1qnWLSY2i9jo5RkgSpsI81WYp0tqX5lYeuy17WidFagMvzjxN8jRhjkhisjTnVGbtZooXqWkRk50i0o9n25Jn25Kabyn+scVTsfvQjTA3vn9fv6joqN7otKlPTFpYrDOvtcRFKoREITq5HsaFBgXObB7tmv8jDN6QxxOipblzkc5TiQvYs5L6xvTgnV2Ozp3p+7pOMQnLs+55veLwqUTaT1Oxei9DoO0mQNCBUxRMn5ikYvpX4XywFlZqCxWFoYXFExePxRaRnSzOrcW6SMtyncJsg1yflH+5nE0uZ3cskUFI2pS4EHloUVktD96pD2dWjw7eKSRp/UGLkwKhG17BdB2k7q718m975E0Gdq2U5TrMwFqzeznRklWNdM69MgxBnbC2LamulzqWRVSOLva3msKQVgFJkhYWNYqxfUypE5KdtLC2OfkmFWtK74zEgqW/wr0nQE36T4vatqRWLcYWEd2M2/A6KF569TgzOakY2gxinIY9USlagx2raSBPc2Boen1jOpSD1ZAsnlUSJ/I1E0JiyBZ5mj3LOrSaeVpb6S6tMInEFZNMCYndpTSAIZ3kae4ad7ea+VQOaQwOccQkU0JiyBb+vLRp9YsYttPCchMzhrMajZAYEsWbzdExQ2MgUiXAKO2HjVcxQqIRJ2DIWcU5KJhr0jAiEh/PiZ3UcoA4eW2NkGhip++mQIOluXOdAC9DMkxKzpGdU7M6xcRb6BnnXA4UEiHEUSHE3wohHhZCPCSEeJu7fb8Q4gtCiMfcv/vc7UII8UEhxEkhxLeEEC+M3LsM4Fkh3ShS4+qZxynNVCOLSS5na48hGTbNBLKYT83WmS3VKFIbWXW5YdGrMqCOa8KL0YqbTS7IFEgb+Hml1N8LIYrAfUKILwBvBO5RSr1HCHEncCfwTuA1wHH38WLgw+7fsSLM7FGZCsxAdbMUOGy+MOus6M3L3bMfWaLKPp4+fcj5R4NltneqRbFUY1Guds6L1QmEG49pZc/6GCQUBerUKURefxMk5icoA+8GpdQ54Jz7vCaEeAQ4DNwO3Oru9jHgizhCcjvwcaWUAr4mhCgJIQ657cRm50nTFaQ1SBjC5p3YSZkKcsZm9eJC19d3lnnwF4nOKhV7nmfO+j5vW0YSkz05m4VFJxK3QKPrQjNnJbQ91OpySRC2LrFFkyZWaDHRKSIQMkReCHEMeAHwdWDRJw7nAW/xxmHA72k8627TIiSgV0zszlfX/4vQYZyXqCLnbFYuHupsK8w2yMsmBRqZiFwNQsWep7WVZ6PaZVVwQDE5eHhlWwb4IKtUvRmHqGLimfhJDMX64fd/hB2uSOzQYqJbRCCEkAghZoE/Ad6ulPpHIUTnNaWUEkKoMAcWQtwB3AGw97kHw7x1G97JC3sTBhUQ3RSpcXSuTcs1w8dlHVGDQieF5NZGwRGMXnivdRGU/QcrLMrVyFm8ooiJP69LznU8gvOZkkyY7B0vrq8jjJgkVXEwkJAIIfbiiMgfKKX+1N286g1ZhBCHgDV3+1OAf233EXfbNpRSdwF3AUyfuC6UCO0krJjY5EKXMWyRJ69JxQs0RvLLlxQtLFZWl3g27PoZ1zrZO9Xi+vLDgJ7kzQXq2MiuPpNuxdt3Hs/738u1kpSY6BARj0HtJGGF+AkyayOA3wMeUUq93/fS3cAb3OdvAP7Ct/2n3dmblwAXdflH+hEmfH4YtVAHkeVZGD82OU4/dSy8iPi4sfwtN5ayqS2X6M7zO88686yzj6o7z3b50Y8iNe1pCZOil7WRtIhAMIvkpcBPAQ8KIe53t/0n4D3AZ4QQbwJOA69zX/sccBtwEqgDP6Ozw/3whiq9hguNjDvi0oIn2N976ur+Q5ggtCX3r76AE4v3aujZZTyrRFeiY09MdCUCAjqWjs4flZ0zOcMQEQg2a/MVQPR4+Ue67K+AN8fsVyz8Q51WBI92L3QOb7KKTY4zlaNcCpGycVRkedo8Dp6YAEMREchAYqOojMKROu60sFi9uKBdRIql7Nzwo8pRG5ak1+TsZCJC5HXnuZxEPBHZ6jalG4P9R9a41npUa5uG4TO2FslOdJRDlBq97FmjTkG7iBy44hxX8oTWNg2jYSIsEo84IjDJItLColopaW93iRXtbRpGw0QJCUQTk0kWEXCznWXIj2EYPhMnJGGZdBHxKMt15g5WtLV31RXfHftVu5OEEZI+JC0iXoRrVliwVpmdr2ppy4iIQ3tMZhcnUkjSZGFIbAo0KNDQXiE+CQ7NrLB3tjF4xz5cdcV3JzbGY1yZSCEJwiiGNHlamRATayq6NbFnqpXZRYptpNYYkhw2FtlOWuUxMdO/YRilXyTvrgTy1gMlvfo0CodmVjgHbKyXQr93YXE1M2tX/OgUkSwNZ4MysULSK64kLc7Vy6H46RSUQzMrrOVsLp4PXgR872wjc0OatrsYtE68aN6gWc+yysQKSTfSIiJ+/IKSNjFZsFaRR+ztWdD6UCxlZyUt4C53i3fedaYKSDPGR+KSRhHxSLNXvyzXOXDF4CwRe2cbLEr9hcuToo2MJSLj5P8IgrFIIBMretNmjfgZtEBsz1SLa8uPDn0hWVR0+EMmRUA8Jtoicep5pF9E0k6eZm+rJGdz8+I/ZEZELlDS4lRNsxWZBBMtJAZ9lLiwW0xyNi88fG8mprQhmaRFk4IREoM2SlxwwuhzNuRsbjp8/0SKyCQy8T4SLzVjmpGu4y4LyaIXrFUWDjtO1TrT24LP0igquoPMJpWJFpK0C4ifLImJH+8mzbn+KB1Z4nXS6pJp3hCezA1t4qZQlJ0W0nMxB8UTkyzSRlJnmhZWqvwHBerbCnEZopF6IbG33fpy1/YwZFE8dpJlMQGnoPgwCk+FwaxEjk9qhSSoUATZJ6sWSC+8FcNZFZQ2MnWlQXSH7mf1u4lKqnwkUYcsl8tPbBeLcRKPbmTVbwLbnZxpWH+j028zaSICqbFIhJYAnu0FssZbRDyyPNRpI1M1xNEhaFn9LuKSEiExxCFryZF2kpbp1xx2LDGZVBGBMRWSSQtP9pOV5EhpJaqYTLKIwJgKyaRj1g/FI+daeEGZdBEBIyQGQyyMiDgYITEYuhAkAtcMIS9jhMRg6MKgzGaTlLQoCEZIDIYe5Gl2tTrMcGY3RkgMhh7ksJmmvk1MjIh0xwiJwdAH/3SwEZHeCKXUqPuAEOJpYBNYH3VfQjBPtvoLps/DImt97tXfK5RSB4I0kAohARBC3KuUOjHqfgQla/0F0+dhkbU+6+ivGdoYDIbYGCExGAyxSZOQ3DXqDoQka/0F0+dhkbU+x+5vanwkBoMhu6TJIjEYDBll5EIihHi1EOJRIcRJIcSdo+5PL4QQp4QQDwoh7hdC3Otu2y+E+IIQ4jH3774R9/EjQog1IcS3fdu69lE4fNA9798SQrwwJf1dFkI85Z7n+4UQt/lee5fb30eFEK8adn/dPhwVQvytEOJhIcRDQoi3udvTfJ579VnfuVZKjewBSOBx4CogDzwAXD/KPvXp6ylgfse2/wbc6T6/E3jviPv4cuCFwLcH9RG4DfhLQAAvAb6ekv4uA7/QZd/r3evDAq50rxs5gj4fAl7oPi8C33X7lubz3KvP2s71qC2SFwEnlVLfU0q1gE8Dt4+4T2G4HfiY+/xjwGtH1xVQSn0JeGbH5l59vB34uHL4GlASQhwaSkddevS3F7cDn1ZKNZVSTwAnca6foaKUOqeU+nv3eQ14BDhMus9zrz73IvS5HrWQHAbO+P4/S/8POEoU8HkhxH1CiDvcbYtKKa/g7XlgcTRd60uvPqb53L/FHQZ8xDdcTF1/hRDHgBcAXycj53lHn0HTuR61kGSJH1JKvRB4DfBmIcTL/S8qxyZM9RRYFvoIfBi4GrgZOAf82kh70wMhxCzwJ8DblVL/6H8tree5S5+1netRC8lTwFHf/0fcbalDKfWU+3cN+DMcU2/VM1Pdv2uj62FPevUxledeKbWqlLKVUs8Cv8tlkzo1/RVC7MW5If9AKfWn7uZUn+dufdZ5rkctJN8EjgshrhRC5IHXA3ePuE+7EELMCCGK3nPglcC3cfr6Bne3NwB/MZoe9qVXH+8GftqdVXgJcNFnmo+MHf6DH8c5z+D09/VCCEsIcSVwHPjGCPongN8DHlFKvd/3UmrPc68+az3Xw/Ygd/EQ34bjRX4cePeo+9Ojj1fheLEfAB7y+gmUgXuAx4C/BvaPuJ+fwjFRL+GMa9/Uq484swgfcs/7g8CJlPT3E25/vuVe0Id8+7/b7e+jwGtGdI5/CGfY8i3gfvdxW8rPc68+azvXJrLVYDDEZtRDG4PBMAYYITEYDLExQmIwGGJjhMRgMMTGCInBYIiNERKDwRAbIyQGgyE2RkgMBkNs/j/RcZrfWbyYQAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -279,7 +279,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -291,7 +291,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -303,7 +303,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -315,7 +315,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -347,7 +347,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -370,7 +370,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -401,7 +401,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -431,7 +431,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/demo/neighbors/quantitative_neighbor_maps.ipynb b/demo/neighbors/quantitative_neighbor_maps.ipynb index 1ffcb74a..a96339d6 100644 --- a/demo/neighbors/quantitative_neighbor_maps.ipynb +++ b/demo/neighbors/quantitative_neighbor_maps.ipynb @@ -21,7 +21,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 2, @@ -56,12 +56,12 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAD8CAYAAAB3lxGOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAACTYklEQVR4nOyddVgVTRuH71UsEAOwwC6U1xZRTBSx8zMwEbDFeu3u7gBbQMRAxe5uULFQQUxULAQUESx0vz8O58DhJK2+3te1l5zZ2dk5yP525plnnkcQRZG//OUv/10yZXQH/vKXv2Qsf0XgL3/5j/NXBP7yl/84f0XgL3/5j/NXBP7yl/84f0XgL3/5j5MmIiAIQjNBEIIEQXgkCMK4tLjHX/7yl9RBSG0/AUEQMgMPABsgBLgGdBVFMSBVb/SXv/wlVUiLkYAF8EgUxSeiKH4DtgNt0+A+f/nLX1IBnTRo0wR4keBzCFBT3QV5dQxFkyxF0qArimQuHMz3zD/4HPVVVhYVbpwu905NwktFkjcyN3pfwlTWCc2in449klDwWwRviuTix7Ns6X7v1MAg71s+6OUiy/O0/d3lyhRFbBEDIsPjH5XvX40QCoH4GrL//J6q9/se/ZHYr58FZefSQgS0QhCEfkA/gEJZCrOj9Ol0u/eblmUJyZULAGOnbWw2D0q3e6cWi4u/40PTTuy91VPp+VWFrDFJ5z5J6Xh+FEes1mXQ3VOGf4+RtFq3CdLwvdBwTUmm1K6DWcdKZKe4rDzkWS+yToCW7Q/x4J/qqXrPR8e2qzyXFtOBl0DC13rhuDI5RFFcJ4qiuSiK5gaZDdOgG6opeOgBXeaYA+Co2zBd751aeL2dx8sixxTKVxWyZlUh6wzoUTwGndeRa93DDO1Dcsj3vjANRu5N8/t8iJ7C1sf9CFjtLyvLE9iUCjFvyHRkaqoLgCbSQgSuAWUEQSghCEJWoAuwPw3ukyIelXDjwaMBGd2NZHM1cjGdjvWSK8voh1/KoTcfaaLbPqO7kSSOjZ9L+PdiFAgvxCvnc2l6r5sj7Vnfvh4jTlizx2EUeQKbys6VujQwTe+tjFQXAVEUY4HBwDEgENghiuK91L5PatDtmhOzFhbM6G6kCr+KAEip2ncQU/X7ZnQ3tOKJlxmn7H1oauxDkWaXOXpjQrrc9+ZI+3S5jybSxE9AFMXDoiiWFUWxlCiKs9PiHqmFaac1Gd2FFPOrCQDAwhI9aPaoWkZ3QyueX6zPnX8Oyj7nzto8Xe7rlMMAhzF30uVe6vjPewxG5c+d0V1INpmqR2d0F9Ri1CAn1Z8qNUj/MnTpuIzbE2/JlfW080zzKYGN7lk6XmmZpvfQlv+8COiHRmZ0F5LN0qFzfslRgBTLejN5MK90RndDJVWdItmxaidHC1+VKy/S7DI+dy+k6b3Liv+jttXoNL2HtvznRSBo5+9rHDw+8ENGd0EtsZf8yNamCoGOwRndFQW21HNhS+QMmhr7KD0/vKErro510uz+5WJi0qztpJJhfgK/CoU/ftVc6Rdkcdl3fCg+mXNv3TO6K2rxCrqM4OHClnrF6X7BKaO7A4D1/SKYDLnD19DOVLyn3GRVfMEiDu8dRXBeU8z8BWJq30+1+1+zMKfSI9dUay+l/OdF4KLZTfA+mtHdSDLO9lXwccsCVTO6J+rxnTiRyh2tcZ04jxVLCjN0nfI3b3qwpZ4LW3qZ4HQcbthMBaAgbZTW/TIfCnKeRcCrUyvYZJ+bMxNmEpbbC0fXS3J1bXTPciLGSuV9bXTPMqfCKGqctwDA94orpK9rjFr+89OBfgZD6OlnmtHdSDI1fH9iU7BLRndDK0plmcG+8LHsGxHCin6W6X7/LfVcaLFhLy8u9SDPuRkE9VDtaq0MY+uhjH8xnuMDYwi4vZCooNx4D5glMx6WFf/HNQtzpddeszAn9uJSBvQNofrm3VTfvJtNu36tvXT/eRGIGO9KfZPFGd2NJJPn2qJf2iiojH3hY3Hs1Z0nXmbpds8nXmZULfaEPOdmkHXvTsw7DUpRe1/mn2f8i/FsybsK6xBTdC+Xw75iSWqct5AIwZdBsqPvnguMWWPCx+tXUunbpA3/+ekAwEjhAWcCBtDQ7PfxGSjWoitEPc/obiSL/IUHERqyCh9npzS1E/TOvoFAbyO2ZMue4oc/McbWQ+O2F7gz33s/S69MZ0xJE6pf3y2rcyMMUCIAvTqacckwfkXicZ3VQMZ4C8LfkQAAA4tf+q08Bx+dWMB3vTMZ3Q2t6DdkKL75OiqU5y88CNf189hSzyXV77minyVdOi7jbfevBPUIS3UBSEzBoDa8nPsQrmrn+JNl42dA8vA/rrOa5ussaL7OQiYG6c1fEYhD37J7RndBKyxyj2T3kH54d7+e0V3RCs/lufF0eKv03L7wsVgOdiHq7WOi3j5O8b1W9LOkd/YNxGw4SqYcHjRqm37bmb/MP8/Pm63I9UNXY931YiE+lD8me/il/B0JZDAtW//624kfnVhAxMu6vNlsQzvPwwx6fSqju6SRBm+DFcraGs4nNGQVOesMJuCgObe2lWLo5m44LKpJpz59tRKEFf0sWdHPkmPj5/L5Sk2KPZ5IxVw3WbVnZqrM/ZNDxU7G7G8YzvWe/9NYN+EOQoAj/a6qqJn2/BUBwGCuIwHH3md0NzRyzyE/9Ve1AKDG6lWUKpp2ziypxc9S29kXPhaQPPyum7bgvOACM1/oc2EZ5K7uAYCjzhUcda4wtMJ6hm7uRvWnAoGOwTJB6J19A+d+fJQ98DEbjjJp9zKaitPo776FBosccIu+i8PWjF17G/9iPMGxp6hmtFNtvaCrHnIPfkaNAiANYgwmhwo5qojpGVQkMW9aluXn+N046jb8ZY2DFrlH0vzObqLeGsnKTvzsxKrFnTOwV+oZ/dST3QFO7LxanpK2AQQ6BrPAzBZHnaRZy11ja3Kw90vezX+HXaTqDakR346l6xRAHU1W67J04im1KwOLatpgn68RR/pdTXMReHRsO58j3irdyPF3JACE5JL84bjG/LrGNo9hj+UEAKCd5+EM6o12ZNbfTSVvCzpZBHJhGYRVKp5kAQDJKKHVRhOK9R2lss76Ntbk+rYxBb1NXc4Hm/PhjPqYCkFXJaOgzzenU/beddmRGgbCpLTxVwQScSbg19tLsLifCd/qrFIoD2r/lUtlL2ZAjzTTsmAucukY46hzhWX7Uj7adNS5wrR1xzBbm0/p+Q67xmSIHUAVX+af53yrYWrtA6YWduyuIdlJuLtGS9nx+eZ07uoWVPkgP66zmoezCjIhb3mldcreu85sS0vu6mq34vWfF4Fdo6Mxdtom++wac+aXEgKL3CP5OCkr7gaKAZt7NNmI3b30DUWlLV8dK1BxjEeqtlm6kB8FRlszvICRwrlfaRQgZfyL8RTZp9ol3WxgJaXl2SbA1mx5ZWIgHR3c1S1IeQ8TyrW7Q+zjQAYd38O3sl0UxODQnpZUbRhIZttA2TLkV5MsKvvxnxeB/Wc3KJT9SkJgeXqUwjRAylmfXlSpmz5RcJJCyWm5qJ2zXZq0XbqQH3NDRssJQVjYvF9qFJCQUp/eKx0N9BVeE7DanxxVpyqcc1ucF4AcVaeyNVteMl9vQ6v+s8hsG8juM3fxD5iN/iDJsutCw2e86b2NVv1nyYTi2JVm2F4LxLDYUg5PyMPhCXmootwcAPwVASb2/Ky0/FewD9gMqot+VvXhGTeMnc2LCo7p1CPNLF44hWP1QqgRPCvN7jG0wnoCT21h785wADwsL6fZvVJKhWJjqepioVD+vXcOAN7O/kThYpv437VDcud3XfTk7exP7LroKSurZDYRQCYAU7y+yM5Z+h9iY8AKMtsG0rl6UVl5ULFbWHRX/6L4T4vArtHR6FdrpfJ8Tz/TNB8RbPE+hmW1QVjkHikrs8g9kq63B1FzYE9iviiOVBJy1qcXjTZnTtM+aotOHXOOvD9JFn/3NL9X0Q5OzPrfcPbuDMej9Ig0v19KCCs8Q+5zX+E1Fe50kn0OWO2P+7vT9F8qEYTeZkPJd7EBAPkuNmD/8x+0H5aL0XPOcN7UkBJnVwAwOrwYM2yzMzq8GOPzNGNMwWVkfbCdcZ/iRx5TdmVj80X1K0j/aRGoG6B5H650RPDoxAK5f1OCZbVB3J/Sjgtv3tBAmMmEfA0o3mArIBGAAau6E3A5v0YBkDJ07adfwkD46p+pHI/Zw53ASelyv6pmPmR72CFd7pUSSn16L/MbsO/zAVMLO6X1FppOJWC1P29nf2Kh6VRZ2bu6I2m1x5Fz815QsdZ8LHJ5ULhGOfrUKkJOu2e877WBd3VHyq5dcugtYVbytqKbxt9U9u8/6ydgMNeRN3kj8D/3WG2w0aCdA2hxyQmsqgDw4vxritQvhJdXF65Gxu8+fHRiAfucHGjr4kZpmzFy5e1LluJOqQ6UmGNC6ZASZJ6wmgX3DHm5YAT3CxYifFw5Bi/Lw9xB9cl+0oejufyxNpcfHlpZblL7fTp2tcQ0eEnG7Sw03MPjScUICLRK19sOfRhJ+Y8Nf1mbgJQJ9y0Jqq+dqKcGB9u7UshzCrbXAnm6bDN6PnMRbyk3DPxnRWBrDRem7PDj4uBLauvVda5D6fcHcdx7gFmmrjjP3gfA4IltqZnrtuyBX9zPhKM6JXhU+ClPJ8TnWrGsNoi+I/tgcnsqkzbosWdDCBPmXmfULIkn3O5DgbK6zwvXJU/DunL31/TwJ6TP/IkU2NsqXYVAp4455TLFMLrDDAwC0t82seJuXyZE9eFM94yP2quK7GPrs+iSJ2ceRKXrfe/4juVOK0kcw7Vva3Ij9MVfZyEpdjWW0yj/co0CAHBx8CXcJ+elstFZJgU5suDwFMaFWlC0TmW5eiPXvWR1+zZyAgBQ3A2CQoJZOnQOVbO1ZtOh8wCc8ljIokmleOLTiic+rdCptobr+nNl11lZbkqSAIDESOh/ejmLs3zRXDmF6NQxZ0kZX75mEvlfc3saiK/S/J7KyFnOn8j8bhlyb225Zr6dNZ6pv1tSE3Vm5Jf9rG468J8TAbsay1mQP+n/IbmPuTLBYS0jTRcyfNBECt3xkBv2AwqfAWyHS4xWlbc8xCRXDL1a1gfg5gP5KUibQstlU4CkPvwJOZBjO1l7O9Ch5r+U+q585SOlXCtTkZozHvDB4TzXrrSj/NL86WYHSIyjzhVq9riZIffWFsFis2w1ID3pv/QTTovHMSisNpnvq34x/KemA8kVgMQYtDZjqb3yRKAWuUeSudRnPu2UDMm3zezA5vKSQBNrj1WjTVR5pdeNmvUYd4O2KRKAxHge781et4AU2wq8+5RHd28FjEJ7YDujJ4XqweLm8eGyLQb141BMmdTocrL41e0CTVbroj/1Wobdf3TQdK4aHuXG9+vJmw4IguAqCEKoIAh3E5QZCIJwQhCEh3H/5o0rFwRBWCEIwiNBEPwFQfhlUtCklgAAmDXNqzYuocX6ydz69J1bn76zc0YJsncdiWnh4lwsWpzAx23xLHicsk6tWNcth+zIv+MCutn7pEr/pPRospFd23zYfteKQa9PUaGeGSWn5WL0U0906sjHxNOpY453n/J49ynPtZ/7uPZzHzoLe+N5yp/jG87ie8WPg0+H07OnIZ/Cv7D6whxu13oKwPNiXqna76RS+usoPnz5Zf7UFFh5RLlnYHohXWlQhcaRgCAI9YFPgIcoihXiyhYAEaIozhMEYRyQVxTFsYIgtACGAC2AmsByURRraupkWo8EUlMApEQ2dWRvP+Vvvwtv3hCzpC+fry2lXD3JppcTR6cDYNNsKvt3uPMo8hAzWshHd+vb5wh96ylOKVKDpvaVGLpnN3OHSNan772dx0PL3rydfIvgTx+4YF0AAP3w8uh90JyVqdy0wcxrPZ4qxTLTcaNql9T0Qu/DB85W25XR3VBKrwm7+LRB+QgwvWgQZpn8kYAoiueBiETFbQHpuHUT0C5BuYcowRfIIwhCoWT1OpXYNToao53HU73d3MdcsXaYpvTc1SnVKZY9My+iozlxdLpMAEAiBjlyPSPHwUaUe1qTPBXit5Dmu7A21fsppWe3GtRcaiX7vMSgEJ7Lc3PCqAEPi7el4ONaFHxcSysBALg/zZl21U149CnjBQDg3deMCc2lDe53nmR0F9SSXMNgAVEUX8f9/AYoEPezCfAiQb2QuLIMYdfoaC47dWaM08M0ab/LHHMFj8It3seYWCBE7sFXRumBocz8FMnR/VcZ42/PtRAUlgdTkx5NNrLUdA3jV+6k9fl/eOXbIlXa3eO1hZa6afP7TQob3j3h5GbfjO6GAnd2vqLiyvCM7oZaUrw6IErmE0m2LgqC0E8QBD9BEPwifqT+LymtBQAky4cJA5RaVhvEvk32LDzmr+YqeV5ER/N9gwNV+69MVaOgMmbXacVls3dki7yp9RtfEwea/xrpx4dWWI+9//yM7oYCGbUykBSSKwJvpcP8uH9D48pfAkUS1CscV6aAKIrrRFE0F0XR3CBz6oaESg8BkCINULq47DtO+rtR703SsxnV7tufe755OevTK7W7p0BQ8dT1s9fdPZrHrX+NP/LdFTdndBcUOFD3Z0Z3QSPJFYH9gPQvthewL0G5XdwqQS0gMsG0IV1ITwEAiW0AoEfH4bhWS/5w9LDtOhpOUh0551fl/jRn7Cmc0d3AyD+YT7mzkH1s/Yzuihztv6Tuik9aoM0S4TbABzAVBCFEEITewDzARhCEh0DjuM8Ah4EnwCNgPZCuC7cGcx3TVQCkLO5nwo6TKbPqlx4YygH/2FTqUfqx4bUFp8IzPq3Woq0nKZdTYlj9VYSgyWpdfvx4lNHd0Ig2qwNdRVEsJIpiFlEUC4uiuFEUxXBRFK1FUSwjimJjURQj4uqKoig6iaJYShTFiqIo+qX9V5BgMNcR+65v010AAKoNb50q7Zx+qJvmUwLTwROJzhOZau29bXqMrJczfoXg5L2nlDwev0SY0UIwt8hcDvSo+sunIIM/xG04IwUAUi8ASY3HJ9DX7Z8qbaminedhjGulToDSDa8tuHnBlWn5N3Gt+CTyuY/OkJUCI/9gVo2vwZMmHfky/zwXzbvwZf557B4tSfe+AJw6ac+IgIPcCJP4ZEgzDv2q/PYikNECALDZPHUSl9Tu25/xx9PGWUjK/A83iTzalXLTBqeona0vPDn7dT136h7A5Oh9TI7e53atp6y/MT5dhcDIP5ji/W1xEQ9y/1N/Tm725cOXapzc7IudT20abqmI307FIK1pxd1n8/E43UomACDJOPQr89uKwOrgOuwaHU2r3ZU1V05jtngfS7W25q9J22WuGcVciM4TyfVls5M9Ldj6wpPuXU9wrfUwoswVndCm5d+ULkJg5B+M+G0lHRZVBODnR8WNRBN/rudj1t7pIgbZx9ZH+J6XAX1DFM7drag+GUlG8tuIgMFcR9mDv2t0NPlcJF6AzdDJ0FFAatPBsi+TV+5Ik7Y7drWkZ7cW2NYykR02YeeSJAYbXltwf/JQykY+UyoAACZH76f5iKDecPhcNA+jvmru+8+PN9NcDN6Y7mfR9dp8zByT6m2nNb+FCBjMdWRdxErZg/8no1O0He0D66V6u33mT+StxXeO+emQx/Sl7CgwswrLXNuTu9k2jW2UmzYYT88deF2vpFIAEpJWQvDotTmHOu9l0r2kLakmFoPU4o3pfkxyh1J1sTu5fuiyZn1hqhntJFf1+G0zv7Jd4LcQgYjxrvQzGMI7pyYK5/x2/tpZeJLKiaPTGVeik+aKSaD15y70eRzCntxvlJ4PPLeH1qYtKBMscffYe/0lRf0/c2ljIdlx/GUHtl2YQuFOkVoJQEKee7twM8CSKl0fs+JuXyKv2+Eaq3FfmQwj/2Cq1nBm6MNIzC1rMmyjCy7iwST1ISFSMUjJqODVqRWcOmlPZosNXLn8ht1HfhJWeAaP8sL/RkZwvtc/XPkSxIGvXhz46oVXbKlfdkqgo7nKr0HEeFcGFgcDA0dmdw36o0cF9WY24TipEzjU83hvhqzZRulaBhrrmg7ozvT1a3CrcYLv86czMSJBSvGtPgBs+bqEsn6qpwKJedk2E6eLZYNrvRleDPCsyR7g+cTpVMn7mKGbu8lSk7nG1qT+ux9kvewAQO7iknK3QscxbvuWx173Ob34DI0dhkFD7X8Hqpj4cz2ZslYFsjG3yFycLpQDIP/qpTxp0hEAY+uhsvqvTq0gPKIjWQZloWX121z7UZvdR5R7BMasN8eQbxgi+S6PgPu6ulBxp1yk4V+B32IkkBCJGFxSOirIKKRxB1OLh1Xmaa6kJXvdAnjYSrMAANSImEGXurf4Pl/15ien82OpftdSq/Yq+5ag3XsrpeeKV5nK8GJnmFwkikevzZnWrAiffbuit/cYE9xfkSW0C9aDg7AeHITd53Zy17Z3tdHq/trw8+NN7B4toUB4Iawu69DWrzWrVjpytHUu7rncxWPGTu7ne8eoWm7Uq36bJ40OEnR/D0t+aD+SkXIyyyNcl6xJ9xHB6KDp3CwRrPL8bx9ZaGsNFxrlX57KPdIevd5uPDxYmjZ+qRevIGxXO6LeGqV4Q1Ep/WzkuZSXY37aDfg2ulvRKqqSWhEAcHfITu3RXdXWqexbgu57FlGl/HqN941u9Qmf+e9Unj8y9Qu1jkpi53/sU58Wj5VHdUoumXJVxWb2ZioPLyBXnjtrc3raeWL4QnV8vuRQzsGVNtHN0mREMDpI8n+XMJBIbavRfLjtyouAqD8z2nBG+wlUMvRggGsEDi3yJGvzUGLKWk3CL3wfj02/k6dh3WQJgefx3gAMWbNN61EAQItRB1i3XfN2ZstGL5jzaGv8ddO+YjGon+xzGZuyXC8hsqWeC5aDXZjdS/2mpea5FjPSR3XiTpAIQWjeaBa8SRvX6oL1zzHk2kgivx0B0k4ApEw/VggXy8csqpl6oxqzgZV4XcsCnVLlKTMp3v7zuM5qviyI5efzn39mtOGI8a6U4QMLXNI/xl1Irmwc1SmB4fiULwt9/liMiMirVA7vgW8fR97V649u9j5auRF7Hu/NtYGDaGpfiYmXDrJspSvtLubAu0952kdql5n2Q5AJl7Ymjh2jSPfn9mxyniL73CtHY7rvWcTWCzNlx1ndR2ypJxkZ+Tg7EXxL9cii87/vOGz/XuN9m0/PTv73euxxPKHFt0k6Qy568ryxxFszd9bmTNg6KM0EAGBq09cE/pOHGZc1R7xWx+ig6ZgNrERtq9GEGzyh7agnZDoyVZaIVJsU5b+NYVAdA4tfYtfoaBak8+ahij4zWNPpAv97epy2jqe5s6Ip48+3TPJuwrJWkyhkvZaJuS6RcHf+7U8+PL9VnNafd8vVt72gR48mG7k2cBB7e7Rg2TwBj3+uszQ3cMCY7v9ch2+OcB7u5xuu9t4fgkyoETGDcUGbObCgL1mqDNA4HUgqbZcU5naiBMU3endi2QqBOz5NaPb6EKe0aKf59Oz03e9AWFjqvT2lTPy5nqPNArk+SiIAMevNNV+UQgxffONVXz+Crj6m/r5BlLo0kA/lj9FyuHxWpUv9P1H23nWudgyTleUJbArAY4/VYADhcQ/7kX5Xk9yPP0IEADou1GN/pyZA+oiAXm839t3KzACP1+yzc2RcgCNbGsOa0lD08E22VBuvcXrw+WMxPos78fkynOu5lO+FNzU9RpsR2eQL90jm++XzZeK59KFXwbl3y9jf7jj11+2hRoQkJ57OuIP4rLtK0JotXLAugMnF7WwGyNeAGbfWEOzsTKPBg6kwMn6Ec3exLt2f2+Ph1ozQEvHf693YQ7Bnkdw9bduuBOJHZvtGhFC8iuTBL1H1NRc6NGbqvcLcsYYN922Y9HMXkDF+/gkxfPmG4Q1dU2XlQVti1pvjFTcQkr61PTwWytXZmHcFe66bEDLghyyLcbgWb3ht+e1tAolJi6CiidHr7cYFUxc+eQ1VWWeWqSuH9oDlg/jh+KPV+THpnoObXhOw3/KCgJelOT1Y9VD4+a3itAk4q/Sc09EsuNtqt+Nwy7mvdHtehv4O8W/Q3t83sdhtqdL6Rq/2kNMwO7XuS7L62Ftex92nOobdF9IhQhI5t5hfC3bbT2biahtmrpDPCvzOOICslx0IL+/JvhEhRKyUBaqWvP2t5Vd2llq7M9czH6MPaxaCBoscCAtLvdUTKVLjoKolv7QkvEhWlgQEUn9f2u28/6NtAok5+L/baWof0EYAACYFOeJj5kjRVzf5/LEYy08/YdPor+wMHcCjhhH4he9TKwCVc1piaqp6T4JLs+8Uzeqa7O8R9LCEynNhxu2ZtTM+ZZa7T3X0Z7nJBADgmflhqt+1ZNzGk3hXlmygWvXQgHfGktgCbXY1UxAAVei7bOFo23801jsy9Qvr26RNirVc3zZi7aD+/zStMHzxDa/YUhlyb/gDRSBivCvu2wqkiRBoKwAJGT5oIpXb9CRvUS/K3Bqn9XUHLr7GdE82zRW1xOq8/DxfP1x9COzZBvK+AE/3Km5sWpUliMq+JbjVwIGpMzbTqcFFOo7wouMI1XkIvkyKH6VtuG/DUmt3ytU1xKVDMRa2UL2KsGfzaELzRpPtnHKvx5SQKVdVToyIxKnzslRvW1sG33Kk1KWBmiumAX+cCEDaCEFyBEBK4+7dk3yNulGAlB1B2rm8ripkTdHonQQ51JUdOqKV2muim9XG3vK67DDyu0+favH3u17Bh66l8vA0dxHmjPrGqQczAdi1xFZWZ/1tfaptlHeMGfdxENP3hLDhvg3l6hpyt0kv3EZL9i209mihIARHpn6h2G4Xjs8Q8HWZz7wFoTgJrbT63trSqG02zkyYmaptJpUJWwdRZ23ODLn3HykCIBGCsE6p41WYEgEAuFzASuYF2CqfNa3yWRN7cSN5hyp/Y1bLVRevetEa2z2cSbPXWp0HdWlZMBcARaN3yo6D7e/Ts9x3pdfoxg4l0/d1NJ10QHZsOzSNPtMmsSpLEKuyBFFz9hCe5pbElJ2wKCvWZSdT690uDodXBWB/x6McPJWbiZuWcKGbxOg5L9cq5uVaxa5cARjPqk7H88rzLDQoGSI7QvNG02LsM7nzXU8XSrWlwky5quIxY2eGjgKkaMoUlFb8MasDyjj4v9v46DliXLgeVatu0CoLcUL0ersRlT83F/LOSbYAABzrFsCxW+tolU9+Plvq4wraf3zMsyUXEl2hz5lb2SDRspoUp6NZsPG0ocWKNtjdq87Zqk48/6aYFlwqAIEDFNuIsQ6hw5vMHDkdREx++chI4953oE2Fp6iL1HBl4kpKRpbkae4inIkI4+KKnjz+Dr34SnTblYSXl/j9HzyVG9dNW3DjKGtLtZdc7PaK7JRj7JA9cEDeuFmhxhwO3g9LfDs5JkSUY9y5N/BYbTWtaHHZBq8xmv0U0pqY9eY0bKufIff+Y0cCIBkNtGwtMVrdvNkHvd5uRDaVPCx1netQ17mO0usimzpiP/M9I7KMIMi6VYoEAKCe+VIFAQCwKHyK3YcClV6jLMxYF8+NTPp8kQEWKym1og0Ag3QF2bRgy7mvskOdAGhiXl5vClUpRImR3hyb1ZquLafRteU0aleMH1ldCTLgic4TJizKykXPB3LXLzYbjmFgD/k2cylOXT4Obpz0zqUimXJV5Zard4b2QYpuXz+qb96tuWIa8EePBABqd65CwgVD48L1yNbal4DWEvU3wEzhmpBzW2jYbw2PTixIlT6YhB5QWn6/YCFKB9VSem7v+RDaJCozNBqA7eeVSus3yDccr8nxU4hnB19qFIAaETM4ki+GoRRXOFfi0CH2Fq3GecfZMExSpv+oNa1vlafuuTqMtVzKlSAD5oz6xg/1t1FJPe+TPJm0BZ998TtCv5SejOyGgJjNXeG6OQb3sYt8h/rxgmZyfdvI0BmjcEphO6mFkOey5kppwB89EgDJlOBVSPxwO1voQjW1JVRqUIp/3TfTf2sMW3cV0Fg/OejU7U3X7MoFAJQbBsPD1ii1A6yKEfEqL29DGBzbVO39j/npsMSgEKcqDUE3VLl3jLjwJEX045cFJ5c+wMUqgfQvVoYbFSU+fhMWZVV6bfcL8Y9WK+vI+KlAIoxnVcfJ+5nsaN8z/v8neNE+phbITi2nsYDk4R83Jj/vNndOka9AplxVmZ2pb4avCPwq/PEiEDHeleubJXMtbQQgIZUalKL/1hjyze+SrHsPDoZ5Zj3YOUNxTX5kBSOuKYaiSxYeSjwGT19rq7K+15ZiLDoYyCvfFuh9yK1gE5BSp5sBtwr/j4DlE2Vlk0sfwHWUGdY52nGj4ilWXJIfbpTKMgPffB2JevsYh5meOMz0VNv3V5Pk+269diPDpy8neJFke/b0t18Qs7lTy2ks7zZ3psXjniq3EmfKVZXGPWvR6u4YGveshYflZTLlqiox/llepnHPWhTIXpT8VZYxqUB1JhXKp7Zv6cmLo7U5tCxjpiZ/nMegMlYH16H30eT/h/ufe0zopIpJsg0U3NUWt1avmN7BGE/q09LwHyyt4/cUZB5/nMrbOipcV6MwjPG3B6Co6zK5czrrS/NDnMmdiDVy5SO/Z8e7j/y6f7BpJ+qPrI7tDPltt7qnCuP4xlWWkHRboA26seq/19qsddmUOTsAJdqNlfkMTPr0lp8ltjNu1k7GBHgxMmAZXvuGKFyvX6AUVZ0iKVFVPhnVMAdjLPxscPKWt/4/yveF6W+/KLTjFn1X7QjAzPgqOUsVkSuLaZqZsOOBvH0YyFUHU7lzJn1Lk9sp442CAC9snxDQOu38BNR5DP7xNoHUoFKDUoS9n8AtLVcJCu5qi8X6yYwdtQjbCyNovcwPXzt9LBNkZXw+vh01WsT/+kM716OK82Oq73Eh1F/y5g3dU1uh7fBKBWm7ZDL+RUMI1GvPsXmt8R6o6PhTPGgn0w5KBED3lCRNmNubzFxgvVxGYqNXe4jJr/l3MOlTXJQhT/l1/ExPu1BjiSmPracoFQCAqLePMRhiBRcTiYDJQpzGl5Ura7bvHs59kuc9V/L4LkIH/itXds9lN1frmgKmyi/6VfiSrsm65NAmDVkRQRDOCIIQIAjCPUEQhsWVGwiCcEIQhIdx/+aNKxcEQVghCMIjQRD8BUGoltZfIj0wujuJKu8nkNN2hdp6UgFoOCp+jn5yyxYFb0GTXDFMORzLzeA9tN6zhzH/hNNkdR4M/ScmblIOQ/+JXGw8heOztrFgwg0yGfjTYYPyFQaQCMD9NpbcDZhNjYgZ5F+jS5RhIFGGgWqnAkmh0/U5MtdhZegXkDzU/R/vkTuinBSdqEYfXqJ0FJBcEr/9f0V0+/rRMEBp3t50QZuRQCwwUhTFG4Ig6APXBUE4AdgDp0RRnCcIwjhgHDAWaI5kC1kZoCawOu7f3x6JEMxSOSIYHAwtW71i7Cj5XXVOUxxpVV3Rlv38WiWWX1P/0KuilkcUtZgImGH2uhOdLj+VMw4Gm3aCxctwOzcXS/bLyu1vLIcbkp/dqw1DN7xhqgiBKvQLlOLTJWcitvZk3Ef5t53rLAELv2Jy04EjU7/wlqRvAJudqS9bmvQl/FpNBIvNFBXLcu3RPn75EQASe8D50ZqDuaQV2uQifC2K4o24n6OAQMAEaAtIw95sAtrF/dwW8IjLS+gL5JGmMf8TSDgiGBwMbT1ec/XiMzwcr1O4RQ+mdzCWq996mR9hbaoqtLPUJPX2xLuO3cnO2iWwDdSTlZnNlx8d6Iw7KNtCLD3sbywndloJlasDIHEc6jHLXmMfOh9QfKtLBaDeVuXhwIYPFdk4VqDZvnuy40vpyUwtkF3j/RIyO1NfznS/g7H1UCp2MqZCsbHkX730txgFAMTUvk+4wZMMu3+SVgcEQSgOVAWuAAUSpB1/A0jX0kyAFwkuC4krS9xWP0EQ/ARB8Iv4EZ7UfmcoRncn8clrKD2MrAg1P8Iwg1OsHnWbfbsaUbuvvJPPlmU7FKYCS01sqOURRWpRyyNKTgiCTTvhrHOMaa8k7roJH/yE+Ky7SpBDXcYdmKvQ5rj3HZg6szPBrSdTYqQ3a+6/Z0uPJczKqXzJtL1LY7l9A5oEQBWPtv1gze3euC20VThnG664I1EqAIl50qQjFm6pkx4uzclAewAkQQQEQcgJeAPDRVH8mPCcKFliSNIygyiK60RRNBdF0dwgs2FSLs1w/M89xsPxOv8+t1M451P2DWcW6ZGjxr+ULlaaauJuLlWsyFITGw6+O5XqAiBFKgS+VyUPnVQAEq8OKOPsZnnvvktbIzCtMgDjma9oeHUwM3NE0bJqcep7T+fE9C4yQZDyrMIRnpkfxnnAdZkQaCsAS63dFcruXptAq3JLyJ1TsmNQ+GqP8NWeO7sa4iS0wshIIqqZclVlYdbkW9QtVlol+9rUQrevH2cepP7fQ1LQanVAEIQsSARgiyiKUt/Gt4IgFBJF8XXccD80rvwlkHCdpnBc2R/FK9+lsKuR0nMD9w3EJHSv7PODEhMxc96D4YeJGPqnXZ9qeURxDEf2zdxK/Q/aXXO2/lRsL45mgxjvn7jYyIVvr5WHGPOc5A5Vi4P3dC7fOU6WCYeoOfsRAYFWVIq14DxwbtR09uw8IzU9qGX+yvb8zKs8x0L7ngvZtCwcX5f4bcx3djXEDKjYsRU1/3HBo3Ty36J7sm/gzI7hGeow9OJobcxGV9JcMQ3RZnVAADYCgaIoJgz9sh+Q7v7oBexLUG4Xt0pQC4hMMG34I6jUoBTLZqhW7/073BXKukeoj7ibmgR1ek5YfomTjtcU5WHL1PGsyUIq5lMfPPXQzWC+7D5MzdlDeDf2kFxGoakzNrPxSx/Z7sHkcmTqFzkBSEjX0/JmplenVsgdmQYV18om8Lir+tDpaU1G2wNAu+lAHaAn0EgQhFtxRwtgHmAjCMJDoHHcZ4DDwBMkSVfWAxk74ckAyhaSXwm4IfyPK5n2q6id+tSf/43Br+O3IOYxVT0Q6+9gw4bv8rsUVojBrCihOmrR5M/6GHZfSOP2kvTmXdfLr+tPn9KTQMdgdu53p9rGnQoxBaTMy7WKlgdyqbzPvM2qdwfUbSjJZ2D3SPJeyjSoOOERHWVH2HHVy6a/FBlsDwDtVgcuiqIoiKJYSRTFKnHHYVEUw0VRtBZFsYwoio1FUYyIqy+KougkimIpURQriqLol/ZfI33xP/eY4VO03/b5eLpiyuy0pJZHFGtnXWKasWROri7seO/vyvMa3C49RuU1mTqU5MuqooAk0GhC12H/DlcplWWG7PPyU19YfuqLUiHIPsuJA3aqc0k6jFYeb6FixzPMzhQfl1lZPkHxqnYGyeAm2mVTSisy0j9Ayh+/dyCjSe9RgJRaQ0/i2EqyKON2TtH6D2DZz0JprMFx7xyI6VaZrIXkg1z0mGXPpszZ6VGpGr1yxG8DTjgVmD4l/uE7HF6VtoaS4bwyIUgccDQhow8vQfhqr/Scl2EFitR0kH1eUTV5zkXhJtrlZPjT+U+IgE+nzqneZvbB6mP0SUnvUYCU5ZsmMn9HfOQgh4LyG34t+1kwyuE9By/KOz0NFYpzz0GXrWHjKTu3OnMOWnLGwpnJn/XxcGuGqWlveg2ewabPJ7kycSVVPB3wzuWJf4erdLhtKjcKmPFzIj3cChAasoq2hvMJvjUd7/qWXOi2GdF7Eb3nq15QalAyRMEeULHjGSp2PMP6Nta8uOImd+7nqmC5zwdHbKL9lz6yQ0r7L30INymISd/SVGqRE7dWuRmR+Yr6X2YaEV4kK1GPlUd8Tk/+ExuI3rQsi0FrxbgBKcFcPz+H9iiWr9/ejj7XHbDf8oKXlaezo0GWVL1vUnCfGkBZPRumvdqM7YyePNeT5L5zrzaMC9YFOHhxqJw94NWHkbQ+ojx34MpVzzlrJDk3NWi8rPzltszUahMh20SkiimZZst+fpRtERN31lKZeWjUq+6E5pV4P/q6zGeOwX22NXpNy5KS5Ue7yHv8G6HoW7Iw60Dq+m3nkE1JTLoq7hjdUOoglVooxvFzOBiJtcPQdF0l0O3rR+PvpZlSbXy6GAb/UyHHE7M6uA6RTR35mn90qrXpZPKaN8ccGbioMkuLxhvgYj/a0+e6ZJjq3r2IqsvTjbUXP1Ls5h5sZ/TEa0sxYue1YsG6vtyqYoV+eHn6FLpKnyySqcpQobhKAQAwbToHV+/zTA0az8ttmWUHgO9+A7xzqd8yPOOnxD3azaEyy1YIDAyKooV7Xo3fQRpLICFhYfOYnNNP4fiYtbcspfie7Bs0ti3FrVVuTrmp3xOSmuj29SModBJXPH4Nc9kfLwLtnVRnu00q/uce42TymvYlS+E+dgWDoi9RK+dZWraHpUU9MH8gb5G2OJGxe6d8TtUiqPgInqzcJMs+tDFLfEy/6DyR9Cl0laFCcY15CN1rFgOQPfiJeVpMvYFrSqbZuDlU5tLB+KVVbYVgf9f4of/XBgXJlEvRDRtg5idzwiM6UqN0WyzcgpIsBOk1LSga65/hDkIJ+aNFwK7GcllMwVchF1I0GvA/95i13XRpX1J+OSyn7QrmVflEu6O5U9TXtCL4k3xexLVuJ4gyjBer6DyRjHvfIfFlCkxo5cPlO8dVnvdycOXx9ylKzykTACkDg6KIeaI5H0PX04Wwi7xHh12qVy0ABAuJb4IyIVA2FUhIWq8U6Pb1o5yDKxN8N8pSiLcc3iHD8g1I+aNFIHE6slchF3j6TXVIL1WoEoCEvOm4jxy5nqk8nxH42ulztqp8BL26La6TNyz+j25boA39e6i3rh9/PEAWVEQVxY2j5YyCCWlheFOpAEg5tX4RNzz6ck7/LDFPxrHIeItcbEFfl/lsa/Qa2/C7HMw3Au+OSYv9uCf7BvZk34D/4U9Jui410e3rh/FZBzkBkPKhvOYcE2nJHysCq4Ml0YRzH3Ml9zFX1ra5IDvGNftOxIEAnn6rpXF0oI0AgGRE4FM29bPjpITBy4/RoOMuubKLh6sDoCNaEWUYyIbvbVjrmbRde8qIMldqc5KNDqTbiNeWak/Hj4pG2peBbnwc3JhT6xdxYLwOBd5IxCv6bTMqdozf6nzoiRcn3ZbLicHMT6ozCCfcRGT48o1GIRiR+QouO4arrZMUwotk5YXtE4rG+mN7Yy93K+6kV0ezDMsxoIw/cnVgdXAdcnfqht9O1Y4oCRnj9JDIppL8BNI4hP7nJEHttREAKdYtO1Eq100ur5ck1bC52ydDVwdOj6/L0/FPea7Xidh5rbh4uDpXe7wi1Cf+TfreaDVWPT3puXsmr7ord/Nt2+McZbO50MhH+fmX9mcpUcacHa230OF2vKvu1Bnx9Qt0HYbXviFcXraDHmPUxwt4/sCEwCPHGK5XnLHX3NXWXa3/Evd/JO3Ne6ZDROnPALx9KJnyKHMdDjcpKDc1cDgYSfHjPgr1Sm3blqwVA92+fszptoo1HnWZU2EU7ncUrf8u77vQ90hXqofXxdTCjtpWo2VZidMCdasDf5QIGMx1ZF3ESr6ddddaABIzxukhIbmysbabLt06vuXzDcUQX+qYdOcq2ZZLvNlGHbhD6Q+lk9WPlDKs12zWumbFJXoZXluKUSNiBp47SnG38jSl9Y+cPohuwaE4Td9Gk1LxMQy7Gc3l2IWvPJl2RqlNQCoAlhM+cidwEsPbKh8RSNl5tTw1m3xUeT6X80l2/pA48SybOgyzzCvkRgKJWa3/klzfNgJQ128718y3I1hsVhpTMCEmfUurfPgTo0oMdPtKrPsx680JL5KVmNr3sdE9S+wSR8z+/aCx3YT4rsjK5bHH00wI/hNLhAZzHWm1uzKXnTonWwAAFriUofDHr7wweZKscOMbjsdnOQpoGZDsfqSUqsXb4xK9DJDsHbh4uDqhA1RvCpqXL94Cf/zxAI4/lrgCT2jlg+OiAGblLCCXfOS0ZU82TJvF+n21tRYAkGQkUsdcT/mAsDVHFODOLtVBTwyyNk2Wx6C2AgCSTUbSacL0Y4W48s4No5ApGC8wR3fqfso5uHJueE6cchhQVvxfkgUAoNbQbzQ7ORnDiJJJvjal/BEiYDDXEefd1THaqdp6nRQWuJTBzMCCJd+XaK6cgE9eQ1lpZCT7fKamL5W3PEyVPiWVvn2OyH7+ECRxH86/Rpf8lsqt6+PeOeA0fZtc2fHHA1jWTZcS7SRr9bNyFuDp/Lv08J4rCzs+e6AkJ2BC12F16Of9Tg1vZ6XnprYvTIUacwDJKEAadrzmiALoFTiq9BqP3PEpzb/MPw9AUbGs0roJ0VYAEvK4a1eaVZvDS4+RrPNyZoGrAeu8nCkr/k/pkD+pmNW5wKRRtdJdCH57Edg1Ohrn3dVT9PZXxdRqc1jxNfmJLxt37072riNTsUfaMazXbDI7j8NrymZZpGGA4jnzkH+NrkL9WOEsJ04qj3nfuVQenM5LRKBEu7FMLh2fTWly6QM8yF0M189f8O9wVen1idl5TnksvantC7PhvnzItYQBR8Vs7kpHBIeeeMlciF+dWkENvy48u6ZekFKyZ6B0NfnIUanx8Ccka7e2FDj1lLez028l47cXgZTM/7XBfXJeclTTPj3UiaPxyz8HhpszsWcfNbVTH187fdwmPuPNg13seCZZlstj+hKr88qDhABUHz5RNvxXxrEBpXn0KYucAEiZXPoA3bvk0apv06f05Ku7RGyko4Gp7QtjUt5BJgCtTfviHFOO4dOXK1xfy2msLI6Al2EFXMSDrNZ/SZGaDhgbxAKSsGI1/LpQo7Tq5CtLfyY3cRpsXzyIMY4Sx6rUFgApTnm3s6vmIc63XZUuPgS/hGGwcpk84rGlVirPR4xXvrddOg1ISxEAmH5jAhdMtYuA27ZvXszForLPOWr8y2lDB253L5NW3ZOj6VhXnvVag+9EiZvuEbs57MktWbp8O/kWV3u8Urgm1GcBZS5cJpuzcm/AHY8/MHv3ZsyGzVZ6/sm0M4zZ0kHjaGCEnTOFz/ZkvpvECNzCc57C21/KhNzDyddaITQlADHPt2OcKHbtloJ95T6HR3QkNO8EQH6FINykIHuOKo9kpC2H7e5RVvxfitrQlnIxMVi3cdBcUQO/vWHQYK4jBnMVU2+vi1iZ5gIASZsWPDH+rrlSGuFrp49Pb1+ZACQm+NMHpeX5LcfwvFIO2apAk1JraFJqDe41i7F6QhRlRgeoFABtmD6lJyVn98F1vXz2IFUCADC+xzuZr0Bi9AocZXLOeL/7hNuKpdTw60L+93MoUKY8rS9movXFTFi4BaVoFCDlRIxVitvQlvu6umk+NfgtREBKYjHYf1Z73/CUos204JPXUHaXUL1HPq05PzYrxrG3ZJ8DLAfJRgEAc4d0Unlt7mbbOPX5Afa+0Rhv6Ynxlp5MjPDh/LQyLNiu+a3nqKPod+858ykFug6jwaKp7NywnlPlXnB7YFMKDdacT1jfZQvdTurKgo0mRMzmzsF8ysO1lTy+i5LHdxG8dxT5Jvlh1KS87PjH6X+4tUq5e7eN7tkUt5EUdtU8RPN1Fpxs7cTnm6qndcnlt0xDZjDXUeUUIa1Y4FKG/WJ+PjavifuR8wrnP3kNxTLAlXz/VmLGTiNuek1g4tJVbDZ0YO2xatQibTeMDOs1m/dXQvE9oDz46YcgE3qjepcgwP1pzlApfnvvaWdnaKj+9zzzUWsy+a+nYnl3ufLXXj0oPPcH+gWWyTIQAQxd5wP04VN5Z+pq3rJA9kcziSyofComGw3c88P9HxfmPZP8OQfvHaWyPYuVVjBU814FdQywu8jpTekzHZBypN9VnmbeSNXpULpAZoa/ek2j2Py0bH+II/3ip2HN11kovX53TLDKtn+rkUBCDOY60iydNayNEErIBBVLVY7XyfdvJUy65wCgqu0cXuZvzdpjkp2EvnbahyNLDr4rGrMikQBIw44D1IiYIbeDMDFBD0tQ1P+zXJlp0zmM6bJbxRUSsgaGkRn5OfadwEn45uso9/AnZt84gZeBbirPA0Q5dVcaZ/DKkre0eCwfPsz+npNsBKCOl9tSb0t5enJqf/zv6tHbtgzOPACzbP/j6eGNtOo/i1b9Z3GytRNPD29UeuQwzqOy7d9WBACyWtmn+z3HNftO/lmSZBefvIbKjhkzOsoEQIp79yJyOQbSSgjyt7dg9dFDCuXTjHvS1DyWMj4buXi4OmvdTpB/ja6CGIT6LMB3RxGFjUQ7Hn9Af5YbMx+1lh0JmfmoNSOOj6Pos/hEIXcCJxF53Y6OI1QHGAHofsGJet4n1dapcfuozFdAivDVnnFj8itsJ1a3f0CuTTWrBr8y/ntP4PxjjdJzj962lQlDcvitReCdU8bMv7fOLconr6HMM+vBPLMe+H6yoo2fdqsHqSkElta+OPUOYH3l7xSoa8nuwh2oNVtiwGtUYx+DY5vi4twUnXEHZdcUz5lHQQw238/CPQdF/wEpT/fOp7vnCLp7jsBxUQCeHcYz/4Al45b3YazlUravG4fr5y80NJA4SjVYNFXtKEBK/8dKQjPFEeXUnTEV7GWfryx5S8zz7VjpuSmMAkC5cVAZmnwIflWydmvL4tbX0qTt31oEJm4zxbxTC80VU5kxTg+5evEZVldDsLoaAsB+cydebpEfTle1nUPNn20Urk8NIag39R+qPq7DhBnPMO8r8bJrOu4AFr6WNKoh//Yst1/RO654zjyMX7mTyKNd0Y1Vnm5944kwJpc+EJ+WHHjS1JQbHXx4G5WNsZaS+HhXggyI7PmWNo2uY1b+rFw6MnX0GONCubqGctmJo5y6U66uITt/FGS4XnEAphbIzhyD+7LwYsrwKD1C41QgteiwZlK63CcxRgfHU7rAPs0Vk8hvLQKQMVMCgMv+8uG0PPMUY05NRXfPLQbKXY+TKwS+dvrUWhBK7/NNmXjpoML5HUGrOH1Nfshb7GGIUmeh0AEx1Ho+ixViMCUOyU8nXnXfzJuoIwrXNA9Wnz33ysSV1Hq3i6i3j7X5OoBk2D/p5y7eX/pJbLfNjKlgLxMAKfvsG3A2WvK2VxVZKL1I79UBKbWGfmP/85QvcSbmtxeBfgZDMmQ0oIy+XfYypVNuuRGBqk1EZW6NY8PVgWy4OpBhvWZjae2LpbWvSnGQPvxNJnVlfExTbDyVr7HXKuGnMBIYHNuUwHOKQ+9XvvG/txVisCyugHstPboZzWVHpdecm69NMrF4oswFpmSaza4ltmqF4NMlZ3blCuDU+kWcWr+IgUFRLGwhWfZbNnWYQv2pBbIzpeh2cm2IX5n5+fGm7NCGsOOBHByxKcNzDaSETEdSPw7Bb7lEmJijxGKkuVqqscClDJ8uFYLr8uVLi3rADyg9cAwNa1UGoOxTWNI7gqCQYNlKAUC79lvZqCdZAzcZA+1pCcD+18PQKyTx97/5YA2mlaJ5dngbxs06Mv5Bacz12mMu7xynFcP9YhlPvMPQ3CGd6Hjgm+z8uHcOjF6bGauaZrjHlflM2cLJZrWpfX8IA8pJYgFafK3HATTvE9h5ri674gZBHUd4yWwEK/pZ4pblKPPGR/EFFxKOp7LPcmJ071PUtlrOcIorbXdCRDn+7SgJId93f/xS38nNvrS6O0bllED32A/cbfODCfwLLG1imaxNRKW2bWNOBY80cxlWh8v7LmwMWMHCdqnbrka3YUEQsgPngWxIRGOXKIpTBUEoAWwHDJE8Dj1FUfwmCEI2wAOoDoQDtqIoBqu7hya3YW1ID/fhhDSOzs3JjcqXzzbtdmF4AUVDoWe/5uxokIVhvWZzvecP2hRS9I9Xxu5Dgawq5kyBulq8wUYZ0rqiohXZafAxBm+R7LJMGFQkVjjLtkAbbnr0oJuR8iQlE1r5UORzJCDJQHzgm2oR2H+6OoWG3Jcr69TgIg7z/fh0yVltmDEpXj+W8yif8u3B58M/Yxd5T+m5JWXasGP9XjkheDfLnIMjNindNLT0548kCcGSHzVZdsaRojf2ZpgIlDw5k0dvk77Ccb9FB2L87ybbbfgr0EgUxcpAFaBZXKLR+cBSURRLA++B3nH1ewPv48qXxtVLc44Smx63kVHl/QSl5f8+t2Okl3Jfgh7rjtBt8lRuFN+qtQAkhVIrJEbI1qZPCRgbnxzFWecYx/wkg76EAgCSMGOt6q5Qu4FoWTddZuVUH1uhpmkEZt3fk8lIccPLznN12VLPRSsBAFQGHm0x9plKAQCJr8CX+ef5uSqY4u0WAZBlUBaVuwaT4j1Y9ORajEKm4FwlfZ3UEpJWKcu0yUUoiqIodV7OEneIQCNAGsBuE9Au7ue2cZ+JO28dl9k4TWljlb679TabB2mupIQuT6qzd0+3JF93ZtYi/NYrF54g59mMP3aUWiX86N4gG+feLaPW+ia0Nn3K6PL3mKZfjA9BJoyIeK00nkDesIHY+0arvPc7j4EY+d3n8p3jvNyWmRsVT8mdr2kaQc3ZQ5jXuzGVvC14u205ehWi0asQ32bifQPquFa5GcVHtZUdADOedyGgv+rw8WFh83D/xwW7R0sYVyyWzn3bUTBIcWUmIf6HP2llHyi1bRtrPOqSR095INX04kmhdskaBWhCK8OgIAiZBUG4BYQCJ4DHwAdRFKWv3xBAuuXLBHgBEHc+EsmUIXGb/QRB8BMEwS888lvi00kmvQ2EPf00p71WxZC231g0Sbu4hbsPBbKn/AWme/cg62oz2nke5kSPE/itnyB7+GcUc+H5N8UNVv12zZfbO3DNYApj+q1XEIL3Rqtxr6VHdLPacoeUhUVyymwCAH2mTZIJgVQAGhvc5/FNa7xzefLwxAOOWYzhmMUYCnT0YbHZcCJW3tXq+y4vVZ65nvk496Sw7Fhzu7faa9a3sZZLUCrFb+cqjbkH1I0GlvyoyUTjeoTl9iJsZjAfoqfwIXqKbCtxerO7Rss0aVcrERBF8YcoilWAwoAFUC6lNxZFcZ0oiuaiKJob5s6a0uaA9F0uDLJuxYOhizlrUVhz5UR0eVKd0D2ajWv5d1yg2qpCmJpKQlLbXtAjqP1Xhq79RNbVZgR/8lX68KvDZ91VBSE4ffaR0rpSMejs9EwhvmCfaZOoaRpBydiSMgFQhncuT2rW+s6FbsqDlCZkeany2C+sx+jD8suqzaerj4Yc4L5DqbPQiqpfaLVEtav00p8/8MzXi1Lbtskdaxwzk/twO17YPiGm9n0cXS9xc6Q9RpOLYzS5uMbvkRa4vO/CpSmhadJ2kpYIRVH8AJwBLIE8giBIVxcKA9IJy0ugCEDc+dxIDIRpzjunJukyGph3NAuZS32mnKMRjdbN5sHQxQDsODmGKSVXc2C4ZhdWTWHHdhgf4OqmingeV/8W1ISytOQ+666yMUsvYoWzZIu8ybj3HXCvWYx8dqvJZycf6HJhkZy8iPKXiy8opebsIVgM6qdSABLSeaREaNaWas/aUu0VzqsSACmuKz4rLY/4dkyjt6Dhyzf0edxK9rlSi5ws/fkDawdFJ6nRJ3oQ9NEAR9dLCudOxFhxIsYKnRGu2FdM3xBgDQNeJtstWBMaRUAQhHyCIOSJ+zkHYAMEIhGDjnHVegHSxen9cZ+JO39aTKfIJRO3maa5gbD//nqI83qxv2B87rpyjkb0+PCMzx+LsX+HOw9eG3E4k3qvOVVBRsoGVGCH8QEevHPXKACJE4skpnuDbCrTktcNOI/eB8lQ+HmlHLyr4kdMt8r82yyGOVsXs7BITmbrLKaz0zMClk/kS96T+GepwdP5d3k6/y6nLRVdd9Vx0dGJHUvjg4hKxWBtqfZkn+WEd8W5KgUAYPj05XLxBCHeDqCMoTezs6BlaULzTsDCLYiX20bTfNY5ms86h//hT0oFQFtOxFjRz3Zwsq9PLmnhLQjajQQKAWcEQfAHrgEnRFE8CIwFRgiC8AjJnH9jXP2NgGFc+QggZfs2k0hqBRtVxavRa5hYUtGGccHwgtxndULg2a85+dtLtnyWDaggKy8bUIFB31/z4J27xn4E5N+j1VRgmnFP8pjKW5UvsJ6Cj+UzMbWrbkLvFx2YbWBJhZExjH2yhHzZvTk2K37TkL3ldTocqkSHQ5UYlWULVyau1Hj/xAxzMFY45rud5oCd6uXdhS1GsOCuO5/bVyG4pDl7d4ZjG35XpeegR+kRZLeI4p6L+h2QKcFocvF0Gw10vNKSlb7qt4GnBG1WB/xFUawqimIlURQriKI4I678iSiKFqIolhZFsZMoil/jyr/EfS4ddz5dF1THOD1kjFPaRPjtv78emUspH5YqQ5UQFHJdwKhZj2UCUDagguznd/X6K9RPLnUe1MXMZxWPfK2ZFvWMaVHPsOxnQeTRrkrr35/mTO8XHdh/twRPF2ve7B/8Sk+rfjwv5sUV3yx0/lfeuj/f7TR3rJsQ9FpiYlrYYgQLW4xgseVudLb25J8zNfAoPpa5jXXQO5iTwQ36UmbyIkrZlmNSvoaEHHrDhlE+2PnEGzGH3szO3WfzZclHlGH4MuWZotJrNHDFw487vmM5rZM29gD4A9yGE7IuIv7NlBZC8Gr0GrlpQELqhddTWu61bAlmh8yYvXmD7F91VN/Wkx5NNqqtow11HtRl9FOJP97pa20x81mFmc8qikbvVHvd/WnOTMnXgBIjlUcfTkiHiEpqzz8v5sXWCzPJ03QSNx4ekpsOzHc7zatJ11lq7Q5AaKGWzG2sw9zGOhz5OBKr2RcpNDgMD70dVNso3+dqG3dSbeNOqn8ohtdAyN50FDWjdzP4cj8+Zu2tVgBAkposNVKRp/Vo4IqHH3bv43NFDH/1Ok3u80e4DUv5dtYd8suXJTQUpsSjcIzTQ85X3w4XlScd9cxTDGXe/BOXrmKzy26+sJgOwBcWcxYYEr2EB2Y75KYDAONKdGLvnNekJKrclnNfGf3FU+m553qd4H+asz3tLfoWntsDyEYFCacG7j7V0Yv0ggTPUqmqkmXDFZcGsOJuX1yrZCIyuCZb4vRx4qYlDI6aI6vfp9wJluLOv6fs2fjPMYWHXRuk11gBkJNTr6dhMzQ/kXnVr764tcqNMnPmnG6rkrRLMK08B6dUG4/X++YK5aUL7Et1X4HfItqwtth3lWx5lT74UiOhqghE2ohC//310K/Wiqnve7PPyYEXmQpwRXeA3IjgdL+J9Lo+j4XH/Hm0Or8suMhIr6PMyDueL9sWK21b1zWc9itaygnBA7O7PFtyAfGU6pUB0z3Z2NujBcfmteZsVSc528CWc18p5XmONx2VJ+BoG1qfE0YNVH7fctMGs7GINxMj4t1pK4yUvI3aPS/AmrzuLPrenaYNu1Bz9hDejVUMZjK/x3ka77NTKD99LRuvneV3eYx1aMTwoWKyBEAVr52NyHNuhkohuOpgiknf0kwfKvHslKYZCy+SFecNhkpXBpTRcE1Jztg3wynv9lTp97et+3hUTOLp2N5PdWDX5KwSqHMb/iNEYHbXIHw6dda6vipRaJR/OXWd63DogMQRaFjdxYy1VJz32hYYB1ZV2OXXlhJmbVm/vZ3ceYcWeZhRpSatxvSig4v6369UCKTsfz0MvROFGWi+iUHfX/PJ3Equ/or+ObHxtCHIOf6PJPiTr0wMfPseVykAoFkEyvT7hkkZxbDkUkQ72FdkBEN3dVdZp7HBfc4XtVEILPLpkjPXa9nJQo4PexwoN0VITd4712Xo7WVs+mAsCz0O8QLgcDBSVlb8uA9FT66Vu96yQj2MB6v+PQFcszCnxnmJgTc5QvBtq8Tan7VbW75t3ce/rltpvs6CUQUHsujNag7taUmmI1NlcQMP7WmJ2+K8FBsbxDLjQkkaEfzRIpBUAVBFM3RoPb4Kq1q84dGJBXTr+FbjNe/Gbuf15xDC5yqPyuPdszn3yvXQ2M7Ci/lYnEu5Jbtr9losGLCIxVW+8m1gAPpfVRvjTIOXoPdF9byxUY19nLv/g2yRyrfe1no+C/3iD/k+X3VE2wojY9C/Gc7Ll6oNVSWemdD06gKi7yr29bDvMo6Nn8u4j4NS9e2viuhWn8iUw4PIvFeVCgCAtcNQvudTTJKqTghsdM8SNjNY5kr8IVqSgn2dl7PWU4QrHn4cWuZNwGp/AEYHSX7v6tKWjw6ajofHQj7fnM6lKaFajwr+WBFILQGQ0gwdqveMQr9aK4KsW2msb1tgHEcbt2fvuutKz5+odwefZv4a21EnAgDRNiF8qd6YBQuU5xGUMqOYC3uPBas836jGPvaGOSssD0qZXek9J3pGKj0nZVInfaZXWM/VbBcUzo04Po6sl7OoFAApX929KV4l9ffFq+K1sxGZfF5yeO5WpXkHVIkAQOS3I7LpgbbBRGKXOLLA1QD3O09wed9F4bw0JfmG3E8B9Q+9OkYHTedd3XNkvt5G46hAnQj8tobB1BYAkNgQjm7OgVGbsUTdKaDVaKDm/RnsJW18uqXonShMm0KjaVylER9upSyFu2mZp0QqEYFy0wYz3i07oHrZq8LIGEblzM5007mQKMIwwJIm89hos5norqoFwGvfEITwIwxDvStwalJocBg3evdgka8DWCQvV0VSognpjHBlAnDi/Q5WZlPcdVihlCT/w8Jk9SQeqXiM/jydm1N3U3V68sKg/7ZLhPlc0s4pyLxTC/pvVZ3GW4rX23k03Wqm8ny5eqM0JiRde6waPd5oDph6ymMhA5u1xHSw8uxC2nD6WlssPI15U8pX7sjdbBuvfetQ/MBMtddXHjaIJ01Vb5zqEFEJz5lP1bbR7r0Vw6zTTwCkVNu4k7sXJyU5+UizanOSHU4stQyGmlhoOpX+Sz/xffQqAJ5aDcU/YLbs0MRvKwJpyVFiefBoAPN9VG+vleJtZay03KFFHp59+UGxC954OwlKxeD0/B181HtB1bLazevGHx/DiR4niMoWrSAGUdmi+feNPUNbn6bgrgdKrw+wHITV+elsXDiBtYaX2bhwAhsXTmBMv/WM6bee3n1Wc2h2XpYeVbRxVBgZw7mR6mMgXK/gw5RMqv/oDvsuY1/4WC2+adrwoexZqvVSnK+PPqHcbhP57Qi9xiR/unx51hKybJR3LqtwR3UWqJSw0HQql88u5P7eiuydMQ+x13nEXudZaPiMnm/7YRirfGkbfmMRSOsUZEeJ5VHeVmzdpTqYhm2BcTT85Eq7ftUxHB8/cnCt5su2mUt5+y4LOidnMWXIZkpNrYpp4eJ4Owm8X/aZhRfzUb7UPrW2gMTMajyX8LA1PPIO4kSPE+Sp0gjTwRPJU6UR78815JF3EJWXrufxmwos7bFM7trOxfSZpl9M9jlhGPKEZctc29N5ow/9ulwky9j4ueq846E4dqivtn+1Z1dVawt44mWWIaMAKXkHX2TUlTYKo4GY9co3fGm7VKgKo8nFuW4YP21KKwFIiJ3daF5djE8JN6rVM0a1ekbIQ9Xb9X9bw2Cr3ZXTpjMJaIYOZUuvIWq3YkQc2wLjsDj/g2PdFAOJPl66i+bLlLumxjaeRJ/t0Ul6+EFiHJzYPYiA/Kpj9Sek4aRR3Lo4h6Zhlzm6tr3ESSiJjHJ4T5kLl3HNFcP0CuvjbAHKObHuIDeX6DIyYJnS8177hiA8OpKhIgBwo3cnTL54Mu9VfHwEp87L0O3rx5xuq2RllhXqpWgUIGVOhVFc73cNUwtFv4m0YnTQdK5+tON2jaaysp9hrxG/f/19sxJnFEeJpfDHr8pHA1ZVlAoAQP7YyWrb7eP3XO35aJsQrO1GE20jyWkw0HwTEf8Eay0AIIlE9P5sVvxM+8tCiyWVRW556f+oJZMyrdZY91YPN5UCAPDubOsMFwCQ2AY+lpuIU+dlsgMko4HIb0eI/HYk1QQAYMLdRXKjgfRgoelUvo9exenF2v29/BUBDZwOHcaop+2xLTCOzzdq827sdt6N3U7hFprX/5Whc3IW7c0OqDwfbRNCxD/BBLf8wM7P/3B68HuyDS5M7ybJMzJ5F61P+QaK+/eTgr5uPRp2XKC2zvweiklapXTPUobZvZRnEf5V0O3rp7lSMrkRlvbTgMTUWZsTl04ntKr724qA5c4d6XKfo8RSIqsvzvZV+OQl2YM+OBiMa/2brPZiG09iT0Brlef7XOiIleUmPI/3xtT0GDk+BzFlhAEAhkYDlB5VW1WjdAdTDI0UDYxF7qY8MKbV+ekcnzGCqUHjFc41D67LiXUHFVKT61WIZrHZcBabDcdysHYp2jKShFOB1KaaUdo7RSVmoelUDq6N3wNR9udPlXV/WxGYuM003YQgrMIsuc/OxSWrAkNqKd/tV3pgKAXyfafLk+qystjGk4htLPlPKXRlEh/9zBj5UX5dN9omhKbmgQp7BoLaf2V7j97kbXAGG08bucPdthenvt7m6sdH2BTsQl6rb5TuYErDSaOo2qoaFeqpXsJMCvq69bBziI+ivOHGIAZ+q4phmxg2OU/hWvFJvN22nEFlIni7bTlPJm5ggZktPSaXoG/ltE3LnlJ0+/oR+U0x21JqUT1cfdamtMLObjS59Ew5FR3Dl6yq/w5+WxEAiRCkdZThZugw9b3iRp59doU4Wd2OJ8bf5coX1WnI54/FcO9ehF4rXpIreAHVRHkjYLEL3hSZUp2S28KY/noYNx+sYaD5Jvpc6MjMIaodoKQ5BxNSNGv8m35VIWseZ8nB1Y+P8L6ylHPmWXB7kzmpX1kpVuens3F0Y9nDf9belyjzeDtTi2lfqeRtgXflICp5W1DJ2yJV7psWGF+ZxojM8SOXF0dry5/XsGfgd2Gh6VQOnTIjqNgtDPVVB0f9rUUAJFGG0xpVnoNvjjnStmO8B9+VclOYsTOSm17xG1a8li2h/L/K5/MT9hVjSe8IPAseZ26TBaweEcXklTsU4gn0aLKRGqtX0c7zsCzacDvPw/hX86Ty0vVcKps+hqfAfpINQQkffild1yuPnuw582mG+gYo49T6RQQ3scRlx3BcdgzP6O6kKc/mm9KzrvoR82/rNpwQy507Ut2FWEqj/Ms5P1b5Q+xcHJbNiOJKLcnmkQuGFzBKIADaEtOoLSAxvLWrXxhrn15YWUqE4KxPL876SEI2RiNxXlpgB9HASLtsQBduRPWgjFdOBlispFYJP7ac+8qqQtbEXvIjTyuDJPdHFRaexrwortzp5ExEGFWUlE/JNJth1idTrQ+pQfkNnyhewAe2ST4XaXYZkNhpmlWbQ6/tGb9snp789iMBSJ9pgTIGB0MJs7ZcMLwgizG4obqbwhLhyS1bVLYxp+0zPtyVX4L7cOai3MOvicL6sSzY+oGSw3tiNq8a5advoO6WNtTd0ob9x17hs05zePOUUNm3BP/eUb7isXND2sXGSy5dXK9Sats22eeFNp7kztqc3Fmb/zFTASk9213WWOePEAGQTAvSSghy2iqGohocDKUPz+ZdLnl/e8PxMazdW5DafSWxAm2Hj8AkVPWSYAcXkb59Us8oddanF4X1Yxl5Kxsjb2XD0esnO46n7XDcYlA/peX+Ha6ypd6vtTKw//U0Bp+TD1Hu1HkZPe086WnniatjnQzqWeozOmg6p8I0r2L9MSIAkrwDqUkzdLCf+R775vXJabtCTgxenH+Nc5sNClGGpYxuWomqtnP4WHwMV21Up/fWdQ2nck75VFh5GqaeNfmsTy/2fjinNDV5UtlcMxtXs11A3y9+uPyyWTk6fFTtM5GU9GPpReLtxOFF4pPfDO4TzokYq3TuUcbyR4mAdFrQDB2V0YO0pRk6WC1twI12kje9ffP62Devz2D3Wwx2v8U+u0JatSNdFkzMnLbP6LM9mv51c3H7kySU14tDPdl7PiRF/VbGgq0fUjwtiJ3XCtvLkkQmwa/0sHKvhZV7LSaU7qbgIyDlVzQKJkbZ5qHUHA3ELnFMV5fh5PBHiQBIpgWN8i+nUf7lyRYDqQBU6aba6p7TdgU17yc/QeWEfcVYnGs310Kg37Tm/Pj5gzwN62JtrhizLzUoObwn54OvUW6/9qm4EzL16gh+loo3kHob+ONt4M+SJvOI8uwgJwT+Ha7i3+Eqhef++CVchaXc6N0J9/7OADzuKgm7nnh5ECB3VsUAn78jh5Z5c8N0uMZ6f8TqQGIWuJRhv5ifuvhxcfAlCB0mO6csuKh5pxZy5VPE/Kz3X0iVAqrzptg3r0+PWsMphvKovgBlC4WhLnWlxFlIEs/v9icfyuioTrudGpQc3pNXTbbTdHEIx0Zq78oaO68VVp3+h8885VOf4Fd62JY/SwdPyRtvzEwvAMq7lkKSqOrXYPzJWB6dk0xPgptYwnFAfbiHFHPGvhlTSH9nKbOBlXhdy4JqQf9ydUtTyJ5NZd0/UgTMO7WAHRJf8MimjlRP8J9Qvaey/ABRcuU3C9eDrpr/eH09bOihwi4QPleXFnW8AO3eKpVzWhLzJW23RwNsPN4FK8tNmA93Jkej6txvoz41t6nbRcYXGoxRv5UcaVSZ5sGq7RWlssiPjDr16ctyB+dfYjTQ+d93PN6rmBLT8MU3OZsAQE87T2Jq3092MBEpcyqMokO/BtztvTNdthFLGR00Ha/3zfl+SSLKwppjRPdU7byl9XQgLj35TUEQDsZ9LiEIwhVBEB4JguAlCELWuPJscZ8fxZ0vnqJvlAwid24FkEUNTiqvQi5gekpxv31CCs69gZdVIWren6GQeCR8ri4n6t3Bs59qAZjTVrLeXiMuqfGBi2mTWEIZZ316sWiCHXkGlObcegd8RrZRsBe4VxvGcMc9ONd/wOoJUQx4b8+q01MICtrIkeKK06TGBvcVymb8nIjrJtXLo+nJWLcY1unJO5YFN7Ek0iUvfSvEyh064/Qo4lWSTQuU7rzVitgljgzoK7HvJA4skta8q3uOK2GJjNHFlOe+hKTZBIYhSUQqZT6wVBTF0sB7QOpb2xt4H1e+NK5eujJxW/Ie/oRE3ThItb3KtwS7HzlP4+seADwx/k7N+zNoc9uYhcf8WXjMnwlXnhDRR3ngSikOw9oS06gta/SMqFGYNLMFqGPkrWyEtl1O6b02NF11ixKNM9FgkmQE1bRoGXxuxTKpk76s/oD39jz6lIXHtavyrbwkf8CI4+MobhzNikvKoyM5zFQ9XUov3jvXpUvoKIUow9LgIm6tcssdAJEueZlv15tLJwckebUgdokjWFSkrxAv7Hcrps8mIrOBlTgdo0e1oGVaX6OVCAiCUBhoCWyI+ywAjYBdcVU2Ae3ifm4b95m489Zx9X87Zi1UTOvtfuQ81i078e9zeYtvvTfxm2sG7htIj3XK1/6f1euA76hAdL+k8WQ0CZz16cXG411YsPUDg4eW5d+ODWn3XHVEpRIjvTnhuYQOEZW41cONkrEl+bRnBTVrfefx9ykK9Zef+pKW3VeL87n1lLzTmcXXq/Fvpvh9FNrEGnRrlRudcXqY5lJn2VHkjH0zPl6/wnpRuxWk1KLAxJy8rmXB3hlJW5bVdiSwDBgDSPcjGgIfRFGU5gEPAUzifjYBXgDEnY+Mqy+HIAj9BEHwEwTBLzxSdeijjMTYaRvuR87Ljl05p3J6SFs6nH3F0qIesnpXyin+4asik80ENpgXZeTH/7EoryQR1rXUXxVMEecqT+NnFuUOQFLW5HVny/YPss8lIl9wddU6Mj83p5CtJ1MyzebGw0O8O9uatobzM0QITt57Ssctl/jYpSvtv/Shz+NWcm97bWkWYkHYzGBilzgSNjNYY/2qLhb8/DiPnx/n4RVbiurrajDkqyNBVz00Xptc7PM1Ituyhlo5ByVGowgIgtAKCBVFUXlw/WQiiuI6URTNRVE0N8ydVfMFvxDlHI14MHQxS4t68C7XTJUOQ5rQO1GY6kFhXFn0IXU7mELG96/Kj1Z7cfyoy8wcyi3bi753p8W0rwrlJSJf8GZsJE8mbpDFEVh/W5/QkFXpKgTNcy2mwvLpmHSND+y9oZR6O48q3FrlxmhycRa4GpBHb4ZGITCaXFx26IxwZcLdRdgYdGZt5CYaltVP1anB6KDpFJiYk6eHNzLF6ws3TIfLHdqgzepAHaCNIAgtgOxALmA5kEcQBJ24t31h4GVc/ZdAESBEEAQdIDegaJb9DRk8sS3SDX7lHI04bVGYnB1XALo4UgvXar7YNFOfSOLlx/hIvtZ2o1mXawKg3kKfEYzvXxW9HHqcu3yOmW+D6THLnq4tp7Ht0DQAXJ0teY/qzVLL9iluwgkNkQTu6Fs5in3hY1N91aDzv+8YpNuejaGS9GMmXbOkSrsOByM5vz6YMXoRfIiegtHk4slqx2hycWwMirN7iTH+BfpRqZ1NslYNRgdN59Ayb8INnvDz3XROt3aCH2vAqJpcvWXGhdhcQJeeb9WP6jSOBERRHC+KYmFRFIsDXYDToih2R7IA3DGuWi9gX9zP++M+E3f+tPgrRDNNBkZ35b39nGfvU1FTgk2zqaxuu5r9O9wVzs1p+4wdDbIwxUWyWWhGhxXk33GB9RuaM3hZHk75pW0Ck+QQbReN0cJaLP6fPi+i/Gne0Ze5TVoyt0lLvA38yTc/eX1Oi5GBOHQS+Z80YuTWTBwerDyXYqUWOZPV9u4jP2Vv9eQKQEJ0RrgS3P0Hu9caaz1FMBtYiQITc5KrxWLc3+VkwZvhnGztxGkd1enghr96jfOPNfhUaklM9heq+5PkbxDPWGC7IAizgJuAdBP8RmCzIAiPgAgkwvFb8vRbLXJUW8PnGxKvso7m+9gfonwrrUOLPBRqK3nAX275zOFRtuicHCNzGw5rU5WVwjhwgU3F6zDy/Sm569vVL0yU5nwn6U5h/VgiF1tRZIvErGPSVeJ3b/K1Hl4OF7Cd31JpZuKhddbgsH4T+0ZIDB7rb+sr1AGoWmsD0/dI6tTzPsnTm4XU5ii80Vvy5pyXaxUPffax1NqduZ75uPo1P9tmyOc8ML4Wv5R57dE+0LyhToHpQ4/yb8d8lFOebjJF6IxwZe3MYDJdKcTm/ZI4kKUuDQTgcZ3Vss93dQuy9c1wivUKgtZxD/1Y1Q9/Yoa/eo2/juovkCQREEXxLHA27ucngIIHgiiKX4D0j6yYBhgXrscr1mDfPC7e/tlbWNhXYZapKzmHvebOiqYsiss3MENoymri12bPLNIjVKcg3O1DUEgwZW4tgKqSc9WCu2HSeQn578bf64eSHHm/CrYX9Ah1Ngfk04pbfK1HbNtIqnhKduXttp9MzdmStfien0M46l8Tic0YWYixhGJwvZYdq426YN03ruAofKzcjLMT6/LvKXsO9xjHsMeBZJ/lxDCThby/9BP3HAUQvtrDp7FMuOsAd0Gv0X2goazdd7PMESw285z4JCwFypTnyKRPSRoNOByMJHfpdtjoas7ik1yMJhcnbOY8DCNKYrHLCJCY3sres2B3jZZMyCvJQgzaP/RJ5Y/0GEwtgnYOkKQhT8Bg91vkPPKJilMLwStkjkK3jBSvzx87mTltfSn9oQwP7eYB8W2d8lhI1+zKE4P+ahTWj2VNpRU0OKO4V6J0r7VE/ZC8cQuedKfeiZWAZBmx/4xKfJr5WW4noVQMxmwaxKA57alxW769GrclS60XjY6S6yjUH72X5ZbHeRLbCmpCW/dzwDm5a7qeLkTdhhYUmFUUwWIzApuVfg/Dl2+A0lp/7/V3daizPe0EQIrR5OI8r+BM0Y62cUIgIdsEKKYTlOb3/+M2EIEkWWlqsLab+jFgwqXBInOOKZw36Z5DoWxPQGv2BLRm5Mf/se2Lr+zo/Ko1H86kb3z6pFBOvwWZp8rP7F5uy0z9aQ9lnyvmi+H28lXcXr6KvUXfUsSiE++yPsali/x1+8LHMtYtRvbAq8PJ+xlzlHgjKkOwUP7wy9q6UA7/w5+0amtZ6ezUabxGq7qpwYS7i5hxIz65y+4aLdXO91OTP1IEpKHGWrZOvhgYF67HPicHzRXjaNevOgP3DZQrG+l1lAn7ilHzZxtqeURxNUTiF1CsRVdm5q9DTPbFsuPAjoLE7szDmDWjfkkjYY/6Icxyq0Tlj21kZU/n31W5hAgSUXA6P5bbtZ7KTQPaGs5n+cvRXKvcLNX652GpecL/XHjAlO15sFhppVQMHA5G4pmvF25m7dmWDiOAxFyetYRRBQeyu0ZLtmbLq/mCVOKPmw7M7hrEAqeLSFY2JUKQnD0EUfmVO5S4HzmP/fyhFG7RgzsrJEtQiZ2FQnVm4kl9fgx9TA8eQ88jmB0ywxKJAKjCtFI0sS1XYu9dg/C6fdJlQ1FSGDy0LM9brqLuTcnv9iLl0WT3PXzoEG2/F+BJQzM5Iehb+R9yvRGpG7adpdbuKkcFzfbdo2xEOaWjgW2NJG65XoYVsL/nhNmYY4QdD1Sol5DnwgPwc8WeUIqKeSQGQ8Ck60Lqr86LeYV6GA9ukOLNQ8nBaHJxdq81pvDmmRTrlX7bmX/bXISqmN01iPZO7wDJlmKAMU4PqetcR6MYGBeuR1T+3DjqSoxMRV6WpFvHtzK7gLN9FQruaiurv+DwFF75LmXD8Uu08XOR+QjEPt9L2afybxLPfs3xHRWoVgQSMjn0EhPmBPxSQhASpUNwxXnMzhfvfvvCMBcvcuSmYj7FpQ2X+vMZfmoJT7xUx7zvWzmKMZsGMdYthiin7tS4fRTdkvM41b83ezaPZtlUyTbw4EX7uDX/GB/71McuUrLlen0ba7m22rva0LhnLe4+S952FXfb/Jj5C+k6DVBGm+hmiOtTNyOSY+ut3Pd/q9R9/48TgXURK/l21l3pOb+dh5UKQomsvrSxUJ6BtqGZ5A9icdl37Mqp3BHIOk9HetSNDz1WpkMXfgx9LFcnf+bujC5RNClfhSB/PXQ6fUjVcGMp4cTPTtQskglb43iDptcrX4pYdFIqArt7O1GjofJ8jYnpWzmKiJV3uWzXhP4W5ZTW8Ri/na8NFPdzJKS9qw0FshfVaB9QxduHgZwqHJRquQiTQ3qLwB9lE5jdNUilAIAkzsDp0GHM6GzO2jYXaNk6CP1qrVQKAMCZgAGcCRhAWxc3rftxYLh8quvtJa+zTVAdoEQVppWimRO0N8nXpQV6HnrUblGO05Y9eWYuCcCiTgDaPS/ApluFtW5//W19vOtbcqi18t2XwYv2yUYA6siT/UayBQCgRum2miulMbtvNuXZ/JTvhNWWP0oEkpJ7wLxTCy4OviQb+muitM0YOpor9xhMmIVo/w53Wi/z40GJiZgdMsPskBn3yvXgRvGtWvctIWP87TN81eDEiAFUaduBpkXLsMggAseno3hY+irrKjoqFQCAmTmiuOjolKT7SJcPh09fzvDpy+XOtRj7TGH4r4y6fslL3CrlufCAhhMqpqiNlPLhTHu6fX2fbvf7Y0RgXcTKJMcTXOBSBtcY7cJfnQkYQNtOwxg8Uf5NMS7UgtiP9ky5dYUTR6cDkjwDL/O3pnvECLpHpCwbr2mlaErm75FhKwYhUTr8KFQBYXRjWdneom8pqN+cvUWVZ2YCycrA5uJJ21g1ZtMgzJq0kH2WikFiQVBFh11j8BuU8t/TANeMd9z637X0iy/xR4iApmlAavHC5Alvjjmyv+AK2eHcJt5wd6FgM9p0tqdx9+6YhB5gi8GSVLmvcMGLzSXVbwJJbawsN9Hp8lPCRvsy62GuZLUx/vghzt3Qzt+2b+UoojZ68KW08kAuAT+Gku3cG7VtNGqrOo5eUjhU5tcLk56W/BFLhD6dOpOcFWfzTi145dIVRmtXv8jLktiFPOOyf3y0nCLVM9MmxFj2+cTR6ZT9soW3QhZuDPkfExpPYsTGanQO3Kb1yoAyDKI7o2vcM11WC/Q89KjuX5CNb65T4WfyNzR4TnJnU+bsDNsWzK3cqufa0hWCIi/C+ILyaMjBi/Zx9rkDvi3nM8fgvmx5UErLkra8cdiPfPCr5PFy2+gMNw4e6XeVkdRIl3v99iOBVrsrpyjHQKUGyhNpKqN9yVJyAgAoxBe0aTaVhlfirec6J2dR5tY42psdoFpwt2T3c9Oh82S/nvY5/ZxXPCC0wgk2vomiwsiU7WiqmC+GRQYRnO1ckKP/mlPSVrJS0LdyFPkLD6LDeR9GRe1mSpl7PPTZR/PpyrcWD9crzoznEn+EWk5j2d/VDb0CR+WOs9EOdJ0yMUX9lVKjdFt87iYvRkRqId1IlB781iKQHDtAYsyaau+ZZd1S876oE0enc6amr+zzjJU9eVhlHldDrLkaYs2zw9vUXK2eKd5D09xIOK/oT5queZRiAUhIxXwx9H23kGXWI+hkEUi2iyspYTaPkFn/cKFDYzp+NGP6nhDy1snEo23x8/FlU4cR+amgTAA0EZnfjQXfUx5D4LnwgOENXTVXTCNqTxrBw1kF022F4LcVgfSyA4BkGjA0mw1F6hdiXv74qLxeVoXIGyLvD3ChYDMenJ3FkeEFiW08ibA2kq2DS01sOPjuFCa5YujVsr7sSArPHcan/MtowO38MoJ00iY2bH3v6Zx6MJNrHQYrPf8y0I3QQi1ZcNcdAIfRXpIdg0ng7tP6qSIEIzIrz6qUHviuiI+0lR5C8FuKwOyuQamainzWwoIqVwmKvCyJzbXl2M8fCkhiCpzJ6QjA7hLKcx9eKNiMH5P3YHJb3rnoYZV5vPyoS1G3ubJjcuglxHq2TA69pFEUJsy9znX9uWrrpBSbJWu42iT1fPoTMvmzPhEf1C+VTt8TQt2w7WR/NDPJAiBlwygfDB4pbt7SlgN1f5L7cLsMyUkYu8SRsFZzcVscP0JNayH47URgdtcg8rkcT3E7fjsPU71nFNsnSDyzXrl0ZdbCggrH9LwbFa69ojsAA79mjLqkfnmxcffu1PKIkh1lbo2TRRYCSXShCXMCiPgnmIotTjGwUGm+651hcugldL+MJMhfT/bzyApGFHVdli6hyQ89759mowGpL4A6pu8JUWkf0IZaTmNZt2U94tWeSb62qFgW8xpPaVZtDq+cz6WrEITNDGb75oF0rKuYHzEtheC3chtOPAJIrj2gUf7lGLQ2w//cY82VgVNu06j42Jtxt3LSZKM1913DACi7YiRD7p5Wes2MKjW5bDpFlmREysq2Xmz7uI913XIw7+lOBkSH0dQ8UO7hTugTUD1qPNf156ZrXoKQKB3W3rtN+zNOnD43npk5olQ6Bd15p0u+7N64+1SnZdXiKuuBxIvwS2QR/Ato/pvTjejFpmUpC015MNNlAsUb1CjdVrJxSAsqdzJkrIe88KfXKkFZ8X84Gt4nW1zoxpbt4//PH/xTnbu6Bbk0JXnbi9W5Df82S4TKpgBHiU2yEEzZ4UfAMe0FAMDaYRrGTttw7mfNgsOVZeW+HjYUc+hF+FxdHFrkkbvm2RflDidD9tlCw27MeyoJobVGzwixfmH2nm8pe9ATP/DWpG9iksL6seje/kajwYPp7O8OQLvn9jIxkD742d83xrFDZTbcWMvsfJmpdHUn7So6KnUiuvNOl005v9NixSB6jHFJl+9hbD2UJbXcMHlcF/xcEa/2JN8kP4q3W6Tymqmvm9NwQkXGdmwNQLNqczgRY5WmuwrDZgazzsuZ6/2ucbl3UYhbGMhyyF6u3vfeOei8aZMkwGjz6bgtlkYdShm/hQhIg4RY7tyhcC4SZNOD/Wc3KBUFabLR/vvrsb20X+LANFrxyqUrbzrug8Pykdc3VR+H1ZgQdJ7bycKPz9gZyUvbQwqjACmmlaKROhoPiA5jNZI3/im/lhmSiUgZS06cJvfZ+E0sa/K603TSAQyi/Pm5awxZoyMp8ugjrDtIMSRefrbGtbDpUJJ5s+/QsmpxAPJl92ZQoxlY2R9j+eOu7FiaL92+g92jJdy52ZTvQMViY/HbuZeQWSGEqNn+bGMO5p3WEVBGsnXZOr8pjHvD/aqOvLB9kqpiEDYzmNqTRhDbsB7Xb+wF1Kcsy7LxM3sYBUgEocKdThQwy8nnm9PJNoFkByH55acDyY0SJBWGcYMGc/NmH0ASLiwlGDtt41E/a8aFSkIrfnFW7pgSOqcbesN+qBSBntXDEJuWBOB6183ku7BWdu5X2TE4uG0mjuraypWZDZvNo039KebXQsVVEp6ZH6aYXwv+0fuHwWuqE/Ve3lrv2Ks712vZ0fFj/Bbjqe0lm4023LcBoFxdQ3zmv6NByRAchybdyOcaO4rYT6lnPAbIbhHF638fUzTWP9ltSN/6Nc5bUH3zbrlUZSnhe+8cbNoVwNp/c7I1m+II4bfcSpxaIcLyuRyXCUFKRQBg+9tJnO6n3inF6moIt2I/4jTFUeFcz+ph5DIPINomhDaFlrPD+ACvjtjLzl/Xn4up6TF6NNnIWZ9eCtenJSFROux1C6Da/dGUuzUKi2Kr5M57t/Rn3PI+WrV14qQZNwNU51NoZR3JqKjdPJkkn7A0yqm7Qt0DQet5W9BFq9WCNtscOGcNC7OmjbONeadBfAzewy6zyCTHHZDmKLSNe+unBdIRgn2+RnSs20MmBr+VCKTWw5+Y3J260bH3iSTZAhJzym0a+wq7qxwBJMTb1YNmiaYE3SNG8LTDG6qWlYhRtE0IV0z1FEYCi6vEZ/axvaCXLEGwspSkg0x4XUiUDiv6S6LtFgh4y5QRBgS1/0qPJhu5NnAQly6f46Z1KJUfLaDpi3d0dnrGsVmt479TS3+6XjLWOBIA2DV/Hk9yPFRbx9SwjSyYiCbmr2zPSJ//4b56sUox8HWZz0UHT3J9U1zRSW3q+m3HZHwZ/u2Yj6qL3dXWzaM3g9IFNlE9PP1Ged9756Bz3Zm8696L0zqhv74I5M+cQ7TVLZ7m90mpEETtjmLkJu3MKK06rqByojXx0h9K03RsvCdatE0I32s05cWh+KWs6/pzudVnt9x1U0YY4HQ0Cy7NvtPFU/IHPt27B4X1Y1FGSJQO/955yPx2LSgetBMLX0uu1vKh0pu3vJ18C4BsPVpygfWE+iygwu1pAOzobUnlRwsAaPriHWOfLOHp4g5ybZ8buZwi4aozLu+2n0yUucCu2LzUy3RXZb1W1pHUbPKRXM5Jc4VWJQZWem6E5S/F0Jupm9VIE5F5r9JouRnftu5jffN4b9C+RyT7RNY335aqw/6kYmphR64WizG9tuy/EVREE5E7txJxQLtIN8pIHH5cHX2uKwYprfmzDZ06XJN91juhGHRDlWEwb4Mz7O3RgoktvjOxxXe+bXTD83xhPM8XRs9DD5A8/J7nC7NspSs+FyZTf2R1iq6bR4leAp+7enHl37MEf/pA8KcPBK2RDMMb3OnAwnBzpmeOou1SfYYMKsrJy0/59nq6ggAAfMl7kiVNFHfZjbVcyq0ebvwsr0elbxLru7q05PkLD8KkvPaBXGX3GbIHna09CfcoQehxSQi3RTEV6fbyn3QXAADrxu40bTENkDz40kNK9c27se/zId37JSXoqgeXXxTl7aNolXX+UyMBKYvFsjInIW2YNPoNYy31GObaBJ3Myv0CEqJsFCAlrE1V2kSVl30uaXmQ54Xjh4mJpwMQPxLI2+AMtp8lb9dVMSIe/1xny7mvdG+QjaJZXblay4dgU8n+BrP5gRiF9sB2Rk+8thTjq+chgj99kGt37pBO6Ex7qtDH0WvzsXpClFIRACh1+SbV7sgH+Hg+1Z9P9ysp1HWdPQ63yfLOL62sIxkcNYdXk65rNRVQx+PoynR7+U+K2kgp2S2i+GewwLetikFnKrWTGDrVWf3TA7uWswjwD07+SEAQhGBBEO4IgnBLEAS/uDIDQRBOCILwMO7fvHHlgiAIKwRBeCQIgr8gCNXUt57+zFvljGkn7Y06jnsPULvQUq5NbI5xLc2pnydceaLyXOIwY098WlE0RPWmoCkjDOjiuZHwsDU88g7icKaasnNbzn2V/ZtQAABOX2uL7Yye6J4qjEPBHxSYWYUeneOnQXOHdKJuwHml93SvWUylANhM3U61O9bUNI2QHbk3F2BMgJfS+rZtVzJ0nQ+GgfJC0MJzXooF4FehQrGxNG0xTW46APComGp/hF+JpEwHGoqiWEUURWkAvXHAKVEUywCniE+v0xwoE3f0A1YrtJTBvHNqgtNcP43biI2dtjFp9Bty2q6gSP1CFKlfCG8rY6VCYHU1BKurIezb1YglOqodEZSFGcsdLkmZfV1/Lqf8WjLyVjYO5JCEyZLaAKREZYtmVYxk9Na9gSSIxrqOY+UEQBntIwtSwUyyqnHBuoBMANpVN2FePkn8xKFZDMh3y5xpfZvgOcldaTtrnz2kpmmE2nslxm2sOd9qu6Gf9zv6eb9z7oYuFU8dR99li+aL1TB/ZXtavUudwC0pwW/nKtzLzqOhu3zYdNsbe8my8XOGjwI0odV0QBCEYMBcFMWwBGVBgJUoiq8FQSgEnBVF0VQQhLVxP29LXE9V++k9HZDS3ukdIbnio9EYO0mUXFPcwSIvS3LPIT/XysZHD06Ye2ClkRGtxiha8zu4iCy8mI8eb+Q3Hq3rloOa2Ycq1J85pDOl9OWj5VRtVY3gT5KtymerOlEitz9e5ePne74TJ9Koxj6cdY4ROAB0T8XbHfbkfsNGdyveG8nrsn54efbdOUCXurdo+uKdrPzb6+kyl+AF2/+H46IA1j57yG57xeg/O7uEyE0Hou/q0amB6hFOxxFe2B64k6IpwfyV7bEaJ2SILUAZkXmv4nG6FWPWmKTpMmBySPF0ABCB44IgXBcEQRrnqkCCB/sNUCDuZxMgYR7kkLgyOQRB6CcIgp8gCH6fReVW7rTmotlNTDutkb3xHXUbahV49IXJE2pX6sGVclNkR0KGhIXRz1yxndvdyyiUVS07gLlNFii9z+SVOzALbS/7XLqDqUwAAKxuqna/HRzbFK8p8lF3yzdoryAAAFGGgczY6KtQXjFfDN4t/QkzL4fjIolB9YVhLqrflaz/R5kL3J9UnpKxJbnVwIGhFdYTfVePFoY31QoAwK4ltnTf9JKXgdpHcU5MywPJC3uWVuR+b8HKfpk5Y6bw5/5Lo60I1BVFsRqSob6TIAhye15FyXAiSRZGURTXiaJoLoqieQ4hY7yX3zlJ3sjaRhxOClM65cZlhisBLQPYO7g9LjNcWTSpIhu66FHq4wrmjK8OQPi4cuw9H6KynQM5tmNoNABDowEUKd+aQbrxYn62qmI030Y14o1T04x7EmMd33bsvFYq73N/mrNCWeVhg3i6V3434aycBZjzbhhXggzIFVif8kvz8zR3EeaM+sbQOmtYbDZc5T0S8622G5PHFkn2tCDwyLFfZhQgJVfx9rzaYKu54i+EViIgiuLLuH9DgT1IUpK/jZsGEPev1HH5JVAkweWF48p+OfK5HFeZbiyltLktiTt4pqYvL/NLHG5e5m+Nye2p1Gq7nw/7LxK65yqZM2VW1wyex3tTaUBOKg2QOPkkNAwC9Ns1H9tAPWwD9RTsAtNebZabDlQwm0i9U4qbe/TDy7P3+ktOXn7KgoYLWdBwId/nT6ffzWIq+zXfR7mBdEqmpOXw08/7nYveBZIlBNLsRL8SfjtX4VVQdcalXxGNIiAIgp4gCPrSn4EmwF1gPyCd+PYCpK+g/YBd3CpBLSBSnT3gT+SC4QW6RamPUfcyf2sWTarIjY9JDxd2tqqTbBQw3mYLTyMrce7dMgCcdY7hrHMMo9AeODRQjERUc6kV9U69peDjWrJj350D6BaU2CTeeQzkncdATjs7M7n0gST16/FNa6Lv6iX5++zc7858B+2iEgPcbdKLDZFVWH/0bJLvlR7c/KB6xPUros1IoABwURCE28BV4JAoikeBeYCNIAgPgcZxnwEOA0+AR8B6YFCq9/oX55bQnhw1NC8lAvSbpj7xpFe9aPzXfMJ/zSdeBB6QswkkpGhWV8buPSz7PM1YeUCN9pEFmTukE+WmDWbDaws2vLZghRisUO926TEU0a+E6ygzSrQbK3fuSVNTdttPxmJCJSwmVKJE5AuF65NKUPh+jaOBu016sTF0Gf3dt1DbugAddo1J8X3Tgvyrl3Ld8NdNM58YjZNxURSfAJWVlIcDCilh4uwDSUs98xtiUbeYxOSZiAuGFyjTwYtnWzQPb1/mb03b8AtUj2onK5OGD7M2P0RIlA63iMalmWTj8d4ecxh/THn2XmXEWIfITQek9P6+iVH942Ml9smyn5seDWjbQ7K0mc9uNWPOjObb1ulM/qzPusXPOHZI8n3emnzn/Jhn3AdkeYKnSVYwnk54iY9nBO9IOrc9ejMp1y5YqXhuV/3+dDy/lhXng7Cs8AYlf3a/FF/mnydrwAJYmbKgKOnFf9JjUEruTt3wWDstWdcWeVkS/TO36fFBfruwzemDVG6jXVirhldqkT1XfW4NjvdXyL/jAlc3VaT1Z8U97wH595DX6ptSgyDA1Vo+siVCKU6Dj8kJgdubzHj5vmRboI2sbMP3Nrz6MJJszplxr1mMaX2b8O21RAASU+v+Hcp6TedlM+VJQ8svzc/Kr080rg4kpOMIL+pVdmfSz10a6470+R/FdrvIMhRntLegMsw7DaLXhF1c73dNc+V0Qt0S4X9aBB6Sh4CIq5orJqLIy5I4DxlHjdlHcJ69j/0FJRmJ77uGsertDOy3aB4em4QeYMWxLRSdu1fhXMQ/wQquw1KyOT7DvUx1hfK5J7pTylO5k9KbjmXx3jSIHDsK0fr8P8QKZ9H7kJsNry0werWHoVkMZHVbH1nPXfs2SgVASsvqdnxZpTrD8pbKsxm8RrGPqmhQLYYJO/vR8fxazZUT0dHxyS8pBP69dFkSkPJEKKlFavgJ/HHkcznOvKNJD02dUAAABk9sy/Hepzje+xTPL91mQ3Xt1r3rPg9WKgAAutlV79nPU6WRgn/A82+OWE9WHsYboOCuB7g4N6X1+X94b7SaKMNA3pTyZdFaCzkB0JbwLaMxOXpf5fmHJ7SL5weSUcDh1bmSJQAAO/a8YkXVL8m6Ni3Zvvj3MYX9Z0Xg21l3wirM0johKUBDszXs27lcJgDK6Ntlr8Z2nKY4MrWQ6iSbtz8pT8UF8HboY5qOk7faN8g3XKPbcMDY8hyoL5/a+/qypC3nSfEtV5FGU5epPP+02EvO58vMznPq9893HOHF5WU7KBgQmax+ALT2aIGdT+1kX59WnHJbwXqxUEZ3Qyv+syLQKP9yjO5Oor7JYuz6T8PMwILlF0ey/2odZi0sqFC/odkaFvczoWBT9Zlpngbsw717EZXnLw++S+2G3Yi2Ue0gpIntzTowt2kz7B9eZ+6J7sxvpznIB0CQg+JDOS+vd7L68CXvSYXRgMnR+0T2fIuJSX62NXNjcOwL2jdqx+HwqgrXR73PwuVlO3B7mPz8AACHWn9k1j+LfqnRQM5BnYg55Uau6jU1V/4F+E/aBDTlLZAGLJ2yw49DB0yJ8tnC2m66XPmosEiigPPsfZz0d6PPdQdsh0vSkrdeFr9tOcskE2Z0WKG2jSumeuw3v6H03FuzAjLHIYBbF+cwaJl2CUnqr9vDhofxQTzyhg0kVjjLiVOfiMkvGRGNe9+BEgXeqrUJSMnUoSTV7ljLHIeemR9WWm9VliCG7upOiWcmlLEpy5x1c3joIzFepmQUkBDHn+60ap5++ftUYWwQi7PJNrrXlmxs+nj9SoYFFEnIX8NgApKbuKSp5S3qfN6ksV7ROpUpu2KkXNlK3948MZYs80XMM6buyRlq2/heoynTyioKRUD+PTScNEqu7EXgAW5UzKPVaOBNx7IUalKaUB/JXoUD9e8xfuVO5g6Rn0oEPXvL61uvafe8gLJmAMkqgWH3hXSIUIwhoI5ifi04cdIMk0JmDI6ag+OE1EmtNtLnf1zftydD3YjNOw2iyWpdlk48JVf+KwjBXxGIIyWZi/af3UC2KVvVjgaUCUBidpwcwzWxFmWdVHuVPQn1ZOO/8mmplQmAlGXRkezopegPkJg3HctS+Ynmh3bukE58WFeFWwXcVQrB9ArrKRKd/Ld4Mb8W3Orhxsk8F1JlNNDyQC46LKpInuzKR1BpjbFBLPdc7lJ/0z2lcQQyelfh39UBUiYAAG2s+tBwhh3zqnxSel4bAQDo3HgBVsMvKQ0tBjDqveQtciDHdmwvSFxw1QkAQIfn5+W8BVVxxG6OxjoA41fuZP7XiZycsYpGDeYyM0cUM3PEpw9zJyRFAgCSqUPe+wXI+6Mnu+r3T1FbAMstj2NmfBXzTulvlTc2iKX7+0EYn3VQGUjEq1q79O1UEvhPiEBq5C4EyGplz1DdbLw5Fh9KvMlGa3IOe62VAEg5eeQduVv0VBCCyts6Muj7a67rz2Xyyh0U1o/F9oKeWgEAKFK+NU8jK1E8aKfKOmbzA7kbkLTVgB/2Nnz/cIp/Q7IgeMDMHFHY9BjBzxLbk9SOOnT+OUNQgaTHGkyIod1Tsu6VfPdXp1ZgbJC+W9MDxRs4a+EYtF4sxPfeKTOEpgV/9HQgtR7+xNQNqEree/Np+MmVWnYnktXGv8/tcH/hJ/MYnJhrAs9vFVeoZ21+iDHd8sgZA5Ux4n0HGuQbLvucMNCI7t4KNBe74blDfSQldYQOiKGqtSU+85ySbAfQhM4+c8pZ9GC1qWZjZGJaHshFp3V2lMsp72cwrphECNLKRmDeaRCvTq3gVYQOAYH5qL5M83Tsf1WPsWlXAAtNpxJ01SNN+qWK/6RNIK0EQMrPHHfw/WSV4nbe60Tj2ak5By4qNxxZmx+id5PtakcDH26d5py5ascnnwuTCTpTIsV9LV5yN/lE4xS3owwvO2+M935I8nWH7d/TIXgNNWtNkD3wbt3CKVtWEtPwwQNPogL1Ul0MXjbSoZyDKy08/uGw3T3mVFA/WgO43u8aphZ2zIj9SOlno3hUbFG62Qr+EyKQ1g99YlJLBDbtdmHLsGVq65iaHuPsTUXfBZCsDiwt6C43CkjM/HYtqFm/j0K04aRi36Y+9+4oj4KUUm7UzEp04GpaHsjFodaq8xqoiiZ0wC7eJnK07T+4dJDEQnDyfsap/r15X7MN9dv6pSgxibFBLB+7dCXo/h6MQqaQR28GH6KnaL4wAYmvWeflnC7hyNSJwC+RkDRL0TLkm64+Eac0ClBC8rkc59tZd/x2HuahkyTvnHmnFmS1sk+Lbsr4dtadG/pGUCVNbyOjR5ON9JmvPPWZ7ee7agUAkNgK+qa8Hyd6RkIa7d79WP48x2pe5GkTyVJn8+nZuR+mfWKS1h4JlkgTjLQlYnASDoGd4WH6hK9Ocpoy806DmFtkLjvnV2DlyYoYhUge4qQKgLJr+tkOBluovi718xNqyy8hAtqg7E0vFYCM4L5rGEqW8tOEsz696N1kkVIfgZHfs/8+/4lJ4MjUL9y9NkH+4U4h0rYeGh5mVNfT/FOzMg5bDWXz+/CIjgrX1PDrgsmH3vzPbh8r/1Ht6p1S+tkOpqqtBbl+6FLdtUa6Biv9rf9+slrZE0YsRjvjBeIosbTJwD6lJf5r5JcnbTzncMM3bYbn6U3AlrxUq15cEowOyUjAeu1Gubd6atHaowV4gNOZZ7hmuofth96ccLzLi6OKL5peGwxZ+awvzEz9fijjQ/QU+tkCtuAVO4MFrgaMWWOSpg5Hv/0SYRurPtR22YF5p9R7Y2jCb+dhIsy1D+6RUhZX+YqhkWJG5bcXfei3a76SK+SxDdQjW4+WadG1VGPQd1PsZ0uMeVIBkM7r0wqXDsUICBlMqW3beHFUcRPSZo8ebNuevE1WqYFEEAbz4Ux7cv3QZUAPp2RtSnIYc4dgVK8u/fYiICWrlT1hnZrQxkq71NkpYd7RLMleGkwq1uaHCMi/R+k5/zWfGG+jXYDOPKa/ZKxXOc6uucoi4y3pIgBS7l6bQMM5inkUNnv0oMOaSYTNDE6XfmjiQ/QUqrpY8PPjPKqvq6GVGGzI/ZSHc2NZeWgbZFYMMCvljxEBIF0EILVxelSI1nVV/4fqeegpHQVI6fD8PLGXtM+rmFzmDumEUb/k7TjUhmJ+LbAaYIFLh2LpJgBO3s9o1L8eZrcMlZ7XlHI8o+hnO1gmBtLRwffeOagx7R11v0mObz/v4VXND+O6NbHW06XcS9VLpH+UCPyOGI6PofOr1rSrrzxDceI0ZIl5f64hLyo4qq0D8CEoZQkxWp//hxvnf6aoDXW8fBlKn6Xp6+l3qn9vnHVKoHe4EpU2xVCk2WXZOcsK9dK1L8mhn+1g2eign+FVzlo349gVyfH9kh17Z0hi/55evIfonKodsf6KQDLwP/dYcyUtKJbZk7F9S+Jsf4asSxyp7Dof+4uRdMpxj/aB9TC4V5zp3j00tqNuNBB7yY9z75ax4/hYiufMk+y+ngsoyYZps5J9vSY6F+uJ2+htmiumIvfDTvI85Dreo+6QvdArBv9vN9sXD+LRjbW0/KqYrflXptnJydwwHZ6sa38JZyGTEpXE/hr8BH4lUsNRKOeC3SwqtYKXH9XH23+9+wTr7dTP5ysNyMmI9x1kWYqliUpBEopcyoCwXXTdkrRQ2KEDYihU6xJFZkRhaXeAR5tSvtknMVu2f8BjgIDPvvR1+FLG6cXjGeLe55edCqjDccQAgktHYVxXMZhJv0ndCXoS8Os6C/1OFA+pRcztUM5O0cfqavKiA+VcsBuT+oG8DNSccKPWBlfy9f3OnPXKtx5XGpCTWxfnULSqK8QFEFa1Q39CrsN8tF2O/qHFar0HpWnLfXcU4URDb7oZecP64zQlGw31fTjjbKmx30nB5+BbfPr6p2qbyaXr6UJ01T1LmOaqvxyuS9awzssZvYgaHDG4ovV1f6cDSaB4SC0cW0keAGXpybVBKgCdAy9pVf/Z4W3MKG2N825FR5a8Dc5w6+IclSHIE1M0qysVCupjNeJ/mA5QzAQ8d0gnLlgXQGfaU+pZVyPfLXO6GclHLTKrEsScd6mX/mtVliAGr12cau2llH32Ddi0QOkL87egn+1gnFoeY1urXVpPD/6KgJZ8O+tOiyzrcZ4tCYvlbWWMZ9hZzlpo3j0mJakCIGWG00ByLOvL0LWfsPG0wcbThgEWK/EuWl9rAUjI08hKfBNWs617XYrnzMPcIZ14WLwtQc/eyh5+95qqLfR984+lT7VVSb6vMvafrs67Qr9OLL53B14y3653RncjRXyInsKP5+fp0+qEVkKg1XRAEIQ8wAagApLsw45AEOAFFAeCgc6iKL4XBEEAlgMtgBjAXhTFjAn3kspcMD9LAXPJCMB78yuyFmjCttA+3M55lnlmPdROD/59bkeZJwN4nW9Dsu797PA2Cg+oyd4Vs2nx8wqdTVMWPKNoVlcwgmJF9/Bh3WguHX6BFYVw1+LaaeuP89P6CaR8YyIG+rN/qRTjR9v+g457W6BiRnclxYw4Yc0Sm1NsOGijtp62I4HlwFFRFMshSUkWCIwDTomiWAY4FfcZJOnLy8Qd/YDVSe/+r0dWK3vuvBgiO6SblO68GEKmzxX5WLMerV0K4uthIxsd/PvcjpwLdtPjwzMm6DTldc2UWdfDBt1l1zYfVsWknjF3vM0W8vS7leTrcpyqwLcPRim+/5hNv1Z8/mb77nE5+vcxUmtixAlr+rQ6weNXqo3L2mQlzg3UBzYCiKL4TRTFD0BbQBp5cxPQLu7ntoCHKMEXyCNNYf4nM2+VM+FD7zG4RDPW7ctBscyeNG6ej8ofttK1zgoc9iumFUsq2UMko4jkTAHUIRhmxv7KM80VExG2rgNn7X0p5pc8l+2z9r6MdYtJ1rV/0Z4RJ6ypYqB62qrNSKAE8A5wEwThpiAIG+JSlBdIkHL8DZLsxQAmQMI8XCFxZXIIgtBPEAQ/QRD8oqMitOjG70FWK3uCC/vSqW05TG5PBeBZvQ5UzdY6Vdr3PJ7689X7P3Wx943WXDER5/ZNZV7vxuxxOsn1CqoTpihjy/YPtJg+X6v8g+lJvtYmxNRWnV3pd+VZ3ucqz2kjAjpANWC1KIpVgWjih/6ALBNxksaooiiuE0XRXBRFcz39pKfC+tW5vK8Ez//tT7Vug9hisCSju6OWp5GV2Pw/Rf95TWQNlCykTViUldqzq9LsQk5WZQnC28AfbwPFJb9ifi24XsGHFoGjudelODeM8qVKkNHUJOb59t/SRyAlaCMCIUCIKIrShcddSEThrXSYH/dvaNz5l0DCFDyF48r+c8xb5YzP+5sMrFYXk1wpH/ZOcVlNoF77VOiZIubvZyd5SuDcLZpe4x5wtN4n3oyNpMo5N/werMe3ihv13xvh+HQUc94Nw3e/ROT/0fuHiTVdWVI0ErtoSRCYj82Kp/ZX+UsS0SgCoii+AV4IgmAaV2QNBAD7gV5xZb0AaT7s/YCdIKEWEJlg2vCfI6uVPcsK/GB8wVDNlbUgyDlttraWf19S6ymB/ZVn2F95xoKvxylttp5rfafz78lIRk6uQ45TFehcKg/BfdYzcI4+NhMM2By6BIMfPZk+RTFl+1iHRjgs7JraX+cvSUBbj8EhwBZBELICTwAHJAKyQxCE3sAzoHNc3cNIlgcfIVkiTFk86T+ArFb29LhdFVAek/5X4GlkJWodKwXDVKdVVzdScJq+jWDAXomjmv2VZ9gPKI17zRt8veVI5ZNVabh/CMtWSJxy6oZtxy1ps8m/pCJaiYAoircAcyWnrJXUFYHUNV//AXxrdZ68dXLwftnnjO6KSoxe7cFyxlIAbpceQ0w3Sbal5KwcKEPSzjPc320n4JYplU9WJU/TSTinSut/SS5/9w6kE3deDEH36b/k5NcUgSJ3XTlx8gAu498B0PQFTOt2PNUEICEJxQBgQsxmDgW0+aWchv5L/HUbTkf6TtiTKgbCtMC7T3n6HI/3ZRj94lOaCEBCpLaFOv9biF75jM8o7OT9jF3Zfo2NTOnJ35FAOpK//yTu75iDfrM6Gd0VBTpsCCS03wEAYrpVximNBSAhTtO34TxhKBvHCvSen3G2gVP9e6P/9BymPuM0V/6D+DsSSEfaWPUhOAVm0qJuczVXSibefcpzoHlfOpfKk+YjAGUMnKPPsW+hWLZVzC+Rnmz20BzE5U/jrwikMx0/TU/2tT3eNKHFT+33iWvL82+O+Py/vbML0aIK4/jvj5+V4vfFgua6FIRYmEppikgXEUt4JaVFV0pmQoWBaIHQpV1ESZKVBoZWln2JEGrptbqmrmubuZYEUa1IWZdaTxfnWXt3Wa1135nz0jw/GN4zZ4Y5//c98/7nnDMz59n4CyNeG1L3Yw+ElbMvMKVlZ3YjqBphAiXTfufL/HB04AE9N2x+nV83PVKAIph/8QIzH26MaLlhBOUTJlAya7tX8+TjA/vDTW1dxqqm29i9bQfnnt7DouOb66Zn2ph2tm3NPyhXy8rZF9h6+Vbueyf/dGNVIEygZBYvWsHGSwN7l+C5GRPZvW0HAG1vPU/zqLl109M57rvs3YD++PnRNXRdmcOM/dv/fedgUDTERKOS/iBNUpKbidAQ08uFjt6Ejt7ciI6pZjapvw2NcovwjJn190RiqUhqCx2ho2o6ojsQBBUnTCAIKk6jmMCbuQU4oaM3oaM3/0sdDTEwGARBPhqlJRAEQSaym4CkByWdkdQlqdA3NyS9LalbUkdN3nhJBySd9c9xni9Jm1xXu6RZddQxRdIhSV9LOi3pmRxaJI2UdETSSdfxoudPk3TYy9vlk8kgaYSvd/n25nro8GMP8Yls92bUcF7SKUknJLV5Xo7zY6yk3ZK+kdQpaV6hOsws2wIMAc4BLcBw4CQwvcDyFpLmR+yoyXsJWOfpdcBGT7cCnwMC5gKH66ijCZjl6dHAt8D0srX48UZ5ehhw2I//AbDU87cAqzz9FLDF00uBXXX8TdYA7wJ7fT2HhvPAxD55Oc6P7cAKTw8Hxhapo5A/2wC+7DxgX836emB9wWU29zGBM0CTp5tIzywAvAEs62+/AjR9Rgonmk0LcDPwFXAv6UGUoX3rCNgHzPP0UN9PdSh7MimAzf3AXj+hS9Xgx+vPBEqtE2AM8H3f71Skjtzdgf8Uo6BgBhU/YbB4c/Zu0lW4dC3eDD9Bmi36AKll9puZXemnrKs6fPslYEIdZLwCrAX+8vUJGTRAmjZ/v6Rjkp7wvLLrpJA4H9cjtwk0FJastLTbJZJGAR8Bz5rZ7zm0mNmfZjaTdDW+B7ij6DJrkfQQ0G1mx8os9xosMLNZpFB6qyUtrN1YUp0UEufjeuQ2gUaIUZAlfoKkYSQD2GlmH+fUAmAptNwhUtN7rKSeR8pry7qqw7ePAS4Osuj5wGJJ54H3SV2CV0vWAICZ/eif3cAnJFMsu05Kj/OR2wSOArf7SPBw0kDPnpI1lB4/QZJIsR07zaz2lcJStUiapBRxGkk3kcYlOklmsOQaOnr0LQEO+lXphjGz9WY22cyaSfV/0MweK1MDgKRbJI3uSQMPAB2UXCeWI85HPQZUBjkQ0koaHT8HvFBwWe8BPwGXSY67nNSf/BI4C3wBjPd9BWx2XaeAOXXUsYDUnGsHTvjSWrYW4C7guOvoADZ4fgtwhBQ74kNghOeP9PUu395S5/pZxD93B0rV4OWd9OV0z7mY6fyYCbR5vXwKjCtSRzwxGAQVJ3d3IAiCzIQJBEHFCRMIgooTJhAEFSdMIAgqTphAEFScMIEgqDhhAkFQcf4GUhha+YMI0nUAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -88,12 +88,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -111,12 +111,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -141,12 +141,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAD8CAYAAACcoKqNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAB1D0lEQVR4nO2de3xT5f3H349J2/RGY1vaWloplwoiDMROUFAQUBwiiAMRh0MnOjd1url5/7nNOTe3uenmfW7eRRSnKKIookxkwECLIJdRoEipbWlrSktJacL5/fGc05wkJ8lJmhvSz+uVV5uTc3mSc57P871/haIo9KAHPTi2cVyiB9CDHvQg8eghgh70oAc9RNCDHvSghwh60IMe0EMEPehBD+ghgh70oAfEiAiEEOcLIbYLIaqEELfF4ho96EEPogcR7TgCIYQF+B9wLlAD/BeYoyjKlqheqAc96EHUEAuJ4HSgSlGUXYqiHAZeBqbH4Do96EEPogRrDM7ZB9ire18DjAp2QIYQij0GA4k2bEBmogcRBgSQmgFY4nCxDPX1TYCN6C+RR4CDgCaAHwZaonyNENjgpFFRlN5Gn8WCCExBCHENcA1AjvZPkqMXcCEJ/NHCRApQMgQ58FijGJgch+vEGmnAycTmJn8J7ABc6t+VMbhGEIjN7An0WSxUg31Aqe59ibrNC4qiPKkoSoWiKBVHy0JyCDiQ6EGEC1ecrtNA3Fe4mKCA2DH9iUC5+v/mGF0jQsSCCP4LlAsh+gkhUoFLgTdjcJ24oxNoTfQgwkAnQFOcLuYCauN0rVghE8iL8TVORIrA8bovJhF1IlAUxQVcDywDtgKvKIryRbSvkyjUJHoA4cIdx2t9GcdrxQKxlAb0SELdMiZDUhRlKbA0FufuQRJDUw9yEj2QCJDG0TnuKKEnsjBMNBA/tTsa6DxI/KQCF1IGPBoRL2kAoB9JRzo9RBAmOhM9gDBxoC3OF/wScMb5mt1FGrG3DfheL8nQQwRhogwoL070KMzjkJv4WvMPAus5esQmC9L1GU+93YqUQJIIPUQQJmaXAg9C4VESWdQJdO4mvkbDHRwdKoIFjxU/nrAhySeJ0EME4WIa0A8ypiV6IOZR00L8XXtbSe64Agvsm5PLr8fcknSrcyLQQwRhIBdgBFK0mwv9kozVg6GzgfhKBQeBT0haFWH/nCx+y53UU0hnInT2YQm4ZhD0EEEYmAQy/BSkaDdXhvEeDahpQa7S8SADKx7RNxmJoB88xXwOk5q4MeQm7tJGSMLQhuTFkCl4Zx1NgZLXYfeORI0oPOxukJ4rTib6iUhWYAxwMewbmssWhpBNKy4sDOJ/9F7RBvXEVyoxwij4cfkDNJFHOu2UUUtKcwLGUY60TyRJEFYPEZjEQID5PhtzgBsh43poj/+QQiIF6JUGvXKAy4HTkIaqHKR0sJ7oPIhW4G5YPOY82knv2tyo+uT2Ukr2hFam7l4Ba0gMGWTCjhkl/JJfU00ZAOm0U8xX0BH/4Xw64mTcb1v49tjNSWFL6SECk/heLlLcdeH9IBdA4Rg4sB6aEvBABUIKUHIjMBcohoN5x+G26sSAcZDd0omoRAaDVxK5GH+FPwn4opVsFvc7j7P6/ZvcV53xnXy58PCUq1jETC914BAZNFAgpbyDcRwPUMkIVnMm3775Brg7vtc2Qo+NwAQmAeI+JHM3q3+1Vw5wB/R6APqVBj5HvFEyCrgFDpyawoHCFG8SUNGak8KBcSk47wZ+i/SIhBtYczG8P2dsUBLQ0E46HzCJL2b1j4/7zAKMg/+bcjsvcZmhTWA3ZRwsiPM0yITtDKKDNP4w43qYGN/LG6GHCEJgEjD2YVTlOgCsSJ3vbkkGiTYg9usHLIADheZGctiWwoFTUzh47XHwIDJl7MQQB9mAYbDyutO7VAAzcGHhc4axcsLp0qYQq6IpxbBgznQuLH2FD6SZ1xCHSWN72qAYDcIY+0uzcGAHYBPf4tMHT064bN6jGgTBd4BRD+PJIQ+FE4H7oeQZqHkvMeHIJTnAA3CwOHyOd1stHCi0wDTIHteJWI90AW5CSj+ZwEnAfHh28CW0k44dR0TjrOUE/tXvO4zqt5Y+rzdHTzS3wMGLj+NnaX9mkwkfnRsLtZzAyDhGQDmw064r5/Q0VzBy2q3wr7gNwQ89RGCAFODOfsA9hB9skgdcCyXF0PQ8HIijYSwFSPk1HJxynKEqEA5ac1JgIljGuclsOgJ74XejbmItp7OXUtxYuZA3IyYCgA5SWc2ZlM7Yy+iVG6Xa5SJ8+4EaIegcAZsyh/IL/hiWa/B/DAJWhHnRCOGC4o5apqW9yXg+onelmgyS4PyMHiLwQRcJPEDkBQozgVmQVyDPEy8yKJkAnVfQbRLQQ5MSXMUWsmmliXzcWMmgnRO9SlNGBhcWdlNG67hs/spPKKSe8XzE3M2vyVDlUCiABWOmc737EZqrixk7YDnuMPWN3ZRJMonHfdoEmVceYZZrSVLFWPQQgQ5RIQENVmCcFBB6PaEG9MQIGUBhBfA4HMqKjYXC6nbzfZ4DixRly6gmK4r1muopZAtDWLLvQv7BfO4Z+n+MGrou5HFbOJlP3x4LLkgZe4DDpGIJc0bvZCAHTzyOzN1HIh2+OXwGPELCV38j9BCBiqiSgAaVDFLKod8DgBvqd0Qv5qCXBfIegfd/OJYyqil010fpzIFxGS/ixkJHlKPyLLi4jBe533YbbpeFw6RRyYiQx7mxwNBOqEqhMK8+bBIAqbOvTjuTc1kVwchNoh54gqSIGTBC1BucRIJiIZREVjGOCQn4IgceGzWPIWxl3CPr4HmoXxsZKfSyQN7lsO3pvjzFfNrJYAavM8q9NurDDoTPLKdSywlRPacbK0/wQ6opC9v20E4G+TRGRARuLDSSz7ucT/m2GBSjcwHPk/CaXWIzGxRFqTD67JiXCAqBH80C5hDbpgUWaKCQSk5l4XWzsV/n4L4Vv4EbwzzPNNjz2978getoJVs9tYu8OFfDzKcx6kRgwcUMXuc5vh+2np/dDTWlnQx2fXIKc8e8wFrL+OjbCjYRN1tkpDimiaAQ+NF8YAax/yWa4SJe51Guw42FJvK4Y8L/MWzT52Gd5hAZOLB7TZQ0DlNI7NUCPdJpx4obV5QDASJZ0UGu6tpYwj2Hpuas2z6OjYPKGb4tiskjm0hau4Aex2xAUVxJQMXw9TsoVgsDZNNKMbW0kR3Wy4203g+gijJ2k0E7xdSSHudsBzsOUjkc12uGgjuCG+nGgoPjocwJWU7O511WDD4jOgNqAZ4hae0CeiQFEcRbLCkEfnQFcSUBAJrhTFZTQD0DqCKtGwH3Vtwcj4MyqhlBJVZ3fDN5rG53t2IIAiHaRshgkMFExTTV53Gc1c1xVjcN9YVcysu8MPi73VMVW4CHSJrswlBICiIoOB5+VRyfzlxdJDCLhChG51auYiA7sUZJEU2jg3oK6LDEv7pGPo1RP2ckq7rnWKkemLUvfI2d+qZCv+1N9Xn8oOmf/LT0Pg6UR+CO1UhgU/iHJgpJQQRYgCnws/LYxumfjKoOJIgEgJgYJA+RQVNcy/BKZNEaNULTEK6R0P94cze2g1T2tpTidhlfz+2y8Nf6n3C+5V02DjYZY94Ldg0ukuHSRxEJQLIQAXRlis1HFm9JQa7eKXRPUkgHflUKv/oXjFRKpHcggSbSgyceF/XKOFLPtUf1nGaQTWu3rPWxgBsL9RRSSzHtZNBOhp+64cbCXk7ksDO0FLW2fhQT3B/y/uCxcoMF+UBqr1zYMbiENYOH81DxNfyNn8DgaH+r2CPklBBC/BOYCjQoijJU3ZYLLERW964GLlEU5WshhEAKRVOQLvIrFEX5NOQoBJAFDIXCufCT3cjCGWOAfyOTfp6GHWthOTIk3SihJwWZGpAOzC1G1hd8AP4+eC6tZDOAnZQnuGlZ5tYjpI44HHUyqKWYkyzb42orsLrdZFla+TqKJNR9icDCnrcHQyPssakb7UAJ5A7eR6qlAytumurNS1CORjuX5r/MvYPvpJZiNTfBAy37spAGaQw+Cnt8mVkbnwEeBp7TbbsN+EBRlN8LIW5T39+KTNgrV1+jgMfUv8GRh2yVatO918Ie+qt/x0C5C8q/BJ6Aj5bCp3i6E48Epj0PK+aegRsLjzGAw6R1PVgW3Jzj/jDx8d2uyF1kweDAziEy4r5Cp0XZc9Dd8W/dMwzqkPdZc9k5gGpoXtVHPvHjFY7LCs/L0urI5pm8K0nnUMB9aimW93Z9RENPKEISgaIo/xZClPlsng6MV/9/FvgISQTTgecUGa64RghhF0KcoCjKV0EvchweEgg12v7A/TD+Dhi/G1ldB6h7PoeHmB10RelVe7T1KTIPzQI+iO1xvW4B9VRTFrV4gnr8jXdm0UEqrE8JTvYuwCGkBBoG0mwdptylDRTQja+QMERqIyjUTe46PF+9D3ilpNWo26KPHKTofytwJ2R3SL98LFbbowV7KcVliVWlD2N8RTGvM4PDUerj1R2XZENHITFwZABgz3SYf7biewuigm4bC9XVP+yEBSHENUKI9UKI9fu/7uYgXJC54wizdi9hCFuOWTJwYO8KO44X9lLKgi9+wFKmROV83TF6tqwpisoYjFBgMnLThQXl+pgNI2aIlAjqhRAnAKh/G9Tt+wB95b4SdZsfFEV5UlGUCkVRKnofH+EofHEQzt2xiivdT1PK3qQkhF0VRTGz8Lux8ATXUmUZGJPzG2EvpeCCDzmHJvK7dS43VhzYIzKkdpAqZVMzCLMxbKqtg4wgtgE93Fh5O3fCURe8HykRvAnMU/+fByzWbf++kBgNtIS0D0QbHdBra2dySgcFMI/norZ6+qKeQn635/+Yx7O0WzJCHxAFpNMOTtj/yYncsPPv/I2fRKQmtJHN9R0P8+RDN7L1xZHUus1VN3VjodZdzI4NwzGtVZjdT0V2TltYz9FHnHPUtVEz4z5cgDQM5gshaoBfAr8HXhFCXAXsAS5Rd1+KdB1WId2HV8ZgzOZwEM7dvQpLP3dX7brmUhu5WxOX/bFmxHA2dQzDnuZgEsujbuFvIg8aU9js+DZLh09hJouien5fdFjSpN9c+0lrBP+pmcD2sYP4vuU5TsdcWnQb2VzX9AidD/eSxrxGaP5TH5pnFkObgM26nUcr9B+whXbSqVvbX/q0NiONf+djzugcJsK9T5sYBuOABdEfS6xgxmswJ8BHfkWYVXvBdd0dVNRwECbs/g/ufha2MISPOIeL095JSEMLgH9zFm6XhSZXHtszB1ERRT9TOxn8m7PkRLDCndzLZ5YR3Ml9ZLhjk5C0jMlsXTvSb3vzqj48mHU7w09bw0wWMYAqr88PkdHlHWgnnXs33gdv4G3tbwOeEbAIb5HfJtg19BT55NbpjmkDtoGJWibQCEfaMky5EI+4LGSEmdDlwoJyLYijiAiSojBJxSlCWb8whhfIhYeKr2Ehs5nNQm5878kYXswY+87L5QLepl6VGdM4zJmsZhRrw37QfNFOBi9xGev2nOn9gdXN2D4f81P+wiT38m5dwwgXWN5m1cpzg+9UojBvwON8RTFVDGTXxlPkBNav8m0EdvktR05wPWxgaI4oAi4i+PJWBTwOjAYehOPyA5dPPrItE16Q5xx3wbtBTuqPR7iOU4btCuuYWCNYYZJjgwiAT4eezGkbt4C9k6/69qbovfjlhu47L5eL+Re1Bl09TmI703grYjLoII3nudyfBHSw2Vv5a86NXMQbpLmjIw7VWoo5ec8OqDaRHVKH/2TWI5jfvxF42WdbFhjaW63AUPWVhTEhPI7s6gSSNO4NTAZHFqlEcD6M/eX7YdkJBrGdJ269KTpRhlrj3W5WXA9GBMmTaxBjjKzdKleSX6XQp35f3Iw5wUgAZCnthcwO+HkwmCEBAKcjm2vrH+d6Hma3pSzs62hwWSystpzJ+ZZ3+VbT5+ZIALrn27cCDgUcnZ5XIOJoRE7cu5CxsNXqdgcy5O1xvAlpCTAVjvw8kyONmRxxpnKkJpMjmzM5sj6TrhKGjeGFPruRquhl9/9Dms9DNYsJBCvwKtzwyv0yZT6GOMqcHJFjf3GWbOtVA0fGZzJx61t88N6FMb1mKBLQsJdSFjGT2Sw0XWnILAloOOJM5ZU9l7Gp7zBesMxloLsq9EE6rLdU8Av+wKcvjpUrvBXZGdZMhF6osG5rkH1cAK2gd9/VFfqrBi7oSiNxISf840jpYA3g0iRf4X1cDVLicAFDUyRpaMbPfHVs12K6CIueMPZSyvh+7zDp7eXcdf0DsNLUKSSswJswpfQ12QwlxjP1mJEI8pvbYKb6xiUNVlEKhjPEvvNymcZi0yu9AztvcWFXQFA7GXyNHZeaY/81dr5WA4ZcWFjETNMkoMfWPcOYywtssQwBoNWSTaMlj0ZLnmFNA5fFwnOW7zNx5Wo+fWCsx3CnTTwzuRuRPsRtqHH7vqHhTXK1d+leRlKHA7mquzp1OxqowhoR1eFfUswuz2Em9sNIanBjYRmTWfDwdO9+jwXI98XAMGTtypvV12/hv58N5cLSV2gnAwuumBu4jxkbAcCqoSM5a/EGWAUtv0+l19ZOmTt+kKgmI2kk0BBB0PlJbKeNbNZ9MQ6qZK1+i9WFc1WuHKMNbKObcTq6F0GYU9TEkLQtrG+qoLNaJnr3Pu1LRrGWabzJl5RSTC3PcCXrnhgXOAhnIMb6OnhW5neRoWWBAv+0yacnjCVAZTsEdN1Z8a5ekU7gaha+RJLifa0s5CIRyPVoRTbB9H1GrGAb28y3cjaFlBgsuJnEcrUcvJVlTO4KnGono8uIrMchMqilmFL28sS0m2B30EuERI+xUI8C2F+QRe9tbd439iDdqy1nhQPjUvir5Se8zkURkQCA46CdtkW9Qxe7HAyUdSOJymWFShE6QaeR4PtkIUVoTUXQJlMb0vW3WT1eUyUG4pmEGlHU6M6Vpb5fX4//BNa/9w2YshK4lXOnbh/h+Vcb71h1XMGgCRS+sAJT4YwLVoQ0Jg6gKqLYkWm8xbnfXtXtAqg95cz1aIDeDQbLWyZSVTiIFMPCkRBOhD8Mvp77Ou6k3ZFBXl5jxJV7Opxp5m54DVBiBWsM86qtyIkSSBpwIUXvGnXfLCRBFanbq3z23YYU1+3qqwpvkd6pvjc0LjbjSToHmcumJwNN7NfbADqhy+ailrvxfeLzCU0CweDCY5QMgu4UcfmQczj3vFXS8BgjHHtEEAxWZFYj8u8Xpf05pUH6gjvToDJnqJ8e6MLCG8zgr00/odOZii2rvVvluzQxPSScgDP8dNouuETofSA4EdQgJ7PGRQ68DXZGqCN0ToAdqCnUnSxF97dT/Wt0AS3lRXus63X7dYLVoLd9G/K37E5EYh20kh00c9Js0pIRWsli22/7MnjpnpjV0zi2iCANvijvzynbdgX+Qa2gFMCi3Kl8xqmm3IwW3MzOW8j/OIkvvXKuIoDZG60Zt8rClAo0lWANcuKOJfgksKnXqtSNzYpc9beFMd5wYEVKFttKdBsLkI70Q8jVvR9SAmhWP3cBTUEG5PKoKHoEC2byOTwgHFLPD0QEpeztdjj5i1zGb877XcyqHx1TROAshsf5IX9LuzWgvrdxcDlLuSCsdF4LbkrZSyl7WcvpfqWszMCFhUMdGZiupOZEWtS3CchPkRPHrtOhXbpbqxGFywovC2m802M0wSULXzFfgxrObIiQLsEgxxpCAEN8jhPg0uwCwUggBBxELlmFQCl7yYtCkQQHdjrvgJT3iAn5HjPuQwBbLdzG/dIOACjF0KlbwLcN7ssiZnYrp780glbhLizUbe9Py6VFcC+hV1onHjtCG1JHXQ5Upsggn8oUWC7k6yMBm1Pk6w0DEtiGtNAHIiAXYaftBoU2XrMpw77wJQ+rti3P58MDeFe3DGBYdeEd7hxon0CwASWwa+0prG85jVa1CQ1EjwQ0/CnnJiKIOzOFY0oioAP6bG7uevtU7lyu+eR57hpzB9fxKEuZ0q26+uApYBlOpGDd9v5wPZ7JuBy5SpXhPek1aIEuemjGOCNoz2Ibxit1I5Igxqv76Ce+y+D6+s+CSQRZPufSDIEauTgI7HrUDJVhWcoLkQTQiifQIBtJEp1IF6OBncChjisLbzXJob5cSFVI/12tyPugba8E5+ZcNtpHQz6cN25xVEkA1OzSucB9UT0tcKwRgQ8mshw+gns/uo+mO/Oj0rnHgpsRVNJIvqkCGzXby71JADwTJdAqbSPwBAoGzdVntBo7kSuj0RNRgjEhBbGzYMc/J0CfLai91wjDF0OR9gtNh6/C4178yGAsgJzo6cg64zvw+Py0qMQqcJWAVRdvYFWv8QbytxmLJ7NR/zs5kMSsfa8S/G0rmru1Ef494ixOyolu/cgOUlk85zymb3ivq1ZntHBsEoH6rdM4DHbofd2XUW3flUcTQ9hCZYic2NaObPg5/hPeRnCddSz0v+ALv835NJJHE+/snAFLhPFkGYr8/tpiZWbFtSFdbFU++2vE4sTbz27XjV//hBXh7xqsU7cPxGNz0OISNEIBOQk15CPVGYfuml6ifzoyU8elbte8Caqvz1WuUyl00CSjEvzRhpS4zvcZSwA41+dyeGIaqVEMCbQia2sc/lMqs3YtkVwXtXMfS0iDV8uncsnON6Xr7TWgDObzVNQvVcZu9lLaFTGmuRT11X5bVhX5+6CtyAfR6M7Yganw6Lgr6BfEef3DAU+w/sbT2EAF76y8WD7gdciHWVv19C4/F6HDhW3ICasP/rFjvKIH8kJo++uv40IaOocGubYvipDfYYm2oRPD6MEuaBfNVV9N0sho9BtrhGb0meYtMYMYGPS0gKUqBrLtX30ZPHZP1BqsHlNEUFeewyW/fsuThgpwRWyulU0bFlzUPdIfrHDcRQc5sjlTPrzaw1aJ56HTHrJ8/CeSHbjJyV197uFUKkOmLKfRwRhWM4bVzB/3FG4sfM4wqunHCwuvlsSg3fl89W+ROp5gEoI2tlAPeaCJpEkQbXhqCmiuwnChEZIVcGnxBRoykAFHh3QvjWE1aPEIBmMPZvtIIDQjpJa/MHjak/Avuozf3UESft3YoWhHizSIrcfzzWPkNnJj4dPFY7uaXRx5N9N41S3BY3DS3w0bMB+mDn+VEXzGKNZGFKikkYZGDBtmn8bWf4w0nvAlGLsJ9dAMgJGseFnImH49+YULTXz3s5+kSN3/fKQ7tCgDyJDf5/fpyBq6nRFeVIWmriQAVtycQC0ZHMKCCytuXr1lKkNu2cIptbvgWrqVi3BMEcGO8hL4AXLlGwjYoWhibKrIVFPmyWd34W8o02AkAQC5D+7jWcv3o95k9HfczqKrZvLCJ1d78gD0Y3EQs94AXapBpE+d5uqrARlM1IAsjVkIUzMkCeT7HDMCmJoHS5qRkkF68GtoRlH9PdFLCWbHPtQZNftABocoZS8ZtHvlM7STwXoqWF9cQembe5nwyX9kncRPCJuojyki+AV/gFXtQEaXelD3Yn/4XvSv1Uq2p1puIBec5iLzxRXwR8svok4CINWG7/Eik8cs4/Yxv6PmiXLvh8bIoBcujETrQN81FKrAU4NVyx3ogwwwygYOQEmGbJkX6GmeizQQvqvlKhwCmsFZ6BmTC7VmQQPUWMGZ55F+NHJoRJJNKCnSBVTaeKnoe0yyLO9WeHEGhyhjd8hy6nsp5dkxpWSMaWciy8l9wSmNiavkVw1FDMdM9uH7Q8dy3tUfw1NNeGWpjYUfffznqHoNADZwGu9dPd1DAkY+fiseK76GK+AfYy6TzTRjjFay+Rl/9iaDLDzGRc3nr0FbGUN5GrTv5TthwlUpXMCfOsGrGnIKcDqSCBSwCXgQc+7URmTAVp2mV+RChZq4VAU49PpGOobZjFPVVzBoXhSAgXDJ9GcjIgOzJBAIFtzk08jprCX3BSfi8p5SZdzFvfCUwc2wyUnb3S68vqin0CNKGj38dqQua1ffW4H58SMBkBlxf+AXpMw84DHklSAb0E7F21WmxTa0GZ3JACXqsdorkCckGKq1f3RJR7ZRMEnIMeYL6X61mzxfPrKugHau0Rme1Gg/r0UAxgoU26EdoicBgCp4ZeU8doaZ4thdEgBPi/i3mMazcy8Juu+xQQRWuIG/wdxCZLCJDkNh3dvjWGuiabNZOLCzccNoqZ9WIF1dmsHaJq/ZRQJqcMrpj63kpVEXxY0ENByPg5fzLmXovP/6R88VISfOeLxX81CruhYHoIc+JsAImuqgkacDuYKPTUE21C4H6yhJTnYkuYwPcU4jjAdKSqCk0DsewA7StaghgC2hGuMaDZr6YPTbrId3nr2YDRguxn7I4BADqeoWCYSLY8JGsHFwOZf/dJHK5gZf2QUrN57PsOGfk93NwHq3WkaMzXj0TxvyAa5EPnAG7sHLeInjo6yemEUG7cFVoxLkuPW2A70dQP+T2pHkZ/Rkaa7DNp9jtf/153TqPh+PR5/3PW+43oss4GHImrSftrt6e6IHs5ASwppDyDDlA0gbhC5dW80r4CM87l7tFWocjfCfZRMonlxLoM7R2bRRSH1C2vUdE0QASB39I9/CFXh+gWp4OP8nXN/nr90ig50MYP9ig7K1WXhyB3wxlLhLAr44k9Wssp5r/EBrkYUO/G0GWoASeK/qRtBc+W14XHHaqwbvVmRZSImqGhlnkKX+r0kL3QnYKYHWvQVs+0tfTm35FOe1ahm4LO1LgTRMVgNlYBUeKcSKRz1yqC9fT0UgVMNrG+cGHnsWzB3094S06gupGgghSoUQHwohtgghvhBC3KhuzxVCvC+E2KH+PV7dLoQQfxVCVAkhPhdC+LfCiTOG793BXe/cASUqCdiQIu9FeAezVNs4RAZpEbp9HNh57ZO5YffWO2/i4qi3PwsXIfsq+Bo1Ndh1LzN+di1CMQtv0shH3o+5Crl37WPz3wag/ELQ8Ho2yjUC5QLBkfsFXz1mp/eCL2E+8KAztOHOCI1QNziHwQv28O+ccZ7tTvCPUGyQ5DUwwHczS0iaBKEPx/Z9OWCpe0rU7VVmhxcKLuBmRVE+FUJkAxuEEO8jY/I+UBTl90KI24DbgFuB7wDl6msU8Jj6N3Fogd8c/B3shbeYRiH1TGEpHaRy674/gsvCGX0/5kLeYhDbcWOhgzRayaKVbA6RQUeIksddKkF1mGMrgwt5K9JvFjWEXIGy1JevRGM25FZDgCfuu997gUUrLpedND/3XKe3TjoTW6GIFhpsfcECrIN9M3IpcTSZr+MA4JDt2ubxCiNaNsukr2dQCTwdbzKwBl/xHZircKQFjoVAc00BX/e1U9iVHxEfhCQCtZvxV+r/rUKIrUhH7nSk9gbwLFJzulXd/pzaB3GNEMIuhDgh7l2RDTCNt7xi9O24ebDPjeTR5LUiWnCTQTsZtFNIA24sOLDTTgYO7IakUE2ZVAkCrRCB3G7nOxkYMpwv9iijGooUqAlQwsyKJ8FIW9XCCbAJsl/v737Jot2XY9rDpvsd+7zZzPBpa9i4cLTJgyWu2PMC8/q/QspSUHIEf//7XK554HlYnoe3oTBEAJI2nmBEYMc8YTpTIuom3V2EZSMQQpQBpyIdu4W6yV0HXWV7+4BXdY4adVviiMAqDYZaV2SQk91sQUkLbvJoIo8miqmlgzQOk6oeLQtRLHdPCq4SGH1mhal9Ei8NgKoa2DoI+ERX4a3jOzGfhGP0lFlhwvQlTOMtbtz8JGyKaNhwEN7lfE4Y4fDOIQmFuhRZsBagBa5+9QX+ePPP2fHRcLyKompu02AqwDYCRoh2eYnMzrQ2GTEYb5gmAiFEFjJf7yZFUQ4I4Vk5FEVRhBBhRSYJIa4BrgE48YRwjgwfewb39nLdaCQQCfTSgt7Snm1ppdl3Z+0hcuCZONp2ABtR7YgcM1ThUXn0bkAzNoEAyDm/jg9WXkg0bKRFC1rYMGcIp1Vtibyakguu5BnusP3Fe9Jr388R4Dgr8t4GU02GEln9iDjCVByBECIFSQIvKoryL3VzvRDiBPXzE/Akfe8DrwqeJeo2LyiK8qSiKBWKolT0Pj7S4YfGgZNTWI13R6Dudh82woW86X2zHciHow6PKKsPOFGNQ1u0OnwJRiodFPUxmJWNeIr9+KKNiMORJ6UtjwoJaBj5+lYeuODHxrUEjOD0LlMHcBkv+hNbGzJxzOh7al6SUDCKKg2CRBgLzXgNBPAPYKuiKH/WffQmME/9fx6wWLf9+6r3YDTQkhD7gBX2Dc3lbcsU2d5MRSqHY+KaOZuPmTP9n/KNLwEcBbDi5lu+8nkboVOTG0N8Dv4kYpfJT1GFE3726mMcGiGYM/ufoQnBCik+9rgTm/fjVUvGCSzvhMYNULVFEkId8v5qLzMS0WZCG5Fd6rmr4a8tN4QsahNtmJEIxgCXAxOEEJXqawrwe+BcIcQOpDPu9+r+S4FdSIHy78CPoz/sEMiBTwefzDIme5EAELFrMBQsuJnCUm8/81GG09jgrb5sJvQkdxK8EKkTv0YmJRN3UL4iHDO/SbjA9ia89OpV1IzJg4og2qoVv36CYhncf+sNnpoLa0C6MAAOgetzqD4ANeqrWjFH9llIEvlIPWc13qqGA0kqqu3FuSSXB9feznImRUU6OExqSMnTjNdgFX5ROF2YaLC/AlxnZoBRR5osPrKWUbLQowHiHahxtKCDNN7gIg+JaUlHZtCIcRyBtsppZKG6IJdwgXkPQSRwQZ8FzXw153hOtH9J55pefuR8XNlBw9oLtyx9mFuv+Bv8CYNJ7htj4FKLogSBHWlI1H4LkERgwxMoZUQmVfCC42qYDOfwYcTPbTvpbKCCZUwGfhVwv29GroFV6nuflp/MUqYkjATS6ICxIfoRJmks5/NcztYPdLFfwSIEfdGIXOnW4zGMNiInmjYBVZsIjcTNPVa0oIXD23L4+ILT6D/7C088QD68XHgpfGlwUAtcMvnZAC5B30pIKcE9CnYCxyBoklIw6bERXnj7aq5tepzrDz4sa1zo4MYS8qWRQKCwZg1J+liGgTTYWF5OJaeGFKNiTQQW3BT13Usd/YPvqPvV6yNslhpNtJPBsoOTvR9oLfIvlJqjnwgaIfgmL4FXJmZc3WNfwtgvP2Vn3lAOTEzhQ8s5DKSKU14NXJDGglt+l3yg7TRwbUGWSHch7d7DIEt48i8ceCa99r216Mlg0MdjBIIDOp/qRWcbPPWb+dzNPV0fhZrc2j4W3CH3PbolApdUBTZQYUqXssSioqQPzuGjsMqfrVx8Po2mg9Vjg5e4jLY1vf0/CLVMOPEnCm3lD4Ll/hpl7NEEvV7pZPqC9zhlQZCWd+CpLGRFbZCqlzAPAcJ70rvweFca8URhRhNZsmFKB2ldLzfWkK8KNjCeD4MWu4VkIYIjhI7ZdiKLNK4BHgIeAO6EomdaTMcExKLijy8u5E2ZaWgW6+VETBS2MITXNgRIhAnET5obNJC0ECgdV0UFG8IZYtxxJ/d5AqVcgFl3s2YLMeNSDAO9b/2S79z6L2YTWfWeCjZwGS8F3Sc5VAMH8Doy0su36WglMkLhM6AD2hvApXvIrCth1jNL4A7YcV4JlYzoivzzhSYmxRKb+JYn0kyLF4DAk8MF72y4mB+e9kTMPBqB0Eg+v3XfGdgoqOn6vuM2Crjx/dyJ96qo/RZZMIjoNv6INsqX1jDuw3dZOex8tVx7P2jT6n1ZQ6/2bZgLINLUr2AY7+Sn/CXmSWnJQQRHkPXZW/AEmbiA9+CAkUFHB5cLDqwBpkGZrYbyoTWSUGbJba8WTO3qZRgPiWAhsz3lwvW/rg3j9FkrsArWnjaKs/l3zMenwYWFp5hP8/I+xjtogTTB3GPBnh6j71kG5EOxO7Ep1yHRIslqpSba2YE2XSv2UL+JmQzMEqTXQLWbdIVt63+3MtS0+NhnpiaHamCEraFJwBeHnHBgPRxYCQeuh/b+MOviJfygdgHZtJoyrnQH7WSwa+0pxh9a8e7+Y8OTvmuF3719D9sj6KIcKT7mbFZ+EESHMZIEfOEKso/vSldCl6oxy/Iq5JgZZeIwmWWeVb0GPG3TXOBqMj4oC1mbIVD+hZabMRoZuKR5Zmx4+ija6SLNH435M4P4X3e+hmkkJxFshfa1oXcLBZcLDiyF9pMkIUzig5iqBlsYEryzrjb58/GU89ImTDXctPIJ3mZKzMYHUEsxv+TX/GHn3YFXtjb8S52HAyORV+ddeG/nNA5OTM5HT8PF770DjxPgN6r3to9o0s5YAqsEdiQBjCaw7UXL4yiBuWNkgZJ4IbnuhhNYD+2feNsBuguNEHoXtjF923sxI4OlTAntbgvmn98MD792S0zIwKXWS7jq2ZdYd/U4+L0wtu67UCv6mjyx9vDadC+7wX5ebkbBbWm/Mz/4RGAEcJf6fz54pyO3QuMBT1Ul/QofCHaM3apGsIKdr8MabneRHDYCDdukaB8rHGiBXtdC3keNNMTAf++IRopZHTz8yS30G1MdlRWhgzQ+YjxPd1xJy8+LvIlqG54KTVXIiWojcJKRL7KQK6HvBDAyjGoW9TL59mPOlupBlHr3RRu/K7jJkyyUBTTm4v3D1IPrEDisUJ0XulyZg9AxAwlE8gyrCTorY3+ZA2tg7FOfsnj+eVHN8mongz0bBofe0QzWw81Vj5Iy9QDX5T3CeD6KyKOwl1J+0fFHWm4rMl7hVyHbh4F3sdASQluzA5EABA5EqqOrrPmm+mHSQ5SMRFABb3Ghz8ZOArp9zOSWOPH3pASCNT6GbZ9LJgEUYK009sUFd8LkOe+xNPM7UTvlYVLNlcvSQm+L1JdeVdDcbmpQTufDvXgw63YenHQ73xn+L2ayKGSR072U8ibTcGBn1eJz4Y0g4zByG2rBMSUBjtPpsUGfHhv++rVuwqTaOkjKtI8TQRxRZME9LYGsEfArHZZO1w9gZhY5kWRshgiKnJR61faJPZKDCNqgPfolAgLiQAv0ugnsf3dERZyvYgB/4aehiaARuQo78VTktSPFyoHqPr6LThvwBryz5GLeKbkY20XNzMx5jcksI1+dyR2kcR93sO61cXLia2K+ZonWT0gtCSjYKqa5srSnQ/83H3M5/0ZPlo48huRsgQDG94SiBe9sypp6ZECRvpZhIfLLqNmNZn4P8EhEIZBii02qfDAkBRG4neDyj/+JKQ48DxNG/adbKkIHqbzBDF5ZPE/eZM0nbAQ9CWjQVl8t7sCOxw+tTVT9ClINzgdzecF6NS+MuBoGK9Ao5Dl/j3/fgTXq/w79QBT5oT0l+ENZrftf7+IaGuQYX9jU8Q8FyhROH/BvNTTWwkB24hwHtvdIrroNHXj0/TqQ/Q3AIwEU4gk5VpNyq8EnH8gYJg3g5+RFnm0YKZKCCBKG+2DI/C1etQzNwoGde7ibPc8O9n6QNZFYr3O34U8CejQCT+n21082bRKW4NHJXcjc9seFf6KQPvPPL21W/wU6ZZBMPh4CCgQt4CWcp8UKXNrJuL4fkE2rX55HB6nMy3yGC2e8xdwVr8U2LTkcOOGScc/yyq/mGdyvFAyLmW5GNnUJJfZrEpUmcRnBrtaFiDOOaSI4UAvla2tYPmoi+TSZZuHVnMkDX9wlV1wjlq/G08HXjr947gsXdE1aV4p/ExFNv6xCkkERxlGKmvtuPcAWPI089Q+vTmxxdcpVr06VDrJ05zQyAoazck+C7/R9K2hr8A5SWcR32TJhCPft+A1JUb7Rqra018KE24KJeSpceDwwgdzDZVBy4w4KqOcwaTQapMo31BdSWrg3LslxvjimiQCgc7DsdZBHE2fySch68ouYyYKFPwjuZ6/CI9pr7B/MvdSlk6YQtFemE/nAVQc4n2Z7cHXKc3EIudSWy881tcPpm1ffqdo3UjwPsmbI9IUZF9hQGDv8/aAkoMcWTubn5b/hTw3/Z1wjIJ44EdY9oDY9KQJqyvCUcE7B05DVB9uQkpgWR2FFEkMZMAn6Dt9GoSr2WGnnRINEphMLpYGwklM5k9VxbXpzzBNBylfgzrHQQAFLuYAzWd1lhAO6SjxsYhhVDGDxsjlhdzIKSvBdakSKObeddkw1nhBlkGRSCV0GLHKR+m0v//h3K+AyWunUlnAu9Xy+ZKDFAuhJSB8oBDAQxl7wPnlhVjWtYgDPjrmEeS2vJNSlWDcqxxNIBDBUwOYyJHEGqUakVwkd6jYr9P/bF17Pkxk0UMBqzuQcPiSVw2EdGymOeSJgAaT++jCHSeUwqWzgNC8VwYKbVrJZ8uIseYPN/GK+RrhAxzRiXCY8FOrwGAY1vbMOPCRgRXZ97gWkGBcJcRlVn9Nt0wyZ+mg4TSVxBBlbGcEbqgbB61zEgClVjF3waUTHxw6+BNCJ/FG0FfsQtBX637/BkUcINlDAZ5zKKKIQa28CyRVinAg8DjN4HYB02v3sBG4sZNBO+fc2mu9Wo48P0McI6OHA4+YLF20gJ70CLgXq1P+94CsG+MAGQVc48BgebUiVJVT0XBTwBNd6mqomAEU7WvDqXu4AY6NrA9L/2QS0g8Pn97cBc7sXGLSTAWznpIiPDwfHPBEcaIHLW2R2YloQMexUKjnjuyvMie7a5NFemrio+e9r8C+caea84IkP8Ksn2x0DUycBPQya0czs+MwEzARBK1k8W3pJ4mTVDqRubw/3wAZvY+qlMPK0Vd0aihsLm/hWdELXQ+CYJwKA6pwSUx6DPJpC+4tdGGfutSENSlVIItA+tyLPORTjKsD6lxZ1qLkTu8hgH+YTBHSwaQPQ0O7vGTDKGwiG8d0vCbeMyXByt04RORpQ4x7QqWshJCegq+Of9nvNVaISJnyIdCoZ0e1w+FDHH/NEYLWaTxbKoJ3h49YEX/VqCN3MIgu56lQgM9fK8EgPWXjO70sEemhkkC+QtoB6PMEvGkTglVUjlmCT1gmwIbxOPVndjw5qJ51VQ0eG3jEWaIHjSg56eLWLdH1/yHQ8BOGTdOQC3g3UASB87KWUR/gxi5jJek4LS0JwY+EwqSGJ4Jg3FmYUw+vMML3/ILaz5fwhdL7Ry3gOGUkDvighePEKzaAfKvbAikocvaBurLp/PZANZPiXCtP/3/Vee5h1qoETZFjtVqAZ6lZB9djQ0pANhvaJtJupN95gBmNzPo2/B6EUigtrqXGUe7blo3aJ1jwHVuRvnA20grWX/0yKYihAI/lU15exwzWIj61nkW1vpSCtngo2MIQtXcbZdtI5RAbptJPBoa6S5mZwzBMBlvB7zU3KW847ZRdLMV/T+7UY/moTJzCjb2vGRqMHymibFrRUdwDI9pdagpKL9nDrV7F09YAUYJMMnsofaywNWT2vzRu/Tdnw6m6rB9WUSfVgTag9o4g8sA/7ipZfFMnvqcWCOMAT+mhFumY1GJAAQLWsAdFd9cCFhYaDBRxxyWf0iMtCS6OdFuzstA7sIoXDpOHosNPSaKd/n538kMfDuraZ3oc2IcQ6IcRGIcQXQohfq9v7CSHWCiGqhBALhRCp6vY09X2V+nlZRL9AvJAVPhFk08rQif+VRLAG6b+vQz4wendbLBBsftkAeznYAvQNCCq1+4qyArniWZH5ws2wxOAcmkqjfecXiChk2xDR/B1Hw5I5E2ieYwt43v3nZdHy+yKPSqChGjwGVYPYCyf+5N4G7ih8gUNk0N5mfD81UtixbxB7dg6ipaYQnGkUUh82AZmxEXQAExRFGY6sw3K+2tz0fuAviqIMBL4GrlL3vwr4Wt3+F3W/5MUsWb4rXDiwexv9NNiRZOC7XT+BzCyWWnCKr0gfCna6Hx7cBS0MthBph/hI2gv0Yci+z7oD9jw7uNvdjFxYWFA6nRVzzui+O7EYLur3ErfwR77Duzw86yp5zkzv3RbxXY8UYKcrHdw7TdKXDIQ813zgUt1rKNT7leQOH/Xuwi5pwAxS7K2MkJFlYSEkESgS2s+jxVgqwAQ8EfXPAhep/09X36N+PlHtqJycSIusDXV9U2HgiZmFFNFr2j1dcx1N4FRC6/7geQA1IgjXcm+0EAU9PlCz0HSf/wu84x8CLXjrYb2XMz58tJLNZRveYOLK1WTnNkROBlZYOe50qunXdd5H+TGjSj/i/WljYSzcMef/mDznDe7jTu8ksUpUN69RQJGgiwQuRRLHQN3LCnUv9qfKHSxmPDhaycbRaDf5PV2k2Fu5Mu9pBho1dQx1uJmdhBAWYAPyKz4C7AQciqJoj1cNoNXF7gOyqoKiKC4hRAtyaQkvzjJO6LwiwuOW9wr8oQO80+m0CbUPXIXQmBJchegKO8YzgbWJZ+aOGe2j6fZdwUjN6oYqdazTDA7qRZetIGuUp56AkRfDZ/z77z8Rx61bIo6sayK/a3VuW9+bEeP+Q2X/M2Sf7TCwb1YuP+MBvz4XrWTzC/7IxgOj4TXdByXAM/h0eNbutRUvI+xYYGqQizugeUkfWqfXR5Q3EI400LfvTi7kzZAdjQLBlPtQURS3oigjkD/T6Xgq3UUMIcQ1Qoj1Qoj1TUG6V8calTlDIzswYi/ZIRmFtj7AOVwEb6wZCpo04Xu85q4cC3I1+xRYB+xAuh19XY8acoGB/hWJHCHGUQUr9403P26vUx/Pxo2jvbZt/GQ0s0c9E14Z9Bx4nB9yKECvxY37Rvi7RjXDrx96gT3Du2aEmXtUA1u/GBl2Kf0O0mh1ZJvaN8V2mMksi5gEIMw4AkVRHMCHwBmAXQihPRolyKgW1L+lAOrnORjUolEU5UlFUSoURanIS5Di0KsfvOlXmy4K8AvUMYjacypS9GzEE7/vQD6Ibf67A+b6DNTgkSg0osnCYzewImMXGAn0BUYB49UPDRjZ2g/K8iJzj71ro5JTA05EI7ixsrrpTH+iccErn8xj8ZTzpMkiBCEcuCSF3025iTeCuIaL+tT621MqA+xsZHfZhrl6hWsIu1iuAzudTnPVeorzahkQgTqghxmvQW8hhF39Px04F+lg/hCYqe42D1is/v+m+h718xWKoiRwzQ+CyfBVBIZCIPhEyAdUndSTvoruvQqn4nE76l/BxH+NOPSn0yz3RmMswRMlp8EGFOUhZ1QunjJczXhJBxqBGEkubQG267Ee9twwmPdenM5OBga1oh8mjUpOZcniWXRWBlC7nHDRB8sQfRQKpuzh3jk3w6kG+xXC1Za/8zyXB7X/HI+DlNE+klCg+xrI7mLS8FuzttyUVNBOBuu2j2PPngEmTgzHWd1UsL7bbkozGucJwLOqneA44BVFUZYIIbYALwsh7kV2JvyHuv8/gOeFEFXIJ+vSbo0wlhhKVzu0cNBBanDRuAakEKR/oNsxF6pKcNtB2wHgEDgL/QN8spDbqtX3gwkcuJQP1KXj6eCjQQ2a0Y8hkArjCHB+3zDpVbC58ttsPv/bnDFxBRbcXjrzXkrZ/MS3pYHOoY77fPx/By1nowb2rzmR/7P+ifsvupXWXgXwCdILUA7/LJ9j2oVZlrebHSXDpSTgIoBaEAAu5G89wsS+m+HwqDQK1aKkGbTLkHUf1FPAZmsFWM1N7LzCpoi8BL4ISQSKonyOAe8qirILaS/w3e5Edh5MfkTg5u0glY/dZ3vCgTXR0IWnTdh6bYMGzeXkQhrm8kAjIAf+WX2BdFAHyImbHjgTUMsUtBM8FDofyMoAZ4ZHmtCLuXoJQ/Nc+Eod2ti13zHY79kGLIL/fDTB//xVeJuSqzAu9Ol7fRe0vdGb9KlNzJ/1FMuYzFcHi+EglGaaqwJsxd1VILbLIFuCTyFaBdqEcSKSGYnABiVX7eBC3uoiwEABVwOoYtSAdTSRx1KmUNU0MKiKUMF6Msx2aw6CYzaysNc0ePWKYCZffzSSx4ovpsp6gS5kckojMqjoI5CrvougtQJxIaUFtRhmoChDXyKoAymyW8HeK/gkt2MuC3CozzX0/2u2hmBoVF92zK2KYLzi+s4JF/I3nUroKEwXOJfk8vDgWzz72hQ6BjSY6gXRQZrnfoKnspAdtX2d7l46UrzJQJO46ggcv5EFw+etYTYLTUdbWnBRQD2X8RLb8waxjMns3+cfk5BiOxy1tmjHJBGk22DHKyV8yDlYcJuKI2gkjxUbpkrxVYMV+SDkg7fVXdc5F/BEpWmqgQu5svcKnO6q3RlNHKadrhj3QNJAd6F/GrQH3EVgXViLbzATMk2AcwRCNR6pwKn+X4ckOHuIY52Cw6SaIoJdO4cYGwiLMOhjqRZ8talj0HxnmjSoSYlaoNUkhUsGPMcIKiMKuU6lg2F8Til7WdhnNtX1ZV7uxFF5aymIUtXXY5IIUq6Dp7kSCy4yaA9pJ+gglRWfTA1cXNMO/ku49r4dT3MMKx67QZNMFgq0cmuBLW0+tQKsQTIKNZh95oLtZ0NOQm2ia19Hs5TbiB4hBfo+y5E2jxo8LtUspBvUjidNuAjIVycpkFJ0wHyJr49EGK5gdaCaquR773TEmPPzOm5Ii05Lcztfcxkv8nHh2az84nz5HNbBoFu3RyXVGY5BIki3warfjqRVvYtlVDOMTbSSTSUjqKW4S0JwY+Fr7KzYNymwWwnU6j0ZsjGml1qgJwHwzLxegNXzcAe6C23ozpcOiNBVkjQDVhmBddq2INfUw4p/jQQAtoCzhC5S0zwIZiUDo+sYeScc+K/KbciJMAkY76R/n52k0YELC3tbSnG7rJTl7TY1QTpIC35f/ew0OhJuQxKUb+CgShKT05ZFtfhoNq1MZhkr7eNhkQ1c8OGt5/SoBpEiZShsoIJS9jKJDxi5eWvXXJ2b+Rp1o3JYzZlsYQh/cf+U5o/6hC4pZkO64hf5WuD1sCJddXl4fvZ2qMowDs/qIgHVB68F9AS7Y3qDZTXSBuBrwa/DQwT5BD+fUS7BQKAyHWgCZy9PnwUzMQ6+0MaQjySBzfi7Ro2gEs/JfbbodnXTL6c6xCC8sWvPScGzRQcC2zQ2sPqPJ1AMQT6GHoHuwoKLH/V5lMfKfgZVkYXGB8IxRQS9yoFZcOO2J6W9zleFPAhFK1q4mHe4OO0dysZUc3XFkzi35RqczQeVRhu1hhiaKTrAz62PHfDS01P8J6O2eoJ3+DF4SEC7nO8KrZGA/phAMCIBUEXyfuCqN/f0aDq9Fuyk16PzdWPURP7NuveabcAII0xcOxTaUgL/Dhq52QW4UozjOxwBji0jZI/KSFHKXsb+7X1WXX4uezYOpmN4WkQNcn1xTFQoslqh1yzgbmAYUIs/CfiiA+aueI36rCJM5c8YPlBatVtdw0xf2PFftTW93Fcs10jAqvtf20+bcFkEjh/w1WkDrWjatQJhLDCwMPA+2ko/WDeWEqSEMhS50hoRVZb6+WA8gVCBbCiB7DVhoP8pX8h4BSO04bGFZGEsPdmND805v850T4dwYcHFFJaS8uABWBM9qeAbLxGk2yBlBjCHiL5tr5WdbJ1QxslUh1kkoxNPsM4huvz/XsgwXyQzUPSgHkWEVzzUyHWoGbz0kkega9XgrRYMxJusfGFmbHq93Iokg234E22d1PG7sxqm0UHvG79kf/WJ3rYITYXyxUwkUWm/y2A8dgzNvmGDsrTqiMdkBhZc3J13D+4fWqISQwBJQgQWK2RnQuvB6J63VwFwI1IK6MY3Hbxij0ky0Ca6UVVgXyIIkYGoIdjE8kUootB/rl/lHHjEXJdu32Dn06+Yg5H5C5EaC/XwNRhq0o7DZ3udLM3VXbE4n0b2X3Ei3Ia3quVLPGXImgO+ZJaPJPM6pL1hEszsys6PHVLpiJrHAJKECBAgcqBXJigHu08IvXKAKcB5EGauR0AMXrGHlyZcxGXb3vB/KKuAan06hW8cgVbGQW9MTA8eTKStro1Er1uwXi+3+WyH8Pz8NcixZSFVhWiQgBH09g5tgrYBM2WugBE6SMOCy/RE6T/8C3aNPcXzfarxLwo9mMASjWbwHAgjR62KmVoQSyQHEWiwqoRgg86DcCjMCdArB9nm73K62v1FE3NWLubjeX/msWd/5r2CNoJ/zH460r3mG0ikoRVcBvXuNBKwq+8b8YS72gked2DmbtoNtmkEoRkbQU62/ADncOHV1qvbZffVVT9nUh2tjmyOvJvpHXKsSQXatSvlq3VytpeLrt5dSHNlHym1lUHK6AOU5u0NKTVYcEmJplrdUIL8zbep78vwlN0JBhtsaRmCI+f4iOswJAoiGRIDK9KEsr6PwQcuoAPaVQkhPQ2E/mHPRRa4HAOUgzIWRGWMB5sL/x0xlNOXbfK0OnciazHVaSHGRjAgipJe3iupLwmAGgffhMxRSAd7P+NGqWZsCKHcfHqvgqafG5FLDZ4GLUOBm0JcVxufFhBkBYrk6jmJDxjBZwxkJ8XU4sLCVoawiJksPDibts291fBt3XfQdPJL4eTZsj3a7pYynI/n+sdm5EPOtXUUpwW24reTwZ6Fg72Np23IGo0O9fsNNfEdVYwd/j4X8qb5A7qBcNSDm8VjGxRFMTR9J5dE4At1lcvIBM6DzvvBrRtxe6ZNVrJRkU0rRZYWoqg6+aMZvr1iM0WTd1G3vL/cZkMakpZkqCrCIfxnnO9Pne7/sS8JgOpqywNnvTyv44C3JKFFuZm5k6FEfzseY6F2Xl8JxIm5Ss0abMBohfsG/AwHdiazjFQ6yKaVQhr8GsukAqexgdPYwL2Zd7Fl1BAm1q32rM5WPK7FJbC1bKS8xrt4q2w6l2rL8iIKLghc0LO+pcDfg5KFvKcl+Cc/hUA1ZbixJqS9eaRIbiLQowMcOVlBmztkd7TGlgSCQSODRgFvZMgJ64V0sOrKXGnWcS0ir4TAIvZYYHkvZD6DGsiThSdwqA35fgSB76iZZ1JzlYFHHNdb8cFbfQhxrqyL9vPrzF8ykeUU85WJg7xhwc0wNvHA9B9zc82j3oVFG5HvHyR4vwUXsAZ2jBjkFYCkR8A4Ed/vbhI1e8po6psXtTyAeODoiSNYCb1vagvYadeCi8wdR+I2nMksM/4gnwBhwBnehjrfFd0e5GJFwIgSvOobaCTgwGNAa/Q70uMKM/os0LU0UtKTSiVS99ZUgizkBDRaLccrPPC9H7Mx81tczvMRkYAes1lI7+u+9Gyw4yEsTYIJBhfwgo16d6H61tL1+hp7eBKOGThSqI+WlTrYZTiexiglfBw9EgHAm9C7uA3HLXa/jwo7GrzD+mOMs/mYZ/mR8Yf54DEUqm7EYD50bSIH0/GHApRApSLvWjXeOQN2vAOQNPG+BkkEVp/PjRDI4Kg3DoL8fnqduU29/vhO5vZ9hit5mmFEp+MRQCqHuY5H+JX1fo/+X4R/I9lgaIPmVX1oHpgHNTav7VHzyuiwltMZwpaYqQdurLSShRU30WikcvRIBBqehvLXa7w2WXCRuTt+0gDAaawPnNTT9YCmIHMFMkIb8sw8jEOB8cLjUtMi94Yiox+1uAAt9kAfoquRTTBEsiw4gYFw/7wb2NB3OH/mZ1ElAQ1X8DS5N+3zbNBcdmZjLEBKRZtt3jUiXQRPBTcTBOULF+z4v+G8xGURHGwO7aTjxkoHaWHVhAyEo48IOoA7oHyphwzy3U3EKLQ7IIbv3mFsvW8jdIXf7kCzKZTpXiUEjuTztUkEQrDJpLcd+O5bAvdfcANX8gylmKsKFAkyOMSfLT/zVkUGIwkwlKQDwb0qvi5QlWh7z/uSoRP/S+/hX4ZHklXANtj82re73ejFCIdJ87KVNZInMym7gaOPCECSwR+gvFaSQaozWEWgGGE3XDX7Yf8HRHNt+aKRwIY2TYQPJBVodoQ6PK67mgD76mFDitB2PHq/S/dqRLpA1wQYlx7a98zCQ4BWmPr8q3yf500MpvuYzDJu/t69apk15PexEzqLEoKv7JoEVQKc76T/vC84ffJKBlJFNq0MpErmJZglgzrk7/luFNu/qcinSS2m4xmMG6tf34ZwkdxxBKFwMvA0sBuIcniyKRSDSD8MD6sBQ1Zk7bttRjsrdPUXzMI4mk+bZFb8m5xoRjEH3hmGoVxb2v5GaAM2q/d/tAg+Wdar5xpBlzF05DureJk5AQ24sUArWQw/+DltL/f2/kAzlhp9V801a2jE9SBnfB1D0gLn99dTKFOXHQGK0NqgZNAOsmll655hcFMKPNjJ9X3/QiENEUUcZnCIYWxi3Np18CWyDUUB7JufyyNc1yUZZNAeMuPx6I0jCIWtwM3AlQm6fi28MuFiLil5y7OqzMVTw7BLJ1e8/7YFqDLUhlzpA90VTf/XGwIhMBmECiCyAVkC2hSPCzIQ8n3+zoTfc3tcSQDkxCjIbKANHyLIInhPCBMh0MGCjgAKqSe7bysbrSOgUXdCq6yKNCRvC3mqe8be10HV6wMZxHa2MAQHxzOI7abJQKuX0fuZNumx0UuLX0Kfymbuq/gNzlmwPbOcbzXvoD43h0XMjEg6OLqJAKQ0EOohjiH2UuqtX5Ygw1HHIy37L2BsM9BHv4UD/TEaGWhGM6NrhDrXYKAqQIVeDVnIdN0s5Kp7Pbw1fGJUymiHC99S6F7QAo2MYrlCEUEWpsqbZdDO6X3WUlU0kObqYnLLaimz7CabNi8PQTrtDOPzrve1nIADO6XspZjarvThVA53HWfFTSl7mbV+CbyHlAACQY2PsK2B4ewAoMjWwpQH3+YtpoWdnnz0E0EL0maQCCIogF/U/9F/uxWPVbsaWCII3Gg0TPjeMX1Qkn6bGS+Btq9DgfXCuNGoHSlWa+efD5uHD6Agnr5aH1zGi2y0jvaf8JoHQduu2VW01bSCwE98kWI6pdeCm0GW7bgHVJEVRjmydtLZzknsZACNaqfpbNqw8zWzWciclYslAURa3MgJ/X9ex43XPcnD/a4KSzI4Oo2FehwkeN25GOLToSdzZFVm8J0moUa+Cd0L41Urwki2LmgGwM1Inb7axPmcIBumdPoThx1vEgD6j/oioSQAMIkPAqtDlXgCn6rx5B5sJmjgUNGA3WGPw3SBVB+0k8Fh0jhMGk3ksZdS5qxfDAuInAQ0tAEPwPUr/hHWfTr6iQCkrSAB2Etp6FXXDlxhsF0TYfWRhmaIwGhF085VjafunyYRhIpPsIGMdUjxuD61SEcfEgAoI/wJE20EzCbcrL5q8BRN0eBEEoTD4DirtMbHCxbcXTkWFtzMZqHs1BQtuIBXYO6O10yTlWkiEEJYhBCfCSGWqO/7CSHWCiGqhBALhRCp6vY09X2V+nlZBF8lPBykeytphDAdNRZIHA2k14dyI7p8XoFcilY8EzvY+QaqL6e6vxaEZDC+C1ga4GTxQxat5Iyt8/8glEvVAeRDSsUBGKhAERw34iC2iuaoVfoxAy3AOZUOLuNFbvnlw7FZzB6C63f/wxQZhCMR3Ij3cO8H/qIoykDga+AqdftVwNfq9r+o+8UWu0G1l8QVUxtWBE94CYVABOE70fUEYIQ2PL5rDZqUoenJDt3nehtCoHM2GmwrImrls7uDDA4xKm2t98Y2QucMVEDRxF2U5u2l/4At9B/+BWWF1RTnfEW4bcu7i2FsYk3LWdxy58PELDfJhVQTdvyDE0K4Fk0RgRCiBLgAeEp9L4AJ0FWT6Vk8pRumq+9RP5+o7h87uEiMncCs5d+G9L9rkX6+kXpG53Xq/uqlAAJcU08Uviu5Fn/QqHvpjWhGMCKJoTCAnUEOih9+yl88adNOPE1QNPiO3Q7HXXuQDL+6EBKRNMONFFbcPFP7Y1Jupfs2gVBQyWDOPYuD7mbWa/AgcAtdnTvJAxyKomg/dw2ghQT1ARlrqiiKSwjRou5vtMZED+uR5clyYnoVD8phcvEb8psG0+1deFp3lfhsM5Bu/Y41gkP962slB09tAiPvgq89w0pY3pbyMRvjHjcQCK1ke2dV+j5d+u9qA66A0sLAIdAybj+VtDAMgFLTD7/ugB2HNAzGEyFC8ENKBEKIqUCDoigbojQk7bzXCCHWCyHW749GDYGTYf+MLOIl4b1fOpb3tk/39MALRKl1+GfJae5FE0EufnCAXEbqwdlurDKYzaYzGpuGMryNmEBhgr0FeqxllPfk1/+eVjwVnW3AtdB34ja/Iii+aCU7qk1DAiGb1tDl9OMMMxLBGGCaEGIK8mftBTwE2IUQVlUqKAG01LB9QClQI4SwItdoPwFIUZQngSdBhhh394tQDsuYTNm43Yzd8SkxzH8B6PIDA556/Nvwj+arxnhlt6nHOPCsypqVXxPljY5rQ/dBK7gyAq/+ITPzDgD10FjuiRi0IYltPH5h0LNZGOxkccUiZnpvyELGCbTh3Zm4DEom7ghJAkBXNp9Zw2E7GTiwU0BDWFLBhbwVPFgoAQhJBIqi3A7cDiCEGA/8XFGU7wkhXkXW5HkZmAdoSsib6vv/qJ+vUOKR0DBLimo7GUhDeSEXu9+JaUbiG8wAq/xaWUWN/DjzUVKHd3CIDFZzJh2kUsEGniy7Ef5kcAJtpdXHv2uE4MRYR3eCN6emA53gSglOBgGjDtVzteFpSFKBf5l19f8tDDE4UfzRRB57lg32/6AIf2nIrHSkQiuRboY46inA0WLHnuMgPQwimN7wXniDigO6E1l4K/CyEOJe4DPgH+r2fwDPCyGqgGbg0u4N0QSs4OznedtKNisGn8EE53/kCKKNYhjPh5w0YDsgRWa97qwPvc0e18oDm++SnX31z0qwX96GnJh6T4ADmRPQZaFMx1MdOQi0+Hu7zzVdIOV/4TG6jSVoh+MNnBb6enFAB6nGFiejSe+E1o5s8tLMWeXMSgXtZNB2MLtrPOkmpYgMDhm0W088wiICRVE+Qq0pqyjKLuB0g32cwKwojM08cmF15hlem/ZSyooRMKH2PwGyASNEKSwpn0A2bQzifyF3H0ElD173Qz6+7ixe2/k9eEaYG08Rnp4GdQre5Zd8SSCAVNCFenCo5dX1KoBN58zR9OmjAIfIMB830gYtjXby+pg3z7eTHpIImsjD5bKo/+ebNqJm0xqVdm3RxjcjshDjHnB7KeXV4qlhlaIOikxYUz4cB8eHdVgeTVzEGzwz4FJ+85ufm++lqMUHdMtIp9VqOIR/9yUd7IT0IKz7YlxSqAcfco5/8FAUA8o0D4IvLLgpo5qT2M4o1jIo538MyvkfZWEUPRzCFpkfk2Q4+pOOAEYTsLpxOxnUFeRQtKMFCoBMIvvWmbBm1HCqDMsSmYP2IDHXCeuDLL81SCOj5go09ZB3gkvTg9TCmVbw7qcQRJUI9pto9oxKeOOUixIeVFRNWcwjSe04mM9THI+D83evlNfrAD7AY/HXigLlwH+vGMr93CqLoQaAFTd37Xgg9rEDEeCbQQRz5YTXw6KmdI5buw5eBTYhb1yh+jcHKFZfocghE7aN6tstEtDj5j5/4oGiu4zjCDSXnj44qC0bQma5dSKfsEPIUDUruPIw3QIpUNEOn8Mf3PdTftzn0YTFE7ixUEux/wfBjIKu8FyC+TTywY4L4RnMEU4tfPuXm1k06nI+nXIy93GHHyFkcEj+ZkkoDcA3hAiU/p7/S9kr7QLvIRM59G6aDvzdNpnI9mjlwIl4fpFM6BwMm3JOpoGCqJWNBhleetxdBzlyvU/mYh3GnX/JQNoFXMiJbrSyp6j7aCpAJ9I9WOa9m2ZrtOIxSlqRDmDfSEkjDqm20d4nPWFE8FvuYMkvZnmnXmskEOhprk6BvuavcQN/M08CGpzAShi5diuLxlzOv877Di9xGV9jJ5vWrojGdyvGcf4zKxOSGxMMR3epMoAc2PZZX7YziOmV78mIrcoIzmNFSgf9QLkWXsz9Lg7suLGonXlCpRmGBwd2ftHyB5yXqs01XBjXOzTMBzDS9TuRkoCmHqQjScCno9JgIcOdtQAcvYaihT4HMxxa4dHZVzCT1wLsEDs0UMDQZ3d6WqD5hlXb8SYDNbS7aPYu8mnykxqNcCqfseiZy7ufBGQDxsA/z5sjbRoqiqnl/nt+FfdiuwDiCb6hpcoAnDD4gT0Mbt4jCSBSpnUhpYUvQRQA840NkNGCHQelOXvZ4dR12cnCnwhsGKQ6W5GqQifeX9g3jt5HcrAJWR/BHmBQWtx+iDyIjzmbc/iIvDgru8uY7LG4+wZuaaSQhVRzKqDvmG0UUu8VExCMDM5kNc/vviY6CWxO4AP4QdMC0ue0s5QLAPWZSsJZl4RDChN5SDUgmngV5ma+xgtzvksTed1uHhEIOz4Y7r0hC5MZGQJJAsEmfpn6XvEccxHmOhdrgUi+UJOgFjzxA1b/8ExWcE7UJaVAcGPhEa7zkKIR4Y+H8tkbyeCQoftPK3FmRAbZtPL8imsI1MAqYlTCnIOL2Tl/ILUUcxkvJUQaCIWjmwhykDp+LPAMzHW/xvtzxxobp6KAoom7qLtXZ+Cw44kf0B70InRuRDxhw215SBuA1mMxBewlnirI2qpeLaQXYjzGfRiMEMjwphPF9zwxmBt/+Ff+ztWmovC6AzcWFjGTXb89RW7wlQZAfucRoQuMZNOKBXdXgxCQhU7+yC9kafdYYDfc9cgD0ki9g6SzD8DRTARpyLboscTzcO6yVXAnvDD4u1E//RhW81pWf0/rstHI6L5tyIlvU7dZkZGFv8cTjJSFbIbq6gRSZIt1o3iJgXg6IpmFNuGtBts0uGDJa7NY+t3XZex8jODGwl/4KX/47S89v4nDYMcs6D/oC1PnzKCdNDqopRjHQTvPZs7j3HtWxa4kvqZ2QtJ6DY7OgCIr0g0YDxprAJ6WLqVo40LegtuQUvx4PPr7aKQYfz6eQJ8S9b0eNmTL9NEBSECD0QoabN8apC5ehRrajLGUUAdX7XmW7Zxk8uTh4yUu85AABL7nI2S5cbOw4Caddtrq8mVcRLz6YiTp0nt0EkEuxKCTVGBUwvkLVka9oaUbC7mj98G1SBIIFeJbYbCPZumPFhx4SpZV42lsEghLUjhrz5qYkMFeSrn5g0dD122wIn+/MHE8DrKKGhncsCeS4UWGJA3jPvqIIJP4FR/RY2n0y3TtpozmbWH4TbPwL41mdoUxk4Xnu/K7fP4GwpIUbuQhWqPESA7srOZMbud38K7Ph0bENxVGDgpfwbfg5neZt6t1t+IEC0kpFSThkEIgESQA0ADDH9lB9XX9olbWqpp+5noPaMgCfoVM/Nbim4YiRfk1QY4zE1zYhnENBK02gj344Z8+MpZT5n7Bb3PuYiLLKearEBf0RytZPM/3+dXG++V31Nsq7Ej1aCCSDDbTJb3kXrovrMpCerSTHv92eYYu4cTi6CKCTGLnJTCDpTB91nu8UBAdw2FEab1lwL2dYNVZ6h02+WAZRSXmAz+H04ev5LOmU+ls7CW9Etvw9AuE4MVRHQSuz6izPzifyuVm66MwAu4adwfzeSpgjUCAw6SynUFd8Rr3cDerfnGut1RShLSZaBGQGkarf7M6GWgJVGYpNBKSN6FJBUnkPTh6iMAK+qJACYELeAgyfttuKkotGA6TSr27MPwDbYo3CQDYnXBtGiwXsu6BFmU3FUZOXsVAteBoWV61/A0HQceYVA6R0eUa3bzw27AkwDV9pQKrbruRBLEe7t18Hy9d9z3O4t9eH0/iA0rZyxP8kAUrfyCvGUxtGUjw5qVtKXyNPeK+BKNYl5gJmWRSwdFDBAXE10AYCFthRvM7vJw73as1dbhoJ4Pm6jDjE6yANcBTa+uA8y1kzXUwJHMLBTQEzalPU3vtaDkDGbPbWdc2TvrSfQuoWPFUP9ZyFELVL3DCrttPYVfbKV6bn7X/SE58rdaCHr7n1FSBEKhu6kd+XhKm9AVDkkkFyU8E/YBTkdmDyYCDIG6Efs9XR5SNaMHFELYwpGUH7QPSeWvANLa4ZY5/qqWDS1nI20yhyZ0vDYn6VSMLf2lAD6ubkzK3h5Ufr6GMarKuamWFdaqM5dceUG3ia9DqJLQhV+pAZBDIZekgsDtSSySyquceH+T8OrjDzC5MGvgSQRay2mcCOncld9LRFNj/cBYZHe1kzjqSXJVf58O/Zn3HtIqQQTuT3Mvp9VSnzGnXFrBCZDlYADcy/FSTfq6EgyOO409pP8eFhTeYweZ9wwJe4zirm8mFywJ3CzaBDlJZvG8GrLKFjrSzE9iI6MK/6YoGI++EludgQwY/XYp5V5tNYeSATyIyGC5mOr1vTZCMbgVORkYbOuHP9/+Ip7mSTT8/PSZqw9GXdJQDXAf75ufSSB6FaQ1kZrUkFxE8AxePeYcXioMbDi24GMVa+t9XJ9OifVfCevw73WhRaHdAJkf4JX8A4DdX/o4r5j7Ks/uuNLxWcWFtt0gApMpwSZ+FuGdbePv8KTjvChK+qUVE+kQcBiyo4sATPp2FpxOT/jfR1IZwnkyX4DBpEXsOEoY0WDH3DPZSSi3F3PHsX3hj3uSE2A6SL46gH/AmfDG/v6d1dEdrUhlWAPkw79aaXPiLptm0MozPmfPqYvpfUielADO+/GB4Gp658sds7TOY0/t4t/w6zurmJLZ38wIeWHBzak5lSDtAV8NR7VWH94R34enQvFm3TzWBuy2Fqze7oNYdm3yQmCJPBk01kYcFF/PmPSaNqwlYnpOLCCpg/wdZbCwtj3svuoigawysEYIFF3M/eY3p17/H8It3wONEtzTVlzB44h7W3jSezX1O4fQ+a7FltTOscFPUO/raccjaBYEQKnTZiYcAGvGXHKIFFzSv6sPuCBpRprkTKGaWyyKoIMuYfYtNvMT3ZMeu7qAjwCsIkkM1yAbmADdCLSckejTmYfAwD+J/sv1LrI3Ym+CUibtYWz4e5T64kkdldd8oIptWTv7ep2ytHulJfHLhyX9oJHQH4kATfiBwPTKEeQ3dk/hUdaRuY38GDpeuUjO1JNJpx2WxgLUzaaz3h0nlhSnfZW7ta7JDiA2pKlugK8mzBWNJyg18Ce0RdK5PCiLoKLOy67cyVE7T89xq8+ikxhqwX+HoKpw6hC2MvH5rfItT7gBxLYx6ZS0f6SrhRAvZtMJU1NRndWNXijPwBoEnURkym1KfKzAYci/axyTLckaxlvaJGVQygtc+meupLFWC+Sczq5OTT9lEAQ3MZBEzWUQ1ZbSSTRUD2MS32M5JHCatixwsuEmlQzYj5Up+xmMmLxYf2PkaXoD6lWC1QJ5aZ7NTLT51oA1cUc78Tgoi0CNVlWFkc0kpbmccPEKMU94jw0G6EpEyaOfbj2xOiOuHJvjRm8/y8bSzo1pVyY2Fz1uGeZ4S3xj/MmSEn5F3YTCcfutKvtvVMFvCt8hLBu2cyWrOHLMa1xg59layub/pNjrrehEUWZ2813cC525b5RUZWcRGAM61rgIrdJbC6pzTeYOLaCSfBgq6TvEZp0q7VDSqEnUDFtwMoIqpe1fAfEkCICd8fRwKmSQdEWiQ8oC8s6K7RrZYwQ3ZtOHgeGZtXgJLEziW12HUtLWs5syonbKRfJx1IYo+jEBKBpqKYAPGwzWzH2JQmMZLjSSOx8HMvEUscFwJTmG4b0rRAX6d90vO3bwqsBFWtWGk7IBxrGOcdR0HTz6O36fdygYqcGPhEOkJzwi04+AHlQvgYqiPQKyPBkwRgRCiGlkkzw24FEWpEELkAguR60I1cImiKF8LIQRSS54CtANXKIryaXcG2VxsI7efM+Gs7YcmGLdjHXSskw3gEklYX8KNC55k05xhUUuKaqAgtO6sTnyWA1kw/M41zGSR6UaigVDBenYOGMC6L8b5fdb3lG28zKWMrtwYnm7vgsxNR/hN3u9Y3O88nmJ+t8bYbXwCP3M+Bkuh6anoi/vhIByvwTmKoozQBSTcBnygKEo50jl2m7r9O3gKhF8D3VfAHNjh4u6eJUa4CbiZxJKAhhfgBv4alVM5sLP3YKm5nYuAK+CaOx/i+zzXbRLQcBFvMPyUNZ7lyqZwzSkPsaPl5PBJQI8mmL75PR7mOs7i48QZCpdC/XSofyKxJADdUw2mI9cCgGeRgam3qtufUzsgrxFC2IUQJyiKEn5eqg7OUWDLJP4po6EQTvWfWMMJwxfsIH1Oe7c8CK83zaDz8V5ytfetihQARYN2ha0KhEIaHczgdWoHFdNUn8egwu08sfcm/wCsSOCEvuv3c6P1SU9mZTzv42Zo+iyO1wsBsxKBArwnhNgghLhG3Vaom9x1dPXZog+wV3dsjbqtW6jNLAJ/KTHxSBYS0PAqVLAh4sP3Ukrnn3p59H6Tbj0zDWEjQTat5NOIxeqWpd2i7ZFxIcN845ne3gHKmsRLAXqYJYKxiqKMRIr91wkhztZ/qK7+YSUtCCGuEUKsF0Ksb95/xNxBE0mODMRkRgtc2fE0BdR3Vew1U2XYgps8mqTXQSM3LXIwFLI6OZXYLW8nsZ1ReWu5t+VXsSHeNGSBl3iZzrdCQ3Po3eIJU19dUZR96t8GIcTryHbo9ZrIL4Q4AU/L3n3IHCoNJeo233M+CTwJMKwixRSJ7Bnam74n74+sk9ExhIyDR7CnOcimDTcW8mjkTFaTwSEqGeHlYhzAzq6in2Ud1bitFt7+4xT+xk+op5Bd+wbIwidB0LfvTkq9hMDoYhIfMJNFpMTSWFyMTPaKtavOSveaW8cIIYlACJEJHKcoSqv6/3nAPci4p3nIItvzgMXqIW8C1wshXgZGAS3dtQ9ocGORfuvKaJwtCkg2tQDABp/kjgSkCzabVmazkL61+wEYGTLQ4QhzWMwc9Xbu75PFPX3+j3WMYt3Os/3deTaFKTH2mxZTS9HmONQBL0dO0ljdVxswg+Bl5RIEMxJBIfC69ApiBV5SFOVdIcR/gVeEEFcBe4BL1P2XIl2HVUj3oXGqXIQ4MC2FXm92JmW3mKSARer5GiaxvIsEIkHv2jb+xq10ZsKyARN4gmtZsu9CaLOBrZOUrEMxb4haTG18vDJ5yHDeWEWGWsBZDrYkrGQckggURdkFDDfY3oTU2n23K8B1URmdD9xY2WIZQvrT7QyftiOxacnJKA2o0MK0z+Zjvt2wOSrnTDkIUw+uYKp1BSv6nMFaRnFPy/9x2JlGNWUx6fugIZJCKxHBAoxBEsEGok8+B8F2LdQnMvAsAJIr+zAEainmAvfbnMtyWeO/B/7okKXUTqWS8S2rok9YLphQ+x9ua36Q7+W8REZWe1iNRSKB/WD82gM5R8BPp93Htl/3laQQjdU7B5gMFMOBV6NwvhjgqCKCQuo5y/Jv9u85gf13Z0njTryDpEcgY9OTFcUgmuDi2ndIiWHMhXDCYy038M/MH1AQQ+tXNq3Y4mxh/xo7v+VOfjztAXb9ukiqDJE+Zzmw547ePDThGl69cSq9Roc+JBE4qogglQ5+z+3c3vc33MhD/Pn5HwXPl4828uCF+7/Ltsf7xvGiYWI0cfOJpxyEi1qWSB0+RkjnUFz7BdqaPY1UW8nmHu7md7fcBLMInwxssP+OLN5gBgD1FMb3eQ0DRxURgCSDNDo4TCqrOZOHf3sVcQkZr4AVL53Bdk5i8I44tsgKB1Zi3xjWBykH4UxWx6wjchm742uPacHL+OnGyhaG8PMRv5GqgllkQufPYBGeUnZuLIntyxEERx0RAHToooo+Yjw3zLof7iY2wUZW4DxY8tsJrGWUbNiRiFRjM8hERsnFGeUNNVEPLwa5Ijuwx90wa5TK3Uq2/G07CJ4SbwUuho13l/NEzlUcPkoi4I5KIvDFVxRzxZhH6XweODGKJ7YCM+Cxm+exiW91bW6eloT+H5B+8DhLBAC4YASVUZUKWslmN2X8j0FxTRPuLKWr6YuGfBp5YuVN8ADSk9CGVFcOqi99KbBZ8PdRc/mIc6JaGyLWOOqI4BAZXRWB9Ggjm7k5z/DY3+dFR1VIAx6Ah+dfhYPjvT76H4OST8SzklD9M7ujlQ5SaSW7W5WlXFiop5DtDOIQGTImIo4GYbfVIxEcIh03Fu7tuAtexbirk74UewuJ78YVIY46Ivg3Z3UVfPSFGwsfMIkfz3qAA0tTZJRDqIfIqnudiPQIVACT4eHBVxnm9m9hiCfFKllQgGwEkyA0puWxl1IayeMrimkkP+y2cBbcODieasq6JqMLS1zzS2x7YRRrZfm07XOx4yDzziPm1ZP74eoXXoi6hBRrJG2FIiM0UMhaRoUUuRoo4AeWf1JwSwMVt6xnpnsRvR7ohJXIhyoPGTxyKnIVVd2QzaW2Lp3OjYUhbKGJPOopxI2l68Gup1AajnbF6ptGgLF4GqUkAPp74sJCK1m4sTCI7aQb1Cew4qaAhq4qVBr2UsphUmkkj0Nk0EQ++/tl0bspTvXsv4SrF7zA+F9/xPmD3uWhlpvDK6zqAlbBuE3rOPvWdTydO6drMbHgjqsHJBwcVUSwhSG0hVF9p4ECljKFpZYpFNzSwKNzb0axQWOuLL53mNSgxw9iO66u/D0rDuzUUizF1WSyAWVCshV/zqaNGbwetmsxnyaGsQkHdtYxiu0M8iOLmGITUA/l19ewM2do5BO3BcQd8IMrF/DPUZIMCqlPbDm7IDhqVAM3VrYzKOLj7TjYVtyX2txcDpMakgQ0WHGTxmEyaKeYWkbwGVN4m84pJMRC74ccOPjqceyf5ltZNHGw4uZs/h1xfIEVN/k0MYWl3MBfyW6JU/mnZjyVNFzIUOPuctDT8IMFCyignreZwoEdKd08YWxw1BBBd5DKYabwdrfbgYGHGBpycmWJsv7dH183BgMXw9q0UaaJLdaw4+Ai3mBYlLrWWnHjyMnyr6AcbbiRWYGx4JyVMKd2MesYxTLL5BhcoPtIGiJYzRh2BugufBiZ2JJKh7qWy5cZ5NHEZJbFJF9+X79clPtJjGRgA66AlXNP57D6yyQS+e4mZvIa3+d5BlIV1XMfJpUD5SmxVWS/JLYZrX+GJ7maWQuWxPAikSMpuiGfXJGuVH+wj9k5C7mbe7q2t5LNVxTzGadSbdDOqpVsFmz8Adg7Gdl3Lf10WWqpHGYAVcxkEXYcfvX0o4ni5mbEjcQvNToHeAhWlJ7RJQnk0cS3a6OTaRgunDnQnmmLeqclXxQ3NyNiZaBdC1ESYoLjvcSVLC8icDfkpJAIaijFuT6XZ/fMZwtDusI6FzGT15lhSAIAlYyAB4G7Uvj0hrG82TSNRvLZwhBG8Bnf53nyaYopCQDU5ubC/cgJGmtYgbvh/dKxXupAK9l0JiC2YU9xb36W+QAfc3bonbuJr3NtsQku6sDTgTrWOFl2L0o2JAURtB3oJY0y21K4jztZyhTeYhoNQZz1HaSy9cWRHmOOAzrv6sXKf5zP1odGcuvCv/E0V8atbVpdcY6MW4jWg6rFNmi973KQbs884EsooF4m5Kg4TCp7c4qidHHzaCObVrJjWqpMwyEyUGLR9HgH8XPrFastzJIMSaEaiJMqFP62HvLhvNMWmypE8TFnsfXKkZ5S1CMg9/p9NL/ch64aGedD5aCTot4lOBhqKebblZvhD4Rfdlub/Gl4CCUQj+Uh3YZj4MDkFHZbyrDi5pTa+AY3dGbCxzlnxCTXwAgW3GS42+m1o7N7jVM1uIFlxLfi1SdQnwAtLulVAxSgxDwJAGzdN0SSQAUUPb2LOTf+kwstb0K+bqfl8Bd+GjepoINUXmcGPx7xAO++NE7GplcgV3O92K6PZtRWfG21z1X3tRCYBEC6tr4EFkCvKzoZftMOTnlkl2xBHmcMYUvcruXGwtOWK/nz4B9FJ6/kS+JfTLRf8qkHyRFQ5ABWgf0Uh+lDJvRZzv+eH8RZfOztFhzqhG3qcuqCZzf+iDuH34c1St13gsGCm1K+pIk8XmcGb46YRt6IRgppIJtW5v3yFZm5aPU6KDpoUl9bkZGSBcF3jwb2FefyNFdyGS92lUeLF7YwhD8UXM91OY+SuTWMEGANWkOTtcS/7Fwx5J2YOKOhEZJDIlB9uJsYZvqQgexkCkv9YgOy7D6xApvV3IA4QIsx0ODGQgOFbGGIFJ1bkGK/hdArfqRoAV4gLqucV+hsHFGg6lz/YxC3pf2OxSPOCy/3Iw9eHTGV9yvGxmaAZhALW0c3kBxE0Btyn9rH6azt9qlOy9wgxW0bUk3IIqDXIRbwVW0suPk+zzH6po2xq47ri3rgPWJb3NUqg4cu57mYe2V84daJVIfIYDkTWVM6HKU/KP2RpGDFTwVT+sO2ir483O8qPuNUGYsSpxQGP5RDbjy8TCaRFKpBfnYDF1sWReVcA6liw9z9tL3bG9ukZm7LuZ9JLI/Kuc0glQ4suHFjSQwJaNiEtDVMI+qSh2KD53IvYRmT+T7PRS2K0Cy07FOpiu1lMssopla6cQFyIb20HavbQ1BrLaNYzZlq7kgSPPZpkHIasCLRA5FIgl8kurDg5sLMt7B81818nqKM3XFfsTTM4PXEkICGSmTPqWhWfLbC67nf4S0uxKXLyIw3LLipYD0TWW5onzhEhhcBlrKXMqqpYkAcRxkCSVTTIjlUgygjm1Zeqr+M8U+s5VzeZy+lcfMcAF3pt+c+sSpxJAAybv4totcZygr/KvgOC5mNCwtpHI5p4dJAGMIWxvMh57HMtJEym1bG8yHfYhNpqs4U7VDosJGTPOrBN5IIAMoKq2E57Jg1nDM+qYxb7bitDKGSEfxs6WOwKi6XDA4nMvU1CsbDJQUTWMjsrryGDlL9ynrFA0PYwtl8HLakZ8XNmaxWpYgO+mxOcCfSTEgZnNghaDBFBEIIuxBikRBimxBiqxDiDCFErhDifSHEDvXv8eq+QgjxVyFElRDicyHEyNh+BWMMYQvYka6h9dBOelyuK/Pn3Qnx5wdEC/AM7CouYkXxGewoLsFpdiWySpvAgcIU3mJawpObooF+VDOCyviFFQfDickRU2BWIngIeFdRlMHI9mdbgduADxRFKQc+UN+DbJ1err6uAR6L6ohNYsmei+CpdtgGlBE3A9HlPMfqzRPjk8ASDpqk3lzJCN7iQp7OnMfi4vPYX5zlsRSpFnbFBs3FNvYXZ7GvIJcvc3tTbymklL2yirPXaY/OIn2jWJscXYlzIS+RqewqzHRDzgHOBq4AUBTlMHBYCDEdGK/u9izwEXArMB14Tu2BuEaVJk6IVkdkM2gnAy5KAbbCNis4hmDn67hce/h7O+D5uFwqbJyydBcfTjnMYVI5RAY7GcBeSikt2MuZrOYwqV22FN9ycBZczGYhTeSxnUF8zFk0kscWhgQ02CUz3FjonAEpW0l8+bACZL5DAmFGIugH7AeeFkJ8JoR4Sm2PXqib3HV4Qjr6gFcGSo26LW6o5QSdgcwFfyLmKbJdSKRxMBRW4GfcO0wqaXTQShYdpKpl2YxlVQsuCqjnLP7ND3mCM1lNPYVBk8OSGU05OYktLKPhZChMcICRGSKwAiOBxxRFORVZyf02/Q7q6h9W9pIQ4hohxHohxHrn/uhGdax4bSrwObL2VCfY4xP9ZsENSRQ26od6/7yAE6hlADvDPlUejcxQKxElwmAYDbixwGmJHgXSzTk0sUMwQwQ1QI2iKFrY3yIkMdQLIU4AUP9qGtc+pPdaQ4m6zQuKojypKEqFoigVtt5RrkPlADiEFERGwjOKYSXdaMN+sCW+WWwRYPB6T7u2bFo5lcqIi4NacDGTRXEPKIomnCcTnzoSoVAA2QmMKwhJBIqi1AF7hRBa5dCJwBbgTWCeum0esFj9/03g+6r3YDTQEk/7AMC4q96FS0fBpHKYKsAh4tJ1xtaMlJeSGRsgnXbSaec0NpDazThkC674VhmOMhyZOcnRmDQTMhIoWJn1GtwAvCiE+Bz5s90H/B44VwixA5ikvgfptd4FVAF/B34czQGbwSC2w5+csuClFY4ridPsXEP8M9nCxZeQwSEG8b+oGlDjGbAVTbixyJ4QyYB+ibu0KZ+aoiiVGAeqTjTYVwGu696wuo+5fZ7nhWuvhjXwauGsmFu1k94+oKFDJkZFOyLQjSVmodxrGUU7GZzDhzE5f1chmDhVTQ+IEVA4H1gATW+CK46R8d/YyMIM2pk+eQHn/XIxp7E+ptdyYSHD3Z4cASqh0ATjatfFRJyPhVSwhSH8lZ+wnIkxkzrqCnKSo0fFLFgyawIr/nUGeTfH99LfWCIAcHA8722czjpGxfxaVZaBSZVEEhA5yCCiGMCNhfVUdKsRjR61FPNXfkItJ3B8DCtRJ433QL0t7aSj3AoFcexs/Y0jAjcWqhjAWkax8vbz4Ta4ZMNbbGJYzFaUNA4z8tWt0lt5jKOWE/gZf+ZFLutWOPK/OYtf8Ee2c1IURxcEJxLX9uuh8HbuBMSC+CUlfeOIoIM0VvxiKhsvHO0JKhoN3zn5I8bySUzSZlPpgE9IvI6ZBNDckU8xn/u5jaoATWsCoZZi/sJP+RM/l4FhcUJdQQ7MiNvl/GGFg/28p+O7540j5dfxyUX4xhFBBu2M/eP7MBfpt/gIcLXDtgPUiHK+1bKRe7gbB/aEjvObijyasOPAjZXlTOJGHuL33Mp2BoWUEBrJ4x7u5k0u9GtHv4Uhhi3qowU3FprH2aJTEDUSFMOmNO9SfS4srLjxDPLujj0ZfOMKk4CMnrPPdrDk57PA2YnHp3cApz2XJ2038uSSG9k6sSwq/RAzDjqT320YJ1hw8S02Ua36wlrJZikX8AGTGMBOBlJFlvqbr+bMrv0A0ugIqL7tpZQPGc803orZ2A+RAec54Rnifz8vl0Toi3bSWXH3GUzgPzTdEztPwjeSCEBKBtiBmhTgADK4sRkYBy4Bb0DHxNSorDG2V0l84opZWP0TiqINuwzt9EIHaax2n8mSVbOCqlC20c2U5vg3S3FhYREzqWBDTIuh1FXkUHSwBV4lfmQwFhaXngdg6M2JBxl841QDDVsYAtWoVFcN/AupJ7TCTOj7t21RaXzSp6E56cOKvTA4frUZ9DhMKs2r+oS0ozjX5+LgeMPP9lLKm1wYg9F54MZC3bgcgwiZ2GHN3OH8iZ8HrbbdTjqf3n1yzLokJUenIyFaIU6tcoIjH0+fpESiZxze6BmHNyIdR19FUXobfZAsqsH2QK2Y4gkhxPqecfSM41gcxzdWNehBD3pgHj1E0IMe9CBpiODJRA9ARc84vNEzDm98Y8eRFMbCHvSgB4lFskgEPehBDxKIhBOBEOJ8IcR2tQ/CbaGP6Na1/imEaBBCbNZti3t/BiFEqRDiQyHEFiHEF0KIGxMxFiGETQixTgixUR3Hr9Xt/YQQa9XrLRRCpKrb09T3VernZdEYh3pui1ocd0mixqCev1oIsUkIUSmEWK9uS8QzEt9eIoqiJOyFLNu4E1lLNhXYCAyJ4fXORtZb3Kzb9gfgNvX/24D71f+nAO8AAhgNrI3iOE4ARqr/ZwP/A4bEeyzq+bLU/1OAter5XwEuVbc/DvxI/f/HwOPq/5cCC6P4m/wMeAlYor6P+xjUc1YD+T7bEvGMPAvMV/9PRcbJxmwcMZlwYXzZM4Bluve3A7fH+JplPkSwHThB/f8EZEwDwBPAHKP9YjCmxcC5iRwLkAF8CoxCBqtYfe8RsAw4Q/3fqu4nonDtEmSTnAnAEvWBjusYdGMxIoK43hdkOdXdvt8rluNItGqQ8B4IJLg/gyranopcjeM+FlUkr0RWoX4fKaE5FEXRgt711+oah/p5C0Sl1dGDwC3AEfV9XgLGoEEB3hNCbBBCXKNui/d9iXsvkUQTQVJBkXQaNzeKECILeA24SVGUA4kYi6IobkVRRiBX5dOBuLblFEJMBRoURdkQz+sGwVhFUUYiW/ddJ4Q4W/9hnO5LTHqJBEOiicBUD4QYo1v9GSKFECIFSQIvKoryr0SOBUBRFAfwIVIMtwshtPBz/bW6xqF+nkP3ezuNAaYJIaqBl5HqwUNxHkMXFEXZp/5tAF5HkmO870tMeokEQ6KJ4L9AuWohTkUaf96M8xji3p9BCCGAfwBbFUX5c6LGIoToLYSwq/+nI+0UW5GEMDPAOLTxzQRWqCtTxFAU5XZFUUoURSlD3v8ViqJ8L55j0CCEyBRCZGv/A+ch+1rH9b4oieglEi0jSzcMI1OQVvOdwJ0xvtYC4CugE8m6VyH1yw+QbSiXA7nqvgJ4RB3XJqAiiuMYixTrPkcWVKtUf4e4jgX4FvCZOo7NwN3q9v7AOmSNp1eBNHW7TX1fpX7eP8r3Zzwer0Hcx6Bec6P6+kJ7HhP0jIwA1qv35g3g+FiOoyeysAc96EHCVYMe9KAHSYAeIuhBD3rQQwQ96EEPeoigBz3oAT1E0IMe9IAeIuhBD3pADxH0oAc9oIcIetCDHgD/D2pG1OIEH+cMAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -171,12 +171,28 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 7, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\structure\\code\\pyclesperanto_prototype\\pyclesperanto_prototype\\_tier9\\_statistics_of_labelled_pixels.py:168: RuntimeWarning: overflow encountered in subtract\n", + " bbox_max_y - bbox_min_y + 1,\n", + "c:\\structure\\code\\pyclesperanto_prototype\\pyclesperanto_prototype\\_tier9\\_statistics_of_labelled_pixels.py:169: RuntimeWarning: overflow encountered in subtract\n", + " bbox_max_x - bbox_min_x + 1,\n", + "c:\\structure\\code\\pyclesperanto_prototype\\pyclesperanto_prototype\\_tier9\\_statistics_of_labelled_pixels.py:180: RuntimeWarning: overflow encountered in subtract\n", + " region_props['bbox_width'] = bbox_max_x - bbox_min_x + 1\n", + "c:\\structure\\code\\pyclesperanto_prototype\\pyclesperanto_prototype\\_tier9\\_statistics_of_labelled_pixels.py:181: RuntimeWarning: overflow encountered in subtract\n", + " region_props['bbox_height'] = bbox_max_y - bbox_min_y + 1\n", + "c:\\structure\\code\\pyclesperanto_prototype\\pyclesperanto_prototype\\_tier9\\_statistics_of_labelled_pixels.py:182: RuntimeWarning: overflow encountered in subtract\n", + " region_props['bbox_depth'] = bbox_max_z - bbox_min_z + 1\n" + ] + }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAD8CAYAAACcoKqNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABrFElEQVR4nO2de3hUxfn4P2M2kIQEYsJNEjQIKCA3gQoKlhRBwSpoRdFKC34FC9YLohVtsWpLq7Ze0GJRwRYqVVFQQMpFAeEnKNiA3ARsIoQSkEtCA4kkIbvO7485kz3ZnN09u3t2N0g+z7NPsmfPzpndPfPOO++8FyGlpIEGGji7OSfeHWiggQbiT4MgaKCBBhoEQQMNNNAgCBpooAEaBEEDDTRAgyBooIEGiJIgEEIMFUJ8JYQoEEI8Eo1rNNBAA84hnPYjEEIkAP8BhgBFwL+B26SUuxy9UAMNNOAY0dAILgMKpJR7pZSngbeBEVG4TgMNNOAQrii0mQUcMD0vAvoGekPzNCFzWkShJ06TCicbpca7F7aRCAoqL4Ky6F+rUYsKmnEi+heKATIK82MlSZRvlsApdaDdeZy3b7Pj1wnEN1AspbQcadEQBLYQQtwF3AVwfibk/S5ePQmBNrBmUDdO0yjePbGFmwSu/2o1rI3+tU73g5E9nicBd/QvFmUqSHG8TTcJzJ07EcbOAo5ywd6bGCs6O36dQDwJ+/29Fo2lwUGgrel5tnGsFlLK16SUfaSUfVo0jUIvokEJZFIc716ERlJ1bK6zE47SMjbXiiKnaRyVdl14GDNmJswZD4yhcEJshUAwoiEI/g10FEK0E0I0Am4FlkThOrGnClpxNN69sI0LDwMuWBubi5XDdrrF5lpRwoMLDwlRa9+Fh9FjZvGBHMPzr0btMmHhuCCQUrqBe4CVwG7gHSnll05fJ160PnBmrYNT9Jo0BuRv64EnfqvNiImmENA0poo+bOZk1K8UGlH51aSUy4Bl0Wg77pz5S+DosROO9mjJeRyKd0/CIhaCIJbXCYUGz8JQ2QeNOB3vXtjmIr6CpBhdrBz+deLaGF3MWaJlG7BiASPpFbOr2aNBEIRKZbw7EBod+Dqme0OVazMo5dzYXdAhYjlLF5NJfbOPNwiCEKkcCO9zQ7y7YZu2HIDcGEqvwzC/ZFRMZ9hIiXVfy0kjt23w82JJgyAIkdFN3mCGeICvuDjeXbFFCqeYlPUCpMfumtWLmrKM+r9E8ODiP1wc8zV7GWnUt6+nQRCEQgIsfG40MJNJm+vZ/k8ArmIVF4zaE7sLuqFocUe+oU3srhkiHlzM/OdkPhQdzxihHk0aBEEoXAhMA3BDn32s5Jo4d8geLjzcyPsx1Qo4DAs3j663S4SZKyfD6FnABjVDx5rfxv6SgWgQBCHwXt9hUDrfePY+0x99FHc93Aqy4ipWcduov8VOGLiArVBA+xhd0D676AJD9wFHgcS49OHLNhfG6crWNAgCuyTATfsXU8tb+umPeJPb49alUHDh4af8kxGj3oredqIL1Xaq97Fm03XM51aO0ipKFw2Nz+nLmm7XATtQHb6eHPbFvB//4OeMiflV/dMgCOxyFZBz3OfgDt669P/io1rapIrGlJHGF1zKagaTQgUXjvmSc274VkWBOLW1qAVAkk+bhXBs/vm8s3IMnwcOQo0qFaQwY/8DfN5tIOwEGA6MgwGZpFMa8/78afHjtN0p640/wZnrDxpjft3yMSAfGAc9jV3gVGC22hdO5hQuPHHsYV2+4FK+pj1lpFFlipjsxna6tdpOxY9T+IqL2b+5kxoc4e4yJhFcyyiFz/81kP/+uC3D+YBGVIV5sdAp5VzmPTle2XdqeYZmgksJibRYxGobuEmAJ4CtsxhWClvSY3ZpvzQIAjt0hXT+x2i5m3Q+rRN4VMq5VJBCDoUx9e0PxCHasJWetQSAL8mcoidf0K33Dgp757DzYDdYnwTl2Hel1ssBO5TD4fkX8tqAX3BL1nxacsTmG8PDg4tPuYJtP+sH8/yclKe+q4v5Kqp9MVNCc9i6GThOoxyJvFnwxLsxu7wlDUuDYHSFv/W8DQ8uurCLNnxDAp5aD1AqeCE5nIpCLHuo/I90PuZHAYWAmQTctKeAEVnvM3DUClrc+V/IIfA04TYe4eRpWZ/EO5vGsJk+UQtSOkorZr4+mW3nBRACAOWQd6J3VPrgj089V6BsFEDpM4gXKuLuadggCPyRAPRUQuCITUNXFY0poD3FNI9q1wJxihQ+5QrKwhqhSvO5gg1cfc1isu/Mh36onQYXaulQCMwG7jkCKyLoaCF8tngQb1b91NFEIB5cLOJG3rlyDIwDDgd/T+WeDMeub4fjO7PArA1lb2TywzHtQh0algZWJMDx25J4k9tDNgR6cHGAtpymES05ElO7gZsE8ujDASL3X03mFL3Jo3ePPEp7nMunJVdQ3bwE2IDaOXFD5W8iu0glnFjUmte73sNNl8wjlTIaczos+8EB2rKD7uzdfAkMIDR7xypw902IyW/ViNMM6PER6x+awtV/Xsy9vAR8CBOifumANAgCXxLg2G2p/J2xEamtR2hFFY1oy4GYCYNvaMN/uMjxdtP5H4MzV7F8wk/glQ2oNUEW5Dp0gZ2w8PBoGIxakoyDy3+zhm5afQ7AEVqyeO5tMHYfsANcl4QeKp6nBHgsfqcpPM3H4hjXAe5nIc/bhbjSIAjMOCQENDoKrw3f0DiKVvJTpFBKOv+PH0bNwakRVVw3812WJo2G6c8Dt6tB6xRFAJuhcAVMhc+m3shnIwcFf98qoPQZoAIYHF6+iPVQSE7UDYZTeIZd4hiFUb1KeDQIAo2xHHBKCGj0jkJLjnKAtnRhl2NC4RQp3FryNtXZTWEFjBj4liPt+iMBN1e/sJgPyyerAefk3ZMEjO4N8zagBnUObLT75mEoiZAT3rWLYf22IbTvURA1raAvmzgiitgUldYjp8FYCDVCYDbjomLFrqIxC7iJX4sHuaHFSm488R6rGExVmH74p0jhzzzETZcvo7r5fKh8xnCSiT7JnOK6We9CNOpXDQa4FxgHrW0aEFOB1t2BySgPqTDpeYrVqgOO04jTjH9uHqui0rozNGgETWHj8B78P66Mar695pQAJ6H4GSrTk3mOjjy3airPXXV3zRakHT7hShbeNhrengM8Yxxtqqz7MSIBN9kX51O0taOzDScBTwuYkRna+1woGXCYMFPJVQOvUJQ2maqytY4v4x7gBWY+5GiTjnN2C4KmsG74ZXzKFVG/VA6FMLsLjFuBUn0LYXARD079a2i/QiXG7J8DHEfdxGl07L3N2Q4HIWqeeJHckakQnrdwBZAM5ctZyTVcy78cWyLcy0sUiqIou05Fztm7NIihEABIwMPoO2cBQ40juTAyWw3s8hAebqOJCbmQMxnoDoxWmYhiSFsOEEd3CWvCDqZKBm4HBnIs7XzeLLndEaPrRXxFu6R8NkTcUvSpH4IgFWIath5jIaC5mK9gXBfgYZjQNzKreyowErh1GKyI4gzth2ROQYcoFE+JJEt0RPptMpAI5dVUZzdl7qaJEXmJXsRXPPyDGTwfu5CKiKgXgmDzji6IphI6xeBicRICoLSCO2fNgCdEeK65VmQDe4hLBGT2BYXONxppesWQv1cLYVZZDf0kbz35fxTQIeQuaCHwRLydA0KgXggCKIWhzyBWS6Ka3aoTrBl+eVyEgCYqA/Yw/CcO6bZacsR5K1OkdSNCEgQycEeeqGbd5UNZyTW2lgoFdOD1dfdwKVvPKCEA9UYQALjhkZn8YtB0Z5ttAm+NHoG4VCIek3FPL/YVF6u1vpO4oejr0GeuSGnF0Yh27KJCjWAKNMg1NqTOxmqKEjvyxpGf4yaBKhpzhFY1j0O0YUHVSF5fdw/rxBWQ+wQLGBnBB4gPQeW5EOJvwHXAUSllV+NYBjAftcotBG6RUv5PCCGAF1E5Wk8BY6WUW4J3IxmYQLPKav7sOR+aAh5U4I/+W4X63QIZc5ugNIrG8F7PYXzClUx/8VEQHwHzIHV0SFt10aAvm9iW3i9M63YA1gtOt28c0zj/RlRBdiUUxqqCig3cAPtQOyo6GZgLdVNlGMcSsVwS+G2zmu+ymzB3xkQVaOUbbFV5CigBPgdyeHXnHTwR/ieIC3YUuznADOAfpmOPAKullE8LIR4xnk9BuXh1NB59gZnG34D06L2Prcuaw2pTr1ym/81/3VgLhYEgzqmA7CTUbPABcBJvDGoibIxtLUArojZQC6CEzJiXG0tNL6PcydxnkdpODoMSAjpOWlOGCpZyoW7P5NDadVfDhIoAJyQCl0HzTLjtjtDargcEXRpIKf8f6ps1MwKYa/w/F2oqfowA/iEVG4F0IcR5wa7hOvGd/agLF2rmb4IS8k2AdiD+KCF7AWrg/xMsykx2vmRL3DWCqFEJnx+MfSqwi5p85aydwEbYsF8qAXYRWOV3o/wGokEiFEvOxKLQ4doIWkkpvzH+Pww1AftZUGtDu8g45jxaa2gMfAtvzrwBeo4mXllp6wUrkmKePrzQ006l3XLK7pEewXuLIXqDPISlRP3M4B6QiI2FUkqJPctMLYQQdwkh8oQQeccirTTuhtuWLUYuETBtFBCii+r3hUIcyUUQCsfzsmDnH+BphxosDfN9blDJPqJVrtpuu2Ws+PvAKPUheoQrCI5old/4q5P4HYRad2I2tfJ/e5FSvial7COl7NOiWZi98GUHyJsEf5XzoWv90w48JPCm53Yj5DYKlMPO8T9gM32idAEL8gCqoWBTBL7+Bm6UIAinDTcog50domsnGs+suKceC5VwBcESqEnLPgZYbDr+c6HoB5wwLSFiw16YuGwucpmAZ0dRn4TBIdpw3OWCV6LgkQdKwMyeRZHoGLuKxDmgVn9FMCkfphLeMqEUlVpsznI4vMm+sHSjlgTFJ8G2d2Wokia036tofMd6k6bcLkEFgRDiLeAz4GIhRJEQ4k6UIjhECJGPCh7ViuEyYC9QAMwC7o5Kr+2wA+RwAdO1MKhm9+ZeMS94aWbmtsmoTZj3IjOK+aMIlHL2POtWDo1qNCWoNOAqxVYOynJbCIUfwTipttjsjrdSVDuV81Gzej6wEIqqoUhCUZHpgTIKlqJeP/wRVM5BzUFRErChMhtyx8W7E6ER9E6RUt7m56WrLM6VwC8j7ZRj5CthINwSHpoP/aCsOi0uBS08JKikn7iBI0qlHopzFvdKDDW9F9AShsLSJ25m0ONLoxaH8OG2EVC03uKVVTCnKSztqwZ4V5+Xy/EKwkpg2inUdq95IFcA76HW/WYDYCIUa/vzSWpLm+NgK9HsSeNadrTFauP6oWiWJ1kxayDMXhfCe+KLUGM3vvTpKGTei9Fr//i1SWQmVoB7Hkwfze/vfyim24geEljASLal9YPyEtTsmQh9UHkEIt2GrwTeBopLqD0wXDAgE96u5LqsD0hw0JDmwcXSK2+G9R8FOTMHbuioZvA9wOGTqMG923ROBf5n8zLqbgUnYu0HkIbyEQjESVQq8SyU20sgf4IiYJ1xbmhbs3fKf9BO3FtfdBQAnoTNUkpLA9JZIQgAZl07mrvEFUAOA6SLa1kW3Qsa1AiBdv2wTFaXg/LbDFcY+BUCZlrBeri6/2IVNegAhbRjm8im9oD2RwV1Z29NMJXIjTfvgsaIFLRsqxVeD0IrtqOWTy6gMyoDqz9hsAFYi/qRrg/Qpi8V0KcV8jzBHz6IfMHycBNwu4k4kjGQIKhHsQbRZfyeecBEYBPr2w6hJAZbjEGFAKjjbxPeToItIQBwBAac4sPxIyIKTvLgYm3Vj1g87Da2iX7YEwLagSdcbUQLikSfh79rHUTN+Pl4lxTVKC0kH69vnBvV/3+i8h1qrURrLEV4f7RQhnKFajdvCeIDyVWyB9eH8G4zTYEfyctoUiVpujro6RFx1mQoOtkxEeV1BhT9geeenMofH38gatezJQQ0xcAiVH6B1jYvYFsIaMpgdhm7V/Wial9jurHd5oUUn9KfYz86H9Z+hNfZPoOQXXXrEE4W1EDrez1oj6MGZVPq2hnMnERpCdWoz2M+rxVel+Rg2oC2JRTgXcos4XLxZ5g0BLlehBSR2BRoK68jV4wG/hD1kXrWCIKme6vhui6w1DgwVAUAqfqAzrqChSQENJWo8XUDyruu0nho33u9JadrDS4lBCFgovAIe9tdwul9jejJVspIo8IYzOmU1lk6eHCxdMPNMGAfasfDzEnUAInmbWQ1gPVn9h2cvjN3helhxqq/1X7Oa2V6zZ/Q06/vtmijAqYvQWyVbOwpWG4c7W9qrVcTSHkOaja0OkNu/+WsExLYos6M1OkuCGeNjQBgxbUDGdZuLRRK5JFzIE8ZEhdxo+2yZsEISwiYyUEN+uJ9KDW3F+qG14mwE41j/tbcdmmlKgKthxpNKbWLEkT3oPIidkK5D69aiP89+kBagRs1SHxDVcyYVX/zQC7Dq67bWZsHEkbB3I4TgQ4E1m6aYr1EyDBesxICZpLhoSFM+vNTnCKF1xbf7905KcX4HUy4ga3A4eXAMPYiaoJ7wqXBWGjmfKhsB0m6YA9AM9jfvwWLuDHs9FSnacT73Mi2B/rBAiLwHqwGlhN8XdoRe1tlga6zieDCJNggSoZafnTmMNGTQd5vFgJmThJYeFi9x9yeL+Y+aENjNd7PnoX6DIGESSDB6/LTHzOJkD0MegY5zZdyaPHxf3lSXBBxAtQGY6GZ/0LSOmr/pifggmXHuH/PawxmFa1C+Mo9JLCLLjzxwDNsE3tg+rwIXYgDbaWZiVVe3GBqfwXKCUg/TpqOBRMC/gx/VsfcPg+7BjzzMqIpShC4jL9peGf0SJY3djSzTuGl4kuFY/eez8Qbw3hvCJw1NgJb7IUf7N3JD5rtZEX/gdxa9TZXNP6UBDyUkca6g7ng9vFMdLvgIQGLnkcNgkhjUO0O8FDU5mjjG/cfKVrLqBtKbr8fUFdYhHu7++Y2CJVEyG4X/hZxIYz74C90EfeG/I3Y5exaGmTCtL4PMnXNc/6TZLrg24Hn0K7xPo7dcX5tTdcfej238xRqIESisu/C3rYcqJiuLEIXBkUo+8MRsBUe409LiUQIBVOnq1H7/VrY+V5fr+fdPu/xRyL4zReZTWAhoZc5gfD3eRIhaZhyV4hk2u0A8j+CJyJwf2lYGhjs79uCx7o9q7RBK1zw2NWPkjrDo4QA2JsMXCgvwbEp0CFSo6PdGbUMtcZfZfy1O1dsR6XUMkqb17jbBkKvp8NVz63as0ui6a/2KDQb9czprMLFzucPh0RwOSAEAArgvX8Ni1pU41m1NLhg0zEW7biGGqfCzqhvwKi+/aer72HaA3+MLJ9gDmorOWROooyERwi+P6899fT7TqIGdg7QEmVo00uMRLwaij7PjBslVNKIzTJDb7W58S+Rw8FF7QEbin9CoG1QO7OA4TJeawvSIU3AxE0vLmMbgvecaa4WZ5UgoARGLPuw5und7Z5jppjMILmU3/BHprz+l8iTirY2HiFFF55EBdjowX0c78xnNfNaGeGqUZ5zhRavBbPAgxIGGdRVcQPNhm6Cq/eJpv/d1LbWB9qb17N/KBmHzEuIatP1XaZ2rJYH5u/Y5XMskC2mqU972gjphtRctT3r5AjbCN0Xw3sjHGzT4OwSBD7cx0vMpANrxEnW3Ppp5ME/oL7RntTNdOsXXyGgicQtN1ys1rmJKAGhE4KGSrXP/7oN87rbShhkoVQ2PRC1cExE2VB8BZSvk5F5cPsKHt/bXrsg688Kdbc+tYahBVSgnQaX8ynrAUpB5Evkg4InnnO26bNaEKhw5CxguDNCQNMaJQy22jl5Cdbr+0Az7X0wyeJwV5RfzFigcB7OWPB1X6yEgd6C8x10/rSIRJ/3m4VBK7wCIQ2vETPZ9Dqm13eY3utPQFl9hyepa2fQaIFghdYwMvFvdDSzD9ztnB1h5cBDsxAuiWwjeMLBhNVnlyBIghmD7uTem2erL/V2gF1q4DhNB5SWXhropCLsqe2aLMgezj0H/sSlAaRM2b40FjCS9etGQ65EGS22mK5l/tndpmOBhI/eh9dtpOGdofUsqQVAGdbCQBv2fAduDqHluG1qvMfsbWkH/bn1TB9qnESgnYcYsAfgOLifQbwkWTZS1HwDkXJWCYJjg1K5V0wGnjEdDTc2LAipxqN0CeoGGogaRLvxDgS7nkdZcMNwBr2/lOH8ImiikTTKuIO/c8fAv1MsMzlNY1ZyDZtKhlHdfAvKlqAx3wLB/BKSUcZI/Jxnw7sOUJ9faxOY2gwF30Sl5mu7TG37W2LFetnlAK2BYkMYj1zOsDfh5E/tbzYH4qwSBC3WlEOfLpD3gelopNFzfnADRZvx/kyFWM+G/kiGfmPh7WqGXfAB1zOWxpwOuRvNjYSed/B3fp75D+565A14+gjWyxFtMAyEndnXrB34Hr8sxLZ80YlFzCq8NlqmoeIwOuIVBEdRRbmstKFQifNwyQEqJ6po1RwQn0qaVR7m143/wJ2uGfwlglw7Z5UfwbFBqZCn49SNAZneLjoXKwKljpsJYRZ6aCx//Wwsr18whpEsCEsI+JKAh788NQ6KRqDWRVbRe07UBfC3zNDOT4FyCgTjIF4fCL1uByVgxgK9UUsHYTxaofbw7F4v0G8USp9znJUbelXVFfVxcoAiOHFra6bc/BeaL5QMl5154mp7LmK+nFWC4GbeBd4xHUmE0iglkyoHr7EuxJs+5z4e/vOTjgx+X1I4xetZ/8dUOQ1Gj7U4wwlBYLUn7xucZJfjKFvAJlS2ILMirL/Xbqi9On/fc3dUgkizN6JVeLL2zzCXTDOfa3fnxA3sUDtHxTZOD4adJE5zoPeNuxC9JB/Ld3jiC3ji1yoZmx1vjbNGEKy/thfrOg5FzSBmq/Gq6Gz1hLsEzbmPh/c9ycV85Wh3fGlHIc+8cS/cOh77gkpn8LEjLLJRKnqO6RHOMmw7Xi3AaiDq3IPB6A3ci7Liasrwhjv7Cgbtcem7/RksFkQLjkJgCWzcHFnG6lC1ij2w9MabEU9KxH8l/eZIVsiFPLEj8NvOGkEwhn9AwRPGM/ONn6+SfPiLPQgXWz++WYVOhg6xEQKa5pTwxFtToNNY1GztWzHY7AykZ0Q9a9oJT85AqeatCF0bqMa70+GTkLXWYxj2BVkiyjfB9zpW2kGgfvlDt2M+56BajhbabN5MpEuLcmARLL/xJ4jHAscUnR2CwAXT+A00f4K6N00FVD6vXPadohQ4vB1lDc8y/pp/VbN/vJEFZ9F4/pj/QMyEgKYtB3hu990wdhReV1kz+rmvcTGQMPDnrhtoEG1HJQvdYnoUUNsByVcbSAzQB390xhsPHM5IK7Pohz7uLzhrN+xca9OvxCDGdsmzYtcg/+psftp2ERT7y+BbDcVLoHg4NI/wYm5U/sE6mzqB3GUzGDNiZkh5EJwkndLaGnMdUrD2DThJXcOgdj7yl1PAKglJGbDfp32rkGIr42aoNh4BSTcpu+IrC/EGhlj5U1jFKySjlge++RSC9eMkFO2C5l38a5/pqPsvDqPyrBAEZaRB0TzUj+5vnboblmbADQMiq8i7B/xnGLIKpwUYwsUxSq/ujwt+s4f9UwNtb/oG9WgqqB3GG0xNP4JS97VGoXdwfNtuiaolsAlVTCvb+F/bCyIw8uaA/KVg3czLyL1jE8z5g+lF3/5rYWC2K2kBpAuf2LV97IetWnOwIg2yexPL0pUaOyXP2gohPhZC7BJCfCmEuN84niGE+EgIkW/8Pdc4LoQQLwkhCoQQ24UQcS8D12vTbm6RHtSNpdVWKzfTwtoJQ0OlFMjbhP1inKj+bCRu2oAm+PX9rfH192h3S1Bn+j1KbTW7KbimQOspMHQKy+U/kUd6UCh/g9x7IXJjI06XXsluOQWmTlbnjZwC/brYuKYPh2FP1wsY+NznvPP366m9TLNCZzaKFHPwkxVlqqxbHHyd7GgEbuBBKeUWIUQasFkI8RFKuVotpXxaCPEI8AgwBWW96Wg8+gIzCbVMjNOUwPwPx1IsP2CN6IbXsw2Ul113aN1X+e9raVyKMvgVG3+DGRNrlgSFIXbuMu7sOyPE98QDPdB9Z+JQjIAB/BTmTESeK7y2wRfV3ws45u3BeujEfmS2gKfU61+Ou5Cu7b4O7WsvhVf5BS+4fs21VcugwwdQMAelaYSSCzEU7ArKI1CeHZlWGgZBNQIp5TdSyi3G/2WoxW8WMAJqEqvOReW/xTj+D6nYCKTrEupxpRms2XAdtTWBXJg6XtXoextVfkzb8Zrjdd64DrVN3Qn/2kIB2Es66sOALlzBp6G9JwpcxWpUku1AWOUssKsFHEQZAAt9XnNB9mRO3yCUTC5Bpe4ONCuWe8+7ZM5emGajCz5MH/Yo9IQmr3yH/J3gLnkCtb3oi1NCwG47bud3sGwQ0q6BECIHuBS1WGtlKnl+GG94WBZwwPS2IkKLKHGeZtCowwkYsBnvHZYL81DLz2BLgVSUMa0fStyZBUO68fpGSfAlgUW6rdn2PkK0aU4xBM3g3BRvSTEtUIMF4VSgdgS0RyfULM2mTqarvBy5RpAY7vdQAjtvb69+j1DYAzRD3Q6H4NWXJ8E8f9pNIKlkzllg9QB7WY41FfVbEAghUoGFwCQpZa29JKMKckjJD4UQdwkh8oQQeceiXLzhmv6LqG6ej9fTL1cJgewwGtPaghYM16GEQ6qwODnR5+Hr2ZbMoIuXhtGJeGBeR2uBYPcLtBhI6RORPxLseO4yFYkdAZe8uJdFn1wTWSi5G266fR51bQH6t/KHeYfB6hGPvBKhY0sQCCESUULgn1JKnSnpiFb5jb9HjeMHgbamt2dTNz8WUsrXpJR9pJR9WjQLt/vBefHau/hQDMcrBDLgacITAlbopcRYoFY9RX/ReeabYz+flPzQoY5ERiNOB8i570+ttRObYPaZMPEs8IW9vgXFDSNmf8iIirfs/67lcLKb6Tdyw2P8Dv95CiIZzFFyY3cQO7sGAngd2C2lfN700hJgjPH/GGCx6fjPjd2DfsAJ0xIidmTCT699nUniFVRpa4PW3aOzPXMDcOswdeF6kWI8NFI4pSoc1SHY2jZYHYZE6o7OLN650+Hw7xOw6NWfcvRAGkmlx4MLhCSjDJ6JLifyqeuu7OtV6fuwg5XHoS/6Oidh65Ew816Gjx2NoD/wM2CQEGKr8bgWNa8OEULko1baTxvnLwP2oj7KLOBu57sdmG+vOgeRKnlL9KCWEMAF44iO94QLGA1wQRQajw2d79xCXQ9IOwQaEHoAmNbfnW7i5mVRWBKVQ4vnyql4O5PNB7ooQ68/XMC3tQ8lzoFb5AqUDcQqzuC4z8NuBijtg6G1QXPbZhfnU8bz9bBzE+TZbD4Ylah4rQDY2TVYL6UUUsruUsqexmOZlLJESnmVlLKjlHKwlPK4cb6UUv5SStleStlNSunUxwlOJoy99q+k9vNA17XU/aE6xsVZ40zgFCnsvkPXVNQ3pF38udfqICXwGhUzeH23Q9k0/FEOvV7czc6P28OtWMuznngXsxo3zH9rLOSMxd7a3o5no9lQaHZEMj+svu8iKPoocmFQDqyQUPpMwNO+H7EGTeCjawcgkiRzRS/Yutb6vPRW4TsL2SEJIJiDS/105rx3w2yYY7ba2RUEbtRuyW7U1qD2GDyJGmm+CUCPUkWjiPtrp1uXvLgXOV4wp3qUskmkG6+lw9T3f12Txr4WRyGjoI5Jyw/BloDBdguCCZKTShgsyodF++oGsvnGX/k+kjBiaP5IMKFWP+/KUGgJosVpEEUE1X/MnrDRwGVcI2gGMq9BqnprU7gqin2yQSnpaua0zAwc7As7hfcm05qB1TacdiN2U8q5Yfc1JNzAFzDmi3cY0+Yd9v+vBW/wc/qQx9CX1/l9T2ZCMccDxhuYC624Tef4pkuzYyvy53auOQl8oP5ufBgmpXi7k2rRNV+aA8XB08Kf8RrBT/u8DjlbUEErgXDFZlkwFPx721lYnwdXc6DWJkvseXD1X6FoeRjvrKDu8stNsKpLL/BAGNeKkENwwXPHmPrccwx9bl3AvfoUWyHW/rYZqwnNb8AuTSEnReUtbG48kgiuFUwCmk/GuDH9Ui8EwXdNUTEmdrYRtcpjPI7QEpX0wsZUH81lgWYkKNupFVY32Bye2Bx4/RZN3udGGLwPNbP7EmimCjTgrYKIvL/PKN4OpYsxZy4/J7zSxeC8z0AiMBn6TFaG7lBxAQ8BT/cOeFq9EARfbOmO+IFEPCIR7b2Pv117m3fQNzE9Gnsfq/Ou53M5mNTyiyE3FxVv7hv/D+CGnTH4MHmg1ss60Yd59rC6SdwwVBnrYk0BHVja+Wbq5lY0489RBgLPelafVYUo/5BPwuht7OgxJ59zDptnUN/P4tT6MtHnrxW5MBU1wURxWVsvBAH8D3gJ1r8EnfRjLUdo5R30fvxSqIIfbNhJ2c6WyL8ItsorWSvvYICsgNm5eDPSuAJvJznFHPDGq5ujHAME5xQv501+Gv2+maiiEU+9/DvYszDAWcHU21Aj8lxAFu35OsT3xZgS6NkqkLdTsFnfToCR+b5oinLv9n1PRxjdNCaabD0RBL4kw8ZcHt003f5b3MAJ6LEhn4EbPueTDVcjewgWyZ/DnFygY2S54+xQDhT4U5ddWKeRdAFFfCZas8rvksJ5XuABuCeQXcCuocufMPCV2jrkuIDed+yCC200H0d+zhv4r7fgz4bgwpuWzRyebSbR9Lp5Ma+rO2mB0BFu7a4C32JAPRQEybBoPLKliHy5VQUjNnyIvESwUN5Bs+mHo7trsBVUgI0/MvAWGvVVcTbwlhjJ4zwZte4B7KILd658k/y2PQhs1LNr7LISBFbGMlPNwTnL2XKjb+7A+sX9774GE8Ybz3xvGqttvzRql22D2rsLevZPs2hPowVCBgztHsDl23nqmSDoTmr5DcjuAhys60YV/GTDckr3ncdN/ec52LAPiyC426lVXkDNfIrE8agIgyoa8Tt+y3NiCgx9CYpeInCNQrvowiJm4Wa1DDLf/LvpvXJXCNeIA/2BVzbjf9CW4fWZaEVg13K9VAhhFkq3f6oT1CNBkAx5uZTtbOmsEDBTAjO4B7JDCpS0T7ETjWynSGQ5tkyoohEvcR93PzCH/WIbKk+MRnvP6a0v/Qh16ysFNRD0wwqtEhs8Apwf4mViyLg2f6G2e7oveutUp107s6k/giB7PBWdHFgOBKH1hhNMbz/B+SVCOVDoLzlqqPyTt0QP7vzRmzzLQ2HvKOygG3f/ag7bxH6Y/hJ1c/LrLUBz/kDt8hoJ/gSJaXmwdXPdzOL1hR/D61/eg/2bxOnowsSzNYtxIn888ABJG2Jztfv3vMab/X/K5+sGOtdoJVhEW/vB/LVb3URu4HNY+zm7RQb3Np8NK+DB3tPoQmCVehddePXbX1Be1EI5UJW/5OfMQLN+GcGTlATDymPO/LlbxSUBR1C6gfiVhKU6oWmg9bydbVQzdjw1AbKCZJV2nnohCFJ7J/Donumxu2AJvMj9XN58qzPq/B7gCQguCPQMbN5e0j+BvyCX41A8E/q4eI7hMHQqSW8f56Fmz9LOSPtVRSPu3jZHRT/uXA+8gU58EvgnDpRnIFhl5Ajpkw37otd82JQA630P+go183rfnP/SKaJUmDcA9UIQXFyeH1riXwfot2kb0/v+gkkbXg1/OVKJynU4Zxd1Q9l88eeJp28ycycsnKFwAxtgxQYq011MYyoMTlGHy4G8OdQVRHZUVqtbwG3Rlg1/iDpoQ2IO0ApaJ3q3cDvAxpt70G/Otpj/9gH5FtXdrVB798M3jsD8v7/4ijDpmhlZtqUwECrLWHzp00nIvNfjcOHzIbNNEcfXh5FSsRjlulm4ibo7BeaBrVXIQAYlndwT1GCzymlgrgFgdR1/17ZCz2j+bm5/klFHVdnBBeRCp0T/N3U6ZH+cz4EPL7KOBIwHLsi8p4jjrjlYb4NafaeJKF0+mAaVgRKMR/EvpJvChO5KGDnNI2KzlNIy4qZeaARx47/wo7Yfs3DVaJV/0K4H1ypgWjUqh6vVoDmJNwhK1wAMhPmm8BewovekzUY9f268UDsqznwc07FQjVyhqE69oGsQo1cpFP2gI2KCpPyeBJq88l380/u54PjOLEJXz4+jtAJ/v18GNO+utgXL2/lxbisBV+y1ATjbBQGw8MvRMO0lIBce6q6SkQZiDjBnM4Gz05jLg+m/gYSBObtvqwDnmROhWvkruEx/df/ceJ2Y9A3qL4mI1fXC4QLokGnv7nIDMyC13IPsLwLv2MWCzoThyFON0uiO4BXY+rdsBXSD5sJbTi8dP34CxtZrHiors+U50eGsFwQtLvkvxygDPoBnN0HB+NoRmy7UD7IRZRRcug/7KarsoDPWJKOyvtuZicwWa/Mx88BNxmvw823TXLorWN98hUEwI2IG5HQJ3T9+HrS8fz9HD1ygEt3Fib2DWmMEjJjw1ar8fW9mnwzj/NZDQh/QxSiD5WBiph2c9YLgAV7g11xETYmdRahBr9Fj7vBLqB+4F8FnyjRq79n7+5p1Ukx9jl111LcgqVWQi9m11QotKELBX3FTM2nhzWRuOPaD8/nZv1/jjZfvqodbi4k+/9vJbJwVfsBQMV7NIAbUH4eiOPHovunQaSJqYIxR6ps52rbS+MtYlAXHjrqsA0f0bGz1Hi0EwnFGsTJO+iNYhuFgVOPVVhy0jFvhhnk3jufwL6OY3z4IF+48DPzE56jV96RzLvhLN+YC+kc21RZgFNWNPme9IOAQJK4/CdwL6QGcaJo3Bdco7P2y1SitIA3vzFth+nuSukLA7npc7z44scdv3gsPlKzTqtSZPyLcAy+E7myPTRIZK1wQPPW4Fb7n94cOVkVvQmQrqg5nlGkQBEB1eTI0t+HWmQrBdwDA2pBXjdo20mXBzev3VliHvJqz3ppdgX2XEcHTg1njW3DFCVfZdhG3cOzG85E3O9CVcNgL6vcwfx92vhffXZneziy8K1FLhEh2UyoJ6jjXIAhcQJHN2c4FKktxoF84UOELfUNpVfsC1HLDau2tlw46qMW3XZfRRhZqxnZiFjMbujRlhJa/3wGK4I6Mv8bHgnUII4GNeYvVTiISM24cdZssRGUpegW1dR2KN2wRKjNXQeDTGgRBO7ylWezQHKB7gBNOEnxAZhA4HNkOZmNgFsqhRfsZmK/vb6bXN7jZoKg1Dd9txiPYDkSy628UCDfMfXFifKITO+NnC9m30GkwHHSIKALYBYW7YFU+PFuiojeXUlsoFKMGfDFKC9hjvNdGV876XQNptRMXjNSmUN4Sr1uxuQag3TJYwUjGv7qvHVd8z082+uRroPQNjvGd5fS+t69lvML0t4DAArAaOAVFp6C5A/kXF8DxT5LIeM7B7YNgv/X5IJ6WsPR5nxd8lwh2cg0etx9jFAg3UGn2wdaC+QisT4T1GSj/g12o36gQyIUbAv1WdbFT+zBJCPG5EGKbEOJLIcSTxvF2QohNQogCIcR8IUQj43hj43mB8XpOSD2KMWXNEkMXBDWFTCpQjvJaC9AWdqfw52EY6O66wE8fzDkHAnkk+qIFRAUYQU61MQRATbvrrE8LFTecprEDDSkqJ8DP7n+NjQ/28Ls3v+fmC2DpLIILc3+7BGYcylFQCt4tZqt+HEFlxVqF8tMuI7BTmjV2lgZVwCApZQ+Uz9VQo7jpM8ALUsoOqOyjdxrn3wn8zzj+gnFeveUfCT+PILuxlbrszx8gVGnjz9MvzeK4mWARh6HgGyF5hNo3uFkAaE5C6a7INWM33My7THnwCb6955zIPtKlkDxdMq/beC4fspWLfrlVtekzXlRmKPOgs5OEFNRSryNKCOsHyo04ku/BDRTbLaumaQnZURAERi3DcuOp/mYkMAhYYByfi6oHDDDCeI7x+lVGReV6yWkahfljBduf10Y2PQubB5CdC5q802puRrvahlPhw+YbTPfjJF6B4O9z7I58/7sY1ouT/ElcQGqSh28nhGnOSoJfD3pMracBDkN+tx6k3uDh7tHPUT0OkseVIMol71w+xvRGsw3GKgGpJgMlUXSKNv0AytdHph2Vgv0GMoCW0Hp8WIV8bMlZIUQCsBllkXoZ+BoolVLqO6EIZbHC+HsAQErpFkKcQC1iHEnk5TSv8Isw35kf4DWzFPdnqAuElaU6lMFt9bNqFV+3rfugZ3SrbVFzTINvvEIgV2M3uNdD+YDw/QEO674BzCH1Og9ymrDIFRCYFb8cyFM/+p0K1TZTBDOvnMzM9TdS26XYygnMLIDN34FOWOqPCnBvh/Lu4X0PtrQBzXDo1DTsuiy2xKyU0iOl7ImyCV9G+GVgahBC3CWEyBNC5B0rjbS1MHFB/qYeYb45Ep2vDBWkEshn3Qo7hkg31tt9TamdRVlvTfqW6fbFnHgzFGF0JOiWlV+Kgcol1PoeVs1HbJXQJoR2zodhB1f4n4LWlwDvW7xg9Tn9aQfBOAJFJ0O/XcqN99oiEbqGLwQgxO1DKWUp8DFwOZAuhNBTTzbegPqDoIr5Ga83wyL1hJTyNSllHyllnxbpYfU9YmRHVJXcuFCBt1qw7yNcxx43SpXUg9zst2AOnNECwZxsxN82o++WovlawfqyS3UnlEHgBop2UddAVgET5jP2tr+qLb5AW4su+PeDXUkf/g3cECBqJz2TuppQKMYIO6XTAbaEXlOjCOwbHLMizl9gZ9eghRAi3fg/GRiCqun1MUalP2AMsNj4f4nxHOP1NbI+ZD+x4F8Zg6JUBi1QsI8ZbTuo9nkEQs/iZnRghJWDkHZ19t0a1H4MvtuMZmEUrsehy3jsh9KPYKdFSW9f3CgNYucu/Jdgq2Cu6ID48WnEHyU5D+6GWyxO6wyXPbeDE31aBw5eygbrBuxiV8JVQ3mRvdPLgT35ECQ3ZS1ap0RsH7bz9vOAuYad4BzgHSnlUiHELuBtIcQ04AtA5xh6HXhDCFGAumtvjayL0WMrl4ZnuXBDYDVdDyCrsNVIDHnaTRmUS7JvEFAiykSjM+BkWJyjCSao3D7/2w1J1ksIc4KUPXB4PxzuBjlGzL15zVwMHN6Mml/K8L8MqTbO2Q1bYb9IRGRLThQ2oukr1dASqq+Gfs0+gSlBPp6mQwoUXIZX+IT6+5zCXjBWAbiyvTN3OtazeBEwLwP7AWmtHKmGFFQQSCm3A5daHN+Lshf4Hq8E4uUpHhJVNAr9TW6g9BTWP5IWDr5qrTbSQd3BE4rerMOPA2kcWhgQ4Bz9mu9WpHn2t9Mvs7DzFQC+VACfQ6ELbwJXzUlq2zXcWLejYyNM32XRTJo1P63sfTeAsmmHMDiSQIWWHzQdNLtza+OqP+FUgYo2DTSUkqHrAOUN2DzAaZrRmVCQqdyKS/cRcNJJz3QkQOus9Sxc3P9qpt32x9DeVA5U7sNrBdNr6xLq5qELNLMES+5hhV5CJKIs1YHeb9ewl4H1gK+mJj9DDVaDUy8fXNj3LbYykvrrg80w6dKX4AbzYMmA4vH2Bp0b6lo1tU3F/B34emeC11WxxHiPlUBIhsEDVH7LUOgAzANWtIMZEqUJ+ZLogNlecXbGGjSBGyauhLdn2l8alAOV+dS9aczbcmaq/fzvS7AiotV4g470+dFOd60NioHmCXNotV38aVJWRLgrY9c4VwDWW8FW2o3WRnxdjfVOTQm1DYhD4JEBMMlmX3xxoeIe5ghwdbF4vaM9YWeDs1IQ/LrnY/DKPJTEXxv8DW6gchf+nTuCDRjdiO/xQAUx9Tm+xkE7QsDuIAp0ntY8WqKWGlow6KjIcNK1hfoeK6Fh3sHQy6BclHqv6Q+tbV7CfYTQtzW0UdXqNSNaNHuIcqfLJXK9uzVKOxjQBa9VdYfSBhzS6c++pUEzeOry3wF/QH38lmoLsRKVpmwnXkuzG8O76wiBi5ekoJYJ5u0es5ZgVi/NanuwG9Bq4AQTBNWovrbC2knIHCBlR/U2Dzwd3ajX+NrGoDWDYMshf9qAOUGKHZJRAmqYMva5UL9ZYY7qW05ve+vmSgjsGBYMf5+5WhWbcWDtXkM6ysYwujuUfqCO7cSxikhnnSDY27U1bCwCfgpPt+O6Ke/ShXcBKPtFGiu5hr3zL1ExHLN3AR+gNq4DDUAXatAF2knQAsD8lVejBrtV/IDvtp2+4U4G6IsWAm6U8PLdNtS7DrqNYD7pVraGDLw7F6GE1wVyWNJt2N2XB+gOXU1RjqlA146hdakIAjvtaMHnD39GzUz7GkkouIBpwD0dCN9by3/TZw2yM3zCDxkmP6ctB0inlAQ8Na+nU8oo5sMoKBuVyozrHoYbkrHnOG91w2itwF8gksZ885ttA/4s5+bzzO/VQkAnLfENBzYHDfnbEjT3w9/1zSHY4RAodsLXd8Ff//xMhaHc0UEjnLUhFEJbPnSKToESUB979CiYNwsoAne2I6P47LARuODL/hfydMYkvuJierKVTEpqCQFf0ijn0RG/ZaD8CsIuUW7HMOb7K7pND6tzfY14LtOjKUoL6IB1eXLzwNPaiL8+BVLzW6EETbA70OwkpX34m+Lf4OnrdxFoOWFlRQ+RTlDbtmDG1xDqL37Dgux20U1DPhrIGQ8UOpb/pH5oBNHsRWPY0qcz73MDnjAudAWfckieR77oD2xwuHOB9t19+5qGdUISM1kB2rPCny9EBV4XZH+kUdsmopOYBIvKDBXdri8OJP5woQZt0VHqGoKt3Hs7U1sQa7vQbrwj0uWIg09QpgILBjgmcOqFRrAn6SLe7X9daAEldmgJb/UZEbYQ0IxkIR1lPkYyOz8E2j4E/zN8MLQWEGw7zw7a8Ke3B7PwroONrDc1uxTBApzMWoue4cONkfBt1xerdo84U/sgHaAvdW03vjQFuqF0/mzj0dT42xdvqrhRMMGBfgWjNY5tHUI9EQSVMonxVbO4ot1qJRCstNpQyIQt/TvzfMeJ7KB7REJAM5KFsEf76PtSgdfrz586qz3UzAMo0AypB2oWwZORaILNuCmmds1OSXrmD0XP1C6wbuxldrYrJKzOM+/f69eH+LfK19SisEkHUANct2/15kDFXZqiEpP0h8GJcaldGCn1QhBodlV1YXzVLEZ1msPG/j1UhFkoY7gdHO+fxKxOo1nASIqdFJnAgxdPg2f7UvvG13vKwW50f84pVmhrf7Kp/VAs6oGwUvmTqTuYA2kE1T6vR5oIJQvoBbmjoNN9qEHli1mIHge21M0xUIyRsXcX7DmptH07WoPlPWb+TE1Ry4JgJIaeZThcXHz/NAJfVlZdw9CqFXRpu5kn+z7Mt33OUcHM56OyDhuP/P7Z/Kn/PaT3+QaxRyJ6SO7hZfY5kFvfikacZuKDz5Mtm6ISeR7H603mO7gSfR528d3yc6Es9AdRd7Y/A1+kg1EbGjWBDHVmwWfXy1G73+agpuBb4OlRdJYdmSqXsVyOp/Djlny9+zz+KueTVDoacu8D7rNoqxrYBIUmH4Ai4PB2VOaS48B2KN+khEKwgVkJtf1EzKHXyaiQGrtVno7A2zZPjRQH/RREfYgQdvXuIVM/Xen39fTGpez/spOFEWYf3vK51cB47pIvklk3/YHjPNXtd7Bzjs/RQOm7fNFWfjP+KgrptTvG6xeYXtOahfZ1D0QwrUXbCvRnsIpwrEaVfNdtNcUb5GRFU2iey9XHFnOAtkzhGVI4RSYldGNHwN54SGAl1zBWPA2s8Omn/swTUd/JdvzH73dX2Xv8aZc7QbnuWdGZkHO0Z7dSNQiibYovpPbXEoxFYrOUso/VS/Vj1yAIpVXpRmHSjwiYw20wMREC/tGDxp9ACJRYNFD2m6Z4BYE5Gk47DmmNJCdAG3Ywb+v52+LzLcDqj6aQm8uIj9/iAfrSJZT4eoMEPFzLMm6R1/KOyMI7a7vwLk9morSzQLfybijsG8ALL5B3YRiu1EUSDgtnajwEIp3gKdptUi+XBlak3noMnh2Cf0+NVmR/FIm7aIgEzLJgNRjN6qbVciFIGGudWdcsBKBuglQzR7BIEuWHVsbDtwCLXpr4S61tovVwRshv2P1xDrO4KywhYOZP/ApuHW464pvvIJhgqobK7d4lgtnccBgc8UmoxXGnHf+seRpYYLPwTBDOGEGQ4PKQOuEYjBuC5UzVZzgja5Iqx4DrQn1DpBGDWgXX7ZiFgG5f7+ObHXIKUYPYKvzXLnr2tTKK6vDoZMgZDkVX88Y3I5nFXY5pZylUMPCtFdRNIhoKJ+FwCew8BXu2w57N6lG8FsdqENTg9mZNjhZFwNaFwDpHtlHPGEEAShgkPn0Seo6m9k2RwzlLvyXZsSpDwbmgxx78++r7DhY7N60d/U4LA70U0P4FehbXKnM1KuRX5y7U7Ufp+0m9iWGyjNX7ruBoVguuwb+9J1z+xh0wcqzpiNYK7OZeAPgcZVM6iDLA6pyRgQyB4ayeq2HnfJgexlvt8gooW02+rQDaYJxRggAgJfUUiatOQofR1NwAXYfwUKtnY9qPK/gU/1khfAe1Q36ggNf/PcP08BfObF7nR7KY1NZzK7pzV9mLzGVMUONfJKRRzoPvTqO2S7D2tozUkcnq82Wi0nP2J3RnroNAAaw44uxPr9kK5C03nrihcpYRQBU+Z5wgACUM1BbN9UAiZBMwbiAatOUAPNuOujeQv1nXn2qt1e5gxVP1TF+G/XwALtRg0U5Evr4CJ1GL2YIg1/ZFL7CTaVZ5KU/yeAjvDZ8pPENHmYSy+mmbi4vaOx3+CPZ6CmrwdweGA8NQWpbAXqIWM0dQ3+cSVdLcCXQ4STYwG2rbNcoivs4ZKQgAmnU9DGszofVYrl6+OPgbHCYBD3c+OANSR5mOBrpRzI5BelD7Zgw+6vPc/PB1XPLN8+cPLQSs1N9En/btYDpv/X1sbNwvpkJ4CSOgn5WdKNg6346g64YSBFbflSC4MHChhMdwVCLvo/DEKbXFF+46Ph0yBh9k0lVP8cerHuDNS27gwfxpMHsytbdBNkekfZwR24f+SO1zjLbfHKA3m+Ny/ZYchZ3VkKNtBS7UrFJC3Zx/mkBrdS0AAv0s5sAeffMHckEOltvQnDE3WLJTs8D4DW/2vyHm27XplCp/ko2+r+gcC5EYZYO5SgvU72tOHQde7cSUVtzdDrhXHZuB8lUYhxHbEAQXkCMZ0H4Vo5jPxXxFI07XvNyGD7jmzpW8f+eNzNwwWWVCmlTNOUnf8t1DTep6XNq85BlLgsvDKVI4TaNaX1RM2em7vkxE6W+tUDfLQazrEPj76oP9JNogqNEDIJyfUucWCJYvQV8vTZ03dCKvL/8pg1kdxjUjIwFPgP15f0lb/IV1mwlFiOgoUG1oTKz79bv0eQZrUWktrgMG4NUQ0vF6CCYBHSq5J+slfsgnaqLxQyNOM4r5jOo/X5kxUHU8r576CTxByBrIGS0IAE6RQlWcBMFRWnpLv9ZBW7W1MHAK3aYZnfxEYwqJtYWOOMyxeE3bJQxhkDqRz5d3I8eR2ufhcfXji/nwCauQZ62xmDMeHcGbBSpQNFsGasa3Swq1NAA7HEat718Bb73FXkB3WAUPD3ySK/l/pIUzpaOEw/KLc/nNW9PY8rMBIWkGZ6yNQHO6qhGFUYotCMZKrgF3sGWJtuoHI9SYBH+U4c2x6Jti3Qo9W1p5DFbXPT6JuAoBgId4Fv8JRQpRxk/9V9tRyghsRwiWts1JSvCGfS8HZjLoqqVcy7KwhYAmmQr+zMOMfmNWSPkMz3hBAHBAlVqMOUX7cwhusNNLBV90vjutkmqzcDAV1pw6yzes+TheR6Nq7Mc+6D7owaJtFRbCIddGc1EmmVP4T3N2nNr+E2b87cxoW0msyMS7bEiGrhP5Mcscaz0BD+OYzeV/XmM7MMm2IBBCJAghvhBCLDWetxNCbBJCFAgh5gshGhnHGxvPC4zXc8L4LCFxmkZ4SIj2ZepwTlKkyxErvdJOYJDv4D6Jmv19b36dLMRfm3rA6/qI+rmRktvifbdcNTdI/6JPGw7BAH/CNRBu1MzfAWUbyTD+z8EZbSwUDHtL1/t4c8cNUTF4T2Mqvd5Yb0sYhKIR3E/tzctngBeklB2A/wF3GsfvBP5nHH/BOC+qHPG04pDj6Y2Cc32rJYSfTzrYVqPv80C7Dfo1vbzQGYr1LGeVcchC7Q9K96h4DYZKGuUWlYPsxBy0REUTZhl/u+FN/hJDXED2aDLcN/HOjutpwzdRuUwCHv7Mw1z+xpqg6dNsCQIhRDbwYwxXBiGEAAZBjXP/XLxmsxHGc4zXrzLOjxoedwKFUUsbGwy7M4lVvgJ/+PoR+M7qVkJEOw75S2tm5ZsQIq6+9GVT6O+LAn8ZMQ41mLWQ9JdZSONC2RX8CWAn0qzZJAkGHPiI9xJ+EnBnwAkS8PAUj/LG70cGPM+uRjAdeBj4znieCZRKKfU3X4RXrGYBBwCM108QefKxoBTQnjJHK0oEZgfdWJx8G8rYE2xQaTXbZXpEgu/sZ9ffPlAqNRtMI+o3rl3KSKNu4VQCPO9FYINgNRCj3Byt4ef8IzbXMmirhqRfggoCIcR1wFEppaOLGCHEXUKIPCFE3nfHIndKObz6QmY8+TCltjw2Imfpppuh8hmUdT4f/4PrJLZCd21jFgJauPh6wtl1MdPLAyssdjGCqJexZD6jqJ2bwle4mg2wl2Ev1Vg0AgMsaE5MA+TsYEcj6A8MF0IUojz8BwEvAulCCP3tZ+PdLD8IyoxvvN4Mi2B4KeVrUso+Uso+57RwQGHYCjwxn5nnTWYZ10bfeFgI3htHRwNaOfYEqnOv39OU2vn+A83u2lior+3vXDs3dRnWxkcd1acdjdRj9I9n2WgzNmx7tJ/PEV2CLQOvIVBnGbbKgWhFqFpBCbjzQ5cfDwWfoWNNUEEgpXxUSpktpcxBpeNYI6W8HfgY0AuPMYB2+F9iPMd4fY2MRT60eQAVcHgO20Qia6O9zzUVvIMlBwYMgJF94YYBkJ0LzXNhcC4qeMUKc5ISjdnY52+Aa6FiDrrxR6A71By7oNvU17ZqM5FlnmsDtBc7DtBWJeWog5UgDXUZFMpMvQFVEi80Lr9pTcjviTaRLFanAG8LIaYBXwCvG8dfB94QQhSgpsOAuXycwONO8MkIs4PPxVgyZQk92er49b6mvXIV3TlFHcimdq07c3RyaitY1BfYQt0BFwhfV2LzroGv9lFNYM2ggroDXMcW6IHjDtKnao7PyFJ7R3HmFMmofJV2MG+R2kUS3MuwBG/UZgm2zWDpROWejJSQBIGUci1GGgQp5V7U4sv3nErgZgf6Zpvy4nSVsbYWc1guxpIn+3AHf3csQm4H3Vj68s3KL9wyDaQPnYB7+kJeX9goUaFodmwienBabfOFElugQ5xP4l1+mAWKxkZ7MVpCB0PZgaxmbith6EYlaQlFEFQQPBHs56Y+7EYFENigOfVm58XM98KzELfv7KmZwzHxX/767d2OXKaETJauvjn0JBCpKI+8RwSMHYY9wxV4ZzM76m0gpyGzH0IERqqHYBVXhf9+h3iVCaiBGE38rGa7oiaApGGofBjXY1sIAORCWjgJUaPMGR90BMB6gf/AngLKnx7Aj37/MbvoQinpVNE45EuUkMlr6+5XBSwioTVAbwJnt9QCINQpWO9OmNOiOzWNu4E5TOZ5ttPDoTbDI4/ewP+L7kVaC7Vp3hquG/gujakimQquYSUpqIShVTQClIZy9/5ZkJsYdJK4eubiOGfatub7IQheAeuZbiyd5RY+IpOsOccZ0my9moybwrE2qeygG1vpGbQiUgmZvPb1faHlkA/ESGCBzgPgi++WnnmJEAw9++ucBjpCT//MwfIcWFFbkBxOu5BDZedFzRsuGB4SOPzlhcBq6haCcYikFG75Zi5381dbp7fhG1ZfMJBV+wbz1MFfw4CkugLBvQ/YQ3H0XWrC4vshCGpNrrfDxkR+3/chph4S3mhPUK5NRkKLFpQziM8YlPEZJ3+cyKqEweygW422UEgO84+M4ruxTZQ9wF96wnDoACof3kJqD7RA+/oavbXn7zXdnr+kKHrw6Da0naApdZchFm2U76OE5nETBEP4CLrOxxtaDMEjN8sIKbrwbfgFr4bUrwQ8XMNKBmetYuW+a/jT4sdhEsY283aUKlnNlmFT8CxPiHlqvWCcEZWOAlFWmsZ3rSuBg7SWqWygPxfOORxGJ4A+8GWnC+l68EvI/hKV8bYa6AWThjhb3LIcpcm4ZxFYfdfLBI2/LT43daMNrTwOtQuy1RalOX+ivz65uEV6mME9AfocHQrJ4TKxCfiLccRcJt5qJ8bY2qW38dxGDYCeKfz1i7F0ibDWga7S9Kdhj8MKc7hNLq/JGVzEfyJqPxxyxed+Kx2d8cbCvq02MVU+x1Y5km/eah+eEAB132+ES+bsZXrW/dS21Hd3XndKxUhbpZ16/BkFfWc7c75DnchURwtaOQaZ0YVSfIuXmM/395rGzTtfjYlL6PfL3A3803TEdztUL4MyUBtaN0Fqb1MWoCA7Abkp3PTFvIiFAHirND26/LfQZ0qtfrrjECkbjDN6aZDc+BTv8RNazznhaLv3z3uNYpnJNHE1sAloFZ1vqrjOQpLgMQN2bQZaazALhywb7UPQBJ2dltB7wi52z8yJmeHLQwJzX5yIN5jVyuehu3okUVd7c6GEQXkK1ppBCg9//CTXOpgXAOAaVtL838U8KJ4GlsMjA7iYhx29hhOc0YLgVzxL63nOCgEA3PD7eU/hkh6eEM9Er959UrZFbjnfwesvn6BVqq6WpnP1gNeJNv1lMrYiBWtbhW67Al5ZQufRhXzTPz3q610PCTzOkzBprXHEn0NWVuDkoLWEgdmjMhm2wo/42JkO+9CbzfxV3kcp53Ixc+udfQDO4KVBz8ZbmbxmZvScXNzw+Jw/IXcIbqv4W3Su0RNqy2IdL98BNXBz8MbN96KuU0yi6a/2rfddSjTFW8vQLlbzg++xChiwiz/w6xDaDR0PCYxgMa+Ji1DemTqmwJdkbHn3uVDCIikRlc1pA6wQLO+RG9VAoC7s5go+rZdbh3CGCoLMxiV8fHwY/DcGF8uDv317p7O7BpoBAKPwrt1z8K7TdWIR32QjVlF2VuXLw6UaNUDM+Atz3sGMdg9HNa5jMs/zuThF8EKlObbTcgGGlpcJbCGp3/F6Fw0Ya844QdCo8WleYQLC2aVcQJLehUVjrgntRrODG9Ts1gt76bKcGuyB8FePwQ+F87ml4wd8wpWO92QXXXgr+f8ILgQSgc6hL3STmgKd6dss2l6K9Z8zThAMZwlD3l0fc7/3ERs+hFsd3motgtDqZweyFwTDzhfmW7jDJgXzuenFZZQ45CxTQibzGUXu5k2qrl8trL6DbpAaxrWTgOnDeYg/h9fR7xFnlCBo1Pg0T/EofBuHi+fD1vYXByiuEQYFENrAS0TF1qeZHna1hGDTpU5aGg7VMGk+na8sZCIz2UWXsFopIZPRzKNzx0LuFbnQ5yW8Rss0lL1kMCpFRmeUFpUN9A7f7F1JxCnEvw+cUbsGw1lCi3fj96P1mJfPdb98l6WPOhRcuTWcNwUrTeZLU2AodBCG4JGowVWE1xcBAuf8D7StacqFuH4WC0VTFrKRy+XHzGWMKlHmh9M04lOuqPHm/NnKBTB0FvC86awMvIZScx9yjL/JkS3ZciN47/eIM0YQ5DQuZNbxe+OjDWjc8HbVraS2vllVrYmESrDl6VYHKw3CnOcAvOHGvSCnqTdXQnNQcfZNwd1F9aHYeO3wLgJH9FnlPPD1egQlUGbzmcjgoqkHaP37vbVencCrdGEXv+RljnU8HwrW4g3LnkXdbcscAtccqFBemukBTglA177/Du+N3zPOCEGQ4PKwmOGIJfHuCTRZ9h1X37+YDx8bEZmdohJCL4VmNfB8Xx8GHTLVLBnI/0HvqevZ1NUFiiqAHX7eYE6PZi6y4o/jMG0mh6fV9nV4gstQ0/BKgsdVtMReqvFT4A6x/FgDtajXX53HnUD5zhZQDheIY/HujuIErNx0A2KohKVhvN8FjIRBPZayZvB1KtR1vem1p4FnMTSOXdQeLIHyH4KasTMJEkxpTTbKHXdPIipIJliaM4L0xd/rB4O0rWkJ9MXeMqieZEyJkNM04gBtac/XMb92vTUWetwJlM9uAf3WqmRn9cmesxsW9r+2dnqyYDSHC57awxu/H8l3bQWrd16PvFjw3WLBCXcj9ahshBwuKC9MoEQm84ycyS1yD8zrC6/0BYYHuUhy+PVWQKnXfboDo1G++pGUGA8Vc6r3liiDoN3rV5yRsuA0jfg7Y/kPF1FKOlfP/YQ7275JRUy/d0W91AhOFKfDuCRYsQQohOL+yki8Ib79MvOTecsZeP8K1t0xVM3A/r7JJGBcJauzBjEo/zOoqv2yOARND9WeOZvkf0cTKnmYGQDM7zEWgLfkCH76o0Wwdj7Ws2238LQBMy6gH0AX2NiF2nHcvli5OWs7gt2koYFCqu1SfUYKglOkMLfFROYW94fW3eHwS7D1vrg4N9UrjcDjTuBEXmvI/g5WzKQmb33zxOA+JbHGjSqoMmcePLtL1YAyay2tgVvhmcfv5bvkZAbtrCsEQuW2nYs5saoRreUPULO2ebAkQ2uHq0LnQPC5ItHnYT5untnc1LYzBGo7jFHtPnXGCYOvaQ/F24ENcHgmkAiFNGgE5StawMi1qDVq/Wcwq9lCGrACilfAjMFAd26Tf2Mav+HCo4dhp7PXbLq7mm9oz37Zgn5s5LC4EPgIGILjVd/SQfkthCuFEwkv5VqoHAfegfLbIT208uaNIpXOEbCSa6ij5t4wn8flk/wpzAjFBNykUEFCiN95vRAEnvJETixtrSa5M0QIgL6JzsV7o6+C9O684plA093RraV3wc5jfEN7jslUJjKThcMgwJZ9eCQB6X2htNA4oFOhmUOcw1Vjs4CfoAKJtkfQDnizNH8ErtH25E4lUFnEjpLuMSjIFwrH+Vz0YoG8iZeOT+F/GUl8TQc8JNAIVX07h31kHK0Ttqp4C3ifkGVvvchQJJL7SHLy1I9TWI0qIbaDmuCX5vchXxfOVg5zgOoboVF6HiqTEeCazCfVvRmwc0tsO9ISxHJp5G50mD1Aqd7W8N0+rCDwFqiuOmz+4XKgdVMVcNUTtZzaAyzSvzsEr/ZkxqgSlQ48Ai2m/JdjX56v/CN2ojKE5eFdtrn1/0uA3ZA9hdUHrohLaPAf+TUfikMWr0xEviPgQVSdsD4o+6nOgn4E//40AT6GOITfDEX1QiOoIQnolAh0gfIuUFQCbFE3Tf0L4SbxG/Cug7OYVP1U7IUAwFH4y5hx3Dt7trNauBsoNSdPsYp89JeENQd65ho1sn38ss3NpKJu9J7G7w5Ks5kuCe5nkQE7Uxh2yXsk4PGqw5cY6vZAOP3LxhygLTs3/8C7VVs+kxpPyqKP2EpPeuNoac8wcIFrPBRWIrcJmIC6548DH8bk6vWUVKBTJjBELRnqoyGoHGq2M3aO4oUDUa3+HpA7qv7OvbfONkq/OcRhsDUYa9VLcAH9YWy70LYyzXdic2CogBXmYiy+ZMF0wbBL3gu4zm9EFe0poH3vAjxvuPjUcwXHXRNRbszVwHFOBS1mEh2UFuICunOhTOXrCQKuJGKjcjjY2jUQQhQKIXYIIbYKIfKMYxlCiI+EEPnG33ON40II8ZIQokAIsV0I0SviXi6F4zdHK01QBOxE+e8XjEM2FSpLcpxokv8db/xyZOTbh2aKwN42oE6GmgNdR8MjIQoBK/qhPCStSM+Goiquu//dkIx9Cbi5MuH/cblcA/dMJjZh3f65m5e5TSbwjbyGry/qqsooxsl2Gcr24Y+klD1Na4xHgNVSyo6oJPOPGMeHoUzNHYG7gJkR93IjDOLjeqm/yOJzkN+dE1choBmdv5AWHziUraUU7JVmAyUEOsOtucr5y4m8DS5UW9nZeNOKVcOEbHr8byMjst4P2TKuackRhv3lPcibCDmj4rJzkICb615cw5vn30nrrBPxjaEhMj+CEcBc4/+5GKtB4/g/pGIjqnz6eRFcB4BtT/YjDolzg1NJ3KR4HargeSaHHYBTw8ZTsGcO8F4Ib+rsfBanJIx623tQ1WXKuHzmGnJsF0D1TyOqGNH7La7b9y6NDWt8LBmwaQu8TL2xfdkVBBL4UAixWQhxl3GslZRSV7k4jLeCRBbUKv5ehL3IkcAsglkDR0fcjKO4gCbx7kRtRh9a6C1WHw6FoOoGHERZqmxu6+UkRkdjSwdlMj8C/brTsk4atchIwE0efYzCqrGhOcXwW+KuBZixKwgGSCl7odT+Xwohfmh+Uao9yJD2IYUQdwkh8oQQebhtBBRVwl37/6buifpCE6KX4ThcjgO5EjbuU1WdSlGGVu3Gb4V+LQdj4OmdEF00JRhNQ6oDGhIuVDAUE+n42baoXKKMVD7hSjwxqjdwyZq99c5T1pYMl1IeNP4eFUK8j4pIOSKEOE9K+Y2h+h81Tj9IbSU+GwvTs5TyNeA1MPwI7DAykS//fSGXzNkb/NxY0CzeHfBDqQDeUf/vyYLU0TQrPkx641L2/6tTrR2YpNzjtGtWCEBPI1PK+ydGU3lPhtIO1ldD0DLe3SM3DgZiKqTecw5d2BW1SxSSwyHa0LaWMus8HhLgC+rNkkATVBAIIZoA50gpy4z/rwZ+h/LIGIMKnB0DLDbesgS4RwjxNiqO9IRpCREZlfA4T7KAnznSXES4iLfR2ZpmwC3mA61IKjrOHY3/rp7+OHgTE5q9Cm+o/wvowNLHboYFwJ7t1NUQkpVRL5qG3E5wZZNPongBcJPAZnrThkNRcy4qI5XrX12NvEXUTsJUD7CzNGgFrBdCbEOlsPmXlHIFSgAMEULkoxLJPW2cvwzYi9pYmwXc7Vhv3bBw4mgY6FiL4ZNB/VsWADSmptArJMPsIYxrNjvs5jpQwKTfP8Wdu2eQVJoN1w1A3RIVqJ94d/S/hw6xiQk4QNuo2grKSIOHoDJQwqU4Ub9cjO1QCuRVIj9Njq+xpTP1zlAIQAaI9hIqn4cJk7lz5gzSgmYCso+bBN703M7xZ7PgESO5aIffwFjHLlGHFr/5L1fEKAY9hQrSKeVG3q/x7XeKBNy0o5CsC4/HZacpkItxvQpDDkoxcHgWZG+j8to49qOx8aiPnISkw8eh32RGzHzLUSEA4MLDzxP+wZ1TZsCA+4CW0Sn+YqJ5TWLF6LOs6lpmisu4eu4nzGcUp2kUcZtHacnveIzddCHr0vgIgWCcWYIgHVRG27UMarJauSzFmG9vO4fjtyXVS+cmgMq28ECz6dzz2Z9op/M5RIE0yhjzyUxYOx66Ru0ykE4cyoQVwNiZzBSduXrxJxwifDeYo7Tkll99wBpRyl3iZeph/VPgTBMELqBDb2Acn4m2iKmSb2+L4UfoDKlDPWTOr7/lsTY1uYwKknHFwCx9LqWMGThTBQ1Fi1Qc12oCkdO4EDXZABTCDXP4qXiXqUwLua0KkrnlxQ/g2XmorZrl7L0tlPx2sePMEgRgzMRGwou120m91cNbY0dE/bL7x7ZAjJOwdiYXjvoy6tcLCxeOVRuyy7mU0vmmLdEzGHaNbfKQNhyi9l5oBTCb9SKDN0LYrSohk2Gr18Kk5Xj3ays4WuN3V7848wQBUCsQZtF2fioWMW3sg9HZ13fBR2MHkJN2FHa+BMClfBGFCzlAE8KuMhQJuayF66LQ8Frg7Si0GwD/TkUHyaMPbThEK46QwikScNeJd/CQwD3M4KZhy2DwfOoWlK2fnKGCwJftPCZ+y5U3fuismuqCv42+javFs1D+knGwmoWv1jNXZ4P9bVvEXCMAaEwVAy9e4VyDbtQW6KqPYAacjqFldjvdUNlMzHRjjDzIRwyhlecIbTyHuNjzFRfzHy7mP+SwjzYcIoVTjGEuO8W3sGIOkWVdii311OQVADdYf8GFrBdZiJGShe9ey0/mLI/sOk2gy82b2S1OUcezbh5wPfUuY9LmqC7WA5NGmZq9S1HhZ4EyOweiHNVO4SzgOFRmcIqUmC0PKqpS8P6w1UAvkkq78GeG0dhTuw/6eWOjb5kJxRwpaUXohWviz5mnERSA/xHohgXbuUkso8vYzewf28L+Np8LOB9oB/SD9Tf3Yrc4icqp58P6fPLbOFkNNXKq28IX9Izb9T+pulItnYqehxkL4YlTqgBMKJHCLpSQLXwe729cobJFx4iejbdCzlhUrcUyGDmAgmYd6wgBK1weDwczs5gqP4QOYzmT5tkzp6dgxMjnBzkJYDu7hYscjsIE6DFzI+9xIxfOO6wEQybQGL7tcw47GnfjiGHAKSTHSHiVQAnNYW0uzMiFBUdQsfkbUHf2Kl7lFzzLY1H4kOHxSbPLKSct3t0w2A+8Aht7waRcsAolcbnpfMGOOk472/r0g8FjUN/1buBztnz9AG3bx8ZYcClf8Py+ydzMu+wVwxnx7lukeezvWjT2VPErnuXW/Pl03fw19FmPMXsBaZyHVY7C+HNmCYLDENq6azu8AtteSaE93/BH+QBtOcBRI4SxKoC6kE4pfxz4AJ6BCZSSThlprOQa9j/WCaYVkcDrEX0UJ5Ft4Csuinc3fOgPRT0YkfVWSPH+Ha4q4JRMYRdd2D9+OMwugaTYLAtceLiKVXTwFPDvhD6UyOYBqzkHoq3nACW9k7lO/ovPRAeUMBjCBRPqSek+H84sQRCJY0mu8iUPlQQ8ZFJCJiX8glfx/D6Bkt9n0pYDVLeFxOgGqwWlui00GivhHph01VPx7UwNaTCvLzdlzQs5gCcBD2mU0ZdN9J21idJZ6Y67+vqjLQfoYyQxdXk8tIrQ4u/yeFia8GOekY/wJ/E4MJ/cV5az9oNhDvTWWc48G0FYpHHZx+scCTFNwENLjlJGGguajUC2caB74eKCIc2Ww6L5ztc0CJuhsHY8I25/y5EovnRKa4xx0aQxpxnFfFI84ZSq94/L4+E3nj/QS64HjrDun0Mdbd8p6o8gKAC/LuVJqGSWozOhU3f1SOpus+HusKodV7PSkW6aKaQdszNGUx2PFGoZcGWnD1knTgMHYaMKCIoXVzT+FDbeRy95nJsGznM0/VcCnqh7SnZjBxfxVdTaf4+fwNr7WH37FVG7RiTUj6WBB3DPg+JcaG6yxqej/NiHGn9dJqNTqYAF3eHpXSgpkkHtBAGtYGgrblv+N7qwK2ox5sU0541mt/F/374Vs+3EynaQPFvCpHnU5IOZDp4/u2LiWmzGTQLf0IYUTnFL37nB3xAm+veLlrDrwi5cnuh9d+d6Sinvl0CTCd9F7RqRUD80gupTqL3X5cog6AJygSeARyT0lLWFAEC6NMTYKrR1WbVRAZyEVa2YtPwpurEj6lVsjtCKuW1uiU1YcmNI3ihh0kt4k0IB7iVsjcP24QcMZ6HoyML59dPJyg7plNIzBt6iHleCShpTDyNX64cg4ARqW+4olB6BSahHhwC5EsoFTDuJdxdBl8zaAnwOg5cw/ctHY5aH7ggtyW+X7ZwwMBKjVreFg10z2Nu1Nflds9nYsQep/Y6h6gZ2wKvUFfLZHwbFfHlw4EhbIJ/sUXa2dSMjWkuE/nxKc09sIhwr+xLdIK0wqSeCQNMNnm2lkm/6agC+LACYYzxJBH4CN9yHtyRwAXSVHIlRtlMPLp5hCuJvkt5dP+HbjmF8tU3UVuDBrhn8u1NXNrbrwSfNLucrLqaQdhygLadIYXGTEfxVTmWq3Ehi8VjoNxkYZXwnsWVUq/mQN5re2EwsEyEJeNhEX+Xn4QCNOV2TqzEWnE5KVElt6hn1I0ORyJLwHjzdF0ba7M9oARufB4bC2C5wj3G8zy5UDnwAF7x9H78f9VBMilyWkMlzYiywHIaO57Ll63iOyfQ/vgVhKDy6WwA0BtkMDmUoN9oSMsMqv+UhgQLas4Pu5LCPb4jNVoabBMpIoyLGJcPe6TwG9sAFck/EKn0fNnM3L0fVPuBL043V8DNinqDkDCiCKoG00FJiTwB6TlYpspqbhEfzLlCsBYEbbj3FqVEpMYlpT6cURmbDggpY8RKfi0Su5DWgN7SGOd+M4go+rcmL5yHBkbp7CXhqAmBOkUwZaTHxMlzGj9l77iUM/N+KiPfcQ6IS4Hn2i3EcKm7DNZkrQ656dJrGJODhZ/wjpkIAlEdrk6u/UyXO6gn1aGmwwjuR22GAhIdkbSEAUCfvw3t8Smy2bBLw+Fy/GuUqOxNy1esHaEsZaZSRFpXimylU0IfNpMZA8B39tmXME4cA3ppazKa6+RKWDruZQtrZfvvXdGB5i5+w9NKbY2ZDMuNxJcClMb9sQOqHIBBtYORklRY7UsaBChipRhkSj7LpxGUONGyPpGnHUTYLTSLcOpE5b40ykl5EnzTKuJj/RHU5dIoU2jf5mssPrCEFZ51wglJr8j8KK+awbWI/lpX8mGUlP2YzfThNY8O0qB4VpPCJ54csfuY2dop0KH4eUgnbhThiricuqfb8UT+WBl2Apx2yVQwFmo+H4meAhyEvkQnNYud626bZN3jLr3iFQLQLZ9TpB4c4TSN20M3xtotpzrzx42H2Qlh7E20HRs9/wJKl5idDYXQX6ADV85QfSZGrKUWtO3qzJiWhSvTmzaGWs4eLmC8LNCdbJdL0/mqvbSvO1A9BIBxsyyVhgYDCKdwyZm5M/Aj8MiA+QkDTlgOUkh5WjIU/qmjMvGfGw+xZQIURCBZjau7ayTCNutWX3Rgl3U30A/JuAV6Jbt9CIQNIoF5UPaofSwOnyZYwB94RQ3nsgWf5mvZx6MRYJn7yfNyEACibRDd2OBb6WkVjZj43GR6Zg1p2tSL1ujhE000F0ierkjp2UxV0AJ5OASaDNqTG2weqIyoHRj3g+ykIwHDamAPTn+H1c+/hVE1hz+iyd8MlAFwtP2ZkPDb2fUjAQ3d2kEqZkWEvPOOYmwRmvjoZHpqDt+zZEcpXtHCqq/bpifI6DTVhahLwLDBgPJBM5zstks7EkJOtEuG2uHahBluCQAiRLoRYIITYI4TYLYS4XAiRIYT4SAiRb/w91zhXCCFeEkIUCCG2CyF6BWs/KgwGNQ24oTQ/dkk7FgD04pooBDmFSyNO04fNzPjDw8y4+WGmb3iUL7g0YD4GUIP/CK3YTje18zLBovZhZfT6bcUh2sCeCBpwoXYdUidyBZ8606lIuIp6UUPTro3gRWCFlHKkEKIRkAL8GlgtpXxaCPEIyhwzBVU6vaPx6AvMNP7GlqXgzQzTMehN7xRXv7CY0hfS6caOmFzPLimcUtuz61+CBYmsozPrcibTet9ermEl51Jas6VZSjrLF/9ERYPmoewAboB9qLvWJAzygNtj9zkKaB+5XcIFPE1Uow3t8m27c2hy1Xfwfnz7YacacjPghxjV7aSUp4HTQogRqNAggLmo5NNTgBHAP6RyWdxoaBPnOVYR2Q6VAmYUoe7eahhMzBxefsqbcbUL+CMBDx0/2Ua+0AN5OxRu57DIYm7ziSpX4FpUKXQ31vkNBrSDw+0M+boQOAjTqyl9IT1m23CHt13oTENumLL5Lwzv/QFtPPFLH+ZxJUDP71QN8TgaDe0sDdoBx4C/CyG+EELMNsqjtzIN7sNQU7khC2qNhCLjWOwoglqZh1cVxUwjiGUxjlD5Fc+iFDYzB6G4Wq2d81BaQKmfBpJQoRyDgU43AaOAJXz6bWwctk6R4lXynCAPVqk1ZFypvpm4ByLZEQQuVA2omVLKS1E1iB8xn2DM/iE5Aggh7hJC5Akh8jjusOX5aVALSV0IJTaGQlCeffWV9nwNub6VdnKhX6LV6YHJxmirL+ULYmMwLCHTf/KacKiEv0ezjLNNKlITlb4dv7wytgRBEVAkpdRT7AKUYDgihDgPwPirQ2oOQq2N62wsEr1LKV+TUvaRUvYhw+EbqRxqVUOakBkT77fGVMXeyy5U5pmteznQs7v9LThfXMCAbCgnKu7Svuyq6uK4cXLLugEcSohnvjmDPhDPamhBBYGU8jBwQAhxsXHoKmAXalUzxjg2Blhs/L8E+Lmxe9APOBFT+wCorSUGo1x9E2EpVDlQ3joYjTgdP+clm9yW9SZqpdYKsocTcTRvErAi+lmUy0jjxNIoFBDdA//g5863GyLfZp4TD5N6DXb9CO4F/imE2I7axf0jSgEfIoTIR426p41zlwF7Uau5WcDdTnbYFp0kDBhAjS00h5ik8Iqb33oI9CEPNfWMgk4ONVoJ+X/oEVWtYAfd6noLOkElvHBiEu6EOOrlGEbDq4nb8sCWIJBSbjXU+O5SyhuklP+TUpZIKa+SUnaUUg6WUh43zpVSyl9KKdtLKbtJKWOTscKX6YBrCjCYQZ8sjUlK7JhH4YVBGmWQOiC0kG87bIyOVuAhgXc2j6HojuhF6FQWnxvT+or++Pfwrlz13w/g38Qm7Z2J769nYbpUvgRv9+WHfBLVS3lIiEsV4nBoywGYjfNlzCsh/1c9aqpGOcX7R26EPvkw52Ro5dNCYZVgASOj1Lh9Bn27hjWiFJG1kaX/GRTTa39/BQEoC/NU+JgfRfUyJWQyT4w/I4TBIdqElvchFLbCugeGsuzbayOO8/eQQB59+K51CsrBoWn0QuTqye5BeUELlLTbzfXPrIbesbv2908QuAVsFSoCcfR6KPgD6zoPZRddopaEIpkKLpdr6MKuqLTvONGaWQGmQ3nqZyx8bHRNJqZQ8ZDAwnWj2StSUOpL9Nny1QDKEupL7UjgkXm0X7KTEPKtRMT3TxCUAyO3wyPPA+vUsT3PME/04rHXn41K8FE6/+O3/O6MsBFEna4AJ2HaTD7sPIKVVdeEJIC/oCcLh4yG3OWoVPUxYhWMZ1bcjIZVCY1VOfga3OwVX/Pr9Y/FJP35908QpEuY0x1ck40D1agpcAWMm8W0J//I4yVPhj1bNRCE5qDKTVfDnpc4kfQ5C68czbJvr6WU9FpCwUNCrcdXXEy+6AKrZlF3i2CTs85Evrhh+fyfsDlOLn5ryYWnfVOqH+cp8WNm7R0ddWFQP7IYd+sjWfRvZxstEpC7BFXnwNdzLhlyJ/Pox791ZBZvTBVd2BWzYp2RUEgOd/7szeglFHEDa4uA93xeyABGwaREQ2tAZaPfaH6vxP9SIBE6jVVJa6NIj/s3soKhjtdADEazVadh6Bw/r3bmNTmD8RfOiyjz8RmQxTgKpEJd1+Jq79+1pzjtgJNRKenksO+MEAIQAw9AF6hB78txYCZMD2agSMb6tqyGPeuhYICKLo8S217ux//98m/8LeH/YiYMXkn4BQzdHuCM3dwl7iFBevi/C9+KShr079/SQLMRlDYASgBU1349N4XMSMqsG/zpV4/zO34bcTuxYiXXxCe9GGDPSlkR4Lzd0bcdumH5yz/hD/w6yhfyMuVff0HlNj8Z4Kzd3Cn+Cf2j04f6sTQQogzqQXC4WuFGcyVql4Z+1KahH7UJtx8XSCktA3vqy9LgK39rl1gihMhr6EdDP87Gfnx/lwYNNNCAbRoEQQMNNFBvBMFr8e6AQUM/atPQj9p8b/tRL4yFDTTQQHypLxpBAw00EEfiLgiEEEOFEF8ZdRAeCf6OiK71NyHEUSHETtOxmNdnEEK0FUJ8LITYJYT4Ughxfzz6IoRIEkJ8LoTYZvTjSeN4OyHEJuN6840U9gghGhvPC4zXc5zoh9F2gpEcd2m8+mC0XyiE2CGE2CqEyDOOxeMeiW0tESll3B6ofCxfAxcCjYBtQJcoXu+HqHyLO03H/gQ8Yvz/CPCM8f+1wHJUZcZ+wCYH+3Ee0Mv4Pw34D6oUbEz7YrSXavyfiEr93A94B7jVOP4KMNH4/27gFeP/W4H5Dn4nk4E3gaXG85j3wWizEGjucywe98hcYJzxfyMgPZr9iMqAC+HDXg6sND1/FHg0ytfM8REEXwHnGf+fh/JpAHgVuM3qvCj0aTEwJJ59QRWt2YLKnFcMuHx/I2AlcLnxv8s4Tzhw7WxgNTAIlU5GxLoPpr5YCYKY/i5AM1Q1GRGrfsR7aRD/Gghxrs9gqLaXombjmPfFUMm3orJQf4TS0EqllNrP13ytmn4Yr59AhRpGynTgYeA743lmHPqgkcCHQojNQoi7jGOx/l1iXksk3oKgXiGVOI3ZNooQIhVVMmiSlLKWo3ms+iKl9Egpe6Jm5ctwLqWpLYQQ1wFHpZSbY3ndAAyQUvZCVYL5pRDih+YXY/S7RKWWSCDiLQhs1UCIMhHVZwgXIUQiSgj8U0qpY3bj0hcAKWUp8DFKDU8XQmj3c/O1avphvN4MIo7c6g8MF0IUolJzDELV2oxlH2qQUh40/h5FVSS8jNj/LlGpJRKIeAuCfwMdDQtxI5TxZ0mM+xDz+gxCCAG8DuyWUj4fr74IIVoIIdKN/5NRdordKIGgs3n69kP3bySwxpiZwkZK+aiUMltKmYP6/ddIKW+PZR80QogmQog0/T8qwfhOYvy7yHjUEnHKyBKBYeRalNX8a+A3Ub7WW8A3qJjkIuBO1PpyNZCPyo2VYZwrgJeNfu0A+jjYjwEotW47sNV4XBvrvgDdgS+MfuwEfmscvxD4HFWb4l2gsXE8yXheYLx+ocO/Ty7eXYOY98G45jbj8aW+H+N0j/REVaPcDiwCzo1mPxo8CxtooIG4Lw0aaKCBekCDIGiggQYaBEEDDTTQIAgaaKABGgRBAw00QIMgaKCBBmgQBA000AANgqCBBhoA/j9fyt+XekJ/2QAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -201,12 +217,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/demo/neighbors/shape_descriptors_based_on_neighborhood_graphs.ipynb b/demo/neighbors/shape_descriptors_based_on_neighborhood_graphs.ipynb index 01d8a66f..1079f4b3 100644 --- a/demo/neighbors/shape_descriptors_based_on_neighborhood_graphs.ipynb +++ b/demo/neighbors/shape_descriptors_based_on_neighborhood_graphs.ipynb @@ -303,7 +303,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/demo/tissues/parametric_maps.ipynb b/demo/tissues/parametric_maps.ipynb index d06b8fd4..5a8b9c7a 100644 --- a/demo/tissues/parametric_maps.ipynb +++ b/demo/tissues/parametric_maps.ipynb @@ -1,5 +1,13 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Parametric maps\n", + "This notebook demonstrates how parametric maps can be made. In such parametric images, pixel intensity corresponds to measurements of the objects, for example area." + ] + }, { "cell_type": "code", "execution_count": 1, @@ -18,29 +26,11 @@ "execution_count": 2, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\skimage\\io\\_plugins\\matplotlib_plugin.py:150: UserWarning: Float image out of standard range; displaying image with stretched contrast.\n", - " lo, hi, cmap = _get_display_range(image)\n" - ] - }, { "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQgAAAD8CAYAAACLgjpEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9ya8tWZbeif12Z93pbvtaf957ZERkn2SRTIoskqJUVZIg1awgaaJBAQQEaC6ONap/QRwI0ESQNClIAghJxYIEiFUCmVQlM7KJzsO719/u9NbvvTXYZnbOue8+j/Akg+UJ+AIe3m3OPcfMttnaq/nW9wnvPd/Zd/adfWd3mfxv+wC+s+/sO/v22ncO4jv7zr6zt9p3DuI7+86+s7fadw7iO/vOvrO32ncO4jv7zr6zt9p3DuI7+86+s7far81BCCH+IyHET4UQnwoh/vGv63O+s+/sO/v1mfh14CCEEAr4GfDfB54BfwT8z7z3f/Fv/cO+s+/sO/u12a8rgvgbwKfe+8+89zXwfwT+41/TZ31n39l39msy/Wt638fA073vnwF/820vjnTmUzUF78B5EAIEIDv/5X34t29K4YyizQQu8aRJzVSXTGSJBxqvqL3GI8JbIGh9eL/aafLG4CqFLkE2HtE4RGt3nyMlIEAKvCAcE+FHNpLYBERqiXWLkZbGKVonUdJjhEVLh8CHn3efK4VHCYcWjtZLitbQlAZZgy49snbQtgwfJMXufLtr4fd/BggXjtcLgTeCNhX4zDGJS2aqIBUNAqiReB/+VguHxCPF4Xu1Hlx3nWqv2dqYTR0jthKTe0TrwHu8lHgt8EogrAcPwzu5vXXyHuEB54ZzcrHCxgI78mRxxZEuGMmaWAha72g5PCYPtF5RekPlNI1XVFbT1gpZClQFqurWTQi8FMM1EvvH40E49+Z9JCVeCXx/z+19fH9uw3nsXf+DdZD9Wtw6fwj3z95rcIfrdnCd9r7H+fA89GZd9yuHUAqMwUWSNhW41DGKa8aqIpMVsfAHV9F5T+kVuY+5eV6Qz+vDi/w19utyEL/UhBD/CPhHAHFyxB9+9J8ibpagFERm90ACWAtVHb5OE7xWNPenbB8n3PymwH2S83c/+AX/4cmf8v3oNQrP1mv+onrM2qY0XnHTjtjYmGf5Eb+4OWNxOSb7LGL6uSO7aIiuC+R8vfucLMVrhU8MPtJ43T2gSrJ5J2H1vqT83ZzvP3rN/WTNsklY1wlKOhLVkOmG0mpqp5F4tLR8NL7inWiOES1fVaf80c17/OLPHjP5THL8aUN0U2NeL8MD1Vr8JMNHGoTAJbeWynlk1SJah9eS+jRj/W7E/Afw8Pde8Q8f/JT/cPKnnKgShee5HVM6A0AiG6ai2l1eBBbBwmYAlN7wqj3ij1Yf8K9ePSH/02PO/7Uje1mh1iU+0tiRoU0UCIGqLLKyyMbdOkaHaCyiqPFxhI8VN781ZfkxJL+94D949yf8R7Mf8bvRijM1ovGWpSsP3uLGwY1N+En9kD/PH/NlfsJXq2MurqakP044+Yll8rMFoqjwSYQdx9gsnKesLaJ1CA8yr6G1iLoJjiSN8UpgRzE2DdfWmeBcdBH+TlUWWoes2+BAJLgswkuBTTQukni1O1a9taiy5S5rRwYbSWTjEA503oTnoLGIyoYX7cXzonWIsg73o7W4bY4QAuIYzo8p35my/MAw/y3H937zGf/+2af8vfGP+cQUnMoUJcKbWe9YuZK1d/y8mfG//J98defxvc1+XQ7iOfBk7/t3up8N5r3/J8A/AZhOHnuvJSJN8JEZXiOaNnhTe+vGM5rqNKI4l9RHlrNpzsNkCcDCJYxETe5irJeUXnNRT1m1CV+sT3m2mJFfZ8QvDcm1x+QOlbeIonMMOlwSLwWoOzIw79GVQ+cSm2vmZUqiGqTwGBUWOm8jtk0MQGU107hkZkrumxUnekPjFbmL2NQRshaY3CMbj2z77WX32V5KULeiBusRdXdtqhqfjrCxpDoStNOWkyTnYbRgImtKr1i4hBfNMQBSOO6JNQufUne7ysomOCSlMyQy3LjOC0a6YpaWrFNPOZMk1xIFiLpFeY+og+MUziOLFmHt2+8ILWknMdWJoH7Q8IPjG34ze84TvSIT3QONIBHq4M+OpKXxNRNZkqkaKTxaOqTyONM91EqAVlA3yErhVYgK8CCsC7t2a8NG4xw+MiHiUuGzhPeI1iOb8HpZW2ReD5sC3oOWeClxWh5uXv2atG+v5YnGokoJHrpgEqdlcGCNDZGNEDh163FUEqEVWIvQGhFHkKU0s5TyRLN9DMnDLX9w/JS/Pfr5G84BQAnJWMbgKp7oFbG424G9ddm+0at/dfsj4BMhxAcEx/A/Bf7nb3uxqFrkusBHBpfFoASiboODqBt83YB3CK3xkcGOY8pjRf7AY+4XfO/4kneiG5yXLGzGgoy1S7mxIy7qKb/YnPFsfcT1zRguY7JLSXrhSRaO+KZBbauwaysV/gFEZrhBROvAenwcficrj849cqNZbFNmccnYVGQ6OJm8jdjUMUZZEt1wP1nzQXrFe9EVAM/qE77YnHI5n2A2Ap079KZBbkpoWjA6HEdrkXnY6V0W766Xc8FBdGGqixQ2kTQjEFnL2FRMZQEwOIcXzTGZrDhSOQC1V7xqZ7xsjlnbBOcF182I82hDJsN5OC84igu+zFzYMTtHJRoLDuSe35Z1Gx7Cu8x7vFG0I0WTgRnXnCcbjlTORHgyGQHdzSySgz+VrqaUNRNZcKY3lJmhbA2LNKUaJVQzQXOSYeYFYttFH1LgIoW0DodGeI+TMbJoQiQQGXys8KZbz9Ki8jqsc1UHp9JayBJQEq9liJoSTTvS3RqElEu4cE1U3h6mCd118qb7HOeR1tHEGuGDU6IO18triVcKH4e0Ge9RZUjfPHuZTxzh05hmaihOJdW9lu8dL3gYLXmk1wfOIXf1cF2NUBghga9x4G+xX4uD8N63Qoj/FfD/ABTwv/Pe//nX/EEI+xKDy0y4QP0OaS247sSMoT0dsXmSsnkiaN8r+P1HL/j++BUTFW6O3MXUXvG6nfGqmvH59pTP56cs5yPktSG5kCRXnvTGEa1a9KoMC30rShl2DwihMiBKj00NsnHoyqO3gnyVMM9SAMYmPMyJamiUItUNp/GWd5I570TXADxtTvjZ9j6fzU/wrxLiOcQrh9pUiKqBpgkOgm73645LNHqX6zYWmhbhfIh0hMAZgYs9UdpwZIJzuHYpL5pjru2Y3IWbpXcQDsnSjljbhEWT4RAsmxQlPKvuIV00KbVTCCsOc+bWglJvRgxaDespyuBkvNEQR9hE04wUNvOkac39eMW5WjHrbuK3WSYjzoB7asPCLLAI2nGo3/zsXkKxjMkuNKo0qNaFlKxfNiURsUB4jyQEEkLKA+cgrEPmDXKTB+dsLcQRGI2bpthMU08N9URSzQTCgi7BbB3R2gbH4DyqSxmG+8eoXd1IhNqL0yFN8d3PDqxzvl4Hd2AJqaVQwaEJKfFZgh1FFOea/IEnPcv5wdErfiN+wbkUKCHJXU2DpfGOxu3Wx/0lu5W/thqE9/6fAv/0V3qxkrhJih3HuEgiK4soGyhK3Dbc0HKU4ScZ23dSFt+TVN8r+N33nvF3Tj7lXK9RXfXHIrlqp1zUUy7rMRf5JDiHK0P6SpJeepKlJb5ugnPYlqE4ad3wYAKIvHrjMH0So4oGpECXGrOSNBPNdTJGHfvBQUjhmcUFM1PyKFnwg/Q5I1nxqjniaXnCz5fnrF9OmDyXTJ5Z0pc5crnd1T/uMFHujkc4D3XvSMKN5TQ4A1qGese1HQPwojlmadO3vu/GxiyalNZLnBfc1Nnwu1WdMC9TZCHRBcivCaP9fhrkxK5IJkMK0I40TSpoU88sLZmoEiMs5lZKcZcZoZjJgsd6PvzMHkkutyPWFxHNSGIyEyIEJRDWoQqPjyROdU8khIKkYXAOQHAO1wt80+C76y/TBDdJqY9jtvcN+UNBdeJpjlv0UhPNBemFRBeOqGxDmrA9rJ2IOMKOOucnwGmBi9/eNBR1i6iD47CpBiNpjUQaiWgdUglcYmjHEdWRpD4L0cO78Q1P9BIpBJVvuHI1W9cV2Lm9Xr9ybXKw/9aKlAcmJS7d1R5C8c3ivUcIgchS/OkR+btTVu8F5/D+w2s+mVwykeWBc7hsJzRe0XhF6xTbKsJbgc4F0dqTLCzJZRV2bOvDw+b3/nUmrH8z1/Qe31XCVeWJ5542U1SZwR6F1yaqYdylGkc6OLcXzTG5jfl5fo8/uXjE/HJC9lSTXnqiZRvSl8iE6vRbTNyujnfHK1yoeOvCI5vd8TZdCmERxKJlokpO9AYpHHbvRhmrChcJWn/42asmpB2bMg7V+T4s3jOXvWX3d/6g4OZj03WCGO5RKdxdf/lWUwKOZAWdk6icYZaWLDJHk4auis2icIzOI/CIwg2HITyIotvlZSg295GDdyFSE3GEmIzZ/uAeyw8N28ee5l7Dyb0Vx1FDZmperKasb0Y0M0MzMYxHknjeYlKDWleIIjjyX4YvOriW/aWQXT3E+yHCsIlGlS0ui2gzE9K0LpU8TzfcN6H2VnlH5WuarhP1b8u+FQ5iaEtZh9qGCjJ1E8IqpSBNaM4yNu9otu9bvv/Oaz6eXDJRJaq70VYuJXcRyzYjdxHrJmHTxlgvEKVCbwXJ3JFcVuhlGXLN/qETIjxwxeEugFL4NN45irpBCIFUCrNRxEtJPRPUuWK+zoiV5STZhj8VHi1isPCiPOJ5PuMXF2c0FynpK8XohWf0okav65C/v+3avKVQKqQMIbFzyHoUWrXt7sa4aiaorp2ZqQrTFaecl1y2U+rOiWayJosOI5eNjSmsobKaqjShldj4bo3ecuM7v2vLSoHLoq5N6A+ji+HlfzkIzpGsaNSaSzWltgrRCGQLroscQsE0OIK+89Cb6BwBsuselBW+KPF5gVASMZ1RPzlm+aFh8VstTz645A/OnvLb2TMAXjZHXM3G/Gx2j88np6yzDJso0teS0WtJJAW6W5MD83305XBGokuLKnZrLqwN0U1XP5CVxe51rWyiUUWL14JmJLEpxFnD/XiFwuEQXNrQiVJvRA07s4iv+e3d9q1wEEDw+s53xUmLT6LwfRLT3p+xfRCzfSyQx9UQyu9bX5RDg7KO1sjQN280ei0xGzBbGyKHTX7wt95oMBqRlyEH3Tel8PHeZRJiKFYK54lWHnuhqOyIL7cRL9Ipo7RGq3CT1K2iKCKaZUx8oZheCtJrR3JjiS+2iKIOrbfus8IBddGMlGD0YT2EUDT13edTlNjUUJ4o6iPHaVoNEZXEc2bWoRjYXZ/Sm+HhPNMrEtmQiF3+XHrDi+YYi+S6GoXDEWCNCDtd3YTj1WposeI8smyCM++dgei6C3u7mbAgWkHZatY2IXcxlc9/pTRj37Y+4ufFfV5dzsheSrKLhuRVjtwUwXk23cMXmV1dBIIT61qv/fp5CM7h+Ijiw1Oufytm9f2Wjz95yd85+wW/n33BkcrJXSgS3zMr7pk199M1XxydcPF4zPXzMdUXhskzxdh51LLoztfhpUL4UKNQhNqW7IqTfcTa1ytc1K8/b7aMCfibNhE0Y8fZqODY5N2aBWdfesNEliTizWJk4yUXdkzjr77Rtf52OAjf9fTLJixgDwqJDW4UU54n5Pcl1akliVpKaw7+PJPVEEkoHE0XLpdW0zYKnYvQdWg8omp3ub4xYdeTd7Su4uiNn3mjhp+JLqyPVj4UrnJJtYlwccQyzkCFHV00Ib2ZLCG98iTzluSyRJZt6FrcwngM0UxrIZJvfna3gwsMvm4QcYSLQ3fAZW5otSrhmKiSiSw4UltGou6uicEiyV3MA7PkXK1I9lpfpdcoPArPVTzmy/SYbZoGAFb/8Lf2ABAkXLiuwje7a6YkLjahPagEsnGY3KFzxXKT8rqashhlrN2K8S8JJiSCiZAgLVsned6c8NnmDC7j0I26KlE3K/xqE1qBXafiLtsv/A4/SxLcbET+wLB5z3H+ZM7fO/85f2f0Mz40K0ovyDvciEXw2NzwTnTNy9ExL09m/IvsPV6LM3QuSa4MchOcvty4ofskrA333v791GFsoIui+0ja+8GJ9eZMAJg1I4EdW0ZRjezigbVLqDsHAWBU/kYkUXrNq3ZG7b/ZI/+tcBDCOuS62D0oHVDKThKao5jtPUV1Aj5yCOG5KTKOopyx6roGoiESFqU8FgkWChcxrzLaQhM1oGqPKuxhhNAXJW+HhLDbza1FtF2ra6+4hfXowqJqR7wQtAtJfS2xMWH3FALhQFUgW0e0daEwuixCQbLbzQ4+u6yCs+pbrns2VN1xYMNOJESEFw1Oi1D9VgFBt7ExqWqIZbguWxdTEuoFffRghOVcrUJeD8ykRQGlr1F4LIJ30xHXxyP+5DSjuo5pU0XUOwCtdtFD0YQi6n6bU0pkE4WWolHoLqKIF4rVPOHl/SkX7ZQbc0nmCmby7YVUJSSx0FgaSuF5WR/xbDkjvpZkVw3qaoVfrrCrDWo6RoxGAZgVmTfAR+w3G6o6gI+SmHYSU08E/rjm46MrPo5fc19tyITAeo8Rjkd6ievQqKdyyz295qGZsD2JuT4b045GA85BtDbgMrr17b8/WNNk9kZ0OByr3TkJFymckTQjST0FOW6YRcWwKf4qtvURr9vZsHn+qvatcBBAeCj6h9frrqVjqCeK8kxQTx2o4BWtF7ROBWdAaNmBHfLs/jXWyVB/yMHkHlWGlhRxtINx0y1eeSttqWqIoyEMBZBFMxRThfWofPd50UoQpW9efOG7aKPDOYiqOYwY3mZC4I0OQKm3mFcC0gibBsckYss0LpnqUJtxXnJtxySiYST7DovjXK0wwvJI5Yxkf8OH7sXcFUCBZc4iGvE6m/Lj7D7OxLSZxGdxABsJgczrUGeo6rAr307POkfZR4Wy9ZiNR+aSRZly0UwpE0XjDx+ct9naeS5txmU9YbNNSLdgVi0UJb5pwVm87Up0QuATvatvecA1+Cxcc1HViMgABp/G1EeG6liQjCtGusYISyIcZ2pMIkpyvzu32nuW3YNfKsNIVyjt8ApcH/XVDbQtYv2W+tLXrL0sW1yi8V3q5VKNTWRwPgKEDGCxY73lRG1+pWs3EjUz9c2cCnybHMTtcL7D1bepwCbgTQD8N7UmVxF5Gw259solrEhwXmK9GHbJvDHIQpDMPTq3yG0VCnt9Mc17fF5A2wYw1nAoAjHKoGnxSRQwBw34NAqQ3d564GNZIZzn7qB2z7qbxucFYpQFB5B0DqdLrwa7Vfs4+Nz+9V19wguB0xAlDSdxjhEW6yWvmykAE1WSyzh0MXAkouGByplIwUwmBzWAmUyAkkfkXOsFJ+Y0fF4/iyBEKNTmXUHXuUPnKrqUra+fmJCDeyVRpcVsPfFccrPJeFEd8Sqb8kRfv/WS9VBhi6dB8Lw95kUxpZnHHN949LzArTe47fbt172fh0h0AJgR1pKule2NohlJ2pHnOCs5j9Yo4YZyylgmjPfe7spuQ7rjHdZLbuqMutLDwyTqJrRN82K3plKGaEUKRJqGtdcSL8WAqAwzGMF5SRLacTSA4AZH58CWekiz9x/43MUDDuixXr1xGU7VBnNHfeLr7FvhIMLMQ4S43UUgFLZ0AXUrEJHlZLblwWjND6cv+V76igd6SSIaLuyE2iteNse8rGdclmM2RTyAfA6q71WNtw68w2+2AfQTRYgkxo/SkN7MMmxqcEbijECXFtEEQBOua1Ptd0JgAHx9rQmBmIzxoxQ3SvCxeiPf/FrrP3uvTdYmgm7MYhgM2ze797N7as25KjiRkkyary0QNl7zspxRbyMmOZiNRdZtB192u3PuLU2wR2PaWUw7UpRHCmcEZutQjUfn3RzCFtaLhK/Ojnk+PuGJXnAq3QFEuLceKjx3JT9vTvkvFz/kz18+JLpWRBuH3BbY9o5d2u+6GS6LOvBW+0ar1mcxdhzSi2bsmcUlD6MlD9SSmfz6cDx0hCZclWNcrtE5qLK7NkUZQG9KIZRCHM9wR2PaaUIz1rQjiY1CB8ZsLGYdQHsBj314jMEHhFqXKgEH2yaicobLdsqJ2hBKoPtrJzHfMFq4y74lDkLgYxMKTN1OLqxFtgGxKGvAg9KOWVwOzuGRnjOVJXV3cZZ2xLJNWTYpN+WIqjBEhQjzFntVYd+2ARTjHK6qUEdHiPEIPx3RHqW0I01xqmkygYvCAqnSEK8ciRSobYPYFAEtqDvEXFdY9Mmbxc3ehHPh91KGAlWs9qZXxeGNIcSQXuwjFoVzO5Qie6AfH6Kr63LEk3ROLNoBMp2pirjrVoR/Hikksbg75mm8J/eKy3bCF5sT5FITLTxm04Y+fzdABITZFWPAaNp7U7aPU4rTrv0783gF0VIRLT3JTQAtRUuPmhueL2c8Pz7mhZnxnl4wE3fXIXJfc2kl/2r7IX/06l3ss4yjryC5qEL04jxIhZAipA1ShrSxq4n0dYCh7jMUUlUHAdehCBtZJlHJTG2ZyYq7gEXVXjq09RFLmwUw2Uahc4/e1IhtgbMh3ZGTCWIyonr3hO2jiPxegMTb1CNbgc4hvhGkN5LUujDT0u2TPSRb1uH4Te5oU4koFGWruWrHTFTBjR2/cZwLl3KudlGVEZaRrIbC5q9q3woHYY2gvJ+ReI9cbEJI31rUKEZOw03sFUzGBe+O54NzuKc2GOFYdC0oi2BjY5Z1wvU2w68izCpM2YnadXMdNb6q8WUVxmmFRIxHtA+PKe+nbO8r8geC6tThJg0icvhGItea5LUiO0qZPFUk5S3UowhOjsjgIn1QHBteUnUPZF/Iquzd1e041B6Gdmpxx5hyZ84ohAdVg9sYbvKU1SThPNow03l3UzgiYZnIgomsyb4mytm4ihuneN5O+UV5j4v1GFUITOG7DoDFV1XYGYXAJxF+lFCfZqzei9g8EZQPW8xRRZw0WCvZLhPqizDNGC880kK0FKxWKb/YnvNudM06uiYRzRtOa+kKnrXwR+V7/POrj1h8ecTsc8nJX+SYr66wN3N82yDTEPmJKDpAxNK0wwRnSHl06Cx0WAgXaeytqczh2npP7g7XOfcNa+fZ35s3ZUx8I4mXFrXI8UXXbo0M/tEZmw8m3Hxfs32vJbu35nhUMItLllXCzXpE/mxE86VCNjHJpYc1IQLqZzW65TLb0OY0K8n1asSL4yOO9ZYHennrGGNK78hkxairyyXd+iv+CtYgnIHtQ4OqUqK626XKCi+7GYModDCmScUH6RWP9JwHen0nKGTbxtyUI/JtjJlLolXY+dS6QmyLUGtwLtxUcYxMYpp3Tll9lLL8SFI+bJk+WPN4suE02SLx5G3EZTHixeyYZhYhbYQqRxi313OHXe9fiTexC9aD2nvQHcj+RrqNkgSIgXb3Pj42XY7aQtJ1JFKD6wfIatBLxXqWcjkbcx6FYSiFI5ENmag4Vduv3UGsd5TeUfqIGzvmaXHM5iZjtBTo0oVzkHLXYUmTMGeRRRT3AiS5fK/m5N6Kx9OQAy/KlLlybJoxeqO7OQaP2QrKm5hPT894mDzksZnzSC+HrgrAjTV81Z7yo+Jd/uX8fT797AGTzxWzXzSYLy5w8wVYG9ZxNsWdHtFMYlzSOdbGhWivxxsogTcKF6vwuz08hKxB1JJNE4dI1MUkomAiDwuoDsg7b7J1Mc+rI7bLlJOXnvSihuUaty2QaYKYTli/P2H+PU3+w5LfeOc1H0+ueBAviWXD8+qYH5sH/Lww1IskQMbXGtW1ar0IHb7encvGoRqFKgVVrbksxyyTjEzWOxwQUDqDFI7Sm8FBAExk/VezSOk1FOeCeGkwcx0q/UKEsV0Z5gxEajlNtiRd6+4u5zBvR8zrlGWR4NamC90COEpuctxmGyKIug4Pm1KI2ZTNuyk3vymY/fYV/+D+V/ze+Cui7sKWzrB2CfNmxF+kD/l0dsYqn2HyGNk61PUmAK/2qtIB7CVwsQ5FKesRVRMiBbu7Kd9AbvZ/z957NWIPjSgg0dAX2jpyFOHCQxctBPkk5unkmEfpCpV2oaloiYTFiB51F3YUQ5j4W7riYJhn6yNetTOero/Q12EsPp43ocAnBEIHYFk/Vu21pB4JqmPP0dmGj46veS+74WlxzIIUKTwisdhM4SUh71554hvJ61dH/Av1PgDfT19ypHLWLqF0htfNjB9vHvCz63Pmz2eMP9Mc/6wl+8UN7YuXwbmaCDHKcPdP2HwwoTiV2FggW48uwORxlyIePhiqcqhtjfChXR2tNNFC8nw548eThzwyAdJd+jdBeb2tXcqPbh6jX0ZMv6yJvrqivbgMx3V6jL1/xOpdzeajhu89vuAPTz/nneiGRDbctOOhYCiEx0u6f+F6vsH/AR2AqpvgbSSLKuV1HQrRjVEH3aq7TA30Sb+6fSscBNpRnXqKhcSsM2IhkEWJymtUuRtzlrfnaW+Z9RLnJY1VqFxitgEchfX4bagoC63DDS4l4v4Z5XsnLD6R8P6W3zt/zt+afMpfS57yyo65bKcD10MiWhZZxk2Z8ezemM1coaqEtLHIW1HAQDDjfADN9HWDrroNfH0xcw8NGELiu2sFLtXYNPAxmBzarcAsFctNwqvZhB9Hj3hoFgAo5bm0IxSec7XFARvfsLG7HdJ6z2sbkJQ/3j7k9c0Usw01HNG4oQNAHEhTfBaHGYGRxqYCrx2ymwG/qUeU7d5xCz+EygC68qSvQTYRT8tzrjcZ/zz7kESHz9jWEa2VLOYj5GXE9Jlk8tSSPt8imhY5HiNnU+yDYxYfj1l8LCneaZGjEqUdTWEQhULmspvAVMgqOCfZQLTyTDoAl2gc8cqSXGmWL8f8xegB38teYUTLRL45QNd4yc+ae/yz+Q/58vkpR08FycsNfrMNBck4xk9GlPcyyjPIznI+mV7yXnzFA71k62Isgqt6zKaJ8F7gIk+TCmzaE0bsQdf3TLYeVQGNpHWSq2rEebSm8cFBHKl8KNr33byt16xdEqZ6/eLt990d9q1wEEJ62pGjOlbUN5po2fEydN5dVRrfClonabzieXuMEe1BONpb6yVFHnXoyVB/kHmJ9y4gD5MYkaUIY6gfzFi9G1E8bvnBg0v+2uQLfid+zrlyND5nIQLU+EhtWTBCCxuQitOG8lyS3EiiVYRcl3jhD7AVALJsQjvQ2lDzqKrQrwcYj0LbS3UIyf2Zi76Q5v2btYzbQz4OdOEQNqRTzUiQ3yT8PDkHwE4kRGGQTeGQIvw7kiVl19nph7dKr3janPJnxTv8ydVj3FVMfBOKY6poQmRnw6i3T+IAD9YSm4iDh39ZhWKjFA7VOQzvQqQjXNgF+zQjXgpUqamup1ymE1zUIUWdQJaCbC5IrjzjVw3Jixx1MQ+OPkmwD46Z/3DC5V/z3Pvkgv/B/c84NVsqr3lVTbksx9yUI1ZlzLaIqSqNzzUyl6SvJbrUxEuLWTrM2pJdSOqZ5vnREX8yfYKZWo5UzlRUWMQAZ/6iOeO/Wn7Cf/3lB6Sfxky/ahHXi2HyWEQRbpqS39fUZ5aPjlacR2tOVGgzN17xsj5iXmVsyhjfShDsCHCkRFZtKFJ3SNRwTXyIIiqQuWJZJJylW67rMZmseaCXnKs1pdcs7IhIWCyCtUt53hzzvDqmsJ/9Ck/kzr4dDoKAcwgjy4J2ZJCTLGD7fWh1Ukte5xO+TE8HFOBING+0ciqrcRtDtBTE6xa96SruQgbnEHch6SSluB9Tngr0rObJaN5NO3rKDjn3WM8DFZsLIKIH0YpXyZQX6YwmjWkzQTPS6DQ6fHCtR+A65F4bUpqqCk5iH9atFP5ogktNIGQZCGksqmi6YqcIcyod/FZ2lGZeCWTVYiS0qUbVjmgD9lqC0KyY8HM6HsyJY+1KTtQWJRy5i2m84qjLW6/tiHXHHfHz4h4/unnM61dHJNeK9MoRLVvkMg8dpj1HZlNDOzZhmvKOIp+WjpGpWcoEStWR43jMxqJLi5cCowSq0ZRLSZvJoV0bdnpPvHCklw3xVYdAtRY/HeMmCZd/MGH+245Hn1zy37n/Gf9g8mMg1AYemgkv4yNeJVOuqxHzLMM6yaqMWS4zqiZBF7J74DoQV+5IrgTNs5R/Gb+LJPCLTmXB1sV8Xp3zRX7KV+tjnl8cob9ImH3mSF/lQ2QooggenrP5YMzyI8gebvhkeslM56xdyit3xFUz4aoaUzs1IDNt5CnuS2SrUEVKtKwDEK1qAmRdiXBfdIXe5lqyGWfcZAXvjm4G0JTqjvmBXjCS1eAcvqpO+fn6nML+UrTO4Rp+o1f/Ok16bAxtLALXX6QDRsAF9ia9VlzOJ3wWnTJS1W7QiIati7lsp7yuprxej9FLRbz0mJVF9rMXMoyNiyjCZQntJKbJwmScNpaxqoi6nHDtwt0+kTXbbjYBAuDoXrxhnFZcJxnWqF0nzDGkBYLu/6YNvfBuJFskMZgIZmP8OKVNDfVxRHmsqGYSF4fwV289ukzwim6svEWVNji7HnuRdhj/2iGVA9Hlpx6ElXilWfspPyUwQyWq5cgUTHXBM3VCLBvO9RojLDftmJf1jM/yM34xP+PqYkr00pBcQjK3mJtiN+CmDke8veijApCNIC9jqrgmbyOcF6yqhLyM0KvQ6jS5w2xaZB6Khy7RoYaykbRpwJw4xYCbMNsWvSiDc2htoFx7OGXzOGbxfc+jTy75hw9/yu9nX/JEB0KZG5uRyEBPJ/GBzNhUWC+4iUbBUZxoytIgnERXmnjeYDYto9cCGyu2Ysr/17/Puo3RwrFpY54ujlitU/x1THIlGT3zTL4qUZdLXOf8xWRMfW/M9oGivt/waLLhfhSQq5fthJf1ERfVhMtyzLxMqUoDDnzkaSaOeiap1sHhy7KFtkF2xW+hJaqwxGtFc6NoxoaroxFX4zFVasL0rvAoH8iRnzfHPKtP+bI84cvNCZ9fnlI2fwVnMSDAhG2qaTOwcdhl+90yWkdEC0kZpzxPZpwlW+5FK6Ydi9TT+pQfbd7hX18+Zv1qwmguiNYuQKvLzrN3ZLc+MgGCu9dlcE6wagNH47pnXpLVQOS6cgkLG9KNB/GScVxxLUM+KFofPsPagQtg33zeVZeVQowy7IPQTi1ONM0Y6lkgI3GPijCLVShoJaIWiFYQ3ygmX0omz6ow77De4l0oNkkdeDT2iVKF9chWgVCIVrF2U/54nRAlLVlSMU0qpPDEquX98Q2prFk0GV9sTngxn1FepSSvNMkVZJeW+Lp8gwxl31TlMFuBjQRmKSiuU14DqzimdZLtOsHfxIyuBfHCBWe3rYeCpwSUFKhKoLfiAJimNvVAeot1+DTGTVOW7ycsvwfjDxf84b3P+cPRpzxQXdfEJSxcdgAOi2XLWbThph4hhSfSFj1qqE8lqlRUE4neSsy6Ibl0QIyqJZtmwh9dh3RJ1BKzkCS5IFoHLEd20aAv1/jVBleUyFEG0zHlqaE8hew05zjOWbUJSjjWNuHL/IRVnbCsEtZFQltpcAKvPC6FNu3Jf0JqcbsKIZxHFQ6zkcRzwfY65dP0jJMoD6MG8Su2LuZFc8xPiof8bHWPp4sjNjcZ0SuDKL/ZmP23wkFI4RHS41VHqd6Hq91obryyZK8EspVsojF/oe4Ty5Z5MyJ3Ec/yIz5fnHDz/IjkhSaee8ymo3Hrc/6mDfwSe6mArjyqEpRVaBldtqEirPBYvaJ0hhftMVsXDwWftU0oGgOt6IAs7CZQ9wBNviwDWpOODet4SnV/wvKDmM27AbVnj1pk0hKnDe+ezLFe8nI5HbKVplGUUYrZKqKtQa9HSBiAUqIjud0vkMrWYTYQRwLhJLJRtJcpNvPM0xE3iQ1Rj3F8NQtEtm0rqZYJ+kaTrgXJtSe9csRLGzoyt+n4kmggN1FF2zE1e5zRCKepV2MWiUNYgSoE8UKQXHqitQtjzM7tZkyc644/IAW7s0DUHSO27fAXRuNHCdVZSnFP0LxT8vvnr/m90VecqzVGOK5dYDAvnelo8nfhdCxbTqItjZfUmUJJxypqKdsxZitJb+RAHRcbifAa2SrqK4NsCalRHhC5unTI2hMt68CmHRlkmiDPT2nOJ1TTANuemJa8jXhdTamcYWuj0EatElZFQlmasNbagw4zP20WujDOhJasTyOwHpcYbNrNlshw78Y3YBPDpTzi/9NoXp1O+FHyhMpqLqsxX8yPWb+aoNaK7EaQXnrU20nL7rRvhYPoTbQCVQYPiQ+LIYqCxIEqE0xhcFozZ8YfOck0qViVMZtViriOSK8loxee7NKSXBQDjZvb5sG710EjQgqBkgKzVcQ3gu3ScFNm/DR/QJUYjLADC3TuItZ213Z8XhxxNZ9gVoK7CIJ90+DLKuwoSRyIdmcT6gcT5p/ErD4E8/GKj44XzOIQXSSqIVUN8zpjney6NqRw5STlIkVvJapISawf6pa3eQ1FY1HWI5Ug8aALRbQWge5MC2wsaFODTUNLrU1jvPbIWjAuIL7pUoDcEc8b9LK6O3roPrefD/FKIbuHOV4pihOJTRSiDUNyunCYbUgXZA8Ke8tGJhuL7KHnjsDR0c3E2NRQnmryR453H97wG+PXHHVowWuX8qqdAYGQ93UzO1g3CE7i3XTOSZRzEU+4STJ+XhrqqzRgIfIaUdSY1iHLGL0JkabeNMjWBej2PutYFchhhBCI6QQ3zWgmhjYTeOXwXuC9YFEHSr+yNayqhE0Zh9QCkNqhjN2hoWRg3xrWVghcFmpRXooQXRNSz/TGh02gMqzzGf/NIsOkAZxmFxHxleLotSBaeeJVS3xdv9Hu/WX2rXAQHnCtRNchn+2ZiPqQXdYtZtUxLWuDLjX5+ojNyCELSVRAtBAkN570KjgHdbPZzVzAGxwBgaotFEBVLpnnKRfjCbFseRjtkGl9qOq84GU14xfLU9x1xOhGEK8tetvejXL0bsBZFO8dMf84YvU9R/rumneP55wlG6a6Ymsj1k3Mqk7Zdnm79wIhfAiHo5by2FFuFbrQqDoh6qDDbm+YS1jfsbJ6IMyfmG0b0o3ufG0cojMbSZwCG/UOxgcS3sKhtxadd2lAT+YrBGR7MGjnQKgdItSHVrLOe4xH4GBUtQscHDaI26hts4t29mnW7mCpEnU3NyEEPkvwaUR9ElGcSvxxxUfTK76XvGIiSxYu3Vunuz2P82Jok49VBQmcRDlP0yOaLKHJJEmkA4GPcwFY5wMpcIhEbYjcOiIfn8bh6zgKrF9CdMNVPSstFJWBMXw4DiQtWxUP3J/hqoNRlpOsoLGKmzxlG6XD+omqo8XvhrrE3jWWjccpQWrB5IJoJWlHMU7HGEuIoreBfyRaNoFe745o8JfZt8JBOCcRG43ZCKKtQ2/bQBrb0XcJAp4+qhpklYSaxFLRjFQAxOSQLFvM2mJuSuQ6R2xyfBl2P6E16D48C9wOWB/y59yjt5LNIuXVaMpEV8TyMDRovOKmHvHF+oTLmylmKTFrj97u2IkGLgQhEEYj0xR5dkJ7fxacw8eO8ftLPjq54jzZMNVl4M5sFKU1zMsU6yRFHZyYlo7YtCRRQ3NcUeUpuhBEW42sk04Qxg+U/LKfz4i7Kb+uLqGKQI8vqzacd7czeSlw6d7yO4YoQFQNomzCPEPTDiPSg9lbfBXeB4GZqsW4jpinmyEQ1u0c/h61Xq8F4RGhfQo7nYpeAatp8VqBVrhYU08CL4hJA91aHz30qWFvSnhi2ZC7aHAcqzblyIRJVyUCurR0hklacZn6rmBtkGsZHIEUKBvIjEVe7hTPtA60Az1Opatr9ehZL8PurgpBU2mECEVSCPMQyybhKAlptfOCkal5f3IdipZ5GoYLfQB2CRuuv4TDWpPzyFrijcTkIdqIF2HqUziPrDwmb1GbGrmpuiisw7t8nXbJHfatcBDeCcwy0NEnPdt0FeYmgmiIgm6YWm0b0tahiyjwELrgVVVeI8sWsS0CTLuLHkSSdN2DAI7yWRyovWSgQw+hr6TaapZFwnoUM9LxQEYDUDnNdZVxuR7jbiLSlSBeWqJVM9DV+7oO8//GQBwjTiKq905YP4lZf+gYfRicwywqKayhsIZNE9N2UnJ1q2ntm7tfpC3TSc7NzFBvDPmZRFhDclEhqk43w7ldgbSJEEod6mh0D6co93ZqJRHdAJuw9lBExh7StvnEHJDl9BJ8w/p1cyNOh5u2dw6y7pSpqibUHPaJbG8TpexT+ZUdl2U3Cu+Noh1H1BNBPXMcZSWxbLlux6xFOmh+9ANJCsdElmxEx0u698FG2EEioXSGRLe41NFmCpsqTD9WXdbQz9vsP1SRCQjSNAqkPf218B5ZWcxGYDKJziV1owa5QwhO/zTeUjuN7lCtmQ6SeXMZ2rA9kEvWdkhhaFpka3fsVI3tiHe7NVECYQ26CK1Q0QYqf1E3wTn8Gwh0fyscBFYQzwXp3GIWJWK1xa/XO1qzZBcWCWsRuSXer9xXDWKd0+to+LYF37EUZ0kH7AkL2jsH2OV5euvRK8niZsTPxDn5LOI03k3CXZZjXm8mbG9SkmsVcvVN9wD0rUwIXycJfpTSno7ZPI5YfiRQT7b83v3npKpBCc9NnYUKf6++1WrqdtcTF8KTRM2AKhRCI7OWNtXYJBSwws5sdw+yDkI7ogkRw76ORrjGnfYoDBOn/ZRoSE/s8HovRJj36KONOIy9eyODAlV9uAs5LfFRCIO9EJ2T6etIlp685evQozbe47PsjqmPLBAiCANlApdZpknFRJWsXUh7+jrRid5ikUxlQSIbjvWW0hlumtHXTzH6LrXtaf37aVUhArnQHq+lT6KgsBXrHSN6f8ydc5UWpAVawbaJ2Niw4RhhOTXhGLVwTPVufuK6HLG9yhjfCJJFwO+IMgzF9bowwvZ6KRY6wZ5emlE2Fpq9AUDnAmbF6AO1OuZ/BRmlZAOjl47kokJdLHGLZSgspsmOCr5pDwejOhvUt7b5QYdCRGaAVPf49kBkcouYRgVauPRSIFzEvJyxLWJGaUUaNTRWsSliikWCvjbENxBtQggniuChfV4MFP1B9zGinRiKc0n1pOZ3H7zm+6PXfF6csWziwREA1E6xqSLKyuCdAOFJkuBIJlFF6ySLPEVIj0t86AyUdwx4SQl7oDFRVsOx3Lbbu/dt1mlv1CG8u7tmTkmE9MOAmRcClyicEgOT0l1FMK+6AltmBtyIaNwgNWhTTduxcfWt4zfI20VYK+Iwk2OEDfKFNkQJsWy5aUec6C0rAolx0N0ID9dNnaGlHUbglzZl0WSsqwiVy4C63dQDcbHPC8Rk/AY6NsxJmB3Bctm8QW0nW48qQ2t0XcZcVWOIQ+0jYDMs9+MVZ2ZN5Qxflqe8Wk5IXhgmTx3ZV2vkooNuRxEkgVn9QKule+jfRlk3DPlFGXYUDYS4/vlfRQdRQ3rVotcd2tC50DaaTvDjDLd/k/c1x76I2e1UpMmhWnXHUXDwd13bdOB39AHVB6AaiawkOte0NyOWacYi9tCGVl22FJgNgZF6HvI70U+G+o5nIIrwoxQ7iihPNOWp5+h0w29MX/MomrOxMUaGzwvMVwKamHFcY53EOkldvbkkSdSw3qTISnS73Vt2w+58fRq/0eHwXaoAb+pZ3K7Ohx++udv3U5E20YN2g5fgYhm0RXvOjZ59Sku8joa/8TLMGggbOkneSGRpd8rat81xyCnpgVqyrNOBLQsgVR0xTPcmlTNcOsPSplzWE2znkI91PqQX1ksaL1ksRsQ3kmTRBjKgnlns3ulBmjYcUnftwqYTIeUuKvVSHBQpVS5ZzTM+T05wE4FKHA/iJYlouWrHXDUTLusxf3z5DsXzMSdPPdnrGrnc4rd5iKC7a+6y5K2dn33zcaAclnkdhIaVpBlrXJf6fVO1gW+Fg1C1I369Rd6scXkeEGlJgjs9wo2j4YZUeQutC8QrnpBHKwk20KD5cXb4xt1OJ5wPO72S0JG3IkP7qpew11tBciOpJyowB8c7ynbZQLKwO2Tfsgot1LrBHxC1Bkoxm+qQL59YfnA058wExOKx2Q4F0Mt6QqLC17ULffn9yAI4+N5WirgCXe7Yse6q/vskulOHAhWmSwe9UXdYQxgKg2+xANBpcUbhjRgckDMSWTl03g4OYvj8/jO6eo8nODgvCSS7+wGh70BedTiOngjXZ93u2XpU4ZFFqPZfTsacmu2dA3yBFyThop4MSmFa2mHU2SKonOZlMcNtDNlrT3xTI9Y5vqwQR9NhEK0/j/5jhO2Gzrp0yu5FWvtaFrr0RHOBl4YX/gT3MHRRYtmG+kk95lU54dn6iMuvjpl8oZg+rYkutvibReiAdQxn/bH076/KNoAI7yJb7k1KvJK0aUdZp0Lk+U2FMb4VDkLUFnkxx7c2FBSPg4BJcR5RTcLDqipPdmW7Vly7y4M77UfgTRbjsgn52zBiHSrnYv/CCjHoO3gpUJXG5L1u4+5B1NtOg3EbeuVhxqIJgKi6DukMIV8vTzT5A0F0WvLR+JJHZhHmOrygVIEqLKh/SSBhZGpqq2j3UG6hRhHOq7WHYaGwfhCa7YenBrOHoXnPxu1NUL3ud7h99OX+roMDaVtc9/OvM9k4dN50kGA3XNf+weoLeN6osCwG5B1tNtk4pHWhvtHjJHpnJYIQbwAogd4IFssRL6cB89B3CGLZDmrulTO8qmYU1uAQzEyBEW74/bLN+Mn6Pj95cZ/4UmHyAIXHaMReO3cAotXt8PVwTFkU0iuzR37sPbQhxYjW3WCVlTS54VV9yvVszJ+mDwGCVsoiJrpRnHwJ068akmerUGSfjHFnM8rzjO2jUJz1MkRQsvYkc0N62YR6XXdct1MNl2hs3JEJVaFuZFbVnXobX2ffCgdB2+I2W+R4hD8+Jn9/xuIjQ30EzdjjYhdguJEiWkkSI4gWHZVYN/EGdISfe9tS7wh6FmmlApoSdkNHvQaBD/DloNhs3niIZNGEdmJehvdtW2jqjrreD1FPM4spTyTlfcvDWWhnjmRQtgoCLJZStKxtQqoaaqehgcbuKt5No8kB6yTOQ92GZXLdasm+Fel8OLf9m7ppB2p3LwXCd3UY5eFrnvedmIwLTkYJqAjV8v0OxjA4FshYZE/ws/9efZRifbhxu4ddvoV7c/js1h20QnvS2/C5QTA3vlE004gvx8e0TnIUFWhpuzmTkmWbsbExWxuxbQ9TqcYrrpoJF9WELxYn2Ncp2ZUgXnY7su02k0YEnY/uXhJ1EwrQPSuVkhDd/eiE1rNH1Z546RFWovMwsdpmikJnyBpMIRgtA5x99KxEL/IQ5WYJ7XHG8uOMzWNB8Y5FzOoAw68DHCB7FoSAx9YHVfLGhgKNlAfRY7+Jysoia4u6Xr9dgf0t9q1wEN4HNJqfjMg/mHH9A8PmNyuScU2sAsfAZpWyEYHaS3TEGcY6cLZT3g55tOjZlrV6Q1tisF7TAUIhL9KHF7ba44Bs3Rttvdsmoo5PM46ojgzlqcCcF5ymOQ7BdRs4A+sOQ56IhkdRICSpnaaxim0Z0baKtumPuYtIvKCue3GVWx/cRTBC60OhmLq7FiKwOQshkD7QpMk7zmOofHfXsC/MCWsR22ZHrmu7roT3yKJFbjtneUt0WOgAEXaZwUWqU6zurqvbo1Iz6iAdEWUb0kfdD+uZ8HvnUZUlWktGrwRtqlhFE6paczzJiZWlzNaQBKDUoknfSNd6K6zh89Upi5sxyXWYjIzmdWgX152Ab1lCsesweBe6Y0iBGI0QUiKNxhuJV2ZgnPai0yfZWyeTBxBatAxRgGqC4JLZWvSmQS8KxHw11NHKJzPmn0RB+u/DS/79+5/yg/QFCsePy0f88eIJfzp6B68idBmRvnLodRnWTqsDdfP920XULX69GToiv6p9KxyEEBJxdkL9cMriQ8P2fcvjh3NSE7bCxiqslRRTg6oUTSpIZEgNZBnCfVGE4ubwIEuJzwKBaU/R5rXcCcl2Jqv2jZz9Dabqgbo8FABFUYUiaFki0mQ3iHU6oThRVKeOs0nOeRw0C3IXUzZvjtkq4Vg1YXCnLCJ8K0NLXQucE0NEYYylBlzsaZOQV0YdrTxxfFiMhd33XZvOReFmRoqDcxOtO6Rb79uge5V7H5nw0KKGIq+qA1dF//ogjqNxowSUoDpLgxTgWNB2xL96E1iv0htLNK9R27u1MLwMzsGOTMeWFfAFWI8qLfESkmsBUlO4lGsnmI1L6lhTOY0SnpEOEU0QD2o5M2sg6JW+KGY8uzpCv4zIXnjSqxa16gbh+jZ5B1ASSgVMSxrhswQ3SrDjqMNMyKG4qiqHKhw26XkdgjPQ5a7IGGjtHKoKG47K6yAW1XXAOD0if3/G1e8Ytp/U/O7HT/kf3/sT/nb6GaedHsyH0QUzVbCuY76o7qMLTZukjJXo+DpsKJpHoSAs+0HFpjsfY+AO5vCvs2+Fg0Ap7MmY/H5M/sijzwrO0i1aWtZ1J3QiwEdB6xDBDju/DrP4rpuaFEoi0hRUyL3tOKbNDk9T9FXmIsCkZV4PeTpwIJBz27wKGAHRtOFii6B34KYZxf2U8kxgpy1HSQh9r+vxgOYbimTd94U13HSkIa7QYDtuAOlRei+KER6VtLiNwqbgIjHoU/StVWDYySCwPSFlJ8Cyhy/wId+WZRNgvD2KsavCv2GS4RoN75FXAedQlEEmwBjsJKE6S6gnis1jSXnuae43pNMSpRzLVYJ+EdM800wUJNajttVh86JLZ/p6UJuqHXy7sWgbnMVECFSt8EJT6pg6abrr6zkxO/zKTOfc10siYSm94fPinJ9dnyOepYyeCaZfVh3vQgnOH7TJXZ6jZlNEluAmI5rzjOI8ojgNWi0u6pipFp54LUJ7VzDMvagqAPiE88gyMLT3CFWcC0hfG1JVMR2TP5ly+buG+rdz/u4Hn/E/PPlT/nb6lPsqHoh8rd/wB+kXPD85onjPcOFOsZFC1THpa9B9Ctfpb+BCu1s0e3KT35Bz7lvhILxRFA8ytg8kzXHL2bhEyztCoQATQBddJd+6UCTsuB3l0Qx/NKE6H1GdGMojSXkiaEeEeYA6LKpZe9JrR+w9aksozJUt3Ko5uFjvZgZ6cwzIuUEHMg38EsWZorjnGZ9tOUu2KOEDB2Q9JpbtgM68bkY4LwdcvlEWmbYds5AnShuypGaWlqH1aRVl0eXTnXPzicaXu3HgoC1iBmdhRxG2h1LvAyiL9k6N58AQtfd9H97D4FD68x+0U0cp9mRM8bBjA38kKO+1JOdbvn/vkg/HV4xVhfOCL/JTfn56ztXsCBtrZlKQXAj0uqIfzOs/z8UqODW/c2j9nInw3T/XkcrkijyPuUkzTuMtTouDzoZD8qods2wzfry4z/pqxPSlYPTaYlZ1EFOiW9OqCiA7IVCTCTy6z/a9Get3NdvHUN2ziMQiI4trJSwMmVbIljAct7UI77FGBv2PvNl1cvYK430UJ7SCcUb9+JjFxxH5RzW/+eg1vzd5xg/jlwfOAUAJ0TGCeVLTII9q2quUJpOYsRkYp/p2tMsMyjmomlDIV+oNXMcvs2+Fg0AKqlnQHVSThlFUE3UOwiiLQwzUZbLuxrTLIN/uqjoUCOMI++CY4tGI7YNAXV+eOcRJyXhSUpSGojBQKOKrAAsWPsw1yLwJ0NqmHRbPj5MBiuzVfpHODjh8tA6oRKVoxjq0R2cNp6N8CHOtFxTWsG4SKqNpnWJrw1BWaQ1la5DSEcVtQEgKPziH02RL6xQ3ZYaQDrzotD4PH3AvRcg/lQodCSVpRxpnRJiLaP2uuHhbe2MfJajUgG9wRnZoSxdaekoFbk0bink+Mvg0oniYsnxfs/nAEb+z5m8+fMHfmH3BbyQveKyWZLJl4SKejk750fgJ/5TfZL49JVpLZB11nB0B7MYtUJfZhOnP3jl51RUICeG72YTjrETCq84pzNOUWRQ2jJVOuJBTbuoRz/MZX706IfkqYvTCkT0vUTebsN5Niy8KfNPimxY5HSPSlOLRhMXHhuVvthw/WvJ7p5do4chbw0054pk6xl6nw66styEqkx0uYh9f4veoBT2EKd8ubSkexJTnMDnb8u5ozofxBSeyJRa3plGFDNIAsiWSFm1aXByIlmwiUKUK9Z3920OEeyMQH0u+aQjx7XAQnXkFSlsS3TDSNVI4YtWGuYU6YiX38ucmCKMIrYPC9dkxi+9PWHxPUr9Xce/ekg+zLY+zBWNVcVmPuepYfC6PJiyOYuojTXakyC4NyYUMVd7+4d+bDdg3YW0oCPY7QxzhEt3N8YPMWk6SLVNdsrUxhTUDu5IUYZpvn20pRBCOyLQoGcSJp0nFyNRMTEXjFKXVRJE9gA0cHlQotAYSWz2I+cqmG5hq3a4t3KcRQnRplNm1eY0K6uGtCy1RI1FFcCo+VqE74lXQ/hintEcx63eCczj66Ia/++gz/v70J5yoDVNRcb8DMCFrbmTFTBW8N7th+U7KpsgQrSJaaHQZUr2ha9A4pPWoojmI4LwOjg+CGHNy7dCFwKwl1Srj2TTl6fQEFXfVe+kQAppK47ea7CvN5CtHdlEP8z54H0BJ1iKMDm32B+eU98dc/1bM6ocNv/0bT/lkfAEEYeS8fTP97OXzRB2Gq7wSB61aHyvoZ228D+rnWZAMaDKJjTxvYl4PbSxiTmXOw2jBJLo/INfD7EYo/sraHiiF9ykx1nUwgH+HDkII8QVB5sMCrff+rwshToD/E/A+8AXwn3jv57/S+1nwThApy1QXaOloneSGEUp4aCSyCX3dYdBoPMKezSgfZqzflbSf5Pyt977kh5OXxLLBCMvGJsSyJVUNR1FBZhqushGraEKbKdpU40zKqLEBALU/iKQkXotAYLL/837KMNHYcYTTXcFKORLVDmFuac3wde3C5GbVahyCeg/fEGk7OIhYtSSqobKavI3Im4hiG6G3gdNRVmGCE4AkxscBSjvoN9qO2KToOg51uHH7mkS3eLv25V57zAug6+3L2r4hVRcO1tCcJOT3DdsnnvidDX/zwVf83cnP+NBcdbyIDtPdwRM8j/SSMjaspwntI8WP6sfkZUKyjEk96L692lhk4wKA7XZbtJNQlN3EqM4FbhlGnaOloM0kzTjG3QJAphWYDWQXgd/SXOchJ2+aUHdQMoDuuoJv+WDM6r2I9QeOJ+9d8Tuz52Sy5qKZsG4Stk1M3hicFTjtsRFhmlOJQDLbXVcf7xV7ZZBxGLg8YoPTkjZTQ/t63xofRIMgOIZelrAnzz0wEaJKWdtQT+vHCvZNhYG62wjbX2b/NiKIf+C9v9r7/h8D/6X3/j8TQvzj7vv/9S97kz6nbBtF6ySx7B6y7jxrq5Cl3DFV99oZWUJ1P2P1rqZ4x/K9B5f89dmXfBhf8KqZcdVOeFXNaLyksIaJKRnpmuM453NlmadjbBLjlcasUyLnAubdh3l8N5I4JUOB8Vbo1i/EncW9WyaFH5zDponeaMP1KdT+6zdtzKJMuVyN4TomeynIrlqiRYXMg2Cw192QU8cXsK84rvrCYr87a7Vrc+7dKAddnN7JdOPkvdL08FqjcImknuogI3ev5nfuv+IH2ctOuelNh2KE4IGywBVm1JLIhm0b8Wn+kHiuUIVBrWUIfn2H8RA7Z0dr8d1w1P75CesQHuJI0aaKdqxoUnkQRas6jOWbTYDyi7wKXai2H4QTYYQbQpqWJRRnhs0TQfrOit85eYESjotmwmebM6pWMy9TtmXoOoWpSmi6yEYWQRza7bVwZW0HQuLbcyyIoM8pW6hqHVTpveTSxTSE9WtkwZkaMXcFlzYdGLGbWodRcNWhULuifQ9Y8+mep+ymmb8NRcr/GPj73df/e+D/zS9zEB5M4TBribyI+NScU7RmiCCWRcLiZkx8E7QudL5zDu3JiPxcs/4Qxo9XfH/2mrEquW7HvG5mXNYTmk4voycTkcIRSctZlqOkZ5U2rKIRwkaMJ4rR5+uwkN4HJqEeRdfXJ3RHRx5p2pEZvLJw0JSamyojVc1QaG2dZN3s8smeFEZJx9jsugOTqNxFG1bzcj3lZj4KzuG5JL3qCF/XZSCRNRr2BGYPdvtbk4bedNOdtqtD1A1CpG9FS/bOgdYhN/Vu0jPS2MzQjAKX5uio4FG65JEJUogA95XDCMlMHmptSracyyuOZI49l+SN4fX2HrLRxNcGtS47gaEmzJP0juvWxCR0D8Q2zOIIo5G1QVqDrHfnI+uOW8R2IjnFXkEyjt4cxIoNzekotGdHntO0Qkvb6a2E0eyiDRFhEjXUiaGZKaqNotiER0nfmhQWnUNQxWGCKLrxcKeC7ohZKTY3KZ+enPMgfsJlO+GRmTOSFbnMeW0LLIprOyaRDVq4wElUBNWz4by6Vi2EYugwmt7dq/9OUwzCnvr/FEJ44H/rvf8nwH3v/cvu96+A+7/KG4k2iJmkryRVk/HFMoYul6RQRDeK9DIwRslNYPbxkaGZReQPBP5xwW+dv+KT9HVAzLUTvihO30DT1fVuXuM4yTHKcm+04XncsCmPka0ivk4C9VleH7T3Dk5cqQN4q/CEfH2tebY4QktHohrWdRJShVs4CCk8ZaM5T7dkusYhGKnAxFw5xUU+4epiir4wJNeC8TPH+EWFXpQBcbfdgokQk9Fuz+4c2ABX3g8nu/qNqOpB2FZqhbd3O4jhvKqORenWZGgbC2wCR0l1wJ0h8SjEG84B4EyNsN4BOXb8Uy7OJ/yzD1PKqxk2M6hlwAWE6+lDC/Vtx1U0O+yLcyBBaklU2aGSLyqL3BSh0JoXXftPDv+7SRocZjf56pIoKG93lHFCeGqnudnLAVSn9aGkw48LllZQbxPsVSBbVqUbnAJ0cxM9Nd9+K72LzFTlMBtHciNpX2m+GJ8yMRWX2YTX0YyJKjnRGxIR6jm1V2SyDsX7UqO6+RxVtAElud/2Vl2EG2nacZjR+YajGP/GDuLveO+fCyHuAf+FEOIn+7/03vvOebxhQoh/BPwjgCSaBeVoHxiZzUZgX2uc1ngdJM/N2pNdW6JFjdyEgS53MmZ7P0xNnp+seJLNeWzmXLdjLrwepvj2rQ/tpfCcRDkPkhWxDDn/f/Moo1glpFcRyU2NzDu4sDhEx915PtYjmyCsmq8SLuIxWQf0WhYJ1S268WlWcpSWnCcbYtmyaFLmdUppDTdFxvVijLrRJFeCyTNHctWECdKivnNIZwA92ZCWvTGx2Q33+DgC0RzAmL/OfBp1EPZAQYfsip42REzWfbO2mRKSExVz7nI+SV/zk6P7fHY0pc0UxuigkdJxV4ivYz+SDExXrivQ9u1RaR2iaAMStLX0QkR+lA7AMQizJnJTD87PjgztSAZm9Vk78HHs29hUO0i83cHAhe3qANYFKYK9+klfBA5gNDdI6zktsakKxfk6DHfVFzF/Lh+yPE/YjCOmuqKMDY+i+eAkIESlouomY22gxvNpx13RtaF74Fo7jsI4veRXmgjdt38jB+G9f979fyGE+M+BvwG8FkI89N6/FEI8BC7e8rf/BPgnANPRI6/KMIClt4p4EU4maCQIVN3Rwy0q1LoMXJPHU9pJRHkmaM9rPjm65J1oTiYqrgngpFjaUNwktBtLaw64CSGMAJ/oLW0m+cXsjM0spslCZVwphWjqAFn+mv6xMwEYYwpPPJe4KOLSzYhGNcZYmkZ1UqDhc7W2JLplFhVI4djaiJf5lHmesi1i6lWMWiqSS8nolSN7VYcJ0m0ZdnRroevedBcztNQ6FWsfmYOx9gOT4CbJrnOhwr9emOcuE5UdCGmQcgCa9duRuQuz8kssEY4jlXOWbPlZ6mmzTs1cKWiD2JDoRt/3W7G9hd2YsFFEKmipCLFTpirYQeSdD52nTnl9YK66db5eS5o0aKWo1OK9YHMrApXCE3eOQ0mHtzKon+euYzZrQ0G4T4scoTOmoxAV+a7wLQVttissqyrMbrRXklIkXCZjJlHVFbnDA5+pisoZfra9z/PljOhGEi2DfoisA5OUN2pgHXdRcJqDc/hL2F/aQQghRoD03q+7r/8D4H8D/F+B/wXwn3X//19+hTcLePsywF6jnmug4xDoq/Ci2M3ru9hQnhjKc8/0dMsH2TUztWXtUpRwnOiAqGu8Yt0mXbsw1DW+zrzytJmgHSmiZXdVmxbRijemRYe/6WYNdOlJrjyiFdSbiGamqWctMraYuEXrIN03TSpOki1aOq6rERf5hOeXR7i1wSwV6VoQLyFeOLJXDdFlGC0X/aAYDAK6sDeH0svcew+Enf+uGoOLNH7cVcXjQPgSAGhtGEhrb10jIaDu6lsqYA/aFGzqGccVsWjZuoiFSzlXW/jGM8U7TkjVQbsDcKkeJnXfuOZ9p6CbUO1zfq/F0DHwWsIo3WERtOx0Urt0qy9Gl3XoSGlBm0KbeqSyQfuyHB987thUJF371joJG020hHixcw6iboddPHxw0E7xaYRNg5ZpT18/XIIyXPdmpGgmgrbd/fKqGrNuQ7S0bmL+4vUD6s8nHH0F45ct0XWBXBUBMZklA8jNRzJ01/qxo9a/Cfz7ZUvzzV5+YPeB/7yrNmvg/+C9/78LIf4I+D8LIf5T4EvgP/ml7yTFoC/RWyikteGmdITdq26GaqwdBaRkc2R5b7LhcTQnEnZoARlhSWTDqk5Y1OltfqLBHOINevReZXk4lh45GN0Nv+6PVzZBx1JaQbQS1GtJWXSFrFTRphaf1szzILxqvWBTxmxXCeplTLwOzNw690TbIDJjFuVOTasPuXvn0BfC+pkIuQM3eQJmQxR7Baw9s6Yb/e7rgNA54zsYobQEAqo00PbJ7kF0g8N1yGEY7S9jThGGnyITHF13fl4Gx9zXfPo04oDAtewhxoDQXbpnh47LwTrZPaLhTpPDpzHtUUZ1YqiOBXZkySKL580USgrPSNVcVyPyKkJtJGbTcXA2dpAJOOTb6KZAtdy1Q2/djsKFOo9sAjdJMU/4TJ8GLdj+GnnBdpsgniZMngrGLxqSl3kgae7qSvvr7JQ8UDZXpX072dBb7C/tILz3nwG/e8fPr4F/+Jd9XyQ7kXIHom4OIMSBlVrRTAzNVKAmDefJhki0SOFovOaynbCxyaD2fVNlTKNDfYdNEyOFRwvLVJfcNKMhp/xVrOfGxPkdU5ILPADyJrREq7VG55Jyq2jHkmai2KYapGclRuH8CoVey9DCvHCkV03HP9EgN0ETQmyLwwd8rxBFUUIaHFyPMgSGwtudU6ijrv213w4sXIBh2zCcdjs98VpCHNil3V5bdF3FbOybzEt32ZXdvvGzVZO8+cKeuk8FkuEeIeqMCjf9bR7IalevUJtdwdR32qY95DzweTSh5du93o0TfKRppoZ6LKiOPfK4ZpKWQw2paA1N5yiOkyBBWFpNkUcky46JPW+Q22onUdhBm70M5+Iijc2i0DK/g5bPxjLIGHowW3CvDNVySp45fFdgVoXErCSTLzzTL0uilyvEahOAXlm6a9fuXRsA0QSHKcv2352D+LdqbxulVmI3atyRjvg4FNfKU0U9hSStuZeseaCXJKIJ8nk2YdlmLJqMq3oU5NW7wlLeRmjpGJuKkygfCEesF9S1Cm2jnDAkdOu4gv5Dd8hd4VLsYd8h3ISiGyoya4GwYDZhqjGw+6gQofT+zoJZedJri9k49DpEC4F/wu0WtON8GJxAXykfwucwi+ESM9Db20QFR3Nb8MWG9l+LxkVd5b3TD+0nO+9cpo50JkR7INzOURypnAd6jUVQesvLdvN1Kz5cc+fFQUbiYw0+GXbcYWjOhZscuRsbF9aF+shd+bUjQLgTTWCxEggCP4XL4sGh2ElCPTVsHms2TwTuccFoVHYfKaispmw1o6gmVi2tkzyvZjydH+GvY6J14KlQ60AvP+iwlFWQe8yybmhwTzOjv086Xg0XdRq0hSO5AZ0LzDoMhe3XX4LwsWP0qsHc5ME5tDbwoR4sVFjDfmJWNG5gwv6m9u1wEM7fWZl3qRkeCC8EjLucM9a0saBNPZO45ljnJKIhEQ2y0zxw3QyEFg6jLG0nyOu6m3Kka0aqIpENtoM/N9uILBeY3HYCs/VBLnlAjGJ0uJn731nAe1Rhd97aOsxKEieqQ8ztlrHtQl/VBCWxaFEPrdVeE6KPloTW4UYRYvjMgS2r/53Rw83uIkEzkrSJINoYzMaiylDIkh2/hbAtWgp84wZwj2hCi653BG9YT/xSu46lqBtHl5aJLAJ83Mcoijf/9pZZBFftlHmZonK5z7d7sP676+vAieEel2Uz6G14/eZtLLqhK+oWVUra7FZ6KEPdop4ZirPgHKp3ah6crVDCB0avOhoEjCDUH5Z1yvU2I7/OSK8CNiVaNGE6My8DP4eSiNEIbzR2llDPDM0o1ANM4ZCVJ1p1cxu17ZxFiI4QoEtgHgBszuwAY6oMOBi1LJGLdSBqtnaH5+juEdHeSqj7mtI3HNSCb4mDEM4j90PDDtTjRVBaBpDW4QjELjYOMvHe+CFHm8iSRFgsghO1GdSxKqcx0g5jwI1XpKoJeHZZYpHM2xHrOkEtQsHJbDtdz22xI525Te22f/yNQ/fQb3/4c2FDbqqKW5RguiO+6QuwdUdXn5fd7qkGktl+dP0u80mET8K49fZRTHksaUeC4p6nHbnA2FwYdBEilXjliRc2qC3VFkrXTa6aMBquAzrQdRDzIdLZJ6Xtz89CYyWNU7xqj0AHXdNeET3pGKVLr4avITiHSzviZT1jVSShC1C4cL16LQgOuwyB/u8W+EsJkOpAyiBc3E6ecG/TCbDxvetmFDbRlMeK7UNB9ajhwaM5H0xvuKkyLjZjIm0x0jGOKrR0gf2L0GKUW0U8h/SiwVxv8ZttmOfonIM7PyJ/MmbzSFGeCGzqEU4QzSXpdeCF0D2TWWMRUoR/3SCebEPR0vXDad1k6AD4ut0CVgofRzuKwVsSAk7Lrmv1V3FYy+8JtUCAvN6q4vRwZ9/NCYQwVxzUDWbS4oB7ao2KHTO15aqdcmq2mD21rJkqeGxu2Lo46Ca097jcjsJuv3LoTfDuQxVdqW7asMspI9PlyGEh9qv+QXQm9N4FgA258MBM1d20g7twhKp9a8Mu2bXA9klg3uoc4kCI085SyrOI9RNFec/THLWkZzknWUnVaMraUNSa7SIiupZkLzWjV5Lkqg7j1p2wMUlgP/YykNH2BymrN7d31YDeBn7Iz07OODZbjGg5VRvWLqH0hlMZnHKNwohygGE3XnJtx7yuJmxXCVkBZmsD6UmvWMWbbUjgjUjDK8Eb6EDZ8VjuFRhvd2ZcpGhHmupYUp2EEf0Ppjc8TJbUTpHHEUoGxG2mA4CtdZK8yci3CdFCEs8dZh50XFzdBJGmyYj23pT1+xmLjyTFk5bouCSOG6rKsLpJaF5o8IbkRobIsWvxu0ghm85BWIesLKqpwz3Vd1ysC9GlD61bgQnOYTbGjmNsZgKhzV5xNqS9Habn3zGS8tdqwvsDXkg8yNIiVBDOlS1Ujea6GXFtR7ynG2YyAQoy1zCRJff0mmt72Ko6UltGombtU67aKU/zY1brjNEqsB7pTafaXJbhIb9V7AueWB22EDt5u/6m3kdZDl/bPbe3V4D1UtJjYELkEL+ZL3bkH8O1cT6EsKOI+siQn0vyhx793obff/CKd0dzFD2Lc4AKf7U94bP5CatshmwlOleojQisXN6juh2mHekD5yC7mkqfPyvrMLkmXiiqy5g/Hz3o5Od3D/TCjihVxEhWBwAfCFHc6+aIp5tjxHVEPPdEN0Em7m2RWs+KBBxcH9HYA0LZIS25gwBHWD9gFLyMaEaSegLtacOj6YqHyZJUNYNoUusUrZdDiqGlY5mnuOuI9MKTvW5Qyy1+tcZtc/RsSvNgxvLjjPn3YfSbN/x3H33OD0YvaLziZX3ELzZn/OvZOyx0xviZYOI8UVdrkpXFJbuBKtG64ZqI7V7a1hcftQ7DelrRHmdUx+GcqiPRMbP3CF+I1oHN69swi/GXMrev/yjBdeH17aqrTUKaEQg5ROB5sBENfXtTcV/FWF+hZMGpLIbiZe5jjmSoMp+onAs7oXSGl/kUdxNhVoErUGwKfAf55Tbf49eZ9weAKpccYt979ujwS4/Uu+lKKSX+Nit0dYgmvH0tXBZR3ktZPdFs3gvO4XceveDfO/qC5A7p8VOzJVIt/2qVki8T4oUivpFDwdNDKKLu1UqEg30tDme633swG098LdmkY/7IvMvmNOIimSKFD84igkTWHO0NcTVe8ovmHv9i+QHPr46IryXptQ3j12UVukKjW9T9LlyvgasDQhF2HAccRxREiVXRp3n+QJhnuP5K4DsHEqZ4BfWRJzsuOE83g2bFmVlzYaYs2mzg8yitYVmlFHlEfK1I5i4ISjctpAl6lFF/cI/FJwnzH3pOfnDN33v4Kf/e+DO+H73mRTsjkzXOCy5OJzxdRqhKIzsIfrSsw4a4P7PRExP1xeO+UG00bpIEhORIUY8VxamkOoXq1OEmDToN72NbibiOSF+HqbL9OtivYt8aB3GbzWj/wTqg9u5+bIogkFpsI16XE57Wp7yv5xxLh0RyJCU4S4Pgvtrw2o5pCK3QqQg7ceM1z6pjXs47Qd7ch/RiW3Q3YRgDvqtgN7Q5hx90rcf9za8f3OnPpX++BR32f3eOvaPwUgyzBGFU71ar0nat1dhgM009kZT3wL9T8sMHr/i96TN+mDzHYLm0UxqvsF4ykuGcz+Its1nOehoH1GF3LG+Enr7nWmwHEpmgokwnD+DRxmO2gvZGcaWn/HGjuToao6Uj0zVmYjlVG7bSYLA4L/miOeNfrD/kRxcPcc8yxs896WX9BjM2e7soVT20PQHoHGt1ElGPgyQfMlT5o01QKFdO4K1A5fVBsbM/D68E1gjaieWj4wWfjC54ZBZDtGOE5V604qKecuknLOqMVR3jFxHxnAB9n4fag4gj/NGE7eOY1Udw/puX/I8e/zl/OPo5vxutmMmE0m941c6Y6YKTJOfVcUmVZ+hCEq8UsjHovDmUHNw31RWOtQqYjdOY/J6iPBW0GVQnDnle8hsPL/hwfM1ptOGynvAin/EX0X1Km6FK+VdTOOeXVVfvkhfrtQfUXPPl/Jg/Tt/lkZlzri45lSnHKiMWNQ6HxaPEmrUzQyHz0o74vDrnx4v7VNcp0ytBvAhITrzfhW/j7O4agHMHcxoHN6Hcwyk4PwieyNoOfIu3d4uecs0m3Vhz2Q7DPbJoeAOdGBmakaY4k5SPGj5+cMUHo2sS2Qxq1zftGCMssQwR1NKmVPZwRsUbhZ9kQ+Qjrcfb0Kk40LAQnTCMCD17mwhsFMRY4rlA1RH5RvPTTYzSjvGopHWSeZsNYkHOC/5s9YifX5zTfj5m8oVg9DLAyOmUtPvr5uKAYVDrKnQcEjPcJ+WDEZtHms27gurE4mOLqGUY6LuQpFeSaGWJ2q7N13azGB1IycWK4lSzfUcQnxV8f/aa30qf8VjPqVE4H+pd/WDUvWiFFA+5LjKwArPpdFLyEm8tfpxRPZyyek/Svlvw0eyad6MrHqk1iVBIBKey4kRteC1mHMc5j05WfFUayjwivpFES8K49lt0LoijgMScJKzeT9g8kWzfa5GThiSteXey5cFoxcejSx5GC5yXGGE50oFZ/Sf+PltS3C9jpbll3w4H8Q1MNA4fKVTpMdsQ4q4mY34UP2KqS07VBkzBsUzIZLgauauZCEspHAsX87Q55Wlzwr+cv8+XL09JXmmy1454XoVZB2NCFBNHnXxZd9PuqVLJquWtFOJiV/0XMLA5CRdC3zsZ2b0/oLYb3qqbJxiKuErhxzHtLCG/p8kfe6b3NvzO0XMexwuMsKxtCEUbrzDCUjlDhcF6ybqNaRoNwmNNgE37SNMzgsvShm7CXki/b4GKbve9qgKbUbQEs5bUy5Q288xHMf96nfHz0fnAdeG9YHE9xlwYxk8F06ctyescueoIXDq5RG/2BJaNCgNcRgX2pYlm+b5h+65HfbTm+2fXAbJeZFzcTFlNE9pMMnrZrVNtBzbuPr2wiaSeBkrCj04XfJRccq5XTGTNwsU4ZBhJRzCSFaWLeGmOAAKD1dbvdDSMxo8SqhNNee54eL7kk9EFj82cR1owlgkbV1J2KNNYNpxFG5qx4mo6oujYu2XrEGWDaDtGKL0Dn/mupd4ep+T3Y1bvS4oPaz5874LHowVjXTPRJWdmzblek4iGazvmoVnQaEUzUVT3NJ/ac7z5qwiU+hXRXaKxyH6MVkK8BGsEYHhlT/nnhOErxj/mE1OQibAol7alQfCqnfBn5RP+fPOIX6zO+OrlCcmnCeOvPNlFs8MgGN1RuR+2i7yRg3o1QiAdg56E2Cta9q3Nu6Tx7rKeybkXwB3OtxOSEVUnXGwtbjaiPhuR3zesPhDw3pY/ePCMH2YvsEgqZ1jbhIkqB6FaCArYqw7P7z0IKzouQ4UWYiBrUcVheOt7ujQPqgoMU73Qrqo9qvsI2XqijSC57uYZMk2bacp4r7bkYbwWxDcd/f1qD8DVi9LE5kDbwUUBIOcSQ3E/dGrWH1nOPrjhbz/4nI+SSwBu2hFfHZ3wk5N7vBif4rTBS4Ns/Y4rsmzxqekYs8Gnlli1ZF0htfSKhctovEYShslGouaii8vLRiOagF0ZlNGNoR11tHGZ5V625mG04JFaMxYJS1dwZS2lj0hEwwO97LhJBOPkjFxNghL419wrLoux04jFhwnbdwTVbxT87pMX/OHJZ8xUztolHYuXpXSGWmicl4xURe0VxzrnfrbiYjLmpfpmwxjfDgfRhc9eqUG/YV+HsLcQhnfVaBdy5GQZpOFdpHllTvi/8Vt8fnLGD0YvGauSSLRcthMaF+oNf3L9iIubKe0yIn2uSS88ydIO3I1EgQBm3zH07EDDQNDtnN25cMNU7DmJu8Ffd5oToFSYKRDhcgwVdxh63j4ytNOE4tyweSyp3qn57Uev+YPJVzwx1+GtCC3EU7XBIljYEVsXh/TCdYVfQVDa2ot09s9l38LhqA5F6pGlRxNSEJvukbM0PnCjShEYljJJG9+aOfBhViXaBCCaqPeYj5IoRAl7StT92vdclNVUUtzzJA+2/PV7T/nt7BlPzDW5jznRG2Y6Z2JK/hXwojpHF4p4pXYoURgiE2mBVvB6M+EXs3sY0TKSNRaB8xIpHArXqYjHPC+OWK5GpGuBzkN6iTGhJjA2lMcCNQuw/wd6waSLmhrvBhzIA70mkcEBXzXj3eCgP8TPhAPsBtAiwtzRaeA9KT8u+eE7r/j7Zz/l+/FLJI5LO33jluprThA4LGJpA0fnG6/8evuWOIg9kyFH7PN02O2kwdSQv/ey8vEi0HapynC5uMf/69GU/9/kHaJOW8J5wbaMKDYx6nVMNBdMFh6z8aTXLWbbBnq2tgsZlRjaikIJiNWBQ5DWoYom0L71oX9eBVm//SRPCERRB42K3vodc28cWFT27p5/NzMwhPrdzVgdCYqHjqOzDb8ze86T6JrHejX83RO9AAIgSeEpnUHiB8r0LKmYp9mQMv3SJblFmqPyQHir8/agvrIfMSVyD+RW751D/5zWu5awncRBGTtW2G4Q7GBeQQhsJANcPXOcZCWP4gVHKh+oABWOB3oJCWyPYy5OJ1TXI9yzzrEPTE+dM8s9ZqG4Ho35r6MPuT4a8WF6xUMThv4gFLEXLuNpcxI6XdcRegt627Fwd7WmNpPUxxAnNUY4ImHvVDlUeE5lwY0Mbfd1GaNKEUBRVahpDBibPdLkdqSpx5LiseWDx1f8rZPP+X78kgdqxcKlQzv762zbRhRVhHPfzEV8OxyEPMQV7O/UNtHozaGwjRe7ARxVWaJNV153AbxTL1K2acKmWyVVhrboeBv6wTp3JHMbHMM2aG6Kxg5DYS41yKIJg0K3CpTSOtSmPlBXdlkCWtKOI5qpoRkHItK+YtzudStUBdHGYdZtEG3ZlGHcmG4n3Y9SYg1oyCt8Eo7FGUE9FdiTmveO5iGc1XMedVwTdq+Y+aIDkY1kxX2zZKZz7kVrXucTbiJH33IR3n9tOnQwE7FnonXozd2MW9g9IZeDC7gbxDt4eRJo+vsWKp6w63eOpk13acEkriid4bP6HMUZwMC6dK7XnEdrtLG4/W2516LofW0ByZUgjyK+4gTnBUp4jvWWSBQ4L3neHvNldcZ/8fr7fPH5PcbPVEBBFp3MXSd11ybyzrqS+yVj79Z1up39BG0/V5PFu2chDjD98kTgU8t5uuGhWWBEyys7fQPjc/D+XvCyOeZlPSNvv2F1srNvhYPwQuBSvRMUsT60ovpOwP704i0TjSNaNchGY/IQ0lpz+NqQM9KJqobWndrWwTF0/BJohZdhzgNCFV1YFx5U0YelYW6hJ2cR1uHTGDuNqWcRzUSRn0nqGdgk8CU47fGRC6G2A72WJFeK7LVAFzZ0dzvZtx6U5bVCKIlX3Ui3Uh1bsgwPkYJ4FIh3T9WGU1lxrMbkrib3d0vajWTFiCrk1eaDw2vY8UC+sS4qDH35LBuiuuFvnA/dh+HFe4NjqiPShQMK9nBdVRgksv1gWPdwiO61btdelWUTisRdyucMiI6G8KYZcdOMSGVN2vEzPDJzSmeonMZaibRhY5DWDdoa4dMMZusQVoCQlG3MM3FMrFtGquJxPAfgZX3Eny4e8cWX56RPDaPnYQRf1G3XGpZhQlN3KdueNcBrG7A0jZeYWxDQyoVp0NEadNmlt73TudXVs1GoF6nEMjMFI1mxdinPm+OBZ/Xgs70aUqWLOjBxl1YjhH/bY/RW+3Y4CB2gsapsO1rzFudVYBz2ntv48cC90IFiOjUhvW3Rm47spJv0O/gMc6s20OEMhnmH2yYFTml8FNqSsukKj/08glK4cUp5P2P70JA/ENQzT3PcoqY1o6xiklScpDmZDrvsokr56uaYzXSEl4poG5GVDWqt8EURhrK62Yp9UWGhxNsHqDqz3pH7hvxtk7G/ijW3wFVJhksN1WlCNVPYaLcO0caRuB7G6w5AXXbckaIosJHExntdHR/Yk6KVROXtwLwtazdwUciqPVg/LwNmoX8WqlZTWDM4ht62LuZlc8SX+Qn1NmJcBAZ0takHhi3hwr0jW4HJGQh+yjbm0+Y+6ypmFpdBdHmbMb+ckH4RMX4akJO62CFlXWJoR5omE29Q16+douwe1Bs75kRtiHAY4di6mNfVFJdrVBk2LrwPQjpZ9LVUgM5Lti7GIslddKeDuGlHrNsE6wWtU4x0xVmyZZGmyF9CmHTbvhUOYhiB7QpzQoidArQSd16wQyn5ECHArpc8hO2xwSXRQPNlp2En7AVWhQs3py7tbqqxsiHEk2IYlrn9EKAk7Sxm+8Cw+hCqd2rO7q2YJiXHcc6DJIS6mapIREvuIl7WM6TwfO4F1WbMZquQdUbaWORlRzgaHToHePssxr45PDcOym5QCmB9R9N7bRO2TYQoZFDdcj7MilQNNDuJNq8VzUlGeR6Tn0uK8zBw5BWIlgCzniXowhOt7O7BkYLyzFDNAty3GYHN/PBwq0IQz2H8EhIXwG6317NvTb7NlHTMTEEma2a6YKxKnJesXcLT8pjP5qeouSZaeHRpdzBto4bCbFAn85gcZCuQjUQ2ERflKa+1Ay9QW0l2JRk/92QXLdG83KViUoa5h7HqBIodsWmJ5c5pbX3U4RFaIkL9Z+s1r5sZzzZHqJUK4LwyDG3tp9HAoMkSND/DnrZsEl42R8Sy4VU1I1UNM53TOE2+t95NN708MaGbVahOwPotqudvs2+Fg+iBQaJuB3HT4Xc9SKazHkBz22SvzmT9ju1YKVwW0U7iAZJazcKcvU0JWHVHQMbdOEYvRRi+2ZZ4n2BH4aLKOjiPwNDUMWqPU8qTiO1jgf0453cfv+SvH3+JxDPTOSNZDbMJjVfD4k2jktmo4PVJQpEbVKkRdkzaWHqtjbed43BNLDT1DvBkEcxdySs7GrAPAJftFLtXt165lJfNEa+XE+IbFQbTcrtL37p0JjAspeQPYzbvKLaPPDwqmE5yYtNS1oblIqN8GRPNJfFcEK/CDdmkgvJUUJ15mns16bRkllaBv9ELrhZjmpcJupSYtcRABwTbs18SBR3HOe8nV5yoDSNZM5EFN3bMT8uHfLY+Y3EzJruUJHN7oKMBoUi5D0LShSdaO3TlMduQ/nmpAgVf7jFbR3LdBC2SdUnP8O1GSZhbSQL9nssc47hGyxAhXLsU5yUnKkD7FZ7SK161M36a3+fFzZT4RhKvbCCxKbpIalA8C8fqVOgGeQXeCa7LEZ/rM0a64qYe8X52HWD1EnoUVADHtRyZwLdaOsNX9oSbVYb7hiTD3x4Hsa7egNsO8xl3eFdg4CMEBnyCsD6Iw3iPGyfkj1Pyc0VxFlIAmzl86lBZixAe5wTldUz9WiJsRCoFkfe4JNQgZB3CYuEcvXCvT2Kao4TtA0n+Tsv753N+/+gpH8ev7zy//iEdq4qzaMsiSVmdJJSVRDiF8AZVTQ4H0+4wLwVtIrARmKgdCHkBau9x3ZQk8EbouXJBcOXH6weU24jRtlMo63D+XgoYpfgkxs4SNu8krD6QbD+uefTODb9/+pwH8ZKxKoMQ7uYBvzg94/pmTL40mFUgQ7Gpxx43xOOKD0+WvDueE8lwrNYLXo5m/ETcp7gakdwozNoEFigHg7r3/i4qxQE+xFeKdRMIgTJZE3nLjR3zaXWfP18/5On1EfpVGAAzGzdwIfgsxmXRG50b4XwothbB8ZqOEEp4guBO3qJW9TCh65M40MYNBXWQDeiF4nI15svxCe/G18OQmsJjETxtj3jeHPOT4iH/6vUT7IuM8Y3HrII26UBr6HeiOn3tS9UeXQqqlWFxnLBOYmLVDvqv53pF7RUzVTCV3QxRpxiwdTGfFe/x4+t72BcZov4rGEHgXJhW64R4fRqk6+nn1x27vjAcSuB1P7OpHtqfbhTjjKQ+jtjeU2yeQP04pACRDnTmx3GOFJ7rcsTLZErBOOTFjUZWcSfX3hURe72JvIS6wc0yqmNDeSYwxxXfm13wMFrwQC/Z+oiti/eGkxRX7XTgvZTCcRQXLLKU+sRQEiGcQhcR6ZVAb/cUoe+IIu6KEF/ZESNRDyHtwmbYW+Og83bEz7f3+GJ5gphHgQ25cEG4uFfpkiGdq48M20eS7fst3/vgFf+9+z/m72Y/Y7IHvFpMYv718Xv8N2fv8Rfz+2zKQOGnpOPRdMV5suGT7IKJKofzdl5yZApuioyLWUY9lqS9SHBVHehu9GtrEz2kBLoQyK3i2c0Rf2Ie00wVJ3rL62bKz9fn/MWrBzTPRkyeC0avuy7RtgxcoloGqbuuNgJhUrX3sYFyby9ydR3AqjqkqEOyi7h8IJuN56Hbsk1H/Jl6yEkUvMwTc90BsAx/Wr7DHy/f5c8uH7D9bMb0U8nkeZe2dEXqvigcUluBi0MaqKvwGdWJZLEYcZkE4tyxrjkzawAiYTlSCx7rxcC98cqOuSzf4YvtCfPrCaMXEvmWptPb7NvhIDyBFSmb4tKONk0KmrHGJhLZBtr7nkxD53dX6oe3UyKg+I6Cynf9uObJ42s+ml2xbuKB+j6SoW3kvOCrwpA/SJCNRLgIs7ZoFyC1OwwGQc1rGohZqmPHyaTgQbziSO34FqeyHIZ+XrWz4eeBzSo8uJO4YptF5A6aTUKbhNxYtC4oRjkfFJEG9ua3e/7cxeTEND4s51EX1va2dTGND6PLmyLu1Jg6fEmvHdF1ilxmqKaK4p4nO9/yg6NX/DB5zrkqOl3IcPxHsuK3k6coHA+TJZtOqLgvihkRVNl7LMaRylE4Sq95MFrx/OyE4l5EtInIGofelp3uhgwdgUFkGFwUSI2jZZiWLeyIP968y0+n94hNS9Vo8kWKeW0YXQnSa4dZW1S+Q2ra1Lwxqer2tDNFN3/SU8GpvGtj3xIM2jfZhBQtNuH4nJYUdsI/q7/Hnx0/5KPZFVo41m3ML+ZnXF1MiZ9GHL3wjJ+3xNdVSK9kIOv1URjf7/Ej+1Os/eTsNo25yMakuiHOljReUXs1YDdur/tX1Qm/uDzDPIuYPHWo+q8g1NprSfn+CfVMB8hqDAgCJ98wpSeJF3Zgx7mNPJONO8hdXSSpJ4Jm5jg+W/MbRxe8k8y51iOqruQ8VlV4cJzkZpKxOjPktUY2amB4Vtt6KHj21iaKZixwxzVPpnMemsWAXDPsFmrruxpGR4N31YwHdu1YtYyTiqrSOOOHXUlue+1IGx6SXmdxTwhHuFCDmFcZl+2U0ps3OBf2rfGK63rMi82MYpGQrQKtni7sruajOtq6RFFPBc2x5cPjBd9PX/JYLbmvNDeupeMzIROWTG1QyVMemTmN16xdwtqmrG1C5TWSkPZkqkThyGRFJoNquUptEKiJAkBKOA8dL4UwCtvxajrTMTNXntgFDhBZS5p5jI1itsojrGC8gfjGkyws0bINo9j9teug7LcHoPoNB0KBvBe9CUS44XreyftR7xVUG4/ZWGQrEVZiNpIiH/HsKOXZ9BhvBRQKs1BMLwWjF11NY16GulndhLqPUYO+R7/GqiPqkbUnah3xQtCmkjzNeK4CmU3rH3ERTRmrihO9pfGapAsTflS8y58vH1K9zDh6DqMX1a4L9yvat8JBtJni5d+Oqe5ZGNcI7XCNDJDgUhFdBxEZ4cBsdiSfsrKoqpN6L5vDPFYK2lGgMJ+lJSNdMdM5mQo3qcKxdgnzZsTEVDyYrJHCs5ATEIELU9YGtdGoouqq4AGX4OJQnc+mJQ/SddBQFGFRek/epxorlw44eYDCGvI2ItM1TaS4chNkG8BBqnGIdT4UwmhtKNLeih5kC34R8fn4hP9Kf8THo0vejQPUeiSrA2SdRXLVTniWH/H88ojkWUT22hMtWmS+cw4+NrjYhMGeY0F8UvDe+IZHZs591RCLFNhFUiMZ+CEfkQ/cE003y/C8OeZZfcJElcSyYSoLJirwcuxDgCFgVGT15u7XT7161YX7hcfXIFuJ2TJwgsjuIRfOY9YBMq+KJuT1ddPVr+TAGQEhWuiFgA82GueRdftW0t7bJqxDudChkW3Y6XUlkY3AXiucUugC4qXDbF1wXPMSWQWNk6CzErQze9q8fdkBr3ddNAj8G8m1wMWalR/zs1ahVOBcjU1LZhpOky3HUY4Snh8v7vPli1NGzxSjVx3nxq84H9Tbt8JB2BTk7y75nbMr7qdBCu+mHrGoU67yEZfjCds4BiFJLxmk7fv5gIP2oxO4xGCT0JsWieU4zjkzG74fvxzCbQhQ2lWbIglqSaO4ZpW22FRjI4HXAcnmtRrqHj6NcCrcuFo5ItneuXuXXY+6n3/orbKaSO4pMxHmAlQdJj2xdmAJIup4IpUMubgUmNwTL8LA1EpP+Knw1FZRjTVjFZzguV6zsBlXzYTrZsTPVvf49OU91LOE0VNPdmExq/8/dX8Wa1u25nlhv9HNbnW7O+fs00XEjbhxL3mzMqvLynJRgIoCgYyxSn5BRpbcIZcfQH7xg7FfsISQeHAjS0hIZRlhHgzmzchCQjKSBZgCqlRkZXO7vDduNKfZZ/erne0Yww9jzLnW2nufuBFZyI4cUmjHWXvttWYz5je+8X3/pkFWzVaERSlcYSgPFc3MczQueZbO455WYoTiSGpMDBKHg/dmRSYaNj5oTzYoRjIcB0ASg0flEtak/Kp+xLzJsBtNsQyFwC3FWeGyZKCVw9bTQXYu6FBU+3WC3eCiYsDrO03C+egyFQPwYHIbiWf2fiTwSkL06AjHJAduCIT6VxBO3nktbgVk69E4koVEzH3skHWYZbs9tqodXMTdKKUbGbpRQMjKejuvg3K3QCYEjo8IXVqvwjGqytDONY30lATUrlfwWWGReUeSdlTXGdlrQ3HmSW/b8N3f0tToOxEg0rzhf/Dp3+UfGf+MA1lx6zLetId81R7x09VTXmcln+lj1hSARFces+m27THvh0mBUjBOoyYDIDyJsjw1t7zUt6y9ZuNSruyYy27MeT3es+K7O3y0ssP7IAq6A0Xre8oXdsqpvo2CrSFz6DsKl13oKmxswnVT4BBo6QYZfrwInp6buGcGBnPZTGPHSVhJ4/cm8w7ZKYRVCKe5ZcqvgMoaxqbmNFvgMsllO+bnq8ecrae8vZxhPssYfwHTL5pQvLtZ7VHIkWHFCtuLjpNizRMz30MAGqE4UopUbIPeTGbMXYX0nluXxtZqdO1CcGu3ZsmX7YTX1QGf3x6hrzXJ0kf18DYUqHXOrn9k8OlwgVq/w/q0veLWnd+JTR0e+jJ6oGTpgEp80F27twOQW2WvLWdjC+eHoIERfBdAS7s3D/qhSodsgxyiaoK2qVrVyIvb8IbEBJnAcRFsI48NbSFoi9CBy24CKNCsu0hItDj0AMUWDnTpMGtFex3+DiGIdWCcBmc07cTQFTC7gfzSkZ+36EX9zcmDO+M7ESCMtHyYXvJSrTiQkolYoXBI4TATy9Nszkm25g+ypyzzKaCwSUpuZFAHXtZD+7G3hmvz0NZMi5aTZM2xXiHxHMgG52UouDnFvM6ZJNXwwOrE0qU+oP+i6YqsOpBJ5GlEclIHVZlwVk15lRxx0U04Uisqn6DopfclNhb1nBeMdYOkV7OSrNoU1wlUGVNl7yHPwkpapDSHGTbbZi96YxGdxyw9uQosU7xmsTngdjZG5x15UTNKP6BqDOtNSjtPMTeK/FyQLixmFWjtwvk97UeXGbpsh525I/fej93AsDtc/M8io97kjNf1Ae/qaThHBIs6Y15mrMuE9iZjdCMi3LmvsWQBW2AiFLvukKvmXsfKFRpbaLo8bjMbhy7t1jBHCCjysGUaZ3TjIKyDYJCOV3U0Od7FW7htYdTmwRyoG0VR4iYULnuOyED5h/3OmgfRRJet2qLWdUjp8wxvNN3JmM3TlPVjxea5pysiDN+DaATrUqDXmvRaUVwYknkXMgob0MGq7HCpwjiPqiTJSkSXsW03xhlBW/Ty+Q69CdJ4orah2Potpe+/GwFCOB6pBUpAIQ1SdFS+Ah2YdR8ll3yQXnFgSv5TPmbVzILQqzOkNx2qlIier6BlNKiBrvDM8prTdI4RoRdfCM818K4NE3jRpHReoh8wZvCSUEXPNLKK243ezqyEbm34anlArloep0suxQTnBYVq9hB1pTUsuhwj7VDhv2jG1Fbj1xqz3uopeikCMExLXCpxiUA2fQAhEIW8j2l5gmwUupJ0VwkuNZRZzkbF91aCYi1IbzzZjSO72rGil2JvsvR7fgAcYdvi3gNDvzPWzvN5N+Or9pgv6hO+LI/45eKEi+WIqkxwrYRSoUqJrAXFUpBdBICS7Fd2GW3poq2eaDrkptoep1b4IqEbh5W3GUWMQOuDOjSghMB3DlTQq2ymhmaqaCYCmwYlKLNxmLUMgSWeb+jmODxbewGbqcHtSjY+8Gj6bS1s9RuiRsiQoeyK1GyiGlZq6I5GrF5kzD+RbD5uOH1+wzSpMcpyW+UsqpSqTNhsDPVRKBaPtCC/iKI8dWCPqqp7kCkqov6IN4pM7ZzXDmvWy29vjfidCBBaWg7UhkIIWm9x8SYcyBojAnFmIksYQ3lq+D1ludGHgMJLjWxTktaGlDzTtBNFMxMwazjKN8xUyURWtF5y6QJL720z46Ie03QqiKzKO9y7SPqyiUR2cvDkcEmwflONR80VV7MRF1kZshOzoXYhGPQBwiK5rMc0TjEzW/u/dZdyW2bISt4rigUXJIkqt61d2fphry5sEHZJbmVMZwPfQbgIyVUi9uhDJVxXLqSmyx7wE9LqYGsXJpNLFS4VoR6ykdxWeWAB5ibM0PeMjW+YO8OPqxf84foZf3T9lLPrKe4iwywE2SZQ8WUbUIt9oTm9tZhNh3AuBN5MY0cm1JSWbagpWQvK4CYZzWFG+diE9vIRNAc9b0OQXRnMUpMsM8wmvN5MJNWRZHPqaY8spBZ5YzAriSoVegNmkwQ/1eiDKrutLLzsfPQC8SHl7/wQnIchZTAjGwKrH3xOBuJaZrCjlMX3AvCs/Y0Nv/X8jN89/ByAyhlWNuW8mnBdF2zahOvDgpWeAAGXk9yGz97Npu7Ol74OJ+p2MO8danPRTuFPMr4TAWK36l75vugULvpIdJENZ3msF3yQX3Mzy1kcF1TLnOQ2+GK6NFidu0RiDbihlSyY25w37SGJsax9wq0t2LiEutMoGWoU/bA2VKFlu62Q94c3ZNw+PDNmJakWKVeTAik8tdM4L0hVN7QzF23GpjM0TnMYpeEnqqKymqbTyE4gnA/ckEQjlx7qAJbSq31U4ZCOR8yC6Byy86RzF6v9/ftCBiGtDxO7jg5OdXT/VpGJmBt8bKvZQTXKo9eS60XB26MZr7tDnuk3HD5w3+au5FUHv1e/5L+cf4+//+4Z6zcT0gtFehWo9WZthzalsD6aBbmQJfQF0th1ckoibbSIcxGXMc1pjnMWHxpWLwT105bieMOjogrbqDJheZShVhK9luhSIiw0M09z0nH0/Jbn0wVTU/GrxRG36zxkNY2CSgZjobUiv1BkV450YQdMhI7dpF4hW7T7dozegLBi4AERa0VD8TMJ0oXNUUJ1JCmfdfzms3f87uHnA+p24XJWNmOsakZ6ivOCeZHx+42irEaYpUTVEhUBkgHMFluhsSW7nSDb+skefP4fYHwnAsTXjVuXsnYpS5dzawtuuoJ1m6KNpR750ArSYj9FJqxYLDRv51N+mp8i8SxcHm6ALZi3oQpvlCXXLVJ4WpvjrUCXYsDhm00XHsSqw6cKVYHTAl1KzFLQ3mquxiOU8GF7oRt6eZjbJue6LoY6hBGOmQ5BwnlB2+4ScwROy5A++uCwpbwPBdI7bc6+px/8Ofo24Lbar1bNTlALe23R9FZ+gYXoldyD8/YBRragN7C+zfjV4pivJkc81zccyYqx3MrHzV3Jm87zB/Vz/j/zT/k7X32A+2LEwa9CWy+76kIBMtKscSFNdqkZjol4rrDl44S2jgwdpHFBe5CxemqYfx+S78/57374cz7Nz5HC8Xl1whebIy6Ox1SdZlWllGWCd4LZdMOfPbrknz7+o0FY5qvZMdfdiJuuoHGa66agsYq36ylnXx1RfG6Yfg7JIgCtQHEPcOPYGko/NPp7peJ2dxyAZ80UxKjjSbbckwLsodEyRnfnBQdmw9XxiM9XCc15QrtUJDeEayO2rc9eLMf3JDTrB0U2AHIDdRuud9sFQNy3LFR+JwKEFo5HsuZEhYr/3JUQMexrl3LrCpY2Z+MCCnJkYsorfXSC2krUCetJ1o7uRtCNFeu84N1swkm6GmC/rVeMVMMsLQPaz0k2VnO9KgZZc7MJqWVPFSbqT9pRimw96cJi07AF2RQZb2rNcpbyeLIazskhBlfxmal4mV2TiY7Lbsy8yWk2CdlSoCuP3tiB+hy8OVtE2yKyFD/K34ukfMgLohe67cVvRGvBhk7F4NXR779jSy14Q4bAlyyguVa8OZjyR7PnvDTXPFJvqPwWLXphBX+vfsl/ufyYv3v2EvtVwfgrwfhNR7Logn1A3e5vn5oWYdQ98ZmeeyC6YNDbbxW9Eiw+SFh8DOmnC/7qi8/4J2d/xEjWnHUHPE4WOC9IpKVxCjcW3NQF1kl+ePCO3x6/4s9lXw5K5ploudWhq3JrC94mB7ROMTY1Tae4qQ8xS4XswKzlwNPwRuKdD8ftPFKF6zp4hNB3XPwe6tZlhurYUJ5IyhcdL5/c8JvjN0F9fUcBrHA1G5dihB0MdkamQRcdXZ7QFqFYLmygqj+41RCCkDbGLVI/l/rrb3TQ6fjTWKSEe4skABd2xLUdxwwiEHQgOBx5D6ILSEubhJ/SRlXmHZMXm2leHRxwmG4G+XUIW4+ZCdLsl+WYy+WI6t2I/I0iv3Rk14EJKDfNgKpzRYbahMq6cJrMRFk1oamPJItaoWNG0g8pPI/TJY+TJYd6zcYlvKkOuFyNEDcGsySwCdctYl1Bb9gD+DY6fEuJn+TD66JPd2PlfRC0iQUpUbUx8+jbtBrp2FtdhN1yD2TZIpxBaImuFbpUJAvB+jrjxwdPODAb1i7hublhIkPA+3H9nL+7/B7/+duPWHx2wOyXITiMvlhB54I6+N3RZzBmixhUZTfgHoT0w7l0uaKZKtYvBN1HJX/xyRv+4uQLnutbli5kMgrPWNfAgtoZpHCcZktaL/nt8Ss+Sc4HTgyAER0TVfJczVn7EKQqb2i94noyYn5cUB8XmFUoDup1C53DjgwuVQGb0Bv29B2f3Qy/bAf3M28CfqUZS6oTGD9Z8Vce/4ofZm+Ga9iPqayYygojLG/a7WZOCI/N/LBdvnvfhsu6IwnYe7WIzU5XB0KL3qiHFdW/ZnxnAgQE0ZOFq6h8hESyFQHZ2AQpPFNdUZqEUV5zned0RTDyBbZiIG0A1SRjSXIjKV+P+EPxlMVRmFh6RzRjUWdcrQrKq5zsQpFfevJLG3QHvyYdE11oIWXXYdXVpaRsBfNxQW46jvINWtigAdClvPGK82bCl+sjfnl9zOptoCQH1uF7NCmNgSzFFdnW6TwCgGQv6Br79X1QvLc+yCDj5tD3Vx7nhww6IE81Xazc6zUkV4q3/hH/4Trn9w5e8CRfDiItX64O+fL6kOb1iOKNpLiwpLfhgUKCm+aDO5qs2kBhF1t+DTDs3b1gy9hUckDHdpmgKzxJ1nGUbMhEw5mdEvzJHCd6QSpbjBhhveSJmQ8YjE+SczLRcm7HHKs1Cs8jtd6qO/kgU3fdjXmazHETwdVhwbvjlOxiFwQV2qKWUMgNgsUMAUJVdqj9+DxuB4Wgm4UuSnkiqE9bPj645ZPsnOdqzkS2NF4Odaq119zagsrvZ1ZKO7qEQXBH2q+RBnSRcbwzQhFaYUfBZKkdK9yvvl0n4zsRIGTMgzosF86zdMmwvXjXzrZMyMhzkMIxSlpu8o52pGhHobugqu0eS1WWZKXIroKsWOnH/HwVqgMysUOP33mBu05JryXFW0927TDzZk9U1Udb9btDdJ50bkmWDmEVXkhWk5RzOWZdJ4N6T2ZCi3VVJ8wXBeJdSnEpyc89+ZUNtmvlFtXIjp29N3pgIrpEBb7AQ9BkKQZxnWGLAeGni6CxO3MrGCC7Ya/cFVF1ywWPUvFO0K4U7e2UX07H/HLSIU04J7s0mGvF5ExQvHPBaWodug92nNMcpKGzYkGXAU8guu2WEHr+TABo9RP/HqfGeEZJSypbKp9w1h4McG0l/FDgnqgqdMIizfpAbWJ2kLB0WXidrdt4H0gOVGD1Pk6WPB/PeTeb0Y36CndEPvpgmNj1kn9SBALZHbsGL4DI+7Cpoi0kzcxjZjVP80Dom8mWiRRcxFtoEWx2amybB0R+ZF/crbuHXbeIwaHthi2Ez1K6aUY7NZTHmvpQUB9A97cf/PP3ju9GgBCe1sPSNZzFbcXCZrzrZly1oz1psZVNWXeBWqwTSzfytCNJOwq4iN6PMcjERfetJnQc2lEaoKoR3wCAA7MKD0R+5Uhv28DgbO2A5cfo+0QfF7oDAww2lwErf6ZoqoJ5ErcEgmBW4kEvFekiKColC09+2ZHe1Kibzb6d+64XqNG4RA2V6281vN/iDHZf7rUMlMClJoLLIjTdg64jMKvyJAtBdxu3a6mKvAMQXehSpHNLetOi1214cMYZ5WlGeaTosgAoShYSUwb+h2ocqgnBVTY2StDFS2Xd4DC2O6wXoRXYTgF4bBaMZM11N2Zu8wE6D+GBn4o6qEsTspmRaMiE5crlXD8g8pqJBhiRSIvUbi+lv3ftdAwQCu5ZTOwYBjstYu3AM8paUhXuw8YrnLP0E9B5wZUdc2XHrGwWFL+6sJBZG7tpLRF81Q3SecOIRdMeEerTYDxkxwnzjzLWzwTlqUM/3nB6tODNv/v1TOi749cGCCHEvwX8s8C59/7PxNeOgP878BHwOfDPee9vhBAC+D8B/wywAf7H3vu/900OxCLY+CDRXjnD0oUHbLduAFBEkdJpWrEYpdwUKV0uaQs59MCH4YIPg9lAsgxiKw8ZA4Red1CaDoY3dltpjz4ZQOgv990jF2F14YLEz/C427Dl6EfwvgzptFnH71l7zLLDrFrUotpCniGg7vKtTL7LtupSwvnBS+LeOcSH6+7YNf8dXqv8FlqsBF0elJnDAW/l+8IxO3Ql8cJv+RFNSHX1OmzFVG84lBq6kaGexKzOgOzCT9ejyHtcR2Pvmev21yvUjnr77pCBpbIbqv9ZJMZVXlM9AOYqZMdEeDbeIr0fRFv6udWPHgZeecN1N6JxCmMsLg2MXdmYIVtzidoiTX0Ing/RGrySOBMAbl0u8Mpjo4rTxqWc2TGZaLHIYVvxqjlmabMt0zdiaLyT6FoEqQPrQmDwwZcViAVRH7oTgE8MdpIFt/cTzfxTsN8r+eT0kt88eMun+Tu+Muv7B/0145tkEP828G8A/87Oa/8y8B977/91IcS/HP/9vwL+28Cn8b+/DPyb8eevHa2XUehzewONsPfgvgHUZHmUrlgXCbf5CFso/ANRX9UO6h0c/nsKNKK7j+kPX7bPpOz/vxe+HYRwfSDZeAV9sqMax12KvmyDObBeNQPSbs9SLw/AJVc8kGZWcXvV2gc9QoC9bdG9c9wRPfFFutXdZD+jkjYiB+MIUN/4uy7UeFRlAw1+XQ38F5/qIE9fqOHzAkDKB2xF321xfdfk4b20S9TW3k+EgJEoy2my4JkJoDkp3KB9oWIBQO4gYQN7VjATYJ0dNCz6sXDBROiyG2O95LYtKK1h3uRhCkhPV0jMSgxFnYHbQ+wYdRHPUdutwA/b99okcDdULajKwMN5185Yu23wf9scDN8thedRshwg7q1VdLUiK8M96T9XyLB9ER5Us794eiHocsXmkWb1UsCnK/6ZT37CXxh/wT+UvKWQLf+mfD/o7aHxawOE9/4/EUJ8dOflvwH8tfj//1fg/00IEH8D+He89x74L4QQB0KIp977t1//JaFjYRG4eEeO1WpPbGV3HJk171ywme8nkU2hy+WAQZB1R38t5K8RmLlf2WMwu3lY6k7s8RiGj+k8srP0ztiDv6X1Q+Gtb/2JWGy89zmRGXhXTUp4H17febCEB+88ol/Kdhbk4CkqsZmKIJ+w3+9bqcJ7vPOxuAV6J/uSnd/SjkUIEjYNBVJ8D6oyqB4tqIOzmY8PdkBLhsCgWjBrG9q46/fch91zHcA+BK3H3HGQlTwx82CME8dZN+OJng9ZxbFa8czccCxLft1wXnDZjXlTHQRcTJshhSdVHXnaskqDFolNJSrqQewuFMKCXrX7GdDQUQoFV6eI11vQXSf8cnbCzJR8vzgnEx2tV5TWcF6HLc8kysc5L3hXT3g9n6GuDWYVsjWb6cDFyO6vcl4KfJHSzXLWzxLmn4D/dMU/+uFn/NnRVxypVSAR2oTuW9p7/0lrEE92Hvoz4En8/+fAVzvvexVfuxcghBB/E/ibAI+faRqvHtwfPjTquxrjhEk5pMZ7TlyE1tP7EGVC7DlH49z2/6W8Fxz6sevWFF4ggIFaF3QdogGu3DQh42h2Hg4hApDG6G2nxEexXSmGPvvdIZt9JJ+o27CoxfahN3Lgi7QTQzuSoQ7gQl0hOErpAUwlWoeUFlWHVung5m19eJhl+OxuZAJVWjCoU4fWZHyYtcCarT5osg7nrlcW1Qbi0p6t/R2fE1sEJe/dc7Np4E+QBEp97/Ww27ZMhOVUz1HCcaRW94JD6z39st9nEWE7MeamLXhbhkVGC0umOirhETFjHfw87vbffSiAqyiSPGSRrQvUfCPp8vBduvSYVQDxXR+M+Dw/5jRdgKq4bCfctgWN1YxNjRSejUs4rya8Wh2wvs7Jb+WwLRXO47UMHqPR2mEYKhj41EeGzRNB86zhr7z8in949gs+Sc5Z+2RwfH+YyfH+8Q9cpPTeeyHuws2+0d/9LeBvAXz6W7m/2+LZ/bfzYi8oXLcjWqdobe91EZySVBMunGjvtw3fJxsGBIn53rn7PSn6vb9R4p5OgFlF1OXd1E8JiN/vI7Xa5iaKluxoGOxM/nvHb1QQ0r0T/IChpRZqMYGyXR9BO3G4zCNagV5LzEKQLBTp3JPe6L0sJxzLTj/dueg41qC9D62yNOgWQF9LiP8WYk+MRa8tKjIaZd3tuZAFWPU2kIUVN1r0WXdfrKWVXFcj3rYHwbn6jqhiJhsO5IaDndR5qGd5wdIZLIILOxkQrRBqW4+yFUc7e/LGBXUxAJswIHR3h7D7nBgIRcOgGyKjApZHVz1UP3Rt2quUr/IDjrPHHCUb1jYhkR3H6ZpUddRW84vlIz67PA54nLeK4q0nv+62DnC7i0PEwvio+t5OUzYnivVLy8sXV/z52ZdMVMnaJ8N2rPJmKzPwDcefNEC867cOQoinwHl8/TXwcud9L+JrXzuCCUj64O9WNqAnuztFhk1nqDqNb3ruhIsw3Z3VqQtUWS+/+UXxRn2jINE/VEPLrgmFpB51OThLJfuXuF+ZBlWsxobCo9F47YeV9KEAgdtOzv41lxnWpynVkaA+EDSHnu64YXK85nS0YZLU1J3m7XLCapFTXick15JkGTEYm+hrsX5P/SKu9j4KqUIIDoFTYfFaR2wGO7+LdREXzscLsXUNi8HYpX1XZHv97t8MkBvJxXLET4pTWqc4NGtmapspWOSQVagHqoYNKnhm2Hzv9VR2PE6Xg+hr7QxvqxlVZYbOwd3R12B68Rriiu6VHIqTQcxoV9QGhJPYVFKZEX9fPGOS14yShlR1aOlorGLTJpzPxzQXBflrRXbpKa4syXWweXyo2AyhI+WNoj4MrUx53PDB5IYn0UV8ty1cOTNs4b/p+JMGiP8A+B8B/3r8+f/Yef1fEkL8e4Ti5PzX1h9gL7L3IxMtN92I82qy9/rEVIMik/MCGomq9yHzXktwaiDNCOehbIY20DD6FhEg2m8WRHqRGq9lxMaH14dCJwwaiF837krcey2H6vTAnXjge3vCkDcKWyS0Ux3k95953POSpydzno3n/MbkjKfmdkhdXx8e8raaDYSl5TplfZ5QvJWMX28f0N0CrE80LhPYwoTgIEMA0OtuyH7Uug04jYfasLHt5wuD8LEDJEWojexkIw9enybUMNIbSZmM+QP3jKvDEU/yJY+zJYdRsUoJxxeccKRXPNLLr73md4cRlkI2jGTNu3ZGZTVdZcg3QcDHrLs9zw65Kxkfz03c7cR4UL2GQ7yeupQIp9GlolxOeXfYIUcdJunwXtCWBl8p1FqSXUuyq9ByT267YAfh77d+Ic4Zo+hGhmYi6UaQ5Q0HpkQJz5UdM+8KjnSA//eZxLcZ36TN+e8SCpInQohXwL9CCAz/vhDiXwC+AP65+Pb/kNDi/AWhzfk/+SYH0XrFRTcd9Av7MVMlE1PRxO3Frr+C85JNnaBKid4EcYxeUsxrGbgHSWj9yE0Vbph1cYL2uucMuoBD268/b3t/FQ8fvi0IDiIid38HWy9Lvw0Ge9J4D4z+AdrtfuxtfwY/y/C7rlCUR5rqxONflvzGs3f8cPKO03TOM3M7gIgUjpkuSYvgpdAdKN6WU74cH7IsRthEY03CJPptyk30qRAhOPgowS4sgxvX4G0KYC2qZqAZ31VjujtcxF304y50GGKhcwN2Gc6g7kZ8tkj5Mj8ij7aGu+NJseRZvuBRsuRIrylkfU//EsLCc2KWbFzCTTcCAlBv4xKuqxHi1qDL0N5Vm27QfZCbZstj2T2X7IHz7AvQ9HiZwBKVXWBmtjcmMGkFSA9ZF7bIehNcx5O1I1la9KoJC5jRg97q3blqcx1d7gkFYuFZ24SLLiysDvEnCgz9+CZdjH/+Pb/6Jx54rwf+xW97EEGFaEomWzYqCT6GwgZFKeHo8IH4pCuk8FzWY87WE9ZXBdlChgu7suhNiyzbAEtOoxLTThEwIM3EIPPuixSfyIC171dBH4hTQjqk33IDBi2Afvuys2DuYuGHazGk1n4o0PWtxt2tCRC2Fya0rvaS5DvFPK8EJHrHPFbQTATNo47feHrOXzr8gu9n7+7ZwSvhkHhOzJIXyTUA1cTw2eQRf694yev8EC9TdGUoOodclYiqxkeOhI3BQa/agF+ILeGh+LtLLZYSNzJDuh2Qk+HXurTb4m48UVUH8lHfxu2DoaocWkF2LcMDu5J0eUJXGDZZxirdrdcI3hwe8vnxio8OrjnNlzxJFrxIrocgsWVLSqayDNYH8SAqn/CrzTFvb6Yk15Ls0pNeVuG+9pySNNkyU+O5Brf17dZ3V9Zu4MdUdjhfVW6VqQOILNDge+2JoAwVQXXrdptF1k0Awo6yPTPph0bTaK7qEefpFCMtqej2zv3bju8EkrJ1iut2xIHeDDet93Y4TedsbMKiy7ltC26anLfrKe/eHpC+1WRXBAu5qOMHDD/3xD2EwBcZPk9Caj5LaCaBTFMfBvdkCCIrZhn35kuHKi2qdqGo+J7ePTBkFPeMhneqzWF7o2FTD23U4X3WQ9kGiq739+XWd4Y3CpdqyhPN5plnerrkN6Zn/NniS47UiotuuocuzETLEzMPRCUdsASt10xkCLjjpOZn/im6TJA2RTaj8DDEiajLYFocVrS4jZISNynoZoG45GUIJF6GFqHTQVJOlyHg9s7oLtdgA3qy19rsM467RUppg0mwWYfP7PKtDuPAf4h4ifYmZX5j+L2jMYfHS753cM1mnPCD7IyRrHmslnudsgO1ofUa5yVfNgd8Nj+huco4vAgIV7VudhS/t0xhr0IQ7LU03F0hlth2D/d+2/URPmZfddDwMCuiBF7Et/QEvN1uWj/SJGRxkUFq0600/naegWygLg11F473RK/2MqldfdBvOr4bAcIqzqtxaGsBmWxZ2iAXP1YVNhJb3lUTzlYTrq7HmHeG/EwEKbXrHTQf3MOreykCZLlIqE9yykdh394ceNqJh1mDzlqck2xWJpiqLiTpjSS/kiQLR7Js8dY/iP4bRu8vQawyC3HHZDiOHeyDH97fBtniHipuAv/Ca4nTIjBVGzeYy9hc08wEzXHH96YLPs4vgmzfTg4ihRsUt42wTGQ5VPstDSTnZLLlUG+4rXKuLh6RzCXJbYLp99BRK1NFlyk6C4nBTlPaiWHzxNBMAlrSpgzqysJCfilDYJhHKfqmG9p1ELdhfeHT+wFl2Vso6nX/8Hj0RmLzCF4iIhkJ3+eMoFkJzEJSL1NulprNacrmJIED+EF2RuUNRnQUsh48PCqvmXcFn61PeHc9JTvTjM4s2WWFKOswb3Zh753FZyku0XQjHdTFIk9CdH4LwzYhY9ClHcx5VBVIhMJGsZzIl9ndxoqywafJPi5HBUk7r0K2susMpioXAocSMQsR+EaybhNSGZirR2qFQ1I5QybbYQH+puM7ESA6K3m9mqGlY6r3qbDOS266glebA355eczmsiB9p8nfCfLrKF22aALF2ehQSLP+npW9nWSUz3JuP9asvmcZv7zhk9mc58WcXDUYYVl0OesuYdMl/OrmiPm7Mc1XhtHr0CVRjRse4HtDMmj+ic7tgYLuZh5DoTS2+4AQDPZQmxJbaJqJoh1JkqUjvWmRdXhvlyu6AuSk5SjdMJFlFKLZzi6FZxqpxbcurB5LlzCRDQo/GMuSwbPxc94dHdJODDYLxrqitZg+8HaxOJom2FnG+llKdSRZfg/aoxaMQ6UB+eq9oNtoICGdi602Yt3fk1BXEZ1HdXdcvQG83+tq9NsxrwTG+UEevv+dS8LePl0IVC3QG0XZjfhFF6/FQfhxam6ZyoqFy6ic4aye8cvVIz67OUJ8mTP+ypNdNshFGXArebpXbPZpUBmvDw1tEbIlXXlU5dHWDkQum4hBjUy2fbBr90h2clPvZ7jxvEUTMrd+jvRAPR8p8l4R8DZRNWwgj/WOYS7A5oL/S81UVqx9IA4eiA1GfL3/693xnQgQWMnFzQQZVZlKm3CcrJh3OefVhF8tjri4nsLblFFkQSZLG1SLllGvQatt5O1rBVpFLoNk8f0Riw8lm08bfvjRW37n6Eu+l16QxX7W2gUyUCqD4eoHo2N+L3/BV+IE1RiyW4Vs92+oaO1+FTu28fbeczebSXYARrs4KyUGOjEC2rFm/SSY2HQFJLeKsYZcAB66IrhKZ3ngpoweMF20iMHM1yIoROiFTwjvVXgy0ZKJlkfZCjNusNH2EALkXHR2QOq5zNAcZZTHivVzyeaZI32x4uXBYlDlknjmTcbFckz7zgyErXAQFoSJDlIR+xBh17JstyzUUToUO/ssw0YtUNGGuoXaobtLK5FtwFR4aSI0WVJ1Bb/gEZs24fYg5/vFOTMV6g9f1sf88eoxn98csno1ZfpaUFzETFQHl7Hd7KG/b22kxHcx25XtnfaqDx2YIKtnh4KlvKtnqVWs40QR4dSE74znNPAtYht1f1KFQu9dEJewoJaK6+WIP1g+x40lt3pEJhoe6yWZ+FOaQYgO3HXKO6ZUreYqH3GcjbmpC17fzCgvCrIzTfE26C/ml4E9KGPairgPaCHSn+04oZkY5h9L2h9t+CsffsFfPfwFfyn/jKXLBoTZtuLveWICpLc7UiyrlOX8kOJtUFraE+e4w29AiHvu0ff0XoV4rzpUvyfvCsXmRLH4GNqTFpl3tGcZslUBFVk5rAnptZRBLFcJdw9L0nrNq3ZG6xVPzQ23hCzCiG4PWBRec1GwJR5mEyXKyiq4fhtFfZKxeqpZvxBUL1qePL/h+weXfJBfD59z2xVoaVk3CbeROet3ipi2SOgKHYxpa4e5bbe8lJilSCGwoySwTHWQn7eJCC7X652U/AHviAzQlUJvQlZRtgVfVJp5mfF6dsCjbEWuWl5tDkJweD1l/Jli/NaS3DbbOoO642gW79tW1Pbuzdt2Y2QbtoL9tnfg9sRiNMSCs9tB40beT8/DGaT1uztdE73tAA3u7IRMxqwgvRaUWcHfUy+5PBzzNF/wSXGBQ3Kq598yPHxHAoTsID1X2FXObZZxnTk+kx5RBSHS8bUgu/Tk13YrZ9b3p50PkbQH6jiHqJoIY4a20Cw+0JQvQqX/d2Zf8GlyxtJlnHUHQzvo7jDC8iRZ8GSy5PZ4THWUkN0qdBbs6kV5R7FHSrpZSnWc0IwkPfDTlDlmFbwbZP0ATBa2k8SDwON1LPQZD9IjlMdrTzcS1NOgYN3lAoSnKhMumjFn7QxpAonpTXuIHSDGasebQyKFo/KGKyf3oMkOgXcCFSX2B4FW7/HjnOq0YP6RYfXSoz9Z8sPja34wPefQbPZwLBI/EI66wgXZ+aOERBBAviKkx77bitUEPojHa4UfZbRHOeVJkGoLWh9BrVs1kF0oklXwatXrAHne3cIJH1ZSaQPUObsSyC5heZnw42KGzy0mb2lLg7rW5FcBdxBs++xeG/mhIbwP9aAygrPqXSRqG+DrsZDbzxGvJG6a001S2rEOIkdfg3gWcQthVg6zbO85gO1mnl0eMqeQuQQ90eRasfFjfnKd84vRI/5odspBVnKUbrjqzt7/xQ+M70SAEB2M3gazmrCX2mLZQ0/akt52IWvYNMhVtU27pAyISR9vinVhRWo7XJGGguSLbaX/R9lrprLidXfIdTfmsg0BQgkX2aOO624cClqq5nG+5FejY7pRQjuSZBDwFL17U5Hj85T2MKN8lLB6JmmmYIvYrtpI0usIgLkWmFUXvD731JHDHlNVXVhtpzpMQgu2k7hGhTaXIhQDfY9oFHRrw+v1AV9mxxFV6Paow8BAaDLCooRj6XIkjgRLg2LtEt5sZrQbQ27DCkjTQlWDUnSTlHqmKB+Df1nx55+94uPRJU/MIsi1RTwBBAuDwEaU+MxRHyiqA4WwCbLsBrMb4aLVYE/4Mho3yWhnKeunhvUzyeapw+VRsl473DqI2qRXEncFqQyrrIpaFEM7sXY4IzCrsAVI5uGh64pA2bZZQtIFt/Ds2pHedsFtrIqt6F0+zs7wUiBrt/fQyNoF1e4qdD5EWYdrZ0NHwk9HuCJh82LE5nE0Rh6BzT3cTSQjn8isRTg2LbZtd+cHP9IBteo8IooBCecxsaQkW0EyV8EfJjecTzPepQ6UZ1VmfJvx3QgQDtJbh4ymqtseuUeXAawiGzu0nryMluy9KGtPBHIgNlXoxU8Lyucj1s8E3YuKH56c88PijEy00R5vn5uRio4jvcIIy8alHKigPv1BfsMvZyecz0ahxXZnuCKjfDlh+VKzegnNs4bioKRIWqrGUG0SquuU+lzilQ6971U9SIQ9hLiUjSdZeLILiWwUXirMUpBdB80J1fgo1BuMXL8ojjHSspjkPEtvKVQ97IsLWWNERxK7GImwFLLGecnCZbzpDvmD9Qt+dXMU2IPr0KkRzof2mla0Y011KGmOLbNxiY78441L7qFgx6pmZkpOig3NI82qG6PLMM30ygQcRbtTwG1tUGCa5ZRPc5YvNItPHeLxhqPphlR3WC9oOkWZJ1RFQnNsqK8k2aUmv5Tk50FNrG9veyloY6tVVx7ZBcu6UNBjqPrrjQu+IRE/I6y/j7TduUfBO0Tu/V5275GBSxN8YmhOJyw+SLn5TRAvN8wmJd+f3nCaL8lj4G69ovOK2ybnV4sj3l3MKC8T6gtJPjKkC0WysHgtBq8O6EljEeNgeoXz4DLu10SPlCCP55VCWLgo/3/DxfhvdAjnQ6uyCmnegCi8izxs2j1uhZdBAFUoH7nxwazVJ5rmOGf5UlGeOr737JK/dPA5H5kLgEGMZqJKqogyK2TDqZmTiZbKm1C8iwXMn48f82Z2QjPTdOMEuWmjk5eiO8goH2kWH4P4aM1vPT3nRXGLFpbrZsSXy0Mu8xGlKVCtxguDsAVq06HnD1OTVe1IlgJ7KTBLCJRrT7JyyMYP+20vdZC5y1I+N0eBwDaV/LB4h4rZ0IDD90GEx4iOxgfdjS+aR/zh+hm/f/WMxdmE8bkYxHoD18CEcxxJugJ8ZinShsZpFl1Gac2e2lc/xqrmOFuzahPWoyzUHEzgn6j6DpGuafHFiHaasD5VrF96Zh/f8GI2J4uf3VjNdVVglCNPGzZ5SlUk0YNS4qUhWaqgiRlHr9+gq4BkfAituev9GUhPcg+YhvVgA3XeGYVNZNB5iHNWly5wae5uGQGvFfZoxPx7KfNPYfobV/zTL37KJ9k5nyTnPNNLirjHaj20CK5txn80/i3+s+QTvkgOKVURtq4jRZdJ0qVFty6qf4c6h4hgPqkDm7bX39ilLvUcmoA2/lNZpHSY6ypUqZtws9DyvjryA0ClvS6CBK81zVHO6nnC6kPIXi75c4ev+DC55EBtuLZjGq9IhAUsT6LGwFRVESdQYkQw171yBYWp+Y3JGX9w/IxmMqGdKpKrSGDKUtqZoToWdE9q/vLLV/y1w58xURUX3YSxqtl0oRp9CaxEQZeH9l9xIWM9It5o6wOBS4Z0Vdpw83vXZ2mjXb3dCtYKmyFbHYqaacFrINctx2ZNKjuMsGSiRQnHu3bGG384XKqNS/i92xf88uKE+qxg9Eox+cqRXbWDh0aPHWkLic1AaE/TaW6qqC4uHCfpivGdSmyuWh5nS95upvhOIveJquHYWxu2hs7jjKKdBLJR+6TmRyfvGOmam+Y+sMcoxzivydOGZqZZ5yOE1YPEYJ9+y/hw683WPbwnxw3H0M8nIXCF2eOTqKoDDU5quvGWixIMcgX6TmyXZRu2F2UQ0fHFhOpRxvIjMD9Y8Fef/op/bPIz/mxyxUwmpGKfPAbwobZcuc+4ake0VvHaScokobtRUbldUdQeU9vBq6U/B5sb1IBd0XgZwVn1FoglV83e+X+T8d0IEJ4hU/AyKPG4REGigjZCTPtk3eF30jlhLbIVe0asXgShj2YiaA9bvn90w8vsmuf6htM4ke/2glsf9CiCEpELqsnCc6oCyWWmSpRy2Jie2iJBlNGQNZe0I0hHDc+zW07NnFM1p3KGGzlCS4dRlixpsUcVdZdTzRXSKnSptzRe75E71vZeBRPbftKqsotgIjdcKx2xFvmFxEtF1Y34SaO53Iw4yEq0dDzKgmnxRT2mscFm0DrJ5abg+nyKOTeMrgT5RWgd7wneEtuvKvicpqOGg7xkZGqcD54fd4NDPxSOVHUI5Qc9isHEZ1OHPXWW4FJJc5hQHkvKU8eTJ3M+Kq5QwjFv8wfpyUo6lIy8g9TidHggQmbZG/qGtqjsdTl6KLfaOlOFFwK8uxuFLEdVgRXce3U4I2lHQbGsX329iFuLHutQtmEO9rWLxNAeFSyfK+pHlt88vubT/JyX+pYTlWPEwxXKlQuCu7lqGSc141HFWjraNKGbKdpJsHEYvRNkF02g5MeW/i4vaBfyvYfBUfvQ/W8yvhMBYjA6jbDWQPqJvPxxGhSMAKXltqds/Z6Wo9jUwd3bgM1DoTA9rHiSLznVcx6pkkIITlXNaCdAWARvuhkbl7JxKY1XPN8xNXlwCCLvIEzKrvCMsyboJooaixhUk4GgVmQ68qTlbWkGJe52rANYqOmCqvVOtdpHXIfcwfrLTbPlPkSFKbXpKM6Dga9ZSerbnPOjhHeFReWWXyYdtpO0pUFohxAet9GYG834OhTD0ltHsrKkV/V2Py22MOguF9jMMcvD1gHgKNns9dRLa/bMflsvo+KXD9RpHyauXNehy5TFGtI4oR0rqmMBxxXPxnOeJrfMuwIZOTiV1cgo5rKpE4r0Ac8NAnIRHx6KZB7ucW/xJ6suCLpwh8sgoCv0IPIiQ3MICItBl8u9dF14MBE+rjdB4BjvkZtq4KL4IqM6NlSPBOlxyW/O3vLD9A0z+f7Ve+Uq3lk3tN2l8GRJG871IDCXz7JDEAZVK5Jbia7aoc0uhQh6IbUN9oVEVbGIqwlz6k8pF6M3ku2BRs7ILWgI7rEmB4ejRg6r7+5wvXL1NxhtLNbd2iLAcFFb7wSC9d/SZjh3J/JKEZyTDgTtoWWWh9V06XI2PmhYGGF5nIYsZKQbCt2wqlLWBwlmI6gOVGjVve/g7m6bxVZpSsaJL7zDrDu8Cpb1wgckYZepAKhJQjekKLeMv74dptc+8Fg2LmpPbsltfaC+y8rMVctINRz0JXPC5M1Vu1ePaL1inaYkeYtNs1Bptz50gGDYvthcR/VnSPOWwyQgQmd6w0m6orShmJypLojKSkeqO1wsXN51gun35q7nsfQPe++85u/wY6SI2hYxG7A7TMz4+p5G53qry9mrn7OzVfHTEc3jEZtHkvJ5x599cs5v5G94rhc8Uul7s4fdoXAcJJtB6UrvBJaz7ohqbshuNHqeRqOk0BULsO/d7C8qi42jS3kH9hd/Cn0x+uEjWCTw7Ldai8L2HITtZHBJ0FyQzcOmM0jQ2pGrluJrhDpvXc7S5lTeIL3n1o4YiSa6gStuXcFFM6FpNEkXVYJiIAsqSwKMY2QajOxCgZNQ4JypksqEB7q0JmgeJi3L1NGOFGmEyfaoT7/bWtO9N4O/RzHuR0+ckiYY93gpUG2s1OugjygixiBM/P5Ce3QVIcClRa8iWKm/jkLEArAMnhU7StcAI10PrdOVTWm9YizrUPOIhd25zZHCoZQbVjBRt4P+xu6wCdjEM07aAPrCoYTjNFlw1kzpvByc0ecmw3nBpkuGy+KS0P51WqDKyPvYpd73dHkf5pLaydSciQjc/hmP3JPeIV3V+1E6GDOFYDqAmawLuBvATtJgt3cqmJwu+WR8wTN9wxPlSMV7/DzjqGKqEgyi6iHoHuoAhGucZn6cUx9omokkyzQSEG1EZfb1OxVsEpoDQ3Wo2DwO5lK6DNfq24zvVIAQzgUV6jvGMMIGlaZB2ktsFZkA1EPy6QoS3TFSgc1mvWDpHO1O83npEpYuJ5Phge7RlAuXsYj2bhuXsrYJrg20Y72OKlWJDhXtHggnPBMZCp09QapXMJ7q0Bpcttmwp5Yx2HjJFp69F/0VrjCDKMmwf++vzW7W5MM1czpkEMOK50FXdihU7b5/IJ05h9w0gxQeMEjCBYXp/kER1J2ijQifYqf20HrFRFXM1IZTcwvAZ/UTfmJPqcqEouUeTL0fsnEDKlHJYKXXt2WfJTfx+lWcmAAVvuwmzLucd/WE1inmeU47NrRF4GT4SNkXtYXIb/FGDpqbu4FO1DbMNSUg04Nk3PtGL9U/eFMoFYJPfDhdZqgPU8ojSTNzvJisOE3nnOol2a/JHDbectYdsHA5pTVMdYmRQdDmUK9ROM7TCSeTNa8ORlSHimJiMN7jrd6/b9EIaf1YszkVbD5tUKnFXabYP60BIqS3NjAa747++b9z77wMWH18DBISXBZWdafChFx0Gbd2NDy0ACPRYiKisPGKR2pB5c0AVa684UBuaFGsXYr1Am+DJkJw1JbhWHf2sssmZW4LMtkykdWAZFTCcaRL5jbnTTljUyfIOorclEELwCuBiPoC/We62LbyQgwB0Kdmf6XfvRZCRHPXraK2rG2UtHuAoBMFeYX1obD2NVsy1QQ1pboOmoYTVaHwzNSaiawCv0OWHOsVI9FgEUjhuKpG0Qw52AsG0ROJz1TYvkQdR2HD6r6uEs7qKR8kVySxA/MiuUIJz7FaIXEcqA1vZOjGNE5zno9ZFhnNLMDT+/kyZJ1wP0DGMbTQvQxaHIJ4zePvPQNpbNfHY1dirv98IQXdOKEbSdqxwBUdx9maQgbTHr5GLLb2LWdW8aY75G1zQO0MU13xxMwpZM2xXmGwtIXiuhnx+vCA+jCnHStko7fwfy1px4ZuFFy9qkeC6oljcrQm1ZbLUgWFmm8xvhsBwrkAcOospGbgvw9DbtGGwKB5OAjHRvVhl4Z2V98Dr1vNRTXmD8sXXCVjDlQosB3IzZAKKzyJsLQoFi5nJOuAMtxhRm66BJrw/4FbsA+CE7XidpPz8/UTGMFahUDT/70RFoln1aZUZTKoB2XXbWT5RRk7qXaw+feFQXysMdwbgqHNR1ypZWVR61h0vGOkO0j6K4FXGvlAHacfqgqrrmyg7VSoAwjLkV6h4nUaEbtD0druopty2U64WI1IrhT5lQ2Q4WhsS2LoxslA2BIeVCWoVim/WDziWTrn+9k7jOj4yNxwIKsB+JXJYDpz2Y6DQ3teschHdPGBQKgAkNpshXMfJEvdvbYCbLJfkPR9yzQGh0GMaCd4A7hMIeuA1GwjiU4W3SCNeGFzDBuMaO9tM1pveWdrzrpD/mjznLVNWXUJp+k81LD0klO1GPxhltOMH0+fsBxltIUgud1hAAuwuaI8UrRjQX3k8YcNqf52rc3d8d0IEDAUG4Xz2Dyo9PYeiaHS74ZKuLAuKDX1D4v3ezLxvX5AVQYZsVfpIa1XbExCIRuclxyxGkxXdof1AoXkyo4H/MBVNULcIc2INojUpDea7I3ithjxy/yEk3Q1OCOFz5O8bWa8rWd8dXuAu07QmyimsmyGqj4w7GuBKIi6M1t7cJiWOBMDULY1k3WpHK6TrKImoiME37gV6415gjv19tYrKQZ0Z3hh53pkYcLb3JOkLZnqONRrjOh4rJZ7hjXOSyyCr9oj/uvblyzPJkwWYJZd4K9Yh9cKlwa37MHE13nSa0FzYHg3nfBuNuXD9JLn+mGfC4VDCs9JumI9Trg9yljpnHWeUB8KyluF3qgo3xY4DemVCNuDPhgneqh32Sy0OL2+E3xlyCgCeC+0t+8WbXugUu9Qvv1F+PFIL3ikSh4p/WANwuFYupA99MrtR8mGx2bBqbnlVC1IheVYeRQLLsxtCIra31tAhuvTeHwFqhR0twlXfoJvJOmZ/sbaq/347gSIvlCXpzRHGaunhnYk8DpUjpNV6NPLVgb5N8IKKGGbNcTRM9vK64SzZIKSjnmbcZsWPEtvUcYNYCmzsylVBEbkhgBRXrqcn66fcL4Yo1YS2W6LfhBwGdmtxSaKbpLwtpjyy/yErtjm67UL5iifz49YXYzILoNicXbdbcE1g7uWRPQ33SrkjqqQK5ItgtQEJSObyb1JKWzYVqhN0IuUm1DYGwqhMIjN9A/nbm2gB6UJp4PPRWQOOiOwWcCG5CrUao7VCinc8ABbBNe24Kv2mL+/eMlPzp6QniuKdw6zaoMJbtMGK8P42cP9Kj3COuoDyXpa8OXRIU+SEw7UhslO9rA7+vs20TVPJ0sulaUsEurSsD7WiFoG0Z9rSXYlEC4hmbeo1m47NVLQjc2g0NS3SMMFj18UcQY2V1t1qF1sXm33Om7fZljvuLA1V27M0uaUNmGqS56ntzw315yqBUY4DqRDIphJy4Fa431ggt5FcIpYVDWbwNnIrgSylbjrFFVBdu15APj6teM7EyB8YnDjlPWHY24+Vay/10FqwQrUrSa7lOTvBFkqybwfKtKwfWAAehdrVXuSW0ldpFwkI+pO01hNrpohc3hi5kjhBu+AXZHTs27GZ+Uj/ujylM27EeNrQXrr0Ks2svYCzVhvLGYTJuPmOuOP00csmwwhPK1T3JYZ82WBu0rJzxSjN57ReYdZRHWm2DcPNQH9tbUAm+lhlbuL/5d1yGjkbtutHz2+5D0ydv1evfcO8UmAlNeHmnomqY+hO+iYmIfFRvrg8MvmMX+wecGPL59gXxXMXkN+EQKhT4I5jptkQQi315yI/p+qEaQ3knai+ezwGCk8r6pDfnv8arDcM6Ib7t3T5HZPVm+WBp2HVZuybFKsk6zrhNUyY3Oe0HxpGL+RFG+CoXFfyOsKie3p061HRIV0vY56EyoA71xfkPZx2+Xew8GIw1tB4/R77Rx2RyZaPk7fIUWosZzqWw5kGWsX0BJMgJYu1MTWTcxCN1GlaqcmpVchk0wWoFpNeiMGuTuzcXst228yvhsBQkrq5zM2p4bbTyX1JxW/+cFbEtkFTYjxjE2W41RkqCUZySrYuYnujgAsRCVhSG4FNjUsxYiqSLBeME3KYWJZL3li5vfEPBcu56vqiJ/MT7m+mJK/1WQXQW14KPq1XRAZbhxm48iuwn5+2U1ZjEZIY3G1QpRBvq64EhTnjuzKkl2UiKpDtF0oeCYGl+j7Lk53L1PrsLH9KTs3cFZk3Gvvyu4BgZeyY1QzCKz6beYgG7cHv/WpoZ0kVCeG9RNJdQL14478qOSwCJX1XV5HgmXhMn5cP+cPli/4g6un3LyaMXktGb3rSG7qIKWWGNwkC4W8XO0HQh+wBsnKk10L1q/H/KTRnM0C03aZZxjZMZHVoFU6lWUAoyWxLhEzokWXUTtD6yU3TcHVZMTn8piyzjBLSZrr6OchQ2Z0R3p/wDh0W6FXn5n7zMv+0O+IuQjnkZ3AV4qrasS7dsYm1aAefjATIZiIFqUWmMRyrNZDYOjHMnaObl3Kq+aY+SojKUO2IFu7FSVyHpnoyJS1yDrUS0Ir1m+l7r7F+E4ECKcl808SFh9D9hs3/KUnr/nB6ByJ51UdKtZvBJQyo50GQlJ2KSguRcTa30m1othpjwyqO0NzKLkCjHRUI4OOfAsImUSfPSxcztvmgC82R7y6PkBdGdIrKC4sybwNFuxVA9bivUfWCWYlKS6Cq3d6FQ1sNaHNuAk+lflNh1lYzDJKmrlIqS6y4Gv5HoHa3aGXNWqzzSBURHOKzoUU3rmQwiuBzw1OMMjW9ySjXkVaDS5gNjzARoOWNLOEzRPD5lSyOfXwvORgVHE02vAkD74Tf1w+GfwWzsQBb9sD/rPLT/j88ojm7YjxV5Lxa0d61e6ZIjsTNSh3kc5RJELWjmTlcJeBjVhWOVdW8Fl6jPOCk3SFMuFz+iChYldjslOnqJKElc3YuAQjHJsuIcsbynEa2K86bLdka1FV2OrYRCBtgFL3waFHXkIIGv5O8nR3WxteDJmrWYJcK27LnLfNjDM75Zm+5iFjSQmMpMM5y6lePrid6sdX7TE/2zyhXaaMVlHn8o6/Sq9yJjY1cnUH/+P9PW2JXze+EwHCpoLbH0D68YK/ePqKH43fkIkOi2CiK54US1qrmCcdqzzHFhovFKpRgd24GyA8QUW5k2FP6WTgzDtFazNeNYrrScGT6XJPM2GmN8y7gvN2ws8Xj/ni+pD6bcHoXJBG0Vq5IzHnI523R+ap2pE1nuyG2GbdMuhk64N92qqJzltBvHRY7b8B6rOvwssm/J03KnpSED08Ykoc/Sj7ApzTYp+iHK+RbN3OyuPwuaGdJiw/SFi9EFSnHeOnKz45uhrs4Q6iWc3KpmxcQuENX9bH/HjxlJ99/hRzZpi9FhQXjvyiGawCfJqEgJXdD4I996FHWurK4+fQZYIqS3mbT8l1y9om3JqcR8kKmwR1pL4rtTvOugNWNmPe5Sy6lEWd0TYapB+sDVwSTJXCNoHBvLjXqYAIxJORt+HZbjH6YybqQcb73Ade4QLFXG8EqzLlvJpwNprRJFf3jnXhKirvubAJax+2d+8zH76wI/7rzYf8vfOXpG81+YXDLOr7GqneB9h+t5+FBPqCflDn4uvGdyNAZPDoz5zzj5/+MZ9k51Te8LY5GH6vhQvklaRmmVecX09p1jntDaRGoKotHLvXKnStQjYBYagriaokzVrRXSvWjzSvOwlH4fOdl5y3E86qKV8sDrm4nuIuU4q3kvzCk19a1CI83IPasZL43NCNDF7EtlrZPegL2hcIRdOFuoMI7lLiju/F3oiCKkOv3oGo6u2Nt2bvs3skn9dy4FGEohvcXZTUJrRWRWtDgVQInJHUhwFYU33QcPr8hh8dvuNpNueJCdyUjUtY2q3gyHkz5Q8Xz/jp28dknydMvvSMX9WYRRMc1fu5GFvD/THtUq8HYlEMZn271ibBu7PMc77SB+RJy0kRAsITs0AJx0g0zGLm5xBcuTx2OBylTXi9PuB8PqZrFL3xsEvCuSrrQqtcCoSV2/pNHMEZ/eHOxPanuLf1kF0IcslcsrrOuDga86Y55F2acCQbChkCwaVd03rPO5vwVXfE2qUoHE5LHu0EvuArOuKr9pi/d/2S618ccfQrGL2pkYtyLxCIttvyk8oKP8oH7o43Chu1Pr/N+E4ECJE4Ppld8Ty9Yemy0ENvxkNt4MCUHCXhon25PsIeSC7OMvq7M5jg7rlt91JgoQjWp5FtEWiztcw5U6FdtukSys7wdj5lfZ1jLg35pWD01pFfWZLbOjz4vVhNkeJVYNYNxbbeNDiKsEJ8IGTgjnghYLTtRAhP0JVwLgJ7tp4aorX3Ukev4vdKGRSejkxYwQR0mRzovboKXpuqDhBquWjQO4K4e1h9oyDR2CJh+VHO4iPJ5tOaj15c8v3pJc+yW4C9mg1skY0AjX1Ju0gZXUFxEZWZekJWng7XoL9GDw2bh+JrV6hBqk9XoR7RHCo2m5Q8aclUy4EpMaLjSK2YyIaRdBQioGSRJcqEbcfKZpxnY27zjCTp2GhPfZRTLSSqUlG4JmYR78nq+/bxvePN9tmgw39REao3kzZXmi8PDvn97DnPkhsm8le8AGrf0XrPmxgcflY9pXKGQtUcRQYxBKTv5+0J//XmQ37v+gW/+MUps88k4zcNeh6Dw65/Rh8MlIRxgZsVdOOEdhyg2W0h6H7+pzCDMNryNJsDDLboZVwhjXBMdTnQip2XlJ3hXPuBuyDbIPqxj4XYStR7KUgXvfox9PZ7G5PzJr6/rg3uMiW7VuRnnvzKkt50mEUTMAJNGyjKRseIvBU17b+/DyLA4J1pCx0Kq2loF3apGOTS04UJEnTRRcmnehDKob/5/U0vcmyqaA4T1o8V5WNBN/LRFyKQslQtMHNJfiEYvxXo2xpZt2AdokgfrHO4VNNODeunks2HLR+/vOAvH3/OiVlhEYMkXxoZsMWOevaB2rBpE9RCkSw9Zt4ib9dh+9S7mCVmuE/3/EijMKzXsVPQuwFEPUnVhJW4GhvcTJCpbqg73B0TKcBZsqgE9tTccpmPWTRZMGYSnvlBSjOV5NcxENctUsttINe9z8U3rPQ7BnxOOG4ffJtbj157skvBalTws+wxE/0pRlhukzMyIbl1BWfdjC+aE366PgXgaTrn2ow5UBuWLuOXzRN+b/UBf/f8JRevDxj/wjD9siM9L5GLTQDA7R5rmuBHOXac0o1DobmeiaCzMQ4eMPY/+man1o/vRIBQwtF6xdvmgHf1FCkcY90wUoEAdGJWQ997pGty3eLNvmrOrx2xcq8Bt+yRhwn1TbgEqhKMrgL9Ob+ypLdtEGgpQ/9e1MEj0ac6ME7jHlW2Ub3YEVL1IolAL83mRFMdC9opdLnHZh60wwtPdh69Pa4U2aXE3FRBoxFCSp7qoI+oJC431MdBbn7xkaT8uOH582sOsnKQmge4rgrOrqcsvixAKNJrg9zUiKYNeBGf3POSdLmmOg7+ntlRxfPR7RAczpspl82YD/JrJmrfrwSCU9NtmaHqKNayWwpKTSiY9kSpdmelU0GF3GuBU3LL9+g7K7VH2LDdSObQzBR1++un6kQKHLB0jmO94qPsEoXjuh2hheM2n2Azea+4KFsXYNMqBrGeuLXT7XloiGhm5HV0B0uCoLCXgWujN570SjLXM/4rLyit4SfFs2Euv2umXDcFt3VOoRsep0sWLufH9XN+b/0Bf//6Oa8uDvGvc6avBZOvLPmbErkqoW7wTQNab7EzUmKnGauXOavnis2pp3vUkowbZuOSZ+MFt8X9+/h14zsRIHoYaSYDm08Kz0yVZLIN1N+dPdm1HL3vY/ZG70q1tYXbVv+TVbiByZw9wFB240gWARasVjvCsmkSRFWzBG8ktti2vYTd9qG9UbTTlM2pYfVCsn7uMKdrRnlNnrQUJvgSrNuEs9mMLs+C34PVqNqglndunlbYSUo7TVh8oFm/gOaj0AL+i4dfMlOB42G9pHaad0lY7V9byabMya9SCkBfrwPOQgcafbAJDF/RFppmIujGjuPxhifpkrGq2LiEExPS3UO9ZqbWVD4ZNB/mNudNfRCg4xsRYc2hY+GliNcswONF0+2JlXgR7080vYFQQxJ1LJ46kG3QUlSVR68EZWVYtSk2v58iF8IMNOobV2GE45Fa0MS2rpaOq3oE2uM02CRsudR6y8Zkh6Q1AJ88ex0yVdtBm6QfPTo0/IMdMJVHWkESzYeXbsrfXmX8XvEcJUOw7KykqU0wuilq5k3Or7JjKmv44/NH1O8KsjNFfuEpzi35uwp1sw5dNO9BqhAc8iy0kac56xc5808U60+2tgQHpuTAbHiRXPP7+k9hgLAuqDHPVMlYVYNgbF9wOo77slv79cFBlsGVyGVxGyBDNO+KLQFHdiBLR3rjIlFpu5qo0qJWTYjQ3kdikcElAdjTB4bBmLWxoeBXNgFkJCXNgWb1XLL+MxW/+8nn/PWjnw4s0Y1Lqbzmsp3wk/yUX6QnlH6CriTpjUKtBGIdb2AEN3WFoTzRrD4E//GG3352xu8cfsGL5DqwRW1QXVpHc9FxUvPoaMn5o4TlC4WwKUUMYC7XAVCmwOvwoHdFRDVKOMxKDvVmcFg/UiteJNfD8Ts6asLfnTcTfjZ/TDtPycqttJso61B70FsXahHvxQAXV4F1aVO1ZyPXI0EhwMipLKpS6DIEiLILZLErOyaTLQk2OoqpezoLB7KG6EN60+3Pm1649n2j9yfpCW/b+dGG/dzO2JPcdwGpOACvavDCoyowK4V7leN0Tpf6SMUXmC5kl+s8Y5lP+Ex6cILkQjF7K5i86Uiv2jAvlxvEaru9EkqG4KAV3fGI8knG4sMQHH7z01f89ZOf8aPsNQATWTISXy998ND4TgQIgGOz5tEdJafTqBfZn1SQgnPc1jlqI4Ms/trui3bsDJtuW1O9X0JY6VzQLATUaos9lVUX6hbeB3WqniR2R4mn95GU/XvzZBA/qWaS+tjz+GTBx8UlP0jO9tyVb11BIRvU1NE5yU9ucprrwMBTZYJZhofTq4BobCeK6kjSHHe8PFoMEnK3tuCmG3FWT1ExHRjrBrIQTK+PRqxf5AirgAKztsNquLsK9+Qin4UH4aodcWJyDtSaY7Ua7PyaqI3Rs2L/mMfcbHLkJrirq9h+3SuaRS0Ll+lBwu19kGSbSlTlsLkOFGwf2o9mE2or3gnWbULrFa1XNO/ZXx7LHEnJxnuWzg+4AucFdAJVw56wU/S00Jt9DLLNtsfTk7VcpgP3IvI37g5VOmQNMpXITuJlkKIPRLDQ8QjaksTWbjw2HbpPvXyAKiFZevKrluS22aqg72IY0iTQzcdZsJV8krJ8oVh9z/L85RV/7iDosO76scJ78V7vHd+ZAHH3pveTPhMto4iJ2EDQetzkqEpE3wwb/Ax6ybkH5o3u22ouFhQ7v7V82ymc9QjJQU5uh0EKd4psvQBq37FQkmYaaw6HLUf5hqfJfK9lBQyq0q1XfDy+4rPZMc1U0xaSdPfuKYkdGeqZojqG5LDio+kVU12ycUkUUlGsu5SjZI0RNgiMxCLi/DDjzErqRU6yCJN9wItE3MFwKgZwAuskFkntDAdmwyO1Hh6w2wgZvnUFrdfhu8sUs5Rkty7UazZ1pI4HjQRZtVtfyUxFxSsGzkPvbN3l0Z/UhFqGFyE7QwhUo0Mbu1Q0VnHdFIzVhImsQMNDEiyOIBHZz6uNTbjcjJAbhS4jbqQv91Q7StiJ3i4GoidquSEb/XWjx8NYx4Mq2ruEMFm70CFx9z9DbwIqVlbdoOQ+jN74OXYr7CilmRnWjyWbp57xiwW/efSW3y6+HDJvYFBI+1MZIDxw0xVkkecPDFuL/gHrWz5/OH/G4npEsRLoel9gVVgLPlSiMaGq7HuTGedRZVQD7msGO2mwlwI/ToIaURQE8Q9pU8AWo9DaoQJus0j1HYGatJxkK4706uG/3/0oF1SgZBf1C6wdJkEw6YV26pjm9aAy5LwYmH9TU3FoNqSiC+1IBY+SFdfZiKtkhC08Xc7QapTWQcWw95edR5cCUUrmdRb1Hkqmd0hSB7JmJFpaFH9cH/Jqc0CzSpheQ3rTDdqMpEmAJj90rvGBGFzG4n0Q1oQuQoQtB7Ww0MJ1JuhcqLXkdplzWYz5IL+JCMqGmUz2the171g7z9JrKm+46Kb8cnXC5c2E9EqSX7lAs1+19zPPnUCwyyB2Rg41CuH9g/oSsnUPZrG7ruUIiVUhk3BplKgvt/6dwKCQJsomqG/tAptEqO1A3KalCd1IUx5rVh+A+HjNX376Jb87+dVecAAohCcTgruE1V83vhMBonOSz1fHdIVipGtmaosmswiWLuGXzWP+q+XH/PHlCebckF179HqfR9APL9gDhPQIORlBTENRUW/ldULBTIESwanp1wh8Cu+h7RBG40xQl2pHIjzM45IX2e0eBLgfI9EylRVLWW1p4T48qLKx0VVaDZJvXS6w045ZXpGrkB3UTrPuUka6ZqRqJJ5MtrRWUTs9COYaYynvtoNbu7fsqja0fmUrWFXpoAH5vnFrR3xWPuLzm0P0lSGdhxVPNl2UOuuBW+re6th3BITfbs9Ea0OrsQefSaIoz06tpwO9ElSLlOtpwcVozDoLx9li2bgof+db3nSaM3vMlR3zq/oRv9w84lc3x3CWkr/zZJct5rpEVG3gwkgxmObu3+AAqJKtG4JpODG/RVbundv+yfoe9NVEaYLoKLanQta4+3PSqIFB6hMT0LrufvDxicblhvKxYfVCYF+W/OUXX/FPHPyYj5NzNi5lIkPBdiItIyEppEF+yxziOxEgbKP45fUxjVN8f3LBE7PgRC/IRMu1Lfi8PeFvLz7hP3/9PaqvJkxfiQhgaoKaTtsN/gquSAK/P5GDySkEWu6wyn3NcEoijPr6Xng0Bu4/3ZtgLtOOBPag5cVsztNkvscO7YcRjkIGGbyxrkkSi5UElt0difIuDxmEGTccZ8HrovVqTz06lR0OwdJmrGzKZRNMj1ur0HI7aUXnBy+FcNDBh0N2AW8gW0FVJiy7lKXNWbiMIjqdQwjUr+2M39+85PeuXrC8GlHciH3NRh24FgHWG6XydvQbd1feYJCr7pGHfK8kLQOvAR/xHSto55qr8Ziv8kN+njzlubkhE3PAcusSzuwxXzXH/HH5hK/KQ16vZlzOx3RvC8avJKPzjvR8HTAEPeIwT7eGumYr2ONVOBanVawdbMFoXgu6HbCUqj3OyK2dIAw+Gj2VXEZ9DtUEkl3vWXF3TnqjsOMk2hKCTySy7Pa2QgC2SKhPUpYvJdWPSv78R1/xjx3+nB+lb8mEjeZPlkxYjqRmLAMC9r/xACGE+LeAfxY4997/mfja/xb4nwEX8W3/G+/9fxh/978G/gXAAv8L7/2vhWaITrC6KbhMWo7SDc5L5knOl80JrVd8WR7x+xdPWX81YfRKBlbkZYta17FFFdyiXbSu70VvUQGnIHwAv7hEhQuvvtme8uuGNyogG7WMyszBfcoULY/SFc/Mzb36wzqmvbvsURFrLXfFSryWNBNJc+A5OVgND7sRlqkumeqSQ7MeiojX3QjnBa1TVFazaFKWqxzZCFTtI05hW0QcMAs+unbdSjbjhD/Mn9JYxeYwYaY2PNJLLIJ37QGfV8f8ncsP+erNEckbQ37pSW+DgS6dHYR2vQrbgkHqznvUptkDsvXDpbGAmcZ2dN5nD9v3qNZj1pDeCCqV8dPulMvNiOvHI35QnFHIhl9Wj3lbTflsfsLtJmd9VSCXCr0RTN8KinMbvCQ2dTjWCHizR+OobtWbIsutapgnBs+oHSojaDIa5jotwrHKwPnRm/1ststkcGJPJaLy9OK4wm+Fj3aLur2KeJcpdO/jIQRiJ5v1RtEeZGweG1YvJZsfVfzO977krx/9lN/KvsLgsF5wLEseKYdBDsHhTzK+SQbxbwP/BvDv3Hn9/+i9/9/tviCE+BHw3wd+E3gG/L+EED/w3n+t5pVsQV0ZrpIxvxCe3OwUjrzgcjVi83rM9BeK0VkgAullHUx8pQgTUxKQe7Ei7Xbk6XrTFGSE/Ypty23v+HdX8FiE7CvwDw0bCUjtSNMWgVOijR1wHbtj7TVvukOquPqfdbNBLTuI3rDFCciAna9ngu6o5VGxZmZKFl3GVFfMdMmTaBN41s2AsO24bkd00Y9iWWa464T8RpAuoofDZkd6LgZNVXu09mRXHlDUmym/t8i4eV7wcnwTXMYQvCsnfHlzyPrdiOIrTXbpGb/uyM43qJv19j7A8D2ic8NK7dMEWXXYO0FCyKiMJQOpLHhxbAOY2bio0B2l2xtJU6Zc3iT8x6ucvz97RqIsl6sRq+sCsVEk14rZFSQLj9l4ssuG5HyNXG2CIbEQgWI/LWgOU6rjIL3fFSJYDArQVRAqMmtIun5rdH8ODL4TO7gYVXqcCS3xbZBQyMYF60EbhIL35ADTBNe30CXYNNgU9r4e4cMFLtGUJ4b5x5LqhxW/8/EX/PWjn/IX8s95JGve2ZxCtjxTlhP1zTBDXzd+bYDw3v8nQoiPvuHn/Q3g3/Pe18CvhBC/AH4X+Ntf90fCQXotqEXKu4UZIm2ItgK1lIwvRFAnWkaOQa99YEz0TtzKl8UDH/rYwm4l899XeJSdg8burKx9C0oO2on7Bx3SR68EXbbdK9el4aIac9bNyAZzVs2tLVi7NHRlZE3rFefVmLY05HGO2NwgRjm+SOkKQ1cAytM5iRKeaQS5WC+57sa0XnHZhp+9T6aNjld9ZrLrBg0R/Ve2uFQHsxUjI5vRk/mQzTVNwufVEz5PHm3/sBPo62C2U7z1pEuLWbz/PgB7PJVeYHhXELaXECQyYvvuhnAh6+kFWUJ7OjBls1tPvRS0I0lzO+Y8G+GVR68low1RedyTzYPfh3CgV80AgccY/HREfTpmfWooT0Jbupl5fN4hiw7fSXwryV4Z8vOQHagmmP3iARkefNWE7VmYKEThZR+U12VQdVJ10PTsldptqlBl3/kSEP1gXBpEemweRHz1qg3BpAnm1Uion4zYPNZc/0jgP9rwOx98xW9PX3OkV2xcyhuv4hzrOJT3rf3+JOMfpAbxLwkh/ofA3wX+l977G+A58F/svOdVfO3eEEL8TeBvAiTFAdmVRzVyEOBQFUMvXG/ChEyvu6CnsKoGNJlXYdL1Rik9O3B3Pyha9430FmSzI0emIv7hPYAapwU2kzgV+uqyDdoP1SLhq8WMnxTPWNmMQgaV5030j+ghy2d10Lr0ZWi9yb7SrVRQdBopbApCO6zbL4htXMLGJdy2BZdN2Fok0kZS24bSmrAl8QGso5od/cIuyLwHBGDUsawdXsWHoBLBfv52X91K2KBrkd468ot2/z4IgcsSupGhHevBRdsmfeD0gYuig6u27KKRbOlQVWgfeymQSgAhAwpCufGhFgT6PqEYmN5K2lEo4AbAU+hoqWhyoyobjYCiInXVDsfpi4z2pGD5MmHxPUFzYhHThtG4ZppXHOfBsOayHPOVfYSqdcgiVm5QCydianaHqm3g48QAIq1HbEJxUW/stvDYF3Fjp6oX8rG5ostlqAlVMXNoAr/HFQku1ayfGObfF+gfLPirL3/Fb49f8Ugv2LiUz3eUq0aypvYdhfiWGvcPjD9pgPg3gX+VEE//VeB/D/xPv80HeO//FvC3ACazFz67caSL7cOoq36C+3Dxq9AbFlUbFLCNxpsotBKrxbv71l6WXN4JDsL6LYnra4KGTwPduG+9yXaLud/9LBV73uGjJOk7xbU64G8D5SPDJ8UFE1UxURXLKGRSOcPbasbFcoxeKMzKI2Oxz2dB8bktZJho2pHr+0KCtdOsbRIEUaLQYCqDca9KHD/LnzAnbD+cFvhE4iOfoeeShP9kfABjm60L1zy7uRMYPejaoVd2GxxWJT41uElB/TgPnI6DUIsJqyxDkGlHHpc71EZi5oLsSpBfCcwquLLLxqKkCIQnEwKXbGzI3jzoshvADUHOX6FLub0Pgzx97GzdLX5KAcZgJxmbJymrF4Lu0w3H0w3TrAq+Jqbig9FN0NxMN8xPM1bljOxKDJ8dstIO0T3w6MjILVEx8LZRUbvHg0gRFMTj/HKpoi00LglFT68gndttR0RKXBFqDtWx4eY3wPxwzj/y8jP+yvSXHKmYOTSHe4eRiZZT9RVPYaCX/0nHnyhAeO/f9f8vhPg/A//P+M/XwMudt76Ir/2aDwy99L0Di/1htWm3Lt99v1iFtpjPkyHjCErX94eLrMtedks6u1f0+aZjD3NPeKB8Ex2rOk86D9sTl0i80lybKT8zHZPoCGVkx9wGU5Rll/HTq8esz0cUt0HhWtXbDoPoIpirAdcoHjozIyyJDNLqE12Tqo6prihUHUyI1QPtXy1BhA5D3/Pv1ZJkTZjgRqB2ShVyp0sxAMza6AmiFe5wTH2csXyhKR8L2qmnyz0+2a7+SI8sOrKspesk5SKN+poK2aWYtSW5qQNaUYjt9qjfYjiPaNw9WHM/fft9PRAwKk23NSOCgC1JE7yWtAcp5bGgemz5wekFT4sFE11x3Yww0pLKjhOz5Nis+Wx8zCKf0GUarxi8NoKRUSgsi3YrMtN/v7QuzLXeVbxzgZPitngHL0TcvgZFK6d3tmTxXFyiaKdB4Wv9XOI+LPnzT1/zu5NfcaRWOCS3tuCsmQKho5VGd7czW3AkKwr+/xAghBBPvfdv4z//e8Afxv//D4D/mxDi/0AoUn4K/Fe/9vOcDyIju5iGXSfozm6LOVmK1wqfpdEJ/Nd3I7wUeARCBjquvLO6DBX3O63NvuAEd4qdxIet3xVEBmBYYQzCSbwynOVTfpE9Qk0cj5Mlt23O680Bt1XOzeWE/LUmu/Iki2gXZwNARguBGRt0qfDtNpj1RUoIBLdjs0YJz4HekMqOmd6g8MxtzqpJQrXNBSRpD9a5Jxjig/sWzoe6yh1Zd1VuzW/769NrTPpJTnOYsj4NQJ36cYcctWR5S2o6VusM20mkdqRpyygL97BMO1ZiBGhkK8kvQbZmaMX2RkG9/wkQcBZS3j/+h4YQe+/zmQlyAKnGppL6QCCOGp4WC55nt8z0ZmBYmqh0fmTWaBFYbX3TSZZdqGXEQqpTEhVXe9krrUuJQ29RunEe97/fPUZb7FgPNP4+zFEGNe31M8nq+y0/OL3gR+O3PNILHJKfVU95XR9wXgeSXq5aTpIVt7bgdXfIqXrN4bez4rw3vkmb898F/hpwIoR4BfwrwF8TQvw5wiPyOfA/B/De/5EQ4t8Hfgx0wL/46zoYECKxS1To9fbZ1WaHdSYl/mAyqOJ0I43N1SDLbpPQdzZliNCq8hHx5vYKdF4IfEytIU7+3jTG++j8dOfYenMe9iesv2N9J3xIic1KYnJBei3ZpDk/5QlfFQdMsppFlVJuUrp5QtLL39/u8BjCB28LrA2IStLFGsSxWXOkQ+t0bnMqZzgy4d8BUpziEJzVMxabjGQei30xLd59cIQNRby9c0UMQW9YrT0heOwEVZ8Z7CilepyyeaxYvYT6RcvRowWfHAZptasq1EbKMsF7sVXdF55Ed6SzirrNqUodWoSlwqy7e/iTQXznTnH5If5E/AJcpveKy8L7yOzVkckJSltOkhVPk1sO1GZoPRey4Uivhm4TRL0NJXC53up4+oh63HGbh9C2Ft5jM0032unY9ItJHYKxiPdYr+1QXwlbqS3KtytMqLWMoDjecJytw/3tDoI/qUvovOIoCQSuXAaHeedl5M9I5q5k9g9QsPwmXYx//oGX/y9f8/5/DfjXvs1B7Po2DLJZmzKmsRo3G2NnGc3UUB0r2lHoHHgdb54JbUJViUEkNlk5EktITd+jZCS832v9ibYb5OEHb8c86BbgPPiIn3io3bWDv0jnLmpVSuoyZ53nrIxHtAJdQj4XpNee/NqSLLoA+93Nanyou4Sim2BRZ+iJ5YkJ5DWLROIxwtJ6FeTebYpTgkWX86acsrnNmd4Islsb5NTW9bACuyKknaJzA2IwvHAHfdoX+TbRFatvDypNfZKyOYnB4WXDh8+v+NHhGb9RvOWyG/Mz8YTWKqTw1K1GSUdnJXnSDnTndqppZgqzCvgD2cgApnqPYXHfUhzctx+Q93NF2Hbudp56Y5ue9u+0J8taUtnxSC84VivWLmVlswEe/66dUVsd/Cd8T7barT9t6xH44EESLBk1ZKHIXB2qwURZdlFIpgo6qgF96kLH3YbC58APig5ezgjaXNDlnoO0RQpP5YIOKARtUACJ33Nb78eFK0jsCkVFKgytt9h7lvFfP74TSMp+DOKrvQ5jnuGKjOr5OCotC6ojTze1kFt0agPuQIZdelUb7MqQnGvyd2GCZNcOvWre/6XDlwtckeJyTTc2OCUiqi/8VHW/0utgAtvFvWYce05VjSNZRM2JRd8GFag2yPHr0mJWLjD1yq31Xj98oiO2QuCyIIt3aDY8Mze0XrN2CejADn3XTgfo9bpLuWlyvpgfIpcas/ShvrGqEXUb1LDU9jh9r8mwY/zSr2z3EKci1HxcZmgPUjaPFNUjQfNBzZ//+Ev+8eOfD3Z8RnTYUQhiizSjthojt/gQ5wVKpMzv+ESGeo5DVF0oIAuxB3n3SSgA6uhLImo7aHbumg/j9+9NH7ybWSyijhyHSctMbxjJmmO5YakXZKJB4bjoppw1U97NJ+i5QnSxXWzdcG2GWkTkc/Q1MTtKqY9TVs8Vy4+gnVlEYfGNRNSS5EZhFoJkoRmdW5J5h6y2vJS7o1cLEw+AMMaq5tppaqdpvdozgRrmJYIL23HtJJ+3J9y6++K5Xze+GwFicDNygYsAoV+dGuwsY/PEsPxAUH7Qcni64KODazLVoaVlqgOcubSGi3rM+XrMOw6RjQnp/loG6kHE/T/49akJKWGhaCeKZhTt5lKBS0A2gXaczkUMDHGyvGfzJDqP7mxMg0OmI2zgIvRVdrWONYcdXwNvdPCtnCQ0U0U3Ap/sdzGUCH6YE1nikGxcErIHAorypi5YbTLMIrBdZRMl8esmFHdNtOvTPTFq63IlWz+0h72S4HcKg4kJkPJJwvrUsHkiKJ9bPnx+yT9x8lP+YvY5meg4s6FgJlMfsB71hNKawWLAeRG8Tu9es76G03SIpg3bAiVwJqBVH8wCtRwWkwCTjp/ldlzQCXWVXu3J5uBNeOA2tjdr1hSixuiOtQuK3ef1hHpjyJYCswmBVlbdFonao0TbWBsZZTTHBdWJYfVMsvrIMf5ozm8fX/Asn1M7zdsy2C/enk9IzjSgkLUnadz+/NzLVBhsH3PV3lP2qp3mekcnJXBxwvuXLqNyhrNuxk/LZ/x0+YTr5tX96/g14zsRIISNhb4eH69VaPGMM9qJoToSlC86vv/JGf/k45/y5/PPubBT3rUzZlG/7zxWchd1hiy6oAVZBEBNYtSg/HQX3YeWtJMkrC6HkupY0I2gOXC4cVBmFhtFeq6wRiBbFdLDXj07mger2kZ36J1OR7OFNQ9O261DVk3AI9wZ3mhcYWhHmnomaKYeNWrJdYv1krPuYBBzSYQFLE+j65TCcdEE5wXbKUwXsAF7JCKjA/U67es3cg8F2Bv/erlVfpZlF6jvUuEyQ3Wk2TwRbF52PPv4kt89+YJTPY/FPTdodzRecaTXlNbQui2Vf9lkrNtgYrQ98ejxUHeI8o7OogidqP7a9ZR1bxReeUTPo7hTvOy3T/3rXolBqUq0gqoxvGumvE6OsFryWAVIeRXb0AGjEjAQxbklOy/DsTkXAkK6fXTcOKWbpqyeJyw/EtQ/LPmzH7zinzr5MZ+mZ5yqFZVXvO4O+MnRc/7T2ff5I/2Msk4xG4W0HtO7ke+cu+w8pgxs26rVjHQ93G+ApcuRImSY/XbzuhlhhOWZueXz5hHn7ZS/f/uCn757TPN2RLX5dl2N70aAcKEWsLtK+DxIra2eadbPPdPTJX/h6CteJNcsXSi6jFXFKBKfFJ6rNkRSpS3dxFEfKMxa0hwkmE2ErLpuoMy6ImAONqeG9amkfOLpHtckRctBUXFUlOS65fViynUxxaUmouo0su6CkEgVVaxyc2/f3BdIg9uSG2TsvVJbXj/bkobPw/GUx4rqSNAdtjyarTlMw/7yvJ3SasVI1vGhDEHqWK94rY+Y6gMArtcFZZZhTRCDVUWKdA6Xm0GJu/cY9TqY1rxP2RnnAsdFyVADOpKUTxzTZ0t+dPiOiaq4tQUXckIha5yXw3EBe7DzRZPhEGjp6O7gCIQLD/Vgpwi4zAzEu74guFcAkuL9NjPDg7aPWzErT3opuR1N+OX4JOhnFAyWfld2zC83J7ydTzE3iuzak1414T7bcAy73+nThOY4Z/NYM/9+wFb85Q+/4L9z8vv8w9kXjGTwj628xTKnTTWvxwe8PZlwe2NoLgXJUqLXEpfeeRx9v7URWCtZtllcGLYjE90QHJZdhpYWS0Da/mTzlB/fnPLlm2PMq4TDr+Di2ynOfXcChFiXAScPYaVTgvJRSGXlizW/c/oVn2Tn3NqC8zb2fUVHknQUsuaJueVdMuVzdcwob7gtDN1YUh8KzEYNqzipGlK5bpxQH2mWH0g2LyzjFwu+f3TJPzR5hxSBQj1WFa8nh/yd9EO+VEesfUqyVCQ3Em9Dl0RsaiRgx/d9GO9W2numIxFAszu6kaGdKNpJsG7Pj0tOx0sep0Fi/ryZ0HrFiV5xqucoPFI4TtWKU7XgzEwDua04YpXPgj18Fvw4vc/CtkH0HReH8BIa7hnQys7tt4Jl2JJ0o9Ai5FnJJ0eX/Ob4dRAbbg/YuJSZWpPtOJtL4Qa5ukWTsWxSxqZBCE/TKbwLjFhdbcVjBoPiXr69f76j18ceFsL6YPpjdjgg/WFL9rAQoTugEN4FXoc2/KJ4hIiGxL20/0/Wz/j5zWM2r8ZM3wqy6y5AtTf19vhi+53E4EYp5UmYQ92nG37nwy/5p47/iP9W9gUf6IIrV/LOxu2c3+lGFSXXhQuWiyJCsCOV/N7wUFcJpTVc2aB6rXaKjc4LrpsRtVM8SZcoHK+aQ/7w+ilfvTpm9McJ468ck1f1g0I2Xze+EwFiiPY67MHt0ZjmIGX5QrL5Xsv3H19zlKy5bCfBhzFe6Ey1nOr5VnchrgR/YJ7xK+C2kei1oUvFHlykRxJuTs3gBfHxywt+ODvnWXrLoV4PN8AiOdQbPp1dIITnlTlkURYInzN626Bva8iTIHGfqiBw4ndgwrvf+2vg3jZTlEeK6gT8acXLw1teFLcogup35xWtU1jEsM/snZgyYXmkljxNbjnK1nyRO7pCBziyUfs+Gz5iPNZb7olwoTU3zLs7fhFeCdpcYnPIslBRb73ivAlFUpl4LIIjVijhcUgy0fE4qLYCIZsYm3po2y5X++03r2XgJhCyh8GJy/tBtGWXvNRTxnEeuWmR66Al6rUKWWLVQaYHLohXAVWqa096I+heZfzcPeF8NWaa1aybhKurMeptyvSNYPLKkl7Xod6QJgPAbDheo+jGhupQUj6zPD1a8P3RBRNZcesSXtsN19ZwbsPWb+nygaTXOflgMNiV5XMmZHrJHLpXGb+fP2OkG15kNwPmZfg7LwKrtxlxVY+4KEe8eXVE8cuEyZeO0ZsGfVP+6bTe63HqaIXXCjsylI8M9Yln+njF02JOKjuu2hFTXQ2rVCpbjtSKR7Km8hKlr3GZZGMTKmtYlwndlQ4otZ1ns6dob54EL4gffPCOv/74Z/wwe4vE7VGy1y7FqYrv5ZeMImLxZ6tn6MqQLHXYF/esbkF0avI7KXH8zjsMUuF2UkUh8DIU0ZoDQfW44+RwzQfjG47MmtYrbts8pJhRE2LtUg70hkwEeZg2YhhGsmZsakhtWJ2A92trssU3KLUnqSdcQJ4GrovYPmDGo4WncZqzejbUPVLZkcmW+R1h4UI2Q5CQwuG8RItQeFXa4nZ2Al5LsHeCqN8KzTw4euhz3Qy1JeGDf4nPAnrSpop2pEKw1GLAymTXgsamzK8SbrVHbSTj89CCLi460ut6UDf3Rg0LCwQMRPhcTVeAmDU8HwcXskw2XNkRF3YSugjdlMZrVjZjaTNu25zGqijtv3O9fShwC+m3EP/Ok85D23eZj/kv5Qe8O5zwQXEzCA4tupyresS6Syhbw8V8THuRU7xRTL9wTL6o0OeLQFGw76msv2d8NwIEMCjo5MlQpGunlu9NlkOnIlehNTWRYSN1rFccy5qJFLTOM5ENR2rF02TOu2zC23zKoihwJgCqiNVtl2rasaKZQn5c8un0gh9mb/mhOaf2ip+3j4GQPWxcIFk9MXOUcHQTxauTA8rrKdmlQnRmgAQ/lDX0YxdwBaBjJBfWB4XnkaE8Dl4G+eMNzydzRrqmdprLZrxX1MtEx1RWUXItvF55z0UMHHeHUxKRqAA730nThxV4780+wojlMDt6J+xQ5BO0reK6LPhCHtE4TaFDG3njksGjQwk3mOz0QUIKP2A23qxn1KuUYtHrUIZ2624IE+0DIPPdWBEp+YN0XBI6X0iJnaQ0s4T6UFMeSZoZUbcBVB1buh0kc0F2ISLZzpNfd+jSYW7r8NkRJm1HCd3Y4AUD78Olii6K/qZ5y+N0xUytab3myo6Z29FA1IMAZlvZFOcFme7wxuG0Ch2uOqpyNYTFcmRwRgW/0jKQ15xWlNUBf3A45iejU0zSDe3PttF0tcZXCn2rmLwNHqnFWYu+LRFl/a2DA3yXAgREodaEeqZoDgRq1nKcrTlOVoxje+dAbShkHR+Qkl40aiI81x6msqKQQbvRaBtVfKJiE0B8UOupop04TscbPswvOVVzJtKhvOdAbnAEJeelyLAIWq8oZEOuGiZ5xXo6oj7QmI1EV2rLHvXyPSe3P1yqEK0CFwhJ7cxQnQi644aPD2/5ZHxBKjtWNh3ahFq8PwC1PqSwG5ewalOoFX05IKgZRfLTnW2O22Gs9opP/s5T6UzES+iI3raSxiqWzVaIZNFlGLHFOhhh91y4igHlJ3hXT7lcjVDXAWqe3dqoZH0HF3EHEu+0DKSzeKyh6OwGARgvJe1RQXWSsHkko2mRpxtbfBEfDg80EllJVCVQlSCtgnZEft2RnVeDwXJvhuSVwpvQDg6kQBEFZiRtLrCF5yCvSWXLxqVsXIpFctmNh+1wP3qswqY1iEYiu1jEjsxNCN8pOo3sPGJtA/27CsA7sxS0Y4PNDV0R4NmyCR3erAlAPLPywY3+tiO5XIf6XnfHnvwbju9WgIipbFsI6kNPMao4SoIg61EsgPW1gUwEObS1kxjpMEJwJC1VRHaX1lA2ZlC/Fo6h2GYzRTsGWzgOsjJObMcy7o1PdUiJ23hz37SHXHahQCiFZ5rUnE9a6iNNspCkN6FSLd0Wit2v0r2NvLDhdy5qBfSiMBBUlZqJoh3B6KjkSbHgZXbNxqYDWu7rhgPmzrCIvqY3dYGsghy9rgLRSVYd3kjk3WxdBQbiUPz7Gm6LV8BeVyIcW2o1Ok78R8kqHpPgshszVhXZTlfjopnwy/kx6/MRo0tJfmkxC4taN/dcv3b5DT5V9491780ha1h8lAXMzPdrTh4tOco3KOn25PecF6yalHfzCdVVDmiSRXSFX1WDsrnPE5wKjGEvxED3lk0QgOl9V7wEJYOD19vYSYKtl+ldDo0UnlWVospg3aAqNwjV+jQJyuzOozbhuun4M73azl+bisD4FaHIGy5U0J/QG4te1qErtImqa3/C8Z0JEK7Iolt2wC/YkWWa1TxLb/kz+VdMZcWtKwaMfF+k201CjRA8Ug2nZh7UnyNM9m4Lb3CaFts23NJlbEg5kCVGuCiWu10hW6+GG26URRmLlx6bgc0VcrUfGIbzynSE/sr43TtFLinoZhnNgWZ9Kqmftnx8eMNvTV7z57IvWfuEE3PEW3OAQyDxHOn1nvmJA86s4sxOWdqc2zbn7HaKKkUUKtlK7gURnjsXw4GQIcW3ub5nFhNOat+wtmsU3gtmacU02fbNOqe4bkccmfVwreZdwVddRu00F9WYz2+PuDmfkJ0FVapk3oVOT+eQqyY8jGZbnOyv6d2QMBDsXOCGVE8D2vb2U2g/qPitj97wG9Ozva4KhEymkA1zm3N2OOOPDk75Ij/Gqwx8ysx59G0VDIxiYHKmF4DxW0fwneuoKjg7O0AJT+sUT9IFuWq5bYvhvu2ORZtRlskg5hMyIbaQbSlQdvs3Pg+dL9k6xKpBZRpnFMliP5iLNnSfZNkilzuCyUZvhXnlN8tw+/EdCRAi6EQqEXQBC/C55Sjf8Cy54bm+BWDhsiFFu7Uj1iLFiFuC/GUY/ek7H2zNlAW8R5fdVgrN7z/IrVdcdKF12ijFc73g2hZc2TFLlzG3BfMup3MPU6/3zqQHYxGERZECm+1WSPff7xJJNZNUJ57ieMNvTM/4rewVz2IWs21faqyXVN7QehWuhe1QrDjrJpx3E961M75YHVHdZORrga4CUGo478ZvhXbj5JethTY6bMegeVevs8sVXSYCUKwB5ob1KOGTw8uBKLTqouBtlwZVK13hfOCGfLY85npdsN6kdFcZ+ZmieBfT4KsqoknjMVq1bU/2Enx3QFCq7BB1O4ChunFG+Uiz/FDQflDxow/f8o8e/zEvzTXAHgR5JOuh63WWHfAoWfJ3TMMf2eesq4R0kZBZjymbodU6eFlE1ququqEFq5qg52mThLdmRqo7jLTkrmXRZkzNPvDAeUHnJLbSZKVAly60nOsmbAW8R0RXr+BGFnRBUEFIWbQWocSgUCV2jYq8D36uzgXkrBABPZs8bEPwTcZ3IkB4JQYQj00lLgGddzxKV6FLoZqo1H479KsXLqPyD5+49ZJ5m9GtDelG7DspEYqJehMAKI1VtO7+ZThSm62RT/ya1iuW9j0CoD6i99y2Y+CyUBjcV9d2gSLsiA5NQQuxedTyydENPyre8EzPedYXD5Xjmbpk4+HMFixdztqlTGSJwlPFY2y95qodcV0WiFIFkdeF3aOou+ge3mto7Pox7FbP7eAVQtyWRTRo51GNQG0kNtYhaqvR0tI4jfMCKTzvyilfuUNWTcr5fEx9naNWElUKxreC7MpHVfIW2XRBCTuPjegov/bgVsd6JFtNBq+DcczmWcbiQ0n3myt+dHrBXzr8gkd62149UGtGIgQgE5WeAZS+gTzc1/pDzS/8E3SZ4FUarA8ighPYExX2SgxsYtHXuCxYK2itGgrKDwWHq3bETZWDDfWCZBW5Mk17P7tLDHaa4VIVWui9p4YRg0uc2nQBhGd94Nuk20zBFfvbU2Htn9IMYkes1ZpIiMsbRrF7YYATlQMlt07iECxi+l95zdK3HIgQaB0BDXdVjaKq8U6BcmeoNrS1bquc83YSRGB30lGF50BtSIQlkw0SR+s1cEChG7R2dHp/y9Dj8/0OIWo3OGzfFya3S8Ik60ZgZjUfja95bm44VZbxjknxWBK9HzZYJNmOx+JyuA5BpWq5ydBlcCnX6/skIGdiN0OLYCTUt1u9Byf2nMmcCauXje7bsg0FMV0JqmXC5/kRN3lFIi03VR62XsIzLzNWqwy3MpgbxfhGoFdRnXrlyG4sZt5EV3QX/TTiF0eND6dlmBe9hwaxaNntXGej6EaazSNJ+bLjLz5/w5+bveKD5HIPcagIHa67YyIbnusbKELgWNYpl9ePULUkvc4C5qLsEEpseTdSBNi56V28g+q12gjaueEsmSKF5yhbo6UjUy1GOFJpuG0L3pZTLm4m6GtNeuVJLyMIq9c7MSY4uk8L2oOM9dOEZiJwUVQGAU4F7c10HuT39Maiyg4Vd55eKfxY7fFuhHXIRtwrQP+68d0IEHF4GeXR9H1FJCMUhVTcOj/YwFXecGFD+o1eovAsIx32cjVCl2LwjRQPtCCFhWWZ8qacMVY1J2aJER0jV0cnqY5MWYzrqGRC6y1PzS1n6YxpUXGRj3Hp119x2foHg0SfWdhE0OUwyhtGqqaQNam4H+ULmfAUgBVrrweQzIaUW1ewshmbLqGpNdk8qFTJ2iKqIHLSYyC8FoNXw24/w8cW6Neeiw0BQpWQvDPcrg+5yS0YB40c2h+ylCQ3ErOCZO7Jb2zwz/Bgll2wlYtGy96oLbp093gi01Tc0aLoSViBU6JDG/OxIDsu+bC45nvpBQdqzVUX8Bl3ocl3x0Q2vDRXVN7w0eyU88dTqnlGM9NkrUM4h6j8wLlxqQqycjFAqNaHzsEGuFA0dcEXq4Sz2YQia5hmNeOk5qoecVvnvL2ZIl7lTD+D6RcN5t0CFiu888GM12jcJKd8PmL1TDP/BLrHLcUsbIua2mAbhbgxFG8lNhHk1+yLLekdYZ3IZRHDv79dhPhuBIhohtrrEshIprluRlzbMdfuisxusNFUciIbWq/37MXObHjv580Jf+fqQxbvxkyuw4OiV9HfUIZVe7fz1HWKq2rEdTpipje0XsdMYWsYfCBrWrXCIvj/tvensbJ16X0f9lvTnqrqjHce3vd2v/2STbaaQ8sSpZBRRAuwLQIBk3wwnA+xnAhRPlhIDDhAaOmLAH9xgkSBAgQCaNiAFDiRA1iBiMSKLMkWHFIiLZLd7Hnud7jjGatOTXtaa+XDWnvXrnPOfYdWk+9t6D7AxT2nqk7VqrX3fvYz/J//f+INh8khSrowLPQhreUgA7g5KC6RuA4MJMK8v0s8Un54pblzEgvfMHchvThQK0pvSGWDQ+DK0N4UzsfxZBeq2AOQlHoJXsNmgeG6w3N0r/NS0GYhgjDLboydoCGhJDYZFIJ9aMmlZx6zcpiFw8ybDVYkjkh3al8+NYHcJQ09/y7ikZXFZepKwdSboAzutaQ6SCkPJNWh5fY4sGpNbcHcZjReM1Fr9tScA7VC4jlUVyNJ6z2NDVHZjWTJ7t6Ki8OEcl8im8BEJZpIMUfAlHgZMBQ6Do7ptSM9l8hKoNaCdm5oTzXTwnGeO2QWB/vWGnOmGT0RjJ63JNMKMV8GV787xk4K1g9GLG8plg8E5YOGew9PeXNyzt1sFlqn1Zgny12e5rusRIE1ErwKa63jQGDdbteaIj/rD2OvhIPwbApjgV5csDjLOd4f87g+iCrfUzpgfrho10zj0JZF8LzZD6pP0wd89+lN8seG8WNHftIENBz04WuX36pSUJWa6TrjJBsx0eVW7jqsPt9USyyCp1GHwjqJrGMuuLbbwr4MUg8fSG19ZL/qi4AvAQcGNqCXIweNUEi/nQrJ2PpdtwZaiaqCnsTlWQ8IBb6tTkqX3nUFyo75KSpa989L1dch8rPtmQGvN5L3ED5brV0v9Tcck+5NDpxDhBdvtYaTSA/fjZ93+A0p+uJhvROwDuKg5jAPxdIn1T4Lm7KjS4xokbioCu8vk4UFG+zFSFfsFWumxYTywJDMt9Gv/Z84tkRyAiOWx0SkptOB5cyr0JJsoxaIXkF+Gs7J9PkCebHCVzUiS3HjnMWnx0zfVizfarh9/5xfvvmYnxu/xyNzjBKO5+0eT9O9vrbxFKh8QXIhqVcKs9CoZQ3VZvDRR80Y+TKd2Q+xV8JBdBJl0nrM2gWc/NPNMI09lDxPTwJISmzL2a18yvv1IV+aP+Tr57d5/mSf7HEStBumbeC6XJT4PMWLcMJ1Jhz4UuFcoHVzXmCj1L1FkAnbIxXPnOe4nfBec8gXpw958XSP0bEkmW+Uojumpl4palifaD06yqltHnOYdaiFLFYZL6oJz9td7un5S7kEjVAUwjBjk1OX3vCs3uNslSPX8kOjmi3eybjEYRsTNhFB1x6Vje8hz6oMeICXyhM6NnfexoIMsxXIbUWzEM1tiGqwm+MjPCHsjp+zBaDMFDaR1JMAhMryGik8z6rgvCurr5CnHHzIDbRj5hp+/5dOuF42HyI2XYJNIJkH0mG8x+aSNp7behUxCsvYhvQesTuhvbXL9LNjzn4aeGPFL7z5Hn98913+RP4DbqolRrgek2O9YJWkHGVjplnOtEipDiSyFejSINdJkA9YVRvinx8eBvGKOIjOIkY+nQWiUJtlfLu9w6zKuD+ecStbcDu5QAkXQmovmduM7y9v8LXjO1w8nVA81oyeesZPG5LTNXK2CiQ0WiG86vkDhAu5tFoolquU86KgKjQzW6CEI5MNmVpSxoug9JqpK3invMEPzg4wJ4b0zJOd2R4c1VmXP1+2rk/d/64lutSYFazPMt7ZO+T7o1vcM+ccyCX7MkddU48wQpEKqL1n5TXfr2/xnflNzs/GJBfRaXXXR2x1Xalei9g9ihqS/cMvoedTpeuf76nRVlcLf1sf0ckLaN3viS10iAoun7Q+cIL06UfrkHE0/jqi2lBLEdjEMdKWdWv66G43XZPK9lqFs8tWes/ShynJaVP0GiQdi5SXAw1Wdb2X6fRJbSoxTWip9+C0GPmINpLhlE0gYV6XgU5xb8LizYLp21B8dsov3v8Bf2bnW3whexw7WQJQHNuWTDRkMowb3MoWPDZ7iNxG2j5JU0jSjtuVGD2ol2u7fBR7pRxEuGg74RuJU4p6lnJydIvnk0MwDpVbtGnJ06Ai1TSaamUQ5wnFC8n4iad40QQa9Rj2+yxI0vtE92Ixeu1IZwEyu8pTTvOC6ThnlSQ0zS539IypaJhCLyP/xdWb/N7ZGyzOCoqZIJ05zKINGHrgMkVa/728v0qPTrhDqdKRTCX5E83j0T5fHt/nhpmTiXf5aVMzFlfbqkYo9qTmxAq+Wd/ld2eP+PrzO6jnKcVzT3HUoJddR0WAVH2RrTMvrnZYOsary8Qlm+MT4Nqym314mbnQUgssT7Fbk4a7vtcCYUU4zgMwUHctey37joZY2WsnYL0Q/dqFg3VlWKcGKTyFqRnpmn2z5FAtep6H+Usc3wub87zd2xJEBnBJSJuGTmGo6C2c3+YRHaRoTklkQs9u3b+kdaGd2XFe7I5ZvzHh/LMK/5klf+reO/zZ3W/wx9MnvKFzjBiQDxG6WJ3NkoK9bM0szykLHYSesxC59l3BLMylfJhS/QfZK+MgeuYjG7gBRBu4FpoLQX0uaAsdct00tEEXaVf0gnwl0MuQ3xVHLWZabXgeE4NLDXZkek/qo8KTKsHMQV8oVrsZJ+WYHV2hpcWI+z2B6dQWHNU7/N7ZG/zg+AB9akguYp7fDQv1phFSIIYCwX4zV+AiNZqMsweqcmRThzOS6jDh+4eHfLq4wSNzTKNnV/ap8ZbKN0xdyzfrh/yT6Wf58tFdmscjxs8E+UkcUW4sogokvEGHc5PddII0Q80L2GiRXHZkPSinsVvqY5uDt7moAcS66SOW4KDixWyDnJ60V3UuoKtDDZxY+uEAH+EEtlXUVqGkY2wqJrpkIgOZ0F4ERa389TlbYMIKnCI7ek1hauSopd7TNKeh4yPazYXecWlc3icvBBjZO7rOSbR9BOHRUqCaFhIB45z1wx1mnzKs32j43N0jfnHnO/yEObriHCAUqO8JQeckpsmIh6Mpqybh8crQFgqbXQWVhWOwAXt9THHvV8RBOHpRFgh3H1mHu4peBsad7mJrs+1iWlBgduhlqJbrRd0P24QWWpjCa/PBhse/1ZXHrgiUXivNi8UY5wV76ZqTakwqW0a6YtmmvLM44PHpHvZZweiFID+N0cN6QJMWLwoJLy1C+ug4JDbQucUmR6Y16ani9GzM9/du8LlihzN3zlja/mSx3nFi17ywhif2Bv/txU/ym+99mvrxiNFjyeSxJT+ukRfrwH60roJHNbpH6AGQbyZQgTAoFH/v5iGGiNB+2xrbc4b6LO1TE39Jh4LcwCUiXlmGsfQtvYju8HeCvpfSsutOdlm2qDgsFfQ7t7daS0cq24HOxcsT8KlL2ZNVj9Sdu4wX2Q5n+wuOl5rqzJCfqXgzaXvQmYqp1XUj9P13SiRWStpCYo1AlyFtFk3oKDktWdzVLB56Du7M+NzuM34iecE93WLE9fM3qTDc0wArpuaMZ9ke50XOUT6mTZPQseiui3VgIXc7OW2uNlD/j5luvBoOopuJv6w14YI4qvCbcFjVob0W2mkRQFM59HIjp+6VCGmFUUFOvXhJxc97pA3RhznWnNk9ZpPRRtlJOpLEUteKZpYil4r0TGIWvteb8KnC2+RKIagfqRZiQ3zCpmtgc42KrxM+YAz0CqrTlG/v3uS3krcxouX9NrTpAI7tiNLf4ElzwLdWd/jtZ29Svz8iO5bkx57stEHPqp4ajTQJd/cOlRkLVh2ter/WLqUY9sjjbABsiq/kBsj69Tcj3XMsOC1QdSB3DXwLSd/FGO5HxwIF9PiHy3vU2eXaDgwcWKxjyAYaF9Y9Tmq0cOzq9ZW/G9rcJT0KV1JyT9WELhlM9kr2zJp/aiXLkwPKE4Ve2P5YdaxVl52D8EGnYzh3gyCQ7KThZ+EVqkpCR6tjTNcOo0LNSwp3fadlYKkw3FYexwm2CKDBk/WYd09y2lxicxlqOG6QJspwU1Wl+9gFy1fDQUS7XNjbjB+LnqzUZjIoRUVx164d192VfMSsIwNkeCtyuGTCBbZqewGyFZi5DjDjQXGrBXQjSNdREn7lSRYes7RBraoLMyU98q/Ta3C5idHOpaGaSyF8gH47sjNJm0vOs13+mX/EtM55VJxSqJrGK07rcTghqhHfPLnF4skO4yeS7MQzflpjjle94FCYFRAhDx12U5oGr0xYX9pBqmWP6d9SgJIy5vsBfWnzMOLsVFC3bkZQ7QchmjBWL0imgmTh0esoRFtpVGnjTEjTK1P1xzw6hw8DaW1vYEh7VGUQrcBH4RklHAfJEonvaw+Xbek1R3ZCJpoeRGWE4Laqmchj3jYnALy3u89Xd/Y2+IGOItCBqGq8uUaMxnlk0yBs0BNtxpFOLhNdLx81CvocvisOizAJenmg64Osw8PI5IjSGx7v7PP+zj7OxHmaOLuBCORFetkG4t/KvrQI/TJ7NRyE7+YSLhGZ+quThd1xV/HL9jlfnJpsR7rXrOjIWfuPEQymucAsXSQRkbSrKMYjudIm7NiFA429Q5UuaDO0G6ZsbxQuN71updcRRHSpyBbUlLZx90IK9LolPxEB9GI1i9k+/+xgwj8fvUleVFSVoSk1vlaItcTMJZMjwfhp0NgwF3UQt+lUpNNkwyTVMz9LiLyZoQsQFcaU7IFVQ2sLg00lq1uaekdQ7UNbeFzicVnQe9g7WLCTVZyvcparlOVao86C5IBeg15CMteYpSOZKfRqQBn3Mk2OSyas3wqNu4KnNeF4qsSyn625kS25k1wE2LwIjq70iiTeNrtOVBc9DFGWmRBkIrSzN58bcC7SdoK9m7uy8B5/WeAnwrAhphjRMah1kEqQcXCwy3FtGigH9rM1N8y8X+dHsUImHGDJRNPrv272RyPzNMy3+LB2WRFQtT+elHMf4SWd1/WxH+8HEUYU820LFarkUtDBBGQdADsdxftQAwKgo31XlSBSGVxL7KlL2wuyDgVbwgIGXyDmgU4HxF/HUdlpY15X5JONwzuPkaF4Kq3CXEiaM4NLDFWWIytB3oQ0RFWh555eWLLjOpwAkRXcR8mATnjGJaqvxNtcbbD4g06Aj+roau03kGwlglr3vmR5X1AfWORhxY29BQf5irGpuJUu+Ezxgj214tvrO7yodjitRjxd7HA2G1GuNPJCk55K0pnCJoJ0KjGLcKJ28O5uHbLd7FNvvYjPNRGGAJt68qLiMFvyqDjlXnLOTX0R0bAEAhcCmG5qR0xtcBB7KojmDK30npUzzF3GtMxR61A76ArK1E24M2sFzkXKOLWZG+lOh9g+lq2P/4JzMEsbRJ89WBXnIpQnGdRMACrfkIqPNoGphOOkGuPWGlUNuisxkvVG9bMrnQD2x7FXwkGIKDXX6TFcZ+GOHH+5xFEYcrpYqfUhuhjSv8lVgyjChis2DEnhj3lpNX8L3243wCDR2I2GR9SaGB6QzjnYVOEVeAeq9aFT47miM9mvsw7U+JkIYBubBmcTopwIUqrDbEk3FaoWdQjbncPnaeChVDGCiQ7CJRKnRABDifidWx/k5Lo9iA417A20I8XqlmL+yCPur7h7cMFP7B3zs5P3eTt9jsEGrIgIjNCZaLjIcipneLG7w5PDPY7LMc/mE84PxzTPU5yWyMhRIQcnaldht0pgExkVzAj1i0vgqt6EiMJGDqMsN9IFn8lecE+fkwjLksAnWsYLzXrJ02afmd2kBiNZMZcliesG3wxP7C7fXd3iydEe2UUcma8ifsF5XBTc7Sd3ldyaY/EyOGIgaJ/6rn1vQ3fOh+jCi1A/oQ1CQt2U8sx5Vr7ituIDnUTlG2bO8q3yHt+d3kCfatJpIJ+RtUWUdXCuw4jhYzoHeEUcRMey7K8BBV1nNpXo0mIzvS0ME+1yuCysDXlhNOn8Ju8Vm/52UOcmAHmikElPUjro/XshEJGAw+Xm6gkcKdpl42BYzPc+yMddk2/L2uK16JmLVAVmcSnXiWAiYDvkdeATjR0lW7yXXf2jS6069iO93jgb2C4Oexk0M6sdyeqORz5c8qmbZ/zxg/f4ifw5n02ebU1GhjtzuCuPZMWOXLOrgsjwqkj4XnaTb5ubvNC7rMiQrUSvFEltQ6szE6jSbZxX7FAJH+QMr0szu70Mk5RhbmfZphhhWfmURISibuNVf+FZJKXXlM6wtgYjLKUylN5Q+rCnp67gW+U9vnj8APUko3juSc+bqNOqgvLZ4POFtQhvkKXdoFMHMHphfURUghqC5LyMz4FaKp5d7PCd3du8lRxhxBSLY+4Ce392lQAAVQBJREFUj9zQSVjvuHAhnZh7x9frQ740f8Dx2YR8KkgvLMksToe2oSbX8bm7cYadZPhnHw9y/Wo4iGjdXHtnImoeAtthpoQ2U6jKbY2vDlODraLXVpHOIqRErP0WScrwM7cXJTbv0VeF6anIrnwWbEnYbz3uPVYH4RqbR8Se3QxH+Thn0H90Zfv96ERdr2s1unEQrG3GetPv7k7SQTdCVRtmqQ4Zed33tomg2hfUN1o+fWPKf+/G9/nZ4r3I27mNnnzeTnja7vOi2Y2KTuEOfs+cU3qzVXx7AZTLnPxYkp7H4x2Pw3VpnZeir7pfV8SUDaiVoFwnvCgDYc49c85zt3vltZ2treG4HiOF50FytvXcqR3zlcV9Tk4m7D4WFMct5mwV9GKVvLZFKKoGIQxq3QZGrii72Jlax67OKhbRYwonPJilJz0TXJwXvLN/yJNiHyNa7qgFLyysfEUhNvvdeM+ZC+fc++0hv7v6FN+Z3kQ+zchOPel5izpdhAGw1RpR5FDVIbLMDOvb6cce2nqlHATOc10Q0bU7rYiTmD7WBCJe3jsQYuNMnJKQD/HDxNd2cL1LOW0MuaX1yNKG6OFyKjwooArr+xHkTqlqK0W+9LcishBtWfeaSw7J5jJ0BKpN9NK1+1yqQ4015rxd9GKz4Bj6FKu8hNoU4Q6KCulTkKy/tJ4YyrcjRbUjArv2zRU/tfuCny/e4bPJMdaLaxm1MtFwQ8+v0LtlogmK5EWYIWisYlpk2CTgGERHplteJdPtl+799cVe6zErT3IhqE9S3hvv8ZXsPmfZiAO93HqtRXDSTHqRYzeYayid4YkzzF3OP5n9FP/03U+RfTdj8n5LdlJuqNuEgCzZdKqqrtCcQGb6CKIDUgWZgE3xNfy8vXe6DIOJcmb4wfkBv1c84iwfcc9MuakuIgFz2NPGS57bHU7bMQ7J11b3+f2zhzx//4Cdp4LszKLnNaJu8N4H5wABybo3YvmwYPZphf2ta7f5pfZqOAixueiuQGt9LOJFRuHh491FJyzQ0M/qb/25hLbQsRJtA1hIbKMcu7upjOi+MN7r+07EFXO2R0r6XgU8jkpHuPKHWT/bcE3l/rpKvlcSpMf7AHrq4Mv9ndX5UHVvXS8u01X/u+/ghYh1joiI9L53UK5I8EbSZpJ6T2BvV3z+1gt+fhy0Nw8krLxj7jbHpxygE0cDTc6uO2AJMny7esWeWTNKak4zH1m0VNAUWTcgYzp2aS+21j8Ax4WDFeja0qmgPZLM8zFfM3eo9jTTpIho2MCyfVKNOa0CAU8bnUMqW74t7zIzIxqv+P76Jr/z/A3cOyMmTz3Fk1WY41nHDkGWhry+Pwdiu1ZKXK6DY/exKN4Nmblh4XL7htVphZqVJzmXXORjfke9wcn+iDtZIC2+Z6aMZEXtFY/rQ57Vu5zUY+ZNyg+mB5w92WP0jmb81JEf1ajpCl9WofYQJQ18aqgPMlY3Jat7Dpf8GBYpfWQQukxzDtDJkn2YicbGu2usE3TS9knMbWPnI7xYxEJR9PCDyi+ATxVWyyi6EusTMZcUPowN+3iR2kTi0sDX2DmIocnabkUjsnG9yG9AFcax6u5u00aCm0u1lQ34RvQOYmta1AW0omhdf/F3gKgeJZmEO7EUgBQ9XqOzNlOU+4LywLN3sODtyTGfTZ9yR1U4BEsnsYjAJu51EIaJF1ztFY0PStMHUUmo9IZFpOhbtim1VbjMUR5o9FoFTIHzPV+BtLFDFI+FXNW4URqe7yKk4TF3IW1KpiGKOhZ7LNYpo6xmnFbsJiWJaimtYVrmrBtD2YRT/oWZ8B1zk71sTW0VTy92mD+dMHkhKE5a5LwMqcXLTErcJKe8M2J9Q1PtygAUW3mSuYrds+svRq9DMTacH4FbwxnNebvPF+cF+7tLnu/ucCe7wAjLs3KXH1wccLHKqMoEu9Doc81O1L7Ij6Jq1roKaN54wvk8xU0Kyn3N+rbA3F+gkh9H4RxB0DuwHy0/Epc7DNBjEfqZB7Fd/XZaBFCNFKHKP7y4BrRm/etjr90l8cJvbX+ROhOKTM4MnIPfFP2G1r3vFh6+s65S730vYNO3cC+tR9YufH7HmXBNcbbreQeoOVA3CKNwaQznfbwT6zAt2YGpuu/bsVy5zHE4WvEgOWciawohaLxn5Q1lZLMqvWFucyySZRQX6kL3oAshmLVFXySUInAykDhcEo6Hi12Ubl985Mvs61AyToCm1090itaTXthQZxES0Rqaqea0cJzkFp23SOXwniAq00howhoXAhCex5nFW4mcaUYvJOOnjvSsCc5BiF7oeTMAlfTp3fpOwcWbmvImVPsuMJgtJOl5QNumF64npd06t/o6kUfVYR4IL9ArRXORc7yfcD4bURQVrZWsZjnqTAcw31owuoBkGtS/knmDnpYBINdc4v9IE+qbOavbkuqm5bM3TznVH08f40MdhBDiIfC3gduEe/Cve+//hhDiAPjPgUfAO8C/6b0/FwHw/zeAXyFMlvw73vvf/7DP6aTphjMAQzjw0GS8y8hqqDd5vbdW1YeH+y9dUyR56e4EXUQdSHbDXa3XJfAhv+9UvK9+P7bSn5dW5wd2eS9kGXEY9QccZO8RZbPBWlyS/NsyKbCpjimSohlJuqHGbqQe4MyFjsCpHfXK6hCKeo1XzNoCgEnUwLAIztsRpQvdBQAjLQfZisfyIHx0nKjdIp6JkV2XagQ1q2TT4YAtJXIRW8+ycgin0SsZ4cuKtlA4nfR/p30sCA+uIVWDzQxOgVlAcewYv7cOpCvd3l1SHvNaYscp5a2U+QPN7G1H/mDO23szZlXGdJEzOypIjxX2mSQ/hbR2Ubwo3Fy64no3yq5qkFMfNDingvZM0xaaMsmRjWBnCtlp2BOzcoG2r3KoVR3Aesvy6gAd0O5kVHua8oZHH5Y8HJ3zB/JH7CAIaON/33v/+0KICfB7Qoh/CPw7wD/23v9HQohfA34N+N8Bfx54O/77BeBvxv8/mg2q7kA/Yuw7OrrSopZV/1qfKuw4wSlJWwT9xa0vuPY9+4+0odXkLsvNXTKba2wmt6jpLhOqdCAY2HRPRGw5Xp7yu47dWq/s1Y6Jh6Gg/RYKsmNc6ohVthYzeItE44okdGik2Fp3V7zcKpjKSGs/itGFApc5kgEnaONl+MembQhB5eysHbOrQ1tR4TnQC87aMTfiJGyHtThvRzxfT/BOoKp4XJaBn1J406Mqw0ZGqYCuridCtCCbbZKazsnKyoYxfk8PduvmQ4YmXEA0duxXuvK0qYgXXmhpqmUdNEmlCF2iS1bfGFEdaKafUVuK8HfywEQ23c357ugGx/kuskkC29RKIleRXasJ7XlkQGl20nrh+4T1twtJG6f8u7QlOw20fR1nRh8lSkKU4yooNs7bFRnlrZTFfUl1r+Zzd4/4+fF7/ONryHs/yD7UQXjvnwHP4s9zIcQ3gPvArwJ/Nr7sbwH/hOAgfhX42957D/y2EGJPCHE3vs+1Jlws1rUOuapCz1mJMBgjJT43secc8mq5COIiGI1NUuodQ7UrKQ+CTmIQjImbu/BxaCiOGDcW1Tr8OLmCXxDVxhH1nY3LyL5hPaF2/RTq5YtdVBsuA6dEP9UHGxzCZRteuH3lvuuyOo9aNmFWohocZCnxRRoiMC1pdoIeZRM1Izugji49ZinJj6or6xM+fq/Bv9oqKmd6qPKRHXPc7iBxJCIUAA2Wm/qC06he3cnS39QXXLh8izN0ZWP3oJKodeBxlKsGsa4DaErK7eJsBz7y0ZleItsBelFhWVuSaYWqrhf+6SD8woa7cIeq7dJM2cS7cWM30ZcQG6KVwSBbs6NY3lYsP9Vw/81T3t475lY6xwjLDTOnyRV7yZp/1irm0z3MXG4cXEewE+suCBDuqgMfOvYQKbSoZRVSr2r7AvdFGtmrsx4p6bMUu5OyPlSUh569mwt+bu8xP5e9Ry6u0hB+kH2sGoQQ4hHw88DvALcHF/1zQgoCwXm8P/izx/GxlzoIrEMtm+C506tL6vJPWYXilZcCX6S4ImH+KOfiUZBfl4crsqyhtZLlMoGFJnuuaDNDcWJDmPcBDrS/YFzgabCDqbzQaQE9aA9e5jQYzgwMuzEBag1CX6rEd+bodR42j4WTuc0Df4ReBVShy82GoVgGLdOgRiZZHSrKG4LVfYsfN6jUYkuFWCqyI0V+5NErHU667jNaH7+TxmmBXknMTPH++R5fKh5iRMs9cx5YtgYn155akonmilhw18U4VAtu6guSKGp0rCdxk+mnc11hAuN2Bw2/xrqu0mW19CD2HDkfCx3qRNb16efQ9GL7oMsqgrBUwFmodbPBW3QkK0JszofKhhHtRLE+UKzueSa3F9wbz9DCMW8zGhco68aqYqQqbk/mTPfGeJXECdZLN5BY9xo6PbmOcypCoKr42Y3dLqJLuRnAEyIc/zxggmQVSHZ9EoYO20LQ7FlujReRsf0PUbxXCDEG/gvg3/PeX4hBkc9774W4jBz40Pf7S8BfAsjMziavlhtASs/r393Vq4gtNxqfaOq9EEKtHjV85jPPeXvnmAfpOedtwZP1Ho8Xe7xfHOJlAlIFoFBXH3hJWu60DCG8CjwTToc2Zj89WtktpKVPdN9lEdJHXMTAqTU+FEitRzZci7pEbtqNEO90bQibpfX4y+llZGmqDzLKfUW1G4BN5W2Hubfgj90+5m4+I5UtJ9WYd+f7PNvdw6YpsjWkM0cyEwET0ViEFWjrsZkiWSiaqWB5POKbo1tMTIlF8ig5ZqI2Y9QjUTOR9RUHMR9EDgmWiawpvaL0hlmdodYSVUYeBx1o7y8P6W0dH98B6Fzfcek1TY0MTjwO2Mlld5VfPRWHwrheR0EcKSIpro1dr4i6HI7CexBYnA6DgM0oqM4/GC95mJ8DsHZBVSxXgRszlW1I0aQnzPm4nnNjWGwdRjriUm1JVc3WtRAQs76H9rsk1I5soaN6vcTAVv3Lx2nRVLdbzv3j2EdyEEIIQ3AO/5n3/u/Gh190qYMQ4i5wFB9/Ajwc/PmD+NiWee9/Hfh1gN3srhdlEwRDRnHkWgnafKPwJNsQGgoncOOM6iBleVuzuue4+WDKLxy+w88U73FHz3ja7PMoG3M+GfGb5i2+xV2ETdArBSRh7uMl48VDPkkviBRpBL4J53uG5n7uIlG0Y4NNRay4i0hVFje49FF9yYULw7mtu4lXVwth/b5bh15uwF3dSLtLNdWNjNkjw+JNT7trufnwnF+6+ZifGj3j08kRO7LEInjS7PPe5Abf3LnDlyb3OS8m5M8Uo+eC7FSSzOK0H0AlSBaO9kxiU82zbJ/vZmvup+dMZMnOgDD4MhFL6Q21130nY/N40A399uoOT892Sc4k6UVIzZySocuSbAhNhvYyPImPWplOi77+4hUb2YTr9rJzLpfYr8KTop+hocO3DNIPCOeFM0FlzBtPrhtyFS66yhkWTUquGlLZksqW2ipYqxA5xpatKGswGhm7IP3Hd1PBVdunMz4Wj3tnOM42z6kQPbWZGswfuSuTmrLxyCgO9TIVug+zj9LFEMB/AnzDe//XB0/9BvAXgP8o/v/3Bo//ZSHE3yEUJ2cfVH8IH0LvGX3EH3Sh9XXmjIzVWYG/UfFoNwim3FJz9mRJoy8oZMWeWnG0M+HoxpjZdJ9yHuTWkzm9kAvQoxGvbR0SU45YMSbWSoKadMbqbsrqhgy8CAk47SP1V3jzoHIlSM8CC5WqgqPoPndrdgKi7qMIbTvXFQWiRefQ7CQs7mqWDzzFT0556+CEXz78Nj+bv8t9taAY+L5Hesaj5IRPpcfcz6f8ZvFpnu4dUN0wjN/VFEeS9Lztc3e9tCSpoBkLqpnhvekezye7TNOCTDeMBkrdp4OORu01iQgMXAdqQSJC9LD0muN2h6erXerzjJ1FmDHpCH56Yp2X1I23Jna7qdSIXu2cihjUirwSeHt1X4dO2ZlN21RFiv3wRuIq0E6LCIRStFkkfzEOLRyFrHv0aKHH5KrBCMvaGhZ1irDdjUbgEx0chLrGQXXFZ92N5QtcZnrlMC9FT28wjDpk66GbEraxfmEkLtV9DUM4WDeGk2ayVWD+qPZRIohfBP5nwFeEEF+Kj/0VgmP4fwoh/iLwLvBvxuf+S0KL87uENuf//EM/ofOKW/MTgx8t22PAQtCMBNWBZ7yz5la64I6ZAjB1GQrPjixxSG4lcx7tnfGlwxHVNMPMBboMlfSuCh5IYsJbdwcgKF2HDoWqLHIRmJo680UaZN9uSC4+43E3asZ7KzLTkumWvWzNujWcLgvOn+5iE41sJdm5J5mFNKXTyHAmfP+tluwgFZHrZnD3kNhcUR0I2vslf+reO/xre1/j8+kzHihDIcdXtveRdiySxzwyx9xNpvzB3kO+enKXc3UYCXYgmbUgwl0nvbBBXn5HMp+M+M7+LX66eMotNQcRqNqaSLwytKBBEdiRDiMX5NxlfHt9h/dmeySninTqMbF70YXQwvu+ExTu0mGAS63bKLcXELYuDZFDm6u+JiTrcHz6CV0Rz6foQLyKuiRKIrwPOhyDeQSb6Q0i95oZGq86NS1Bj+aMh0YJxw19QSobpmnBzWROoSq+u7rFRZkiSxla4N05HlnOeqr/qKe59VlRHgACsK0ZxYlgBXq54QZV1iMGNSvZug3NYlyrcEH7ZVkmvKh2eG53af3TK+fHB9lH6WL8JrwsY+fPXfN6D/y7H2cRXgpckYSDl6iAXhx+4gCCa3ONi7P0W4Na+F7c5thudC339ZI7+Zy9/SXTw4TkQmLWMkxKXkpVh10D6FqsLrS+3KbC7HYL1vdGnL+tWbxluffWMXdGF7xZnGEJ+ho7umRhU55nO3xHeM70DjYz1C/CHUE2vp+LUNX10GqbqnDyx3BUVJZ2YljeUazuO964e8bPjB/z0JxG55Bcu79KSHZFzs8mJXfUV3mUnPBWcczf42c4LfZxRjF6JsiPw4kmFw4zUuiVQCwVx6sRj+sD9tSKPbWZcximE84LnJAMldaXXvN+c8jjco/p+YjxWRifxrFp0UGPUIU4UBY5GOQiTDQiNyNfG2h5JNPtrr9uqjUCq9wgzQuDcYNZGu+vHHvo0ojL5x5bhWibgcpaCl0zViX3zTlLt8KMLXtqyVk7xnmJ92ILQeu1BDfoGlkfyH0J+9AxrvfESWKDmYA4Q+O3o8mtKVwlgrxAEqJvL0QgZV7C4izn/YM93h8fUvuPh418NZCUA3Ox6LR5IFTwhyK0myEY8AMv0XiJFJ7Ga6a2IIKv2dMr9os15ztjmlFKm27nl0PrnFPXsZBd20tKvA7Y9vJWwcXD4BxuPDrjz939FrfMBYdqwYXLewr1Xa0pZE0bW1lnagIkCKvIzkN4bS7aKwK7HQFOWE9QmBI+4OttIql2BeLWmrd2Trhvzrmnqmsjh8s2lhljCQfyiHv6HN6Af5R8lvfsbUAhG0121iBLi1450rMwM3G0t8MXi4c0XnE3mW5VwzNRU/qEs3ZMJhsO9ILSGU6B95tDvrR8g6+d3EEepWSnnmR+6VjGOYyt8fzY5xd1E+QKBoU9L69qdAA9C1hbmFAkvoxaHZhoLzFSqw1C1UtwEV7fDc2JdsNcJiy4RlJaTeUMI1Fzxyw4VAuWLuWxO+S0KqgqHeoPEeuw9fkxahDeQ9MG5qcu6ok3KXuJgkCWG24MMWAs23yJePMaPCatRy8Faqb5wfEhv5W+xdx+6aX7cp29cg7issnLoCAi1NmDbARNo1hbw4XLgrBIrNbWXnHS7tB4hRSekalJRzX1vqFaScxKk1wIzEUT5iM6tunW40UoKvZpjZS4cUq7k1LvamaPNIs3HLc+dcrnDp6zq9Y4L7lwOQub9bneyiVUTrNrSm4UK7gBZ0ywkUxWlx4TiWZg07V52eyJzTT1RNKOIc9r9syKPbli9BF5NDrbVwWfZskvj7+OuWv5+8B78jayDulGdhrAZflpqI7bNOMr4h7PlxNuFEv2kjU7pkTiuZmEKc7Gh9mKF80uc5tTes23l3f4/aP7TL93wOR9wehZHdikGturZXXgqK1R/UGO3t1Z+2OfyECKco3OyHUmepq3jV038tzdLK57zplI8NJ6kjnUpwnvHuzzqdEeF1nGRIaOzpN2n3fKQ757doP2KGd8GjgaVCS63VpXY/u6SK/0ngywH2t7xbHYVG3o+jpCopgWSut6AF3ofHnMSuClZ/REsG5G/M7qU8yr6xmzX2avjIO4LFUHhPCuLz7JrSEXPIgG6kpzXI152uyTCIv1klM75rwdcdKMe0k1iSdJWqodS7UMnI7SbqjkROvxiQp3C6Ln7gROtMTmhmrPsD6UrO56zIMlb+yccyNdsHJJz3vQeMXcbsRupPBMTMlhFkPzGzDVI8pFjllIzFxdHQW/ZD4J726NpCkEbe45yEt2ov7DD2M31Agj1li+w+xmztkqZ3W+h1lKzEKhly3JDGxisIlkTcbRNOFFsYfJG7SxZEnDTlaxl67JdMOqTUKq4QWzKuPobAf/LGPyrmT81JIerWMq4PBK9cNusvFb496icWBU35L0UvQXREfw03GOeq2uiBKFm0dEJ14GukULOqkxknzZ9K0cDMnJ8J7JzJMWkrP9Cb+fPWRHl9xNpjgv+OLiDb54/IDF+zuMHgfcSTJtL+mmdIsU+NyEcyvTW6xU3azRy/RJNl/CB3rFy2/dn8M+yAA2Ar0WrJcpovwx5YPoQiPZOKy8lAdCHz51BRiIgJtKcbYueFbvsbAZ1kte1DtcNFmvtegQLNsEoyxmp6KuJeVaoUtBMpVB/HbgrVXZbmY9vA93MSVoCkG9I2gPa+7vzRnpmmWb8qzcYc+saYza4kvoeAkuV4/rVrM8TFClwqxMQGNec0IM98amYTCsLQQ2DyStd5Mp2Q8BfulsV+Y80gt+bvQu3zy4zRfvjajOEorjMBOjrSM7JbBgOxlze4XXCTb1LDSc71reyy3SOGyloAqtaLWUpGeC7NgzetGSTGvkIuIopMSPQ4vOK4GVohNTD/vfhu5NHznE7kLfflbQjMKpK1sfVbZ9f+yu7N81Nx8vY4v00pb3iuYipBqXC/9m6clPwBYJ78pD/r+tJtMt3guenu7inuRM3peMn4UpSzMtg24KRFaqkKa6DGwR0qduYlhVLrbSw0zPkGAGQtTRzR+5VCMauU36ay/B6AX4EkzUlkkugrDzx7FXwkF4LagO4gFvIgeABFUG8dOOfUlWgVEaAWYtA9nGQnNRphxVE+YqINqOy3FQuh5Y5yyk9PjU0RZhsMemAScPg2KUZ4NaHHp/EYpUInGMk6Dg5LykdprWK06bEXeSCwodjoKKZ58RlrvJbGs93ztMWduU5EKgao1eiK10aqirERY+0FiQQcn7vB3xL2oHUvP55BkvDr/N0WrCi+PbZKcatU5i6yx2NmbbV1Kbhf1oC02ba5yBtO4q5yBbyM4dZuVIZg16XvUw4KBXYgLOJXYFbBoKcluFt4FexrDo2B2L8Jrt79ONuw8JfmRp+/e5EqXGz+6VyJtIH/cSnIy0nuQC8ucS2WS8uDB4E/AG6VmQIChOLMm0jaA6FxjGoS9GtqOghNXf6OKcScfjIQfCPF3nJjzAVnercyaX9WSGzwtAVKHTI6y+NmX/IHslHIQ1gnI31BVUFbj6AidhmL6ziUA1no6EWK1bzFKRXAj0QrCYFvygOCRVwXvWTrFuPgAY0vmBQcuqa6f1L+m8coS0bjQ6COF1BMVULmzhWV0wUjUkG8cwNClCC/AgCYNNs/2Mo1ZQHmSYhUKVHu/CBdJBhoFek2ITfoKoBeernGf1Ls/tmNvq4uNverSxzHioS76Q/4B3bh7ydw8PqXYN2blCL+Ner2LNpz+RAwzdKxGo3S+ZcIGwVS+aoFvSkdNEQJIdmchncWmPBt97eBz8kAtisLWyjQNfscsUNgxE3SAH042uSDasXDHf7wV38+2QOwDhfCwU603BMppeO1QZKACSuSB/ESIbvfLkZy3pWdPPdYTNEIEpmXjBGxWG47qbXutJlha1akJ0YH0ozsYZC2sk7VhFCQePKlVwZlXkGXG+1zIZQta9EL0SWAfnFsO62ke0V8NBjDznn/fohSA9l+iVxyzDwFVHYCra4L1fFoa3TvJhvDLOSZpaI9Yqgljie7lNpbmrmHcUYj4Wjra4JXxgIl7atK89HCQrRqq6ItjSeIURlky03ErmNF6hpeWsKjjPCmzhafOIFrVhMGdo0oU5CWFlvCBCZXo2K3i8v8eT0T731Jx96a5VAv8oNpYZ99SCL4zf5R8c/hT17u7W5Klau77IFjoOcVYllT3Sc6hRoqowXKVWTQ8f9lLi8wSX6x6YJJzHE9qB+pKYb28i1gtiFqHLbjYhcl/UIR30Mna/JGFW4SUWVMzcFf7Prdc4j/AOaf1mirrLdizoqkV4ha4E4jSua2WDPF+zzas6REx2wDjhgwOVjUOvgoPrC9Va4nZyytt5gNHvBYEim4XITFUhOjMLH8SjlzbiVyIUPcK5h2JEPtbShmnaR7VXwkFkacPNnzjh+GxCO05JT2WPOUgWHlUGQV8ZqfGDd6f/J7T7UGmNqtEs1wmuVEgb7nI2FTTjjv0n0LV5pbaUr4Pq1OZ9hAdXKxqnqKwmVS25ashlza5eU1wap+0cBNA/Z4TlJBvzJNmlNPRj5aJ2iKrZRtopiWwsqgrkNcnC055L2knK93cP+d7Obe6bcw7VBYcy/6GdxEQKHpljbu/MeW9nh6YIg1vd+EWXH4c5kQ0DVgceUo3bDK9FFSph/YZ2XV7XOQhX/XXcGK7Lvf0mBJdNoNProO7C+r5G1E7SkMvH+QoZC899ytC/V6w3dWClQQsTIl4hIhtlZVHdRaZF393qHjeLzXfuJzUjatIrvfU9hA8OwksRlNd9nM4ta2iD2BJG0xwWlAeG+cMwidnsWxi36KyhKg2+kmAFZqbIjxTJVJLNFOl5g76I8xzJ9mV9GR36ceyVcBA7puTzh894Ly2ZHWS8eLYHLqF4EZyDWbZRUTm0dzr0oTPgNSjl2E1LEmmv1B4g3PGXq5RmkUATipxt7sEFSLNTJg7wRC5KEdp7Xm9YiTu7riaYq4DLb7za0l0Yq/KKw4DgKDocf6cvOcy/X6abEWY6IJl7mjPJdG/MV/bucctccEctGIuWQlwPlvoopgjt4HZsqXY0ydxhxEDdO1LCAX0oa7PNHIVuHGKQE4c5k0unmN+8X4d+lPXmfdEygn7CpKaqLGYRcRGNCxeUdXSygu0kpbqRsD5QVPtis0/rKC40cz0nhS5dAGJF5XiIF3zsWAm7XRQcrnVYRO0fdx5Zt1stTG8UzU6YsPQqpsyRMEY0DhWdp1w30LT9fIab5NSHBbO3EuaPoLlfcXhjzmGx5FY+52ayoHKGk3rEtMo5XY04m44Qz1OKZ4qxEYzrMEJ/2aTdpBZXOEg+xF4JB6GF5c38FIBlllA1mlm5i7SKZCERTpFcGq12EZrtRSjEJNJSWk3rJWW7/bXKRmOthDZ2NQqLG0E7lrRjiXAhSjBLsUFspttIuM46B2Gk5W422yJLASidYeXCRTpWmxZkKpstJac9s+JwtOKJ3A0RzSAsvW5Gw2YSm4i+F99mgubU8IP9Q76cPeCmviATT3hDqCvS8R/VpHDcTBfISROKj1mokgfdEo9o/GayFjYU7o7+ghOdaKwQvfbn1v4NCG+EFniCMxaD93UmFPA6BvNw8bqgZiYlbpRiR4bVrYTFfcX6tqe53bB3uKCsDXWpcQuDvlAks7B+Z8AsQ0okGzBr3zOBCR8ilFDv6L4cvTMJmIRLrdDuO1gfawuy35OOTs8ptvhEhPOIqg3fo24gTXBpghsnLB/kXLyhmH+mZe/+BW8fHvMT4yMmqtxiDF+6lGf1Hi8mOzyd7PKt9BZLOUKtJWaVkAiu8GaEFLqbdP3IpwPwijgIgaeQAfhTOcUkq1gelJSrAnMR+uTmYtPCakdXo4R5kyKFZ9UY6lZRD5xEuU5wlQrjt8YjE0uW10HvMjNUC4NeCiCMV6tOqv1StNBJ3vk6IDYP9JJ75hwIDM5n7ZhGKJRwWC85b0dIfN/uVINbzd1kxl665rH0XIdkd8k2A1WnaK7WDlkLMg3NRDId7fCt/DY3kwW31JxUXHBXFT9UqqHwPMjPGU1KrMlDCjbSsTjmAN2jILuBKeFCatS3aTsn/kFUd5dNsJk/GMxK9IjJ1oUQPuIimp2U5V3D7G1J8/aan3n4mD9345v8ifz7PG33+eLqTb52cZfvnx8yPR8hI5FxudDomQ6SemtBMvU9L6Zowzr6Kdy1D7WwVTwnrtHt6MwP1r+lwdJtRdTFEFWzRQfojaLdTVndSph+RrH+yYqf//R7/JnD7/DQnLGnlsxdTiGqnim89AaFY1evuJnM0dLyFXeP1XJEslDolYpi1oNR8o7HtGxfWsN7mb0SDgLgtpmRyoYbZtGPEr9falZlgi4lZqEjsUfn9YkXM9Rrw/kqRyuHvHTb915sOc3OOUzyCqUci1aCMP01qqoo0rtm6wIFtpiXWieZ2ZwDvcAIi40l+ULWFLLmrB1FZSfBWTtiVwe2pS6KkMJxmC5xmY+iwSF3DpR7RPbrDR+A7lqxzgf+A0fgMDxRvJse4rwIBdLxN4AfzklYBI/X+yznGeNVqNhvUeMNw9MeixJz/Tr26LsZi46/4BonMWTL6tqbbWF63sZQS4jpXfeZzuOKhGY/4+yzKRc/4cjfmPHLD7/Hv7H3Zd42Jxwqz8qteCM5ZTVKmJiK892C1ssevDUvU1arlGqtWa3V1TuqB1mFiFIvJdkJOA3pTAZynVVzhfwFAsRbuFgnGQgh6S7lGu5dmuC1pLxdBEf3GeDtBX/ywWP+1YNv8jPp++zKilUkCJbC9cNvjZcUsmLuMp7IA87zgtODEe/czFguNbIx5KcCPW/6elAg3GkDG9WPo3ivxDOSFSNZcSEziO392TpjPteBgDTZYM/VukVVCtEq9FrQzjRTPSIrakZZ3c9nCOFpGoWLTMYoj0la0jhx2VgZ6hDRVBNO9q5Cr6y/Ns3ACs7WBY/X+6SiZRJTCTMYhc5kg/KOkyaoOK1sisJjRNvfDSqnI4dl3IeqRZQVSgkQyZa37wtNApwQUXTFUzwLr33fHvKb6i1S0ZKNv04m1txQHw8nsXIpz9Y7+LOUZB4IUtW6fWne2juHWB/Ahxad28k3IkZRp7SffxgOPkVJAptJZOXwTiDkoLPkg8CPqFu80bS7IXKYv+W4+9kjfuHmO/zK3h/wp9M1hSw4sUv25JpMNtxNZuzqNRSb9TZecVqPOalHnJcFsyqj4zmyLgxYLdYp1gra0tCuFF4rpJUgRBDfrWVgqBpGSt1e2EAkpNaOAbfO5nVShnFvLfGJpjzQLB4I/GcW/OKbP+DPH3yZzyXPua0cpfco32CEIxO2T2EzYZnQMBU11kuOkh1u5gte3JiwqsaoSiLbULsR6zbQ+lV1YOmuaq6yD32wvRIOwggbhoeAiYww5RE82dnlIh/TFoFxWY+TEMpaH2CkCx84GBJJmWsq4XvnIKWjSMMFa1tF2wZnYFvFukporApV4VKFgZoICFJRDXw4yNXNaUB4jV4ozmcjvqVuAfBWcRzEYdSq/5tMNmEmwV3fclvZlJNyhFpJdMmV0E9W7XZhrEhA0gsCC+tJFi7g7ZUEDO8WB3wpe8Cn0yPu6ff5OLbynu/Vt3h2sUMylZilQy/thpY/hveddcxF4XjE4q5S+ImiupFTT2RUue7upI7kwkZ2JRsipMFgVCh0OoQTfQdiOAtjx4bl3YTZ2xL1YMEXbrzPz47e46G+wIiMyjesvI+0/GEMu7lmcvGumVIWhsoZjuoJh2ZJ5XXvOL4vDmlaxVp6Gq2pJICinkiSC0GRSnLPBmVrVL8f3V4MrScdVgKvNEIHvoZmYljcl6wf1fzkrVN+dvI+n0+ekQnHKpZpMuG5pyBwRW1bkOSbcmx2OMomnO6NeKc0rFcZslbINiF/4YJzmC/xHSX+j2ORUuJ7IhInau7ogDq8kS357qih3tXUY4FZKjRdBOEwS4FNFG0RmZmFpwak8uhLeyoTi2uCH/YerJU0pUY08U4XL7quFbZVEJUKTxjRNiuPmUnW44RTM+I9s89IB/zDkKQ1Ew1L8fLBmKfVHkeLMXol+g6GNwqRGDqlcIgnmBDIJrR4O7BHR6jrhSA7DR2B5SjjO6ObfGNyjwO14EDOtz5zLLMr6wgq0TX/9erT/H+OP8/0yQ57R5DOQlt5iwrwMv9ANK8kLlPUe4ZyT1EeSqp9sGnMfVsw8zBSbpaeZCZCOiFFH0V0ob6MYB5ZW9Sy6WXrmomhPJSU9xp+6tYJb+dHvJUccVMKJIKFa1g6ydKHAnEibB+pTdT6WvDakZn0r5magm/Ku0zznMpqpHS4tGGpHBUpzSQojrlE4XRGdtJscV3K1sUW6zX1pFRFdfjwcz0x1BPJ+q7jzv1zvrD/Pp/P3uehlpTeU3qPFDASklwk16aKqdAosaZJn7ByKcs2ZXmQ8GKlKdeGdCbIjEQ0bXAO1oL++Jf7K+EgIOS/c5dgkSQiSMvnqqEoKpajjGYUqvh6FcI5VbahfeM9zug4fKNpAZ86LlNkChXo3gQBbq1Udwfc4PtfynoRTbY+nOAXYAtFaTKeqR2MDBJv+3rJjrwcW15vz8sJ0/MRk3kU3HH0bFrbH7otGitajxp2PERoe9uzABuf5hP+6fjTpKJlT32VvUGb9cAvMUKyK0MrtvIN328a/qB6wG8c/Sxf/OYjJt/V7LzXkkyrHqEHgHPbv0PoVGQalyqqPcP8vmb+aYe4t+LG/pzCNFSt5mxRsHwxwmkV9B184JpwKsCnezXvVPbzBGrZIBdrfJ7gs4RmrKgnoMcN94sZt82Ue2rFvvrwMfeRqDkYRHcQiIUymfWcFlmsfx2kE07LEUY5UA4KWAJ2LGkOBRdFElGQhlFlkasmdHa6lCrVG+q7yvZQaYnDu5AqNmPJ+obE31rz2f0jPps/5aG+IBc5uYALV7Ijsw+sISkhOZQ5Vq+Yps/D8XSai1VGPdM0xaWpYKUQ+uUQ8pfZK+MgnBdXQsKbyZy7kznfzsdhdiITJF1xzHloO1bmIAMvHGBCBVMq19eShPCkaQsZGGVJTbgrlmmCHUi621RuqV57Jbe5En038usDDkNrVmnKWVbQjlU/7wEwtcUVfsaJWpMIy6kdc1qO8EuNXoXR6mFo6optLMOQ8apbR2fd5GJ6EZS32pHm+6MbKOFwCG6ZC+6bM0aiplQrDI5GLZk7z7eaQ35n+Ra/N32Dr75zj/w9Q37sSaZR8j5GUXaU4hN5LQzaFpry0DB/KFl8OpDn/MzhUz6THyGFY2Ezvr28xXdGNzna2aF+ktHmmnQWIiBVg03CdzIDfYhhu9TmgcbfZpAXFTeTOff1OQcv4fLMZMMkOuppJA+6HEEcyjVOSWqvOLNjrJes7GbfhfCMk5pJWnFjHLpQzgue5rus5AjZSoRNyV9soqmOxcomUR1MXBoSi/vZZoLqALKi5kay4FAvKOINTQnJvhoUTj7AlJAYIbinZ9Re8V52wO7okBfFKGjEFBJfZOHckgI/ymH6Y0oYc2THlN6wE8eXFZ67yYy3d475wc5hEILpmKK7YRal0FIgd9RmSk14lHEIwabVKTxKOnbzklw3OATzKg31Ci+QbQArXa1oR8BPPMjdoFgOyEYirGRhEi6KjLO6oCwMx+0OQN/FgHBiLWxIN07tmCfVPtNVjloq9IooIDNQwxrY1rAObBzFYK1q7QKRiRHY55LSZnzb3aZsDTfyBQ+KKW/nL7hvzpE4vtME9unfunib33n+BmdP9sifaEZPPOMnNXq2Du04E7gY2pHGJZE1OeJROmav8oZheTs4hwefOeJ/8uCLfCF/h0O5pvSKJ+0et8wFbxUnfG1yly+n91iqMTYXJDPIzoYwxujwOlnFgdCyTcDmnklWIYWPzF0e6x0LX2EJ7WKFR+J69KoSDhmrwI2X1Mg+nQ3zMSJyh0xYuYRFVAKTwpOqlpvZgokOo/VKOL6S3OOr7T3KeRFQjGcSYhvWjtMYFUUm9Mh72mmaEEl/vAjfZZyGeZ6R+HhiNkNT8TuPZMXdZMZ+tuZ5bntWKa8ljHN8amj2M9x7P6bj3gCO4NGVcNzR056JVyr3UlLToG/YVZCBSiHyBq03d7s0bRlnFbluaL1kXqWcTce404TsWJKee9J5kDQbahWEu8C2aKwXAtGGWkS79CQzSblIOS1HnDSTHjjVWQe1LmRN7TUnzYSvX9xldj4imwr0QEruJZuCxIUuhtgofAW5uc3LQmvWkZ0DhEnD90/u8O5ey5eLmoOdR9wolmQRwXleFbz74hB3lpC/UP0UYjfqTsz97SjBZioAx5xGKtfjUWyuKPcEq3ue8f0LfuHmO/xc9t6gJadwSHZkGIW/lU64u3/Bu6WhqVPMXCCcw6yIClMbfkmhDEJK7MiE+lIccxfxfb9f30LxnId6NSjhCW6qJYWseifQUe83XmKEw1xmbrnGlHTsZ2tuZgtupfM4Vt/0Ea7zAiWhzSNOpHHISPSiGodqtmc9LhO//CgtRBsrYMGxOedGtkBlLcJtoqFOoc2mLyeCfpm9Mg5iJCtKayi94VAu2It4gbU12FahWhH0ES7tdVf9lw2olUAlijbXqMgqrZQj0S3OC9atYVkbZhej4BxeKIoXnvzUkcxa9KLu9Re8UgH2q7cHtbo2KALMSqBXgvrMcLQ/5p38kD0TpOc7UNTaJeSypvGKymu+s7jFd09vIE8N2ZkPMOIP6E13wCSfi945AVv70JGfyOi4hHWkM0H+QlDtJ7Qjw8mo4EVxgMgtvpGIlSI9laRTMHNPNnUk53WcKIwUe4neInIZWtCkEDQTQbvT8sbelLeyoz7XtwhKb3r1b4AdvWY3KSnGFesiCUS9TQAh6VUcwhqmWlkY7PIKXALIgD85qiYU8gZGWJbuokcZQqg3JAMnMIk1mBp5xTmEi377+yWyJVM+EP3okl217rtT8zajtAa71mhLLKDSK3AJ73vIuNOSTjumLzBL+dIBsX8R65zEqTnndjpHSrelQQqhixIc/8d771fGQezJiix6/Y4EZWoLjqsx7dKQLcGsrhkHjndW2UA6A+EE69RQOoFQnnxUkWiLdZJFmbJapPjzjXMYP20xFw1qHfDx3VSgyzQuUzQjHQRhZTiZ9Sr2+2Nb1Mw9aSqZjid8DRilNXtZpGSLV/EFGa2XLJqUH5wesH4yZvRcMnphMfM2nFTXpBdD61iPhqdzR1E2jHBk40nLcCJI66lPVcjf00CG2uYavSZOzLqIdbDhztd1DfJkw3TUneSXxoSv074cmsIzkSUXLru2HuNVoPaTtccs2s0Mgd4uym5ZK1iUKcflmAOz5N3qBi/k7tZLbpsZh2rBHXWxpd0xpOsfPja/9FgiLe1lbQ9nmLuM765u8Xw+QaxVQGOuooOv4zkxODe32J/kZtS7Z7RuoGp/OEj8dbavCu67BXeTGUmyfY2I1iEXNVqIH18kJbDFjjSNmPPHs13UTKEXoBf2Ks6ceJKtIoTPR3XnlcRmnlWpKIsE7wR+pVFzRXYmyI8jscd5HTgDu4LYTko7NizuGqo9QVvQK14n84CuS2c+gKp8YA1GBEWtabvDNLcc5WNGeY2UcczWSdaVoV4b5FHK6EgwfuxIpm0I6a298p0uW3dn7ScYdTfKGp7vLlhV+w0zUWUj+i9EQm0WcmO9dn04LxoXJd9iUVB2/Iiqn7sIgKgPWJsTNFYxd1lEdHosom85ntkRK5ty0eZI4RhnFctxTjNRuEREcaJO2IZtISFBz7eQzATLSc55kfMi2dm6+49VhZG2R7UeqMVHSic+ijVec1TvMGtyytoE7Moq3rCGM0KXOlCiDjJ4Q96LEO2BbAXrVcp7632e5Pu8qX94To/OUhEit7aVbJW5vUfYjqXq473nK+MgJL6na5u6lCftPl+/uMP0bEx+JsnPHOaiDmPE6zowAXfmO0Fch64Czr7eieHvSoDUcWZfYOaQnzjy4xA56ON4YKJwTzMxzN8wzN6C9nYV+Be1o6415TQhOQ1kH8VxuPuadfhMvCA9D3fotki4yAtcFlupa4leC4q5iLl+SzJrMWfrgHcYAG4gFGG9Ulf1Kp1HLqut17fFkG9gMzoOsTi2bgOqT4CJBU8dRYBFY6Fpt1CBfpT1DqKz6+YQVOnQRqBKiahD+lY5w6krMMLivKT0oWh7VO+wtClndYGWjr1szVlR0I4MTSFJZh8cdgsXGK1sKmlzw3E+QQDTLGdsQipaGc3NZMFJO6b0mjfMGSP1wVyfQ+Gfl1nlNVU7Di3EOqOuDLok4GFWDrUecF5cinzENY/1gLsa2qXhnYtDHo8PeGGOeKA9P2xM0XjLiTU8r3ap14a8jGLArUOsSnzyh6Ss9UdhRsCedJw5xdSlfKV8yO/NH/G1Z3fRz5JAlz6LcF7HNhrM+0A8Cwir4pyCCiO/1eaA4LuD6kmnbXA2seaAEDijaA4Kpm8lzH7SUTyc85MHZySyxXnJWVkwK7Jw4SeBlTo7CQhBs7QIJ2mWEpuEiMPmMqQrPoTzeg1mZTGrkG93YsX9zEI3w/ABJvxmgtKnZqNpGVudstlED3g2GgvD93Dx87ooREdHOxCD7RmW1bZz2BIq9p6Ogs8nsR3qZV/Ia7zmSbPPs2aPdWwfHiQrGqe4qANgSzZsFVqH1g2DhTVvlNrTc8FqlHKR14yTCucFE11xaJZRyGaBES0WgR30hs9swc2BpkdYo+JJs8+ZfTmWooPSr2wg5LVrRboWIT1bXCKkfUn43h0HZwTIqLS+EOgzzfPxDt/du8Vn0hfc00+5/0MO2jkcT+wuv3f6BvI4oThxmHmDWFchIjN6a08/qr0SDsJ6z5lTPGl3eL855IuLN/i9Fw9onxRMngqKI0syq5Grik6jAgC5TRWn1m3UWTCoWuIvBsXFWCXvKMrEsgzOoWnxRYYrEtY3Dau7nt1HU37u9hMe5ac0XrGwaRBKSXJS03Jsd0OoWYKqOxUoRxKhw86Iwckdi3BlyFVlG0hhcAS59m59VR24Cz/g3BCdoOslgZdOgEe020U+H3PODzwpomNwsd5gU3UlEulfGucugJ78xCvwJnzmaTPiSbPPSFZYJHOXsbKB+j+VLVI4GhTWS9rSkDWX1MSuM9+R1QgSLbCJoDqQlOuEeRaOi5a2Ty86O7XjLWHh0huMaJnIGoVn6lJO7Zh5lCoYFlO1cGhpyVVDJht21ZJdndM4Ba3ELALSVM8qRNngjQYte/j1h5mqQ0TUjAXrccZX9+5wO71gIteUZsoDZSJS8oMdhfUOh6fyDe+3jq+uH/L+i31GTyXZSYU5X0Nrg6JXol9e2/kAeyUcxNIn/IPF5/j++ibfubjJ++d7lM9GjB+HUD652OAEuouoa91cZyKO54pu2Cr21mUUSR0eRJ+nuN2C8kbG8o6ivtHyU3vn3EgWFKrivBnRRkWksamoUs1ir6RcK5oLRTIf3lVjl6PTS2zjmK8NDNmidaHo16//aoh7XT2il37vLuTIF+GF6PUhZHmVKCTwaRJeO2BQGlqnh9pZpxGC9Fc4I4dm09DFcBpwgkWVcFRNeJbs8SA5IxMNB2rBJCvZN0sap3EInle7tE7iK8k1XDrXmrA+zDpFUJyZS8pFgt2V7Cdr7qQX3DVB0MciWbmEb5d3abyidIYDveSuOWfqChqvt1CVe2qF87Ln8ACYmIB7+Fz+mB1VcmEz3i/3eXK2S/pCM3rhSM4CTVwQ2Q3p4GUpvQ8y2XrSKSAUL9wNfqNKeHF3h58YPedP5D/gjyXzDxy2CynFmqmTPLUTvl4+4L968VOo9zOKI4c5LzfOoUiDYvkP0UB5JRzEeTPiN57+DEcXY9anOeZMMz4WjJ478uMGPY+kpKbjibwkpqLlBkIaSUZCuD1oIbrAYdg5FpEYfNRnaMeGekdSHUByUPJofMrdZMZYlaxskHUf6UBGI3OP84L3SkN7mkdIa0DOdWF+Z2rdopZVJOyIF34swF2pL3TWXsMrEJXEfaQS65S3OqfXSdiH51Tfduu0PL0KpCyyCTnp0AKfY+BuEHEGxHmJkGLrfLrcggwMXyoQDLeCdZWwaCLICHdlcK3xiqktaPw+yzpBLRSqHKQtkdD22mgnHk+9djglSC4E7ZnmYj9juZv0aYDCYQlj+OdNwVkz4rwqeGN0RiGDAthw3B4CR0chqy0HAaHoOYoe7HvVbb58eo/6RcHuC8hOmiiG4/BJEnRDjQr8oYne3AiU6IWCXSL7qCyQ0wSCItkGItr1eo//ep7xrVu3+O7+Lf70zvd4O3mOEZaJaNiTDgusvKD0imM74klzm2fNPt9e3ubr57d5/s4he08E2VkbJAa0wptkI+v3Q7RYXwkHsVonPP7KHdRKMJ4J8hNPftKSzBrUog4VduKsQmquhkrqsuSYi+PH8fdyIKseHYsdJWF4RkuakaaeCOp9x62dJXeTGbfNDOtFf3LfTOa97mYiW6arnJXJ8AraQob258A5yHrAoyDBy49Wfrqsg9CDloaPtw5lu8jhUljb07UFeHabRXp1ATRxhDoWeoEgR38pLBZGbe1pJ+Qia9s7IplpdOWC+M9UUo4SmgNFKkNY3imcAdzRU07tmLN2zIv1DuezEcm5DNHXsJw0jGTqTSTVk73a0DlIpgKbCpanOd/PD7mVzpmokpv6grN2zKwtuGhzzquCszKokh+aUH8oIuR2uL7hmP6qTRjpGodgagtKb/id00c8f3zAzvcVk6ct5rzc1B60jOK+kp5Qx/q+XeuMDOC2zme3HulDXcVLj6oCAa1ZCuqTnCd3Ux4f7vPP997g1njB3eKCt4pjHiRnQfOl2eWomXBUTni82ON8lbM4K9DHhr33Bbs/aMiO1ptCdieQPDhnPo69Eg5C1oLxu3KrN5+eVaEC27W/OjTYpbkE0Vyfw25xKWSbO+/WbAWBuq4ZSZqRwO/VHOYr7ppzMtEwUhWN16QD1InzMjBTK9eH4KoKQryydthUbe7s3d8UydZndxTs3Zqa8XZ+GMhK2hAMdePCA42IsGeRWabDT0jZf8+uGHWZ0r1//47BO03wWYzGYoTlcrOlDRocSkzP6s26VdmiV+GY6aWgWWmOFmOO9neYyDIogXevjV7gpBlzvB5hz1Imp578LPBNDvdjswfDgZOu8h/Yq5Olp70QmDPNSbrDP5dv8Hyyw0+Mj3BeMG0DSUyiWgpTM9EVDsG+XlLIGoW7ApDqrPWSWZMxb2/zHW5xWo749rt3KL5v2HnHkj8vwxBZGiIHW+jekXoloKFXIm8KHcBdmUSXriffpfFbE6wQalmilchaUl1kzNOUab7PtyYtv5V/mjyv8QR2tGZlAhZjJVFrwc55ALuNjlrSkzK0V7O0T0m74/hxW5zwijgIVcHkfYte2b4yHERz6QVcEaKnn7cd/VrlgpDp5dCp40esbCC57UA/WvQsUarcRBhehWq8yRsO0iVK+H50+46ZMonFLucDFPy96gDXzw0QgEbLJt5h4zj2oGDlpQjzDD1TtkCtWmTZ4nYUNpeUu6o/aZKFQ0aSm270fEhjvmUd63K3P0mnEC3jHMAGtCMrG1qoQiCkxGc68D9CSEvEZn09QCqmaR29PESn5Tx60ZCfyaD1UEjmeznfuLhDKjckOp0dtxMel3s8P9klf6IYvbBkR1XQtOgo0QbM0C7VG3Ha2K71iQwcGQJyGWDnlU14vjrk9GDE8/0ddtINQE3iyVQbeEqdiQxfinrgHFykCiyd4awuOF0XPGsnOCdZlQn1eUbxrmbnHcfonQVqtgx8klrhpQmOdHCxd/vWZop2FDU9baxNRUbszvnp5ebG04wNwmt0JchP4tq0oM0NbZHQZKOgm1rCeOUxkfHLLENXTC/qcIyqNqxNy40qfLuJwD+uvRIOQjaO7LiKQy11pCWHTuOgQ6G5VPWzCN1cgjNyi6U4iIrEvnTs+285Bx85B+wHV/e7k2gkakaq5tSOe9jN2hqW6xS1Cjlkp9ch6hY1uMv2Wg3Eu7YWg3mKINW+vpGwuilZ3xFh7qIBdyRRtUJqgWxkYHVyni3yvHhRudz0UgDdmLFwgQkcAOu3UH0i6ib4PAmttygAKyKDUxCWCROJ0gYAmCpbnDQh9RBiK9qRTRyBn0nWz1K+JW73e3QrmfedhW8s7/LNs9uIZ1kPMZeN2xzr7mvFSLFTut5yioJepi6ZW4oXYBaCeqqpz0Y83svx2oMJUHiZWKT0pFnDJC/ZScI8zs1sQa7qILjcppTWcFqOOJqPWZwW0EjUQmGWgt0zKI4cxYuBdkWR0e4V1PsBLt51qsKGxE6QErSpQFcevdzc+Hq6fet7+n6fGlRp8TrIFobnN8eqzQRNEcSLzMqhly5KANhIwwiyasKxScNI91CPI7TSCRQIP45AKWHjtBuxaKYjhgA2FX99veiHVyFMV2XMyRvbzym4GNY7s4EjCxtg0p2DcCawEA/bekuX0vh9jLDsxd5511Ofu5x3FwdUFyk7qw38W5TtFb4/n5qIywioxiEzVUA+KuqxpNkR1DsuKlKJwJJlxFaV/zLEPHz3cIcagpqkHehTQOjNt26DlGwtPktxiaYdadqRohN+cUb1zgEJTgpUG4R11brdsFjHYxT4Gx1mJUmnHpdIKp/z9fYuLw4m3J/MeiDTd6c3OH6yx/hYkJ9Y9KKJJK5VCIdlLLBK2adjvXMQIXx30cEKG5x8biGdCeyZoJpI2pEKUggyjJB7Cd5AlXlWxZjnmUOkliRvej4QgLoytGuNvNDkpxKzBHPhSZaOZBZa7GpZh7UaHejvRpo2D4VHfQ0FiJcispWHSLdnoIq1KFFF3ZCmBSEQWqIqi6xjZ8pubnQ2N7QjHQR3BkpiQ4VwIKxNbRCwQxPe49uYln4MeyUcBGyq+k7LbZbgj2CBgWhTgAnjtps7odcxcmh9n387E51HIrDdSWUlqzbhqNlB4jGyZelSRrJC4bhwOe9Vh7xzckDy3GAuQs1EVm04wdOu1qH6YmG/Rhdk4oD+orap7E9oVQlEC2otrsw99O9xSTui05XorHMOsm43LWApQguujOCoNIjMNGPN+jBcULr0IBSy8b1zGNqWbgUgy7ovFqtE4taOZB7WoZeCZpox3Uk5OdhFZvE7XyQUjxX5C08ya7eKkOHLhXVecQ7xeHbpWa9jWVlUJ6S0EKTng9kQEfAZLkaN3R3YZgqnDS7J+vqRMyHgyNehWJidWZJ5wMvIJqRkQbEqhumpxo5SbB7wIoEqINLNDWsKZaRGtL6nLxSt4zr0d+CoDN9ZVTY4o3Xd42TEbkgvZNWGNKy1PfK3f49EX4nurnzGsNv3Ee2VcBDXIf6Gdrk1t/WcDWGuaF2YPDSDFKRzDv37XMIAqO33sXPDexf7ZKrlIFkGyHAiSUyLEo6jZofvzG9SneZMzgTJ0mGW18i7X3IO0BXdfLe0qLQURHC8It456IVyVemuOooORSk22hGdDSMH0boQdYkQpovWQaIQPhR5qwNDNZGUN8KFZFcCcKhyu9ouYnoSVKyGw0eyj+i6MXRVe9ILSBae5kLgj6DaNaH/DpgLSGcBZq6XA5m9NMHnUeU6FqAv11pE65HR+Xep0GY2BYipvLyk7O2SEHnaPBIfmwC02sJ3dN3xJhbILyKVnHObO7zRPTjPZSYodXkwiyifN9DN8CLQ6TkCW7caUs3HmYjOvBCQJ5taC/TTxKKsAsksIIosPhaiDcxmiM6nJvBLRMh9F31cZ86oj3XjhY/gIIQQD4G/DdwmnOG/7r3/G0KIvwb8L4Hj+NK/4r3/L+Pf/AfAXwQs8L/23v+DD/oML0VQOybe5S9dGELENk3rAN1X54UNIVdXyNvSzxykFUPbxgJo3CRI8ekS9ExzOhrzPek4ywru5hccmiVzmzMn53m1yzvTA5IzRXbmAy/hrLo6G/KyvWximzDmiHoN+Qkk85AGdXUUs2iv1TXo7g5D7QiIGIUYOVxWI/dSgJGBh9OEMLyaSMpDQXUQnJNTAlkL9Dq0aztiWWF9P8gmylAs9omOUZ6gE7cJ6NVO2NcGUtfa0Yw1Lt3k1HplwxzIapM7deQqNtfXFmG79AzAJ/JaGTlRBQcmVqGORdOGvD7Sy+PDHd1m24LBeh33KjrVwCoe+Rs7U6Ge0EVMbWGwqSSZN2HPLw3beaVw6H7cf0uW77JJ6PRDRB3EneWqDo5hiIMpa6QOkZ2/hHb6oL1jAKDrkJQft5HxUSKIFvj3vfe/L4SYAL8nhPiH8bn/s/f+/zh8sRDip4F/C/gccA/4R0KIn/Dev3xkUfJSlFfgnJR9ZNAXKQGGz4nNc8KG57rd6E6EIVS4f3/biaSE/L86SzgWO8hDz16y5qiZsLApp82ILx4/4PzpLuNzQbKwmEUT8nsb+AbRm1ZjlxvKssFlJoT6RuESHQ6oDLJ1ASjj4rAZdEpPl6nmL58EQ+2Ibp9eZh2E2mabC7vP5RsRxr/XoSou+s+Pex/bns3dMe1I0RQhlG8z+uq9bIMkoKpD+064iMKUUaS2jndS6xEdr6Wkv+g2yuV+a80Qo8tch5TEEWjxhx3Qxm45RTfO8EphdxKasaaJa27zeDElca1rT7L0mIUjmW+UtXFuqybislBM7jQ2bSZDAbF2qHkV0oDEbL6Ds0jJtSjfK+jfToZvQH7b7YHbKWB3hEs17TgJN9BBdKfqUKTsWueBif3SJSbFFn2h8Jfdy4fbhzoI7/0z4Fn8eS6E+AZw/wP+5FeBv+O9r4AfCCG+C/xJ4J994OfI7oQApN+Eko3DJ1c3u0stulRiK2+OUmoi4vzVIPTs7uBeS4QP+AWvwl3cJgIvJbVIOEtGGOlYtQmtlzybTzh7usvoHU3xwpOdhgMrqhrqBqEVzmSDzwkYDlE2Ac+QaGxuwkk7UTR5lJBfOpSkL7KqVYMtzBYT8hUqdS367+slm4GnTnuhfyHXzmJ0eqB6KVBVmG7Vaz8o9AaMhxvQylU7gnovXGg299g4oKVqEZWqgoOtR4HCz6zD4NiwBScXZQintcIPaMeF91ewEDbTOC02YkVChPC73VxEnXMQdajgkybYcUq9n7C8rVnfFDRjj809LvWhw+FBNAE/kE4l2bEItYJ1i7Tbd26Xa9qx2QgouU3UqpYVclWGlmdrQXeSXCqgYYdkw90xuZw6dWlT027hWUgM7U5Gs2Ood6KDKzZrUHXoHKUXQU9Er4KqOK17OUKXWOj+wwRKCSEeAT8P/A7wi8BfFkL828DvEqKMc4Lz+O3Bnz3mgx0KEIg8AaTpwl2LR1xxDl2RUcWiZJtt02h1jE/CRnn4SxsSBFqvXjCqCtOCLhEIp6ibEe9OM95LIgPTOqgp50eedB5AUQGpFiY73TjdLhqlqs+NvVG04zAMtryrWN3xuMQjWkE6VZiFwsxjQatNcDqeiGW4aJNZHWoC8dbpXbg9OyNwqUS2G+n47bmKIA3fzWJ0HRyzDKpdJjJq5ydtbNcGartmYmgLyfpAUu0Jypue9lbNaLdkkgZhok40SytLaxWLdcqq0ri1RqwlZiYpnmuKI0HhPDqyKvk8CXfmXG/WFEP8eJJtUqm0Sw9cHymqso0XuQ01h9idsQcjqoOU+QPN6q6g+lTF3Tvn3C7mjE1gKzuvCuZVStVo1pVhOU+p9g3N2DB6rsiPE5Kz9fXkPQ7MKkQZatlsopbE4LUKWJ1u/YPBKKclbjy4i3fft7F9aoT3Pf+nnWS0I83skWF1V1DebVGTBm1avBc0awMXmvRUkb8QFCduqxD6o7aP7CCEEGPgvwD+Pe/9hRDibwL/IcG//4fA/wn4X3yM9/tLwF8CSPK9AYgoPG+t3NI27OoS/ayD3xTShtXjIOe+aXd2+IlONLZvl4pQ5ZZR8UmXAA7hJe1aoFcSdyzx0vSj49mZp3jRRge0AQ35JACOQh/bbz2HlNT7KeW+ZvZpyerNlsmdOUp4WidZznK40JjZJs8SPnQzkhmBt7JUG6q57q7TbnAVdEXLgXXhZti7EIWFvfMoLchsB57ymHnTz2w0k9B6Xd+UrG95mts1B7cu+MmDY25lAdcwbYp+OjOVLWubcFSNqa1mVmfM1hmzWcFKZKhKks4UKtGIxvTdCpuHU0+2IT1THZjnUgx8uVDrjQwXVjd0Zx0+TyhvZswfKOaPQD5a8Mtvfp//wd43ecOcIYXjabPPN8p7vLc+YNkmnJYjpnnGLC9YJFk4L1SQz9OL2LnwHWI1tCDVot6aq/FagZIhjO+mYhMV25nh93akt85hFVviclHF2ocNDiZGmKs7Kcs7iou3HOkbc/7799/jreIEIyyNVzwu9/nW9BaPX+zjdIozgdrAGYlehmnmy7ou/yL2kRyEEMIQnMN/5r3/uwDe+xeD5/9j4P8df30CPBz8+YP42JZ5738d+HWA0eFD76LHVc4HNaYIDAnjwGILJNSnDB706hpSEB/bpZmk3tU9yES2HtshKePwD41HdqlIFRiZ2lXob6t6+JmeZN5sThIf81Ud8uhe/6Bxvehvh9Ff3jYsHgiqz6/4/P3n/LGdpxhpaZzivfUBjxd7nK1yUm0RwmOdYHYxonqa4Z5KkrnuI6NOvzKsN6QCXgj8JR1Rr0S/T53WRP9cBzGxPg5dhbSlLRTlvmJ1R7B8s2Xn7pyfu3HE5ybPuJtMcV6wcimpbKPWaNifbtCpchotLZOkQivH8cJQXWjqc4VsDKZqeoSk04OWnAevNnfZrgXapzwdz2MS9lNiwyyJ95AmNIcFy9uK+ZugP73g5+895l/d/wZ/InuPe0oxdy2ZaJjaglkbxrZT1ZJoy/7OioWxLBnhhUTYhEKAOV2h1oGK0KsY6ayqTaQAvXPoOkY2D2hZvWxBCdpcDzplAhURwnJeIpYRPCFl4GooDNVhyvwNxfwzlrtvHfPLd77Dnx5/h7fNKQcSzhy80+zx3+Vv8dvpp/iavYdLErxUZGeSbCpRa4u2gSXMfUBn8KPaR+liCOA/Ab7hvf/rg8fvxvoEwP8Y+Gr8+TeA/7sQ4q8TipRvA//dB32G1/TFo/4xGQpJ11lHpHq56NgV8tpCUe1K6omg2he0hY/6ERKb+E1hbqXIzmP+HZ1Ep1il126LLKWbDB1OTfpYfAzrHXZQFF4Lqn1DPZbM3hLUb1b8yTff48/uf4tHyQkSR+kNY/WQg2TJejdcIHtmxUk95mmxyw/kIUsK1DqMlWdnIFeDUDLCva+1gb/wSvTgGVnavmYh2nCn84mk2g+tz+U9wephy8GDKQ93ZnxqdMoNM+8FgfbUilQ27KlVX6nveBeO6glzmSJFw41iyXSvYHVXotYqOqViKxrsC8uXvoNSAbfS/euJiQdYDJ8moATVzYLlvYTlfYF7sOZn7z3hzx58i8+nT3hTJ6TCUPolSaTCVzhKq7Eu7MdevkYry/NxRhtncpqRxpzSpxrdfnWsTC6LqFLYng8SwdHaQvdcGd1xUqVFrergHFobOiVC4HdGtAcjVndS5g8V87eCtsj/8P5X+KXRt3ioV9xVOUYo9qVDcc5Z+oLZTs70bs7zZJeVyHCpwCtFehHqNmr5w1PpD034DwlFhBC/BPz/gK+wgXn8FeB/Cvxc+Pq8A/yvOochhPirhHSjJaQkf/9DPuOYIGB08kN+jz9Ku8GPxzrh9Vr/sOzHea1veu9vftQ//lAH8UdlQojf9d7/K5/0Oj7MflzWCa/X+odl/zKt9eOPd7221/ba/qWx1w7itb221/ZSe5UcxK9/0gv4iPbjsk54vdY/LPuXZq2vTA3itb221/bq2asUQby21/baXjH7xB2EEOLfEEJ8SwjxXSHEr33S67lsQoh3hBBfEUJ8SQjxu/GxAyHEPxRCfCf+v/8Jre0/FUIcCSG+Onjs2rWJYP+XuM9fFkJ84RVY618TQjyJe/slIcSvDJ77D+JavyWE+Nf/CNf5UAjx3wghvi6E+JoQ4n8TH3/l9vUD1vqj21fv/Sf2j6BF+z3g00AC/AHw05/kmq5Z4zvAjUuP/R+AX4s//xrwv/+E1vZngC8AX/2wtQG/Avx9AqTnTwG/8wqs9a8B/9trXvvT8VxIgU/Fc0T9Ea3zLvCF+PME+HZczyu3rx+w1h/Zvn7SEcSfBL7rvf++974G/g5hGvRVt18F/lb8+W8B/6NPYhHe+/8WOLv08MvW9qvA3/bBfhvYE0Lc/SNZKC9d68usnwj23v8A6CaC/9DNe//Me//78ec50E0vv3L7+gFrfZl97H39pB3EfeD9we8fafLzj9g88F8JIX4vDpgB3PYbmPlzApnOq2IvW9urutd/OYbm/+kgVXsl1nppevmV3tdLa4Uf0b5+0g7ix8F+yXv/BeDPA/+uEOLPDJ/0IXZ7JVtBr/Laov1N4C0CZP8ZYSL4lbDL08vD5161fb1mrT+yff2kHcRHmvz8JM17/yT+fwT8vwgh2YsujIz/H31yK7xiL1vbK7fX3vsX3nvrvXfAf8wm3P1E13rd9DKv6L6+bNL6R7Wvn7SD+OfA20KITwkhEgJV3W98wmvqTQgxijR7CCFGwL9GmFr9DeAvxJf9BeDvfTIrvNZetrbfAP7tWHX/U8BsEDJ/InYpV788EfxvCSFSIcSn+AgTwT/CNV07vcwruK8vW+uPdF//qCquH1CJ/RVC9fV7wF/9pNdzaW2fJlR9/wD4Wrc+4BD4x8B3gH8EHHxC6/t/EELIhpBP/sWXrY1QZf+/xn3+CvCvvAJr/b/FtXw5nrx3B6//q3Gt3wL+/B/hOn+JkD58GfhS/Pcrr+K+fsBaf2T7+hpJ+dpe22t7qX3SKcZre22v7RW21w7itb221/ZSe+0gXttre20vtdcO4rW9ttf2UnvtIF7ba3ttL7XXDuK1vbbX9lJ77SBe22t7bS+11w7itb221/ZS+/8D3iYZsx+8YM4AAAAASUVORK5CYII=\n", "text/plain": [ - "" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -52,9 +42,9 @@ "source": [ "# load data\n", "image = imread('https://samples.fiji.sc/blobs.png')\n", - "blobs = cle.push_zyx(image)\n", + "blobs = cle.push(image)\n", "\n", - "imshow(cle.pull_zyx(blobs))" + "cle.imshow(blobs)" ] }, { @@ -62,27 +52,9 @@ "execution_count": 3, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:252: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " warn(\"Non-empty compiler output encountered. Set the \"\n" - ] - }, { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -96,7 +68,7 @@ "source": [ "binary = cle.threshold_otsu(blobs)\n", "\n", - "imshow(cle.pull_zyx(binary))" + "cle.imshow(binary)" ] }, { @@ -106,19 +78,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUMAAAEYCAYAAADGepQzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAA0K0lEQVR4nO2dd7gdVbm43y856f2knhSSUEOHSBXBgCIIeCl6I4gSijfIBQEpElAERDBIC14xEJWmmJirVKVK+aFeKQkllAQIJCEJKaSQHtLW74+9dzJnnz2z18ysmVmz93qf5zzn7Jm11nzHQ16/NauJUgqHw+God1plHYDD4XDYgJOhw+Fw4GTocDgcgJOhw+FwAE6GDofDATgZOhwOB5CgDEXkaBF5V0RmisiYpJ7jcDgcJpAk5hmKSGvgPeBIYB7wCnCKUuod4w9zOBwOAySVGR4AzFRKfaiU2gBMAo5P6FkOh8MRm4aE2h0AzPV8ngcc6C0gIqOB0QCt4HPtWreO/dBB/dvEbmPuxxtj1R/SNf7vUc7slZuNtwnQu0OnRNoF+GTdmsTa7rPdHkbbW/zRW0bbq1U6D4qWO30ye+MSpVTv0ucu7fdQm7as1q6/fuOcJ5VSR0d6eAiSkmFVlFITgAkAHRsa1LCu3WO1d8vVTbFjuujqBQzrGq+N3x7VJXYc5Xz3yVXG2wQ4e68DqxeKwZ3TXkqk3XOve8p4m7efu5vxNmuJA8d1jFz3jlFz53g/D229mMf2/rp2/UEv39Er8sNDkJQM5wODPJ8HFq85HLE493b32jnvrF4/kBfeuSlEjTsSi8VLUjJ8BdhJRIZSkODJwLcSepaxrNAE331yVSLZoWmSzgodtUOcrLASi9t/wv/sMl6/wlSjj/clERkqpTaJyHnAk0Br4C6l1NtJPCsupiTocDj06LJlESPWj9Mu/2JyoTQjsXeGSqnHgMeSar9EnKwwDyJM6n2hoznn3v6Oe2+YEgMatnBdj3Xa5ccmGIuXzAZQsiZJEZrqKjsR1j7vTv/q1p932fXxDCNJjzfWtaLpzTBd72WJxeIl1zI08a7QVpwIaxevACtdt0mKpt8XAgxutSM3dfyjdvkTV+xrPIZK5FaGtneP42SHToS1iZ8EK5WzSYim6dz2PQ7b/gj9Cim9zcqtDGsVJ8LaRFeE5eVrUYqr2u3DM0NCzEH9VzqayqUMbc8KS5TEppMhOglmS5KDJ2FFWKluLUmxw6pX2ftZ+6af5VKGecMrupIYs5Sfm2Po0CGJ94UAiwc0MO6aEItKRs2tXsYAuZNh3gdN6ikDPHuvAxNbkufIL13Vzhz92QPa5cezS4LRbCNXMsy7CB3xuf3c3YwvybO1i1yrNKz7gO7v6K9NTotcydDhcOSfTwY0csf1I/UrjEtnV6FcyfCiqxfkZvDEkdyuNSazQ7fqJH02zVzAiq/9POswWpArGdrCTvcVFgi9f5o7zSAJFi5vuRq1X4+DjD+n1kTY+ZJ5vvdW3zQwdHsvXbg2kUGU/uzJVfKkdvnHSOf1mJOhJiUBVrrmpGiGShL03vMKMW52mCcR6kyrCRJh6X4UISbBnA5LOXu33+tX+HtysXixQoaDu3UCjaNYsugiV5JgpTJ5EuKd016ybmPXIBE6gqkmQttYJ72Y1uaMEDV+mFgsXtxRoQHoiDBKWRvI45QXU8KspawwbyIEaL2xga4fN2p/6SAi3UXkzyIyQ0Smi8jBItIoIk+LyPvF7z2C2rAiMwS446v7873HX0mk7ShZYd7kZhNpibYkNd3uchgJzu35vO+9QUtHaLezy66Pu+k1ZfRZOZ3vPneAdvlr9YrdBjyhlPqGiLQFOgJXAM8opcYWjyseA1zm14A1MrSJqCLMW3e5Vqj2/tCUBIPKhBGkLjZkhUkMorTq2YNOp4WYZ/iL4K2uRaQbcBhwOkDxRM4NInI8MKJY7F7gefIiwySzQ0dLknh3mGRWGDSibKLrqyPCKETJDpNYi2zNIMr6DvD2nmFq9BKRKZ7PE4oHypUYCnwC3C0ie1M4KOACoK9SqtQtXAj0DXqIVTKsRpR5hm5uYTBpDKbkgbginNvz+cDsMIwQTYweB9XLWogruy/gyRND9L7+xhKl1H4BJRqA4cD3lVIvichtFLrEW1FKKREJHKbNlQzrnZ8tuASAHzeFOVmsOqaEmFVWGBdTGaEJIdbS7jR+tP10M0Mf1N+9+rnqReYB85RSpf8A/0xBhotEpEkptUBEmoDFQY3kToZhssNayQpLEvT7bEKOcYRoQoL9ehyUyfSapLrGflQSYlgBpj2CHPW94UsXrq14fXCvTfz6LH0Z3vW34PtKqYUiMldEdlFKvQt8CXin+DWKwjEqo4CHg9rJnQxBT4h5FmG57HTKmxJiCV0xmswGKwkxyYwwCaplh5B99helqxxGiH4SLDGry1C+c/j/hHj60TqFvg/cXxxJ/hA4g8LUwckichYwBwhcEJ1LGUKwEOtJhEnhJ7mkt+VKU35JZYU6Qswj1YRYTYIlui5QHPWzjdrP/V+NMkqp14FK7xW/pPuc3MoQKgvRhAjfP21MpOk1cafVxBGhqeywGnmcrO0wh1d4B47rqC1AL8vXtuGB1y0Y1S4j1zKEfGeBXkxkhGkJ0eEA/UywnG4NKzim51+1yyd++HoRq2RYr3MMbeka1xNpD5w4tvHxZ7350ayzQ9S4MrFYvLi1yT6E7fJG7SKbFqETa+2T9TzBuLRaL3Se3qD9lRbWZIZ5zgptEaHDoUPWMu00cDkH/egh7fJ/CZNExsAKGc5ZsYZhXbtnHUYLog6kOBy2krUIARobuzDy5EO1y9eVDG2mlPVVkmKc0WOXFTrqle6rlvMfz+qfjpcWToaauN1oHLqkMcdw9U0DQ69EsSErBHin+wL2PeGarMNogZOhw5FTwgjRFhECtFq0M11vvidEjXQm4jsZZoDrImfPoKUjEplek/bKk5LkKkkxrAB3/PD+rT/P3P7UeIEFsLbLu0w54vDE2o+K1TK86oALKl6/5uXbUo7E4bCbqJmfV4CVrichxZ0X7MWEnz6tXX4EfYzHUAlrZegnwtK9vArRZYX2YDo7zNt6ZD8RlpcxLcT316zj6CnpHAwfBmtl6HCkgSkh1qIIk6KpRwPf+3pP7fI/SSnvsVKGQVlhnnFZoT7Xv319xetX7H6F8WfFFWKti9B0driyoT1P99nFWHumsFKGjvrET4C1zt9eG1/x+rH7nmP8WVlmhFtjaPcmj263k3b57smF0gzrZJhUVtj04d6+9xZs/0Yiz/TiskJ/wkjw+revtyo7jJMV+kkwKeKI0GR2+Na6oQx7O8zvrr0lYSysk6FpgiToLZOGEB0tiZIN2iLEPInQJjq3mcnn+5+oXT6ttSo1K0MdCVYq76SYHjZ2i72CM3WQfDn1LEKANsv2od/EMOfdtE0sFi+xZCgis4FVwGZgk1JqPxFpBP4EDAFmAyOVUsvjhRmOsCKsVDevUszL5q5xRViqn0SGWCKJgZF6FyEAnd6g1f4hjvz9d3KheDGxn+HhSql9POeajgGeUUrtBDxD2fml1dCZPxhUJo4Ik2gnTfIiQpPYmF36EVaEpsUZ552f0bmG7begdlul/ZUWSXSTjwdGFH++F3geuCxMA9e8fJsVq0/y9C4xTyLMk8Cy5m+vjU9kVDlLuqwTDn+9nXb529mQYDTbiCtDBTxVPKn+TqXUBKCvUqp0MMlCoG+liiIyGhgN0KZVywTVKz3dFSdJZHOmhPjjppsSG1HOkwiTIKkBlVpk5vanZj69plOXRg788kn6Fe6YkFwwHuLK8AtKqfki0gd4WkRmeG8qpVRRlC0oinMCQMeGhoplSuR16V0a5FGEV+x+hcsONUkiK8xaiB9uGsjIpTeGqJEDGSql5he/LxaRB4EDgEUi0qSUWiAiTcBiA3FWJcl3fLZmh3kUIdRnNznPAyem1yZv6qlY9i39c5OxfadrEekEtFJKrSr+/BXgp8AjwChgbPH7wyYCrRVKAosjxbxK0GEPWWaH2y+ewX3jD9Quv3+CsXiJkxn2BR4UkVI7f1RKPSEirwCTReQsYA4wMn6YtUcUKToJ1hc2DJwksYXX5vXDWPHWMyFq9DIeQyUiy1Ap9SHQom+qlFpKWutniuRxGkwJXSk6EeYXW7vI1bLDpDZ4ndl6Ecc3hnlnmA41uwLFJGlMr3Gyq01sFWGJJHe09qNbzwaO+nZv7fKTxiUXixcnQ4cjIeKI0IYuclK0Wdmdvk/rr02G6q+STKyGczJ0OBLA9owwS5b2auCe7zbqV7hcu+ThSqklns+l1XBjRWRM8bPvAhAnwyrkZQVKHPqcP6vi9cW/HJrI80zPM6y1CddhssIrRjZfnXH95HQ2NYjDPtPWMmXQ69rlJfqjQq2GczKsU/wEWKlMUlKsVdLICsslWH7dZimu3xmm/2aLfoXDtEpFXg1XwsnQUZU+589yQkwJnazQT4TlZWwV4vR2S9h/57vDVOklIlM8nycUZecl8mq4Ek6GAdRqF1knK6xUx6QQTXWVbesiJ50V6ogwDZqGrw28v+DVjr73eswfwvGX/0b7WXfxhyWeXbEqYmI1nJNhnRFFhEnh1ig3p1pWGFaESWSH1SSoQ78Bb3Dx9frnPN9VJYk0tRquJmS4YPs3cj3xOi1sEmGJOEI0nRVKnz9s/Vkt/rbRtuMSNSM0IcQoAmwavtY3O2ytBtNjww0hWvvPagWMrIarCRkmQa12kW2kJLUwUjQpQq8EvdfCCtFNp2lOSaKvla28W7temDrdnHpMrYarGRmazA5rUYQ2ZoXl6EgxyWzQ755tWWKamOgWl9NqdQe6/Hsv4+3GpWZkCGaE6ESYPWkNigSJsLxcPQoxCRECbFkkrLzZPvXYF1FM4gixFkXoqIyuCL3lkxSibcvvkhIhQJthaxg0+WX9CnskFkozak6GEE6ItS7AvGWFjuxJUoQA69cu5K1Xfp7oM6JQkzKEbZLzk2KtSxCcCNPm2H3PiTSIYltWmDTdG4ZxYu+XQtRok1gsXmpWhiVsl97YI5ufAjjmaXfeS9KE7SKHIawQkxahjatQNm1azJKl9v13XvMytIly8QWVcVLML7pC1BWhLatOTLFhQRc+uv6LWYfRAifDhNERoKP2KInOT4r11jX20nmPDRz6ykf6FVqeJJwIToYJEkeEY4+8IPfZYdd/fbnFtZWH/D21+iaJOpJcKUusZxECvPv2bA7fa3TWYbTAydDD06c1AXDkfQuqlKyOiYwwz0KsJDLv9SCp+dUt3ctKiFHJSn42vi8E6NrQgcN77a5d/nleSDCabdStDEviC7pnQopxsUWIYXasCZJZpTIrD/m7Vh1v3TSFWI8TrpOkZ4fBnLG7/iDTVc/rizMOdSnDIBGawPR7QluEqEMYqcWpEwe1+NvaI8o2iPD6yW1DD6LYkBVu26hhXbPryxsb+NO3Qhz/ebu5mIKoKxmGlaBNGWIeSFNqcbPDkuQqSdEGAZajI0RTAixJLM7k66D9DNes+pgpf/9p5LaTwnoZTrvzmwDsdfafMovh6dOatIVYi6PHOl3ktLM7U9goPj9KsvNK0YYMsJwgEQKsWtqbZ/8Q5j1qOqmhNTIsSS/ofl6EaAuLfzk09ioUt92/faQlwAWvdgydHVYTIUC/7T/mgt9fpd3mpYF7XJvDChmuG9xIa41yNmSJeSOOEJ0IHWGEqCNCgC7vKUYctSlOWIlghQzDknWWmDeiCNH06LFp8ja9Js/oSk6XObTiXNoZbdMEuZQhhBdi0iPIthNGiC4jrA1e//uaFtf2+XKnDCJpzsaGbszrcZx+haWTkwvGQ25lCPWTIZqaVlOSXJAU8yBClxUGU0mCle5lJcYtAz5i/dj/1q/wjeRi8ZJrGdrImKdvs35E2bTwwk6ajvoMG/jCXYXDz/95ZkoLZkMSJMJKZbMQYtuOWxi4j/7AzLIEY/GSexnqZIf13kXOG2mJryQ2L0GS85Yvr2uDHMOI0FsnbSFu13Ywvx70I+3yXyCddcy5l6GjtkhDhJUk6Hfvn2e2Ciwf1GaagowiwqyY+05bLth7u6zDaEFdyPDI+xbEzg7DzDHMQ1fZNrLMBk2WL69rQ8ZYjbSzQ/msLW3mDE7tebrUhQyzoN6EGOe9oa0iNPXMpIWYp6wQoE3nRfQ/6Gb9Ck8nF4uXupFhnOww6soTE0LMywYNEE2ItSxCR2VWd+3PP478mX6Fp3+bXDAeakKGulNsoggx7hK8essQHS1JMjvMW1YI0Nj+bU7eeVft8r9MMBYvNSHDMIQRoqm1yFGFmKessEQp06uWIaY5VcZlhXaxqXUvlnQbFaLGLxKLxUvdyRD0hGh6U4YwQsyjBMsJkqItcwbzjs1Z4U/ab3vRdyLDm93r+sEqvvL157Xb+qOhmKpRMzIMuxolix1oqgmxFiRYjhNffeGVoB+LevThtq+fq9/onS/HiEifqjIUkbuA44DFSqk9itcagT8BQ4DZwEil1HIREeA24BhgLXC6UurVZELPJ7UoPIdDR4IlPlvTmfde/LzR54tIa2AKMF8pdZyIDAUmAT2BqcB3lFKBu+PqZIb3AL8C7vNcGwM8o5QaKyJjip8vA74K7FT8OhAYX/zucDgcADT1as35Z/bQLn+Z3tulC4DpQNfi5xuAW5VSk0TkDuAsCj7ypeoQl1LqBVouDzweuLf4873ACZ7r96kCLwLdRcSthXPUPUkM4piaKB2nnZ+0fzpUVgjQ0AA9+2zR/qqGiAwEjgV+W/wswBHAn4tFvI7yjyvUb7GNvkqp0ku3hUDf4s8DgLmecvOK11q8oBOR0VBcdNirc8QwHI76Zp8vd7J6IKUSW5a1Zu3EbmGq9BKRKZ7PE5RSEzyfxwE/BLoUP/cEPlVKlXaQLXkokNgDKEopJSIqQr0JwAQA2aFP6PoOhyM+cbPCKMxtWs2FY/6tX+ERliilKm7+LyKl8YypIjIiUkBFospwkYg0KaUWFLvBi4vX5wODPOUGFq85LGX6q30C7+86fHHgfUf2RM0OsxAhwF7zNvLUZfO0y/cLvn0I8B8icgzQnsI7w9sovKJrKGaHWh6KKsNHgFHA2OL3hz3XzxORSRQGTlZ4utMOi6gmwUrlnBijk/T65LBCzHLH6+mrOzH8nwcZaUspdTlwOUAxM7xEKXWqiPwvhW1hJ9HcUb7oTK2ZCIyg0G+fB1xFQYKTReQsYA4wslj8MQrTamZSmFpzRojfy5ECuhIMqps3Kepuw5V3dIWY9db/Qzuu4I5hj2mXPyLa5LzLgEki8jPgNeB31SpUlaFS6hSfW1+qUFYBIWZTmqMetv93RKeehGg7C3dcw02PvqRfoerQRwGl1PPA88WfPwQOCBNXzaxAcVQnTlZY3k7eskNo3lVNU4x52NMwTdZ9sJw3T/pz9YIpUxMydFlh+uRViCV0t/d3mGfXoXvy2B/0u8kDdxqYYDTbyL0MkxDh1J0ubHHtc++PM/6cNDGVFZa3mWch+lESpQkpuqywJXM/Ws5F5z6YdRgtyL0MTVFJgH738y5Gmzi1ww8qXr9/3a0pR9ISk1J0bGNTxy4s32+EfoWnEgulGbmWoYmssJoE/eo4IcbDT4Le+zYIEaIPvrissDJqqfDZ3W2yDqMFVsiww5xlBG4n4cFUtziKBMvr2yDEYy99qNnnv914QosySXSRvW3rdpWrCdBmwgixHiT40/VHAtEmXzftupornnhBu/wL/UM/IhJWyBAKkpt25zcD75sirggd26gHEZbQEWI9iDAuWz5byZoPUur7hsAaGYIbFa5VoorQRFdZjbyl4nWZfFGk9irJLi9HgiZBKUME/Szxo1WbOf9Z+zaXsEqGaZBVVvjpyhW+97p3DbWDhy+VushQyN6S7CrbiJ8Ey+9HlaIXG0R40LCPI9V7cYa5PqhXjEHsvKQtf7lbf7rMsKgBhUQKi0aypWNDgxrWtXviz0lChDrvDYNEWMKUEINIQojVuskmusdhs8NqIqyECSlmRVQRljApxEq8tnzpVO+uM70G9lLHXvA17fr3/fCeqX671pgk+/9Lq3F0RBimXBxMzwmspTmGUQRqA3FFaKqNMGze3JqVy7ppf6VF3XST8zBo8unKFalkiCawVYRxpKZG3pKrDNGkxEptJZ0lAvRevYRz/k//YPiHkgulGXUjw7yQtBBNvD+sRRE6CqQhxVWr9+L5fz0bokZjYrF4qQsZ2jhokiUlmYWVYlgJ1sJ0mnrloGEfJybEhfIBN7b1n0bXgnWJhNGCupBh3kiruxwkRW8GaWsmWM+k/Z7PJE39+zL63PO1y19zRfRdtcPgZOjwlZ2ToJ2kJcKkssMuK2dz+HNnaZe/xngElXEydCTG/etudV3lOqTt0MsA2DDrhor3VzYM5akevwzR4lcNRFUdJ0OHw0PeRpSTJmx2WBJhs5+X/7BZmYVdOjB2xL76QUzWLxoHJ0OH1diyc42jOl4RBrHHZ5/ywKy/aLe7c9SAQuJkaCF5mWtYq9icHdo6cKIrQoDZvVbxX2f8Q7/xGyMEFAEnwwTp3rWbtdNrHMGYXLtcD2yYdUMLIfq9MxyweC3X/kr/yLvDYkWmT13I8HPvj8vFChRwWaGXsF1kmXyR8YnX3vacGIPxCtFPhADzl23hJ39cnVZY2lgtw1Zt7272ecsGu45h1tmkIUx2WGsijDOSHPVdYRJCLGFz99kWgiRYQnbbQqu/htjCa3CMgEJgrQzLRVi6FlWItmeHToT5wAkxPt1m9OXYg/9bu/yz/DjBaLZhpQwridB7z7YMsRol0VXKEGtNghBfhHFHkJPMDiFbIb44o7+1gyi6rO3ZgymjTtSv8PM6lWGQCMvLhJViqVtrIkOMcv5JLYqvnKxFWCJpIdYLSaxA6bj2PYa/frR2+YnGI6iMNTLUkWClOlGyxLhdZhsOgrINWyToxQnRTvo0duf8bx6rXf7Sx+9IMJptWCFDkaGpPzNqluhE2BIbRViiFoWYVlc5qV1r1qzpwpQpXwpRo45kmCVhskQnwpbU6kBJNWp9ICXJ/QzVxlmsn3eqsfZEpD3wAtCOgtP+rJS6SgpZ1iSgJzAV+I5SyvdU4rqXIegJ0YmwJVmcbxIFlx3axbKunZl4VIgjTR56rlqJz4AjlFKrRaQN8E8ReRy4CLhVKTVJRO4AzgLG+zXiZFjET4h5luDIM+ZVLTM5xClljvogTlY46+hFLS9ObK6ZpnatuHJIJ+02qx0QoAqn2pVmcbcpfingCOBbxev3AlfjZKhHFuI7dfBBvvfun/Ni5HZ1RFgqF0WIeeseJ7U6Jcuusuns0LgEfVixAB6/IdSpnL1EZIrn8wSl1ARvARFpTaErvCNwO/AB8KlSalOxyDxgQNBDnAwzIEiA5eXCClFXguV1XIaYT0wIMS0JlujSuxOHjdb7NwDA839bUu2oUKXUZmAfEekOPEiE45adDFNGV4Te8rpCjCLCLHHbc5lBR2Z+wkzjNLxyZs1by2mXTE2kbaXUpyLyHHAw0F1EGorZ4UBgflBdJ8McECVDDIvLDsOTp9HkJKQXJSsE2Kn7UB476X7t8n1+Ffx+UUR6AxuLIuwAHAncADwHfIPCiPIo4OGgdpwMUyRsVhgGE1lhmkLMIiusxVHlLIgqwRLT+k1n8CUhRpN/VbVEE3Bv8b1hK2CyUuqvIvIOMElEfga8BvwuqBEnQ4cjAnnKCk0SV4QAfVoNY1THqtNltvILegTeV0pNA1qcI6CU+hA4QPc5uZZhnjZsSDIrdDjSwIQIARqnz+KUA0/TLv8LI0+tTq5l6CjgBk70MdFVrtes0BQru63jqaOn6VfwnRlollbVCojIXSKyWETe8ly7WkTmi8jrxa9jPPcuF5GZIvKuiBylE4RSs0IHnqessBaJKjQbRpCjykwmX1S3IjSVFQJ0aAW7dhDtr7TQyQzvofAK876y67cqpW7yXhCR3YCTgd2B/sDfRWTn4hwgYzgRJkPYwZOw5yLbIMISYTLEehVgCZMiBNjcbQBrjrtOv8It36pexgBVZaiUekFEhmi2dzwwSSn1GTBLRGZSeIH572oVt2w4Q2sbLyfC5mTdRS4JrpoUbRJhiZLkKkkxrgDveqHyTitnHva9WO2mjWkRAnT4sCO7nzzceLtxifPO8DwROQ2YAlyslFpOYbmLd0Jc1SUwXpzo8ouNstPFZObnJ0Hv/bwIMQkRAszr3ZYfjtbWAlyTSBgtiCrD8cC1FBZDXwvcDJwZpgERGQ2MBmjTquqry9xz/5wXI48oJz3h2mGGaiL0lrNdiEmJEKBdDxjynyH+zdssQ6XU1v+lROQ3wF+LH+cDgzxFfZfAFBdaTwDo2NAQatV2XokjxHpjjzFf87331thHU4xED10R5oEkRQiwcfo7fLLvXok+IwqRZCgiTUqpBcWPJwKlkeZHgD+KyC0UBlB2Al6OHWUdUy9ZYZD8KpW1UYhhyEN2mBRdOnThi7uP0C7/l1c+SC4YD1VlKCITgREUttGZB1wFjBCRfSh0k2cDZwMopd4WkcnAO8Am4FzTI8l5J0x2qCPCyXcPzHwQJS5hROitY4sQXVYYjk09evLJiafrV3glcBWdMXRGk0+pcNk3OqXUdUCIcfP6w3WXtxFFhN66tgixFkhDhACb1rZmyRv2nRTpVqBkRJAQs+gaZ7FjTRwRettwQswX7dvOZveBp2cdRgtyLcOV9wav0+k66pyUIolGvbwPrIQJEeYZE+8L7xzTPLs6e+yK2G2mwZK+cGeYjdJvTiyUZuRShtUkWF7Odik68ktW7wvLRVh+zWYx9pmv+MGVm6oXLBJqzl4McidDXREmSbeTTgBgxQMPZRoHmFmBkmYXudYywjMP+15oIcbJCitJ0K+crUJsGLAD3a59UL/C3TskF4yHXMkwSxGWBOhwZIWuCL3lsxTi0Cf6AoVdVZuxfBGtHrgx9XiqkSsZRmXlveMjd5WDJJh1hmhqSk1aO1zXWlZYIkp2GJawIsyakggrsX7DIN6dMy5Ea+m8isiNDNPOCsNkgt1OOsGKLrPN1KoIw1IPE62DRAjQa9WbnPWP7bXbGxM3IE1yIUMTIgyTHeahS5z3ida1hk52GFWEaWWFQ5/oG3uuYTURArw9eHd2veP/6Tc6PJ3fPxcyTJOoInTZocNPiHnKBuMIUUeEAJ0/XMShI/Xny4QYaomF9TI02T2O8+5QByfE9LFtwnWexOdHWCHqSrDEDo2reeDb/9IuL1eHaj4y1sswTfLQPQbXRc6aE/babevPD017J9FnZTVwoivEsCIEWNZueyZuPylEjd6hnxEFJ0PDuOwwPdLOCr0SDLqWtCDTIorodNi8ZR4r1l2aSNtxsFqGpkeQa2ElissK06eS8KqVrxUhJkGPRsVJ39RfgXLO2QkG48FqGTocfqSVFYYVobeeE2Jllr67mT8c/mnWYbTAyTBHJJUVZrFjTRxsF6G3flwhnj12Re4mXFej/aBO7HzzwfoVjvhr9TIGsFaGNqxBdpjjrbGPGpl4nRcRetvJKkO0dm3yJ6vpe8cLWYfRAmtl6GhOPb8rtGGgJEtqLTtc1m4DE3eak3UYLagbGdbC4EkSpNlFDpsd2jaHMCpZZIdRs8IPdpje4toOH+waN5xmdO3fkyN/Mkq7/K3XXR54X0QGAfcBfSkcRTJBKXWbiDQCfwKGUDieZGTxSOOK1I0M08RNr/HHdsEllRXGFaJXbkFZYlgJVpJfpTImhdhlhmLEIRuMtUfhvKWLlVKvikgXYKqIPA2cDjyjlBorImMoLHO+zK8Ra2XYddQ5xt4b6maFKx54yMjEayfCfGJb99gPE+8CdSRYXt6UEKfvsp79n31Xv0LX4NvFkzoXFH9eJSLTgQHA8RQOswO4F3iePMrQFK577HBsI6wEk2DLa8tZ2/i/Yar0EpEpns8Tiueut0BEhgD7Ai8BfT1HGi+k0I32xWoZxs0OsxBhnrLCvE2pccQjrghNZYf9tuvApZftoV3+v899eYlSar9q5USkM/AX4EKl1EoR2XpPKaVERAXVt1qGEF2IUUVoqqtsmlo4H9nhAGi/Ykd2feqBEDWq/5+2iLShIML7lVKlxheJSJNSaoGINAGLg9qwXobQXGw2n4iXdFZoUoguK6wvTHWPTWSHH3Z9m5GH765f4eHg21JIAX8HTFdK3eK59QgwChhb/B7YUi5k6CUN2dmaHZrCiTAbspqAbcN7Qi9DV/fl9v/T/3f8Fa6sVuQQ4DvAmyLyevHaFRQkOFlEzgLmACODGsmdDG0lrXeFcbNDJ0JH1mzotpy5x/1Zv8Lk4NtKqX8C4nP7S7qPcTL0IUx2mJdBEyfC7HEbOECnRRs58KYF1QumjJNhACXJ+UkxKwlGyQ6dCB2miPve8P0u23H0l8bqV5gW2Ls1hpOhBnnJ/PywSYRv/OytwPt7/1h/yoWjOra9LwTYcdM87l/oO/e5BcMTjMWLk2FOKQmuUoaYJ/lVK+/kWHss/HQoYx+5K0SNQxKLxYuTYc6xSXxewkqwWjtOivYQd2pNY/+OfPPivbXLT/5BrMdp42ToMI4pEZa3WQtCrPfBE4BlzGbiljOyDqMFToYOoyQhQm/btSDENNnhg12Nvjc0sRyv7bxGtrvklBA1Qq1jjoyTocOREi4rLPBJwwbu7PmRfoVoZ9qHxsnQYYwks8I0eGjaO4lt41ULIjS1hdew3RSTn9ioXX6P/kYeWxUnQ4cR8i7CWsZEVzmKCDe0u774U/OzPuetXszF//p1rHiSwMnQ4fCQRHZoQ1YYR4jxRNiS1Rv78+/5V4doTf+IgDg4GTpyRRqDKCaFaIMIS0QRounzTwDadviYAXtW3XxhKyuNR1AZJ0OHowIlicWRogkRHvrDl7f+/I9fHBC7vZLc/KRoQn5BWSFAu9UN7PSvwE2nmzGdEIMtMXAydDgCyDKz84rQ+9mkFLOgVcfedBh+dvWCW3klsVi8VJVh2GP4ihst3gYcA6wFTldKvZpM+A4bSHPwpB7mGZZLsNJ9E0JMgmpZIQCd2qP23zn5YEKikxmGPYbvq8BOxa8DgfHF7w6HowrVROgtZ6sQq9GBT9i9wczJlyapKsMIx/AdD9ynlFLAiyLSvXQOgfnwW9Jvwz987y1se2gaIeSKa07v3OLaVfesDtXG3j/ew02tcehlhcCq+a14/rJOCUcTnlDvDDWP4RsAzPVUm1e81kyGIjIaGA3QplWrsHFXJEiEpftOiNuoJELv9bBSdMRDNyvMOxv6NTHvsqv0K/z2t8kF40FbhnGP4SuneO7pBICODQ2h6laimgi95epZiH4C9CurK0SXHTp0aVzxHqc8doR2+Z8mGIsXLRmGPIZvPjDIU31g8Zo11KMQw0iwvJ4TokOHtp9dodVV/mzNMN6f8myIlntGDyoEOqPJYY/hewQ4T0QmURg4WZH0+0LdrDArDv90gu+957qPTvz5UUVYXt91mx0m6NNuLRfuoP9KYGKCsXjRyQzDHsP3GIVpNTMpTK2xb+My0skOgyRYXiYNKcYlTJbocPgxc31HjpuxX9ZhtEBnNDnUMXzFUeRzY8aVe3REWF4+CSHGzQortRckxCS7yvUwx7Ae6N5pJiftf4J2+TsnJReLFym4K1s6NjSoYV27R64fp5tsOjsMK8FKmJKiaRGWEyRF00KsBxGGGU22eY5h+XvDtxeePVUptTUV3LVtk7qrl36H8fMLft6sflLU/XI8k91lEyIstZOHbnMQJjPEehAhFASnI0SbRQiFgRTwn3f4cd8Grr24l36D7gyUfGFKhN72bBdiGl3mehGhLraL0EtJiuWsW/Ypb/7h0ZSjqY6TIfU51SYt/GTmzk+uTFB2mCcRBtGncQ3fP/VF7fKXTU0wGA81IcOFbQ+1fnpNFGohO/SjXmWnQyUh1ooIAVZ8uh1/fTjEChTOTCwWLzUhw1omD0J0mKeW5FfOLmojL6z/WLu831SWrfdF7gKOAxYrpfYoXqu4q1ZQO1bIcNDg7bjx+p9y6TkXZh2KIwJu/qEjDItZz68wuk/kPcCvKGw1WGIMlXfV8sUKGZa4cfw4ACdFhyNlxsyu/A5v7JCDjD9rXdMA3rjyOv0Kx/0x8LZS6oXiJjJe/HbV8sUqGZZwUjTDVfesTnyuoSPf+Emw/L5JKTZ2W8Wpxz6vXT7injV+u2r5YqUMs6BWR5TTEqLrKueLahKsVN6UEDvMXcieF94cpkovEZni+TyhuOuVFrq7alktwxvHj0s1OyyNSNeiFB3VWdh4a+D9fst+sLVc6ec8ElaE3nomhLhsU38mLgkzmvyfSyKsQPHbVcsXq2UI6QsRai9LdN3l6lQTYXkZ7895EWNUCZa3EVeIn3VuxXuHdtCvcH+kx/jtquWL9TKEbIToqA90JGiyjazEaUKEpmjdeQ3dPj+lekFNRGQihcGSXiIyD7gK/121fMmFDB3xSTo7zOP7QhMijPrMNKVoWoRxs8M1MxqZenBVN3m4OvCuUuoUn1stdtUKomZkWKurUEziusv2kNZ7x6QywjhC7LLPDL74r89rl388RI86DmZOYkqB0nSbIEy954vSTl5WieQxg0uCLLJCG2OIQ1TRblzTgYVT99b+SouayQwd+pjOEE0L9tGX32hx7WsHpPePIk2S7Dbb9J7Qy/oOwnt72Kce+yKKSZbd5ee6jza+lVdSGacpIZoUYSUJeu+ZEqKNGVlep+tE6S4PnTGIew8ep12+N3uGjCoauZJhHkaVkxCiraQlQm+ZWs0QIb9CDMvabh/z6jFX6leYnlwsXnLzzjBP1MP7w7RFGKVsHjGVtdraRQaQtutpu91M7a+0yFVm6DBPlO5yViL01qnlDLHWeX/Njhzz4kMhauyYVCjNqEkZxnlvaGpE2kR3Oa0M0yu3amLMWoSO/DO4w0au3nO+dvnTUzo4uSZlCNGEWEtL8KLiJ0bbpuS47DC/LF3fjntn7JB1GC3IlQyTHDxJQoRxskMb3jvaJsB6wNQAytghB1n73nBDj9V89I1/61e4r3oRE+RKhmEpCS4oQ4wqwT4TugKwePTKwHJhhWiDBB2OJGm/cS27LXldu/wHyYXSjJqWYYlKUowiwZIAK10LkqJXcH5irEcJfu2AvTN5b9hv2Q+snGtYL/Ts0YbvnNhbu/yj6ZwHlR8Zmugix+kKVxJh+f1qWSLUp/T8yHIAxUYh1sMcQ4BFK4SbH2+fdRgtyIUMs55oXU2E3nI6QnQ40iCN94ZRNmvot3QTl99Xda/VrZwQ+gnRsF6GWYvQ4cgzSQox6q41HzQIX+/dznA08bFahnkUocsO84NNXeUku8i2jSwP6NiZc/fS38LrigRj8WKtDG0RoW4X2ZEupuYY2iTEJDEtxDibu27ovpC5X79Jv8KlkR8VClGq6qFRidOxoUEN69o96zBaEFWELjPUJ8ogShKTrbMSYpaDJmHkGEd+ry1fOtV7oNMuO2yvfn39tdr1v3zyt6dGOBAqNNZmho76IKvpNeVkkSFmPXqcxAHxOnT6dDYHP3pGJs8OwsnQkTlhhJjkEjzvUaBJkrUEs2bV2n149vUXQtToklgsXpwMc8R5JwzY+vOvHtJf6O4IR7msTMix3gXoZcuQJaz9zd36FfTHWmLhZGiYNN4X1qIISxmfDV3mciqJTFeQToItWTizHTeeNCTrMFrgZJgzalGEXoKkaNMuNU5y0enc1I7PX7azdvkp5yUYjAcnQ4MknRXWugi92CQ+h1k2tFnPvL4zsg6jBU6GASwevdLNMyzjf04dz/fvPyfrMBw5pmHtInpPuTnrMFpQVYYiMojCjmJ9AQVMUErdJiJXA/8FfFIseoVS6rFincuBs4DNwPlKqScTiN0q3NxCh0OPJR078Nv9wpx4l85pl1UnXYtIE9CklHpVRLoAUymsnR4JrFZK3VRWfjdgInAA0B/4O7CzUmqz3zNsnXRdolp26ESoz5vrhgOwZ4dXM44kOuN6P9Hi2oWfHJ1BJPmgfNJ1h4GihpzXWrv+jMs32zHpWim1AFhQ/HmViEwHBgRUOR6YpJT6DJglIjMpiDHE1rZ24brL0SiJL8w9WyVZSYCV7udVit1u3KXi9RWXvmv8WQ2fdaffzCO0y8/gAeMxVCLUO0MRGQLsC7wEHAKcJyKnAVOAi5VSyymI0rvOZx4V5Ckio4HRAG1a2X9iaSn780oxiYxw6vktBw4+90v7ppsEESTBMHVtEGM1CfqVz4sU/STovW9aiAO3bOGG9Wu1yx9o9On+aMtQRDoDfwEuVEqtFJHxwLUU3iNeC9wMaO9Jq5SaAEyAQjc5TNBZkmSXuJIIg67bJsk4ErSRsCIsr2u7EKuJ0FvOpBAb2vam13ZhNjmu/ncQkaOB24DWwG+VUmNDx6VTSETaUBDh/UqpBwCUUos8938D/LX4cT4wyFN9YPGaIwA/4enUsUGKSYjwzXXDM8sO44jQ24atQtQVobe8KSF+2qYrj/Q397+LiLQGbgeOpNATfUVEHlFKvROmHZ3RZAF+B0xXSt3iud5UfJ8IcCLwVvHnR4A/isgtFAZQdgJeDhNUkvS7srA72sJrr+eOC34PwPdu+06WIUUSYXn9LIWYZEaYhRBNiNBmworQW8+EEJd+PI37rhpUvaA+BwAzlVIfAojIJApjF6FkqDOa/AUKY9tvAluKl68ATgH2odBNng2cXZKjiPyIQpd5E4Vu9eNVnvEJsAZYEiZ4y+iFiz9r8v475D1+qPw7DFZKbT0BSkSeKJbTpT2w3vN5QvE1W6m9bwBHK6W+W/z8HeBApVSotSs6o8n/BKTCrccC6lwHXKcbhFKqt4hMSWP4PClc/NmT998h7/GD3u+glLLy3YH9w7gOh8MRjJFxCidDh8ORd14BdhKRoSLSFjiZwthFKGxam1z5dPX84OLPnrz/DnmPHzL4HZRSm0TkPOBJClNr7lJKvR22HSvOQHE4HI6scd1kh8PhwMnQ4XA4AAtkKCJHi8i7IjJTRMZkHY8uIjJbRN4UkddFZErxWqOIPC0i7xe/98g6zhIicpeILBaRtzzXKsYrBX5Z/JtME5HM19n5xH+1iMwv/g1eF5FjPPcuL8b/rogclU3UzRGRQSLynIi8IyJvi8gFxeu5+DsExJ+rv4MvSqnMvii87PwA2B5oC7wB7JZlTCFinw30Krv2C2BM8ecxwA1Zx+mJ7TBgOPBWtXiBY4DHKcwvPQh4ydL4rwYuqVB2t+J/S+2AocX/xlpb8Ds0AcOLP3cB3ivGmou/Q0D8ufo7+H1lnRluXUajlNoAlJbR5JXjgXuLP99LYd9HK1BKvQAsK7vsF+/xwH2qwItA9+K+lpnhE78fW7eRU0rNAkrbyGWKUmqBUurV4s+rgNJ2eLn4OwTE74eVfwc/spbhAGCu53PF7b4sRQFPicjU4nZkAH3VtvXaCynsDm4zfvHm6e9yXrELeZfntYT18Zdth5e7v0NZ/JDTv4OXrGWYZ76glBoOfBU4V0QO895UhX5CbuYt5S3eIuOBHSiskV9AYRs56ynfDs97Lw9/hwrx5/LvUE7WMsztdl9KqfnF74uBBymk/4tK3Zji98XZRaiFX7y5+LsopRYppTYrpbYAv2FbF8za+Ctth0eO/g5+2/nl7e9QiaxlaGQZTdqISCcpnAeDiHQCvkJhC7NHgFHFYqOAh7OJUBu/eB8BTiuOZh4ErPB046yh7P1Z+TZyJ4tIOxEZiiXbyIlU3g6PnPwd/OLP29/Bl6xHcCiMmL1HYaTpR1nHoxnz9hRGyd4A3i7FDfQEngHep3AQVmPWsXpinkihC7ORwrubs/zipTB6eXvxb/ImsJ+l8f++GN80Cv/wmjzlf1SM/13gq1nHX4zpCxS6wNOA14tfx+Tl7xAQf67+Dn5fbjmew+FwkH032eFwOKzAydDhcDhwMnQ4HA7AydDhcDgAJ0OHw+EAnAwdDocDcDJ0OBwOAP4/PM57+ChohlkAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -130,8 +92,7 @@ "source": [ "labels = cle.connected_components_labeling_box(binary)\n", "\n", - "cmap = matplotlib.colors.ListedColormap ( np.random.rand ( 256,3))\n", - "imshow(cle.pull_zyx(labels), cmap=cmap)" + "cle.imshow(labels, labels=True)" ] }, { @@ -149,19 +110,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -172,7 +123,8 @@ ], "source": [ "pixel_count_map = cle.label_pixel_count_map(labels)\n", - "imshow(cle.pull_zyx(pixel_count_map), cmap='jet')" + "\n", + "cle.imshow(pixel_count_map, color_map='jet')" ] }, { @@ -184,24 +136,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -212,29 +154,20 @@ ], "source": [ "mean_intensity_map = cle.label_mean_intensity_map(blobs, labels)\n", - "imshow(cle.pull_zyx(mean_intensity_map), cmap='jet')" + "\n", + "cle.imshow(mean_intensity_map, color_map='jet')" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -245,29 +178,19 @@ ], "source": [ "minimum_intensity_map = cle.label_minimum_intensity_map(blobs, labels)\n", - "imshow(cle.pull_zyx(minimum_intensity_map), cmap='jet')" + "cle.imshow(minimum_intensity_map, color_map='jet')" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -278,7 +201,7 @@ ], "source": [ "maximum_intensity_map = cle.label_maximum_intensity_map(blobs, labels)\n", - "imshow(cle.pull_zyx(maximum_intensity_map), cmap='jet')" + "cle.imshow(maximum_intensity_map, color_map='jet')" ] }, { @@ -305,7 +228,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.6" } }, "nbformat": 4, diff --git a/demo/tissues/tissue_neighborhood_quantification.ipynb b/demo/tissues/tissue_neighborhood_quantification.ipynb index 0a63426f..9a959e97 100644 --- a/demo/tissues/tissue_neighborhood_quantification.ipynb +++ b/demo/tissues/tissue_neighborhood_quantification.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -28,26 +28,16 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 2, "metadata": { "scrolled": true }, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -60,28 +50,17 @@ "# Generate artificial cells as test data\n", "tissue = cle.artificial_tissue_2d()\n", "\n", - "cmap = matplotlib.colors.ListedColormap ( np.random.rand ( 256,3))\n", - "imshow(cle.pull_zyx(tissue), cmap=cmap)" + "cle.imshow(tissue, labels=True)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -94,7 +73,7 @@ ], "source": [ "membranes = cle.detect_label_edges(tissue)\n", - "imshow(cle.pull_zyx(membranes))" + "cle.imshow(membranes)" ] }, { @@ -111,19 +90,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -137,7 +106,7 @@ "neighbor_count = cle.count_touching_neighbors(touch_matrix)\n", "\n", "parametric_image = cle.replace_intensities(tissue, neighbor_count)\n", - "imshow(cle.pull_zyx(parametric_image), vmin=0, vmax=10, cmap='jet')\n" + "cle.imshow(parametric_image, min_display_intensity=0, max_display_intensity=10, color_map='jet')\n" ] }, { @@ -155,19 +124,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -180,7 +139,7 @@ "local_mean_neighbor_count = cle.mean_of_touching_neighbors(neighbor_count, touch_matrix)\n", "\n", "parametric_image = cle.replace_intensities(tissue, local_mean_neighbor_count)\n", - "imshow(cle.pull_zyx(parametric_image), vmin=0, vmax=10, cmap='jet')" + "cle.imshow(parametric_image, min_display_intensity=0, max_display_intensity=10, color_map='jet')" ] }, { @@ -197,19 +156,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -222,7 +171,7 @@ "local_median_neighbor_count = cle.median_of_touching_neighbors(neighbor_count, touch_matrix)\n", "\n", "parametric_image = cle.replace_intensities(tissue, local_median_neighbor_count)\n", - "imshow(cle.pull_zyx(parametric_image), vmin=0, vmax=10, cmap='jet')" + "cle.imshow(parametric_image, min_display_intensity=0, max_display_intensity=10, color_map='jet')" ] }, { @@ -232,19 +181,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -257,7 +196,7 @@ "local_minimum_neighbor_count = cle.minimum_of_touching_neighbors(neighbor_count, touch_matrix)\n", "\n", "parametric_image = cle.replace_intensities(tissue, local_minimum_neighbor_count)\n", - "imshow(cle.pull_zyx(parametric_image), vmin=0, vmax=10, cmap='jet')" + "cle.imshow(parametric_image, min_display_intensity=0, max_display_intensity=10, color_map='jet')" ] }, { @@ -267,19 +206,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUoAAAEYCAYAAAA6b7/5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZJklEQVR4nO3dfawldX3H8feHXR4ERaCQ7QpY0G7sUpPiegO2awwtokBNV5PGYKJuDcmaCK02mrrEGEmM0TbVtiaWdFUqVoVaHwoxVKVEYrpRBLaIwC2yRZTdXlioT6hFvMu3f5w5cLh7zpkzc+bhN3M+r2Ryz5l77sxvZs753N/DzBxFBGZmNtlhbRfAzCx1DkozsxwOSjOzHA5KM7McDkozsxwOSjOzHA5KM+stSVdKOiDpzpF5J0i6QdK92c/j85ZTW1BKOl/SPZL2StpZ13rMzKb4BHD+mnk7gRsjYhNwY/Z8KtVxwrmkdcB3gfOAfcAtwOsi4u7KV2ZmNoWk04AvRcQLs+f3AOdExIqkjcBNEfGCactYX1PZzgL2RsR9WcGuAbYBY4Py6BOPjuNOe3ZlK3/Ozx6sbFlV+8Uzj2q7CNaAo3/2WC3L7dv7Z/m2xx6JiJMAflOKXxT8+xW4Cxjd2bsiYlfOn22IiJXs8YPAhrz11BWUJwMPjDzfB5w9+gJJO4AdAMc+91guvvVNla38vbvfX9myqvcYe7ZubrsQVrMtu5drWe6erafXsty2vFjL3x8+/gXw5oJ/fzk8FhFLZdcfESEpt1nd2mBOROyKiKWIWDrmpKPbKkYr6voQmXWZGNTcikwlPZQ1ucl+Hsj7g7qCcj9w6sjzU7J5Zr3nf4TlCDi84FTSdcD27PF24Nq8P6grKG8BNkk6XdIRwEVZ4SzjD1M/+biWV0eNUtLVwDeAF0jaJ+li4APAeZLuBV6ePZ+qlj7KiFiVdCnwFWAdcGVE3FXHurpsy+5l91f2hANyfsMaZZUi4nUTfnVukeXUNZhDRFwPXF/X8vvCYdl9DslqDGuUKfKVOQnwB627fOyq02AfZWGpBrhZ8toIybXr7FNrJOUaZarlmsu7t16W+LmU1nWp1CRnLUcXArWOPsqquOmdiFQ+eJavi8dqy+7l5Mt9GPCMglOTZbNEpP5GNh+jOqXcR+mgNJtRH0Iy9W1o6MqcUuUysxypB0wfpNxH6aA0syR41NvMLIdrlGZmOVyjNDPL4Rplw3yyuVn3uEbZIIekWTe5RmkzG56G0oVLzhaFTw1qRso1yl6dcN6n2mQXLjlbBH08BqluU8pX5qQa4IX1KSRHjb6pXctsTqph0mduetesryG51rQPr0O0OosQkqneMDrVQOp803tRQjKPm+rVWKR9mNq2Cjh8fbGpKakGuJXkpnp5qQVHE1KqWUqwvmgirdZSlEN0ukbp2uR0i/jBL2uR91UqrREJDl9XbGpKZ2uUDkmrQgoBkYq2a5elapQNSbRY0zkkrQoOybQM+yhTlGixJnNIWhUckgkS0GBzuohOBaVD0qrgkExUwpfmJFosq0Iqo5lmM0k4KDs16v3urZe1XYTOcEhaJyX6pTmdCkpwWM7CIWmddBhwZMGpwaJ1jsNyModkPu+jRA2b3gnWKBPtEcg3GpYe5BlwAMxuz9bNHtRJUaKj3p2sUa7lGqZDsgzvs8QkXKPsRVDC4oblnq2b/YGfg/ddQhyUzViksHRAVsf78Smtd0esKzg1pLN9lJP0ve/SH+p6uM9yoNX3V8LnUSZarGq8e+tlvQhLh2MzFjksk3iPOSjb4ZC0ohYpLJN7byUclL3qo+yb5N7IC2IR9nuy2+g+Sisi2Tfyghju/z7WLpN9byVco0y0WGZp6FNTPNmAHHJQmnVX18My+YAcSvh+lO6jTFSXP5hmpdR0wrmkP5d0l6Q7JV0t6aiiRXNQmlk6Kg5KSScDfwYsRcQLGdRZLypTrNIk3Q88ChwEViNiSdIJwD8DpwH3A6+NiB/Nsx4zWwD1Nb3XA8+Q9CvgaOB/ii6gihrl70fEmRGxlD3fCdwYEZuAG7PnjevDOZRmC6Vc0/tESbeOTDtGFxkR+4G/Bn4ArAA/iYivFi1aHYM524BzssdXATcB76xhPRP1JSRH+yk70yHfQ+4vnmy4byp5f5Yb9X5kpJJ26CKl4xlk0unAj4F/kfT6iPhUkZXMG5QBfFVSAP8QEbuADRGxkv3+QWDDuD/Mkn8HwLHPPXbOYgz0JSDHqfQNaTPrQ0jW9X3do/umsvdn9VW3lwPfi4iHASR9Afg9oFBQztv0fmlEbAEuAC6R9LLRX0ZEMAjTQ0TErohYioilY046es5i9DskR23ZvdyLD28X9Gk/V70tk5Y313qGfZTVXpnzA+Alko6WJOBcoHAh5wrKrP1PRBwAvgicBTwkaSNA9vPAPOuYxaKE5KhhYPbpw5ySPu7XqrYpbzml11PD6UERcTPwOWAP8B0GmberaNFKB6WkYyQ9a/gYeAVwJ3AdsD172Xbg2rLryPPe3e9fyJBcy4FZrT7vy3m3bda/L7Wems6jjIj3RMRvRcQLI+INEfHLokWbp0dgA/DFQW2W9cBnIuLLkm4BPivpYuD7wGvnWMdYDsfx6uqLWiR9Dsmhsu+Tovum1HoSvTKndFBGxH3A74yZ/78M+gFq4ZCczmFZ3iKE5FDR90nZfVPozI3DgMLXzDSjU1fmOCTzOSTLWaSQHKq1GV1mOQl/Z05nborhkLQ6LGJAjpp2Wk8d+ya3Jtu3pneTHJJm9VobYHX+A5m47IRvs5Z809shadaMYYC1VstOuOmdRFAex495Df96yHyHpFmzWu+K8FdB5BsXlma2INz0LscjuGYLxE3v8hyWZguinmu9K5F8UILD0mwhJFyjTLRH4FB9/vrQqvgfinVeoomUaLEma+pcL+s/v38S48GcergG9XT+4M/O+ypB7qOsj8Py6RwA0/mWdAlzH2W93Bx/On9txIDfCx2UaCIlWqzyPOjzlEX9cjIf+46q7+tq59a7oBxyYD7d2v3Qt+D0ce6BhAdzEi2W1a0vtU0HZI84KC1lXe3TdEj2kJveZtVxSPaQa5RmZjkclGZmORIOys6fcG7VcXPWWucrc6wLHJbWmoSvzHFQ2iFSD8vUy2clCTiy4NSQ3gflnq2bO3faSwpSDaNUy2UVcI2yfQ7L4hxK1igHZRoclsWlFJYplcVq4KBMh8OyOAeUNSXWFZuakuhZS/XybdmK27J7udV/Mj5O/ReCg4km0sLVKNfyYM/sHFZWqywoi0xNSTS/m7c2LB0K4+XVLOu4wYaPxWIIweq6onW3J2opy1oOygncPJ9sUliO7qeqAtP7fnGExMH1RSPp8VrKspaDcgZ7tm72B3aN0bCctm/mue+l9/niObguzfusOSittKJBNun17iM2gEAcTPSGlA5Ka11Xbxxs1QrEqoPSbDo3te1gopGUZqnMbOG46W1mliPloFz4E87NLB0HWVdomoWk4yR9TtJ/SVqW9LtFy+UapZklocbBnL8DvhwRfyzpCODoogvIrVFKulLSAUl3jsw7QdINku7Nfh6fzZekD0vaK+kOSVuKFsjMFtOg6b2+0JRH0rOBlwEfB4iIxyPix0XLNkvT+xPA+Wvm7QRujIhNwI3Zc4ALgE3ZtAO4omiBzGxx1dD0Ph14GPhHSf8p6WOSjilartygjIivAz9cM3sbcFX2+Crg1SPzPxkD3wSOk7SxaKFS5HP8zOo1HMwpGJQnSrp1ZNqxZrHrgS3AFRHxIuDnPFWxm1nZPsoNEbGSPX4Q2JA9Phl4YOR1+7J5K3Scz/Ezq1dAmT7KRyJiacrv9wH7IuLm7PnnKBGUc496R0Qw2MZCJO0Y/hf40cOr8xajdq5RmtWt+j7KiHgQeEDSC7JZ5wJ3Fy1Z2RrlQ5I2RsRK1rQ+kM3fD5w68rpTsnmHiIhdwC6AM5aeUThozaxfajyP8k+BT2cj3vcBbyq6gLJBeR2wHfhA9vPakfmXSroGOBv4yUgTvfNmuVuOmZUTiMc5ovrlRtwOTGue55rl9KCrgW8AL5C0T9LFDALyPEn3Ai/PngNczyCx9wIfBd4yT+FS5Wa4WfWG51EWmZqSW6OMiNdN+NW5Y14bwCXzFqoLfI9Ks+r5phhmZlOkfK23g9LMkuCgNDObQao37vXdg+bgQR2z6tRxrXdVXKM0syS46W1mNgMHpZnZFP5yMTOzHMM+yhSlWaoF50slbVGl2vT2qHdiRkfSPapui6Tk/Sgb4aBMnMPSFoWD0mYyKRQdlrYoUr0phoNyTlWFWN5yHJbWdymfcO6grMCerZvnCrJZ/9ZhaX2WctPbo94VGg2yWUesi4afb+9mfeZR7wUzby0zb9lmfZPyjXsdlDWbFphNNNfNuiLlPko3vRuytlnuoDM7lJve9qSmRsrNuiTlwRwHZcc5LK1PUg1KN717wCPh1gdPcBi/5Mi2izGWa5Q94Zql9UGqNUoHZY84LK1L1r5fU+6jdNPbzBo37p+6b9xrjfG9LC1101o+vnGvNarM5ZRmdZsWkv5yMWuVQ9NSkNeH7qC0ZDg0rQ2zDjQ6KC057s+0lHgwx5LmwLQ6zVqbTPlbGH0epT3J52Fa1Yq+p3wepSXPNUqrUtGQ9GCOmS2UMq0T91Fa8lybtKrM04WTah9lmqUys06aJyTd9Daz3pt3MNBBaWa9VtUZE+6jNDObIuXzKNMslZktnLqa3pLWAbcC+yPiVWWW4aA0s2TU1Ef5VmAZOLbsAnxljpnNpar+yTrucC7pFOAPgY/NU7bcoJR0paQDku4cmXe5pP2Sbs+mC0d+d5mkvZLukfTKeQpnZmmr8rLXYDCYU2Sawd8CfwE8MU/ZZqlRfgI4f8z8v4mIM7PpegBJZwAXAb+d/c3fZ/0DljCfbG5lVH9vgMFgTpEJOFHSrSPTjieXJr0KOBARt81bstw+yoj4uqTTZlzeNuCaiPgl8D1Je4GzgG+UL6JZ+3wfz6fUdfOUQDzOEUX/7JGIWJrwu63AH2Ut3qOAYyV9KiJeX3Ql8wzmXCrpjQxGk94eET8CTga+OfKafdk8S9Sif+hnsTYYFvG2dE3cWarqa70j4jLgMgBJ5wDvKBOSUH4w5wrg+cCZwArwwaILkLRjWF3+0cOrJYthVq9pAbEot6VrajujXNO7EaXWFBEPDR9L+ijwpezpfuDUkZeeks0bt4xdwC6AM5aeEWXKYfNbxNrRLGYNhz7vvzb+EdR1CWNE3ATcVPbvSwWlpI0RsZI9fQ0wHBG/DviMpA8BzwE2Ad8qWzhrTp8/8EWUDYc+9WG2VVPu9LXekq4GzmEwurQPeA9wjqQzGYzo3w+8GSAi7pL0WeBuYBW4JCIO1lJyq8WerZs7/0Evq6qA6Oo+bLsrIRAHn+hoUEbE68bM/viU178PeN88hbJ2dfWDPo+2Q6JtSWx/wOpqR4PSFtMihGUS4WBPihAHV9OMJF/CaBPt2bq50TDp67psNoOgXFdoaoqD0nL1LcAckokKHJTWbXWHy+jyHWSLKUKs/mpdoakpDkqbSdP9lV0Oy7737dZHPHFwfaGpKQ5Ka92kUOxiWDok5xDA6rpiU0PSHGKyhdF0GNa5PofknEKNhl8RrlFaaxyS6Uii/AGsqtjUEAelzaTqkCl6LXVT6ysjiZCpQBLbsVpwaoiD0mbWhdAaty6H5Oxa3Z7BLc4dlNZ9bQywVHGjiqpt2b3cu5Acam27HJTWJ10IS9ci59PKNgbwq4JTQxyUVkqKtbwm1rEIITnU+LYGcLDg1BAHpZWW4qh1XWXqc1N7msa32U1v66MiwdTkZZBVWsSAHNXY9ruP0voshZtmOCTr1ch+cFBa3+UFVZ1h6pBsRu374wngsYJTQxyUVpmm7l/pOw21p/awTLRG6Wu9rXJr745eR5g5IHtoeHpQglyjtFoMg8yBZjNL+PQg1yitNg5JK2Q4mJMgB6WZzazWf34OSjPrutpbCA5Ks+4ZBoNPE2qQg9KsmxyYDXGN0qz7RpueixaajQzMOSjN+mVccPQ1PBs7eyHh8ygdlGYV6WMTvdFTvIbnUSbIQWlWsb4EZivnwbrpbWZd0UpIuo/SzCyHg9JssXS92d0KD+aYmeXwYI7Z4nBtcg6JNr19mzUzO0RrX1eb6I17HZRmNlYrX1fr7/U2s65pNCx9414zsxwJnx7kGqWZTdVorbLiPkpJp0r6mqS7Jd0l6a1liuUapVmFPOI9h+HX1VZrFXh7ROyR9CzgNkk3RMTdRRbiGqVZRfocko1sWw2j3hGxEhF7ssePAsvAyUWLlhuUk6qukk6QdIOke7Ofx2fzJenDkvZKukPSlqKFMuuSLbuXex2SQ7VvY7mgPFHSrSPTjkmLl3Qa8CLg5qJFm6XpPbbqCvwJcGNEfEDSTmAn8E7gAmBTNp0NXJH9NOuVRQjHtbbsXq7vhhnlLmF8JCKW8l4k6ZnA54G3RcRPi64kNygjYgVYyR4/KmlYdd0GnJO97CrgJgZBuQ34ZEQE8E1Jx0namC3HrNMWMRwbVcMpP5IOZxCSn46IL5RZRqHBnDVV1w0j4fcgsCF7fDLwwMif7cvmPS0osyryDoBff67HlCxtDsgG1HB6kCQBHweWI+JDZZcz82DOtKprVnuMIiuOiF0RsRQRS8ef5KC0dDkkn662/VHPJYxbgTcAfyDp9my6sGjRZkqoCVXXh4ZNakkbgQPZ/P3AqSN/fko2z6xzHJLj1dJXWcNt1iLiPwDNu5xZRr0nVV2vA7Znj7cD147Mf2M2+v0S4CfunzTrn8r/iSR8CeMsTe9JVdcPAOdJuhd4efYc4HrgPmAv8FHgLdUX28xSUHlYJnr3oFlGvadVXc8d8/oALpmzXGa2aBK+1tujKGZWWqX9lP4qCDPrm1oGc/xVEGbWB7VemeOmt5l1WSPf9e2gNOsWn0P5lEZC0n2UZtZVjYQkuI/SrIuGAbHINcvGQhLcR2nWZYsWmI2G46iEg9J3ODebUWsB0qBWt9FfV2vWD30OyyS2rcPXepvZiCQCpa+i4NQQB6VZCXu2bu5dYC5KH2wZDkqzOfQtLG08B6XZnByWVUl3NMenB5lZItI9P8hBaWaJSPcaRgelmSXCNUozsxyuUZqZ5XBQmpnNwE1vM7Mp0q1R+jxKswr4XMoqDAdz0vu+WtcozSoyGpZdvByw/bBPt0bpoDSrQZfuYdl+QA759CCzhTQuhFIKz3RCElyjNLMnzVrbnBRiVQVtWiEJrlGa2SGm9WlOC7EqmvXphSS4RmlmU42G36whVnbwKM2QBNcozWwmZUNs7d+NC850A3LINUoza9Da5nn6ITnkGqWZNaw7AQmuUZqZ5XJQmpnl8GCOmVkO1yjNzHK4RmlmlsM1SjOzHE8A/9d2Icby/SjNLBH13I9S0vmS7pG0V9LOMiVzjdLMElF901vSOuAjwHnAPuAWSddFxN1FluOgNLNE1DKYcxawNyLuA5B0DbAN6F5QLt/22CMv1vLPgUfaLksFTqT729GHbQBvR2rGbcdvPPVw5Stw+YkFl3mUpFtHnu+KiF0jz08GHhh5vg84u+A60gjKiDhJ0q0RsdR2WebVh+3owzaAtyM1edsREec3WZ4iPJhjZn22Hzh15Pkp2bxCHJRm1me3AJsknS7pCOAi4LqiC0mi6Z3Zlf+STujDdvRhG8DbkZrGtyMiViVdCnwFWAdcGRF3FV2OIqLywpmZ9Ymb3mZmORyUZmY5Wg/KKi4vaouk+yV9R9Ltw3O5JJ0g6QZJ92Y/j2+7nGtJulLSAUl3jswbW24NfDg7PndI2tJeyZ9uwnZcLml/dkxul3ThyO8uy7bjHkmvbKfUh5J0qqSvSbpb0l2S3prN78wxmbINnTseY0VEaxODztX/Bp4HHAF8GzijzTIVLP/9wIlr5v0VsDN7vBP4y7bLOabcLwO2AHfmlRu4EPg3QMBLgJvbLn/OdlwOvGPMa8/I3l9HAqdn77t1bW9DVraNwJbs8bOA72bl7cwxmbINnTse46a2a5RPXl4UEY8Dw8uLumwbcFX2+Crg1e0VZbyI+DrwwzWzJ5V7G/DJGPgmcJykjY0UNMeE7ZhkG3BNRPwyIr4H7GXw/mtdRKxExJ7s8aPAMoMrSjpzTKZswyTJHo9x2g7KcZcXTdu5qQngq5Juk7Qjm7chIlayxw8CG9opWmGTyt3FY3Rp1iS9cqTroxPbIek04EXAzXT0mKzZBujw8RhqOyi77qURsQW4ALhE0stGfxmDNkbnzr/qarkzVwDPB84EVoAPtlqaAiQ9E/g88LaI+Ono77pyTMZsQ2ePx6i2g7KSy4vaEhH7s58HgC8yaDo8NGwGZT8PtFfCQiaVu1PHKCIeioiDEfEE8FGeas4lvR2SDmcQMJ+OiC9kszt1TMZtQ1ePx1ptB2Ullxe1QdIxkp41fAy8AriTQfm3Zy/bDlzbTgkLm1Tu64A3ZiOtLwF+MtIcTM6avrrXMDgmMNiOiyQdKel0YBPwrabLN44kAR8HliPiQyO/6swxmbQNXTweY7U9msRgBO+7DEa93tV2eQqU+3kMRu2+Ddw1LDvwa8CNwL3AvwMntF3WMWW/mkEz6FcM+oYunlRuBiOrH8mOz3eApbbLn7Md/5SV8w4GH8aNI69/V7Yd9wAXtF3+kXK9lEGz+g7g9my6sEvHZMo2dO54jJt8CaOZWY62m95mZslzUJqZ5XBQmpnlcFCameVwUJqZ5XBQmpnlcFCameX4f2coGC91TW+eAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -292,7 +221,7 @@ "local_maximum_neighbor_count = cle.maximum_of_touching_neighbors(neighbor_count, touch_matrix)\n", "\n", "parametric_image = cle.replace_intensities(tissue, local_maximum_neighbor_count)\n", - "imshow(cle.pull_zyx(parametric_image), vmin=0, vmax=10, cmap='jet')" + "cle.imshow(parametric_image, min_display_intensity=0, max_display_intensity=10, color_map='jet')" ] }, { @@ -302,19 +231,9 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUoAAAEYCAYAAAA6b7/5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAsZElEQVR4nO2df6wdx3Xfv0ckJVMOVemREUOTgp4SEy4dS5UJwnIrw1DrOBHVoHSMwpWBJGwggPnDap2iRSM3f5j/BHCLxm0NpAKYWLWcOFJcx4aEQI6tqjGMCrEiWVVESYxM1n6KHkuRkdSIREhbfOTpH3dHnLdvf83MmdmZvecDXNwf777Z2b27nz1nZnaWmBmKoihKO5eNXQFFUZTcUVEqiqL0oKJUFEXpQUWpKIrSg4pSURSlBxWloihKDypKRVEmCxHdR0SniOg567MFInqUiI5Wz9f0lRNNlER0OxG9SETHiOieWMtRFEXp4AsAbq99dg+Ax5h5J4DHqvedUIwB50S0DsD3AHwYwDKAJwF8nJlfEF+YoihKB0S0COCPmfk91fsXAdzGzCeIaBuAbzHzu7rKWB+pbu8DcIyZv19V7EEA+wA0ipLoaga2CS7+bYJl1VkXsexYXCis7Jj1XYlYtk2sQ4silZuq/DrPvcrMPw4A7yTis47/fQJ4HsAPrY8OMfOhnn/byswnqtevANjat5xYv+Z2AC9b75cB3GJ/gYgOADgwe/cTmEXIUuwSLKvOVeFFxNjqncf/6QgLjFn26xHKTFG2zUKkcmMdsjYbEywDAM4B+OmXzLuzAH7VsYSDwA+ZeY9vDZiZiag3rR6tM4eZDzHzntlKXj1WNRwRkCQgH9SkCpIaOT/mwj1IJYGSOTfKMgiz04DLw5OTVcqN6vlU3z/EEuVxANdZ73dUnxVOzMjMk0GSFBL8Kl6rHiVhDs7YsowVTaYkpiybyyYAGxwfnjwMYH/1ej+Ah/r+IZYonwSwk4huIKLLAdxZVU4xSESBo0SSJQoSWHtwxpLlFCRpiCHL9jJjRJRE9ACAPwPwLiJaJqK7AHwGwIeJ6CiAn6nedxKlwYOZV4jobgDfwKz34z5mfj7GstIiHJmtwP0X8JbjVQiPiNsEeR5B5/fotB2cGzv+5sqUBGlzDnInle5tbSJKSZj54y1/+pBLOdFahpn5EQCPxCp/HE5jVFmO2haZKoo0LTRpDs5LywkR5lQlaQhtshi2bU1EmSO51mu+GCLL0SSZWpAGyUhmCL7R5dQlaePym7hvyxgRpRQqSmciRJVdjNYO6YpP+h27f8/1YHWV5RiSrO8QqQ/hPln6R+YaUSbnCOKOpUxEckmOFT22kTqqBIbLMpdIcuhOInmoN/0u4W29GlEq/dTT7yiSbOvQkRJkX1TpE0H6yjLkwO1rt8xFki6YHUrqkJfvEb8M+Y5yVVHmhJFlskgytwiyDVdZSh3ETcIsUZJloBGlMpwkkkw5DjL1dQYxxv6ZdHwKkvQZk5aOXGuWa72UaMSWpJ1+S0pyjPZKmylIMm80olTmkBiR5NiyTIXZdttHrUVqtNdbmTNipttdskwxmUNsjtdez48sc44o9VYQSgS+Hrn8JiFOTZLzR8LZg5yZsCgznOlnLri/ek4pyylLcn7kmXD2IGcmmnqbdCXxVTRFcAOAHwiXeX/L518HsFd4WTZTECQwTzLsQtsok1Jv0zGRpQpzhqQk2wRpE1uWqTgKYKdwmUMFOR9tlTm3UU5QlG1ICjNWpGqnq7HkcgOAgw2f72/4rIshkpwKy9WzlCw1gmxCI8pkDDnrSggztiTt99LCPNjyeUzxlRxVLtfeH7Ve+0gzB0lKDTq376BwbXBpGlEmwTU1CRGmdETZ1fEhGWUeDPz/EEqTZV2QTRhpDhVmiCRzSb/bbi8TLk0VZXRCdiC7d9xFfs8GLNPG5eDpEmqfhA46LCcWUrJs2g6SEh4iSZuulDyHCLIJn6iy9x5c1vf8ZJmrkHKtlwOSZ9mhkeKS4DK3Q+Zg6krVDwqUL0WILIdE3qHCdJWkoUmW0pKUiirtel3f892hcmz7v+HCJAAbkt0axY0JiFKaPlkuJaqHL/VU/eBI9ejCVZYuYzJDhOkrSYPdfnllYFnStEn7JTTL0leQXeV0S5MIWK+ijEGsNps2WS5FWFbM1Cz2oO8QhsrSdx1cZRwqyVQMiSpd96mXqufrISfIJrpTciJgw7qIiw+gYFHGbtiuy3Ip0nKkUu8S6ZKZhOSHyLIUQfYhsQ+9hPiTjrTL0iuiTESm1eojVe+fkeVSouXNI7bMYkTAXal4yZI0kWWJJ9lmWXq1USYi02p1kXqIhF4zHp8UTQT1ttvSJWk/l0iDLAmApt4S5DCOTCmfkiU5Fc7hUttoRcaX5mRSrYvW66lMdJADyyg3PVOmS8sxrqIcwhBBHgPwztgVmQgaNSk50nOcZ2Qkm0yr1UVqWZ6snnO9uKqJuiQ1qlRyoEeSlwG4IklFnCl04t5jiZZzsv8r2aGRZD+Hx67AHDIgY8x4ivMCI0qDLUvpCLNEQQIqSRcOA7gxYvn2b7Ej4nJKwKHfIdNe70IjyjpSEeZJtEvyvNAyYtEnSR0xsJZYkeXrtffLkDuJlXYydJCkRpQp8G27LDV6NJR24OSGZGRZF2Qd81v5RJjLtdclRKmOI1i01zsVQ2QZIsbzyKdTx0eQ2qnTjIQs+yRpM1SYXb9xLFlK3Tvdc5hfpqn3xEQJNLdd5h41uggsNIJUWTYTIksXSdp0tWMO+Z1jyPI0Vl+NttWjDE9JakQ5FscAbBq7EgJoep0GH1n6SrKO728s1WnUdqmuCTKGCjPggpGMRTmRzpw2YkgyRqdOV4QXQ5LasdPO0A6e1yEnSSlc95XTWBtBtjEkKwu8qk47c6aGVFtlXwqskeQ49EWWuQnSZmg67jPZiy3LeoQpdOmxtlFODRdZ+rQJqiTHxUSWdWHmLElDnywlZsSyU3IhSWacemdaramgnSblY0eXJUjS0NSzHmPKwJMQuyOpinKeUDlOj8Mot113GXHuQx+BjOejnHhnTmxMhHHcekhRwoBiRREkUmcOEf0rInqeiJ4jogeI6G2uVVNRenOmen4d8e8zoihzgrAoiWg7gH8JYA8zvwezmPVOn2p5Q0RLmBnjAoAVZt5DRAsA/hDAImY3m/kYM/+/kOXkx5mGzzZCJx1WlADipd7rAWwkovOY3Uf4/7oWIBFR/kNmvpmZ91Tv7wHwGDPvBPBY9X4kmoSWY5mKonim3luI6CnrccAukpmPA/iPAP4KwAkAbzDzN12rFqMzZx+A26rX9wP4FoBfj7CcgZyB3MDzPklKR5UL1uuSelynRqkdOSnYVT0LtM/79Xq/agVpa4skugYzJ90A4G8A/Hci+kVm/n2XhYRGlAzgm0T0XcvkW5n5RPX6FbRc+0REB8xZAHgjsBp9SESBqSPJs7X3C1gtTl+kO52mTumSXEC8wS27rNfbIbKt5DtzfgbAD5j5r5n5PICvAvgHPtUK4QPMfJyIrgXwKBH9pf1HZmYi4qZ/ZOZDAA4BANG7Gr8jS0hkObYkbYwsXSNMlaM7U5CkYT2AFcGyd7V8HjDpSpw2yr8C8H4iuhKzdO9DAJ5yLSQooqzyfzDzKQBfA/A+ACeJaBsAVM+nQpYhi4/wXP8nVQ/4AoZHmSpJd6YkSYNUZNkmSYPntoswPIiZnwDwFQBPYzYg9jJUAZoL3qIkorcT0SbzGsDPAngOwMMA9ldf2w/gId9lxMFFfGN03HRFk210CVMl6c4UJWkIlWWfJA0e2zDSOEpm/jQz/11mfg8z/xIz/8i1aiFbbSuArxGRKecPmPlPiOhJAF8morswu8P5xwKWEYkhaXiIJMcaKrSA1Sm5StKdKUvS4JuGD5WkwSMNz/TKHG9RMvP3Afy9hs9fw6wdIHPaZDnm8B+faLLOAvQug77MgyQNrrJ0laTB3qY90rwMgPM1M2mY8ytz6lIsXZKAStKXeZKkYWic5CvJOj3bWOejzBkTWepA8vlkHgVpYxTQFF1KCdKmJx2fWuo9LWJI0qWdUiqaVOYLiXG1hnoqHkOSwOy4eGfzn3SaNaUdlaTig6QkDUaWMSXZgYqyj/VY22M7BfqiSpWkkhsjSdKgqfcQ6mfJqYnTRiWpzAsDJakRpS9TjDIBlaQyPzhcqaaiDKF0WdbT79IlaXqJdTB7N4vV89KIdSgMvRVEKDEarlNizqpTkWT9tbKaxZbXSicZj6MsRJSA3DRjY5FCkjEHmzeJUWW5lsWBn+WK5KQuHmWpKKVwmTVnCOeQ5rrsVMuJQZcQS5aldN0XPf+WCzdVzxKy9Cgj44iygDbKLkLbL8+1vJY6qy73LFN6SrYbIR9VDpFJwByEoyF9r+5FoXLG4qbae3vfdD3Be+7X2kYZE9/IsuvHD43+ltEsSZc6+HJj/1cG4xJxlRJZ3ojV20giO1kU/t4QJDs465KssxFJ5lnViDI2rveWGSqotu+17TRD5Ni0jBiRJRAWXfqIL7fI0uWk4ZudLHp8f8ljOTY7Gz57zbOsPknaDIkyA/flTI2UabVC6LtVgkQU15Q++0jSLi/GGdsWhYs0Q6LDHGTpG1W7ynLRczmL8JNlkyANm6tnF2G6SLJOSGreQsap9wRFabCFGbMT5Rz8z+b1cgyxpQm0i1MihR5DllJNDkNkuSiwnEW4ybJLkjZDhRkiyTpC+6sOOB+T2D3NEpKsY+ocs13IN9ocSipZSrbJGrpkuSi4nEUMk+VQSdpstl7X91FJSQqiopwymxFHlkAaYQLyPcCpiCFJQ1MTzmKE5SyiXZY+gmzCjjIzlaRBU++pEkuSSjcxJWljosvFiMtYxCVZSsmxic39XxkTjSiV+WPsDh1JFhMtY0OC5WSMilJRFKUHFaVSBjsQNsxJUQLRNkolb66snlWWykhoRKnkzZW197nLMlVHjpIUAnDF2JVoZgLXevdxffVQmqlL0rAjaS2Go5L0ZyOyHgKW8bXecyBKQ8myvCpSuW2SNOQqS8WdBJNahKKiHIv6lixRllur51iy7CMnWU45mow5NKguyUyjShVlTkjKchlxL5HcWnsvKcu+aNLGVZZTGkMJAKfHrkAAbZFknrLkdW6PVGTSmXMZgE0AzgiW2bVqtixf8izf7uyINftPE1ch/MB1kaRh7A6eqUaT9slP+qTbt0++jpxur8IEXMjESHUyq9Ym63WINF1Wy0jTRZgpZi6vR5M2IbL0kaRhiCynFk0aTkM2om8qq37HTh9c9z1pWfZdgnm0/U8qSh+MNF2F6btK9ZS8TZyuM5fHijTtA22oNEMkaeiT5S3V8xMCyzLkEE1eCWAF/vvXUMma/cVHmL77WqgsXa5Pt7+7WppMwMo619bAi47f9yNjURpchCm5Ok3pue8M5oahO3JXNNmEOQi7hCkhSUObLO22TClhji3J+nZzlaVvFDo0uhyzNzt0Ao/V/89EuLDe9Rh+M7AOwyhAlAaptNyH6wE8LlDOkGnTXCVp05aSS0rSYMuyq7PnFuu1qzTHkmTf9uqTpVSK3iVLaUG6RJXxZji6sC7PaxgLEqWNdMdPato6f0IkaahHlzEkaXDtDb+l5XPJND0El23VdFKKMYSrSZaxosguWcac/m0Gg3Ah04u9CxUlsFaWpa1KPbqUkKTNVZhFPiUQo12zC6mTR6qxrbYsY6fadVnGF6SBQVhRUcag9MgSmB0Ai5HKXo9yZAmsjjjPjlaLPEnVFjlum/CFTJWUZ62c2IT498VRlHmgSZJnEbf55hKaeisjUlpUGZs0B315jD26IG9RzuEljIqirGZ8SRouYJ3TYwhEdDURfYWI/pKIjhDR33etl0aUyhyh0eRahkgyTfodsTPnvwD4E2b+p0R0OTxWpjeiJKL7iOgUET1nfbZARI8S0dHq+ZrqcyKizxHRMSJ6loh2u1ZIiYGeD5Um8okkAZN6r3d69EFEfwfABwF8HgCY+U1m/hvXug1Jvb8A4PbaZ/cAeIyZdwJ4rHoPAHsxG0+wE8ABAPe6VkhRlBTkJUlDhNT7BgB/DeC/EdH/JqLfJaK3u9arV5TM/G2snZNpH4D7q9f3A/iI9fkXecZ3AFxNRNtcK5Unt0YsO8U0XlJRZT6zzbghmTqWug0MPpKMP1zLdOY4inILET1lPQ7Uil0PYDeAe5n5vQD+FpcCu8H4Hj1bmflE9foVXBotvR3Ay9b3lqvPTqB4JC5hrFPKAVev5wJync9w2thjKX2HxOUUSfKadx5tlK8y856Ovy8DWGZmczXDV5BQlG/BzExE3P/N1VTmr+z/joAamAHnsdvhboWMLHORYy71aONK6KDzLnxmGQqVpGSnTpMySHzAOTO/QkQvE9G7mPlFAB8C8IJrOb61OklE25j5RJVan6o+Pw7gOut7O9AyQSEzHwJwCACIbnQW7Qz7qhwzVjDXjos+MUnPd9jE+gTLkGIjLsngtcCyptDb3XZlTtvntkBziiKBZklGHUf5LwB8qerx/j6AX3EtwNcqDwPYD+Az1fND1ud3E9GDmF2P9oaVogvRd8liyJyBbTxdPQ85i+ceqUkRM/2uH/ybES7LecNsw3eOWou1tMdEDMKbuFx+iczPAOhKz3vpNQoRPQDgNswaTZcBfBozQX6ZiO7CbLLGj1VffwTAHQCOYRanO5u7HZdruiVk+XTH3+ozukjJMXZUmXs02XU9s68sN6P8S1wLuINiL/1JY9GTYjDzx1v+9KGG7zKAT4RW6hIhE14MkWWXDPuwU0NJYskyRpkSUaXLNnSR5ebaMkqVZeg+dgzjRpVurWo6KYYzErMCtckyRJApSHF/FilCZOkjASPANmFubvm8RFmWHkm6STLna70zFKX0tGlGlrnLUZLUk2C4yFLq4G8T4pBllyDMXCXZ1/Pt2S8LFeUALiLuvJIlSrItqvSRYIrbkvbJMqcDP2Q84rx01vngL0lDsW2UShep7udd8jRpOQmyCYlB3NLkvs2aospwSXKEcZRSzMk0azeNXQFPViAnyRRX0tSjrdwP+Dp9HXQposnSthkgIclZKV6XMCYhT30rKH+QdIkHvGGstswSt5mMJA3aRqnMCQvIJ4UNpcSe8iZiDBE6C2mxFz2OUpkSKTp1UosldjvxVGQpjfw21zbK0TkCYMPYlXDgdcwmPYlVdizGkGSK5ca6uKC+jJgci1y+DLm2Uc6BKI9Yr0uQpS2ykmQ5liTHWr4k5xC/s+0cgMPVI0+0M2c0jjR8tgHA+dQVCWAZs0mYpEmRhseiTYqx03AjM4nt1rQOsX6T+rL6ZNk229C52mvZuuqA81FokqQhV1m2RRUxZQmE7/Apo7m+ZcWSpb3cIULLJcL1qYct0hs7ypAXe66dORNNvbskKY3UAdGXesVKw4csuzSkJdUW/TV9zzx8kfwtJLZDX/T5uvUII8bNxaSYcETZh1RUaR8YvmfXoTtZrMjS1MGn/jlFk6mXaX436QhWIlKT2lYuw4rCMpScU+8JRpQu0WRI505T5OBzdnU9E8eOLF3qn7MkJeo2ZvocEqFJ1tunt9y/7rl25kxMlD4pt48sh+yIMulIMzFlaeire86SDPk/1/Q5ReeRC9K/i+9Adfe6mwHnLo9UTCj1DmmXdEnDXXfErnQkRKQx03BDWwpYgiTt/x8isxAZx5bl0FQ2lw4kg71/969DzgPO86xVtkg10pd0u9eShxEZ+mSWm2DqjNXLLnnZ47D2y1zbKCciSole7raoMsYOKCXJFFElMJ4sJbd9XZa5y9GFktalfV/KuTNnAqKUHApUl2UJO2BqWcbeJjHHt5bwe7aRQzOIFO2yVFFGIcZ4SSPLknbAVLJMLcn1KHvSYmnqgilpH62zVpYXcRl+hCvGqU4PBYsy5qDyEnfAVLJMjcpyNaki+xSsbYLSiFKUlFfelITKcj44ifzv0T6E1Vf9aBtlME03BytxNmilnb62yZxl+Rr87grpg9lOse7/noq1l0bqxL2DeBrA7trrrrsnprqxV0kcrx4AcMuYFYmE2V1zEubZ6jmFLOsnk5iylJ4R3ab9+nEdR9mJ2dlsMQ65xWypsjwOYHuEMm2esF7nLk3Xnu5co8uYsmzbRqVFlu2S1NQ7KnajdgnSPF57BsKlWZdknVBpnrWeU6WYfeQQXZ5t+CyGLPtOJKer59yF2T0TkYoyGUaaocK8Cpd2vhQY0fkIs0+SdVykmUoEIeQgzDqvVc8S28kl2s45uhw2s7qKMikSwowhyz6p1f/eJ05XSdYx0mwSZpMkDa9Zr0NlIDXAPMd0PFSYPttGSpZm1qCYbZWr0c6c0QhNy80OJyFMH6m1RZqhgqxTF2aXJOtIRk+hdMnyLGTvle66jVy3T8gJRDKylLjV7bBoUifFyIKQKDM0ugwVm7QY23gC7fdL6SO1DNqoy/Jsw+tQYbpI0uAShUtsl1xk6XYzs1xT74nNRxkT350uleQk8JWk4TWsFsJYmPN/m9DOdvytD9//s+naRjneywnwm8DXTZJ6F8bJ4BpZliRJSSTbMH0ZIjT7O5Jp+RCaInBpSUp37tiy7Isw3W+Lq22U2SAxfEiy3TInQqPJNtraMGNGTj6/zRjStGWZayTZRlc67n/vcG2jnBx9wpzXaLKNkqTQ1pYpkXbXeQ35Dunpo0mW/pLUcZSTpikdV0k2U5oUYohxatiy9JckoKKcA2xZqiTHZWpNIiVwDFLTvmkb5eS5Cjr929ioJEtGx1EqiqL0ECv1JqJ1AJ4CcJyZf96nDBWlGKcxu4JGU29F8SVSG+UnMUv3vBvIdcC5CHbKJz192tSIlR5r2j0u4UPvYgw4J6IdAP4xgN8NqVuvKInoPiI6RUTPWZ8dJKLjRPRM9bjD+tuniOgYEb1IRD8XUjlZYk3BpgeoEsIU7n1jCDvGGLPOHJfHAP4zgH8L4GJI3YZElF8AcHvD5/+JmW+uHo8AABG9G8CdAH66+p//WrUPjExqSZYWVcYabN6G9MllSbi82JyzHsDsHjixkLqH/FBCjrVZZ47LA8AWInrKehx4qzSinwdwipm/G7pWvW2UzPxtIlocWN4+AA8y848A/ICIjgF4H4A/86+iL7En8dVIMowlAIuO3++i/V7RMthjBENOLG0R5EkAWwPKbcJMDmJkGXP7hMMgvInLXf/tVWbe0/K3WwH8kyrjfRuAq4jo95n5F10XEtJGeTcRPVul5tdUn20H8LL1nWWMEl7FlORpDJNkKVFl6mgSuHTgLg347tLA79nlSlMfSH244bMh9KXZJyEXXTZNN5cquvQ7/sy13lKpNzN/ipl3MPMiZpnu//SRJOAvynsB/BSAmwGcAPBbrgUQ0QETLgNnPKtRZyPiptmuUWQpskxJ/WBdavjOEtwE2VV+KF1CdJGlS1ukrzBXrEcb+cqS/VLvJHgtiZnf+hWJ6HcA/HH19jiA66yv7kDLeBlmPgTg0KyMG9inHjNS3CcnJM3OfciQOdhTRJZtB+kSZmn4kvByQlLNoRLs234hnTUu6bjL7O6xmykMG+G6/rEuYWTmbwH4lu//e4mSiLYx84nq7S8AMD3iDwP4AyL6LIB3ANgJ4M99K9dP7pI05C5LIJ4wh0YwS8LLNct2FYLv9cr1Nkyp3mwTk3QJ0+cWGPnJsuhrvYnoAQC3Yda7tAzg0wBuI6KbMevRXwLwqwDAzM8T0ZcBvIDZr/cJZr4QpebR2yHnlcOQkWXq3tY2XIQQNqnD6nKk7zVjp+JbIXN/IPs3iinNYbJkEC5cLFSUzPzxho8/3/H93wTwmyGV6qeE29KWjK8sc5FjnSGylJJkCnK7iZoQDKysFCrKNFwJYLf1/umO76ok0zBElrmKsYmmdsuS5Fg6/VElM+HCSiZKqpFnrd6SZl2YKsm0tLVbxhLkccQfKWCiS5VkerplOROlRpQe7K6912nMxuEw0g11SiFLleR4dMiSoaKUYRdUlmMRW2DHa691DOp02dT4KTNh5byKUgiV5TikFlfJsjRNFVOa8EKKLuUQLl7IU0mFTrO2a+wKKKK0jTHNfexpE3Z7rrapr6ZHggxgZZ3bIxF56nsQGllOg9QyjLm8plEC7lenTJMBqmFKKj8XChYlUI4sS4yMUjB1SSozBmqGAaxQ1Jr4UmjqbbMLsqn4PF+V04W0ZIaWJ7VclWQ7Ma/KcYzFVhwfiZiAKA1SspRuV5pSNFmCtJqWNbYkJfepzYJlAVlJcjbFeZaiLDz1rhOSip+3XpsdO7RtaUqSNIzRG+27zLEFaZNTW2WKyTA81GJEmSETiigNLpHleevRxEb4z3E5RUkaxlg312XmJEnD2L3gC8hWksBMlOcdH4mYoCiBfln6bGWXnXzKkjT4rmOKbZOjJA2hsvSRUCpBAkFJKgO44PhIxMRSbxtblkcgc/oZkpLPgyQNqdPwIcuLtf0lO2xc0/D6XJT2YduWq6a+P46QSjJNvScsShvpGN2OCnJpdxoLF1nGPomUIMmhDJ3ZvC7NMW4gJqQRbaOcMrY05ymatEndi52yDrEk2ZaCb4X/3RjHiHsEl6m93lNnI4BjY1diZPoiy5gyLU2SBpOCS9+mNhXC+rgI4IeyRUqholQEMcKK3W5pS7n0KF5akqcBXCVcZhOR1JFp6q2iVCJQjy5jyKx0QZZMJG2Y4UEZoqJUImFkqUJTBmKGB2WIduYoEVFJjkPs+Qp2xilWO3Omzrx35CjzgxmfvBPAUdmiMx4epKIMRiWpzAv1K96EZaminCoqyemyHc23uFVWIyxLFWUXJTaVqiSnS314kwqzG9NmGShMjSiHYO7MdkawTLN6u7H2HuG+qCCnTdcYUPt+5hLSvFKgjFQMmZUrUJgqShckhNm0WuYe4b7CVEFOH5eB8q83fDZEnnU5riDOYSg58Nx1Umy7V9xBmjqO0odN8JNl3yrttl4PlaZKcvpIXE3UlaJ3RY+xZHkewIbAMkLvHODQhpnxOMqMRQm4y9J1dYak5CrJaRPjcksjzB0O/yMtSzPpRl+I1iVSqdurOKTkmnr7MiQVD1mNJlmqHOeD1Le0SIXL5MBGpHVhSt6wz9CTkmsbpQSbrNdnIFt1u/1SJamMhURU6TuDeurGwYaUXEUpTaxq74aKUpHBJe22CZHl2PfkcaV2KaR25iiKMhwfWZYmyQa0M0dRciTWPX98o0kbF1lOQJKGTFPvEi+JURRBcp7haIg1Ykny8UjldpDx7EEqSkUpVpaxJGlGmCSWpd7XW1EUf5pkGVuShoSy1Pt6K0rupL5HuSt2m2UqSSYm4+FBGlEqSjFsQPgliW10STJSVLml4Vp04TZKIrqOiP6UiF4goueJ6JM+VdWIchWPQ+/zMs9IRJUSPd5N2FGk9OWOI0SSTZKMc7vaFQD/mpmfJqJNAL5LRI8y8wsuhWhE+Rb2WXO79VDmi5CT5AKAs1IVsWhKtaVy1KGSFIwqmyQJROn1ZuYTzPx09foMgCPwOLB7RdkWuhLRAhE9SkRHq+drqs+JiD5HRMeI6Fki2t29hLF5HN07gcpy/nCV5QJWzxgkKcuu9shQWbpGkoGy3HJVuyQBX1FuIaKnrMeBtuKJaBHAewE84Vr1IfF7Y+gK4J8DeIyZP0NE9wC4B8CvA9iL2bVJOwHcAuDe6jlDhv7wmo4rTXTNP3kWaSbm9U3DfdPtxwHc6v5vXYI0+F3C+Coz7+n7EhH9GIA/AvBrzOx8m8reiLIjdN0H4P7qa/cD+Ej1eh+AL/KM7wC4moi2uVasG4l2INezo6bi80XbiXEBayPINkIjy6G9266jrxO3SQ6RpCHC8CAi2oCZJL/EzF8dXplLOJ2KaqHrVmY+Uf3pFQBbq9fbAbxs/dty9dkJ6zNUIXIVJr9jYA02W6+NLJcH/q8htK3FyFIjzPnC99YPqSJLYFh0mbEkIwwPIiIC8HkAR5j5s77lDO7M6QpdmZkxW83BMPMhZt4zC5u7dsLN1qOJHdaji762SFc0upw+5mQYen8cn8jSd6xkl2mkJDngOOprj2wiziWMtwL4JQD/iIieqR53uFVsYETZErqeJKJtzHyiSq1PVZ8fB3Cd9e874B1+tcmxjR1ojjBjXV2gbZfTR+rOi0aWQ6LL0AHlTZGldCTZ0lbpKkebCNOsMfP/AkCh5Qzp9W4LXR8GsL96vR/AQ9bnv1z1fr8fwBtWij6Qrgiyj3p0OcLF/YrSSl90KXXVjR1yxUq3a8dWiCSB4i9hNKHrYSJ6pvrs3wH4DIAvE9FdAF4C8LHqb48AuAOzGXDPAviV4dXxlWMTOwD8oWB5iiJFW7tljEsTY7dJVpFlqCQNmV7C2CvKntD1Qw3fZwCfcK+GpCQN/wwqSyVPUnbyxEZIkhlf662XMCrKaNiyLHXy3b2zp1cBbAksSm8FoShKM2cRJ5tKwd7Vb0NlqbeCGJOPAvAaY6ooSiN72/8UIktNvcfCxPEqSyVXzP2zT3V+y5+NAM4JldUhSJsQWaooU1Nv7Pho9azCVIZyY+Tyd1mvr0U8WUowUJIhaBtlarq2tgqzGXMgfH3UWswHu1o+jyXL66vnlzz/30OSPlFlxm2Uczwf5Uf7v9LLTUhypo3O3pbXsZcVo2yJ8k05Qy6NHcou65GSa63X11uPoQRsz1cdv693YUyJS+zuK8ubqoehZFk21T3W+sSWZOhy2kQbKkwXOV7b/xWRsrpkuRdiJx0XWWYsyomm3i7YsuxKx2/q+Bsw26lKSltTyr2+LMlt1bYefU0JPuvfNpdAG77RY0gK7iLappQ8wn4xNA3XNspSaOsd75OkoYR2vqEHgoTMupYVUr7LwSx94A+RpUR67SNL32jUCPPdnv8vSKZtlBMTpcTpyJblUEHWkY4uY0tLYrmxy/ddRgzaZCnd/ugiS8mUfUScJmtMx4REKRmz+wrSRlpuqSKwpv/tWm6ovGKXH4v6xNGpO2kAeTm+gGhRpcQljiMyIVHmiI/cJNNVKcnUlystr6b1ylWQdXYA2BSx/KaostDosWBZqijXcEy4vDa5hfTMjhGBpRJXKYK0OYN0sixUkoZOWebbmzMRUea5cS+RIgKLsZyUlFz3FBQuSJtWWeZ7sfcERJm7JGNR72FX0SgF0ShLjSgjkedGTYsKUimUNYPRNaKMgEpSUaaFRpTC5LkxFUUJQUU550jOCagoU0ZTb0E2QP7MY0Qmfa/ujdazylJR2tGIMmOa5CUly/oNo1SW02QjZpHQFA4ncw1h241XYy9bI8oM6ZJWqCzb7qoXQ5Yq4DywD/ISDy37MswxhKkRZQRC0u+hUvGVZcpbj2pqPy5tv7WRZgmHWNd16vYsFbGlqRFlBOpS6FsVX4m4ynIMSdrvS5VlzLqb7TTGtmk68HM67Fwm84gtTY0oBWnb2dvO4BIHx1BZDpWkhBS6UnsIlJ+KjQ2vperedCKJWf5QhkabbdGV1GEbMuNRjNRcI8pAXHZse0NLnp26ZJkyihy6vFhtoRAot6/+9t99l9W1jNjlD6WrTbNLGBJpvdS0cAw5WWpEGUBOkdH26tkWpu8B4ysyl+VJylIq8nPdXj7rEHsbxTgx2vIbGlX5dh6NMXfmEDSi9CQnSdqY6DLHSLLpf2Kn+W3Ulxv7pBJSPiIvYyi+oqj/X9OhHUuQUlGlRpQOSMoxxsB0g8QB4yKxkOWFyDJ0uVK0pcsxlpHrCdqFenqeaxRZRyPKHqawc8ZCSsqA23ZOHTEPJXa9pibMG8euxEDyjSgzua/3xYhlb4hYtgQuHRsplhdruSXS1mteGofHrsBAjChdHmnIKKKcZ9pS41gHZurllYzZVrpt4qOdOUovdXmlSC9TLq9kdNukId/UW0WZFamjF42WlJzQiHKCLAB4PUK5JQw5UpQYaESpKIrSw0XkOtIgk15vRVEUk3q7PPohotuJ6EUiOkZE9/jUTCNKRVEyQT71JqJ1AH4bwIcBLAN4kogeZuYXXMqZE1HGvEJHURQZonTmvA/AMWb+PgAQ0YMA9gEoUZTPvgr8xN+i4U6/BbIF5a/HFNYB0PXIjab1uP7SyxPfAA5ucSzzbUT0lPX+EDMfst5vB/Cy9X4ZwC2Oy8hDlMz840T0FDPvGbsuoUxhPaawDoCuR270rQcz356yPi5oZ46iKFPmOIDrrPc74HF/FxWloihT5kkAO4noBiK6HMCdAB52LSSL1LviUP9XimAK6zGFdQB0PXIj+Xow8woR3Q3gGwDWAbiPmZ93LYeYuf9biqIoc4ym3oqiKD2oKBVFUXoYXZQSlxeNBREtEdFhInrGjOUiogUiepSIjlbP14xdzzpEdB8RnSKi56zPGutNMz5X/T7PEtHu8Wq+mpb1OEhEx6vf5BkiusP626eq9XiRiH5unFqvhYiuI6I/JaIXiOh5Ivpk9Xkxv0nHOhT3ezTCzKM9MGtc/T8AfhLA5QD+AsC7x6yTY/2XAGypffYfANxTvb4HwL8fu54N9f4ggN0AnuurN4A7AHwds7tHvR/AE2PXv2c9DgL4Nw3ffXe1f10B4IZqv1s39jpUddsGYHf1ehOA71X1LeY36ViH4n6PpsfYEeVblxcx85sAzOVFJbMPwP3V6/sBfGS8qjTDzN/G2jni2uq9D8AXecZ3AFxNRNuSVLSHlvVoYx+AB5n5R8z8AwDHMNv/RoeZTzDz09XrMwCOYHZFSTG/Scc6tJHt79HE2KJsuryoa+PmBgP4JhF9l4gOVJ9tZeYT1etXAGwdp2rOtNW7xN/o7iolvc9q+ihiPYhoEcB7ATyBQn+T2joABf8ehrFFWTofYObdAPYC+AQRfdD+I89yjOLGX5Va74p7AfwUgJsBnADwW6PWxgEi+jEAfwTg15j5tP23Un6ThnUo9vewGVuUIpcXjQUzH6+eTwH4Gmapw0mTBlXPp8aroRNt9S7qN2Lmk8x8gZkvAvgdXErnsl4PItqAmWC+xMxfrT4u6jdpWodSf486Y4tS5PKiMSCitxPRJvMawM8CeA6z+u+vvrYfwEPj1NCZtno/DOCXq57W9wN4w0oHs6PWVvcLmP0mwGw97iSiK4joBgA7Afx56vo1QUQE4PMAjjDzZ60/FfObtK1Dib9HI2P3JmHWg/c9zHq9fmPs+jjU+ycx67X7CwDPm7oD2AzgMQBHAfwPAAtj17Wh7g9glgadx6xt6K62emPWs/rb1e9zGMCesevfsx6/V9XzWcwOxm3W93+jWo8XAewdu/5WvT6AWVr9LIBnqscdJf0mHetQ3O/R9NBLGBVFUXoYO/VWFEXJHhWloihKDypKRVGUHlSUiqIoPagoFUVRelBRKoqi9KCiVBRF6eH/A8kgY0AJeH18AAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -327,29 +246,19 @@ "local_standard_deviation_neighbor_count = cle.standard_deviation_of_touching_neighbors(neighbor_count, touch_matrix)\n", "\n", "parametric_image = cle.replace_intensities(tissue, local_standard_deviation_neighbor_count)\n", - "imshow(cle.pull_zyx(parametric_image), vmin=0, vmax=10, cmap='jet')" + "cle.imshow(parametric_image, min_display_intensity=0, max_display_intensity=10, color_map='jet')" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -363,7 +272,7 @@ "local_mode_neighbor_count = cle.mode_of_touching_neighbors(neighbor_count, touch_matrix)\n", "\n", "parametric_image = cle.replace_intensities(tissue, local_mode_neighbor_count)\n", - "imshow(cle.pull_zyx(parametric_image), vmin=0, vmax=10, cmap='jet')" + "cle.imshow(parametric_image, min_display_intensity=0, max_display_intensity=10, color_map='jet')" ] }, { @@ -379,6 +288,18 @@ "display_name": "Python 3", "language": "python", "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.6" } }, "nbformat": 4, diff --git a/demo/tribolium_morphometry/tribolium_morphometry.ipynb b/demo/tribolium_morphometry/tribolium_morphometry.ipynb index 2876dc35..80a12391 100644 --- a/demo/tribolium_morphometry/tribolium_morphometry.ipynb +++ b/demo/tribolium_morphometry/tribolium_morphometry.ipynb @@ -22,17 +22,20 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Intel(R) UHD Graphics\n" - ] + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ "import pyclesperanto_prototype as cle\n", "\n", - "print(cle.get_device().name)" + "cle.select_device('RTX')" ] }, { @@ -53,10 +56,21 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "(213, 710, 355)\n" + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: 'C:\\\\structure\\\\data\\\\lund1051_resampled.tif'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0mskimage\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mio\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mimread\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mimage\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mimread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'C:/structure/data/lund1051_resampled.tif'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;31m# print out the spatial dimensions of the image\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mC:\\Programs\\miniconda3\\envs\\beetlesafari\\lib\\site-packages\\skimage\\io\\_io.py\u001b[0m in \u001b[0;36mimread\u001b[1;34m(fname, as_gray, plugin, **plugin_args)\u001b[0m\n\u001b[0;32m 46\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 47\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mfile_or_url_context\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mfname\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 48\u001b[1;33m \u001b[0mimg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcall_plugin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'imread'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mplugin\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mplugin\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mplugin_args\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 49\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 50\u001b[0m \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'ndim'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mC:\\Programs\\miniconda3\\envs\\beetlesafari\\lib\\site-packages\\skimage\\io\\manage_plugins.py\u001b[0m in \u001b[0;36mcall_plugin\u001b[1;34m(kind, *args, **kwargs)\u001b[0m\n\u001b[0;32m 205\u001b[0m (plugin, kind))\n\u001b[0;32m 206\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 207\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 208\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 209\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mC:\\Programs\\miniconda3\\envs\\beetlesafari\\lib\\site-packages\\skimage\\io\\_plugins\\tifffile_plugin.py\u001b[0m in \u001b[0;36mimread\u001b[1;34m(fname, **kwargs)\u001b[0m\n\u001b[0;32m 28\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'key'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'img_num'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 29\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 30\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mtifffile_imread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32mC:\\Programs\\miniconda3\\envs\\beetlesafari\\lib\\site-packages\\tifffile\\tifffile.py\u001b[0m in \u001b[0;36mimread\u001b[1;34m(files, aszarr, **kwargs)\u001b[0m\n\u001b[0;32m 758\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 759\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfiles\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mstr\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mPathLike\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfiles\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'seek'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 760\u001b[1;33m \u001b[1;32mwith\u001b[0m \u001b[0mTiffFile\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfiles\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs_file\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mtif\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 761\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0maszarr\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 762\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mtif\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0maszarr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mC:\\Programs\\miniconda3\\envs\\beetlesafari\\lib\\site-packages\\tifffile\\tifffile.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, arg, name, offset, size, mode, _multifile, _useframes, _master, **kwargs)\u001b[0m\n\u001b[0;32m 2851\u001b[0m \u001b[1;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'unexpected keyword argument: {key}'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2852\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2853\u001b[1;33m \u001b[0mfh\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mFileHandle\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0marg\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmode\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moffset\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0moffset\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msize\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0msize\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2854\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_fh\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfh\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2855\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_multifile\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mbool\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_multifile\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mC:\\Programs\\miniconda3\\envs\\beetlesafari\\lib\\site-packages\\tifffile\\tifffile.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, file, mode, name, offset, size)\u001b[0m\n\u001b[0;32m 8577\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mis_file\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 8578\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_lock\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mNullContext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 8579\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 8580\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 8581\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mC:\\Programs\\miniconda3\\envs\\beetlesafari\\lib\\site-packages\\tifffile\\tifffile.py\u001b[0m in \u001b[0;36mopen\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 8590\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_file\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrealpath\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_file\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 8591\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_dir\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_name\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_file\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 8592\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_fh\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_file\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_mode\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 8593\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_close\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 8594\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_offset\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'C:\\\\structure\\\\data\\\\lund1051_resampled.tif'" ] } ], @@ -71,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -82,10 +96,10 @@ " if (len(gpu_image.shape) == 3):\n", " gpu_max_projection = cle.create_2d_yx(gpu_image)\n", " cle.maximum_z_projection(gpu_image, gpu_max_projection)\n", - " max_projection = cle.pull_zyx(gpu_max_projection)\n", + " max_projection = cle.pull(gpu_max_projection)\n", " plt.imshow(max_projection)\n", " else:\n", - " plt.imshow(cle.pull_zyx(gpu_image))\n", + " plt.imshow(cle.pull(gpu_image))\n", " \n", " plt.show()\n", "\n", @@ -93,40 +107,19 @@ " if (len(gpu_image.shape) == 3):\n", " gpu_max_projection = cle.create_2d_yx(gpu_image)\n", " cle.maximum_z_projection(gpu_image, gpu_max_projection)\n", - " max_projection = cle.pull_zyx(gpu_max_projection)\n", + " max_projection = cle.pull(gpu_max_projection)\n", " plt.imshow(max_projection, vmin=0, vmax=1)\n", " else:\n", - " plt.imshow(cle.pull_zyx(gpu_image), vmin=0, vmax=1)\n", + " plt.imshow(cle.pull(gpu_image), vmin=0, vmax=1)\n", " \n", " plt.show()" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\rober\\miniconda3\\lib\\site-packages\\pyopencl\\__init__.py:252: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.\n", - " warn(\"Non-empty compiler output encountered. Set the \"\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# push image to GPU memory and show it\n", "gpu_input = cle.push_zyx(image)\n", @@ -144,22 +137,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# gaussian blur\n", "sigma = 2.0\n", @@ -180,22 +160,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# threshold\n", "threshold = 300.0\n", @@ -205,8 +172,7 @@ "gpu_masked_spots = cle.mask(gpu_detected_maxima, gpu_thresholded)\n", "\n", "# label spots\n", - "gpu_labelled_spots = cle.connected_components_labeling_box(gpu_masked_spots)\n", - "show(gpu_labelled_spots)" + "gpu_labelled_spots = cle.connected_components_labeling_box(gpu_masked_spots)" ] }, { @@ -218,17 +184,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of detected spots: 1650.0\n" - ] - } - ], + "outputs": [], "source": [ "number_of_spots = cle.maximum_of_all_pixels(gpu_labelled_spots)\n", "print(\"Number of detected spots: \" + str(number_of_spots))" @@ -244,70 +202,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJQAAAD8CAYAAACRm43jAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABLQ0lEQVR4nO29e7hkV3Uf+Ft7n1NV93a31K2WkAABkhAISY6RMC8bxsFgMMgMeL7JeGCcwPiBZsY4Yzv5YmMzk4nzOQmM89mAkxA7Bgd7mDAYAzb+GCfYYBIPIBAS5iFeAiSQ0ANJ/b5dVefsveaP/d5nn6q6t+v2fVC//uq7VeecOudU1eq11l6P3yJmxgorLAtip29ghf2FlUCtsFSsBGqFpWIlUCssFSuBWmGpWAnUCkvFtggUEb2YiL5MRHcS0eu24xor7E7QsuNQRCQBfAXACwHcA+BTAF7JzHcs9UIr7Epsh4Z6JoA7mfnrzDwF8C4AL9+G66ywC1FtwzkfC+Bb0et7ADxr1hsGNOQRDmzDraywXTiFYw8x8yX59u0QqIVARDcDuBkARljHs+gFO3UrK2wBf8Hvubu0fTtM3r0AHhe9vtxuS8DMv8vMT2fmp9cYbsNtrLAT2A6B+hSAJxHRlUQ0APAKAH+6DddZYRdi6SaPmVsi+jkA/xGABPB2Zv7Csq+zwu7EtvhQzPxBAB/cjnOvsLuxipSvsFTs2Cpvv4KGQ4iDaQhEHTsBaBWOqSrgxmsxvmQUtinG8MGz2Hh8eC9p4ODt96K9p7Om2bVYCdQSIQ9fiLv/l+uxcWUTNjJw8S0Vjv7hpyEuOozv3PREPPx9Go+5+js4OHjEHyaIUQmNRw+/CQGGIJPBuO3Bx+KR+58BABh9q8YVv/U56FOnzuvn2gxWArUkyMMX4u6fvR6T689CxjuI8cjzW5x91NNx9vqzuOySB/DEuoEk7Q+phMbhwVnUQkGAMZQtBBiVUHjeY+4EHmOOU08T+LMLno4n/9M7oE6ePK+fb1GsBGpJePhl12Fy/dnOdiE0hmstDvzgKVwkFQQxWi0gBIOsFlqvpqiF6rxXM0GSeT4ULWqh8OMv+BjeVf8Arnr/FPXH74Aej7f1c20WK6d8SWidO0TsH0Iq1LXCqG5BFMwYM0HDSMrACpmDIIZAmrCvhMa6nGJILQ7KCX7mhz6C57zpFnztH98IMRphN2ElUMsEMQgIDzIPAInQOAykMXG5AMUQxBiJxh8jSUOSxrqY4id+9KO7TqhWArUsEKzOCdBKQGsCEUNz2FtLBUkamgmCNKqCuQOAmlLtFftdADASDV710o/gzl+7EY/81PeD6sHSPs5WsfKhlgTu+a8pRDBzrRZYixxyI1CpdhJ2XyUUKqEhoRMNJiKhqknhiDiDf/SyP8GGHuB3Lr8JT/gXt4Kb6TI/2qaw0lBLQHXZpThxDXcMV1UbzaO00U6KKdFUgBEqzQLKbpeZgNVCeTPnhEmCMaIW62JqX2scEmP83Cs+gLt/9ek7qqlWGmqrIML0Rd+Hh/7WAONLGLh4DNbG7hExZKUgpbbOuFuxBW3lnHTNAi0LDEhDMaHR0qzoSBmTB0ZNwSRK+3ooGvvaChlpHBWn8YuveD9+i34MT/hnO6OpVhpqKyDC5CVPx93/tcTpq1u0lzTJbs60EMWru2iFJ4ghrC9VghHC1G8yfpXTVKn5A4ALxFn84n//fqOpqvOvL1YCtQXwDzwV37xJgCtrnhqCs3fM7mGEhIj9c80EpQUkaVTCCIPzoVot7evgpCsINCyhWECQ9sJUk0qEaSQa42tZs3hYnsGPvOyTEEeObPt3kWMlUFvAxmXDIEyA/xZdmICs2SMbRmiV8H5UjNjZdlqrthor1loNS28Cc2GqqfXCJMH+cd36t3HvTzwJYn19uR9+DlYCtSDkJZegevRlqK58Ao5dI7OdkXC5wCacSTPPtRaQVis1Orw/PiaGgkhWeBNdd46pqcXAai2ZLQkuq47j1177B/jKP/9eiBuugzx60eY/9BawcsoXAD/nBnz9R9agKxMeaC9sw07JIME2khlpHJX+Xx3WLWorUEqbfcZEWeEDoyaNia4wFC2GYmqcdhAEGIoFNAvA+kqzhKmmFpI0BlB460vfhlM3reG373o+qn9xBeRHblv215NgpaHmgH/gqbj7JWtQI4ArAAKgNvhM4cD+c1RSe+3k0GojILFpc2ZPg9BwqgVHdlXntkvr0MfCJEljJKYmzACGgMZINHhsdQxvuPqP8bw3fwyTlzwDEJmGXSJWAjUD4tAhfOuHD0BnYR0xFjMFqITYgyJbqgIg9ZW0NI679aFioRI+GGoc9VzgAEAgxKkAI4QDhJDDiw59Dv/zm96De173LFRXXbEt/tVKoGaAiFD43aybVF7qOzCTlznNRv6cvzQQIaWSaCi/GhR+v/O3GpZ+FacgoLLQvAt+OmFyzrqD02bXDe/D77/mzfipP/8wvvzWp0AevnDh72MRrARqq9Czd8cKTAqG0gKtFiboKYKzXaouMD9+uIAkjYmuvWMuYYSn4crvNwIUhMmsBjk6n/HRJBgHqMVTBg/gvT/4VnzpzU9cqlCtBGpBMEUPwYALA2iAVVdbuS1UWMGZt4XYVI6haCGIbTggvL9hadI00c+mQIkwCbjwgYtzpeEEBwHGumjxgb/9r3Hvq69f/IuYg5VAzQBPp6hPWQGy4QCWDF3DvGaYb1CwSbtEwiErlfhNOjKBzlfSMHm8qTVrlVAYymgFiRABz1Mw4bzhJxRWc8UC5vdRKkwuDVSTxo/91EfBz7lhU99NH+YKFBG9nYgeJKLPR9suIqIPEdFX7d8jdjsR0Vssjc9niehpS7nLHYIej3H0C2laJQ4PUEv+OWuCboNQuSqDGNLn70Lg0giVeT60JcCxkLjUSy3axDGfWnOXC1msifq0U5yAlmD8j4dvwfPe+nHo596w+JfTg0U01L8H8OJs2+sA/CUzPwnAX9rXAPASAE+yj5sBvPWc73AHIQ4cwHdurBPNk/jCDCAyd06oTHHd7GWgE6LKCkTLAmdVnZhC53yLglBMdA0V5foU0ucAIsEK76vj8hcwagIkAX/38Kfxt//NJ85ZqOYKFDP/ZwCPZJtfDuAd9vk7APxYtP0P2OATAA4T0aPP6Q53ECQl1NBaO1tJgFxQspQK62DalBZmtWfrnmJ/qRLaCxNg4lJtVMbSsESrBTb0wAtZbESdtpraXF8MBQEFMkIWayxX9QlGDfb16sI+XnX4VjzrX30a1eMu3+xXFe5ri++7lJnvs8/vB3CpfV6i8nls6QREdDMR3UpEtzaYbPE2zi+YkGgrAN0yzQxOiIgYyiaHgXJJsDN3LoKuIDDRFTbUwAuTsD7SiBoMsrKW3G+Kr+P8JhlpJbM9vj7wysOfxIlnFX+yhXDOTjkbCrxN0+DtK/aVSEuRYAihrWZKV3GxELlIeYxKKNNK1ani5CSX54TN5PsYkrTXSHERnovEG3PoBCs6b/Rc2sdFQuFnfv19JqK+BWxVoB5wpsz+fdBuX4jKZ6+Ar3gMWHIIFfRpIxViCiQYRK6ILhUi93ZXxqILJ8xjUi7m5HJ5JnQQKkBLiKPjUwgffQfKmimO3Uoi3HTgG/iBf37LluJTWxWoPwXwavv81QD+JNr+KrvaezaAE5Fp3FOQ1z0Z33ypydA7y0LaulBxUAowkmL1tKt9YjY9eVLoTk0UYExgrKUEmcBjw8LXRgE2JhVpIQBouIKECWzGfpULdJrzhZKWWEMBBc1E5B8O16/fC9pCN80iYYP/AODjAK4honuI6KcBvAHAC4noqwB+2L4GDOPK1wHcCeDfAfjZTd/RLoC85BLc/fKL0a5bM9HaEAEAsBUsDcDFp2CfC4awpSylsIGDc9RdLEoQYyRbX1gXhxJcxQEQzFgMo7X6i0ZM4DOs7FR0W06YSviv1u7GN17zxN7z9mFu+Qozv7JnV4fD0PpTr930XewCiEOHQI+5FA8/8xI0BwCV/ed0ccy4Ipd1EDIwgWwNeRwy8MIDY6J8HMquwICug27Mk4Rghhahe9jvB/l6qSlLrGMCxQI1NWhYJs46YARRMWXxp35hAoAREc4+pu3d34fv+nqo6qorMHn8RXj4iUNMjhJUbcpUjOAQ2BXPuT8iikUJNmYvFiD711VrmiAmIGD8plpENVA2jyeIO63oTvgUBGqYSs08DGASwuE5gOJKT9maKgeN1G/K4XWg7Neyc9/73QZ5ySUQN1yHB17waHznhhGmF1KICNjv0Zs2wHSz5Dm7wved/5+XdsWntH0wdWqjBsJoAuc7STJL/EqoYq7PhA2mtiS4hY5We3HfnsOYJZoZP7WIHjUI0j7e+Lx3Y/Kjm1vtfdcJVPW4yyG+9yk49sIn4sFnXYh2zbY+sfWVdBq7JEVGkAjmv3bpP62LmHuHvGxKmCkRuHyl53J7JSg2QuOaFGZhOkP/5OIWC5DM/ju8cO0+XPTLd22qIO+7yuTJ656MR264CO0w9I2TtibMrtRImxVaDrdJtATlzSCBpgDXMA55rZOWKffXbXPBTQfnfGsWkFEKBto2eCLUoA9lGzpeClpIZKLiAqSAi4yHtEy9ibDhwXqCMwsf/V2koeT11+D4914EVWertZa9WXPFdKTgJUhXpsLAi4E2msyDjQaj2qi2Pu1k6qAYeWdwo2TRrMWInfY+DabtTxnCEFE9FbrX3S58VwiUvOZqHP9bR6Blloqzq37RcGLKyAqbrhhcGSfd705qeRmQDB4pkAw/YN/4nNx3AqyWKgQ4K+pGzJ3DnefuhF3tue0DKKP1wBhAJ2GDktO+TOx7gaquugKnr73Ir8xIsxeqguUAyJhAPeBOnoIlwBWbfZLBlRWmqhtF13E6JlrV+f0uzgTGVMnUFEYkGoLYl/c6bOihdcS7HS853HmUv555KABqGwaY72uBkldfidPXPyqYOQBgQLTcKRpgJzAC0HUUGmAfZgKIoetIeKzvxZnwULCqprAui5K7eihXEmxY7YxQuTCCO3YkGtSkOo0JIvKJYuSrvHnmdBYEmaAoicXPsW8Fqnrc5TjzlEuKTQbgyE9igImMEPV8byxh7SD8g+NIOKNTsZlDREIG2PIVG5Ny0fA45RK3WLmaKCcsgjQ0hE+txLXlpkS4ex8lH0oBUJGGq0kkDwnCz1/2F3jwNc8IzGlzsC8FiuoBmscdNYLAwScKB8A0bUpAVwQ9RNA62bFmBcjJfvY2M/2RWJc1wqxiu0qkZBmOQMNBsQkt1KL1YYMSdPRTzkrF5Gis2aupLApXVcDbf+lNeOQnn73Q+fadQFE9AJ76ZDQXDCDaKNOvwmpO1aY9yvhEPWRhrijHaSV/ouyvOzyu3LRJYq3DibXbFplAAUZFyps/FxoAjLOuELRUqRW9b8UHAGOuMc6Sx1vF1TXj1ItPL3TsvhMoefFFmFy8ZovhgrZhQT5o6eJOuqLZlVzcUUIBrtgu3x9VG7StSXj0hRI0CFNdQbNAJbSPmPvPgnIPnoNjZ+mDq9xMrxmCmxJATQSxoDlbBPtOoCCEdaDNS9LpL05ZHImcJopdotSH7+xPvjVNIMkg2TWDzASlTD+eQ+7LTFSFM+0A47argZSPLW3+B3e9faYl3eb77N+GY6FanjAB+02ghIQ+ckFnc5yP09bUGe3FXvhcNoMlDH+BpiAb8Q+af//5ajFzzksR85yuR5LGIGqfktFxMTyvAXQnMp4jbhTVoCQs4UIHs6oNtor9I1BCQl5zFaaPOtAxU3HsSVfkTZ5P/nJ47TWbjxVE6DF/STjH+kqwJcBV1J/n2tM1EyZthUlbQTNhvZriQJXSF1aWCypGqCs/t/iRpNnVBjnGrDD660MLHbtvBEoePIDmUQeL+1hQWnaCUHBJipH8bpl562F8DiBTRx6/9vckOdFQuWYCgMqy2SWcUfYGPAtwQYDcqi5fEW4GihkNGJrZhw9E4d8pzVh/cE7vvb/3/YIo+NZRLFZ4tCybLu9HWUc+10RGi1F3P7GpiXLXsXXkRAxhUzF5UNMNCRpWLYZVC2nDBlMtcVZ1/SjAmETXm+cw5cqUwkTbxlynhBrZz1ta8alMmEq4VA7w+l//9wuVsuwLgaKqAl/+aLD1CRJH2wlKfLzK4lIcVn9xzMoV14WVoi1ncZFxgvkG3WqPTSwKcbS8YJ1qWWZfGavaC1XObRAaQLvxJl9cl8WoZBRN70sOSyqXruT4odFJ3P3S+T7XvhAoecnFUBeOQG34Qr3PNCBfVEnMPnRAKhxDkdZxv6+WaX4uqdx0hGO2pjwWmjz+5NDXh1dlCeOpNkLiOocdtbQqRMBraqNzlZjsuvZagdAwfF+MABYPGyxw2L4QKAcnNA4syZg5Ip9uITY+k1cM0aIsMZWxMOVfpODy6g6h9Nc990FMKzgEm/yFqT2vMq1SkfaNCzk21LATd+rTTvMQCxXQb+42i30lUADSeFKUgSAOmsjk5uwxIjJfhfP4MILKgpgusBm/JRKqGLH/JMhyRVnTFXe4DITCmmyS98WlLY7w3sSXTD7P5PmCMMWhhVIlgolLuec7EIcioscR0UeI6A4i+gIR/bzdvnsYWEam89iYNu4EM90+Jqe1wjYgmEDzwjxEQ7bBMz6m4NTn6qvHd3Jym6/y8jku8aqtKfAWxFAscEYPEpKMhis0LBNhSnKF9q9pRw/b9Yy4luvZq07MDzYsoqFaAP+Qma8D8GwAryWi67BLGFhoOER7SRTM1IBodNdMOeEo+Kax0MRxKIrzFHZjx7JomFZ0JtuGbi4Qp1vYdr64nJ2rdyqGA2xlQQmumiC9vPD15nEB3pgd253ZNs6EzEFl25zw1CT9w4UP3vnjb8GxV39/8d4cFmFfuY+Zb7PPTwH4IgwBxsuxCxhY5GMuA0sBWM1Emo0ZE/CrvhjOMTfP4x3dc4s2RMu9n+XCzLGwOefexp2YybCw5CYxikN1aRADF4H/bAiVCJK0n+8Sw9RKpdUFGsJUcMYNEEyYFrSdBtBw+r+kz5+6cSDw5P/pizObFjblQxHRFQBuBHALlsDAcq6gegBeHxlHnAGQMVO6tkG/rJCOtBWy2JRZRtWIAnzORaPnTB06HyAoQVe16aoPiBi1VKilm1IV2tDjeqeJXekJ4mLy18WXcmLWrULDRMNnmT2HoZjd/LmwQBHRQQB/DOAXmPlkvG8rDCzLoPMRT3gs9FptakNc8HIoo0qDrj9FzGn/HWeayu2irnsEQhjJ4b45bYVKI+okDoJkPiui6VPhpLHzrmfEihzyEpa8Q9ihphYHxKRj4po5GcDc/G0FCwkUEdUwwvROZn6v3XxODCznSudDVQUMB6FZnwhcC3AcDWeAFuymdrGqcAHAFda5nJ+u4yXkrJsLdrJtXZmv3cSEcVuhtSUrvgpzgR/TOeguRlWCQH/fnqP2cRXRrqZcwFZrbirDV8YiqzwC8DYAX2Tm34x27SgDCw0G4EoYn4gL2sQdly23mKgjOLHGEg18dN1pOrcvPZG/QGoGoziUPzTTSnlOL3fQS8ODAMOz6YKZTqiEZWWZ2mMG0XChWbVSQIhDuXLfeZhwgw/ffp1NB5SxSK3ocwD8PQCfI6LP2G2/CsO48m7LxnI3gB+3+z4I4CYYBpYNAD+5wDU2DTpwoPh/mpTlZ5LOVyJbppL7Tq4ZIYpDOW2kzD5iGFMWlbS4WnJiAnMkTPGqDkiaFeIOGCc4Q9n6Js+BaIxg2HxhHuws5fIA4Iwe4rA0M180BBTKrejxdRPyVnQ1imKzvC055h8+exGufcuxmd0yi7Cv/DX6g+47x8By4UHEhfOBHYUhGts1XhHUwAYb7epPKIYmF2NKzWOnrDda2bG0EfYoKEqarJ/ERuAiLeP8JsBQ+2gGKtdBHF0jZvZ1QjUQ2pOLxeYrN2XdeqnKdiGHZgbzt0yX2FcP1bfK+5H1E/i3/+YMqr/32HTZlbx3LyL6IrgSHZILvy/+wqyGSggw3HFRyxQQ+VJeoKITR9qGiX0rFWYx3CE1e8Oq7S0LBhznUx5vCrNfDDmZsoMX0w/t4k8OsTCJKEoOlPvyZhXdCQi878l/gnv+2yfMOGYPQgyHwKBOwtEsKIQPYLSTFwgCdOZOeL/ZxZWA5HiOqGxEG2nCOP4kEMpXNEE3oujMuTxeLkSlqegALIdBkHrnsDfeT2qtGUz/Zzj/Khcqd44BaRt3mjtZpBcCArOaavakQNHaWnG710hU0E7+mPhEVqAixhUjTPFJbXxKR0V6mspOujWB7E1hikaFuBMATzedw/XnxUFN8z6dBDF11ISQT0+IZ73kcELlX9uaqEXiUPOwJwXKwwlK3tkaBzP7YkwyqzgofRPWUfcnii+jKNAkxsdyuC1mgrAEGS50ILNYVFsodamE8tTSQ9H6cEFJQDb0sLPvAJly4kVaqDRM/En7EMK5icTeFCgpUq0jyKRecrXAsEQYkbOcpVKA1NEOB3Yvm2q3TMAq7QkzyMYxWJuulzgO5WbhxQVz08geSzLkrYIY68IIRpwkVqAu0f2MBPKsjhmVPF8sqPmNdozDX+sP7u09gRISdOhgEJKYhVQxSLllvTUrme9kUjMI1ZmM0KjgD0LBpMXayJ7bV+hZ+bZCFCPn3GyUuSE3OWEamTeXGA4T0PN8nxHY2EdyA4M2C4G0UaEmkwB2Zk+Aig8JxplLl5TL2w0gKU0yWPUwg1k/h1q2aZaowTMyS4D564KXokW3WaF4A1Yzue9Up4IW9+eRYNR1RqAa8RlUpDHK6p8mukLbE5Cc6No75p66h9TCzQmxCYzLV/I2dDHDVF5RreN9r/+N3v17T6AGNSyzfGEnQdnEcCjvddokOiyOfkd+kq9/EqYeyvmopjsmDSd47aThBwiRG2iNEIdqGum1kozGwgpiHKgnPr/XxmkV7vbtAcBY10nVpogi4md0SF+VfCfXmxcvarvH6IUofh4r+0fL7jmB8nAfPP4EWZuUX6HFznWMgt/kWezYlq84QYprqfKcn+Uop6QDJhyilECco1ZaWILV/h8vztXleb5SSsUJlQLhjO6WCgPAoEilGMpX3EpPn0OSeM8JFK0FAnFqtXfOO79Nx2kPu0p+qtdOWVjBOF0muGmCotmb+4S1cCulioMSXF1Ufpy0vpXj2cyrDeLQwRk9nEmmoVH+8Y0nNX912Ie9J1B1FNBslXnOrtyk+2MnJbzaClfh+4rbpwB3vuwg56wnuRMGKg1WXYccMGkXRy09Dy0bR13YysyNaBy7K7CrRVsUlJFoMKJQoNJHMe3vK3vtwgaLtKe//8zhhc+7qyGPHAGGg1DjJAWo1cZPIhMpF4rTEhb0VyIkvXsF5CkYAFGvHpnJ6FV4s25ER6hMHs+U/vouYnSj5iW0WoZiO6RDGE+pNW8WBWmMKDj30r52c17yNA7QbUVXYG/65pm89z3U3yawdwSKCLS+BhAZLVNXwdzFoQMXZ5JIVnjmQHhhdC1Xcau5+96T3CBxCD3k8dPCPBdWofTXt1AVSlrarNw32Zcw2ZExc1GlZE0K62Ji4lOw/OWRZjJTFwLVjxOqUgnwVvCOJ3y4d9+eESixvg4IgbgMkonAlYCu7HZthIQFBfNn1IFJm8SCYh32uOYpOQYAyDLd5X6V+ys5IbwH7ErPlq5Q1gSaTPQkbbmhUqGqSCeDrENbVJRbdF0utiIhjkvFFQnxak+BMOFlFAzPxp4RKIjsVrPlrfGBgvbxh1WAUFGVAQMu9OOZWIQRnM57RaTNNKX9fD7kjiRsIAR3BKmEs23tx5s5k9hq4evLY2zofKJnJDR2rKxe4KccUlg7KnQTxH20iJvB3hGoGCJKvWROJCelLfa1TcH40JG1KEKZ2inHANxbyRkHQ92muEHB1T1VYZLCLAJXQsoOHMNFzuMevZPtCKfteKx1Me00JjRc4bgqx4ZiLRXXrOerPAnyJcCzVnmSBOQMwdt7AuX+62d/mWBKVpJtkSmKg5JR/ZNQXHTK2XEbRELlS1riwKZ9TfniMaooCLdOdiiQ7nAaDKTCQCpUpL0jHuNEu4YNPejtchlz3UnBOD9qXinwopglSA57T6CIwgMIBBk+HsWBGCOul3Iax+XvYnnIlYrzpWIJyVeDVNiW3SaAQNQKIG9onmacUKVGBVdMF1cdlDCrn8XRT8/CrPKVeVopxp4YHkRVZcaV2vBAgsTrhSnFVRyG6wKWzN4KnOXY1AAgrTxElImJkPT8Bol2moO4J29QqWyfqToYFEZ2APAVB/MY6yRpHBBTP/Ezn/My6CEt2w7sCQ1FVQWS5VtlKSFaDVL2Syz8NvHqLQkNxHGmWGNpQChKGe/iMuFEc0WCW7p3u9oDUPxRzzSD3h+7VHGQQ5LGITFOqH1c4FNCY0Rt8Rwq2yRBxVqoRTWTw54QKO+Em//uaR5Pmu2iyaoPyNZCuZccUiuec9OavsQhL4UIbDyKXKVm/vtY51y3ouNoEzG0NpxRLkns0ipxCbAbIqRBmGjpTd08rItJQpYRIxdICU7+vzXMHbIxxewDm5sVJmCPCBQNbSZdu/R/IaAYmTjXig4O1QZxgDMuFdaWETgWFK/REg3mTGbOYJfei9aO3N4e4p1zuz8SJscTlW+bRq3oyblBScxJRr6RRiDIEKQxwOwSYFOp2cW5MgMv0ug5IqJPEtHfWDqfX7PbrySiWyxtz/9DRAO7fWhf32n3X3FudyiBKnL1ci0V3ysjONQWOp8AjdQEhhyffe4sB3EyDyaeoedLf13vVucCIVKer/JyOJ4DVx9V2R68NuuqcL15x9oDyaotXtk1XGHMNQZWVBS6CebtxiIaagLg+cz8VAA3AHix7Qh+I4DfYuarARwD8NP2+J8GcMxu/y173JZBUpqa8TghnNdDJU0I3QRx2BlttibQC1x2nOMp71RzohBiyrRRfEtEJtgpBGPaSkyt2auERi0VBqINgmSrEdwwoXgi1bqYYl1OMBQNTumRIWiNDJiw3OUp44rAFOUUT+mHj1d5WzF3fedNYGl53KCP2j4YwPMBvMdufwdSOp932OfvAfAC286+JdCgdveRrvKUNiGDlOCy7ANZ+LydDSHoisBViJL7t1mtlJSzxCbQmblE+7gn7gT2bdYpJ2IwgHFjLjaULQZCYaMdJOEDAFiTDQaixURXvtkzX7kdEIFgJBasnIvTCVVjt8cFdq5BYZlYSAyJSNo29AcBfAjA1wAcZ2ZnIGLKHk/nY/efAHC0cM7F2FeECAEcKYGqJ0jnmFbiAGZBjpmi1Vv86WO5JHRroxC9zstU4tEcPZAUqHzioCYzYaMdJFrEUeYomHRMHn9aFxMvRPPKf10MSiKdd1w8dgku9UJnYGbFzDfAMKk8E8BTzvXCC7GvCGlYVgBQFMxMYNvKAZiksCS74nMXgn+frhA0zRydGTd6dr6lOI8H2Ej5bIFynS+Cuq1TcRfMBfUY1Vy2/X6UGhZcF02OEZXppM+lP29TIsnMxwF8BMD3wzDTOWMRU/Z4Oh+7/0IAD2/9DrsfmJQ2K75SoBPBZOXVlGxDBq4SpFhnnsdN46h5Hrci+G/QMdaF0pXiuiGBtAT4A+uYD0XbmUgFBI5yh5mlwyxwXK9jim6VwvnAIqu8S4josH2+BuCFMLSIHwHwd+xhr0ZK5/Nq+/zvAPiwJdDYGuJ8RcQmT4a00n4KMp0wNhFsjrV/Gf6XDVSIJikcGhnccdFrdE1f3DlDHF8r0liMpMjOuXUlDRabvnFbdyYpSJicn2JXlWAHU1M8aKirTRQL77gvKlDLqDQAFku9PBrAO4jIsb+8m5n/jIjuAPAuIvp1ALfDcEjB/v1DIroTwCMAXrGUO83AUoCHFcAMJmG1BkMoDTWM/CwvWAyhCCpqQiBl2qxEY3r1EuecIuecwgPZaNhgWskLFiuCFgKDQQspu+bGWOFujAkIHTESGmuyMUStIIwte53axA8/zZLCsaaLoymO+F6b4nnUtPVk8iJ0Pp+F4dXMt38dxp/Kt48B/HdbvqMStFmLUA3jMzlt1AkR5IV1drPTLGzslHPMDcGG/YGVyfGpgRUsV9+hray6WigOfwkEzr15F/luBDCAL1WBFj4H2CjZEbKKlJ9IpZkAEon2ccJwSI7tayNYU5YYxStA0qihMCCFOku7KBA0gDr72mJse2Bzx2EG+aLDmsacjOIAIp/ImUInAByZNxWOzf0j0YTQgkuzBH+MbdomMnU+/mRf55ooctLcKs5ppo0mXdkt0g0jwEnOLockjQM0xcgSmJXMXfyDTx1JRuaR7NuuFzEaAiUVP2PFB3R+VwMOwcz0PeGprjLaHyeMpUUPwVR0Ouc7v2hh5VdJjUGlIIXGREmcnprVrQBjvZpCg3BWDbAZxB0wNdJ41RSy2KBgrgkMiHwsKqeW3ip2r0ARmbiT+6DMZmU3S5jiT0Nd4enUOMWHM0zaRsYb7PtkppmcMBFMTGoaXYgAUWtUtZrZ2TKUVrDaKglstixwVg1sB7HwdVKuFy+HGVZdHosGIOGZiuGuGEqCeSlBzl0rUDSI/qeyBpQCT20xuM+0WmIHGzGP/ScuhBvibUk3DCKnO3rthJIBy7Fod+a/URx+oEDAqhSlXOTRBWtbnQmYTuKxXeFVpFELUyUw0ZWp0rR5PAHuEGUIaIx1begQs59zXktCXwnwuWDXChSAUF1gQTLqegGsb7XA/6qCturk6GKhsO3nLAsmEkAnmRet/PKIudaEVoXSlT5MVYWBaFELhTUx9aUrmilJBm+oIca6thqL/aNh2VnVldDM8Y/i8pWtYHcLVNzpUg+MCXQgStIwFDniLGCmKNhuFzMidnOOJmlKzaOLRzHS0EEU3JyHaSvRKomhVJ1y37Gqeue8NFmub0OXMwsDUjPbzwEz82U8rxUeGmqLPtXuFqgYIvKdmAEpTCNno3wtFCk21QOWSlo0Okw+B5Jot/N94+DlrOwJ57k6Fz6QjEX+Q9dSQVpBnBS0lTGJ5R+xj+Q+xrqYoKbWNnVKS/xajgqNWWKj554lmcrNbas22DEkEXIByqPkngQ8HEuaO6mamIbHCA8ZwjEZabXseHds2Ji9ZoT5eTac4I5bRA/68hT7IGIcrCczR3NMuOqkYGJ0O15mHAueGYvat2EDACZskPCJZ35TUjFgI9VWcBzfATj05MWxJ5ZRzZMGqI3TM9FpS5UHcZTcXRRRqIDCqLNkO0Kw08Wd1m1A83Q7SIQmduQNN9QAk1kUvAtAgrFu/9eM7fdVk4Ag2uekrSWfx4YM2DUs2D/+t/JCQ37VpitKc3YR8uRwzCWlY1OW9eAlz0XYL2QYCQumpJVKFchZzUcIc4fHqsbx6RrO6nLjgoLxsS6UG3NLUfqwTsqnXWKGbHMv+71zOFrlsZrxv8cdl3/HwgiUCU4a/k0/4ZyQlPWGCyGcyyV2s+i4n4yeOO0chcxc5UHYrbTApJV+xFkfWhY43ZaDmxIaF9enbH7PtKC7R5+/lL7/3ONM87C7BSpGIfUCIG1LZ4Da/i/NNYCG14UJnT2mLZk5TADXbBxywNrYIEglaE1oW9nhJp9XR5Ujji1pH4kSGOu6yw5sy4glGDV0cQVZvNf9GDaYWzVsNVbabl6eN+zAZBLAQmVm0q38RoW4kzOXjmzDRsm7q77FTJAUGkoHhrpBQVu1Wm6quUBA45A8az4Di+RxkocLC1I4335zymcJUxjxFHX82gqCZHpCFBmPN+tIaKwpFK3NydmWqqQdTqBzjrwx1GzrOmq6QDENWGJWLawZ7Joq05u3Oee7t2VqZvt6+HjLmo6+SwVKhKYEW21AVRWqNAHERPdulBkIltEOiQAU0ypwJhBFP0pMqZuaEQgkYz2rvE1/1ILJG4gWQ9Gi08O3hXbyvDpBw3QNu+TwsrE7BaoPGUeU00jUBJWSLMg0F4OVeUiAbfdLcowlUGKgGLj0FZuUsv/OAlGglp6FNVkeVn1pfRLK+ktTrrxZ6+OGMrybcXWn1ZDoJ2112FeRchLBrM1c3fUgCQdYn8qlX3JGOhYELXsUTGlbSdVl+53yEpmgCdENTea0Pn2oRShNcTQ9YzZE+CXmFUfiCsDPM97sKq9PqL4wPdv7nl0pUIB1yp1GktYEhp29flbchg5E/pALZlIootOSfCdM0fRtFT7IGYcQKHRhRWYsn965WQhiHK1Om5QLpF/1OdJWwKRaNoN4ladYJ4//PAZe88u/2H8/W/sY5w9+tadUp7KA2DoDQlinWgRH3AqIKd1NnXWXNPYJX3u8aAsRcn+t9L48pU/rgqyp6RMLap68yRPor2EqIS9RWWQCVY68YhPoDx285lOvwgXvva33XLteoIoRcwetAREmevokcRQv0padJUeH2MQ59bZOqjR0KDmcg+Cabi5rWu3zbrl7lx8KKJcCnw8oDovkuLgujpZrcOfxR8/6XYirn9B73t1NOEaEpARYqXS0GRGgNUhkkZasX4/cgjHWOBqGmMxO/kzYVuwq0aVi4lWhv47TcJIBJuhWGI5NGUhb49tw7ehxk6e0/AZTXUGAcbatMaxaiOGpDo2hYWkRvRUJ6bHzC+skmZryARFqlBs+SxiR6iyOYuxugXJwQlViAtYAoG1VgQAjdLIk5g9BoIgZDPKCEzcqcGQCASNUxayGgCG998cTWAlQFKh0cSjnDsbapxIaB+oppNBeyGqp8Pj1Yx0tdVBOcGG1YWflRcwr4E5bVQ0zi1izAGyjQh1NXK/BkBRMk0Boo1oGFjZ5lt/gdiL6M/v6/ND5+DuNV1cutK0hplGcJfqPyZIyjdQ1JcLl8kp5aAVPJR3JjN2JbqTc3VZmGwNZRnqsE6YYVc84jZEohxGGosGAWpxSZmSuEybANShIn3YBzPDHWJhGOxyH+nmYjmGH80Lnk+TwnIaKv4g4Ym7bdN08l3gCui9TQSFUECeEEZ4nM/QoTFTwwc04vwcYLeU0G8Fzlrtbc5BCdwKa69UUB+tJJ7Itof1kT4eaFA6ICUY0hYDGlCVOqbVOPEpBbMpJX6Qn730nbwCdON27fyGBIqLLAfwogN+zrwnnic6n2EYVbgxcy4ilruB8J3Eo2OcwHS5x+Uv8VmcC7XMGPF/UXNgkcacz2KZaiBijKm3AXK+mGNnpCWdVnU5cKKwW4yFBDipisDsXaPuvhNN6gj/7P56P9p57i/uBxTXUmwD8EoIuOIrzRefTfWPndSiUKyeH3T4ff7LBTZbkS1hSDWb/ypSxhZpubjAWRKr0zIoDh0lbJd0wg4htZaIrnGlNzfhQtBiJpqNl8urMkWisxuqaxnmQID8VPYYu/GvAGD04+7dahCzjpQAeZOZPb/puZ2AhOp/yDfVv09wpX3GOOWmYaQpZDVSaqgFkZF26oQJ3XLRDkan2lNqv5PrgfCbFhDPNAI2WnrkuxsTOgIlJW12deE0q0U4j0fi5eSXzphCogsy1i0TJS0sOL7LKew6AlxHRTQBGAC4A8GZYOh+rhUp0Pvcshc4nhtbwLYpZ14uHbVEnEtBDSrSJTwbn312+zSWCq0w4CVnsoAzWZbMXQzFho6lxqB7PPhngwwUlgRkkQmcY72JNpVlA2f9wcXBFw7IAE0FQmVI6x3ENyMnsdtC5Z2HmX2Hmy5n5ChgmlQ8z80/gfNH5xMjnuzCDqxCX6iSG+wojIyfc81voqKIgCiOEEwI542+8rzR8cRHMa3tSdhCjO05HyeBZTQ0ONQU24AHphHVls7Rm7zt5A+iOr8885lwi5b8M4B9Y2p6jSOl8jtrt/wDA67Z8BWEbFPqi5cq0pjt/yFNL9xyvZYG7IApaOuQ16knXS8cOovPaBTdLkMSohUYtNCQxzlg6RDcsyD3yyejO5G3oAcba1F+WOoPzBLBL4yxSZDdvgHXDsph1iLGpwCYz/xWAv7LPzx+dT3qBEIIWpi8PgwraaanIKY8j4VrCj+cAgqPuhNBrJbJOuxttpu3rOO7kVoWJc07ezLEmaE2dagMi7qzaGiWL7VFnVQ1dkefbBMwP6kIIU64goDHC5h1xh1LKOBcqF0pQzPiL+5+CUfPtmefctbk8byUtU12RY9MOZKRGhVpxNoLkBMVNU9AVJSkUIMSZjL8ESzMdn9/+iUqGSQHUkuEqn1UHlWkyZvR2vpSgmHyDp+M2GIoG65b9V9vGhLyOPA+Mzisldh5RX6hAMUMx42fu/hGs/yyBm2nxOH/9mXt3C0RJmCITl/2vSmYOx6kV99YGJl5kqw3YBTnZrQbhHXNzwihk4M5ZR9fUZFd75R9vRrXNXDhhKiEeAwt0c3hu5nDynuxUOnlejkF9pWEce+2joe78xtz73Ru5vBjMoFaB6+jWO0MY7V9Bpi9PG23k4k+m+ZO8A17sz8vgF3jSmkPKTCAAbgmUfaNCMKrK/KxKzy/llcRJjVSyMmNhZwz3J38blsnIDjOXmHAgqtxUHFjsaitw8dpNQSVhhON6HeLYqYXaQHetQPUG1+0Q62RyJ5ENFZDN4aXhAsCQZ7AgP+VzVs2ZzgPOkbZigtHrOjJ5BYdd2ynocth4v4mZcLapMahajCozQYGIMVUSAow12WAoWy9ErRbQkvzr3LzpyCw6xKu6cJzAGNJUCsBUGkjMTrVslStqb5g8h6gXj2ylAUsJ2NCB0TYzUiQMz68ZWFmyQ5zApG8z2136hWxwM6qJypsWDD8aQaksv6YJ07bCULaeBH+qK5xszAjYWCNNsl67WrRzOZ9K+82c4rA9N3vLxK4VqGLoKm6hsl0vFHcXV8LEpdzhUZ+eltHKTiBEzCl9OJPn+aMy/2sm3MqQUr+pNPKshFlkGEAweX0oMdwBpVBCiEEtUroyZZmSl8zArhUoD0GdD+OHLZbY5QVSnyj7jtN4U0/Um20yOAp2dt5sj/NOGAE00CBbYeAeeW+e+UiL/ThrMl1RKRa984MF5o+B3QpOaIW//66fgbrv/oWO37UCtdUCBSYyg6kRmTfLvhJXF8S00rHQ+ZWfCzFk1ImJRbERdreNiLtZHW3mtUjB/uEaPWdhKBrUpExA0561Fm0nAXxGD6FYRPm87nndrJccirsMwDne8MAP46pfvx3c9rMPx9i1AtULInAV8nkcsdq5VilqOe12ieF8HdegkK3qimEbV1fFFJHhcygBtkFPPa6K3cK5yWOmTnPCQBhn3AmPc+Q1k42MU9Jj52+NKTF1Y10noYIRtWbWCxhTFp4ScZ5T7nC6HUBPFw+e7h2BKpk31/VifarEf2p1WNERBb/IwZkz+7uKFl3zR+FPnI6hhmztLKc+VmxOiSErBSF1pwMm96EGosV61aBhgYnqEos5oXJBSzc+1j3i+JNGylwnqDxtfRFoZnz1+CWbes/uFKi8qI5Nzm6hiTzuLTLjOnCnzkxceEPURsXmwE7azpPiz7owQEJDSO0dcx2ZNyLGet1gIJSvJV+vGi8sjaXzyee+OLixHQ65I15Tm1UbUHRsavoUMxqUzZ5mxuvvfz6O/EMJ6MXTyLtToGLkq4sF1LRrL6c8gu5TL7NSJrNfkyokhwV706db0YmMmznE5rmI+KGYCa0W2GjrTtVBiSzDDA+aFzboT0pLcOcHj4UqfrzpkWfgrlc/HuqOr8y8Xo7dKVBJHXlBgKym8qUrwoYLXFShFkXtBMDHqny3cAmE1JlykfCaoWujuaglr8kSC6WpYJkJrSVqHWQMwKUBjJIYF1RpnZRmwiPtgWSbJI2alCEfmxNymLUCVMwYs04e7/rS921amIDdKFDFisz0NklpM3vYNi3oyjICz4qVWF/HcY/rylYjxMFIGXyqmOy1w7QC40dRu/jXZzihsBCVYWUFZRacMEnbpHBGDxeqKXdR8rn3q7YmGrtPoPogRLkvL2akmwZqRGLLU247YXRliTJsqMAPCcoEyvfj5au/nFAjTxjPgKNBZCaMm6rYfi4okNgD3eV/LRQOybHfbuJOaduVo5V22sr7ZZkGm+cR/ceNq3Dl72wtbLP7BIq565QDKd9mZWcPFyoQPGeUHcaYhgS6ZqzYQuVO15Cf/qmrHu3nHTOYwroqy/hLjWHdRu1UhHFbJcHP9WqKOmpUMPNegraphcJBO9ZsQw+CUEXCNKLAtjLmGlPIntiT/Vv+NACA37vruRAfvX3GEf3YfQKVI+cedwOEcljmX2oz3kybbonBFFZqrt1c1+UYlGgo1KL3QVhBsmEE1cqoP69bvenaqNyjZdkxhWfaoRecdTH1wqFZ4LQadaYpxKu9RSPmKnsA87XXPOx+gZpHfOWyMC5vJjNfiixhBgqrOw7pl6T4Lrqkrpy/RT5qnsgHo0M4xprQTCsTJitIYl612WrRWeWZUWf9PlFfTk+C7ay8roC5d/R9o06Y7n/kgt7rzsPuFyhn/nJ+KM2WfSUTFDLOtjd9NiLumhbCa1NIF7dZmTfYdIv9dtUw8tE0GcGywqVHtiyllK+zQraZKs3k/eCZjrlJy1QdQcyFqQTFQMMhaxQf/b/e9d/gml85h5njW37ndmKWVrJlvyZpjP64VME3KlJIkwloyjE6hK6BFDbkgP1DItRDtSJZBYpKQ1YKRGa11ChDJy0FY33Q9FYF+PeDcbjeMAOsIazfFD7Ium1Dj8uEHeYJUwzF4eEE6wv/5Wq0d39r4XN0730vIA8HZH6U0Ui2fMVqHGEbPrXsEbgMxLb0t7Bt7kqfUy0lhE7kvG0lpq30jZ6lzuI20jSH6nFiFt1UdAXTHePqyh1KPpPbtii3gROsc8Wi3AZ3EdHniOgzRHSr3XYREX2IiL5q/x6x24mI3mLZVz5LRE/b2p1Ft8Y61EeV8nnMENPUPJAykxPOBS5YvVC1SSPAjTBFeIXfcDRoIIXhhZuoCo2Wnq88z7fFWqYmhXUx9UIVmzhJbKgP7eDquBjPrQBjYVtEd1G7tXCBv+4mjv0hZr6BmZ9uX78OwF8y85MA/CVC/91LADzJPm4G8NbN3hRb/8iXsCSkY9o73WQ7XsAMPUhjO0wm/RLDcB+E/aVS385rWkBD+XsjcCOK6cZahp+z0QIbTY3TzQDMhIP1xG6X5hHVPJWofPw5C9UHuQksTUXvw6/c8zJc9c4HZhwxH+di8l6OwLLyDqTsK3/ABp+AaVl/9KbOHCcjY3/KzsnzqRe3emu1bz5wWknXAixhaqOiYGU1TqPjyWUjmeScnaUPlD0kd/rxZr31wuFZr50ckeupdtRpf5JRE6jrHO5Q/5BGw3Lm3BcnVLkz/r/f+1Kc/MkjUF/52kL33odFBYoB/Cci+jQR3Wy3XcrM99nn9wO41D737CsWMTPL5mG1k+/Li4gxksO80LD3qRyEHRrknG5XcSDHSM1iRPejB/BTzykjc53Vj0fSMbCk25tCKqMSXaIMAB0t5YRJ2pWfmzE8tR0t7hgHM+Ol/6d10XTDHGweX3r7tecsTMDiXS/PZeZ7iehRAD5ERF+KdzIz0yan4FjBvBkARljfzFs7iJ1xwMWWGIkNY+MTqYGLSdl83VlADRjNoYg/yrVKufPZWipdAXrA8Ax2pby1EmBtg6x2vxCclLDA3tl6PUWrRULnAxhNdaYdoq7NdidMcWTctEcJDFgBZPynXKg2wxY1J3W4MBbSUMx8r/37IID3wbSgP+BMmf37oD3csa84xMws8TkXp/NxJjDO3eVxqQxufgtgVnosgzDFIG0EyPlTbmUn4jIVMhpLDyMhYip7udrWIDGBNUFKjYFNvTgzRgAODiaohO6YNkGMSihMrJZymkpEyWB/KSac1GuYskzY60bUJEOwzdhY0ZuYfufxZ+Li208U920Wi/BDHSCiQ+45gBcB+DxSlpVXI2VfeZVd7T0bwInINC4MX3YqMlOntGnyJPuDuvFmOYe5YlRnte/RM80GfSUtmfPOgJgYoXI8m7rOzq8BamZ/fbLSqCsFYcuAWyX9qs5NoTJsKi6Za3vzhMJQKLRa+pXbrHSKZpFMRHc15DLyzRoWaCC8YDnheufxZ+LjP/sM6M/cMfOzLIpFTN6lAN5nV1wVgP+bmf+ciD4F4N1E9NMA7gbw4/b4DwK4CcCdADYA/OSW7myRWSMCtsTXvlYMEBmHvApTPWdeRqDY9ElsfCxdAapPgXJ0cAFSpj5SqwRaJaAivnINwritcbCeJDNehqLFBVV3BEbcOSyITYDTl/3OZpfTTInwfurs5fjYzz0T4v/bWiK4hLkCZVlWnlrY/jCAFxS2M4DXnvOdMYM56yJZtPzXtVJlXOXEnHUcG2HpWxSZ/WVfKTlxz/ZFpymU+vGGovHCaCiikfCUO2GStiR4JGaTWHSuyYTbzlyB6ravbCK2Ph+7P1Kek9+XDoliUyZcQPY5JcIgp0hCBmpoj+kLIwww+xvqk+8ZatGRtm4GG7o7MnZAra+dck77bsDuFqjCfBcAXSdcA2LS2vRLti/23TWjmrDvHnZ8UaIF8v/gWtoVHRC6iJN7AHjUQ4EzkWgnVbFjeN1GzEuDF/uQN3i6bhcJXQxuAoulXDYzNXRR7GqB4mn+K2c/oIZtZwJAFDqKI/guFnfO+BNn2ktM4buFdVJlAMhJqslYcn88yt6GUiL50dYHjW9QaDnd186IG7nYUx5fKpHkh9Xd7DrzB9VBfPg9z4De2Og9ZivY3QKllNFS8epMptwF8QqwrzHBt06xo/QpHyengB3d2509DPiZw/P4DmigUQ1bKOuEO8GJHXTNhIkyM14qUj5K7uA0ktNGALChhkkoIYYPcCKPVXVv9GG9jl9822tw+b/85MJ+6aLY1QIFZuizGUvujME1IADRFM9OpWbeq5cXMUigPQBfL5Xsq9k2jjqHv+cWKkY1aL1VbluJaVNh0lSYqogcjNhQ91haac1pQd1ZNcBpNeyUuox1jUfagziuQjDYVxYU/hc0LDGF8I8H1UH8o9+4GZe/8ZaF28s3g90tUDlc27kqh3XZDV/UJv0iGoaYujIWQHV9W8QdLb4MmAE5Jh891hW8MPm3Ce51vjsunqX12ZgGgRnK1rSfR1qryiLm00JvniQNSdqbPgn21QZAuZJTR5UKGzzEpR87tqnmzc1g9wvUrHEbUes58qno9r1yqj3nZp+pA9DlhbJCJRoqaiPSNrCa8xYU+vJKcPXkDuvVFMNMoPLI9kg0GEYPoNs5PM93MtQ88+9vq9j1AsVtA+RkDXHrVGtJJWz5StoWRWjXTJ4vLgsGus65I211rz2vwSyr4NIvmqJH/+FKCb/yy32meZzjIxHa1U2Hy9RrqZjbYGpnEcftVA5neIBf+eArgTvvmnmtc8GuFygwgyeT5DXMePHwWrHtt0srDfTAxqTI9OHJidVs9q2GJtEmfWXwjVzpiqk6mKNumFKBioQkbpUiYlQy5O6aQm9eDjPnTqAWbVIw16nYzLSUYuEbP6cwjvmYa9z8gdfgyb/6Wejx/OkNW8XuFygAejwBtzYm1SpwPNUTSDSPEyqhuLNSy4cHkbJpFwr74vfoOvhd1KaOOvdpFA2wFna0WViE1rXChWvjkNfTAi3LYixIkMaBaoKhaHBaDTHpVAIGlBzxeN9Y1xhzjf/tqz+Ga/7JF5ceJsixJwQKWkEfOwaeNqHBcwYTy0wyjB50Vm6UlbBo40+Z4dc96RjLc0CFlItSAk1UwsJMODUddhxvQRprsvHLf81UFBpnIqXVYvmsvOTaLDD+o0uhji+nomAW9oZAAeC2BZ86lWommwzm2poPX95LaNdlb3VB7zWo+1y0SPwiVwdFeetUpUFDDRopyOK0z5S1joixVpl8XaulH9HhcnPzkLehuxKWkmBpCIjtWdR1sGtppefCruq4Crk7B0ctbVIsYZXmevLCgUZgdI2uxqH0GP/eaDsp8kx2VGu/rzSWI711I0yepQ6EsY1B5aEDoJ+MNcfUcpTneuKPHnoGjt56bDsXdx57RkMBRkuhVaDWfuky1la2RYnChAVT9msK7VRNaEd2e/Rby7MMarPVP6Ez2yWfs+e3x3zlFm0jZ4YOBkJ1uocrUqhIoy046zWpsKIjjTGXAmoGytZGuRXecbWOr/+Ta6E//6Xe9ywTe06g9HceArTuxpQYSGYOWzih8g0HmgNTnT8oHAsEpz05fZ3m9zqIzaUuT/Vs2vLKriKF9apBJRQaFjhrqwviWFVcsekofGZB2XjUSb2G0bdPzTx2mdhTAgUAejyG/s7DWUyJLPNKJEyzfnsrVKIF1JD8Ss4NE8otDFc29ZKbTIeCz6Ss8BAxpNSQ0oy6b7PacgFOKBH99sIq0lQXqMQETm2XS8l3OqOH+I0PvBz4yl2Fm94e7DmBAgC9sQHasLGUnmbOeSs90txN8nIoZYmdbq8MssoFcyIUqw60IihlasqFCMStZyaDhB/KtUY51KSxNqNYzgmThgkJuMh4LlgbeojXv/9/wNX/+PZtjTvl2JtOOTP49AZwaA2kdTL3Lj0OPtErFBDlZsHCaCbT/BmN6HCJZQagCSw4zM5jAA2Z0bHe0ece0j3GYKA6VD7DuvXJYPNXJJWYORxXec2qox01BMYsUMM2L5CGYomvjC/H+9/yQ7j6/zq/wgTsVYECoB56CNX6CPrwQQC2CqAypBWeRxMwr20k3PXlMRGUXdmRBqqzjHaNAul93IJuhTIG6aiOfaj9dXJtl2N90GCtbkzTgJIY2srNlgUGPbVNgrh3eoKDL1NhiRPqAD70+h/E0Q98/Lys6nLsSZMHAGBG+817II6f9vk8R4UoMjPoCTOsgLBM68iZyE9D1zWKTQvmOPteV1xnNRe7lIsTQDZxp5gEvxIaa3XjHW0NwlRJtCwSv0rDMKo4YZKkMaQWNSkoiN7IuItBNSyx/s3z54Tn2LsCBXihwue+ivpY6BDJQwDF5/GxfgVYqEhxuTrY43J/ycmqpvShupOoYmgmNFoaonumJFwQP8+d8Hk4pUbhP9gOYG8LFBCSx/fe782M96eoUHlp6508aYZraJC2KSE/nE07Vcxy5yEQVniFVVnsP7Xa8ETlkLbArmXhhy82LDxPuZ+VZyV3lvl7pD2I9779eVBfvLP3mO3GonQ+h4noPUT0JSL6IhF9/7bT+WwS3LSm7iluk7I+keM2cL4V6agpwVorV1xHOYuEPaZUTOdzfWQTwYL9ox61qDIC1zxkACCKMxlhChMVjODoSJDceLNxIVl8Sq3hHf/uxbjst2/ZtuK5RbCohnozgD9n5qfA9Oh9EdtI57MV6DNnMPjqtyGUDg6xS4XYVvQ8t6dth4wbYu0gGsDPghFseKJK1QVOnijdXw0UZKU7K7y4ssD5Ui5iPohLVIgxFK1P/Jr3GiY7x2lwRg/945Raw2/+9YvwmN+5bUeFCVisFf1CAD8I4G0AwMxTZj6O7aTz2SLa+x/A4MvfxuDE1DPYAS63lx7rylYAFL+FhDzCxati/ynyvTrCFlFIx2haQzLmCMYkaVQZS4XMyMc00mqDia4Ts9ewxG9+7EW49nV3nvcQQQmLaKgrAXwHwO8T0e1E9HuW4+Cc6HyI6GYiupWIbm3mtFBvBu39D4A+8XmM7jErnTh8EC4efKs8/uTAuVaycSn/fslAVXZ+c6YVB2U5yp3ADKRKIuKxMDUceA0mXHWEaqJrfOTha/B7f3gTrv2lO6GOHSte83xjEYGqADwNwFuZ+UYAZxDMGwC49vNNFSFtin1ls9AK4thJiCYEIBPZcJ/arerYmDnvqEdkY26UBwA/As37TgX2382g1aHFKtdMrZadtirFwj829AD3/Nur8dg3fGzXCBOwmEDdA+AeZr7Fvn4PjICdE53PdqO999s48Pn7jVBxSoYfmOkigdOBtDXWTsY0xjXskRBpKvtW7jqFXc6vooj0XjOhKoQGTqth8KFAmHDlH98aH8EFd+28icsxV6CY+X4A3yKia+ymFwC4A9tM57MMtHd/CwdvvxeH7tpAfUZDNhy0T1aVAATZiP0tU/prnXcqBD3ntHPnflQtjLMeT+xsWWKiwyhYBzM1YdgJZn57fBif+e0bQB/7m5nX3gksmnr5+wDeSUQDAF+HoegR2E46nyWhvede4J57ceDoReDHXYbm8AgnrhqaCgMK6RggCBpFMScXYlAje8K4/JcBKLIcVpG2QxqDioXK5fBiaDYjztZk09nXaonTGGIoWpxph/jYfVdg8O4jOPzOT5RV4A5jIYFi5s8AeHph1/bR+SwZ6uFHgIcfgRQSR6bfg4e/Z92UT8WswHFncISkWjPnRihUGgjL+GtK39OTTdoKJZdxqiu0WkLK7kjXVks8NDmIL/3+tXjUH9wGnnx5U5/9fGLvR8o3C61An/g8jn5+A/UZhh9QbVd+uc/EZFqpvFzETCxk83mRdjKXmP219rGe9NEWahA+9eFrcfRtn0xbynYh9my1wTlBK9DHP4ujn1mD/t6r0Rys0VxQ4ZFrrIPEmbPtS1XsS1vWkvBtxnzgrQCRxGC4OHeAZsLpZoiaNHTEh6WZ8Fcf/x5c8y/vgNrhoOUi+O4UKABgNj1qn/gsagA1EYbPuxH3PXtklJC0QiJgVnMxfQ/bBoW0PTDF5kiRAQAtS5xVNY5P13DnAxebjd84gGveeMd5aYFaBr57BSoHM+Rf3Y7H6Btw4sqRIcEnYHKEcPZRNhfYV/NUEB4T3OxqlFaZOFJVqFbSTPj6iaMY/esjuOo/mRUcK7UnNJPDSqBiMEN89HYc+WjYJC+4APf/xPU4eRVBNJYN2AkVwXfG59CtKO5rtcCJ8QhHRmf9MCHAzH+57/gFeNTb1zD84Kd2CcHh5rESqDlQJ0/isnd+AesvvBZqaHoBdUS7uHFZhTPXTEFSA7nwtNKT1zswE77zrSNY/9PDkOOolvzkBFfc+a09Y9r6sBKoBaBOnsSBP76luO/oaITv/N0bceoKBIHSwKG7gAvuJtz33IOYXhgER04I177jIagvfjU5D+Pcx7PuBqwE6hyhx2McfdsncDRnKrZ+z+M/LEFRRJ417ymfaLNYCdQywAxwj5BotRCH/37Bd19gc4VtxUqgVlgqVgK1wlKxEqgVloqVQK2wVKwEaoWlYiVQKywVK4FaYalYCdQKS8VKoFZYKlYCtcJSsRKoFZaKlUCtsFQsQpZxDRF9JnqcJKJf2G10PivsDizSOfxlZr6BmW8A8H0wzZvvwy6j81lhd2CzJu8FAL7GzHdjF9L5rLDz2KxAvQLAf7DPdyWdzwo7i4UFyvIavAzAH+X7dh2dzwo7hs1oqJcAuI2ZH7CvdzWdzwo7g83UlL8SwdwBgc7nDejS+fwcEb0LwLOwAJ3PKRw7/Rf8nt3LALE9uBjAQzt9E+eAJ5Q2Ei9ACWMpEL8J4CpmPmG3HQXwbgCPh6XzYeZHiIgA/CsAL4al82HmW+ec/1ZmLrG77Fvs18+8kEBt+03s0y93FvbrZ15FyldYKnaLQP3uTt/ADmBffuZdYfJW2D/YLRpqhX2CHRcoInoxEX3ZJpNfN/8dewNE9Dgi+ggR3UFEXyCin7fb93dSnZl37AFAAvgagKsADAD8DYDrdvKelvjZHg3gafb5IQBfAXAdgP8TwOvs9tcBeKN9fhOA/xeGw+XZAG7Z6c+wlcdOa6hnAriTmb/OzFMA74JJLu95MPN9zHybfX4KZuDSY7HPk+o7LVALJZL3OojoCgA3ArgF55hU3+3YaYHa9yCigwD+GMAvMPPJeB8bW7evltk7LVD7OpFMRDWMML2Tmd9rN+/rpPpOC9SnADyJiK605TGvgEku73nYnObbAHyRmX8z2rXrZ+ScC3Y8sElENwF4E8yK7+3M/M929IaWBCJ6LoD/AuBzCENnfxXGj1pKUn03YscFaoX9hZ02eSvsM6wEaoWlYiVQKywVK4FaYalYCdQKS8VKoFZYKlYCtcJSsRKoFZaK/x85QP3XJUf8AQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# label map closing\n", "number_of_dilations = 10\n", @@ -334,22 +231,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "flap = cle.greater_constant(flip, constant = 1)\n", "for i in range(0, number_of_erosions):\n", @@ -371,30 +255,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1650\n", - "3\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "gpu_pointlist = cle.labelled_spots_to_pointlist(gpu_labelled_spots)\n", "gpu_distance_matrix = cle.generate_distance_matrix(gpu_pointlist, gpu_pointlist)\n", @@ -410,22 +273,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "gpu_touch_matrix = cle.generate_touch_matrix(gpu_labels)\n", "\n", @@ -446,22 +296,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "gpu_touch_matrix_with_distances = cle.multiply_images(gpu_touch_matrix, gpu_distance_matrix);\n", "\n", @@ -497,7 +334,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.6" } }, "nbformat": 4, From fbb49e885e9fb39aae2c9befd5afa9bc0881c94e Mon Sep 17 00:00:00 2001 From: haesleinhuepf Date: Mon, 11 Jan 2021 11:36:40 +0100 Subject: [PATCH 27/27] improve interoperability with scipy --- demo/transforms/affine_transforms.ipynb | 194 +++++++++++++++++- pyclesperanto_prototype/_tier8/__init__.py | 2 + .../_tier8/_affine_transform.py | 58 ++++-- pyclesperanto_prototype/_tier8/_rotate.py | 52 ++++- pyclesperanto_prototype/_tier8/_scale.py | 76 ++++++- pyclesperanto_prototype/_tier8/_translate.py | 19 +- tests/test_affine_transform.py | 44 ++++ tests/test_rotate.py | 61 ++++++ tests/test_scale.py | 140 +++++++++++++ tests/test_translate.py | 69 +++++++ 10 files changed, 667 insertions(+), 48 deletions(-) diff --git a/demo/transforms/affine_transforms.ipynb b/demo/transforms/affine_transforms.ipynb index 9a9fedcc..d86806f4 100644 --- a/demo/transforms/affine_transforms.ipynb +++ b/demo/transforms/affine_transforms.ipynb @@ -212,7 +212,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQYAAAD8CAYAAACVSwr3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAACT60lEQVR4nOz9SYys6Zrfh/2ed/iGiMjhzHWq6o7dtweCFEm7QdKwF7YoAZI21MKWpYVMCQR6IwE24IUJb7TxQtqYkAFDQAMSTBqGKYK2QUIgYMiULFmWKFMUJYrdTfa9ffsOVXWq6kw5RMQ3vJMXzxtf5qmq7nuqu6u77qn4AwcnMzIyMjIy3ud7hv/z/0sphSOOOOKI2zB/2E/giCOO+PLhGBiOOOKIT+EYGI444ohP4RgYjjjiiE/hGBiOOOKIT+EYGI444ohP4QsJDCLyz4jIPxaR74nIX/wifsYRRxzxxUF+v3kMImKB3wD+aeA94O8C/1Ip5dd+X3/QEUcc8YXhi8gY/hTwvVLK90spM/BXgT/3BfycI4444guC+wIe8x3gx7c+fw/407/TNzTSlo71F/BUjjjiiAOuefmslPLgde77RQSG14KI/DLwywAdK/60/Nk/rKdyxBFfCfy/yl//4eve94soJd4Hvnbr83frba+glPIrpZRfKqX8kqf9Ap7GEUcc8bvFFxEY/i7wHRH5log0wL8I/M0v4OccccQRXxB+30uJUkoUkX8d+H8CFvj3Sim/+vv9c4444ogvDl9Ij6GU8reAv/VFPPYRRxzxxePIfDziiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hZ8YGETk3xORj0XkH9667a6I/Ici8t36/516u4jI/0FEvici/0BE/ntf5JM/4ogjvhi8TsbwfwL+mU/c9heBv11K+Q7wt+vnAP8s8J3675eBf+f352keccQRf5D4iYGhlPKfAi8+cfOfA/5y/fgvA//8rdv/SlH8HeBcRB7/Pj3XI4444g8Iv9sew6NSypP68YfAo/rxO8CPb93vvXrbpyAivywi/5WI/FeB6Xf5NI444ogvAr/n5mMppQDld/F9v1JK+aVSyi952t/r0zjiiCN+H/G7DQwfHUqE+v/H9fb3ga/dut+79bYjjjjipwi/28DwN4E/Xz/+88DfuHX7/6JOJ/4McHmr5DjiiCN+SuB+0h1E5P8K/I+B+yLyHvBvAP8m8NdE5C8APwT+hXr3vwX8c8D3gD3wr34Bz/mILytEXv28fO4K84gvCX5iYCil/Eu/zZf+7GfctwD/2u/1SR3xJYMIYi3iHHiv/zuHWANtowFBhOKsBoMaICRlSAligpQoMerXQyRP081tR3zp8BMDwxFfPYhvMOseWa+hbSitJ3cNubVkZyjekK1QrFCcaOu5JgtFBAQkl+VjEwqUgokFSfrP7mckJMwUkRBhDpQQIEbKMJLHCXL6Q30dvso4BoavOmo2YE5OkPNT8klPOumI3pBaQ/aG3NyUCNlCMUIxUCwkL6QWshdMLFBAMiBQBEwCiSAF7FwwUYOGpEb/z/o59X87Z8ycb4LGMCP7kXJ1TdruoORjifIHgGNg+KrhUBY0DebslHL3jHjaEXpH6g2xM2SnBz87IXWQGv0c0P/rx7HTg08dWGd/cz8pIAkSkOu7zETBRA0YxYCJGizIYMMhcNwcejuVGkTAhIy/GDFXA7y8JF9eU2I4BokvCMfA8BWB+AbTd8jZKfneKfPdnriy5EaWg58aYT4RcqOHN3v9JwXINUPoCsXUrMDo/UQTBexcg0BNMCTVQFIDAdSAEUGSYIIGiwMLRopg5vrYBUwsuD24qUCxzKcOO62w0x38xYj74Dn56poyB0qY/6Bf0jcax8Dwe4HIl/uKJYLZbDCbNfnRXaZ7PbG3xJUhdkK2kFoIGyF7SB3k5ub3yY0GgUMg0ENeoOiVHzQQSEKDhNMDf+g5ZHcTCIotlPpukyBIKcR1uQkaBUwQ7KhRpViNNnYSTBQkgduD3xpsKNg7Dvdwhd9G/PMd8uKSfHVNHoYv99/kpwTHwPB7wZf4DWhWK8xbDwlvnTGcN8wnlnmjhy71QlxBaiCuCqnPekBtobjaJ0gCuaYD9dAXKUgwmFlI6wSuHuwMEg1mMsv3F1sPt4AdDLkrSBTMpIFD0MBRfMHMNWNZZdIKfQyfkSYz7x1Sswq7N/grwW9Fy44zQ7O1+HOPffeU5sWIe35Nud6SLy6PE4/fA46B4U2CCIjBPXpA+OYj9vdbwtoQemE+1X5BsTDdzWSv31J8Xg444RYPwQBGA19xGXxBTKHMhSwGCQZyoXRJR5WmkNtC7jL4DFH0MQrEJmtwMaIPXG5KC/0B9b8m145lvSEL0ulkwjSJ6BvSShiLBpv2pRDXghsEtzeE9Rr7oMcN9/Av9tiXW/LzF8cs4neBY2B4U2AspmuRr73N/lt3mM4swz1DONE+QTgppFWm+AJt0mwgChINTHXEGES/DvWqr9kCtsBstEJIgglCOk1IkyAZ7TDaGhRcDQoC4jPismYItpCumpuspM2ajSQhWY0S0mZKFAgaeEqqgcIWMmBPAqWAtZkYLOPXMumqof3YYmZD+xKaK4MbDeHkFHnnhObyHv5Hz0gffnTMID4HjoHhTYAI9nRD/s7Xuf76it1blvGe9gjiulDuzhifcaJX/ZQMORpKttpUPJQPyE1AsBogJBqKR6/iAsxCEf3c+EwuQrFANEgfKZMFX0AKZTaYJmGkYGwm95EiFmzBdZEUDCUJ5iRoT2LWr4mPNYMxiNXgUqIhTRaxmYSBLJQstHcH7n9zx7OrNdc/XuMvDW5v6V4U/K4QVx327jus3jvDfP890vX1MXt4DRwDw087jMU9vM/0C+9w9c2W4YEw3SuE04Q9n2l8wpiMqQEhzI48W0rSjKH4yiGI8urVPGlKX0xGbK35TYEe5MMWGSxJwLaJLAKuUAZ9O8nO6OM2mZKEJEIugmsjtBHvEzkbRArZZ5xL2sdtIjHqc3NNQrqCtfrc59lRsj5OjhpQMELOwvXY4n1i/XMv2O47dk97pnuG7qmhvSjYuRA2p6zu/Cztb3xI+uhjSkrHAPE74BgYfsrh3nnM7o8+ZvuOY3ggjI8y/u0dvSk4pwdwni0UIWdDmg3EWuAfMoMslC5rj8FqoDhMFqRNlMkibcKYQtfP7B9BmS1wc7ZKQcsIgD5jfdYMQGCzGZlmR87aw8hZf75vIiJgjX5fiJaT9UgqgpXCMHmMKZQiNE3ESCFEi7SFMDucTziX6JuASCFlw7v3Lsh3L9lOLc8+PGV86uk/MjSXhe3bDXH1Dutf86Qfv38sLX4HHAPDTytEcG8/ZvdPPGb7tmP3tjB+c2JzPtC4SCnCFPTPm7PRq+1oIRhN00Wv6MZn8mS1F+DQK3GS2pCsBAUpiBScT0sZQjDgMs4nihXCVYNMhrJJdVIhiM34JpKLYG2mbTKNS+RyExzmaJlmh7WZrgls2pkheMbg8D7V5y90TUSkUIDTbiL2BmsyIVm9vQimBgeRwnfuPOXxyRXvPTzj4vSc/j1L/zHsHzjyH3/EiQjp/SeU6SgS9Fk4BoafUri3H7P9k++yfduy/Rqkbw/cOdkTs2GcPSLoIa61eA4G8ZlSKs/A3aTR4jPGZYwUYnbQZET064ervnWZeXQaFADpEmIzpWYBGG7KEikYo32FGC3z6Gn7ADbjbFoClpY4hpTAWc0adrMnZ8M06X02q4n7mx27uaFzkTEW1n7GmsyUHA/6HXO2DNHTWg2IQ/S8mFY4k/mTD9/n6dkl/3D9Dtm3dM+BYpE/8pANkH703jFz+AwcA8NPG0Rwbz1i9yfeYfuO5fobwLf23DkZECmMsydnwZhCTgbfKAfZurRcgUUgRqNXWVMwJpOzwZjaR0AP9zx6xGesyxibSckgoqPDNDqMh1wEYzLN6cS8bTBNwjWa4k9jQxotttM+RwH2U4M12rSkZg0i0PrIygde7ntyEc5PBjoXsSbzaHXNhe25nDrWzczaTxgpnDYjMRuMZEK2bOeWTTPRu0BjE0P0XIaO82bPP/Gt9/i19i3231ux+kjIzlLsQ05KOZYVn4FjYPhpggj24QO2v/R1rt/VoGC/vWXVzcSkmYIxGV8zAzFFr8RNPHw7rQ/kbGhcZI6OxkWsKczRMoyaaaz7CWcz14eNyQLeJ6zNDLuWNFlsWw97EUQgDB7bJUQKYdJGYSlg2kTXz8SoQcXbhLOZdAhERQjBcr3vGJzXCYYUvNVpxhA8z8c1uQidi/Qu0NlILIY52Zv7m4TxhfN24MwP7GJLZwMxG/ax4UG35X/yM7/B/7f9NntO6Z4Je7HIH33ERoT4gx8ftzlv4RgYfopg791l+qNf4+rrjv3jQn53pHWZKThCsHRdwNu0XP3PVwO7qcGYQowW76M2IIuQkyVnQaQQk165myYxjZ7tvsVabV6GYClFu//z5OvClJAGS961lC7R3hmxTaIAcXBgCskYxBSdOgaLtRlrtERZNzPeJkKyQKLrAvPkSNFgXaZvZwRtSnZOg9qhf2Ck0NoIydH5wD42xGxxRrOGxkSsFFoTudvsMLUkug4drcn86bd/yN8p32D61VOKEyRZ5OcfsB5G4pMP/zD+rF9KHAPDTwnsvbtMf/ybXPxsw/5xIbw7c7IZyUVISacOIThCcHgfkSIMwemV1kcuJ0eYO5zXOnzdT4RkicmSi+BtwppM8tqXCLNjnrQpeJgeAFqWdFqelK2jmEo4ipa080ibcLV8ydkgNtE0EW8TKRtSNlyNLdt9h7WZTT8xjp609dh15N5mS2sTuQhTdKy9BpGYDdkInQ1czh1zXdmM2bByMwY4ayIxW3ozc9fv2KYWL4lQLCdeXytnEt+5/4z/7lsN5YcdJghb6zDpXbphIF1c/qH9jb9MOFrU/RTArNeEX/w6V19v2D8W5rcC7XrWOh29Ih96AwCt06vx5ZWm4HO0pGApGaarljA5nM3kLKRs8DYxR0eqNf+hN9GvZpo2Lj0JYytbEUhbh5l1ghGj1aakFKzLy8qlMbnumemEZBg94+TZDS1tG/AucXG1UuJSk3E+EpOOQYfgNRggxPq8eheYs2MfG3ahISTLGD372DBnR2MSc9bvP3N7chFCsVi0sZmLYRdbjGS+887HpG+NDA8KYS1cfd0Tf/GbmK77g/mjfslxzBi+5JC2pfzCN9l+rWP/ljB+bWZ9Z8DX7n7OQtuGpVxofCRloW8CpWYLw+zpVjPGFHa5owTD1a4jRq3RUzKEoB87n2g75QUYKViTGaaGFC2mTiHSZG9WrpMQg8W6jO0COWumYGAZc8ZoXmmIFgRnMruhJc4W1yZMJTKlrNnLaTcyRYcVPdTbuaV1Nw3C1kZWbiYjhGxJxfAir+hs5Om8YcqeXWq463ecupF9bgBtlsZiOW8H/sy3fov/PH6bYlvKM+HqZ3ruXnwN/vH3v/L9hmNg+DJDBPv4EZff3LB7bNh/Z+b07g5nE1fXK3JWfoC1WrunSl9O2dD6WBuLerBaH9mPDdZn4t4xXbfYPpKi9gKMFOLk9KA2iVjHhf3JWCcKlpIF2+pEAlMotiCzkGdLX/kTU3CEWXSSsTQnC32rTcdh9lqyZENKBleZkMYUnMlYU7ieWkQKKx8INQMAcJK1h1KEq6nT3kcRQrK0lbthJBOz5eNpw5g8rgaWKXs+njZ0NrBxOtXobeDevS3PLxrKCyGshP23z1k9u0t6+vQP/u/9JcIxMHyJYe/eYfjZB+zeslz/XOTugyu8zexnr2NIWLr949CQs6F12iuIydI3gZQNm24iJEOKlrh3yGwwW0s6V6ZjBIwtykmYLdkVJToB8+Rp2qClgi0YmzB9IM6WvMrQZFwX6ZvAbmyYZ0fTRLom0DeBkCxTcMzREpLF24R3iZi0keh9WjgX99aa/h8Cxz74pd8wJ0sqLSsfyEXYNBOpGO60e+bsuJq0BDhrB+ZsiVl7Jx+NJ8TWsIsN+9hw4iauYs8uNvQu4GzizrdfcBnuYpJh99DRff0hcnWl5Kcvu+bGF4RjYPiSQnxDeech119v2H6jcPLWNY3T9PbuamAfPNf7DmsLOQtxtnTrGWcTrU1cDh3gyPU9fXm1ro+b4Xwmbz1kcM89aWWJTSUnBUPC69JUFqKxy+gzzSoCK6ZgXCF3iVIgRcPldc/JZmDdzcxR2YgbPzMZR+ciQ/Bc71vm2S6jT1NJTXPNTnZzQy5gBDatXtVXfmY7txpQasDIRZbSYLSezgbudjtApxeH3svj/opdbEhFmJMjZsOQPHO2TNFxOXasfOAbpy/57s/DVbpHEeHy50+4+/ED4nvvfyWDAhwDw5cW5nTD9lunDA+F8u6edTsvjcLd3LCfPCkapRZLoekDXROwUhij46wfebZdM+wacm1Oui6QpmbZiZBowFQhlVjIm0QhY7cGiaJr2k5Io6bzpu5LFNBFpsEi60i/nrTHkSyt1+xhmD0fbzd4l1g3KrtWitB3gdZrybHup6XPYHxmP3lWrV7FQ9IR5BA9u9nT1EwoF8GbjJPMnC1OMpdzjzeJfWjwNtFapWE/HTd6n/o4uQgZYR80qHS3ehbvnF5x8faauO3ZPzL0v/gW3X5Pev5JP+evBo6B4UsIaVvKu4/YPraM9wpdF2o67khJOQopGdou6Jgwaa9hPzbM0XF/s+Ny6Bj2GhRcFylA2DcwG8xoKEYl2lS+TT8mClKE3BdKU5tvwWj20GSsS+RkdeRpM/POLSSqcfLVMsJyuhpp61i0FOGjyxMATtcjjYvc6/c0JvKrHz5mHj0lGFI0JJeYol2yhRe7FVNwyy7EAa3VEeRpO/JsWFOAxmomcTl23O33dDbS2IgziTF5huB59+QCgzZUyYaVn5lqJuEk8eDeNU/vtvitYfu2x1+9i1xefSVZkcfA8GWDsZiTDdffPmW6I5THA6Dz+nlydL1efe+sh4UktJ91tBdmx5wM74/nxGuPTAaaQky1NIiCRFENxgbsoCpLqdOFKTMaTBTSYdPSoCvYs44L2zZiJGDqtMHcL8RgcTZxutblqHH29F57G2N07KdGG6PJsJ88ucDgPc/DCucSdnNojoYl4zA165lCXa7y2kT15rBP0dC4yMZPOMm8GFeU2nd4uLqms5Ex6Vv7xOuS1HkHjYnkYjjxE7GYSqvekotwPXeEZDBBd0lSC9uv9Zy//xbxx+/9Qb4DvhQ4BoYvGUzjKW8/YLhvdIW6bhXGaOl7pT53TWBOljlp/d+4RJwNMVjK3mEGg5s1G5C9UNpCqQffTlJVmPXgZ6eai7kpFAtxXfXd6wY1o8HfmYiTY3fV0a1nNv1EYxP7sSEOjriy3FkNGrwqH8LbxAfPzrEucboeOe8HDIXWRT7cnvDyck3Xz/RNYNNOnDUju9gwBM/LfU8pwulq5P5qx6kfl4binC0rP1OKcL/ZEbzBmYQzmcZEWqOZTiyGxkRCtqzcTGMSXjJZCo2N3HGaLeyjlhWti0zBU0whrgQQpnNDfOcuHAPDEX+oMBbpWi5//oz9Q8G/veX+6W75csyGq31H7yOpCNuxJSWjdXw7s3ctOQi2Cq7aSdWWShVdsYN+La6KBo2qu5D7QllpQDhIsVmvI9A426UH4HzURmcyhGhxLhM7pUJfTw13VwPXY8vF0CktuZvpmqBj0zo2fLpf8/TDM8RnvnHnJQArp1nQEP2yVp2L0LvAED3bueXt9SVd7R1sY8sQPd+7vs/PnjzjTjOwdhMxW4xkrmOHk1yDROIydDQ1YJgqMBmyZUyOTc0enGQ23cT8jmN/7ll/r8FOMN1t6buOPI5/UO+CLwWOgeFLBLGW+Ee+yXDPMLwTWbvMaTuycjMvpxUpeB6ebtnNuqHorV4pAZ6+OCXH6hkZqqqzUXm33GYkCGYW4roQ+6IisKkqOEmB0SJ9Wup530TtZzgdUXqfljp/jm4Zk67XI7byD6yo3sKLizXOJx7fuVp4FCs3swstV/sOvwqsV9OS2r+cVgsfYY6OIIUxOMxK+wExG57sT3Emc9YMNCbivPYO/sGLt1n5mYf9NaduIleV2X30jMnxsNvyjdULLsKKKVusFE7cxJBuGJOP+ytyEd5aX3PSTlxPLS+ePsAOwnjHsr5/j/ze+38I74g/PBwDw5cBVd3ZPnrAxbd6xvvC6tGO89XA/W7LnB1GCo9WW16MK067kRe71aJ0dL3rSFcq+2yikFblRoU5q+x69oV4milyo+dYqnqzuKq/ICi1uvIKSmHhS+SsDcJSRPUbk6Fpgy5OZUPfBKbkuNvvicmw3XVcT40GDJPxJvHk+gRnM289eMkYqyZDzSScZLAs4ispC/vg6Vxk02ifYOVmng0bOhdI9Re82+2Xl3FIqslgKNxpBpxJ9GZmSA272NDayJD8Ms5cuZk5Oz4aT3jQbnnUXzFnx0u34qP7d2guPXEl5Hun8P4HX6nR5TEwfBlQCuIs8zcfMJ8Iwzdnvn12rU2yyvwLyTLg6V1QAlANCiFZ0rVHkiBzFWZdHldNXIpRmXjJsrhEYQviCmIzOViwWbMDk7FVKToGS5ZcSUiqvzgODSULTRsQgWHf0rSBuTYaH59e0frIVRYdRQbHeq1peFtHl70LPOqv+Wg44WrsaF2kdZGrsSMms2Qt91dbRApPd2sebbbEOonYhYZchLWfl3FkLgZjEiFbrmPLXMuE3gacSWSE69DWRaq8UKOXMiZ5XDE1i7B05yPFeJIX4mmHEQPlq0OTPgaGLwNEsG895OIbHbt34dHbF/zi2Ue0JvBkPOM3nj/AmkLb69V7Hxo6HxmDY/eyr2aQqHw7KLNxrvqKXvkJMhv1gIh1yYFSNROUB1GCIUvGGCFnMKbQtMo5SNkwDA3UvsGqDcxRmYWnJ3tVXIqW/b5lNzTE0VNGSz7TvoSuSuuher5bcdqOZITd3HC57Yizo+0DzqkGQ+sSu7Hhw2sdc95ZDQuxyVUOQ+8DsZhlMjFnyz56Ohtxknk6d9xrd7qlmXXLdB8bzpuBMTlisYteQy6Gxt+UIRs/cbIauVxtcHshbBx915L3e74qOAaG30/8TvRZYz97McdYTN8x/twjdm8b0rcG/qm3/zHfap/yW9MDnNF15b6ZeLpb46quwcoHAOaTiemqpWSlLGMgtxG5cNpXCEIZDy60ZmE0Eg1mHTRbSAJO1ZuMzbgq6noQbwXo+5kQ7aLVuGpnbF20mpOlc7GubhdeZkNMsvAYchF+/NEdXKMr2E+uT5fAQhHKbIjOqhJUE+lcJDjL+WrgpJl4ul/z4cVJXRiLjEPD6ckeawpvb67YZsvl1HHSTDwbNsqWnFp+IHfxJtHYRGfrCLVmEu/vzrmaOtWH8DNPhw2tizRGA1ljE6kvFCOkziB9B8fAcMTvCq9bgx4CiLHqPP3uYy6/2bB/J/Pzb3/Ez3VPeG++x5A8/+jFI4ahWdSV2jZoNdDesAllsOoLMRskCOmkduCjzuMlHVyoi3IbCpSmkKcaFGzBtakSmAy5Kkw3tfdwEGvt2xlbF66m4OgbDU4H3oKvFOeCsiRPNgOt14M+DI3+yqIblNPsEAHnE6xvehlzdEuT82LfM9bPmyaqhHzNUsbZk5JhO7R4lxb+Q+siY/TcW+1YuZnr0PF8aPFGA+rl3PPx/oTTdmQonsYkng8rDbTRka1w1+243+94v88Ua9SDs2m+UnsTPzEwiMjXgL8CPEL/5r9SSvm3ReQu8O8D3wR+APwLpZSXIiLAvw38c8Ae+FdKKf/1F/P0vyR4nTdMTjf3q/cVI5jzM67+6D32jwX3eMefOH+PZ/GU52HNP75+xMvLtS4xZYP3kVVdjLrYrkhJCINffCDslcGOgqmaBrkaxeQuL+zFYlQl2nR6EEsyGK+sRhEWAhWoQKuSmfSp52ywRvsNjUusfGCKjt3cEKJljkpQci4x7ZTY1FaJtnvnW8bZK/ehbnCuOpWQazaJi33PsGswtuDWI3fXe/bBL8KxzmSkUaLTugncXQ3kInx8vWGaHXdWA0P03Ot27GODM5l95UXYuj/R1ZGl83lZugK40w1aVtQGzWHsKetIMY6wMtB3X5mgAK+XMUTgf11K+a9F5AT4eyLyHwL/CvC3Syn/poj8ReAvAv8b4J8FvlP//Wng36n/v7l43TfMJ+5nTk4If+Rddo8t4+PE/+jrP8BI4Ve3b3MdWy7Gnn410VbJdSPUWhv6ujvRtpFpcsTnfc0Q1DSm2OowBYs3JLNB+oRxmRwNxmWQjLEJV9eku3rlBRgOOwo2U8pNoIjJ0rioitT1ir7bt4S9p5yNOJcJTqcLnQts55bdpHsMX7//kim6RethNzf6uckYq6VMSJaX+54puEUfMmfBu8RpN6m0G7D2Myd3J8bkcFU1ehta7rZ79rGhs5HkDVN0hGyWXYoD1n5e/ChmUWp0UwMZQLeeKbYjtVD6lkXG6isQIH6iglMp5cnhil9KuQZ+HXgH+HPAX653+8vAP18//nPAXymKvwOci8jj3+8n/tMO8Q35229z+c2O/aPCna+/ZM6OX7t6i9+8us/zcU3MhpNu0uWhbBiDbkt6q3yBTadjvJws7tqolf1KnaslqZx78aVaxgFG16vT6FQu3mT61UzXBVWARkuTkLTRd9JNi4z8obcRkiFlYZh1/8BIYZg9cXL49czj8yvOVgMlGebZ8cHVKakId1cDp50qOIfaSByjw5rMpp1w5mbbUqQseyGtj6xaJUq1PrIPHpHCWTtgJGMk01mlR3uT6GxUdqSb6VxgXacOtvZC9kHHut7qpCIVVYkaol82M6+CZhOPz6+I60J2Ql41iLVfiaAAn7PHICLfBP4k8F8Cj0opT+qXPkRLDdCg8eNb3/Zeve0JRyiMxXzra1z+zAnDQyF8feS0m/j+xT1C1HTWVfGVYdQRm5FC5yPvnFwyJqdjuanVJaq5yroHKGKU3rxK2j+A6iwlSB/JwVQjGcFa3WGI0bDuNcgMsx68dTsz1DTemnwznZgaWh9ZtzNGCtupUVHZC0/YCPmebj9+52sfsa1jRdD9hpgMrmpF7KZmeTkOPYVVNzPOnrN+5GLf433C2/TKVXyMjjF61Xk83JYsp2Zg4yeeDht6F9ij5YdB9y7G4Fg1gXv9niHq2Heq+xQpm8Wn4tCsHJPeJ5xk4soynzW0TfOVWah67cAgIhvg/wb8r0opVyI3HetSSpHDpeX1H++XgV8G6Fh9nm/9cuHzppfGYu/dZfzmHaYzYXio2gY//viucghcXuTaYw0Sq26q9X3mcu64HDplGF6u68/W5mJqqiEtVBv6ujVZbqYOronMOz2UMahStPOJ3dCSoqXrdQ/hxdWKplGJ+Hl2zMHRtzPeJeZoibnTg2cyp6uRj1Y9RKM1vcnEqpewHVtlLPYjU7I8360YpoaT1UhjEy93PeNeewvKthQ++PAOzWrmzskeK4Vn2zWn/ciDfkfvVKjlTjOwSw0P22ueTRtO3YSXjFmVJTic+pGroJoLpQjrZiZUyfnblOuQDbu5WRSsjRSupo5NM1HaDGKJG0vXdzAMX4ms4bUCg4h4NCj8X0op//d680ci8riU8qSWCh/X298Hvnbr29+tt72CUsqvAL8CcCp3f/pe6VuBEdAJg5Hf8YoizoG15G884vpdz/6hkNtEqazF1GSiLWAK877B94G7pztOm4n3Ls60eef1vvPoaFudCuyvPbnR7yt9tbgXloxBVtVXwqj/g5KaTGU8wnzdaEbRJrYvV9g20a8mGhe5ul4Rdx67DuTcLi5TjQvY6iu5nz3N2cR81fL0xQn9SpejclEOQu9U1t5GT0y6Jr6fGq7rCvnmZOTOauD5bsU8O31+WZYpA+i0Ys6W+91W1ZkQ1nbmvf05nY2LbNs73QVXc6cbmslxPbdMSVe5DzJvuQgxO1LJTFE5DmPQPsUgXtWismFKDrOKZO8ZzywnqxV8RfQZXmcqIcC/C/x6KeV/f+tLfxP488C/Wf//G7du/9dF5K+iTcfLWyXHm4FPBgUxiFFa8297PzGIc8jZKbvHK8b7Qjgp2MHAWHcaqNwjlzGtdv8PKfe6m7nadUyTr+Kr6h+RY7WEX0ekyarREBw5CWWwC9PxoMAktlCi0YwC1M9yaU56sIVUYBc7Rq8HlKAO00YKvk3LBXMMjnl2hMnRdBG/mRd16N4HxuhoXVxq+KtRa/cH51tSNmzHFmBZ0d5007L74aw6UO1Cy1mvjlPbWZenTpqJp+OGe92OxiacSVxNujh1FXs2fmJOjjk7Whtpaw/ietaffyhvDuhcZCdaIlmTaWziMJtp+0CxPam71YC8nTG8oSPM18kY/ofAvwz8dyLy39Tb/rdoQPhrIvIXgB8C/0L92t9CR5XfQ8eV/+rv5xP+UqByEA54JSjU28V8OniUlJHTDfv7ltizNAlTr8KqNHkxdMmzZQqW0Dj1XTj0HnwiT5Y8OEwfEVOFVtA3sTGZGGsJ0WQlNV2riIqJQm6y0qeTwN6qv23QVexUtRGIosSe2Wo54lUWvutnpkkzlhEVmB2TIe88zclIu4o8e37CJPDR5GkaZWfagw9mEe6sBt1ZiJ77mx1XY4s1ZbGje7y+YhdatqFhF1pejr0SlFxkNzekLMsVHeBRf03MllM/0trIqRt4Ofdch5azZiAbWViPU9Jm56GUCMkSs+G8GygrWRqtpapErf2sDc+mNiDPVojzlBj0PVB3XN5EqvRPDAyllP+MG4b9J/FnP+P+BfjXfo/P68uPUg+RmFtBQSC9GhRKLlAyYrWUSHfWTHeE1BayL5QOrWMLkAVpEsYV0qDko4ylRHWrJgnzaHXsmIWM06v0Wr0fztYD62bmauzIBS4u1pStw20NkkAyFNEsorgag3zBJBVrKUY1G3Kn3hBlrExJV4h7xy4LJRp8H5R/4OrGpVU3q/1eex7WZqbBM+8aZGcpTaa/N6gxTTa0Fq7Hdpk+GJNx1rIymY/3JzrKlMLl1KmcfFWTSlkYZ4+zuln6fLeidzeqzyFbns4bXk4r1n6msYnLWUlS3mQ6F3Am01n1p5hrYDj0E0K2XAw9KcuSpXRN4HpVyF4Ipw1N4ymh5hOlcCNc8WbhyHz83eKQPpZEKVlLhZqiHoLBK3dPCWkawmlDXPEqz0CUynyYFhiTSNEjQWCu9zN1KzIJEgylzZg+4puIR6/e55125l/u+0Va7ZCVUHQNu5gaIKpIixTlPuRWx5y5yVBXss0mILaQ9g7ZObKA7aOyEIM2JONkwWWmyZNny+Z8TymCaxLJQLlwtM89YzRs3rlaDmAqggXub3bEbNhNDaXIkgmc96pQdTXeaCmsGl3WAk3/QxWridbwVnuFkcKH4ymgak1Xc8fV2HHajRgp7EPDppl0W5Wy9DDOmoFnw0ZFY2tm9my7rtlNIp0kijWk7jOm+29gGQHHwPD6OOw6fFZNWUoNEEtBf1Nu5PTKnkRxhtQV4r2ANFn7AFmXoKQYitHewTJRMCCzKgodHJ5Kk7EngZPNwBQcp6tRacmHJaB2ZggesmB3RpWZVqrBIEmQIORVRqJQstKjzWiU87COlNmAz5yf75ijY3vZgCt0pxNdExgmz3TRIV2lXvuaYUxmMa9J1YQmnGi9Xkxht+24aHQ7dBw9fTW2cdVnczu15KKNxjvne+Y6Ply5mZULzPls0ZUMTqXoTxu1nns2bThvBp6Pax1POs/T3Waha1/NDafdyD40TNWa72Cq09rIaTtyNXWs2pn91KjsW93kxBayh/Hcsmoa2O1403EMDJ8Xh6Dw2wUIYEkvD0tTh4CSM2bOFKsy7sYWkivI3uB2usOQ94a8snpV95opCHW/oU1Im5R/MBtCstzd7Nk006J8fKcZeNht+dHuDr0P/Hh8oOvYq6TuUaOhNBnpkwYlqwGoCDrRmJUy3awC19teg5RVNmV38Im4bpdlLFMVn9Kopc/+xUqnIV5fA9NHchQtUazjquvwLtE0iTk4huCVpwDEZNjtW5xPfO/Ffe6tdWnpwFe40+4Z+jqVSXZRjV65mZgtU9LHO2kmOqtq0wD74HE24SQzZZWe631YXLVfjj1t9e4M2dC4RMrCR9sTNu2EXwVS0xB7gUZ/PsZqVnjoNbxhmcMxMLwuSr5pNt3+HF5tRKE9hpLSK/cV5ykp07wYsENLiIY0S/VyEOxeSL2qKckklKbgz6fa5S+sOm2EgabRF/seZzNvby55OmyW/6ds+cX1E65Cx8ZPvNffoTQG2yZyElir7kKqAQADzHLT50iCrKrOZLL6s+/tmSfdW4hBexQHy/s4qaEuSXTCshOlZEdRRSnd8NYgZwvjvmF2anXnvNrspWxwNrFqZ1IRxtGzz6p43frAWTPQ28BYm4cC7CrRCnS3IRb1jDhtR86bASOFs3ZkjHUUnA270FCAk1YZmBs/MUbPi33POHu6uhSmhjdVMr/a9qVGPS7LW/eQ5y+0XDzgDWxAHgPDa0KspeSitFgjkJJ+XoOAOF/vV6cPtdkIUFLNIEqGnGkuYdrpAZMouL1oH0Bq7d9lzKmWCp2PrHxYvBIApuR4uNkuHfZ73Y6v9S/1Klqvrl/vX/Cj4a6m+V4PU9OpHdw0ObKpUwtUxIVQR5mtEqFicBoUVjeU7DA7xOSF5zBNDrC1N2LqtKNWRhbNHARd8vJZ7xZUul6XtlR9qusCfaPNxRAc1hZKgd1Fzy73xGT544/e53ruaKoydsyGlcnM2RGzpbE6FgUWI1wjhakSmuZoF/NeoRrkJuVD9D7yYqskuwMRK2ZDzMq07JrAxUmhuRKGtzf0320o46TvBXg1SLwhOAaG14GIHvJSOFg7iXMQY+UnmJoV1JfTCGQDVsVdGadqd6YZhJ0L/YdWtx8rcgOpKdi395ytJtrq/JyLsJ0bojP1ocvC6ovFcOIm1m4iFMsfO/uAkC0fhVN9YxeD94nxZYfbBLxXjcjSJChqRqtqSXqoXReIkyPv9InZ05mC1vw5qw5kDBbfxMW8VgTKYLFbLX+yL5iaKSRXR7ACrlGx2ZAMee/ITgOKmMKEJ0a10EuzxXUB5zJiVe5tt+v4Oz/8Jk2TeHCy1U3LOnKM2SziLXO2NCYtFPJcRCXpXWTG8nK7YtNP6kgVPZO4RfzFmEIqwlQt9U67aXHZblyCs0D+sGU+s6zaFkkJctGLgrWUN8wE9xgYXgelKKPR1royQbH2pnSwZmk8StNASvrPGP3/9kN5SxHBzGAnpTGDchnyacQCU3A6atw56BLdRrcAT1cj62bGSead/kIXmJKnNZEzO3DXbflHw2M2duKH411yEe2B9pG2CwuFuTVKXBJTCJNbfCPi5CihelTW6UPOhmn05CQka0iDI3cJY5OOUAHJgkkaFIqB6DXzwGdMk7Aua09hUlZjiVUHwkCJhgTEnUdqAzQUoA9Yn9VMpokYU5gnx6XruLNSrw0jhe3ckorQrOOybp2LsHYzV6Jj21Ql9ufqVdE3gd2s9x2C4+5qYNXOKkBbPTOuRt1DubPZI1I4Od8zbhqmU0FON3B9ffM3TW9WUIBjYHh9iB7yV8oDI3rVKLXEsBa8q1t4udaeWQOEtZi2ZTrriGuIa2hf6OITBYoVzLUjAKlLWu/bArNhGjxnZ3t1iK5XsYuw4tzvl8bcmduzzy0P/TXb1PKN1QtWZub53TV36hry7WWhk3ZmHzwv05q8KuS9g1lHj8YlXFWFHkenEnBZ8G0kidNJrNHAkqOqRAHkw7vpMFoV3eZ0Pi3lSElVaSpL3eeAMjidkPiCdAnjlaqNyUgRztbD8nvHbHixWykfwcXldlBJ+IPPpTO5rllnrBRiNctV+zuDNUV5Cl6l7b1VOTlvMk038Wy7VhEctKcTk+X6VBeq4qNz5MOPKSEu5LZjxvBVReUllEM5UdTmbPlyiK9mByqciIhACIgIcueM3dueYsGOIBFsKGSrHhD+yhCjJ7eVVdllpDYFUxFIZikRPhpVD/FRe8WQPNvUsc8NqRieziecuoG7zY4/ducDvCTeH87ZVo2H+/2Ws2bk5bTCmszVvmMykGYVbdGSwSE+KuW6KKU6xkP6ryzGHIxa2OVb/AhXlkaj2KzU7CLMwdVYqY1JQANEVJ/M4gp4XSBLoyVlhzSJptfpwZyFvgnEZJiCU//L6Oh9wFfDmQP9+VACbBr1p/A24YtwPbQab0WJSSFbvFMBWV+XwXIRNl4XqRqv1n6HgMpZIPaW+W5He/g7i9ELxBuGn6jHcITi0GAqIX6qnyAiS/ZACDdlRM6UWVlycnbK/hceMZ0ZwroQV6U2H/VAuR30T6F9Idi9MhtxhfO7W1YnuhKdipBq/WwoTNnq+A3DZewBzSSuY8s2tbQm8Gc2v8kdtydWjsPKzziT+YX1h7y9uuQX7nzMqg203YzvVfk5TK72SYWSNFsoyZBnqyIvwZAmq1f6Sq/OVfvhQO0Wq5OHPFnmUacZOWhg8euA38yYLi09CFWtrpmCoAthUQVaQrK1n6E+mTkLrVdl6eup1b2L0NKYyN12t2RRTvIy0ixFiLUBaUzG24x3ibNuvNGFqOa7L8deRWRn9Qu9rqvvrolkD2FdA/4bjGPG8Jo4dKDF1/IhZcTqYVuyiHrlKCEi+Yb5aB49YPyZh1x/zTOdg0nqHzndgfFeJTElLSv8FsJJVXyWwjA1uEo9vr/ZcdaMnDaDrhhL4aPphMfdFQDbqMHgxE1YKfxgvM877UsAvrF6wa9fvbU05bwk1nbiQXPNy5MVu77hYuiZomV7pUEmhUq+4mbPqmSrHphDnUZQRWFsXfn2GeMT1ifKwYsiC8UWbJtoWnXlVm1HGEtDng3SavlUDnoRoMIypnBxtcLYqglRBGMK5532GTQoNEhAPS3qmHGu6lEZ4WJUWvT9sy2+chVyETqbsJI5a8clmOQafL3VtXc5SPQXwblMagqpFfAeiXHpOb1pOAaG10RJSevJpBOJEiMlZu0rUBuQUVNPRD8W55Cvv8P+W3fYvu1JjWCDVhlVrkCXl3zBj7rIFNfoFdNl+pOpCqlY3jq/4k6758W45lF/xcZODLnhOrY8GU+XMeXBgs1QCMUSqo7hxmrW0dnAys18FE65ih1nTmnUH+03pCw8Otkyjl4l4A8XxVhHm5WhSRLsqItWJkG2dTzpM34z0zSJlAy2CYRg1VMzCd1qZt3NVeFaqdtiUC3KaNTspvZVJAqlyYsmxXl1vArpJsmdkpYSrYsMwS86jqayKQ2Fe+0OQ+HZsFZSE4WYtZdwEI5tbaTzE7tQ7fVMqSSnWDMNAxiszTd9lAM+uVH7huAYGF4TYkTHjyLabGwaDRb185LyK4Qms1qRf/4bXHxnTeyE2AupRacRGdjqYQprFpEVN2qgsIMQvV4hTZsxooYzv/rkcVU1us+3T57hJXO/2TFlx9pNtCbSmbA858WnsViezic3QWF/SmsSvZ35cDpjG1rVcsyG1kbONiMX2ZCTajRQt43T3i2pQ+oKdqwErQMT3Ks5jTWZECxdo/Jzl7tepyDC4mR90FrM4RMHK6gjNwBZt0xLUY6DNVoSeJcYo+dy6DjrR66nlsYmpmS5mjpO25E5OT6ees7bgZWbebjKvBjXyyKVt4mYDU+v13zj7kty0RFmV5WqUjas2lmnGK36T0yjRwr4nZaIWl6mJZt8k3AMDK+JknWMhbeYxpOH8ZU6UypVtsSI6dekn/s6Vz+rQSHVTlVzracqNQchFc2as1fH6VLraxO1Ux9PDakqJzmT+eb9F6y9OkO31ffxXrNlnxrOnLpJexOxFK5Tx5QdH8+n7HPDkDx3GtVJXHttyl3Hjg92Z4gUTbGDI9QdAl1B1slD2waMKeyCgSunnSlTkHLIclQgpl/PWJvZ77XJl6unhDGZMFdFJ3RqcLj94JtJtcvDFph0f0NWkTIpbbvUBac5Os6qs7YxmTE65mhr81EP+y40POi32NCqqxRCYxPn7cAuNozRMVV5udbH6kqlDt3XuxWr+nqnIgyTKjsdPDbsKLTPb5S038SgAMfA8NoQI6/2EERuRpYHGKOZwrff5upn1swndc6fQFIhO4i9kL1mBpJ1xNe8NPitPkTqlGFsry27vsN47ZZ//eQFD5otCcOzacOLec2pH9mnZqmP7zp9kOvcsbITVjLXqcNL4nF3SSgWi47v1nbi2awmK51V6bOz9cCUHDEpLyMHi62KzKE2DjHK1iyi2Y9+kJEmM+4anTpUSfoQLXNwpKTkKO8jITim0S/CryULUrTJiSvIZMGysDKxZVnzPuhRHl7xUJehCprISN19uJ5aVZD208KCnLOjs7XnMPSqY+kSjYuEbBdjnIMq9aFkMUYboq2PXO86XAI7pYXoRslH5uNXHrlQuCkfAMo861VDRCcRbz9k940Nsa+ekVaWujS1tVSY63pBq2fNhkPmoF/3OyUN7dcOc2eisYneaomwsRMvZMU+Nqyd8Gze8Li9ZMyej8IZKzuxTy2dCZzZSgSisLITz8IJXhLvti+1/+AthrI8dusiF2PPbqgSbj5RkuhKde0B5C7hnnmkKtgtSp+mUJLQrgLeqzmMSMG7xGqjOpKdi1yNLdvYMe8azu9tWXUzV66nTJayt5hJyOcR3wfiXP0xikrB5SxYm3lRGYwHtSeApi5MOZN5uN5iKHQu0NvALqoo7ZxUIt7ZRKzeG3dqExOo9OiwPM5uali1gWH27IZGpzIRZI5gzadW698kHAPDa2KpJ7FgZeEsHIhNpRTM44dc/eI506khruSmlS/aQ7BTvcrKjTYC6TbJ6SDoWr8tCtbp9OHlvOIlKxqTFju169AtHgtD8mQjnLk9VjJj9qyMprxnbs+J0QNgKYzFMSXHysz4RhWY3zYJS2ZYNaQiPL3YYF0mRZWPK0kwjW5i2uFmtyO1OnblwmOSMF07psOvfWfm9HRgNzXkbNjS0jehUqoNc7SsuxnrdGRZJqsr4E3SacasZYT3iXm2NE0iBMs8+qUEUNKSXuVbp2SlzqpgbGMivQ2EbMHNjMmTsuGsHbkYdfJyt91xNfcY0bHmhI4u5+AXqbcpWnKuKlgBJGZyugkKYuSNixHHwPCaWNiMJSsjrk4mAEQE8/ZbXP6x++zesmppVksF6pvJzJohpF4/lsPtBxGVQ6laIPaQq3HMNHh2fcOl7XnQb9UhqfIYnLmZk93xe7wktqkjFMvGjlymHi9JS4h6afcSuU4drSgZ6FBuYGBlZt6xF7j7if+ar/HRi1PEgDWJiCVNFv/cvRLcJAlmMFg1tCbc0X6D7CzlZcNlMpgmIagN3Rgcoe5orFoVie37mWFoCIe174M+RZuUbRlV5yHVXoM9eGsWoXeJ825gjB4ruWpAZpragzEUTv3IlGop4Q1GMmNVhx6TrzsW9flno2Sy+vhTNco5GO5CC9O8TKluL9C9STgGhtdFuTWaXNrwtQ59/IjrP/aQ4b55RSUpOzgUxNmizbWCyqrlOvuv/2vtXsmAm0LcZOj1YDQuLi5L99odD/trehvY2Il7fscjfwlQD3nPZerJxRCKlgov4xpLwUtiLJ5QLF40qLRGBV4uU4+VTGsC9/yO03bkYzlZjGnLbDDXDrfVEWVqdDKh3pgHHkPtP5gCp1H1HgZLioJpE8OljhPFZZpeU/Zc9xhyp1d5s8rEWd+WvlW7uzDrNMSYTFN1HuZoubfZs51Uy/GwDBUrRwHgYu6JxdAYDeAbNzMkzy42nLYjU3R8sD2j9zqtmbNl08xM0XE9e9btjG20JzPOXh25LEg69EeKjqaPuxJfYVh7Q3JqW7AGiRE5P2P7Rx+xe8sujUWAUCcRVa0N0GmD0SVDSlMPlNFAcVimyh7CnUR3b6DxEWcTJ83ENzYv6G3gzA3sU8PKzjz2F/xC+wQvkf9s9/N4Sdpo9Bfsc0solqm4RdnJknmZ1tiDjDqyZBi72DJlt2QYXe075CQa/5LSllOrY8rcFNWPqM+5GG1MHta2SzK6bh0Fv5lxLjMWgSy4NhKjrboHhqYKwR5GiNvZ4ZpE14bavDT4VjkFzqZlqzMVpUk3JrFN+pyv506zgOTYhaZa3TfcaQYlR1FwUjMKK7iUF6+KlZv5eH+y2O4d+hBtM+NsZpw8XQDmUMsHpcabtiVP+Y0SazkGhtfEkiXkrOQlHLz9iOufO+f6Hafpf4OmwIesQLSvUCd/GgREJw9Q+Qw1izAJ5pNCPCmYTeDeyY7rseXuauDnTj/mj6w+4DKtOLN78OAlcWIHEsIur/CSWJmJy7QiFMuzsFmeuzeJj8IpJ1anGEAtNyY6Exizx5nEkDzPwoarqIcr1d6CdRl3PjG/6Cj+JjtI51G3JF1hdTawagOX1z3lR6ptEM+UzRg/WpEK+F3tTdCQ14VLryl68dr0y0XY7rXxGWfLQENKuquRomWelSzV9zPvnF0yZ7s4St3pBhqT6F0gFsMuNmyndhFkGZLHiBrd3mt35GJ4Mng6pxyFLLJkGkZ0L2SfhdPVuNjaAZiJm2W6lNERCm9UUIBjYHg9HEhNh8WotiHVkeT2a4awUU1AE9BNw6hlQWnrpKFmmoIGjOz169nphEIyymnIQj4NmAJDcJz1I4bCB8MZrYls7MTKuIXR+Cye8HfDtxlSw71my5i1TNjTVKVlZf95SexLw3VSI5ZtajWlTi0nbmTKjuvQEaoKUszKC+hWM/vLnpyE05ORFy87sivLpEV8Bgfnd3ac9aOOD4PFFSVp2cmqTH0NjLe4V9hByNcn7M8z+/sT33n7Y1oXef5ig7GFuPWEvdPayhXyoa9RS4/eBebZLqNaODAeEzkLu7mh92ERkt1Hz1mjjZB7fseT6QwnmSxCYxJz/Z0frq55sjslRYPvo5YRh+wmWprrQplmHVUvi3Vv3t7EMTC8DsRg+o48jJi+Y/5j3+DZH+2Y7kLsS6079cBnX2XhrZJ07NbQXGhdDnUSUeri1HDzOdR9iStH8ZYXO8/+3sDJauSyUn1/ZvOMVZn4te3bnDjl92+sSqfvU0MyRkuBbEnoIX+nvcDU0uFlXGnAINcxngYI0KnGmBx3moGLqFf8d88v+d7QULKw3Xe6kh2sqkxVr4nTkz3D1HC97fXXyEKhBoFZlnFmtjcB8tB3cXswk2EwDT9o7urrkwwxaBZC0NKDWZDJUFa6a9G6yNNhXanV8Hh1xT56rkKHk7QQq3oXlgZtLkYDQRGehzW72PD19Qt2seXptKku4mqMMwZH00ZOqlhLqO7e6dLTv4iUaVr6CmIE07akeX6jsoZjYHgNiBFoWyREyjsPufjZlumONt9MAgKVsSjErioYRSiz1uXhDNxWsFPlA4W6I1FHk4tgi0FXmNukRjGoPuFubng2aGnwxKk8+i62OoozlpWZF1mzfW507FgFXPa5qQ3IFVN2i7jLYUoxVWm0WAwbP/GovaK1kQ/2Z1iTOT/b8fL5CTkZ1YNM6ppVmkIcHZesSDu/6N+6k0B+Z2RsW+wkuN0NyQtqmXV4YbNKN3RPLfO8Jp1H3CoSR6clymFKkaomJaqm5EzmcugWotOYXD34OjkIyfLuyQVnzcjl3DFXIskuNjQ28XTc0NnIs2nD2mmzce0nnuxO6Vyk83GhRgPax3CRq52leVEFag9M11KOzcevKkqM5ItLzOkp22+dMp/qASkCaa10ZtUkKEpgmgQTtFTItSYPp4WylYXclB3QqKy72wthXZt3TUFcQVp1lQrJctaOPFpdce4HhtRgRDvlrQlYVPnYm0QrkRHPz3Qf86P5HvvUsE8NPxruLt15L5mM1CUrgxcho+SfxiRaE3nUXPEPXzxWCXqoKkyJKL76UdRNyiCURjC9dv3z1iMm89bdLTyAD57coXzULP0Vk8BMoloUmWUBy45g1qL7EC4RRW3zpJYOknR5rTgd1V5PDc7qEpShMGfHEP2iyxCLMh1TnVTkZGqpkMjF0HgdZSotXHsal7PyGkKyrHxgiqpveT0q9+LF9ZruueBe7MjzDGJ0uzYl/fwNyhbgGBheGyVE5GTNcE+1Gm0AuRRiuGk0StE3voks5YKJotqHWbkJJmhZEToNJOEskZ0l3Q2IyxifsTaz6mbW7cymmTiva9bPpg1GCu/0FzxuLsh1zJiKoZXIe9Mdzt2eF2nNz7QfYaXwq/t3aE3k1EaG5Jmy43F3qTP67LkIeiAygj+k3WgqfrntiLNDTNFFqSwUVxtwprB5uGMc1CjGmKwyasHywZM7yLXTycE6468MRSCeZqQR7KTOWIdRp52guRBSY5lbr9lCk5UmbdUPgyS4VWSYGjb9VD0iPKfNxNXUVel3u2hi5iKMybMN7TKKfDZuGKLnXqe+EIcNzDFqE7K1ZlnJVmcrXaRqbeJFNJw8Kch2rxlCiZTAIXr9obwnv0gcA8PromSKs8tY8ZAG20mQ/Q2hSWnQGiwk1r7BLOSmsh7RskEyTI+jNtbWkfXJRClq5np3rW5Ou7nBdIVYDJdB+wxnftRmYmpVkkwSGzvSSeRBc83KzPzW8ICXbs0v9B/wM93HbOzEXbfl1/ZvM2XHmRsIxTLMDWs38WQ448Ww4k+e/5hQLD/Y32M/e+6e7nn64gQRON/s+fBlR1plitUDu9+2yMetXtEzrC6F+dyqq90ohJNMWmdiX24mM/YmIGQLNurnRdDM6R60pxPzvqHU5SrjE3m25Cw0PnLaaRPRSOHl2KtCU9VWOHAWjOhYUrkNKvn2cHVNZ8PytQNCNuTQELKhcxEnmYR+PFdB3vii4/SHE/nqRutR3xdvXlCAY2B4fZSCTDOmcg9yq2/y3JbaNxB8fc+4PSzWcFTeQp0+ZA/JqPjr6t4eEdRPIWu3PSbLWTNyp93zZK9qz2Py3Gt3nLiRWKwGBBMJ1Wqtk8hl6gnZsvEj77YvyQjvzfd0SpEbrGRi5Sv8eLwDwJPhjJWbMRTWfuZXrx7zmy/uM0fLNDa8ff9CNRKAcfZL01CiQDTYZ36xujv0Etxe1ZzIuhwWZyGuq+XdXh22clMo400nPzW6oZm6QtMHJRIVkF5JH3m2mDbhG+V1HNasrRTEpqWkAIiVQupItfcg2lMxGiTmZDnzo05fajlxaGLe9/r6DtGTi/DW6pr3t2dcDB3rH1raH31EGoY3NhjcxjEwfA7kFxd0L95m+64lN9pPOMCOdfQYAVFas9QrpCSwQ729U75DdioGYqqoqa9OSVrvdtxp99zvdlzMPRs3sbYzd/yelZn5eD5hY0em4gjZct9fc18iyRku44oPpnPOve5MvAwrcjHsYstvXt1niJ7eBc5a3Z04cRNPhw1OMr/64WOmwbM5HXBVLSkHQxkcl9FgqkQ8oO5WQOoypSmEVpfIJOlqsuSb393tlRFqZihO+zOH3ko5LG0GNdyZBw9FFpm5OOuCWr+a6RudSMRKWx6CitqCLoBN1dfy4Eu5j83y91n7mW1o1e8yO1ZO1bavaiYWs6GzkVjyMtV4Oa2wUrh+tuad7yfK5dVNo/ENLSEOOAaGz4G83XLy3UuuvnGX+UyvjCYIJlf2YgsHlVBJN4xGEzVwHPoOxRUkC9e7jrMTtZgzUjhvBsbkFp+Eu+2O3gZaEzn3e0K2XOaed9oLzux+oTV3MnOZ15zYgY/LKReh59m8preqWHQd27p6rCawc7KcNCND9Py3z94mJlP9JaBfT3Rel5yG2avU2sFxr83YnSWt1fcy3g80J3M9vBByg9uaZeqiNGYhSyGuMpIMcZ0xs/pnHvZDDmxQyYAp9OuJebaqPTlYzFqdsbZDS2pV71ENZPSJHcqCWAy+CFNygDZOWxdVLbr6TZy1A9vQso8Nu6AS8nda9cl0JrGf9XZQuvYQPO0Hns1vXpGvtjdvhjc4KMAxMHx+/MYPeOuk46NfWhE2OmWgaBYQTvTAA9qDCCzTiXCq9wunWnpkX+jawGk31U3ARCyGh92WD4cTXlae//1mq1uEksnF4k1adiMOsm2gOw/vzXf57vYh26g7Fc+nNffanZqxFFdHeYaYLM+GDfvgSVm43vZs1iP3T2/MWrv1XhWkVz3J6pSANpMOIi3nkb4LtD5yFfpF11FVqXQBzG8NZoLpQcbcmYm2obSJ1AgyWvxWeQ7ZaRClqFvWqp0Z9hsVaRG9PSWDq94QqbpMZaNOUyIFogaIkFTwdaqGuEP0rKrq8xA9V3NHKUJAD33nor722RCz5bQZeDasD5wsLq97Tn8I9uW1Sju+oV6Vn8QxMLwuqjdlHkfsf/NdHs/f5vkf27B/VK98dSJxsLdPqxuZNjPrYTFJiOuCGYXcZ949v1Sx0WxJxdA5XRFeOa15extY2ZmVmXkynwHwnfYjHtgr7tkd78dzLtKKtZl5Mt3hw0nv05hYr5qaVp/4kefjGoB1E7BmojFpcXsOyS6qy70LDNGr4atJvHX3imdXa+Z9A6ZgTwI5CnnvGJMwDCvcpdWN0Sy4QcsoDmUVUHzmwd0rXrg188tOtRuaTNwI/koDaWoLuVelpDFUCTkpOgk5CMfkm75EzAZJZdm3iNW1OhdRIpNJNCaxDw0hWc7bgbWfF2l5fS1m1l4nFrkY9rHhYlKiljeZffDkD3rOvz+RnnxEiZW6+YYHBTgGhs+Hg6V9KcivfZ/789d5+qfOGe7XN3dflLRUS4XUFrIrSFTjktApu0cAWUXO2mF5o46Vgegrl+BAT/7u9iEnXrvwXjL37Fb1Forj1OjtP5wf8Bu7RwzJs48NsegVdU6WH+3uqNdCbbRZk3m8uuKj4YTGJB6tVGR2zo6NmxiTIxo9iPvQ8HLXM49eD2kypKGa2BaQ5w3NVgVpTBTCRhesTKiTBqt9F//S8fxsTTkcyixgCrHX18OOOuItttA0KvKCKOVa2oL1CV/Lm9ar4/aBCm1qcJuiW27fzi291yDbOd0ePYxgXTXcsZKZYsMkjik6vE00Ji7bmd4mht2K9XuG5r2L357ZeDAzPhrOfEVx602RR5UiMd/9IQ93I+O377F97JnOhbCB4gUJ+v9ByMQOQlkVUpvJq8LpqTb/cs0UmvrGvJh77rdbTu2Ml8ST6Qwr6qvYmsA3/TMu8orvTm8BcJlW/MbukS7+FLMQmcakV/3LqYEGpuiWQ5QR3llfcDFrc+1nNs+4CD2nbuTZvGHOesiAxQG6FGF4uuKgYC3R4gYVbTloSlCE3CrPQbL2YFLS+0zPekqTa2alVnTcmQmdJe0tdlLuQs5CrBmDGA0KXRdoXSImzW5KDXCqA+lIVcnJVQ1IAG8Taz/TmKiuVFXFKRdZTGlS7Uect4Oa4hbhbr9f1Ka3H21450eJ8sFHv32WUApLE+YNwk8MDCLSAf8p2lZzwF8vpfwbIvIt4K8C94C/B/zLpZRZRFrgrwD/feA58D8vpfzgC3r+f7AQeeXKkIcB+cGPaZ98TPf4Ifufv8/ukSP2VRvSQG5q+quihBRnSCeJs34kZkNjdW6+dhpsrNN6eMo3V7FUhF1s+Ub3goQwFr80Hr0kHrVXJFSA5GDyup8b9qHhtJk4awes6AJVYxJ3m33dKTDLYz9otnw0ndKYWEVOBMmF837kSmCKVokbSVQ+/lqbkuGkEE8yzUtdHU19wVYBF0lC3NTdEVeWZariCmUVlduQtazKrb5G+8sec+mUAXo203e6eh2jBoSuUR08NaxVV6o7G7Xv288eZ/PiiL0tLa3VHkRjE41Ny1hzKq7azwXG5BiTTirOm71OJMae7olj9WRHHsbf+X3xBpYWryOKPwH/ZCnljwN/AvhnROTPAP8W8JdKKT8LvAT+Qr3/XwBe1tv/Ur3fm4FPvgGqSEceRvIPfsz6Hzxh/WHE7Qt+V7BTwe0Kbl9wQ8Ffgb8ySFDLs42feNhuF+l3W5WZWhN52FxXazbdZTCSuUw9/2h6m13W0cd17mhNWBajzv1AYxNj8oRsGYKqEz0f19rHyIY77X75GSpnZpiyptbXseU6dDiTOW8GXUKqHf9xaJCovpMyGy2Xqk6lezAwPUxL6TSfZ8JJpji138tOuQ8yG8zeYHcGRotrEnRJM5B11LLihaO5MNqHCYa+CZysRrr6v6nGvADW5sW8RnUdEikra9HbxL7+/o1Ni9zbmJzqUMwNcy093CH7yI59bGhM5OMXp7QvwX189Qf6Fvuy4CcGhqI4zGl8/VeAfxL46/X2vwz88/XjP1c/p379z8qb6Od1yB5KgZwouZBfvKR7OupIso7fihVSI4SNLHN9MuqzaNLC3/eSeNRc8aC55k+tv88/tflVfmn9W6QihGLIxXBiRxIGS2afW57M53wcTtmmG5GVr/UvedBuudPueefkklKEi0G1IduqiGxE9ysA7jY7Tt3A83nDL24+5Gurl7zVXS1aknNWG3nrMnI667LYLOSHM/OdTLGFcFGNXiqHobhCcdqENAltNvbVaarVDMKM1Sl8Vxemrj0yWg0KszZyGS0X234hfw2zr2WENh1XTagy9yw+FevKdehdYOXD4pfRmMSpH+lsZOVmvMmcdSObKqV/sPDrrLpmp+ctzVWBj5/zxgk6vgZeq8cgIhYtF34W+D8CvwlclFJq35n3gHfqx+8APwYopUQRuUTLjWefeMxfBn4ZoGP1e/st/qBwiG+lVFm3W2+YklUgNmbCRhanqcPSUfa6E2AnFgYhwHUl2EzZ87JuVHZm5j/ff6dKsOnSU28nnoUNY/bc99dcxpXWyaJB5cDwu+d3DKmhtRoExqqMHLJddA83duIiKvEpFltl4AyP/CWXacUlfV3WKgzB09jEpp8YXWKXDPle5t7dLc/zCXlvsdfKUjLTYc3aqrqTKaR6GTFNIs/KfJTJkjeJvPPgc3WfArsz2PmWs5XAtGuYB49rI8ao5mPrR20OztqwtdWnAlTVyYruTRymLkP0PCtrOhu5Di1DVCakoXA59UtQ2HjN3D7ebnBbg98X9R79SaXCGzi+fK3AUEpJwJ8QkXPg/wH8wu/1B5dSfgX4FYBTufvT8aoeZti3ew239R+NQXJWebYqoCTxZkZ/mNcXp4s7h9Xo1kYywmXocZL5jy7/yKKncNATOFjSXVQj28NBOIi2WDIvwpqreKNzeB215Fh7XcueosNVz8sX80oXqZLjOrZczR0Pmi2dCexrVGuMEon2s0eAdTsTVpamUR1K2yRiFJKA3VrSqixr5XYSnTrUJSgBDQJZMwqp2o3N6cQ8eMyFw+3lllaFEOvbogwO0wdd/XaZ7djWABGwpjBHu1jaA4zRM0ZHSIaTdua0HSu13NU/mZYPh1EnaAZ3UJXe7lvMLHTPqiDLbRiV+CsxvNGchs81lSilXIjIfwz8D4BzEXE1a3gXeL/e7X3ga8B7IuKAM7QJ+dMNY29SSjGIlRuxDms5CMMWX1Wiq4u1lFpt+AMTskCbaG1kG1p8q49xaIoNSXn6GZ3HT3XG7uuC0JwdKzvz4XSqfYJSFrGVVISQdaPQmbSM7lx1fG6dBqBQLHebPc+mNbvUMNfGm5W86EOeuoHr2DJMjdrNdUHt55tI3wSsFHxTtRME3YGQqtXgavN1HZEmw2TJ+zqCnHUiIVuHnM/Mo0deNPhrgxtvlqxiX5DBUE4yZh3IWScKKRlSUoPZnM0iQuNtemVKcRCZBZZx5GFU6Uymk4gz2o/pJdTMyvLdqwfEj3vOnkL3g+fElG4OvwhiLWbdQ+7I0wRJy8iv3LhSRB4AoQaFHvin0Ybifwz8T9HJxJ8H/kb9lr9ZP/8v6tf/o1LegJB6q85chED1E7WvsyDOMTzUNWYTb2jBcug3GH3Tt+uZ1kUaG18JCABGqsiKjbQm4o0qMl3FdikrUjGc+wGLbgEevl8bZ4kH3ZYpW/axYYqOWQqd06vpy3HF2s64yvbLxXBddwj+k/E7dC7Q2ciDTttKjY/EYBcfxwJMwXE9tAwXHUSD9BFzlgiXLRKE3BY4CZCMsheDYAejt4uOK/NZ0OxhNjTXckOGqtoN8Vw3T30XadpIzoJzgXH0GFPU7Le6jYdk2XSTBq7qN3GQWzvY7R34ImfNSDyMiE1cRri72HAx93zvyQPa55aT9yLl2Yubv/shU0iJvN0tf/tPvjfeFLxOxvAY+Mu1z2CAv1ZK+Q9E5NeAvyoi/zvg7wP/br3/vwv8n0Xke8AL4F/8Ap73HypKSpo1OH+LDSfInTN2j9Tb0cz6Bgeq/wJK7e0KJ+0t41kpbG8t+2zczMXcYyiLKhMoASpKxpnEVewWVuTLsKK3gTmr0IozibvNjmfThpgtjzbXPB9Wi2hqFuH71/c0Fbe6vAXVTyGbhSY9Z8s+NEyzIydlI+Zs1JzWqfHL8noEA03CngTSbBBbqqozlGxIzzVg0BRKmymrjO8iYXQ0H3nsWNWtam9hehDxZxM5G/pel6RKUdLVyXrECMSk3pVT8EtJkIsQkqkq0gWwuGauEwcdd47Rc9qOnLhJFZ1qqbZ2My/GFXnr8VtY/9Y1eb+/VS5kdTcHSjxkD7yR9nTwGoGhlPIPgD/5Gbd/H/hTn3H7CPzPfl+e3ZcJh6SnlhRi9M0i1lJywZyfMf7sQ+YzudFksKhASzWgSS3kTslKU3QLy+5gkNKaxDY2i9qQK1JHlWXZpQBdLY45MYrXmri65p43AyGrZ0RrI3PWw7vygV1olEYsBSuFq7GtOgaZdTMvqkUxG6zLXE0dL7YrnMs0zciqCYSk+ofWZJzLpDZhN7Oujnczc7SYVWHYt8yXLTKpwnNZJWKXwWXa9Yz3id1lT/fDltTdaGYWW4OpLRw090PlLyjqslRS/oUTaFysEwkdU87R0TeBEJWnvg9+6cesqhL1nCxPhlNWTjdWczFsQ8vHlxuap5bTHybkhx+QD2XE7b+/yPIeWC4Q1i7mQ28KjszH18UhIFhLSbzSXzCNp7z9gP0jT+xrsxF9s0vRsiLXpiOiJfmUHLaoRoCrCi7KzDOs3MypU0PW6+Q58SNrpxLovQ2sqwBsLsLGKjFqYyeuYoezid/YPmQfG37uVEVatqnlg+GM5+OalA1Tspz3I9djS9MoV6GtAiWxiqbO2XK2Hrjc9fRNUgETo828ffDMk4fnLaHN2FOVYD9fD4Skass7q1lQ20ZCsBijPpbT7Ni+WNF8oP6XdhBcFbrJVmnlCISLFnxWOc1DIKo7E1NwOJewRnkYvVdBlRDtwmE4eFkWlLV5+PxApY5Zf8/WqPbjh7sT4o/X3PsNOPt7H5K2NwtlrzQX5ZZnZWU9LlTvNwjHwPCaUDsyblmTLV9QM1uj8mV2Vh3XYm6WiCQBjkXp6PDmve2alIthqvsMrdE+Qyi6Kn0Zek7cpKKtcqMXYCvR5yKs+Fr3giF5fjzc4eW0YgieF+2K++stV7EjF+FBr32DfWy4mjpECmPUCcdBibqxibHc7B2IFPXJnBq8zYuQaxotNoLJhiSeQbTu7xrduHQ2c7ffI1KYkuPFbsX2uqNcNiqWa/S1MkGTg+kuFKNTDZKoo1VtYpoqFpOTqX6S5ZXJgqnMxkNgCMkuPZVUX6tUBJMNKz+zcvOSieVieLI/5ePfvMe9fyjc+3vPSR98eEt3wXDzx0aDwqG8uH3bG4ZjYHhN3E4bP/VGyBmZAs02E68EEGKnmYMcfCqTKjeVPi0ir7aWEL0N1c/BLFe0w0iys7ESklTJubeBKd+MMQ8wkhlys+wCbOeGJ/szLuYVV1PHGB0/e/6M3oaF8nw1tlzvO843e3aT8hZ2panBIGFt4nytW4kFsFJ4vl3x4GSnxrN3QXYWiUK6ahh7w6bXJuAcLXe1D0tTJyR5cOAK7srg6vKVJF1JH98JiM+USZmhpctIW81ti7BajwuJKRfoq5fk4fUaQqVDu6gLa9U011eK9N1+v2yNOpO50+iuyq9fPuLH/+1jHv+XhfP/6gMNCiEujUZyulmUuv13vx0c3oDe+idxDAyvi/rGOFw8Dr0FSibPCTdMNJeR1AjZGbKXV4xtF/n00XK97fE20/ugy07h5o3lbrESD296f7CUM4lQVDfAZMd16aC9YsqOD6ezxSxGFZMzD7qtbltmw0k7sY+ec68H4tSPPPcr1S8wmb5RpuCh+WjryO/Baqd7EwF2s2caG96fPCUL4jLuwUzXBYbqIHW165aewNPdmk0782K3Ytg3SgXfGppLobkqhBNheKQ9BoIgXebO29cMU8Nw0WGsZgbGZk66iauhY5g9p/2o+yD1uR5+XilC6zRLSNlgjZZbU1QJvJgN97qJEzfhTeLvfvR1dn/nPt/6/wz4X/0R8cWFlovOV8HXWwc+3xpbwisjzDeRy3AMDJ8XB/ehWlceMon89DnNqqPYE6bTBrevozfHjXfljGof2sww+6qaJItv4iEQzNkyJk9nA2d15frQeGyNqj1bisrBm8SpGxgqKSkjvNz3vH16tSwHbZppWSJau4k10yIuK1K4HLrF8v3+ascQ1S7+tB2Z6zajt4knT89UG6G6S4kr5GRJKfHO/Qs+vtrgXCJGy+lq5OunL9nHht4FnvkV1zYTek9uHKWOGouBcJ6QVURs4fJqzWo9YlcRYzJtHVWOwbHpJvZTwxgctgm6VOUjc3RqCJMN9/sdL8YVMVmcTTVAZK5Du9Cjn44bfv3DR3T/xYZv/L8v4Ls/JB0mEEAJ8yf+5uXV/z/5tTeQ8X8MDK+Lz6oj621iBFmtyL2nWCGuZGEAHshN2aF19SikaEkuM0dLW4k5rtbKhxHlQe34MnSLnLmRwsfTyatfj72qIMeG1iQ2buLeeq9chuSIxfJiWOFM5sWw4oMqbtr5yJ1uwNdV5VgnDlN0tC7Cbd2C5Hix75XC3CbEFsRmfD20w67lh1cdvgq5vnPnchGx3fiJ2VjsJtP7SDoXLk979t0Kf2lVr6KPlKjEJbKwKx39aqb1ASPqbG0EWpug8ilUvRnSMppkaTBq30RLH2O1cWqqkMs+Nvzj9x9x+nd6Hv/Hz8m/8Vu/OxbjGxoQDjgGhtfFJ2rMpQEpBnPvLuHn3mH3Tsv2HcN8qjsRblBtAlvJTQu3oQgxGozRPsPB8OUQFAxFxUrrglUuwj42OsKsVu+N0Tf+YfNy4/Qq54yuFu8qN2IXlOS0r+pHKRtdYXZpsY8/pOLeJsaowiWHn2NtZjc37LYdMguyzuStp7RC9onzkwFf15zVV1JJWwe25RiVuPWov8aZzHuXZ8qFWEVC9YtQvTgwPitDsj6XB+sdH12fEKJdiEsrH7jTDQxR9/kOQVOAh6tr3SyNFlOfv9TpzcGe7vtP77H++z2P/otLym/9+NXs4POUA4e+Axybj19p3N6NqGzH5Y1xsma655lPtKHm9tzsS6ygf1Zw5fA1Ybry5JXQNJGrUUeMt3HWDEvHfM5q737YAjSiUu+9VV/Gy9CztjPb2DAmz8tJ+wZO8iKffriypmyUdFS1DA5swNap5gOopFnnAtdzW+8v7MYGYwqxz5TBqa7ltSPMhmeTw3qdVpQktH3An+q0ICSLcYWrqWMXG64n5VvkLKxOpoWDADBHx+6yx/SRe3e2SlqqehHW5sVIpnWR67ldhGQaexMsY7ZLMACWPQjqz3lydQr/aMOj/9+A/PpvkYfh9f/+t3sKpbzRQQGOgeF3hduUaDGC7AbcNmHOLG4HSPWPqPJm+0d66NwA/ho1rtkZdqbgzvZYI4vASq66AIcew2GsduAYzNGRnbB2E7vYch3a5Xl1NixqyBnhcu7ZzQ1jXVfOtVFXCouCkZHC4/UV13O3SNgP0S+iqrEGh1IEtw7EwVHIUOnNJRnSlYfTQNMHho9XXPpI1wQerJQLYE3meqo7G1bou4CzaeFE7KdGM6gmsVppP8TbxIdXJ0yjp+0C21Gbm6fAbm7wtUTYzQ2mrlcDixs2sGxXArwYVlz+8Iy3/9uM//Uf/WR/iNuBQB9Ybz6QmXI6lhJH3MIhWzg0IRPk7Y7mcsY88roIZA7TCCGutdfgBpQFaMFfCemBukVbU25ESZOltRknibnoUs/BZ3IbWrpFqDVzHTvO/MBl6Jay4XLquZw65mhZV2XklIUwK53ZN5EUDcYqWejl9Yo7J3tdJHJB1Yxq6t/YxG5qNHiYTE5C2XpklbB9JF6rAY10CfdgJlx0pCctPAjs9i1TcGzHlhAs635SZWYxrzATrcl4m+ibwGQsIrrB+XLXkw7lhVURlRAssbFsQ4M1uZLE7FIqzMnydFgvmcTD9baWG7pE9ez5Cee/bjj7+090+vCTcLvheGvy8IqB7e0JxRuGY2D4PKic+U82nso8Q84gNUswQmr1YxOrJTwQV+DGunFpId9izDlJRNEG4JIm+wjFsK2+EBuZ6vJVUgJUtkuGMUTP2s1V9LXlyfUpuZYNKSk12ZiMb3QSEmaHbyIrf7NMdDGpD+b11Orhk6KN0mQwLpME/HsNFOirkW9uHaltaYJmSf5jTxFPLBAsxJNEOrNs1iPD1JCSMA4NvomEZBmDw4i+FmF2fPTROZiCsQVj8rJAVYo2IUEp0Q83W7ahYdVOi56lSrVFQjaLN0TKhsuhw73fcu8fjuQPPrxJ/z9ZHvx2uP21T6l4vXlBAY6B4fVxm+RirO5KoONKs1mzf7girIRihVxFRg6uTeXAhDy8p0pVQcqQsiosPduuaVzitBtVzt2poOuhvDjsSjhJN5JkNnPmR97bnTNFx4kfdZEo6jbk5b7XA24KaXTsL3tsF8mzHjAxmYuhW8qHXIT97LGmMAXHfmyIs9X7Z5Vmk6SKztO9TPdR/Xwu6vA965IYRrOi8b6KsMTJcl16cjDYJmFsxhg1jT3v9Tlf71vSzoHPeJ80m7Iq4yYiuGWFWinXh+erpjCOzutC2FyD6hBuxsHbFyse/WrB//qPyLd3Gg5iO6/TdPxkafHK1z7BjnwDcAwMnwe1rjz0GEzXwjwj3hM2SmoqSnxUq7Zb5KZigMOWpauBwsB239J1YaH3jtEtO5WH5lkuQhaByCINb0rh6dyx9hPeJjLCi3HN9dTQNYExOObJ0fWzEikykJWhiBSkTxhTGGfPS9MTa+oes8GaxG7fEmdLGS2mqjhLgrjOqrngC8UZwqZQrB4sE4VwNyFJyHtLXicVkI1GLexdxjeRuxt133pndcmQPN+/vEeKFqkO1zFoJqRNRN2ibF1ijlY3J23iemxpfVx6CrYGAbjZjRij42rX0f+g4c4/vKDsh1oG3mxM/ra4PXX4pCjPAaW8qtPxBuEYGF4Xt64Wh8bjQUa+pIydD/VmXZqqW8mHRaoiLL6WxUBe6QJVzoZx9FhbsGZath+XZmS2dQUbhuiXHYG59h9yDRStjVWQJC/En2tUxDVNdvFykMnAiV6RY7SkaAnBYm1h1U0IMMx6NW76wBQM+TTClcOOugFmR4P/qGpYZjBJSKtCymA2AXnSaeaQRH9xo/2UQ6YwRcf12JKK4UG3ZTc12sOIymMoRrCtljIn/chuahYZtxAsrQ/4mkEc2I/GF7ZTg617FdYHhtkTf7zmnb8fkR8+IYdb2cInS4jPygg+SYG+fb8D3tAm5DEwvC5eeUPcrFsDEGbcLmGiJYtmDblBM4fDIlW5KSeyh2K1aUZRNSLn0tITODD2QL0SQLcxDwKtIdnFQObgh/B8XC9X2etBF6SQQtg2EIw+l0FNaXMUYnTYVdQDOXtoI9fbXr9n8JBEremsHvDiC2US1U4YbsxobXWtDmeaHVhTVLfR19+/1+ec68JYjJb9tqVbzfzgo3v8gHtYlzg723N1vSInQYwaz3Q+crnricFiXSZFg/PqCB6SvjY6edBxZ8yGkJQsdrHv2T5bc/59w/q7z8j7/au7D6V8dr/gtzOVuaXg9KatWH8WjoHhdfEZ0vFi8itCHRIhd3DwW1x2JWqWYGI9TLNuWuYq/upc0qWlatW+r+IjKz8v0mzAYkozJo8tWS3YYsNH2xNiMpz1IxfbdW3WGeLkdNXTFohCaTJmZzBXjnwW8T4xRY/xmbCrNvep7oVLQUyhBIO9dEgQ3CivlEWxUQn5cJrBZ8Rn0tZT1oXcqCS8b/UQGaP2c2rJJwzXLcZljNUG5xQc/WoiZ2GaNDPaT5551sZiimZZuxYp2JoZpWxYtTMxWTXmQceUV9cr2g88935thCcfU0K8yQA+717DJzOJTwaQN2xPAo6B4fPh1htiGVuVrLsS3iwNx1wdrk1k2SDMza0pxQzNc8OMh01QSzbAiiEYHWEaKeyrGzOwCI68vbnk3A5czD0f7TdcbFdLk20/NjiXmEZP18+U0aqrtAcpglRvTQTEqrt12TtSAdpK7x4sxWdolKdwwKG5GNeqBp1t0TIiiDZSTwpl7zCjwUyCmS35VOXdDxMQ7/U1S7EgbcI5pYMbUzCm0PnI1U6NcVLSKYWAblgmTbcyVIUmoAbSKWi2EOvUYkqedOm588NC+1vPiNfX9W/1EyYPv91C1O0JVPqMJuNxieqImzT0Zh1Xupa4MqRWtEwwYAeWQCG5qDPTYVJRVKDkACUfGTKwOpBzYOmwH3QXQja8d31OKsI43ygTHWzdjMmMQ0OeLWNpNFNZJ80CZlGvBiCeJeUBvOjV36FoC+JgJGsmfS4lGMxgqjZCYe7rQljWjUg7Sc2SijYZa+M1rXR0WybLNFuMTwuxKiVlJgqqryCmLAFiDI4YLGIK476hZM1eRAqm0ecsJi9VQClCSJacZeE9WJuZ957+fcfZ90fy0+eHF/n1/r6fFRQO06hPrl6/gQHhgGNgeF18lsRX1WfI986ZTs3SjNOvs5QU2dWAYetUy7D4TlB5BiULvomMwakSct0eDMnSuMhJO7Pys4725nYJCqVoYKCm23nvwBdyqJZyNRAht/ocSeDS40a1rpcsmGCXoJX6UseQ2lModaqXXSGvMsUZ3K6a9m70e8pkoU3kpu4/SMG0iZKEHCwRSHWHwdis/IhocE0kxpvDnefavJgN+FrOIIhNiMmqrFb9JUS0eRujXWjQIVhk61h/UGjevyD9JHu523hFqekzmpC3g8MSMNIbGRyOgeF18ck/fpX1MusN8/2VHvqaERSrB1/SzW120knF7Z5D6RJEIWPJUlQOvWYHegDyUiYA7Ktu4zBrD+JAdU7RUqKhTOofSWCZBlBAoqb3utAAxRT81mgT0VTjXcDtpMq3F9xoVAK/Nh5NENwOgtPsIbXKZwAWtSWZHKVPSJswtpCD7mYYnyhZLedSsTrZqPfxPjGNjd43mBrI1D9igSmUVMVXa6YgUojREmufxhj9Whg83TPL+sMAnzdb+J3+3kt2cGMhcPP87FdPPv6IildcqPRNIs7DowfsHjcq0NLWVWsLsbuRLluk43vtM9ipEoGiIKPVACGQcoYGkLLsCOQsuEY3HOGG4HPYfcjJkIPRJqMvMOvITwVVwV7bajBbex4C/tJiRxWSMbP2CVJXkMrSdO7wux56IoIbITVCPNFMIrVFJdpE5dhkMpRWs4USHMnW0WirDtZqOoHqjJuC8xERmCdPjnVUmW43Neo0JAviNWs4lBkieWkH3LBHqy/gaFl9WOif7Cjj9PvDMfhEybCoO4mpT+LNCgpwDAyfD7dt6YzF3rvD+O4ZYS1Va0GDwkEYMbt6GA+chlyXqKxuWeZGiUPRauOSRutn79NyNbQ2q4lKMngfCcExl8OhEJVcaxMJNP0GZBW1Ps9Cbgp2kGV3w0SQEQ6LXoe+xyFQHJa/clObi5f6PbHTEsPMggl6n9RXYtMs5FXWDMUdghM3Uw7qa1IEc22QDOFa33p5VQ9V1oxGgoCFEuts1xZsda0qt8qnpdWTdbxJEZWjf2bpn2fMh89JMb5a+h2++XP9zeVTj7GMK5c+05vXazgGhs+DW2QW03jK3TPGu66WCoV0YD4WblynRF4pM2wdY5oZmpfVhKUorwGlHpCixfu0lBGH8iLWujxWTwfjbjtPoCKqpY4bi8CkAafUw5ragt/Jsuhlp+qr2UK26iCVbX0S1fI+NepYjan8C4G40q/ng+q1EeRMVXBLvtVUNUWnIvYQKcFvVej1QJ2WZLWHIfU1ECDp70JTMF75C8rLqGcwG1LWQFEq7yHOFiZLeyH460S+3n564ckcmjyvgc/iOpSCOHdrIvUZXIg3BMfA8HlxILqsV0xvnRD7m1pTstbixWqjjqxWa8XrFTmuirL6Ji0z9NBCadTTUUzRNeZSaLugi0OTJy5NN/05ph60krWcsE6/Xrp8GCxAEJrntqb7LKWEnWpgqiWP7nEUTBJ9zii1GfS5xbVetc0kejX3SoEutmYHQDlJ+jNNgcloCWEqbdqX5XYzGTX3zdBcCfOZfr/Emyao/tybQHLoi+RgF7/LZfEx6c9Jk9WgOBn8tuCvwmcf2tssxd+JyPRZtx/+/Lcp1W8wjoHhdfEJbwHxnumOI1Yl5ENTUYq+wZtrVYpOnX5f7AvFFYwDJiE19VAeru6mUEYLvmBcZhq1sVgyOKtjuDA7UtARXyk1hQbi4JYJCEkoGCQaJOs48cCnMPWQHf5JBJraYKwZQfY1OAQht1nVmgej0nSu6GO5ov2MJDrhmI1OIw5GMbboYe9r9zUJkvXwp15/th20V4Gw7JccfoeClhQFQ3FF+w/RUA7NVKvNyBLrN1mdt9pJsCPY/fzZfINP/h1/u699VoA4BIM3sJ/wWTgGhtfFZ7xZTCpabzdoWpypZraqg5AtpE7Lhuz1Cp/qtMIEbur8mmXQZO3gR0O2ygWQmh3kLDquM/UwzVWUNUudHGTMKpJHq1ftIOrTYJU/sEwkrCqpmcDimJXaootRFnKXkSgcKgKZD9ELLR8akCIUCu7KKmch1+aj14+LzxRbT3wU7N4sh7+YmiXZ2pMxkFc6Hs2uZhhQfy/0d0yiU4oaKPX/+vhFX3uyErBsKMh++mzruNuchE+OJj+LyXi7nHgD+wi/E46B4XXxycUZ50hVIt6km6te9of765Xa7USbdkHLiew0DZdJuQ1ppQcR5RndrEQ7bcAVUyhZa+lDQKAeFimyXEWJohyGKJhZD2JcF+wIZns45TcTkqlazGeHHsbCctUuVnsDEjVrEHtT/5u90bJhtGqeM9WJQx23lq7yGA7BSGoTtgYi/aE3Hxd7KzCKZirF6HMqUm4WsUp9UZM2XNXVBy1ngn7dbwW/S8hYM4bPOvDlVjnxWX/b3w63V7RN7SYvXgJvXtA4BobXxSdq0xLCshAFLL4RpYEiotuWIqTuhtOAK9hZMBOEdaE4sPWgJYHSyPImz8FAFUstRptwJcmyEAXolboSkYoRSlt0J0IAKZjZ4K+lTh1qY7PRZiO1iagitZrm5zYvAaHYutsRKk8gysJrOASP4m4apof9CV0zr1f5AFg1siUa3F4wQbSsqn2YUn09C7yiX6E/FM0coixxgVRLByk3I9B6H7cHO2bKdvc7bz3+duzGT5YJn7VFubwPbjMgj3oMX118kks/TbhdJj20ta+gh18Si3claGnhdrULL9roy14ZhbnhRstgEih1+9EXsECw+nVbyLPBDJbDglNpCsVnTeEPvpgZPYi2QJOJrpA7JSo1F0a9LpxewbWcqQ1HUxZfzVLrdaxmKrbSqLM/PH/9WYfvPayU6++qAYq6PCYZCJrBgP48yYdRbVmeB6VekGsTsvhc+yOycB8kaUkkNWM4NCoPgdQOBrcr2DnfGif+hKv4K8H+J/AdDkxXI5/uX7yBfYdjYPg8uFV75t1A//41+0d3SO1NxqAmtoXcaI3s9vq+yY7FX8LGm8lAqldac2ArglKBZ1mu5OX2ASo17bZQXKY0WQ8jeljMJEg05FbZjssB5WbcaCeI/eGKrVkGRTOCwxX5UDrkehhzlzGjwQbIaFayKFIdypnCzYEGyFLHk5VmHQ+BSe9vZ/2diylLKUXRnomEw9gVzYTyTTCQLMgsS8ZC0VXw9jpj5gz5NUlNP2lxavn6jSJ0yYZXaNFvaP/hGBg+Lw4kl5QwHzyl//opwz27cBUOaf5BENYkiPVVPvQistfDXswNCeqwpl0sy8G6fTVW3kEtMwQIsrg5SRRMHRGS9cCYUZQfNOjVOa7LcvVPTbl5/HoQlx92qP9LLRf6sixamXp1PgSEw/Tg0JvIdZRJW29POpU5TB8OE5riWBShoAZM9DEkaXl1aCoegghZf58lABWU3FR3T+wIbsiY6XfQSvgMstJn7kfcHnXeziYOHx8CxW3C2xuGY2D43aDUtHo/sP6tS1J7zrzRVeAM5FaWwFCMKkSXOk2wo2YRqa0HoqkHtRL9JADIEizMYcOwPpYePi1RzN4sS05yuKIWkGxu9BflRkyluNrbsNrrgDrK9GXJAA7NQLs3pL5uSbqixKnaTCy15DjwHXKjh7f0CbOqwizBIHsHe0ORsuxbSP29UltwW1keD8MyWtXHBBLYLMQ6Jj1Aoj4Xg/ZI7Cg0V2CHz1ho+uTV/JXlqM+4yn8mj+EmQ7jxLH2N8uOnGMfA8Lo4vClu6TCUeUbe/5D1uoGvr5jX2kj0uwIH70pbs4JJsJP2Ig6lQXFCPKTqhwZl1pXt3JalCVhsIbXUyEG9surMvjj93O1vPpdcHbCCLHW81AzboyNTRLOJ4iDVZp5UMtQBdjAqU1d7GJLAzqK0gTpyRPTqn71mK3lwN0SkyrOgNjj1deSV8kY5FrLwJyTfLHVB7YXMWp4cguMSRGctaewomFAqycog3r2qxfjJseOtv+nrCq68oth1+N5PrmG/QTA/+S4KEbEi8vdF5D+on39LRP5LEfmeiPz7ItLU29v6+ffq17/5BT33P1iU8qmmU8mFdLXF/ub7rN8baLZ5IRMVATsXtaobwe8LNujBTe1N/WzmykgcWe5rg14Vsy/EdSacZopX4tRB+OWwj3FIq5WcpL2D2KlU/YGGfVj5NqFelYPc8CgsGoxG5T6YoKWFCdo0Paxe273oRGU+sCf1c4k1658Ed2Ex15aytzAbzFhHm4e9Cbl53rmBuCnLc9PeTC0lppsG5u3SivoQB0ak5BvhGzuDHK7kn+QwfLJ8EMMr25G38clJRhWNXWTh0CDxSjnxhvUX4HMEBuB/Cfz6rc//LeAvlVJ+FngJ/IV6+18AXtbb/1K9308/jH31zaQbPACkl5fY777H5kd72suEGwtuOlwBizYj3f+/vbOLkS277vpv7X1OVff9mvF4HH+Nk7GRJZQHFCwrJEqETBAITJTkwURGkWJQpJHgBcRDsIWEhMQLPKAYCREsjGQQIQ4fkS0LCMZ2HnFix3biJDhxEod4ZHuYj3vn3u6uOufsvXhYa+99qm/PTN97e+7tvnOW1OqqU6eqdnfVXmet//qv/4Lto8JwTRrVF7vyUijK4uXEzsLzMAn9rWAVhZu2WYODkoVpWZwLooyPKGnffrJPwSpRy3RJG7mqlB19YxUdhpLDB48wwkgdllOdQElbZmCjenWivyWsnwusnous/l9Hd8vXnFo0VHgNlVy159FKogKgYYDOmZFSgFpfk4ztvcH/DrfqGOIsWjgpIqiRRPDPVdrPSXZs8+s0zl7zNRwxiMgTwF8D/o3fF+BHgP/sp3wM+Am//eN+H3/8L/r5D4eVL1Mx/2LkGy8S/vBpLv/Ri/SHuUq7laugJLuabx9TNm+A8cpMvKUzh5D225W/lPYstRC6I6mMyZqL+3c1rbzK0KtXQiytCINFIN2BvYb4Vbbk+YV3UCOI2eMm3mKv39+yKKH0WYCdU8DG3NsGt7Rntnbsah8PPerYetVEW9QTBqlcjP6A+p61IzV5pLIVwiSE5K/l+pPFSVRiWeZkp1A/rxJVJDtvzoI8qb9idgFAZDedeEidApweY/g54GeBq37/9cB1VS2Q0DeBt/rttwJ/AqCqk4jc8POfnb+giDwFPAWwx6W7XP4DtGN1bc0BPThE/u+3uPrCLdKbXsfhW/cZLgemPcvlVzcMxEtrmK5Ad8s2WgEiNSghWwpRvvi6Mlq1JAvtizOxmFprGN5fF2+EauF1d+RXYoFp38hWZfhNcJAzrxWKxH1o+guSnK6dPd2oEQL1yl+u+pYKNb6DyczLbst5coejNCCT1sch2UHImc+dO6vyXqWtPXjZtGIVI5AUScmEX+efE3AigemVpNrmz9WGLd3GoHwtlitF5EeBZ1T1iyLynrN6Y1X9CPARgGvy2Pn/r56k+ad5h/Cm04TempDNlnB0xJXDxzl88hovfrcNorXNbT95heXRjvRbiO/lxCTGF+hsM3UjVQ0qqkcXe1YJ6G5JxSjCiLMFvWegKDpD3UzgqUrXzm1XeK0gX0jmEGSiMRq9cpj27Pjqhjm5MApxgOGapxyKVRRGYDAnNV3y1+wKzkFlYs4Zj3GwcmzY7naA5pWtQaNrQrjDKyMAVzczYUjIZiRP047M+w5ofNvnqru/i835CzvHQ3UK9XUfMqcAp4sYfgj4MRF5L7AHXAM+DDwqIp1HDU8AT/v5TwNvA74pIh3wCPDcma/8Qdh8buXcSWipFgR3FhkOj5BnX+Dyiwf0Nx7nxXfsM1y1jR8H62FI+8K0b5uaNaAWroeBSmIKuaUO1ohFTReKpkKYbNPF0cBOsE1tebmSVo7o+9U3liuwOqI/lX6G1o0ZN9CPVkVJe+JUb6p2ArTNXTd6gvUL9lgqQ7hLZFAIYMk2fymPlmggOqg57fn/wdvSyyQvBn89501UnsgIcaOsr0/Emxt4/rpFDJXCHF7aKbzchKl5s9UOCap95vV1H8KI4RUxBlX9kKo+oapPAu8HPquqPwV8Dnifn/YB4BN++5N+H3/8s6oPyX+tSHlBnV0JIF134lVJb7xIvn6D1R89w6O/d8De85kwqYX1+xZOx00DHAEn/yjdkbK6aZulhP8qVLp1mOa5v4KH/KmHKsk22b89jNBttAKNZUpWd0SjcueGSZTX7I4cgBy0YhsFLwmJyqdIaxgeaRwE8CqL67DmVat+FGxkLl4TJscsyhCbgR08pQCmYXLM5NAdjDvR1U2lf36DHG1bnwQ0fKBc+R1olK6zzzHEihdJ1yMx2o9/nvbALHI4iSBVvhcPmd0Lj+EfAL8oIv8E+BLwUT/+UeDfi8jXgecxZ3LxzfGEeRIsXc/xFEOzIhHIFjkII3rzFt0fZ1538xEO3v4It94SmS5JnUzVHYEOHuJHewfbsJ4O7Atxo3TZsAIooGbrVYiD1hSgOAStKYCF3x2mxhRGanWk0LOlpBpqTsEiEWW4av0PVTPS9SyLUJT1ezgekWD7iG3e4lBMoIaqGlVBx6mlOcUJaAc4DqElvVJ7jzBAo45DmfIlWVlfz0hpbit9EvNN7J+NpRe7qWAtXaoND5IgVtXIpump03gymLnTvv3wgZB35BhU9VeBX/Xbfwh8/wnnbIC/fgZrO582483v3JcAFKRbGvYQAqqK3jpANlsuDyPd0es4fGPP9pqQ+8ZpKKPd8krql16ygYgajMTTbUyhWbIdSz22YdyJSNKaQqAm4Kr+uCYh5BKVUMuU2uEYhNZNGpLW/D2vbCc2R0OrCGTDQCY13CNm78w8tCgj92oTrCZrHqsAItR27OJwJNcsxZ2ckjuhO7D/Q+7aVdpSF6U7hNUNV2zaDruya8eqR7bJ9fbKgoR6zPgK7iAkzJzD8WrFMfLUQ2YL8/GUVrvqROu0a4nsXGks/LQvo6ZkX67slMMQ0HGEb0/s3Tpk9Z1HOXz7NQ7fEM0ZRNvsIUvt1syxfelEWzOV5eWe0niOnlZ2rmSBIVeUvwCGOUoTldESvitpzwRliqJ1HCxSEAcw4yhMl1qfQnanUtKaeATdobIKMF4WxxC0gpZG89ba81HMSrItNZGs1q7u59ZqA958FWmDg2lYx+pWpru5RTYjenC4G+rPnfdO49OxK/wJZcf5Z20LidWJSBCLTB6iKvxxWxzDKU1zA6Q0h5aDRh92Ur5AWXe+aJoy4s1ONbU4OESGgSs3brH+7sc5eMuaaT94B6ZWPKFs0PGyo/D4VVds01bx2JUDcgXB761sWaoddS2lLOgRAvg5OwCi1jSlCNsayKfe9CVVdCUF26zBA6X+QCtjEYEUzYGFSVGPFso6mv6kRT65E7ojrQK1c5Ykod3XWLoyodsq+88OyDAhB0e3D5epV3Lf0HPZ97nTyOmYyGuuvzVxDIgs/7eXoVY/BLY4htPaHMHOqe0r3b167Hz5ADSTh4T09sXTlGAYDeQaRrpbBzz69FWmNz3K0Zv2GK6EnRRBg204Ywt670MujoPam1FKkDlC8FxeQ4tEaj7vaUDMpmpdruxx0IpTxCGDwrRn4q1h0gZQeo7f31JkX2qHaGE2dltl2ms8hTg6ADqo9VKs7XX6A53pUVo0VFOYZA5IPTsrpco5AzJulUvfGeieO0IOjsgvXEfHUrpgd6M6DqDTLL2YOw04eYJ1iRLmaUNOuwHGQxo1LI7hTq2E9oXYNO3WweczB+oXSAQdBua9+5rNSYRVTz48JDz3Ale//To2f+oNDNc6xktiZUagNB6F5P0W3negnafSYwPqAFIvNpnJnUHuW49Fa6l2XGJL01UAV7q2sL4yJUv60nmEMFB1J8LgFQp/v+GKO0hPV0yurVVdUOsb6Q4d9yh/yyT295VGM9erTD1oN6Nvq62t22a6gxHZbNGDQ/LBwak+N/uHpJOP13+CRwDHtSFf6nUfQuewOIa7tNZ6e5qT53nv7hc0b7zenpX0re+wvnXA3rWrbL/nMY4e79EojPtSS41lSK76vIpS4hMvH9aOTmkOpFipPmR3KMYd0MZ6TI0Yldcw7hv+0G3sWFrbfQSyayCUlGbal6bk5O9TwM0waU13+gPXoZwKdkLTe5xKdcVSpqlzyboA3bY5kpCU7la6u015GrWlhywtuBtbHMPdmIgDkKc//0QefjHV2piTnnseuX6D1bPPs3rzdzG85Rqbx/qKLdgV2HLdHEF6oZQks1/llRYZFG5BcRg4g9KARk8f1JyApBIttFC+VAPSZWp0YDwG2+y5k9okVjgJO2zLyUFUsepKt7H3zFEqvbloZFrKos71CLW1u6wV+/OtTJtBJgN1X7WN/Bp2EItjuAvbabs98YRjkcFptAfn3XtZSTdvItst6+0bQR9neLQzjGHeS5Co9XtoGyatZKdHoaQdpcRYcnVrC1dElWmv5N5+RT7M5F5IvW3a1U1zRqNv2JDaHM4SyRRQ8jjgWc4rjqjiB85HCJM7KF8/uQnHgEcsmdlzhLQX0CiEcTpZKv5e7W5H2j0ktjiGuzBNyUqV94JG7xBwjqUahSw1DOjz1+mvXELDZaZLEenKFbiU9ewLXCICu2qrVdZKdaAvBCWvOPjGDqMSN4m8mreTu4MR/+24QneUmS4FK2E6Xbk/sJSmUK7L64NXSrDyqDEWdacnYm65E3TQOllP+zAjVc2A01mElnvDHUjpZOBwsXuyxTHcjdWKw0unBq9oL6U1WH4XRDwIkq1BKAbIq0AQ25CAtT13Ql43haPcGR+g0J+77W5VIkzQbXNNCUr/ReEGhCGjElp3ZCnlj0rcZqb9QFp52TJaWlAwkGlf6A+cRxGtGax2ZibdIUnh2EZ/mGuqoNE6UUNJF7QAp1pxEJO8t05KAMaZPsJZ2p1iSA+RLY7hLu2uwteT2npPwh7mo9C6jrw2sQHxzWU8f6+pZ3MI/aFdTqd1qAQpcJDvmM5h9N4EUedCTJmQAju8Aaxsmfs4AxXNCaWVVEp0YVUWp1TIV6JeosQjFk8bxEua0MDRbpNd3q04SGuMyr2VWnOU6hQKGzQkNYwhvUp05Idws9+JLY7hbuw0ZawTn6cvf/+E43q0IRxuyfudbYrk5TuoV+IC2gE28FZahSBkez0VqbTpMBmuYG3ftmNLtaM7SpAUeho5qYCRnTmeHKXxE6ZGxEorqVf2wma01ON4xaKlTnGT7e9CXcA2NEk39RmdBRPZGGc6d0axJjmTMbwM3rPYXdniGO7G7uPkIZ0mwnZApn10r0M72wSWexc6IDAD80p4rkEa1Thr7Z+QSR2EVGTMSGfRQrnCj1f7Nl3KLa8aPyGOWp1B1bf0smWYpSylZTpsM9pJjThKgxiqdJtkJKySasTi9KSK0NSKxYwmrZ3YtF+10fSLna0t/9G7sfsp6ZUSbAcTIdECODqC78CcdsFUmFxfEixVIJYSn9amLGvWyqRVqHRkaFfx7BtTpox0tjOtREibmF3oylI4ClapKOQja+H2905aS6wyZSS5YxszoXQ6RiFszdGGQezvqToIrTmsrisb70N7mwJGjPcGBC92my2O4W7sfkYMKaFHR8jhlriKzki0Da5RyH2o0ULcZvoX1Ts2y0g3djCCusGytsExcYZBBIEAeR2qA9AgxCEhSUl7kdxLdUDltcD4CGEyLkSVgfPNGrfe+jxOph3RB2TMaB/aa0VLd7KzHgueUFKmgmuUvyHvdQQRiAFZrdDt9uw/gNeoLY7hvJsqutkSDo4Iez2xC+S1zbCUpPS3JqtUDIZ76Mq7O4OlDGGyTaYC3SY5F8KjAtdzKLoPpaOztDeXcmfcZgvzu1D5EeBEK1U0hMq8LBRqtDkemVpkErYZSdmAQ3+snKgi5vgmbQSy4tT8tQzoNHxEY0D3VrDZmGMotPPF7tkWx3A39nKpxEtNTr4Hy8OIHB4hl/aQSyvbOCk7tmBhuOX06ukEiDdCVYl5VWTItuHWsVYeKLhDUsJoQOBErBuy3AhJSVFtrmRy8FIbJlBYk7kP1SmI6ylM1yJxo/Q3hpqyhMG4B9rHmlJoF0h73U4EU9Wms1LnRVSHlmHVY52TYUfncbF7s8UxnLFJjMhqRT48PLsXzYl8eEi8tSb2HVxZt3blONtYIoQxoxN+dW9djmHIthlD8DDeNvecOVlnNWirXBZcwghHSrCBlw5OirEPJ63rKelKmGaYgvd1pP2O6FhCAR9lysholZBCD0l7HSIZulDTlDBmCvVbZs5MO1fWKm3xi52JLY7hjE2nV4eiq8OAbrbIZiB0AYLzFQpOIICnDERpkULKVpYcDSPQnCtISG6RQu6lbrq4TagYr0AxZwPubMRKoBX8lOBAolbadneULIpJGU3mKHIfqhOSlA1DSJiIjcu+MyohWKokWVC1KKGmEWOuzgT8uSJI35MPj+4vKPyQ2+IY7sZeKY89wzRi/p663SLjZFfY0IhRuuqMIZmyMSYd8dc+2iYszVUOXIoLp1h4nneqHKhf8bOCdGjJ/0vKoNhmTaW3oW3UuFHGy+KRS3IeRIZhIoZA7tyZjQmNARmm5hTy7H2SImL9EyVKIJf3zYg7KnGnQt8hIpy9O37t2uIYLpDlzRbZbE30pbAhx9K27ZWIEq0EsSghq2s6GLWaehX287xyYHoLTbhFo6cJvgkz1PJkcQZS+BNRSGtjSPYHxllApIKMMtn7BjCg8niPCFhZNkZkTIQYYDKHpiWdKE7BmY7mTPy5Il6yXFKJs7LFMVwk0wzbLeytjdzTm7CCjAmyoDESJJNXEUVMfnIsOX1TIQpjInnjlDkLxxKESkTSYGmJMSYzMSvMWhIK2BlKGXKw9GC82jenMjh+AMZSzBkpMxqyAYcq0noeAHXJPJkcY9hO9b3qcY9qUGc/JteWm0n6L3ZvtjiGi2Sq6DAg04RsBc25OYdZ56KUDVzTCwMA89po1ZS0AeqVHYkNcUwWZYQCUA626bSzCkjugqUoDkha05cAgf7mSF5FAxDH5OmCOQUAuojGaA4pZyQUB6WQJ8IQyd3KjpXXntO3S1oxJXtNVRhGGzLzUoNlFrtjWxzDBbM8jMgwIKGU5zyVoBGYtCuVgHYFzSvb+DJOtilpVQUpdOlCflJgUkIuIKF1W8pg0Yk438CGyYZKuw5jgo0SNxNpz4e6pGN9JVMyXHTVoe4UwmYmezdOyBAMHxl3N7qMaSdKqNOtgdtk4Re7J1scw0WznKw60fe2iXKZshTQvrOr8OQgnkS0DzXEDsPUwvaCM2SQnCDZV6HiB2NG15EcokULQQhDEcSlRhqKO4nig2ZpvjmHS6bifDS4o0i27qKeHdp0L1Ky9anC5b2WZhQsQbVGCjKlBr7W6kSHDnfZ4LbYji2O4QKabrfo3try9eybKwQPpaPJoWfvdMzBAD8MT9A+IttEmDK5C9AF62BMDu7NrsK1jyIpgVn1IqtFHp7v67o3XCOIazlgfAVVpisrZB3pSpmxbOqUYVBzZiFYlaJs8JRhO0Ifd9OJglNkdxDFAcxTiPtIV3+YbXEMF9DUr7radZajq5cdVaqAi42qz0gOFvoHD8+nbA5iyojzHmRSpNNKJjKU3/P+qYGbpYIRjsbatFS5ET7gtnR/5lV00hHWAJYMCyggqMbQoo5CWooR7bwhKgR/X21pxjxSUK2VjCVCOHtbHMNFNFXydktY9bNowVF59Q03JT81Gm0Yz+VLua8LKNHbrzNMs2qBWzgaSZdWtiEJdUNKss5GQrDuzt7AxriZvGfCS6UKbKi8A/oOnQtChtCUqAK3bfCCQ0hxfBvnX0xluESs0YL0PlhYBJ38NbO+OpyS14AtjuGCmo6TofExzhTivVrQeafTZK3aJB/6Wjehb1xnQxZhFnJumgjZW5xnz6sVAWzz51VHXkdrugpCGAOQrbmpa3gF7jyYxNKfkhbEmUReOe7lTJN4sygnBwM6w7q3NframRKyGVxJysucMcI0VSxDYXEOd2GLY7iolpOVLmNEV30lMe3oRpa5md6aXKsXhMYSrHm6VlaijJBXJgozz/FtbJ2QL62YLhtfITuZCXXac5hVQyZr2kIDKvb66qF/SW8IVOak9rE5L6d923GLLFJRsZqyYRhTJqx65GhrIOVkE8IkCDrQqi/+/1rs9LY4hgtsmrJvCGl4wyxKKJ2GdpWOTV6pnLdNtjFzrsxJALaDqTolNR5CtjKn7q+YrqwMaCyt2QWMVCVskzmTKTfdh9SATGG24YNhBTqvSjBjRmZs3mWw6CWvxfstAA2kvWgaD0eCeOrCOJm4jFPD1XkOQkQXx3BHtjiGC2w6DuQgrUJYqMHTbBOkhIq3Qodgj3sjFV2ZLdc6HS2dyJUxiXpIH3vSfm/lTzAFpWij4uJmqrgCo5BnrdS5M8GXOWNRya46pdb4FUJNYbL3fbTeiVCZlAXmsDU1kRrpI2GYCEfineaTlUIdg1B0N5pa7BVtcQwX3HScDGcIgoa4m1IURF9Nxsk2DS2tKDTpsgn7iGxzYxQ64UhXe9axiVcwNEMU5MDl2QofIilobo4qKUFbO3ZJFYqKdG0EC4Ec3QmsrNnKyFNCGNWqGqtAFiGvZupRAcZLHV1IjatR8Iuua6xQRtBFq+FObHEMF90ca0AEkYCGfoYz5CZuEotmgTZ15YI/1I5H/ByxqKNrOT+u3aDqG7UwJaNUSraKD+FNWolVRXCWLljk4RtYwWnYru4kRSreIwTv1UjrJitv7eGRaU/qYBs6ix7iNhMLRTtlW8c2IjItXZd3YYtjeAhMp8mUklOCNJvlOJ8nkbJdoWNoJb5KbdaWQvQdqv0MrFRvtBIISkyptUsXBaewK/kmHq1omIXvUwYJNuAm2vtqYCZFJxWrMDallz3dcZS+jDhkwlRATyyy6AzglElJ+z2xpERdRKfoKUVe0ok7sFM5BhH5BnATSMCkqu8WkceAjwNPAt8AflJVXxARAT4MvBc4BP6mqv7G2S99sbnlYcQHSTnpJ7c25HI7q4XTMdaGpHk/YulsxKnVjJOds8FC9aLTmPOs3Cg1EpAys6aIr5R0JOL4Qq4AqInFhBoZ4CVJk78v+hGmQVnk5u14E5tNe+LzONUmfQfIe5EwRGR0sDXITNN+YUWe1u6kgf0vqOr3qeq7/f4Hgc+o6juBz/h9gL8KvNN/ngL+1VktdrGXsZzQlI0VWSwl+8mW+6PZavzTZA5iVs5Un9HAZHL1sh2RYUSmZL+Ptsh2QLZGktK+MwLSujfH4OpO9YocBe0j2gWbZuV9Ebkz+nOJVMKUfaqUElKur1Ebu5hVNiI10rDj7gy8bGoK1sHJV2KpUIiISNWEXOx0di/KFj8OfMxvfwz4idnxf6dm/xt4VETefA/vs9gpTYsjSO4kSs9DASLnP16pMPai4wTFCaQMw2jnlQpHSUtWPbrubPhNlEo4CkcTYTtV0FK9smCS8nlHUwFoMm+Tuh6lT8AKs7KplhF7NGzCZ2nWtCM2R5HWjk3EUJmZ1ZZpVXdkp/1vKfA/ReSLIvKUH3ujqn7Lb38beKPffivwJ7PnftOP7ZiIPCUiXxCRL4ws8wDOxErUMIsG9HhOHQS6zur9+3vWvFSUkYbR0ofphHBbxPCH/hgfApBtqupQ5eoOhnM2DQVLQ8JkTsA6J5sgjEnReUoy5Yox2OMOPk4N5CzzLeM2OwaBOZBoreB5r/eeCy/hLnZHdlrw8YdV9WkR+S7g0yLyf+YPqqqKiL7Ec080Vf0I8BGAa/LYggidkWlKVsOvB8oV3CTW6TpkvUL317uVCbDQu/RcIJWeXFINDcH1GbRVMkIwOXpois/Z+xiCz56YryOWTU4DGGcTsahRgG1+jWU2p51fwEgKJJFpz1eqxkReRevcBK/OLEKxd2KnihhU9Wn//Qzwy8D3A98pKYL/fsZPfxp42+zpT/ixxe6H5YR6WbFGDuUKHyOyv29DWvqubfoSphe5uDkbUdXwgTijL5fIQASKYrU7i3J1l5QanRoMjByNbVkdCOzI05dJVvgA3jhkG3WnNFwh4/MvqPM146gEj1TSakapjsGqNWJr1EXh6dT2io5BRC6LyNVyG/jLwFeBTwIf8NM+AHzCb38S+Gkx+wHgxizlWOw+mI6TaysG8jDCOBr41ve28aGRm9wJaG+EoNIOXXUSZm3Q1UrZr/RWbMd2RS7lyz6S9zryuqvHq/CKPzcMyXAJf7wN3c0VCwlJ2SEiqO4M1ymSdmWEXe5aVKJdcMdY+jmWqOG0dppU4o3AL1sVkg74BVX9HyLy68AvicjPAH8M/KSf/9+wUuXXsXLl3zrzVS/28pYTmqxkKUGQ1Qr6FaxdSzErSrLN7vwFjYqM2mY1FN0D71qsalGu3EymXVaKJsScN1HFVxxPyLk2NZGBzoHL7KM31YRetA+QMKJT53oRHhmUQTZltkUBIVErlYYyam+azZ4oAjY6i14We0WT28CpB7EIkZvA1x70Ok5pjwPPPuhFnMIuyjrh4qz1oqwTTl7r96jqG07z5PPCfPzajB9xrk1EvnAR1npR1gkXZ60XZZ1w72tdiruLLbbYbbY4hsUWW+w2Oy+O4SMPegF3YBdlrRdlnXBx1npR1gn3uNZzAT4utthi58vOS8Sw2GKLnSN74I5BRP6KiHxNRL4uIh985We8qmv5tyLyjIh8dXbsMRH5tIj8vv9+nR8XEfkXvu7fFJF33ee1vk1EPicivyMivy0if/c8rldE9kTk10TkK77Of+zH3y4in/f1fFxEVn587fe/7o8/eT/WOVtvFJEvicinzvk6vyEivyUiXxaRL/ixs/vsK332Afxgnfp/ALwDWAFfAb73Aa7nzwPvAr46O/bPgA/67Q8C/9Rvvxf475gEwg8An7/Pa30z8C6/fRX4PeB7z9t6/f2u+O0e+Ly//y8B7/fjPw/8bb/9d4Cf99vvBz5+n/+vfx/4BeBTfv+8rvMbwOPHjp3ZZ3/f/pCX+ON+EPiV2f0PAR96wGt68phj+BrwZr/9ZoxzAfCvgb9x0nkPaN2fAP7SeV4vcAn4DeDPYeSb7vj3APgV4Af9dufnyX1a3xOYtsiPAJ/yjXTu1unveZJjOLPP/kGnEqdq0X7Adk/t5ffDPIz9s9jV+Nyt18PzL2ONdp/GosTrqlqUG+drqev0x28Ar78f6wR+DvhZ2hjd15/TdcKrIIUwt/PCfLwQpnrn7eWvtonIFeC/AH9PVV+U+YyGc7JeVU3A94nIo1h37p9+sCu63UTkR4FnVPWLIvKeB7yc09iZSyHM7UFHDBehRfvctpeLSI85hf+gqv/VD5/b9arqdeBzWEj+qIiUC9N8LXWd/vgjwHP3YXk/BPyYmL7pL2LpxIfP4TqBV18K4UE7hl8H3unI7woDcT75gNd03M5le7lYaPBR4HdV9Z+f1/WKyBs8UkBE9jEc5HcxB/G+l1hnWf/7gM+qJ8avpqnqh1T1CVV9EvseflZVf+q8rRPukxTC/QJLXgZEeS+GqP8B8A8f8Fr+I/AtYMTysJ/B8sbPAL8P/C/gMT9XgH/p6/4t4N33ea0/jOWZvwl82X/ee97WC/wZ4Eu+zq8C/8iPvwP4Naw9/z8Baz++5/e/7o+/4wF8D95Dq0qcu3X6mr7iP79d9s1ZfvYL83GxxRa7zR50KrHYYoudQ1scw2KLLXabLY5hscUWu80Wx7DYYovdZotjWGyxxW6zxTEstthit9niGBZbbLHbbHEMiy222G32/wFx2a0Ve3B3gAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -224,7 +224,7 @@ } ], "source": [ - "scaled = cle.scale(input_image, factor_x=0.5, factor_y=2)\n", + "scaled = cle.scale(input_image, factor_x=2, factor_y=2)\n", "cle.imshow(scaled)" ] }, @@ -356,7 +356,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -399,7 +399,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 13, @@ -438,7 +438,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -465,6 +465,190 @@ "cle.imshow(transformed_image)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Interoperability with scipy\n", + "Affine transforms in scipy are applied in a similar way. Thus, APIs are similar. Let's start with translation, which is called `shift()` in scipy. The `shift` parameter takes the translation vector in `[z, y, x]`:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "import scipy" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cle.imshow(scipy.ndimage.shift(np_array, shift=[0, 0, 80]))\n", + "cle.imshow( cle.shift(np_array, shift=[0, 0, 80]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Analogously, the rotate function can be used. The provided dimensions in the axes array are 0=z, 1=y, 2=x:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQ8AAAD8CAYAAABpXiE9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAACQ4UlEQVR4nOz9WYyseZreh/3+27fFkuvZ6lRVV3V39UwvM+QsHJIwDUugZUi2DFo3BHkjwiA8vpDgG1+Y9o18YQG+sGHAMCBgDBOiDEgybUAgbRMSJWIEWhQ15HDEmZ7hzHRXd+1nzTW2b/lvvni/iDyn19Onp6Zr+sQDJDIzMjIyMuL73u9dnvd5VM6ZPfbYY48fFfon/QT22GOPP5nYB4899tjjpbAPHnvsscdLYR889thjj5fCPnjsscceL4V98Nhjjz1eCp9a8FBK/atKqT9USr2rlPobn9bf2WOPPX4yUJ8Gz0MpZYBvAP8K8DHwT4G/mnP+F3/kf2yPPfb4ieDTyjx+BXg35/ztnPMA/MfAX/qU/tYee+zxE4D9lB73PvDRM99/DPzZ73fnQpW5YvIpPZU99tjjZdGxZsi9+l4/+7SCxw+FUupXgV8FqGj4s+ov/qSeyh577PF98Bv5H3zfn31aZcsnwBvPfP/6eNsOOedfyzn/cs75lx3lp/Q09thjj08Ln1bw+KfAO0qpt5VSBfBXgL/7Kf2tPfbY4yeAT6VsyTkHpdS/DfxngAH+Zs759z6Nv7XHHnv8ZPCp9Txyzn8P+Huf1uPvscceP1nsGaZ77LHHS2EfPPbYY4+Xwj547LHHHi+FffDYY489Xgr74LHHHnu8FPbBY4899ngp7IPHHnvs8VLYB4899tjjpbAPHnvsscdLYR889thjj5fCPnjsscceL4V98Nhjjz1eCvvgsccee7wU9sFjjz32eCnsg8cee+zxUtgHjz322OOlsA8ee+yxx0thHzz22GOPl8I+eOyxxx4vhX3w2GOPPV4K++Cxxx57vBT2wWOPPfZ4KeyDxx577PFS2AePPfbY46WwDx577LHHS2EfPPbYY4+Xwj547LHHHi+FffDYY489Xgr74LHHHnu8FPbBY4899ngp7IPHHnvs8VLYB4899tjjpbAPHnvsscdLYR889thjj5eC/XF+WSn1PrAEIhByzr+slDoG/h/AW8D7wF/OOV/+eE9zjz32+KzhjyLz+Jdzzn865/zL4/d/A/gHOed3gH8wfr/HHnv8lOHTKFv+EvC3xq//FvA/+RT+xh577PETxo8bPDLw95VS/0wp9avjbXdyzg/Hrx8Bd77XLyqlflUp9ZtKqd/09D/m09hjjz3+uPFj9TyAv5Bz/kQpdRv4z5VSf/DsD3POWSmVv9cv5px/Dfg1gLk6/p732WOPPT67+LEyj5zzJ+PnJ8B/AvwK8FgpdQ9g/Pzkx32Se+yxx2cPLx08lFITpdRs+zXwPwB+F/i7wF8b7/bXgL/z4z7JPfbY47OHH6dsuQP8J0qp7eP8hznn/1Qp9U+Bv62U+uvAB8Bf/vGf5h577PFZw0sHj5zzt4E/9T1uPwf+4o/zpPbYY4/PPvYM0z322OOlsA8eLwopz/bYY48R++Dxosj7afIeezyLffDYY489Xgr74LHHHnu8FPbBY4899ngp7IPHHnvs8VLYB4899tjjpbAPHnvsscdLYR889thjj5fCPnj8NGFPZNvjjxH74PHThD2RbY8/RuyDxx577PFS+HGVxPbY43vjO0uonJ+/bZsl/ail1j67+sxgHzz+JEGpz8bJsz3hlUbp7zj5lQatID3zPLVCGQPGoKwFa1FGg3Py85zBmt1jZ2fBWRg8KkQYPHm9Jg+ePAzklCHFT///3OMHYh88/iThjzNwKCXBwchJrZyVk99oOfmthaokNxXZGXJhSU6TjUaFBFqRFWSryVoRGkM2Nw+frCI5uQ9A1qAS7BRvx886ZlQC0ybc0uMuW9T1irxakdqO7MM+kPyEsA8ee4CSzECVJaooUGUBdUV2llw4sjPEyhJrSyw1qVQkqwilBACAZCGW8rWKN0EuG0UqIBaAgqwkQMQSssmooCRgjIEjm/E+CchgPJgOTK8xncUMFbY7pFgE3EWHvV6TrxfkrpfMJEbIafzjn4Es7acY++DxKuGZ/oKyDl1XqNmUPKlJkwp/WBIaQyz1LjBkDclBMpAKRbKQLYQaYplJDtBZTnotJ212GWyGqFBVRLtECmNg0RlXBlLUWBdRKmPM+HtZoVUmJk1hA93gCFnRekNsLXppcQtFdaaxrcbedbjNFLc+xa48ug2YIYAPqH4gL1bktiX1o7XHPpj8kWIfPH7a8WzAMAZ9eAC3TwgHNf1BgZ9qQqWITjHMFf1JhqyIdSY2iWyzlBA2o6tACnp8rIxSGaUh9gYSHN1eYnSmsIHCRM7XDTFqTqYbjE7EpBmiwUdNzorX5gu0ylx1NT7J45YmkrJi1RdonSms52ASmdweANAq82Q5ZdE50scN1VODWxmKpUP7LNmLAh0ytsvoIVE+adEfPSKeX8gLsQ8ifyTYB48/JihrySH8Mf7B8UpvHfpgRr57i+HOhO7E4WtFqCFMFP1hZrgdaE43DL0jA0UhQcIpKEtPaSOXi4YcFaZIlNVAYSPd4EhJkRPcOllyUHZ8dHnI1dCgVObt2+fU1vPB1RGzSq7+h1WLVpnLruYbj24RBkvuDaYJFKXH2sg23A2DwXvDRmV8rSlspDSRX7z7MTErutcdi6Hi3Ue3SE8rqicatwY9gErSKwGDveOo7k+Yfr0hfPQA8r5H8keBffD4Y8IfS+DYNjmdRc/n5Dsn+FsNm9sF3ZEiVor+CPrbATUJTGYdBZDags1lLZdsk2lXTrINlxlWBcukwCaKxmNM4mgiAUDrxKwcqKxHq0wbHG8eX/J0PeHibMZ7T48BsDbRDY66HDhbThgGS9xY3HRA20Q17fHe0K0LZgctTTlwva6ZNj0haRQwBMu6LQGorGdedFTGc51r7hwvOHrtMX20nK8bLp/OcE8cbqEwA9JzKQ2huc/BpCZ96wNyv3cp/HGxDx6fRfyoI9kxaOiqRJ8c418/oT0tWd0z9McKP834w4Q96Zg0PbkrCINhdTaR309gpkH6jApUyS4LKG2kDwY79jOUytKXyIraBZTKxKzxSdF6R0ya5boCr5mddlQuoIBp0ROzRk8ya1/wSX9EOKs5eeuSwgZWXYkxibYt6AeL1hkfDZNSypU4ljXORK77iou2obKBciyR5q6jrjxvTi5pTxxP35ryaDFjed5QfVTglopkIP7CMYdNgf7DD0ir1b6E+TGwDx5/krENGoVDv3aX4f4R69dK1q9pNncz4cTTHLUcVAOLdcWwKbi6LtGdJlUJbAKTUUZOIFtErI1Yk9AqU7pA7Twh1uSsaMoBBaSsSFkxL3raIAHj0cUcv3bMTtc4F5neXVDYyKYvcDbS2IEuOi67mlVXQi9z23VXUEwDhb0pJYbBUpaeYbBMyoHKBlJWxKQoXWBe9ISssSpx2clz60pLFy1T13O/vuKd6RMeTA95eDTn24cnrD+cUj3VoODiqzPm03co/vm3iFfXP4l37qcC++DxWcSWjfmDropKoazDnB7j377D5ds13Ylm+fmEe23J6WzDpi8wOnF+OSX1Bno5eVITQWd0GclJyQSkCFSFR+uEMwmlMvOiJ6HQY9YB0AdLHwzORAZrGKIhJo1fO1RvMCpTlp5p2bMeJHBUNrD0Fauh4Pxqir8sUV6TZ4HgDQ+fHOLKgHMSQLTK+MGSkmbdFwzBUBeeaTngk2ZIhokbaOxAbT0XXcMmFPTRsvQVpY6sY8mh23BcrLlTLfnD6W0++egE3nMkB1dfLDmKn8f+83dJy+Wn/Y7+VGIfPD5r2E5Hfkg6resa9dbrLN85pD02XP0sqDfX3Dtasu4Lrtc1wRtQmTQYlE1knSEpiArbSMmBytSV9CysSRiddtOQBdANjvWmJEZNUQacC+SR2XXdVrR9QXdeo+rA5GTDYlGTOsvlxFMUAWsjMSk+eXpIGgx0GtNq4kGgnPboZwLXciXPuaw9KSm0isTxueSscDbSe4tRmWA0590EHw13Jws2oeCjyylvHF3RJ0Mbhb06sx33qmuOb6/5Zr3mvVvHtF8/pDpTXL1Tcdy/hf6db5K67tN8V38qsQ8enzW8QA2uZzP4whssvjhjc0tz9ed66mlPU3rOlxOG3u4SF6VAF5EcFdoljI3ksX+w5VmEqIlRk5KwuFJWKGClE1pn0oMadbenLgeWq5qi9LR9gVIZ7w1qfOy2LchJgc7E64JWFZiloVgonMvEAlKZicce7RJ+7G1YJ5MbAG0y3XWJm3iqeiAlzazuuFo1bLqC+aTD6sT5ZkKIGmcjTzYzNt4xqQY+vDiCY5gXHVdDTcyKu+UCgFvViuntnt/6siH8szmguPrZKSdX9+Hd9/dM1R8R++DxJwyqLOHt+1x+dc7qdc3wCys+d3LN4+sZl9cTkteYIuKKQEqKGAwpalwlxKyctDC/s2IYLClocm+E0BUV2SX5OilykVAuQZFRT0uuopKTuy3Gv5PICXKR0DoRgyF38lh2ZbArBRqGg0SqM9kmdBNQSZE2FnQmmUwMmhy0/F2X0GXEtw6/cRTTgfNhQkqasvQs1hXLTUnwFmMj06ajcQOvT6+4GmrghmyWUDxsD1iHknvVNU5LcHjr5II//Iqj+GYNSnH5S7c4XqwIj5/sG6g/AvbB408QlCvQX3yLqy8fcv1FjfuFS07KgU/OD0hJEwc5oZXKaJ3pO0dZeYxVpKTGzEIeK60dKiqUV6BAe1BREWYZXEbVnum0QwFLXcOZZBrWBYbOYQrpg6RWgkD0huQNujUor7AbCRzdnYCqowQVjfReBg0aVBUhKQkcnUZlBYMm6cyW7DFcVFAmpkcblMq06xJtMsZGjmZCPvv4+oA0VxQm4kxk5QsOynbXB2nswMUw4dBtWIUpb00vSPcV34h3Ue+WtEmz/sU3af6rlrhY/GTe3D+B2AePzyq+s2GqDfqLn+P6q0dcvSOB47hpWfYFzkXatcWWkQxok4gj/dsPlhSVnLReS4nRKUxWZJNF0cXKVTo3EdVEWXJ1UTKTpHBlYJhrWDn6oDFlxLlIDJo0jE1YQPUGu1Ror/CzTJxEcIn8DE09tgaVFdmkXSBTJpG1hggEhUJKn1xHCBqCYr2smMw6JrOOuvD4YGgHx+l0jWsSXXD00aKAkDSLoaKPVpq2OjIYQ0JhVOZiaLA68c4bj/nm+j6mN1y/7SiuP4/+zd/fc0BeEHsxoM8qng0cSmHfeoPVzxyxfF1jf/mSO7MVPmlCFBamton5bENZSqMyZ/C9lRN87WDQ6E5KA4B45EkHgdREchWlXKkSyiSUghgMvrfSA4ka2wTQGXNWEHtDSgq/LNC9Qg0KtbbYhQSS0GTiNEKZUFamOs28w7ogEx6bIEFOijw+HxIQFDqADkhg8XJ46loIdutlRc6KTV/sxsUpKyrrMToxROGjpKyIWRqtzkQWfUXIBk1GkwlJU2jhiJy+dUF3KxNquPhyDV/74l7O8QWxDx6fdSiFOTlm884p69uG4c8tefPwChC+RQaMkfFoSppJJU1GrTPGJvJ6TC41pHkgTwLp1oCuIspkdBPQRQQNppJJyu6EVtI/MCMHQ5WJeORRJsuIt5NMxrQK20r5E+tMKsayIyqUSVT1QF14QAIGJqOC3nE9stfoXqO9rOaTYberrzOps5AU2iY2yxKtExkhrLVeMo6Y9C6YNM5zUq23/wJ9sFx1Nde+QqvMJhRolemD5bXpguqda2IJw4Hi4ufmmK986dN+V38qsA8enwZe5sqlze5DleVzuynx86+xfN1x8ecHvnL3EYUOLPuSVVdKryNoQjD4aKhsoCkHjqcbclaoOkIZUU3ATQYOb62YHrRU9YAuIkrfZDhx5dAmUx90pChBQxtphIbOys58UuSVxV+VmE4TpnF3wiebSS6TmpF8VkXSYGhXJYt1JQ3bOPY7DgYoozBae4PpFG6l0YNs8jI+LzXokciWZOSsM+2mRAGHdUdhIlebmotNTe8tMSuUynzr8hSA2nlq55kWPUOyPO2mQq1XmYOyJaH4hbsfE762JpbQHyiufu4Ie/+1fQbyQ7APHp8GXqZjn0SHQmklAjc5o8oS/c5bXP3slMU78DOfe0TIhsebGVermr63hKBxRcB3lluzFa9Pr5iVPVYnvvTaYylDTKaoPFXlKV3gZLJh3nQ0TY+1EVcGmltr6uOWFJTwQwCyImeIg0xQ8mDAJZTXlE8sscxgMraTVf3YJHKZUHXATrzwSEB6IlETeks975gcthgrmQ+dxqy0BB0jy2zZZnIlASjbjLIJMxLIclbEweCDoQuWLkhmZZ8hssWkMToxLXqMEu5KGjOZhKKxA1pJ+TJEQxcd/73Pv8vmc55YweaWZvO11zAH85c/Bl4B/NDgoZT6m0qpJ0qp333mtmOl1H+ulPrm+PlovF0ppf7PSql3lVK/o5T6xU/zyf/UIWcRswH0ZIL+4ltc/OIx5z8H9c9ecdXVfHB5xNn1lH5V4hcysgzBUDae2npmruMv3PoWf+b0A96YXEppYhN16ZlVPYdVS6Ejd5oVbx5eMWt6nIs0pSy9lY2UP2SIQT+j3iPlBiMzNNuMaRVmYYlVFg0Pk7Ezz+ygxbpI1Uh2kztD6A2miGidiVEe17qIORxIRSZVogkiIkAKvTaoTkvjNGj8WjgkOWhyaxgGS4gaHwxV4ceAkXeBY7vv8rnpBVYnrE4UOmCVvL6XXUNlApUJdNHhdOTnfvYj2nuJ0MD124781n2UK35wBrLNGF9BvEjm8e8D/+p33PY3gH+Qc34H+Afj9wD/GvDO+PGrwL/3R/M0PyP4ozpIlHpGB1R9x+0ae/uU8Itf4uzPHHP+84rjr5xRF57N4Oh6h++sUM0zaBM5PVjxM7efkLLCqcSbxTmNGRiSZTbp+NztC+4fXHOnWTIvOmZFx1fmD/ny/BF/+tYn/MzpE/pg6HvL68dXNJMObTOpN/i1k1FqGVHjhERpEQEyvaiAJSvBQ9WRsvJyUnvD5rqWMsWIyIZSmaG39OsCf10KH0MnuNXDzEsQMmDX4/gmKwjj1yONHpWFg5KUZA7BkLPsvAAMQSjzWmUu+oaP1kekrDhvG65HHsgb9SUh691HoQNPuikn5ZrDL1wwHGbCRHH51bnon6jvc5psj4ecvvfPf8rxQ0e1Oed/qJR66ztu/kvAvzR+/beA/xL4X423/wc55wz8N0qpQ6XUvZzzwz+yZ/yTxA87SF5kG3YMEM891ra/YQzm9ddYf/UO69uWi5/P3P3yExrnebycyhjSG2mCKqBI5KQpTORXjt7nOtYYEstUcT5M+bnpJ5wWK+6Xl3x9+ToAtfFcDA1Hbk2fHI0ZmNieD66PCdZwUq1ZDYWszS8dZq0xr2/ISQlV3GZYW5LL2LU0S8Mki6RgUnRtQVw4kRdEVMVUr1EJ4rXdrforICwd7qDH2IitEm1n0N6Sy0yaROnX9EYCRzmWOUlGzCpDjBpjEsu2lL0cxRhQLNN6g08GqxJ9sHSDYwiG89zwZDOTHki0hKQJSsa47y8n3JqsuTg+oLx0tLc0/iuvo//h2fd8f3XhblTKXkG8LM/jzjMB4RFwZ/z6PvDRM/f7eLztpyR4fI/A8OwB9SK9jpxFjEYbRLjz5qpm7t1l9bW7LN60LL6UuPWlMwozTjqAtnOkhcNsRjWvgwFXBAodaUzP68U5j8MB/+TqbT5eHfIrn/sWrxfnfDCccjnUPN7MSFnxufkl725uUxtPGx1OJd6YX/JAH2BV4qDsOL+eoOpAqiF7QxoMtgpkm1DeYjq10yDVXqGuDCoZzKBwSNKQdSZbMK1iOBpVyTTkOqI2Bntt8WNPI6WEqiLhGMluBo1aG/IkSu8lyTRH6UwuEkUVsEamLilpUtIMSeOM7NIkFBM3YFVk4npSremi5V6z4J8/vs/EDbstXIBNKKitZ+ML3njrjI+7OzQPNJdfqrj923Pi9eK73t/U9680I/XHJonlnLPadcZeHEqpX0VKGyqaH/dp/OTxo2pw5JvAobRCnxyz/to9Fp+zXH858vo7T7g7WXBUbPj1b79DGCwsHG6hyQZinZg2Pa8fXPOl+RMMmY+HE761uUVC8YWDM357/Sb3yysqFXhn9pQ3J5esQ8nlUPO0m3KrWnE5NBwVGwoTeXN+ySY4Hi7maJ1H7VFNWkomEQAGjenHBmmZsS0ymk2SaYRGspBkpX+he0VopD/ij6TsKR44TD9OVXBkBfFUhIGyyegrS7aZVCXUuAmclZYspogUk4EYFaZMGJ2xOrHaiFCQH0uJIVgKG/j80blQ1XNGJ8P1UPFztx/wjcvbTIqBlS/Z+ILTekXIsi18q1px/npDenrAMFN0v/IO7r/4b/cKZN+Blw0ej7fliFLqHvBkvP0T4I1n7vf6eNt3Ief8a8CvAczV8Wc/fH+nYdE2WDybdTwbQL7fduy2bEGCBqOu6PCV17n+vGPxTuLgjWtem17zC/OP+PuPv0yKhryxVE+M8ChcRkVhXdqjS0odeL874XE/Z2J7js0GqyJHbsMyVvhsOLZrrkNNUwzcKRdU2vOgP6Qyns9VF/SlZWo6fLKclBt+68l9rq4mZK+lfFhbCAqz1riVorsbMStNLOW5xCoRbUbPPfpBhfGyBAdjbySCeSRlS7YZPxE+SLYZs9GUH5YMhwl3u8X3GrswYseQIRwEcBlXe3zrGLxmctDRe0vOirocMKOmqrNx1zQNSbMJxY44tvEFq6HkrJ1idaI0YXffJ5sZtfNoMgtf8drhgvcOZ5hOs77rOJlOvpu6/gpnHfDyo9q/C/y18eu/BvydZ27/N8epy58Drn9q+h1K3wSLZ4OENs8HCqV+eGN17Heo0f8kvn2X8y9XLN9OFPfX3D+45muzB3x9eZ8PHp+Qn5TYa0O2GT0oiiuN7iWNn7uOZaj41uoWKSumpudOseBuscCpyNNhhs+G61CzSQWnboVRiSfDjJgVX2jOMCqhyWxiyR13zVenn/DO8Zms3kclJLLtRTdJxqBbJSNVO5YoRWZyd33zcqUxaCQJIv1Jws+SBL+xZeOWmvLcoKPcx24U/qqUCct4ZGaTUYPGXFj8ZSnEMy2Bou8dMQrL1tqtkFGkLmSydDLZsOgrztuGPlo23pGyorRhLG80SmVKE7A6sexLlMqctw2lCaRTL4zZGrh7a8/7+A780MxDKfUfIc3RU6XUx8C/A/zvgb+tlPrrwAfAXx7v/veA/yHwLrAB/qefwnP+yWL0ONmOVOU2LSmtunFGE67GM01RbUYuR94FlxwT+o3XOPtTE1ZvZbjX8/rxFf/9W7+Pz4bffvwa6bwQuvg0ERswrUZFiLMEQfP1J/cobMToxK/c/oDbxY2wjVORUnuO7ZpGD3TZolWi0QPRavpk8Vmo5jFrFqHCqETMcsXWJhNdwphELOQkTmUit8IsjdPx/0uAS7TrQtigRcYON4ZOKm4/ns3eILmRCJble9MrYivlSTwIqF5jlxoVFMlldK/JMZOjoi/l0J3UonNa2ICPhpQ0ReGZuGHX9+ijRZNlrDuqkhXjhm1jZSo1LXouNjW18xiV6aNlctCSbEmyinj4U1Ba/xHjRaYtf/X7/Ogvfo/7ZuDf+nGf1GcW2kBO5JRR1kkASfFm9DqWI9n/ELHjnMQGoa5Yfu0Wm7uKcDxwPF/z5uSSzxdP+P9e/ilhUga5wqtBkU8G1Gkk9BZbCd17sylJ9YAzkdp4Si23X4eGA7fh8/VTnIocmjUXYcpjf8AqljRGiFJtdPTJUZuBZZAdkJgVF20DSvoeMRhuvXHJ0weH6JW4MmWTcFdaJi0uozpD8ho7H6hO16weT1GD6INI2SIN1mxBDxJEdACVZBTr54lYZbRXmJWivy2LcalXIwdEgocKshnsVwXKjkSvwRKNlsRAp91kZVYOzFzH2hfy93QS1fVe+iMHVceQLH20OB3p2oIHvaMqPYdVy1HT8rg5oFgoUmnR24sE/Og9rp9C7LdqXxBbT9Ycx6+1ku1QzK75qbR6LiNRxtz4qqZnDjp5QMLX3mbxpqG/FTF15LhpqY3nP736eb5xfVtW7KOk/tzruXW05LRZc9nVbPoCO5olbXpHWckV1ZC5jjV9snw8HPNmeU7Kisf+kJlpaUyPH30fl6ECoI2OK19z1k127MvbzZLLdc3mskYViXZwKJcwnZVGqJeTeKuFqmxGLSzxrGQ1MxzeW8hJ/PFEejQJVFDESZLpjIf+NAoHJCp0r3ELjQ4wHI4ZjZfmsO4UqYR8NMhOzcpC0KjK71TNCit+L6ULEhQHx3oouN0sqa0EVF1nZq7nvUtRdT8LE6pCMo1kpRw6PVjhR57IcbXhQZ1JThFLjc7pu0vUVziA7IPHCyLHKJaMRYFSihzHDEQrUJKFbDOSbbmy/fk2wGx9X1Eac/c212/VrF/P5NFRzelIG50YGy2m6EsnJ+eB5+RgzWHVsugrNqOKV2EDs6JnUji+cvSIUgfOwhSnIj4bDkzLdRRiVKMHuuRYxYo2OiKamBVDkkMgZOGLbELBvBBJvtcOF7x70cC1g1lHTlI+qACxypi7LcobWDrqoxUb32AvLHpZsDwrQAsfIxWZdBiE5LVw+OMgBLe1EUKYEhe6WGaxodQSaPIkiLZHVpiZJy6c0OLrTJwN1M1ACIZZ09MODq3TOFkRsebeWy77hpNqzVVfU1vPOhTcnq04XzcsVjUpK944vJLluigcEWsiT9ZTDquWeBDJDzV+ZinrmuyDXCAUN2XpKxpE9sHjBaGKAlK+CRw7T9TRCHqbdeSb8gXGgOIsjBmJshZVFPg3T1m9pkllRPVCvmqD41uLUxZdSdcWItJzPFDVAyFqPr46BCAlRVV47jRLpq5n5UvuFAsa05OypksSgHw2uCx9j8swIWZNzJpVLKmNJ2VNG92OkanJNHYgjUHFR8PRnQWXnxwwKQdWNJIJREUqI1UR8MsCTGbzVGwcwokXDQ4lnA7VjWv1104o7JpdpqEy+MNEbkQUyCxkQU51Ct9EaA16Jlu8cemglIarenPNpAzEqGkqCRyFDTSFly1jxnM7ix3E4zQDoDDC6ZjYAV8Z1m3JrOolU/GO+bSlsIGpkzIwZUV12JGcY5hq1GwKqzW5jTfZppH3Owf/ygWQffB4QSilyDmShu9olMJzpYpkKNyUMSnvAkdOwqykcLR3SvqTvKv5s9e8/9EttIvk6wJ1MJCPZLms6xxdLtBa1tunlee16TVWJ5xKHBUtTkVS1ixjNdLUI05FLsKEkCRgDMnSRsd5N+GkWtMFRzuK6PikOak33KlWhGT4vYu7GJ3YdAXYzGHV8phD4XAYWbkXoyig2LpUK9R6bAYb0GtNqhNUkey1iC+DrNmXCd2KGHKwGVySDKXIom6W1W4WGDuLbgI5asKp57Ae6AaHc0H2cACjM0OUv+1MpHaecmyilkZKmbUveHB5wNun5yIS5CJWJ9rgsDoxH13tzJjBrH3B8WzNlZoRC1BNTbq4ej6LNGb3/r5q2AePF0Qa/HPELmBsnurnpy/PBBSl1U0A2f5KzqjDOe2JJtZZFM2VQvUavdLEqcZ0ijRXHByt6b3FDxbjAjEYKhe4PVlRGWnKHrqNaFNkiyNyYDccmzWbVHIRJlwME0LWXA/VTpZviIbSlDR2dHsj83Az57DYcKtYsQgVPgr/oV+V6KXh4UI2THOZiJVGt5o0LsIZK8pi62WFW7gbqcMCclDk3ohXTB1RZUI70T5NzogSWQa1MeQio5ogv+5FQUybTBokiygnA33riFlRjL0NaxLORnyQk7kcTaa2W7SNG25eq6Ll4dWce/WCR8sZx5MNAE5HjJJlujTqnw7RcFRu6KLjohj/l7q8OQa2x8FYrr6K2AePF4QEge+3IKVQmJtm6nh/SWs1hG2drCFlclUSamkapmlCJSifGkKdheNwp981QJXKNE1P6QJ3p0vWvuCkXHPs1mLMpANGJXwyPA0zrIqcmRmGxMNe6OY+GYZkqUzguNwwcx13ywWXvqFPlsftnNY7auN5u3zKr29+9saESWXSPLBeS3OVpMhOgp5u5KQMXpbd9KUbaetIdgLYtSZZIZJlK+peMYMtI+VhJ9qqcRTyGYxIFuos3JJCNnuVTVTNwDBY8ctVmfWmxLqI1gNOSxBRSjKkjRfpwanruewbpq6nsQMhGeZNx8T2NIVsIYes8cngdGQ5lBKQVGLtC6aup9ARP0uUl5pw1KC3721OuwuGMoYcXr0Asg8eL4jdyQ/fRS1XaqRax5v7KWNgG0is3V2dlLPEWUly4NaKOBPClV1DVgp1YfGHimLWsVzU5M7gZgNGJ6yKfPngMRMr3AatMkYluuRYBmmEHruBO25BqT33imvOwpQP22MOi5b79RXLUHFoN7iRgQrwuJ0Tk+ZWseL/+fCX8El6IIWJ1LOe9qwh9khGUSbS+FkruHO84NHFHFd7okt0tgCDyBqOi2xbESGCCC5npQlJibaqHwWRbZL7aFEpM3VAjYrsyWu6dSHbvUmxWlc7dTM3TpzuzRY8Ws2II7ssZs3Kl9TWc7ta8aSbMiTL5bJheVxxXG+4aBuGaGic50695GGcY1XCmchU9TwZd4HiYSA9KOhOC6bTiey5KC3j+uDlWNjyeF4h7IPHi+I7R7E5yWQFxMR6G0yMYWs2zbYuTgmlR+6HMYSJJTkgg10YVERYlxnSGx3Tpme9KSEp3GzgeJy03K2FAHbla0odsEhW0SfLod0Q84Snw3S38PbN1W36YEkoblUr3lufoFWm1gM+Gx52B5Q60EXLYd3yB8s7HJYtKy88CKsS07onHYvpku/lyk8tDc4UFQ/PDkitJcZtxsUuK0l+1Ey1GWUz2SFOdVqMqFwZCCYTlXBHbCM9npwV4bpADZpcRfk8kQlHMe+pSs/gLXU5cNqsx+camZU9y76kMHE3YbEq8WBzwJAMZ5sJOSk0meVQ4oz0PPpoOOsmTJz44l51NaUNTIue1VAyOW7JtqA7MswOD+B6Mb7v/qZkfQXX8vfB40dATvn5dfptBjI2zbYlyzalVSnJz3K+uY+RsV8U3pJwJgZFrDN+njEmSkZhEm4SaUYBn589eLwbwU50vxvDLkJNQhqkIRmOiw2P+zkpKw6LDRtd8Gg950E8AKQHAIecFmuGMV2/31yzjgVWyQ6Ij7LKHrKmcZ6+EOGdMBjJKjZy2OQM9AaVx9Hq2EhFgdYZVcbdqBWVUUhJkrNCWXkNtcrEMeOQZnDPsq2ITytymWR9fzLQNMPNGhHgXOCw7miD46RaswkFXbBYLcphm1BQmUBCMUTD+WbCvOpwR5F1LLjXLFiFkkVfUZpIZQKFCTxtpwzR3HBDVOZ0uubB0Ry7VqRp8/wxoDRKp33Zssf3h3KWPAw3pcuzTbPx+xyjZBwgjTRjtvYjUtoojaprQj2ulyfQg3imhCno2x0H047rVcXdoyVaZSrrmRcd175mYgasjhgSCRHDsTpy7WtuFUuSU7xTP+ahP+TpMEMnwwY4rFra4Fj2JYdli1WJk2JFP05fDl27Y6cuQk0ohZ5OhLrwrIeC0gW6TYG2iTQoTKeJE4XeCJ08VQlKsVfIKzdqoCZc44lBY6z0JJQSJbEYhBafs9rplXat6Ij4s1omvTNPWQ1UhWde9ZytJsJtKQfWg6zQn20mzFwvE6OxBCl0pA+WW/WKha/wyWB04qjccJ4naG5O9MYNO4OoynhKE1gPBW2QrHKIBh814X5PuKiIBxWmcGJPqdQu+9iXLXv8YOQ8zvXlwFJGS8kSuelzpCy3bwOL1uA9aE0evJQtlWyZqgTWK5IDf2fgz37uQw5cy2/xxi5wWJ2wSq5yVkt2cZUaIpqnw5RbxYovNE85smu+VG3o0mjbSOZyqNkE2SSdlx1xbPhObD/2NRIT26NV4n55xUWY4HSUcsX1dMqx9CWTQk7WnBXZj3T5AHahCdNEriPlvKcsAoO39FGan6k3pLGpSlRjErZ1sVMQjQj8gASlpAiLClTG3m157XjBxrsdi7RyQSwmTaSwgUIHDsqOedECsNIFIWkaJ6/XwldohDRWmMhZO5Vt26wZ4s2hv53MhGREmnDcf4lZMQSDNYlm2pNsJX2PooCuu8lA1NjwesWwDx4vijguvlmLqkoJBFtspyrG7G5XzkotHKMEju2+i1LCGYjCpMwO2nuBO3eusSpx6Fo+d3DBypfcrpd00TEZiVttdLTRkbLmrJ9QGc/tYsmB2XAdG574OZtY4LNhHSVtf3tyzkftEY83M/poKEzgi80TPmhPWYeSuevok+XhcMBb1RmVnmBVpI0FK1+yHgpmZU/KMJu3rDclaRrIK0OymeLOBq0zpQu7jy/fecRl3/B0OUXrxKQciEnTeUvXShDSJu9sL+kMeZIpSk+YQdxYikLGpjkrVm1JyuCjZHI+mh0bNqG46Ccs+opucFSFZB5aSemyReMGKZdU5rX6mifdbLRhcHQjq3fhZaJ0XG3ootg1lC5wtWooXGBzkNncMswmDSyXYw8MCSCvYM9jr57+gthOUXJMEgi2jbLxcxo8OQQJIgAp3ZDD/DO35ywLYSLHiZ9Jn2AIhontcSruhHmdErISSNbhVKIb3d8LHZnbnpg1j/0BD4cDnIrcK665V1xzWqy4Uy74/cXdXQ0/L/rd789tS8qKJ91Unu5ILLvnrjhxa0odqIxn1ZV8fHFI7+UEIytYymOkaRRV9KBZb0rZSNWJP3hyhwcXB9yarXjr6JLPzS/Z9HIiGytEt6oeMEY8bill0tIvStJFIf64CFlrWvbjyyYGThnogqW2nuteMovzVjZet/T0YiSFdUGylpxFMT1kzflmwrvLWzsa+3psDu8yFB2w49hWqUxlA8YkZlVPmEdCo8hHc3RZ3vTAXlHsM4+XQO578VZJ+bmrTvYBVbjnmqTb1fzUe3RZgjXCg7Cyz5GNsCt7b3nYHjA1PV+YPJXxqtvsSpU+OQaV+aWDDznzU86GKaX2JBSrWOJU5DrUeCPaHWf9FKdFFQtg6Ky4OSbNP7v+HJrMKpSkrPjG9W0mbmBuOw7shsvQ4LNwL7QWoyWlM76IpCBm2Mkq9MrgQymCxCbzgT+hnowsTZO42tQ8uppLOeINZjSASkmLgjoStHQRSZ1B9QZ1OFDWfpROkYBhjLw+rx9e0wbHqi9Y9OIeF8bR7NaCwajMeTfZWSt04/Lfk82MPlimpdDRH25kLHvRNhzXG9qxpLNORISqkZ1a6Mhh0wqb96hnOLBs3jqg+lb+btLgK4Z98PhRsT1gvkshbDvKTfKzGIXfkaM0Uq0EleyscEKULJelMuMmnpPphrnrmNuORaiozU1ZZHXk0Gzw2XARJkxNz0JXHLkNl76hTQVfrJ+gVeIyTLhXXDMky4frIx6vZlgTxaZxcDSFXLGvNzVNKTsc15uaPF3zB8s7fHX+kEYPNHpgHUohZrUW6oC1keg0WWdSUNiVgV7LIhuQW8MmyCKedpHgza6fYExi0vR0g8PaKBolUaN1IiH8jVxHyiowDBZrI30UWcCmHNj0BYuh5KDsWHYyZu2D3W3AZpV3gSQmjTaR0gYIdif8UzshhqWsOCjECNuayDDyWkoTZMqEJiaNT5roC4pxAmZdJEwy7YmltlY8bdU4hXvF9lpgHzxeHEqjCyf0cmtHUR8FaVwC22JLGjOGnPNz411lDOlwgp+KUI56RvbjsGpxOrIIYok4GVfnt1uvvUr4rGljwVqXlDqIbGA23NZL9NhUbfRAzJpaD1iVmBTDrumYs2LdS88hjXsm15sarRProWDZH7McKo6qDaeF8Cfq0jNUBfW0l0zARbKFISuiF4vIVKfdjosymdwZ0uBkTGsyymRM7dl0hYxwVcZ7MaU+nm+4WtUkX6KagcJJmeC9ofeWaSHci20m4pNB60RtZR3f6ETbVRidduv4SmWuu0oaqyZSW78r/w6LlquhprGeTSgoTWRWSLa09gVXQ71rVm9NoRrnWfal8FNcJhZKFiU3QrJ7FfsdsA8eLwzR8NC7BqgqC2g7Uts9n76mDFUBwyCTFy1N1hwTqqlZfGFCaGT9XGVkCjFyHvpoWWmpwaem59rXxNGLZT0SQ7ZU6hO3IWXN1HTMdEeXHcdmRTKaf7L8PBdDg1aJw7IlJE0fLJULDMFQuMD1siZXUpYc1h1DFPf6R8sZT9cTwpGmsQOlC9gysFlUKAW2DGL/EDS4RM5agoYWha8MMnpNImFIlDLHdxY1+uem5EjRoFRmsanoz2oJMs+83mZkjm4tNKkQ6cEguqUXbTNKBxb03nE6XbPsCxrncTqypsDp50/quRNqesqKh5s5/VjqtEHkCWvrdwSx7TLd9vG2I+ZUZlKhwOjnpy2voDjyPni8IHKMsJUWjFH2VUL4rvsoA7ltb/Q/rEUdzMlv3uHq7QntiR69WCEawGRuzVcsBwka96prrnxDNHpXusSsSFlT6kCv5C3bxAKN0NM3seT14oJlqumTbMk+bafcqleElJkW/W7sKKI5cHywxuhE5y1XbcWkHJgVA40TXsej9ZwhytW/KMXOMntNLkbzJZvIFbLsprMIJa+t0MuLJJu2GVlwM6JI5lyUMiVpqklHXXie/uGpsE9L6W2slhXaZLRJLJYNOSuOJxtWfYEzkYkbKG3gbDVhVvXMq55YCD9DVZJdrIaSWdkzcz0JMb+2Y/M5JEMXxabSaaGin1RrhmhIWXNcb4SVO5ZbzkQeLWcUNhKj0OuTVSh3o9vyqvE7ttgHjxfFM1aQebOB9nnzpu3iXB6bqMo69PEh8XN3WL/RsLmt8VNFLMHPEnpkZBa3N7w1PwfEkGkVS0oTaKMjJJnAaDRJZfwYQA7dhkYPOB0487OdFmmfLOtY8vXze5w2a+y49xKzxulEny3WBsyYwjsTOWpahmiISXNSrflkdYA1UZqNXvoFbedg0OhJIGxEvfjwdEXvx5KqdSIxWEV0E7hzusDpxEfvn4pWCQh9vQFjFEUhZtyPnxyIloeC5rCVMsQmCieq5lpnem93CmEKZMoyVKMGh+XuZEGhZWxbEjhvG4oxyISssSpJ0zlL/6VPljS+HqUJTFzPgWt5HOasQyFTJx1ZDSXTomc5lMyrnmVfYG0imCxj9kHKKck4077nsccPgFLPKUd9rzV8AHLCzGbkt17j6suHDDNFrKTHoT0kN0pfmIzpFKfzsbdgPFPTc+FvGJClCfTJYlQmZsXcdjRmoFSBSns2qaAaNUv7ZOmT5WJouDtdcquUKcsXDp/y+8u7bExB6x2bvtj1BuZlh0+G9SA9kU0oWHYlpY20g5ON1yTaoKpMpKWDSjKNq4sJejSgbqb92PzM1IWn95ZHT2fSTKyilC9eiwdM0OSkpBHbG1Rn0AHCgRGvGJ1o25u+TDlKDWqVWfcFm8FR2MhkbPaufMm8EJr6RdtQO89RueF6qHlregEwTo40QzKQYUiGw7JlXrSkrHnaTVl6CdobX9AHS2kDy6Fk1ZVMR52PGDUYMP57BIpXUE1sHzxeFN/pxwLPL8MBSifMrTt0X77P4nOFcAIMuz0WANtCaBXD7UCqNNOiJyRD0pFVLGmjrMYXOgjlepwglDrysDvgfn0Fmh0BahXLHUfjyte7/ZR1FLblaemY2V52NoKh7dzO97YwJX60Z0xJcdnVzKuejPQXjE6s+wKlNKaIBD+OM4sIKpPfn+API3k+EAdD7jXrrMRqUo2btXnUeh0Nq0kQMiiTUV7LXs9BoLRigh2CYdJImRWCjHev2wqtE9bI3sq2CRxHvsfTdkqhpRy73NQ0bqA0gcfdjHv1AkPGKCGdXfTCCbE60kUhiLXB4UchoXnZsRzkNR2C3emhmtGgWw0K0yFkwLzd5dGvZOmyDx4/Kkbh2+eyjpykt/HmGyy/csLqrsHP1Y33yLgspuK4de5lt4WpZ+p6ShNkzJg1EyPpcBp/2ahMoYPU44VYKDgVuU41s3Ha0kZHmwqcSrTj2HFrePQbT99i2ResNhXWRlLSMt1IiqvxX+pa0URdmZLSBbnqZ4hpVOZykeCtrNj3Bu+1aHkUmeKoE7KXSQQjlPRsx39aj/okWYIGUaErUQRLnUypdIA0aLpNQVEFmqqXIdYo7jMMlj4pjg/WYtRkA32wMkoNhlj0LLqS40Yo6kdNy7zoWAwV9+oFWiWWQ43V4k1TmMjcdTs2aR/Er9boxMY7SiO6sE83E2rn6ZSlHRxtP46Ee0W5jEICfMV9XPbB48eAsg49n8LJEd2bh1x/oWA4kKCx3V1Jo6DmlhimgyzDqVajJ56Z69HkHRksIePIbeP0fFQ03zb+Si2lTG08PhsaPXAxTOiTYTHUu5Ht9VBzthJ18LYvKAoxOtoGh3VbEIJMPFwht7VtQT/IIaEUFKPMn/eG2BpME6BU5CTTEH8Q8E9r/DTgas901hEa8Y2NQVNWnr5z+I2TqVITpPJTGVUIPT1rg+4VcWOhCmgF/Rg4UlJUpceOq/MZIZVlZNu1dIHLrqawEU3m1mTN7XpJqSOV8cxchyFhqsyDzcFuw3aj3G5R8LjeUKq8c5DzyWB1YloMvD654htXt1ingpSU8DyA8tI/Lz24H9Xu8QPxjJP9VsQ4fuUtnn5lQntL7RijyWX8QRJvkqTQHkw36nEm2WdJRaa8MPSHmmO3xmdDbTzrUHLla5yOXPmGz9Xn9OPVP4yfP9gciy1AsaHXdscDSVkzL1qMyny4OmLZl6zWku5PqoGTZs2HF0f0nSOtHKqK5CLSNFKmdJ24r20DSd85hs6SkxKSWIa4KNBTj7GJz92+4JPLA4arKbESNbAwutaXLlBOA5u+wNiEnvX060KW4ZISTRCAqAiHQYSSXSJnOKyFNt8Hy1pJw9SOhLDaeZ4up0yrnkkx7NTCzrsJE9djtewGpaw57xtWvqSxXuw1racLjnnR7UhiM9exCYUICCUoTOSiLcVESkeuh4qYNFXhofB0g5MLw5Ce03B5VbEPHi+IZwVv1dtvcPkLJyzf0Ph5Fm4HiAO8gfqhIVaizxHKTLai06kDFNdighQr2SR9Okw5dC1n/XScBMh+hVGZA9NSjs5mtfEMybIYKm7XS1ahoNSGuW15sLm1c3t/uJnvVtPXpcdHw2vzBfOiw9lIO1QSxKIiBk0/WKxNlGXANb1kKS6QCiXTjtbJhbVIKJdIg8FOIquhoF1UUCdME4he06UCVwSqSbcjcDVVjzOJx6uSvDaoJuCagG8d5VFHXXoW7x2Sphml4IOnR9w6XDEEyxuHV5y3DU8u5miTiLU0UXtv8VHz1dNHTO3AgetIKGZWlvyWvuKg6IhZcdZNSVnkC0LWpHG3p7EDi6HaaX5sOR8TN3DdV2SrWIzjc6PFbS5GLTIKnew2kX6IuddPOfbB40eBMZjX7nL+iycsPq/xEzEzSk1GBYVtFaodexxZUVxI5qHyWL4AJAkiYSK9BKMy7dhR3SqAbZumm1TQjgd7Fy2FjrwxucLpyMT0tLHgyjdU1o9TB6n3fTJ0wXJ7Lv4kjR14tBYBY6XFiY0sGcCwKfA2iR5oKezM1aoitXbkZ0SoErYKlJVnGAxNJVuyyiYIhqP5hiEYNpuSoXVcZyVZxKylcZ6NdztLSu3kb1kXOZi0PH56ID3H1tCpEl0IXX5a9bx/eYT3dhT/iTSF39kr+Ggw4ybsm/UFT4cZ5dgb2vJjfDa7hbguOkISDdXSBla+pB9f05BkElMio9uQNZvtIqDKqKzQbnSn86DGDeu8s18w38X5eRWwDx4vCqXR0wmbn7nN5o6+8WHNUpZor0TYJ9zcntw4mk1IwzTI51CLVN+86YTbEYrdKLHQkXLcoP1i+ZjfuHxrJ8QL8HTcgj0qN9wuhZY+c2KbWOuBx/2co3JD1QRq43myeIvLvuFi3RCj5uR0ydmjuUS4USYw1ZGQYeWNlClejyxRqCcD6+uKsBSBn+msoyo8IRqMTeRes9yU3D5Y0ZQDV6sG74VCvlhXLFVFDBpdRZpJv+tVhKh59OgQc1aIn0tmJwrkveHpeoZxkbrynMzWvDm75KJvOK3WrHxJGEesfbR8vDrk7mRBbQYWoeSin5Cy4rjccFS0u+ChR67M1qKhHNXD1qEgjixcLFy1Fc4kWm8pXRCafDmwTAqVFCokUryxX9irp+/xg5ETqq5Z37VkIw1RHZGDPoPu2QUGPchINgUZ02YtvRDnFWEiyuKxkVHos4HDqkQ5Rp9/4/g3+a9WPzMqpEswOS1XO2uArUUkSL8jZM3VUDMkQ0gGbQcedzNmdc8HD06oJgN1KeZRp3cXrNqS/kmDXWl8lUgrJ/KBnSZXiemdFc5E8W2JamexMKvGMWoUh3ndQX9dMUylV+GcTEwO646Pnh5RVp7D6WantdE4Tx8sTx8eoDaGVCWyzUzurCmdNHeNSTTVMI6LhY9yWLRc9A2HTjRWj8s1T9oZEzvweJjKhuxoM5GyYjWItcTKlwxJSHDORBE70rI5G5PmvBOzqmFcwhuGksJGnE4MwXC1ajiZCRfHe4MdQHXPEsRkRP8q9kz3weMFkVMGa0hWAkKYZJmgFFKyqLEckUABgwO3kt25WInLWqygP0qjZqkcbWfddCdeE9A7W4T/8Omf53KoGZLl2mcKHVmHks/VZ3x9ef+59PxpN93V7QnFzHU8aWfMi45VV5K9JnjDydE1TkfmRcdmVvD1izeIpQKvhE6eRCXMzDzeG1YXzbguq5hOJOMA6AbZBSkrT9tk9MpwtapRSrRFjc50I8XbmchB2VFZkffrg+Vi1YDJ1PdXhGA4mm14bXrNx8tDJtXApBDxI580IRoWfcVvrN7kuGn59upkJxG4VXm/P73maqg5LNqd6lrMiuUgC3NtkKxj8HL/ebFi5Uu0iZjxrK8bvwtQIJu5OStmTYcbl+eemiluhawpaPVKe7bAPnj8aIhpt0pv14pUjAu1ox+rSkoW3pJ8n+2Y5kYwPfgJ4s0K5EGz2IgmRWWDLLBlzbeXp3yyOSQkLSd50CyGimJkU25p6xd9Q2UCrzdXvDN7wsUw4SlTPrg84oP2mOODNYWJ/PydB/yBvc3JZMObk0s5eWzLN1e3UZVYOpoDaczcPV7QB8vl9USGS1FxdHdBYSNPnhygjles2xLfWVwVKIpAOvGYJwXD04by9kbc7TpH6ByTg5aTyYZ50XG7XPHu8pQHC9H3OL21ZNM7bh2s0CrzYHVA52V5z+hE7x2rruS1+YIhGV6bXnO7XPHPz+8zLzu6KMHJaiHFTZ0svB0XogK28QWzouPDxdEuGIEYPHVjMLFKaOsgiulaZQ5HScNFX1G6QDs43Ohd27eOySaLrOTOiuPVI4dtsQ8eLwg9acibDeV1Zqkl01AJCRyjqE+yYDokYKStojikMmNahVtCaBT9aSRPI33vSEljZ2uWXliNEzdQGU/HTYNP+AlwWMp4ccsFiVnz8eaQ15pr7lXXnJYr3mwuWceC9xYn/OGj23zh9hm9t5yvG+4118xNz9NhynsXx7CSRmYcNM2845MHx1SznuQ1fXAc37umdoGQNK/dveS6rRhWBaaKDIsSX1qUTYSDgFkZuvOaW29csmpLVO25PVtxVMra+oebI6aup92UTCcdQzAcTtrdBmsbHLXztN5xsW64vmooGxE78tFw2TeivzFuylYmYHWi0IEhWUIwFDrwqJtx2TeEpLnsm1GdXcqL2vrRi1dKm4AhjD8bony9DTzb53LUtHRBpju5M5TXmdwPYh1qnjlA9vT0Pb4f9HxGPDtn9u0VizfnhIn0NbSXZbdRdxiVFKnI2JWSHZYIaOl1mA5QiD+ry0TvSKUhz9ayyJU0IWnO/UQIS1Hq9dr6kS0pUnnHbg1TWeEPWcsWbZ7uypg+WkoTyElxtpnw9skFIWkebg74res56/NG2J6DIjUJesPm6QQVFf26GUltmeK2eL72I0179WSCvbKEI0Vx0JOiBDczDcTR4OlqWctkpBqorWeIluuhYuIGLvuGO8cLrtuKGDVvzK646sWpflb0XHX17vWeHbTcnS0JWbPuC6ZFj4+GN2cXPN7MKVxPO/qyrH3BxjuOqpbGCv+jLANT11NbTx8trR+FoVWmGlXou+jQVk74x6spG19QGc+0EDX2DPidqpj0fsqrsLPZyH54Zs/pj/Fg/IxgHzxeEHnTQsrob33Cye2a86+5Hf1cJYS7UYpYTLIQpnnHNDWDLMZtFcRUBHdtSAbMm1JebDU0fTKypOYL5mVHP6p8n5YrQtKcuDWNkanFgW15szjjHy3eodQBpyKNlRPjsGg5qaTRd1i0fLg+4t1PbhM7IyZKZSRrLQ5uu35HQvmt6nvm/GpKdXpFyorHVzMoErFO6I3BlxZbBqpSGrydKghrR3hSk0575k23szQojSidr3Mha/6d4+7xgqu+5qPLQ+yoEboZJNuqRhbskAyLrqQqPDFrzlYTFkPJui+4aBuUyqRKej1h3AzWKnNYtmgyXRTq+ZaV6oyc4VbHHf2/Nn5UiPf4MVs5KDracbdlUohbX0oas9a4q5Y8DKNGS7yx4NhdKV4d7IPHCyKt1mLm1LY0/+wD+sPPc/kzWrKJDHYjWUhoMm6tSCaTmky242Rm/NlW8UYPwg/Zan1+cnbI4XxDMVKx0yja2wbHZVfz9avXmBciU3hsVrwb7/CF6gm/VH3EL1Uf8Y/aL3AZJlyHmgPbMjUdfen4g9VdroYaHw2xM5gqUh62DN+ck20mTkdR4yLtrB7VyAT1iwJO4Xw5YVgVKJvIsyDbsAtHOs6EkMVPVmXMxGOe1HhTcq4Tm76gsJGTRgLkQdGJFqiJ3J0s+Gh5SM6KxdmEduqY1AObdcXgAkezDYuuZFbKZOPJcspmU+48akGsGLaB4c50SRscT9spEzdQjFMrq8VG4lrVu8bpgeroswQaETx2GJ0wwEm13vVHdsuBQyF6ptcac92SYtqJAO2Mvl5B/NDgoZT6m8C/DjzJOX9tvO1/C/zPgKfj3f43Oee/N/7sfw38daST9L/IOf9nn8Lz/okhxwTLFce//j7Rvc36NUWxGHdZMqM7GmAV7oka6ejyu1uaugpyW3IZP+6SzKbSqHMmij7FOIY9Kjd0Yc7GFzR2YGY6fv3qy9wrrzk0Gz4Jc+a644mf48fm35FdM9MdS1Vx0Td8dHWIVpn/7le+wZ1yyTeXt/ntpxNUL7RsPfektZUJwliybCUFh2joripZaMtq5/6mB026KjD3BpwLzKqe603N+rYDnQm9pVOMaueOr18eEoLhYNoSk+LDxRG9t/StQ68snDmuJzW5jjSTjk1fUBciBfj4Yk7oLK6W9fx502F0orJhN20JSYMVIaDVUHJaSwm33ZjdOsClrFiGEqsSM9tT6iBN1uCk3xEKitG7phhp8UYnQtDU56BGQaic8o3B11YI+xXDi2Qe/z7wfwH+g++4/f+Uc/4/PHuDUuorwF8Bvgq8BvwXSqkv5fxTkM89IzWYh4H49IyT/9cS+z/+OVb3NbbNFEsgQ3tbJiyoG9KYGUaSmJYGa2gyuUyERUF9t+fOdMVF29AFSzYygflwcSTmQ0nhdeZRmnMxm9BGx9Nhxt9e/jKvN2KVsF3Ntzrx28s3WIeCPzi7zWZdMZl0fPXWIz5cHvOP3/u8+MAGhekkG8pBy67LYORzL+zRk5MVT6+mkBAtjzqiXaSce8LcoIH1VU016ykmGw6alpyhsHHXiAQ5Yb03on+aFZPC83QxJXjxq+1nhjRRVIcdwRtWVw3lZKCwkSEYYpCywLpIXQ74KGLGB0WLHtXS70+uADEAXw7leNs1t+oVV31NHyxqXIALSXNUbRiS5ePNIY31FONm89x1XA2SpYSkKcZSx/eWk6eRfHYxskrHw8KHm9WFVww/dLMn5/wPgYsXfLy/BPzHOec+5/we8C7wKz/G8/vs4BlD4xxFET21HYe//m1mHyXhS2TQUfgf2bDriWwDRyqEph5LdoQsbMKozEXb7NLlbrzapazovJV6e0z3t8rq7ahFsR019luh5GQ5dmsqI25zf/rNjyhs5Dc/fBOlMl++/+imaTuP1EctOYzLbypzcrrETANlIx4soXOyil8kEfRpLe2yFDHi6xK9sAyd5ZPzAx48OGZzXbNc1ayva7w3lDYSs7jEtcuK84spD84OUSpzerTkaLbh7muXmEa0UWPQVNOe146usSayXNVCRnPiKGd03ulsDMmyHCp8NLjRMOu0Wu/UzrtoebyZ0QXZou2jHRussrMysx2N9XTR7koYaaj6UQQ5jGWLI18WNA97Ut+jzGjytVWWi/GVm7TAj9fz+LeVUv8m8JvA/zLnfAncB/6bZ+7z8Xjbd0Ep9avArwJUND/G0/jjwXf51OaE0op0fsHhP7Lw33mTzakmlWIfSZKgMQp9CVXdsmuYkiHNAngxTPLluB5vIt3gWCpR685ZYa1QpNd9we+pezgtquCNHeij5fEwp42OYyd6Hw/7A866KXXh+fblCVdXE6bzllv1isu+AZuIpUb3mvaiRnUaFRW5kCzn7sk1AIuuvDkngpbRcx0xhazH64knZYfREIOodFXznuPZmqdXU4ZNwcaITmoaDK72lJVnWknD1+lEFyyFiRwdrEU3Y10w9I4nyyl954iDwVbyIs4n3RhMhWWrVeakWu9O/rN+ysx1lCZwvplwr1ns1uzVyMztogRmkEBb6kCpw462PrE9Ky+GT0M0OxHl+qHBPV2RRg9iUt4RxESC8tM/Bj9reNmd4n8P+ALwp4GHwP/xR32AnPOv5Zx/Oef8y47yJZ/GTwDGiCK6MbtgEs/OOfjdC0yfCZX0Mp7lgfiprOvHSpipsRKbydnJGhUUYTB0naPvLeu2JHhD37udSI+I1Yi6+FVbsfEFd6olB66Tv58Vp8Vqp4H6YH3AH35yhwfvnXJ1NeFf+dnf5yu3HjOzPY8WM8y1RQ8K3SnslUWP/rPVnTWrTckQDUM0rBa17L+MDdXsEgRFWQ1onTA2Yeae5DU5aHQZmTWy8u4XJXkU+dmsS5RJuEJquE1fiG1k0gzBcLFuGIIhBI0tIndPrmWSkhWu9pAVdeWZlT1N4YWFagemth8zhcB539BF0Tm51ywobZBG8bgkuGW8+mRYDSWXQ8OQ7M2+y/h1yprEllAmEWG5qpl9mODx2OIbM09ygvTqskxfKvPIOT/efq2U+r8C/5/x20+AN5656+vjbT8VeLazLgeMzPuVUhAibpNpUZhWOB5+Ij2PrTCQDtCdJHQvE42uLdCdIk4U8aog1hFtby5henSWt6PKufeG5BR3pis+Wh9yWq05dC0T29Mny313ybfXp3zj2/dQraa6t+Evf+m3+KXmPf7fF7/Ar7/7JdJVgVJg/DagJfTJwNt3znE68u3HpwBcLWtYOHRQ0vOoxuel4XDS4qNh1ZbEmIm9Aa9QJnF2NiP3BnthCYeRNIiZtTI3MoKbriBEzazuiUmzvqixTRApw87woLMok2kmPSeTDZfjlm1tPbfqlazSW88wGlOXJrAJBbeqFRdDw9XQMETDw1H1PIw2D37cX5kW/a5E1CoxpHI3Kr9VLDnvxdZhNRQYlUmf1Mw+7Enr9nkFOaVRZlSVewVJYi+VeSil7j3z7b8B/O749d8F/opSqlRKvQ28A/yTH+8pfjagikICxrP7DFubySx7L8ZnnFAriIWULVlL6bI1eaoeG+rHGrsRC8aswT0sUOkmMBVVwFjxQknjAlfbFsRgOGpapq6nMmF0mGt3HrW/t7rPb370BqrTfOXnP+R/96f+DvfcFX/n/Bf5+vk90kVB+cRQXoxWj/c6Xv+ZJ3zt9QfcaxZ8fHVIVQ+il3FVkYskptYGmRJNAnY+cFJvuLieMPQO31mIClWOr0US+cFsZZ1dFxFlxWU+Js1qLfJ/etyg7QcL456MrTzTOyvRSAVuz1ZMi56DWnZj5q7j8WYGwMfLQy576ROd9xNuVSsedzOckoboabNmUvjR5V4eLyTNeih2W8ptdHzj+jZXvUy2hlFEOmSz84u52tTM31W4P/iYHMYaND9brry6frUvMqr9j4B/CThVSn0M/DvAv6SU+tPIJO594H8OkHP+PaXU3wb+BRCAf+unYtLCKAY0XnVuuuuGHDy6KMhao33GrTLDXEmTNMlOSzYSSJJBBthjOWNGarceHFnn8eIlQaVueu7MVmy843LVMGl6mnKgC5a71WJHEnNKntN1qPnS5BHuC5H/0n6RQgf+7w//PB9eC5dita4oLgymlyAWS+C85CN/wnDXsGxPadcl2oyBsUjQa/TakMokWhw2EwfD737wGtomymqgXZfSKHZJMpCowGTSrQFjM7OpZCnTShzn2lFOEGBSDCx0RXO8oXSe0skotpgGkRZUmbPNBKMTOmk+Xh3SBWGL1s4Tk+bhZs7nZ+ccug1z2/JRe7Rj4i67UkyzTNo1UQHOuwlH5YZNKJi4ganruegbpqMaWWMHlkMpf+v9Gfd+ryMvl89lFrvAMdps5MieJPadyDn/1e9x8//tB9z/3wX+3R/nSX0WkX0Y9xmMzPfTmMZnI8IwzjBMNf2RNEy3VPRtg3SkR8C4eetnieODNWd+RqoyVEnk+aIijtaKD67mpKSpy4Gm8MSsOKpa+mR5rbzGqMSD/pA2OmJW3C4W3CqWfOXOI1a+5Lqvds3S9KhCuUxASio02JXCG8PjB4ejMrOYL6WlAw2616QyoZpI7gzRy3RIOem/9L0jB41ZGlKxNUCCYj4wbTquridcX06oZ2NvJmmacqCy4suy7EuOpxsy7IyljU7EpMVnFui9ZVIONE4IczEpslLEpIlZyYp/sjzsDnCj5kljB+5WCza+YD2IVofVadconbhhVGyLVKN3rdWJ827CSbmmNuJp++hqzvQjTfHNB8SYbkqTUQBbWTeKKsU9z2OPHwCtUDwzz9d6VNDWqLpiOKoIley56EG0Pp4VP94FkjCKIdcyCnRVYKgs9VxkApeLetfrMCZT2Mhr8wV3quVOJPnQSQB52B9w2TdYHbnsG16vroiI/mZjB06r9Y6yvTod8J1Br8xuE5g87rdkg4qK8o0Vb51c8I0Hd4hLR5oGMJncGlQSkyqyOMblrEbqSyZOEgxaDJ6msm17dT0h9Qa1NrRUMm42idPpIPTvca1+m0VsdUqsTrsltYNCBJW32cBWEKn1EiydTphRAyWhdmZQAFe+5rRe4dNc5ANs2FlKgmigbKn8m9HsaT0UnPcTkTXMiu6s5s43PPHy6jnPni12/Y+8N33a4wdh53qfyV6uijtLybomNEYChbrheKiElCiW3fYtdvy5yhxWLau6YLiU1fz7B9dwcM03H94mRs2t2ZrGDbw5uWQVCiyRL00e8wfru/zWo9fFELscOKxaFl3F71zf51YlZk9HRcvPTh8ysT2P2zlDMCyWDamTZTbtRybpiOwyQ+92G6joLDaQQd30Y9y2x6NIaxnN4kT/Iy4cKiiqmUxAlM6YKhK9xjwt6NeW8vZGtlnHicYQDfOq2zndr8fltetNzZtHl3TRYkdT65nr8ckwjLs/i66kGu0W2ug4LjYsVbmTGyzGxbeD0dhq6z07tT1XQy3yg1lc8babt5Ni2GmaPl7OqD+2NN94JOPZ+D1Kklcw23gW++Dxgsgh7BahdlOXnEDLS5jtGDDGq3rW8lklyUTiOI3eljB65hmieMfa+UC3LEknii/OznjrnQt+88kb3G6WXPYNv33+GgrZCP2vP3mbEAwxKmaTjtp5blUrGjtw3k34g8vbaJX5ytFjPumPeKO65MTJyv9i2ZCtjJEJilxsG79IudQavvHeXfAaNQkiR+g12Yp5kx4bmUJTBz0JKC18i+RFirHbFLSDRllplpqZJwIqKvyHE66+EHZZwxcPz3h/cSxlBFKKPLiYU5aBDy+POJ2Kn26hZbFOI6JIvU6sNiXTce/laqhFqiAr+mgxKrEKpajMlyJbKHofereFvN0fSlljdaC0ARUzZ92Ew7Ll6mLC4RVweX3D5zDm+bFsTs/c9uplH/vg8aLQZkxP001fLEsPBK3QXlzvtQdfggsiSWik3Jegocd+xzxz99Y1p9V6d9VbFwX3m2tK7TlyG9rh83yyOgDgYjnBuUCMmq4tODla8cXDM6wWgaDb5ZKDpuVb9hbn/YSlL3naTfkwHHFUbbhbLfi5owesh4ILPcEvC6KVESwaVK/l+SUlW7VBQXCScahMrjKqCtgiilP8ZsyyktpNhETbE/STQjIrl4nWSAbTj2bXg2L14ZzNaY/WiXnZ8TOHT/j6+T2ckfX/NIHaBYZo+OD9W6gi8R5QTXsm1UBhA5UNHM83u/5Im91OKPpWtWJIhiFZCh0IyXBQdKxHh71Cx5FY5mjsgFGZh5s509E/50694NvLU+gMdpNFAGo7VXvOqyU/f9srFjjg5Ulirx62W5TW3WhXWiuN1G70MnXjJpgS8WA9jGxShGEaayGIJZe5WE52wjMpw8GkZRlKVrHkX5v9Dj9z+oRHTw94ejVFqUzfOw4nLWT44uEZp+WKQ9dyUkop0GfL280Zf/742/yFW9/iTr3gX7/7dVJWXI9Ldl89fsQbty5xswF32EE5btLWkXQQ2I5B8jh2VXn82sq2rdaZogiYWqzvqmZAAXHhpHdSZmIjamvKK6HfBwWjZkZy0jMRv1rNu09PWceCxbqiHRxXbcW6LbnayPPVTaBoBiYH7U5/9XwxYdmXxKTpgqWy4k278iWFiZQmUJnArXI1igeNS246MrEDWiUWQ8WbzSWHruVeeb1TabtVrXAqcbGpKc4N5TKR+/75wLBdwdfb5Zb8SgYO2GcePxpyIof0jIaD3s3+k5ONVJUkRUdL0zRbYZgyapmqKAfatBaP2o13z2lJ3C5XdNnyZw4/YPN6IWzITU27LHlwcQoK7lXXXPgJx26Nsy0+G65DvXOUcyoytx0fD0f8mcP3WcWK82HKOha8Ob3cbZlezmrOzmfkjXA1AMxSdl6yG1N1r4XHojP9RkSSc1TgEt2mEGZpL9IEfipiSNlmlJflQPVMeZQqyDrDxhKAUBp+h9dISdTCNuuSHDQD0Dkhs2ktfR2jZdxqTSJEzbzqRUB6kKlSTJqjqmUY/WuSURyORtYpS1PVjjqwx+UGrdLOZAsgjiXNdT/l4vGcZq1oHvaSWewCxU0W8hxeQYIY7IPHy2E8gJRx5HFrNmu163E8W6KgIJajrkeQn2ebseNuyucPz1n5krPNhNY71rHg7y9/DqcifRQj57V1FI1n8Jpb9692DnMnbs0miXeLVmnH+QA4dSu65PioO+bK15x1UxZ9xbzsKG2gtp6VKagnPb3JYveIlBsY+ciIBYMqZeM2R40yia0PbR40qjfoQeQWdVAkLY+RbZasYwubyNtJxdgPIiraswYKEdupauGN5KCJvUHZRIwaH0XQx6gstPNNTR8DB9bjisjGF2iVuexqjE74ZGisqJBt91a2CvQLX4mJ9WhzURvP3HU7Y/GPloeotaVYgPvkgjCu4O+Cw7OBZPv/KP3KcTxgHzx+NGwPIKXGrGOMHCGgh7wbx5ph9GYZjzPthVCkgyJWGQ49J/WG0kjz0MeGg1E1TJN5Osyo9cDZasK06rk/X7CuOx6aOf+j13+PY7tGq4QhcdndZm5bpqbnOtYcW7GvPPNTtMrUxsvmbbVi40Wr4n5zPS7Xianzxhc8vprJ1EcjWcj2vN/+y6VQ54si0F7KzotKamwOZ5IdZQi2EyaE0r6b1OTRcnNrJKXksbMTJq214qPbqUKoFCPDVmuhlVeux4+ToG2vo49WtnuTxqjMUdVSGU+hxcz6UTtjYgaWoWTQCSwUOnDZN1RG9FHb6JjYgVIHnvZTLhYTiivNwfuefHH1/Ih2yyTdyjNsg8orGDhgHzxeHCM5aEdNNsIuVUUB2qBDJhU3NHRKIEufgyxCQMllYpGZzORKtw4Ft8sVjxERIKMTl0PNSbnhajigdBKcKiM8iK/dfciXa1kVughTLsKUrzaf8NgfsEkFx1a2as/ClEWoMCpT64FaDxRFoDyIO18Tnwy3yxVv1Jf0yfFNe4tvXLx2M4FxSS6s+iYdT0HThUIaoKMGqvYis5isBE+VkS3djPjQNkE8e23a0c4Ppi29l0W1lNSOAzKErbiOIkdNPW3F+9ZGfDSEqLEm0ZTiWHexbhi85WDSUhcDs6LbjXQBlr5i6StOqvXOE6cygaNys2uW6jE6Xg41710cEz5pOPoo0/zhGXG1fv6C8WzJ8opyO57FvmH6oniGXQjsDiQ9mxK+dJ/lfUuyY5NxVFF3azCtjDDNIN4tKsFmJXPbiRWHs8loGxCT5oPrIz7ZHPCbH77JxbUYEh2MafUXJ095017QJUeXHcdWShOfDV8oH3Mdah4OB3TJ4Ub/Ep8Nc9sxNT1tFE2Lie2pzcDd8poTJ1lMbT2ze0sIowxh0OQM2mSqZuDwcC3EtUcl2Wb0aT++LmJFkQr5jKy0EOuEmXqmBy2u9miTcS5yPBe9jbuzJYUNdG2BH2TNvu8cOcq82zUDt2ZrhsGyauX1WrclMSk2fcG6k1KlcIFZ2dN6x3KoWPqSlS95sDlgYgdmrmNiBjbB8e3VyW6ZbjHU48g20ifDg9UB649mzN7TnP72ivTBJ5Di8+89PLdNLU0Z8xxx7FXCPvN4UTwbOJARnTk+Ir39Gtefr4m1wq4RpTAjmqaplN0Wlcb+x9hMLRuR/9960r5WL1jHgsftjNoFLrsapTOnszWzoufbyxM23jF1Pe83p9x3lxQq8m5/h+tQ41Tk65s3OLAi/NuYnjM1YxEq5rbDZyNfb1WyYsGdcoFTEaciU9MzL1qcieQqooJkFsoBKtN3TkytVSbXCXttyGstLNoxU4lNgmoksfQaisRs0jGretYmcnU9oesc3humTceyK7EmCls1bjMQ4ZLEZJk2PU+XE1LUaJNYtSVNNeCjYXk2QRUJPeuYlMPOsuKkWu9YuI/b2S7jWEexbJhqCXifrA+orceOI91P1oc8fnDI/NuG09/tUF//Jmm7BLd977dfhvDMBWTkd6jxzX3FMpF98HhJqKKA2yes3mwINeOIdiztPTu5QZXGrVoNsZar89Z57bRYs44FPmusStypl1id6IOlqxy3JyvemT7hyjeUJlDrgd/vXsPVkdfcJYskgePAbOiyZCA+WR4OhyxDhSbzYXtEqeNu+/aChoftnJA198prGjOMgjiyum5mnhT0KAa+tVPMuNozm7asJyXpW1OKcy3Zxv1OdmFshqDRVcCM+qFbrY6cwbqIGqnjy3UlsgBGpAmHaBlah6sCvnWgRC1s6B1FKctyKSlSViignPfEYDiZbHCj8rwzkYQ0VRehwKrEUbHhvJ8wpJvDvLFiCTEvhFT2zatbfPLxMdNvFNz+b1vsb71L6rrveLPVzUj22Qx02wd5RUuYffB4UWxJYttv64r2zQO6Q71jk6Kf4XWMlHSVb0SByJCLhNGZkDVnwwSN1N0JhWaUwGOknRcb+uR21gV6rNF/t32de8UVE90zKXomuufb/W0+6o4J2ex8W3yWRiLAItQ4HZnZsUTKikWo2aSCA9vSJ9l8XW9K4W+oPJ4fmc26pGjE3BqErxHLsUF6XqIz5CCOeSmBGgOQNon5ROwat0tvWmU2fcGmK7A2cjLZ8PByTtoGKpPQGmLUlJUnJUWMmpwUq1VFWXmKItBMWyrrn9t7CWM2p1Vi4vqdVKPfGltbMbDasksfrA745P1T5r9vufuPl+jf+eZ3Bw54PjA8u1lbFLtVhVcR++DxglBajWvXeaxzNcPc7MyeQDgcKkJSCj8VkeNiIVu229GtbjXrrqCvhAHZWNEjLUdRmzY6kha25dXQUBvPkCyP2tlY3pQUOrAIFVMrafh1qDnrpxwXaxa+YuVL1qFg5jpOys2Ofdkn0fqc2V44D7GgyOK4thhqOi+Hg9aZWS2+K2fXUybTjlvTNZebGmsTfZNEPHkqPQ7dK3RUmI1iOII46p32G8tqnKSEYKhLETUGKEtPaSOfn52z6Eq6wZGzwk0i3htyFmPpohDV9hBFPzWYxMGkZV7Iin+hw86fdogGqxN2DFKrUatUMo2WLjo2QWwUztuGBx8fc/g7ljv/+Br1+9+SwPG9OBvfh8eRfZC+yL7nsccPwo2ClJLdFq1EJWzsZ+gxcMRCOA9hIn62biW7JJu7spW6VeQKSbMJhWyYbk/usYG3DRiFlmCyCQVrX/JET3mjvtxpeVz6hqntufY1QzJ8vDmki7LcNrHi0Lb2JX20TAsJNGtfUJrAabUWN7rSczE0PFrPaPuCO8cLFOyyhWnTcdxIL8WPilym1WQL3O3JVwVhNO1WhzK6dbVHNTBcVtIrAXQho9jHT6cyfXKJci5lxZ3pareQ92Axx9ooBLSoGVYFeI1uZV+muiUr/X0UNfSZyqxCSR8sE9djVcLqyGKoaeyAVpmQzC6QpKx4tJyxev+A43+huPP/e0p69wOSH8Y3+gXLj2dHtK9gyQL74PHCUFv1dKXls5XpSnIKHcZlM0BlIUfVj29u705GiwObsStDNy9oawkYDzdz5kUnCuNjzb6OBRo56EsdwQ4MyVIZz+9c3edecy1X1lhy5RviKKlXmMj1UNMFu3NUK0c+yaKXk9gnLX6wbcNB1fFkM6MfS4r6Ga2NRVdSucAXjs7ZhIIna+GNHNQdq6MGLq2cP43IClT1QGkj5+dT/HUpDddmXKTzmrS2XJ8fioDyJPD6rcudD29Mwu7sgkxd2nEalaOS6c+osZrHwOuj2S3Xfbw8pDCR01oMs7eUdK0Sm1BQWb+jrvfB8u7DW9j3K279QebkHz0gvP/hd43h5Y0c+xnp+yijP5tt7IPHHj8Iz0kPKpHdF2JUvmGOjpKD8Rk951ArwiSLotigiLX0EjaDE7q1k4M8JM3U9Tt7SavFOW4dCkLWWCX7Fz4aQjJcDBNCFkGcLjo+XBzt/uZB2dHrxKOrGU8fHlAfdhiThFDlpf73veUsz3aj0Wbe8Qv3PiFkzYPVAZNCrBdWvmTjZf8kJcVyUeOagWAS1kam047SBWJSWBNlB6YJGBdxTsqVWGjSRYlbKYZa+iirvmRedSyHkkVXsm5Lhk2BrTzKZNJgdpT5XCQoEtV0wJko28ijMtikGMZ1/nKn1bEJBX20xKQxvuSkWrMYKt57eoz7Vs3J7yUO/+F7hEePb96o7xUAniWIPcf3yDe/s22cvoIBZB88XhDP9TxyJK/WFKtELA15K/QzTu50yDc+tlGYpsWVjHK7W4q+KOh0Yij8TjJvq9ytR7V00aMQPc3GDoQsAjnlaE70tJtSGGFLbrzjYtEwqQdmVc/Ki7hNzgrlEt26QNuMsVGMloqAKwO+t7hmQCloSs9F31BoEQiOSTQ3nq6nXC0a4nkp1PUiEa5qss2YxtN2jn6wDJsCdJYT3AWWT6bkqacoPdZGzOs9w21LCTgXOb+YcmkbtE6E8xqz1KgyE04ytghiOwHEdhRDnnc7JbCc1c4U3OpEacVeIWTRe3UmCv1+EGe4lS/59pMTzB9Muf2bgclvvEc4v/jBJ/1znJ7v3TD9gbe9AtgHjxfEVvhnO+fPMVF/vKY7mgvTenQo0FHcB00vIsjZAAn6o4zdKCGPLTTD1LGuClIjGhSNHW7UtFSiGzMQTd4pa20Vv5+2U2orBs2LrmJSDBxMO2JSGJ1oTCBmzbosKEtPjFpW6cfN2GFTcHC0ptMZrRN3D5aURqYGS18ycz1dVmwGIWNFr3f+tXo+kHRGrSzdeQ0mo1qNHhSxSXSdwd5a05xssCZRF57N4KhGS8p2cFxfN9gHpeicFOBGJfctJX5SDwzB0HfFjSZqUmgtgSNmiCOLNBl5zWJW9KPPilFJbCaTxmjNo+sZvDfhzj/1NL/xbeLF1Q0BbIvvFyi0eZ4str392ezjFcU+eLwgVFFIVIDdbF8/eIr6ymzc01BgkOmDv1mKQwk1PTaZWEowcUtFeuKIc82iryhHz9WQtfz+aGg0JNl12XqKzIuOp+2UIYqaVsqKSTHsehaFTTvPFQVMyoHFpmLedAxBhIeqcSmusaKaFbJmYobdnsdiqEgoKhN42M05na35+NEEd62JdSZ0VohdOmMXZrcIGAtwC4M/DqK5MZpQG5U5rLudFKDTicvHcxnHFsg0qoDgsryENlG6wHpTEjsDLlE0w46qr1SmctKXMTrho6EdFciKUfd0NUgD1ZrIeihYPJxx5/cyk99+QLy65ntuxm4DxbNkr2cp6do8I3r8au6yfCf2weMFoacT4sWlfJMTYMjLFc3TwPquk1Jl5HTEcqzVlXAhigV0JbS3MzqMJ0yZCd6IFkewXPU1lZG18SFapuNqOSDU7WC5SrWQxazn4XKGM0m8XJOWq7q3aAVh5EyIkZJh0xdMq56TesPTzYQuWJqpULYBrvoD4lhn+SgmSauuZOgty4/nFOcGPcBwmGHQ4CUbCPOI6vU4VVIMBwndBGoXsDpxWIpM4CfLA/pggJK+d2AT4daAuXAkq2Tr2MiSXFF6ei8BCp2ZHEi5clB3LPtiXJKTx8/I/1qOwWRL8Tda1vaNTjy9mHH4dcvJf/2A+OjxzTLj98J3jl2fy0LkPQde2R7Hd2IfPF4U21XsEVsPl+r9Sza3b5GMQmXpdZgBhrna6ZhGGXSgEFGgYZZF52Ks3Q/KbqedueUopKxY+ZLKhJ3Te2X9bk3/3mxJSJrVIN1ZZ0ZP2FFVPGdFVXjWUdMPYrHYO4sbPW9vVyuuhnqcTiQKFbEq8sTPWLYlSglRK9tMKmR3RQ9K/GqrjNloUp2xrWzg9scJfasjBc2Dx4ecni53RksxKenFdCXDupDgkxSxTsSDIFqpraiOhWDoNoXIpZhMUw74YHhwfgAqM216rkexIGDHWi1dIETDECQLczay2FQU36i584+viR89uDFngu8/QfkBPZDttO07yxnlCkTr5dUijO2DxwsiLRbyxXjwKa3Iw0B++ITm0SHrewVZq5veh8+ESpHddtNWoQeE62EhTiJOZXzUrH1x83eyojKeK1/vRpm19Rgl5KeYNZddzVHV0tiBnBUXbUM7ErwqJ+bMm77AjQzPzlvmVc9iKNn0BafTNReDGCZNx6W8i74ROT9vaUqPUpm68FwwIXYa3ckGrYoKt9SyOXwlvYr+OAq79uOafOwxTWDdFRQmcrFqaBcV6tZC6OU2oa4LUplwR730YjqDvTaEeRQTqasC0yriYWRRyZRHGzG6zlunN52YVf0zNg4FWiETn6xoB4f/1oz7/9SjvvE+aWtG/cOapM/ie913GzCMIb/CBDHYB48XRu7758VflIw4c9tSvX/BcHCbUCsRBUIappAJtZQu2gNKtD3UePFFZdZtSdsXMBU/kZA0Qd1kOc+OJbfWAT4arroaN8ruTQr5vXV/M2XJsGvAAqwHkTtMWbHsZQoRxp2aWdFRmMjaG5xJHJQds6LjrJ1ynqY7DovpR53Scf8NpIdjV1r2sxOozhBNRtcDGRgGC70of123Cm0ysYngMn7thA8SJMNRUaHOC0wn28eM1puzSUfbFxiTxDd22u5Kla0HbeVG3xcF7WBZfzLjzm9nJn/4VORFnhXv+V74zoxEGwkQfvju3RZ4Ts80B/9KljH74PEyyOnm7DGG/OAxs0nF8p25GF1bYVraVsqUZMWnNtSImHBQ2KXBuwJTR+azDX2wOHOjTl5bzzJanIo7zYmYND4ZjkcB37PNhOsotg2lC+hRJCcmtfO3LW0cP0R4qBucTFDGq3hh487OYNkXYmugSoZkOF83qLMCHRQ6iiYr3PzrIHolehCKunyvYGVZq5rNuiQtHWaj+fjpEdZFUBk9CaTWYq6s6H4cBPKdIBnHIMHWf64Hr4nB0PYF9aiUbp/xvPXRoLLaNYN9kKC7ejrh8PcN82+vwAfx2BlV77+rdHlODex5b5bn7ru9fatfq2+yoFcV++DxotiWK1aajLsrT8rkOKDf+4R6XrH8XIkZRFkLGDVLbyQK9UaapSoCQZNiou0LnBMFoWnZMyRDCgqn487V3WoxgopJUxphm1Y2sB6Xa2rnWfcTCiu7IEZnrAkUI6kKoDSRpvT0QbxYFbDqLL23aC3Pw9pIu2pEYyMoOV+CBIxYjaLO2yU/+0zQqDJmkP+TWZAL9dpi5p7oDCYr1DhF8huHGSc1sRYC2LaVYDpFfyyqZcomrItStig4aURt/v3zY1KJBL4ggW8I0nzebErqjxyzTwIqJAgBNa4UfJf6+XdqtGzf55y5UVIb+xt5yzRN6LoGY6DrJevYyxDu8QOxG+XB80K4I9+g7XC//yFN/TbdkexdJCt9Dpczw8HYQNUiECSWDAZvE94ajEmkHFl0JfWYgmslHI9JIVfd7Xbooq9o3EBpAxfrhhA0y1WNGputhY0Uo0NaRjKZPliiiVgTCVGjRjLa1s4BbpqPMWjiygqvI0mw0L1iOE4Ulxrdj9nHOJZWEVIh05Y0jWiTyCtZ048biyoiblxwc0UgFJZUa3QHuciYc0e24NYKP0vYWx0xSCkUvKGsPMuNMFJn4xSq99JETklTOk8/jmv5sObgWwm7eiZr0N+RIWxP9u8KHGP2sR3LPit+/OyhMAw7n9qdpscriH3w+FGQInlLTx8PtO2VRxlI10vq3/kIfv4N/MSMOqYK28rOS/1USphQj00/r4i1JQLbRXC5OrOzYLw9We2mLWa0YlSI2vfWQHoY0/WclTA2oybEgphF4g9E97O0gc3gaMqBIVi6wTB0VjJxJYzObtwrUZ3B9IowjWSjSacBvTHYDRI0Mjsdk+FQpkypzOhaggQ6Sw+kTBiXiFGRoiFeO+zCiDzjvQ79uEJFJUbf76yYjc3amMYpkUmEIDKFPhreWx2jVN6VeGZc4ItR053XHL8H00961JAgJHJK38XPEb7G82/tzsjrGUtRZQzKWtK23zWWLHnbfH3FsQ8ePwq2pYsZT9aQdt9vU+Lw5Iz66wrzhbv0JwVkTXKSdSQrV+rCZ/FxSYriStNbMYoeektRBtrBkTJjTd3gzI2QTjESn7YoTNxxPQobd+dJNzhiVOSkcUVAa2m+9t6ybkuqUrQyAJLX2MqL2HBSpN5AmYhKvFdymbGXlmIhZUkSvR5ilXckMUBU0zuxcVBRQQQGTZgC0aI2RvROC/GKse/WDIdJplRFpr+q6KnAZFzjUVr8aqwVy4XLTU1KUkptOR0gPJjgDdUjy+xDj1kMYJ7JKJ51+IPv2ffIKe94Hs8tQW59W56Vn/xeey6vIPbB40XxnGrUtrH2jJr2FjkRzy5wbYt77Q7DnSn9oZOrq1Gk0cc2a3Z2DLrVJOXkJBuDxLY/sO4LDuqbvQ6nI2UtuxxdsKz6YmySalIWNbCYpCzRmv9/e2cXY8l21fff2ruqzumZnrlf/og/rjAmzoPzApZFkEAoUqQk+MXJCyIPBCIk5wGkIBEpDrzwSKLEEZEiJCOQICIhSBBhRYkUQImiSIHEWMYGHIIBg22u7/Xl3jv9dU5V7b1XHtbaVaf7zkfP3J7pnpn6S0d9uk7V6d11Tq1a67/+ay0INuUtBLX05dCQU6AXZdi0SFCkKcSo7O/1HAL9NtqohBJojgKyESQJaU8JrZOJrmHRaK0IQxLCJpg3tTIpvhQzmCW3lK4QXhjIJw3NXzR0f94StyAlWg9Ul6FLU5CojAcdcT8RYqZpCl1j4dbRZk1ssrU9SHG6rtNBxzNfVtqjZJXNo13kIoJOn9OZqtndnzuf4ZsGWN9mn/nzfzpDFliMx/mxQ6KdqrAFtLhRqYOgciYfHCGbLd0r+3TveIHtu28w3mhIe8K4Z8IqSeaJtEfCKEKONgwpNMowQNeZ6GibjENZN4mTsbNCMDcStcdGGzPFjUiVqqsKm75FRD3TaNV7WoThpEP7QNhPIDqLrbrE0LXoYMOc2kPrTyIZa/SzV8yrUEvZjvuKrgplEOMo1jZhjpOGvFbyzUx3s6dpMkPf0n69oTmWiXSlGAeUOxuqrQR0BEmBMgZikwmhcNJbs6AQ7ZyXYt3FSgmULDaU+tVEPBmQfrQxkfHMqITbfqbn9B7uVnX7lGIxHveDqZhq5460m+I782XSMVFuHSJHx6z/fMXqG97NyYs3UDEVKKrE3kKakAQ9CRSJsJ/IKZJ87EHKNtler219SlpHFJ26Zg0pIrFMhXOrNnHSd2SXqRcvitNi74NaOpVGyUMgrqza9rCs6LpEaIoRnbUezP+tvC5ex2MtBzWZUdGmEG8m8hiIPloy/uUt73/hNb5+fJ3XXr6Jvtpa2FPPYGNp67zyrutRCcfRCgmDovtW+QumFSk5WE2N4gVy1YBYVufa15T2KCNjNuMBnLrcdz+b3SzLWaNwN6HYNK/4HlW2TwkW43ERuFMzGR9PqTnAMCL/94/Zf+MdtO9/O5u3tQz7JjRLe4KMEIsQUkMeA+qNdLrVOLnnR9sVOQf2VoMJyxxpjGyLWMbGQ5Y2WsblZNtNF52EQhOVUSL5OqBCXGX29gb6vmHs7SItQ0R6r5TdU7o3xIr6OnWyQ5BBKHuKtgWKkDb2VcojhFUm/ck+f/Y7NwgjXPMQp3pbpTXdSzwWjt9TaDwsyiszRLoudNdG2tZm2Qyunq2eBmQzhAXKGFm/3HD95UTcJGTM0A/QNhDb2cDHCPeSj9/OOOyiKkp3RWNPMe5pPETkReDngXdixvyTqvqTIvI88B+A9wFfAr5bVV8XEQF+EvgIcAJ8v6p+5uEs/xIxfdF2SNPd9N2pL9ZOA6GXv84qF8L2beg37IEIzRa7kwcnI1MgJyHvCVsPEXCPITamx8jZyutjtOxBEyEn04ccH6xNzdqYmO10RjIjwLWbW3IONnpElK7Lk6ej2URhea3IRuifV1avCfEwkp8fIYuRo6sMo1UCyzqzf3PD4Sv7lOOW1YHQHptnkq5Be2Sal+FZ+z9Xr1vfk+tfDQw3LVOTr2cLeZpCyQFtMsPYMI6WYZJQKGOgJEGL1ceEWw3tATQnmdAnE4XlDE2EMaHlTM3J3TqA3ana9k6/361O5inAeTyPBPyIqn5GRG4Avy0ivwZ8P/AbqvoTIvJx4OPAPwG+C/iAP/4a8FP+88nB2RGDZ2XPd7mDaS6UV/+C5viEZw7fSf/ufU6GhuGGkDsrT6/kiuSIbiJlz+TcqkJOYXLXXWdmy6ljHQW0jzAKuTYkupaMkASKy+pzE+i6xNHBHv3GeJHYZlarBDd6+jFYPc4bgfYImo1y7SVh2LSWohWlJAt9UNBN5HCzbzNfig29Wr1mdTySvGiwEavzKUYWj2shdz77RW0/1PZhlRkHGyepPtOFElE3VgDSB9avBq6/VGiOR6TPyPEGVUWKPQgBYph5qvr5nRf3ajf4lBoOOIfxUNWXgJf8+aGIfAF4D/BR4K/7bj8H/HfMeHwU+HlVVeA3ReRZEXmXv8+TiakxzA4xV4VIUzhT3N5YazE9Okb++M9Yv3yd1XvezuE33WD7XKAMGCGJ0Gwsc5FTJF8rpOTzUYZgw6hFrSCtKahftPj8WFExs6+gJ43ViahYX9CoDCr0RyvoA7KXER82bQYqengSzCMYhfGmUKKlmMNo+pUgZhymhENUVAqyieS1KVLzygxEyBaWDM+oNUxqjTSVbDUzubPaltIVaIqJxIrYYG1AB/udUifaWZq7PYTu0LQcMiZ021tqNgT7OfEV5/AS7ve1+yFcn0DcF+chIu8DvgX4LeCdOwbha1hYA2ZYvrxz2Fd825NrPKpOYFdteLbT1M4XzO6C2QRm255wfMwzr7/A3vvexubtHf2NYBe/mpAsboRyHCit9b0orVrYEM14aL9zNy7WLLgOoZJkfEJZ2+/xKJD3LQ0ryY7TPpA9NOqBPPos2hHGZwvjDUw7lW0fxGe0dEagxm0gd2L/ulrpvhTr8oUav4GYoWhObGYvgcm45bXN8NXG1GdxlckHnaWLaz9HH6ytYuKz7o3A6nVoj5Xu1kjoE3J0YiK+EtCUkaYxruOt4HYE6h0+16cN5zYeIrIP/DLww6p6ILujF1VVaq7v/O/3MeBjAGuu3c+hl4M7xbe1r8P9tOHfLeUuGR0G8tdeoXn1NZ55+wsM732e4/euya0wXve799ru9hogXQcdvKN4dDKyyJQVKe084iHU9oHbMKlApXfPpWAdyaNCH63BT2+Nh2X0YVbXE7qNplNpFLk+wmEL2bwb2dosXt0GM2j+NQijcRoyYH+3c1VtAoITxAMMN5W0p9CoNTpuCvnQdTEi1oZQzQASoDmMtEcm749bZf1GIW4TZEUPj05L0WMwKXm+DZfxoB7DU2wszuJcxkNEWsxw/IKq/opvfrmGIyLyLuAV3/5V4MWdw9/r205BVT8JfBLgpjz/eHwiF1kAdeZLqMOAjgn9yp/TvPIqz335BTYfeAfjjYb+mcCg4mlN6G6JSd+9NF59Ol29ScdeiNtISNbJvax02o4X6eU1EJRwEgmDz5TpFIodF7c2rCofN7SHgeKRjG4CpVPzhorxFRmrfdEMeb9QVoXt2wOIsPeKt1/0aXphYM6hundEdC8KLCRTsSxOFsTDMATicaC7JTQnTG0OujcSshkJJ1vjlXNBIhZChmDhjAhv+oLdrxF4isOTO+E82RYBfgb4gqp+YuelTwHfB/yE//zVne0/JCK/iBGlt54IvuNOBVC3maT+JtzpNd8+1UqoNbLRzYbyZ19h9fLXWb/4broXn6N/rmH7bGC8aYRim+x4jbPRqNPrNBhhGQcY900vZYI08SK2Wh0rNQpBgxAGe4hiXMtKaV8L5t1gj7wyQ1Gl6aGXSTxnBicQN4EwwvZ5JW6FMFp/Uo3meYi68rRlrsx1owSz3B2ZjU7sheZox3AkZX2r0JyMRsa+fgvVmi0qSINlXcAIVHFP5kEMwFPc8OduOI/n8e3A9wKfF5HP+rYfxYzGL4nIDwB/Cny3v/afsTTtF7FU7T+4yAVfGu71BXpQIu7s6zt1E2UY4Y/+lNUbh7TvfQfNX7rGcBRtFox34lOv4ZCklE4su5HtopRsRqQ9dEm5N2hutkZYlsjEoUgWb2DkF6yrX6VY2nYiSxNzqCRMHEcYjCOhBJqNhVesPNtS7LWwNS6mtNYJvX9uykBb6IQbDp/9G3uZ7HUYLfVb19cewer1RNgmGEYzFMW8DRExi5nnVLq+Fa+hDn/yz2WpbTGcJ9vyP5nuLW/C37jN/gr84Ftc19XDrpL0onAvg+PZGj08JBzfZP11obsVGZ7tGG5GxmsWbuy2PgyDj39oIK9tJGZIZgw0Qt6DXDsLRJykBEWtC5oLuSSa6lXUjMtEgqo3ABqt1qXZiF/o5tGIukFw1eysUtX5b/oDmAeBYz9rmBJcmhFGa2sQBu/GBsRBaU8KYSioCGFrXcusmMcxSdPdKN0udDn357Rbu/SAKd8nEIvC9Ly4rDoGVUrfE197A1m3BBG61weaTWTcbxivB3Jr6VBgagcYezu2egh5NfdXLS1TQduEYOMPgve2kSK0t3wJATTq5EFoFB9uZaHK/Pcs/CGYUVKxzmLxlk7GIK1lMh5hBPXUtEaQ0Y1JmtO4UiBu3Jj4cttjpTkpk0GaDEUxbY11rY/mjYQIuNV5EM7qdt7F7iyXO+3zFGAxHveDs1++R/WlUaW8cYt4Yx/NSnl2jzAUujdGJDeU1gRmYIO2S+MehDfyqa/Vat7S+t04Aa5qrZ3OCCCjZUOaLYzXoT0wsra+VjrnO4ba1BnGG1C8DyniIc5gYVTubCxnacywhAS5qWGUxT5xa/1RJZvnRJnDIzMkZoDiAM1WJw9HagVsjPZZ7PYWLWXKvqgp6U6f1/MoRFWRpjmtUj37Pk+h4YDFeJwfZ1WlddtbxTkNkKaEHp0gIsQo5BtrrLCuWDl8subLUmC4YV5Ge2J1M82xkq4JunYydXAVZ4AcaybGRyvgBGywUKHzWpTGuxWN16G9JZNuo4rEykqd/wBthMYHX5VOyWvjU9I16A7N8ORuHk0RPPQhzM2Vawez2Fs4NnkhvXkdqLIrDtCUZt4jRksH116k9VTXiX/TQef4/ESeupEK58ViPM6LK+CaljduEdcrpE+EdkTdXR+faVGxizH2StO48lOgPXJhWbLwIHh2pUSok+50tIs+jnbh5pWnQQ+V3BqXMe7LNMh7EnxtzED0z5tBiFuhO/C1euNnDcZ75PWcKUnXXLOxhewZopAtbEFtHcajeLhToOnt3LfHBUnFJO4CGiPaNjOnMZXcquk7Sn6LfMcdlKULFuNx6biPL6KOAzoMsGoJm5Gy1xJ7GIs19SkhTDyAqF3opRKTnq5tBsxouPbCa+Hs4k2gnd3tmxMjJku0FGcYXRvi2RHx1CvFVbC9aziKkaMxWTOvSsLWq7dyF7UTO17nEkZ75M4zPWnuUhaSGZJZBBeIfbHm0gEzGG0DKaFjQtrGQouUTChWQ5nb9fRY8MBYjMd5cUXuNuWNW8S2Nd1UCOheIA7Fmi0Hy7yIYgrQrDTJR0H41avBZOPB+Y+8YsrImMrKNSK9Thd8TfFK8tak/q2p4Y1UmbnP4m2OnUAVUFETsWG9W5MTuDVkIRghWrM8rWeMwAxaSEoczJBpsAK7kGta17yQ6mmcPlF+EnYUp6e6p58HV8DbvMpYjMdjBh0GtB+QJsIwUvY7d/ELYVRKF8idEkd2shGWNg2DXbClVXSciVRLkdquzYk9r+0Bmt7K6CUbWanBrylvoShqBiN6R/WQsFL8ouSVeOd1GK/LnPXZUcRW7iX0dozJ2meyNIzQbNzLqNWySWcPa8xI8sbUZ8+V7uxnvQfeetJsMSgTFuPxqHGvL9+9XlelHBwQVx00kXjYU5qAtgEEmk0ieNm6BsjraOFHC60bhaaHtBK/IOc7c1nZRbw6KORuzuCYYMxL6qNnQ2okkKA9UEorNFulPdbp4oedMCWpCd+aWa+R1y5E87CEMPMdNdSJo06/axRCb+uIx64eDWHOuJw6TaYqra0Rblvfci8sfMddsRiPR437UZveaZdhQDcbpG1QoDkaKOuGvG4mzgGAIsRtRpvgMj/1gdzQFqWMJiKbemycWEjSbGy/4tqRKX2azUhUngKBEmD1GsixTgYjrS3rU99bG/tZPPwJgxkAyTWjorNa1bmOsRFiUh+a5cSr/y7FNCQhF6QUy4jk4jqPMqVgNWekXSGNQimU4ekbzPQwsRiPxxGqlKNjYtsaUdhGJBXiyWgx/giljdDYnbmqT+1YJtVnFEVKmLI0iPEjITmvMJqEvT2p6VWrZNVg3cnUZeQhO5mZXGfSzlkZquI0yqR81WD71FCnpmGbSooqrA4LzcbHMjQQeluT1jL/qlgN4bT8eacEfxqRUVWmbYP2iwG5KCzG4zHFxH2kjJZipGVrrRBFIeZEaQKSlNCI9dbA1Jt4WhcxrkSjGQxJam079sKUKpVWpvAht9VTURiNvwijuuHxupoyG6eq1yitkbfqM3xr3U31NKrRMA+nPnelqPMgpRUKzu3kQu28Ps1nqe0GJVj2JWc73vUeCm8mVRe8JSzG43GFqoUuqw6JAd3rTCchAlGQMRNKIHedGYV6p04+P6YRr6SdsyFxKNNFHt0DSXjWY1Rkzy5+oYrN1Bsaz2FKSEquMnX3VsLU6kSnBkFVNt949W/9n0JSI35dJVsaIeY5XAlDtrBMQFQt2zImvMMzEoOFL1PFcjHjcTuF6YK3hMV4PMYofY9st9Yxq4loWyOFiAZrSxh6GxeptS8qaiXsU7tEQYYyV+eqeSBg3Ekt2w+jWro0zn1IZWDiH7QxT6W4p9JslfGaE6SuGi2NhS6Sdcr8NFszFtUTAozbEEvLglBamXQd2gYYd+paxoQOo3keOZsh9eHWgJ0bWLyOh4BFNfOo8DB6QqhSNlt0HJFNj2xHV18W01+oWipztLt11UVImu/wVeYdkjqpGUjXgvfgEPMuihLGMl3oISurWxY6hHGevVs8LGk3SlrtcB/s8Cy9V/4m4zUk23tKsZRsGNVEYEMxLiQpU8Gd4kVvth5UkTRzGHXerKVlw5taEN63zmPBXbEYj0eFh5Ti075Hj469d4WaC78DSXNxGIB24dRawqjEk0Tss8nWu2C8g+rkCSBifAXOUWwss7L3WiKOyupAJwVoHJThemC8DrW0vrYDaI/mtKtpSSy9K0XNcPS1Nh/rAFb5m6EQt9mzK7623XNasoUlMaI1LesVtrab77coTC8US9hylXHeorm+R4fB7rwi1oJp1Rn3MSSCKtpGc/ujoDHYvu3cOBknKduTgTA2DDebKTQIrlKVAs1JmfqRmmzdPYNox+fVGeLUhWO1ojcOVTWqxK1f3FGQXMjraJmVwbcLkyisrjEUF4wlV5cW5zyKzkay/vQCOca88B0PAYvxuMo4p7diFbfHiLvqkjIyJjMkYzI1qk860xigayGs7O3VQoDSBAsT/O4eRrvD587u1qXx+bLeFlBUp1ACMcm7Btd45Fmebsfacd2ByeibXombQhwKaS9aU58oE3FrsvVK6JaZIC0WhlF2OtQn8zokhlkYhovEsmWiTo3GWHBhWIzHE4Ky2SLXrhlhWopdtzlPVabaRLsTx4A2gbBN5L0WcRdfVKwDeQyuBdGJRJ0ITbyF4FhrS5S8DvQ3gilIcU7DdRtpZanWdE1Yv26aDfM4zHDkVZg4jxzFNCSC8RmYlkM80zIF2K5jkZwtVEvJyVITiGmMkwGhFGjb2dgsuFAsxuNJQcmUgwPCjX37XcRCl2IajGkIElCHFYUxT89rNkKbgHifEOM5/PdNobgEHjUtSHuUGXZHKnjFrXkt0KgyXg9T4VxIyt7LPaUNlG6ujC1dMA9jKsQTMyBTxgVkMANgKVt/LWUzGjl7pmWHIC0KbZy7i01zdRZcFBYG6QlCFY4hwS6qlGfisHgDUlXrgdGEUxmgqp8obYCsNgulvm+wVGkcioUoKwtXSmvHx0Enw1EVqlV8JgX2Xs+ErOx9bWuZH1XCUIibRF7ZVzCOhZDK7PWIELJ5K+BhUpRJwyHJjMap4dU7XcMknvlqLyHLhWPxPJ4kuHAMXN/QtW96nWKVqBoiMiQ0RvBMSvU6iKbIFM+6iKdPaw2dKUEL43ULV0pjoUxaixWyMadtV7eykaaDhUQaAyX6QCkizXEy7QbY2oJO5K3Nmp25jjhmU5XWrJJ3TVfVKU0LTKKwU+HLggvH4nk8YdCUrGEQzJxHTXum7LoOtaHQfTJPYLC7t7Ux9PCltcZCoYqzvE+I1aGo8RU1o+L1LSFBe1TcUHjndS+Aa06y8Ss6p1pn1WiBPBsKrTNmVQmuUwHMqLiqtP4vp0Yq7Mxp8SdMHdXltKe14K1j8TyeQOiYrM6ja5GUjCjN2d39KUFiRKnPOiEI0tWZDKArm/QU8pxVCV7WnppoYjH3OuqclwYPbYpOozFDVrqDEakcRlGKWLWvGbRC8b+rHo6IzFPuJevkOUyl96XMtSw1HAOTp+9kW3Y9DglyYcP+FhgW4/EkwuffynptvmWdSFfvwkVO3+GjZWRkR/atzc7ckzZYj1QxaXrcZic1LRQJiam7eRiLl/27J3KQTSIfZll7GDIhFQufnJsQxbQbWZGSZ/l5mg2HpGKy+5TnoU5nMHkdxcKvakAWwvTisRiPJxVFracngJa5xgPmug8PBzRGdNVYOOGy75jt4iurBpJO35RQq11r+KEQt+ZVxG02I6KQrgvtQaa9tYUQpgpZqPUwYn+zZoOypZfre9Y+HuAeRwFSRhqm9DLV+AWZmhNN/3uQ2eNa8FCwGI8nFVrmB3hKsyBdCwloPETJBekHdN0ah9BG73hekG0iuLdRNBqRKjKla22/KigrhD6T9xqGZxq6g0R7OJgRyJk4JMqqMVI2lXmyXAxI9kxLKUzjgKNMCtKJ8wArhIth1rF42KJFkVCsO1GYU8/G+RQLWxbe9EKxGI8nFJoSuu2RNV7TUaBp0L5HVisYdb4rixAOTtDODIhUYVlrBsZGQirTxHkv56dALEpzZNVvpYuULrB+dSD0Lt7y9gCEYO8zFgtFAqbDCGJp4qo58fWQXIKuOtft1J6kzmdoNt5Dc3ZCtIZlOnsl9XwsVbUXjsV4PMEow0iIkWn4M5jCdLCOY+Lt+wTs934wg+JhjL2Jqz37YsakFKyjMjuyb6V0EW2E9nAk9AnZJqi8SQhzyf9gsnkNbphyQfrRG/iYAEybYLU4idlouBhs1zCIiLcWqA1DymRApv/XBXISBNXz1QotOB8W4/Eko+Spt4W2rXEH1XeP0UIQ+2W+yJJfoHEmV80TKBYujB5y1AK7XKzloQjxJCGb0fuFyMSN1EY9FSpGZIbR9Bsq4vNXsHRsn1zrkY3nqMSoVHmrexy1wU8dQi7taaEYzF3FFs/jwrEYjyccOgyoVPGX8xwxGmmpPodVMsIATWNGo160cCqUCL3rQQgue/dUqhMY1XBMWo5iVb1GdMY5DCrF5aimgpUgXllr5KmMFvJMRmO3uG0cdzIqZjgkAqGxgU+hmURik2S9NkZevI4LxWI8nnSoYv0A8ymRlNaZrjlbKFMETk6Q/euTB6IweyDuAWjbIP1ola9RpgbEYXDFZ20jEMxglXVnadZKenq6WIY0cRnmaezwE5WvqJxM5TxKcf3GTto1iBkNFaRtZmMBSNeZIQnB5tTmvBiQC8RiPJ4GqM7DmmM0XsG5DgVkAKKnPvvBCuqqoKzshAwi5jX0yXiM0Ez6C7KpPtUl8TKMaNcStsOkx5g8ienCr6FRsf2jh025oKt2aikwtROoytmi82Dr3VGSRVFsNm01IurZlkXncfFYjMdTBK2EY70LB7GeF7jiVL2mRcRCGFVEa+almfpnzCSmTs14pFjZfw05AL+4mS7+aYJ9lafXxsXOS8jue4/umdSq2OpxOKELO4IwmLgP2fGugNN1Lcu0twvFYjyeNmiZZdo5W/8L3LBoQGT2BiYGE+zCFpmqXIGparf2EZXaAtE7mknK7qFgF26cMyzT+ySfJ+vvP1UAZ7EK4UrwOkkKQN+jY/L/JZ8mY2tBXDUiISwG4yHhnoVxIvKiiPw3Efl9Efk9EflHvv3HReSrIvJZf3xk55h/KiJfFJE/EJG/9TD/gQX3gZr5KNkyMX4nV69OBZz/qO39RuMx6rFllq9LLfevr+005iEZ4Qq82aPwv2Xhie9Tn/tDS0HH0d4vGZdyKkzxTumnGhpLmNLPE69SCeKlqvah4DyeRwJ+RFU/IyI3gN8WkV/z1/6Vqv6L3Z1F5IPA9wB/FXg38Osi8ldUl7KkK4fqhYilPKVyEDW1WbyYDuZMTcOcFYH5ru5egQ7jaTm8p1cF9xom3sOVr+No+04jIguMg/EXVcuRXBtSPZtJPVt1Ju69EGcepYZGIpS8ZFseBu5pPFT1JeAlf34oIl8A3nOXQz4K/KKq9sCfiMgXgW8F/tcFrPfxwOMSW+9cfKpGhmo/mIfRNh4OKDRqF3kNAYLrKjSZzL16FhWycwE70SkisF4ZfzGOMzeRkpOZXugWw2Q4KAWFycMwzmbX2xAnSo0HOcV3xDhnk4Lvt9y/LhT31c9DRN4HfAvwW77ph0TkcyLysyLynG97D/DlncO+wm2MjYh8TEQ+LSKfHunvf+VXGNJ1l72EB4LmYhkND2VqqKDbrdePeMp3HE/1CgHMSFTRVh02HYLtW3wcwrafe26Mo4UmgG63aD9MndB0N4SpaxjTacMBHgoVCGcK4Co5W1GN04ILxbmNh4jsA78M/LCqHgA/BXwT8M2YZ/Iv7+cPq+onVfXDqvrhltX9HHrlof1jaAzrhegXrA6DCbJqhkZ3tCLX9mBvjV5bU57ZR/evodf3kGt7SNsirXcwG0czGvVP5IJu+5lHKepjE5xjqYZpt3ZlTG/2OCqq54HXroQweX1Sxy5M+y59ry4a58q2iEiLGY5fUNVfAVDVl3de/2ngP/mvXwVe3Dn8vb5twRXHrohqt4SfGJnmwK5X6N5qR6uBVeTSolnnMQ+ehRFwebuFD3qyNX5kZziVtI13P3ejcTuDcYdQUE4ZCNN31AFQwOwNLbhw3NN4iAWSPwN8QVU/sbP9Xc6HAPxd4Hf9+aeAfycin8AI0w8A//tCV73g4eBsFWqtD+la4zu61pr31PRqMT2GpGyjHdoG3eusLyouQ/e+IDKa+GtSgGbL5ug4+kWvIJ1tHwboy70L2WolbXBRWJ1bU2t4iuk+HgP26bHEeTyPbwe+F/i8iHzWt/0o8PdE5JsxkeKXgH8IoKq/JyK/BPw+lqn5wSXT8hhCjf8Iq5UZjp1eqBpcVlaKDdgOYZaxgwXDIpRV67NlC+y1dnwusxchQtiMJn2/dWjeRxOQrkXWK3TbzyHUKUJWpjVC9DqbMk2I02SjL+mChZC7lbcLLgyiVyArICJfB46BVy97LefA23g81gmPz1qXdV48Lmqt36Cqb7/dC1fCeACIyKdV9cOXvY574XFZJzw+a13WefF4FGtdKOgFCxY8EBbjsWDBggfCVTIen7zsBZwTj8s64fFZ67LOi8dDX+uV4TwWLFjweOEqeR4LFix4jHDpxkNE/raX7n9RRD5+2es5CxH5koh83tsOfNq3PS8ivyYif+g/n7vX+zyEdf2siLwiIr+7s+226xLDv/Zz/DkR+dAVWOuVa+lwl/YTV+q8Xpk2Gepdmi7jAUTgj4D3Ax3wO8AHL3NNt1njl4C3ndn2z4GP+/OPA//sEtb1ncCHgN+917qAjwD/BWsY9m3Ab12Btf448I9vs+8H/XuwAr7Rvx/xEa3zXcCH/PkN4P/5eq7Ueb3LOh/pOb1sz+NbgS+q6h+r6gD8IlbSf9XxUeDn/PnPAX/nUS9AVf8H8NqZzXda10eBn1fDbwLPisi7HslCueNa74SppYOq/glQWzo8dKjqS6r6GX9+CNT2E1fqvN5lnXfCQzmnl208zlW+f8lQ4L+KyG+LyMd82zt1ruv5GvDOy1nam3CndV3V8/zALR0eNs60n7iy5/Ui22TcLy7beDwO+A5V/RDwXcAPish37r6o5hdeuZTVVV3XDt5SS4eHidu0n5hwlc7rRbfJuF9ctvG48uX7qvpV//kK8B8xd+/l6p76z1cub4WncKd1XbnzrKovq2pW1QL8NLMbfalrvV37Ca7geb1Tm4xHeU4v23j8H+ADIvKNItJhvU8/dclrmiAi18X6tiIi14G/ibUe+BTwfb7b9wG/ejkrfBPutK5PAX/fswPfBtzaccMvBWe4gbMtHb5HRFYi8o08wpYOd2o/wRU7r3da5yM/p4+CHb4Hc/wRjC3+I+DHLns9Z9b2foyl/h3g9+r6gBeA3wD+EPh14PlLWNu/x1zTEYthf+BO68KyAf/Gz/HngQ9fgbX+W1/L5/zL/a6d/X/M1/oHwHc9wnV+BxaSfA74rD8+ctXO613W+UjP6aIwXbBgwQPhssOWBQsWPKZYjMeCBQseCIvxWLBgwQNhMR4LFix4ICzGY8GCBQ+ExXgsWLDggbAYjwULFjwQFuOxYMGCB8L/B/vP6JjZpXjBAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cle.imshow(scipy.ndimage.rotate(np_array, angle=45, axes=[0, 1]))\n", + "cle.imshow( cle.rotate(np_array, angle=45, axes=[0, 1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`zoom()` can be used in the same way. Also here, `zoom` factors are provided as `[z,y,x]` array, or alternatively, as a single number for isotropic scaling:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQYAAAD8CAYAAACVSwr3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAACT60lEQVR4nOz9SYys6Zrfh/2ed/iGiMjhzHWq6o7dtweCFEm7QdKwF7YoAZI21MKWpYVMCQR6IwE24IUJb7TxQtqYkAFDQAMSTBqGKYK2QUIgYMiULFmWKFMUJYrdTfa9ffsOVXWq6kw5RMQ3vJMXzxtf5qmq7nuqu6u77qn4AwcnMzIyMjIy3ud7hv/z/0sphSOOOOKI2zB/2E/giCOO+PLhGBiOOOKIT+EYGI444ohP4RgYjjjiiE/hGBiOOOKIT+EYGI444ohP4QsJDCLyz4jIPxaR74nIX/wifsYRRxzxxUF+v3kMImKB3wD+aeA94O8C/1Ip5dd+X3/QEUcc8YXhi8gY/hTwvVLK90spM/BXgT/3BfycI4444guC+wIe8x3gx7c+fw/407/TNzTSlo71F/BUjjjiiAOuefmslPLgde77RQSG14KI/DLwywAdK/60/Nk/rKdyxBFfCfy/yl//4eve94soJd4Hvnbr83frba+glPIrpZRfKqX8kqf9Ap7GEUcc8bvFFxEY/i7wHRH5log0wL8I/M0v4OccccQRXxB+30uJUkoUkX8d+H8CFvj3Sim/+vv9c4444ogvDl9Ij6GU8reAv/VFPPYRRxzxxePIfDziiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hWNgOOKIIz6FY2A44ogjPoVjYDjiiCM+hZ8YGETk3xORj0XkH9667a6I/Ici8t36/516u4jI/0FEvici/0BE/ntf5JM/4ogjvhi8TsbwfwL+mU/c9heBv11K+Q7wt+vnAP8s8J3675eBf+f352keccQRf5D4iYGhlPKfAi8+cfOfA/5y/fgvA//8rdv/SlH8HeBcRB7/Pj3XI4444g8Iv9sew6NSypP68YfAo/rxO8CPb93vvXrbpyAivywi/5WI/FeB6Xf5NI444ogvAr/n5mMppQDld/F9v1JK+aVSyi952t/r0zjiiCN+H/G7DQwfHUqE+v/H9fb3ga/dut+79bYjjjjipwi/28DwN4E/Xz/+88DfuHX7/6JOJ/4McHmr5DjiiCN+SuB+0h1E5P8K/I+B+yLyHvBvAP8m8NdE5C8APwT+hXr3vwX8c8D3gD3wr34Bz/mILytEXv28fO4K84gvCX5iYCil/Eu/zZf+7GfctwD/2u/1SR3xJYMIYi3iHHiv/zuHWANtowFBhOKsBoMaICRlSAligpQoMerXQyRP081tR3zp8BMDwxFfPYhvMOseWa+hbSitJ3cNubVkZyjekK1QrFCcaOu5JgtFBAQkl+VjEwqUgokFSfrP7mckJMwUkRBhDpQQIEbKMJLHCXL6Q30dvso4BoavOmo2YE5OkPNT8klPOumI3pBaQ/aG3NyUCNlCMUIxUCwkL6QWshdMLFBAMiBQBEwCiSAF7FwwUYOGpEb/z/o59X87Z8ycb4LGMCP7kXJ1TdruoORjifIHgGNg+KrhUBY0DebslHL3jHjaEXpH6g2xM2SnBz87IXWQGv0c0P/rx7HTg08dWGd/cz8pIAkSkOu7zETBRA0YxYCJGizIYMMhcNwcejuVGkTAhIy/GDFXA7y8JF9eU2I4BokvCMfA8BWB+AbTd8jZKfneKfPdnriy5EaWg58aYT4RcqOHN3v9JwXINUPoCsXUrMDo/UQTBexcg0BNMCTVQFIDAdSAEUGSYIIGiwMLRopg5vrYBUwsuD24qUCxzKcOO62w0x38xYj74Dn56poyB0qY/6Bf0jcax8Dwe4HIl/uKJYLZbDCbNfnRXaZ7PbG3xJUhdkK2kFoIGyF7SB3k5ub3yY0GgUMg0ENeoOiVHzQQSEKDhNMDf+g5ZHcTCIotlPpukyBIKcR1uQkaBUwQ7KhRpViNNnYSTBQkgduD3xpsKNg7Dvdwhd9G/PMd8uKSfHVNHoYv99/kpwTHwPB7wZf4DWhWK8xbDwlvnTGcN8wnlnmjhy71QlxBaiCuCqnPekBtobjaJ0gCuaYD9dAXKUgwmFlI6wSuHuwMEg1mMsv3F1sPt4AdDLkrSBTMpIFD0MBRfMHMNWNZZdIKfQyfkSYz7x1Sswq7N/grwW9Fy44zQ7O1+HOPffeU5sWIe35Nud6SLy6PE4/fA46B4U2CCIjBPXpA+OYj9vdbwtoQemE+1X5BsTDdzWSv31J8Xg444RYPwQBGA19xGXxBTKHMhSwGCQZyoXRJR5WmkNtC7jL4DFH0MQrEJmtwMaIPXG5KC/0B9b8m145lvSEL0ulkwjSJ6BvSShiLBpv2pRDXghsEtzeE9Rr7oMcN9/Av9tiXW/LzF8cs4neBY2B4U2AspmuRr73N/lt3mM4swz1DONE+QTgppFWm+AJt0mwgChINTHXEGES/DvWqr9kCtsBstEJIgglCOk1IkyAZ7TDaGhRcDQoC4jPismYItpCumpuspM2ajSQhWY0S0mZKFAgaeEqqgcIWMmBPAqWAtZkYLOPXMumqof3YYmZD+xKaK4MbDeHkFHnnhObyHv5Hz0gffnTMID4HjoHhTYAI9nRD/s7Xuf76it1blvGe9gjiulDuzhifcaJX/ZQMORpKttpUPJQPyE1AsBogJBqKR6/iAsxCEf3c+EwuQrFANEgfKZMFX0AKZTaYJmGkYGwm95EiFmzBdZEUDCUJ5iRoT2LWr4mPNYMxiNXgUqIhTRaxmYSBLJQstHcH7n9zx7OrNdc/XuMvDW5v6V4U/K4QVx327jus3jvDfP890vX1MXt4DRwDw087jMU9vM/0C+9w9c2W4YEw3SuE04Q9n2l8wpiMqQEhzI48W0rSjKH4yiGI8urVPGlKX0xGbK35TYEe5MMWGSxJwLaJLAKuUAZ9O8nO6OM2mZKEJEIugmsjtBHvEzkbRArZZ5xL2sdtIjHqc3NNQrqCtfrc59lRsj5OjhpQMELOwvXY4n1i/XMv2O47dk97pnuG7qmhvSjYuRA2p6zu/Cztb3xI+uhjSkrHAPE74BgYfsrh3nnM7o8+ZvuOY3ggjI8y/u0dvSk4pwdwni0UIWdDmg3EWuAfMoMslC5rj8FqoDhMFqRNlMkibcKYQtfP7B9BmS1wc7ZKQcsIgD5jfdYMQGCzGZlmR87aw8hZf75vIiJgjX5fiJaT9UgqgpXCMHmMKZQiNE3ESCFEi7SFMDucTziX6JuASCFlw7v3Lsh3L9lOLc8+PGV86uk/MjSXhe3bDXH1Dutf86Qfv38sLX4HHAPDTytEcG8/ZvdPPGb7tmP3tjB+c2JzPtC4SCnCFPTPm7PRq+1oIRhN00Wv6MZn8mS1F+DQK3GS2pCsBAUpiBScT0sZQjDgMs4nihXCVYNMhrJJdVIhiM34JpKLYG2mbTKNS+RyExzmaJlmh7WZrgls2pkheMbg8D7V5y90TUSkUIDTbiL2BmsyIVm9vQimBgeRwnfuPOXxyRXvPTzj4vSc/j1L/zHsHzjyH3/EiQjp/SeU6SgS9Fk4BoafUri3H7P9k++yfduy/Rqkbw/cOdkTs2GcPSLoIa61eA4G8ZlSKs/A3aTR4jPGZYwUYnbQZET064ervnWZeXQaFADpEmIzpWYBGG7KEikYo32FGC3z6Gn7ADbjbFoClpY4hpTAWc0adrMnZ8M06X02q4n7mx27uaFzkTEW1n7GmsyUHA/6HXO2DNHTWg2IQ/S8mFY4k/mTD9/n6dkl/3D9Dtm3dM+BYpE/8pANkH703jFz+AwcA8NPG0Rwbz1i9yfeYfuO5fobwLf23DkZECmMsydnwZhCTgbfKAfZurRcgUUgRqNXWVMwJpOzwZjaR0AP9zx6xGesyxibSckgoqPDNDqMh1wEYzLN6cS8bTBNwjWa4k9jQxotttM+RwH2U4M12rSkZg0i0PrIygde7ntyEc5PBjoXsSbzaHXNhe25nDrWzczaTxgpnDYjMRuMZEK2bOeWTTPRu0BjE0P0XIaO82bPP/Gt9/i19i3231ux+kjIzlLsQ05KOZYVn4FjYPhpggj24QO2v/R1rt/VoGC/vWXVzcSkmYIxGV8zAzFFr8RNPHw7rQ/kbGhcZI6OxkWsKczRMoyaaaz7CWcz14eNyQLeJ6zNDLuWNFlsWw97EUQgDB7bJUQKYdJGYSlg2kTXz8SoQcXbhLOZdAhERQjBcr3vGJzXCYYUvNVpxhA8z8c1uQidi/Qu0NlILIY52Zv7m4TxhfN24MwP7GJLZwMxG/ax4UG35X/yM7/B/7f9NntO6Z4Je7HIH33ERoT4gx8ftzlv4RgYfopg791l+qNf4+rrjv3jQn53pHWZKThCsHRdwNu0XP3PVwO7qcGYQowW76M2IIuQkyVnQaQQk165myYxjZ7tvsVabV6GYClFu//z5OvClJAGS961lC7R3hmxTaIAcXBgCskYxBSdOgaLtRlrtERZNzPeJkKyQKLrAvPkSNFgXaZvZwRtSnZOg9qhf2Ck0NoIydH5wD42xGxxRrOGxkSsFFoTudvsMLUkug4drcn86bd/yN8p32D61VOKEyRZ5OcfsB5G4pMP/zD+rF9KHAPDTwnsvbtMf/ybXPxsw/5xIbw7c7IZyUVISacOIThCcHgfkSIMwemV1kcuJ0eYO5zXOnzdT4RkicmSi+BtwppM8tqXCLNjnrQpeJgeAFqWdFqelK2jmEo4ipa080ibcLV8ydkgNtE0EW8TKRtSNlyNLdt9h7WZTT8xjp609dh15N5mS2sTuQhTdKy9BpGYDdkInQ1czh1zXdmM2bByMwY4ayIxW3ozc9fv2KYWL4lQLCdeXytnEt+5/4z/7lsN5YcdJghb6zDpXbphIF1c/qH9jb9MOFrU/RTArNeEX/w6V19v2D8W5rcC7XrWOh29Ih96AwCt06vx5ZWm4HO0pGApGaarljA5nM3kLKRs8DYxR0eqNf+hN9GvZpo2Lj0JYytbEUhbh5l1ghGj1aakFKzLy8qlMbnumemEZBg94+TZDS1tG/AucXG1UuJSk3E+EpOOQYfgNRggxPq8eheYs2MfG3ahISTLGD372DBnR2MSc9bvP3N7chFCsVi0sZmLYRdbjGS+887HpG+NDA8KYS1cfd0Tf/GbmK77g/mjfslxzBi+5JC2pfzCN9l+rWP/ljB+bWZ9Z8DX7n7OQtuGpVxofCRloW8CpWYLw+zpVjPGFHa5owTD1a4jRq3RUzKEoB87n2g75QUYKViTGaaGFC2mTiHSZG9WrpMQg8W6jO0COWumYGAZc8ZoXmmIFgRnMruhJc4W1yZMJTKlrNnLaTcyRYcVPdTbuaV1Nw3C1kZWbiYjhGxJxfAir+hs5Om8YcqeXWq463ecupF9bgBtlsZiOW8H/sy3fov/PH6bYlvKM+HqZ3ruXnwN/vH3v/L9hmNg+DJDBPv4EZff3LB7bNh/Z+b07g5nE1fXK3JWfoC1WrunSl9O2dD6WBuLerBaH9mPDdZn4t4xXbfYPpKi9gKMFOLk9KA2iVjHhf3JWCcKlpIF2+pEAlMotiCzkGdLX/kTU3CEWXSSsTQnC32rTcdh9lqyZENKBleZkMYUnMlYU7ieWkQKKx8INQMAcJK1h1KEq6nT3kcRQrK0lbthJBOz5eNpw5g8rgaWKXs+njZ0NrBxOtXobeDevS3PLxrKCyGshP23z1k9u0t6+vQP/u/9JcIxMHyJYe/eYfjZB+zeslz/XOTugyu8zexnr2NIWLr949CQs6F12iuIydI3gZQNm24iJEOKlrh3yGwwW0s6V6ZjBIwtykmYLdkVJToB8+Rp2qClgi0YmzB9IM6WvMrQZFwX6ZvAbmyYZ0fTRLom0DeBkCxTcMzREpLF24R3iZi0keh9WjgX99aa/h8Cxz74pd8wJ0sqLSsfyEXYNBOpGO60e+bsuJq0BDhrB+ZsiVl7Jx+NJ8TWsIsN+9hw4iauYs8uNvQu4GzizrdfcBnuYpJh99DRff0hcnWl5Kcvu+bGF4RjYPiSQnxDeech119v2H6jcPLWNY3T9PbuamAfPNf7DmsLOQtxtnTrGWcTrU1cDh3gyPU9fXm1ro+b4Xwmbz1kcM89aWWJTSUnBUPC69JUFqKxy+gzzSoCK6ZgXCF3iVIgRcPldc/JZmDdzcxR2YgbPzMZR+ciQ/Bc71vm2S6jT1NJTXPNTnZzQy5gBDatXtVXfmY7txpQasDIRZbSYLSezgbudjtApxeH3svj/opdbEhFmJMjZsOQPHO2TNFxOXasfOAbpy/57s/DVbpHEeHy50+4+/ED4nvvfyWDAhwDw5cW5nTD9lunDA+F8u6edTsvjcLd3LCfPCkapRZLoekDXROwUhij46wfebZdM+wacm1Oui6QpmbZiZBowFQhlVjIm0QhY7cGiaJr2k5Io6bzpu5LFNBFpsEi60i/nrTHkSyt1+xhmD0fbzd4l1g3KrtWitB3gdZrybHup6XPYHxmP3lWrV7FQ9IR5BA9u9nT1EwoF8GbjJPMnC1OMpdzjzeJfWjwNtFapWE/HTd6n/o4uQgZYR80qHS3ehbvnF5x8faauO3ZPzL0v/gW3X5Pev5JP+evBo6B4UsIaVvKu4/YPraM9wpdF2o67khJOQopGdou6Jgwaa9hPzbM0XF/s+Ny6Bj2GhRcFylA2DcwG8xoKEYl2lS+TT8mClKE3BdKU5tvwWj20GSsS+RkdeRpM/POLSSqcfLVMsJyuhpp61i0FOGjyxMATtcjjYvc6/c0JvKrHz5mHj0lGFI0JJeYol2yhRe7FVNwyy7EAa3VEeRpO/JsWFOAxmomcTl23O33dDbS2IgziTF5huB59+QCgzZUyYaVn5lqJuEk8eDeNU/vtvitYfu2x1+9i1xefSVZkcfA8GWDsZiTDdffPmW6I5THA6Dz+nlydL1efe+sh4UktJ91tBdmx5wM74/nxGuPTAaaQky1NIiCRFENxgbsoCpLqdOFKTMaTBTSYdPSoCvYs44L2zZiJGDqtMHcL8RgcTZxutblqHH29F57G2N07KdGG6PJsJ88ucDgPc/DCucSdnNojoYl4zA165lCXa7y2kT15rBP0dC4yMZPOMm8GFeU2nd4uLqms5Ex6Vv7xOuS1HkHjYnkYjjxE7GYSqvekotwPXeEZDBBd0lSC9uv9Zy//xbxx+/9Qb4DvhQ4BoYvGUzjKW8/YLhvdIW6bhXGaOl7pT53TWBOljlp/d+4RJwNMVjK3mEGg5s1G5C9UNpCqQffTlJVmPXgZ6eai7kpFAtxXfXd6wY1o8HfmYiTY3fV0a1nNv1EYxP7sSEOjriy3FkNGrwqH8LbxAfPzrEucboeOe8HDIXWRT7cnvDyck3Xz/RNYNNOnDUju9gwBM/LfU8pwulq5P5qx6kfl4binC0rP1OKcL/ZEbzBmYQzmcZEWqOZTiyGxkRCtqzcTGMSXjJZCo2N3HGaLeyjlhWti0zBU0whrgQQpnNDfOcuHAPDEX+oMBbpWi5//oz9Q8G/veX+6W75csyGq31H7yOpCNuxJSWjdXw7s3ctOQi2Cq7aSdWWShVdsYN+La6KBo2qu5D7QllpQDhIsVmvI9A426UH4HzURmcyhGhxLhM7pUJfTw13VwPXY8vF0CktuZvpmqBj0zo2fLpf8/TDM8RnvnHnJQArp1nQEP2yVp2L0LvAED3bueXt9SVd7R1sY8sQPd+7vs/PnjzjTjOwdhMxW4xkrmOHk1yDROIydDQ1YJgqMBmyZUyOTc0enGQ23cT8jmN/7ll/r8FOMN1t6buOPI5/UO+CLwWOgeFLBLGW+Ee+yXDPMLwTWbvMaTuycjMvpxUpeB6ebtnNuqHorV4pAZ6+OCXH6hkZqqqzUXm33GYkCGYW4roQ+6IisKkqOEmB0SJ9Wup530TtZzgdUXqfljp/jm4Zk67XI7byD6yo3sKLizXOJx7fuVp4FCs3swstV/sOvwqsV9OS2r+cVgsfYY6OIIUxOMxK+wExG57sT3Emc9YMNCbivPYO/sGLt1n5mYf9NaduIleV2X30jMnxsNvyjdULLsKKKVusFE7cxJBuGJOP+ytyEd5aX3PSTlxPLS+ePsAOwnjHsr5/j/ze+38I74g/PBwDw5cBVd3ZPnrAxbd6xvvC6tGO89XA/W7LnB1GCo9WW16MK067kRe71aJ0dL3rSFcq+2yikFblRoU5q+x69oV4milyo+dYqnqzuKq/ICi1uvIKSmHhS+SsDcJSRPUbk6Fpgy5OZUPfBKbkuNvvicmw3XVcT40GDJPxJvHk+gRnM289eMkYqyZDzSScZLAs4ispC/vg6Vxk02ifYOVmng0bOhdI9Re82+2Xl3FIqslgKNxpBpxJ9GZmSA272NDayJD8Ms5cuZk5Oz4aT3jQbnnUXzFnx0u34qP7d2guPXEl5Hun8P4HX6nR5TEwfBlQCuIs8zcfMJ8Iwzdnvn12rU2yyvwLyTLg6V1QAlANCiFZ0rVHkiBzFWZdHldNXIpRmXjJsrhEYQviCmIzOViwWbMDk7FVKToGS5ZcSUiqvzgODSULTRsQgWHf0rSBuTYaH59e0frIVRYdRQbHeq1peFtHl70LPOqv+Wg44WrsaF2kdZGrsSMms2Qt91dbRApPd2sebbbEOonYhYZchLWfl3FkLgZjEiFbrmPLXMuE3gacSWSE69DWRaq8UKOXMiZ5XDE1i7B05yPFeJIX4mmHEQPlq0OTPgaGLwNEsG895OIbHbt34dHbF/zi2Ue0JvBkPOM3nj/AmkLb69V7Hxo6HxmDY/eyr2aQqHw7KLNxrvqKXvkJMhv1gIh1yYFSNROUB1GCIUvGGCFnMKbQtMo5SNkwDA3UvsGqDcxRmYWnJ3tVXIqW/b5lNzTE0VNGSz7TvoSuSuuher5bcdqOZITd3HC57Yizo+0DzqkGQ+sSu7Hhw2sdc95ZDQuxyVUOQ+8DsZhlMjFnyz56Ohtxknk6d9xrd7qlmXXLdB8bzpuBMTlisYteQy6Gxt+UIRs/cbIauVxtcHshbBx915L3e74qOAaG30/8TvRZYz97McdYTN8x/twjdm8b0rcG/qm3/zHfap/yW9MDnNF15b6ZeLpb46quwcoHAOaTiemqpWSlLGMgtxG5cNpXCEIZDy60ZmE0Eg1mHTRbSAJO1ZuMzbgq6noQbwXo+5kQ7aLVuGpnbF20mpOlc7GubhdeZkNMsvAYchF+/NEdXKMr2E+uT5fAQhHKbIjOqhJUE+lcJDjL+WrgpJl4ul/z4cVJXRiLjEPD6ckeawpvb67YZsvl1HHSTDwbNsqWnFp+IHfxJtHYRGfrCLVmEu/vzrmaOtWH8DNPhw2tizRGA1ljE6kvFCOkziB9B8fAcMTvCq9bgx4CiLHqPP3uYy6/2bB/J/Pzb3/Ez3VPeG++x5A8/+jFI4ahWdSV2jZoNdDesAllsOoLMRskCOmkduCjzuMlHVyoi3IbCpSmkKcaFGzBtakSmAy5Kkw3tfdwEGvt2xlbF66m4OgbDU4H3oKvFOeCsiRPNgOt14M+DI3+yqIblNPsEAHnE6xvehlzdEuT82LfM9bPmyaqhHzNUsbZk5JhO7R4lxb+Q+siY/TcW+1YuZnr0PF8aPFGA+rl3PPx/oTTdmQonsYkng8rDbTRka1w1+243+94v88Ua9SDs2m+UnsTPzEwiMjXgL8CPEL/5r9SSvm3ReQu8O8D3wR+APwLpZSXIiLAvw38c8Ae+FdKKf/1F/P0vyR4nTdMTjf3q/cVI5jzM67+6D32jwX3eMefOH+PZ/GU52HNP75+xMvLtS4xZYP3kVVdjLrYrkhJCINffCDslcGOgqmaBrkaxeQuL+zFYlQl2nR6EEsyGK+sRhEWAhWoQKuSmfSp52ywRvsNjUusfGCKjt3cEKJljkpQci4x7ZTY1FaJtnvnW8bZK/ehbnCuOpWQazaJi33PsGswtuDWI3fXe/bBL8KxzmSkUaLTugncXQ3kInx8vWGaHXdWA0P03Ot27GODM5l95UXYuj/R1ZGl83lZugK40w1aVtQGzWHsKetIMY6wMtB3X5mgAK+XMUTgf11K+a9F5AT4eyLyHwL/CvC3Syn/poj8ReAvAv8b4J8FvlP//Wng36n/v7l43TfMJ+5nTk4If+Rddo8t4+PE/+jrP8BI4Ve3b3MdWy7Gnn410VbJdSPUWhv6ujvRtpFpcsTnfc0Q1DSm2OowBYs3JLNB+oRxmRwNxmWQjLEJV9eku3rlBRgOOwo2U8pNoIjJ0rioitT1ir7bt4S9p5yNOJcJTqcLnQts55bdpHsMX7//kim6RethNzf6uckYq6VMSJaX+54puEUfMmfBu8RpN6m0G7D2Myd3J8bkcFU1ehta7rZ79rGhs5HkDVN0hGyWXYoD1n5e/ChmUWp0UwMZQLeeKbYjtVD6lkXG6isQIH6iglMp5cnhil9KuQZ+HXgH+HPAX653+8vAP18//nPAXymKvwOci8jj3+8n/tMO8Q35229z+c2O/aPCna+/ZM6OX7t6i9+8us/zcU3MhpNu0uWhbBiDbkt6q3yBTadjvJws7tqolf1KnaslqZx78aVaxgFG16vT6FQu3mT61UzXBVWARkuTkLTRd9JNi4z8obcRkiFlYZh1/8BIYZg9cXL49czj8yvOVgMlGebZ8cHVKakId1cDp50qOIfaSByjw5rMpp1w5mbbUqQseyGtj6xaJUq1PrIPHpHCWTtgJGMk01mlR3uT6GxUdqSb6VxgXacOtvZC9kHHut7qpCIVVYkaol82M6+CZhOPz6+I60J2Ql41iLVfiaAAn7PHICLfBP4k8F8Cj0opT+qXPkRLDdCg8eNb3/Zeve0JRyiMxXzra1z+zAnDQyF8feS0m/j+xT1C1HTWVfGVYdQRm5FC5yPvnFwyJqdjuanVJaq5yroHKGKU3rxK2j+A6iwlSB/JwVQjGcFa3WGI0bDuNcgMsx68dTsz1DTemnwznZgaWh9ZtzNGCtupUVHZC0/YCPmebj9+52sfsa1jRdD9hpgMrmpF7KZmeTkOPYVVNzPOnrN+5GLf433C2/TKVXyMjjF61Xk83JYsp2Zg4yeeDht6F9ij5YdB9y7G4Fg1gXv9niHq2Heq+xQpm8Wn4tCsHJPeJ5xk4soynzW0TfOVWah67cAgIhvg/wb8r0opVyI3HetSSpHDpeX1H++XgV8G6Fh9nm/9cuHzppfGYu/dZfzmHaYzYXio2gY//viucghcXuTaYw0Sq26q9X3mcu64HDplGF6u68/W5mJqqiEtVBv6ujVZbqYOronMOz2UMahStPOJ3dCSoqXrdQ/hxdWKplGJ+Hl2zMHRtzPeJeZoibnTg2cyp6uRj1Y9RKM1vcnEqpewHVtlLPYjU7I8360YpoaT1UhjEy93PeNeewvKthQ++PAOzWrmzskeK4Vn2zWn/ciDfkfvVKjlTjOwSw0P22ueTRtO3YSXjFmVJTic+pGroJoLpQjrZiZUyfnblOuQDbu5WRSsjRSupo5NM1HaDGKJG0vXdzAMX4ms4bUCg4h4NCj8X0op//d680ci8riU8qSWCh/X298Hvnbr29+tt72CUsqvAL8CcCp3f/pe6VuBEdAJg5Hf8YoizoG15G884vpdz/6hkNtEqazF1GSiLWAK877B94G7pztOm4n3Ls60eef1vvPoaFudCuyvPbnR7yt9tbgXloxBVtVXwqj/g5KaTGU8wnzdaEbRJrYvV9g20a8mGhe5ul4Rdx67DuTcLi5TjQvY6iu5nz3N2cR81fL0xQn9SpejclEOQu9U1t5GT0y6Jr6fGq7rCvnmZOTOauD5bsU8O31+WZYpA+i0Ys6W+91W1ZkQ1nbmvf05nY2LbNs73QVXc6cbmslxPbdMSVe5DzJvuQgxO1LJTFE5DmPQPsUgXtWismFKDrOKZO8ZzywnqxV8RfQZXmcqIcC/C/x6KeV/f+tLfxP488C/Wf//G7du/9dF5K+iTcfLWyXHm4FPBgUxiFFa8297PzGIc8jZKbvHK8b7Qjgp2MHAWHcaqNwjlzGtdv8PKfe6m7nadUyTr+Kr6h+RY7WEX0ekyarREBw5CWWwC9PxoMAktlCi0YwC1M9yaU56sIVUYBc7Rq8HlKAO00YKvk3LBXMMjnl2hMnRdBG/mRd16N4HxuhoXVxq+KtRa/cH51tSNmzHFmBZ0d5007L74aw6UO1Cy1mvjlPbWZenTpqJp+OGe92OxiacSVxNujh1FXs2fmJOjjk7Whtpaw/ietaffyhvDuhcZCdaIlmTaWziMJtp+0CxPam71YC8nTG8oSPM18kY/ofAvwz8dyLy39Tb/rdoQPhrIvIXgB8C/0L92t9CR5XfQ8eV/+rv5xP+UqByEA54JSjU28V8OniUlJHTDfv7ltizNAlTr8KqNHkxdMmzZQqW0Dj1XTj0HnwiT5Y8OEwfEVOFVtA3sTGZGGsJ0WQlNV2riIqJQm6y0qeTwN6qv23QVexUtRGIosSe2Wo54lUWvutnpkkzlhEVmB2TIe88zclIu4o8e37CJPDR5GkaZWfagw9mEe6sBt1ZiJ77mx1XY4s1ZbGje7y+YhdatqFhF1pejr0SlFxkNzekLMsVHeBRf03MllM/0trIqRt4Ofdch5azZiAbWViPU9Jm56GUCMkSs+G8GygrWRqtpapErf2sDc+mNiDPVojzlBj0PVB3XN5EqvRPDAyllP+MG4b9J/FnP+P+BfjXfo/P68uPUg+RmFtBQSC9GhRKLlAyYrWUSHfWTHeE1BayL5QOrWMLkAVpEsYV0qDko4ylRHWrJgnzaHXsmIWM06v0Wr0fztYD62bmauzIBS4u1pStw20NkkAyFNEsorgag3zBJBVrKUY1G3Kn3hBlrExJV4h7xy4LJRp8H5R/4OrGpVU3q/1eex7WZqbBM+8aZGcpTaa/N6gxTTa0Fq7Hdpk+GJNx1rIymY/3JzrKlMLl1KmcfFWTSlkYZ4+zuln6fLeidzeqzyFbns4bXk4r1n6msYnLWUlS3mQ6F3Am01n1p5hrYDj0E0K2XAw9KcuSpXRN4HpVyF4Ipw1N4ymh5hOlcCNc8WbhyHz83eKQPpZEKVlLhZqiHoLBK3dPCWkawmlDXPEqz0CUynyYFhiTSNEjQWCu9zN1KzIJEgylzZg+4puIR6/e55125l/u+0Va7ZCVUHQNu5gaIKpIixTlPuRWx5y5yVBXss0mILaQ9g7ZObKA7aOyEIM2JONkwWWmyZNny+Z8TymCaxLJQLlwtM89YzRs3rlaDmAqggXub3bEbNhNDaXIkgmc96pQdTXeaCmsGl3WAk3/QxWridbwVnuFkcKH4ymgak1Xc8fV2HHajRgp7EPDppl0W5Wy9DDOmoFnw0ZFY2tm9my7rtlNIp0kijWk7jOm+29gGQHHwPD6OOw6fFZNWUoNEEtBf1Nu5PTKnkRxhtQV4r2ANFn7AFmXoKQYitHewTJRMCCzKgodHJ5Kk7EngZPNwBQcp6tRacmHJaB2ZggesmB3RpWZVqrBIEmQIORVRqJQstKjzWiU87COlNmAz5yf75ijY3vZgCt0pxNdExgmz3TRIV2lXvuaYUxmMa9J1YQmnGi9Xkxht+24aHQ7dBw9fTW2cdVnczu15KKNxjvne+Y6Ply5mZULzPls0ZUMTqXoTxu1nns2bThvBp6Pax1POs/T3Waha1/NDafdyD40TNWa72Cq09rIaTtyNXWs2pn91KjsW93kxBayh/Hcsmoa2O1403EMDJ8Xh6Dw2wUIYEkvD0tTh4CSM2bOFKsy7sYWkivI3uB2usOQ94a8snpV95opCHW/oU1Im5R/MBtCstzd7Nk006J8fKcZeNht+dHuDr0P/Hh8oOvYq6TuUaOhNBnpkwYlqwGoCDrRmJUy3awC19teg5RVNmV38Im4bpdlLFMVn9Kopc/+xUqnIV5fA9NHchQtUazjquvwLtE0iTk4huCVpwDEZNjtW5xPfO/Ffe6tdWnpwFe40+4Z+jqVSXZRjV65mZgtU9LHO2kmOqtq0wD74HE24SQzZZWe631YXLVfjj1t9e4M2dC4RMrCR9sTNu2EXwVS0xB7gUZ/PsZqVnjoNbxhmcMxMLwuSr5pNt3+HF5tRKE9hpLSK/cV5ykp07wYsENLiIY0S/VyEOxeSL2qKckklKbgz6fa5S+sOm2EgabRF/seZzNvby55OmyW/6ds+cX1E65Cx8ZPvNffoTQG2yZyElir7kKqAQADzHLT50iCrKrOZLL6s+/tmSfdW4hBexQHy/s4qaEuSXTCshOlZEdRRSnd8NYgZwvjvmF2anXnvNrspWxwNrFqZ1IRxtGzz6p43frAWTPQ28BYm4cC7CrRCnS3IRb1jDhtR86bASOFs3ZkjHUUnA270FCAk1YZmBs/MUbPi33POHu6uhSmhjdVMr/a9qVGPS7LW/eQ5y+0XDzgDWxAHgPDa0KspeSitFgjkJJ+XoOAOF/vV6cPtdkIUFLNIEqGnGkuYdrpAZMouL1oH0Bq7d9lzKmWCp2PrHxYvBIApuR4uNkuHfZ73Y6v9S/1Klqvrl/vX/Cj4a6m+V4PU9OpHdw0ObKpUwtUxIVQR5mtEqFicBoUVjeU7DA7xOSF5zBNDrC1N2LqtKNWRhbNHARd8vJZ7xZUul6XtlR9qusCfaPNxRAc1hZKgd1Fzy73xGT544/e53ruaKoydsyGlcnM2RGzpbE6FgUWI1wjhakSmuZoF/NeoRrkJuVD9D7yYqskuwMRK2ZDzMq07JrAxUmhuRKGtzf0320o46TvBXg1SLwhOAaG14GIHvJSOFg7iXMQY+UnmJoV1JfTCGQDVsVdGadqd6YZhJ0L/YdWtx8rcgOpKdi395ytJtrq/JyLsJ0bojP1ocvC6ovFcOIm1m4iFMsfO/uAkC0fhVN9YxeD94nxZYfbBLxXjcjSJChqRqtqSXqoXReIkyPv9InZ05mC1vw5qw5kDBbfxMW8VgTKYLFbLX+yL5iaKSRXR7ACrlGx2ZAMee/ITgOKmMKEJ0a10EuzxXUB5zJiVe5tt+v4Oz/8Jk2TeHCy1U3LOnKM2SziLXO2NCYtFPJcRCXpXWTG8nK7YtNP6kgVPZO4RfzFmEIqwlQt9U67aXHZblyCs0D+sGU+s6zaFkkJctGLgrWUN8wE9xgYXgelKKPR1royQbH2pnSwZmk8StNASvrPGP3/9kN5SxHBzGAnpTGDchnyacQCU3A6atw56BLdRrcAT1cj62bGSead/kIXmJKnNZEzO3DXbflHw2M2duKH411yEe2B9pG2CwuFuTVKXBJTCJNbfCPi5CihelTW6UPOhmn05CQka0iDI3cJY5OOUAHJgkkaFIqB6DXzwGdMk7Aua09hUlZjiVUHwkCJhgTEnUdqAzQUoA9Yn9VMpokYU5gnx6XruLNSrw0jhe3ckorQrOOybp2LsHYzV6Jj21Ql9ufqVdE3gd2s9x2C4+5qYNXOKkBbPTOuRt1DubPZI1I4Od8zbhqmU0FON3B9ffM3TW9WUIBjYHh9iB7yV8oDI3rVKLXEsBa8q1t4udaeWQOEtZi2ZTrriGuIa2hf6OITBYoVzLUjAKlLWu/bArNhGjxnZ3t1iK5XsYuw4tzvl8bcmduzzy0P/TXb1PKN1QtWZub53TV36hry7WWhk3ZmHzwv05q8KuS9g1lHj8YlXFWFHkenEnBZ8G0kidNJrNHAkqOqRAHkw7vpMFoV3eZ0Pi3lSElVaSpL3eeAMjidkPiCdAnjlaqNyUgRztbD8nvHbHixWykfwcXldlBJ+IPPpTO5rllnrBRiNctV+zuDNUV5Cl6l7b1VOTlvMk038Wy7VhEctKcTk+X6VBeq4qNz5MOPKSEu5LZjxvBVReUllEM5UdTmbPlyiK9mByqciIhACIgIcueM3dueYsGOIBFsKGSrHhD+yhCjJ7eVVdllpDYFUxFIZikRPhpVD/FRe8WQPNvUsc8NqRieziecuoG7zY4/ducDvCTeH87ZVo2H+/2Ws2bk5bTCmszVvmMykGYVbdGSwSE+KuW6KKU6xkP6ryzGHIxa2OVb/AhXlkaj2KzU7CLMwdVYqY1JQANEVJ/M4gp4XSBLoyVlhzSJptfpwZyFvgnEZJiCU//L6Oh9wFfDmQP9+VACbBr1p/A24YtwPbQab0WJSSFbvFMBWV+XwXIRNl4XqRqv1n6HgMpZIPaW+W5He/g7i9ELxBuGn6jHcITi0GAqIX6qnyAiS/ZACDdlRM6UWVlycnbK/hceMZ0ZwroQV6U2H/VAuR30T6F9Idi9MhtxhfO7W1YnuhKdipBq/WwoTNnq+A3DZewBzSSuY8s2tbQm8Gc2v8kdtydWjsPKzziT+YX1h7y9uuQX7nzMqg203YzvVfk5TK72SYWSNFsoyZBnqyIvwZAmq1f6Sq/OVfvhQO0Wq5OHPFnmUacZOWhg8euA38yYLi09CFWtrpmCoAthUQVaQrK1n6E+mTkLrVdl6eup1b2L0NKYyN12t2RRTvIy0ixFiLUBaUzG24x3ibNuvNGFqOa7L8deRWRn9Qu9rqvvrolkD2FdA/4bjGPG8Jo4dKDF1/IhZcTqYVuyiHrlKCEi+Yb5aB49YPyZh1x/zTOdg0nqHzndgfFeJTElLSv8FsJJVXyWwjA1uEo9vr/ZcdaMnDaDrhhL4aPphMfdFQDbqMHgxE1YKfxgvM877UsAvrF6wa9fvbU05bwk1nbiQXPNy5MVu77hYuiZomV7pUEmhUq+4mbPqmSrHphDnUZQRWFsXfn2GeMT1ifKwYsiC8UWbJtoWnXlVm1HGEtDng3SavlUDnoRoMIypnBxtcLYqglRBGMK5532GTQoNEhAPS3qmHGu6lEZ4WJUWvT9sy2+chVyETqbsJI5a8clmOQafL3VtXc5SPQXwblMagqpFfAeiXHpOb1pOAaG10RJSevJpBOJEiMlZu0rUBuQUVNPRD8W55Cvv8P+W3fYvu1JjWCDVhlVrkCXl3zBj7rIFNfoFdNl+pOpCqlY3jq/4k6758W45lF/xcZODLnhOrY8GU+XMeXBgs1QCMUSqo7hxmrW0dnAys18FE65ih1nTmnUH+03pCw8Otkyjl4l4A8XxVhHm5WhSRLsqItWJkG2dTzpM34z0zSJlAy2CYRg1VMzCd1qZt3NVeFaqdtiUC3KaNTspvZVJAqlyYsmxXl1vArpJsmdkpYSrYsMwS86jqayKQ2Fe+0OQ+HZsFZSE4WYtZdwEI5tbaTzE7tQ7fVMqSSnWDMNAxiszTd9lAM+uVH7huAYGF4TYkTHjyLabGwaDRb185LyK4Qms1qRf/4bXHxnTeyE2AupRacRGdjqYQprFpEVN2qgsIMQvV4hTZsxooYzv/rkcVU1us+3T57hJXO/2TFlx9pNtCbSmbA858WnsViezic3QWF/SmsSvZ35cDpjG1rVcsyG1kbONiMX2ZCTajRQt43T3i2pQ+oKdqwErQMT3Ks5jTWZECxdo/Jzl7tepyDC4mR90FrM4RMHK6gjNwBZt0xLUY6DNVoSeJcYo+dy6DjrR66nlsYmpmS5mjpO25E5OT6ees7bgZWbebjKvBjXyyKVt4mYDU+v13zj7kty0RFmV5WqUjas2lmnGK36T0yjRwr4nZaIWl6mJZt8k3AMDK+JknWMhbeYxpOH8ZU6UypVtsSI6dekn/s6Vz+rQSHVTlVzracqNQchFc2as1fH6VLraxO1Ux9PDakqJzmT+eb9F6y9OkO31ffxXrNlnxrOnLpJexOxFK5Tx5QdH8+n7HPDkDx3GtVJXHttyl3Hjg92Z4gUTbGDI9QdAl1B1slD2waMKeyCgSunnSlTkHLIclQgpl/PWJvZ77XJl6unhDGZMFdFJ3RqcLj94JtJtcvDFph0f0NWkTIpbbvUBac5Os6qs7YxmTE65mhr81EP+y40POi32NCqqxRCYxPn7cAuNozRMVV5udbH6kqlDt3XuxWr+nqnIgyTKjsdPDbsKLTPb5S038SgAMfA8NoQI6/2EERuRpYHGKOZwrff5upn1swndc6fQFIhO4i9kL1mBpJ1xNe8NPitPkTqlGFsry27vsN47ZZ//eQFD5otCcOzacOLec2pH9mnZqmP7zp9kOvcsbITVjLXqcNL4nF3SSgWi47v1nbi2awmK51V6bOz9cCUHDEpLyMHi62KzKE2DjHK1iyi2Y9+kJEmM+4anTpUSfoQLXNwpKTkKO8jITim0S/CryULUrTJiSvIZMGysDKxZVnzPuhRHl7xUJehCprISN19uJ5aVZD208KCnLOjs7XnMPSqY+kSjYuEbBdjnIMq9aFkMUYboq2PXO86XAI7pYXoRslH5uNXHrlQuCkfAMo861VDRCcRbz9k940Nsa+ekVaWujS1tVSY63pBq2fNhkPmoF/3OyUN7dcOc2eisYneaomwsRMvZMU+Nqyd8Gze8Li9ZMyej8IZKzuxTy2dCZzZSgSisLITz8IJXhLvti+1/+AthrI8dusiF2PPbqgSbj5RkuhKde0B5C7hnnmkKtgtSp+mUJLQrgLeqzmMSMG7xGqjOpKdi1yNLdvYMe8azu9tWXUzV66nTJayt5hJyOcR3wfiXP0xikrB5SxYm3lRGYwHtSeApi5MOZN5uN5iKHQu0NvALqoo7ZxUIt7ZRKzeG3dqExOo9OiwPM5uali1gWH27IZGpzIRZI5gzadW698kHAPDa2KpJ7FgZeEsHIhNpRTM44dc/eI506khruSmlS/aQ7BTvcrKjTYC6TbJ6SDoWr8tCtbp9OHlvOIlKxqTFju169AtHgtD8mQjnLk9VjJj9qyMprxnbs+J0QNgKYzFMSXHysz4RhWY3zYJS2ZYNaQiPL3YYF0mRZWPK0kwjW5i2uFmtyO1OnblwmOSMF07psOvfWfm9HRgNzXkbNjS0jehUqoNc7SsuxnrdGRZJqsr4E3SacasZYT3iXm2NE0iBMs8+qUEUNKSXuVbp2SlzqpgbGMivQ2EbMHNjMmTsuGsHbkYdfJyt91xNfcY0bHmhI4u5+AXqbcpWnKuKlgBJGZyugkKYuSNixHHwPCaWNiMJSsjrk4mAEQE8/ZbXP6x++zesmppVksF6pvJzJohpF4/lsPtBxGVQ6laIPaQq3HMNHh2fcOl7XnQb9UhqfIYnLmZk93xe7wktqkjFMvGjlymHi9JS4h6afcSuU4drSgZ6FBuYGBlZt6xF7j7if+ar/HRi1PEgDWJiCVNFv/cvRLcJAlmMFg1tCbc0X6D7CzlZcNlMpgmIagN3Rgcoe5orFoVie37mWFoCIe174M+RZuUbRlV5yHVXoM9eGsWoXeJ825gjB4ruWpAZpragzEUTv3IlGop4Q1GMmNVhx6TrzsW9flno2Sy+vhTNco5GO5CC9O8TKluL9C9STgGhtdFuTWaXNrwtQ59/IjrP/aQ4b55RSUpOzgUxNmizbWCyqrlOvuv/2vtXsmAm0LcZOj1YDQuLi5L99odD/trehvY2Il7fscjfwlQD3nPZerJxRCKlgov4xpLwUtiLJ5QLF40qLRGBV4uU4+VTGsC9/yO03bkYzlZjGnLbDDXDrfVEWVqdDKh3pgHHkPtP5gCp1H1HgZLioJpE8OljhPFZZpeU/Zc9xhyp1d5s8rEWd+WvlW7uzDrNMSYTFN1HuZoubfZs51Uy/GwDBUrRwHgYu6JxdAYDeAbNzMkzy42nLYjU3R8sD2j9zqtmbNl08xM0XE9e9btjG20JzPOXh25LEg69EeKjqaPuxJfYVh7Q3JqW7AGiRE5P2P7Rx+xe8sujUWAUCcRVa0N0GmD0SVDSlMPlNFAcVimyh7CnUR3b6DxEWcTJ83ENzYv6G3gzA3sU8PKzjz2F/xC+wQvkf9s9/N4Sdpo9Bfsc0solqm4RdnJknmZ1tiDjDqyZBi72DJlt2QYXe075CQa/5LSllOrY8rcFNWPqM+5GG1MHta2SzK6bh0Fv5lxLjMWgSy4NhKjrboHhqYKwR5GiNvZ4ZpE14bavDT4VjkFzqZlqzMVpUk3JrFN+pyv506zgOTYhaZa3TfcaQYlR1FwUjMKK7iUF6+KlZv5eH+y2O4d+hBtM+NsZpw8XQDmUMsHpcabtiVP+Y0SazkGhtfEkiXkrOQlHLz9iOufO+f6Hafpf4OmwIesQLSvUCd/GgREJw9Q+Qw1izAJ5pNCPCmYTeDeyY7rseXuauDnTj/mj6w+4DKtOLN78OAlcWIHEsIur/CSWJmJy7QiFMuzsFmeuzeJj8IpJ1anGEAtNyY6Exizx5nEkDzPwoarqIcr1d6CdRl3PjG/6Cj+JjtI51G3JF1hdTawagOX1z3lR6ptEM+UzRg/WpEK+F3tTdCQ14VLryl68dr0y0XY7rXxGWfLQENKuquRomWelSzV9zPvnF0yZ7s4St3pBhqT6F0gFsMuNmyndhFkGZLHiBrd3mt35GJ4Mng6pxyFLLJkGkZ0L2SfhdPVuNjaAZiJm2W6lNERCm9UUIBjYHg9HEhNh8WotiHVkeT2a4awUU1AE9BNw6hlQWnrpKFmmoIGjOz169nphEIyymnIQj4NmAJDcJz1I4bCB8MZrYls7MTKuIXR+Cye8HfDtxlSw71my5i1TNjTVKVlZf95SexLw3VSI5ZtajWlTi0nbmTKjuvQEaoKUszKC+hWM/vLnpyE05ORFy87sivLpEV8Bgfnd3ac9aOOD4PFFSVp2cmqTH0NjLe4V9hByNcn7M8z+/sT33n7Y1oXef5ig7GFuPWEvdPayhXyoa9RS4/eBebZLqNaODAeEzkLu7mh92ERkt1Hz1mjjZB7fseT6QwnmSxCYxJz/Z0frq55sjslRYPvo5YRh+wmWprrQplmHVUvi3Vv3t7EMTC8DsRg+o48jJi+Y/5j3+DZH+2Y7kLsS6079cBnX2XhrZJ07NbQXGhdDnUSUeri1HDzOdR9iStH8ZYXO8/+3sDJauSyUn1/ZvOMVZn4te3bnDjl92+sSqfvU0MyRkuBbEnoIX+nvcDU0uFlXGnAINcxngYI0KnGmBx3moGLqFf8d88v+d7QULKw3Xe6kh2sqkxVr4nTkz3D1HC97fXXyEKhBoFZlnFmtjcB8tB3cXswk2EwDT9o7urrkwwxaBZC0NKDWZDJUFa6a9G6yNNhXanV8Hh1xT56rkKHk7QQq3oXlgZtLkYDQRGehzW72PD19Qt2seXptKku4mqMMwZH00ZOqlhLqO7e6dLTv4iUaVr6CmIE07akeX6jsoZjYHgNiBFoWyREyjsPufjZlumONt9MAgKVsSjErioYRSiz1uXhDNxWsFPlA4W6I1FHk4tgi0FXmNukRjGoPuFubng2aGnwxKk8+i62OoozlpWZF1mzfW507FgFXPa5qQ3IFVN2i7jLYUoxVWm0WAwbP/GovaK1kQ/2Z1iTOT/b8fL5CTkZ1YNM6ppVmkIcHZesSDu/6N+6k0B+Z2RsW+wkuN0NyQtqmXV4YbNKN3RPLfO8Jp1H3CoSR6clymFKkaomJaqm5EzmcugWotOYXD34OjkIyfLuyQVnzcjl3DFXIskuNjQ28XTc0NnIs2nD2mmzce0nnuxO6Vyk83GhRgPax3CRq52leVEFag9M11KOzcevKkqM5ItLzOkp22+dMp/qASkCaa10ZtUkKEpgmgQTtFTItSYPp4WylYXclB3QqKy72wthXZt3TUFcQVp1lQrJctaOPFpdce4HhtRgRDvlrQlYVPnYm0QrkRHPz3Qf86P5HvvUsE8NPxruLt15L5mM1CUrgxcho+SfxiRaE3nUXPEPXzxWCXqoKkyJKL76UdRNyiCURjC9dv3z1iMm89bdLTyAD57coXzULP0Vk8BMoloUmWUBy45g1qL7EC4RRW3zpJYOknR5rTgd1V5PDc7qEpShMGfHEP2iyxCLMh1TnVTkZGqpkMjF0HgdZSotXHsal7PyGkKyrHxgiqpveT0q9+LF9ZruueBe7MjzDGJ0uzYl/fwNyhbgGBheGyVE5GTNcE+1Gm0AuRRiuGk0StE3voks5YKJotqHWbkJJmhZEToNJOEskZ0l3Q2IyxifsTaz6mbW7cymmTiva9bPpg1GCu/0FzxuLsh1zJiKoZXIe9Mdzt2eF2nNz7QfYaXwq/t3aE3k1EaG5Jmy43F3qTP67LkIeiAygj+k3WgqfrntiLNDTNFFqSwUVxtwprB5uGMc1CjGmKwyasHywZM7yLXTycE6468MRSCeZqQR7KTOWIdRp52guRBSY5lbr9lCk5UmbdUPgyS4VWSYGjb9VD0iPKfNxNXUVel3u2hi5iKMybMN7TKKfDZuGKLnXqe+EIcNzDFqE7K1ZlnJVmcrXaRqbeJFNJw8Kch2rxlCiZTAIXr9obwnv0gcA8PromSKs8tY8ZAG20mQ/Q2hSWnQGiwk1r7BLOSmsh7RskEyTI+jNtbWkfXJRClq5np3rW5Ou7nBdIVYDJdB+wxnftRmYmpVkkwSGzvSSeRBc83KzPzW8ICXbs0v9B/wM93HbOzEXbfl1/ZvM2XHmRsIxTLMDWs38WQ448Ww4k+e/5hQLD/Y32M/e+6e7nn64gQRON/s+fBlR1plitUDu9+2yMetXtEzrC6F+dyqq90ohJNMWmdiX24mM/YmIGQLNurnRdDM6R60pxPzvqHU5SrjE3m25Cw0PnLaaRPRSOHl2KtCU9VWOHAWjOhYUrkNKvn2cHVNZ8PytQNCNuTQELKhcxEnmYR+PFdB3vii4/SHE/nqRutR3xdvXlCAY2B4fZSCTDOmcg9yq2/y3JbaNxB8fc+4PSzWcFTeQp0+ZA/JqPjr6t4eEdRPIWu3PSbLWTNyp93zZK9qz2Py3Gt3nLiRWKwGBBMJ1Wqtk8hl6gnZsvEj77YvyQjvzfd0SpEbrGRi5Sv8eLwDwJPhjJWbMRTWfuZXrx7zmy/uM0fLNDa8ff9CNRKAcfZL01CiQDTYZ36xujv0Etxe1ZzIuhwWZyGuq+XdXh22clMo400nPzW6oZm6QtMHJRIVkF5JH3m2mDbhG+V1HNasrRTEpqWkAIiVQupItfcg2lMxGiTmZDnzo05fajlxaGLe9/r6DtGTi/DW6pr3t2dcDB3rH1raH31EGoY3NhjcxjEwfA7kFxd0L95m+64lN9pPOMCOdfQYAVFas9QrpCSwQ729U75DdioGYqqoqa9OSVrvdtxp99zvdlzMPRs3sbYzd/yelZn5eD5hY0em4gjZct9fc18iyRku44oPpnPOve5MvAwrcjHsYstvXt1niJ7eBc5a3Z04cRNPhw1OMr/64WOmwbM5HXBVLSkHQxkcl9FgqkQ8oO5WQOoypSmEVpfIJOlqsuSb393tlRFqZihO+zOH3ko5LG0GNdyZBw9FFpm5OOuCWr+a6RudSMRKWx6CitqCLoBN1dfy4Eu5j83y91n7mW1o1e8yO1ZO1bavaiYWs6GzkVjyMtV4Oa2wUrh+tuad7yfK5dVNo/ENLSEOOAaGz4G83XLy3UuuvnGX+UyvjCYIJlf2YgsHlVBJN4xGEzVwHPoOxRUkC9e7jrMTtZgzUjhvBsbkFp+Eu+2O3gZaEzn3e0K2XOaed9oLzux+oTV3MnOZ15zYgY/LKReh59m8preqWHQd27p6rCawc7KcNCND9Py3z94mJlP9JaBfT3Rel5yG2avU2sFxr83YnSWt1fcy3g80J3M9vBByg9uaZeqiNGYhSyGuMpIMcZ0xs/pnHvZDDmxQyYAp9OuJebaqPTlYzFqdsbZDS2pV71ENZPSJHcqCWAy+CFNygDZOWxdVLbr6TZy1A9vQso8Nu6AS8nda9cl0JrGf9XZQuvYQPO0Hns1vXpGvtjdvhjc4KMAxMHx+/MYPeOuk46NfWhE2OmWgaBYQTvTAA9qDCCzTiXCq9wunWnpkX+jawGk31U3ARCyGh92WD4cTXlae//1mq1uEksnF4k1adiMOsm2gOw/vzXf57vYh26g7Fc+nNffanZqxFFdHeYaYLM+GDfvgSVm43vZs1iP3T2/MWrv1XhWkVz3J6pSANpMOIi3nkb4LtD5yFfpF11FVqXQBzG8NZoLpQcbcmYm2obSJ1AgyWvxWeQ7ZaRClqFvWqp0Z9hsVaRG9PSWDq94QqbpMZaNOUyIFogaIkFTwdaqGuEP0rKrq8xA9V3NHKUJAD33nor722RCz5bQZeDasD5wsLq97Tn8I9uW1Sju+oV6Vn8QxMLwuqjdlHkfsf/NdHs/f5vkf27B/VK98dSJxsLdPqxuZNjPrYTFJiOuCGYXcZ949v1Sx0WxJxdA5XRFeOa15extY2ZmVmXkynwHwnfYjHtgr7tkd78dzLtKKtZl5Mt3hw0nv05hYr5qaVp/4kefjGoB1E7BmojFpcXsOyS6qy70LDNGr4atJvHX3imdXa+Z9A6ZgTwI5CnnvGJMwDCvcpdWN0Sy4QcsoDmUVUHzmwd0rXrg188tOtRuaTNwI/koDaWoLuVelpDFUCTkpOgk5CMfkm75EzAZJZdm3iNW1OhdRIpNJNCaxDw0hWc7bgbWfF2l5fS1m1l4nFrkY9rHhYlKiljeZffDkD3rOvz+RnnxEiZW6+YYHBTgGhs+Hg6V9KcivfZ/789d5+qfOGe7XN3dflLRUS4XUFrIrSFTjktApu0cAWUXO2mF5o46Vgegrl+BAT/7u9iEnXrvwXjL37Fb1Forj1OjtP5wf8Bu7RwzJs48NsegVdU6WH+3uqNdCbbRZk3m8uuKj4YTGJB6tVGR2zo6NmxiTIxo9iPvQ8HLXM49eD2kypKGa2BaQ5w3NVgVpTBTCRhesTKiTBqt9F//S8fxsTTkcyixgCrHX18OOOuItttA0KvKCKOVa2oL1CV/Lm9ar4/aBCm1qcJuiW27fzi291yDbOd0ePYxgXTXcsZKZYsMkjik6vE00Ji7bmd4mht2K9XuG5r2L357ZeDAzPhrOfEVx602RR5UiMd/9IQ93I+O377F97JnOhbCB4gUJ+v9ByMQOQlkVUpvJq8LpqTb/cs0UmvrGvJh77rdbTu2Ml8ST6Qwr6qvYmsA3/TMu8orvTm8BcJlW/MbukS7+FLMQmcakV/3LqYEGpuiWQ5QR3llfcDFrc+1nNs+4CD2nbuTZvGHOesiAxQG6FGF4uuKgYC3R4gYVbTloSlCE3CrPQbL2YFLS+0zPekqTa2alVnTcmQmdJe0tdlLuQs5CrBmDGA0KXRdoXSImzW5KDXCqA+lIVcnJVQ1IAG8Taz/TmKiuVFXFKRdZTGlS7Uect4Oa4hbhbr9f1Ka3H21450eJ8sFHv32WUApLE+YNwk8MDCLSAf8p2lZzwF8vpfwbIvIt4K8C94C/B/zLpZRZRFrgrwD/feA58D8vpfzgC3r+f7AQeeXKkIcB+cGPaZ98TPf4Ifufv8/ukSP2VRvSQG5q+quihBRnSCeJs34kZkNjdW6+dhpsrNN6eMo3V7FUhF1s+Ub3goQwFr80Hr0kHrVXJFSA5GDyup8b9qHhtJk4awes6AJVYxJ3m33dKTDLYz9otnw0ndKYWEVOBMmF837kSmCKVokbSVQ+/lqbkuGkEE8yzUtdHU19wVYBF0lC3NTdEVeWZariCmUVlduQtazKrb5G+8sec+mUAXo203e6eh2jBoSuUR08NaxVV6o7G7Xv288eZ/PiiL0tLa3VHkRjE41Ny1hzKq7azwXG5BiTTirOm71OJMae7olj9WRHHsbf+X3xBpYWryOKPwH/ZCnljwN/AvhnROTPAP8W8JdKKT8LvAT+Qr3/XwBe1tv/Ur3fm4FPvgGqSEceRvIPfsz6Hzxh/WHE7Qt+V7BTwe0Kbl9wQ8Ffgb8ySFDLs42feNhuF+l3W5WZWhN52FxXazbdZTCSuUw9/2h6m13W0cd17mhNWBajzv1AYxNj8oRsGYKqEz0f19rHyIY77X75GSpnZpiyptbXseU6dDiTOW8GXUKqHf9xaJCovpMyGy2Xqk6lezAwPUxL6TSfZ8JJpji138tOuQ8yG8zeYHcGRotrEnRJM5B11LLihaO5MNqHCYa+CZysRrr6v6nGvADW5sW8RnUdEikra9HbxL7+/o1Ni9zbmJzqUMwNcy093CH7yI59bGhM5OMXp7QvwX189Qf6Fvuy4CcGhqI4zGl8/VeAfxL46/X2vwz88/XjP1c/p379z8qb6Od1yB5KgZwouZBfvKR7OupIso7fihVSI4SNLHN9MuqzaNLC3/eSeNRc8aC55k+tv88/tflVfmn9W6QihGLIxXBiRxIGS2afW57M53wcTtmmG5GVr/UvedBuudPueefkklKEi0G1IduqiGxE9ysA7jY7Tt3A83nDL24+5Gurl7zVXS1aknNWG3nrMnI667LYLOSHM/OdTLGFcFGNXiqHobhCcdqENAltNvbVaarVDMKM1Sl8Vxemrj0yWg0KszZyGS0X234hfw2zr2WENh1XTagy9yw+FevKdehdYOXD4pfRmMSpH+lsZOVmvMmcdSObKqV/sPDrrLpmp+ctzVWBj5/zxgk6vgZeq8cgIhYtF34W+D8CvwlclFJq35n3gHfqx+8APwYopUQRuUTLjWefeMxfBn4ZoGP1e/st/qBwiG+lVFm3W2+YklUgNmbCRhanqcPSUfa6E2AnFgYhwHUl2EzZ87JuVHZm5j/ff6dKsOnSU28nnoUNY/bc99dcxpXWyaJB5cDwu+d3DKmhtRoExqqMHLJddA83duIiKvEpFltl4AyP/CWXacUlfV3WKgzB09jEpp8YXWKXDPle5t7dLc/zCXlvsdfKUjLTYc3aqrqTKaR6GTFNIs/KfJTJkjeJvPPgc3WfArsz2PmWs5XAtGuYB49rI8ao5mPrR20OztqwtdWnAlTVyYruTRymLkP0PCtrOhu5Di1DVCakoXA59UtQ2HjN3D7ebnBbg98X9R79SaXCGzi+fK3AUEpJwJ8QkXPg/wH8wu/1B5dSfgX4FYBTufvT8aoeZti3ew239R+NQXJWebYqoCTxZkZ/mNcXp4s7h9Xo1kYywmXocZL5jy7/yKKncNATOFjSXVQj28NBOIi2WDIvwpqreKNzeB215Fh7XcueosNVz8sX80oXqZLjOrZczR0Pmi2dCexrVGuMEon2s0eAdTsTVpamUR1K2yRiFJKA3VrSqixr5XYSnTrUJSgBDQJZMwqp2o3N6cQ8eMyFw+3lllaFEOvbogwO0wdd/XaZ7djWABGwpjBHu1jaA4zRM0ZHSIaTdua0HSu13NU/mZYPh1EnaAZ3UJXe7lvMLHTPqiDLbRiV+CsxvNGchs81lSilXIjIfwz8D4BzEXE1a3gXeL/e7X3ga8B7IuKAM7QJ+dMNY29SSjGIlRuxDms5CMMWX1Wiq4u1lFpt+AMTskCbaG1kG1p8q49xaIoNSXn6GZ3HT3XG7uuC0JwdKzvz4XSqfYJSFrGVVISQdaPQmbSM7lx1fG6dBqBQLHebPc+mNbvUMNfGm5W86EOeuoHr2DJMjdrNdUHt55tI3wSsFHxTtRME3YGQqtXgavN1HZEmw2TJ+zqCnHUiIVuHnM/Mo0deNPhrgxtvlqxiX5DBUE4yZh3IWScKKRlSUoPZnM0iQuNtemVKcRCZBZZx5GFU6Uymk4gz2o/pJdTMyvLdqwfEj3vOnkL3g+fElG4OvwhiLWbdQ+7I0wRJy8iv3LhSRB4AoQaFHvin0Ybifwz8T9HJxJ8H/kb9lr9ZP/8v6tf/o1LegJB6q85chED1E7WvsyDOMTzUNWYTb2jBcug3GH3Tt+uZ1kUaG18JCABGqsiKjbQm4o0qMl3FdikrUjGc+wGLbgEevl8bZ4kH3ZYpW/axYYqOWQqd06vpy3HF2s64yvbLxXBddwj+k/E7dC7Q2ciDTttKjY/EYBcfxwJMwXE9tAwXHUSD9BFzlgiXLRKE3BY4CZCMsheDYAejt4uOK/NZ0OxhNjTXckOGqtoN8Vw3T30XadpIzoJzgXH0GFPU7Le6jYdk2XSTBq7qN3GQWzvY7R34ImfNSDyMiE1cRri72HAx93zvyQPa55aT9yLl2Yubv/shU0iJvN0tf/tPvjfeFLxOxvAY+Mu1z2CAv1ZK+Q9E5NeAvyoi/zvg7wP/br3/vwv8n0Xke8AL4F/8Ap73HypKSpo1OH+LDSfInTN2j9Tb0cz6Bgeq/wJK7e0KJ+0t41kpbG8t+2zczMXcYyiLKhMoASpKxpnEVewWVuTLsKK3gTmr0IozibvNjmfThpgtjzbXPB9Wi2hqFuH71/c0Fbe6vAXVTyGbhSY9Z8s+NEyzIydlI+Zs1JzWqfHL8noEA03CngTSbBBbqqozlGxIzzVg0BRKmymrjO8iYXQ0H3nsWNWtam9hehDxZxM5G/pel6RKUdLVyXrECMSk3pVT8EtJkIsQkqkq0gWwuGauEwcdd47Rc9qOnLhJFZ1qqbZ2My/GFXnr8VtY/9Y1eb+/VS5kdTcHSjxkD7yR9nTwGoGhlPIPgD/5Gbd/H/hTn3H7CPzPfl+e3ZcJh6SnlhRi9M0i1lJywZyfMf7sQ+YzudFksKhASzWgSS3kTslKU3QLy+5gkNKaxDY2i9qQK1JHlWXZpQBdLY45MYrXmri65p43AyGrZ0RrI3PWw7vygV1olEYsBSuFq7GtOgaZdTMvqkUxG6zLXE0dL7YrnMs0zciqCYSk+ofWZJzLpDZhN7Oujnczc7SYVWHYt8yXLTKpwnNZJWKXwWXa9Yz3id1lT/fDltTdaGYWW4OpLRw090PlLyjqslRS/oUTaFysEwkdU87R0TeBEJWnvg9+6cesqhL1nCxPhlNWTjdWczFsQ8vHlxuap5bTHybkhx+QD2XE7b+/yPIeWC4Q1i7mQ28KjszH18UhIFhLSbzSXzCNp7z9gP0jT+xrsxF9s0vRsiLXpiOiJfmUHLaoRoCrCi7KzDOs3MypU0PW6+Q58SNrpxLovQ2sqwBsLsLGKjFqYyeuYoezid/YPmQfG37uVEVatqnlg+GM5+OalA1Tspz3I9djS9MoV6GtAiWxiqbO2XK2Hrjc9fRNUgETo828ffDMk4fnLaHN2FOVYD9fD4Skass7q1lQ20ZCsBijPpbT7Ni+WNF8oP6XdhBcFbrJVmnlCISLFnxWOc1DIKo7E1NwOJewRnkYvVdBlRDtwmE4eFkWlLV5+PxApY5Zf8/WqPbjh7sT4o/X3PsNOPt7H5K2NwtlrzQX5ZZnZWU9LlTvNwjHwPCaUDsyblmTLV9QM1uj8mV2Vh3XYm6WiCQBjkXp6PDmve2alIthqvsMrdE+Qyi6Kn0Zek7cpKKtcqMXYCvR5yKs+Fr3giF5fjzc4eW0YgieF+2K++stV7EjF+FBr32DfWy4mjpECmPUCcdBibqxibHc7B2IFPXJnBq8zYuQaxotNoLJhiSeQbTu7xrduHQ2c7ffI1KYkuPFbsX2uqNcNiqWa/S1MkGTg+kuFKNTDZKoo1VtYpoqFpOTqX6S5ZXJgqnMxkNgCMkuPZVUX6tUBJMNKz+zcvOSieVieLI/5ePfvMe9fyjc+3vPSR98eEt3wXDzx0aDwqG8uH3bG4ZjYHhN3E4bP/VGyBmZAs02E68EEGKnmYMcfCqTKjeVPi0ir7aWEL0N1c/BLFe0w0iys7ESklTJubeBKd+MMQ8wkhlys+wCbOeGJ/szLuYVV1PHGB0/e/6M3oaF8nw1tlzvO843e3aT8hZ2panBIGFt4nytW4kFsFJ4vl3x4GSnxrN3QXYWiUK6ahh7w6bXJuAcLXe1D0tTJyR5cOAK7srg6vKVJF1JH98JiM+USZmhpctIW81ti7BajwuJKRfoq5fk4fUaQqVDu6gLa9U011eK9N1+v2yNOpO50+iuyq9fPuLH/+1jHv+XhfP/6gMNCiEujUZyulmUuv13vx0c3oDe+idxDAyvi/rGOFw8Dr0FSibPCTdMNJeR1AjZGbKXV4xtF/n00XK97fE20/ugy07h5o3lbrESD296f7CUM4lQVDfAZMd16aC9YsqOD6ezxSxGFZMzD7qtbltmw0k7sY+ec68H4tSPPPcr1S8wmb5RpuCh+WjryO/Baqd7EwF2s2caG96fPCUL4jLuwUzXBYbqIHW165aewNPdmk0782K3Ytg3SgXfGppLobkqhBNheKQ9BoIgXebO29cMU8Nw0WGsZgbGZk66iauhY5g9p/2o+yD1uR5+XilC6zRLSNlgjZZbU1QJvJgN97qJEzfhTeLvfvR1dn/nPt/6/wz4X/0R8cWFlovOV8HXWwc+3xpbwisjzDeRy3AMDJ8XB/ehWlceMon89DnNqqPYE6bTBrevozfHjXfljGof2sww+6qaJItv4iEQzNkyJk9nA2d15frQeGyNqj1bisrBm8SpGxgqKSkjvNz3vH16tSwHbZppWSJau4k10yIuK1K4HLrF8v3+ascQ1S7+tB2Z6zajt4knT89UG6G6S4kr5GRJKfHO/Qs+vtrgXCJGy+lq5OunL9nHht4FnvkV1zYTek9uHKWOGouBcJ6QVURs4fJqzWo9YlcRYzJtHVWOwbHpJvZTwxgctgm6VOUjc3RqCJMN9/sdL8YVMVmcTTVAZK5Du9Cjn44bfv3DR3T/xYZv/L8v4Ls/JB0mEEAJ8yf+5uXV/z/5tTeQ8X8MDK+Lz6oj621iBFmtyL2nWCGuZGEAHshN2aF19SikaEkuM0dLW4k5rtbKhxHlQe34MnSLnLmRwsfTyatfj72qIMeG1iQ2buLeeq9chuSIxfJiWOFM5sWw4oMqbtr5yJ1uwNdV5VgnDlN0tC7Cbd2C5Hix75XC3CbEFsRmfD20w67lh1cdvgq5vnPnchGx3fiJ2VjsJtP7SDoXLk979t0Kf2lVr6KPlKjEJbKwKx39aqb1ASPqbG0EWpug8ilUvRnSMppkaTBq30RLH2O1cWqqkMs+Nvzj9x9x+nd6Hv/Hz8m/8Vu/OxbjGxoQDjgGhtfFJ2rMpQEpBnPvLuHn3mH3Tsv2HcN8qjsRblBtAlvJTQu3oQgxGozRPsPB8OUQFAxFxUrrglUuwj42OsKsVu+N0Tf+YfNy4/Qq54yuFu8qN2IXlOS0r+pHKRtdYXZpsY8/pOLeJsaowiWHn2NtZjc37LYdMguyzuStp7RC9onzkwFf15zVV1JJWwe25RiVuPWov8aZzHuXZ8qFWEVC9YtQvTgwPitDsj6XB+sdH12fEKJdiEsrH7jTDQxR9/kOQVOAh6tr3SyNFlOfv9TpzcGe7vtP77H++z2P/otLym/9+NXs4POUA4e+Axybj19p3N6NqGzH5Y1xsma655lPtKHm9tzsS6ygf1Zw5fA1Ybry5JXQNJGrUUeMt3HWDEvHfM5q737YAjSiUu+9VV/Gy9CztjPb2DAmz8tJ+wZO8iKffriypmyUdFS1DA5swNap5gOopFnnAtdzW+8v7MYGYwqxz5TBqa7ltSPMhmeTw3qdVpQktH3An+q0ICSLcYWrqWMXG64n5VvkLKxOpoWDADBHx+6yx/SRe3e2SlqqehHW5sVIpnWR67ldhGQaexMsY7ZLMACWPQjqz3lydQr/aMOj/9+A/PpvkYfh9f/+t3sKpbzRQQGOgeF3hduUaDGC7AbcNmHOLG4HSPWPqPJm+0d66NwA/ho1rtkZdqbgzvZYI4vASq66AIcew2GsduAYzNGRnbB2E7vYch3a5Xl1NixqyBnhcu7ZzQ1jXVfOtVFXCouCkZHC4/UV13O3SNgP0S+iqrEGh1IEtw7EwVHIUOnNJRnSlYfTQNMHho9XXPpI1wQerJQLYE3meqo7G1bou4CzaeFE7KdGM6gmsVppP8TbxIdXJ0yjp+0C21Gbm6fAbm7wtUTYzQ2mrlcDixs2sGxXArwYVlz+8Iy3/9uM//Uf/WR/iNuBQB9Ybz6QmXI6lhJH3MIhWzg0IRPk7Y7mcsY88roIZA7TCCGutdfgBpQFaMFfCemBukVbU25ESZOltRknibnoUs/BZ3IbWrpFqDVzHTvO/MBl6Jay4XLquZw65mhZV2XklIUwK53ZN5EUDcYqWejl9Yo7J3tdJHJB1Yxq6t/YxG5qNHiYTE5C2XpklbB9JF6rAY10CfdgJlx0pCctPAjs9i1TcGzHlhAs635SZWYxrzATrcl4m+ibwGQsIrrB+XLXkw7lhVURlRAssbFsQ4M1uZLE7FIqzMnydFgvmcTD9baWG7pE9ez5Cee/bjj7+090+vCTcLvheGvy8IqB7e0JxRuGY2D4PKic+U82nso8Q84gNUswQmr1YxOrJTwQV+DGunFpId9izDlJRNEG4JIm+wjFsK2+EBuZ6vJVUgJUtkuGMUTP2s1V9LXlyfUpuZYNKSk12ZiMb3QSEmaHbyIrf7NMdDGpD+b11Orhk6KN0mQwLpME/HsNFOirkW9uHaltaYJmSf5jTxFPLBAsxJNEOrNs1iPD1JCSMA4NvomEZBmDw4i+FmF2fPTROZiCsQVj8rJAVYo2IUEp0Q83W7ahYdVOi56lSrVFQjaLN0TKhsuhw73fcu8fjuQPPrxJ/z9ZHvx2uP21T6l4vXlBAY6B4fVxm+RirO5KoONKs1mzf7girIRihVxFRg6uTeXAhDy8p0pVQcqQsiosPduuaVzitBtVzt2poOuhvDjsSjhJN5JkNnPmR97bnTNFx4kfdZEo6jbk5b7XA24KaXTsL3tsF8mzHjAxmYuhW8qHXIT97LGmMAXHfmyIs9X7Z5Vmk6SKztO9TPdR/Xwu6vA965IYRrOi8b6KsMTJcl16cjDYJmFsxhg1jT3v9Tlf71vSzoHPeJ80m7Iq4yYiuGWFWinXh+erpjCOzutC2FyD6hBuxsHbFyse/WrB//qPyLd3Gg5iO6/TdPxkafHK1z7BjnwDcAwMnwe1rjz0GEzXwjwj3hM2SmoqSnxUq7Zb5KZigMOWpauBwsB239J1YaH3jtEtO5WH5lkuQhaByCINb0rh6dyx9hPeJjLCi3HN9dTQNYExOObJ0fWzEikykJWhiBSkTxhTGGfPS9MTa+oes8GaxG7fEmdLGS2mqjhLgrjOqrngC8UZwqZQrB4sE4VwNyFJyHtLXicVkI1GLexdxjeRuxt133pndcmQPN+/vEeKFqkO1zFoJqRNRN2ibF1ijlY3J23iemxpfVx6CrYGAbjZjRij42rX0f+g4c4/vKDsh1oG3mxM/ra4PXX4pCjPAaW8qtPxBuEYGF4Xt64Wh8bjQUa+pIydD/VmXZqqW8mHRaoiLL6WxUBe6QJVzoZx9FhbsGZath+XZmS2dQUbhuiXHYG59h9yDRStjVWQJC/En2tUxDVNdvFykMnAiV6RY7SkaAnBYm1h1U0IMMx6NW76wBQM+TTClcOOugFmR4P/qGpYZjBJSKtCymA2AXnSaeaQRH9xo/2UQ6YwRcf12JKK4UG3ZTc12sOIymMoRrCtljIn/chuahYZtxAsrQ/4mkEc2I/GF7ZTg617FdYHhtkTf7zmnb8fkR8+IYdb2cInS4jPygg+SYG+fb8D3tAm5DEwvC5eeUPcrFsDEGbcLmGiJYtmDblBM4fDIlW5KSeyh2K1aUZRNSLn0tITODD2QL0SQLcxDwKtIdnFQObgh/B8XC9X2etBF6SQQtg2EIw+l0FNaXMUYnTYVdQDOXtoI9fbXr9n8JBEremsHvDiC2US1U4YbsxobXWtDmeaHVhTVLfR19+/1+ec68JYjJb9tqVbzfzgo3v8gHtYlzg723N1vSInQYwaz3Q+crnricFiXSZFg/PqCB6SvjY6edBxZ8yGkJQsdrHv2T5bc/59w/q7z8j7/au7D6V8dr/gtzOVuaXg9KatWH8WjoHhdfEZ0vFi8itCHRIhd3DwW1x2JWqWYGI9TLNuWuYq/upc0qWlatW+r+IjKz8v0mzAYkozJo8tWS3YYsNH2xNiMpz1IxfbdW3WGeLkdNXTFohCaTJmZzBXjnwW8T4xRY/xmbCrNvep7oVLQUyhBIO9dEgQ3CivlEWxUQn5cJrBZ8Rn0tZT1oXcqCS8b/UQGaP2c2rJJwzXLcZljNUG5xQc/WoiZ2GaNDPaT5551sZiimZZuxYp2JoZpWxYtTMxWTXmQceUV9cr2g88935thCcfU0K8yQA+717DJzOJTwaQN2xPAo6B4fPh1htiGVuVrLsS3iwNx1wdrk1k2SDMza0pxQzNc8OMh01QSzbAiiEYHWEaKeyrGzOwCI68vbnk3A5czD0f7TdcbFdLk20/NjiXmEZP18+U0aqrtAcpglRvTQTEqrt12TtSAdpK7x4sxWdolKdwwKG5GNeqBp1t0TIiiDZSTwpl7zCjwUyCmS35VOXdDxMQ7/U1S7EgbcI5pYMbUzCm0PnI1U6NcVLSKYWAblgmTbcyVIUmoAbSKWi2EOvUYkqedOm588NC+1vPiNfX9W/1EyYPv91C1O0JVPqMJuNxieqImzT0Zh1Xupa4MqRWtEwwYAeWQCG5qDPTYVJRVKDkACUfGTKwOpBzYOmwH3QXQja8d31OKsI43ygTHWzdjMmMQ0OeLWNpNFNZJ80CZlGvBiCeJeUBvOjV36FoC+JgJGsmfS4lGMxgqjZCYe7rQljWjUg7Sc2SijYZa+M1rXR0WybLNFuMTwuxKiVlJgqqryCmLAFiDI4YLGIK476hZM1eRAqm0ecsJi9VQClCSJacZeE9WJuZ957+fcfZ90fy0+eHF/n1/r6fFRQO06hPrl6/gQHhgGNgeF18lsRX1WfI986ZTs3SjNOvs5QU2dWAYetUy7D4TlB5BiULvomMwakSct0eDMnSuMhJO7Pys4725nYJCqVoYKCm23nvwBdyqJZyNRAht/ocSeDS40a1rpcsmGCXoJX6UseQ2lModaqXXSGvMsUZ3K6a9m70e8pkoU3kpu4/SMG0iZKEHCwRSHWHwdis/IhocE0kxpvDnefavJgN+FrOIIhNiMmqrFb9JUS0eRujXWjQIVhk61h/UGjevyD9JHu523hFqekzmpC3g8MSMNIbGRyOgeF18ck/fpX1MusN8/2VHvqaERSrB1/SzW120knF7Z5D6RJEIWPJUlQOvWYHegDyUiYA7Ktu4zBrD+JAdU7RUqKhTOofSWCZBlBAoqb3utAAxRT81mgT0VTjXcDtpMq3F9xoVAK/Nh5NENwOgtPsIbXKZwAWtSWZHKVPSJswtpCD7mYYnyhZLedSsTrZqPfxPjGNjd43mBrI1D9igSmUVMVXa6YgUojREmufxhj9Whg83TPL+sMAnzdb+J3+3kt2cGMhcPP87FdPPv6IildcqPRNIs7DowfsHjcq0NLWVWsLsbuRLluk43vtM9ipEoGiIKPVACGQcoYGkLLsCOQsuEY3HOGG4HPYfcjJkIPRJqMvMOvITwVVwV7bajBbex4C/tJiRxWSMbP2CVJXkMrSdO7wux56IoIbITVCPNFMIrVFJdpE5dhkMpRWs4USHMnW0WirDtZqOoHqjJuC8xERmCdPjnVUmW43Neo0JAviNWs4lBkieWkH3LBHqy/gaFl9WOif7Cjj9PvDMfhEybCoO4mpT+LNCgpwDAyfD7dt6YzF3rvD+O4ZYS1Va0GDwkEYMbt6GA+chlyXqKxuWeZGiUPRauOSRutn79NyNbQ2q4lKMngfCcExl8OhEJVcaxMJNP0GZBW1Ps9Cbgp2kGV3w0SQEQ6LXoe+xyFQHJa/clObi5f6PbHTEsPMggl6n9RXYtMs5FXWDMUdghM3Uw7qa1IEc22QDOFa33p5VQ9V1oxGgoCFEuts1xZsda0qt8qnpdWTdbxJEZWjf2bpn2fMh89JMb5a+h2++XP9zeVTj7GMK5c+05vXazgGhs+DW2QW03jK3TPGu66WCoV0YD4WblynRF4pM2wdY5oZmpfVhKUorwGlHpCixfu0lBGH8iLWujxWTwfjbjtPoCKqpY4bi8CkAafUw5ragt/Jsuhlp+qr2UK26iCVbX0S1fI+NepYjan8C4G40q/ng+q1EeRMVXBLvtVUNUWnIvYQKcFvVej1QJ2WZLWHIfU1ECDp70JTMF75C8rLqGcwG1LWQFEq7yHOFiZLeyH460S+3n564ckcmjyvgc/iOpSCOHdrIvUZXIg3BMfA8HlxILqsV0xvnRD7m1pTstbixWqjjqxWa8XrFTmuirL6Ji0z9NBCadTTUUzRNeZSaLugi0OTJy5NN/05ph60krWcsE6/Xrp8GCxAEJrntqb7LKWEnWpgqiWP7nEUTBJ9zii1GfS5xbVetc0kejX3SoEutmYHQDlJ+jNNgcloCWEqbdqX5XYzGTX3zdBcCfOZfr/Emyao/tybQHLoi+RgF7/LZfEx6c9Jk9WgOBn8tuCvwmcf2tssxd+JyPRZtx/+/Lcp1W8wjoHhdfEJbwHxnumOI1Yl5ENTUYq+wZtrVYpOnX5f7AvFFYwDJiE19VAeru6mUEYLvmBcZhq1sVgyOKtjuDA7UtARXyk1hQbi4JYJCEkoGCQaJOs48cCnMPWQHf5JBJraYKwZQfY1OAQht1nVmgej0nSu6GO5ov2MJDrhmI1OIw5GMbboYe9r9zUJkvXwp15/th20V4Gw7JccfoeClhQFQ3FF+w/RUA7NVKvNyBLrN1mdt9pJsCPY/fzZfINP/h1/u699VoA4BIM3sJ/wWTgGhtfFZ7xZTCpabzdoWpypZraqg5AtpE7Lhuz1Cp/qtMIEbur8mmXQZO3gR0O2ygWQmh3kLDquM/UwzVWUNUudHGTMKpJHq1ftIOrTYJU/sEwkrCqpmcDimJXaootRFnKXkSgcKgKZD9ELLR8akCIUCu7KKmch1+aj14+LzxRbT3wU7N4sh7+YmiXZ2pMxkFc6Hs2uZhhQfy/0d0yiU4oaKPX/+vhFX3uyErBsKMh++mzruNuchE+OJj+LyXi7nHgD+wi/E46B4XXxycUZ50hVIt6km6te9of765Xa7USbdkHLiew0DZdJuQ1ppQcR5RndrEQ7bcAVUyhZa+lDQKAeFimyXEWJohyGKJhZD2JcF+wIZns45TcTkqlazGeHHsbCctUuVnsDEjVrEHtT/5u90bJhtGqeM9WJQx23lq7yGA7BSGoTtgYi/aE3Hxd7KzCKZirF6HMqUm4WsUp9UZM2XNXVBy1ngn7dbwW/S8hYM4bPOvDlVjnxWX/b3w63V7RN7SYvXgJvXtA4BobXxSdq0xLCshAFLL4RpYEiotuWIqTuhtOAK9hZMBOEdaE4sPWgJYHSyPImz8FAFUstRptwJcmyEAXolboSkYoRSlt0J0IAKZjZ4K+lTh1qY7PRZiO1iagitZrm5zYvAaHYutsRKk8gysJrOASP4m4apof9CV0zr1f5AFg1siUa3F4wQbSsqn2YUn09C7yiX6E/FM0coixxgVRLByk3I9B6H7cHO2bKdvc7bz3+duzGT5YJn7VFubwPbjMgj3oMX118kks/TbhdJj20ta+gh18Si3claGnhdrULL9roy14ZhbnhRstgEih1+9EXsECw+nVbyLPBDJbDglNpCsVnTeEPvpgZPYi2QJOJrpA7JSo1F0a9LpxewbWcqQ1HUxZfzVLrdaxmKrbSqLM/PH/9WYfvPayU6++qAYq6PCYZCJrBgP48yYdRbVmeB6VekGsTsvhc+yOycB8kaUkkNWM4NCoPgdQOBrcr2DnfGif+hKv4K8H+J/AdDkxXI5/uX7yBfYdjYPg8uFV75t1A//41+0d3SO1NxqAmtoXcaI3s9vq+yY7FX8LGm8lAqldac2ArglKBZ1mu5OX2ASo17bZQXKY0WQ8jeljMJEg05FbZjssB5WbcaCeI/eGKrVkGRTOCwxX5UDrkehhzlzGjwQbIaFayKFIdypnCzYEGyFLHk5VmHQ+BSe9vZ/2diylLKUXRnomEw9gVzYTyTTCQLMgsS8ZC0VXw9jpj5gz5NUlNP2lxavn6jSJ0yYZXaNFvaP/hGBg+Lw4kl5QwHzyl//opwz27cBUOaf5BENYkiPVVPvQistfDXswNCeqwpl0sy8G6fTVW3kEtMwQIsrg5SRRMHRGS9cCYUZQfNOjVOa7LcvVPTbl5/HoQlx92qP9LLRf6sixamXp1PgSEw/Tg0JvIdZRJW29POpU5TB8OE5riWBShoAZM9DEkaXl1aCoegghZf58lABWU3FR3T+wIbsiY6XfQSvgMstJn7kfcHnXeziYOHx8CxW3C2xuGY2D43aDUtHo/sP6tS1J7zrzRVeAM5FaWwFCMKkSXOk2wo2YRqa0HoqkHtRL9JADIEizMYcOwPpYePi1RzN4sS05yuKIWkGxu9BflRkyluNrbsNrrgDrK9GXJAA7NQLs3pL5uSbqixKnaTCy15DjwHXKjh7f0CbOqwizBIHsHe0ORsuxbSP29UltwW1keD8MyWtXHBBLYLMQ6Jj1Aoj4Xg/ZI7Cg0V2CHz1ho+uTV/JXlqM+4yn8mj+EmQ7jxLH2N8uOnGMfA8Lo4vClu6TCUeUbe/5D1uoGvr5jX2kj0uwIH70pbs4JJsJP2Ig6lQXFCPKTqhwZl1pXt3JalCVhsIbXUyEG9surMvjj93O1vPpdcHbCCLHW81AzboyNTRLOJ4iDVZp5UMtQBdjAqU1d7GJLAzqK0gTpyRPTqn71mK3lwN0SkyrOgNjj1deSV8kY5FrLwJyTfLHVB7YXMWp4cguMSRGctaewomFAqycog3r2qxfjJseOtv+nrCq68oth1+N5PrmG/QTA/+S4KEbEi8vdF5D+on39LRP5LEfmeiPz7ItLU29v6+ffq17/5BT33P1iU8qmmU8mFdLXF/ub7rN8baLZ5IRMVATsXtaobwe8LNujBTe1N/WzmykgcWe5rg14Vsy/EdSacZopX4tRB+OWwj3FIq5WcpL2D2KlU/YGGfVj5NqFelYPc8CgsGoxG5T6YoKWFCdo0Paxe273oRGU+sCf1c4k1658Ed2Ex15aytzAbzFhHm4e9Cbl53rmBuCnLc9PeTC0lppsG5u3SivoQB0ak5BvhGzuDHK7kn+QwfLJ8EMMr25G38clJRhWNXWTh0CDxSjnxhvUX4HMEBuB/Cfz6rc//LeAvlVJ+FngJ/IV6+18AXtbb/1K9308/jH31zaQbPACkl5fY777H5kd72suEGwtuOlwBizYj3f+/vbOLkS277vpv7X1OVff9mvF4HH+Nk7GRJZQHFCwrJEqETBAITJTkwURGkWJQpJHgBcRDsIWEhMQLPKAYCREsjGQQIQ4fkS0LCMZ2HnFix3biJDhxEod4ZHuYj3vn3u6uOufsvXhYa+99qm/PTN97e+7tvnOW1OqqU6eqdnfVXmet//qv/4Lto8JwTRrVF7vyUijK4uXEzsLzMAn9rWAVhZu2WYODkoVpWZwLooyPKGnffrJPwSpRy3RJG7mqlB19YxUdhpLDB48wwkgdllOdQElbZmCjenWivyWsnwusnous/l9Hd8vXnFo0VHgNlVy159FKogKgYYDOmZFSgFpfk4ztvcH/DrfqGOIsWjgpIqiRRPDPVdrPSXZs8+s0zl7zNRwxiMgTwF8D/o3fF+BHgP/sp3wM+Am//eN+H3/8L/r5D4eVL1Mx/2LkGy8S/vBpLv/Ri/SHuUq7laugJLuabx9TNm+A8cpMvKUzh5D225W/lPYstRC6I6mMyZqL+3c1rbzK0KtXQiytCINFIN2BvYb4Vbbk+YV3UCOI2eMm3mKv39+yKKH0WYCdU8DG3NsGt7Rntnbsah8PPerYetVEW9QTBqlcjP6A+p61IzV5pLIVwiSE5K/l+pPFSVRiWeZkp1A/rxJVJDtvzoI8qb9idgFAZDedeEidApweY/g54GeBq37/9cB1VS2Q0DeBt/rttwJ/AqCqk4jc8POfnb+giDwFPAWwx6W7XP4DtGN1bc0BPThE/u+3uPrCLdKbXsfhW/cZLgemPcvlVzcMxEtrmK5Ad8s2WgEiNSghWwpRvvi6Mlq1JAvtizOxmFprGN5fF2+EauF1d+RXYoFp38hWZfhNcJAzrxWKxH1o+guSnK6dPd2oEQL1yl+u+pYKNb6DyczLbst5coejNCCT1sch2UHImc+dO6vyXqWtPXjZtGIVI5AUScmEX+efE3AigemVpNrmz9WGLd3GoHwtlitF5EeBZ1T1iyLynrN6Y1X9CPARgGvy2Pn/r56k+ad5h/Cm04TempDNlnB0xJXDxzl88hovfrcNorXNbT95heXRjvRbiO/lxCTGF+hsM3UjVQ0qqkcXe1YJ6G5JxSjCiLMFvWegKDpD3UzgqUrXzm1XeK0gX0jmEGSiMRq9cpj27Pjqhjm5MApxgOGapxyKVRRGYDAnNV3y1+wKzkFlYs4Zj3GwcmzY7naA5pWtQaNrQrjDKyMAVzczYUjIZiRP047M+w5ofNvnqru/i835CzvHQ3UK9XUfMqcAp4sYfgj4MRF5L7AHXAM+DDwqIp1HDU8AT/v5TwNvA74pIh3wCPDcma/8Qdh8buXcSWipFgR3FhkOj5BnX+Dyiwf0Nx7nxXfsM1y1jR8H62FI+8K0b5uaNaAWroeBSmIKuaUO1ohFTReKpkKYbNPF0cBOsE1tebmSVo7o+9U3liuwOqI/lX6G1o0ZN9CPVkVJe+JUb6p2ArTNXTd6gvUL9lgqQ7hLZFAIYMk2fymPlmggOqg57fn/wdvSyyQvBn89501UnsgIcaOsr0/Emxt4/rpFDJXCHF7aKbzchKl5s9UOCap95vV1H8KI4RUxBlX9kKo+oapPAu8HPquqPwV8Dnifn/YB4BN++5N+H3/8s6oPyX+tSHlBnV0JIF134lVJb7xIvn6D1R89w6O/d8De85kwqYX1+xZOx00DHAEn/yjdkbK6aZulhP8qVLp1mOa5v4KH/KmHKsk22b89jNBttAKNZUpWd0SjcueGSZTX7I4cgBy0YhsFLwmJyqdIaxgeaRwE8CqL67DmVat+FGxkLl4TJscsyhCbgR08pQCmYXLM5NAdjDvR1U2lf36DHG1bnwQ0fKBc+R1olK6zzzHEihdJ1yMx2o9/nvbALHI4iSBVvhcPmd0Lj+EfAL8oIv8E+BLwUT/+UeDfi8jXgecxZ3LxzfGEeRIsXc/xFEOzIhHIFjkII3rzFt0fZ1538xEO3v4It94SmS5JnUzVHYEOHuJHewfbsJ4O7Atxo3TZsAIooGbrVYiD1hSgOAStKYCF3x2mxhRGanWk0LOlpBpqTsEiEWW4av0PVTPS9SyLUJT1ezgekWD7iG3e4lBMoIaqGlVBx6mlOcUJaAc4DqElvVJ7jzBAo45DmfIlWVlfz0hpbit9EvNN7J+NpRe7qWAtXaoND5IgVtXIpump03gymLnTvv3wgZB35BhU9VeBX/Xbfwh8/wnnbIC/fgZrO582483v3JcAFKRbGvYQAqqK3jpANlsuDyPd0es4fGPP9pqQ+8ZpKKPd8krql16ygYgajMTTbUyhWbIdSz22YdyJSNKaQqAm4Kr+uCYh5BKVUMuU2uEYhNZNGpLW/D2vbCc2R0OrCGTDQCY13CNm78w8tCgj92oTrCZrHqsAItR27OJwJNcsxZ2ckjuhO7D/Q+7aVdpSF6U7hNUNV2zaDruya8eqR7bJ9fbKgoR6zPgK7iAkzJzD8WrFMfLUQ2YL8/GUVrvqROu0a4nsXGks/LQvo6ZkX67slMMQ0HGEb0/s3Tpk9Z1HOXz7NQ7fEM0ZRNvsIUvt1syxfelEWzOV5eWe0niOnlZ2rmSBIVeUvwCGOUoTldESvitpzwRliqJ1HCxSEAcw4yhMl1qfQnanUtKaeATdobIKMF4WxxC0gpZG89ba81HMSrItNZGs1q7u59ZqA958FWmDg2lYx+pWpru5RTYjenC4G+rPnfdO49OxK/wJZcf5Z20LidWJSBCLTB6iKvxxWxzDKU1zA6Q0h5aDRh92Ur5AWXe+aJoy4s1ONbU4OESGgSs3brH+7sc5eMuaaT94B6ZWPKFs0PGyo/D4VVds01bx2JUDcgXB761sWaoddS2lLOgRAvg5OwCi1jSlCNsayKfe9CVVdCUF26zBA6X+QCtjEYEUzYGFSVGPFso6mv6kRT65E7ojrQK1c5Ykod3XWLoyodsq+88OyDAhB0e3D5epV3Lf0HPZ97nTyOmYyGuuvzVxDIgs/7eXoVY/BLY4htPaHMHOqe0r3b167Hz5ADSTh4T09sXTlGAYDeQaRrpbBzz69FWmNz3K0Zv2GK6EnRRBg204Ywt670MujoPam1FKkDlC8FxeQ4tEaj7vaUDMpmpdruxx0IpTxCGDwrRn4q1h0gZQeo7f31JkX2qHaGE2dltl2ms8hTg6ADqo9VKs7XX6A53pUVo0VFOYZA5IPTsrpco5AzJulUvfGeieO0IOjsgvXEfHUrpgd6M6DqDTLL2YOw04eYJ1iRLmaUNOuwHGQxo1LI7hTq2E9oXYNO3WweczB+oXSAQdBua9+5rNSYRVTz48JDz3Ale//To2f+oNDNc6xktiZUagNB6F5P0W3negnafSYwPqAFIvNpnJnUHuW49Fa6l2XGJL01UAV7q2sL4yJUv60nmEMFB1J8LgFQp/v+GKO0hPV0yurVVdUOsb6Q4d9yh/yyT295VGM9erTD1oN6Nvq62t22a6gxHZbNGDQ/LBwak+N/uHpJOP13+CRwDHtSFf6nUfQuewOIa7tNZ6e5qT53nv7hc0b7zenpX0re+wvnXA3rWrbL/nMY4e79EojPtSS41lSK76vIpS4hMvH9aOTmkOpFipPmR3KMYd0MZ6TI0Yldcw7hv+0G3sWFrbfQSyayCUlGbal6bk5O9TwM0waU13+gPXoZwKdkLTe5xKdcVSpqlzyboA3bY5kpCU7la6u015GrWlhywtuBtbHMPdmIgDkKc//0QefjHV2piTnnseuX6D1bPPs3rzdzG85Rqbx/qKLdgV2HLdHEF6oZQks1/llRYZFG5BcRg4g9KARk8f1JyApBIttFC+VAPSZWp0YDwG2+y5k9okVjgJO2zLyUFUsepKt7H3zFEqvbloZFrKos71CLW1u6wV+/OtTJtBJgN1X7WN/Bp2EItjuAvbabs98YRjkcFptAfn3XtZSTdvItst6+0bQR9neLQzjGHeS5Co9XtoGyatZKdHoaQdpcRYcnVrC1dElWmv5N5+RT7M5F5IvW3a1U1zRqNv2JDaHM4SyRRQ8jjgWc4rjqjiB85HCJM7KF8/uQnHgEcsmdlzhLQX0CiEcTpZKv5e7W5H2j0ktjiGuzBNyUqV94JG7xBwjqUahSw1DOjz1+mvXELDZaZLEenKFbiU9ewLXCICu2qrVdZKdaAvBCWvOPjGDqMSN4m8mreTu4MR/+24QneUmS4FK2E6Xbk/sJSmUK7L64NXSrDyqDEWdacnYm65E3TQOllP+zAjVc2A01mElnvDHUjpZOBwsXuyxTHcjdWKw0unBq9oL6U1WH4XRDwIkq1BKAbIq0AQ25CAtT13Ql43haPcGR+g0J+77W5VIkzQbXNNCUr/ReEGhCGjElp3ZCnlj0rcZqb9QFp52TJaWlAwkGlf6A+cRxGtGax2ZibdIUnh2EZ/mGuqoNE6UUNJF7QAp1pxEJO8t05KAMaZPsJZ2p1iSA+RLY7hLu2uwteT2npPwh7mo9C6jrw2sQHxzWU8f6+pZ3MI/aFdTqd1qAQpcJDvmM5h9N4EUedCTJmQAju8Aaxsmfs4AxXNCaWVVEp0YVUWp1TIV6JeosQjFk8bxEua0MDRbpNd3q04SGuMyr2VWnOU6hQKGzQkNYwhvUp05Idws9+JLY7hbuw0ZawTn6cvf/+E43q0IRxuyfudbYrk5TuoV+IC2gE28FZahSBkez0VqbTpMBmuYG3ftmNLtaM7SpAUeho5qYCRnTmeHKXxE6ZGxEorqVf2wma01ON4xaKlTnGT7e9CXcA2NEk39RmdBRPZGGc6d0axJjmTMbwM3rPYXdniGO7G7uPkIZ0mwnZApn10r0M72wSWexc6IDAD80p4rkEa1Thr7Z+QSR2EVGTMSGfRQrnCj1f7Nl3KLa8aPyGOWp1B1bf0smWYpSylZTpsM9pJjThKgxiqdJtkJKySasTi9KSK0NSKxYwmrZ3YtF+10fSLna0t/9G7sfsp6ZUSbAcTIdECODqC78CcdsFUmFxfEixVIJYSn9amLGvWyqRVqHRkaFfx7BtTpox0tjOtREibmF3oylI4ClapKOQja+H2905aS6wyZSS5YxszoXQ6RiFszdGGQezvqToIrTmsrisb70N7mwJGjPcGBC92my2O4W7sfkYMKaFHR8jhlriKzki0Da5RyH2o0ULcZvoX1Ts2y0g3djCCusGytsExcYZBBIEAeR2qA9AgxCEhSUl7kdxLdUDltcD4CGEyLkSVgfPNGrfe+jxOph3RB2TMaB/aa0VLd7KzHgueUFKmgmuUvyHvdQQRiAFZrdDt9uw/gNeoLY7hvJsqutkSDo4Iez2xC+S1zbCUpPS3JqtUDIZ76Mq7O4OlDGGyTaYC3SY5F8KjAtdzKLoPpaOztDeXcmfcZgvzu1D5EeBEK1U0hMq8LBRqtDkemVpkErYZSdmAQ3+snKgi5vgmbQSy4tT8tQzoNHxEY0D3VrDZmGMotPPF7tkWx3A39nKpxEtNTr4Hy8OIHB4hl/aQSyvbOCk7tmBhuOX06ukEiDdCVYl5VWTItuHWsVYeKLhDUsJoQOBErBuy3AhJSVFtrmRy8FIbJlBYk7kP1SmI6ylM1yJxo/Q3hpqyhMG4B9rHmlJoF0h73U4EU9Wms1LnRVSHlmHVY52TYUfncbF7s8UxnLFJjMhqRT48PLsXzYl8eEi8tSb2HVxZt3blONtYIoQxoxN+dW9djmHIthlD8DDeNvecOVlnNWirXBZcwghHSrCBlw5OirEPJ63rKelKmGaYgvd1pP2O6FhCAR9lysholZBCD0l7HSIZulDTlDBmCvVbZs5MO1fWKm3xi52JLY7hjE2nV4eiq8OAbrbIZiB0AYLzFQpOIICnDERpkULKVpYcDSPQnCtISG6RQu6lbrq4TagYr0AxZwPubMRKoBX8lOBAolbadneULIpJGU3mKHIfqhOSlA1DSJiIjcu+MyohWKokWVC1KKGmEWOuzgT8uSJI35MPj+4vKPyQ2+IY7sZeKY89wzRi/p663SLjZFfY0IhRuuqMIZmyMSYd8dc+2iYszVUOXIoLp1h4nneqHKhf8bOCdGjJ/0vKoNhmTaW3oW3UuFHGy+KRS3IeRIZhIoZA7tyZjQmNARmm5hTy7H2SImL9EyVKIJf3zYg7KnGnQt8hIpy9O37t2uIYLpDlzRbZbE30pbAhx9K27ZWIEq0EsSghq2s6GLWaehX287xyYHoLTbhFo6cJvgkz1PJkcQZS+BNRSGtjSPYHxllApIKMMtn7BjCg8niPCFhZNkZkTIQYYDKHpiWdKE7BmY7mTPy5Il6yXFKJs7LFMVwk0wzbLeytjdzTm7CCjAmyoDESJJNXEUVMfnIsOX1TIQpjInnjlDkLxxKESkTSYGmJMSYzMSvMWhIK2BlKGXKw9GC82jenMjh+AMZSzBkpMxqyAYcq0noeAHXJPJkcY9hO9b3qcY9qUGc/JteWm0n6L3ZvtjiGi2Sq6DAg04RsBc25OYdZ56KUDVzTCwMA89po1ZS0AeqVHYkNcUwWZYQCUA626bSzCkjugqUoDkha05cAgf7mSF5FAxDH5OmCOQUAuojGaA4pZyQUB6WQJ8IQyd3KjpXXntO3S1oxJXtNVRhGGzLzUoNlFrtjWxzDBbM8jMgwIKGU5zyVoBGYtCuVgHYFzSvb+DJOtilpVQUpdOlCflJgUkIuIKF1W8pg0Yk438CGyYZKuw5jgo0SNxNpz4e6pGN9JVMyXHTVoe4UwmYmezdOyBAMHxl3N7qMaSdKqNOtgdtk4Re7J1scw0WznKw60fe2iXKZshTQvrOr8OQgnkS0DzXEDsPUwvaCM2SQnCDZV6HiB2NG15EcokULQQhDEcSlRhqKO4nig2ZpvjmHS6bifDS4o0i27qKeHdp0L1Ky9anC5b2WZhQsQbVGCjKlBr7W6kSHDnfZ4LbYji2O4QKabrfo3try9eybKwQPpaPJoWfvdMzBAD8MT9A+IttEmDK5C9AF62BMDu7NrsK1jyIpgVn1IqtFHp7v67o3XCOIazlgfAVVpisrZB3pSpmxbOqUYVBzZiFYlaJs8JRhO0Ifd9OJglNkdxDFAcxTiPtIV3+YbXEMF9DUr7radZajq5cdVaqAi42qz0gOFvoHD8+nbA5iyojzHmRSpNNKJjKU3/P+qYGbpYIRjsbatFS5ET7gtnR/5lV00hHWAJYMCyggqMbQoo5CWooR7bwhKgR/X21pxjxSUK2VjCVCOHtbHMNFNFXydktY9bNowVF59Q03JT81Gm0Yz+VLua8LKNHbrzNMs2qBWzgaSZdWtiEJdUNKss5GQrDuzt7AxriZvGfCS6UKbKi8A/oOnQtChtCUqAK3bfCCQ0hxfBvnX0xluESs0YL0PlhYBJ38NbO+OpyS14AtjuGCmo6TofExzhTivVrQeafTZK3aJB/6Wjehb1xnQxZhFnJumgjZW5xnz6sVAWzz51VHXkdrugpCGAOQrbmpa3gF7jyYxNKfkhbEmUReOe7lTJN4sygnBwM6w7q3NframRKyGVxJysucMcI0VSxDYXEOd2GLY7iolpOVLmNEV30lMe3oRpa5md6aXKsXhMYSrHm6VlaijJBXJgozz/FtbJ2QL62YLhtfITuZCXXac5hVQyZr2kIDKvb66qF/SW8IVOak9rE5L6d923GLLFJRsZqyYRhTJqx65GhrIOVkE8IkCDrQqi/+/1rs9LY4hgtsmrJvCGl4wyxKKJ2GdpWOTV6pnLdNtjFzrsxJALaDqTolNR5CtjKn7q+YrqwMaCyt2QWMVCVskzmTKTfdh9SATGG24YNhBTqvSjBjRmZs3mWw6CWvxfstAA2kvWgaD0eCeOrCOJm4jFPD1XkOQkQXx3BHtjiGC2w6DuQgrUJYqMHTbBOkhIq3Qodgj3sjFV2ZLdc6HS2dyJUxiXpIH3vSfm/lTzAFpWij4uJmqrgCo5BnrdS5M8GXOWNRya46pdb4FUJNYbL3fbTeiVCZlAXmsDU1kRrpI2GYCEfineaTlUIdg1B0N5pa7BVtcQwX3HScDGcIgoa4m1IURF9Nxsk2DS2tKDTpsgn7iGxzYxQ64UhXe9axiVcwNEMU5MDl2QofIilobo4qKUFbO3ZJFYqKdG0EC4Ec3QmsrNnKyFNCGNWqGqtAFiGvZupRAcZLHV1IjatR8Iuua6xQRtBFq+FObHEMF90ca0AEkYCGfoYz5CZuEotmgTZ15YI/1I5H/ByxqKNrOT+u3aDqG7UwJaNUSraKD+FNWolVRXCWLljk4RtYwWnYru4kRSreIwTv1UjrJitv7eGRaU/qYBs6ix7iNhMLRTtlW8c2IjItXZd3YYtjeAhMp8mUklOCNJvlOJ8nkbJdoWNoJb5KbdaWQvQdqv0MrFRvtBIISkyptUsXBaewK/kmHq1omIXvUwYJNuAm2vtqYCZFJxWrMDallz3dcZS+jDhkwlRATyyy6AzglElJ+z2xpERdRKfoKUVe0ok7sFM5BhH5BnATSMCkqu8WkceAjwNPAt8AflJVXxARAT4MvBc4BP6mqv7G2S99sbnlYcQHSTnpJ7c25HI7q4XTMdaGpHk/YulsxKnVjJOds8FC9aLTmPOs3Cg1EpAys6aIr5R0JOL4Qq4AqInFhBoZ4CVJk78v+hGmQVnk5u14E5tNe+LzONUmfQfIe5EwRGR0sDXITNN+YUWe1u6kgf0vqOr3qeq7/f4Hgc+o6juBz/h9gL8KvNN/ngL+1VktdrGXsZzQlI0VWSwl+8mW+6PZavzTZA5iVs5Un9HAZHL1sh2RYUSmZL+Ptsh2QLZGktK+MwLSujfH4OpO9YocBe0j2gWbZuV9Ebkz+nOJVMKUfaqUElKur1Ebu5hVNiI10rDj7gy8bGoK1sHJV2KpUIiISNWEXOx0di/KFj8OfMxvfwz4idnxf6dm/xt4VETefA/vs9gpTYsjSO4kSs9DASLnP16pMPai4wTFCaQMw2jnlQpHSUtWPbrubPhNlEo4CkcTYTtV0FK9smCS8nlHUwFoMm+Tuh6lT8AKs7KplhF7NGzCZ2nWtCM2R5HWjk3EUJmZ1ZZpVXdkp/1vKfA/ReSLIvKUH3ujqn7Lb38beKPffivwJ7PnftOP7ZiIPCUiXxCRL4ws8wDOxErUMIsG9HhOHQS6zur9+3vWvFSUkYbR0ofphHBbxPCH/hgfApBtqupQ5eoOhnM2DQVLQ8JkTsA6J5sgjEnReUoy5Yox2OMOPk4N5CzzLeM2OwaBOZBoreB5r/eeCy/hLnZHdlrw8YdV9WkR+S7g0yLyf+YPqqqKiL7Ec080Vf0I8BGAa/LYggidkWlKVsOvB8oV3CTW6TpkvUL317uVCbDQu/RcIJWeXFINDcH1GbRVMkIwOXpois/Z+xiCz56YryOWTU4DGGcTsahRgG1+jWU2p51fwEgKJJFpz1eqxkReRevcBK/OLEKxd2KnihhU9Wn//Qzwy8D3A98pKYL/fsZPfxp42+zpT/ixxe6H5YR6WbFGDuUKHyOyv29DWvqubfoSphe5uDkbUdXwgTijL5fIQASKYrU7i3J1l5QanRoMjByNbVkdCOzI05dJVvgA3jhkG3WnNFwh4/MvqPM146gEj1TSakapjsGqNWJr1EXh6dT2io5BRC6LyNVyG/jLwFeBTwIf8NM+AHzCb38S+Gkx+wHgxizlWOw+mI6TaysG8jDCOBr41ve28aGRm9wJaG+EoNIOXXUSZm3Q1UrZr/RWbMd2RS7lyz6S9zryuqvHq/CKPzcMyXAJf7wN3c0VCwlJ2SEiqO4M1ymSdmWEXe5aVKJdcMdY+jmWqOG0dppU4o3AL1sVkg74BVX9HyLy68AvicjPAH8M/KSf/9+wUuXXsXLl3zrzVS/28pYTmqxkKUGQ1Qr6FaxdSzErSrLN7vwFjYqM2mY1FN0D71qsalGu3EymXVaKJsScN1HFVxxPyLk2NZGBzoHL7KM31YRetA+QMKJT53oRHhmUQTZltkUBIVErlYYyam+azZ4oAjY6i14We0WT28CpB7EIkZvA1x70Ok5pjwPPPuhFnMIuyjrh4qz1oqwTTl7r96jqG07z5PPCfPzajB9xrk1EvnAR1npR1gkXZ60XZZ1w72tdiruLLbbYbbY4hsUWW+w2Oy+O4SMPegF3YBdlrRdlnXBx1npR1gn3uNZzAT4utthi58vOS8Sw2GKLnSN74I5BRP6KiHxNRL4uIh985We8qmv5tyLyjIh8dXbsMRH5tIj8vv9+nR8XEfkXvu7fFJF33ee1vk1EPicivyMivy0if/c8rldE9kTk10TkK77Of+zH3y4in/f1fFxEVn587fe/7o8/eT/WOVtvFJEvicinzvk6vyEivyUiXxaRL/ixs/vsK332Afxgnfp/ALwDWAFfAb73Aa7nzwPvAr46O/bPgA/67Q8C/9Rvvxf475gEwg8An7/Pa30z8C6/fRX4PeB7z9t6/f2u+O0e+Ly//y8B7/fjPw/8bb/9d4Cf99vvBz5+n/+vfx/4BeBTfv+8rvMbwOPHjp3ZZ3/f/pCX+ON+EPiV2f0PAR96wGt68phj+BrwZr/9ZoxzAfCvgb9x0nkPaN2fAP7SeV4vcAn4DeDPYeSb7vj3APgV4Af9dufnyX1a3xOYtsiPAJ/yjXTu1unveZJjOLPP/kGnEqdq0X7Adk/t5ffDPIz9s9jV+Nyt18PzL2ONdp/GosTrqlqUG+drqev0x28Ar78f6wR+DvhZ2hjd15/TdcKrIIUwt/PCfLwQpnrn7eWvtonIFeC/AH9PVV+U+YyGc7JeVU3A94nIo1h37p9+sCu63UTkR4FnVPWLIvKeB7yc09iZSyHM7UFHDBehRfvctpeLSI85hf+gqv/VD5/b9arqdeBzWEj+qIiUC9N8LXWd/vgjwHP3YXk/BPyYmL7pL2LpxIfP4TqBV18K4UE7hl8H3unI7woDcT75gNd03M5le7lYaPBR4HdV9Z+f1/WKyBs8UkBE9jEc5HcxB/G+l1hnWf/7gM+qJ8avpqnqh1T1CVV9EvseflZVf+q8rRPukxTC/QJLXgZEeS+GqP8B8A8f8Fr+I/AtYMTysJ/B8sbPAL8P/C/gMT9XgH/p6/4t4N33ea0/jOWZvwl82X/ee97WC/wZ4Eu+zq8C/8iPvwP4Naw9/z8Baz++5/e/7o+/4wF8D95Dq0qcu3X6mr7iP79d9s1ZfvYL83GxxRa7zR50KrHYYoudQ1scw2KLLXabLY5hscUWu80Wx7DYYovdZotjWGyxxW6zxTEstthit9niGBZbbLHbbHEMiy222G32/wFx2a0Ve3B3gAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cle.imshow(scipy.ndimage.zoom(np_array, zoom=2))\n", + "cle.imshow( cle.zoom(np_array, zoom=2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Last but not least, affine transform matrices can be passed like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "matrix = np.asarray([\n", + " [1, 0, 0, 50],\n", + " [0, 2, 0, 0],\n", + " [0, 0, 1, 0],\n", + " [0, 0, 0, 1]\n", + "])\n", + "cle.imshow(scipy.ndimage.affine_transform(np_array, matrix=matrix))\n", + "cle.imshow( cle.affine_transform(np_array, matrix=matrix))" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/pyclesperanto_prototype/_tier8/__init__.py b/pyclesperanto_prototype/_tier8/__init__.py index a392616a..178007c6 100644 --- a/pyclesperanto_prototype/_tier8/__init__.py +++ b/pyclesperanto_prototype/_tier8/__init__.py @@ -3,6 +3,8 @@ from ._rigid_transform import rigid_transform from ._rotate import rotate from ._scale import scale +from ._scale import scale as zoom from ._translate import translate +from ._translate import translate as shift diff --git a/pyclesperanto_prototype/_tier8/_affine_transform.py b/pyclesperanto_prototype/_tier8/_affine_transform.py index f76f1fc3..ca28c5c4 100644 --- a/pyclesperanto_prototype/_tier8/_affine_transform.py +++ b/pyclesperanto_prototype/_tier8/_affine_transform.py @@ -8,7 +8,7 @@ import numpy as np @plugin_function -def affine_transform(source : Image, destination : Image = None, transform : Union[np.ndarray, AffineTransform3D, AffineTransform] = None, linear_interpolation : bool = False): +def affine_transform(source : Image, output : Image = None, transform : Union[np.ndarray, AffineTransform3D, AffineTransform] = None, linear_interpolation : bool = False, matrix : np.ndarray = None): """ Applies an affine transform to an image. @@ -16,12 +16,14 @@ def affine_transform(source : Image, destination : Image = None, transform : Uni ---------- source : Image image to be transformed - destination : Image, optional + output : Image, optional image where the transformed image should be written to transform : 4x4 numpy array or AffineTransform3D object or skimage.transform.AffineTransform object - transform matrix or object describing the transformation + transform matrix or object describing the transformation. Internally, this transform is inverted. linear_interpolation: bool not implemented yet + matrix : 4x4 numpy array + affine transform matrix, overwrites parameter transform if set Returns ------- @@ -42,27 +44,39 @@ def affine_transform(source : Image, destination : Image = None, transform : Uni source = source_3d # deal with 2D output images - original_destination = destination + original_destination = output copy_back_after_transforming = False - if len(destination.shape) == 2: - destination = create([1, destination.shape[0], destination.shape[1]]) - copy_slice(original_destination, destination, 0) + if len(output.shape) == 2: + output = create([1, output.shape[0], output.shape[1]]) + copy_slice(original_destination, output, 0) copy_back_after_transforming = True + if matrix is None: # we invert the transform because we go from the target image to the source image to read pixels - if isinstance(transform, AffineTransform3D): - transform_matrix = np.asarray(transform.copy().inverse()) - elif isinstance(transform, AffineTransform): - matrix = np.asarray(transform.params) - matrix = np.asarray([ - [matrix[0,0], matrix[0,1], 0, matrix[0,2]], - [matrix[1,0], matrix[1,1], 0, matrix[1,2]], + if isinstance(transform, AffineTransform3D): + transform_matrix = np.asarray(transform.copy().inverse()) + elif isinstance(transform, AffineTransform): + transform = np.asarray(transform.params) + transform = np.asarray([ + [transform[0,0], transform[0,1], 0, transform[0,2]], + [transform[1,0], transform[1,1], 0, transform[1,2]], + [0, 0, 1, 0], + [transform[2,0], transform[2,1], 0, transform[2,2]] + ]) + transform_matrix = np.linalg.inv(transform) + else: + transform_matrix = np.linalg.inv(transform) + else: + # transpose X and Z to make matrix be compatible to scipy + transpose_matrix = np.asarray([ [0, 0, 1, 0], - [matrix[2,0], matrix[2,1], 0, matrix[2,2]] + [0, 1, 0, 0], + [1, 0, 0, 0], + [0, 0, 0, 1] ]) - transform_matrix = np.linalg.inv(matrix) - else: - transform_matrix = np.linalg.inv(transform) + matrix = np.matmul(transpose_matrix, matrix) + matrix = np.matmul(matrix, transpose_matrix) + transform_matrix = matrix gpu_transform_matrix = push(transform_matrix) @@ -76,15 +90,15 @@ def affine_transform(source : Image, destination : Image = None, transform : Uni parameters = { "input": source, - "output": destination, + "output": output, "mat": gpu_transform_matrix } - execute(__file__, '../clij-opencl-kernels/kernels/affine_transform_' + str(len(destination.shape)) + 'd' + kernel_suffix + '_x.cl', - 'affine_transform_' + str(len(destination.shape)) + 'd' + kernel_suffix, destination.shape, parameters) + execute(__file__, '../clij-opencl-kernels/kernels/affine_transform_' + str(len(output.shape)) + 'd' + kernel_suffix + '_x.cl', + 'affine_transform_' + str(len(output.shape)) + 'd' + kernel_suffix, output.shape, parameters) # deal with 2D output images if copy_back_after_transforming: - copy_slice(destination, original_destination, 0) + copy_slice(output, original_destination, 0) return original_destination \ No newline at end of file diff --git a/pyclesperanto_prototype/_tier8/_rotate.py b/pyclesperanto_prototype/_tier8/_rotate.py index 5a1f53bf..c7252f72 100644 --- a/pyclesperanto_prototype/_tier8/_rotate.py +++ b/pyclesperanto_prototype/_tier8/_rotate.py @@ -2,7 +2,7 @@ from .._tier0 import Image @plugin_function -def rotate(source : Image, destination : Image = None, angle_around_x_in_degrees : float = 0, angle_around_y_in_degrees : float = 0, angle_around_z_in_degrees : float = 0, rotate_around_center=True): +def rotate(source : Image, output : Image = None, angle_around_x_in_degrees : float = 0, angle_around_y_in_degrees : float = 0, angle_around_z_in_degrees : float = 0, rotate_around_center=True, angle : float = None, axes = None): """Rotate the image by given angles. Angles are given in degrees. To convert radians to degrees, use this formula: @@ -13,17 +13,21 @@ def rotate(source : Image, destination : Image = None, angle_around_x_in_degrees ---------- source : Image image to be translated - destination : Image, optional + output : Image, optional target image - angle_around_x_in_degrees : float + angle_around_x_in_degrees : float, optional rotation around x axis in radians - angle_around_y_in_degrees : float + angle_around_y_in_degrees : float, optional rotation around y axis in radians - angle_around_z_in_degrees : float + angle_around_z_in_degrees : float, optional rotation around z axis in radians - rotate_around_center : boolean - if True: rotate image around center + rotate_around_center : boolean, optional + if True: rotate image around center (default) if False: rotate image around origin + angle : float, optional + The rotation angle in degrees. + axes : tuple of 2 ints, optional + The two axes that define the plane of rotation. Default is the first two axes. Returns ------- @@ -44,7 +48,39 @@ def rotate(source : Image, destination : Image = None, angle_around_x_in_degrees if angle_around_z_in_degrees != 0: transform.rotate(2, angle_around_z_in_degrees) + + if angle is not None and axes is not None: + # adapted from https://github.com/scipy/scipy/blob/v1.6.0/scipy/ndimage/interpolation.py#L886 + ndim = source.ndim + + if ndim < 2: + raise ValueError('input array should be at least 2D') + + axes = list(axes) + + if len(axes) != 2: + raise ValueError('axes should contain exactly two values') + + if not all([float(ax).is_integer() for ax in axes]): + raise ValueError('axes should contain only integer values') + + if axes[0] < 0: + axes[0] += ndim + if axes[1] < 0: + axes[1] += ndim + if axes[0] < 0 or axes[1] < 0 or axes[0] >= ndim or axes[1] >= ndim: + raise ValueError('invalid rotation plane specified') + + axes.sort() + + if axes == [0, 1]: + transform.rotate(0, -angle) + if axes == [0, 2]: + transform.rotate(1, angle) + if axes == [1, 2]: + transform.rotate(2, -angle) + if rotate_around_center: transform.center(source.shape, undo=True) - return affine_transform(source, destination, transform) + return affine_transform(source, output, transform) diff --git a/pyclesperanto_prototype/_tier8/_scale.py b/pyclesperanto_prototype/_tier8/_scale.py index fe5fd347..e838e16c 100644 --- a/pyclesperanto_prototype/_tier8/_scale.py +++ b/pyclesperanto_prototype/_tier8/_scale.py @@ -1,15 +1,16 @@ from .._tier0 import plugin_function from .._tier0 import Image +from .._tier0 import create_none -@plugin_function -def scale(source : Image, destination : Image = None, factor_x : float = 1, factor_y : float = 1, factor_z : float = 1, centered=True): +@plugin_function(output_creator=create_none) +def scale(source : Image, output : Image = None, factor_x : float = 1, factor_y : float = 1, factor_z : float = 1, centered=True, zoom = None): """Scale the image by given factors. Parameters ---------- source : Image image to be translated - destination : Image, optional + output : Image, optional target image factor_x : float scaling along x @@ -17,7 +18,13 @@ def scale(source : Image, destination : Image = None, factor_x : float = 1, fact scaling along y factor_z : float scaling along z - centered + centered : bool + if True the image is scaled towards its center (default) + if False it will be scaled towards the origin + zoom : float or sequence + The zoom factor along the axes (ignoring centering). If a float, zoom is the + same for each axis. If a sequence, zoom should contain + one value for each axis. When the zoom parameter is used, factors and centers are ignored Returns ------- @@ -26,14 +33,63 @@ def scale(source : Image, destination : Image = None, factor_x : float = 1, fact """ from ._AffineTransform3D import AffineTransform3D from ._affine_transform import affine_transform + from .._tier0 import create transform = AffineTransform3D() - if centered: - transform.center(source.shape) - transform.scale(factor_x, factor_y, factor_z) + if output is None: + import numpy as np + dimensions = np.asarray(source.shape) - if centered: - transform.center(source.shape, undo=True) + # Todo: I'm sure the following block could be shorter. + if len(dimensions) == 3: + if zoom is None: + dimensions[0] = dimensions[0] * factor_z + dimensions[1] = dimensions[1] * factor_y + dimensions[2] = dimensions[2] * factor_x + else: + if isinstance(zoom, float) or isinstance(zoom, int): + dimensions[0] = dimensions[0] * zoom + dimensions[1] = dimensions[1] * zoom + dimensions[2] = dimensions[2] * zoom + else: + dimensions[0] = dimensions[0] * zoom[0] + dimensions[1] = dimensions[1] * zoom[1] + dimensions[2] = dimensions[2] * zoom[2] + else: # 2D image + if zoom is None: + dimensions[0] = dimensions[0] * factor_y + dimensions[1] = dimensions[1] * factor_x + else: + if isinstance(zoom, float) or isinstance(zoom, int): + dimensions[0] = dimensions[0] * zoom + dimensions[1] = dimensions[1] * zoom + else: + dimensions[0] = dimensions[0] * zoom[0] + dimensions[1] = dimensions[1] * zoom[1] + output = create(dimensions) - return affine_transform(source, destination, transform) + + if zoom is None: + if centered: + transform.center(source.shape) + + transform.scale(factor_x, factor_y, factor_z) + + if centered: + transform.center(output.shape, undo=True) + + else: + import numpy as np + #zoom = np.asarray(zoom, dtype=np.float32) + #zoom = 1 / zoom + if isinstance(zoom, float) or isinstance(zoom, int): + if len(source.shape) == 3: + transform.scale(zoom, zoom, zoom) + else: # 2D image + transform.scale(zoom, zoom) + else: + zoom.reverse() + transform.scale(*zoom) + + return affine_transform(source, output, transform) diff --git a/pyclesperanto_prototype/_tier8/_translate.py b/pyclesperanto_prototype/_tier8/_translate.py index ca86b9dc..ea4863f1 100644 --- a/pyclesperanto_prototype/_tier8/_translate.py +++ b/pyclesperanto_prototype/_tier8/_translate.py @@ -2,14 +2,14 @@ from .._tier0 import Image @plugin_function -def translate(source : Image, destination : Image = None, translate_x : float = 0, translate_y : float = 0, translate_z : float = 0): +def translate(source : Image, output : Image = None, translate_x : float = 0, translate_y : float = 0, translate_z : float = 0, shift = None): """Translate the image by a given vector. Parameters ---------- source : Image image to be translated - destination : Image, optional + output : Image, optional target image translate_x : float translation along x axis in pixels @@ -17,6 +17,9 @@ def translate(source : Image, destination : Image = None, translate_x : float = translation along y axis in pixels translate_z : float translation along z axis in pixels + shift : float or sequence + The shift along the axes. If a float, `shift` is the same for each + axis. If a sequence, `shift` should contain one value for each axis. Returns ------- @@ -29,4 +32,14 @@ def translate(source : Image, destination : Image = None, translate_x : float = transform = AffineTransform3D() transform.translate(translate_x, translate_y, translate_z) - return affine_transform(source, destination, transform) + if shift is not None: + if isinstance(shift, float) or isinstance(shift, int): + if len(source.shape) == 3: + transform.translate(shift, shift, shift) + else: # 2D image + transform.translate(shift, shift) + else: + shift.reverse() + transform.translate(*shift) + + return affine_transform(source, output, transform) diff --git a/tests/test_affine_transform.py b/tests/test_affine_transform.py index ded2b6d9..8664a8da 100644 --- a/tests/test_affine_transform.py +++ b/tests/test_affine_transform.py @@ -96,6 +96,50 @@ def test_affine_transform_scale_with_transform_matrix(): assert (np.array_equal(a, b)) +def test_affine_transform_compare_to_scipy(): + source = np.asarray([ + [ + [1, 1, 0, 0], + [1, 1, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + ], [ + [1, 1, 0, 0], + [1, 1, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + ], [ + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + ], [ + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + ] + ]) + + transform = np.asarray([ + [1, 0, 0, 0], + [0, 2, 0, 0], + [0, 0, 1, 0], + [0, 0, 0, 1], + ]) + + import scipy + + reference = scipy.ndimage.affine_transform(source, matrix=transform) + result = cle.affine_transform(source, matrix=transform) + + print(result) + print(reference) + + assert (np.allclose(reference, result)) + + + def test_affine_transform_rotate(): source = cle.push(np.asarray([[ diff --git a/tests/test_rotate.py b/tests/test_rotate.py index 8cb2c510..8c0cf29b 100644 --- a/tests/test_rotate.py +++ b/tests/test_rotate.py @@ -55,3 +55,64 @@ def test_affine_transform_rotate_around_center(): assert (np.array_equal(a, b)) +def test_rotate_compare_with_scipy(): + import numpy as np + source = np.asarray([ + [ + [0, 0, 0], + [0, 0, 0], + [0, 1, 1], + ], [ + [0, 0, 0], + [0, 0, 0], + [0, 1, 1], + ], [ + [0, 0, 0], + [0, 0, 0], + [0, 0, 0], + ] + ]) + + import scipy + + angle = 90 + axes = [0, 1] + print("Rotation angle ", angle, " axes ", axes) + reference = scipy.ndimage.rotate(source, angle=angle, axes=axes) + result = cle.rotate(source, angle=angle, axes=axes) + assert np.allclose(result, reference, 0.001) + + angle = 90 + axes = [1, 0] + print("Rotation angle ", angle, " axes ", axes) + reference = scipy.ndimage.rotate(source, angle=angle, axes=axes) + result = cle.rotate(source, angle=angle, axes=axes) + assert np.allclose(result, reference, 0.001) + + angle = 90 + axes = [0, 2] + print("Rotation angle ", angle, " axes ", axes) + reference = scipy.ndimage.rotate(source, angle=angle, axes=axes) + result = cle.rotate(source, angle=angle, axes=axes) + assert np.allclose(result, reference, 0.001) + + angle = 90 + axes = [2, 0] + print("Rotation angle ", angle, " axes ", axes) + reference = scipy.ndimage.rotate(source, angle=angle, axes=axes) + result = cle.rotate(source, angle=angle, axes=axes) + assert np.allclose(result, reference, 0.001) + + angle = 90 + axes = [1, 2] + print("Rotation angle ", angle, " axes ", axes) + reference = scipy.ndimage.rotate(source, angle=angle, axes=axes) + result = cle.rotate(source, angle=angle, axes=axes) + assert np.allclose(result, reference, 0.001) + + angle = 90 + axes = [2, 1] + print("Rotation angle ", angle, " axes ", axes) + reference = scipy.ndimage.rotate(source, angle=angle, axes=axes) + result = cle.rotate(source, angle=angle, axes=axes) + assert np.allclose(result, reference, 0.001) diff --git a/tests/test_scale.py b/tests/test_scale.py index bcc39695..ea7e5a9c 100644 --- a/tests/test_scale.py +++ b/tests/test_scale.py @@ -12,11 +12,16 @@ def test_scale_centered(): ]])) reference = cle.push(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], ]])) result = cle.scale(source, factor_y=2) @@ -45,6 +50,11 @@ def test_scale_not_centered(): [0, 0, 1, 1, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], ]])) result = cle.scale(source, factor_y=2, centered=False) @@ -57,3 +67,133 @@ def test_scale_not_centered(): assert (np.array_equal(a, b)) +def test_scale_x_not_centered(): + source = cle.push(np.asarray([[ + [0, 0, 0, 0, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]])) + + reference = cle.push(np.asarray([[ + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 1, 1, 1, 1, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + ]])) + + result = cle.scale(source, factor_x=2, centered=False) + + a = cle.pull(result) + b = cle.pull(reference) + + print(a) + print(b) + + assert (np.array_equal(a, b)) + + +def test_scale_compare_with_scipy(): + import numpy as np + source = np.asarray([ + [ + [0, 1, 0, 0], + [0, 1, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + ], [ + [0, 1, 0, 0], + [0, 1, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + ], [ + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + ], [ + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + ] + ]) + + import scipy + import numpy as np + + zoom = [1, 2, 1] + reference = scipy.ndimage.zoom(source, zoom=zoom) + result = cle.zoom(source, zoom=zoom) + assert np.allclose(result, reference, 0.001) + + zoom = [1, 0.5, 1] + reference = scipy.ndimage.zoom(source, zoom=zoom) + result = cle.zoom(source, zoom=zoom) + assert np.allclose(result, reference, 0.001) + + zoom = [2, 1, 1] + reference = scipy.ndimage.zoom(source, zoom=zoom) + result = cle.zoom(source, zoom=zoom) + assert np.allclose(result, reference, 0.001) + + zoom = [0.5, 1, 1] + reference = scipy.ndimage.zoom(source, zoom=zoom) + result = cle.zoom(source, zoom=zoom) + assert np.allclose(result, reference, 0.001) + + zoom = [1, 1, 2] + reference = scipy.ndimage.zoom(source, zoom=zoom) + result = cle.zoom(source, zoom=zoom) + assert np.allclose(result, reference, 0.001) + + # this one makes me sad, luckily this one failing should be irrelevant in practice + #zoom = 2.0 + #reference = scipy.ndimage.zoom(source, zoom=zoom) + #result = cle.zoom(source, zoom=zoom) + #print(reference) + #print(result) + #assert np.allclose(result, reference, 0.001) + +# for this one, we need a different image to make scipy output something reasonable. +# in practice, this should not matter +def test_scale_compare_with_scipy_failing(): + import numpy as np + source = np.asarray([ + [ + [1, 1, 0, 0], + [1, 1, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + ], [ + [1, 1, 0, 0], + [1, 1, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + ], [ + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + ], [ + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + ] + ]) + + import scipy + import numpy as np + + zoom = [1, 1, 0.5] + reference = scipy.ndimage.zoom(source, zoom=zoom) + result = cle.zoom(source, zoom=zoom) + assert np.allclose(result, reference, 0.001) + + zoom = 0.5 + reference = scipy.ndimage.zoom(source, zoom=zoom) + result = cle.zoom(source, zoom=zoom) + assert np.allclose(result, reference, 0.001) \ No newline at end of file diff --git a/tests/test_translate.py b/tests/test_translate.py index 222bcb10..45a97cf1 100644 --- a/tests/test_translate.py +++ b/tests/test_translate.py @@ -28,3 +28,72 @@ def test_translate(): assert (np.array_equal(a, b)) +def test_translate_compare_with_scipy(): + import numpy as np + source = np.asarray([ + [ + [0, 0, 0], + [0, 0, 0], + [0, 1, 1], + ], [ + [0, 0, 0], + [0, 0, 0], + [0, 1, 1], + ], [ + [0, 0, 0], + [0, 0, 0], + [0, 0, 0], + ] + ]) + + import scipy + + vector = [-1, 0, 0] + reference = scipy.ndimage.shift(source, shift=vector) + result = cle.shift(source, shift=vector) + assert np.allclose(result, reference, 0.001) + + vector = [1, 0, 0] + reference = scipy.ndimage.shift(source, shift=vector) + result = cle.shift(source, shift=vector) + assert np.allclose(result, reference, 0.001) + + vector = [0, 1, 0] + reference = scipy.ndimage.shift(source, shift=vector) + result = cle.shift(source, shift=vector) + assert np.allclose(result, reference, 0.001) + + vector = [0, -1, 0] + reference = scipy.ndimage.shift(source, shift=vector) + result = cle.shift(source, shift=vector) + assert np.allclose(result, reference, 0.001) + + vector = [0, 0, 1] + reference = scipy.ndimage.shift(source, shift=vector) + result = cle.shift(source, shift=vector) + assert np.allclose(result, reference, 0.001) + + vector = [0, 0, -1] + reference = scipy.ndimage.shift(source, shift=vector) + result = cle.shift(source, shift=vector) + assert np.allclose(result, reference, 0.001) + + vector = 1. + reference = scipy.ndimage.shift(source, shift=vector) + result = cle.shift(source, shift=vector) + assert np.allclose(result, reference, 0.001) + + vector = -1. + reference = scipy.ndimage.shift(source, shift=vector) + result = cle.shift(source, shift=vector) + assert np.allclose(result, reference, 0.001) + + vector = 1 + reference = scipy.ndimage.shift(source, shift=vector) + result = cle.shift(source, shift=vector) + assert np.allclose(result, reference, 0.001) + + vector = -1 + reference = scipy.ndimage.shift(source, shift=vector) + result = cle.shift(source, shift=vector) + assert np.allclose(result, reference, 0.001)