diff --git a/doc/api.rst b/doc/api.rst index e5c47a64..4313921b 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -1,7 +1,7 @@ UMAP API Guide ============== -UMAP has only a single class :class:`UMAP`. +UMAP has only two classes, :class:`UMAP`, and :class:`ParametricUMAP`, which inherits from it. UMAP ---- @@ -9,6 +9,12 @@ UMAP .. autoclass:: umap.umap_.UMAP :members: +ParametricUMAP +---- + +.. autoclass:: umap.parametric_umap.ParametricUMAP + :members: + A number of internal functions can also be accessed separately for more fine tuned work. Useful Functions diff --git a/doc/conf.py b/doc/conf.py index 230015da..274aeb38 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -20,8 +20,8 @@ import os import sys -sys.path.insert(0, os.path.abspath('.')) -sys.path.insert(0, os.path.abspath('..')) +sys.path.insert(0, os.path.abspath(".")) +sys.path.insert(0, os.path.abspath("..")) # -- General configuration ------------------------------------------------ diff --git a/doc/images/retrain_pumap_emb_x1.png b/doc/images/retrain_pumap_emb_x1.png new file mode 100644 index 00000000..501325c3 Binary files /dev/null and b/doc/images/retrain_pumap_emb_x1.png differ diff --git a/doc/images/retrain_pumap_emb_x2.png b/doc/images/retrain_pumap_emb_x2.png new file mode 100644 index 00000000..34e45817 Binary files /dev/null and b/doc/images/retrain_pumap_emb_x2.png differ diff --git a/doc/images/retrain_pumap_history.png b/doc/images/retrain_pumap_history.png new file mode 100644 index 00000000..050fd848 Binary files /dev/null and b/doc/images/retrain_pumap_history.png differ diff --git a/doc/images/retrain_pumap_p_emb_x1.png b/doc/images/retrain_pumap_p_emb_x1.png new file mode 100644 index 00000000..0d852b96 Binary files /dev/null and b/doc/images/retrain_pumap_p_emb_x1.png differ diff --git a/doc/images/retrain_pumap_p_emb_x2.png b/doc/images/retrain_pumap_p_emb_x2.png new file mode 100644 index 00000000..49372546 Binary files /dev/null and b/doc/images/retrain_pumap_p_emb_x2.png differ diff --git a/doc/images/retrain_pumap_summary_2_removed.png b/doc/images/retrain_pumap_summary_2_removed.png new file mode 100644 index 00000000..e616d52a Binary files /dev/null and b/doc/images/retrain_pumap_summary_2_removed.png differ diff --git a/doc/index.rst b/doc/index.rst index eca2f009..b7704526 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -61,6 +61,7 @@ PyPI install, presuming you have numba and sklearn and all its requirements transform inverse_transform parametric_umap + transform_landmarked_pumap sparse supervised clustering diff --git a/doc/parametric_umap.rst b/doc/parametric_umap.rst index f672ce98..4b4943b6 100644 --- a/doc/parametric_umap.rst +++ b/doc/parametric_umap.rst @@ -91,7 +91,7 @@ This loads both the UMAP object and the parametric networks it contains. Plotting loss ------------- -Parametric UMAP monitors loss during training using Keras. That loss will be printed after each epoch during training. This loss is saved in :python:`embedder.history`, and can be plotted: +Parametric UMAP monitors loss during training using Keras. That loss will be printed after each epoch during training. This loss is saved in :python:`embedder._history`, and can be plotted: .. code:: python3 @@ -103,6 +103,8 @@ Parametric UMAP monitors loss during training using Keras. That loss will be pri .. image:: images/umap-loss.png +Much like other keras models, if you continue to train your model via the :python:`fit` method of the model, the :python:`embedder._history` will be updated with further training epoch losses. + Parametric inverse_transform (reconstruction) --------------------------------------------- To use a second neural network to learn an inverse mapping between data and embeddings, we simply need to pass `parametric_reconstruction= True` to the ParametricUMAP. @@ -205,6 +207,8 @@ Additional important parameters * **optimizer:** The optimizer used to train the neural network. by default Adam (:python:`tf.keras.optimizers.Adam(1e-3)`) is used. You might be able to speed up or improve training by using a different optimizer. * **parametric_embedding:** If set to false, a non-parametric embedding is learned, using the same code as the parametric embedding, which can serve as a direct comparison between parametric and non-parametric embedding using the same optimizer. The parametric embeddings are performed over the entire dataset simultaneously. * **global_correlation_loss_weight:** Whether to additionally train on correlation of global pairwise relationships (multidimensional scaling) +* **landmark_loss_fn:** The loss function to use when re-training on landmarked data, where you have provided a desired location in the embedding space to the :python:`fit` method of the model. By default, euclidean loss is used. For more information on re-training, landmarks, and why you might use them, see :doc:`transform_landmarked_pumap`. +* **landmark_loss_weight:** How to weight the landmark loss relative to umap loss, by default 1.0. Extending the model ------------------- diff --git a/doc/transform.rst b/doc/transform.rst index 742af001..6334d797 100644 --- a/doc/transform.rst +++ b/doc/transform.rst @@ -13,6 +13,11 @@ the latent space the classifier uses. Fortunately UMAP makes this possible, albeit more slowly than some other transformers that allow this. +This tutorial will step through a simple case where we expect the overall +distribution in our higher-dimensional vectors to be consistent between the +training and testing data. For more detail on how this can go wrong, and +how we can fix it using Parametric UMAP, see :doc:`transform_landmarked_pumap`. + To demonstrate this functionality we'll make use of `scikit-learn `__ and the digits dataset contained therein (see :doc:`basic_usage` for an example diff --git a/doc/transform_landmarked_pumap.rst b/doc/transform_landmarked_pumap.rst new file mode 100644 index 00000000..e9881e49 --- /dev/null +++ b/doc/transform_landmarked_pumap.rst @@ -0,0 +1,227 @@ + +Transforming New Data with Parametric UMAP +========================================== + +There are many cases where one may want to take an existing UMAP model and use it to embed new data into the learned space. For a simple example where the overall distribution of the higher-dimensional training data matches that of the new data being embedded, see :doc:`transform`. We can't always be sure that this will be the case, however. To simulate a case where we have novel behaviour that we want to include in our embedding space, we will use the MNIST digits dataset (see :doc:`basic_usage` for a basic example). + +To follow along with this example, see the MNIST_Landmarks notebook on the `GitHub repository `_ + +.. code :: python3 + + import keras + from sklearn.model_selection import train_test_split + + from umap import UMAP, ParametricUMAP + + import matplotlib.pyplot as plt + + import numpy as np + import pandas as pd + +We'll start by loading in the dataset, and splitting it into 2 equal parts with ``sklearn``'s ``train_test_split`` function. This will give us two partitions to work with, one to train our original embedding and another to test it. In order to simulate new behaviour appearing in our data we remove one of the MNIST categories ``N`` from the ``x1`` partition. In this case we'll use ``N=2``, so our model will be trained on all of the digits other than 2. + +.. code:: python3 + + (X, y), (_, _) = keras.datasets.mnist.load_data() + x1, x2, y1, y2 = train_test_split(X, y, test_size=0.5, random_state=42) + + # Reshape to 1D vectors + x1 = x1.reshape((x1.shape[0], 28*28)) + x2 = x2.reshape((x2.shape[0], 28*28)) + + # Remove one category from the train dataset. + # In the case of MNIST digits, this will be the digit we are removing. + N = 2 + + x1 = x1[y1 != N] + y1 = y1[y1 != N] + + print(x1.shape, x2.shape) + +.. parsed-literal:: + + (26995, 784) (30000, 784) + +New data with UMAP +------------------ + +To start with, we'll identify the issues with using UMAP as-is in this case, and then we'll see how to fix them with Parametric UMAP. First off, we need to train a ``UMAP`` model on our ``x1`` partition: + +.. code:: python3 + + embedder = UMAP() + + emb_x1 = embedder.fit_transform(x1) + +Visualising our results: + +.. code:: python3 + + plt.scatter(emb_x1[:,0], emb_x1[:,1], c=y1, cmap='Spectral', s=2, alpha=0.2) + +.. image:: images/retrain_pumap_emb_x1.png + + +This is a clean and successful embedding, as we would expect from UMAP on this relatively-simple example. We see the normal structure one would expect from embedding MNIST, but without any of the 2s. The ``UMAP`` class is built to be compatible with ``scikit-learn``, so passing new data through is as simple as using the ``transform`` method and passing through the new data. We'll pass through ``x2``, which contains unseen examples of the original classes, and also samples from our holdout class, ``N`` (the 2s). + +To make samples from ``N`` Stand out more, we'll over-plot them in black. + +.. code:: python3 + + emb_x2 = embedder.transform(x2) + +.. code:: python3 + + plt.scatter(emb_x2[:,0], emb_x2[:,1], c=y2, cmap='Spectral', s=2, alpha=0.2) + plt.scatter(emb_x2[y2==N][:,0], emb_x2[y2==N][:,1], c='k', s=2, alpha=0.5) + +.. image:: images/retrain_pumap_emb_x2.png + +While our ``UMAP`` embedder has correctly handled the classes present in ``x1`` it has treated examples from our holdout class ``N`` poorly. Many of these points are concentrated on top of existing classes, with some spread out between them. This inability to generalize is not unique to UMAP, but is more generally a difficulty with learned embeddings. It also may or may not be an issue, depending on your use case. + +New data with Parametric UMAP +----------------------------- + +We can improve this outcome with Parametric UMAP. Parametric UMAP differs from UMAP in that it learns the relationship between the data and embedding with a neural network, instead of learning embeddings directly. This means we can incorporate new data by continuing to train the neural network, updating the weights to incorporate our new information. + +.. image:: images/pumap-only.png + +For more complete information on Parametric UMAP and the many options it provides, see :doc:`parametric_umap`. + +We will start adressing this by training a ``ParametricUMAP`` embedding model, and running the same experiment: + +.. code:: python3 + + p_embedder = ParametricUMAP() + + p_emb_x1 = p_embedder.fit_transform(x1) + +.. code:: python3 + + plt.scatter(p_emb_x1[:,0], p_emb_x1[:,1], c=y1, cmap='Spectral', s=2, alpha=0.2) + +.. image:: images/retrain_pumap_p_emb_x1.png + +Again, we get good results on our initial embedding of ``x1``. If we pass ``x2`` through without re-training, we get a similar problem to our ``UMAP`` model: + +.. code:: python3 + + p_emb_x2 = p_embedder.transform(x2) + +.. code:: python3 + + plt.scatter(p_emb_x2[:,0], p_emb_x2[:,1], c=y2, cmap='Spectral', s=2, alpha=0.2) + plt.scatter(p_emb_x2[y2==N][:,0], p_emb_x2[y2==N][:,1], c='k', s=2, alpha=0.5) + +.. image:: images/retrain_pumap_p_emb_x2.png + +Re-training Parametric UMAP with landmarks +------------------------------------------ + +To update our embedding to include the new class, we'll fine-tune our existing ``ParametricUMAP`` model. Doing this without any other changes will start from where we left off, but our embedding space's structure may drift and change. This is because the UMAP loss function is invariant to translation and rotation, as it is only concerned with the relative positions and distances between points. + +In order to keep our embedding space more consistent, we'll use the landmarks option for ``ParametricUMAP``. We retrain the model on the ``x2`` partition, along with some points chosen as landmarks from ``x1``. We'll choose 1% of the samples in ``x1`` to be included, along with their current position in the embedding space to be used in the landmarks loss function. + +The default ``landmark_loss_fn`` is the euclidean distance between the point's original position and it's current one. The only change we'll make is to set ``landmark_loss_weight=0.01``. + +.. code:: python3 + + # Select landmarks indexes from x1. + # + landmark_idx = list(np.random.choice(range(x1.shape[0]), int(x1.shape[0]/100), replace=False)) + + # Add the landmark points to x2 for training. + # + x2_lmk = np.concatenate((x2, x1[landmark_idx])) + y2_lmk = np.concatenate((y2, y1[landmark_idx])) + + # Make our landmarks vector, which is nan where we have no landmark information. + # + landmarks = np.stack( + [np.array([np.nan, np.nan])]*x2.shape[0] + list( + p_embedder.transform( + x1[landmark_idx] + ) + ) + ) + + # Set landmark loss weight and continue training our Parametric UMAP model. + # + p_embedder.landmark_loss_weight = 0.01 + p_embedder.fit(x2_lmk, landmark_positions=landmarks) + p_emb2_x2 = p_embedder.transform(x2) + + # Check how x1 looks when embedded in the space retrained on x2 and landmarks. + # + p_emb2_x1 = p_embedder.transform(x1) + + +Plotting all of the different embeddings to compare them: + +.. code:: python3 + + fig, axs = plt.subplots(3, 2, figsize=(16, 24), sharex=True, sharey=True) + + axs[0,0].scatter( + emb_x1[:, 0], emb_x1[:, 1], c=y1, cmap='Spectral', s=2, alpha=0.2, + ) + axs[0,0].set_ylabel('UMAP Embedding', fontsize=20) + + axs[0,1].scatter( + emb_x2[:, 0], emb_x2[:, 1], c=y2, cmap='Spectral', s=2, alpha=0.2, + ) + axs[0,1].scatter( + emb_x2[y2==N][:,0], emb_x2[y2==N][:,1], c='k', s=2, alpha=0.5, + ) + + axs[1,0].scatter( + p_emb_x1[:, 0], p_emb_x1[:, 1], c=y1, cmap='Spectral', s=2, alpha=0.2, + ) + axs[1,0].set_ylabel('Initial P-UMAP Embedding', fontsize=20) + + axs[1,1].scatter( + p_emb_x2[:, 0], p_emb_x2[:, 1], c=y2, cmap='Spectral', s=2, alpha=0.2, + ) + axs[1,1].scatter( + p_emb_x2[y2==N][:,0], p_emb_x2[y2==N][:,1], c='k', s=2, alpha=0.5 + ) + + axs[2,0].scatter( + p_emb2_x1[:, 0], p_emb2_x1[:, 1], c=y1, cmap='Spectral', s=2, alpha=0.2, + ) + axs[2,0].set_ylabel('Updated P-UMAP Embedding', fontsize=20) + axs[2,0].set_xlabel(f'x1, No {N}s', fontsize=20) + + axs[2,1].scatter( + p_emb2_x2[:, 0], p_emb2_x2[:, 1], c=y2, cmap='Spectral', s=2, alpha=0.2, + ) + axs[2,1].scatter( + p_emb2_x2[y2==N][:,0], p_emb2_x2[y2==N][:,1], c='k', s=2, alpha=0.5, + ) + axs[2,1].set_xlabel('x2, All Classes', fontsize=20) + + plt.tight_layout() + +.. image:: images/retrain_pumap_summary_2_removed.png + +Here we see that our approach has been successful, The embedding space has been kept consistent and we now have a clear cluster of our new class, the 2s. This new cluster shows up in a sensible part of the embedding space, and the rest of the structure is preserved. + +It is worth double checking here that the landmark loss is not too constraining, we still would like a good UMAP structure. +To do so, we can interrogate the history of our embedder, which will retain the history through our re-training steps. + +.. code:: python3 + + plt.plot(p_embedder._history['loss']) + plt.ylabel('Loss') + plt.xlabel('Epoch') + +.. image:: images/retrain_pumap_history.png + +We can identify the spike in loss where we introduce ``x2``, and can confirm that the resulting loss is comparable to the loss from our initial training on ``x1``. This tells us that the model is not having to compromise too much between the UMAP loss and the landmark loss. If this were not the case, it could potentially be improved by lowering the ``landmark_loss_weight`` attribute of our embedder object. There is a tradeoff to be made here between the consistency of the space and minimizing UMAP loss, but the key is we have smooth variation in the embedding space, which will make downstream tasks easier to adjust. In this case, we could probably stand to increase the ``landmark_loss_weight`` to keep the space more consistent. + +In addition to ``landmark_loss_weight``, there are a number of other options available to us to try and get better results on this or other examples: + +- Continuing the training with a larger portion of points from the original data, in our case ``x1``. Not all of these points need to be landmarked, but they can contribute to a consistent graph structure in higher dimensions. +- Changing the ``landmark_loss_fn``. For example, if we want to allow for points to move if they have to we could truncate the default euclidean loss function, allowing the metaphorical rubber band to snap at a certain point and prioritising a good UMAP structure once we discover that sticking to the landmark position is not correct. +- Being more intelligent with our selection of landmark points, for example using submodular optimization with a package like `apricot-select `__ or chosing points from different parts of a heirarchical clustering like `HDBSCAN `__ + diff --git a/examples/mnist_torus_sphere_example.py b/examples/mnist_torus_sphere_example.py index 26d6d594..1377ce0f 100755 --- a/examples/mnist_torus_sphere_example.py +++ b/examples/mnist_torus_sphere_example.py @@ -50,7 +50,7 @@ def torus_euclidean_grad(x, y, torus_dimensions=(2 * np.pi, 2 * np.pi)): for i in range(x.shape[0]): a = abs(x[i] - y[i]) if 2 * a < torus_dimensions[i]: - distance_sqr += a ** 2 + distance_sqr += a**2 g[i] = x[i] - y[i] else: distance_sqr += (torus_dimensions[i] - a) ** 2 @@ -74,7 +74,7 @@ def torus_euclidean_grad(x, y, torus_dimensions=(2 * np.pi, 2 * np.pi)): # Plot a torus R = 2 r = 1 - values = (R - np.sqrt(x ** 2 + y ** 2)) ** 2 + z ** 2 - r ** 2 + values = (R - np.sqrt(x**2 + y**2)) ** 2 + z**2 - r**2 mlab.contour3d(x, y, z, values, color=(1.0, 1.0, 1.0), contours=[0]) # torus angles -> 3D @@ -105,7 +105,7 @@ def torus_euclidean_grad(x, y, torus_dimensions=(2 * np.pi, 2 * np.pi)): # Plot a sphere r = 3 - values = x ** 2 + y ** 2 + z ** 2 - r ** 2 + values = x**2 + y**2 + z**2 - r**2 mlab.contour3d(x, y, z, values, color=(1.0, 1.0, 1.0), contours=[0]) # latitude, longitude -> 3D diff --git a/examples/plot_algorithm_comparison.py b/examples/plot_algorithm_comparison.py index 107b845c..a180c9b7 100644 --- a/examples/plot_algorithm_comparison.py +++ b/examples/plot_algorithm_comparison.py @@ -43,6 +43,7 @@ the equator and black to white from the south to north pole. """ + import numpy as np import matplotlib.pyplot as plt import seaborn as sns diff --git a/examples/plot_fashion-mnist_example.py b/examples/plot_fashion-mnist_example.py index 863d2b8e..6d48c31d 100644 --- a/examples/plot_fashion-mnist_example.py +++ b/examples/plot_fashion-mnist_example.py @@ -11,6 +11,7 @@ (as shown in this example), or by continuous variables, or by density (as is common in datashader examples). """ + import umap import numpy as np import pandas as pd diff --git a/examples/plot_feature_extraction_classification.py b/examples/plot_feature_extraction_classification.py index 89aa9a6a..c0bb780e 100644 --- a/examples/plot_feature_extraction_classification.py +++ b/examples/plot_feature_extraction_classification.py @@ -20,6 +20,7 @@ used as a feature extraction technique. This small change results in a substantial improvement compared to the model where raw data is used. """ + from sklearn.datasets import make_classification from sklearn.model_selection import train_test_split, GridSearchCV from sklearn.pipeline import Pipeline @@ -45,7 +46,7 @@ # Classification with a linear SVM svc = LinearSVC(dual=False, random_state=123) -params_grid = {"C": [10 ** k for k in range(-3, 4)]} +params_grid = {"C": [10**k for k in range(-3, 4)]} clf = GridSearchCV(svc, params_grid) clf.fit(X_train, y_train) print( @@ -58,7 +59,7 @@ params_grid_pipeline = { "umap__n_neighbors": [5, 20], "umap__n_components": [15, 25, 50], - "svc__C": [10 ** k for k in range(-3, 4)], + "svc__C": [10**k for k in range(-3, 4)], } diff --git a/examples/plot_mnist_example.py b/examples/plot_mnist_example.py index 44b412b4..e7b75051 100644 --- a/examples/plot_mnist_example.py +++ b/examples/plot_mnist_example.py @@ -13,6 +13,7 @@ 0, and grouping triplets of 3,5,8 and 4,7,9 which can blend into one another in some cases. """ + import umap from sklearn.datasets import fetch_openml import matplotlib.pyplot as plt diff --git a/notebooks/MNIST_Landmarks.ipynb b/notebooks/MNIST_Landmarks.ipynb new file mode 100644 index 00000000..17ab58a5 --- /dev/null +++ b/notebooks/MNIST_Landmarks.ipynb @@ -0,0 +1,566 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9cedf393-2d45-44b6-b202-00544167e5fa", + "metadata": {}, + "source": [ + "# Transforming New Data With UMAP\n", + "\n", + "UMAP is useful for generating visualisations, but if you want to make use of UMAP more generally for machine learning tasks it is important to be be able to train a model and then later pass new data to the model and have it transform that data into the learned space. For example if we use UMAP to learn a latent space and then train a classifier on data transformed into the latent space then the classifier is only useful for prediction if we can transform data for which we want a prediction into the latent space the classifier uses." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e48b9170-eef7-41ce-a126-109fe50fb702", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-12 16:36:09.292491: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-10-12 16:36:09.327100: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-10-12 16:36:09.338231: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-10-12 16:36:09.364220: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-10-12 16:36:13.617408: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "import keras\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "from umap import UMAP, ParametricUMAP\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import numpy as np\n" + ] + }, + { + "cell_type": "markdown", + "id": "77085099-1276-45ae-b2d0-0044d343e265", + "metadata": {}, + "source": [ + "We'll start by loading in the MNIST handwritten digit dataset, and splitting it into 2 equal parts with sklearn's ``train_test_split`` function. This will give us two partitions to work with, one to train our original embedding and another to test it. In order to simulate new behaviour appearing in our data we remove one of the MNIST categories (digits), ``N``, from the ``x1`` partition." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ba6291df-01e5-4638-8f10-1e52eb9fafd3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(26995, 784) (30000, 784)\n" + ] + } + ], + "source": [ + "n_samples = -1 #-1 to use all samples.\n", + "\n", + "(X, y), (_, _) = keras.datasets.mnist.load_data()\n", + "x1, x2, y1, y2 = train_test_split(X[:n_samples], y[:n_samples], test_size=0.5, random_state=42)\n", + "\n", + "# Reshape to 1D vectors\n", + "x1 = x1.reshape((x1.shape[0], 28*28))\n", + "x2 = x2.reshape((x2.shape[0], 28*28))\n", + "\n", + "# Remove one category from the train dataset.\n", + "# In the case of MNIST digits, this will be the digit we are removing.\n", + "N = 2\n", + "\n", + "x1 = x1[y1 != N]\n", + "y1 = y1[y1 != N]\n", + "\n", + "print(x1.shape, x2.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "6832869a-3ab8-496d-ac36-18362660900d", + "metadata": {}, + "source": [ + "Firstly, we'll train a ``UMAP`` embedder on ``x1``. This is straightforward." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6a305035-c376-41fc-8a79-b9286bfd9e6f", + "metadata": {}, + "outputs": [], + "source": [ + "embedder = UMAP()\n", + "\n", + "emb_x1 = embedder.fit_transform(x1)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "87182090-92f7-404d-96a0-0fff096669e7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAGdCAYAAAAWp6lMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9aaxk63nfi/3e911jjXvePXefkaQomqRiUpTka9n3RnboxIMsQzYERIYQwEbyxbLywSYMASZki5ANGLQEO4k/yciNjcQRZDt2kitZVkTRGq5IisMheeY+Pe9517imd8qHd9Xu7jNQ4uE5PIfN9QN279pVa6pV1bX+9Qz/R3jvPR0dHR0dHR0djzDynT6Ajo6Ojo6Ojo63m07wdHR0dHR0dDzydIKno6Ojo6Oj45GnEzwdHR0dHR0djzyd4Ono6Ojo6Oh45OkET0dHR0dHR8cjTyd4Ojo6Ojo6Oh55OsHT0dHR0dHR8cgTvdMH8FbjnOPu3bsMh0OEEO/04XR0dHR0dHT8MfDeM5/PuXDhAlK+9fGYR07w3L17l8uXL7/Th9HR0dHR0dHxJrh16xaXLl16y7f7yAme4XAIhBM2Go3e4aPp6Ojo6Ojo+OMwm824fPny2XX8reaREzyrNNZoNOoET0dHR0dHx3cYb1c5Sle03NHR0dHR0fHI0wmejo6Ojo6OjkeeTvB0dHR0dHR0PPJ0gqejo6Ojo6PjkacTPB0dHR0dHR2PPJ3g6ejo6Ojo6Hjk6QRPR0dHR0dHxyNPJ3g6Ojo6Ojo6Hnk6wdPR0dHR0dHxyNMJno6Ojo6Ojo5Hnk7wdHR0dHR0dDzyPHKztDq+O/DOAg5E9LbNXeno6OjoeHToBE/HdxTeLKC+DXYOwoPawssMBBBtMNeKaTFnlApGvQFCxHjvwWvAtz8SIRO8951Y6ujo6PguoRM8He9avKsBmDcSZ2pG4jaifhGYAjYspGMgA5FiomvcmqQcL2Zs5J737G4QxZtgJ2Bn4CxEGcheGyEy+HgHoYbvzBPs6Ojo6Pi20QmejncF3hvwBkQCCHAFmBNOK8dzR46xuE3c36cXF69aU4cfvwQtGcoBxJq+AnQV7ncF4MBbsAbMDPRB2F98gs+eBhmBzBGiK2vr6OjoeBTpBE/HO473BvQRmDnoJYgqiBHnEVqzgSEVM5yrvsFWHBEnbKczRlKRxZLIAKaEZAOkAufAO9An4GdhNTsBfRd8DSrDyzGoAYgYRIwQ6ttwBjo6Ojo63m46wdPxzuM06D2orwPz9k4BSPqR4kLucd6QKt8+JglvXQO4BzZkyKQhS8E4KKwgkwLJORB9cJMQ7fEVISWmwHlo9sL9MoZoC2QWflQfH211oqejo6PjEaATPB3vPHYG9V3uix0IxcUWtA3SR4D2oBDIs+LjnJDSah7anPFwu4bCetbjBefF1wniSHPficG2tw3aaUptiKSnx2lbDD0GEREEVSd4Ojo6Or7T6QRPxztPc0QoRH41Eu0FlbEgQXlQeGQMMY62NYsgSszZWsZBZYNAKq3D+4L7zVj2ge0boOBkYTkoBHkccWHs6EkFfg5qC4jw3oWUl4gRIgpdX9B1eHV0dHR8B9EJno53jNAuvkovvV6xcEqc5CybBdZZhPL4sxSWBBKg4EGxA5BK2IyhcLAewxvrEg8EMTSMFVkEUqhwvwTMMdhNcA24U/C04sdAtIVPtkIhtFuCTBCy/xaclY6Ojo6Ot4NO8HS8c7glNLdC4TA9ggBZpacEkBCTsDHI0K7BW4PgwToewavFDgSBs52+wS55rbRaT6EfWyIRka7qdcw8FE+Xacho2QJ8GYqeBYBuf7fRHxfjI8D7IIJEEh4XEULEb+r0dHR0dHS8dXSCp+MdwXsL+jAUK/saojWQ10BPwd8m1NtYQKCwKGnQ0oWUFhCEjufhouVvhEAT4zEIHDGSIH0ccSSISYH4gW3qEMmxx8AAfAG2jURJGaI+ds5ZiswtoL4DdhHukzlEuxCPusLnjo6OjncBneDpeGfwNggKorZIeB2SyxAtoTgBlgRRs0p5GR6Ok3jui54/ihhPjsPhUERYLGuoaBAiOWdRoiCAOBNDhMdkDC6HKAl/e8IxuRmQgpmCPeK+SEvaVB3ht3P4eA0h8zd1qjo6Ojo6vnU6wdPxzuAdYCHqg1iD9DyQstSSlAERDaFGB15f1DiCGFI8nNaKud9V5c5+CxoEqpUxCSragPQq+BfB3g3HQgxyrV2/DukpmYbfzoM9bDNpEkQKLgLKUN9DMEQ0xNSVQwpLlM6JvW7FT4OPL3Szvzo6OjreITrB0/HOIADVA5dCtIYXGc/cnXC0OOHpgWQnj9tOLLjvu2N5WPw07YYeJAa2CWJnAtSsan0SLB6JIA2ixUzANzwkmGQvRHTotfO3UnBzsEtgFoQPQxBjiIbhGGwCPgtHpDNm84J+rhGyIA6VziGSVN4EmeHjbcgudrU9HR0dHd9GOsHT8c4gUlAbIC2oPnuzgmfu3ELZI7bFks3cEtPw6pbzEH3xBBHzejU8Bjhpf5cP3B8DEoG4X3Ts522kKeWsU8zMguARMch+cGR2DSGatBJPKcTngnszTQhE2QKcRbqCJDYIAVIIoNdGgBbheJ0AcwvcpB1pkb6mvsf78Jy6MRcdHR0dbx2d4Ol4RxBChBEOgPcNtt7jQu8Qo5d476h0TBYbisZQW0gV9BK476OTc7+r60HR0xBqaV6dBnOEt3sCPgKtQbSCR6yiORpYhEVFBlaD9IACsd4uIyDqgVLt3zKk5GQM/pQs8shxincQq15YnuaB4wmt8DR3wr7jDXy8e1bf410D9iTcVhvdVPeOjo6Ot4hO8HS889gl28kBaq1iWUMSpcz8NrGdc3d+j+3MgQJtIT4LhkhC1CYmRF6aN9r6aicPLBcD1f06Ip+Gv8+EU78tqJ62dTo5JOfAteupLHSTiTbS5P39SJAzJEKAku02V4aKq4gUYT++CIaLbgZmiU+vhhSfr2E1M0yU+Poe+Ck+PoeId978Oe7o6Oj4LqcTPB3vPN6SiprzfUvZ0yxKQ9Mc8GLhcUawlkIqABECM8SibSt/vbdvQhA0Ja9Nd63+budoERFESCgqDkRAH5hxXyQBLCHeBFuBq4Ng8RU42RYlr7q7RHu7bn98u81eu8+i3W4Z9msSMAUIA9G5kEYTKixrl9A8F4SUWeDVGkKuCrk7Ojo6Or4ZOsHT8c4jeqGmx1uULnDGUzVLIhT9zKEkKAHOhn4rtCKKc0RwBCQIjBjog9gJURL2CSmqhCBm7Kt2GhNqdx4UO7TbOua+OGoFjJ2CPm3FTRKGe7l5u4/VvK20vf3gD+ExdS50fOk73I/6eIIoklCfgK1D0bRQ4fjMrPX1qYMomsf4/Gp7WBLUECHfwGGxo6Ojo+MhOsHT8c6jckgugNlD4Bml0I88hTF4EZHGCSLaZNEURJRIkSDUEPAh4kJCEBxZiJT4OfdTXq+ufYnCcqyH4Vw2JhQUP1gY3bTb6wFDiPIgRvy0fazfproqguBZsUpZmXb/abt8G0kyVXtMq0nvD+zP3wPd7lP2g5EhVftD2I99DhavhG2oEaSX8cnjCNmZGnZ0dHT8UXSCp+MdRwiBj9cBSRwDGmQE63lCzADidVBDekJh/T4JcUglibbz6UzYFOCOuD+bazVNXRBETj+kpWQ/jIkwc4JY2gKh2yLkgrP0lNgElYBZmSDC/S4xx2sLow0PR3Zo963bQuTVlPce4b9ewf2CZnt/fSd4/bqklfdQE4Re2YDR+OwJRNRFejo6Ojq+EZ3geRcwqwpemO2hneXKYIvz/bXvvq4ccz/tFMcQBMswODC7IC4yMQvFwVjwcVt0LEEOQ6rpIU+dVZ3MyuvGB1PB5GoYtlXfCeuINt3EPKSNzgqhI0IqaRIeo00zkbb7WPLa6NFr53rdT1ut2t89kGPIMDQoqtdxkI6AQfscVuJtlbrznLlA+xr0dRAaL96DUNkffZ47Ojo6vkvpBM87hLaG42rO/nLKb997lrvlKUooLvTX+DPnv4en1s8TPeKpCu+qMEBUZGHYJm1l8lkEZdZqoLqdadVw31snIgiILERs7Kt9d+C+UWG7TWHbfYm2w4pWKE0IreeA6INXQTz5tn7mTGisxlms2t4jXpueCugHMl1BwK2iTGFURoFG6hIF6JgHRE9b8Cw2wCehLV6koYaIaft41v7U4fj1PqhtUBfCBHpcN7uro6Oj41V0gufbjPeeu/NT/vONL3CvOKHy5uxyqb3hsFjw3/ZfoHANH956rDWve/Tw3ocp6a4KU8nVOoitkGq6f0YIF/nV2/TBFI8N94tBayBoeP0IywOdWXYJ5iTswxYgk9Y5WYS0GdttBuokpLesI6S8VvtfiZ6VIWCvvT15YD8pWluWS4P3kKYrwbMSSxHQkFBh8Gdy7IEzAyzb56MIUa5+266+aJe24XnLFGwZ2uL1vZBgE6HV3kdbCNX/o16Gjo6Oju8aOsHzbaSxhi8f3eDXbn6ZU/vqaETAOcNps+DLx7e4OthmKx9+m4/y24iI2rlUKkR40nNQzYFT7ndVGUL8o0cQHyft/W1bup+2U8tD1KXSUGowHrZ6IZhzf3kR7rCzEBESMkw1FxlEO+2oCxPSWG7VeQXQBzUMgml1rHJVlFyBWaW5wjF4AbOFxXnNRgQegTgzSQyRLIVAxAnioZTWqj5oNRR10HZsiVacjQiptNbHx/pwDKJtja+fD89P5m0XVx/vmyCIRPLdlybt6OjoeIBO8HwbOa7mPD/ZZ/oGYgegwFBWcxZVyX/hK/ypi+/lXH/8yKW3hBB4td76zkSAuy9+fMzDbeQNiBEka1DXhLRQuw4VK4HgPJQmiJ15IxgknvxMTciQriIOaTQaQjosD5Pb3axtOU9Br9JYtL+LYDoY9UBtQfZYWN8ch2JklYfWen0P7IIk8qxvKBZFn7ifB81iDwkiJoFoROyq4PjsWz+es8jRyvenHWEhe6CPgsDBcD8etGyfVj90bAkXnKG9bd2j05AyNO2YDRUKvzs6Ojq+W+kEz7cB7z0zXVLomjhSKATudSeA30+aFBhemN4lT1K+x5zn2niHWD5aL5cQCsRqpEL5QG7n1Z45FvwpNFPOhAARD3dMBWscY2lHUQhitTICbOtnVAr2HjgNmJA2smHKOc1xm+qqCRGmVTpLhn34Weu0LMIO8CHVRCvS1DCkmOqb4AuGA8FwNIBoHZwCu8BTUaLQdkwv2SFWOegKzF6Y3SUk2H2C6BlCvAv6mOALZOAhb6CUs/QWWZveOmxFmwqF3FhwRYiAmRofN+E5ij5E425WV0dHx3cVb/oT7zOf+Qx/8S/+RS5cuIAQgn//7//92WNaa/7e3/t7fOADH6Df73PhwgV+8id/krt3737Dbf7yL/8yQojX/FRV9Q3Xe7dTWc3d5YTr8wNuz47CAMs/BnPf8OzpHX7t9jN85s6zzJoS511bmPqIsRomqvqEi/mrJ4lXbTRkVTDcRl54+L2x3oP1HHb6kkgmhNb0HjAOC7iqrY+RYVtuGUSCXZn8tSmjMM6d+2aCc3AnYK5D9fVQKGwtRBdChEclkFyE9DG8XGfietxuEuZuZTY4wVBi3IRZfZu705eYLr6G118HfxK2bUNLfdX0mJcZRp8SxNer54WtokFRSMHpE6ieA3snRKrcHMx+eAwZHBvtARRfheZeiETpA7yZ4t3r1T11dHR0PHq86ZDBcrnkgx/8ID/1Uz/Fj/3Yjz30WFEUfOELX+Bnf/Zn+eAHP8jp6Sk//dM/zV/6S3+Jz33uc99wu6PRiOeee+6h+7LsO7vdViAoTcMXDl/hpFm8Jn7xurT1rad6wUQXTOoFxhnWkgGNbWAiOT/c4NqFTaL4Oz/dJYSEeB2vL4VU0dnYh9UFuSREXNphnni0rjAOSgexlAwSRyQhSiAIhIb7JoJZqMFBh9vY9vZqAGjcOjSvxFDr3HwmNh5McS3ARpAmQSyZglBnM4D0Ao2IOazvUhiPtXsMoiOECM8j8yWNK0OjmAETQfzA1w5toCoqlpVGSkWUrmqJXv2uWd0vCKJolYZzoRi8eL5NFfaCUPShOwzvQJagb4ei7GQXnz2NiLoC546OjkebNy14Pv7xj/Pxj3/8dR8bj8f8+q//+kP3/dIv/RIf/ehHuXnzJleuXHnD7QohOHfu3Js9rHclUgiOllPmujq7bLWJkrMQ22tEUHTfjg4cpdE8c3KLXCXs312wuK4Z+JQf/bPv5Xvfs40SI4R4BOYsidVMqtXFfNVavpp9FTxySl1TGsmtqeSklOwO4Mq4YXB2Cl4dEVkQXIzTEPHwq+3mradPxX135FXr96pe6EE35bMDbSNDixA1sh7EFAQoZ0lpUO6IjBohwvoxwUx54O7HkF5TR+wl1oMUFvzKPLHgfrJzlaJbFXOvtrRK33mgbEXOyvtHtsvn4LNwvG4enltTgczx6ukuxdXR0fFI820rCplOpwghWFtb+4bLLRYLrl69irWWD33oQ/zcz/0cH/7wh99w+bquqev67O/ZbPZWHfJbgveeV+YHXF8e4LxDAgmSmAgnLMNIsZb12FtUTPz99Mzq0rO6bBss87pkTsXcNJjEc2oMv3nrOUYXPFeHMeo7XPB43wA1SBXaxeUg1KBg2s6oJAzS9FD6lFuzlMIW5ElCJGq8f7DO5aEtt78UyAcjPStBtUpjrbx9Wnfks/TZqyMsbe1QfatdxrbqdQ5eE9kZF6IlRmkSv9pP2EZMcJF2rZ9gJB7cpkLFPXoDSWIikkwQTA9XpoMPPBfgrPD6LMX3YHpqtfyDKT/dFkqvvINac0YzfdV2Ozo6Oh49vi2Cp6oq/v7f//v8xE/8BKPR6A2Xe+9738sv//Iv84EPfIDZbMY//+f/nB/6oR/iS1/6Ek899dTrrvOpT32KT37yk2/XoX/LeO9ZNDXOQS4TvBCMoozKNhgEUawYJBGb/QGu8CxcffY9HUAhsHisg1IaFEEHxELgHTRDy+3lkmujV9e8fAfi6iBKojbC53QrJFJIdkJUprkLomCQSMaDPrvCIX1NqqCfZIQLfStCgPuFzTWQgl8pjFX6ahU5gfuTzldRlNUsrLjdTvnANk0bJXFt6mjl8zMBO20tCUUoRAYeFExKcBbBCzEb2UqaBIlDUqCExFSCOLsvYvTZP+GQ4rNp7O6B3yskrxV/nlAA/eBjGrzvjAo7Ojoeed52waO15m/8jb+Bc45/+S//5Tdc9mMf+xgf+9jHzv7+oR/6Ib7v+76PX/qlX+IXf/EXX3edT3ziE/zMz/zM2d+z2YzLly+/NQf/FrAwFdob8ihhlOaspQOyKOa0WjA3JQLJce2YViWNt2eRnVW6yz/wzTskWiJU5qhUe8FKIuY13FoUXOyn37Ht696b0E20ckMmA38HMKE1O9oJwgcHZo9ERkHk2VVbN9xP66x+R9yfZu6AadvZnbfpnlfPvIL7MiRr15ftz4NWAqv1as5SbUIQWt5XIzI8RFvhb7ea0VUC7kxmrWSKwOE1GLdoC/U9kYRGgydpp8LHoaNrhaat6w5mjFUFZR3E1GAEcjUP7HUjXq+6zwdh3vn0dHR0PMq8rYJHa82P//iPc/36df7rf/2v3zC683pIKfnIRz7CCy+88IbLpGlKmr47ByeeVAtuL06YNAWjJCOWin6ckKgYnMdYg5AR2mpse9EBgce3SZCIGEGFxsiQChtlPWpjcNQ0WCa64KuTe5TWkl14Lzv5+Dv7wuV98Jwxh0BxP0Ji5yEXlD4F0S6Y01B4e5Z2ejDCsRI8q7TNCkuo5cl42N94VbsTh9SZf3BMhW4fe5DVcM9WdYhLEG2G7a9qg0QOahf8McgC3KooeBlqs0w4mkS02gtwNoi1OLbB/DmOEKScRZqiGowPPoIPHL7WcHgcnkWvF+x4ZAxhHteqs+0b4PbD6Ipo7Rsv19HR0fEdzNsmeFZi54UXXuA3f/M32dzc/Ka34b3ni1/8Ih/4wAfehiN8e7HecVIvKG1D1WgSFbOVjRilOUflnNoZ+mlGJCJUktNTCfeqKcYZcA6LQOIZpQOGzrPQJWkcs50N2CtnOBOukgbPYb2gaCqMc3xw8yrv2TiPfKAA1Xn/rh9RIUSEjzYAEZwDxZQgJnrBN8YdQj0HNWj9c2ZtLU7M/Yqn1eTxVTfX6/XD2bYbK2//bru0cOE+mYRtt9GYII4U9yM9q7jMA+Mv3ATogSnvr+dNa0x4yH3DQAUkKAxeuODj7EK5kjUAnji2yDjopkitfIBCHVAscnRcInwQxNpKYuWQMiwvIoge+h+96kT7o6jAzDrB09HR8UjzpgXPYrHgxRdfPPv7+vXrfPGLX2RjY4MLFy7w1/7aX+MLX/gC/+k//Sestezt7QGwsbFBkoTi2p/8yZ/k4sWLfOpTnwLgk5/8JB/72Md46qmnmM1m/OIv/iJf/OIX+Rf/4l98K8/xHUEiyFWw84+UIpKKi4MNLg02+Gz1LEtbh460fMxWPsZ7izt5haJuWDQVFoPGMdclgyTFWdDO0ljLbjam0A3G3Z8ttfSGL53cZK+coL1lLeuznvRZmoqlrllP+2xkg3fwjPzRCJnh490Q8nArB+VBGOPg2s4jNwlGfm41c0uEZRAEsaGCSPKrYl+43/EF4S2/ZFUkfL8LjLA9JwjC6cEC4Lzd9oPDTR/8vYR6rw0wrVJoqh15UXImwkQKPkJSk6jglKxdKGAWAuJoNXcLUCuRJYDZ2e0Yj3agG6hqSd6TZIlheweaBpKH6tbrB26/UXqLcGyq9waPdXR0dDwavGnB87nPfY4/+2f/7Nnfqzqav/k3/yb/8B/+Q/7jf/yPAHzoQx96aL3f/M3f5M/8mT8DwM2bN5HyfiRiMpnwt/7W32Jvb4/xeMyHP/xhPvOZz/DRj370zR7mO0JpGu4sT7DOcS4bUdmGSmvuLsIcqIWuqKwJzcLeoZRCO8dGMqCyE7wVWGvD93NnKa1GO4NGcFouGff6bKVDfDmjeOAbvMFxXC64MTtgqcfc4pA8SlFtQepa2v8OiPRIvOoBmyGCI9tojZWtgLCtKFl1Ua06rVbPKwujFsyS+6IlB9ba23NCPU3bJoUiCIE03H5ohMPq8ZL7oyzEAz/cv+3Kdps1xiikNEhpCKaHrbePX1VmPdhCvnrerz4Tq0LrRfu3O6vKWR2GVB7Xuj/nmSZ/Q7sqAeRoDNAg8dyv9EpBPd6m5Do6OjoeXYR/xGx7Z7MZ4/GY6XT6TdcMvRUYZ3l+usf12QGJVKylPbyDw3pBpSvW0wGTpuCVeZitdKG/yXvWzjOIU65PD7i+OAopL1Pj8PRUSiojTvUSgyMn4Vx/RGU0c9tgjMbiqbF4YKRSPrRxibltwAs2sj6XhlukMmaQZIyTHr3o3d2+7r0NAmI1FNSL0J6u74VOLrcyAyw5cxxeFSiLzWAi6O4Qipkl0IdoIwglVxBET0gvBfGj7y93tt0HPW/EA/tRoajah1STpgE0cdvJVVVT5nOPMYqtrc1Qj/OQl89K6IQCZOfCOAwPJHHcDhltu77adaxtZ5muaIM1xkIUZ8QqJQirVbt9RBB4qxSbR6MwdU3TSOIkpZcmGARlvUEyuEY23PkWX7WOjo6Ob423+/r9aA1nehdgvUNbTWMMC18xqwsmusBYj/UhWjOMc1IV01hDoSsEsJuvcXt5gnaGWAickNTeUFpNbTW6/Ya/pOGwnBHJiFQoNnp9tvMh+8WEyhg2s5yFXVKaijzKGMRb7GQjjusFB+WU2miujbaBNnpkajyCfpS8azq8hFCgBnjZC/U2IgLbhJSQLcCetiMUVq3l3P/t69a8cGVSOAyjH1wd7pNpK3oiguCxhBRWiM6E+1asIkfqgX2Y0DqPpDEFVVlSNxGjtYQ0WqcsaxqtWS4iBiNHHJt2uw33HZxhJXykhERG3PfTeVBktUNRW7GzejRWoJ1ARSmxapeNcpDjtpgnDUNO3TwMN/WAnWC9xtiMqrpIbzzg5GDOZOpR04prTzqiqDMe7OjoeHTpBM9bjBKSG/MjXpkfYJzFeU/tDB7BKMlIVcQ46VHZhr1iSmkbnjm5RWM1ygt6UYqxhrmuqR8ojl1lPBSwdA3CGRKhGGV9CtswiHOGSUhrzZuKXVFzUQiu9fqMsz4zXWGcJWpTiM477ixPuDE7wuF4bLTD5cEm6l3ktiuEPBsuShRD1A/RHzMNQzobD0y4L3oUZ745sg9yA5LHwRxBc5OzwmTyVlNE4HqEqMhqpMSqmHnB/ZSTJAiSAq01jgopErxrozXe0eictL9OlBc0iwaVjsj6q/EWD5oGvrpzbBU5Wgmu1bIrZ2l9Vmp0FhuqFAcnY6JIsD4uyNMonCcp7qfN3CzMJVM9kD3i6jYmOiLOE3q9J/CRQOsSgcZojbWd4Ono6Hi06QTPW4RrM4OvTA94dnKXSR3GASQiwnmHQCK9oDaaw3KKEIqdfMh+OeOkLrhXTNlM+jjrqYxu6y0CGYoES1l6jBf4CKLE4b3EWsuJrulHKUoKJk2JNQXbfoF0A+qjZwDNxd4uDUP6UYoxjtm85LQumDQFkRAUusY6h1LvzEXPuyYM8iQCNXjD1nohFMQbeGLwTajefbDmRiYQjUILuxxDsgt6xn0vnrp1cAb8gvsjGtqOKDEMZjYmtJ17D4vFABGtk2f7eGq8A+1BpQnKSKI0I82GYI4Z9mOyfBOVDqiWR5ycKPoDRT8zCPFw51iwRwznO8WfDZXVBvAWEbdxKglGBrETkzDXY7RROO9YVmvk/bj1Kjofnp83wc8IHzrc1JhGFhydeoTM2V3PEMow2tyEyJAPNknT7qOgo6Pj0ab7lHsLqK3m3nLCoqn40vENpvUS3UYHnNeh9FUIagw3FseAZy3p8z0bl3DOMzcVhamJVYwTntrZs8tiBGznQwZasaeXLIXGCR8SMipm2hRAuNyvp320s2jn2XOSpq45dZ5B74RRtk6erVPqht95/gWO5wtkJGDNk8YZm9mA+B1KaXnvwxRvd9pGZq6EtMw3IhpA/p4QxbA6CB0zC9W/crM1ojHhPr9qJbdAGrx2WNXyWM6Gi6JAzIEhIcJjOT0V3LgNMjJcvbpNEmm803gvwQii2JH05sQsgipBEjMBvclyVrMsPN5LEvXqDiqBI8Y4iZRgkMTEaG2pTBjNleGI2gxY+I+qgDF5T7C56dE6pTfeDAJNpiANItptz6kGr0GkCKGYTHvcuj1FKEU+OGZz0zIcxAzWztF9DHR0dHw30H3SvQUUpuGomvN7e89ztzg9EztwvwpECMG8KqhbKVMbwzjOKZymtBqpK5SQWGfQ7n50RyCIZMSl0Tl8dco9PUHlsNbLccBJvcDhkEaxcJLU9VCRZO5iiCSohD2j6ddzBILn51NeKvbRxiERbLsBSkrwAusd0TsyYsCGQZxet+3ob4z3Pizr6hARUkNI1oLQqe+EtnW9RxA0LtSyqAZMzpmJoKsIgubBCeglwSk5BlGwSikZ4zC6AmOxuk/cH+DNPPRQ1TUyqkF7dLzydo6BBmzBoJfifUKk+mH6BA33a4JiPAlaQoQjxgPNWcJLSpCvmW/1GKRrxO6ItbU0FGKnl8M4CzQP1h8JEYfi7ZZFobh506DUkqvXwoiNRjfcun6ENYILl9cYjt6wzaujo6PjO55O8LwFaGt45vgmN4qTh+5fNR8rFIlUGBcuYB7QWF5ZHBFJhRKCJQLtLcYYMqEw3iKAfpTjEey7CdG6YFgnJMRkJuLIz2mswWOxJqU2jkE84OLaGkliaJxmVpd84fSAZXFClq3xufmSI79kmPY4399gkKU0znC3PEVIwU7+7e9s815wUOY0dcnmoE/vG70tfRUM/VwVCnRlSkjdtAXIdhF+Vt1Kcj38nHkROvBLzlJYZ4NCK4IgicK2FHibMtrQ7JoSJQzjgSfCQeSDv3Mt8MKHZFkTNFcUr3x9PHGqGKUZkh6xUG1BdWukSESiUpxUSKmI6n1wB6TRw2XS95HBm0cmwHqIgCXnW++irRDFagWO9649BxbUECEiqqKhrg1KSqo6A5VRzAwnx0u8g96g7ARPR0fHI00neN4CTuolx/XyNfdLBLGIiIUiExE6VhjtsG1kobY6jJUApKyJhUIKiOKIHZGzlfXQXnJQTTipZkghiH3E4p6maCrErocEEpnigUKXGN0w0gkntmSuKxqrGTmNqD26KNl3Eq8km8MBP3jpSZa6aet43rmC1XltefHYUdWCy1bzdK8KBcHeguy9arCl4ywNJZI2BRaHNnaxGvIZZtKH9vG2kFldhHQbmtug98FnoZaHETRfIggeEbYXnwdXIKQiknc5f6FB0BCxZOWjE5OS9QW2KpnOYb6A/khwbnM1f8sSoYiQoNqUmk+DR1C0Sej2qohVqCnyfgtRTZGiJHvVHFitodEKJ2YMNjYR0RBE+/wJLtUPTcrwVYh0+dawJ1qjP0hYW8tJ0oj+sI+IRuQDzXhsqWuLNY7jwyVrG/k7VsfV0dHR8XbSCZ63gExGRK9TZBsRZmeJdrK5w5FGCdpoNBbdSh8P4Cwlod5nKFK2h2P6cY+DYoYxltqFFuWlb9CFC93HDfSTmH4UM8xzyhSsM5y6KZMq1BFJQtxCmwJvNUuRoIjAeySCa8NtlqbGescozl/zHL4dKCmJoghpIpRSoRjZLsIFWxmI1u8vLPIQsVkZBHoDenK/fT0+B2qtNa7RYG61Bcg58N5QzBxvBbEjRmCPoWn9dUjaMRbVWQRJePA4BM2rj5oYQWnglZtwsA/bW55hpuj3+9wfOFqFqJKIQ3u8WoN4LYSE7CqBFZ11U9033Jmd7amuYTpPsCJG5Y7eIAWZ0ebJXofWMFGEQu6qKqnmR+zseM5f2WJjI8cYR5bHPPH0NjdfOearX7rHYJTyPR84z/buu9uRu6Ojo+PN0Ameb5Gbs0PuLE/ZiAfslVNMW3chgbU4Z5T0aKyhtA21bedkS4FzDxv9h9oUcFIw9TV2fkTdX6N0NalUCKByGi8c9EFUkHiFINTfREJyedjntC65tVjQtMdhAes1xy5GCI9H0yh4abKHwfH02jmeHl94R8ZOeO/BLujLivftDKlsj/U8CdELVhEz0Z6bGoQKtSnRCO/rMCndToKvjndhorpqIz62FRrUnLV76wOIzoWBpM6Cvwd62k6kzxH02pldC4LzskVhwuyr1xz9IkzaSkJwpanBaIE2rWiSUTiGVtI2PqZaNEg1YTBKAIMUCsEYxC5CtG3kXrTzvFLgiPB+yVjqXeK4D3IN4i2EkMxnFYd7c/J+yu75IUKEWjEhM3y0GdYVKcXpCbPpAiUddbHgpRdC5OfytXWiSPI7/79XePnFYza2ezzx1Nbb+ZJ3dHR0vGN0gudb4MXJHr9y/X9m0VQhmhOlVMaghGQYJcRxzEmzxHpHaeozN+QQNXgADab0IfMyApkIFl7jl1PW0n4oRTEenGVgG/KRZzkcILJgTjgzjiSKGJHjsEghUP7BBmiJE216ow1EFT74AMUyIlMpoyR/B4wHTRiuaQtGMmWUbINqJ5aLzdZELwmT0d0CRIRXm23kQrSCog5REaVaoeSC4Z7XbTRoB9xJWN4swb4MUoWIine4eh8zm+JsjYiykNGK4WwuFwAeQcTD87XaWpsEnn4a+j1IE0+/p0Gt6oqyUGMkcibHDZNJhY/32fET1jIZIlfJVnBXNsF5m6hHqT3OJPSiAQJB2ttk4/x7ieOY3rAf/ImA/XtzTo4K4mkFqWK/bkiV4omtAUl0vx6nN+ixtj5AG0MUp9y+NePlZ/d5dqvHE+89x2JeEccKJSSD0R/RHdfR0dHxHUoneN4k1jv+YP9FjusFwerNcF6tsZtnnMvHOO95eX7A0tQ477Gt2AFeEy3wjcceEIIBkUcmQZUYb5FSMG8aKqNRTrPmS5I4QqaChQPpQ/Sn1DULU1PqBu0MEkGEoMYFISBXtnXhYjlUOWtJj0GcnQ05/bbjfZiXZU7Cbe+BEUQ7CJnjvQmmgWYSlpdZEAZu1qad2loelbWRnV5wFrYV+DhYEsfXwF4JxoP+XjtpPQI7BJlhmwLvytDNHtXgFJ4IcZZsXM3Per0y4giJIY7CorM5nJwadnMbUljRGKJtiHYw/gaHdU2sKlLjqE4EtVYM1vpsbliEdyGSU8GNlysknnMXzzFYG+HkObaScXCYtiVerCFkRpZFxLEkz2MmjeZ4USOlYHuQsjW4L1ySLOf81UscHRUkScLp3svceGmPZ54x/E+/8RxpmnLl8gZ/8geusLbeDRHt6Oh4NOkEz5tk2VQcV4uHvHillEgpMTga14AA5UUb0Xl4WOSDxJEgHkY01iKTsEwEbGZ9hlHGrF7isEQCcgGNUFTOokiIpcI6S2MNr0wOqDAIBB5PLBQjIma+CWmcFgFs99f5X13+AL0oIY+SkDb6dmseEQWRwhyogpDxI/Aeb6ahjsfNWhO9ECnBzds5W2UYIaGGEF8E1Y5VoApnzy3BToElJNdCI5bX0LZ/QwFOI6XAqyg4OIsHX6MHX6vgkOxcmGslBIhog5oRCftYU6Eij69hMtFsbC+Ik0FoiU/PI2SfrYvv5VQNsGIPL2tOFxohIsy0Ytg7IRUxqIRaRxTlMd6lDMx5JlpRuZodd8xGVLUisWBvr2E6rVjf7HH+0phpUzNvKpSKyJP74uywnHFaLXnpD444uVVSlRpbTDFWczJxGAMLWdIbFKSZYjGruyhPR0fHI0kneN4kUioSFREhcTjGUU4vTnDe4bwlljEXe2skIqJpShYmRAscjgTVFi0H4jRi/cqQab1g2d4rkGzEfQQC6UOcoSDmjhyhhQglKJQIJB4XanXa7Ym2WBkviCJF38Rn24VVSatnMxuAENxbnuK951x/nVhIStuQqpj8bRwy6r0PtTcyCy3Wrmz9cSz4EvSN+5GfaAzxLsQboEXbgj0IgkcmoZNLtqKN9VDNrS3Yo7M5UsS7UO8R6nkgCCOLShOEirB1GYyazxqeVlGdlZOSpyg8ZQlJGuFVxGJpGQx6KKkZDQ1JDOCZTxdsbMYgajAFPs5J05inLl5i1qwhbINeTLC6IY5iIrEEaUCtM9rc5uLVDOsFw80hd+pTrHMsjGAjTgGHNjGH+3OKZRNKfKRjo78kTzUROXkS/lsXZc3t41P2jqfcPDjl5GbJ3s05zjYgHMZBEwNSMGsMy0LT6AfHXnR0dHQ8OnSC503SjxLW0j55McV6xzgdMEp61EbTUykXB1vcWRxxWk6wNCTCIWXEIOnTUymH1ZSpKXGAwZLGiszFLHUQJhrHi/MDBkkOQqGQeOGYnYVhbHsZdmduMnDWn4NAIpQkVTGxjJBWtJ49kBGTOctxMSVPcu4uJ0ybBa8sDvHao4zi4sYGj6/vvC3uy97VbZRmFlJM6DbT5oKY8foBAdRGgWRwDPbxVhA+tL42q1oZQsEuaoA3e6CPQxRIpmAWEO9AdAnMg6InAvrIJEGmApwOLd2sio0jQvFy8Oo5OdUUpSTNcvK+omkk9+5ALw1lz2UJcQKxWgb3Z7sIuxERHk9Cw1D1efYUlnKd8+sJF7YUylwHb/FeEfmS87s5JEO8EJSiodSa9WwIUTATipSkP6yx1jEYpUjlcGgyBUIEwTI5Kbh1Y8LN4xO0stjacbS/YD6rsK2mcRG4SGLziPrSADFOGI07L56Ojo5Hk07wvAmsd7wyO+S0XmJxRFJysbcOUhAJhfWOebPkdnHKUTkPtThIYiHZycZkKmJpKmamBEIQIpMRvXydqS7PeoI0lkVTkUbx6ybEHvw7JqInJT2f4aVj6RsiIRipBK8UPZtgnEWpmMwUrNsTbt37PPH4cfbLUxa6IRUVs/0GOVNUO4bR92Rs9UZvqegJdTnHQVjYtrtKKvBroe5F5ISZVn0QZYgAqTVQbReZb4dxehGqv0X6UP2Rtxrq62D3AR3av1vPm1BA3AMvg0hSayGCJGWbGrsQ5m41L7Yuzn1Qu+F4MAy3NMUeJIOIpOf48leX3L2pGfQ9u7uCOILhwKPOXJUtvn6FZaUxOmE4SqltzaTIsd7TKEksLZg5UIIV+CYJqbn+OUq/RnHHMBxlDEcZQghOjgvKRc3Wdp/dc0O88xgtQWaUuiGLMyIJi3nNbFIyv9FwOl1y/bkT5pPyTOwAxA58LEnWc7avrrG5O+oGiHZ0dDyydILnTbDUNTdmh8yaArwnjiJ2+kOUjDgop2hjuVtMmTZLnFRgLUJI0ihlGGdMdYn25iy1lRIhvEBFgov5GrXRTHRJhcViiKxCItvk2X2idtxkJBTCQ9qkRNOEuC+xuUc7zakuQQuMd3g8AyFJBEhnWZZTFvIAKxRrSY5yCuEVSEVTO/aKKVIKdntrb+HZW8k00RoFWpyTyHgjFMfYE9BV22a+FoRONEYIGSJD5qQ11rOhRUoOw4gFgsOwqacs7hxBcUo+FriFRmYJalwQ9S60y8pg/hdvBSNCitANthq6GY3B90Kxt29HUKgh67tPsHZuiBA109OCsrlD2ZT0+w56imToSZMKYwzaQ+QFejGlWtQcLcY0uyM2drfYHY4ptacvBAf7Bf3Ik8aO2XzC157RlIXn2tMJz7+4z9e/ss9glPGXf/wDbGz2uXNzwmJes7ns4ZznxecOyfuS7JKiTiLWezHv3U5IM8ULXz/gq8/cYz6tKJevTVUJYGeUMX58gx9473ke3+q/ha9zR0dHx7uLTvC8KQTTuqCwDdo7eh6enexxbbDN1cE2J9WCO8sJqYyJ4gijUhyeQZzTeMO0WVI0YRZBLlK899xZniKkRApIZBScj71d7Y5BnLFsKlwYJNH2EHlSERNJRW0tZV0jC8m53hYqEkxYUHlLIiS11Tg8/Tijl43YX5RUXjCbnZCkGR8cbfPBrQtMM8l8bijziiiSZy3Qb9mZEzE+WgdvKBdTXn7uJcrCcemxIefOx8EI0MyCQ7LMQ32PrfC2TROJEpzHOc3hoaZpLNsXBmSpwxU3OHzpJRaf+SL+dEE8UmQ7Kf33b5OkgihdBBElR2GiuhpAdi1EWMwc6hdCxEf1W/NCDX4SIkmEAZ1SKqBH2ovZ2DjF6TFPPjWmf9FzdFBwUo3p6YSBisFMseYYU3lMI/Cij9GKfFEiasmdk1MO7k0Rvub8bsXNmw2f/7JmegIbX9JESBYnDcdHBV/5/F3+ux95khsvH3P71oTLV9Ypi4YbL5/ifMPmcki+nTNxDS/99nX2bxzw8ksnHB2+8WvhHaja8ifGAz56fi3MVOvo6Oh4ROkEz5sgEoITvcDZtn5GCGZ1wXUOcAQH42m5xDpHoiSpyEgixYXBBg5PoWuMtyQyAeFpnGHhG3DQFzEqlg9FcvpRzLXhDkfVFO8lp/WCqS1D75C3CC8Bj+gLYqnYHY8YjmLqoiF3oXuschbpHNLD7arkwITaIcWSoTccmIKXmilRNmbt4mUuZ2t47xm+xe7LftV+7mquv3DA1786w9owNmFza5vYE6IsXgI1mDshCiPatJPaALXB0bLk8y/exdQVl+8WPL45JW5uIvcOSOo5zjfYhaK8PGaQx7gIlmVBxHnS4UYQNITjAAfCohvL7dsVyzLmytNbZKlFipwoDqmzUGdjw/Txk5KsF3P58R0uP9bj+Pg2zSSlWOas9c9TqBFZUpL6u+SyYXdrzNpOn5dfnPHs16fcuTllPp2zXFRsbcFy6pjNGqbHjrKE6ckp2XoKcYxvLLdu7PHslxQvPnvA8XHJ5LhECM/d0wKrBNxWDGeek7snnN4+YX7a0DSa1UjTN6JaNpTLmpOjJesbPaR8B+wJOjo6Or4NdILnTTBtCu7enTKbNsQjgdiUIEBbx6xa8sriiL1qshoaQC4TejZlEGXUXmOcxeOxGKQLaS0IlSK9JGMzCYZzTROcmYVr2C+OKb2jp5LQ/m4lAk8kIhqnccFykGpU80q2T+5jLvc2SKOYe8sp1jnwnso2zE1D00oqB5S24a6MOFqcsFZXbKD4k/HjbObDt/7k2SnUN8BNyRNDmkmm04i01ydKYtBZaE1XOUgbUlyuCXU+5KAyvFrjznzGga5Y3p2gJscMtmb01wQycsQXR1A1xDsDmgubiCym1vDcizXL4pDHnnYsqzkXL+ZsrFWEVqc+83qHZ188Yj533Nm/w2CUMRrFPPl0Qp4swTSUdY/GDjHGghc0jeXwsGExEVQzz2I65ysnFX/4B4LHnjrH9/6JxxlvRFgf8dxX9/nt/3rA/r0ZRaHJYkOx0JwIgW4M3jmE96z3G4aZJ80cR06wnDV8/vNLXnlpDyFjjo41xweSKFUU2mJTxa2XlmyOLfPSsGw0aS/4PnkNWQabOykH+w118XAl2LnzIy5dXacqDUZbkrT7SOjo6Hg06T7d3gTTZYWfCdxSYLUnXRNcGGwwTnMmTclMF2ct4gZYuoa6sWhjQXqKVnB4J+ipiD4ZjdVkKuZKb4P1bEAWxThnwTY4Yzgwc5CKKFGsJzkISRx6sThpFu2kJ8dEL1noEP1RQrKTDTkqF9ToMKVdG4zzobM7Ct/mNSBVhhVQiSQUXr+BZ9C3gvcOqpugb4M3rK/n7J5f5+LjF/jeD11GKA1uEy/WOZmmaF2z0QdHjXQZ3m7w7Jca7t7+OvPBEp1aZFJiZhPuLSvkvYhmMGL7fedY73miQQ81ivGyYDax3LuXUtaag6MjlrN9ds4LPvx9Y2Sck6RbpP3LWF+jTcXenRlyb85oDONhwnhcoU3KnTslpyenqEgyGKY0jefkcMnJcUUx18yPTjm6d0rZSJ5/7gir3odC8sXfvcW9e3Pq2uCtJ0kkeS9HxZLZ3HIys1gJLoZMQBxFKKEQ1qJrj6lhr7aM+pY0TmgaR1PXId1mDHYJJ7ZCDGPi8z36zZJoovACen144j0Zk1NDXdyv5VERDEYp9+7MuPbEJnHy1nfkdXR0dLxb6ATPm6CfxPQ2IuaZwOI5MDPWTJ8nx7vMdEUkIsTZNKsQRXE4ClejEBhc6+HrcXiGKkHGGYlKaLyjNppzvTHCeQ7mh0x8hUUgnSdRMZcHmzweReQi4frykKUNLcoa3/rxtAkx77hRnj507Fp7TBVmW8gEokwwVBmPr10mj2JGSc4oyihNzbQpGCdvofOuW4YhYELS+Ij9o1Ars7bWJ4oVoPDxLieHc37vs3epasfuzojhOCbNU+I44dmv3mTv7hzR88hdRyp6TOWY40VGmY1YLnKGZZ/3PJ1g98N8zouXhhRVxLL0zOYFN146BqHZuwd3b09A9lnbKPjAhy8glSSOJMNRjrUWIWpu3Sz50skUbSQH+xHFHNI0ZvvcgEgZsqxgNtFMJ4Z7Lx2AtSyKiKN7J9z7H3+PfpawPDAY7VFKkCSKUZSATOn1E2ZNicOgrSMSsGxiNtMe2xdz+ukR/aLh8DTG+pjBOMXUDqsNxkGiQBuPRSPxzCXYHBqfEemKKIIkg6JosObhwmUpoa4dcawY9N8ht+2Ojo6ObxOd4HkTzF2FG/hQViIFNZ6X5kcgFBJBL0ooTUX1QCWOae0BcxejkDhsuMcZJta0rd8lhc5IBhEj0cNgmeGwKLIoYT3t00tSKmfQxjFzFdo6tvsj5mXFRC8xWCQ8YDP4ME63czh9qKfZHg356PaTfOTck0RSIhG8sjhkUpc01tCP0rduxpZIQI4hivBNjPEpQsaoSLaDRKd4U7K3P6Eqj7HGc3TQZzrro6KKa09uUJWaqtRQwZrMiOOEaSSYK4u0Ed7D0YlGviToZaAby907AuOCweCd/QWTSY1SjnIJx0cG5yt2zluc8RweLlBK8qGPrHH52gYnRzOe+cINbtyoyLKIyUlJ3QQvnLKs6fUc1644dN1w907J0WmIzCxrGRrSasvSVhQLgmWQDFE2PAihGIxTLlwcsX8imc1PkVaQ9xX9YZ9rV2LSdcvRQHNnX7GM19js1+zdKDGxZFmAbtoB695SLi2VdehSUhlHPg0TRYyG6bFGv+pNEceKKBZcvrbGeOOtrdXq6OjoeLfRCZ5vkkldcFBMEXhEvBoZAbVruDE9pJckeOOIWlnz0ER0QEjBKOqhrcF4h3aaBkfpgvvOvKkxM8NSV9xZnAQ/HSQDmxLXETO7pIhqNpM+XsIgSRhGaxRJybMTg/EGiSKx5iF3ZQBvPa5wuCp0hG/0Uj608zhPjs/Ri4OrsvOeWCqkgFhFb+m3fiFTfPoYuJq01+PKhRnVZM5oJw/+Om7O4dE+ujli51xDVWTgG55/viTvJXjvmE2CWjt/PufchRFZr8cLX5cslguyPGa5aJifVpjG8fR71mmKOUdHJShNKRvm1PiewxSQxBFam1Ak7qBuDHVlqCvLKzeOGOzGeCnQOqJpFHXp0NrjraWsLffuzIgU9HspvQyM9ExsgtKg0Oyea7j2lGBeJtyuYDYJnVHWQN1o6iZCn1jUacHGRk5c98kHJcO+QsYFX/wDz4e/RzI8l7GRpYhSE4mGtXU4nbcD31+VeUxmBhULpPFnQ2oX01Aa9WCWcjCKec/7d/jv/vsn+RPfdwmlug6tjo6OR5tO8HyT7JcTTpolkZJkOqLBAAKHZ+YrZnUFtLO14CHBoxCkMqSNlBBMqoJT1zxULeOAU7OkLi3aGyIUsVGoheLELNFrhqgniYRkI+nTWMPMLlnamlRF5MT0VEiTlEaf7V8QZmq6ZYgyJClsjdeIEEQPXOykEFzob7CRNmRRjHqr29JlAjLB1TVq7zbZbIYXNTx1DWMjGu0oSmicQCUKSZ80WzIpCu58/gSvBYnUbG82rI9qXryeYQxs7gzQ2tIcF5SVxguYTi1FIalKgRUatR6e62g9ZzBOGK6nHO7NWyEqkUKwsdWnqQ1H1Zzf+OyM7Y0+WS8ikoqi0jS1QzeGKAnRJG2hrgyDsWfrWsQ+kvquZigcu2PN+XWJNYo4vh8l84B3IdxTLhuq0jCZ1mxs98gzxWDsufVyRVFYhusZVipe/nqNrZeMR4pU9UBp7g8TuY90nkh7klSytTugri1NaYmUwIuYpjJk/Zgf/h+e5L/7Xz7FcJh2Yqejo+O7gk7wfJMM4yyIB0CpiMxJtLfYV118HKu55AEBpChGacZ61megYhZN+br7sEBtNJmMWzEiWEQ1C1vjvSO3EXNdszQ1ldH0ohgL5FHCuWyIE4KpWRITaoyidv+1ciiniZ0nkwkRECvJ4FWt57FUxMnbk+Lw3oQbLhTb4jxeG27fnHP75oL+cIPaRkznJdVU4EwFGdR1g1EOXTqGY481ljs3T3nhGU/hY9afiCkrw7SoKQtNVTa85BwCQX8Qk0QKlcJy3kAF6VrK5aubDIY5927PiCNPlgs++P7LzOY1/5/f+AqTo5I72ZRrFzeRUlKWBttYrPMkQpD3Y7IMoqikWGiclWRJRjxUVBPDydQQ3YL9Y8F00p4AAVEsUEphGkNRaJrKIWpLmkouXtxBIJmc3Gs7wCT7h46T2wIloFha+rlgUVia1n5btK+vJETu0kTx3vfv8Bd+9P3cujHlua/sE6WSwTBjclxw+do6f+q/f4L1jW4yekdHx3cPneD5JjnfW+fJ4S635sdUAuIoJhcps6ageVVvk3ngtgeWGI7KBZcHm3gRWtnFG0xRXxU1pyJCxw4zcPQGMbES5GlKJCULU4fJ4g52eyP6SYpzjsNyhhIRkYxQ3qO8QQJx5tjYLRl7TZmPkHGMQOHfho6s18O7KjglA5oxh3LEvLKMRcqLX3uJl56fkeYDPvz9l1genvDCK3c4uDdHZpJsUzFez7A9B2PD1/ZKpq9oDvc8wyuOtbFB1Zoidayvw3IBy1nDYJQgIkV/LcNrj5gUVI1lGVUcHSwZjBIuXc7Ic8PVq4ILF1PEPUF9aGimDp80zAcNo7Wck5Oi7XUTRLEgTRVWa27faKhrmBSO5axAKnA64vae5N6hQEiB0SGy1uvFrG/kVGWDcyBEOPdOwGljOFgUXBusMximeC/oR4rJ8RIIqbBiEUTjcgk2lgjnEAYSD/EgIs0TBnnEhz9yhSvXtnj8qV0++oPXwsBTF/YllSTpOrI6Ojq+y+gEzzeJx6Ox9JMM6zzDJCONY8rTCuEFEigekjoPM3c1NxenGGuw3p11VIU4jmgrgoKb8tJZXOPIk5Q8S0ilQkrFQCVcHG6y1BUzXTKKcx4bbXNQzTkq52hnGCQZm9kQBUyLE6ytURbOxZoUQywdRiq2swG9t3gqepha7l/r0uwNdVVSl5qytNw89ewfwqV0H9tM6fcshyeer335Hvt35xzuL5nPapgJnE45v5Ezfk/M9XvHVC5mUliE9PQiyVoOaiCp+i4MYBdQLAVRHOEkFM6TKsn5i2MWs5ooUeS9mPFajlxX9POGJIEvf+E2Lz2/RDfB6Nrb0E5fLhtiJakAYwyzmQ1pR90gENR1W0/TDnOnfVXtA2PsvYNeP2K4ljKblqFFHY9QUPUidKT46s0pd5+foGuDlHB8DL7PSjHjDNQFwSvROZCCpC/50PduMxj3OT5ccuH8iHMXxmR5DMBw1A0E7ejo6OgEzzeJFJL1ZADeY7AY5yiLOZFSRC5U7WQyZmFqLO51qizg9vKIXKU454lQrWWgJFcxAkFlNaadhi6lYBznDJOMXKXMTUltDaWtOd9fZ90MSCPFVjaiH4cxFZlUeA/raZ9IKa4LEM0MaoOxMTWKpVOsq4Rh0gMEtdVtsfJ9kTJrSoyzDJOMSPgw3RwJaoQQrx8h8N6BPWE5L1gWCf1Bn35egEypm4QvfW7G/jO3GPcT4t3zqFhxOJ236Z2G02PH4X7BbFpjtSVJFMY4+nnKIE25tLtG4yx3llMioemvxZzfXOexy0PuNEecRnO00ySZQsUpAIu5phcpzj2xzk6eUleG5bKmKg2LWU0+iKmN4pVXao4Oa/b25oBHChBesH93RlNbtHa49gU12iMyi/cCjyCKCXU9saOqzNmg9NeeIMfkuMRYH7qrCJ1UTojgnG0Ei8Kg2v00dTB5vl8UZkhkMGwUOiHvx3zkIxc5d2GN0VpOcbnm3Pkxu+ffBtPIjo6Oju9gOsHzJtjOR+z21jiq5twrT1FC4oFEClKZYLCsxf3WgPC1ksfgiRCgJM44JJZelDBQGYWuz9ZRCDbTAcMkRQlJrCRNpZk1BTNTcFAs2EhyEHBQzDnfW+OxwTbH9ZyDcs5hvWBaF9TVhKuyIY5ivmDGWCwi6rOtJAtd4grHXFcMopQL/XWkkBSm4W5xSm002/mI86kEOw+hE5mEaeavh2/QzYLTgwmTmaDX81y7YpAqoakvs39HU0w0qTY88ZRhtNnjiy9G7B1E7F2vsXVNU4eiY5VEbJ7P6A9T1od9zl8asZUP2XhiQHRym8HVHGs8ly5vMEi3uPb4Fjeuv8x8vsA7C3isce18MoFdaEQ/J81j+qOUw/0FzsFsUnNQGITwDNdSzktBMa+pq4ZGW6rqta+hB5JEkPZymtrgXBAwqVBkY8Vc1zR1u/Cq1kaCQ5DkEdEywhlHVYU0U1oYpFVI45DWP7Qjfwoo2gp4z7mNil4SM7EDNs9tcunKBlkeE8eK3fMjNrd7zGY1WR6fRXk6Ojo6vtvpBM+bQElBJsKpEyIkovpxRioltTFU1qAQVK8b34GUiM18iAD2iineR2QyZisfcEOXWMKX+UzGJFJyZzFBCOiphIVuKG2NN1BqjXYjGmupXMP12SHft3MVJSSJiqidRjcLxnaKdJYTOUSrBI1kO+kzjHPmuuSompOrEA3RzpK+XteOjJlPHJOJZrjWsL7Vx3uPrxtEHCFUG/ERMVJkeBFhnSJSVWv6Y+j34crTu+xXc3bHklEuqW/eYv1kwYuHMaYBox1xrhAS4kzSP5/yxPs3iBcJTWWZTRpGaykXL6yjS0exrJnPal5+8ZjL19Y5d2HI8dGSsjBUlUEIyPKErVF4fapSs3tuxNpGztp6j8Wi4sYLRxzcO8VZj5CbjNd75MOE6awA89r6JqkgjiWj9QypFOVSU1Ua7zzOKraHA5LNiNPTiqwXsbHboyg09cKQ9zIuXFijqY9ZVhUmBqFBGY8yb5AKfSAtpqQAMrYujPmex59g+8ImUayII0maKaRSfPVL95icVly5ts6f/IErraljR0dHx3c3neD5Jmms4cb8CIMjj1J6UcY4Spnpilld4r1D46ide826wUtYkKkEgUA7QyQlqYy5NFhnnPS5OT8+Wz6SkuNySdG2rjdRMKxrvMF6j3aauJYIJEvdUAnHSVlwbbTFlcE22hqeNUvkYkJPJZxYhcORKsWF/ibjuIdvx1Pkccxa0iOR4S2RyZih6TGUnu18iHOCO3djZjPHbFHSHw7h+Ah99x6y3yN76glEFCGEQmU7bF8c0V/39PsWKY/A1Uhf8Cf+5A7zp7c52p9xdPcOGEtfKgaxokokjYBsIElGEd57Fns1+8mCJ67uUi4bdGNwJkEogdaGRltuvnIMNwQvPX8EAmxjkELirAMRurQef2KLNFMs5jXZIOap920xOa34wu/fYrFYousCY+DurVNuvHzKct7gnUAqT5pEQeSkiqY2JIlEtR5Fy0XoCFuZ+jlnOdhfMBynZHlE2lOoNYiUoFp4mlKzXJYUZUOlgp2BoO0yJ/jlSA3qLMrzsA+SUBFNPGbnycd4/D0XKOYVr7x0RBJHpHmEUpL9vTlKScpSY4zrBE9HR0cHneD5prDOcWdxwovTPe4VEzIZkycxykkWusZLgfSS2EH1OoXLFhB4SluxX1piFYciVxwSyXEVLlS5jVBSsJ4OOK7mOCBCspONOWnmmPZiaAHjHD0RY71EeMl06ThNC6y3PDk6xwd330uV57wy3edeU2MdDOKMNIqpraZsNJvZkAu9dYZtK7pxluP9JQe35sSJYihzsl5MkmZI5YgThZSC5vgYu1zitcaVFWo4AEAISd7vkbdZL28FmGOca5iXJSczwdFRhWDAhSf6zJZHFPWUurHEsWJjfcDgsZjDvTl66YmbmHpmEJGgN0y4dfOUL/3BbQ4OFuim9ZgB4kiRZhFJHpMPJWvrEcM1GI2D787tmxNuvnTM157Z5+4rJ5Sl4StfvMfkZI6S4ZxWdYE1CuMseEeeJ1y8vMZ4LWM6KTg6LJGRxFmLUgLTGB4MzDgHdWkR1KgoorGWk6MSs7QY7XHG8vLzmqJqIIIojYg89DMZHLS9QEWWPAV8OwrECGQESgjiVHH1iR3OXdoMzs/HDtM4jg+nZGnEcJxz4dKYwTDj0tU10qz7L97R8Z2ODy2d3fiXb5Hu0/CbwHpH44NDcmkaCt0Qm4hYKAwWPGQqI49AGUFtNPX9yVZhG4DTDrucIx24XopJEqZNST9O2M1HLOMa78A5j3AhApPGMf0oZu+B4Y+C0BG1NBVF6ZB4jtSMeNkwbVKEkMybkhemS16cL6jb/yy+LrhbnGJxJFLh8Ji2teignHEwn7E8rUFLiqLh+WcPGA4Tzl0Ys7HdJ89joljhd3fw2qCGA2QviCXvPca4h4z2kBnIPkfLkhdOKprCkytBf23A8LF11A2DdRNipVhb67N9YcDwSkIpGiY3K47vzjk9LMh7Ebq2LOcN00lJsWxw1tEIT5LGKAVpljFaz7l8ecTWVo2Kanq9jMOjgpeeO2LvzgznPIcHC0xtmM9rrAElwjBN8OQDhVtaDBJrHeP1nA9/9BJH+ws+98U7LKcVkdcIaxiPIoqC+/U67QsjlUBKwEjqiUYXBqsFsQznKJIKJWAwSNlay+llEc8+f4icW0TkSfMw66rXB6NjoiRCAINRhhAwn9ahoH09RcgNimVDU1uiWPLBP3mZre03qLHq6Oh41+C9PxMzzXRBPOyhoocvy7MXbrP/u18l31nn/J/9ECp9a7tqv5voBM83QaIidvIxx9WceVNh3QztHE548ighUzGjqEeDIVERxJ5ZUzK1ReveAhKBqArSeU3moEZQRzGTasGkEiRxTD9KaTBM6yWlb4iEIvWKw3pB5fSZ0dxalNOLEqaUyFijpKRRC44qzZaA507u8eJsj1O9xD/wzcDhiKVCEUwH19M+/SjFecfd41Nu3TtBWsmV0SbCSubTiolxbGwN2N4dnG0n3tkm2twAKRFC4Jzn9s0Js0nF5naf8xdHAAgR46MtFm5O7Qq005zenaIXNXVlOH9pyPu+Z5f5suHy1TXSPOJrX7/L7LRieU9TaUejNWkas783R3hBFCniWKK9J1KwsZ0xGvQYDDMcAm0cL9woWFCyveOYPTulOJhQVwZroSh06MKSoFRoKQ9pq4j3fs8ud+5OuHN9grWe06MlL79wyHzSECeSNAVpBb1csrE9QGUJ11+c4Fst6iykcRT8d4xHWDA14D3ZMCWOFMZC3ldESqGEYDqtsKVFAd5A3cD2lmDr3BbnL+1w7vyQ/btTytoRx+E12djq89iTW0gp0NpSFobBKCXvCpU7Ot716EXB4edfoNg/4Wv/999k+fxtzn3se/hTn/4/4BJomiWHv/k1nvn5f0dzMqX/2AUOP/cC6c6I3R98H/m5Tcy8Ihn3SdeHXfTnj0EneL5J1tM+H956jFhEfNVaSqfBC2IR6jFK0yCASChKahocqYyJZcQozpnrikIYhCkRSFQU4QWcmhJHayJHdOb3IxFobyldgy5D51FGzE5vSD/O0M5RO4uJPYkMV27rHLOq5LCeMtXla2wF19MBVwdbPDHaJYtjEhmhhEQKSawjXB0MD8/vrpH3Ym6+cooU0B+89pvFWbEy0NSGyUlBWWikhJ1zg7OxBUIIzo96aO145faMl768z8G9GV/63B0ee2KLD3//BZ54ehfvPP/u//qH3HzhGKNNGC+hBEIrdGMpCo23js2dAZeurHN6vCDPHB/68Jjh2ib7exWTScn+3Tl3pyfUkeHmvQXcsjQFDBIN0nM6i/GRYG09ZzjMmJwWZFnMe793lyRWVAtLHIc6HYfnlZdOObw3R1sDkWc8UGxs9/iBP/MUv/87+9y+PqF5oEa91pY8i/HOhrlkUXgeSRpz6eoIhoLjxYzlnYbFQUMUSYRcmVAKygKOTyVPvG/M409tcfvmlOFaj/PjFCkkurHsnB+Q98JrkmYxg64TvaPjXY93jtnNfV76N7/B8R88y/xozvTzz4G2vHLrkHM/8D78tuDkay8x/cItTp+5jisq5i/eZfrll+k/ts3t/+m3qZcW72O2PvQE7/3f/g9sfO/j7/RTe9fTCZ43QSQVc13ipaevMq4Otpg3FS9M7zFtCvAeRzAplEKihGKc9NjIBsyaAptGzLbWKI2APEE7jXlAllQYBKELORS1ehauDuMsEOxkQ96/cZnDekGjG9ZGO8Et2XnuFqcUpmbRVBReIxBE3iOcRClIRMw47QUX5yjiuFpgvGUt6ZNIxcZaj6er86RRzGickaQRT713ByH4I2cuJWnEeD1HSMHaRu81y2dKIk5riv2C+aJEG0tdGb7+1T329+Z87E/VvPcD54hihfWexjg21yJUHCFwLBYaay1pFnHtyQ0uXBzzlT+8SaJqhiNBb6jQt4O3Thw5fG2xwtHMIK4F/bThyYsNGsv1u7Bocq5dyinLhpn01LXm6HDBdFZxOllirWXn3JC19ZyXnj9mNq2wDmQUQtE37hia37zN5Lh4eGaaguE4JZIRWlusEwjRpiCt596dOW7oiTc8cuxJRYLWDi8FKvJnA0Elofutqg1aG7z3XLq6jhDB5XmjGw3R0fGux2mDKSqiQc7s5bs8+3/5f3H31z5PPVviqwYGOSDBawSe6dducvzSyyz3jqEJnwurD5hyMsfvSZZ7xxQmwkUJtYwYffYZqr0T+ld3GV47j4y7S/vr0Z2VN8GiKTmsQvHwII24OtzkuFrw0mwP6y2Nv1+3MyDh8f4Ol6JNbOI4TGZU1uAiiRXgWqnz4IAJ/wa3ATIRsTtYQwnBSTkDIbmSD9DeUeuGSCoWpqaxrYuvF/TnGU3jcX2DyS1FU5+ZDDrvcc5zUgWPnURGXH1q+yH35Sj64w2XlFJw+ep6W8MjWcxqqkqfCSdjPXdvTVnOa/Ikwa8JFpOS5aKhLBp+4//bcO/uhHOXhty9nTMD8IrRsIdpaiJlaO11qJaar39ln8lJzdZmxOGhgKMFt6/PODic4p0jUpZoCaYCpyKG64q17QjdNGTHEelAMU4nVNOKyMCiSbl3a0atLWUZIjPVYsmdG4Zyqc+EiBBgKsHJQUlVOPI8Rsm2jgtY28pZX+8xnzY44THK4mOPMIqqMpiFxc0ssRYMfE6aRhRliYgEcT9lPEjwGvr9hM3dHLXpGZJw7dwWTzyxjfeglOiGfnZ0vEtx2jB/+S62MTTTJcs7h9Qnc44//zz7v/tVlrcO8Y3FS8Fg1Cf/wacpb50w2F3j4Pe/zumXXsR5z+ipizz24z/M3q9/geJ4ChsbVIMBzGdoLxFpglYxt/7z7/HKdMngsfNc+2t/mit/4ftxtcZpQzzqd+muljcteD7zmc/wT//pP+Xzn/889+7d41d/9Vf5K3/lr5w97r3nk5/8JP/qX/0rTk9P+f7v/37+xb/4F7z//e//htv9lV/5FX72Z3+Wl156iSeeeIJ//I//MT/6oz/6Zg/zLcV7z2m95NnTO1RGg4CL+QbjpMe0KhklOUVVYh4sVPaObJngG0lvLeax4RaZijmtlxjniISgMg3LV3V1eefBgojvv1FjYJT2sM7yxeObTOuCRCmOVIyQCuEcxhqMt+jV9hqYHFXgQGlJfxCRJwmPj3bZzIbEMkRTlqZmWi/b1NbD/zm89xzuLyiLhq2dAf1B+obnSEpBkiiqUvPsV/eZzyouX1vn/MURi3nNbFpyfLSkbgx1pUMExFisgOW85LmvHjIazRmt9ZhPGg6PGmq9oJcnCCHQxuC856tfuofzDeMhlGWfe/cSQDObl1RLQ127NioV6nRkCsloTK3gtK5pIsfaIOLkdIZEc2HDclIIFibBWRcibAYWM0eSliSJIk4kgpCCVJEgj2p6qWC4MSCK11kuKnqDhAsXxjS1pa4sA5HRCI1WDc0RuMZQ1Ra3AL3wbFyOEUnYXtpP2b404vs+cJ48jlBKcO6pIc1Yk+1GbGcQ2RkkQ4TsWs07Ot4NWOc5uXeMqDXDzSHJqM/k7jFf+ezX0aczNr3j5Pe/xv5nv0Jd1OAsUipEJFG9FGMMfRmRP34elcYcfv5Z3LIGD7Nnb3H1f/NDfOgf/k2e+T/9R2ZRjjCaSA3JtGX0kfeSCqhfvkW5f4opa17+vzUUNw/ond9AZSlr33OV/sUtgO/6yM+bfvbL5ZIPfvCD/NRP/RQ/9mM/9prH/8k/+Sf8s3/2z/jlX/5lnn76af7RP/pH/MiP/AjPPfccw+HrFxv87u/+Ln/9r/91fu7nfo4f/dEf5Vd/9Vf58R//cT772c/y/d///W/2UN8ylqbmhckeL073WTYV47xH7R1/ePgK98oJAujFGYumYRWDFEjuuSm1N2RNTDZUnOuPyVTCQT2lMfq+OGnxpcdMPN6AzD3ROHyTHyY9chlzc37EVJdoHKmPOCin7Xj2MNpCOs6iRknksTnQxCQjhRKSQmvuLo+50F9nLQ3dPGOXM05yYhmRqYeLXotlw93bU+rKYLTjifdsP3y8PjgaR7GiaQtZiqLh3p0Qzalrw42XT7j+0hGzSRAPWS9iclqGAZn9mP4gxhjB6dGS09OC0TijrjXVUlMVDVESgfNo72mEwdWQSc9iIZCqRhWeWkvqqsFad3ZcwyFEkWCx0OzdXlBVA5RMyVKLRVG5jFRq0lTz5E7MzdMeR4clTRMib1JB0pcM12IiFKenDlN7IjwXdiPOb1om0xlJkvEnfuAyu1c2OTxYcLS3oD/QnNscIkZwcG/K4bTES0Fdl6GTSwh6g4SNjT7pJGIwSHnfBy/wvvfvkCThv2Y0EOxXU7ytSasDfOWhv4von3uL3tUdHR1vlnI54/O//wzP/7vfQz93hycubfLh/+OPsy8jnr2+T3PviPM39zHPXqc+aj+n44jh+y+SrvWZvXyX5mDK8WRJfn6TfHc9DJZehfUrwzO/9Ctsfu9j+KKmvxnBKCaLYgbZgFhakrUB+fuuIiPF4tY+937jD9n/va+SjAbsfPR9PCZh8coeQko2PvQEyei7t4PzTQuej3/843z84x9/3ce893z605/mH/yDf8Bf/at/FYB//a//Nbu7u/ybf/Nv+Nt/+2+/7nqf/vSn+ZEf+RE+8YlPAPCJT3yC3/qt3+LTn/40//bf/ts3e6hvOVHbyq2QCAH71Zybi2NqoyldKFqOkfRUQqpiKldyT9RY74hPFFmcsJUOcKVnYqqHN65Dl44PHoPoJbgBCC+ZyBoaT+McBhced4alrpEIEh8jlaQXZXgjwGsSBeMLsJENsdmA/XKCEJ6Dao71DtnOxIqkInMx+3cWRFHBzvnRWSorimSYDG7ca3xdjHHcvTXh+HhJnsd45zHWMxymjMYZk5OCr395j8O9GWVlSFPF1oUhURqRZoo0j7j6WMalaznPfWXOYl7jtKMsNEaHbeHBWkOkgCR43eChMaLtsBIsl5r5wiG8ZZA7itIjI4mUgiwDYz2zWYOxc648scnWboKpLZNScTJ3XEgMdbRBmimy3KAiwXDs6K15lo0iShWDKGN6UrBYlAjgNqCXnh4OBDxxPuepj17mq1+8y73bU+JUkccJ73lqh/L8DrfWJyznFS88f8xi1tDrKa49tslwLeP9HzrP409usr07fI1RYJ4keF0QzZfg9IPTSTs6Or6NeOeoT+bILKHcO+Hr/+Y/8Ye//RzF/gxRNtx69haDrTHr/7u/QKwNdu8Ec/cALyUkEWiLymNUmtC/skuxd0zNHLMsaU5nxIMcr1/1BXhWMvn6LWSiGK3FrF3ZQqqIeG2T+t4UlCBd65PtjJhfv4f3jmr/lOpwSnU4oTw8YfTEBfLtDdQgZfzExbM0l/cevEfI7470+NsS37p+/Tp7e3v8uT/3587uS9OUH/7hH+Z3fud33lDw/O7v/i5/9+/+3Yfu+/N//s/z6U9/+g33Vdc1dX3fBGU2m31rB/8NkAgiISl0zVJXxFJyMV8j9sEteebKs1RWgmAjHWC8paDBe411oK2m8RZrDM69zuiJGISBXi/BNAabC5yPEA6UDAJlI8ugchROt+aDlgjFzJV449jNxvTTEafVDGUbBirmyc2LNFHKQpdU1jBQGdGrppkfHxXs3Z0hlSDvJ/SaOae39vAb61w8P8L5AcONPlWpOTkuODpYcHq85M6tKUaHWpaN7T7LRcNoLSOOQrv0wd6c2axGSSCLODgpqAuNN55LFwd85Ic2Ga5F3LtdMR5n1I2lWNYY55AJqCQIQGcgVgJsKAp3BioBR8ca4SVN44gVbG02iLHnaJnjPJQVNA1Y6ylKzexkSV011EJw5B0+7WNmjqfWE0aRp6kTds4POXfB8bWvnzDfr9AmYn1dggIbPAmZLmBtLUcJxaAf41TEF37/Jof7S0bjDKMdy0XN/u05T71vl8ee2CFJFb//365z46UTLl1d5+pj66hIce3xDdbeoAg5lhE+GcLwUnjSyeitfFt3dHT8MbBNxVf/z/8PXv4ff4t6UjN68iJHX3ge5TwyyUmLAl/XvPIrn+Hg97/O0FiS0yUiEuTnN+id26A6nGCKmtlLt6mPpzTzZagNjCK0d8xeuIOZLx/ecS8lihUqS8FGNMc1w2sbSBFR7J+yuH1Ifm4dGcX0r54jWh8yf/keblHSnC44/uLLTJ69RTIesPe7z7D+vqtc+l9/jO3/xdOcPvMKThvWv/cx0rXB6z7vR4m3RfDs7e0BsLu7+9D9u7u73Lhx4xuu93rrrLb3enzqU5/ik5/85LdwtH98Jk3BUT3nsFow1UumuqSxlsvDTcZRyuEDvToWz0m9IFYK78ALgcDjhUBbw8I5UpkSUb7GkznNJe87d46qaaiEYRD1qUzD3BYkUpKgSGVC7SwO11YMCZq2aHaua96TrmNjz5I5C5Wx19Ssy5j1NoU1TLJQ1Ezwz1nV3sSxRCiQzjG5fotbtw8xX3+ZC1cGbO+sI/rv497dipsvH7O/N8dYy/FhQV0aLl8Lzr5VpVFSIJUiySOMdSSpJI4UWS/m+HSJ0R4lBcVS8/ILFRcv95hPLVKF+iHdOKyFuAdJFuOMR3mIVUwmHWVToyOwBmwNkXREsSCKAJVR1kHoGB1qeHQTtuusZz5vaIyjRFDlAtNY1lKL9bRiTjOZSA4PBHdvNZQFeDTKh/OT9yKMcSS54j3f9wRrgxgpBTePG06PJ+Bh69wApQQvv3DEctEwXs/5yA9cpaoM5y+O2doacPnaOmvrOQjBcPTGdVEQ2vpJx2/F27ijo+NN0MxPufebn2fxyh76pKJ48R4AOZDLeVjIQ3n3iPLuSZghKCUmT0j7OaPHz6OLmmLvGIwNc/qkR8QKby2RV1jXhI0E0zbEoE+61iMZ95Fe4D3opcE5iZ0XOK0xZYNeVOS7a5z78x/hxudexr1ycBYKr45nID3FnSNOn7nOyRdfYnH7CPG//4vMX7iDyhPy7XEneL5VXl0Z7r3/I6vFv9l1PvGJT/AzP/MzZ3/PZjMuX778Jo72j2bRlOwXE5btgE+L4255wp3yBOChUaEOz9LWCAu5SrHW4nQoQs7iCCUlpa4YRj0a01Bjz1rTPVDaBiMdpTGspfDBjUtcnx5xZ3HMqS2pXIMjzOeKCTOyZLuuKQyvLE4wkaUUnkIUzN1tHh/uMEp75HHIAZeF4foLRxjjuHJtnfF6zq39E/aKKVENa3nGorRUpzPSfkM/qYnL8xRLQd1YBoME6zxGO8zAkeYRl66MuHI1oSo105mgmDfgHUoohsOUotDo0iCERArPfFrze5/Zw2pPVTUgJBKPF6EbKksThqOY6WmNaRy9VNLgQiGyDCZ/AFJKermirCzX74TW7tcLoHkgiSXrGxmcTPEVNFrQG0hOj0uO9htOT8Jnxenxys0aIgW2caRxxIVLa9RVzblzKefPOapaMJ976kZz8+XwQTdez2kqw3LRkGcxde2w1jMYpuyeH6Eby9bOgF6/c03t6PhOIBr0STYGWG3h1Vll1bqYatteCFYLWLyrKPdP0NMFi/1TqAwoiPoZMlLUkwVECplIZNRD5hmuanDeEeUxOI+pGlzVEBU1zjnSUY90cw09W1IcTJFt6/rL//n32f/CS0TLgtg7pADKUAB9Vha0f8rxHz7P7f/37yMQiEgyvLqLbcJAP5U8usalb4vgOXcuFFTu7e1x/vz5s/sPDg5eE8F59Xqvjub8UeukaUqafuNvx28FxlkKY5g2JRoLq2GPzkHy8IwTCQ/56mhbwRxQYVJ6nqTUtqFyIc0l8Mh2iKQnRIduLo7PtpBIyU42ojQNc1NTen227bC8wONIUSFiY2HmCygFVakRkcD3G6ZpydXxNpvZiPW4x4vPHvDcVw5IMtVGdxSTZcHS1tzcOybfOYe6IDitEtR8isgkiyPLcm6xxpHkMWvrOevrOVUTPHWO7h1x5apgayPm1isTDu7NWC4a4kQxm3nm8xrdWLy3NBKUNAihcN6hG4+U9mxAeZQIYilw0sPY4ivPsiwxtaMuw/mUEagY8ixiNm9wrxlhtirfDv8qCVVtON5f0Es9tnL0exHepyFFd3JfKBkNcQxJIsn6CVkSMxxn7Oz20CZhkGtmk5Isl9y9u+DkaMHJUYFQ8If/8236o4S8n7KxnnPt8TX6g9BpdvWxjbfgHdnR0fHt5ORuQXzhCsgvcnYBWKHDJzESyOLwbaxuQhTHe/SsoD5dBPEhgDhi/N7LgCc5mVNPClQsiPo9RKSoDyeszLtsUVFNFiAkLm1ItobIPOPyX/oY0SDhxn/4HZZ3jjj+8kssX76HcgKJx9L2sTz4xa+NoNcnCw7/4Dn6FzbJttdY3j6mPv0CAMnmkGxjRNRLcY0hP7dBlL/919hvB2+L4Hnsscc4d+4cv/7rv86HP/xhAJqm4bd+67f4hV/4hTdc7wd+4Af49V//9YfqeH7t136NH/zBH3w7DvObw8NhNWWhKyQC15qyCC3Dmzx+aNHXEgEuLDpvCubUYeBlO638wVFMDqjad6kECtNwr5xS2Br3qoJVB9Rn//ksEaByhas9uUnwdYJ3kCaKJIqRQnK+t0ZKxD05I80UUkkGw5Q0j1nr9zncX3ByVPKl63u4ynH3nuCOzRlPUrYXJ0yOSrK8IUkEx/sx2+c2WN/ooRuLdRVHRwtuvOK4faumXGqaxtLUhlJJjHHYB0SJSD3jUYJuDLgG60J9jGjDVbrxmKmGdQ8O6onDNmdPlyiCNI2wzr+O2AEQJO0gzjSFWgucE0xnmjpz+FixtjNk48I6J79d4bFIGbqzrAmR5ygSrI1zds4NGI1ynHekImJrI+Xq42v81n894KtfPqSuDFIK0jRCrgvSJOLqY0OefHqHK9c2Oi+Mjo7vUE6XFV/53WeZ3J4TXdilOX2D0gwHUZ4R9VL0vMRqA86G6Il24QNbCVSWYpYFwycv4rRFlzW20kR9D0qi+hm2avBljS4qhJKISOK0pT6e4aqGO7/+OW7+P/8bi7uHeGMwRRM+54INLRLAP+DwNkhJx0NsUQKe6nBCMyvony4QkaK3s8bspXs0i5J8e4zMI4aPb7P1fe9l64Pv/Xac5redNy14FosFL7744tnf169f54tf/CIbGxtcuXKFn/7pn+bnf/7neeqpp3jqqaf4+Z//eXq9Hj/xEz9xts5P/uRPcvHiRT71qU8B8Hf+zt/hT//pP80v/MIv8Jf/8l/mP/yH/8B/+S//hc9+9rPfwlN8a5ibirkuEELSVwkm8TgNaS9inKUsbMXEhlTX6wqeFLBQxuasakcAiYxJo4iqKV53v46QCi51g3EWhUS2YijDEOGZ+Sh8GwAMoISl34vYyUryJOdQZ4g1QW0aFk0VQqWJ4trjW6xt9MiymM3tULX/2KUtFscVdyZTTmah+HYwTDE6oaoct66fYK3lQl/jGsViWTEcD7n6xCaRkty97Xj55TknxxXTE0uaxygl0caiq9d2Fw0GGR/74avcePGUWzdOqAqLiGkHcEJZNyRITNUaCDb31xUSVBRhjUA3YZzFyhzQP/AiKBkKjZ2HNI4xjcZZx7KAOBdUpUQaEbrBdNivX4WAHWhjaYxhbTMnTWJkLGhKy8svzzg6nnJ4WOM9CATjjZzLV9e5dGWdK49t8PhTW+R5RJo9umHijo5HGe89sztHTO8c0FwckNtLNF+/8dq0VouZLbGNxtd1G/lpWfWIWI9dFpx89SbLvQlxnhAlMV5IJAJfN6gkwpY1zez/z96fxsqWnve92O993zXWqnHXns/ZZ+55IJukOMkaaFmSJV1d58ZyEgPBlWNAgSAkCMwIQgTIgIQrWP7gD4JhIRe+ECTLQiwHkOwrWXKi0BZliyYlUpybPfeZ9tlnzzWv8R3yYe0zdZ8m2WQP7Ob6AeTpXVWr6l1rVa361zP8nxSrDa3NPggoR1OqacqNT34BL444/tKLOBzJ2VW6awOO8xwzTRG3wuTWQaBQSUT30imKoynOeHitVu3l5RzVIsMZQ3Y0wVQV1XiGMxavU6DLbWbXX6Kapax84HG86J2dgv+WBc/nPvc5Pvaxj93++1YdzU//9E/z27/92/zCL/wCWZbxcz/3c7eNB//0T//0Hg+ea9euIe9qh/voRz/K7/3e7/FLv/RL/ON//I+5ePEi//bf/tvvCA8e4yyLqsCTkuWwz0rUZ5zNmZmMdhgTmZDpLMfcX+7Ub/ZXdP4pBG0vRDtHiKLgPkUngBKKbhBTFBpfKXCCwJasUGBwaAHpSYjJAwSK2Go6ZLQ7gsr3mQjFXJfo6s4K292Q9iuKZaPIYzhoY0owa4ZuN2Zjs0OeG/b2Z2xfHiOkxfd8Tp1ucfWq4fhgwef+4grSF3hKYsoZ6AIpPDa3emiTcXyYkqZ11ARXTyZvdwKefP8mUiiyRYlAsrwacenRFaJI8fwzh+xcm1AVBucEVt97bINQnBRHSyotabcUrSQgzzXj4zpmFgR1wbjWDmuh2wfrBJi628uXitgJxicO0M5xTwQKQAqwpeXF5w6xlaO/FHN0tGBylCE9QbsdMlhqkXQjvuejW7z/g2eIWwFBoJqoTkPDO5xs95jFZ75EeHwd0Xb4iQNPQvlaisfi5vmrbxcCZB2ppnI4m5OXJXbQQSiJM6BCn2i9j6cUVhsKJZHO4bdCtGexM4d1Fdn+iGqSUY5nREtdVj78CH4UoXwfnaZkN0cUx3Occ7ROL7P0ngvMnrtONcvQpcbvKbxOhJIKv9dGRSGtU0NUHOK3YqKNJabXnqGcLciPJ3z+f/ptzv6dj/Ho//knkd4717zwW175D/7gD9Y9/K+BEIJf/uVf5pd/+Zdf8zGf/OQnX3XbT/3UT/FTP/VT3+qy3jQ8IVmOulTWIbBYZ4jCAHQ9XLLlByhkXd/zdTgpvgfqwua5LgikR6g8hBHkr+jZEoAnJQ6HJyS+8oiFZAmfuMzInCUE0tvPCYEQBA4WCCZak0oNVhFMffLUkvcqukvxfdcXxT7nLg1ZWm6R5xVh5DNcThiPUl564QhdWHCOlc0lhC+ozJgXn9tnPM4xWtNKFI88ItHakaWwt5chfUGnJxDKsZiBEoIoCegPWlgDn/30NY7251hrSToBFy4ucXqrw42rUwS1AHF3V92dUBUOqytanYggqo+RtoakHVCWBt9XPPDYKtuXjzk6SPF8SRgFGF2SZfV5stpyuDvFGot1JzlvThocbp0DJSi1JT/MkAK0sUxGGVle4QWKjUHE+z94hg985Az9QasROQ0N7yJspSlGE9RoRCx9qkUGUQDliagJVJ37vnXNqP1fX01Y+/Dcvrj4ChzY0iADgTMWPSvJXe0cK2KPcNjDLjJMXqFlhZPgUk22N8LMczAWXWq65zcJ2i3K8RzhK8RTkF4/ZHZtj2itSzGakR3O0GmOKzXl8ZSwl5A8sErYSajGC0bjOYtr+zhrCJba+NEy5WyOZytkNefav/svnPr+9zJ4/PxbcNTfHN65Uu0tJvYCHuxt0PEjnhnd4EY6orD1cM5QKlDBiRVgjXjF/26VziYypOfFHC8yMgqsD8qTOONwJ0ND68fWs7AcPpkuCZXHg711ttMjplnGzTJDuoDKaaZ4dS7LghUVKtD0UNwgJkcQWckp12Fgu7SLCHefHx9300oCDvcX3LwxRVeG4+UEKQXLKwn6oWWODuYUhWN0WLBzfczxcUqeaayxlFXF5cuCbkcwmwmmU4fvg0XiKkMQSKyt27/3ixmj4znTaXX7AnF8NOdz//VrXF8NKQtbCx0BztSpJmvrcRFG1/9tLOS6QglBaASRqz2EVtc6rG12eezJDf5MP898VqL82kDxaL+eySUV6NJijQEEcSdExD6hsOSz8vbrd5KQOKmrraKWTxR5GByi8ugPE849vs6T7zvFYOm718G0oeHdSGUsU99nsjcju35I9WJFpBL6j54lu3aAzorawE9bLBYhJHaR3/uLKajD+9L3sHl1+zble9hKg6xHztiTLik9nuG0RcUB3QunyCpNMZ5TOQ1lBZnG6JPcvhQE3YT58zvIyCNa6dG5tEl5NMNrR5iyJN09Jts9plrkuEUd+a4OphzPUorjKcsffAhnHNMXdki393HGkO+NeeAf/DDTK1Omz13FWYczJenOIdFqn3h18BaehTeORvB8k4TK52x3mfykYjbVddGxtoaxrjAYyhPB4wEtFWNtXUTshCI/KT4JlM/ZZI35fJsSTVA5bLqgshYdCZR3SyDVz1W3vztmRU7HD/FRHBZT8ltN6SdOybj6R0ZkIBGOpKWoKoFBkPghDw02SaIYJeSr0ljWWOQrBlF6vmR0nLGYFhzsLRiuJkSRR5FrsoVmf/cQbSyLWQHO4nkCFQcUacnuDhyFgrgV0e15CCmYTRyVdlhXu5UaC1Y48tLd82sonVtefnHBzvUFTso68nJyv7V1VFhJgYocZX6i84ra6dh5kjI3WF27LK+udbj84iHj4wxc/cPr6CijPAlFWwMyhjgKUL7CrSUQK/S05KGzS7RaAdm8xNr6XCTdiA/9jXOEoeIrX77J2Dm2Hljm8XMD1obvfg+LhobvNq4cLXhud8rNy8f4XziANIOtIW5RR+Jb60vgIN0/xpUOZyrQdy5oqtciWOtihcVlmlJrKDT4Pk4IHGALjRf5WE+hfFUXH1sH2mGNocpzzGRRfzFoe+d66StUEuMPWoy+dhmdFQS9hGqyQKc5CInfaREZS3k0oyjn9+5crllc2Sde7tO+uIktS6pFjlQKPUs5+NzzTF++QTmaYY2kfabN1T/5DDv/6Qts/fcfYeV7Hn7HtbA3gud14IDDbEZuK5SQlLoiNeVtwz8AKvDwatEiHFZIjNWYk8dYDDMygpZHrANahwu8Fw4hAnFuiB74mJPIjsKiqNvStbAc5wuO8pTqPvFSicCzDuF8POmzb2tX4EhIznVXeXTjFPGpuuDs7inbuztTRkcLeoMWG6e6t9Mxq2tt1jbajALJzvUx43FGtxcyHmXMZyVJSxL5FXFU0O3W/WGBHzNVdWeV7ytWVtqsrCZEScjOtWO2r0+pKkMU+0jpWKQl8/GrW6sWaS1uvKCez+WcQeu6SNkBnu/h9XyKWY5bWKR19fBNT+EFCucs6bzkrz9zlYODBbNpgRC1wCnzeuirEobNZU1vIIiXVlk5NWAeS565PCJo+Vx4aIXv+eBZppOc/ZtT8twQhJKts7VZ4Mbpfn2WIp/4FaMgGhoa3h3sz3Ou7s8wswUiK1GFoTiY49J6xIsQEtWJMFkF2JM0lQc4hO+jghA8gdcNsV2PyPfqwaHSQ1hLflIgbAFbVGAsfrs2I7W6ZP7yDmaanszgUsheUkeQpCRa6hCt9gnaCdYaismC4nBMuntEsNQlWuoSDjusffhRjs9vsP3HnybfPrp3B7WhyDL88ZzFziFOa0QSIuOA3T//MsVkgdEGtTYk7iTMX7hBfjQjP55QHM85/SPvR4XvnELmRvC8Dpxz5FajhGRe5EwmdXhQdkCcGD9RgRorXABqpW5Zr92M67snVY6d7NceCZ4kCWICP0YZQxVGjBEU1NEgn4DN1oCNdp+sqhiXcwpT4iEx2NrUUMIw6kMsMJVDydopee5KAgfDsM2TwzO0/ehV+6Mrw+H+gsW8QBvH8kpCEJ4MrfQVDzy8xuUXD9nZnjAZZVRFRZRErKwFeDIj9DTOGPo9gfR8jLFIISjKEM8TFKXm6DjldDtg7XSPpBOSZZoo8vF8weXnj5iPZ69al1DgRyGDYUReWJxxFKWmKjTGWLyTz5dwoh7u6Ut6cQhY3EkYaG93RjYvKQpzO69YOI050aYba4rVJYvnW5wp0IVhc7nFoh+RpRrVi+gMItY2Omxsdrl5Y0LU8m87Inc67w5fioaGhtdmpR3S7SaURYU0FqzDTBeArKPBiaM8OoKsvmYL5eEPuqjAw508XghJtTvDLCqEBhEFqCgk7Ce0WgFmnlHN64HCQoh6fI2uMLMcKn07oiOSkM6FDSbPXQPt8AYJXtJCJSF+EpMfzshHc+zBlGCyQM8yXKXZm2U442htLKNin8X1w9r88ITyaMbBlUPMbFFnCtKCapZRHM4wVQVRCN0W3tYa/u4RVV5iFgXzq7tk+2PaW6tvw5n51mgEz+sgUB6XuqscZBOuTA6odutUhy8EqksdfkhhYQp85RE5gdD3FjJrHHN7UqgsfPRKTBK3CHzLPNBQ1Z1CEoiVz9nukEv9dW7Mjjmu5rejSy3n6B/O6JXQ3uqTrK2R2orKGI6LGbEN6UQtHulvsBQlWGeRr5idpTxJtxdhjKXTCV81tLLbizh9rs+n/uwyeVrgnE/c8mm3EzwPFpM5caTw2rUD4GRSsdSvKMuSoyPB8aFieTVhMkrxfI/BMGEj9rBW0OtHFIVm9+asFiEns/WElPi+ot+PiFsh/YGH50navZDJOOdob0ZROqx0eErgRT6bawmhJ9jbXVDkmjSdUJb2NXx5aioEXtKj2/EpXEwr8VnuRrC1xIvHc8YKDtKCs5FPuxvyQPed86FuaGh4Y9gaJNgLcPXJ8xy/cJV8fwyeRHke8kK7LiLUHkyAEoSpr7NeEhH0E6pRiilL7Nxg0gohwBUaV5ZIZ7GVQQQe0g/AZXU7+9zhSlOnvm4RKPwgYP7iDUjrgs3yeIYSCpMX6E6GE64eUuoMKgjQRcXs+gG2KBGegkrjt2LC9QHF9lEdRve9eop7oe80hZSaxfYBaA1KIJMucRyxNGzj91vEqz3i9SU659ffcYaEjeB5nZzvrTIpU56+ssNJ/upO25UCWg4XgQ01GdzuubrVnXUrGaWtpRRlPVCzF5AZQ15oSuMQChQSJwTTMmdS5mgcofSJlU8pJHahqYxh6gncdIxbHtD1Y/xQ0VKSWVVwqjNgpgtemu6xmQxYje+dxSSE4PTZPivrbcJA1fbkr8AZ6PVDFvMcoy26soyOU5LEYzSJyeeOorS024LJuGI4sChliUKYLRxbZxRnzxrS3OPmQYEdZ3hSMp1kBIHHcDXi6CDHOfADiR/6CCGoLCTtgM2tPqfP9qkUfOGzNyi36w6GlaU2g36EQjBYThgdp5SFxWgH1CaEDtCBAAle7rh772apZFZFvOfxCyxvLBH4kpW1Lp+/coQxFVPhSEuDsfXMr4aGhu8+Yl/x8FqXjf/b3+FL+THX/+JZ3HGKMOCFIVWRIZXASgGhRLVCnNV1EXJeEawF2MyRH9UObVJ5CKVQQYAtNcKvr3d4Ai8KcdYipMAph/FOMgRhgGpFYE6ubwpQPn4rQnoenudjs4qwk+CFAV4ckS8K8qzEHByjrCMYtDB5hcwrhIFg2K3rI6sKO8/uiB0JtLzauKwEjINpCruHjD7zDEEnIlzqsfzUA6x88GGC3jurdrERPK8TKSSrrR6n1/pcEYcYCfLuIdctwa04yd0BBh+Bh6DCYnFYDA4PJVVdl+IUHoq5LUBBhUW6OkWV6oJ+kKATSygUu/mYSQhlL8ZzDtuuWyQTPyJLR7h8XAujqkXgtcBBbl5hhX5rf6Qgjl+78CyKfTbP9rl+ZcTe7oyd7QmdXkjge3VhtVTMLFy9kuOmBlNaohZkWiADxcapgG5XcHA05cZhRj4uCYOIdtRCeuDHlqQH+RysEVhtCUKFs46lYcKFSz2+/PwOX9yesjisiBF0QknckkRxwmJmuH51TJ5VBIE6MQ2sj3DuS/KBjwpAzTRyZHAC/ACCxKPT73Du0jqnztzpONjc6DCRjry03JxlGAcPrnQIPPmax6ihoeHdTbG7zyGC7eVllJixsj+mev4Y4VN3XkmPaNihtb6MLipsXmBtRufsABm0KOcFi+uzuu4viQgGHTxfMd85oBwtwJdIJF47xlmHtRYhAvwkJjm3RufMKvuf+iqeMXjLS7TWl4nXBpiiRIUn4icMyG4ek+0dU45SqqJEKoUQFldoQJAfThBC0n74FGESM3lum6KoIKy7yPDBhRIVx2g9h0xj04z59Ypsf0LQaxEtdeg9dIrNH3rf231aXjeN4PkWWIm6PL66ReFKDopZ3SlkTwptFQy9FgjBSKe3jQglDoVBU3dOAQgLHRWihUNUmtKl3D37qTAVxtaP7gUtYuUDlrnOWZQFRQICjyBpEyqPSbGAdIxn5mSpwssSzp06RSsOGIbfmhJvd0KWl9soX1IVdcTDYfH9uj27PQwwGtJ9A6Xh+jYEXUlhFSL0ePGFOc8WJXsHFbkzSKDIDFXq6K1GnLnoCJXiuacFVRZQaI2zdcv4dJzzub+8zFee3mdsQPseGEGAIks182nFzo0JeVbWLf+diPVTfRaLitHRAistXtunNfSJkwrQaGtJuj7Lqx0efXSdpeV7W8lP92ICJbk2Sikqw9GiYNGLCbx3TmFeQ0PDG0t6Y8L+UUaaGYSVJPOMKC/qmsGTsH1uZ3UNzLzE4QhXIhCCcNAhWs1YXJtis5y8rC1HbBJTHs3qkRMFiEGCNQaTlbiiBAE28LFZwfFXX8ZWBoTA8wOqyRy7KPA7MaWekXseyeYyQknMIscu6nocmxtEu0Vyapl0f3oyRNSix4s6IpSEQBe/38bmBflsBhZcYW6799etwhpjHVle4KqKg88+R/5TE+K1d1Z7eiN4vgVCz+d71x9iJeryyetPc3l+VLdZ1558TEVOLEN8oVCuTrFoLNpqtBXg1REVjWO/mFFVBYoSe2vY1q3BXEKxn07pBC1GxTapLhkELbaSJULlMy1TBmGb71m9QGYqjvI5Y6uRc40qBUYr9AzObCx/W/u7capDGCqMq+dM+V5AHPvEsU+vF1FWmrJbUOq6Y2q6cGgJssj5689mCAtI6CyB8MELayNHoQtagSJJPJ58b8KzT2tCrahKQ5FV7O5OCSODzR2iMCjfYaQkKyw72YS45WO1paqHrGOMI2mHlIVGScEwitg6v8wDT6zS0YKXnjkEBKe3epw63eehJ9bv6Vgz1nFtlDLJK3qRR+5JWr5HO2w+Jg0N381EKwOGBRwvcrzJjCDL63TP3eQV+Y1jkBIReTjbQVQd2usXyVYFk+SQKisgryh2jylbUT04EECC301wuhY8GAtSYLVhdnUPpzUqCgiXunidWigV2Qxzw2CyupU83T0m7CZURVW7IS9SRGXRZBhjQLj6OpkVpDeP0IucYJBAXpLvHKGLop4F1o2QTmFu1V/cMoe7ZcpKXdhs9dcpkvwOpbmSf4t4UnGpt06uCw5fztgtaq9jX9TpKGx50hwkEEg0to7s3F0O4hxpVaIx+M5Q2ZNOL3tLEzlyV3F5to+1jlmVsRS0eM/KOTzlEXshq1GHS711jsoF7SDifHeVKq/Y2RlhK0U/ub+j8uvhcG9Olc/Z3ACQVMYjCOv8crWoGMaK9qke1TDhcG9KurvAO5ldVe8FYCCd1BGwIJL0133m04LRAXRCjwuXlsnygq9+cZfZJK8/mJXh3IPLLK0Kyp0ZlXagNaVUxC0P31cknYhSL+pwcOSj24qWahNFAYPlmKee3OKRx9fpdEM++KHz5HmF0Y5uP7pH7ABklWF/XpKWFcY6Lg7bnFlK8FWTzmpo+G4m2Vph69IG8qUdsjzH9BPseM6rjPVPrnmqFXH6Rz5INOgwf2nC0uOXyPenHH0+x0xScA6lJHJ5iTIvoZNAK8SNZzij6/Z2RG1GqCtA4g26nP7b30O2P2aUvYTJSkxeQKGxTpPdOCS7cQjOIYLa1dlZhxAOtMVrx6g4xOi6e0ynBf4gQfke1Yn5qpeEDJ68SHJ6ld1PfJ78aFIXL0uJ8BTeoEs87NDeWkVnBe80GsHzbRAojyeGZyi15Y9e/BpjvUDWMyhPanRAIGnJgFAoxndt2xZBPTRUa5yTGBFgrK49HCys+11MILDCEqqA3JVYZ5lVBXvZFItDCpjolJem+5zrrLAcderISV9wtreK1Y4k+far6B2OwDeIlkRbMJnj+ChFSsF8GtBue0ytZXKcY0pTHwD3qtFh6BKcDxEeRW4YHeWkM4OwFbraZXpkmBxnmJNoaq40Bzfn0FIo30OfdDkI6Qh8SacXEUeGpeUWfiAJz/RJ1hNEZVm2ggcuDjl1pk+nW7fkR7FP9PXqlXzJsBUwLyqmecX1SUY78tnsffuisaGh4Z2LF4cMHz+P5/s4X6HnKVf+6NPkV3fvHRAaeMjAIxx2OfjM03idGOEE68mjnP0f/gZeN+boCy9h5hleKyJc7iKMoMpKqqMJLq/D1coTOCFqJ2YD+BIVB5i8xFQVXitC5yWMJvd0V93C3XZpFQTLXZwTLLb3odLI2MfOc4wEPSvxYp9wpU+00qN9Zo1TP/QUIvKYv7yDrir05CTNhaBzeoWlJ88xfPICi2v7dM6u17U/7xDeOSv9DsVXPt+zfpFWEPDnO1/jZjo5GQlRR3cMltyW+NLH42SaOSeePrqsh1ViTwqcvXqGigWLwDiLQvBQd5XCaV6eHqKkoK1CUlMyN5pFVfLV423aQcRWe3h7Xcm32C5YlgalxD3Rj82tJdZODRkfjRFeSHq9rE38So21ELQ85rmmyEp0ftdMmftgKphOcoq8RJ90HRweWKbjEdMZGFOHwJyDPLXsFlO8yKMoNEoJwkCStCOGw4ThchshBSsrCU99cIsbWcnEGAadkEfXeiSvMxXlScmDqx26kcfLR4v6NtV0aDU0fLfjjMXvtek9dJrxM9co9ie01wZ4SjG/tg9lCYFHsrmCcI7ieEaWHiKlJFjrc/TVywyVZOvHPoQQktnXrlHMUnRW4EURejbDZtXtBIB1DukpqOoOLuFJyuM5e3/xVfxWSLnIyPfG8IqBykhqf49C1xdRKZG+opotwBpsZepUVFXXXBZujDo1JDm1zPL3PISepoyfu45e5HhxRNBpYbMSW2gkgmq2QEhFvjdm8PiFut39HUQjeN4AlJQ8PDjFtfkRudakpsAZR37iiVxgKeyd8J/RsDC14y/3qYVVvmBCitCCyA+YVDnvG57n0cEWL+7ucby3wIYgA8XcFCREZNW3H148Plywsz0hin3OnF8iCBRVZWphI2KuXhtRFgtabY/hckJVGXxPsLHRJc4Knj/K6g/Za8yU9cOTGVgGyqoeB5HlMB7V09Nnr/AgdHUGCz2v5aCzDhEpXMvHO9VmdWtA2/c4c67PqTN9Vo1jnJVEvnrdYucWSgo2ezGtwMMBg68TEWpoaPjuIFzpEa0vcfDZZ7j+//tcHaHpJfQfPE1+PEfPanFhpcALAvTucW08GHhYbTn+4guMvnKFwVMXcXlBWVUUkzlWG6JlhSh1PRV90EZFPiYtqMoTe3kZI6RDKIktK+RSB3s8xZXlnQV6dW2o14uwTmD3J/XtlSW9cVwXPFemrhkS4vY12hUlxfEMnGP0hRcRSlKOF6hW3d4erQwwaU5pUhwWqhnplRfoXlql++Cpd9yg5EbwvEEEyuP9q+fxpOIwnZKbkuvzY1L3inZw53AV2AlYDd4KqFDUQREfQjwMmpQK3wpEBTfSEZU1rPs99g4n7OYzJmlBGId0/JgzwyH96PV3YWVpSbqoSNoBUeyzvzfjxWcPGB2nnLu0xJlzS4yOFizmJVdfOuL4KAUHQehx/kKPKAnwPUW3H7I0KRjfmDIyjvSWCc5dkZ6k49HuRowO69EYUkIYK/LUMJl+47UKAVJJ4iRADlvE6x2SMz3ee3pApxMihCDwBKudVztKv16EEAxaTVdWQ0NDTTVeMH3hOtf/w2eYvLCNcILkLNhTy4TtEH0SQckPx7i0rH1shMILA4J2RDaeYU3O8RdfJB72sGmBFHX0RYUeXhJRTVKClR7J6oB05wgPSTZbIKUg8BVSSgSO1voSqh2jFwXVLEV2YvwwxBUlKgzJDkd3Fu7ATrM7hce3boSTVAPoeYbTDmcc0VKPar4g2x8RLvfqtbVChPIwOkcoR3k8Jd8/IOi884YlN4LnDWSjNWD5dJfnRjs8N7lJbjWHiwmLux15hMAWluoYKEB2BWEk8fFIXIAWlrHTOKDCESCY5Bn7uzOen+2jnUG3NaXz8CPBwO9xKllhOWpjrcNah/dNeMZobbn68jHTSU5/0KLbD/nKX9/gL//bFaaLjM/8xcusrLbpL7U4OlgwHtX25MpXLA1jLj6ywugoYz7JuHG9pMgqNk/1aHcjrs5SFqUhyAyJEISBh+97yEAwWG5RpJpWx2NpOWExLTk6SCnKEmddfZ2Qdb3PLZQHaxtdgpZP+1QHsdpi/VSXteUW/X70jvuV0dDQ8M4jP5iyuFGPZXACyvGC0RdeoJzmeEmMDKHMCpCurl2Qtjb3Kw0i8OuRFNOU5PQqrY0h+cGEoNti42+9j4O/eJq52cWkOdVkgd+J6Z5dJZ5klPsj7CzDao3JS2ZXdvEGbXoPbCI8j86lTQ4+/QxFWeEUdZrrlsutJ+ruESFe1VUmgvpHnRMOk+WY1EeuSvxeQjUvKA5HqCjC7yb0t1bJDkdURweUqUGqd5bD8i0awfMG40vFStxlpjOGYcKLBLyw2MVykuoRGs9X+JGr56koQSAVhdFMdFrna0+eSwI4S14VpFNDNqvwlCJse7TCgKHf5oGlZU51uljtuHb1mDyt2DjdY7DUes01WmO5fvmIL39+B8+XGGN45qu7XL0yYi5y7IrD5Y6jowVlZVhMS6rSEkUelx5e4Yn3bjI5ztnfnVGkFWVlUUqwudWjZyx7V44weYUXG5aFotNvkfuW8bTECcEg9lleTTh3cZnBsMXocM7VK2PyrGT/5pzyxHE6bClWVtt88INniVsBMw9cN0R5kgfXu2z24kbsNDQ0vKlYa9n/7DPs/PkX0Iv89u3lIofRvB4iGoUEm0uYhaznT40KJB46y1lc34NA1b/kBAhP0L6wiYpDug9vsfrhRzFpic4r9CLDlJqgnyCtI/QELvDItKEcz6jmGbYyhEWdAmudXiHqJIRLndst7rk86QYOPFQSI5wBT6EP76oZCCUy8DCVhqzOQpSTFJUELD1ylt1PfJ5sb4LwPFrrm5z+sQ8y3z5g9xN/TdhvM3j8QZxz77jrbyN43gSW4w6+VGS6RBvHzcWUKYuTlnQPFTsGmy2UFyJbghKNNRojHAaLhySWtZNxaitw4GnD0qQg6YTocEC32+HJU2usJRFKSmbznNFhhjGW48PF1xU8WaZ5+su7PP/sPs5adLXKZFIQRh5RX5ELC0rQi2IefGCVqy+NSOclp84O+P6/eZF2N+S5p/cx2hK1PDq+h5CC9c0uxsGVwzmx77F5KqTve/R6MWko2L4xIxsXrLRDNtYS3vehLZZXOygF82nB1ZeP+dLntplMCrbO9/mBv/UArVaAc46yNBQSbkwyOpHP6X6rGfnQ0NDwpjN5fptn/p9/yPHV63hn2pi9FKyoa2qyuknDzXPSywd4q2282McuTgaBZjnOACLAiwKEEOhJivY9wqUOysHkuW3yvTEmzXFAfjCmOJyQ7h7jKoNeZFRZjplnYB3leI6tNEE3Ppl1FREM2pTjGSoM8LsJVZbhRSHJ2hJOCrKje+sGvE4bYW3dJCIBA64qqUpNcTBBJTHBkiHeHLL5tz9A0GtTfO55vDgmGPYZvPfiO07sQCN43hSUkCxFbayrx0hMy5IvHV4hpf51IKXCG4QEwkM7i9UWcGhVhxwrLL5z+EJiqaORfT/loYEikJbDXOLakrzUVHFtBBHFPr1BRJ5V9AevLXYAglBRFpqqqM2odOVYWW3T6cVsZB2uHR7RUiEf++jDnD23xJUXj5hNc06d6bO+0SVdVCxmJYOlmOFKwnScU1WG9c0eg6WYKFBYIAwUi0VFtxPS3+xwdX+OKCoSKVlaSlhZ6+CfDCztDVo8/t6IIPSYjDLOXFi6Zz/CyKcDLLe//RqdhoaGhm+Gap5x8798kfTwCP9shB/E2LU23kig84rMONz8JOozr9DzESgBYYgK1e06Rul59B44TXY8JT8YU07m9B4+R7TaZ/LCdfb/8hnK6QyBxFmLEw459RFKIk46d+tcvwZboqt6AGm5OqecLpCBj7Mwv3kEgSReW6J9ZhVzWFDOU0xe4QAjwPM9wl4LFUV4WU55NMUsclCS+eWblAcThHW0z64Rb62y/cd/ha0qZBQQLncZPH6e1trS23VKvi0awfMmIoVkqz1k88KAQRjy6d0XKJ2m40cMozaxDJjrgsLq2mX5Lpxw+NKjj2BhS2ynRWUtp6PTVLKDyQJ6tsVK1AXA9xXnLw0x2hJ8gw4l31c89cEtirxCeYpLD60wXGmzutFBClgsStrt8PbzPPz4+j3bt7shFx9cRmtLtx8znxXkWUWvHxG3AqI4wFmHH0jms5Io9kjaIWc3e/dbzp3jpSQPPbaG1va2EGpoaGh4uyiOp1BZwn4H2bMEq2389QBzNWV6+SZeHFDl+b2DE02tUOLVZTJtMEWF9D1aZ9dQrYD5lX1U5BN0W4BAL3KK8QxXVvWvW0+BNgjPRymJ8BVSRQglqEwGuu62MmnJ4uoeThssjtnVPShKSALirQFOG/KjWW1GiMN1EnQQ4nUT4ourhK2IajZnlJW14Kks5fEcUVpkFKCigHz/iPmVm9hFSfeRM2x87L1s/vD7CQedt+mMfHs0guctQEnJRzcfZKuzTKoLlqMOBksvaHFlusdndl9kXmQoLApJKHyGUZt+lOBJwdXJEWYA89WEwfLjBPsW5QnODJeI75rxpJR8lXvwa3Hu4pCVtQ5SClrJvR1JYfSNW7G7/TtmfP1BDIM7fyftO8/3zTzX3QghGrHT0NDwHUHQb7P0xAWMNpT5nGRrCKVke/evIKsQUkEQgCnvsePwkhaDJy8QrvSYPXsdr9NCzzNA4iUBKmlhypL59T2mz9/AZSdRolaIQOBKixMQn10nTCJUO2ZxfY9pdRM3O5lu7kl0qSmOZzhnodIn080L0pf3Uec20XmGsxqsQHYjwlMbqMhHBAHVaMp8+xCX5vXz+RIVBchWhBd4FAdThAKkIFjtMXzfJdY++hj9B7be+hPxBtEInreIUPlc6q+96vZumLAS9diZTwDJIEo4216icpbznWWMsxjrWOiSrd4aw+Uem8s+AvC+DWEghKDdeWdW2jc0NDS8FQTdhNWPPMrwfZeopikqClhsH1DuT8l2jwiNoypKysMJ+c5hncISoALF7PkbeO2QYNhBRSHVNMUVFa5y2LIiu3mMLSoWO/WMPwTQaVNNcrACphnFwQhPLTN4z0WCXovF9hFa5uB7+O0Yv9fC77aweQlRPU4CwKYalxaE3Q7VaF5PS88WqCInbimqGwd1vdBohtMGfIkXh4TDLl4cIX0PEUjCpQ7R2hLDDzzI+vc+Tvvcxtt4Nr59GsHzNqKtoeNHdIIWlhBdaTIcZdvgCYVAEPshF7rreEJwqb9O229qWBoaGhreKqTvIX0Pv13XFHrtmGi5x9Z/92GygxHjZ65x5Q8/TXE4wVUV+D5+p0V+PCF0PcJBl2i5RzGake2N0XmObxNkIlBJjBeFGD/DCUGlIrQo8JzDGUu2N8KPQrL9ERhL0AoxqY/wJEGvzdJ7z4MQZDeP8adzqlltQGuLEtmKUIDXitF6gUtL3PUblEcRhbME7Ziw26aazZEyJFjpI4VAeKBaPjYrmV/eY+37n2T1Aw+z+sFH8Frv7O+fRvC8TWhr2J4fk5mKftCiTcxcFbSDgKUgQQqB5yn6QYtOOybxwnvSVw0NDQ0Nbz0q8GltLqNaEVf/8FNs/3//isXNI5wA1YrpPnYWFXiMd47RWUlyapl8OmdxfY9yvMAahy4rbFbSaq2y+pFHmb2wTTGesVABRbsNZYVXFlBq5jcOkElIa3WAP2iBFIjAJ17qID0frx2R741J1paZTFNcZZCtkPxwUk9e90Q9jLTQuGlGOc1AgpSS9tl1FqaqvYIqjfMU1bTCZhqkQLXqaE/73BrqWxxX9J1EI3jeJkqrWeiCg2zKC5NdrJfRlwGXBss8uXQGc1LGvBp1ibxmvEFDQ0PDdxLpzSNu/qfPc/z5l+up5bIe1imEYPLSDnpSW5GkgBoF5AfTuqjYglWQZQX+oIsXhax/33s4evoy9souvm9xiY/xLBQVtqiYvbhNvjtGrSckHz1LoALkAsrJnGI8Q/genQsDug+fYfL05XrW1uEEjMVvx7RODVlcPYD8xPnfguzEBL2E+VWLyQt0GOCHAZ6nMFmF9AXxao+NH3wv/YfOvK3H+o2iETxvE5HyWYoSbi5GzKoMLTS9IORcb8hq0kOJb674uKGhoaHhrUcoSTnPMUVZ185IMEowe2mH6pbvjYNqllLNMyiqumVdOEg8GEZoXbLYPsBkOVII/MAjWephTYfF7ojyYAwOXGHQfk7Y7xNtdWFhmT97A1dphBT47Ziw3+bsf/9RXvxdzf5fPI0tNFiHKw3tU6t4Sczs+W1sWkDoM3zsPH7k4yUxNqtQgYe1BmEdWENy5jTL73uQte997G09zm8kjeB5m5BCstEaYIxlJx0zKzIudVd4sL/ZiJ2GhoaG73CilT6DJ86zuLxLmeZgHVJJbF5xz/CqSt8uZkYo8B0kPuGwjadCdJFTjKEcLRAIgkELJySLG8eIOMAPQoKlBCkVYdyGVJO9dEx64wCMwR908DoJ2c4RO3/2JbL9Y5yzCKUIejHhsEP3wdOsri9x8F+/wvGXXwbr0KMF0YUNOpc2yZIIFfr47dZtz53+I2fpnF9/x7ag349G8LzNrCd9vn/zIQqt2UgG+LJpyW5oaGj4TkcqyeYPPoWe1emjbDIj359QzVPwJJgTb7VbFmvu5P8iDxX4mMOMSjjCzWXitSEYV8+1yiuygzEmy1FRSHx6iPQ8vCBk6exZJi9sM/vyDsVohlQKIwRBN0H2ErLDMf6gTXxqSMtBfGpI/5GztE+tgoTeo2eZvrRDOV4w3d7HX+3RWh8StFtgDDL0AInqtehc2mTrJz6MVO+e76RG8LzNeFJxpr2Ccw4lm8hOQ0NDwzsBpw1hr8Wpjz3F9OpNdj/1VWajG7iirAd23hrgeTfWwMxgFhqvFUIvoLW1it9tIdQqarygOBxTHM9BCJSS+ElCvnOIZs64HVIcjHHG1ELEOoSDaNglXB9gsgIlFf2HtvD7HcJBm3Cpw9FXXgLtaJ1aJhh2SEvNYlGQ/9evkPQSwn5C+/wm7fNrTC7fYPr8S6S7ewzfe4l4ZfB2HN43hUbwfAcghagdNhsaGhoa3hEEgw79x84xeXGboy++zOL6YS12qnpYJ1KCtRBI8CTCSZx1IED6Cq/XJloZID2J1Ra/28JkJd7WMvnhhPRGhklL0huHoMAPA4QBIRR+OwZf4LQmGHboP3aeeG3Atf/1U2R7I2QrRGIQniQc9An7bUxlyQ/HFIuctJtQZRo3myF3R6huTP/hMwyeOMf8+IDyuQXOg/HV66x/9PG3+1C/YTSCp6GhoaGh4XUihMBLIvKjGen2AWaRo9othLFYLLYsoRXg9zxap/tIGVPuZeSjGV4cEHRayNBj+tJNko16yKdZ5CAEyx94kJvTFF2WOGNobawQrfaQUpLtHyEShWgFkErCtQ6nf/QDTL52DVtp9DxDVAWKEmcFtizpP3aO2bV9jr/4EkZJvF6HQknIPASWqNfF68QUozmutMiWj58ktE+/2iz3nUwjeBoaGhoaGl4nOi+ZPHuN9NoB5XSO1ZpopYerNNUsxVmLvDWss+8hCPHCNqasMGVJtciRvgfGkB1MqMZzdFmiPB9nDMnmkOxgVHdg9dqowGNxZZ/8eI4MFeGZNjYtiS8sIboe0WqXzoUNnLXkRyOEkMjAw09C0ptHzF+6Ua/LOOKsxLcOZSqCQQch4fiLL1JNUvLDEUl3ieHjlxg+cuHtPsxvKI3gaWhoaGhoeJ0URxPy/QnReh+/m1BOUkxWEnRaOO3w4ggcCF0xf2mBkgYMYCxKeQTtEJzF6yfYvKKcLtB5idcKmV/Zw2vHtM9tIANFeTQh33csru9jioKwvUSr1UW3Df6gzbX/+GmyZw8RniLaHCKlBGHJj6csbsw4fvbz2DQFJ5Chj8gKRJpjpaRAML28Q3bzCCx4vZjeg2e48Hc/Rrzcf7sP8xtKI3gaGhoaGhpeJ347Jlzq0H/kLPuf/hrZzSOq8RynDe2zqwyevETYa9UmhOM51TSrJ6dHPqbSgMAUGlkZqjTDaI3fbRGv9Ei3j8iOJsggoLXax1YVxdGMcpbiygpz/QCblwTLHWaza4xGOTrNCboJgycvErZiqnlKfrQgH49wpa67xqTEugrmtya8G7QQOAFiWeJFiuRsl63/zftZeuLdFd2BRvA0NDQ0NDS8boJem5UPP8rSU5c4+OzzTJ7bxqRzzCzDlJr2uU36D28Rrw3w2zEm12SHI46/+DJWl8xe3sfkBbYoyOYZZAUCid9tUxY76FmGajl0UeCyEqckrqxAW9y8IFMzBJLqOKUYzRHOYQtNtnNY1xZN5uTHU1xeIX0FUYCz5qSL7K4dEQIlFDJUxFtdwqU2Xksh3oVdw43gaWhoaGho+Bbw4hAvDnn0//J3OP7Sixx+egwO9GjG/meepjye0X9oi8F7LrDy4UtIzyM5vcreX3yZxbUjjLVkR3PsIgcpMGHJ5MXteixFpet6oLTAKYHJctB3lIrQBoerJ6Fri5UOnRYcf+klTFGBseisAKWQYYjXbeGKnKI0IGw9Ib0TE3QTVBigghA9rig7OYf/7TLLT74HL3x3zW9sBE9DQ0NDQ8O3weDhs2z+2PcwefYa1XgGUlLNMrK9Y7rn19GzlOnz23QvbnLqb70fW2jygynTZ1KEo/bsMQ6rDTYta2EjBdZRz7VSAul7mMCDUteuzYBe5AgJAostDdY60Apn6/lY4JC+dyJsYopRiUpC/E5C+9QK3QdPEw/75KMpep5RHE4RBHhJ8q4yHLxFI3gaGhoaGhq+TTa/90lmz17n+CuXMWmBsxaVhCQX1vG7CSYrQCo6Z9foXlgnXu4hnzzP9OWbLG4cYo1FehKdFcjAxxoDRYnOcoh8krNrBN0EnRXotKgFUmnAWWTg47UihLY4KXDWQFmnpGTk0T6zRpkucJGHtJb47JAH/o9/m40feA8y8pm9tMPoyy+Dg/6T5xk+eQnpNYLndXHu3DmuXr36qtt/7ud+jt/4jd941e2f/OQn+djHPvaq25955hkefvjhN2WNDQ0NDQ0N3y5rH32MaLlLdjDm8K+f5/K/+y8U+1Ou/a+fZvDwGfqPnqFzdhUhJZ1Lpxg8dpbJSzt4/Q7OOfQko8pyTKFRgQIjIc3repvS0NoY0ru4RTmaMHv5JvnBBFtVWGvxO23i9T6La/uU4xRbnRgg4jCFx2LnEFtWOGWRSYDRhqv/7i/Y/8uv0b14is65NYbve5DVDz+C9N69cZA3dc8++9nPYoy5/fdXv/pVfviHf5i/9/f+3tfd7rnnnqPb7d7+e2Vl5U1bY0NDQ0NDw7eL9D0Gj51nAMQbQ174158gvb7H/Mouk+eukfz1Mp0HT3H2Jz5KsjFk/QfeQ3ow5vATn6c8mKK1RhgLpsKMTT2PSwCeQMQh7dMrrHzPg0xf2MZUmnC5x+L6PuV4gd8OaW+tsri6j60qKHS9KAcuK8kOx4StGGkcAshfOmCeXkf5Pp0HTnHxf/8xWqtLt+edvlt5UwXPK4XKP/2n/5SLFy/yAz/wA193u9XVVfr9/pu4soaGhoaGhjeHoN8GY7DGQmWojqbMnOXl3/1PDJ+4AE7Qf/w8yX97GhUGde1OoZHOQXkSJDAWf6VP96FTdM9tcu7vfh82K5G+YvDAFn63xfGzVzn+/IvoWcb4q5dRvo/fiakUkGswro70VIai0ETDPtIJ8sm8rhNydXt9cnaN3sNbtRHiu5i3bO/KsuR3f/d3+fjHP474BnOjnnrqKfI859FHH+WXfumX7pvmukVRFBRFcfvv6XT6hq25oaGhoaHh9ZKsLXH+f/c3eeZ/+UPK3WOwDlcZivGMK//+U9i0YOmpBxg+dYn8YIIIPBY3j8l2D+9EWaSgtTlk8/ufYPjeB3Dasvufv8hi55DW1grtixsM/Ytk20fMr+1SLnJsqU+GjnoY38JdGRYKTX54DJ4HSiGCgPalTR77v/4PnPnJj37D7+V3A2+Z4Pn3//7fMx6P+Qf/4B+85mM2Njb4l//yX/L+97+foij41//6X/NDP/RDfPKTn+T7v//777vNr/3ar/Erv/Irb9KqGxoaGhoaXj9P/N9/Cqs1L/+/PkFxNMNLQhww+vJl/HZEezRj/WPvZfjUA1z6H3+Er/3Gv+f53/yPt7f3OjFe6HP4uRcZf+UqwVKHbG9EcTSpxdHNY7oPncZpg1AeKvKoKospK2xeIgIfF0vIqjuLKi06lMhBj/j8Jg/9j3+LtY889l0hdgCEc+4tydr96I/+KEEQ8Ed/9Eeva7uf/MmfRAjBH/7hH973/vtFeLa2tphMJvfUATU0NDQ0NLyVzF7e4Zl/+R+4/iefJt0+BhzdB06z8YPv4dz/9vtYfv9D2LIi2xvx0u/9Z77wP/1ryGuB0nvyPN0Lm8yu7ZHvj/FaIQ6BqyqkVAT9BOsc5fEc4UHr1BCBYvL8dUxaEA67qDgiOxhRzTMoNTIOUKdX8P/2R1j70CM8+YEHGJxb+44xGZxOp/R6vTft+/stifBcvXqVT3ziE/zBH/zB6972wx/+ML/7u7/7mveHYUgYht/O8hoaGhoaGt5w/F7C8KkHOPz882Q7I0xeke4cYeYZ0foS0lMcf+lFZi/vUowXeEmErjS0AtrnNojWB0yv7uKspRzP61b3KMKFEl1UmKKims+JN2JaZ2Oi/ipep4W1Bk8qHILWag/ZijCFJmjHrP/w+1j68Y/Q31iiFby7a3ZeyVuyt7/1W7/F6uoqP/ETP/G6t/3CF77AxsbGm7CqhoaGhoaGN49qliGFYPWDD6PTgvxwQrzUo8pKrv3xZ0hWehD67P/l16jyisGTFxh/5WWMcYy++jLZzWPiYReBINsf4/kSISV+PwFtKLMC2fZpP7JCcqpL1B8yeORBupdOMb++x+5//gJy2Gblex+n//AZQLD0ngsEneTtPjRvC2+64LHW8lu/9Vv89E//NN4r+vt/8Rd/kRs3bvA7v/M7APz6r/86586d47HHHrtd5Pz7v//7/P7v//6bvcyGhoaGhoY3lGi5R3JmhdbpZR76mZ/k8K+fY/y1K+Q7h9z4k78kv3mM8xQ4R9jvEK0OCbp75IcT8sMxVZrTlev1PK4owEmBwOFMSVVovG4LL/JpLa+z9L4nGFx6COWHdC+dopycR0qJ04bBExdZ+Z6H3u7D8bbzpgueT3ziE1y7do1/+A//4avuu3nzJteuXbv9d1mW/PzP/zw3btwgjmMee+wx/viP/5gf//Eff7OX2dDQ0NDQ8Ibit2NWPvQoAEIIWut9ltZb7H/2WQ4/9xz50YTseI4XKOZLHfxK4+IAEShMobFWU+oKvzKEy11sWRG0JS4r0W0fp3oMnnyA5fdeYuX9j9E5t377taPlPhsfe4pqlpKcbrzs4C0sWn6reLOLnhoaGhoaGr4VbJaRfeVrlLMZL//HL3P1P3+VbKceK2EHbbyzm4jJHLN7iD6ZyRWsDVi+tEX7zCrxco9ydBNlF/QeXUV1zjN46nGS0ysEg847vtvqXVG03NDQ0NDQ8N2OiCL806eQozFP/j+eYPlvPs/T/+z/Tbo/xq12MTbFpHPsPIPSoEOJdZKx8ll76Azn/7sPcfNPP4NgQf+RcySXHiLeXCHbPSY/mtLaHOIn8du9m9+xNIKnoaGhoaHhLUAIQbC5Dpt16unM3/4Q+e6Yo8+/QOpmZEeHzA9LrAIQaM9HaEN+NKayDpMWROtrOGMINs6TbK1TjGYcf+ll9CKjmmcsP/XA27qP38k0gqehoaGhoeFtQEjJ5g89RWt9wP71y5SfmaJ6LfyRper2CPptpBC0fIWqSpKtVYSnsGV1uy5HSIH0JELJd/XgzzeC5ug0NDQ0NDS8TXTOrpNsLjNcPIx0glmyjXiPT/I33gPGMv2zv4ZCM7h0inDQIRx07tk+6LUZvu9BdFYQr/bfnp14h9AInoaGhoaGhrcR6Xu0+n0e/T/8BPPLu0SrfZJTKxSjGdsS9CInXh285vbRcu8tXO07l0bwNDQ0NDQ0fAcQ9juET92J4PjdFoNHz1Icz+he3HwbV/buoBE8DQ0NDQ0N34FIpVh68iLO2u+YeVfvZJoj2NDQ0NDQ8B1MI3beGJqj2NDQ0NDQ0PCupxE8DQ0NDQ0NDe96GsHT0NDQ0NDQ8K6nKVpuaHgHUhlLVmkq41BCsD/PQcDpXovYV+/4mToNDQ0NbzSN4GloeIdRaMOze1NePlqgjWGUlRzOcgrt6MU+T20N+J4zQ2LfQ8lG+DQ0NDRAI3gaGr4jcM5901GZUVby8tGCFw+n7IxTro8WzAqDsY5WoHj+YMZnrx1zabnDI2tdhknIcjtENlGfhoaG72IawdPQ8BZQGcsoLQk8ST8O7rnvcF5wbZTSiTwuDNuvGZVJS81fXjniq7tj5kXFzjjn2ijlOK2oXP2Y0mgKPWeaVTy7O+W5vQkfvbDCY6LPcjt8s3ezoaGh4TuWRvA0NLyJWOe4crTgC9vHOGCQhLzvVJ9B6474uDFJGWUli1Kz2onoRf49z5Frg0TwwsGcT760z+4kxTmBcQ6BQ7s7jxUOlJSklUEqwazQFNpirCMtNT5wY3tKUWhOb/VIGhHU0NDwXUIjeBoa3kTmueaz1454bn/Goqg4t5TQDTzefya4nWIatAIWpaETesSeumf7UVry4uEMIQQCiD2FsWCcpRd7VCZgUWrmlSMQkISSYcsn8hRL7ZBzwzab/Zj9Rc4LhxqTldy8PkFbR6YNp1bbeL6iP4ibQueGhoZ3NY3gaWh4ExECnIN24CMcDNsR1jm0cQReLTC2+i0EsDfLuTlNOTNIbouPeakZZyVVaenGHr4USAHawqI0BFKgJPgSpITIVxgHk1wzzjTGOJZaAYGSfOnGiOujBW6uiT3FpNBc3J/jfMmTD69yarXzdfakoaGh4Z1NI3gaGl4nR4uCRaFZSkLa4df/CLVDjw+eG7Izzii0YZJVxL7iOC0ptKEdeuxMMr5yY8TxyX1/84FVLIJZXrEoNAf7C0xasoNjNyuw1DVBpXZklcEiURicg7w0FNqyKA3GQlZp2pHPVi/m6ihjlGlyXTHw4eosZZyWDHsxYnfMzaLkVDsiCDwCJem8IrXW0NDQ8E6mETwNDa+DvDK8dDhnklesZiVPbvbvSQXl2uAJgadqT08hBBeGbU51Yz7xwh5HWUm1P+VoXmARLKqKm5OcZ/bHZIXBk5LjtMRXAnBMUo2aFax4iquTjJd1hcaBBScFWWmIfEUgBdoYKmvxhcAY0EBeaTwpaUcew5bPvCioBCAFpiWplGTuWT55eR/3UoUHbCz12Rq0+b5LqwxiAUiEUPc5Gg0NDQ3vHBrB09DwOhACMm24MU4xxnFpWVMYhycFeWW4fLwg9hUPrnaIPMWi0KSVIfIke9OUa8cpS7FPVlaUGjwJ2+MFpXZUFjzhuHI0Q0pJoCSzvCJfVNx0MK80Y61vFyl7srZKDz2Pvig4zir2q4BFVd/vgFLDMzdHXD2ecTQvSLVBIRilBXlpkbLEHlnyqqLrVwTSkRmLdoL3FjM6UYlAoRggRBPxaWhoeOfSCJ6Ghm8CbS3WQugp2r5H7HncGKf88Vd3iENFO/SRAirjOJwXxL5isxfzzP6UvWlGURme251yY5JzRYKzljjwCKVge5pjjKUT+TgpcEJiXEXkKyZpxbzSiCRkhkCXoOsAD0JAHCnanmGaFSy0wKKx3BEmJXBllCOot5Gi7uTyFFirMc5RaotwkOBY7WjakWK1HbKcAK6isBpnC5LAawqbGxoa3rE0gqeh4RuQVYbn96dU1nFh2GalE7IzTdmeVGxPU5SAfhyy1onwFczLiuf26jbw3UnGC/sTro4zdkYL9hcl2p4UMvtQWrCuLkLOjaMbKqxzzHJNaUApwNVr6MQBi8owLSwO0AZiIQBBYSTCWm7JEVlvhgPMXftiHbX4MRB5hsjzsNaCgOVuyKnlAWfW1vnAmWVi3yMtK/7q6oKsHPP4Bpwdtt/SY9/Q0NDwRtEInoaGb8CsqDhalFjnGMcl54YJR4uCF/bn5JWhFXgEnqAX+Qi/4Ga24PrejM9chbS0TPOCaa45XpTkd6mPRVWLDwcoURciT3KHs47U1LejIRDgnGWRVzgkAntbzAS+orAwrUIMGnfykbb32Q8FKAnGnqS7LPRjj0AJpFL4UcxB6VEepQTemChY4ks34M+enxP5KQjBSieiFTSXjYaGhncezZWroeEb0A19ltshpbEMWrV/jq8UW4MW86JiqRWy1W9xZimmQPPCoWVSpHztRkGuoSoNxtXppbuxQOQBrv63soLCOJy9I4QkdepqVhg8T6KEI1JQGPAFzKu6W6uC22LntehFiq1BzPYoZZpbBAIE9FoBBsFRWjDOK148mrM3y3jpaM7utGBnktEKFNujlC/fGHN+uc1aJ7r9vMY6hOC2r1BpDNePU66OFxjj2BrE9OKQbuSzKDSzoqIT+qy0w3sLvivNzjhjVmpO91sMkzumiLO8Yntcr+NUL75dFN7Q0NDwzdIInoaGb0DkKx5b7+Gcu/1Fu9GNmGQVzjl6ccDWoMXDaz1eOrZU1TGzeS1SKl13S90PB5iTSM60ACEdxt6JzoSqFj6eBN+TWOtQOJbigExXGAvFycR0uDd1dTcCaHuC5XbI951bolgL+YurYxbWZ2uQ8PBah71pwY1xyt48R1sQzvHs3ow0L6mcQwnF0aLk+jhl0ApuC555oXnhcIYEzg/bOOv4g69c5//z1RvsLUo8JVluhXz4/JCVJMIJx80TAfXk5hLnhi36UcDNacZ/em6Po7Tk0kqbm9OMXuSz3I4YJgHb4zmLfJdro5SdSY8HVnssxQlCRAjRXMYaGhq+Mc2VoqHhm6Ceb3UnGjFMQj5yPuBgnjDPNSudkMN5wRevLfjqjZxF4fCloOKuuQ84JBrwsdSCRgoodC1WxCvyUIWp01nagfPqwaChp5iVmspCpR1CgrW18aA1909lRRLiUGGM5fnrV3ioU/BAoriqI1aTkE4Y0FnxSSvNwbyg5UuEEFTGMDeWfhTQDn1GRcmXd0YsioprowW92Kcylmmh8aVkURp2pxl/9vwBu7OSwgHGok3G0zcnbPUrjHNcG6fEnsc003xtN6QTeuzNM565OWFeGa6PZnSCgFagkFLQiQIif8QHzxxwfljx8lHMZ67EPLkRsd49hSfXkLKOBlnnmOZV3Yr/DTySGhoavrtorggNDd8iAlgUhoNFwdf2prx4MOPz144Z5yXG1YJH4AiAKADfOdIKKioEPvKkEOeWJHL3eY3K1R9Sh0BbRygcWhuEAKUERVWnsxR1iqu4z5P4CkIlKY1mvkjJAksSxdi55Mu7E764MyJQiqIoybVjNfbZ6LZA5nhKcq4fU2G5fDgnLw27k+xEullWk4gHV9o8fqpPqS2H8xxP1LVCytTravkexjostVGiOKlCyrXhyztjJnmFrQoWpSbXcIAEkbLUqsWQpwq2+gumZcF637HemXMwX/DcfsD2pKAlci6unqHTitidZLx4OCdwJQ+3jun6GoIeeC2wGiYvg/Shc5aynGNUQqt/6r7dZ69ngn1DQ8N3Po3gaWi4C20sk7wi8hTJSYSgKDS7NyZYJ1jb7GAl7M5yepHH/jzn+YMZz+xMOMpKJkUFSHwFpbb4nsUCvpT4psDH4pDkVKT2/r42AvAEmJP2cxwsSk0lBUVlMc4ihMSTjvnJNob68R6vTqEpKev6mdJQ+D2ua0Mr6eMry8G8JCt13TlWvxShV5GWJZEneOL8kEfWOvzpM3vsTwsmuWbYgW4omWSQlYblxGcQB1Tacm2U0goV339xmZVOTF4Z9ucF00JTlIblJMRXktUk4tywxZ89v48zBulKMJas8tBYPAGFKTmf1CnFdljRjxwtD7we9FqO/WnB/mTKlYkkG/t84NEVZrOblLMFRqdUxSGIEbRPgxfDYheOvgrWkofr3LQDhE7pDtZYCjQEAxg+DGEf0l0wJbTWEEHTmdbQ8G6gETwNDXdxZbRge5TSjnweW+8R+4rJKOPa9Qk7eUlnOuOFScbOJKcfeWhnuXy0QAFCSlZPipvTsmJSaYqTGp1cWwSSBINB8vU+ereEhyfrdnULOAPOOrKTERJSWOR96nZ9CZ6F/ORvCXhKEHiS2FfszQ1XppZ2lFFqy7zQcFJ0XGrwlSCrNC8cZQyTgLQ0THLDotKUrk7BDWND6FkCJTmYVRSV4eXDOYGSTArNJCsYJj4//PAGg1bIH3zxGpePFwSewDrHShKy1ot476kBUghe2L5OOU25bCzzqgV4+J5gNTH86MNzljvlibdRvU+BBOdBN4aiNFTpgjLfI6umrMRTdEsQaU3PF2DDuupb+lDOoZgCGlNlxNVVPAxe+jR4HgQxzLdh+fH6DDiLU8E3FDzOnJSjC4VzFqkag8aGhu9EGsHT0HAXeWUxDgpt0caCr7ACnp+nPDOes3vzkN1ZTmXrtm7JncLiYeJxaaVDVjlGWXm7IPkWDp8539yXoXEQKAhlXeMjBAQe9eua+n73iiplH2gHiiiQHC0qUgOxB8NWSCsMcFqzyCqyqqIocwwh5UlH2GonwDiLdIJu7JMEEl8JtLUcLjJ6sc/ZXouD+YLSCHLjMAZ8X7I3L/nazTHaOqr0kEv+lKRq8xcvxVxa6XN+KQEJaWFQQOBL5kXF7jznBy6t8r1rGV98cUFqU+ZeiB/FLEeGYWeBExmBLDnVrz2EpjmEXn08hgmkqceR7xF3LdKrCGPLhTVBwBBhVnC2xOaHML+MrKaIk/hX4AoG1GKyHpqhoaxgeg38FnTP1SkwU+JMhTgRMc4aKKf1AQ97UKW4+Q3c/AbMbyBkgB0+jhg+hJD15bVJjTU0fGfQCJ6Ghrs4O2gRKklWVexOU9LS5z+8tMcn9kfsTArKV9TI3NIc2sJ4odn2MuLAQziHkrVA+VYQ1H45ndjHugrr6tSUqexJTQ9Udz1eAUuJT8tXWBxR4EGpUVIQKomHY1YZPJvTEgYfS2oFJQFK1lEghUc/DnjPZpdu6ON7iv1ZzqdeOmJeViy3Qs4Ph1ybpNwY5zhn6cX1JWR7lJEZw5loxlqYgTQ8v7PHM3t1tCz2QOczYrdgT0e4sMtSyyE5whdzgp7mzKkW3WqFD57tMSuuMi81RelACDqRY17AzXGEUo7TA4N1PhMdE7RijPQxhcSP+ghpqMbXUOkcoQtsto8oMpw2t8vOfQF3a0/roLAGPzvEO36pToMhoJjivANEe7N+YDnBTa+DkAgEzpWYbBu7/xnIJigRIHWOi1dwQQuyQ3AaoiEiGnxrb4aGhoY3hEbwNHzXUWpLZS3JXQZ6lbE8vz9ld1awPZrzX186IKsMw1bI9jhlb16+Ztu3Rx0pKCyMspwo6BD7HrPSIOz9i5FfC0EtXhy1iJpmFaWFjsrpuIqpCChcSOhBLOrHVAYCv+4kM84R+Yq01ISeRMo6plFZh+979KOAFiNK60GdzWKtE7HWjhnlFYGSnO63iQPFSwcznt+fsTPJ6kiIkGz2IrIKcJIkUJwfJnRDn51JxrwwTKKYU4HFqQRT+JTGcjQv6IcSv5hRSk0goBIRo8mE2XiG8mDQdzyy5Sh1xpNbC44WUy4fFejSEnmOQIESHrnpECKZZAWL0rEoPZZCWA3n+NpH5RGiGGFHVzAmxZkKWRa4qsC9lj8AcFD6zExAIB2bbgdv74uQLENrvbbFvhtX+1c7HMal6GIHWczqaBAVjC6D+wT4Qd161z6Fcw7CHkI0/kENDW8XjeBp+K4iqwzP7k3JK8P5YZv1bu0nsz/L+cRzu3z68iF70zplpRQcpwWFtq8pdkIgiQRp6dAW5jnsipR24COFQOGw3L9d/LWer9cSjFJHCWQWfAzLfk4oDLHQTAof5ySrnZjjrCA1lqoC50qWWnUNUT/yOc6q26MklpOI0hq06XM48xmVhgpBy1esJBH9VsBCG3wpGWUF22PNzjgn0xqLo+V59COPbuQziH1CJVntRPyf3r/BZ1/a5tpRTlZabtInbg15Ym3Ilm/ZmaZEnmS5FdDreVRVyXEe0GtHODPlOLX0Ek3iKTqRZCmaIkXJSluzyB3PzyXP7Fme2HC0QsnWoE87MEwLjbGGpZbgXFIxsHNUKSAXUBlUmWNdgcNiJQihcK9xFq2DYx2RGUVLGUpr8OY7oGeAB91zuGIKtqq1Tj4CV+CiZRh/FTm6AaZWUwIHZgxHf1U/eTCEcADSA1uBCu+7hoaGhjefRvA0fFeRlppJVpJpy3N7E3YmKVIKXtid8ZnLh9yY5FTuZAq5EESeqmt5TrjlgHyLAihyh+SOqBlnhlbo04sCUqmptKE096agbhHdNerBV5CEPr5yODR3nH8kSkAsLZWrq4acg71FSVbeWVtxEsHQxpAbyCtTp9oKjXGGeWGoLLSiiGmVU5SGvNS1W3Q75NxSQuwpnrk5ZW+eY63DU4LlVsTpQYsPnllitRux2o04XhSc7cfo6TZhfoN1CVddG+MUTrTYnTpuTDJK4zg9iHnvqRDlLbE3CVmVbYatLosF6PKQ5U7FqRUHqqIlF5g0RynBKAt5+cix3lMcZ5qzyyGd0CCoEMKRl3VRk9k7oCCl1Q3RvoctMxZjjawqko7GRC1M0IW0INEe0mTg7qS3hIAlv2DXtoilIZIOZw2imMDsCvgJLlkGncJiDyaXyUpNcbhNiwUyHYHVt+u57qGcQj6F7f+Gw+HWP4BYeqip6WloeBtoBE/Ddw3OObqRz0Yv5tm9KXuTjKujBbNcM8krJnn9Cz4A1rs+339pjctHc57dmxFWhkDV6aP8G7yOAY4XOavtiHbgszs16PsEFwIBsS/BOTxZWxJq65gZe1s8KcCXgptll4WnOSw8JILKgtXmnsiRA/LS4ClJZc3t4uZ5VvHiwYLSGApt2OxG9COBJ8EiKEw9FuL8MGFRGGb7U47SikBCvxXw0FqXB1c7PLW1xEY34voo5YXDGTcmM2BBJ1RsdhQXZUyuBZV1HGd155LvCTY6ActJydXxlMNZSpsZ7+sX+P1NjGzTCvZB7QEFZeFwRY6xHgEtWmFFqOA4E7QmBcPuMVLAdCK4dj3GL44Z9FMqVzBbJGReRHE0Yv8qRE6wuSnxY4/STyjb6/gKgvlLUM6guiNBV4OSVb/EiVvCdY6yLUQ1h3SvHjFfjqFYkGdTdJVRkCIxdCm+zrtBw+5f1v+qCHC4zhYiSL7Bu6ihoeGNphE8De9arHPszwqsczjn2JsVtCNFL/Lphh6fevmQl4/naG2Z5hWVrqdR+QG0fB+JYH9RMS0MFbXz8WvRC2BS3onyLCq4Mrojje5Xx1M6qApL2xeESmBO+s9N5fAECAXY2nwwt5KFCW63rENdEH338wYKpIQkkCRRSGtRcbTI8ZUALGlVj2mPAsF7l0MmuePKoaAVKGLfox34tHyfB1c7ZNqghOTiSpsfuLjMg6s9Bq0AqH1xIt8jiWK0XGe5v8pDDy1x+rji2b0Z1jragUccKC4M2zyyEfHs7mW+ul0yn+VsqRnjcMrFMx5e/yyZG2NRgMQ6A8bDCcXWEmhKFmVtZHiYlURRSSgFs0IxXYTYIiRb6oOz7FwfcjAu8LREap9umKOsQBmHM+AJHy8KcFWCsBrnBDgBaDC1maM9Ob7CGpzLEF4EJgVTQJXXkRwvxlWagBx1W+wI6rhgQB33u/VOcNyeomZSqAqwJc6Gt7u4Ghoa3hre1E/cL//yL/Mrv/Ir99y2trbG7u7ua27z53/+53z84x/n6aefZnNzk1/4hV/gZ3/2Z9/MZTa8SzlelDyzN2GSVZTG0I0Cnj8oaQceX7h+xDM3x0xzjXZ3uq0qoCjh5aMUKSyLwiFfmcd6BQGw2o7JJtk909DvESMnIyLsXdto6nSKc3UnkrW2NglsK9yJA3NWGsZ3Ka1bJa/qxJjw1mu0JHX6zYIVcH6QsNE2vHAkKbUh8hVnogAhJacHIeeWKw7nHrPU3J7J9eLBlNBTXFrpcL6fcHCYstqNuDjs0IvvtDSttEMiX4HrYZwjUJIk9Gi3S2LP48WDGXEgeXDVJ69yPn25YHdaMMsclRUMljxaMWg5orQFTpiTIyIxzkdEGa3QEvklj4VwcwIvj2vRs9Gvj2HoWZbaU1rDFTZWHXs3ply+OuI4lxSiw7CnGLQDWr0MX3oEQuEpUMdXsGicCGp3RzTkxT3H11HPEhMA0RL43ZMq8gVYS+BHGKHwyjm+cYAH7taZrb7+m6WYwJU/xQ0exK08gWxET0PDW8ab/ml77LHH+MQnPnH7b6XUaz728uXL/PiP/zg/8zM/w+/+7u/yqU99ip/7uZ9jZWWFv/t3/+6bvdSGdxHWOeZlxdXjBVdHKbEnOd13xL4irwwvHc05zvR9y1hv/Sa/MS1QShGpuhvqtQI8JZAby6l+zPY4u28kyJN1OgzqluiVlmJWOay2GANpWeEQRNLjwjBhNQnZmRYcznMWRXbbPVmcbH/LhfnW3+3Yw5i6+ywrJbvzgo1uxNlBi5vTnHYY8p5TfZ7a6nFjnLM7m7A7yQmkxIj6eL14uEAJGLZDnuy2UHspZpTzlcuHrK50eHC1g6/qOVvd6F4/oWlecbQoCH3BojK8cLjP1UnGhaGj5QWsdSp8KZB4LPf7xMMQHRpm+QG+Z4h9qCqHQiNkrR+sqf0AlQe+EHXhsYtBF0TAWjtkpWfxgpSgXdFb1iyOErTfxXVayAhUoPCCPl7vHIxehmKKEh426mLMGPL0ntobwV0XRRlB7xz0z9eVzTqFagHRCnF+CCo4MUMydVHy/BDs+Ou/MbPrUI1O2tUtdukhZOPk3NDwlvCmCx7P81hfX/+mHvs//8//M2fOnOHXf/3XAXjkkUf43Oc+xz/7Z/+sETwNr4srRwtePpwzSgsqbcFa9mc5kSdvdy59vbJRD5BSIXEIJWjhmN0u+TBwV5VNiGUzqFjt9+iEbfanOceL2pn4lrFddpcJoSdhXhmMgcXJ02QlBMIReJZxVtFvBXieZJzrutbmxCBQnvz3LU11y/TQGktlwAlBZSx5pWkFHhvdGN+TbHQiPnp+mV7s88zunK/tFhzNCoQQbHQj2oEHFAgpMcZxmJbklUU7h1daDhcFp8qYfhy86lg55+o5YtvH3BinpKVFKI3FEKiCM4MFndAxzRTzChLfw8gWN+cZ08ISepa1rsHDgdRYA5ePFNPKZ7On8aUgCSWxH5H4Es/5eMoQ+wGtVhvUgnbHcvZCxGB9hcL3iOYvcdYbERgDNoZiDMURuAp0iiimICpwdR3UfQuOrQYnQSbgFtBagTyCfL8eO+HHEK9A1K0FkfsyzBbcvzz9LvSiLn7e+RSku9iNDyHj5a+/TUNDw7fNmy54XnjhBTY3NwnDkA996EP8k3/yT7hw4cJ9H/vpT3+aH/mRH7nnth/90R/lN3/zN6mqCt9vLNsbvjHGOg4WBZO8ZHuUcjDPqbQjDBSRJ7m40mGzE7M9yckqi3Ovjt54AjCaSsC8vPd+n4qIulJDA+dbGQ+3LUuhpRWuIGhxOJ/elkSvfO7K1ALolUhRT0AfpSVJ4JOEtddNUdVePIZbQuyOoWHd3SWQ3q1IlENbxyQr2Z1k9GOfH394g5V2yPlhwvYkIwk8BFCY2lU6rQwbgeSBlTaBp+i1AnIpCNcSer6k149JIp+Wf//LhRCCUjtuTnPyyrLWjljvRax0JpwdCgbeFFzFgQmZZBFF5ZAipTApQli0syxKaIcWayEvBftzRWEc0lie2IDesociQ520s/VXPPpDS+RFKB7Ajxztvod0AqkzxI0M5hXaOkQxZTGaU+Vzur7AxyIokXdFyRwgXtWDl8H+X0E1Bb9dCxUc6AL0FGxe5ySnl+uH5xNePcnsfjjQGcx3a/Xa2oBG8DQ0vOm8qYLnQx/6EL/zO7/Dgw8+yN7eHr/6q7/KRz/6UZ5++mmGw+GrHr+7u8va2to9t62traG15vDwkI2NjVdtUxQFRXEnBz+dTt/4HWl4R2GdY5IWfPLFfb52c0ym6yjLMPFY67ZYikPsSe1JUdn7fkWVDorq/tUYEsFqkJLhk7qIUjgOspSZMcwDSaarW2Wq9+V+r6c4KTrGYYwmrwyXlhI6gc9Xbk4oJxna1HUsPpCeCB4PMM7R8RVnhgnXjlK0rfvq55XlS9tjvrY35eHlNsN2yDAJ2RrEPLraBgfTsqId+mx0Wlxa7tAKPQaxz7VxSh76nF1KGCYhSgokFqczUOGrDPQeXO2wO8vYn+dcGrb48Pkh2uaM59eR6RRTGRZTRyUCHCXICS2v7orzpCX2Dc4JlJKEMfQSmOeGpVbdPh7IW2eiLg6WUoE0WBZ43hBlW0x3n+f4YEKiFgxVRmklWRlSpY50OiFdGEwXVjv25Dxy+zkFJxXirzzj+QImNyA6STsFPfAiqCLQFWSXsSbFncglgfu6kcM7VHWxlTPcdyhaQ0PDG86bKnh+7Md+7PZ/P/HEE3zkIx/h4sWL/Kt/9a/4+Mc/ft9tXulP4U5cTl/Lt+LXfu3XXlUY3fDdzSQtuXqcsjtJSXX9FWaBRaUZxIqlls+N8RRt7L2FxKKO7JT26/9OLwiwvmItabG9cOwVMCtBKh/PT1/1Xr1VtfZ1mryQgO8pKm04Th2jfMruLOVMv0Un8glnGQJOoiyW0NarjnxJHPisdCL+3nu3OE4rPnft+LZZ4F9dPWJWVBzOMj58fpWH17s8uTnggZUu26OUWVHigLVOzHo3wjv58u1EPpWxtE7cqJ01uNn1uoYl7EN78579XEoCfvjhdbIypx3OcG6XF/b32ZuMWHMVl4ZwYaiZipxM53hKE3nQjR2VcYBECoFzgtATPLjhKHNNZCvwQhA+GDBOYQmog70nR9YFOAc7N0tmxzlzt0uQ7CKE49itEekjPFfSi0p8z1EXSBsEDoUArwN+B7J9Xm0RWUF5VJ89Qd0653chcpDu4UyGRWNVAHEbVeSIypz4KLnbM9cSZevi97vfFV4I0QC657/OO6OhoeGN4i1tEUiShCeeeIIXXnjhvvevr6+/qoNrf38fz/PuGxEC+MVf/MV7xNN0OmVra+uNW3TDOwJtLNNCc2M04998YZtndkaMc31PkqKo4As3prx4mN5O/dyNVLUJ4NcTJjWCqQkpMkeWVxQGSgJ0BSIv8V/xg72ujvkG66eOaPiqji45A3tzTVbNMCdTygNPEvmKQCoQDl8Jzg5ipJKc7sVMc8MDy21wglxr4kDxzN6EhTZYJ/C9OwuLfcUDq53XXI+vJL66a0ecrtMwtq6BuZUEupsk8Ig8Q2mOqeyIwJ/iZMWNXHG2Bb1I0VMzSl0fZ1+BJwWevH8jQ9zyuTPwSoPrc7Tw8FVBgiE4OdDOFQjPp7W8jC3GxNkU3yxAWobyCkFgETIFq1GBV4fJbASuABGDn9Q1OHgnZ+Lu94UBW0I5qaun5zm0HYjw5DhU9aOVxEUhzu+BTHAmJ1sccmUCWSUYhAWXovTuI1y/bvsM4HDZEQTd20NKGxoa3njeUsFTFAXPPPMM3/d933ff+z/ykY/wR3/0R/fc9qd/+qd84AMfeM36nTAMCcPGrv27Gecc//XlfZ7enfLM7oSXDueM7+oPvx1hcTArTD21W9QiwhN1GYYvapfjw0X1Tc2+GuUGcnM7LXKrCPrWTK1bt0m+sdiB+iu2cHV3kuLO125ROeJAoYRAOxBCcnElYZCEDJOI7zmzxM4k5a9vjPjTZ27ie3WLeKEtW72Y92wOGIxTHlrtsNTyOVoU9OMAJb+5xMttZADxEpQzRDR8VUrLOYtxU4yd4ZwGKai04nBh6EUehRQEqj4nwbd01VFoYamsj3aSyJQI30c4g81uUKmAlU1Jq8iw+xpjDL6wtERRDwr1bhUS23oMhBC1aPHi2l/HZNw/rufqOhubndyt6iiPDOvt6lswZYFc5AjfQ7gC6yoW2uPAROSVxsNCdPfz6tqTZ3YNbIZrrUHn9J0hpQ0NDW84b6rg+fmf/3l+8id/kjNnzrC/v8+v/uqvMp1O+emf/mmgjs7cuHGD3/md3wHgZ3/2Z/kX/+Jf8PGPf5yf+Zmf4dOf/jS/+Zu/yb/5N//mzVxmwzucZ/em/MGXt9mbFhijsa8Y9miofWqKE6M+TW3mp05GSCSh4tJygi8ls3JM+g2abOBO4sMCoYA4FOSFo3B34h6xd2fcwzdLaaHjQyuoU0pSSAatgLNLCUeLukj24kqPU4MY4WCSlVw9XvC1GyO2Jxm+Uqx3I5LARxvL911c4fsfWGUpCXhub0ZpLBeW25zut17XuoQQiNYatNbue791GcZNTtq0AyRt+i3NSttydik/ETnfQEreXaYDQEx9hjyoPHwCusEauY2IQwiFh8j2oUqpxIzrOznPf26KmcU8vByw1k+Jo7JWtrekqQjrF3IaMKDnJx46t5v84VUVWLf+PpG15RhEUE9Md7eErcDlc0RpwdcIT5FIS9sr8XXJ6SDDOChN3VXnSw16DBNdP185A6FwrdXGkLCh4U3iTf1kbW9v8/f//t/n8PCQlZUVPvzhD/OZz3yGs2fPAnDz5k2uXbt2+/Hnz5/nT/7kT/hH/+gf8Ru/8Rtsbm7yz//5P29a0htek3mh+erOhOO0ZJoVJJ4iVpIF9p7W7Vv/3krECGohZKgnid8a9hkoD2d1PZbhFa+lePVtgXRs9gTCORYKSiPwpWJxonS+Ud2OAm41P+UaBJZEwnJLYUVIWmr6seIHL60AAiHh7CDhmb0pR/Ocv74+4to4JSvr1JrF4hD1UFQB+/OC0PMIlCI3FmsdpXllncq3h3MW62ZYO8E5sDgsM5aSnMc2NIEyKBxVVSsaX3F3xfBtKn3n/NQR3QTwEdZD5TM8XbERO0RnDSEU1liKKsd3mioT7F2fsH9g0ZOScx2HcLBYaKrIJ/FvnT1Zt6bfisc5c3IW1IkL5K0GdcPNImKv9Fn1czajjNty2QJUdV2RP6jFk63TpwgDziGcpB3GPO4yVDzGs/BS1mGqJWfCOYPA4AkHZlYXQC/2wevg+ucR0dIben4aGhpq3lTB83u/93tf9/7f/u3fftVtP/ADP8DnP//5N2lFDe8GtLXsTDKyynCclqSVJkQQKInyJHmpEXcV7zjqNu5b4uOVcYastDy7P8E5R1HVc69u/davqL+b275A4FhU9yY+/BPBc+XIsCgdxnicWg6YBh4H8wL3ildT1AEHAXgKNlsCA0y0IlSOrizZilKWopIbpk9lIa0cf3n1iB97dJNHN3pcO14QeJJpXrE3zymsJfAkvZZP6Eme3Ojy2Eafwlh8KTHW0QlrQ8PKWDa68Rt8RgyVzblyVLAoCzb6Od0oozIe8yIkUqDi7LbgrErw/RPhc0JV1XU9tqiQ0q/rh+QCUDgUlgLrAjJ3RD7W4LqMDxWLmWC4HBOFFRtLDrdRkoczOtH/n70/i5UsPc9zweef1hDzHnOeqopDFYuiOEmW5KPhqI/U1jmG5WN0u4Fuo30jQLAgwCYM2YJ9I9/w1jBsyVZDLUNW23A3BENyS21Lhk2NtGWRFCmZZJGsIbNyzj3FvIZ/6It/xd47x2IVK7MqWeshNit3DCtWxI5Y643v/773rZEyYL0ikICwRPvqotmLcLjviCSKllABgYCmlB1eL/tMnacKko2kJJWeo3dRo9p0SqxEhWZprIyePSoBmZGrZVxFEzB1hjpI9l3GwM/Rq+df7kO9iPt34qPR3bmlpeVtp62dtjx17C0qXtmZs7QO6zybvZQXzoz4xp0pu4slDocUIJvoBcn9rajHccD+0pJqdVgOWpnRZc1F3gcKd3+Xx8JKXtuBygUKG00Nb00rUiOQPhye5BXxBK8EJFIQhKSrHZfyBa9MFfiEPE15tp+wZWompWdeF9ggGCTQSRRL66mtJzOKXCs+eGLEa/sL9hYlHz+zznddXOfV3QXDzHB62OF9Wz32mvW57X725vt2vmk006Xm6kGg9gGhLINMsShzxos+pRmTmxpjLLWNJoudENtgVn3RxoAvo8hUjqgQmlF0KTPI+9TpkqIeM5vMmU+mTPZHCOHYf/Ua6/2CzWHNJz+wxI5nCFezqBXObDEYplDtx2yPldiJmR7xLx0KVkImAC5VyAQ6ywVVoRmqGiPurYq5WCmq51GpSRWrRcFH0bOgKSnG5TAl4FI246Du0FOO5K4KV6wQMRcwv4UPdeyTSgeP5a/V0vJepRU8LU8dWkoSLZECttY65InmA1t9/t2fX8EcWMK0prJH8UaPbsmpAYPzMXRzpAyzomJRR+di+wCRc5wAXJvB6qOkgKK2LJ26K+vKEaMSBJAkASUFSoDCMjIeyPno+U3+tw+OODi4yX997Tan5gXO5Hzi0jrPbZ5gu5/RSzWdRNNPDYmSfNeFNXYXJVu9nE6iUEoxWdbMKwsITg8fXM0JIfD6wYLdRcXZYYet3ltv/A8UJLqgmzqWtWaYxFTwfjpimCu6aUli4nPPNKQ6CkrvjgQPQCqbGxwOgOVI1tF0CTpQU4AtsTZw55bF1ZY0FYzHlqqE0BFsdSx62MW7Lkn3fZTyIqW/iTar18HD+PVjlZ6jUuBhW7P3yMWc5xJPrSS5cjxUK7oqihpniBI5evkE5s1mfaOhM9ZMYM0suH/0fcUMXv73sPE8Ye1ZwvASIh22PT0tLW8T7Sep5aljLTe8cHKA84G1ToL3gT+/MYYgcEHivUCGgFZgpKKuH9ZJUyMJSGpCMPi6Zj2pKZWC+kFC57h00jwonELLJo1AeIwWVHU4nN467E9Rkk6qAcmUHs9sSDa3T/O/fvgCm72M5UafU1nN12/eolAamQ44WFRkRnFmmKOkOEwuB82ocyRWLqx1uaUL1jsmBnw+hEXtuHoQlwWDh41ugnyI19Ub4fyU3Cx5fjPgioJOmqHCgCwbcM40SzVNhaSu42ugiDlZd794xMqOAFRsIg4kBDRClIggSdM+vkqg6jIYJJzdrrg8t+yPJVl/gMy3CEVAGMmtm56DYkyPKc+d0SSDTajmwKscSdH4V4nOOc1u1PHvnAjI9KO6sFbdYBKEbgwJC8DiEQQtEEiktYhm5N1TERpzwgfaDdoDGL8KSe+oibl/5s38OVpaWh5CK3hanjqEEHdlOu0sSr56e8rOrGK+DJSlBOHoG4UQgslDSjwS2JCWGoPSkIiasqxZVinWqSbtU7Ay1ukS8ASWSI6CHu7ZtwC51qzlCbJpGvbBkyvJuIrj8B84NeLsoMNeUbEoLbabsT3ss9GNwiUzhnNrA3CWm3WPz+0tKGrHYG/OqJNw+gE9OCEE7sxK5pXj0nqXbvroj3aqJP1U40NgkOu3LHYABBk+KPJQI+o5wtV42cGJCrgVM6uaqsYj02HuSu6sgDGBipoBKmwRyBDBcrJbYjYd0tRsqF2GFxYsCkWaV0yqLlKcIvF3qPZuUixndPshjqKHAOkgrqX542+KcFRUavqYhXojA2QVfXTqWfO7jEtZKhCcIqhAkAoSA/MFhCUBd0z4ikbwROG1WnI1ANUi9gAdTpO1tLS8HbSCp+Wpp3KeV3YmfO3OhEXpmjklwaJ2zB55vjAMuob1vqGsFbaGnVmg8jJ+AzfqcPFBAF0jKa2lCBAad5+BkQgCizrE+o+MFZzTww5L6+ikhmFmuLje5dX9OQL4S8+fop8ZdmYV16dLBIJLG71D52KhUxic42S2Sddl7MkJX9+ZkWlFoh4sTOaV4xs7MxaVZV5ZXjw1fORrppXkgycGFLU7dFN+q0iRoVUfL2qEmBNEQAqBYw4sAR+zNcPdS1hvjCNW1SpgHqfaApBVnDmTo0yGLDOMm5Kmgb2dA+q6IKBZ4w7n1guGy4RukpGY7di3U45BJ/dNnmvi/u1OJKn2dNOY/PDwtifXePc0s35h1mgXgSCJQRMCRF0frq0eD6wNpCyDQNZLZMJh8bAGTBqgXsKwH60AWlpa3hZawdPy1BN84PLenFvT+rDZuGPimPejEMCBVWyqLs9tdNiZzrlTzdB1YJQK5qVjciykc2I1CoUixh9s9zP6mWF/VuCp8XVAC9jspiRastFLKWrPB7d7fPDkkB82Jzk5yOil0WPH+oDzAR/iFNVd+2a6pKZLCvzAcxmXNnr0M81mN7v3aQCgpCBRgkLIh4qie7nPTRnwocSHJVIkSPFwr54QAoGCWLkx8SSfdrD0QASEBktgWWq8V9ycOqQMnB4E0vsD1x9BSVxyckCKNB1klmGStZhUbrfAXkDUc+T4S4i6JGWCwNJJKsrSMZk5zHifvvBQ7EbX5ENWfTeAi1lmZSHx3jPowCPbZ3zsk7ofiRKGUE7hMFsr9gqtXu2yLGKGKGCq2CsmZFwSxc9gcgXyjZjQrh/8N29paXlztIKn5amnk2h2F/VdZoBaKZR1cTDnIXhiZeTGZAEiLkWdX+/hXEwb370n0rxovsEnAi6ud/nouTWMklzemfNn13exARKteGary0dODxl1crwPbPcyzq13yPRRT00UG9/88/vgiUdP7ORG8YHtAUvrGGVvSlEcEkLAhwkhLHEkUcSIBx8iZtWUvfktUgOjNAcslgN8WhOrHgW3x30OFutMq4obE0+qAomynEmO/1HuTiiv3dHI/hGrKSqNYIDqbCHUKFbE0qN974su1fUv4OevUhUSVcHuOEUK2D+oyPRtjC+5u2n46N9GQzcNTINCKc9DwuFXtwbVifvu6rgGplaTXwJUggidpn/JsD+FooZhWtHJlggRl8xkMzCmVZNuIeMCm5i+BtITVAJbH0a0oqel5VumFTwtTz0HRcUgUYff1RMJ59Y67M5L9uYVlTsaTYcjj51Ex5PNwaIiNYYPnergQuDKdMHesozbWnnmSChc3L6S8Tz27FYvpowPFeP5PncWjkFu+NCJhA+fhWGq6SXDhwbfvt30M0OfbzWLSRGEQLIy4Lsf70tuTS8zWe4gCWQbGqN1U/GpAQ0+YVYa5tUeSpasIqzuFjJHJn8A8wJuTA21k1xcr8iTu9WqwCClRsij/psQalyYI1DowTZmscHV6R3Kes4wFGgZqJ1A+BpriXliXsJDLCGTHDa0xQmY1QqJIzGg0fF56ZxC53gX0FqQuKpxkMygdxH8HMpFNCDUGQjDbLHklduORSXY7Ek+eGqJFI3UErGyI2Sz5CVWPT4eFnuwuEkIL3yTCewtLS2PohU8LU89qVZ87Nw6PgQWteXkIOeFEyOcd3zx+phpZalqz9I6Mq34gWe3WO8ZXttd8rWbE2bWsdFN2OgYFqVFqThD081gs5MwSCRKKu7MlkxLS2I0Z9Y6FJWnlypsrvnEiYTXJjUfOTvi4xcztHLUYY6nj+KbLOW8wwghUAyR5Ag0Qjx4vz0zUj1n2FkiCAhpcIeSsgAkyD6nhwnddE4nqdnqS5QIbPdXIiY93NpKfNgQhdakVMzKDnmyCikF6KFYR4oOUsR+pxA8tbuNZ4okRS1jgnmHOcEIhE/YXCspS0k3q1FkcZqKBwmeWGkKdVOfcgKrcmqhGWLRwoFKqIOlrCqmLid1gi0xjT06WoNJYolKVjFRPh3Ccg8me2jl0UKDdDG77R5d2jgCHe4JaDC9aIo4u4UXIDrbiKT3pv+uLS0tkVbwtDz1nBxk/OUPn+F7Lm2yNy+xwCBN+PDpAR+7PuHy/pzSxhPch0+N+MjZNYracWV/zq//2VVuTUs+cmbED7//BDenS/7w5R2+sTOjtBYlBHmi2eimfOj0iE6qSWUTH1E55pXj1PoawVd8X6q4dPIkBUsqv8TIvKmUPD0IoRA83Ik5hBidMOz0KasFUjiOckSXxAqPAg7opUOyNIqmfn78dJ5xvH13RaoDWVKx7nN6aULsLF7FQBiUyFFiAylMc88Kz5IQCsr5kmRWYOoJgxQ6QKgzSgX9ToVJQMlVpsWDxvbifggJ2kMmA7WuybAkFE2qROPdUy64vaPJNAw3HUILgvWY2XVEOY5rU+U+6DuQ9khlxcXtkqJWdDN/7NE1BgWUh6P6R6jo8TO/GZusszWCMq3gaWn5FmgFT8tTj5aSC+s9Lqz3uD5esL+sOdnPGGQJ33Vxg+e2+0gB653kcHmpm2o2exnffWGT0jme3ehzbq3LubUuF9d7/MevXOc/vXSLZQgMc8knzm1wepQxLx39zDAuapa1wwc4Pepxctg7dDLWIcOHPlLoJ7ac9bgJweO9w/rruLCHxJMlOYEZsapTcVQ1iR46ngMgIS4gNiP+h7/nze1qmsAJMgPbvYDoS5TsExuWV9ePKcMdZOggwhZCyOhxI7rs79fcfr1k4D0n0oxELtBKs6wDlVWUoUsvMSQmgWryyOdpFNQq7qUmRk2sijG1CzEmog4Yv2Qxg1mvoJNAsQik1QG5aASabARLPcdITSct6KQWDSzIKEkRSHrsP2QRchnTbqWA/umYVq/fXOBrS0vL3bSCp+XbitPDDqePTWQrKR7qIrzWMTy71aN2njPDo5NJx2i0VOSJpqg9p9dyvveZTbqpprKeRAluTgvGRc3Jfh6Xgo7pmvj7t9pL8+7B+xLPBB+W2LCD54CwCuI8XJI6vkTUASSefaJgWd3WND8JkhxJhkfi2QFuA6seH0tc8lLN4wdu3yhZTMecOTVmY2MNIaJwMnKDaiFZLBZUskN/Y43EvQLzm4h6FyETCALR2QQxg8ry4BjYI1Z/OXVPGInzTX+Nlqz3SzQVuY5OytYWpHWApKkiyTT29QQP0mG85shtp0LW7tDf6eGUsSE6P4EYPQPqrbtht7S0tIKn5T2MlpLza937LpdScHqY8eKpIalW/JUXT9PP4mlw5V58r7D6diSEgPMHOL9DCBUWR6AmNBWcKBpW1ZuVsc1K+a0qPkXzu+do0SYHEgQSLTRVUDQ2y831Gjg4vH1Zwu4NWE6myOVlBkNAxrF5LUesb6xRLGKS/MIvcbOUvhmh+gbtpwjhMJ0BlMXR9lU3GgVSNpetoiFCrKQICfWY48JIAmUApCQ3llz7OEYOpFqgEsVRN46G7ikwGRy8DHZxuJUEjzH+sHn+kQgD5QFhdj0aHeabCPl09IS1tLzbaAVPS8s95EbxkbPrfODEkGFu7honfy/hfUXpLuPYI1ZqeoBAsY6nJlAiUXhyonBYVXIelV42QDEELIgKHxSx92c1Q6c4WuqSQILWHpNZFpOSECpclUKS4MWAEGqyzohT5wZ8/ct3+NqVHT4wukXSm9Efjlg7uxlFg5RQTyDpxMfoNDET85vx8WQak89ND/I1OLjKvVUgYSCpAV8hjjkSKgOpMfH+dgY4gt1HzDVsfWfznFbPL8HgeHRC2/E/goX9r0C1C90z0YE5W/vm7tvS0nIXreBpaXkAwyw6JL+XsW4Xx1WgoLZQeY+RGalOEGSNc7AhChY4zJU6zIdf9e2sloYSFAIRM8mJvjqGeBgyHGXbrwIYoqmhMYHts4GTwwUZNWF+C8EpfDLGhzkuTJnNBsxmBfNZRdUhCgNXQOhH98DgIe3FSIl0APl6XC6CmHguANmNlZ1iAn5VDTrCNP8nLTgR8HH3qOky1lvk9gCBa16FgCjvwM4XY6o6xOeWrsXXpLxx17ZD07Ys7hVCbr66QZxZb4NEW1reMu2np6Wl5T5CCJTsEis3nhDABYOkC+QIKhwWjUFgmhP2atbouOvRagQ8Xu6oiP06HhH6CBJiz48nCqdVP9Dq33GbvVQgnCCpUqRViEpjE42gJFDS7UtOrAc22WWrn9AZjSDJIBnEKsn4NSj24ph3/2wM55xebXpsTPxxJVTTGOMezXV4UK+P0ceWovQaczNi6QcYt4Cgmv4mgBAfMxmC7EXBgo8CC8Nhc7fK8FIg6vIu96MYtl4hsi3Y+gjkm7EC1dLS8pZoBU9LS8t9VPY1YFWF0Gid0/UbaNVHUuKYAgWWVbzC8WU/RVySOr60JaK4CHOQJU0NhMCSQ+8eVstb92LRiQIfJ9+0XEPkZ0EUBAqUGJF11nj2wpLQsUiZwPr74jb3X4qVnOUOLHdBGsrbitJn5GmF0cmRNqvn4FdLc3GirERDXcbCiri35yYePhM/Y6QyfP8iLCqknSOOCyVXxoqTL6GccCgAZQL5FqHTJ8yvx7H3EOfDPIu4BamQKqD75+KEWTUhJINvm+m/lpYnSSt4Wlpa7sI5iw1Nbws5MCQRfbxaEJg0md8x4wpqbFWjRQnmeDPzPemc3sHyIP43S2IzLw6YExXH6r4PQTnI+8j8GYTcQpkhkiWLec1iaegPFLq7iShOgfdxQmr/q7C4dbRdmWB94MrVGeNKsTEQnD81QIQ7zA/GaDFDm3hzQcDVJUUZA8+lpVm+Oi56NNgC4wSDRDBOBhQ2LvYpkmjbvLJSBgjNkp8ycWzdA8IjrEX4sCrpEEzWGDlWIDU+zPGTlxF1ATJBDHVsYG5paXlTtIKnpaXlLqSUCNdDsCQgkXTwlHjGrJa4IhnFzOFcSch91Dsyjl0vS6h9jPnIUqInTahoUkUbq2FD/GVVCXqDqoUMWGYEEcCleJdx5ZUpk/EB/UHGB55fR+Yb8bGoccaDmyJnE0TWA9Ol9oqiqsEuWC4UO7sFxXjOYu5Y7ylGPYc0q3iHqEvuZ6WKEhABfIUtD0jLL8aoCyExQkG+HZfKhIDqAKQmSEl5a06oLcmGRMkJspgi7BIICKEIbg5aEYQCKRGzm6Behc72ve6ELS0tb4JW8LS0tFBZz7Ss6SSa3Cgy/UEqO6DiVTx3OGo+Xk1QxWmqqkqReh4zM5uo+srC6weSnZmknxpePB2zNZGuybFSENLmwoQoeuSx7T/IIycDNI4xLkzwboatN6gqzdUrB2gl6SZLzq/PQAScrPFaIlSAUMBsgkUSSDg1COAFKslQvsSkJVWhmBeGfscdemM7JMGDF8cCRoFDOaQE2JUAtLhaU5QKqQ3ZWi82RqdreLukdKDFErGYU49rbFWyWwvqdcOptCBbKSupwDlkXeEICClR1QGYWzB8BtE7hWirOy0tb4lW8LS0vMcJIfDyzoyb0yWjPOFDJ4coafHMiUtOFVHgrLxqElbCZNCfURM9ZVZHkxAEyyrl9rSHxMcgTVHHZSbrIDioF82I+ErsZMTls31iH8/xRHMFbAGz+FMU+OIW2uygzSUW8yXGGPYnNac2c4wKyKxP0ALMNQi3AdvMjlUMm+QMT4XzBoyi29UsfJeQBmBCuazYnyYoBev9AmOOmxBaagT1zKO1J9FRADmvAEHpO9j0JDpbB2A8O6CazTESumkH0VvAfIlKmphQF0D6+Lq66FEtQ7RkFM7HaAmA7hYiHbw9f/SWlvcgreBpaXmPE4DCOrwPlNZR+gnKX8ZymyNvndXo+EqkzIAlmPvN81ITOD+sGMkpG2sacRi34IEiVnk8UNdgjpsX1hyWiQgcjbPr5ropBAvVHGEDwWvyfJ8TZwRVvWS41UOOhvhgECpHJWtwsodYFoTxq0BNXYMWoDSkKqNKB+hqQp5YSDxGJVBI7iw1O9OUPJf0sposORoXD4CvArMlaBPo9wJKpMg0wQSLVhblq5h27gtEcUDm9jGuQqQd0rMGXaToUCOExyiFlRrlbRQ40IzuC5A5mEGc0kp6OD9BCIMUD887a3lvUNVLDsqbJCpnmJ1oG9m/CVrB09LyHkcQuLSh6KWaVEPgFSw3iNNTq2WnlQhJiWKnfPgGnWPDz9hMHcEpPL14V93EhPvV8tiqd2flyjyDu6a+dPPfNQ6bmwWgDbgUadZZ29Zc8BUmSTh5OsFyAAREkGh5Ejm4CNsfx06v431NAMogGGKgs0miDLCAqgQ3A69BJ6z1HKUFoVN0d50pMzSLWOMKUDvFZJkhC0+/VyPNgK4tcJlF4RGTy1DcAjOkY8cIJoAnlBVBa5Sskd5F8WSymLbuFWqxaDqZ0miWqNO4NGYGeCaEsCAEjRIlQqTRD6k90X3b4MqKYmeM7mToTopMDEIInKupfY2QAiMSptU+L+39ESULUtHl/Wt/gVG29U7v/rueVvC0tLzHqeyM1Iw5O/Is3C61vYFSS6TwHJkA0vx7NVb9YJyPK1ZpaDK0goAqNB40IvrfWBcNAO9ynDluuKeBLQSbjS9NbFY+JB8g0vej9IAuc84/s0CgUDIlIPFMWTk+CwEh60PaJyznaAJ+ZXDolk1nchZH5YWBtA8qI+9ILnZuINweZZDsMkTVgg09RwvQeZeBXCOVC0wnAzNAzl5HShXT0llAVQGSJFSAp3JQOUvSPNeVp3SwFqQkhHCsbTvEsXWh4pSXnRPCMPodhRJLhSRBiXUE2Vv4q7e8W7C+YmlnKKGZfe06s1du4vaWpBsDepdOo58bcKd8jWU1wYic0i058DfwzReGIjhKOyUu+7Y8ilbwtLS8hxkXNS/d2kew5OKGxZgDnAApVmGXqyblN6ZubmZRuKRLJiwhSZpxbIiNvusgCgjT2PR7eNo/Lq6iwEpESqDChoNmX2KPDGKLLH0OEFh/HSGWCAxSbCCFwIUe4JCihxCS0DmJGT4D1RzHjLRpMqZqhJFM4radg2wbTnwY5rcQ0ysQKgSKlABGIxq/oCw1ZMkUr3JK2ccUd5BuVfVa9TsRvYd8XKYqfdOZ1LxOsrmJtxa8R/jjfUs2Giama5BtQu80Wq4R6OD9As+SIyHa8jSytHMKO8X5GofFBcuBvUapD/B7c3oE5p05y43AhDusvmjkHH1qIIa9ZIzwPiBlW+17FK3gaWl5j+JDyZ3pq9yZHSCEYbvfZTMZIpUmLmPVwC3ubiA+HhXxkO06cDIhzbPm9gJqCTpBkCNk1rQ5r/p3quaxVlUeAVhciOaFgSZegT6gMYwILFGyjwy92NcjNFIKpMiQ91Q8RLZGuPgjmO4pzO0vQHEQy1BSNJUmG00BQ4BqDHYOQYLuQ2XRCAYskEwbGeOh3CM0nsqem1g8sbW4ETsyidtzVfN6aXJtWdomRlXcHcSB94fTYYevgclg6zsQpz+JSPrNpR2ETJvnKBG0CepPI0s75er0yyzdlER0GKZbuFDhTyiCMQTdZXd5BzuUeO85/uZw3P0JlBi+euN/0GWb5849Q/Yej8R5FK3gaWl5j+L8hG56wKhTIIVgkHUxoo/GIcSQwu2CGAML4um5Rzzyzrn/sBtZRT4pBRwKD9cUPKKrj5FnsH6M5SpHBoWS+N11NZoukKQENAHdXN5D00PKHM8cGToo2QcvESJAMA+08hFCILIhYfs7COkAyv0oepY341h5sR9FEz4GjO68BPUMhAedI0NN5mb3bDUcyjPdfPOuEZjGjDHGU9jmJdIgNBpL/55z0XGPanH8UplD/xwMLxyKnaPnoxC0ERNPM8t6xtwesKynLMUCLQ2zasKcXcI62LUaKgjGH/pWrqi4+23uakddz6i85fXbFZudDUYbp9rergfQCp6Wlvcgy9pBMIzyHi+eFCi5TqpGBA4IoeTm9AZ3pktODjWDfFVFWPXaPDjp25i4giMkGAWxsfm4KFI4FMmh904BTY0kCh4DbDT3k9TsIZqlLkkXxRZKjhCybDK4mjOBcHgKBB4R1h56oBfpALZeBFsQCHDwKoxfjo1Hq+WtegHjV2MDMwBZbB5+gLhbLfodIalISSjvuUbEas9DuH9vA6gc0mEcJ2v5tiGEQOkXeG+x1lNTIkLNteXXjklo4psifbgV5/F3kzaGYDTeT7m1d4OD64ZL44+z+ewzj/GZPJ20n6aWlvcYt6YFr+7OSLXkA1uX6JoaHypcuE2gpA5TFvMFd3YEslZkJywIhxAlWjX9xw9ByONj6sebm1eBordwvs8qq+pI8GgEPRQDLDeBcdPNE4WNJEGrHlquscqiEkIQgiNQQbAEUTXbergdsRASTCcuzG2+QOhuHy1l1ctmCcpydEpZgn/wEoHgyCs6AHXtqJkjTDj0T/QGjMxiCKjnvm/rR6QcTb6p6FHUPQWqXbL6dsEFy7KasldeZ1zeZBZ2edQAwAM53k5nADTr6SmSvMetg5cobY23NYvJLtAKnntpBU9Ly3uMg0XFvHIsa8e0rOlnu3hqJBZLCUxYjkvKW4JZAcWaJU0dIgh8kKiHKh7d/BTHLmtiGLDEg7vFU6LlAOENgTmWBeAJZFj2gAPikT12uSjW0XIdKQZRsBxraBBCIUMPzxIRkkcpivsQQoLOCf2zMdSzHMNyD+zknls+umlbYSipm0W5AK6ZVmvuWoU5zD0CTzIUCClwtccHBx6UMsg8hZBBqKPbcu8E6BzRmBe2PH2EEAgEBIKD8jb7xTXmbsy82qMMq+rmI7hX3Kz6+nEYFAkpveQM651TCC84yHNqv8RIQ3fjxON6Wk81reBpaXmPsd3PmJYVqbqDMdexjd+OxwBToCJRjrWOwSjZuP9G3rgtQBKrFSvDwg7xMLOqnHQRZIRQ4nEECiQBjwX2iC7Lxys1PYw4h5YjhHjw+LWSPfAuJowHj2L0zfcv6BxMB7rbkG9BcgP2XwFfcOQJtPqJo+73ctiH04zOGBUHsw7bu12cPgtC4L1CSXBVhQiiWSQMKBtQm8/Hyo7W0DkBSf9olKvlqcAHjwsWgWBa7zKv9lhUM/bKa9TEpdRYufT33FPCfZc11U8P1CZ+jCTxssKTzRUnT55jlJ2ndAv61QZISU+v0x1uPPbn+jTSCp6WlvcYg8zywRM3cFxDiFWMw6oyE5uIt05KstyS5ZJeHzwaKQLyUEisDh3Hm5dX0109Vq7JsY03Q9BFAUpsghTYcBVCQTh0Vy6BkroOQIJpHJgVQ6TMcIwRoUAxbKo8R4Tg8RQQaoKAECwBh0AhxKMFg5CakG+DLWJ1qLMWr5jdiEtd3sXxcJNGcbTYgzC/bzsGA7I+LD5JI/F4fA1OgBYC3QGpNeCRUsZv/xKQHs8UaWeIzfdB7ywEh8jehHBreccJIbBbXOeguI61JbN6TMEMd/geX6Hu+l2gSehSsWg+D/fcLppRHbOtkigbEBOFXw8IIUhkRj/dRquEVHXR9/mft0AreFpa3nP4MCaIMeLQ4XjFarnIk3cEeefIP0c2/42sIiZqjqoxR9uQpEg2sdxpLukgiHPYQVgUnThWLQKEHMcCcJR1zbyQuJAzwpGZFEVGoIRQEYTnaFLsCCEkMnTwIiDI8GFBYAZoNOtvLHrSAcFtx19Wvjc3/jgucwkZl5ncMj5u/zQsboOdcSgUo5IBu4xj7jrHJCOWtWNMYGkE29mEXLn4GroFOtdxWevwdW9eXZUg8nWESt7gr9jybiAEjw01IghcsIzLGxxUt1i6Gf5wAvFe7v7MJSRIGVD+niZ4Q6zswNGZ2gBeUcuEbO0ivY1oNiiEpKv7KCExMosGmC330Qqelpb3GMHrw8L6kchZLcykxErPo7x2VtNa4tj9VpNMrnE6LoAlAY1jn0CJCA4VCrR+ASMu4L2lDJeJY+9TQgAhDM5pYIgkQ8oegpwgaCazHnwgj548HUDi2G/GxSxhFWz6CIRKEP2zRxckz+FDgPl10F2YXobZtfj0TA9yCcvrcaRdJtA/H/Mmxtc5dEhOe2jjycsSVQeM6sQxdwS4OMWlTBQ6HoXqXIJzP4gYnm3FzrucEGJVpfYVu8srzKsJ0/oOUmgMWXzv3bc8tWL1eYvSRqAYJCdwoSL4GnvvkukDtLqWHUbbW6TJkFKUpPQQQtA1a6SqixIGKVrB8yBawfOYqfcPuP0nf0Lxn/8Ak+eM/tcfpfP8+6GsUL0uwrSlx5YnRwgBF8YcjYxrjvpT4P5R8uNkHHVONtWKVcjloeiJVSN/bGg7bm3ZOOwscG6KVJogLIHi8DEz45Ei0EtnJCZHiAQhDEoOWFV2HrXEI5qDvKKHQyDQjUh684jRJehuE4SCpBuXt+pJrOYkPfBzsDfBL2MlaHQekgksl9HTxxaYasLIFQSdIVQWq0Wq8QoqxoBH5duocz8Imy8gk+5b2teWJ0ftS+bVPpNyl0l1h8LPqdyCqmnUN2QkMseQUzK9594PaqgPrKenqX1J5eYIXzZfRgT3iyaFISMTPWpfMK13yXSXaOUAUigS1YbKPopW8DwmrHe4/dvc/C+/w/SXfx3K2Bq6/K9/Qvaxj9D50PN0nn8fnY98uF2nb3lieF83KeirJZkMGDTX7vHwb6ZwVBFajYys+neSZjsrobQa1E4RDAgsmstjKlYVriCsbASQIy6PORAFiYnbFVRIIUHExk3xJr6xCpGgxbdWJRFSQzqMkm79AwSVw/RVQEM6iuPr85txv5e7kG9ANgBfxVFy72PvT/AIL5oimopLX51t6JyGbAjr70dsvNAeA97FhBCofYkPntoV7BRX2S2uUvmieQ8fVXRqFgT/oKbk+KVCIgi4w09KQkYgMLE7VL5+wP3u2hOM0AThcCHgvMWIVuC8GVrB8xiY1wXX53tUl/+c8N/+GFPGQmUAxpVj+qWvsLG/j1CC7LnnUL3O4X1DCBACQn7z47UtLd8slbvBsr6NpGoMAhMSuUXwipqdN7h3ydGY+ap3JzT/lscul0QR1EXicXjiUplBoIE5AUFAIw+rQattCSBHMkSIPPb/vMPleSEk9E40QRLEaa79yxwKvDCD3a+CTkBlsQHa+2hiiAUXonATGegRrH8AuqeiEWLSb8XOu4wQPIVbEIIn011qX3BneZXSzRFB4uw+ysdwXO8b08xjh2t7KPDv2ipxActgjy0n980GtxevMnO72Lt6fh5cZbXBoUKgo0f0zRodM3y7nvZ7glbwPAZmdcl0PuPgs59n88+vHl5ugVoorFD05kv6MUTn8HpX1ez/2SvUsyWj5y+Qb6898X1v+fZmUuxSuIpMxRYUqzxpRzeZTN+MyG6CNw8P2iuxUjf/Xo2hp0g0vmlijtWgHhIVqzquistaKASzmAJOAuQYniXVp5olrXeHGBA6h8HF+G+p8HbM3c2nC7ALsPGQWqNxWBQBQxlHtZSOPUH5BqJ/FtE2lr4rqXzBtNqlcotmqanCh4ra16QS0uAIMlDVkpsziRCOXg7HI6zcpMTbgMoVMo9XxBrPymU8Rpkc1Leavp3Ve+lRWXWCmgIaF571/CxGtv1eb4bHWkb49Kc/zSc/+Un6/T7b29v8+I//OC+99NIj7/OZz3wmZt/c8/PVr371ce7q20rPZGSzAvP168g6vnlXhzYjAgkB4ZtvB0oTXHyzVwczZlduU9weM3v9zju09y3fzgT6LAqoykBZBMbjCULkCHFo8vEGODgcs004ckxOgCGK0xhOoQ5DQQWSDkqMEGgCFllOkYsZajlFs4ZiAxg29z9Los4iZfquETsrhFTHRIrgQd8Xaxw1gZpA4RMqr6hRkK1B/xKMLkE6asXOuwTra5Z2Su1jD04IntItWdoJk+oON+evcLt4hYPyNrhA6Wqm9ZwQapY1LOtA7aA81mvsK4e9McfdWmBvLwhuNYsnm0WtFaHxwFp5VinUfT1nsW+nyzoZPVaLZbnu0tHDd91n5N3OY63w/O7v/i4/9VM/xSc/+UmstfyDf/AP+JEf+RG+/OUv0+0+ukHvpZdeYjAYHP6+tbX1OHf1baVrUs5nQ3StDrW6pGkP9TVqXkO1YPrHn8OcOEF25hTZc5cwvZx8a0Q9L8i32lJly9tPPz3LzuRVlu4A4TxKOJx3GJWCMxx5hEje2PbeEpe4UjRnMeIZhKyx7gZQN2O5jkCGCDni0IG5Jog5zht0UCT6GXBxOkyJDkJa3m3F5+AdVBMQIjYy52ugelg3bppMwaGoyQHBggHLdEgaCgajbcyZT0TREzwiayu3bxcxWqSJbf0mlj6tr7GhQqGRQjOtdhlXt9DCsJFfoLAzXh1/ntItkUJRMid2mpV470hChqUmhIDXFbnSeASZUmgSLBUSj5CSYANSmti71TguL5nwoD45eTiOdfeXjgHbXBp9GBc8t4pvoKxECk1HD1Hi3fUZeRp4rK/Yf/gP/+Gu33/5l3+Z7e1tPve5z/H93//9j7zv9vY2o9HoMe7d48Ug6Jy/yPzGHZjEbn1jNKZunBZqi/3GK0x//w/hEx8lOXsa3e2w+V0fxNcW022b0VreXnwIvLJXcnN6jkxbLg6X9Pp9jOriwyoBHThMJ39UeR1WbsiCHMkAKaPbsaeGwwrPFMccT43mJEIEfKIJyNjAK1OkVMggY76mCE2fz5MjBA/1HBBgug/81hzKA9j9cmxKTtai+FGK4DIsFo+i0hvsy00qrxDDi4zWtkikoLt1AWnaz/PbTQgeFxrLA3IUDw6OLdyc0i4wKqNyC5Z2ivUlAsWk2mFRj5FCU7qCyhcs3ASPQ4VV1XPVkLyM4+PET4UPkCY29sKJOO0oESSJRp3o4UuP6HUQUuGwTTXnEc8Hi2+2EprPVj8dEYQg4DnZeR+FnaBlymZ+vq3uvAWe6JFlPB4DsL7+xvkwH/3oRymKghdeeIF/+A//IT/0Qz/0wNuVZUlZloe/Tyb35uC8M9S7e1BVmO1N6iRBBFBrA+ydXRg3+2gdxddfjv+cL+l954tkz15CJe3BseXtx/tAaT2IEUo+R7dX0lEjBF2cv8VxL53IobXrQ7a4ak7OsBzg3E0CAUmKO2xijvlZ8aQkSNQZgvI43W8eweD9DEGClBrJqFlee4KUY8LsKiARg/Mx0uFeXBVFTl3AwRWop4DHi4wqeAIJmUlZyzpMzQnWT1ykv34OoD0xPTZ8TBgPHsRqLETgg6fyyygcQmCneB0fHB3dRwjFwk7ZW16l8iUei0TgCZSLBQrdyBaPQJKSY6nwuMZ+MxwmvAUXqJxHWBCpJUUhUSihCIMQ3clJmqb9R1VLNRJxaDooMCgEqeji8VyefQkXKrp6ja3sAr10DdUuib4lntiRJYTApz71Kf7iX/yLvPjiiw+93alTp/jFX/xFPv7xj1OWJf/qX/0rfviHf5jPfOYzD6wKffrTn+bnfu7nHueuvyWsd0yoqVxNgkcJgS0r0vddoprOCbdug7WE6Zzq2g0oSmQnw5zYRg8Hb/wALS1vEq0kl9a7dI2kn81IdY3jDsFV+GaM/GgpS3HUmyOJI+v3kiDpI+k1rsoxBNTfdYBXrCpGnjE+rKPkECFOE0KNCzM8C0JwSLHReO48WYK3MUICRyjjl7JY6YnLCyH46MDcOwOLO1DsNstbinR0AqtGKCxZkpEnPdYGJxGD7VboPGaE0Cj6eAqk6Bz+vQo7ZW4PEEIhgsT6CusrUtmhawaU9Yy5P+BoaSklEJqsK00ickSI9ZZiNgHrWR+eRSWa/fpmE7AryLRiaT2JhsTExduUHnUoqXFNvEkVRdmjngfQU+uUfh4nw2QXL0FLzdJNWdopjprSFhhShBRokaDbnLU3jQghPKpm/bbxUz/1U/zmb/4mf/AHf8DZs2ff+A7H+Mt/+S8jhOA3fuM37rvuQRWec+fOMR6P7+oBepIE53jl//sbvPpf/wC9M2EwKeguK5AS8pze9343QkgWf/ol3LJEiIDqdOh/33fR/cTHoKpJLpzDrLdr/S1vHRcszlu0TKKnTYMPC4r668dESiD66IyAMXEpSqM4j2icRiy3muvi75EUwQaK9WZby2Z7xw/wGYc+OxgSzpPoSyBqQrA4P8OzA0Ei5RpGbj2ywhOKA0I1RqQjRPr29LkFVxOK3bisVTc5WaoDroif2fHluPy2/R2AgKufhYOvxTH0jRfh5Cfj/Yrd6N3TPRV9fFreEeb1mLndRyLRIqFwS5b1GC0NIXhuzl9jcUzAS1I6sk/pF1hqNAoQ1GUFpQMFqcw5tf5Bri+/TsWM6PudUbE89siSTPSRUmBdRU3VLE09ylsnTm5t6LMUfooNNanKAE1hY79PwSrIVjHS25wfvMgoPfFt6aY8mUwYDoeP7fz9RD6VP/3TP81v/MZv8Hu/93tvWuwA/IW/8Bf41V/91Qdel6YpaZp+q7v4tuJrS/0/vgrLkloLqCtYFvFcsSyY//c/JT1/CrO5jtgbg7WoNKPePWD2e38IWpONJwy+/3tbP56Wt4QPjmm1i/UFqerTT44tI4c4YbSamjoak+2hGBGokPRJ5CnqsIMLuwgMgRPAPhwe5D0Bj2PCUb+P5O7en4Kjpa0lFdfBGqQKMfTTB6RIQRjkG0yKBVcTFrfALgmujFWYt0FYCGWgs02Y34RiD/Zfhr2vgqvBZIA69NiR5/4n/PaL8fkJoH8WkfRiHlf3BCDays47jESytHOW1RTnKqyrqRcH+OUSmafY4x0DHnxVEbKV0YKlbpazlNQ46UBCrWoOqh0kR309d4uduLEQLNYJBIqEBNu47vhDJ7b78QTu2MusprWW9sGNzeDwwdJTo29LsfMkeKyCJ4TAT//0T/Pv/t2/4zOf+QyXLl16S9v5whe+wKlTp97mvXt8CCXpjdbZ+upX8ZMl+eyoAoVvvDkPJrgQCASWtaOeLVirapQxSBlAiPjT0vIW8MHjgsWHEBstm/wfAE+JFCkudICD5h7RU8dwDqkMSvbjt1MbgCIGeALclfUTG5Pjdatx9dWY+vGE6PLYvw+okVSFpLCWVGd0zTpKpAQv8HKB5MGNw0gVXYxdCTKNUQ1vE2FxKzomLw5g9ytgm6WtsojeOUo30zYgBhcg34wdI0n/cCnl3hT3lneG+ew17PgrTMKcRSLjW3JRRJ2yWMT3zuo7cl3D0jFf7sBhQT0u6XaSEdaUOCoCgcKNG/PJo0bmu1EkqoOWCVqkOF9TugVFaBriHyh4BHd/ph5eDRJoenoDpVvvnbfKYxU8P/VTP8W//tf/ml//9V+n3+9z8+ZNAIbDIXkeZfbP/uzPcu3aNX7lV34FgH/8j/8xFy9e5EMf+hBVVfGrv/qr/Nqv/Rq/9mu/9jh39W1FGsPwk5+k+NMv43bGd1+pNSLLsMuSUCwJ3lHVgaLbQ1pY//ALuL19zJmTeO8IswVCCNTgAY2ULS0PQQlNRw2oZUGmevcJCCkV2ufUoQ+HFRpLkDOC6OFDQKCapkvFkYvyKntrZTC45MiMcBUoOiKeNFYDBMcP4jWBGbvzDOst/bQgMQuCHyBFD+jFEWPur9oKIaF/NjoZ6+yox8YWBLsA3UXqN1/tDSE0y1kLWN6KWVgrTBd652BwDjY/FPfjWOxEyzvP/nLCzmKPUd5lI13Dzm/hqilSlRAyEAqXS9Tc4kuL6JnYgLxanQ2CuloiFxqZG4QAjSaIGikUIqTYsKSgWe68r4oZURgUGhUMQVqcc5ShwB26kt+PIDn2ZeLBGDp09ICeWeNU97l2HP1b4LG+cr/wC78AwA/+4A/edfkv//Iv8zf/5t8E4MaNG1y5cuXwuqqq+Lt/9+9y7do18jznQx/6EL/5m7/Jj/3Yjz3OXX3bCc4hKFEDA9bhpq4ZWKnx4zEiNbFZ0hiEkghtMFpR37qN29/n4CXPst4luT7mpO7Q+Y4PoddG7/TTanlKEEKQmz459wtlJXoIFIgcG0rCoUGgimHevsaHHRAVPliiKeCqShOIjciO2K9Tc/cyVGguW29uM+duHIQFWns0nkTHypDFo0JAhs4jKyVC6hjeuXo0bwkH34DpNUgG+O3vfNMj4ELETiUmV6Cegek3iedrsPlh6J1ADM4jjj1uy7uDyjq+dPM6k3KPUa55frPCaYNWXbwIh1VALwW2cvhxhc5LTJo3Q4gGiiV+pyAUGrUtoKPx1JQ+VuAVK0fw+rDCk5A3Mt82doKBgGfi7qBJEFZQHpoKPpwHi53VtKQmFzkdNeJ0/wMMky20ahuVvxUe+5LWG/Ev/+W/vOv3n/mZn+FnfuZnHtMePTnszasoWcIoxRc1znqYhfg+3t0n9LvQyyCR9FRGnhj0tctMX3uFIte8bC4yFY7R/gSzU8bu/fc/R3LyRNvX0/ItIYRGiTiia0MXG+YIFIo1gsvx7OFZxnFffBPwY06miAAAX3pJREFUuTowr7Kzjn9r9RxFTKwO1qulrVVT9PEdsGzkJdaDMSsRlaBEjiRHiDdxUA8OqjnYedyOncObFDzBVVDN4hKySmHtWRg9C2vvi+dE3Wmdkd9l+OARCJz3WFci1BSHZm4PqNOcRRhQ+dW4OugKij2Ln1k4fez4mUNYGoQqEUYdthE4ahwWgSIQcMQpPgCFbMROgUQ2gijgmi8F1V2fizdHj20cNR6HFJLc9BgmWwzSjXYq622grY09BkIIyPUOdHJEkJBmsLfqcWiwNSwlTJfAFC8VlRAEa5l0ulw/VWPlPnpnSnFnTJFnyCRBdbtUeYdES3QrfFq+RbTMCW4Ul69ERh1u4zkgLk8d99KBo3R0OBI3q9vkxGWuVeTEShQ9GKE8Rq2EUQ0s8KGCN1muFyolDM7F/Up6CPMWqjBCgek1KeabMLiE6J2Ozcwt7zoKN2dpx0gM1pf0O1NUXdLPNEEEPIFKCmw4Ot6Kbkqy7QinMnQv4y4R3pPoExkyU6DVobuUPZyxil5SKxRJ49QjGxOGqqlxvnWhA4acXvQAkgERIFE56+lpBuk2Rr67BnOeVlrB8zYTnKN89TLLr13FaYPfr/ELINwjTrwA56F24OL3B5IErOVApkz2IMwXXHr9MlU5p+zlqI0RO50BN7MB/WGPD2730aoVPS1vDUGOlttINnBuDx/2G7GzakJeVW0gCpuUKGJWvTqr5slYpRH02JkE9haGc+sTsmTl5yO5X/z45rrViaTEcoB0eyiRI8Q335gpe6cJnW1AvKVKjJAKBuej4NF5K3Te5RR2Tu0qAgXWV+RJRWzJWbI7fx2Pow53LxUJJchO5FjCYRTI4XWJJN/OEEDp47t+1bVWYBurwSMymcWlMieoKQmH3lNvnpxRDNSVltovqVkiPGiRM8q2Wc/OkOrOW9p2y/20gudtxhcl5SuvMf+jz+OuXotTWaoplRoD3U4UOgRIk3h9XWOVRkpJtr5Gp5NyoqNxy4LeZEyoS/z+mLAsmbx8hWq0zji9RGE9vVbwtLwJfCjwoUCKtGkMDggh8Szxh/02qwbkVQVm9XPcUyRObx3hKOsrVD5+Px4vUrJk9d7Mm/sfPwnFsMS7PXsmuLCLCz0Um29qvPtbHU8XKgHVTr+8m7G+ovYVWhgKPBJJrgYkcp+FnzFnQqgt2IDMVlN88f0aGlF+9zsuVicVAkLABXfYgSY4Wpw9Xg2SJCAkthK4xZBOz2PFFEtJfehSvrrnG7V0SHLdBzxzO24qSQGJopP02czO0zGtCe3bSSt43mZklsa3el0368EBnGs8O/qkly4QhKC6eg3hPSFLobb0rI1fgkvNCaVYo8SLEuUqjK2xZYGva4ZhghsOGPRTOknbV9DyzROCx4cJIRQ4UkRI8UwBgZQpIXSaY/SRz06s6qyWYysefhB3KOEYdqCXWLRZ9TwoJoXBOsUwtyi5cnReLXsdxzT7KaEdgWo5hg+Og/ImB+UdfKghCISQDJItumaNebnPsqoJdY1dWEwdYHD8+Bge0D4sMCSkogPCUocFgRpQzSB6FEuGHCMMvul0q61jugdlNSdZKjrbjpoSCGhyunKIDzXTsM+jlrcUCQhQIkWJDBEEUiqMzNhIztEzrfHs200reN5mhFJ0PvwC+Ue/g/kf/Xc4OIhXBFAb63Q/+h0sr1+HV18lVBZ6XcTGBmEyhrKE/QOYL8ico/Pi85QXzxEOJiRbG7j9AzprI9YywXCzHVNveStIghDIVe+NaHqTQ4ZkhEZgOYDDqImV4BlzdPB+sKeI0tDxUAuHMQAZ00LwtVuC0mVcWHecHSkkp5AkWC5z5NfTRXESIzdQYtia97XcRSCwtDNm1S6lX6KkRgRJ4SbkeoBUCoLC1zWhcvg8ZmQd527pITFkseFYggwpkkCCRglDCLFROeBJVZ9RsoWRGZP6DnVV4VkgtUOl7rAyA2CpEVKTyYy6chSHPlf302eLXPfxONKQ4Z1BKOjpddayk+1n4DHQCp7HQHLqJFv/t7+Oc5biP/6Xw8vlsE85mbJ86aXovFxXoBVqaxMrBVy/EW/oHHiP7PfonT6Fn83wdY2fznBS4KfTOPau2gpPyzePEBLFKBr7YWIl0tc4v0dgQTwcRAt7GkdZQY9oLng8lPdhVZ4OyICRjnh66WO9oHYO5z3eDUlYR+tNvK/xvotHAR1SuYmSI5QYPPnw0JZ3PUpoumaNSXXnsPpnXcUizLG+JtU90mRO6RxSgUge1YelSOnQUSNKP6NyCzwejSGRHbTICcJS2hkeiZaaTjJkK7uAmAumYofBhqOuFXlmsKFsJrQALDO7Sypyctmn8DPuXrY92odgKjyeVHbwqqaipqP7rGWnyHT37X0BW4BW8Dw20u0tktHwri6H+itfp37lMtQlvmw6+xdL7M3b8QbGgBTIjXXSixdQgz6d9z2L2t6k/NrLFFeuQl2j8g6+KFDd9kPR8uYQIkZKADi/S+0vNzlYGsEASYagT2COJEOzhiCjpAJ2eLjYSYAux/16JJr1THNp3VI5ydnBFkr1kHSw/iax0TnBsI6WJ5sAyPZbbcvduGAp7BQjMk513k/p54ggOKhuMav28S5gfYnDQh4Xqh6FQqNJCNJiQoYNJQJBwCOCAOHx2CY13WFdybi4QyZ7WF9RuAVZktBPezFt3clG2MRFM8sSGwrmYY/45eF+BIqqLsEf4HRJAHLdpZ9s0E822s/BY6IVPI+R9JlnQGuwjcIvS2xdEaQAJZFKNxESMi5naY1YH5F9+AWkdfjpDG8d2cY6pXgFNRwgfMDXFcsv/Q/SZ59Bb663vjwt3zQrb6xAQe3uYNkhmgO6ps2yQyBtuhWGaLUWexlcD9jl4YLHcuTCHM0IAxot1zk7GiPI0LKPQFHbPRx7QI0kQ8oeUuTtQb7lgZR2ztyOcQ4kAwbJACUF1luWdoYLJTNXYO/LtrqX+P4KBCqWSK9IZRePpfAzPB4bHIGK4IjBsd5R+AXLcs64vANE/x2FwckMh6XyBbpZ+rWsqpurBbQHGw8qFJYafEB4Qa4HdPSAUbpNorK34VVreRCt4HmM9D7yIjsXzhBevhwv0BIZwEmJSdK4dNWYu5EYCJ5QFFSvXCaUNebkFsn7n2Hyhc+x+PM/QwhD54PvZzKbc+vLL5F//VUuff/30L14/h19ni3vfkIIsWGZkhAUiLJp46w4OiiP8cyIp4QOnpza7RKIXlGP9hfxROE0BBwxPlEjZYVHIVHU/mbTJF0138LjaHus7LSiveXBSKGQSC6PC+bFNTqZYKsbWLpxrOz4mEx+PwaJaGYMFbZ5r0drQEcSUpysGtNAi28mE1Xo40INwaNEQh3mREPBOSDx2Hh775ucLY/EINFoRGNTePyzEme+ZHNfRUI09AwIoTEiZaA3GWSbpKqt2j9OWsHzGPHzBclojVK/HoWNlkhlkN7H5av5vDGutSAFWAfzJXZ3H3pdCJ793/897EDDoiQpJB39QS5Xnl03Ibu6T+9Pe6RrQ0JRoUYD5LssOb7l3YKNY+eh8RUJIqaUh+OHgCM3WZjhuI5DEIXMPZWdwFFrwspqh2nzjwxJghIZYBAhYMMSxz5xyUuiSFGsoWQP2boYtzwEHzyBgBYZVeWwoWBRWfbNBOen+OAan5wjgaEwGDIsdeOQHFPQ7662BJwPzP248dGxza0s1seJq0A0L/QEJIJE5LhgCY2bj6VuYkRd87/V4ycI0sPYCIFGkyIQ1Cxxx5LTg+8wSLbY6lxoYyOeAK3geYzUV69R3bwJtvkwBgvdBLo5lPUx01p/95fnEGA2wzkHxlGKLkIKuDNh/7f/M+IDl8iv3yafzimDZrG5Ds5jTp4g/8BzT/pptjwVKAQZQRTI0EVKjRcFlV0jCpp7qzeSo1H0B1R2LOBjSR4kSM3Km0eQIeggxSZQUQeLY8IqaFSyRSLPga8RywmoGSF/SEJ6y3sWHxwH1W2m5R1c8HQzSV0ERqlGhUAQkkQOUBj27Y3Yw4NiJDcpQkUZlgTcfUaDzdaxjSBRCI48oRxVUy0S0cKwuU2HzeQs+9VtbIj2DOFQ5MjDbcbbGgySoplAjLeL3ZzhrgZmgVSCjhm0YucJ0Qqex0i1s0fY2Tv83UuJSzQqCGTV2J4LEX/8A04qzsHBAu2aD8mdKfXNMVuvvEbPe6RWmP6UYG0s3Ia35vbZ8u3PakILHAiNEAJBB8Npam5zZCLYJyaW5wRmxL6d+1mZ9ht5r8GaQdJFqxH4mjK83BgarowMU4zYQMohYnEnTiuqnRjYadpyfkukcgVLO2FRXWdR7zJ3NUYlbHZTCjdh6mYIBH2dMEjXqcKCmfMIAnM/a0bKHUeGTndXgWJGVvzdIZrlpliv8Q8I9Kyx7Jc3mDMDfGPMcHx7mgBk9MjlgMJPEU2kaLzlg3p5BF09JFNtKO2TohU8jxG3LKCOYiUoKC6OqPMu7M8Z7NbxoxhC/IG4rJUkRyIoS5G9Pkzn0Z3Z+hiW6CD3AmzAdQboCxfQRmPWR+/UU215Coh9Mnf3yggkYLCuAhIStYliQOxV6DXfTCd33aOum+/M0lBTY9TqMJIiOUciTiPQlOEa3u3EAEeZAP3o7ixqPAeoUEO9iE37ol3Waok4XzOtdhmX16n8HtYXEAJzVxB7aeJ/ASZ2ByNSUtmlcnMsFSVLYt1RYcgICDxl01AcRZBCY8ioqXHUjeHgI/eKOfuHv4UHfI4SUpTQFH7axOEmMeC06foRh+InIJF05IhTnefomOHb9tq1PJpW8DxGTL8PWQqLJWGYUpxbj6bLyxqvJMrfo/qVinETSYbq5JjtTTCa6toNpHOEUZ/gPH4S3XHpjTCnT6MHA5JhD6E1dlEQnMf02/yVljfCI6SlLAbcmSsIXU4Pc4RaNI3KDhjQWIBzlKcF1i8wEsAcaqgQ0iaBfZfgprh6H0LZ+BQ6pBqgD312AiHYKMJWAr+lBah9SeUXLO2MOlTgVjWSGneP27ejYq++QSZ6CDSO5eGykSCho0YkOmevvNrkYxkSkaFVghEdFvX+4dLWo7n7WC0xTaxuBU1jtMXiwqqROWBIm9F2iUYe7pdGk6icYXKCzPTbpdwnSCt4HiOdj7xA/qHnWX7uC6ilo7comQ26GOdRUnHfyKIQUFtkR2JOnSA5uY2fL3B5DtYiswQzHOEFBOtBCvITA+zl1yj2xzAcsZh4XG1Ze/Ei6ckNpBRU1pNq2X6wWu5BosSQZVXy9Vs9tPQkck6SjMl0RZYYoIezisomCAWZydEqZVrU6LQ+TE+pHdRhgvd/Rio1WntE8BwufnmFVBmJugCiAjSIEkwH2jHcFuIkYenm7BU32FlcYc/eIHo1iUbiPGhZKGBZMg9V89vRbRwVlVswcwfUVEgkfbFJmuQciSb5kO0+Gokk4FHoOG3VCBuPPdyHmiWrXC3RZMcJQEtDz6zRN6OmQbpd0npStILnMZKePcOJv/UT3PmX/5rFK18lvT6nO6sIqcL2epDa2PhZ2ej5QOzlkcMBZmMNP51ipwtEmiCTBNHrIfo9ZF0RtEf3e4S9fSavXSbMl4T+kGLtLCExvPLyN/DFhFIN8EGw2U95dqPXip6WQ4QQKDkiM5pZ9TLj5S5CFpzsl6x3HUoojFlQ1JZlHUiNJlMeIVMEOY4aDdQ2UAdP7eNki26CHdVhAoUB2fjwCH2YhB56pyDpg84Qqp0ufK8zrw+4Nn2JW+XLzdRU5I0iOONtHtwjs2SGb6aiFAYvK2b1AiEE0muECBCOQkYftI0HiSLbbFOjMehmkkzjgmiqPitW4aWOVdbW0Gyynp3GqJRUtZX4J0kreB4z6bnTrP+f/wrVP7+NcPukZ3p4DwczqGtNL8swuYt9Ok3gaJgvCEHgplP8soQAPjUkG+tQFYRlQRAC7z0UBfXBGBYLbADvBHRA9Lv4b1xnJ2ySnb7IrhScHwUS3QqeliNi83JJYWdMy5qXbkI3FWz0YDWmrjUoD7UPeO9QEnqZxHpitRGBEAoRHEp6QhDIOjrWok0Ttt5BiIzjqaBCpZC3Que9Tu2WOF+xs7zKnfK1u8TOIcGDdXH1U6+Wk8DW8R2lzL35bgKJIjYYx2qMQFK4BTUFEkEmRiiVYmxOzfy+h5Qk9OU63num7HC3KLLN/wfAYzCEsHLbyQhNz869zyXgyWSf9fQMUipk6z/1RGkFzxPAz2YoafBOR/EiJEXp8cuSelkjMkHIE4yNkyxuOqe+eROpFaGu8LMFQisqKRGVharC1xYhBfL0adJnL7JfwauTgqQuOf/6dcy1AoPm9OZ5rDBsnPkIRrVip+V+UmM5PahRwrGoJeN5ht4sMDoerCWQa40XAqlLvL+K0QGcwIeAEgqtwCgIQaEcCFsRSzzxCkm3yclq34MtR1i35KB6hXk14/J4wtI6TALqHh0gaovyHikCtZQEqfA1FDVYp1lTilR6fGMruOr60SRINEpqgg+N3V9AoJBCkwiNkgMKbygOzTUlsgmgkEpiZIK1PQrmxya/Dj1FiE48go4cYnTCsl7gQgnEas9xU0SNIggLIrRi5x2gFTxPgOTsGdJnLlHdSvH1ElcUJMsS5z1BWyb9HkEbhkqjixIk+IMD1PmzyKLCqwJc9O60zsNshqwtYVcj8g6d7/4ERTDYz36e8sZtJospo8TjFxMGOwWZ9Iy2K+ziJOrM+1qjt5a76BjNi6c0G13NosowJkPJm4fFGGM0hgGhLigOxgg80khMNyWELC4LINGiORm4qrFaoFmq7WI4jZRtr07L3ThKXKi4OV3yjds1iVFsDCydewp/QcQuGBcEIXhAYQNUdZyECg6kjm71hOh/QyNbjOiBcKACoWmAVigCNdYHrKgJTZVGYZAoPI4gYFGPMSIjV31wkiVHmVl37R8eiaBvtlFil7mNvUcqaFI6cfBdGTLVZSM/h5bJ439xW+6jFTxPgOTENpt/469TfOMVqtdfYfHVbzDozfB+RonACQipJugEEFBW1NM57spVQvCIukYOBox1h9JWdIuKpFjiyyWiqpgrxejCJea2RCaCQXcdjaec38IvS8L+FYqvBw52blHUGafPnSMzrehpWZHQSVLOr9VUbkSgIk+OV2IsMMFWluAtQglc6TDdFCH6QAF2GU80SoHOwGsgRZsNlDiJUaffmafW8q7GiD5dvYVmgRaCwmq8K6lrMIKjM5Q2eLJYHWkKI4mGfiZx3qCMR6BJVIKwdVxSEpJUdZAYwFO6JZYaS4w7iUWagPe2GRYXTW+OxWDwIfonC1GhRUKu+tRuNd6+QiMaH59aVAgRsN41E4ianhmRqIyuXmc9O4lWWVvZeQdpBc8TQg/65M9egrKkvnmA2dyjrmp0uURbh1rWGAdMJlDVsJjj53MwhpAYpJC4qmxMzUV0uLUeN55i7+zQPbnNxWEGXU32kRfZuXqL5dLRWU4RJqdEs1Mp9iYONS24sN6avLVEFrXg1iSlsAW9dMnJ0XF35dUhIiCMIMwFPnh0aojj6rNY0fEFuBqsRuRbmPw0khFKddpg0JYHMi5q9hcV/XSLZzdTSr7KpFhG027ABegKSSYT5g606RCYUVNFySHBpAUdQJNSe0sIAqNSgg+4YJnb6CElm2mpmorQZGG5UKJDt6noWCyWo96cJQZDionJ5r7A+9CMsB/1CmkMrJbIkCQyJVU5dSjJVY+z/RdQQpGqDkq2p9t3mvYv8ARRwwFqYz2OmFsLxmBqy9q8RnYTfFlFsQPRaLAs4lrvoIcQgcF4l16SoU5uwU7TtJxnqPU1VK9Ld32E7HSYnTjN3pUd5GiN/JnzdD78fuy50ywLicoHJLr9htFyRCBhXmtKC1qtPHcgHh5yVj48OgGxlsVYuBRiaX8RtdFq2iUYEnESoy4gZWuX3/JgnA+8sjPjzqyglxo+enbE8xvPcWshuVUuqGuH0ZDoaPE3lH2E6FA7hXX7rIRJJiBRjuACVaioQ0XmYpjDyqBQIqmbJS7uaSK2zImxEnDvUpUm0CNh4l0jslZJ6MfvH0fPe2rIRnqWUXYSLRNy16ejR/STtbf9tWt567SC5wmjRkNkr4dIE0y/j88zQggIY2B+E4AlioAg9R7lBb72mP6AXCn0aAi9DvMvFHDrDt4HiqJgMVzHCMX2yTWS9XWKU6dY6IzhuS163/kB9GiIKWq8Dwzz9kTUckQ/kZwa9FhUU9a6lph4DhyavB0Zsz0w8kcD1oBMMOZDGHW+FTstj2TlNXljUpCokgvrHU70N9lZvg44jInSoqwDTtXkMkHLDC0Tlq7CMkYARgmE8Dg5xbnYS2YPvXAal3tWY+cPGz2/pyenhipAJgzOSAomD7lvzGHXGDI1pJeuxyW0VNEN6yStv9S7jlbwPGHM5oDhj3wMvd2lfPUWbjanbpalcJ4CxW0xwgrFKMzYqAqYjPHzDdJnLiCMYvInXyC8ermJJkrYu71P+adfpjOfoc5s0T1/jrC+RXXqHPP1LvT7AAyzo5OQXxaEukb2ugjZVnze04iSzU6F7XgECYH0MD3a+Tm1jQNXWt9riNx4R4kETJ80uUSiz7fLVy1viBSCk/2My7lBC9idjekkgb3p69TTElRAdwylUVROULsxxhVokaCFpgzx8FcHUHhKfzQ1FZqsq1i5efOmgksL8zKlkh2sXkZ7hUMEGX16eg1kwHpLqjLWsjN0kxFCSBKVf6svT8tjohU8Txq/wKynDH/ow0y6PSb/4Q/wBweEaglGQhXdOKusEyeyggUhsJMD6uk67s4u4crVo2XkskJdv47ZH2OHQ6bjPUwQZOcS7IkeIQSK6zdQ0xnm5DZ6fQ03X7D44p8TrCV97hLp6VPv5CvS8o6jcEzxzPABbk5gXtScGBYkwrEsa5SSZEGRHA6XdIAOkhzJACVHGLXeip2Wb5r1Tsqzm33GxQ5a3+TKZIdiuQ8q4JcWJ0CbBE1CAFwoYzOy1ODiaHjh7rcljNEOR2Gh4UG+Pg/DQ2U71M6gRIkVxT03kHT1GhdH34EPHo8l1wMS2fapPQ20gudJIwwESb2zz/KL/4Py+g2Cq8jefxK3a+DqPmuzJd0gGAw1auMiSijcbMbyC1+CsgR797eWZDalcoFro21Mf4t0MOB9WwOKk306xQJ/+XWCc/i6Rq2NKF+7wvzzXwQBMs9awfMeR4ocSR/HHcp6wu2xwAdBojwnezXCeYoiIHqKJMmJieh9JF2MOocSPYSQCNEuY7V88yRa8vyJAXvL61yZXWfqFtgUqARSSrTKyOg3KVQWGwIi1GgRMGQ4bOOifBzRiB2IFR4LTezDNyN8Mjkk6UuWVYmSS+42M1T01Rone8/SS9bfjpeg5QnTCp4njexS7x9QfOU25SvX8MUSkUryZ09TD3vUtw7o2zm4Jagu2QvPoTc2Gf+n/wzjSUyWvgfjPS5JKEdrcO4cda9PbkvMn36e6rUr1M6SPfsMutvBL5cUr1+lunULrKN+5hK+KJFZ63j7XsbIE9T+daQIDPKA99AxIL0iqXNM3aWnz6Ex0XNEapToo2Vb1Wl56ygpqL1n6mIlRSUaLy0ySUnSLpnOmNsxDotEoslRwqBFSuWXlHc1Ems4nLRSGHIkkMkeoJj4249MRU8ZMEq22K9uoJOq6f0JxHBQQULOWnqaQbLxGF+RlsdJK3ieMEIIQlAEnRG0gdoRnKe4MgZvCUXz4Q0BipLyynXkaAhSgWr+XEkCxbFSa5IwGnQI5QR9+wb9kab4yk2qGzfx0ylqaxO1PgTvmX/+i4TFErMev6GoXo9gLasU7Jb3JlL2kH5IanY5NQhYH31OjDjBcPQMygwR6QiAEGoCFoFpxU7Lt443sPR4XSONQZlYKZQobHBIFA7LqkmY4DG6Q6o6hNpTsWzCOe+uxyQiZZhuk6iURT1BVarx2TlObGgWaLQ0CKExMsV5R8AhMWg0Qkl6ZoNuskbtC4QTba/OU0greN4BzOYGiy99merWHZhMQWsWr95ClseCRJWCxIB3VNdvQKcTRU4Al0jmnT6hrunUnvT0aUbPXqS3N8bffB3sglIKhJTIfpf0/FmSU6dZ/vmXqW7cQKY53e/7LlSSkpw6iey2AXbvdaSU5Or9LJwnT+8Qmz0H5PLDaH13+V4Ig6Bdvmp5e7BXF3C9xK1Z2BTIRCPQCCHIZIeuHjEu7xBwBFHj0XgsRuYMzQmm9Z0mMCK2K7tG1AQCtStY2H0qWxLukkOSnAGj7CST+g6FW1D6OVMLHbOGqCWVXyKEIVVdBmadYXaSIBwLO6EOBVomSNEauD5NtILnHSBYR3n5ChwcxEqO91CUyDwndDpxTL3XRQRACKprN8GXkEgoPb6sEVpSZYZCBbqdHDkc4K/fJJQFdmYw25skJ0+SXLyA3thg8fKrTP/gvxKWBdmHPkBy4gRhPgcl22/pLQAo1acrPkoINQiHIEG2FvgtjxHna6rZmHxHwq0F6n2GcC6N0Q8hoIXhwuDD3Fq8xn51g9qVOF9R1kusistcUew4NClKZtS+oqKgDDOKeoFsKkMCSUKXQEChUDJWdXLVp3AzLBW1SzFJikrWmFWCmhJHRaI7rGcnmVR3KFkiUBwPwm15OmgFzzuASAzJyROxarOMOVns7KG/5xMk589id/YQicHt7YN3iFSitMEbgT9YwKRCewXeY5B47xFJghoMKK8dIOcTSNbxVc3Bb/02bm+CW8xw8zkqzUjOnqK+eh07mRC+9jLd7/pY27jcAoCUmvaw0PKkmO1NuLa/ZA6MTvUwHUONxuNwWJZuyrw6oKO7LFwH7z0OS8US6epGzDS5VVLTUT0Kv0dFfTiQHnPSDQYDSIQIhBCwfsnu4ipKKkJ0zyRQU9gZpZ/jvIuzXsIyqw8IQM9skOkKLUwbEfEU0h7Z3gGk1gx/+AfwwbP7q/9vOBhDWVK+9Ar97/ooUsrYV+McMjHIjR4icfiyYvHFlzGTBVQObT0mSQjzBdUrr+GtBQ/1nT0CsExuY1+7AotFNFCRCpIU2e8jRgPKL3wJv1gAoP+XH0R127iJlpaWJ8etm/vsLTWL/pBs3aKGUN2agwI50LjMc6d4DSUTjEiYh1UWlidQNbUag0KDh7G/RcnynkeJSVnQtB8HScUSRwXMj3kKCjyeeT2mZBbNX8librrUeF+jVRofq+WppP3LvUOoXpfR//z9zD7/Rco//nys8pRLqtevoYZ91Po6nQ89jy8r9PYa6tQGspuzvPz/IFzfjR0UPjY2u1t3qMoKv75G2BtDUVIdzKCTx8mu1dK1lri6xvkmL2Y8xs/n1Lfv4K2jXY1uaWl5knSGfbq9Hkmm6W5WiHAAszkYiVc5ZIHCzhGioPQLrI/u3zGuM6ahBziMkrD3iZ0VNQ6FQVM1y1T3E1AYhBQIH2tHierQT9YYJFv3um62PIW0gucdRA8GDL//e7n9jddgfx/R7aI31xFSk545Se8TH6W6dp35n32V+o8/T/bMs1A/YKyyrnHTafxAlmXsCap8/G8AL8AqiXEesb/H9Lc/w/IrX4PZHJll6LU1pGnfCi0tLU+WM2e36Qx6IBxzrjBdLghDw7K2oGKPz4x5PJbJuMSk0BgRG4YNKbWPAsY90mdHEgiN2LnXTDCiMGS6R64HLO0YISRb2Xn6yQap7qDbfrannvYs9w6Tnj2DSgxOCPx0ij5zivz0adCaICTBeapXX8ONx1RIdJ5RKxUrQiucixNcdR2rPhD76azDAwdZhhASU9f06hoODrDeIdMUlXfRp7YRqq3vtLS0PFmEEKwPu5RuwXwRQEvEVoq0Gq9gyZhy5rDTmmSYYDoyWgkGhRKSrllj4aYsrMWQIMkPG43vHlIPjSB6WNSEpKc32e5cZD09Q+VnKJHQMYN2EuvbiFbwvMOYE9uIRIO1MJ4w+cwfIX7oL6L7PcTVa7j5AtnvgA/I9RH5aICfzXC3d6Eo4/0gpqs7D0rGhEetoKyohGSZdtBGYmcLOnWN9AGyDLW1iT6xjV8WVNdvkl268M6+GC0tLe85QgjMqn2qUOF8lypM8SqKlVB73Gtj1NUZ5kwX9eH1pmnZYr2hLq9B462c6i49PaSuJ8zchALbuCuH5ufBYqcrNlhLTnGq/ywdM0AISU7bz/jtSCt43mHM2ojORz/C5OoNqCv8jRvM/uiPMadO0Hm+pnzlNYRJSJ8/hTm1QfXaFcxwiJstoDxahw4QqzppiujksQScpiQhkASJryxZVUV7LgH6xDrdjzyPvb7L8itfRWUZ6YVzbZBoS0vLE8WFGo9Fi4S19AwewX59DfCEyuHvFCQ+IBcWEwKu6aXx1FSHRoIK7RNwlqWb4Cnu8d0RGNI4uk5CwRwIDMwWzw4+RicZtPYc7wGeyNnt53/+57l06RJZlvHxj3+c3//933/k7X/3d3+Xj3/842RZxjPPPMM//+f//Ens5jvG8H/+AeSJTTAGfMDeukP5+jXK6zex4yl+tkCv9ZCmwu3fRgiPUDpa4SpFAGzfUJ/oYrd7JCdPIpIU2esiOx227JItb+mr5gMtwO7cpnj1FXxVEqZzghSU8zmVexNBey0tLS3fIlJoEpnT1SNG+QmeG32MbXMBkIiOxlzoE052CBf7VA8dBfc471n6Ao/H3eWRoxjKbc50X+D5jf+J7zzxf+A7Nn6I54Yf59nhR+mmw1bsvEd47BWef/tv/y1/+2//bX7+53+e7/u+7+Nf/It/wV/6S3+JL3/5y5w/f/6+27/66qv82I/9GD/xEz/Br/7qr/KHf/iH/K2/9bfY2trir/21v/a4d/cdIbtwjtFf+l+Y/9mXqV95DZyFuiIUJWrQA+dRnRxUhTmzjVzfQm6doLp8lVAU2HIJ2oISiM0+sj/CBIdIMurdPbwSyOCh2yXUBwgP3Nij2J2hz54lOX+W2e3XufzVCbo74MyF5xl2h+/0y9LS0vIeQApJP9nAB4dqAmifGX2CfDHk2vyriGcE0D8cLM/ookWHMsypma+2ghYShMSoEdJbhBB4ApnusJ0/w2Z+FiXjKW+gNhmkm+/As215JxEhhPDGN3vrfPd3fzcf+9jH+IVf+IXDy55//nl+/Md/nE9/+tP33f7v/b2/x2/8xm/wla985fCyn/zJn+SLX/win/3sZ9/w8SaTCcPhkPF4zGAweHuexGMmeE/xymtUV64y/9KfU37jZexkjhwOMJtrZBfOE6oKocCcWCN97gPItMP0j/4bbjaj2NmleOVreC3IXvwQvY3TLD7/JYISuN0D3M4uSEnpHHa+iLnBqcJLTdbts/GJ76A8lbHjF6j5ks3zz3L+R/93hGrjA1paWt4ZnK95bfJn3Fh8HdtMViWiw6nOc2xk5xgXt9grb7CwMwTQSfoYMrQydM0a6+lprK9RUpPpDqI1CnzX87jP34+1wlNVFZ/73Of4+3//7991+Y/8yI/wR3/0Rw+8z2c/+1l+5Ed+5K7LfvRHf5Rf+qVfoq5rjLn7JFyWJWVZHv4+mUzepr1/cggpyZ69RHr+LPnHP8L+/+fXY8jnfIE3BjudYW/eJlQltn6G7ndtYvcOoKqob+1QvnYZbu0jtUZsL7DsYff2Cd4hlELoaINeLZZAwKeKyiiKXodqsMGGTkg7PTovX4VbB/gbU4pnXiR73wfb6a2WlpZ3BCUNp3vvQwnJvJqgpCbROZv5BXpmDSUNxqTMyn0QAiEEXb1OKnO6ybAN92y5j8cqeHZ2dnDOceLEibsuP3HiBDdv3nzgfW7evPnA21tr2dnZ4dSpuyMQPv3pT/NzP/dzb++OvwMIIRBJQpIkdL/jQ9i9A+z16yTnzxASjd3dxS8LgguM/3//CX32DEEZZJLAbIEoa2xpuf7q6yz35mzOluS+Rg0HkGWEosA4R6CxtEAQZEIvSwhVjf/qDfJrB7i9A5xecPCffp+NwTpJGznR0tLyDpHrPucH3xFDk6kRSLQ0h9dpaejqNXxwSKFJVQcj07Ynp+WBPJEprXvffCGER74hH3T7B10O8LM/+7N86lOfOvx9Mplw7ty5b2V333E6H3kRvTaiun0HX1ZMP/cFvHO4ZUHY22P+Z3+OuXYDORoi8jQ2L0tBYTLGKqGUCjVcY0CNOXcGu1hQX36dLFHUpYfaob1nyAyjNcXebmxeLmoIAWcsxcuXWb56Gb2xjtAaoRR2/wC7u4caDTGbG+/0y9TS0vIeQAoJAiTpfZenqkOqOu/QnrU8bTxWwbO5uYlS6r5qzu3bt++r4qw4efLkA2+vtWZj4/6TbJqmpGl63+VPMzJNyd73LOmzl3DjMeP/9Bn8wQRqS8gz3HiK1Aa1NkSmSZxJFxIlAlpL5HDA+uaAzkaf9NIFqtt3WFY1VZ5jTcAXJaIoSAuLmy/AOpjHTC3SFHQWe36u34AvKAQCvbmO290jLAvUwRjV7yG/zV73lpaWlpZvXx6r4EmShI9//OP8zu/8Dn/1r/7Vw8t/53d+h7/yV/7KA+/zPd/zPfz7f//v77rst3/7t/nEJz5xX//OtztCSrwD6jpWuZrKmEhTfPDYnV18VcNyCQJypTi3MSAZJCTlEjebY8dT9MYm/e/5BOV8ie0pyivX4OoNuHYHqjr6+ThLHcBKhZ0tyF6/SnAL7LkzhBq8SZEbIzqXLqHTpO3taWlpaWl5qnjsS1qf+tSn+Bt/42/wiU98gu/5nu/hF3/xF7ly5Qo/+ZM/CcQlqWvXrvErv/IrQJzI+qf/9J/yqU99ip/4iZ/gs5/9LL/0S7/Ev/k3/+Zx7+q7EpUnZM8+g53N43h6v4vQCrs3xt3eRQy6iCwnCJBrI0bvuwhBUF0+wE5mqDwnPX8WIUdo61An1hn3B4TJHC7fjE7NSoLXBB9wPiCXBaFYUldL6ps7yCzDIqi2NsjPneTSpY8hdOtZ2dLS0tLy9PDYz1p//a//dXZ3d/lH/+gfcePGDV588UV+67d+iwsXYozBjRs3uHLlyuHtL126xG/91m/xd/7O3+Gf/bN/xunTp/kn/+SffNt68LwRqttl7X//38g++BxuOifUNcWXv0r56uuE4Em2N1Cb64jg6bzwPL3v/W7CbAFG4/fHkCbozTXcwZhQLkj3J+RpxtIDQhDSBPIOupPBbIHf3UcFhwnArIRZiVcTrNHYsmT+n3+PxcYJuh/8ADs3xkwWnq1TA9bW23X0lpaWlpZ3L4/dh+dJ8zT68LwZ3GzGrf/nrzL9/c+CkqQvfABZ1eyXHn/xIqc//AE6RmL3Dqhv3SYslwStEQJkklGcP8GutIjf+69kV26hkXS/+xOIxFC89A2Kr3wNptP7HrdW4KVCdnK6zz1L9sKH2L2xz7K3Qe/DL/CBv/g8UrU+Fy0tLS0tb42n2oen5e3HzeaxZwegrCi/9g1Kk/LaxllsOqCelrwvLAkh4Oczilcu4xdLRJ7TfeH9yCwl+dyfoq5fBSTpBz9A/3u/i3pnl+q1K6jNNZyzUC3heMqEI6ayL5bUV28QgqNYeK6v1wz3T/Kc963gaWlpaWl519IKnqeNAOrkCdRggDs4gPEEtCBdOlzw+M6Hkee3sXt72PkSX5bU4zHK1pTXb9G7cI7lV17C3zlA5AmhrhHdLvJggswz8vc9h93aoPjay2ALqDxUFk3UP6Z2hP0DaltS65SsP8T3MwoXeI/1lLe0tLS0PEW0gucpw2xvMvgLn6S88jrLP90DKtIaThV3qKoFg4GhtHPCdIa9fQfvPHQ6BOuwe3ssX/o6fm9JWFSEylNdvsLuv/13qDRBSEnnxRfQZ09x8B//C8s//wp+bxcqiwAO9UxVwUFNnncJ5ZS+K9G7u4STW+30VktLS0vLu5JW8DxlCKWQWY4ZDFgKCTaAh8xZsnoMX/gCk9deQ2YJ9fVbICX6xBYy6YIPlFdvEHyI3j2VZ3Gw5PWv3EJ3c86d6ZFcOIfqdem87xlwluobknpnH+YzcMfavVwgL5bkl6/Av/l/sfOdH2H9//jD6CwDKTCbG8i8tXZvaWlpaXl30AqepxDRydCbG6A1BAnBN1cImC1wywKX51BWeAKzm7skvS46WKSrEXmXsKzB1kydZi/t4QLkLrBpHdWVq9jbu6gkoftdnwRjmP63/4579TLUTWOPEuBdXFIbT1js7iGDQ6UpoVjQef8pej/wfYh8Hamyd+7FamlpaWlpoRU8TyVmc4PRj/4wbr5k/Jnfj03MdQ1FE6LqPCwLCIGxT1gWGmUtJwYC042+PXVjNpisdXBDjUgVyzMjitevYno91GiAGg7ILp7Dh4BbLpkVBWEyBSnj403nRzu1LChfuYzb3UebBf52B7v7MsnF50nf950kp6INQRwKDG1ycUtLS0vLE6UVPE8hQsQlo63/+/+F/P3PMv/Sn7H86jewr1+NQgegCQp1CLz1SCVwaEAgCDGWAtg4u0n1/g2qumawtDBfINZGJBfP4fbHiEEPe/kq7sZtdLeHGI0gzahu346PZV18vDTFTab48T4+84RpYP65rzD5/FU6z99k/a/9VVTmIMwQSYdg1hCy9e5paWlpaXkytILnKUalKYMf+D6y9z/H/m/9Nov1EfVL34i5WFWFALqUBGXIejnd584hXKDe3cHkKflHvxP5nc8Q0gqbGIbfOMDfnlDvj3H7BxyMZ5S39sn391CTCRQFsrOG2VxHaUXlAm42hSxFKIFfLqCosQW4YoFINF7U1MX/IHnmHL339xG5x4V1jExawdPS0tLS8sRoBc9TjhCC9PRJtv6v/yfK6zeZ/8mfcvCfP4N/5TKEQI4n7ziSD5xHr6/h7uzE0E+dkJzfJnn/OfA19ZWbVH/y57hbu+iT21Sb21y9M4XxgvVEMRj18FmCOXcGMxz8/9u78yC5rvrQ49+79zrdsy8aaTRaPLKx8CZjyQuyDdgyiwEnXpIqYyeECglO2KqCi4SySRWFodgqELaEJ8KDCrxgweM9eDEm3gjGRrZlW9a+jzT72vvdz/ujLSHZ2tFoGf0+VV013X1u63f6zNz707lnAcMATSMulwlrbn2KfLF8IC7lqvru6wSossv4/1xD5cJu3DdfSNCToEmPaJdp7EIIIU4TSXhmCSOZJLWwF7u5iWBggNLQaH1sj66B7UCtivKS6LZFrBtolkHt5ZdR7gRGUwfRriGCwRHCiSmiaoWhRI7dHd2Yhk5zUMT3CviGQzSnhdZrryOeKlF64inKL7xMPDlVX505jg8fXBThDY1TLdeolAPsm3PYl8yn7dXNUIUQQoiZJiNHZxkznyN95eX1WVyJRD3ZUTHh8Bjh4ChGawvOwvlgGARjE7hb91J8fhNbdo7Rb6bxYwU1D3NslLwKydfKZFIOGAZasQR7h3C37kQLAxKLFmBkU6goBsME/fBr8CggVorYDVEjJdTgFDndkmRHCCHEaSM9PLNQomcumeXLcLduJyyVCKeLKBWBqZO8qA/l+4QTUxBDVAyZnBygGGh4yTTZji7swb1k9u6hvVwmbZskOlux58zBNywSuTxqbILQD9CTSYzGRrTUOErXIPTB0upT14Pf9/Zorz5M36VhYpKGwUmSu4dhadOBMiqOiWsuumPLTuxCCCFOObmyzEL23G5yN78Fp2cu7vad1LbuICqVUK6Lv2sP9rx52HM6IIzRMinsyhaStRqW04ClWagwwipM0VycBsMiNKHxrW8mahlFqRil60Sui/K9V2dqBVAqg6kBCkz9kIQH6r9oMWBWKri/eYaJiUn0VJLkwl4A/D17CUZGMXIN2HO76wssJmX9HiGEEKeGJDyzkKZpJHrmYre3oadTKKWovrKRqFCk/MomEqUSKI3EhX34I8OYA4M0uz5O3iFlmni6hoo1CGMgIpwqUHv+JaLJaeIoQoUhVkcreiqNbltopoFSMbhxfczQQZuIKh2ihIHmRxgh9XE+hSK159YxlkzQ/r4/QSmFPzQIKiAarhFOTaNZFlHvXKx8AynTOWPfpRBCiNlBEp5ZTE84ZN50BUZjHn9oGHdiimjnbtT4JCQSeINDRJNTMD1NMgzR+vcRtDUT9TQTE2EMl9BKNULXxe3fC35AVCiCphOXKyQu6iNx8YX4XoA/XQTfqyc7B3XuhJ0ZYtNEq/poU1W0/TuwRxG1lzYw9K3/QaK7A/I6ZlsWq6GDuOJT8mtMTA/jmAHd6SYylvT2CCGEOHmS8Mxyum2TWnIB9vx5+P0DFP0qoV8mMTVOYodfH7ZuOWDoKC8gjAPiRa2QtCE7Cev70QwdDR2jdx614SEYGMEYGanfokomCfcNgGMTGAaBppGKQ7D0+q2txgaUSb3np+jVV4FG1QdTxyHelm14e/diL2jFmmyEHoXZeQEFt8hk5JL1XcJkdGa/RCGEEOc8SXjOA5phkLn4DVT37qMyNQxVj1ApzJpPsaUBP5OkMd1AquSD7aArC6utG1XUiBum0TQdPZmg0t1OsS2L4VZJj0wRDw5R9n2oVogMm1K6gZJh0+mVSZtA2ibV3IYxv4ewfxgV7UVLJNHTSTAM/B276mOAPJ9gl0IVawQ7x4iT24jaGjAXdRMsSWDkdeLqOPgFcBrRk03HrLMQQghxMEl4zhPpy99Is6FTeu4Zqrt2oZeqBI5FqTFDbOrolRKOp5FunIeVaUc3crjeEH46Ba5LODZG+cUa1YYU6YQNiQTKLxAGPsoyiA2dWiZLIddCtjpNrqMRJ+mQuvQizHwzlXA9bi1E+QF60gEvQG9oIA7j+hQuTxGPlokqVfA97GQSZ3iEoH+IPQv6mdeZxZiawmhtxel7E5ouv7pCCCGOn1w1zhO645Bbdhl9i+ZTeGUD0z/4MVFxH3bNJ0iYOIUylD0wLyQxr4e4WkVXYGQzxJZFWHFJjU9gNGZJtXfgNJrUoL4+TxiS8UKMyCfwXUbTDRQ9nYVtjSTKPr5eZnTPMF41IGuCU64SFYromTR6Yx4tCNEMjahQgvGJ+v5cfoizfS+UavhD41Qv6sXRFFoxwmwbRbcVmpNDszNn+qsVQghxDpCE5zyi6TrJpmb0nl6sP3o3Uz/9Ba07dxKZBrYXgGWjKQVRhNnUSPKiPox9g0S1GtWNW6BYJhlEJBf1YXU3oG3XwfNQo5MQhCRjhdPQzIgy8Cse+wbGSJRLuFMFxqarEIVQqGIZMZGKKdcqRJFBg25hxCZRsQyaRgCAwqjUcCYmSVR9PFfhpxwSi22ikW3oLQ2oyAUrJTuvCyGEOCZJeM5DVmcHWcsiubCXgc99pb7vFoBtE1UqVF56heTFF6InHKJKjdq27QTjY4SA4cYkJydJXLoUp6MN///8P4IwAhSaYdDV006wb4yKbaNsh6hQIJyYJCx6GKUiVq1IoENgO/i2jq4p3FCR8COII1RUH6CsFNhhhFX1ISgRhDF6Kol+0YWgmaDpoNd3fxdCCCGORRKe85BuW9hdHdhA+1/cw9BXvgHFIhga/r4BooYiWjqJput4e3YTlyuU0w6upeN4AWzfjtHSjNXSip5IQjYDQUDi4iU0vGExfr6ZPVPjxLGPN17AU5AIali+ixGFEAFhhB3qxIaO7oV4GASagbIcMo6BFkfg+VCtgp0gsh2sdAq7Zx7WvMVopgIrDShU6IJuox1pawulIKzWn5gp2dJCCCHOQ5LwnOfSF/WRu+YqSr/5HbHvEZUroDSqm7ahqhWiyWki22RyfhvlpEl6soxV9Kn095N2PYyEQ2LJYuw5nTTddivx+CTmxDS5lE9y3xB6eZpEOSAKQjRLR9MdiGKsKEL3IpStYegGw8kGAjSUZpChUp8ur+L6mj5xjJnNkLx0Kc68bjQ7iQoC4nIRXS9BVAanATJzDn97yy+iSgMAaNk54ORO63cshBDizJOE5zxnZDLk334TCg1/Tz9xuUIchoSDw/XeFRTKTGPl81gZByOChKVjdXVgJFNgGoSVCkYqCa6Hlk7RGPloyseoltE9D0pVMij0TIZE31LC4SHCmodl6GDZKOq3yioKmkvTaEEAcQAHFikMMbNZNE3D27qDqL2IqrnEpSJ2Y4DVloegAnEIhv36SsYhxP7vfxZCCHHekYRHkOjtofV9dxEMDlPdspXpXzxa3wg0jkDXMf2A1rEiLaluEp295JpayK+4Cm9ggMqzzxMNjRK4HtXWTRCG6BPT5GMbbeESfGsU192F7nkYCRujMU88OoaV1HAWLSCuVAnHJ2ivTJGbLqG77usDjGK8iQm0XbtRhk4ykcDfN4Dfv49kbzNWaxskmkC3Dl9BuwFSbb//WQghxHlHEh4BgJnNYPYtQkUB5YYscbFEbNugG2iWSTbUSFoZ0iuW4XR34+3YRfWFl/F27CIslNAcG80wiIMAPZXEbp2Lns1gNY6hgpCoWMRsa0ULQ7R0EhTErk9UKBKVK6hSBefgZMeyAFXfeR1Q4yPUitMEQ8MYySTulq24u/rx9mbQGjppuP5CiCI4zE7rmmGhZbqOWPc4COurSesy20sIIWYrSXjEIezOTjJXLcNt3Q2GQTgySlAsEhZLVDZsREul8Pfsxd25i2BgmLhURrctjGQCFUWY7W0kLlhENFXA27MHFYRkl11GMDmNu3s34dAwmmNjNDUS7tlHMDEFmgbZbH2QchjW9+PKvfrcisD3CfyQimOhTY3jP/y/MWwHNTFJVCxRXvsCVksLKvAxO9pwujqPWU8VhsSejztdobhlH0Y6QfOlCzGcw9wSE0IIcc6ThEccwmzM03jLW4k8n+J/PUV1eprY81EjY8QopienSC3pQ08lsRrz6AkHPZHAcBzCqSnM5iastjZUzcXM51Geh7N4MebIMO6ePQRjE/XyuQaiQgFVLIBtY/V0E2oaamoabAsMEy2bwEgnCUfHCUMXL2njpRNYA5Okqj5YFgpwN25m0vex53VjT0xit7ehGYefsQWgggB3207CYpHBwRIjEy75tEO2t4NkmyQ8QggxG0nCI15HT6XQUymM5kbMfA729NdnTIUhVKsEkxNkei7FbmslrlYIi6V6L43nE05NUdu4GaIIu6cbVanh9+8hLFew2tqIC0V020YLI/TGPLHnoQGaH6AByjQgjjHSSaymJhJLFlHbuIXqjh3YVR/TCzG9VwcgqxhUROj5hJu24A8OY7W1YLa2kLqoj2BiktrLr6A5SdJXXIKZra/KHJUr1DZtwS9XKAYaqlLD9WPGhtrJZ5I0pGRndiGEmG0k4RFHlLpgEVrgg2lQeuZ5VKkEYUgwOk5YLJJccgF6MoGWTBHXaoSFAsHIGIE3gGaZqCikumU7/uZt6OkUzkUX4HR3EU8VMLvayaSSlF94iWBwBD2XJax58OpaOrphkuxbRPa6azDyedzN27Gq9bV0DgxN1g3I5tEtHVwPVSoTJhOM/6+fYqRTxNUq/uAgOhrutu3kbr4RAHfrdoLxcbBsssQkK4NM+rDh6XVkJsu88Yo3kGvInoFvXAghxEyRhEcckT2nE7OpkdTVyzFbW5n8rydhdz+445R+81vSl1xCYmEvse9S/t064mIJPZ2BKEZPWVQ3bMbbN0BcqYBpoWJF+tKlaI6N1daGkUxgz5tL6ddPUyuWSTY2Eu7cRVSqoNsWkedTefkV3J270cKA183B0jW0hIWVzxN7PpqKiQslwoEt9W0sXl2TJzYMys8+h79vgFrgUkjZJJ0EHRdfQmscURzdR3G6hF7Yhl+ZppQOaFh29REXMhRCCHHukYRHHJWeTKADySUXYDzyGNH+N6YKlJ/5HYneuahyFX9wmHBsHHuOgdnRQTQ9TVQoogA9l0PPZYhLJcrPPk/ygoWvDjIOMDIZRrt7GStWaNYVbdks/s6d+EMjhGufR7NsYs+FIETBq/tsga0BukJNTOJ7AbphYM/pxC/uhWB/qai+gGE2QRhVCTdspGzqeK0N+Avn05JO0NA9l3Bsgub+tSTdKayUIludBhUCkvAIIcRsIQmPOC56Kond3UVtdLQ+Vdw0CUZGqKx7ud7TomkoTRGMjtanpgMqjtGDAM2y0U2rfgsqDFFRRFQo4I6Oo1CUW9oIWkymalVaUjbm5CTe4AhUKihVIY7qe3X5gKtbaLrCSGhYOYc4naLqKexqFdW/Fz2VIk4moPbqFPekjdacRNMgLoZY5QjDMDCdMdypX+NVq5BIYlsmRjXGjkOMVCPunmGiYpHEgh7MBlm7RwghznWS8IjjkujtofHdb8fqbMMbGIEoxG5vJa5VMbIZlK6DFxCMTxOWqjhdHVhNTYRo+KMjRJ5H9oKFOD3dOHO7iWsu4fgEwcQELU1taHN6yMYaxrZhfNdDT9ioOIFm2eB6xLUafqRR000cE1STjdVoMpaxmS7pJIyQ1vECVjpN4rqr8bdtJ5yYBN+DgksMEMU4homezaEHEGzbQVx1wbIwG3NopoWWyuPuHid4ZgPR1CTJC5fQ+J53oNsye0sIIc5lkvCI46LbNtkrLyd75eVEQUCwp5/IdVE1F+X5pN7Qx3T/PsKJCbRyCWfJIqz5PUQbfdS+iLhapfrcOoLhESprX8RoyKJQRKNjNBkm7XPbIaxRGh1F+R68Os7H6WjH37ePmopJ1DxqsU4YRyg3xNtXRY9L5DQdXSmimos2sBcsAxI2mBYEAaroATrkGrDyeZy5c4ktnerIGKDQEg5aPoeWdDCbGtESNnGlTDA5jdqyhczYVThzjrxwoRBCiLOfJDzihBmWhbFoIQBxtUrs+cRRRPHRJ+sJRhhSeeY5KmtfgKA+3Tz2Q7yBQbx9Q+gJG2tOJ07PXMzmJoKJSeINm1HlCkopgslJoqkCaqqAiiOoeZjJJFoqSX58mij08Usalh/gKEWkgxGDGQOBT7hxK5gG2Dak0+imiZZKYbU0YRgmmq5hOgnSlywlHB9F6SZaGBJPedDaQuqNF6NcD29XP+HEFNX1m7C7OmWXdSGEOIdJwiP+IPvX7FFxTPqKy/D37iP2fdTYeH2sj65BvhEjYYOCqOYSBx7adBqrtVZfYVnXicoltDBGy+dh1x60WKH8gGhyirhYQvkByrGxw4AaCt0wwHKwXBcrPkxgYQRGiNXVRWrphVjNzYQjI4STBYhj7LYW9MULiUslajv3EA4MoscRYaQYLlQJExk008QMo/qtsTiGoyxmKIQQ4uw2Y5sH7d69m/e///309vaSTCZZuHAhDzzwAL7vH/W4e++9F03TDnksX758psIUp4im6zS+62aa7ngviUULQNfrSUIYocIAPZfDaMyhJxw00yIcG6eyYSOV8QF8I0BZBnEcE+zaA5FCTydxFs7Ham1Ft2w0DajVQCliW0epiMB1UfsDMLT6Yz9dA9simJjE276DYHKSzIo3kVi8AKOhASObJbl4IYmeeaT6FmPN6cJsbaXQ2Mqm4QLbp12q+ab6IoYX9h115WYhhBBnvxnr4dm8eTNxHPOtb32LRYsW8corr/CBD3yASqXCF77whaMeu2rVKlavXn3guS0DRs8JRipJ03vegd6YJxwbJ9w3WE96XBctmyExbx7B0DDetu3ErkdU1ohqJSJLEU8XcMeqjE2UsMOYtgU9tN59J7VXNuFmUgRj47gDQ8Q1F4II3a9PPVeABuA4kEpBpYzyQjQUlKpQquKOjBIOj+F0dmB3zyEsFAhHx4h75pFYshizuQkjm8YbGEIVywTxKJahk7x0KZmWPJpj1Vdx7myX21pCCHGOmrGEZ9WqVaxaterA8wULFrBlyxa+8Y1vHDPhcRyHjo6OmQpNzCBN00guXkBq2WUUy1WYngbPw9+6HbMhA4sXUdVMjOFhLFtHb8gST0wTTrtMTdYY1y20dJ7cBUtIzp+HYdvYLU3Enk/p2eeovvAydrEAr97GOtBFmUyCphMEYT3J4qAVmcOQcHISd+cuEvNCVKmEampChfV1gFQUw+5+gn2DZKZL9HYGpC++kI6F3aiJKaLxSeJKFTPfgJZKnd4vVAghxClxWsfwFAoFmpqajlnuiSeeoK2tjXw+z8qVK/nMZz5DW1vbYct6nofneQeeF4vFUxavODlORzstt78HbJPi//5PcGtQKOK+tJHYh8krV2BMT9NhhGSmx/GUS+yWScQR6QhCU8MxdGLXw2jMY3oeeiqJ0ZhHBQH6jl2Ek5NQrm81gaFjNGSJikVUGHPYPhjPIw4jNE0HBcpzD7xl5hpwFszH37sPDIM2Q5EIXIwoRmUzhK5b30LDet1az0IIIc4Rpy3h2bFjB1/96lf54he/eNRyt9xyC7fffjs9PT3s2rWLT33qU9x44408//zzOI7zuvKf/exn+fSnPz1TYYuToBkGVmsL+be9FXfTVvxtu8D3iUsl2LaFxiDAzGZINjag20nMXA5yOXJDw5jDY+iVaZyxEdztO9FsC39wCAA9maLhhuvQVr2N6V89RvXp30EYojXmsZpb0JqSkAxRw2XC8LVBacTlMiqbxu6dj55JYxzUW+N0d8G1K6hs2IS77iVK/z1CMD5O7ua3oCcS6KmkJDxCCHEO05RS6tjFfu/BBx88ZoKxdu1ali1bduD54OAgK1euZOXKlfzrv/7rCQU4NDRET08PP/zhD7ntttte9/7henjmzp1LoVCgQVbIPaPiOKb63DrKa5/HHRjC3zeIqlQgijGamrDndqFn0sSlMloqheHYROOTKBTJxYtIXnwhYbGIv3MPsQK7rRWzMUfyoj7KzzzH9K8exx8ZI7Ggh6i7GyOeJN6xnWD3GKr42oyH+jT11ibSFy4h2bcYp7uLRG8PZkszKgxRvk/55Q1M/fyXxOMTJPsWk7n+Wvydu1GaRnb5ldid7af/ixRCiPNAsVgkl8vN2PX7hHt47rvvPu66666jlpk/f/6BnwcHB7nhhhtYsWIF3/72t084wM7OTnp6eti2bdth33cc57A9P+LM03WdzJuuIH3l5YSFAmP/4wdUn19H5PqoMCR2PYKRUeJCET3bQOaaN5HsmYfWkEVvb8bNKFy3ilaYRpUq9VWTbZOoVMaaPxelFJpl4GkWFS2DZfhkmppQI2Uoll4fkO/DwDCVSg1N1zAcB8+ywLKovrie2PPQslnstmYC30fLNRBVyrh79hKMjhFNTZN/1yrs1pbT/2UKIYT4g5xwwtPS0kJLy/Gd8AcGBrjhhhu44oorWL16Nbp+4rPgJyYm2Lt3L52dnSd8rDg7aJqGlc/TfOd7iV2XcLKA1dWOsi2iiQnQdVQcEg4MkrrlZjJvvAhXValWh4nLCXQT9HQKYgV+iLtpM7WBYcLxSVS1ijY8jLrsOip6N+mGFuyRAH/KBT84TDDUPycI0BI2mmNTfuElqi+8RBz4OHM6MTvaCAZH8bZuw2xvJSwU8IeGwdBJbNyMde0KmaYuhBDnmBkbwzM4OMj111/PvHnz+MIXvsDY2NiB9w6egbVkyRI++9nP8t73vpdyucyDDz7IH/3RH9HZ2cnu3bv55Cc/SUtLC+9973tnKlRxmlitLeRXvZVwfAItlab68ivEkQIUsdLwJqcIR0dR8RKYLGJUqySaO9CWBKiRcbR0Bt2x8fv78bfvRFWrgIbVlGfu0nmQbyJV6qIwNERYqRIPj0IY1DctTSfrc9h1HWdeN2ZbG+F0EXd3P8HUNPH0NLHroxsGcRARlYqgGdReXI/yp9F1j2hiDGWa9TWGhBBCnFNmLOH55S9/yfbt29m+fTvd3d2HvHfwsKEtW7ZQKBQAMAyD9evX873vfY/p6Wk6Ozu54YYb+NGPfkQ2m52pUMVpots2yb7FxPO6QdepbdqM5thEvgfDwwQjo0z7AWZnO/HkFGpwkNgPCAaGiApF7K4OrEsvRctm0RwHq70d3bFg0QL6i1V0DNp37iSueRiOQ5ywoehDHILrQSaDPacDe8F83B078X79DHgummViNjfXZ3qVKijAaGhAeS7h9BRxpYBmaOgJA3uObDEhhBDnohlLeO69917uvffeY5Y7OPlJJpM88sgjMxWSOAsY6RRGuj47KnXxhQQDQ/ieRxjFEPr4O3ZT+MWvMByLcGIabBN/YAjlevXtJAKP9KVLUZ6Pn0ljJJMUOucwVgtQURmr7NKUcNCzabRiClWt1beZiGPwXFQYEo5P4PbvhckpCGOUoeNXqpi9PZjpDEbSweqaR1QsEU5PE0yNoAcxKlQEoxMk5s1Fk14eIYQ4p8heWuKMyS67DKuzg9Kza5le839RxRIkHYKJcQKliKs1zIYGjJYm9DgG26H2ymbcgUGCnXuIwxAVRiTcGvmGNP7EJClTR881oE9O1fe+il9NqIMQwohgZJywXIVSBcJXVy+MYihXUJOTGD1z0TWN2sYtxDUPbAsz3wKej2ZYRMMjRIUiZmP+jH1vQgghTpwkPOKM0SyL5Px5OF2d2K1tlH/3HFocE0xNEYyOo1Do2SxmwkFPJHG3bqW2cTMAppNAKYXelCfd2c6FSUVghViOiWeZqDhGiyKUZdYTmjAEpWBiElWpQvCaPd2UIiqUUK5LWK7i7dxdX+MnlyO5pA/lefXeqaYm4lKZOJlET8jsQCGEOFdIwiPOON22yK28mtx1y6ms38j0//l/BJNTqJqHv3kbvqFBOg2lcn1quW4QxgpUTDQW4m7dTvrqN6EphbIMnLndqEqVqFQkrlXBDzlkJcLAB03nwP4UAJYFhoGmIKzVoOaB76M0nWhgEC2VRAFhpUx1wya0rdtJX7oUs6X5dH9dQgghToIkPOKsoBkGGAbO3DkkllyAMg283XuJJiYhiqBYBtMAx64vIBjH4PkQRvgDQ4z/4MdotoXd1kJi0UISl1wMmRSVF9YTTk+jhoZ/f3sriiFh1x+WXb/1FYZoiQRmWzN6JkPQvw8VRxDF+JNTqOFhNEMnVmAmbJSuoaWSZHMNsgKzEEKcAyThEWcVs6WZ/E03krniUib+7yOUh0ehVqu/GUZgU59xFdXH5OApYs/DG5sAw8C1LSr55zBbWzAac+iGhnLd+pT0g6WSGNkMketBpUrgulBzKT+zluzbbsBobCQMA7Ds+sB610fp4A0MQHcXekOWShiTiGJsyXeEEOKsJwmPOKtomobZmMdszNP2F3djtTYz/YtHUJPT9Z4Zz6+PxdE0MEzQ43rPTRTVb1uFIZHnEdVq6GPjaKZZL29b9dthhgkNDZitTfWBzIUCNTdgMpUlUpDfM0z045+hZ7L1f8N3wUnWfw5D4qlpoqxGmAqZfvY5xrG48NrLMWXWlhBCnNUk4RFnLSuTofVPbyd92Rsp/tdTVF58mWhiqt67Y9dXSUbTUH4ANbe+yKBh1G95+QFxEKLbNno6hd7chJZMYM/tRvN9QsuC8UnCqSmCEMp2kpKVwCrFNExMEU9M/T6QIKonPAr02MX0x4n3TpCZ8HBfeInp/EfJzenEzOdkBWYhhDhLnfDmoWe7md58TJwZkedRfPzXlJ5bh+7YmG2tmLaN2dWFbmiUn1uHNzKKbhoQa4TDI0RuDYix5szByjdipBKExRLhyCh6IomWsAkrNapbdzBmJPAMg/ZKgZSKANi/MYVlmvUeIqXQtQCnzUIzoTriQymGdJLkkj4abrqR3I1vloUJhRDiJJx1m4cKcSYYjkP+phtpuOYqlFIYmUy914X6bbD0lZcT7B0kjkLCySlqm7YQDo4Q6xrpxQuJo4jSCy8SD48ShyFGQwQqhT23k6BUoHPPQP2zDvNv+5kG7OYcpmUTlkt4E+P1Xqbqq7O8KjX8/n24m7aQW3kNmPJnJYQQZxs5M4tzhqbrGEfYYsRwHIxFvQCoICB9yVKIY6JqFeX5VDZuJq5UUFGMns1CKk2wb5Bgxy7wvMMmOgCxZuAsfSNNS+ajOxaxH1B98WXcnbtBd8G06z0/TXmSSy6ojxkSQghx1pGzs5h1NMvCeHWquJFJA+Dt6sdpbyewbIymRuJSCbxXd1Q/+K5uvgFSaZgYx4rB7J1PftlFJNrbMFqb0XSDhuuWE01OY7S1gucRjE9htTZid3WdieoKIYQ4DpLwiPNCaumFaKZOHAbgh3j9e4lrLsHUNLoCLZXEmTeH/LvfSVwoUF23Hj3fQHbZpWh2Aqu5EbOp8fcf2Nl54Eene84ZqJEQQogTIQmPOC+YjXkyy69ExTH+zt2YTY00vPV6lB+iAh+7uwvz1dtlKopIX7IUPeGgO7J9hBBCzAaS8IjzhqbraLqOs2gBRNERV0jWDAMzJzP8hBBiNpGER5x3NF0HWShQCCHOK3LWF0IIIcSsJwmPEEIIIWY9SXiEEEIIMetJwiOEEEKIWU8SHiGEEELMepLwCCGEEGLWk4RHCCGEELOeJDxCCCGEmPUk4RFCCCHErCcJjxBCCCFmPUl4hBBCCDHrScIjhBBCiFlv1m0eqpQCoFgsnuFIhBBCCHG89l+391/HT7VZl/CUSiUA5s6de4YjEUIIIcSJKpVK5HK5U/65mpqpVOoMieOYwcFBstksmqadss8tFovMnTuXvXv30tDQcMo+92wkdZ2dpK6zk9R1djof69rf34+maXR1daHrp37Ezazr4dF1ne7u7hn7/IaGhln/y7ef1HV2krrOTlLX2el8qmsul5vRusqgZSGEEELMepLwCCGEEGLWk4TnODmOwwMPPIDjOGc6lBkndZ2dpK6zk9R1dpK6nnqzbtCyEEIIIcRrSQ+PEEIIIWY9SXiEEEIIMetJwiOEEEKIWU8SHiGEEELMepLwHMX8+fPRNO2Qx/3333/UY5RSPPjgg3R1dZFMJrn++uvZsGHDaYr4xO3evZv3v//99Pb2kkwmWbhwIQ888AC+7x/1uHvvvfd1383y5ctPU9Qn5utf/zq9vb0kEgmuuOIKfv3rXx+1/JNPPskVV1xBIpFgwYIFfPOb3zxNkZ68z372s1x55ZVks1na2tp4z3vew5YtW456zBNPPPG6NtQ0jc2bN5+mqE/Ogw8++LqYOzo6jnrMudimcPhzkKZpfOhDHzps+XOpTZ966ine9a530dXVhaZp/PSnPz3k/ZM9lz788MNcdNFFOI7DRRddxE9+8pMZqsHxO1pdgyDgE5/4BEuXLiWdTtPV1cX73vc+BgcHj/qZ3/3udw/b1q7rznBtju5Y7Xqy145T0a6S8BzDP/7jPzI0NHTg8Q//8A9HLf/5z3+eL33pS3zta19j7dq1dHR08La3ve3AHl9nm82bNxPHMd/61rfYsGEDX/7yl/nmN7/JJz/5yWMeu2rVqkO+m1/84henIeIT86Mf/YiPfOQj/P3f/z3r1q3juuuu45ZbbqG/v/+w5Xft2sXb3/52rrvuOtatW8cnP/lJ/vZv/5aHH374NEd+Yp588kk+9KEP8cwzz/Doo48ShiE33XQTlUrlmMdu2bLlkHZcvHjxaYj4D/OGN7zhkJjXr19/xLLnapsCrF279pB6PvroowDcfvvtRz3uXGjTSqXCJZdcwte+9rXDvn8y59Lf/va33Hnnndx999289NJL3H333dxxxx08++yzM1WN43K0ularVV544QU+9alP8cILL7BmzRq2bt3KrbfeeszPbWhoOKSdh4aGSCQSM1GF43asdoUTv3acsnZV4oh6enrUl7/85eMuH8ex6ujoUA899NCB11zXVblcTn3zm9+cgQhnxuc//3nV29t71DL33HOPeve73316AvoDvOlNb1If/OAHD3ltyZIl6v777z9s+b/7u79TS5YsOeS1v/zLv1TLly+fsRhnwujoqALUk08+ecQyjz/+uALU1NTU6QvsFHjggQfUJZdcctzlZ0ubKqXUhz/8YbVw4UIVx/Fh3z9X2xRQP/nJTw48P9lz6R133KFWrVp1yGs333yzuuuuu055zCfrtXU9nN/97ncKUHv27DlimdWrV6tcLndqgzvFDlfXk7l2nKp2lR6eY/jc5z5Hc3Mzl156KZ/5zGeOeqtn165dDA8Pc9NNNx14zXEcVq5cydNPP306wj0lCoUCTU1Nxyz3xBNP0NbWxgUXXMAHPvABRkdHT0N0x8/3fZ5//vlD2gPgpptuOmJ7/Pa3v31d+ZtvvpnnnnuOIAhmLNZTrVAoABxXO1522WV0dnbylre8hccff3ymQzsltm3bRldXF729vdx1113s3LnziGVnS5v6vs/3v/99/vzP//yYGyOfi216sJM9lx6prc+l8y/U/341TSOfzx+1XLlcpqenh+7ubt75zneybt260xPgH+hErx2nql0l4TmKD3/4w/zwhz/k8ccf57777uMrX/kKf/3Xf33E8sPDwwC0t7cf8np7e/uB9852O3bs4Ktf/Sof/OAHj1rulltu4Qc/+AGPPfYYX/ziF1m7di033ngjnuedpkiPbXx8nCiKTqg9hoeHD1s+DEPGx8dnLNZTSSnFxz72Ma699louvvjiI5br7Ozk29/+Ng8//DBr1qyhr6+Pt7zlLTz11FOnMdoTd9VVV/G9732PRx55hH/5l39heHiYq6++momJicOWnw1tCvDTn/6U6elp7r333iOWOVfb9LVO9lx6pLY+V86/AK7rcv/99/Onf/qnR91Ic8mSJXz3u9/lZz/7Gf/+7/9OIpHgmmuuYdu2bacx2hN3MteOU9Wus2639GN58MEH+fSnP33UMmvXrmXZsmV89KMfPfDaG9/4RhobG/njP/7jA70+R/La/30ppY75P7JT7UTqud/g4CCrVq3i9ttv5y/+4i+Oeuydd9554OeLL76YZcuW0dPTw89//nNuu+22Pyz4U+xE2+Nw5Q/3+tnqvvvu4+WXX+a///u/j1qur6+Pvr6+A89XrFjB3r17+cIXvsCb3/zmmQ7zpN1yyy0Hfl66dCkrVqxg4cKF/Nu//Rsf+9jHDnvMud6mAN/5zne45ZZb6OrqOmKZc7VNj+RkzqVnw/n3ZAVBwF133UUcx3z9618/atnly5cfMtj3mmuu4fLLL+erX/0q//RP/zTToZ60k712nIp2Pe8Snvvuu4+77rrrqGXmz59/2Nf3/3Jt3779sAnP/pkiw8PDdHZ2Hnh9dHT0ddnpTDvReg4ODnLDDTewYsUKvv3tb5/wv9fZ2UlPT89Z9b+LlpYWDMN43f8CjtYeHR0dhy1vmuZRk9yzxd/8zd/ws5/9jKeeeoru7u4TPn758uV8//vfn4HIZk46nWbp0qVH/N0719sUYM+ePfzqV79izZo1J3zsudimJ3suPVJbn+7z78kIgoA77riDXbt28dhjjx21d+dwdF3nyiuvPKvOwcfjeK4dp6pdz7tbWi0tLSxZsuSojyONct9/f/TgP8CD9fb20tHRcWAmBdTvuz/55JNcffXVp74yR3Ei9RwYGOD666/n8ssvZ/Xq1ej6if9aTExMsHfv3iN+N2eCbdtcccUVh7QHwKOPPnrE9lixYsXryv/yl79k2bJlWJY1Y7H+oZRS3HfffaxZs4bHHnuM3t7ek/qcdevWnVVteDw8z2PTpk1HjPtcbdODrV69mra2Nt7xjnec8LHnYpue7Ln0SG19us+/J2p/srNt2zZ+9atfnVQirpTixRdfPOfa+niuHaesXU9oiPN55Omnn1Zf+tKX1Lp169TOnTvVj370I9XV1aVuvfXWQ8r19fWpNWvWHHj+0EMPqVwup9asWaPWr1+v/uRP/kR1dnaqYrF4uqtwXAYGBtSiRYvUjTfeqPbt26eGhoYOPA52cD1LpZL6+Mc/rp5++mm1a9cu9fjjj6sVK1aoOXPmnHX1/OEPf6gsy1Lf+c531MaNG9VHPvIRlU6n1e7du5VSSt1///3q7rvvPlB+586dKpVKqY9+9KNq48aN6jvf+Y6yLEv9+Mc/PlNVOC5/9Vd/pXK5nHriiScOacNqtXqgzGvr+uUvf1n95Cc/UVu3blWvvPKKuv/++xWgHn744TNRheP28Y9/XD3xxBNq586d6plnnlHvfOc7VTabnXVtul8URWrevHnqE5/4xOveO5fbtFQqqXXr1ql169Yp4MD5dv/MpOM5l959992HzLj8zW9+owzDUA899JDatGmTeuihh5RpmuqZZ5457fU72NHqGgSBuvXWW1V3d7d68cUXD/n79TzvwGe8tq4PPvig+s///E+1Y8cOtW7dOvVnf/ZnyjRN9eyzz56JKh5wtLoe77VjptpVEp4jeP7559VVV12lcrmcSiQSqq+vTz3wwAOqUqkcUg5Qq1evPvA8jmP1wAMPqI6ODuU4jnrzm9+s1q9ff5qjP36rV69WwGEfBzu4ntVqVd10002qtbVVWZal5s2bp+655x7V399/BmpwbP/8z/+senp6lG3b6vLLLz9kqvY999yjVq5ceUj5J554Ql122WXKtm01f/589Y1vfOM0R3zijtSGB/9uvraun/vc59TChQtVIpFQjY2N6tprr1U///nPT3/wJ+jOO+9UnZ2dyrIs1dXVpW677Ta1YcOGA+/Pljbd75FHHlGA2rJly+veO5fbdP8U+tc+7rnnHqXU8Z1LV65ceaD8fv/xH/+h+vr6lGVZasmSJWdFsne0uu7ateuIf7+PP/74gc94bV0/8pGPqHnz5inbtlVra6u66aab1NNPP336K/caR6vr8V47ZqpdNaVeHb0nhBBCCDFLnXdjeIQQQghx/pGERwghhBCzniQ8QgghhJj1JOERQgghxKwnCY8QQgghZj1JeIQQQggx60nCI4QQQohZTxIeIYQQQsx6kvAIIYQQYtaThEcIIYQQs54kPEIIIYSY9SThEUIIIcSs9/8BAH8QdHGrNI0AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(emb_x1[:,0], emb_x1[:,1], c=y1, cmap='Spectral', s=2, alpha=0.2)" + ] + }, + { + "cell_type": "markdown", + "id": "d6dd112b-368a-4a9a-a4e9-de20db2c1acf", + "metadata": {}, + "source": [ + "UMAP is built to be compatible with ``scikit-learn``, so passing new data through is as simple as using the ``transform`` method and passing through the new data to transform. We'll pass through ``x2``, which contains unseen examples of the original classes, and also samples from our holdout class, ``N``.\n", + "\n", + "To make samples from ``N`` Stand out more, we'll over-plot them in black." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e23da71e-7698-4a6c-9153-2c30512723ab", + "metadata": {}, + "outputs": [], + "source": [ + "emb_x2 = embedder.transform(x2)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "98eeb71e-4cf6-4e05-b1b8-5d716ce4e0c2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(emb_x2[:,0], emb_x2[:,1], c=y2, cmap='Spectral', s=2, alpha=0.2)\n", + "plt.scatter(emb_x2[y2==N][:,0], emb_x2[y2==N][:,1], c='k', s=2, alpha=0.5)" + ] + }, + { + "cell_type": "markdown", + "id": "507613c3-d69e-40e6-a262-bdc3b08fdb01", + "metadata": {}, + "source": [ + "While our ``UMAP`` embedder has correctly handled the classes present in ``x1`` it has treated examples from class ``N`` poorly. Many of these points are concentrated on top of existing classes, with some spread out between them. This inability to generalize may or may not be an issue, depending on your use case. Parametric UMAP can provide a solution to this through updating the parametric model weights.\n", + "\n", + "We will start adressing this by training a ``ParametricUMAP`` embedding model." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4c11fc5b-80cb-4af0-93dd-16e89f19e9a1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jacob.golding1/anaconda3/lib/python3.12/site-packages/keras/src/layers/layer.py:391: UserWarning: `build()` was called on layer 'umap_model', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m3507/3507\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m154s\u001b[0m 38ms/step - loss: 0.2557\n", + "Epoch 2/10\n", + "\u001b[1m3507/3507\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m127s\u001b[0m 36ms/step - loss: 0.2014\n", + "Epoch 3/10\n", + "\u001b[1m3507/3507\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m126s\u001b[0m 36ms/step - loss: 0.1953\n", + "Epoch 4/10\n", + "\u001b[1m3507/3507\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m125s\u001b[0m 36ms/step - loss: 0.1926\n", + "Epoch 5/10\n", + "\u001b[1m3507/3507\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m125s\u001b[0m 36ms/step - loss: 0.1908\n", + "Epoch 6/10\n", + "\u001b[1m3507/3507\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m125s\u001b[0m 36ms/step - loss: 0.1893\n", + "Epoch 7/10\n", + "\u001b[1m3507/3507\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m124s\u001b[0m 35ms/step - loss: 0.1880\n", + "Epoch 8/10\n", + "\u001b[1m3507/3507\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m124s\u001b[0m 35ms/step - loss: 0.1868\n", + "Epoch 9/10\n", + "\u001b[1m3507/3507\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m126s\u001b[0m 36ms/step - loss: 0.1861\n", + "Epoch 10/10\n", + "\u001b[1m3507/3507\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m124s\u001b[0m 35ms/step - loss: 0.1855\n" + ] + } + ], + "source": [ + "p_embedder = ParametricUMAP()\n", + "\n", + "p_emb_x1 = p_embedder.fit_transform(x1)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "27a27f33-b3fb-484c-b60e-4acf5c86b078", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(p_emb_x1[:,0], p_emb_x1[:,1], c=y1, cmap='Spectral', s=2, alpha=0.2)" + ] + }, + { + "cell_type": "markdown", + "id": "eee0699b-860e-4cd0-8c2d-28fab6c2b644", + "metadata": {}, + "source": [ + "This gives us our normal UMAP result for MNIST, but with only 9 categories.\n", + "\n", + "Similarly to the ``UMAP`` Model, adding new data here is straightforward, we can use the ``transform`` method. Like last time, we will overplot our samples from class ``N`` in black." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "82252524-1489-4edf-b6a4-7a2c0ff12b42", + "metadata": {}, + "outputs": [], + "source": [ + "p_emb_x2 = p_embedder.transform(x2)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "672c72cb-9a50-4c6f-be34-011e9870aeda", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(p_emb_x2[:,0], p_emb_x2[:,1], c=y2, cmap='Spectral', s=2, alpha=0.2)\n", + "plt.scatter(p_emb_x2[y2==N][:,0], p_emb_x2[y2==N][:,1], c='k', s=2, alpha=0.5)" + ] + }, + { + "cell_type": "markdown", + "id": "2ccde3e1-5982-4b16-9747-4f2b82b6113c", + "metadata": {}, + "source": [ + "As with our ``UMAP`` model, the original classes present in ``x1`` have been treated reasonably, but our holdout class ``N`` has been embedded on top of existing classes.\n", + "\n", + "In order to update our embedding to include the new class, we'll fine-tune our existing ``ParametricUMAP`` model. Doing this without any other changes will start from where we left off, but our embedding space's structure may drift and change. This is because our UMAP loss function is invariant to scaling, translation, and rotation, as it is only concerned with the relative positions and distances between points. \n", + "\n", + "In order to keep our embedding space more consistent, we'll use the landmarks option for ``ParametricUMAP``. We'll retrain the model on the ``x2`` partition, along with some points chosen as landmarks from ``x1``. We'll choose 1% of the samples in ``x1`` to be included, along with their current position in the embedding space.\n", + "\n", + "The default ``landmark_loss_fn`` is the euclidean distance between the point's original position and it's current one. The only change we'll make is to set ``landmark_loss_weight=0.01``. We can tune this number by looking at the training history, which we'll take a look at later on." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "4cd198f6-7363-4dbf-af96-d7ded721afef", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "\u001b[1m3923/3923\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m184s\u001b[0m 40ms/step - loss: 0.2113\n", + "Epoch 2/10\n", + "\u001b[1m3923/3923\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m138s\u001b[0m 35ms/step - loss: 0.1956\n", + "Epoch 3/10\n", + "\u001b[1m3923/3923\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m137s\u001b[0m 35ms/step - loss: 0.1938\n", + "Epoch 4/10\n", + "\u001b[1m3923/3923\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m137s\u001b[0m 35ms/step - loss: 0.1923\n", + "Epoch 5/10\n", + "\u001b[1m3923/3923\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m138s\u001b[0m 35ms/step - loss: 0.1914\n", + "Epoch 6/10\n", + "\u001b[1m3923/3923\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m136s\u001b[0m 35ms/step - loss: 0.1907\n", + "Epoch 7/10\n", + "\u001b[1m3923/3923\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m137s\u001b[0m 35ms/step - loss: 0.1904\n", + "Epoch 8/10\n", + "\u001b[1m3923/3923\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m138s\u001b[0m 35ms/step - loss: 0.1901\n", + "Epoch 9/10\n", + "\u001b[1m3923/3923\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m138s\u001b[0m 35ms/step - loss: 0.1900\n", + "Epoch 10/10\n", + "\u001b[1m3923/3923\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m139s\u001b[0m 35ms/step - loss: 0.1902\n" + ] + } + ], + "source": [ + "# Select landmarks indexes from x1.\n", + "#\n", + "landmark_idx = list(np.random.choice(range(x1.shape[0]), int(x1.shape[0]/100), replace=False))\n", + "\n", + "# Add the landmark points to x2 for training.\n", + "#\n", + "x2_lmk = np.concatenate((x2, x1[landmark_idx]))\n", + "y2_lmk = np.concatenate((y2, y1[landmark_idx]))\n", + "\n", + "# Make our landmarks vector, which is nan where we have no landmark information.\n", + "#\n", + "landmarks = np.stack(\n", + " [np.array([np.nan, np.nan])]*x2.shape[0] + list(\n", + " p_embedder.transform(\n", + " x1[landmark_idx]\n", + " )\n", + " )\n", + ")\n", + "\n", + "# Set landmark loss weight and continue training our Parametric UMAP model.\n", + "#\n", + "p_embedder.landmark_loss_weight = 0.01\n", + "p_embedder.fit(x2_lmk, landmark_positions=landmarks)\n", + "\n", + "p_emb2_x2 = p_embedder.transform(x2)\n", + "\n", + "# How does x1 look when embedded in the space retrained on x2 and landmarks?\n", + "#\n", + "p_emb2_x1 = p_embedder.transform(x1)" + ] + }, + { + "cell_type": "markdown", + "id": "5aa1f003-16cd-4561-9989-191c09fcae17", + "metadata": {}, + "source": [ + "We now plot the different embeddings to see how well our additional training has worked. We can see here the value of this approach, our embedding space is consistent with the initial embedding, but our cluster of ``N`` samples is now neatly clustered in an appropriate part of the space, as opposed to being distributed unhelpfully on top of existing clusters." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "145dded0-e933-41e7-a200-73ad334a5472", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(3, 2, figsize=(12, 18), sharex=True, sharey=True)\n", + "\n", + "axs[0,0].scatter(\n", + " emb_x1[:, 0], emb_x1[:, 1], c=y1, cmap='Spectral', s=2, alpha=0.2,\n", + ")\n", + "axs[0,0].set_ylabel('UMAP Embedding', fontsize=20)\n", + "\n", + "axs[0,1].scatter(\n", + " emb_x2[:, 0], emb_x2[:, 1], c=y2, cmap='Spectral', s=2, alpha=0.2,\n", + ")\n", + "axs[0,1].scatter(\n", + " emb_x2[y2==N][:,0], emb_x2[y2==N][:,1], c='k', s=2, alpha=0.5,\n", + ")\n", + "\n", + "axs[1,0].scatter(\n", + " p_emb_x1[:, 0], p_emb_x1[:, 1], c=y1, cmap='Spectral', s=2, alpha=0.2,\n", + ")\n", + "axs[1,0].set_ylabel('Initial P-UMAP Embedding', fontsize=20)\n", + "\n", + "axs[1,1].scatter(\n", + " p_emb_x2[:, 0], p_emb_x2[:, 1], c=y2, cmap='Spectral', s=2, alpha=0.2,\n", + ")\n", + "axs[1,1].scatter(\n", + " p_emb_x2[y2==N][:,0], p_emb_x2[y2==N][:,1], c='k', s=2, alpha=0.5\n", + ")\n", + "\n", + "axs[2,0].scatter(\n", + " p_emb2_x1[:, 0], p_emb2_x1[:, 1], c=y1, cmap='Spectral', s=2, alpha=0.2,\n", + ")\n", + "axs[2,0].set_ylabel('Updated P-UMAP Embedding', fontsize=20)\n", + "axs[2,0].set_xlabel(f'x1, No {N}s', fontsize=20)\n", + "\n", + "axs[2,1].scatter(\n", + " p_emb2_x2[:, 0], p_emb2_x2[:, 1], c=y2, cmap='Spectral', s=2, alpha=0.2,\n", + ")\n", + "axs[2,1].scatter(\n", + " p_emb2_x2[y2==N][:,0], p_emb2_x2[y2==N][:,1], c='k', s=2, alpha=0.5,\n", + ")\n", + "axs[2,1].set_xlabel('x2, All Classes', fontsize=20)\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "91c2559e-c27d-47e7-a8f1-f52533b5f3b2", + "metadata": {}, + "source": [ + "It is worth double checking here that the landmark loss is not too constraining, we still would like a good UMAP structure.\n", + "To do so, we can interrogate the history of our embedder, which will retain the history through our re-training steps. Plotting it, we can identify the spike in loss where we introduce ``x2``, and can confirm that the resulting loss is comparable to the loss from our initial training on ``x1``. This tells us that the model is not having to compromise too much between the UMAP loss and the landmark loss. If this were not the case, it could potentially be improved by lowering the ``landmark_loss_weight`` attribute of our embedder object. There is a tradeoff to be made here between the consistency of the space and minimizing UMAP loss, but the key is we have smooth variation in the embedding space, which will make downstream tasks easier to adjust." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "6cb7eb90-332b-4527-b9a1-b84f7c7e86fa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Epoch')" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAGwCAYAAAC99fF4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABbU0lEQVR4nO3de1xUZf4H8M+ZgZnhOoDcFRCvCJoXNAS1tBQl1zJtRdtF3Z/V2tpuZm5rq5VZu3bTdLd0tS3TNo1Mu+xKEabmBS0jNPOKooIIchOGiwyXOb8/YMZGBuQyM2dm+Lxfr3kFZ86c851G5OPzPOd7BFEURRARERGREZnUBRARERHZIoYkIiIiIhMYkoiIiIhMYEgiIiIiMoEhiYiIiMgEhiQiIiIiExiSiIiIiExwkroAe6XT6XD16lV4eHhAEASpyyEiIqI2EEURFRUVCA4OhkzW+lgRQ1IHXb16FSEhIVKXQURERB2Qm5uLHj16tLoPQ1IHeXh4AGj8n+zp6SlxNURERNQWGo0GISEhht/jrWFI6iD9FJunpydDEhERkZ1py1IZLtwmIiIiMoEhiYiIiMgEhiQiIiIiExiSiIiIiExgSCIiIiIygSGJiIiIyASGJCIiIiITGJKIiIiITGBIIiIiIjKBIYmIiIjIBIYkIiIiIhMYkoiIiIhMYEiyMQ06EfnlN5BbWi11KURERF0aQ5KN+ehoDmJX7sHyL05KXQoREVGXxpBkY4K9XAAAV8trJK6EiIioa2NIsjHB6saQlF9+Q+JKiIiIujaGJBsT5KUCAJRV16G6tl7iaoiIiLouhiQb46lyhrvSCQBwtYxTbkRERFJhSLJBQerG0SROuREREUmHIckGBTUt3s7nSBIREZFkGJJsUHDTSNJVjiQRERFJhiHJBgWpOZJEREQkNYYkG6S/wo0jSURERNJhSLJBN3slcSSJiIhIKgxJNkg/kpRfdgOiKEpcDRERUdfEkGSD9CNJVbUN0NSwoSQREZEUGJJskItCDm9XZwDslURERCQVhiQbxSvciIiIpMWQZKOCeYUbERGRpBiSbJR+JOlqGUMSERGRFBiSbNTNK9w43UZERCQFhiQbpb/CjdNtRERE0mBIslFBTfdvY0NJIiIiaUgektatW4fw8HCoVCpER0fjwIEDLe67c+dOTJgwAX5+fvD09ERsbCxSU1ON9nnnnXcwZswYeHt7w9vbG+PHj8f333/fqfNKIdjrZtdtNpQkIiKyPklDUnJyMhYuXIilS5ciMzMTY8aMQUJCAnJyckzuv3//fkyYMAEpKSnIyMjAuHHjMGXKFGRmZhr22bdvH2bNmoW9e/fi8OHDCA0NRXx8PPLy8jp8XikEeKogCEBtvQ4lVbVSl0NERNTlCKKEwxQxMTEYNmwY1q9fb9g2YMAATJ06FStXrmzTMaKiopCYmIjnn3/e5PMNDQ3w9vbGW2+9hdmzZ5vtvBqNBmq1GuXl5fD09GzTa9prxN92o6hCi/8+MRqDeqgtcg4iIqKupD2/vyUbSaqtrUVGRgbi4+ONtsfHxyM9Pb1Nx9DpdKioqICPj0+L+1RXV6Ours6wT0fPq9VqodFojB6WFqxmryQiIiKpSBaSiouL0dDQgICAAKPtAQEBKCgoaNMxVq1ahaqqKsyYMaPFfZYsWYLu3btj/PjxnTrvypUroVarDY+QkJA21dgZN7tuMyQRERFZm+QLtwVBMPpeFMVm20zZtm0bli9fjuTkZPj7+5vc57XXXsO2bduwc+dOqFSqTp332WefRXl5ueGRm5t72xo765eLt4mIiMi6nKQ6sa+vL+RyebPRm8LCwmajPLdKTk7GvHnzsH37dsMI0a3eeOMN/P3vf8fu3btxxx13dPq8SqUSSqXydm/LrG7emoQhiYiIyNokG0lSKBSIjo5GWlqa0fa0tDTExcW1+Lpt27Zh7ty52Lp1KyZPnmxyn9dffx0vvfQSvvrqKwwfPtws55UCp9uIiIikI9lIEgAsWrQISUlJGD58OGJjY7Fx40bk5ORg/vz5ABqnuPLy8rBlyxYAjQFp9uzZWLt2LUaOHGkYDXJxcYFa3Xj112uvvYbnnnsOW7duRc+ePQ37uLu7w93dvU3ntRX6W5Pw/m1ERETWJ2lISkxMRElJCVasWIH8/HwMHDgQKSkpCAsLAwDk5+cb9S7asGED6uvrsWDBAixYsMCwfc6cOXj//fcBNDaJrK2txUMPPWR0rhdeeAHLly9v03lthf7WJNcqtGjQiZDLbr9Wi4iIiMxD0j5J9swafZIadCL6L/sS9ToRh5+9xzD9RkRERB1jF32S6PbkMgEBnvopNy7eJiIisiaGJBt380a3XJdERERkTQxJNi5I3yuJI0lERERWxZBk43hrEiIiImkwJNk4w3QbR5KIiIisiiHJxhmm2ziSREREZFUMSTaue1NI4q1JiIiIrIshycbpp9uKK7WorddJXA0REVHXwZBk43zcFFA6ySCKwDUNR5OIiIishSHJxgmCYBhN4j3ciIiIrIchyQ7ob0fCNgBERETWw5BkB4K8eGsSIiIia2NIsgPBarYBICIisjaGJDugH0liQ0kiIiLrYUiyA8Fq9koiIiKyNoYkO2AYSeJ0GxERkdUwJNkB/dVtZdV1uFHbIHE1REREXQNDkh3wVDnBTSEHwDYARERE1sKQZAcEQUCw/ka3XLxNRERkFQxJdiLIiw0liYiIrIkhyU4Eq9kGgIiIyJoYkuxEEBtKEhERWRVDkp3QtwHI401uiYiIrIIhyU7cvDUJp9uIiIisgSHJTty8NckNiKIocTVERESOjyHJTuhHkqpqG6CpqZe4GiIiIsfHkGQnXBRyeLk6A+DibSIiImtgSLIjhivc2AaAiIjI4hiS7Ii+VxIbShIREVkeQ5Id4a1JiIiIrIchyY7or3DjSBIREZHlMSTZkWCuSSIiIrIahiQ7EqS/fxtHkoiIiCyOIcmO6NckXS2vYUNJIiIiC2NIsiMBnioIAlBbr0NJVa3U5RARETk0yUPSunXrEB4eDpVKhejoaBw4cKDFfXfu3IkJEybAz88Pnp6eiI2NRWpqqtE+J0+exPTp09GzZ08IgoA1a9Y0O87y5cshCILRIzAw0NxvzewUTjL4uisBcF0SERGRpUkakpKTk7Fw4UIsXboUmZmZGDNmDBISEpCTk2Ny//3792PChAlISUlBRkYGxo0bhylTpiAzM9OwT3V1NXr16oVXXnml1eATFRWF/Px8w+PEiRNmf3+WwF5JRERE1uEk5clXr16NefPm4ZFHHgEArFmzBqmpqVi/fj1WrlzZbP9bR4X+/ve/4/PPP8d///tfDB06FAAwYsQIjBgxAgCwZMmSFs/t5OTUrtEjrVYLrVZr+F6j0bT5teYUpHbB8SvlyC9jSCIiIrIkyUaSamtrkZGRgfj4eKPt8fHxSE9Pb9MxdDodKioq4OPj0+7zZ2VlITg4GOHh4Zg5cyays7Nb3X/lypVQq9WGR0hISLvPaQ76Xkn55ZxuIyIisiTJQlJxcTEaGhoQEBBgtD0gIAAFBQVtOsaqVatQVVWFGTNmtOvcMTEx2LJlC1JTU/HOO++goKAAcXFxKCkpafE1zz77LMrLyw2P3Nzcdp3TXPS9kq4yJBEREVmUpNNtACAIgtH3oig222bKtm3bsHz5cnz++efw9/dv1zkTEhIMXw8aNAixsbHo3bs3Nm/ejEWLFpl8jVKphFKpbNd5LMEwksTpNiIiIouSLCT5+vpCLpc3GzUqLCxsNrp0q+TkZMybNw/bt2/H+PHjO12Lm5sbBg0ahKysrE4fy9IM92/jSBIREZFFSTbdplAoEB0djbS0NKPtaWlpiIuLa/F127Ztw9y5c7F161ZMnjzZLLVotVqcPn0aQUFBZjmeJemn2wo0NWjQsaEkERGRpUg63bZo0SIkJSVh+PDhiI2NxcaNG5GTk4P58+cDaFwHlJeXhy1btgBoDEizZ8/G2rVrMXLkSMMolIuLC9RqNYDGBeGnTp0yfJ2Xl4djx47B3d0dffr0AQAsXrwYU6ZMQWhoKAoLC/Hyyy9Do9Fgzpw51v5f0G5+Hko4yQTU60QUVWgR2NQSgIiIiMxL0j5JiYmJWLNmDVasWIEhQ4Zg//79SElJQVhYGAAgPz/fqGfShg0bUF9fjwULFiAoKMjwePLJJw37XL16FUOHDsXQoUORn5+PN954A0OHDjW0GQCAK1euYNasWejfvz+mTZsGhUKBI0eOGM5ry+QyAQGe7JVERERkaYLIm4B1iEajgVqtRnl5OTw9Pa167ofWp+OHy9fx9sPDMPkO258iJCIishXt+f0t+W1JqP2C9De65RVuREREFsOQZId4axIiIiLLY0iyQ0Fqfa8ktgEgIiKyFIYkOxRk6JXEkSQiIiJLYUiyQ7w1CRERkeUxJNkh/a1Jiiu1qK3XSVwNERGRY2JIskPd3BRQOMkgisA1DUeTiIiILIEhyQ4JgnDzCje2ASAiIrIIhiQ7FaTmjW6JiIgsiSHJTunXJbFXEhERkWUwJNkp/RVu7JVERERkGQxJdko/ksReSURERJbBkGSn9CNJeRxJIiIisgiGJDvFkSQiIiLLYkiyU/qr28qq63CjtkHiaoiIiBwPQ5Kd8lQ5wU0hB8Ar3IiIiCyBIclOCYJw80a3XJdERERkdgxJdixIzV5JRERElsKQZMfYK4mIiMhyGJLsWLB+uo0jSURERGbHkGTHbt6ahCNJRERE5saQZMduTrdxJImIiMjcGJLs2M2GkhxJIiIiMjeGJDumH0mq1NZDU1MncTVERESOhSHJjrko5PBydQYAXOWUGxERkVkxJNm5ILYBICIisgiGJDsXzIaSREREFsGQZOcMi7c5kkRERGRWDEl2Tj/dxpEkIiIi82JIsnPBHEkiIiKyCIYkO2dYuM2RJCIiIrNiSLJz3Q33b6uBKIoSV0NEROQ4GJLsXICnCoIAaOt1KK2qlbocIiIih8GQZOcUTjL4uisB8PYkRERE5iR5SFq3bh3Cw8OhUqkQHR2NAwcOtLjvzp07MWHCBPj5+cHT0xOxsbFITU012ufkyZOYPn06evbsCUEQsGbNmk6f19YZeiWx6zYREZHZSBqSkpOTsXDhQixduhSZmZkYM2YMEhISkJOTY3L//fv3Y8KECUhJSUFGRgbGjRuHKVOmIDMz07BPdXU1evXqhVdeeQWBgYFmOa+tu7l4myNJRERE5iKIEq72jYmJwbBhw7B+/XrDtgEDBmDq1KlYuXJlm44RFRWFxMREPP/8882e69mzJxYuXIiFCxd2+rxarRZardbwvUajQUhICMrLy+Hp6dmmWi3lxf+exKZDl/D7u3rh2fsGSFoLERGRLdNoNFCr1W36/S3ZSFJtbS0yMjIQHx9vtD0+Ph7p6eltOoZOp0NFRQV8fHwsft6VK1dCrVYbHiEhIW0+p6UFGxpKciSJiIjIXCQLScXFxWhoaEBAQIDR9oCAABQUFLTpGKtWrUJVVRVmzJhh8fM+++yzKC8vNzxyc3PbfE5Lu3lrEq5JIiIiMhcnqQsQBMHoe1EUm20zZdu2bVi+fDk+//xz+Pv7W/y8SqUSSqWy3eexBq5JIiIiMj/JRpJ8fX0hl8ubjd4UFhY2G+W5VXJyMubNm4ePP/4Y48ePt9p5bZX+1iQFmho06NhQkoiIyBwkC0kKhQLR0dFIS0sz2p6Wloa4uLgWX7dt2zbMnTsXW7duxeTJk612Xlvm76GCXCagQSeiqEJ7+xcQERHRbUk63bZo0SIkJSVh+PDhiI2NxcaNG5GTk4P58+cDaFwHlJeXhy1btgBoDEizZ8/G2rVrMXLkSMNokIuLC9RqNYDGhdmnTp0yfJ2Xl4djx47B3d0dffr0adN57Y1cJiDAQ4mr5TW4Wn4DgU19k4iIiKjjJA1JiYmJKCkpwYoVK5Cfn4+BAwciJSUFYWFhAID8/Hyj3kUbNmxAfX09FixYgAULFhi2z5kzB++//z4A4OrVqxg6dKjhuTfeeANvvPEG7r77buzbt69N57VHwV4uuFpeg/yyGiBU6mqIiIjsn6R9kuxZe/osWMMft2Xiv8evYtnkAXhkTC+pyyEiIrJJdtEniczr5q1JeIUbERGROTAkOYigppCUX85eSURERObAkOQggrzYdZuIiMicGJIchP7WJOy6TUREZB4MSQ5Cf2uSokotaut1EldDRERk/xiSHEQ3NwUUTjKIInBNwyk3IiKizmJIchCCIBgWb1/llBsREVGnMSQ5kJtXuHEkiYiIqLMYkhyIfvH2VbYBICIi6jSGJAeiX7ydz4aSREREncaQ5ECCm3olsaEkERFR5zEkORDDdBtHkoiIiDqNIcmBGKbbOJJERETUaQxJDiSoaSTpenUdbtQ2SFwNERGRfWNIciCeKie4KeQAOJpERETUWQxJDkQQBMONbtkriYiIqHMYkhyMvqFkHrtuExERdQpDkoPRX+HGXklERESdw5DkYHiFGxERkXkwJDmYm7cm4UgSERFRZzAkOZibtybhSBIREVFnMCQ5GH2vJF7dRkRE1DkMSQ4muGkkqVJbD01NncTVEBER2S+GJAfjqnCCl6szAF7hRkRE1BkMSQ4oyLB4m+uSiIiIOoohyQEFq/WLtzmSRERE1FEMSQ6IvZKIiIg6jyHJARmm2ziSRERE1GEMSQ5If4XbVfZKIiIi6jCGJAd0s1cSQxIREVFHMSQ5oOBfNJQURVHiaoiIiOwTQ5IDClArAQDaeh1Kq2olroaIiMg+MSQ5IKWTHL7ujUGJtychIiLqGIYkB8XF20RERJ0jeUhat24dwsPDoVKpEB0djQMHDrS4786dOzFhwgT4+fnB09MTsbGxSE1Nbbbfjh07EBkZCaVSicjISHz66adGzy9fvhyCIBg9AgMDzf7epBTMG90SERF1iqQhKTk5GQsXLsTSpUuRmZmJMWPGICEhATk5OSb3379/PyZMmICUlBRkZGRg3LhxmDJlCjIzMw37HD58GImJiUhKSsLx48eRlJSEGTNm4LvvvjM6VlRUFPLz8w2PEydOWPS9Wpu+oSRvTUJERNQxgtiBy59yc3MhCAJ69OgBAPj++++xdetWREZG4rHHHmvzcWJiYjBs2DCsX7/esG3AgAGYOnUqVq5c2aZjREVFITExEc8//zwAIDExERqNBl9++aVhn0mTJsHb2xvbtm0D0DiS9Nlnn+HYsWNtrvVWGo0GarUa5eXl8PT07PBxLOWd/dn4W8pp3D84GP+YNVTqcoiIiGxCe35/d2gk6eGHH8bevXsBAAUFBZgwYQK+//57/PWvf8WKFSvadIza2lpkZGQgPj7eaHt8fDzS09PbdAydToeKigr4+PgYth0+fLjZMSdOnNjsmFlZWQgODkZ4eDhmzpyJ7OzsVs+l1Wqh0WiMHraMtyYhIiLqnA6FpJ9//hl33nknAODjjz/GwIEDkZ6ejq1bt+L9999v0zGKi4vR0NCAgIAAo+0BAQEoKCho0zFWrVqFqqoqzJgxw7CtoKDgtseMiYnBli1bkJqainfeeQcFBQWIi4tDSUlJi+dauXIl1Gq14RESEtKmGqXCW5MQERF1TodCUl1dHZTKxkvMd+/ejfvvvx8AEBERgfz8/HYdSxAEo+9FUWy2zZRt27Zh+fLlSE5Ohr+/f7uOmZCQgOnTp2PQoEEYP348du3aBQDYvHlzi+d79tlnUV5ebnjk5ubetkYp6a9uu6apQYOODSWJiIjaq0MhKSoqCv/6179w4MABpKWlYdKkSQCAq1evolu3bm06hq+vL+RyebNRo8LCwmYjQbdKTk7GvHnz8PHHH2P8+PFGzwUGBrb7mG5ubhg0aBCysrJa3EepVMLT09PoYcv8PVSQywTU60QUVWilLoeIiMjudCgkvfrqq9iwYQPGjh2LWbNmYfDgwQCAL774wjANdzsKhQLR0dFIS0sz2p6Wloa4uLgWX7dt2zbMnTsXW7duxeTJk5s9Hxsb2+yYX3/9davH1Gq1OH36NIKCgtpUuz2QywQEeDSO9vEKNyIiovZz6siLxo4di+LiYmg0Gnh7exu2P/bYY3B1dW3zcRYtWoSkpCQMHz4csbGx2LhxI3JycjB//nwAjVNceXl52LJlC4DGgDR79mysXbsWI0eONIwYubi4QK1WAwCefPJJ3HXXXXj11VfxwAMP4PPPP8fu3btx8OBBw3kXL16MKVOmIDQ0FIWFhXj55Zeh0WgwZ86cjvzvsFlBXi64Wl6D/LIaIFTqaoiIiOxLh0aSbty4Aa1WawhIly9fxpo1a3D27Nlm64Nak5iYiDVr1mDFihUYMmQI9u/fj5SUFISFhQEA8vPzjXombdiwAfX19ViwYAGCgoIMjyeffNKwT1xcHD766CNs2rQJd9xxB95//30kJycjJibGsM+VK1cwa9Ys9O/fH9OmTYNCocCRI0cM53UUQWpe4UZERNRRHeqTFB8fj2nTpmH+/PkoKytDREQEnJ2dUVxcjNWrV+Pxxx+3RK02xdb7JAHA31NOY+P+bPzfqHA8PyVS6nKIiIgkZ/E+ST/++CPGjBkDAPjkk08QEBCAy5cvY8uWLfjHP/7RkUOSBXAkiYiIqOM6FJKqq6vh4eEBoHFR9LRp0yCTyTBy5EhcvnzZrAVSxwV7NfVK4v3biIiI2q1DIalPnz747LPPkJubi9TUVEOH68LCQpudeuqKDDe5LeNIEhERUXt1KCQ9//zzWLx4MXr27Ik777wTsbGxABpHlYYO5X3CbIX+1iRFlVrU1uskroaIiMi+dKgFwEMPPYTRo0cjPz/f0CMJAO699148+OCDZiuOOqebmwIKJxlq63W4pqlBiE/b2zMQERF1dR0KSUBjZ+vAwEBcuXIFgiCge/fubW4kSdYhCAKC1CpcLqlGfjlDEhERUXt0aLpNp9NhxYoVUKvVCAsLQ2hoKLy8vPDSSy9Bp+O0ji3hFW5EREQd06GRpKVLl+Ldd9/FK6+8glGjRkEURRw6dAjLly9HTU0N/va3v5m7Tuog/eLtPC7eJiIiapcOhaTNmzfj3//+N+6//37DtsGDB6N79+74wx/+wJBkQ/SLt/PL2AaAiIioPTo03VZaWoqIiIhm2yMiIlBaWtrposh8gvRtADjdRkRE1C4dCkmDBw/GW2+91Wz7W2+9hTvuuKPTRZH5BDeNJF3lSBKRxXx5Ih9fHL8qdRlEZGYdmm577bXXMHnyZOzevRuxsbEQBAHp6enIzc1FSkqKuWukTuBIEpFlVWrr8cdtmajXiRjcQ42wbm5Sl0REZtKhkaS7774b586dw4MPPoiysjKUlpZi2rRpOHnyJDZt2mTuGqkT9Au3r1fX4UZtg8TVEDmei0VVqNc13if8y58LJK6GiMypw32SgoODmy3QPn78ODZv3oz33nuv04WReXi6OMFNIUdVbQPyy2+gl5+71CUROZTs4krD11/+XID5d/eWsBoiMqcOjSSR/RAEAUFe+ik3rksiMreLxVWGr4/nluEq220QOQyGpC5A31CSf3kTmV92UZXR919xyo3IYTAkdQHBao4kEVmKfiRpZC8fAAxJRI6kXWuSpk2b1urzZWVlnamFLMTQUJJXuBGZlSiKhpD0+Ng+OJL9PY5eLkVhRQ38PVQSV0dEndWukKRWq2/7/OzZsztVEJmffiSJvZKIzKuoQotKbT1kQuNI0uAQLxzPLcPXJ6/htyPDpC6PiDqpXSGJl/fbpyAvrkkisoTsplGkHt6uUDrJkTAwEMdzy/Dlz/kMSUQOgGuSuoAgrkkisgj9VFu4b2MDyYSBgQCAI9mluF5VK1ldRGQeDEldgP7WJJXaemhq6iSuhshxZBc19kjq5dcYksK6uSEyyBMNOhFpp65JWRoRmQFDUhfgqnCC2sUZAJDPdUlEZqMfSerle/NWJPrRpC9/zpekJiIyH4akLsLQK4lXuBGZTbZhuu1mJ/uEQY0h6eD5Yo7cEtk5hqQuIljfdZsjSURmUdegQ05JNYCb020A0MffA3383VHXIGLP6UKpyiMiM2BI6iKC2SuJyKyuXL+Bep0IlbMMgZ7GPZE45UbkGBiSuogg9koiMquLTTe27dnNDTKZYPTcpKaQtO9sEaq09VavjYjMgyGpi+BIEpF56e/Z1tvPvdlzkUGeCOvmCm29DvvOFlm7NCIyE4akLoK9kojMK/uWHkm/JAiCYTSJU25E9oshqYu4eWuSGxBFUeJqiOzfxaKWQxIAJAwMAgDsPVOImroGq9VFRObDkNRFBKiVAABtvQ7Xq3lZMlFnZRcbN5K81eAeagSrVaiqbcCBrGJrlkZEZsKQ1EUoneTwdW8MSryHG1HnVGnrcU2jBdDySJIgCJjIKTciu8aQ1IUE80a3RGah77Tt46aAl6uixf30U267T11Dbb3OKrURkfkwJHUh+q7bXLxN1DnZJm5HYkp0mDd83ZXQ1NQj/QKn3IjsjeQhad26dQgPD4dKpUJ0dDQOHDjQ4r47d+7EhAkT4OfnB09PT8TGxiI1NbXZfjt27EBkZCSUSiUiIyPx6aefduq8jsLQK4ltAIg65XaLtvXkMgGTBgYAAL76ucDidRGReUkakpKTk7Fw4UIsXboUmZmZGDNmDBISEpCTk2Ny//3792PChAlISUlBRkYGxo0bhylTpiAzM9Owz+HDh5GYmIikpCQcP34cSUlJmDFjBr777rsOn9dRGHolsaEkUafoG0mGt7Bo+5f0U25fn7qG+gZOuRHZE0GU8HrwmJgYDBs2DOvXrzdsGzBgAKZOnYqVK1e26RhRUVFITEzE888/DwBITEyERqPBl19+adhn0qRJ8Pb2xrZt28x2Xo1GA7VajfLycnh6erbpNVL77/Gr+OO2TIzo6Y3t8+OkLofIbt3/1kH8dKUc//pttKEfUkvqG3QY8bfduF5dh62PxiCut6+VqiQiU9rz+1uykaTa2lpkZGQgPj7eaHt8fDzS09PbdAydToeKigr4+PgYth0+fLjZMSdOnGg4ZkfPq9VqodFojB72Rn+TW96ahKjjRFE0TLe1dPn/LznJZZgQySk3InskWUgqLi5GQ0MDAgICjLYHBASgoKBtf5GsWrUKVVVVmDFjhmFbQUFBq8fs6HlXrlwJtVpteISEhLSpRluin267pqlBg44NJYk6oriyFhXaeggCEOrj2qbX6Kfcvvq5ADr+7BHZDckXbguC8Y0hRVFsts2Ubdu2Yfny5UhOToa/v3+7j9ne8z777LMoLy83PHJzc29bo63x91BBLhNQrxNRXKmVuhwiu5Rd1LgeqYe3C1TO8ja9Jq5PN3gonVBYoUVm7nVLlkdEZiRZSPL19YVcLm82elNYWNhslOdWycnJmDdvHj7++GOMHz/e6LnAwMBWj9nR8yqVSnh6eho97I1cJiDAgw0liTrjouGebc1vbNsSpZMc45um3FJOcMqNyF5IFpIUCgWio6ORlpZmtD0tLQ1xcS0vKt62bRvmzp2LrVu3YvLkyc2ej42NbXbMr7/+2nDMjp7XUQR58Ua3RJ1xsY09km6lX+D91c8FvH8ikZ1wkvLkixYtQlJSEoYPH47Y2Fhs3LgROTk5mD9/PoDGKa68vDxs2bIFQGNAmj17NtauXYuRI0caRoNcXFygVqsBAE8++STuuusuvPrqq3jggQfw+eefY/fu3Th48GCbz+vI9A0lzxZU4L5BQRJXQ2R/LrRj0fYv3d3PD64KOfLKbuBEXjnu6OFlgeqIyJwkXZOUmJiINWvWYMWKFRgyZAj279+PlJQUhIWFAQDy8/ONehdt2LAB9fX1WLBgAYKCggyPJ5980rBPXFwcPvroI2zatAl33HEH3n//fSQnJyMmJqbN53VkY/s3rt/acvgSNDW80S1Rexl6JLVzJEnlLMe4pp+/L3mVG5FdkLRPkj2zxz5JQGPPlolr9uNCURX+dE8fLIrvL3VJRHajvkGHAc9/hboGEQf/Mg49vNt2dZuevldZuK8b9jx9d5suUiEi87KLPkkkDSe5DIubgtG/D17kVW5E7XDl+g3UNYhQOskQ3HSbn/YYF+EPhZMMF4urcPZahQUqJCJzYkjqgiYNDMQdPdSorm3A23vPS10Okd24eWWbG2Sy9o8CuSudcFdfPwC8yo3IHjAkdUGCIOCZiREAgA+P5ODK9WqJKyKyD9nFbbuxbWvuG6S/yi3fLDURkeUwJHVRo/v6Iq53N9Q26LBmd5bU5RDZBX0jyfZe2fZL9w4IgLNcwLlrlbjQdDwisk0MSV3YM5MaR5N2/ngFWVwfQXRbHWkkeSu1i7PhJre8lxuRbWNI6sKGhHhhYlQAdCKw6utzUpdDZPMummG6DQASmhpLfskpNyKbxpDUxS2O7w+ZAHx1sgDHcsukLofIZlXX1hs61ffuxHQbAEyIDIBMAH7O0yC3lGsCiWwVQ1IX1zfAAw8O7QEAeD31jMTVENku/SiSt6szvFwVnTpWN3clYsK7AeCUG5EtY0giLBzfFwq5DIfOl+BgVrHU5RDZJHNNteklNF3llsIpNyKbxZBECPFxxcMxoQAaR5PYhJ2ouWzDPds6vmj7lyZGBUIQgMycMuSX3zDLMYnIvBiSCADwxD194KqQ4/iVcqSe5PA/0a3MPZIU4KlCdKg3ACCVU25ENokhiQAAvu5KPDI6HADwxtfnUN+gk7giItuibyTZy0whCWjsfg/whrdEtoohiQweuasXvFydcb6wEjsz86Quh8hmiKL4i0aS5pluA26GpKOXSnkfRSIbxJBEBp4qZ/xhbG8AwNrdWdDWN0hcEZFtKKmqRUVNPQQBCOvmarbj9vB2xR091NCJwNcnr5ntuERkHgxJZGR2bE8EeqqQV3YDHx7JkbocIpugX48UrHaByllu1mNPYmNJIpvFkERGVM5yPDm+LwDgrb3nUamtl7giIumZ455tLUkYGAQAOHyhBGXVtWY/PhF1HEMSNfPr6B4I93VDaVUt3j1wUepyiCRniUXbeuG+bogI9EC9TkTaKU65EdkShiRqxkkuw9Px/QAA7xzIRmkV/3VLXdvFIvNe/n8r/WgSu28T2RaGJDLpvoFBiAr2RKW2Huv2npe6HCJJGUaSzHhl2y/pu28fyCpGRU2dRc5BRO3HkEQmyWQC/jyxPwBgy5HLuFrGjsDUNTXoRFwusexIUl9/d/Tyc0Ntgw57zhRa5BxE1H4MSdSiu/v54c5wH9TW6/CPb7KkLodIEnnXb6CuQYTCSYZgLxeLnEMQBCQ0XeXGKTci28GQRC0SBAF/mdQ4mvTxD7m40HSFD1FXcqG48c99eDc3yGWCxc6jX5e072wRqmt5VSmRLWBIolZFh/lg/AB/6ERg9dfnpC6HyOosvWhbLyrYEyE+LrhR14BvzxZZ9FxE1DYMSXRbiyf2hyAAu07k4+e8cqnLIbIqw41tLdAj6Zcap9waR5N4Lzci28CQRLcVEeiJqUO6AwBeSz0rcTVE1pXdNN1miR5Jt9J3395zppC3BSKyAQxJ1CZPje8HJ5mA/eeKcPhCidTlEFmNfrrNEt22bzWkhxcCPVWo1NbjYFaxxc9HRK1jSKI2Ce3mill3hgIAXks9A1EUJa6IyPJu1DbgankNACDc1zI9kn5JJhN+cS83TrkRSY0hidrsj/f0gYuzHJk5Zdh9mr1cyPHp1yN5uTrDx01hlXPqQ1LaqWuoa9BZ5ZxEZBpDErWZv6cKvxvVEwDweuoZNOg4mkSOzbBo2wrrkfRG9PSBr7sC5TfqcCSbU9tEUmJIonb5/V294alywrlrlfj8WJ7U5RBZ1EV9jyQrhiS5TEB8VONoUsoJTrkRSYkhidpF7eqM+WN7AwBWp51DbT2nA8hxZTct2u5toXu2tSTBMOVWwBFbIgkxJFG7/S4uHP4eSly5fgPbvs+Ruhwii8mWYLoNAEb26ga1izOKK2tx9FKpVc9NRDcxJFG7uSjk+OO9fQEA/9xznrdQIIckiiKyi6w/3QYAznIZJkQGAOC93IikxJBEHZI4PAShPq4ortRi06FLUpdDZHalVbXQ1DT+A8DaIQmA0Q1vdZxyI5IEQxJ1iMJJhqfj+wEA/vXtBZRV10pcEZF56a9s6+7lApWz3OrnH93XF+5KJxRoanDsSpnVz09ENhCS1q1bh/DwcKhUKkRHR+PAgQMt7pufn4+HH34Y/fv3h0wmw8KFC5vtU1dXhxUrVqB3795QqVQYPHgwvvrqK6N9li9fDkEQjB6BgYHmfmsOb8odwYgI9EBFTT3Wf3tB6nKIzEqq9Uh6Sic57h3gD4BTbkRSkTQkJScnY+HChVi6dCkyMzMxZswYJCQkICfH9GJgrVYLPz8/LF26FIMHDza5z7Jly7Bhwwb885//xKlTpzB//nw8+OCDyMzMNNovKioK+fn5hseJEyfM/v4cnUwm4M8T+wMA3j90CQVNnYmJHEG2FW9H0hL9lFvKiXx2uSeSgKQhafXq1Zg3bx4eeeQRDBgwAGvWrEFISAjWr19vcv+ePXti7dq1mD17NtRqtcl9PvjgA/z1r3/Ffffdh169euHxxx/HxIkTsWrVKqP9nJycEBgYaHj4+fm1WqtWq4VGozF6EHBPhD+Gh3lDW6/DP/ZkSV0OkdlI0SPpVnf384eLsxxXrt/Ayav8O4fI2iQLSbW1tcjIyEB8fLzR9vj4eKSnp3f4uFqtFiqVymibi4sLDh48aLQtKysLwcHBCA8Px8yZM5Gdnd3qcVeuXAm1Wm14hISEdLhGRyIIAp6ZFAEA+PhoLi41TVEQ2Tspum3fykUhx9j+jf+AY/NWIuuTLCQVFxejoaEBAQEBRtsDAgJQUNDx+feJEydi9erVyMrKgk6nQ1paGj7//HPk5+cb9omJicGWLVuQmpqKd955BwUFBYiLi0NJScu3AHj22WdRXl5ueOTm5na4RkdzZ7gPxvb3Q71OxOq0c1KXQ9RpDToRl0qqAVi/keSt7hsUBAB458BFPLrlB+Q01UVElif5wm1BEIy+F0Wx2bb2WLt2Lfr27YuIiAgoFAo88cQT+N3vfge5/ObVKQkJCZg+fToGDRqE8ePHY9euXQCAzZs3t3hcpVIJT09PowfdpF+b9MXxqzh5tVziaog652rZDdTW66CQyxDs5SJpLZMHBeHRMeGQywSknbqG8au/xeupZ1ClZX8yIkuTLCT5+vpCLpc3GzUqLCxsNrrUHn5+fvjss89QVVWFy5cv48yZM3B3d0d4eHiLr3Fzc8OgQYOQlcU1NR0VFazGlMHBAIA3Us9KXA1R5+ivbAvr5gq5rOP/aDMHmUzA0smR+OrJMRjdxxe1DTq8vfcC7lm1D59l5nFBN5EFSRaSFAoFoqOjkZaWZrQ9LS0NcXFxnT6+SqVC9+7dUV9fjx07duCBBx5ocV+tVovTp08jKCio0+ftyhZN6Ae5TMDes0VY/fVZ/uVNdkvfaVvKK9tu1TfAAx/MuxMbkqIR4uOCaxotFiYfw0P/OowTVzh6S2QJkk63LVq0CP/+97/x3nvv4fTp03jqqaeQk5OD+fPnA2hcBzR79myj1xw7dgzHjh1DZWUlioqKcOzYMZw6dcrw/HfffYedO3ciOzsbBw4cwKRJk6DT6fDMM88Y9lm8eDG+/fZbXLx4Ed999x0eeughaDQazJkzxzpv3EGF+7phcXzjtNs/9pzHX3b8hLoG3gCX7M/NRdvSrke6lSAImBgViLSn7safJ/aHi7McGZev4/63D2LJjp9QXKmVukQih+Ik5ckTExNRUlKCFStWID8/HwMHDkRKSgrCwsIANDaPvLVn0tChQw1fZ2RkYOvWrQgLC8OlS5cAADU1NVi2bBmys7Ph7u6O++67Dx988AG8vLwMr7ty5QpmzZqF4uJi+Pn5YeTIkThy5IjhvNRxj4/tDbWLM5Z9dgIf/3AFhRVavP3wMLgpJf2jRtQu+pDUS8Ir21qjcpZjwbg+mD6sB1758jQ+O3YVHx3Nxa4T+Xjy3r6YE9cTznLJl5wS2T1B5JxIh2g0GqjVapSXl3MRtwm7T13DE9t+RE2dDnf0UOO9uSPg666UuiyiNhn1yh7kld3AJ/NjMbynj9Tl3NYPl0qx/L8n8XNeYy+l3n5ueH5KFO7u13r/N6KuqD2/v/lPDbKI8ZEB2ProSHi7OuOnK+WYvj6dPZTILtTUNSCv7AYAaXsktcfwnj74fMFovDJtELq5KXChqApz3vsej2w+yp87ok5gSCKLGRbqjR2PxyHExwWXS6oxfX06juWWSV0WUasulTSGCk+VE3zcFBJX03ZymYCZd4Ziz+Kx+L9R4XCSCdh9uhDxb+7Hq1+xZQBRRzAkkUX18nPHjsfjMLC7J0qqajFr4xHsOXNN6rKIWnTznm3unerZJhW1izOenxKJrxaOwZi+jS0D1u+7gHFv7MOnmVd41SlROzAkkcX5e6jw0WOxuKufH27UNeDRLRlIPmr6JsZEUrP1Rdtt1cffA1v+705sTIpGqI8rCiu0eCr5OKavT8dPV8qkLo/ILjAkkVW4K53w7pzhmDasOxp0Iv6y4wTW7s7iv2rJ5uhHkuxlPVJrBEFAfFQgvn7qLvx5Yn+4KuT4MacMD7x9CM98chxFFWwZQNQahiSyGme5DKt+PRhPjOsDAHhz9zn89dMTqGcvJbIh2cX6RpK21SOpM/QtA/Y8PRYPDu0OUQQ+/uEK7nljH97Zn43aev4MEpnCkERWJQgCFk/sj5emDoRMALZ9n4vff5CB6louKiXbcLORpP2PJN0qUK3Cm4lDsOPxWAzqrkaFth5/SzmNSWv3I/VkAUd2iW7BkESSSBoZhvW/jYbSSYZvzhRi1jvfoYTdgkli16tqUVZdBwDo6esqcTWWEx3mg88XjMKr0xtbBmQXVeH3H2Rg6rp0HDpfLHV5RDaDIYkkMzEqEFsfjYGXqzOO55Zh+vp0XC5hTxeSjn6qLVitgqvCsbvEy2QCEkeEYu+fx2LBuN5wcZbjeG4ZfvPv7/Cbfx9BZs51qUskkhxDEkkqOswHn8yPQ3cvF1xq6qXEK29IKoZF2zZ0Y1tL81Q5488TI/DtM2MxN64nnOUCDp0vwYPr0vHYlh9wtqBC6hKJJMOQRJLr4++OT/8Qh8ggTxRX1mLmxiPYd7ZQ6rKoC3Lk9Ui34++hwvL7o7Dn6bF4KLoHZALw9alrmLR2P55KPoackmqpSySyOoYksgn+niok/34kRvfxRXVtA+Zt/gHbf8iVuizqYgyNJH0d58q29grxccUbvx6M1IV3IWFgIEQR+DQzD/es2odln51AoaZG6hKJrIYhiWyGh8oZ780dgQeHNvZS+vMnP+Gf37CXElmPYSSpC023taRvgAfW/zYaXzwxCmP6+qJeJ+I/R3Jw1+t7sfLL0yirrpW6RCKLY0gim6JwkmH1jMF4fGxvAMCqtHNY+tnP7KVEFqfTibhY4hjdts3pjh5e+GBeDLY9OhLDQr1QU6fDhm+zMebVvfjnN1m8Jxw5NIYksjmCIOAvkyLw4v1REARg63c5mP+fH3GjtkHq0siB5ZXdQG29Ds5yAT28Hffy/46K7d0NOx6Pw79nD0dEoAcqtPVYlXYOd722F+8dvIiaOv58kuNhSCKbNSeuJ9b/ZhgUTjLsPn0ND//7CEqrOMRPlqGfagvr5ga5zP5ubGsNgiBgfGQAUv40BmtnDkFYN1eUVNVixf9O4Z439uHjo7kc9SWHwpBENm3SwCB8+EgM1C7OyMwpw0Pr05FbyqtsyPy68pVt7SWTCXhgSHfsXnQ3/v7gIAR4KnG1vAbP7PgJ8Wv2Y9dP+dDpuJaQ7B9DEtm8ET198Mn8WASrVcgursKv/nkQn2XmcUE3mVV2kf6ebQxJbeUsl+HhmFB8++dxWHrfAHi7OiO7qAoLtv6IKW8dxN6zhfw5JbvGkER2oW+ABz5dMAp39FCj/EYdFiYfw2MfZKCwgpcjk3lkF3PRdkepnOV49K5e2P/MODx5b1+4KeQ4eVWD3206isQNR5B+vpjTcGSXBJExv0M0Gg3UajXKy8vh6ekpdTldRl2DDv/adwH/2JOFugYRXq7OePH+KNw/OBiCwHUk1HGjX92DK9dv4OPfx+LOcB+py7FrJZVarN93AVuOXEZtfWM4clc6YXhPb4zs1Q0x4T4Y1F0NJzn/nU7W157f3wxJHcSQJK3T+Ro8/fFxnMrXAAAmRQXipakD4eehlLgyskc1dQ0Y8PxXEEXgh2Xj4evOP0fmkF9+A//45jx2/XQVmhrjVgFuCjmG9/RBTC8fjOzVDYO6q+HM0ERWwJBkBQxJ0qtr0GHd3gv4554s1OtEeLs646WpA/GrO4KlLo3szNmCCkxcsx8eKif89EI8RyXNrEEn4kyBBkeyS3EkuwTfXyxF+Y06o31cFXJEhzWONI3s5YNB3b2gcGJoIvNjSLIChiTbcfJqORZv/wmnm0aV7hsUiJceGIhuHA2gNvrq53zM/8+PGNxDjc+fGC11OQ5PpxNxpqACR7JL8N3FEnx3sRRl1cahycVZjuE9vRET3jjSdEcPhiYyD4YkK2BIsi219Tq8vfc83t57HvU6Ed3cFHhp6kDcNyhI6tLIDry99zxeTz2LB4d2x5uJQ6Qup8vR6UScvVaB77JLcCS7FN9dLMH1W0KTylnWONIU3g0xvbphcIgaSie5RBWTPWNIsgKGJNv0c145Fm8/jjMFFQCAyXcE4aUHBsLHTSFxZWTLFm8/jk8yrmDRhH740719pS6ny9PpRGQVVuJIdknTaFNps0aySqfG0BQT3g0xvXwwJMQLKmeGJro9hiQrYEiyXbX1OvxzTxbW7buABp0IX3cFXp46EJMGclSJTJu+Ph0Zl6/jn7OGYspgrmmzNaJ4MzR917SuqeSW0OQsFzCwuxojevpgeJg3hvf04T+OyCSGJCtgSLJ9J66U4+ntx3DuWmOTwPsHB+PF+6Pgzb846RZDV3yN69V12PWn0YgKVktdDt2GKIq4UFSJw02B6ejFUhRWaJvt18ffHSN6emN4mA9G9PRBiI8LF+UTQ5I1MCTZB219A/7xTRbW77sAnQj4uivx9wcHIj4qUOrSyEZcr6rF0JfSAAAnX5wIN6WTxBVRe4miiNzSGzh6qRQ/XC7F0UvXcb6wstl+/h7KxpGmnt4Y0dMHEYEe7NXUBTEkWQFDkn05nluGxduPI6vpL86pQ4Kx/P4oeLlyVKmr+zHnOqatS0egpwpH/nqv1OWQmZRW1SLj8nX8cKkURy+V4kReOeoajH/duSnkGBbWNNIU7o0hIV5wVTAkOzqGJCtgSLI/NXUNWPtNFjZ82ziq5OehxN8fHIQJkQFSl0YS+iTjChZvP4643t2w9dGRUpdDFlJT14DjuWX44fJ1HL1UioxL11GhNW5w6SQTENVdjRFNa5qG9/RmY1EHxJBkBQxJ9isz5zoWbz+OC0WN9+qaNrQ7XpgSBbWrs8SVkRReTz2Dt/dewG9iQvG3BwdJXQ5ZSYNOxLlrFTh6qXF67ujFUhRomt8LMtzXDaE+rujmpoC3mwI+bgp0a/qvj+F7JTxdnLjeyU605/c3xxWpyxka6o1dfxqDN9PO4Z0D2diZmYdDF4qxctog3BPBUaWu5mLTjW3DeWPbLkUuEzAgyBMDgjwxO7YnRFFEXtkN/HCpcaTph0vXcfZaBS4WVxn+jLTGSSY0hijXpvDk3himvF0V6OZuHKi83Zzh46rgeig7wJBEXZLKWY5n7xuAiQMDsXj7cWQXVeH/3v8BD0X3wHOTIzmq1IVkN40o9vZzl7gSkpIgCOjh7Yoe3q6YOrQ7AKCsuhbHr5TjmqYGpVW1uF5Vi5KqWpQa/qvF9ao6VGrrUa8TUVShRZGJq+xaonZxRjd3BUK8XRHWzRWhPq4I6+Zm+Jp9n6TH6bYO4nSb46ipa8Cqr8/i3wcvQhQBb1dnLJrQD7PuDOW/9BycTidiwPNfQVuvw77FY9GTo0nUATV1DbheXYuSysYA9cuvfxmmSqq0KK2qRdmNOrTlN6+/h7IpMDUGp18GKW9XZ07vdZBdrUlat24dXn/9deTn5yMqKgpr1qzBmDFjTO6bn5+Pp59+GhkZGcjKysKf/vQnrFmzxmifuro6rFy5Eps3b0ZeXh769++PV199FZMmTerweU1hSHI8GZdLsWTHCcMVcH393fHcryJxVz8/iSsjS8kru4FRr+yBs1zA6RWTGIrJKhp0Iq5XN45MFVZokVNajcsl1cgprTJ8XVFT3+oxPJROCPFpCk7dXBHmc3MEKtjLBXIZA1RL7GZNUnJyMhYuXIh169Zh1KhR2LBhAxISEnDq1CmEhoY221+r1cLPzw9Lly7Fm2++afKYy5Ytw3/+8x+88847iIiIQGpqKh588EGkp6dj6NChHTovdQ3RYT748skx2PZ9DlannUNWYSVmv/c97onwx9LJAzgd44CyixoDcaiPKwMSWY1cJsDXXQlfdyX6Bnhg1C3Pi6KIsuo6XC6txuWSKuSUVDeGp9Jq5JRUo0BTgwptPU7la3Cq6cbev+QsF9DdywWh3dwQ5KmCm9IJbko5XBVOcFXI4aqQw03pBBeFHG63bGv82okhq4mkI0kxMTEYNmwY1q9fb9g2YMAATJ06FStXrmz1tWPHjsWQIUOajSQFBwdj6dKlWLBggWHb1KlT4e7ujv/85z+dPq8eR5IcW3l1Hf65Jwvvp19CvU6Ek0xAUmwYnry3L3srOZAthy/h+c9PYvyAAPx7znCpyyFqk5q6BuQ2jThdLq1u+roKl0urcaX0BmobdJ0+h9JJ9ovQ1Bic3JRyuDgbBy43hRyuSqfG/ypuPmf4r8IJrsrGMKZyltnEFKFdjCTV1tYiIyMDS5YsMdoeHx+P9PT0Dh9Xq9VCpVIZbXNxccHBgwc7dV6tVgut9uaCPI2meXonx6F2dcayX0Xi4ZhQ/D3lNHafLsSmQ5fwaWYenhrfDw/HhMKZIw92T79ou5cf1yKR/VA5y9E3wAN9AzyaPdegE1GgqcHlkirkllajUKNFdV0DqrX1qK5tQHVtA6pq9V/Xo1prvK1B1zhuoq3XQVtfi9LbX9jXZoIAw8iVPoD9MkQZbW/6bx9/d4zpK92SB8lCUnFxMRoaGhAQYHzJdUBAAAoKCjp83IkTJ2L16tW466670Lt3b3zzzTf4/PPP0dDQ0Knzrly5Ei+++GKH6yL71MvPHf+eMwIHsorw8v9O4+y1CrzwxUl8cOQynvtVJO7meiW7lt10aXcvLtgmByGXNU61dfdyAXq377WiKKK2QYdqbWNoulHbgKramwHrZrhq3Fap30fbGLj0+1Y1BTD99urahqbjA5XaelRq64E2XgU4ZXBw1wxJercOvYmi2KnhuLVr1+LRRx9FREQEBEFA79698bvf/Q6bNm3q1HmfffZZLFq0yPC9RqNBSEhIh+sk+zKmrx92/akbPjqai9Vp53C+sBJz3vse4/r7YenkSPTx53ole3SxuHFNEnskETX+XlQ6yaF0kpv1RuA6nYgbdU0hS3szbFVpb/nvL59v+u+wUC+z1dERkoUkX19fyOXyZqM3hYWFzUZ52sPPzw+fffYZampqUFJSguDgYCxZsgTh4eGdOq9SqYRSyfb0XZmTXIbfjgzDlMHBeKtpvdLes0XYn7UfSSPDsHA81yvZE219A65cvwEACOd0G5HFyGRC0+JxJ6D5DKFNk2xRhUKhQHR0NNLS0oy2p6WlIS4urtPHV6lU6N69O+rr67Fjxw488MADVjkvOT61izOWTo7E10/djQmRAWjQiXg//RLufn0f3j90EXVmWDRJlne5pBqi2HgptR/vz0VEJkg63bZo0SIkJSVh+PDhiI2NxcaNG5GTk4P58+cDaJziysvLw5YtWwyvOXbsGACgsrISRUVFOHbsGBQKBSIjIwEA3333HfLy8jBkyBDk5eVh+fLl0Ol0eOaZZ9p8XqK2CPd1wzuzh+PQ+WK89L9TOFNQgeX/PYUPjlzGsl9FYlx/f6lLpFboF22H+7nZxBU3RGR7JA1JiYmJKCkpwYoVK5Cfn4+BAwciJSUFYWFhABqbR+bk5Bi9Rt/rCAAyMjKwdetWhIWF4dKlSwCAmpoaLFu2DNnZ2XB3d8d9992HDz74AF5eXm0+L1F7jOrji11/GoOPjuZg1dfncKGoCr/bdBR39/PDsskDTF6BQtLjPduI6HYk77htr9gniUzR1NThrT3nsenQRdQ1iJDLBPw2JhQLx/cz60JI6rw/bz+O7RlX8NT4fnhyfF+pyyEiK2nP7282eiEyI0+VM/563wCkPXU34pvWK20+fBl3v74X7x3keiVbYhhJ4qJtImoBQxKRBfT0dcPG2cOx9ZEYRAR6QFNTjxX/O4WJb+7Hp5lXUM+wJLmL7JFERLfBkERkQXFN65VWThuEbm4KZBdX4ank4xj7xj58cPgSauoapC6xSyqvrkNJVS0ArkkiopYxJBFZmFwmYNadodj357H488T+6OamwJXrN/Dc5ycx+tW9WL/vAipq6qQus0vJbmoiGeCpbOzdQkRkAkMSkZV4qJyxYFwfHPzLPXjx/ih093JBcaUWr351BnGv7MHrqWdQXNm2Vv3UObyyjYjagiGJyMpcFHLMieuJfX8ei1W/How+/u6oqKnH23svYPSre/DC5z/jyvVqqct0aDdvbMvbyRBRyxiSiCTiLJdhenQPfL3wLmxIisbgHmrU1Omw+fBljH19HxZ9fAxZ1yqkLtMhcdE2EbUFJ+OJJCaTCZgYFYj4yACkXyjBun3nceh8CXb+mIedP+YhPjIAfxjXB0NCvKQu1WFkc7qNiNqAIYnIRgiCgFF9fDGqjy+O55Zh3b7zSD15DV+fanyM6tMNfxjbB3G9u/E2Gp2g04m42LRwm9NtRNQahiQiGzQ4xAsbkobjfGEF1u/LxufH8nDofAkOnS/B4B5qPD62D+IjAyCTMSy1V4GmBjV1OjjJBPTwdpG6HCKyYVyTRGTD+vh7YNWMwdj357GYExsGpZMMx6+UY/5/MhC/Zj8+ybjCLt7tpF+PFOrjCmc5/wokopbxbwgiO9DD2xUvPjAQh5bcgwXjesND5YTzhZVYvP04xr6+D5vTL+FGLRtTtkV2kX6qjeuRiKh1DElEdsTXXYk/T4zAoSX34C+TIuDrrkRe2Q288MVJjH51D/7xTRauaWqkLtOmcdE2EbUVQxKRHfJUOePxsb1x8C/j8NLUgejh7YKSqlqsTjuH2JXf4JHNR/H1yQJOxZmg75EU7stF20TUOi7cJrJjKmc5kkaGYdaIEOw6kY//HLmMo5euY/fpQuw+XQg/DyUeiu6BGcNDOHLSxNAjidNtRHQbDElEDsBJLsMDQ7rjgSHdcb6wEtt/yMUnGVdQVKHF+n0XsH7fBcSE+2DmnSFIGBgElbNc6pIloa1vMHQzZyNJIrodQRRFUeoi7JFGo4FarUZ5eTk8PT2lLoeomdp6HfacuYaPjuZi/7ki6Jp+0j1UTnhwaHfMGB6Cgd3V0hZpZVnXKjDhzf1wU8jx84sT2W+KqAtqz+9vjiQROSiFkwyTBgZh0sAgXC27gU8yriD5aC7yym5gy+HL2HL4MgZ290TiiFDcPzgYahdnqUu2uOzim/dsY0AiotthSCLqAoK9XPCne/viiXF9cOhCMZKP5uLrk9fwc54GP+f9jJf/dwqTBwUhcUQI7gz3cdgAcZFXthFROzAkEXUhMpmAMX39MKavH0qravFpZh6Sj+bg3LVK7MzMw87MPIT7umHG8BBMj+4Ofw+V1CWblb5HEkMSEbUFQxJRF+XjpsC80eH4v1E9cSy3DMlHc/HF8au4WFyFV786gze+Pot7I/wx884Q3NXXD04O0J2aV7YRUXswJBF1cYIgYGioN4aGemPZryKx66erSD6aix9zygw31w3wVOLX0SF4YEgw+vjb73oeQ0hijyQiagNe3dZBvLqNHN25axVIPpqLnT9ewfXqOsP2Ht4uGNffH+Mi/BDbyxcuCvtoJ1B+ow6DX/waAHBieTw8VI6/UJ2ImmvP72+GpA5iSKKuQlvfgN2nCrE9IxfpF0pQW3+zi7fCSYbYXt0wrr8fxkX4I6yb7U5jHcstw9S3D8HfQ4nvl46XuhwikghbABCR2Sid5Jh8RxAm3xGE6tp6HL5Qgr1nC7H3TBHyym7g23NF+PZcEZb/9xR6+bphbNMo053hPlA62c4o08ViLtomovZhSCKiNnNVOOHeAQG4d0AARFHE+cJKQ2A6eqkU2cVVyC6+iPcOXYSrQo643r4YF+GHsf390d3LRdLa9fds46JtImorhiQi6hBBENA3wAN9Azzw2F29UVFTh0Pni7H3TBH2ni1EYYUWu09fw+7T1wAA/QM8MDbCD+P6+yM6zBvOVr5aLpuLtomonRiSiMgsPFTOhg7foijiVL4G+84WYe+ZQvyYcx1nr1Xg7LUKbPg2Gx5KJ4zp54ux/f0xtp8f/D0t34/pYhEbSRJR+zAkEZHZCYKAqGA1ooLVWDCuD8qqa7E/qxj7zhRi37kilFbVIuVEAVJOFAAABnb3xNh+/hgS4oUBwZ4IVqvM2mZApxNvdtvmdBsRtRFDEhFZnJerAvcPDsb9g4PRoBNxIq8ce88UYt/ZQhy/Ut50exSNYX9PlRMigjwRGeSJAUEeGBDkiX4BHlA5d2wh+LWKGtyoa4BcJiDUx9Vcb4uIHBxDEhFZlVwmYEiIF4aEeOGpCf1QVKHF/nNFOHS+GKfyNThfWAlNTT2+v1iK7y+WGl4nExqnygYEeTY9GsNToOftR530U22hPq5WXwtFRPaLIYmIJOXnocT06B6YHt0DQGNfpguFVTidr2l8FGhwOr8CpVW1uFBUhQtFVfjfT/mG13u5OiMi0MMQniKDPNHH391o1OmCYdE2p9qIqO0YkojIpiid5IgM9kRk8M0mb6IooqhCi1P5GpwpqDAEqAtFVSirrsOR7FIcyb456iSXCejVNOoUEeSBHy+XAeCibSJqH4YkIrJ5giDA31MFf08Vxvb3N2yvqWvA+cLKptBUYRh5KquuQ1ZhJbIKK/HF8ZvH4aJtImoPySfn161bh/DwcKhUKkRHR+PAgQMt7pufn4+HH34Y/fv3h0wmw8KFC03ut2bNGvTv3x8uLi4ICQnBU089hZqaGsPzy5cvhyAIRo/AwEBzvzUisjCVsxwDu6vx6+EheH5KJLY9NhKZz03AkWfvxaa5I/DMpP6YMrjxpry9fN1wT4T/7Q9KRNRE0pGk5ORkLFy4EOvWrcOoUaOwYcMGJCQk4NSpUwgNDW22v1arhZ+fH5YuXYo333zT5DE//PBDLFmyBO+99x7i4uJw7tw5zJ07FwCMXhMVFYXdu3cbvpfLbef2CUTUcYIgIFCtQqBahXEMRUTUCZKGpNWrV2PevHl45JFHADSOAKWmpmL9+vVYuXJls/179uyJtWvXAgDee+89k8c8fPgwRo0ahYcfftjwmlmzZuH777832s/JyYmjR0RERNQiyabbamtrkZGRgfj4eKPt8fHxSE9P7/BxR48ejYyMDEMoys7ORkpKCiZPnmy0X1ZWFoKDgxEeHo6ZM2ciOzu71eNqtVpoNBqjBxERETkuyUaSiouL0dDQgICAAKPtAQEBKCgo6PBxZ86ciaKiIowePRqiKKK+vh6PP/44lixZYtgnJiYGW7ZsQb9+/XDt2jW8/PLLiIuLw8mTJ9GtWzeTx125ciVefPHFDtdFRERE9kXyhdu3NoETRbFTtyPYt28f/va3v2HdunX48ccfsXPnTvzvf//DSy+9ZNgnISEB06dPx6BBgzB+/Hjs2rULALB58+YWj/vss8+ivLzc8MjNze1wjURERGT7JBtJ8vX1hVwubzZqVFhY2Gx0qT2ee+45JCUlGdY5DRo0CFVVVXjsscewdOlSyGTNc6GbmxsGDRqErKysFo+rVCqhVCo7XBcRERHZF8lGkhQKBaKjo5GWlma0PS0tDXFxcR0+bnV1dbMgJJfLIYoiRFE0+RqtVovTp08jKCiow+clIiIixyLp1W2LFi1CUlIShg8fjtjYWGzcuBE5OTmYP38+gMYprry8PGzZssXwmmPHjgEAKisrUVRUhGPHjkGhUCAyMhIAMGXKFKxevRpDhw5FTEwMzp8/j+eeew7333+/4TL/xYsXY8qUKQgNDUVhYSFefvllaDQazJkzx7r/A4iIiMhmSRqSEhMTUVJSghUrViA/Px8DBw5ESkoKwsLCADQ2j8zJyTF6zdChQw1fZ2RkYOvWrQgLC8OlS5cAAMuWLYMgCFi2bBny8vLg5+eHKVOm4G9/+5vhdVeuXMGsWbNQXFwMPz8/jBw5EkeOHDGcl4iIiEgQW5qDolZpNBqo1WqUl5fD09Pz9i8gIiIiybXn97fkV7cRERER2SKGJCIiIiITGJKIiIiITGBIIiIiIjKBIYmIiIjIBElbANgz/UWBvNEtERGR/dD/3m7Lxf0MSR1UUVEBAAgJCZG4EiIiImqviooKqNXqVvdhn6QO0ul0uHr1Kjw8PDp1Q15TNBoNQkJCkJub6/A9mPheHVdXer98r46rK73frvJeRVFERUUFgoODTd7P9Zc4ktRBMpkMPXr0sOg5PD09HfoP6i/xvTqurvR++V4dV1d6v13hvd5uBEmPC7eJiIiITGBIIiIiIjKBIckGKZVKvPDCC1AqlVKXYnF8r46rK71fvlfH1ZXeb1d6r23FhdtEREREJnAkiYiIiMgEhiQiIiIiExiSiIiIiExgSCIiIiIygSFJIuvWrUN4eDhUKhWio6Nx4MCBVvf/9ttvER0dDZVKhV69euFf//qXlSrtuJUrV2LEiBHw8PCAv78/pk6dirNnz7b6mn379kEQhGaPM2fOWKnqjlm+fHmzmgMDA1t9jT1+pno9e/Y0+TktWLDA5P729Lnu378fU6ZMQXBwMARBwGeffWb0vCiKWL58OYKDg+Hi4oKxY8fi5MmTtz3ujh07EBkZCaVSicjISHz66acWegdt19p7raurw1/+8hcMGjQIbm5uCA4OxuzZs3H16tVWj/n++++b/Kxramos/G5u73af7dy5c5vVPXLkyNse194+WwAmPyNBEPD666+3eExb/mwthSFJAsnJyVi4cCGWLl2KzMxMjBkzBgkJCcjJyTG5/8WLF3HfffdhzJgxyMzMxF//+lf86U9/wo4dO6xceft8++23WLBgAY4cOYK0tDTU19cjPj4eVVVVt33t2bNnkZ+fb3j07dvXChV3TlRUlFHNJ06caHFfe/1M9Y4ePWr0XtPS0gAAv/71r1t9nT18rlVVVRg8eDDeeustk8+/9tprWL16Nd566y0cPXoUgYGBmDBhguF+jqYcPnwYiYmJSEpKwvHjx5GUlIQZM2bgu+++s9TbaJPW3mt1dTV+/PFHPPfcc/jxxx+xc+dOnDt3Dvfff/9tj+vp6Wn0Oefn50OlUlniLbTL7T5bAJg0aZJR3SkpKa0e0x4/WwDNPp/33nsPgiBg+vTprR7XVj9bixHJ6u68805x/vz5RtsiIiLEJUuWmNz/mWeeESMiIoy2/f73vxdHjhxpsRotobCwUAQgfvvtty3us3fvXhGAeP36desVZgYvvPCCOHjw4Dbv7yifqd6TTz4p9u7dW9TpdCaft9fPFYD46aefGr7X6XRiYGCg+Morrxi21dTUiGq1WvzXv/7V4nFmzJghTpo0yWjbxIkTxZkzZ5q95o669b2a8v3334sAxMuXL7e4z6ZNm0S1Wm3e4izA1PudM2eO+MADD7TrOI7y2T7wwAPiPffc0+o+9vLZmhNHkqystrYWGRkZiI+PN9oeHx+P9PR0k685fPhws/0nTpyIH374AXV1dRar1dzKy8sBAD4+Prfdd+jQoQgKCsK9996LvXv3Wro0s8jKykJwcDDCw8Mxc+ZMZGdnt7ivo3ymQOOf6f/85z/4v//7v9ve7NkeP9dfunjxIgoKCow+O6VSibvvvrvFn1+g5c+7tdfYovLycgiCAC8vr1b3q6ysRFhYGHr06IFf/epXyMzMtE6BZrBv3z74+/ujX79+ePTRR1FYWNjq/o7w2V67dg27du3CvHnzbruvPX+2HcGQZGXFxcVoaGhAQECA0faAgAAUFBSYfE1BQYHJ/evr61FcXGyxWs1JFEUsWrQIo0ePxsCBA1vcLygoCBs3bsSOHTuwc+dO9O/fH/feey/2799vxWrbLyYmBlu2bEFqaireeecdFBQUIC4uDiUlJSb3d4TPVO+zzz5DWVkZ5s6d2+I+9vq53kr/M9qen1/969r7GltTU1ODJUuW4OGHH2715qcRERF4//338cUXX2Dbtm1QqVQYNWoUsrKyrFhtxyQkJODDDz/Enj17sGrVKhw9ehT33HMPtFpti69xhM928+bN8PDwwLRp01rdz54/245ykrqArurWf3GLotjqv8JN7W9qu6164okn8NNPP+HgwYOt7te/f3/079/f8H1sbCxyc3Pxxhtv4K677rJ0mR2WkJBg+HrQoEGIjY1F7969sXnzZixatMjka+z9M9V79913kZCQgODg4Bb3sdfPtSXt/fnt6GtsRV1dHWbOnAmdTod169a1uu/IkSONFjuPGjUKw4YNwz//+U/84x//sHSpnZKYmGj4euDAgRg+fDjCwsKwa9euVgOEPX+2APDee+/hN7/5zW3XFtnzZ9tRHEmyMl9fX8jl8mb/yigsLGz2rxG9wMBAk/s7OTmhW7duFqvVXP74xz/iiy++wN69e9GjR492v37kyJF29y8VNzc3DBo0qMW67f0z1bt8+TJ2796NRx55pN2vtcfPVX/FYnt+fvWva+9rbEVdXR1mzJiBixcvIi0trdVRJFNkMhlGjBhhd5810DgCGhYW1mrt9vzZAsCBAwdw9uzZDv0M2/Nn21YMSVamUCgQHR1tuBpILy0tDXFxcSZfExsb22z/r7/+GsOHD4ezs7PFau0sURTxxBNPYOfOndizZw/Cw8M7dJzMzEwEBQWZuTrL0mq1OH36dIt12+tneqtNmzbB398fkydPbvdr7fFzDQ8PR2BgoNFnV1tbi2+//bbFn1+g5c+7tdfYAn1AysrKwu7duzsU4EVRxLFjx+zuswaAkpIS5Obmtlq7vX62eu+++y6io6MxePDgdr/Wnj/bNpNqxXhX9tFHH4nOzs7iu+++K546dUpcuHCh6ObmJl66dEkURVFcsmSJmJSUZNg/OztbdHV1FZ966inx1KlT4rvvvis6OzuLn3zyiVRvoU0ef/xxUa1Wi/v27RPz8/MNj+rqasM+t77XN998U/z000/Fc+fOiT///LO4ZMkSEYC4Y8cOKd5Cmz399NPivn37xOzsbPHIkSPir371K9HDw8PhPtNfamhoEENDQ8W//OUvzZ6z58+1oqJCzMzMFDMzM0UA4urVq8XMzEzDFV2vvPKKqFarxZ07d4onTpwQZ82aJQYFBYkajcZwjKSkJKOrVQ8dOiTK5XLxlVdeEU+fPi2+8soropOTk3jkyBGrv79fau291tXViffff7/Yo0cP8dixY0Y/w1qt1nCMW9/r8uXLxa+++kq8cOGCmJmZKf7ud78TnZycxO+++06Kt2iktfdbUVEhPv3002J6erp48eJFce/evWJsbKzYvXt3h/ts9crLy0VXV1dx/fr1Jo9hT5+tpTAkSeTtt98Ww8LCRIVCIQ4bNszosvg5c+aId999t9H++/btE4cOHSoqFAqxZ8+eLf6htiUATD42bdpk2OfW9/rqq6+KvXv3FlUqlejt7S2OHj1a3LVrl/WLb6fExEQxKChIdHZ2FoODg8Vp06aJJ0+eNDzvKJ/pL6WmpooAxLNnzzZ7zp4/V327glsfc+bMEUWxsQ3ACy+8IAYGBopKpVK86667xBMnThgd4+677zbsr7d9+3axf//+orOzsxgREWETAbG193rx4sUWf4b37t1rOMat73XhwoViaGioqFAoRD8/PzE+Pl5MT0+3/pszobX3W11dLcbHx4t+fn6is7OzGBoaKs6ZM0fMyckxOoYjfLZ6GzZsEF1cXMSysjKTx7Cnz9ZSBFFsWi1KRERERAZck0RERERkAkMSERERkQkMSUREREQmMCQRERERmcCQRERERGQCQxIRERGRCQxJRERERCYwJBERERGZwJBERGQmgiDgs88+k7oMIjIThiQicghz586FIAjNHpMmTZK6NCKyU05SF0BEZC6TJk3Cpk2bjLYplUqJqiEie8eRJCJyGEqlEoGBgUYPb29vAI1TYevXr0dCQgJcXFwQHh6O7du3G73+xIkTuOeee+Di4oJu3brhscceQ2VlpdE+7733HqKioqBUKhEUFIQnnnjC6Pni4mI8+OCDcHV1Rd++ffHFF19Y9k0TkcUwJBFRl/Hcc89h+vTpOH78OH77299i1qxZOH36NACguroakyZNgre3N44ePYrt27dj9+7dRiFo/fr1WLBgAR577DGcOHECX3zxBfr06WN0jhdffBEzZszATz/9hPvuuw+/+c1vUFpaatX3SURmIhIROYA5c+aIcrlcdHNzM3qsWLFCFEVRBCDOnz/f6DUxMTHi448/LoqiKG7cuFH09vYWKysrDc/v2rVLlMlkYkFBgSiKohgcHCwuXbq0xRoAiMuWLTN8X1lZKQqCIH755Zdme59EZD1ck0REDmPcuHFYv3690TYfHx/D17GxsUbPxcbG4tixYwCA06dPY/DgwXBzczM8P2rUKOh0Opw9exaCIODq1au49957W63hjjvuMHzt5uYGDw8PFBYWdvQtEZGEGJKIyGG4ubk1m/66HUEQAACiKBq+NrWPi4tLm47n7Ozc7LU6na5dNRGRbeCaJCLqMo4cOdLs+4iICABAZGQkjh07hqqqKsPzhw4dgkwmQ79+/eDh4YGePXvim2++sWrNRCQdjiQRkcPQarUoKCgw2ubk5ARfX18AwPbt2zF8+HCMHj0aH374Ib7//nu8++67AIDf/OY3eOGFFzBnzhwsX74cRUVF+OMf/4ikpCQEBAQAAJYvX4758+fD398fCQkJqKiowKFDh/DHP/7Rum+UiKyCIYmIHMZXX32FoKAgo239+/fHmTNnADReefbRRx/hD3/4AwIDA/Hhhx8iMjISAODq6orU1FQ8+eSTGDFiBFxdXTF9+nSsXr3acKw5c+agpqYGb775JhYvXgxfX1889NBD1nuDRGRVgiiKotRFEBFZmiAI+PTTTzF16lSpSyEiO8E1SUREREQmMCQRERERmcA1SUTUJXBlARG1F0eSiIiIiExgSCIiIiIygSGJiIiIyASGJCIiIiITGJKIiIiITGBIIiIiIjKBIYmIiIjIBIYkIiIiIhP+HwbGIzmf0qAhAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(p_embedder._history['loss'])\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('Epoch')" + ] + }, + { + "cell_type": "markdown", + "id": "bff1f5c5-2b32-4f89-b330-d3dda6948bec", + "metadata": {}, + "source": [ + "It is also worth noting that, due to the relatively straightforward nature of the MNIST dataset, we have achieved good results with just the default model and training regime of Parametric UMAP. Options for improving these results include:\n", + "- Using a CNN architecture instead of the default dense layers.\n", + "- Training for more epochs.\n", + "- Selecting the landmark points intelligently (e.g. points descriptive of the clusters).\n", + "- Trying different ``landmark_loss_fn`` options instead of the default euclidean distance, or different values for ``landmark_loss_weight``." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/umap/__init__.py b/umap/__init__.py index 6efb69ac..ff0ca952 100644 --- a/umap/__init__.py +++ b/umap/__init__.py @@ -4,12 +4,13 @@ try: with catch_warnings(): simplefilter("ignore") - from .parametric_umap import ParametricUMAP + from .parametric_umap import ParametricUMAP, load_ParametricUMAP except ImportError: warn( "Tensorflow not installed; ParametricUMAP will be unavailable", category=ImportWarning, ) + # Add a dummy class to raise an error class ParametricUMAP(object): def __init__(self, **kwds): diff --git a/umap/aligned_umap.py b/umap/aligned_umap.py index 317b19f8..264af457 100644 --- a/umap/aligned_umap.py +++ b/umap/aligned_umap.py @@ -103,8 +103,9 @@ def build_neighborhood_similarities(graphs_indptr, graphs_indices, relations): raw_base_graph_indices = base_graph_indices[ base_graph_indptr[k] : base_graph_indptr[k + 1] ].copy() - base_indices = relations[i, j][raw_base_graph_indices[ - raw_base_graph_indices < relations.shape[2]]] + base_indices = relations[i, j][ + raw_base_graph_indices[raw_base_graph_indices < relations.shape[2]] + ] base_indices = base_indices[base_indices >= 0] comparison_indices = comparison_graph_indices[ comparison_graph_indptr[comparison_index] : comparison_graph_indptr[ @@ -169,11 +170,11 @@ def set_aligned_params(new_params, existing_params, n_models, param_names=PARAM_ if isinstance(existing_params[param], list): existing_params[param].append(new_params[param]) elif isinstance(existing_params[param], tuple): - existing_params[param] = existing_params[param] + \ - (new_params[param],) + existing_params[param] = existing_params[param] + (new_params[param],) elif isinstance(existing_params[param], np.ndarray): - existing_params[param] = np.append(existing_params[param], - new_params[param]) + existing_params[param] = np.append( + existing_params[param], new_params[param] + ) else: if new_params[param] != existing_params[param]: existing_params[param] = (existing_params[param],) * n_models + ( @@ -472,7 +473,7 @@ def update(self, X, y=None, **fit_params): self.repulsion_strength, self.n_models_ ), learning_rate=get_nth_item_or_val(self.learning_rate, self.n_models_), - init=self.init, + init=self.init, spread=get_nth_item_or_val(self.spread, self.n_models_), negative_sample_rate=get_nth_item_or_val( self.negative_sample_rate, self.n_models_ diff --git a/umap/distances.py b/umap/distances.py index 8001671d..48b490ef 100644 --- a/umap/distances.py +++ b/umap/distances.py @@ -204,8 +204,8 @@ def poincare(u, v): @numba.njit() def hyperboloid_grad(x, y): - s = np.sqrt(1 + np.sum(x ** 2)) - t = np.sqrt(1 + np.sum(y ** 2)) + s = np.sqrt(1 + np.sum(x**2)) + t = np.sqrt(1 + np.sum(y**2)) B = s * t for i in range(x.shape[0]): @@ -340,7 +340,7 @@ def canberra_grad(x, y): result += np.abs(x[i] - y[i]) / denominator grad[i] = ( np.sign(x[i] - y[i]) / denominator - - np.abs(x[i] - y[i]) * np.sign(x[i]) / denominator ** 2 + - np.abs(x[i] - y[i]) * np.sign(x[i]) / denominator**2 ) return result, grad @@ -497,7 +497,7 @@ def haversine(x, y): raise ValueError("haversine is only defined for 2 dimensional data") sin_lat = np.sin(0.5 * (x[0] - y[0])) sin_long = np.sin(0.5 * (x[1] - y[1])) - result = np.sqrt(sin_lat ** 2 + np.cos(x[0]) * np.cos(y[0]) * sin_long ** 2) + result = np.sqrt(sin_lat**2 + np.cos(x[0]) * np.cos(y[0]) * sin_long**2) return 2.0 * np.arcsin(result) @@ -514,30 +514,20 @@ def haversine_grad(x, y): sin_long = np.sin(0.5 * (x[1] - y[1])) cos_long = np.cos(0.5 * (x[1] - y[1])) - a_0 = np.cos(x[0] + np.pi / 2) * np.cos(y[0] + np.pi / 2) * sin_long ** 2 - a_1 = a_0 + sin_lat ** 2 + a_0 = np.cos(x[0] + np.pi / 2) * np.cos(y[0] + np.pi / 2) * sin_long**2 + a_1 = a_0 + sin_lat**2 d = 2.0 * np.arcsin(np.sqrt(min(max(abs(a_1), 0), 1))) denom = np.sqrt(abs(a_1 - 1)) * np.sqrt(abs(a_1)) - grad = ( - np.array( - [ - ( - sin_lat * cos_lat - - np.sin(x[0] + np.pi / 2) - * np.cos(y[0] + np.pi / 2) - * sin_long ** 2 - ), - ( - np.cos(x[0] + np.pi / 2) - * np.cos(y[0] + np.pi / 2) - * sin_long - * cos_long - ), - ] - ) - / (denom + 1e-6) - ) + grad = np.array( + [ + ( + sin_lat * cos_lat + - np.sin(x[0] + np.pi / 2) * np.cos(y[0] + np.pi / 2) * sin_long**2 + ), + (np.cos(x[0] + np.pi / 2) * np.cos(y[0] + np.pi / 2) * sin_long * cos_long), + ] + ) / (denom + 1e-6) return d, grad @@ -598,7 +588,7 @@ def cosine_grad(x, y): dist = 1.0 grad = np.zeros(x.shape) else: - grad = -(x * result - y * norm_x) / np.sqrt(norm_x ** 3 * norm_y) + grad = -(x * result - y * norm_x) / np.sqrt(norm_x**3 * norm_y) dist = 1.0 - (result / np.sqrt(norm_x * norm_y)) return dist, grad @@ -622,8 +612,8 @@ def correlation(x, y): for i in range(x.shape[0]): shifted_x = x[i] - mu_x shifted_y = y[i] - mu_y - norm_x += shifted_x ** 2 - norm_y += shifted_y ** 2 + norm_x += shifted_x**2 + norm_y += shifted_y**2 dot_product += shifted_x * shifted_y if norm_x == 0.0 and norm_y == 0.0: @@ -677,7 +667,7 @@ def hellinger_grad(x, y): dist_denom = np.sqrt(l1_norm_x * l1_norm_y) dist = np.sqrt(1 - result / dist_denom) grad_denom = 2 * dist - grad_numer_const = (l1_norm_y * result) / (2 * dist_denom ** 3) + grad_numer_const = (l1_norm_y * result) / (2 * dist_denom**3) grad = (grad_numer_const - (y / grad_term * dist_denom)) / grad_denom @@ -838,8 +828,8 @@ def correlation_grad(x, y): for i in range(x.shape[0]): shifted_x = x[i] - mu_x shifted_y = y[i] - mu_y - norm_x += shifted_x ** 2 - norm_y += shifted_y ** 2 + norm_x += shifted_x**2 + norm_y += shifted_y**2 dot_product += shifted_x * shifted_y if norm_x == 0.0 and norm_y == 0.0: @@ -889,12 +879,12 @@ def spherical_gaussian_energy_grad(x, y): # pragma: no cover sigma = np.abs(x[2]) + np.abs(y[2]) sign_sigma = np.sign(x[2]) - dist = (mu_1 ** 2 + mu_2 ** 2) / (2 * sigma) + np.log(sigma) + np.log(2 * np.pi) + dist = (mu_1**2 + mu_2**2) / (2 * sigma) + np.log(sigma) + np.log(2 * np.pi) grad = np.empty(3, np.float32) grad[0] = mu_1 / sigma grad[1] = mu_2 / sigma - grad[2] = sign_sigma * (1.0 / sigma - (mu_1 ** 2 + mu_2 ** 2) / (2 * sigma ** 2)) + grad[2] = sign_sigma * (1.0 / sigma - (mu_1**2 + mu_2**2) / (2 * sigma**2)) return dist, grad @@ -914,13 +904,13 @@ def diagonal_gaussian_energy_grad(x, y): # pragma: no cover if det == 0.0: # TODO: figure out the right thing to do here - return mu_1 ** 2 + mu_2 ** 2, np.array([0.0, 0.0, 1.0, 1.0], dtype=np.float32) + return mu_1**2 + mu_2**2, np.array([0.0, 0.0, 1.0, 1.0], dtype=np.float32) cross_term = 2 * sigma_12 m_dist = ( - np.abs(sigma_22) * (mu_1 ** 2) + np.abs(sigma_22) * (mu_1**2) - cross_term * mu_1 * mu_2 - + np.abs(sigma_11) * (mu_2 ** 2) + + np.abs(sigma_11) * (mu_2**2) ) dist = (m_dist / det + np.log(np.abs(det))) / 2.0 + np.log(2 * np.pi) @@ -928,8 +918,8 @@ def diagonal_gaussian_energy_grad(x, y): # pragma: no cover grad[0] = (2 * sigma_22 * mu_1 - cross_term * mu_2) / (2 * det) grad[1] = (2 * sigma_11 * mu_2 - cross_term * mu_1) / (2 * det) - grad[2] = sign_s1 * (sigma_22 * (det - m_dist) + det * mu_2 ** 2) / (2 * det ** 2) - grad[3] = sign_s2 * (sigma_11 * (det - m_dist) + det * mu_1 ** 2) / (2 * det ** 2) + grad[2] = sign_s1 * (sigma_22 * (det - m_dist) + det * mu_2**2) / (2 * det**2) + grad[3] = sign_s2 * (sigma_11 * (det - m_dist) + det * mu_1**2) / (2 * det**2) return dist, grad @@ -962,14 +952,14 @@ def gaussian_energy_grad(x, y): # pragma: no cover sigma_22 = x[2] * np.sin(x[4]) ** 2 + x[3] * np.cos(x[4]) ** 2 + c # Determinant of the sum of covariances - det_sigma = np.abs(sigma_11 * sigma_22 - sigma_12 ** 2) + det_sigma = np.abs(sigma_11 * sigma_22 - sigma_12**2) x_inv_sigma_y_numerator = ( - sigma_22 * mu_1 ** 2 - 2 * sigma_12 * mu_1 * mu_2 + sigma_11 * mu_2 ** 2 + sigma_22 * mu_1**2 - 2 * sigma_12 * mu_1 * mu_2 + sigma_11 * mu_2**2 ) if det_sigma < 1e-32: return ( - mu_1 ** 2 + mu_2 ** 2, + mu_1**2 + mu_2**2, np.array([0.0, 0.0, 1.0, 1.0, 0.0], dtype=np.float32), ) @@ -985,7 +975,7 @@ def gaussian_energy_grad(x, y): # pragma: no cover grad[2] -= x_inv_sigma_y_numerator * np.cos(x[4]) ** 2 * sigma_22 grad[2] -= x_inv_sigma_y_numerator * np.sin(x[4]) ** 2 * sigma_11 grad[2] += x_inv_sigma_y_numerator * 2 * sigma_12 * np.sin(x[4]) * np.cos(x[4]) - grad[2] /= det_sigma ** 2 + 1e-8 + grad[2] /= det_sigma**2 + 1e-8 grad[3] = mu_1 * (mu_1 * np.cos(x[4]) ** 2 - mu_2 * np.cos(x[4]) * np.sin(x[4])) grad[3] += mu_2 * (mu_2 * np.sin(x[4]) ** 2 - mu_1 * np.cos(x[4]) * np.sin(x[4])) @@ -993,16 +983,16 @@ def gaussian_energy_grad(x, y): # pragma: no cover grad[3] -= x_inv_sigma_y_numerator * np.sin(x[4]) ** 2 * sigma_22 grad[3] -= x_inv_sigma_y_numerator * np.cos(x[4]) ** 2 * sigma_11 grad[3] -= x_inv_sigma_y_numerator * 2 * sigma_12 * np.sin(x[4]) * np.cos(x[4]) - grad[3] /= det_sigma ** 2 + 1e-8 + grad[3] /= det_sigma**2 + 1e-8 grad[4] = (x[3] - x[2]) * ( - 2 * mu_1 * mu_2 * np.cos(2 * x[4]) - (mu_1 ** 2 - mu_2 ** 2) * np.sin(2 * x[4]) + 2 * mu_1 * mu_2 * np.cos(2 * x[4]) - (mu_1**2 - mu_2**2) * np.sin(2 * x[4]) ) grad[4] *= det_sigma grad[4] -= x_inv_sigma_y_numerator * (x[3] - x[2]) * np.sin(2 * x[4]) * sigma_22 grad[4] -= x_inv_sigma_y_numerator * (x[2] - x[3]) * np.sin(2 * x[4]) * sigma_11 grad[4] -= x_inv_sigma_y_numerator * 2 * sigma_12 * (x[2] - x[3]) * np.cos(2 * x[4]) - grad[4] /= det_sigma ** 2 + 1e-8 + grad[4] /= det_sigma**2 + 1e-8 return dist, grad @@ -1019,7 +1009,7 @@ def spherical_gaussian_grad(x, y): # pragma: no cover return 10.0, np.array([0.0, 0.0, -1.0], dtype=np.float32) dist = ( - (mu_1 ** 2 + mu_2 ** 2) / np.abs(sigma) + (mu_1**2 + mu_2**2) / np.abs(sigma) + 2 * np.log(np.abs(sigma)) + np.log(2 * np.pi) ) @@ -1027,9 +1017,7 @@ def spherical_gaussian_grad(x, y): # pragma: no cover grad[0] = (2 * mu_1) / np.abs(sigma) grad[1] = (2 * mu_2) / np.abs(sigma) - grad[2] = sigma_sign * ( - -(mu_1 ** 2 + mu_2 ** 2) / (sigma ** 2) + (2 / np.abs(sigma)) - ) + grad[2] = sigma_sign * (-(mu_1**2 + mu_2**2) / (sigma**2) + (2 / np.abs(sigma))) return dist, grad @@ -1283,7 +1271,9 @@ def chunked_parallel_special_metric(X, Y=None, metric=hellinger, chunk_size=16): return result -def pairwise_special_metric(X, Y=None, metric="hellinger", kwds=None, force_all_finite=True): +def pairwise_special_metric( + X, Y=None, metric="hellinger", kwds=None, force_all_finite=True +): if callable(metric): if kwds is not None: kwd_vals = tuple(kwds.values()) @@ -1294,7 +1284,9 @@ def pairwise_special_metric(X, Y=None, metric="hellinger", kwds=None, force_all_ def _partial_metric(_X, _Y=None): return metric(_X, _Y, *kwd_vals) - return pairwise_distances(X, Y, metric=_partial_metric, force_all_finite=force_all_finite) + return pairwise_distances( + X, Y, metric=_partial_metric, force_all_finite=force_all_finite + ) else: special_metric_func = named_distances[metric] return parallel_special_metric(X, Y, metric=special_metric_func) diff --git a/umap/parametric_umap.py b/umap/parametric_umap.py index 801e6ecf..4d6784de 100644 --- a/umap/parametric_umap.py +++ b/umap/parametric_umap.py @@ -4,7 +4,7 @@ from numba import TypingError import os from umap.spectral import spectral_layout -from sklearn.utils import check_random_state +from sklearn.utils import check_random_state, check_array import codecs, pickle from sklearn.neighbors import KDTree @@ -28,9 +28,7 @@ import keras from keras import ops except ImportError: - warn( - """The umap.parametric_umap package requires Keras >= 3 to be installed.""" - ) + warn("""The umap.parametric_umap package requires Keras >= 3 to be installed.""") raise ImportError("umap.parametric_umap requires Keras") from None torch_imported = True @@ -42,9 +40,7 @@ import torch.onnx import torchvision except ImportError: - warn( - """Torch and ONNX required for exporting to those formats.""" - ) + warn("""Torch and ONNX required for exporting to those formats.""") torch_imported = False @@ -61,8 +57,10 @@ def __init__( autoencoder_loss=False, reconstruction_validation=None, global_correlation_loss_weight=0, + landmark_loss_fn=None, + landmark_loss_weight=1.0, keras_fit_kwargs={}, - **kwargs + **kwargs, ): """ Parametric UMAP subclassing UMAP-learn, based on keras/tensorflow. @@ -92,6 +90,10 @@ def __init__( validation X data for reconstruction loss, by default None global_correlation_loss_weight : float, optional Whether to additionally train on correlation of global pairwise relationships (>0), by default 0 + landmark_loss_fn : callable, optional + The function to use for landmark loss, by default the euclidean distance + landmark_loss_weight : float, optional + How to weight the landmark loss relative to umap loss, by default 1.0 keras_fit_kwargs : dict, optional additional arguments for model.fit (like callbacks), by default {} """ @@ -110,6 +112,8 @@ def __init__( self.batch_size = batch_size self.loss_report_frequency = 10 self.global_correlation_loss_weight = global_correlation_loss_weight + self.landmark_loss_fn = landmark_loss_fn + self.landmark_loss_weight = landmark_loss_weight self.reconstruction_validation = ( reconstruction_validation # holdout data for reconstruction acc @@ -117,6 +121,12 @@ def __init__( self.keras_fit_kwargs = keras_fit_kwargs # arguments for model.fit self.parametric_model = None + # Pass the random state on to keras. This will set the numpy, + # backend, and python random seeds + # For reproducable training. + if isinstance(self.random_state, int): + keras.utils.set_random_seed(self.random_state) + # How many epochs to train for # (different than n_epochs which is specific to each sample) self.n_training_epochs = 1 @@ -136,7 +146,44 @@ def __init__( ) ) - def fit(self, X, y=None, precomputed_distances=None): + def fit(self, X, y=None, precomputed_distances=None, landmark_positions=None): + """Fit X into an embedded space. + + Optionally use a precomputed distance matrix, y for supervised + dimension reduction, or landmarked positions. + + Parameters + ---------- + X : array, shape (n_samples, n_features) + Contains a sample per row. If the method is 'exact', X may + be a sparse matrix of type 'csr', 'csc' or 'coo'. + Unlike UMAP, ParametricUMAP requires precomputed distances to + be passed seperately. + + y : array, shape (n_samples) + A target array for supervised dimension reduction. How this is + handled is determined by parameters UMAP was instantiated with. + The relevant attributes are ``target_metric`` and + ``target_metric_kwds``. + + precomputed_distances : array, shape (n_samples, n_samples), optional + A precomputed a square distance matrix. Unlike UMAP, ParametricUMAP + still requires X to be passed seperately for training. + + landmark_positions : array, shape (n_samples, n_components), optional + The desired position in low-dimensional space of each sample in X. + Points that are not landmarks should have nan coordinates. + """ + + if landmark_positions is not None: + len_X = len(X) + len_land = len(landmark_positions) + if len_X != len_land: + raise ValueError( + f"Length of x = {len_X}, length of landmark_positions \ + = {len_land}, while it must be equal." + ) + if self.metric == "precomputed": if precomputed_distances is None: raise ValueError( @@ -146,11 +193,52 @@ def fit(self, X, y=None, precomputed_distances=None): # prepare X for training the network self._X = X # geneate the graph on precomputed distances - return super().fit(precomputed_distances, y) + return super().fit( + precomputed_distances, y, landmark_positions=landmark_positions + ) + else: - return super().fit(X, y) + return super().fit(X, y, landmark_positions=landmark_positions) - def fit_transform(self, X, y=None, precomputed_distances=None): + def fit_transform( + self, X, y=None, precomputed_distances=None, landmark_positions=None + ): + """Fit X into an embedded space. + + Optionally use a precomputed distance matrix, y for supervised + dimension reduction, or landmarked positions. + + Parameters + ---------- + X : array, shape (n_samples, n_features) + Contains a sample per row. If the method is 'exact', X may + be a sparse matrix of type 'csr', 'csc' or 'coo'. + Unlike UMAP, ParametricUMAP requires precomputed distances to + be passed seperately. + + y : array, shape (n_samples) + A target array for supervised dimension reduction. How this is + handled is determined by parameters UMAP was instantiated with. + The relevant attributes are ``target_metric`` and + ``target_metric_kwds``. + + precomputed_distances : array, shape (n_samples, n_samples), optional + A precomputed a square distance matrix. Unlike UMAP, ParametricUMAP + still requires X to be passed seperately for training. + + landmark_positions : array, shape (n_samples, n_components), optional + The desired position in low-dimensional space of each sample in X. + Points that are not landmarks should have nan coordinates. + """ + + if landmark_positions is not None: + len_X = len(X) + len_land = len(landmark_positions) + if len_X != len_land: + raise ValueError( + f"Length of x = {len_X}, length of landmark_positions \ + = {len_land}, while it must be equal." + ) if self.metric == "precomputed": if precomputed_distances is None: @@ -161,29 +249,42 @@ def fit_transform(self, X, y=None, precomputed_distances=None): # prepare X for training the network self._X = X # generate the graph on precomputed distances - return super().fit_transform(precomputed_distances, y) + # landmark positions are cleaned up inside the + # .fit() component of .fit_transform() + return super().fit_transform( + precomputed_distances, y, landmark_positions=landmark_positions + ) else: - return super().fit_transform(X, y) + # landmark positions are cleaned up inside the + # .fit() component of .fit_transform() + return super().fit_transform(X, y, landmark_positions=landmark_positions) - def transform(self, X): + def transform(self, X, batch_size=None): """Transform X into the existing embedded space and return that transformed output. + Parameters ---------- X : array, shape (n_samples, n_features) New data to be transformed. + batch_size : int, optional + Batch size for inference, defaults to the self.batch_size used in training. + Returns ------- X_new : array, shape (n_samples, n_components) Embedding of the new data in low-dimensional space. """ + batch_size = batch_size if batch_size else self.batch_size + return self.encoder.predict( - np.asanyarray(X), batch_size=self.batch_size, verbose=self.verbose + np.asanyarray(X), batch_size=batch_size, verbose=self.verbose ) def inverse_transform(self, X): - """ Transform X in the existing embedded space back into the input + """Transform X in the existing embedded space back into the input data space and return that transformed output. + Parameters ---------- X : array, shape (n_samples, n_components) @@ -214,9 +315,12 @@ def _define_model(self): parametric_reconstruction_loss_weight=prlw, global_correlation_loss_weight=self.global_correlation_loss_weight, autoencoder_loss=self.autoencoder_loss, + landmark_loss_fn=self.landmark_loss_fn, + landmark_loss_weight=self.landmark_loss_weight, + optimizer=self.optimizer, ) - def _fit_embed_data(self, X, n_epochs, init, random_state): + def _fit_embed_data(self, X, n_epochs, init, random_state, landmark_positions=None): if self.metric == "precomputed": X = self._X @@ -234,6 +338,14 @@ def _fit_embed_data(self, X, n_epochs, init, random_state): "Data should be scaled to the range 0-1 for cross-entropy reconstruction loss." ) + # Make sure landmark_positions is float32. + if landmark_positions is not None: + landmark_positions = check_array( + landmark_positions, + dtype=np.float32, + force_all_finite="allow-nan", + ) + # get dataset of edges ( edge_dataset, @@ -249,31 +361,31 @@ def _fit_embed_data(self, X, n_epochs, init, random_state): self.batch_size, self.parametric_reconstruction, self.global_correlation_loss_weight, + landmark_positions=landmark_positions, ) self.head = ops.array(ops.expand_dims(head.astype(np.int64), 0)) self.tail = ops.array(ops.expand_dims(tail.astype(np.int64), 0)) - init_embedding = None - - # create encoder and decoder model - n_data = len(X) - self.encoder, self.decoder = prepare_networks( - self.encoder, - self.decoder, - self.n_components, - self.dims, - n_data, - self.parametric_reconstruction, - init_embedding, - ) + if self.parametric_model is None: + init_embedding = None + + # create encoder and decoder model + n_data = len(X) + self.encoder, self.decoder = prepare_networks( + self.encoder, + self.decoder, + self.n_components, + self.dims, + n_data, + self.parametric_reconstruction, + init_embedding, + ) - # create the model - self._define_model() + # create the model + self._define_model() # report every loss_report_frequency subdivision of an epochs - steps_per_epoch = int( - n_edges / self.batch_size / self.loss_report_frequency - ) + steps_per_epoch = int(n_edges / self.batch_size / self.loss_report_frequency) # Validation dataset for reconstruction if ( @@ -304,10 +416,14 @@ def _fit_embed_data(self, X, n_epochs, init, random_state): epochs=self.loss_report_frequency * self.n_training_epochs, steps_per_epoch=steps_per_epoch, validation_data=validation_data, - **self.keras_fit_kwargs + **self.keras_fit_kwargs, ) - # save loss history dictionary - self._history = history.history + # Add loss history from this training iteration. + if not hasattr(self, "_history"): + self._history = history.history + else: + for key in history.history.keys(): + self._history[key] += history.history[key] # get the final embedding embedding = self.encoder.predict(X, verbose=self.verbose) @@ -319,7 +435,8 @@ def __getstate__(self): return dict( (k, v) for (k, v) in self.__dict__.items() - if should_pickle(k, v) and k not in ("optimizer", "encoder", "decoder", "parametric_model") + if should_pickle(k, v) + and k not in ("optimizer", "encoder", "decoder", "parametric_model") ) def save(self, save_location, verbose=True): @@ -340,7 +457,9 @@ def save(self, save_location, verbose=True): # save parametric_model if self.parametric_model is not None: - parametric_model_output = os.path.join(save_location, "parametric_model.keras") + parametric_model_output = os.path.join( + save_location, "parametric_model.keras" + ) self.parametric_model.save(parametric_model_output) if verbose: print("Keras full model saved to {}".format(parametric_model_output)) @@ -355,8 +474,7 @@ def save(self, save_location, verbose=True): print("Pickle of ParametricUMAP model saved to {}".format(model_output)) def to_ONNX(self, save_location): - """ Exports trained parametric UMAP as ONNX. - """ + """Exports trained parametric UMAP as ONNX.""" # Extract encoder km = self.encoder # Extract weights @@ -368,6 +486,7 @@ def to_ONNX(self, save_location): # Invoke export return torch.onnx.export(pm, dummy_input, save_location) + def get_graph_elements(graph_, n_epochs): """ gets elements of graphs, weights, and number of epochs per edge @@ -530,9 +649,7 @@ def compute_cross_entropy( """ # cross entropy - attraction_term = -probabilities_graph * ops.log_sigmoid( - log_probabilities_distance - ) + attraction_term = -probabilities_graph * ops.log_sigmoid(log_probabilities_distance) # use numerically stable repellent term # Shi et al. 2022 (https://arxiv.org/abs/2111.08851) # log(1 - sigmoid(logits)) = log(sigmoid(logits)) - logits @@ -547,7 +664,6 @@ def compute_cross_entropy( return attraction_term, repellant_term, CE - def prepare_networks( encoder, decoder, @@ -623,6 +739,7 @@ def construct_edge_dataset( batch_size, parametric_reconstruction, global_correlation_loss_weight, + landmark_positions=None, ): """ Construct a tf.data.Dataset of edges, sampled by edge weight. @@ -639,25 +756,35 @@ def construct_edge_dataset( batch size parametric_reconstruction : bool Whether the decoder is parametric or non-parametric + landmark_positions : array, shape (n_samples, n_components), optional + The desired position in low-dimensional space of each sample in X. + Points that are not landmarks should have nan coordinates. """ - def gather_index(index): - return X[index] + + def gather_index(tensor, index): + return tensor[index] # if X is > 512Mb in size, we need to use a different, slower method for # batching data. gather_indices_in_python = True if X.nbytes * 1e-9 > 0.5 else False + if landmark_positions is not None: + gather_landmark_indices_in_python = ( + True if landmark_positions.nbytes * 1e-9 > 0.5 else False + ) def gather_X(edge_to, edge_from): # gather data from indexes (edges) in either numpy of tf, depending on array size if gather_indices_in_python: - edge_to_batch = tf.py_function(gather_index, [edge_to], [tf.float32])[0] - edge_from_batch = tf.py_function(gather_index, [edge_from], [tf.float32])[0] + edge_to_batch = tf.py_function(gather_index, [X, edge_to], [tf.float32])[0] + edge_from_batch = tf.py_function( + gather_index, [X, edge_from], [tf.float32] + )[0] else: edge_to_batch = tf.gather(X, edge_to) edge_from_batch = tf.gather(X, edge_from) - return edge_to_batch, edge_from_batch + return edge_to, edge_from, edge_to_batch, edge_from_batch - def get_outputs(edge_to_batch, edge_from_batch): + def get_outputs(edge_to, edge_from, edge_to_batch, edge_from_batch): outputs = {"umap": ops.repeat(0, batch_size)} if global_correlation_loss_weight > 0: outputs["global_correlation"] = edge_to_batch @@ -665,6 +792,15 @@ def get_outputs(edge_to_batch, edge_from_batch): # add reconstruction to iterator output # edge_out = ops.concatenate([edge_to_batch, edge_from_batch], axis=0) outputs["reconstruction"] = edge_to_batch + if landmark_positions is not None: + if gather_landmark_indices_in_python: + outputs["landmark_to"] = tf.py_function( + gather_index, [landmark_positions, edge_to], [tf.float32] + )[0] + else: + # Make sure we explicitly cast landmark_positions to float32, + # as it's user-provided and needs to play nice with loss functions. + outputs["landmark_to"] = tf.gather(landmark_positions, edge_to) return (edge_to_batch, edge_from_batch), outputs # get data from graph @@ -688,9 +824,7 @@ def get_outputs(edge_to_batch, edge_from_batch): edges_from_exp = edges_from_exp[shuffle_mask].astype(np.int64) # create edge iterator - edge_dataset = tf.data.Dataset.from_tensor_slices( - (edges_to_exp, edges_from_exp) - ) + edge_dataset = tf.data.Dataset.from_tensor_slices((edges_to_exp, edges_from_exp)) edge_dataset = edge_dataset.repeat() edge_dataset = edge_dataset.shuffle(10000) edge_dataset = edge_dataset.batch(batch_size, drop_remainder=True) @@ -786,17 +920,13 @@ def load_ParametricUMAP(save_location, verbose=True): # save parametric_model parametric_model_output = os.path.join(save_location, "parametric_model") if os.path.exists(parametric_model_output): - model.parametric_model = keras.models.load_model( - parametric_model_output - ) + model.parametric_model = keras.models.load_model(parametric_model_output) print("Keras full model loaded from {}".format(parametric_model_output)) return model -def covariance(x, - y=None, - keepdims=False): +def covariance(x, y=None, keepdims=False): """Adapted from TF Probability.""" x = ops.convert_to_tensor(x) # Covariance *only* uses the centered versions of x (and y). @@ -804,8 +934,7 @@ def covariance(x, if y is None: y = x - event_axis = ops.mean( - x * ops.conj(y), axis=0, keepdims=keepdims) + event_axis = ops.mean(x * ops.conj(y), axis=0, keepdims=keepdims) else: y = ops.convert_to_tensor(y, dtype=x.dtype) y = y - ops.mean(y, axis=0, keepdims=True) @@ -822,20 +951,16 @@ def covariance(x, n_samples = ops.shape(x_permed)[1] # Flatten sample_axis into one long dim. - x_permed_flat = ops.reshape( - x_permed, (n_events, n_samples)) - y_permed_flat = ops.reshape( - y_permed, (n_events, n_samples)) + x_permed_flat = ops.reshape(x_permed, (n_events, n_samples)) + y_permed_flat = ops.reshape(y_permed, (n_events, n_samples)) # Do the same for event_axis. - x_permed_flat = ops.reshape( - x_permed, (n_events, n_samples)) - y_permed_flat = ops.reshape( - y_permed, (n_events, n_samples)) + x_permed_flat = ops.reshape(x_permed, (n_events, n_samples)) + y_permed_flat = ops.reshape(y_permed, (n_events, n_samples)) # After matmul, cov.shape = batch_shape + [n_events, n_events] - cov = ops.matmul( - x_permed_flat, ops.transpose(y_permed_flat)) / ops.cast( - n_samples, x.dtype) + cov = ops.matmul(x_permed_flat, ops.transpose(y_permed_flat)) / ops.cast( + n_samples, x.dtype + ) cov = ops.reshape( cov, @@ -860,16 +985,11 @@ def covariance(x, return cov -def correlation(x, - y=None, - keepdims=False): +def correlation(x, y=None, keepdims=False): x = x / ops.std(x, axis=0, keepdims=True) if y is not None: y = y / ops.std(y, axis=0, keepdims=True) - return covariance( - x=x, - y=y, - keepdims=keepdims) + return covariance(x=x, y=y, keepdims=keepdims) class StopGradient(keras.layers.Layer): @@ -877,20 +997,30 @@ def call(self, x): return ops.stop_gradient(x) +def _default_landmark_loss(y, y_pred): + # Euclidean distance between points. + # Relu activation smooths gradients. + return keras.activations.relu(ops.mean(ops.norm(y_pred - y, axis=1))) + + class UMAPModel(keras.Model): - def __init__(self, - umap_loss_a, - umap_loss_b, - negative_sample_rate, - encoder, - decoder, - optimizer=None, - parametric_reconstruction_loss_fn=None, - parametric_reconstruction=False, - parametric_reconstruction_loss_weight=1., - global_correlation_loss_weight=0., - autoencoder_loss=False, - name="umap_model"): + def __init__( + self, + umap_loss_a, + umap_loss_b, + negative_sample_rate, + encoder, + decoder, + optimizer=None, + parametric_reconstruction_loss_fn=None, + parametric_reconstruction=False, + parametric_reconstruction_loss_weight=1.0, + global_correlation_loss_weight=0.0, + autoencoder_loss=False, + landmark_loss_fn=None, + landmark_loss_weight=1.0, + name="umap_model", + ): super().__init__(name=name) self.encoder = encoder @@ -904,6 +1034,8 @@ def __init__(self, self.umap_loss_a = umap_loss_a self.umap_loss_b = umap_loss_b self.autoencoder_loss = autoencoder_loss + self.landmark_loss_fn = landmark_loss_fn + self.landmark_loss_weight = landmark_loss_weight optimizer = optimizer or keras.optimizers.Adam(1e-3, clipvalue=4.0) self.compile(optimizer=optimizer) @@ -915,9 +1047,12 @@ def __init__(self, from_logits=True ) else: - self.parametric_reconstruction_loss_fn = ( - parametric_reconstruction_loss_fn - ) + self.parametric_reconstruction_loss_fn = parametric_reconstruction_loss_fn + + if landmark_loss_fn is None: + self.landmark_loss_fn = _default_landmark_loss + else: + self.landmark_loss_fn = landmark_loss_fn def call(self, inputs): to_x, from_x = inputs @@ -938,9 +1073,7 @@ def call(self, inputs): y_pred["reconstruction"] = embedding_to_recon return y_pred - def compute_loss( - self, x=None, y=None, y_pred=None, sample_weight=None, **kwargs - ): + def compute_loss(self, x=None, y=None, y_pred=None, sample_weight=None, **kwargs): losses = [] # Regularization losses. for loss in self.losses: @@ -957,6 +1090,10 @@ def compute_loss( if self.parametric_reconstruction: losses.append(self._parametric_reconstruction_loss(y, y_pred)) + # landmark loss, present if landmarks are provided in fit() or fit_transform() + if "landmark_to" in y: + losses.append(self._landmark_loss(y, y_pred)) + return ops.sum(losses) def _umap_loss(self, y_pred, repulsion_strength=1.0): @@ -970,12 +1107,11 @@ def _umap_loss(self, y_pred, repulsion_strength=1.0): repeat_neg_batch_dim = ops.shape(repeat_neg)[0] shuffled_indices = keras.random.shuffle( - ops.arange(repeat_neg_batch_dim), seed=self.seed_generator) + ops.arange(repeat_neg_batch_dim), seed=self.seed_generator + ) if keras.config.backend() == "tensorflow": - embedding_neg_from = tf.gather( - repeat_neg, shuffled_indices - ) + embedding_neg_from = tf.gather(repeat_neg, shuffled_indices) else: embedding_neg_from = repeat_neg[shuffled_indices] @@ -1000,7 +1136,7 @@ def _umap_loss(self, y_pred, repulsion_strength=1.0): ops.ones((batch_size,)), ops.zeros((batch_size * self.negative_sample_rate,)), ], - axis=0 + axis=0, ) # compute cross entropy @@ -1036,17 +1172,35 @@ def z_score(x): # compute correlation corr_d = ops.squeeze( - correlation( - x=ops.expand_dims(dx, -1), y=ops.expand_dims(dz, -1) - ) + correlation(x=ops.expand_dims(dx, -1), y=ops.expand_dims(dz, -1)) ) return -corr_d * self.global_correlation_loss_weight def _parametric_reconstruction_loss(self, y, y_pred): loss = self.parametric_reconstruction_loss_fn( - y["reconstruction"], y_pred["reconstruction"]) + y["reconstruction"], y_pred["reconstruction"] + ) return loss * self.parametric_reconstruction_loss_weight + def _landmark_loss(self, y, y_pred): + y_to = y["landmark_to"] + + # Euclidean distance between y and y_pred, ignoring nans. + # Before computing difference, replace all predicted and + # landmark embeddings with 0 if there isn't a landmark. + clean_y_pred_to = ops.where( + ops.isnan(y_to), + x1=ops.zeros_like(y_pred["embedding_to"]), + x2=y_pred["embedding_to"], + ) + clean_y_to = ops.where(ops.isnan(y_to), x1=ops.zeros_like(y_to), x2=y_to) + + return ( + self.landmark_loss_fn(clean_y_to, clean_y_pred_to) + * self.landmark_loss_weight + ) + + ################################################## # 1. Pytorch version of parametric UMAP network. # ################################################## @@ -1055,7 +1209,6 @@ def _parametric_reconstruction_loss(self, y, y_pred): class PumapNet(nn.Module): - def __init__(self, indim, outdim): super(PumapNet, self).__init__() @@ -1092,7 +1245,7 @@ def forward(self, x): ###################### def weight_copier(km, pm): - """ Copies weights from a parametric UMAP encoder to pytorch. + """Copies weights from a parametric UMAP encoder to pytorch. Parameters ---------- km : encoder extracted from parametric UMAP. @@ -1103,18 +1256,18 @@ def weight_copier(km, pm): Net with copied weights. """ kweights = km.get_weights() - n_layers = int(len(kweights)/2) # The actual number of layers + n_layers = int(len(kweights) / 2) # The actual number of layers # Get the names of the pytorch layers all_keys = [x for x in pm.state_dict().keys()] - pm_names = [all_keys[2*i].split(".")[0] for i in range(4)] + pm_names = [all_keys[2 * i].split(".")[0] for i in range(4)] # Set a variable for the state dict pyt_state_dict = pm.state_dict() for i in range(n_layers): - pyt_state_dict[pm_names[i] + ".bias"] = kweights[2*i + 1] - pyt_state_dict[pm_names[i] + ".weight"] = np.transpose(kweights[2*i]) + pyt_state_dict[pm_names[i] + ".bias"] = kweights[2 * i + 1] + pyt_state_dict[pm_names[i] + ".weight"] = np.transpose(kweights[2 * i]) for key in pyt_state_dict.keys(): pyt_state_dict[key] = torch.from_numpy(pyt_state_dict[key]) @@ -1122,5 +1275,6 @@ def weight_copier(km, pm): # Update pm.load_state_dict(pyt_state_dict) return pm + else: pass diff --git a/umap/plot.py b/umap/plot.py index 0c872f00..51be1d57 100755 --- a/umap/plot.py +++ b/umap/plot.py @@ -206,9 +206,10 @@ def _nhood_compare(indices_left, indices_right): result = np.empty(indices_left.shape[0]) for i in range(indices_left.shape[0]): - with numba.objmode(intersection_size='intp'): - intersection_size = np.intersect1d(indices_left[i], indices_right[i], - assume_unique=True).shape[0] + with numba.objmode(intersection_size="intp"): + intersection_size = np.intersect1d( + indices_left[i], indices_right[i], assume_unique=True + ).shape[0] union_size = np.unique(np.hstack((indices_left[i], indices_right[i]))).shape[0] result[i] = float(intersection_size) / float(union_size) @@ -264,7 +265,6 @@ def _datashade_points( show_legend=True, alpha=255, ): - """Use datashader to plot points""" extent = _get_extent(points) canvas = ds.Canvas( @@ -1466,7 +1466,11 @@ def interactive( width=width, height=height, tooltips=None if not tooltip_needed else tooltips, - tools=tools if tools is not None else "pan,wheel_zoom,box_zoom,save,reset,help", + tools=( + tools + if tools is not None + else "pan,wheel_zoom,box_zoom,save,reset,help" + ), background_fill_color=background, ) plot.circle( @@ -1546,9 +1550,7 @@ def interactive( "be displayed. Sorry; try subsampling your data." ) if interactive_text_search: - warn( - "Too many points for text search." "Sorry; try subsampling your data." - ) + warn("Too many points for text search." "Sorry; try subsampling your data.") if alpha is not None: warn("Alpha parameter will not be applied on holoviews plots") hv.extension("bokeh") diff --git a/umap/sparse.py b/umap/sparse.py index f834e7b6..bb683411 100644 --- a/umap/sparse.py +++ b/umap/sparse.py @@ -13,6 +13,7 @@ locale.setlocale(locale.LC_NUMERIC, "C") + # Just reproduce a simpler version of numpy unique (not numba supported yet) @numba.njit() def arr_unique(arr): @@ -464,10 +465,10 @@ def sparse_correlation(ind1, data1, ind2, data2, n_features): shifted_data2[i] = data2[i] - mu_y norm1 = np.sqrt( - (norm(shifted_data1) ** 2) + (n_features - ind1.shape[0]) * (mu_x ** 2) + (norm(shifted_data1) ** 2) + (n_features - ind1.shape[0]) * (mu_x**2) ) norm2 = np.sqrt( - (norm(shifted_data2) ** 2) + (n_features - ind2.shape[0]) * (mu_y ** 2) + (norm(shifted_data2) ** 2) + (n_features - ind2.shape[0]) * (mu_y**2) ) dot_prod_inds, dot_prod_data = sparse_mul(ind1, shifted_data1, ind2, shifted_data2) diff --git a/umap/spectral.py b/umap/spectral.py index 77bd48e3..4b11d533 100644 --- a/umap/spectral.py +++ b/umap/spectral.py @@ -153,7 +153,7 @@ def multi_component_layout( metric_kwds={}, init="random", tol=0.0, - maxiter=0 + maxiter=0, ): """Specialised layout algorithm for dealing with graphs with many connected components. This will first find relative positions for the components by spectrally embedding @@ -249,7 +249,7 @@ def multi_component_layout( metric_kwds=metric_kwds, init=init, tol=tol, - maxiter=maxiter + maxiter=maxiter, ) expansion = data_range / np.max(np.abs(component_embedding)) component_embedding *= expansion @@ -268,7 +268,7 @@ def spectral_layout( metric="euclidean", metric_kwds={}, tol=0.0, - maxiter=0 + maxiter=0, ): """ Given a graph compute the spectral embedding of the graph. This is @@ -310,7 +310,7 @@ def spectral_layout( metric_kwds=metric_kwds, init="random", tol=tol, - maxiter=maxiter + maxiter=maxiter, ) @@ -323,7 +323,7 @@ def tswspectral_layout( metric_kwds={}, method=None, tol=0.0, - maxiter=0 + maxiter=0, ): """Given a graph, compute the spectral embedding of the graph. This is simply the eigenvectors of the Laplacian of the graph. Here we use the @@ -388,7 +388,7 @@ def tswspectral_layout( init="tsvd", method=method, tol=tol, - maxiter=maxiter + maxiter=maxiter, ) @@ -402,7 +402,7 @@ def _spectral_layout( init="random", method=None, tol=0.0, - maxiter=0 + maxiter=0, ): """General implementation of the spectral embedding of the graph, derived as a subset of the eigenvectors of the normalized Laplacian of the graph. The numerical @@ -481,9 +481,7 @@ def _spectral_layout( # L = D - graph # Normalized Laplacian I = scipy.sparse.identity(graph.shape[0], dtype=np.float64) - D = scipy.sparse.spdiags( - 1.0 / sqrt_deg, 0, graph.shape[0], graph.shape[0] - ) + D = scipy.sparse.spdiags(1.0 / sqrt_deg, 0, graph.shape[0], graph.shape[0]) L = I - D * graph * D if not scipy.sparse.issparse(L): L = np.asarray(L) @@ -532,14 +530,14 @@ def _spectral_layout( warnings.filterwarnings( category=UserWarning, message=r"(?ms).*not reaching the requested tolerance", - action="error" + action="error", ) eigenvalues, eigenvectors = scipy.sparse.linalg.lobpcg( L, np.asarray(X), largest=False, tol=tol or 1e-4, - maxiter=maxiter or 5 * graph.shape[0] + maxiter=maxiter or 5 * graph.shape[0], ) else: raise ValueError("Method should either be None, 'eigsh' or 'lobpcg'") diff --git a/umap/tests/test_aligned_umap.py b/umap/tests/test_aligned_umap.py index b55f14cc..3e2642bf 100644 --- a/umap/tests/test_aligned_umap.py +++ b/umap/tests/test_aligned_umap.py @@ -59,9 +59,9 @@ def test_aligned_update_params(aligned_iris, aligned_iris_relations): n_neighbors = [15, 15, 15, 15, 15] small_aligned_model = AlignedUMAP(n_neighbors=n_neighbors[:3]) small_aligned_model.fit(data[:3], relations=aligned_iris_relations[:2]) - small_aligned_model.update(data[3], - relations=aligned_iris_relations[2], - n_neighbors=n_neighbors[3]) + small_aligned_model.update( + data[3], relations=aligned_iris_relations[2], n_neighbors=n_neighbors[3] + ) for i, slice in enumerate(data[:4]): data_dmat = pairwise_distances(slice) true_nn = np.argsort(data_dmat, axis=1)[:, :10] @@ -69,6 +69,7 @@ def test_aligned_update_params(aligned_iris, aligned_iris_relations): embd_nn = np.argsort(embd_dmat, axis=1)[:, :10] assert nn_accuracy(true_nn, embd_nn) >= 0.45 + @pytest.mark.skip(reason="Temporarily disable") def test_aligned_update_array_error(aligned_iris, aligned_iris_relations): data, target = aligned_iris @@ -77,6 +78,6 @@ def test_aligned_update_array_error(aligned_iris, aligned_iris_relations): small_aligned_model.fit(data[:3], relations=aligned_iris_relations[:2]) with pytest.raises(ValueError): - small_aligned_model.update(data[3:], - relations=aligned_iris_relations[2:], - n_neighbors=n_neighbors[3:]) + small_aligned_model.update( + data[3:], relations=aligned_iris_relations[2:], n_neighbors=n_neighbors[3:] + ) diff --git a/umap/tests/test_data_input.py b/umap/tests/test_data_input.py index ff329a1d..fa6cb5fe 100644 --- a/umap/tests/test_data_input.py +++ b/umap/tests/test_data_input.py @@ -63,8 +63,8 @@ def call_umap_functions(data, force_all_finite): call_umap_functions(all_finite_data, None) call_umap_functions(all_finite_data, True) - call_umap_functions(nan_data, 'allow-nan') - call_umap_functions(all_finite_data, 'allow-nan') + call_umap_functions(nan_data, "allow-nan") + call_umap_functions(all_finite_data, "allow-nan") call_umap_functions(inf_data, False) call_umap_functions(inf_nan_data, False) @@ -81,5 +81,5 @@ def call_umap_functions(data, force_all_finite): call_umap_functions(inf_data, True) call_umap_functions(inf_nan_data, True) - call_umap_functions(inf_data, 'allow-nan') - call_umap_functions(inf_nan_data, 'allow-nan') + call_umap_functions(inf_data, "allow-nan") + call_umap_functions(inf_nan_data, "allow-nan") diff --git a/umap/tests/test_parametric_umap.py b/umap/tests/test_parametric_umap.py index bf349fad..61dfff0b 100644 --- a/umap/tests/test_parametric_umap.py +++ b/umap/tests/test_parametric_umap.py @@ -16,7 +16,10 @@ from umap.parametric_umap import ParametricUMAP, load_ParametricUMAP tf_only = pytest.mark.skipif(not IMPORT_TF, reason="TensorFlow >= 2.0 is not installed") -not_windows = pytest.mark.skipif(platform.system() == "Windows", reason="Windows file access issues") +not_windows = pytest.mark.skipif( + platform.system() == "Windows", reason="Windows file access issues" +) + @pytest.fixture(scope="session") def moon_dataset(): @@ -59,6 +62,7 @@ def norm(x): assert X_r is not None assert X_r.shape == X.shape + @tf_only def test_custom_encoder_decoder(moon_dataset): """test using a custom encoder / decoder""" diff --git a/umap/tests/test_spectral.py b/umap/tests/test_spectral.py index 6891b2b1..f3f53aa3 100644 --- a/umap/tests/test_spectral.py +++ b/umap/tests/test_spectral.py @@ -6,12 +6,15 @@ from scipy.version import full_version as scipy_full_version_ from warnings import catch_warnings -scipy_full_version = tuple(int(n) for n in re.findall(r'[0-9]+\.[0-9]+\.?[0-9]*', scipy_full_version_)[0].split(".")) +scipy_full_version = tuple( + int(n) + for n in re.findall(r"[0-9]+\.[0-9]+\.?[0-9]*", scipy_full_version_)[0].split(".") +) @pytest.mark.skipif( scipy_full_version < (1, 10), - reason="SciPy installing with Python 3.7 does not converge under same circumstances" + reason="SciPy installing with Python 3.7 does not converge under same circumstances", ) def test_tsw_spectral_init(iris): # create an arbitrary (dense) random affinity matrix @@ -22,8 +25,8 @@ def test_tsw_spectral_init(iris): graph = rng.standard_normal(n * n).reshape((n, n)) ** 2 graph = graph.T * graph - spec = spectral_layout(None, graph, 2, random_state=seed ** 2) - tsw_spec = tswspectral_layout(None, graph, 2, random_state=seed ** 2, tol=1e-8) + spec = spectral_layout(None, graph, 2, random_state=seed**2) + tsw_spec = tswspectral_layout(None, graph, 2, random_state=seed**2, tol=1e-8) # Make sure the two methods produce similar embeddings. rmsd = np.mean(np.sum((spec - tsw_spec) ** 2, axis=1)) @@ -34,7 +37,7 @@ def test_tsw_spectral_init(iris): @pytest.mark.skipif( scipy_full_version < (1, 10), - reason="SciPy installing with Py 3.7 does not warn reliably on convergence failure" + reason="SciPy installing with Py 3.7 does not warn reliably on convergence failure", ) def test_ensure_fallback_to_random_on_spectral_failure(): dim = 1000 @@ -44,8 +47,5 @@ def test_ensure_fallback_to_random_on_spectral_failure(): y = np.eye(dim, k=1) u = np.random.random((dim, dim // 10)) graph = y + y.T + u @ u.T - with pytest.warns( - UserWarning, - match="Spectral initialisation failed!" - ): + with pytest.warns(UserWarning, match="Spectral initialisation failed!"): tswspectral_layout(u, graph, k, random_state=42, maxiter=2, method="lobpcg") diff --git a/umap/tests/test_umap_get_feature_names_out.py b/umap/tests/test_umap_get_feature_names_out.py index 804d20b7..432c251a 100644 --- a/umap/tests/test_umap_get_feature_names_out.py +++ b/umap/tests/test_umap_get_feature_names_out.py @@ -8,8 +8,10 @@ def test_get_feature_names_out_passthrough(): umap = UMAP() # get_feature_names_out should return same names if feature are passed in directly. - example_passthrough = ['feature1', 'feature2'] - passthrough_result = umap.get_feature_names_out(feature_names_out=example_passthrough) + example_passthrough = ["feature1", "feature2"] + passthrough_result = umap.get_feature_names_out( + feature_names_out=example_passthrough + ) assert example_passthrough == passthrough_result @@ -48,6 +50,13 @@ def test_get_feature_names_out_featureunion(): pipeline.fit(X) feature_names = pipeline.get_feature_names_out() - expected_feature_names = np.array(["umap1__umap_component_1", "umap1__umap_component_2", "umap2__umap_component_1", - "umap2__umap_component_2", "umap2__umap_component_3"]) + expected_feature_names = np.array( + [ + "umap1__umap_component_1", + "umap1__umap_component_2", + "umap2__umap_component_1", + "umap2__umap_component_2", + "umap2__umap_component_3", + ] + ) np.testing.assert_array_equal(feature_names, expected_feature_names) diff --git a/umap/tests/test_umap_metrics.py b/umap/tests/test_umap_metrics.py index 2531d43a..39d23366 100644 --- a/umap/tests/test_umap_metrics.py +++ b/umap/tests/test_umap_metrics.py @@ -10,7 +10,10 @@ import pytest -scipy_full_version = tuple(int(n) for n in re.findall(r'[0-9]+\.[0-9]+\.?[0-9]*', scipy_full_version_)[0].split(".")) +scipy_full_version = tuple( + int(n) + for n in re.findall(r"[0-9]+\.[0-9]+\.?[0-9]*", scipy_full_version_)[0].split(".") +) # =================================================== @@ -125,7 +128,9 @@ def sparse_spatial_check(metric, sparse_spatial_data): assert ( metric in spdist.sparse_named_distances ), f"{metric} not supported for sparse data" - dist_matrix = pairwise_distances(np.asarray(sparse_spatial_data.todense()), metric=metric) + dist_matrix = pairwise_distances( + np.asarray(sparse_spatial_data.todense()), metric=metric + ) if metric in ("braycurtis", "dice", "sokalsneath", "yule"): dist_matrix[np.where(~np.isfinite(dist_matrix))] = 0.0 @@ -144,7 +149,9 @@ def sparse_binary_check(metric, sparse_binary_data): assert ( metric in spdist.sparse_named_distances ), f"{metric} not supported for sparse data" - dist_matrix = pairwise_distances(np.asarray(sparse_binary_data.todense()), metric=metric) + dist_matrix = pairwise_distances( + np.asarray(sparse_binary_data.todense()), metric=metric + ) if metric in ("jaccard", "dice", "sokalsneath", "yule"): dist_matrix[np.where(~np.isfinite(dist_matrix))] = 0.0 @@ -344,6 +351,7 @@ def test_seuclidean(spatial_data): err_msg="Distances don't match " "for metric seuclidean", ) + @pytest.mark.skipif( scipy_full_version < (1, 8), reason="incorrect function in scipy<1.8" ) @@ -508,9 +516,9 @@ def test_grad_metrics_match_metrics(spatial_data, spatial_distances): test_matrix = np.array( [ [ - dist.weighted_minkowski_grad(spatial_data[i], spatial_data[j], v, p=3)[ - 0 - ] + dist.weighted_minkowski_grad( + spatial_data[i], spatial_data[j], v, p=3 + )[0] for j in range(spatial_data.shape[0]) ] for i in range(spatial_data.shape[0]) diff --git a/umap/tests/test_umap_nn.py b/umap/tests/test_umap_nn.py index 1a131c60..96d80a3e 100644 --- a/umap/tests/test_umap_nn.py +++ b/umap/tests/test_umap_nn.py @@ -15,6 +15,7 @@ # Nearest Neighbour Test cases # =================================================== + # nearest_neighbours metric parameter validation # ----------------------------------------------- def test_nn_bad_metric(nn_data): diff --git a/umap/tests/test_umap_on_iris.py b/umap/tests/test_umap_on_iris.py index 673ac58c..d91fe9a1 100644 --- a/umap/tests/test_umap_on_iris.py +++ b/umap/tests/test_umap_on_iris.py @@ -23,6 +23,7 @@ # UMAP Test cases on IRIS Dataset # =================================================== + # UMAP Trustworthiness on iris # ---------------------------- def test_umap_trustworthiness_on_iris(iris, iris_model): @@ -281,5 +282,6 @@ def rms(a, b): ).fit(data) assert len(record) >= 1 np.testing.assert_array_equal( - fitter_ignoring_force_approx_True.embedding_, fitter_ignoring_force_approx.embedding_ + fitter_ignoring_force_approx_True.embedding_, + fitter_ignoring_force_approx.embedding_, ) diff --git a/umap/tests/test_umap_ops.py b/umap/tests/test_umap_ops.py index 7a95bde9..15597ba8 100644 --- a/umap/tests/test_umap_ops.py +++ b/umap/tests/test_umap_ops.py @@ -116,7 +116,7 @@ def test_disconnected_data(num_isolates, metric, force_approximation): new_columns[10 + i, i] = True disconnected_data = np.hstack([disconnected_data, new_columns]) - with warnings.catch_warnings(record=True) as w: + with warnings.catch_warnings(record=True) as w: model = UMAP( n_neighbors=3, metric=metric, diff --git a/umap/tests/test_umap_repeated_data.py b/umap/tests/test_umap_repeated_data.py index 29f82be4..2d2bf973 100644 --- a/umap/tests/test_umap_repeated_data.py +++ b/umap/tests/test_umap_repeated_data.py @@ -83,6 +83,7 @@ def test_repeated_points_small_dense_binary(binary_repeats): # Repeated Data Test cases # =================================================== + # ---------------------------------------------------- # This should test whether the n_neighbours are being # reduced properly when your n_neighbours is larger diff --git a/umap/tests/test_umap_trustworthiness.py b/umap/tests/test_umap_trustworthiness.py index 945c0c6e..ab0bd876 100644 --- a/umap/tests/test_umap_trustworthiness.py +++ b/umap/tests/test_umap_trustworthiness.py @@ -127,7 +127,7 @@ def test_discrete_metric_supervised_umap_trustworthiness(): def test_count_metric_supervised_umap_trustworthiness(): data, labels = make_blobs(50, cluster_std=0.5, random_state=42) - labels = (labels ** 2) + 2 * labels + labels = (labels**2) + 2 * labels embedding = UMAP( n_neighbors=10, min_dist=0.01, diff --git a/umap/tests/test_umap_validation_params.py b/umap/tests/test_umap_validation_params.py index 7617a7b9..f5b4737e 100644 --- a/umap/tests/test_umap_validation_params.py +++ b/umap/tests/test_umap_validation_params.py @@ -147,11 +147,7 @@ def test_umap_haversine_embed_to_highd(nn_data): def test_umap_too_many_neighbors_warns(nn_data): u = UMAP(a=1.2, b=1.75, n_neighbors=2000, n_epochs=11, init="random") - u.fit( - nn_data[ - :100, - ] - ) + u.fit(nn_data[:100,]) assert u._a == 1.2 assert u._b == 1.75 diff --git a/umap/umap_.py b/umap/umap_.py index 3745cf1d..f5fef0d2 100644 --- a/umap/umap_.py +++ b/umap/umap_.py @@ -736,10 +736,12 @@ def reprocess_row(probabilities, k=15, n_iters=32): @numba.njit() def reset_local_metrics(simplicial_set_indptr, simplicial_set_data): for i in range(simplicial_set_indptr.shape[0] - 1): - simplicial_set_data[ - simplicial_set_indptr[i] : simplicial_set_indptr[i + 1] - ] = reprocess_row( - simplicial_set_data[simplicial_set_indptr[i] : simplicial_set_indptr[i + 1]] + simplicial_set_data[simplicial_set_indptr[i] : simplicial_set_indptr[i + 1]] = ( + reprocess_row( + simplicial_set_data[ + simplicial_set_indptr[i] : simplicial_set_indptr[i + 1] + ] + ) ) return @@ -1242,7 +1244,11 @@ def simplicial_set_embedding( print(ts() + " Computing embedding densities") # Compute graph in embedding - (knn_indices, knn_dists, rp_forest,) = nearest_neighbors( + ( + knn_indices, + knn_dists, + rp_forest, + ) = nearest_neighbors( embedding, densmap_kwds["n_neighbors"], "euclidean", @@ -1368,6 +1374,7 @@ def init_graph_transform(graph, embedding): return result + @numba.njit() def init_update(current_init, n_original_samples, indices): for i in range(n_original_samples, indices.shape[0]): @@ -1942,7 +1949,9 @@ def _dist_only(x, y, *kwds): raise ValueError("n_jobs must be a postive integer, or -1 (for all cores)") if self.n_jobs != 1 and self.random_state is not None: self.n_jobs = 1 - warn(f"n_jobs value {self.n_jobs} overridden to 1 by setting random_state. Use no seed for parallelism.") + warn( + f"n_jobs value {self.n_jobs} overridden to 1 by setting random_state. Use no seed for parallelism." + ) if self.dens_lambda < 0.0: raise ValueError("dens_lambda cannot be negative") @@ -2327,7 +2336,7 @@ def __sub__(self, other): return result - def fit(self, X, y=None, force_all_finite=True): + def fit(self, X, y=None, force_all_finite=True, **kwargs): """Fit X into an embedded space. Optionally use y for supervised dimension reduction. @@ -2351,11 +2360,22 @@ def fit(self, X, y=None, force_all_finite=True): - False: accepts np.inf, np.nan, pd.NA in array. - 'allow-nan': accepts only np.nan and pd.NA values in array. Values cannot be infinite. + + **kwargs : optional + Any additional keyword arguments are passed to _fit_embed_data. """ if self.metric in ("bit_hamming", "bit_jaccard"): - X = check_array(X, dtype=np.uint8, order="C", force_all_finite=force_all_finite) + X = check_array( + X, dtype=np.uint8, order="C", force_all_finite=force_all_finite + ) else: - X = check_array(X, dtype=np.float32, accept_sparse="csr", order="C", force_all_finite=force_all_finite) + X = check_array( + X, + dtype=np.float32, + accept_sparse="csr", + order="C", + force_all_finite=force_all_finite, + ) self._raw_data = X # Handle all the optional arguments, setting default @@ -2366,7 +2386,12 @@ def fit(self, X, y=None, force_all_finite=True): self._b = self.b if isinstance(self.init, np.ndarray): - init = check_array(self.init, dtype=np.float32, accept_sparse=False, force_all_finite=force_all_finite) + init = check_array( + self.init, + dtype=np.float32, + accept_sparse=False, + force_all_finite=force_all_finite, + ) else: init = self.init @@ -2467,9 +2492,7 @@ def fit(self, X, y=None, force_all_finite=True): if not np.all(X.diagonal() == 0): raise ValueError("Non-zero distances from samples to themselves!") if self.knn_dists is None: - self._knn_indices = np.zeros( - (X.shape[0], self.n_neighbors), dtype=int - ) + self._knn_indices = np.zeros((X.shape[0], self.n_neighbors), dtype=int) self._knn_dists = np.zeros(self._knn_indices.shape, dtype=float) for row_id in range(X.shape[0]): # Find KNNs row-by-row @@ -2542,21 +2565,21 @@ def fit(self, X, y=None, force_all_finite=True): X[index].toarray(), metric=_m, kwds=self._metric_kwds, - force_all_finite=force_all_finite + force_all_finite=force_all_finite, ) else: dmat = dist.pairwise_special_metric( X[index], metric=self._input_distance_func, kwds=self._metric_kwds, - force_all_finite=force_all_finite + force_all_finite=force_all_finite, ) else: dmat = dist.pairwise_special_metric( X[index], metric=self._input_distance_func, kwds=self._metric_kwds, - force_all_finite=force_all_finite + force_all_finite=force_all_finite, ) # set any values greater than disconnection_distance to be np.inf. # This will have no effect when _disconnection_distance is not set since it defaults to np.inf. @@ -2677,7 +2700,9 @@ def fit(self, X, y=None, force_all_finite=True): if self.target_metric == "string": y_ = y[index] else: - y_ = check_array(y, ensure_2d=False, force_all_finite=force_all_finite)[index] + y_ = check_array(y, ensure_2d=False, force_all_finite=force_all_finite)[ + index + ] if self.target_metric == "categorical": if self.target_weight < 1.0: far_dist = 2.5 * (1.0 / (1.0 - self.target_weight)) @@ -2727,10 +2752,14 @@ def fit(self, X, y=None, force_all_finite=True): y_, metric=self.target_metric, kwds=self._target_metric_kwds, - force_all_finite=force_all_finite + force_all_finite=force_all_finite, ) - (target_graph, target_sigmas, target_rhos,) = fuzzy_simplicial_set( + ( + target_graph, + target_sigmas, + target_rhos, + ) = fuzzy_simplicial_set( ydmat, target_n_neighbors, random_state, @@ -2745,7 +2774,11 @@ def fit(self, X, y=None, force_all_finite=True): ) else: # Standard case - (target_graph, target_sigmas, target_rhos,) = fuzzy_simplicial_set( + ( + target_graph, + target_sigmas, + target_rhos, + ) = fuzzy_simplicial_set( y_, target_n_neighbors, random_state, @@ -2786,6 +2819,7 @@ def fit(self, X, y=None, force_all_finite=True): epochs, init, random_state, # JH why raw data? + **kwargs, ) if self.n_epochs_list is not None: @@ -2823,9 +2857,10 @@ def fit(self, X, y=None, force_all_finite=True): return self - def _fit_embed_data(self, X, n_epochs, init, random_state): + def _fit_embed_data(self, X, n_epochs, init, random_state, **kwargs): """A method wrapper for simplicial_set_embedding that can be - replaced by subclasses. + replaced by subclasses. Arbitrary keyword arguments can be passed + through .fit() and .fit_transform(). """ return simplicial_set_embedding( X, @@ -2852,7 +2887,7 @@ def _fit_embed_data(self, X, n_epochs, init, random_state): tqdm_kwds=self.tqdm_kwds, ) - def fit_transform(self, X, y=None, force_all_finite=True): + def fit_transform(self, X, y=None, force_all_finite=True, **kwargs): """Fit X into an embedded space and return that transformed output. @@ -2874,6 +2909,8 @@ def fit_transform(self, X, y=None, force_all_finite=True): - 'allow-nan': accepts only np.nan and pd.NA values in array. Values cannot be infinite. + **kwargs : Any additional keyword arguments are passed to _fit_embed_data. + Returns ------- X_new : array, shape (n_samples, n_components) @@ -2888,7 +2925,7 @@ def fit_transform(self, X, y=None, force_all_finite=True): r_emb: array, shape (n_samples) Local radii of data points in the embedding (log-transformed). """ - self.fit(X, y, force_all_finite) + self.fit(X, y, force_all_finite, **kwargs) if self.transform_mode == "embedding": if self.output_dens: return self.embedding_, self.rad_orig_, self.rad_emb_ @@ -2930,9 +2967,17 @@ def transform(self, X, force_all_finite=True): ) # If we just have the original input then short circuit things if self.metric in ("bit_hamming", "bit_jaccard"): - X = check_array(X, dtype=np.uint8, order="C", force_all_finite=force_all_finite) + X = check_array( + X, dtype=np.uint8, order="C", force_all_finite=force_all_finite + ) else: - X = check_array(X, dtype=np.float32, accept_sparse="csr", order="C", force_all_finite=force_all_finite) + X = check_array( + X, + dtype=np.float32, + accept_sparse="csr", + order="C", + force_all_finite=force_all_finite, + ) x_hash = joblib.hash(X) if x_hash == self._input_hash: if self.transform_mode == "embedding": @@ -3007,7 +3052,7 @@ def transform(self, X, force_all_finite=True): self._raw_data.toarray(), metric=_m, kwds=self._metric_kwds, - force_all_finite=force_all_finite + force_all_finite=force_all_finite, ) else: dmat = dist.pairwise_special_metric( @@ -3015,7 +3060,7 @@ def transform(self, X, force_all_finite=True): self._raw_data, metric=self._input_distance_func, kwds=self._metric_kwds, - force_all_finite=force_all_finite + force_all_finite=force_all_finite, ) else: dmat = dist.pairwise_special_metric( @@ -3023,7 +3068,7 @@ def transform(self, X, force_all_finite=True): self._raw_data, metric=self._input_distance_func, kwds=self._metric_kwds, - force_all_finite=force_all_finite + force_all_finite=force_all_finite, ) indices = np.argpartition(dmat, self._n_neighbors)[:, : self._n_neighbors] dmat_shortened = submatrix(dmat, indices, self._n_neighbors) @@ -3304,9 +3349,17 @@ def _output_dist_only(x, y, *kwds): def update(self, X, force_all_finite=True): if self.metric in ("bit_hamming", "bit_jaccard"): - X = check_array(X, dtype=np.uint8, order="C", force_all_finite=force_all_finite) + X = check_array( + X, dtype=np.uint8, order="C", force_all_finite=force_all_finite + ) else: - X = check_array(X, dtype=np.float32, accept_sparse="csr", order="C", force_all_finite=force_all_finite) + X = check_array( + X, + dtype=np.float32, + accept_sparse="csr", + order="C", + force_all_finite=force_all_finite, + ) random_state = check_random_state(self.transform_seed) rng_state = random_state.randint(INT32_MIN, INT32_MAX, 3).astype(np.int64) @@ -3344,21 +3397,21 @@ def update(self, X, force_all_finite=True): self._raw_data.toarray(), metric=_m, kwds=self._metric_kwds, - force_all_finite=force_all_finite + force_all_finite=force_all_finite, ) else: dmat = dist.pairwise_special_metric( self._raw_data, metric=self._input_distance_func, kwds=self._metric_kwds, - force_all_finite=force_all_finite + force_all_finite=force_all_finite, ) else: dmat = dist.pairwise_special_metric( self._raw_data, metric=self._input_distance_func, kwds=self._metric_kwds, - force_all_finite=force_all_finite + force_all_finite=force_all_finite, ) self.graph_, self._sigmas, self._rhos = fuzzy_simplicial_set( dmat, @@ -3533,7 +3586,9 @@ def get_feature_names_out(self, feature_names_out=None): :return: List of descriptive names for each output variable from the fitted estimator. """ if feature_names_out is None: - feature_names_out = [f"umap_component_{i+1}" for i in range(self.n_components)] + feature_names_out = [ + f"umap_component_{i+1}" for i in range(self.n_components) + ] return feature_names_out def __repr__(self): diff --git a/umap/utils.py b/umap/utils.py index 6bdffc21..5d1f633d 100644 --- a/umap/utils.py +++ b/umap/utils.py @@ -156,7 +156,9 @@ def csr_unique(matrix, return_index=True, return_inverse=True, return_counts=Tru unique_matrix[inverse] """ lil_matrix = matrix.tolil() - rows = np.asarray([tuple(x + y) for x, y in zip(lil_matrix.rows, lil_matrix.data)], dtype=object) + rows = np.asarray( + [tuple(x + y) for x, y in zip(lil_matrix.rows, lil_matrix.data)], dtype=object + ) return_values = return_counts + return_inverse + return_index return np.unique( rows,