From fe1393fcd1761bf2b0e2d207d8da5e1d350dfd93 Mon Sep 17 00:00:00 2001 From: N_T Date: Mon, 9 Dec 2024 10:31:53 +0800 Subject: [PATCH] added references, minor typos, TOC, todo: move dppm to ddpm notebook --- _toc.yml | 17 +- diffphys-code-ns.ipynb | 2 +- probmodels-ddpm-fm.ipynb | 1148 ++++++++++++++++++++++++++++++++++++ probmodels-dppm-fm.ipynb | 1148 ------------------------------------ references.bib | 35 ++ resources/pbdl-figures.key | Bin 8018109 -> 8169534 bytes 6 files changed, 1194 insertions(+), 1156 deletions(-) create mode 100644 probmodels-ddpm-fm.ipynb diff --git a/_toc.yml b/_toc.yml index 13d096f..49e2032 100644 --- a/_toc.yml +++ b/_toc.yml @@ -10,10 +10,11 @@ parts: - file: overview-burgers-forw.ipynb - file: overview-ns-forw.ipynb - file: overview-optconv.md +- caption: Supervised Training + chapters: - file: supervised.md - sections: - - file: supervised-airfoils.ipynb - - file: supervised-discuss.md + - file: supervised-airfoils.ipynb + - file: supervised-discuss.md - caption: Physical Losses chapters: - file: physicalloss.md @@ -32,6 +33,12 @@ parts: - file: diffphys-code-sol.ipynb - file: diffphys-code-control.ipynb - file: diffphys-discuss.md +- caption: Probabilistic Learning + chapters: + - file: probmodels-intro.md + - file: probmodels-ddpm-fm.ipynb + - file: bayesian-intro.md + - file: bayesian-code.ipynb - caption: Reinforcement Learning chapters: - file: reinflearn-intro.md @@ -45,10 +52,6 @@ parts: - file: physgrad-hig.md - file: physgrad-hig-code.ipynb - file: physgrad-discuss.md -- caption: PBDL and Uncertainty - chapters: - - file: bayesian-intro.md - - file: bayesian-code.ipynb - caption: Fast Forward Topics chapters: - file: others-intro.md diff --git a/diffphys-code-ns.ipynb b/diffphys-code-ns.ipynb index 3807814..8dd6d7b 100644 --- a/diffphys-code-ns.ipynb +++ b/diffphys-code-ns.ipynb @@ -355,7 +355,7 @@ ], "source": [ "# neat phiflow helper function:\n", - "vis.plot(field.vec_length(velocity_grad)) # show magnitude" + "v = vis.plot(field.vec_length(velocity_grad)) # show magnitude" ] }, { diff --git a/probmodels-ddpm-fm.ipynb b/probmodels-ddpm-fm.ipynb new file mode 100644 index 0000000..a4dd102 --- /dev/null +++ b/probmodels-ddpm-fm.ipynb @@ -0,0 +1,1148 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "q4kVgOM2pyzJ" + }, + "source": [ + "# From DDPM to Flow Matching for Airfoil RANS Flows\n", + "\n", + "Ever wondered how to turn your existing _denoising diffusion code_ into a _flow matching_ approach? 🤔 Or what all the fuss regarding diffusion models was about in the first place? 🧐 That's exactly what this notebook is focusing on 😎\n", + "\n", + "We'll be using a learning task where we can reliably generate arbitrary amounts of ground truth data, to make sure we can quantify how well the target distribution was learned. Specifically, we'll focus on Reynolds-averaged Navier-Stokes simulations around airfoils, which have the interesting characteristic that typical solvers (such as OpenFoam) transition from steady solutions to oscillating ones for larger Reynolds numbers. This transition is exactly what we'll give as a task to diffusion models below. (Details can be found in our [diffuion-based flow prediction repository](https://github.com/tum-pbs/Diffusion-based-Flow-Prediction/).)\n", + "\n", + "# Intro\n", + "\n", + "Diffusion models have been rising stars in the deep learning field in the past years, and have made it possible to train powerful generative models with surprisingly simple and robust training setups. Within this sub-field of deep learning, a very promising new development are flow-based approaches, typically going under names such as _flow matching_ {cite}`lipman2022flow` and _rectified flows_ {cite}`liu2022rect` . We'll stick to the former here for simplicity, and denote this class of models with _FM_.\n", + "\n", + "For the original diffusion models, especially the _denoising_ tasks were extremely successful: a neural network learns to restore a signal from pure noise. Score functions provided an alternate viewpoint, but ultimately also resulted in denoising tasks. Instead, flow-based approaches aim for transforming distributions. The goal is to transform a known one, such as gaussian noise, into one that represents the distribution of the signal or target function we're interested in. Despite these seemingly different viewpoints, all viewpoints above effectively do the same: starting with noise, they step by step turn it into samples for our target signal. Interestingly, the FM-perspective is not only more stable at training time, it also speeds up inference by orders of magnitude thanks to yielding straighter paths. And even better: if you have a working DM setup, it's surprisingly simple to turn it into an FM one.\n", + "\n", + "Below, we'll highlight the simiarities and differences, and evaluate both methods with the RANS-based flow setup outlined above.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "32daES8LGs6v" + }, + "source": [ + "# Problem statement\n", + "\n", + "Instead of the previous supervised learning tasks, we'll need to consider distributions. For \"classic\" supervised tasks, we have unique input-output pairs $(x,y)$ and train a model to provide $y$ given $x$ based on internal parameters $\\theta$, i.e. $y=f(x;\\theta)$.\n", + "\n", + "In contrast, let's assume there is _some_ hidden state $\\psi$, that varies for a single $x$. This could e.g. be measurement noise, the starting point of an optimization for inverse problems, or the non-converging solution of a RANS solver (our scenario here). Now we can phrase our problem in terms of random variable $Y$, and our solution is drawn from the distribution $y \\sim P_Y(Y)$ that we typically specify as a marginalized distribution, in terms of samples with varying $\\psi$ for any given $x$. From a probabilistic perspective, it is important to capture the conditional probabilty of our solutions, i.e. $p(y|x)$, where we marginalize over $\\psi$. (We don't need to know about the specifics of $\\psi$ in practice.)\n", + "\n", + "This conditional distribution $p(y|x)$, the _posterior_, is exactly what our generative model should learn: when we repeatedly evaluate our model, it should give us samples from the posterior with the right probabilities. And it should do so efficiently, without wasting computations...\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AVmsZmUsGwkR" + }, + "source": [ + "# Implementation and Setup\n", + "\n", + "First, we need to install the required packages and clone the repository:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KtHsiFscpyzN", + "outputId": "980dbf3a-54ab-441c-de05-3f95729a88e7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/thuerey/jupyter/Diffusion-based-Flow-Prediction\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/thuerey/anaconda3/envs/torch24/lib/python3.12/site-packages/IPython/core/magics/osm.py:417: UserWarning: This is now an optional IPython functionality, setting dhist requires you to install the `pickleshare` library.\n", + " self.shell.db['dhist'] = compress_dhist(dhist)[-100:]\n" + ] + } + ], + "source": [ + "%pip install --upgrade --quiet einops bayesian_torch\n", + "!git clone https://github.com/tum-pbs/Diffusion-based-Flow-Prediction.git\n", + "%cd Diffusion-based-Flow-Prediction/" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "geSEvam6vDxA" + }, + "source": [ + "We also need to prepare the training dataset. The one below can be generated with [OpenFoam](https://www.openfoam.com/\n", + "), but is downloaded below for convenience. The data structure and the `DataFiles` class that are used to organize the dataset come from the diffusion-based flow prediction repository, details can be found [here](https://github.com/tum-pbs/Diffusion-based-Flow-Prediction/blob/main/generate_dataset.ipynb) if you're interested.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cd-7RLz7pyzO", + "outputId": "ae8d07ab-8d2f-4d6e-90d1-4eb5d8bf2693" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using device: cuda:0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading data: 100%|██████████| 125/125 [00:00<00:00, 341.19it/s]\n" + ] + } + ], + "source": [ + "import zipfile\n", + "from airfoil_diffusion.airfoil_datasets import *\n", + "from airfoil_diffusion.networks import *\n", + "from airfoil_diffusion.trainer import *\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "print(\"Using device: \"+str(device))\n", + "\n", + "if not os.path.exists(\"./datasets/1_parameter/data/\"):\n", + " files=[file for file in os.listdir(\"./datasets/1_parameter/\") if file.endswith(\".zip\")]\n", + " for file in tqdm(files):\n", + " f=zipfile.ZipFile(\"./datasets/1_parameter/\"+file,'r')\n", + " for file in f.namelist():\n", + " f.extract(file,\"./datasets/1_parameter/data/\")\n", + " f.close()\n", + "\n", + "df_train=FileDataFiles(\"./datasets/1_parameter/train_cases.txt\",base_path=\"./datasets/1_parameter/data/\")\n", + "train_dataset = AirfoilDataset(df_train,data_size=32)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "I913Pn0opyzO" + }, + "source": [ + "Next, we'll implement the denoising diffusion model, so that we can compare with flow matching afterwards.\n", + "\n", + "------------------------\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PGf_5o2CFNC0" + }, + "source": [ + "## Denoising with Diffusion Models\n", + "\n", + "At it's core, the denoising task is as simple as the name implies: we learn to estimate the noise $\\epsilon$ by minimizing\n", + "$\n", + " \\parallel \\epsilon - f_\\theta(x,t) \\parallel^2\n", + "$,\n", + "the trick is primarily to carefully control the noise so that it can be learned easily.\n", + "\n", + "Note that for all equations here, we'll omit the $i$ subscript that previously denoted the different samples of a batch or dataset in {doc}`overview-equations`. Thus, we'll e.g. shorten $y_{i}$ to $y$, and leave out summations over $i$.\n", + "\n", + "To get started with denoising, we'll define a forward process that\n", + "adds noise to give a perfect\n", + "Gaussian distribution $\\mathcal{N}\\left(\\mathbf{0}, \\mathbf{I}\\right)$ at $t=1$.\n", + "It starts with a data sample $y$ at $t=0$, i.e. $\\mathcal{N}\\left(y, 0\\right)$ and then turns it into noise as $t$ increases. Note that the noising / denoising time $t$ is a _virtual_ one, it has no physical meaning.\n", + "The change of mean and standard deviation over time $t$ is controlled by a\n", + " _noise schedule_ $\\beta^t \\in (0,1)$, that gradually increases from $0$ to $\\beta^t=1$ at the end of the chain, where $t=1$.\n", + "\n", + "By choosing a Gaussian distribution, we can decouple the steps to give a Markov chain for the distribution $q$ of the form \n", + "$$\n", + " q\\left(y^{0:T}\\right) =\n", + " q(y^0) \\prod_{t=1}^{T} q\\left(y^{t} \\mid y^{t-1}\\right) ,\n", + "$$\n", + "where\n", + "$$\n", + " q\\left(y^{t} \\mid y^{t-1}\\right) = \\mathcal{N}\n", + " \\left( \\sqrt{1-\\beta^{t}} y^{t-1}, \\beta^{t} \\mathbf{I}\\right) .\n", + "$$\n", + "\n", + "It's fairly obvious that we can destroy any input signal $y$ by accumulating more and more noise. What's more interesting is\n", + "the reverse process that removes the noise, i.e. the denoising. We can likewise formulate a\n", + "reverse Markov chain for the distribution $p_\\theta$. The subscript already indicates that we'll learn the transition and parameterize it by a set or parameters $\\theta$:\n", + "$$\n", + " p_\\theta\\left(y^{0:T}\\right)\n", + " =\n", + " p(y^T)\n", + " \\prod_{t=1}^{T}\n", + " p_\\theta \\left(y^{t-1} \\mid y^{t}\\right)\n", + "$$\n", + "with\n", + "$$\n", + " y^{t} = \\sqrt{\\bar{\\alpha}^t} y^{0}\n", + " +\\sqrt{\\left(1-\\bar{\\alpha}^t\\right)}\\epsilon .\n", + "$$ (eq-yt)\n", + "\n", + "We can calculate the correct coefficients $\\alpha$ from the noise schedule of the forward chain via\n", + "$\\alpha^t = 1 - \\beta^t$ and $\\bar{\\alpha}^t = \\prod_{i=1}^t \\alpha^i$.\n", + "\n", + "Each step $p_\\theta \\left(y^{t-1} \\mid y^{t}\\right)$ along the way now has the specific form\n", + "$$\n", + " p_\\theta \\left(y^{t-1} \\mid y^{t}\\right) =\n", + " \\mathcal{N} \\left( \\mu(f_{\\theta}) , \\sigma_{\\theta} \\right)\n", + "$$ (eq-denoising-step) \n", + "where we're employing a neural network $f_\\theta$ to predict the noise. We could also call the network $\\epsilon_\\theta$ here, but for consistency we'll stick to $f_\\theta$. The noise inferred by our network parametrizes the mean\n", + "$$\n", + " \\mu(\\epsilon) =\n", + " \\frac{1}{\\sqrt{\\alpha^t}}\n", + " \\Big(\n", + " y^t - \\frac{\\beta^t}{\\sqrt{1 - \\bar{\\alpha}^t}} \\epsilon\n", + " \\Big) .\n", + "$$\n", + "The standard deviation interestingly does not depend on the noise (and our network), but evolves over time with\n", + "$$\n", + " \\sigma=\n", + " \\frac{1-\\bar{\\alpha}^{t-1}}\n", + " {1-\\bar{\\alpha}^{t}}\\beta^{t} \\mathbf{I}.\n", + "$$\n", + "\n", + "Thus, given a pair $x,y$, we can directly compute the right amount of noise for time $t-1$ and $t$, and generate $y^t$ and $y^{t-1}$. In practice, we're not only interested in retrieving an arbitrary $y$, but the one that corresponds to some global paramters like a chosen Reynolds number. These conditions, together with e.g. the shape of an airfoil are actually our $x$ from $f(x)=y$ at the top.\n", + "So, we'll also condition $f$ on $x$ to have the form $f_\\theta (y^t,x,t)$.\n", + "\n", + "In practice, we simply choose a time $t$, compute the right amount of noise $\\epsilon$, and let our network predict the noise given $y^t$ computed by linear interpolation with $\\bar{\\alpha}^t$, as given above in equation `ref`(eq-yt).\n", + "This gives the loss function:\n", + "$$\n", + " \\mathcal{L}_{\\text{DM}}(\\theta) = \\mathbb{E}_{x,\\epsilon \\sim\\mathcal{N}(\\mathbf{0},\\mathbf{I}),t }\n", + " \\left[ \\parallel \\epsilon - f_\\theta(y^t,x,t) \\parallel^2 \\right]\n", + "$$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wQBjN33OWsP_" + }, + "source": [ + "## Implementing DDPM\n", + "\n", + "We'll split the implementation into a helper class that computes the coefficients for the denoising schedule, and a trainer class that takes care of the training loop.\n", + "\n", + "The helper class is callsed `MyDiffuser` below, and starts by computing the beta coefficients for a so called _cosine-beta_ schedule.\n", + "It has the form $\\beta = cos\\big( (t/T+s)~/~(1+s) * \\pi/2 \\big)^2$.\n", + "The offset $s$ below is chosen such that the standard deviation of the $\\sqrt{\\beta}$ is smaller than the color step of $1/256$ for a typical RGB image. The `generate_parameters_from_beta()` function takes the precomputed list of `beta` coefficients, and turns them into PyTorch tensors, computing the correct `alpha` and `alpha_bar` values along the way.\n", + "\n", + "The class also implements a function `forward_diffusion()` that calculates forward diffusion step using the precomputed `alpha_bar` values, given an input $y$ and $t$. Hence, this function computes $y^t$ from above.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "yxF4ePQhW4Ol" + }, + "outputs": [], + "source": [ + "class MyDiffuser():\n", + " def __init__(self, steps, device):\n", + " self.device = device\n", + " self.steps = steps\n", + " self.name = \"Cos2ParamsDiffuser\"\n", + "\n", + " s = 0.008\n", + " tlist = torch.arange(1, self.steps+1, 1)\n", + " temp1 = torch.cos((tlist/self.steps+s)/(1+s)*np.pi/2)\n", + " temp1 = temp1*temp1\n", + " temp2 = np.cos(((tlist-1)/self.steps+s)/(1+s)*np.pi/2)\n", + " temp2 = temp2*temp2\n", + " self.beta_source = 1-(temp1/temp2)\n", + " self.beta_source[self.beta_source > 0.999] = 0.999\n", + " self.generate_parameters_from_beta()\n", + "\n", + "\n", + " def generate_parameters_from_beta(self):\n", + " self.betas = torch.cat( (torch.tensor([0]), self.beta_source), dim=0)\n", + " self.betas = self.betas.view(self.steps+1, 1, 1, 1)\n", + " self.betas = self.betas.to(self.device)\n", + "\n", + " self.alphas = 1-self.betas\n", + " self.alphas_bar = torch.cumprod(self.alphas, 0)\n", + " self.one_minus_alphas_bar = 1 - self.alphas_bar\n", + " self.sqrt_alphas = torch.sqrt(self.alphas)\n", + " self.sqrt_alphas_bar = torch.sqrt(self.alphas_bar)\n", + " self.sqrt_one_minus_alphas_bar = torch.sqrt(self.one_minus_alphas_bar)\n", + "\n", + "\n", + " def forward_diffusion(self, y0, t, noise):\n", + " yt = self.sqrt_alphas_bar[t]*y0+self.sqrt_one_minus_alphas_bar[t]*noise\n", + " return yt\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Cux8zWnzan7G" + }, + "source": [ + "Now we're ready to start training. The `MyDiffusionTrainer` class derives from a `Trainer` base class from the airfoil diffusion repository. This base class primarily handles parameters, book-keeping and a few other mundane tasks. Effectively, it makes sure we have a batch to train with, and then calls `train_step()`, which is the most interesting function below.\n", + "\n", + "It implements exactly the procedure outlines above: given a $y$, we compute noise, and $y^t$ with a forward step for a random $t$. Then we let our network predict the noise $\\epsilon$ from $y^t$, the condition $x$, and $t$. All that's left afterwards is to compute an MSE loss on the true noise versus the precicted one, and let PyTorch backpropagate the gradient to update the weights of our neural network." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "nwVvxlbsFIeO" + }, + "outputs": [], + "source": [ + "class MyDiffusionTrainer(TrainerStepLr):\n", + "\n", + " def __init__(self) -> None:\n", + " super().__init__()\n", + "\n", + " def set_configs_type(self):\n", + " super().set_configs_type()\n", + " self.configs_handler.add_config_item(\"diffusion_step\",value_type=int,default_value=200,description=\"The number of diffusion steps.\")\n", + "\n", + " def event_before_training(self,network):\n", + " self.diffuser = MyDiffuser(steps=self.configs.diffusion_step,device=self.configs.device)\n", + "\n", + " def train_step(self, network: torch.nn.Module, batched_data, idx_batch: int, num_batches: int, idx_epoch: int, num_epoch: int):\n", + " condition = batched_data[0].to(device=self.configs.device)\n", + " targets = batched_data[1].to(device=self.configs.device)\n", + " t = torch.randint(1, self.diffuser.steps+1,\n", + " size=(targets.shape[0],), device=self.configs.device)\n", + " noise = torch.randn_like(targets, device=self.configs.device)\n", + " yt = self.diffuser.forward_diffusion(targets, t, noise)\n", + " predicted_noise = network(yt, t, condition)\n", + " loss=torch.nn.functional.mse_loss(predicted_noise, noise)\n", + " return loss\n", + "\n", + "diffusion_trainer = MyDiffusionTrainer()\n", + "\n", + "dif_network = AifNet(\"./pre_trained/single_parameter/32/diffusion/network_configs.yaml\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_36M6WQyFSff" + }, + "source": [ + "At the end of the cell above we directly instantiate a trainer object, and initialiaze a neural network. The `AifNet` class implements a _state-of-the-art_ U-net with all the latest tricks for diffusion modeling, but in the end it's \"just a U-net\", and we'll skip the details here.\n", + "\n", + "More importantly, we can finally starting training our DDPM model. For that we can use the `train_from_scratch()` function of the trainer class, which we'll call in the next cell. The training with a default of 10000 steps can take a while, but shouldn't take much longer than half an hour on current GPUS. If you're not patient enough, feel free to skip this step and load one of the pre-trained models from our DBFP repository with the commented-out code at the bottom." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Fb8uPp9qFRvi", + "outputId": "7f82b6a0-26fa-488b-f996-ad266b4ad7a9" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Trainer created at 2024-11-05-03_25_26\n", + "Working path:./training/single_parameter/32/diffusion/2024-11-05-03_25_26/\n", + "Random seed: 1730773526\n", + "Training configurations saved to ./training/single_parameter/32/diffusion/2024-11-05-03_25_26/configs.yaml\n", + "Network has 1185218 trainable parameters\n", + "There are 5 training batches in each epoch\n", + "Batch size for training:25\n", + "Training epochs:10000\n", + "Total training iterations:50000\n", + "learning rate:0.0001\n", + "Optimizer:AdamW\n", + "Learning rate scheduler:step\n", + "Training start!\n", + " 0%| | 0/10000 [00:00 None:\n", + " super().__init__()\n", + "\n", + " def event_before_training(self,network):\n", + " self.flow_matcher = MyFlowMatcher()\n", + "\n", + " def train_step(self, network: torch.nn.Module, batched_data, idx_batch: int, num_batches: int, idx_epoch: int, num_epoch: int):\n", + " condition = batched_data[0].to(device=self.configs.device)\n", + " targets = batched_data[1].to(device=self.configs.device)\n", + " loss=self.flow_matcher.cfm_loss(network=network,x_1=targets,condition=condition)\n", + " return loss" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6klh2FfQFZCv" + }, + "source": [ + "Next we can instantiate a trainer object, and allocate a network. We're using a U-net that's identical to the one previously used for denoising, so that we can make a fair comparison between the two training methodologies." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "uY6BS0IRFYYr" + }, + "outputs": [], + "source": [ + "fmatching_trainer=MyFMTrainer()\n", + "\n", + "network = AifNet(\"./pre_trained/single_parameter/32/diffusion/network_configs.yaml\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "t10nHfJLyLK3" + }, + "source": [ + "\n", + "Now we can start training. Similar to before, this should take around half an hour for 10000 epochs, but if you want to skip this step, you can find code for loading one of the models from the github repo below.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sQ-lNvZSsGj9", + "outputId": "c3555bab-c5c3-4da3-c032-515aa1880b93" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Trainer created at 2024-11-05-03_56_06\n", + "Working path:./training/single_parameter/32/flowmatching/2024-11-05-03_56_06/\n", + "Random seed: 1730775366\n", + "Training configurations saved to ./training/single_parameter/32/flowmatching/2024-11-05-03_56_06/configs.yaml\n", + "Network has 1185218 trainable parameters\n", + "There are 5 training batches in each epoch\n", + "Batch size for training:25\n", + "Training epochs:10000\n", + "Total training iterations:50000\n", + "learning rate:0.0001\n", + "Optimizer:AdamW\n", + "Learning rate scheduler:step\n", + "Training start!\n", + "lr:1.000e-05 train loss:0.00430: 100%|██████████| 10000/10000 [30:44<00:00, 5.42it/s]\n", + "Training finished!\n" + ] + } + ], + "source": [ + "fmatching_trainer.train_from_scratch(name=\"flowmatching\",\n", + " network=network,\n", + " train_dataset=train_dataset,\n", + " path_config_file=\"./pre_trained/train_configs.yaml\",\n", + " save_path=\"./training/single_parameter/32/\", epochs=10000)\n", + "\n", + "# uncomment to load the checked in model\n", + "#network.load_state_dict(torch.load(\"./pre_trained/single_parameter/32/flow_matching/weight.pt\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ezZSMjpvgjbF" + }, + "source": [ + "We finally have to trained models that we can evaluate side by side.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZCGAEnlFpyzP" + }, + "source": [ + "# Test Evaluation\n", + "\n", + "To evaluate the trained models on inputs that weren't used for training we first need to download some more data. This is what happens in the next cell. \n", + "The `scale_factor=0.25` parameters of the `read_single_file()` function below make sure that we get fields of size $32 \\times 32$ like the ones in the training data set. However, the test set has previously unseen Reynolds numbers, so that we can check how well the model generalizes. While loading the data, the code also computes statistics for the ground truth mean and standard deviations (`mean_field_test_gd` and `std_field_test_gd`). This data will be used to quantify differences between the trained models later on.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "Skfwn5_-pyzP" + }, + "outputs": [], + "source": [ + "df_test=FileDataFiles(\"./datasets/1_parameter/test_cases.txt\",base_path=\"./datasets/1_parameter/data/\")\n", + "df_test.sort()\n", + "std_field_test_gd=[]\n", + "mean_field_test_gd=[]\n", + "inputs_test=[]\n", + "samples_gd=[]\n", + "for case in df_test.get_simulation_cases():\n", + " datas=[]\n", + " selected_cases=df_test.select_simulation_cases([case])\n", + " for case in selected_cases:\n", + " raw_data=read_single_file(case['path']+case['file_name'],model=\"dimless\",scale_factor=0.25)\n", + " datas.append(\n", + " raw_data[3:]\n", + " )\n", + " # scale factor is 0.25 to get 32x32 data\n", + " inputs_test.append(read_single_file(case['path']+case['file_name'],model=\"normalized\",scale_factor=0.25)[0:3])\n", + " samples_gd.append(np.stack(datas,axis=0))\n", + " std_field_test_gd.append(samples_gd[-1].std(axis=0))\n", + " mean_field_test_gd.append(samples_gd[-1].mean(axis=0))\n", + "std_field_test_gd=np.stack(std_field_test_gd,axis=0)\n", + "mean_field_test_gd=np.stack(mean_field_test_gd,axis=0)\n", + "\n", + "df_all=DataFiles(df_train.case_list+df_test.case_list)\n", + "df_all.sort()\n", + "std_value_gd=[]\n", + "for case in df_all.get_simulation_cases():\n", + " datas=[]\n", + " selected_cases=df_all.select_simulation_cases([case])\n", + " for case in selected_cases:\n", + " datas.append(\n", + " read_single_file(case['path']+case['file_name'],model=\"dimless\",scale_factor=0.25)[3:] \n", + " )\n", + " std_value_gd.append(np.stack(datas,axis=0).std(axis=0).mean())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3AUNl4MEpyzP" + }, + "source": [ + "The next cell defines two helper functions to compute the Euler integration for a chosen number of steps of a trained FM model. It simply evalutes the target samples via ODE integration steps to compute \n", + "$$\n", + "x_1 = x_0+\\int_0^1 v_\\theta(x,t) dt ~.\n", + "$$\n", + "\n", + "It does so using Euler steps (for simplicity) for a whole batch of 25 samples, while the main `sample_flowmatching()` function breaks down larger inputs into chunks of 25. More advanced ODE integration methods are interesting to try here, of course, and a variety of integrators can be found in the accompanying github repository.\n", + "\n", + "It's worth explicitly pointing out a key difference between denoising and flow matching here that is not so obvious from the equations above: for denoising, we repeatedly add noise again over the course of the denoising steps. Flow matching, in contrast, only works with the initial noise, and follows the trajectory prescribed by the learned vector field. Hence, _no noise is added_ over the course of the flow matching steps at inference time.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "HEWdmjANpyzP" + }, + "outputs": [], + "source": [ + "def integrate_euler( f, x_0, t_0, t_1, dt):\n", + " t_0 = torch.as_tensor(t_0, dtype=x_0.dtype, device=x_0.device)\n", + " t_1 = torch.as_tensor(t_1, dtype=x_0.dtype, device=x_0.device)\n", + " dt = torch.as_tensor(dt, dtype=x_0.dtype, device=x_0.device)\n", + " with torch.no_grad():\n", + " t=t_0\n", + " x=x_0\n", + " while (t_1 - t) > 0:\n", + " dt = torch.min(abs(dt), abs(t_1 - t))\n", + " x, t = x + dt * f(t,x), t + dt\n", + " return x\n", + "\n", + "def fm_sample( network, x_0, dt, condition):\n", + " with torch.no_grad():\n", + "\n", + " def wrapper(t,x):\n", + " return network(x,\n", + " t*torch.ones((x.shape[0],)).to(x_0.device),\n", + " condition=condition)\n", + "\n", + " return integrate_euler( f=wrapper, x_0=x_0, t_0=0., t_1=1., dt=dt)\n", + "\n", + "def sample_flowmatching(network, input_field, dt, num_sample=100):\n", + " network.eval();network.to(device);predictions=[]\n", + " batch_size=25;N_all=num_sample\n", + "\n", + " while N_all>0:\n", + " batch_size_now=min(batch_size,N_all)\n", + " N_all-=batch_size\n", + " condition=input_field.to(device).repeat(batch_size_now,1,1,1)\n", + " noise=torch.randn_like(condition)\n", + " prediction_batch=normalized2dimless( \n", + " fm_sample(x_0=noise,\n", + " network=network, dt=dt, \n", + " condition=condition)\n", + " )\n", + " predictions.append(prediction_batch.detach().cpu().numpy())\n", + " predictions=np.concatenate(predictions,axis=0)\n", + " return np.mean(predictions,axis=0), np.std(predictions,axis=0), predictions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YLOQ9i9_pyzQ" + }, + "source": [ + "We'll directly test our FM model with a varying number of integration steps. As promised above, FM can produce results in very few steps, so this is an interesting hyperparameter to vary. The next cell collects results via `sample_flowmatching()` with `step` varying from `1` to `100`. For qualitative comparison, we'll only do this for a single test sample, so that we can visualize the results next to the ground truth.\n", + "\n", + "For each integration step count, we'll collect 100 samples produces with different noise as starting point, in order to gather the mean and standard deviation statistics.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "n6K7JVTkpyzQ", + "outputId": "a1315a4a-dbca-4fd7-bd7b-68c6f2d11ff2" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 4/4 [00:05<00:00, 1.36s/it]\n" + ] + } + ], + "source": [ + "index=3\n", + "input_field=inputs_test[index].unsqueeze(0)\n", + "\n", + "titles=[]\n", + "result_fms=[]\n", + "for step in tqdm([1,5,20,100]):\n", + " mean_fm,std_fm,samples_fm=sample_flowmatching(network,input_field,dt=1/step)\n", + " titles.append(\"Flow Matching {}\".format(step))\n", + " result_fms.append(np.concatenate([mean_fm,std_fm],axis=0))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "69f5EdBNtK7K" + }, + "source": [ + "Next, we repeat this process and define helper functions to produce samples with the diffusion model.\n", + "\n", + "As mentioned just above, DDPM adds the correct amount of noise for the current noise schedule in the `DDPM_sample_step()` calls.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "cIi4AAmuA5ma" + }, + "outputs": [], + "source": [ + "def diffusion_sample_from_noise(diffuser, model, condition):\n", + " with torch.no_grad():\n", + " x_t=torch.randn_like(condition)\n", + " t_now = torch.tensor([diffuser.steps], device=diffuser.device).repeat(x_t.shape[0])\n", + " t_pre = t_now-1\n", + " for t in range(diffuser.steps):\n", + " predicted_noise=model(x_t,t_now,condition)\n", + " x_t=DDPM_sample_step(diffuser, x_t,t_now,t_pre,predicted_noise)\n", + " t_now=t_pre\n", + " t_pre=t_pre-1\n", + " return x_t\n", + "\n", + "def DDPM_sample_step(d, x_t, t, t_pre, noise):\n", + " coef1 = 1/d.sqrt_alphas[t]\n", + " coef2 = d.betas[t]/d.sqrt_one_minus_alphas_bar[t]\n", + " sig = torch.sqrt(d.betas[t]) *d.sqrt_one_minus_alphas_bar[t_pre] /d.sqrt_one_minus_alphas_bar[t]\n", + " return coef1*(x_t-coef2*noise) + sig*torch.randn_like(x_t)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "J-bBAWGGpyzQ" + }, + "source": [ + "Note that these snippest closely follow the sampling of the original airfoil paper, e.g. [sample.ipynb](https://github.com/tum-pbs/Diffusion-based-Flow-Prediction/blob/main/sample.ipynb). Below we compute a single batch of outputs for the diffusion model in `result_diffusion`." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "LzsUIt0KpyzR" + }, + "outputs": [], + "source": [ + "def sample_diffusion(diffuser, network,input_field,num_diffusion_sample=100):\n", + " network.eval();network.to(device);predictions=[]\n", + " batch_size=25;N_all=num_diffusion_sample\n", + " while N_all>0:\n", + " batch_size_now=min(batch_size,N_all)\n", + " N_all-=batch_size\n", + " prediction_batch=normalized2dimless(\n", + " diffusion_sample_from_noise(diffuser, network,\n", + " input_field.to(device).repeat(batch_size_now,1,1,1) ))\n", + " predictions.append(prediction_batch.detach().cpu().numpy())\n", + " predictions=np.concatenate(predictions,axis=0)\n", + " return np.mean(predictions,axis=0),np.std(predictions,axis=0),predictions\n", + "\n", + "mean,std,samples_diffusion=sample_diffusion(diffusion_trainer.diffuser,dif_network,input_field)\n", + "result_diffusion=np.concatenate([mean,std],axis=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0GkKGQv6pyzR" + }, + "source": [ + "Let's first do some qualitative comparisons first by plotting the mean and standard deviation fields of a single test case." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "ngLHnm8ZpyzR", + "outputId": "61e2ad43-6357-4bdb-dba4-651fcfe43a61" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result_ground_truth=np.concatenate([mean_field_test_gd[index],std_field_test_gd[index]],axis=0)\n", + "\n", + "CHANNEL_NAME_MEAN=[r\"$\\mu_p^*$\",r\"$\\mu_{u_x^*}$\",r\"$\\mu_{u_y^*}$\"]\n", + "CHANNEL_NAME_STD=[r\"$\\sigma_{p^*}$\",r\"$\\sigma_{u_x^*}$\",r\"$\\sigma_{u_y^*}$\"]\n", + "\n", + "from airfoil_diffusion.plotter import *\n", + "show_each_channel([result_ground_truth,result_diffusion]+result_fms,\n", + " channel_names=CHANNEL_NAME_MEAN+CHANNEL_NAME_STD,\n", + " case_names=[\"Ground truth\",\"Diffusion 200\"]+titles,transpose=True,inverse_y=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "whqPXFippyzR" + }, + "source": [ + "The code above produced 100 samples with each method, and the image of the previous cell shows the mean and standard deviation for each spatial point in the regular grid. This illustrates that the mean is relatively easy to get right for all methods. The corresponding fields don't vary too much, and even the 1-step FM variant gets this mostly right (with a bit of noise). \n", + "\n", + "The standard deviation across the samples is more difficult: 1-step FM completely fails here, but, e.g., the 20-step FM version already does very well. This version only uses one tenth of steps compared to the DDPM version. The latter uses 200 steps, so the FM version is effectively 10x faster, while yielding a comparable accuracy here.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Quantified Results\n", + "\n", + "So far, we've focused on a single test case, and this could have been a \"lucky\" one for FM. Hence, below we'll repeat the evaluation for different cases across different Reynolds numbers to obtain quantified results. In total, the test set has six different Reynolds numbers, the middle four being interpolations of the training parameters, the first and last being extrapolations.\n", + "\n", + "The `do_test()` helper function defined in the next cell directly computes the statistics for a given network over the whole test set.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "id": "oE0ObxRx_jdD" + }, + "outputs": [], + "source": [ + "def do_test(sample_func):\n", + " mean_predictions=[]\n", + " std_predictions=[]\n", + " std_a_predictions=[]\n", + " for input_field in tqdm(inputs_test):\n", + " mean_fields,std_fields,_=sample_func(input_field.unsqueeze(0))\n", + " mean_predictions.append(mean_fields)\n", + " std_predictions.append(std_fields)\n", + " std_a_predictions.append(np.mean(std_fields))\n", + " return mean_predictions,std_predictions,std_a_predictions\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Because of the larger number of test cases, the following cells can take a bit longer, especially for the diffusion model with its 200 steps.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ld8sTk1qpyzR", + "outputId": "e44918f5-8436-4f9f-bab0-59ccaed4c6d2" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 6/6 [00:01<00:00, 4.35it/s]\n", + "100%|██████████| 6/6 [00:06<00:00, 1.08s/it]\n", + "100%|██████████| 6/6 [00:25<00:00, 4.28s/it]\n", + "100%|██████████| 6/6 [02:09<00:00, 21.59s/it]\n" + ] + } + ], + "source": [ + "std_a_fms=[]\n", + "labels=[]\n", + "for step in [1,5,20,100]:\n", + " _,_,std_a_fm_i = do_test(lambda x:sample_flowmatching( network, x, dt=1/step, num_sample=500))\n", + " std_a_fms.append(std_a_fm_i)\n", + " labels.append(\"Flow Matching {}\".format(step))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jjoAQ8u0pyzR", + "outputId": "2fe75d92-8f35-4426-9b21-3fa555613c06" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 6/6 [03:40<00:00, 36.68s/it]\n" + ] + } + ], + "source": [ + "_,_,std_a_predictions_dif = do_test(lambda x:sample_diffusion(diffusion_trainer.diffuser, dif_network, x, num_diffusion_sample=500))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we have all the numbers, and the next cell produces a graph plotting the ground truth standard deviation per Re (blue line) next to the esimates from the different trained NNs.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 457 + }, + "id": "UFlXoT1KpyzS", + "outputId": "c28f9035-7cc3-4812-db24-a964dc0e8172" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x=[0.5 +2*i for i in range(6)]\n", + "plt.plot([0.5 +i for i in range(11)],std_value_gd,label=\"Ground truth\")\n", + "plt.scatter(x,std_a_predictions_dif,label=\"Diffusion 200\",marker=\"o\")\n", + "for i in range(len(std_a_fms)):\n", + " plt.scatter(x,std_a_fms[i],label=labels[i],marker=\"x\")\n", + "plt.legend(bbox_to_anchor=(1.0,1.0))\n", + "plt.xlabel(r\"$Re \\times 10^{-6}$\")\n", + "plt.ylabel(r\"$\\sigma_{y,a}$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E_hDWNLppyzS" + }, + "source": [ + "The graph shows that the single result visualized above was not an outlier: 1-step FM doesn't do well, but 5- or 20-step FM are already very good, and largely on-par with the DDPM variant. In general, the accuracy of the NNs is very good. Even the last and first dots, the extrapolation regions, are captured reasonably well. The networks over-estimate the variance for the low Re cases because they haven't really seen static cases in training data, but the potentially more difficult high-Re case on the right is handled very well.\n", + "\n", + "Overall, this setup is a non-trivial case: the networks had to learn the posterior distributions from almost constant to strongly varying across the differen Reynolds numbers. The _flow matching_ NNs really excel here: they yield excellent estimates and posterior samples with a very small number of integration steps. This is important for practical applications: these surrogate models have to compete with classical numerical simulations, and many fields have highly optimized simulation codes. Hence, it's important the trained NNs provide estimates quickly, with reasonable hardware requirements (i.e. not overly large parameter counts). These results indicate that _flow matching_ is a highly interesting contender for probabilistic simulations. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Next steps\n", + "- For this setup it is interesting to try higher order integration methods. Can you observe any gains over Euler? (Make sure to count all NFEs within the integrator, e.g., the four NN calls of the RK4 method.) \n", + "- Improve the overall accuracy of the trained models by increasing the number of epochs, and the feature count of the U-net architecture.\n", + "- The implementation above uses _basic_ denoising and flow matching. It's worth trying improvements, e.g., additional rectification steps from the paper by Liu et al. This could potentially reduce the number of required steps even further.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "------------------------\n", + "[-> Back to PBDL main page](https://www.physicsbaseddeeplearning.org/)" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "A100", + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/probmodels-dppm-fm.ipynb b/probmodels-dppm-fm.ipynb index dab0005..e69de29 100644 --- a/probmodels-dppm-fm.ipynb +++ b/probmodels-dppm-fm.ipynb @@ -1,1148 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "q4kVgOM2pyzJ" - }, - "source": [ - "# From DDPM to Flow Matching for Airfoil RANS Flows\n", - "\n", - "Ever wondered how to turn your existing _denoising diffusion code_ into a _flow matching_ approach? 🤔 Or what all the fuss regarding diffusion models was about in the first place? 🧐 That's exactly what this notebook is focusing on 😎\n", - "\n", - "We'll be using a learning task where we can reliably generate arbitrary amounts of ground truth data, to make sure we can quantify how well the target distribution was learned. Specifically, we'll focus on Reynolds-averaged Navier-Stokes simulations around airfoils, which have the interesting characteristic that typical solvers (such as OpenFoam) transition from steady solutions to oscillating ones for larger Reynolds numbers. This transition is exactly what we'll give as a task to diffusion models below. (Details can be found in our [diffuion-based flow prediction repository](https://github.com/tum-pbs/Diffusion-based-Flow-Prediction/).)\n", - "\n", - "# Intro\n", - "\n", - "Diffusion models have been rising stars in the deep learning field in the past years, and have made it possible to train powerful generative models with surprisingly simple and robust training setups. Within this sub-field of deep learning, a very promising new development are flow-based approaches, typically going under names such as _flow matching_ {cite}`lipman2022flow` and _rectified flows_ {cite}`liu2022rect` . We'll stick to the former here for simplicity, and denote this class of models with _FM_.\n", - "\n", - "For the original diffusion models, especially the _denoising_ tasks were extremely successful: a neural network learns to restore a signal from pure noise. Score functions provided an alternate viewpoint, but ultimately also resulted in denoising tasks. Instead, flow-based approaches aim for transforming distributions. The goal is to transform a known one, such as gaussian noise, into one that represents the distribution of the signal or target function we're interested in. Despite these seemingly different viewpoints, all viewpoints above effectively do the same: starting with noise, they step by step turn it into samples for our target signal. Interestingly, the FM-perspective is not only more stable at training time, it also speeds up inference by orders of magnitude thanks to yielding straighter paths. And even better: if you have a working DM setup, it's surprisingly simple to turn it into an FM one.\n", - "\n", - "Below, we'll highlight the simiarities and differences, and evaluate both methods with the RANS-based flow setup outlined above.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "32daES8LGs6v" - }, - "source": [ - "# Problem statement\n", - "\n", - "Instead of the previous supervised learning tasks, we'll need to consider distributions. For \"classic\" supervised tasks, we have unique input-output pairs $(x,y)$ and train a model to provide $y$ given $x$ based on internal parameters $\\theta$, i.e. $y=f(x;\\theta)$.\n", - "\n", - "In contrast, let's assume there is _some_ hidden state $\\psi$, that varies for a single $x$. This could e.g. be measurement noise, the starting point of an optimization for inverse problems, or the non-converging solution of a RANS solver (our scenario here). Now we can phrase our problem in terms of random variable $Y$, and our solution is drawn from the distribution $y \\sim P_Y(Y)$ that we typically specify as a marginalized distribution, in terms of samples with varying $\\psi$ for any given $x$. From a probabilistic perspective, it is important to capture the conditional probabilty of our solutions, i.e. $p(y|x)$, where we marginalize over $\\psi$. (We don't need to know about the specifics of $\\psi$ in practice.)\n", - "\n", - "This conditional distribution $p(y|x)$, the _posterior_, is exactly what our generative model should learn: when we repeatedly evaluate our model, it should give us samples from the posterior with the right probabilities. And it should do so efficiently, without wasting computations...\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "AVmsZmUsGwkR" - }, - "source": [ - "# Implementation and Setup\n", - "\n", - "First, we need to install the required packages and clone the repository:\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "KtHsiFscpyzN", - "outputId": "980dbf3a-54ab-441c-de05-3f95729a88e7" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/home/thuerey/jupyter/Diffusion-based-Flow-Prediction\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/thuerey/anaconda3/envs/torch24/lib/python3.12/site-packages/IPython/core/magics/osm.py:417: UserWarning: This is now an optional IPython functionality, setting dhist requires you to install the `pickleshare` library.\n", - " self.shell.db['dhist'] = compress_dhist(dhist)[-100:]\n" - ] - } - ], - "source": [ - "%pip install --upgrade --quiet einops bayesian_torch\n", - "!git clone https://github.com/tum-pbs/Diffusion-based-Flow-Prediction.git\n", - "%cd Diffusion-based-Flow-Prediction/" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "geSEvam6vDxA" - }, - "source": [ - "We also need to prepare the training dataset. The one below can be generated with [OpenFoam](https://www.openfoam.com/\n", - "), but is downloaded below for convenience. The data structure and the `DataFiles` class that are used to organize the dataset come from the diffusion-based flow prediction repository, details can be found [here](https://github.com/tum-pbs/Diffusion-based-Flow-Prediction/blob/main/generate_dataset.ipynb) if you're interested.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cd-7RLz7pyzO", - "outputId": "ae8d07ab-8d2f-4d6e-90d1-4eb5d8bf2693" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using device: cuda:0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Loading data: 100%|██████████| 125/125 [00:00<00:00, 341.19it/s]\n" - ] - } - ], - "source": [ - "import zipfile\n", - "from airfoil_diffusion.airfoil_datasets import *\n", - "from airfoil_diffusion.networks import *\n", - "from airfoil_diffusion.trainer import *\n", - "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", - "print(\"Using device: \"+str(device))\n", - "\n", - "if not os.path.exists(\"./datasets/1_parameter/data/\"):\n", - " files=[file for file in os.listdir(\"./datasets/1_parameter/\") if file.endswith(\".zip\")]\n", - " for file in tqdm(files):\n", - " f=zipfile.ZipFile(\"./datasets/1_parameter/\"+file,'r')\n", - " for file in f.namelist():\n", - " f.extract(file,\"./datasets/1_parameter/data/\")\n", - " f.close()\n", - "\n", - "df_train=FileDataFiles(\"./datasets/1_parameter/train_cases.txt\",base_path=\"./datasets/1_parameter/data/\")\n", - "train_dataset = AirfoilDataset(df_train,data_size=32)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "I913Pn0opyzO" - }, - "source": [ - "Next, we'll implement the denoising diffusion model, so that we can compare with flow matching afterwards.\n", - "\n", - "------------------------\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "PGf_5o2CFNC0" - }, - "source": [ - "## Denoising with Diffusion Models\n", - "\n", - "At it's core, the denoising task is as simple as the name implies: we learn to estimate the noise $\\epsilon$ by minimizing\n", - "$\n", - " \\parallel \\epsilon - f_\\theta(x,t) \\parallel^2\n", - "$,\n", - "the trick is primarily to carefully control the noise so that it can be learned easily.\n", - "\n", - "Note that for all equations here, we'll omit the $i$ subscript that previously denoted the different samples of a batch or dataset in {doc}`overview-equations`. Thus, we'll e.g. shorten $y_{i}$ to $y$, and leave out summations over $i$.\n", - "\n", - "To get started with denoising, we'll define a forward process that\n", - "adds noise to give a perfect\n", - "Gaussian distribution $\\mathcal{N}\\left(\\mathbf{0}, \\mathbf{I}\\right)$ at $t=1$.\n", - "It starts with a data sample $y$ at $t=0$, i.e. $\\mathcal{N}\\left(y, 0\\right)$ and then turns it into noise as $t$ increases. Note that the noising / denoising time $t$ is a _virtual_ one, it has no physical meaning.\n", - "The change of mean and standard deviation over time $t$ is controlled by a\n", - " _noise schedule_ $\\beta^t \\in (0,1)$, that gradually increases from $0$ to $\\beta^t=1$ at the end of the chain, where $t=1$.\n", - "\n", - "By choosing a Gaussian distribution, we can decouple the steps to give a Markov chain for the distribution $q$ of the form\n", - "$$\n", - " q\\left(y^{0:T}\\right) =\n", - " q(y^0) \\prod_{t=1}^{T} q\\left(y^{t} \\mid y^{t-1}\\right) ,\n", - "$$\n", - "where\n", - "$$\n", - " q\\left(y^{t} \\mid y^{t-1}\\right) = \\mathcal{N}\n", - " \\left(y^{t} ; \\sqrt{1-\\beta^{t}} y^{t-1}, \\beta^{t} \\mathbf{I}\\right) .\n", - "$$\n", - "\n", - "It's fairly obvious that we can destroy any input signal $y$ by accumulating more and more noise. What's more interesting is\n", - "the reverse process that removes the noise, i.e. the denoising. We can likewise formulate a\n", - "reverse Markov chain for the distribution $p_\\theta$. The subscript already indicates that we'll learn the transition and parameterize it by a set or parameters $\\theta$:\n", - "$$\n", - " p_\\theta\\left(y^{0:T}\\right)\n", - " =\n", - " p(y^T)\n", - " \\prod_{t=1}^{T}\n", - " p_\\theta \\left(y^{t-1} \\mid y^{t}\\right)\n", - "$$\n", - "with\n", - "$$\n", - " y^{t} = \\sqrt{\\bar{\\alpha}^t} y^{0}\n", - " +\\sqrt{\\left(1-\\bar{\\alpha}^t\\right)}\\epsilon .\n", - "$$ (eq-yt)\n", - "\n", - "We can calculate the correct coefficients $\\alpha$ from the noise schedule of the forward chain via\n", - "$\\alpha^t = 1 - \\beta^t$ and $\\bar{\\alpha}^t = \\prod_{i=1}^t \\alpha^i$.\n", - "\n", - "Each step $p_\\theta \\left(y^{t-1} \\mid y^{t}\\right)$ along the way now has the specific form\n", - "$$\n", - " p_\\theta \\left(y^{t-1} \\mid y^{t}\\right) =\n", - " \\mathcal{N} \\left( \\mu(f_{\\theta}) , \\sigma_{\\theta} \\right)\n", - "$$ (eq-denoising-step)\n", - "where we're employing a neural network $f_\\theta$ to predict the noise. We could also call the network $\\epsilon_\\theta$ here, but for consistency we'll stick to $f_\\theta$. The noise inferred by our network parametrizes the mean\n", - "$$\n", - " \\mu(\\epsilon) =\n", - " \\frac{1}{\\sqrt{\\alpha^t}}\n", - " \\Big(\n", - " y^t - \\frac{\\beta^t}{\\sqrt{1 - \\bar{\\alpha}^t}} \\epsilon\n", - " \\Big) .\n", - "$$\n", - "The standard deviation interestingly does not depend on the noise (and our network), but evolves over time with\n", - "$$\n", - " \\sigma=\n", - " \\frac{1-\\bar{\\alpha}^{t-1}}\n", - " {1-\\bar{\\alpha}^{t}}\\beta^{t} \\mathbf{I}.\n", - "$$\n", - "\n", - "Thus, given a pair $x,y$, we can directly compute the right amount of noise for time $t-1$ and $t$, and generate $y^t$ and $y^{t-1}$. In practice, we're not only interested in retrieving an arbitrary $y$, but the one that corresponds to some global paramters like a chosen Reynolds number. These conditions, together with e.g. the shape of an airfoil are actually our $x$ from $f(x)=y$ at the top.\n", - "So, we'll also condition $f$ on $x$ to have the form $f_\\theta (y^t,x,t)$.\n", - "\n", - "In practice, we simply choose a time $t$, compute the right amount of noise $\\epsilon$, and let our network predict the noise given $y^t$ computed by linear interpolation with $\\bar{\\alpha}^t$, as given above in equation `ref`(eq-yt).\n", - "This gives the loss function:\n", - "$$\n", - " \\mathcal{L}_{\\text{DM}}(\\theta) = \\mathbb{E}_{x,\\epsilon \\sim\\mathcal{N}(\\mathbf{0},\\mathbf{I}),t }\n", - " \\left[ \\parallel \\epsilon - f_\\theta(y^t,x,t) \\parallel^2 \\right]\n", - "$$\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "wQBjN33OWsP_" - }, - "source": [ - "## Implementing DDPM\n", - "\n", - "We'll split the implementation into a helper class that computes the coefficients for the denoising schedule, and a trainer class that takes care of the training loop.\n", - "\n", - "The helper class is callsed `MyDiffuser` below, and starts by computing the beta coefficients for a so called _cosine-beta_ schedule.\n", - "It has the form $\\beta = cos\\big( (t/T+s)~/~(1+s) * \\pi/2 \\big)^2$.\n", - "The offset $s$ below is chosen such that the standard deviation of the $\\sqrt{\\beta}$ is smaller than the color step of $1/256$ for a typical RGB image. The `generate_parameters_from_beta()` function takes the precomputed list of `beta` coefficients, and turns them into PyTorch tensors, computing the correct `alpha` and `alpha_bar` values along the way.\n", - "\n", - "The class also implements a function `forward_diffusion()` that calculates forward diffusion step using the precomputed `alpha_bar` values, given an input $y$ and $t$. Hence, this function computes $y^t$ from above.\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "yxF4ePQhW4Ol" - }, - "outputs": [], - "source": [ - "class MyDiffuser():\n", - " def __init__(self, steps, device):\n", - " self.device = device\n", - " self.steps = steps\n", - " self.name = \"Cos2ParamsDiffuser\"\n", - "\n", - " s = 0.008\n", - " tlist = torch.arange(1, self.steps+1, 1)\n", - " temp1 = torch.cos((tlist/self.steps+s)/(1+s)*np.pi/2)\n", - " temp1 = temp1*temp1\n", - " temp2 = np.cos(((tlist-1)/self.steps+s)/(1+s)*np.pi/2)\n", - " temp2 = temp2*temp2\n", - " self.beta_source = 1-(temp1/temp2)\n", - " self.beta_source[self.beta_source > 0.999] = 0.999\n", - " self.generate_parameters_from_beta()\n", - "\n", - "\n", - " def generate_parameters_from_beta(self):\n", - " self.betas = torch.cat( (torch.tensor([0]), self.beta_source), dim=0)\n", - " self.betas = self.betas.view(self.steps+1, 1, 1, 1)\n", - " self.betas = self.betas.to(self.device)\n", - "\n", - " self.alphas = 1-self.betas\n", - " self.alphas_bar = torch.cumprod(self.alphas, 0)\n", - " self.one_minus_alphas_bar = 1 - self.alphas_bar\n", - " self.sqrt_alphas = torch.sqrt(self.alphas)\n", - " self.sqrt_alphas_bar = torch.sqrt(self.alphas_bar)\n", - " self.sqrt_one_minus_alphas_bar = torch.sqrt(self.one_minus_alphas_bar)\n", - "\n", - "\n", - " def forward_diffusion(self, y0, t, noise):\n", - " yt = self.sqrt_alphas_bar[t]*y0+self.sqrt_one_minus_alphas_bar[t]*noise\n", - " return yt\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Cux8zWnzan7G" - }, - "source": [ - "Now we're ready to start training. The `MyDiffusionTrainer` class derives from a `Trainer` base class from the airfoil diffusion repository. This base class primarily handles parameters, book-keeping and a few other mundane tasks. Effectively, it makes sure we have a batch to train with, and then calls `train_step()`, which is the most interesting function below.\n", - "\n", - "It implements exactly the procedure outlines above: given a $y$, we compute noise, and $y^t$ with a forward step for a random $t$. Then we let our network predict the noise $\\epsilon$ from $y^t$, the condition $x$, and $t$. All that's left afterwards is to compute an MSE loss on the true noise versus the precicted one, and let PyTorch backpropagate the gradient to update the weights of our neural network." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "id": "nwVvxlbsFIeO" - }, - "outputs": [], - "source": [ - "class MyDiffusionTrainer(TrainerStepLr):\n", - "\n", - " def __init__(self) -> None:\n", - " super().__init__()\n", - "\n", - " def set_configs_type(self):\n", - " super().set_configs_type()\n", - " self.configs_handler.add_config_item(\"diffusion_step\",value_type=int,default_value=200,description=\"The number of diffusion steps.\")\n", - "\n", - " def event_before_training(self,network):\n", - " self.diffuser = MyDiffuser(steps=self.configs.diffusion_step,device=self.configs.device)\n", - "\n", - " def train_step(self, network: torch.nn.Module, batched_data, idx_batch: int, num_batches: int, idx_epoch: int, num_epoch: int):\n", - " condition = batched_data[0].to(device=self.configs.device)\n", - " targets = batched_data[1].to(device=self.configs.device)\n", - " t = torch.randint(1, self.diffuser.steps+1,\n", - " size=(targets.shape[0],), device=self.configs.device)\n", - " noise = torch.randn_like(targets, device=self.configs.device)\n", - " yt = self.diffuser.forward_diffusion(targets, t, noise)\n", - " predicted_noise = network(yt, t, condition)\n", - " loss=torch.nn.functional.mse_loss(predicted_noise, noise)\n", - " return loss\n", - "\n", - "diffusion_trainer = MyDiffusionTrainer()\n", - "\n", - "dif_network = AifNet(\"./pre_trained/single_parameter/32/diffusion/network_configs.yaml\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "_36M6WQyFSff" - }, - "source": [ - "At the end of the cell above we directly instantiate a trainer object, and initialiaze a neural network. The `AifNet` class implements a _state-of-the-art_ U-net with all the latest tricks for diffusion modeling, but in the end it's \"just a U-net\", and we'll skip the details here.\n", - "\n", - "More importantly, we can finally starting training our DDPM model. For that we can use the `train_from_scratch()` function of the trainer class, which we'll call in the next cell. The training with a default of 10000 steps can take a while, but shouldn't take much longer than half an hour on current GPUS. If you're not patient enough, feel free to skip this step and load one of the pre-trained models from our DBFP repository with the commented-out code at the bottom." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Fb8uPp9qFRvi", - "outputId": "7f82b6a0-26fa-488b-f996-ad266b4ad7a9" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Trainer created at 2024-11-05-03_25_26\n", - "Working path:./training/single_parameter/32/diffusion/2024-11-05-03_25_26/\n", - "Random seed: 1730773526\n", - "Training configurations saved to ./training/single_parameter/32/diffusion/2024-11-05-03_25_26/configs.yaml\n", - "Network has 1185218 trainable parameters\n", - "There are 5 training batches in each epoch\n", - "Batch size for training:25\n", - "Training epochs:10000\n", - "Total training iterations:50000\n", - "learning rate:0.0001\n", - "Optimizer:AdamW\n", - "Learning rate scheduler:step\n", - "Training start!\n", - " 0%| | 0/10000 [00:00 None:\n", - " super().__init__()\n", - "\n", - " def event_before_training(self,network):\n", - " self.flow_matcher = MyFlowMatcher()\n", - "\n", - " def train_step(self, network: torch.nn.Module, batched_data, idx_batch: int, num_batches: int, idx_epoch: int, num_epoch: int):\n", - " condition = batched_data[0].to(device=self.configs.device)\n", - " targets = batched_data[1].to(device=self.configs.device)\n", - " loss=self.flow_matcher.cfm_loss(network=network,x_1=targets,condition=condition)\n", - " return loss" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "6klh2FfQFZCv" - }, - "source": [ - "Next we can instantiate a trainer object, and allocate a network. We're using a U-net that's identical to the one previously used for denoising, so that we can make a fair comparison between the two training methodologies." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "id": "uY6BS0IRFYYr" - }, - "outputs": [], - "source": [ - "fmatching_trainer=MyFMTrainer()\n", - "\n", - "network = AifNet(\"./pre_trained/single_parameter/32/diffusion/network_configs.yaml\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "t10nHfJLyLK3" - }, - "source": [ - "\n", - "Now we can start training. Similar to before, this should take around half an hour for 10000 epochs, but if you want to skip this step, you can find code for loading one of the models from the github repo below.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "sQ-lNvZSsGj9", - "outputId": "c3555bab-c5c3-4da3-c032-515aa1880b93" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Trainer created at 2024-11-05-03_56_06\n", - "Working path:./training/single_parameter/32/flowmatching/2024-11-05-03_56_06/\n", - "Random seed: 1730775366\n", - "Training configurations saved to ./training/single_parameter/32/flowmatching/2024-11-05-03_56_06/configs.yaml\n", - "Network has 1185218 trainable parameters\n", - "There are 5 training batches in each epoch\n", - "Batch size for training:25\n", - "Training epochs:10000\n", - "Total training iterations:50000\n", - "learning rate:0.0001\n", - "Optimizer:AdamW\n", - "Learning rate scheduler:step\n", - "Training start!\n", - "lr:1.000e-05 train loss:0.00430: 100%|██████████| 10000/10000 [30:44<00:00, 5.42it/s]\n", - "Training finished!\n" - ] - } - ], - "source": [ - "fmatching_trainer.train_from_scratch(name=\"flowmatching\",\n", - " network=network,\n", - " train_dataset=train_dataset,\n", - " path_config_file=\"./pre_trained/train_configs.yaml\",\n", - " save_path=\"./training/single_parameter/32/\", epochs=10000)\n", - "\n", - "# uncomment to load the checked in model\n", - "#network.load_state_dict(torch.load(\"./pre_trained/single_parameter/32/flow_matching/weight.pt\"))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ezZSMjpvgjbF" - }, - "source": [ - "We finally have to trained models that we can evaluate side by side.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ZCGAEnlFpyzP" - }, - "source": [ - "# Test Evaluation\n", - "\n", - "To evaluate the trained models on inputs that weren't used for training we first need to download some more data. This is what happens in the next cell. \n", - "The `scale_factor=0.25` parameters of the `read_single_file()` function below make sure that we get fields of size $32 \\times 32$ like the ones in the training data set. However, the test set has previously unseen Reynolds numbers, so that we can check how well the model generalizes. While loading the data, the code also computes statistics for the ground truth mean and standard deviations (`mean_field_test_gd` and `std_field_test_gd`). This data will be used to quantify differences between the trained models later on.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "id": "Skfwn5_-pyzP" - }, - "outputs": [], - "source": [ - "df_test=FileDataFiles(\"./datasets/1_parameter/test_cases.txt\",base_path=\"./datasets/1_parameter/data/\")\n", - "df_test.sort()\n", - "std_field_test_gd=[]\n", - "mean_field_test_gd=[]\n", - "inputs_test=[]\n", - "samples_gd=[]\n", - "for case in df_test.get_simulation_cases():\n", - " datas=[]\n", - " selected_cases=df_test.select_simulation_cases([case])\n", - " for case in selected_cases:\n", - " raw_data=read_single_file(case['path']+case['file_name'],model=\"dimless\",scale_factor=0.25)\n", - " datas.append(\n", - " raw_data[3:]\n", - " )\n", - " # scale factor is 0.25 to get 32x32 data\n", - " inputs_test.append(read_single_file(case['path']+case['file_name'],model=\"normalized\",scale_factor=0.25)[0:3])\n", - " samples_gd.append(np.stack(datas,axis=0))\n", - " std_field_test_gd.append(samples_gd[-1].std(axis=0))\n", - " mean_field_test_gd.append(samples_gd[-1].mean(axis=0))\n", - "std_field_test_gd=np.stack(std_field_test_gd,axis=0)\n", - "mean_field_test_gd=np.stack(mean_field_test_gd,axis=0)\n", - "\n", - "df_all=DataFiles(df_train.case_list+df_test.case_list)\n", - "df_all.sort()\n", - "std_value_gd=[]\n", - "for case in df_all.get_simulation_cases():\n", - " datas=[]\n", - " selected_cases=df_all.select_simulation_cases([case])\n", - " for case in selected_cases:\n", - " datas.append(\n", - " read_single_file(case['path']+case['file_name'],model=\"dimless\",scale_factor=0.25)[3:] \n", - " )\n", - " std_value_gd.append(np.stack(datas,axis=0).std(axis=0).mean())\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "3AUNl4MEpyzP" - }, - "source": [ - "The next cell defines two helper functions to compute the Euler integration for a chosen number of steps of a trained FM model. It simply evalutes the target samples via ODE integration steps to compute \n", - "$$\n", - "x_1 = x_0+\\int_0^1 v_\\theta(x,t) dt ~.\n", - "$$\n", - "\n", - "It does so using Euler steps (for simplicity) for a whole batch of 25 samples, while the main `sample_flowmatching()` function breaks down larger inputs into chunks of 25. More advanced ODE integration methods are interesting to try here, of course, and a variety of integrators can be found in the accompanying github repository.\n", - "\n", - "It's worth explicitly pointing out a key difference between denoising and flow matching here that is not so obvious from the equations above: for denoising, we repeatedly add noise again over the course of the denoising steps. Flow matching, in contrast, only works with the initial noise, and follows the trajectory prescribed by the learned vector field. Hence, _no noise is added_ over the course of the flow matching steps at inference time.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "id": "HEWdmjANpyzP" - }, - "outputs": [], - "source": [ - "def integrate_euler( f, x_0, t_0, t_1, dt):\n", - " t_0 = torch.as_tensor(t_0, dtype=x_0.dtype, device=x_0.device)\n", - " t_1 = torch.as_tensor(t_1, dtype=x_0.dtype, device=x_0.device)\n", - " dt = torch.as_tensor(dt, dtype=x_0.dtype, device=x_0.device)\n", - " with torch.no_grad():\n", - " t=t_0\n", - " x=x_0\n", - " while (t_1 - t) > 0:\n", - " dt = torch.min(abs(dt), abs(t_1 - t))\n", - " x, t = x + dt * f(t,x), t + dt\n", - " return x\n", - "\n", - "def fm_sample( network, x_0, dt, condition):\n", - " with torch.no_grad():\n", - "\n", - " def wrapper(t,x):\n", - " return network(x,\n", - " t*torch.ones((x.shape[0],)).to(x_0.device),\n", - " condition=condition)\n", - "\n", - " return integrate_euler( f=wrapper, x_0=x_0, t_0=0., t_1=1., dt=dt)\n", - "\n", - "def sample_flowmatching(network, input_field, dt, num_sample=100):\n", - " network.eval();network.to(device);predictions=[]\n", - " batch_size=25;N_all=num_sample\n", - "\n", - " while N_all>0:\n", - " batch_size_now=min(batch_size,N_all)\n", - " N_all-=batch_size\n", - " condition=input_field.to(device).repeat(batch_size_now,1,1,1)\n", - " noise=torch.randn_like(condition)\n", - " prediction_batch=normalized2dimless( \n", - " fm_sample(x_0=noise,\n", - " network=network, dt=dt, \n", - " condition=condition)\n", - " )\n", - " predictions.append(prediction_batch.detach().cpu().numpy())\n", - " predictions=np.concatenate(predictions,axis=0)\n", - " return np.mean(predictions,axis=0), np.std(predictions,axis=0), predictions" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "YLOQ9i9_pyzQ" - }, - "source": [ - "We'll directly test our FM model with a varying number of integration steps. As promised above, FM can produce results in very few steps, so this is an interesting hyperparameter to vary. The next cell collects results via `sample_flowmatching()` with `step` varying from `1` to `100`. For qualitative comparison, we'll only do this for a single test sample, so that we can visualize the results next to the ground truth.\n", - "\n", - "For each integration step count, we'll collect 100 samples produces with different noise as starting point, in order to gather the mean and standard deviation statistics.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "n6K7JVTkpyzQ", - "outputId": "a1315a4a-dbca-4fd7-bd7b-68c6f2d11ff2" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4/4 [00:05<00:00, 1.36s/it]\n" - ] - } - ], - "source": [ - "index=3\n", - "input_field=inputs_test[index].unsqueeze(0)\n", - "\n", - "titles=[]\n", - "result_fms=[]\n", - "for step in tqdm([1,5,20,100]):\n", - " mean_fm,std_fm,samples_fm=sample_flowmatching(network,input_field,dt=1/step)\n", - " titles.append(\"Flow Matching {}\".format(step))\n", - " result_fms.append(np.concatenate([mean_fm,std_fm],axis=0))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "69f5EdBNtK7K" - }, - "source": [ - "Next, we repeat this process and define helper functions to produce samples with the diffusion model.\n", - "\n", - "As mentioned just above, DDPM adds the correct amount of noise for the current noise schedule in the `DDPM_sample_step()` calls.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "id": "cIi4AAmuA5ma" - }, - "outputs": [], - "source": [ - "def diffusion_sample_from_noise(diffuser, model, condition):\n", - " with torch.no_grad():\n", - " x_t=torch.randn_like(condition)\n", - " t_now = torch.tensor([diffuser.steps], device=diffuser.device).repeat(x_t.shape[0])\n", - " t_pre = t_now-1\n", - " for t in range(diffuser.steps):\n", - " predicted_noise=model(x_t,t_now,condition)\n", - " x_t=DDPM_sample_step(diffuser, x_t,t_now,t_pre,predicted_noise)\n", - " t_now=t_pre\n", - " t_pre=t_pre-1\n", - " return x_t\n", - "\n", - "def DDPM_sample_step(d, x_t, t, t_pre, noise):\n", - " coef1 = 1/d.sqrt_alphas[t]\n", - " coef2 = d.betas[t]/d.sqrt_one_minus_alphas_bar[t]\n", - " sig = torch.sqrt(d.betas[t]) *d.sqrt_one_minus_alphas_bar[t_pre] /d.sqrt_one_minus_alphas_bar[t]\n", - " return coef1*(x_t-coef2*noise) + sig*torch.randn_like(x_t)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "J-bBAWGGpyzQ" - }, - "source": [ - "Note that these snippest closely follow the sampling of the original airfoil paper, e.g. [sample.ipynb](https://github.com/tum-pbs/Diffusion-based-Flow-Prediction/blob/main/sample.ipynb). Below we compute a single batch of outputs for the diffusion model in `result_diffusion`." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "id": "LzsUIt0KpyzR" - }, - "outputs": [], - "source": [ - "def sample_diffusion(diffuser, network,input_field,num_diffusion_sample=100):\n", - " network.eval();network.to(device);predictions=[]\n", - " batch_size=25;N_all=num_diffusion_sample\n", - " while N_all>0:\n", - " batch_size_now=min(batch_size,N_all)\n", - " N_all-=batch_size\n", - " prediction_batch=normalized2dimless(\n", - " diffusion_sample_from_noise(diffuser, network,\n", - " input_field.to(device).repeat(batch_size_now,1,1,1) ))\n", - " predictions.append(prediction_batch.detach().cpu().numpy())\n", - " predictions=np.concatenate(predictions,axis=0)\n", - " return np.mean(predictions,axis=0),np.std(predictions,axis=0),predictions\n", - "\n", - "mean,std,samples_diffusion=sample_diffusion(diffusion_trainer.diffuser,dif_network,input_field)\n", - "result_diffusion=np.concatenate([mean,std],axis=0)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "0GkKGQv6pyzR" - }, - "source": [ - "Let's first do some qualitative comparisons first by plotting the mean and standard deviation fields of a single test case." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "ngLHnm8ZpyzR", - "outputId": "61e2ad43-6357-4bdb-dba4-651fcfe43a61" - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABqEAAAWNCAYAAABlsv8fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeZwdRbn4/6e7zzZ7EhKykBDZFy+7bFFABQXlChf9/vAiIojiLipeFVyuF/gqXEW4iHCvetkUkEVB/IqyR0AEFAhC2BMSdhIhJJlMZuac012/P2bJnEw9T+Z0embOwOf9euUFqTpVXV1d9XR112RO4JxzAgAAAAAAAAAAAGQoHO8GAAAAAAAAAAAA4I2HTSgAAAAAAAAAAABkjk0oAAAAAAAAAAAAZI5NKAAAAAAAAAAAAGSOTSgAAAAAAAAAAABkjk0oAAAAAAAAAAAAZI5NKAAAAAAAAAAAAGSOTSgAAAAAAAAAAABkjk0oAAAAAAAAAAAAZI5NKAAAAAAAAAAAAGRu1DahVqxYIUcffbS0t7fLpEmT5BOf+ISsWbNmg+Xuueceefe73y0tLS3S3t4u+++/v3R3d4uIyNKlS+UTn/iEbLHFFtLU1CRbbbWVfPe735VyuTxY/sknn5R3vetdMn36dCmVSrLlllvKt7/9balUKqN1qnWrt29WrFghX/ziF2W77baTpqYm2XzzzeXEE0+UVatWDX7mtddek0MOOURmzZolxWJR5syZI1/4whdk9erVNXVdfvnlsssuu0hzc7PMnDlTjj/+eHnttddG7VxH4vzzz5e3vOUtUiqVZO+995a//vWv6mcfffRR+dCHPiRvectbJAgC+a//+i+z7jPPPFOCIJAvf/nLg2lLly6VIAi8f6655pqMziob9fTNJZdcMux8SqVSzWf+4z/+Q7bffntpaWmRyZMny0EHHST33XdfzWe+973vybx586S5uVkmTZo0GqeVqTSx5mc/+5m8853vlPb2dgmCQFauXFmT/6c//UkdI3/7299ERB9H995772id6ojUM2Z+/vOfy3777SeTJ08eHA/rf37ZsmVy3HHHyaxZs6S5uVkOOeQQefrpp2s+8+lPf1q22moraWpqkmnTpsnhhx8uTzzxxKic38aop2/e+c53eq/voYceWvO5xx9/XA477DDp6OiQlpYW2XPPPeW5554bzO/p6ZHPf/7zsskmm0hra6t86EMfkmXLlo3aOdbrzjvvlA984AMya9YsCYJAfvvb35qfv/baa+U973mPTJs2Tdrb22XfffeVm266qeYzZ5xxhuy5557S1tYmm266qfzLv/yLPPnkkzWfeeWVV+SYY46RGTNmSEtLi+y+++7ym9/8JuvTy9R4xRoRkZtuukn22WcfaWtrk2nTpsmHPvQhWbp06Sic5chkHWeuvfZaee973yubbLKJBEEgDz300LB6Gn0uDcj6vj2SGLx48WI54ogjBuflkUceOeH7plKpyGmnnSZbbbWVlEol2WWXXeTGG2+s+Uwcx/Kd73yn5rng9NNPF+fc4Ge0+fXDH/5w1M5zQ+rpBxGRa665RrbffnsplUqy0047yR/+8IeafOec/Pu//7vMnDlTmpqa5KCDDho2RkYSvx5++GHZb7/9pFQqyZw5c+QHP/hBNidch7F+JhAZ2f2oEdbG47G+E7GfzUVEDjvsMNl8882lVCrJzJkz5ZhjjpGXXnopuxMfgXrn1IArr7xSgiCQf/mXf1E/85nPfMYcX729vbLrrruq9y4RkUWLFklbW9uYjx1ijS7rWNPZ2Slf/vKXZe7cudLU1CTz5s2rWceJiKxZs0a+8IUvyOzZs6WpqUl23HFH+Z//+Z+az/iePz7zmc9kcs4jVU/fXHvttfK2t71NJk2aJC0tLbLrrrvKL3/5y5rPbCjWjPTdzIknnih77LGHFItF2XXXXTM/75EYjzXeSMfEJZdcIjvvvLOUSiXZdNNN5fOf/3w2Jz0CxBrdaKxrNlTnhsbM3//+dznqqKNkzpw50tTUJDvssIOce+65mZxvPRr9efK1116T2bNne5/hR1vWcXgkfTNmscaNkkMOOcTtsssu7t5773V33XWX23rrrd1RRx1llvnLX/7i2tvb3RlnnOEWLlzonnjiCXfVVVe5np4e55xzf/zjH91xxx3nbrrpJrd48WJ3/fXXu0033dR99atfHaxj8eLF7qKLLnIPPfSQW7p06eBnTjnllNE61brV2zePPPKI++AHP+h+97vfuUWLFrnbbrvNbbPNNu5DH/rQ4GdWrFjhLrjgAve3v/3NLV261N16661uu+22q6n3z3/+swvD0J177rnumWeecXfddZd761vf6o444ohRPV/LlVde6QqFgrvooovco48+6k444QQ3adIkt2zZMu/n//rXv7p/+7d/c7/61a/cjBkz3DnnnKPW/de//tW95S1vcTvvvLP70pe+NJherVbdyy+/XPPn1FNPda2tra6zszPjM0yv3r65+OKLXXt7e815vfLKKzWfufzyy90tt9ziFi9e7BYuXOg+8YlPuPb2drd8+fLBz/z7v/+7O/vss91JJ53kOjo6RvMUM5Em1pxzzjnujDPOcGeccYYTEff666/X5Pf29g4bI5/85CfdFlts4ZIkcc45t2TJEici7tZbb635XLlcHq1T3aB6x8xHPvIRd/7557sFCxa4xx9/3B133HGuo6PDvfDCC84555Ikcfvss4/bb7/93F//+lf3xBNPuE996lNu8803d2vWrBms56c//am744473JIlS9wDDzzgPvCBD7g5c+a4arU6Juc9EvX2zWuvvVZzXRcuXOiiKHIXX3zx4GcWLVrkpkyZ4r72ta+5Bx980C1atMhdf/31NXV+5jOfcXPmzHG33Xabu//++90+++zj5s2bN9qnO2J/+MMf3Le+9S137bXXOhFx1113nfn5L33pS+4///M/3V//+lf31FNPuVNOOcXl83n34IMPDn7m4IMPdhdffLFbuHChe+ihh9z73//+YWPmPe95j9tzzz3dfffd5xYvXuxOP/10F4ZhTT2NZrxizTPPPOOKxaI75ZRT3KJFi9wDDzzg9t9/f7fbbruN1qmaso4zzjn3i1/8wp166qnu5z//uRMRt2DBgmH1NPpcci77+/ZIYvCaNWvclltu6Y444gj38MMPu4cfftgdfvjhbs8993RxHI/JeY9EvX3z9a9/3c2aNcvdcMMNbvHixe6CCy5wpVKpJkZ873vfc5tsson7/e9/75YsWeKuueYa19ra6s4999zBz6w/vy666CIXBIFbvHjxqJ+zT739cPfdd7soitwPfvAD99hjj7lvf/vbLp/Pu0ceeWTwM2eeeabr6Ohwv/3tb93f//53d9hhh7ktttjCdXd3D35mQ/Fr1apVbvr06e7oo492CxcudL/61a9cU1OT++lPfzp6nbGe8XgmcG5k96PxXhuP1/puQ8/mzjl39tlnu3vuucctXbrU3X333W7fffd1++677+h2yBD19s2AJUuWuM0228ztt99+7vDDD/d+5tprr3W77LKLmzVrljq+TjzxRPe+971PvXeVy2X3tre9zb3vfe8b07FDrNGNRqw58sgj3Y477ujuuOMO9/TTT7vvfve7rr29vWatc8IJJ7itttrKzZ8/3y1ZssT99Kc/dVEUueuvv37wMwcccIA74YQTau5bq1atyrwPNPX2zfz58921117rHnvsMbdo0SL3X//1Xy6KInfjjTc650YWa0b6buaLX/yi+8lPfuKOOeYYt8suu4x6X6xvPNZ4zo1sTPzoRz9ys2bNcpdffrlbtGiR+/vf/14zrkYTsUY3GrFmJHVuaMxceOGF7sQTT3R/+tOf3OLFi90vf/lL19TU5M4777zM+0AzEZ4nDz/88MH7+/rP8KMp6zjs3Mj6ZqxizahsQj322GNORNzf/va3wbQ//vGPLggC9+KLL6rl9t57b/ftb3+7rmP94Ac/cFtssYX5ma985SvuHe94R131jpa0fbO+q6++2hUKBVepVNTPnHvuuW727NmDf//hD3/ottxyy5rP/PjHP3abbbZZHWeQrb322st9/vOfH/x7HMdu1qxZ7owzzthg2blz56oPBJ2dnW6bbbZxt9xyizvggAOGPXCub9ddd3XHH398PU0fdfX2zcUXX1z3w82qVasGN1KyqG+sbex8mj9//ohuKuVy2U2bNs2ddtppg2kDm1C+AD5eNmY+Odf3ENDW1uYuvfRS55xzTz75pBMRt3Dhwpo6p02b5n7+85+r9fz97393IuIWLVqU8kyyt7F9c84557i2traah4IPf/jD7qMf/ahaZuXKlS6fz7trrrlmMO3xxx93IuLuueeeFGcxukayCeWz4447ulNPPVXNX758uRMRd8cddwymtbS0uF/84hc1n5syZYo5rsbTeMaaa665xuVyuZoNhd/97ncuCIJx2fTOOs4MpcXViTKXsr5vjyQG33TTTS4Mw5qHhJUrV7ogCNwtt9yykWeUnXr7ZubMme4nP/lJTdoHP/hBd/TRRw/+/dBDDx22dlv/M+s7/PDD3bvf/e40p5CJevvhyCOPdIceemhN2t577+0+/elPO+f6XmLNmDHD/fCHPxzMX7lypSsWi+5Xv/qVc25k8euCCy5wkydPdr29vYOf+cY3vuG22267jTzjkRuvZ4J67kfjtTYer/Vdmmfz66+/fkzvT2n6plqtunnz5rn//d//dccee6x3E+qFF15wm222mVu4cKE6vv7whz+47bff3j366KPqM8HXv/5199GPfnTMxw6xRpd1rFm7dq2Losj9/ve/r0nffffd3be+9a3Bv7/1rW+tWd/5PjOS9xajaWNjjXPO7bbbboNxI+2zpPVu5rvf/e64bEKNxxrPuQ2PiRUrVrimpibv+5yxQKzRjca6ZiR1pokjn/vc59y73vWuuspsjEZ/nrzgggvcAQcc4G677bYx34TKOg4PZb3DHKtYMyq/ju+ee+6RSZMmydve9rbBtIMOOkjCMBz2q78GLF++XO677z7ZdNNNZd68eTJ9+nQ54IAD5M9//rN5rFWrVsmUKVPU/EWLFsmNN94oBxxwQLqTyViavvFZtWqVtLe3Sy6X8+a/9NJLcu2119ac97777ivPP/+8/OEPfxDnnCxbtkx+/etfy/vf//70J7QRyuWyPPDAA3LQQQcNpoVhKAcddJDcc889G1X35z//eTn00ENr6tY88MAD8tBDD8knPvGJjTpmltL2zZo1a2Tu3LkyZ84cOfzww+XRRx81j/Gzn/1MOjo6ZJdddsm0/WMlq/m0Ib/73e/ktddek49//OPD8g477DDZdNNN5R3veIf87ne/y+yY9cpiPq1du1YqlcpgTO3t7RURqfnVAWEYSrFYVGNzV1eXXHzxxbLFFlvInDlz0p5OprLomwsvvFD+9V//VVpaWkREJEkSueGGG2TbbbeVgw8+WDbddFPZe++9a36d3QMPPCCVSqXmuNtvv71svvnmGx3jGkWSJNLZ2Wnehwd+dezQz8ybN0+uuuoqWbFihSRJIldeeaX09PTIO9/5ztFucirjGWv22GMPCcNQLr74YonjWFatWiW//OUv5aCDDpJ8Pp/ZsUdiNOLMSEyEuTQa9+2RxODe3l4JgkCKxeLgZ0qlkoRhuME19FhJ0ze9vb3Dfm1NU1NTzTnNmzdPbrvtNnnqqadEpO/Xi/z5z3+W973vfd46ly1bJjfccMO4rffS9MM999wzbC178MEHD35+yZIl8sorr9R8pqOjQ/bee+/Bz4wkft1zzz2y//77S6FQqDnOk08+Ka+//vpGnvmGjeczQaPfj8ZrfZfm2XzFihVy+eWXy7x588bk/pS2b0477TTZdNNN1ViQJIkcc8wx8rWvfU3e+ta3ej+zbNkyOeGEE+SXv/ylNDc3ez9z++23yzXXXCPnn39+HWe18Yg1utGINdVqVeI4HtE963e/+528+OKL4pyT+fPny1NPPSXvfe97a8pdfvnlMnXqVPmnf/onOeWUU2Tt2rWp2lWvje0b55zcdttt8uSTT8r+++8vIumeJd8s72bq6RtrTNxyyy2SJIm8+OKLssMOO8js2bPlyCOPlOeff36jz3tDiDW60Yg19dRZbxzZ0Hv1LDX68+Rjjz0mp512mvziF7+QMBy1bzDyGo04XI+xiDWj0qOvvPKKbLrppjVpuVxOpkyZIq+88oq3zDPPPCMifd9Zc8IJJ8iNN94ou+++uxx44IHe308t0rfBdN5558mnP/3pYXnz5s2TUqkk22yzjey3335y2mmnbeRZZSNN36zv1VdfldNPP10+9alPDcs76qijpLm5WTbbbDNpb2+X//3f/x3Me/vb3y6XX365fPjDH5ZCoSAzZsyQjo6OMV8YD3j11VcljmOZPn16Tfr06dNH3Bc+V155pTz44INyxhlnjOjzF154oeywww4yb9681MfMWpq+2W677eSiiy6S66+/Xi677DJJkkTmzZsnL7zwQs3nfv/730tra6uUSiU555xz5JZbbpGpU6eO2rmMpizm00hceOGFcvDBB8vs2bMH01pbW+VHP/qRXHPNNXLDDTfIO97xDvmXf/mXcduIymI+feMb35BZs2YN3vQGbsqnnHKKvP7661Iul+U///M/5YUXXpCXX365puwFF1wgra2t0traKn/84x/llltuqVn0jaeN7Zu//vWvsnDhQvnkJz85mLZ8+XJZs2aNnHnmmXLIIYfIzTffLEcccYR88IMflDvuuENE+sZnoVAY9h0AGxvjGslZZ50la9askSOPPNKbnySJfPnLX5a3v/3t8k//9E+D6VdffbVUKhXZZJNNpFgsyqc//Wm57rrrZOuttx6rptdlPGPNFltsITfffLN885vflGKxKJMmTZIXXnhBrr766syOO1KjEWdGYiLMpdG4b48kBu+zzz7S0tIi3/jGN2Tt2rXS1dUl//Zv/yZxHA+L0+MlTd8cfPDBcvbZZ8vTTz8tSZLILbfcItdee23NOZ188snyr//6r7L99ttLPp+X3XbbTb785S/L0Ucf7a3z0ksvlba2NvngBz+Y3cnVIU0/vPLKK+bnB/67oc9sKH5pxxl6jNE0ns8EjX4/Gq/1XT3P5t/4xjekpaVFNtlkE3nuuefk+uuv39jTHpE0ffPnP/9ZLrzwQvn5z3+u1vuf//mfksvl5MQTT/TmO+fkuOOOk8985jM1L0GHeu211+S4446TSy65RNrb20d4Rtkg1uhGI9a0tbXJvvvuK6effrq89NJLEsexXHbZZXLPPffU3LPOO+882XHHHWX27NlSKBTkkEMOkfPPP7/mReFHPvIRueyyy2T+/PlyyimnyC9/+Uv56Ec/mu5k65S2b1atWiWtra1SKBTk0EMPlfPOO0/e8573iEh9z5ID3izvZkbaNxsaE88884wkSSLf//735b/+67/k17/+taxYsULe8573SLlcHoXeWIdYoxuNWDPSOuuNI3/5y1/kqquu8r5fHg2N/DzZ29srRx11lPzwhz+UzTfffMR1Z2U04vBIjVWsqWsT6uSTT1a/NHDgT9ovo0+SRET6vuD+4x//uOy2225yzjnnDAbv9b344otyyCGHyP/3//1/csIJJwzLv+qqq+TBBx+UK664Qm644QY566yzUrVrpEazb4ZavXq1HHroobLjjjvKf/zHfwzLP+ecc+TBBx+U66+/XhYvXiwnnXTSYN5jjz0mX/rSl+Tf//3f5YEHHpAbb7xRli5dOuZfdjmann/+efnSl74kl19++bCfRvLp7u6WK664oqF+0iatfffdVz72sY/JrrvuKgcccIBce+21Mm3aNPnpT39a87l3vetd8tBDD8lf/vIXOeSQQ+TII4+U5cuXj1Or/cZqPo3ECy+8IDfddNOwMTJ16lQ56aSTZO+995Y999xTzjzzTPnoRz86rl92vjHOPPNMufLKK+W6664bnDv5fF6uvfZaeeqpp2TKlCnS3Nws8+fPl/e9733Dfirk6KOPlgULFsgdd9wh2267rRx55JHS09MzHqeSuQsvvFB22mkn2WuvvQbTBu5Zhx9+uHzlK1+RXXfdVU4++WT553/+52FfMvxGdcUVV8ipp54qV1999bAHgQGf//znZeHChXLllVfWpH/nO9+RlStXyq233ir333+/nHTSSXLkkUfKI488MhZNHzQRYs0rr7wiJ5xwghx77LHyt7/9Te644w4pFAryf/7P/xHn3Ji0LSu+OPNmtqH79khi8LRp0+Saa66R//f//p+0trZKR0eHrFy5Unbfffcx/+m9LJ177rmyzTbbyPbbby+FQkG+8IUvyMc//vGac7r66qvl8ssvlyuuuEIefPBBufTSS+Wss86SSy+91FvnRRddJEcffTRj701ipM8EjXI/Gi1p13f1PJt/7WtfkwULFsjNN98sURTJxz72sYa8P3V2dsoxxxwjP//5z9UfwHvggQfk3HPPlUsuuUSCIPB+5rzzzpPOzk455ZRT1GOdcMIJ8pGPfCTVTyJj4vnlL38pzjnZbLPNpFgsyo9//GM56qijau5Z5513ntx7773yu9/9Th544AH50Y9+JJ///Ofl1ltvHfzMpz71KTn44INlp512kqOPPlp+8YtfyHXXXSeLFy8ej9Makba2NnnooYfkb3/7m3zve9+Tk046Sf70pz+JSH3PkiJvrnczI+2bDY2JJEmkUqnIj3/8Yzn44INln332kV/96lfy9NNPy/z588fl3DG+6okjCxculMMPP1y++93vDvtXmY1qNJ8nTznlFNlhhx3GbPM/K1YcHqmxijX+3+Wm+OpXvyrHHXec+Zktt9xSZsyYMeyldrValRUrVsiMGTO85WbOnCkiIjvuuGNN+g477CDPPfdcTdpLL70k73rXu2TevHnys5/9zFvfwK+B2nHHHSWOY/nUpz4lX/3qVyWKIrP9aY1m3wzo7OyUQw45RNra2uS6667z/pqDGTNmyIwZM2T77beXKVOmyH777Sff+c53ZObMmXLGGWfI29/+dvna174mIiI777yztLS0yH777Sf/9//+38FrMFamTp0qURTJsmXLatKXLVu2wb7QPPDAA7J8+XLZfffdB9PiOJY777xTfvKTn0hvb2/NGPj1r38ta9eulY997GPpTmKUZNE3Az8VvGjRopr0lpYW2XrrrWXrrbeWffbZR7bZZhu58MILzQepsTYW82mkLr74Ytlkk03ksMMO2+Bn9957b7nlllsyOW69NmbMnHXWWXLmmWfKrbfeKjvvvHNN3h577CEPPfSQrFq1SsrlskybNk323nvvYT/52dHRIR0dHbLNNtvIPvvsI5MnT5brrrtOjjrqqGxOcCNsTN90dXXJlVdeOexf006dOlVyuZz3njXwKxRmzJgh5XJZVq5cWfMTNxsT4xrFlVdeKZ/85CflmmuuUX8C6Qtf+IL8/ve/lzvvvLPmX/YsXrxYfvKTn8jChQsHf83NLrvsInfddZecf/75Y7qJNxFizfnnny8dHR3ygx/8YDDtsssukzlz5sh9990n++yzTybHH4nRijMbMhHm0mjdt0cSg9/73vfK4sWL5dVXX5VcLieTJk2SGTNmyJZbbpnNyW2kNH0zbdo0+e1vfys9PT3y2muvyaxZs+Tkk0+uOaevfe1rg/8aSkRkp512kmeffVbOOOMMOfbYY2vqu+uuu+TJJ5+Uq666KuOzG7k0/TBjxgzz8wP/XbZsWc06ftmyZbLrrrsOfmZD8Us7ztBjjKbxeiZYunRpw9yPNOO1vqvn2Xzq1KkydepU2XbbbWWHHXaQOXPmyL333iv77rtvqnMeqXr7ZvHixbJ06VL5wAc+MJg2sNmWy+XkySeflLvuukuWL19e8xPQcRzLV7/6Vfmv//ovWbp0qdx+++1yzz331PwaVBGRt73tbXL00UfLpZdeKrfffrv87ne/G/xBWOecJEkiuVxOfvazn8nxxx+fWT+sj1ijG41YIyKy1VZbyR133CFdXV2yevVqmTlzpnz4wx8evGd1d3fLN7/5Tbnuuuvk0EMPFZG+dzEPPfSQnHXWWepaeu+99xaRvt8AtNVWW6Vu30ik7ZswDAf/5eiuu+4qjz/+uJxxxhmDv9J0pM+SIm++dzP19M2A9ceEL1ZPmzZNpk6dOixWZ41YoxuNWJO2Ti2OPPbYY3LggQfKpz71Kfn2t7+dqk1pNPLz5O233y6PPPKI/PrXvxYRGfyBmqlTp8q3vvUtOfXUU+s6Zr1GKw6nMVqxpq4fkZw2bZpsv/325p9CoSD77ruvrFy5Uh544IHBsrfffrskSTJ4Iut7y1veIrNmzZInn3yyJv2pp56SuXPnDv79xRdflHe+852yxx57yMUXXzyin/Ic2LEbWGSOhtHsG5G+fwH13ve+VwqFgvzud78b0Y7vwPkO/L7ZtWvXDuuvgQ2Z8fhptUKhIHvssYfcdtttg2lJkshtt92W+qHlwAMPlEceeUQeeuihwT8DDwQPPfTQsE3ICy+8UA477DCZNm3aRp1L1rLomziO5ZFHHtng5mKSJINjpFGM9nwaKeecXHzxxfKxj31sRL/b/qGHHhrzzdwBacfMD37wAzn99NPlxhtvNBe8HR0dMm3aNHn66afl/vvvl8MPP1z9rHNOnHMNM642Zj5dc8010tvbO+ynYQqFguy5557mPWuPPfaQfD5fc9wnn3xSnnvuuVF/MTOafvWrX8nHP/5x+dWvfjX4ID2Uc06+8IUvyHXXXSe33367bLHFFjX5A79b2Hc/Gs37tM9EiDXWvXus+2u044xmIsyl0b5vjyQGT506VSZNmiS33367LF++fEQ/PDEWNqZvSqWSbLbZZlKtVuU3v/lNzXlrc8M3Ly688ELZY489xvU7MNP0w7777lvzeZG+38k+8PkttthCZsyYUfOZ1atXy3333Tf4mZHEr3333VfuvPNOqVQqNcfZbrvtZPLkyRt55hs2Xs8EjXQ/0ozX+m6kz+brW//5czTV2zfbb7/9sDFx2GGHDf6WiDlz5sgxxxwjDz/8cM1nZs2aJV/72tfkpptuEhGRH//4x/L3v/99MP8Pf/iDiPT9Jpbvfe97ItL3fSRD6zjttNMGf1L5iCOOaKh+ESHWbEysGaqlpUVmzpwpr7/+utx0002D86lSqUilUqk71jz00EMiImPyfJlV32jvFkayjnmzvpup5zl7/THx9re/XUSkJlavWLFCXn31VTNWZ4FYoxuNWJO2Tl8cefTRR+Vd73qXHHvssYP3rbHSyM+Tv/nNb2ru7wNfb3PXXXfJ5z//+bqPWa/RjsP1GLVY40bJIYcc4nbbbTd33333uT//+c9um222cUcdddRg/gsvvOC22247d9999w2mnXPOOa69vd1dc8017umnn3bf/va3XalUcosWLRoss/XWW7sDDzzQvfDCC+7ll18e/DPgsssuc1dddZV77LHH3OLFi91VV13lZs2a5Y4++ujROtW61ds3q1atcnvvvbfbaaed3KJFi2rOu1qtOuecu+GGG9xFF13kHnnkEbdkyRL3+9//3u2www7u7W9/+2C9F198scvlcu6CCy5wixcvdn/+85/d2972NrfXXnuNbQcMceWVV7piseguueQS99hjj7lPfepTbtKkSe6VV15xzjl3zDHHuJNPPnnw8729vW7BggVuwYIFbubMme7f/u3f3IIFC9zTTz+tHuOAAw5wX/rSl4alP/300y4IAvfHP/4x8/PKQr19c+qpp7qbbrrJLV682D3wwAPuX//1X12pVHKPPvqoc865NWvWuFNOOcXdc889bunSpe7+++93H//4x12xWHQLFy4crOfZZ591CxYscKeeeqprbW0d7O/Ozs6x7YARShNrXn75ZbdgwQL385//3ImIu/POO92CBQvca6+9VlP3rbfe6kTEPf7448OOe8kll7grrrjCPf744+7xxx933/ve91wYhu6iiy4avZPdgHrHzJlnnukKhYL79a9/XRNXhl7rq6++2s2fP98tXrzY/fa3v3Vz5851H/zgBwfzFy9e7L7//e+7+++/3z377LPu7rvvdh/4wAfclClT3LJly8bu5Deg3r4Z8I53vMN9+MMf9tZ57bXXunw+7372s5+5p59+2p133nkuiiJ31113DX7mM5/5jNt8883d7bff7u6//3637777un333Xd0TjKFzs7OwTkuIu7ss892CxYscM8++6xzzrmTTz7ZHXPMMYOfv/zyy10ul3Pnn39+zZhZuXLl4Gc++9nPuo6ODvenP/2p5jNr1651zjlXLpfd1ltv7fbbbz933333uUWLFrmzzjrLBUHgbrjhhrHtgDqMV6y57bbbXBAE7tRTT3VPPfWUe+CBB9zBBx/s5s6dO9inY2k04sxrr73mFixY4G644QYnIu7KK690CxYsqFnfNfpcci77+7ZzG47Bzjl30UUXuXvuucctWrTI/fKXv3RTpkxxJ5100tic9AjV2zf33nuv+81vfuMWL17s7rzzTvfud7/bbbHFFu71118f/Myxxx7rNttsM/f73//eLVmyxF177bVu6tSp7utf/3rNsVetWuWam5vdf//3f4/JuVrq7Ye7777b5XI5d9ZZZ7nHH3/cffe733X5fN498sgjg58588wz3aRJk9z111/vHn74YXf44Ye7LbbYwnV3dw9+ZkPxa+XKlW769OnumGOOcQsXLnRXXnmla25udj/96U/HoFf6jMczwUjvR+O9Nh6P9Z1zG342v/fee915553nFixY4JYuXepuu+02N2/ePLfVVlu5np6eMeiZ9Ou7Accee6w7/PDDzWPMnTvXnXPOOWr+kiVLnIi4BQsWqJ+5+OKLXUdHh3mcLBFrdKMRa2688Ub3xz/+0T3zzDPu5ptvdrvssovbe++9XblcHvzMAQcc4N761re6+fPnu2eeecZdfPHFrlQquQsuuMA559yiRYvcaaed5u6//363ZMkSd/3117stt9zS7b///mPUM/X3zfe//3138803u8WLF7vHHnvMnXXWWS6Xy7mf//zng58ZSaxxbsPvZp5++mm3YMEC9+lPf9ptu+22g9ekt7c3417wG4813kjHxOGHH+7e+ta3urvvvts98sgj7p//+Z/djjvuWDP+RguxRjcasWZDdY5kzDzyyCNu2rRp7qMf/WjNGmH58uVj1DMT53ly/vz5TkRqnj9G22jE4Q31zVjGmlHbhHrttdfcUUcd5VpbW117e7v7+Mc/XjNABhZr8+fPryl3xhlnuNmzZ7vm5ma377771rzMu/jii52IeP8MuPLKK93uu+/uWltbXUtLi9txxx3d97///ZqANd7q7ZuBge/7s2TJEuecc7fffrvbd999XUdHhyuVSm6bbbZx3/jGN4ZNlh//+Mduxx13dE1NTW7mzJnu6KOPdi+88MIYnbnfeeed5zbffHNXKBTcXnvt5e69997BvAMOOMAde+yxg38f6Jv1/xxwwAFq/dom1CmnnOLmzJnj4jjO8GyyVU/ffPnLXx787PTp09373/9+9+CDDw7md3d3uyOOOMLNmjXLFQoFN3PmTHfYYYe5v/71rzXHPPbYY719vP5cbRRpYs13v/td7zlefPHFNXUfddRRbt68ed7jXnLJJW6HHXZwzc3Nrr293e21117ummuuGY1TrEs9Y2bu3Lnefvjud787+Jlzzz3XzZ492+Xzebf55pu7b3/72zWL/RdffNG9733vc5tuuqnL5/Nu9uzZ7iMf+Yh74oknxuJ061JP3zjn3BNPPOFExN18881qnRdeeKHbeuutXalUcrvssov77W9/W5Pf3d3tPve5z7nJkye75uZmd8QRR9QshMabdn8Z6Itjjz22Jr4ecMAB5uedc+r9auj8euqpp9wHP/hBt+mmm7rm5ma38847u1/84hdjc9IpjVescc65X/3qV2633XZzLS0tbtq0ae6www7zbliNlazjjLa+G/qZRp9LA7K8bzu34RjsnHPf+MY33PTp010+n3fbbLON+9GPfuSSJBnV80yjnr7505/+5HbYYQdXLBbdJpts4o455hj34osv1tS3evVq96UvfcltvvnmrlQquS233NJ961vfGtY/P/3pT11TU1PNZvl4qvdedPXVV7ttt93WFQoF99a3vnXYZn2SJO473/mOmz59uisWi+7AAw90Tz75ZM1nNhS/nHPu73//u3vHO97hisWi22yzzdyZZ56Z7YmPwHg8E4zkftQIa+OxXt8NsJ7NH374Yfeud73LTZkyxRWLRfeWt7zFfeYznxnzZ8t659RQb9RNKOeINZasY81VV13lttxyS1coFNyMGTPc5z//+WH3nJdfftkdd9xxbtasWa5UKrntttuu5n793HPPuf33339wPm299dbua1/7mlu1atWo9sX66umbb33rW4PPQZMnT3b77ruvu/LKK2vqG2ms2dC7Ge0ZZOB92FgY6zXeSMfEqlWr3PHHH+8mTZrkpkyZ4o444gj33HPPjU4neBBrdKOxrrHqHMmY0Z5P586dO1rd4DURnifHYxPKuezj8Ib6ZixjTeBcA35rKAAAAAAAAAAAACa0ur4TCgAAAAAAAAAAABgJNqEAAAAAAAAAAACQOTahAAAAAAAAAAAAkDk2oQAAAAAAAAAAAJA5NqEAAAAAAAAAAACQOTahAAAAAAAAAAAAkLmG2oTq7e2V//iP/5De3t7xbkrDoW909I0f/eJHv+joGx19o6Nv/OgXHX2jo2909I0f/aKjb3T0jY6+8aNfdPSNjr7R0Td+9IuOvtHRN7pG6pvAOefGuxEDVq9eLR0dHbJq1Sppb28f7+Y0FPpGR9/40S9+9IuOvtHRNzr6xo9+0dE3OvpGR9/40S86+kZH3+joGz/6RUff6OgbHX3jR7/o6BsdfaNrpL5pqH8JlZXzzz//DVlPFhrtnOib0a8Ho6fRrnUjjZlGOyf6ZvTrwehptGvdSGOm0c6Jvhn9ejB6Gu1aN9KYabRzom9Grw6MPsaMjr7R0TeoF2NGR9/o6JtR5BrIqlWrnIi4VatWbVQ9O+ywQybtaaR66BsdfeOXVb+80WTZL41yrbOqh77R0Tc6Yo0fY0ZH3+joGx2xxo8xo6NvdG/UvmmkZ8s3GsaMjr7R0Tc6Yo0fY0ZH3+joG10jxZrc2G13jdzq1as3qnwcxxtdR6PVM1CevhmOvvHLog1vZI1wjRqtnqzmUhZtabR66BsdscbWCNeo0ephPunoGx2xxtYI16jR6mE+6d6ofZPlsyX8GuVaZ1VPI72PyKo9WdVD34xuHcQaW6Nc66zqYT6Nbh30ja6RYk1DfSfUqlWrZMomMyWJu8e7KcAbQmtrq7zwwgvS0dEx3k1pGMQZIHvEmuGINUD2iDXDEWuA7BFrhiPWANkj1gxHrAGy1yixpqH+JVQQBJLE3bLXwb+RXL5VwjCQIAwljPr/GwQSBANpoQRhKEHYlxYOpAWBBGHQ99kwkDCKJAwDkSGfjaJoyOdEgjCQKJSav4dRIIEM+UwQSBTVlgmC/s8FMqRtIlEUDpYJwr68MHQSBDL4JwxEokAkCNzg34NA+toR1H52IC0cmjZYz7rPhmHfZ/tPV8IgkHy07nhhGEgUiOSidflh/+dzUd/fo2Bd+Sjq//uQOvNR//mLE0licUksElfEJYlIEoskSd//xxVxLl6XVq2u+7zr+6yLB9KGlI3LIomrKStxVcS5/nKu7//jWJxL1qU7t+5zyUB63+fWletPH2xDIuKk7//jWFzSV9Y5Jy5JxPWnuf7PucSJq8brPuOSwTTXf8y+z7u+sgP19NebVJO+NidOXNyXnlScJLETF69LiytJ/9+dJHHf/yeV/mP1pw98JknWlR0s15/WFVfl2DXPSBAE4z21G8pAnNnzPb+WXKG1P370xYoglNpY0x8/hsaaKNcfP4bEmrA/bWisGYwzQ2JNGA2JMRM01oThus8OxIVcf6wYGmvyUW0s6vtcf9qQWJOL+mPwkFiTi4LB+gdjTbUi4taLF9WKiEsmdKxJ4oG4OSTWVNeLRy4ZTBsaa5Jq0n/+62LN4OeGxJqk0v/5eL14MSSmJHHSF2eGxBBizcZpqFgThX1zV9b/zHprof6JPDTW1MSjgdgTBsPjx2B8cUNiQW1asF5aGNTGmYkSa/riTFITa1xcGZI2EHsq/XUMiTVxdUjs6I8Zg58Zmh6v+9zAf+OkP74MiTVJPKRMf6zpj0cTOdYk5Xhd3On/75pyRY5bs4RYsx5frBmMH0NiTRj1PRQMjTVRFA3GnIEYEg08Yw2JNWEUStiftu5zweBcnKixZiDODI01uagvjgyNNflo3TPTQKxZ9zy1LtYMxJ6hsWbwGWtIrHHVcv98HRIv+tcvEznWJP3PP0NjjYvX/V2PR31xxvUfazDWDMajdbEmqcTiYqmJNUkl7vv/oTGlHK/7ezKQti4eEWvq1yixZiB+DI01UbjuWWhd7OmLR0NjzbB4FKyrf2j8iEKRQGrjShSuiwnBemuVobEmDPu+eH3CxJrqwLucIbEmrvTPuSGxpjr0/Y4bLLsuJvTHh3hd7BiMNTXPRP2xJhn63DQkRtXEp9rPTdRYk5Tj2uep/rSuOCbWeKwfa4bGioFYE4V9aUNjzWD8GBJr+soGNbEmGHyeCod8LugvN3FjTRQOf7czEBeGxpqB56mhsSbX/+w4NNbkwyFrqXD4u+TBWJNU++LG0FhTHfKOeILGmr73wUltrImHxJiBeJTENWl98SgZjCkDsSapDo1H/c9dlYH4sS7WJP0xJamJKXHts1PiJCknNZ+ZKLGmoTahBkS5FsnlW2qCyeDLmv60wUA08IJ28HNBzWdD68XO0IehcPjDUeALGkM+MzSQhAOBzngxHA4JCGFQ+xI4HBIotLRwvYAy9GXNQJpvE2pdcNEDx/qLlqEve+rbhPIFjv4XOOu/GB5MG/piON8/Ma0Xw0nti+HBB6b1Xwwn/hfDcewJYJ5NKO+LmLj2M4kTF62/CZWIq4bDN6HC2k2oJHaSSCJJ6MSFTlzYt3iKXSIucOICJ0nQ9/9x0p8mTpwkEsdBXyAT1//iKJA4CAbL9X02Ge+p3NAG4kzti+H64sfgw9aQF8Peh62hC5RAJnSsGfi7HSuGvxhetwjyxJ4wSPFieCCGrL8JNbFiTe1iZODhyBOPIk88ijzxKAxrHqBcnEgs/ZveQ2JNPLC4GhJrkiTpiynEmkw1QqwZeDgavlGlrH2GxBrrxfD6saLmYWnInNbSwvXizESJNQN/r3kxXK1IzTqo5sXwkFjjfTFcXe8BSnsxPPDAVBujal8MO/8m1ASLNUkokjhXE2sSicd7Oje0obEmbfyoecayXuwMiRcTOdas+4z/xfBAvu/FcH79F8NDY8+QWDPyF8ND4sUEjTXJ0DVOzYuYEcSjyBOPBuLMkFgTS9gXX4bEmsQFkgSuJtbESdD3ImZIrImjuC/mEGs2ynjHmsG/D4k11ovhobFmQy+G148VQ+PKSNJqY88EiTXVigy+QK7n/U6ivRhe90zktGeiwbo9L4Zr4lbt5yZqrElC6fv/IbEmDkScuPGezg1tINbUbkLVGz/WPXcNPosN3YRabw0ykWPNwCbU0LrX34Ta0Hvemk2oEb5L9m9ClWvfvUzAWDO4CTU01gz5hwp1x6MwHPKZ/k2oIOzbSBoSaxLXH1OGxJo46X//MiTWJFHc9/8TLNaE490AAAAAAAAAAAAAvPGwCQUAAAAAAAAAAIDMsQkFAAAAAAAAAACAzLEJBQAAAAAAAAAAgMyxCQUAAAAAAAAAAIDMsQkFAAAAAAAAAACAzOXGuwE+cbVLgiCQMAwkCEMJk/7/BoEEQd//J1EoQRhKEAb9nw0ljML+/KDvs2EgYRRJGAYiQz4bVaMhnxMJwkCiUGr+HkaBBDLkM0EgUVRbJgj6PxfIkLaJRFE4WCYI+/LC0EkQyOCfMBCJApEgcIN/DwLpa0dQ+9mBtHBo2mA96z4bhn2f7T9dCYNA8tG644VhIFEgkovW5Yf9n89FfX+PgnXlo6j/70PqzEf95y9OJInFJbFIXBGXJCJJLJIkff8fV8S5eF1atbru867vsy4eSBtSNi6LJK6mrMRVEef6y7m+/49jcS5Zl+7cus8lA+l9n1tXrj99sA2JiJO+/49jcUlfWeecuCQR15/m+j/nEieuGq/7jEsG01z/Mfs+7/rKDtTTX29STfranDhxcV96UnGSxE5cvC4trib9f3eSxMm6/yZuMD3urzcZOF6SSOwG2tX3Z60k4z2VG1pc7RoSPwIJk0iCUGpjTX/8GBprkqQ/fgyJNWEcDdYzEGuiaP3PiYTRkBgzQWNNGK777EBcyPXHiqGxJh/VxqK+z/WnDYk1uag/Bg+JNbkoGKx/MNZUKyJuvXhRrYi4ZELHmiQeiJtDYk11vXjkksG0obEmqSb9578u1gx+bkisSSr9nx8Sa+JqbUxJ4mQw3hBrstUQsSYK++aurP+Z9dZC/RN5aKypiUcDsScMhsePwfjihsSC2rRgvbQwqI0zEyXW9MWZpCbWuLgyJG0g9lT66xgSa+LqkNjRHzMGPzM0PV73uYH/xkl/fBkSa5J4SJn+WNMfjyZyrEmSWJIhcYZYs2FDY41z0eB8HYg1YdL3UDA01iRRNFhmIIYMPmMNiTVhFErYnzbwuWhwXTJxY81AnBkaa3JRXxwZGmvy0bpnpoFYs+55al2sGYg9Q2PN4DPWkFjjquX++TokXvSvXyZyrEn6n3+GxhoXr/u7Ho/64ozrP9ZgrBmMR+tiTVKJxcVSE2uSatz3/0NjykDZIenxwPMUsWajjHesGYgfQ2NNFK57FloXe/ri0dBYMyweBevqHxo/olAkkNq4EoXrYkKw3lplaKwJw76f9J4wsaY68C5nSKyJK/1zbkisqQ59v+MGy66LCf3xIV4XOwZjTc0zUX+sSYY+Nw2JUTXxqfZzEzXWJEnfZ4bGmsTFxJoNGIg1LlkXKwZijYv70obGmsH4MSTW9MWZoCbWBIPPU+tizcAaZCLHmigc/m5nIC4MjTUDz1NDY02u/9lxaKzJh0PWUuHwd8mDsSap9sWNobGmOuQd8QSNNX3vg5PaWBMPiTED8SiJa9L64tG6GDAQa5Lq0HjU/9xVGYgf62JN0p82NNbE1bj22SkZeKZa9w56osSahtqEKhQKMmPGDPnrTR8a76YAbwgzZsyQQqEw3s1oKANx5m+3/J/xbgrwhkGsGY5YA2SPWDMcsQbIHrFmOGINkD1izXDEGiB7jRJrAuecG+9GDNXT0yPlcnm8mwG8IRQKBSmVSuPdjIZDnAGyRazxI9YA2SLW+BFrgGwRa/yINUC2iDV+xBogW40SaxpuEwoAAAAAAAAAAAATXzjeDQAAAAAAAAAAAMAbD5tQAAAAAAAAAAAAyBybUAAAAAAAAAAAAMgcm1AAAAAAAAAAAADIHJtQAAAAAAAAAAAAyBybUAAAAAAAAAAAAMhcbrwbMFSSJPLSSy9JW1ubBEEw3s0BJjTnnHR2dsqsWbMkDNlvHkCcAbJFrPEj1gDZItb4EWuAbBFr/Ig1QLaINX7EGiBbjRRrGmoT6qWXXpI5c+aMdzOAN5Tnn39eZs+ePd7NaBjEGWB0EGtqEWuA0UGsqUWsAUYHsaYWsQYYHcSaWsQaYHQ0QqxpqE2otrY2ERFZuvBBae///xph5C8Y6Dt5QS6vH1DZAQy044iIGPU58e/SJ4leXTXW8xLnT4+1DKOMxWqfxqU4johImh9ksDZqQ6W+SMswyoiI5JRLb7UhSPSL6Kplf0a1opexLkjsL+crs7pzjWyx8x6D8wp9Bvrj/k9/UFoLw+ez0yaRMeita+aUcuZ1tuZ47B9vaevTztc8JyvQaPVZsS6uPwi5OGUQylAQpfvJrDBS7j3GrccKXKESuIKcHrjCSD9YoNQX5f33vzXliuz5v78l1qxnoD+ee+5ZaW9vH+fW1E9b01jShKGUoUsqSgwwb6FKHIqN+F416qto9RnxyVr3afVVrfpS9J9Vn9l/aeqzQrXzjzHtcqzt6pRj378lsWY9A/3x0VMelkJpeN9Y615NkKLQWP60sra2MsukfH7SDmXNc+1YsbHesc4pzflmzbq+Wl6krHdE7DGmZYXGussasvWO53JPp1z6f3ci1qxnoD/e89HbJV9oHZav9XNgPEiHxrhS18vm2DHGqfrup/42mPWlmCsikuqn07Xq0sRwEX0epa2v0WmxOs07NZH6Y1e5p1MuO2NnYs16BvrjvR+br8Qa/1yx3gFacUi7V0V5/XW59vwtIpLL+cvlcnr7zLyC/1g5Iz4VCnpeXqkvn9fL5JT3Clp6X56apb5fDUN98lmvXrSusJamQaAfS42FRn1WmNSWf+ZrtUSvUKtPW5r2rF0t3/7YWxoi1jTUJtTATbm9rU3a2+vZhLJeprEJtSFpNqGyvjGbZdiEWif212eV4Z8w1xroj9ZCXtqKhWH5al+m3YRKscljb0L5B2OjbEJpm0POWFAkYYpNKKO+sZL9JpSxcLZevIzVJpRn07amHLGmxuCapr2dTShpjE0obc1lbkJlvWmUcX1aGZHG34RydW5CDSDW1Broj0KpTQql4bGGTaj+Mqk3obQNpYw3oay1VaNvQinjJftNKGszQ81K/QKdWFNroD/yhdbsNqHMDSBlfTuGm1D2GE6xCWW1nU2oMTd2m1D2tSXW1NpwrFE2jVLMV6uctQkVWZtQSjl7E6r+TSOrTJpNKKtM1ptQ2qUyN6GMacQmlJ0+oBFiDb94FAAAAAAAAAAAAJljEwoAAAAAAAAAAACZYxMKAAAAAAAAAAAAmWMTCgAAAAAAAAAAAJkzvips4rC+ZM4up3yZnJYu9hd1a1/mbH0JtfVFZLGSmbY+68um1TY0wBfhRsaXp2mXPjS+ZM74DkER5fpaEyUyxp82xlxofRN7iguFicf6AuqMx4D5ZdfKscwy1pdxK3mJ9WXcShnrOJYk7bfJKrQvTbbaF0TGvUL8fREaPxdi1Zfmi6ADIxBGxYI3PSz4I2Eo43+faGhJMiHjujriUn7BuDLs7R+HMrpNPZRRn/Zdt7GxrprItFhoDceK0RdVtT4j3pnrXH+6tvQsV/W60DcnfPNCvUekWF9vqFya+tKp/3nMGc801pzQykXGl2drz3CRtTYw5oq1JsuSNlZE7C/cTjPGrL7Qyo3VuHQxP6ebhrbutNYG1nXTxlVoxS5jfauPK6O+yKhPa5+1/k4xj6y5oh9n7OZymvieZr5aso7vFut65PP+8VIs+dN7u8t1H//NJAhDb1yJIv+gs559tTIietywY4NRnzJGcjm9TC5v5CnltHElIlIw6ssXlHFa1OvLKS9E87l0711zkba20stYeVpIsd4Lm/FYybNCRpziecilfIbSaEO2kVY1jdQWAAAAAAAAAAAAvEGwCQUAAAAAAAAAAIDMsQkFAAAAAAAAAACAzLEJBQAAAAAAAAAAgMyxCQUAAAAAAAAAAIDM5ca7AaMuTLHPZpRJEr1Y4upLFxGpxHqmdqxqrNcXu/rrs9pn5Y2VMNAbEQb+9HykZGyQdiyrPj0vCiN/RqhfxMAYf84p9VkDE28OKSerU8o5IzZZeXHZP7atMkmKtlv1ZVlGRMSliCdBYsQF5ec/goJeJswpc19EAiUvKhb0Nhh5uaZiXWUKubxaF0Qkifv+ZMBlVM9IBNr9y2iDWkZEIuXeFhr30KqaI5JXylnrKm3NEAV6GxJjDRIpt2trnWZJlDWcFSKrxvlq7eitGjHciF3V2J8XG0sQqz5tyarV11tNu7Z7cwijUELPoNSWlYEx7q3HJ61c2vrSsI7ljGchjbWM1uqzjhMr8zLtcj3NOVl9pElz3a1yVpms67PU239xjp/TtQRhIIF2Q/V93hoHxqALtVhjlLGOFSnrZV/cHMyz2qc8H1hdYx5LKWf1tXa+kfHskmaeW/XZ17f+PrJo6yHteVYkXfzMGTGgWNTXuqUm/+vVlmZ/fd1ry/U17E0mCgOJPHNGiwG+zw6wnqW1cmFUfxkRffzk8nqZfF4/VqHgL2eNRTvPX18hr8+VovK4X8jpZfJGnnY5jG6VwHgm08KQFWvM9+DK80vZejhNwTonY8iq1P4znv3GGissAAAAAAAAAAAAZI5NKAAAAAAAAAAAAGSOTSgAAAAAAAAAAABkjk0oAAAAAAAAAAAAZI5NKAAAAAAAAAAAAGSOTSgAAAAAAAAAAABkLjfeDahLEGVbX+ivz0mgFkmcXl019qdXYr2QVsYqlyRGG4y8WMlLnN4+7VhWP6QR6l1uykX+gtY5GZdDEqc1RC8UGo2PIv8+b6CMvb4jVdQ8ZCcIAwm8185/zVxsTNYx5KwAkKKMUyaEli4iEpf1vtDKJUbQSNMGpwU0EUmsSZ5CqMSZQJnffXlGXCj4539U1G/JUTGv5uWaS/4yTUW9TIq8qMl/nHx3r1oXRFwSi0vqiB8p5rhdn3Fs616Uph2hfiztvhfkjLFtzKOqkh6p93F9bRAaIcPKkxRdZK5BlPoqxiW01pHdFf/BqrHRr+ax/OWMcGwO5zjx16ct4SqVlIvFN4kgFAk9t6VIu4cFen9aeWp9xnrYWudr5YwmZM54bNDLGOsaLcsqk8ZY9rn1vJOGNcZcigtirTP14yh1xRm/c3iTSDNGrDEc+AKaiITG+jvK6ddOK6c9r/flGXNMrS/b2JqmPquMfU5afen6yDpfTWIsKmJlnqeZ/yIiReXZq9Skj6OWJr2+tiZ/O5pL/sXVWiUdfYIw9MYB/R2b8WxujMUwUp7NjXiSy+vHyuX8eVq6iEihoOcVi/52aOkiIqWSXl9T0T9Omwr6PCopeYW8XqZg7DbklaYbrzxSvTNO85wkItJT1tpgrbv0+rRn2kJOL2OFT21o5iJ/fXmX8fuFjcC/hAIAAAAAAAAAAEDm2IQCAAAAAAAAAABA5tiEAgAAAAAAAAAAQObYhAIAAAAAAAAAAEDm2IQCAAAAAAAAAABA5tiEAgAAAAAAAAAAQOZy492AurhYych2Ly1J0uXFifOmV7Vmi0gl9pexylWM+qpGfUrzzPq0802cfpyshUGg5uUjpc8jvb5iXq9PxF+f3QajtshfzmoBGpQxBhqB0yb4hvKUmJHEerDTyoiIxBV/OauMU46VmGXSnW86/ntMvkm/9xRa8mpevrXgTc+1NKllci0lvT6lnFlfU1HNC4rKsUr++sJij1oXpO9G6ruZJsbNV+GsRYhayDhOXNHzAuPmphUJ9TnhQn/brcgahHobclH97dOOlqSMGWHGtwWtGeWK3r61Zb2+ctXfwIqS3pen11eN/eWM24V6TiIiSaJcD6VMd7mx78PjLQoDiTzrzkBZv/g+OyCM9LmslbOWSZFRnzaPAmOCaeckImKEoUylCccWq91prqHdf0obUq51tedC63HRWqtp9VnrQvP5XVtnKtXFOX5O1xKEoXm/931eY405bQxHOf3+b8cuf14ub5Qx5pF2rLzxriE0+kKbz3as9ufljTFsnW9OKacdR8S+hur7MeV5UUTEOb0+7coXi/qYaGrWX3m2lPzta2/W29fapMehduXRa5N2f7+u6WRdY4mi0DtvtZhizn8jbmh5uZx+fbS5IqLHgHxBb4M1hktN/jHcZLyL0Ma2iEhz0T++m40yLcqrg0kteh+1FPW8UkGJd8atxXre6Cn72766Wz+nbuP5SgtrxjAy80LlOdh6lxyGevualDFWUNK7jLE81lhhAQAAAAAAAAAAIHNsQgEAAAAAAAAAACBzbEIBAAAAAAAAAAAgc2xCAQAAAAAAAAAAIHNsQgEAAAAAAAAAACBzufFuwGgLwkjPDP17cEmsF0mcnldVylVivZBWRkSkt+ovZ5WpGHlVpR1WfXHiT7f6ITEytaww0OtTLpOIiOSVy1vI6RUmzmi8+MtFRvvsvvCnG6MSYyUMvANPu9ROuZYiIoExSJ0VUNJQBpzTBpuIOCMGJcokT8p6fXGl/mPFZb0f1DIpjmOJCvp1CvN6Xr41700vTS7qZVpKel5bi5LebJTR83Kt/rygpJeRUpOeV1Tani/40wvdel3oW1R44oA6Z521CKk/nlixwVbxpprxzhl3tzTtCPXzDXL+8ZiL9DZoTchZzXb6AkBbV1nrgnJFz+zq8ed19er1dZf19pX9l1DKVeucrDx/urZWFBFxRv+ZyzEPq90QCYJAgmB4H0XKIjaM9LmslRERyeX85awyVl6o5EVW+4wHh0ApZj1rWDxdmrqM/byjTwgtRuUivUwY1L9Osp6RkkRvvBYDrHgSG/WpscZcz+p5sdKOatXfcG1MwuaLPyIigTlf9Xmu1mdMSitu5JS1vhbTNpSnxTWzPuN5Qytn11d/GwpKGRF7PaSx3iWJdt+2nruM57Wmor++1iZ9IdLRojdwSqs/bmzaobdhcqueN6nZn1fM+4+zejX/JsAS5iIJPYNSiwGRMYBzef3Vd055d5g2NuSVl5TFot6+QknPa2ryH6ulpN/3rDnR3uwvN61djw2btPnbMKVVL9PWZMR+5Zk2Nt6Udnbr5/tqindDOePeFBb89VnruCblVYmISFGJu9Z766L/FZSI6LE6VOZGp3FvHGuN0xIAAAAAAAAAAAC8YbAJBQAAAAAAAAAAgMyxCQUAAAAAAAAAAIDMsQkFAAAAAAAAAACAzLEJBQAAAAAAAAAAgMyxCQUAAAAAAAAAAIDM5ca7AT4uScQlybD0IIzGoTW1KrFT86pxfekiIr1Vvb5yRWuDXl/ZqE8rVzXOKU2ZRM8S5wJvehDohUIjr5jz11fJ620Q8ZcREclF/mMVjJkSDx+qIzoWxlcQhhKEw/fhnfgvqO+zg2U88WpdOf8YcEq6iIgz5lcaVn1aXmJMZKu+uOwPGklF76O47M9zxuQKIv16RAV/Xq6k30MK7QU1rzip5C/T0aKWybc26/VNbvOm59pb1TJBk34saVbyrDJF/zmJiEje3xdB0X9OQXGtXhfUNY3EZfXzqsRYAKhlzJtU3czoZMRJ0dZwTj+nINJv5lo7gpw+l3ORvw2JsjYRsWOhtkbqVdZvIiKd3Xp9nT3+9O5evX09ZT2vW8mrVPUy1ppVC8ku2yGmKvunDPpFUSBRNPzahsr90vfZAbmcPpe1vFw+XX15ZS2fMx77wlCfR9rywFg2SGAs1yPlWHYZf3o+p7fbetbQymnPLSIixjJTqrE/s1zVy/RW9Aq1mGI+lxpxKFIaXzVOqmpdEGVtr/08bs4aLMiU9pwkIhIpQUBLF7HjmjaurPhUUJ4prHL5gt6+NMfKG23Q4kYhr8+9XFT/TVt7h9OXp5fTpmXBiIXNJT1vcqs/b84meh/NmKRfjxbxP8PEq/6hlnGrutQ8ec2/ACwra/HymjV6XZAwCiXyxONQWc9bsSE0YoO2Tsrl08UGbc4Wi3r7moz3FC3KnGhv1udyR4ueN2cT/7FmTdHPqTVe5U1PVuhzxXpqDZr970PClg6jlP7+QntcyxtrySmt+phoUq5hqWCV0Y+VV8aftfbT7lkWrUiL9Yw+xhqnJQAAAAAAAAAAAHjDYBMKAAAAAAAAAAAAmWMTCgAAAAAAAAAAAJljEwoAAAAAAAAAAACZYxMKAAAAAAAAAAAAmWMTCgAAAAAAAAAAAJnLjXcDvFwsksTD0xNlzyzKpzuMBN70JNHLWHmV2CnpeplyRc/rrfrr6zXKlJUyVjmrfbFyvnHi7zsRkcTKU5oXBnqZMNTPSWufiF4mH6lZUoxTjAn9UNnzzQst3RkXFhIEgQS+cRcqccYYh84YH2l42zVwLLUNevsSfaKIU+JWUtbLxGV9bCUVf7nYqM8p7Qsi/eckciV9Iudb/feE0uSiWqbQ3qTndbT60ye1qWWKk/W8oLXdn6Gli4i06PVJc4s3OWwy2lDylxERCfIlf3rB33+55jV62yASV0Ti8rBkp91YqvpN3mn3ABHj/pBxgLJo8VNEglzBm26ek79IX31KunVLDgv+eR4b8VNbi4mIdPX681at1ft8dbeaJV09/rPq6tH7tbtXv1/0Dh92IiJSNhZ+iXJPENGHknHZzftZoN1ulTLV6hiO5QlIW9dEkb8/cznjHmvl5f31FYwFdt54VCvk/GMubzylamVERHKRPy9nrP/tvPrrKyrnO6lZnw9tTXpeS9F/Pay5VzVCa2e3/5xe7dTn2Kq1Rizs8ac7Z6xnzecnLdOIJ3qW6D936z9fbc4gHes537xHKHnWtQ6tZ4e8P69Q0MvkC/pELxb9eXmjPq2MiB43inl9spQK/jyrjBW7gsBfzupz691Ki/LotUm73kdzNtErbK2u8KZXX35GLVN95nk1r7tbWZQZa3EJjc7IKRdRSa92rdXrgoRRJGE0fDxEyiDO5fRrY69r/Hl5a11jxgb/AqbUpJdpLulztrXJf6+a3KqXmTtNP9ZWM/x51ReeUMuUX3vJmx5oY1428C6ioL1v8KeLiPQqaxcRPa5NNWJNh7Em014NubWdahlTqDTQeA52FSMOKQJlb6RQWV13XaOFfwkFAAAAAAAAAACAzLEJBQAAAAAAAAAAgMyxCQUAAAAAAAAAAIDMsQkFAAAAAAAAAACAzLEJBQAAAAAAAAAAgMzlxrsBXknS92eEnPXZJK7/8C5dXlVpRk9ZL9SdIq+3qreht6LnVZWuqMZB3WVio8vjRK/PKacb6EUkF+l5TqkwCPR+LeT1g1WU87WuOyamIAwlCD378Eo8caE+bkJjkGpTJTAGlZP645bFxfqx4opyvsYkT5QyIiJxuf76ck3+W1G+Ja+WKbTrecWOkr9MR6te36Q2vT4lL+roUMtIx2Q9r9VfLmjXy0Qd09S8sGWSv75Ss1omyOn9J1FBz/N9PLe6rs+/2bgk8a9Tqv4btrPWLUoZEREXl/0ZGa+RTMa4crG/7UHeP183fCx/24NQj8famqZH6ToRka5ePX6u6vL37couvb7Va/Wf/1rT7b/PrFmr33/WrtUXhRVlUVM1Yri13okifzu0dBGRXE4/X7WccgkTbREJEREJwkACz1pFW2Mbyxrzmhby/guUN24rxbx+7UoFf56WvqH6iko7mo1bW0tJP9+Won8MtzXpZaa0+suUpFstk3SuUPNcT48/w4h32tpARGRKqz/PtyweUDHWcRUlDGkxV0QkCo11sNP6Vi9jPUuKaJn+E7biFsaOL56J2PHJystrsaugz6NiUc8rKc8vpaLeBiuuNRf9eS0lvUxHiz+v3YhPhZzxTKv0eZMRPyc16/NlSrM/blRffkYtU1n4tJrXs/xFf8bK19QyrmuNnhf7g1RYLKplpEV/ZpTW9vrKKMdHnyiKJPK8Z8kpY9iK3bm8nqfFhkJBL2PHBn+eNsdFRNqa9HtsR4s/b+40vQ1bb6pmSfmJe73p1VdfUMuETcoYLhjPccZzYVDwz7HeihHfjfv8pu3+zBZZq5apLl+q5vUaazKNte4Kiv73MtrzsYiI69Hb7n2PKSKh8s4o6dHj4FhjhQUAAAAAAAAAAIDMsQkFAAAAAAAAAACAzLEJBQAAAAAAAAAAgMyxCQUAAAAAAAAAAIDMsQkFAAAAAAAAAACAzLEJBQAAAAAAAAAAgMzlxrsBPi6JxSXx8Ixqxfv5IIxGuUXrVGJXd15vVS/TXdbzunr9eeVqoLfByCtX/enVWC9T9VyGDZVx+ilJouTlIr2Qc/qxQiUrZwyJqnENk8RfYUXph7769DztfKMxHLNQhIF3AAXK3ry1Y5+IPgiC0F8y0AavUcbijHFt5SVlf9urPfo5xeXEOJY/L9+SV8s0TS1500tTmtQy+bZmNa8wqc2bXlTSRURyHe1qnnRM9qe3TVKLhJM3VfOiTWbVlS4iErbox+qN/fFEiz8iIrGRGSljUxuylSI/z2JysYhnTeNd54ioa52+qsp6XrnXn6EdR0RcrB8rjaCqz/Mg589T+0FEJPHHBqu+oKTHhs41/nG/cq0e01YoZUREXu/yp69eq8+JlWv0vNVr/H3RtUa/Tt1rlcWdiJSVWO2MhVoU6femfN4fa4olfU0Thcb9J1BiDUukVJRljYRaTI/0sZjLG3nK02Mxr1/r5qKe16TkWWU69GkuHS3+tk9p0cf2lFb9fAuV1d706oqX1DLx8/687lX/UMtIb4+epzHiXTRlhppXnL2dN31KyzS1jBULu3r8eUX9liDG8DOeP60y+vUV8bcvVGJQoodVNADrGSqXqz+uFYx4V2rSX5e1NPnb0VLS1xQtJX0eTW71520xXW/fzEn+9pUKahEJrHVh2R+Hkq6Vapn4lWVq3tpXnvFnvLZcb8Oren09r/hjaO8Kf5wWEUmMwJFr8a8zm6dvopdpblHzpOivL5q+uT99jbKQhIiI5HKB5HLD55k2z621i7aGFREpFPzlrPlv5TWX/LGhtUmPDR0temyYO9Xf9q311w3S+/hf1Lz4Hy9609O8v7CeM4O88RxXNOaRosNYx4WrX/Gm9y59RC2TLPf3g4iIKLFQmox2K/NcRH+XGL/ub7eISNK5Qq9PeTcUdujruEbBmyMAAAAAAAAAAABkjk0oAAAAAAAAAAAAZI5NKAAAAAAAAAAAAGSOTSgAAAAAAAAAAABkTv82tRRuu+02ue2222T58uWSJLVfunbRRRdleSgAAAAAAAAAAAA0sMw2oU499VQ57bTT5G1ve5vMnDlTgiDIqmoAAAAAAAAAAABMMJltQv3P//yPXHLJJXLMMcdsfGVJ3PdnWHqkf15TrahZQaHkTY8Tb3LfoYy8snKorh6nluk08nrK/o28SlXf4Out6Hnlqj+9GutltPONE72M009JtL1Jq0wY6Jk5ZUhY17BiDZfYf6yqUSYx+kIrly8YvwkzVE7Kygs9JxwY9UDCKJLQM4Bcoow34zpHoX49Y/EHhkCLZyIioTHgFE4ZuyIicUWfEHHZn6el9x1LzytNLnrTW2e36mWmTvKmFye3qWWKUzrUvLCt3Z/RppeRdn8bRETCSdO86dG0OWqZ3JRZal5X6D+v17v0a9i12ri+rv7xkreGnzLUi3l/RmenEXDRdyP13UyVtYuLy2pVrtyr51V6lDL+dBEx10hOaV9g3KNcLq/mBUpeUGzRy+T96zQRkbBlkjf91dVqEXlVGatauojIyi69vlVd/tivpYuIrFylLMZEZNVK//XtWqNfp7Vr9by44j9WGOnXsFjSHw2iyB8DXKKfb6AFFKO+KPLXp6XDpv1goLF0UdfrIvraO5/T71Olgp7X2uSff1Pb9AbOmJQib9UrapnqomfUvO6XlvgzVixXy0jnKm9y0qvHcGuuBEUlFnZMVstYK4No0gxvesu0TdUyLUW9fd0l//VtUdJFRIrGW4jeqr/c6rV6mTXdRhxSBrT63BcZD6YQlyTiPOsap4zhxHjQt55WQyVIWT/srN1XRERyOX9eoaS3ormk19dS8seutmb9fGdvombJHlv610nu5afVMskzr3nTe3uNyWKs/ZLuTn9G1xq9vs6VapZb9bo3vXeZv90iIl0v/0PPe9F/rEqXvrZqnt6k5hXa/WvQXIfyLCkiMmtzvb5t3uZNXztpS29672pj0QrJ5QLJ5YbHgVzeHxvyxgNuwXj/Viz6y5Wa9BuVFRu0dU1bs/68MXsTvX3bbeZvX+8jd6hl4mXPqXm5t7zVmx5tubtaJlJWFdV/PK+WMd/TK/G9oD9KiluzUs0rP/eYvwnP6fHTvbrMOJj/WgXTN9PLGLTYmiwz+s+Iu+pI0l7gWxsZYyyzp7lyuSzz5s3LqjoAAAAAAAAAAABMYJltQn3yk5+UK664IqvqAAAAAAAAAAAAMIFt1K/jO+mkkwb/P0kS+dnPfia33nqr7LzzzpLP1/47urPPPntjDgUAAAAAAAAAAIAJZKM2oRYsWFDz91133VVERBYuXLgx1QIAAAAAAAAAAGCC26hNqPnz52fVDgAAAAAAAAAAALyBbNQm1FDHH3+8nHvuudLW1laT3tXVJV/84hfloosuGnFdLq6KiyvZNCyM1Kyg6j9GFBbUMtXEqXndZX9eZ49epqtH/1qunnJQV7qISKWqZkm56i/n9OaZeWmEyulGxreTGV2eSjXWK+xV+qhg9Gt3Ra8vpwy/Qk6/hqHWSSIigb/CIIw9aZl95dsbUhBFEkTD+1PpYnMgJvHw/h+gRyCdM+rTcpI4UcskZb2+ao8/zyrTOqdVzevYcqo3vXmmP11EpDRjmj9j0iZqGemYrGaF7f5y0Saz9DIdShtEJJw8w5v+2mp9TCxboV+P5av8AaWrRy1ixsFQCSda/BERKeaNPGVl0FTwH2hNp36uEHFJLC7xzKdE6TdlbdKXV9aPU/YPINe7Vi/T260fS4lDThtwIiI5fWCFxRZvepAvqWUiZe6JiLy42j9QX1yhx67Xu/x93t2r3y+7evTzXdXlL7dSmeMiIqtW9tad17lSv4Y9a/XAkVT9fVFs0fs8X2xT8zS5vN5/uZyely/48/LKGinJG2MPdQsCvT+jyMgL/TekgvFUWSroN7Gpbf5xMHeqfhPbpKDPicozT3rTq88+rpaRF5eqWWuffcGb3vPqSrVM3OuP1VFRf8YsTtLnXmnqJH99LfXPVxHRH8gMbU36mJjS6r9WMybpxwl7Vqt5QcEfo576hz4mnnhRX4sE3f529Cq322ou44fPNxiXOHGehWmiLFZDYxHrjJcNibJOCtWHNTt2FQr+ck0lvb7mkj6u2pr9bZ+rP1LIbtNWqXk9997hz1jxql7hGqW+Hn1953r1dUO1278Oidfqa5fKWv1Y1S5/XnlVl1qm6xU9r/tVf9ubpurrmvYt9Oe/ll138qbndnq7WmbtzN3UvHue8a//Xn5KWX8q61L0CaNQQs+LQm1tWVDWlSIixaI+z0tN/gVMqajHEys2tCuxYcYkvb5tZ+rtKz/+F296/MIitUxxn0PVvHuW+d+VJE/oz6B7bu1/xsv7nnH7We/0g5x/PdStP+pKUc8S193pz3hdj59rX3hFzSt0+N935beepJYJ8noLq6/615LyipIuItVV+jopV2rypiedrynpa9S6xlpmb6kvvfRS6e4efpPp7u6WX/ziF1kdBgAAAAAAAAAAABPARv9LqNWrV4tzTpxz0tnZKaXSup9CiONY/vCHP8imm266sYcBAAAAAAAAAADABLLRm1CTJk2SIAgkCALZdttth+UHQSCnnnrqxh4GAAAAAAAAAAAAE8hGb0LNnz9fnHPy7ne/W37zm9/IlClTBvMKhYLMnTtXZs3Sfw8rAAAAAAAAAAAA3ng2ehPqgAMOEBGRJUuWyOabb25+yS0AAAAAAAAAAADeHDZ6E2rAs88+K88++6yav//++2d1KAAAAAAAAAAAADS4zDah3vnOdw5LG/qvouI4Hnll5R6R8vCmuZxSR5LodYWhmuWivDc9VyyYzdN09Tpv+ppuvQ2r1+r/cqy711+ut6K3oVLW+yJx/rzQ+NdruZy/DYF+ShKlyLP+AZ1VX5p/eFeN9UKd3f4+sspERmcUlBnWZNRXDCM1zz/CkEZYiCTyXCCX1N/LQWJcs0iJW6E+BlxVn8dBzn+sxJj75a6qmlft9udN23kTtczkHeeqeU1z5/gzZsxWy0SbbeVNz8/aWi0Tt26q5r262t8XK7r0a7tqud5/q5b6g+7aXv0arunW89b2+q+hFWdykd725qI/r0lJt8qIiEjJn9zW5G9fLuJfQKfhnD82OGNN42J9AeB61/rT167RG9Hbo+dVyv5068Zb0NdPTrm35Wdvp5Z5+nVlMIrIs//wx67X1+j35J6yvw29Ff2cykbe6k7/NVy9Suk7EVm92shb4b9Wna93qmV6urrVPO23E+SL/vWviEghb6xpiv5FTbGo3wNLTXqetkYq5P3xKYhZBVkS1/dnfc75+01L3xAtBFj3qRZ9Ksusyf4xNyVcpZbpffJBNS9Z+oRS5km1zMonlup5i1Z60631YtMm/hNumdWulomM58+ordWf0dahlslNU9ZjRt7Ktfo5zdlEjw2VBTd503tfWKyWkZY2NSua+RZv+lY77KeWWb5Kv3dWqv7zShL/YK7qYQsiksSxJJ53O4HybGOua4x5pOVZj2rWb+XR3muUCnqFbU163oxJ/ryd5VG1TM8Nt6h5lZde8qavfWWFWmbtK69507te6lLLVHv093LaNSx06PGpNLmo5hXamr3pxcn6/C90tKh5U3bwX8P2rfV4l3/HIWrekinv8KY/tES/7i8/pmZJl7LkjpT7Y48RcyGSywWSzw8fk9pczllr2JKxVi35y7WU9OvT3qznTW335209Q3/9Hj7/kJpXWbzQm1498AS1zMXz1SyJlZC8zWb6O6PVynvSTYz4HnVMU/NeXOmPNctX6W2YNUVfQ02e4v8KoGrwsFqm0ul/dhYRadnW/36quJO+Dum981o1z/1jmTd99aLn1TKWjunTvenx6/7jxGv0e8JYM17v1+f111+v+bN8+XK58cYbZc8995Sbb745q8MAAAAAAAAAAABgAsjsX0J1dAz/Saz3vOc9UigU5KSTTpIHHnggq0MBAAAAAAAAAACgwWX2L6E006dPlyeNX38AAAAAAAAAAACAN57M/iXUww/X/q5F55y8/PLLcuaZZ8quu+6a1WEAAAAAAAAAAAAwAWS2CbXrrrtKEATDvuR2n332kYsuuiirwwAAAAAAAAAAAGACyGwTasmSJTV/D8NQpk2bJqVSKatDAAAAAAAAAAAAYILIZBOqUqnI8ccfL//zP/8j22yzzUbX5yq94sqepiWJv0BOSRcR52L9QGHkTc6XWvQiQaDmdXb7019dpX/11muv6+0rl6ve9DjWzzcM9fZFSl6+4O8HEZGcMkJyehHJRU7Ni5SuyOf0MgUzr77jiIgkenWyttffR8qlEBGRpoJeYUezvz6rDRLpnRuE/hOzhjn8giiSwNPXgdL9Wt9viFPiVlhJF36rXf5AU+0xYsmqspo3511zvembzNtdLRNsu7OaV3rrO7zpi1frcXXxMn/bX/27PhdWrtEnUWeXv897uvU+qlaN+4g5Yf3iuP4y+YI+xto7impeLvLHmY4WvQ2bduj3ii039ff7JoW13vTVpR61LmRMWweJiKsq87zXuD6dK/W8rk5/emDEwo7JalbpgCO96fcs0WPh86/qY3jlGn+5rm59bJcr/hhgzXErNqxd618caOkiIj1rK2peb4//Gvau1a9h9xpl8SkihVLBm54v+tNFRNqMWDN5sj+vtUUfEy0lvf+KeX+/F/L+z6+N9LrQN459YzlRxrcRTsx7mFOyjEckaSnqmTPb/POl+/479DYsfUrN63r8aW/68geXeNNFRNY8v0bNC5XnpObpTWqZ1tmTvOlNMzZRy5Q2m67myYw53uTc3O3VIoXt91bznnrZf/G7y/o6aVKn3n+rrrvam77ikefVMnMO2UPNk2b/mrEY6uNSWwuJ2GMT9UsS540rgfKOIg71YBNU9PtlqDzQJ7G+blj/t/IMpa2zW5v0MpNb9bxdX/6NN/2lK69Ry/zj78vVPC0OdS3T7/OaXJP+DFVS7uUiIu1z27zpLdP157j2rf3xSUSkNFfJmzFbLRNN3UzNy83a2pv+fDJTLfPnx/Rr+NpSZYwZj3HOuHc2N/vHpvZOLdJePEBE+v5hQ+h5B5PL+69bPq/3Z8HIKynv81qb9Is9pU0fJFsoz9LtXc+qZcqP/VXNW7j98d70m67Vnyl6uvXYuslU//qlt6LfLJ980b8+ePv2+vv/l1fq/ffQUn99y17Xr9PiV/T6Dtr5bd70woxH1TJNy15V8wrv9j+3Vtv1+PTMz69X8yJlzIbG+59J2+nHkiZ/TA5bOvzpLrN/f7TR0r1VXU8+nx/2nVAAAAAAAAAAAAB488pkE0pE5KMf/ahceOGFWVUHAAAAAAAAAACACSyzf5NVrVbloosukltvvVX22GMPaWmp/edhZ599dlaHAgAAAAAAAAAAQIPLbBNq4cKFsvvufd8h8tRT+u/pBgAAAAAAAAAAwBtfZptQ8+fPz6oqAAAAAAAAAAAATHCZbUIdf/zxcu6550pbW1tNeldXl3zxi1+Uiy66aMR1uUqvuIqnaXFF+Xyk1hVEeTUvqfrrkyRWy3S0zFLzunoCb/pDf1+pllm9okvNa5vU7E1vadXPqVDUL2mx6O+nwPhmsEjp2lzk1DI5/XJIIecvlzdGYqmg5zUVE3963n8tRER6q3rbK1V/Z8SJXibUDyWh0rdWH1njzyX+8/Wla59FnyCKJPBciEC5aIE2GUTsQaBMMGsI5Nv8c19EJKlUvendr76gltnmw7uqeVM+921v+u+XzlDLLHhcH1vP3rDSm75y+Utqme6ubm96b1ePWqaq9IOIiHP++RoE+nUqNBXVvNaOFn/65Ha1TPsUfxkRkeZmf8CbNEVvwxYz9T7fdQv/eW3ZukYtU178oJqX3POcN7179ev+9LX6dYJIEEYShJ4ZHyhRQLtxiIh+JxIRLeZrax0RkdUr9aynlvozjHg347SfqnkX3eEf98te1cf2ms6ymlcuK/dDZf5bokg/J+tWmmj3ZKMNubwe/YvKgqfcXFLLVHr166vFtWkz9di1+Rz9WFPa/Ofb2qTH45K+ZJWiklfI+a9Hlx4iISJx7CSOh4+9yJMmIlKt6oO7WtXnRLnqH8PVWC8ThfqcKC/y34+6brlRLdO5RF9TVNcaMU/RNFUf94V2/7xs2rRVLVOc4p9jxUlt3nQREWntULPCqTO96fnNd1TLPPGifn2fetmflyT6Ndz5n6areZXOtd70NS/700VEwqYmNS+36Vu86a+uVotIV48+xrSxWVEeubR09EniWJJ49DspUNYbvT36i4PeXj1Pu9fPmKyfy27/7ytq3l/OvtObbsUT7ZxERFrn+GPK1J030cvM9seUQpv+HJJv1Z8zC8ozT366Pv9l1uZqVnHnA7zpz8b6c+aSZXrsantd6z+9zGZT9djQVPTnrVyjr8W1d34iItqjZjHvP46r1L9mfTMJQ/9jkdbP1no+Z7xv1K5PS0m/PnOn6WNkhnvZm9778B1qmed2+4Se95y/HcuX6ffYnm59bf7SC53e9CXP1L/QXrBYX7tY73HXKrG6c5Xx7FfR5/mKTv/1+MBeH1PLTNv1nWre9Utme9MPfeV2tcyzt+jv43Y8ZjtvevtWm6llmnbZVc3L/9O+/nRlXVhYbSygxpix/VCfSy+9VLq7h79I7O7ull/84hdZHQYAAAAAAAAAAAATwEb/S6jVq1eLc06cc9LZ2Sml0rqf/IjjWP7whz/IpptuurGHAQAAAAAAAAAAwASy0ZtQkyZNkiAIJAgC2XbbbYflB0Egp5566sYeBgAAAAAAAAAAABPIRm9CzZ8/X5xz8u53v1t+85vfyJQpUwbzCoWCzJ07V2bN0r9HCQAAAAAAAAAAAG88G70JdcABfV82uGTJEtl8883NL34HAAAAAAAAAADAm8NGb0INmDt3blZVAQAAAAAAAAAAYILLbBMqS67cI64cZVNXijJJ5wo1rzi5U83raNnSm37ogW1qmfe9pdtoSU+d6W9M0eQZap6rxt70ha8U1DLV2BoViTe1ozlUS0xt1/Pam/x5+Uhvg+upqHni/OcriSdd+yxERCTM5yXM5z0Z/n/NGeQ8nx0sY8SrgjIWiyW9TKlZzWrbagdvevtnf6aW+caFr+nH+m8t43W9jCFQ+m/yjCnedBGRyamOlK3lzy1T86K8/1apnauIyKbT9Wu483b++t4vN6hlkoX3q3m98/3X6tVu/V4R9+pxxiX+OKjpNOqCiER5EV/88MVtEZFYjzVBvqjnFfwxxRmxy2ltEJFFv3nUm9500z1qme/9eI2ahz4trfr1KDV1eNPbp7SqZVav0NeYm8zw1/eueXp8mr2JPv9LBX/Mi8botyCEVX7bgiVJEkk88btarb8u4/YmoXK9O3N6oZdf18fVDt0veNPvPuTHapkfnq7HIZU1fPQpIaL130tGGSsvUw+pOZttM0fNq/SWvemHf2hrtcwL3Xoc2mS/vb3pU/bcWS2T2+sgNa9ns9286U89pw/mVWv1C9zd68/r7vU/p3WX9Wc7iCRxInE8fE67xP9865zx3GusObU87Th9bdPXNfm8/3ltixn6M9lh9x6p5sk8I2+svFJn+ig49ovvUPPaHvdfw7fvoM/X/XfU10nPv+a/vk++qI+jpcv05/Ryxd8OY4hJ0XglkM/V9/aRXyJlC4LA+5u2Qu19jRG6oxR5BeN6bjZZH1e9v7nCm/4/pX9Ty1z72bvUvEa24E9jd6ypm01T8xb+zZ9+913+ZyERkY4p+luo5uZeb/r7NluklnnXL45X82TKpt7kaPZWapH83J3UvDWR/7xeed0/Zjs7GyfYsMICAAAAAAAAAABA5tiEAgAAAAAAAAAAQObYhAIAAAAAAAAAAEDmNuo7oXbbbTfv7+j0efDBBzfmUAAAAAAAAAAAAJhANmoT6l/+5V8G/7+np0cuuOAC2XHHHWXfffcVEZF7771XHn30Ufnc5z63UY0EAAAAAAAAAADAxLJRm1Df/e53B///k5/8pJx44oly+umnD/vM888/vzGHAQAAAAAAAAAAwASzUZtQQ11zzTVy//33D0v/6Ec/Km9729vkoosuGnFdrtorrhINT09if4FYSe8rpOdVqv70akUtEi9eqObt8+LF3vQ7v3y9Wqb3j99S84q7vVvNm6iSrpX+jHD49R4s07lCzQuKzd70t07ZRC2zNteh5s2Y5P+atGJe/7WTTQUrz3nTXblHLeOM8afmJZ5x7kvDOlHU92c9gSdNRERyeb2ufEHPK5b86a3tapHc7G3UvCeb9/SmX31zWS2z/Y76fHjisdfUvInq65/wn+92m+lxpuu/z1HzXr7j7970nqd71TI9t+p5mqfb9TGWb9HzCh3+8RcV9Ft8kNP7ItTmQOiPdXFZj1kQCXJ5CXzxQ1vTJErMEBEp6XE9VNY7iXYcERHZSs3Z/YyjvemXLdK/TrR7rbKuEpGm5syWnA2jvd0/93J5vY86OopqXlG5leQi/1pCRKRUmKTmTe3wj4nJLWoRbZqLiLGsGKNvmI31boCIVKtOwsrwTkqUC2ctExOjrytVf8FyWZ/jq7v0e87i/Ie86X+9+wW1TMdUfS2/6tVVat5EZZ2v5p9230zNKzX5r1WPvpSUB5/R7yW7HHCiN729SQ8oy1fpA/DFRf57ycouvb413VaeP0j1KufbW/8S7k0liWNJqsPHgwv9/Zw4PaC4RL+BxLESu5R0EZGq9n5HRPLKTXZtb5NaZtZW+jx6afGLat5E1Tq5zZseRfp1uvmGZ9S8fMH//PL/fq/Xly/qzzzNrf41VIvxnNTSatSnrE1zOb19xhCTSlV5VlLCZ8/akX21yZuVc06cET+GfT7lukYLKWXleoqIvNqpH2zarvt503cynplvVuaeiMia1zvVvIlK+1qf0HgQWfWPlWpeqLzbWLu6Sy2zZpW+ttrnnf5n5Kd3Ol4ts/0sfR2svXrpLusDc0W3nrdKWUN19frLrDHG61jL7LGxqalJ7r777mHpd999t5RKxgsVAAAAAAAAAAAAvOFk9mOpX/7yl+Wzn/2sPPjgg7LXXnuJiMh9990nF110kXznO9/J6jAAAAAAAAAAAACYADLbhDr55JNlyy23lHPPPVcuu+wyERHZYYcd5OKLL5Yjjzwyq8MAAAAAAAAAAABgAsj0F/QfeeSRbDgBAAAAAAAAAAAg200oEZFyuSzLly8f9iW4m2++edaHAgAAAAAAAAAAQIPKbBPq6aefluOPP17+8pe/1KQ75yQIAonjeMR1uUpZXMXTNK0Oq+5qRc8r9/jT13bpbVv5mprXueQlb/rc98xWyzx3wWVqXtvcP3rTm2dOU8sUNpmk5gXtSl5zq1pGSs3KgQr6cYpNRp6/vqBQ0svkrbzEm+4qyrUVkZZCUc1rnawfS5Xo48/1+NvhjHFptV07lvOk+9KwThAEEgTB8Iww8heIlHQRkVxez8src8WYQ5LT8/5pc387phyuj+tZrb1qXu82C73pyUtL1DJixEHXudqbXl2jx9VKl3/Mx71ltUxSruptONs/9l8oG/Ouqs+XfKv/egSRZ/wMlGnRb68udnXXl2vS6wtzytgM9fq8Y38D5YIwrCsdfYIoJ0HkiRFF7brpsSYwYoN2fw3bpuhl5ujHym22tTd9xv363Nt8bpuat2KFf54n/tu4iIhE1pzI+cddsaSfUyHvL1MwymjHERHJ5/zt06akiEgY+ue/VS4X6WWKeT0vVvq2q1cvY9HalzfPt/7jhEp8ssYKRJI4kcRz0Z3z92es3ItERKpVvbO1a7q2S7/HVir6sbRyOWNgbbGj/sONWgww73sNwGqfFgtzSkwTEXGJERuU4FCu6n2+olM/1gOL/fXlc8YYi/Xz7Sn7j9Xdq5dZa+T1lv3tKPf61349Pfp9Dn3vd5zz9KkapPWxE4sea7TR6IybQS5vrJeVefTok/pz0nY7z1Lztthuuje9VxlXIiLlst52X/wWEalW9Xm0/g9+b6guEbv/9OOkWzeEyjNFaDxXR8YiyjvuxO5zrYxVLqes70REoqj+hY3a7m597EGnrV+sdU3FeC3cW/Ff7861+jh4aKk+5gq53b3pz/9Dj0877LGVmvfy8yu86Wte71TL9K7V3ynGynsPK25o0q6tgjrfN4jYc0+L/aVW/d305E0nq3ndytr070v0a/jKSv3dVVtJiYXG+xor7vYqy5ReZZyvXZMuho+GzDahjjvuOMnlcvL73/9eZs6c2fALfQAAAAAAAAAAAIyezDahHnroIXnggQdk++23z6pKAAAAAAAAAAAATFCZ/Q6dHXfcUV599dWsqgMAAAAAAAAAAMAEltkm1H/+53/K17/+dfnTn/4kr732mqxevbrmDwAAAAAAAAAAAN48Mvt1fAcddJCIiBx44IE16c45CYJA4lj/4jYAAAAAAAAAAAC8sWS2CTV//vysqgIAAAAAAAAAAMAEl9km1AEHHJBVVSJx3PdnfdWK/nlNpaznlZW83h61SFKuqnm5pqI3fdI20/Q2GHItTd70MJfytyjGStu1frXyokgt4qpGnwf+tgehXp9WRkTEVZRr1aOXSfQjSdC7Vskw2meJ/X3hEqMVxvVwiTLWfenaZ9EnCv3jOFTGjjVGw8DIU+pLnFok6Vqp5lWfe9SbPj1fUstUVqxS81x3p5qnMvoiyPlvK2GxoJaJqtasVI4T6H2eVIzroZXRrpPBuoGGeSNuKdc+MMZRYLQvUO4JoRGnzfqUPK191rWASFAoSVDwzE8lRge5vF5Zmrhu1FeN/OsMEZFnlvuPFRlTZcZ0/VilJv+M6e3Vz0mbKyL6eIwifTzmlLmipfflqVlqX+Qivd1WqNHKFYw2WPU5pRlxovdRr77MFRHtvPT6jK5Qb52JcpxqbFQGqVadhJ77qXVv0VSMRwNNbFyfakWf53HFHHReVtzQwoY1zy0plgfqfTFNXSLGXDb6vBLoa6uw4m9IT681x/TGlyv+cmnik4hINfb3nzVUenv18y2X/XlVZf1ZqdS/Ln0zSRKRxDPRtOuddpWorUft9a1+NC0OrVrZq5bJF4x3HsogtuZlGtYyO0wRVFyKdbv1GGzRrofV7tBYx2m0uSyiXyernLWWTNPnmt7u+u9/byZx7LzzKVTmmDUOrHWD9i4yTvRr3aW/MpZYacaqNXoZa43S3NbsTU+q+jlFxgNbpde/yKsaN9lYOSnzvaZBi+9Wu3N5/YGooLyLLzXr78hyOX2el5V1wOudxjseI/SvKtb/jGfdPbW1rtaGtb2N874ms02oO++808zff//9szoUAAAAAAAAAAAAGlxmm1DvfOc7h6UN/SkwvhMKAAAAAAAAAADgzSOzf0v6+uuv1/xZvny53HjjjbLnnnvKzTffnNVhAAAAAAAAAAAAMAFk9i+hOjo6hqW95z3vkUKhICeddJI88MADWR0KAAAAAAAAAAAADS67b9VTTJ8+XZ588snRPgwAAAAAAAAAAAAaSGb/Eurhhx+u+btzTl5++WU588wzZdddd62vsjgR8X2HlPa9UtWKUVdVz0uU+lyiFglykZqXb2vxpoeFvFrGJfqxomLBX5+SLlL7PVwj5pyep/WR9R1fVl7Of76uWtbLhMZeqXbtwx69jNHnLue/VkGoX3ezfcqxnNavInqfG/X5P2tcV+jSzCFLiriVdK5Q81zZP7atMeoq+nxwXWv8GVZctSjzITRiZ1jw34qs+GjlBUpMy/qnLgJj7ge5sfseRC3uW+2TUB/ngZGH+rlcQVxu+H07kPpjtBP92mhTorusH6ezS59Hnd3+cpExrFqbrHPyt72nrK+RqsYSTj1KimFvTZVcpJ+T1hdWH4WhXl9eCZORUcY6lnY7M5d9xjKjqoY1vcLE6WNWux7aObGsscWxkzj2dJIvbSNo4yfWB4gkxrNBolzY0LgXxbGxBqj6yzlj4FvPT1ozrHtlmrmXbvmp90NiBMNKpf41ShzrDezNKWs/46QSozMS5fp6x3e/alXvCy2vWvGnV8p8l7UlDP3zM817CGuMpKnPGTeKuOJfVPT26nMlNurT2mfFGot2KHNdrsZPayFiVFfPu4aRHEuR9nFbvb5GE6xXU1p9Vryz4m69yr0pFrpvInHiX9cESuxO+wirzdlK2XjWNw6m3VvWrtXfr1j3ZW2O5fL66/yqkaetocIUscul7HQtflrnlC/qz4xaXmTUZ11DbR3Q1aXP2SDQj9Vb8fdtPpfuGa9e3T2N834ns02oXXfdVYIgGDaB99lnH7nooouyOgwAAAAAAAAAAAAmgMw2oZYsWVLz9zAMZdq0aVIqlbI6BAAAAAAAAAAAACaIzDah5s6dm1VVAAAAAAAAAAAAmOAy/YqMO+64Qz7wgQ/I1ltvLVtvvbUcdthhctddd2V5CAAAAAAAAAAAAEwAmW1CXXbZZXLQQQdJc3OznHjiiXLiiSdKU1OTHHjggXLFFVdkdRgAAAAAAAAAAABMAJn9Or7vfe978oMf/EC+8pWvDKadeOKJcvbZZ8vpp58uH/nIR7I6FAAAAAAAAAAAABpcZptQzzzzjHzgAx8Yln7YYYfJN7/5zfoqS6p9f9bnEv/nndPrsvISpb5I75agUFDzci3++sJCum4O8/5yYVFvg+Tyel6Q4h++aX2kXYsN5Llq2Z9htS2MjLwePU+Ts9oe+9MDow1jyGntS4anu1jpa6RjjfnEiDOxJ5aJiFSM62PNIaWc0QKRWBk3VjuqFb2M1RcpBEHgTw/1uBDmjDmpXA+r1Wn+WbAL/e0WEZGqkaexxpF1LIXVf4FRn1Uui8+/2VTjvj/rS5L6r6k1RHor/szeql6oq1fP87VZRCQI9DLFvJ6nLrmM4aO1QcTui3pZbVDCk1kuCvXGWcfKRf5y1hSz2pdGYqybY+c/mHG66eKaMlayvOZvRHGcSByP/P7sUnaoU8ZIbExYrYxFixkiIoFxnsqqS1yiT6Qo0ieSdq83QqGESqZT5lBfG/T6rGWcrv61WmKMiWrV6j//sbT1nYg9JrSxGRvti+P68xJlHFWr2a5z3+zsNWea9a0xrozAUa34J1IQalFDxDnjvZDSjDTnJJI+JmcpzHhNn2aNYvVDovWtMf+tp+SUlyozlTKxxhJXk8zisTW9tGNYawPrfpko47G3V7+Zl42xkFgLIoX1fB4pDyOJ8f7CKfU5Y4FirQG09qV9RxEqi6jQvF9Yax5/n3d36/cL63zjxN++nDHGtOdCkfpjV3fvOAe7ITK7y8yZM0duu+22Yem33nqrzJkzJ6vDAAAAAAAAAAAAYALI7F9CffWrX5UTTzxRHnroIZk3b56IiNx9991yySWXyLnnnpvVYQAAAAAAAAAAADABZLYJ9dnPflZmzJghP/rRj+Tqq68WEZEddthBrrrqKjn88MOzOgwAAAAAAAAAAAAmgEw2oarVqnz/+9+X448/Xv785z9nUSUAAAAAAAAAAAAmsEy+EyqXy8kPfvADqVb1L+kCAAAAAAAAAADAm0cmm1AiIgceeKDccccdWVUHAAAAAAAAAACACSyz74R63/veJyeffLI88sgjsscee0hLS0tN/mGHHbbxB3Fu4+sYKlT24IJALRLk9C4LSyV/ej6uq1mDoqjuNmhl+hqS2Z6jiEv0vMS4TolSzqzP6L9qxZ8e6OdqjaJAOZYLx6hf0/L1q9bXsKWJM9YYTZR4Uu41yhjXLs2/OI1TzCHrOFZ9GmNOBsocCnPGPE70ORnk/NfQmqmx0edh3h9zk6reD5ERF1wDzE2tz/sy9XtgJp9/k+mtOOmtjDyuWLdQY8hJJfYX7C7rZXqtaa4M09C43Hll7ln1WcPHOt9Yi60pBIHebut8tbZHxvSKQuNYSjmrPqt9Vl4aWugyL4XVdu04ShdZcwMiSZJIok00j7T3okS5EM5YP7k0F88YO1bb052VsUZRmh4accMpk88oYkpzm7Wuh9Z9UaQfKIn0+qoZBxttvJiPmMbYV2OXklGtjv86rZEFQSCBZ1Caa8sUwszHlXK9K+l+m4+vD0REAqPdYSO8NxhDWb++c8paN63xnunVKgsbSxw7ib3X3H/l7PuefrXVuWzcfK1j+dssUinrDzbWfSdWYlSS9QQbQ1qctO4j1vVIw1pTVJRn90pZv049oX4v0cZLznjfZeVZr/19eiuN874ms02oz33ucyIicvbZZw/LC4JA4jQvLQEAAAAAAAAAADAhZbYJZe0sAwAAAAAAAAAA4M3lzfXvgQEAAAAAAAAAADAmNvpfQnV3d8ttt90m//zP/ywiIqeccor09q77rpMoiuT000+XkvJ9SQAAAAAAAAAAAHjj2ehNqEsvvVRuuOGGwU2on/zkJ/LWt75VmpqaRETkiSeekFmzZslXvvKVjT0UAAAAAAAAAAAAJoiN3oS6/PLL5etf/3pN2hVXXCFbbrmliIhcdtllcv7559e3CZW4vj+jLQj86bl8yuqU326YS/l9WVp9UaSXsdoeKuW0fhARCVP8xkZnnK9TrmsS60WqFb0+7ZxivYxxtuK0+kL9nII0fTQWjD6FQft+uzjj/gyNGKfNk7SsOVmt+tNjJV3E7gut/6w2pGDNuyD0z3KnpIuIhEZcTcR/vmFOL+Ose5gVcxuY1udaf6NPNe77sz5tiFhfsVmJ9XFVVcpVjTLWsbT2hcb4jYzbYUFdcerts+qLtVCTcfi0pquWFwZ6I6wlg3a+Vj+Exr1Ea591TlboynqqJ8rBQmJKKi5JxHkmtdbPZl0pJpJ538uYdU6h+IND2lVI6PwT0FmxQWme9QhnLa20mOKMRkSRnqd9l7NVXxzXPy/TPiKpS0ljXFp59dYXj+FYfjOw1g1pnqOtWGONg1hbOBiMpyGJlJtzoMQMkezjJGvwDRvLe1O9986q9hwOERGpVp2Engcc7V5l3aese2Ia1rjSsqraw5qIVHr1saDFLjMWGg95adaFmiDlew3tvmDVlybeWeeaWM/ISp9XKuneCWrtKBT0haE1XkJlPGv92tub7bu4jbHRb88XLVokO+200+DfS6WShEMWE3vttZc89thjG3sYAAAAAAAAAAAATCAb/S+hVq5cWfMdUP/4xz9q8pMkqckHAAAAAAAAAADAG99G/0uo2bNny8KFC9X8hx9+WGbPnr2xhwEAAAAAAAAAAMAEstGbUO9///vl3//936Wnp2dYXnd3t5x66qly6KGHbuxhAAAAAAAAAAAAMIFs9K/j++Y3vylXX321bLfddvKFL3xBtt12WxERefLJJ+UnP/mJVKtV+eY3v7nRDQUAAAAAAAAAAMDEsdGbUNOnT5e//OUv8tnPflZOPvlkcc6JiEgQBPKe97xHLrjgApk+ffpGNxQAAAAAAAAAAAATx0ZvQomIbLHFFnLjjTfKihUrZNGiRSIisvXWW8uUKVOyqH7jBIGeF0XZHivc6N9uWEtre2AcxzonLS/KZBhsFJfEal4QGudUrfjrS98QfxuM9jmrfVbeKHPKuaCfc31/1qeFDN9nR5IXV/3piXF9jPGmxgWrDdaxtHFSVdptlREZ/EGETJgxVW9DoMTIIDTaZuRprXBWfUafB4n/Grokw74bBUHob7eWjj5xLFL1TOlYmSvWdK0aeZXYX5/v2IPHSjFfrWkZGXku0o6ljx+r7aEy/9KGao21jNTyrCmRpr4gMOJTxtMvTX3K0OurL0UbEiUWauno4xLn7aM09+U09yNnBS9DoAQVsw3GwNKaERrrhjQtD61gqLTdCGkSGvPcaffflFNCX0rqFQZW8BojadeY2pjQ6kusoAYJwtA7bxthPWjdJ4LAPxASo92BUV+sRA6rTGgdK8W7JJdirDbCXE4r0+dMSX/f0tS7TkmshS4kiZ03HmvrAysGWa9X0rAutXYPiY3rXa3o7160vCTW60vi+t/XWM+FaeZKmphmsdaFWvusmGFej6qy7ipnGz+tkBZF+rGiOt/L9JYbJ9ZkuvswZcoU2WuvvbKsEgAAAAAAAAAAABNQxv90BwAAAAAAAAAAAGATCgAAAAAAAAAAAKOATSgAAAAAAAAAAABkjk0oAAAAAAAAAAAAZI5NKAAAAAAAAAAAAGQuN94NqEsQ1JcuIhIa+2zO+dOjkTdpxMdKQz1f4zih0ReRcmJW/6Vpg8Ul/vTEaINZXexNDxKjfUn9F9gZ1QXKKfUdy98+CdMOsjpox0afxIkknounjXnrOlu0+kIl/ojo88SixTMR/3luqFxc1cvExthS2u4So30pBEasc0pe4OovIyISaD+vYfWrcT9wymCyzkky7j+Mndg5iT3zrKpMI+tSV2I9U6vPKGIOYU1kLTOMuOaU+ZcYsSsn+sG0frJCoZWXRqplqbnk8jcwzTLNOpZ2nNFgjjElTFp9BJ1zTpxnkGd9/3VpAkeK+gLrPmqdU5pbtrHI03KsNmj389B4oDCWKPqjqfF8Yi3VRPxtN+NTiokZWAHK4BvHGyyTYpxrRWLrxom6pRk7Fmt8WPFJW+tbYycWfSKFyvuLMKc/51tjK1DaEWbdfynKWPHYPFbG94s0khSxIU0MMutT2pDE498/jaxarUpYGf5OQru3ZB1rLFbcSJQbcGxc70R7kDPyYqOMGQsbYF6OFes6WfO8WlWeyUK97+w1j/9aWW2IIz3uRsoDudaESrlx3g3zL6EAAAAAAAAAAACQOTahAAAAAAAAAAAAkDk2oQAAAAAAAAAAAJA5NqEAAAAAAAAAAACQOTahAAAAAAAAAAAAkLnceDfAKwz6/qwv1j5v7KU5p+dFSrp2HKuMJTHaYPH1gYhIYJxvoJSxyln9Zx1rrCTGBYmU9iWJWsQZ9Rm9p9dnDZjQP2ACvXnZMfoABjVmGP2Zpqut2JQ1ayw4JS/Wx7Wz2p423o2BwIhnQai32ykXOLB+jsPqcyvm1tmGhqDdqyAiItVEpOqZTtpUia1QkyIv61uBNXxDYw2iZWm38b769Hmp9ZNz4z8eA6Pd1jJNXfalKLOhcnjjcYkTV8c92DX4OtFqX5DmPmqsXcxbtnb/tdqgxWPjXh4a9cWxv+1GqDHjp8YZASVFdSIydmtCc22qlVHmS6L0N8ZWolwfa92Qpr7AfDDXD5ZoWb5F38CxzEWUP1mb/5Yg6wWA9T6mAaSZ/yJ6DLDL1H/vTJT2xcbzNkSSaixxNLyPQu1eNYbdqcUTEZFEeUixrndixI1YqU87jojdPm3cp5oP5nshY64ogTz1XE4xx8Kq8W5IiaFhZD3r1n8vSYw+iiJjjCntCJV+rVYbZ13TADsMAAAAAAAAAAAAeKNhEwoAAAAAAAAAAACZYxMKAAAAAAAAAAAAmWMTCgAAAAAAAAAAAJljEwoAAAAAAAAAAACZYxMKAAAAAAAAAAAAmcuNdwPqEih7Zi42ygRGhUp9kVEkserT2uCMvBT1hcbeodZHIiKRcmJWG0IlzzrOWHJJPckiIhIketu1K2VeJet6JP6x6cag+5zVCRDnnDg3/IoHidJv1nVOE4PiMbw+nvMcpJyvr2/WZRptV+fk2J1voFwrp8zHvjL13yuc6OcUWD/jkaYvrPE3zrT+Rp/E9f1ZnxYCEmPu+eppJNZQiNTz0ueeFYa00GrFrrHqPzOcGLRzsuqzlnCBsv606guNCrXrG6U8X2TLJcmY3GutGJUlayza5+kfqNZ93owb2rLQWAOok8UokhiZobauifV2Oys2aH1h1Bdaz7MNrt7Y3+j3WuicefGUZxTrppgi1hivGiQ06tMer9Kss536VmNDzzyNzb6+aeqr/56Z5h6otTvr83mjSeJEEs8Dk/ZIn3Zsp7kO1tjRxkhS1d9FxMa7Ia2c2YZYP5bWPqs+893QGLHXasozj3FtfWNrMC/091+1km38dMZiLU1eqJxStdI474Z5cwQAAAAAAAAAAIDMsQkFAAAAAAAAAACAzLEJBQAAAAAAAAAAgMyxCQUAAAAAAAAAAIDMsQkFAAAAAAAAAACAzLEJBQAAAAAAAAAAgMzlxrsBmQgCPS809tmSRKkvMo6VYt/OKcdJW1/a89XKWW1I1b5s9zZdEhuHMq6VRrvuVhuMPONqZC/N+cLPJd656bS9+dgYh9ac1FhzNY0U41pExDlldFtxK9FnhDPy9DLp2l63UL9OQaJfDyf+ax8Y19CJfk6BMsasfkgzxtRrizEVJ31/1pco1yftdIiVy60dZ0O06WJMI4mMvEQbw6HevjjRK1Rnn9GGoAGmhNV/Gmv6B41wUoasb3XITtrY0Oj0e6k+GIMUEzMx1juhtgYwn0v1rFh5FrLaHVprFOWGYcUafRWsS9OvljRrzEY+zkQVBIH32oZpnodSMJ8bjHEfKAsEcy5b97AUsSY23ipo8yXM+DnJfjU1/jftrJ8L09zr0saAets+Zs/AE1QcxxIa72CGF8j2+NY4sK6d9gxuxZqkqjc+Ufog9j1gDrQh4/c1WdPmpRWBzD5X8tKUERFJlHdDgdHniRE/q+oiz1irWeNFaV8U+Y9TNdo91sb/LgMAAAAAAAAAAIA3HDahAAAAAAAAAAAAkDk2oQAAAAAAAAAAAJA5NqEAAAAAAAAAAACQOTahAAAAAAAAAAAAkLnceDfAKwj7/qwvTPyfT6y9NKWMiEgU+dOdM6oz6tMEynE2JEyxRxgERp5SX2iU0aQpMxqS2J9udJ0zLmGaszJGiwShcu2tcWRdd+18N/azb0aJ6/uzPi3OGFya/fx4DK+PNeg1vr4ZQX1OG9tWfQ0uUOKdS3tOSn1Byp8L0fo8sO4HGRqr40xUiXOSeNYVaaZKmiXIWLJuX6F2XokxftRCej85p9cXKVnWsi9raaZLEOgNTLeE0wulWXqiMWixZqKyzsUaw2mY93NlTlj3vkSpL7SeS9NMPqO62HgO0NY1ljBF+1zc2OMxUW6qcdzgN1ukos9z/XonxtpcnRKpF2v+CmPjbUOauWxSnk/TxtxGuCeleV5Tn2c3VK7O822A7mloSTWWJBq/d1rW9dTu8yL6+LHGYmK8G9LuSdY4teae2r4GGJDm3Iv0eKz1rXkNjbxA6fPQiLlx1Rqr/vfCVeP+E2kPriKi3be05+C42jjrGh41AQAAAAAAAAAAkDk2oQAAAAAAAAAAAJA5NqEAAAAAAAAAAACQOTahAAAAAAAAAAAAkDk2oQAAAAAAAAAAAJA5NqEAAAAAAAAAAACQudx4N6AugbJnFiZ6mSTNPptRXxTpec7Vf6ggqL+MWZ9xvqFyLKuMlZdG1vU1giRWs7QREYTGOEqM8acJ34D9Ol4S5app80dExKW4ZmNJOyeRVG13Vn1ZSjMXxlBgjQnjZzycdl5WfUafBynmv9oGTFhjdUnDlOM00opZwzex5phyrEBvg9a8rJdiWTNDjVnOXzDtkkG9himlPS8gMZ65tHFv3fes+6i65kkxj6w4HVrPn2qhlJM5xaFi43nHXg81Lu3aujTP9FDZzw3WpPCP79TzSJsv5nzQMxMlCKR+LE+1kBubdwCx+lajMWT9XJM2BiR1PiNb9zKIxImTMB5+bbVnkXr7f0OscWXFNW38WPXFnvPcUDm7TLZ9ofWt+VyYMev6aq9XzTLWNQy0Ps/6fI33wgbt+oaR/54Qx40Ta3hzDQAAAAAAAAAAgMyxCQUAAAAAAAAAAIDMsQkFAAAAAAAAAACAzLEJBQAAAAAAAAAAgMyxCQUAAAAAAAAAAIDMsQkFAAAAAAAAAACAzOXGuwFeQdj3Z30u0T+vCZUyliTl3lyQrljdwpQH0vrJ7D/lWGnKTGSJMY7C+seLS2I1Lwijuuvzts9qM/riiRZTfNLGhUZQz3kOFnFGnlGfUs4q45x+rDFjxK1AufYuRb+KiARKzDD71YqrxrWqtw1pZFnXG5FLlBCtXDZrGMRjOFUi5bIaty+TOkysaWQNrSTNWqMBYk0KYZBuXZVmakYpDkUIeOOx1gBZCzJ+bkiUNYU1j6z7r37P1vtIOydrvZNm2R6aAdQqmO2kdcrNKUgZu8aKdj0aYl06AaWZe43AvN7mFPNnJil/zjvVtOR5X0Syn7NJynug+SyXweffbFySePsoTtFtadY11riyrp02ftLWp7U97fsarR1px30jUO/n1nWK63+otd57JIHVf2keoPX3wk69rSr3pbF8ibABPDYCAAAAAAAAAAAgc2xCAQAAAAAAAAAAIHNsQgEAAAAAAAAAACBzbEIBAAAAAAAAAAAgc2xCAQAAAAAAAAAAIHO58W6AVygiYTA8PVH2zFyi1xWk2GcLjfoaQZpzssr5+vpNyiWxNz0Io3QVKvWJUZ/WBkvq9r2JucSJS9yw9ECbD1acaXC+89xwGeN8U9TXCIJQj53m+aY6lh5XteuRun1pYvgEvYYYf+ZwszK1MWctaaxpmWYplEzM9Y4RGlKJUnZDmnawxGxcadYGo0G/J2Y7eBKnn28YWPdsfyCy79n1n5Mz2hco7UtSXsPQDK4Zyjp4ARtgzQlt3Ftz2aLH0HTzK0mxsGGK9UkbCzVZPxdqY6VR7sONKokTSeLRv1+lud7WmNPu59ZxrLEQK31g1mesKbKeL1my+sGFRp7SF85Y31n9EAT++uK4/ne1fbRgna4+fT3pP04cN84157YFAAAAAAAAAACAzLEJBQAAAAAAAAAAgMyxCQUAAAAAAAAAAIDMsQkFAAAAAAAAAACAzLEJBQAAAAAAAAAAgMzlxrsBQznnRESkc223/wOJVlDLSNuQjOvLWpBy71Arl6Y6qw1hUH+5wCgT6scKwkgpo6T3ZRp52nGs803RgWb76ufrh86utSKybl6hz2Cc6en15gfW+J2gXFL/GHCJEQdTjCmrPnWMWmWMc0oVwq3zVY7lUt4rUl2PrO9LKdqg6ewtiwixZn0D/bFmzWpvvnYJrKEYG12slUuM65Ji2JtDx8xTMu0yep7VF2nqa2RplhmWKOVtLtVyJ8NbateaThEh1qxvoD8q5TX1lcvwPjAaxnI9FlrPIQrz2UAtk+6cghTtG4121H+cifnzrpXevrlErKk10B/VSldd5cz5ZYxFbfyknQ+hcixrnKY5Vup5nmK+pIldb0TWWjcN8zk4VX3+9g3ct4k1tdKua1IfL8X11p5rRPTraR7HqC9WyqV6vyLZPg9ZYcuKn2Hifx9qxbRAKSMikkT+hoSRXkZrg4hIosTxMLbaYBxLaZ91v7DarvVtpByn3Ns4z1CBa4RW9HvhhRdkzpw5490M4A3l+eefl9mzZ493MxoGcQYYHcSaWsQaYHQQa2oRa4DRQaypRawBRgexphaxBhgdjRBrGmoTKkkSeemll6StrS3zn/gC3mycc9LZ2SmzZs2ScIL+JOJoIM4A2SLW+BFrgGwRa/yINUC2iDV+xBogW8QaP2INkK1GijUNtQkFAAAAAAAAAACANwa22wEAAAAAAAAAAJA5NqEAAAAAAAAAAACQOTahAAAAAAAAAAAAkDk2oQAAAAAAAAAAAJA5NqEAAAAAAAAAAACQOTahAAAAAAAAAAAAkLnceDdgqCRJ5KWXXpK2tjYJgmC8mwNMaM456ezslFmzZkkYst88gDgDZItY40esAbJFrPEj1gDZItb4EWuAbBFr/Ig1QLYaKdY01CbUSy+9JHPmzBnvZgBvKM8//7zMnj17vJvRMIgzwOgg1tQi1gCjg1hTi1gDjA5iTS1iDTA6iDW1iDXA6GiEWNNQm1BtbW0iIrL08Uekvf//R8Qlel6g7/IFubw/w9gZDMJIP5aWZ9QXJ/Xv7FfjuouIiEgldukKeiTZVbVBYYoffshH6X5iIlf/JZRAjM6oVupugyv36HmJf6y7Su+wtNWda2SLnfcYnFfoM9AffzvhCGktKDHAx6Ub9Oo1M+rTyoiIOvmSOF1gcCkCijMCgHq+aYKGdZyUcXCsBMatQmUEu8DM8weoIGfdy/S8XKnoTQ/z/iXDmnJF3vbTa4k16xnojyVLn5P29vZh+Wl+CMm83yicpLsfWmFILWM0T6sv7XpCW9NY7dbCrrU+suqrKsVio0xsHUttn16f2T6tj6zrZC1plPqs24i19FTbp6yN13Z1ysfetyWxZj0D/XHCaY9JoTS8b8pl/wXK5/UgVKnoAytS7i2JcbFDY10epVjoxykCh7XusmjnZa1rtBhgzf+qMdETZaJbPyFurQu1NYC5/jSEkX/RY7Uviox1iDI2rT4vNukLL22MFYr+dU1vT6f898nbEWvWM9AfBx93h+QLrcPytX62pl5ojANt7Rsp480qI6KPR6uMNrat+qyfMk/zjzqs9mnSvD8RSbcmM58LlSyrH2JjEaX1rRYjN0S7L6R9rtbGS055yVTu7ZSrztqVWLOegf5438fv9MaaRLluoTGwrDGXU55xLaH24lBE8sWCv4wRG/IFPU8Lk5Gxjmtq0t9z5XLKPbGg90Ox5D/fQl7v2Hy+/oDSXEi3Visq5YzLZDJuTapcaKzxlGcb6xnKykucv77esj+9e+1q+fpH3tIQsaahNqEGbuTtbW3eFzYq622k8SaQTaj02IRaJ/tNKP9NS8TahNI3rvgnzLUG+qO1kJe24jhuQqXYyBERYxMq3T+rdSnehI/VJpQzYpYzbvKNIEgRg6wyY7oJpcyLMG/PF2JNrcE1TXs7m1BGfWO5CaVv8qTchNJeNKfYGBJpjE2oNG3PehNqQ2tjYk2tgf4olNqk2OR5fgr9F6hgvPAIIn0g5JR7i7XBElmbUCnul9axNGk3obRj2ZtQytg2N+qMTShlYjb8JpSxdsl8E6qkv9bQxpi2CTWAWFNroD/yhVb/JpRyTa25Z27yjNEmVJh2E0opxybUkLxG34TK+Ic71U2ovP0mnFhTqybWFD2bUMp1s+ay1cdZb0IVSllvQvnbrt0rRUSKKTahisY9Mc0mVCHFJlRTMd1ardQIm1CRsQkVj80mVGhcD5HGiDX84lEAAAAAAAAAAABkjk0oAAAAAAAAAAAAZI5NKAAAAAAAAAAAAGSOTSgAAAAAAAAAAABkrv5vYBsLLhFxnm/hSpRv5gqtL4ysf58tMOqTnP4Fb9qXf6f5kmwR/YvItC+73VB9WX/JeCPQvnswsb4A1fguNu0L3grGTDG/AFEbL9WKUaEx/lJ+6SaGC8KgrvjgUn5BqfaFp+aXP1tf8JpiDKQrk64N6vkaX8Zt5Wm0L+m2WMcJjC9G18pZZcQYLmGKb7o0v2hZ++LmvH6/Co2gFhX9X6YaNRW96dqX1KNPFDqJwvG7mQaS7tjWvU1lTEvt1pZ23aI2zxqOSn2R9SWtxrXTstLdLdKu0+pfE1bML8HV69PKWe22jhUn/n6vVP3pPZXx/zLdRlapJBJEwy9GpNyrYuNaF4wvyNa+1Fg7zoby0rDq09pXrRprF2Me6Y0w2qD0rXUvKBhfMF6u+NturdViI4ZrX46e9vuqtethrl2Mg2nFis362sX80nllnaKtJdOsMaHPI+vaWGMkivwLB7uMEbvUcW/UZ3yrvVYsbbzTzivNF8mnWcI1isTpfa6NMaesJ/rqM46lPeOlHGPFor/tTc3+Z7Le7rLeOEjinCSeC6i+i0j5XjhWYn4un+6eo92bw3y6e2Kx5D8v7V4uIpLL6fUVCv76rLVfQWl7Ia9PsKL+KkKKSrl8Tq/PCMdSUMpZ4dN6JRME9a8Lq3H9cchabmjPSSIi2rJVW2eO57uI9fHmCAAAAAAAAAAAAJljEwoAAAAAAAAAAACZYxMKAAAAAAAAAAAAmWMTCgAAAAAAAAAAAJljEwoAAAAAAAAAAACZy413A+oSRv70QEm3yoiIhGOzB1eN05WLE+dNV5L78pL62xE7o8IUxxlL+SjwpofGKYX+Iv38BctVvVDOGGI5pX2BOS7rHzCBZyz70rBOEAYSeAaD0yZYYAwcYw75jtFHvz4uSRk0UtDO1xmTXO0jEXGxUp+SLiKSxP5jWWXSsOpLcyyrTKDMfRGRRPznmyvot+TQCDRRseBPbyqqZXJmXsmf3uJP7+3pVeuC9N0ws7ppjmFsMO9Tisi47zhR5oTVNcZtLK/UV7HmslKftWaIx67LVdbwsfIqSturRh/1VtLUp5epxnosVEK/Wp/VNugibS1qrGu0MiIiYVT/+tJae2vrpJTLLrVcLp9uXVyt1B+/q1VlXWM0PDbmpdbnVn0W7dpbjw5WrNHK5XJ6hdYY045lldHX2/r4056Vkrj++x/0cWU9k4bGRNdjg1VGP5ZWLpc31tgpYmGaeCeSbl6mKZOG1edpyqWNXVqctOKn9pwpIiJ5f3Iur2SISLGoj5e2dv/zVXu7/xmvZ20DLDIbWC4XSS4/vO+09xTm/DfvEco8MtY7vnaty/OPEeuemCYvX9DHYrGot6/U5C/XVNT7qJD3z7Gmgj73tDIiIkUlr6hPPTFCtVrOisfau1oRkXLVn95dNt4nGWEtUh42q0ZszUX1H6ug9IOrZvtebWPwlhoAAAAAAAAAAACZYxMKAAAAAAAAAAAAmWMTCgAAAAAAAAAAAJljEwoAAAAAAAAAAACZYxMKAAAAAAAAAAAAmWMTCgAAAAAAAAAAAJnLjXcDvJK478/6wsj78SA09tJ89QzWp5RTjiMi4iRQ86rKoRKnNyE2MstVvZymEuv1ae2zaM2Lk/rrso+jtzsMjD5XGhjqRcy8fOTPLOSNi2iMCe1YkTVmrSMp5ZzzjFljHOONxyXGpDTijFbOWWWMOKPlJUbQ0MpYx0lSti9LgRIvRERyBX2O55r8t96olDfKlPS8Fn9evqXJKGPkNfvzguYW/+e7e9S6IPqaRuHq+OyoStGOwLjvaHnm/TCxbub+5MgZZVKsGSJjDZIE/voi45TSrcX0mFYx6qsqsbCr11or6udbqfrzrHOy8/z1aefU3WtcKEg+H0rBuPesLzDGtpWnzZfAmEiRcb/U5HL6uVjt0zhjHllrHqsd9R7LXLsYSxetfdYzphXXtHK5XLZzLDKCoXU9tOtrnZPF6iefOMU1fzMJg0DCOi6GFRus9zjaOIhy+lojNMacNh5zeaOM2XZ/nhUzrFiojntjOGplso7HadptseZ/taI/M1ar/rzYePYLAn28FEv+vJYW/Zmso12vr6PF375Jrf4Xe2vXpHjh9ybiksT7riJUYoD13lArI2LNPWMeGfVp88WaR/8/e38erVlW1vm+z2rebr+7ix1tRvYdSZOJKdiUQIlaHhW4UJQWt2xGIVbdca5YdRwDy1N6uAWWdYRTlJaOY2FRR+oMGXDOFSkbroVaMEwRSpFGBVIgSRLIPiIyuh27effbreb+EWRi5n5+T+b77pWZERnfzxg5Bsy551xzzeaZc60VETs6v6mY0g5iV7en29fr+O1Y6Oq112v7a6zX0WuvK8qYmS11/Tb02rqPojz5aj8IT+Ng+RWD2c9dUShUeVEfRc+TeeaXa4tz3ED8/NOBExYAAAAAAAAAAAAax0coAAAAAAAAAAAANI6PUAAAAAAAAAAAAGgcH6EAAAAAAAAAAADQOD5CAQAAAAAAAAAAoHF8hAIAAAAAAAAAAEDj8qe7AU2oq0rmJXlL56WZn5Hqb3PBpawo/fRpWc9cJioXtiHIK0VeEbSvEllRGyLBpQK6UEsNYaJry7MgU15rnjJmaeKXy4LPv3Jemlmdio73BiThG3MoTdyJokda92cUg+YSTeA5LlWrhRyVCRZrlFeJQBOVKaez39S87ZtH2vbHPu/qtdrq670n73X89H5PlmmvLOprLS349S366WZmSVfnWa/vpy+I9J2hrgtWV6XVlbPZNx03vGs8GaI9KigW7aJKFpzHrPJrzHXzZCuqOtjHo5tquMtV6BpPdZnRRDdwZ6Lq06MR5U0LPy86yxalrk+dS1X6KGgbzOq6ttqZy3ku9jCRbmaWBOeQTJyjw/rEeTiqLzrGZtFBWrZB5wUhQJ6hoj4q1SSek3qeiGLXPH2UheOuy00Lvx2q3WZx25UieNCt5jj7peqZsA43EgiJ2LOjeRCto1TkpcHcjuZ93po9Fqr4FOVF9cVtF+8NojaIPponhpvptkf1Rc+Zas1OJvPFSNV/vQW9ZvuL+plsdclP37eo27dvsZB5R/b57bts1X/turX5jHgd+6RJ88xS52CfiQ0pnvfRuvTry9XLRovXUavtl2uLdwpRGTOzTsfPWwjm9kJXt6/f9ed3v6vX8tKCX2ZlQd/TapDXF+1bCtodPRaqZ5Fh8JwU5amwlgdzrKeHQ7a9nev6OkF9/Y5fYb/j17e1eeGca3hLDQAAAAAAAAAAgMbxEQoAAAAAAAAAAACN4yMUAAAAAAAAAAAAGsdHKAAAAAAAAAAAADSOj1AAAAAAAAAAAABoXP50N2AmSTZ7mXT272y1JTKvqnW5UmQWpS4znuoK1bXGRVCm0tdS7SiDe1L1VfV8bVD3VAZlsmAIJ2Ko8kyPYacV3LAce10mupa+X10mS6N5Pg3y0IhUjE20+JsWXKsO1p4sEyzKWlyrDgJDFSzYauLnVdE9iWtFbaijoCEkQTDJu3rd5T1/q2wtd2SZVr+n8xYX3PT2yqIus6zzkr7I6y/JMtbrB3l+25OuXybp7ui6cH5T9NZgFRwOhGgt60KzXycUtCEJzly12r/ylq4vb8u8TF0r2F9VeFfpj5snmlAWukx0JhyM/Ji3NdSxcDjR9Y2nfuNH6vAUlDEzm4r7KkpdJrrfWbfVcdBumLU7ubU7u/crtc+nwfk1DSZ+nvsTPwvqU2XMzFptPy9ae3lwVE5EuSTREy66ln42iPj3pNr2eNTxJQkqzNLZz4vR811YTsTdeZ8XVUwZB+8Cqjw6O/vp04kfoKro4RiNiuawOlNk0Xm+FeSJOBTFpzBPXCvP9T21gvpScV95K1jnqkzQhih+qlgYvs8az77Oo5jbX9Tnwn7ffyZbXdQBZf+ybvzla35DrtyvO+nAssyy8swxN706e85Nr7e2dWWwvJVb3to95mreR88han1F9UXnmlY7eHcg1nmrpcu0xVnIzKwr3kV02rp9/a5eE0sL/ppdEelmZkf2+W2/fJ9u90o/iO+F/wBTF/p9Z9Luyrxh4bcvet8eDIct9fy2L+lXPNaLxqPj56n0x6svfqftXCeYy081/iYUAAAAAAAAAAAAGsdHKAAAAAAAAAAAADSOj1AAAAAAAAAAAABoHB+hAAAAAAAAAAAA0Dg+QgEAAAAAAAAAAKBxfIQCAAAAAAAAAABA4/KnuwGeuqqsrqpd6Ula+gWSTFfm1POIvD1jy8wK0YQob1rWukzQPFUuasN4qvMKUV+lm2dTca0qKBS1L+gKKUt0Xi6GXqWbxfcr25DqRkT3m2eqz3V90f1aynfjpiRpaonTn17sOf/zemDqYB171zhfJpg485hnYptZreJCqW+qmgR5oh1RmVpcqwoCRhoslLTtB4BWX295rX4ryOv56St9Waa9GOTtW3LT06VlWcYWg7z+op/e021Il9Z0Xs9vX9JdcNPzrW3dNphV5fn/HkPFGqvnjA0ipsjrBGXMzCz115E8i9njNF3VFxSJoloiznBZsE+qvTcL9uRJMft5ZzTRZQZjnbc19PMGY1nEhmPd9h2RN5oE9zvVeVPRF+F+Uc++N6k9dTRseN+8ROQtf01kmV4rWbDHttp+uTzX9bVbuj59ltdzJzrnJ4lfrhWUiY7XWTr7HFZdG10nul9ZXxBA5zkWBkvZinL22FBWUZnoWn56NO4q3pnpfkrEO4SqDC4EST0rqWchM7M0mMSpmPjRM1mSBM/YIq6FsUvEOzMdWzsdPX+ia8nYGkzHdu6vvSieBF0UvNcI+ryr76nX8/O6bd2+5QUdiA4s+4Hj2sO6DVcf0M94tv6gm1yeOCaLjO46K/OqnU0/o/Q7djrY0W2DpVnqnlXSTD2j6HnaFu8HHr6OJzoLRbGhJQ4c3Z5+FxHFDbWOorWy0tdr7NCKn3flAd2GK/aLd1obJ2WZ8iE9v5NcrEvxvGj2OH+DJvXfe0Tnrm5bj+9Sz8/rd3SZfjc4604Hbno13JJlbKSfe4rJSJfzfn4ruM5TjDfaAAAAAAAAAAAAaBwfoQAAAAAAAAAAANA4PkIBAAAAAAAAAACgcXyEAgAAAAAAAAAAQOP4CAUAAAAAAAAAAIDG8REKAAAAAAAAAAAAjcuf7gbMpCrd5KTV0mXS4DubyCv8y5iZWVnVMk9lRfVNS13fZOqnjwtdJr6Wuo6uTzWvCNpdVonMq3UxKdHVWStT6fpCWaorVH3UrnQbyuCmqtq/VtCEeM5WfkMSp4yXhq9LksQSb3KJfqtNT4Kor+syWJRzqMUcqKPYNNVtLyd++6pJUCaorxaxQV0nkrXFAjezvKvzWov+ntBa6uoy/Z7OW+676Z3VJVkmX12Reba86qcviXQzSxaXZV66ctBPX1rTZXq67Unb76ek5afn3U1ZF86vWXfdlpO56pIKcWgI64vWpV9ftI0neXQeC9qu6gvyVDuSvK2bkPhxIzqLjYMz0mDs520OdZmNHd0Pg5G/l2wPdU/sjHXeUOQNR3rcp1HsF/1Uz3O4M30eSzO/H9T1cV6aPM758jGiccvzYP/N/fFpt/TFW7m+VkeEjU5Ll4nr8/PawVNvmur62rl/X1nQ10s9P7PX1oWi/kvFw1AVPYMEIVfFrmGwLQ1G+loj9cwabEvBFJPPs6OJ7qOFYHeKyuHpFT1DpSIvinMqPkV57bYu0+noidrt+UGl0wnaEMz7tohdUSxUedF1xBZrZmaliBsq/fHqW+j47Tu0ogfx2kO68av1WTd9+sCdssz4i/fLPNsSzzCTkS4TPHNLudiAdoaz13UJaXfa1u7qc/1j5S09GaN3gKrcPPHEzKwj3lMsLOiDSLer61vs+Qtwsafn4qEVnXf9Eb99h1rbskzxwDGZpySZfi6s1cEheofZWZBZbTFNVhd0fQf06xBLC39tVhunZZn6nI4bxdTPq4ZbuhHBs716hk9FH1XbA32dpxhvqQEAAAAAAAAAANA4PkIBAAAAAAAAAACgcXyEAgAAAAAAAAAAQOP4CAUAAAAAAAAAAIDG8REKAAAAAAAAAAAAjcuf7ga46tKsKnenp/43s7qcyqqSNGuqVWZmVjjNeth4Wrvpw4mfbmY2LnR9I1FOXcfscdpX+OXKKpm5vqhMlDePLNX3W1az1zcN+igv/WtF/VrNcb+VviULZ6xYA+56QShJU0u8/qzEpFJ9bxZG0lrUl6R63gTTY+brPG45MeerYJKqMmZm5WT2uZi1/VnfXm7JMq1+lNfz01f6skxndVnmtdf8vGRpVZaxlX0yK1nd76Zna0dlmXTloMzLltb86ywsyTLTUs8/NZXUlBilxJ9QXZ0/1+xKVh2t+7Mu9HlHlYvOSI2L9iJ1HovKtHWWnMG5LqT28knQRYOxjndbQz9vfaDj8fZQ7yWbO/5dRWUGO7r/RkM/bzzWZap5DlaBPA/2zpbK89tQzbnPXSrSLLE02z2Hsszv53Zbj03m1PNIuZaf123rtdJp6byWOEMtdHSZ6FqLXT+939H3tNTTfaHK9dq6vlVx3Ki2zsoy9WhH5qkzaNrT+/ykpc81Z7f9tXR2oPt1Ejx/qmerPItOtME5uPbLRXNiq9JjqOZLK/fbkDT8LHupqNVBsdnXMZaKmGYWxy61H7XEc4iZWbur8zodv74oPkV5PTG/+11dZmXBT9+3qPuoFYyHejyNHoN7Yk8wMzuyzy9YPnSPLFPceafMG518wM84e0qWqTY3dJ44ALrvCL4m7XVkXtITwX9Rx2NoSZq470zUWo7OnFFs6HT8RTFPGTOznnhP0Q3OIcsL+oy7tODHgKP+KwAzM3vWZfoF1cr0ITe9OHFCV9j2D1fqPYSZWT0Zy7xqPHDTk+CoX09HMk+NfD7WZ6tqQ8eNYnDOb8NEt6EOrqWeg+ud7aBMcBaZ8TtHFbXtKcbfhAIAAAAAAAAAAEDj+AgFAAAAAAAAAACAxvERCgAAAAAAAAAAAI3jIxQAAAAAAAAAAAAax0coAAAAAAAAAAAANI6PUAAAAAAAAAAAAGhc/nQ3wFMXU6uL6RP++aSd6cyqnPn6VaXziqC6cTF7mdGklnmDkZ83LnSZokxk3lTkRWVUX5RBH5WVrk9JE31PrVzXl4hy06DPi1JfqxJtj8aw0tXJctEcq7PgflN/rtepU6H4WZyXZJkludNHav5GkyDV3/NT7xpmVtXBxElnX0N1MBHLiW57OfUnYzXRkzSqT8l7ervpLLfd9PZqT5ZpLS7IvPbKon+d1SVZJtu3T+bZishb3S+L5Aev1Nfaf7mffvAKWWZzKLP0XjEI5pjpvExMZzUttwZBQIM+04jzSXj+CfLqcjJ7mWgzmkfemi9PCfaxJPPrK02X2Rr68/5sMIfPBevo7Laftz3Ue8L6ts7bGviLbHtLjK2ZDQZ6fMdjf45NgvgeyXO/7a1WdE7TeWnm91+r5Y9hGuy1MKvK2irnjJuJJRGPjc4TxxqZbmbWael11PWPALbS12XWFnX7Di3782RtUc+fTqLXWHHmmJteHrtfltk59aCfMdiSZUJ9//ySHfTPE2Zm+ZHrZN7asl9uGDxAtYN1PhXPVtHROUv1+Kpnoai+XlvXN56qtvtlsuC5FM2KziEqREWPSVkQu1ptPwa0RbqZWa+rA9tC158nfZFuZrbY0/d7QDymXH9Et+Hwkn+tanBOlqlHOzJPlpmMZF555pTMG95xws84c1Jf7JQoY2ajE6f99DPnZJlypON7JjagztqyLNPtdWSeLfT99P2HRGWzj8WlpN1KrN3avT4TEQSi86g6W5rp2LCwoJ9dcqddD+v3/Hb0Onr9L/Z03Di04ufdcFi/X1kZ+2cXM7PylH9+SVcOyjLZ/qN+Rlu/r7GtMzpvPHCT62kUa/wyZmbV2F9L5bqOJ+GZbDz209Wh2sysG/SFvI6+XyvEBwYzs54fa5J9/pxN5nkOf5LwNAcAAAAAAAAAAIDG8REKAAAAAAAAAAAAjWvsn+MrisI+//nP24kT5/+625EjR+y5z32utVoXzl/7AgAAAAAAAAAAwFNjzx+hqqqyN7/5zfZrv/ZrtrGx8ai8lZUV++f//J/bz//8z/PvuAMAAAAAAAAAAFxC9vwR6md/9mftXe96l/3bf/tv7Xu/93vt8OHDZmb20EMP2Yc+9CF705veZJPJxN72trftubEAAAAAAAAAAAC4OOz5I9S73/1ue8973mPf+73f+6j0a665xv7H//F/tKuvvtpe+9rX8hEKAAAAAAAAAADgErLnj1BbW1t29OhRmX/ZZZfZYDDY62XOqyqRXsoidZLJvETVZ7pMWdcyb1L4eYOxLnNuENXnp4+n+p82LNUtmdlU1FdWycz1RdeZRyvTbUgS3UdJ4pdrZbrMVE8XmdfW1dlYjLuZWS6m0liMhZlZmuq+aKWiwtRpOP8EZihJE0vcvvb7LWnr/qwLPanUUkmqYFLZNMgTbSh1fdVEL1iVVwyDSRpoLfq/B7B/pC/LdNaW/fR9S7JMe1XnZSurfsbSiixjy6KMmaVrR9z0/NDVskx+8EqZd3bk99HJB/U4bQ5n33uCUBLGmY44GbRbfpntnWguQ6kLsc6jM0050XmTsZ8+HelGqDZEor2l0L8HNGl33fRo9iR5UN+CHwPWN3WND236a2xjoNfexo7Mss0df01sDHQfnQvat3HOH6vNTT3uwx0dq8dDf05EWh3d592en9dq6XNzFpzvWrnfT7mINSod5+Wt1PLWEz/7JcGPRuOWpf4cbud6bnfb+lorfb/cZau6gYdWdN6+tr+Oige/LMsMT90v8+rTx/2Mhx6UZcYnz/jpZzfcdDOzvN+Teb2jh9z0cqQDVNLR5672/svd9FQ8V5nFz1YqbCz15luzGzvibFrq+naCcKe2LXl8D57tYFbVtVXOc0yS+ONWy3cuZtF7F/XaxX9++1ptUezK/InQ7ug2dIOXAEs9/76WFnSZqw7o2HXzVX47qiA+TR/Y9MsMdKypJ/pcWA3O+RmDLVnGtv02mJnZxrqbPDl9VhbZOeHHTzOzneN+udG6DgCtvn7luXTVATe9s6afGZMrrpV5+Q23+mWufYHfts2g72B5O7NWe/e6yOX5Ua+vTrTOe35er6vLtFuzx4aFri5zZFXnPesyfw6vDr4qy0xP6Lz80DVuenngelnm1LZ/T72pbvdy8C5eqUf620EU16pzp/2M9VP6YkHsqif+s1ey3z+PmZlZHnxeKcWB45yOd3ITNDNriYO1/GbS8Av8PdjzW+rv+I7vsJ/+6Z+206d3D/rp06ftZ37mZ+w7vuM79noZAAAAAAAAAAAAXET2/Deh/tN/+k/28pe/3C677DK75ZZbHvU7of7mb/7Gnvvc59oHPvCBPTcUAAAAAAAAAAAAF489f4S68sor7bOf/ax98IMftI9//ON24sQJMzP7lm/5FnvrW99q3/M932Mp/ywYAAAAAAAAAADAJWXPH6HMzNI0tZe97GX2spe9rInqAAAAAAAAAAAAcJFr5COUmdknP/lJ+4u/+ItH/ibUkSNH7EUvepF98zd/c1OXAAAAAAAAAAAAwEVizx+hTp48aT/wAz9gf/7nf25XXXXVo34n1Bve8AZ78YtfbL/zO79jhw4desJ11tOx1dPW7ozMSXscSTfTmVUpMnSZqtLVjad++uawlmUGY13faJK46ZOpn25mNlW3ZGZV5ZerdPOkOiiT6OZZKvLKRFc4+6jHojGcFH47sklUo77hlphKKv1x8U9bNibJMkuy3QORqLEJFkqtJraZmZg7da4nYprrCVKKmFGXun3lVF9rOvADVxXU1z/Uk3lL1+x30xcO++lmZh2Rl6wdkGVseU1mpat+uWzfYV1m35GZ805u6H498aDOO71ZuOnRflCUwRwTMSjP9Bi2c5230PbT+6LIaDLHJnIpqcvgvOH9uDhMmJkVOq+ejvz00UCXGe/oPNHmJNXxKWl1dV7tr4k017t8FqzLB8/68+7EuWDtbfl5w7HeW3fGeu1t7fh5G1t6Tayv64W+cc7P21zXYzjcHsq8curHmqylj/8LtiDzuj1/rPJc91+rredLW5zROx0/vS7nPTxdGiaTypJs9xxvt/3xifb5eURH1G5bX2tt0V9H1x7S451vPijzRnd81k2vj90jy9Snjsu8nfsfctOHJ8/KMhtfXfevU+r41D/al3mpWLPdA/pckwQDUogtqQjmRHTUvf6wP1ZH+jrehftP3z8X3nVc76X3no72Wb8v1D0VwRkJZlVRWpU+8XNNkup5n83zImJOaq/qtPXk7nV025cW/LZff1ivvZv2+2c1M7Ppl77gphcn75VlbCTOAGN9HRvqM4UNttzkWl3HzIqBzpsO/HZMNrZlmcmmzlPPuwvBs+nKjVfKvN6zn+2mZ8/+Rllmev1LZN5/v8s/dz3wUX+9DAdPfB1ditLEP1vkLX+NqfOOmT5bRnm9TvA+pKvzlhb8uHH5mo41Vx/QZ/OVzTvd9Mk9n5Nlut/wnTLv06dW3PTpPf78NdNntSJ4t7qyf1XmyVdu8mWcWTX045OZmU3Ec/DZ07LI4P4TMi/v+zGle9V1skyytCrz6hMPuOnlqVOyTCRbXHbTVR9VI33meqrt+Y32T/zET1hZlnbHHXfYPffcY5/4xCfsE5/4hN1zzz12xx13WFVV9s/+2T9roq0AAAAAAAAAAAC4SOz5b0J98IMftI9+9KN200037cq76aab7Fd/9VftO77jO/Z6GQAAAAAAAAAAAFxE9vw3oTqdjm1ubsr8ra0t63Q6e70MAAAAAAAAAAAALiJ7/gj1j/7RP7If/dEftd/7vd971Meozc1N+73f+z37sR/7MfuhH/qhvV4GAAAAAAAAAAAAF5E9/3N8v/zLv2xVVdkP/uAPWlEU1m6f/43mk8nE8jy3f/pP/6n90i/90p4bCgAAAAAAAAAAgIvHnj9CdTode8c73mFve9vb7K/+6q/sxIkTZmZ25MgRe+ELX2jLy8t7biQAAAAAAAAAAAAuLnv+CPWw5eVl+87v/M5mKium5/97jLoq/Z+vqrkuUyWZm5722nPVNxjXbvrGIJFltoc6b2fs500LXaYQXRTJ/W74Wp5/T2nwDzmmunmWpn59WVBfEtSn2heViUzVFBv513k8LdG3vdZ8Y5hnc94Ydkny1NJo8s+grvT8SBIxuYOFUhc6piXp2E0vJ3riTDYnMm+6vTvWmpmtXKf/AMG+514h8xav9fOSw5fLMsmho2566/KbZJn8sutk3ultv89Pb+l+PXtS523e6/fRYKTHMMobTfz2FaUuk4nYaWbWbvl50VaW9nR9Kr4v9fz2JcGehIA80+i1XDtno0fyJiO/usGGbsPYjydm5p7DzMzqTMfNuqNjTZq33PT8+m+UZb54XGbZvacLN317qA8Ug5Hf9tFEz+HozDXY8ePGxjndr1sbOm9zfeCXOaPHcGdrR+Yp/ZVFmZcF+2Kn4+f1FvyxNTPrL+q8bsfv225bnBWDvRbnzyLReeSxkjkPy2qKqHEzM1vu6fquPuBXmG+fkGUmX/2szKu/8nk3fetzX5Rl1r/wgMybDvxYE5270jnO61lbP5ZnXbGh95d0mUPXyLyvnvLbfv8ZfRa69pCODQd3vuKmD//q47KMjf09y8wsu+55bvqNN71IV1fo+fdAqfL8cWo19obkmamua6vr3X1ai3cyKt3MrCp1Xikeistyvuc3db5t53ruLAbn5SOr/vy5Ib9flhn+8Ydknp085iaPT6/LIuNz/u9mn2745wkzs2KozyFJ7ndS3uvKMu3lvszL+37w719xSJZZyi6TeemCX19yRD+bdv7Oy2Xe7ZuH3fTP36dj+LE79JwdDf08cQS2kThH4rw8Ty135mSei9itXr6ZPsOa6XW+1NPjE8WGy9f89l1/RLehd1yfa6Z3++eayd/5YVnm//xTmSVj3vOu1ueaXtuPDdG73xPruv+Kyn/XtLK2Isss7fffGZmZjVO/bysRV83MqlLfb/cyP0a1v/G7ZJnJXX8p8+qHHnTT17/wVVmmsz/oi2X//FeLYFPvDGVdT7U9/04oM7PhcGh/9md/Zl/4whd25Y1GI3v3u9/dxGUAAAAAAAAAAABwkdjzR6gvfelL9pznPMe+/du/3W655RZ76UtfaseOff1r48bGhv3Yj/3YXi8DAAAAAAAAAACAi8ieP0L9zM/8jN1888128uRJu/POO21pacle8pKX2H333ddE+wAAAAAAAAAAAHAR2vNHqI997GP2v/1v/5sdOHDAbrjhBvuv//W/2vd+7/fa3/27f9e++lX97xsCAAAAAAAAAADgmWvPH6GGw6Hl+dd/e2eSJPaOd7zDXvnKV9pLX/pS+9KXvrTXSwAAAAAAAAAAAOAikz/+j8Se/exn21/+5V/ac57znEelv/3tbzczs1e96lV7vQQAAAAAAAAAAAAuMnv+CPUP/sE/sN/8zd+0f/yP//GuvLe//e1WVZX9p//0n2aqs56OrJ44TUszv0Be6brqUualqf8XwVrdhaB1uss2dvx2nNrQZdY3apk3mfhtLwp9v2kis6zd9fuvJ9LNzHKRlQV/hy5J9D21RH2tXJfptGbPa+dBRwSK0q+vSnR9pR6OuZSVvl8zvx2Jsza8NHxd2sotbe05BD6uuu1fIy3mu3YxGLrp00Ehy4w3JjLvsm894qYf/LZvkGWS658j8zrPe7GbvtG7Qpb50nE/1h17QBaxM1/Qa3Jj219Dwx29H0RxtQrXZHPabb1mF5daupyIg4s93e6rD+ogfu0hP683fMhN35xsybrQsErP4Xoy8jPGY13f9obOGw789CQ4AKzul1mdb365m/4Xd+tYeP9pPYfPbfvldsY6NozHfv9NxXnLTJ/FzMyKQsWaqSyzE+RNhv5YjUc6hqsyZmaZ2ONUupnZwmJH5q2s+nlra21ZJopDCx2/b7uiup3gvA+zuq6trnf3dynOttG+V1d6P1JbYqGXiuWZXperPb8dO3/933WFd+t/aePMJz7rF/mjr8gyg2M7Mm/1xhU3fZ9INzNrLfp7dnulL8v0Lz+k67vmOj/9hltlmfuGyzLv9nv9Pp8Wepyeq49xNvnkn7rpw898WpbpHlyTeeWS3/bOjToWpomes1n61JzjLhVlUVqaBgv+MQrTzyiJeB9zPs+fj7l6oWBmZan3tzz3r9Xv6vmxJOKTmdnz7Qtu+vZ73iXLbN19TOZt3rfupk+C57hi5I9DHrzfWTjc03mH/LUXxafOtdfIvORKEbuuDZ4zD+r67j7p3+8XHtDjdM9f6Dmxve3Pzeg1SjuYf6v7/AOMetc1DJ79cH7Neuu2JdZyJ5j3HX1Ule8UozPs5Wt6v7z5Kn/O1Xd9XJaZ3vEpmfeVF/6Em/57v6tjw86OjrvXXuPHgLPbsoiMhYeWdQw/cU6vy9Nb4uwXPMctdPT7kG+76Tvd9PT0cVlmaar7r/3dP+imP5BeJcscevB3ZN7Gl+5z04endae3VxZlnuWiL5bE2TTVffdU2/M/x/e//C//i/3hH/6hzP+P//E/WlXx0AgAAAAAAAAAAHAp2fNHKAAAAAAAAAAAAOCx+AgFAAAAAAAAAACAxvERCgAAAAAAAAAAAI3jIxQAAAAAAAAAAAAalz/dDfDU07HV0yfetHqaybwka8m8ajISGZUss7R0hczbHvrf9P7mc1uyzOa5ocxbXOq46f1FfU/tju6Ltvl5SSKLyLwsrWWZXDdBlmsFw73Q0dda6vl93gnqq3R1tqmHQ+ro4bB27ndgGnz+zVI9IIn5ja+r8gml4euSLLPEmayJGJwkGBdLggGNyglZz1/7ZmbleOKm7zx0vyxzzctuknkHfvwNbvqfbD1XlvnsXXqR3/OuTTf93Kn7ZJmdrR03vZgWskwdxOmy9PPSINhlQRBaWO676f0VP93MbHlFj2FvwQ8aK6u6Ddce0ev5W2/059+h4oQsM/nKX8u8+rPH3fTxxrqfPhR7Kc5LMrPUWTNeWpQ+r0qvI9vakFmDr9zjpmctvent++mfkHnv/vO2m378tN6Utzb8eGdmNpn467yug01+DmWp61PXisrkreCcJmJ/r9+TZcogTrba/litHd4ny1x1zZLMu+yAH0NX+jo+9bs6Vvc7fn2dlp++rcMq7Pzji7c1FlN/DLJM74mTqR7T4difw/1udN7Ra2J85yf8Nnziz2WZc1+8R+YNHhq46Z1lPwaZmeVdvf/2DnT9+lb9dDOzvO/ndQ+syjLdo0dknh26zE+/8hZZ5M7P6fj50Lp/v6OJHsMT5/ScWBr6fZ4E5+NkeUXmZQevdNPHtR7DNNXtK0SWCp9BWIWd3/u8/U+d27Oq2T/3nGW6vtFw9jPU/mW9T7349n8v8z7zq3/gpudd3YasrdveO+Dv9SvXHdBlDvn7edbRa0U9S5rpGJVcfo0skz/7m2Te9pFvdNNvu1MvsrN36LW8vODvJb3gfdFzrprKvKGIeee2dSwcjKJzoV9u1nScl6SJ+w5GvZdpi/OjmVkr1+Om3jeuLeq2PftyfW6ov/IpN7348u2yzCee9eMy74tf8O/r2IPbskz0zvP0Kf+lZ/ReeG2/f6657toFWSY6AwxGfpw8tz6WZargph447df30lt+UJa55lv1e/rf+5w/+C95jixi43v1+y71fu/ArdfJMr3nPU/mpVfe4KbnR/z62lt6rjzVGv0Iddddd9mHP/xhO3nypFWPeQp685vf3OSlAAAAAAAAAAAAcAFr7CPUO9/5Tnv9619vBw4csCNHjljytz6jJknCRygAAAAAAAAAAIBLSGMfoX7hF37B3vKWt9jP/MzPNFUlAAAAAAAAAAAALlKN/QO96+vr9prXvKap6gAAAAAAAAAAAHARa+wj1Gte8xr70Ic+1FR1AAAAAAAAAAAAuIg19s/x3XDDDfamN73JPv7xj9stt9xirVbrUfk/+ZM/2dSlAAAAAAAAAAAAcIFr7CPUr//6r9vi4qJ95CMfsY985COPykuSZKaPUPVkZPUke+IXrypd1xOv5evVDTZkXme4KfPWlp7lpn/vSxdkme+7dhi0ZOymJuk0KKPVop+SVP+FuLoQ10pnGJ89ypbWZF412nbT79lZmutaubitXjuRZfqd2fOi+totmWWmxsNLVz8LMzNLWy1LW05np/7YJNGcz4K8dsdPb7V1db2+zFt+1nPd9MNv+D9lmTf/+lmZV/9//fQk0bGuDgJrIqZ2f0XfU5T3VNk4reN+3vK3yrylx/3QYR33n3ud30nfW/1XWab69Cdk3s4fnHbTHxro/aUcT2ReXZQyz7M1IdZEkrxlSe7Emkr0cxC761zHjaTd9cukwVGvLGTWPX/weTc9fe+fyjI/93Z/Tz7PP9NE6mr2U1wiYnhYRgWux1FHwVDodvV4tFt+LFxY6skyC8s6fq7sX3TTX/yty7LMoVW9/tcW/fOiOjudz9OZKoSqIczK+cbpUlHXtTsni0LM05Guq5pj7a0H56STCzrW1Lblpv/pt/+SLPOOz96uG7IqrrMcPC8Ga1n1RTbWz0/ljrjWKVnE0jv1/JZtyP5Sllk5uCrzVMx7wYuulmWOndV99Lxve4WfceSzskzr6A0yr7jiVjf9y8d1fHrgjB7fwci/362hP4ZDkY7zisnUrN59VlH7b10Fa6XU41aJvKrU86CY6rw089txxWF/rzQze8X7v0Pm2VV+3jxnAzOzpBAx4EFdpn5gvmvNKjon/b9+8htkXv+sPx4vebY+C3X1UdeOrftz4o4HdPseWtd7k4oN04mel63gPY46D6lzzZxT5ZKRJP67BTUfo6NLdNRXr0PzTBfqVgOZt/Ph33PTf3X138gyf/KWT8u8ec5k86iCdwCpmNx/+afzXSud43ltaU0/v3zh0/4gfuQj+r3wwqJ4T2dmWeY/037/C3SZ0Xf8DzKvM/bfy2RrR2SZ/OiNMi/d55cbiVc8045+t/dUa+wj1N13391UVQAAAAAAAAAAALjIPSl/zEf9STwAAAAAAAAAAABcGhr9CPXud7/bbrnlFuv1etbr9ez5z3++vec972nyEgAAAAAAAAAAALgINPbP8f3yL/+yvelNb7J//s//ub34xS82M7M/+7M/sx//8R+306dP2xve8IamLgUAAAAAAAAAAIALXGMfof7Df/gP9o53vMNe+9rXPpL2qle9yp73vOfZv/7X/5qPUAAAAAAAAAAAAJeQxv45vuPHj9uLXvSiXekvetGL7Pjx401dBgAAAAAAAAAAABeBxv4m1A033GDve9/77I1vfOOj0n/rt37LbrzxxpnqqouJ1dPdTauLiV+gqnRlVanzpoWfXkxlkfKrn5d53/TAu930P/+X/1WWGX/gX8m8zq3f5abXQfsszXSe0HR9UZ9Xw63Zq9s4JfOSzoKbfs2ibkPd3y/ztoa1m54H3dDKEpmnymWpfx0zs3oy0nlirtfl7jGsSzG/cV6anP/vMRI15/OWrqsV5HV7fvrCkiySHb1W5t1/8CVu+vtu03P+Oc/Tc/6Oz5+ReUqip/xTptZLyP7lP93npj/rMv3nLrZ+7Rdl3rE//aybPtnUsXP0e2OZp3yxqwNN1tZtz3r+Vp61dJlclDEzS0RMS0VAKyfBHgKzJDVLdvddomJK19/XzOb8k0PBHh+cnux5/58fdtN/44t6ng62xTnNzPqLbTc9iQJKo7+5VKujgBJYXvbvKQ/W3pIoY2bW6/h9kWe6fe3WqsxbW/JHuNvW+0WvPXuAD4/hQXUqT1VXBEd6mE2nlSXZ7t5LxXSM1l45nL2zt7d0rNka6HPS3Qvf46b/9z/+qizT6uj6xjv+Obqq9DpKnfPg4ynUc6SZJaLT1TnezKwM1lG713HTe31xxjSzm55/ucxbWPDPAEt9Hd/PbukGfnLhGjf9yLOuk2XUM5eZ2caX/bl0bkcWseFYj+H20B+PaeGXmZYXwEH3AlZXlTuXazFF6mDtZcH+NhXrpQw2g2idT6d9Nz3aYw9fe5nMO/HVYzJvHuosEsUNFWvmtbDkn0Gzln5u+IMPPCDz1LPD72XBc01wrW7Pj/3qPGZm1l/U+0VLPF+1W3O8AzOz8WS28+RoPN/581Kn14ouE23zajsfBOOzVevntfyWb3LTb+3p+j4u1p6Z2eaZTTc9CW5qntgQ1afiUHSdKojVaXv2TxEbpzdkXiZiymBjW5ZptXVs+IZvu95N//99Rpd5/jUvk3mrC7OPx7TU82Vyxh+PoYhB21sXzkNUYx+hfv7nf97+0T/6R/bRj370kd8J9ed//ud222232fve976mLgMAAAAAAAAAAICLQGN/dOIHfuAH7BOf+IQdOHDA3v/+99v73/9+O3DggH3yk5+0f/AP/kFTlwEAAAAAAAAAAMBFoLG/CWVm9sIXvtD+r//r/2qySgAAAAAAAAAAAFyE9vQRanNz05aXlx/535GHfw4AAAAAAAAAAADPfHv6CLVv3z47fvy4HTp0yFZXV91fcFvXtSVJYmV54fwiLAAAAAAAAAAAADy59vQR6k/+5E9sbW3NzMw+/OEPN9IgM7N6MrK65fy6qkp8yJoWurJiqvOmEz99tKPbduakzBvc/5CbfvV3XyHLPPh/6H++cPGqD7rp/csPyjL5vn0yz5ZX/fReX5fp9dzkpN2VRZLOgs7L2356q6PLBNeqS39868lI15eck3krbb8dqt2Ppy78OVZXVVAmmLPlE68vrAdmSXr+v8fKMv/nVbqZWSuYH3nLT2/PUcbMbjjgx8GfeKUus1ydlXnjox930+uHHpBlbP2MzCq3/L8VO93ScbUcjv30sYjRZlYFcb/6t34f3V/oPwxRTvV6afX9vk0z/WsV866eL1VVyzwlTXf/IY9H8tp+O7K2bkPq7bFfk6R+XiLaoNJxXtLuWOLtLYUYgzSINUFeJvbKtL+i23bVc2VetXalm37kU3rtXXWNvtbZM/6+XNd6PWSZnlutlt8XnWDtdTp+XkusITOzPNd5rdxvXx4NYRrcr8iL6uvo0G9l5bcvOILYODw6+O1ri36Iypw3W+yY8ufZQkVRWVoEg/vYn5/qn82DPWK440+SVrDnnHxInwEmI7++3qL/DGJmdujyNZmnYoD3hyUfFsUatV6i2BVdSxFb7/m84LyhtKN9XrSvDKbPYKTv6f7Tft6xs7qPovudFn59O2PdhslU541F3mjk3/Bo54mvo0tRXdfh/N8l2HSq4AyZiT0iOhO3gk1RzfsvfkVvLs+79ajMu/6mQ276ZKLvdzTSZ6iy9Pu0COJ6JcrMqxJjVc/x7GJmlkUHGCEN4rEa+vFYj2E0V9W+lST6MBTNP0XNvfGQ9zWRqqzdOa7mY7RWdsbBWV/MubNbum2f+rJey63VV7rpG2f13Ln62fqd8enj59z0rXXdwPGOfh9ais1evQOIRO8153lHEJ2fOt0gvotrtbv6PfPiviWZN534MeXYGf1uulTfK8xsecFf6/1OEO+C/itE7FfPSoPtC+dcs6ePUC996Uvd/w0AAAAAAAAAAIBL2+yfOoX/9t/+m/3Zn/3ZI///137t1+zWW2+1H/7hH7b19fWmLgMAAAAAAAAAAICLQGMfof7n//l/ts3N8/8M09/8zd/YT/3UT9nLX/5yu/vuu+2nfuqnmroMAAAAAAAAAAAALgJ7+uf4/ra7777bnvvc879b4Hd+53fsla98pb31rW+1v/7rv7aXv/zlTV0GAAAAAAAAAAAAF4HG/iZUu922nZ3zv3T2j//4j+17vud7zMxsbW3tkb8hBQAAAAAAAAAAgEtDY38T6iUveYn91E/9lL34xS+2T37yk/Zbv/VbZmb2pS99ya644oqmLgMAAAAAAAAAAICLQGMfod7+9rfbT/zET9hv//Zv2zve8Q67/PLLzczsj/7oj+z7vu/7ZqusKs//91jTQvy8SDczm0503njkp4+GummF066vyXodN33lhkOyTJJlMi/vd/0yafAX2OpK56m+yFu6jMirTfTdvKJ7KnQfJap9kznbV/vjW0/GM5eZmzf3H75UJca3mO5OK500PCLJUn/9JWIuRnM0vJAoV9WySLV9TuZN7vmcm95v+/HHzGw62JB59Wgg86QgbqWdtl9ExW+zsC/0hRKdl/h5dVQmoGJukup7Stt6vtTlHPcbSFuqfboNSdQXIk/2g4pLMDOzJG9bkjvrIvXXUWL+3m9mVgf7Q3R9ZRjsrw+e8q/VyvX8PXxInyc6Hf9a04m+pyg0qCmci/VgZpbnfl6a6fXQyqM8Pz1JdMPbwck7Tf1yLT1Mlmf6WqqPon6t6mBvqvwKizCmRXHXL6dCV9Q2mFVlbVW5Ox6r8Y62gcl09ri+s6PPnXUw6QpxPsjVAjOz8VjHDbW/qfVvZlbPMbcScdaYt74yCO9iu7AsiF3TQo+h6qMd/Qhsda0DUVn5fRvFuzAOiaZPCn2/wSO6TSd+haWIXSod51WVWeUMYDrj+fHxqHJp8BySBXnqvHH2rH5v0Io2YKGI1l4QN1JxdojWuVLNOYdTNVbzPgaLpkfPIdHepOJGtGaj/UKNleyHxyHPL2JKjIe8r5mH2t9awTyYBl09GPkDF51vB6Ngzk39SbyxrdvQX9TPUMOVvpuuzk+PpxTlovrkuUYdUCyOd7LMnGuv3fXfhbU6wbOpeH9vpmPKxqaOJ3mm267mxGZLz6Oo+9SlVPpOw6/v96Kxj1BXXXWVfeADH9iV/iu/8itNXQIAAAAAAAAAAAAXicY+Qt13331h/lVXXdXUpQAAAAAAAAAAAHCBa+wj1DXXXBP+dbsy+jcGAAAAAAAAAAAA8IzS2EeoT3/604/6/9Pp1D796U/bL//yL9tb3vKWpi4DAAAAAAAAAACAi0BjH6G+4Ru+YVfaN33TN9nRo0ftF3/xF+37v//7m7oUAAAAAAAAAAAALnCNfYRSbrrpJvvUpz41W6GyPP/fY1WF//OFSDczK4O8avZ/IjDNM5nXXlqYuUySpDIv67b8+trBsAX1WfDPJUqqzyt9T5G6mLrpSd7WZUq/jJmZTcZ+elXN0qyvX0u2zx+LuaVB/0Xzcs77wgxSsYbmWT9mZrUYMzHXzMzq4ZbMK9V6COZUPR7KPBuKvHn/CVURg9IsaJ+IabXqu8dT1X5yUCTJ/TJmZjKq6rBlSarnSy3aNy95raANcX2zjWGaEZcipWVWmtN30T4gVMGQqu1hONTzbTDWY7clymXBMWOpF81tv+BkqvthWsy+VtIgVqsjUnBMC+83z2bvI1UmKheViZZ5kszef1F4KkVeGpSJ6pN5YlpyBIqVZW2lM0hl6XdctBfNs4cVU/3MVdf6Wqq+stDnkDRYZEXR7P1mmZ8XHQvV/Ub/dH2eB/c0VfcU1NfS9am+qNQiN7PhSI/HeOy3IxV9Z6b71UwfnctgDNU8NzObTvw8b72YmU0m/BqBSJqapc6aiea3rCsok4l1Hr1bqYONQs2R8ViPt5ojZvp+1aOkWRwL1fSO+9UvlOfRr8mYPRbO++yi6gvPLnM8v1TB+q/r2fsiC85dTZoG+xy+tjbT3X3UavsxYDTS55Bo3k+m/hxpt3SsifYw9fwyGurxnoyjM5Sf3urolxHRnliINRatvWLqtz2KuREVx/OWftet9gQz3faovoiK1dEc297pBPX56ePgNXMUCjMVW0UX7QyDjekp1thHqM3NzUf9/7qu7fjx4/av//W/thtvvLGpywAAAAAAAAAAAOAi0NhHqNXV1V1/SqOua7vyyivtve99b1OXAQAAAAAAAAAAwEWgsY9QH/7whx/1/9M0tYMHD9oNN9xgef6k/6t/AAAAAAAAAAAAuIDs6evQC17wArvtttts37599pGPfMR++qd/2hYW/N+LBAAAAAAAAAAAgEvHnn471R133GGDwcDMzH7+53/+kf8NAAAAAAAAAACAS9ue/ibUrbfeaj/2Yz9mL3nJS6yua/vFX/xFW1xcdH/2zW9+814uBQAAAAAAAAAAgIvInj5Cvetd77Kf+7mfsw984AOWJIn90R/9kfv7n5Ikme0jVGVmVe2kO2lmZlWl66pFmfMNmy3dzJJWW+ZlPf9aaUeXiSSp/xfVojaYKBOqg/5TfR5VN53IvCTN/DKTUVAmuKeq9OsrdBFLg2tlft/W4jrn6/PvKZKkus/Da6k8Zw3Uk/Gszbq0JEm41neJYkmUV0zF9YN5HazJeqLXl1QGc0qtPdXueaVBXBV5SdRHUX25vybn/au/ajTSoA31LHPr4TLRPJpDMkcbzIKYq+436AeYFeX5/x5Lba9lsO9GW7J3DTOz4UQXGox13ljso9Fwd9uzt10sVzPT92RmVtcqbsy+jqJ7io4gmcjLUt0GVSa6VtSGeY5985LH7WAMq2DSTs3v+Jaob44j6SWlKEpLp8GieYxoz6lLnVeKhRnWFwxeKhZFtMdWpT4nFVM/rwzqy3O9kFTbVbvN9LoM+yjIm2c/L4MxnIiTTbT/ZEH/RX0hy0SPd2J4oz6K7leVU3NlOnni6+hSlCSJOyflu4to7kSHAFVmznNnOfUPNtNgMkbzKsvUOaTZc3E07+fpCtVuM73PhmMYtGGefTvaL9TDXDBMczWiLJ+aZ5vpJHgPB6vr2p3/KnbP+0haifGOxieKDaU4o+wM9PuV6bTZQ+48cTJaezoGNPsgUgfv9tN2S+blLf/TRqujy0TUeEyCOTEIxtfMb8ekCM6m2ezPk2pLHU8unPc1e/oIddNNN9l73/teMzNL09Ruu+02O3ToUCMNAwAAAAAAAAAAwMVrT58tX/CCF9j6+rqZmf3cz/2c/Kf4AAAAAAAAAAAAcGnZ00eoO+64wwaDgZmZ/Zt/829se3u7kUYBAAAAAAAAAADg4ranf47v1ltvtR/7sR+zl7zkJVbXtf3SL/2S/NtQM/1OKAAAAAAAAAAAAFzU9vQR6l3vepf93M/9nH3gAx+wJEnsj/7ojyzPd1eZJAkfoQAAAAAAAAAAAC4he/oIddNNN9l73/teMzNL09Ruu+02O3ToUCMNAwAAAAAAAAAAwMVrTx+h/raqqpqqyqyuzv/npT8VskzntTsyK039X7FVF9O5mpGkoh15Sxdy/iba36pwrna4ylLnBf1XFxM/I2hbEsytuvT7NpElzOrJWGfm4lpRn4s2mJklid8XtQVzQswjs+B+xXUQqOvz/z2Wmm9JMKui+KfWShLMgSjWFYXOk20Iyqj6orgVrf954rSa86nu8yRYJ6mIQVHLksqZCw/X1/Ljah30Qx2tYzFforhlQfvmEvStovo8GguYjYvaxsXu8VNhIxrqaakzCzEdvWs/khcs80o0JE11fXmm51WnJeoLpuI0CjWiGSo9EoX3JNEVZmLqq/THu1Ym+jaqL+o/VW6O5R8KHwGitov0co61Aa2YznFuCNRikdXBACXBpKvUgAeTJ1oThQgcWa7PykVwQshEXCsrHaDyfJ59cfbzU10HfRTEY9X0Omh3FdRnhd/2LBioKA6VYi6pfcnMrAr2R1VMzb1C3A9iap2nwcaXRHnifFmqA4/pZwAzs0QeKsT7CTNrddoyT825cJ+P1uUce5xaR0/lfvlUXivaZ5pUznOYnEMRnNFxfi8onXWm3j2r84lZHNejODSPqYg106lunypjZjYd+zEqPFtF7zZEnEzVu1Azq8RZUr3XMJvvHUEYw+d4gIn6IXy9p84HU32/k4keQzXHOl19v1lwv+q1v7qn0bjhh7892NNHqN///d+3l73sZdZqtez3f//3w5991atetZdLAQAAAAAAAAAA4CKyp49Qr371q+3EiRN26NAhe/WrXy1/LkkSK6M/OQ8AAAAAAAAAAIBnlD19hPrbfw2y0X+ODwAAAAAAAAAAABc1fpEDAAAAAAAAAAAAGrenvwn1sKqq7F3vepf97u/+rt1zzz2WJIlde+219g//4T+0f/yP/3Hjv+gNAAAAAAAAAAAAF7Y9f4Sq69pe9apX2R/+4R/aN3zDN9gtt9xidV3bHXfcYa973evsd3/3d+39739/A02dU/QBLBF/ESwLuqWuZ29C3tKZ0T9jmGWzpZuZRddS5VQ/zKuO/mlG0YagTF1MZF6S+m2PRin8JFqJviiCMqIN59shfhdaGoxh9PvTKj+vrqa706YjXQ80NRfrYJ2IcZlbNAdSMYOrYNZHa7LYPXcetw1N36+g1vf5PL2Sa5GXVLpMkgfjG61/VV+qx6MW7aijMbwA/t6y6nP+oEmsLM0KZ8mo7X9a6nkQTZFx4WdOxBI/X9/sZ5pg6VmeRW1XBXWZNLhYFXWGbIO4TnRUnCMvTaJ70vWpdkRtSINY81QJpmwYuuQYio6YY8gvKXVdWz3Dmi6nenOL9t95VF4Q/Jo098/E0b2UUX1i/kT1per8b2bq2SWKG0XhB/h590tVrgwWX5SXZWKNBc+lYezK/MzpJJpjs/dFeE4KqPFQc0L9PM5L0nSmGDHPWM+rDuawyquC9T8d6/cQWWv2V2l19DwpRGFjniey8BlqjjU2z/hG8anp2BBti/OE5DmOzlIVHaBg5bSyItu9btUcKUs9oFHImmdvnk5mX32TqY5PxVTXp87LRXCOi2KhKheVaVra8PuDec6S86zl6HwwGc9eX1Xq+vKWnrSttn+/mVgb0+B9wFNtzx+h3vWud9lHP/pRu+222+w7v/M7H5X3J3/yJ/bqV7/a3v3ud9trX/vavV4KAAAAAAAAAAAAF4k9/zG33/zN37Q3vvGNuz5AmZl913d9l/3sz/6s/d//9/+918sAAAAAAAAAAADgIrLnj1C33367fd/3fZ/Mf9nLXmaf/exn93oZAAAAAAAAAAAAXET2/BHq7NmzdvjwYZl/+PBhW19f3+tlAAAAAAAAAAAAcBHZ80eosiwtz/WvlsqyzIpijt/qDgAAAAAAAAAAgIuW/nr0BNV1ba973eus0+m4+ePxeK+XAAAAAAAAAAAAwEVmzx+hfvRHf/Rxf+a1r33tXi9zXiL+4lZa6zJp8Je9smz2NrSS4Fqln15Xuoy6JzPd9iRoQ97Seep+5+mHeVVBX8xRpi6mbnoSzeygz2v1l/ZS3YYkmmNKUF84Z+fpP/iq2u9P1f9R30drUpk3LsyjErHJTN+XWFthGbPz/dqQJNX9mgRxK1FtCPaKpA7aLeJJUun2VYXuc9X2JGhfzdq/aE3L2qbl7rFVQxotoekcS9m59OOWiaRBvMuC0JVnqiFBfUFnlKLt0VJumuqKqB+i7ULXN99NqXZEbQjCrr7OHGXQvKoorcx2B4lKLZbAPHtOFSy+KG6o/TI6XyfBpKtE3EhN31N0t7VYSEE4NnlCCWJDUej+y3O/YFQmC/ponjhZhvvPHHOsCJ6txHyp5wzwZbQROho8yl5SonUuy0RnfVHfXM/epmNUEsbI4FpT/8VB1L46mFzRc8+s0qgNM66Hx9XwgqnmaN88j+JmZuVc+2PwvCbmmNpTp5PJzNe/lBRFbWmwVzxWGhzAo+UlXx0EZYoZ2vXIdYK5PR3rdy+liDUq3Syep/OUmae+8F1Og/HOLHj30tIvhsvgfU1RqP1HtzvamtR+Fom6vJj68y9v+Y0YjS6cf51uzx+hfuM3fqOJdgAAAAAAAAAAAOAZpOE/bg8AAAAAAAAAAADwEQoAAAAAAAAAAABPAj5CAQAAAAAAAAAAoHF8hAIAAAAAAAAAAEDj+AgFAAAAAAAAAACAxuVPdwNcdXX+vyYkwXe2RFwjy3SZOpmjDa2gvuA+o3bIawXtU30RlUnnuN+qDupTZUpZpA7GMKlEXqX7rraprk9lRO3L27q+VLVP1xfmKekcc+USV9e11fXuuSrnQLRWoyFzrnH+QtHammMORFQbzMzKYuYyXr99PbOh2L0HiYhbdRDPUtNrSN1RLXPM0jyIQSJG1pWuL5lnP4hEYygb4fdfkj39Y34hq6rz/+1KF0MwDZZ/UepxK0S5YFqF27WitrXzebrCTJyfoniSBnFSZc0zteel2hCG90Am+i+qL5vjj5MlSbOdFExL/rTbU6gqK6vKJx6PqznXXlRunjKZ2N+iPTHaz2UbokeuYKKWok/TIBiq2JoGQVedXczMisJvQzJnsCnFos2y+eqbp1w0HmovicqEZ1OhmPoVFpOGz+HPMEmShPN1189HB4eAGtN5Y4M6f5dzP3fN/pyfRc8HYl3Os87Led4nzGmWufAwNRaPV19Ubh7zxI1o/qFZZVnL/cpTBe8h5plzURl1NojKTSf6PeQ816qCMtHcVnnhWp4jpITrdY5XG/Os/0o9IJtZEcTWvOU3MBHnMbM4Vifi20M0Tnke5LX8/aea+NeZivPO04FnQwAAAAAAAAAAADSOj1AAAAAAAAAAAABoHB+hAAAAAAAAAAAA0Dg+QgEAAAAAAAAAAKBxfIQCAAAAAAAAAABA4/KnuwGuJD3/3y6l+PkkqCvIy8Tt15UuI5pgZma5+KYX1Ze0gjzR9jT4duj229dk2exllDTo16dS5fdtXemBilpep359SdRHwbVkO1IxFvMqpruvPR01e41LhZhT4bqzKGaIvHnW3bzCmObP0bquZy5z/lKinEp/Eqj1mqS6DWHMmCMW18GcUDEoCeKC7NdAreaymSVqP3iccphdZf70n4opVwVrL5oGpVx6za69LNhEo6NBNkfIK4MbVsuyrnUj5glD8xx3kmS+PpehZs4+j47AF7JKDJRKx3lJmljiTIiq8INNGkyQKG5E5eapT+05YRtmbkEs2vdqcb9VdPYTLQxLzPFokIaxptlekmch02szOjpHR43pRDyPzfn8qc5Qqr55r3OpSJNkrjjgieL6POeGqL4kUZMuOM/LMno9R/OnFPHYzCwV5ebZ+ZLwubVZtTqAmo4b0XNmVN88mn6uieZY+Pzs1aXeE8DMzKbTwpK0eMI/H+1TTYvGupj6bY6e51UZM7NKvHtR5zuzONaoNTHP+4bIhb6XxmMYvfj3ZcH9FmJ4w+fWIDyoocrEg3pRXDixhr8JBQAAAAAAAAAAgMbxEQoAAAAAAAAAAACN4yMUAAAAAAAAAAAAGsdHKAAAAAAAAAAAADSOj1AAAAAAAAAAAABoHB+hAAAAAAAAAAAA0Lj86W7ATNLETy+jMnN8Z4vqy4P66kpkZLO3wcwsEddKRD+Yxferyql+jdoQieoT6kp3epJG/Sfygvosqk+Uq6NuKNW4myWq/+Ztn8rz0sN+g9WVu2Zr9W2+DOboPGuyDuZAVF9d6zyl0nO0VvXJePY4eU+RJIh1Kp4kQWyqg7xEzYmgX6NYXNvs/Td7VDWb98+ZRH3r//x8rbtUTMvz/z1WJdZeEYSGaMpFefNI5ZlLx6A0iF1V4peLykRTWIUu1a9mZqIJc4uaroRHrnmOaWGe6nNdJhoPFRqyhkOAmntyTsLMzp9FvPOIiullcK4J16UQrb2my1VBoFT3m8w5UeU5KYrHIjPLdFCrgtiqhqMK1kRV6AZmoi+CKWFmzQbQaDlX6lLh/jN7fdXEv+Hp5Ok/517Iqrp21200v+dRi4NNHcan4JlHTZLgABUtiUTEhrQKnimi54N69hilnkHTOZ41nhTiftXYPp5KBgdNxvA51fO0QdxvtJfhfL/NNFfC9wPBOg/e5+n69DxQ14quUwUbcDEpZi4zj3nPcfOQ/TfnK0y1zqM+T3N9sXnqK4rgTKZuNzib5sHXGtW+StQ3FeedpwN/EwoAAAAAAAAAAACN4yMUAAAAAAAAAAAAGsdHKAAAAAAAAAAAADSOj1AAAAAAAAAAAABoHB+hAAAAAAAAAAAA0Dg+QgEAAAAAAAAAAKBx+dPdgEYk0be0SmfVtZ+eZUF1QX2JKKeuY2aWJDovneMbYVSf6qeo/+YpM4ckDfo8UFelX98cZR6vnBS0va79+ZJE/Re0T+Z5bYjqgVlVn//vsdJgjQt18D0/iWLGHOoonshCQRu8PnicMrUqY2a1uF+VfqFIgnhbq30k2g4aju2yDYG54tkckvSputIzyzxLopxj+Te99KLpmwbty8WMLEwXSmo9t1QoTII2zBM+I9Eyn4daSuHRLrhhlualZTqZmiXTRuoqSx04sqzZZ4B0joUU7dlKdH4K46Q4T6fBAkvNfzYo59jLzXSfR+exaG8uxWaSRgE0oK4VnhcbDlCTYvZYqNrNuSaWJslc67Yp0VpOgtNvJeZjFE7idwp+fVV0TgqCjXr0ip9R/DbUwfnpqZQEMWAe8zwHR3FIl5kvVlcztm/Wn7/UVGXlnkf0mM73/mue8Y7OSUpV6vap+GQ237yPrlVMn5r3hOHay2aPUXH/+eeu6DVzVej6SrHHRe941Nnqa1cT6XN+yxDlVBsm0wvnXRx/EwoAAAAAAAAAAACN4yMUAAAAAAAAAAAAGsdHKAAAAAAAAAAAADSOj1AAAAAAAAAAAABoHB+hAAAAAAAAAAAA0Lj86W6AK0vNsmx3eql+PqhLlTEzS0R6FRRKg+92iaiwroNGBFR9yZzfDlN1ww2Xmbd9T5VgfNVIhb1QVTovb/nXKae6TKondCL61quvLgt9DWjVHOs11XNg3uU/s3nabWZWB/NXFgnKzNOOqL55qLgVhPYkiHWqi5JgP4j6KBGxvQ4mS3Qt2QZruF+VefaJS0hV11bNEAgaXw7B1JkGW5GsLxjuLJoKoh1p0DWV3JXN1M4cteEpi8cBdbSLy+iGz3e004XmCDVzlUHz0iQJx/axZolLTZRr8jrpXIEymKhBVpbNPsGr0j9wpOFDq1bOs5+Hj7PieSKK70FwLUt/rOrgTBiENVkuOqtVog1mZoWYL2psi+lTdH66RIRnYu+dz56uFcUnvx1V+Oey9UJS5/kooFTz7LFNx7unUB2e4xq8TsOH52j/iefYbJqs65momBaWpE/8nda8/TnP/Ime25Viou8lqq8s/DgUlZmnL5peR/OI7ilqnmq7Oo+ZxWeKVLQjal8xjT4+qL0u6nMdx9WzoXomm2e+PlkujN0JAAAAAAAAAAAAzyh8hAIAAAAAAAAAAEDj+AgFAAAAAAAAAACAxvERCgAAAAAAAAAAAI3jIxQAAAAAAAAAAAAax0coAAAAAAAAAAAANC5/uhswk0R8M6srXSbLdF5Z+ulpUGYeSZCXBplV7adH9xT1RSqGO2qD6vOozIWu6fF9CttQq/GtnLnspeHr6ipeL7OoLvDv+cF91iLO1FXQNyo2BeXqWpd5qiQqnlmwtswsSf1ytQVl5vkzHlGfB1TfqnY/bn1ztgOzCZZRs9eJjkjRFFHbTVAknHKqYKbPE3EY8jsw6tdEXKqumz3TJEmzgzvvkSsVNzxnaIiGKmjDfNfC7Kq6luvi6abOGmbzHaGi+8yi5yQhal8pgleiAkpovrN5av49JcECS+dY6GUZnBdrXd88XRH1eZNlzMwysdmp+436Ac2Knw/8iRWdU5Ng/ev5o+urgvN8JjbF+Bw9+7qc6zFTvecyfTYw07E1KvNUanqPmzem6Ppmew6uiDWhclpamha70tX+G8WTaM+e5z1FWcy+n0fXieqT8ycoE62VeZ715fuGpzA2pHM8VFTBGk/Dd1p+XjROWa73H3WuSKL3wkF8mIi8VtuvryovnOeDC/zNKQAAAAAAAAAAAC5GfIQCAAAAAAAAAABA4/gIBQAAAAAAAAAAgMbxEQoAAAAAAAAAAACN4yMUAAAAAAAAAAAAGsdHKAAAAAAAAAAAADQuf7ob4ErS8//tUuqfV+pK52XZ7GWeSmkyR5mnaEijPo+kF8B3z0rMIzOz1J8TdVAmEWXMzKyYiusE/RDVh8bUVW11VTdSV5I+dTGjqTZ/vT7R9oav80yUBOs4ihmNtyPx94q6ZgwvBHVl5i0ztfSaFm0380zTNDqbRHFDtSPqh+jIUPntiJsn2pdcGGslFWt57vpE/2XNXmZu4VzCzLIss8x5tilLf6FXRXS2jfa32deLPGuYmVroSTA/ojaU4nlx3vWlHgvTXJ/X1b5cBe3OgvrUfl6Xur6oj1R9qt1mZlUYrGeXBnOsEvMlKlMG81n1bd7y06uSZ7F5qDkXreWIWi/R3hGdfdPMnz/RWoleeZSlmqfRQWT2dRS9mopitWxC+OrM74uoTNOaftadrw260+d5vlJzWZ5LYWbn12zqnGsqda4J5060X/rjPc8+Gon2KXVPkWj+RGc85al8d6DaPm+oUWMVvpNp6Xfnck6EZ1MdN1ROIUuYZWLPMtP7ainOhSr96XABfBEAAAAAAAAAAADAMw0foQAAAAAAAAAAANA4PkIBAAAAAAAAAACgcXyEAgAAAAAAAAAAQOP4CAUAAAAAAAAAAIDG5U93AxqRJjqvuoi/syWi7dH9zlNfJMvmuM6c7XuqVJXOS+e430g6R59X5cxFkqz1hNLwdXVVWe3MhWSOMauruokm7Yl3L0/IHG2PrlXXor6ojGhD1K/h/TY8HomIueG4h/uSXy6ae3OPr5BEcXrGNTDPmoHu5unsW8D8bQimwTzNSOeY9+EfhwqmvTqelNGyNL994bEgaF/Dy3KuI0MkE8PR9HWiYQ/nxIz1zXv8vVSkWWpptntwi2nh/3yuz7zznGsy59oPazqsqX3ZzCxt+DlE7XHRPjrPvI/2+XnaIM9jZu48MTOryuhspbPmasMcgWjeoa1E36ouL57KjfgilOSZGz+qwu+3C+WcqOZ3uI7mWJdVED/n6Yp526fN87zR7BjO06+PV65JUeyKxldRe0LT+9UzjXpfU84Ra0pxFoo0vfaqUu8t88z7aP7Uc72HnG9d6jKzn9XCdxQBtWazlv7kEY2HEvZD8CpZzpfo7BycydLaL1eIw1pRPP3vKx92YZwIAAAAAAAAAAAA8IzCRygAAAAAAAAAAAA0jo9QAAAAAAAAAAAAaBwfoQAAAAAAAAAAANA4PkIBAAAAAAAAAACgcfnT3YC/ra5rMzPb2hn6P1BWfnr0KU0UiRsyT6EnQSJubN5Ph6q+SJbNcZ1E56V+G5I0uE6UJzojEdd5XHlr5iJx25+a77xJtrvdW9sDM/v6usJ5j8SZ0djNn3vuPM3qas64Ncf8iK4l51tUpvLLhKE4ul9RX6SeI+6rdj9uffO0b47xjdZ+EsTpWWPG9ng6V7lnuof7Y3t7081X02Baznc9NUWqYFyiaVXI+mZo1KOu5ReM6psnrJVztC+6TrQlzBt257nWPDKxzJu+Thoe+4LMGesbbG+ZGbHmsR7uj+l4282fjiduehKMTbS/KVWmJ1apnuECUfsiafQcMgd1LkyD+5237bO2Yd69PBX1VUFQi641TxuqUr+GUO3Igj4vCr15ztr26ZhY43m4P4rJwM8XY5BUc7xPMD1u0b4yz3NcND+itTzPteaJTw2HtLDd6nmj6efj6LlmnvY1LVr60blaUeM+nWx/7XrEmr/tkXPNxD/XqHgfzZ1yWszcjig2VOXsD2xF0Ia55n1wVivneXcw57qUZYL+U2uiqvXZYJ7YH9YXtU+cN+oqOrvMvtdlwVkoos5xqXj4m1xA55qkvhBa8TUPPPCAXXnllU93M4BnlPvvv9+uuOKKp7sZFwziDPDkINY8GrEGeHIQax6NWAM8OYg1j0asAZ4cxJpHI9YAT44LIdZcUB+hqqqyY8eO2dLS0lx/2grA19V1bVtbW3b06FH5pfxSRJwBmkWs8RFrgGYRa3zEGqBZxBofsQZoFrHGR6wBmnUhxZoL6iMUAAAAAAAAAAAAnhn43A4AAAAAAAAAAIDG8REKAAAAAAAAAAAAjeMjFAAAAAAAAAAAABrHRygAAAAAAAAAAAA0jo9QAAAAAAAAAAAAaBwfoQAAAAAAAAAAANC4/OluwN9WVZUdO3bMlpaWLEmSp7s5wEWtrmvb2tqyo0ePWpryvflhxBmgWcQaH7EGaBaxxkesAZpFrPERa4BmEWt8xBqgWRdSrLmgPkIdO3bMrrzyyqe7GcAzyv33329XXHHF092MCwZxBnhyEGsejVgDPDmINY9GrAGeHMSaRyPWAE8OYs2jEWuAJ8eFEGsuqI9QS0tLZmb2z952p3W6S7vy3/g/HHfLTR/8oqyz86xvkXnp0pqbPiyyqJm6PvGRfntYyzKb40rmrfb8L5TTUtfXyvSfFDiz7V9rONH19dp+ffOUMTPrirxRUN9iZ/Y//RD1Q9TnR1b8se8Wm7LM8fGizFsQ9xt9fF7q6bbfd9pv+2XnPr0rbWt7YNd/x6seWVc47+H++O8/8F222NodArtrK265yea2rLOu9PxV8n5X11eUMq8cT0Ub9LxOgglXTQo3PW3Ptz1Uou3TTb/dkbSt250FecXQb0M51X3U7rdkXiK2hKiPovFQ5bKWbkM51f03OTfyr5PpPuoc0HFrsjFw0w99y/Pc9K3R2J7zr95BrHmMh/vjo391ty0uLu/Kv/KAP7Fa9UTWWedtmZeYH4fqiT8/zMzq8VDmpT0xR1J9RqqDPNW+stJ7XmY6Fm5P/PkdhE8rRV5Z6xg+CeqbTP1yQz2E1gqOmIPx7HvJpNBl1NYUXWc80eMxFHnz/oG6bstvx70P+TFytLNpP/9PrybWPMbD/fEffvtu6/V3983l+/1+/pYb9J6TTvx9wMxsYAtu+mbwvHN4RU+SLVFuI6jv6D5dn3ruOrGh9+WVBT3vF7t+3oNndX3Ksy7TAeBz9/nnMTOzqw/65dZ3dBv6wfPYvkW//waj2WOQmdlq309XMcPMrAzOzuo5biO43/3VKZl3Jj3opt8u+nxnsGWv/b7riTWP8XB/vOr//TFrtXefEQ5fseqWm/dvMkzFuX0hOLPvDGZ/3mi1dDzJ8+B5o/DbF83tTL0wCspVwbufqvTb0O7oWBP9KfhO1y83DQ5Dqh/Ot8Pfz6P6suA9zliU67Tne3+nTIJnxuhapRir0dCfl5PRlr37rc8n1jzGw/3xhl/5snV6u/vmxmv8MQiO8+FZVS3L6EycZfpiXfG4NgqeDxY6ur62OC8PRvqm1BnbTO/Nw7G+355o36QI3rvu6LyFtl+fulczswPLOm9n7Kev+EdWMzM7vh4884z9vt23pGPDQkfnnd7052wezKPVvq5PbTN/+Xk/Yzzcsl95ww0XRKy5oD5CPXxA6XSXrNPb/cJmeWnLLTft65nVWdadnC7tvoaZWavhj1BJsJDqkZ5YSwvNfoQaJ/61sjk+KM1TJsrLg/qWxMNfJOqHqM+Xl9VHKH2t7ZF+mdsXH9Dm/Qi1JD6gLRe6DfwV5kd7uD8WW7kttXc/xHQ7/oPNxPnZh831ESqqL5ggavnP+xGqrMUan/cjlLjWJIiDSho8FGbBm9xCHIZKCx6SnA+SD0tEPIn6qPGPUMEyHrfEh8TgI1Q3mH9qri/3OroRRqx5rEdizeKyLTrnDbXfNP8RSpepx3oOp85D3/mMC+MjVDrHRyiVF36ECvb/sfgIlc35ESoRD2QR1QYz/YBiQTzOggfuRDyczv0RStxvdyvef4g1j/Zwf/T6S7bQ3x1r+ot+Py8vRx+h9ETNxEeoOtfzanlZTxL1nFQ1XN92sC8vBR+h1Ll8I3hJqai4b2a2uKSDjSpXZMFHqOAP8S2Lj1DZHDHIzGxZfIRqNfwRqsqDZ7hK/4GLSeo/8/cXgwBvxJrHerg/Wu1Fa3V2nxG89zd/u9zM1xPzu9PTsasoZ/8I1Q7+YFv0ESpTH6GCdzXRBxZVLqpPfYRSH5PM5vsIlWbBR6M5PkKF9QV9ZKn4CBV8dJuHmnuPdy01VlUdz0tizaM98l64t2RdJ64s9J+aj1BpS49L9PFAfYRKdeiyha6uryPONXX4rK/rU+d5y4OPRuIjVB58hJra7B+11L2a6fOsmZmJvg0+FdhCcEYxEfsXgg9D/a7O2yln/wjVX5z9I1S3F5/jLoRYwz88CgAAAAAAAAAAgMbxEQoAAAAAAAAAAACN4yMUAAAAAAAAAAAAGsdHKAAAAAAAAAAAADRuvt88/yR748tO2fLS7l8uOvmbj89c1/TYl2Ve++qunz7ckmXkL+o2/YvoV/qrskw3+EWY/a7/S8PufFD/gjL1S/DMzK495P8ytOD39NoXj/m/sLUT/NK6dpA3GPm/KC36RYGqH8zMTm/5jVe/RNjMbFv9Ij4ze/Cs/8suVxf0uF++rH/RZF34efV4IMtsVAdl3tX9bTf9E+e+cVfaINmU9cBs6ZrLbKmze8EkYjLmC368MDMbPHhK5iXBL7RViuFY5qVtP2xXo+AXvHZ1qFf1laNJUF8QaITeQf1bIafb+lrKeFOXScVvF81aeiwmA72O233/N12OzgxlmST4pbp5TwRd8Yu9zUz/9kkzW7nxMr/IWN9TkulfqlsX/lwanjzrpo/Gs4/fpeSq8h5bLhd3pafbK+7PV2nwy6SD80QtyiW5Xq9JcK268udBPdrR9bU7QX3+vM+6wW+MDc4nHfHLgoPf0St/+eso+MW0we8/V7+z1qroNyMHcjEcafBLZLttnTeaiF+QHfSr2BK+xq9v3t9xq8bqm5/lnz0H2346zvs7N6W2tLS7Uw/ed5tf4MyzdWVLazJrYervBd2hn25mdsKul3mHVvyJILYiMzMbT/UaU3P4yv06OCzV+tnvc6f8zfnQip74BzP/DL459OO+mdmth3VsLTq7fzG7mdlqTxaxc0PdPtW3y5Uew+gZuFz3y3VyHUDLM8dkXnbgSjd9beuELDMJnvnXjt7gpv+9A37Q3ez4z1s4b2G5b+3u7nWxtOyfAcZjvZj74oxtpt8PDLb1+XZhQW9iZenHjW5Pn4WKYvb9fHFJ31N0PMjEs8NkojdtVWa4EzzXBO+fVB9Fv8y+3dF9rq4lHtXMzGx1TT9zD8Xz2s6OPh90e9Gc8Pu23dFzohPcr5qzS2JOjIacayJHD7es58SIV3+L39GfvVf35336dY0t9vx5f5V+LWcnN/Ri3hb7741HdX33nNSLoi8erw6vBm3Y/Tr9Eeq557I1Has3Bn6fZ6luw/7l2c9q0dnvwLLuoxP3+nlV8A6lKHV9+5f9hnSC58KovuUFP9asBu9/zmzp+m466o/HF1f99E579vd3Txb+JhQAAAAAAAAAAAAax0coAAAAAAAAAAAANI6PUAAAAAAAAAAAAGgcH6EAAAAAAAAAAADQOD5CAQAAAAAAAAAAoHH5090Az+Qrn7ZJf+EJ/3y675DMy296kcxL0tqvL2/pi7V7Mms88dNPn6tkmV4rkXnrA7/cyoIuc3rLvyczsy8dL930otRlCr+Ind3W93TZ6uzfNsdTnbexo9vXyvy+uPe0bt/hZd2+fnf2tteFbnw9HbnpaX9VllmZbMm86X1fcNNfuLi7vs1iW9YDszTLLM2zXemTjYH780mu50aUl/e6bnrWaev6Ul1frRZloK70elDX8vrmibRBXWvnlL8WIu2+jsVpquNg2vbvqQ5iXTXRfVR1/byq0vV1V/T4KtG4JyLWmZlVIoBWwThlmR7f7oFVN33hcn+vLYZjWRfMkt6iJQtLuzMyf46k3eD8E82Rwj+E1Lmei5NSz4N2JWJhu6PbEFyrNP9aE3F2MjPLg3k6GPnrL1iWNhUxIAqrQaixLdGGaVBfJzh5p0lwMSE6ww0nft5wqsvUtW5DWfl5Sz0dPzd39JytZFYwiJA2BrWVzrPNZUdvdH++WL1S1tVJ9MKsBufc9Pta18kyfb2UrZX4C6bf1YUePKsX2VA0ve8fx86X6SzKvE7Ln4+HVvTcfuDMssjRc7u3rMqY3X9KPcPJInb1weh50V+zl+e6wq+eDQbRDrqp/SCAHr5qVebVI3//aV1xkyyztarzel/4Azd9/LxXuOnb6aasC9p04s+fOtiYz5weyry2OM8nwV45jTZgVWai6xuPg2ee2r+vrc3gYBMIHtek/qL/rJQG58XNoH2ZeN7odPT639kuZN5UjGFR6JudBM9kqn3ROO3s6Pa1xLu4aI5lme7bbs/vp/WT/rPSeMQzVGRcJJZOd4/F+z/pj2krOGMfXdNx6NhZf7xPngveNwRzZKHrX+uvv6LnjjprmJltD/1rjYLY9awr9JpQIXns9PXD1Hl+MXgGECHya9ea7TpmZl8+rq/VbfsXe2hd13f5Ad1HD637a3n/sm7D+nY0X/z0cfBMFvnig3651UW/fcNkjg3mScLfhAIAAAAAAAAAAEDj+AgFAAAAAAAAAACAxvERCgAAAAAAAAAAAI3jIxQAAAAAAAAAAAAax0coAAAAAAAAAAAANI6PUAAAAAAAAAAAAGhc/nQ3wJMfvsbyxcVd6cWxu/yfP3KdrGtSRFdK3NRemskS26Na5t17unLTO0EvH1/3y5iZrfb99qV+spmZFaVu33jspw+Ce7rygP+dMmrD2W19TweWxXfPUtcX9dGBZb8hyz3dwO2xvt9cDP1qZyrLWHtBZg3Mz+ttHJNlqtXLZV6ysOSm52tHd6flm7IemBWjsRX17rnQWvLHrBiOZF3tpb7MK0cTN73O9aSvC51XjkV9lZ7X5VgHwnLiXytr6zhYB3GmKvV6nVVUVxXc73TdD3bFSPdrEgS16cBf/61+S5YZHBvIvM6+jsxT2mJempklmT9WaaLvKW3rjamzf8XPKEX/qXSYmVk9Hlg92r33Ja2u+/PVaEfWleR6zqm8evucLNNO9Z9Fqkt/3qt2P560GLrpvbwdFNLtWxVhdzzV876q/bzxVMeTIBzbkuiKIOSGChHzgm6wcXA8UXnTQvdREDasEiF5Z6wLRf2XifvaEEtgRy8NmNnxc6X1nQ5/3nX+2fH4pt5jj6zqdXn7xmE3vR9sbZNgja0u+HvY39ynF9IgOMs/6zK1J8oi9sAZ3Rft3C/4h3+tF99V4vlpPXhG+sID+n6/9QY/vn/6Hl1m36K+YfXs9zfFmiwT9d/JDf++juzTwevuk3oM+x0/wF+5X7dhZUE3sL76Zje91xMxd9rcWfaZqK7P//dYutr3vAABAABJREFUOzv+fNwXnHtVGTOz4dDfQKbTZs+dWarrKwo9F6JnByXPZ/8z4NEz3voZ/2wV6fZmfwW4tRUcNgITcSCK+kGdNcz0eETj1OnoZ9rxSMQAdUAxs/FYz5epeK5eXPJjeCs418NsMKisrHeP0U1X+Gsievd7z0k9pnnm1+fFuYclwVLutUX7gmeUfjd4jyuWX1dcx8zs1Ia+1sEVf97fca+ODf2ef62Nge6I6HljpS/WchDeo2t1Wn77WkG4e/C0jg0HRB9Fc2w4nj2+R+/v9y/ruHb1QT/9L874bZinbU+WC6clAAAAAAAAAAAAeMbgIxQAAAAAAAAAAAAax0coAAAAAAAAAAAANI6PUAAAAAAAAAAAAGgcH6EAAAAAAAAAAADQOD5CAQAAAAAAAAAAoHH5090AVzE1Kya7ktOVg+6PV8MtWVW3GujrVKWf3u7KIr12IvOWe37e0X36W9/qQi3zxoWfp9LNzNLgs2Kv7ae3Mn1PW0P/WqkuYuNC56n6hhN9T4OxzitKvyEHlnVHnN3W9V25318S95zRS+XAksyySlwq239Ulimmur6s0/fLnLx3d9rWtq4IlrXblnV2L4piMHR/vpoGEzsiFstkS8emuqhmvkxd6TLTbT2p2it+YKgms7chkgZBoxILZbKp212Xun1pO/PTS732u/s6Mq8Y+XtF3vWvY2bWWmzpvL6/x6RtXSYXZczM8p6fl/f0PbVWdeBKFpf9jO6C//M7/prBeenimqVLu/s0URt2qudVHWwQiRifehycg3I95+ZRj/S1EnG2qoP7jRTiCNfJRIaZjUv/Wp2Wjk9FEDfUHq/OOmZmS+KsaKbPcOpezczWBzoWqjPSzli3IQ+GQ5VrB+0bTvS1xmI6t8WRa2cnOHzCrE6srnf3UbV9zv3xQwf2y6paWfB8MvXzpsE8iJ4bvvyQX3BjZ/a5HbWjFczt6DlE1feKW/WzxheP++n7g+cT9ZxmZvbpe2Y/gy739LWOnfXru/6I7qR7T+nx+MZr/UV7ekuXedZl+lpri376Qxt6nPrO3H9YIvbOcv2En76l3y3ArCgKS93nIn8ST6bBM0oQOFpi0ar0823T16pr8V4j02slelmmrtXu6FKj0exrudvV9aXqXUPwfmcSPOP1en7fVsFzV0s8d5mZdTr+OXMw0OfZbjAeSq0OZBbPiUxsTq3gXNhu6/apZ9qNc7vfbZqZTUZ+Os7r91PrLezu7zNbfj8PRsHZoIjO+v6Y9jp67mwPdX1nNv01u7ak64vars5QZ4Ktam159mebyw/qeKyeAaLz3fKCvt+Ngd/n3jn2YSt93b6ReN4YBs88K33dvtMbfvuiMt22jkPt3M/Lg/N2lHfHA377VJlcbRZPA/4mFAAAAAAAAAAAABrHRygAAAAAAAAAAAA0jo9QAAAAAAAAAAAAaBwfoQAAAAAAAAAAANA4PkIBAAAAAAAAAACgcfnT3YBZZCsH/fT9R2WZ4sRXZV7SW3LT86C+LK1l3lI3cdMnhSxi22NdXyvT5ZRO7rfBzGw48a91alO3YW3Rr29zznb3O359qm1mZgeW9LfSkxt+ubVF3Yai1Nf64rHSTT+8rNuQpbrPRyP/WlW5IctYZ1VfS6yBKm/tSkttdxq+ri5Lq4vd491e9idPXVeyrmI41hdK/PmRpHpO1ZW+ltdmM7PpYCTLtFfaMq+a+NcqhjpwlVPdvqzl39d0MJVlJgP/Wqqux2tDOhJ9tK3bkLXnCLhzyrr+eOT9nizTWfX3KzOz1tKCn5Ho/ksWl2We9fqiEV0/XQ8FzKye7Fg93j2/6tSfc1FssCxYyxunREYUT/SaqAbn3PT8gJgHZlaXuj6biDLDLVkkaelrtZx9z8xsarqPlGlwLmja1lBfS+WNg24djvV8GYk+nxT63JIF028qytVB902m+lrdtl9wR9xTdK8wa7fMOs6yuC+7xv359JyODVfun72vl3p6rDcG+lpbQz89Ov+v9Gefw5evBuf/B2WWjad+ud/+hC5z7WE/fZ94rjIz+8oJ/+xiZnZ0zd8vjp3VZT74GX2OE0dJe/CsLhM9W33puN9HneBNw5o4apiZff4Bf74sB3Ps/jO6L64S6dm+I356Js5VMDOzbrdl7e7uYJPn4hlgoscmEc9JkclYz9Pegn7+3d7yN8V52mBm1hYTfDrV99vt6kWRZX47yuCMUpXiOS54/1TNceZR93r+Wjq+D3f8Pm939HNX1H8dUU71Q1TGTB+Rozmh5pGZXgMLC37/ZclF9Tr2KVcUZlNnLi90/Dm8vKDn9t0n9DxQ59HoDBuFDVXfMfGoZmZ2eP/s6/Lay3SZk+f0Gaotpt08zwDDse6IpWA85gm7ZzZ1A/td/1p5ptsQ1bdvyQ8O69u6jHcGf5iaE1E/7AR9q+o7JcZ9NJlvn3sy8DQHAAAAAAAAAACAxvERCgAAAAAAAAAAAI3jIxQAAAAAAAAAAAAax0coAAAAAAAAAAAANI6PUAAAAAAAAAAAAGgcH6EAAAAAAAAAAADQuPzpboAn6a9Ysri4O6MqZ64rO3Clvk7qf4Mr07YsM5noa6Vp7aaPp366mdnla/o7YFX56ed2RIaZbQ113tltvx0L+nYtE81bXUhkmcFY3+9w4udNg6EdbOl7yjM/vdRNsBsvE4UC6jpmZr1UT4px1nLT096SLNMuhjJv+sCdbnq5fmJX2mR7R9YDsyTLLHEGtq79+VYMx7KuyfqWzEvbfpitJlNZpir1gqgmhZteDP10M7NiNHvsrCZ63aVtHbfUtcqgvqzl11dXeiHn3dnX8eKVzr7yNQsHF2Rekvvtay/1ZZl8oavz+j03vXNgVbdhcVnmWVe0va/v1zq6fab6PRVxv9b7Acyy5QOWLe8ev2oo4kZw1qm2zugLpf6aqLbO6iLBXqQOIWVQXyLaYGZWizNXpJ6M9LVyf3/NW8HcVlp6fbWCUKO3fx27iuCA0mv7a2lrqMuILcHMzHbGfp8Px3rN5llwgBKioY3yNndEbM3FWTG4V5yfP94cWuv7/XzinN6XP3OP7uwVUd9InPHNzA6t6Inw5RN+Ozr+Ejczs3ZLz+ETAz+G3n9a11cE542br/TPcVH/nRbPLme3dRuOrulgo/o2aLYt9aJY46cfX9f9qp7hzMy2R37eZft0fV9+SO91Sz2/3PF13eeX7dNzLDlwo5uuHtGn9exnzEvJcGdsZbl7EvUX/UU73NFjnWV6jtS1P0CJOo8+jk7HH9dUvfAws6LQc2408uNk1Dx1T2Zm47F/raoMnslE25PgOrl4rjGL71eZTuZ4zgzuqQzOScXUL9dqB/EzeEZWJvqx37o9/Qo1Sfy29xdFGWLNXNT5cTTRiy9al2PxWqYodaF+V8/TTku8d+3oNpzd0utyc9Ofw9dcrstE7y8nhX9f0TNAS5zNFzqzPzeYmd3zoL+W1/bp9RWENdseqnvSZaaFrvCkOA8t6VdGdmZD56m//6Oeeczid+RqPnfbfn118E3iqcbfhAIAAAAAAAAAAEDj+AgFAAAAAAAAAACAxvERCgAAAAAAAAAAAI3jIxQAAAAAAAAAAAAax0coAAAAAAAAAAAANI6PUAAAAAAAAAAAAGhc/nQ3wJNkuSVZa1d6uf6Q+/PZysGgtlLmFGdPuenpFc+TZbptfaV2lbjpGzu1LHP/Gd0+ZTDSeVUV5NV+O87t+O02M1sf+GVKca9mZv2uvl/VvrNbur7rDuu801t+hVtD3YaNge6kTsu/1sqCbkNR7p6rD9u/7JcbTzNZph0MYn7kOje9nu6eFKnpdsGsriurnb7OOl3/5wdDWVcWBIa05YfZalLo+lL95wMSkTcdTGWZedSlnodpqudv1p99WyknfhzMe7quqH2dfR0/fcUfWzOzqtCxuLO05KZnPf86ZmbdA6syL19Z9jNW98sytijKmJl1e25y2l+RRZK27gtv/43k24OZfv5SU412rGo/8XVRT8ZBZXre16WIAcUkKBPkFaK+4ZYuk+u5o+ZVOBeDvLTnr0sL2lDv6LYr01KfJ9QZZDjRZUZB3rpYSqOJPoNsD/V+sbHtl5tMdbzLMl3fUOwzK6vB4TgwGPj74NKSv16mpe4HmB07a7bghI9vOeQ/7yx19blha/WozLv9Xn/c9i/ruTPWRx45vxfaeq10gpCaZ359LX10saWebvun7/bXy7OO6jJHVv0G3ntq9uc+M7NUTP261msiWOaWivG4PDiGdPLo2c9PX+3rMvM8q33zDTq+R32bifcB95/127clYjvOq6vaqmr3+OW5vyZ6a3rctrf0OWQ89sctUwvCzKbimcLMbGfHj3mLS/o8Pxzo9iWiHZ2uDlBlcKYYDf32RfUVhT9XOx0d8EZDHZC74tkr6lfxisnMzNqiHVF9ql/Nzs89j+qHx6PmbLs935/VV3M2ScQ7oWAsYFbV5/97rGsO+eN9Ojjmbw70mK5v+3nR3B6MgjgkhnV9U8/TKw8H7wAzf13ujINzUkvnqWeH1UVZxNSrq/tP6Ousrug+X9vn39Pqou6Hex7UeX3xDmq5r8sc2iezbDz1xzd4ZWSH13RfqLnUDc66+4P36me3/L6dFH67L6RnKP4mFAAAAAAAAAAAABrHRygAAAAAAAAAAAA0jo9QAAAAAAAAAAAAaBwfoQAAAAAAAAAAANC4J/0jVFEUdt999z3ZlwEAAAAAAAAAAMAFJH+yL/D5z3/eXvCCF1hZlk+4TD3cttppWbZ21C+QtXVd05HMS3vLfnox1I1r92TW/WcqN3192083MxuMa5l3dM3/RjgpdJlIr52I+nSZrR2/TBp8vnzglJ5WnZbf9jzT9/TgWZ1XlH5Dqlr3eVX592RmdmjFT++0dJnIZKrq0/dU7QyCvC03PUl294OXhq9Ls8zSPNuVXk39QUuz3T/7sKQ3e19nXR23SjVxzKwcTNz0utRzKu/qtlcTf63U7aBMpa9VT/360rbuo+nAv9/+4QXdhlKv8YVDfmzPeh1Zpr2yKPN6h/e76Ulbj6Gt+mXOV9j305f8dpuZZSsHZV6Stdz0dCloQxTE1XW6fruznh+X8DV1ZVbvPgPVE3E+CcamdurZi1rsKeevJdZYpdtQb52VeUlvyU3P8uAMV+hYWA3O+ddpdWUZy/21Ep3FzgZnuLFo3pktXd/OWJ8nhiJvaxiUGem8nR3/gLe1OZZlWkHsb7f8ubmzo+dEK4j9hdgvxDYs03HeVQfMFp1lVld+P//5Q4dkXUs9Pab7Fv0xPbGu18qBZT1Pb77Kz+uI+WZmdjy41saOn1cG5/+Ftl6ziSj2xQd1G/riuDHQS8+K4FxzaMXviyTRZXrBs4tqR9SGYabrG/lHU5tMdb8Og7znXuE/S57c0O27+qCOXeWZ+930raH/bmF7ON+z9qUizTPLnGeo8Xj2M0qiFpiZdTr+mJbBM0/UhsUlf2FGzxT9RX1GmYg9rA6ek7I8iEML/hklkud+bJhOdD/kQWxVbY/OBkkaxA3x3Jq3dH1ZEGtyMSdGQ/1CK6pPzbGo/1bXgnOmoNpX18SayEq/sl5/9/w6ueGPqTqXm5mtb8/+7NvrzDc+WwO/fWtiLzfT+6iZ2VRM77Wl6BlFz3sV8jZEu83Mtod+2/vitYaZWTvX/dfK/UZEY3hwv44bZv61VLvNzLI5XpdGS1a9OzczO7jqx5RgCwznbPQ++ULHW2oAAAAAAAAAAAA0bs9/E+oFL3hBmD8cBn+rCAAAAAAAAAAAAM9Ie/4I9YUvfMF+8Ad/0K699lo3//jx4/alL31pr5cBAAAAAAAAAADARWTPH6Fuvvlm+9Zv/VZ7/etf7+Z/5jOfsXe+8517vQwAAAAAAAAAAAAuInv+nVAvfvGL7c4775T5S0tL9u3f/u17vQwAAAAAAAAAAAAuInv+m1D/+//+v4f5119/vX34wx/e62UAAAAAAAAAAABwEdnzR6inUl2XbnqSt2SZKM+6/ZnbcOxsJfMy8ffKVvqJLPPQRi3z7jru329V6frGU52XiKztof4LcdtDv5Cqy8ysKHVmK/fvd31bt6GqdR9VYjjKSteXZ7q+PPPTzw10md6qvt/TW34DL1/TZbbbB2XeokhP8vautKy9JeuBWTUtrEp3z5PW0oL/85NC1zWeyLy68udOOZnKMmVQXzX151Rd6jka5RUjP87MS12r1dfbTefqJT99Tc14s6ytY3tr2Y/t7RVdX77oj7uZWbL/kLhQR5c5fIW+1sEr/TI9vx/MzPL9R2VeXfhzqWjpPW440XNiqefHJxVvLdF9B02NW5KKjcjM6tGOzpuO/PoSvR/WpY5D9cSvLzo71VUQT4b+nlR1g/kz1lnZ6hE3PWl3ZZnNqR83zu3os91Yh35b39blFHWuMjMbjPyxGgz1et3e0p00GvqNn0x0u4tC543E4W9xafcZ5JEyI92BiaivVPumSMd5/U5i/c7uPv3c5gH3568/omPDZ+7Ra7nb8sfh0Iqub1LosRuM/bwvn9Bz8fCKXkeqHYORbkOa6vquF9c6uqbv94sP+v23NZRFbCV4LL3nlN8X33urXnsf/IyO7ztjdb+6H154vb7fM+J5J6Keucz0c9dGEKsjB1b9c9fN4pFrczNoHCxJEjd+9xb8PTbL9Lza2dF7RJ77c64odHyqgmeeidjQW2093mVQX7frP9tMp/M9WyUiDkVtKMazX6sI9uVuTzxfBW1Qe7mZ2dKKfyabt4/Uc3V0DonONfNQZyszs/6i33+qj6K+g9nGILVxvTsO9Nr+/CmD96T7FvU8OLXhx5rgaBC+D+33/HkavavtiLOVmdmqaHtUX0S9t+61o/eufl7wisyO7tfr/IHTftydFvqegtAv3zMvdPQ9be7oa630/XJRG/Yv6zn2wCn/fg+u6jLRnChFsbF4x6PSnw57/uf4AAAAAAAAAAAAgMfiIxQAAAAAAAAAAAAax0coAAAAAAAAAAAANI6PUAAAAAAAAAAAAGgcH6EAAAAAAAAAAADQuLypir7xG7/RkiTZlZ4kiXW7Xbvhhhvsda97nX3nd35nU5cEAAAAAAAAAADABaqxj1Df933fZ+94xzvslltusW/5lm8xM7NPfepTdvvtt9vrXvc6+8IXvmDf/d3fbb/7u79rf//v//2wrunxr9h0c2FXevtZ3+z+fD0e6MrSTGbVg3Nu+nrrqCwzLmqZNxj56cOJLlOUMsvMdn/UMzPb3NF/gS1Nomv55QYj/zpmZqm4VK89ez+YmWWivoWOrm95oZJ5qi8We7pMXev7XVv06zu0rPv8+Dl9rZaYfmWl27Dcmsi8cnvsp2+ccn52W9YDs2yhZ3m3vSs9yf1By3odXVmqx7MWi7wYDGWZvNfV1xKyjg7nky1/3piZ2chv3/C0bl/a1nE1a/lrpb3ckmXayz03vbu2Ist0D+3TbVhc9DOWV2UZ6/VlVnr4Sjc96eoy7atvlnmjfNlNP35ObwjDEzLLemI8hhNdX6anrPW7fqaa5ltbOgbCrBqcsyrdPRZq/tQjfaaJzjv1aMdNL3c2ZZmktTsGPlJf5c+ftAr213Kqr9UX63miDw11cK2k7cfkhwY6Fqrz2Pq2PoOc3NB5O2N1TtMLbHuozxNnzvj7/zRYy1tbus8n48JNL4KzbLuj43tH5EXtU2XMzCrRjLL0x12l47zhpLbMmeMHxBm2k+t5+oJr9bht7PgDV+ppZdHQjad+wdW+bl8ebGL3nfYvdtNRvfbuP6MbeGTVL/eFB/S8X+r57TuyT3fS2SAOLYpjYRS7vuk6HQs/fY8fN8ZT3a8nN3QfjVRsDR7Rn3elHo/TW359vbZuX78THGy+/DE3eXLDi/x0HVYRUHvOcBi+8JByMYWz4LnL2npe1WLTKYPgFe1hau9rqRcApvvITO+J/b5+hspELFT3GpUxM6trv1x0T0WhY8O2eAbtdHV8itquZlKxoxdtK3huVWOfRM/2oo+i+vqL/hjmmR5bmB1cqazX3z2/2qLbRvo1mo0mwfu3BX/cone1q4t63g9GfhyK2hdMK7k3q3erZmYHV3Xj1bNIFbwnXXHGwSzu15PndAOnhV8uevcbnSXPbPjXWtqnCx0OzmTqvfqpDR1Pzm3r+1Xz5d5jug2HD+j61Nxc818z2VA3+ynX2Eeo06dP27/4F//C3vSmNz0q/Rd+4Rfs3nvvtQ996EP2cz/3c/a//q//6+N+hAIAAAAAAAAAAMDFrbHfCfW+973PfuiHfmhX+g/+4A/a+973PjMz+6Ef+iG78847m7okAAAAAAAAAAAALlCNfYTqdrv2sY/t/qvuH/vYx6zbPf9vCFRV9cj/BgAAAAAAAAAAwDNXY/8c3//0P/1P9uM//uP2V3/1V/bN33z+dzd96lOfsv/8n/+zvfGNbzQzsw9+8IN26623NnVJAAAAAAAAAAAAXKAa+wj1r/7Vv7Jrr73W3v72t9t73vMeMzO76aab7J3vfKf98A//sJmZ/fiP/7i9/vWvb+qSAAAAAAAAAAAAuEA19hHKzOxHfuRH7Ed+5Edkfq/Xe0L1pL0lSxf6u9KrrbP+z3cXZF3VzpbMS9LMTV9LN2SZ/YdWZd7t9xZu+qSoZZlz2/pfROx1/HJpoutLEpllZzb9a+V+N5iZWeXfkmVz/kOOZeWnn93SFVb6dq3T8tMHo6A+0QYzs/tPl256GvTraKIbePXlQecK2xNxU2a2uO+wm14Nzu1KSzJdD8yyTm6ZM4GS1J87/sz4mmCSqvqybluWKUeT6GquOpjYOw8NZV6S+ZM77+ntYe3ZazKvvbrkpi9de1SWyVZW/YzDuoz1/euYmeVrfrn88htlmaSl/6nYpO3nbY51nDk70nPirnumbvo42CuKUgchFffrIHZG2mLorzzg3+/OeM4LXSrS7Px/j6Fig4n59khdM0q6u89TD6tHg5nrq0t//pqZ1YWOXWqNJf1VWSY/fI3MO7nhx7wHzuhYuDn05+rGQK+v6DyxMfDzNjb1jjEYjGTe5obff6OROIyZ2XhnLPOKabhziTL67FDX/r7VDfaLMtgfl5b9+jKxL9Xl7PP/UnLZvtSWlnfPyZMb/hgcn+i1csMR3dftll/fsbO6vo0dmWWFmKaLXT13onO5Ej1PnNrQFfba/n11gqfofsev756Tuo9uvEzHmgdF3959Uq/x01v6WtPCb19PH01tfRC13Z8vSz3d6blY52Zmg5F/rVYQAh5c1+27buOUm94V4a7NI1SoKkuryt1zb2m54/58mupzw9am3sOGO/6Y5rleK4uLehIPd/x2FIWeO2PdPFmuG7woSaOXKOJFyXQy+14eXsf0/eYtv9wk2C+i8VhY8BdT1OeRlggC6khtZjYez95/WbDJjEe6PtW+WmxA84ztpeT4mcS6w91j0e+J9ytpcG4I5siCeO+qzidmZncf03mHxKuS6Byy0tdrYmso1qV+PLCtHX3DrVzMx6C+oXjvoeoyMysrvY6i+1Wi9yE9cWZcD963d9vROwz/Wu3gfjd3dPvWlvxyK8v6YNMV508zs/3L/uT88oN+zB1O5jg4P0ka/QhlZjaZTOzkyZNWPeaF6FVXXdX0pQAAAAAAAAAAAHCBauwj1F133WX/5J/8E/vYxz72qPS6ri1JEiudPy0DAAAAAAAAAACAZ6bGPkK97nWvszzP7QMf+IBddtlllkT/LhwAAAAAAAAAAACe0Rr7CPWZz3zG/uqv/sqe/exnN1UlAAAAAAAAAAAALlLRbyycyXOf+1w7ffp0U9UBAAAAAAAAAADgItbYR6i3ve1t9i//5b+0P/3TP7UzZ87Y5ubmo/4DAAAAAAAAAADApaOxf47vu7/7u83M7O/9vb/3qPS6ri1JEivL8gnXla0esmxpcVd60l91f77cOivrSntLMq+ejNz0qudfx8zswVOVzMsz//dg9dqyiKVzfAYcTvTv25oWOq+qZ79WKqrrtnVlZaXbUItiR/fr+ZFnMkta6Oj2tYL6xoWfvjXU9a0s6PtV5ZZ7ug29dtB/k6mbni6t7U6zlr4INDHp6yCGZb1Os01oBaF5MHSTx+t+uplZHSz+RMSttWfvnlMPW7z6Mpm3cNVRP+OQSDez9Oi1bnp+6GpZJjl8vcy797Q/VuundD+cG+i8jR0/bzTR+8HYX6pmZrY99MdXxUczs1auM/ct+u2IfjXj2pJu+6EVP0ge3edvWJtZY3+e5RkpSTNL0t19Wk/G7s9Xg3Oyrmpb59WjgZ8xmUTN04Z+fXXXPzuZmVmu95269BdFuXaNLHPnAzru3n/an8Mbg+iM5M/VUi8HGwVnrnMb/qGhmOoKpxN9T5vn/Dge/Z7Vna0dmVcW/rW6C11ZptvTY7i46B9oV1b1QTfPdXxot/z7UvGuLuY4yF5CBpPa0vHuPrrlKn8MPn23not3nwzmqTjbri3qeZomwTm677evExyFxNQ2M7Nvuc5vx4fv0Ovyxst0209u+uUOLeu5PXDGwcws2i6jZw11pljZr9sdPS9uiP4rgvPiPjFOZmYDsS1EzzQbO3o8lnp+udW+rm8taF/37/x9N/1e8Vy/tRVsCrC6qq1y5sqZ0/4e1m4HY9Ob/XXUeKwDwHSq81S5Tke/HBiNdH1tUa4ODvRVcOBIRYBI1AsZ0894RRG8swr25dHQP9e02rqPJuoFSnCtqA1R21VeNMeiM1QmnoMj0XN13prtmSgaW5h1O4l1O7v76KpD/py7/5Sep2XwnnSS+WPaCV6nLS/qawVHc6kodfty0b6+Ps7bVC9L+Y4gaoN6X3vsjO4H1W4zs3Pbs78/mOd9yCQY95W+jjVnNmd/CR29t1bnvyQ4H/e7un0nzvoX66n34BfQM1RjH6E+/OEPN1UVAAAAAAAAAAAALnKNfYR66Utf2lRVAAAAAAAAAAAAuMjt6SPU7bffbjfffLOlaWq33357+LPPf/7z93IpAAAAAAAAAAAAXET29BHq1ltvtRMnTtihQ4fs1ltvtSRJ3H8Dd9bfCQUAAAAAAAAAAICL254+Qt1999128ODBR/43AAAAAAAAAAAAYLbHj1BXX321+78BAAAAAAAAAABwadvTR6jHuuuuu+zDH/6wnTx50qqqelTem9/85idcT7WzaVW6+5/vSx5T58OylYOyrvLMMZmX7Tvipuf1RJZZ7rVk3p3HCje9nSeyzAMP6bxeL3PTt7b865iZLS7qIZ1O/P5b6Og2TAo/79x2KstEhmN1Lb9tZmad1u5/4vFhVxzw81J9S9Zp6cxzA7++wVi3YRr8S5O9tn+tr57U93tgSfftUq/vplfH7tqdtrWtGwZLWy1L27vXc9Ly11DWacu6orx55P2ezKsKf8K1lzqyTDHSk3TtOUfd9JVvvlWWSW+4WeZ1nvMiN/3OM11Z5kvH/fXw0Of8GGhmtvOXek2eOuXH8CwLYp2Ij1G5utJtCLIsF3tCGgSulRU9vit9v9xCWzfi6Jru22dd5uclJ7/ipk+2tmRdMKuLidWFMydT0c8tvVas1vNU5kVlRkNd3bH73PRkZZ+ub3W/zOo859vc9Nv+ZirLrG/rNXFm0++/aO1tbYszQxAbNs6NZV5V+vVtbupz5HBHn+GKqZ83OKf38+FAj2GW+eeJhWX/LGFm1lvQ59y1/f7c3L+qzy1rS3r+jSZ+v+eZ3687aTCXYZ+/r7aF/u6+u3yf2nN0XUvBs8HxdX98Dq3oMtce0he767h/RjkbrP+br9J5f/AZf55cf1i3Iddbop3c9NOj/ju54bfh4PLszyBmZgvimHn7vbrMgSWZZVcd8Bu/vq3XWBRbhxM/8+5z87VPPXep51IzM/GawMzMVre+6qYfPnijm95L5nvOvVTk7Za1Orv3ik7HX0jRGXs00nviPIrp7PvEJCjTauu5oI7tSaLnaben39Vsb/nnod6CLlOKhRm1IXoeynP/fktx3jEzS8VZw8ysKPy+jeKJmkdm+r7GY/2smwXPV9OJeK7u6D5Pgv5T8y9vEVPmkWW1eybc3PH70wlLj1jp6zlyZtOvL0v1RO0Gz9mLPT9PnXsfr76JuN+tHVnExCstMzPbHvrtOLiiY+EDp/11Gb13DcKQ7V/2x6OqdaHTG9E5TsSuYEu454TupKUFfzyc3z70iGgMh2LsozLtYAzV+G5u+tcZyffwT73GPkK9853vtNe//vV24MABO3LkyKM2iCRJZvoIBQAAAAAAAAAAgItbYx+hfuEXfsHe8pa32M/8zM80VSUAAAAAAAAAAAAuUo39vdD19XV7zWte01R1AAAAAAAAAAAAuIg19hHqNa95jX3oQx9qqjoAAAAAAAAAAABcxPb0z/H96q/+6iP/+4YbbrA3velN9vGPf9xuueUWa7Ue/VvhfvInf3IvlwIAAAAAAAAAAMBFZE8foX7lV37lUf9/cXHRPvKRj9hHPvKRR6UnSTLTR6ik07Oks7A7oyrdn68G52RdaX9V5pXrJ9z04vT9sszq0Rtk3r7+mpv+N/fov3D25bvWZd7hI04fmFlV1rJMVcksq2u/XLqip0E798sUZSLLHFjxx8nMbDDy+2J1UTe805JZUprq9p3c0P03Kfz0VqbLjKO8wm9Hr6XbFzTd6q0zfpml/bvTrK0rgiVpYonT2UnL77fWvhVdlyhjZmapP+ezvr++zcxqEevMzOrCz2st6foO/w/Xy7zO973WTf+vdx2QZe59IJN5d390000/8YCOq9Px1E0fbe/IMpPRROYpaabbHekt9tz0dleP+8JyX+ctdtz0Zz9nVZa54qCeE998gz/HrljSfTT96md13ke/6mdsnnOTJztDWRfMrKrdzbmejtwfr0d63ieZ3hDlTlTquWPBtYYP+fvNwoKe272/+/0y771/5rfjvhP6jDSZ6LPBYOD3X7SHluL8lGW6UKW3eJuM/UNDkuj6gixdJrqpQHfR3xf2HViUZa66ZknmLfb8zji6X8+xPDgjLetty9VJgkMu7PCqWd8Z2nY5cH9+TextZmbH13VfX77mz8f7T+syG34TzMxMPdZcfVCXiTznCj+m3P2Qbl8lnpHMzK495J8d7nhA16facNdxXWapK7NsMPbTDyzpdu9b1LH13lN+O77hGn1O+vTdwV4iRM+LR/bpvNOb/n1F8TgPjninOv45eHDWv6ftrdnv9VJSFoWV0937X1H486rX04Mz3PGfAczM8pY/h/Ncz+3xWI/d4pJ/bo/OAKOheDkQiOpT5xAzs27X76eozFSck1pt3Uejkb6nbtd/LzSd6H4tg4WpxkqNrVnc562230fFNHiXtKjPzmrOqnSzeHzV+zbVf1G/wmw6TSyb7u7v8dTvZ/Xu0sxsY6DnXCaygqOBdVo68+yWX+FiT8+rUxu6feoxIHqmSBLdvnbuF9wa6gq7bfEuOXp3GfTf1tC/36i+6J2xOm9EbVD3FJmK97tmZksLs7dvoRO8S3bm/sPObPr9t73tx5TRzoUTa/b0Eeruu+9uqh0AAAAAAAAAAAB4Bmnsd0IBAAAAAAAAAAAAD2vsI9QP/MAP2Nve9rZd6f/u3/07e81rXtPUZQAAAAAAAAAAAHARaOwj1Ec/+lF7+ctfviv9ZS97mX30ox9t6jIAAAAAAAAAAAC4CDT2EWp7e9va7d2/7LHVatnmpv+L6gEAAAAAAAAAAPDM1NhHqFtuucV+67d+a1f6e9/7Xnvuc5/b1GUAAAAAAAAAAABwEcibquhNb3qTff/3f7995Stfse/6ru8yM7PbbrvNfvM3f9P+y3/5LzPVVQ23rcrqXelpZ8H/+cE5WVd59oS+0KZfLr3iellk8tXPyrxnP/u73fQX7jsmy7zuhZnMy5b8vHG9+2+cPezcTiXz+p3ETe+c+Jwsk64cdNPr0UCWSXLdPstbbnImrmNmVpruo1R8Rv2LO6eyzIo/jczMLM/8Pjq0Mt/32kO9sZteZD1ZppWUMm+c7XfT0zO751g12H6c1l3isuz8f09QkgfhsuXPazMzS8U1+ov6WtXu+Pew7vXPcdPvvOb/Kcv89m0TmXf2nSM3feP0g7JMZ6Er84aDoZteFXpe5y2/by+77nJZZv3kusxbWPIXeTktZJnlNT0eaeav/yuu1GWOHNRz6xuu9eP087Y+LMtUD3xF5tWfudtN3xrpcS8G/ribmVWlP1Yt0a/TkR/n8DVp4m5W6YIfz6tC719JW6892xH7VK3PBWpPNjNLxbrcedXPyjK/+gd6nT90fMe/TrC9pkFmVfn3lee6zM6OHwOmE93uSJL6Z4Ziqvt8ZbUj8zJxBjlweEmWmUxmv9ZzbtRtWFvScbKV+3vT9Yd1vBvr6qwo/fqGInSlZWN/du4Z6cxmbUPn/LBe+LH7+Lqe96OJPodMxDA870o9D+49pa+1uuDP+xPndBuu3K+v9amv+JNua+hfx8zs4IrMsq2h345rDun6vvigvy47LX1Pm0H7rjzg5x1f1/WlwTOhOvLcfm80TjLLxoXfjkMr+p7ueEC3b1r45a49rNtwwyGdV57xz7Qn2v45s2jrdsOsnJZWpLvnSqcj3l2Mo2cAHdcztccWwfuOvj7XqHZUpa5P7fNmZrV4XiuD5zh1T2ZmWxv+M9TyPr348tyvT7XtfBnd56XYl0cjPYZJsFxaC/54RGeXqH3qvlptvScMtvW5WpWL5tjSkj5DReWa+PlLzWRaWzrdPeYtMdzRM0W0/6o5LB41zMys1tVZW5yX1d5mZiZeN5iZ2Wjil8uDV1nRtfYv++v5zKausNf2O2NTPX9afE/q1VDU7n7wGKzGdzjWjVjp6wE+u+WXi8b9zKa+VrftF1wOzlbB6zM7tCr2s8ofwzR4p/5Ua+wj1Ctf+Up7//vfb29961vtt3/7t63X69nzn/98++M//mN76Utf2tRlAAAAAAAAAAAAcBFo7COUmdkrXvEKe8UrXtFklQAAAAAAAAAAALgINfbvWlx33XV25syZXennzp2z6667rqnLAAAAAAAAAAAA4CLQ2Eeoe+65x0rn90iMx2N78EH9u0UAAAAAAAAAAADwzLPnf47v93//9x/53x/84AdtZeXrv9m1LEu77bbb7JprrtnrZQAAAAAAAAAAAHAR2fNHqFe/+tVmZpYkif3oj/7oo/JarZZdc8019u///b/f62UAAAAAAAAAAABwEdnzR6iqqszM7Nprr7VPfepTduDAgT03KkkzS9JsV3px+gH359OlNV3ZaEfn7Wy7ydXJ+4P6hjIrv+8uN/3c5z4ny/T+7ktlXtLuuumdm3WZg+nufxLxYdX6OTc93XdYlqmLqZue7TsiyxQnvirzWtfc7KaXZ47JMpOly2VeL5246d925UiWqbrLMu/EuWqmdDOzqw/snqsPK7Kemz6c1LKMtXV9lSiWTHbfbz3VfQCzpNWypNXendHx1505/9zo1ytLdN7yqp/e9eeGmVnr2ltk3v0Lz3XTP/lp3Yb9B/S1Njf9NbS8tijL9BZaMm9xueOmt9uz/+uvaarLXH7llTLvH36n375brtDX2vnd/yDztj8rYvjng/oe2v07Eh82Ou3vS3eXOi7kvdm369aiM7+/phj6sd3MrLPad9PHZzfc9MFY1wWzejq2erp7TiZdv5+Tjp9uZpZUei9SO0fV0es/6SzIvN7l17rpt91VyDJnTo1l3mjkl+t29dwej/TcUnEozXTcUHEoy3T8bLX0ntxfFG0ItoQjh3X8XBDjMZ7qCvNMx41+18/bv6zn0dqivpZqx9qi7vNgytpxcbaaTFV6cHaCXbYvscWl3WM0FXvLYKz7c3VBz4NzO365LzygY0M0h8diXJd06LJzO3pibQz8a+1b0mUGI92+nthKu21d5nLxaHrinCwS6nf8a11zULfh3tP63FqUfrmrDui13NGhy26/xx/DGy/T9R1fD87VuV9fmuj6pg98Uea1rni2m3505L8L2Jz46Tgv77Ss5UyIRDwPTSbB2SXYMNVe0OnofXkwCM63olye63PIdKrnaSliax7cUxLkLSz5z6DTiW5DnvtrYmdH98OSeFYz0/2X57rdRaH3EvUop9ptZjYM2q7Oa63g/Un0bkWJ5pia52Z6Tqgza13t+XXsM9rKolnPeSxa3/bnT3QmHk2is7SffnifXnsPrQfPB+L8HbWh39VxUpWL7jd6PXVm02/7QtCGjYHf5+2WbkPwCGVV7Tcw6gfVhsiRNT2GD56O1rmf3hLnEzM9j8zMem2/XHQ+7gR9q8ZQxdzgtdpTrrGod/fddzdVFQAAAAAAAAAAAC5yjX56HwwG9pGPfMTuu+8+m0we/afrf/Inf7LJSwEAAAAAAAAAAOAC1thHqE9/+tP28pe/3HZ2dmwwGNja2pqdPn3aFhYW7NChQ3yEAgAAAAAAAAAAuIQ09i8DvuENb7BXvvKVtr6+br1ezz7+8Y/bvffeay984Qvtl37pl5q6DAAAAAAAAAAAAC4CjX2E+sxnPmP/4l/8C0vT1LIss/F4bFdeeaX9u3/37+yNb3xjU5cBAAAAAAAAAADARaCxf46v1WpZmp7/pnXo0CG777777DnPeY6trKzY/fffP1Nd1WjbqqzalZ72lvyfH5zTlZWlzsv926/vvksWGT50RuZVk6mbfub2+2SZo72OzKur2k9/4G5ZxpLgu+Lyip/e0m1Il/a56dn+o7oJra7Mm973BTc9P3SNLNM68xWZVy34cyLp9GUZO6Pn49GDV/rpC0NdX1dfq1o/4aYv7Tuiy+ye+o9IEz89yVu707LdafhbktRfL5kIi8E6scJf+2ZmlmZ+ujNmXy+j1/Hl+/z6/h/frCfO0cWRzCvP+DFt8pVPyzI2HOi8wbafvnFWFqlH/voqBsG6m+g+Gv36OTf9RLC4qrEew3I08dOnusx0cyzzOqt+jJxs6TLt1Z7Mq8V9laNgXgaS3J9j1aTw06d+Os5Le0vu+SXtLLg/XwXxJCn9uWhmlrT9GJUfuU43LohD2dKaf53bdXWHjvj3ZGbWOefPq7L0zzpmYSi0TtevL8vERmlma/sX3fQ812X6Xd2+WmdJ3bYuNBVH1l5Hl1kI8pJk9gYORtF4+P0UnVs2RzpzMPavpaZEMFVgZpPSbOyE440dv+MuX9MLLBrTdsufByfWdaHvfoGONb/9F/4eEq29kxs675rDfvq5gV7nvbbMsuHEv1YlntPOl/HTV3SIDPv8ruN+Zjdo97ltPb4rfb/tW8PgnFTr/ju65td3ckPXJ44UZqafd4ogCHwxe7bMu6Hw94ueeo4sCDaRViu3Vnv389JUbGLLy3qibmzos28h6quCeRDt54pqt5lZqyWe40yfX7pd/YptMNBnPHW/3Z6On1sb/rNSf1k/N2xv67OkuifVNjOzTnC/xdSPAUWhY0Pe0rFLvR+LzpJ1cFhTYzWd6PuN5svKqn8W397y+3zibdp4xGCUWOlsCIf3+fMneiSNzstF6ccNlf549ZViekfPDcGRwjotP3M81e3LgmeoRBRzwvrjtqGd64af3dKNGI79Rqz0dWwYiucGM7Ozm356ErwfP7xPr+XTG37sF69JzMxsEozHPG1QfWRmdmDFL3ffQ/79jsVZ9unQ2Eeob/zGb7RPfepTduONN9pLX/pSe/Ob32ynT5+297znPXbzzTc3dRkAAAAAAAAAAABcBBr75/je+ta32mWXXWZmZm95y1ts37599vrXv95OnTplv/7rv97UZQAAAAAAAAAAAHARaOxvQn3TN33TI//70KFD9t/+239rqmoAAAAAAAAAAABcZBr7m1AAAAAAAAAAAADAw/b8N6G+67u+6wn93J/8yZ/s9VIAAAAAAAAAAAC4SOz5I9Sf/umf2tVXX22veMUrrNVqNdEmAAAAAAAAAAAAXOT2/BHqbW97m/3Gb/yG/Zf/8l/sR37kR+yf/JN/YjfffPOe6qyLidXF7qbVk5FfoCp1ZWNRxsxsY91NTjodWSRJE5nXPbDqph/+tp4sM9nakXn9a65w0+szJ2WZpL8k82Q/La3oIu22n/7Anf9/9v48WLP7ru99v2t8nmcPvXuQWlJLsixL8hTbmATMseWDBOH4OLaxCYEiBM61QyU+oqi4KlCGXBOgnGAbTCAHikq4cS4+VdwTEkgcOwmUMYMkJ3GkGMvGgDzIlqyp1d3qee9nP9Ma7h/tFkj7+/m2ntVLUrf6/apSlb1++zes3/D9/dZa3b1lnvwyv91nEkV5m8dllnahx7DeXPjVFENdXjXX5T32Vfd6ItptZpYE7WvGJ93r2cblMo+dOCSTitz/0LsYn9pZ9/ZY1wGzvDDzPpw3jf/zaRaXpWQiX6JjiWyDmQ0Sf/4eGAbr5IReX9Wh+/2EE0dlHjt9Utd10o+rbaXjdJL7fdRUuh+qiY6dqq56ptd+kup/nTYt/a2yDcap2BXtI35dzXwi80R1WdO6lzPRbjOzxVbUF/7cTER5aevXjzOSYmBJuXM+VINd7s8Xpd6/wlgj9vh0fa/MMjV9PplM1bhWMs9lu/VcGA78+zp50t/HzcxWV/X95oU/T8tCx2oVjiNRqK5qP3F1qNerCHdmZlaLbAvd5VaHf/7Lb9/pbT1Ol/vT0szMNid+A09u604S4Smkwl0UBmFWZmYDJ0zfcIU/6dJK7zkf/3O9f6itZX2k58En/kSv8xcf8PMdOa0nT7QuB7mfOAjWylRvibZv3S/vgcM6z951f7Le+5Du1+94tb7fP3vIL+8FG/rssj3TC0Zt29F6nekhtE2xX6zqo5BduVsP4uNi7C/bpe/39CTYf8yf683WTFw/LcuCWVXVli52njlScb5dOD/7dAxH/qJt1GZp8buaxdxvR+kFzq+bz/QGXIn7qiq90QfNs7L0841GUXn+Oa4KnqEKUY+Z2WLu328enK26qCq9Xtd36WCt7mvrtL+WzcxW1/R7nOnUv98k2mQCJ4777di7zz8Dl0UQJGFFrs8cno1VPa9OB2fV0cDPNyh0eSe39H40LP18G6t6Xa6NdF1HTvptV/WYxbFmPPUTg9c10ua27ofVYTAe4lXl1kSXp8bJzCwVN6zu1cxsNXjkTlO/rjzTbYjSlNPj6BwXtd2vazQQecQz63PhvH8n1Lvf/W6799577aMf/ahtbm7azTffbK95zWvs137t1+z0aQ5wAAAAAAAAAAAAl6Lz/gh11mtf+1r70Ic+ZI899pj9yI/8iP36r/+6HThwgA9RAAAAAAAAAAAAl6DePkKddc8999idd95pX/jCF+wVr3gFvycKAAAAAAAAAADgEtTLR6iDBw/a+9//fnvxi19s3/M932N79+61u+++2+666y4bjfTvGwAAAAAAAAAAAMDz0xK/5s33pje9yW6//XZ7wxveYL/wC79gb37zmy3Pz7tYAAAAAAAAAAAAXMTO+2vRxz/+cbvqqqvsoYcesve+97323ve+1/25e+655+kXur1tlrQ7r7eN//NpcBvbWzKpHo/d69ll+2We0XXXyrT5ocN+ecNS5hleeblMa6vKvZ7s1Xls85ROK0Q7FnOZJR2tu9ebzeMyT1svZFp96Gvu9aQcyDxJpvvPUv8v8y0euldmyfZdrYtb3+tebxdTmWc22CfTBhuqIv2XENPV3TKtGZ98+uUFdcDOxJPGiSnetbM/rwxXdFol1sNMj0/1+MMyrZlsLldPlMfM2tnETxityjxRXZnqi7Fug5IEczgb6H/qtRL/DGw10eu4msxkWjP3Y3EkzTKZ1rbO/mZm5YaOdYPdu2Ta7KT/uxezgS4vLfS+qfK1jd/uVFzH12WFmbOPpYn4+aA7sw29/08qf87VwfiMZzqubU78fBtBuDupj1yWZ355e/fotbw91W3PRAcO9XHCsnT5uarabWY2KPw0dd3MrKrVwJvtWvHzZR238yL3y1tUug2NiE+RiT5GhkeRgQhD/ukc5/LIsdZWZjvH77rL/THNs6Es6wWX69hQiO3twcdrmWffup4Ijx732zcq9Tzd3NZpRzf9tl+7T+/Lp0W8M9Ox8MUHdBsOn/LTrtyr++jEli5vOvfTVNvMzPat6/JObPn5jgVHNRWfzPR+tqWPXZYkeo791ev94HDvI7r/rt6r51iT+/8yS5b6cyLtcO67lLRt655lVbwXrzTMTO/lkUWt5+JIbSxmNp/5DZlOdQOrhZ5zw5F/fplOdHlZpu83EX0xm+o2qDyRqA157qdF9dTBeKhnh6LU63WyrZ8zU3EgKoJxn810/w0GfgyIHm2i8di9199XT530nzNnU/38CbMyb610ztQzMUWiM/ZkptM2Vv396PAJfW6I9vNjp/15Op5G+7JeEwf2+XU98rhu375deo/dDvpCSUSW6Jwf3e/lu/1FdnpbF1gGr/2vvszvo/sf05nqRrdvfeS3b7bQeU4HZ9OrxHyJ2hA9T6o5q551tzM9X59t5/0R6md+5mf6aAcAAAAAAAAAAACeR/gIBQAAAAAAAAAAgN7x73UBAAAAAAAAAACgd3yEAgAAAAAAAAAAQO/4CAUAAAAAAAAAAIDe8REKAAAAAAAAAAAAvcv7Kmg6ndpwOOynsGputsh2Xk+da2ZmSaPLWlmTSel4U9S/0OU1uq7y6gN+wnwm87RVJdOSlVXdDmW0otNUeapfzaw5fsRPCPqoPn5It0Hkqw49oPMk+ltpfsV17vW21u1rNo/pulQThkG/RvkKf000W6dknjSoK9tzpXt98ciXdlxro3kMs7Y9899TDUf+zwfz0DK9hmRao9d+u3VSptUTEbca517OyoNQP932r4+3gjwTnTabupfrTV1ePZsvdd3MrJrouCrrCfIUu3S8zUcD93qS63Gvxn4/mJmlpT8e06MnZZ4kTWRaucvf55qFnmNNG8w/MZfauhbXgz0Ylg5X3Lju96bZ6UUhy1pvxfo3s1m77l6PQsNELzE7vuVnLHM9F0cDXVklbjhJggYGf1ZqLqZwkevyBoWY21ETAqWoK9FdJNsQtSNaYlmwNal80ZxYqIlpZml0Y8J0risbT/20SjRQXccZ33B9ZuvrO/clseXYI8f0xLrxCr2/Hd/y822s6Ml4alvXVYj2/bUX6Vj4+Qf1HrY69NuRBmvl0Ek9t9Qa25zoPJfv8tfK46d1nsdO6LRvutFvxAOHu+2/ailftUev8SI46j563L8+KsNWyJR7HvAD0VBPCbtsXQ/wg0f98vbv8gvcqoKKIE0mfj+XpR6b6Gl1NvPLW1vXE2s6Dd6tiLN0GZyxgyTLc/++2uBQkQUFFqW/yKLyVB/Vtc4TvM7qJOojdU9R+5JMF5iJtOCVmuWFnn+1OFcMh/rZWY17lLZ3n/9OaBodxGFHj9c2nO6c4y+4yu/n6Lz8gv36gHvstF9elup5Op3rearW2NpIl7cdvNp49Ki/jq6+TN9TdGS+aq+IG0H/jad+H62PdKYjJ/XBYfean29eLf8saWb2wCF/zUbPSSc2l3/OXB0GZ78N3RePHff7QvWDmdm+XTpNneMeP+XXM90ODnHPst4+Qu3evdte85rX2C233GK33nqrve51r7PRSLzMBQAAAAAAAAAAwPNab/8c3x/8wR/YG9/4Rrv77rvtbW97m+3Zs8de//rX20/+5E/a7//+7/dVDQAAAAAAAAAAAC4CvX2Eev3rX2/vec977BOf+ISdPHnSbr/9drvxxhvtgx/8oL3xjW/sqxoAAAAAAAAAAABcBHr75/jMzL785S/bHXfc8cR/s9nM3vKWt9itt97aZzUAAAAAAAAAAAC4wPX2Eerqq6+2yWRit956q9166632Ez/xE/aqV73Kkg6/xBgAAAAAAAAAAAAXt97+Ob7LL7/ctre37dChQ3bo0CE7fPiwTSaTvooHAAAAAAAAAADARaS3vwn1uc99zk6ePGmf/OQn7c4777T3vOc9du+999qrX/1q+7Zv+zZ73/ve9/QLSzKzNNt5fWXV//lTJ3RZTf306z2rHOi0ybZOG46Wriq58lqduL3pX88LnefxUzpNtW9NtzvZtce9nq7tlnnqYwd1G8rSL299r8ySrm7ItGbzuMizW7ch0IxP+tePPizzDK55iUxbPHa/ez0JxrCOxlfx5nmXuX8paZoz/z1V2/o/Xy+61+NJgz8DkMx02kDEpyQobzbVaa1oX+bE4LMKfx1HsmBeZ+pvzAbtrja3ZFpb+3N/vqnjd5rr+11M/PFoZ3pOVBPd9tyGMk1pFpVMa8UcS1L9N5HTaHyFYm3Fv17Mly7rUtLmpbX5zjVz4rQfa8pgCxin6zJtMhGxK3BiS6x/M5tXfnnjma6nbXUcykTSvNLzdDTQdakQquox0+E9qidS1X7bE1WRmc1FHjOzPPPzrQbtC6qyWgzvoNCZ1JYVibYz1QYzs4U4ppS530cLcR1nPHikttXtnZ063vAHKIo1f/Kg3nOu2uOXd2q7w+Qxs62JX95n7tdtqJrl1+xsofNcvVfPrSifcnLs5xkEfZ6lup6J2Gbnuovsmn16YT5yzB+r3au6H774qB5fFXf3runyHjgik+ybb/QLfPiofrY5PdXtu3b7Xvf65sor3OvBkQtmNtueWlPvnMxXHvDPKAsV7M1svtDjps6x47E+f7dBbMgLf17VQZ40OFQ0YoObjPW5eGVNv2eabPv3NZ/r/lNtiP41osVC31Ndq+dg3UfR88Zs5rc9y7rt59OJX15RLv9cE7WjqoJ4F7Rd5Tt+zJ8T8yl/aD9SDjIrBzvHVq3Z6Hz75Uf0q++VoZ9PnfPNzE5sLn+en86DZ54yiEMi26lxt79TotoXPZOtij46clKvvfUVvY5ObvX292HMTI999A+zqXsyi8dK2ZzoPFft9WNX0+o8XZ7x1D2lQQx/tvX6O6F2795tb33rW+3mm2+2173udfaxj33MfvM3f9Puvvvu5T5CAQAAAAAAAAAA4KLW20eoj3zkI3bHHXfYHXfcYffee6/t3bvXXv/619sv/uIv2i233NJXNQAAAAAAAAAAALgI9PYR6rbbbrNv/dZvtXe+8512yy232Ctf+cq+igYAAAAAAAAAAMBFprePUEeOBP+wMwAAAAAAAAAAAC4pvf5OqLqu7aMf/ah94QtfMDOzl7/85fa2t73Nsg6/AB0AAAAAAAAAAAAXr94+Qn3lK1+xN73pTfboo4/aS17yEjMz+8AHPmDXXnut/c7v/I7dcMMNT7+w6dgsbXZen0/9n19Z12VtnZJJyXDFT0iDj2at066z6nq562Zm25tB2ti/nqY6z8qqTquq5eoxszYv3OtN0A/ZvgO6PDGGSRLcU7WQSfWxg+71ZqzHPV3dkGmtqCsR/WBmVj16n0xLxNxsp9syT3HNS2Ra/fgj7vVm6+TOa2NdB8zaxcLafOe8S0YiLnT9mK7W63yu80R1LWb+9WKg8wTzTdcTtG8mYrGZWVH614N13EwmfhM2dbvbRsegeua3XV0/Q7TbzLKR37f1RIyFmRXrYh6ZWSLmRLE6knksSZYuL+qjtNTbf+KsCzOzRuxl6jrOSKy1xNod12Vo0EvF6nZnOWc1ImlW6TxloeeVMip1njTRcy7P/Hxtq8urgqml+i+Y9nIZFbnuozToork4VkV5ajVQptsXlRcdn9R9RX0+0Mcd2/RDtY10+LRxtF0sua2KKYSv27WS2Nrqzk66aeVx9+fnq1fKsh45qgPRFx/1J35V6wG6+aV6z/nvX/TLix539ox04omxHwRecrluw1cPLb+PvfRqPYE/9zW/vH3ruo8mwRHl0IkgsMnydKzZnvnt+NwDOs8LLo/a7ud70J96Zma2MtB1Hd/y7zfqo+t36WBTTf35sif1n8MzcR1nDFaGVg6GO6634owym+r1lQWBva7FHhbso9VC11WU/pptar2+BiO9zsdbfpwcjoKNNJCIzX51TW+yso+C82KkFn2xsqLvKS90PFZ9VHUcQ9UX84UewzJon6L69Vxpk23/fgtx3m4qDjaRqmqsqnaObZEv32/DUo/b1kSsvaHO0/XZQQmWhGxfWehMu1aWf95Q9ZiZzRd+2vqKXnub23rt7V7z8w2Ce9qa6PKOnfTzjYLz4iiYE3nmp0VjG52DHzvu7yXROI2nev/ZWF3+XHihWD4iC+9617vshhtusIcfftjuueceu+eee+yhhx6y66+/3t71rnf1VQ0AAAAAAAAAAAAuAr39Tag777zT7rrrLtu7d+8T1/bt22c/93M/ZzfffHNf1QAAAAAAAAAAAOAi0NvfhBoMBra5ufOvrm9tbVlZBv9OBwAAAAAAAAAAAJ53evsI9Za3vMXe+c532t13321t21rbtnbXXXfZbbfdZm9961v7qgYAAAAAAAAAAAAXgd4+Qv3Kr/yK3XDDDfba177WhsOhDYdDu/nmm+3GG2+0X/7lX+6rGgAAAAAAAAAAAFwEevudULt377aPfexjdt9999kXv/hFMzN72cteZjfeeGNfVQAAAAAAAAAAAOAi0dtHqLNuuukmu+mmm86vkKI8899Tra77P3/0kC5L5TEzO3bEvz4Y6jynjuu0LPOv50E3N61OS8VfVNu1R+dZzHXaaNW/nhc6z/bYvdwGeepKj0c68NvQNDt/n9gTeVLRr2aWjPzxTYfiXs0syXTb2/nUv17JLJau7pZpi6/9mXs933+dznP/n8i0djHzy7vihTuvbW3JchDYPOVfH63oPEmi06rFctfNzIZBXcpYryFrG51W1/71KJYEa1KV16p6zCwRsbNY1/3QNvqesqH/ewjrqb6nZqEXeVv5bc8G+vcdVhN/rZqZpYOg/1SeXOdRbe/avnzk74H1LJgTkGaLxGaLnTFiMvfncBqEk/FMnxnUkWESDNt4qstTdRXB9J1XuvF146cNCt2GqtblZamfb9GhDWKJm5lZsPRsOvfLU20z0+NkZqbCWtvqe4r6LxF7Uxa0Ic90XWnqN/DEVnCWDai+VXNvVnWr51Jxeru12pl7B9f2uz//lfv0OWTXSM+DoVhHjxzTbTu6qffsDbHVj8poLuq6RoWf79S2bkMVPI/tWfUr++ohHThecJmfJ2rD5kQmybi7PtJ5Hjuh7+nyXaIN/mOQmZkNcj0eR0/71y/bpdtw9LQuT+1b11+hB/5zjw1k2jfsvdy9Xp847F/f5Bkq0jaNew6vKn9+j1b0s/eJ43rSleK8rOoxMxsM9XuXTOxvZanz1LWew4u5f/7OV/X5OzrjVaIutZebmVXiAJPneq0s5jp2ZeKAMJ3qPHkwHnXtp6l6zMyGwXyZL4Jn2g55Vlf9urJMj/sgeI5Tc7NtOb90sXcjtZGzB6tH+tWh7mf1DBDli54BoroePOTP7/17dJ5T4+X/kbL1kS5va6Lvd2PVn6dFrstTUzh6VoueUdTzmvfMfNaeNb2WC3FG2QrOVnmwzifiGS/6t+RUv5qZDcWZdi0Yw+D1lK0M/HyHjvv1TKfB5vMsO6+PUD/6oz/6tH/2l37pl86nKgAAAAAAAAAAAFxEzusj1Gc/+9mn9XPRn94AAAAAAAAAAADA8895fYS6/fbb+2oHAAAAAAAAAAAAnkeW/4cnn+L+++/n3zgFAAAAAAAAAADAk5z3R6ibbrrJHn/88Sf+//d93/fZ4cP+L/kEAAAAAAAAAADApeG8P0I99W9B/e7v/q6Nx+PzLRYAAAAAAAAAAAAXsfP6nVDPmMm2WdI8/Z8vym71JIl/va50nizTaXXtX5/PgzZ0+A7YiHrMzAZDnVYt/Otbp3We4ci/vh18aAz6qGnEuM5mujyVx8zayaZ/PS9knnR1Q9c123YvJ0F5zfikTMsuv9a93tZiLMwsHa3LtGXqyQZ+3+Dr2ubMf081XPV/PpgDobxDmF0E62E29a9nQT0q1pmZpSIGBesuKq9d+PGuXQRxVWjmep3UM52WpH77mqANaRTbi563StG+JIqdlY77qWhfkuvyVB4z3RetuB72Haxpz/z3VAsxpFlwLFDL1cxsIo4a80W3fzJ575o/T8dTXd56cAQpcz+m1I2OJ0Wu61JhKAp3WeqXF+fRacNy+b6NyvPmiZnZoND1iHByJk3cb1UHmQK5qCxqQ7R1Nq2fUYW7umO7LxVrw8TWRjv7aHXg99srr9X7wNFNfQZ4+Jg/QNfs05P71FjP4dWh377HTug8V2zoubCxunzsms6DuSWOhZviOGZmNhEB/uSW7qPr9uvylM2JHqc10a9mZmUh1l4wTpsTnaZjlG5DFD9ffJU/N4+c0vc7KnVd6cbl7vWvzfa51zeL4NkYVi9qq9Kdc3xl1Q/404k+ww6H+gw5m/n5ilLnyXO9xhZiXSZJt3Ps2vrAva72cjOz+ULP4V27/Hda47F+5mlFZYu57vNKHUDNLBPPDmkWrK/gYLO65penxtbMrK51Bw6HfmzYDvpotKL3OtW3ZaHvqRLn2chCnMWril9rEkkT/4xZiueD6Hw7Guhx29z2x/uKPXqeRueG3eJ13tZEz6t9u3T7VF11MBWjOHRCnEVacS43M8szv8CoH9Q4mZltTfx8L7xSv69R42RmNpn55Z3e0mOYB7FL3dfVl+nyxlPdF4tKpUXnY512+IQfW9V5rAnG4tl23n8TKkkSS57y9P7U/w8AAAAAAAAAAIBLy3n/8e62be0d73iHDQZn/iTIdDq12267zVZXn/zHxj7ykY+cb1UAAAAAAAAAAAC4SJz3R6i3v/3tT/r/P/iDP3i+RQIAAAAAAAAAAOAid94foT784Q/30Q4AAAAAAAAAAAA8j5z374QCAAAAAAAAAAAAnuq8/ybUM6IozIpy5/W0wzez0apMaqcPudeTzVO6vCRog6qrWug8pXOfZ83n/vXtsc6TZTotL/zraaLztK1/val1nuieZjNRXiWzJMMVmZav7/WLm2zKPIsH/lym2Wjkt6EYyiyZaIOZWXXoa35C3m3pZXsPuNebU4/vvLa51amOS1078ddXotaCmVnT6DS1HqYTnScJ1mQt1l45WD5PZKDnfBjTohgps/j32yx0XEjLYA2J8UiLbuuu7dB/bTQnRFJUT1ReMvTnWFvp8uqZ2F/MrBHtUH2eRvcK2562lpU748e88mPK6kCv/zSIDUXml7cZhJr5Iohr5teVZ7oNTRAnG5EUhda21XUliZ8xOtKIW7I8ODqpeszMMlFZnEfXVavYEPTRahCqT2777RsUusBT2zptUfnlnQzyFEHfLkSIysVczsR1nHHN3szWd+3s8FEZLQrfFw/2G9cfPb78mjiwV7d7PNXlXbnHL/DIKX1Pa8Ogrplf12yh80xmftr+3cvHXDOzwyf9fNfs0wHlwZ2PBk9Q+0V0tIoew2+40l/oR07p+90K9qZPfck//738Wt2IaO9cPPIl9/rVV7zUvX46ep6GZUVmuRPct8f+80ESnF0GQ93XtTg4TMb6DLu+oTfFuvbLGwbrP3oEqMXmPJ/pTOu79HuSrU3/vuZzXd7Kiv9+p6p0vMsyvdBTEZC3t8Q7HDNro8BR+uObBWfJwUDPiZno20XwXDMM5lgr5thwpO+pEPdkpu+rrv21kQb9ALPtWWKN00drI39+R+flrYket91rfnnHN/WeEz1vDJ3nPjOzlYFuoDo3mJntWffb9+hRfU/R4/nayG/Htl7mNhCvkq++TMenQ8f77fPomUL1+d4NXd6uFd1JuYiF0T1FyuDZSxlP9Zy4cq/f72oebWcXzvsa/iYUAAAAAAAAAAAAesdHKAAAAAAAAAAAAPSOj1AAAAAAAAAAAADoHR+hAAAAAAAAAAAA0Ds+QgEAAAAAAAAAAKB3fIQCAAAAAAAAAABA7/LnugGu6dT/PJYXvVaTrK77CXsu05lOHlu+ovXdOm24snx5i5lOq2udlopvjnkwDWairtGqzhO0LxF90Ta63c34lC6vmPrlBW3I9l8j0+pTj/v1BHMvqsuyzL8+GcssyZW6b9uFf7/u2uh5vTzfNLO5NWmy43p22X4/w0z0vZlZMH+tqvzryc66/yIt+PMBYkrZYqHzRGrRviCWtOqe7Ey/uteD9iVqnQSq8USmZYPSvd4G96TymJk1TetfD8pLy+XXX9b69ZiZ5aOBTKunfp+nwT110cz9cW8Wej7gzDaQO1O8zP0Y4ISlJwyC7boS07EIlleR6coWoryoDVnQ+C0RQves6TwntvSaSFM/bXdwrKpFcUE32La/vM7kSxv3uggZZmbWtrqyUYclq452ZmalGKtojuVBZ6zqMNTJ6sCvayyOVVHbYHboVGNbzc45+coD/mI+PNaLeVQu39fHg/W6O3hsWB/5dV25W0/uBx/3156Z2USs2St362B46KTez0+c9tuxNoru17+nk/r4b1Wt7+lFV/htv/dh3Ya967q8WsShKB6rs5CZ2Zce9eu6Zp8ewyTR5V2912/H5kTnGYg91cys3d5cqrytoB6YZXluWbEzfuS5P95ppufByRP6+SoRz0rDFX3Grio978vCb8d4rJ9R1D1F8mAuTraD5yGxOQ9H+n6nUz92lQMd77rc02hVH1DaIDbMZ8u3T417lDZY0QeUaE5k4lyxva2fbQbqMGm6bwfqfpvln4EvJfNFa+liZ3+fGvv9fOVevZcfyHXaya1+/27G9kzM0+D1wOpQz9NHj/rzZHWo52L0eD5b+O27Kug/71nWzOzwCd13w1K3T/VR0+j1r579zMzUNhO9cnv8lF5/6lkpuqc9wblrc9sv8NRYNzDYOmWaeh+grj8X+JtQAAAAAAAAAAAA6B0foQAAAAAAAAAAANA7PkIBAAAAAAAAAACgd3yEAgAAAAAAAAAAQO/4CAUAAAAAAAAAAIDe8REKAAAAAAAAAAAAvcuf6wa40vTMf081XPF/vlroso4d0WlF6V8//KjM0laVTEtW1/2EyVi3oW2DtEan9Wk202m5mCLRPa1vyKR2vOUnZJnOo2uyJCv8PLOJzrS+VyZl+w641+tHv6rbsLZL1zXeFBXp+60e+bJMK17wUvd6Mz6689pWMEawJE0t8eLMdNvPEK3VJFm+AUF5bTUPqhJ1lUE4j2JkquZirfME0tHAvx61r4MkD2JG5bc9SfSfu2gbPR71TI+HLk/Hb3feWTC2ZlZPdRuahb8vpYXuc5XHzCxJ/XZEsRjadN5aMd/Ze6e2l9/jR6WeI+OpP0ITp+6zgmnqHsPMzNJgnmbBH23KUtU+nScKrW3rJy6C0BWl6Tbo/lN9MdfLy+qgz1VdYkmamVnT6MSBf0Sy8VTnCUKrnC8bq7q8U2Pdf1MxN1U90XyF2SPHGluZ7eykv7LXP9eMZ+K5xczKXI/pNfv8hf75B/XEL3MdHFQMOHJKzx01t810LFTzzczs+KZu37D08734gM7zwGF/sr7oCp3nq4f0BD9yyk+7/go9TtP58utc9Z2Z2epQl7c68PONZ7q8/+XFui+u3uXPpa+d0OeaQTBn043L3eu1OIur6zhjMZub2c6FW1VD9+fTIHZH5++2w8lzMNKb2Pa2OC8He2y4/4rmpcFhaD7TB5GN3X5gm0x0nlzM+yY4bEyr5TfTqB/yIL7Xtd/2KmhDVN7Kih8DTp7Q77Oq4PAwHPl9Xpa6DWvregNazP26VLvT5MJ8HXuhGA0TGzl7z4F9/loOwomdGi+/zzfiWcPMbHWoK1OP2dEZe7bQda2IPTba56PnjcnET4zO8weP+f23vtLtcK7OmcNSlxfd06Dw++j0th73aAzL3E/bnOg+msy6zRclul9V3tcO+5NsEvTDs+3CaQkAAAAAAAAAAACeN/gIBQAAAAAAAAAAgN7xEQoAAAAAAAAAAAC94yMUAAAAAAAAAAAAesdHKAAAAAAAAAAAAPQuf64b4KkfP2z1aLDjepYkfoai1IVddqVOO/G4f/2qa2WWZOu0Lm91zb+eZTrPYqbTdu8TjQi+HUbtK0U/DYYyS7q+173ebB7v1oa1Xe7lpNRtiO63OX3MzzJa1XmCtme7LnOvp3v2yzyW6valV+92r9eHH5J5kuFIpjXjU+714vpv2HntdDAOsLaura3qnQmZHxbb7bEsK8l1KG2rSiQ0YftkeXXrtyGYh/VYtz0d+HGhmc1lnqiuZrJwr7et3+5Qo/uonvr1mJml5fJbW5KK/cXMMtFHkTYY32rix/1qPJF58lUdFyxou5IE+1K5y9/LmtpZL2ZWTIN9DLaxmtqu1Z1r5uimvyaC5RVS+VYHen5M5suvy2mQJ2r7qPTbsfCnlZmZJUlQl7itRa3vtxDTfqLDnTWtLm8hktRx1Sxerq2oK9hiLA+OmLOZ339Z0IjxVJc3KPzyDp3U47THmftnNSLbQuxziF25O7G19Z1j2042RY51Wdb+DT1HNif++Fy2rsf6yGm9JzaNX9d4qufBKNiWV4d+edFa3r2m27cuyvvyQZ1HHXmOBv3wkqt1/x064edTcdXM7NS2risVMSCKhaNSj8e+XctvXI8e1+0b5IV7fTzTea6efEGmZftf6F5vxLErOH7CzNIstSx7+mOeZcufU83MhiN/85tOxLOVmW1t6ueDolx+ntZqozKzVqTlua6nHOhNezb1D0RReQsRbKJ9vqqC2CDGtUueM/x7KgudJ3pm3N72x359l94UujyDrq76McjMbCTmpZlZVfnzb77w+28hruOMImutyHeO3/FNf/7sWtFjnWc6zXslZKbPvWZmk1nwvOG02cxsrkOXPAtF7bhsQz9EqT4yM1sRz4Zb+lWE7V3352rUr6e3ozYs30dRqNkW46HqORc1J6I2RH1Ri6U+Uw+TZvbK63R5X3jEb4hqX8dt+BnB34QCAAAAAAAAAABA7/gIBQAAAAAAAAAAgN7xEQoAAAAAAAAAAAC94yMUAAAAAAAAAAAAesdHKAAAAAAAAAAAAPSOj1AAAAAAAAAAAADoXf5cN8CTDkpLB+WO64uHHnR/vrj6Gl3Y1mmdtrLqX08SnaeudNp0IupZ13nm0yBtrtOUYme/nVOiv0W2s20/YaH7Idm9T5fX1KIe0XdmlgxGMk3WE417cL+26zL3crq6IbM0k03dDnG/yYbuI2sbmVRvHvOv/7eP7Lg23dZ9Cq3dHrvXk8FA5qm3tmRaOhy615uZXt/ZKJjzYvq21UJnKQqZluR+Wtc/oZBU/pzPRrr/msnML8vZB86K7qlZ+H2Rreg2WKPXnaX+npDmmcxSiXsyM0szP18irpuZJcG+VM/9eJyt6j6qJnrvUW1vxdg20w571SVke9paVrY7rjftzmtmZuMgdF+2rufBIPfTxjO/HjOz9ZFe6VXt5yuL4IwUUEtsMtftGwSn1NWh3w4xTc3MrBZtGDnjc9bmVKeVos+7ykRxYijMzGwWHEvVnAhClxx3M7NGJIkQaWZm02B8UzH9CtE+dR1n7F5LbX1tZ6cmpb/3XT/Q+8ADp/2zi5nZjZf5i+yzD3c7ObzqOn9gDwz12Wpe7JJpd9/nnwFefb0OKEc39SR+kf9oYPcflVmsEIv59ESvB1XPGX7fHj2ty7vhSr1gHjjsB8OXXq3HcHWg++jgCb+86y7TbajXddsvW/HH8NETun3pip4Tsy98yr1+5Tf+b+71lYw/pxspytIK54x+1dVr7s+fPKHPxMORXpeZWEdRnsj2tr9hDgZ6nua5ngvTabABC2Wpy1NnfbVXmpnNxRmvCZ4bonsarfjPDpNt/ZypxsnMbHXNL28+189dqTpsBHV16VczPSdmM32YLMpovvh1zUV5i3lwaIVN54mZ06f/68v9OfJ5/3WxmZkNg7O+CvmHT+ixPrBPj9146s+DQaHb0IrnQjOz2cIv75p9em7PFtH9+ml5FrVPPVPoPHmm17nqo7m4VzOzjVVdXlUv3+eRV1znX3/4qG7DdK7bPq/8tMs3gj7SW6ddsVvdlz+Zo7j6bOOEBQAAAAAAAAAAgN7xEQoAAAAAAAAAAAC94yMUAAAAAAAAAAAAesdHKAAAAAAAAAAAAPSOj1AAAAAAAAAAAADoHR+hAAAAAAAAAAAA0Lv8uW6AJykKS4pyx/W0KNyfbzdP6rKuuFpXNJ/716cTmaUdb+m6VEJQnpUDnbYQ7VvfrfNMt3Va2/rXC92GZNe6X9SxI7qacufYPVGeM65mZslgVeZpTh+TaZb7cyK78oUySzsdy7TqyIPu9WTk94OZWToM2j7ZXLoNg5e9TqbNvvAp93p+46t3XtvScxVmbdNY2zRP++froD/TwfJzPm2fft1/WSvWcVIOdaZU/3mDdtufi21dyzzNfKHLE/mSPNPliTztTMRAM2sbEc/MLB/5MU3VY2ZWT/U9ZStBnBbSLLhfVc8wmEfBGBbrK0vnSYPxWGz6cyIfBXMM0qRqLV/snK8zMeWaYG6PZ7qePPNPIcNSnk7s1FjHIdWM8Uy3r4soDC/0krWq9tuxPtL3e1q0XXTd1+vRiepYFZlXy+cZFLqiqH155ueL8gwLnbYqQuH+DR1r1Lw003NJjW3WBAMFO3KqsXG9c0FdcfKP3Z+PzpvzhY73beMvzJed/m8yz/U3fptM28j8Z5cHTuvz9d5VvSZefo3/eLs6PSzzHGkul2nHt/35fe2+YG5P/fblwR//fOyUTlNrYnWo27A5ifrIPwNcta4D1MmZ/8xlZnblbv/GLtsls9ijx3XaVuXX9VfK+2WeRm2qZpZdfq17/dAJfwPaPN3tjH6pqKrK0sXOubK9pcdASRI9h8uBv5bnMz1PVZ6orqrS450Fe9hwuPyrtKiuUpzX8iBwrK37zw7b27qPVtf0Wp7P/fblRbDPB+2bTv12rK7qNsR95NdVixhpZjaL5osoryj1c1Lt7LNnNaId6p6ie4VZlpl5j6xffszvt+BR2q7eq9fyYyf8cbtyr34QqYJnlNHAL297qttQ5HoOZ2KJ/flD0TOATOr0fPDC/f71Bx+PziE6bc+a34bda3pNTGa6vJWhX95W0IZdK7rPv/CwStHlrY2C91PBeCjR89VRcU45NfbbN9m+cJ6h+JtQAAAAAAAAAAAA6B0foQAAAAAAAAAAANA7PkIBAAAAAAAAAACgd3yEAgAAAAAAAAAAQO/4CAUAAAAAAAAAAIDe5c91AzzJ9/yEJbt27bie/fd/42c48pgubLS6fAOGI5mUZJnOt2+/f/30SZ1nZfn2JeVQJ+65TCa107GfUNcyT7N53E8Y6DakKzvH7onyjvpj1XboBzOzZOCPlWy3mSXFQKcN/XZEfZ4MVmSa+sqbXnaNzDO779MyTSmuecnOa6dPL13OpSR/wQstX3Hmz7Ej7s9HX+yb2VymJYvKvd42jcyTFoWua7Hw65kHbShLmWYqpgVxIS11++qJn68O+qhvqo8iSR7EdjFWTaXH0NJEJ6X+1psW3bbkVoxVkuhZO9i7IdPykY6Rbj2Nnisw2562lhbtjuurQ3+ODHI9dyKpGO7Nyc66z9UGM7OJWLJVrcsbz3TaqPDrCoqzptWJi9ov79BJnacRSXWwlAfO2J1ViTZEglvqZEMfQaxp/PatrgfxKbilUSnKG+hMRabTdq/4aZtTv5OKlj87FzlysrWVamffjV/yN9yfH9gpWdbJ7WAd5f7Z+3/k/6vMM7vPPwuZmb34gH/Gngdb+Zcf0/vOVXv8efLHD++Tef6Xm/TcOnLaDxB/9pAOHDNnHMzM1ke6nsuCdfmnD/rlRfFpl36ctU1xVvvqYd2GjRV9v5sTP+2rh3Qbrr9Cn7u+ethv32R+ncwT7U3rI/++jjzsz8vxlp6v0B5/fOJeL0s976vgLD2d+OMwm+n1P5/r8sZb/sFmONLPNceP+fdkZlaW/hyug7mYBJtskvhpk8nyzzVtcNiYiPVvZtaIA1E0TlGfq3acOjWTeYZD/Tyk2h7dbzRflFMnt2Xa+i79XK366fQJv7z5TLyfg5mZFVlrRb5zbA+f8Nfe3nU9F//kAR2HVL5Dx/U+NRrougqRbTTQ8/Tk1vJn3Olcx5M9QV9sT8WeeEK34dTYb/vx4JXjy67Ta+/gMb+TsqAbhqXuv1NiKUXPag8d0ZV5887M7Io9ul8fC+ZLJbpiJZgTqs/NzBrxTDQRYzsV158LPM0BAAAAAAAAAACgd3yEAgAAAAAAAAAAQO/4CAUAAAAAAAAAAIDe8REKAAAAAAAAAAAAveMjFAAAAAAAAAAAAHqXP9cN+MvatjUzs83N0376eNvPuD3VhQ4nOm0q0mqdxWZBeUPVviBPmwSV+ZJFoxPTTFc1Fe2rgxsuKv/6VPd5WoxlWjMWfRH1Q7WQSUmHKZzk4p7MrK3mfp5FK/OktW57K+ZL2uhxWqh5bib7YnF655o5vbl5pg2tbvul6Ik4o+LGZObnq/S8aRbBHE39b/1to9dxWuk0VZeqx8wsqZefA+3cXwvnUk/9/rOgfbINlY5NbRQG8+XjalMFa1yUF+WxYHz71ooYniS6z5sg7mdLdt/m9MxcIdY82dn+2NryzzRqWS46nszUcG9Nuo3LVIS1Kogn45lOawp/YkXhKaorTfzyFjpUWyOKq4PlWhW6DXWw/8vyojOmqqcMOmmh26DCUBvkSYNbqks/Ma10piIIKJk4Cm2JebT19ecDYs2Tne2P7fGmm7552g8qeerHJjOz8ZZeFKdFeeMtfRaa6yTb3PSDV3C0svFUz4HN3C9ve0svPnVPZmZbm35fRH00E+eDtNb78tD0Wtke++XVue6HLIg1HY5klgVtH0/9voji3eaKfhbaEn2r9qUzdem+SESMUmN4di0Ra57sbH8sZltu+nzqPzu0wdxZBO81arGW57PgDBvsOXMxgdJEr//5NDpU+HO4juZisMmm5pdXBc+FSjR1o/FoxIGoip6Tgj5X7Yj6SPVDJFqr85nuv6QVc2yq59isLGRaLcZqLt4JnV1LxJonO9sf0219TvFsp3qsJ2M971W+yXYwF4N1WYlsbbCOovYp0+A8Pwj6Qr1HmW7rNkxSv+3qFbNZfO6ajP1OyoJuaIJ3suqcWQXPatO5TqvE+Wq77DbH1HRJgjlRB8+gjXh/rsbw7Fq6EGLNBfURavPrL81ffMMLnuOWAM8fm5ubtrGx8Vw344JxNs685O//1HPcEuD5hVjzZGdjzbe/5vrnuCXA8wux5snOxpq//9YXPcctAZ5fiDVPdjbW/Idf/mvPcUuA5xdizZOdjTX/6Adf+Nw2BHieuRBiTdJeCJ/Cvq5pGjt48KCtr69bIv6EK4Cnp21b29zctAMHDlja5Y88Pk8RZ4B+EWt8xBqgX8QaH7EG6BexxkesAfpFrPERa4B+XUix5oL6CAUAAAAAAAAAAIDnBz63AwAAAAAAAAAAoHd8hAIAAAAAAAAAAEDv+AgFAAAAAAAAAACA3vERCgAAAAAAAAAAAL3jIxQAAAAAAAAAAAB6x0coAAAAAAAAAAAA9C5/rhvwlzVNYwcPHrT19XVLkuS5bg5wUWvb1jY3N+3AgQOWpnxvPos4A/SLWOMj1gD9Itb4iDVAv4g1PmIN0C9ijY9YA/TrQoo1F9RHqIMHD9q11177XDcDeF55+OGH7Zprrnmum3HBIM4AzwxizZMRa4BnBrHmyYg1wDODWPNkxBrgmUGseTJiDfDMuBBizQX1EWp9fd3MzB742kO2a9euHelpNXHzJWkmy6zTUqZlVrvXF60ur2lkkjWtfz0NPt5vTUQmMysK//p0HuTJdGWq7XWry+tSTxdFzzNxUOj25Xp4LTHRF8HAt9VcFyjytdVC56mDNDHXm8nmjmubW1t2/V+9+Yl1hTPO9sen/9532Vq5c5G1Ysya2o8XZmZpFsQMka+tdHlRXTqTXsdtmCbmaJAnrEs0PQnW3QUhCtRCVurA1QTjm6ogFLQhmmNKEgS7TG0wATUvt+YL+5YP/2dizVOc7Y/7H3jI1r0zTYdtNFqWarijc0sXURuCaW+1yBiGmqDtKkwual1gJZLqoJ6FymRmC9GGKmhDRN1v1eHs2bUd6p7MdPua4BzZNMtP9DT1y9seb9oP/u83EGue4mx//PJvP2CjlZ2x5q4/Pu3ma4L5ked63GYzfyIMR8HzWLQuxRpbW9N77HSqJ6qajlnwBz/LgW771lblXo/6b2V1+QebrU39PJGJxkePcE2H4J8Xuh+2T2/LtGLoP29nwdkl+sPttQjK0Z/eLQc6bWXFP/O84LpV9/p0+7T99DuuI9Y8xdn+eMdP/ZmVw519c+TRE26+Jthk6+CZJ+nwp7WzDoerYqDfFyUdykujYBPI8uXjRt9/oj0V73iibojOISpftCd0eDUVxru2Q4HRs3g0L+uFv1+sro/c6/PZpv2bn/8GYs1TnO2P/+u3/HPNH39u57svM7NTx/U+JZ+/Tb8PiXR5/xPNnXKgn81L8W4zik9qLZvpOBnFk7zw07KgnjzvEMOD+JkH73hbMYTR+h8OdcxNRDNUPWZmpd5K5HNr9NpPPTub6XP6tfv9AifjTfs/33b9BRFrLqiPUGf/quWuXbvERyh/YV7MH6GSQk8s5/24mZkVz8OPUMG73E4u7o9QQXnqI1TQf/wV5ic72x9rZWHrzmYvP0JVekOMDjUqXxts8k3d4YHiWfwI1UYPDuLlYdJzzOhbl/aFH6GC8b0gPkKpDSYQrQEzYs1Tne2PdXWm4SPUOcuL2q7qCj9CqXNQUM/8AvgIFX4YusA/QtUdPkJlYh85i1jzZGf7Y7Syy0arO2NNOfTzRS+GoxcHbeJPkjJ4mI9eOKZiYQ5Gep9qxDOcmX7hEL2cHgz1fjkXZ/boI1Q5XH6PLRczmXYhfIRazHRaKV7iZ8E5pP+PULouNZdGK/5HqLOINU92tj/K4bqVw52xphioD7bBH8wKDg6dPkJ1+ADU90eoLm0wM8s6/KlcPkJ9vQ3Ru5qogaq8jh+hqtRfA+XQ/wj1RJnEmic597nG768i2Aei/eiC+AgVnBtK8QEoik/RxyGVdiF8hIryXOgfoYKtRD639v0RamU1/sPsF0Ks4R8eBQAAAAAAAAAAQO/4CAUAAAAAAAAAAIDe8REKAAAAAAAAAAAAveMjFAAAAAAAAAAAAHq3/G8/fBak87Gl852/6C3JxS9rU9fNLLPoF0ov/4veo99rqH5x2Hi+dDVmpn95WfR782ZBAzv8Tkb5i84n826/dFv97rzoF2EPxC9dM9Ptmy2i9kXlibQ0+MW6efAb6BrxSwnVb4k2s3Y61mm1/8uR09XdO6/VfGOONHVtTbWzj1IxqdIgWnb5had9i9oQ/bLNZrH8L+JsO/yy+yhP9MvRu0g7/kJgJRFxoen4y5TVWHX55cdmZomYs+EvdA5+KaXKl4tfmJx3bPelIs/8vSoR55O60f0Z/mJosYzCaRCekcS8D5Zr1L5wWxbCM1eX31wtVFF86jc82czfxs/UJZrRdDzbRXXp8nSBam5GIbdLeG9bv55azEmc8enPbrq/rFvtsfO53sMm49nS9S/m/i9kN4t/EfJwxX+OG2/pCVxVy/+y5ipYLPW2TpO/wDuYjlXl97m6fi5qWVYL3eddzkLzaYegEbRjPtUPwYOVQW/1mJmlwS9HP3XKn89/8if+9fl0c7mGXWIefeCIFeX2jutdzrfRWTUV+aJ4EpXX9ZytZGKNpZl+b9AEv4U+FW2Pfo+8ik/RvWZBWpdH2ijStCJ4FUF8ip4L1X21wdk5uic1Z1v1ksni8SiH/n5WlH55bcP7mshn/mTLyuHOPjpxdMv9+WiPyIIxVWs2Wq9qbpuZZeqZudBtyHM9F9T8qYPnlyKoSynLfuejik+R4Ui3uwjeC6t1PtCfCkJqeHt+bRWqgvd0mXg//cjj/vXp9vLz4ZlC1AMAAAAAAAAAAEDv+AgFAAAAAAAAAACA3vERCgAAAAAAAAAAAL3jIxQAAAAAAAAAAAB6x0coAAAAAAAAAAAA9C5/rhvgScqhJeVwx/U2zZYvq5rLtKop3etpostb1K1Mmy+edrOeVnlW+5ebIMtC5IlkwafI8cyvLE10JxXBMKm2R19Dqw73lAYFRuWpsY/KCxMbNYi6EW3dYSLVzjzvUs4lJM0yS/OnH1PaYOG1TaPTukzgSBQAelTP+213G8S6KE1JMh2DGtPjoaRBFFJ1RXMiCcJCkvuJSRhogvJEvrTQW3xUV1r6+VR5WbRpwpKmtsSL+WIfCKNSh3NQuByCeaDCYxMMdxSeCrGOZgudqcvU6jtERuGpEolR2I/ap8oLtpiwfU0ryuvYR7VoR9vqgRJNCC1EPV3OuJeSum6tXmI/XVsfyLTpVMcatfdFY50Ge7ZqcxbkSRJdWS722EgSBJuoHYq+J92vg4FOqyp/UZQDPYaNWrAh3YY8OFM0IkilwR6j8piZZeLhNA8eMqMzmRKNO7Smbtz5pZ6HsrTfV05tFGzCeeW3I5oHSfDOIxXrOZqn0YsSFWvS6GWNEMXB6HEjul8lipHL7ElnpcFZdyHOjFG8q6PnNdFPUWjoEjdkfG86nOsvIZunZ1bOpjuuq3ka7VN1cDjPxENPE8ydoojWmJ8Wvk/qcGAuy27rXMWUPLgn9bw/HHWL74OBWHtBu4fl8s+M0dFgUOjEReUXGB2tojQ1VFUQT4pgv5hM/Moa8Uw2D563n238TSgAAAAAAAAAAAD0jo9QAAAAAAAAAAAA6B0foQAAAAAAAAAAANA7PkIBAAAAAAAAAACgd3yEAgAAAAAAAAAAQO/4CAUAAAAAAAAAAIDe5c91A1xNfea/p6rm7o8n5VCXlRcyqWz86/NKF5cmQZr4pNeIeqI8UTvqoLyqbnWi0ARZVNvTTOdZOEN3PiqL7skfkDLo12gMlWgMsw6fctv5dPlMZv66MPMHJBokWNs01joD24oFkea6P5sgZrTmj1nbLr9WI969nNUsdFo9F+0LYkmUJtsQBZougvLS2l/kSaYXf10vH7ii8tpU93nSLN++tNR7WVr4W3la6i0+K4LyRL5U5MkS/jxLF62K54EO21csaEMi9pA02FuimaBCVBBaw/NJlvi90SQ6kzqfdA1P6p6ic1oUC2V5Qfuic5+qqhExyCxuuxJsMaFKxGr580G7YbaYN5akOyd5Ig6+81lweOkgz/X4qDZEsiDPykYp02Ssyfvdq7LwTOEvvujsF7VPldcEZ78k0WeAqvLzRc873tw6azb1M6ZBHxXBGUXd72CgNwyVx0z3reyHYC5DP0Ml4sWGerY6k0fXk4h9PlpHqg1RmqrHzKwYBOfl6EWOEMWNVLxUiGKDakJUT3S/Ki0sL4jVA5EUvn8KDyJizWbB2TSIDUUhnsmiOVHqulQ/ra7682i6vZBl4cxaX+adSRRr8oHec+TaE8/Y56L2vrII1nLwUlHNq2hPDNelyBfFGtWGKM9wIJNsWPpjlQTPcdF71y7vZINlbgtxRI6eWyOLSsTWoN2qDWbR2d4/q6nrzwXeHAEAAAAAAAAAAKB3fIQCAAAAAAAAAABA7/gIBQAAAAAAAAAAgN7xEQoAAAAAAAAAAAC94yMUAAAAAAAAAAAAesdHKAAAAAAAAAAAAPQuf64bsIwkzfyEppF5WpXHzJrWvz5biAQzm1U6rar96wtx3cxsHpSXi6ares5VlxJ0n6XiM+Vkrtut8kQGwUzsUp5ZIlMKPSXknFBjcSZTMP+aDgPSQTuf7ry22HkNfyHJMkuynQObiLFuaz2WSarnWyImcLNY6MapiWhmjQgAbZCnrZdPqxfBvO5QXt/aOmhf6Q9i0uhxSoMxbERdeakDVxoEjbTw8yUd8piZZcPSvz7wr587rViqnjLoB5i11dzaar4zoQpigCorDTbsvqV+rElyPXeiDTvP1BrTay86c6nlEp2Dsg7nieiM1DfV9qbV/TCvdP+pMBkUZ23bb3mR6DzrmS+/ZC4peZFaXuyc5Iu5P3BZqRdENa1kWin22OAYYnmi51UrJlAaLNgkKC9N/fJUPWZmhbgnM7NMxi5tMPTzRO2ezfSCWB35++xi3u1sWouzWlReUejyhsPl2xeN72DgX4/GYi7muZke+zwXZ3RxHWckaSqfb/yfX34NRVLn+e3p1BXNOZknuM9UzEc1r8zMoq5QcSjqalVX2IZgHWUd+ihalyrWRPF4Ng3OfuK+VD1mcf8V4sXQYKjnmIp3ZmYrK36+svDbN3H2bJybem6PXr1F63848p99q0rvK13WuXdGezrlDQYiNgRrb3XNv6fIqpi/ZvoZaiDm9rnS8sxPC45JJl5RhIJXRrbQR10ZN5rgfVLUdnW/VR2dZ3V5qyM/3zQV8am5cN7XEPUAAAAAAAAAAADQOz5CAQAAAAAAAAAAoHd8hAIAAAAAAAAAAEDv+AgFAAAAAAAAAACA3vERCgAAAAAAAAAAAL3Ln+sGeNr51Np5uTMhL/wMufOzX1fVuh6V1rQ6z7zSaYvazxi1YbbQaZO5X17TRG3QaUol2m1mlqaJe73Ilq/HzKzM/fJmQb8Oglmq7jdN9D2Np7q81aHfPtENZmaWpR2+5aZBBy6CBi5TXtJxkC4RSZpY4oxdGy0woYkWuaxfz5um0guiFQGqmet2VxNdXtOhvLbWaY2IJ20QZ7pIsmBRzv3xSEu9JqJRzzN/rJIgMKSFDlxp6e9l+epQ5skGep/LR36+fDTQbQjSkkLUVfp5krxDzLqUNI27cXeJNeEBoO1wAAj2CRWjwnYHcS0TZ7Um2A+LYJ3PosOaEISuTlQTonNVdN5RZ8y60f1Q1TpN3W/UD23Qraod0ZRIglC9bPum86AwWJKYJU6H5+Ls7f3sE3mCg36e++s8L/T6j+pSouP1YBDEjWCvl3UFzVP3pfrhTBv8tEVwtlpdE8+5psdwOtFxvw0Ws1qzC9FuM7M6iGtTcc7MRvosFLVPzZdoHpX6mBTGKE8anTHRK/WuwUzPkWh00mCOZLkfG1Jxzj+TFsRJEQOi+BTFtVK89Mg6tCGKT3kRPL+I/ov6oar0AksW/hgugpdW0fNVIkY/erVSBnFtddWPu6NRkGeoY9fayL+vUoTC7UHPB9NLRCaes9Os2/uvaA7LNgRrQsWAeF3qtFKklUN9v2VwjhuJOVzmem6PBn7a6lD3XRBabVAs/xwXPfqp56G647OD6j7xit7MzLocHYrgvXUX6ryYX0BffvibUAAAAAAAAAAAAOgdH6EAAAAAAAAAAADQOz5CAQAAAAAAAAAAoHd8hAIAAAAAAAAAAEDv+AgFAAAAAAAAAACA3vERCgAAAAAAAAAAAL3Ln+sGeNq6srZe7LieDlf9DE0ty2qaTKYt6nap62ZmdSOTgjbotCqoKxWfCGdVt/JUO4IsNsj9xInu8tBC5EsTnacqdNqoVCm6wDTtMr5BAyOq04M5a5m8KbNW5JvPdl5z1hDOLVELr9XzJgnmVBuNdY+aIDg1TRAX5n6+eq7b3QZBoxV1NVGg6SBtojXpj2EStKFY1dthseavyWw0kHmygV7HuciXr450G4K0bHXFTyh1+ywPtv/BUJQnrucTXRbOxHsvDtRz98fbKojdqT7TdBPVJWJhsEfJ+GlmavUVal6ZWROsc1VVkek8s2r5ONQEsX+2EGckf2jNTJ+DzMzm4nxX1fqeFsGZsBb9VwVtCLaLcDy6UHWpo9N80W/9zzdZlljmzP+29fstOnsPh3qPaMWayHO9/pNk+bUc5gnWubqvvNDtKwc6tha5X2BZ6MWSqXPhULc7D8J7nvmLolrV9xSt85lYS4uFHvfpVAcbNVRVEHOjc2ua+fcV5Yn+bK068tTiXJhFiwNLU88G55Jm/qLIxPwwM8uKfl9veTH1XGlRnqLUC30g4lBZ6vtV5ZVFt1ij1nK09NJEF6ieg9s2uKci6KPh8ve7MtTzb1WkDUsdQNdHujNWB2K/FTFlHLznglm9qKxKd+49ReJ3XB7MnSo4gKuQr/Yis/jMo9ZydA6J5v3Kih/XRIg8kyeY9ysDP02tBzOz0cCf9+vBuWYQrMtUBJvJXLcher5SZ55gCK0I7nfivF41M8uz4Fwjzttm8TcB2YZ5sP+I+xqJsbUOz8DPFP4mFAAAAAAAAAAAAHrHRygAAAAAAAAAAAD0jo9QAAAAAAAAAAAA6B0foQAAAAAAAAAAANA7PkIBAAAAAAAAAACgd3yEAgAAAAAAAAAAQO/y57oBS2lq93KdljJLGnxmq/zi4ia0rUybL/zrs0rnGc90WtP41ycLnSfStol7PUl0edszP08W9GtUXirS8syv50xdOk31UTROZkF5Ils8V4K254Vfz2Qq87SVmEhmlqgJ7V2PJj8sSRNLnLnVqknQs1ZN3nPlq/32NXNdXpRWTSq/nqAf6qC8tvbTVLsjSRAX0pHevrIyc68XqzpPseqvVTOzbODvMcXqSJe3viLTcpEvX9HlJSurMs2GIl+h90Yb6vbZSJSX+v1q+UCXBWubxl3vMgZEsSFIa8UZSZ2dzilX82em80TzSrQ9kfWY5ZmYc2a2ELdVB/u/OruosszMZnpLtsncvz4N8swWOq6pc2RV6zxR21W+jtuP1Y1fXnTkSnTTw3yeStSPmDpHe2egsxqxl0f5kmCws+icL9KGwT6f5/qMOxz5cWN1qCfcoIjS/L6IjtmlaPqw1PVE62FDhNZT2zpPMIR2cstv/HgarTE9HiqmZJluRB3FNXHOTIMH0Oj5czD058Rc1NPUeu9Bv5rgeSNJxLmh6PYKS82fvNDjHcUalTYY6PKitLV1/zyUB7db5H7/RTGtiyg+VUH7RkPR58Fajt4zrQz8OTEa6AauDXV5l+3y49DGim5EETRwdeCXp94Hbor+wRlpllrm9Lc6h9TBxjcYLn+mKMQ7BTOzlRVdnlrnpdiLzMzKIA6trfjzZ22k53103hiJtP0bel8eir5Qc/5cNieqfbrd0TOPOtKORMw4FxVDo+e46PlKvU+O3jMP9OspSR3F8+zZecf5dBD1AAAAAAAAAAAA0Ds+QgEAAAAAAAAAAKB3fIQCAAAAAAAAAABA7/gIBQAAAAAAAAAAgN49Yx+hFovgtzIDAAAAAAAAAADgeS0/3wJ+67d+y77ru77LyrI0M7Nf/dVftV/4hV+wRx55xPbs2WPvete77Kd/+qfPu6FmZm3lf9jKykxnSnRaLpLGM13cPPi2Nqtav7ypf93MrGl0edtz/3pVJzJPlNaIZrStztOKPGnw+TIL0ko543QfLYJ7Gs9UPp1nVMikTjKrZZqas6FGl9fMp0+7mE51X0rS5Mx/T5E4185ZVJBWi0WeBIuoaSqZ1tb+nG/UAjezttaBphX5qoluQzUJ5nzQDkX1eVbqPkoLnZYP/eBe7iplnnJjTaftWnWvF+v+9TPl6bRkJNJWdB4brug0Vd5gILOko3WZloi6kswPnvlwrNsGs7Yxa501I2J0W4nN/1xErGkXT3/feFr5Un2uSoL9KxXzqg32tSyY95mIG4PgZLs58ftovtBxS58zzKZim53M9D4yWyyfNgu28/hM6F9vg7Nnow5+ZtaKtCjup5luX5qI2C+mWK2nF+zMOHhjkYqDeRnssfO5niQq30DsvWZmYqjNzKzI/fKKoH0rI13XaODPx/WRvqehPh7YaODnu2xdt29jxb/h3Su63WWH55PoufThY3rB5Jl/T0UenYH1/VaVn7ZYBOfF4LiYizPecKgDfFSXouZyW/OPxUTaprHWOXOoZ5suz1bnql9JC73GUtG+XMQgszhOFqKu0YpezMModg39RbEiYpqZ2bD009R1M7O6ifZllUdmCeWZ345BEO92r+r27V3z0/au6n5dH+nyBpkfN9oqeCEYSMqhe3228OdRKmInzigHpZXOBp2Js2X0GqIMHhDUa5nBIHiXHLyLKMT76fVgnqqzi5nZrhV/Aa6NgjwjmWQH9vrt2C3OLmZmk7lf10y/MrJT2zpwqGeUaAxXgrOaerev4r5Z/Myo7qvLPZnpc/A8iAHR1qn6Sb1vr8/7y09/zrsp3//932+PPfaY7d+/3z784Q/bu9/9bvvxH/9x+5Zv+Rb77Gc/ax/4wAfswIED9vf+3t/ro70AAAAAAAAAAAC4CJz3R6i//Kcif+3Xfs3+yT/5J/bud7/bzMze9KY32d69e+1f/It/wUcoAAAAAAAAAACAS0gvf/8z+frfLbv//vvtDW94w5PS3vCGN9hXvvKVPqoBAAAAAAAAAADARaKXfxnw4x//uG1sbNhwOLTt7e0npU2n0yc+UgEAAAAAAAAAAODS0MtHqLe//e1P/O8/+qM/ste+9rVP/P+77rrLbrjhhj6qAQAAAAAAAAAAwEXivD9CNU0Tpl9xxRX2gQ984HyrAQAAAAAAAAAAwEWkl78JFXnLW96ydJ62WlhbLXZcT7LC/fnaMllWGvzWq3N8P1u6vPG0da9P5jpPlLY98/8Zw6rW/7xhVevyVL4k8dttZpZ2+JcUi1xnWuR+XXmm8zStHqj1oZ9vWAZ91GHcQ43udG8en0uS+/M8LM9rQ9AumKVZZmm2M3a0rVgPQbRsg2CSiKAR/TOlKo+ZWVP7c6CZ6zbMx5VMW2yJ8ha6PJUnko90B+ZDP4YP9gxknmGUdtmKe71cX5V5il06rdxYE3nWZR5b39Bpa7v866t+PWZm6epumZas+O1IB34/mJlZOdR1Dfy+SEq/z/PTm7oeWLuYWjvfGdfbShwAgnjS1vrQ0M5norxgjxLxxEyfuUKlLq8R7Yh+OWm0H5qV7tXxTJ9pNid+2sltnWc81S0YT/04rs5vZmbTuU6bL/y0+UK3bzHX8V1NpSo4CEXnvkQkRvtZFpzv8sIf/Vo0L+oHmKVZamm2s0/VuWY60XNntKLX3kDs2dG/vl6W+llttOKfDwbBWX5jVc/h1aF/v2sjnefAHt2+a/f5fbFR6OBQPfIl93p7evnzk5mOhasbl8s8q1dfLdPyzI/HlVp8FsfCRsyxPI8i/PIPZFE8SVM9hoWYf1ubwYM4lubFHzOzttGxOwveG6S5P27quln8DKViVJf3HWY6FpalbsPqSJe3ser3UxTvNsRRvwz6tar1eKihit7VRP23d83vi/0buo/WMx1s6hOH3evNkeO6EcE5WEWAZKifobI9V8q0RMShWeXH8FnFuSaSZYkb94OQIsl3PGaWidilzr1m+uxiZra64s+D9RW9ltdGun0bK37a9VfodbR/l04bifOVek4yM5uJI2OUJ3rfrmJUEN5tdRCMh7in9VHwnjloX/RsqEzm0TOofz3PdJ7KgveFIpt6Bp0Ez6bPtuhkCAAAAAAAAAAAAHTCRygAAAAAAAAAAAD0jo9QAAAAAAAAAAAA6B0foQAAAAAAAAAAANA7PkIBAAAAAAAAAACgd3lfBX3jN36jJUmy43qSJDYcDu3GG2+0d7zjHfZt3/ZtfVUJAAAAAAAAAACAC1RvH6He+MY32r/8l//SXvnKV9prXvMaMzP79Kc/bZ///OftHe94h9177732Hd/xHfaRj3zE3va2t4VlJWlqSbrzL2m1TeP+fNbMZVltWsq0pvWvL2qRYGazhUyyWeVfn+jm2fZs54e7s+YLP21e6TwL0QYzs5koz/t4eFYm/q5cq7vIhqVOVPmSJCgwoMawCsZwUevyUtEXeabztFVQoMozny6dx8zMGr+uJN85z71r+AtpUVhaFjuuqzgTjnPU1WLSN3MdTJJUr8lWzO229tsd5TEzq6f+fVUTHUwqkcfMrFj1txV13cxs5YoVcX0k8wz2rOu03X5aGeQpduk0W9/wr6/t0nmCtGzvle71dH2vzJOu7l46LSmHMk9tOqgtG9IWla4HZtY0Z/57irYWMaDSsSHaO9qFn9YG5ak9xUzHwmheqTaY6b963wZ7VVvo8mbtzvhtZrY50fHu5LafdnpbZrHxVP+jAeOpH6u3xXUzs9lMx+qZOEjO53qcFvMg9keHNSFVBz8zU1tTmun7LUsdaxJRlTqLterQBzMza+rGGucsoLptMAgOt4Fq4c+5otRzJ4vmSOGnRc8TUdruVT/txQf0OeTaDX3mmf7JH7jXJ0cfk3ls86R/PVqT5UCnrfpnlHSff54wMxvcqGP1+miPe33U8dFBzaVWh6dwTqiYkgXxqUt8KAq/3fWi29q41Hnxxyx+1xBRYxqNtTq7mOk5lxd6Xqk5Yqbn/dqqLm/vut7Pr97n39f+DV3exop6XySzyL08Slsf6UxrwWNAc+px93p9+LDMMzt2UJd38qhICG54oBuY7TvgXk83Lpd52tV9Mu3hE/78e+Cw377xVtBuWNP6Zxi1ltX5xMwsz4PzrfPu2cxsNNTrP0rbteK3o8x17LpOTzk7sMeva78dkXmaI8dk2vzKv+Jev/cRPR/Vu+5dQWxYHei0PWtiDOvgGarS/Tcq/Xy7Cv0cvEj0oUc9MzbB/rM5kUk2Cd77K8F2Js/2Kk9U1rOtt49QR48etR/7sR+zn/qpn3rS9Z/92Z+1Bx980D7xiU/Yz/zMz9g//af/9JwfoQAAAAAAAAAAAHBx6+13Qv3Wb/2Wff/3f/+O63/7b/9t+63f+i0zM/v+7/9++9KXvtRXlQAAAAAAAAAAALhA9fYRajgc2qc+9akd1z/1qU/ZcHjmr8A2TfPE/wYAAAAAAAAAAMDzV2//HN8/+Af/wG677Tb7zGc+Y9/8zd9sZmd+J9S//tf/2t7znveYmdnv/d7v2atf/eq+qgQAAAAAAAAAAMAFqrePUP/4H/9ju/766+1Xf/VX7Td+4zfMzOwlL3mJfehDH7K/83f+jpmZ3XbbbfbDP/zDfVUJAAAAAAAAAACAC1RvH6HMzH7gB37AfuAHfkCmj0ajp1VOM9u2ZprtuJ6Kf8mvrQpZVpLrtFLc/ahIZJ7xtJVp2zN1XZe3NdH/IuKpsZ+vbWQWm04rnSjUtb6nPPfbNxztHJ+z0uAfecxFtqrWeZpG95+uZ/k8ZmZz0X1ZcE+jUv8Tk+1cTIpIEwxw6ndgW82f1jX8hSRNLEl3zpNE9XE0saOuLvz1lZY6NtWzRVCgyDPX82Z2Qs/D2Wm/8c1cL8pyVynTNl60y72++4bdMs9g74Z7fbR/j8xT7FqTacm63wZb122w0aoub5ffjmzjcpkn23OlTrv8Gvf66YnMEu49s03/ehXE9qYNgu6Stjb7K+v5qK3mfjxu/H5r51NdVq1jQzM+tXR5Vi1/ZjAnbp6VDPU6knmK4J9pvvxamXToUb//Hjyq5+N46sfxzW19T9N5cCac+Gnb27pfo3PadOKnzWb6nqoqODMIWTCGRanPd+pMWJbd/nXvauHHqLLsdoa71A1HhQ1GO88WW1v+Pt+2eo+IjjwrK/4DVDnUc6csdNpo4LdjfaTn9q4V3faXXu3XdVV5WubZvv1jMq196H73+uTgEZ1HnOWToGNHB/bLtGQhzmqlPo812+JwYGZF4Z9rJsF5Ns90n6+KMD4Ixj1SLx/WrKp13Kgqv+27dom5nPf6iuR5p2laa5qdfaqev6NYE/Ge08zM8mBeFQO9JtQeVgTlDaK4NvDTVod6Al+9T/fFq67z592u4BVac+px/3q1rfNsHtcFqjzjkzJtMtGxRp5Bt8e6svGWTpuK+9q1W2ZJ9+pnsvL6b3CvH5zq58w//bw+ix895c+xIyf8sZ1uE2siWZZY5sSV1ok/ZmYDsSbN4nONSltZC97XBI+/A/H+58Bevf6v36/nwvrJL7nX5we/IvMMX/VtMu33/tSfw4+L+WtmdmCff8OrA51n/8byzwdzsV+bxa9JlbbS6zVv9DNykfkx4Mipbs8oayP/vqLtMXpHrr4xqDO1Bf36bOs96s3nczty5Ig1T5khL3jBC/quCgAAAAAAAAAAABeo3j5C3XffffZDP/RD9qlPfepJ19u2tSRJrI4+FQMAAAAAAAAAAOB5pbePUO94xzssz3P7L//lv9hVV11lScI/pQEAAAAAAAAAAHCp6u0j1Oc+9zn7zGc+Yy996Uv7KhIAAAAAAAAAAAAXqW6/Sdjx8pe/3I4ePdpXcQAAAAAAAAAAALiI9fYR6ud//uftx3/8x+2OO+6wY8eO2enTp5/0HwAAAAAAAAAAAC4dvf1zfN/xHd9hZmZ//a//9Sddb9vWkiSxuq6ffmFVZVYtdlxuptvuj0df0trFVKatru9zr49nrcwzr3TaZOb/HqyTW7qFp8cyybY25+71qmpknsVc93MjsmWZ/v1dKyv+FIny5Jm+31q0QV03i/tcjVWeBWO4c2o9YZDrfMoo141PUr8v2jTTBaqBMj2fk2K482JUBywpCkuLYsf1VvR/EnRnkur1oOZApK30Op5vzvzrp/14YWZWTSpd3ik/364Xrss8V7/+gExbvfYK9/rKNVfKPMm+/X7Cxh6ZJ93lx28zs2yP34ZUxPwoj5nZVrVznpiZHd7U8eLYpl7Hxx/zg9BsoedRE4SmVqTlwZyNYuT60G/H3jV/LgchCxHVcY1e/+1cn2naSsSAmR8zzMwsKM/mIl+mj45tcNZri4Ff3OXXyDx/9pAu78HH/f47NdYTfzz157Y6v5mZzWZ6go/Hfp9vj3XMnU6DNBGrp9t6DOuFLk/tP4MVfyzMzNaCM1wuhj7cA4PfEZsXftpwKNrQ9PZn556XFlVt6WLnmikKf00Mh3otR88aSlPrfSUf6XyrQz/fxqou70VX6LlwZXLEvT69506Zp33wKzLtxJ/6adVEx0+19tbEGcnMLBk4Z/mzVv0zWX7gJpklv/xambb5mN+3g0L3+d51PSd2r/rXVwd6/T90NDhDnfbnrDrvmJlN59GzqZ+2EM+ElQ6rsDPvd1pnMCqxH2XBgbQOnnmywo9RTXAojn4teV7467IsdTyJ4uQe8aj0hlfrRlx26osybfGZL7nXt7eCP9B96oR7ud08qfNE7+Uyf6ySotR5his6TcQuG0abwppOW/GDTbpfnyWTV/3vMu1jn/Xn7AOH9Bgefkw/c58Wz+NqT51PN2VZOLOevXNkImJ6Gpxho+fVcrD8ezPnNdITVuS5Rs+rXaf0OWT+mT9yr4/+xt+VeX79k/qs//BBf/Pb2K3j3ZV7/A6M3jdE79VPT/y0I6f0QG1OdF37N/zyvvkGcUAxs2TTPy+amT163I9rp8Z6DG95hU67YsOfm19+TB84xlPdfyfGfpp6n5RGL5OeZb19hLr99tv7KgoAAAAAAAAAAAAXud4+Qt1yyy19FQUAAAAAAAAAAICL3Hl9hPr85z9vr3jFKyxNU/v85z8f/uyrXvWq86kKAAAAAAAAAAAAF5Hz+gj16le/2g4dOmT79++3V7/61ZYkifvvAy/9O6EAAAAAAAAAAABwUTuvj1APPPCAXX755U/8bwAAAAAAAAAAAMDsPD9CXXfdde7/BgAAAAAAAAAAwKXtvD5CPdV9991nt99+ux05csSapnlS2k//9E8/7XLatra2df75voX/T/q1eRGUtpApyXziXl8dDGWeupFJNp4m7vWDh3QbHnloU9dV+febpH4957K6VrrX19b965E0022ImpdnO/+5RjOzLPWvm5mVwSzNRWVRG9JUp21O/HY0unm2PspkWp7qNKVt9D9dmWRirnt5gnJgluaJpbkzGVIx4Zpg8QehtCn8MUtyPTfaYMLlo233ejXV4z09MZNpV7/+Svf6dW96tcxTvOTlMi2/4ZV+nhd9g8xzaDxwrz98TPf5sU3dR+PDfgCYPqwDw7zSabUYDxGizcysafT4VrWftqj0PY0Gun0rQ7+f9q7r/tu3rgPh9fv9tP0jfx6dHsxlWTBr68raWp8DliprPtWJlahjMtZ5Nk/qusbifJLouZPs2y/TBt/yFvf6f79fx88Hj8gkO7nl55vM9DqabFfu9brWeWYzvdDnM7+8WRCPt7f1XJht+2tsMdNrbD7VaWnmj1Ux0OfmotCxZijOOysrurzVVR0LRwO/30elH7smabQPQ6kqv9/UdbMz/5S6ovbEoXem+rrda7quK3b7aS8+oOfONaMtmTZ/4D4/4WH9r3YsTurnsbTwY01W6Xm/cuAy9/rwin0yj115jUzKrr7BvZ5c/1dlnj8/qOPQw0fFnKj1uH/DC/V4XPH4/3Svt0G827judTLtf37Zb1/d6PZFZ7LTwTbo1xM8+MGSJHFjhPdrGc6Heh6K6omaMBz6a3k40ueQy/bquPZ3v/moe33r//6gzHPoyw/JtNMPnXCvz0/pfT4XbR9dpt9njfZv6LTL97rXhy+4Wuax3TquZS94sXu9OHCjzJNs6LPksdP+AN/9Ff88ZmZ273/W+8/DD/rBYTrV5YXvmcS5Kxf7Y5N3e693qWhbf70XxfLv2AaD5fNE56T9e/TYqea96nL/PY6Z2eRTd8m0z7/8ne71//jr+rlwc/OUTNsn4kP0PHTwmH9T82DzbVvdR6e3/bTJTI/TsRO6rqv2++WNSr2WX7GmzygPPe5f37crmBP3/D8yLdnvx9BXfeP/JvN89ZC+37F4Pp3M/H4IX2U+y3r7CPWhD33IfviHf9guu+wyu/LKK590MEmSZKmPUAAAAAAAAAAAALi49fYR6md/9mftfe97n/3ET/xEX0UCAAAAAAAAAADgIhX8w2TLOXHihH3v935vX8UBAAAAAAAAAADgItbbR6jv/d7vtU984hN9FQcAAAAAAAAAAICL2Hn9c3y/8iu/8sT/vvHGG+2nfuqn7K677rJXvvKVVhRP/mWt73rXu86nKgAAAAAAAAAAAFxEzusj1D//5//8Sf9/bW3N7rzzTrvzzjufdD1JkqU+QrXjU9Ym1c6EvHR/vnnaJT81o59zbd8BmWXXKJFpp7f9v1j2mf96n8yzefy0TFvfu8u9vrp7TebJCz2kw1HhXq8WugcXuX+/Wab7Ic9amaYEzQ6tDv12DPxbNTOzPGj7ovavT+b6nmYLnZan/pxIxHUzs7YRjTCTc9Zy54bTTJcDS7LMkmxnH6mxSQZ+/DkXNQrF+orMU+5alWn1bO5e3z78NZnnZf/Hy2TaVT/6j9zr/3X2apnnM1/S8/f+j550rx8/fFDmmU/9e6oWzj7wdVm2/F/kHawMZVoUO1fEeAyHeo0NR7q8JPFj0J69A5nnqn36fl9xnR+DvuHqIG7d92mZVn/6q+71yclj/vXtqSwLZkmWW5LtjNFttXB/vm31npwEcb1txHgvZjrP6ZMy7cjdf+5eH162W+a54id/RKb96//un12OHtf3u7Wp2z6f+/naVs97labW5LnKWwT7v5IG+39e+OMbDKG16lxgZrVI27V7JPNcdbU+Y26IpFGp+2FlqM80Ze7ny8U03846n/gvCfWiscrpo1RM77rW45amOk09NySqIjMz0+W9/Bp/wC878XmZZ3KvfrYysVe5Z+WvS6Pnp70bfp5S58lG/n6e7Llct2HPfplWXvcK9/rnH9HnpIPHdZ+f2PLjUBBOLLhdq752r5/gnLPP2nXt63VdhR83To11G2aL4Plu7vdTUfKs1EVT19bUwfPqU9SV/tlo/1XPAdEzQFCc5YWf78Uv1OV9530/K9N+/9p/514vVnWskWc1Mxvt859TLn/VPpln9Ro/bfUaHU+KPbtlmu0WdV1+pS7vmpcEaS91r/+5fiy0r97nn4/NzCYzf4C3JnotR++6BgM/X1V1O2+UpXiPoCZmSwzqoqn98RkEz+aRlRV/zY6C8tJEz5F96/54JyvrMs9/LP+OTKsf9a9PJjq25rmOa4896m+mD3/tlMwzWvXfhak1ZGY2Ev1qpscwDeL7dKLPPJub/iGlqvX7n81rdZy89yt+3/6//45+XzP//35FpjXr/rv9zYneE46c0nNMfXvYFjFSxc7nwnl9hHrggQf6agcAAAAAAAAAAACeR3r7nVAAAAAAAAAAAADAWb19hPpbf+tv2c///M/vuP7BD37Qvvd7v7evagAAAAAAAAAAAHAR6O0j1Cc/+Ul705vetOP63/gbf8M++clP9lUNAAAAAAAAAAAALgK9fYTa2tqystz5y8qKorDTp0/3VQ0AAAAAAAAAAAAuAr19hHrlK19p/+7f/bsd1//tv/239vKXv7yvagAAAAAAAAAAAHARyPsq6Kd+6qfsu7/7u+2rX/2qffu3f7uZmf3hH/6h/eZv/qb99m//9lJltW1jbdvsvL55zP35tJrrsuqFTstOuteb2VjmecneAzLt83tW3Otv/6GXyjzf/fLjMq3Z3vQTgk+HSdrqxHRbpwntfOonNDvH5wl5IZMSkdZWepyyPVfItHbm39P9490yT1XLJCtE0zdWEplnLddtb8b+GMqxNQv7tpn4+ZLhzrnXLma6Dlg2KC0b7vzbm1I4r4NQmogFu7Iqs6SDoUzb++KXuddv+Mn/n8zz3l/zY6eZWf4fMvd625ySebrYuGxDptW1P+fTVAe7JlgnWebna4PwuHlCr0mVluxdl3k2dg9k2qte5s+7v3n5Z2We6tN/KNMWf3zYvX4kuKd6FuyNqm9FB24GZcHM0uzMfzuu+/M0yXSssVLHBsv8tRzlWWzqc8EX/82X3esv+MqfyTw/8y9OyrThUOyHYv2bmaViLZuZtdGCVnkaP0/XepLEPxskqT4zrO/S+85i7o/haFXHk8lY7/WXXbHmXn/NN/rnVTOz/bv1IakQUyy4XRNdbmZmeeZnrGo/U1LpsqDNF/4aGwzFgJqe22Z6fo+39F6wGZy3jm767fsvX32VzPPfPrlfps2m/nPhItir0mASN2ISq7OGmVmai779msxi9X+NJvgR92p0T8O1kUxb2/Bjw4tu1Ge1z+ok+45vuMW9ngT7z+cP61gznfvjsT3VfT6bLx+rF3O/Deo6Yok410T7aJTWiIf2xVzP+8lYvLsws8Xcn491o+PT9/+Pv6XL++63utejM4A6h0SaqP8Oi/3y8X7bkKsDgJm94W/qP3B+zUF/DL/xRbp9L79Gr/N77vfbfuykvqf7v3JSpg1H/jP8+ro+i6+u6rRlu3Y20ec7mOV5Ynm+cz7U4pwYvTtQeSJ1sBUEVdk33+jPq5/9Nzp2/elnHpFpi5l/rqkX3Q7GMlYH71eOdYgbmToLWbdnqGKgY/VwxV9Lj3xNt/sz6/qMUg78McyD59bkbX9Pph0uXuBev/c+PSceP6X7bzxV5yT/+nS7t79/dN56+wj1nd/5nfbRj37U3v/+99u///f/3kajkb3qVa+yP/iDP7BbbvEPpgAAAAAAAAAAAHh+6u0jlJnZm9/8Znvzm9/cZ5EAAAAAAAAAAAC4CPX2d7Je9KIX2bFjO//Jp5MnT9qLXvSivqoBAAAAAAAAAADARaC3j1Bf+9rXrHb+0czZbGaPPvpoX9UAAAAAAAAAAADgInDe/xzff/pP/+mJ//17v/d7trHxF7+1tK5r+8M//EN74QtfeL7VAAAAAAAAAAAA4CJy3h+hvuu7vsvMzJIksbe//e1PSiuKwl74whfaL/7iL55vNQAAAAAAAAAAALiInPdHqKZpzMzs+uuvt09/+tN22WWXnXej2unYWq9lX6/rqerTR3VZ86muKBX/GuFj98ssi9mnZNqbH33Qvf4/fuI/yjzTf/1/yrTB//pd7vW2Wsg8bbPzn0Q8K5EpWlIO/YQ005mC9jWbx93r0TipPGcS/fu9fs+VMku6V8/RKhu514t2rpsw2ZRpcqyC/mtr3X9JORCNcPohmAswsyw7899TJHnh/3wSrKCBWCdR2sq6zJJf91KZ9qflN7nX/+2/n8g8L37ZXpn21S+fdK/XtR9vzcxSFTvtL/aEZ1rUhnf9H3vc6698gc4z/v/8kkw7ePvn3OvzL+u1OjmqY1pW+O24b6OUecpVMS/NrFjz86WF3uKToP+k1F8D9UL3A8ySYujvpSpGR2so2DvSyt+nmlaXVwZ/U/2Wf/F97vXfvk9mscWskmmDgd/2RMwrM7O2bXVlPYrqaRudtibWbJbpe9p3md4vhqVfV9BFMo+Z2Z51f+x3r+g8eXC8C7pCitreiALVEniWtpeLVpIm7npSc3i8pWP36prec6rF8gPx+FF9jv4Pd/jXDx3cknm2N7dlWib2vizT+168J/qxOjonqZii5ryZWRtM8Fzc08r6isyz+/JdMm1jt/88Ude6fQeP6TPFH9gL3OtV8Chy+ITu862JHzgmU13gYq77bzrRe5NnNuFc06cmmAiLYN4XA3+PreZ6PJNkJtMeP+LHja8EZ+xctMHMbDYVcS1YR9GZQp2Hov5TsSa1YDMPFAO/L5LgOfi//eFXdXmlX95/DA4bKt5F7YjOcbt2++93zMxGI78dabBfRGeh2cwfKzXusyVj06VmMW8sSZ/+O63FQv9sUeg5p8YtF8/sZmbTuV4T//Vefw9pgnNDtbiw54Jal4t5t/2ycX6Vj5lZ0gZ9vqXPfiotiuFzFcPN7MaXXeFe/+0/1vvF6vBqmTYTZ+fpPJiXQdcuKn/+qeNsl1c/z5Tz/gh11gMPPNBXUQAAAAAAAAAAALjI9fYRysxsPB7bnXfeaQ899JDN50/+qviud72rz6oAAAAAAAAAAABwAevtI9RnP/tZe9Ob3mTb29s2Ho9t7969dvToUVtZWbH9+/fzEQoAAAAAAAAAAOAS0tu/DPgP/+E/tO/8zu+0EydO2Gg0srvuussefPBB+2t/7a/ZP/tn/6yvagAAAAAAAAAAAHAR6O0j1Oc+9zn7sR/7MUvT1LIss9lsZtdee6198IMftPe85z19VQMAAAAAAAAAAICLQG//HF9RFJamZ75p7d+/3x566CF72cteZhsbG/bwww8vVVYz3bIma3Ym1LWfoXV+9lx5zMyqhX99e6zzHDsik0594X73+u6bNmSeh/+f/yzThh//I/f66tX7dZ7Ldsu0dHXNT9jYI/NYJqbIcKTz5IVOK0v3cjpYlVmScqjTRuvu9XY+lXnqE4dlWjZc8fM0eo6125syTfVFOwvmWES1I+3te/IlI0kzS9JsZ4J3zcysCOZ1NOeLgX99FK0hf52Ymb38Gn9N/v2/qct78VV6fsy/+BX3evXwl2QeO35UJrVbp/3yNrdknmo8ca8380rmqWdznfbP/bRHmlbmaSu9VxS7/DHMhmKumFm5qudEU/vruAjypLmuKwnSdIFJp7rcnxf3gzOSvLDEixFqnasYZGYW7B3ZxuV+cau7dXlXvkiXd/m17vUDD+u1ctNL98q0Y0f9db5Y6HWZZXqe5rkf1/JCx7uRWLNFqfu8KHV5ZeG3L9HNtjwL7ldUVeQ6TxGc5Kvab8h4pstLU51W5n55wRHJimA6c3TpV9u01jr7XCuGtK71WM/nelC3t/29OQkmfrSWJ6K8XMw3M7PLr94n01pxw4vgnqK6UrEwyyA2qP4Ltl6rgzOKindRn0frazrx+3xlRQeU4/7x7kx5cz9fcLSy6VSPRyUyRvNyNtOVRf2ODkSsqWt9blcy04NTi3mQBxtftdBtmG7555BHHtEb1f5rglhzwD/zJMGEi+KQWs51cM6ebc/c6ypunUsmngGifo00Ygy7lleU/rNSdL/Tqa5rPlP7jy5vHNSlnvFU++ZB22CWZslSczk6j1aVTlR7YrTPHzmu1/mpsR+j8kKP9579+p3sqaMn3eteHH4iTR3+AlGsScShIorHbTAgqq4kuKdIMRDvXYM2DFfEezrTZ4qvHdTjvrqi9xL1fNU0urwuXaFuN1obz7bePkJ94zd+o33605+2m266yW655Rb76Z/+aTt69Kj9xm/8hr3iFa/oqxoAAAAAAAAAAABcBHr7M4jvf//77aqrrjIzs/e97322Z88e++Ef/mF7/PHH7V/9q3/VVzUAAAAAAAAAAAC4CPT2N6G+6Zu+6Yn/vX//fvv4xz/eV9EAAAAAAAAAAAC4yPCvsQMAAAAAAAAAAKB35/03ob7927/9af3cH/3RH51vVQAAAAAAAAAAALhInPdHqDvuuMOuu+46e/Ob32xFUfTRJgAAAAAAAAAAAFzkzvsj1M///M/bhz/8Yfvt3/5t+4Ef+AH7oR/6IXvFK15xfoVWizP/PVXT+j/fNrqs6USnzWf+9cVcZmmDtGJ9xb1+xTcdkHnqWVDeml9eNihlniRNZJqpj4TBPVkq/sXGutZ5kuBfeWz8sWq2T+sm5MHHzcXUvdyqdpuZ1bq8pvHvK8l1n7et7ouk6flfvBTtc697awh/IU30/HZ/PtNpWZCWBGtSaCebMq14/D73+g1DP16YmVWPbsu0RtUVreNgTSa5v61EcUvFhUrnsFbkOdMGfzyauS6xLXR5aenfUzPQaz8f6bS2FXtZR6mYf6rdZmat2k/NLBHrIupzaMlgZMnAWZ+JP25RxGjLYT+N+rpsfa9MOzz250+t9iEzu/JyHQuLcs29Ppt2WytZ5vdUEsRclacodbwLj1W5374oT7Tt5JlfXhbkSRPdR6odi+AINwjqmld+XXlww3UU7ggpvWpa/1FJze/ZVO+Js5meJHJeVXpAm2D/yMQEr4PJU1W6fcOhiK2D4KwWaGrx7NLhjB9svZbnurxK9G1R6HuKtuzRSMyJYNyjtOnQ3y+mwRyLjscq9EdzYjrRda2s+O1T9xTdK8yatrVmibNsdOasg41A5YvOBuVQP28s5v6z8WTLf59gZpYXwVlatCM6LzdBX2Ti+WUx08/06t1PvdDroRYxLRK+YwqkYqEPgnGK+qgK7kuZT/W7LjW+aXDwUntWzI8p8yBG4sxe4K0zdX5ZXYve2el6FuJgvL0dnJOC55e88OfIZFuv5Whul8OBez1aK1EMULrM7SjedYk1acdYo+LnYEU/O0f9t7Xpx41BcJaczfR+MRz5aUnwHBfNWTX/1HPmNJjLz7bzfkP+7ne/2+6991776Ec/apubm3bzzTfba17zGvu1X/s1O31af1gAAAAAAAAAAADA81dvf03jta99rX3oQx+yxx57zH7kR37Efv3Xf90OHDjAhygAAAAAAAAAAIBLUM//VpjZPffcY3feead94QtfsFe84hX8nigAAAAAAAAAAIBLUC8foQ4ePGjvf//77cUvfrF9z/d8j+3du9fuvvtuu+uuu2w0GvVRBQAAAAAAAAAAAC4i+jdnPU1vetOb7Pbbb7c3vOEN9gu/8Av25je/2XLxi+kBAAAAAAAAAABwaTjvr0Uf//jH7aqrrrKHHnrI3vve99p73/te9+fuueeep19o057576mqhf/z6vq50prav76Y6zxZppPEPz1YbqzJPPloINMSUVeUJ2qfLURfFKXO0zQ6TWmDPFXlXw8+XLazbZmWpP79Ns2mzpPpfyKyzWd+nuGKzCPnkZm1Ki3o13Y+1XUpTj+00TjALEnO/PdUqfgLon3351zHmXrzmExrKz9fkut13EzHuryJWCu1ntehzF/L6UDHrbby64o2qDT4p16rib+GEm+8v64J7rcRQ5V4+9RZQeNTNccCSarbrvPoepKoCaKf1J6UZMSaSFIOLSmHO6+L/SvS5nree3WYmbVBPSfHeg5vTvxxLYJmr42iueBPuvFAL5boCKKWX4elYnlwT0HYsEysoy55zHTbo/ZFaUobhK6q1o1X7atMF5hb0BlLhsI6aDfMmrq1pt65aOZzf3/zfvasNpio8yCfbltQl1jMeRBsojVWVX5dVdVtAjUiEEVHAEXdq5mZlfp+q4Xfhqi8NBjDmf+4Y5OJPguVpS5PtUONhZlZHSzoLPMHONoT2iCwbW/7z5+qfWrN4Iy2bd0xV2fV6AybBotZ5cuCuR3FGnUuXsz1+6JoXqnnii55zMzmE7EwA2odRf2aF8F7lw7vfqLnDWUx033eBP2XqWeRYI5Ffa7udyGeTc3MmuDgpepSz5nzWfDeEVbXrTvH1bP0bKbHLc/1PFVp6VSXF+1vqh3TqXgXavGerXRZr13zVQu/7VFZxUC/n1L50uB9dpf3IardZmbDFf/Z2Uyf8U6f1mt2Pu925lGiOav2OvX6OZqvz7bz/gj1Mz/zM320AwAAAAAAAAAAAM8jfIQCAAAAAAAAAABA75b/O38AAAAAAAAAAADAOfARCgAAAAAAAAAAAL3jIxQAAAAAAAAAAAB6x0coAAAAAAAAAAAA9C7vq6DpdGrD4bCfwurGrK53Xm+bfso/q6pE/U7dX5fkhUwb7N/jXi8mKzJPs1jourLMvZ6WwbAlz9J3xcVcp6UDnabGsG11nkaPRyvSEl2amd+tZ/Klov8qPU5dtEF50RyT0p03lWQdyoFZImZPtLaaYP6qsRbr28zMJhNd1VysvTSc9cvXNZ/qPMGaVNpgjSe56IsgFreNiN9mlhX+3I9anam1HwhjcTAnmkq0JOijttH7n9or+qbiY9J17l0i6iaxutnZR5mI9d7PPqEsZdJcLIlFrefVZK7TZqK8aKkMy2DeizmcZ/p+J7Pl51YUjtVUje4pmt5p6lcW5cmCutT2k4l6zM4cmZdVdDz9q/YRAi4M83ltlu7cXxoxSRI1oBYfy7uI9rBUTMiFCmrnkAz92Brcbqgs/T02ijWtSIz6dTFf/myVBgElz3VaLfaFwUCfJ1QeM7PTp4PnQiFqn5qbi4XuoyzYS2ZT8bxI8OokS1PLnLnXiAnu/ez5aILFl5qONer8HT3lyzO7dTsXq9gQ6VJeE51rgnhcq/0iaENUnpoTXam9pFoEz0lR2ztsDPVC702peKZV41QHMQ1aLdZlmukDrjoLmZlNKz8ten8xnSx/RlHry8xstj2TaZWYc+VIv3edbun3Saod0VmtGPjPoGoszHS7zfS+EPV5EN6laI1H91uJtRmdXWaz5ddzdHbpckZRsXA26fd99vno7SPU7t277TWveY3dcsstduutt9rrXvc6G41GfRUPAAAAAAAAAACAi0hvfyzlD/7gD+yNb3yj3X333fa2t73N9uzZY69//evtJ3/yJ+33f//3+6oGAAAAAAAAAAAAF4HePkK9/vWvt/e85z32iU98wk6ePGm333673XjjjfbBD37Q3vjGN/ZVDQAAAAAAAAAAAC4Cvf1zfGZmX/7yl+2OO+544r/ZbGZvectb7NZbb+2zGgAAAAAAAAAAAFzgevsIdfXVV9tkMrFbb73Vbr31VvuJn/gJe9WrXhX+0lsAAAAAAAAAAAA8P/X2z/Fdfvnltr29bYcOHbJDhw7Z4cOHbTKZ9FU8AAAAAAAAAAAALiK9/U2oz33uc3by5En75Cc/aXfeeae95z3vsXvvvdde/epX27d927fZ+973vqdfWNuc+e/pqmudVi10Wi5uvw66pdHtSlI/LS11eenKSNel7ivLdBsGQ11eUfrX80LnkRX1/DfcojEMmtfOp35Cqvuod7no10C7EO02MyuCMWz8fkq8KSZ+Fh1FMSlKU+NQVUF5rU7rMrej9ql2RLGzg/BvxYqYlhbdtqh6OvfbkOo/d9EG6yXK12d5Sfrs/c3httFzTLUjygOtqs/891TzavnxroMx8OowM5vMdZ7JQqfNRVoWLeVgqZRiL08S3YZoSdQirEXTtG39ArO029xWYS3qhzAUinZEefJgS+g7pKitqW50RdGWFc2lPn7+UlOWmZXlzg6fjP19Ph/o82u10GcUtZ9He1gTLUxRV5QnDeqabc/c69VC78vFQD9sVB3uV4n20bzQi2Ux9/toMNB55rNgDDvs89H+o+ZEG5xno7om2/4ZtHDm91nVQp91VdsLEaz5l1xiddNY4mzCal5Fay9aR7l4DojmlZkuT+Vrg/c74dO0OIhE8SkN3uOodizzWuwv1SRTalv+zNOoQ6aZ1cF4qDge9VG0/rp0RdR/qu1dxsnM3HVhZpaJWBOVhTOxI812zr1GvDucT6M9dvn3CrOZnvdRXFMWc/1+JZoLOk2v8+hcI8sLHmC67ItRnlqtlaC8OHL545sGD0pdxnDe4b2QmVkmHmKiV4JRVapvVT0dm/2M6PV3Qu3evdve+ta32s0332yve93r7GMf+5j95m/+pt19993LfYQCAAAAAAAAAADARa23j1Af+chH7I477rA77rjD7r33Xtu7d6+9/vWvt1/8xV+0W265pa9qAAAAAAAAAAAAcBHo7SPUbbfdZt/6rd9q73znO+2WW26xV77ylX0VDQAAAAAAAAAAgItMbx+hjhw50ldRAAAAAAAAAAAAuMj1+juh6rq2j370o/aFL3zBzMxe/vKX29ve9jbLgl/sBwAAAAAAAAAAgOef3j5CfeUrX7E3velN9uijj9pLXvISMzP7wAc+YNdee639zu/8jt1www3nX0ldL58nSXVa2yyfpyiWTkvSoLyI+niXB22IPvhF+RTV9qietMO0CsprGz3uSSbuqWOft/Vi6TxJuvxHVtluM7PgfmWW2fbOa/PJ0uVcUtr2zH/edU8Uf6KYoeZ2Fcw1FZvMzGz5ORpS9xXdb111S1PC+11emos+b8TYmlmbJjItafzymrkei6TQcbBRfRu0r5PonoK0ZfMkdcc97hIxq1qbVU9/bKtg6TXBUlnUfh2zYElO5kFdHaZjnulM6r7aLJqLurxcJFV1t/KUZPmlYlmq6+lyPOmwXM3MLEn8dnS5JzM9J/LgfqtgzqZL3piY4vi6pvXHSD2HdJ0HShpM7jzYEzUdDJsgQGXqDBCUF1Hldem/Nlj/da0XSzn0nxvqoB+ifb4V+WYL3YaovDwX54OOk6wo/T5X7TYzSzPduepRTU3Z6FiPM+O6zDky+tm0wxyJ5lXn9y5CExzK1PNGFJ+6xiFF1ZWq59mOuq5lJe6jIL6Ldd52vF/VjrrSB+RojqndZyGe/RbzDs/Nl5Cmaaxx9sa0w19yWMyWH9Ok0vNePs+bnldRPOmiDR4Mq2BuxevPV4v3pF1jg8rXdwyfT2YyLTqbNs3y7aiChx4Vo4pCz+X484dfXln67a4voIeo3kb4Xe96l91www328MMP2z333GP33HOPPfTQQ3b99dfbu971rr6qAQAAAAAAAAAAwEWgt78Jdeedd9pdd91le/fufeLavn377Od+7ufs5ptv7qsaAAAAAAAAAAAAXAR6+5tQg8HANjc3d1zf2tqysiz7qgYAAAAAAAAAAAAXgd4+Qr3lLW+xd77znXb33Xdb27bWtq3ddddddtttt9lb3/rWvqoBAAAAAAAAAADARaC3j1C/8iu/YjfccIO99rWvteFwaMPh0G6++Wa78cYb7Zd/+Zf7qgYAAAAAAAAAAAAXgd5+J9Tu3bvtYx/7mN133332xS9+0czMXvayl9mNN97YVxUAAAAAAAAAAAC4SPT2Eeqsm266yW666aa+iz2jbf3rTd1vPVmm06K6msa/ngblpcFfRksS/3rUvqzDkKp6zMwS0T513cysqXRaWvjXq0XQhqB9tZ9PzJQz1DiZyfFIcv17zZrJzt+F9kS+chi1ZHli/iXZzn5NojGCpuZH17gwm4rygrUaLIcwnihtMOeVaE2qWGwWxIZ+43QSxYXUT0vyoO+CsNWKtidR/A7IXEHz2qDPWzFno/apPOhfXZtVS0z/aGgmCz0PapGvidZrB9G0F0vPzMxKEfKSRLcvWueqn6LyugjDnWheh/AU5svCo2LUf8u3IUpT2lZnytJ+xwNaU7fW1Dv7W8X7+XQuyyoG+ty7mOl8SrSHVYtgAxayYFHkxfLPQoUKUGZWq+AaaBv/frvs5ZHoqBb1Ud+qym97FE/mle6LPPcz1s78PitJdf9l2XKBbT7jjBRJk8RSZ4NR5w3vZ5+ORhyekmBiRWtMrYlotNNncR0pjYgnXfOkHTb6KA52KS+Kd+HzixjfLn30TFh2v+j7jH6pmIwn7vVo/1f78hl+rCkG4t2lmaXBu6Fq4Z+TovFezPSGXotzUt/P81nwrkSd1ZpaP+RGa7nLGSW6XxUD8kLfU7xe/ftdBPEuut8uZ9MsqEudu+Yz/+fn0+gF47PrvD5C/eiP/ujT/tlf+qVfOp+qAAAAAAAAAAAAcBE5r49Qn/3sZ5/Wz4V/Yh0AAAAAAAAAAADPO+f1Eer222/vqx0AAAAAAAAAAAB4Hjnvf+T2/vvvD//tXQAAAAAAAAAAAFx6zvsj1E033WSPP/74E///+77v++zw4cPnWywAAAAAAAAAAAAuYuf9Eeqpfwvqd3/3d208Hp9vsQAAAAAAAAAAALiIndfvhHrGZKlZlu28XiX+z5dDXVa10GnzqX+9KHWeJPhu1zbiesd/rrCu/OtZMGyp029P5BNpUXldNMH9Rv3XJzUWcZKJGWZtU+s8UZ93kGSFTIvagZ6kYo7WHftelifWt1m8TppgAneh5lR0v1EbRHkX/NxN1eo3S81f422Qp43ioBj6tuPYpiq2B5Igj/ondru271K3qFtb1Dv7NEv8+eP97PmoOi5lJZj2lop7MjNTSVl0rArOT6ouFXIj0TGtyxEu6IYwLerbLrqUF4WuvtuXLVnesj9/qVnM55Yk8x3XGzGo4T+nPttZzlmJWGTVIjjXBNR+mUbBIVCLoBftYdVCB0rVT1H7GnGGivbrtNDPY6qPkp4XZdQPUV2pmBOLYAOK5l/T+OVFZ6vBcPnn2cFAjEf7LD2vXqSatrXmOfx1DNE8SIONQsXC1HRsiI5JSbRhCtGzg8zToZ4017FGxciIivtmul/NdNwNy4vihui/qI/6jpPRXrJsrObZKtZUtdXZzvmQib00mjvRmlDnl3YSxIYgBqp5EI13GszTRjw8RJEhWmOteA/VZT7mwdmlrqNzl9+G6JxUDKL3pH5d6jx2rrrUfInOSWmmR0T102yqz855Ec1Zvx0rK34fNfmF8xB13iesJEksecqieOr/BwAAAAAAAAAAwKXlvP8KTNu29o53vMMGg4GZmU2nU7vttttsdXX1ST/3kY985HyrAgAAAAAAAAAAwEXivD9Cvf3tb3/S///BH/zB8y0SAAAAAAAAAAAAF7nz/gj14Q9/uI92AAAAAAAAAAAA4HmE37oJAAAAAAAAAACA3p3334R6RjRm1rQ7r2eZ//N1rctqnXLOSkV5UZ620WldqDZEaWnSra5E5FPXzcxS8Z0yakPaYVpF5TV6fNvGb1/YQ8GnVzW8iajHzCyYLTpfE8yjrAhKRG+a1h+Hulq+rCAEyXii4pmZWRsUqOaOWqtRnkiUp+84KCTRPaV65bWiz6PQVM/1PbUd7reN+k/EuyQITh2jvtQE+2Yi9oQo1kGrGrPK6e5K9Gi0HS5qPQpdlnlEtcM7nj2RJ1iyiciYBTccHccakZhER7jWryvquuiIJMN7xz/ilYjGh8e0IC3K12d5WRCPI7NKrQG/okW018JGKwMrh4Md12fT5c811ULnaTuck6Lyugn2SzEfozNFEsWhIO4qxaB0r0f9kAXPhI2IUmlwT1WwYLLcryvqh6bWkTJKU9RZw8wsL/z2tcEGVAfjVIigXC38dtfiOmIqdkfUXh6VF83TLproYBO8h5DrKOiHaA4rYXwS5TXewfM8ymuDfugSN9SZ8Fxk+8IDY6eqOlHtUPtIl9h5KUnzzF1n8+nc/fm80A/70ZqQeYJ5FZWn5kE112eAeB35dUWxK3oWyURidE5qxfml69E8Fe/CVFw16xg/g3gcnsm69FEwX2oxX6Jxj85xKnbMZn6e+ezCiTX8TSgAAAAAAAAAAAD0jo9QAAAAAAAAAAAA6B0foQAAAAAAAAAAANA7PkIBAAAAAAAAAACgd3yEAgAAAAAAAAAAQO/4CAUAAAAAAAAAAIDe5c91A1xNdea/p0pFc+tal1WUOi1JlmuXmVmWBeWJb3q1cy9npcF3wKYRbQiGLbonVVca3FMqylNjYWbWinabmZmoK2pDIBH5kmLYqTzLi275eqynXUxlmrovL09bL5Zv1yWkbVtr23bH9cS5dm7BnFdJan2fi1rHURyMqHY0QXlB21uVr9H92oq0ttJtaDv0n6rHzCyJYnEHUWnyfqN51EHUf0mH/S8V+5+6jjOa1p/+anudBUeGiBruOghpTYd4V+bR3InK8/NVQQPbVtelZl2wzK0WieF6DcrrcoxU4x7pUk9UV9fyksTvjKjPI136Alpdt1Y768k765iZLWb6nJhm/e6JRanPvfXCD3pJMEHSIK0WwTDKE+2+XfbLxWzulxWcNVS7zczywo941aLb2a8RZ6jonBSdu9Q5IMv7PR9EcyJsu1gDjdiXusa0S12XM0XaYX1F60iNtVnHs28458Q6Csrr8rzRBuckdU99r5Wo78Lnqw7ta2oda7qMYRfRPOoSCxvxnN7lefZSUs0WltjTf6dVifOEmR4DM73/lqOBzhPMUxkbgnnVBPu5ftbWeaK+UGeyKE+X5311vjMzywr/fXJ0Foqo80Z0T1E8Vvly0W6zc7wGF30exbsu1BTr9IrzGcLfhAIAAAAAAAAAAEDv+AgFAAAAAAAAAACA3vERCgAAAAAAAAAAAL3jIxQAAAAAAAAAAAB6x0coAAAAAAAAAAAA9I6PUAAAAAAAAAAAAOhd/lw3wDUYmA2GO69vj/2fT3r+lpZlOi0N6mqa5fNEbc9FO6LyIkkiyhPXzcyaVpQl7vVc6nr5NgTaRvTFYqozZYVMSqoOjQjnhBpDPcfaahGU5/d7W813XpsHfQCztjnz31M1ap0E49yKdWJm1oo5r9bjudQd1l7UPhW3wuKi8kSa19dPJKnYGcUmnaQkQXmtavczQLdDzzHZR1E9ag8x0+MU6NIGnFmy3rKd1cuPQZdp2nXYutQVLdlMpEXbbprqRrStX2B0QhJZwnAchbu+ZaLx0Vh0OcJZUJ5qg5nu8yTRBUbty8WkqMTaaJ7NwbgIJWni7i/Vwl9lg5WBLGs+3XmuPEvtl8VAn68jaYdngCZYFKq8JDjHqT4yM8vUohDHOzPdvqLo9gxXLfzK8iJ4ngiWy2Kmx1dJg+djda5JVeC3bucu1Q9mcV9UC/H8JJown3HeebZEcT0Vm3NT6XmQRmffnkVxSGcK2t4hFqoWNIvlY6SZjpONeodj3eJxl/hpZpZ1GN8ube8yFmbneEbG0pY910TPqnmhX32reT+fzJbOY2bWiPc1XZ+lozOKkgQPN/Opf1/FoJR5VNvD9R+sV7VW5Jmro2icojnRZayi/UyNoZorZvE5PVWxWo7ThXOu4W9CAQAAAAAAAAAAoHd8hAIAAAAAAAAAAEDv+AgFAAAAAAAAAACA3vERCgAAAAAAAAAAAL3jIxQAAAAAAAAAAAB6lz/XDXDNF2bFfOf1YiB+fqrLSjOdlhf+9bYJ8gRdVteivFbnSRKdpkT31Ig2mJllIl8TtE9RfddVEnwPDcYjifqiQ3ltLdKi9gV93lYL93o6XO21vGS4svNaGcwFnFmvzpptxVgnTRAX0g7f86O40KWuKE8HbdS+KEZepJJUx2IVZ5pKr7EkihlCa0F5wRxTbY/aZ8H9qj1BtSFqG8zqurWq7rDPOqJhW4gqouGJjgyqrq47i2rHINc3tQgqa0SMqhtdXtZlqi6/VMJx6iIqLzpGqtvtcvTsKs+excoucU3dWuPEmqL0z+zzqfOs9TSkYiFVi0rmUW0wM6s7PIcUA11eI87yUfvyQj/fRfmWpdp2LrXYzxv17GlmqXrus277dnQuHJR+/0VDW0d9IW4rL/Q9eXP/ibQlz8jL/vylJk0SS5fYSMKxjnTYP9qen9e6TIVorSQdNuCmQ4xMg4NDVF5q/g1HebJ8+fcx0ThFbQ/HtwNVV9hHQftUrFZ9xDNULEkSd81k6kAfHPQXM/89mpl+lu46PsvOA7Nuczuai5EsL93rqt1m53g3pPJE6zw4o3ShzqaRxUyfg4uB30fq+fNcupz/onO6WgNZcJ69UBD1AAAAAAAAAAAA0Ds+QgEAAAAAAAAAAKB3fIQCAAAAAAAAAABA7/gIBQAAAAAAAAAAgN7xEQoAAAAAAAAAAAC94yMUAAAAAAAAAAAAepc/1w1wJemZ/54qTfyfL4e6rKZavv56+SyhLOuWLxH3G0mDuvLCv14HN+yNw7nydLnf8F47fCuN+qHpMMBBE5JM9KuZ7PM2aEO7mC1dV1stntY1/CUqzrSN++NtG5QVJCZibrdhgYFo7Sninsys2xqPquqSr1m+L8L+a4L7VeUFbWg7lNdFova4c4ja3olqR9/1XCKS1CxdYhurgiWUB1tbJoZtVnUbNzXc0TRIgznc1H5Gcfnr5ek0tY0mSXS/3daYovo8EoWuLse+LltJ3EdaLsdXNzzqIzX2g9zPVInrOCPNEkudDm8av9/U+cTMrKmDfa/DsbxaLP88lgUBL2pflz17PgnO3iIQRXu22pejesrRQKZ1EfV5FKuVJgj+04l/PZpjETX2i5m+p2g8ytIvT+5zdcdn90tE07bWLLH5dD3fds2nqNiQBu8u6mAdZcXyr9Ka4DlJnmuWOUT+Ra4OefQ6j2JGFHOjuKH0HZ/6rgvPnsV8YZbsfKel1sRiNpdlpcGZQs3hru8A1B7Wda2oeVpHZ7VALvover+i2t4tPnW7pzyIuSpWR+2Lzihq/2mCB/Uu7/fSsA3BOVjFanG987vHZwB/EwoAAAAAAAAAAAC94yMUAAAAAAAAAAAAesdHKAAAAAAAAAAAAPSOj1AAAAAAAAAAAADoHR+hAAAAAAAAAAAA0Ds+QgEAAAAAAAAAAKB3+XPdAFeWmmXZzuvVwv/5JPiWVgx0Wl0vd93MrGl1mtfmc5UXtb1tdFoXqh150W8bojyqj5qgj1KRx8xaMSeSaGYH5UnBOLVB2xMTfRvlyYLxSPlu3Js0OfPfMyyaH52oudg1Xqi4EJTXBnGwbfqLW32WdaY83e4knAt+n4fti8oT7YjaF1FtT7rEuqAdrYn7fRbW0cWsrs0qZ5mpboum1aRDOEkTPT5Nq+dcl2FtgjmsyiuCaboI7jfP/AKrOlhHyfJrrMuybFvdecFwWJY+O+2LxjaaLzJPcDSJhkOZVX4mdR1nqGNNvaj8n++w74X1B+UlHc6vtRc4n4a88B8CymEp80y3ZzIty/0gFbUvH/htUG0zM2t6PvMURb/PDM1MPIebPg8l6rnPznXu6i+PmVklYkee++VxrInlZWFFufN5VcWarrqei5fVWPBcHkyGRjxDRe1ORTyJJB325eg8FmnFuTB85OmwYLrkOdMO8YwSnGdjy7ejrnVnqLFKMz8eq+s4Y33PupXD9R3XTxw+4f682q/N4j27EWMarb1oznV5h9HlDNXtSV+3Lwvmo+q96FwT9YNay2GfB+WVI/+9fzXX+1Je6rYvxJkn6qOo7er5Koon0XO6twebmY1W/bNuFr1jfpYR9QAAAAAAAAAAANA7PkIBAAAAAAAAAACgd3yEAgAAAAAAAAAAQO/4CAUAAAAAAAAAAIDe8REKAAAAAAAAAAAAvcuf6wa4ZhOzzLk+GPo/n3k//DTU4npUXtPqtLTn7lTt61u10GmJ+E4Z9VGaLN8GVU9HbaM7L2xduvxcSqI8qh1Rng5tcMcwGldYM5tb48zVNO/Q/0kQF7pom+e8rjaIdUmwxmXTg/LaJrjfDlTbo3uKy+vQvo51KXGfL19XeE+y/8RcqZ6tzeriNCwTG5VPf1+saj2eRbTdiCGNZm+HaRBu8WmmE+eVX2CXI0NXaeJX1rS6z7u0r7F+13949Azap8ewW6en6kjYcQwXInSo9dIssY4uRd/yzRs2Wt214/r//OPT7s+Pt+ayrCQN4lDpP+8EyyikpmO0T5XDUqZ1aUcxKHR5YiENRgOZpxFtn01mMs9wRZdXln7wL8R1M7M62EumE/8ZIVWL3OI+UvlUP5jFZ5dcrPU0C8YpGPhCbJ7f8Mp19/pknNn/LUvDZVdfbuVwZ989/vAR9+ebuts5MQnmoxLFDVVelCft8J4pH+p3QlFfNB3O81mX59ZALc70XetJxSm0rnWf54Xuv0xMia7Pkp36XDXC9Hw58ML97vX5VLzfhJmZfdNf3e2eaz77OX8Mjh/xzztm8VgPBv6ZIlqvSXCWXsyWfw8XvYMaiDPPYq7rmQfnjUyssWjtVYtKpinRqlxZ8+d+VE/UvsXMP9OWwVktOteoMYzeyWTBfqHyDVZ0DIjmXyHm7De+esO9PhlfOM9Q/E0oAAAAAAAAAAAA9I6PUAAAAAAAAAAAAOgdH6EAAAAAAAAAAADQOz5CAQAAAAAAAAAAoHd8hAIAAAAAAAAAAEDv8ue6AX9Z27ZmZra5PfF/oGr861nWrcJF7V9vKp2naXVaLvJF5UUa0b6u3w679FMi6sqCNqRJf/WYmSUdykt1eUka9INMi8qL+kKkRW3oolrsuLQ53jazv1hXOOOJODOduelp3uM66aoVse5ZrKsNYl0SrPGmEnErmIdtE9yvyhOVJ9oQdWuoQ/vCvUJlqVXMj/s8GiuZJ+oMUZ4ap83Z/OtlEmv+srP9sbV5eql821Pdj9F2o6apOuqYmVW1rktNqw7TzczM5pWfMToyzDocn6J7SsV5oul57nbtI9UXUXlR/6l8eZdzmun5l3UrTs7NqvCvj7c2zYxY81Rn+2Oy7cea+VRcn+08Oz61TDet8R8fuw6LOubPv763+EqZotoRPU7Utd4TVV9klT4vNiIgV3Pd52mq7zcTi6xt9KZQB7FwPvWDaxpsMuqeonxRnmiOJeIVRRoEm2j+tbXfvsnYz3R2LRFrnuxsfyxmm276Yr7lXo/Ot5HwGVuInilUeVGetMP7k7bVr9iivmi6PDs0/b5TqMUzVNd6VN/GMXf5V5RdniXNuvV5Gpyh1HyZT0fiOucaT9dzjYpNZmaLYP9txfxugnkanSkW8+UfYNJgjaWJfzCO6lnM/XddZmaNWGOqH8zMKvWOJxD1X5r54xHVE7VPj694qDhH2kKckcP3YMF+ofK1rW5DtF+0rX8Onoz9sZ1eQOeapL0QWvF1jzzyiF177bXPdTOA55WHH37Yrrnmmue6GRcM4gzwzCDWPBmxBnhmEGuejFgDPDOINU9GrAGeGcSaJyPWAM+MCyHWXFAfoZqmsYMHD9r6+rolXf72C4AntG1rm5ubduDAgfBPNl5qiDNAv4g1PmIN0C9ijY9YA/SLWOMj1gD9Itb4iDVAvy6kWHNBfYQCAAAAAAAAAADA8wOf2wEAAAAAAAAAANA7PkIBAAAAAAAAAACgd3yEAgAAAAAAAAAAQO/4CAUAAAAAAAAAAIDe8REKAAAAAAAAAAAAveMjFAAAAAAAAAAAAHqXP9cN+MuaprGDBw/a+vq6JUnyXDcHuKi1bWubm5t24MABS1O+N59FnAH6RazxEWuAfhFrfMQaoF/EGh+xBugXscZHrAH6dSHFmgvqI9TBgwft2muvfa6bATyvPPzww3bNNdc81824YBBngGcGsebJiDXAM4NY82TEGuCZQax5MmIN8Mwg1jwZsQZ4ZlwIseaC+gi1vr5uZmYP3PPfbX1tbUd6tnu/m6+dTWSZyWCkK6wWfp5yqPOkmUyqzU+LPjRWtU5rGv/6om51pg6iNvT9kTTt8AcZmuB2i2z5AqM25GJ4o35ImuU7sJ1uyyytmJdmZkle+HlmO8s7vblpL3zFX31iXeGMs/3xmdv+lq0NdvZnKyZcW4sFaWatWqyBttUTOyxPtS/I09TBHF2ynjN1Ld/2KE+XNkTaDrfbRaK3g7ANMl8QnJIwzY8zSa4DV5rpxqelH2fS3D8ybM0X9s0f+o/Emqc42x8Pfe0B27Vr1470VpwnouX/bP7BpQ5hLRSdNWQbghCgzkJRuFP3VAfxOOqHSmQLtgurgzOc6qPo2Be1b64aGOiSJxrbLm2vxMBvjzft//XGG4g1T3G2P/7Rv3zAhqOdsebgo1tuvjQ4Q+eZDjaVmOBlEe05Oq0R5UVrJQvarvKpdptZ+CetG1HeYtFvkFzMly+vDgJeeE9i8UV5ilK/NlBHlOjsUg6iOdHvs24mzkO7dw/c67PJpv3zf3gjseYpzvbHd/+DT1sx2PmuZrKp38l0oeJGFsQTdSbuUs8586kXB4Euf6sjyqOeJ7v+7RFVXhY8N6h4Ymad/sR933/xJYpD8rk/CEFd2rey5sfP+XTTPvzeVxBrnuJsf/zdn/kzK4c7++bQg8fcfNG4ZYWew9H8VsqRv3+Y6XlflHo9DIbBs7mYc+VA78uDQVCeOENFZ7/VVb+8PNedHryKsDzz8w3L4JmsDc4Uoh3RM1mHEG6FaLeZWdVEsdq/PlvoPP9/9v483rOrrvP9P3v6DmesKZWqDGQmEJIIaPBH4GEIpFsMKrQ2NkP3lWs/rr/E/ondjQgPFFQENNhIy7UHO9p2X/qKAvoAL7RMIQnXjsEYiAxhCEnIXFWp+QzfYU+/Pw4VUnXW+1P57rNTOSf1ej4e9Xgka5219vqu4bPW3rtOfZeHk9c3PxP+wIOlBftXP3XOuog16+ol1JHNcnZmxuYCnZMEHuKYmdUj/TGi7pS+IC+hjtsGXkJ9r0zbL6GcG7lmL6H0vORXmI92pD9mupnNdjur8vVLKD3OjV5CNXiRY2YNX0I1WMjr4CVU3TDW1XG7MVKJnPjjtUGV8+pbFy+hMv/IQKw52pH+mJub4yWUnbiXUE3OVY1fQqn6vDLr/CXUKF+/L6GOINYc7Uh/9Ppz1ptaHWs6PfUg13kJ5ewfiZj4Hefhynp4CaXabebPKVVflLT7N16iuMFLKGfxeecG1efuSyjnYVeTl1DeAzJv7JtQ87nnPEQ0I9Yc60h/ZN0Z63RXP6spxg2e6DnUWXW9vIRKTtRLqAYvUbwyHlWf91l5CXV83V743ur7dRJrHu9If3R6s9btrT7XZN1xsJz3l3wT5z620UuoXtsvoZw9VhRr+hJKnaG8s19vKlxf5r2EcrpVvYTqr/eXUM7nLcrJXxolzkuo2nvWJOqbmvbPkush1vAPjwIAAAAAAAAAAKB1vIQCAAAAAAAAAABA63gJBQAAAAAAAAAAgNbxEgoAAAAAAAAAAACt879l/CkSpZlF6eov76tHy6KA841izhclRp1eML2unC95DbTrCPVGr+0v925Kfc+z932RrX8xuWpDw+9HK6MGX1zrfVGvqs7pB/f77EQHevPInPlX50PvaphAXdXBLyOtG0x69aWmfhnnOk59qpz3RZwu9YWsDdrglaudL5n28hT1pdpNeW2I1JdCNvxO8rjB3//wvlRX5akvdDYzizs6BqXii7qTbieYnjX5Vs+TSRwHN9rIxJc/V7muy5v2cbvjkIjDQW3OHtrgy1/d8OnUl8kva3W+0FYVcb5I1mJdn8pqGBoaqRrE/rxhA0dFOL1w4mcpO11/qa764uHSGyfYnt1L1u2vXmgd54uwFe9Mob642j8+6cyO+PLsfOzcw7k3DuFyaapve4tCX6sU89v70m9VRqWb+V92L7/QuuX9t9PR9bnnENF470vO/XaEy6kvezdrdg4+dGgUTB8NwulYMVgYWDFuZ+55Z9UkCY935MyDWJQxM4vFHG5eX4PzfNvbWINh8Nayuo/zyqROHFLlVMw4HtUM7yzZ5DmT/3n1uPf64X2m3wv30XAwnqxhJ5m9Dx+yrLt6fy5ycSB1NJlzaabPDflI369lXXWf3WwPi8U9Xpo2m6ddMR97XV1frxNuX5rodstuMLNOqurTZbx7PNUOLzY44V3GDe8eqnDy8iJcoVfGy1P2Hgp34GB5/Tyv4TehAAAAAAAAAAAA0DpeQgEAAAAAAAAAAKB1vIQCAAAAAAAAAABA63gJBQAAAAAAAAAAgNbxEgoAAAAAAAAAAACtS5/qBkwkSsLJsfMurSp1XjoVrs8yWaS2SOYV4lIq/Xjysg6mV5UuU4WLuLz6ynryNjThDaGnqvV4yGtFupNK8bm6mb5OnITnpZlZVIyfcLseV6GuT6TX3jxHUBRHFsWhHp18MkYNFkTd8hqqGwaGSgSo2ilTi9jkKceTz1HvOl5elIRXSpN2Ny2n2mBmZmKJe2XiVMeFpNsJp/fC6WZmSb87eX0q3YmBMLMiX/nzZBP7gLc/RM5+o+rzyiTOZi7PT14sbHC8C4b149QXO0u8XAfbqxvevTOcyBvn+gPnzudVeWWlO121wcysEuXUuXkwnvzMdzJJ09jSdPUkL8Ueljh7ThTpPFXOuwdx16WQZs1uDrrd8H1c6UxG71rdbviDjcdOfWm4zGikF1g65dx/ivsx76xWOnlpGn4E0HROqNAfmo+PlUmcPHGp2Glf5ZzV1BoI3weY1dXGekRyopVlaXEgUKtnMmmm+zNx5oGqz5s7iXNeVnPYLyOz5HpR8+p4vDU2qYZNkG1vsv69ck1jjYqFHq9MloXHPuvoDzXlxOqZmXB9U2IfGSzpumBW5IVFcbEqXcUG73mIey/d4F7Wixsqrnlzu8m5y4ufHWcOdzvh+jri7GJm1s3Ceb2OLuPlqfr6znNXp8sbGTiPagtxhqpy3a95odu+PJrsnsdM3yeZmcXi5jVR6c4z8BON34QCAAAAAAAAAABA63gJBQAAAAAAAAAAgNbxEgoAAAAAAAAAAACt4yUUAAAAAAAAAAAAWsdLKAAAAAAAAAAAALSOl1AAAAAAAAAAAABoXfpUNyAoSsziZHV6OQ7/fNzTdaWZzqsqUV+zd3OqurKqdRmdZUU52XXMzPLSqbBBG1ReHDWrTykLnZc4w1GIz+u1L0t0pm6796F0fWnaCWeMB7JMXeTOtUSZwKQIpeFx4ig4UWq18ByREzOqBvV5Y1fXYi46C69usChrJ5Z4eVUZbnuT+qomwcRM9oXXhiYiJ5YkTp4ql/T0fpV0RSwxs2y6Hy7T78oyaV/vm6koF4v0zmAk64JWV5PHBvcAoDjxqUkbnO3VzKkvEuex2D1Q6Kw0cEz83pV0dQ3ODEnk1Be1G1MUddYxMxs556dxHi43EOlmZnmhP29RhvNE2P9eGZ1XVuH61DY3zt3Zd9IrisqSYvVgxCIGRM7c9qitudNxzkLOft7phBez1z511jAzS7NwO6rKiYVq0plZKdZf5AUOIU3bbYNXxus/leedXbw8eR2nj7y+aHIt1UdmZrGYL032BJglSWKJ3oRbo+aPd26InQcHichzz+zOtZIGE8Wtr8kaE2u54eMsWZ+3Xr3P1PZaavJsKhN7jJnZ1FT4cejMtP68c1N6/5nphw89s/1ww5cWG9wLQK7luuGEU3PY20e9WKPqa7rHZuJ81evrud3r6fbNiPnY6+h9dLoXnvdd53H7XPgRxffqC7ev33HODQ22naWhl6vX8oGlcDuG4pWEmdnySLfdu79S0sQ5O2fhvI54w5M0fa72JOA3oQAAAAAAAAAAANA6XkIBAAAAAAAAAACgdbyEAgAAAAAAAAAAQOt4CQUAAAAAAAAAAIDW8RIKAAAAAAAAAAAAreMlFAAAAAAAAAAAAFqXPtUNCIni2KI48H4sToI/X1eVrsu7UFUGk0sLX8fMrKqd6kReEb7McfPKOlyhV8ZrXym6qSh1odAwmJk5Xe62oYnYGUTVvjjShSrRr2Zm3TRczuvzxHmVq9qeiLlsZmZppvPEnG25y09qwdhjfpzx6wtPgrpZdY3a4ZWpxYKtnbhQqWDilHPra9AGL0+XcfYKZyFHSXgM055ex9m0XsdpvxtOn+479ek8VS6d7skycU/nRT1xrW64TNQZyrpgVlel1aHY3SSmiD1g5Trh+lRMa6qOG8ZCle7sh4nX9ipco3dmyMRaHrV8cPHOBd55Ihd5Kt3MbGmo2z4uVLrupNzJU20vSl3GCbtWijFURvlkP3+ySdPY0nT15AulmZmVzj6adfQkTsQEd9de5qxzsS5V+veu5uSFqfPY8ZRiElelboMK71WmF0ReTB5b1Vgcv1y4LyLn/inNJu8/737MGw9VrHD6KHW6rxBxTdVXFvw93SbU/PHGOk692CBiTaLLxM65Qc57p30qfnp5fuzSmpSLG8TjJp+36WdS+0ztPI/x9qaOaEd/Sj/WnJvR82V+OhwD5qfFAcrMts3pvtg2G87bItqwcHhdPo5dN+I0CcYI9fwi9uZ2Nnlfe/U1iTVePMk6ep52RF7HOVv1OnodTffC877f1WW2zITT56f0Z9oyo/tvuivWcse5R3Fiw3AcTh/n+nAwEGXMzAYjcc/Y8F6km4Xbnib6Mznboxyrvhj35ajhw8cnAScsAAAAAAAAAAAAtI6XUAAAAAAAAAAAAGgdL6EAAAAAAAAAAADQOl5CAQAAAAAAAAAAoHW8hAIAAAAAAAAAAEDr0qe6AUFxsvLnWFEgzcyi2HmXVlX+dULJXnWlzsvLWmcKZa3LjAtRxvlIRYM2jMR1PF63Vs5naiKOIp0nxiqJdBuqzLuWuo5uQ1k516rD5RIx91YupidZnQ+D6aE14K4LWBTH4T6Kw+NZO3N+PaideejlVePwB6ucQFM7cabMw+W8Ml6eLjP5gESJXhNxR+d1psNBI5vpyDLZ7JTOmwnnZbPTjeqL+/1wRl/XZz1Rxsys2wunpyJ4ZgNdF8yKfOXPE1R7G2ztHELEAaWunf2mCad93r5Ti7NG1PAkGqsznBNO1BnO2y69+kzU550HvTPX0ihcbmmo61sa6frGefgMMhLpZmaFM8WKMlzOC8fekdDZmoKanFdPJnESWxzY51Q/p5me+ImzX3bEfhknel559aVpuFzqhC6nOouce4AmqmryGKr63FsPTdZKp+U7eW8tO7djUtNbQlUuSfRYFMXkF0vEnK3LlvfNp5koMosCE0KdAbx7efc6or7ECQ5eHArFRzOzNNUBJct0faqcuo6ZnnNeXqivH7uWyPLiu9tH4lre850i13mxisfOZ+pP6cA2NxMe+y2z+vCyeVafwc/YGq7v1Dndhm1zMsuqhf3B9DoPtyHKF3RlsLqqg88x0mzyzc9bRyqmuGvPWUcqNqjz00oZXV+3G25fv6fX3nSDvG1zug07NoXbvlOkm5l1E70uq6UDwfR6Ua/XzvS8ri8LP78YjHU/DJ3bc3l2do4HvY4+RKkp20l1+7xrTYnHUKpMuo6eZfKUGgAAAAAAAAAAAK3jJRQAAAAAAAAAAABax0soAAAAAAAAAAAAtI6XUAAAAAAAAAAAAGgdL6EAAAAAAAAAAADQOl5CAQAAAAAAAAAAoHXpU92AoKpc+XMs8cqsrnRVUZzoTJFXOfUVgWYdr9yoqGWZcaHry8twOa8NuZOnFOI6ZvozedepdHVWeZlC7LwqjaNweuYMu5ko5JTLnDnR4CP5H8qbgJH6YA0GHmFiUkXOmNXemK1zVRlue+3EhTLXn1eV8+qrRRsqp0yc6HUcd8LrJMn0GHbmOzIvm+6JMjO6vjmdl81PB9OTGV3Gpmd1Xj9cn3XD7T5eXtTth9OzbjA97i7p68DqqposRtTeBqvz5DW8azv1KVGa6TbUzubbIE5GzilVxeQ4cmKDyFLpx1OIjzTOdZmloY5rC4NwhUtDHbuGY32twTj8wca5/sBFqfNEqLa6yTnIoYawKBoO1EmirmqrA4fSVOx9zlKxTkfPuTQN56l0M7NMhw1Lk/AESpyjcuqEmiQO1+d9Xm8Oq/Z5ZdR9Ul3rRqh2m5llIhbGUbPFV4l2ePeY3udVcUPFjOPVp+6tqsrrP50XReHJlI/DDYy8yQIrq9riwOCm3v2tkDgLXY2Ddw/gxSGVlzj1Zc5DhUzESe8zebFVfS6vvjQNl/FipHfmUWu2cJ5ZpalezEkSDl4zfV1mfloHjh2bwg05b4f+wKdvcs48u78bTC8f2i3LDO/W9z11PgpniBg0XlyWdcEs62aWdVcfIJrE6MRZFKq+1Fn/XtxQ6zx21nK3q296VKzpZnodTfd03ra5cNvP2qbbt2M6PLfL/Xqt5IMFmafuQaOueK5hZtH8KTJvYTH8eQfjZuck1X/eWW1KP06SMbnfaXbemHS7rZ17vxON34QCAAAAAAAAAABA63gJBQAAAAAAAAAAgNbxEgoAAAAAAAAAAACt4yUUAAAAAAAAAAAAWsdLKAAAAAAAAAAAALSOl1AAAAAAAAAAAABoXdp2haPRyMzMut1u4zrqMre6yFelR51k8spi5z2byKtKXSQva5k3KsJ5g7Gur3Drm7xM4bS9rCavrxJZuXMdr75Jr2NmFkc6s5tG4YyOSDeztMH4dpyVUlX6Wk6hycuYmdVO4zGRKIosilaPnZptUazHuXaGM5IxqN2xrJ05VY11Xi3mfJlPXmblWu19rsSJ+WlP52UzWbjMdEeW6cxOO/VNhctsntVl5nSezc6H02fmdJnpGZkV9cPXiqd0G2JRxszM0nD/KUlncaKfP+nUVTh2i8OGt5YtcDb6frmW9wdVn9c+98zV4AzniER9sXOdWISuSpy3zMxGuY53g3E4b2mkyxxY0v23OAj339JQ7z+Dkc4bjsN5Y+czlaWeR2qvi7xhD+yzR6RpuGAihrCe/Hh5UkmSyJJkdX+rfnaONRYH6jlCnYe6eou1LNWDp/K8s7dXXzcL5yXOPPXymlD3NV6fp0mD+x2Hdzum4tqyE09yJ04uj8LpoXP2Ed49qzqMxyqIr1xN5oTWhZlZnYUHPhXpWBFHkcWByazOL1HW7JGTijVqPI+Xl2XhvCzT54ZeX7e90wnPk8y7f3HWsop5XmxQeV6M9OJQk9jVETHXzGy2H847bYuu8LxTdf/1B7uD6fn9d8oyy19+RObZ4qFweuEEPK8zMvEMtNcPJtdLA10XLE5iSwIbdKwOio4kdZ4diLWcOGPt7ROdbngxd7terNF5073wOpqb0vcUW2b0ujxne/ha2zN9T188eE8wvRotyzKeSNw8xPOnyDKLY93nS6NwX4T2qiN2bJJZNt0Nl5vu6fqaxFaPen5vps+t6t60dJ6Pn2itnLA++9nP2tVXX22bN2+2qakpm5qass2bN9vVV19tn/vc59q4BAAAAAAAAAAAADaQNb+E+u///b/b1VdfbfPz8/b+97/fPvGJT9gnPvEJe//732+bNm2yq6++2j74wQ+20VYAAAAAAAAAAABsEGv+5/je/e5327//9//e/tW/+ler8t7whjfYi1/8YnvnO99p/+Jf/Iu1XgoAAAAAAAAAAAAbxJp/E+r++++3q666Sua/7GUvswcffHCtlwEAAAAAAAAAAMAGsuaXUM95znPsj//4j2X+f/2v/9UuuuiitV4GAAAAAAAAAAAAG8ia/zm+973vffbjP/7j9qlPfcquuuoqO/XUU83MbPfu3XbDDTfYPffcY5/85CfX3FAzs7rIg+mR9ymqauLrFGWz6saFqq+WZUaijJnZcBwulzvtG+f6WqoZ3mdS16r1ZaysIp0pVE59ifOqtBINiZ0yWaLzijLcdm9OdJ35J/s2cxroNT5SjXcaiKAoji0K9LXq/crp41A9R9RluJxbxhtPsVhqZxFVpV7kZR7Oq8ZOmbFuXy0CTZTouJD2w4som9aLqzPb1fVN98L1zU7p+uZmZF53y3wwPZqdk2VsbrPOE+Xi+VNkkWR2i8yLpjeF6+vpz2tJR+dNKEkPt1bX01JVrvw5hjrTeJtyXYyd64TL1bUXTybfO+pStNvMoiTTeWl4zjnbvytKxbVivckPxLlKpZuZLY2cvGE4b++CHsOFZR37D4u8paGOn4OBvtZIHDLHTgz3xHG4HWmqP1PW0Xml2LcicR3vrIiVfgv1nehOi50DtjumqZgHiR6gLNV5/U44r9/VZbo61Mhz/qZpvY464jN59aXO/cR0d/J7oW6my6gx9Bxc1v2351A4biSxE7sGek50RTHvHthMfyg1NZ3jrMXR5NeqxT1r0qTDTyJRZBZFgVjjLYoTJHHuNzKxmLs93e5ud/K8nr5FsW6m52lPxEKvjIqTU04bnC6ScW26pwttn9OxYefmcLn8wW/JMsUdOm+0+6Fwxr49ur6FRZlX5eFzUpzpe9BkZlrmRfPi/q8rBqSe/FnlySROEouT1ZMyERM1dia3FxvUmccr05/SB5GOOPtOTel5Nd2XWTbTD6/z2Sk9f845VV9rexZeE/nD35Fl1LMr796vzocyz7rh5zWxeK5hZrYw0LFQbdtnbdPxadO0zutVS+EM59456unYsDgOX8t7zuzxHhkHr9NZP+eaNb+EeslLXmJf+9rX7D/9p/9kt956q+3atcvMzHbs2GE/9mM/Ztdcc42dffbZa70MAAAAAAAAAAAANpA1v4QyMzv77LPtuuuua6MqAAAAAAAAAAAAPA2s+TuhAAAAAAAAAAAAgGO18hLqP/7H/2hXXXWV/czP/IzdcMMNR+Xt3bvXzj333DYuAwAAAAAAAAAAgA1izS+hPvCBD9ib3/xme9aznmXdbteuvvpq++3f/u3H8suytPvuu2+tlwEAAAAAAAAAAMAGsubvhPrDP/xDu/766+11r3udmZlde+219qpXvcoGg4G9853vXHMDAQAAAAAAAAAAsPGs+SXUvffea5dffvlj/3/55Zfb5z//ebvqqqssz3P71//6X09eaVWt/Hmiot7k1zCz2qJgelnVskxR6vpGebjc0kjXtzTUeYOxaIPTvqoKfyYzs1J0qVOd1SKvrie/jifS1U00FY4Y5TovTZw8US5NdCd1U934vAyX62S6TJR2ZF49Hsk8TCiOVv4cIxK/IOr92qg3RWsxgaPAtZ+IWizYaqxb0SSvGBQTt8FMf660r7eb3uZuML0z15dlOvMzOm8unJfNT8syyeyczLO5TeH0WZFuZvGmbfpaW0+bKN3MLJ7W18rrcFAbOfuVt88lagxF7Cxzvl7SU1dVOA6I2FAXYvM3s7p0NrfxcNKmWV049Smxt4lmOk/GwobzR7TDO1cdWhbnNKfM4YFXX/gzLSzrz3RoSecdXg6vvcUFPU5Lizovz8NBwDtXecORZeE+j/p6P0uda0ViW0hEG1Q6VkSRf56eRJLoijIxbr2OXiuqzEq5cPqMc3u3ZUa3b346nLdpSk+gWW8Ol4Ngej1almWqw/vDGd4CE/FkpRHh2Bo5MXf+lNNlnlpL40KPobrPNdP3i96a7aS6vlLcz3r3mHnhTf7wtUpxD5eu+QnJ01tdm9Vq0EM/797M6zNFIiZQ5AQ6L3alWbi+NNUTtdfX7ZvqhvugL9LNzGb6Om+2H+6nM7fqNmyeCbd9uuvEcKePuplYKwd2yzLlvodl3vJX7wpn7HlE17db5y0/sjeYPtx7UJbx5l/aD2803S36vnB63rln7IfvNeNt4Xu8uLek64J1u6l1ek88IGcdvVa8da7ihlem39PX6oi8afccoufp3FQ475ztug1nTIfPLmZm5b7wevaeRaj7tWrxkCxTLeyTefHslmD6MNbPa6pa99G22XD75ipxHjOz4h4Rn8xsNFgIpnvPZNKd+muIulNbg+l9/ejXkko/E1Dnwljsj0nZ0g1CC9Z8xNq2bZs98MADdvbZZz+WdvHFF9vnP/95e+lLX2oPP6w3JQAAAAAAAAAAADw9rfnvFL74xS+2v/zLv1yVftFFF9kNN9xgf/3Xf73WSwAAAAAAAAAAAGCDWfNvQr31rW+122+/PZj3nOc8xz7/+c/bX/zFX6z1MgAAAAAAAAAAANhA1vwS6tJLL7VLL71U5l988cV28cUXr/UyAAAAAAAAAAAA2ED4il8AAAAAAAAAAAC0jpdQAAAAAAAAAAAAaN2a/zm+J0M9Hlk9zlZnpIE0M7N4KOuKVBkzi6yetGmWl7rMqAinD8a6vsMDnTcW9dV1JMvkhc4rq3B6pItYLPIqp+tqJ09dyyuTJk6eKFc5FY5zXV9XrIiidPrcmROxGI9uqduQOeMRxeH3xrV1Vicmeu7DLE4SiwOTq1aTu9ID477NDwyNmVk10vNGjbOnUgvczIqhnnD5UnhBlGNdn6c7F553U9v7skxv63y4ri1zskxn06zMS2ZFOZVuZja7SWZF81uD6enW03QbnLx6dnswff+inhOH9zrjWzoBRVCx3cysK4KQKrOw0GyunOzqInw4qEtnkxrr804t8tz6Kj12qn1RKoKamVnW1XmKE++i7rTMGxThw8FeZz4eWAznLQz02lt2znCLg3DbDy3pz3RgQdd36GB4DBcO60YMB+KwaGZFEf5c3rmv29WHrrjB3hQ5RZIk3BDVPq/dWDlLh46/6ljTcQ6ctRPW0yRcoXden+7pCqe64fq2z+sKt8/rtp86HV4T+cPflGWqhf0yb/DoQyJjSZaRsTXxbmqce9a5zcH0eDp8fjIzy5z4OdsLl5vu6n4d5TpOqjmRxLqMdy11H3fQ6fLDyzrY5CJMluJs7w0TzMqytLhYffaMVceJWH886nbeO8NGzkaRpuE54u17vY4zh3vhvE0zOt6dvkW376Izwuer9OADskz56KPB9HqgDxvqfGdmNhgth8ssHJRlbP9emVWJvMEeHXOXHtgt8xYeCH+ukXNO6m/ryby5s8N93tu2SZaxnc+QWdmzLwumFzueE0yvDx/W14HFSWRxsnrdqrWszpVmZlNT+tF3LMp11cNBM+t09J4zOxOub6qrY8PWOZ13zvbwtS7YrO8Li706bsSnPSuY/sA+3YYzt4rPu+zEmnwk86JOeF0uDZ1nq07sn6sPBdPH3/57Wabadb+usAo/X6l36PWf7jxXVye6Nl7cJcuM9z0s86LeVDB9atOOYHpRrJ9Yw29CAQAAAAAAAAAAoHW8hAIAAAAAAAAAAEDrWvvn+J73vOcFf/05iiLr9Xp2/vnn2xve8Aa78sor27okAAAAAAAAAAAA1qnWfhPq5S9/ud1zzz02PT1tV155pV155ZU2MzNjd999t1122WX2yCOP2FVXXWUf//jH27okAAAAAAAAAAAA1qnWfhNq79699qY3vcne/va3H5X+rne9y+677z77zGc+Y7/+679uv/Vbv2WvfOUr27osAAAAAAAAAAAA1qHWXkJ9+MMftttvv31V+mte8xr7wR/8Qbv++uvtta99rf3e7/3eceuq69LqulyVHlXiF7eKXNfl5EUiL0s6skxR1TJvOA7nHVquZJnlkf5ltMFo9T9vaGZWrO6ax+WFy3jiWH+mRDQvdi4T+FcZj5sXR7oNtc6yUnRtWelGjApdYTwS6c7vDHp9oXSclZf2EudiIq8MzOVazzuYRUliUbK6PyPRxXWpF17tTZCxSM/0PKy8Ra7aUOr6ikExcV451vOnv60n8+bOng+mT+3cpuvbviWYnmzTZWxus5O3KVzfpu2ySLLlNJ23+dRg+jibk2UeOqj7b993w31+cEmPYT75lLDEie39jg5cnTScp8osLjpBGmZ1aVZNMIDOz3pnmmq0HC4zHur6cp1nKuYF4uYRUaZjQyz2pKQ7peub2STzHngk3L5dB/TaOzwIp49yvR5yHT5tYRCO/YcWdZlDB8VBw8wOHQxvGAuH9DgtL4TH3cysrsJ90el3ZZk00+OhJIkTTzI9X1KR1UnDMaVMiDWesqytDJwFOln4571jorPMLRPjkzrj0+vovNO2hC/2zJ26EfHBh2Te4EtfDqbXjz4iy9SP3K/re2RvML0a63ic9sOxsLttkywTbd8p8+qOuDedDZ+fVgrpvaQQY586a3mbPvLYttlwLNw+r8/HyeCgzIvS8KR9cKkvy/zDd/XnPbwcboeal3VOrGmiEueGyLlZrpxnK4pXn7cfqbxeT8/T6Z4OlHPT4bxzTtX1PXt2n8wbffnvwumHdBk7uD+cPnDOBoMlmVeNw4eefEkcoMxsfHBB5uXijDI6qNuw+LDOG+wNn4dmTpuWZbY8W9/jzf/As4Pp8UU/KMsUz75K5v3tPeH+u/9vw2tjsNTgBu8kknVi63RWrye1ljPnzNntOmcK8dBzbk4/tFNnITOzualw3o7NOp6cuU3HjWeGH0VY/vADssz+2WfKvP91W3ieqvO3mdmWGfF8wLmX9O5BY3H/t/+Q7qPprrOXLB0Mp+95UJbxzn7RTPjQk8yfosvMbpV5neXDwfTB1/9GlpHx3cxseiaYXEyH2z1a0nvCidbaP8fX6/XslltuWZV+yy23WK+3chCvquqx/wYAAAAAAAAAAMDTV2u/CfWLv/iLds0119jtt99ul112mZmZ3XbbbfZHf/RH9ra3vc3MzD796U/bc5/73LYuCQAAAAAAAAAAgHWqtZdQv/Zrv2bnnHOO/cEf/IF98IMfNDOzCy+80K6//np73eteZ2Zm11xzjV177bVtXRIAAAAAAAAAAADrVGsvoczMXv/619vrX/96md/v63/HGQAAAAAAAAAAAE8frb6EMjMbj8e2Z88eq475MuRnPOMZbV8KAAAAAAAAAAAA61RrL6Huuusu+7mf+zm75ZZbjkqv69qiKLKyLNu6FAAAAAAAAAAAANa51l5CveENb7A0Te0Tn/iE7dy506Ioal5Zka/8OUZdNXiRNVqSWXUchzOyjiyTl7XMOzwI5x1aEtcxs8WBlxfuw6KQRaysdPvSNFxfN9Nj1euE6+uk+jpJrPOaTAuvjMqrdROsKHWFi8Nwujfux/zS31HUFOt3dBv8+kSFURJI03MLZlEaW5wG+k2Q8eJ414nDYx059VWFjnWqvmKoy4wPj2VevhQOKHNnzcgyWy/ZKfNmzz4tmJ6edrosY6eE60tPO08WSXeeK/PKqa3B9P2LenEdWNRrfP8D4XKHllfvU0ccXtZrfHkkxrDUc0IMu5mZZSIeq/htZjbu6bz5qXDeXD/ciOyJL6OTU1WFA7sK9s4mUJd6zoXOTWZm9VCfg2y47NQnDhvOplz3pnR9velgcnrKmbLI1x/Uce27e8S6dM5cS0O19mQRq2v9eZfEuW9xQcfcBSceLxwKH0IO7T0oyywv6DGMxVjNOXtf4gSbTifct92urq+rj9QyRnWzcHrsnMVgliSRJckTP2h7x0Tv7w5WlTjXRHp8+s69xrbZcF68/wFZZvTNW2We3fX1YPKhb94ri+z9hwdl3uLD4RjandeTe8uztoTTp3uyTOrE1qgTLpdsCZ+5zPRZyMxs/57wAC+N9Bies11PmE0Ph8cjv+VrskzufN54R/hfUDn9mT8ky+zZPC/zRnn4c+Vim/PuZWFW5oXFkfNA4hjec6HSy8vCj6qKwjkvJzovE3uYd16e6eu807eE2/7M8VdlmeFNt8g8O3QgmFwcCKebmS3v3hdMHx9YkGXyJfHAw6HuP83Mkp6Ohdl0+Os4Zs7U58Xp07fpdqThMZw7/yxZJvnhl8m8R7a/KJj+d3fps/gjn5VZNhDnTLU3D537RaycSUN9l4mbz25Pn0ezjs7r9cN5/a5e/7N9PUdOmQ+XO3Objk8XbNX3B4Pbbwym7z/v5bLMR7/gxNYy/HnP2uE8TxK3oN4X7iRb9Rml6M4F0+/do/thfkr3386dm8IZ45Eskx/UcbJzZvg5VHTeZbJMcc8d+lp3/0Mwvb73LllmtP+QzOtu2xTO2BQ++9XLk8f9J0trL6HuuOMOu/322+1Zz3pWW1UCAAAAAAAAAABgg2rtVyUuuugi27t3b1vVAQAAAAAAAAAAYANr7SXUddddZ7/yK79iN910k+3bt88OHz581B8AAAAAAAAAAACcPFr75/iuuuoqMzN72cuO/jdX67q2KIqs9P5xcQAAAAAAAAAAADyttPYS6sYbw1+WBgAAAAAAAAAAgJNPay+hrrjiiraqAgAAAAAAAAAAwAa3ppdQX/nKV+ziiy+2OI7tK1/5ivuzl1566ROut86HVo8DTYuTcIGq0pU5eZWorzs1K8tkSSTzlkfh9L2HRLvNbO/escwb5+G2FyLdzCxx2jc9kwXT42k9DbIGMyR2vmksEXkqfaW+WuZlomu9MkWp+6goVBlZxLJEX2u6F76WV1+lq7NEzNm6DlRYO+sCFmepxU0m+KTX6YSvUWVisplZ7cStYmkQTh/o+kaHdZzZ/txtwfTTrrhElkmfdbHMy559WTC92vkcWebbj4QXxH2P6n7Y/7AOGouD8CISXWdmZkWuF14tsrxY7K3jsgyXi2Mdm2ZmOzJvy1y43Py0bt9pm/W1ztkejjPz0UIw/XCyJOuCFozbZmaVs0EUucyqRmIcRkNd36EDOm9Z1Odt8pvD8cTMrPOCq4Ppf/MdPRcf3KsX0r7D4dh6eEH3Xz4Ox0l333XOVUURXmNLi3qclpd1rB6IIDVc1MHLy+v0wnEjjvRn6k+Fz4pmZvObusH0zfO6vtm+Ho+OuFQ3Cw9IN+Jc4ynyypJ0dR+pOVyVeuJXqXeODqc7W5g8D5uZnTodXhPLX/2iLFN/4x9k3qN/97Vg+j2f/K4sM9ir42RvS3jebzp3TpaZPn17MD3dHk43M7NTdsis9LTzg+n1trNlmbt36bV3757J19IPn6ljzaFPfjiYvv9rd8syWy4+T+Z10nBwqJ+xLMvM9jfJvCgKz+cm96XQKnG+LUzve55MfJ1DketnK/lYz3u19/U6Ot7N9vVaec7C3wTTD3/io7LM4gO7Zd5wX/jcVY0nX69p33m+MxeOaWZmnbmZYHpv2yZZprfjFN2Qnc8IJsc7wulmZtkZF8q8Yu70YPptd+tz17ce1PPlwLfD6Umiy4hbezMzm50OlxNLw+rC2ThhaRpbmq4OyFknHKRDP3tEt6vHVMUAb/2fsU3Hje3z4Xaclz4sywy+cJPMe/A5rwum/+kn9Lzfv0+fay68UJ9flK8+EI7jlz9TP+MZFbqPvnlvuL77dnvPpnV922bDz/BP27xVluls2STzuv/oDcH0hw/oObH5038u8xbveySYPtx/SJbpbZmXeV0Vk7u9cLpz5j/R1vQE9rnPfa7t2rXLtm/fbs997nMtiiKrA0/r+E4oAAAAAAAAAACAk8uaXkLde++9dsoppzz23wAAAAAAAAAAAIDZGl9CnXXWWcH/BgAAAAAAAAAAwMmt1S9Eueuuu+zGG2+0PXv2WHXMd5q84x3vaPNSAAAAAAAAAAAAWMdaewl1/fXX27XXXmvbtm2zHTt2WPS4L36MooiXUAAAAAAAAAAAACeR1l5Cvetd77J3v/vd9pa3vGXNddWjgdVZvDojDqSZWZ0nsq5oPNR55TicUZWyzPzUaTJvaRgF0++4Y78sc2jvYZk3NTsVTO9Pd2SZ6elM54l00a0reeGP5JZJ9XBYmtTB9MwpE8fhMmZm013RQFPpZqNcX2tRDH2lmyD7yEz3hd9HOq8eisZHgUKRM0iwKEksCnR2JCZ35A2019eqnDOp0umezKvyIpi+vPsBWeb8f/Jsmbf9V94VTP+r754hy3zlWzpGPnjbQjB94YD+3sB8FI7FVVkF083MCtEPK/U5i1zwxlfF4un5GVlmdlO4jJnZ1FR46926rS/LnLNT98UPnR+ef2em+2SZ8Xe+JPPqbz4STB8shverwbLeZ6FFSXi/rs3pT2fzjeLw5lHn4qxjZibG1Mzs8DfvCTch00fHrf/2f5d5f/K34fXy8G4dT5aWdNvzcbhcUei18vi/IPV43plGlfGUpY7vSaLryzrhOdGd0nuCFwtjcaDYsn1Oljn7bHVaNDt1c7jPN8/oPp/u6c/bFVMpTcIDstjlXOMpyzo494o8PD7e3M46+jA6LsLlRrmuT53/zczyXeFYM7rl/5Vldt/6TZm3784DwfTaOXclHT23tly4KZg+c0Y43cyst31zOGNKnxuSzTtkXrr97GD6vft0/Lx7t16XD+11bjaE4XN0bKiKcDsqMffMzJJ+V19sNhyjks2nyiIL9zs3a2hVkRcWRav3HnUPlTqPnArTe9hgcTBx20Yj51rifLBlVtf3oq/+nsz7+9/4i2B6Z04/j0n7un3z54bnff8sEU/MrLdtUzA9E/cuZmZxT58poq3bwxlbtskynfOeL/P2zZwXTP/SPTp2PfpVHY+ne+H5MuWEk9O36WttnQvvW4eX9X52aEm3bzSeLA6Nc+KWJ+skwfNILO7b01SPTc+ZI9O98DjMTunx2bFJX+vsKPxcZvS1W2SZL53xGpl3tzjyLBweyTLjkY6td3w5/IzAO/up5xdfvkvHtL7oVzOzQ+FHRrZ3z5Is451bl4fhM8rLfuCfyjLP+hE9hv/nJ8Nt//9duSjLPPCVu2ReKu7lZs7UZ7+p88+ReXZGOC87/YJw+oJu94nW2t3cgQMH7NWvfnVb1QEAAAAAAAAAAGADa+0l1Ktf/Wr7zGc+01Z1AAAAAAAAAAAA2MDW9M/xfeADH3jsv88//3x7+9vfbrfeeqtdcskllmVH/xryG9/4xrVcCgAAAAAAAAAAABvIml5Cvf/97z/q/2dmZuzmm2+2m2+++aj0KIp4CQUAAAAAAAAAAHASWdNLqHvv1V80DwAAAAAAAAAAgJNXa98JBQAAAAAAAAAAAByxpt+Eeryf/umfthe84AX2lre85aj09773vXbbbbfZRz7ykSdcV12MrS6y1RlVNXG76th5z7Z0MJhcLeyXRaY2Lcu8uamzg+n/5OVzssw/PkPXZ2kdTq+cMnGi84oDOu9E8cZDFZndojPFnPjWvp4scngg+tXMqjpc32xft3vbbCTzNk2Fy832dZmoGMu8qsjDGWWgTCl+FmZmFmeZxVkgzsThsYm8tZU4eZ1uOD3r6Or60zJv7vxnB9O3/dIfyzLv+GNn7V8fTq4qHQebmN08K/OqBrHdE4s4UxalLHN4/+FW27Blq45Bz312YN6Z2SuST8ky5e3/S+YNPhMeq0dHOpbUhe7zWoxHJPp1wbkOzKKsa5GKAwF1R8+daDzUBZPwvLJUH/XqsR677/zF14Pp05/5W1nmnX+8IPOiOLzG6krvyZGIxx6vvibXabt93a7eL9Kt4dg/M9+XZRYOzsi8zdvCeVe+SJc56xQdJ+enwp83Tdr9O21VHe7zimONq6qq4H5aluJc4+wDS4u6s6MoHGv2L+h5cN+jhcy7MHs4mP6/XvbvZJnr7/62zCsuD1+rSWzwVItOfX8XTo5vmzxmmJlVdfjzVs65Znper/P+TDimXHrZ6bLMNx/S8+XC/8+LgumnXfhMWSY64zyZ17vkimD6dw/o/ezgku6LcR7u93ExWTpWVGVlZbl6Pqjdrcj1+jcnrqs1W4s9YuVaeh5EUXhczzpNr5Wf+H9eKvPiy14WTK8axpp6KM7fD+rYWt8/2ZndTJ/zvXJemVf9b+fLvJl+uC9+4By9xp5/rs47sBhO/84u3ecP79PnrqVh+FqjkZ5HcTT5fas6LzpTGWZWlrWV5epOStPwPE2zZufRjnju6h1vd2zSmeO/+LNg+h903yzL3PTfvyrz3BgqNI0Bk/pqw+t4cVyZ3aKfq999Zzj97/5WP4Oade6v1Fwqn79Xltn2un8m85R4Sn+m5NSzdN78KcH0vLc1mF4dbvdZ11q0dtf4hS98wa6++upV6T/2Yz9mX/jCF9q6DAAAAAAAAAAAADaA1l5CLS4uWqez+m/2Z1lmh9fRWzcAAAAAAAAAAAA8+Vp7CXXJJZfYn//5n69K/7M/+zO76KKL2roMAAAAAAAAAAAANoDWvhPq7W9/u/3UT/2U3X333fbSl67827k33HCDfehDH5ro+6AAAAAAAAAAAACw8bX2EuonfuIn7GMf+5i95z3vsY9+9KPW7/ft0ksvtc997nN2xRXhLxcFAAAAAAAAAADA01NrL6HMzF7xilfYK17xijarBAAAAAAAAAAAwAbU2nhG2uwAAJEASURBVEuoc88912677TbbunXrUekHDx605z//+XbPPfc84brq8cDqUbQ6vSrDBUqRvlJI51V1OD0fySLlvd+QeS9+4N5g+t/88sdlmdFf/LLM6172o+GMyvlMcaLzZBnnq8FUfWosjqNaOigy9GeqBgsyL8p6wfQLN2+RZYanzMm8vQvhdnScldJNV8/VI6Z74bykGssy9XioL6bKBPovlIbHiaOVP8eI0kz8vLO2Oh2d1w3PUZvR8zA54wKZ953ZHw6m/9mn9Jy68CK9Hr515/5geuzFBUekl4PU5Fpxoi/0S/9iUzD9OWfo6yz+p38v8x65+R+C6cNv6b1i8KmBzFO+0deBpjOn51hX5KVTYi6bWewEtTgJz/UoDaeX41zWBVuJHaH4IWJNVOhxs6lZfZkyPA6Vdw46s5BZz//t1wfT/8ddeh0Nh/ps0Os1OJ80EAXi+lrEif68s7PhsUozXWbT5q7M64qhT2JxXjWzfnde5m2dC4/9Vj2NrOOcaQo5vLp9Xnif9JjiTWWYFUVtcb56LMoyvM7TQg9Omuq8sgwPRN/Zw76T67x7kyuD6X/7hftkmdFQn3niJgcRh/q8XqxRbahqvVbSzDkDiLxMBQ0zu/DS02WeikNz07KI3bNbL8D+Ba8Opp+2Rc+jpaHuiz3iWg/v13vMwkCPx+HlcDuG43CZ4bDdOfR0U5WlVYENIZRmZhY5G4G3jtS9bO6cO4uxPtdMz0+Fr6Onop1y5naZt+e+XbpgA6qfmtzTq7E4nqwbjjVpps9wf3ODfs6n4trnxT2FmVmnp+95psS9zfSMjoUzs859uhA5+0jtHEZq8XxRPXYcDbiH8ojHNVaLRav265Uyes4VZXi8SzVwZrY00nmbL3tZMP2ZB3WZv50Sz4zMLD8Yfh5aOe2LncCmysUN7qFq51m8274G11o8oJ8LK8sLyzJvYTa8J5iZXXLZWcH0z+56hixz3vlny7zTNofje5bpfvBCfyG6du/hcKEF8Zz7qdDsKWPAd7/7XSsDE3A0GtlDDz3U1mUAAAAAAAAAAACwAaz5N6H+6q/+6rH//vSnP23z89//G5llWdoNN9xgZ5999lovAwAAAAAAAAAAgA1kzS+hXvWqV5nZyq+s/uzP/uxReVmW2dlnn23ve9/71noZAAAAAAAAAAAAbCBrfglVfe8fKjznnHPstttus23btq25UQAAAAAAAAAAANjY1vwS6oh77723raoAAAAAAAAAAACwwbX2EsrMbGlpyW6++Wa7//77bTweH5X3xje+8QnXU+djq/NA08oyXEClm5lVhc4bjcLpgyXdtv2PyryFex8Opp/+4p2yzEP/7aMyb/qznw+mT+3Uv23W2bZF5tn0bDh9Zk6XScUU6U/LIlF3SuelWTA97ou2mVnU09eqRXo1WpZleqINZmanbe7LPCWOdV5UjIPp9Xgoy9Tf++3CoDJcnxV54GcDaXhMFCcWxUkgIwoXyPS8MWdOWdYNp3d7um2ZzrvojECbzewXXiWuY2Y7+gOZNzrny8H0atf9sow5cbBePBxMzxf0msyXwu2rch2/q7GT977w3H/AKVPmer2kU+Hx1aNklvbC42RmVlXhyJVkOpgkHV1fIq4Vpbq+SM1zM7M4nBepdK8uWJR1w2s6EuPmbCp1MXnciOdP0WVOv1DmpaefH0zf8fd6HT3jLL2X798f3ve8LS9J9NzqdML9lDlrpdsN52WiLjOzTqbrU0ekVBexNFEnF7NENMMr0810Xin6dmmoy6j4ZGY23QuPR17qcXK6TypFE0bOkR5mVVlZFRj0QvTbeKwXX+rsHya28wP79NnWmVZ2aN9iMD1J9OS54AfOkXkqNsRObK2cQKT2uCZ7n3fP4PW52n97PX0rn2ZO/BR5hXNLPRjp+u58MDzA9+7RizZ3rlWL+eK1YWmo+y8vxOcVzVPpWFHXtdVqkEI/7zyriU2v8zoKXyN1zstpR6+JWgSib9wlngmZ2QUXnSrzzj4/fL4aDvUEGo2ciS+UalM0s0rkeTGtidDecoQXCxNxIPLCpzu+Is/ro8UF8fzEdNu9+e117STrwsxsNNBtg6bOqkWu+9/b3xYG4XmQpXqifvEuXWG/8wPB9KWhru+855wu83Y9dCiYfmDXPlmmdNasiWcs3j1A3OA5gHcfp+53K2e/8O6Rs274eU2a6T1hbuu8zBsNw+24f09Hlhk45+pdB8J9ru6tzMw6zvxTlkbhMVxabHdPWIvWXkJ9+ctftquvvtqWl5dtaWnJtmzZYnv37rWpqSnbvn37RC+hAAAAAAAAAAAAsLE5fx9rMv/m3/wb+4mf+Ak7cOCA9ft9u/XWW+2+++6zH/zBH7R/9+/+XVuXAQAAAAAAAAAAwAbQ2kuoO+64w970pjdZHMeWJImNRiM788wz7b3vfa+97W1va+syAAAAAAAAAAAA2ABaewmVZdlj/9b29u3b7f77V75PZH5+3h544IG2LgMAAAAAAAAAAIANoLXvhHre855nt912m11wwQV2xRVX2Dve8Q7bu3evffCDH7SLL764rcsAAAAAAAAAAABgA2jtN6He85732M6dO83M7N3vfrdt3rzZrr32Wnv00Uftv/yX/9LWZQAAAAAAAAAAALABtPabUD/0Qz/02H9v377dPvWpTzWvrCxX/hyryPXPK6qMmdloOFm6mZXDscxL+91g+taLdzaqLxH1RXEky9ROX0RlEc4Yj2QZi5NweqWvU+e6/yJRX503aIOZyZ5wxr0eLOhLZc58aaAqG9Tn9a03nzGZODKLA+/hI/FuPtLrzhI9R2W5qpZFqkOPyrzi/q8H00/JerJMvu+QzKtHy6IRlSzjfd4o6wTT48yLneG2F6ZjiUfFyCg03kfyUv2ZylG47ZkTi5Oerq92xl6Jnfapzxt74+T1hZOHyUWdnkWdwByX/Rze+83MIm8PmN40UbvMzIpsWubdsye8FyXO9Ni5I5N5HbEm8rGONd5aiUVDvOmbpuHMrKMLOcvc1LJMYt1ur//SJFwuc07r3tak2l44/VqUusKBCOOZaPdKfTLL0sRpfIC3LcGsKGqLiyfeSd79xHgk7hnMrCwn38PGzv2OWsuefKwnlmpfmjrr0p2L4XL+0S9cn9d3qbPOVbmRM07ebf6yhftvqq8/1MLAiw3iHOJ0qxe7VNwonemdF858zsP9N1gO999wwP2Wp6rMqgnOskmDNW7W7HybOBtmkYcn1uHDzj2KODd4vL1KxQYzs7qePLaq6rw+9y5Tican3kHEEYvY6sVcr49ULFTtNvPPhU3OFd44qbZXIniNh14Mx3hcWZSs7rs0E+f5VA/o8rI+N1Ri7zu0pCfPoSWZJdflgUOTr3Ezvf5mNs/JMqNl/RylyMPzrnIO7aWYw7WziJo8U8g6+l7Si+9ZN1xuak7f63Z6+lpqnS+IR2dmZpF6jmhmhei/XkfPiY5zblVDpUL/8mKzufdk4EkTAAAAAAAAAAAAWrfm34R66Utf+oR+7vOf//xaLwUAAAAAAAAAAIANYs0voW666SY766yz7BWveIVlmf51NgAAAAAAAAAAAJw81vwS6rrrrrM/+ZM/sY985CP2+te/3n7u537OLr744jbaBgAAAAAAAAAAgA1qzd8J9eY3v9nuvPNO+9jHPmYLCwv2ohe9yF7wghfYf/7P/9kOHz7cRhsBAAAAAAAAAACwwaz5N6GOeOELX2gvfOEL7fd///ftIx/5iP2H//Af7Jd/+Zft4Ycftrm5uckqKyuzsgykB9LMzIpc19Ukryxkkbij/8nBpN8VhSJZprNpVtfX7YSrc/7ZwyjS17JIvHOsRL96ebnuI3kdM6tFfU6rrS71GEZVuC+qgX4BGhU9ndcR14oTXSb2Pm8VznD7XJQxs7oY63Jr+NmTUhSt/DmWM55SVeu8WuTlI13dsp6/9a57g+lRJuKPmdWjZZ23tCgynM/krHHVf0kvHM9WLhW+VlI0+ydeS7GGosRZx866U7G4ipzYlOprybjg8OKMivteGW9fikSeqs+9DqyOE6sDe0jUCe9FtbcjdvoyS02rwViv5aVFPReXhuH0xBnu2b6zf9XhgsOxXiuls1Rqkecsc8lZrhbHuv9UX3h9lCZN6pu8jJnemupaz7HcOZ7ovtD1OaHGzML1qZBSefsSrCxrK8vVfVSKhVQ5C8y7n1B7tre3Fc7Eykfh82om9l4zs+FA779ZJ3x765Xp9fV5I00n3+NqEaAabP9m5o2H1zZ9r1aV4XIqrpqZpZm+Vq8bbl/TJavKecftfKwbPxZ5o1F4Xo5FOnyxCPixs8nGTqzR5053Y5Eq8SxpONBrxZv37nOXBkLx28ysdiZ+kzXmNTtucKZ36xN57mcSZwMzfX5pOhZqH/TmmBonM7MkCZdTZcY55xpPXdfBM0eRh8ctTye/vzUzGyyHx6EsG9xUmFlRhNs3WNaxxptXsTjse5/JWxNtxi4vvnvrPBGfyd0vnM+rzozeZ/W2EnVeGw70+SBL9euVSDw/82KAd8+oPpa6L1wetbtfrUXrT46+9KUv2c0332zf+MY37OKLL+Z7ogAAAAAAAAAAAE5CrbyEevjhh+0973mPPfOZz7R/+k//qW3ZssW++MUv2q233mr9vv5buwAAAAAAAAAAAHh6WvM/x3f11VfbjTfeaP/4H/9j+93f/V17xSteYanza2gAAAAAAAAAAAB4+lvz26JPfepTtnPnTrv//vvtN3/zN+03f/M3gz/3pS99aa2XAgAAAAAAAAAAwAax5pdQv/7rv95GOwAAAAAAAAAAAPA0wksoAAAAAAAAAAAAtG59fnlTXa38CaUHf7526vLyRH1RLIvE/b7My6pwfUmvo9vgiKIo3IauU1+a6bxYfC7n85poQ2NlHkyux0PdBNVuM6uLcH1eq50Z0Ujb9ZmYR5PX03rLoKhYYmZWFuH0cbO1VY/H4XS3kNO+kVh7Ym0dt74GVKyL0kSWib02VOE4WJr+TLHp2FmXZTA9ivUYVkW4zEpmy2vTaYcs4vStpPaDtveJp5lxvvJntXC/edOjdDJV1mCsyyyNdN64COdFkS7TyfRcmO6FyyXOEaTtZaSWinPMcJdXHIcb4ZXxlp5aSl4ftb38KufcXFVizjpzwuuMXIxvIqrz5gPMyrKysly9N5Z5+BxSOYsocSZq2fJAZOK+pnbOw15eqA/MzNLMOVM466gWa0IcDVxerClLPR7drlNQ8G6B8yLcR15czcf6A4+G4fZ5n9e73UnFXuId/Qrxmcx039biA6t0rIhjsziwaNR53uvPKNOTRNXn8a6lYkM+FvdqZlbX+nFZnLS7ATeZd03OAF5saFshz5LN6tPHjWYfSsYA0W4zs8oJXlUZns9q3/TmHsyKsrIkENsTsfZy5/lK5eyx6p5+ebnZ+Kh5NRzq+kYjvceq+tJMx6eyo/MqcYCpnbOfd3+gJN4NjODF/cT5vN5zmSbUmWI00mOozi4rwn3rnYW8vlBDpe7TB4P187xm8lkBAAAAAAAAAAAAHAcvoQAAAAAAAAAAANA6XkIBAAAAAAAAAACgda29hBoO9Xf6AAAAAAAAAAAA4OSiv9lrQps2bbIXvOAFdsUVV9hLXvISu/zyy63f77dVPQAAAAAAAAAAADaQ1n4T6nOf+5y9/OUvty9+8Yv2yle+0jZv3mwvfvGL7Vd/9Vfts5/9bFuXAQAAAAAAAAAAwAbQ2m9CvfjFL7YXv/jF9ra3vc2KorDbbrvN/vAP/9De+9732u/8zu9YWZZPvLK6WvnzZEuzcLrX1krnJeI3v+LuBJ/98aLwO8IodYYtE5/JzCyKwulJosuovohyXcapr1blYl0mqvRcqEunHao+J69W14r1+9oo6ej66oZjr6j5F+i/1q99slBzoK51GS9mRMXkbfCuFY3bra8Qayh3ruPGyMljdyTWVxTr1RqJ+GhmFqXheOJEOitt8lgiY6qt/y9cVH2+kulFSUxqVNQ2Kpw1eAxvCVVONXkZzhw4S3nsTPtStCN11mWa6AZmDU6chRNqyircDjd8iqZHkS7kfFxLxDLyllAS62uJ0NW4Pq/tuowuJKaYOU1Y97Hw6SQfjc1s9YKvReCQZ97jqERwmOhe73HUnHP3KYdqn3caU3200o5w+5Jk8gUWOeur09Gfd3k53Posc84hTv+pthcN40kUh/u86XFiNBJtcBoxHuv5rIqVIqipdPianOc9idoUHZUTh6oi3L4Gd2orxBnKW+deX3hrtk2VE/tVG5qU8XhnNbdcy2tTfS5vT6idxqtyal568xWaivfescbbY5Wme4GaI6OhHu/xSOcVeThKVc6NUuXdNApNzoXeWinNuefJwvHd2+ebtkPxxlflFc49/XDgjIc8b+gbZO/RvpgS8l5ynK+f5zutvYQyM/v2t79tN91002N/RqOR/fiP/7i95CUvafMyAAAAAAAAAAAAWOdaewl1+umn22AwsJe85CX2kpe8xN7ylrfYpZde6v5NEAAAAAAAAAAAADw9tfY7v6eccootLy/brl27bNeuXbZ7924bDAZtVQ8AAAAAAAAAAIANpLWXUHfccYft2rXL3vrWt9poNLK3ve1ttm3bNrv88svtV3/1V9u6DAAAAAAAAAAAADaAVr8TatOmTfaTP/mT9qIXvcguv/xy+/jHP24f+tCH7Itf/KK9+93vbvNSAAAAAAAAAAAAWMdaewn1l3/5l3bTTTfZTTfdZHfeeadt2bLFXvziF9v73vc+u+KKKyarLIpX/qxSTt4w7zupgtcwszSb/DpeE0qn3XXlFBTtSxJdxmu7V27SMrHTr15eA/V4KPPUleqmF4vD4xHF+pcG68oZQ6dcI+paofQib/faTzd1vfLnWGpSeePsxZlKrP/cqU+VMdNxwYsllbMi1LW8+ePFtBZFDeNMVIfzaqdM7MTHWqzjutD9oMqYOTEjNB+fLA2+r1HFQXecYFUVDh9qWealngdeGCpEXuHUlztLWbXP29Yy55hRiRNnHOn2Jc61yhO0jNxjpMhLYt2IJvU1KXO8PKXyOrBSH9gp4u0/InbIbcmZ/zCLoij4XbyV6FB3rPNCZpVi8SXOgnWvJXjn67LUk1tNx9pZEKXpa6VxuMbSia1qW0xS3YbxWLchScLl/OOYt2DEWDmfyaPap9LN/P5T5wrvVrZ2Ys1YXKsScyz3NkdYnCTBc7Mat9hZe949dhPe95Gr2OW1oXBioYx53mfybtfcNXtiqDWxXupTvPVft7z/uOeaCdtQqcMszMwsH1cWiedzIUXhnV0mfxbqzR0v1qg9xNv3Su+5gmiHimnrhXcubFuT5xHuLY/o23zc7HygmjeKdH1lpftPTT+13w6H6+d5TWsvoa655hr7kR/5Efv5n/95u+KKK+ySSy5pq2oAAAAAAAAAAABsMK29hNqzZ09bVQEAAAAAAAAAAGCDa/U7ocqytI997GP2jW98w8zMLrroInvlK19pSZN/Bg4AAAAAAAAAAAAbVmsvob7zne/Y1VdfbQ899JBdeOGFZmb227/923bmmWfaJz/5STvvvPPauhQAAAAAAAAAAADWuda+KeyNb3yjnXfeefbAAw/Yl770JfvSl75k999/v51zzjn2xje+sa3LAAAAAAAAAAAAYANo7Tehbr75Zrv11ltty5Ytj6Vt3brVfud3fsde9KIXtXUZAAAAAAAAAAAAbACtvYTqdru2sLCwKn1xcdE6nc5klZXlyp9j1XX456NI1xU7v+ylvquqrnSZJrw2eNTnSpxhi53v34pEO1R6U5UYJ7Nmv3vn9F9dBeaJmUWVU8a5lJxJ3hiKNhw3T15Lj2Fd5MH0KNS+JteGXv9td6e37lSsM9NxwStTOTFNzZM8PNfcMqbXZCPOugvO+SNEDIpiLzZN3n91rPceZ1eyFn8JeaUd3vgKbv/JMuFPpdKxoizNisCyKMWa9YazcPLyMlxf6NqPXcuLGw3EzjpK5dbmrCPveCfWecsfyaXa5y0Jb+mpcl6/utcSeVHUbie5Icj7vCq9Qb/CrMwLi+PiCf987ZzXnWO0jPltxxNvn/LabiLWVKF7yyNFYn1vVYnY6qnFXK2ce0xvfqujVZ3qPqqcQcyyyc8NsTMepeij2pkTqoyZWSSCq3fE9OpT7VCxy5temJwXG5qciL31X+Q6BibiIFI6iy9RAcXMKrWXOhNVtcHMrG4Qa9Ra8daeKtNUZTqeuLG6zTY48b2Jsmz3M6l7tco7pMOqsrYqMBZqCLx9NM8n72v3nORMA1WucNqQj/WzFzVPvHnvza2q0RxWz1d0p3uxPznO05JJNVmXlXMDU9XhWF04N+NebB2JrNJpd1o4z8LEtZIknD4arZ9Y09qTsB//8R+3n//5n7cvfvGLVte11XVtt956q11zzTX2kz/5k21dBgAAAAAAAAAAABtAay+hPvCBD9h5551nL3zhC63X61mv17MXvehFdv7559vv//7vt3UZAAAAAAAAAAAAbACt/XN8mzZtso9//ON211132Te/+U0zM3v2s59t559/fluXAAAAAAAAAAAAwAbR2kuoIy644AK74IIL2q4WAAAAAAAAAAAAG8iaXkL923/7b5/wz/7e7/3eWi4FAAAAAAAAAACADWRNL6G+/OUvP6Gfi6JoLZcBAAAAAAAAAADABrOml1A33nhjW+04Whyt/DlWLV5mxbGuq66dC5Xh5CTRRSLvWtXk9bntE2KnvtQZUtVP3ktC9XnjhlNHfd5KjIWZ1flI5kVJFi7jNCFymt5gNJpxxrDJK9u6Wj33ajUfsaKqzQL9pteJU5e3jksxt2OnjLMeGgl9ziNU273549VXheurRXpTUWiPOHItkRepPcQpY2YWWXhOOLuB1e74iv5r2EeRtye0SfWR03cwy8va8vKJj23hLK+ywbL0Lu0tZSVpONyJWDCVew5y1qXI8qprcuRq8veovDLecomicAP9Mk+wUU9Q7FToHbebqETMi5tOspNcnCYWp6v3g6qY/EzhzQN/zYoyXhsCbTYzfX4ys8S5typFoExUEDKzfJTra4n2pZm+oZBd5OzzlbPQVZZ7bHA2jLFzHlK8W8xafOCmfxFVjaEXg7xrlWIjVPWpz4MVURQFz+Eqbnhndk/o/nblQnoixA3OxF58cmPhxFdqX6zueZw+ajK/5ViYWVRPfjjw6vOoc0PTNavuTxu3b8J2NNlPTybjcWkWr16fTZ4reHEobnDArZw5otpXOeca7zOpPVGth+NeS8w7dR2P1+4msd/7THGDcfdig9f2QtyQN33soaaY95HU2cXMLE3DFdbifFc0GNsny5pvJ++55x4OagAAAAAAAAAAADjKml9CXXDBBfboo48+9v//7J/9M9u9e/daqwUAAAAAAAAAAMAGtuaXUMf+FtT//J//05aWltZaLQAAAAAAAAAAADawlv91dwAAAAAAAAAAAKCFl1BRFK36ItCmX0IKAAAAAAAAAACAp4d0rRXUdW1veMMbrNvtmpnZcDi0a665xqanp4/6ub/8y79c66XMIvHOzHvnVVU6L0lUhi5Tls7FRLnaaYP6TB7vJV/iDKn6vF59cYMXirJfj3MtpXL6PMkmr6/Btepg6oqoyRg6n6mOnf5r6RpYiV3H/nOiZmaRFzNkZQ3WuBdL4pZ/SdX7TKrtTvvqp+Hcipw+V5/XLeP0nypXW4O5h3WvMrPK20SOUTrToCh1ReoaTUKaxwtPqXNmKMROmtS6TBzpz6v6qXbqa1vktE+X0Xmq+5oe01S5Jke7J4OcsxOmY0VVlFYlq/eeUiyWytmnksTbE8MDUTvBxtsvqyLcjjjV5+HImcSqfaWzx3p/gVJ9rlK028wscdquVE58V2Gtcs6fSaI/k2qdv8aabCZtL1r9mfKxHg/1udQ0KnPOY01UgfsqM7PEfVjTLi8OVeLvX3trpcgLmadiVOzEE29meXFN1qfOQqVut6fRXyb3nmuIOdH0L62r+lTcP259DQ7Jak9tch21/8Gn54Eem9h5xluI9dJkfpjpOeLFE28uqHKVMxcrZ000/VyT8mKhLOPEQS9GqjNtVTjn2Uw/O5dnSadfI+ccNx6H+zyO9VhkmZ6z8iyehT9vWayfc82aX0L97M/+7FH//8//+T9fa5UAAAAAAAAAAADY4Nb8EupP/uRP2mgHAAAAAAAAAAAAnkZa/jefAAAAAAAAAAAAAF5CAQAAAAAAAAAA4EnASygAAAAAAAAAAAC0jpdQAAAAAAAAAAAAaF36VDegFXWl82LnPVtdT36tyLlWIrqzLHQZr32VuJa6jplZFE2eFzlt8PKUstR5SRJMritdJorDZbxyUaXbXTvD4V1L1tfyq1xvilnaCbchH65O8+YdVuJGIHbU4t18pNaj2XHijLMeZBlvEqgyDeKZmYwz3pq0Sl+rFuu/dvpP5nl93kDkxbPYaV8sYqfTD5EXi2Ub2g0mXp/jxKlqd6oEfl7/sFdPLpZs0/rUtPd4UzgW10oaHtPUEqsbft42Nek7M/2ZvPr8Y98J+sANNe0nhBV5YVG8+uwXiYXp7VNl2WDPdlTOvYFqR1XoMrmzmBMRVJocrczM4m4Wrs+JNfloHExPMn0Pp9q9ci2R4fSDd/osy3A5f03q9lVivsRegHekabjcaDT5PDLT7VNToijWd+x8qsVRZHGTc26AO25ifrvnBnejF/c8zsR326diVKqfJ8Tu/ZBog3O4qm3yuRo5n9eLa23yruOPoSqj+9U7Bzdpg3ctNVbq856g7t6wqqoKxu98lE9cV+Sca5Qmc9HMrBRnnjLXz+dK58zTpB3euUud8Zp+XtkGZ4Kn4rmrF+/a5vV5k2c5ftwI56WZ/ryR+2A4XK4SG8l4vH6eC/GbUAAAAAAAAAAAAGgdL6EAAAAAAAAAAADQOl5CAQAAAAAAAAAAoHW8hAIAAAAAAAAAAEDreAkFAAAAAAAAAACA1vESCgAAAAAAAAAAAK1Ln+oGBKWpWZqtTi/y8M9X3ru0SmcliSjilWnQZV6ZKNJ5sWhf3PDdYSTKxU4bmpTx8tpWi7HyxtCrTqS7n8i7lhorNbZmVpdinjvtiALjFErDEyDmVO28s48azrcTpa7VzHZUThm17trmxbqqlFmRKFd7+4GurlF9UZO/49E0bonxVe1u24m6zkZVVit/jlWJcfOmgXs8ERtE4bTN267VkvDKqDaYmVXqvBPrWFNWukJ1LS/cRQ1CYdvcI1eD41PkfCh1rdi5kLecvfFtIhYNrMT+o9KxIk4Ti9PV58ta9FsZCkzfkzaI695ZI1b3XGZWi8Dm7S1Ry/ca3rWKPBwN40R/3iQwDmZ6LMzMSu+MIsROu+tSX6sSfd7t6XvWomhwRnHmmGfY4FpqHrllRBcVBbHmRPHiRiT2Km+sIyfWKGUx+T2FmVmShPMqp766QWyNvNja4ODg3cbJe551fq+rztRmftzVZfTn9eZsXYbHXp5rmtyjn0TKvLAiXn0n0yjee/dXDcbBm1eqfd451q1PtM+LXU3mvafJWa3N65i5T/blucs760axc6043Lelc/6s64bvJRooxRkvTcNtKPL1E8N5cgQAAAAAAAAAAIDW8RIKAAAAAAAAAAAAreMlFAAAAAAAAAAAAFrHSygAAAAAAAAAAAC0jpdQAAAAAAAAAAAAaF36VDcgqDKzql6dHovmliNdV+S9Z6vCyUmii9SBdh1PJa5zPHGDd4RR1OxaE1+n4fvLBu2rq9JpRnis3DITt8DMG3XVBjOzusjDZTrOHPPaUT/xuTTJz56UqjocZ5RY92e9Ht7nNx1v1QcN66tVvHP6um4SV1sWeTFNjr0uU6v9xdNwCCMRV71+VWXavD5WVHVt1TqY422JYz3esfM5Y5VVOfNHFvJCiq4vaTBVvaFre+pH0eTzxBkOi0/Q2vSOq6nT6dUkezAaq8rwmTjN9G2g3Msb8uqLxASKnMldO3OnFKd2r764Qfu8PbYswn3uxk9z7ifEtbx+8D6vMhoWE5cxM4tVHzlNaLItqn41M0tS3X/VhPN50p8/2ahzjdpzvHnqHn7FvPKGJ3LODXUpYoO7Vzr3fw3WWLPnQnqTLcQzj9hZDy6xX6wX/lxqUl94PLz4ztnlxKmK0qpk9Zwsy8nXUZNzTZN93lM57W67fW45MYcbtcEpkyQNzplJu8/VvPaVTryLRTtiZ/1Xzn5R1eGY7IWTUuxZZvqVhTq/rKdzzTp4cgoAAAAAAAAAAICnG15CAQAAAAAAAAAAoHW8hAIAAAAAAAAAAEDreAkFAAAAAAAAAACA1vESCgAAAAAAAAAAAK3jJRQAAAAAAAAAAABalz7VDQiKzSyOVqeXZfjn06zZdUR1VlfN6osCbTYzi513fXGi81Q7Iq8+0QavXNP6Jr2OmVldh9Mr3edRg/GNnH6tKzXwZvLTOu2zjr5Wk7Z7Iq9v1/CzJ6W6Cq8x1W+VmLtmpoOJNVtDTXjtaxDTavfzTt6O2ltDsq6GsXiDiry9wqH6Nk68OOjEXNGOSuzBtYrrcDWZ3mWDrvau03SZN5GoUOhN+8qLn6Lxkf5QTT6vOto11faWEDsNVCFFjoVTpqmqQafHopNUOlYkSWJJIO6r/VzFdDN/3JqMQ5zq/ajMi3AZc+6RHJGaPw0Xcyn6KXHaF4lF5vVrWeYyL0nCCzNy93l9LdVHHq++UtxbJc64V87mpK7V9LwxaX1e27CylkLrqRL96a097+wbNVizTc63TTXb3xpdSGapz+St1xPZR21Tbffa3egetKFJr3Ui27YRRXEcHNtiOA7+fNvnxCZr3MzZc5zxds8H4pykYu7xNJl3TfbfstTXScQNoF/GuVYRPoe4e4yTV4l2VLE+O3vn1ibnmqLw4rg6Z4Y/k1fXiba+dxkAAAAAAAAAAABsSLyEAgAAAAAAAAAAQOt4CQUAAAAAAAAAAIDW8RIKAAAAAAAAAAAAreMlFAAAAAAAAAAAAFrHSygAAAAAAAAAAAC0Ln2qGxAUxSt/jpWKd2ZlqeuqCp0XRyIjceqrJ6/PK+MJ9YF3Ha+Mp0l9XhlP1LCcUoXHvnb6IYqd8VXihu9rqyqYXBd5s/omaHtdh6+N42i731R4arJWzdpvn7wM8+d4IjcOTj6+tTl97uwjkYpPTvsip32MfbvK0qxwjinH8rq/ydC425dXnyrnlGmyJLzmeTtlbOGL+X0UXkexczap6oZnOMG7VqP6Wv7rZF7/qWu5c9a51nQv3Bf5BOsF39fpd63T665Kzw+MJ64r9vaPBnO4miQIfo+3F8l9z8xqsV9Wzlppsi7dvTKZfGE26lfvHtgjinn92kSRO/fhDaSZfnRRNdggVZ83GYuTShwFz8CJ2JfVmjyeWuy/bY+Puo6Z+ZuYyGx7Hfnta/fMruKaH3Mnj9Vt32t49Xn9VzbYm5pQ/dD2XDnZVU1jTYP5WJUNyjjt8+Zp2/ciTdZlnISfQzZdy+o5ihtPnDNAE27cEHllqfefssGc8Mokzlky6oTHQ70yafro8cmwjpoCAAAAAAAAAACApwteQgEAAAAAAAAAAKB1vIQCAAAAAAAAAABA63gJBQAAAAAAAAAAgNbxEgoAAAAAAAAAAACtS5/qBkykrsLpceQUcj6iqs+TOHmReKcXOddRZcx0+xKnEV59bj+1KHKuE4fbF8XOZ/LyvM87YRvMzKxSc0y3oS7GEzch6vQmLmNmZkX+5PzsSagcja0MzNWk12n1OnVVB9OjuEH8aXCd45cT7Wi7Pk+TMidQJOJM7ewhkRNvG41Vk/jtXcepT8XjSNQXe3sSLI7C3T0qTsz1T+Tyir15KuaPN02TJscW71hQTV5h7J1pTpDMWWJls1AteUekJmW8KZGX4fSuOLrnhBrXmWfNWbc/tyr9fvHzS4eWZF1ppu+fxsNRML1yFrMXGyKxxuLUOXs711Jt984nkTOJU9F21e6m6lp/JrkvN2xDkYsNqBKL0swSZzxUO7zPVBb6Wmq+NO3y6Znw2X77qVPB9OGAv6fr6c1MWdZZ3Xej5WHw58tSH3giZ12qtezFmra569Imn5BN4qRfpr3rmOm1XJV6vXpxSMVdr19PJC/2K03udWc3zwbTx+HtFN9z2jM2Bc81D9yzL/jzZanHxhu3WqwJb59qsv968947d8n6Gt7kZVPhPXE8mHxCRt5NikM9P2gSn8yareVGZRoeRNTY186NXOr0reqmTZvDz5lHg8mfWT9ZOGEBAAAAAAAAAACgdbyEAgAAAAAAAAAAQOt4CQUAAAAAAAAAAIDW8RIKAAAAAAAAAAAAreMlFAAAAAAAAAAAAFqXPtUNeLy6rs3MbGF5IH6gmrxSr0iT+jyReKfnXUeV8colThmvvjjSeW2KEycv3L7ILePkNXiPGqXOtK9En6eZU6acvA2dycusXOuJz9mFpWUz+/66worH4sxwHMxPWu6vugrXF7W8HtV1jl9OzKmG/SDr88qUk68H7/PKkOu1rUH/1Q33ENX2pvVJ3mdqMv9EfQujlbVErDnakf5YXDwczB8Vk9fZYHlZUTYbFzV9vGnl5olMv4zOU7yP26S+9SBzjkFNhjdxlr84pjXmhZpYZObi8y4tLpgZseZYR/pjNFgI5o+H4fR8tKTrrPRZOR+Fz0+VMy5xpCeCyopLPfH9M0C47d75JHImvjqvRc5nasKb15X4TE3bUOaTb0ClMx6qHe5nKvTZT5+RO7JMWerxTeNw/w0H4X44spaINUc70h/5eDGYn4+HwXRvvlXOc426Do+bOk+Y6X3FzF/nTcSi7U2vo+Jkk9jadjz2lkKTMLRelpbXT0qTe93xKDwn8tHKWiLWHO2xc408v4TTvX3AGzfV/aXzjKLJs5d8nDtt0OeuQsTQJnPRzMyi8F5ajEeT19XwmVachM8UXgxXZczM4sp7ZhxWO2XU3qTOY8fjnaE05xl0Ge6n0QY410T1emjF9zz44IN25plnPtXNAJ5WHnjgATvjjDOe6masG8QZ4MlBrDkasQZ4chBrjkasAZ4cxJqjEWuAJwex5mjEGuDJsR5izbp6CVVVlT388MM2Ozvb+t8uA042dV3bwsKCnXbaaRa3/VebNzDiDNAuYk0YsQZoF7EmjFgDtItYE0asAdpFrAkj1gDtWk+xZl29hAIAAAAAAAAAAMDTA6/bAQAAAAAAAAAA0DpeQgEAAAAAAAAAAKB1vIQCAAAAAAAAAABA63gJBQAAAAAAAAAAgNbxEgoAAAAAAAAAAACt4yUUAAAAAAAAAAAAWpc+1Q14vKqq7OGHH7bZ2VmLouipbg6wodV1bQsLC3baaadZHPO++QjiDNAuYk0YsQZoF7EmjFgDtItYE0asAdpFrAkj1gDtWk+xZl29hHr44YftzDPPfKqbATytPPDAA3bGGWc81c1YN4gzwJODWHM0Yg3w5CDWHI1YAzw5iDVHI9YATw5izdGINcCTYz3EmnX1Emp2dtbMzL77ja/a3Pf++/GiTjdYLooTXambF34DWFbN3raPi8nLlFUt81RWVen6al1dq9r+CwlNX8bGoh2JymhYX+pMI08SiwEp8kb11VUZTh+PVqUdXliws599yWPrCiuO9Mdt/8c/sZlOtvoHxCKqnYVXOwtPlnPWfpNreWX8azX4vE59TdqwYTWMM0rk1Bc5QVKVi5zAFSc6T5VLQuvFzBbHuf3QH/4lseYYR/rj/vvvs7m5uVX5tbU7f7wQ0Ki+BmcQb5mr845XxrtWGd4OrXTicTF5OLbSbcPknykX7TYzK1R9Dftc5anrrOTp+hSnOrfthdx/wmtjeWnBfvbqc4k1xzjSH294+9es01vdN+NReFCLQg9cqRaYmfxbyd7frEzTE/c3mdW6TJJmbVD1eXt23uCm0Pvb3lWDAO/Vp86STf92bJpNfqPUZDwSp3leLFTX6nTC7R4PF+z6d1xErDnGkf64+ue+YFlnZlX+eBS+v236mwyxOo+2fF6OnfZ59cViQjY+z4t2NOk/by23/RzH+7zyPtNZryeyfUrlHGy8eJyIOaFi0Hi0YH963Q8Qa45xpD9++pdut6y7OtYsH1oKlvPmjrf20iz8WDxx9jbveUgq7pnV/FjJ043vdMPt8M5WaeqdycJ5aeaVEfHYaXdXtHulPpWu+9U7oajh9c4NHvUc15tjXlwrynDBYe6d/Zz6JjxmDpcP27t+/qx1EWvW1UuoIxvs3Oxs8IENL6G+l97wYUSbWn72ykuoJ2iSl1BH8CvMRzvSHzOdzGa7Lb2EavJC6SR7CVV7Tyk3qKjhAy1Z33p/CdXtyDJmxJpjPXammZvjJZS1/xJKvSxxX0KJMk1fQsmXRuvkJZRq+3p/CVUd5xxOrDnakf7o9Gat01sdaywK36DE3ksoZyLIB7m8hPp+nuhzj1df5QUi2YYGL6EaPq05cS+hnD5q8BLKe0BmRqw51pH+yDozlnVXP8iq67FbblLyJZQzT9fDS6i47ZdQDZ5r8BLqcfWt45dQRxBrjvZYrOnOWCcQa/Lu5C9sm7yE8va2ytl0stAzJlvLS6hw+7LsxL2EykRftP0SKvNeQjnLZKO+hIrGukL3HrTBuwez9RFr+IdHAQAAAAAAAAAA0DpeQgEAAAAAAAAAAKB1vIQCAAAAAAAAAABA63gJBQAAAAAAAAAAgNaJrwN7akVpZlEa/jK3iTlfQNfkS8EbfWGz86V1TerzvnjVLdfil5a3/P3nJr737fjlxBBWzrfCud9NKTK9ceo4U1XNMXd+F7nOE0JftOh9+SJs5ZsDA/OkbnOhmMkF611HfWG0W84JDOpLYY/XjiZq8UWuKn0jiMQXbnqfSZVp3AbvS47FFze7X84qypjpL4KOxJeYRiWxponI2l0T6otXm5x1zExv9N5we+FEb9hOGSdLFaucL66PwoWanqvWA+9La9Xn8j6vF6oLkenVV3njUYvYKurzPivMlpcKK8rVZ0jvS9SVxNkjlKbfdaz2t6ZfnhzJL5PW9XnnLtUT3rzPxJeIu+cxpz5VzjsbVM6CicWGETv3DrFzrlHNUNfxyhyvnOJ8B7sVebgvikKkE2xc+bgws8nvV0PUmdPMLFaxwZmn3ppIEnG+dct41xLnYu/83fBak9bnPu9oUJ9bpuUvuveaoEJo08+rRF1vnHReKgKRSh8NxpM17CSzeHDRss7qdPX8wosNqfdcWNRXls5YZ5M/SvfWV5N9z1t7as6ZmWWdcCz0ynQ64bxu17mO00XdLLyYY+fBcOYcTVVXJE59TUJXXuhC4qhhZmbjIpzunSXHufdMWzy3Vucakf5U4MkRAAAAAAAAAAAAWsdLKAAAAAAAAAAAALSOl1AAAAAAAAAAAABoHS+hAAAAAAAAAAAA0DpeQgEAAAAAAAAAAKB16VPdgElEcdJqfVUl0munjJNXisym9an2lbUupMqsd7HTD0kUOQXDyVXpFHGqq0TfZokuNM51famYsrHTCG+eq1J1HBj4ltfL004Urfw5NjkOT6p6nS+u2gkmXttVubp06nPylKpc3/3niVv++xqRiCdq7q00QseMOAmv9bijt/g4y3SeKJd0O8H0NOLvs7iq6indnJ0tz8yZc4nIip0aK+dihdqX/U1ZZqliTXraa4JznJC84W4yFZqeIwsRq3PnQ6kyZmalGGA5tna8c264PrVdjAp3Np/0xLHGYrHOveN15O05IitWQeM4EueMrURe4wVvi/XWpSrnrvMGZx51H2lmlqZN5r5zPyEG0etXL06qsc8ypz5nQFSW177auT/OsnBfqDJlw7l8sqjr2u3vY7nxxLsnFuPtxyfvHjuclzjjrc7YZmaJuNH3wpMX79pcl14fNYmfHi+2nqhY7ZXxpGm4oLefdTo6r9cL30N1u+G5MlwunNYhjqJgjIiSyR9ju2tCnpOarSO1v3nr39tj1V6adXR8SrPJ53BHzFMzs45oQ6/j7L2pzuuKRxEdp4x6tmpmFosHyg1vMy0X9xy5s2RVGS9vnDvP9p17sqIOB0MVa8pi/Zxr1k9LAAAAAAAAAAAA8LTBSygAAAAAAAAAAAC0jpdQAAAAAAAAAAAAaB0voQAAAAAAAAAAANA6XkIBAAAAAAAAAACgdbyEAgAAAAAAAAAAQOvSp7oBrYiTRsWqWqRXukypCplZUU6WbmZW1ro+1Q6nCW5e6XyuNiVNXm06bYsj/aHiSKQ7bUgiUcj0giidNshGmB6P1t/+VoFJFkrDhlB7QUhMKq9M7QSGuhT1iXQzs8oJJl65E0W1IUr0WvVUIkDFjYKdWSRiRpTq+pIs03m9TjA9zvQWn3TDZby8pBduQ9qwX08aVTlRPK4bxu5InIW8+lQZ9zqpnouxsx+q2eiekZx2qH0+9rZrde5bJ9ulCuPe+a1wYm4uPte48M6yegxVO7wy/plapYfrG+XEGk9dr/xpg7OU5R7mlfH2y0TsId5Z3hOLgl593jxV5bwyZiIeNxygUp3VGtYXiXshNRbHy1Pj65VxbsfkXlJ5N7oO1U2qX6uy2bOFk52aV43rU2vZuY4qY2aWiHkaJ3q8k1TnxWJ+u+vICZRqHbnPNcS1vLFoMk5eG9oe9ybUvmTmj0cnC3+wTk+P+1Rf5/W74Zgy3QtvGMsiHSuiKDy/vHWuJM46l3uYs/7TzIkbDdZlKuaimVkqnhGkqa4vc9rX6YbzOpmur9cJz22VbmY2JdaDV87pcuvqW1DrihtN7z5zeazzxrlIL3Qfefcpo3H48xa5jgGRM807YnxVv9bOvd+Jxm9CAQAAAAAAAAAAoHW8hAIAAAAAAAAAAEDreAkFAAAAAAAAAACA1vESCgAAAAAAAAAAAK3jJRQAAAAAAAAAAABax0soAAAAAAAAAAAAtC59qhsQVJUrf45RV+F3ZlGcyKpqiya+fF7WMq9Y3azj5rn1Vbq+UuRVta6vcuqTZXR1Fk/efW4fyes4r0PjSDciEeVi5zNZojPjOnwtr4/07GvI64zAulgpE2iFsy5gFsWRRYG+rpssogZqZx275cRkVOlmZrUTg1ReOdYL2atPqbxFdKI4bYibBDtnicWZXsdJryPK6C057fd0fd1s8jK9cBkzs0SUizrhdqedkawLZnVVWh2K3Y02bGddWj5xdXXstEHsRVGhi3jnsVjkeft1IvZkM7OqQRxqwjtztV2fClGF81lHzrDnYroUpe7XceH0uZgu3rmvrHR96pyruqhw5h7Momjlz6p0sb95216a6j0sFodv7/iaJPpikTjne21Qn8lMfy6vjNe+JtSZp+Vw4vLOhak4o6ixMPPni+rbJuNu1vyMrBR5ONiU4p6wLvl7um0K3W89sXLhOeLVp+LTSl74HJKkztnFmcMqRnmxy1sTKs8roz6vv/Zklrwf8tZrE94aL50zj2pG4ox7t6vHd2oqnDfV022Y7etDT78bLjc3Ff75pc6Jee6wUUVxHFzv3ngrXmxIxT24d25wzyHiWt5c9OJG1gmX63b1s4NuT1+r3w23vZPpeT8t1kSv460VPb+nRRvmp5217Ly9UPcihwe6fUujyZ/7N3kfYKbPZF6s9uZEryvSxXjU+Tp4Fvc9nLAAAAAAAAAAAADQOl5CAQAAAAAAAAAAoHW8hAIAAAAAAAAAAEDreAkFAAAAAAAAAACA1vESCgAAAAAAAAAAAK1Ln+oGTCKKk4nLVFWzPFmm1nl5Gc4snOuoMmZmRSna4NTnVCd59cUNXlMmkc5T7fPKxLH+ULEol3oVusLXiiNdXxl57RPlvKnsDEhdqUkRSFc/i0YiZzHIcWnKCzQN1E5gKMfhtntlKqd9XrmnWtQwLiSd8IJNenohJ72OzEv73XD6dH/iMk3rizLdPuuIa4kyUTzUdcGsyFf+HKNucgjx1A3iUJM2pJnOi3Ubok4vXMTZX9Uef7y8STUNuaqcFwa9Lh/l4YKDsS4zLibPywvdeWMnT51LS/esretT/VeL9FHe4qA/DUVxZFFgYSRi74u8tZfoM4+qT6UfL09dq9Nx2uAEAFWf14bIud9RMSrU10fUDYKKV1/bVP8Vzk1r7PSfWrNta9KvZl7cDWfEJ3AsNqIoioLxo8kcduNQg7XnjZ0q583tNNXBQeVlma4vy/S9Q5qF6/Pa0CQee30u94uG8a4SwaFyDkpe+1Qf9bq6zHRPX2umHz7YzPZ1mc0z+lqbpkT7OuEyC/3Jn2+eTNIstTRb/chazUd3bqfOfbvIaxob1PmlSRkzs2433L6u8yzCWxO9Tnh+T/f0GWBGrInp8O2dmZltn9ft2zIdbt90z7lvcO439i+FM4tFvZb9eyhxTiqdOeY9Oxfj65XJUt32rrgdV+mlc/t+ovGbUAAAAAAAAAAAAGgdL6EAAAAAAAAAAADQOl5CAQAAAAAAAAAAoHW8hAIAAAAAAAAAAEDreAkFAAAAAAAAAACA1vESCgAAAAAAAAAAAK1Ln+oGhNRVZXVVrc6oyuDPR3HS6DpVHU4vwpcxM7O8FIXMrAg02cxslDtl3GuF06ta1xfqtu+X03lKHLVXV5PrmJnFzqvSNAkXdPvIaXschevzxiltNv3wFIviyKLgxAtPuLp0JsEJFIyNZlaN9eIvx7rtZR4uVzuxzsvTZXT7oqTdvw8RibgQO4Em7evtMJ3KRJmuLJM4ednsVDh9uq/b4OTFfZHX02Us0+2zTkeUUekDXRf0maZWm7xer2r9N5fLnEhsvt7qV2XMzEyc1ZI0vL7MzKraORyIbvLOE21Tw1E4MXIw1nlLo3DeKNcfysvLi8nLFKXOU2HcCe9WO2OojmriKGZFdQIHdwNKksiSwP4XiQ4N/exa8tJUr/80c/JEOa8+r31ZJ1wuS50zgHOWj+PwRPXKqHmv5raZH7tUuShyzmpe/BSRPC+89e/FDVXGaYKjFDFUne/MdDwx0/eScpxO5EayAdV1bXWgwyObvN/cc4Mq4yykONELMxH3G1488eJQR8Wajm6DKmNmlmXhcl4ZHT9lETd2JSLeec9Pqkq3T5XzlliW6ov1OuG8mb4ONrNO3vb5cNu3zepOmp/SjZ/uiZgizvaHs5Yfqj3NxElscWDdevf0SprpRRGLGNDxzi5NzjVOmZ7zLELl9bq6H6a6em6p9TLT12W2zoavtWOT/kzbRBkzs5k0fA9aO/fBC9aTeWNxSzsYyyLumUedKdJE95H3SEttW1489s54HTFdVPu8dp9o/CYUAAAAAAAAAAAAWsdLKAAAAAAAAAAAALSOl1AAAAAAAAAAAABoXSsvoe688077hV/4BXve855nO3futJ07d9rznvc8+4Vf+AW7884727gEAAAAAAAAAAAANhDnKwufmL/+67+2V73qVfb85z/fXvnKV9qpp55qZma7d++2z372s/b85z/fPv7xj9uP/uiPrrmxAAAAAAAAAAAA2BjW/BLqrW99q73lLW+xd77znavyfuM3fsN+4zd+w9785jfzEgoAAAAAAAAAAOAksuaXUN/+9rft9a9/vcx/7Wtfa9ddd91aL9NYVeu8vAxnemWKUueN8nDBUaHLjEUZr1zlNNBre1WF0+MG/yhjHDnXcdrQRJroi3VTdTFdpknbm/SRVy4yb6CcSSYGsQ6kh9LwOHEUngxqEkR64kTOpKpVnjPMtbOIVF5V6vGuRazz8qqxbmDl1NdIGb5W7Kz9uJPIvCQLL7xsJpNl0umOzuv3wvXNTsky2YyTJ8ol09OyjPWdvF4/nN4Nt/u4eWm4n6Is3EdRtqzrglldmdWr53hd5OGfb7AHrFzGKddELNZYLNptZtZx5lURri9S1zGzOHLWuYit48I5IzXYFr0yuejywViXWRrp9g3G4c80FOnHy8sL1UeyiBWlrk/1RdvnPrVtFk67oSViL42cc4137lX1pWLvNTNLU53X7YbXedbRZTqZbnsm7g26mZ6oHXk/oetLnD5KVfiMnevocOeWU9T6NzMb5eG8wUiX8eJaXTs3V4JzbLUsDdfnxZrai+/izBiLRpQFX5vdpti7+XZEIhB59Xn3ZDJ2OfEp82KNmFcqppmZ9fo6T5Xr6tsXGddU3DLzY1ctinnr1ZznGupavY4uM93TefPi9mrHZv2hts3qDpzrhj9YtbBXlqkO6fue8oA4GIqzbrGwIOuCpmJDmunH295zhY44v3jnmszZtDvi/OLHBt32Xjfcdm+tTPf0op2bCpfbOqv76PQt4c90mkg3M6sP7ZF55SDcvmR2iyyztKQ/r7q/8s4uHjWVeh3dr2XlPYNW7x4mL+NRW2DDbfhJseYT1tlnn22f/OQnZf4nP/lJO+uss9Z6GQAAAAAAAAAAAGwga/5NqHe+8532ute9zm666Sa76qqrjvpOqBtuuME+9alP2Z/+6Z+uuaEAAAAAAAAAAADYONb8EurVr361nX766faBD3zA3ve+99muXbvMzGzHjh32whe+0G666SZ74QtfuOaGAgAAAAAAAAAAYONY80soM7PLL7/cLr/88jaqAgAAAAAAAAAAwNNAKy+hjjh06NBRvwk1Pz/fZvUAAAAAAAAAAADYIFp5CfVHf/RH9nu/93v2rW99y8zM6rq2KIrswgsvtDe96U32L//lv2zjMq2Lo3B6XtayTF7q+kZFOH041vUNnDx1rcJpX6WzJNUPTXltUNeKI90IbzzMVDldJkv0tVTbq8ppgkP2rVNhXTmTzMvDRKI4tiiOV2eoqCjWt5mZ1Xq+RfHkizJyFmUt1kM11nOqzHVeMQh/MHWd49WnxM66i7PAOJhZlITTzczSXiLzOnOdcJl+V5bJZqd1ffPhvGxmSpZJZ2dknk3PTpZuZtbrT5wX93V9UU+3Pcp64fQ0C6anC4u6bbC6yK0u8tUZIp4Hf/Y4ZVbywuuyrpvtGyoCREl4HnhtcIXi8BGpnvel2LC9Jqg9fpR75zRd39IoXG5hoBuxPNKxcGkY7ovhWJfx8kZiKhWFE99LPV9q8bEiZwi9853a61SR3Gk3zJLYLJngUJ84+3Ka6kGNxd7slel29Z6t8rrhrdzMzPpdPRd6nXCeSjcz62Y6b0ocHaa7uv+me+G86a7uo77zeZXCCe8Hl/Vn2nVg8ljt3QPnxWRr2cws1VNC3j9595i1E4eiSrVv8rkMrZb7sh642JkHTcTOmaJJ7MqyyWNXr6/LTDl5Kq5N9yaPd2miyzi3rVbXaq148VPXNyeOcdvmdJ9vm9V9tGUqHLvKA7tkmeqRR2XeaOlQML0unMOfI+qE76HUPVm9xD2UJ4ojiwMbQpqFH9h4zxu8dZ6KZxHuucZ5FqFjg378Pt33zhThee/FhlmxVszMdmwKfy6Vbma2bTacVy/sk2Xq8UjmRZ3w4WpQ6cPQwlAfRNRzde+s4Z0lVd/6z9t1pjqveee43Hn+WIpzjWqDd50Tbc0voX73d3/XfuM3fsPe+MY32o/+6I/aqaeeamZmu3fvts985jP2S7/0S3bgwAH75V/+5TU3FgAAAAAAAAAAABvDml9C/cEf/IH9yZ/8if3Mz/zMUenPfvaz7SUveYn9wA/8gL35zW/mJRQAAAAAAAAAAMBJZM2/a75nzx675JJLZP4ll1xie/fuXetlAAAAAAAAAAAAsIGs+SXUZZddZr/zO79jRbH6Hywsy9Kuu+46u+yyy9Z6GQAAAAAAAAAAAGwgrfxzfD/6oz9qO3bssB/5kR856juhvvCFL1in07HPfOYza24oAAAAAAAAAAAANo41/ybUpZdeat/+9rftt37rt2x2dtbuueceu+eee2x2dtbe9a532Te/+U27+OKL22grAAAAAAAAAAAANog1/yaUmdns7Kxde+21du2117ZRnVldmdXl6vQiD/98nMiqYievqkV6pZtWlKKQmQ3H4byloS4zyHVeXkTB9KoOp5uZ1bq6RiJxqVg3ofX64njyDxWrC5lZHphaR/QnvpJZ4jQ+Vq95C6cRzgSsVV45DqSJ9QIzM4uiyKLQPFGD5szDutJzIBLzI3jt76lUcDKzWsQgr0wxWP3PpT6WNwzPxWqs56hqg5lZlIQ/V9zX200q8nqbu7JMNtvTedPhlZzNTMkynflpmZfOzwXTo+kZWcZm5p28cH3x7GZZJJ7W9UVTs+Ey/fB1zMwszXR9Ki8K76dJ77C+DlbOM9Xq9VSrM41KN7M6FOuPU05e53jU+cmZO+4BSpSLMl1G7qGmz3C5E5+WRpOf01QZvz7d8OWhjv1LIm841mUGIoabmeXjcN8WhTNODrVvuWe4RPdFmoULJqJM22fcp5uqDq+L1DlvyLqcKdLphutLUz3WWUfn9cRW3+/qRkx19WSY7oXz5pxD/uYZ3b7t8+HPu21Wl4mWDwbTq6VwupmZLTv3BkI8u1XmbZnZJPPU+A5EzDAzy8T5zsxsLM7ItXPPmibOWbLBfWbpzNmoVBWqGNTwRhcnROQcDmJn7NS4euPtxa5uN3xOmurr508zfT3v56bCk1jFNDOzaRE/U90Ei51Nuytu12b7uh+8WLipGz6DFvsekGXK+3Te8oHd4YylRVnGcufsXIvA4Z11nfu/eP6UYHrUDd9nRuL5IVZ0uh3r9DpP+Oe9tdxx1nKWhReMV0atfzOz/lR4IU31dPtm+noTm5sKz5MtM3r+nLZFt2/HpvDn8p5rqseXnUw/kwnd/x6h1sr+/bofvPu1VIz9Jv2IR8Y7z0g/VrNDy7rtpXhemDv1DZz7P3W+6orQVTnPK0+0Nf8m1PHkeW7333//k30ZAAAAAAAAAAAArCNP+kuoO++8084555wn+zIAAAAAAAAAAABYR570l1AAAAAAAAAAAAA4+az5O6Ge//znu/mDwWCtlwAAAAAAAAAAAMAGs+aXUHfeeae95jWvkf/k3iOPPGLf/va313oZAAAAAAAAAAAAbCBrfgl18cUX2w//8A/btddeG8y/44477Prrr1/rZQAAAAAAAAAAALCBrPkl1Ite9CL71re+JfNnZ2ftR37kRyartCpX/hyjjhL984rzrVdxJKqrdZlRofMG43DBpZFXRjdwnIfTq1o03MyqSl8rFpdKYv2BU9Hlnkg3T/Z57LQhs8k/rzeGXh+VIk/1XVO1N2e9vDqcVwc+VCgN3xeliUWBCR6JyeP1pjc9VLnImVSRWihmVolJWo11C/MlHbjyxXCgqZ1FVJfOep0ObyuduY4sM71jOlxmPpxuZtbZNKvz5meC6elsON3MLJqZk3k2La7llInnt8q8ZPOOcJnZLbo+J69K+8H0sbNf5c4YTmoxcYI+VjadUDwuxNorx7KqeqwPFHU+DGeI65gdZy8SojTTeV29ZmMR8+qsJ8vUTuBVZ669C3puLwzCFS6NdJlxoef3YBT+TEtDXWZpqGP/0iDcjsGSnhODoR7DIg9/3rrWnzdyDnFpFm57muoyeraY1Yk4ZDY4e2JyiRO71VibmcXijNLp6DLdjr5WrxOej7N9PU/np3Vw2LEpPIG2z+s2bJ/XbS8fuiuYnn/nHlmmGiyEMwpnY3ZEU+Jcs+0MWaZ32gUyb7YfPjdkaXtnA7Pj3N85TyE6DdqRO9uZvKeuwnPCOYbDzMqitDhe3eGpN6gniDd2KualqRO7uvozTU2FY83slI5P89NOXJsK552+Rbdvfir8maZ7uiP6TjxO86VgenlglyxTfvdhmbe8X5Q7fFCWsQUnbzncvjrX5yTzzq1T4tw6t1mW8e7JsjMuDKYPpk8Lpg+zw7IurDwTCT0XabKWs0wfLtWZp9fX678/pfOmw1use3bZPOOda8Kf98ytug3bnPp2i3ulux7RZ5Qztob77+zNen3VhX7+czC8lG3/oo6R3v2aimvTXR3vvDg5ysPXyp321c5z+sEonOfdF3rPctRzenWOy1s+363Fmk8Kv//7v+/mn3feeXbjjTeu9TIAAAAAAAAAAADYQFr+/Q4AAAAAAAAAAACAl1AAAAAAAAAAAAB4EvASCgAAAAAAAAAAAK3jJRQAAAAAAAAAAABalz7VDQipy9zqIl+VHqkChX6XlnR67TTqe8Z5LfOWRuG8paFu38JAfiob5+G8otRlPGkSbl+W6vq6WbiMqmslT7ehEumRrs4qNy+cWakLHbc+kV7pPoqd4YgsXKHTBKvdxpdOSUwiThKLvcl6rEIPdB1Nvibrjg6/Zb46/h1PMShkXr6o6xsfHos26HnY29yVeVOnTgXTZ86YlWX627eE00/ZLMukm+Zlns1tCqfPzMki0awoY2bJplOD6fH8KbrM5h0yb8nCfXRoWUeGhUd13qgIj70XSjyx2LJiMc8XFxpe6CRRV6XVgdhdl+G1V49Huq58qPOGS+H00bJTX7gNnijr6LzA2e2xvI6IG7Xe1xYGet4/vD8873YfctaKaF7unCPHTuwfjsWacM52S0v68y4vhxs4WNbxfejE/qKYfG1mHb0vdutwXhw5e2mDOw21pTbYauEoS71WMqdcmobXS5xMfj9hZjbdC8/TzTO6zOlb9Jw7Z3s4L9l7tywz/NY3ZF69+8FwxtKCLGPi/sRSp2f707o6lT7We4LczM0skfu8rs6/9wsX9Mr0Ojqv3w3n5U48jkQ8NtPnIXUbkExwe4Dvq8W89+5t3fveliVinnZ7zr7n5E31wp/Xi13nhG8pzMzsmTvD8aE72ifLFLvvC6ZXhx6VZfKFAzpvED5L2rJINzNTZcysHobPoNVAn3XzBX1uVffIaV8/8+vu2C7zbMcZweTsgufLIoOtF8q8Ox4Mn/EeuiucvuycCbGyJ4X2JXUOUelmev2bmXU64XLdrrf+dX1zU+G4tmVWx7uzT9FtV+ea9OADssy3l06TeX/7zXCMGo71552fEvH9FH1fGDuP4vfuDffFwwf0mvCeg+fiTDvb12Wc6WLqFnT/oo7v+xd0heqecXmk2zclzkJmZlvnwv23fV68k3DqOtH4TSgAAAAAAAAAAAC0rrXfhHre855nUeCvKEZRZL1ez84//3x7wxveYFdeeWVblwQAAAAAAAAAAMA61dpvQr385S+3e+65x6anp+3KK6+0K6+80mZmZuzuu++2yy67zB555BG76qqr7OMf/3hblwQAAAAAAAAAAMA61dpvQu3du9fe9KY32dvf/vaj0t/1rnfZfffdZ5/5zGfs13/91+23fuu37JWvfGVblwUAAAAAAAAAAMA61NpvQn34wx+21772tavSX/Oa19iHP/xhMzN77Wtfa9/61rfauiQAAAAAAAAAAADWqdZeQvV6PbvllltWpd9yyy3W6/XMzKyqqsf+GwAAAAAAAAAAAE9frf1zfL/4i79o11xzjd1+++122WWXmZnZbbfdZn/0R39kb3vb28zM7NOf/rQ997nPPW5d9Xho9ThbnVFVkzcsVM/3dLN+MD2Oalmm0lk2GIXf6e1f0O/6Di859S0XwfSy1I2II11frx8e7ukp3b5I9EXS2uvLtVHj4Y3TKNd5XbEiRqmusFfq+jqZMyBtqgKNqJ2GwaIsszhbHR9qEWeSSE/6Ok30deLJF0s1Dq/9FYNgajHU4z08MJJ5I5E3dWo4PpqZbbpgXubNn7stmD571g5ZJjv11HDGNl0m2rJd5qWnnhVMT7acLsuU/U0yb+/h8JzYu6DjwoF79H51UMT2wUjHi9qJaZEo5kxL62a6wn4nnL5pOpw+LpzGYSU+h2K09/NCPR7qvNFyOH3gHDSG4XhiZmZluB11oidWnY9lXtyfDZeZ3irL3HufjoX3PRpOP7SkY+5wHF4s3pmhqvS6HIzCBYcD3e6lJX0IWVoM5y07ZYbLek5URXgMO/2uLBM3OOBFzuEzzXR9WSec1+2E66uLE3Sm2qDq2qwObBahtBXt9meS6PqyVO+Jc1Ph9p25Tc+dZ4pjg5nZ6Os3B9PHd39Nlikful/m5YdEDHXmfWd+Jlxk8xZZxjKx+ZpZ1AufyaKZTbJMkehz3OFBODaUTrzr6Ftqm+mH6/PCSRzrwJuKvs2d+zHvnKSO1ZE4QKlzFVZUZWmVOCOEqH42MytLHRticY200ucQbw+LxT1Zlun6pvu67Ztnwu276lJdX+f+v5d55R27g+nDwwdkGXv0kXBd+/fJIvlC+LxoZvJAVNd6nJKujl1xFn64Ejk3Kd2tczLPxP14tH2nLJI9/yUy777Os4LpX7lPB5TdX9N5w3H4c6nuGy47N2uwKI7cM+ax0nTyM6eZWbcbHoduV5fpd/Wa2DQTzjv3VOdcc4qOqaO7vhhMv3P6h2WZ/+cW3T4Vk+fndPsePhDeSC85zWl3rWPDroPhe5u9h/SaGOV6LsxNhT9vv+M989D1PbQ/XN/uA7qP1LibmU11w9faEr49NjOzM8OP1czM7Kxt4X6a7oWvc/iwc4g7wVp7CfVrv/Zrds4559gf/MEf2Ac/+EEzM7vwwgvt+uuvt9e97nVmZnbNNdfYtdde29YlAQAAAAAAAAAAsE619hLKzOz1r3+9vf71r5f5/b7+G1kAAAAAAAAAAAB4+mj1JZSZ2Xg8tj179lh1zD9p9YxnPKPtSwEAAAAAAAAAAGCdau0l1F133WU/93M/Z7fccstR6XVdWxRFVk7w7wYDAAAAAAAAAABgY2vtJdQb3vAGS9PUPvGJT9jOnTvdL6AEAAAAAAAAAADA01trL6HuuOMOu/322+1Zz3pWW1UCAAAAAAAAAABgg2rtJdRFF11ke/fubaWuOh9ZnWdP/Ocr/U/9xU65bDoJpvc7T/zaj7c0DP/2167duSyzZ/eyzBuNwp8rivVvmfV6ekg3b+kG07NOON3MrFepa9WyjPdLcEkcLpc4A+XlpU5fKEWp2740CqfHThv6Hd2GfhVO9+al1Xo+15WoMJSufhZmZhankcVpaCTc0ZlYlYXjSdzRa7Wu9BxN++GYMT48lmUGe4cyb8uzNgXTz/rH58sy8xedJ/Ois8LlsnMvkWWyZ1wUTP/uAd1H9+7R6+TAI+E1uXiPXqvDsV4veREuNxrr+sa5HsPxMNx2Z9it1w/vV2Zm87PhObtlVn+mLbP6WufvCF/rzK3hz3v4sG4bHDKeO/98sZNXj8U6X17S9S0c1PUtLQbTo8QZb2ffyX7wwmD6396lz0j3P6rX2KOHwu1YWChkmbGzzpW61guzyMP1edcZDnX7hoNw3mBxIMssH9bjq86LWVefczsdvQf2+uGYPDfXkWVmpnV9/W64nzppuM8HMeeaJtSZwpvb3jlE5XlHcufIY1tnwwWfeaouM/yHz8u88kt/E0zf9/df12VGOg51t8wF02fP2inLxFu2hTPmNsky0fxmmZfuODecfob+y5/eOenh/eG84Viv1+3zek5cfkY4DkWpjjV3HejJvKVh+FoHl517OH3UtboOz7FygtsqPE5VB+NALe7zi1zve97DqDoL51ZOfKrUoJpZkoTngXfGnpvS9f2T8x8Jpo8++j9kmdGBAzIvXxJ7vfN5o3TyM3jiBOSkH16X8fSMrtCJayZiYXLKmboNc6fIvHhuSzD9uwPdhhu/ojen+x8K3z+XzvOi6Wkd19JssucIpXfzB0vTyNLA85pQmple4yt5emyyjngu3NXjMz+t83ZsCrfjgs16o1r+fz8u8x581j8Lpv+3v9D3AN4cfsZZ4XONOpebmX13VzhufOdUbw7rc8ieQ+E+2r+gx2kw0O07tBQewyjSbdg2q9v+0N5wO7qZLvNjm78q87JnPDuYvlTps9B0rOdLJO6JBpW+J1svWnvaet1119mv/Mqv2E033WT79u2zw4cPH/UHAAAAAAAAAAAAJ4/WfhPqqquuMjOzl73sZUel13VtURRZWTp/sxcAAAAAAAAAAABPK629hLrxxhvbqgoAAAAAAAAAAAAbXGsvoa644oq2qgIAAAAAAAAAAMAGt6aXUF/5ylfs4osvtjiO7Stf+Yr7s5deeulaLgUAAAAAAAAAAIANZE0voZ773Ofarl27bPv27fbc5z7Xoiiyuq5X/dyk3wlV5yOrx9nqjCIPF0gDP/s9lSpjZnVVBdM3zW6RZeanEpl3eDkKpt/+N9+RZfY9sk/mTc1OBdM3bd8sy2w5dZPMK8uOSF89ZkdUIquswp91ha4viSdLNzOLIl1fNwu3I3aaFzuZS8PwtVI97K5YfS4x91bynLUi5nMdKBNKw/fFWWZxpmPH6gJ63kRyoM1SUa5Wi8vM0n5X5hWDYTB9efeyLHPhz5wn8858668E0//GLpdlbvum7osH71gIpi/9zViWqcq94XSnj0J7zRFFXoTLOPVFzvimWXirzDp6/nR7entN0/B8mZ3X437mafpal5wdjicvOFd/pvG3/17mFXfcHUxfPrw/nL4cnpM4DiduSO7eIeZ3rtdeuS+89szMDt55bzA96YXPEmZmp771f5d5//dt08H0B3bpdXn4sG77cCDWuRMbVPc1GQqPN0xeHGrC+7wm2jG3OXy+NDM74xmzMm/LXDh9pq8/8FQ3PE5m+myVxOHPtJRyrvEUeWVxsnosok64o7156t0blGIO54Wzxzrn8nO3h9u3fMP/JcvU998j8xbuui+YXjn3oul0T+b1t4fvC5NTTpFlbMu2YHI0u0kWSTadqvO2nhZM33VAD+J9j+q8Rw+F+3ww0gN11im6vuEXPynzlNNe9DqZd9cj4bEa6i3BxNHPzMwKQscJUYmOjp0baW9d5qPwgCfOg4PCiUNJEp7fW+d1mZ/a/x9l3t//oz8NpudLejJOndqXedsu2R5MnzlrpyzTERtztNmJT1Ph85iZmfXDeckpp8si6fazZd7SzBnB9K89pMf9gQdkli0OwmN4aEnPicOH9Xgk4v6vP6Xv42pn78zHYg2IuVeWTmWwKIosChwg1Lndu59X69/MrCOeKWapHp9upuPGWdvC82f41ZtlmW+c9TMy746vh9s3GDTb3L72lUcnLqPi7v0P6HuKU3foeDcah/vv8CH9XGF5ST/bz/NwfUWh72uiSI/vvQ+G897+ev1MZvn/+mt9rU74Oc/MaRfIMoNK99/eQ+H27RXxbnHBOSSdYGt6CXXvvffaKd87gN97b/hhBQAAAAAAAAAAAE4+a3oJddZZZwX/GwAAAAAAAAAAACe3Nb2EOtZdd91lN954o+3Zs8eqY/6Nh3e84x1tXgoAAAAAAAAAAADrWGsvoa6//nq79tprbdu2bbZjx46j/u3OKIp4CQUAAAAAAAAAAHASae0l1Lve9S5797vfbW95y1vaqhIAAAAAAAAAAAAbVNxWRQcOHLBXv/rVbVUHAAAAAAAAAACADay134R69atfbZ/5zGfsmmuuWXNddT6yOl/dtFoVGJSyrijJ9IWWDgaTq4V9ssi5W06XebP92WD66/63C2WZnz7/QZkXxUk4I3beHVbLOs+8vLC6CvetbFvD+jzJ5lN15jHfPXbE1/b0dJFaziQzi4Kp81O6z6e74TJmZlExDrchH8oydZHrPNV/ofQGfX0yiZLEonT1PI4SMbdVulfGzCwNx6Ao68gi8dS0zNt64UXB9Ave8SFZ5l1/uF/m2cdVxiFdpoEk0NfHyzv2uwUfL/biYAOH9h6UeXXlxYywLdv6Mu+iZ80E0//FM26XZYq/+5zMG9+xO5j+6NJAlilH4dhkZmYTft4Fry5YlHYsSlev97oUsT7ws9/Pc840Kg5Feo+q8kLmfeW/fCWY/oy7vy7LvOe/H5Z5Zl7eiRHF4b4one3SW/+qPk+c6NjV64fr63bDMcPMLM10bJ3fEt5LXnK53mO2z+vO6Hcm/7zqXNWkTKduN+6fLKoyvJfq1W+WJHrcRsPwHMkyPXeWhnqebu2E70/+W/LPZZk//0I4PpmZVUW4HWmmb3urkV7n9VfDefU/6DNKJM4olRdsHHFyn6jvHllmZlP4vtRMx64XXHGeLLPnsP68zznr2cH0WNwbm5l9fbfui10Hw31+YFHHgMFIz9nhOJw3GoevM3TmA8yKojCLVkeQWJ3nnbNGXekxrRqcvz0HuuH2TXX1uevHP3SZrvCZTp7gnin2hedp/ejk/eCdT5rc19TO85PX/rx+PjY/HV7nL3imbl8309f6h3vD6UtLOp4sHB7JvJnZ8NgXuW5Dk1vQfByOn3mu4ypWzi/BM4xz9lUi535IcY7sNj+l8+Z2/X0w/b13/SNZ5ub3f1nmqbZ767IJL+bGIqbcd6cTa5z2qWvVzvOfua3zMk/10a7798oyX5nSz4znN4cHuNynn6n3Xvl/yLyHim3B9MO7dB8dWtLPhReG4vwizjvLi+vnXLOml1Af+MAHHvvv888/397+9rfbrbfeapdccoll2dEPSt74xjeu5VIAAAAAAAAAAADYQNb0Eur973//Uf8/MzNjN998s918881HpUdRxEsoAAAAAAAAAACAk8iaXkLde6/4fVgAAAAAAAAAAACc1PjH1QEAAAAAAAAAANC61l5C/fRP/7Rdd911q9Lf+9732qtf/eq2LgMAAAAAAAAAAIANoLWXUF/4whfs6quvXpX+Yz/2Y/aFL3yhrcsAAAAAAAAAAABgA1jTd0I93uLionU6nVXpWZbZ4cOHJ6qrHg+tHierM6oy/PNF7lRW6axiHM5w6svv/KLM+6mH7w+m3/j//TNZZvyJt8q87vNfFs6o9Gfy1KL/ojjQ108gr1Eblg6GM9JMlsm/+zWZF/WmgukXzW7VjZjfIbMWBnUwvd+JZJluJOaRmVXD5WC6O2e98RVjGCxThT8LVkRJYlGyen5HqQiLgZ99TKer83r9cPrMnCySnHGBzLuz94Jg+v/94SVZ5vwLN8m873zroMx7qsVxs78n8W/esDmYftEZegyX/tP7ZN4jN/9DMH14YCTLDD+n86IkHE++vVnPo56Tl3TDczbu6C0+duZzlIbzojjc7nLkxDOYxfHKn2NEWS/88yrOm1lczerriH2lKnV92Vk678o/fE0w/aP36CYMh7q+Xq/d80QTdYN9Uc17M7OZ2dXnXjOzTkfHrvl5Z52LrCTW7e519F6ybT58npif0vWlIj6ZmZXNjp/SpMNRtHz9p5uiKC3OV6/BuhYx3YkNzrS3QgyESjczGw71fvSuvwjfA3z9jgdkmTTT9Y3yIpheiPTjqevwRI0i3UnqWrHXsY4kCceU3pSOJ2desFPmTU2F+2/sxPB7HtH3asOtlwTTu4uyiB108gbj8OcdjnX/eXn5ODw3R6Pw5x0Om82Vk11VqGcNek8szXlW02DP9sp0+uH1su/wJllm62nbZN7eBx99wu16Ihp9XhGf6rLZc4DeTPi+1Yu5N3xKf098LO4p/sqJn9586fTC567+dDjdzGx2Vseu8Tg8Z5vG6nLCfh+LGASfelzmraHKOcSO83C5vNDz4FD4MZ+ZmS1f+EPB9Gc8rNuQdZw9dnkYTPfWiqcWHejGahHf/evo8fDur5SFAwsTl/HW8tRs+FmymdlpZ84H0z/yjVNlmVnn/qquJ++/otRtH4u5qcosj9bPNzG11pJLLrnE/vzP/3xV+p/92Z/ZRRdd1NZlAAAAAAAAAAAAsAG09ptQb3/72+2nfuqn7O6777aXvvSlZmZ2ww032Ic+9CH7yEc+0tZlAAAAAAAAAAAAsAG09hLqJ37iJ+xjH/uYvec977GPfvSj1u/37dJLL7XPfe5zdsUVV7R1GQAAAAAAAAAAAGwArb2EMjN7xSteYa94xSvarBIAAAAAAAAAAAAbUGvfCXXuuefavn37VqUfPHjQzj333LYuAwAAAAAAAAAAgA2gtd+E+u53v2tlWa5KH41G9tBDD01UVz0eWD2KVqcX43CBwHUfU+Q6bzQMpw+WdJkDq1+0HXH4298Npj/jpafLMvf8/v+QefPn/M9g+tRp22SZ3qlbZV40MxfO6E/LMtabCqd3e7pMqqdV1AmXi7riOk4ZM7NIjG891GMYx3tk3nxX9EWu51hVVTKvzsUcc+ZlXTnzWVyrrleXCaXhcZJk5U8oPaTT1XVlHSdPlHPWUOysh4ufEV5fv/BqXebc7frvG4y+/o1gevnAXbKMHdRxsD58KJheLOo1WQxG4TYMRcw3syovdN77w3kPFXpN1E5eNhcew6Qn5oqZ9TY780WIO3qc4lRfK+6E50Ss5rKZWbx6j8WTI8p64X0sDo9PJNLNzOpExxq1V8azW3TjTjtPZqU7w3+BaPvdes879/x5mffonkEwvSxrWSZJ9DztiPWSdXT/dbLJy2TOuuxk4fYlzl/ximP9edUyTxNdJnNO8iqsLYqjiZlZ5lyrm4XTT1Q4qSrdNmiF2C+jqNnAqXU5Gul99PBhvZ8PxITs9nS823LhGTIvTcMLsK71/KmdudVk2qlredeJnIWkxspbe178VNfKCx3fF5f1te4rwoEoS/XnzQvdvlI0w5tjlbOXFHm4QjUcXl1Ymd/eelrFuVf2/k50JbKc062l4kxsptfRXXctyDJnP3OHzDvj3O3B9MJZR96ZpxIT34tBaq6W3j2PGwu9sWpPFOtx9/amNAuPvuo7M7OlRf3cZTAI95PTPLd9E60LMxs597rQ1Dry1tdY7ANmZvEwPA8WnUP2Q3t1JPqL/eF27Dsoi9hp5+tzzf5d4Wcvywt6Y668GNDg4K6WmLuWW/uVl+NLxVhl6ubFzHoz+vmZOm88+Kj+UNN9mWW9TrvniroOj6Ea9sFg/Tz7WfNLqL/6q7967L8//elP2/z89x9AlGVpN9xwg5199tlrvQwAAAAAAAAAAAA2kDW/hHrVq15lZit/I+Bnf/Znj8rLsszOPvtse9/73rfWywAAAAAAAAAAAGADWfNLqCP/FNk555xjt912m23bpv+pOAAAAAAAAAAAAJwcWvtOqHvvvbetqgAAAAAAAAAAALDBtfYSyuz/3969x8hV1/8ff51zZrYtiG1RCKAN0Vr9Ui7KTeVmG0kEa8FooqASMJoggikBQyQlUTGiiGIixIiYKImJxkuIxqiNGrmqIFjacpGLIVAstsIP6WXb3Zlzzuf3x9Jqu+f93p3Pfjq70z4fSROYM5/L+Vzen8+Zz+6ONDw8rLvuukvr169Xp7P7l+ytWLEiZVEAAAAAAAAAAACYwZIdQj300ENatmyZtm/fruHhYR188MF68cUXdcABB+jQQw/lEAoAAAAAAAAAAGA/kuwQ6oorrtA555yjW265RXPnztV9992ndrutCy64QJdffnlPeYXOiEI7H3+hrpoTdEs7s7JrXxvZ0dvrkurRUfNaMWuo8fX5/3eonV/Hrl/7oAMaX8/bbTONKqONJKk02sl6XbLbryjsNHlmX7P60Oun3C4rFEa67ohdhe12UZlVj1e++6xXoexM/KYeygrB6V/0JCtyZU3juDDCYuaMa28+eNcM9fBmO7uNTzW+fuTs5nghSd31L5vXwogxIbx6t+wYlM2a1ZydF5usvLKGdeAVVW7PrazVXPesY8e6OvdiUHPf504b5UPO/dahp3ImKivLm9vJaoeJ5D2ms8rHmGzWHGWzGuZnZuwn2rPtvIaa55ckhfqg5jTOfM3nNKeRpE3DzbGwyO15dNgh9rZyaNarGl8f2WHPlbqy18PMmC9FYc+jVqt5rFqvj+VnXlJhJGsVxhyX5E0XK13brYNdVgjNbVFZMUhSltnX1G3Oz6ufp9fQ4VQbkkIICmF8IwVjX+mNA0+303u6qrTneVOdx9hzeWSHvWa3jAHpxQZPMNrJikGSVFXNabw6ZM4+02wjJ41VB0nqjDbH8VDbk3nLZvsZeGjI2Hc59fPmv1V3757KsvdnNSu/0VGetzx1LdU9xI/YuZd7z14RusbnLlu32OO+1XLmrBEDvHFqxRNJsqZ5XPxMK/Ve34sNnsrYF4bgPDM6z6BZ3pyf93FWSp0RYo2nDsbezxgHZemsOc7HctZw9ObX1ogxvG2r8/mFk12r3fx8NfsA+5mxO2qXVXabx521X5Skwvh8oJe1YKpyZ2Jae7+h2c2f0UtSe5b9jNzpNLfFf/6f/Tlz51V2frNnG8/VzjOUNyZ6Df0jnT4FtUlItpqsWbNGn/3sZ5XnuYqi0OjoqBYsWKAbbrhBK1euTFUMAAAAAAAAAAAABkCyQ6h2u638lZ+QOPTQQ7V+/XpJ0ty5c/Xcc8+lKgYAAAAAAAAAAAADINmf4zv++OP1wAMPaNGiRVqyZIk+//nP68UXX9QPf/hDHXPMMamKAQAAAAAAAAAAwABI9ptQX/nKV3T44YdLkq677jrNnz9fn/70p/XCCy/o1ltvTVUMAAAAAAAAAAAABkCy34Q66aSTdv33oYceqlWrVqXKGgAAAAAAAAAAAAMm2SFUUnU19m9PVcNrklR27by8a1Z+dW0myYrCvNY+6IDmC3lm16EO5qVi1lBzdkNOtzn1U2bUI9j329gPkt12E1wLVn8U7d7rIEmVkV9n1MnPvt9g5JdlTrs6QrDGmHNPMZruyRv7GJsP1pxofH/kL45a86HTsZNsfsG8FsrmdFmrOV5IUuiMmNfq4ZebL5SlmcZti6I5PmVtO27lZfP8D058DF7csprWbiJXljffb228LklZ7cQM6768tcJh1S9z8rPS+AUZ+fUyj/ZDWWuocX5mecy6YuwzJMnIr5Jdzss77Dm2eXvzHMud/n7VHGd9Dc1jbruzp3GW66hpZFW9cKZDnjv7NCNd6vy86eqVZQl2FRSC3YC1kbBb2WncUOP0b+Pbe3z//qbqlirz8Wu3tZZ6a0TZdfYAhuANLC+dUb86s/PLnf1BXTVfK7v23jt3BmpeGO1klOOp3DRObDDqUDnt4E2wrvnHUOw28upels3XvHhstqvsGOXtC736Wdesbq8rgk2/eHHIkjtpameMWHFtdIf9uUHZsvdQWeL9b0wMrcrEnylYUn924fD6NzP2kqnnrNe3MWPW0un0r10HUV2Fxr4NVh9Etqe1RnQ7ceOqLJvTjeyw91beHsV81nfHqb2vKQpj3+XFViPWWPsTyY9pVt1zJ+YWzkNP2/js3GsHr/2sPty+vff9sSSVXeO52rknr217TTM6OnP2NVM+hHr3u989qff98Y9/nGpRAAAAAAAAAAAAGBBTPoS68847deSRR+p973uf2m3nt1kAAAAAAAAAAACw35jyIdTXvvY1/eAHP9DPfvYzfexjH9MnPvEJHXPMMSnqBgAAAAAAAAAAgAEV+SUn/3XVVVfpscce0y9+8Qtt3bpVp512mt7+9rfrlltu0ZYtW1LUEQAAAAAAAAAAAANmyodQO51yyin63ve+p3/961+67LLL9P3vf19HHHEEB1EAAAAAAAAAAAD7oWSHUDutXr1ad911l/7+97/rmGOO4XuiAAAAAAAAAAAA9kNT/k4oSXr++ed122236bbbbtOWLVt0wQUX6P7779fixYvjMqzD2L+m15uE2s4rGGm8dLl9NpcNDZnXijmzmtO0CrsOtV33rGhOV8yZbadpOYd+1n1lzlmkd81i9ZNk90fVtZN0eq+Cq67MS5lxzbkjKXf6N4ZTv2nJB2O8OOOOeSNdaY95jdrzrq5fstNZKmcsdIwJ5tUvZmw5scSKkVllz628jvgBBy+W2KFdocyaL2TG65K/9lhJnPXAkzlrlp3IqTuSCnmh0LBO1Op97fBCjTUtd3TsRMOj9rVRIwR4w21W286vnNV8Lc/tNF1r7smeYl4b5RFT2btWWNuqzK5E2+l2q20Lp41ST2UvdNlt6yWyK2hscxEp1EGhoZOstcXb1njrSsxaFbNOBWcwlt0yog5xk6Wuel/PU89La9dVFHZBlRcM1dyHXefnU/Pc3vvVxpjIvXHk9G9mNKCXxrtmDVkrzWiHZ6gYeeQcs8TMWS8+1WVzvzpPPKor57Mao37W+I3lje2o/NzY0Duvn6yyvDSVF3Od/oiRuq96VXa80YdOp5Ia1p6Wt5k21KN2XLfW0lEnjTePrEsdJ79uxFjw5tF0j+29UYeYvaS3Lvn7TGO96Nh1GHGqZ8U1bx/XanufCVrP1cZY3jFzYs2UD6GWLVumO+64Q+95z3v09a9/Xe973/vUaiU52wIAAAAAAAAAAMCAmvJp0apVq3T44Ydr/fr1uvbaa3Xttdc2vm/16tVTLQoAAAAAAAAAAAADYsqHUF/4whdS1AMAAAAAAAAAAAD7EA6hAAAAAAAAAAAAkFzEt5kDAAAAAAAAAAAAPg6hAAAAAAAAAAAAkNyU/xzfXlHVUlWNf70um98fQlw5RdH8epnZaTL7Wj57dvPr7YZ7mYy8uawsN+otSa22k5+RzmqHvSHUxst2G2WFc09WurJrV8HOzc7Pa/O8+Z4kKct7P+cNtZ1fT/kYbY1IXpxxxq83FqPKKiPma0z9vHp7YzRi/GZWrHPirZVmLF3zvMtadtt5M9W6o9ypg2q7D4NxLYuMxVbMiIk/Mby+gNTpjv3bkzNETN3KTlQa03y0a6cZLb38mq8VTnc7U0yz2lZZdoZFbteviljiQrBijV2ON7ytEOWl8aaldb+Fk8YJk+59zQTOcE7y/v1NqOvG9aCOeE7KnbU8dX4xa5W3/gajfsEZQLUTUHJjAlpruRS3LuZeOxhleWtC7gRrcx/i3FOrZdevstaLIu2kTfSINCEeoXx53jwHrX176v1o7YzT3LlWRWwcYuZ57j6/2G2R6jOAfouZL/vqHOt1rHtrD8bW86Y5WHabH3rqym5/b00sjY+Z3bp5z/rGpbJrFxRzzRs/1l7I491TatZcceNnxDUvjduHxrWydPazHbssK7wX7rjsfW+aG89+ZXfmxBp+EwoAAAAAAAAAAADJJTuEGhkZSZUVAAAAAAAAAAAABlyyP8c3b948vf3tb9eSJUu0dOlSnXrqqZozZ06q7AEAAAAAAAAAADBAkv0m1B/+8AedffbZuv/++/X+979f8+fP1+mnn65rrrlGv//971MVAwAAAAAAAAAAgAGQ7BDq9NNP18qVK/W73/1OL7/8su644w696U1v0g033KCzzz47VTEAAAAAAAAAAAAYAMn+HJ8kPfnkk7rzzjt3/RsdHdXy5cu1dOnSNAXUwXi9ttME55qlcJplaJZ5KbPSVaWdXzDuSZKyrPl1r34t51pR2Nd6FdOuUlwfVl27GtaF3L7XrLbPXoN1qbLrl9WVk1/CNvf0q5z9gTUWvfnjjl97fETll0f87ICXnzV+SyduOWM+OjY0yJx7zVreHG+ODF7LebW20gUrRksKuRPbrf6w4uMEsmme/1lutwOkbhXUrcb3bcxy6A2R0W7zxVFnKnfs5TVqOBbOJGu3es/Qy6+qm8edt60K3kWDM83Na3lml+PlZ92vl8abflY6Lz9PCFaGcbHLUljbX0KNqw5BdcQYt/KyBCM4eGuBl19uBj07AFTOqm3tATy5V3fj9eAE61y9r8u1c095xN7P6idJqo37zZ00Zem0uRFUqoa1bzJithWRW6hG3r1irL+tPu9Vniifnbx13pqz3pNa7uSXGfsQb/R4zzYxrLjrzf/UvNgfs16krnvq5xSvflmPa3AV8znBfiSE0Din625zu9XeZwdl7+MgJp5IUm2Mkdr5TLEunc8UvYfDCNaeLHU5g6w25mZZ2vu7Onh92NzmlfOwWzgPPkVhxFZjTe10Zk7fJjuEet3rXqcdO3Zo6dKlWrp0qT73uc/puOOOS7ZBAQAAAAAAAAAAwOBI9qMYhxxyiLZv366NGzdq48aN2rRpk3bs2JEqewAAAAAAAAAAAAyQZIdQa9as0caNG3X11VdrdHRUK1eu1Gtf+1qdeuqpuuaaa1IVAwAAAAAAAAAAgAGQ9Duh5s2bp3PPPVennXaaTj31VP3yl7/Uj3/8Y91///267rrrUhYFAAAAAAAAAACAGSzZIdTtt9+uO++8U3feeacee+wxHXzwwTr99NN14403asmSJamKAQAAAAAAAAAAwABIdgh1ySWX6F3vepcuvvhiLVmyRMcee2yqrAEAAAAAAAAAADBgkh1C/fvf/06V1dg3VeVZw+sNr0lS7ny1VQhOOYXxupPGa7HMqF9hlCNJdW1fs+7LKkeSWm37mlUPr35WWZnX5s49ySjL66cYdWVeCqWdLLP61xorkoJzv5nXFHub0wbQ2JhrGnfW9Kr62J514vngzUlr7pVdO43XFqnncoTMWCuCtYZIyoJ9zUqXeV+rGBPb3bA6ncFkAk67QiqrsX97sqa519Xdyp5fpZGudNI4l0zelqtw9k/twpiXTszInP1OYTRg1cep4m3HLN50MbeRTptnmd1+MVMz5p5Ss8ZlzHjdn9RlpboYH2wyY9LGrit2fnEdVBvj23k68cuK+MZjtymM/XTuTLDa2CdZbSdJwRngtRHYcic45BFlOVshtz/Sfcv0mNrYjHvrRYzKaIeyJNgMKi+uWVe84Vu7V5vHiRcb/GDTO/djlwhejLLUTZvcCaSud+qyYvemVllWflWXz2s8VbdUmY//8M7aA2R53MAqjLW0ch4qYvY8Zdf+IDKmLC/exezx3D1K4vysz2timXPMadfc+UzLql/m9GHLOSzoGCtQyxlG3se5pVG/oaHmNq9n0GdJSb8Tqqoq/eIXv9Df//53SdLixYv1/ve/X4V3yAEAAAAAAAAAAIB9TrJDqH/84x9atmyZNmzYoLe85S2SpK9+9atasGCBfv3rX2vhwoWpigIAAAAAAAAAAMAMl+yX51esWKGFCxfqueee0+rVq7V69WqtX79eb3jDG7RixYpUxQAAAAAAAAAAAGAAJPtNqLvuukv33XefDj744F2vveY1r9H111+v0047LVUxAAAAAAAAAAAAGADJfhNq1qxZ2rp167jXt23bpqGhoVTFAAAAAAAAAAAAYAAkO4Ravny5Lr74Yt1///0KISiEoPvuu0+XXHKJzj333FTFAAAAAAAAAAAAYAAk+3N8N910ky666CKdcsoparfbkqSyLHXuuefqW9/6Vm+ZVbVUVZN/f5bFXcuNM7iimHzZkykrBDtNXdvXrPp59+TVPTeuZc5ZpFWH3GvziLNN555CbY+FzLinUHbtNM6oD6VVTkQ/SQrJjnlfqYfVtk1t5I0tSHVobiNrLHrN6c1JS3AyjJlDsWVZ8cmLwZUxUSR73Hl16JPMmauq7TidGzGjLp3Y5P2MR8zc9Oo+zdx2hapKcobKON3KHoulM3Qq45oztOOGoretcmKhdanlbrmceWlkGBOO3Ro47RdTlrstNa5lmV2JmC2w14cerx6YfnmrUN4woYIXBCKEiMDhrRNW/SrZgbNwnnestdmtgxNrMmPCVE6sLormsmLabqwOVn52HSr3+an5nnKnjbz7TR0a8ogMvWFutVOr3Xy/RZF4IYGpdhbZQs39ULufE9mxwZiWqq0NlOJ+YtvJzo1Deezi3FRO5GbIalsvv+BtlAZU7a6b6e7XG/8YW8/rYvIPUd7HDV5b16URayL7x9qHeHPF2x9Y6fxx2jtrbyCl/yjH3L8462/qWOPtocw+tBYSSWXX/oysZRy9lM6HjO4zt1GPbrf5nspy5sSaZIdQ8+bN0y9/+Us99dRTevzxxyVJRx11lN70pjelKgIAAAAAAAAAAAADItkh1E6LFi3SokWLUmcLAAAAAAAAAACAATKlQ6grr7xy0u/95je/OZWiAAAAAAAAAAAAMECmdAj10EMPTep9sX+TFgAAAAAAAAAAAINpSodQd9xxR6p6AAAAAAAAAAAAYB8y5e+Eevrpp/WGN7xh5v62U573r6wQ0QZ1sK/lRn6Zc09ePxRGd3tp8sK+ZqaJaIfgtIOnrppfL5w2quuei/Fql3zkO20eQnPdM29MoDfWWPQ6ujLGoZufN+8i5kPEuJZk18/Lz5mvwczPSePFQYO75hgxyC3Hi1tG92bO+hJkt1+miPka278Gs5+QXBWCqob2trq0dLq6cq6VVXOfJh46rrazZajNMRe3ilbGfPZCQ4jZpyWWZTHxzr4Ws+WaKayx2c+t+74k1KFxnau9PYoh5rnOWxMzZ6Baa7O3ZocsYi/vBEOv7mYap41qo+555IStyuY+LFoRz2mSrC1KZT1Xye/DPDS3nx+PnWtGutiti1WPylg3rdfRX1YM8MaiJ2Ye1c7GK+7zLzs/q6iY+OR/emGzYlTlbUATliPZ8dPjxfeZIK4PUXZLZXk56ffHtnPprH0xrPlSGzFI8p/Nrdjl7e/cPVTEHEvNiuOx8d2KAV5s8K7VRj3Krt3mrbZ5Sd3RTuPreWGvP97a1DLWEmu2lN4HDH025Wi4aNEivfDCC7v+/7zzztOmTZummi0AAAAAAAAAAAAG2JQPofY8sf3Nb36j4eHhqWYLAAAAAAAAAACAAcbvhQIAAAAAAAAAACC5KR9CZVk27u/hztjvhwIAAAAAAAAAAEBftKaaQQhBH//4xzVr1ixJ0sjIiC655BIdeOCBu73v9ttvn2pRAAAAAAAAAAAAGBBTPoS66KKLdvv/Cy64YKpZAgAAAAAAAAAAYMBN+RDqBz/4QYp67C7Lx/7tKdT2+01GmonKtxReQuNi7dQh5g8i5k4ir+7Wn0ks3JvqvZzU3Pbrve6hrsxr5h+SdMqJyi+WUY/QMDeaXsN/hRAUQhj3utlnTj+bc0uKCkFqqNeUeHPIGideHWLyS6yp7yaS5XY/edXOrHiXe/dqx8gQMSiyiMUiOP2U8s/m8id4fWUtlU742FPlDI/aGfd1RNjw8rPkzjxSZeeXW+Mk9+rQ+9jyb6n5YkzbxfKazxI7xayyvPyyrH+NYW1nC2u7Sqhx1VWtuuoh2EQy119nzYnZGuQte+9dOYHSWuvNGCR/vbTW82DEE68OlRMjvbXUirt+vR3es6TFKaoy9sjevitG7tS7dtrCSheM/qidfoKU5bmyhjaNHo/TLPU88uZycDYc1nzpZ7vWffrK+Dpy45W6Lbz+sPjPk835WZ8X1b08IOyHQmjec1jjJ4/8DCVmPHpj0RwHTv0qZyxY6WLGb2ruZzLeZxHW55pujPSKMsaEk5+3l0wtZj/kpSlLY/0xngO6nZmzPvfxJAEAAAAAAAAAAAD7Cw6hAAAAAAAAAAAAkByHUAAAAAAAAAAAAEiOQygAAAAAAAAAAAAkxyEUAAAAAAAAAAAAkuMQCgAAAAAAAAAAAMm1prsCPcmMM7O8ttPUzjlbYbwegpNfZl+z0hWJz/oypw65U5aVzmpXScoj0vRRqKvG17Pc6lzF1d0oZyLWSHLrVzvjuReRdd7fhcoYU7HzThH9WSUaAzt5Mc3ijENr3o2lM8oKXn6936/XHxF3q8zpw2D0YeatL966ZPz8h9sOVix2ZIl/ziSmnzA2JZqmhTXNa2e+xnRBFTMhInmhsG283q3ssV1nduULY07EhDunmBkhYvpLcrZ9kTds1SP31kf0TR2C6oZgk8cOoD6x1t9g7SckZc49Wem8JduTG4HX3TcYdfDq7Wnq16mIeTQNUXvJ3pN4yqo0r3n7wqrHZ6LKeBaAz5oTseM+Ru30nVW/2O1tbg1w97nQ0adtth8/e6+EF6vj6tC/TZkV19znTKd+Mfmhd9Y4Tf4RSkRfj6WLmEfe81/ZHNe8Z0a37kb9Ytb5fo5tr12zovnz1dh+slYSb+9X1vYepdVuPnrxnnXVtfOrjXrkxgavSj05pmBmnCQAAAAAAAAAAABgn8IhFAAAAAAAAAAAAJLjEAoAAAAAAAAAAADJcQgFAAAAAAAAAACA5DiEAgAAAAAAAAAAQHKt6a5Ao1xSnjVcKJrfX3mZORcz6wyuttMURh08IfSeJlbW1G47rxn329jWeyHNROkiZLnRH7XT7+7Ra0T/9lNtjM1We/xrVttgTKjH/k327c7Ayax+8eSJfwYgpg6SghWfemibyaQLddo4aNZ7AGRmHLTHRIgaY5Hx1uirzBiz1utIL/E0iuINK++aNYK94dOSnWFpjVOnDiE0XyzcNPa11Ly6x+XXe+UTb9OSL3WwFXmmohjf4KnXy8wYqF45VhrJXt+8tSVmT5E7daidupvXKvtZozCeF716B/V+T/Z+wleV7sNzozyiLO+O/P7tfUzUTn/0WodB3mPORN64jxnDyfOLjF21UY/c+yzJE7FgevWzpH4mixFbh37NzdhyzOc1Yk2UqqqUN6xX1vjx2tN7ljbXAieNNf89sfWL4cXCmI95zHjnhC1/79ecX+3kVzjPhXY59s0GN342p/P2GrlzVmDVIzj95A0Ja52pjERVWdqZ9RmPhgAAAAAAAAAAAEiOQygAAAAAAAAAAAAkxyEUAAAAAAAAAAAAkuMQCgAAAAAAAAAAAMlxCAUAAAAAAAAAAIDkOIQCAAAAAAAAAABAcq3prkCjLB/7t6eqst9vKZxyQt17ojr0nl/uVcJh5efdb57Z17x0KdPEyJx65xF18No85p5qa6zIr1/dPGadUWSmkaSsNTT5NE4+0NhcbprP3hwyhOD2aDMrnvWbFWdiYp2kYKQL3hyKSTPDZU6cCU77mflFxMFBbr99SVWP/dtTbcQNd6r0sUutUBgbucwh7N2TM+xbaq6g1a5jRUXEaqOcvSHLYupni1jOJsivf22BdGpjjc2dARK1r5nhqqZAPAmZ0U4x88Fbl2PW+VhW/2bOPVnjKFbuBH+rLaoybgWyxrrVH+yffKGuG9uon2M4htWvXr29WGjNF2+uuHE3cf0wsX7NdWJNnKIoVLTGf67XHe02vj+2PVP3gzUvvXKsz1Ak+9nGS+OWFRE3vNjVL+795ta1yL2u9RGZU4css9u8ttovcl8TGuaFJBXFzF6HJX4TCgAAAAAAAAAAAHsBh1AAAAAAAAAAAABIjkMoAAAAAAAAAAAAJMchFAAAAAAAAAAAAJLjEAoAAAAAAAAAAADJcQgFAAAAAAAAAACA5FrTXYFGoR77t6c8a35/Hey8sohztqayJ6qDJKloftmrX0x+qcW0kce9pz6pK/taYd9vMNJludMXtTdejLK8+mF6mfPV6bOZMOY9XgyyeHEQY7x+j2jzzMkvxPQhZoQ6BNVhfP9ZS4e7ZXCWazO/Pk7lPGZOeFsQr+5WutqLxxHzKLPT9Gtapl5i8iwuQ2/8xShm+NI5aLI8V9bQSXlD/Nkr5TvjKjh1qI2J5D0FNd3nRGLXWPNa4gEcooJ12kkZnBjptZ+ZxhkTVr+PXWzec3vjyGM1rbtmwWTFmtSa9k6Sv4Z5czlmDKfmjXtrPMbFhjhWv6auQ+z4SV0PNw4ZvLjRa34x5e9Pup2upO6416uyeY3w+sYbc1Z+sWuONU69+GTFu1he3a21OeZ+vXXeY7WR97lr6hjuxZOsaK6HlybmE14vonlj1rqWtY3X+7BmT9bMqQkAAAAAAAAAAAD2GRxCAQAAAAAAAAAAIDkOoQAAAAAAAAAAAJAch1AAAAAAAAAAAABIjkMoAAAAAAAAAAAAJNea7go0qiXVYfzredZ7XqHu/VqW+Gwud+rglZW6fkURly5lHVK3bQxvTEQkyXK7XUPZ7TmNWu3JVuu/6oYKNr2GXUJVKVTVuNezmDhTz4Bx7Yka8w0xeFLpjLKc/Mw0M0SWN/dvbL2zmDjorCNWX1n1Hkvj1L3XORAzZ+BNCTuN021V3JTtWeENX6d+1iV3+MSU5aTJ1VxYbAiy6l4HuzPyzL5hK52XJjUnbEQpIqreMrZI1usYM//QuRqafdC417e8NNz4/qphD7RTXdrXLN6akzsTPTeCYeEGG5s3/yxeWd59Waw1NnZdttJ5e1avD2Pyy5w45PVvSt7zk1c/y+wDmp+5Wu3m5zeMaQ211R4a33Zlt2x8f+wzRT/XPou/X067YKZ8HPLmZO31R90cN2LnuFmWUc5MEZx1JKafhubManw9K4g1nrmHzNPQrPH7mq3/2dr4fm/dq509j8XbG1RV78/mubORzZyBZZXl713sOWt+dmCmsMWUI9l1d9so8ZoQs7/zeHHSGy+WVsSeMbfaNfUD3hTMnJoAAAAAAAAAAABgn8EhFAAAAAAAAAAAAJLjEAoAAAAAAAAAAADJcQgFAAAAAAAAAACA5DiEAgAAAAAAAAAAQHKt6a7A/wohSJK2bt/R/AbryKz2MnUuWteyxGdzXh28slLXr0h4X14d8qz3dJmTJrfLyvLCTmfmF5HGOa/NnPqFurkPvTRqtZ2yJl/3rcPbx+rwyrzCmF1xZmS08XrmjV9L6piRmheDzCRx48Ya83LGoZnGK8cb10Z+3j1FNJFZzti1tPMuOBWM6Ssvv15tHe28kiex5n/tbI9tW7c0Xq+q3vP0hlxlNL8/TO0+s9J5w827VloVdLhlGfWLKMZtoxheu+bOfsdK56VJzduexCgiqt4ytjrD27ZKItbsaWd7dEa2Nl7vjg43vl45Qaguew9Q3t7W21tZa1gd+dzizT+LN8fcPbshZv/v7YWsdF67en0Yk1/mtlF/YpQ7xiLiZJ43P3PtnEvEmt3tbI+yY8SUbumma+L1W/K1zxinqedlrJgxbMm92BDx3ODl54kpayaIHbNmmqLb+Hq3s23C8vZHO9ujO7qt8frOdtuTt+7V3p7HGKfeuK8q59ncqEdW25/lebGmNsqKeaaQ0o43bz545YTK2Ic4bRS3zsft76yy3H1XZdc9Zm8anLaw9sh5q3kd7o7OnH1NFmZCLV7xz3/+UwsWLJjuagD7lOeee06vf/3rp7saMwZxBtg7iDW7I9YAewexZnfEGmDvINbsjlgD7B3Emt0Ra4C9YybEmhl1CFXXtZ5//nkddNBBSX8SBNgfhRC0detWHXHEEcpT/2jzACPOAGkRa5oRa4C0iDXNiDVAWsSaZsQaIC1iTTNiDZDWTIo1M+oQCgAAAAAAAAAAAPsGjtsBAAAAAAAAAACQHIdQAAAAAAAAAAAASI5DKAAAAAAAAAAAACTHIRQAAAAAAAAAAACS4xAKAAAAAAAAAAAAyXEIhSkLIUiSvvjFL+72/wDguffee9VutzUyMrLrtWeeeUZZlunZZ5+dxpoB2JcQawD0y3333aczzzxTr3nNa5Rl2W7/tmzZMt3VA7CPINYA6AdiDVLiEApT9p3vfEe33nqrhoeHdfXVV+vuu++e7ioBGABr1qzRUUcdpdmzZ+967aGHHtL8+fN15JFHumkff/xx3XbbbXrmmWd2+2AZAPZErAHQD2vXrtXSpUt1/PHH65577tGqVat08MEH68wzz9RPfvITvfrVrzbTEmsATBaxBkA/EGuQGodQmLJLL71Umzdv1k033aRzzjlHS5Ysme4qARgAa9eu1fHHH7/ba2vWrNFb3/rWCdPWda1vf/vbWrVq1W4fLAPAnog1APphxYoV+uAHP6hvfOMbWrx4sc466yx95CMf0fDwsD784Q+7aYk1ACaLWAOgH4g1SI1DKEzZLbfcorlz52rFihX61a9+pXvuuWe6qwRgAKxZs0Zve9vbdnvtoYceGvdak/Xr1+vCCy/U61//eu3YsWPvVBDAPoFYA2Bv27Rpk+69915deumlu71+4IEHKsuyCdMTawBMBrEGQD8Qa7A3cAiFKfvUpz6liy++WAceeKCuv/56nX766dNdJQAzXFVVeuSRR8b9dsLq1at3+2D4hBNO0H/+8x9J0p///Gedd955kqSzzz5bH/rQh7R8+XLNmTOnb/UGMFiINQD64W9/+5vquh73G5Z/+9vfdNJJJ0mSPvCBD+j888/XySefrIULF+rBBx/c9T5iDYDJmEyssfY0ErEGwOQQa7A3cAgF02S/yHvnKfgXv/jF3f4fACxPPPGERkZGdMQRR+x67S9/+Ys2bNiw64Phsiy1efNmzZ8/X5L08MMP69hjj931/sMOO6yvdQYweIg1APqhrmtJ0vDw8K7X1q1bp7vvvlsf/ehHd/3/CSecoAceeEBf+tKXdOONN+6WB7EGwEQmijUT7WkkYg2AiRFrsDdwCAXTVL7IGwA8a9askSTdfPPNeuqpp/Tb3/5WF154oSSp0+lIkp588kktWrRoV5pHHnlExxxzTN/rCmBwEWsA9MM73vEOzZkzR1dddZUef/xx/frXv9a5556ryy67TO985zu1bds2jYyM6LOf/awk6aijjtr108MAMFkTxRr2NABSINZgb+AQCqapfJE3AHjWrFmjs846S08//bSOPfZYXXPNNbr22mv16le/WjfddJOk8RuZBx98cNxP1wCAh1gDoB8OOeQQ/fSnP9Vf//pXHXfccbr88sv1mc98ZtdvOz388MM6+uijVRSFpLE/CUqcAdCriWINexoAKRBrsDe0prsCmLnWrFmz689H7DTZL/IGAM/atWt18skn68tf/vJur/9vzHnppZc0b948SdKf/vQnPfroo3rjG9/Yz2oCGHDEGgD9snz5ci1fvrzx2rp16/Tss8+q2+1qy5Ytuvnmm3X77bf3uYYA9gVerGFPAyAVYg1S4zeh0GiyX+QNADHWrl074U/KvPe979XPf/5zXXjhhVq1apWOOuooZVmmDRs26LLLLtOjjz6qK6+8sk81BjCIphJrbr31Vt17773qdDr65Cc/qRBCn2oNYF+zbt06LVu2TCeeeKKWLl2q66+/XgsXLpzuagHYx/D8BKAfeH5CjCwwItDgscce09FHH60nnnhCb37zmyWNfZH3qaeeyp/kAzAlGzdu1OGHH65HH31Uixcvjsrjqquu0ksvvaTvfve7arX4pV4A40011jz66KP67W9/q06no+XLl+u4447bC7UEsD8444wz9KMf/UgLFiyY7qoA2E/x/ARgb+P5CR5+EwqNJvNF3pL0gQ98QOeff75OPvlkLVy4UA8++OB0VBfAADnssMMUQog+gNqyZYuef/55DQ0N8QAFwDTVWLN48WL9/ve/1/DwMA9QAKZkw4YNHEABmDY8PwHoB56f4OEQCo0m80Xe0tifljjhhBP0wAMP6Etf+tKuL6kDgL2hLEtdccUV+vrXv665c+fqySefnO4qAdhHZVmmdrutq6++erqrAmDAPf3009NdBQD7KZ6fAPQLz0/w8Of40Oiss85q/CLv/7Vt2za95S1v0fr161UUhVavXq2VK1dq1apVfawpAABAWps3b9bKlSt1zjnn6Oyzz57u6gAAAADAjMXzEybC7+Gi0dq1a/WJT3zCfc/DDz+so48+WkVRSJJWr1494Zd/AwAAzHRz587Vt7/97emuBgAAAADMeDw/YSIcQmGcjRs3atOmTRMeKK1bt07PPvusut2utmzZoptvvlm33357n2oJAAAAAAAAAABmMg6hMM7OL/KeyLp167Rs2TKdeOKJCiHohhtu0MKFC/tQQwAAAAAAAAAAMNPxnVCIdsYZZ+hHP/qRFixYMN1VAQAAAAAAAAAAM0w+3RXA4NqwYQMHUAAAAAAAAAAAoBG/CQUAAAAAAAAAAIDk+E0oAAAAAAAAAAAAJMchFAAAAAAAAAAAAJLjEAoAAAAAAAAAAADJcQgFAAAAAAAAAACA5DiEAgAAAAAAAAAAQHIcQgEAAAAAAAAAACA5DqEAAAAAAAAAAACQHIdQAAAAAAAAAAAASI5DKAAAAAAAAAAAACTHIRQAAAAAAAAAAACS4xAKAAAAAAAAAAAAyXEIBQAAAAAAAAAAgOT+P3+OOBE9mGiSAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "result_ground_truth=np.concatenate([mean_field_test_gd[index],std_field_test_gd[index]],axis=0)\n", - "\n", - "CHANNEL_NAME_MEAN=[r\"$\\mu_p^*$\",r\"$\\mu_{u_x^*}$\",r\"$\\mu_{u_y^*}$\"]\n", - "CHANNEL_NAME_STD=[r\"$\\sigma_{p^*}$\",r\"$\\sigma_{u_x^*}$\",r\"$\\sigma_{u_y^*}$\"]\n", - "\n", - "from airfoil_diffusion.plotter import *\n", - "show_each_channel([result_ground_truth,result_diffusion]+result_fms,\n", - " channel_names=CHANNEL_NAME_MEAN+CHANNEL_NAME_STD,\n", - " case_names=[\"Ground truth\",\"Diffusion 200\"]+titles,transpose=True,inverse_y=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "whqPXFippyzR" - }, - "source": [ - "The code above produced 100 samples with each method, and the image of the previous cell shows the mean and standard deviation for each spatial point in the regular grid. This illustrates that the mean is relatively easy to get right for all methods. The corresponding fields don't vary too much, and even the 1-step FM variant gets this mostly right (with a bit of noise). \n", - "\n", - "The standard deviation across the samples is more difficult: 1-step FM completely fails here, but, e.g., the 20-step FM version already does very well. This version only uses one tenth of steps compared to the DDPM version. The latter uses 200 steps, so the FM version is effectively 10x faster, while yielding a comparable accuracy here.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Quantified Results\n", - "\n", - "So far, we've focused on a single test case, and this could have been a \"lucky\" one for FM. Hence, below we'll repeat the evaluation for different cases across different Reynolds numbers to obtain quantified results. In total, the test set has six different Reynolds numbers, the middle four being interpolations of the training parameters, the first and last being extrapolations.\n", - "\n", - "The `do_test()` helper function defined in the next cell directly computes the statistics for a given network over the whole test set.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "id": "oE0ObxRx_jdD" - }, - "outputs": [], - "source": [ - "def do_test(sample_func):\n", - " mean_predictions=[]\n", - " std_predictions=[]\n", - " std_a_predictions=[]\n", - " for input_field in tqdm(inputs_test):\n", - " mean_fields,std_fields,_=sample_func(input_field.unsqueeze(0))\n", - " mean_predictions.append(mean_fields)\n", - " std_predictions.append(std_fields)\n", - " std_a_predictions.append(np.mean(std_fields))\n", - " return mean_predictions,std_predictions,std_a_predictions\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Because of the larger number of test cases, the following cells can take a bit longer, especially for the diffusion model with its 200 steps.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ld8sTk1qpyzR", - "outputId": "e44918f5-8436-4f9f-bab0-59ccaed4c6d2" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [00:01<00:00, 4.35it/s]\n", - "100%|██████████| 6/6 [00:06<00:00, 1.08s/it]\n", - "100%|██████████| 6/6 [00:25<00:00, 4.28s/it]\n", - "100%|██████████| 6/6 [02:09<00:00, 21.59s/it]\n" - ] - } - ], - "source": [ - "std_a_fms=[]\n", - "labels=[]\n", - "for step in [1,5,20,100]:\n", - " _,_,std_a_fm_i = do_test(lambda x:sample_flowmatching( network, x, dt=1/step, num_sample=500))\n", - " std_a_fms.append(std_a_fm_i)\n", - " labels.append(\"Flow Matching {}\".format(step))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "jjoAQ8u0pyzR", - "outputId": "2fe75d92-8f35-4426-9b21-3fa555613c06" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 6/6 [03:40<00:00, 36.68s/it]\n" - ] - } - ], - "source": [ - "_,_,std_a_predictions_dif = do_test(lambda x:sample_diffusion(diffusion_trainer.diffuser, dif_network, x, num_diffusion_sample=500))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we have all the numbers, and the next cell produces a graph plotting the ground truth standard deviation per Re (blue line) next to the esimates from the different trained NNs.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 457 - }, - "id": "UFlXoT1KpyzS", - "outputId": "c28f9035-7cc3-4812-db24-a964dc0e8172" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "x=[0.5 +2*i for i in range(6)]\n", - "plt.plot([0.5 +i for i in range(11)],std_value_gd,label=\"Ground truth\")\n", - "plt.scatter(x,std_a_predictions_dif,label=\"Diffusion 200\",marker=\"o\")\n", - "for i in range(len(std_a_fms)):\n", - " plt.scatter(x,std_a_fms[i],label=labels[i],marker=\"x\")\n", - "plt.legend(bbox_to_anchor=(1.0,1.0))\n", - "plt.xlabel(r\"$Re \\times 10^{-6}$\")\n", - "plt.ylabel(r\"$\\sigma_{y,a}$\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "E_hDWNLppyzS" - }, - "source": [ - "The graph shows that the single result visualized above was not an outlier: 1-step FM doesn't do well, but 5- or 20-step FM are already very good, and largely on-par with the DDPM variant. In general, the accuracy of the NNs is very good. Even the last and first dots, the extrapolation regions, are captured reasonably well. The networks over-estimate the variance for the low Re cases because they haven't really seen static cases in training data, but the potentially more difficult high-Re case on the right is handled very well.\n", - "\n", - "Overall, this setup is a non-trivial case: the networks had to learn the posterior distributions from almost constant to strongly varying across the differen Reynolds numbers. The _flow matching_ NNs really excel here: they yield excellent estimates and posterior samples with a very small number of integration steps. This is important for practical applications: these surrogate models have to compete with classical numerical simulations, and many fields have highly optimized simulation codes. Hence, it's important the trained NNs provide estimates quickly, with reasonable hardware requirements (i.e. not overly large parameter counts). These results indicate that _flow matching_ is a highly interesting contender for probabilistic simulations. \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Next steps\n", - "- For this setup it is interesting to try higher order integration methods. Can you observe any gains over Euler? (Make sure to count all NFEs within the integrator, e.g., the four NN calls of the RK4 method.) \n", - "- Improve the overall accuracy of the trained models by increasing the number of epochs, and the feature count of the U-net architecture.\n", - "- The implementation above uses _basic_ denoising and flow matching. It's worth trying improvements, e.g., additional rectification steps from the paper by Liu et al. This could potentially reduce the number of required steps even further.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "------------------------\n", - "[-> Back to PBDL main page](https://www.physicsbaseddeeplearning.org/)" - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "gpuType": "A100", - "machine_shape": "hm", - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/references.bib b/references.bib index 998e0c2..b198a55 100644 --- a/references.bib +++ b/references.bib @@ -1032,6 +1032,41 @@ year={2019} } +# prob mod + +@article{goodfellow2014gan, + title={Generative adversarial networks}, + author={Goodfellow, Ian and Pouget-Abadie, Jean and Mirza, Mehdi and Xu, Bing and Warde-Farley, David and Ozair, Sherjil and Courville, Aaron and Bengio, Yoshua}, + journal={Advances in neural information processing systems}, + volume={27}, + year={2014} +} + +@article{kobyzev2020nf, + title={Normalizing flows: An introduction and review of current methods}, + author={Kobyzev, Ivan and Prince, Simon JD and Brubaker, Marcus A}, + journal={IEEE transactions on pattern analysis and machine intelligence}, + volume={43}, number={11}, + year={2020}, + publisher={IEEE} +} + +@article{chen2019node, + title={Neural Ordinary Differential Equations}, + author={Ricky T. Q. Chen and Yulia Rubanova and Jesse Bettencourt and David Duvenaud}, + journal={arXiv:1806.07366}, year={2019} +} + +@article{vincent2011dsm, + title={A connection between score matching and denoising autoencoders}, + author={Vincent, Pascal}, + journal={Neural computation}, + volume={23}, + number={7}, + pages={1661--1674}, + year={2011}, + publisher={MIT Press} +} @article{lipman2022flow, title={Flow matching for generative modeling}, diff --git a/resources/pbdl-figures.key b/resources/pbdl-figures.key index ba0c49c5475d3d34d54ea783639498e0a87bad6f..3eaf1080aa4b72ed6f55e5991432835282c4f55c 100755 GIT binary patch delta 255890 zcmagFb!;6?^ekxRn3{dk5J&_h29f|tfn-2(AO(;TNCl(@(g10JbU=C_1CSBO z1Y`!X09k=-Kz1MpkQ2xS$paf77Cm^6KD}w=wuRh)9=*7d9fi}r+}GL>LqjKs4KJGs*x5D zF;6A4`s3wi)z7L!2#Iz@2$0$e{y=*Hyx}zh4lg$+DJv-_H!}|_2P-EjI}bA#7b_1t z=x!938dPwk=MGZJF|>t3(=jXpIamF_g31wNumTNW8Rmd+$YfAK%qap$puagZ2<&a^k^u8{dA8&bFJ1U`@6MEPJ zTt6n!^u?p2qN1WVP#BLFh)Imi-p&ynlT=<5e=V{{K0nptg82P0V}9k98s!s6GNs0+ zd?TTH`Sh^$DTqYEKp{EEVT#6OLy|^vBHkHU#XLF1!NkVK#)-vU;4(Gu^SCrBPZ0Q& z1oX>z?$Jp|>$M!`4`wm2mEsh$>OhvIyT$G^m7w~2H*%PE8n zCq7Ac)4n!>T!p$u0QOS^e^Dn#x)-^sVfZ9pQnZKHl6acEChyY?ISkz(e}#~YvK*xO zqkJ7l7E=7cZ}gE|j7&!xlm6=nMbv3;4w#lbmz^4akq+dxeXani<*6CPz1cjP73;*u z6W0yX60Ncz5#Z{q2#YT&Imn3o21`)xY0P)hVmVYXVG;X?*(F zUTe-RFKP5;ysg?Cmd)h0`D}dJ0K#pqZN4piI=pEtS*aKa3c2`RKZY*tW(V56(JXzj zevF-e;stYz&Sr3!oyKn9IdHsL33I#cOpoe0O*hTvv3I-7Vz^G6zloQ`h=b=Gx) zPIj{2mju~wDt!=7!{#&$i&%8>&;Qi@G3-XkD$qKY3zto#u}+s==ag6$2DF9U#x->T zkCq>gfRnLhWp5iWY$6`pHSLE>1SnDa(icO;J*CH5$UKR&T^SDO!sN~irg0{al48Dc zie~byZL%=tC(X@xH2a|Zt;f7q(q(~wr?G_At>EmvSr2_7CjRX z9NxSr?pa?B?&3lPBr72tK=wO53co_Urtgu(o2!|YXE0ha+}HU+o||(#VS1Z1jU30) zNTOCnm1bw_s{?n5Ic3-=dM{tAFdG{alW-+-ZDDC|o7{AJ$qE%^N%;uPuQHw}gWtB< zls^qH^$XmpM5tokR7xN&9tk?J?0-t5)zQdzEii3ZXrzflcU-j|1D=k^iNrMul9l%E zAANjTMQijscjQya^THr<6}AcMF%7vuhnQj(ay(^d+>3qT8us%RPF%(S5ArUc>&>DZ z`m6ERInIS#Ud86ZzIB~#y@Pcq$I*Mc3VT#WpFBrL@-sRw)KQ?{C4t)xf&~WUU#&B4 z9ee?a!vzxc5 zZy^fhsP$U9tH*>OY;|Wty}>T&KRj-eO6#M0_TP1)B9TK$0Kc7bzpk&-NP^~+-eHSw1+ZnVKN{gUyjK;V<=A{W4NPs|1F10rvMST_V~NgmyL{n1#L@Fp_a z?>{cK<&+)!Ql9y;-o3C$JX3`6hdXEea#j)H=I&F2PZ=G#Nf9GtNX z0@u|Ynxb1Z*a5Sej_Cfgj9g`?+*^IgDfLTLAxa%Qe2!{~LfyFdg}if)4AeL33|By} zjI1RfV1i?Z(+nfupruaN5b2xo7`3N({w2uu8gaJhfr=NhA5V9iUKX-cj@teM?h8g4 ztLB#zR@=^RYzMku*n8b+QmygW;xdnY13t_Ggs0JW+ol$z%1Uc0X;e#zl4}^Btjg_1 zd3o`Oi+p!XGJ$BR$z6|CshB>#{?<;@N_TR+fZsNkHBPlx)m;jKmn4He%djAZcNAJP@_uJ> z==8_<)pp-KL|>=LnSGi$nSWq|tmtLPz->TL{{p}~c%TSXANI}4_0GORy;EszipX){ zIfRiXYer91=ZwnT`zxB^(-Gw{;jFKp_(jIJVnVY916!YAa_D^X=vWoy`k?B7UtHz| z*5#N+VRBAjKGkHh|KViOJ`%A$Akt+%FBu`M zuuBoTQ`xMsQ#WR|jMWOBCg!Dnu%di+gFa&|q|PYyYWPUcl);Ob+{$LS+w!pt6O*a#-Mi;A(D@c z_Ynug3VV+p0{;BT)cl17$evM#1zZu7!zhzNp^m3>*E{A>jEmw-l$SwR52G$-r}7~)$!4dx%Dsoh8N~` zTK;^2#ClIrqCK>#Kanj<3!It1oM98z6!6&yQs1$Pw(UK`G9PlAy0fdZ=o4^^AjOSf z0bO5n1=sB+j{13NbEOfbqb26j)Hf|ZgNPqZNsIXTK}+5(04e%$s8Z~b0;WmkDQfpg z&3F~L1N1{q7;yE>==msy?z8A0Z@z(YdEd6zGx`>+TYr1HhR2sw39W5Q#=hCD7p*2- zi_mn! zb@{ja!A)$dLXO3SM{&B$z-S?(cTKPdS+mISL6&hegGyLrvH-P=`h)cwsRgm3a9Atx z=`Laca#V(f4-Z1GLg(^TC>9TE-=8529`7>~-w$A&Yajk94Ymim91cBXKtyY03}7@B zVW1bAk{`27!U1Sy&7qrTR8!T_P9uSOtnUsP@SCm9GlYB1N7 zwG9(KY54Dk>_9!NGECsppbJ(RC4ipNegk-Vy8ZDCl^c@ z)Ust58Ti}=~vsCu=Y%&YZ*o(W%6$l1uxQ zn@l#Rm>`_-i{g`zd52#dw5PAbFa>!bAIA@G9)9(`Blr-bJ#)r(0)+x468L{ z$~@(iwgxXN7pU~Kx*dGzKC_QKOQhB}pg=j7?$+cUZ z)TTqT9jdb7iaeSUb^=7J-sLBYBOK-XxTN(m^e8O#7Rf8w>Ky2tHskYYO1#;y0U|pc zJB!Qe3vjYC8l>^JRyH9kqu8ZEA#Ur5-$bdrXK;(m`Fx+a?-2w%aXK&_wQlyWH?Keh z$i54H_e@gj$Z3YB(2GZv4z`noRr2ZPqD6vS7Q1ZNW*2?B_v@>RU8IBo*s0s?}tR`RUnhsLxvF4Pe~O)c?MUe$c;qt_f)kg+Jz3 z3755}Q?ivs$v%syIyk;*kSvy~jcriH1wPZZ~ZnT6IgRASXx z?Z2{PDTkGsMZkLV%VN2VO2L9|LTeGm$b;(y8h_Ms$>)qQd(9uHW}wUZ$&~=J6c@>N zx)5iYCzNnz#va%n8CRZiuJCBVpC_z@vv7KL2zd49YvYCNx_U&)3n_z1=po)0ZN*gk zyf%z#ZjS6#9Bu~>_+a^N<5CDI;ZnMo8$~v6%!Lo2nB?L{iF8du<=i#dn?$^7LnrM; z@UgW`r`HZK|4F(ahbi|R)HE8Kcx-9(9#!}HMuaXH*SXFIOn}jzlIQX}uSONQqUZc@ z2Y?f98-x|Zf93)Ve9!@YdCVw~&x8hnaA!**0qnVl9xnJqRcHmYijvEO=W-0Q{gEj- zsekZokQi-TD0*H*YwwWqTHfsIJCWjt2IB8uSlO?Iu?d^}ykwodhW|8=#pj|usL4$v zsZGQYIVdSP5Gl#2nNr5}RT0T6z{sOi09FKHH+qZ)`O73WDtJ&xKM2u?5Jg@c^WUF; zX}J^d=ghaSC)TeCbnqY+w!|<&1*2eTfv~(Fa}nCL!Lq^a=XdC;b(|1<>0F4bEb%I` z#Prl^-yx)*zaX2Gh)p&Vx`4X3@bF*M=2s_=4tS+-m20wFUrd+B9u6)6$#%{~fDhq- zt(tMJpy*qM_{%Q(UIY>%A+Jz#kgM1LEGowhlntco+iyWXmnEYt-=Ddy+uyhxyiL0? z`~`w8LvcM`k#owXlPhPVcbi#`GgHf0=(9HY8LDh2?NE8sY@u`!SsX1A>h<%I(hC%& ztTPScgti<%s%}DOn{%0nI)_iw095j*%o8OL-`U~pYfJj$)Lv8`37Ww`O`pghRE;kP zP!lRMnGp&*^z`mF2>&NZ0uC*o3MEzo5 z&Y#^QoBJ0@Lo&A#F{B##j6N$vb7yl~UTP$_JhJ>-J*+o+L89Hq`NCBvz#FPB3DCdc z82beMM;95VEk#ZEn&*R7GA3`a*@aGISD;t(U$XsTRlJ$G)Eew{0UZRx;PXYP#8T}DR9pnM=)(8S#h8mS*Cggcnw zrxD=6;P?=r`|`>p`$q;f3=UQ5FP!9`n?L&RmH1Xzmc{f`mb^+KK&P;Xm(G8@g1{tL z!LUZcyOiVX)?4qVWkQjnVG;efc&qnM?+^HSI~LwWxddon;F_mQr~KGl{8f3Od3 zU!ybTotX*EDTwP1tvj@Rm@!yquQYyTm)s$s?{wH=aFaV-+TB#pURWz2n>L1TUE3lZ z|Do{t$R$c=SR$Gmawa(qWF;UY2arjZN6DnzF0HAxe&i(HU20RF9&R|A*;*xQB=202 zeD#RF+Dz(jcyK79aIVv-hK|0nxATTGR4uPp>>tL=OvkKEzBtn6pqn}Q{=@tl&hH*A zA!LJA@^|UwAd&SSMD;E?ccfe|bTY{w)RypZ%t(4;2q%ZhR#`6vHI(g@gaCe5hI#$i z%0j}dscVz%12^AnhUa4t#iKChX`H0^hv&TiGtxdw2L4e)$h6@|vTnbl!x)-*8T3=d zNM3iz^w2j1;kk*Y(0!YlG-VP2(n(&*CUXP0sRZq=atO%{ro?z=(+i;&YFbaVq znU!=e!l$s#b{^O5suoQH#o8YejXc0-m%bxkB82xOxzNc@3 z%daCR@{u@De&UuWq5@YcoK4x#q_n#@+1o}%vGKSS7Cb8er>XON1`t2wK^>&WH1x8W z$rBRTC^nWAkcynX?byLt3)rGOb(zr@-wbfQHoQN+l=RNIp=WNnTs3xtr)C9EZMwt< z9`=Dk6z?nN(&ZKxKLD~(d5NW2}r-+C)kSWkko>=ezn0I&8fpY zceG5PtLk%v(TAu;0@TCKIC$X2^@0sr;I+galiA@MZIQ-`!Y#YSI8>MW13!N()6z0IlAhX->mW!~ zW;`8S#be2@C8!6Zq`Eli1DF-Te1G>9E^&vY7y#a`cy+7;J zjno}NpsG8wVjmUtwEa(dZ=umH8q{T9DddH?NMiO49ftrAMnx%frb;_#yY(SQ?_j|7)Auk0xm#IWp1@JI8} z!z#AY40bpIz$GAkO4oFuha%N<#!)RpNjp5NdFX_Zmf~aS-KtqEFcs6wc2NgTtH!o4 zx^zYc_lEYdC^iIt7P-bW4Lg6xcMLYztG={nw2X0WfVa?=KDepLjQglasFrC~V;<6@ z@@$x6JyX)S*hInUlExX$*YHJ{bVJ?I!MlYDVNO~TfESL*pPt7}o&{`1yRzGZUPDL2 zV;VOF6j6K@Gq<^k;=D7dF`i40-v{OSrP3m+b{*0p!=)-WKKGxjG@vZnCHje&&X`*) zcV#Exj2I0>%@LBoDF#H4Dw)${87&o-k@J6doR)mrrdX6jvXr^B+yLSM3 zg=yLYL?Y5{YDMn%)WD^qAQbtJdh*@1ckp#c(h_!Vqw3>?e<3p&$Js)w8(i5|&fbp5 zt>LmZ=IXvn&d2J*u+JN{#6FR6U`vnN5sWyOe>xi)>gm}HsgYhW(JvnouZ(Y3%*1@k zwD?Rr-X;uN_LALxiNME~i@1H^4Ceq+^WpaZ-v@6T)mBXg+Lre#o4GcAYN;yNu5hsl zEVbWYO2|IcHAj76?Y!@1pgM`lYC!$;5-9UK{A*RF67b|c|9&ucy?+&!lpM@J=zaoW#d3-4tBpMsN7LORqfQU*h8>I1pL=E^|LPmU z#8Li$9N_NTUl>Em#114Cht;UE?qq#l`^x3wla6tK7vH?phZo-tXr;z!QcGb)z1Dqo zaahNg!Cp9L8Bu5d;7|U!HTi?{!`gf;z`)BSa6!jdGVq3h|9!dqamJTFCO$O3P)5HM z2eIXnj@tp>KoXs709!}mRpVuD=SDzHXIFQHR28-Gh(AB-r0I0t{u1wN+d?!SYjg|~ zdnB)D2{mkWy&5s#R%QMbNf71ymwSxnuf{RFgj5@Bg2A%pN(FwS_jp_8C4K$~KyTZ= z!gB{Dc9GHq!Vv*{nQp-M`)Q?SBgm#5*UA+6K$X+L8@sgHAv5&plO-v8$jw=7Qkvb- zw#7g8;M>tT{=}~Ls7QHJYrNn4t6$yN1EQIW>&aR21#jI5+3$5m{?_(U)neYIMC9r6 zW!9qKwXb0TZfZX@(RO#I>S{{(0V1EiG3Rd@I&Xeq5ey%diV;p{we-!<3VHh38{ws+ z;+0Cs0;Gzbq>f9TPuFYb*0C09EEV8jk_V{(n zSswIM8bxC&!Sv2&as9N$1jd^_8rWYqeKS%{@r$Eyog5Rnl=9G}95}5*0Dr5-Tz~oU zc~)98LXg$81X<3d&Sc1lJXLz^4@mmLOet%><|c@a7_3RnDA7-~fDxem9#W&8Tz#=C z6gJfdDsR_UN_`)w-^#8lBxhK^UkjUi<6<&?)srODucEC1IvzAEShOdIlgP1ZQ9pzD zV=7!;6Ye*Av{wS{5nk6zh-E1)LxOcq^_yPC?8%5pk+x<|qyC@<4Vh0KLg0p_wu_yhT(E zp0Y_+d%F*TFvLL^#LF(h50@zmaS6kCxrSsH<1B`tacBmi{_xCxhh)&IJQy^NVlb#O zlNcB`J$+uhxTO8Daf@M}5%#TlvWil7*V7menFSS>PsTuN$dC|~#*;)~nEZh%0o@L9 zlrR97||Ypl42 zP7@4vv;WY!(|L==qhZzC{_P^2t_`}P+j_BNJ;&bz0CYkj&Y2lU3ftPZntQt(>7RQZ z%mWuNZO4R4rwFbOZit1y)N^C*iMQRpB5oX=UWNRW2K{bheS`d$F!4Fv)(tqQG82Ck z3{(96!T>g}=%U~5^!fY&Ppl78dTig1=12jF9JI6Vg`_%eLCf?y6ND&VI=v%zP~c44 zQ3WYN0qT9=PwBrYor2Xt%YXBcpU-UZB^sF0x(Ge9ojsTy*g&2Yg`$AOhQ1|3z?}?%L&t*g%(lBvOXkk>4Uiw^`ez+?1&NY=0{u_S zW~-?Im$QKALX`v6gAMezqQ>tsI%ZSvq6iQ^UjVAL32Z;G8?MM++Bb|WOP*J!w~vpP zf{5NYGK%mxzaJ5xS6y{dBbr(TrAc`Oh1zlZn)=wUFxor=n;f+$%a>HtA9dGs%T_1lZFNaOcjza1;LOfpw?l#N^ySAud!nZ^*x0L?l99T`fo` zRww%rcjrmuyXXd)NBQXj?wbtFp$)N3e)5H*O!T)3B-ShC+_w1RRT+bmnT?s9^gFG% zhmE~CDLaQaA3LbgfsP)5gN>b)i;atmgB3KODuNI9f4`>h5De^uV})DY}kpkQ=u3{Y!>4jLT?7bh<%>wk^Zkrd&702>DvE7$*#V`T;1Qj%kW z{-|JMKyvVKf`Zv$|C^A^8wL}^>d1|W#rA)U;Nall;Q^V1C=!BfJ{w{*Mfm&@`84d>>(s_z z`Lcd~58(J?)EnaQ`EWkw$Fzy(K-Sb&3isFh&*q3gV;so!dyhB34ap?lkpl9%eK*g4 zNkG=F_harD^!4lVAphcclLTOKS>N|@eD1ZY`$36n%fN*MPLS10zK0B68F(mG+xFYu zEy>CtB!Z`t6vnA;KI?E8tiZu$vGa?_fWb&s2KFKdx%COvJj9(@9^&8cR0-mAJyl;g zwS+L1iWb)3ELH#xwa&%ytV5DTdlb7&`$3;a4n@cC7joY0XTn=11tX$g>-c6|y&!IV zxEdv%xa*T-sSVmmmWcKMZffnheeb)*Rm=T+m`ncYn(s+<3p+o$bV#D`+Si3 z&#m%vJA&#bj)tIX4k?3}DIr7GpRKOVF{e^0i323NutovBEP6S_LMd$D8pqg2;osG) zb+Oe;1V=HgweL6ZDhXXR;YX7EGoOV27V?;xA}5HhIAH|*q6qwKTkjkjG#7yFw3`?b z`}tSDw2^%WgiJ0~j@lJUX=9(X{xK>xI4CCBi@QlADcICS_SF%}xRCTDUF3k0GSl`) z6znMo>oB+~Grb+2xIXIQ{-J=Fxk23&HX+5%S z2U_z^uwb$+EalnDS(u+cMu5C7g+7ujs{l5Vw2&46p%{T?jCw{JInOXc7vI2#LTVDj z_k*ri0zNsKYMeGhwXA|PO*}Z72Dyjrvv6u5Hq<2N4w6D~I?DQ<%Dx$YfgpuxXl^69 z8N++T0G+(en_-g}**MmHO=?4smxHudLMP@e+1*o zj$oPd*PVS2DXNxJBJ!*mI8(K-UFuGlyGVdF zpbG0x9W9$hprG?&#&3JiA;kYVLtA)pzLciMQ?!bRC19WOZR$?HdodRV22iCRAiu%_ zKskebFN<-;{*ViL4Pod|Jm#2NiQv+Oq@rMmn%;*oX*zJo{_tZ8R4+X=$p}v4v_IAU zoydxKFoF~H_P*QvsrBT*o*tj`uYZe*v@jYMXUN~cb);%)JUt4B3hH;i_&74gyxpz| z(hgGj&P+cpaOL8O&U@|{i0-qsDg6qlE<=c)4%m&)U1WoVh2h)C>n~XX${b-5(^1gM zjG2Wy|MpW0(50)IUkC=xYhhB!1xc1cmduKwz*Ps*wnCP45)FMxcf;@qs*24G=REh< zTQ$@Q)LnLXjK7}{A?robhVEVk8Bt804Yy}FmaOwm2 znaIERL8KMFE|n$54!?|GVt#LIa=3U;>cjU@pK#WF*q-Qj9PUIj6vnx9qeQ^KyY7Bh zoXegWLA6K}@z%^{mDrZbELQ>8J@rahbCE=N51b;ahM){9$)oZlsclKZ>_vq1V>7C{ zXwbUsm8q6!ysEbn@g!+(NlLq~>ap&72=1V(7dlUW&pMnb|Hs_BoU=AbZQab|3$~&a+z)AQ8 z=T|s|Tw**CBziote}o*<$|rY(DULDah7zM{f2i7yF}VqZ3&eVcF$4{=V?`-W+eEzj z!fg7EO~xC1bvW$|i4<{$W=FWR``~V<)6;fz-z8vmAj(M#4lJMkEru>RvrXI-WWxeS z{B?rKOReu`TU*=H*8T$M2zrvnU*&OjK8c3%BxF7MrNOz@4N;U*ZD3kU8#Dk)Zh)QGSc{oGzp3%eE08w9b*sbRH4viP zSQkUv!9p4y=tsZig3u&Hcz02Ht7)Sn8g@YZf?}8WX8ui;0^k79yzXO)X&8MVB7Dz~ zUBnk7tJuO{u+s>V;(&}dI5u7$4A*8(t@Hwz!}4ii2aWorDytT0UcxOjq!=AV02ABj zhhd+|@efQsLL^pVi+OT(4(3hEod^y2*Z^buTd zhNL#AiD^#jYXbmh9g}WJcN^dxBzL84$^31~1QRi;YNmAG<({doV0Vr%Gz%pDVEQOX zlXi;QMG#d`j=G;%zxJ52d-}QA88C$7n1OA&6&Xxa)fziAtdtpVNf|yxo78~e?h1+r zI!W&HZg!NHi$qFHq_e|lcD!Dr&6u~k*099DJ;J!$&VK+3mDJ1Ji=KCXNzGH78G>Vr z9tR&b4iM=shv({rdP^1%e|M9elDM$uTeo3bFg9t;z7p?yj)q^gBWd{^P?}&dtZ|pG zLvF;pDs^YVH)V>|Xpk1-(zZGMHWzIKSO=5QmS(j^pyLY>}sx7_eALLMex9I2Y zvHG5{gk9)kt+CHF^6;kc4iFZ+j(q1faa6jq)-#%(^eNopcNWwW+7T#BcpPdJhndNS z>JUolz;I;C95a+nBqJ+ca2}TaUNc);5E)MPiZBbPoOi{*HqVI`6?KLeiyqKg1e=>i zQ%#1x;<}Hd=Bq{-DD++!ax0ta0t|4RZV!vI%t9xT?a_xhHv!Nd<=kW?@fNe;sV@|; zI23^$imYN^qwpAcPSjl`EGAj(jdsRAKbf0}e81^CQXA6NM|g`}?ZImplc-dD>vn(u zd#45r2=_wGql4u<>y1#?K=)(@3SsxwKAPTAJV)nHVg%@nRZA?(h~RpyNTAh3oM_w zrlN!>@SR8Jpu{*sHlK1xYY?15wR;=-pn!nFddlafj1D){P7-p6;n3|H!n(xy3v+lm zkxkwRDWpWUi(q9AgyV1f`)#2SxM}q}$ zLu9h~#3Yd;?u*7VLdEbhN;cITpqerf9*uV6QmdaRW<5n)j}-l=PDkbLDeI+*(X(P) zjUo;eZ8OX+8jJSaS&DRcGAxH~=FlaQC2F_3lqC5jtbIUTSJNRW&Bdh4uiHS0}5##jt0{8Kn&n(?Ev?DPY5@^Akj*qLDICG5X%AbAP2cQANV{WBC>94$nv)yQ8*2S38A;hmDC>ugp3>*jDWX8n zQY_;{jUX`?UNQ4vqNXxkh#yCUFh9rjRH=;y7f_+a==({R0N~-S%MgQAhR7Jh8Jj_b z9t0=cN`!e$mLdP>W!z+M(S$bNZv%xoAUDjla@t4mgyX#nj&K@eGZV3x1s(|Dy0{4z z-EG&x+8pE(LDDm4_gM=&A_5MPN{LQZEDJ>1gMvnD)ypAIiiNI{ewfBU{t1jzjSkVI z6qinlWLJd%6cynjK%w(Jh7*Y5H~^DhbFt72{v+29RF_To%ZP5ZKX!FpUcsDC-rcvp zi4*vA@{!gavjMrATt|4egn-W{V-Vu<}slw3qp~^WXcO6CAE02kvfG%;<*7xPIwOZTeo;&Xc%rAR=w$sZOkoA z`@fQ|vpo^07imdbvZw$1E<6?=DZ%~&9MfURHM98pC+7C=BU`bAft9-;)N>B(Q*F2> zd4@gG@}N*8X9=zMf_8>}MpBs(wsi4$eRJDA1!$R4ROrgYP{jzsNwxpQ9VOyBi53BV zRW44e!~1l0)R7q(OSD(jSq}R&es=#hT>5%eOQ&+-gkF}Cs_RoW#8tc6}0+s{dmeGR6Hqh^G6KD ztV%r=M&%^cnK5OpnJ4ekj@}6=br%3C-iX+wD0F1BzTQhEa_)ZMyaYi3<@VxJTvK}{ zAKH1~Gq)b!!l0%?zJY=BGaq>C&AmGgvd&Yncew^VeJuIeO^e$;0sk}EoP0#TN@mTJ z@HuM;MF`=HO3UK8cPzD(;)V=_pF1u>&U`$zsrU6KFd-zv7wN$EVET*AGnb zJEM#nuYq3=)h5&{uM<2BQL#m4+av00fU`wpHfbkmzL`8!gBLj+n-pe?vlov z=9w0K5t#TbFA)G0Tsl>T>XLr8u7BilP{XbD*A7kZBRRh741d}shR#i4C)wV7ApZ(|N4qB6t= zD=0xz5N)`=3w2^r*QCvf$DLUn44j;hq^y()}m&BX!Z$03Y zBeH*KN(K*Wa$J)Z3jGyg&-U^?myFK8mcT13u&M(%5A^(?5j$4jr?9up+dV99qZc~! zZSow%t^N6gP_(G|{y|n$QJawD%xO$vKDn%j^c%&lD&weIvG%hpZ;11r)_rN5+K_+e zkRr>{_X=q9xYg+uyTY}jY?AqPh0125ZjP5Zt*KB&fOZQFk3#2m4a6>=v6w6wRK!_CPC*G*3BaGQLb?!&&n_&f+`up z-%D_>tF1f0C;+AMuljoxZpgo0gu7#*!^?kBSi^0Vmt|PD82dcf18YhBUqK z-I8UI#<}Zi`K%QB{`UK(TJ>-zfekeYpqpakV(259z$ftGMERpyD<@V%Z!}LNxx12W zZ%V?8b0?Qe@m`S|AbB|aE_%w94t^az9JLgw{%B;h;Wyl+wZc?$A0X$}Y1*kvMZHTo zbDV^u6Zj$VnpP>!|ED-!rjJbIcxD6}0G;~%D=v#5+=k6T0@J3mi7}cc8B8n*eE?-G$lQPz0v3Y( z4s9zb+T1U;tg$w@NZ*A<`7fK<-0)V^YhQKNLU z*=dAEQb4yCkXEm)Joob=sr#jOck^Y3`T21%2jQD44BC;oGMyuUQW7i(06|KS{J?)j zwCT<=I0ZJ?R~Ez3dHQt_oB(F;1i`zLlPQ#^{B^t_0%JX1Fg+SuRr1?udk1{}m3E^; zAQX5z=>mH|i((f<_DV|gL!oAZ08|ILucpW27rQt%t+537i6Zw`+ zYJUTbgZamQo1z!Feb5c8nsN8yByC|u<&&k@IjjDrzxtLsCp>>B6q^DHZG4bW{g;SH z2tbV9kK7rq7dCB<^_`!Qd^c60f61PTCxHCcffp74$OQr5j`q-EkLUJJ&0+sS8I*#N zpws+C`-@u}7})~J!$HNlpL$~KOY|hN2fdGZiK9y*GR7+|>O8bN7;{9{Qgg_!qNDTk zR6{yHWXw4ah%`+xP2zV0_z+mG`^46H!o7^B9}vzkEO*KKNqHcQUcN^)eV)L})G+D} z94Q`rf!+uF&L_WD$`~j_{od`Yzx9HL_eLUOiit0my@t@rbBN#-YsMUeuJ_PSoho__FbN_u#+mzmzWFp!=~hNx?w(F7{rnTe}K&R5%oI(0I0d zH0*7Dxfi^U^f9zwsOs!o0Lb5JZ}*z(>AqQiitqy5Y%O5jdU@J^-M9U!UCb4Bni{oi zudZzDt^0Le(YPrYEDFmdOKu%m+rn2OD<%i;lmdi z4D&tS{XF!7E?TP6#sh$a#0dlsRUG!eyaTeXrpe0|70MSCG1jG*Q~ge-NBs6J%@lR% zTM}-T?)Q%Yx&*X0=`Cj(c5|;SeP3(S;SP(x&eN#+5}d`P&|mMAyUYpoo%9%g7`crB z`mB5zCiw}a`^!a0OOd$8cNtL{8P7k#T?>R9;owL0^bhT$*_D0bG_+J?bvKhHbVnLm zk;_X+E&ryPrj|E$$2SeiIu@UM5$9{J&nw=*4|g(-RD^5j*{-#lB&*u>Ks9QlYRJ z1;%4+ph}7w)qdA&gTk<;l}9_GOD*jQSxJ*xT4F^LZy4}vC}Cz$Gni}ypRpfnm|3=@ zgid|;m?Kfx_h%s2EH*>Zbm<+uG4e34yE)^0{KE;y5XMR~@U0vo@N5m9Z%-lt4?i-a z;}qp74kJvvYeW@cIIQfx?HEf(`zUg(1%)@S$eD%6#1h8BJg?~elA z=r(u|ho?|+ z{Tv-ML%>tMoC{{9Y5d;SP*%YBRqM&ODj~A7xe}0%KsT;**!>-omdw(xj9_03tgdpAYSG zI>AjCO}VKPoFuO7;}}jGIm8zgz|z?}XPE_#^*hC^F$EEUNjsvG zD7VB03VYunZ7B1gm$UYc08;8dD$<0?B=M-sIR;Y}?COdmOi%G|SJ#KE+?VHw?Lp~C z*aQIW5Y7?&;|1@shNb4-9Iikj*9DUHn&gY_ zW{ah_b8TJ>ARF1b0Jv>j$|cq+M#2n^u_2huJHvi%iK8oCCK6{_{ocDg`el8wS z4*rD1%gPMWH^b2pF={~L&F_(_(7rC^E0F!nTX^r&5R1t{zr}X)kKV1x_vaPbAwXEW zdnourA_&~3B*KNRT+2JKiUYiN0nowgPm$&DCQ~xfp5$Mz6iB}!T?QZ!p0KYkV_E7OeV9M*ug2HF(rp?=5ejO?Wyp-vBEUZ-CD zMW(R=jizV4(HgojM|!~Tyt?0c#?N94Zj~DC%qQ9sVAUE0OgxCpyOu^>Y}C9F2hb!5wXj6W`0R!EbnB(;1Oz{$i` zmhfOE!IG^YRUf}WVMpwptucc!bAEYpg?e0Jts;FR3&LP z-B{kRTLZ|hY_bw<{P^VeNZRF@LU+;Wg(qIxWP8!Ww}1V68hi?x9j7 zo>KI5sG#gHVA3YYuSLQ@!HiXv2KB%#B2%L_ztqjKFhAk=%u+?n0<$2Wgux)C(NbX- zvs-v7H|`QdqKJ)pf z{n=-nc}gUQ{%LEX6$9cVw|f{g1NXF|=D*ICSAi9gNP+F4nxNuV>@fpG7sJ~?d<_Pp zo>9w~CCVf4X(4!{i}2}6Rd^)FB(0rMMzc){(s%ET!c%bY3JgTX4H}CrylJ^k=@N{A4RYi$0%*K%jRgknfR)67`f~^>2>=NJz$n}73C&92B`A%= z4X~T*Q(#=S-!TMBfNxCXvwObukk0AX^_-&-z?u})y6jjiyY|Isg6t6|q!=nDp@q%`; zpwN294u+>to^RNqg)DWiQC%)22^!L*yd1ATBH0y`va+d>6_y9k3eI*JC4slj{pjX1 zi&<%>!?%;x@Quktkvj}nLH%2l9?6(ZP%qS^Nti|5w^4v*+U%0cox|IADb<>jxI^B9 z3W`+O;KWPjY?ceQXkLow$?}`~PRhyno;qt4&S0&~QLLO6Oyd zyg||ns{vs2>f*brm2%kvr*5}Kr^14y`kaXDaR9+3bmOivbISBA6TiTmh9kmmZsqOyq%vKz39v}T5Na|-!ABRS@)1xzHjPbFt?jT| z(gN~!-mHge%w~+Z=*EpTS&&_&2mWkuq?fRnH=f=JZ_qki_Z@qgO-6};M96px?J5ow zhXf!-Ao(Cb7keFvpP!Gv2@+D*lzk_Nx$hp^iGIx^-h~b?M>pZcK48lo*&EcGa3mP| zr4s~gBh(ebygia>+h6`AW@O_95q{TW$UQg)ug_(wCm3;%jU)twZpX{Bli%`&qt-LA z-79gbZ0~wAe&|x-xt9qas;gz@fX8FM2Nj@qb`v{lLKm)`9D2%V*F*YPFjUZ2uv3ss zH$T_HO8|RiG4q-|+ScB6)PdpE_1Hn7)t9J!){4=h)@iC$uS=qT$75Hw*dd(UniM9r zUyw~pOQ)@Fp9F9{2=39%gm=|G>^KCwY^iaG&PGPALR_@iSPU3~4n+@OqC;8?-vFS4 z(1lI%9X|51IR-zjPI@o5y`CkS1oqDtI83s#22aE@FhX^t^!gw6DPJyor4IpVB|)3e zMSY24zyZUN+x>Nkhw``s86)qO?7F9!|BgAybUw*_Gge}9)=xevm*u8F!)JH!b^Gi! z&`lt`-VOTM*~a?_zP;(8UKp20za9X-{?o99Yl>-tYdY{hTynp*_-9_)J)B$WZ%YT7)XYzwg+p)`p=Dty2SOYSyifgS101gLbz*4l)t_z!o`2K*TxnTTa;Dh8`@ z#=*q#P!L-9H#R~BpMt-UDgNjWf20X!21b^D$rNn=mMN6nY>ntdZLA%IjT{W@&1@ZQ zJ_)(cyRv##MsxsSfj<{&X)}Ezd%ZvCouZMwnK9HKhR(!+fcbOdb5}t@8&^$Q7G@>_ zS|)lX0tQAlHUbWI25mYCM?Fh30|9FjOCth$C^`WL10!ok0(K4tD7ruI_U8^QBLgcG zosgcbxRIHOspFsLLD4BX8d<3ju+u{U{_*;s+@295!5?Ww0qRpJ`A@ColYsnhS_>m1 z`~L#@X~#^O_tL`*TzW&{wh7h5Yy0atqS!Ctr=0`gXb!`KTcI4rG*#_5Qs4c^gZJVC zTua={bvAaJJWEVFr|4aEBTm>6hEMGt`4^kpZXBdjb!AE;#VuQBGRazD=+8pBZEs|l z1@?xA^YDIs7JwTLMugieigIeozY9kWf{`?Zg@eetHJ)ip{f>6B#A*G~j)&QT-MJ9( z9bNle-qMks+#psOL!MdE%yhzpmcBU{pwof;_5%P@Q>R~~FqwGJx?!Q*oNka_UGbC* zb0*kVGJ-3aK^p@91SmzB6-{&j!#THU`<-C3hFr+ z{fQ^tzoHKK?_oEycW@Lk)wBN-PHDY=ZZksBshSx&nmTBH!lMK%pHS+btM-2+$G_8x z;7`^mK+!4LC|jHTp)U#kMDQ;mWuX7}2mOO?0zTPIhEGQIZ{f{&xj|!IR6|{< zwBH;hz?Gd6KILiT-r()B5LE-|N8-pW_>LO{=IY$w|RiN~YfPXNq7Gdx!u+1`#Tn=2XEM?d&nTXF?7U0wgh@7DM? zp4GTnzt!p{f8pF5@B8aDha20EpW^?(ef?sD=XZ!^TGd;mhhscd2cLHpZ@d%u5x`Up z;SE_uCRpoV>gQ5??Ud0b_s&uE77cZJNq7te*(eI^onU7MW{!-2AW9^6)Ls4e;mOl0T(0G zOnpT?mCE9ZlBA^7z?(QhKv@9+-(rRVBi0>f7V#7T zmEls}6^nk3Y7%$c+PNtL&wi||n7`N!9Ca=YRr9fV!G*PGoS_H~TB63dGX-=a8lI;_lqs=`g&0 zF3i*i7=s8y0PEr!p;N$k6nF~DAyG%%BD(J z(X4S31P&~Zr0?9Y+ElkRRS;bNkaUw?iCx6g6KovTB2~zmkcz%(HqMnCg zUVaGzhFU2^2;$AvVX0Goe^;-H)G^yTd!yxS-bA8NaJ<~!ejETX3d_rvmNMFDJ5=Zj z4}o%O8(;}zTH*oWp14!N^$MlBi%QI>aMdJJTh+7-jc(|PKL}0(jRrw&*)+?DljhKC zEu2sSsPINb*K0b5Y0kU{3dAnVNIv8!5K3TTnN=g;)ZP$Z(190e8Cix%x`0~+<#+V?~=Y9T1z?@f=EM?V{@ z#n%XOFwF;v-GUl6hs8Ot5Nf8@?@tIUZ>cY20ibKO3k;K%@yINDdX{SS@hpmVl3xpi z&2^8y!Hy#1-Z7!d$WR`C|G{2tMkx!=rJ8Hv-mD1gyAs#1VG+Ia!2jBrXK zaFo+_#GGgLeJX?qW>wJjLR7eGys{Z&Y1?NH9^z<8FYsiezGfS;T7CK85;wuU$@;Ns z5dbWYIhRp6;E;$pY@;~7^@XYsEB@%v((?;gg*ZY7r1&|lt7-%bnU)F-d)`d9l?~!s zANcJIMvwxzdrxK>PJb1BY0>W7G>^?Vzx?N97^^ynvy*+(tr%MKDEVID@D-lPoni^R(u?JpGzf${s zV}HMLD@Lb}vu^)Is!8}PS&55n8dfs1zfbHV1;5x*N9WW)7T6uX)YBPig=_w@Z&sF5 z+p%7hWxi;B)>J+7k&WKW6L-t3GuOQ`Xh*(_W?LQ*zSVgh5=XPsf(#s-^<#G34!~o( z+v=SOXPYx<6{K!{=r$YqIvPCBK0z`R1(8ya7M4I?|EAHw+J|yro&mVm-vJb3oLP<- zA!Ao5P1#9l6sN^kC`xv}`LMuAoT;RqQq*9PW-6{_+`VZyb9Z9*hGUf`C!a~&4d`Rw z5P>~i>?YI-tpOavElPU)pxLUl4}c=sJP!#Er|ryBzYbu9|KMC*!o_Wvg&r*6_8TAI zqsC(phS-ndH*{y`hsRFPv$#s85MBweieuFy2;%Oi30zIoD#@H#rRb0;z@}IaA(kA0 zES1x{^n%JkuI{xNB&Jkpw@z>D6yrku6+BXZZvscKth=Szo4t)~0=u?j4XCA|E~Zkm zZaiEmvoC|`M@4O*{`I3++gitXdVlp?`3-18ruVICc= zI}SFmPx*+7X65@4)k?Lm0QQoV@@#7ysc4Dw_({X5`4j4?R{tq$EK8XMA{8}lP0S9d zD3{GA7E;NSS=VSq7C3pv0(g60!o8RmaVlJ%Ilk=5U^Utvm8){FDjRd!Q&om@G#<(+ zh#K>cuh=Lsmh$a2Z+mB|GHI2<-8(X{;C|AG_rmYu=?uCIB>n!CvZ)Qpl2tGQJbYe5 zC(C9?SH-9#zkJ)LK%v;O?5t`o@g^~`H3MhWmSC`%I;K}MRKNrS4uEnRhNR4_h%STb zP*K!kP2qB};znKYqfsQlXw+Ma=22NDU@&7v{5s6(;hx!eK+^l}c5Jxmg2klsUSM2RXZ&^0ORthHudYJfVAd-~e|$IEu(RfThO3c9 zYxBVb|M|S2YM0+?1n@3dG-wloqy~rhI3O7gwpk!K9usdsf8-W5ds-Gg>gB6nrapuW z4(w*c5%kV4TM~5&f3(FlzgJ*x- z_{&*h#f;V-G)^tI;dA0XaX1_e$)G-iCM~L9V4dIOAvKk2r>BJvokx9KySzjp)o?}A zMxhMZxkCDA3*c7eY~C|ng=HQkCJ<#L>1rlS!^{ncvf)#nyAG-VbnOP%r(B7(;%T3& znOKFx0XXiWAGsa#9}m#+xI_XJm5oy2tYLrlbbQlN82we=|J_xJYF z#znMh+-1iK(0Gm@fLmM6My(xWb(&-$7AzTXON>oA02+=eP8udE_B75+c*&@vu%bG- z%52s|YmaHkEOU#$vo2O%o~|X3DN)@gudC8{*=;?JWmFT!SCP zLJ&E&lKNJamewyjq8{vo?d(5LX#zfbLi)C#0W>u?KLUMy8qP*Q(Smiv4XV08obl5OhZ&TRHYQ!DI zlLDCM9hQ)1k>Bgqs`I{jwZyNvF{Oi)^La0HI{kjuPD*;@5P0kK9wyVx_;Ai$?=G5w z0gTXkdMfhd@$CAhqf-#7Iroz%PgetxTavv%uWK$pI(Tlw9eV`#Qw<_F%wi3W=rL}Y6M_-T%U zi=aR3)X$evaO`cDR%k3szr^3SSQ#LR;2q%UE%?}HSQ*f#GRe&B@YciXdEL*|7QSYQ0?odBQ>?N5OU<}{EVmp zgUExZvi`JwAm(Y>BJ92_wdxwWR<81qF#l~s$9!_yXc2$5e7|iqiVPIooq1r@-P}?; zMfTL(`h$VO!hwTPLFs{<5gLWa!YcqacV>dnwjD={YDBaaW?~9Vw5Z~-EmG)o3i}-U z62@o9U2XMf<$$C1C;;r>8L(T`tk9<`8444ZZ|FLwW4_Di-Y_cFuPa6rmuw=d585K^ZkZx*@GtbV%oVl(PZ)(LNXHk)fi|rnN##p zy9GnOavWSqlkA4li@H0gZW;juV7^xvQ}MEfW|cV7;K0d8V>}qT!X!>zt8sTGA21=w z>Ho}e?5m-;iFKukEVYw|3#7LzSK(%7kbMa-lAVMghlsb^BOTad*1(iw5uG{i6D@Ms z?DUGPT}UHvE<~i|;tNgQ$cD6d6IY<#HSk(`$FN!lJ*AV;uP%~1lluYiYRAYZ{>mJ3 zi`-gjmv{g?iXoG)7+G?pX28vHa`yPJoktIq*F4i~9Zb(FE~3S_!zd^aA_V*(6el4P zL)9ahzp%XlBU25P45>|lD)x?X5bZK*P(3P}%OYzMk;I%fb0u?;T1%@ct{IDp>mdn%{?r097Kh0n&|ZZ1%X zX<*rtEgDd1bX=S$uS<=%-&0;kxfg(mrms?R zPMCmUsK8q&ahhPfp)YN|%EJASH;9O4;~Hxivs~CxoU{umRv!kq^!=J-14UZ0;b~2I z_d592@~{R|dqkExiH(`LLpfj}#$B*quwaQDP86l25$=WY^&VTVdh7&Kf5q`#KkdLe zL;M=~EhMe7{GN2cQ`%f!Arrh}gZL~<-`n6w$nbi6azcNTs4RZ0w9?rfr^Sp6+c2JC zU?-Q{7N;!t_eupIv&QSJPqaQ_FjX6|ajP?0MkM2&)>wDK-Lr-2WG%wfftqn0w8t)~ z-xC+NoQ*l2K0HB?(SzztG?L*!Gm^HaP{_Cg)}lkU4(8w#b%wD(o*bhe2#*#0P90&v z+?|P6=y#==e8twzay}2H!F3_pa#W3}5Hv^We4&Ct8aWGKm*Js&rEMx3k=4drL})B+ z*T9^&$2@+aeL!89@Kv6xazX{iiCm3u?lxc6;de9@dEM^;mJU$+Vmg*2J7-=ZOJL+` zL|uVQ4BR&}Lx<+4InV~C+2a1QSKZU;W~6ez@JTUy!X&$h8ab}Fnm|RinxoeV7kz|m z0k1Q+*r@}+V41RP`v@=(iz=UxYEGB3s!@)t0m?OVIC;PM@{m1-h&P}6k>X|(;Y)gv z&cw?6C+BD{EC1*FjbCSK!6TO>0E&15M)g$kU?9mH@WwG6Zk8ZqnDicBv!;8{nTjVauDYe)qxkvwLQEXNx@8Sd=ONxTo|mS2Hp zqvAQC!tz9lR>m4s^f9vKElblehy3!vr+5b%jXl=VS6u5!Aw1;jh<{?=FScoJ(CVi7%s_Bqe z+E6A>h{?^-AJd3lpUu&Orn|E8{ASxBr@6 zgT|vxE9kQ5-aSL=$kEn0dmmr9>4=GU+%vKiMAc>`WK=nmBdCvA+e#yZ)6Lop_%UQQ ztic{`l)Uc~*u;-*t7s%FcQ7=)Y~_D{-{CND#$Oe;yP6Z@FF8)o(biNbSuxk{*CPW59#zDj3N^w>%Vk!hX2wZ|1UN8-!kpL)qg<&z~8C=wErRN z|ECGS%Km?G0oYkS)qMKDx&WUB!T+ld@VTQR;6IIk|KbDuLnHpHYW$xl=D!>M8CjVB zS0|v&x{m-s#G}*CUa|bwMzErq__Qc>%aD-W4G_ivoB|BwZVv!}kHH$60PHC0aQO?@ z`52GOg2)3__8#Hbv>dLwnT6sfi1a{QY2iw-YuS}b-CY2wO&2ZV!9-N0)mIOx4$`2= z3%q*lt*GkcpM)4()9Zr;a!y_DA7D&N;v9&6<`}aXf*9riE7-!%a`){Tm9Z0f0kcM7@~6)e!g(s(iqQL0hRewJ8s}Ffs6&5;~ONJgI&c# zIO0vEA0k7PR$TbXuc<`X9iv9dj7li8o_OfxWwsLc@g@7xi*NGKtFxv0t!qXvlkIAJKLrF3=_>2HmF^sR&A?GY~8G6O_@31sON`8oev%Drav;~JZy%ikV;1C;LF zOu+Q8mSh#>>Epc}hOXP;3S4-LJSKnu2NYG%7P#{ZFNQzjRgcZ~;}!W6Zaes<-(~mg z6^JV;Mmt>Z70VO&GvQgxVgh-h)D>y}IKR;p?=UaEOm*I<1b8QTTgrMidj`r{Ajz9g z>_b-N7XUHU8p+Q!?=ytJKBYF9||c4zt}q zd|1lvfZ=c8T63f?qMj(~&bdYi(uz-%Bkix62LY!t?xliZEF^eS%R>|Uc5c(VXo)(= z`}M`lLus!LUnQfT1{&g-1!iwy(Y0)-qa$+667fo+EIO$wehahXyG#VhBcJYqVlTA# zuvQSwY&U$XS`=C=T>@tg`@veLVy%$o&6p5w+Bw=1z5)YqKw2^FP;kj*Xb^3!;vbHQ+^1VslCoIcaOC?r$zeT(rzcjty zyx(7fbK&mc&s4#s@v(hKG{zo^B`yFuX@!3;y(YWK%#1INH;v<`)4jfNO`5I8Srmmw z#Ah7!8#yF9F1-^n?`|L*z%aT+a;TibEgu6cmh@~Mm>}mHLmFdbZQJ??a9Lq*;@o;O zPKf1Ogf>Ko-VQ3-nl9fXUr3-2K;0&JiGPo-j{JxmE_-VDEw%P$T^qwljzbIhXz}OB z7{t+_52hswP9lh3sIGG=Nj)T3#^SKFvV@h>`{BXW7??r6esF(!oMM)uxL0=r*OKV? z*kz`}dYQu4_M&=gC6E8BC+f1x<#?i?$`boG+nI9+#Lj&E%OZBPm_xEXP#(xdm7%<8 zk>@H7`P*aS5b>l^+Z|%W^5GVsa2%fU7)mP%#1QE4wz+U;xS|)fS?ED6$$2Sy-8948 z@6lOywC{J5c_7>3TYU26Akmg^sG5q*o)}tE>_+JKIy)51ISK4g0X5~FKwUn_wqUoZZdI7bQx4RUT;e&d{(&SNh zZ+U8zjDAa5jIFh%N_Kt#d7Xxi-0aspEj2rhGs5zt1X=Qi2o;L#5st}YQlSD-0adeo zm|V%md}1B?BuVyzB*bI~6T7M8dq2s0Eiz4cGr~bwS-RtW$q9b29Fc{lK5-RRY3xYJR{Ig9O1A zr1U>ws9jb0gGDkZJ0(zT3m`J+L68xGFg8%+-k2xsgcU=KZQ+D~opyowFpA*mpu`wt z@eGcLR!~goqnrHzI(a?26dMLfgM^U3kkbc3dTGqXxP4=9TrnRF zM5-6AK;(@<(F2P>Uw#hsZoG&jGvCFFT&5k32c(Q*P)D!NR5t>PQbI*WLc+FO0=VG_ z()w7ka^TFiqaV9`xVAinA7dKCioVBdn#CYqj|}a7f5|8YEdDw~?62`b5<_J-u;V^O zs)h9iS|&}vPI)ZrPDadbi21hU7vs3cbd*Ds4=j0#D4U1>xiD2m$S8+*?hH{j?MBz#XX0AiyEgZX1wifGVFh(Tkxs{-s?R4Df|<-&ItrpWQ;T@`#R?~)@6!GM72FZ}kJ?Pm*2r4X%}U?K@;|HfzaTpdY#g7+ z&SzD{K+n!dz`@A+*JAw-fAddfhn0irFU$_hUznZGlZ$^dJO8y*{~yc_!{0zV%xwSH zQXTM*Rn#)Hzsp$k5umicP;+14p+z1GLJKTes}JSiGoQoL|Bi#gMm2zYe)LMSg65%M z>P)qBJzL{#m>_#V>$o78?&d_+dytyr_rRziPW(A=;%KnH5DyiQ)1-L_s(1>%$sEwJ zYbk42&=!BqbN1CE52z9<3gVH|66ILX#n*Rq|%o&UQ6Vj?P4U~zyj4Z`j3Yu;T> zgKtos)L8N+o@*QUk`J_`A90IUvsovkqLw<&%2bE73*DET{_xAn6Kr)-&Rw5T2mJS@ zGlu`4B+uXF!Qa;9p8@?R!^6bNLcqqsOu)iOPXPFw)keU?!AkJw_J0CB4F7}Z`A2;J zQjdSW%D+x4{yB|}@qZRwo8vLk4qN-j{*@ZqK{(= zFdoTfGY;*D_$aUsI*@ph4I|;Z{f#Y14?0k@5b^Z%H66fX@a0P@fzS2W(Nbq@mD`!Y zmt$&#DtK_iF3)XAF#d-xD{AP%JuZixhQhDjeX3xC$Syn;Oq>X+2)bNo*Tag1w+SCu zJ7Bvv+S7+mfCEG^e1agr{x$zXx`j7bOgu=;gETXe+-n-7!~+n`CfdGB80&w zN9E6UxExhZKkzVzc3B(x!W4z=kHZ3h{0Grm9v@^&bu>>^n`2}QhzHQYW;&lpc7kZO zL(?SeyRK+#ZiOLBO;0+#oc*w*et^q1#1*tF8cMS*tqxJH76&DO2$cl+TldSA!4nAK zVk%dZJ;c`sN)3<1yvH_X>m+bbw_vId*Y zgL@db=9d?Dk4Ed`i`Is^ypHktm6>*R^ObtLUUDq#lf|mGg4Pjrb@@(XCy8q+u~==2 zp&E^`R7|syLX7`gz!qg9~L4lqtmSUA+^O@xzu)! zj`VRtDt&|idCG1P9YH(=k_4O<0R;up0uc#)M7CexCq0Bzd=^e2b%vVR5ZlKp!KzB% zm|UU#ok(GZ`TMNJV9`(`RU9d;;=A)LAPq>E%t~mZlK9OZuA|=uo#NKqOo8<_i+!%e3FZy<00= zJ~^JH9fWxNFV=&0&mE_fwW16tn!I12sIl(;oIjMeLkzMi;jaGt z(2zo{wkejJ>4_PGpWm;A#Z6GF>jQ^K%W>9%Ta0;N!=&K{AtGzdleP)~iY96xA{f@_ z*J4tZor?*s{*j}iBHe!+Ld6kv(0?*htwq=rTw-c2DH{$f#496Z*Sge#q&=LY!UAdz z7@a=kfM~cyH#rerJ=Q1&v7tttu;~6qZAZ%Ujwpgr`+U6?8G@It9ow#^SJjJrHPhG& zlc-Z)b8uCwgL&oHf~)Pd%6+dvK;@q{i`r&Qzk9W$^w~KlDQOpWv~Agr4n`}Eu!>;I zZ1bx~pGLNO)$gl`(n|9!md`%heU4-sfQGv}Z2OmV{S4%M+(c82Lq{j{sKC(`7KzEMfVqInIKrS-Qon@*Aa!+y~^6M)_DNx1|5s4HRcnd3}w4Y~y z()TxWivDP}N&1pkKr;pTWXu6bG?vFrq!&Z79hxq|F%!@Tu185^?KeG314?70RHiEs zC!@?9-Lhl~h?6DUSAV55BeLbpG(=d1F~4WJp-D|+kYH8Thax3m=@If@)PlFZ&5(sq zGLUnelcuvw_9H;U{-|gc=Cev@>*(H#NycLx>Ydrbmk%*OP8zQH3c>)$r!I-&uZue{ zExaR>v{5()mt@lqkK^_`QB-@;37mpkx~SQWMM?gcORCo@OuX6oE}`MA>Wk@tuqnLr zv|$?1pulS)38Yx{H5&ZN-8)%zGQPaVP7afqB~d*m>8#bDh@~v2HSFra^5xU?!Rg^^ zV?SoS;GsFpD-}tx-}DD}e)n8lLq=`%+dpoMgXSgh;v^6n|GIS`+PnNA##*BZOy$>4 zrL4p_vk_@2K<}k1waOJ(2^cl>*CU7fjtwm-4N-Gr;~-4+`qVx_!Hxy?)Isoy#Hsr@ zqT=-ctNcQ3t707g8kJGLxaKCZWIilcG8_Ag^D507arefoOHQuqqhzK?2=>SI0*LGt zkNdLrwnO<@^kj%Pc+%uZbe%{LwvXhNRi{IS1Lf}^fZ%*%+(}i#BJ|ZK!T6Hm;_qtI zF_t-va3_7OrL6`|bo0kd&qN4Nam8M!q|WR8$haw1mMxb`&KbG{EZ7v3YFkrSrZ_D*qgb>TIM>X0ty8i{ zHhzv)0($EbhxZTW7A%SO_T;=9B9<)Wf*#TL^X+8X9;`XsFMeUm$>BBG1?lrJ7@>QQ zb37iB`@1;4XrXT2@y;>1c-(aNfW$|`SlwG|zw{{bk-B6>z*TrM_rFbTPISK5w66Ml z6hLg8zYd#hbhlRO^Ee}ToTZ?EWoBLRi;ekY0p^Z}sdyF=ZB_5~azQMQ=PF8T%*2<1ZGb1Dhi}KuRf-%<^joOH&~f^k z4l1e6BXOyVlpEf!;on1ixchin1!&qe!tP)W_jZ;KjSu@;##Jz3xaP&$YI(Z@p&(Fa z1I&+a3z4>9J)_wMe;kNcYVcZ0-Sa2Z*q7W!%7kD!eJ{?NujzE=!L}KY#6bebaTcAh z*T3MCQs*uwP=? zZS4Dh$(s@N-DQlVq-;rT*m4XANW0Tb9_yz`4mN^Hp8OgF-${~d{gK`S~v zlQ!ch$%5;Lbjm6Tl

HeJ`O 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%0AVv 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 delta 150039 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 z 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 LtWoX{`0{@M%wCX1