From 87e0af055b4c1fd2d291ff9cf85a11e2d098215f Mon Sep 17 00:00:00 2001 From: SamDuffield <34280297+SamDuffield@users.noreply.github.com> Date: Tue, 13 Aug 2024 15:56:20 +0200 Subject: [PATCH] Add notebook with Pyro model (#111) * Add notebook demo with pyro * Fix pyro README render * Refix README render * Rerefix README render * README title * Update READMEs * Fix links in README * Update docs * Add pyro convergence diagnostics to examples * Add link to diagnostics * Describe marginals * Update examples/pyro_pima_indians_sghmc.ipynb Co-authored-by: KaelanDt * Update docs/tutorials/index.md Co-authored-by: KaelanDt * Add explainer to notebook --------- Co-authored-by: KaelanDt --- README.md | 2 +- docs/tutorials/index.md | 6 + examples/README.md | 6 +- examples/pyro_pima_indians/README.md | 5 +- examples/pyro_pima_indians_sghmc.ipynb | 504 +++++++++++++++++++++++++ 5 files changed, 520 insertions(+), 3 deletions(-) create mode 100644 examples/pyro_pima_indians_sghmc.ipynb diff --git a/README.md b/README.md index 4424e0f9..257f7a66 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ General purpose python library for uncertainty quantification with [`PyTorch`](https://github.com/pytorch/pytorch). -- [x] **Composable**: Use with [`transformers`](https://huggingface.co/docs/transformers/en/index), [`lightning`](https://lightning.ai/), [`torchopt`](https://github.com/metaopt/torchopt), [`torch.distributions`](https://pytorch.org/docs/stable/distributions.html) and more! +- [x] **Composable**: Use with [`transformers`](https://huggingface.co/docs/transformers/en/index), [`lightning`](https://lightning.ai/), [`torchopt`](https://github.com/metaopt/torchopt), [`torch.distributions`](https://pytorch.org/docs/stable/distributions.html), [`pyro`](https://pyro.ai/) and more! - [x] **Extensible**: Add new methods! Add new models! - [x] **Functional**: Easier to test, closer to mathematics! - [x] **Scalable**: Big model? Big data? No problem! diff --git a/docs/tutorials/index.md b/docs/tutorials/index.md index 877e7719..e4d89e16 100644 --- a/docs/tutorials/index.md +++ b/docs/tutorials/index.md @@ -51,3 +51,9 @@ data, with some interesting takeaways. [Variational continual learning](https://arxiv.org/abs/1710.10628) notebook for a simple regression task that's easy to visualize. + +[](https://github.com/normal-computing/posteriors/blob/main/examples/pyro_pima_indians_vi.ipynb) + +- [`pyro_pima_indians_sghmc`](https://github.com/normal-computing/posteriors/blob/main/examples/pyro_pima_indians_sghmc.ipynb): +An accessible notebook demonstrating the use of `posteriors` with a [`pyro`](https://pyro.ai)-defined Bayesian logistic regression model, as well as convergence diagnostics from [`pyro`](https://pyro.ai). + diff --git a/examples/README.md b/examples/README.md index 099825c0..a58b0d9b 100644 --- a/examples/README.md +++ b/examples/README.md @@ -9,9 +9,10 @@ on a series of books from the [pg19](https://huggingface.co/datasets/pg19) datas - [`imdb`](imdb/): Investigates [cold posterior effect](https://proceedings.mlr.press/v119/wenzel20a/wenzel20a.pdf) for a range of approximate Bayesian methods on [IMDB](https://www.tensorflow.org/api_docs/python/tf/keras/datasets/imdb/load_data) data. -- ['pyro_pima_indians`](pyro_pima_indians/): Uses `pyro` to define a Bayesian logistic +- [`pyro_pima_indians`](pyro_pima_indians/): Uses `pyro` to define a Bayesian logistic regression model for the [Pima Indians Diabetes Database](https://www.kaggle.com/uciml/pima-indians-diabetes-database). Compares `posteriors` methods against `pyro` and `blackjax`. +See [`pyro_pima_indians_vi.ipynb`](pyro_pima_indians_vi.ipynb) for a more accessible lightweight notebook. - [`yelp`](yelp/): Compares a host of `posteriors` methods (highlighting the easy exchangeability) on a sentiment analysis task adapted from the [Hugging Face tutorial](https://huggingface.co/docs/transformers/training#train-in-native-pytorch). - [`continual_regression`](continual_regression.ipynb): [Variational continual learning](https://arxiv.org/abs/1710.10628) @@ -23,6 +24,9 @@ to infer the skills of Premier League football teams. - [`lightning_autoencoder.py`](lightning_autoencoder.py): Easily adapt the autoencoder example from the [Lightning tutorial](https://lightning.ai/docs/pytorch/stable/starter/introduction.html) to use UQ methods with `posteriors` and logging + device handling with `lightning`. +- [`pyro_pima_indians_sghmc.ipynb`](pyro_pima_indians_sghmc.ipynb): A more accessible +notebook demonstrating the use of `posteriors` with a `pyro` defined Bayesian logistic regression model. +As well as convergence diagnostics from `pyro`. Further information is available within the specific example directories or files. diff --git a/examples/pyro_pima_indians/README.md b/examples/pyro_pima_indians/README.md index 4e752477..50664903 100644 --- a/examples/pyro_pima_indians/README.md +++ b/examples/pyro_pima_indians/README.md @@ -1,10 +1,13 @@ -# Using `posteriors` with `pyro` +# Using `posteriors` with `pyro` on the Pima Indians Dataset In this example, we show how to use `posteriors` with [`pyro`](https://pyro.ai/) to define a Bayesian logistic regression model for the [Pima Indians Diabetes Database](https://www.kaggle.com/uciml/pima-indians-diabetes-database). The model can then be used to automatically generate a `log_posterior` function that can be directly passed to `posteriors`. This specific model is small with 8 dimensions and 768 data points. +The code in this folder involves running over multiple seeds and collecting time and KSD metrics. +A more accessible notebook demonstrating the use of `posteriors` with `pyro` can be found in [examples/pyro_pima_indians_sghmc.ipynb](../pyro_pima_indians_sghmc.ipynb). + ## Results diff --git a/examples/pyro_pima_indians_sghmc.ipynb b/examples/pyro_pima_indians_sghmc.ipynb new file mode 100644 index 00000000..ed4fff49 --- /dev/null +++ b/examples/pyro_pima_indians_sghmc.ipynb @@ -0,0 +1,504 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch\n", + "import pandas as pd\n", + "import pyro\n", + "import pyro.distributions as dist\n", + "import posteriors\n", + "from tqdm import tqdm\n", + "import matplotlib.pyplot as plt\n", + "\n", + "torch.manual_seed(42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Building Bayesian models with `pyro` and `posteriors`\n", + "\n", + "In this notebook we'll use the probabilistic programming language `pyro` to define a Bayesian logistic regression model, then as [`pyro`](https://pyro.ai) is built on PyTorch we can convert the model into a log posterior function which can be used directly with `posteriors` for inference!\n", + "\n", + "We'll also use the convergence diagnostics from `pyro` to check the convergence of the sampler (further demonstrating the ease of composability between the two libraries)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load the data\n", + "\n", + "First up, let's load the Pima Indians dataset, which consists of 768 samples of 8 feature variables and a binary target variable (class)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(768, 9)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
num_pregnantglucose_concentrationblood_pressureskin_thicknessserum_insulinbmidiabetes_pedigreeageclass
061487235033.60.627501
11856629026.60.351310
28183640023.30.672321
318966239428.10.167210
40137403516843.12.288331
\n", + "
" + ], + "text/plain": [ + " num_pregnant glucose_concentration blood_pressure skin_thickness \\\n", + "0 6 148 72 35 \n", + "1 1 85 66 29 \n", + "2 8 183 64 0 \n", + "3 1 89 66 23 \n", + "4 0 137 40 35 \n", + "\n", + " serum_insulin bmi diabetes_pedigree age class \n", + "0 0 33.6 0.627 50 1 \n", + "1 0 26.6 0.351 31 0 \n", + "2 0 23.3 0.672 32 1 \n", + "3 94 28.1 0.167 21 0 \n", + "4 168 43.1 2.288 33 1 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load the Pima Indians Diabetes dataset\n", + "data_url = \"https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv\"\n", + "column_names = [\n", + " \"num_pregnant\",\n", + " \"glucose_concentration\",\n", + " \"blood_pressure\",\n", + " \"skin_thickness\",\n", + " \"serum_insulin\",\n", + " \"bmi\",\n", + " \"diabetes_pedigree\",\n", + " \"age\",\n", + " \"class\",\n", + "]\n", + "data = pd.read_csv(data_url, header=None, names=column_names)\n", + "\n", + "print(data.shape)\n", + "\n", + "data.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we'll normalise the features and load it into PyTorch tensors." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Preprocess the data\n", + "X_all = data.drop(columns=[\"class\"]).values\n", + "y_all = data[\"class\"].values\n", + "\n", + "# Normalize the data\n", + "X_mean = X_all.mean(axis=0)\n", + "X_std = X_all.std(axis=0)\n", + "X_all = (X_all - X_mean) / X_std\n", + "\n", + "# Convert to torch tensors\n", + "X_all = torch.tensor(X_all, dtype=torch.float)\n", + "y_all = torch.tensor(y_all, dtype=torch.float)\n", + "\n", + "num_data, dim = X_all.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Define the model\n", + "\n", + "We'll use a simple Bayesian logistic model $p(y = 1 | x) = \\text{sigmoid}(x^T w)$, where $w \\in \\mathbb{R}^8$ is the weight vector and $x \\in \\mathbb{R}^8$ is vector containing the normalised features.\n", + "\n", + "We'll use a normal prior on the weights $w \\sim \\mathcal{N}(0, 1)$ (note the rescaling to ensure normalization in the case of minibatching).\n", + "\n", + "We'll use standard Pyro code to define the model." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def model(batch):\n", + " X, y = batch\n", + "\n", + " batchsize = X.shape[0]\n", + "\n", + " # Define the priors\n", + " w = pyro.sample(\n", + " \"w\",\n", + " dist.Normal(torch.zeros(X.shape[1]), scale=(num_data / batchsize) ** 0.5),\n", + " ) # Scale to ensure the prior variance is 1 for all batch sizes\n", + "\n", + " # Define the logistic regression model\n", + " logits = torch.matmul(X, w)\n", + " y_pred = torch.sigmoid(logits)\n", + "\n", + " return pyro.sample(\"obs\", dist.Bernoulli(y_pred), obs=y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we can use `pyro.poutine` to convert the model into a log posterior function that can be passed to `posteriors`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def log_posterior_normalized(params, batch):\n", + " X, y = batch\n", + " batchsize = X.shape[0]\n", + " conditioned_model = pyro.condition(model, data={\"w\": params})\n", + " model_trace = pyro.poutine.trace(conditioned_model).get_trace((X, y))\n", + " log_joint = model_trace.log_prob_sum()\n", + " return log_joint / batchsize, torch.tensor([])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recall that `posteriors` recommends [log posteriors to be normalized by batchsize](https://normal-computing.github.io/posteriors/log_posteriors/) and return a tuple with [optional auxiliary information](https://normal-computing.github.io/posteriors/gotchas/#auxiliary-information)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SGHMC with `posteriors` and convergence diagnostics with `pyro` \n", + "\n", + "Now let's use `posteriors` to perform HMC sampling with the above data and model.\n", + "\n", + "We'll use the [`pyro` diagnostics](https://docs.pyro.ai/en/stable/ops.html) to examine convergence." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "N_warmup = 2000\n", + "N_samples = 6000\n", + "N_steps = N_warmup + N_samples\n", + "initial_params = torch.zeros(X_all.shape[1])\n", + "num_chains = 5" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "transform = posteriors.sgmcmc.sghmc.build(\n", + " log_posterior_normalized,\n", + " lr=1e-2,\n", + " temperature=1 / num_data,\n", + " alpha=1.0,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "states = [transform.init(initial_params) for _ in range(num_chains)]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 8000/8000 [00:22<00:00, 350.54it/s]\n" + ] + } + ], + "source": [ + "log_posts = torch.zeros((num_chains, N_steps))\n", + "samples = torch.zeros((num_chains, N_steps, dim))\n", + "gelman_rubin = torch.zeros(N_samples)\n", + "\n", + "for i in tqdm(range(N_steps)):\n", + " states = [transform.update(state, (X_all, y_all)) for state in states]\n", + " log_posts[:, i] = torch.stack([state.log_posterior for state in states])\n", + " samples[:, i] = torch.stack([state.params for state in states])\n", + " if i > N_warmup:\n", + " j = i - N_warmup\n", + " gelman_rubin[j] = pyro.ops.stats.gelman_rubin(log_posts[:, N_warmup:i + 1])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Check convergence and plot marginals\n", + "\n", + "Now let's examine our results!\n", + "\n", + "First we'll look at the log posterior values" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGdCAYAAADaPpOnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB56UlEQVR4nO39eZxcV3ng/3/uXnvvi1r7Zsn7biNDAonNZgYIYVgymgQTAlnwBAgD2N+EkGQmcSbDLIHJkMkkAfKLiQcygQEHTIxtbGyMZRvvlmVL1i61Wr3Wftfz++N2VXdLaqmrulutaj3v1+u+6qrq3qpzu1pVTz/nOedoSimFEEIIIUSL0Je6AUIIIYQQjZDgRQghhBAtRYIXIYQQQrQUCV6EEEII0VIkeBFCCCFES5HgRQghhBAtRYIXIYQQQrQUCV6EEEII0VLMpW7AQouiiCNHjpDNZtE0bambI4QQQog5UEpRKBQYGBhA10+fW1l2wcuRI0dYvXr1UjdDCCGEEE04ePAgq1atOu0xyy54yWazQHzxuVxuiVsjzimlEgwMxPtHjkA6vbTtEUIIUZfP51m9enX9e/x0ll3wUusqyuVyEryImQxjaj+Xk+BFCCHOQXMp+ZCCXSGEEEK0lGWXeRFiVqYJH/jA1L4QQoiWJJ/g4vzhOPCVryx1K4QQQsyTdBsJIYQQoqVI5kWcP5SCcjneT6VA5gESQoiWJJkXcf4olyGTibdaECOEEKLlSPAihBBCiJYiwYsQQgghWooEL0IIIYRoKRK8CCGEEKKlSPAihBBCiJYiwYsQQgghWorM8yKWhcjzCEdGiCpV0EBPpdHTKfRUCk2fjNENA/71v57aP0dEkaJa9Am8kDCIgHhhMithkEhZGJb8jbEQKkGFkcoI5aCMH/r4kY9jODimQ8JI4BgOCTNBwkhg6Kf//VBhSFQsEhYKKM9DBQGEISqMIAxQYQhhiGbb8e9gMoWeSqInk2iJxJwWnhOzU0oR+hFKgWFq6MYc/o8EHnhF0HTQTbBSoJ+f/7fCKGTcHWesOoYbugQqwNRMcnaOnlQPCTOx1E08IwleREtQURR/WYyOEoyNERVLRKXaViScyJ/6RE1DM/R4QjpNR73xTSjDgrv+L5oRBwlGwsHIpLEGBrA3bMDIZIjCiMCPUJFCRYAGhqlj2vq8vnh8L6SS9yjnPcoTHuWCR6XgoSI16zm6qWNaOrqhoxsahqlhOSZ2wsBJWSQyJul2B9MyUEqB7xO5bvxlqlQ8Od9km5Xno9wqUbUKYQi6Ef98dAM9ncbs6Z4K9hZBxQsZKlQpeyHhtGt2gwgviFBKYegahq6h6xqmrpG0DLIJi2zCJGUbuOWA0rhLpeBRKfoEXgQo1OTT2UkTLR1QcQoU9DFGgxGGK8OU/NKs7VIKiDTwdDTfIGkkSTtp0naKNjtDe7lK20iRdCmEfIGwUIDTvGc1oQrxQ5+ICA0NTdMwnSTJ3hXonZ1oHd1Y3V04vV1otn3y+VHIUHmIg4WDHMofYKw6gq4Ujp0lZafJ2Tn6Un30pfvoSnTFJ/l+/X2vehWGJ44wOnKY8dEjVPNjUKlgVnysiodd8UhoFolUhkSmC8tJE4UBUegTBD5hffMIwwClgWk7mJaDaSewE2mcTBtOtg0n246RyaCn0/GWSqFN+yMhCCNKbgjEMYNl6Djmyf+f/NBnpBoHmVEUoVREm5HEzFsUjvsUxlyqpYDIrYBfBq+CoXlYRohpRlhWRDIRkkqGpJIBjh2iuXlwCzN/uJoGiTbIDUBuJWT7wU7HvwyBC24eKmNQHo1v/TL1XzJNA8MCwybSLSq6RokIF4WjGSTQSaJhKoWmIgh9iIKpTUVg2HEAZSXiWzMx9W87DU4uPkY3YXowXWsDk7cnPj7L79Cx8jGGK8OMVEYYc8eIVHTK4zU0upJdDGQGGMgM0JvsJW2l0TQNpRRe5FENqoQqpDPROevrLjZNKXXm/4EtJJ/P09bWxsTEBLlcbqmbI+ZAKUVUKhMOHyc4Hm9hoYjy/XjzPJTvT/tPG++GSiOMdEKlESmt/tetiiCqVgnKVcJQI4g0QqVT8U2qgYni5OBD1xSGFqE0DS3Xjt7Vg9HeftIXuWkbZDocMh0OqTaHdJuD5cz84FCRwi0HVMs+XiWgWvKpFn3KeQ+vEpx87cUiFCcwAhfTNkCDKATfjwh8YPIDnEhBFIHGZNBhxBmkMET5LkmqpLUSaaNC0gxmTCCsULhB/BeWUopIRYQqjIM3zUDXdEzdxHZSJFatxlq5CquvF6O7G91xzvj+lbyQqh8SKUUUEd8qRRAqRsseQ/kqRyeqjJf9GecFqoqvqkTKR9csLC2BqZ2QmVAKKiFaIcAoBTgh2KaOYxo4pk7S0tEMn2pYoOgXKfpFvMDHC0KCICQwPDynimeVsE1FFptMaJIKFLofEQUmQagTKI1AI/7LXGlYJR+rWMUqemgKdM3F1KokzJCElcZ0OjBTOTTbAAM0MyC0KoRmGdeoUg2r+NUKhutjVH30akhUTeCHbUSqA50khm6io6HrEVYa7GwFh+MY/iglSoxRxjNCQgtCizgYjxSGF2GEOkZgoIcGRqDjhCbpKIFhOERKUQlc3MBFVyG6CkEF8S9WFEAYQOTN+D8V0+IvQsMG0wHDib+kNS1+7DR0TSNhJEiaKZJmDp00FSvFhJFk3EqRdzK4uXa8TBuRHf9OWYZGxjHJJiwwigx7rzDkvorpj+H44zh+EcaSMNqL5iXJ6hYdeoIOw8HS5hZk65oilfDJpD2y2ZB00sM2/FNc++wipRiPXMYil9GwyljkMh665CMPT4WznmdrBjndpt1waNNt2vTarU1SM8/4h5BSCsKIyA9RXkgUhCgvQEUKPWFhph20hI2WbCdKtFNMpCmme8hbbUwEBY4WjnLMPUZIcNJzW7pFZ6KTlJXC0Az8yGfcHWfCnTihDWDjYEcJqlWXIAxBKToTOX7p+vfP+Wc4F418f0vwIhaECoJ4q8Z/1UeVCqpSISwUCcdGicoVNCdOoevJFKiIsFAgHB8nHBtHed7M51NQ9k3KvoUbmgSRToCBclKoRAplOGi2hWZZcWo+kUCzrBOeQ0EQTGUfJjcVRXEQMPmrr4IA5bpxWwrF+vmaaWD1dGP39qCl0kThqf9SsZMmhqmj6RqBG+BXPRSn/ktIAbYW4IQlrOJxjNEjOGEZS49OuVpBGGkEkU40GaBFCiKl40c6QaTjhQZuYOCGZv0VIqVACzCtPKZ9nECNU/KL8V+xlkFomUS2iTJ1iCK0SKGFEVahinJ9wEBTJmBCZFBxEuTTadxclrCzHTo6MDJZTNMhDOFYoUzZrxAoD19VCZULSsMMLWzPwYhMQjMkNCNCM8C2A3TDxYvKRMQf/IYWZ1s0TYvP1RI4lSRmIYU+YUPVIIhU/F5qECQiIlsR2gFVdRgVjGMoF0sFWK6OXXVIeykSYYoEBg4GDnGgcCIN0DUmMz0RWn6ccKxAEEaEaASajm9YlFM6vq0RWjqRpYGlY5g2uumAaYNuTS05YUbghOD4mIDuK8K8jvJB8wJ0bzIA8SIMN0D3PIh8UHFXiK5VsdRREtphHF2RM2xymo2tDPwwwlcRnopwVUgZn7IKCFU0+fsBIQYKFQcuhoFtOySTCVKJBHbKwcnaOBkLN6FR1CIKrku5WsaPQnTdmMx+6ViGiaXpmKaJZSXQdBtX6fiaiYtO4PmElQph1ccvuAT5CqpQxqq66EqRwCaFHb8HCiwiDBUSGSae6VC2TAqmYtTwyVsBgaOh7ApawsJQq7DdARwSRIYiNHzIjEOqgOZUWZnJsiK7kmxqBZqeI/BNVGhghAki1ySf9ykWA/KuR94P8TGJNBs/9PGMClWnQNU4jqcPYqhROlRAh2aQNWzSZorISlGwTPKmomhERIZJpECL4sxRytYwVIhe9bAqLmkfLHQ8TeESEakITcW/zxpx5lcPIsyKj1kJsLyQbFWRCiARQNI0SRgGKXTMwIdqicj1TvqjLYgUQRQRKkVJ+YwbIceyWY4n2wiNDowgF///NRNgJsGwMS2DbDJFNpsjnWkjk2knk8xiWDqGoYNGPctc8auMlEYYLYwzVpygUq2iQi3+9Ap98MvofoV01uJXPvxbp/yca5YELxK8LCoVRQRDQ/gHD+IfPUowPEJUmj0lXz9PgR/VMiAWXqhjGxEJMyBhBdidOfxMD0WjnXzFJgg1MHQ0YzLLYJ78l4ph6RimXg8eYNr3h6VjWAamrWPaBkndo+uC/rgthQIqlUZFiiiK+89DPyIq5PFf3U2wexeUilPP1duLvXUrUd9aSmUojbuUJlyqxclMQhTAxCHIHwUVousaTtrCzqRIZBIYrodRLmKMT6AF/oxr0BIO9pq1mL09RJ7PaMlltFLFUx6mDZodEhk+FeUSagpF3DWE54Mf4OkhJc2g6FqUKyZhJYGKpgVPWR96qpidIUk7gamb6JpB2VWMll1GimUKrkvRK5PIF2kfK9I2ViJdrJKozgwq6++lpuEmLEJdR48UytAInAyh1oUiS2RmCMwEgW1iGjqWqWMbOnZKofd40F1Fc+KulKSZxAxs3DGFmw9RZQPKZtyNEwUQVCEsgXOcMDFCkCriGzpBGKK8Mn4YEYXQqRL0qhQdJGjDJmNbJCybSOXw/SRekCEgSagbeKZB0bAZ1RIEuoauByTHjtK16znsUh5dBUSOTaV/gGpPN1EqiapG+F5A2XMJolEqWp6QEAMDxzRJqwwZlcUKk1gYOJoBEXhehBfGv2eWFZJOlyAzRsmcoISHF0JQ0mHcQhXbcOkh0BLoOJiaScIKSNll8AJCQGkmytLRTYVhBJhmgKFVcfUJMPJEuo+u6SQ0k3bNRukJqkYGz8jgmhlcM4trZIjSvWxYs4ZLV7XTkbYnv5gqUB2H/JH493niUHzfKYSRYqLiM1ryGC5XKUY+RXyGtQrHKRKGPilfkfIiUtWIRDkkUQowq3HAqiY/EyKlJv+uUGSwSaheClxAWW/HMxJEpoWZUfRvTJBaY3LIyXNcL6G0+D97ZBooQ0cLIwwvQAsjgrTDSDXgyFiFSgFs18auOjhVB9M1sfwQyw/roWxgVgnsCoFVIjLKeI6O61goXSNVdsnkK7RNVMlUDFK+iUEC00jSnXZYmUvSmU7EAUrt/wdxdtMLPaphFTdwccMq1dDFDap4ocfpvngNzcDSkhgk0ZWDUg75SDGOR9lwqUQeWhlsNwUqA+hoKkJXEZYKMTUw0LAwMHUbjDS65WCZJpZlYmja5Odl/MeAZujomQxGVw96pg3NceqftZFboFochOpxklSwNR1LByehsfnf/AoYC1d9IsGLBC+LIiqXqTz3PNXnnyeaZW2gKg75KIuvJ9BsGzOZQEul8JRNteQTVDxU4KNpGpptozlOXMToOCd10RiWTq47SbrNwUmZGFZc+2FaBoatY04LWOptjBS6rhFGCj+M8MIIP4jwQ0WQL7BqTS8ADz75KuO6jR/GnUi6Hqe9dU3DNnU6Eiarq6Ok9u/G27cPpmVdjK5OkhddROLiiwndCpVXnyU69DQq8DANhWWGWLpPWKjgHhmnemgU5U9LLdtJzP6V2Jsvxb7kesL+VewfLfPk4b08M7ST49XD+NHMLwxNA9vQcSydhGmQtA3akhYp2zgpoFMKnGqazFg31kQWS0vg+xZ+aOIlDSq2RsXRUCcUAiulUJqPZXnYlo9peVhhkVy5RLpUwBjLo0bGUGMThEFApEI0TWEZKcJoBW7Yhq7p6JPpfEWEYQRoNoTKIsJCaQaGYWFaJpm0RSabxteTeDhojgO2je+O45eOg3ccRxvEsSYwzDGMMA4Ko6RJlDCITJ0I6LJzrGzfAMleXCtL6BoYw3mifIUwX4p/IIaO2dmFtaIfs38FZncXmhHXCBUKZfIP/YjKCy/Gvw/pFKkbbiB5wQUoTaPkBhTdAC+If5+CUFH1Q8Ym8lRGD5OqDpH2juOERQzlk7YtdOVQLkcUygahbhGaNkEygUoYGARYUQUrrGBFVTQVUra7GE2uZzyxmggDoxRgjfpElYAwUijbIBpIYOdserMOuaSFqWto2lRJU9IyydgGGa1MjhLZhIWd7SIwUhTckImKT77qM1x0eeVYkbI39Tu5ujPFZava2NiTwZj+f0opCL04gPSr5At5Xj08yMjwEOX8KFoUoKsAI3KxLYue9gx9PX10dfdSUC4HKsc5Uh1hxC8yEVZRmoEWahgVF92tkA6hIzJZpaXpqaY5fizDaD5NFGpoQRWLCYqVUdwgbqsGdKRt2lIKjAplv4QbuvXmhiqi6nscL1WYMB38TBthKktHWxspw8AuTJAZK6H7GSKyRGRQykFDw48CvDAgiEIi5QIhhqajYxBFCRQ2uqbVA65gsuZJQ2EnTdJpi2xKozMFHSlFwo7QTWOyQHgyq2iaGLkcZFJUTEXRDJnQPfYXxjg6PsxIfpSJSp5qGOGbBoFp4JsGkRF3ZSbLKbKFDGk3iaaBhUlbYJH1IRtUwa0QRSVS0TjpYJi0Pxp/Lioj/j8Y6uBHGJqOYZig6YSTWWJTU1iGhm1omJaBlbRwLA8nrUi0WVi5uIuKzCqi7Bq0znXYGy9gIUnwIsHLglFKEQwOUn3xRdyXX0bVPkQcB3vVSqxVq6Cjm4mKzfDRCuW8f9rn03SNZNYm3WbjpC3cckB5wqWcj4tWrYRJe2+Sjv40ue7EnEYRVP2QF45M8NyhCcbKPrqmxV0nJzArZf7dO68E4Iv/7ymCZOqMz22bOlnl037kVbJ7nsUeH0IPXMyoimEp7C4dwzHQFIRRkorWT7WiYXgVjNDFjFwIKihToXeYJNoNzM40lhV/YIx5Po9EIbuNiAkzRaA7mJN1AKZmE4YWUWhhkMbRU+hY8V9KCszIJWME9OVy9KbT9GezdNo2juYQRjAcOLw8pDi6Lw/jPpo/s9vLTFl0D6RZvS7HqhUZ2lI2GdtEPyEgrItCiEKUZhCWy0zsH+H4kTLjI/HoGuX7ZBMB2YSPXR7BHD2AVinEBYWGTWTYFNwEY9UERW9mcapGRDIcJeUfJRGOkaCEQyX+wHcykOyMiytNO25H4KLZNkZ3P0ZnXxx4eR5RqUQ4Pn7G91WzTMzePjTLwh88iqq6oGkkL72E1Gtec8Y6n5owUhzLV9k7XGLvcInjBXfG44ausaEnzYbuDNmESdkLKboBbhDiTNbtJKy4didhGfXg1DLi92DkcJFXnxuhWokD/hVrc6zY2Ea6bW7tm00UKfaOlHju0AT7Rkr1nomUbbChJ0N/LkFfzsE2dZSCohvw/OEJdh0rzCgVySUtNvak2dyXZUUuMfvvTu11VUQYhfHvMBqmbhIGEUd3jzP46gRRGEdifetyrFifxghcwqrL3n1HeXnnfkpHj+Hkx9E9l7akxcauJAlTr78XR4seh8arEMQ1XyvakvS3JbBP+BzRLBOjoxPNNAhCjWLVoFgxKFU1XN+o19sRRWiJBHoqhZFJo6VS6LaNbuqUXZ+joxWOV0LUCX9AZBMWbRmbrr4UqZyN3emgJ0y8MMSd/GOq6sd1YkcnqlSmBZKRCqhEEwTaOJo5jvIKmOMaqWKanJGjzcmQtbP09nbQ299Be2+KdJtd/0OuUPUZKrgEoUIFVcyx3Vhjr1LOj1AuTFCtlFChIgo0Qs1ERTr4CmdkmMTIMFrVw54sqDYNHd0w0JLt6OluomQn6CYaYHZ3s/ID/7bJ38BTk+BFgpd5UUoRHDuG+/LLuLv3zOgSMvt6SV5xBc7GjRQnfI7vLzB6tFSvB9F0jfa+FLmuZFx4Ojn0N5GxSKQtnLR1yg+4KIrrUbTaXyhzUKj6PHVgnOcOT+AFp65HMXUt7rYwNFJ+lX9z48UAPPL0XnJdHVimNiN1HUYKN4gYzFc5OFIkXdhHf/FFsu7RuOjRCzBGi5iHRtHcuAjOM1IU7D4qVgfTC1ci06LUs4LCqg2Uu/tB0zAil7Q3TFvlIOXKM7wa7sPVQixdI2dZbOq/gisvexcrOjZiG3b9/aj48V/OE/kC4aGfEh15mkp+ZMaInVO+l5qOa2TRO9agr7gBK0pBISAqBXGNSe3n5Bik22xSdoUUw6QZxtFLaEEJvBK4xXo9xngpw+GxPspBNg4s7AxtfVlWrVGkteNxl0P+CKpaJCy7qCCuMVJGEpXqQ1kZquWIchHcoodZHiMx9hJaoRDXI2l6HKyk4k3P5OIvEMdBBSFRsRAPiZ+NrmGvXo21ejVmVxeaaaJ8P+7qHBzEHxyMg5VpjPZ2sj//c1grV57253kmharP4fEKrh+RsAzWdKZI2vMblh94IQdeHGX44NRomUxngs4VaToH0tiJxtL2URjhexFRGHfbVTTFzqN5XjiSp+ieXNh5orVdKbb0Z1nVkSKXOHPR6UmvHyncso9bCijnPY7ty+NX49fNdiVZc3HnrMHZ8YLL80cmeOHwxGTWVLGuI0nGgD1jFcphnIpam9L4mV6TTLVIVCrFNXW6gZHNYA4MYHbPPqou9CO8akBQ60oOFVbCwE6ak6P+pj6jwjBiIu9y4FiRo8crHB8tMzZcgXKIdsL/TZWziHoTYJ/8uvHvSpIu26LNNMgYBrofMTZYpjzhEqoIXdNxkibdq7P0rMniJJvrrnGDkGMTLscKVYJQUfs4zlcDjoyVKEyMk6iMkSiPgxcRVRR2IY9VLqD7PpFpogwTu6uDd/z2LzfVhtlI8CLBS1Mi18V9+RWqL7xAcPx4/X7NtrHXryN56aWY/f245YADL4wwfmyq6yiZtelZk6VrZeak0TcLTSnF84fzPPTK8XrQ0pWxuWpNB+u700RKYRk6lqHPTIGXSpDJxPvFIqTTJz954ML4ARjfTzS0i2phdLJATqHMFCrViUp0EFlZqkMlvDEPXzmEKIJEiqCtA6unBz2VIjItIsDSdVKOga5plL2AweIQjw/9mNHqECndZ42peIOdZW25gKHpcXZh3c/CqmumgiG3CIcehyM/jeerAEIFhcimWHUpuSFFN8RVOppmYGqKjFahzTHozNgkTCPum155NXSsIwgNxg8OMXa0wMRoEA+tdgtxjckk04jIpDzSSQ/DiPB9g/FCkoobf2jquqK7vUxPR4l08hQZN02HZEfc7eCV4uGhp3tfE21EHRdC70VgZ9AM/ZTdiQDK8wiLRcKJCaJCAQwDzbLQEwnMnh70ZHL211GKcGyMYHAQFUYYHR1YAysWdYj4QiiNuxzdM8HYYKk+tF7TNboGMvRtyM36ha8iRWG0yujREvnhKtXSzJE2uhFnQzVDZ2isUu9eKqKI0gZkLRzHYFVHkqvWdNCba3wOEKUUpXGX4YNFRo4UCU/IAjopi9UXddLRn5pTMDRR9vnhy0O8enxmrV17ymLbxi629GWXbC6diYrP/uESh44UGD1eJigEUAjQNTBNjVRvirZVadJZGzMEx1eYpZDiSOWknwvE7097X5ruVRnaepIndZUvtLIXcGS8ylC+Sr4aUPYCSm6AG8R/vKjJaQnaUxbvu3bNgr62BC8SvJxRVC7j7nmVcHSEYHSMqFKO0+21DIppYG/ciLN5M/bq1WimSRQpBvdMcOSVMaIwzpJ0rczQuzZLut05Kx8WRTfgX14YZP9IHDitaEtw/YYu1nXN4UNvtuBFqThgOfQ4jL4ad0vUWAlYcTn0Xx5nAuZxjdWgyuODj/P88PMoFJZucW3/tVzafWk8KdrEYdh9b1z0C9C2EtrXQGEQxvZPffmnu2H19dCzNQ50ZhNF8VwV5RE48CiMH5z1sFLFply1KHtJyvRQidqIdCceMjs5n0U8l4SGofn09UX0d+Uxy4fj5/dLYGcg0xvPmZEbgExffC7ExaD5w3Eb/FrQO/mz1A3oWAedG+b18z1feNWAkcMlxo6WKI5NZaCyXQl61+bIdcf1EIXRKmODZcaPlQm8mcN5NV1DN7R4WoFZRtHV6IZGridJtiNBuj2uP7MSp+lenFQt+ZTGXQqjVSaGKrjThsnrpk4iZeKkLdp6knSvysxtorkTjJU89hwv4gYR3RmHzb2ZM7ZrKZTzHgd3jjIxdOpawRpN17ATJnbSxEnG8zd1rUzHUyicByR4keDllCLPwz90CPeV3bh7ds8oQq2pFaM6W7bM+Ou1WvJ55fFjVArxX/257iRrL+0imTnNl+cCOzha5rvPHaXshZi6xg2burlydfvcP6xOFbyM7YM9D8QBQk2qMw4a2tdC9+apL+A5ilREwStQ9stUwgrD5WGOlY9xpHiEcHJOiM0dm9m2YhsZOzPzZKXg6NOw+774C3+6tpWwZht0bWr8S14pGH4Zhl6E0nCcYUm0x4GQmYBEDtI9ccChG0SRojzhURyrUil4BH6EnTBJZi26BjIy6+85ojhW5djePKNHS6ed6NC0Ddr7UnT0p0i3x3MT1SYdi+vOPKIoqmdNo1BRHHUZO1amWjzFiDNNw3IM7MnulNqXreUYlCc8xofK9c+KGt3Q6ViRomd1lmzX+TnLcH6kwrG9ecYGy/Vu8lTOpq03RXtvPDhhsTMr5zIJXiR4mSFyXUoPP0z1pZdmzApq9vZirVqJ2dmJnsnEQ+Xa20+e8dINefGRI7glH9MxWHNRF10r02ftw0cpxZP7x3hk9wiRUnRnHd526Qo60w0GTtUqvPvd8f6dX4bBx+Hos/G/dRP6L4WVV8XZgwZ4ocdwZZgjxSMcLR1lsDSIH526cLk72c22gW2szq4+Q1sn4rb55bj+o2tjHFQJcQpeJeDY/jzjg1NBg5OyaOtN0rkiTabzzMW0p6KUolLwGR8qUxp36xMtni5QqtF0jXS7Qypr09abJNedxDAl6AUI/BBUPKLyfAziZiPBiwQvdd6hwxTuvTeexZW4MNFesxpn64VYfWf+kg6DiJcePUpp3MVJWVz42hUNFwjOR8kN+P60bqILV+S48cJerEZTzErFWZaR3TCyJ57uu2blVbDudfGU3HNQCSq8OvEqB/MHGa4Mk/dOXprA1E3SVhrbsOl0OulL99Gf7qcr0SUfVmJRhX4EOvHkY4tAKUXgxUWtXiXAq4R4lQC3EuBVAxKTXUFtPcnzprtDLIxGvr9lbaNlrPLc8xQfehAihdHWRvbGn29oNIWKFHueGqI0Hk9bf8H1fWctcFFKsXuoyP0vDVH2QixD4/UX9HLJylxjX/5KxXUsex+a2TUEcTfMhp+D9jNkQSZNuBM8c/wZXhp9iSCaOSojbaXpT/czkB5gRWaFBCliySx2l5422WVkOca8h2wL0SwJXpYhFUWUHn6YyjNxl4hzwQVkf/7nTpo+/7TPoRT7XxhhfLCMbmhsvrZv0etbxsseRyeqjJU9Do1WODweT9TWnXW4+ZJ+ujINflBWxuGlf46LcSGuXem9KK4ZaV8DVoKiV2TP8Wco+SW80COM4vV+UlaKnmQP3cluKkGFp48/zd7xvfHstkBXootNHZvoT/fTmegkac4+ukUIIcTCkuBlmYk8j8I99+Dtj7+w09teQ/LqqxvOAhzdPcHQvjxoGhuu7CXbuXhLpPthxAMvDfHCkZndL6aucfW6Dq5b14nZaAr8+K44cAncqSHCnZegVq1HoXju+R9wIBrhUOFQPSCZizW5NVzRcwUrMyslsyKEEEtEgpdlJCyWyH/n2wTDI2iWSfaNb8TZuLGh51BKcXjXGEdeGQdgzcWddK6YWy1Io2pdQ4/sHmas7KNpMNCWpDNt05G22dyXIZdobKQP1TzsfwSOPB3/u20lwZa3srM8yN4D9/GOchkNeGzwMYJknMlZkV5Bb6oX27AxdbM+WmioPMRIdQRTM9nQvoEreq6gK9m1oD8DIYQQjZPgZZkIxsbIf+duwokJ9FSK3L/6V3MqyJ3Od0P2PTfM2NF44qeVWzroX9+2GM3l0FiZH70yzOBEPE9F2jF46yUrWN155in7T6l4PJ7LZGhnfT4UteoaDvZs4uED9zLujmNWpmZVXd+2np7udaxvW0+bM/s11rqRauv1CCGEWHoSvCwD3sGD5O+5B1V1MdpytL3znRhtcw86lFKMHi2x/7kRAi9E0zXWXdpNz5rsgrdVKcVje0d5dM8IEK8ddOWadq5e24FjNjEyoXAM9j8Mx1+u33U01cbLuR72uocp73sFgJSZ4uoVV9WPeePaN556ht0TGLqMlhBCiHONBC8tTClF9bnnKP7oRxApzP4+2m6+GX0OX8o1YRix9+lhRo/EQ6lTOZv1V/QsyiiC4wWXB14aqhfiXrKyjRs2dpF2mvg1jMK4e2j/j+vL6la7NvCgqdjjjoAbL29g6RYXdV3ENf3X4FTPvG6LEEKIc58ELy1KhSHFhx6i+vwLADhbt5D9uZ9DM+f+lnrVgFceP0Zp3EXTNVZsamdgcwMz1s6RH0Y8snuYZw5OTK47pPGGLb1csrLJLqn8Edj1XSgeJ1IKt3sDQz1beHD0OYpuEU3TuKDjAja3b2YgM4Cp134mErwIIcRyIMFLC4qqVfLf/R7+4cOgaaRv2EbyyisbGv2SH6mw58nj+G6AaRtsvrZvUUYUTZR9vvPsEY4X4nqTTb0ZXr+lp/FCXIAwgAM/hv2P4kU+z4cFnsl2UIlG4dijALQ5bbxx7RvpTTVW7yOEEKJ1SPDSYlQQkL/7bvyjg2iWRfbNb8JZv37u5yvFsb15Du4cRUWKVM5m0zV9JNJNBBNnUKj6fP2JgxTdgJRt8OaL+1nX3cTIpWoeDj8Jg89SreZ50RvlKUvD7VxbX3coYSbY1L6J16x4DbYxy3w0ug6vf/3UvhBCiJYkwUsLUUpRfOihOHBxHNp/8V2Y3d1zPj8MIvY+M1Xf0rUqw7rLuhdlGnE3CPl/Tx+h6AZ0ZWzedeVKso1mW5SCIz8l3H0f+91RXvBGOYSP6lgH6R7anXau7ruaje0bp3UNnUYyCT/8YTOXI4QQ4hwiwUsLqT7/PNUXXgRNI/fmNzUUuExfFVrTNVZf1Enfugan2p+jKFJ877lBjhdc0o7BO69oInCpjFF44Z/Yefw5dnqjlOwkdKyCVBddyW6u6L2CzR2bZQizEEKchyR4aRFhPk/pkUcASN9wA/batXM+t1L02PWTQbxKgOWYbLpmcWfM/eHLQ+wdLmEZGu+4fCVtybkHLgU3z57d32PvvvsZ9AsoTYOO9SQ7NrC160Iu6rrotPOyCCGEWP4keGkRxR/9COUHWAMDJK+8Ys7nVUs+Lz06iF8NSGZttlzfj51cvLf9lWMFnjk4gabBWy7pp7/tzEFS3suze2w3rx5/nqGDP4bqRPxAoo2Va3+Wi1dcx/q29fOfc6VUgnXr4v19++Y0z4sQQohzjwQvLcDduxfv1b2ga2Te8Po5d/V4lYBdP5kKXLZuW4HlLN6kayU34L6XhgC4dl0nm3pPP8mdH/o8cuQRdg6/gJo4BBMH0JSi386xcd2NbNj0VjLOAk+UNzy8sM8nhBDirJPg5RynfJ/Sj34EQPKKKzC75ra2jlv22fXYMdyyj5O22PKa/kUNXAAe3j1MxQvpyTq8ZsPp2xlGIXe/ejdHC4dg6EVW+gGbnBWs776Y1EXvhFTnorZVCCFE65Lg5RxXfeEFwok8eiZD+tpr53ROYbTKK08cI3BD7KTJ1tf0YycW960enKjy4uSq0Dde2ItxhonuHj78MEcLh7GHX+GtRicr052w+U3QdwnIas1CCCFOQ4KXc5iKIirPPANA6ppr0OxZ5i+ZZmywxO4nh+I5XNocLri2b1FrXCAewv3DXXF30UUDOVa0JU97/K7RXbww/Bza8Zd4o5ZlpdMBl74X2lcvajuFEEIsDxK8nMO8PXsI8wX0ZILE1i1nPD4/XGHPT+PApWNFmg1X9GCYiz+U+NXhEkcnqtimzms3nX749nh1nIcO3A9DL3FNZLI23QmXvkcCFyGEEHMmwcs5rPz00wAkLrkUzTr9cOPSuMvLjx8jChUd/Wk2XdWLtsBrFJ2KUqq+QvTlq9rJnGaRxSAK+JcX78Q//AQDmFydXQ2XvBs65j7sWwghhJDg5RzlDw4SDB5DMw2Sl15y2mMrBY9djw0SBRG57iQbr+o5K4ELwO6hIscLLrapc/XajtkPVIpHn/prhg88TEI3eWP35eiXvAfaVp6VdgLxkgDXXDO1L4QQoiVJ8HKOqjzzLADO5s3op5iPRCmFVw3JH69wcOcogReSbnfYfE0f+iJM938qSil+8mqcdblyTTtJe/bRTPuev4vnDjwIwI3r3kL64veAeeYangWVTMLjj5/d1xRCCLHgJHg5B4XFEu7uVwBIXHbZjMdUpBg+VOTongmqRa9+f7rd4YLr+zGss5dReGWoyHDRw7F0rloze9Zl4sCj/GDPPwNw2YY3sfby7WeriUIIIZYhCV7OQdUXXoBIYa3ox+rtrd8fhhG7nxhiYqgMgKZrJNIWnQNpVmxsO2sZF4jXL3qslnVZ3UHCOnXWpZw/zD8/+9d4KqSv73K2XforZ62NQgghlicJXs4xKoqovvgiMDPrEvoRLz9+jMJIBd3QWbmlg9412bOaaZnu8X2j9azLlWvaT3mM65e5+7HPM+6XSad7efPVH53/FP/zUS7DRRfF+y++CKnU0rVFCCFE0yR4Ocf4R44SFYtojoOzYQMQZzl27RikOFrFsHQuuK5/URdWPJOhfJWfvDoKwBsu6D1l1sUPff55x39luDhI0kzyzut+Z+Gn+m+UUrB//9S+EEKIliTByznGfeVlAJyNG9DM+O05vGusHrhsfc0K0u3OkrUvjBT/8uIxIqXY1JvhwhUnByRlv8z3X/o6g8dfxNYM3n7lb9DeLsOhhRBCLAwJXs4hKgzx9uwB4lFGAIEXcmxvPO3++st7ljRwAdixd5TjBZekbfDzW3tnLBKplOLlsZd55PDDVA89jo3O29e+ie5V1y1hi4UQQiw3ErycQ/xDh4gqVfRUEmvVKgCG9heIwohUm0NH/9LWaBydqLBjb9xd9HNbekk7JiW/xL78Pg4XDnOsfIyCV4DKON2+x425C+i68J1L2mYhhBDLz6JVe46OjrJ9+3ZyuRzt7e186EMfolgsnvG8Rx99lJ//+Z8nnU6Ty+X42Z/9WSqVymI185xSfXmyy2jTJjRdJwqjetalf0PbjCzH2Vb2Av752aNESnFBX5YNPQkeH3ycv3/x73nw4IPsHt9NwStg6ibXKZt3ZzbSteo1kGhbsjYLIYRYnhYt87J9+3aOHj3Kvffei+/7fPCDH+QjH/kIX/va12Y959FHH+Utb3kLt99+O1/84hcxTZNnnnkG/TyYDVUFAd6re4GpLqOxY2V8N8BOmnQOnDxR3dkSRYrvPTdIoRrQnjTYsLLA/9l1H3kvDqx6U72sza2lP91PjzJIPPlV0A1Ydc2StVkIIcTytSjBy86dO7nnnnt4/PHHuWZyOvYvfvGL3HzzzXz+859nYGDglOd94hOf4Ld/+7e57bbb6vdt2XLmBQmXA2//fpTnoWczmCtWADByOM5Uda3KoJ+l6f5P5ZlD4+wZHmU4eBGjc4IHDoYApK00rx14LRvbN05lhV7+fnzbtQlSnUvU4llo2tRQ6SXMYgkhhJifRUlpPProo7S3t9cDF4CbbroJXdd57LHHTnnO0NAQjz32GL29vdxwww309fXx+te/nocffvi0r+W6Lvl8fsbWitx6l9FmNE0j9CMmhuLusu6VmSVrV9ENuO/lV9lVvpdE5gimEeIYDlf3Xc2/2fpv2NSxaSpw8SswGC9rwKprl6zNs0ql4IUX4k3meBFCiJa1KMHL4OAgvdNmhgUwTZPOzk4GBwdPec6rr74KwB/8wR/w4Q9/mHvuuYerrrqKG2+8kVdeeWXW17rjjjtoa2urb6tXr164CzlLItfF27cPAOeCuMuoMFpFRQonZZHMnuU1gKb51nPP8kL+B9i2x5aePt6+8e188JIPcv2K67GME1a6PvIUhAFkeqF9zdI0WAghxLLXUPBy2223oWnaabeXXnqpqYZEUQTAr//6r/PBD36QK6+8kv/23/4bW7Zs4W//9m9nPe/2229nYmKivh08eLCp119K3p49qCDE6OzA7OkBID8SZ11y3UszGV2kIr6960H+5cB3CfG4bvV6fvGCX2R1djW6dopfmyiEw0/G+6uvk24ZIYQQi6ahmpdPfvKT3HLLLac9ZsOGDfT39zM0NDTj/iAIGB0dpb+//5TnrZis87ioVpMw6cILL+TAgQOzvp7jODjO0s59Ml/uZGYpccEF9S6YwkgVgGxX8qy3p+SXuGfv97ln106UUlw3cCn/9pK3YenW7CcN7QS3CHYaei+a/bilVC7DtZPdWY8/Ll1HQgjRohoKXnp6euiZzAyczrZt2xgfH+fJJ5/k6quvBuD+++8niiKuv/76U56zbt06BgYG2LVr14z7X375Zd761rc20syWEpXLeIcOAWBv2gTEE9OVJuIVo8925mWwNMj3932fl44dxw8MLm67gY9c+7NYp1uTSCk4tCPeX3l1PNLoXKRUvKZRbV8IIURLWpSalwsvvJC3vOUtfPjDH2bHjh088sgj3Hrrrbz//e+vjzQ6fPgwW7duZceO+EtP0zQ+9alP8YUvfIF//Md/ZPfu3Xz2s5/lpZde4kMf+tBiNPOc4O55FSKF2dOD2dEBxPUuKEUiY2Mnzs48gtWgyo8P/5hv7f4Ww6U8YwWbLek38ouXXoNjniEYmTgIhWOgmzBw5VlprxBCiPPXon0z3nnnndx6663ceOON6LrOu9/9br7whS/UH/d9n127dlEul+v3ffzjH6darfKJT3yC0dFRLr/8cu699142bty4WM1ccu7u3QA4mzfV78tPdhnluhY/6xJEAc8PP8+Tx57EDV2UUhQKXWxKXs7m3nY2985hpNP+H8e3/ZeALV0xQgghFteiBS+dnZ2nnZBu3bp1qFOk7m+77bYZ87wsZ1GphH/4MBDPqltTGI6LdbOL3GU0WBrkvgP3MeFOANCZ6KTLuAT3uIVt6rxhS++ZZ/UdPwije0HTYc1rFrW9QgghBMjaRkvK3bMHlMLs68Voi6fR992Qcn6y3mWRinWDKGDH4A6eGXoGhSJlprhuxXWsTm/i//eTA2haxLaN3bQlT1OgW1PLuqy4DJIdi9JeIYQQYjoJXpaQ+0qty2hz/b7aKKNk1sZyFr7w9Xj5OD848APGqmMAbOnYwmtXvpaEmeB7zx3F9SN6cw5Xrm4/85MVh2D01XhYtGRdhBBCnCUSvCyRsFjEP3oUmNllNDW/y8JnXSbcCb61+1v4kU/STPL61a9nQ9sGAPYNl3hpsICmwU0X9s1tOYKDkyOMera0RtZF02Dt2ql9IYQQLUmClyXi7d4NSmENrMDIZuv31zIvCz1EOoxC/mX/v+BHPv3pft66/q0kzThA8sOI+16K5+W5ck0Hfbk5vLZbgKHJYcerrlvQti6aVAomZzIWQgjRupb/cs3nqOrkxHTTsy5eNaBS8EDTyHYubPCyY3AHx8vHcQyHN659Yz1wAdixd5R8xSebMNm2oWtuT3j4p/Gsum0r400IIYQ4SyR4WQJhPk8weAw0DXvjVPBSHHMBSGUtTHvh6l0OFQ7x9NDTALxh9RvI2lOZntGSx5P74/qXN2zpxTbn8CsReHDkp/H+6lNPOiiEEEIsFglemqCUohJUmj6/NreLNTCAkUnX7y+OxV1GmY6Fy7pUggr3HbgPheKirovY2D41Z45SigdeGiKMFOu702zsSZ/mmaY59hz41bjOpWvzmY8/V1Qq8fIA114b7wshhGhJUvPShO+8+h2OFI/wtg1vY3W28VWs3cklEKaPMoKpzEumc2HWalJK8cODP6Tkl2h32nntwGtnPP7c4QkOjJYxdY03bOk585wuAFEEBx+P91ddC3oLxb9RBE88MbUvhBCiJbXQN8+5oegVOVQ4RKQido7sbPj84PhxguERMPQZs+pGYURpfDJ4WaDMy6HCIfZO7EXXdN607k1YxtS8LWUv4EevDANww6Zu2lP23J50ZDdUxsBKQP+lC9JOIYQQohESvDSoNj8KwHBluOHzqy+9BICzfj16YipIKU14qEhhOSZOav4JMaUUPxn8CQCXdF9Cd7J7xuOP7xvDCyL6cgmuWtM+9yc++Fh8u+IKMOcY8AghhBALSIKXBpWCUn1/wp0giII5n6vCEPfllwFwtm6d8VhxdLLepdOZW/fNGeyd2Mvx8nEs3eKq3qtmvpYb8OzBcQBu2Ng199fLH4GJQ/Gq0auumXcbhRBCiGZI8NKgsj+1kKRCUfJLpzl6Jm//AaJyBT2VxF6zZsZj9XqXBegyUkqxYzCeQO6ynstIWTMXS3x87yhBpBhoT7C2q4GFFGtZl94Lwcme/lghhBBikUjw0qATg5WCV5jzue6uyS6jC7agGVNDoZVSFOojjeZfrHukdITR6iiWbnFF7xUzHit7Ac8djhdivGFj99yzLpVxOB4XGrfMpHRCCCGWJRlt1KBqWJ3x77kGL1G1irt3LwCJrVtmPOaWAwI3RNM10m3zryN5cSSe+faCjgtwjJnB0POH84SRor8twerOBrIuh58ApaBjHWT75t3GJdPdfeZjhBBCnNMkeGmQH/oAaGgoFEW/OKfz3JdfhjDC7O7C7OmZ8Vityyjd7qAb80uGVYIKe8b3AHBR10UzHosiVc+6XLaqbe5P6lfh6DPx/uoWzrqk03D8+FK3QgghxDxJt1GDvMgDoCMRL0Q4l8yLCgLKP41npE1cdNFJj5cnJmfWzc0/67JrdBeRiuhJ9dCTmhkk7Rspka/4JCyDC/oaqFk5+kw8q266Gzo3zLuNQgghxHxI8NIgP4ozL21OnLmYy0y71RdfJCoU0dNpEhdffNLj5XwcEKXb5l/v8sp4vGbShZ0XnvTYs4firMvFAzmsuWZ4ohAOTZuUTlZjFkIIscQkeGmQF8aBRpsdBy/loHy6w1G+T/nxeFbX1LXXoJkze+qUUpRqmZd51rtMuBMcLx9HQ2ND28wMyUTZZ99IXGzcUJfR0M54BWk7BX2XzKt9S65SgTe8Id5keQAhhGhZUvPSoNq8LvXMi3/6L8HKs88SlcsYuewpu4y8SkDoR2i6RjI7v+Bl93i8ZtLK7MqThkc/d3gCpWBtV2rus+kqBQfjie5YdS0YLf7rEkXw4INT+0IIIVqSZF4aVOs2yjk5IM68KKVOeWwwNkZ5RzzfSuq662YMj66pFOLnS6QtdH1+XTK1Qt3piy8ChJHihSNNFOpOHITi8ThoGbhyXm0TQgghFkqL/yl9diml6qONapmXSEWUhwcxC1WMXBajsxOAYGiIwn33oYIQa/Wqk2bUramW4uebb9Yl7+UZrgyjobE+t37GY68eL1L2QtKOwfruzNyf9NDkIoZ9l4CVnFf7hBBCiIUiwUsDgihAEWdZkkYSW7dIP7WH0R/eScKIZ8bVHAeUQnlxbYyeyZC96aZZJ4OrFCczLxnrlI/P1d6JeA6Z/nT/SV1GU4W6bRhzze5UJ2A4Lv5l5dXzapsQQgixkCR4aUCtywjA1E26Xh3FefkoXmeOdFc/UbmMcuPiW81xsFYOkHntazEys2c7KoU4yEnOM3h5dfxVADa0zyzUHS15HBgto2lwycoGuoyOPA0qgvY1kOmdV9uEEEKIhSTBSwNCFQJgaAYoRcfu45SB8JpL6Xz921FhSDAygmYYGB0daPqZS4qqC5B5qQQVBkuDAKxvm9ll9MzkAozru9O0Jef4GmEAR5+O9yXrIoQQ4hwjwUsDwmgyeNEN/CNHcCoBRdukesFKADTDwOqde5bC90ICL37ORLr54OVA/gAKRVeii5ydq9/vBiEvHs0DcOXqjrk/4fGd4JXjxRe7L2i6XeekVANLIgghhDgnSfDSgEDFw6QNzcA/cABLtyj3tVPBP8OZp1bLujgpC8NsfuDXvvw+ANa1rZtx/86jBbwgojNts7qzgYLbw0/Gtyuvgjlkj1pGOg2lua8CLoQQ4twkwUsD6pkXzcA7fBhLN6n0JSj7p5+objYL0WUURAEHCwcBWJdbV79fKVXvMrp8dfvcV48uHIP8UdANWHF50+0SQgghFssy+rN68UUqntjMQCccGcEyLLyOzBln2Z1NpRgX686ny+ho8She6JEyU/SmprqsDo5WGC152KbOhSsaWMfo2PPxbdcmsNNNt0sIIYRYLBK8NKDWbWSXPJQfYNoJ/ExiTusbncpCZF725uMh0uva1s3IruwcjGtdLlyRxTFPnhzvlKIIjr0Q7/df2nSbzlnVKrztbfFWrS51a4QQQjRJuo0aUOs2cvJxsOJ09YLuNd1tVJvjZT7DpA/kDwCwNrd2WjsVe44XARpbPXpsL3ileEK65bh6dBjCd787tS+EEKIlSealAbVuI7vW3dMdd9NUgsqsSwTM+lxhhFuOMznNZl4m3AnyXh5N01iZWVm//8BoGdePyDgmA20NFOrWsi59F8c1L0IIIcQ5SIKXBtS6jazKZPDS3gXE8794kdfQc7nlAJRCN3Usp7lA4VDxEAD9qX5sY2p5gZePFQDY1JuZ+3pJUQgj8cKO9Jx6KQMhhBDiXCDBSwPqo41Kcb2E09ZRDxoa7Tqa3mU055FAJ6iNMlqVXVW/TynFvuF4OPCm3gbWMRrfD4ELdgpyK898vBBCCLFEJHhpQK3byCpNrluUy5E0426ZRkcczbdYN1IRhwuHAVidXV2/f6TkUfZCLENjoL2BLqPaOkZdm5fX3C5CCCGWHfmWakCg4q4eoxyvX2Rks6TMeMbWRjMvtdWkmx0mPVwZxg1dbMM+YYh03I6B9uTcF2FUCoZfjvd7tjTVHiGEEOJskeClAWEUorsBehhnYPRMpr6Cc6PDpeebedmf3w/AysxKdG3qbTw4FrdjdWcD0+Dnj4BbBMOC9rVnPl4IIYRYQjJUugGhCjFcH13T0RIOmmE01W2klKpPUJfM2Gc4+tRONUQ6ihSHxuJ2rO5oIHg5vjO+7d4MxjL+lUin4yyTEEKIliaZlwbUghdN09GTcXDQTLdR4EWEfgSahpNuPFgo+2WGykPAzODl4Fg8RDppG/Rmnbk9mVIw9FK833Nhw20RQgghzjYJXhoQRiGGG6CjoSfjjEut26iRzEut3sVJmhhG42/BwcJBFIruZDdpa2oK/5ePxRPTbW5kiPTEIXALYNrLc2I6IYQQy44ELw0IVYhRncy8pCaDF7Pxmpd6vUsTWReYqneZbVbdzb0NzKp7fDLr0rXMu4wgXhLgPe+JN1keQAghWpYELw2IVITu+mhoaJOZl3rNSwPdRrXgxWlipFGkIg4UTq53OTRWpuKFJG2DVR1zHCIdRTA0We/Sex50GYUh/OM/xpssDyCEEC1LgpcGxDUvAZqmTdW8TBttNNclAmrdRs0U6w6WBvFCj4SZmDFE+pXJLqNNPY10GR2YXMsoIV1GQgghWoYELw1QSsUFu2j1bqNa5iVSEdVwbl0Rlfow6ca7afbl9wGwJrumPkQ6jBS7m1mIsZZ16d4iaxkJIYRoGRK8NCDuNprMvCQSAJi6iWPEI3vm0nWkIoVbbn6CutoQ6TW5NfX7Do7GXUaphrqMwql6l76LGm6HEEIIsVQkeGlARITuh3HNizM1FLmRiercSoCKFLqhYScby7zkvTyj1VE0NNZkp4KXlwbjhRgv6MvOvctobB/4VbDT0LbmjIcLIYQQ5woJXhoQRRG6H6BpzAheGpmobmqkUeMLMtayLv3pfhJmnPnxw6g+yuiC/ga6jGorSHdfIGsZCSGEaCnyrdWAiAg9CNHQ0eypYttGJqqrz/HSRJfRqYZI7xsu4QUR2YTJQFtibk+kFIzsife7NjXcDiGEEGIpLfOJPRaWiiIMP4Qk6NODlwYmqmt2TaNIRRwtHQVgVXZV/f5al9GW/uzcMzmlYahOgG5Cx3m0llEqBcXi1L4QQoiWJMFLAyLfw1CgadopMy9zqXmpjTRKNhi8jFRG8EIP27DpTnYDUPVD9g2XgDh4mfuTTXYZdayNF2M8X2havL6REEKIlibdRo1w48BDNwwwp+K+eualgW6jRkcaHSkdAeJ6l9oQ6T3HiwSRoitj05OZ41pGAKO1LqONDbVBCCGEOBdI8NIA5cUrQWu2PaOLZq41L6Ef4VcDoPHg5Wgx7jIaSA/U79s1bZTRnLuM/ApMHI73O8+z4MV14ZZb4s11l7o1QgghmiTBSyP8yeDFmZnlqGVein7xtKdXJ+d3MR0D0577pHBKqXrmZSATBy9lL+DgaNxNtbWRLqPRvaAiSHdDsn3u5y0HQQBf/Wq8BcFSt0YIIUSTJHhpgKp1G1kzp/XPWBkA3NAliGb/Upw+TLoRY+4Y1aCKqZv0JHuAeAXpSCn62xK0pxpYZqBW7yKjjIQQQrQoCV4aMdlthDNzSLJjOBhanEkp+aVZT282eKl1GfWl+jAmp/F/+dhUl9GcRRGMvhrvS72LEEKIFiXBSyM8n7I3wL4jHeSHp0YWaZpGxo6zL6cNXkrNjTQ6scuo5AYcGY9ff3NfZu5PVDwW17yYDuRWnfl4IYQQ4hwkwUsDlBviBj2EWBzdMzHjsVrR7umCl0oTc7wopThSjIOXFekVQDzKSCnob0uQSzQQCOXj56FtlcyqK4QQomXJN1gDwsm4RDMMSuMzR6ucKfOilGpqmHTey1PyS+iaTl+6D4B9I/Gopo09DWRdAPKTo4xyA6c/TgghhDiHSfDSADUZr2iGTuCF+G5YfyxtxpOfzRa8+G5IFESgaTipuc8NWMu69KX6sHQLpRSHx+IuozWdDc4SW8u8SPAihBCihckMuw1QceIEbbJotlLwsJx4Uca0ffrgpVas66RMdGPuMWOt3mVFJu4yOl50qfohtqnTm21gYjqvBJWxeJbZ7HkavKRSMDQ0tS+EEKIlSfDSgMiLJ4LTJutF3PLUsOgzZV6anVn3xMnpDk1mXQbaE+h6A6tS17IuqS6w5riA43KjadDTs9StEEIIMU/SbdSIycwLRpx58SpTwcuZal6aWZCx6BXJe3k0NPrT/cBU8LKqo9EuI6l3EUIIsTxI8NKAaDJ4sRNxwsqdFrzUZtkt+SWUUied28ww6VqXUXeqG9uwZ9S7rOpINtZ4qXeJlwT46EfjTZYHEEKIliXBSyOCuJsmlYtntPWqJ3cbhSqkGlZPOrXSxAR1J3YZDRe9afUuDXT9RNG04OU8nt8lCOB//s94k+UBhBCiZUnwMkeRimBycFEyGwcg07uNDN0gacbZkKI3c42jKFL1YxsJXk4s1j00Fg+RXtGWwGik3qU8DKEPph3XvAghhBAtTIKXOYqDl8nMSzYOUrxKMKOLKGvHU/UXvMKMc92yj4oUuqljJea2IGPZLzNWHQOmJqebd71LdkAmpxNCCNHyFvWbbHR0lO3bt5PL5Whvb+dDH/oQxeLsKy/v27cPTdNOuX3jG99YzKaekVJqKvPS5oCmEYWKwIvqx+TsHBBPLDfd9DWNNG1uGZOjpbjLqDPRSdJMxvUu403Wu0xIsa4QQojlY1GDl+3bt/PCCy9w7733cvfdd/PQQw/xkY98ZNbjV69ezdGjR2dsf/iHf0gmk+Gtb33rYjb1jCIiiOLAw046WPbkiKNpdS+1zMuJwUttSHVDXUbFmesZjZQ8Kl6IZWj05Roc6lyIAyEJXoQQQiwHizbPy86dO7nnnnt4/PHHueaaawD44he/yM0338znP/95BgZO/iI1DIP+/v4Z933zm9/kve99L5lMg1PhL7AwClGBRhgqDMfGTob4boBXCUi3xZPF5ZzTZ16c9Nx/3LXMS61Y9+h4XATc35ZsrN4l8KA8Eu9nV8z9PCGEEOIctWiZl0cffZT29vZ64AJw0003oes6jz322Jye48knn+Tpp5/mQx/60KzHuK5LPp+fsS2G0PepeBFlL+Tl0Wp9uLRXnVoiIGfFwcuJNS/VcmMjjapBlZFKHHDUMi+1LqOBtgazLqUhUArsNDhLGwAKIYQQC2HRgpfBwUF6e3tn3GeaJp2dnQwODs7pOf7mb/6GCy+8kBtuuGHWY+644w7a2trq2+rVq+fV7tkElSpBGNe3PDdcrhfeTu82qmde3PyMQt5qg8Okj5aOolC0O+31+WOOTtRm1m2w3qVwLL7N9p/+uPNBMgl798ZbssGfoxBCiHNGw8HLbbfdNmtRbW176aWX5t2wSqXC1772tdNmXQBuv/12JiYm6tvBgwfn/dqnUipU0JWPQUCo6djJOPPiV6YyLxkrg6ZphCqk6MeFyVEY1bMzcw5eavO7TGZdSm7AeNlH06C/0cxLcTJ4yfSe/rjzga7DunXxJqOuhBCiZTVc8/LJT36SW2655bTHbNiwgf7+foZqi+BNCoKA0dHRk+paTuUf//EfKZfL/Mqv/Mppj3McB8dpYIHCJpUPvYQVuaCFhF5lWrfRzLle2p12xqpjjFXHyNrZuFhXKQxLx7Tn9oV5qHgImBoiXcu6dGUcEtbchlrXFSezXBnJvAghhFgeGg5eenp66JnD4nbbtm1jfHycJ598kquvvhqA+++/nyiKuP766894/t/8zd/wjne8Y06vdTak11xK+4p7qPoh5fIIhr0OmBm8AHQkOhirjjFaHWVNbk19WQAnNbdh0iW/xHBlGIDV2bgLbCgfT2Xf3+gooyiEUvxcZPsaO3c58jz43d+N9//4j8G2l7Y9QgghmrJoufMLL7yQt7zlLXz4wx9mx44dPPLII9x66628//3vr480Onz4MFu3bmXHjh0zzt29ezcPPfQQv/Zrv7ZYzWvYyjUredc7r2TDJgcrrBCZ8Y/Oq4Qz6ls6nU6A+gRz1VJjw6QP5A8A0Jvqrde7DBXi4KU322CGqTQcBzCmA4n2xs5djnwfPv/5ePP9Mx8vhBDinLSoHf933nknW7du5cYbb+Tmm2/mda97HX/1V39Vf9z3fXbt2kW5XJ5x3t/+7d+yatUq3vSmNy1m8xqm2WlMQ8MKy4STvTdRGBH6UxPVdSQ6ABhza8FLrVh3bkmu/fn9AKzNra3fN1SIh0n3NBq81Otd+mCOk+MJIYQQ57pFm+cFoLOzk6997WuzPr5u3bpTrsD8J3/yJ/zJn/zJYjatOXYaU9cxoypuqDBtg8AL8aoh5uSkdbXgZbQ6ilIKtxa8zGE16UpQYV9+HwDr29YDcbFuyQ3RNOjOzCN4EUIIIZYJGXLRCNPBNDSMyMcNwvqIo+kLNLY77WhoeKFHJajMqHk5k12ju4hURHeym+5kNzDVZdSRsrHNBt+uWvAi9S5CCCGWEQleGmE4mLqGqTwqXoR9irleTN2sz/cyXBqZWk36DJmXIAp49vizAFzcdXH9/mP5uMuo4SUBlJLMixBCiGVJgpdGGDamoWNEPtUgPOUsuwAdTtx1NDQWz5JrWDqmdfof9VNDT1H0i6StNBd0XlC/fyp4abDLqDIWLw2gm5DqauxcIYQQ4hwmwUsjTBtD1zAiDy+IsJOTmZfKzOHS9S6fyeDlTKtJj1ZHefLYkwC8duC1WHqcpVFKNZ95KR2Pb9NdoDc4N4wQQghxDlvUgt1lx3AwNQ1D+XhBhJWOsyH+CXO9dKfi4GV0fJxuTj9MWinFDw/+kEhFrMutY2P7xvpjxcliXV3TGh9pVA9eZGbdumQSnn9+al8IIURLkuClEfXMi48bRLN2G/Um44AhXygRahHOaYKXZ4efZbA0iKVb/Myqn5mRoTk2OTldZ8bGMhpMktWDl+7GzlvOdB0uvvjMxwkhhDinSbdRI4zJ4EV5eOG0bqMTMi9pK03STKLKBpWgQnKWYt2h8hA/PvJjAF6z4jVk7ezMx2tdRo1mXWBqZt30uTFDsRBCCLFQJHhpxGTwokcBrj9VsBv6EYE/lX3RNI2uRDeUTcp+iVTu5GnolVL8+MiPUUqxoW0Dl3RfctIxxwpN1rtEIZRH433JvEzxPPiDP4g3z1vq1gghhGiSBC+N0M04eFEBXhhhmDqWEwcw1eIJdS9aL0QahbBwypqX/fn9HCkewdAMXrvytScV9MbFupNrGjW6knR5FFQEpg2Tw7YF8ZIAf/iH8SbLAwghRMuS4KURhjXZbRTgTWZaavO3VEsz/5LviuK5VfLGKEqbOYtwpCJ+cvQnAFzac+lJ3UUA+WpAxQsxdI2udIMLCJYnu4xS3bIsgBBCiGVHgpdG6HHwAgp/8i/3Wj1LpTjzL/mEl8HQDYJElaHy0IzHdo7uZLQ6imM4XNV71SlfqjZEujvjYDZcrFurd5EuIyGEEMuPBC+NMCxMPc5k+H6caalnXk4IXip5n5ydg3TAwcLB+v3VoMpjRx8D4Nr+a0mYp+4SanpyOognqANIdjZ+rhBCCHGOk+ClEbqBbkxO+Bb6BGF0yuBFKUVpwqXNaYNUwO7x3fUFKJ849gTVoEpHomPGMgAnqtW7NFysC9OCl47GzxVCCCHOcTLPS4MMM64/qRXtJus1Lz5RpNB1DbccEPoRXalODiZhrDrGM8efIWWleG74OQBeN/A6jFlmvlVKMTQ50qh3PpmXlGRehBBCLD+SeWmQPlm0q6twcokAE8PSUZGiUoi7ksoT8W0ml+SK/ssB+PGRH/OD/T9AKcXmjs2szq2e9TXGyz6uH2HqGl3pBoMXvxJvAIn2hq9PCCGEONdJ5qVRk3UvugpwgwhN00i3OeSHK5QnPNJtDqWJuMsn3WZzcf/1pMwUPz32U7zI4+Kui3nNitec9iVq87v0ZJ3JAuEG1LIuTiYeKi2mJBKwY8fUvhBCiJYkwUujps/1EkQA9eClNO7SsyZLYSQOPjIdCTRN47Key7i0+1KA0y7QWFOvd2l0fheQepfTMQy49tqlboUQQoh5kuClUYaFoU1lXgDSHXHXTn6kQuCFFMfj4CPXM7X431yClpr6SKOsBC9CCCHEiSR4aZQ+baK6yeClrTuJpmtUiz4HXhwFpUi1OTjJxn+8UaQ4XqiNNJrPMGkJXk7iefDnfx7vf+xjYEu3mhBCtCIp2G1UrWA3ikcbxXfpdK5IAzB8sABA9+pMU08/WvbiQmBTpyPVxJerBC+z83349KfjTZYHEEKIliXBS6Om1bz4k8ELwKqtHRhW/ONMZCx6Vp885f9c1LqMerIOeqPFuiDBixBCiGVPuo0aZVjoJxTsAjgpi8t+bjWlcZdsVwLDbC4uHJrP5HR+FbxyvC/BixBCiGVKgpdG6RamdnLwAmA5Bu19qXk9/byWBaiOx7d2GswmzhdCCCFagHQbNcow6wW77gnBy3yF04t1mxlpVB6NbyXrIoQQYhmT4KVR0+d5CRc2eBkpuQSRwrF02lNW408g9S5CCCHOAxK8NEqfuTzAQqrXu2QTDc0LUyfBixBCiPOA1Lw0ajLzoi1C8DJV79Lk1PUV6TY6rUQCHnhgal8IIURLkuClUfVuoxAvCBf0qWvLAjS1krRSUB6J91NdC9iqZcQw4A1vWOpWCCGEmCfpNmqUbkwFLwtY86KUYqwcr0bdnWkiePHL8VBpTYNU54K1SwghhDjXSOalUbo5ubZRiB+qBXvaghsPvdY1jbZkE8W6tayLkwOjifPPB74Pf/VX8f5HPgKW/JyEEKIVSfDSqHrNSxxsRJFqbibcE4yV4qxLeyouCG5YLXhJd8+7LcuW58Gtt8b7t9wiwYsQQrQo6TZq1LSaF2DBuo5GJ4OXjnSTiwXW612ky0gIIcTyJsFLo3QDXdMwiYOWhQpeavUuXU0HL5MjjaRYVwghxDInwUuj9LinzdIng5cFGi49UpzMvDSzkjTISCMhhBDnDQleGlULXpjsNlqg4KWWeelsJvMS+lCdiPcleBFCCLHMSfDSqEXIvFT9kJIbB0Md6SaXBVAKrARY81sYUgghhDjXSfDSKN0AwNQWrualVqybTZg4ptH4E0zvMmpmWQEhhBCihchQ6UbVu40WLvNSH2nUbL1LaTi+lS6j03McuPvuqX0hhBAtSYKXRk0GL6YWgYoWJPMyr3oXkGLduTJNeNvblroVQggh5km6jRo1GbzEs+xGC5t5keBFCCGEOCPJvDSqFrxMm2V3vmrBS1NzvCg1tZq0BC+n5/tw553x/vbtMsOuEEK0KAleGqXroOkYuoaxAMFLEEZMVHygycxLdQLCIC4kTrTPqy3LnufBBz8Y77/nPRK8CCFEi5Juo2ZMriytLcDK0mNlH6XAsXTS9jxGGiU74sBKCCGEWObk264Z09Y3mm/mZXqXkdbMMGdZFkAIIcR5RoKXZixg8DJSdAHoTDc5dFeKdYUQQpxnJHhpRi14Yf7dRiO1zEtGRhoJIYQQcyHBSzMma170BSjYnddII5DgRQghxHlHgpdm6CaGNv+C3TBSjJfjkUZNTVDnV8ArxfupzqbbIYQQQrQSGSrdjAWqeRkre0RKYZs6GaeJt6KWdXGyYMp092fkOPD1r0/tCyGEaEkSvDRjWvASRoogjDCNxpNY8x9pJF1GDTHNeH4XIYQQLU26jZox2W2kqxBofmXpkaKsaSSEEEI0SoKXZhgmmqZh6/NbWXp03iONZI6XhgQBfOMb8RYES90aIYQQTZJuo2ZMrm807+BlcjXpjtR8My9SrDsnrgvvfW+8XyzG3UhCCCFajmRemjEZvDiaAsBtInhRSjExn+AlCqEyHu9L5kUIIcR5RIKXZpyQefGbqHnJVwP8UGHoGm3JJhYIrIyBisC049FGQgghxHlCgpdm6PECipY22W3URPAyPpl1aU9Z6Po8Rxo1M1JJCCGEaFESvDRjAWpeasW67fOud5EuIyGEEOcXCV6aMRm8mFrzwUt9Zt1mg5fKWHyb7GjufCGEEKJFSfDSjFrmZR7By1TmpYl6F5gq1pXgRQghxHlGxoo2Y7LmxdYjiJobbTRWnucEddXx+DbR3tz55yPbhi9/eWpfCCFES5LgpRmTmRdrcqh01Q8bOt0LIgrVeJK0poKXMAC3EO8n2xs//3xlWXDLLUvdCiGEEPMk3UbNqBfsxkFLNWgseBmvxFmXpG2QsIzGX786AUqBYYGVavx8IYQQooVJ5qUZ9Unq4u6iitdYt9FYKS7W7Wi23qXWZZRsl2HSjQgC+P734/03v1lm2BVCiBYln97NqHcbxUFLo91GY/NdFqBWrCv1Lo1xXfhX/yrel+UBhBCiZUm3UTNqBbu1zEuDwUttgrqOpot1a8Ok25s7XwghhGhhErw0Q4+7e6bP8xJGas6nj5Xn2W1Uz7zIMGkhhBDnn0ULXkZHR9m+fTu5XI729nY+9KEPUSwWT3vO4OAgv/zLv0x/fz/pdJqrrrqK//t//+9iNbF59UnqwnrJyVy7jpRS9W6jpmfXnV7zIoQQQpxnFi142b59Oy+88AL33nsvd999Nw899BAf+chHTnvOr/zKr7Br1y6+/e1v89xzz/GLv/iLvPe97+Wpp55arGY2ZzJ40VWIY8ZdSHMNXspeiOtHaBq0N7Mgo1IyQZ0QQojz2qIELzt37uSee+7hr//6r7n++ut53etexxe/+EXuuusujhw5Mut5P/7xj/l3/+7fcd1117FhwwZ+7/d+j/b2dp588snFaGbzJmteiAISVvwjnGvdSy3rkk1YmEYTP36/DKEfjzJyco2fL4QQQrS4RQleHn30Udrb27nmmmvq9910003ous5jjz0263k33HAD/+f//B9GR0eJooi77rqLarXKG97whlnPcV2XfD4/Y1t0k5kXopCkGf8Iq/7chkuPL1S9i5MFQ0bLCCGEOP8syrff4OAgvb29M1/INOns7GRwcHDW877+9a/zvve9j66uLkzTJJVK8c1vfpNNmzbNes4dd9zBH/7hHy5Y2+ekFrwoRXJyd67dRvMfJj050kiGSTfOtuF//I+pfSGEEC2poczLbbfdhqZpp91eeumlphvz2c9+lvHxcX7wgx/wxBNP8Du/8zu8973v5bnnnpv1nNtvv52JiYn6dvDgwaZff870qZiv8eBlMvMy3zWNpFi3cZYFH/1ovFlNZr6EEEIsuYYyL5/85Ce55Qxrw2zYsIH+/n6GhoZm3B8EAaOjo/T395/yvD179vA//sf/4Pnnn+fiiy8G4PLLL+dHP/oRf/EXf8Ff/uVfnvI8x3FwHKeRy5g/3YhrTpQiadQmqptrt1Et89Ls7LqT3WKJtubOF0IIIVpcQ8FLT08PPT09Zzxu27ZtjI+P8+STT3L11VcDcP/99xNFEddff/0pzymXywDo+sxkkGEYRFHjqzYvKk2LA5gwqGde5lKwG0WqXvPS9DBpdzJ4kWLdxoUh/OhH8f7P/AwYTawrJYQQYsktSsHuhRdeyFve8hY+/OEPs2PHDh555BFuvfVW3v/+9zMwMADA4cOH2bp1Kzt27ABg69atbNq0iV//9V9nx44d7Nmzh//yX/4L9957L7/wC7+wGM2cn8muo4Qx95WlC9WAMFKYukbWabLcqJ55keClYdUq/NzPxVu1utStEUII0aRFm+flzjvvZOvWrdx4443cfPPNvO51r+Ov/uqv6o/7vs+uXbvqGRfLsvjud79LT08Pb3/727nsssv4u7/7O7761a9y8803L1Yzm3dC8DKXzEttNen2lIWuN7GgolLgTsT7knkRQghxnlq0sbadnZ187Wtfm/XxdevWodTMKfU3b958bs6oeyqTwUtyMnhx5xC8TFTiLqNcM5PTAfgVCIN4X4IXIYQQ5ylZ26hZk8GLo8+9YLcWvLQ1G7y4hfjWTskcL0IIIc5bErw0a3KW3YQxtbL0iZmkE80/eJFiXSGEEEKCl2bVu43if4aROmP2Zd7BixTrCiGEEBK8NG0yeDEISdpxBFPyglkPV2pqmHTzmRcp1hVCCCGkcKJZ+mQAEgWkbYOKF1JyA7ozp54wzw0ivCDOzDRdsFureZHgpTmWBX/2Z1P7QgghWpIEL82atrJ02jEZLnqU3NlHHNW6jNKOgdXMatIg3UbzZdvwqU8tdSuEEELMk3QbNWvaytIpO94/XbfRvOtdQAp2hRBCCCTz0rx68BKQmZwtt+QuYvASReAW433JvDQnDOGnP433r7pKlgcQQogWJcFLs6YFLylnsmD3dN1G5XlOUOcVQEWg6WClm3uO8121CtddF+8Xi5CWn6MQQrQi6TZqVq3mJfTnlHkZn8y8tCebXZCxVqybBV3eNiGEEOcv+RZs1rSal2wi3s9X/VkPHyvF6xp1pGWOFyGEEGI+JHhp1rRuo1wiDkiKbrxq9Im8IKI4mZXpSDWbeZFiXSGEEAIkeGmeMTXPS8o2MHUNpaBYPbnraLwcZ11StkHCarJItJZ5cbLNnS+EEEIsExK8NGvaPC+aptULcU/VdTQ2WazbdNYFoDo5u26irfnnEEIIIZYBCV6aNa3mBSCXjP9dGxI93ehkvUt7ah5zvFTH41sJXoQQQpznZKh0s6bVvAD1updTBS+1bqPOdJOZF6WmZV7am3sOES8J8LnPTe0LIYRoSRK8NOuE4KVjMjCpZVmmq3UbtTfbbeRXIJwMimS0UfNsG/7gD5a6FUIIIeZJuo2aVQ9e4qCia5bgRSnF2GTmpaPZbqNa1sVOTxUKCyGEEOcpybw0q16wG9e81DIv42WfMFIYugZAwQ3wgghd05pfGqA2TFrqXeYnimDnznj/wgtlsj8hhGhRErw064Ruo6xjYps6XhAxXvboyjgADOWrAHRnbcymV5OWkUYLolKBSy6J92V5ACGEaFnyp2ez9Kl5XgA0TasX5B4vuvXDjozHwUtfNtH8a0nwIoQQQtRJ8NKsEzIvAP1tcYBydKJav2/fSAmANV2p5l9LghchhBCiToKXZk2bpK5moC0JwNHJbMtE2Wek6KFrGms65xO8jMe3ErwIIYQQErw0bfokdSpez2hlRxJNg2P5Kvmqz87BfP3+ppcFmDHHiwQvQgghhAQvzaoFL0qBigDIOCYr2+PsywMvDfH0wXEALloxj7lZgioEk8OvJXgRQgghJHhpmj5toFY4Navudes7AXj1eImKF+JYOpv7Ms2/Tn2Ol5TM8SKEEEIgQ6Wbpxug6XHWJfKBuFh3bVeat1zSz7OHxokU3LCxC6vZIdIgXUYLybLg3//7qX0hhBAtSYKXZmkaGGbcpRPOXM/owhU5LpxPV9F0ErwsHNuG//yfl7oVQggh5km6jebjhLleFkVVZtcVQgghppPMy3zUalDCk1eSXjAyTHrhRBEcOBDvr1kjywMIIUSLkuBlPk5YnHFR1LqNHAle5q1SgfXr431ZHkAIIVqW/Ok5H2cj81JflHGBamiEEEKIFifBy3zoixy8hD74k0sNOBK8CCGEECDBy/zUMi+L1W1UK9Y1bTCdxXkNIYQQosVI8DIftZqXcJFGG7m1epdcPDRbCCGEEBK8zMtiZ17cQnwrXUZCCCFEnQQv82HY8e1i1bxUpVhXCCGEOJEMlZ6PxR4qXRtp5GQX5/nPN6YJv/VbU/tCCCFaknyCz0d9qPRi1bxIt9GCchz4i79Y6lYIIYSYJ+k2mg/9LI02km4jIYQQok4yL/OxmJPUKTVztJGYP6VgeDje7+6WEVxCCNGiJHiZj/pQ6UUIXoLqVHeU1LwsjHIZenvjfVkeQAghWpZ0G83HYg6VrnUZ2amp1xFCCCGEBC/zspjLA8hIIyGEEOKUJHiZD2MRh0rXgxepdxFCCCGmk+BlPvRFHCpdH2nUtvDPLYQQQrQwCV7mozbD7qJmXqTbSAghhJhOgpf5WMyh0jJBnRBCCHFKMlR6PurLAyxmt5EELwvGNOEDH5jaF0II0ZLkE3w+6kOlw3jTjYV53iialnmRbqMF4zjwla8sdSuEEELMk3QbzYc+bf6Vhew68kugongGWFuCFyGEEGI6CV7mQzempphfyKLd+gR1GdDlLVowSkGpFG9KLXVrhBBCNEm+GedD0xZniQBX6l0WRbkMmUy8lctL3RohhBBNkuBlvup1LwtYtCsjjYQQQohZSfAyX7W5XkJv4Z5TRhoJIYQQs5LgZb7qc70sYPDiTsS3jsyuK4QQQpxIgpf5Mpz4dkFrXmSYtBBCCDEbCV7mq9ZtFLgL95zSbSSEEELMSoKX+VroJQLCALxSvC8Fu0IIIcRJZIbd+Vrogt3aMGnDBCu5MM8pYoYB//pfT+0LIYRoSRK8zNdiBS9O29QEeGJhJBLwjW8sdSuEEELMk3QbzddCdxtVxuLbZPvCPJ8QQgixzEjwMl9mbbTRAmVe6sFLx8I8nxBCCLHMSPAyXwvdbVQZj28T7QvzfGJKqRR3xWlavC+EEKIlSfAyXws9SZ1kXoQQQojTkuBlvhYy86KUBC9CCCHEGSxa8DI6Osr27dvJ5XK0t7fzoQ99iGKxeNpz9uzZw7ve9S56enrI5XK8973v5dixY4vVxIWxkMGLX44LfzUNErI0gBBCCHEqixa8bN++nRdeeIF7772Xu+++m4ceeoiPfOQjsx5fKpV405vehKZp3H///TzyyCN4nsfb3/52oiharGbO30KONqplXZxsPM+LEEIIIU6yKN+QO3fu5J577uHxxx/nmmuuAeCLX/wiN998M5///OcZGBg46ZxHHnmEffv28dRTT5HLxTPLfvWrX6Wjo4P777+fm266aTGaOn8LmXmRLiMhhBDijBYl8/Loo4/S3t5eD1wAbrrpJnRd57HHHjvlOa7romkajuPU70skEui6zsMPPzzra7muSz6fn7GdVQsavIzHtzLSSAghhJjVogQvg4OD9Pb2zrjPNE06OzsZHBw85Tmvec1rSKfTfOYzn6FcLlMqlfj3//7fE4YhR48enfW17rjjDtra2urb6tWrF/RazqgevPhxwe18SOZlcRkG3HxzvMnyAEII0bIaCl5uu+02NE077fbSSy811ZCenh6+8Y1v8J3vfIdMJkNbWxvj4+NcddVV6Prszbz99tuZmJiobwcPHmzq9ZtWC16Umn/diwQviyuRgH/+53hLJJa6NUIIIZrUUM3LJz/5SW655ZbTHrNhwwb6+/sZGhqacX8QBIyOjtLf3z/ruW9605vYs2cPw8PDmKZJe3s7/f39bNiwYdZzHMeZ0dV01hlWPDpIqbjryLSbex6loDwS76c6F659QgghxDLTUPDS09NDT0/PGY/btm0b4+PjPPnkk1x99dUA3H///URRxPXXX3/G87u7u+vnDA0N8Y53vKORZp5dmga6GWdd5lP34pUgcOPnk8yLEEIIMatFqXm58MILectb3sKHP/xhduzYwSOPPMKtt97K+9///vpIo8OHD7N161Z27NhRP+/LX/4yP/nJT9izZw9///d/z3ve8x4+8YlPsGXLlsVo5sKZXvfSrMpofOvkpoZfi4VVKkE6HW+yPIAQQrSsRZtM5M477+TWW2/lxhtvRNd13v3ud/OFL3yh/rjv++zatYtyuVy/b9euXdx+++2Mjo6ybt06fvd3f5dPfOITi9XEhWM6ceYkdJt/jnqXUdfCtEmc2rTfNyGEEK1JU2q+Q2TOLfl8nra2NiYmJurzxSy6J/4WCsfg0vdA96bmnmP3fXBwB6y6Bja/cWHbJ2KlEmQy8X6xGGdghBBCnBMa+f6WtY0Wgjk5cmVemZfJbiMp1hVCCCFOS4KXhVCreQnmEbzUal6SErwIIYQQpyPBy0KoZV6aDV6icGp2Xal5EUIIIU5LgpeFYE7OM9Nst1FlHFQUjzJysgvWLCGEEGI5kqWLF8J8u42mT06naQvTJnEyXYfXv35qXwghREuS4GUhzLfbSOpdzo5kEn74w6VuhRBCiHmSPz8XgjnPlaVljhchhBBiziR4WQj1zEu1ufNlmLQQQggxZxK8LIQFq3mRzMuiKpWgpyfeZHkAIYRoWVLzshDqo42a6DbyK/EGUvNyNgwPL3ULhBBCzJNkXhbCfLqNalkXJztVOyOEEEKIWUnwshDq3UYeNLpUVL3eRbqMhBBCiLmQ4GUh1DIvKoLQb+zc6XO8CCGEEOKMJHhZCIY1Nblco7PsViTzIoQQQjRCgpeFoGkzu44aUes2SnYsbJuEEEKIZUpGGy0UMxEPlW6kaDeKoDIW70vmZfHpOlxzzdS+EEKIliTBy0Kpz7LbQLdRdTxeUVo3IdG2KM0S0yST8PjjS90KIYQQ8yR/fi6UZtY3qmddOmRBRiGEEGKOJHhZKMbkRHWNBC+1kUYyOZ0QQggxZxK8LBRzHsGL1LucHeUyrFsXb+XyUrdGCCFEk6TmZaFYyfg2qMz9HFmQ8exSCvbvn9oXQgjRkiTzslBqwYvfSPAimRchhBCiURK8LBSzFrzMsTsicMGbXNlYal6EEEKIOZPgZaHUMy9znOellnWx02AlFqdNQgghxDIkwctCqQUgc828SL2LEEII0RQJXhaKlYpv5zrDrtS7CCGEEE2R0UYLpTZJnV+JR7KcadI5WZDx7NM0uOiiqX0hhBAtSYKXhVLLvEQhhP7UcgGzkQnqzr5UCl54YalbIYQQYp6k22ihGBboRrx/proXpaYtDSDBixBCCNEICV4WiqZNm6juDHUv1QkIgzjYSbQvetOEEEKI5USCl4VkznHEUb3LqAN0eQvOmnIZLr443mR5ACGEaFlS87KQanUvZ5plV4ZJLw2l4MUXp/aFEEK0JPmzfyHZ6fi2NnPubGSYtBBCCNE0CV4WkpOJb93C6Y+T4EUIIYRomgQvC8meDF5Ol3lRCkrH4/10z+K3SQghhFhmJHhZSPXgpTj7MV4pronRNMm8CCGEEE2Q4GUhOXPIvNSyLsmOeG4YIYQQQjRERhstJHsONS+l4fg23b347REzaRqsXTu1L4QQoiVJ8LKQasFL4MZLBJwqsyL1LksnlYJ9+5a6FUIIIeZJuo0WkumAPhkPzlb3IsGLEEIIMS8SvCwkTYNELt6v5k9+XEYaCSGEEPMmwctCq61VVFt4cbrqRNydpBtxwa44uyoVuPbaeKucYRZkIYQQ5yypeVloyfb4tjp+8mO1Yt1U59QK1OLsiSJ44ompfSGEEC1JMi8LrZ55GT/5sdJQfCtdRkIIIUTTJHhZaLXuoFN1GxUng5dM39lrjxBCCLHMSPCy0E7XbVSUzIsQQggxXxK8LLRat5FfjZcBqPGrUBmN9yXzIoQQQjRNgpeFZtpgp+P98ujU/ROH4qHSqc6pZQSEEEII0TAJXhZDtj++LQxO3Te+P75tX3P22yOmdHfHmxBCiJYlwctiyK6IbwtHpu4bPxDfSvCydNJpOH483tLppW6NEEKIJknwshhyA/Ft/mh86xaheCzeb1u9NG0SQgghlgmZpG4x5AZA06E8Eg+ZPvZCXO+SG5haPkAIIYQQTZHMy2KwktC2Kt7f8wDs/3G8v/LqpWuTiJcEeMMb4k2WBxBCiJYlmZfF0n9pXOdyfFf8754LoO/ipW3T+S6K4MEHp/aFEEK0JMm8LJa+SyAzORldog223ByvOi2EEEKIeZHMy2LRdbjk3XD8Zei7KO5KEkIIIcS8SfCymJIdsOb6pW6FEEIIsaxIt5EQQgghWooEL0IIIYRoKdJtJM4vqdRSt0AIIcQ8SfAizh/pNJRKS90KIYQQ8yTdRkIIIYRoKRK8CCGEEKKlSPAizh/VKrztbfFWrS51a4QQQjRJal7E+SMM4bvfndoXQgjRkhYt8/LHf/zH3HDDDaRSKdrb2+d0jlKK3//932fFihUkk0luuukmXnnllcVqohBCCCFa0KIFL57n8Z73vIff/M3fnPM5f/Znf8YXvvAF/vIv/5LHHnuMdDrNm9/8ZqqS4hdCCCHEpEXrNvrDP/xDAL7yla/M6XilFP/9v/93fu/3fo93vvOdAPzd3/0dfX19fOtb3+L973//YjVVCCGEEC3knCnY3bt3L4ODg9x00031+9ra2rj++ut59NFHZz3PdV3y+fyMTQghhBDL1zkTvAwODgLQ19c34/6+vr76Y6dyxx130NbWVt9Wr169qO0UQgghxNJqqNvotttu4z/9p/902mN27tzJ1q1b59WoRtx+++38zu/8Tv3fExMTrFmzRjIw4mTTZ9fN52XEkRBCnENq39tKqTMe21Dw8slPfpJbbrnltMds2LChkaes6+/vB+DYsWOsWLGifv+xY8e44oorZj3PcRwcx6n/u3bxkoERpzUwsNQtEEIIcQqFQoG2trbTHtNQ8NLT00NPT8+8GjWb9evX09/fz3333VcPVvL5PI899lhDI5YGBgY4ePAg2WwWTdMWtI35fJ7Vq1dz8OBBcrncgj73uWC5Xx8s/2uU62t9y/0a5fpa32Jdo1KKQqHAwBz+uFy00UYHDhxgdHSUAwcOEIYhTz/9NACbNm0ik8kAsHXrVu644w7e9a53oWkaH//4x/mP//E/snnzZtavX89nP/tZBgYG+IVf+IU5v66u66xatWoRrmhKLpdbtr+UsPyvD5b/Ncr1tb7lfo1yfa1vMa7xTBmXmkULXn7/93+fr371q/V/X3nllQA88MADvOENbwBg165dTExM1I/59Kc/TalU4iMf+Qjj4+O87nWv45577iGRSCxWM4UQQgjRYhYtePnKV75yxjleTizK0TSNP/qjP+KP/uiPFqtZQgghhGhx58xQ6VbgOA6f+9znZhQILyfL/fpg+V+jXF/rW+7XKNfX+s6Fa9TUXMYkCSGEEEKcIyTzIoQQQoiWIsGLEEIIIVqKBC9CCCGEaCkSvAghhBCipUjwMkd/8Rd/wbp160gkElx//fXs2LFjqZt0Sg899BBvf/vbGRgYQNM0vvWtb814XCnF7//+77NixQqSySQ33XQTr7zyyoxjRkdH2b59O7lcjvb2dj70oQ9RLBZnHPPss8/yMz/zMyQSCVavXs2f/dmfLfalAfFCnNdeey3ZbJbe3l5+4Rd+gV27ds04plqt8tGPfpSuri4ymQzvfve7OXbs2IxjDhw4wNve9jZSqRS9vb186lOfIgiCGcf88Ic/5KqrrsJxHDZt2nTGof8L5Utf+hKXXXZZfQKobdu28b3vfa/+eKtf34n+9E//tD5JZU0rX+Mf/MEfoGnajG36em+tfG3THT58mH/7b/8tXV1dJJNJLr30Up544on64638WbNu3bqT3kNN0/joRz8KtP57GIYhn/3sZ1m/fj3JZJKNGzfyH/7Df5gxfck5//4pcUZ33XWXsm1b/e3f/q164YUX1Ic//GHV3t6ujh07ttRNO8l3v/td9bu/+7vqn/7pnxSgvvnNb854/E//9E9VW1ub+ta3vqWeeeYZ9Y53vEOtX79eVSqV+jFvectb1OWXX65+8pOfqB/96Edq06ZN6pd+6Zfqj09MTKi+vj61fft29fzzz6t/+Id/UMlkUv2v//W/Fv363vzmN6svf/nL6vnnn1dPP/20uvnmm9WaNWtUsVisH/Mbv/EbavXq1eq+++5TTzzxhHrNa16jbrjhhvrjQRCoSy65RN10003qqaeeUt/97ndVd3e3uv322+vHvPrqqyqVSqnf+Z3fUS+++KL64he/qAzDUPfcc8+iX+O3v/1t9c///M/q5ZdfVrt27VL/3//3/ynLstTzzz+/LK5vuh07dqh169apyy67TH3sYx+r39/K1/i5z31OXXzxxero0aP17fjx48vi2mpGR0fV2rVr1S233KIee+wx9eqrr6rvf//7avfu3fVjWvmzZmhoaMb7d++99ypAPfDAA0qp1n8P//iP/1h1dXWpu+++W+3du1d94xvfUJlMRv35n/95/Zhz/f2T4GUOrrvuOvXRj360/u8wDNXAwIC64447lrBVZ3Zi8BJFkerv71f/+T//5/p94+PjynEc9Q//8A9KKaVefPFFBajHH3+8fsz3vvc9pWmaOnz4sFJKqf/5P/+n6ujoUK7r1o/5zGc+o7Zs2bLIV3SyoaEhBagHH3xQKRVfj2VZ6hvf+Eb9mJ07dypAPfroo0qpOMDTdV0NDg7Wj/nSl76kcrlc/Zo+/elPq4svvnjGa73vfe9Tb37zmxf7kk6po6ND/fVf//Wyur5CoaA2b96s7r33XvX617++Hry0+jV+7nOfU5dffvkpH2v1a6v5zGc+o173utfN+vhy+6z52Mc+pjZu3KiiKFoW7+Hb3vY29au/+qsz7vvFX/xFtX37dqVUa7x/0m10Bp7n8eSTT3LTTTfV79N1nZtuuolHH310CVvWuL179zI4ODjjWtra2rj++uvr1/Loo4/S3t7ONddcUz/mpptuQtd1HnvssfoxP/uzP4tt2/Vj3vzmN7Nr1y7GxsbO0tXEastLdHZ2AvDkk0/i+/6Ma9y6dStr1qyZcY2XXnopfX199WPe/OY3k8/neeGFF+rHTH+O2jFn+z0Pw5C77rqLUqnEtm3bltX1ffSjH+Vtb3vbSe1YDtf4yiuvMDAwwIYNG9i+fTsHDhwAlse1AXz729/mmmuu4T3veQ+9vb1ceeWV/O///b/rjy+nzxrP8/j7v/97fvVXfxVN05bFe3jDDTdw33338fLLLwPwzDPP8PDDD/PWt74VaI33T4KXMxgeHiYMwxm/hAB9fX0MDg4uUauaU2vv6a5lcHCQ3t7eGY+bpklnZ+eMY071HNNf42yIooiPf/zjvPa1r+WSSy6pv75t27S3t5/UvkbaP9sx+XyeSqWyGJczw3PPPUcmk8FxHH7jN36Db37zm1x00UXL5vruuusufvrTn3LHHXec9FirX+P111/PV77yFe655x6+9KUvsXfvXn7mZ36GQqHQ8tdW8+qrr/KlL32JzZs38/3vf5/f/M3f5Ld/+7fr69ktp8+ab33rW4yPj3PLLbfUX7fV38PbbruN97///WzduhXLsrjyyiv5+Mc/zvbt22e08Vx+/xZtbSMhFttHP/pRnn/+eR5++OGlbsqC27JlC08//TQTExP84z/+Ix/4wAd48MEHl7pZC+LgwYN87GMf4957712Wi67W/noFuOyyy7j++utZu3YtX//610kmk0vYsoUTRRHXXHMNf/InfwLEC+8+//zz/OVf/iUf+MAHlrh1C+tv/uZveOtb38rAwMBSN2XBfP3rX+fOO+/ka1/7GhdffDFPP/00H//4xxkYGGiZ908yL2fQ3d2NYRgnVZIfO3aM/v7+JWpVc2rtPd219Pf3MzQ0NOPxIAgYHR2dccypnmP6ayy2W2+9lbvvvpsHHniAVatW1e/v7+/H8zzGx8dPal8j7Z/tmFwud1a+gGzbZtOmTVx99dXccccdXH755fz5n//5sri+J598kqGhIa666ipM08Q0TR588EG+8IUvYJomfX19LX+N07W3t3PBBRewe/fuZfH+AaxYsYKLLrpoxn0XXnhhvXtsuXzW7N+/nx/84Af82q/9Wv2+5fAefupTn6pnXy699FJ++Zd/mU984hP1TGgrvH8SvJyBbdtcffXV3HffffX7oijivvvuY9u2bUvYssatX7+e/v7+GdeSz+d57LHH6teybds2xsfHefLJJ+vH3H///URRxPXXX18/5qGHHsL3/fox9957L1u2bKGjo2NRr0Epxa233so3v/lN7r//ftavXz/j8auvvhrLsmZc465duzhw4MCMa3zuuedm/Me79957yeVy9Q/kbdu2zXiO2jFL9Z5HUYTrusvi+m688Uaee+45nn766fp2zTXXsH379vp+q1/jdMVikT179rBixYpl8f4BvPa1rz1pioKXX36ZtWvXAsvjswbgy1/+Mr29vbztbW+r37cc3sNyuYyuz/z6NwyDKIqAFnn/5l3yex646667lOM46itf+Yp68cUX1Uc+8hHV3t4+o5L8XFEoFNRTTz2lnnrqKQWo//pf/6t66qmn1P79+5VS8fC39vZ29f/+3/9Tzz77rHrnO995yuFvV155pXrsscfUww8/rDZv3jxj+Nv4+Ljq6+tTv/zLv6yef/55ddddd6lUKnVWhkr/5m/+pmpra1M//OEPZwxlLJfL9WN+4zd+Q61Zs0bdf//96oknnlDbtm1T27Ztqz9eG8b4pje9ST399NPqnnvuUT09PaccxvipT31K7dy5U/3FX/zFWRvGeNttt6kHH3xQ7d27Vz377LPqtttuU5qmqX/5l39ZFtd3KtNHGynV2tf4yU9+Uv3whz9Ue/fuVY888oi66aabVHd3txoaGmr5a6vZsWOHMk1T/fEf/7F65ZVX1J133qlSqZT6+7//+/oxrf5ZE4ahWrNmjfrMZz5z0mOt/h5+4AMfUCtXrqwPlf6nf/on1d3drT796U/XjznX3z8JXuboi1/8olqzZo2ybVtdd9116ic/+clSN+mUHnjgAQWctH3gAx9QSsVD4D772c+qvr4+5TiOuvHGG9WuXbtmPMfIyIj6pV/6JZXJZFQul1Mf/OAHVaFQmHHMM888o173utcpx3HUypUr1Z/+6Z+eles71bUB6stf/nL9mEqlon7rt35LdXR0qFQqpd71rnepo0ePznieffv2qbe+9a0qmUyq7u5u9clPflL5vj/jmAceeEBdccUVyrZttWHDhhmvsZh+9Vd/Va1du1bZtq16enrUjTfeWA9clGr96zuVE4OXVr7G973vfWrFihXKtm21cuVK9b73vW/G/CetfG3Tfec731GXXHKJchxHbd26Vf3VX/3VjMdb/bPm+9//vgJOarNSrf8e5vN59bGPfUytWbNGJRIJtWHDBvW7v/u7M4Y0n+vvn6bUtCn1hBBCCCHOcVLzIoQQQoiWIsGLEEIIIVqKBC9CCCGEaCkSvAghhBCipUjwIoQQQoiWIsGLEEIIIVqKBC9CCCGEaCkSvAghhBCipUjwIoQQQoiWIsGLEEIIIVqKBC9CCCGEaCkSvAghhBCipfz/Aegvdy9KifFKAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(log_posts.T, alpha=0.5)\n", + "plt.axvline(N_warmup, color=\"red\", linestyle=\"--\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All good so far!\n", + "\n", + "Now we can look at the Rhat (Gelman-Rubin) statistic for the log posteriors values (which serves as a good univariate summary statistic as opposed to any individual dimension), which we calculated in the loop with `pyro`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "k = 1000\n", + "plt.plot(torch.arange(N_warmup + k, N_steps), gelman_rubin[k:])\n", + "plt.axhline(1.05, color=\"black\", linestyle=\"--\")\n", + "plt.title(\"Gelman-Rubin (Rhat) Statistic\")\n", + "plt.xlabel(\"Iteration\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[According to the Stan documentation an Rhat of below 1.05 is considered good for convergence](https://mc-stan.org/rstan/reference/Rhat.html), so we're looking good!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we'll inspect the marginal distributions of the parameters to check nothing looks too crazy." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 4, figsize=(12, 6))\n", + "\n", + "for ind, ax in enumerate(axes.flatten()):\n", + " ax.hist(samples[:, N_warmup:, ind].flatten(), bins=50, density=True)\n", + " ax.set_title(column_names[ind])\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This looks reasonable enough, as the samples are well distributed within their domains which are clearly removed from the initial value of 0." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}