diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..4dbd9c2 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,45 @@ +name: run-tests + +on: + pull_request: + branches: + - main + push: + branches: + - main + +jobs: + build: + + runs-on: ubuntu-latest + strategy: + matrix: + python-version: ["3.9"] + + steps: + - uses: actions/checkout@v3 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies manually + run: | + pip install future matplotlib cartopy pandas requests seaborn jupyter-book scikit-learn ipywidgets + pip install pmagpy==4.2.106 + pip install -e ./smpsite + pip install flake8 pytest pytest-cov + - name: Lint with flake8 + run: | + # stop the build if there are Python syntax errors or undefined names + flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics + # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide + flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics + - name: Test with pytest + run: | + pytest smpsite --cov --cov-report=html:coverage_re + - name: Upload coverage reports to Codecov + uses: codecov/codecov-action@v3 + # with: + # directory: ./smpsite + env: + CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} diff --git a/.gitignore b/.gitignore index 4747af1..f833a3e 100644 --- a/.gitignore +++ b/.gitignore @@ -3,4 +3,5 @@ *.pyc *.csv *.png -*.pdf \ No newline at end of file +*.pdf +*egg-info* diff --git a/Makefile b/Makefile index 71a7372..16d236b 100644 --- a/Makefile +++ b/Makefile @@ -7,7 +7,7 @@ env : conda env create -f environment.yml conda activate paleosampling conda install ipykernel - python -m ipykernel install --user --name make-env --display-name "IPython - PaleoSampling" + python -m ipykernel install --user --name paleosampling --display-name "IPython - PaleoSampling" .PHONY : help diff --git a/README.md b/README.md index 7770e53..0846d29 100644 --- a/README.md +++ b/README.md @@ -3,9 +3,12 @@ For a detailed description of the project, take a look at [our preprint of a manuscript that is in revision at JGR](https://www.authorea.com/doi/full/10.22541/essoar.168881772.25833701). [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/PolarWandering/PaleoSampling/HEAD) -[![DOI](https://zenodo.org/badge/595793364.svg)](https://zenodo.org/badge/latestdoi/595793364) [![Jupyter Book Badge](https://jupyterbook.org/badge.svg)](https://polarwandering.github.io/PaleoSampling/) [![Build Status](https://github.com/PolarWandering/PaleoSampling/actions/workflows/book.yml/badge.svg?branch=main)](https://github.com/PolarWandering/PaleoSampling/actions/workflows/book.yml?query=branch%3Amain) +![Tests Passing](https://github.com/github/docs/actions/workflows/test.yml/badge.svg) +[![codecov](https://codecov.io/gh/PolarWandering/PaleoSampling/graph/badge.svg?token=8BCZXZV5JP)](https://codecov.io/gh/PolarWandering/PaleoSampling) +[![DOI](https://zenodo.org/badge/595793364.svg)](https://zenodo.org/badge/latestdoi/595793364) +[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![All Contributors](https://img.shields.io/github/all-contributors/PolarWandering/PaleoSampling?color=ee8449&style=flat-square)](#contributors) @@ -43,7 +46,13 @@ install all the required dependencies. Beside some standard Python dependencies, `Pmagpy` using pip and the extra installation of the module `smpsite` (included in this repository). The package `smpsite` includes all the code used to make the simulations and compute the estimated poles. -In order to install the environment, you can use conda or mamba (see [Managing Environments](https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html) for more information) with `conda env create -f environment.yml`. Alternatively, we included a `Makefile` that creates the conda environment and installs the associated iPython kernel so this environment can be accessible though Jupyter notebooks all at once. In order to use the Makefile, you need to open a terminal where the repository is located and enter +In order to install the environment, you can use conda or mamba (see [Managing Environments](https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html) for more information) with `conda env create -f environment.yml`. Once the environment is created, you can create the associated iPython kernel with +``` +python -m ipykernel install --user --name paleostats --display-name "IPython - PaleoStats" +``` +This will allow you to execute this environment directly from Jupyter notebooks. + +Alternatively, we included a `Makefile` that creates the conda environment and installs the associated iPython kernel so this environment can be accessible though Jupyter notebooks all at once. In order to use the Makefile, you need to open a terminal where the repository is located and enter ``` make env ``` @@ -56,7 +65,7 @@ or ``` pip install -e smpsite ``` -if you are working in developer mode. +if you are working in developer mode. ### Makefile diff --git a/notebooks/Sampling_comparison.ipynb b/notebooks/Sampling_comparison.ipynb index eccf52d..c5d10b1 100644 --- a/notebooks/Sampling_comparison.ipynb +++ b/notebooks/Sampling_comparison.ipynb @@ -5,25 +5,36 @@ "id": "d1dd31bc-d251-49fe-85e9-26efafac52af", "metadata": {}, "source": [ - "## Comparison of two sampling strategies\n", + "# Comparison of different sampling approaches\n", "\n", - "In this notebook we compare two sampling strategies for estimating true pole. " + "This notebook enables comparison of different sampling approaches for estimating pole position in the presence of secular variation of the geomagnetic field and within site scatter. You can use this notebook to make a comparison similar to that shown below from Figure 3s of Sapienza et al. (2023) while providing your own parameters.\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " Figure 3a: Comparison between two different sampling strategies to determine a mean paleomagnetic pole position in the presence of outliers for a fixed number of total samples (n = 100). The red histograms and curve are strategy 1 where we have one sample per site (n0 = 1), one hundred sites (N = 100) and we use the Vandamme filter. The blue histograms and curve are strategy 2 where n0 = 5, (N = 20) and we filter all the outliers (perfect detection algorithm) for (a) p_outlier = 0.10.\n", + "
\n", + "\n", + "These tools can help guide decisions about the tradeoffs between the number of site ($N$) and the number of samples per site ($n_0$) while evaluating or designing a study." + ] + }, + { + "cell_type": "markdown", + "id": "c5bfdb52", + "metadata": {}, + "source": [ + "## Import Python packages" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "262aa4fa-b0fb-4098-b9b2-a643b17a3787", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ERROR 1: PROJ: proj_create_from_database: Open of /srv/conda/envs/notebook/share/proj failed\n" - ] - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", @@ -43,73 +54,185 @@ }, { "cell_type": "markdown", - "id": "11db379a-7ec1-4b37-87d1-828d19102eff", + "id": "22560589", "metadata": {}, "source": [ - "## Setup \n", + "## Define parameters\n", "\n", - "Our goal is to estimate the paleomagnetic pole $\\mu$ for a given period of time or age. For doing so, we are going to recollec a number $n$ samples from $N$ different sites. For each site, consequence of secular variation, we are not observing directly $\\mu$, but instead $\\mu_i$ as a result of secular variations of the magnetic field. If we compute the Fisher mean $\\hat \\mu_i$ (the hat symbol will be used always for statistical inferences, in opposition to the _true_ value of the pole), then we hope that the new Fisher mean $\\hat \\mu$ of the $\\hat \\mu_i$s will give us a estimate for the paleomagnetic poles that will average out the secular variation. The question we are trying to address here is what is the best recollection design of the sample poles that will lead to a better estimation of the final paleomagnetic pole $\\mu$. \n", + "The data generation model requires that the following parameters are given:\n", + "- `site_lat` is the latitude of the study site (between 0 and 90º)\n", + "- `outlier_rate` which is the fraction of samples that are spurious (between 0.0 [0% outliers] and 1.0 [100% outliers])\n", + "- `kappa_within_site` Fisher precision parameter ($\\kappa$) for the samples within a site\n", + "- `secular_method` is the method used to estimate secular variation with the options being `\"G\"` (model G), `\"tk03\"` (TK03), or `\"Fisher\"` (Fisher distribution). If `\"Fisher\"` is chosen, a `kappa_secular` needs to be defined which is the Fisher precision parameter associated with secular variation\n", + "- `N` number of sites\n", + "- `n0` number of samples per site\n", "\n", - "We are going to compare two different strategies for estimating the paleomagnetic pole $\\mu$:\n", - "- Method 1: Compute the Fisher mean of ALL the sample points afor each site and then compute a second Fisher mean of these site vgps to obtain a final estimation of the true paleomagnetic pole.\n", - "- Method 2: Assume we are perfectly able to detect outliers, so we can repeat Method 1 after removing those sample points that are clearly ourliers. \n", + "### Enter parameters that are the same in both sampling strategies \n", "\n", - "Since we want to know what is the choice of $n$ and $N$ that will lead to the best estimation of the paleomagnetic pole, we are going to compare these two methods for different strategies. " + "`latitude`, `outlier_rate`, `kappa_within_site`, and `secular_method` make sense to define across both sampling strategies that are being compared. Let's define them in the cell below (**you can change these values to match those that are the best estimates for your study**):" ] }, { - "cell_type": "markdown", - "id": "8ea4c287-abde-4653-8ead-e98f951da9c7", + "cell_type": "code", + "execution_count": 2, + "id": "aaba708e", "metadata": {}, + "outputs": [], "source": [ - "## Simulation" + "# enter the values for the scenario you are exploring\n", + "site_lat = 30\n", + "site_long = 0\n", + "outlier_rate = 0.10\n", + "kappa_within_site = 60\n", + "secular_method = \"G\"" ] }, { "cell_type": "markdown", - "id": "1b2a5f8d-d43a-4cb3-a5a5-508f41a1d02a", + "id": "71ccdcf9", "metadata": {}, "source": [ - "We first set the parameter for the two simulations. We do this by defining an object class `Params` that has been implemented inside the package `smpsite`." + "### Enter sites and samples per site for approach 1\n", + "\n", + "Now we can set how many sites and samples per sites for approach 1 (say 100 sites with 1 sample each for a total of 100 samples):" ] }, { "cell_type": "code", "execution_count": 3, - "id": "5c16ca97-32cc-4cab-8afc-9d5a8b6ab1e2", + "id": "05378524", "metadata": {}, "outputs": [], "source": [ - "angular_dispersio_within_site = 10 # degrees\n", - "kappa_within_site = smp.angular2kappa(angular_dispersio_within_site)\n", - "latitude = 30\n", - "outlier_rate = 0.10\n", - "n_iters = 1000\n", + "# enter the number of sites for approach 1\n", + "N_approach1 = 100 \n", + "# enter the number of samples per site for approach 1\n", + "n0_approach1 = 1" + ] + }, + { + "cell_type": "markdown", + "id": "9cb466f6", + "metadata": {}, + "source": [ + "### Enter sites and samples per site for approach 2\n", "\n", - "params1 = smp.Params(N=40,\n", - " n0=1,\n", + "Now we can set how many sites and samples per sites for approach 2 (say 20 sites with 5 samples each for a total of 100 samples):" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2adb625b", + "metadata": {}, + "outputs": [], + "source": [ + "# enter the number of sites for approach 2\n", + "N_approach2 = 20 \n", + "# enter the number of samples per site for approach 2\n", + "n0_approach2 = 5" + ] + }, + { + "cell_type": "markdown", + "id": "517944dc", + "metadata": {}, + "source": [ + "## Assign parameters for each approach\n", + "\n", + "We will create a parameters object that has these values assigned for approach 1 (`params1`) and for approach 2 (`params2`). Nothing needs to be changed in the code cell below as it will take the values that are defined above." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "41c6d750", + "metadata": {}, + "outputs": [], + "source": [ + "params1 = smp.Params(N=N_approach1,\n", + " n0=n0_approach1,\n", " kappa_within_site=kappa_within_site,\n", - " site_lat=latitude, \n", - " site_long=0,\n", + " site_lat=site_lat, \n", + " site_long=site_long,\n", " outlier_rate=outlier_rate,\n", - " secular_method=\"G\",\n", + " secular_method=secular_method,\n", " kappa_secular=None)\n", "\n", - "params2 = smp.Params(N=8,\n", - " n0=5,\n", + "params2 = smp.Params(N=N_approach2,\n", + " n0=n0_approach2,\n", " kappa_within_site=kappa_within_site,\n", - " site_lat=latitude, \n", - " site_long=0,\n", + " site_lat=site_lat, \n", + " site_long=site_long,\n", " outlier_rate=outlier_rate,\n", - " secular_method=\"G\",\n", - " kappa_secular=None)\n", + " secular_method=secular_method,\n", + " kappa_secular=None)" + ] + }, + { + "cell_type": "markdown", + "id": "74275aa9", + "metadata": {}, + "source": [ + "## Generate the simulations with the chosen parameters\n", + "\n", + "### Chose the outlier detection strategy\n", + "\n", + "There are three options for outlier detection:\n", + "- `\"True\"` This choice corresponds to perfect outlier detection. Recall that the outliers are generated at the sample level. One can envision that with 6 samples per site and a 10% outlier rate that it would be straight forward to be able to filter out outliers by looking for site level consistency.\n", + "- `\"False\"` This choice corresponds to no outlier detection. All samples are used regardless of their position in calculating the site level means without filtering.\n", + "- `\"vandamme\"` This choice corresponds to using the Vandamme (1994) filter to detect outlier directions. This approach provides a quantitative way to filter outliers for a 1 sample per site sampling strategy\n", "\n", - "assert params1.N * params1.n0 == params2.N * params2.n0, \"The two methods don't have the same number of total samples.\"" + "We need to assign an outlier detection strategy for approach 1 and approach 2. In the versions of these approaches given above where approach 1 is 50 sites with 1 sample per site and approach 2 is 10 sites with 5 samples per site, the approach could be taken of using the `vandamme` method for approach 1 and the `True` perfect outlier detection method for approach 2." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, + "id": "05901cfd", + "metadata": {}, + "outputs": [], + "source": [ + "#assign \"True\" or \"False\" or \"vandamme\" for approach 1\n", + "approach1_outlier_method = \"vandamme\"\n", + "\n", + "#assign \"True\" or \"False\" or \"vandamme\" for approach 2\n", + "approach2_outlier_method = \"True\"" + ] + }, + { + "cell_type": "markdown", + "id": "1dc1e472", + "metadata": {}, + "source": [ + "### Chose number of iterations\n", + "Before the simulations are run, the number of times the poles are simulated needs to be specified with the `n_iters` variable. Something like 1000 should do a decent job showing the resulting distribution. We used `n_iters = 1000` in Sapienza et al. 2023." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b9aafc4a", + "metadata": {}, + "outputs": [], + "source": [ + "#change the number of iterations if you want\n", + "n_iters = 1000" + ] + }, + { + "cell_type": "markdown", + "id": "72aa7699", + "metadata": {}, + "source": [ + "### Run the simulations\n", + "\n", + "The simulations take a while to run (and will take longer for large values of `n_inters`)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, "id": "db193d70-2953-48c9-8911-aaedf6d0195e", "metadata": {}, "outputs": [ @@ -117,29 +240,155 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1min 29s, sys: 56.1 ms, total: 1min 29s\n", - "Wall time: 1min 29s\n" + "CPU times: user 1min 32s, sys: 336 ms, total: 1min 33s\n", + "Wall time: 1min 33s\n" ] } ], "source": [ "%%time\n", "\n", - "df_more_sites = smp.simulate_estimations(params1, n_iters=n_iters, ignore_outliers=\"vandamme\")\n", - "df_less_sites = smp.simulate_estimations(params2, n_iters=n_iters, ignore_outliers=\"True\")" + "approach_1_estimates = smp.simulate_estimations(params1, n_iters=n_iters, ignore_outliers=approach1_outlier_method)\n", + "approach_2_estimates = smp.simulate_estimations(params2, n_iters=n_iters, ignore_outliers=approach2_outlier_method)" + ] + }, + { + "cell_type": "markdown", + "id": "d5686798", + "metadata": {}, + "source": [ + "## Assess the simulated results\n", + "\n", + "### Calculate RMSE\n", + "The root mean square error of all of the simulations combined can be calculated for a given approach." ] }, { "cell_type": "code", - "execution_count": 6, - "id": "f0863458-1d3d-421f-8c50-d1cb25782446", + "execution_count": 9, + "id": "3eca8625", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The RMSE for approach 1 is: 1.9 º\n", + "The RMSE for approach 2 is: 3.4 º\n" + ] + } + ], + "source": [ + "approach_1_rmse = np.mean(approach_1_estimates.error_angle**2)**.5\n", + "approach_2_rmse = np.mean(approach_2_estimates.error_angle**2)**.5\n", + "\n", + "print('The RMSE for approach 1 is: ', round(approach_1_rmse,1),'º')\n", + "print('The RMSE for approach 2 is: ', round(approach_2_rmse,1),'º')" + ] + }, + { + "cell_type": "markdown", + "id": "8e155489", + "metadata": {}, + "source": [ + "### Calculate error angle percentile\n", + "\n", + "Rather than assessing the mean error, it could be informative to investigate the percentile of the resulting error angles. Calculating the 95 percentile assesses what the error angle is that 95% of the simulations are for the parameters of a given scenario." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2ae41fb6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The 95 percentile error angle for approach 1 is: 3.3 º\n", + "The 95 percentile error angle for approach 2 is: 6.1 º\n" + ] + } + ], + "source": [ + "approach_1_95_percentile = np.percentile(approach_1_estimates.error_angle,95)\n", + "approach_2_95_percentile = np.percentile(approach_2_estimates.error_angle,95)\n", + "\n", + "print('The 95 percentile error angle for approach 1 is: ', round(approach_1_95_percentile,1),'º')\n", + "print('The 95 percentile error angle for approach 2 is: ', round(approach_2_95_percentile,1),'º')" + ] + }, + { + "cell_type": "markdown", + "id": "9b82effd", + "metadata": {}, + "source": [ + "### Plot distribution of error angles\n", + "\n", + "The distribution of the error angles from the two approaches can be plotted. First, let's extract the parameters associated with each approach to plot on the figure." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "7daba4d5", + "metadata": {}, + "outputs": [], + "source": [ + "def annotation_text(approach_name, params, outlier_method):\n", + " \"\"\"\n", + " Generate annotation text based on provided parameters and outlier detection method.\n", + " \n", + " Args:\n", + " approach_name (str): The name of the approach (e.g. \"Approach 1\").\n", + " params (object): An object containing attributes related to simulation parameters.\n", + " outlier_method (str): The name of the outlier detection method (\"vandamme\", \"True\", or \"False\").\n", + " \n", + " Returns:\n", + " str: A formatted annotation string containing simulation parameters and outlier method.\n", + " \"\"\"\n", + " if outlier_method == \"vandamme\":\n", + " outlier_method = \"Vandamme\"\n", + " elif outlier_method == \"True\":\n", + " outlier_method = \"perfect\"\n", + " elif outlier_method == \"False\":\n", + " outlier_method = \"none\"\n", + " \n", + " # Display the specified params1 attributes in the annotation box\n", + " annotation_text = (f'{approach_name}:\\n'\n", + " f'number of sites = {params.N}\\n'\n", + " f'samples per site = {params.n0}\\n'\n", + " f'within site kappa = {params.kappa_within_site}\\n'\n", + " f'site latitude = {params.site_lat}º\\n'\n", + " f'outlier rate = {params.outlier_rate}\\n'\n", + " f'secular variation model = {params.secular_method}\\n'\n", + " f'outlier detection = {outlier_method}')\n", + " return annotation_text\n", + "\n", + "annotation_text_approach1 = annotation_text('Approach 1', params1, approach1_outlier_method)\n", + "annotation_text_approach2 = annotation_text('Approach 2', params2, approach2_outlier_method)" + ] + }, + { + "cell_type": "markdown", + "id": "c5cc989e", + "metadata": {}, + "source": [ + "Now we can make the plot showing histograms of the error angle for each approach." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "69579683", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAMWCAYAAADs4eXxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzddVxUWRvA8d9QA6h0iYJYiK0Y2GC3Yrdidyd219qta62F3WsH9trdudggKKgg/f7BOus4COgygL7P9/Px886c+9xznjvwuj5zzj1XERsbG4sQQgghhBBCCCGSnU5qJyCEEEIIIYQQQvyqpOgWQgghhBBCCCG0RIpuIYQQQgghhBBCS6ToFkIIIYQQQgghtESKbiGEEEIIIYQQQkuk6BZCCCGEEEIIIbREim4hhBBCCCGEEEJLpOgWQgghhBBCCCG0RC+1E0iLYmJiePHiBRkyZEChUKR2OkIIIYQQQggh0pjY2Fjev3+Pvb09Ojrfns+WojseL168wMHBIbXTEEIIIYQQQgiRxj19+pTMmTN/87gU3fHIkCEDEPfhmZiYpHI2Qvx6Pn78iL29PRD3JVe6dOlSOSMhhBBCCCG+T0hICA4ODqr68Vuk6I7H5yXlJiYmUnQLoQX6+vq4u7sDYGZmhpGRUSpnJIQQQgghxI9J7JZkKbqFECnOyMgIX1/f1E5DCCGEEEIIrZPdy4UQQgghhBBCCC2RolsIIYQQQgghhNASKbqFECnu48ePWFtbY21tzcePH1M7HSGEEEIIIbRG7ukWQqSKN2/epHYKQgghhBBCaJ3MdAshfkpPnjxBoVCo/dHX1ydTpkw0btyYCxcuxHuel5eXKn7RokXf7L9+/fqquPXr16sdi42NZc2aNVSoUAFLS0sMDAywtbWlcOHCdOvWjWPHjqnFjx49WiPXr//MmjXrP38m/8Xx48cZMGAA5cuXx9TUFIVCgZeX1w/19enTJ8aNG0eePHkwNDTE3Nyc6tWrc+rUqeRNWgghhBDiJyAz3UKIn1r27Nlp2bIlELds/eLFi2zatInt27dz6NAhypUrF+95enp6LF++nC5dumgcCwgIYPfu3ejp6REVFaVxvF27dqxcuRJzc3Nq1aqFvb09b9684d69eyxbtoyQkBDVI9G+1KBBA/LlyxdvPiVKlPiey052y5cv548//sDY2BhHR0dCQkJ+qJ9Pnz5RsWJFTp8+TYECBejatSvv3r1jy5YtuLu7s2XLFurWrZvM2QshhBBCpF1SdAshfmo5cuRg9OjRam2TJ0/G29ubESNGaMw6f1a9enV27drFjRs3NArh1atXExkZSZ06ddi5c6fasRMnTrBy5UoKFSrEsWPHMDExUTv+7t07bt26Fe+YDRs2pGnTpt95hSmjR48eDBw4EBcXF86fP0/JkiV/qJ958+Zx+vRpGjVqhI+PD7q6ugAMHz4cV1dXOnbsSIUKFciQIUNypi+EEEIIkWZJ0S2E+OW0b98eb29vLl68+M2YNm3a8Oeff7J8+XJmzJihdmzFihUULFiQwoULaxTdZ86cUZ3/dcENYGZmRqlSpZLhKlJW0aJFk6Wf7du3A3FL6j8X3BC3IqFdu3bMmjWLzZs307Zt22QZTwghkio0NJSrV69y88YN/F+/IDIyMrVTEkKkIn19fWxs7cmXPz8FChTA2NhYa2NJ0S2E+GXp6X37r7hMmTJRpUoV1qxZw5QpU9DX1wfg3Llz3Lhxg9mzZxMUFKRxnoWFBQAPHjzQTtI/udevXwOQNWtWjWOf244cOSJFtxAiRb1//56VK5fzNuA5WR3tKFXEGQMDfRSK1M5MCJEaYmMhIiKSp89fsv/PLVy4cA4vr3akT59eK+NJ0S2ESHE6OjqqmVUdneTfz3Hx4sUAlClTJsG4du3asW/fPnbv3k29evUAWLZsGQYGBrRo0YK5c+dqnFO1alUyZMjAwoULef/+PfXq1aNIkSI4ODgkmtfmzZu5c+dOvMe6dOmCnZ1don18vZQ+MX369MHMzOy7zvkvrK2tefDgAY8fPyZPnjxqxx4/fgzAvXv3UiwfIYQA2LhhA59C/Onk1QALc7PUTkcIkYYEBr1l9fpdbNy4gXbt2mtlDCm6hRApzsjIiPPnzydLXw8ePFAVoh8/fuT8+fMcO3YMGxsbfvvttwTPrVu3LpaWlixfvpx69eoRFhbGhg0bVO3xcXBwYNOmTXTs2JFVq1axatUqIK7YLF++PJ07d6ZChQrxnrtlyxa2bNkS7zFPT88kFd1jxoxJNOZLXl5eKVp0V69enTNnzjB27FjWrl2rWmL++PFjli9fDsTd9y6EECnl7du3+D15gGf10lJwCyE0WFqYU9HdjZ37ThMcHIypqWmyjyFFtxDfwc/PT54vnUKsrKxwdHRMNO7hw4cahaiNjQ0nTpzA2dk5wXM/z2jPnz+fly9fcujQIYKDg2nXrl2C51WtWpVHjx7h6+vL8ePHuXjxIidPnmTjxo1s3LgRb29vJk6cqHGej4/Pf95ILTY29j+dr219+vRh/fr1bNiwgTt37lChQgXV7uVOTk5cu3ZN7V5vIYTQtvv376OjiCZnDqfUTkUIkUY558iKguM8ePCAIkWKJHv/UnQLkUR+fn7kdnEhNCwstVP5v2BsZMTtO3cSLbyrVq3Kvn37gLhHff3xxx8MHjwYT09Pzp07l+i9Oe3atWPOnDmsWrWKffv2qe71Toyenh6VKlWiUqVKAERFRbFy5Uq6du3KpEmTaNiwIa6urkm82l9HhgwZOHXqFGPHjmXbtm3MmzcPGxsbunTpQq1atShXrhzW1tapnaYQ4v/Ix48fMTJUYmBgkNqpCCHSKKXSACOlAR8/ftRK/1J0C5FEb968ITQsjMW1S+NslfzLTv6ffIqKxmvbcQBW1iuHoZ76zOe9N8F03nWKN2/eJGm2+zNra2sGDBhAcHAw48ePZ/jw4cyaNSvBcz7vUj5nzhxevnyJt7f3D91nrqenR4cOHThx4gSrVq3i6NGjWim60/o93RC3g/uMGTM0doVfuXIlkHw7pQshRFLExsaiq5v8+4cI8V/MW7yK/t4TyeOSk8und6V2OqnGuWAF8uTOyfb1i3/o/DXrt7Pv4HGuXL/Fg4d/45g5I/euHvmhvnR0dYmJifmhcxMjRbcQ38nZypSCdvHf7yuS5mNEJK8/xK0YyGdjTjoD/WTtf+jQoSxfvpwFCxbQp08fnJycEoxv164dPXv2BPjPu2qnS5fuP52fmLR+T3dC1q5dC5Bmn1UuhBBCpJQ/1m4F4Nad+5y7cJXiRQumckY/p7UbdvLaP4BirgWIiYklKo0+ClC+9hNC/HKMjIwYPHgwkZGRjBs3LtH4Nm3asG3bNvbv30+OHDkSjN23bx87duwgKipK49i9e/fYvHkzkPjO6T8qNjb2u/4k9oXDjwoNDeXOnTv4+flpHAsJCdFomzlzJocOHaJevXoUK1ZMKzkJIYQQP4OLl69z7cYdqldxB2DFms2pmk9Y2KdUHf+/+HPLUi6d2sWKRVNxTsP7NshMtxDil9SpUyemTJnCqlWrGDp0KNmzZ/9mbIYMGfD09ExSv3fu3KFv375YWVlRrlw5smfPTmxsLA8ePGDPnj1ERETQtWtX3NzcNM5N6JFhhQoVSnIO2nDy5EmWLl0KxN0b/7nNy8sLABcXF4YMGaKKP3fuHOXLl8fd3R1fX1+1vjJlykT58uXJmTMnCoUCX19fLl68SNGiRVm2bFmKXI8QQgiRVq1YE/ckkwkj+/PuXQibtu5h+sShGBsbqWKe+D0jV6FKTBg9gKjIKJau3ID/m0Dy5s7JhFEDqOBeUhU7bvJcxk+dz1nfrUyctpAjvqdRKBTUrFae3yZ4Y21loYr9vJzbq0UDJk5byJ17D+nZpQ0TRvXn5q17jJwwi5OnLxD26RO5cmajV9c2tGpWT3X+p0/hjBw/k6PH/+LJ38/Q1dXFOYcTA/p0ok6NimrXGRMTw8Kla1m5Zgv3HjxGaWBArpzZGNSvM7Wrqz/pZf+hE4wcP5M79x7i6GBP/54d8GrZINHPUhuPntUGKbqFEL8kQ0NDvL296dmzJ2PGjFE92uu/atGiBenTp2f//v1cv36dgwcP8unTJ6ysrKhSpQpeXl40aBD/fyQSemRYmzZtUrXofvDgAX/88Yda28OHD3n48CEA7u7uakV3Qlq2bMnRo0c5fPgwCoUCZ2dnfvvtN3r27IlSqUz23IUQQoifRVjYJzZu+ZOirvnJm8eZNi0a0KX3cLbs2KdW3H626Pe1ODrYM22iNzExMUyfu4w6jTtxaNcqShQvrBbbuFUPGnhWp6NXE27decCYSXO4ffchJw9uQF//31v5rly7xZB7j/Du3wWnLJlJZ2zM3fuPcK/WDGtrS2ZMHoaFhRk+G3fSobs3rwMCGdCrAwDhERG8fRtM3x7tsM9oQ0REJEeOnaFJ6578Pm8iLZt6qsbp0N2bdRt30rZlQ0Z698JAX58r127yt98ztbyv37jL4BFTGNinIzbWlqxYvZnOvYaRPZsjZUsl3+o4pYUL5UoX4+Cu1cnWZ1JJ0S2E+Ck5OTkl+visHj160KNHD7W2lStXqjb0Sszo0aM1Ni6ztramQ4cOdOjQIcm5xtdPWuPl5aWa1U4KDw+Pb37+CxcuTKashBBCiF/L1p37CQ55r5rFbVSvOgOGTWTlmi3xFt3RMdHs2bocQ8O4L60rVyiDc6GKjJk0l73blqvF1q1VmUljBqribG0sadNpIJu376NZo9qqOP+AIK6c2Y1zjqyqtlYd+hERGcmBHX/gkDkjANUru/Mu+D0Tps6no1cTTE0yYGqSgd/nT/o3v+hoKriX5N27EOYuWqUquk+eucDaDTsY0r8LY4b1UcVXrVRW4xrfBL3l6L51OGa2B6BsqWIcPX6G9Zt3J2vRrauri04qPbb055iPF0IIIYQQQoif3Mo1mzEyMqRx/ZoApE+fjgZ1qnHyzAXuP3yiEV+3VmVVwQ2QIUN6alYrz8kz54mOjlaL/bKwBmjoWR09PT2OnTir1p4/by61ghvA98RZypcrqSq4P2vdrB6hoWH8de6Kqm3L9n14VGuGhYMrxtZ5SWeTjxVrNnPn3kNVzP5DcU+p6dK+eSKfCBTM56IquAEMDZXkzO6E39MXiZ77PUIDbrJ/+8pk7TOppOgWQqQ4hUJBLitTclmZolAoUjsdIYQQQgite/Dob06cvkD1yu7ExsbyLjiEd8Eh1KtbFYA/1mregmZnY63RZmtjTUREJB8+hmq0f0lPTw9LCzMC375T79NWs8/AoHdkjKc9Y0YbAIL+6WP7rgM0b9cH+4y2rFg0leP713P68Ca8WjTg06dw1Xlv3rxFV1c33rG+ZmFhptGmVBrw6dPPu8Hb12R5uRAixRnr63GmY53UTkMIIYQQIsX8sXYLsbGxbN25n60792scX7N+O2OG9UH3iyXQr/wDNOJe+wdgYKBP+nTGGu2Z7G1V76OioggMeoeluZlaXHzzHZYWZrx8rTnWy5f+quMA6zbtwilLZtYun6k2cRIeob53jpWVOdHR0bx6HUBGOxvNAf/PyEy3EEIIIYQQQmhRdHQ0a9ZvJ1tWRw7s/EPjT5/ubXn5KoB9/yzL/mzH7oNqM8jv33/gz31HKV2yqFpxDuCzaZfa+83b9xIVFUW5MsUTza98uRL4nviLFy9fq7Wv2bAdY2Mj3IoVAkABGBjoqxXcr14HsGvvYbXzqlYqB8CS5esTHfv/gcx0CyGEEEIIIYQW7Tt0nBcv/ZkwegDuZTQfK5o3t7Pq8Vo1q5ZXtevq6FKjfjt6d/MiJiaGaXOWEvL+IyMH99ToY8fug+jp6VHRo9Q/u5fPpkA+Fxp6Vks0v2GDurNnvy9V6rZh2MDumJuZsn7zLvYeOMbE0QMxNckAQI2qHmzffZCeA8ZQv05Vnj1/ycRpC7GztebBh79V/ZUpWZQWTeoyafpCXge8oUZVD5QGBly9fhsjI0O6d2r1Ix+jhtt3HnD77gMAXvu/ITTsE1t37AMgd64c5HbJoYo1ts5L2dLFUuW+bim6hRApLjQyioor9wBw2KsGxvryV5EQQgghfl0r12zBwECfNs3rx3vcytKcujUrsXXnAV77v1G1d+nYgvBP4fQbMgH/N4HkccnJ9vWLKFXCVaOPDavmMm7KPJas8EGBgppVyzNt4lAMDAwSzS9Xzmwc2+fDiPEz6T1wLGGfPuHinJ3f502k9Rc5t2nRgIA3QSxZsZ4/1m4haxYHBvbuyPMXrxg/db5an0vnT6JQgTysXLOZ1T7bMDI0JHeu7Azq1zmpH1uiNm/fqzFus7Z9ABg+qDsjhvz75UR0dDQxX20+l1LkX7pCiBQXGxvL3TfBqtdCCCGEEL+yTavnJRqzeukMPj9B+sk/z7LWUSgYNqg7wwZ1T/R8h8z2bF2X8GM771098s1jefM4J3o+wIDeHRnQu6NG+5cFLoCOjg69urahV9c2351PUp+lPWJIT41xvyU86E6S4rRB7ukWQgghhBBCCCG0RIpuIYQQQgghhBBCS2R5uRBCCCGEEEKkIU6OmZO8HPp7lliL1CEz3UIIIYQQQgghhJZI0S2EEEIIIYRI046dPIvSwkX1OKi07onfM+o26YxdNjeUFi709574n/pSWriwat1WVduZs5cYN3ku74JDkiPdVPP+/Qe8R/1GjfrtyJSzJEoLF8ZNnvvN+MtXb1KtXlssHFyxcSpG49Y9efTkabyx85esJr9bdTLY5ce5UEXGT5lHZGSkti4lQVJ0CyFSnEKhwME0HQ6m6VAoFKmdjhBCCCFEsho4bDLnL15l8dwJHN+/nl7dvr2Dd2Iy2tpwfP96qlfxULWdOXeZ8VPn//RFd+Dbdyz7YyMRERHUqVEpwdg79x5RuXZrIiMiWbt8JkvmTuD+gydUrNmCgDdBarGTpy+iv/dEPGtVZvfmpXRu15wpMxfTa+BYbV7ON8k93UKIFGesr8fVbvE/p1IIIYQQIrWEhX3C0FD5nycFbt6+T1HXAtStmXAhmRRKpQFuxQr9537SoiwOmXj9+BwKhYI3gW9ZvnrTN2PHTpqDUmnANp9FmJikB6BwobzkLVqNmfOWM3H0AAACg94yafpC2rVuxLgR/QBwL+NGVFQkoybMpleXNuR2yaH9i/uCzHQLIYQQQgghVMZNnovSwoVbt+/TqkM/rLMUxSFXaTr1GEpwyHtVXHzLnj/7epnw5z6v37xLM6/eWGcpil02NwYOm0RUVBR37z+iVsMOWDq64lywAtPmLI03t0/hEQwcNglHlzKY2hekUq2WXLl2SyPu4uXr1G/eFbtsbphkLEBx93ps3rZXLWbVuq0oLVw4eOQknXoMJVPOkphlKkR4eMQ3Pxu/Zy/w6jyQzM6lyGCXnwJuNZg5bzkxMTHAv8vgHz76m/2HjqO0cEFp4aJ67nZ8tmzfR5lKjbHOUhSzTIXIVbgSnXoM/ebnPG7yXLxH/QZArkKVVGMcO3lWdc6mrXsoV6UJ5pkLY+HgSs0G7TU+p0dPntKyfT+c8pQlg11+HHKVpqqnF1ev3/5mrslNoVAk6QuOqKgo9hzwxbN2FVXBDXFFu3uZ4uz486Cq7cDhk3z6FE6b5uoTPK2b1yc2Npadew4l3wUkkcx0CyGEEEIIITQ08epFI8/qeLVsyI1b9xgxbgYAS+b9+P3Jzdv1oXmjOnTwasJh39NMn7OUyKgojvieoXP7ZvTt0Y4Nm3czbPQ0cmR1xLN2FbXzR46bSaGCeVg4exwhIR8YN2UelWu35uyxbWRzcgDA98Rf1G7UkeJFCjJv+mhMTNKzaeseWrTvS2hYGK2/KsY69xxGtSruLF84ldDQUPT14y+RAt4E4VG1GRGRkYwa2ossDpnYc8CXISOn8ujJU+ZOG0XhAnk5vn89jVv3JJuTA5PHDgLilojH569zl2nRvi+N6lVn+OAeGBoa4Pf0Bb4nzsYbD9C2VSOC3gWzYMkaNq6ai52tNQC5c8XN3k6ZsYhRE2bTpnl9hgzoSmREJDPmLqNCzZacOrhRNctbt0knoqNjmDh6IA6ZMxIY+JYz5y4numQ9NjaW6OjoBGM+09NLnnLz4WM/wsI+kT9vLo1j+fPm4rDvaT59CsfQUMnN2/cAyJfHWS0uo50NVpbm3Lx9P1ly+h5SdAshUlxYZBS11hwAYHfLKhh94z9uQgghhEg9Xi0a0r9XewAqepTi4WM//li7hcVzJ/zw8uv2rRvTp3tbVZ+Hjp5i4e9r2bhqLnVrVQbAvUxx9hzwxWfTLo2i28rKnE2r56nGL1XClbxFq/HbzCUsnD0OgF4DxpLHJSf7d6xUFX1VKpblTdBbRo6fScumnujo/Lvgt7x7CRbMTPxe39kLVvD85WtOHtxIsSIFVP1GR8fw+4r19OzSGuccWXErVgilgT6mphkSXRZ+5txlYmNjmTdjDKYmGVTtX38x8KXMmexwyJQRgIIFcuPkmFl17Omzl4ydPI+uHVswc/JwVXtFj1LkLVaN8VPns3b5TAKD3nLv/mOmTRxK88Z1VHFff97xWe2zjY5fzMQnJKmPPUtMUNA7ACzMTDWOWZibEhsby9t3wWS0syEw6B1KpQHp0hlrxJqbmxL4T18pSf6lK4RIcTGxsVx+Fah6LYQQQoi0p1b18mrv8+d15tOncPwDArG1sfqhPmtU9VB77+KcjWs37lC1UjlVm56eHtmzOuL37IXG+U0a1FIr+LM4ZKJk8UL4/rO0+sGjv7l7/5FqhjkqKkoVW62yO3v2+3L3/mNy58quavesXTVJufseP0vuXDlUBfdnrZvVY8lyH3xPnMU5R9Yk9fVZUdf8ADRv24e2LRtS0s2VTPa239XHlw4eOUlUVBQtm9RVu3ZDQyVlSxVTLUG3MDcjW1ZHZs5dRnR0NB5l3SiQz0Xty4hvqVmtPKcPf/vea21K6MueL48lNS6lSNEthBBCCCGE0GBpYa72XmlgAEDYp08/3KeFuZnaewMDfYyNjTA0VGq0h7z/qHH+56XUX7K1sebajbsA+PvHfak/ZORUhoycGm8OgUFv1d5njKfPeM97+44sjpk02jPaxS0dD/qBGdSypYqxac185i9ZTbtugwkPjyCPS06G9O9Mkwa1vrs//4C46y9VsVG8xz8X1QqFgn3bVzBx6gJmzF3G4BFTsDA3pWmj2owd1ocMGdLHez7E/Qy/nJVPCRYWZkDcz+BrQW+DUSgUmJmaAGBpYcanT+GEhoZhbGykFvv2bTCuBfNqO10NUnQLIYQQQgghvpuhMq5QDo9Q33js66I2Ob16HaDR9to/QFWUWVrG/e+gvp3w/Ge5+te+no1O6sSnpbkZr15pjv/ylb/a2N+rTo2K1KlRkfDwCM5euMLUmUto3XEAWRwyUaJ44e/q63MO61fOxtHBPsHYLA6ZWDx3AgD3Hjxmy/Z9jJsyj4iISObPGPPN81JjeXn2rI4YGRly49Y9jWM3bt0jezZH1Rc3n+/lvnHrHsWLFlTFvXodwJvAt+TNnTNZcvoeUnQLIYQQQgghvputjRWGhkqu31QvhHbtOaK1MTdu/ZM+3duqlgj//fQ5Z85doWWTugDkypmNHNmzcO3GXdXjopJLefcSTJ25hMtXb1L4i9nSNRu2o1AocC/j9p/6VyoNKFe6OGamJhw8cpIr129/s+hWKv9ZdRAWrtZeuUIZ9PT0ePjkKfXqJG3ZPMR9EeE9oCvbdh2Idzf4L6XG8nI9PT1qVi3Pjt0HmTR6gGom3u/ZC46dPEuvrl6q2CoVy2JoqGSVzza1onu1zzYUCkWizwPXBim6hRBCCCGEEN9NoVDQvFEd/li7hWxODhTI58KFS9dYv3m31sYMCAiiUasetGvdiJCQ94ydPA9DpQED+3ZSxcyfMYY6jTtRs0F7Wjevh31GW4LeBnP33kMuX72Fz8rZPzR2r65erF2/A8+mXRg5pCeODvbsPXCMxct86NSu2Xffzw0wZuIcnr94RXn3kmSyt+Vd8HvmL16Fvr4+5UoV++Z5n2dz5y1eRaumnujr6+GcIytOjpkZ5d2TUeNn8fjJU6pULIu5mQn+/oGcv3SNdMZGjPTuxfWbd+kzaBz161YlRzYnDAz08T3xF9dv3mVgn44J5mxpYa5x68F/se/gcUJDQ3n/Ie52gtt3H7J1xz4g7j78z0vERwzpSelKDanXrAsDenciPDycMZPmYGVprtqcD+KWv3v378roibOxMDelUvnSXLh0nXFT5tG2VcMUf0Y3SNEthBBCCCGE+EFTxg0GYMbcZXz4GIpHWTe2rV+Ec8GKWhlv7Ii+XLh0nU49hhLy/gPFXAuwZul0smd1VMV4lC3BqUObmDx9EQOGTuLtuxAsLcxwyZWdhp7VfnhsaysLfPf7MGLsDEaMm0HI+49kdcrMxNED1Iq+71GsaAEuLr3BsNHTCAgMwszUBNdC+di/YyV5ElgG7V7GjUF9O7Fm/XaWr9pETEwMB3b+8U97Z1xy5WD+4lVs3PIn4RER2NlYUaRwfjq2bQrErVLI5uTA4mU+PHvxCoUCsmZxYMq4wXTv1PKHruVH9Rowmr+f/rtp3pYd+9jyT9F998oh1e7sLs7ZOLhzFUPHTKdZ297o6eriUa4Ek8cOwtrKQq3PIf27kD69MYuWrWPmvOXY2VgzsHdHhvTvknIX9gVFbKxsHfy1kJAQTE1NCQ4OxsTEJLXTEWnEpUuXKFKkCEfb1qCgnWVqp/NT+xgRSaEF2wC40q0e6Qz01Y5ffRVI+RV7uHjxIq6urqmRohBCiF/EkSNHuHzOl56dW6R2KkKINGz2wjUUK1URDw+PJJ+T1LpRZrqFECkunYE+9/s0Tu00hBBCCCGE0LrEH8QmhBBCCCGEEEKIH/JTFN0LFiwga9asGBoaUqRIEU6cOJGk806dOoWenh6FChXSboJCCCGEEEIIIUQ80nzRvWHDBvr06cOwYcO4fPkyZcuWpXr16vj5+SV4XnBwMK1bt6ZiRe1s4iCE+HFhkVHUXnuA2msPEBYZldrpCCGEEEIIoTVpvuieMWMG7du3p0OHDuTOnZtZs2bh4ODAwoULEzyvc+fONG/enJIlS6ZQpkKIpIqJjeWU32tO+b0mRvZyFEIIIYQQv7A0XXRHRERw8eJFqlSpotZepUoVTp8+/c3zVqxYwcOHDxk1alSSxgkPDyckJETtjxBCCCGEEOLXN27yXJQWLqmdRppUuXYrKtdupXofGhrGuMlzOXbybCpmlbhTf12kS6/hlChfnwx2+VFauPDE71mq5ZOmdy9/8+YN0dHR2NraqrXb2try6tWreM+5f/8+Q4YM4cSJE+jpJe3yJk2axJgxY/5zvkIIIYQQQgjxq5jzm/okZmjYJ8ZPnc9w4p4VnlYdPXaGI8dOU7BAHkwypOfYyXOpmk+anun+TKFQqL2PjY3VaAOIjo6mefPmjBkzBmdn5yT37+3tTXBwsOrP06dP/3POQgghhBBCCJGaQkPD/tP5uV1ykNslRzJlk3KGDuzGvatH2LR6HtUqu6d2Omm76LayskJXV1djVtvf319j9hvg/fv3XLhwgR49eqCnp4eenh5jx47l6tWr6OnpceTIkXjHUSqVmJiYqP0RQgghhBBCJF3AmyC69hlB9nweZLDLT6acJfGo1ozDvv/eFnro6CkatOhGtrzumGQsQO4iVejWdyRvAt+q9fV5yff1m3dp5tUb6yxFscvmxsBhk4iKiuLu/UfUatgBS0dXnAtWYNqcpWrnHzt5FqWFC+s27mTgsEk4upTB1L4glWq15Mq1W0m6nk1b91CuShPMMxfGwsGVmg3aa5z76MlTWrbvh1OesmSwy49DrtJU9fTi6vXbCfbdofsQLBxcuXX7PlU9vTDPXJhMOUvSe9BYjUI5NjaWRcvWUaycJ6b2BbHNWpymbXrx6In6RGHl2q0oXKo2J06fx71qU8wyFaJTz2HfzCEpuX+5vPyJ3zMy5YzbL2v81PkoLVxQWrjQofsQVfz9h09o3bE/mZ1LkcEuPwXcarBw6doEPwtt0NFJW2Vuml5ebmBgQJEiRTh48CD16tVTtR88eJC6detqxJuYmHD9+nW1tgULFnDkyBE2b95M1qxZtZ6zEEIIIYQQ/4/adhnElWu3GDOsDzlzOPEu+D1Xrt4kKOidKubRk6eUKFaItq0aYmqSgb/9njN7wUrK12jOpZM70dfXV+uzebs+NG9Uhw5eTTjse5rpc5YSGRXFEd8zdG7fjL492rFh826GjZ5GjqyOeNZW3wtq5LiZFCqYh4WzxxES8oFxU+ZRuXZrzh7bRjYnh29ey5QZixg1YTZtmtdnyICuREZEMmPuMirUbMmpgxtVs791m3QiOjqGiaMH4pA5I4GBbzlz7jLvghPfIyoyMpK6TTrTwasxA3t35K9zl5k0fRF+T1+wzWeRKq5b35Gs9tlO904tmTCqP2/fBTNh6gI8qjXj/PHt2NpYqWJfvfanbedB9OvVnrEj+iZYfH5v7hltbdi16XdqN+pI25YNaduqIQBWVhYA3L7zAPdqzXDInJEp4wZja2PFwSMn6TdkAoGBbxk+uEeCn0d0dDSxSdhgV0dHJ80V1YlJ00U3QL9+/WjVqhVFixalZMmSLFmyBD8/P7p06QLELQ1//vw5q1atQkdHh3z58qmdb2Njg6GhoUa7ECJ1GevrpnYKQgghhEhGZ85dom3LRrRv01jVVqeG+uN7O7VtqnodGxtLyeKFKVemODkLVGDfoRPUrl5BLb5968b06d4WgIoepTh09BQLf1/LxlVzqVurMgDuZYqz54AvPpt2aRTdVlbmbFo9T3VraqkSruQtWo3fZi5h4exx8V7H02cvGTt5Hl07tmDm5OGq9ooepchbrBrjp85n7fKZBAa95d79x0ybOJTmjeuo4r7O4VsiIiLp3d2LHp1bA1CpfGn09fUYOX4Wp/+6RKkSrpw9f4XlqzYxZdxg1ecAULpEUfIVr8bsBSuZOHqAqj3obTDrVsymfLkSCY79I7krlQa4FoqrqTLZ2+JWrJDa8YHDJ5MhfTqO7lmHiUl61TWFR0Tw2+zf6d65FeZmpt/sv5qnF8dPnU8wb4BWzTxZOn9yonFpSZovups0aUJgYCBjx47l5cuX5MuXjz179pAlSxYAXr58megzu4UQaUs6A32eDWie2mkIIYQQIhkVdS3Aap9tWFqYUcG9JK6F8mrMXPsHBDJm0hz2HTjGi1f+xMTEqI7dvfdQo+iuUdVD7b2Lczau3bhD1UrlVG16enpkz+qI37MXGjk1aVBLbS+oLA6ZKFm8EL4J7L598MhJoqKiaNmkLlFRUap2Q0MlZUsVU+3cbWFuRrasjsycu4zo6Gg8yrpRIJ/Ld83CNmtUWz3fhrUYOX4Wx06epVQJV/Yc8EWhUNC8cR21XOxsrSiQNxfHv9ogzNzMNNGCO7ly/9KnT+EcPf4Xndo1xdjYUC3XapXcWfj7Ws6ev0q1yuW+2ce8GWP48OFjomNZWpr/UI6pKc0X3QDdunWjW7du8R5buXJlgueOHj2a0aNHJ39SQgghhBBCCJW1y2YyadpCVqzexOiJs0mf3pi6NSszcfQA7GytiYmJoWaD9rx85Y/3gK7ky+NMOmNjYmJiKFulCWFhnzT6tDA3U3tvYKCPsbERhoZKjfaQ95oFm52ttUabrY01127c/eZ1+AcEAlCqYqN4j38uTBUKBfu2r2Di1AXMmLuMwSOmYGFuStNGtRk7rA8ZMqT/5hgQ92WBpYV6AWlnE5dv4D9L8v39A4mNjcUhV+l4+8j61RL5+K43Pv81968FBr0jKiqKBUvWsGDJmm/EvI23/bMc2bIkeXn5z+anKLqFEEIIIYQQaZuVpTnTJw1l+qSh+D17we69Rxg+dgb+AYHs3ryUm7fvc+3GHZbOn0SrZv/u1/Tg0d9ay+nV6wCNttf+AVhYmH3zHEvLuGPrV87G0cE+wf6zOGRi8dwJANx78Jgt2/cxbso8IiIimT8j4UcSR0VFERj0Vq3wfuUfl6/lP/lZWpqhUCg48udalEp9jT6USgO19/E94UkbuX/N3MwEXV1dWjSuQ5cO8a9mdMqSOcE+ZHm5EEIko09R0bTZegyAP+q7Y6gn93cLIYQQvxLHzPZ069iSo8f/4szZSwB8rgeVBuqF4tKVG7SWx8atf9Kne1tVMfr30+ecOXeFlk00N2X+rHKFMujp6fHwyVPq1ama5LGcc2TFe0BXtu06kOQd0n027VLd0w2wYfNuAMqVKQ5AjSrl+W3W77x4+ZqG9aonOZfvldTclQZxhX/Yp3C1dmNjI9zLuHHl+m3y582FwVc/46SQ5eVCCJGMomNiOPjwueo1SNEthBBC/MyCQ95TpU4bmjSoSS7nbGRIn44Ll65z4PAJPP/Z8CxXzmxky+rI8LHTiSUWczNT/tx/VO2RYsktICCIRq160K51I0JC3jN28jwMlQYM7Nvpm+c4OWZmlHdPRo2fxeMnT6lSsSzmZib4+wdy/tI10hkbMdK7F9dv3qXPoHHUr1uVHNmcMDDQx/fEX1y/eZeBfTommpuBgT6z56/k48dQihTOr9q9vGqlcpQuUQSI2/itfZvGdOw5lItXblCmVFHSGRvx6nUAp/66RL48znRu1+y7P5cfzT1DhvRkcbBn197DlC9XAgtzUywtzXFyzMyMSUMpX6MFFWq0pFO7pmRxzMT7Dx95+MiPPfuPsn/HHwnmlCtntu++jm8JeBPEiVNx97vfvH0PgP2HTmBtaY6VlQXlShdPtrGSQopuIYQQQgghxH9iqFRSrEgB1m3cyd9+z4mMisIhc0YG9OpA/14dANDX12fruoX0955A976j0NPTo4J7SfZuXUGOAuW1ktfYEX25cOk6nXoMJeT9B4q5FmDN0ulkz+qY4HmD+nbGJVcO5i9excYtfxIeEYGdjRVFCuen4z87sNvaWJHNyYHFy3x49uIVCgVkzeLAlHGD6d6pZaK56evrs239QvoNmcCk6YswMlTSrnUjJo8ZqBa3YOZY3IoWZOnKjSxe7kNMTAwZ7Wwo5VaYYq75f+hz+S+5L5ozAe9Rv9GgRTfCwyNUy71zu+TgL98tTPptIaMnzMb/TRBmphnIkS0L1Sq7/1CeP+rWnfs0a9tHra3XgLgl8+VKF+PgrtUpmo8iNil3q/+fCQkJwdTUlODgYExMTFI7HZFGXLp0iSJFinC0bQ0K2lmmdjo/tY8RkThMXw/A0/5NSWegfo/S1VeBlF+xh4sXL+Lq6poaKQohhPhFHDlyhMvnfOnZuUVqpyJS0LGTZ6lSpw0+K2ZRv2611E5HQ4fuQ9i68wBBTy+ldiriH7MXrqFYqYp4eHgk+Zyk1o0/39ZvQgghhBBCCCHET0KKbiGEEEIIIYQQQkvknm4hhBBCCCHEL8W9jBvhQXdSO41vWjp/8k/32Cvx42SmWwghhBBCCCGE0BIpuoUQKS6dgT5B3q0I8m6lsYmaEEIIIX4ulWu3onLtVqr3oaFhjJs8l2Mnz2rEjps8F6WFC28C3ybar3PBCnToPiRZc01Mh+5DcC5YQa1tyoxF7PjzULKP5VywAp5NOyd7v7+yv58+p1OPoTjlKUsGu/xkzVuORq16aMT5BwTSofsQ7HOUwCxTIcpVacKRY2dSIeM4srxcCCGEEEII8cPm/DZK7X1o2CfGT53PcOKWef+ojavnkSFD+v+Y3ffxHtCNHp1bq7VNmbmE+nWqULdmpRTNRai7eeseleu0JquTA5PHDiKTvR2vXgVw8MhJtbjw8AiqeXoRHPye6ZOGYW1lwaJl66jdqCN7ty1P8Wd0gxTdQgghhBBCiP8gt0sOrfRbqEAerfSbkMSe3y1SR2xsLG27DiZzpowc+XMtSqWB6lij+jXUYles2czN2/c5ts+HEsULA+BR1o2iZT0ZOmoaJw9tTNHcQZaXCyFSwaeoaLy2HcNr2zE+RUWndjpCCCHE/71bt++jtHBhy/Z9qrZLV26gtHChUMlaarH1m3elRPn6qvdfLi9/4veMTDlLAjB+6nyUFi4oLVw0lon7+7+hVYd+WGcpikOu0nTqMZTgkPdqMV8vLz928ixKCxc2bNnNyPEzccpTFivHIlSr15a79x8leo0Bb4Lo2mcE2fN5kMEuP5lylsSjWjMO+55WxXy9vFxp4cLHj6Gs9tmuupYvl9K/eh1At74jyZbXnfS2+XEuVJHxU+YRFRWVaD7xWbRsHcbWeRk7aY4q554DxlCwRE0sHFzJ7FyKqnXbcPLMBbXznvg9Q2nhwrQ5S5k8fRE58pfHJGMBSlZooLGs+vMS/yvXbtG4dU+sHItgnaUoXp0HEvAmSC1209Y91Kjfjiy5y2JqX5ACbjUYNmY6Hz+G/tD1/agTp89z9fptenZprVZwx2fH7kM458yqKrgB9PT0aN64NucvXeP5i9faTleDzHQLIVJcdEwMO+/4ATC/Zgygm7oJCSGEEP/n8uTOSUY7aw4fO00Dz2oAHDl2BiMjQ27ffcCLl6+xz2hLVFQUJ06dp2PbpvH2k9HWhl2bfqd2o460bdmQtq0aAmBlZaEW18SrF408q+PVsiE3bt1jxLgZACyZNzHRXEeMm0kpN1cWzh7P+5APDBsznfrNu3Ltrz3o6n773xRtuwziyrVbjBnWh5w5nHgX/J4rV28SFPTum+cc37+eqp5euJdxY+iArgCY/LPk/dXrAMpUaoyOjoKhA7uRLasjZ89fYdL0hfzt95zf509K9Fo+i42NZcjIqcxfsoZFs8fRunnclxpBb+NyGz6oO7a2Vnz4GMrO3YeoXLs1+7av0Fi+v+j3tTg62DNtojcxMTFMn7uMOo07cWjXKrUiFKBxqx408KxOR68m3LrzgDGT5nD77kNOHtyAvn7cnjsPHv1Ntcru9OzahnTGRty9/4hps5dy4dI19u/4I9HrSuqXD7q6uigUim8eP3k67kuGDOnTUadxJ3xP/IWenh7lShdj8tjBuDhnU8XeunOf0iWKaPSRL28u1fFM9rZJyiu5SNEthBBCCCGEoHy5kmqzood9z9CsUW227TzAkWNnaNnUk/MXrxHy/gMV3EvG24dSaYBroXwAZLK3xa1YoXjjvFo0pH+v9gBU9CjFw8d+/LF2C4vnTkiw+ALInSsHKxf/pnqvq6tL83Z9uHDp+jfHAzhz7hJtWzaifZvGqrY6NSomOJZbsULo6OhgbWWu0fe4KfN4GxzM5dO7ccxsD0AF95IYGioZMnIq/Xq2T9LS+7CwT7TtMogjx86wc+MStc82V85szJ327z3z0dHRVKlQhidPnzN/yRqNojs6Jpo9W5djaKgEoHKFMjgXqsiYSXPZu225WmzdWpWZNGagKs7WxpI2nQayefs+mjWqDYD3P180QNwXA6XcXHFxzk6lWq24fvMu+f8pZOPzxO8ZuQol7T74Azv/SPD+/+cv42anO/YYSoO61di+fjGvXgcwesIsKtZswYUTO8hoZwNAYNA7zM1NNfqwMItr+/xFRkqSolsIIYQQQghB+XIlWLdxJ4//fkZGW2tOn71I53ZNCQp6x2Hf07Rs6smRY2dQKg3inUn8HrWql1d7nz+vM58+heMfEIitjdV3nZsvrzMAfk9fJFh0F3UtwGqfbVhamFHBvSSuhfKqZnR/xN79vriXccPezkZtRrdapXIMGTmV46fPJ1p0BwW9o2rdNrx46c/RPWvJm8dZI2bJivUs+2Mjt+8+IDw8QtWeK2c2jdi6tSqrCm6ADBnSU7NaeTZs+ZPo6Gi1lQCfC+vPGnpWp303b46dOKs69ujJU0ZPmIXvibP4BwQSGxurir9z92GCRbe9nQ2nD29K8Po/c86RNcHjMTExQNyXIIvmjFe1582dk+Lu9Vi0bB1jhvVRtSf0xY2ChL/U0QYpuoUQQgghhBBUcC8FwBHf0zhlyUxkZBQe5UrwOiCQSdMWxB07doaSbq4YGRn+p7EsLczV3isN4u7TDfv0KfFzzc3Uz1Um7dy1y2YyadpCVqzexOiJs0mf3pi6NSszcfQA7GytvyP7OK8DAvlz31HS2eSL93hgEh6Ldv/hE96+C6Fd60bxFtyz5q9g8IgpdGzblFFDe2FlYY6urg6jJ87h7r2HGvF2NprXYWtjTUREJB8+hmJqkkGt/Ut6enpYWpgR+M9M8IcPH6lYswVKpZLRQ3uTM4cTxkaGPHv+isateyb6eRsYGFAwf+5EPwMgwdsCACwtzIC4GfkvFcyfm4x21ly+ekstNr5bBoLeBQPEOwuubVJ0CyGEEEIIIcicyY6cOZw4cuwMWRwzUaRQPsxMTShfrgS9Bozh3IWrnL1wlZFDNJ+L/DOwsjRn+qShTJ80FL9nL9i99wjDx87APyCQ3ZuX/lB/+fI4M3Z4n3iPf17unBC3YoVoULcanXsNB2De9NHo6Py717XPpl24lynOvOmj1c778OFjvP298g/QaHvtH4CBgT7p0xlrtH95b3NUVBSBQe9UX2ocPXGWFy/9Obhrldpjtt4Fq2949y3Jubw8oRn12FjQ0fl39jpv7pzcuHVPI+7mP215c+dMUk7JSYpuIYQQQgghBBA3271l+14yZ8pI9cruQNzSX8fM9oyZNIfIyEjVjPi3KA3ilmyHfQrXer4/yjGzPd06tuTo8b84c/ZSgrFKA33CwjSvpUYVD/YdOka2rI6Ym/347GmrZvVIZ2xE604DCQ0NY9mCyaqZX4Uibsb4S9dv3uWv81dwyGSn0deO3QeZPGaQaon5+/cf+HPfUUqXLKoxm+yzaZfq/nuAzdv3EhUVRbkyxVVjx12/+vhLV25I0nUl5/LyqpXKYWxsxP5Dx+ndzUvVfvnqTV69DsCtaCFVW91alVVfEhUvWhCI+0Jh3cZdFC9SEPuMKbuJGkjRLYQQQgghhPhHhXIlWLxsHW8C3zJtoreqvXy5EvyxbivmZqa4FsqbYB8ZMqQni4M9u/Yepny5EliYm2JpaY6TY2Ztp/9NwSHvqVKnDU0a1CSXczYypE/HhUvXOXD4BJ61Kid4br48zhw/dY7d+46Q0daa9OnTkStnNkZ69+Sw7yncqzaje+dWOOfIyqfwcP72e86+g8eYN30MmeMpjONTv241jIyNaObVm7CwT6xeOh0DAwNqVPFg4rSFjJ00h7Kli3PvwWMm/rYApyyZiY5nZ3BdHV1q1G9H725exMTEMG3OUkLef2Tk4J4asTt2H0RPT4+KHqX+2b18NgXyudDwn93rSxYvjLmZKT36j2b4oO7o6euxftMurt28k6RrMjAwoEjh/EmKTYyZqQkjh/RkyMipdOg+hMb1a/La/w1jJs7BMbM9nds3U8V6tWjAoqXraN62D+NH9cPaypLFy3249+CxxmZyKUWKbiFEijPW1+Np/6aq10IIIYRIGzzKlUBHRwcjI0NKfLEpWQWPkvyxbivuZYqrLX/+lkVzJuA96jcatOhGeHgErZp5snT+ZC1mnjBDpZJiRQqwbuNO/vZ7TmRUFA6ZMzKgVwf69+qQ4LnTJw2j98CxtOrQn9DQMMqVLsbBXavJaGfD6SNbmPjbAmbMXcbzF6/JkN4YpyyZqVKxLOZmJt+VY/XK7uzYsJj6zbvSoEV3Nq6ay5D+XQgN+8TKNVuYPncZuXNlZ+700ez88yDHT57T6KNLxxaEfwqn35AJ+L8JJI9LTravX0SpEq4asRtWzWXclHksWeGDAgU1q5Zn2sShqpl1Swtztq9fxOARU/DqMoh0xkbUrl6Rtctm4uZRX6M/bevbox2mJhmYt3gVG7b8SYb06ahSsSzjR/bH4ov7/JVKA/ZtX8HQ0b/Rd/B4QsM+UTCfCzs3LlFbJp+SFLFfbkEnAAgJCcHU1JTg4GBMTL7v/yzi13Xp0iWKFCnC0bY1KGhnmdrp/NKuvgqk/Io9XLx4EVdXzf9ICCGEEEl15MgRLp/zpWfnFqmdihBa8/n+6UljBtKvZ/sEY8dNnsv4qfN5fv8MVpbmCcb+P5m9cA3FSlXEw8MjyecktW5M/GsqIYQQQgghhBBC/BApuoUQKS48Kpruu0/RffcpwqOiUzsdIYQQQgghtEZuphRCpLiomBh8rj8CYGqV4ihJ+NmMQgghhBDi25wcMxMelLQNzkYM6cmIIZobqwntkZluIYQQQgghhBC/pA1bdlOqYkPKV29O5dqtuHLtVornIEW3EEIIIYQQ4qfUofsQnAtWUGubMmMRO/48lOxjVa7disq1W/3QuYuWrWPVuq0a7U/8nqG0cFE7dubsJcZNnsu74JAfzvVbVq3bitLChSd+z5K97//q48dQWrbvR77i1bB0dMU8c2EKlazFpGkL+fgxVCPePyCQDt2HYJ+jBGaZClGuShOOHDujFnPm7CW69R3JH0umcXTvOjq1bUathh0IDnmfUpcFSNEthBBCCCGE+El5D+jGxtXz1NqmzFzCrj3JX3T/F4uX+bDaZ5tGe0ZbG47vX0/1Kh6qtjPnLjN+6nytFN1pWWRUFLGxsfTu5sX6lXPYvGY+9WpXYcJvC2jQsrtabHh4BNU8vTh67C+mTxrG5jXzsbGxonajjhw/9e+j1Fb5bKN29YrkzO4EQKP6NVAaGLDv4LGUvDS5p1sIIYQQQgjxc8qe1TG1U/hPlEoD3L54Hvr/MzNTE9Yun6nWVtGjFOEREUyfs5RHT56SzckBgBVrNnPz9n2O7fOhRPHCAHiUdaNoWU+GjprGyUMbAXj+4jUF8uVS6zOTvS1Pn79KgSv6l8x0CyGEEEIIIdKcgDdBdO0zguz5PMhgl59MOUviUa0Zh31Pq2K+Xl6utHDh48dQVvtsR2nhgtLCRW1J+KvXAXTrO5Jsed1Jb5sf50IVGT9lHlFRUT+U4/gp8yhTqTF22dywciyCm0d9VqzeTGxsrCrGuWAFbt25z/FT51U5fc756+Xl4ybPxXvUbwDkKlRJFX/s5FnV9Y2bPFcjD+eCFejQfYha29nzV/Co1gyTjAVwylOW4WOnExkZ/3Vu2rqHclWaYJ65MBYOrtRs0D5V7n2Oz+dnievp/bvx7o7dh3DOmVVVcMcd16N549qcv3SN5y9eA5Apoy0vX/mr9ffyVQCZ7W1TIPN/yUy3EEIIIYQQIs1p22UQV67dYsywPuTM4cS74PdcuXqToKB33zzn+P71VPX0wr2MG0MHdAXAJEN6IK7gLlOpMTo6CoYO7Ea2rI6cPX+FSdMX8rffc36fP+m7c/zb7zkdvJrgkDkjAOcuXKXvkPG8ePmaYYPilkRvXD2Ppl69MTXJwJzfRgJxM9zxXnOrRgS9C2bBkjVsXDUXO1trAHLnyvFded2+84Bq9dqSxSETS+dNwsjYiMXL1rFh858asVNmLGLUhNm0aV6fIQO6EhkRyYy5y6hQsyWnDm4kt0vCYyf1CwtdXV0UCkWicbGxsURHRxMa+okz5y4ze8FKmjSoiWNme1XMrTv3KV2iiMa5+fLmUh3PZG9Lq2b1qNO4I8MGxc2Sb9m+j9CwMKpVdk9SzslFim4hRIoz1tfjXu9GqtdCCCGEEF87c+4SbVs2on2bxqq2OjUqJniOW7FC6OjoYG1lrrFse9yUebwNDuby6d2qAq6Ce0kMDZUMGTmVfj3bJ1pgfu3LQj0mJgb3MsWJjY1l3uJVDB3YDYVCQaECeTAyNMQkQ7pEl5JnzmSHQ6a4Ar5ggdw4OWb+rnw+m/DbAmJjY9m/YyW2NlYA1KjiTuFStdXinj57ydjJ8+jasQUzJw9XtVf0KEXeYtUYP3W+xpLvLz3xe0auQpWSlNOBnX/gXsYt0bhNW/fQqmN/1fs2zeuzYNZYtZjAoHeYm5tqnGthFtcW9PYdAKVKuDJ/5hhatu+L0sAAHR0ddm5cgpmpSZJyTi7yr10hRIpTKBRYGRumdhpCCCGESMOKuhZgtc82LC3MqOBeEtdCedHX1//h/vbu98W9jBv2djZqs7PVKpVjyMipHD99/ruL7qPH/2LKzMVcvHSdkPcf1I75BwSqCt6UduzkWcqXK6E2vq6uLo3qVWf81PmqtoNHThIVFUXLJnXVPhNDQyVlSxVTLWv/Fns7G04f3pSknJxzZE1SXOWKZTh9eBPvP3zk7PkrTJu9lMC379i0eh46Ov/eHZ3QrLmCf481aVCLJg1qJWlsbZGiWwghhBBCCJHmrF02k0nTFrJi9SZGT5xN+vTG1K1ZmYmjB6iWXX+P1wGB/LnvKOls8sV7PDDw7Xf1d/7iNWo2aE+5MsVZOGscmextMTDQZ+eew0yevoiwT5++O8fkEhj0Djsbzc/I9qvPzT8gEIBSFRvF28+XRW58DAwMKJg/d5Jy0tXVTTwIMDczpUjh/AB4lC1BNidHWnbox649h6lbqzIAlhZm8d5mEPQuOK6Pf2bB9x86wbTZSzTipk0cmuS8k4MU3UKIFBceFc3wwxcAGF+xKEq9pP0lLIQQQoj/H1aW5kyfNJTpk4bi9+wFu/ceYfjYGfgHBLJ789If6i9fHmfGDu8T7/GMdjbf1d/GrX+ir6/Hdp9FGBoqVe079xz+7tySSqk0IDwiQqM98J/l1J9ZWpjxyj9AI+71a/U2S0szANavnI2jg71GfGK0sbz8a0WLFADg/sMnqra8uXNy49Y9jdib/7TlzZ0TgKqVylK1UtnvHjO5SdEthEhxUTExLLsU95fi6PKuKJGiWwghhBDf5pjZnm4dW3L0+F+cOXspwVilgT5hYeEa7TWqeLDv0DGyZXXE3EzzfuDvpVAo0NPTRVf339ngsLBPrNuwUzMnZfw5xefzJmvxxWdxzMT1m+rF5tHjf/HhQ6ham3sZN3bvO8Jr/zeqJebR0dFs2rZXLa5yhTLo6enx8MlT6tWpmqT8vqSN5eVfO3Yibon7l4+Hq1urMr0GjOHchasUL1oQiNvQbd3GXRQvUhD7jCm7O3lipOgWQgghhBBCpCnBIe+pUqcNTRrUJJdzNjKkT8eFS9c5cPgEnv8sMf6WfHmcOX7qHLv3HSGjrTXp06cjV85sjPTuyWHfU7hXbUb3zq1wzpGVT+Hh/O33nH0HjzFv+hgyZ7JLco7Vq3gwe8FKWnccQPs2jQkKesfM+csxUGred54vjzMbt+5h09Y9ZHVywNDQgHx5csXTa1wswLzFq2jV1BN9fT2cc2QlQ4b0tGhcl9ETZzNm4hzKli7G7bsPWLh0LaYmGdT68O7fhd37jlC1rhfDBnbDyNiQRUvXERoaphbn5JiZUd49GTV+Fo+fPKVKxbKYm5ng7x/I+UvXSGdsxEjvXt/8DAwMDFRLwf+r31eu59SZi1QqX5rMmez4GBrGqTMXWfD7GkoWL0ztLzbR82rRgEVL19G8bR/Gj+qHtZUli5f7cO/BY/ZuW54s+SQnKbqFEEIIIYQQaYqhUkmxIgVYt3Enf/s9JzIqCofMGRnQqwP9e3VI8Nzpk4bRe+BYWnXoT2hoGOVKF+PgrtVktLPh9JEtTPxtATPmLuP5i9dkSG+MU5bMqmLze5QvV4Ilcycwbc5S6jfvin1GW9q3boS1lSWdew1Tix0xpCcvXwXQtc8I3n/4SBYHe+5dPRJvv+5l3BjUtxNr1m9n+apNxMTEqJZm9+vZjpD3H1jts42Z85dTzDU/65bPomGLbmp95M3jzN6tyxk8Ygrtuw/B3MyU5o3rUK92Fbr1HakWO6hvZ1xy5WD+4lVs3PIn4RER2NlYUaRwfjq2bfpdn8l/kS+3M3v2+zJi3AzeBL5FT0+PHNmyMLhvZ3p380JP79/SVak0YN/2FQwd/Rt9B48nNOwTBfO5sHPjEsqVLp5iOSeVIvbLJ7cLAEJCQjA1NSU4OBgTk5TdTl6kXZcuXaJIkSIcbVuDgnaWqZ3OT+1jRCQO09cD8LR/U9IZqH8jfPVVIOVX7OHixYu4urqmRopCCCF+EUeOHOHyOV96dm6R2qkIIdKw2QvXUKxURTw8PJJ8TlLrxoS3oxNCCCGEEEIIIcQPk6JbCCGEEEIIIYTQEim6hRBCCCGEEEIILZGN1IQQKc5IX48rXeupXgshhBBCCPGrkn/tCiFSnI5CgaNZ+tROQwghhBBCCK2T5eVCCCGEEEII8Y9Fy9axat1WjfYnfs9QWrioHVu1bitKCxee+D1LyRR/2IuXrxk3eS5Xr99O7VQSddj3NOWqNMEsUyHsc5SgQ/ch+AcEJuncNeu307J9P/IVr4ahZW6cC1bQcrYJk6JbCJHiIqKjGXnkIiOPXCQiOjq10xFCCCGEUFm8zIfVPtuSFFu9igfH968no62NlrNKHi9f+TN+6vw0X3QfP3WOOo07YWNjxeY185k+aRhHfM9QzdOL8PCIRM9fu2Ent+7cp5hrAbJldUyBjBMmy8uFECkuMjqGeWdvATC4TAEMdHVTOSMhhBBCiO9nbWWBtZVFsvUXGhqGsbFRkuPDwj5haKhEoVAkWw5pgfeo38iZ3Yn1K2ejpxdXsjo5ZsKjenNWrt1C53bNEjz/zy1L0dGJm1/2bNqZW7fvaz3nhMhMtxBCCCGEEOKndeqvi1T19MLS0RWzTIVwr9qUPQd81WLGTZ6L0sJF49yvl4c7F6zArTv3OX7qPEoLF5QWLgkuTf7W8vLDvqep6umFlWMRzDIVwqNaM44cOxNvTpev3qRpm17YZi1O7iJVEh3r4JGTdOoxlEw5S2KWqRDh4RE8ePQ3Hbt7k6doVcwyFSJr3nLUa9aFG7fuqs4/dvIspSo2AqBjj6Gq6xs3ea4q5uLl69Rv3hW7bG6YZCxAcfd6bN6295s5acPzF6+5cOk6LZrUURXcACXdXMmZw4kduw8m2sfngjutSFvZCCGEEEIIIUQSHT91jqp1vQgJec/i2RNY9ft00qdPR/1mXdm0dc9397dx9TyyOjlQqEAeju9fz/H969m4et539bFu405qNmiPSYb0LFswmbXLZ2Jubkqthh00Cm+AJq17kj1bFtatmMXc6aMT7b9zz2Ho6euxfOFU1q+cjb6+Hi9f+WNhYcaEkf3Ytel3Zk0diZ6eHmUqN+Hu/UcAFC6Ql9/nTQTAu39X1fW1bRVXiPue+AuP6s0JDn7PvOmj2bxmPgXzudCifd9473H/WnR0NFFRUYn+iYmJSbCfm7fvAZAvby6NY/nz5OLWndSdtf4RsrxcCCGEEEII8VMaPmY65mYmHNy5ivTp0wFQs6oHxcp5MmTkVBrWq/5dS68LFciDkaEhJhnS4Vas0HfnExoaRn/vCdSo6sGmL4r16pXdcfOoz8hxM6ngXlLtnJZNPRnp3SvJY5R3L8GCmWPV2sqWKkbZUsVU76Ojo6lRxZ1CpWqxdOUGfpvgjYlJevLmzglAtqwOGtfXa8BY8rjkZP+OlaoZ5ioVy/Im6C0jx8+kZVPPBGeQc7tW5u+nLxLNf/ig7owY0vObx4PevgPAwsxU45i5uSmBQe8SHSOtkaJbCCGEEEII8dP5+DGUcxev0aldM1XBDaCrq0vzJnUZNnoad+8/xsU5W4rldObcZYLeBtOqqSdRUVFqx6pULMv0OUv5+DGUdOmMVe316lT9rjE8a2vGR0VFMX3OUtZt3MXDx35ERkaqjt259yjRPh88+pu79x8xeewgVX+fVavszp79vty9/5jcubJ/s4+tPguTtMlZRrukbTr3rS9Lfsb716XoFkIIIYQQQvx03r4LITY2loy21hrH7P8p7IJSeFb08yOtmnr1/mZM0NtgtaLbLp78ExLf9Q4cPplFS9cxoHcHypYqhrmZKTo6Crr0HsGnT58Sz9s/Lu8hI6cyZOTUeGMCg94m2EfuXDmIjY1NdKzE7re2MDeLG++fGe8vvX0bjIW55gx4WidFtxBCCCGEEOKnY25mgo6ODi9fB2gce/HKHwBLSzMADA2VAISHR6BUGqji3gQmXEh+L0uLuPFmThmOW9GC8cbY2liqvf/emdv4wn027qJlk7qMG9FPrT0w8C1mphkS7fPz5zSobyc8a1WON8Y5R9YE+0iu5eV5czsDcPPWPapXdlc7duP2PfK45Ex0jLRGim4hRIoz0tfjVIfaqtdCCCGEEN8rXTpjihcpwI7dB5kydhBGRoYAxMTE4LNxJ5nt7VSFYhaHTABcv3mXoq75VX3s2X9Uo1+lUp+wsPAfyqmUmytmpibcvvuQbh1b/lAfP0KhAIMvvkwA2HPAl+cvX5M927/Pqf78hUPYJ/Xry5UzGzmyZ+HajbsahXtSJdfy8kz2thRzLcC6jTvp26Mduv88Wvbs+Svcu/+Ynl3a/FB+qUn+tSuESHE6CgW5rc1SOw0hhBBC/OTGjexHjfrtqVKnDX17tEXfwIDFy9Zx8/Z9Vv8+XTWLXK2yOxbmpnTuNYyR3r3Q09Nl9bptPH3+SqPPfHmc2bh1D5u27iGrkwOGhgbky6O5k3Z80qdPx8wpw2nfbQhv3wZTv04VrK0tefMmiGs37hIQGMS8JOxQ/r1qVPVgtc82cuXMRv68ubh05SYz5y0js72dWlw2J0eMjAxZv2kXLs7ZSJ/OmIx2NthntGX+jDHUadyJmg3a07p5Pewz2hL0Npi79x5y+eotfFbOTjCHpH5GSTFhdH9q1G9Ps7Z96NyuGQFvAhk+ZgZ5c+ekTfP6qri/nz4nt2sVWjX1ZPHcCar223cecPvuAwBe+78hNOwTW3fsA+KWwed2yZFsuSaFFN1CCCGEEEKIn1K50sXZv2MlYyfPpUOPocTExFAgby62rFtAzarlVXEmJunZtWkpA4ZOpG2XQZiZZKBtq4ZUrVSOLr2Hq/U5YkhPXr4KoGufEbz/8JEsDvbcu3okyTk1b1wHh8wZmT5nKd37jeL9h1BsrCwokN+F1s3qJdu1f2n6pGHo6+nz26wlfPgYSuECediwai6jJ8xSizM2NmLJnAmMnzqfmg06EBkZqVru7VG2BKcObWLy9EUMGDqJt+9CsLQwwyVXdhp6VtNK3t/iXsaNHRsWM3bSHOo374qxkSE1qnowacwgtdsDYmNjiY6OJjomWu38zdv3Mn7qfLW2Zm37AIkvb9cGRWxS7nb/PxMSEoKpqSnBwcGYmJikdjoijbh06RJFihThaNsaFLSzTPwE8U0R0dHMOH0DgH6l8mHwz7Khz66+CqT8ij1cvHgRV1fX1EhRCCHEL+LIkSNcPudLz84tUjsVIUQaNnvhGoqVqoiHh0eSz0lq3Sgz3UKIFBcZHcPUk9cA6OmWR6PoFkIIIYQQ4leR8H7tQgghhBBCCCGE+GE/RdG9YMECsmbNiqGhIUWKFOHEiRPfjD158iSlS5fG0tISIyMjXFxcmDlzZgpmK4QQQgghhBBCxEnzy8s3bNhAnz59WLBgAaVLl2bx4sVUr16dW7du4ejoqBGfLl06evToQYECBUiXLh0nT56kc+fOpEuXjk6dOqXCFQghhBBCCCGE+H+V5me6Z8yYQfv27enQoQO5c+dm1qxZODg4sHDhwnjjCxcuTLNmzcibNy9OTk60bNmSqlWrJjg7LoQQQgghxP+LyrVbUbl2q9ROI9l16D4E54IVfujc9Zt3MWfhH/EeU1q4MG7y3P+S2k/pid8zlBYurFq39bvPPXbyLEoLF46dPKuFzBL22v8NI8bNoFg5T6wci5DeNj/Z8rrTuHVPdu09QnR0dOKdJLM0PdMdERHBxYsXGTJkiFp7lSpVOH36dJL6uHz5MqdPn2b8+PHfjAkPDyc8/N8HxIeEhPxYwkIIIYQQQohU4T2gGz06t/6hc9dv3s2t2/fp1bWNxrHj+9eT6avnXYu06ez5KzRo0Y3Y2Fg6tW1G8WIFSZ/OmKfPXvLnvqM0ad2T+TPG0LZVwxTNK00X3W/evCE6OhpbW1u1dltbW1690nyQ/ZcyZ85MQEAAUVFRjB49mg4dOnwzdtKkSYwZMyZZchZCCCGEEOL/SVjYJ4yMDFNt/NDQMIyNjcieVfPW0+TgVqyQVvoVyetdcAiNWvUgXTpjfPeuI6Odjdrx5o3rcP3mXQKD3qZ4bml+eTmAQqFQex8bG6vR9rUTJ05w4cIFFi1axKxZs/Dx8flmrLe3N8HBwao/T58+TZa8hRDxM9TT5VCb6hxqUx1DPXlcmBBCiF9PwJsguvYZQfZ8HmSwy0+mnCXxqNaMw77qqzUP+56mqqcXVo5FMMtUCI9qzThy7IxGf3fuPaJVh3445CpNBrv85MhfnnZdBxMeHgHAuMlzUVq4aJy3at1WlBYuPPF7lmC+46fMo0ylxthlc8PKsQhuHvVZsXozsbGxanHOBSvg2bQz23cdoLh7PUwyFmD81Pnx9tnfeyLmmQsTEvJB41iLdn1xyFWayMhIADZt3UON+u3IkrsspvYFKeBWg2FjpvPxY6jaeR26D8HCwZUbt+5So347LB1dqebppTr29fLyhUvXUrFmSzI7l8I8c2FcS9dm2pylqnEhbrn93gPH+PvpC5QWLqo/n8W3vPzmrXs0aNEN26zFMclYgGLlPFnts00t5vMS6w1bdjNy/Eyc8pTFyrEI1eq15e79R/F+Zl/6/DO9fvMuzbx6Y52lKHbZ3Bg4bBJRUVHcvf+IWg07YOnoinPBCkybs1SjD79nL/DqPJDMzqXIYJefAm41mDlvOTExMWpxL16+pnnbPlg6umKdpSgt2vXl9es38eZ18fJ16jfvil02N0wyFqC4ez02b9ub6PVo27I/NvHa/w2TRg/QKLg/y583Fx5lS6RwZml8ptvKygpdXV2NWW1/f3+N2e+vZc2aFYD8+fPz+vVrRo8eTbNmzeKNVSqVKJXK5ElaCJEoXR0dXO2tUjsNIYQQQmvadhnElWu3GDOsDzlzOPEu+D1Xrt4kKOidKmbdxp206zqY2jUqsmzBZPT09Vi6cgO1GnZg9+alVHAvCcC1G3coX6M5lhbmjPTuSY5sTrx6HcDuvUeIiIhAqTT4z/n+7fecDl5NcMicEYBzF67Sd8h4Xrx8zbBB3dVir1y7xZB7j/Du3wWnLJlJZ2wcb59eLRswb/EqNm/fS7vWjVTt74JD2LX3MF3aN0dfXx+AB4/+plpld3p2bUM6YyPu3n/EtNlLuXDpGvt3qN9rHRERSf3m3ejo1YSBfToRFRX1zet69NiPJg1r4eSYCQMDfa7duMuUGYu4d+8RS+ZNBGDOb6Po1nckj548ZeOqxO/dvnv/Ee7VmmFtbcmMycOwsDDDZ+NOOnT35nVAIAN6qa+wHTFuJqXcXFk4ezzvQz4wbMx06jfvyrW/9qCrm/jkQ/N2fWjeqA4dvJpw2Pc00+csJTIqiiO+Z+jcvhl9e7Rjw+bdDBs9jRxZHfGsXQWI++LHo2ozIiIjGTW0F1kcMrHngC9DRk7l0ZOnzJ02CohbqVC9XjtevvJn3Ih+5MzuxN4Dx2jZvp9GLr4n/qJ2o44UL1KQedNHY2KSnk1b99CifV9Cw8Jo3bx+otfztYR+fl/S1dVNcOL1sO8pdHV1qVbZ/btz0LY0XXQbGBhQpEgRDh48SL169VTtBw8epG7duknuJzY2Vu2ebSGEEEIIIbTpzLlLtG3ZiPZtGqva6tSoqHodGhpGf+8J1KjqwabV81Tt1Su74+ZRn5HjZqqK7oHDJ6Onq8epQ5uwtrJQxTZrVDvZ8v19/iTV65iYGNzLFCc2NpZ5i1cxdGA3tWLHPyCIK2d245wja4J95s+bi8IF87Bq3Va1onvDlj8JD4+gzRcFmveArqrXsbGxlHJzxcU5O5VqteL6zbvkz5tLdTwyMpJhA7vRpkWDRK/rtwneatdVpmRRLC3M6NhjKFPGD8bczJTcLjkwNc2A0kA/SUvJx0+ZR0RkJAd2/KH6kqJ6ZXfeBb9nwtT5dPRqgqlJBlV87lw5WLn4N9V7XV1dmrfrw4VL15M0XvvWjenTvS0AFT1KcejoKRb+vpaNq+ZSt1ZlANzLFGfPAV98Nu1SFd2zF6zg+cvXnDy4kWJFCgBQpWJZoqNj+H3Fenp2aY1zjqysXr+dO/cesnntAmpXj1spULlCGcI+fWL5qk1qufQaMJY8LjnZv2Mlenp6qj7fBL1l5PiZtGzqiY5O0hdTP/F7Rq5ClZIUe2DnH7iXcfvm8WfPX2FtZYGxsZFae0xMjNrMvo6OznflmBzSdNEN0K9fP1q1akXRokUpWbIkS5Yswc/Pjy5dugBxS8OfP3/OqlWrAJg/fz6Ojo64uMQtCTl58iTTpk2jZ8+eqXYNQgh1EdHRLDp/B4AuxVwwSMK3vEIIIcTPpKhrAVb7bMPSwowK7iVxLZRXNasLcObcZYLeBtOqqafGTF+VimWZPmcpHz+GolAoOHHqPF4tG6gV3Mnt6PG/mDJzMRcvXSfkvfpycP+AQGxt/l2hlj9vrkQL7s9aN69P38HjuXv/EblyZgPilrwXdc1P3jzOqrhHT54yesIsfE+cxT8gUG1Z+527D9WKboB6tasmafwr124xdvJczpy9RNDbYLVj9x88oXjRgknq50u+J85SvlxJVcH9Wetm9dh/6Dh/nbtC1UplVe21qpdXi8uXN+66/Z6+SFLRXaOqh9p7F+dsXLtxh6qVyqna9PT0yJ7VEb9nL/7N8/hZcufKoSq4v8xzyXIffE+cxTlHVo6dOEuG9OlUBfdnTRvWUiu6Hzz6m7v3HzF57CBAfYa6WmV39uz35e79x+TOlT3Ra/rM3s6G04c3JR4ISf6d+9rAYZOZt3iV6n31Ku5sX7/4h/r6UWm+6G7SpAmBgYGMHTuWly9fki9fPvbs2UOWLFkAePnyJX5+fqr4mJgYvL29efz4cdwvX/bsTJ48mc6dO6fWJQghvhIZHcPoo5cAaO/qLEW3EEKIX87aZTOZNG0hK1ZvYvTE2aRPb0zdmpWZOHoAdrbW+AcEAtDUq/c3+wh6G4yOjg7R0dFk1uLu2ecvXqNmg/aUK1OchbPGkcneFgMDfXbuOczk6YsI+/RJLd7O1jrJfTdrVJshI6ey2mcb40f25/adB1y4dJ05/yxtBvjw4SMVa7ZAqVQyemhvcuZwwtjIkGfPX9G4dU+N8Y2NjTAxSZ/o2H7PXlChZkucczgxfdIwsjhmwlBpwPlL1+k9cKxGv0kVGPSOjPF8Bhkzxt1HHPT2nVq7pbmZ2vvPtwMkdXyLr843MNDH2NgIQ0OlRnvI+4//5vn2HVkcM2nm+c/9zp9vdQh8+w4bG83b/mxt1K/R3z/ud3bIyKkMGTk13ly/d5MyAwMDCubPnaTYxJbiO2TOyIPjf6s21vusT/e2NG8ctyqkQYtu35VfcknzRTdAt27d6NYt/g9o5cqVau979uwps9pCCCGEECJVWVmaM33SUKZPGorfsxfs3nuE4WNn4B8QyO7NS7G0MANg5pThuH1jttXWxpLo6Bh0dXV59iLhJ/d8LsDCw9Xv8X4TmHgRtHHrn+jr67HdZ5FaIbdzz+F44xPZz1iNuZkptatXZO2GHYwZ1oc/1m3F0FBJkwY1VTFHT5zlxUt/Du5aRbnSxVXt74Lff2P8pCWw889DfPwYyoZVc8ni8G/xefX6naRfQDwsLcx4+TpAo/3lS3/V8bTA0tyMV6/iyfPVP3lamqniLly8phH32l/93M/xg/p2wvOfZe1f+97Z6ORcXv556f2+g8eoX7eaqt0hc0bVqgSDL1abpKSfougWQgghhBDiZ+WY2Z5uHVty9PhfnDkbt9KrlJsrZqYm3L77kG4dWyZ4ftnSxdi6Yz9jh/fFytI83pjPReX1m3cp6ppf1b5n/9FE81MoFOjp6aKr++99rmFhn1i3YWei5yZF6+b12bx9L3sPHsNn0y7q1qyEmanJF+PH/a/SQH1DuKUrN/yncT8X51/2Gxsbq3Gf8ueYsE9J2wOqfLkS7PjzEC9evsY+47+bO6/ZsB1jY6M084ix8u4lmDpzCZev3qRwwbyq9jUbtqNQKFQFrHtZNzZv38uuvUfUlpiv37xbrb9cObORI3sWrt24y7gRmpus/YjkXF7ernUjZs1fgffoaZR0c/3mDuapQYpuIYQQQgghklFwyHuq1GlDkwY1yeWcjQzp03Hh0nUOHD6hmiFMnz4dM6cMp323Ibx9G0z9OlWwtrbkzZsgrt24S0BgEPOmjwbgt/FDKF+jOWUqN2Zg745kz+aIv38gu/cdYf6MMWTIkJ5qld2xMDelc69hjPTuhZ6eLqvXbePp84RnyAGqV/Fg9oKVtO44gPZtGhMU9I6Z85djoEyeWcHKFUqT2d6O3gPG8up1gMYO1yWLF8bczJQe/UczfFB39PT1WL9pF9du/rcZ6YoepTEw0Kd1x/7069mB8PBwFi/34W1wsEZsvjzObN99kMXLfXAtmBcdHQVFCuePp1cYNqg7e/b7UqVuG4YN7I65mSnrN+9i74FjTBw9UG0TtdTUq6sXa9fvwLNpF0YO6Ymjgz17Dxxj8TIfOrVrpipiWzapy5yFK2nfdTBjhvchR7Ys7Dt4nENHTmn0OX/GGOo07kTNBu1p3bwe9hltCXobzN17D7l89RY+K2d/V44GBgbf/Jy/l5mpCZtWz6N+864UK+dJp7ZNKV60EOnTGxMY9I6Tp8/zyv8NJYoXTpbxvocU3UIIIYQQQiQjQ6WSYkUKsG7jTv72e05kVBQOmTMyoFcH+n/xOKnmjevgkDkj0+cspXu/Ubz/EIqNlQUF8rvQutm/T+4pkM+Fkwc3MW7yXEaMm8H7Dx+xs7HGo6wbBv/M4pqYpGfXpqUMGDqRtl0GYWaSgbatGlK1Ujm69B6eYL7ly5VgydwJTJuzlPrNu2Kf0Zb2rRthbWVJ517D/vPnoaOjQ4umdZkyYzEOmTKqdmX/zNLCnO3rFzF4xBS8ugwinbFR3JL0ZTNx8/j+R1B95uKcjfV/zGH0hNk0adMTS3MzmjSsRe9ubanTuKNabI8urbl15wEjx80kOOR93NOPguIv+nPlzMaxfT6MGD9TdW+4i3N2fp838YcemaUt1lYW+O73YcTYGYwYN4OQ9x/J6pSZiaMHqHZDh7h75Pdv/4P+3hMYPnY6ChRUKl+a1Uun415N/ZHLHmVLcOrQJiZPX8SAoZN4+y4ESwszXHJlp6Fnta9TSHFuxQpx6dQu5i1exc49h5m1YCUREZFYW5lTuGBeFs4ap3ZrQ0pRxH79xPtksnLlSho3bozxN57bl5aFhIRgampKcHAwJiYmiZ8g/i9cunSJIkWKcLRtDQraWaZ2Oj+1jxGROExfD8DT/k1JZ6D+TfrVV4GUX7GHixcv4urqmhopCiGE+EUcOXKEy+d86dm5RWqnIoRIw2YvXEOxUhXx8PBI8jlJrRu19oAyb29v7OzsaN++PadPn9bWMEIIIYQQQgghRJqltaL72bNnrFmzhrdv31K+fHlcXFyYMmUKr14lfl+JEOLXZqiny87mldnZvDKGevK4MCGEEEII8evSWtGtq6tLnTp12Lp1K0+fPqVTp06sXbsWR0dH6tSpw44dO4iJidHW8EKINExXR4cyWewok8UOXR2t/TUkhBBCCCFEqkuRf+3a2NhQunRpSpYsiY6ODtevX8fLy4vs2bPj6+ubEikIIYQQQgghhBApTqtF9+vXr5k2bRp58+bFw8ODkJAQdu/ezePHj3nx4gX169enTZs22kxBCJEGRUbHsPTiXZZevEtktKx4EUIIIYQQvy6tFd21a9fGwcGBlStX0rFjR54/f46Pjw+VKlUCwMjIiP79+/P06VNtpSCESKMioqMZdOAcgw6cIyI6OrXTEUIIIZLNomXrWLVuq0b7E79nKC1c1I6tWrcVpYULT/yepWSKav5LDnsPHmPc5LlayCrp4zgXrECH7kO0noO2zF20CqWFC/sPnfhmzLI/NqK0cGH7rgMpllda+N38lWit6LaxseHYsWPcuHGDPn36YGFhoRGTMWNGHj9+rK0UhBBCCCGESFGLl/mw2mdbkmKrV/Hg+P71ZLS10XJW2rHv4DHGT52fquNsXD0P7wHdtJ6DtjRvXBul0oA/1m75ZsyqdVuxtrKgZrXyKZiZSE5aK7rd3d3jfb5uREQEq1atAkChUJAlSxZtpSCEEEIIIUSaZW1lgVuxQiiVBsnSX2hoWLL08zMpVCAP2bM6pnYaP8zSwpza1Suya+9hAoPeahy/c+8Rf52/QosmddHX10+FDEVy0FrR3bZtW4KDgzXa379/T9u2bbU1rBBCCCGEEEl26q+LVPX0wtLRFbNMhXCv2pQ9B3zVYsZNnovSwkXj3K+X4DoXrMCtO/c5fuo8SgsXlBYuOBes8M2xv7WE97Dvaap6emHlWASzTIXwqNaMI8fOxJvT5as3adqmF7ZZi5O7SJUEr/Xs+St4VGuGScYCOOUpy/Cx04mMjIo3dtPWPZSr0gTzzIWxcHClZoP2XLl2S3W8Q/chLFq6DkB1rV9eS2xsLIuWraNYOU9M7Qtim7U4Tdv04tETzVtL9x86QVVPL6yzFMUsUyEKuNVg6szFSRonvuXlfs9e4NV5IJmdS5HBLj8F3Gowc95ytScnfV7uP2PuMmbNX4FzoYpYOLhSrkoTzp6/kuDnmNy8WjYgIiKS9Zt3axz7fDuCV4sGAIyfMo8ylRpjl80NK8ciuHnUZ8XqzcTGxqqd51ywAp5NO7P/0AncPOpjal+Q/G7VWblGc0Y9qb8Xm7buoUb9dmTJXRZT+4IUcKvBsDHT+fgxVC2uQ/chWDi4cufeI2o2aI955sJkyV2W32YtUY1XvnpzzDMXJm+xqhorQz7//+Lo8b/o2nsEGbPHXWu7roP5+DGUV68DaN62DzZOxciSuyyDR0whMjJSrY+IiAgmTVtIfrfqZLDLT6acJenY3ZuAN0GJ/Ti0Qk9bHcfGxqJQKDTanz17hqmpqbaGFUIIIYQQIkmOnzpHjfrtyZ/XmcWzJ2CgNGDxsnXUb9aV1b9Pp1H9Gt/V38bV82jq1RtTkwzM+W0kwHfPYq/buJN2XQdTu0ZFli2YjJ6+HktXbqBWww7s3ryUCu4l1eKbtO5Jo/o16di2KR8TmOm+fecB1eq1JYtDJpbOm4SRsRGLl61jw+Y/NWKnzFjEqAmzadO8PkMGdCUyIpIZc5dRoWZLTh3cSG6XHHgP6MbHj2Fs3bmf4/vXq879vFS+W9+RrPbZTvdOLZkwqj9v3wUzYeoCPKo14/zx7djaWAGwYvVmuvYZQbnSxZg3YzTWVpbcf/iEm7fvAyQ6ztcC3gThUbUZEZGRjBraiywOmdhzwJchI6fy6MlT5k4bpRa/aNk6cuXMxrSJQwEYM3E2dZt05u6VQ5iaZPjm5wkQFRX/FxZf09XVjbcu+qyiRymyONjzx9qtdO/UStUeHR3Nuo07cCtakNwuOQD42+85Hbya4JA5IwDnLlyl75DxvHj5mmGDuqv1e/3GXQaPmMLAPh2xsbZkxerNdO41jOzZHClbqhjwfb8XDx79TbXK7vTs2oZ0xkbcvf+IabOXcuHSNfbv+EMtNjIykiate9KxbRP69WzPhs27GT52BiHvP7Bt1wEG9OrIUHtbFvy+hg7dvcmbOyeuhfKp9dGl93A8a1Vm9dIZXLl+m5HjZhIVFcW9B4/xrFWF9m0ac+TYGabN/p2Mdjb06R43sRsTE0ODFt059ddF+vdsT4nihfF7+oJxk+dSuXZrzhzZjJGRYZJ+dskl2YvuwoULo1AoUCgUVKxYET29f4eIjo7m8ePHVKtWLbmHFUIIIYQQ4rsMHzMdczMTDu5cRfr06QCoWdWDYuU8GTJyKg3rVU+wWPpaoQJ5MDI0xCRDOtyKFfrufEJDw+jvPYEaVT3YtHqeqr16ZXfcPOozctxMjaK7ZVNPRnr3SrTvCb8tIDY2lv07VqoK3hpV3ClcqrZa3NNnLxk7eR5dO7Zg5uThqvaKHqXIW6wa46fOZ+3ymWTP6oiNjSWAxrWePX+F5as2MWXcYFUhBFC6RFHyFa/G7AUrmTh6AB8+fGTQ8MmUcnNl/44/VJ/1l9eY0Djxmb1gBc9fvubkwY0UK1IAgCoVyxIdHcPvK9bTs0trnHNkVcVnSJ+O7esXoaurC4C9nQ2lKzVi/8HjNG5Q85vjPPF7Rq5ClRLNB+DAzj9wL+P2zeM6Ojq0alaP8VPnc+XaLQoVyAPAvkPHefkqgJFD/v35/j5/kup1TEwM7mWKExsby7zFqxg6sJva7+uboLcc3bcOx8z2AJQtVYyjx8+wfvNuVdGd1N8LAO8BXVWvY2NjKeXmiotzdirVasX1m3fJnzeX6nhERCRjhvXGs3bc6gv3MsXZc8CXqTOXcNZ3q+oaixTOR2bn0qzfvFuj6K5R1YMp4wYDUKl8ac6ev8KGLX8ydfwQenfzAuJ+Lw8eOcn6zbtUv2ubt+3lwOETbPhjjmp8gAL5clGqYiNW+Wyjc7tm3/x5aEOyF92enp4AXLlyhapVq5I+fXrVMQMDA5ycnGjQoEFyDyuEEEIIIUSSffwYyrmL1+jUrpmq4Ia4WcnmTeoybPQ07t5/jItzthTL6cy5ywS9DaZVU0+NWdQqFcsyfc5SPn4MJV06Y1V7vTpVk9T3sZNnKV+uhKqwgrhrbVSvutomZQePnCQqKoqWTeqq5WBoqKRsqWIcO3k20bH2HPBFoVDQvHEdtT7sbK0okDcXx0+eU11vyPsPdG7f7Lu+3EiI7/Gz5M6VQ1Vwf9a6WT2WLPfB98RZtaK7ehV3VcENqApHv2cvEhzH3s6G04c3JSmnL8f7ltYt6jNx2kJWrt3CrH8K0lVrt5IunTGN6lVXxR09/hdTZi7m4qXrhLz/oNaHf0Cg2s+3YD4XVcENcT/DnNmd8Hv677Ul9fcC4NGTp4yeMAvfE2fxDwhUW9J+5+5DtaJboVBQrbK76r2enh7Zszqip6erKrgBLMzNsLG2UMvpsxpVPNTeuzhnY+efcT+zr9sPHT2ler/ngC9mpibUrFZe7fevYP7c2Nlac/zkuZ+/6B41Km7JhpOTE02aNMHQMGWn7oUQaZ9ST5f1jcqrXgshhBAp7e27EGJjY8loa61xzN4ubulyUNC7FM3JPyAQgKZevb8ZE/Q2WK3otosn//gEBr3DzkYz1var8z/nUKpio3j70dFJfEsof/+4gswhV+l4j2d1cgDgTWDcxmGZ7O0S7TOpAt++I4tjJo32jN/4mVqYm6m9/3w7QFjYpwTHMTAwoGD+3EnK6cui/luyOGSifLkSbNi8myljB/P+w0f2HPClaYNaZMgQN4l5/uI1ajZoT7kyxVk4axyZ7G0xMNBn557DTJ6+iLBP6jlbWJhpjKNUGvDpi7ik/l58+PCRijVboFQqGT20NzlzOGFsZMiz569o3LqnxtjGxkYYGirV2gwM9DE308zJQF+fT+HhGu0W5qYacXHt6n0YGOjzKTxC9f61fyDvgkNIb5tfo0+IWwGQ0rR2T3ebNm201bUQ4ienp6NDlRyZUzsNIYQQ/8fMzUzQ0dHh5esAjWMvXvkDYGlpBqAqHsLDI9Tu0f5cNCYXy3+KpJlThuNWtGC8Mbb/LLX+LKkzxJYWZrzy17zW119d/+drXr9yNo4O9hrxSRrL0gyFQsGRP9eiVGruuP35M7SyNAfg+YtXPzROvGObm/HqleZ1vvzqZ/pfJefy8s/atmzIYd/T7NpzmBev/ImIiMSrVUPV8Y1b/0RfX4/tPovUCtqdew5//wX8I6m/F0dPnOXFS38O7lpFudLFVe3vgt//8NjaYmVphqWFGbs2/R7v8S9XtqSUZC26LSwsuHfvHlZWVpibmyf4l0BQUOrsHCeEEEIIIUS6dMYUL1KAHbsPMmXsINXGSjExMfhs3ElmezvVsuAsDnEzp9dv3qWo67+zZ3v2H9XoV6nUJyxMc9YuKUq5uWJmasLtuw/p1rHlD/XxLe5l3Ni97wiv/d+olhJHR0ezadtetbjKFcqgp6fHwydPE126rjT4d1b4y42palQpz2+zfufFy9c0/GJp9NdKFi+MqUkGfl+xnsb1a36zdvjWOPEp716CqTOXcPnqTQoXzKtqX7NhOwqFIknFb1Ik9/JygDo1K2FpYcbKtVt49TqAnDmcKF2iiOq4QqFAT08XXd1/VxuEhX1i3Yad35f8F5L6e/H5R/P5Z/HZ0pUbfnhsbalRtTwbt+4hOjqG4t/48iqlJWvRPXPmTDJkyKB6nVz3Zgghfi2R0TFsuvkYgEZ5s6Kvq7WnFwohhBDfNG5kP2rUb0+VOm3o26Mt+gZxu5ffvH2f1b9PV/1btlpldyzMTencaxgjvXuhp6fL6nXbePpcc4Y2Xx5nNm7dw6ate8jq5IChoQH58uTSiItP+vTpmDllOO27DeHt22Dq16mCtbUlb94Ece3GXQICg5g3ffQPXat3/y7s3neEqnW9GDawG0bGhixauk7j2d5OjpkZ5d2TUeNn8fjJU6pULIu5mQn+/oGcv3SNdMZGqo3b8uVxBmDa7N+pWqkcuro65M+bi1IlXGnfpjEdew7l4pUblClVlHTGRrx6HcCpvy6RL48znf+5l37KuMF06T2cavXa0r5VI2xsLHn4yI9rN+8we+rIBMcxMNDcGb5XVy/Wrt+BZ9MujBzSE0cHe/YeOMbiZT50atcsyQVwYgwMDChSOP7lyz9KqTSgacPaLPh9DbGxsUwY1V/tePUqHsxesJLWHQfQvk1jgoLeMXP+cgziWU2QVEn9vShZvDDmZqb06D+a4YO6o6evx/pNu7h2884Pj60tjevXwGfTLuo26USPzq0p6loAfX09nr94xbGTZ6ldvSJ1a1VO0ZyStej+ckm5l5dXcnYthPiFRERH0+PP0wDUdXGUolsIIUSqKFe6OPt3rGTs5Ll06DGUmJgYCuTNxZZ1C6hZtbwqzsQkPbs2LWXA0Im07TIIM5MMtG3VkKqVytGl93C1PkcM6cnLVwF07TOC9x8+ksXBnntXjyQ5p+aN6+CQOSPT5yyle79RvP8Qio2VBQXyu9C6Wb0fvta8eZzZu3U5g0dMoX33IZibmdK8cR3q1a5Ct74j1WIH9e2MS64czF+8io1b/iQ8IgI7GyuKFM5Px7ZNVXFNG9bizNnLLF7uo9oF++6VQzg5ZmbBzLG4FS3I0pUbWbzch5iYGDLa2VDKrTDFvlgt0LZVQzLa2TB9zu906TOC2NhYsjhkomUzzySN8zVrKwt89/swYuwMRoybQcj7j2R1yszE0QPUdlJPq9q2asj8JavR1dWlRZO6asfKlyvBkrkTmDZnKfWbd8U+oy3tWzfC2sqSzr2G/dB4Sf29sLQwZ/v6RQweMQWvLoNIZ2xE7eoVWbtsJm4e9f/TNSc3XV1dtq5bwNxFq1i3cSdTZy1BT0+XTBntKFu6GHn/+RInJSliv36S+n8QEhKS5FgTE5PkGjbZhYSEYGpqSnBwcJrOU6SsS5cuUaRIEY62rUFBO8vETxDf9DEiEofpcc/afNq/KekM1L+hvfoqkPIr9nDx4kVcXV1TI0UhhBC/iCNHjnD5nC89O7dI7VSEEGnY7IVrKFaqIh4eHkk+J6l1Y7LOdJuZmSW6pDw2NhaFQkF0dHRyDi2EEEIIIYQQQqQ5yVp0Hz2quZmEEEIIIYQQqSkmJtkWdgohflGxMTFa6ztZi253d/fEg4QQQgghhEghhoaGfPoUTkxMTJKeMS2E+P8THR3Np/AIDA0T3h3/RyVr0X3t2jXy5cuHjo4O165dSzC2QIECyTm0EEIIIYQQGpycnIiMUfDE7znZnBxSOx0hRBr0+O9nRMXq4OTkpJX+k7XoLlSoEK9evcLGxoZChQqhUCiIb582uadbCCGEEEKkhIwZM2Jhacvxk+fJlNEWpVLzMVNCiP9f4eERHD95HktrO2xtbbUyRrIW3Y8fP8ba2lr1Wggh4qPU02W5ZznVayGEEEJbFAoFDRs1ZtUfy1m+ajP58znj6GCPgf6PP9tYCPHzC4+I4Omzl1y7cY+wKD1at2mc6KbgPypZi+4sWbLE+1oIIb6kp6ODZ275O0IIIUTKyJw5M15tO3Dy5ElOX7iJ7+lrkHxPzRVC/IwUCpRKY5xd8lGmTBkyZsyotaGStej+2t27d5k7dy63b99GoVDg4uJCz549yZUrlzaHFUIIIYQQQo29vT2NGzcmMjKSd+/eERERkdopCSFSkYGBAWZmZuinwKoXrRXdmzdvplmzZhQtWpSSJUsC8Ndff5EvXz7WrVtHo0aNtDW0ECKNi4qJYffdpwDUyuWAnuwmK4QQIoXo6+urbocUQoiUoLWie9CgQXh7ezN27Fi19lGjRjF48GApuoX4PxYeFU277ccBeNq/KXoGUnQLIYQQQohfk9b+pfvq1Stat26t0d6yZUtevXqlrWGFEEIIIYQQQog0Q2tFt4eHBydOnNBoP3nyJGXLltXWsEIIIYQQQgghRJqRrMvLd+7cqXpdp04dBg8ezMWLFylRogQQd0/3pk2bGDNmTHIOK4QQQgghhBBCpEnJWnR7enpqtC1YsIAFCxaotXXv3p0uXbok59BCCCGEEEIIIUSak6xFd0xMTHJ2J4QQQgghhBBC/NRky2AhhBBCCCGEEEJLtPbIMICPHz9y7Ngx/Pz8iIiIUDvWq1cvbQ4thEjDDHR1mVezlOq1EEIIIYQQvyqtFd2XL1+mRo0ahIaG8vHjRywsLHjz5g3GxsbY2NhI0S3E/zF9XR2aF8ie2mkIIYQQQgihdVoruvv27Uvt2rVZuHAhZmZm/PXXX+jr69OyZUt69+6trWGFEL+Q27dvp3YK/zesrKxwdHRM7TSEEEIIIX45Wiu6r1y5wuLFi9HV1UVXV5fw8HCyZcvG1KlTadOmDfXr19fW0EKINC4qJoYjj14AUCGbPXo66ttLvP4QhgJo2bJlKmT3/8nYyIjbd+5I4S2EEEIIkcy0VnTr6+ujUCgAsLW1xc/Pj9y5c2Nqaoqfn5+2hhVC/ATCo6JpuukoAE/7N0XPQL3oDv4UQSwws5IrhRzsUiHD/y/33gTTedcp3rx5I0W3EEIIIUQy01rRXbhwYS5cuICzszPly5dn5MiRvHnzhtWrV5M/f35tDSuE+IXkME9PQTvL1E5DCCGEEEKIH6a1onvixIm8f/8egHHjxtGmTRu6du1Kjhw5WLFihbaG/b/j5+fHmzdvUjuN/wtyf7EQQgghhBDie2mt6C5atKjqtbW1NXv27NHWUP+3/Pz8yO3iQmhYWGqn8n8lPDw8tVMQQgghhBBC/CS0+pxuAH9/f+7evYtCoSBXrlxYW1tre8j/G2/evCE0LIzFtUvjbGWa2un88g49eM6EE1eJjIxM7VSEEEIIIYQQPwmtFd0hISF0796d9evXEx0dDYCuri5NmjRh/vz5mJpKkZhcnK1M5b7XFHDvTXBqpyCEEEIIIYT4yegkHvJjOnTowNmzZ9m9ezfv3r0jODiY3bt3c+HCBTp27KitYYUQQgghhBBCiDRDazPdf/75J/v376dMmTKqtqpVq/L7779TrVo1bQ0rhPgJGOjqMrVKcdVrIYQQQgghflVaK7otLS3jXUJuamqKubm5toYVQvwE9HV16FAkV2qnIYQQQgghhNZpbXn58OHD6devHy9fvlS1vXr1ioEDBzJixAhtDSuEEEIIIYQQQqQZyTrTXbhwYRQKher9/fv3yZIlC46OjkDcI66USiUBAQF07tw5OYcWQvxEomNiOPPUH4CSDjbo6mjt+z8hhBBCCCFSVbIW3Z6ensnZnRDiF/UpKpo66w4C8LR/U9IZSNEthBBCCCF+TcladI8aNSo5uxNCCCGEEEIIIX5qWttI7bOLFy9y+/ZtFAoFefLkoXDhwtoeUgghhBBCCCGESBO0VnT7+/vTtGlTfH19MTMzIzY2luDgYMqXL8/69euxtrbW1tBCCCGEEEIIIUSaoLUbKXv27ElISAg3b94kKCiIt2/fcuPGDUJCQujVq5e2hhVCCCGEEEIIIdIMrc1079u3j0OHDpE7d25VW548eZg/fz5VqlTR1rBCCCGEEEIIIUSaobWZ7piYGPT19TXa9fX1iYmJ+a6+FixYQNasWTE0NKRIkSKcOHHim7Fbt26lcuXKWFtbY2JiQsmSJdm/f/935y+EEEIIIYQQQvxXWiu6K1SoQO/evXnx4oWq7fnz5/Tt25eKFSsmuZ8NGzbQp08fhg0bxuXLlylbtizVq1fHz88v3vjjx49TuXJl9uzZw8WLFylfvjy1a9fm8uXL//mahBDJQ19Xh9HlXRld3hV9XXlcmBBCCCGE+HVpbXn5vHnzqFu3Lk5OTjg4OKBQKPDz8yN//vysWbMmyf3MmDGD9u3b06FDBwBmzZrF/v37WbhwIZMmTdKInzVrltr7iRMnsmPHDnbt2iU7pwuRRhjo6tKrRN7UTkMIIYQQQgit01rR7eDgwKVLlzh48CB37twhNjaWPHnyUKlSpST3ERERwcWLFxkyZIhae5UqVTh9+nSS+oiJieH9+/dYWFh8V/5CCCGEEEIIIcR/pZWiOyoqCkNDQ65cuULlypWpXLnyD/Xz5s0boqOjsbW1VWu3tbXl1atXSepj+vTpfPz4kcaNG38zJjw8nPDwcNX7kJCQH8pXCJE00TExXH0VBEBBOwt0dWSJuRBCCCGE+DVp5V+6enp6ZMmShejo6GTpT6FQqL2PjY3VaIuPj48Po0ePZsOGDdjY2HwzbtKkSZiamqr+ODg4/OechRDf9ikqmkp/7KXSH3v5FJU8f08IIYQQQgiRFmltemn48OF4e3sTFBT0w31YWVmhq6urMavt7++vMfv9tQ0bNtC+fXs2btyY6JJ2b29vgoODVX+ePn36wzkLIYQQQgghhBCfae2e7jlz5vDgwQPs7e3JkiUL6dKlUzt+6dKlRPswMDCgSJEiHDx4kHr16qnaDx48SN26db95no+PD+3atcPHx4eaNWsmOo5SqUSpVCYaJ4QQQgghhBBCfA+tFd2enp4oFApiY2P/Uz/9+vWjVatWFC1alJIlS7JkyRL8/Pzo0qULEDdL/fz5c1atWgXEFdytW7dm9uzZlChRQjVLbmRkhKmp6X+7KCGEEEIIIYQQ4jske9EdGhrKwIED2b59O5GRkVSsWJG5c+diZWX1Q/01adKEwMBAxo4dy8uXL8mXLx979uwhS5YsALx8+VLtmd2LFy8mKiqK7t270717d1V7mzZtWLly5X+6NiGEEEIIIYQQ4nske9E9atQoVq5cSYsWLTAyMmLdunV07dqVTZs2/XCf3bp1o1u3bvEe+7qQ9vX1/eFxhBBCCCGEEEKI5JTsRffWrVtZtmwZTZs2BaBFixaULl2a6OhodHV1k3s4IYQQQgghhBAizUr2ovvp06eULVtW9b548eLo6enx4sULeRSXEAIAfV0dBpUpoHothBBCCCHEryrZi+7o6GgMDAzUB9HTIyoqKrmHEkL8pAx0dRlStmBqpyGEEEIIIYTWJXvRHRsbi5eXl9ojuD59+kSXLl3UHhu2devW5B5aCCGEEEIIIYRIU5K96G7Tpo1GW8uWLZN7GCHETywmNpa7b4IByGVlio5CkcoZCSGEEEIIoR3JXnSvWLEiubsUQvxiwiKjKL10FwBP+zclnYF+KmckhBBCCCGEdsgORkIIIYQQQgghhJZI0S2EEEIIIYQQQmiJFN1CCCGEEEIIIYSWSNEthBBCCCGEEEJoiRTdQgghhBBCCCGElkjRLYQQQgghhBBCaEmyPzJMCCESo6+rQw+3PKrXQgghhBBC/Kqk6BZCpDgDXV3GViiS2mkIIYQQQgihdTLFJIQQQgghhBBCaInMdAshUlxMbCzPgj8CkNk0HToKRSpnJIQQQgghhHbITLcQIsWFRUZRaOE2Ci3cRlhkVGqnI4QQQgghhNZI0S2EEEIIIYQQQmiJFN1CCCGEEEIIIYSWSNEthBBCCCGEEEJoiRTdQgghhBBCCCGElkjRLYQQQgghhBBCaIkU3UIIIYQQQgghhJbIc7qFEClOT0eH9q7OqtdCCCGEEEL8qqToFkKkOKWeLr9VdUvtNIQQQgghhNA6mWISQgghhBBCCCG0RGa6hRApLjY2lsCwcAAsjZQoFIpUzkgIIYQQQgjtkJluIUSKC42Mwnn2JpxnbyI0Miq10xFCCCGEEEJrpOgWQgghhBBCCCG0RIpuIYQQQgghhBBCS6ToFkIIIYQQQgghtESKbiGEEEIIIYQQQkuk6BZCCCGEEEIIIbREim4hhBBCCCGEEEJL5DndQogUp6ejQ7P82VSvhRBCCCGE+FVJ0S2ESHFKPV3m1yqd2mkIIYQQQgihdTLFJIQQQgghhBBCaInMdAshUlxsbCyhkVEAGOvroVAoUjkjIf7H3n3H13z9cRx/RXbIkIRYiU1sYs/Eir1r761WUVq79qq9qVXUplbNVm1F7aJKVW0xEzOR5P7+UPfnSiRBkhu8n4/HffTe8z3nfD/fr2h87jnfc0RERETihka6RSTePXkeiue4ZXiOW2ZMvkVEREREPkZKukVERERERETiiJJuERERERERkTiipFtEREREREQkjijpFhEREREREYkjSrpFRERERERE4oiSbhEREREREZE4on26RSTeWSZKRHVvL+N7EREREZGPlZJuEYl3dlaWLKjla+4wRERERETinIaYREREREREROKIkm4RERERERGROKKkW0Ti3eOQ57iOXITryEU8Dnlu7nBEREREROKMkm4RERERERGROKKkW0RERERERCSOKOkWERERERERiSNKukVERERERETiiJJuERERERERkTiipFtEREREREQkjliZOwAR+fRYJkpE+Yypje9FRERERD5WSrpFJN7ZWVmyvF4Zc4chIiIiIhLnNMQkIiIiIiIiEkc+iKR7+vTppE+fHjs7O/Lnz8+ePXveWPfGjRs0atSIrFmzkihRIrp16xZ/gYqIiIiIiIi8IsEn3cuXL6dbt27069ePY8eOUbJkSSpVqsTly5cjrR8cHEyyZMno168fefLkiedoRSQmHoc8J83YJaQZu4THIc/NHY6IiIiISJxJ8En3+PHjad26NW3atCFbtmxMnDgRT09PZsyYEWn9dOnSMWnSJJo1a4azs3M8RysiMfXkeRhPnoeZOwwRERERkTiVoJPukJAQjhw5gr+/v0m5v78/+/fvN1NUIiIiIiIiIjGToFcvv3PnDmFhYXh4eJiUe3h4cPPmzVg7T3BwMMHBwcbPQUFBsda3iIiIiIiIfLoS9Ej3SxYWFiafDQZDhLL3MXLkSJydnY0vT0/PWOtbREREREREPl0JOul2d3fH0tIywqh2QEBAhNHv99GnTx8CAwONrytXrsRa3yIiIiIiIvLpStBJt42NDfnz52f79u0m5du3b6dYsWKxdh5bW1ucnJxMXiIiIiIiIiLvK0E/0w3Qo0cPmjZtSoECBShatCizZ8/m8uXLdOjQAXgxSn3t2jUWLlxobHP8+HEAHj16xO3btzl+/Dg2NjZkz57dHJcgIq9JZGFBcS8P43sRERERkY9Vgk+669evz927dxkyZAg3btwgZ86cbNq0ibRp0wJw48aNCHt258uXz/j+yJEjLFmyhLRp03Lp0qX4DF1E3sDe2ooNjf2jrygiIiIi8oFL8Ek3QMeOHenYsWOkxxYsWBChzGAwxHFEIiIiIiIiItFL0M90i4iIiIiIiHzIlHSLSLx7HPKczBNXkHniCh6HPDd3OCIiIiIiceaDmF4uIh+fu0+DzR2CiIiIiEic00i3iIiIiIiISBxR0i0iIiIiIiISR5R0i4iIiIiIiMQRJd0iIiIiIiIicURJt4iIiIiIiEgc0erlIhLvEllYkC+Fm/G9iIiIiMjHSkm3iMQ7e2srfmlZ2dxhiIiIiIjEOU0vFxEREREREYkjGukWEREAzp49a+4QPhnu7u54eXmZOwwRERGJB0q6RSTePXkeStHv1gNwoG11HKz1vyJzuvXoKRZAkyZNzB3KJ8PB3p6zf/6pxFtEROQToH/piki8MxgMXAl8bHwv5hX4LAQDMKGcD3k9U5g7nI/eX3cCab9hH3fu3FHSLSIi8glQ0i0iIgBkSpqEPP+tKi8iIiIisUMLqYmIiIiIiIjEESXdIiIiIiIiInFESbeIiIiIiIhIHFHSLSIiIiIiIhJHtJCaiMQ7CwsLsro7G9+LiIiIiHyslHSLSLxzsLbiQNvq5g5DRERERCTOaXq5iIiIiIiISBxR0i0iIiIiIiISR5R0i0i8e/I8lKLfrafod+t58jzU3OGIiIiIiMQZPdMtIvHOYDBw7k6g8b2IiIiIyMdKI90iIiIiIiIicURJt4iIiIiIiEgcUdItIiIiIiIiEkeUdIuIiIiIiIjEESXdIiIiIiIiInFEq5eLSLyzsLDA0zmx8b2IiIiIyMdKSbeIxDsHaytOdKxt7jBEREREROKcppeLiIiIiIiIxBEl3SIiIiIiIiJxREm3iMS7p89DKTt/E2Xnb+Lp81BzhyMiIiIiEmf0TLeIxLtwg4FjN+8a34uIiIiIfKw00i0iIiIiIiISR5R0i4iIiIiIiMQRJd0iIiIiIiIicURJt4iIiIiIiEgcUdItIiIiIiIiEke0ermImIWbva25QxARERERiXNKukUk3iW2seZ8t3rmDkNEREREJM5permIiIiIiIhIHFHSLSIiIiIiIhJHlHSLSLx7+jyUaj9so9oP23j6PNTc4YiIiIiIxBk90y0i8S7cYGDf5VvG9yIiIiIiHyuNdIuIiIiIiIjEESXdIiIiIiIiInFESbeIiIiIiIhIHFHSLSIiIiIiIhJHlHSLiIiIiIiIxBGtXi4iZuFgbWnuEERERERE4pySbhGJd4ltrLnas5G5wxARERERiXOaXi4iIiIiIiISRzTSLSIiYgZnz541dwifDHd3d7y8vMwdhoiIfKKUdItIvHsWGkbzNbsA+L62L3ZWer5bPh23Hj3FAmjSpIm5Q/lkONjbc/bPP5V4i4iIWSjpFpF4FxYezva/rxnfg5Ju+XQEPgvBAEwo50NezxTmDuej99edQNpv2MedO3eUdIuIiFko6RYRETGDTEmTkCeFm7nDEBERkTimhdRERERERERE4sgHkXRPnz6d9OnTY2dnR/78+dmzZ0+U9Xft2kX+/Pmxs7MjQ4YMzJw5M54iFREREREREfm/BJ90L1++nG7dutGvXz+OHTtGyZIlqVSpEpcvX460/j///EPlypUpWbIkx44do2/fvnTt2pXVq1fHc+QiIiIiIiLyqUvwz3SPHz+e1q1b06ZNGwAmTpzI1q1bmTFjBiNHjoxQf+bMmXh5eTFx4kQAsmXLxu+//87YsWOpU6dOfIYuIiIiCYS2aIs/2qJNRMRUgk66Q0JCOHLkCL179zYp9/f3Z//+/ZG2OXDgAP7+/iZlFSpUYO7cuTx//hxra+sIbYKDgwkODjZ+DgwMBCAoKOh9LyFOPXr0CIATN+7yOOS5maP5+J2/8+Ln4o/bgVjY3DRzNB+2Z8/DjO8PXgnAztp09XLd6/il+x2/dL/j1+GrdwBt0Raf7GxtWbhoER4eHuYO5ZOQKFEiwsPDzR3GJ0P3O36lSJGCFCkS7k4fL/NFg8EQdUVDAnbt2jUDYNi3b59J+fDhww1ZsmSJtE3mzJkNw4cPNynbt2+fATBcv3490jbffPONAdBLL7300ksvvfTSSy+99NJLr7d6XblyJcq8NkGPdL9kYWFh8tlgMEQoi65+ZOUv9enThx49ehg/h4eHc+/ePdzc3KI8j7kFBQXh6enJlStXcHJyMnc4IrFGP9vyMdPPt3zM9PMtHzP9fMvrDAYDDx8+JFWqVFHWS9BJt7u7O5aWlty8aTr9LiAg4I1TllKkSBFpfSsrK9zcIt8P1dbWFltbW5MyFxeXdw88njk5OekvvnyU9LMtHzP9fMvHTD/f8jHTz7e8ytnZOdo6CXr1chsbG/Lnz8/27dtNyrdv306xYsUibVO0aNEI9bdt20aBAgUifZ5bREREREREJK4k6KQboEePHsyZM4d58+Zx9uxZunfvzuXLl+nQoQPwYmp4s2bNjPU7dOjAv//+S48ePTh79izz5s1j7ty59OzZ01yXICIiIiIiIp+oBD29HKB+/frcvXuXIUOGcOPGDXLmzMmmTZtImzYtADdu3DDZszt9+vRs2rSJ7t27M23aNFKlSsXkyZM/yu3CbG1t+eabbyJMjRf50OlnWz5m+vmWj5l+vuVjpp9veVcWBkN065uLiIiIiIiIyLtI8NPLRURERERERD5USrpFRERERERE4oiSbhEREREREZE4oqRbREREREREJI4o6f5ATZ8+nfTp02NnZ0f+/PnZs2ePuUMSeW8jR46kYMGCODo6kjx5cmrWrMm5c+fMHZZIrBs5ciQWFhZ069bN3KGIxJpr167RpEkT3NzccHBwIG/evBw5csTcYYm8l9DQUPr370/69Omxt7cnQ4YMDBkyhPDwcHOHJh8QJd0foOXLl9OtWzf69evHsWPHKFmyJJUqVTLZOk3kQ7Rr1y46derEb7/9xvbt2wkNDcXf35/Hjx+bOzSRWHP48GFmz55N7ty5zR2KSKy5f/8+xYsXx9rams2bN3PmzBnGjRuHi4uLuUMTeS+jR49m5syZTJ06lbNnzzJmzBi+/fZbpkyZYu7Q5AOiLcM+QIULF8bHx4cZM2YYy7Jly0bNmjUZOXKkGSMTiV23b98mefLk7Nq1i1KlSpk7HJH39ujRI3x8fJg+fTrDhg0jb968TJw40dxhiby33r17s2/fPs28k49O1apV8fDwYO7cucayOnXq4ODgwKJFi8wYmXxINNL9gQkJCeHIkSP4+/ublPv7+7N//34zRSUSNwIDAwFwdXU1cyQisaNTp05UqVKFcuXKmTsUkVi1fv16ChQoQN26dUmePDn58uXju+++M3dYIu+tRIkS/PLLL/z1118AnDhxgr1791K5cmUzRyYfEitzByBv586dO4SFheHh4WFS7uHhwc2bN80UlUjsMxgM9OjRgxIlSpAzZ05zhyPy3pYtW8bRo0c5fPiwuUMRiXUXL15kxowZ9OjRg759+3Lo0CG6du2Kra0tzZo1M3d4Iu/s66+/JjAwEG9vbywtLQkLC2P48OE0bNjQ3KHJB0RJ9wfKwsLC5LPBYIhQJvIh69y5MydPnmTv3r3mDkXkvV25coUvvviCbdu2YWdnZ+5wRGJdeHg4BQoUYMSIEQDky5eP06dPM2PGDCXd8kFbvnw5ixcvZsmSJeTIkYPjx4/TrVs3UqVKRfPmzc0dnnwglHR/YNzd3bG0tIwwqh0QEBBh9FvkQ9WlSxfWr1/P7t27SZMmjbnDEXlvR44cISAggPz58xvLwsLC2L17N1OnTiU4OBhLS0szRijyflKmTEn27NlNyrJly8bq1avNFJFI7OjVqxe9e/emQYMGAOTKlYt///2XkSNHKumWGNMz3R8YGxsb8ufPz/bt203Kt2/fTrFixcwUlUjsMBgMdO7cmTVr1rBjxw7Sp09v7pBEYkXZsmU5deoUx48fN74KFChA48aNOX78uBJu+eAVL148whaPf/31F2nTpjVTRCKx48mTJyRKZJoyWVpaassweSsa6f4A9ejRg6ZNm1KgQAGKFi3K7NmzuXz5Mh06dDB3aCLvpVOnTixZsoR169bh6OhonNHh7OyMvb29maMTeXeOjo4R1iZInDgxbm5uWrNAPgrdu3enWLFijBgxgnr16nHo0CFmz57N7NmzzR2ayHupVq0aw4cPx8vLixw5cnDs2DHGjx9Pq1atzB2afEC0ZdgHavr06YwZM4YbN26QM2dOJkyYoC2V5IP3pnUJ5s+fT4sWLeI3GJE45ufnpy3D5KOyceNG+vTpw/nz50mfPj09evSgbdu25g5L5L08fPiQAQMG8OOPPxIQEECqVKlo2LAhAwcOxMbGxtzhyQdCSbeIiIiIiIhIHNEz3SIiIiIiIiJxREm3iIiIiIiISBxR0i0iIiIiIiISR5R0i4iIiIiIiMQRJd0iIiIiIiIicURJt4iIiIiIiEgcUdItIiIiIiIiEkeUdIuIiIiIiIjEESXdIiIiEi8WLFiAi4vLe/cTEhJCpkyZ2LdvX7R1e/bsSdeuXd/7nCIiIu9KSbeIiIh8UGbPnk3atGkpXrw4AA8fPqRx48bky5ePXLlyMXToUGPdr776ivnz5/PPP/+YK1wREfnEKekWERFJoAwGA6GhoRHKQ0JC3qm/d22X0EyZMoU2bdoYP48YMYKkSZNy7NgxDh06xLp169i2bRsAyZMnx9/fn5kzZ5orXBER+cQp6RYREYknBoOBMWPGkCFDBuzt7cmTJw+rVq0yHt+5cycWFhZs3bqVAgUKYGtry549e/Dz86Nz58706NEDd3d3ypcvD8CuXbsoVKgQtra2pEyZkt69e5sk6W9q97rDhw9Tvnx53N3dcXZ2xtfXl6NHj5rUsbCwYM6cOdSqVQsHBwcyZ87M+vXrTeqsX7+ezJkzY29vT+nSpfn++++xsLDgwYMHb7wnGzZsIH/+/NjZ2ZEhQwYGDx4c6RcNLx09epQLFy5QpUoVY9nJkyeNn+3t7SlTpgwnTpwwHq9evTpLly59Y58iIiJxSUm3iIhIPOnfvz/z589nxowZnD59mu7du9OkSRN27dplUu+rr75i5MiRnD17lty5cwPw/fffY2Vlxb59+5g1axbXrl2jcuXKFCxYkBMnTjBjxgzmzp3LsGHDTPp6vV1kHj58SPPmzdmzZw+//fYbmTNnpnLlyjx8+NCk3uDBg6lXrx4nT56kcuXKNG7cmHv37gFw6dIlPvvsM2rWrMnx48dp3749/fr1i/J+bN26lSZNmtC1a1fOnDnDrFmzWLBgAcOHD39jm927d5MlSxacnJyMZbly5WLz5s0APHv2jJ07dxrvG0ChQoW4cuUK//77b5TxiIiIxAmDiIiIxLlHjx4Z7OzsDPv37zcpb926taFhw4YGg8Fg+PXXXw2AYe3atSZ1fH19DXnz5jUp69u3ryFr1qyG8PBwY9m0adMMSZIkMYSFhb2xXUyEhoYaHB0dDRs2bDCWAYb+/fubXI+FhYVh8+bNBoPBYPj6668NOXPmNOmnX79+BsBw//59g8FgMMyfP9/g7OxsPF6yZEnDiBEjTNosWrTIkDJlyjfG9sUXXxjKlCljUhYYGGho0KCBIW/evIacOXMavvnmmwjHAcPOnTujvXYREZHYZmXelF9EROTTcObMGZ49exZhindISAj58uUzKStQoECE9q+XnT17lqJFi2JhYWEsK168OI8ePeLq1at4eXm9sa/XBQQEMHDgQHbs2MGtW7cICwvjyZMnXL582aTeq6PHiRMnxtHRkYCAAADOnTtHwYIFTeoXKlQoyvMeOXKEw4cPm4xsh4WF8ezZM548eYKDg0OENk+fPsXOzs6kzMnJKcrp4/b29gA8efIkynhERETigpJuERGReBAeHg7ATz/9ROrUqU2O2dramnxOnDhxhPavlxkMBpOE+2UZYFIeWV+va9GiBbdv32bixImkTZsWW1tbihYtGmHhNWtra5PPFhYWxuuKKp43CQ8PZ/DgwdSuXTvCsdcT65fc3d05deqUSdl3333HuHHjTMqWLFmCj48PgHEKfLJkyaKMR0REJC4o6RYREYkH2bNnx9bWlsuXL+Pr6xsr/a1evdok2d2/fz+Ojo4Rkvro7Nmzh+nTp1O5cmUArly5wp07d96qD29vbzZt2mRS9vvvv0fZxsfHh3PnzpEpU6YYnydfvnzMmDHD5Lrbtm1L27Zt39jmjz/+wNramhw5csT4PCIiIrFFSbeIiEg8cHR0pGfPnnTv3p3w8HBKlChBUFAQ+/fvJ0mSJDRv3vyt+uvYsSMTJ06kS5cudO7cmXPnzvHNN9/Qo0cPEiV6u3VSM2XKxKJFiyhQoABBQUH06tXLOCU7ptq3b8/48eP5+uuvad26NcePH2fBggUAEUbAXxo4cCBVq1bF09OTunXrkihRIk6ePMmpU6ciLAj3UunSpXn8+DGnT58mZ86cMYptz549lCxZ8q2vSUREJDZo9XIREZF4MnToUAYOHMjIkSPJli0bFSpUYMOGDaRPn/6t+0qdOjWbNm3i0KFD5MmThw4dOtC6dWv69+//1n3NmzeP+/fvky9fPpo2bUrXrl1Jnjz5W/WRPn16Vq1axZo1a8idOzczZswwrl7++vT5lypUqMDGjRvZvn07BQsWpEiRIowfP560adO+8Txubm7Url2bH374IcaxLV26NMqRcBERkbhkYYjugSsRERGRdzB8+HBmzpzJlStXYrXfU6dOUa5cOS5cuICjo2OUdX/66Sd69erFyZMnsbLSBD8REYl/GukWERGRWDF9+nQOHz7MxYsXWbRoEd9+++1bT5uPiVy5cjFmzBguXboUbd3Hjx8zf/58JdwiImI2GukWERGRWNG9e3eWL1/OvXv38PLyomnTpvTp00cJr4iIfNKUdIuIiIiIiIjEEU0vFxEREREREYkjSrpFRERERERE4oiSbhEREREREZE4oqRbREREREREJI4o6RYRERERERGJI0q6RUREREREROKIkm4RERERERGROKKkW0RERERERCSOKOkWERERERERiSNKukVERERERETiiJJuERERERERkTiipFtEREREREQkjijpFhEREREREYkjVuYOICEKDw/n+vXrODo6YmFhYe5wREREREREJIExGAw8fPiQVKlSkSjRm8ezlXRH4vr163h6epo7DBEREREREUngrly5Qpo0ad54XEl3JBwdHYEXN8/JycnM0YiIfHoeP35MqlSpgBdfhCZOnNjMEYmIiIiYCgoKwtPT05g/vomS7ki8nFLu5OSkpFtExAysra3x9fUFwMXFBXt7ezNHJCIiIhK56B5JVtItIiIJjr29PTt37jR3GCIiIiLvTauXi4iIiIiIiMQRJd0iIiIiIiIicURJt4iIJDiPHz8mWbJkJEuWjMePH5s7HBEREZF3pme6RUQkQbpz5465QxARERF5bxrpFhGRj86lS5ewsLAweVlbW5M6dWrq1avH77//Hmm7Fi1aGOvPnDnzjf3Xrl3bWG/ZsmUmxwwGA4sXL6ZMmTK4ublhY2ODh4cH+fLlo2PHjuzatcuk/qBBgyLE+vpr4sSJ731P3seoUaPw9/fH09MTe3t73NzcKFCgAOPHj+fJkyfv1XfHjh2N13nz5s1YilhERCTh0Ei3iIh8tDJmzEiTJk2AF1PWjxw5wsqVK1m7di0///wzpUqVirSdlZUV8+bNo0OHDhGO3b59m40bN2JlZUVoaGiE461atWLBggUkTZqUqlWrkipVKu7cucNff/3F3LlzCQoKMm6H9qo6deqQM2fOSOMpUqTI21x2rJs1axbu7u6UL1+e5MmT8+jRI3bu3MmXX37JwoUL2b9/Pw4ODm/d7y+//MLMmTNJnDixHiMQEZGPlpJuERH5aGXKlIlBgwaZlI0aNYo+ffowYMCACKPOL1WqVIkNGzbwxx9/REiEFy1axPPnz6levTrr1683ObZnzx4WLFhA3rx52bVrF05OTibHHzx4wJkzZyI952effUaDBg3e8grjx9mzZ7Gzs4tQ3qxZMxYtWsT8+fPp1KnTW/X58OFDWrduTa1atbh79+4b/yxEPhSBgYH8/fffPH78GIPBYO5wRCQa1tbWJE+enPTp05MoUdxOAFfSLSIin5TWrVvTp08fjhw58sY6zZs356effmLevHmMHz/e5Nj8+fPJkycP+fLli5B0HzhwwNj+9YQbwMXFhWLFisXCVcSvyBJuePFFwaJFi7hw4cJb9/nll1/y8OFDpk+fTv369d83RBGzefjwIStXruDfi+fBEIq9nQ2JLCzMHZaIRMFgMBDyPJTnYQYSO7pQtlwFChQoEGfnU9ItIiKfJCurN/8KTJ06Nf7+/ixevJjRo0djbW0NwKFDh/jjjz+YNGkS9+7di9DO1dUV4J2S0A/RTz/9BPDGafFvsm3bNr777jsWLlyIh4dHXIQmEi8eP37MggXzeBYUQPWKxciSKT22tjbmDktEYsBgMHDz1m0OHTnJ+rUrMRgMFCxYME7OpaRbREQSnESJEhm/cY7tKV+zZs0CoESJElHWa9WqFVu2bGHjxo3UqlULgLlz52JjY0Pjxo2ZMmVKhDYVKlTA0dGRGTNm8PDhQ2rVqkX+/Pnx9PSMNq5Vq1bx559/RnqsQ4cOpEiRIto+Xp9KH51u3brh4uIS4/oTJ07kwYMHPHjwgH379vH777/j7+9Ps2bNYtxHUFAQbdq0oXLlyjRt2vSt4hVJaI4dO8aDO9do27wOrkldzB2OiLwFCwsLUqZITvXKZbGw2MEvP2/Fx8cHS0vLWD+Xkm4RSZAuX76sLaPikbu7O15eXuYOw8je3p7Dhw+/dz8XLlwwJqKPHz/m8OHD7Nq1i+TJk/Ptt99G2bZGjRq4ubkxb948atWqxdOnT1m+fLmxPDKenp6sXLmStm3bsnDhQhYuXAhAsmTJKF26NO3bt6dMmTKRtl29ejWrV6+O9FjNmjVjlHQPHjw42jqvatGixVsn3f/++6/xc5MmTZgxY4ZxJkBMdOvWjcDAQOOXHyIfstN//EHGtKmUcIt8wCwsLCiUPzcnz6zjn3/+IVOmTLF+DiXdIpLgXL58mazZsvHsPbcikpizc3Dg3NmzCSrxjg1///13hEQ0efLk7NmzhyxZskTZ9uWI9rRp07hx4wY///wzgYGBtGrVKsp2FSpU4OLFi+zcuZPdu3dz5MgR9u7dy4oVK1ixYgV9+vRhxIgREdotXbr0vRdSi+vFmy5dugTAzZs3+fXXX/nqq68oXLgwW7duJU2aNNG237x5M/Pnz2fmzJkxqi+SkBkMBm7dvEaO4rnMHYqIvCeP5O7YWiciICBASbeIfBru3LnDsydPyNtrJo6eUSdG8v4eXvmL49924M6dOx9d0l2hQgW2bNkCvNjq6/vvv+frr7+mZs2aHDp0iCRJkkTZvlWrVkyePJmFCxeyZcsW47Pe0bGysqJcuXKUK1cOgNDQUBYsWMDnn3/OyJEj+eyzz/Dx8Xn/CzSTFClS0LBhQzJlykShQoX48ssvWb58eZRtnjx5Qtu2bSldujTt2rWLp0hF4o7BYCAsLBQbm5jP9BB5aeqshXzZZwTZvTNzbP8Gc4djNlnylCF7tsysXfb2s59u3Axg5twl/LrrABcu/ktIyHMyZUxLm+b1adn0s7eaJm5hYYG1tTUhISFvHUdMKOkWkQTL0TMLzpnymDsMMYMnT56QPXt2AM6cOfNOe0C/LlmyZPTs2ZPAwECGDRtG//79mThxYpRtXq5SPnnyZG7cuEGfPn3e6RlzKysr2rRpw549e1i4cCG//vprnCTdcf1M9+sKFixI0qRJ2blzZ7R1AwICuHbtGteuXXvjPUyZMiXw4jnZvHnzvnNcIvHJQiuVyzv4/oc1AJz58zyHfj9BoQL6987bOnriND8sW0fjBjXo06sj1lZWbP15N116DubQ7yeYPTXirLKoxOXfZSXdIiKS4BgMBuOzw7E9Zbpv377MmzeP6dOn061bN9KlSxdl/VatWtGlSxcAWrZs+V7nTpw48Xu1j05cP9P9ukePHhEYGBij580dHR1p3bp1pMd++uknbt68SaNGjbC3t3/jM/MiIh+DI8dOcfKPP6nk78vmbbuYv3iVWZPup0+fYW8f+daQCVmxwj6cPbrNZF2RcqWLE/L8OTPnLGFA7y54pklpxgj/L253ARcREUlg7O3t+frrr3n+/DlDhw6Ntn7z5s358ccf2bp1a7TPeW3ZsoV169YRGhoa4dhff/3FqlWrgOhXTn9XBoPhrV7RfeEA8O+//xqf5X7V8+fP6datG+Hh4VSqVMnk2JMnT/jzzz+5fPmysczNzY05c+ZE+sqaNSsA48aNY86cOTFa7V1E5EM1f/GLRTOHD/ySooXysXLNJp48eWpS59Llq9i6ejN28hxGjZtJplylcUqZm6Jl6rBj1wGTukNHTcHW1ZvjJ89Qr1kX3L3ykyxtAVq078XtO6bbW2bJU4aaDdqzdsM2CvnWwillboaNmQbA6TN/UadxRzzSF8IpZW4KlqrJoqU/mrR/9iyYr/qPomCpmiRLW4AUGQpTyr8+6zf9EuE6w8PDmTZ7EQVL1cQ5VR6SpytIyfL12bB5R4S6W3/eQ2G/2jinykOuwpVYsDjyhUVfldTFOdKFPAv65Abg2vWb0fYRXzTSLSIin5x27doxevRoFi5cSN++fcmYMeMb6zo6OlKzZs0Y9fvnn3/SvXt33N3dKVWqFBkzZsRgMHDhwgU2bdpESEgIn3/+OYULF47QNqotw/LmzRvjGGLbsWPHqFOnDiVLliRz5sy4u7tz69Ytfv75Z65cuULWrFkZPny4SZtDhw5RunRpfH19YzT1XETkU/H06TNWrP6JAj65yJE9C80b16HDF/1ZvW4LTRvWilB/5nc/4OWZirEj+hAeHs64KXOpXq8dP29YSJFC+Uzq1mvamTo1K9G2RX3O/HmBwSMnc/bc3+zdvtwkOT1+8gy9/7pIny87kC5tGhI7OHDu/EV8KzYkWTI3xo/qh6urC0tXrKdNpz7cun2Xnl3bABAcEsL9+4F079yKVCmTExLynB27DlC/WRe+mzqCJg1qGs/TplMflqxYT8smnzGwT1dsrK05fvI0/16+ahL3qT/O8fWA0fTq1pbkydyYv2gV7bv2I2MGL0oWe/t9s3fu+Q0rKysyZ0pnUm7r6k2p4gXZvmHRW/f5vpR0i4jIJ8fOzo4+ffrQpUsXBg8ebNza6301btyYJEmSsHXrVk6dOsX27dt59uwZ7u7u+Pv706JFC+rUqRNp26i2DGvevLnZkm4fHx+++OILdu/ezY8//siDBw9IkiQJ2bJlo3PnznTq1CnOp82LiHws1qzfSmDQQ1o0efG7oG6tSvTsN4IFi1dHmnSHhYexac087OxsAShfpgRZ8pZl8MgpbP5xnkndGlXLM3JwL2M9j+RuNG/Xi1Vrt9CwbjVjvYDb9zh+YCNZMqU3ljVt04OQ58/Ztu5745TsSuV9eRD4kOFjptG2RX2cnRxxdnLku2kj/x9fWBhlfIvy4EEQU2YuNCbdew/8zg/L19H7yw4M7tfNWL9CuZIRrvHOvfv8umUJXmlSAVCyWEF+3X2AZas2vnXSvX3HXn5Yvp7O7Zvi5prU5JilpSWJ4mAP7phQ0i0iIh+ddOnSRfsseOfOnencubNJ2YIFC1iwYEGMzjFo0KAIC5clS5aMNm3a0KZNmxjHGlk/CYmXlxfjx49/qzZ+fn5v9Sy+RsNF5FOxYPEq7O3tqFe7CgBJkiSmTvWKfL9kDef/vkTmjOlM6teoWt6YcAM4OiahSsXSLF/9E2FhYSYrdL+aWAN8VrMSrTv2YdeegybHcuXIapJwA+zcc5DSpYpGeAa6WcNabP15N78dOm5MmFev3cKUmd9z8vQ5Hj/+//aur8a59efdAHRo3Sjae5Inp7cx4X7ZT+aM6bh85Xq0bV917MRpGrfqTuECeRg28MsIx5/cPv1W/cUmPdMtIiIiIiISxy5c/Jc9+3+nUnlfDAYDDwKDeBAYRK0aFQD4/oeIs51SJE8WocwjeTJCQp7z6JWE92X5q6ysrHBzdeHu/QemfXpE7PPuvQekjKQ8ZcrkANz7r4+1G7bRqFU3UqX0YP7MMezeuoz9v6ykReM6PHsWbGx35859LC0tIz3X61xdXSKU2dra8OzZs2jbvnT85Bkq125FpoxpWbdiNra2NjFuGx800i0iIgmOhYWFccswbccjIiIfg+9/WI3BYGDN+q2sWb81wvHFy9YyuF83k9HrmwG3I9S7FXAbGxtrkiR2iFCeOpWH8XNoaCh37z3ALamLSb3Ifq26ubpw41bEc924EWA8DrBk5QbSpU3DD/MmmPx+Dg4xfUzL3T0pYWFh3Lx1m5Qpkkc8YSw6fvIMlWq1xMszNT+tnouzk2Ocnu9daKRbREQSHAcHB06fPs3p06djZY9uERERcwoLC2PxsrVkSO/FtvXfR3h169SSGzdvs+W/adkvrdu43WQE+eHDR/y05VeKFy1gkpwDLF25weTzqrWbCQ0NpVSJQtHGV7pUEXbu+Y3rN26ZlC9evhYHB3sKF8wLgAVgY2NtknDfvHWbDZtNVy+vUK4UALPnLYv23O/jxKmzVKrVktSpUrBpzVySujjH6fnelUa6RURERERE4tCWn3dz/UYAwwf1xLdExB0scmTLwow5P7Bg8WqqVChtLLdMZEnl2q34omMLwsPDGTt5DkEPHzPw6y4R+li3cTtWVlaU9Sv23+rlk8id05vPalaMNr5+X3Vi09ad+NdoTr9enUjq4syyVRvYvG0XIwb1Mo4eV67gx9qN2+nSczC1q1fg6rUbjBg7gxQeybjw6F9jfyWKFqBx/RqMHDeDW7fvULmCH7Y2Npw4dRZ7ezs6tWv6LrfRxLnzF6lUqyUAg/t348Lf/3Lh7//HkCG9F8ncXY2fHZLloGTxgmxdu+C9z/22lHSLiIiIiIjEoQWLV2NjY03zRrUjPe7ulpQaVcqxZv02bgXcMZZ3aNuY4GfB9Og9nIA7d8nunZm1y2ZSrIhPhD6WL5zC0NFTmT1/KRZYUKVCacaO6IuNTfTPN2fNnIFdW5YyYNgEvug1hKfPnuGdJSPfTR1Bs1dibt64Drfv3GP2/GV8/8Nq0qf1pNcXbbl2/aZxv++X5kwbSd7c2VmweBWLlv6IvZ0d2bJm5Kse7WN626J08PBx7t57AEDthp9HOP567GFhYYSHhcXKud+WheFtlhf9RAQFBeHs7ExgYCBOTk7mDkfkk3P06FHy589Pyck7cM6Ux9zhfPQCL5xgT9cyHDlyBB+fiL/EzeHJkycULPhim5DDhw9rirmIJDjh4eEM/qYfVcsXJk+ubOYORz4yly5fJWvecowc3IseXVpHWXfoqCkMGzONa+cP4O6WNMq68maTZiymYLGy+Pn5xbhNTPNGjXSLiEiCYzAYOHPmjPG9iIiIyIdKC6mJiIiIiIiIxBGNdIuIiIiIiCQg6bzSEHzvzxjVHdC7CwN6R1xYTRIOjXSLiIiIiIiIxBEl3SIiIiIiIiJxREm3iIiIiIh8NHbtPYitqzdr1m0xdygxcunyVWrUb0+KDIWxdfXmyz4j3qsvW1dvFi5ZYyw7cPAoQ0dN4UFgUGyEaza/7v6Ndp37kqtwJZKmyUf6HKWo07gjR4//EWn9YydOU7FWS1w9fUieriD1mnXh4qUr8Rz1C3qmW0REEhwLCwvSpk1rfC8iIvKx6tVvFIePnGDWlOGkSO5OihTJ3rmvlB7J2b11GRnSexnLDhw6xrAx02jaqBYuzh/udsiz5y3l3v0HdG7fjGxZM3Lnzj0mTptPSf8GbFw1h9Klihjr/vnXRcpXa0aeXNn4Yd4Egp8FM3jkFMpWacyhXWtJ5u4ar7Er6RYRkQTHwcGBS5cumTsMERGRN3r69Bl2drbv/eXw6bPnKeCTmxpVyr13TLa2NhQumPe9+0mIJn07kOTJ3EzK/MuWJHuBCoyeMMsk6R4ycjK2tjb8uHQmTk5JAMiXNwc5ClRkwtR5jBjUM15j1/RyERERERF5J0NHTcHW1ZszZ8/TtE0PkqUtgGfW4rTr3JfAoIfGepFNe37J1tWboaOmROjz1OlzNGzxBcnSFiBFhsL06jeS0NBQzp2/SNXP2uDm5UOWPGUYO3lOpLE9Cw6hV7+ReHmXwDlVHspVbcLxk2ci1Dty7BS1G31OigyFcUqZm0K+tVj142aTOguXrMHW1ZvtO/bSrnNfUmcuikvqvAQHh7zx3ly+ep0W7XuRJksxHFPkInfhykyYOo/w8HDg/9Pg/774L1t/3o2tqze2rt5cunz1jX2uXruFEuXqkSxtAVxS5yVrvnK069z3jfd56Kgp9PnmWwCy5i1nPMeuvQeNbVau2UQp//okTZMPV08fqtRpHeE+Xbx0hSate5Aue0kcU+TCM2txKtRswYlTZ98Ya2x7PeEGSJIkMdmyZuTqtRvGstDQUDZt20nNav7GhBsgrWdqfEsUYt1P2+Ml3leZPemePn066dOnx87Ojvz587Nnz5431l2zZg3ly5cnWbJkODk5UbRoUbZu3WpSZ8GCBVhYWER4PXv2LK4vRURERETkk1S/RVcyZ0zHsu8n0/OLtixbvZFefUe+V5+NWnUjd05vln0/mVbN6jJ5xvf07DeSuk06U8nflxULp+JXsgj9Bo1l7YZtEdoPHDqBf/69yoxJQ5k5aRjXb96mfLVmJs/17tzzG36VGhEY+JCp4waxavE08uT0pnHr7pF+QdC+Sz+srK2YN2MMyxZMwto68onDt+/cw69CQ37+dR/f9O3K6h+mU8avKL0HjuGLr4YCkC93DnZvXUYKj2QUK+zD7q3L2L11GSk9kkfa52+HjtG4dXfSp0vDojnjWbtsJv16dSQ0LOyN97Bl07p0bNcEgBULpxjPkS93DgBGj59J07Zfki1rJn6YN4H5M0bz6NFjylRpwtk/Lxj7qVG/HUdPnGbEoF5sWjOPKWO/IW+ubNE+J24wGAgNDY3R610EBj3k2IkzZPfObCz7+5/LPH36jFw5skaonytHVv6+eJlnz4Lf6XzvyqzTy5cvX063bt2YPn06xYsXZ9asWVSqVIkzZ87g5eUVof7u3bspX748I0aMwMXFhfnz51OtWjUOHjxIvnz5jPWcnJw4d+6cSVs7O7s4vx4REYkdT58+pVSpUsCL//fb29ubOSIREYlKi8af8WXX1gCU9SvG3/9c5vsfVjNryvB3nn7dulk9unVqaezz51/3MeO7H1ixcAo1qpYHwLdEITZt28nSlRuoWc3fpL27e1JWLppqPH+xIj7kKFCRbyfMZsakF4lv155DyO6dma3rFmBl9SI18i9bkjv37jNw2ASaNKhJokT/H6cs7VuE6ROGRBv7pOnzuXbjFnu3r6Bg/tzGfsPCwvlu/jK6dGhGlkzpKVwwL7Y21jg7O0Y7LfzAoWMYDAamjh+Ms5OjsbxZo9pvbJMmdQo8U6cEIE/ubKTzSmM8duXqDYaMmsrnbRszYVR/Y3lZv2LkKFiRYWOm8cO8Cdy9d5+/zv/D2BF9aVSvurHe6/c7MouW/kjbV0bioxLTfclf9UWvITx+8pTePdoby+7dewCAq4tzhPquSZ0xGAzcfxBIyhSRf7kRF8yadI8fP57WrVvTpk0bACZOnMjWrVuZMWMGI0dG/GZs4sSJJp9HjBjBunXr2LBhg0nSbWFhQYoUKeI0dhERiTvh4eH8/vvvxvciIpKwVa1U2uRzrhxZePYsmIDbd/FI7v5OfVau4Gfy2TtLBk7+8ScVypUylllZWZExvReXr16P0L5+naomCX9az9QULZSXnf9Nrb5w8V/Onb/IqCFfAZiMtlYs78umrTs5d/4fsmXNaCyvWa1CjGLfufsg2bJmMibcLzVrWIvZ85ayc89BsmRKH6O+XirgkwuARi270bLJZxQt7EPqVB5v1certu/YS2hoKE3q1zC5djs7W0oWK2icgu6a1IUM6b2YMGUuYWFh+JUsTO6c3iZfRrxJlYql2f/LyneOMSqDhk9i6coNTBjdH5+8OSMcj+rLnvhepNVsSXdISAhHjhyhd+/eJuX+/v7s378/Rn2Eh4fz8OFDXF1NV5979OgRadOmJSwsjLx58zJ06FCTpPx1wcHBBAf/f4pBUNCHvZy+iIiIiEh8cnNNavLZ1sYGgKfv8Yina1IXk882NtY4ONhjZ2cboTzo4eMI7VN4RFwF3CN5Mk7+8WJGbEDAXQB6DxxD74FjIo3h7r37Jp9TRtJnpO3uPyCtV+oI5S9HV1+Oxr6NksUKsnLxNKbNXkSrjl8THBxCdu/M9P6yPfXrVH3r/gJuv7j+YmXrRnr8ZVJtYWHBlrXzGTFmOuOnzOXrAaNxTepMg7rVGNKvG46OSSJtDy/+DF8dlY8tw0ZPZeS4GQzp342ObZuYntPVBXjxZ/C6e/cDsbCwiPdV3M2WdN+5c4ewsDA8PEy/nfHw8ODmzZsx6mPcuHE8fvyYevXqGcu8vb1ZsGABuXLlIigoiEmTJlG8eHFOnDhB5syZI+1n5MiRDB48+N0vRkRERERE3sjO9kWiHBxiuvDY60ltbLp563aEslsBt41JmZvbi/9+1b0dNf+brv6610ejYzpA6pbUhZs3I57/xs0Ak3O/reqVy1K9clmCg0M4+PtxxkyYTbO2PUnrmZoihd48yBhpjP/FsGzBJLw8U0VZN61namZNGQ7AXxf+YfXaLQwdPZWQkOdMG//mPCouppcPGz2VoaOnMuDrznzdo0OE4xnTe2Fvb8cfZ/6KcOyPM3+RMYNXhC9u4prZtwx7fWjfYDDEaLh/6dKlDBo0iHXr1pE8+f/n4xcpUoQiRf6/XHzx4sXx8fFhypQpTJ48OdK++vTpQ48ePYyfg4KC8PT0fNtLERERERGRSHgkd8fOzpZTp00ToQ2bdsTZOVes+YlunVoac4t/r1zjwKHjNKlfA4CsmTOQKWNaTv5xjqEDekTV1Vsr7VuEMRNmc+zEafLlyWEsX7x8LRYWFviWKPxe/dva2lCqeCFcnJ3YvmMvx0+dfWPSbWv736yDp6aLh5UvUwIrKyv+vnSFWtVjNm0eXnwR0afn5/y4YVukq8G/Kranl4/4djpDR0+lz5ef0//rzpHWsbKyokqF0qzbuJ2Rg3oaR+IvX73Orr0H6fp5i1iLJ6bMlnS7u7tjaWkZYVQ7ICAgwuj365YvX07r1q1ZuXIl5cpFvZ9dokSJKFiwIOfPn39jHVtbW2xt4/fbDhERERGRT4WFhQWN6lbn+x9WkyGdJ7lzevP70ZMsW7Uxzs55+/Y96jbtTKtmdQkKesiQUVOxs7WhV/d2xjrTxg+mer12VKnTmmaNapEqpQf37gdy7q+/OXbiDEsXTHqnc3f9vAU/LFtHzQYdGNi7C16eqdi8bRez5i6lXauGb/08N8DgEZO5dv0mpX2LkjqVBw8CHzJt1kKsra0pVazgG9vlzJ4FgKmzFtK0QU2sra3Ikik96bzS8E2fLnwzbCL/XLqCf9mSJHVxIiDgLoePniSxgz0D+3Tl1OlzdPtqKLVrVCBThnTY2Fizc89vnDp9jl7d2kYZs5tr0giPHryrCVPnMXjkZPzLlqSSvy8HDx83Of7qQnQDeneheLnPqNWwAz2/aEdwcDCDR07G3S2pcXG++GS2pNvGxob8+fOzfft2atWqZSzfvn07NWrUeGO7pUuX0qpVK5YuXUqVKlWiPY/BYOD48ePkypUrVuIWEREREZG3N3ro1wCMnzKXR4+f4FeyMD8um0mWPGXj5HxDBnTn96OnaNe5L0EPH1HQJzeL54wjY/r/75LkV7II+35eyahxM+nZdyT3HwTh5uqCd9aMfFaz4jufO5m7Kzu3LmXAkPEMGDqeoIePSZ8uDSMG9XznpK9ggdwcmfMH/QaN5fbde7g4O+GTNydb1y0ge7bIH6MF8C1RmK+6t2PxsrXMW7iS8PBwtq3//r/y9nhnzcS0WQtZsfongkNCSJHcnfz5ctG2ZQPgxSyFDOk8mTV3KVev38TCAtKn9WT00K/p1K7JG88b2zZt/RWAbb/sYdsvEbeZfnV6uneWDGxfv5C+g8fRsOUXWFla4leqCKOGfEUyd9cIbeOahcFgMMT7Wf+zfPlymjZtysyZMylatCizZ8/mu+++4/Tp06RNm5Y+ffpw7do1Fi5cCLxIuJs1a8akSZOoXfv/S+Pb29vj7PxiSfjBgwdTpEgRMmfOTFBQEJMnT2bRokXs27ePQoUKxSiuoKAgnJ2dCQwMxMkpfh+yFxE4evQo+fPnp+TkHThnymPucD56gRdOsKdrGY4cOYKPj4+5wwHg8ePHpEuXDoBLly6ROHFi8wYkIvKa8PBwBn/Tj6rlC5MnVzZzhyMi72nSjMUULFYWPz+/GLeJad5o1me669evz927dxkyZAg3btwgZ86cbNq0ibRp0wJw48YNLl++bKw/a9YsQkND6dSpE506dTKWN2/enAULFgDw4MED2rVrx82bN3F2diZfvnzs3r07xgm3iIiYX+LEibl9O+ICNCIiIiIfGrMvpNaxY0c6duwY6bGXifRLO3fujLa/CRMmMGHChFiITEREREREROT9RL+juYiIiIiIiIi8EyXdIiKS4Dx9+hQ/Pz/8/Px4+vSpucMREREReWdKukVEJMEJDw9n165d7Nq1i/DwcHOHIyIiH7Gho6Zg6+pt7jASpPLVmlK+WlPj5ydPnjJ01BR27T1oxqii16ZTb2xdvSO8chWuZJZ4zP5Mt4iIiIiIiCQ8k7/9xuTzk6fPGDZmGv15sRVZQmZvb8fWtQsilJmDkm4REREREZGP0JMnT3FwsH/n9tm8M8ViNPErUaJEFC6Y19xhAJpeLiIiIiIiseD2nXt83m0AGXP64ZgiF6kzF8WvYkN+2bnfWOfnX/dRp3FHMuTwxSllbrLl96dj94HcuXvfpK+XU75PnT5HwxZfkCxtAVJkKEyvfiMJDQ3l3PmLVP2sDW5ePmTJU4axk+eYtN+19yC2rt4sWbGeXv1G4uVdAudUeShXtQnHT56J0fWsXLOJUv71SZomH66ePlSp0zpC24uXrtCkdQ/SZS+JY4pceGYtToWaLThx6myUfbfp1BtXTx/OnD1PhZotSJomH6kzF+WLr4bw5InpWiYGg4GZc5dQsFRNnFPlwSN9IRo078rFS1dM6pWv1pR8xaqxZ/9hfCs0wCV1Xtp16ffGGGIS+6vTyy9dvkrqzEUBGDZmmnHKdptOvY31z/99iWZtvyRNlmI4pshF7sKVmTHnhyjvxadAI90iIiIiIvLeWnb4iuMnzzC4XzcyZ0rHg8CHHD9xmnv3HhjrXLx0hSIF89Ky6Wc4Ozny7+VrTJq+gNKVG3F073qsra1N+mzUqhuN6lanTYv6/LJzP+Mmz+F5aCg7dh6gfeuGdO/ciuWrNtJv0FgypfeiZjV/k/YDh04gb57szJg0lKCgRwwdPZXy1ZpxcNePZEjn+cZrGT1+Jt8Mn0TzRrXp3fNznoc8Z/yUuZSp0oR921cYR4Br1G9HWFg4Iwb1wjNNSu7evc+BQ8d4EBgU7f16/vw5Neq3p02LevT6oi2/HTrGyHEzuXzlOj8unWms17H7QBYtXUundk0Y/s2X3H8QyPAx0/Gr2JDDu9fikdzdWPfmrQBatv+KHl1bM2RAdxIlevMY69vGntIjORtWfke1um1p2eQzWjb9DAB3d1cAzv55Ad+KDfFMk5LRQ7/GI7k723fspUfv4dy9e5/+X3eO8n6EhYVhMBiivW+JEiWK8rpeevr0GV7eJbh95x4pPZJRrUpZvunTFdekLtG2jW1KukVERERE5L0dOHSUlk3q0rp5PWNZ9cplTeq0a9nA+N5gMFC0UD5KlShE5txl2PLzHqpVKmNSv3WzenTr1BKAsn7F+PnXfcz47gdWLJxCjarlAfAtUYhN23aydOWGCEm3u3tSVi6aioWFBQDFiviQo0BFvp0wmxmThkZ6HVeu3mDIqKl83rYxE0b1N5aX9StGjoIVGTZmGj/Mm8Dde/f56/w/jB3Rl0b1qhvrvR7Dm4SEPOeLTi3o3L4ZAOVKF8fa2oqBwyay/7ejFCviw8HDx5m3cCWjh35tvA8AxYsUIGehikyavoARg3oay+/dD2TJ/EmULlUkynO/S+y2tjb45M0JQOpUHhGmbvfqPwrHJIn5ddMSnJySGK8pOCSEbyd9R6f2TUnq4vzG/ivWbMHufYejjBugacOazJk2Kso6uXJ4M2qINzmyZQZgz/7DTJ7xPb/u+o39v6wkSZLE0Z4nNinpFhGRBMnBwcHcIYiIyFso4JObRUt/xM3VhTK+RfHJmyPCyHXA7bsMHjmZLdt2cf1mgMkOFef++jtC0l25gp/JZ+8sGTj5x59UKFfKWGZlZUXG9F5cvno9Qkz161Q1JtwAaT1TU7RQXnZGsfr29h17CQ0NpUn9GoSGhhrL7exsKVmsoHHlbtekLmRI78WEKXMJCwvDr2Rhcuf0jtEo7EsN61YzjfezqgwcNpFdew9SrIgPm7btxMLCgkb1qpvEksLDndw5srJ77yGT9kldnKNNuGMr9lc9exbMr7t/o12rBjg42JnEWrGcLzO++4GDh09QsXypN/YxdfxgHj16HO253NySRlvni44tTD6XK12cvLmy0aDFF8xduDLC8bimpFtERBKcxIkT8/hx9L94RUQk4fhh7gRGjp3B/EUrGTRiEkmSOFCjSnlGDOpJCo9khIeHU6VOa27cDKBPz8/JmT0LiR0cCA8Pp6R/fZ4+fRahz9enAtvYWOPgYI+dnW2E8qCHEX9vpPBIFqHMI3kyTv5x7o3XEXD7LgDFytaN9PjLxNTCwoIta+czYsx0xk+Zy9cDRuOa1JkGdasxpF83HB2TvPEc8OLLAjdX0wQyRfIX8d79b0p+QMBdDAYDnlmLR9pH+temyEd2vZF539hfd/feA0JDQ5k+ezHTZy9+Q537kZa/lClD2hhPL38XNaqWJ3FiBw79fuKd2r8PJd0iIiIiIvLe3N2SMm5kX8aN7Mvlq9fZuHkH/YeMJ+D2XTaumsPps+c5+cefzJk2kqYNaxnbXbj4b5zFdPPW7QhltwJu4+rq8sY2bm4vji1bMAkvz1RR9p/WMzWzpgwH4K8L/7B67RaGjp5KSMhzpo0fHGXb0NBQ7t67b5J43wx4Ea/bf/G5ublgYWHBjp9+wNbWOkIftrY2Jp9fHdWPzvvE/rqkLk5YWlrSuF51OrRpFGmddGnTRNlHbE4vfxODwUCiRDG/R7FFSbeIiIiIiMQqrzSp6Ni2Cb/u/o0DB48C8DIftLUxTRTnLFgeZ3GsWPMT3Tq1NCaj/165xoFDx2lSv8Yb25QvUwIrKyv+vnSFWtUrxPhcWTKlp0/Pz/lxw7YYr5C+dOUG4zPdAMtXbQSgVIlCAFT2L823E7/j+o1bfFarUoxjeVsxjd3W5kXi//RZsEm5g4M9viUKc/zUWXLlyIrNa3/GMRGb08sjs2bdVp48eUqhAnnfqf37UNItIiIJzrNnz6hTpw4Aq1evxs7OzswRiYhIVAKDHuJfvTn161Qha5YMOCZJzO9HT7Htlz3U/G/Bs6yZM5AhvRf9h4zDgIGkLs78tPVXky3FYtvt2/eo27QzrZrVJSjoIUNGTcXO1oZe3du9sU06rzR806cL3wybyD+XruBftiRJXZwICLjL4aMnSexgz8A+XTl1+hzdvhpK7RoVyJQhHTY21uzc8xunTp+jV7e20cZmY2PNpGkLePz4Cfnz5TKuXl6hXCmKF8kPvFj4rXXzerTt0pcjx/+gRLECJHaw5+at2+z77Sg5s2ehfauGb31f3jV2R8ckpPVMxYbNv1C6VBFckzrj5paUdF5pGD+yL6UrN6ZM5Sa0a9WAtF6pefjoMX9fvMymrb+ydd33UcaUNXOGt76OyPx75RrN2/akbu3KZEyfFgsLC/bsP8SUmQvJ7p2ZVv+tuh6flHSLiEiCExYWxqZNm4zvRUQkYbOztaVg/twsWbGefy9f43loKJ5pUtKzaxu+7NoGAGtra9YsmcGXfYbTqfs3WFlZUca3KJvXzCdT7tJxEteQAd35/egp2nXuS9DDRxT0yc3iOePImN4rynZfdW+Pd9ZMTJu1kBWrfyI4JIQUyd3Jny8Xbf9bgd0juTsZ0nkya+5Srl6/iYUFpE/ryeihX9OpXZNoY7O2tubHZTPo0Xs4I8fNxN7OllbN6jJqcC+TetMnDKFwgTzMWbCCWfOWEh4eTsoUySlWOB8FfXK90315n9hnTh5On2++pU7jjgQHhxine2fzzsRvO1cz8tsZDBo+iYA793BxdiRThrRULO/7TnG+CyfHJCRP7s6k6QsIuH2XsLAwvDxT0aldU77u0Z7EieN/oVYLQ0yeVv/EBAUF4ezsTGBgIE5OTuYOR+STc/ToUfLnz0/JyTtwzpTH3OF89AIvnGBP1zIcOXIEHx8fc4cDwOPHj0mS5MUiLo8ePSJx4vjd2kNEJDrh4eEM/qYfVcsXJk+ubOYOR16za+9B/Ks3Z+n8idSuUdHc4UTQplNv1qzfxr0rR80divxn0ozFFCxWFj8/vxi3iWne+G5Lv4mIiIiIiIhItJR0i4iIiIiIiMQRPdMtIiIiIiIfFd8ShQm+96e5w3ijOdNGvfO2V/Lh0Ui3iIiIiIiISBxR0i0iIiIiIu+sfLWmlK/W1Pj5yZOnDB01hV17D0aoO3TUFGxdvblz9360/WbJU4Y2nXrHaqzRadOpN1nylDEpGz1+Jut++jnWz5UlTxlqNmgf6/1+zP69co12nfuSLntJHFPkIn2OUtRt2jlCvYDbd2nTqTepMhXBJXVeSvnXZ8euA2aI+AVNLxcRkQQnceLEaHMNEZEPw+RvvzH5/OTpM4aNmUZ/XkzzflcrFk3F0THJe0b3dvr07Ejn9s1MykZPmE3t6v7UqFIuXmMRU6fP/EX56s1In86TUUO+InWqFNy8eZvtO/aa1AsODqFizRYEBj5k3Mh+JHN3ZebcJVSr25bNP86jVPFC8R67km4REREREXln2bwzxUm/eXNnj5N+oxLd/t1iHgaDgZaff02a1CnZ8dMP2NraGI/VrV3ZpO78xas4ffY8u7YspUihfAD4lSxMgZI16fvNWPb+vCJeYwdNLxcRERER+eSdOXseW1dvVq/dYiw7evwPbF29yVu0qknd2o0+p0jp2sbPr04vv3T5KqkzFwVg2Jhp2Lp6Y+vqHWGaeEDAHZq26UGytAXwzFqcdp37Ehj00KTO69PLd+09iK2rN8tXb2TgsAmky14Sd6/8VKzVknPnL0Z7jbfv3OPzbgPImNMPxxS5SJ25KH4VG/LLzv3GOq9PL7d19ebx4ycsWrrWeC2vTqW/ees2HbsPJEMOX5J45CJL3rIMGz2V0NDQaOOJzMy5S3BIloMhIycbY+7SczB5ilTB1dOHNFmKUaFGc/Ye+N2k3aXLV7F19Wbs5DmMGjeTTLlK45QyN0XL1IkwrfrlFP/jJ89Qr1kX3L3ykyxtAVq078XtO/dM6q5cs4nKtVuRNltJnFPlIXfhyvQbPI7Hj5+80/W9qz37D3Pi1Fm6dGhmknBHZt3Gn8mSOb0x4QawsrKiUb1qHD56kmvXb8V1uBFopFtERBKcZ8+e0bTpi3/ULFq0CDs7OzNHJCLyccueLTMpUyTjl137qVOzIgA7dh3A3t6Os+cucP3GLVKl9CA0NJQ9+w7TtmWDSPtJ6ZGcDSu/o1rdtrRs8hktm34GgLu7q0m9+i26UrdmJVo0+Yw/zvzFgKHjAZg9dUS0sQ4YOoFihX2YMWkYD4Me0W/wOGo3+pyTv23C0tLyje1adviK4yfPMLhfNzJnSseDwIccP3Gae/cevLHN7q3LqFCzBb4lCtO35+cAOP035f3mrduUKFePRIks6NurIxnSe3Hw8HFGjpvBv5ev8d20kdFey0sGg4HeA8cwbfZiZk4aSrNGL77UuHf/RWz9v+qEh4c7jx4/Yf3GnylfrRlb1s6PMH1/5nc/4OWZirEj+hAeHs64KXOpXq8dP29YaJKEAtRr2pk6NSvRtkV9zvx5gcEjJ3P23N/s3b4ca2trAC5c/JeK5X3p8nlzEjvYc+78RcZOmsPvR0+ydd330V5XTL98sLS0xMLC4o3H9+5/8SWDY5LEVK/Xjp17fsPKyopSxQsyasjXeGfJYKx75s/zFC+SP0IfOXNkNR5PncojRnHFFiXdIiKS4ISFhbFq1SoAFixYYN5gREQ+EaVLFTUZFf1l5wEa1q3Gj+u3sWPXAZo0qMnhIycJeviIMr5FI+3D1tYGn7w5AUidyoPCBfNGWq9F48/4smtrAMr6FePvfy7z/Q+rmTVleJTJF0C2rJlYMOtb42dLS0saterG70dPvfF8AAcOHaVlk7q0bl7PWFa9ctkoz1W4YF4SJUpEMvekEfoeOnoq9wMDObZ/I15pUgFQxrcodna29B44hh5dWsdo6v3Tp89o2eErduw6wPoVs03ubdbMGZgy9v/PzIeFheFfpgSXrlxj2uzFEZLusPAwNq2Zh52dLQDly5QgS96yDB45hc0/zjOpW6NqeUYO7mWs55HcjebterFq7RYa1q0GQJ//vmiAF18MFCvsg3eWjJSr2pRTp8+R679ENjKXLl8la96YPQe/bf33UT7/f+3Gi9Hptp37UqdGRdYum8XNW7cZNHwiZas05vc960iZIjkAd+89IGlS5wh9uLq8KHv5RUZ8UtItIiIiIiKULlWEJSvW88+/V0npkYz9B4/QvlUD7t17wC8799OkQU127DqAra1NpCOJb6NqpdImn3PlyMKzZ8EE3L6LR3L3t2qbM0cWAC5fuR5l0l3AJzeLlv6Im6sLZXyL4pM3h3FE911s3roT3xKFSZUiucmIbsVypeg9cAy79x+ONum+d+8BFWo05/qNAH7d9AM5smeJUGf2/GXM/X4FZ89dIDg4xFieNXOGCHVrVC1vTLgBHB2TUKViaZav/omwsDCTmQAvE+uXPqtZidYd+7Brz0HjsYuXrjBo+ER27jlIwO27Jouc/nnu7yiT7lQpkrP/l5VRXv9LWTKlj/J4eHg48OJLkJmThxnLc2TLTCHfWsycu4TB/boZy6P64saCqL/UiQtKukVEREREhDK+xQDYsXM/6dKm4fnzUPxKFeHW7buMHDv9xbFdByha2Ad7+/d77MfNNanJZ1ubF8/pPn32LPq2SV1M29rGrO0PcycwcuwM5i9ayaARk0iSxIEaVcozYlBPUngke4voX7h1+y4/bfmVxMlzRnr8bgy2RTv/9yXuPwiiVbO6kSbcE6fN5+sBo2nbsgHf9O2Ku2tSLC0TMWjEZM799XeE+imSR7wOj+TJCAl5zqPHT3B2cjQpf5WVlRVuri7c/W8k+NGjx5St0hhbW1sG9f2CzJnS4WBvx9VrN6nXrEu099vGxoY8ubJFew+AKB8LAHBzdQFejMi/Kk+ubKRMkYxjJ86Y1I3skYF7DwIBIh0Fj2tKukVEREREhDSpU5A5Uzp27DpAWq/U5M+bExdnJ0qXKkLXnoM59PsJDv5+goG9I+6L/CFwd0vKuJF9GTeyL5evXmfj5h30HzKegNt32bhqzjv1lzN7Fob07xbp8ZfTnaNSuGBe6tSoSPuu/QGYOm4QiRL9f63rpSs34FuiEFPHDTJp9+jR40j7uxlwO0LZrYDb2NhYkySxQ4TyV59tDg0N5e69B8YvNX7dc5DrNwLYvmGhyTZbDwJNF7x7k9icXh7ViLrBAIkS/X/0Oke2zPxx5q8I9U7/V5YjW+YYxRSblHSLiIiIiAjwYrR79drNpEmdkkrlfYEXU3+90qRi8MjJPH/+3Dgi/ia2Ni+mbD99Fhzn8b4rrzSp6Ni2Cb/u/o0DB49GWdfWxpqnTyNeS2V/P7b8vIsM6b1I6vLuo6dNG9YisYM9zdr14smTp8ydPso48mth8WLE+FWnTp/jt8PH8UydIkJf6zZuZ9Tgr4xTzB8+fMRPW36leNECEUaTl67cYHz+HmDV2s2EhoZSqkQh47lfXL/p+ecsWB6j64rN6eUVypXCwcGerT/v5ouOLYzlx06c5uat2xQukNdYVqNqeeOXRIUK5AFefKGwZMUGCuXPQ6qU8buIGijpFhERERGR/5QpVYRZc5dw5+59xo7oYywvXaoI3y9ZQ1IXZ3zy5oiyD0fHJKT1TMWGzb9QulQRXJM64+aWlHReaeI6/DcKDHqIf/Xm1K9ThaxZMuCYJDG/Hz3Ftl/2ULNq+Sjb5syehd37DrFxyw5SeiQjSZLEZM2cgYF9uvDLzn34VmhIp/ZNyZIpPc+Cg/n38jW2bN/F1HGDSRNJYhyZ2jUqYu9gT8MWX/D06TMWzRmHjY0Nlf39GDF2BkNGTqZk8UL8deEfRnw7nXRp0xAWycrgloksqVy7FV90bEF4eDhjJ88h6OFjBn7dJULddRu3Y2VlRVm/Yv+tXj6J3Dm9+ey/1euLFspHUhdnOn85iP5fdcLK2oplKzdw8vSfMbomGxsb8ufLFaO60XFxdmJg7y70HjiGNp16U692FW4F3GHwiMl4pUlF+9YNjXVbNK7DzDlLaNSyG8O+6UEydzdmzVvKXxf+ibCYXHxR0i0iIiIiIgD4lSpCokSJsLe3o8gri5KV8SvK90vW4FuikMn05zeZOXk4fb75ljqNOxIcHELThjWZM21UHEYeNTtbWwrmz82SFev59/I1noeG4pkmJT27tuHLrm2ibDtuZD++6DWEpm2+5MmTp5QqXpDtGxaRMkVy9u9YzYhvpzN+ylyuXb+FYxIH0qVNg3/ZkiR1cXqrGCuV92Xd8lnUbvQ5dRp3YsXCKfT+sgNPnj5jweLVjJsyl2xZMzJl3CDW/7Sd3XsPReijQ9vGBD8Lpkfv4QTcuUt278ysXTaTYkV8ItRdvnAKQ0dPZfb8pVhgQZUKpRk7oq9xZN3NNSlrl83k6wGjadHhKxI72FOtUll+mDuBwn61I/QX17p3boWzkyNTZy1k+eqfcEySGP+yJRk28EtcX3nO39bWhi1r59N30Ld0/3oYT54+I09Ob9avmG0yTT4+WRheXYJOAAgKCsLZ2ZnAwECcnN7uL4uIvL+jR4+SP39+Sk7egXOmPOYO56MXeOEEe7qW4ciRI/j4RPylbA4Gg4EnT54A4ODgEO32MSIi8S08PJzB3/SjavnCMV4sSiSuvHx+euTgXvTo0jrKukNHTWHYmGlcO38Ad7ekUdb9lEyasZiCxcri5+cX4zYxzRs10i0iIgmOhYUFiRMnNncYIiIiIu8t+rkhIiIiIiIiIvJONNItIiIJTnBwMO3btwdg1qxZ2NramjkiERGRhCudVxqC78VsgbMBvbswoHfEhdUk7mikW0REEpzQ0FC+//57vv/+e0IjWZ1VRERE5EOhpFtEREREREQ+SstXb6RY2c8oXakR5as15fjJM/Eeg5JuERERERH5ILXp1JssecqYlI0eP5N1P/0c6+cqX60p5as1fae2M+cuYeGSNRHKL12+iq2rt8mxAwePMnTUFB4EBr1zrG+ycMkabF29uXT5aqz3/b4eP35Ck9Y9yFmoIm5ePiRNk4+8RasycuwMHj9+EqF+wO27tOnUm1SZiuCSOi+l/OuzY9cBkzoHDh6lY/eBfD97LL9uXkK7lg2p+lkbAoMextdlAUq6RURERETkA9WnZ0dWLJpqUjZ6wmw2bIr9pPt9zJq7lEVLf4xQntIjObu3LqOSv5+x7MChYwwbMy1Oku6E7HloKAaDgS86tmDZgsmsWjyNWtX8Gf7tdOo06WRSNzg4hIo1W/Drrt8YN7IfqxZPI3lyd6rVbcvuff/fv3zh0h+pVqksmTOmA6Bu7crY2tiwZfuu+Lw0LaQmIiIiIiIfpozpvcwdwnuxtbWhcMG85g4jQXBxduKHeRNMysr6FSM4JIRxk+dw8dIVMqTzBGD+4lWcPnueXVuWUqRQPgD8ShamQMma9P1mLHt/XgHAteu3yJ0zq0mfqVN5cOXazXi4ov/TSLeIiIiIiCQ4t+/c4/NuA8iY0w/HFLlInbkofhUb8svO/cY6r08vt3X15vHjJyxauhZbV29sXb1NpoTfvHWbjt0HkiGHL0k8cpElb1mGjZ76zot2Dhs9lRLl6pEiQ2HcvfJT2K828xetwmAwGOtkyVOGM3+eZ/e+w8aYXsb8+vTyoaOm0OebbwHImrecsf6uvQeN1zd01JQIcWTJU4Y2nXqblB08fBy/ig1xSpmbdNlL0n/IOJ4/j/w6V67ZRCn/+iRNkw9XTx+q1GltlmefI+PulhQAKytLY9m6jT+TJXN6Y8L94rgVjepV4/DRk1y7fguA1Ck9uHEzwKS/GzdvkyaVRzxE/n8a6RYRERERkQSnZYevOH7yDIP7dSNzpnQ8CHzI8ROnuXfvwRvb7N66jAo1W+BbojB9e34OgJNjEuBFwl2iXD0SJbKgb6+OZEjvxcHDxxk5bgb/Xr7Gd9NGvnWM/16+RpsW9fFMkxKAQ7+foHvvYVy/cYt+X72YEr1i0VQatPgCZydHJn87EHgxwh3pNTety70HgUyfvZgVC6eQwiMZANmyZnqruM7+eYGKtVqS1jM1c6aOxN7Bnllzl7B81U8R6o4eP5Nvhk+ieaPa9O75Oc9DnjN+ylzKVGnCvu0ryOYd9blj+oWFpaUlFhYW0dYzGAyEhYXx5MkzDhw6xqTpC6hfpwpeaVIZ65z58zzFi+SP0DZnjqzG46lTedC0YS2q12tLv69ejJKvXruFJ0+fUrG8b4xiji1KukVEJMFxcHAgICDA+F5ERD49Bw4dpWWTurRuXs9YVr1y2SjbFC6Yl0SJEpHMPWmEadtDR0/lfmAgx/ZvNCZwZXyLYmdnS++BY+jRpXW0CebrXk3Uw8PD8S1RCIPBwNRZC+nbqyMWFhbkzZ0dezs7nBwTRzuVPE3qFHimfpHA58mdjXRead4qnpeGfzsdg8HA1nUL8EjuDkBlf1/yFatmUu/K1RsMGTWVz9s2ZsKo/sbysn7FyFGwIsPGTIsw5ftVly5fJWvecjGKadv67/EtUTjaeivXbKJp2y+Nn5s3qs30iUNM6ty994CkSZ0jtHV1eVF27/4DAIoV8WHahME0ad0dWxsbEiVKxPoVs3FxdopRzLFFSbeIiCQ4FhYWJEuWzNxhiIiIGRXwyc2ipT/i5upCGd+i+OTNgbW19Tv3t3nrTnxLFCZViuQmo7MVy5Wi98Ax7N5/+K2T7l93/8boCbM4cvQUQQ8fmRwLuH3XmPDGt117D1K6VBGT81taWlK3ViWGjZlmLNu+Yy+hoaE0qV/D5J7Y2dlSslhB47T2N0mVIjn7f1kZo5iyZEofo3rly5Zg/y8refjoMQcPH2fspDncvf+AlYumkijR/5+OjmrU3IL/H6tfpyr161SN0bnjipJuERERERFJcH6YO4GRY2cwf9FKBo2YRJIkDtSoUp4Rg3oap12/jVu37/LTll9JnDxnpMfv3r3/Vv0dPnKSKnVaU6pEIWZMHErqVB7Y2FizftMvjBo3k6fPnr11jLHl7r0HpEge8R55vHbfAm7fBaBY2bqR9vNqkhsZGxsb8uTKFqOYLC0to68EJHVxJn++XAD4lSxChnReNGnTgw2bfqFG1fIAuLm6RPqYwb0HgS/6+G8UfOvPexg7aXaEemNH9I1x3LFBSbeIiCQ4wcHB9OjRA4Dx48dja2tr5ohERCS+ubslZdzIvowb2ZfLV6+zcfMO+g8ZT8Dtu2xcNeed+suZPQtD+neL9HjKFMnfqr8Va37C2tqKtUtnYmf3/99T6zf98taxxZStrQ3BISERyu/+N536JTdXF24G3I5Q79Yt0zI3NxcAli2YhJdnqgj1oxMX08tfVyB/bgDO/33JWJYjW2b+OPNXhLqn/yvLkS0zABXKlaRCuZJvfc7YpqRbREQSnNDQUKZPnw7AmDFjlHSLiHzivNKkomPbJvy6+zcOHDwaZV1bG2uePg2OUF7Z348tP+8iQ3ovkrpEfB74bVlYWGBlZYml5f9Hg58+fcaS5esjxmQbeUyRebnIWmT103ql5tRp02Tz192/8ejRE5My3xKF2bhlB7cC7hinmIeFhbHyx80m9cqXKYGVlRV/X7pCreoVYhTfq+Jievnrdu15McX91e3halQtT9eegzn0+wkKFcgDvPi3w5IVGyiUPw+pUsbv6uTRMXvSPX36dL799ltu3LhBjhw5mDhxIiVLRv5txJo1a5gxYwbHjx8nODiYHDlyMGjQICpUMP0BWb16NQMGDODvv/8mY8aMDB8+nFq1asXH5YiIiIiIyHsKDHqIf/Xm1K9ThaxZMuCYJDG/Hz3Ftl/2UPO/KcZvkjN7FnbvO8TGLTtI6ZGMJEkSkzVzBgb26cIvO/fhW6Ehndo3JUum9DwLDubfy9fYsn0XU8cNJk3qFDGOsZK/H5OmL6BZ2560bl6Pe/ceMGHaPGxsIz53njN7Flas2cTKNZtIn84TOzsbcmbPGkmvL+oCTJ21kKYNamJtbUWWTOlxdExC43o1GDRiEoNHTKZk8YKcPXeBGXN+wNnJ0aSPPl92YOOWHVSo0YJ+vTpi72DHzDlLePLkqUm9dF5p+KZPF74ZNpF/Ll3Bv2xJkro4ERBwl8NHT5LYwZ6Bfbq+8R7Y2NgYp4K/r+8WLGPfgSOUK12cNKlT8PjJU/YdOML07xZTtFA+qr2yiF6LxnWYOWcJjVp2Y9g3PUjm7saseUv568I/bP5xXqzEE5vMmnQvX76cbt26MX36dIoXL86sWbOoVKkSZ86cwcsr4kb3u3fvpnz58owYMQIXFxfmz59PtWrVOHjwIPnyvdij7cCBA9SvX5+hQ4dSq1YtfvzxR+rVq8fevXspXPjtpzOIiIiIiEj8srO1pWD+3CxZsZ5/L1/jeWgonmlS0rNrG77s2ibKtuNG9uOLXkNo2uZLnjx5SqniBdm+YREpUyRn/47VjPh2OuOnzOXa9Vs4JnEgXdo0xmTzbZQuVYTZU4YzdvIcajf6nFQpPWjdrC7J3N1o37WfSd0Bvbtw4+ZtPu82gIePHpPWMxV/ndgRab++JQrzVfd2LF62lnkLVxIeHm6cmt2jSyuCHj5i0dIfmTBtHgV9crFk3kQ+a9zRpI8c2bOwec08vh4wmtadepPUxZlG9apTq5o/HbsPNKn7Vff2eGfNxLRZC1mx+ieCQ0JIkdyd/Ply0bZlg7e6J+8jZ7YsbNq6kwFDx3Pn7n2srKzIlCEtX3dvzxcdW2Bl9f/U1dbWhi1r59N30Ld0/3oYT54+I09Ob9avmE2p4oXiLeaYsjC8unN7PCtcuDA+Pj7MmDHDWJYtWzZq1qzJyJEx2ycvR44c1K9fn4EDX/zw1K9fn6CgIDZv/v/UiYoVK5I0aVKWLl0aoz6DgoJwdnYmMDAQJ6f4XU5eRODo0aPkz5+fkpN34Jwpj7nD+egFXjjBnq5lOHLkCD4+PuYOB4DHjx+TJMmLfVUfPXpE4sSJzRyRiIip8PBwBn/Tj6rlC8frgkwiEjcmzVhMwWJl8fPzi3GbmOaNUS9HF4dCQkI4cuQI/v7+JuX+/v7s378/Rn2Eh4fz8OFDXF1djWUHDhyI0GeFChVi3KeIiIiIiIhIbDHb9PI7d+4QFhaGh4fpQ+4eHh7cvHkzRn2MGzeOx48fU69ePWPZzZs337rP4OBggoP/v1BBUFBQjM4vIiIiIiIiEhWzjXS/9Pqm5gaDIcqNzl9aunQpgwYNYvny5SRPbrq8/9v2OXLkSJydnY0vT0/Pt7gCERERERERkciZLel2d3fH0tIywgh0QEBAhJHq1y1fvpzWrVuzYsUKypUz3RcuRYoUb91nnz59CAwMNL6uXLnyllcjIiKxyd7enn/++Yd//vkHe3t7c4cjIiIi8s7MlnTb2NiQP39+tm/fblK+fft2ihUr9sZ2S5cupUWLFixZsoQqVapEOF60aNEIfW7bti3KPm1tbXFycjJ5iYiI+SRKlIh06dKRLl06EiUy+6QsERH5hMycu4SFS9ZEKL90+Sq2rt4mxxYuWYOtqzeXLl+NzxDf2fUbtxg6agonTp01dyjR+mXnfkr518cldV5SZSpCm069Cbh9N0ZtFy9bS5PWPchZqCJ2btnIkqdMHEcbNbNuGdajRw+aNm1KgQIFKFq0KLNnz+by5ct06NABeDECfe3aNRYuXAi8SLibNWvGpEmTKFKkiHFE297eHmfnFxvcf/HFF5QqVYrRo0dTo0YN1q1bx88//8zevXvNc5EiIiIiIvLBmDV3Ke5uLjRrVDvaupX8/di9dRkpPZJHWzchuHEzgGFjppHWK3WCXnV/975DVK/Xjkr+vqzq05Xbd+7Rb9BYKtZswYEdq7G1tYmy/Q/L13Mr4DYFfXITHm4g9PnzeIo8cmZNuuvXr8/du3cZMmQIN27cIGfOnGzatIm0adMCcOPGDS5fvmysP2vWLEJDQ+nUqROdOnUyljdv3pwFCxYAUKxYMZYtW0b//v0ZMGAAGTNmZPny5dqjW0TkAxISEkK/fi/2OB0+fDg2NlH/chURETGHZO6uJHN3jb5iDD158hQHh5g/VvX06TPs7GxjtCbWh6TPN9+SOWM6li2YZNyfO51XavwqNWLBD6tp36phlO1/Wj3HOFOuZoP2nDl7Ps5jjorZ5+x17NiRS5cuERwczJEjRyhVqpTx2IIFC9i5c6fx886dOzEYDBFeLxPulz777DP+/PNPQkJCOHv2LLVrR/8tlYiIJBzPnz9n7NixjB07ludm/nZaREQStn2/HaFCzRa4efngkjovvhUasGnbTpM6Q0dNwdbVO0Lb16eHZ8lThjN/nmf3vsPYunpj6+od5dTkN00v/2XnfirUbIG7V35cUufFr2JDduw6EGlMx06cpkHzrnikL0S2/KZbH0d2ru079tKuc19SZy6KS+q8BAeHcOHiv7Tt1IfsBSrgkjov6XOUolbDDvxx5pyx/a69BylWti4AbTv3NV7f0FFTjHWOHDtF7UafkyJDYZxS5qaQby1W/bj5jTHFhWvXb/H70VM0rl/dmHADFC3sQ+ZM6Vi3cXsUrV9IaI+mJaxoREREREREYmj3vkNUqNGCoKCHzJo0nIXfjSNJksTUbvg5K9dseuv+ViyaSvp0nuTNnZ3dW5exe+syViya+lZ9LFmxnip1WuPkmIS500fxw7wJJE3qTNXP2kRIvAHqN+tCxgxpWTJ/IlPGDYq2//Zd+mFlbcW8GWNYtmAS1tZW3LgZgKurC8MH9mDDyu+YOGYgVlZWlChfn3PnLwKQL3cOvps6AoA+X35uvL6WTV8k4jv3/IZfpUYEBj5k6rhBrFo8jTw5vWncunukz7i/LiwsjNDQ0Ghf4eHhUfZz+uxfAOTMkTXCsVzZs3LmT/OOWr8Ls04vFxEREREReVf9B48jqYsT29cvJEmSxABUqeBHwVI16T1wDJ/VqvRWU6/z5s6OvZ0dTo6JKVww71vH8+TJU77sM5zKFfxY+UqyXqm8L4X9ajNw6ATK+BY1adOkQU0G9uka43OU9i3C9AlDTMpKFitIyWIFjZ/DwsKo7O9L3mJVmbNgOd8O74OTUxJyZMsMQIb0nhGur2vPIWT3zszWdQuMI8z+ZUty5959Bg6bQJMGNaMcQc7mU55/r1yPNv7+X3ViQO8ubzx+7/4DAFxdnCMcS5rUmbv3HkR7joRGSbeIiIiIiHxwHj9+wqEjJ2nXqqEx4QawtLSkUf0a9Bs0lnPn/8E7S4Z4i+nAoWPcux9I0wY1CQ0NNTnmX7Yk4ybP4fHjJyRO7GAsr1W9wludo2a1iPVDQ0MZN3kOS1Zs4O9/Lps8mvXnXxej7fPCxX85d/4io4Z8ZezvpYrlfdm0dSfnzv9DtqwZ39jHmqUzCA4OifZcKVPEbNG5N31Z8iE+v66kW+QtXL58mTt37pg7jI/e2bMJfxuLj1FCuu9Pnz41vj9+/PhHt1e3u7s7Xl5e5g5DROSDdv9BEAaDgZQeySIcS/VfYncvnkdFX25p1aDFF2+sc+9+oEnSnSKS+KMS2fX26j+KmXOW0POLNpQsVpCkLs4kSmRBhy8G8OzZs+jjDngRd++BY+g9cEykde7eux9lH9myZsJgMER7ruiet3ZN6vLifP+NeL/q/v1AXJNGHAFP6JR0i8TQ5cuXyZotG8+ePDF3KJ+MZ8HBfHj/W/3wPLt3CywsaNKkiblDiVSJEiXMHUKss3Nw4NzZs0q8RUTeQ1IXJxIlSsSNW7cjHLt+MwAANzcXAOzsbAEIDg4x2W7qzt2oE8m35eb64nwTRvencIE8kdbxSO5m8vltR24jq750xQaa1K/B0AE9TMrv3r2Pi7NjtH2+vE9fdW9HzarlI62TJVP6KPuIrenlObJlAeD0mb+oVN7X5NgfZ/8iu3fmaM+R0CjpFomhO3fu8OzJE/L2momjZxZzh/NRu/X7z/y1cITZ91T8VIQ+DgSDgaydxpM8a15zhwNAWPBT9veqAkCxb3/C0vbjGel+eOUvjn/bgTt37ijpFhF5D4kTO1Aof27WbdzO6CFfYW9vB0B4eDhLV6wnTaoUxkQxrWdqAE6dPkcBn1zGPjZt/TVCv7a21jx9GvxOMRUr7IOLsxNnz/1Nx7bx92W2hQXYvLZ39aZtO7l24xYZM/z/d83LLxyePjO9vqyZM5ApY1pO/nEuQuIeU7E1vTx1Kg8K+uRmyYr1dO/cCktLSwAOHj7OX+f/oUuH5u8Unzkp6RZ5S46eWXDOFPk3lxI7Hl35y9whfJIcUmdKMD/bhvBwfGfsAyCJZxYsEtjWHyIikjAMHdiDyrVb41+9Od07t8TaxoZZc5dw+ux5Fn03zjiKXLG8L65JnWnftR8D+3TFysqSRUt+5Mq1mxH6zJk9CyvWbGLlmk2kT+eJnZ0NObNHXEk7MkmSJGbC6P607tib+/cDqV3dn2TJ3Lhz5x4n/zjH7bv3mBqDFcrfVuUKfixa+iNZM2cgV46sHD1+mglT55ImVQqTehnSeWFvb8eylRvwzpKBJIkdSJkiOalSejBt/GCq12tHlTqtadaoFqlSenDvfiDn/vqbYyfOsHTBpChjiOk9ionhg76kcu3WNGzZjfatGnL7zl36Dx5PjmyZad7o/9tB/3vlGtl8/GnaoCazpgw3lp/98wJnz10A4FbAHZ48fcaadVuAF9Pgs3lnirVYY0JJt4iIJDgWiRLhmDbifqoiIiKvKlW8EFvXLWDIqCm06dyX8PBwcufIyuol06lSobSxnpNTEjasnEPPviNo2eErXJwcadn0MyqUK0WHL/qb9Dmgdxdu3LzN590G8PDRY9J6puKvEztiHFOjetXxTJOScZPn0KnHNzx89ITk7q7kzuVNs4a1Yu3aXzVuZD+sraz5duJsHj1+Qr7c2Vm+cAqDhk80qefgYM/sycMZNmYaVeq04fnz58bp3n4li7Dv55WMGjeTnn1Hcv9BEG6uLnhnzchnNSvGSdxv4luiMOuWz2LIyMnUbvQ5DvZ2VK7gx8jBX5k8HmAwGAgLCyMsPMyk/aq1mxk2ZppJWcOW3YDop7fHBQtDTJ52/8QEBQXh7OxMYGAgTk5O5g5HEoijR4+SP39+Sk7ekWBGAz9W135dybFvO5BvxHpS5y1u7nA+errf8Svwwgn2dC3DkSNH8PHxMXc4IvKOwsPDGfxNP6qWL0yeXNnMHY6IvKdJMxZTsFhZ/Pz8YtwmpnmjRrpFRCTBCX8ewvnlEwDIXL87iaxtomkhIiIikjAp6RYRkQQnPOw555e82LIk42edlXSLiIjIB0sr04iIiIiIiIjEESXdIiIiIiIiInFESbeIiIiIiIhIHFHSLSIiIiLyCSlfrSnlqzU1dxixrk2n3mTJU+ad2i5btYHJM76P9JitqzdDR015n9A+SJcuX8XW1ZuFS9a8ddtdew9i6+rNrr0H4yCyqN0KuMOAoeMpWKom7l75SeKRiww5fKnXrAsbNu8gLCws+k5imRZSExERERGRD16fnh3p3L7ZO7VdtmojZ86ep+vnzSMc2711GalTpXjf8CQeHDx8nDqNO2IwGGjXsiGFCuYhSWIHrly9wU9bfqV+sy5MGz+Ylk0/i9e4lHSLiIiIiMg7e/r0Gfb2dmY7/5MnT3FwsCdjeq846b9wwbxx0q/ErgeBQdRt2pnEiR3YuXkJKVMkNzneqF51Tp0+x9179+M9Nk0vFxGRBMfS2o4SE7dTYuJ2LK3N9w85EZF3dfvOPT7vNoCMOf1wTJGL1JmL4lexIb/s3G9S75ed+6lQswXuXvlxSZ0Xv4oN2bHrQIT+/vzrIk3b9MAza3EcU+QiU67StPr8a4KDQwAYOmoKtq7eEdotXLIGW1dvLl2+GmW8w0ZPpUS5eqTIUBh3r/wU9qvN/EWrMBgMJvWy5ClDzQbtWbthG4V8a+GUMjfDxkyLtM8v+4wgaZp8BAU9inCscavueGYtzvPnzwFYuWYTlWu3Im22kjinykPuwpXpN3gcjx8/MWnXplNvXD19+OPMOSrXboWblw8Va7YwHnt9evmMOT9QtkoT0mQpRtI0+fApXo2xk+cYzwsvpttv3raLf69cx9bV2/h6KbLp5afP/EWdxh3xSF8Ip5S5KViqJouW/mhS5+UU6+WrNzJw2ATSZS+Ju1d+KtZqybnzFyO9Z696+Wd66vQ5Grb4gmRpC5AiQ2F69RtJaGgo585fpOpnbXDz8iFLnjKMnTwnQh+Xr16nRftepMlSDMcUuchduDITps4jPDzcpN71G7do1LIbbl4+JEtbgMatunPr1p1I4zpy7BS1G31OigyFcUqZm0K+tVj14+Zoryeuzf1+JbcC7jByUM8ICfdLuXJkxa9kkXiOTCPdIiKSAFlYWuKSxcfcYYiIvLOWHb7i+MkzDO7XjcyZ0vEg8CHHT5zm3r0HxjpLVqyn1edfU61yWeZOH4WVtRVzFiyn6mdt2LhqDmV8iwJw8o8/KV25EW6uSRnYpwuZMqTj5q3bbNy8g5CQEGxtbd473n8vX6NNi/p4pkkJwKHfT9C99zCu37hFv686mdQ9fvIMvf+6SJ8vO5AubRoSOzhE2meLJnWYOmshq9ZuplWzusbyB4FBbNj8Cx1aN8La2hqACxf/pWJ5X7p83pzEDvacO3+RsZPm8PvRk2xdZ/qsdUjIc2o36kjbFvXp1a0doaGhb7yui/9cpv5nVUnnlRobG2tO/nGO0eNn8tdfF5k9dQQAk7/9ho7dB3Lx0hVWLIz+2e1z5y/iW7EhyZK5MX5UP1xdXVi6Yj1tOvXh1u279OzaxqT+gKETKFbYhxmThvEw6BH9Bo+jdqPPOfnbJiwtLaM9X6NW3WhUtzptWtTnl537GTd5Ds9DQ9mx8wDtWzeke+dWLF+1kX6DxpIpvRc1q/kDL7748avQkJDnz/mmb1fSeqZm07ad9B44houXrjBl7DfAi5kKlWq14sbNAIYO6EHmjOnYvG0XTVr3iBDLzj2/Ua1uWwrlz8PUcYNwckrCyjWbaNy6O0+ePqVZo9rRXs/rovrze5WlpSUWFhZvPP7Lzn1YWlpSsbzvW8cQ15R0i4iIiIjEsgOHjtKySV1aN69nLKteuazx/ZMnT/myz3AqV/Bj5aKpxvJK5X0p7FebgUMnGJPuXv1HYWVpxb6fV5LM3dVYt2HdarEW73fTRhrfh4eH41uiEAaDgamzFtK3V0eTZCfg9j2OH9hIlkzpo+wzV46s5MuTnYVL1pgk3ctX/0RwcAjNX0nQ+vT83PjeYDBQrLAP3lkyUq5qU06dPkeuHFmNx58/f06/Xh1p3rhOtNf17fA+JtdVomgB3FxdaNu5L6OHfU1SF2eyeWfC2dkRWxvrGE0lHzZ6KiHPn7Nt3ffGLykqlfflQeBDho+ZRtsW9XF2cjTWz5Y1EwtmfWv8bGlpSaNW3fj96KkYna91s3p069QSgLJ+xfj5133M+O4HViycQo2q5QHwLVGITdt2snTlBmPSPWn6fK7duMXe7SsomD83AP5lSxIWFs5385fRpUMzsmRKz6Jla/nzr79Z9cN0qlV6MVOgfJkSPH32jHkLV5rE0rXnELJ7Z2brugVYWVkZ+7xz7z4Dh02gSYOaJEoU88nUly5fJWvecjGqu2399/iWKPzG41ev3SSZuysODvYm5eHh4SYj+4kSJXqrGGODkm4REUlwwp+H8M+6WQCkr9GeRNbvP4ojIhKfCvjkZtHSH3FzdaGMb1F88uYwjuoCHDh0jHv3A2naoGaEkT7/siUZN3kOjx8/wcLCgj37DtOiSR2ThDu2/br7N0ZPmMWRo6cIemg6HTzg9l08krsbP+fKkTXahPulZo1q0/3rYZw7f5GsmTMAL6a8F/DJRY7sWYz1Ll66wqDhE9m55yABt++aTGv/89zfJkk3QK1qFWJ0/uMnzzBk1BQOHDzKvfuBJsfOX7hEoQJ5YtTPq3buOUjpUkWNCfdLzRrWYuvPu/nt0HEqlCtpLK9aqbRJvZw5Xlz35SvXY5R0V67gZ/LZO0sGTv7xJxXKlTKWWVlZkTG9F5evXv9/nLsPki1rJmPC/Wqcs+ctZeeeg2TJlJ5dew7imCSxMeF+qcFnVU2S7gsX/+Xc+YuMGvIVYDpCXbG8L5u27uTc+X/IljVjtNf0UqoUydn/y8roK0KMf+Ze16vfKKbOWmj8XMnfl7XLZr1TX+9KSbeIiCQ44WHPOTtvEABpq7ZS0i0iH5wf5k5g5NgZzF+0kkEjJpEkiQM1qpRnxKCepPBIRsDtuwA0aPHFG/u4dz+QRIkSERYWRpo4XD378JGTVKnTmlIlCjFj4lBSp/LAxsaa9Zt+YdS4mTx99sykfgqPZDHuu2HdavQeOIZFS39k2MAvOfvnBX4/eorJ/01tBnj06DFlqzTG1taWQX2/IHOmdDjY23H12k3qNesS4fwODvY4OSWJ9tyXr16nTJUmZMmUjnEj+5HWKzV2tjYcPnqKL3oNidBvTN2994CUkdyDlClfPEd87/4Dk3K3pC4mn18+DhDT87u+1t7GxhoHB3vs7GwjlAc9fPz/OO8/IK1X6ohx/ve888tHHe7ef0DyV75Ueckjuek1BgS8+JntPXAMvQeOiTTWt12kzMbGhjy5ssWobnRT8T3TpOTC7n+NC+u91K1TSxrVezErpE7jjm8VX2xR0i0iIiIiEsvc3ZIybmRfxo3sy+Wr19m4eQf9h4wn4PZdNq6ag5urCwATRven8BtGWz2SuxEWFo6lpSVXr9+M8nwvE7DgYNNnvO/cjT4JWrHmJ6ytrVi7dKZJIrd+0y+R1o/isdoIkro4U61SWX5Yvo7B/brx/ZI12NnZUr9OFWOdX/cc5PqNALZvWEip4oWM5Q8CH77h/DELYP1PP/P48ROWL5xCWs//J58nTv0Z8wuIhJurCzdu3Y5QfuNGgPF4QuCW1IWbNyOJ8+Z/cbq5GOv9fuRkhHq3Akzbvqz/Vfd21PxvWvvr3nY0Ojanl7+cer9l+y5q16hoLPdMk9I4K8Hmldkm8UlJt4iIiIhIHPJKk4qObZvw6+7fOHDwKADFCvvg4uzE2XN/07FtkyjblyxekDXrtjKkf3fc3ZJGWudlUnnq9DkK+OQylm/a+mu08VlYWGBlZYml5f+fc3369BlLlq+Ptm1MNGtUm1VrN7N5+y6WrtxAjSrlcHF2euX8L/5ra2M6q2nOguXvdd6Xyfmr/RoMhgjPKb+s8/RZcIz6LV2qCOt++pnrN26RKqWHsXzx8rU4ONgnmC3GSvsWYcyE2Rw7cZp8eXIYyxcvX4uFhYUxgfUtWZhVazezYfMOkynmy1ZtNOkva+YMZMqYlpN/nGPogIiLrL2L2Jxe3qpZXSZOm0+fQWMpWtjnjSuYm4OSbhERERGRWBQY9BD/6s2pX6cKWbNkwDFJYn4/eoptv+wxjhAmSZKYCaP707pjb+7fD6R2dX+SJXPjzp17nPzjHLfv3mPquEEAfDusN6UrN6JE+Xr0+qItGTN4ERBwl41bdjBt/GAcHZNQsbwvrkmdad+1HwP7dMXKypJFS37kyrWoR8gBKvn7MWn6Apq17Unr5vW4d+8BE6bNw8Y2dkYFy5cpTppUKfii5xBu3rodYYXrooXykdTFmc5fDqL/V52wsrZi2coNnDz9fiPSZf2KY2NjTbO2X9KjSxuCg4OZNW8p9wMDI9TNmT0LazduZ9a8pfjkyUGiRBbkz5crkl6h31ed2LR1J/41mtOvVyeSujizbNUGNm/bxYhBvUwWUTOnrp+34Idl66jZoAMDe3fByzMVm7ftYtbcpbRr1dCYxDapX4PJMxbQ+vOvGdy/G5kypGXL9t38vGNfhD6njR9M9XrtqFKnNc0a1SJVSg/u3Q/k3F9/c+zEGZYumPRWMdrY2LzxPr8tF2cnVi6aSu1Gn1OwVE3atWxAoQJ5SZLEgbv3HrB3/2FuBtyhSKF8sXK+t6GkW0REREQkFtnZ2lIwf26WrFjPv5ev8Tw0FM80KenZtQ1fvrKdVKN61fFMk5Jxk+fQqcc3PHz0hOTuruTO5U2zhrWM9XLn9Gbv9pUMHTWFAUPH8/DRY1IkT4ZfycLY/DeK6+SUhA0r59Cz7whadvgKFydHWjb9jArlStHhi/5Rxlu6VBFmTxnO2MlzqN3oc1Kl9KB1s7okc3ejfdd+730/EiVKROMGNRg9fhaeqVMaV2V/yc01KWuXzeTrAaNp0eErEjvYv5iSPncChf3efguql7yzZGDZ95MZNHwS9Zt3wS2pC/U/q8oXHVtSvV5bk7qdOzTjzJ8XGDh0AoFBDzEYDATfizzpz5o5A7u2LGXAsAnGZ8O9s2Tku6kj3mnLrLiSzN2VnVuXMmDIeAYMHU/Qw8ekT5eGEYN6GldDhxfPyG9d+z1f9hlO/yHjsMCCcqWLs2jOOHwrNjTp069kEfb9vJJR42bSs+9I7j8Iws3VBe+sGfmsZsXXQ4h3hQvm5ei+DUydtZD1m35h4vQFhIQ8J5l7UvLlycGMiUNNHm2ILxaG13e8j4EFCxZQr149HN6wJ9+HLigoCGdnZwIDA3Fycoq+gXwSjh49Sv78+Sk5eQfOmd5+pUuJuWu/ruTYtx3IN2I9qfMWN3c4H72EeL9Dnz1mS20vACquuYyVXWIzRxR7Ai+cYE/XMhw5cgQfH+1FLvKhCg8PZ/A3/ahavnCMF4ISkYRr0ozFFCxWFj8/vxi3iWne+E4blPXp04cUKVLQunVr9u/f/y5diIiIiIiIiHz03inpvnr1KosXL+b+/fuULl0ab29vRo8ezc2b0T8zIiIiEh1LazuKjFpHkVHrsLS2M3c4IiIiIu/snZJuS0tLqlevzpo1a7hy5Qrt2rXjhx9+wMvLi+rVq7Nu3TrCw8NjO1YREflEWFha4p67BO65S2ARzb6cIiIiIgnZOyXdr0qePDnFixenaNGiJEqUiFOnTtGiRQsyZszIzp07YyFEERERERERkQ/TOyfdt27dYuzYseTIkQM/Pz+CgoLYuHEj//zzD9evX6d27do0b948NmMVEZFPRHjocy5tmMOlDXMID31u7nBERD5IM+cuYeGSNRHKL12+iq2rt8mxhUvWYOvqzaXLV+MzRBPvE8Pm7bsYOmpKHEQV8/NkyVOGNp16x3kMH5uVazaRt2hVnFPlwdbVmxOnzsZq/9dv3GLoqCmx3u/beKeku1q1anh6erJgwQLatm3LtWvXWLp0KeXKlQPA3t6eL7/8kitXrsRqsCIi8mkIDw3hjxlf88eMrwkPDTF3OCIiH6RZc5eyaOmPMapbyd+P3VuXkdIjeRxHFTe2bN/FsDHTzHqeFYum0qdnxziP4WNy+849Wn7+NRnSe7Jh5Xfs3rqMzBnTxeo5btwMYNiYaWZNut9pn+7kyZOza9cuihYt+sY6KVOm5J9//nnnwEREREREJH4kc3clmbtrrPX35MlTHBzsY62/D0He3NnNHcIH4+nTZ9jZ2XL+wiWeP39Oo7rVKVW8kLnDijPvNNLt6+sb6d6iISEhLFy4KV1EdwAAN8ZJREFUEAALCwvSpk37ftGJiIiIiHwi9v12hAo1W+Dm5YNL6rz4VmjApm07TeoMHTUFW1fvCG1fn5qdJU8Zzvx5nt37DmPr6o2tqzdZ8pR547nfNLX7l537qVCzBe5e+XFJnRe/ig3ZsetApDEdO3GaBs274pG+ENny+0d5rQcPH8evYkOcUuYmXfaS9B8yjufPQyOtu3LNJkr51ydpmny4evpQpU5rjp88YzzeplNvZs5ZAmC81levxWAwMHPuEgqWqolzqjx4pC9Eg+ZduXgp4qzcrT/voULNFiRLWwCX1HnJXbgyYybMitF5IptefvnqdVq070WaLMVwTJGL3IUrM2HqPJNFp19O9x8/ZS4Tp80nS96yuHr6UMq/PgcPH4/yPsa2XXsPYuvqzZIV6+nVbyRe3iVwTpWHclWbmNzzl44cO0XtRp+TIkNhnFLmppBvLVb9uNmkzsufre079tKuc19SZy6KS+q8NG3zJaUrNwKgcevu2Lp6U75a07fqG+Da9Vt83m0AGXP6kcQjF+myl6RB867cCrjDrr0HKVa2LgBtO/c1/pnFx6MIr3qnke6WLVtSsWJFkic3nX7y8OFDWrZsSbNmzWIlOBERERGRT8HufYeoXLs1uXJk+V97dx4XVb3/cfw97GqKC4JLgJqKIi4I7pqWiUuL2qYWZqWWaW5UKq6pKTctxQ3NMrnZdWmxsrKrVNctrRRFy7hmtwWugYgoqCjKML8/vM6vEVQYGA/g6/l4nMc9853v+Z73GafH9eP3zPfojUVz5ObupjdWrdWDg57Tmjdf1yMP9inSeO+tWaqBT46VZ5XKWjx/uiTJ3d2tSGOsfW+Tnn5uou7v012rYv4mF1cXvRW7Qfc9PEyfffCW7u5qe9frgCdG65EH79XwpwbqXPb5a46b+O9f1Kv/U/L3rau3lkapQsUKemPVWm344PN8fV9dsEIz5izSkMce1KQXn9Oli5e0YMkq3X1vuL6Je09NmzRU5Isjde7ceW3ctEU7tqy3HnvlVvmR46drzbqPNeqZcM2Z8YJOnc7UnHkx6tZrkPbu+Fg+3l6SpNVrPtBz46bpzk5ttHTBy6rpVUNH//O7DicelaQbnudqJ9Iz1K3nIF28dEkzJo+Rv29dbd66TZOmz9OvvydryWszbPqvWLVWAY0a6LW5kyVJM+cuUt8Bz+pIwpfyrFL5mp+nJOXmFvwPFldzdnaWyWS6Yb/psxeqVctALV80W1lZZzX71aXqcf8T+m77R2pQz1eStG3nt7r/keFqG9JSS19/WVWq3Kb3N27W40PHK/v8eT3x2IM2Yz47eop6hXXV28vnKTs7Wy2aN1XnjqEa+9IszZ42Xl07t1OVyrcVaexjfx5Xp3se1qVLuZow/lk1bxagjIzTivt6l06dzlJwi2Z6c+lcDX9+siJfeE69w7pKkurWqVWoz6uk2FV0WyyWAv+w/vvf/8rT07PYoQAAAIBbydSZr6ta1SqK2/SObrutkiTp3p7d1ObOfpo0fZ4e7t+7UMXSFa1aBKqCh4eqVK6kdm1aFTlPdvZ5vRA5R316dtP7a5Za23v36Kp23R7U9NkL8xXd4QP7aXrkmBuOPWd+jCwWi7Z8EmstePuEdVVwx/tt+iX/N0Wz/rZUzw1/XAv/NtXa3r1bRzVr00uvzFumf7y9UHfU95O3dw1Jynet3+1N0NvvvK9XZ0/UuFFPWds7tQ9VUNteWhQTq7kvv6izZ89pwtS/qWO71tryyd+tn/Vfr/F65ynIopjVOpZyXLvi3lObkBaSpLDuXWQ25+nN1es1esQTatywvrV/5dsq6eP1K+T8v0dl1qnlrU73PKItcTv06EP3XvM8vyf9VwGt7rlhHknauunv6tq53Q37eXlV0/trllo/h47tW6tZaC/NX7hSyxfNliSNeXGWAps00pZPYuXi4mK9vvSMU5r+ykKFD+wnJ6f/v7H6rq7tFbNwls15/htwhySpYQN/m8+0sGPPilqs9JOntXfHx2r6v7Ek6eH+va37zZo2kiQ1qO9r138LJaFIRXdwcLBMJpNMJpO6d+9u/QAkyWw267ffflOvXr1KPCQAAABQXp07l63v4w/pmacHWQtu6fKs5GMD+mrKy6/pyNHf1KRxg5uWac/3B5RxKlODB/bLN4sa1r2LXl/8ls6dy1alShWt7f0f6Fmosbfv+k533dneWnBLl6/1kf69bRYpi/t6l3JzcxU+oK9NBg8Pd3Xp2Ebbd313w3Nt3rpNJpNJjz36gM0YtXy81KJZgHbs+t56vVlnzurZoYOK9I8b17Ntx3dqGtDQWnBf8cSg/lr59jpt2/mdTdHdO6yrteCWpObNAiRdvkX9eurU8tbur94vVKa/nu96Bjx0n83n4O9bVx3attK2/33mv/z6h44c/VV/mzVBku1Me68eXbV5yzYdOfqbTSHc7/7CfT+KMvaWr3aoa+e2NucpjYpUdPfr10+SlJCQoJ49e+q2226zvufm5qZ69erpoYceKtGAAAAAQHl26nSWLBaLavvUzPdenVqXb13OyDh9UzOlnTgpSRr45Nhr9sk4lWlTdNcqIH9BTmacVi3v/H19rjr+SoYrv8m92l9nUa8lLe2kLBaLfAM6Ffh+/f/dKp1+8pSkkr3t+OSp0/L3q5uvvfY1/kyrV6tq8/rKzwHOn79w3fO4ubmpZfOmhcr016L+egr6s/TxrqlDPx6RdPlzlaRJ0+dp0vR5BY5xMuOUzeuCvt8FKcrYJ9JP6fabfKu4PYpUdM+Ycfl3B/Xq1dOAAQPk4eHhkFAAgFubk6u72ry8zroPAOVZtapV5OTkpJTjJ/K992dqmiSpRo2qki7P8kpSTs5Fm99oXykaS0qN6pfPt/DVqWoX2rLAPj7/u9X6isLOENeoXlWpafmv9fhV13/lmtfHLpKfb51CjZ3vXDWqymQy6evP/yF3d9d871/5DL1qVJMkHfsz1a7zFHjualWVmpr/OlOu+jMtLkfcXp5awHfxeNoJVf/f9+JK9gnjn1G/+3oUOMbVs+qFvYGgKGPX9Kqm/5bgn5mj2PWb7iFDhpR0DgAArJycXeTT9vor3wJAeVGpUkW1DWmhTz6L06uzJqhChcsTW3l5eVr33ibdXqeWtcjw9708c/rD4SMKbd3cOsbmLf/KN667u6vOn8+xK1PHdq1V1bOKEo/8RyOHh9s1xrV07dxOn/3zax1PS7feYm42m/X+VStT97i7s1xcXPSf35NveOu6u9v/zwpf+fwkqU/YXZof/ab+TDlu8zvfq3VoGyzPKpX15ur1evTBe6/5DwjXOk9B7uraXvMWrtSBg4cV3LKZtf3dDR/LZDIVqvgtDEfcXv7exs81btRT1s/hj+Rj2vN9gsIH9JUkBTRqoIZ3+OvQj0c0e1qEfcGvoShj9+x+p/7x3iYdOfqrAhoV/PML6x0DF+z7b6EkFLrorl69un7++Wd5eXmpWrVq1/2XrIyMjBIJBwAAANwKZk+PUJ8HhyrsgSEa//xTcnW7vHr54cSjWvPm69a/e/fq0VXVq3nq2TFTND1yjFxcnLVm7UdKPpZ/ti8osLHe27hZ72/crPr1fOXh4aagwIBC5bnttkpa+OpUDR05SadOZerBB8JUs2YNpadn6NCPR3TiZIaWvv6yXdca+cIIffbPr9Wz75Oa8tJIVajooRVvrVX2VSue1/O7XTMiR2vGK9H67fdkhXXvompVqygt7aT27j+kShUrWBduCwpsLEl6bdGb6nnPnXJ2dlLzZgHq2L61hg55VMNHT1Z8wo/q3DFUlSpWUOrxE/rm2/0KCmysZ//3W/pXZ0/UiLFT1av/Uxo6+BF5e9fQf35N0qHD/9aiedOvex43t/wrw4957kn9Y/0n6jdwhKZPGi0/3zr6Yut2vbFqnZ55elChC+AbcXNzU0hw8xt3LIITJzL0yODn9fQTjygr64xm/W2pPNzd9NL4Z6x9li2YqQcefUb3PjRUTzzWX3Vq+yjjVKaO/PwfHTj4k9bFLrL7/IUde3rkGG35aofuuW+wJox/VkGBjZWZmaUtX+3U2JFPqUnjBmpQz08VKnho/fufqknjBrqtUkXVruWtOrV9iv05FVahi+6FCxeqcuXK1v2SWmAAAICr5eVe0rF/Xf5X+7p3PSInl/y3BAJAeXJnp7ba8kmsZv1tiYY9P1l5eXlq0SxAH66N0b0977L2q1LlNn36/lt6cfJcPTVigqpWqaynBj+snvfcqRFjp9qMOW3SaKWkntBz46bpzNlz8veto58Pfl3oTI89+oB8b6+t1xe/pVERM3TmbLa8vaqrRfMmemJQf7uvtVlgY32x8W1NnPaqho6apGpVPfXYow+o//1hGjl+uk3fCeOfVZOAhlr2xjt678PPlXPxomp5eykkuLmGPzXQ2m/gw/dpz3cH9Mbb66yrox9J+FL1/G5XzMJZahfaUm/Fvqc33l6nvLw81a7lrY7tgtXmL3cLPDX4YdWu5a3XF7+pEeOmyWKxyN+3rsIH9SvUea5W06u6tm1Zp2mzFmja7AXKOnNO9evdrrkvv2izknppNGvaeO3b/4OeeX6yss6cVZvWLfTuW6/rjvp+1j7durTXN1++r7+9vkIvTo7SqdNZqlG9qpoE3KGH+xVvce3Cjl23jo92xb2v2X9botcWvamTGadV06uaOrYLUfVql5+qVbFiBa1cPEevzFumex8apkuXLmnqhFGaNml0sTIWhclisVhu2tnKiKysLHl6eiozM1NVqlQxOg5Kif379yskJERdFn8tz4YF/7YJJePYv97XgfkjFDx3k+q2KnjhE5Sc0vh55144p38+ePn/2HttTJKLR6UbHFF2ZP5yUDvH3K34+Hi1bt3a6DgA7JSXl6eZM6bovh7tCr2IFVDabd/1ncIeGKJ1q6P1YN9b66lUi5a/qzYdu6tbt26FPqawdWOhZ7qzsrIKfXIKVQAAAAAAilB0V61a9Ya3lFssFplMJpnN5mIHAwAAAADgZnDkDeCFLrr/9a/8KyICAAAAtyKTySQnJ2ddupRrdBSgxHTt3E45Gf82OoYhzGazXFzserjXDRV61K5duzokQExMjObPn6+UlBQ1a9ZM0dHR6tKlS4F9U1JS9MILLyg+Pl5Hjx7VmDFjFB0dbdMnNjZWTz2Vf2GC8+fP81xxAAAAlAiTyaSq1aoX+LxpAGVLZtYZnb9wSVWrVnXI+IUuug8dOqSgoCA5OTnp0KFD1+3bokWLQo25YcMGjRs3TjExMerUqZPeeOMN9e7dWz/99JP8/Pzy9c/JyVHNmjU1ZcoULVy48JrjVqlSRUeOHLFpo+AGAABASQps1lz79nytHnddtD4LGEDZc+jHf8vVvaIaNWrkkPELXXS3atVKqamp8vb2VqtWrWQymQq8770ov+lesGCBhg4dqmHDhkmSoqOjtWXLFi1fvlxRUVH5+terV0+LFl1+Jtvbb799zXFNJpNq1apVqAwAAACAPYKDg7X3+z1a/8Fnur/P3aperarRkQAUQW5urg7+kKgduxPUpkM3ubu7O+Q8hS66f/vtN9WsWdO6X1wXL15UfHy8Jk2aZNMeFham3bt3F2vss2fPyt/fX2azWa1atdLs2bMVHBxcrDEBADePk6u7Wke+bd0HgNLIy8tLTwx5WmveiVXMqvflXaOKqlSuJKcbLD4MwHg5ly4p9XiGcnJNCg7tpD59+jjsXIUuuv39/Qvct1d6errMZrN8fHxs2n18fJSammr3uE2aNFFsbKyaN2+urKwsLVq0SJ06ddLBgwevebtATk6OcnJyrK+L8ng0AEDJc3J2UZ0ufY2OAQA3dPvtt+uFFyfol19+0dGjR3Xu3Dnl5eUZHQvADVTxdFfDwPYKDAy0Ti47it3Lsx05ckRLlixRYmKiTCaTmjRpotGjRysgIKBI41z9GLIrjx2zV/v27dW+fXvr606dOql169ZasmSJFi9eXOAxUVFRmjlzpt3nBAAAwK3Lzc1NgYGBCgwMNDoKgFLIyZ6DPvjgAwUFBSk+Pl4tW7ZUixYttH//fgUFBen9998v1BheXl5ydnbON6udlpaWb/a7OJycnNSmTRsdPXr0mn0iIyOVmZlp3ZKTk0vs/ACAossz5+rPnZ/oz52fKM/M43gAAEDZZddM94QJExQZGalZs2bZtM+YMUMTJ07UI488csMx3NzcFBISori4OPXv39/aHhcXp759S+6WQovFooSEBDVv3vyafdzd3R32o3kAQNHlXcrR/qinJUm9NibJydkxz80EAABwNLv+FpOamqonnngiX3t4eLjmz59f6HEiIiI0ePBghYaGqkOHDlq5cqWSkpI0YsQISZdnoI8dO6Z33nnHekxCQoKky4ulnThxQgkJCdZbeiRp5syZat++vRo1aqSsrCwtXrxYCQkJWrZsmT2XCgAAAACA3ewqurt166adO3eqYcOGNu27du1Sly5dCj3OgAEDdPLkSc2aNUspKSkKCgrS5s2brQu1paSkKCkpyeaYv65CHh8fr7Vr18rf31+///67JOn06dN65plnlJqaKk9PTwUHB2vHjh1q27atPZcKAAAAAIDdCl10b9q0ybr/wAMPaOLEiYqPj7cuWvbtt9/q/fffL/KCZCNHjtTIkSMLfC82NjZfW0HPBv+rhQsXauHChUXKAAAAAACAIxS66O7Xr1++tpiYGMXExNi0jRo1ynp7OAAAAAAAt7JCF908bxAAAAAAgKKx65FhAAAAAADgxux+Bsu5c+e0fft2JSUl6eLFizbvjRkzptjBAAC3LicXN7Ucv8S6DwAAUFbZVXQfOHBAffr0UXZ2ts6dO6fq1asrPT1dFStWlLe3N0U3AKBYnFxc5dvjMaNjAAAAFJtdt5ePHz9e999/vzIyMlShQgV9++23+uOPPxQSEqLXXnutpDMCAAAAAFAm2VV0JyQk6IUXXpCzs7OcnZ2Vk5MjX19fzZs3T5MnTy7pjACAW0yeOVfHv9+q499vVZ451+g4AAAAdrOr6HZ1dZXJZJIk+fj4KCkpSZLk6elp3QcAwF55l3K09+VB2vvyIOVdyjE6DgAAgN3s+k13cHCw9u3bp8aNG+uuu+7S9OnTlZ6erjVr1qh58+YlnREAgHInMTHR6Ai3DC8vL/n5+RkdAwBwi7Kr6J47d67OnDkjSZo9e7aGDBmi5557Tg0bNtTq1atLNCAAAOXJhYzjksmk8PBwo6PcMjwqVtSRxEQKbwCAIewqukNDQ637NWvW1ObNm0ssEAAA5VnuuUzJYlHAqAXyDmhldJxy70zyz0qYP0Lp6ekU3QAAQ9j9nG5JSktL05EjR2QymRQQEKCaNWuWVC4AAMq1inUbyrNhS6NjAAAAB7NrIbWsrCwNHjxYdevWVdeuXXXnnXeqTp06Cg8PV2ZmZklnBAAAAACgTLKr6B42bJi+++47ffbZZzp9+rQyMzP12Wefad++fRo+fHhJZwQAAAAAoEyy6/byzz//XFu2bFHnzp2tbT179tSbb76pXr16lVg4AMCtycnFTUHPvWrdBwAAKKvsKrpr1KghT0/PfO2enp6qVq1asUMBAG5tTi6uqnf/MKNjAAAAFJtdt5dPnTpVERERSklJsbalpqbqpZde0rRp00osHAAAAAAAZVmhZ7qDg4NlMpmsr48ePSp/f3/r4zeSkpLk7u6uEydO6Nlnny35pACAW4bFbNbJw3skSTWadZDJ2dngRAAAAPYpdNHdr18/B8YAAOD/mS9d0LeT+kqSem1MkotzJYMTAQAA2KfQRfeMGTMcmQMAAAAAgHLHroXUroiPj1diYqJMJpMCAwMVHBxcUrkAAAAAACjz7Cq609LSNHDgQG3btk1Vq1aVxWJRZmam7rrrLq1fv141a9Ys6ZwAAAAAAJQ5dq1ePnr0aGVlZenw4cPKyMjQqVOn9OOPPyorK0tjxowp6YwAAAAAAJRJds10//Of/9SXX36ppk2bWtsCAwO1bNkyhYWFlVg4AAAAAADKMrtmuvPy8uTq6pqv3dXVVXl5ecUOBQAAAABAeWBX0X333Xdr7Nix+vPPP61tx44d0/jx49W9e/cSCwcAuDU5Obuq6dMvq+nTL8vJOf8/8gIAAJQVdt1evnTpUvXt21f16tWTr6+vTCaTkpKS1Lx5c7377rslnREAcItxcnXTHQ+PNjoGAABAsdlVdPv6+mr//v2Ki4vTv//9b1ksFgUGBuqee+4p6XwAAAAAAJRZRS66c3Nz5eHhoYSEBPXo0UM9evRwRC4AwC3MYjYr8z8HJUmed7SUydnZ4EQAAAD2KXLR7eLiIn9/f5nNZkfkAQBA5ksXtGvc5X/U7bUxSS7OlQxOBAAAYB+7FlKbOnWqIiMjlZGRUdJ5AAAAAAAoN+z6TffixYv1yy+/qE6dOvL391elSrYzEPv37y+RcAAAAAAAlGV2Fd39+vWTyWSSxWIp6TwAAAAAAJQbRSq6s7Oz9dJLL+njjz/WpUuX1L17dy1ZskReXl6OygcAAAAAQJlVpN90z5gxQ7Gxsbr33ns1aNAgffnll3ruuecclQ0AAAAAgDKtSDPdGzdu1KpVqzRw4EBJ0uOPP65OnTrJbDbLmce5AAAAAABgo0hFd3Jysrp06WJ93bZtW7m4uOjPP/+Ur69viYcDANyanJxd1eixCdZ9AACAsqpIRbfZbJabm5vtAC4uys3NLdFQAIBbm5OrmwLCJxodAwAAoNiKVHRbLBY9+eSTcnd3t7ZduHBBI0aMsHls2MaNG0suIQAAAAAAZVSRiu4hQ4bkawsPDy+xMAAASJIlL09nk3+WJN3m21gmpyKt+wkAAFBqFKnoXr16taNyAABgZb54Xtuf6yRJ6rUxSS4elW5wBAAAQOnE1AEAAAAAAA5C0Q0AAAAAgINQdAMAAAAA4CAU3QAAAAAAOAhFNwAAAAAADkLRDQAAAACAgxTpkWEAANwMTs6uavDQ89Z9AACAssrwme6YmBjVr19fHh4eCgkJ0c6dO6/ZNyUlRY899pgCAgLk5OSkcePGFdjvww8/VGBgoNzd3RUYGKiPPvrIQekBAI7g5OqmwKEzFTh0ppxc3YyOAwAAYDdDi+4NGzZo3LhxmjJlig4cOKAuXbqod+/eSkpKKrB/Tk6OatasqSlTpqhly5YF9tmzZ48GDBigwYMH6+DBgxo8eLAeffRRfffdd468FAAAAAAA8jG06F6wYIGGDh2qYcOGqWnTpoqOjpavr6+WL19eYP969epp0aJFeuKJJ+Tp6Vlgn+joaPXo0UORkZFq0qSJIiMj1b17d0VHRzvwSgAAJcmSl6fs40nKPp4kS16e0XEAAADsZljRffHiRcXHxyssLMymPSwsTLt377Z73D179uQbs2fPntcdMycnR1lZWTYbAMA45ovn9fVTwfr6qWCZL543Og4AAIDdDCu609PTZTab5ePjY9Pu4+Oj1NRUu8dNTU0t8phRUVHy9PS0br6+vnafHwAAAACAKwxfSM1kMtm8tlgs+docPWZkZKQyMzOtW3JycrHODwAAAACAZOAjw7y8vOTs7JxvBjotLS3fTHVR1KpVq8hjuru7y93d3e5zAgAAAABQEMNmut3c3BQSEqK4uDib9ri4OHXs2NHucTt06JBvzK1btxZrTAAAAAAA7GHYTLckRUREaPDgwQoNDVWHDh20cuVKJSUlacSIEZIu3/Z97NgxvfPOO9ZjEhISJElnz57ViRMnlJCQIDc3NwUGBkqSxo4dqzvvvFOvvvqq+vbtq08++URffvmldu3addOvDwAAAABwazO06B4wYIBOnjypWbNmKSUlRUFBQdq8ebP8/f0lSSkpKfme2R0cHGzdj4+P19q1a+Xv76/ff/9dktSxY0etX79eU6dO1bRp03THHXdow4YNateu3U27LgAAAAAAJIOLbkkaOXKkRo4cWeB7sbGx+dosFssNx3z44Yf18MMPFzcaAMAgJmcX+d/7tHUfAACgrOJvMgCAUsfZ1V3NR803OgYAAECxGf7IMAAAAAAAyitmugEApY7FYtHFrJOSJLcqNWQymQxOBAAAYB+KbgBAqWPOyVbcoABJUq+NSXLxqGRwIgAAAPtwezkAAAAAAA5C0Q0AAAAAgINwe3kZl5SUpPT0dKNj3BISExONjgAAAACgjKHoLsOSkpIU0LSpLmRnGx3llnIhJ0eeRocAAAAAUCZQdJdh6enpupCdrVYvrVBl38ZGxyn3ju/7Uj+/M1e5ly4ZHQUAAABAGUHRXQ5U9m0sz4YtjY5R7p1N/tnoCAAAAADKGIpuAECpY3J20e33DLTuAwAAlFX8TQYAUOo4u7qrVcQyo2MAAAAUG48MAwAAAADAQZjpBgCUOhaLReacy09mcHavKJPJZHAiAAAA+zDTDQAodcw52frng37654N+1uIbAACgLKLoBgAAAADAQSi6AQAAAABwEIpuAAAAAAAchKIbAAAAAAAHoegGAAAAAMBBKLoBAAAAAHAQntMNACh1TE7Oqt35Aes+AABAWUXRDQAodZzdPBQyebXRMQAAAIqN28sBAAAAAHAQim4AAAAAAByEohsAUOrkXjinz/rU0Gd9aij3wjmj4wAAANiNohsAAAAAAAeh6AYAAAAAwEEougEAAAAAcBCKbgAAAAAAHISiGwAAAAAAB3ExOgAAAICjJSYmGh3hluHl5SU/Pz+jYwBAqUHRDQAodUxOzvJu08O6D9jrQsZxyWRSeHi40VFuGR4VK+pIYiKFNwD8D0U3AKDUcXbzUNuZ642OgXIg91ymZLEoYNQCeQe0MjpOuXcm+WclzB+h9PR0im4A+B+KbgAAUO5VrNtQng1bGh0DAHALYiE1AAAAAAAchKIbAFDq5F44py/6++qL/r7KvXDO6DgAAAB24/ZyAECpZM7JNjoCAABAsTHTDQAAAACAg1B0AwAAAADgIBTdAAAAAAA4CEU3AAAAAAAOQtENAAAAAICDsHo5AKDUMZmcVL15J+s+AABAWUXRDQAodZzdK6jjq5uMjgEAAFBsTB8AAAAAAOAgFN0AAAAAADiI4UV3TEyM6tevLw8PD4WEhGjnzp3X7b99+3aFhITIw8NDDRo00IoVK2zej42NlclkyrdduHDBkZcBAChBuRfOaevAxto6sLFyL5wzOg4AAIDdDC26N2zYoHHjxmnKlCk6cOCAunTpot69eyspKanA/r/99pv69OmjLl266MCBA5o8ebLGjBmjDz/80KZflSpVlJKSYrN5eHjcjEsCAJSQi1kndTHrpNExAAAAisXQhdQWLFigoUOHatiwYZKk6OhobdmyRcuXL1dUVFS+/itWrJCfn5+io6MlSU2bNtW+ffv02muv6aGHHrL2M5lMqlWr1k25BgAAAAAArsWwme6LFy8qPj5eYWFhNu1hYWHavXt3gcfs2bMnX/+ePXtq3759unTpkrXt7Nmz8vf31+2336777rtPBw4cuG6WnJwcZWVl2WwAAAAAABSXYUV3enq6zGazfHx8bNp9fHyUmppa4DGpqakF9s/NzVV6erokqUmTJoqNjdWmTZu0bt06eXh4qFOnTjp69Og1s0RFRcnT09O6+fr6FvPqAAAAAAAoBQupmUwmm9cWiyVf2436/7W9ffv2Cg8PV8uWLdWlSxe99957aty4sZYsWXLNMSMjI5WZmWndkpOT7b0cAAAAAACsDPtNt5eXl5ydnfPNaqelpeWbzb6iVq1aBfZ3cXFRjRo1CjzGyclJbdq0ue5Mt7u7u9zd3Yt4BQAAAAAAXJ9hM91ubm4KCQlRXFycTXtcXJw6duxY4DEdOnTI13/r1q0KDQ2Vq6trgcdYLBYlJCSodu3aJRMcAOBwJpOTPBu1kmejVjKZDL8pCwAAwG6Grl4eERGhwYMHKzQ0VB06dNDKlSuVlJSkESNGSLp82/exY8f0zjvvSJJGjBihpUuXKiIiQsOHD9eePXu0atUqrVu3zjrmzJkz1b59ezVq1EhZWVlavHixEhIStGzZMkOuEQBQdM7uFdRl0VdGxwAAACg2Q4vuAQMG6OTJk5o1a5ZSUlIUFBSkzZs3y9/fX5KUkpJi88zu+vXra/PmzRo/fryWLVumOnXqaPHixTaPCzt9+rSeeeYZpaamytPTU8HBwdqxY4fatm17068PAAAAAHBrM7TolqSRI0dq5MiRBb4XGxubr61r167av3//NcdbuHChFi5cWFLxAAAAAACwGz+UAwCUOuYL2frqyVb66slWMl/INjoOAACA3Qyf6QYA4GoWWXQ+Ldm6DwAAUFYx0w0AAAAAgIMw0w0AAIASlZiYaHSEW4aXl5f8/PyMjgHgOii6AQAAUCIuZByXTCaFh4cbHeWW4VGxoo4kJlJ4A6UYRTcAAABKRO65TMliUcCoBfIOaGV0nHLvTPLPSpg/Qunp6RTdQClG0Q0AAIASVbFuQ3k2bGl0DAAoFSi6AQCljkkm3eYXYN0HAAAoqyi6AQCljrNHRXVbsdvoGAAAAMXGI8MAAAAAAHAQim4AAAAAAByEohsAUOqYL2Rr24iO2jaio8wXso2OAwAAYDd+0w0AKHUssuhs0hHrPgAAQFnFTDcAAAAAAA5C0Q0AAAAAgINQdAMAAAAA4CAU3QAAAAAAOAhFNwAAAAAADsLq5QCAUsckkyp4+1r3AQAAyiqKbgBAqePsUVHdYxOMjgEAAFBs3F4OAAAAAICDUHQDAAAAAOAgFN0AgFLHnHNeO8d2186x3WXOOW90HAAAALvxm24AQKljseQp82iCdR8AAKCsYqYbAAAAAAAHoegGAAAAAMBBKLoBAAAAAHAQim4AAAAAAByEohsAAAAAAAdh9XIAQKnkVqWG0REAAACKjaIbAFDquHhUUtj6n42OAQAAUGzcXg4AAAAAgINQdAMAAAAA4CAU3QCAUsecc167Jz6g3RMfkDnnvNFxAAAA7MZvugEApY7FkqeMH76x7gMAAJRVzHQDAAAAAOAgFN0AAAAAADgIRTcAAAAAAA5C0Q0AAAAAgINQdAMAAAAA4CCsXg4AKJWc3SsaHQEAAKDYKLoBAKWOi0cl9f4o2egYAFAmJCYmGh3hluHl5SU/Pz+jY6CMoegGAAAAyqALGcclk0nh4eFGR7lleFSsqCOJiRTeKBKKbgAAAKAMyj2XKVksChi1QN4BrYyOU+6dSf5ZCfNHKD09naIbRULRDQAodcwXLyh+zpOSpJApsXJ28zA2EACUYhXrNpRnw5ZGxwBwDRTdAIBSx5JnVtreOOs+AABAWUXRDQAAAACFxMJ1N095WbjO8KI7JiZG8+fPV0pKipo1a6bo6Gh16dLlmv23b9+uiIgIHT58WHXq1NGECRM0YsQImz4ffvihpk2bpv/85z+64447NGfOHPXv39/RlwIAAACgnGLhupuvvCxcZ2jRvWHDBo0bN04xMTHq1KmT3njjDfXu3Vs//fRTgR/sb7/9pj59+mj48OF699139c0332jkyJGqWbOmHnroIUnSnj17NGDAAM2ePVv9+/fXRx99pEcffVS7du1Su3btbvYlAgAAACgHWLju5ipPC9cZWnQvWLBAQ4cO1bBhwyRJ0dHR2rJli5YvX66oqKh8/VesWCE/Pz9FR0dLkpo2bap9+/bptddesxbd0dHR6tGjhyIjIyVJkZGR2r59u6Kjo7Vu3bqbc2EAAAAAyiUWrkNRORl14osXLyo+Pl5hYWE27WFhYdq9e3eBx+zZsydf/549e2rfvn26dOnSdftca0wAAAAAABzFsJnu9PR0mc1m+fj42LT7+PgoNTW1wGNSU1ML7J+bm6v09HTVrl37mn2uNaYk5eTkKCcnx/o6MzNTkpSVlVWka7rZzp49K0k6/ctB5Z4/Z3Ca8i8r+agk6cxvP+qks8ngNOUbn/XNVRo/b/PFC9b9jMPflatHhpXGz7s84/O+ufi8by4+75uLz/vmOnvsl8v/e/Zsqa3LruSyWCzX72gxyLFjxyySLLt377Zpf+WVVywBAQEFHtOoUSPL3Llzbdp27dplkWRJSUmxWCwWi6urq2Xt2rU2fd59912Lu7v7NbPMmDHDIomNjY2NjY2NjY2NjY2NrUhbcnLydWtfw2a6vby85OzsnG8GOi0tLd9M9RW1atUqsL+Li4tq1Khx3T7XGlO6/LvviIgI6+u8vDxlZGSoRo0aMplK779iZWVlydfXV8nJyapSpYrRcYASw3cb5Rnfb5RnfL9RnvH9xtUsFovOnDmjOnXqXLefYUW3m5ubQkJCFBcXZ/M4r7i4OPXt27fAYzp06KBPP/3Upm3r1q0KDQ2Vq6urtU9cXJzGjx9v06djx47XzOLu7i53d3ebtqpVqxb1kgxTpUoV/sNHucR3G+UZ32+UZ3y/UZ7x/cZfeXp63rCPoauXR0REaPDgwQoNDVWHDh20cuVKJSUlWZ+7HRkZqWPHjumdd96RJI0YMUJLly5VRESEhg8frj179mjVqlU2q5KPHTtWd955p1599VX17dtXn3zyib788kvt2rXLkGsEAAAAANy6DC26BwwYoJMnT2rWrFlKSUlRUFCQNm/eLH9/f0lSSkqKkpKSrP3r16+vzZs3a/z48Vq2bJnq1KmjxYsXWx8XJkkdO3bU+vXrNXXqVE2bNk133HGHNmzYwDO6AQAAAAA3ncliudFSayitcnJyFBUVpcjIyHy3xwNlGd9tlGd8v1Ge8f1Gecb3G/ai6AYAAAAAwEGcjA4AAAAAAEB5RdENAAAAAICDUHQDAAAAAOAgFN1lVExMjOrXry8PDw+FhIRo586dRkcCii0qKkpt2rRR5cqV5e3trX79+unIkSNGxwJKXFRUlEwmk8aNG2d0FKDEHDt2TOHh4apRo4YqVqyoVq1aKT4+3uhYQLHk5uZq6tSpql+/vipUqKAGDRpo1qxZysvLMzoayhCK7jJow4YNGjdunKZMmaIDBw6oS5cu6t27t83j1YCyaPv27Ro1apS+/fZbxcXFKTc3V2FhYTp37pzR0YASs3fvXq1cuVItWrQwOgpQYk6dOqVOnTrJ1dVVX3zxhX766Se9/vrrqlq1qtHRgGJ59dVXtWLFCi1dulSJiYmaN2+e5s+fryVLlhgdDWUIq5eXQe3atVPr1q21fPlya1vTpk3Vr18/RUVFGZgMKFknTpyQt7e3tm/frjvvvNPoOECxnT17Vq1bt1ZMTIxeeeUVtWrVStHR0UbHAopt0qRJ+uabb7jzDuXOfffdJx8fH61atcra9tBDD6lixYpas2aNgclQljDTXcZcvHhR8fHxCgsLs2kPCwvT7t27DUoFOEZmZqYkqXr16gYnAUrGqFGjdO+99+qee+4xOgpQojZt2qTQ0FA98sgj8vb2VnBwsN58802jYwHF1rlzZ3311Vf6+eefJUkHDx7Url271KdPH4OToSxxMToAiiY9PV1ms1k+Pj427T4+PkpNTTUoFVDyLBaLIiIi1LlzZwUFBRkdByi29evXa//+/dq7d6/RUYAS9+uvv2r58uWKiIjQ5MmT9f3332vMmDFyd3fXE088YXQ8wG4TJ05UZmammjRpImdnZ5nNZs2ZM0eDBg0yOhrKEIruMspkMtm8tlgs+dqAsuz555/XoUOHtGvXLqOjAMWWnJyssWPHauvWrfLw8DA6DlDi8vLyFBoaqrlz50qSgoODdfjwYS1fvpyiG2Xahg0b9O6772rt2rVq1qyZEhISNG7cONWpU0dDhgwxOh7KCIruMsbLy0vOzs75ZrXT0tLyzX4DZdXo0aO1adMm7dixQ7fffrvRcYBii4+PV1pamkJCQqxtZrNZO3bs0NKlS5WTkyNnZ2cDEwLFU7t2bQUGBtq0NW3aVB9++KFBiYCS8dJLL2nSpEkaOHCgJKl58+b6448/FBUVRdGNQuM33WWMm5ubQkJCFBcXZ9MeFxenjh07GpQKKBkWi0XPP/+8Nm7cqK+//lr169c3OhJQIrp3764ffvhBCQkJ1i00NFSPP/64EhISKLhR5nXq1CnfIx5//vln+fv7G5QIKBnZ2dlycrItmZydnXlkGIqEme4yKCIiQoMHD1ZoaKg6dOiglStXKikpSSNGjDA6GlAso0aN0tq1a/XJJ5+ocuXK1js6PD09VaFCBYPTAfarXLlyvrUJKlWqpBo1arBmAcqF8ePHq2PHjpo7d64effRRff/991q5cqVWrlxpdDSgWO6//37NmTNHfn5+atasmQ4cOKAFCxbo6aefNjoayhAeGVZGxcTEaN68eUpJSVFQUJAWLlzII5VQ5l1rXYLVq1frySefvLlhAAfr1q0bjwxDufLZZ58pMjJSR48eVf369RUREaHhw4cbHQsoljNnzmjatGn66KOPlJaWpjp16mjQoEGaPn263NzcjI6HMoKiGwAAAAAAB+E33QAAAAAAOAhFNwAAAAAADkLRDQAAAACAg1B0AwAAAADgIBTdAAAAAAA4CEU3AAAAAAAOQtENAAAAAICDUHQDAAAAAOAgFN0AAOCmiI2NVdWqVYs9zsWLF9WwYUN98803N+z74osvasyYMcU+JwAA9qLoBgAAZcrKlSvl7++vTp06SZLOnDmjxx9/XMHBwWrevLlmz55t7TthwgStXr1av/32m1FxAQC3OIpuAABKKYvFotzc3HztFy9etGs8e48rbZYsWaJhw4ZZX8+dO1fVqlXTgQMH9P333+uTTz7R1q1bJUne3t4KCwvTihUrjIoLALjFUXQDAHCTWCwWzZs3Tw0aNFCFChXUsmVLffDBB9b3t23bJpPJpC1btig0NFTu7u7auXOnunXrpueff14RERHy8vJSjx49JEnbt29X27Zt5e7urtq1a2vSpEk2Rfq1jrva3r171aNHD3l5ecnT01Ndu3bV/v37bfqYTCa99dZb6t+/vypWrKhGjRpp06ZNNn02bdqkRo0aqUKFCrrrrrv097//XSaTSadPn77mZ/Lpp58qJCREHh4eatCggWbOnFngPzRcsX//fv3yyy+69957rW2HDh2yvq5QoYLuvvtuHTx40Pr+Aw88oHXr1l1zTAAAHImiGwCAm2Tq1KlavXq1li9frsOHD2v8+PEKDw/X9u3bbfpNmDBBUVFRSkxMVIsWLSRJf//73+Xi4qJvvvlGb7zxho4dO6Y+ffqoTZs2OnjwoJYvX65Vq1bplVdesRnr6uMKcubMGQ0ZMkQ7d+7Ut99+q0aNGqlPnz46c+aMTb+ZM2fq0Ucf1aFDh9SnTx89/vjjysjIkCT9/vvvevjhh9WvXz8lJCTo2Wef1ZQpU677eWzZskXh4eEaM2aMfvrpJ73xxhuKjY3VnDlzrnnMjh071LhxY1WpUsXa1rx5c33xxReSpAsXLmjbtm3Wz02S2rZtq+TkZP3xxx/XzQMAgENYAACAw509e9bi4eFh2b17t0370KFDLYMGDbJYLBbLv/71L4sky8cff2zTp2vXrpZWrVrZtE2ePNkSEBBgycvLs7YtW7bMctttt1nMZvM1jyuM3NxcS+XKlS2ffvqptU2SZerUqTbXYzKZLF988YXFYrFYJk6caAkKCrIZZ8qUKRZJllOnTlksFotl9erVFk9PT+v7Xbp0scydO9fmmDVr1lhq1659zWxjx4613H333TZtmZmZloEDB1patWplCQoKssyYMSPf+5Is27Ztu+G1AwBQ0lyMLfkBALg1/PTTT7pw4UK+W7wvXryo4OBgm7bQ0NB8x1/dlpiYqA4dOshkMlnbOnXqpLNnz+q///2v/Pz8rjnW1dLS0jR9+nR9/fXXOn78uMxms7Kzs5WUlGTT76+zx5UqVVLlypWVlpYmSTpy5IjatGlj079t27bXPW98fLz27t1rM7NtNpt14cIFZWdnq2LFivmOOX/+vDw8PGzaqlSpct3bxytUqCBJys7Ovm4eAAAcgaIbAICbIC8vT5L0+eefq27dujbvubu727yuVKlSvuOvbrNYLDYF95U2STbtBY11tSeffFInTpxQdHS0/P395e7urg4dOuRbeM3V1dXmtclksl7X9fJcS15enmbOnKkHH3ww33tXF9ZXeHl56YcffrBpe/PNN/X666/btK1du1atW7eWJOst8DVr1rxuHgAAHIGiGwCAmyAwMFDu7u5KSkpS165dS2S8Dz/80KbY3b17typXrpyvqL+RnTt3KiYmRn369JEkJScnKz09vUhjNGnSRJs3b7Zp27dv33WPad26tY4cOaKGDRsW+jzBwcFavny5zXUPHz5cw4cPv+YxP/74o1xdXdWsWbNCnwcAgJJC0Q0AwE1QuXJlvfjiixo/frzy8vLUuXNnZWVlaffu3brttts0ZMiQIo03cuRIRUdHa/To0Xr++ed15MgRzZgxQxEREXJyKto6qQ0bNtSaNWsUGhqqrKwsvfTSS9Zbsgvr2Wef1YIFCzRx4kQNHTpUCQkJio2NlaR8M+BXTJ8+Xffdd598fX31yCOPyMnJSYcOHdIPP/yQb0G4K+666y6dO3dOhw8fVlBQUKGy7dy5U126dCnyNQEAUBJYvRwAgJtk9uzZmj59uqKiotS0aVP17NlTn376qerXr1/kserWravNmzfr+++/V8uWLTVixAgNHTpUU6dOLfJYb7/9tk6dOqXg4GANHjxYY8aMkbe3d5HGqF+/vj744ANt3LhRLVq00PLly62rl199+/wVPXv21Geffaa4uDi1adNG7du314IFC+Tv73/N89SoUUMPPvig/vGPfxQ627p16647Ew4AgCOZLDf6wRUAAIAd5syZoxUrVig5OblEx/3hhx90zz336JdfflHlypWv2/fzzz/XSy+9pEOHDsnFhRv8AAA3HzPdAACgRMTExGjv3r369ddftWbNGs2fP7/It80XRvPmzTVv3jz9/vvvN+x77tw5rV69moIbAGAYZroBAECJGD9+vDZs2KCMjAz5+flp8ODBioyMpOAFANzSKLoBAAAAAHAQbi8HAAAAAMBBKLoBAAAAAHAQim4AAAAAAByEohsAAAAAAAeh6AYAAAAAwEEougEAAAAAcBCKbgAAAAAAHISiGwAAAAAAB6HoBgAAAADAQf4PCGd+cYW0/sMAAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -147,18 +396,35 @@ } ], "source": [ - "fig, axes = plt.subplots(nrows=1, ncols=1, figsize=(10,8))\n", + "# Calculate the 99.9 percentile for each approach to set axes x scale\n", + "percentile_1 = np.percentile(approach_1_estimates.error_angle, 99.9)\n", + "percentile_2 = np.percentile(approach_2_estimates.error_angle, 99.9)\n", + "\n", + "# Find the maximum value between the two percentiles and round up to nearest integer\n", + "max_x_value = np.ceil(max(percentile_1, percentile_2))\n", + "\n", + "fig, axes = plt.subplots(nrows=2, ncols=1, figsize=(10, 8))\n", + "sns.histplot(approach_1_estimates.error_angle, ax=axes[0], color='#e84118', \n", + " stat='probability', binwidth=1, binrange=(0, max_x_value), alpha=.7)\n", + "sns.histplot(approach_2_estimates.error_angle, ax=axes[1], color='#0097e6', \n", + " stat='probability', binwidth=1, binrange=(0, max_x_value), alpha=.7)\n", "\n", - "sns.histplot(df_more_sites.error_angle, ax=axes, color='#e84118', stat='probability', binwidth=1, binrange=(0,20), alpha=.7)\n", - "sns.histplot(df_less_sites.error_angle, ax=axes, color='#0097e6', stat='probability', binwidth=1, binrange=(0,20), alpha=.7)\n", + "for ax in axes:\n", + " ax.set_xlabel(\"error angle (º)\")\n", + "\n", + "for ax, rmse in zip(axes, [approach_1_rmse, approach_2_rmse]):\n", + " ax.axvline(rmse, color='black', linestyle='--')\n", + " ax.annotate(f'RMSE = {rmse:.1f}', (rmse, ax.get_ylim()[1]*0.95), xytext=(10,0), textcoords='offset points', \n", + " verticalalignment='center', fontsize=14)\n", "\n", - "textstr = '\\n'.join((\n", - "r'$RMSE Method 1=%.2f$ (more sites)' % (np.mean(df_more_sites.error_angle**2)**.5, ),\n", - "r'$RMSE Method 2=%.2f$ (less sites)' % (np.mean(df_less_sites.error_angle**2)**.5, )))\n", "props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\n", - "# place a text box in upper left in axes coords\n", - "plt.text(0.65, 0.95, textstr, transform=axes.transAxes, fontsize=14,\n", - " verticalalignment='top', bbox=props);" + "axes[0].text(0.98, 0.95, annotation_text_approach1, \n", + " transform=axes[0].transAxes, fontsize=12, verticalalignment='top', horizontalalignment='right', bbox=props) \n", + "axes[1].text(0.98, 0.95, annotation_text_approach2, \n", + " transform=axes[1].transAxes, fontsize=12, verticalalignment='top', horizontalalignment='right', bbox=props)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" ] } ], @@ -178,7 +444,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.11.5" } }, "nbformat": 4, diff --git a/smpsite/smpsite/__init__.py b/smpsite/smpsite/__init__.py index 39213ef..bf5d26b 100644 --- a/smpsite/smpsite/__init__.py +++ b/smpsite/smpsite/__init__.py @@ -1,12 +1,15 @@ """ Set of tools for the sampling of paleomagnetic data -This includes: - - +This includes the following modules: + - .kappa : Calculation of parameters of the Fisher distribution + - .sampling : Random sampling of paleopoles and samples in the sphere simulating a paleomagnetic study + - .estimate : Estimation of paleopole using Fisher means and secular variation + - .theoretical : Theoretical calculations based on (Sapienza et al 2023) """ __version__ = "1.0.0" -__all__ = ["estimate", "sampling", "kappa"] +__all__ = ["estimate", "sampling", "kappa", "theoretical"] from .kappa import * from .sampling import * diff --git a/smpsite/smpsite/test/__init__.py b/smpsite/smpsite/test/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/smpsite/smpsite/test/data/df1.csv b/smpsite/smpsite/test/data/df1.csv new file mode 100644 index 0000000..9e5b53f --- /dev/null +++ b/smpsite/smpsite/test/data/df1.csv @@ -0,0 +1,51 @@ +,sample_site,vgp_long,vgp_lat,vgp_dec,vgp_inc,is_outlier +0,0,219.13330481569574,81.26082305832416,354.4888357847315,6.351383145022099,0 +1,0,237.74717618213316,66.85382686386579,340.5615969983794,-5.365834506825029,0 +2,0,192.711474408199,79.36339904242857,357.6722343122069,-0.7626174117950171,0 +3,0,213.8387689568436,74.37789364520403,351.3633126291201,-6.064222264978353,0 +4,0,296.98902000463045,33.764886440746494,303.04112738724984,46.64939083492478,1 +5,1,243.73625218829494,80.8214209264816,351.73256176698,11.579164264807307,0 +6,1,280.42933080429617,71.70316874959207,341.54443485371735,24.363500822120454,0 +7,1,230.4788453844742,85.19890481348794,356.2709932758645,13.65521061595589,0 +8,1,99.88502789355302,3.0068304979169693,85.26849628337541,-17.93150862219616,1 +9,1,42.65365480998903,-55.24497456953516,156.34778489033346,29.307049169851197,1 +10,2,97.0615820505266,70.82814024365085,19.175165536777058,14.060894965312187,0 +11,2,147.15478420420132,81.25380937998214,4.735640321296188,5.241455350347652,0 +12,2,90.35617051394006,69.31459011574015,20.9686440176458,17.99287037607214,0 +13,2,113.42608204711446,72.1158741797574,16.383576370522775,5.150531078481537,0 +14,2,101.80817882405739,71.6223862054569,18.071325282625423,11.505708190308939,0 +15,3,353.0213847012938,70.36117170613686,357.31146458524506,48.50518352134069,0 +16,3,335.0080476288843,78.15384411387532,354.6807312774738,37.05397904398577,0 +17,3,46.60452987812272,72.72343355380315,13.412531604297016,38.25370220359266,0 +18,3,29.375970348082237,80.57286770555638,4.8509764905785175,33.28391791296636,0 +19,3,23.857879518844253,81.63842317477004,3.5382304651325285,32.43082978237877,0 +20,4,316.0277772064835,65.65157721762687,341.29984761029846,45.255234669445514,0 +21,4,321.9301858689908,72.85486441186181,348.59059370661134,40.649362033716244,0 +22,4,324.44599781252964,78.11403389373059,352.6977229604082,35.41121301073734,0 +23,4,302.3368540741673,67.68801299542302,339.88436092207087,37.71508838008895,0 +24,4,185.17670049435225,64.8185553372273,357.72133134223714,-28.319900116930505,1 +25,5,305.73802862239955,82.46716442483972,353.6946398805071,27.067849007784137,0 +26,5,341.7332710354796,79.94586521562428,356.6715761188276,35.34736705729971,0 +27,5,2.5295280849800044,85.06155695210555,0.22529452994513122,28.076034919024067,0 +28,5,340.93761183179936,79.877446693818,356.5079284502881,35.37412879771137,0 +29,5,17.53335607461966,78.7659008434254,3.596878182780358,37.06107768699812,0 +30,6,98.18150868669491,70.53883680140027,19.393788984871236,13.261949751897834,0 +31,6,106.08295929096683,71.15006917736781,18.140622923161516,8.688893862038048,0 +32,6,110.2215268740124,74.72384473611093,14.358261587572258,8.873818596469382,0 +33,6,82.15126280150365,75.67391401241669,14.492695455765585,22.36678792694117,0 +34,6,94.04437260375809,77.25476551834072,12.869162067354267,17.318220336626407,0 +35,7,295.5593003361987,79.88829113634073,350.596341884356,26.867056444448803,0 +36,7,286.73501819313776,80.48590716921939,350.6656542353553,24.085935544636758,0 +37,7,288.35052170919556,82.66191410585289,352.8744592476786,23.43623378890866,0 +38,7,280.6295897055199,71.97075496552158,341.82450389258975,24.415669413288366,0 +39,7,262.10537724648555,72.10764200102851,342.14115966523593,13.99844498948782,0 +40,8,352.1100676804693,84.52847864690229,359.22203980719553,28.880840630061492,0 +41,8,309.3510029772657,75.97433802716435,348.5918835633614,34.0220182579263,0 +42,8,10.176222570142908,75.14783920307329,2.854973818110466,42.48164812467167,0 +43,8,321.4106181095484,80.01068167389938,353.47760202801817,32.59724801941754,0 +44,8,318.6204418812604,67.47173232310028,343.5854124274588,44.70338391673065,0 +45,9,60.719855724102786,69.75700713602085,18.642120942541112,34.921027591595205,0 +46,9,77.15890160112627,71.06727789834594,18.994604254919693,25.83282896636268,0 +47,9,341.7104171985521,86.95183748031964,359.01910212067173,24.597833775742476,0 +48,9,72.88337267387455,74.2611694052295,15.512022310014629,26.888210271381755,0 +49,9,249.96946085012448,46.81388689225083,319.722159655811,-11.838709337890075,1 diff --git a/smpsite/smpsite/test/test_estimate.py b/smpsite/smpsite/test/test_estimate.py new file mode 100644 index 0000000..26f7572 --- /dev/null +++ b/smpsite/smpsite/test/test_estimate.py @@ -0,0 +1,54 @@ +import smpsite as smp +import numpy as np +import pandas as pd +from numpy.testing import assert_allclose + +params0 = smp.Params(N=10, + n0=5, + kappa_within_site=100, + site_lat=10, + site_long=0, + outlier_rate=0.10, + secular_method="G", + kappa_secular=None) + +def test_robust_fisher_mean_single(): + _res = smp.robust_fisher_mean([10.0], [20.0]) + assert _res['vgp_dec'] == 10.0 + assert _res['vgp_inc'] == 20.0 + assert _res['n_samples'] == 1 + assert _res['resultant_length'] == 1.0 + +def test_robust_fisher_mean_multiple(): + _res = smp.robust_fisher_mean([10.0, 20.0], [0.0, 0.0]) + assert_allclose(_res['vgp_dec'], 15.0, 1e-6) + +def test_estimate(): + + # Read sample data created with these params + df = pd.read_csv('./smpsite/smpsite/test/data/df1.csv') + + _res = smp.estimate_pole(df, params0, ignore_outliers="True") + + assert_allclose(_res['pole_dec'], 350.20065867362314) + assert_allclose(_res['pole_inc'], 86.75081527833235) + assert_allclose(_res['S2_vgp'], 182.60923786776738) + + _res = smp.estimate_pole(df, params0, ignore_outliers="False") + + assert_allclose(_res['pole_dec'], 18.215514011721595) + assert_allclose(_res['pole_inc'], 86.81743210088786) + assert_allclose(_res['S2_vgp'], 99.71484820447859) + + _res = smp.estimate_pole(df, params0, ignore_outliers="vandamme") + + assert_allclose(_res['pole_dec'], 18.215514011721595) + assert_allclose(_res['pole_inc'], 86.81743210088786) + assert_allclose(_res['S2_vgp'], 99.71484820447859) + + +def test_simulate(): + _df = smp.simulate_estimations(params0, n_iters=10, ignore_outliers="True", seed=666) + assert _df.shape == (10,17) + for col in ['plong', 'plat', 'S2_vgp', 'error_angle']: + assert col in _df.columns \ No newline at end of file diff --git a/smpsite/smpsite/test/test_execution.py b/smpsite/smpsite/test/test_execution.py new file mode 100644 index 0000000..0e3198c --- /dev/null +++ b/smpsite/smpsite/test/test_execution.py @@ -0,0 +1,26 @@ +import numpy as np +from numpy.testing import assert_allclose +import smpsite as smp + +def test_run_kappa_from_latitude(): + _res = smp.kappa_from_latitude(10.0, degrees=True) + assert isinstance(_res, np.ndarray) + assert _res.shape == () + +def test_kappa_from_latitude(): + _degs = [10, 50, 80] + _res = [49.5176626866052, 21.698350477271674, 11.416853315971776] + for i, _deg in enumerate(_degs): + kappa1 = float(smp.kappa_from_latitude(_deg, degrees = True)) + kappa2 = float(smp.kappa_from_latitude(_deg/180.0*np.pi, degrees = False)) + assert_allclose(kappa1, kappa2, rtol=1e-6) + assert_allclose(kappa1, _res[i], rtol=1e-6) + +def test_kappa_from_latitude_power(): + kappa = float(smp.kappa_from_latitude(10.00, degrees = True, inversion="power-law")) + assert_allclose(kappa, 21.282720785612874, rtol=1e-6) + +def test_run_lat_correction(): + _res = smp.lat_correction(30.0, degrees=True) + assert_allclose(_res, 1.2578124999999998, atol=1e-6) + diff --git a/smpsite/smpsite/test/test_sampling.py b/smpsite/smpsite/test/test_sampling.py new file mode 100644 index 0000000..8dcf942 --- /dev/null +++ b/smpsite/smpsite/test/test_sampling.py @@ -0,0 +1,27 @@ +import smpsite as smp +import numpy as np +import pandas as pd +from numpy.testing import assert_allclose + +params0 = smp.Params(N=10, + n0=5, + kappa_within_site=100, + site_lat=10, + site_long=0, + outlier_rate=0.10, + secular_method="G", + kappa_secular=None) + +def test_params_read(): + assert params0.N == 10 and params0.site_lat == 10 + +def test_desing(): + assert np.array_equal(smp.generate_design(params0), [5, 5, 5, 5, 5, 5, 5, 5, 5, 5]) + +def test_sample(): + _df = smp.generate_samples(params0) + assert isinstance(_df, pd.DataFrame) + assert _df.shape == (50,6) + for col in ['sample_site', 'vgp_long', 'vgp_lat', 'vgp_dec', 'vgp_inc', 'is_outlier']: + assert col in _df.columns + diff --git a/smpsite/smpsite/test/test_theoretical.py b/smpsite/smpsite/test/test_theoretical.py new file mode 100644 index 0000000..e78518f --- /dev/null +++ b/smpsite/smpsite/test/test_theoretical.py @@ -0,0 +1,14 @@ +import smpsite as smp +from numpy.testing import assert_allclose + +params0 = smp.Params(N=10, + n0=5, + kappa_within_site=100, + site_lat=10, + site_long=0, + outlier_rate=0.10, + secular_method="G", + kappa_secular=None) + +def test_kappa_theoretical(): + assert_allclose(smp.kappa_theoretical(params0), 259.0223874154575) \ No newline at end of file