\n",
"\n",
"**Note:** This notebook is written in JAX+Flax. It is a 1-to-1 translation of the original notebook written in PyTorch+PyTorch Lightning with almost identical results. For an introduction to JAX, check out our [Tutorial 2 (JAX): Introduction to JAX+Flax](https://uvadlc-notebooks.readthedocs.io/en/latest/tutorial_notebooks/JAX/tutorial2/Introduction_to_JAX.html). Further, throughout the notebook, we comment on major differences to the PyTorch version and provide explanations for the major parts of the JAX code. We do not provide speed comparisons for this notebook since they tend to be uninformative for such small networks and potentially bottlenecked by other factors.\n",
" \n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In this tutorial, we will review techniques for optimization and initialization of neural networks. When increasing the depth of neural networks, there are various challenges we face. Most importantly, we need to have a stable gradient flow through the network, as otherwise, we might encounter vanishing or exploding gradients. This is why we will take a closer look at the following concepts: initialization and optimization.\n",
"\n",
"In the first half of the notebook, we will review different initialization techniques, and go step by step from the simplest initialization to methods that are nowadays used in very deep networks. In the second half, we focus on optimization comparing the optimizers SGD, SGD with Momentum, and Adam. \n",
"\n",
"Let's start with importing our standard libraries:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/home/phillip/anaconda3/envs/dl2020/lib/python3.7/site-packages/chex/_src/pytypes.py:37: FutureWarning: jax.tree_structure is deprecated, and will be removed in a future release. Use jax.tree_util.tree_structure instead.\n",
" PyTreeDef = type(jax.tree_structure(None))\n",
"WARNING:absl:GlobalAsyncCheckpointManager is not imported correctly. Checkpointing of GlobalDeviceArrays will not be available.To use the feature, install tensorstore.\n"
]
}
],
"source": [
"## Standard libraries\n",
"import os\n",
"import json\n",
"import math\n",
"import numpy as np \n",
"import copy\n",
"from typing import Any, Sequence, Callable, NamedTuple, Optional, Tuple\n",
"PyTree = Any # Type definition for PyTree, for readability\n",
"from copy import deepcopy\n",
"import pickle\n",
"\n",
"## Imports for plotting\n",
"import matplotlib.pyplot as plt\n",
"from matplotlib import cm\n",
"%matplotlib inline \n",
"from IPython.display import set_matplotlib_formats\n",
"set_matplotlib_formats('svg', 'pdf') # For export\n",
"import seaborn as sns\n",
"sns.set()\n",
"\n",
"## Progress bar\n",
"from tqdm.auto import tqdm\n",
"\n",
"## JAX\n",
"import jax\n",
"import jax.numpy as jnp\n",
"from jax import random\n",
"from jax.tree_util import tree_map\n",
"# Seeding for random operations\n",
"main_rng = random.PRNGKey(42)\n",
"\n",
"## Flax (NN in JAX)\n",
"try:\n",
" import flax\n",
"except ModuleNotFoundError: # Install flax if missing\n",
" !pip install --quiet flax\n",
" import flax\n",
"from flax import linen as nn\n",
"from flax.training import train_state, checkpoints\n",
"\n",
"## Optax (Optimizers in JAX)\n",
"try:\n",
" import optax\n",
"except ModuleNotFoundError: # Install optax if missing\n",
" !pip install --quiet optax\n",
" import optax"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We will use the same path variables `DATASET_PATH` and `CHECKPOINT_PATH` as in Tutorial 3. Adjust the paths if necessary."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Device: gpu:0\n"
]
}
],
"source": [
"# Path to the folder where the datasets are/should be downloaded (e.g. MNIST)\n",
"DATASET_PATH = \"../../data\"\n",
"# Path to the folder where the pretrained models are saved\n",
"CHECKPOINT_PATH = \"../../saved_models/tutorial4_jax\"\n",
"\n",
"# Verifying the device that will be used throughout this notebook\n",
"print(\"Device:\", jax.devices()[0])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the last part of the notebook, we will train models using three different optimizers. The pretrained models for those are downloaded below."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"import urllib.request\n",
"from urllib.error import HTTPError\n",
"# Github URL where saved models are stored for this tutorial\n",
"base_url = \"https://raw.githubusercontent.com/phlippe/saved_models/main/JAX/tutorial4/\"\n",
"# Files to download\n",
"pretrained_files = [\"FashionMNIST_SGD.config\", \"FashionMNIST_SGD_results.json\", \"FashionMNIST_SGD.tar\", \n",
" \"FashionMNIST_SGDMom.config\", \"FashionMNIST_SGDMom_results.json\", \"FashionMNIST_SGDMom.tar\", \n",
" \"FashionMNIST_Adam.config\", \"FashionMNIST_Adam_results.json\", \"FashionMNIST_Adam.tar\" ]\n",
"# Create checkpoint path if it doesn't exist yet\n",
"os.makedirs(CHECKPOINT_PATH, exist_ok=True)\n",
"\n",
"# For each file, check whether it already exists. If not, try downloading it.\n",
"for file_name in pretrained_files:\n",
" file_path = os.path.join(CHECKPOINT_PATH, file_name)\n",
" if not os.path.isfile(file_path):\n",
" file_url = base_url + file_name\n",
" print(f\"Downloading {file_url}...\")\n",
" try:\n",
" urllib.request.urlretrieve(file_url, file_path)\n",
" except HTTPError as e:\n",
" print(\"Something went wrong. Please try to download the file from the GDrive folder, or contact the author with the full output including the following error:\\n\", e)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Preparation"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Throughout this notebook, we will use a deep fully connected network, similar to our previous tutorial. We will also again apply the network to FashionMNIST, so you can relate to the results of Tutorial 3. \n",
"We start by loading the FashionMNIST dataset:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"import torch.utils.data as data\n",
"from torchvision.datasets import FashionMNIST\n",
"from torchvision import transforms\n",
"\n",
"\n",
"# Transformations applied on each image => bring them into a numpy array and normalize to mean 0 and std 1\n",
"def image_to_numpy(img):\n",
" img = np.array(img, dtype=np.float32)\n",
" img = (img / 255. - 0.2861) / 0.3530\n",
" return img\n",
"\n",
"# We need to stack the batch elements as numpy arrays\n",
"def numpy_collate(batch):\n",
" if isinstance(batch[0], np.ndarray):\n",
" return np.stack(batch)\n",
" elif isinstance(batch[0], (tuple,list)):\n",
" transposed = zip(*batch)\n",
" return [numpy_collate(samples) for samples in transposed]\n",
" else:\n",
" return np.array(batch)\n",
"\n",
"# Loading the training dataset. We need to split it into a training and validation part\n",
"train_dataset = FashionMNIST(root=DATASET_PATH,\n",
" train=True,\n",
" transform=image_to_numpy,\n",
" download=True)\n",
"train_set, val_set = torch.utils.data.random_split(train_dataset,\n",
" [50000, 10000],\n",
" generator=torch.Generator().manual_seed(42))\n",
"\n",
"# Loading the test set\n",
"test_set = FashionMNIST(root=DATASET_PATH,\n",
" train=False,\n",
" transform=image_to_numpy,\n",
" download=True)\n",
"\n",
"# We define a set of data loaders that we can use for various purposes later.\n",
"# Note that for actually training a model, we will use different data loaders\n",
"# with a lower batch size.\n",
"train_loader = data.DataLoader(train_set,\n",
" batch_size=1024,\n",
" shuffle=False,\n",
" drop_last=False,\n",
" collate_fn=numpy_collate)\n",
"val_loader = data.DataLoader(val_set,\n",
" batch_size=1024,\n",
" shuffle=False,\n",
" drop_last=False,\n",
" collate_fn=numpy_collate)\n",
"test_loader = data.DataLoader(test_set,\n",
" batch_size=1024,\n",
" shuffle=False,\n",
" drop_last=False,\n",
" collate_fn=numpy_collate)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In comparison to the previous tutorial, we have changed the parameters of the normalization transformation in `image_to_numpy`. The normalization is now designed to give us an expected mean of 0 and a standard deviation of 1 across pixels. This will be particularly relevant for the discussion about initialization we will look at below, and hence we change it here. It should be noted that in most classification tasks, both normalization techniques (between -1 and 1 or mean 0 and stddev 1) have shown to work well.\n",
"We can calculate the normalization parameters by determining the mean and standard deviation on the original images:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Mean 0.28604060411453247\n",
"Std 0.3530242443084717\n"
]
}
],
"source": [
"print(\"Mean\", (train_dataset.data.float() / 255.0).mean().item())\n",
"print(\"Std\", (train_dataset.data.float() / 255.0).std().item())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can verify the transformation by looking at the statistics of a single batch:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Mean: 0.008\n",
"Standard deviation: 1.009\n",
"Maximum: 2.022\n",
"Minimum: -0.810\n"
]
}
],
"source": [
"imgs, _ = next(iter(train_loader))\n",
"print(f\"Mean: {imgs.mean().item():5.3f}\")\n",
"print(f\"Standard deviation: {imgs.std().item():5.3f}\")\n",
"print(f\"Maximum: {imgs.max().item():5.3f}\")\n",
"print(f\"Minimum: {imgs.min().item():5.3f}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that the maximum and minimum are not 1 and -1 anymore, but shifted towards the positive values. This is because FashionMNIST contains a lot of black pixels, similar to MNIST.\n",
"\n",
"Next, we create a linear neural network. We use the same setup as in the previous tutorial. "
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"# Network\n",
"class BaseNetwork(nn.Module):\n",
" act_fn : Callable\n",
" num_classes : int = 10\n",
" hidden_sizes : Sequence = (512, 256, 256, 128)\n",
" kernel_init : Callable = nn.linear.default_kernel_init\n",
"\n",
" @nn.compact\n",
" def __call__(self, x, return_activations=False):\n",
" x = x.reshape(x.shape[0], -1) # Reshape images to a flat vector\n",
" # We collect all activations throughout the network for later visualizations\n",
" # Remember that in jitted functions, unused tensors will anyways be removed.\n",
" activations = []\n",
" for hd in self.hidden_sizes:\n",
" x = nn.Dense(hd,\n",
" kernel_init=self.kernel_init)(x)\n",
" activations.append(x)\n",
" x = self.act_fn(x)\n",
" activations.append(x)\n",
" x = nn.Dense(self.num_classes,\n",
" kernel_init=self.kernel_init)(x)\n",
" activations.append(x)\n",
" return x if not return_activations else (x, activations)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For the activation functions, we make use of JAX's and Flax's library instead of implementing ourselves. However, we also define an `Identity` activation function. Although this activation function would significantly limit the network's modeling capabilities, we will use it in the first steps of our discussion about initialization (for simplicity). "
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"act_fn_by_name = {\n",
" \"tanh\": nn.tanh,\n",
" \"relu\": nn.relu,\n",
" \"identity\": lambda x: x\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finally, we define a few plotting functions that we will use for our discussions. These functions help us to (1) visualize the weight/parameter distribution inside a network, (2) visualize the gradients that the parameters at different layers receive, and (3) the activations, i.e. the output of the linear layers. The detailed code is not important, but feel free to take a closer look if interested."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"##############################################################\n",
"\n",
"def plot_dists(val_dict, color=\"C0\", xlabel=None, stat=\"count\", use_kde=True):\n",
" columns = len(val_dict)\n",
" fig, ax = plt.subplots(1, columns, figsize=(columns*3, 2.5))\n",
" fig_index = 0\n",
" for key in sorted(val_dict.keys()):\n",
" key_ax = ax[fig_index%columns]\n",
" sns.histplot(val_dict[key], ax=key_ax, color=color, bins=50, stat=stat,\n",
" kde=use_kde and ((val_dict[key].max()-val_dict[key].min())>1e-8)) # Only plot kde if there is variance\n",
" key_ax.set_title(f\"{key} \" + (r\"(%i $\\to$ %i)\" % (val_dict[key].shape[1], val_dict[key].shape[0]) if len(val_dict[key].shape)>1 else \"\"))\n",
" if xlabel is not None:\n",
" key_ax.set_xlabel(xlabel)\n",
" fig_index += 1\n",
" fig.subplots_adjust(wspace=0.4)\n",
" return fig\n",
" \n",
"##############################################################\n",
"\n",
"def visualize_weight_distribution(params, color=\"C0\"):\n",
" params, _ = jax.tree_util.tree_flatten(params)\n",
" params = [p.reshape(-1) for p in params if len(p.shape) > 1] # Remove biases\n",
" params = jax.device_get(params)\n",
" weights = {f'Layer {layer_idx*2}': p for layer_idx, p in enumerate(params)}\n",
" \n",
" ## Plotting\n",
" fig = plot_dists(weights, color=color, xlabel=\"Weight vals\")\n",
" fig.suptitle(\"Weight distribution\", fontsize=14, y=1.05)\n",
" plt.show()\n",
" plt.close() \n",
" \n",
"##############################################################\n",
"\n",
"small_loader = data.DataLoader(train_set, batch_size=1024, shuffle=False, collate_fn=numpy_collate)\n",
"exmp_imgs, exmp_labels = next(iter(small_loader))\n",
"\n",
"def visualize_gradients(model, params, color=\"C0\", print_variance=False):\n",
" \"\"\"\n",
" Inputs:\n",
" net - Object of class BaseNetwork\n",
" color - Color in which we want to visualize the histogram (for easier separation of activation functions)\n",
" \"\"\"\n",
" # Pass one batch through the network, and calculate the gradients for the weights\n",
" def loss_func(p):\n",
" logits = model.apply(p, exmp_imgs)\n",
" loss = optax.softmax_cross_entropy_with_integer_labels(logits, exmp_labels).mean()\n",
" return loss\n",
" grads = jax.grad(loss_func)(params)\n",
" grads = jax.device_get(grads)\n",
" # We limit our visualization to the weight parameters and exclude the bias to reduce the number of plots\n",
" grads = jax.tree_util.tree_leaves(grads)\n",
" grads = [g.reshape(-1) for g in grads if len(g.shape) > 1]\n",
" grads = {f'Layer {layer_idx*2}': g for layer_idx, g in enumerate(grads)}\n",
" \n",
" ## Plotting\n",
" fig = plot_dists(grads, color=color, xlabel=\"Grad magnitude\")\n",
" fig.suptitle(\"Gradient distribution\", fontsize=14, y=1.05)\n",
" plt.show()\n",
" plt.close() \n",
" \n",
" if print_variance:\n",
" for key in sorted(grads.keys()):\n",
" print(f\"{key} - Variance: {np.var(grads[key])}\")\n",
"\n",
"##############################################################\n",
"\n",
"def visualize_activations(model, params, color=\"C0\", print_variance=False):\n",
" # Pass one batch through the network, and calculate the activations\n",
" _, activations = model.apply(params, exmp_imgs, return_activations=True)\n",
" activations = {f'Layer {layer_idx*2}': act.reshape(-1) for layer_idx, act in enumerate(activations[::2])}\n",
" \n",
" ## Plotting\n",
" fig = plot_dists(activations, color=color, stat=\"density\", xlabel=\"Activation vals\")\n",
" fig.suptitle(\"Activation distribution\", fontsize=14, y=1.05)\n",
" plt.show()\n",
" plt.close() \n",
" \n",
" if print_variance:\n",
" for key in sorted(activations.keys()):\n",
" print(f\"{key} - Variance: {np.var(activations[key])}\")\n",
"\n",
" \n",
"##############################################################"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Initialization\n",
"\n",
"Before starting our discussion about initialization, it should be noted that there exist many very good blog posts about the topic of neural network initialization (for example [deeplearning.ai](https://www.deeplearning.ai/ai-notes/initialization/), or a more [math-focused blog post](https://pouannes.github.io/blog/initialization/#mjx-eqn-eqfwd_K)). In case something remains unclear after this tutorial, we recommend skimming through these blog posts as well.\n",
"\n",
"When initializing a neural network, there are a few properties we would like to have. First, the variance of the input should be propagated through the model to the last layer, so that we have a similar standard deviation for the output neurons. If the variance would vanish the deeper we go in our model, it becomes much harder to optimize the model as the input to the next layer is basically a single constant value. Similarly, if the variance increases, it is likely to explode (i.e. head to infinity) the deeper we design our model. The second property we look out for in initialization techniques is a gradient distribution with equal variance across layers. If the first layer receives much smaller gradients than the last layer, we will have difficulties in choosing an appropriate learning rate. \n",
"\n",
"As a starting point for finding a good method, we will analyze different initialization based on our linear neural network with no activation function (i.e. an identity). We do this because initializations depend on the specific activation function used in the network, and we can adjust the initialization schemes later on for our specific choice."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"def init_simple_model(kernel_init, act_fn=act_fn_by_name['identity']):\n",
" model = BaseNetwork(act_fn=act_fn,\n",
" kernel_init=kernel_init)\n",
" params = model.init(random.PRNGKey(42), exmp_imgs)\n",
" return model, params"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that in contrast to the [PyTorch version](https://uvadlc-notebooks.readthedocs.io/en/latest/tutorial_notebooks/tutorial4/Optimization_and_Initialization.html) of this tutorial, we keep the bias initialization fixed. As the default, JAX uses a zero initialization. In practice, the initialization of the bias is less relevant as long as it is reasonably close to zero, since it is only a (learnable) constant added to the features."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Constant initialization\n",
"\n",
"The first initialization we can consider is to initialize all weights with the same constant value. Intuitively, setting all weights to zero is not a good idea as the propagated gradient will be zero. However, what happens if we set all weights to a value slightly larger or smaller than 0? To find out, we can implement a function for setting all parameters below and visualize the gradients."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"application/pdf": "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\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/pdf": "JVBERi0xLjQKJazcIKu6CjEgMCBvYmoKPDwgL1BhZ2VzIDIgMCBSIC9UeXBlIC9DYXRhbG9nID4+CmVuZG9iago4IDAgb2JqCjw8IC9FeHRHU3RhdGUgNCAwIFIgL0ZvbnQgMyAwIFIgL1BhdHRlcm4gNSAwIFIKL1Byb2NTZXQgWyAvUERGIC9UZXh0IC9JbWFnZUIgL0ltYWdlQyAvSW1hZ2VJIF0gL1NoYWRpbmcgNiAwIFIKL1hPYmplY3QgNyAwIFIgPj4KZW5kb2JqCjEwIDAgb2JqCjw8IC9Bbm5vdHMgWyBdIC9Db250ZW50cyA5IDAgUgovR3JvdXAgPDwgL0NTIC9EZXZpY2VSR0IgL1MgL1RyYW5zcGFyZW5jeSAvVHlwZSAvR3JvdXAgPj4KL01lZGlhQm94IFsgMCAwIDg5MS4zMzc1IDIxNS40NDY4NzUgXSAvUGFyZW50IDIgMCBSIC9SZXNvdXJjZXMgOCAwIFIKL1R5cGUgL1BhZ2UgPj4KZW5kb2JqCjkgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAxMSAwIFIgPj4Kc3RyZWFtCnic1X1bjy67cd37/IrvMXlQi/fLowwnAoK82BGQZ0WWEwnaMnSxDf/7rFXF7q7mcI7P3pqzAWJD9sw63/DrWl0sFsnion/9/u3nv/Cv//uXF/7Py71+j//9O37+JX9/c/jty1vr/oixZvzyh/uX4PORUmn48Q/44OPX//f29s9v7ui+llRdbu01/5K687242l5/5tf+8t0Hrl/epk+/vaV6eD5B8kfVb/zy5ms8es6lBQP/wcK+1qOc+NnEA5Sn/tPrffM+lKP58Q8txXz0159/+/rfrz++fv6LoOz9D/zv9/ifsPf287//7b/97je//cdf/t3rN3956+nI2YXkH898o4/HePtfb//w+tPZsDt8xps525ZffznQt7/71evn/x1/7l+/+uc3vJjUak2uBNdeIR2xerb4q396+y/uv75+9fvXf/uVtPwTGOhLR5sZL+jxUi70Uwz0pRyuxlA7rCyThfm08PyTwD+p4QgutOS66/7Vj9zBjv7BL37z19/926//+rt/+ePr3379h7/8xAR9hc9+Kz0hHBG2xXo01+P54o+f+tWfTbaMuJBaqE/Lbvhvtqwh8nS8/1JC9MM6/52s86EdPYQKX36YZ/C/2T4Pj+4th9pCKqeB4XsZiK6SPbrXZN8F/+3mlXZkvL7QW+lhmBeX3dahyZ95jAsYVKr4cutHaaPzfpFxiX//97/9419+99f/+FsoimoLHsrFjkGsYrxJOvKEiCHvKOfYk2SoOgK8rwWXXBoDpf3jl/3jt+mP395yOASIjziQM4IUQlp7hIEbzejEDj2I7+BuwaIYuf5uA+sXdsL6CgeLOcan9ReaG760l+qfnBh0E+sXdsL6jufr0U/v/kJrQgdAOGgPTiy6ifULO7+8lXD4gPDyfPc3ylzT51DSgxOL7mH9yk5Yn44UXWvPd3+jyA8dGirxyYlBN7F+YSesL0eNpdT0tP5CvUe213vK/UHKA97E/oWlsL8fLgXa8bD/QvnEsRaX05MWC29i/8LSL28VvRh5YXq+/xv1CZOHlF32T1osvIf9K0thfzxKTi483/+N+lSQ7qLTh4kWA29i/8JS2I8Hyr356f1fqI/hKCGEPNFi4U3sX1gK+5nB5Nyn93+hPrmjtVhyfNJi4U3sX1j65a05zAZ8bM/3f6OPjm5p2a7/ryyF/eFotfryfP836gMSntJSLk9aLLyJ/QtLYX8+8GCYZj7tv1CPmOdrTqk8abHwJvYvLIX99UitTenPBfqCmXRxIfUnKRbexPr3dnJJGROYlMP08i/0McrdpOw39q0M/fLWkc07F/3D+gv0CaNdrElCvOXEwHtYv7BTlr2TK64/3/2NPuxck7KJ9QtDYT5See+nSd8FPtIbw8l+Wc/CThiPPN7XUqZ3f6HeRyS6ucjs7ibFoptYvzD0y5t3yOMDTHluUl2oz/5ovTVJbgwrFt7D/pWltB+dOPQQy0TABXsXjhhdKuFJjIV3YWBhKynAI8Xsgp8ouGC4/NFyDLlN1Fh8Fw4WxpIDpPPJNTe7wQVzKyQW13KduLH4LhwsjAUHHil9Qkib/OCGJz+4udnQD1bGkgOk9TnEOvnBDT9mO5ab/WZBS2PJAZL73HyZ/eCCH2O/5Wa/nGBpLDlAhl9iT7MfXPAj+7Pc7JcVLo0lB0j0S69x9oMLfsYDw82O8WBhLDgI4XA1Z1+fHNzwY/X/wc12uwJLY8kBRrjmo5sKmW64xcPl2Ep5UmPhXRhYmEoGyoEfXZu94IKfDCyJ2YWBhalkoB29h1ZnH7jgx4zItLLhTGlpLDiInm2UPHnBDdttYNPIfrvDS1PJAMY2l1KavOCGHwysidmFgYWpZACPhKlfmH3ggks8aq1SXGbaMOgu9i8Mpf1I+n1xfvaAC84BI2DQ8izTiIV3YWBhKhhISPmDr/25XGbheoSMltOTGAtvwsDKVDKAhD/U3OLEwAUXf7gQk5RCmUYsvAsDC1PJANL9GGOZfeCG05GdK+oDphED78LAwlQygGQ/dp9nH7hh2wtMIxv2goWpZACpfko9zj5www8GlsTswsDCVDCAmO6yq2HyAQM/esHdyH69YGUqGUCmj9TWTT7wEbzkaxcGFjaRAST6JYQ+5UMGVncvMzEG3oWBhalkAHl+aa72iYEP4CVfuzCwsIlnapDnV8xyn5au0TUtm9i/MInmxyPXXtL0pj+CV7TsYv/CJBKQj9ZyilMM+Ahe8rILAwubyEA7fPfBz+/6hseQ1ydiDPzNDDyP1Bz59e9vH5r05OMff/l6Hr2xx0HK4TP+3PNIQDwSF7SKPlvPspiTWfbt5EU2FsEUKQAGWmLvPfA4iO94YC5+8ZiE7xEPwIlgbsXLoYJyxNq4i5b70UNKTQ4V9APsMEQ0Dhc9dam3hRkxphBeLL4poVa2yymFD7XIcZzaAuh6SWl6xUDbE0vTW68ccIBGbtiC2levLFjsLSraXU9NNnQ93oai5QhoLPM4FYzvrXmvcHPFs/whVBb9RSe14O3AWBbCqIUm2/IYeCQXuDeUSEUu/GzFu2khIBH0eME9wlCpskRuwHOB+EIkyxVPkQecey+j/ijBaKmyr/HwtSGQChxyC/J4gDnN8PxGGF6LlxWXmjALLx1jDh8EXQ8kvKSCM+FN86HBPt6ZJ0uVJxpzAQuEWylFyx0xbvFoaJE2UpQfAWMYjymyCi6xCq5EOQECGP5SfRAYzpai1AzTT6Jj1VjiilDCQKBwR1bUmxJVPM+aAe4Hl5F5GDWSYO/EmoaPRO9YeBjrEUvK8sYAV+9SqAKDsS75ZUO4hQdUtQZeL9VrAV1CtuqYl8Pw2viFXK2FX7Gkk6ka3m2qCsMCzOIA58PBd8V54Zzw7dRYDFEPnm8UjwQMd2wBxvBEEFJ+bYR+AWu8wC2VIr4OGH6fWUULuOJr1JiCuBC5p8y2m0OeJJ+uTB4QOV7MpFpr4lGN+7AevwCNaBrDyyjTSg6OGMSaVJzXyj28a5jotYYDnKoLd/yMUcl58agCc8SjAFfM3aXKOx14Bbqf0QMsq4HLu5jcgrLQBUZXQWyoUZ0kI87Tdp4PiTn6oi/SxSB0A+arHgcLWFcS6CQdQSEH0uMDvDUiWo/SG/wsdVe+oz28ZYF5Agk/R/k0ksvupEir4Y2ATd23zwiibhSwhNSTYwyVyMADhQLjhVVWdUQwD4abFnvACNecFEHBBkRU3fUF3vFxPkuASzMCyVIHIwh8V3aFMnwwJqGceEWj3BgLsi4ezxqT6NAHouLZdR0fgLeWvHw+sRkX9XHYZvAyIKBFRKWkj4MQ4PA2mxib0GboA0d0bdyUDIi/vWsc9I7dBtEmCY436oe5lWGA/kocb7ZH3dxEyAKxvkswhMfgSQbeYsF4KriHP0i/9d7DU3JxWfDGQok08I5ozlgbeAbXD5phfK5JAiWiasagUnVzHeEfLQR5Kx7B2A+0IZyVKN6ER0lBW4cpiABOvQyPVbs+ZeGsK6YugSG3jI4/8BI6z33S/UL2enSPe5ex1CqlHSzuzLUoCwhHAbGzql9mdFtZ5MUveAi+FI8hAZ7QdAcEgaekJAVEeD8YE3RNGG8uBZgVODZlDH5dWiexLnA+1B1ctzHkK5wxhOK9NcaYFpUxvGbPMOR5mBnPqrXHhCvyGox7jZuPnGsKDLIxEmPgQyMNHWA8CQcU7ty/0G8RGPuwB1+UK/es0OXQRc7nrtzWDggW7ETweQn09P+AkZ8DpWPWgZAYBw7+G14BPt4xiKjLhI4RH1/ZXuih+M9VogxSiyNHpCsYsBFhKxOIl24g4P3AqRBvkCgUdceI4FMxnEZSBS6jqwNuGV9QaCXCZleni5E9Ai2+EPUR6zCOvHRluqLr4esRdwvcQM2Bo0XET2QyDLAInjpvBdxdKV3WsZlYNG2bZcAF34NUJ0RZ5dUlX1dy5HIfrKU3+wHDH9CiwNdTg8yQHAI520CWoRFGxmmQ3V4y5OD5hBCMmnj+BBMAp1ZDEEYSj+JJRsfsC8OZhh2GZsfgxKfuwbXRNvokskHkAMjbKpwoiemM77Hx+zEmIlMb3QTZiGODnRkhRvSgRgLO4IzbI+hHGPyiLvbiMxneoBP8hICmX1nlyD2IIFz7CBQcfPGUPIYCgksOkr1xpQieiy/EdyCKDBs7IiSoklWlFjEoiI3CPMbOQphCDJKWEG7e9SCZN8ZxRAOBeV4fDh0ERiqnG1WgByEf7koYiZzX3QuQiZDWuRWa+dRO3zo9o9AXuarZUhwfpthILlWeD3m7G03DF9HzuKGMEF9qk2GfMLzcsRgR3ozEz5+zY6S4UUtU8TwlCdnIiDF+uVGxXtlrCSPNRWYDxxc44wXLp0uSt6oVLRimknYbzjow8UR051fiLSlTBf0aMY81QJGZadIP3zOXyBiYtfpxDT9P4QfORBBPx+zqPxedWCqfoM2lGMWXDwVU8BdfJ2mx+N4fbN3BsB8lMSCCAcjKwD1ehOh8eCaR2hZVAv7nr//jt39+udcpEzAEb75Gn0ZlcWadmncSN0+dGvQf5B/vDn5E9As4mJ+KYA384MK08l6thp5wfSDh37dOZN9W/hM4T+JM6mmAgT9F1yXwdCcSFIzyjEk/oFzz05mKEQKJiEYU+65u+FNMjTCAAxACLqYfk6neLcUwgqzln1b/aBGbn9Atvsqvv1nth/MvpM3j+d/J2rjv5BnGWvhpwTwE+crD2hv+NGsLVyUy8pqC+eBpccjf3WJO+GLnesLD4hv+NIs75/0ek86AZOi0OH//dyyTtJiZKj9MNvin2cxpC+aVwSNZxFcMo+v3f81cymAAxmTqafSNf57RTMh7QgbI8fqUcXLr2HcLATXPzFyb+Qo5oG+kj+vcP3Zd16xzI6Pvi3XuH1wkR54Q5b+nqRIUc3HkmTFMlaAGPiWAisBXIxa+1rn3IGJhMYnArAjT12kbx8CnGlCZ+DHwZkQsLCYRsgRbp0PDBh7CQLE9+bHwZkQsLCYR6P/4q9wmIi541EDKEp9pxMKbEbGwGERw5oq5bXpWORh4yAUNIm5+DLwXESuLSQSXD4IPk0fc8HlEQFbDTSsPfDMqFjaTisI1+D5VjRr41BCS3Q9LkcU3o2JhM6loXBEvffaKCz7lRHyfKLL4ZlQsbAYV3H/qspb6oOKGT3WFMDN0w3sRsbKYRESktzlMwisGPg/WyQKfJcjim1GxsJlUZDyhd1NdqYFPtSGNFIYii29GxcJmUtEOjAQtzl5xwc9IYSnaNlKsbAYVLP4IaHiKFDd8nr4dHeSmyOJ7UbGymVRwL5ny0RMVF/yQI7IULWWK9qBiYTOpwGwiJt9nr7jghzaRpWipWbQHFQubSQU32Hqvs1dc8EOoyFK0FDDag4qFzV9k6b6kXMvsFRd8ntCWHd8HRQbfjIqFzdwV4Sain/TMbvRxVH1BUN5vKF1YTB4wn8iV1YdPIi74zKNkO9MQZOHNiFiYTCYwnShxnodd6HlYt8z8WHwzIt5bTB4a04LuZo+44IfAkSFoqXu0BxELk8FEY1aQ5qnHhT5kjiw/S/mjLYhYWEweWOPsUp084oZPUQtdrbkJsvBmRCxMJhP5qK2ESf7FwKfkkWy2WYYsvhkVC5tJBctIg0uzU1zw5BQ3RRt7xcJmUNEdrzqZzvze6HMCZgjadwK2sJg8sKguFj/t/NzwmTSE9iTIwpsRsTCZTGAS4XpyU5y44TOP1KUaw5DFN6NiYTOpqNzE8ZM+jIHPeBBniiy+GRULm0lF59Z6r7NXXPBz18NStO2ux8rmL2/RYR6B+WWequpueMgD1fZkyMJbEbG0mERgIhFDThMPJ2rt/YCdzWh4by9ZwCQiIjlqEw0XPGZZuacHPQ94MyIWJpMJnoBKfpqGGthuiptGtt0rX1oMIjxmEam36TS4gZ9ELPnZi4iVxSRCTo6V5iciLvgUUKpPfiy8GRELi0kEphA8FTeNGTd8CimVJz8W3oyIhcUkgqdoapg2Ai08FCT6kx8Lb0bEwmIQwWONNbpJZ8bAp6xSffJj4b2IWFlMIjCBqvibadQw8DhNP/Fj4c2IWFj8RSr2efTTTaOGgYfE0MyPgTcjYmExiYBBHU1Mo4aBH0Qs+dmMiIXFJIJHMIqfVKst/OgadyP7do2FxTwc41W/YvKID+A1bXsRsTKNRCS9lzRPRNyw7RqmkW27xspiElH0itKZiA/gJW2bEbEwjUQ0ua10Gj0/QJfsbEbDe8vAAn6RW0untYgP4CU7e9Gwsow8RL2+tE88fAAv6dmMiIVpJCKvLn21sB06TSOfOHTao1FvouD0+pG0vFdwskd3yhF4PjzK+QROB3jwhEqUMCzoyRSq8xS5BlhEePCNLz2w4puUimVKXXini7U8x1ISNXSk7lKUK0KMR+c8I78K35DrTo961CP2zquhG+boGGHkPHygAAzlijoPTFGSQDfYE+0tITUKQHTnUo0DBnu8XqP3A+6HSb/AVOdJnPWLZkmOJWgrXA0IUW5rCfyeNkrrkflFR00qbkdhuixqAKytprRC1TJzzw0r/TilC1osqoxUYyp6egUUJVedFs64XMtoHcy1EnsUjZzQktZYJSQXJVeeWaNQAD4sEgmBsliJ6lSC58QblQZOIY+gClAhdpm5sdgXsxgqXGnrxeu2q2j6UDpIJZaqi14/j0dLlOzRilgX6vg8b+2hUo5q83T8lVbQcsRzSbWXis+6QwG01g5/01ZqzWprzlTk8kVloHhmLg64x5adluHmXrtWH4owUhW9LDDpClwqDRyumGMTrZaaOOa+tHAz8LV5+XzybjgeJZNiFoGtRD5KbvqY/eg9isJWZVdTCbKAqa/P+I9FdJJchje1gdeIeE6Bp3J4TA+rlsOFI3ov4lt4MgoEjeLJcIwjfVRmcKV1/dqCKFC6yG/h8x39MWkJFb4siXIScdGP0srDciCWiKYWXw86kLo3cBAlolp4zR1Bo+j3VooQiaoWvAK+ov5a0YWdV4krOTYTtKsBz81VVb6Cw3TtDTWwyBGvXNWL0OAoZomwtonMFaJSYEBKA2+80FXlfPD0pZ1lQDyp1FR2iAo7ynLlYa4iSldUr8Fz+TzwwlPCKjtUW1ZJJhbRIJqJ1hV6IUXL2ll9REUVil0hwOCVu/H8oLDyaSTsFHXjKv1dJLAQ6Hr3o/dUxJUYRASLymzoK0kb7xREERUsT7UgX/VhGgJOdSKDReEgStL4gcOPeXMJhYZqdqoSx3qPhAglW3ZZNjI1njXEmdZECcvDGdEfrqoIRBmKFAUJVs2lAbNqROSq0CE9up5WFFC8pMRTr6rgefrAu5PLE4gjE0n9LMYAY45CVsBb6kE9lgI/DrE3Sfs5wW+1ncYrKSqVqSjJRLWjNHBk/eN6q4JmurLQGZgSlakCgyQ8UjywI3b5XqlMFbjFT70YwT3FcioHOmoppTYqyDqCVOSNeSLhVOE6GnQ6/AVPIFcJIUQg1IzP45l7Jlf8PIJd08fviaXLnspUcGUEryZSLNxIjUjSotYfgN2udPaCD7EnqHxfbMOVO+JOBulZdxszftL2G4/yNwYSJ3iO2j61i2gZhyWMpGUsxPPWp9plHR4h/t65gu/hLb6o/VFyGfs4CDquYJSlLhHFdpLCAc9LcUOB25DEIYw/BXHSCHqyRBZuBjkOCU1OpcvBQUWLg8N5SjWhoydtQu5mpX/CXCpJSfQgzBViVym9hMidg8KITRgKsqBoIviBYjgsGNOopIbnH03zl07ltU5BR7wXfToqQjVH8SoORVGjOWH4XKJ4FQ8kJK9LtayIQN4k2lVIRKry4RHEsohiIn40RAE10aPvI+ZjIEJwhVdp5OTCd6vorMhECvMaVSqL6LKwC7GfCYrHAON1UZTlzp5dJ1MOMKq4FmH4fsPYgCgb9evAI7IrLqgzmWnB5QHXQskvyYcQDJwuv1PNDvlJpO4S2pdwHClPxyq58hK5Y/TGMGCMAezXmTKN0V/rlBjFEQy5hI/cShOzyHP4CKlUTO9U6wlqN2AEpIIRBlmHo/iUfhpRqDDtFO0mvJemn45UcRsqzC4guxM6GDGQW1KJqojMVNInES24UkTpqfAr9dP4xYscJdISBMCsVCPKosMzY2ImTG0ubaRRhE9ulpaQdlrZeF8eL8BgEpM9BZH+IFomGCSZibAR9C9JkbgcESitKVl2j0mlHAm3GORKDhZQeCfKUPB/ZAqemkhUhuKl7HXAHB7CWADumkpEHih0TXSXQHAen0W8KNXr4WY4vld3VyHJ8x4Y5HvyGHKhAWFB0VllRIlUVWIurW2wpqOcMwakHCoAhSk14t5L5xeetbWeSkpwp9H9zbQjshd7GQY+gL9Cd+kDgZSPlHzQ8lI75cuHmkD4i68WYVl/+w9+x9dpMDHBQm4JbxOdmqUIU/juIkyJof/9cRYE/cO9v37RwA8yTCtrEab7A/z3TXPRD2Q60G8w2rA/PAww8LcqE/3pjcoaP6PGRsSYX/GAkSRGo0v0my9PMQ++4ogMDMnmEN1Q1aI3vNI/4VVQ449yHPdPaAF//rNf/Pl3v/7Dz7787o//+pfX3//L2z/w30/LGzXsEKrKc4fPwJ+i6JR4ZpgCjhhiMCL9gHjVT2hq55Q3zeIABv4cUxt1ujqHTw5LP0q8Ksn2B2Wbfqxu1U/Zk74mFHyzxFflRVxu/FvoVn13Y6tjlsLVqIexN/xpxnLqjVyzYuKB0fOUrfruBnOCURs34x8G3/CnGYyw2fGNLIpJl05X+u4GcxbOm88w5j0sNvinmSxTXYeZRJOJwrC5fH+bORfhmtVk8gV/nsUiQxtyRcrfL22y9sOCVZHCoEjws7bxowWrvpG7b1zd9/z9q1f3E9eB31/ZmLy0wfUTG0gNPJSpiqZUVyMWvi9m2IGIlcUkIqxubjTwUKYSBV7Lj4E3I2JhMYlIqwscDTyUqeQUsGnEwpsRsbCYRNTVTY4Gtpd2mkbWd3luQcTCYhLR9YLC2SMueChTibC55cfAmxGxsBhEBK/3FE4eccOPO61NKx/cdb0DFSubSUXSCwunceOGVZiKy2UTRRbfjIqFzaSi6M2FaaLigk+5GdldshRZfDMqFjaTCu5Vph5nr7jgh5rGg6KVysYeVCxsBhUsJ+D9EpNX3PB53jHPFFl8LypWNpOKqJcaTl5xw6c0lehpWIosvhkVC5tJRdbbDeNExQU/Y4WlaNtYsbKZVFS96LBNVFzweTJaLuWwFFl8MyoWNnN90+mVh5NX3PBDmspStJSs2oKKlc2kIqwuPzTwKU0l27CWIotvRsXCZlKR9BbEaQS54edgaijadzBd2Uwq6ur6SAOfJ+aTnyky+GZULGzWvZDUq3OzV1zwQ5xqQdGGg+nKZlBBqSEX6lSLa+BnimUo2jfFWtlMKjCpcC1PRboGPgWqNK8wFFl8MyoWNpMKTCp8mjbTb/QUqJKCR0uQxTcj4r3F5AEzChZq5ImIC34oVBmClsJVexCxMBlMyEHPPOfcF3pKjKSJHgPvRcPCXrIg94KwBPVJwwWf6lRyy6Ghx8KbEbEwmUyw/rbOPAzwfO1yn6xlx+Kb0fDOXpKASUSKrDB+0nDBz+nXRc++k6+Vxbxcj/WFfTorfKPPHMLQs28OsbCYPPBASGqTGKqBn4nlTdC+eeXKZDLBKkk36ePe6DNCGH72jRALi8kD5g6lpDB7xAU/tzsMQdvudqxMJhOYOlQuLTyJONEhxKRbHXcTFt6Mhvf2goXGGt/a533AGx4GS938O3bCfvnDymDywKtxY523AW/4mlT1Jz8PfDMqFjaTinLE1mHRRMUF62Z4lCv4TCMW3oyIhcUkgpdk55hnn7jgURUg5y3e8aPwZkQsLGYBq5zB8/Oq5Q0PRarun/xYeC8iVhaTCB4RLH1S4zHwUKTS6ffdiIU3I2JhsZY0F8+zhBMRN2wUqWwjK6GqPYhYWEwieJt7S1PRsoGHIlXrT34svBkRC4u/vGWHNkIK02UcFh7aAeHJj4W3ImJpMYnA5CHy0OdExA0PtZk+8WPgzYhYWEwiEs+vt9QmIm7YBIP3/OwXI5YWkwjMHpLnMb8nETc8+kCd+DHwZkQsLCYRXVU6Zo/4AF7SthkRC9NAhPd6N+7kEQZ+xIi7kW1jxMpiEpH0btzp1X8EL2nbjIiFaSSi6N24s0d8AC/52YyIhWkkoq2uFP4QXvKzGREL03iWxunVuPPJ2DW85mcvIlamkYi4ulLYwiaFtI18Ymb5mWJV9tiOilXJOeJ2ZC6t5aFVpfJLeM7D81quplpVvvUw4BphgVetKteuIyzRu5DS0KpyOiNH3ISRPQ6xqlr1wzw0lxhERKwqNJ21Ug3CRR67V7Eqf56QaEl0ZFSrKujCKNwuBU/lINWqitpEZ9kSNZiGVFVsZ8V45Flpf0pV8ag4cYpAlESlE5WqSnrsgGoxMVPLS7WqvBofeCpFBNGGVFUWiYcU8GQ5ZKNV5fRrqaXum8g9iVaV6skk0czxXpSUVKxqPGblC8xSaiRiVSpvw3reUHqj5hDFqhJY6AOnGE04xarGrJc6D6526swkEasqoxrS8XbjkEaNrIsuagmg5yJzpmCXilUNF4j00dxjPtWqkr7sGI4YMg8VDrmqEuPAO7f6/SVX5eXxI+8sir2kU6+qVX1OiuDw1NeQq1JFFRZnwh07d4tFrsr38XEqleCdFJWrcr13fUyuf7kiEl8qV6XlfLGC/R5Fy0v1qnRXPnKZqLH49dSrcto+pT9qpJbX0KuKaeAtl0otr6FXJepCLBdM3Mu+5Kq0MAjza7RLLa+hViV30BDPHc5WLrUq+VL4CyuqqM0lYlV4/VqAJ8I7vJ5jiFVlPRlELY7qqCE1xKqqTvDRSTO6mgQQUauKahQrfREbub8iclXB6bsCzqhN9QCVq0pVa1jwQrnfkE65qn4V+eBZc6+nXFVVX+DRyBDImapVVZGdIczyyRYvtaqkBSMU1PCFGlxDrUokioij0/TSL7WqfpbURHQDHy61KqUh84BUL+PWQLCanLafD0rV89pqFaw62ykUAqODDcEqzHMEByexulAvwap+4nhMvnLVq0rhrHeJPVeKfJ16VX3gHb/lculVJd3xdzyeIbJaQ69KRFSIoxE3RL4oWOXPMpLQ8WXtEqxKYeCt+lr9KVgVnbaP+IXkVES+RLBqBJ4CzqNLFPlSwaqkLlsy6Kwg9xSsqu3Ee6gqIiaCVXrHNboMj/rm0X5JPY526oGHFxExVazK9cQRSMKpV1XUBwt7awyhn3pVcex/gxL+aTj1qlQyjbvBuXhRC1O9qqrRmvXJyYta2NCrigOuwYlYmMpV9bGFGEBaF7EwkatKtE+3Fl2spyoYwkHTpaHKSF9E/WvIVelLqYgvGcEpn3JV6dy5BDHwzaFW1bSfV7Gcx99FrorOPmAkBJQEE7kqvCfd3+vSJ4daFVKLMNAW2bbAHNJ1/d9RpA+BbKhVRX15DZGlsJBgqFU1HRwa+mOiluApV6VsNbmXlyJhqlcVdee5sVNXaoSpXpUe0QXaQDNeuupVZX3qlpgoUCBM9arGuE6FKb7deOpVnds36HlUBxO5qtDGUyMIFhn6Ra4qdrlgnnDHsIzerHpVSVnlZ9D7qVogelWiiZc6sorcKRimclVVvRPfk6jJFYdc1XAfwL3L0KxyVUFHuc5S58JwPOSq3Lm07qnyFFSu6hxyOzOWDNZOyaqxrIg45RMVw4ZklYaRTn+JVAEbklWiO0S4yC1UKlmlx/O5NBngeRj3VLLKaSgFXDsToyFZldX95DX1yqVtkawaftZ5TLBTHEwlq7LAXO3zrlEcTCSruN414EIX8UOyipFEl8QQ8HiwQBSrfNEPI6hg1EQEU8UqVdrishETBua0qlg1Po1QE0RAbyhWiXgZYSp+6UUBolilcEGKAKf0Q7GqjAUIxJMIJ61DsSpn/TTSgt74iypWtbGA1Y/I8bCoYhVVNwYMH6EUmCpWaZqRkbJmJActnIpV+mkfWHch4l6qWaUfRszwQWsaRLFKeEKsR0wRaS+vilV+TIkcO41OJ07JKvQAeO5Q1e/nLWQybUCn5SVORrEKTnFwWGJ90VCs0knGPfdQaar0IfoVelUfCKN8JHqElpeaKV8+lE/CX3y1+Mr623/wO75Or0pyr5JFcHSlVZW+u1YV5i5wI8xZnrt/lXcyvb8Y08APIkwra62q6wOxxMdX/c3yHIXJVePQ8DDAwJ8iRFR47DVgdompBSLdD2gu/YSmIgBH/26D0sCfYyqGJ5l/wlzkFE9Tw1pzqchKvngGdbF/rPDST8fV1/n1t1KF6SnMLnE8/w8LL30XYyt9wXs3GXvDn2ZspV8wdQk8C78SXvouBnNWhDY5R39YbPBPMxkEYuxnapl5Z8BKe+n72MypMRKGMtt8459nM9I0ZGdU5G63ElH5YSWizMQCiZvXNn60EtE3svdtS7deLpj7+qVbzBLkusLneZVMZWZe3jctVt/wkBwS8TPTiIWvpds9iFhYDCKoIc0VkWeINfCQHNIM2vBj4L2IWFlMIoJe3hcnIi54SA6JJq5pxMKbEbGwmEQkvbxv2tW44VFFKCtAphELb0bEwmISUfXyvjARccFDckjWTSw/Bt6MiIXFJKLr5X11IuKCr8uiy5OgB74ZFQubkb07r9f3PaOEgVVxqLgwMWTgrYhYWkwiol7f1yYiLvjUEJGNPkuQxTejYmEzqSiHXOAXJiou+JRI6DNDN7wZEQuLSUTTC/xmn7jg8xibLOVagiy+GRULm0EF5x784BQnbvhUG+oTQwbei4iVxSQi6hV+k0/c8ENr6EHQSoNoDyoWNpOKrNf4zT5xwedxV9mOsBRZfDMqFjaTiio3+fnZKy74oTVkKVpqEO1BxcJmLn06vcxv8oobPrWGpB7AUmTxvahY2Uwqgl7nN3nFDZ8jpuzTWoosvhkVC5u/yAL24h5EA58HoWXb50GRwTejYmGz7g24FNIkGm3giYo1RZtRsbCZVGA+kRqr6J5UXPCZSEmVmqXI4ptRsbAZVPCqzJy46f6g4obP46+yvGopsvheVKxsJhWYUWReFThRccGn2pCGTUORxTejYmEzqcCUouTcZ6+44IfekKVoqUO0BxULm0kFy3Z9nCRXDPxQkLAULZUl9qBiYTOo0CJUP8lHG/hUHZKSRUuRxfeiYmUzqZD6jz7prhj46RWGon29YmUzqeClna3G2Ssu+DkdMxTtOx1b2UwqWEKWcpi94oKfCzeGon0XblY2gwreB+3cdLTvRs+csk/8GHgvGhb2kgWWthXXp5Tihs9wICv7hh4Lb0bEwmQygekErGqzQ1zwucchG4APhgy+GRULm0kFphO+llInKi54aO/oSt7diIU3I2JhMYnAZCJEVn4+ibjgYXHzS37ahkQsLAYRBVOJ0MMkf2rgc7I1wsTVygPfi4qVzaQi8kpdN+0BXajdHDdNbLtnvrKXLBSePmtuSiRu+MnDip3NaFgYTB7ktFWexKINPASIpLDfNGLhzYhYWAwiKiYQvHN7GjNu+BQgetJj0L1oWNlLGnhYRI76PGm44aGfUJ7sWHgzIhYWkwhMHUrsaRoxbnjID2nHuBux8GZELCwmEZV32Nd5omHgcUh84sfCmxGxsBhENHe4mvOkFG3hR9e4G9m2a6wsJhHhQJtx3gg08JAfakt+yn5dY2UxieA99NW1afJp4NEH+sSPgTcjYmExiSgixzCvW34EL2nbjIiFaSSis40yDRo3OnrARM6NbkbCe2t5bsjr3adTnPwAXjK2Fw0ry8hD1KtPJ+//CF7SsxkRC9NIRNGrT6cw+RG85GczIham6Yk6ufl0Khv5CF7ysxkRC9N4tsjpvafPDMLCNqc0jXxiTvmZekT28I4cm9Lr6xvlCmrREN/ZmhzJAIzMUO4T7lxfKTJZ4JGVUAsVJTJMwDy76qfbkWLmGWxRW3G160kfHoaMmIFTMSDFlvQANaUBvHe9v8gKnrdrBXxkpT8PYY9nko3CTCGiQlkZnqpPLUpqxrJ4lis1XnrTqEjj9Ss79R5ikDtR8IQVNkiG53hCz1NJiRtOrgXvz1pz38BgFTkLNJN1wVV2sMFRFIWX0HpJZ0l26rVLoYzc2pZEe4CHQB1esAuye1G9jzEPvOTCP6ZqEO+fSPo8+cA7603FikprsdeBN5+jbI5Q9yHXfNY/c8YyCnH4aXeWA/sYqpRtUYghxuAHXiloUlQdqJVaFO8H0hrRbEriMC2dtbQJbltVfSgn7+UYffHh4LKz3LyFl0WhxjTwiqehllOksIhLugolS5GqDoSO0vX+T6I9FFF4Imvdjympz3gVSSSeRDTIO22ESzhRFJ4o09NqSX7gLQiDeE38Syc327CML/HtetESShGNnXgnm0lUgPDGddrj0VdBUFWJId/7KBFliazjUWI0UjvlbAZcfc8soqXARab21EsL5lptou8kwkZhbG2KxEwRHafM8TJEZSxg+o1mRK+piQTCVYXWo+omUXsgq+ZOodJLD6q/RPGJpncysAyJZXp8TCo9pZKClic1ijTR26m5kxMesw0ccVH0lwILP1PWMwToBTxo1IfYDPq3yMeUyF5WRX8Jn/foYeogwNGRpfnCv/RZiz5EA0oEmPBNCAxFTp0Sby2LABO1vgqVZAQPdGrvxoYw/o+IO7B4RDILVbPBTKy0s6gEzDFC8HF6o8CD4Okg+bJlhHZ6d+oiPBmCF0zFJs8NReeVTsZVOHXR4zWtBhZnaKVGDsKOZ0QpxStcud3Usl4xRb0mUU5iNQNV8Bmp8Z4bqwT18x19r4rwE95z7T63OPBO1YOm1Q/eVa2VYR+reBMqMZQyXq98ngNDTCr8lCgJF5N+PlBHZLwsuHqWSEq49ajCT4kOHpw4Pjwp1aDCT1QwoiCQ4HRUr8JPVFqqruSB442J8JOMR4gP2g5Vo/op8IRo16Nu3xd6JCZJEjUpcB3PPVy4nQg88UU41+SagJKo9lTHyR30var9FjCmGCLwFKlSV4bvU2OlFBF4wvvPiMIalIGjG0SW1UTRugsirwV/OpxLKvBE6Smv3T8jdhUR3qOPhNySHhpBTEGUFL0mT6/OSeszGFOynK/qtA8uWweM906dHwqcFw4FAjP1AVXh1ZkSRNU1KxI7KpcSMPrhO7LTT1eeWGr4Ik4mKKB1bvcxJmBYQiOu0XUFRhdAX0oqa4QRV70moyd19rXO809IRXTh3/Ei1YyhCo8NG7WjFVn27L5QeQhDqR4b424JBiF4P2HYFHXeXxC0POufCUceec4Dzt31JKpGGARdOLcafHWhyem8dp424HJ76hTy5Uge+XYEpvIMMrNEE5kD6QAImKf6KNEEDkLq40FYDcGw0XjG/gxipVDbAQMLBYli5Tnvly5xozmKDsAsCiL2OGA8RgWVVJBDr9A+XRDxUqQoEOJ1rqLwoOvD6MuU7KKMWpSLvBVG+lMxwGUqPrmuW9KVqkUMX5QvwrsNZaANQz28kR+O8G95kArn5fGk8BKXa9o5K3pqrdygIFpHX+DJ11wxNPAxeKZdLae9yBgRs0X7zemhN67cucpoyS4URBBU0ZL1Yl683NzPDyOCRb5UkSNqGFj1oTvLvKk0ye4MIsecHx0dr1T1iPAVows3DjZVroJmRIEtYiLvBUFfjbKWyrFFRxfkmp6lCyr3U7JTrnl5RkrOSZZcWThZB8yhLss6LTy1q4s0OX5fuq5RIefS4MOLJwo1/JgIda+ZBHwLcUH0bpiW+TFMoPuAG8fjyaAvUaBQYGQvGAt0T75hPFVjuobioSTkRfaKUxzfQ9MqnwZ2Nbiwn1BDTFtGmNae25lc9qyCRsiSvPgeZw2BFbNEEeei+K+dSwSOE6ra9AH8FQpDHyiAfCRVg5aX4iBfPhS9oSbR16qMrL/9B7/j6xSGkFohcfCcTlCIZakyVL67ylBl5H9/UqWh4/j5JsMLfBBhWlgrDN0f4L9vmlx+ILyBtJ6SsW66MsfAnyK703igtfBSHaSz9YcUhn5CUzFgYvpWJoUhA3+OqVmiP3y18WrKp6l+rTBUZVWeIlwiZvxjFYZ+Oq6+xqe/lSikr9yKGP/+E32h72IqUhPMjDApsKbe4KeZSllSTLiR6SYflupC38XcxvoBJn/W3Bv8NHO504IcDWM3x8eVsNB3Mdd76gQiw3rYa9BPM5gLVo7XA0XObN/JCn0/izlFwwwT0y9r8Y1+nsVRlqYa/j9S2dPi9v0t5hXRlBd+Wnyjn2cxwnzzVAuvnHCoxR+E90s6qnIlg7rGo2P8WOmob+TuW1fZ3beo/leKJHPp5FmwUKmRzOv0niVNBj41oiQzvhux8LXKvgcRC4tJBNXo391CaOBTI8pP/Bh4MyIWFoOI6vQ6vUl+84ZVI0onsaYRC+9FxMpiEhH0Oj0/EXHBo9BTlqNMIxbejIiFxSQi6XV6U4y44aERJedxLT8G3oyIhcUkouh1etOW5A0/rm82rayvdd6DioXNpKLrhXplouKCh0aUCnVbiiy+GRULm0FF86ubCA38EH+xFC1FYbagYmUzqYh6qd4UKW741LaQ1cEHRQbfjIqFzaSi6LV6U6y44fO0YZ4psvhmVCxsJhWNf5b87BUXPHSiNLUyDBl4MyIWFoMIbsDwYr3JJ274GSksQdtGipXNpCLq1XqTT9zwOJc80kxDkcU3o2JhM6nIerne7BUX/JCJshQt5aP2oGJhM6moq+v1DHzKRMnuvqXI4ptRsbCZVHS9YG/2igs+h0yp07AUWXwzKhY2c7cjrG4mNPB5YH1QYSgy+FZULG3WjZ/cKq8Re1JxwafJst+7oKhuNytd2kwqCmtvSp+94oLPREpOKFuKLL4ZFQubSUVnFV2aDksY+Dyh/I4ii29GxcJmUOExpXA5TMdJDHzKRJU6UWTxvahY2UwqMKXgvRuTV9zwKRMllT+WIotvRsXCZlLBgubS4uwVF3xJfUwMGXgzIhYWkwheJMuGJyIueIhEddlwswRZfDMqFjaDisDSw+mGrj9Y+CESZSlaikdtQcXKZlLBesHkp2szDHyKREnZlKXI4ptRsbCZVLDer7MY8knFBY/sIUrlnKXI4ptRsbCZVLDcJtcye8UFnzmlFFtaiiy+GRULm0kFL1WUoylPKi74GSsMRRvHioXNoAJuHnLlmYoHFTc89jqynCt4UGTwvahY2UwqWFobWWH6pOKCh0SSiLOaRiy8GRELi0lE4SjQJ6EcAz+JWPKzGRELi0kEphP4bbre08DnhEs2Ak0rD3wzKhY2gwqehsOke9ogNLDdJjeNbLt7vrSYRMSjthJmHk5U7dVTg+/YUXgzGt7bSxbkON1clm7gUyzqQY4BNyNhYS5ZaEfstU06OQYeUlFSVmUasfBmRCwsBhGZp3timc6tW1j1LtqTHoPuRcPKXtLAS8b7TMIAT5Uo/2TGwpuR8M5aUpAZ6Pyk7G3hcZ4/WW4suBkJC3tJQ+U5sl6nyGDgoRCVJnYMvBkRC4tJROdRdR7KexJxww8ilvxsRsTCYh58wXwBE8dpA9DCj45xN7Jt11hZTCKS6mZMGz0fwUvaNiNiYRqJKHpf7TReGNh2DdPItl1jZTGJ6Hpf7UzEB/CSts2IWJgGIqrX+2qfBq/RNTt70bCwjCxEvax2mmJ9BK/Y2YyGhWXkoehVtVMO8RG8pGczIhamkYi2uuLXwnboNI184tD5mdJR9vAOL+F1lBrnmZV0hBRSEeHh3loTpRseTknO+xypv0BFGDm3XxEHc+7czMMY2WtsXc/0NDwWptvtVQMVcroIVUgZf47cDmaVla96zh+z8SOXyvPzogeTeFZK8HbUUFwKctgs9haK1sD3o7VUgx53q9mrNBVLf12KFKQSeR387M+S4BIC8xhWf7qYYtHPY1h3ot3DmtBcRgEx5sXNpzTUl1pwWnnfKBQCMovgLacsogHEO6gJqh7l8KNWomZMtFujaBVh5NXCY6N6RfGstEMrJfmzQrUeveesX1p9r10/zpt2UquKU3dLnxFxN6fgizQON8py0I14jTEPJauGRpQBqpn0EIZiVU6+KsMdT5ZFBoMVXjAbDvHSekB8NVj1mCNGfL3c24HmqCZWKEAF5wgwpCueD27yty54wwts2nw5vIOrBNF8gh94NRZ4aVIhQjxQg0is7ZVXLDk5awfvBIfxrNXDaBtZ0009jwB6tH3un0b+MSstuu+jmrEfGV2gS4lrK27sqzlMdxPVekSYCq3rtV4saEq1e66YkmO5G29U9+BJKTslMmI+jHVFBx/N2VM8iopIYE7Ib45yVLEl3cJM+OIeBG80kaZQxQnN47dRHIFXm3l+IUQYkoJTHD3JgZMuekQBhqcwSgjQqJxaD/je5PXoBx4AsSb3ovJouffYT7ykHEXeyfMFqRIPXJKHBYqoR3meJukiC8aNeeR2UVSi0GvxyFk38ik9hWfT53SsrtfPU0PNOZF3otoUzNX9S093d5RxQjQrvjitlsIfwze5g0d+QFQO534nxcO6ykq1FMf3UkQJDiyX6PBoaXFjJww9q/KuOsUTwl0ZeKFEvm4tl1q9CCThvzJ796LXhLCAwBTrwBuFZLy+F/yhvi/8EjF2sFRD/lRchrickxYYbsLFo3PDrroWqMsEBnODLefuFWIXDNDal8Q6fMIcIukDry5+ocfMuYGB10wVJwr+eEqWDBj9lnEMfYzeW3SRHx3OeQr6AHaw81r7d40aVzwmlUtStR70aVjRqewEGAGgRW2bS2Ds8OjtCLlqDQNnJXVEfQ+D84gulSvVmxAyEl67aK40BE4fC/2Na8uI4C0NuGI8gts2hurofBsr0a0miuAgODZ4yFiS5H53ZC7dMGahX/ZzpZJ3oKOvcGhJogtIuIqwGR6Lgkq96lEwrufhhXIjMIMbjIJdF7+pY8fgmCnbE53O+z1YiJRRQjSBZwR97xn+n5tTHWmEzCAqg/gmBPJCsS0+UcoqZMPJMd6OnFaB36F7q5MU9LQaWAyRqNDnRUqM0wUMHJSwSiI3lTXCMH126BIqcMORQ2yhun3yotYTqBfW1EWqaBMWHiCjOk1NWk9TEzX5ZKed41kdH6YJUXR2AtWXROnIZiuBmodVI8Ia/gpxmg/EIz5SOUHLC12JLx9opVDK5uvEKdbf+wPtf50oDQcYdIWM10/tjqUoTXvN58IT/zS2Qp0APAF7f/TvFT/+6Xd/+euff/d//pW/XAfC3/4/12SyLgplbmRzdHJlYW0KZW5kb2JqCjExIDAgb2JqCjE0NDE4CmVuZG9iagoxNiAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDExMiA+PgpzdHJlYW0KeJw1jMsNxEAIQ+9ThUvgz1BPVnvK9n9dBiVCwg9sOSJBMxEbyYEPr3P+lqTO416a/tAJUasHj1omhLOJcz9UNRbNFnJIWdeZ7aFTp7CSQ05wF6gqglpFEMa4lrLCy6HUCSvINjhZO2/jvb5/Qwoj6AplbmRzdHJlYW0KZW5kb2JqCjE3IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMjUwID4+CnN0cmVhbQp4nD1QOXIEQQjL5xV6Ajfd71mXo93/pxa47GBGNFA6aDMIuvmrumgtfOmz78/ANN6PW/xV/bsUpkRDJFEKryeuoW4hrVF9kFmoDE7yBoo68+VRVCjSjZPKizi20mG16LWTqYRMfBm3KgWmPRNvaCfZFBq0LUT10SH3SQpzPaiQ5J62KqgWx2FCwwIdhZgUcDoVOHeFvc39frQNJ3gAt5xiYm8n5OIchBfueAm6U6YPzlQvUkhOLooyq2Yj6VAPMZnDdkJvVo5s2iLfYq1/VuFzOUrMJX1S1EYQ7o3O5HVEMP9eI6havNzkKJ+gtvjaEFP9x3k/3z9SFVx9CmVuZHN0cmVhbQplbmRvYmoKMTggMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCA1NyA+PgpzdHJlYW0KeJwzNTVTMFAwNwYSpkaGCuaGZgophlxgfi6IAgnkcBmaWSCxLEyADJBqOMMASIP15HClAQB+bw+xCmVuZHN0cmVhbQplbmRvYmoKMTkgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCA0MzcgPj4Kc3RyZWFtCnicNZJJciUxCET3dQou4AgxaDrP7/DKff9tv6TciyqQEJCZMOeyYbnsy92ml80c9sefGmWr7O+T2xXOGuYYHzbt88QZ9jUtandieLb9PD7fUu5hYSeMcp9nUvuozE39PTeXclZY8fhM+lqMxfWibGyjQVTZvRZTr923xbrkHot9OzWOEpxTXJ4PMm+Rhk8eHQCSY9OStuTn5YuOyKPza89rZ/yPHG7OBRp5O63iKDKHld6iQ02hiLaoAcm+GbIIBfjKxrbwAoaFdnc285z3lUTS/jycCowqRhAetSSZj2OFfp5pc0j8zXyEMAZqxstT04pWTzniJi/RUC8SuTXTzyMMk5EWnOvyTfytSRZ1Sxg2rKhYh6gLex3eiBEqtwqy2dXwAj1/2vOcxJhYdekljAVXwRsMaTSG0SgCSxY8HHpDotjvqr3SB+RZuvXuloYWCBnajtAaqG1I0KutQ1Bgx7gtNTcjzTUAiHupSe8koH0dgBKBeNvsHHmqwlJdmLC8p8XfDUnznEJQ1jsYFNH5HkUThff9XQz2LreKYY+a9zwuECAkYs4+NcF3l36p/jzf/wAZT6ZTCmVuZHN0cmVhbQplbmRvYmoKMjAgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAyNTEgPj4Kc3RyZWFtCnicTZFLbsRACET3fQouMBL/bs7j0ayc+29T4ImUhUWJooGHI5KYMuglQiFBW5LessQ38j8LDtPdoY17Sdg/5dmmFFNwktqmMCatmHgt0ydjgahGdhJDBI6Lk9chN3yHybGHowrOhmPofYqcA1VFthVOMJTVrGnsEzX7TSvZ6FRGgir3opwxaCCYGzqAWjLxWqo1Sg4+p8YF4/XlBpODJw0XGMWoCpRhS9nQeroWmx0DdvYwPf7MNNUWFrjZBjJW+iL3KMApdqonavaZWvWpusLmDbCBgV4BKEdW+zwHQ85EAABxMvgZXSHt8KyFnrabKefdH8q1Pr/wIlwGCmVuZHN0cmVhbQplbmRvYmoKMjEgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAyNDYgPj4Kc3RyZWFtCnicNVFJcgQxCLv7FfpAqgzCxn5Pp3JK/n+NYGYOXcLGaKHXnJjgxZcZ4hoWJ75txAzYnfgbdWl58TviqLKLWIl0hJ0afAbVXSCtSTxX4zN8siuLDXOYjuvofk/VUbOWre0iFM0FjQixbsdOlIdnnIUogmplwlb5LBo7kpUdl+NyXcKFYuIrB/V+meabtjQiyr6+t/84LrXd6gkuKibFS71mRk9yCWnNKx4xcGpSUTxvo6IyujI5i/AOFlZeTCemOq45f6Hv7qiqFdcLq2VsfbOT3YXcHWzXQqNA8mqqILV+gUiu1/Vhb4fSrlV/ft0zfv4BzmpYzQplbmRzdHJlYW0KZW5kb2JqCjIyIDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMjU3ID4+CnN0cmVhbQp4nDVQMZIDMQjr/Qo+kBmDANvvSeaqzf/bE3hSSYtXICkiZQpcXqri22VpykeHT+P825ghz0AeUReY9q8Wq/E9TKOZrkWFOsTAsc4tHrJVOE8T1c0pXzV23bMZDXE4JoFOcRNwb9LQqTGV7tw8Ib5cFPw+WcuXSnChURSY3IJGumGEYlCToBFQE1ovSAY8S7AraJ1IGuzrZBX7Gb8CLpuF3cMz1KK9fpvpYSBspiVmMlxd0OMV1owR2BDnWQVhehGAV1KQrGDuPsu6cMT5rns1WpSiGIxl8A8weGn8ahBdCWjLWaTlRQa3y5Qab1sufm3RKBZfaBz09ovyHn//45VeggplbmRzdHJlYW0KZW5kb2JqCjIzIDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMjU1ID4+CnN0cmVhbQp4nDVQyW0EMQz7uwo2EECnZdezQV6b/r+hNBuMByJskZSYuSHwwpcqUhPpgm9dYQrdhd+ValB2vVfcgoohSrAV4Qae1/Lr4BcxInae+lomZ5AGeRQRRx7e5yWONtUab8tsmaKGga+hMh0x7RoHKRsmNdNZ3alk9AtRSE5HBLnkvziqU8VmI4891XZzBmXwJmAcbCqt6WM16L2UmkoXJVOdfyXn2bNSoDhKTAK96u5NXXeDjmBfOHM73e3nPoFJB8DZPqHSq7OTy3jDHsR49cDTp9sP5ya7MXU67aC+PZnYkU825ve5YQJBd63DvcchGe3lHk4l7vvv+Fo/f0kXXLoKZW5kc3RyZWFtCmVuZG9iagoyNCAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDQxNiA+PgpzdHJlYW0KeJw9UktuBTEI288puECl8E/OM1V3vf+2NjOv0suDCQRsQ2bJklD5UpVUk9Yj33ppt/je8ntpIL5UVF3ClpyUiJT7QkbUEfzijEkPXNPZJbul7IhaShXTtVwadQx12MQ6x96Xe4/Hfr3QzQpvWCvwX7YltqNoPNaNEXhxEOkYFJH9wgo/gzOIF/38ZYKI8Qv5GeKpeIvIIEh0NSCmABbnsYvV6GmwF5gbWjCJtZYLEEeNcNaPvS++oqexEVd8TXrZvOZ90NhqFoGTYIRmiKKGG1lDTc8UdQfcEv0noEmRm0OhBwjaIAohldWTj03RwEkDNwbLMRklc8Ci574nw2u9b3zbVPEDMJTsfGQeD0Pwje04iKBvQdhnaOV4s3ADGSgBLRCg89wACTOIrZR9iDbxNeir5cMHEX80+R1P0U2dcRyMQ2extLiEC5w3xbQFyTg8mxWDkkvAiHxhSPfQcQjcPgR0rZncxlY+omi9Iq3ZNnoAzgzbeMqzKLwnZcN8FCfZJMaiOYWEp9hFZmjrSAK4mLQNEVDD2nwo3tfPH4ihpDYKZW5kc3RyZWFtCmVuZG9iagoyNSAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDI0NiA+PgpzdHJlYW0KeJxFUTtuxTAM230KXqCA9bV9nhSdXu+/lkwCdEjE2BJJMVWNiXR8maGssWbj2wZPbG/8DouEncJnWE5Y6WkYO20bTuIazpFl8Gj0hBOyXCMsBCIPViPWgc3N8+RbXOlBDr+rR+lGaBfUEZ6IzfEKcZXzi48V4iyKzLtSnE7vEzqKQ3cnqKUbU0/TvWbz0QyXg1qI2FrJn4U/I0n+j9pdt6R9UW1kTCKfhtSW2chVcMqpymLdSOaTprPYaQoimVJ03/HGG7On1hKyxX4qGZWymNWdBLMzuiSHfowyVX2yFjIqcMY4IyKuynxTLAvvv7vGzx8eSlj2CmVuZHN0cmVhbQplbmRvYmoKMjYgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCA5MCA+PgpzdHJlYW0KeJxNjUESwCAIA+++gicYKFL+0+nJ/v9akXH0QnYSIKqNKkHG0HqTodGDIhzGNxUG6gUHsPIAEZ/rvVzAQZnGs015GummGj9mT2psZ6OaDs99FfGqfH8x2SEpCmVuZHN0cmVhbQplbmRvYmoKMjcgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCA2NyA+PgpzdHJlYW0KeJwzMjJSMFAwMwMShqYmCuaGZgophlxAvpmhqUIuiAESyuGCSUJYIMkcmCowwwCi2NTQEqoEwTKAqcjhSgMAlXoVTAplbmRzdHJlYW0KZW5kb2JqCjI4IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggNDggPj4Kc3RyZWFtCnicMzIyUjBQMDMBEoamRgrmhmYKKYZcYH4uiAIJ5HDBpCAsAyANVpHDlQYAgA4MJQplbmRzdHJlYW0KZW5kb2JqCjI5IDAgb2JqCjw8IC9CQm94IFsgLTY2NSAtMzI1IDIwMjkgMTAzOCBdIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMzUKL1N1YnR5cGUgL0Zvcm0gL1R5cGUgL1hPYmplY3QgPj4Kc3RyZWFtCnic4zI1slAwNjRSyOUyNQMzcsAMSxMQAySHYIEl0wDuxgm1CmVuZHN0cmVhbQplbmRvYmoKMzAgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAxODEgPj4Kc3RyZWFtCnicTVBBEgIxCLv3FTyhEOjCe3Q86f+vBhwdD9sEUtKwEUe2nD48Lwlsueua+tUQWvJc6vHHnB9ZQmKrGHLGoHvwtuD66VzsmAuqfUDFzThjdLB5zoNup1o5yUrFL3atqPLG9lYyBJlzH1Ef1Jkh20yCqh9C48vohuIsHZE1nNnal1k6m1s7QpwbUEFvluPg4WJlg7dlPKdjOsm1WGvP6KEDK6UKr0HL3rRZZ5o/+VyPN55TQ7sKZW5kc3RyZWFtCmVuZG9iagozMSAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDIzMiA+PgpzdHJlYW0KeJwtUEGSxEAIuucVfmCrWkU7/Z7Zmtv+/7pgcoLERsCqtmWZ9uNu5ccql/36xT9Rx/5EssrIEW3uadhpn8tr871beIwmdg9+rsQehkXZakO5oTXB4Rc3yCdxBqM3J8PW4vtjTj1uIjk1fWxzQTIAYdFxTDqVO3yCy1z4uWI9VRwwJnPtvGVQ5FBR57a3HVsE3p5ifjjOm2Iic7nLyk/Z3hYZ1o9VyymZgyR5QE7zrvc5HLMAwQoHg9GhCVmGTsAgG6PBUjpdGKyXPAOYVyaY3HIVUwi9UKxHo6C56crgGQ8+pb7/VM5WwgplbmRzdHJlYW0KZW5kb2JqCjMyIDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMTE0ID4+CnN0cmVhbQp4nDVOyw1DMQy6ZwpG8N/xPK/qKd3/WsdqLwZhQLgHCEzVV1ORXHjxupTwWbK98Qx6DAuFG0G0lTYLMawKz+JIWBZYAxY2peZ2P81cq9Psu3tkUl63ZSNE2yNpCHcoEWInlGPGPOs/6/xWnfX+Ai2WIl4KZW5kc3RyZWFtCmVuZG9iagozMyAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDQyID4+CnN0cmVhbQp4nDMyt1AwULA0BBKGQNLQwEAhxZALzM/lggrkcBmisEA0lEoDAH7MDBIKZW5kc3RyZWFtCmVuZG9iagozNCAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDE0NCA+PgpzdHJlYW0KeJxNjzGyAyEMQ/s9hY9gyTaw58mfX23u30aGFClAAs2TxxFhbqN0RU6rcPvDtd/vlsJtz4XMH5fp7YbcHIZFK3ejToH2uggVMY0xdiHrqJJ1XEDK70hvpn+S3ctbvUHjDOktmltFx3FESWNPTDaNJQZuEBPiMabFzE5KLmkoJb62cmInvflzdn2u/w/DNDGPCmVuZHN0cmVhbQplbmRvYmoKMzUgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCA0MDggPj4Kc3RyZWFtCnicLZM5cgNBCEXzOQUXUFWz9HYeuRzZ90/9PnKggaGn+QtojmHD0u3lbrXcZg778oeKz2m/j/sxX8d+Ho8wz+S3zAe/eewcez9+hu1h4WE0iNnh/cTtJLm2rmWFnUk5qfmgvonxHyt1omyl5QJoH65M8zt0IthLZaTFOGBMi9CJXxBFqBbV0R2D++/nUthle1vQYxUixWqCmGG0TpooHJVJapTRoWKKdpXIbpky7SyrI9pldUuwuDJ5kxcT3b4G8bYZdAmwx20vRU4RP/YnS76fAR9E666EC5mTu8GBCVXBQotOYlJ0KTALF/Nj41xYl8wlMTyvHBb50YZX9jfYVUgKTCimFZUd4TKiM9+qaNb0zx4mzwopoxsaFPN6n5Dt2zuQTNQLK1cPoRiNzJ+3VfnG1tztBt9mthspV8TV5aCeoZGKF57liZ4XmtmtYA2kPQrm6IrYPSTujN176ic+ccrBzqSbtztb/tI02jMoXCiA0asn8Lj2En703ovVq7dD01MmjXTSxlFln2AJDbn8+WO8n+8/heOYmQplbmRzdHJlYW0KZW5kb2JqCjM2IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMTM4ID4+CnN0cmVhbQp4nDWPSxLDIAxD95xCR/AX4/Ok0xW9/7YimWxAlphnkTkhiOKRqigpfHRwnmb4HXGsPd7wUdMXVcxErkZoIy3glYgIXMNd4DNgnbClsFJoFxNLh3rBwkDTCBLaejfYvBfYSLOhJOoSmByiCR8vEl1JfojheXaxT0rDSU663usuf72/2OP7B2dLKxYKZW5kc3RyZWFtCmVuZG9iagozNyAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDM1MyA+PgpzdHJlYW0KeJw9UjtyRDEI698puEBmzB/Os5lU2fu3EThJJQYjQMLuQYe06IOZnA8lN33yY13kxvR+DElXo+/HjpBHkTZKW0kzKU7T61FXCkVGgBYk1YuvR4JvRgMVRcJOgarXwzVsJY4gT6DPHJ8XTLMOYnEy7DCoMXMYnewgk0ImRgK+2Zk5mG7QIgFO4KV7cXbLjewADTwbBdPNsKWCM7L1nEVRwctEs58jy4aOhZnggzN6igyLat9d1oBIOAj9vUZKxSL2YtmIfRRuk1USI0toHeEBXekILMfLawkbwhnLXuChMddeSNoWR969mXZSjh0wIpJ3VRxhlmxIg51/Jx2De4W+b4SzjkjeI9TGqElI54QNRSCPjpI1GgdMEkdz2FU+gDWEJ5iPkLCmQD7Txg7uCIoJMnlRZJ2cKOeeQcqXo3YvZvhbMEfGGcyqixhuv5lTW8H/HHbZLisoi/4kvp6vH1MwiTEKZW5kc3RyZWFtCmVuZG9iagozOCAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDE3ID4+CnN0cmVhbQp4nDMyt1AwgMMUQy4AGuMC8QplbmRzdHJlYW0KZW5kb2JqCjM5IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMTcwID4+CnN0cmVhbQp4nEVQOQ7DMAzb/Qp+IIBFH7Lek6JT+/+1lFMki0mQskibvlBhC8cE3eC14mWFY8ED35Ka4VPYB44Gsu3J2hPOYs4k1h2HBlvFStWYK027miEaeqprYHYsIiJPG0yR6KMqQPM3GRYism4yFSBrxi54scvMpg/7r5D7MLvvGtXR9dw6hB2xy7ojpCtFDW2pnKUcE3JYBQNUguAs5CbshOsfrm86y/sHMoY9iQplbmRzdHJlYW0KZW5kb2JqCjQwIDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMzY2ID4+CnN0cmVhbQp4nDWSSXIlMQhE93UKLuAIMUo6z3d45b7/th9U96ICSkyZCZklS8LkS01SVbZe+daHFz1X/jzqS2yp/D4aSzSVb4tqEle5Lp/HVlIm5ilF8l5tPo/TDcejZIc4n65Oj0VvVwmlT+2xtm5H2osrQZ4dp2aLT8SZ6/R3MpwM269l+IzgxS82xUDmPhFLehfIbablIHztHUvOrvFcWwRQwjEieiI0ong51NzXpnfNeOBuRokAnialU4NW1ShhWNC2OmOZ4/G+IFVn6Plfo3npgiLRXVEYbKmHCJTTHfilk3GK0iMKzNotsJbJZlSL12uzqrEAmY20IL3QNVDrvuLTpUkjSaVD9kpZ0woo5SVCNCtf61PTHifQGbGpAVlEQwxohRkL66XZu7AzkZ6+z+R6dh2y2O7IBSlz+tiMyFi+Jsxx9frp0EC4wez5zs+dpfaR9n217bur8TRhx0k2G545RS4zWqkr/+748/z8BfNwirMKZW5kc3RyZWFtCmVuZG9iago0MSAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDI2NyA+PgpzdHJlYW0KeJw1UUlywzAMu/sVeIK4i+9Jp6fk/9eCzHTGMmhzA6CIxIE2X3EMJY0feSa8js8GB+/HzgLrVGAGl3lS8HrC0GxUiDr6Qjjx9cyH3IKkQZVHeDKY0eYEvTA3WBFrZk2Psdtjhiv83sVQZWYjzrVuxCWWc/mZHm+kOUwK6QmtL3KPxffPIVFSlkrkucMtKPaSsBXC64tn9zDgqveIimpMC6UL6WWuLJIoDlSR9UqniDhEaiPnoCRNd+Ia5FyVtGBWBCcu6pCfyGmHd8JplNNzt1gizJxaO8YkV4r2uyb1irVwbg+MnbomqdF81uqh9ayV25Q2GaFdo0GSog/1hM71vv7v+f38/gErHWDYCmVuZHN0cmVhbQplbmRvYmoKNDIgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAxODkgPj4Kc3RyZWFtCnicTVDBbQAxCPtnCi9QKUAgME+rvq77f2uSq9QHMjJgA+6BiVj4EMHKBZfCl4w1m/85uAPPsHBIwmSeVl1y8HPoy0iSYY87grRoQTZkFkxRAZ9k0xCJvZCFYIM4yVZmD5cQrwO1m77LPENc/2Vq8maSbWeMnqSXZRuHHV2hC3WkFDzr7rknx4+TXifSFGFi3JNVM7vdxr9w2rYeMUuiVReKp4bCeJIwGvsZXYl3zb8/3mw2nnc+4/sX9s1EjAplbmRzdHJlYW0KZW5kb2JqCjQzIDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggOTggPj4Kc3RyZWFtCnicNY3BDcAwCAP/TOERwAktmadVX+n+3zpS+gAsA+d0hyOaWq9CxsAdxljua/KXMy08t2KcoNdSHIizg10AFVPTOy5jlpABHro4dFFNP9SmjdqcP02cQYXNHTrt+QAByBvjCmVuZHN0cmVhbQplbmRvYmoKNDQgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAyMDggPj4Kc3RyZWFtCnicNZDLcQMxDEPvqoINaIbg6kPW40xOTv/XAJJ9IlZYPQKa7uaGZT28bBRsouwHbYV1VNlfm1L84902qAKWqTkM/lzxaoj4nD1bgsxRunfMpYu+DdutV3KSkFtWDuv8QhE1l4VPRgGdcIF0Qk5Z4GFQsU7CdwPwUQHZKfU8hnSLMbmfk0SuI2wtJkuLfZdHBa8sOoMdLuZbnphiqMPbbLXG4XS1FZjtppChfpMm1G5zY0lkKaWeKjyYYt+nBclH0HRcmaE57fvWr/b7D9bFSiAKZW5kc3RyZWFtCmVuZG9iago0NSAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDI3MiA+PgpzdHJlYW0KeJw1UUtuBTEI288pfIFK/EnOM1V3vf+2JumTZgQJ2BgnsyAIw5cqUhZaN7714Y2n43eS8GaJX6IWMhvvs5jLhhJVwRg89xS0N5qdZn64rPPE93G9Nx7NqPAu1E5WQoLoTRkLRfpgRzFnpQq5WVlUV4HYhjRjJYXClhzNwVkTR/FUFqyIIc5E2WXUtw9bYpPeN5IoqnQZYa3gutbHhBE88X1MbqbJ37mrURXvyaKmY5rpDP+fq/7xbDLzPK4o99Ee9DqUAi5qzoXljKqjQE/isaY6xtz2MWYIgqchnHiHTRbUPR0ZF5NrMENSVnDljCgOuZHD3e8NTSnjo/HB8jyA0vA8W9LUFnxWeZ+fP/SWZUsKZW5kc3RyZWFtCmVuZG9iagoxNCAwIG9iago8PCAvQmFzZUZvbnQgL0FyaWFsTVQgL0NoYXJQcm9jcyAxNSAwIFIKL0VuY29kaW5nIDw8Ci9EaWZmZXJlbmNlcyBbIDMyIC9zcGFjZSA0NiAvcGVyaW9kIDQ4IC96ZXJvIC9vbmUgL3R3byAvdGhyZWUgL2ZvdXIgL2ZpdmUgL3NpeCAvc2V2ZW4KL2VpZ2h0IDY1IC9BIDY4IC9EIDc2IC9MIDk3IC9hIC9iIC9jIC9kIC9lIDEwNSAvaSAxMDggL2wgMTEwIC9uIC9vIDExNCAvcgovcyAvdCAvdSAvdiAxMjEgL3kgXQovVHlwZSAvRW5jb2RpbmcgPj4KL0ZpcnN0Q2hhciAwIC9Gb250QkJveCBbIC02NjUgLTMyNSAyMDI5IDEwMzggXSAvRm9udERlc2NyaXB0b3IgMTMgMCBSCi9Gb250TWF0cml4IFsgMC4wMDEgMCAwIDAuMDAxIDAgMCBdIC9MYXN0Q2hhciAyNTUgL05hbWUgL0FyaWFsTVQKL1N1YnR5cGUgL1R5cGUzIC9UeXBlIC9Gb250IC9XaWR0aHMgMTIgMCBSID4+CmVuZG9iagoxMyAwIG9iago8PCAvQXNjZW50IDkwNiAvQ2FwSGVpZ2h0IDcxNiAvRGVzY2VudCAtMjEyIC9GbGFncyAzMgovRm9udEJCb3ggWyAtNjY1IC0zMjUgMjAyOSAxMDM4IF0gL0ZvbnROYW1lIC9BcmlhbE1UIC9JdGFsaWNBbmdsZSAwCi9NYXhXaWR0aCAxMDE1IC9TdGVtViAwIC9UeXBlIC9Gb250RGVzY3JpcHRvciAvWEhlaWdodCA1MTkgPj4KZW5kb2JqCjEyIDAgb2JqClsgNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAKNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MCAyNzggMjc4IDM1NSA1NTYgNTU2Cjg4OSA2NjcgMTkxIDMzMyAzMzMgMzg5IDU4NCAyNzggMzMzIDI3OCAyNzggNTU2IDU1NiA1NTYgNTU2IDU1NiA1NTYgNTU2IDU1Ngo1NTYgNTU2IDI3OCAyNzggNTg0IDU4NCA1ODQgNTU2IDEwMTUgNjY3IDY2NyA3MjIgNzIyIDY2NyA2MTEgNzc4IDcyMiAyNzgKNTAwIDY2NyA1NTYgODMzIDcyMiA3NzggNjY3IDc3OCA3MjIgNjY3IDYxMSA3MjIgNjY3IDk0NCA2NjcgNjY3IDYxMSAyNzggMjc4CjI3OCA0NjkgNTU2IDMzMyA1NTYgNTU2IDUwMCA1NTYgNTU2IDI3OCA1NTYgNTU2IDIyMiAyMjIgNTAwIDIyMiA4MzMgNTU2IDU1Ngo1NTYgNTU2IDMzMyA1MDAgMjc4IDU1NiA1MDAgNzIyIDUwMCA1MDAgNTAwIDMzNCAyNjAgMzM0IDU4NCA3NTAgNTU2IDc1MCAyMjIKNTU2IDMzMyAxMDAwIDU1NiA1NTYgMzMzIDEwMDAgNjY3IDMzMyAxMDAwIDc1MCA2MTEgNzUwIDc1MCAyMjIgMjIyIDMzMyAzMzMKMzUwIDU1NiAxMDAwIDMzMyAxMDAwIDUwMCAzMzMgOTQ0IDc1MCA1MDAgNjY3IDI3OCAzMzMgNTU2IDU1NiA1NTYgNTU2IDI2MAo1NTYgMzMzIDczNyAzNzAgNTU2IDU4NCAzMzMgNzM3IDU1MiA0MDAgNTQ5IDMzMyAzMzMgMzMzIDU3NiA1MzcgMjc4IDMzMyAzMzMKMzY1IDU1NiA4MzQgODM0IDgzNCA2MTEgNjY3IDY2NyA2NjcgNjY3IDY2NyA2NjcgMTAwMCA3MjIgNjY3IDY2NyA2NjcgNjY3CjI3OCAyNzggMjc4IDI3OCA3MjIgNzIyIDc3OCA3NzggNzc4IDc3OCA3NzggNTg0IDc3OCA3MjIgNzIyIDcyMiA3MjIgNjY3IDY2Nwo2MTEgNTU2IDU1NiA1NTYgNTU2IDU1NiA1NTYgODg5IDUwMCA1NTYgNTU2IDU1NiA1NTYgMjc4IDI3OCAyNzggMjc4IDU1NiA1NTYKNTU2IDU1NiA1NTYgNTU2IDU1NiA1NDkgNjExIDU1NiA1NTYgNTU2IDU1NiA1MDAgNTU2IDUwMCBdCmVuZG9iagoxNSAwIG9iago8PCAvQSAxNiAwIFIgL0QgMTcgMCBSIC9MIDE4IDAgUiAvYSAxOSAwIFIgL2IgMjAgMCBSIC9jIDIxIDAgUiAvZCAyMiAwIFIKL2UgMjMgMCBSIC9laWdodCAyNCAwIFIgL2ZpdmUgMjUgMCBSIC9mb3VyIDI2IDAgUiAvaSAyNyAwIFIgL2wgMjggMCBSCi9uIDMwIDAgUiAvbyAzMSAwIFIgL29uZSAzMiAwIFIgL3BlcmlvZCAzMyAwIFIgL3IgMzQgMCBSIC9zIDM1IDAgUgovc2V2ZW4gMzYgMCBSIC9zaXggMzcgMCBSIC9zcGFjZSAzOCAwIFIgL3QgMzkgMCBSIC90aHJlZSA0MCAwIFIgL3R3byA0MSAwIFIKL3UgNDIgMCBSIC92IDQzIDAgUiAveSA0NCAwIFIgL3plcm8gNDUgMCBSID4+CmVuZG9iagozIDAgb2JqCjw8IC9GMSAxNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0ExIDw8IC9DQSAwIC9UeXBlIC9FeHRHU3RhdGUgL2NhIDEgPj4KL0EyIDw8IC9DQSAxIC9UeXBlIC9FeHRHU3RhdGUgL2NhIDEgPj4KL0EzIDw8IC9DQSAxIC9UeXBlIC9FeHRHU3RhdGUgL2NhIDAuNSA+PiA+PgplbmRvYmoKNSAwIG9iago8PCA+PgplbmRvYmoKNiAwIG9iago8PCA+PgplbmRvYmoKNyAwIG9iago8PCAvRjEtQXJpYWwtbWludXMgMjkgMCBSID4+CmVuZG9iagoyIDAgb2JqCjw8IC9Db3VudCAxIC9LaWRzIFsgMTAgMCBSIF0gL1R5cGUgL1BhZ2VzID4+CmVuZG9iago0NiAwIG9iago8PCAvQ3JlYXRpb25EYXRlIChEOjIwMjIwOTAxMTk1NzI1KzAyJzAwJykKL0NyZWF0b3IgKE1hdHBsb3RsaWIgdjMuMy4yLCBodHRwczovL21hdHBsb3RsaWIub3JnKQovUHJvZHVjZXIgKE1hdHBsb3RsaWIgcGRmIGJhY2tlbmQgdjMuMy4yKSA+PgplbmRvYmoKeHJlZgowIDQ3CjAwMDAwMDAwMDAgNjU1MzUgZiAKMDAwMDAwMDAxNiAwMDAwMCBuIAowMDAwMDI1NDI3IDAwMDAwIG4gCjAwMDAwMjUxNjkgMDAwMDAgbiAKMDAwMDAyNTIwMSAwMDAwMCBuIAowMDAwMDI1MzQxIDAwMDAwIG4gCjAwMDAwMjUzNjIgMDAwMDAgbiAKMDAwMDAyNTM4MyAwMDAwMCBuIAowMDAwMDAwMDY1IDAwMDAwIG4gCjAwMDAwMDAzOTcgMDAwMDAgbiAKMDAwMDAwMDIwOCAwMDAwMCBuIAowMDAwMDE0ODkwIDAwMDAwIG4gCjAwMDAwMjM3NzAgMDAwMDAgbiAKMDAwMDAyMzU3MCAwMDAwMCBuIAowMDAwMDIzMTIwIDAwMDAwIG4gCjAwMDAwMjQ4MjEgMDAwMDAgbiAKMDAwMDAxNDkxMiAwMDAwMCBuIAowMDAwMDE1MDk3IDAwMDAwIG4gCjAwMDAwMTU0MjAgMDAwMDAgbiAKMDAwMDAxNTU0OSAwMDAwMCBuIAowMDAwMDE2MDU5IDAwMDAwIG4gCjAwMDAwMTYzODMgMDAwMDAgbiAKMDAwMDAxNjcwMiAwMDAwMCBuIAowMDAwMDE3MDMyIDAwMDAwIG4gCjAwMDAwMTczNjAgMDAwMDAgbiAKMDAwMDAxNzg0OSAwMDAwMCBuIAowMDAwMDE4MTY4IDAwMDAwIG4gCjAwMDAwMTgzMzAgMDAwMDAgbiAKMDAwMDAxODQ2OSAwMDAwMCBuIAowMDAwMDE4NTg5IDAwMDAwIG4gCjAwMDAwMTg3NTYgMDAwMDAgbiAKMDAwMDAxOTAxMCAwMDAwMCBuIAowMDAwMDE5MzE1IDAwMDAwIG4gCjAwMDAwMTk1MDIgMDAwMDAgbiAKMDAwMDAxOTYxNiAwMDAwMCBuIAowMDAwMDE5ODMzIDAwMDAwIG4gCjAwMDAwMjAzMTQgMDAwMDAgbiAKMDAwMDAyMDUyNSAwMDAwMCBuIAowMDAwMDIwOTUxIDAwMDAwIG4gCjAwMDAwMjEwNDAgMDAwMDAgbiAKMDAwMDAyMTI4MyAwMDAwMCBuIAowMDAwMDIxNzIyIDAwMDAwIG4gCjAwMDAwMjIwNjIgMDAwMDAgbiAKMDAwMDAyMjMyNCAwMDAwMCBuIAowMDAwMDIyNDk0IDAwMDAwIG4gCjAwMDAwMjI3NzUgMDAwMDAgbiAKMDAwMDAyNTQ4NyAwMDAwMCBuIAp0cmFpbGVyCjw8IC9JbmZvIDQ2IDAgUiAvUm9vdCAxIDAgUiAvU2l6ZSA0NyA+PgpzdGFydHhyZWYKMjU2NDQKJSVFT0YK\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Layer 0 - Variance: 2.0582759380340576\n",
"Layer 2 - Variance: 13.489117622375488\n",
"Layer 4 - Variance: 22.100563049316406\n",
"Layer 6 - Variance: 36.20956039428711\n",
"Layer 8 - Variance: 14.831436157226562\n"
]
}
],
"source": [
"# An initialization function in JAX takes as input a PRNG key,\n",
"# the shape of the parameter to create, and the data type \n",
"# (usually jnp.float32). We create this function based on the\n",
"# input parameter 'c' here, indicating the constant value\n",
"def get_const_init_func(c=0.0):\n",
" return lambda key, shape, dtype: c*jnp.ones(shape, dtype=dtype)\n",
"\n",
"model, params = init_simple_model(get_const_init_func(c=0.005))\n",
"visualize_gradients(model, params)\n",
"visualize_activations(model, params, print_variance=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As we can see, only the first and the last layer have diverse gradient distributions while the other three layers have the same gradient for all weights (note that this value is unequal 0, but often very close to it). Having the same gradient for parameters that have been initialized with the same values means that we will always have the same value for those parameters. This would make our layer useless and reduce our effective number of parameters to 1. Thus, we cannot use a constant initialization to train our networks."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Constant variance\n",
"\n",
"From the experiment above, we have seen that a constant value is not working. So instead, how about we initialize the parameters by randomly sampling from a distribution like a Gaussian? The most intuitive way would be to choose one variance that is used for all layers in the network. Let's implement it below, and visualize the activation distribution across layers."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"application/pdf": "JVBERi0xLjQKJazcIKu6CjEgMCBvYmoKPDwgL1BhZ2VzIDIgMCBSIC9UeXBlIC9DYXRhbG9nID4+CmVuZG9iago4IDAgb2JqCjw8IC9FeHRHU3RhdGUgNCAwIFIgL0ZvbnQgMyAwIFIgL1BhdHRlcm4gNSAwIFIKL1Byb2NTZXQgWyAvUERGIC9UZXh0IC9JbWFnZUIgL0ltYWdlQyAvSW1hZ2VJIF0gL1NoYWRpbmcgNiAwIFIKL1hPYmplY3QgNyAwIFIgPj4KZW5kb2JqCjEwIDAgb2JqCjw8IC9Bbm5vdHMgWyBdIC9Db250ZW50cyA5IDAgUgovR3JvdXAgPDwgL0NTIC9EZXZpY2VSR0IgL1MgL1RyYW5zcGFyZW5jeSAvVHlwZSAvR3JvdXAgPj4KL01lZGlhQm94IFsgMCAwIDg5MS4zMzc1IDIxNS40NDY4NzUgXSAvUGFyZW50IDIgMCBSIC9SZXNvdXJjZXMgOCAwIFIKL1R5cGUgL1BhZ2UgPj4KZW5kb2JqCjkgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAxMSAwIFIgPj4Kc3RyZWFtCnic1X3LkiW7kdy+vqKW0oJJBN5YkkaJZjJtZkQzrSkOR7q0bo7xMRybv5d7IE9mAAfV7Ed108BrJKv81sFJ90QiEUDAQ17/8PLzX8jr//3LK/7n1b3+Af/9D/z8a/7+4vDbx5fa5AihJPzy4f7FSzpizBU/fsAfDr/+v5eXf31xR5OSY3Gp1tf5l9ictOxKff0zv/bXT39w/fIy/fXLSyyH8AqiHKV/48cXKeFoKeXqDfzBwlLKkR/4o4kB1Kv+0+tz8+LzUeX8By2FdLTXP//+9X+//vH157/wXb3/gf/+Af9V9V5+/qvf/+2n3/3+n3/9y9ff/eWl1CN6l1odrvlGh8t4+V8v//T6p0fD7pCEO/NoW3/99Ym+/OlFIN7PHP5V8YfEItnV6Ourj0cowvZ+9/Hll795/fl/l1eR19/860vGd4bqq3jez9/8y8t/kf/6+ps/vPy336A1dzhhi/jn+gkN4NM/+8Wff/rth599/OmP//6X11/928s/8Z/X7yKWiD+KxJrDeIdv+GvlGoQQ146cfMjBSw1GMWriqMkrNPleHNGmc0382CMM/D4cI7p/zNlX10KZOMqD4+Mjnh9BP/LO1+garuO1Ham57PsHfvG7v/70t9/+9ad/++Pr33774S/fWaIveMq/Vh7vjwBuoRyqz3nrj+998x9N1nR4z5FtZHbD38ysyuGbJGlBgpzs0g9ih06M51Ukx5Gewb+Zn6BHlxJyDtln33v1D7t9wiG3heDqRPDGv51grodPqbrSQgsnwbR8cPkS+BmHbLyIi/bmigGuno/vR32X8/O/+v0f//LTX//zW0QKnYtv1YWGF3/BiyP2t7UPeK0c+fG+jvp6P3Bz8M6RGvM5ubAffrUffpk+/PKS/KHA+DZIeEhcGa75wwim6EsmOHz+geJd/8sNuD+zBPVyJFxUCCP3Ac2SS5kVeYCbcF/QBPmG68Nw1kbyA5oEw/mTJA90E/YLnh9fMkYWn8SNr78RzTljCJk1eaB7sF/xBPt4RIyqdbz3I4qGSn3W5EQ3Yb/gCfb54JuuTPfeohVz9idJHuAm3Bcswb0dLvqYpjs/oAgMYpkVudBN2C94Ik5ExB2rj+OdH9AaHF5tsyYXugf7FU+wDwjTovPjvR9QtJeyPGnyQDdhv+AJ9rig1Krkkf2N+sNhqjlJcoObcF+w1PURn1Nq052/UYSqLab0pMiFbsJ+wfPjS0WoViTUcZpnUH9khAihzJpc6B7sVzzB3h+1FCkj+QsMCJlcRuAzKGLQTbg/swT1dOC6EEyO3G808umuGl7eDRhwE+4LmiBfjlhriSP3C+RTHkTfaebzBt2E+zNLLrMjbo/JT/f9RuuBUM7rusndgAE34b6g+fGlYb7uXJCB+wUmgAWBXB4Esege3BcsQR2zdZddG+/7jabMNVzvw6CIATfhvqAJ8pmLgbVON/5CEco414JG7ncLFt2E/YIn2GO2LojNp1t/oSUeuUaJgyQG3IT7guXHF3GYrPsQR+43iiGuCUa2Oihi0T3Yr3iSPWbrvvHrRvoXLA73Oaemr/S7kQHeRYEFV0qASwrJeZkkuGAu72cfuXcxSmPxXTRYkKUGmLlHV12eNLhgbuGJeOcnaQy8iwILqtzWxfw9okNPveCGJdUjl+hinJSx+CYarMj2re2afChTL7hhKfgWiUXX7602Ft9FgwVZaoD5fEIAP/eDCyZXaSX1AXHU5sJ30WBBlhpgWp8DJnaTBhcsOWDmU/Opwa2NxXfRYEGWGjSu15cw94MLZpJEDtL3M6w2Ft9FgwVZaOA9orqUplU/A4tvoJ2b95M2Ft9EgxVZahCPUCW4qR/cMBN4XItdAiONgXdRYEGVCmRM9IurZVLggpvD56IvYRTGwrsosKBKBerRmq/TnpeBSz5SAFxGYSy8iwILqlAgMIOn5jT1gRvO6XAxuD4/vBux8CYKrKhSAUz7Mcebdr8MnMAKLz5d/jONWHgXBRZUqQAuSZz3cx+44ITgMGMiMOlyo7vwXxAlf0z5cStlehMYmKmSKYU4ymLhXRRYUGVaKCb8XsqQP/xhgBNCoVx7iGQaMfAmCqyoUgFM931J026YhZnpin/hJ2EMvIsCC6pUAJP9EPBWmxS4YYQArVb3LMwF76LAgmpPjo6hSZr7wA17xMUY/OskjIF3UWBBlQpgoh9ji5MAF+qZLOqqf5Llgnfh/0wU9BMm+ckVP3UAAzPxAVFAmWW50E34r5hSAMzxU07Ti9CireSeeDw2ccG78H8mSvqY4Gfv23z/Lcxd0ZZnWS50F/4LphQA8/vMZPBJAAtXpv61Z10e8C4KLKhCgYz5fQk1T9HACD+S/qZG9soFXFKlAuFIpeU49YER5uG59izMA95FgQVVKpDwPKcY5j4wwI9E/6mRvfL/l1SpQD2kiZe5DwzwI+F9FuZb8+DHIzJHev2PlzcpjXr8869fx6M08+EMVxIPQxVM2FrLPUUEF4Tpa0/xwxge+vu8hqK7f6XgSkMRTzSK8Hig5oQVcZExIObBDS9/TZbCTNiXwiw59Ink8UogGg98KlZNrBLncs8tChETBo2gcOkp6OfzkVyoXKDIB76q6RXUwlEW8hJtvEL924r5t3gmY9YjcOu29tyVhu8XfBd/wpXr1r7gBlQEbK+QA5Fb0GtoTO3KoINhHPe0yJkVkoVbP6/ZMQ0m6gJPSzwFxd3hjH8fXPDSMwZa8EwWyfgyl7hGrlvpHpMifK5CMAwMtW+r4a656iB05Qpyi30O5XiqNAt+0R9Bvj32YitzEPKrSObzVaouQrp8eCfoYug0GRqGGuq5Y+VTbuiZknkIsbQLr/3sluRyaMimXVYENzNlxxNQDa/x4PoiJ/AGjWPVXR/EN1HyuRuUSvS6IwY18ZjHjoejBN9K0b+PsZ7b6YKLEB+8Nl+jnrjscG1C0fksxRpa6M1kzqVC7JfvJPgYTjz7lhvbkSO0mjUtg5sS3jXHrepUDnAq5+VURqMux1cNT9Bfz9VrjNI5xpD10YvJtz6F8eiRUD9xsRuKhIivVhxPNLpR7ekQzRW9Kb7gKvGWy6/s/w2dL56LgqWl2tIrpImuuB4hBsTIAY9sfMUIiVtZ22MBDXwy+iJ0R2fsXxgCTxTk0F45qyrR9c2XEA80HM5crOiT3jzeebx0kman5ey89C9kzlp2kQMO5iJ8NnqoHhip6uNXnYu9Y+DBT7ioKJrZ6PGVZ1SLyxevGaDJ4cb2AAhPSMnCRxj9IJf+ECP0wYNTz2V1PJc9a0QnBehpfc+lors6pZgxFJUi5yiJR8yHxZga2Nyb8Hjaz3OMRL8/x/2/f7x1eSodbS6PvX5883A7PvFlh2cX3/vJ1h2IfdZRRj2YyKGwRIxfeqJYMAqfbfE04v/87X/+/s+v7vVxHPE0I/gS74BuWTB7CDzZD4weAp4pJM/ppwH9OKFzh3HnzcCDFqaVZycB9oTrDyL++dpX7Muq/yCiR58u+oQYAgZ+B1MBr6Ezkywrk06+xFWAA/63GAt8R+Uac2ZjmDIRDfwuZ+89xmZMPDCsp5rq7C9wuOGY8vdji3cG5jfC+cfQ0W/4XdgG3XjGCwDvHyg4s/XrM8te12gevD/bbeA79o0vGha+umtwixqTpvP6J/+BH84Us4WMN3qLI9MbfjemJeP97TG7RBBWlK3/4WyZLYH3dZKJrsHfjS8zdBJeOrhgbkORcPzxhBN9ZnINYSJ84+9HGNNDzCQR8Oi8i4Tzp90KPOKK5DFn6w18tmfBV0rH8P1zw9U7fAeSwiJ8/2Tsj0lG0H8fpwM+iDs4ZURoNowmE5zO+fvUyAO+wvc9hFgwphCIrhFATCe634SXsm0mxIIahcBcAXPVYcb+4W14qc9mQiyoUQg8//hUyhPjN+ClPpsJsaAGIc5Nmynt5S14rc9eQqyoUYh4eC6l1UmIN+ClPpsJsaBGIfKRamkSJ8YDfL01xkb2fGusGFOIyjXdMsmwBJeSbSbCEzFG+XJIa7FO4+EAV65xtUmbC9xLhBVfysBVQM4eJxksjPltWqnzgDcTYsG4r/pUETelxoxwiyXk9qTPBW8mxIIxhaiHSOauwyjEDXMbQ9DQpI+BNxNiwRhCZHzMo+HpbWFgf8QEzvFJnwveS4gVYwqBqMHXKJMOF+qP5n3fnxnVueDNZHjmSxUQMoQobe4ON4wxocWs+yymDYNuJsOCMHVAxBDalEhr0Ii5UisuT+IYeDMZnvlShcbM6JKn6YOB8+Fyyr6M6hh0MxkWhKFDwesvSZpyaSxcD/zm+mvTNGLgvYRYMaYQiBZSCdNpdAMnx6lj1ewh04iFNxNiwZhCIGLIQaYz6Qamo6YgpPCTPgbeTIgFYwqBmEFXYichLhjvypaYETDIY9DNZFjwhQyV2SQxTwPEhWJI8Bn3P0zaGHgvGRZ8qUI4YnVxXoe84dKOUFPWbKS7DYtuJsOCMHVIzCL10xl1AzNpi+ZzMspj4c2EWDCmEPVwzbs4d4gLFldoytUz0UwrA76ZFAvOTBtwR2D629QnbpjZWq56p5lnViKL7yXFijOlYHpWyDL1ihuma0mIVfOwrEIG3kyIBWMKkehPFd3cJy6YaYHCnE0/CWTxzaRYcKYUCB6YEDrNI26YGZjJJdcXIoxEFt9MigVnSoH4wbtW5l5xwcxRDWi0TQoZeDMhFow/vgSH+AFR5bRbZWDJTCiT0meXRiCLbyXFkjOlQAQRfJqWpwzMLFZfc9ZTC1Yii28mxYIzpaBpQw3TMXcD82BzrD67WSKLbybFgjOlQCQRo8jcKy5YPPP1Uz9rYCWy+GZSLDhDCkEwEZlBP0pxwzyYwB80AdtKZPG9pFhxphSIJ57ztw1cMXlwRc+UmDYMupkMC76UIbGUScxzj7jgopXoRM/8m0YsvJkQC8YUAqFELj7N/eGCMxgnJjQP8hh0MxkWfCEDhrxQgpu2/AzMPMfmqh7ZMY1YeC8hVowphD9ywWem/nDDiUWlYj9eZvUx8GZCLBhTiIiRP9IMbxTihnkOy/djhbYRA28mxIIxhShoA03ESYgbzphENac7OrYRA28mxILxRz2dkFpGZD0JccORmYSigYVtxMCbCbFgDCGCPFdT+zDA4UhqMz3Kc6N7ybDiSxmi1kWbNv4szFzjWNRX3zZi4M2EWDCmELnXSJveGQbGy8Glvkg56nPBmwmxYEwhai+XNr0zDMxT576fZx71ueDNhFgw5sEwWdWYG2E2GeOkj4H3EmLFmEKEXkVt6hEjXGPt06mxkQe8mRALxhQi9Ypq0yxihG8hlvp8qxD2yNOLmk68fqYsz6YTTydq6JbI3EF3FP7cu7i0WHtuHGvMtvowUhLX9/5Tr8xapY+FTnI5U8hSYQUmfVfE1NIj3+w81gR9cIvOjBItz9mazj+ktJA6nDHryJnmbZEJio/kHO4p9zQcnsB3j1wVfLdaXajRhGsdxpdjApMyUzQiTQSUSwm4jCpRYwHv8CU9j4EHSnBXKo/3R9wZrZvmS+FZf89NfVcS96z6LjfGvVozfQNSBL/ecoPouBP4a0RYPJqve+LV05e6YVQoDLyc9/ncGoVeeKHSfUOKD/XcJow10bS0VfpOJN9hTMdwz0K3/G38+3huIImotYIEGmfwP4rj7qXCUyF0WYhNyrnNEg7cJXKjOVbGa7zKuefQJAitxPXaQ0j97zM+jGe66V5E6bXV+sq8K0JPHa7MV0ndnIJ4TuJpWmFNKHiwGJefTtOKmhKLE/Z17VAbhsxucoGgXA1ribdMBr38L/q0dkT0Mehd1GwCrx8esnssmwvut5pWRAa35wqQw4OIK1ATCuHR5qJfiyth4aRME4qgNUKr+HMVEaMY/xzzHamJthZ9RS2nWvBU0GUD0+JeZCoIt+9yUW8K/JjdGU71Mu2Cx4UVmvDcaE5tkEhfCwjPQ6AOV9+/VNKRxfH1SX+OFrpLX5BMR+tEcwr+dQh9+RvBOz1i8HBlffqr9HkqfS14lJG9ukYE9+EM7FLmSMNnIGMeK+0McyBl49OFJyah8+uV0D1Yauj1pIpvQR6xALqS60YUFZ/r64wYQhx6teiEGcOMi4+ZYg06ntB2seSkuQ+cNxUW4lY/Gl6oupxwFhFz0X0i+qzEGq4RFO/U81XS8MiX5/E2YzCRt+EvcKJ448zzW94GaHl5HPrjmy4J+MQXn6tef/snv+PLXCm8biU56QdP17YU/ofbUmCIwViH7jRO05NnWc+nIhkGHsQwraxtKe4/4D9f9RJ+49xxxLDgKgaiMQA38DvYUmDcOVjVPuXAVLMvs6Vw32RL8R2VywXDvngZQ1UDv4tRQ0x4m0aP94LDYPZ3bCm+H9tEC6OIbu+njn7B78I2sUSG93TECmVhwrG2pYi6AERDhs91pPiO3eKLRoSvtu+oePu58Lj+TzhS/BCmmL0GTDmqH5ne8LcwxTyjXNdPm6/Y0N8wbWvKVn48XdqpOY/paBv5GvzdCLOUGl45mJLT1U0tOP4BhOlSn9HFykT4xt+NMEuiFEx6G2eAWRmHfwBj2t45BDdxYnzj78c4c2uHdSI1GlbXEfdpF45Q1CddPbrQwme7cHyldl+3rMEIL335skZkyulzaQ1OSXxTW3A7gk5wcd0zdmrkAd8mmjsIsWJMIXwvGSGTEANccrfxm/U54c2EWDCmEHFVaGOEq0u9tvjYyAVvJsSCMYUovYJEnISwcBWGtM/6PODNhFgwphCtF5LIkxAWrq1Fjf4nfR7wZkIsGEMIL72exLgrMMJ0HJVnfS54LyFWjClE7GUl2iTEDWslsr52bBsx8GZCLBhTiNzrS0xvDQNjts4T9eFJnwveTIgFYwpRD9aZmLxHLMz0/tb9bkd9LngzIRaMIUSQXnFiemsYONB7GrPdSR8D7yXEijGFCFp5Yso/snDk6rHT7QfbiIE3E2LBmEKkVcEOC/OIvW9q2m4bMfBmQiwYU4iyKtxh4cwppGtt0sfAmwmxYAwhouv1KKYxwsDtCAHvzTrpY+C9hFgxphC+l6WYxogb5halxKipZ6YRC28mxIIxhYi9OsXcIy44ZUwYCvesR30MvJkQC8YUoqyKehiYOQSptRZGfSy8mRALxhSiHbEVN/l8GriwvF/IfpTHoJvJsOALGRJXFfz8yrjQ6o4WegkS04JB9xJhwZYasCRLTVPqkYEb5o74St1mv9uw6GYyLAhTh8wSHUwPGnW4YHzo8EGiWk6YVgZ8MykWnCkF4gbvZLIeMLD4gKDbF81hshJZfDMpFpy5NYzIwad5dn2hPBeJd0QrMglk8b2EWDCmDggcglZIGoW4YOZ7AZf+6rwFsvBmQiwoUwlEDmPdlw83yL2mjHlCj7aMOhbfTIYnvmfGRAy+zjJcMNPwmk/93XmpY8DNRFjwZTEhp8sq07LUhfacQ9f69pYRx+J7CbFgTB0QMqRY09Qdbpi1u1hILE763OhmMiwIUwdEDNnleZvvhoXn3/DJVCZ9LL6ZFAvOlAJBQ87RT9s6N8yLDj66PEtk8c2kWHCmFAgdivdzp3igLHEnrRdls/oYeDMZnvlChcqt7NLmfb4bZo5zdRgP6iiPhfcSYkWZSkQtrlmnDnHDzBQLWhXQNHGDm4mwYEsRMjPzU567wwUzXcaXbgBqGrHwZkIsGFOIir9MYbIYMDCzqCX1DHXTiIU3E2LBGEI0PWYzJ6obODU8AT71bd+7EQvvJcSKMYVA2IAOPr8wbjhxE6s5Pfpi9THwZkIsGFMInlzBwz7Nr2+Yh05cSX2MMPoYeDMhFowpBGvQ1timMcLAzCb2OedRHwtvJsSC8ceXhLmA91pf3AphYdapxZXXSR8DbyXEkjGFQOgQnJtMBiwc6Qfak15tIwbeTIgFYwqBwAH3dbIZsHBgve6kR2RtIwbeTIgFYwpRWO06TyapFmb15SZ6/tU2YuDNhFgwphCtHz2ukxA3zHKI/cDqKM8D3UyGBV/IINJL+Y37OhbmgUjnTh2sOhe8lxArxhQi9lJ+0zvDwJ5HBUQzSUd9LngzIRaMKUTupfymd8YA13bWbBobueDNhFgwphC1l/Kb3hkDzCNyulo/6fOANxNiwZiHZNyqlN8IV3+6VE36+Nm8agshVowpRFiVOpzgWpray0+NPOBvFeI9/TemszR4v9WiibTuKKGe74oWmnPxTB0ujaYmHPR8jLmvT3u8HPGfpi/H7JhtryljjiX/fJ9bxdZCz0gPtC6IPBtPSy9QTz33koYJITg14KD3Wd8TAvfqJDD2hQroTLE3kg+Qcl6n7PjJx/7X7agpl6Ahn0d0c6YqIfaVFH14TaBTzzZodR487gpLhuQKrduZzoNgOVahLWFAYNB3I2jE5nkHuVvXci/LxZyXUOny8prL4Z3HKHBmgeAmep90HSqkFjXQ4EVhLiXCegw+5tYDMSaSgUoNr432CY7nYwkHmgg0hKf04IAIrcM00qgsAkQPjtKPcn/Q08T4ORR1s4/0VdTGs1YRo+kIK0L7WrWCFPcc6RPRT6ipkYeiuMG5RvUCZxmV2ulkSl9EbZ8ry1CF1v88H5gZs043t6ogTutXDi1cTRW9Q202mpSz+XLknPxoyhHprEGnk9D/2p/288TRh+tpTN5Y56ZvkGEOgnmHb3o1BfcgxBNv1dP3RHgBRYuwcomY/qsQhWRpMCitPradfNPOioZxG2PpOZ+FPqWVJh6JKTz4l9q3CsZ31g5P6nHiXJX+tbiVFb3B4e9dgh41ucc6LQSSWF4LHzIMA31BCn0NFEPgGVp0+DMZvWbcykCHE3DKvja1woh6/M/RmCTrsX3pe4TsJ3QOCey6NZ7W7Ihgj1RyYzUgFrwonLcTxnMmPFqrRYLootfjf/XzcE79ajBq8x3eo2GMmpk7+0VtOdsjdsbgRJMRPIhQIOvJUAYIJQaaiTB3HG+/qi9D5rqILtQwkipOLyQJRgT6iugZDNy8LP3Nie/Bbe6lsdD7RDv6NKoiLI+LwfYBf4HLxhvnuN+yakDLyyPeH980fcAnvvis+PrbP/kdX+ayweGusWTYGw4b8Yc7bCQ8OeU5H7fQQ/u5oomBByFMK2uHjesPAv6JX/WafeNQcWbnR2g4zRsN/A4OG3iFojWOppGHsb/QYePbLDa+o3R4UyfMJKb1KgO/i+kEevvBBV6fcsUY+myxMRw//450C77Zp1TG4NvA70OXlmeRySORr8FnumuTjayrPPps0Qjuc502vp9cXzYyfLUjCWY7whdPv/5POG38EKacsyRM8mRkesPfwBQzWeev68fcTyTUxmG52zCkH08XcxVMp1iibaB7w99ClysR142tlZOl6LJOQ7uxyI/niyk2Jr+OnoYDYYO/G2Pc3aNgYukxkGLaq5T/AbdYuGac9WDhSPnG348y3hzOYypaAkbA003lH0CZwQxm4ClMlG/8/SjTsCQIIgUEZJ1x+jvmIhjfj5AL5t39yfhcc5Gv1O4rPVNr+YoVG8RVWnllWszE7EmrkEyLmSNcnKir4dTIA75WbHaQYcEXMtCgk6sG0+L2CIO+z8/qPOCdZFjxpQy+lyCZesMAAzs3O4ZGLngrGRZ8KUPsFUjm3nDDHoNpjs1P6hh4KxkWfClD6QVI5t5ww4jJU+vrOaM6F7yVDAu+lKH18iNzb7hhf3Axzz+rc8FbybDgy6hdevGRsTdYmFWsMJHMT+pc8EYyLPlShtBLj+RJhhsOR/Y+q0GubcTAW8mw4EsZ8qGFR/wkww2rkXDU9VjbiIG3kmHBlzLUXnekTTLccOIeV8+ztY0YeCsZFnwhg7hedmTqDQYuhw8xxDapY+CdZFjxpQyhFx0pkww33A6R0w/fNmLgrWRY8KUMqZcciZMMF0xH/9KcboWYRiy8lQwLvpSh9IIj09hwwykdRbLTrVmrjoG3kmHBFzJ418uNTL3hhjN90nMMozgG3UmEFVuK4Hupkakv3DCPMgqXICdtDLyVDAu+lCH2CgDTHPKGwSxFyX1kuBux8FYyLPhSBsQI0cfJz9XAjcsKknQL2TRi4a1kWPClDDy+W32cR4YLpiVE5ouxjvIM+FZCLBhzVw9RQq/ZMghxw6L7dEySmASy+E5CrBhTCMQJiVV/JiEuWJhvVUpWY3UrkMW3EmLBmEIgUsgJd3YS4oKFOVkp9dwbK5DFtxJiwZhCIFYoEurcIy6Yq/wt+aqpMlYgi28lxIIxhIjuqAXzwqlH3LAmjYUWNI3KCmTxnYRYMaYQgUWh2mSSYGBmw3mMCppfbAWy+FZCLBhTCNYgqyXMPeKCmc7HolY96rYCGXwrIRaMKUQ5SotpcnM1MKuK4bZ7Te20All8KyEWjCFEQtzg3HR06UZZs6K5UDTf3Mpj8Z1kWPClCggbXGZ1wVGGCxaW2gkx9VfGLY+Ft5JhQZg6IG4QLYU86nDBrWJodNIj77sRC28lw4IvZUDYICVPm3kGrpw8naUATCMW3kqGBV/KgKDBs3dPMlww073xntQDjKYRC28lw4IvZMgIGXzz02aegVkq1EvroffdiIV3kmHFlzLosQs3eSMYOGWeQolatdI0YuGtZFjwpQyZM8LqplfFDdN2T5zoORSrjoG3kmHBlzIgWGAO/aTChfK0jpSUR20svJUIz2yZasx6t551bQcRDMwh0bfSRm0MupMIK7pUAUFC4qmmUYQLTSxIG8IsjYG3EuGZLTVAfJBDm3fxDBwPwUCgp4RMGwbdSoQFXapQWNd4Xqm/0XB4iVU9rG0TBt5KhGe20KBqNfEkU08wsBZxdmouZ9ow6E4irOhSBdaylDCZnFsYoYO4XgNjFOeCt5JhwZcysMxzcXXuDDfM85Kxe0+O6lzwVjIs+FKG3E9Ez73hhv3Bm96e1bngrWRY8KUMjW3kNL0pB7g1SVr9YmzkgreSYcEXMjTplQWn3jDAtdXQN66GRi54JxlWfClD6HUFpxn0ANdHgvSkzoZ500u+lCH3qoKTCgZVtmGtzW7viQVbalBXdRgnuIWoTgBjGw90KxEWdHmyx/VqguO4MMGP8yNTI+91rOQ9jUCmky8JLWh5ZDzKTcT1XctaJapBP3PheVi96Pl+V1tfRUxcWc3B0wqfCwiS1ZaAScK6if+qjhulzyZdPHhE2mkmLabU3cg5Ow6hPJyoxh4xqPlGFtYJaOpHUg8pMfieauYPLmW6XqsKHNT8lxl3zeN/1e4j44faM9AY2Qem7aeEzyVJcqZkRefpXpLwUwBlHcQE9yzjxV7ovBC4C39mLkFhHk+kJ0aks4HCcmACBNVY+kZccFrZggk++FaPTo8IQhz6QTwTXtAgrU5qOBhb9UjLM0POUycePMEN6Nfny8FcKY/7TyFz8X2A8e3goYzG436sLFK8e2RV1JpKpnV21sICxZ976HgMaHcikDahZ/SXFjtVxL0qr5IaBegebzkU2oTWFF4l04mkoiXF8UdS6G1Cuw705dZTwQM9OvDuq92/v3kfyrlBSWlERtuPjA4lKfkU9e9xl1Ls21esSqm0WBHe56hujIRrCzRJobsHQtKi3i7c9osFD3i3LMms39d3x+hLJU33Rbm2GWPL5+6Yx63gNiFPxTqp5/Yhu1vN3FCOrETvc089YIdzdJQREAkBvayvo9NONbJSIg9w1lBKv3qtY+HVbgU9HJd19mt0OUcbmMzjqMXjZunVp6wuK7hDlTMG1yWjHQkEB/GSWayz1zPmam1udLGh7wru8LlgpcsUDX2IVi8u9Br1Gb843FWnxrcOo1IPZXn2tzhftWqXIKTtN4NHCX1tJdI5pNED8lwLc1mLGYEuOJ3THFrd8ES9rpxFXEffksftCjVqDQholnBh5VxGEe8jH1JaU+NJ7zG10MkdTXJ1BW/H7mLDUDvgZxpk8AyrO8MN6BAbgq4egUPHs212/OBdP4XhILyyoRu2wxAQzxhNeujWWMswSj//ghg+6rxkGrTxzPtPwF/gM/LGKfa3DCvQ8vKA+8c3rS/oTPKlJ+XX3/7J7/gynxGOhQmvDAw0NBNYeo3kH+41UvhIMfF2TNGrlcVwy6jSBQ5CmBbWPiP3H/Cfr3qLv3G+GKMnhtDi525xw+/gM1L6cS6HF4PHYPqlPiPyLT4j3086zGjwpNeax1msgd/FeKMKx9iCeYrD6Pgpn5HhWSm6isJ1dnWA+1zjje/Z0z7/MflarQoawWvscfWfsN34ITw598BErQ48b/AbeHp6pV488S7Fo4rZd6YDWzfd+PFsmw4ZkN+yvcFvYRvs1dNbPDrWJSmxPjw3fjxd8ZjK4Sc38DXouxEWPPOYpmFGgyfYPyw3/gGMGcRgWioj4xt9P8b0mOMuMW5xyw/Hjb9jQFGEPncI9nobn21A8ZXafeVKAcOeL18rKJhbL0qYYH68KmFiYYSJHCmqwncjBr7WCvYQYsGYQuBN+1zCxMKI551Gn6M6J7iZCAu2EKG4Xodj3GaxsBFhocxeIqzYUgTfa3BMy2cDjPgt1DppY+DNhFgwphCx1+CokxA3jOEAQasGsLYRA28mxIIxhci9BkechLjhcCRd8RnFSWPV8T0kWHClBK1X35h8Lw3cM9xLfVLmgjcTYsEYQlTp1TdGHW40HjHg1RAmdQy8lwwLvlQh9NIbsww3fD0RdwN7PhArqlQgr0qVWJhLhNIT2kdhLngzIRaMKQQXpBE3T3MGA9tHwjSy7yOxYAwhmutVN6YZpIHvZ+JuYc+HYsWVEoReb2OaMRiYr8fmdIvRNmLgzYRYMKYQaVWmxMLcSiji86SPgTcTYsGYQpRVmRILDz3ibmTfHrFgTCHaqkyJhVkLM/Z9UtuIgTcTYsH440ull/xzmRILVxZ0YGrzqI+BtxJiyZhCRJYgaZP7p4ETh4UsedLHwpsJsWBMITJ3z88SC0aIC+b+dHD4lkkfA28mxIIxhWgHWozTeXsDMymgnnVcrD4G3kyIBWMIIfQfSn46b29gniYX73VXwDRi4b2EWDGmEIgbRNzkAmrg6g6uWMdJHwtvJsSCMYVA3EAPorlHXDCmDkxtGdW5wc1EWLClCMw5QsPT+HDD+BB+jH3+aFoZ8M2kWHCGFCwCNpew+WBhDAN4BHLSk9RWIovvJcWKM6UImjk0Hbk3MP15SkiaCWcVMvBmQiwYUwgGT62VuU9csMRyiO9BxaDPDW8mxIIxhWDWSCp5GiduWLR8my99nDACWXwzKRacKYWWfkvzs/FAJYNBLroaZ/Ux8GYyPPPtGUU+FZ4RHWS44SH71chj4b2EWFGmEogechA/CfFAe3ZwatJmfQy+mRDPjKkDOzir7ExCXDAZ42EImpg8CnTBmwmxoEwlGpP251DjQmllVpvvdQWsPhbfTIhnxtABv0QE19MOn4GFtRVjFu9HgSy8lxArylQCL8GafZZJiQsWlnnUshOTQhbfTIoFZ0qRD/ecqm1gVnMKhaHFJJHFN5NiwZlSsOBumQ5V3aief2GCXZgEsvhmQjwzhg4JAYQLebKpMHAFtRi0SNrdhAH3EmFFlyowx6XF6bilgavjsbqkh6qsOAbeTIgFYwqB4EGSTCfzDUx/ipb6uTDTiIU3E2LBmEIgevCsgjrq8EBzYupk0rNLpgkLbybDM1+q0JgEV9I8OlxwFp4I83UU5wY3E2FBFypkBA7BpziNDjecaQsbe3ntUZwL3kuIFWMKEfvJ3empuOHkj1q07vqgj4U3E2LBmELkXrVuCjwN3A6PDzs/6mPhzYRYMKYQrdetm2aUBmY52Fb9JM+NbibDgi9kKNLr1k0jhIFNJohtZNcEkSVjChFW5f4s/MiQsi1smTW15EoJcq9aN40NBjaHLWwju57BWDKmELXXrZveFgamd3a3MRrleaDfKsN72laMp2VEON3rJ24w/5Veo1BaEa01VPCIx5RT0mPhklNVf8vCBdgWU69vGUrxrWcW85w+CzNrabsQajhTbbP3oE4U3MOVZxfEt8vNotc2Lg3dJ7AssSZbgUjTcx0tH7mmXFI/+559b7tp2dXABQLGtmpS0PNznAuO7nO0WQoYpXRL3oGDFB6g5yl47/qikaOPQONp/8Ri8CGrX0F1uAcp8SA8LQdojNATHIqWAo+NCQ6pRF96I2iRNR4Tp0slpnDmhdAfQrwXzqnxlPRSVlXwRfhOV3huEv9XU98jhppe3SEKZl/SfF/nlIhOlVpOtLnAk+XUPYAnaD04oa9xiQfdQfp38jh5w4XFbmeRQ26PvaUQEgsqCyVPzulxPu4wtAKli9rAszpyH9k83TxrVf+IRBuNdrbfEDdWr/4RFMO71Jdj0SnRmXV5knYGsaoVCXH0G5qEEG9Qpu+IB4ycMfvTnz/SnuKxwO2A4p4Rr1D1/HtPk6QWRdd7ebqldJzZ/NHXbovhIUY8YXT2jOmK/nl0rZ2LxpjMttP9H/cx99kNcBpw6FVC2BLPP2d3EzW/oFsDYsPazjVXV+n2oSKwhIA81qpz5haeiuYTi/spzrp2Tc0y+ATiPqg3SA1ci6g0y8DYwCMa7rGQmWg4Ao0Tz/IE3zdBMGT4ltREAy2is3h5LAO6ENREQ49VYgjua1+0oOTRQ8FFcoFcFWOtQc5boAG6M76oaAIbF0aqz3QVaegr8SyewoWCxD2o8FrZiV3sE+OEjs6ZcaMTR8EjkXo0rUmSNMYonqm0LfbVhky/GTpjQC+MTSE+oi08Y3TGYNCJIDz3WLQeeNh5EBNdsoVa+/ZoVpsUrQxXWT8y9R7Jj0Y8JlVdN2gDEs+Jmne5BjW7wZ3ozhgV349rqniwI0I9muG0czoDvrVp0iNz2fz1fkc46DU3HENrUR+N2k0+mx4xeRRmRw/GSJJ159MzQ7ALUgodMEPSERfa1f74Di8Q6BhcfRv+AhONN06kv+XGgJYXh9U/vuHpQMuNLzvxvv7eT7T/ZeYZOtbjFRWiGgIszTPq63zENvKjoWY69eIKGl8H8mwj8C8//eWvf/7p//w7f7nO1r78f3EeOcsKZW5kc3RyZWFtCmVuZG9iagoxMSAwIG9iagoxMTIyMQplbmRvYmoKMTYgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAxMTIgPj4Kc3RyZWFtCnicNYzLDcRACEPvU4VL4M9QT1Z7yvZ/XQYlQsIPbDkiQTMRG8mBD69z/pakzuNemv7QCVGrB49aJoSziXM/VDUWzRZySFnXme2hU6ewkkNOcBeoKoJaRRDGuJaywsuh1AkryDY4WTtv472+f0MKI+gKZW5kc3RyZWFtCmVuZG9iagoxNyAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDI1MCA+PgpzdHJlYW0KeJw9UDlyBEEIy+cVegI33e9Zl6Pd/6cWuOxgRjRQOmgzCLr5q7poLXzps+/PwDTej1v8Vf27FKZEQyRRCq8nrqFuIa1RfZBZqAxO8gaKOvPlUVQo0o2Tyos4ttJhtei1k6mETHwZtyoFpj0Tb2gn2RQatC1E9dEh90kKcz2okOSetiqoFsdhQsMCHYWYFHA6FTh3hb3N/X60DSd4ALecYmJvJ+TiHIQX7ngJulOmD85UL1JITi6KMqtmI+lQDzGZw3ZCb1aObNoi32Ktf1bhczlKzCV9UtRGEO6NzuR1RDD/XiOoWrzc5CifoLb42hBT/cd5P98/UhVcfQplbmRzdHJlYW0KZW5kb2JqCjE4IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggNTcgPj4Kc3RyZWFtCnicMzU1UzBQMDcGEqZGhgrmhmYKKYZcYH4uiAIJ5HAZmlkgsSxMgAyQajjDAEiD9eRwpQEAfm8PsQplbmRzdHJlYW0KZW5kb2JqCjE5IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggNDM3ID4+CnN0cmVhbQp4nDWSSXIlMQhE93UKLuAIMWg6z+/wyn3/bb+k3IsqkBCQmTDnsmG57MvdppfNHPbHnxplq+zvk9sVzhrmGB827fPEGfY1LWp3Yni2/Tw+31LuYWEnjHKfZ1L7qMxN/T03l3JWWPH4TPpajMX1omxso0FU2b0WU6/dt8W65B6LfTs1jhKcU1yeDzJvkYZPHh0AkmPTkrbk5+WLjsij82vPa2f8jxxuzgUaeTut4igyh5XeokNNoYi2qAHJvhmyCAX4ysa28AKGhXZ3NvOc95VE0v48nAqMKkYQHrUkmY9jhX6eaXNI/M18hDAGasbLU9OKVk854iYv0VAvErk1088jDJORFpzr8k38rUkWdUsYNqyoWIeoC3sd3ogRKrcKstnV8AI9f9rznMSYWHXpJYwFV8EbDGk0htEoAksWPBx6Q6LY76q90gfkWbr17paGFggZ2o7QGqhtSNCrrUNQYMe4LTU3I801AIh7qUnvJKB9HYASgXjb7Bx5qsJSXZiwvKfF3w1J85xCUNY7GBTR+R5FE4X3/V0M9i63imGPmvc8LhAgJGLOPjXBd5d+qf483/8AGU+mUwplbmRzdHJlYW0KZW5kb2JqCjIwIDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMjUxID4+CnN0cmVhbQp4nE2RS27EQAhE930KLjAS/27O49GsnPtvU+CJlIVFiaKBhyOSmDLoJUIhQVuS3rLEN/I/Cw7T3aGNe0nYP+XZphRTcJLapjAmrZh4LdMnY4GoRnYSQwSOi5PXITd8h8mxh6MKzoZj6H2KnANVRbYVTjCU1axp7BM1+00r2ehURoIq96KcMWggmBs6gFoy8VqqNUoOPqfGBeP15QaTgycNFxjFqAqUYUvZ0Hq6FpsdA3b2MD3+zDTVFha42QYyVvoi9yjAKXaqJ2r2mVr1qbrC5g2wgYFeAShHVvs8B0PORAAAcTL4GV0h7fCshZ62mynn3R/KtT6/8CJcBgplbmRzdHJlYW0KZW5kb2JqCjIxIDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMjQ2ID4+CnN0cmVhbQp4nDVRSXIEMQi7+xX6QKoMwsZ+T6dySv5/jWBmDl3Cxmih15yY4MWXGeIaFie+bcQM2J34G3VpefE74qiyi1iJdISdGnwG1V0grUk8V+MzfLIriw1zmI7r6H5P1VGzlq3tIhTNBY0IsW7HTpSHZ5yFKIJqZcJW+SwaO5KVHZfjcl3ChWLiKwf1fpnmm7Y0Isq+vrf/OC613eoJLiomxUu9ZkZPcglpzSseMXBqUlE8b6OiMroyOYvwDhZWXkwnpjquOX+h7+6oqhXXC6tlbH2zk92F3B1s10KjQPJqqiC1foFIrtf1YW+H0q5Vf37dM37+Ac5qWM0KZW5kc3RyZWFtCmVuZG9iagoyMiAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDI1NyA+PgpzdHJlYW0KeJw1UDGSAzEI6/0KPpAZgwDb70nmqs3/2xN4UkmLVyApImUKXF6q4ttlacpHh0/j/NuYIc9AHlEXmPavFqvxPUyjma5FhTrEwLHOLR6yVThPE9XNKV81dt2zGQ1xOCaBTnETcG/S0Kkxle7cPCG+XBT8PlnLl0pwoVEUmNyCRrphhGJQk6ARUBNaL0gGPEuwK2idSBrs62QV+xm/Ai6bhd3DM9SivX6b6WEgbKYlZjJcXdDjFdaMEdgQ51kFYXoRgFdSkKxg7j7LunDE+a57NVqUohiMZfAPMHhp/GoQXQloy1mk5UUGt8uUGm9bLn5t0SgWX2gc9PaL8h5//+OVXoIKZW5kc3RyZWFtCmVuZG9iagoyMyAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDI1NSA+PgpzdHJlYW0KeJw1UMltBDEM+7sKNhBAp2XXs0Fem/6/oTQbjAcibJGUmLkh8MKXKlIT6YJvXWEK3YXflWpQdr1X3IKKIUqwFeEGntfy6+AXMSJ2nvpaJmeQBnkUEUce3ucljjbVGm/LbJmihoGvoTIdMe0aBykbJjXTWd2pZPQLUUhORwS55L84qlPFZiOPPdV2cwZl8CZgHGwqreljNei9lJpKFyVTnX8l59mzUqA4SkwCveruTV13g45gXzhzO93t5z6BSQfA2T6h0quzk8t4wx7EePXA06fbD+cmuzF1Ou2gvj2Z2JFPNub3uWECQXetw73HIRnt5R5OJe777/haP39JF1y6CmVuZHN0cmVhbQplbmRvYmoKMjQgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCA0MTYgPj4Kc3RyZWFtCnicPVJLbgUxCNvPKbhApfBPzjNVd73/tjYzr9LLgwkEbENmyZJQ+VKVVJPWI996abf43vJ7aSC+VFRdwpaclIiU+0JG1BH84oxJD1zT2SW7peyIWkoV07VcGnUMddjEOsfel3uPx3690M0Kb1gr8F+2JbajaDzWjRF4cRDpGBSR/cIKP4MziBf9/GWCiPEL+RniqXiLyCBIdDUgpgAW57GL1ehpsBeYG1owibWWCxBHjXDWj70vvqKnsRFXfE162bzmfdDYahaBk2CEZoiihhtZQ03PFHUH3BL9J6BJkZtDoQcI2iAKIZXVk49N0cBJAzcGyzEZJXPAoue+J8NrvW9821TxAzCU7HxkHg9D8I3tOIigb0HYZ2jleLNwAxkoAS0QoPPcAAkziK2UfYg28TXoq+XDBxF/NPkdT9FNnXEcjENnsbS4hAucN8W0Bck4PJsVg5JLwIh8YUj30HEI3D4EdK2Z3MZWPqJovSKt2TZ6AM4M23jKsyi8J2XDfBQn2STGojmFhKfYRWZo60gCuJi0DRFQw9p8KN7Xzx+IoaQ2CmVuZHN0cmVhbQplbmRvYmoKMjUgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAyNDYgPj4Kc3RyZWFtCnicRVE7bsUwDNt9Cl6ggPW1fZ4UnV7vv5ZMAnRIxNgSSTFVjYl0fJmhrLFm49sGT2xv/A6LhJ3CZ1hOWOlpGDttG07iGs6RZfBo9IQTslwjLAQiD1Yj1oHNzfPkW1zpQQ6/q0fpRmgX1BGeiM3xCnGV84uPFeIsisy7UpxO7xM6ikN3J6ilG1NP071m89EMl4NaiNhayZ+FPyNJ/o/aXbekfVFtZEwin4bUltnIVXDKqcpi3Ujmk6az2GkKIplSdN/xxhuzp9YSssV+KhmVspjVnQSzM7okh36MMlV9shYyKnDGOCMirsp8UywL77+7xs8fHkpY9gplbmRzdHJlYW0KZW5kb2JqCjI2IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggOTAgPj4Kc3RyZWFtCnicTY1BEsAgCAPvvoInGChS/tPpyf7/WpFx9EJ2EiCqjSpBxtB6k6HRgyIcxjcVBuoFB7DyABGf671cwEGZxrNNeRrppho/Zk9qbGejmg7PfRXxqnx/MdkhKQplbmRzdHJlYW0KZW5kb2JqCjI3IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggNjcgPj4Kc3RyZWFtCnicMzIyUjBQMDMDEoamJgrmhmYKKYZcQL6ZoalCLogBEsrhgklCWCDJHJgqMMMAotjU0BKqBMEygKnI4UoDAJV6FUwKZW5kc3RyZWFtCmVuZG9iagoyOCAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDQ4ID4+CnN0cmVhbQp4nDMyMlIwUDAzARKGpkYK5oZmCimGXGB+LogCCeRwwaQgLAMgDVaRw5UGAIAODCUKZW5kc3RyZWFtCmVuZG9iagoyOSAwIG9iago8PCAvQkJveCBbIC02NjUgLTMyNSAyMDI5IDEwMzggXSAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDM1Ci9TdWJ0eXBlIC9Gb3JtIC9UeXBlIC9YT2JqZWN0ID4+CnN0cmVhbQp4nOMyNbJQMDY0UsjlMjUDM3LADEsTEAMkh2CBJdMA7sYJtQplbmRzdHJlYW0KZW5kb2JqCjMwIDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMTgxID4+CnN0cmVhbQp4nE1QQRICMQi79xU8oRDownt0POn/rwYcHQ/bBFLSsBFHtpw+PC8JbLnrmvrVEFryXOrxx5wfWUJiqxhyxqB78Lbg+ulc7JgLqn1Axc04Y3Swec6DbqdaOclKxS92rajyxvZWMgSZcx9RH9SZIdtMgqofQuPL6IbiLB2RNZzZ2pdZOptbO0KcG1BBb5bj4OFiZYO3ZTynYzrJtVhrz+ihAyulCq9By960WWeaP/lcjzeeU0O7CmVuZHN0cmVhbQplbmRvYmoKMzEgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAyMzIgPj4Kc3RyZWFtCnicLVBBksRACLrnFX5gq1pFO/2e2Zrb/v+6YHKCxEbAqrZlmfbjbuXHKpf9+sU/Ucf+RLLKyBFt7mnYaZ/La/O9W3iMJnYPfq7EHoZF2WpDuaE1weEXN8gncQajNyfD1uL7Y049biI5NX1sc0EyAGHRcUw6lTt8gstc+LliPVUcMCZz7bxlUORQUee2tx1bBN6eYn44zptiInO5y8pP2d4WGdaPVcspmYMkeUBO8673ORyzAMEKB4PRoQlZhk7AIBujwVI6XRislzwDmFcmmNxyFVMIvVCsR6OguenK4BkPPqW+/1TOVsIKZW5kc3RyZWFtCmVuZG9iagozMiAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDExNCA+PgpzdHJlYW0KeJw1TssNQzEMumcKRvDf8Tyv6ind/1rHai8GYUC4BwhM1VdTkVx48bqU8FmyvfEMegwLhRtBtJU2CzGsCs/iSFgWWAMWNqXmdj/NXKvT7Lt7ZFJet2UjRNsjaQh3KBFiJ5RjxjzrP+v8Vp31/gItliJeCmVuZHN0cmVhbQplbmRvYmoKMzMgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCA0MiA+PgpzdHJlYW0KeJwzMrdQMFCwNAQShkDS0MBAIcWQC8zP5YIK5HAZorBANJRKAwB+zAwSCmVuZHN0cmVhbQplbmRvYmoKMzQgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAxNDQgPj4Kc3RyZWFtCnicTY8xsgMhDEP7PYWPYMk2sOfJn19t7t9GhhQpQALNk8cRYW6jdEVOq3D7w7Xf75bCbc+FzB+X6e2G3ByGRSt3o06B9roIFTGNMXYh66iSdVxAyu9Ib6Z/kt3LW71B4wzpLZpbRcdxREljT0w2jSUGbhAT4jGmxcxOSi5pKCW+tnJiJ735c3Z9rv8PwzQxjwplbmRzdHJlYW0KZW5kb2JqCjM1IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggNDA4ID4+CnN0cmVhbQp4nC2TOXIDQQhF8zkFF1BVs/R2Hrkc2fdP/T5yoIGhp/kLaI5hw9Lt5W613GYO+/KHis9pv4/7MV/Hfh6PMM/kt8wHv3nsHHs/fobtYeFhNIjZ4f3E7SS5tq5lhZ1JOan5oL6J8R8rdaJspeUCaB+uTPM7dCLYS2WkxThgTIvQiV8QRagW1dEdg/vv51LYZXtb0GMVIsVqgphhtE6aKByVSWqU0aFiinaVyG6ZMu0sqyPaZXVLsLgyeZMXE92+BvG2GXQJsMdtL0VOET/2J0u+nwEfROuuhAuZk7vBgQlVwUKLTmJSdCkwCxfzY+NcWJfMJTE8rxwW+dGGV/Y32FVICkwophWVHeEyojPfqmjW9M8eJs8KKaMbGhTzep+Q7ds7kEzUCytXD6EYjcyft1X5xtbc7QbfZrYbKVfE1eWgnqGRihee5YmeF5rZrWANpD0K5uiK2D0k7ozde+onPnHKwc6km7c7W/7SNNozKFwogNGrJ/C49hJ+9N6L1au3Q9NTJo100sZRZZ9gCQ25/PljvJ/vP4XjmJkKZW5kc3RyZWFtCmVuZG9iagozNiAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDM1MyA+PgpzdHJlYW0KeJw9UjtyRDEI698puEBmzB/Os5lU2fu3EThJJQYjQMLuQYe06IOZnA8lN33yY13kxvR+DElXo+/HjpBHkTZKW0kzKU7T61FXCkVGgBYk1YuvR4JvRgMVRcJOgarXwzVsJY4gT6DPHJ8XTLMOYnEy7DCoMXMYnewgk0ImRgK+2Zk5mG7QIgFO4KV7cXbLjewADTwbBdPNsKWCM7L1nEVRwctEs58jy4aOhZnggzN6igyLat9d1oBIOAj9vUZKxSL2YtmIfRRuk1USI0toHeEBXekILMfLawkbwhnLXuChMddeSNoWR969mXZSjh0wIpJ3VRxhlmxIg51/Jx2De4W+b4SzjkjeI9TGqElI54QNRSCPjpI1GgdMEkdz2FU+gDWEJ5iPkLCmQD7Txg7uCIoJMnlRZJ2cKOeeQcqXo3YvZvhbMEfGGcyqixhuv5lTW8H/HHbZLisoi/4kvp6vH1MwiTEKZW5kc3RyZWFtCmVuZG9iagozNyAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDE3ID4+CnN0cmVhbQp4nDMyt1AwgMMUQy4AGuMC8QplbmRzdHJlYW0KZW5kb2JqCjM4IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMTcwID4+CnN0cmVhbQp4nEVQOQ7DMAzb/Qp+IIBFH7Lek6JT+/+1lFMki0mQskibvlBhC8cE3eC14mWFY8ED35Ka4VPYB44Gsu3J2hPOYs4k1h2HBlvFStWYK027miEaeqprYHYsIiJPG0yR6KMqQPM3GRYism4yFSBrxi54scvMpg/7r5D7MLvvGtXR9dw6hB2xy7ojpCtFDW2pnKUcE3JYBQNUguAs5CbshOsfrm86y/sHMoY9iQplbmRzdHJlYW0KZW5kb2JqCjM5IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMzY2ID4+CnN0cmVhbQp4nDWSSXIlMQhE93UKLuAIMUo6z3d45b7/th9U96ICSkyZCZklS8LkS01SVbZe+daHFz1X/jzqS2yp/D4aSzSVb4tqEle5Lp/HVlIm5ilF8l5tPo/TDcejZIc4n65Oj0VvVwmlT+2xtm5H2osrQZ4dp2aLT8SZ6/R3MpwM269l+IzgxS82xUDmPhFLehfIbablIHztHUvOrvFcWwRQwjEieiI0ong51NzXpnfNeOBuRokAnialU4NW1ShhWNC2OmOZ4/G+IFVn6Plfo3npgiLRXVEYbKmHCJTTHfilk3GK0iMKzNotsJbJZlSL12uzqrEAmY20IL3QNVDrvuLTpUkjSaVD9kpZ0woo5SVCNCtf61PTHifQGbGpAVlEQwxohRkL66XZu7AzkZ6+z+R6dh2y2O7IBSlz+tiMyFi+Jsxx9frp0EC4wez5zs+dpfaR9n217bur8TRhx0k2G545RS4zWqkr/+748/z8BfNwirMKZW5kc3RyZWFtCmVuZG9iago0MCAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDI2NyA+PgpzdHJlYW0KeJw1UUlywzAMu/sVeIK4i+9Jp6fk/9eCzHTGMmhzA6CIxIE2X3EMJY0feSa8js8GB+/HzgLrVGAGl3lS8HrC0GxUiDr6Qjjx9cyH3IKkQZVHeDKY0eYEvTA3WBFrZk2Psdtjhiv83sVQZWYjzrVuxCWWc/mZHm+kOUwK6QmtL3KPxffPIVFSlkrkucMtKPaSsBXC64tn9zDgqveIimpMC6UL6WWuLJIoDlSR9UqniDhEaiPnoCRNd+Ia5FyVtGBWBCcu6pCfyGmHd8JplNNzt1gizJxaO8YkV4r2uyb1irVwbg+MnbomqdF81uqh9ayV25Q2GaFdo0GSog/1hM71vv7v+f38/gErHWDYCmVuZHN0cmVhbQplbmRvYmoKNDEgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAxODkgPj4Kc3RyZWFtCnicTVDBbQAxCPtnCi9QKUAgME+rvq77f2uSq9QHMjJgA+6BiVj4EMHKBZfCl4w1m/85uAPPsHBIwmSeVl1y8HPoy0iSYY87grRoQTZkFkxRAZ9k0xCJvZCFYIM4yVZmD5cQrwO1m77LPENc/2Vq8maSbWeMnqSXZRuHHV2hC3WkFDzr7rknx4+TXifSFGFi3JNVM7vdxr9w2rYeMUuiVReKp4bCeJIwGvsZXYl3zb8/3mw2nnc+4/sX9s1EjAplbmRzdHJlYW0KZW5kb2JqCjQyIDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggOTggPj4Kc3RyZWFtCnicNY3BDcAwCAP/TOERwAktmadVX+n+3zpS+gAsA+d0hyOaWq9CxsAdxljua/KXMy08t2KcoNdSHIizg10AFVPTOy5jlpABHro4dFFNP9SmjdqcP02cQYXNHTrt+QAByBvjCmVuZHN0cmVhbQplbmRvYmoKNDMgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAyMDggPj4Kc3RyZWFtCnicNZDLcQMxDEPvqoINaIbg6kPW40xOTv/XAJJ9IlZYPQKa7uaGZT28bBRsouwHbYV1VNlfm1L84902qAKWqTkM/lzxaoj4nD1bgsxRunfMpYu+DdutV3KSkFtWDuv8QhE1l4VPRgGdcIF0Qk5Z4GFQsU7CdwPwUQHZKfU8hnSLMbmfk0SuI2wtJkuLfZdHBa8sOoMdLuZbnphiqMPbbLXG4XS1FZjtppChfpMm1G5zY0lkKaWeKjyYYt+nBclH0HRcmaE57fvWr/b7D9bFSiAKZW5kc3RyZWFtCmVuZG9iago0NCAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDI3MiA+PgpzdHJlYW0KeJw1UUtuBTEI288pfIFK/EnOM1V3vf+2JumTZgQJ2BgnsyAIw5cqUhZaN7714Y2n43eS8GaJX6IWMhvvs5jLhhJVwRg89xS0N5qdZn64rPPE93G9Nx7NqPAu1E5WQoLoTRkLRfpgRzFnpQq5WVlUV4HYhjRjJYXClhzNwVkTR/FUFqyIIc5E2WXUtw9bYpPeN5IoqnQZYa3gutbHhBE88X1MbqbJ37mrURXvyaKmY5rpDP+fq/7xbDLzPK4o99Ee9DqUAi5qzoXljKqjQE/isaY6xtz2MWYIgqchnHiHTRbUPR0ZF5NrMENSVnDljCgOuZHD3e8NTSnjo/HB8jyA0vA8W9LUFnxWeZ+fP/SWZUsKZW5kc3RyZWFtCmVuZG9iagoxNCAwIG9iago8PCAvQmFzZUZvbnQgL0FyaWFsTVQgL0NoYXJQcm9jcyAxNSAwIFIKL0VuY29kaW5nIDw8Ci9EaWZmZXJlbmNlcyBbIDMyIC9zcGFjZSA0NiAvcGVyaW9kIDQ4IC96ZXJvIC9vbmUgL3R3byAvdGhyZWUgL2ZvdXIgL2ZpdmUgL3NpeCA1NgovZWlnaHQgNjUgL0EgNjggL0QgNzYgL0wgOTcgL2EgL2IgL2MgL2QgL2UgMTA1IC9pIDEwOCAvbCAxMTAgL24gL28gMTE0IC9yCi9zIC90IC91IC92IDEyMSAveSBdCi9UeXBlIC9FbmNvZGluZyA+PgovRmlyc3RDaGFyIDAgL0ZvbnRCQm94IFsgLTY2NSAtMzI1IDIwMjkgMTAzOCBdIC9Gb250RGVzY3JpcHRvciAxMyAwIFIKL0ZvbnRNYXRyaXggWyAwLjAwMSAwIDAgMC4wMDEgMCAwIF0gL0xhc3RDaGFyIDI1NSAvTmFtZSAvQXJpYWxNVAovU3VidHlwZSAvVHlwZTMgL1R5cGUgL0ZvbnQgL1dpZHRocyAxMiAwIFIgPj4KZW5kb2JqCjEzIDAgb2JqCjw8IC9Bc2NlbnQgOTA2IC9DYXBIZWlnaHQgNzE2IC9EZXNjZW50IC0yMTIgL0ZsYWdzIDMyCi9Gb250QkJveCBbIC02NjUgLTMyNSAyMDI5IDEwMzggXSAvRm9udE5hbWUgL0FyaWFsTVQgL0l0YWxpY0FuZ2xlIDAKL01heFdpZHRoIDEwMTUgL1N0ZW1WIDAgL1R5cGUgL0ZvbnREZXNjcmlwdG9yIC9YSGVpZ2h0IDUxOSA+PgplbmRvYmoKMTIgMCBvYmoKWyA3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MAo3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAgNzUwIDc1MCA3NTAgNzUwIDI3OCAyNzggMzU1IDU1NiA1NTYKODg5IDY2NyAxOTEgMzMzIDMzMyAzODkgNTg0IDI3OCAzMzMgMjc4IDI3OCA1NTYgNTU2IDU1NiA1NTYgNTU2IDU1NiA1NTYgNTU2CjU1NiA1NTYgMjc4IDI3OCA1ODQgNTg0IDU4NCA1NTYgMTAxNSA2NjcgNjY3IDcyMiA3MjIgNjY3IDYxMSA3NzggNzIyIDI3OAo1MDAgNjY3IDU1NiA4MzMgNzIyIDc3OCA2NjcgNzc4IDcyMiA2NjcgNjExIDcyMiA2NjcgOTQ0IDY2NyA2NjcgNjExIDI3OCAyNzgKMjc4IDQ2OSA1NTYgMzMzIDU1NiA1NTYgNTAwIDU1NiA1NTYgMjc4IDU1NiA1NTYgMjIyIDIyMiA1MDAgMjIyIDgzMyA1NTYgNTU2CjU1NiA1NTYgMzMzIDUwMCAyNzggNTU2IDUwMCA3MjIgNTAwIDUwMCA1MDAgMzM0IDI2MCAzMzQgNTg0IDc1MCA1NTYgNzUwIDIyMgo1NTYgMzMzIDEwMDAgNTU2IDU1NiAzMzMgMTAwMCA2NjcgMzMzIDEwMDAgNzUwIDYxMSA3NTAgNzUwIDIyMiAyMjIgMzMzIDMzMwozNTAgNTU2IDEwMDAgMzMzIDEwMDAgNTAwIDMzMyA5NDQgNzUwIDUwMCA2NjcgMjc4IDMzMyA1NTYgNTU2IDU1NiA1NTYgMjYwCjU1NiAzMzMgNzM3IDM3MCA1NTYgNTg0IDMzMyA3MzcgNTUyIDQwMCA1NDkgMzMzIDMzMyAzMzMgNTc2IDUzNyAyNzggMzMzIDMzMwozNjUgNTU2IDgzNCA4MzQgODM0IDYxMSA2NjcgNjY3IDY2NyA2NjcgNjY3IDY2NyAxMDAwIDcyMiA2NjcgNjY3IDY2NyA2NjcKMjc4IDI3OCAyNzggMjc4IDcyMiA3MjIgNzc4IDc3OCA3NzggNzc4IDc3OCA1ODQgNzc4IDcyMiA3MjIgNzIyIDcyMiA2NjcgNjY3CjYxMSA1NTYgNTU2IDU1NiA1NTYgNTU2IDU1NiA4ODkgNTAwIDU1NiA1NTYgNTU2IDU1NiAyNzggMjc4IDI3OCAyNzggNTU2IDU1Ngo1NTYgNTU2IDU1NiA1NTYgNTU2IDU0OSA2MTEgNTU2IDU1NiA1NTYgNTU2IDUwMCA1NTYgNTAwIF0KZW5kb2JqCjE1IDAgb2JqCjw8IC9BIDE2IDAgUiAvRCAxNyAwIFIgL0wgMTggMCBSIC9hIDE5IDAgUiAvYiAyMCAwIFIgL2MgMjEgMCBSIC9kIDIyIDAgUgovZSAyMyAwIFIgL2VpZ2h0IDI0IDAgUiAvZml2ZSAyNSAwIFIgL2ZvdXIgMjYgMCBSIC9pIDI3IDAgUiAvbCAyOCAwIFIKL24gMzAgMCBSIC9vIDMxIDAgUiAvb25lIDMyIDAgUiAvcGVyaW9kIDMzIDAgUiAvciAzNCAwIFIgL3MgMzUgMCBSCi9zaXggMzYgMCBSIC9zcGFjZSAzNyAwIFIgL3QgMzggMCBSIC90aHJlZSAzOSAwIFIgL3R3byA0MCAwIFIgL3UgNDEgMCBSCi92IDQyIDAgUiAveSA0MyAwIFIgL3plcm8gNDQgMCBSID4+CmVuZG9iagozIDAgb2JqCjw8IC9GMSAxNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0ExIDw8IC9DQSAwIC9UeXBlIC9FeHRHU3RhdGUgL2NhIDEgPj4KL0EyIDw8IC9DQSAxIC9UeXBlIC9FeHRHU3RhdGUgL2NhIDEgPj4KL0EzIDw8IC9DQSAxIC9UeXBlIC9FeHRHU3RhdGUgL2NhIDAuNSA+PiA+PgplbmRvYmoKNSAwIG9iago8PCA+PgplbmRvYmoKNiAwIG9iago8PCA+PgplbmRvYmoKNyAwIG9iago8PCAvRjEtQXJpYWwtbWludXMgMjkgMCBSID4+CmVuZG9iagoyIDAgb2JqCjw8IC9Db3VudCAxIC9LaWRzIFsgMTAgMCBSIF0gL1R5cGUgL1BhZ2VzID4+CmVuZG9iago0NSAwIG9iago8PCAvQ3JlYXRpb25EYXRlIChEOjIwMjIwOTAxMTk1NzMxKzAyJzAwJykKL0NyZWF0b3IgKE1hdHBsb3RsaWIgdjMuMy4yLCBodHRwczovL21hdHBsb3RsaWIub3JnKQovUHJvZHVjZXIgKE1hdHBsb3RsaWIgcGRmIGJhY2tlbmQgdjMuMy4yKSA+PgplbmRvYmoKeHJlZgowIDQ2CjAwMDAwMDAwMDAgNjU1MzUgZiAKMDAwMDAwMDAxNiAwMDAwMCBuIAowMDAwMDIyMDAxIDAwMDAwIG4gCjAwMDAwMjE3NDMgMDAwMDAgbiAKMDAwMDAyMTc3NSAwMDAwMCBuIAowMDAwMDIxOTE1IDAwMDAwIG4gCjAwMDAwMjE5MzYgMDAwMDAgbiAKMDAwMDAyMTk1NyAwMDAwMCBuIAowMDAwMDAwMDY1IDAwMDAwIG4gCjAwMDAwMDAzOTcgMDAwMDAgbiAKMDAwMDAwMDIwOCAwMDAwMCBuIAowMDAwMDExNjkzIDAwMDAwIG4gCjAwMDAwMjAzNTggMDAwMDAgbiAKMDAwMDAyMDE1OCAwMDAwMCBuIAowMDAwMDE5NzEyIDAwMDAwIG4gCjAwMDAwMjE0MDkgMDAwMDAgbiAKMDAwMDAxMTcxNSAwMDAwMCBuIAowMDAwMDExOTAwIDAwMDAwIG4gCjAwMDAwMTIyMjMgMDAwMDAgbiAKMDAwMDAxMjM1MiAwMDAwMCBuIAowMDAwMDEyODYyIDAwMDAwIG4gCjAwMDAwMTMxODYgMDAwMDAgbiAKMDAwMDAxMzUwNSAwMDAwMCBuIAowMDAwMDEzODM1IDAwMDAwIG4gCjAwMDAwMTQxNjMgMDAwMDAgbiAKMDAwMDAxNDY1MiAwMDAwMCBuIAowMDAwMDE0OTcxIDAwMDAwIG4gCjAwMDAwMTUxMzMgMDAwMDAgbiAKMDAwMDAxNTI3MiAwMDAwMCBuIAowMDAwMDE1MzkyIDAwMDAwIG4gCjAwMDAwMTU1NTkgMDAwMDAgbiAKMDAwMDAxNTgxMyAwMDAwMCBuIAowMDAwMDE2MTE4IDAwMDAwIG4gCjAwMDAwMTYzMDUgMDAwMDAgbiAKMDAwMDAxNjQxOSAwMDAwMCBuIAowMDAwMDE2NjM2IDAwMDAwIG4gCjAwMDAwMTcxMTcgMDAwMDAgbiAKMDAwMDAxNzU0MyAwMDAwMCBuIAowMDAwMDE3NjMyIDAwMDAwIG4gCjAwMDAwMTc4NzUgMDAwMDAgbiAKMDAwMDAxODMxNCAwMDAwMCBuIAowMDAwMDE4NjU0IDAwMDAwIG4gCjAwMDAwMTg5MTYgMDAwMDAgbiAKMDAwMDAxOTA4NiAwMDAwMCBuIAowMDAwMDE5MzY3IDAwMDAwIG4gCjAwMDAwMjIwNjEgMDAwMDAgbiAKdHJhaWxlcgo8PCAvSW5mbyA0NSAwIFIgL1Jvb3QgMSAwIFIgL1NpemUgNDYgPj4Kc3RhcnR4cmVmCjIyMjE4CiUlRU9GCg==\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Layer 0 - Variance: 0.08219309151172638\n",
"Layer 2 - Variance: 0.00415463000535965\n",
"Layer 4 - Variance: 0.00010465682862559333\n",
"Layer 6 - Variance: 2.8326080609986093e-06\n",
"Layer 8 - Variance: 3.75452451351066e-08\n"
]
}
],
"source": [
"def get_var_init_func(std=0.01):\n",
" return lambda key, shape, dtype: std*random.normal(key, shape, dtype=dtype)\n",
" \n",
"model, params = init_simple_model(get_var_init_func(std=0.01))\n",
"visualize_activations(model, params, print_variance=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The variance of the activation becomes smaller and smaller across layers, and almost vanishes in the last layer. Alternatively, we could use a higher standard deviation:"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"application/pdf": "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\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Layer 0 - Variance: 8.21930980682373\n",
"Layer 2 - Variance: 41.54630661010742\n",
"Layer 4 - Variance: 104.6568603515625\n",
"Layer 6 - Variance: 283.26092529296875\n",
"Layer 8 - Variance: 375.4525451660156\n"
]
}
],
"source": [
"model, params = init_simple_model(get_var_init_func(std=0.1))\n",
"visualize_activations(model, params, print_variance=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"With a higher standard deviation, the activations are likely to explode. You can play around with the specific standard deviation values, but it will be hard to find one that gives us a good activation distribution across layers and is very specific to our model. If we would change the hidden sizes or number of layers, you would have to search all over again, which is neither efficient nor recommended."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### How to find appropriate initialization values\n",
"\n",
"From our experiments above, we have seen that we need to sample the weights from a distribution, but are not sure which one exactly. As a next step, we will try to find the optimal initialization from the perspective of the activation distribution. For this, we state two requirements:\n",
"\n",
"1. The mean of the activations should be zero\n",
"2. The variance of the activations should stay the same across every layer\n",
"\n",
"Suppose we want to design an initialization for the following layer: $y=Wx+b$ with $y\\in\\mathbb{R}^{d_y}$, $x\\in\\mathbb{R}^{d_x}$. Our goal is that the variance of each element of $y$ is the same as the input, i.e. $\\text{Var}(y_i)=\\text{Var}(x_i)=\\sigma_x^{2}$, and that the mean is zero. We assume $x$ to also have a mean of zero, because, in deep neural networks, $y$ would be the input of another layer. This requires the bias and weight to have an expectation of 0. Actually, as $b$ is a single element per output neuron and is constant across different inputs, we set it to 0 overall.\n",
"\n",
"Next, we need to calculate the variance with which we need to initialize the weight parameters. \n",
"Along the calculation, we will need the following variance rule: given two independent variables, the variance of their product is $\\text{Var}(X\\cdot Y) = \\mathbb{E}(Y)^2\\text{Var}(X) + \\mathbb{E}(X)^2\\text{Var}(Y) + \\text{Var}(X)\\text{Var}(Y) = \\mathbb{E}(Y^2)\\mathbb{E}(X^2)-\\mathbb{E}(Y)^2\\mathbb{E}(X)^2$ ($X$ and $Y$ are not refering to $x$ and $y$, but any random variable). \n",
"\n",
"The needed variance of the weights, $\\text{Var}(w_{ij})$, is calculated as follows:\n",
"\n",
"$$\n",
"\\begin{split}\n",
" y_i & = \\sum_{j} w_{ij}x_{j}\\hspace{10mm}\\text{Calculation of a single output neuron without bias}\\\\\n",
" \\text{Var}(y_i) = \\sigma_x^{2} & = \\text{Var}\\left(\\sum_{j} w_{ij}x_{j}\\right)\\\\\n",
" & = \\sum_{j} \\text{Var}(w_{ij}x_{j}) \\hspace{10mm}\\text{Inputs and weights are independent of each other}\\\\\n",
" & = \\sum_{j} \\text{Var}(w_{ij})\\cdot\\text{Var}(x_{j}) \\hspace{10mm}\\text{Variance rule (see above) with expectations being zero}\\\\\n",
" & = d_x \\cdot \\text{Var}(w_{ij})\\cdot\\text{Var}(x_{j}) \\hspace{10mm}\\text{Variance equal for all $d_x$ elements}\\\\\n",
" & = \\sigma_x^{2} \\cdot d_x \\cdot \\text{Var}(w_{ij})\\\\\n",
" \\Rightarrow \\text{Var}(w_{ij}) = \\sigma_{W}^2 & = \\frac{1}{d_x}\\\\\n",
"\\end{split}\n",
"$$\n",
"\n",
"Thus, we should initialize the weight distribution with a variance of the inverse of the input dimension $d_x$. Let's implement it below and check whether this holds:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"application/pdf": "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\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/pdf": "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\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Layer 0 - Variance: 1.0483813285827637\n",
"Layer 2 - Variance: 1.0350143909454346\n",
"Layer 4 - Variance: 1.018454670906067\n",
"Layer 6 - Variance: 1.0767643451690674\n",
"Layer 8 - Variance: 1.1150107383728027\n"
]
}
],
"source": [
"equal_var_init = lambda key, shape, dtype: 1.0/np.sqrt(shape[0]) * random.normal(key, shape, dtype=dtype)\n",
" \n",
"model, params = init_simple_model(equal_var_init)\n",
"visualize_weight_distribution(params)\n",
"visualize_activations(model, params, print_variance=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As we expected, the variance stays indeed constant across layers. Note that our initialization does not restrict us to a normal distribution, but allows any other distribution with a mean of 0 and variance of $1/d_x$. You often see that a uniform distribution is used for initialization. A small benefit of using a uniform instead of a normal distribution is that we can exclude the chance of initializing very large or small weights.\n",
"\n",
"Besides the variance of the activations, another variance we would like to stabilize is the one of the gradients. This ensures a stable optimization for deep networks. It turns out that we can do the same calculation as above starting from $\\Delta x=W\\Delta y$, and come to the conclusion that we should initialize our layers with $1/d_y$ where $d_y$ is the number of output neurons. You can do the calculation as a practice, or check a thorough explanation in [this blog post](https://pouannes.github.io/blog/initialization/#mjx-eqn-eqfwd_K). As a compromise between both constraints, [Glorot and Bengio (2010)](http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf?hc_location=ufi) proposed to use the harmonic mean of both values. This leads us to the well-known Xavier initialization:\n",
"\n",
"$$W\\sim \\mathcal{N}\\left(0,\\frac{2}{d_x+d_y}\\right)$$\n",
"\n",
"If we use a uniform distribution, we would initialize the weights with:\n",
"\n",
"$$W\\sim U\\left[-\\frac{\\sqrt{6}}{\\sqrt{d_x+d_y}}, \\frac{\\sqrt{6}}{\\sqrt{d_x+d_y}}\\right]$$\n",
"\n",
"Let's shortly implement it and validate its effectiveness:"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"application/pdf": "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\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Layer 0 - Variance: 0.00029831365100108087\n",
"Layer 2 - Variance: 0.0005463268025778234\n",
"Layer 4 - Variance: 0.0007796576828695834\n",
"Layer 6 - Variance: 0.0011752902064472437\n",
"Layer 8 - Variance: 0.011736484244465828\n"
]
},
{
"data": {
"application/pdf": "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\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Layer 0 - Variance: 1.2806072235107422\n",
"Layer 2 - Variance: 1.6784099340438843\n",
"Layer 4 - Variance: 1.6767947673797607\n",
"Layer 6 - Variance: 2.5439999103546143\n",
"Layer 8 - Variance: 4.41333532333374\n"
]
}
],
"source": [
"def xavier_init(key, shape, dtype):\n",
" bound = math.sqrt(6)/math.sqrt(shape[0]+shape[1])\n",
" return random.uniform(key, shape, dtype,\n",
" minval=-bound, maxval=bound)\n",
"\n",
"model, params = init_simple_model(xavier_init)\n",
"visualize_gradients(model, params, print_variance=True)\n",
"visualize_activations(model, params, print_variance=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We see that the Xavier initialization balances the variance of gradients and activations. Note that the significantly higher variance for the output layer is due to the large difference of input and output dimension ($128$ vs $10$). However, we currently assumed the activation function to be linear. So what happens if we add a non-linearity? In a tanh-based network, a common assumption is that for small values during the initial steps in training, the $\\tanh$ works as a linear function such that we don't have to adjust our calculation. We can check if that is the case for us as well:"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"application/pdf": "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\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Layer 0 - Variance: 1.520933165011229e-05\n",
"Layer 2 - Variance: 2.4512757590855472e-05\n",
"Layer 4 - Variance: 3.6233024729881436e-05\n",
"Layer 6 - Variance: 4.8036039515864104e-05\n",
"Layer 8 - Variance: 0.0004025915695820004\n"
]
},
{
"data": {
"application/pdf": "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\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Layer 0 - Variance: 1.2806072235107422\n",
"Layer 2 - Variance: 0.5610313415527344\n",
"Layer 4 - Variance: 0.29278191924095154\n",
"Layer 6 - Variance: 0.2838047742843628\n",
"Layer 8 - Variance: 0.39267846941947937\n"
]
}
],
"source": [
"model, params = init_simple_model(xavier_init, act_fn=nn.tanh)\n",
"visualize_gradients(model, params, print_variance=True)\n",
"visualize_activations(model, params, print_variance=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Although the variance decreases over depth, it is apparent that the activation distribution becomes more focused on the low values. Therefore, our variance will stabilize around 0.25 if we would go even deeper. Hence, we can conclude that the Xavier initialization works well for Tanh networks. But what about ReLU networks? Here, we cannot take the previous assumption of the non-linearity becoming linear for small values. The ReLU activation function sets (in expectation) half of the inputs to 0 so that also the expectation of the input is not zero. However, as long as the expectation of $W$ is zero and $b=0$, the expectation of the output is zero. The part where the calculation of the ReLU initialization differs from the identity is when determining $\\text{Var}(w_{ij}x_{j})$: \n",
"\n",
"$$\\text{Var}(w_{ij}x_{j})=\\underbrace{\\mathbb{E}[w_{ij}^2]}_{=\\text{Var}(w_{ij})}\\mathbb{E}[x_{j}^2]-\\underbrace{\\mathbb{E}[w_{ij}]^2}_{=0}\\mathbb{E}[x_{j}]^2=\\text{Var}(w_{ij})\\mathbb{E}[x_{j}^2]$$\n",
"\n",
"If we assume now that $x$ is the output of a ReLU activation (from a previous layer, $x=max(0,\\tilde{y})$), we can calculate the expectation as follows:\n",
"\n",
"\n",
"$$\n",
"\\begin{split}\n",
" \\mathbb{E}[x^2] & =\\mathbb{E}[\\max(0,\\tilde{y})^2]\\\\\n",
" & =\\frac{1}{2}\\mathbb{E}[{\\tilde{y}}^2]\\hspace{2cm}\\tilde{y}\\text{ is zero-centered and symmetric}\\\\\n",
" & =\\frac{1}{2}\\text{Var}(\\tilde{y})\n",
"\\end{split}$$\n",
"\n",
"Thus, we see that we have an additional factor of 1/2 in the equation, so that our desired weight variance becomes $2/d_x$. This gives us the Kaiming initialization (see [He, K. et al. (2015)](https://arxiv.org/pdf/1502.01852.pdf)). Note that the Kaiming initialization does not use the harmonic mean between input and output size. In their paper (Section 2.2, Backward Propagation, last paragraph), they argue that using $d_x$ or $d_y$ both lead to stable gradients throughout the network, and only depend on the overall input and output size of the network. Hence, we can use here only the input $d_x$:"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"application/pdf": "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\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Layer 0 - Variance: 3.25944201904349e-05\n",
"Layer 2 - Variance: 4.664550942834467e-05\n",
"Layer 4 - Variance: 6.605686212424189e-05\n",
"Layer 6 - Variance: 0.00015451121726073325\n",
"Layer 8 - Variance: 0.002561226487159729\n"
]
},
{
"data": {
"application/pdf": "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\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Layer 0 - Variance: 1.0483813285827637\n",
"Layer 2 - Variance: 1.0137324333190918\n",
"Layer 4 - Variance: 0.9987665414810181\n",
"Layer 6 - Variance: 0.8383973836898804\n",
"Layer 8 - Variance: 1.316560983657837\n"
]
}
],
"source": [
"num_input_feats = np.prod(exmp_imgs.shape[1:])\n",
"def kaiming_init(key, shape, dtype):\n",
" # The first layer does not have ReLU applied on its input\n",
" # Note that this detection only works if we do not use 784 \n",
" # feature size anywhere - better to explicitly handle \n",
" # layer numbers\n",
" if shape[0] == num_input_feats:\n",
" std = 1/np.sqrt(shape[0])\n",
" else:\n",
" std = np.sqrt(2/shape[0])\n",
" return std * random.normal(key, shape, dtype)\n",
"\n",
"model, params = init_simple_model(kaiming_init, act_fn=nn.relu)\n",
"visualize_gradients(model, params, print_variance=True)\n",
"visualize_activations(model, params, print_variance=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The variance stays stable across layers. We can conclude that the Kaiming initialization indeed works well for ReLU-based networks. Note that for Leaky-ReLU etc., we have to slightly adjust the factor of $2$ in the variance as half of the values are not set to zero anymore."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Optimization\n",
"\n",
"Besides initialization, selecting a suitable optimization algorithm can be an important choice for deep neural networks. Before taking a closer look at them, we should define code for training the models. Most of the following code is copied from the previous tutorial, and only slightly altered to fit our needs."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"def _get_config_file(model_path, model_name):\n",
" # Name of the file for storing hyperparameter details\n",
" return os.path.join(model_path, model_name + \".config\")\n",
"\n",
"def _get_model_file(model_path, model_name):\n",
" # Name of the file for storing network parameters\n",
" return os.path.join(model_path, model_name + \".tar\")\n",
"\n",
"def _get_result_file(model_path, model_name):\n",
" return os.path.join(model_path, model_name + \"_results.json\")\n",
"\n",
"def load_model(model_path, model_name, state=None):\n",
" \"\"\"\n",
" Loads a saved model from disk.\n",
"\n",
" Inputs:\n",
" model_path - Path of the checkpoint directory\n",
" model_name - Name of the model (str)\n",
" state - (Optional) If given, the parameters are loaded into this training state. Otherwise,\n",
" a new one is created alongside a network architecture.\n",
" \"\"\"\n",
" config_file, model_file = _get_config_file(model_path, model_name), _get_model_file(model_path, model_name)\n",
" assert os.path.isfile(config_file), f\"Could not find the config file \\\"{config_file}\\\". Are you sure this is the correct path and you have your model config stored here?\"\n",
" assert os.path.isfile(model_file), f\"Could not find the model file \\\"{model_file}\\\". Are you sure this is the correct path and you have your model stored here?\"\n",
" with open(config_file, \"r\") as f:\n",
" config_dict = json.load(f)\n",
" if state is None:\n",
" net = BaseNetwork(act_fn=nn.relu, **config_dict)\n",
" state = train_state.TrainState(step=0,\n",
" params=None,\n",
" apply_fn=net.apply,\n",
" tx=None,\n",
" opt_state=None)\n",
" else:\n",
" net = None\n",
" # You can also use flax's checkpoint package. To show an alternative,\n",
" # you can instead load the parameters simply from a pickle file.\n",
" with open(model_file, 'rb') as f:\n",
" params = pickle.load(f)\n",
" state = state.replace(params=params)\n",
" return state, net\n",
"\n",
"def save_model(model, params, model_path, model_name):\n",
" \"\"\"\n",
" Given a model, we save the parameters and hyperparameters.\n",
"\n",
" Inputs:\n",
" model - Network object without parameters\n",
" params - Parameters to save of the model\n",
" model_path - Path of the checkpoint directory\n",
" model_name - Name of the model (str)\n",
" \"\"\"\n",
" config_dict = {'hidden_sizes': model.hidden_sizes,\n",
" 'num_classes': model.num_classes}\n",
" os.makedirs(model_path, exist_ok=True)\n",
" config_file, model_file = _get_config_file(model_path, model_name), _get_model_file(model_path, model_name)\n",
" with open(config_file, \"w\") as f:\n",
" json.dump(config_dict, f)\n",
" # You can also use flax's checkpoint package. To show an alternative,\n",
" # you can instead save the parameters simply in a pickle file.\n",
" with open(model_file, 'wb') as f:\n",
" pickle.dump(params, f)\n",
" \n",
"def calculate_loss(params, apply_fn, batch):\n",
" imgs, labels = batch\n",
" logits = apply_fn(params, imgs)\n",
" loss = optax.softmax_cross_entropy_with_integer_labels(logits, labels).mean()\n",
" acc = (labels == logits.argmax(axis=-1)).mean()\n",
" return loss, acc\n",
"\n",
"@jax.jit\n",
"def train_step(state, batch):\n",
" grad_fn = jax.value_and_grad(calculate_loss,\n",
" has_aux=True)\n",
" (_, acc), grads = grad_fn(state.params, state.apply_fn, batch)\n",
" state = state.apply_gradients(grads=grads)\n",
" return state, acc\n",
"\n",
"@jax.jit\n",
"def eval_step(state, batch):\n",
" _, acc = calculate_loss(state.params, state.apply_fn, batch)\n",
" return acc\n",
"\n",
"def train_model(net, params, optimizer, model_name, max_epochs=50, batch_size=256, overwrite=False):\n",
" \"\"\"\n",
" Train a model on the training set of FashionMNIST\n",
"\n",
" Inputs:\n",
" net - Object of BaseNetwork\n",
" params - The parameters to use as initialization\n",
" optimizer - Optimizer to use\n",
" model_name - (str) Name of the model, used for creating the checkpoint names\n",
" max_epochs - Number of epochs we want to (maximally) train for\n",
" batch_size - Size of batches used in training\n",
" overwrite - Determines how to handle the case when there already exists a checkpoint. If True, it will be overwritten. Otherwise, we skip training.\n",
" \"\"\"\n",
" file_exists = os.path.isfile(_get_model_file(CHECKPOINT_PATH, model_name))\n",
" if file_exists and not overwrite:\n",
" print(\"Model file already exists. Skipping training...\")\n",
" state = None\n",
" with open(_get_result_file(CHECKPOINT_PATH, model_name), \"r\") as f:\n",
" results = json.load(f)\n",
" else:\n",
" if file_exists:\n",
" print(\"Model file exists, but will be overwritten...\")\n",
"\n",
" # Initializing training state\n",
" results = None\n",
" state = train_state.TrainState.create(apply_fn=net.apply,\n",
" params=params,\n",
" tx=optimizer)\n",
"\n",
" # Defining data loader\n",
" train_loader_local = data.DataLoader(train_set,\n",
" batch_size=batch_size,\n",
" shuffle=True,\n",
" drop_last=True,\n",
" collate_fn=numpy_collate,\n",
" generator=torch.Generator().manual_seed(42))\n",
"\n",
" train_scores = []\n",
" val_scores = []\n",
" best_val_epoch = -1\n",
" for epoch in range(max_epochs):\n",
" ############\n",
" # Training #\n",
" ############\n",
" train_acc = 0.\n",
" for batch in tqdm(train_loader_local, desc=f\"Epoch {epoch+1}\", leave=False):\n",
" state, acc = train_step(state, batch)\n",
" train_acc += acc\n",
" train_acc /= len(train_loader_local)\n",
" train_scores.append(train_acc.item())\n",
"\n",
" ##############\n",
" # Validation #\n",
" ##############\n",
" val_acc = test_model(state, val_loader)\n",
" val_scores.append(val_acc)\n",
" print(f\"[Epoch {epoch+1:2d}] Training accuracy: {train_acc:05.2%}, Validation accuracy: {val_acc:4.2%}\")\n",
"\n",
" if len(val_scores) == 1 or val_acc > val_scores[best_val_epoch]:\n",
" print(\"\\t (New best performance, saving model...)\")\n",
" save_model(net, state.params, CHECKPOINT_PATH, model_name)\n",
" best_val_epoch = epoch\n",
"\n",
" state, _ = load_model(CHECKPOINT_PATH, model_name, state=state)\n",
" if results is None:\n",
" test_acc = test_model(state, test_loader)\n",
" results = {\"test_acc\": test_acc, \"val_scores\": val_scores, \n",
" \"train_scores\": train_scores}\n",
" with open(_get_result_file(CHECKPOINT_PATH, model_name), \"w\") as f:\n",
" json.dump(results, f)\n",
"\n",
" # Plot a curve of the validation accuracy\n",
" sns.set()\n",
" plt.plot([i for i in range(1,len(results[\"train_scores\"])+1)], results[\"train_scores\"], label=\"Train\")\n",
" plt.plot([i for i in range(1,len(results[\"val_scores\"])+1)], results[\"val_scores\"], label=\"Val\")\n",
" plt.xlabel(\"Epochs\")\n",
" plt.ylabel(\"Validation accuracy\")\n",
" plt.ylim(min(results[\"val_scores\"]), max(results[\"train_scores\"])*1.01)\n",
" plt.title(f\"Validation performance of {model_name}\")\n",
" plt.legend()\n",
" plt.show()\n",
" plt.close()\n",
"\n",
" print((f\" Test accuracy: {results['test_acc']:4.2%} \").center(50, \"=\")+\"\\n\")\n",
" return state\n",
"\n",
"\n",
"def test_model(state, data_loader):\n",
" \"\"\"\n",
" Test a model on a specified dataset.\n",
"\n",
" Inputs:\n",
" state - Training state including parameters and model apply function.\n",
" data_loader - DataLoader object of the dataset to test on (validation or test)\n",
" \"\"\"\n",
" true_preds, count = 0., 0\n",
" for batch in data_loader:\n",
" acc = eval_step(state, batch)\n",
" batch_size = batch[0].shape[0]\n",
" true_preds += acc * batch_size\n",
" count += batch_size\n",
" test_acc = true_preds / count\n",
" return test_acc.item()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"First, we need to understand what an optimizer actually does. The optimizer is responsible to update the network's parameters given the gradients. Hence, we effectively implement a function $w^{t} = f(w^{t-1}, g^{t}, ...)$ with $w$ being the parameters, and $g^{t} = \\nabla_{w^{(t-1)}} \\mathcal{L}^{(t)}$ the gradients at time step $t$. A common, additional parameter to this function is the learning rate, here denoted by $\\eta$. Usually, the learning rate can be seen as the \"step size\" of the update. A higher learning rate means that we change the weights more in the direction of the gradients, a smaller means we take shorter steps. \n",
"\n",
"As most optimizers only differ in the implementation of $f$, we can define a template for an optimizer in JAX below. Note that in comparison to PyTorch, the optimizers must be functional and have no effects outside the function. Hence, we follow the basic implementation principles of [optax](https://optax.readthedocs.io/en/latest/) and define an optimizer to be a tuple of two main functions:\n",
"\n",
"* `init`: Given a set of parameters, initialize any state variables that the optimizer may need. While is might not be necessary for the simplest optimizers, more sophisticated like Adam need to keep track of gradient statistics, which can be initialized here.\n",
"* `update`: Given the gradients, the optimizer state, and the parameters, return the updates that should be applied to the parameters, and an updated optimizer state. \n",
"\n",
"The updates can be applied to the parameters using `optax.apply_updates(params, updates)` which adds each update value to its respective parameter. In simplified form, it applies `tree_map(lambda p, u: p + u, params, updates)`. As a reminder, `jax.tree_util.tree_map` is a function that runs over PyTrees and applies a function to all leafs, returning a new PyTree with the results. If we input multiple PyTrees, it runs over them synchronously and applies the functions on tuples of leafs, one of each PyTree. In the function above, this means that a new PyTree is created for which each leaf has the sum of the respective leaf in `params` and `updates`.\n",
"\n",
"In contrast to PyTorch, there is no `zero_grad` function since the gradients are the output of a separate gradient function, not an object-based backpropagation through a dynamic computation graph. The template is setup below:"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"class Optimizer(NamedTuple):\n",
" # Given the parameters, initialize any optimizer state as tuple\n",
" init : Callable[[PyTree], tuple]\n",
" # Given the gradients, optimizer state, and evt. parameters, return\n",
" # the parameter updates and new optimizer state\n",
" update : Callable[[PyTree, tuple, Optional[PyTree]], Tuple[PyTree, tuple]]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The first optimizer we are going to implement is the standard Stochastic Gradient Descent (SGD). SGD updates the parameters using the following equation:\n",
"\n",
"$$\n",
"\\begin{split}\n",
" w^{(t)} & = w^{(t-1)} - \\eta \\cdot g^{(t)}\n",
"\\end{split}\n",
"$$\n",
"\n",
"As simple as the equation is also our implementation of SGD:"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"def sgd(lr):\n",
" def init(params):\n",
" return tuple()\n",
" \n",
" def update(updates, state, params=None):\n",
" updates = tree_map(lambda u: -lr * u, updates)\n",
" return updates, state\n",
" \n",
" return Optimizer(init, update)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that we define SGD as a function that returns a tuple of the init and update function, which depends on the input parameter `lr`, i.e., the learning rate. SGD does not have any state it needs to keep track of. Hence, the init function returns an empty tuple. The update function simply multiplies all gradients with the learning rate. The negative sign is needed since the `apply_updates` function *adds* the updates to the parameters, not subtracts."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the lecture, we also have discussed the concept of momentum which replaces the gradient in the update by an exponential average of all past gradients including the current one:\n",
"\n",
"$$\n",
"\\begin{split}\n",
" m^{(t)} & = \\beta_1 m^{(t-1)} + (1 - \\beta_1)\\cdot g^{(t)}\\\\\n",
" w^{(t)} & = w^{(t-1)} - \\eta \\cdot m^{(t)}\\\\\n",
"\\end{split}\n",
"$$\n",
"\n",
"Let's also implement it below:"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"def sgd_momentum(lr, momentum=0.0):\n",
" def init(params):\n",
" param_momentum = tree_map(jnp.zeros_like, params)\n",
" return param_momentum\n",
" \n",
" def update(updates, state, params=None):\n",
" state = tree_map(lambda m, g: (1 - momentum) * g + momentum * m,\n",
" state,\n",
" updates)\n",
" updates = tree_map(lambda m: - lr * m,\n",
" state)\n",
" return updates, state\n",
" \n",
" return Optimizer(init, update)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We track the momentum parameters $m^{(t)}$ in a PyTree, which is initialized with all zeros, but with the same shape and structure as the parameters. At each update iteration, we update our momentum parameters with above's equation, and use it to calculate the new updates."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As a third and final optimizer, we arrive at Adam. Adam combines the idea of momentum with an adaptive learning rate, which is based on an exponential average of the squared gradients, i.e. the gradients norm. Furthermore, we add a bias correction for the momentum and adaptive learning rate for the first iterations:\n",
"\n",
"$$\n",
"\\begin{split}\n",
" m^{(t)} & = \\beta_1 m^{(t-1)} + (1 - \\beta_1)\\cdot g^{(t)}\\\\\n",
" v^{(t)} & = \\beta_2 v^{(t-1)} + (1 - \\beta_2)\\cdot \\left(g^{(t)}\\right)^2\\\\\n",
" \\hat{m}^{(t)} & = \\frac{m^{(t)}}{1-\\beta^{t}_1}, \\hat{v}^{(t)} = \\frac{v^{(t)}}{1-\\beta^{t}_2}\\\\\n",
" w^{(t)} & = w^{(t-1)} - \\frac{\\eta}{\\sqrt{\\hat{v}^{(t)}} + \\epsilon}\\circ \\hat{m}^{(t)}\\\\\n",
"\\end{split}\n",
"$$\n",
"\n",
"Epsilon is a small constant used to improve numerical stability for very small gradient norms. Remember that the adaptive learning rate does not replace the learning rate hyperparameter $\\eta$, but rather acts as an extra factor and ensures that the gradients of various parameters have a similar norm. "
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"def adam(lr, beta1=0.9, beta2=0.999, eps=1e-8):\n",
" def init(params):\n",
" step = 0.\n",
" param_momentum = tree_map(jnp.zeros_like, params)\n",
" param_2nd_momentum = tree_map(jnp.zeros_like, params)\n",
" return (step, param_momentum, param_2nd_momentum)\n",
" \n",
" def update(updates, state, params=None):\n",
" # Update momentum and adapt. lr\n",
" step, param_momentum, param_2nd_momentum = state\n",
" step += 1\n",
" param_momentum = tree_map(lambda m, g: (1 - beta1) * g + beta1 * m,\n",
" param_momentum,\n",
" updates)\n",
" param_2nd_momentum = tree_map(lambda m2, g: (1 - beta2) * g**2 + beta2 * m2,\n",
" param_2nd_momentum,\n",
" updates)\n",
" # Calculate update for single parameter\n",
" def update_param(m, m2):\n",
" # Bias correction\n",
" m /= 1 - beta1 ** step\n",
" m2 /= 1 - beta2 ** step\n",
" return - m * lr / (jnp.sqrt(m2) + eps)\n",
" # Update for all parameters\n",
" updates = tree_map(update_param,\n",
" param_momentum,\n",
" param_2nd_momentum)\n",
" return updates, (step, param_momentum, param_2nd_momentum)\n",
" \n",
" return Optimizer(init, update)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Our state consists of a counter `step` that keeps track of the time step $t$, the momentums $m^{(t)}$ and the second momentum/adaptive learning rate parameters $v^{(t)}$. At each update step, we update $m^{(t)}$ and $v^{(t)}$, and afterwards calculate the updates for each parameters based on $m^{(t)}$ and $v^{(t)}$."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Comparing optimizers on model training\n",
"\n",
"After we have implemented three optimizers (SGD, SGD with momentum, and Adam), we can start to analyze and compare them. \n",
"First, we test them on how well they can optimize a neural network on the FashionMNIST dataset. We use again our linear network, this time with a ReLU activation and the kaiming initialization, which we have found before to work well for ReLU-based networks. Note that the model is over-parameterized for this task, and we can achieve similar performance with a much smaller network (for example `100,100,100`). However, our main interest is in how well the optimizer can train *deep* neural networks, hence the over-parameterization."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"model, params = init_simple_model(kaiming_init, act_fn=nn.relu)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For a fair comparison, we train the exact same model with the same seed with the three optimizers below. Feel free to change the hyperparameters if you want, the models are relatively fast to train."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model file already exists. Skipping training...\n"
]
},
{
"data": {
"application/pdf": "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\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"============= Test accuracy: 89.61% ==============\n",
"\n"
]
}
],
"source": [
"_ = train_model(model, params, sgd(lr=1e-1),\n",
" \"FashionMNIST_SGD\", \n",
" max_epochs=40, batch_size=256)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model file already exists. Skipping training...\n"
]
},
{
"data": {
"application/pdf": "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\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"============= Test accuracy: 89.30% ==============\n",
"\n"
]
}
],
"source": [
"_ = train_model(model, params, sgd_momentum(lr=1e-1, momentum=0.9),\n",
" \"FashionMNIST_SGDMom\", \n",
" max_epochs=40, batch_size=256)"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model file already exists. Skipping training...\n"
]
},
{
"data": {
"application/pdf": "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\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"============= Test accuracy: 89.06% ==============\n",
"\n"
]
}
],
"source": [
"_ = train_model(model, params, adam(lr=1e-3), \n",
" \"FashionMNIST_Adam\", \n",
" max_epochs=40, batch_size=256)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The result is that all optimizers perform similarly well with the given model. The differences are too small to find any significant conclusion. However, keep in mind that this can also be attributed to the initialization we chose. When changing the initialization to worse (e.g. constant variance), Adam usually shows to be more robust because of its adaptive learning rate. To show the specific benefits of the optimizers, we will continue to look at some possible loss surfaces in which momentum and adaptive learning rate are crucial."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Pathological curvatures\n",
"\n",
"A pathological curvature is a type of surface that is similar to ravines and is particularly tricky for plain SGD optimization. In words, pathological curvatures typically have a steep gradient in one direction with an optimum at the center, while in a second direction we have a slower gradient towards a (global) optimum. Let's first create an example surface of this and visualize it:"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"def pathological_curve_loss(w1, w2):\n",
" # Example of a pathological curvature. There are many more possible, feel free to experiment here!\n",
" x1_loss = nn.tanh(w1)**2 + 0.01 * jnp.abs(w1)\n",
" x2_loss = nn.sigmoid(w2)\n",
" return x1_loss + x2_loss"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"application/pdf": "JVBERi0xLjQKJazcIKu6CjEgMCBvYmoKPDwgL1BhZ2VzIDIgMCBSIC9UeXBlIC9DYXRhbG9nID4+CmVuZG9iago4IDAgb2JqCjw8IC9FeHRHU3RhdGUgNCAwIFIgL0ZvbnQgMyAwIFIgL1BhdHRlcm4gNSAwIFIKL1Byb2NTZXQgWyAvUERGIC9UZXh0IC9JbWFnZUIgL0ltYWdlQyAvSW1hZ2VJIF0gL1NoYWRpbmcgNiAwIFIKL1hPYmplY3QgNyAwIFIgPj4KZW5kb2JqCjEwIDAgb2JqCjw8IC9Bbm5vdHMgWyBdIC9Db250ZW50cyA5IDAgUgovR3JvdXAgPDwgL0NTIC9EZXZpY2VSR0IgL1MgL1RyYW5zcGFyZW5jeSAvVHlwZSAvR3JvdXAgPj4KL01lZGlhQm94IFsgMCAwIDMwMS4wMzIxMzYxNTY4IDI4My40NjA2NjU1MDg3IF0gL1BhcmVudCAyIDAgUgovUmVzb3VyY2VzIDggMCBSIC9UeXBlIC9QYWdlID4+CmVuZG9iago5IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMTEgMCBSID4+CnN0cmVhbQp4nMR9S49sXXLVvH5FDs3A5f1+DG0ZWvIMaMEYGRuwKo2gZfz3WSsidt68VMT5Pt9M5G65XfecrKzz2DtixVrxyLd/+PiLv8y3//anW7r9A/7vn2/59ofbX/z13/2f//G3f/cf/vBXt7/900fC8ftHTfkz1ZLrwD+/nv9ZVv1sI40xcDz9/M///vHxjx/4fvzOH/DV/+1jfpZbTp+zdn7g/lH6/BxPR77sSBn5M59D/KWfDuBr/x4XXuTCP3fHH8i4dvnxD3bk46OMz5zGLvM2y2ebo6yMv5jT+px75tVvueXPudbCx79wHH+3zZnzrfB4T2k2Xg9uNKWy1y3P9dnzmnXj8MdffeDv8M7wv/I3+Sf9L8dt4h9t9d4a7rV+lpIHLgtf3gb+kWZpt5LG5ygdH7q4GP2rpevfLXa35ep2x/ico+IEHuFnr3OvLn/Yv6Do6eAP/8VfVj7vcvsbPGwsls/FR/5tufyLLuPjP2LF/A2+xV4g7uN/8Q57woPY/JI/T581pzZyXTXf/p9/PH1u5s/S+l6j1bQ+cvsseFNp59z27W/vH3/1R65j/OGMh/XH//rxF/8u48Zvf/z7jz/7539z++M/fKxPvN6Z066z3/484+mncT5ablM+meWT//aPH//+w+7+c+yU90hztW8PAq+2591XvY3+uRKudfJBFPylMmrGg694VDONxedeJp/72Fj6ODxaGU2fz8QfqR33dcPG2LXmym/puPmaer3lsj97K3Xz47nnT3y0zIlvwe/hZFn6Nbt/loRbKre2P3dOOI6vmQ0XU2vZ+J6Ci8x5VH7P7LyanfE9peEt4sFW/Z5cElbLaLhhro86Vm38po3rz23iTeTcP3draco6S+mz4R+p3/BC8JtrZ7ui3PBHyuh93CpMRlqdCwUrEV/U08IlYS3usbL8Qikdb2/gj5WcP9dYs9kVFVlAf/hoMBM1NewTrLWG6640MPgjabdZ1200PJuc0o7WHVYUlhsOVLz+2gqWQsHib1jGuW68y4YrkbV045rQ5bM+61xb1kriavmzdhYJF3Lid3Lh2Q/4bfzqn//13/3Df/lP//Qf/8s//unP7//jH//pT7e//p9YU/9eb0VW1s9LCYu7Yg3gAXWYoA4LtHFrY+OGy2rj1rFiFtZ7uKUet9bxzOccveDeyq22z8o9g82P9/mbt1b+P9wa1iVMDBbiDUu6t1ESF+aun6ukhkXdFpc/9ot/az9fMN5wx7YYc/ZFO5N7r2vVXmUj/1ni9d9w/dHFcHHvhEW0+NbrwsIX44WVC2OCN3BrWM515bOrLi8HxgRbcKaEy8D2zdzheNAwWe3H47y8HJiQulPv8qZgKHhbuJyG17Zxp+1Wyyf2TRq/52pqx/PAV+JZYg9g7cxlxlDX7NWV+O7iX2rWx4Y/wYKCkYPDx1fgUYy1aOOf/vXT52jGsCRgo/YY+YP3C188aB/fZtbLv8is8zHCTsMQ5YVlgStJhfgIZnjXgicL/DOXWj8ihr0bbMcN59PGf+3xwFBjVZSO5wYL2Utrndaqt8+FFwU7s/k4ceXyNbtg1y7u+o6HXwe8mn4NHv+o8HtmFfNOsn1gGfocsOBqQ/GNS2woIAZ8D3YTTSRuYZzvWbR4edYKe4+/Beix+T24FWyHSqPOnVFgNQQR4V76xpZdfDmzVLupTX/WFtYl3heMxwSo42aeuDKiHHi8IjZYXF6Bme177DVv2O5pyjb9yaLnOWkG8LD5+NrAR/ioM64W197mulXYqDpT+23Dl2Ec4GMAsAruE//8zHQhGw9z/OsY9bwzzUNehW91wEUuuTtYROyxSYePp8WL+G2PRfe7gTBgXyoQMh9z7/B1iRbjX8Wuw3p/Yhtjkd8GHPOa2LN071iP2LvwW1yCpcB4BO/up0suwBQVKGJ32IZ6g11sRACwSHh7v8u0461jAdedC1dtb7vuaXCj1kb/M7FpuErb77keoLi0VtlYerCJHZCq8do24Nzvs+00bIAlHXBuE/10oDleDzYOPDqsyg2bvgHA7vl7rod+ifB3pgIwN7GfcEt4OM2u55ctfBSh/OYVAVo2+F6Ai47tjv/BBaaaO2CZur+v//mnP52r+h12t8AjE9zzAvH02+Zjsniu505PTW8EaJ2WhlYwzgmv/bax4EdPB3cCGH5Omg/YI+6wDdDR7IsKjlZaBxrQ1GcWO/U5plwSoDK8MG4gn2/C3wBGBNCkqcr4IW35Jqw1GheC3sqFO7G1iWE/G/YlLjsD1pS94Y3PN43PBIPY6A+APDIs5bJvGnD18CawvbCd2C9Lg1J8M5zmjRA+LXrMn20n3yfeP28ST4v7cOrrxCUTzDPgWEC5vwfIFNinjPUJVI6blccAd8VnlXbR7ffZf3uB4f0leLcsjx2esKhFkFuH78QXwyvuWdRZ/fZFYYEVLJcyuakRe8BYJni3neaWi0Lg/tsXhbUAl9eXvMHGt7bkovA6GX7j8U144tVL+l2rnvgaFrgD6THCQwiMBVux3DIcql7U73hSeEeE5boYsB320ovCQiZmACxKjJIQbZXfdVETSwTfAltCHApfgSAaiGrBQqi1+vGk/tftmaLhK0cMCGje7H//99/d/vPtHxl7A+00ojV4Emw//JDFnd7+N9mef/64/MQHMDViecRzBhZgmeGYBWvjCSUY0oLjCEmx4hVKZTwJXDAhCt1bxeoTwoIbDJERrB6/B7FelsCQnwcmwkaT463hXrYcJ3G1sFzkOB5tOYQSrg8XDPuC1dxpAOWHSsPBe7o6i/sZXDGJuDQPYC5YiaUIGS+t4dHjodpHBERlYjRY56xmi1tfaSjE+1grjOV4HC6rtmafB7jjMuL3AA7CXshx7GNYxYx4mV+JPdDH0x0h6haqpC8GEvyBW7faHcVneUdYhrBhNHwwMnjcMGOG+RnTAI0CveBNANUOu5LvTyC+Qn7PgJMhSsU+IbknyzkPRPow3IPH4fbn1u+3O7pcd7+15rw1dJc1BF+RhDbBlQChNrkSoI6E3ZwYhwBew7eIaeJx7PJUt3wePo4wi8cRgOJ7tq7dSfc9LtboO1adt4rusooAjwiMeRxQEA9XVhctLMKhLqsI3nyIj+MLQGgq7gLvrsBlrWyfbwxYddXlLJF6vErf8I4YsJS9tr4j/FNiCJoLMn+EIZWEKB5Gte2MkLrKq+C1wr9MO77prbocJy6zVxqZkcjseGbqS2P7SijDjw+g2zHe9EY7AOBEfKP7PJOJkl0HI447JTE7SLCR5ZDdQlYtiUvHcTyumbIdX/S2+nkcRBh4ZXdCOxXt6sEHBkgnxxEkdoEg79il3q7jEgC6yw02S1/1lAiGr2h+1l3O0sg0JLo0FkPutZYcH7NtWxpYsNiLutkBSdvVnn6HHa3YgHgTtJf4EVtuyZKGfcXCQTR843YibTW62b/vKyB+4ldvyLfTnl3X4zC4iMjlOBZKl5X0jjfqbdK7bMYGnN30jWJ79318Om56VmWxN266m3mtjNf1hZaR8QQuzXRk1mMb4NmMd2xqb5PeZTOSZ2YAgeNlIqbdZl5HL4vwk5t0t6JEEIngDHCqSyPhAeRjpn2zHriBCyPgGY3HJliEg0mkKVwoiSvajLMJwrN8AoX/hL9HcEVaA3ehm6CSui6libwGAG6bOlykPjjg5yteacH3T1Jtq+gawPcjmquddB1d7+77XYvaMztKFvcJ6KnkJTwV1qasro1/AL0vOY53OtXwFIbueyz9/EbQmYp9viCuEzDB187Y+MKsyR1JwEilojX7tsYQT4NbbGgaIdlTiJQkHqYfQwiLvaFUKx+huT0yiL3IYdlS5dLdBu7Z8+Z6GEFX7noP2IEttTftNEAwREcMvigDwS1PdZ9czmUV7kDY3QXD0MxILmwd2TmVOJXoTY0qAobByBKfb7CieV+628g9R8a8Y122IqzFJCTs9U3L0rGdd7Gd2NiAdbr6asN6MtuJ70uwKKVsGBHYhG5OcsAw2QLoWKy1XjrbyDlHttm35ecBkDjSW2zwxPLWB96TPYD47Eewz+6q7ZCK0ZWeaqFR4P7DusTrqPoEBjfUtuMwTK3pE8D/LdnGhVQ57KhupL57URMcbON34IdCEWNLlARTDfdlhpMkOA0qQ8PBxW2G8PsGCBdcvD4jcOKBmS+5SLhU6nS8zE3tbP+wSq5/YpgCSI2jvVhoOBEaid/Clhtm5XH3dNGyamDy8X6xqOX4BFyb6i/p6SdlOYlMBm3XRVjzjjDFsZvKXiQEuCKkbCqbfR3IUeCREDzxOD68z2H8lWJCF5MVdr0CQBFeiq2yZ8XfYWY9s6lsB9YMLlLMZmJKxjbAUWuqXc1jBojdh9XYu2Qxs5SmcRP1CgBFgOnCLHtm/B2AJhNYYGXfqEeVtZdyCdgI+NAuygnjFn5j3/igO8Y/EV7y8NWXXOaCseIDw2XiKnPd79kBrue4i4fALeK/ak9x/+uEY3j/lXgGxwuWlVIJoibCdC7dMmXybV3gpRBfxZ7J82QHLzFdCW8my1+fU0h1Jd5hUMWf4XjLq6sZpX410jkOLzeEw6c9wEqlmiV3jW13ga5CMOaBty+5SLxzSWrgo6AtfkYLLzhL1/nRWVbqE3urvcKPCJjEy1HVwQXyNgntllmaQlWcbJc8LbwGtWP4GiDumvT4wuPpJfat77BLhPtrCEuKS2ISgYXaWJGVmxWfaHDN5aAzbA6q9rKBsG1slwHNVKb/yOfzpsZ8iRYjdBk5Y/wyNcgsl7ngAvqb6DPP0SjDCd83k24yWByVnoSxhJOq+j5hrCwdDZu77LySbtYKs6lgKYSLEbwMHZnn996B/jwrcxdr0usS18kbxb2tA9uwQQW24TjtzV4G81rew1Y04saqyCREiwG6DK2Yb/XeABdd13kXDIbbLlNpolrmaAadsH6wGAU67YJLygdSwRvTo5I9ggVM6xKaRVAuoiZ8KsMeQEn44zfmBS16cmrlZU27//gkLQDPI/rE/exE5XZXVS3w9wBMeN0LHgEX1K4dp08c8POpYvXwOHwEnr8hEwAsCob4ns2ApvWfyKNSGAPxlXWaIcl1w0M6LzQ8q3cE4F5EJyHq60lyheRKmEraFLpjz7f5uPL/xwbGNufKRvkBxvdwRHEGvWjR5TKwPsdzPPeaIPDd496Ngd+wMLJzZ+o7VQO9TIQiv1vIaa9SDnXBPCsy/HRdrWUDzwE0D5B85NI9//8OB+053Ls43IFXTBaIdquXoXiyDOK9WtTOMb1IdYwymfSyqj4VwJyiCAWfx7ZISe8e69dwju/Q36NvfHe5lkk48dKXHMdazqZvrk+8BW7bUTWjo9lhLFQgJPG4wIBrHXnDDzSiwCTy6D4CeEPg0LGAsIVpnxc8RQdUmGagUm5NIoGBbV6LyaT+fvPj7av43A1LvChGrRmMAnPJeJEAnOn59l9y0B7iuKv+MpmpKMeZJ1MMvcNS56nrNjHF8og+sJDYDnIcEX7Nhx31o4woKokAjQ+ALGpwUcNdUANsGBMmZff1aY+ZiUOIPAc/T1Pd7K0U5orCbahNqnAxPV/C7AiWR6jERzEn9iFUJcWsdzGyZjsneIfRs10UnndtFpwkIPa65B5Ww1uedhwIZ/RiL24bUAgjpSiy8iKxL7mcunE9ZqGwV59lqYxN2qp4zMVFJcYGC+aYovDsh8XGCE6a7v1VGW4rtQazMcQmkLROh2RoTL5lMg5/lcmER3qA6xlVji7a5H0ZW0SxSOC2iU+w7dXOtVzf5FhcN6maXEoqmuE17wUY1w3JAyCx5ITHR8FOPMdx1WcjAsic41FkEUUioRv2vPYDJsLDbIGCnclQhIIj4S0aTgzP0g4zezvTyDLdr42lWVY0fQnelHiw41KLyS6hpfQJlitCxsehHm79EndBWYt+EcfTLJJ+eRYA/eSUVwzjIW84Ee7r+w9PfgQ4QcuTqPy3eizVMpZcik1yl8MV36hrnzaTyetNV0s31UMgBtPHzK6lY+98FPKO5ez5CVXjMlVCvUDGCfPEX3iqS6wNbmjg/ovFcdyQTMTkDbWZFFVGcWIUV174Ic9vvUMm8JCPpgL1sVYy4h+3Vo+WjP08Bfdv6oipnFQgGANZuML8Fw1k4kAxiCtjBtdjfN8BlT0nexdnWiaQo75qSgD5QFxEO6XqUseeLwqhWDg0YKz1e/B743Hch9YRFI+duOf03xAp0lYAQy59pYwH1zaThvfbmbvLEG/VZtDSc4CRz7lwUH4Y6oWtehxrTNIBub6IrNZ7FoCLUCyxuzSFlkzyTVr3wpitJRLCcpygOR3xO3NB64LB/dR+5BQ3sowi0QsE5CGmdyAaB6Go+N3aSopQGFjkw3Ii1sc6VoTS1uonoahWEip85SWxduMqEosCtxj/OHDpHYEVNl+SvD1KI3P3qZpcF+u2WMUkUsrSBOFwffpMRsx7uFGbG+Xp8cwywCx5Kq3stt6le3sATZV/lj8UXf2FxZHZIhwY8yQRzuBXAvJaxFUQ+y1d/fhFZpZdRWJB4BbjPw8vvg5oHICCu2eZDY7KZeAG1rCIiakzcNJbDiNO20oGMfWPBYbLTMKR41RRKvYQseVUgQnwz3uyGL7jE81i6AnPTy8cnlQLmiUtAa+H6e44jo+bNIzIkL43KZ4pWIUjX0akUQQb8eQ+XrInwKrlRSNFATPzZoEyEj4sT+DiLLczC1TETWysE2y9sm034+0Ppqhtplvjd/cVfg54WX7PhCNgwhgr7mCz9YZoReqQakX83ZUkPn6LfXKZ87sW2wMzEEDhRzxeTbydk+mbWWp8cE1wkxpYTSJIWZe0ILh4WBM5PlixjMUkXwMfnxVuBDkTr284Dz7dBSYNOiddoUw5yAf7Ew1N3Ym0KmpXuJzqonbG43Sw84QWbsQRBSgROvPR3DvgBpzj6Lnr0geOX5rUkhpbHjTBm2IzdQclwMTSRtUdirc21K+kQb2MbTZkh5aj6Id8S0DPOGTOl1zkZr1/sf2ZdZ+/A2vgn7CLDJTp3+E9WjMeE7uZZoYfmbBJqsMPFn1hd2M90zlufPsjM4L9QpZ8vs/0SAB1yZaIm4mgLMN2WOuhYAZoJb8LbXroUSsVOiv19T3PWZJa3JwZ7UxbFo016Yf4gFHG2rV9hHd+HKVPuEQETaR7+Gj2HQwK0xVGYoL5Yu0kvI8YNJjQQUvUpeqatGs/2MfFRAHZfEVOewyNS+jocRwoNJis2O+SU/tjCQypWOdLhrmpYsXrPlvg4uyHDyLuAiIAtnFHcpxaluYoV8mGaGIwYAz2tjVauXV72boycGdZpUbWrWGRDD0OJ7Z1Twcg5R2ow8OEWnoxa1XjIo0Jtu46FlVn3ofe6eR+NPZjsAHPtj1g7YtC1iVkaSLM6WPUd4itTpCjifr4G0kia/bG6SudRH2+oqwJhuSpdc1N9ncgqlHxtColHFIuAUVzIWZ54tfrLt0DkXdN11m1jGWuOy0Dl42EZNL1jODR3j4Os5ORYEuWffdirjsiXCKCJsKoPqY92oyHM+6CJ5IwkXq1Va0AAwR8btimRECY5znOglnBDdSI4HNOJOAGDkGcEaMYD/S8gwMiah8w8rIi2YZJ8xI711KpxrvlVk4+g+fGY8cZO9qAY3I5KbPWiH637ZCVS3oTD+gCrbtm0aVOkCYLo7KjigEteIosEjgWxgSGP/TNYDm6fk1Op+7P5YxCjilCcT7qe0fcxIudqWpXEJjGQ4OwlUCmTJw3u7OkqgA5dJuu8HClU7hxmRfG6eFMyqzIVcIorHdRYB7M1BRAmBXWmQh+WC09CjT4fd1wZkojncQAFipLAgCW/IThfFQtu6RZwLGFMNYBve8IMj2WXju9NZJjWTtG0OZ3iw6lxVqVvAA4PlMvGU02eCNtjLCXcnphTBqEsHGumJdb9rh9hHFDbhAoecoNdsokdvvhWYWkZJqEXiMwaEnT/zoLJoGNu6RFNDaUylfWKSCpQ9Iw4BhdStI2RW1j6nPMeAL9XTqYF2WorAvPvrL6ZPxmLYrIGgEk21kJJoVJLKc+B150mxNls5WTLuGThhHJGAcxXtBzHgA2tNwgzCT3N9Ynazv09qNzHwHAvmvrs7VGVV9eqvRgodMmZVImmxMSszTrRgQoCnvHhSafZ2Ms1bQq3cNc4uTZ07FNrVYIAPzLeMyF15rMyh6bTJ+W68CzOCQdXWothmWAAx7JqbuzLFhefrHs9JAzDDjGC/Tuof2DxxyQqAlsZeSd7VoBfxWPcdUi1rR7wG8W3Ur0trByWV/tSJYoE5FKEQkVQ1APsp5EmcxijGmgj0KG1uQnANRiAk8XVk7tW4LRh1XperzCj1hz1cZmbG3puiIzZNxNRA0FTJJHPPE4ZRZEw/Y+Z3pWVl6Kcz2MfBcsDBOp77ZxoWzD1IW9R1XhpIA4u144u8Ilybzj9+AlZUVaYWAcBdIhBvcg+wNU9DQENjfiBoENJA8OqAjPqrDK+ltW3RAXS82f6qrYtADhgjVgJMaPZFjW9PA4i3QQ2B5dtQA62+eLNIa8XVFjEZUWYHb+Mpx2NcwCGLifrGpjdzDeIrwfXhWBZGZsog/g4iwfAMuuARnZBQzGDgtaO11J59FJcpktifAqirqPCPX55Do/DnNCYoodj/Cxqs168PUw74tuJYnk3OZzGuIvG1YX8mtOMaxslfyUThhddMGxC0jvfapRyqw5eiQJw60kPQ7slB6dBHyuL+AGL6KKbyHIO4g7cuLEK5KDBO9f9wkRKPxS4V9YkoBl4zBrPozxxcxY/IyIQY9I1NeP9Uyuibn2A8/4p7on5r/Kit0AuYoFgDwPTojPfgSe/y6eH/HyEBxD5J6mvri6mJGo4R37wa2pllv6UiJk0EbJQNvDLN2iie5Vjy866HaBLF5HCh6M06xaoOXU5/l71tUlD7Ugen2beSoK+yZ3a+pKkgA/nIUeEX0RMRjjRAdWvoO388IybZsD0ECmUApAF2tubkqt4YPFGDdYgEdXLlib1rVaZWr9wwXPF/GCUa6Em1nxOm/n4T5NR266FARLCci6KYE2ZmUpCN8+8NBWP1TIC1SDLQX2WxWEiOaLWMEYVjoo9PHuK9cC324eEt7SHLZ+3n14Vs3Z4q7a+jKBVDTmYcP01fmM+bhhdi1jyfPmsfe88rYuo+YycGrlGHhmK7WXZuXvwWcuZr4LOh5MTuj2nkcbh33Eeq92nFZL8YYm3vas6wLG0lL8Io40oFRDUO5B+FdDPg9q3gVSck00haZpSSyvIRysklqgypbNFgdX4s6asz4S2OVkEDQKEaOQMoKyPvR9Hcl4oYYm8Ve8kGX2PY1+kuxZgGdvuGOF1yM2F6Cgs/XxUtNJVfO50YhLjSMZL/J5AzR3sbZWxwFfsfMRUQeClHrq5xEtsGm+7PdkrbK4O6y5YpI+Seu04vLJwYhMjIC8D/zfwfZ2trtg+tmWKROqQXeyd5WpO+wdnqkQjUug5UukMTccccke9/wlVwnTytvIm3jYAqJ3EH5y13Cqkn+XZ7f6uE4Rpli6HsyASVChbfbViCv1wucTPf5RHwy7KydNE4R1nO2nnN8XCF9PU9TWKliXksWIndBry6d8t7JRddHnRV3nZAmx9bJ8ftDOLQW+IT8c8clRlrifVf468PUiM2sjSyVR/cJkD/yTbTFpztUviM9+lKXIkAF1oSMlfaEhPxrxqVHk50eK5/5xY6lJsLK0AFY7Jev9hyc/gsDkLoEJe+sLxNOVoIa7ZYZ+wK83dvpvdZmla0Q8ZUlOMruHp6URaGMav7QRl+/vcGdXgc87qIZGQpwDcrAHaSuWevQutpiF1xyZQEZPPW5oc1yFKWQmIiLDIz6+5CrxcLP0Ysb652SNtyxnLy7TpipYU7SD6rdHs3iKNSdJoRaRQNrrJFoA2+Sty39hT+vyjBjiiFEO4z4/TrT750CZTUeN9TQT77EIMtEHcHGWr5+9xitdC540c06bJvLigddS+Gdg7RjJzlIuX5BPHfF7NhPuh3wPMCVwsxwHYIR7ITKiTUlmMF8HaFjvsFLs6UIMjoWl/Qi4yrYUSvM4l9JNKVzY+CVHgVSwsPWquRMW8xv1WziyaRiu8pnmiJn2mGw9njkbQ80fQsAxntp3ufGidonBXtp6CwV2Vf8IDSh8jNmSNTmly47PzmZ/ansnW+fL8YjyjySCIB51o9d3sL8yhkRK9pg1jLdrS3Kz8mUL2pPpEqWeChcs266HU5/pUW/AtsJVDs/VbUGGZHFALkfRK3+316qQlMMHfmop8wpX5oVMdwmNYENn1rUKKGWvrTLRpWvCYZGZGmqQ65JhRVNdCZa6NR0NubWIi4tDMi+Ee0d87cXLWlwAv5Mli4fmY1dd6OxoiN00phyvk+X2dnznrfe5Jcn+60IsicSVOBj3gvdz+zC6rcgrBv7PgiJg7Y6mHJ/9CDAD51AVWZZyJZwFR7AjmIHJDUViT64tgCexbY2PbhaxIqzqLVtlSHw8sSh0ydfD8m4tXg8gyesW2YuB71aWldt5y1mwxpf2MK3SR0HeMmNXjYEBtykmqq9G0Hjk0EAsiMSFMMb2Y/Jj0PA+hAXFnTDvgAz/LgdiXZxViEUEKT1sYJOJJw/EwpWILCBdLveDnveDGj+L4SrrwZcXPDlCXTvrGXaT4+znNt9Cl7oxgDbJQlAryJMuphsnnDmQqRzzRMrTjvJFdX37lRHZKZPymfWIiY8CDD8geQdV7pEa2oGlIx5u2golc8zdmesAYECkIhw3B56dLNRGxUebSzOotzrBgFqPmPgoocpPwHr97XuQWSurYGG0gw/HD55ZmJy1M7lW5Tin/zyO71nrsMVieX0htR5R8TEg9wC83T1MRxUzLWMJeYMDb9zKxOOTHzI4FBuNG5WjicjTK5Tj6B3GWksnydHBNoPF3+F4DJc52mcUNsjCcQ7OXMv2OO6/TOniweGs9NpPb5MVgbJOgfCwNPFDIvIxMfPi7IfvbXRIIpu5yP5h+uKyAbeN9OMeLNaVoCfrPF/OWhx4/ETAmTyKDBrTz5MmE+TNWBgraV54s8f+lPFPTO1bVMEkWbGsx/4Mzyql1To8iDbqwirYFgAzkaXJ5EF28ylWJeCi0xgQhvgxEks8ccWMNkdt6e6nkvlTBPzrhIaHHu+CEvEouqBHrFWO0J1GRMCzEeoV2am7KtzmRDQ8XKkT48BYPNZ1RYBEhEmITn00+w606YVPWlgH6KkegTO2V0knB6rh9dqVpJ7KowkHy5RHN+qmDvt8pP5EalEcnnnh3MmZ8iJZzZliK7U2LZpIllqaREIbXT/PQcHlUe7G/mH2PfCjFilHSkYgfMSBshdYv6pKeQGAVgaxSqAr1N34xXoSowZ+fer8zcZ5vHKYxACWon4NELkh0lDEikSvOMT4Fo8ci4yLFJO7pDCDJhfIwBic+ORHYGBpkCdLYkQyIqu0l5VtyVSzLn43C/PcFHU2iotDniFb+3LKqW5gok5sgyYTpYFYbBBWYMDfITF9j+e1zhE2IleN5wuWej1JXnit5FVEJWCinsb/lQCQdl+Ig32AXqBIBfJVTBZ45MLL3TTdhO+7DLZlEy+20wOU51BEfTkcokn8o6V57HYq974kZtWEIMC6o6BzPG5Lm1AR38IQQCmOoMT5gJ/NOIA3nJifTuOZOGBcwU948iNYandZahzGyxVFlH60Ig8qxVCGn+c8bpoSdpUDYNdGaMFCfof4JyDsUXIxujZvFooz0ZSyRAMYeCoCD+MsP83qKi3LVxe/a5FKuOL3Gtc3C+0ZYf2U89PkNY0GTCyRCiKzsR44KTipQSxg0lIBajGV98SwnM/ADB5Ov4G3mifI9HGMn5URK4WBsOjpkPZMANWY8jZlR+zn/usvEeVUmrrqIdiareha5mxNvGTmorOjHhDTg/f+Lqt8RULGle7h0/BRnCAzTwvdN/mP+p4YzqVkbEoc3mVV6ASQtfNR5eBIm9DelR+p+wyJ5ATRoi6QY7vTKU/wVcJIVYwpH48ieofs6yWkaZdnenfpAsE5LOzKLSaVgsASLoXbBTvyNPUaCD6XLU849H7kXV8mDlTlqLDVK4N9PYL/TsjYeLidNeUfrhYrMp2JNY2uSgOKjTi9PGqOl24Ugig84n5ql31JLZLgYsLHI4iOQoq9qzEQtop0y8VXsA2tKqTx2Q/ZU2RDmOefZMqpPQHsQaBg4d32lplwVoXk22U/J+Mqh8PXXyPDUplzXLlHE9v9A9A/07cv8NFuyHeXkA8bXt+EFNXp7bfyKfW1RYDh5Ps/xxeDFvl0hYHVrgMRex2R3ZGg7sefr8eHG7aPlkeDArq9pP2wSfQQYVtsgf2oAVHmZLRUNLag+VLvnojbkjZMwff0g9VCCdIXLD158+sD64+ASa9xz/4UVQWMmpaZw5Bv3cD4yv0oAyeZLa+bM8BHPj1ysbk0cuNzaCf9NFIfA7EyJuy+03uPYGJw9zFcyAzaJFxgcpsFE+FZTVZtYzK/ihCjyFztU547ZKyJfKTk9CghxIYibyw+udf6IzOpaW8A4jEOXygWCTjiYyRVhuQRUzXZdZV/f+Ot/pSt8otRsUtUaM9R2Ilt0S8C4bVP7fyqDCLkeH7kZHCMS00764KAqVTfFKpugUoX8iA+b/IOJdUJ8+8S5jPMmGpa8CBSPrmniU0flPKqzcZd4jCgSctqWXA3dZ2qRV93jXTaiEXwWYc3MFsux6OV+cAgaeiLxnJf+yhjFOSWmjTEg32eynxROPR74PNLP+UyvlIXKXsxh+RxTi+T74gEESoxLCQ53uGOdDxNp1JT6N9JpsMMFHO5DsSPMHWMwCNmPwpvsV1Yv9vkeGYG1dPNv8TUe474Lh6XlX202ABf2Ndb76g18oNDmJ7JN2v0QOPkry6umAwQgIgy4SG1H0kBoad3cME7ZNfK91ZFz2y85a3EbhficZNJWjJrb4zrmNJPJo112kDW9VRgA3QVK2PJcbin3d/UL8kNw2wO8BbdTwx6b/OMTQe6L00NWl11PIYWcTSa2aeGHXel0waibhTh+RHhG6pUHJ5PW7MWjp0WMWY2YNbTZaLJMpV28Qz8jhSLt7+zSkNAJdl6mUYSbSTpxnntXh7865ywt5PvsmMnW1kvIeTYIFlJlkZ6KnFcM6k0YNpmXPEkWKNDzOSyeleuJqSQI8o5MhS+YXlDxaWbRn2XNhu4jibUG1tL1GZNG8m39c0OT4todTQ1cWRME2EZjuJJF2u/4bOuIUkbdfHwen68Trp67/IuLy2Ts1YaFW7Hsn48Hxm7pdCN+ZzuxUpxFtY7TJ7HPmhf+iFjVwXZ4KmoS8qcktcVwQjkne3RkkH7xQhC4ij36+SEIJkhJDd8MuQdanYjBhhbJ3AiXiwPnhaR+yIxSvGicEz5cW7f4qMwIokDmEAs97R19XlsWWLjgZY0+H0T5vXC77s2ayi7WSxASJpOcwcqeOKAMuMCrZ9gKwjSW7Zgapp6Q6FsGsmsUXTvswGvy/lODKN11oXYQ7EXduFR4RfCIiCgolBtz6Imq9JM16SYDFa5alZJJP6HyQJxiOSFVO8Q8x3yQmcSrJ6rvc4Cx2xtmYeO9TXWKLOCzI7TVC2LHIEdyym19LX/KFcgIkd8MuXVgN8L4LVviMzQ07tEoGTFJpUzYLbMOeXrxMObR78m8yRWi09lWtuISDaPVPaYIHD4hHdwPR53YyNmJidiyPHJFyjoCxsEq5C4nmrVSNZkHMdhKDlyTlgiGPN+NGJfaY6U6Yga8oik1/U5dm9sRLaTD5tpoBbsFECVvkUSqLi0eYId3zL7eUaxnhfpf45cqFHzJEYvWsdGyu9dht8jL3QaxWSIoTaIAp2+TQ4W3NIFVzYF4KJlAsqE4GU2C1e66+kn7GtagQYWkiM+mXLkaRiUTWw38dJUfyaMV3E6OvdhHAVTuaVCtGzY/W4ahcS6UlCKd2DTj8JY1E8BjqXsSPp2lPLDmUheOa+SofYzz/mSOktevElSN3XSlkyaRwDOOoYqsiqrFTRQcyWdr1BEiUWXSP0NmKRMcMZWhVIMxTzH563/62W5Xg6wziJqlBCabE44hGaJINIyQuqjObWwCdD7kqrROgpbaXJ3ljOcMRIzI+0zbt7hNft4B+r3mAudxYFnMex44vAv3eNw+zMl3fqjPhqrsUeQKHeCElhBf9ou+5JmJIH6zIhLo7zm8jcHfLVqjn0l7b2716foLZor20gC8k/t/bkBCaq6e4L4djSlwW7fBoJg+/a1kuUrX65QJocLW1CZXcYe6k/85ku6LBt/DqGNEyXsmTTWk5zoXphau8l+ZKuJjoySnzATybiR6BtZFI6KnHUVLXQFsPgp0nlFlvWwu5Yis7cXV3GW4H5r6ntjw/rGpilkWwb3kcbimS2tlQ1n9hc3zO3rQsf1Zd8wNnBDiQfaIwNFPIi1WBTOsemcgb3opDVikBJagVHY4j0/WjEk7rmbODmq6See5ZghFtDzFbLQ59GhYK0x9POTORY/2vR6OmCkG0ZxNKvP91wKDrFef4r0XzJ6HnehXYgS3nIx5Rwv4jGaBh5DAQx29tynuTfsy5KBFeRi51YjHqnAgWYc8yIej/JinOPF7DoIBB+vW1dg60KtfYnslNaS9YpHs2AbfvRUsab2NHvFRs6HKlikmkWUgE8hHFHeizy1hxD2/Nx6b5UrU5/wYhi6hTEiBzDNvnCoJ97ltLoIYo5tx10xNxR/48jWi4Tfoc560ae2EkI41Vs9FmOnk50NN1WSPgHYEdPUK/nGPGo2bqPazo7k3Ej9DYNbLxZ+yFNZoOhMq0pCM8eAHIo6PqmAnVqTDNsgvBoM0RSwS7LrErIYWKPWk0/oxlN+vmOsZUXal6eVmVubsst5mdx1z510XpBmFwvm2Q2WKils9CwnNRjeicw+VVW2LVKp2cP3IaAO4Xeg+0YceFtCluQpFylD2Z/lmVekWc8Xa4kv7A03f5a5HDZXunEiwGSwrjT6qiasVPb6k5Jtpjq3bmAkVHIj5Tdy9T40eEe07kXf2kcGdlIbI2Bd7NXq0QkR9dWk25DL/6Efblo/Q8BwOOuMSfa1zED6jIN7jwx4A0/vkkk6DJtTbYW/5wYFwjjjHfPplsdi3jPiF8e5krJKjsNSwyM9M1A//ZIIv4Dice9iLXh3rWal5DbbfNi9h2ctobLW3q0EtbJY9iRUMixa2rarj/RgJb5jvRhbXWExXwPxNBMzilkaP+vDmPmndOpXsJsTgGrbGazsZs6/2O7PMuZxazqFmBVdm4z54c6Ken6phbDjrqYVSWBxcOsFw8f44YqG6s9A2EXMG1zpEafjsx+BNdMS0qaTWaghDilmFSvEJnfwFV2Uy8qbO6o1fT0BHI7v1a3pSqhmR+p3bC096/oOedpL99bRhIOWqkohDmc+1jMdgt3imE5IsICt85gP0RcDKh4eVJ1OnY+vZkfqd9R0zG9S9iJl4bEQ2qAnSQxvsA8PSNE7Ft/ChXbNDyq79dN9fRMPV4P1xVT1SNCL9L+Y5PBIkdfleW8x32XRLg1GpNXZTP2kWnzHSTE0uYIyrvofbRV/a72qT32PQLWrEaMtSxeDmWgPjWzA43Z98azxeMwUgBVrWcO8vM4mCbW8SPsLI1wvID63XkZOGtJwGAUZmZbmsfnhyY8gfNFhGUAFEo/IcHuySBJ4UGXZ0o2JWQRrWXlbJTAs0uoZn2/wM492P76UG0m/QXjkR1Ov8zUe/6KTYmaRrhPk2PEYHoNiNt49+8bRa5OeO82BmTJOk9QZ1pfSrrU8X/oL2R2fDXpDtOvG7zomDaBNh0vASQCE9NN2aFEy1ZwpxOWPEuJOxdA2BaCsBcGRlBtIvyE94NMJT/l4QsPiRlfSGikYlSPOxmetfq7CDmZRC4BxNReRCgpuVlLgJkedtXkCVR+T+ZkjV5kmvv7pyKUa78L7d0LhSaNQy09tvX6VsHIYqLt1HJpVDd/EA9G1L3PstYCVHq+noYZPGhrtZLERfYu+s0jJDJXPmODyCLFXlUm5Y84b4kDovaQyQF88gBEdLKtdsQL2Ph1QfCbCT5ONpcxA+fSEUqMMBoe7SpEtO1a+qWOumyuqIy4RaG1Z+OyGO62dOdu1EtRpzV+h8KbZggx7JxsZ8/hikH5qAX0tL9D+onZBfnehI82mAbdM29aTujZ4LzY4UGk2PqtZ+Iiss3SGHLSJXedws367VaZRUlMFGh79vInvss5XqKTEykuk/fpUEi5z1ixaYeKUhfRTQtavW/49pNVn1d3MYFSw/p4SU3V1+3hwVZjxvRgoSMNIevc11rL6LizIZWYf3626fKDoRfqfIxZ+8frwvbsas8Lm2s8E7y9aPJev0Z5fAFpLSj3Y3idbNwmgzNFpbfUGgXD6STKnIl3VPcKMm5+KFNxI8I3pII8+eqAdNt0WRMNUbkE0CCJONk58VtNxiIKEyyCCHhxoYM0CsENpf5gNsUycY4IFvKUUjOECOVj60Q6oslOofhyrfpxecL6cFclfEYWCmBtvqXQBQlgI+blT+EvqLJFXkhh3M1M08bOaksEBBW1KHSzHnD5V2XiG2c8ZCdXcSPyNrIoMesrTymybCDw/ln8aNOTc2SwBESID7/pUTcdnPwIAr52VCh+UNlTJU3pLfmmLZ8DwqTQEHF/X4oEmVKJwsEtHkV/KuZH8exEfePHEq/vf4ax0kh4TRlp/oN11JunBze2umg8W8JkTRwyahIAmRGJFZbEgzdMyA+UzZMR8Bu0NaN8lLbQbU5tSGUVQP9rplTRIdVoECKxvx2H7JrslGQ7MSodFcmakfoZ8iEefvBrhezG7Th9c1Ej1/bI2bJ0eWKlRvZIeQmPYgEeOn26yueXOE/5xSkV9ETQSTSNKwKcQXs++doI2bUPFzLiqt9ngk2zmdSUdUZZZCDLTy45TGtSPdxhXTakMBdBIMI1jQi+GfF3S5A6dkhrBwjdAYU0/ZkUk9mbRMrkMcHM6gLsRmJ8hepFQ6uulnr5qfgBXJjU9LFTo+7kN1y8HeF7IpgPuYHiYLKkLAv89utKC9SJw48JPQ5OipOEJW48usxtn/kUofwVyWRgS+iHkYTXhviR8A+zkQFlKtvTDRmvGZ7XsaLBjbhVtFeZlpG5tyABupasuM1/rXD+6NH2LCkIYfgHaXbk4pE3ZEpcJ+XKVcATruYviK4qu6721SQZisyyFUez0gaX6GADRJMlCmFc2wtPjylNX/TxxVT9Nnn0JOFCMo2QvF0y8Q8/0CDidC0RczwZOJN3YpUuum00vsXqStsVsuA7lZdirdkwJZ/GrcGLD2rZH+mekl8bJ+l5y/+MJzC7DngEotzYB6okxtz2B8KwSHYx6hxZzwm2rqtUptg16AvmD6Uyu8eKDGJDHAD7STD2N1exiTzTBogHj/p9u/5XmaF5R5F1a0cE19aqjjiY7fMl7Xuzmldnck7QQbJINtFlME8tC2G5GalubGNGjdGwysdvSnn9qIOS3untD2O4F4ndptAJwUfRwZu+2k0OLF66CCW6zn1kLZCpYRqmuvJNiMfTli1q+CBbF+T4r8Cp090JxnW2JeJKBtjAW2HWaOpSJ4ZgipfeYyGrZcVzm6BoDMNFsnNpHV872te8gzvdpgXeI055dvlvXfBj4IYpYg+WyJghsZTJqtTpZFnwUO85YtWidLL2eslWhmB2J37Hd9/zEO8RpJ9v/rpo1W45NAVp8LFZLQLadTIugPmwZvZ85YIzgaavgrJa6RXqhlB1J33FnNK+T2uv6rPc+79aXeg15b1Qyxskd83BPjDRiZBLov/Fy8ZbXO4grj4myYcVDSGdxabjUfKQ0BO70rkK5AySsMzelTJlDKz6NMPgMK3aVvUgIjIkujxh7NX71eAhtlUUbtyxQ7ezFLoFk5SDWVNUdIB4zSYa1vq1ma44L/3IC0kjTjjTwiOfwWJHXJWovHtWGSQ13KbZpcYywYQ9OgGFUPwR8wiV3ldA5MQZQaNvnmU14Oib5knYkgccBrxMf/xjVUGVRYxNn7S3MGSePEsrwrEawrFsSLYV4p858ItjeGGeJOFK4fR7ZsS7I8hPHYlEzEkEdzVQPJ2bhDzlMELLeA3p8KkrHm8IjDIluNlkFE6sSfX+SoTlZB1lanMkOUDAzigkG800U90TSZqCEBlSXS4ydxHqHUtKmZxwgWoelsg4brVk21zbDcgFuqZZ09HfYyW6fZ4pQP83QPF0+kvEvGCuP4To4PG8V0AEFWU4qTf/yqYS8OKtyG1Zt4RreTJbobNyhchvgBeMeVnD2dDQ1nyXx076v0sR9MdcTfy2cT2RbeRgf/4l7/FX7tbl4JwNdaSfT+pTUKlZvIRifGvNSoZCsTzbbxA1UDdhXnkX26ObKXdk+jbercmqkywUqnqf5ffFKOI3c1g7zaZ9n3v166beX7auz2GeTdmv8kakvj6HrCb+T1crhXk1RYCtZpsVVMSs0X4pBIkU6UrDD7kh+N6V3SMxsJwPn2EXqxduuNjFrseeCjMBOLF7hvAVbft+1qa9QDLoSj1wJOyS3yERU9jvgkETCyecetRkoWUwzXBLryQWXURzSFRCf1ZTqyua3CocK8Gs+5SR4dVVgEm+iZ0t0YjvlxM6EUhWBxbNP3UgjKdD18+zKf8rbfH0ykDMjdgNGZoiREZSHqG29gX112VTtcwZX0NNBZ8nccOYT6oRw6rWkVlePMxAn90jvNyQq/LoQpyMxO2ZrPXb3iK1D9l7SsnPu8VrqPsDl4uyHpYNmaddDS8XeU9nKaRZMNAu6aXx6O31II7vsZsFcJc34Wm6wvzQ7lYoEj7Nf0k+ExS/rLi77ok1/kgY7PA5rf0r2pE5PkhxJgwISqgVkFx/mzyxdGCWbGwsVOlfOi7kdhwp6h9DswXAdGMlgRpJ74fIrIi1ViJcOADTmYCzlcTh5hwOxpjINAJ7lFPC6unSoY0co348KXt37HvukDb/gBUR30GG7VVukZ7mbsbrhvZYfg8Eyx8ov8831zO91delIx465LY8Ke0daqReAasMjBOIj6wpnWp9Oo+LMO+DUrS8NAHy3kzxdG5+vfA9MiXUxiQTaSM+N41svHn5547voXSeFYkukvQzzwRifnsWrMcFBdgqs8yN7Fm6fc1lkaQ6OF7NA0xdoI0E3SNr1Y4l3kO5epcddyXj4lyYTRjqAxmMuDEVw7dbSpzR0+RJuHVCHAgy9AeKDNK85+oDTj/sifm+ieDDPktpiqovw4DIOh/1dTkZxfNba+3bmmfKC8E5YDWHdfTlWaAhjyHkG9ZHh6QXTfsZvKE8HYranfZsnbAw8teRmJe0I+o5Q3Qu9td8R/dlQn9cWTNrpd4QLYRGXbAms7XLGp8Jky4QRfs+gY7HjrkQdSdoXob1HBbyjjNBjEnVSFNY3G1RIP67SbL7OkHkBi5P4WOZYq2WDsFUrTtrkPsD88iiA9CXKSNKMaxC8moUfU0nY/JggvBZxb73n8piUFZ/VHcCYgwVgXRL3+zxtj1jtoxIiRyieoP57jBCD8hjEB4qmo3/qDoBTwnOXwwg52nPCxUspB9o+dmiV9+JcqGKlVG1OsmyMvmC0NSj3o8Q4KoujuCilIZICOqe9SQESN+HEvn5OOpgji6gMi0RIJ2kFB/jFJz98HKf9X2DCmBKROZd9G5HOARl0JaokFKL/x0ANwqYqx+Ec8rpOUAgSGi5gogcrXyZ7PPpGWh8VBCQCWCaz4KZcHaKNlqVXO/HiErXjSzsZVexexQPAfFMJ7EDNDcTfmBvymKQ3mH43ftV2V63gUelfhDVO7ail5AENeSfuE4WlRORw3oaeAGJ0y4aKbqQAx/GxF0+/g+7w6Avt/oMNONn2QricZCoq/UDFmx5CayziWDssXP4WVgNvazwGaruSViSBReSIT6a8Q6X2NvNdNi0bM8o44MqYrJ1WTliV8DsiOsIXWxjDjvx98tlJtShMyI/J8Z6mHWngkanwTcsbWvu7RS93aWCH9c86bem6DUBsFGajGt2F/RYupZrq3DicRauEREmp7VREu6J2pIEHDfLcdnrH8xGACKM5JXoUtNMeGnV89iN4n1pBD+BZzQM1OvtT+f7dU8ae6cqT+SJ4vGCc9fUAPvANN8FGVi6KnfNA/uFJZbs2uywVIZ7HzpZpxTKnNbj5h8ah6ZBaLjBxM6FiTS/SAD3NUNHDmCMJK0+VEuDsOcf4FfPvURg6UR3eqfZsMi1wnFY0cwxJZq8PcZXs+nGS6Dlsx9xIH7Bn24J1X9SORPAoed+jVF7n+jzuTrt/NU3wlti+VxsoDkhHFNE1QxKxvDUzlnZeIhHJ9+B4O0NwfEkzkkBjbtDjEl9v/EcGlmnLWwHVqCyr2bx77eJBr87B2qJm0Y5t6WfKTKoqTl30KWynlrUTBqJcrQWJJLFAQPPkti9e3mYDbONYxtYCnNeTExzqRruFpSbqqUA72Jl9uoUhNKxFbxFreD/af5GYsIRZQIs6Tt27n8sQ5T7E1JBHJb3OdHnEnU4ph2GYejuLibk6To2xQapdHxcWgBLwZYnsPPSqE5NILlXwUDUPaEGfRXwAPqJN2vJCsV8gHQPjA/jCs1ZFzASQdlNzvso8vT656rErZQLFWCfWZU1ElYHOjS6ilR+NfMnN6OfJXOWjY/l6WKSfRbE0gcnOcp2EgoCUT6//JV1/kTlkqQYTYPFWk0W7pPoWa1nIunXlvK8YKb8AIk4F8PIG3CQDC5nxlUOzdOGB6k8L4NcVbi/7+67KN8fJqKS8H1mDg6F+Yv26VP1PgQhfUuUMdEj6VIqi8agU8YeSeCShh/21vjfjegfX53F3On8X17y7xrUI/HS1UWjk6KGkg3hqBxLUwI5Jo8Dt2b7HmmeEemikn0bVKz6VaA8ACIFvR353yrBZ3FI9RNfF2Q/rR4PbU6Gdtfza67Rx7hY5PakJZ9ljNUbnuxz6FeqPsV4Z5A+ETBLb6eRiw51ZTPyTvP3LXIfDXugEUkT4eau+h4dmalMiV99GVoamIhrJJ+kcTk3uBt9DPFIOUvHV0Eg9jXLdfTblHfL2lBYTXUfkdoJ8S+/Acp7SorlxuKJR+pF1crOOQi080s7DxbVknHfVyuNJZ/0uvsfjb3QEM3BW2vpC2XOlnE5vdOxFcVxhGzc7DI8wtvU5Ay7UNMtIEg0l1Ige8umkdyjcHpjT3kmUW4Vg6OSguu6AKskIfNMkHhZOKCbnPBrEOWMpUcFnrKAtUMQjAT3Gih62fB37eQGcds6isDmV66xWKcZBU5WYSK+aetvJPeaknaIfB2Q7E3kjSTiSkOPw0AsnHynpWDdG42GRyw+ULk9KenhWoQ9TaCjE9JMoasktmYGepoZT8nk0hf2GFWNsdoXlHBXF1VzMtyQA5KFNJ0kOvyXc9cLXuzXrqRqm4i1jtxy1DVc3l+6UXmHiVf1bdGvborKKdaCeMlIFQxUxio79aPrlqM+LY7RrFnDMMte3GCTrzoSFb5Qn1FDATCv/i+AxNwEY8rSGldVG6QBB9sBFlORFVQ+JW4TAJF5D6ibFI5+VH59VxwczuJVv7HBp7WB+gF6Wc5NYbItjSG8XXFSQMB5K4oGC7gnu6vgQ5pOkZQZAJf3+nMv8SnqDVyx017SHJH1sOaWGadRKz7J/BRxi1xrBlswd8GoRk1AoZlSCJ6RBcpAOESRPhF013Sac7ygo9WSI+4eK16I9SfM6+B9V2geBjM3mY0JWtdYnZDcHAzpt5MtmEEfH9vXwQD8PK3f8Sp83MF0ee3UnezWX8F7i9fn3JEV7MuPGZE9E0kJGMfY3hz+wZmY67ZQcOTDSDgNWzOfQ3sF1eNyFzS2GLWSrAwYmgEf7tEFewrPdjnN6jKTAcsItC6cBgzzUU0ViWKSdRdSIT6WcdG6EFypgcOK3eDVEUsfmX5zVBsHsy7+l1h+IgJhCS/Cw1dnJgDr9YNh1mph+Dw7jaOwqevPzBiL1pGHjDyYoSB5AYgvR2zt0fQ+96hBHeVxFVJa9Trvrik095X3yeEoWvnEgC3MyVZSBtdIs/CgPIEgbiKCxj6Rfhjsuc6F9wxBnqMRIB76tJwpvAde31eF3di4+/cQ2NsbehnemSZuhFB5J5zE14jAp59VLeiP/PwehyMsdTBbUVx+ehMFjX7ZaBKJTR9xdZO1NVZNp5HIYj0QB7WYj31WzHkb4pZkYW3qgbak87Z9ERkuSFwIpIBAOvosMX7wO4C/ZmEwFKHU/p2+zilZGUhNIKYNXZcCAubrwrBVw4LVLwZywjElz+Wjn4MVzVd4v2XD4EIQHyUYXuUmuYugJjHpYIKVW6RFdvSOTxedrNHsdm1xmpuNxs0G/dbhuvOpedO9xAn09A2cYPW/9HmxyG9QeKmCRYhbzQR5/dBY9QDp3M+eRS8YaZePz9uOTH7790s4pcDVDO1wvdqmWd8Bc1b6lkbW26B6nHh5IbMhm4DCiZVFvmPoQZErE1tExpu/IZPCKq+6a4YCHtrW+nR399OUwwyFLSyviVNjN2k8KAtNXuhxGqLzrdeJDlCgRdRP1u48+0M7Q7MwsQ30FznAAsoGd6KRmMHLEBDc4o4vJeE2l/MVcMvw5Urz4Yz/qFQEz2N2POQqbKMWOk3CrXT4/4Y32SWH0ZaBINoqoA+lxm0QGwo9Yxs/lmi+lcnjrWSfBwO6spZ2NEJhlK/x3sFGMRa6wi58pEm0Xf3u97u8dqlL7BBYOVhwW3/cfVRpA3C3p8dZO4MsubnDGU00ZjHmzqVZR6kOQKnFBhXrU6Tum+HmMhc5sHgDvTY0/4Vg7+jKs07Zcq9T6qboR5Kt+nG2Qq/XNCXXwSDcPKBGXQHmd2fS4Su0XSPVn6p8D/sr1TCOD0WYlqIAYmOVHOTXTmKaui5kQ02RjZlwZPBDNYybUY04fom7eAuGZAyqZeo3DsMcRdcOzqmsByzKgJNcwaZ+b4R4s4pWVa8BuTvMxqcphYIIqg1ADjjRjV2O2iAlwYmh5d2Mw/BZ2z2UrtW0egcnW14/nNdTKZdreqa+/M5fYxhDDJGFPyUhKiQL61OcS6qCBbnrBhnrs6Ru64rs1BvcPLZDOJDGkIxrTTpSbUdZhTsWgwI37DHwC4mduliBWxDtWox0J4ZFwHrVZ89uyva7tfGdtpMkW/kJeCsIQhJRx0rXxqtrWfFJYQevpxq5ZU6cw41va2FUZilAI9YXTkBXyKKR3iNq8N1YRWuPykq16AeaMblq06H0iTk8D/QpVx1ilDBTziENh7NCoRMpA7LV/4nZxV0k63zMWFFyPaLQe4Htx9iMoLmPDOEK2KbkVbOxcstGssIPkPkg3bRHjrA/0YjOQTEWCDwBWuqitoN1cU3YKx/pK7pIc9xvMvY5kPCZC26YxN7qpa8Kft6gM/2Da4MOWzb5PrWjN2b4Fga3xDYGkGynAMc3h0SLndcIOSmPLBQswaKyxVtmfSl9nfFaLcWCLVlO1HKH5sAp0wLG2WQvCxw3g0udJrfBdjZ9BFGccRTkAwXYhgNisJeMqqqP9lKMDgz+Vl4WhqlptBa9xArn4rFIYgHlbGjSSHYd7zebKGxeAZpDB0K510gu+RT5xpBFGJpEI6mmm+ljYNY1ccWcWM/9ze5248mGpto5KAwtX507hnSnOrqQYEWhoOI2rLw9lnfS1lNIIZdvqUeJ9QT9KAIhRr4eStXWQy6dJ/5jaZp3KFEyOILEeL+z+KhEUC0R3GdY/pvRZmzVs60O1KVecCHSMkKjzaL03hCAun3S3NktFmgXzqoE7DA0N6bffjaXs/bSCAhzdy+xZWueor0cH8nVMVXnU1uvxhxdP6gztQdyufy9x0PXJcVgIgKvR3uz4cVLmmSG91GyzIXU69fB+LoafuRFFq350e4wWTKpMnRl8WLghoLZ6wGd0zjo2sz5fOysCJ+18cuqAQqfIuYU0TG8HUbikqF/ncFUX4WrXntSth8uuzL8mUTXZp/InzvnXi2c9GUwHkjUgZhl7WrFIAfxPP0NBijb4PZ+aIHYd3luPw+cANz4mkrlqbKTeXhSdOTVqrydWeJG0zh8HZMUCUCy9Vh9nnjj7XdhAwALDVe3wbH0Xs2HwONrkNUrEiBI3okDdj+tfph1dHtGmbwPtM9+XDTkRjSuNRl17jyJ8IS3aNFPIrswwCKaB4i5rOt2afUk2knBjntLjNd+RWuFUuN0l42JNKls6ZQuuR4nUSUICeFpbPiSG3sWOA4mwsE1aQTxqpKNUjChzI+oK63eRfVVi3Xw6eOlcVkWcsGRWbA4BmV1EQPy1kpK2WcZHAHmrHGXKuITKG68M/l+4hYqtBSNubtoV5QIJzxP85DDbJ3TFFks5qTdsepc/0anbnQKDwiJsONvF8nByU9QF6KHkCW58VwUFkwLVssjCF2Ij4TaiZnwq5x1ZBZSvms4DG4w4GM1oZ2egHInCm0z5tUbN36PzOB6+ip/9nIWAxq/cHkX+6OCggfacQb9YaCZJ0sAysraxpFl3pws+PvsRIG5tEtXwkLqWaA520j5dnAZnfGip55il5ZMPUAlDm3y+si2HHg+SEKKchRjQewHAw+DvJHxKT0JZ0qjP8kiqiU5qCmnhWKQlhrRUUvmaSNcQG9NMNaGc8z6EKpxOl+NkmiwFTCKvNvXTo+F5nwRSX5UKVKwg9CPA6ol+WKLj0vZz7ZAwGLw9uDVNFcNSbmc2Q3hSgR7Bu1SudmlA289oDl7dEuoxNRMSo8DRTW+Ns2Ej4d4T+nX/sIc7e6QMBj1zP49bfiV33CUNdd40tp00z6ehhtfTVm8weYgDlq5jGL9czhglYIGRdGFiXdm44FCMj8T7iJP0OczXTb5HM+mo+QVzsfT6KpNDz1R5tiU+k5/rzvsoY0DC0xJ+Zko6HDRU5CIFLyKyPNbr9cwCz4jpCDY2r8janJ1TbveZjpKw8KaKrlLie6apTG02z+MbZtximSgZwU1diEykb1FfHsfk1rTdJeOAjHrTSUoArMpGSM/XWZOkEEi/um2d9gvzXpskCZPLGjoJPc5EiDIX4jayXtvZo63DanahLuZUr8ZagWQY9+LsR/A6tUsGIsrCqCKxl88yssJFCLFXDp14JN3Hq8VbXW+wfV7Qpt3xSpfe08LJtVaOxtu6RFiS4zI4TEuOF6ZPU4yUz8MBWjO9SIqOpOs4JvRiyHdoDE6C912lh9Rklg5QPKMQeZ2IPCrN8RIKGybeuCoqCV1GNghnXIs1OwwViUjBiNrp+e33Xg/xPbJKe0OmomnOnaGcvc4ChFikwYU4ykXRwo5v9qrVz9cEc3mKvX0tPtLuYy7M485en8nlMrQyeZdWw5Y5m7Ik6/C9qe5pmDfYqd06R8E3amFLZfu6/Sh29LTIQLp06V+fKX4HofudoNVp41iUuVgIiih/ncZ9uy9tVMH5BIBCioRI7NVikSwwi1nJSISPRPuQAvYI48NspMY8S2ZNwNpoKfxm6YUyG/FZVaJIfAj1QMG2znTawsEAJmlPSUM/az/FvC7x6Fe1XBTB+BkbXoaHHi8cUGp19Wwr8VNKwa8PsXDLOu6SaoDQpJiyj+hCt+to7AEkg7WYXACEsk8tO5Mfk2YaZOoQp/Tdz0CIMhaiLop+18WHEjc40ZtaG4d+SzDXEHcfJS48qwuAYJCvSEbDNOuFjhedRmIzelHNxgEgXmwYh2MX0Zuv83m6oC6ADt+QtOsi7fFzwWBfXWcTLeAtSZfmaKxt2//irJZPsFi5abf6lQkorDvUbLNYSgB2rZXzu9LtV6iVXkirfuKCT6TQG7QipfWk3YRgewfT4bF1d+lKk4SLk0hgsWz1JlpbksQAGcbEPHhT4LCrJQeOHby6RICR3heogwEN6JOGr0d534g6rZmAqylVHQyAWuqnBgL7NOmHCY+0MIQp/TvntexLEKdfJypEiQ0xE/idNzwgj2dkQWfmJCh7XU+Yc3FW02jYV33pJHAguvIoFyLxzVa9hFVV2Osri+wnuV0lxfmZDdF2wu7vMtmG14kf6vP4i5coDo+z0GnT5CcFiXHhIdJRrgELoDat1GbvV8Rep1CAfrPp8c3Z8Ues9QTfSB6OGBGfQXmZ2vO4Ou2Bu0i0zJsaPhv0KS6BRmgKibd6O7WzFPs4JlsWSOvVJttEyk+kFEVcoEsdvqE43pWadF5bJvbR5pPYQNM6F0lmq/qpxp587TGvjeZoaL07O511O+zKnqFMGhYXerWI5/6xR6TP99iJZccUqkc/rTAvzloXYKzCrnQD3qzpuKzmA3KjO2LNMysiHr1bXAbSLe4JVe9IJPdEdTMKgG28f5ZUbzygpxjvpcHDXtSuQ8eBUlNSYh92KisBWfG2Jol1OY79mNNpmNantPLgcTzn9RupOkFmT0QK+CTC671Q15IgSMJHKv1Z+wDjM/g1MU7kyUozXa0A39I1cUI2AhExzWz7sjUw5bCJNYQNDGS/QCP0FMWvj7Ul0TgpwGAe6bN+/YK/91habQEJ31ssxmNrFi15LYK8i9le5pUkVfXxVrJYQLHs3F7Tjvt5LlFeTMwCe6zx2fa9YiHIfp5q02c5zGZwSuWMxemQ7aZTMBfbdWuiHa6fy4IIGOu8p8eMcKwWOc5xir3sk7iysRNEiydjM9aPhuWO9hNJRVH0MGU7qXvAFlN58w3BvUvTaCPAhl2Y7RX3Ovpp1Qfzadu37WxF4IWopnC4tAhtgG/tdAJ08zyitJCYBPJIox9aFuvqKFdltodmALt4S0fMis4q3FsA3L3dNIS05qd4yhyaSVRHT9anmbsw/PITIS/yJj2tzFPW1NqTMCelzTmP2GzzTZSWR1JpKzDu1qEhC0Jfo5YTmW7h1k2JKJaWV9jhr2a1YjR4mm8Rql+BWBaSYB5n9g5my+OqtBFeZtWi/kXWbamzZ1RH3KGrnwqTNcgr7FM7kt3PGV3k5ztEyRExD+bxZofZwpLaQ6SLujUph2SS8lrRuY+gkPOueTzw8mw5yEmNDZZLVRhmhsudk19i6dE63UqIhJhRtCT10Jp+hAk+UUJQ2CHba6h90jcQC0otjAj+Itcwj9lQ/sVZLZRkuxR6aWaDYjP2UyjJds1cg0lwzqpncPZ3FiQmHiKaIkgOiZSiTL/ZmMaG8AieZrZ35W94sE1boGGDK7sqhZk/WqAVNpNTsangVT0SLzZRlAKjDXt4OqP56R5RekiMCj0U+Yat77EW2gOvIm6rGuPOyYcou5Ndeco6O/8xjkbLPfdUvwejoexOrHtHOnnMingsyht4LYeqkl448Gn2lndLJjY0tqmZhohXzjamorAnXdZX/DS9wtU9ApUkZMG+M2bnnkuTGT64Soli2SjrvPLw3EewgrUNSoM/3yavwuRpMysOGsGyoU+j5JAeHUwA3FJbXUugRxZK6CsW+6PkgIst4uyolysqXJJGG78hvG5TDQHQXFtn5HInLlSXXnDY+pmzbVUdVV06HoHB3FD2iWSiiATyKKPXkxe8usW7NPDlkAJy0lNK1ZeNHktsVMU3To9VYR/NffHpbialSp8DgDKFhWGyQ5AcETYI9hsKvyF5wV3OOt4H76qb60EYncYZwvHdP8Yu6cqF+ckR0Xbxt9eD2ZIGsoTwdWUjscpDyIrPKtIns76FMmLiRKrG647JxCKJsTiQ53SB+h4WhoHYRdjma0SepqTHM9MKimTnA16n/iao64bsdwnNB1vUquDQOX70yOgszEtqmZPM5P0S1b2z319XRM+o8FrtD5IDIkLAJxDekbvixK06xx2vZGY1fwiWbFBlTYx5uygrhb2qLfqvbGXG7mpGgx28E+W6+KkxUVTsB9F292WPJlU3E85E+CtglnLqEy7O6toviaKzyMkdVlgbX5J6SDJySyv9yd/ernhHv3wmFL0jjdzT1BU0Y/HKZuTIR8CEZ1bz10k9l6iTRli43zZtXk03lL7Zd7FvS6BivCvUx8YbRDiUtccJLJzm5wSaXyAQRiSgQxi+PNfGLRm6i6JP+9h0Ug0Ql9ZYUNDHmxD2oek8Wp2z3rQ5YxdWgtKJQtZQ6Q8SA+L2kF47yaPkAQlruR33BX9gPuNpfHhx9iMoGrlLGhcMkWQg4n2k2ZfGuItRfGL9FBU1XodeOY4jbBTGT0q/C0duf10keAX5YE722FfYTfQ1TtPjKG2WKbPEeJTy+zha0mx8ajpgKZ2p2/wM69qpd5U6NYIN9a5IHwvpT48tPVsd3z2FrF4S/JOOSo/s9IuzHx9kIQBcp+IHBmSVge1aHD/OhHnCEOCjLP5pcSXm1fUwhxNko9/xzIT/IghpFqwEdL+rDXg6ghzFH6YSzK+oWLbPPG5nRywJ2Bq9Ca06nle2xX5xVstR8GaxJCRdokr+o1ajVMqN25IK8zzVKN9F7q9QVI5F6CgHJGJLKG7tJvUrEp+0/SbR2qXm7tpZsTdWAojDZsM5DdwrHfkoNksM/v3MHmxDTIh8DZaJVt5GSQ5RToTL/Lks4Rs0O5eW1Y5/PVnqJFOha1unI99gexf9PA7n/qODH1zZVFIonwzUUOCPEgIi2teniR+mbmp5LbOabUQjuZJj7cKzqtqShqQppmkbJtoTf7CKknYwkW6a/cCYzaQvGCt24sP3pAdbn3A//HyWzuTlVKv4mk+kEUXBAxNbBgkAZQIBAH4Kbn69XYSbV3AXOZ9BdDE5v07Ltu2DRSRFhu5yxNTMins5gXc0yU7hrCJmpp0Zlr7MH6UFRBWrfoXrI29HsntpMbICGyw7htKWtxOe1TQ1+P5Rinj10QVGapoaPB3eO90rh6/kkz7jQ1A/kTJO84nSgiILW4UAl89zz3AG4NMSQFgm1M0Ais2am8CewydzITxrbY5ZF790xDiAbT0Yn8wHsf9gU9466pkv7KtNfu3UVa2VnxnhZVLYk4HrZGancCJ1PqP8gZsUn87J7ELoIPhKZ6bVxdmPIIP+Lj19NlwTk2g4p6ecmXqLilxKtIPipbLOFOTxXbaMsdQUU13ri2MsS5LE/c2SetM4g5ZB70jG8KJQ7eZXABnNgPecrd1Whe0Dfh0aSUwctlIJtiTFr6sjQMQz0znuJ29EyR5xmOtExe9g6T3a/a4NFFeX6fDq1dM+5WZ7YU8sTafo3aZPs0GjZLQKack5o6pOR3kMQd5DyOr7KsBTJ2MJzga2jIQrwEb9EcFFJ3VLt850IUlqxjKs+QxmHYjVuo6A34X52pe0kp8cfJVM7KvfjliuhzNntTQJ+RLA4XM/v1dECk96kKncY/bRuiHuuiUNBJtyEYBp3L7yNBI2McN5NxGdyI7Wo05HaravfkfKhq+DvIOycig4bWaJNVi3Xgd7FKXTzLKUrbXOMnhqGdkkpnAY6oLnss0fZXJEiR8xw+cxgq8LFp4AcdfmiYWKrt5mMgKSpW6F1NcxicZjZhkBuM2UMdC0IeORlB9I/6G+4eshr9aauhyUzGVdTcNV8vlTw6rN7apmHIcr50vaSIk5MgGcjmOmfn+L9TxP+vO5LZ8IezUjwav/vH/YqGuWM0rPDjbh0ZYgzBtqU6hLzpFGfKpSjBQLNZswiWtOj8QDN4EhSniIOl27jbEfWcdUt2nDObTdusRwEpSlHYdn1danVTkNSHJH6cW62Xq8l0Ib3QSmnQ52TsgThxhxSBLIH45YougVb7AwfVeGdMz6HL+PyTmOYtTrFKcOB4EI1LBbfFa7ts86JDhOVILb1O3eNL2XOiHB2J7zUVz7je+ICYYrQsJP94jkr0Tr2IcO+8hEzc/yrCwY7ujFvAFewGwHu8YnPwLkpvOIsUGJnMWnwWIoH1GbIMZ6GnF3i98q82jyULPR5zhjhKP0jSjdIwKGPpB8A23nEXHSQge+Tmp5ZVRYVS51S7/1pJNV4M/S6YlTJaNGlEbcrPDUEZsfcP8hx+cQgu+grRwa6q6NNftsW/N/E2v+T4POzFkilgA88mNUIl+XqVisF5in+aeftRJluQQsl0+KvTyZxuWh7taeT7umM7DIJrKlIb+cdBHX0U1ZYBE9ZyHo1zCiztcpDFHKQ0Rz+bTY66L8YoprEqxBLX1kbde9ZBrG2trkB74iia6wZGhqk2i1Ed62bBQ2wEtiLmXiSJ0kGXIBsR3R4B5p/sXrw/JvKumzJqU8vfaX6DqPf7NBdFRJsxzfCMfSmSDHptqiFrCxSRnjNNDBjqGXEjvear0UNFz144Lb87jA102db7u1dxLbKS5tAIGFY9CFw5HgvxlhMEVj5NOLn71PWA3Fj3N2mApqYeJSlOgU+wbHlTyIqjpkO5M5rIplFstdjKgKz6oYjT3VqBBWYqjNFthKVFWuipvcWconI36woJ8iJW8h08w9KmGxQYh06hK0curofG434oIDHMUxZZzVKlAAz/y5Rz9eDSuWhfXgjB8FBcfRX5xVoYaPomoPOiLYdMppsUe1pGczdu+WVxbRaH4J0FXJkC/1e6kBhpiIUJYC49Keu2jAssylYyZhPLPu8/JQpeOzH0HF911ytDgZUqB1JqNmJe+DU7MLaViC8lWE7/uSHKreZJ0LiOfIHUXuQe5WlOt10dPe64F/zD7rEKt6OLrJJLPKT6BzcfYj2NDaRwi+cdH/wvBjNfRHTtR3bByD0RC8RrleocVwDcw7UI9H02mfXNy01oAiticPr8lIbNaYtQ1G5rwjhXZkSHDX+TA1iAz7Oe4mL0W5TjEN6LCGb5hP5lZB3qX566Y8LLQbk6KUkxjkfhdhHH/kE00npQKxGNGOtEXgQELNLowyOYLEj2jQp9+K9mVmxyWqtFdsq7NbRix7v9UzD3cA1h88yEkbp7aoEjEr7gO6s1kFUe5WlOsVE2Eeb/ZqqOeylNpADha8C4nDsUF7tTMmrXCymMUvTJn/0RHOkqSJL4b1ig3F3UgMjllQjzV9Q0MNN4VEB5JWNmdVLmJyQLrCOZZ9Z+acdWk6a1NUpM4qdUkcIjNQt5VGR9JmJIXGJdlOBffrvKZHVGrTVCy5ZbaPMuU4WQNs5iU9zOlRWfwmx6sO6dH3Rp4vDzvuJjZEeRAxD+rxpu9Iy/JKg+6artVY4SEJUoTQyuwyXasIrUrFtHBKxOlzVcmGTTm+KFvL4SiLK8j6umgt7LUifodM6eWN3UW+HKxJr6IjLuoaOm+ayTcwW9oJBeH/tONEerRhpLSwCKxfXKhqRipo1HfM71P2IzFtSa0Fh90JyMUrzw+qMz6rEJiZsNair7JDWbFkpcHMgi7IkLVaDy3dlZ38ssirMkpfCPeEcz0OCNSWFuUDivTnIXX41ra1aU6RvAwABD45zdUKT2ofQTx7qqjynim1D+sjuBnUb1kXcACnM4iX2fAVphJcpR64uWABkwqbCsNMUY96G0KEn4dUZe2ZhY9P7aXR2njkqsRn9fXD0y1RHbUHwsz2+jldjNfNxua1aCZdyEX7ufKxCBqJpp7Iqs9lwmwzkGTCKrZ/e87X+mVlxxNrpI0clsGgtEwM3leRl8xhS7VUg+aIDbRejH3hepacQ9HD2Pn8FiqgkV4aCkGebHQsf01bYruVuCdp2/Fmp934xVmtuZwkFbfkymAvFu0XjidNvosAlKkXAEH5xOB+aOqmiV9llbsZQNG2KtoGUvsqMr3rmez9dcfvcbfaOZcmp2h311KEyvuSnAJgm7ZNERgiSH9pJ9yV0jK/Xy7zHsI8iZgY9ojkc+8cYCn3hyi8DaG12DvFbj4+++Ex9tJFCzBR0iRZM7T7btbsCttGojeEwbskRTa0iYVqo4ajALPNBue44qevlIZigCcdvExwu5HLXSIXhOGHigPktKSxyhhgFg0BCkxHPtUlk/xz0Y9jh+vbDdN9ovSgKDDyAykdY+TT7toAsjDjO9tVdWvxk9jtqidTVsj67tMAEl+wxsmI5mBUO+4q95HQH7P6ngrweqt3NlpJUuHOXL/KOhMzWmtPVjMqn7yVpffZzZBQvKAffdXXU4nVaFWAATq3JtMG93M3sFc0Ck91uFNfgAFJ8vLhnpvWfmx+mZZvJfbz2V3b1DE8axJ4s8vXBsYet0jF8xW/SM9wxY/XGQqPb7oLr4TIpS6NxchU7TOXacmylR3CZia6r1ggWdvSKcdwqU0dUpipE2X2BHSWz36dd46oXuX2CT8m5rgLGtF3Hp/FOyeAZFcHEcU5zlIyj+BrJwFdl8PEp+IcliSDcgJ5kQTvuiVSXEKrknwgaYnITmfTRCpWoHl5CtkXr4TtrtkBN4lQWZ6ziIHuh/gfRJMckaLa06EmwpOKTCdLqm5ShT0OKkV4yDVCRQSY6/DsVAs53/cm4+HwtY++fIvN6/TzMMrr5F/4KkYgekRWRFzmILtP0SPtn8DJS6qMd4E2v4t93KocRxjbfnQyg/Op81zJ6c+5OXuuyxVuCXTSY4CXp+FFml+o47iyz8sJGC7Ndn+0GZSEAIHRXYOsJNHEYpocU8DWqua1mAy8stF4VabcmnvyxetA645ZPI/1e0OuscszadvPzmQs5QHZw6Gd2Z8IyUvVG8XhMk7fz4awouuNTtbCN4OWbupClOkQ0Fg+6/WOBCQW32aWXjLRiNjRVNnNQgseZ3jMGgBbt14UH8fNYZgd5DdFmg+nPsDCNjXCQHl9POdi/HqNrAs+tfEfC5SzhprwwVYTU8mVJ5bZ0yNzIJ6+oUqDXOS6FxfYHOewn7AUJTjF2NbDwo/h6VuHYs8pzBj7yOV8DMDF2Y+gh8NdEhOXDgUl5ZgAEtrpTZQplRRt0T2LJRrSq2GbbDmMu1/lOl8xym+M5mH48zNepiU8okFmZ3OyhOUk0ClokExmsYgiIrkh3IenQxhwSzGcxpR+M3ORiuGrHhGR4dMeR5VX8kzM6F6SXlols0lV+fisovxGCCOvmKHQwfgkcrlnJ33fLtavKWIM/dKWq1IYX/P3cgTMhmSKMnKdnE5WnxXJF5pjeCkzd6kBhkVKzboUrmWD9FhFgMsmbGENHLz2Ou1t2a2Izp95NTMZ4o0knEjxiYqMvZLklwdaubVtd1FpmfQyVf/koMV8dNEFN1C1BX16zI4e7GrXaJr542arG00wiORbX+0NW+S6HXXf4fk9pumu3TYR1ddhnv90tCzCkq6me3YSMxwZnRVySbEJgV+6Vu8DtT8ksxzm63VmyndkOmsaKKhOHdODc8czdylaks9LEVD5MVQaLylprMIGxv3MrPPTt6J0r8hTuo71kZCTRteUm8w3wJSbRZ3EEnLCsx9BI4e7JMAUcqhF9BI8+a4eiIk6muBG61ewctdpXiTc8hDrB6PRHok3fgJPlPATj4TwRkiceBfLZInoCNctJA6TvYpZv4uzH8Er1d5guWzlFrlKTgDvYsUYnMVgLkr4iZeMt8Re5ykd/kJ7wHLqQleaclJUPwkTeECiGTOTEPH3I5ECPkna8xKb1TOSLEzgiBI+Yn7E41MeklRt0h+hM71fPB2eczscX3xWJTkgedYKSFoBjVgzSY60CkF+Zx58XesAAJ+G8+sjLsopfMXLU8g0tkAk0qXLLMWbVNNzTuoL9LxHucus+rm5YZR+abWfWfV711l02XJOjeQXscdfriRuuGoru19YR0BXwgoEr4DO98n/11PQPbL6rl1X92AUp8mypzKSqTBbmhcKAh076eg+CUYbNXrZKkwWOWkXfvZGkO0RkuE+ef5jcrWSmMCVqSuRTVR1JlcHJxX3piZ9pkQTH/gb3ZAv4CpTfml22e9tH9HMF0v9EtBQuo+Ufi8zQBf+5N9dOv2dwuHz7bPcS4gtti5RYms++gKGJ3Xfw9DITBpi7kUq3PY9k6XosqpohmMdbfBngjCm5GIKLxIOPKHBGILNyZYCexF+atHx69S+y9ZLzc1mw6oizoqTQ7XPVWX/gSVEGBOFEELb3GoYlF5UCBitJuuV5Up4geAXCAGeaPB669/FtA6SjDJXCFhXOp8u9mdLRZNjsNmreG5E6tiDXZo20bd37etHeblK6SJTbHpn49JbzIQHvLnHsn/x8ljBNrT7AM3pfGL4XmH1vauTzkhYh1kq4LACG33ZTZQVWWp6mEHtMIWH7TkN4OyuuXKB7uOLRLEC4OkFZ4vPvqR3e2u56MySSdZUt3h4Ui0cFyu3eCWVX4v1fSyfDNBogjhMIj9yfibXMDcz1fizx3n5KdmHWdryIPt9ESASDTz7UaTrGU1n5aheuNlnWIvLlRR69tHrwuKXcRjN+ORHkAfGNLPFbBwJr7gcEyE4r4MSW+arkxeAQHaqrd4UDIau0yZrRYN3Ti/iQA5dT7j+rcSV3z3jZE0xCVF2JiBW5w94aMw41bSp+KyWiAL9LKYvs1gZvtWmbguoI7myCb9Wbwcsfc82+QrzO+J8kCgtKyKAE3nUSeGCA81I3D3nz7ySOenVMN81ozIBLy/NcMH60ivkoEEG/FPudDdJ8vuSVMg0YNaWjZqScpWvONMyyswMm7z7TeFfl+e83aZtnipWjkhXTdSHeoYysN/s3rKzuLbGGcXHyXJNFK3EQj876gtakQAWK3qOAHhePyytZEav1KcwMerP9e2HJxWqwBPXk6eaSznDh0ea2iEfm6Ll9KAKfQrRLeuJU62i1Kxoc+EfrPjIslTyEoD/nqxZL6/3rtm0OiCGVqGvlccZp8t5QtVa08E9KVIV7bilpseBrCy4DLNso6zcuPuj1y3ydYHSExzv2jIbsD01y12ypBo2Hi6la3TV9t6P7BlYyNNemZOVbF58lLQTJflEcqYvf76DpfT0xrvojcCG0myOCgJ8rb7PzHl60lezSO+OYfRdli7Ueevn1+xzX+fbRfl5gZ7py58vv36Xc9EGxq1NaVXEeHlPG5NbtoxX0FWBr7Nk38qXVcfSpwJLNo6q5iWeRXlqF4SORwC9zk95jLM2r+aDyHbdvVtqZ2GcwbE6KtrjKx95OiQri15f5zjWy/ydKN0nJrQ9AvzFwQWu1Ha3bopdOxiwZ08zbQbgjbOw5aVJH6ezNYFJEepONQkwXDOfro9+JkOU+RBLeZ7094ZhJS7por09M+f86muuQE5aAcSU1jSlzJFYNI3HJNFU9P4XCxQt+zFMZIgSH2JKx6OA3kDOeXSbdMHKW0OryWFaN9FH69rVgvHGSm59ZVxRS0OBzjHPpZ2p456KG4i+MZHn0X7H5QOyi+KwWBPBH4rsNPX44UmEq7KZulaljCzJWEQyq/DCJAKoW5ekyO8sMBCXC7st8I/qO3urF3HczHnq4yKk9+N/hyv4+hCdPrNMnhCilFrzcxMgpt6KxgKUJW0qJc3q4Nvo5IeNCulk9oQxwnq2wggxCGy+W9nIrdUDwb4HtnE86ceeEc/l8WIqZHS6/SxJXCyJKc+Jdy+0P3LTw3TuKgxY4hWSdE/0E7ySXpjOMKtKxCM3i8jZtRQ2TKRjJrOvmo7U7CvWkcId9JBwO048FAjgI3mng0hC7jCRxTMFIjyrwS0r5OX6aVPOi29Ll3DbxO11nNocnyr0s4BjuSKSNzw5RF//xpvh3qHSX5g+9ERV/HpJvEsuSrszLApGm0IxcD6atSVjJlXR2VrYQF2CFZqESTAkX7Ios1g9i6tWBNpGyFw6NOdDfOVAQQngio6W7bQqZ8vHZz+sJn9LWwp20eSfmxbX5Sq0nNQtkxA87EVtHCbLwxyY1k5YR8GV0RGRX8vWcjnis3zyK7IokjchI+qr9MvSPfh60p1ri+/Sd0ZzZySFjnMAxRgzvJnsRCVml4hNLPcSUVTz89hj5jTA8fjLiO0MmFuf5z033qWEMkm5WZZ4Ncmj1huPz+o0qo3YYVvxJnPQu7WA4FzbpK6FqWbpGN7v3FdMNoXkVJTNGCraTHwpUyAWTV/VXuavZpu54cldwhPWHzXFrvNkm1VmhvauUsAERignRxCx7Kia/Q9zaM3aw9TEKJUxKLtxY6U3EPHe0pQZw+S8pZaBgLdvATc7k6UpW2ncnqfSkuxfxkECSrMi6rpWaQJNJ6jXcEn+k2XH8inpbgN7I51rG/5zenRfnFUOCyHLIPU6ud/zWofEKtj80kK6U/TtDx3clwP9ytw4Ly/K4/ue9Wd7BwBZJnIkWqX1XPf7Uoqp15rmrqmn7Cw75blwEKDlkmKBI9jhbgXmHMwFk8OMzBCONeHw2GshX2akRgms8dAyb8jZG4btuq0Z7pKBV9gbNEtqG3tHzDNEHnHxElzEkvVu8foQQY/mlT8m7A5lK6PMvCiT76KrvdcF/3UtyvHG2vppc0qwHm6cg34K2bOkwYrf7Yg4Hr3oF1wB4w+OTYdl6ac0wue7I348Uq98teuRZsrZtHzFJBiFosdbm48xBeFZRTswxrJB2V4JcXeaBnSxuWX865DV+pDK/TwYvzT7qpTbz2bwsh/UAtS22fpRktrqelZwfp3GcilJ7WZeO+2WOhrcTTnjzvuQHF8hMmZ/NCefReoikwyZKeUMTXfTMqM0zgvC0yNI31Bh4JLS2tIZm7kPvU/EZmudZBi4jq0EFyLT0xFFMPW0vEmSn9MOu6k5USrPBeXtUeTH7yOU0M5+idKPdnpK9vbjkx8+iNEOr4XWVuVV2H6ds8TJt9guQ+XwWm3QGgfl5t6HabHDpiyGOalRDmuMkDxE9QYOz6Vk70K9YttNYxlJUqXTbhzwjMBfCz73mZFH1Y19eo2tLHtd5yRGOYwB5eszxD8sPwcYsi2YzNprmxm8D8Pvn/sIGnLdJfOW+6sutTOwzNqSaLCHNXklwT2dlY7Lji92KNUWdhwbr3F8mJEbZfBGo9v8UW9n6QMCS+EEXkUTAgP4nNtd13589sNfzjpumhlKSaEwNp0V+bnhURyOXIUvfgJvtF/c7fV6KoanLd41RQOvuevtYL2YtrSW4h4NR3FnZspY7tyHjEsmH4IXpRYxSt0IUz2iFkFuR6FX9QtPj9Auv/BzeRkprc1b+BMi+6pWsrBjlRrxwXHp1Qq967a4PdY5fVU0ljo8aeT1sWxL/kVBTDIqlkCfO7ntxqzIKQkYm8SDMBkcK7E4RkTyMgCJZfsR45Mf16FseC1LVLWA9Q4o8m9s+hcvbjMFeuqwtzGf9RpEgl1YulWXNkcgfVkstr84q/0t4TSzXBml+lbHKaXM7M+ytQWXdpf98lMbvsJcgjj3wM8DiqiTSlErbcmO4Sj28VMyfUucCiDSTGLqHrmAHy1eL84qj79JOW7Nf5m9jINyCwu8NT7jNKt1kia8MNQv9oozO6JMEP/pEorvJUzTknSX50LaX8/RkS7DqhywWoE1Fqe36Uw6KbDSAVBSt8v4zn/GnOMVR+loJK6iose1dJg/FbZWeM7ReEWqdKRH7efOjovT2lcwpDrF0qS7krZYRRjf9d1nCrqAM4pyYMamJR1ESQ1REkSkbbpS6GPMugSwFUu4KF1NocbefXROl33PW2bBFYLKzgE5d6t+YUOWm1RwMNvsvGImrU1+vtHsK3MrCxl2n40dCxvPSSfbC+o7YMqjlUWlJW9RiIqU1KXnGRa/jO9d7fVufTTX2NqkN+VmUQmMGECwAM3KYWJ5HnW9J3lNkh3bqc+ai/JV/SgLwJd2Iyn4UNqIBAS9Li1kTKJunqV/cfbDdUfSM6QAvQ7NkmJroW4J1G1IxyFJkkpExDftAsKm9Oq8ZqbIc4uJ/0AmCAVeTw4+5n5I+ziCIaB/WeLwnad29uLsR1DZfZd0TXh+mYRM2QFoOp3OkmwyOTSdcuTD6rGiuTRxd1nusp7sSzeLM8z6jCbduINx3qDdeWrcXdrI9ZqTanf46yz/lWwBVrk1Qbxw4zVbagHWKrOeuBuy1kqH+Qxe5kMg8vmS4BuUK29JSlsk4ueuyYJ848XmCZN3IZ/ICYHsvGXUPm6pJRVjmBIvezdi/H19IBa6HFXsQeEVzS4GZCkiT+AF0qcahReeVQcPeDxljrcQ5UlzsVj7iO3NWJMt6KmvX6YSBGUtV2Uwrhb+XThX/05ft1XXhs94juOkO0cXMwa8JN0565j56Hbx2Y8gRfqu2akyi1SwZGGNhwRUBP1Lsgvw4jObLZ7j1FqSrhO2P9EObWHSapTkGjW7dXvjvhrHugvzLt3z+Fs6cwnPesibZO9RfKTpuExJH2t6GBuhVot5mUF7pekHGQCBzOWLYm+Q6T3soc2hEPPR1eAw3l569HWY2Pxc22VL6lg+HWhhUihvEpJshgKnOZRP9EfCQKDq+0kAb2BuXTZOW7an2kyuhZvf7XRsL0B5LYs1Rqyu8kwhZK07K1ZhTck+jdy9XNUwtTWm+jxq8PUOgF5hwF1SlgpbKOabCga1zpM6RA5t66SZDWSg4J2mCJtYmmOwOwjL2+y4n8oUpT7FnbS8zlvviGq+CxF3ERw4/6sY99IQcWqZttRsa60uU7DG0vvk+AW8q6nvmS0cH+3t/GzdKLs36j/hCyPvEC4cIeKuPdKpFBu7PjghQqIrplVNumdZ/vV0cGAjK7zQpoWOix1CNKM0yFeN0lsDocPXRQ6fU/rU2AWhmBh4ZsmV0686PvvxIZ3QizgTEo3w8ltIrMTpIFvwJJ5PWXrZcD1MYZ1KN5DqnHZ4S8QpJUQpafgfMV4BP+axaV8fAMidLY21oAt+pjzr9czfHMLLd+YMyM2yaulgnfCsRrQFTnVrh3Fu9XKIrDZkiLnMyEi5X6bNBWX7sbzpq6GueKpgR5KXhLS3ru4nWaNuraTAh7s2PepSyKXJGvFZvXlyWtKAarCtD72i3jxcJW2diA3AwOXUyfliql+7fVXr7SeDeMkjxu8RomxJV9h4is8DaJl0JfQsNsY8YHYfu39xVqFuziKWawvOunoxLqsyBZxogLivVEui4kSiJWkJ7G0Dt94ON4XHQmaan2cUkg9h6RIgEWHiEiyqciDAZ5GdfH61Mp+5vF8eP+11bbpLFsdiRmwW0I1gt2utP4fHZLbykk8AI6vYhMPwqdLkqdN5FItTo+SOMBkkmuvhzwF5SHZTE1LYaUTy0eDZf9BZ8VlN0uNYJCbOUKWFZdinLUzVDn9ALpvS4bp8PT7hFBNUEVXqUatfcplzqyGuTQovfuoK8quyzf9l7WqSHNl53N6nqBNMpP6lO1XefzsEILnd06Qn4tmzmfdlVlelnRJFAiDoMTG3fJZLSn3jU9e2pQNMWQh0s1Qvh2fFCWWVQldh3sAXnHnNHrcfSgEinsfnhU6lB9yUGsTG2G75wjx8ZXhPfkBWlqMaRxlmx1I/A/pscaRdhXXgEYdl/JfviBmGd4yEL/6M2FDA/HnDBxbL/2JrP5lQ6OXvsi3HsVeOXdHzuXHu9T7Ghjh72aoEhPXU6l4rOBveyjl98WdcHXjFxMcyDZdLtQ8PsMZie5LnMEtVfkhLUArc5ORcDJ5CK9YyFAxP67q+GqGOX/6eAU8zfbdWXFRtiKDN/gscpJdj3fSZKODAedkqjEo4fcKDmjgzn9SK/2OEYZFyVOEeEFD1dzhugPr6jKVPb37cMelyKze5lbWrB0hcxtSmTBB6DelwOlSSx7cWHmyLIxTwa3JuZ+KCo80KlVwRb+PzPE+paVrUkI0OGBfHlB2Jsx+paXj3EZiu3RR32lNjgwpAxvbDk1gKhhYIZFeWfduynBLEDLYHdJGTwDTqcSF1lamRkDWayejPcPx4E7vsinomLZj1LCO2bIemhA90ES+ccHyhGr9kLYfryMr5liGQtic8bc6+TMHVNMTUjUf1fMjCuUml/E5gJQlxMLRPF17TBo0KBolmJo/21nc8gjfpYg7PAXlW1I5z3ce2AigsJO08ju8LNJQXkThTuWPMWWGQsaJdCpk5kcJ0kkIVEI7s18Gn9EmB9ULsbtKRBjB+APpHrJXPcX0DpPNwF00tQKRY48AUIsSwDKp9P03HOVRJSisybAsK510jQuYx/x9JXiThi3EdDwc6m94SEvp12TEAV2RsbEvGzq6P7z6CRORmIgLejokLHVjzPI0iJEMlG8OoznlMqe2LrE26KTQJKRhGosxAwhmkOX5W9FRedKHP8JxoVFms3s4CeHP3ERjN3pQftoujfCj3Q9xW9AV/1q6qgWgTyL5khmgbtYyrs2K3UjT197LESMYYzyH15pZ+LLNzX6ecXC1bS9wAqPlqk9Oul+aHaXWchUcaxnCxeGvrj7h+yKR5qH3G1g/KuaOtD26qWEVBtTTG0iqqep1i1eLbIv+Go7DVeapVXxrjt/i+awl2eT+XJ9R16HfYcGvnR57jr7z9Ax7aYZbvbRk+MUeAdlTgE3n4AkTPjJUJpcxSbML/GGDVf6S81GcPxRqutiNmrT2O+3Mu2j2W6ONXZ8lU2yH9JDRDjgwlJuaakqKf5TBqlk5ce2xBxhLlkReQeAHlFzDXPs99pBeYT0YUAgNKCMblNQ4y/ebu44Fmrjkht6Dkzf6bhfoA+7tgNQlBBlVPiC9jqSurSKcxqrCFCWLZNtb82brYJRlJgGP7qLeLkfOypSDssIFDVin5evVu/M9ErPdWaNdqhyO8hRm5kP7z1XZgiGsJVkB/3h8D1lL0CmvaqU+gzwjEHCFp61G8n7t1ev1NNwk6y8UbHbeAr/cmt73GeWdMPgEeW6TZyCP8oG0nahYXRsKLnwyJu4DoCx3DPH+xg0dDuIpypSCVU4NYSufjv7krWIr0ApJmPJI96tq41LJNjyINBag9eD/20knzITjwz+LQE2C01HAi+U7reG2/wa9DvNvDx3VSoiDMwrtha/2Xjvw/Nw27vJpG1NiG2xAjvCXPgBrMEcvKs8DibA1lwzvpfXf42zcnKDHUYkbazZC180i+U9Lb10tRCUyDZPA3eGKqpI/vio6wJH4mhTVbwGu7lE9OHGGNjq4QO8CeveEeYRL0t8bdsK5o2RU563oGYCiZGYwzXmXVH9CQFPb2CeSEBo0977mx9r3geCT/R5yh/T9P6Cqf3+ikXdF6CPryDEHkAFIG3uMvSOO/95B40qCbvSWWCgBnpNJrlC0bRJ3ZsUcUhG1Hn8v2O5JSZFvKQ9rasOMk6lCJ3PJ8d72nAmcA88NxQwt8WcA8h3TEd9VBZEltQd6SwY/NpeoWrTx4rE4kAc3m2s5hcPLJsnfkmkv2eNyQqgFLQxZ7c2HgfV1/Lf9kIZumEIX+m8ypMWJbyz+++/DzEVoiYdWCXYXkz04d9qrOwkm3rfNyhkqSqkDoTrijsFUuS0yY5UWgbwARh6S9w/B/gY1wqSV5tFtVUTd+dgG0V8BG87V9UcrW26T/wK8819WlQeVoSbvrLZRrBPKOmLrymK4vADsuNK0BLfYlnfERDR3bAnawc5bgDnS3YaYkryeGpqmfX/k4+YaCnUDgE2LfDlD+DRreS0vu7XECOpnXMzlMHWOgAZEcZ/ghXVv/DBMI+XiiybPV/NTS+fhnhJdGXQs+yf8hC+tidDexOLTH5G2i/QdzAzub12aRbKtf+9UPQB1jy/7RCLqbxgOlXqDrixBAHzF8GczBZAZmKjTHsD+OxOk5mCO4qzPf9gano/Vt1jx3zoO8GtRqs+O/UCb4G6mBfduqdzZXnrzHVQPphGik7ghnZSyU7zSSDWDPtdCrN6Nrrw8kfAPVfINNIC6jhiu71iylj6F+MduKaW11FPtkB81CIBAk3hQUw1Hp7BXadhl2/fZdJ+WGFlFfJWcf9VQ4Via3Wi3wgdXbYMdG3T0SaAWBmz4Px4yaT3zUQEhJTHVpSNrkEBS1YEQdG/HsPm/W3xc4W+9ApjFWtmp9K91wwLDUmZyIPJgCQlU/6tzGWAmwo85p6MzU9hlwHgFDEjK8Hh98oj0iQOYr7W1JVdTBcyjax3eV5xUUfShmOwL/tTF8DP/p4N92V9uqB60dGApnuyFhdELr46mWqewCssKuYxr4elsTRzW0V3Pr+mVhcu6fn+wq/kqLgdvvc7P1AC26l16QxZitvEHeZXkHElew6nkMBWWEDDsEqogm+zzztBL4LQlBB0PgCR94yD8XAOwFfvRvpSzseZxxZG/uqszNqDk0RLGjf+eE/FoGXeiHrfLctr4wkkX6Ji6hTDGSNboyyF3/oYqupK7HusYrjv8Bde1R0fL5tnx1VvX+1wy2nmlnJ88uwPo6nwauHmifFfmAI369l2kFqq6Y5/Z48S/4gGJfWfrD9h97QITUtjGuPIjM4dDsfZ0iz5fEuf29MecRcSQep7KDgkWslMh5XFaVv6rOLBtNHDqDoS/qKoDo5RgkxXcfgU3pTSmmJYcge4BSYpZdP6JIFAyofuFgZeekkM+BFSLFMSI1LDl4PZBoRorOcGynN+XzC+S9dzTRGc/eVCH0USBwVOsiuiR3D1XRyILdPWff2iAb0vBNqcsioj0CkiRk+j1dwFOxMeCyhJQxIb0WP9fPDMb4rqjLjIVWiWJQlX6GUFYoBaeqCsjIzxBK/1jyodcYDYnQEw9t+eVzLlDw60dm72W+GgB/oLrz8KebarzR66pq4CyIY4xvNH5AnSC1nL2hc9mSwLknDg0c7pphE4n0AlFfaKjiG7B8YQSlx0feMlW34mITbYAaTpe4fbi51AtqFdl2cIXJDcem89dAQJqOjsnXN0V6qIjw9OjRLzCY3ua8abo7Vqa5aRcUTpbRjogxpwZsYGD0Hz/fDjKZW9ZOlt0X7HJfAVMWsJ0+N/oF/tIrwthZszpmI/Iy8GlSCBMT5Af9WlBtWF7MvQ0TEPtGUSsQcG85b/DORQADvDBkOz1u9GP+0nsrt5zkW7nU0N/sO2Aygx9J/Dbw7QP+4kuxtI/zRYRAFwyT5BJ1if1ABhCwnS4z+jl95RFSmmDSriTLadozbmQqQR6WMoFGGhTt9i+e7WMDOTMrwIfy1UDtGpFdPjn2sbW92+F6k9KtCYStrCmtqJmHWrU8AZAfKFT7YLuZfIEZXSJcG/z4ZeIeEL0RMfzGKNMz1vw8seHw5rKHiAFRa3C2UVVboJOQ+HleFmbOOf4v1xWzSzEbFbUsBNInMPeDYcA2gX29kjJ+Ycq2C0xqfg3KsblVMSttZTS0pWx8oeBg7WmA5GAQhdYW0SSNXghbEKKWhRj39GDSb3D3Hu5w716QCtwL163Ary9mVkjBiC8MVFi7egUhjMoGKP/kOI53oLePkb9h+j1lwCGvsU5+KMLEUEekspgEs7nr8Kadc6DQLblLFJ3bl40D8Aa+iWQiSYtum02LGWX2xSIJl7OtRFYjAyrkxVkVpK2TUtgI9gxAUg9S5WVAMHRUxkpO1/wGeO/xMDf5lgHhr2RjBYjxEcYuFqXKutASLngdlt2tLP2eXjls9veNgDcS/EY8j88LfYGz9HIQzlrFOaTxgJZXldN5gia5qVFzLVE2RQCyL7g6C9odKfetrnYxzwAhDQhOnw59aZ5lHCtg1jg5uV7z+EW8uSuzV2ggEKcT2aCx2eqKoAWZFGjH60xMxDFQ4G7yoy7uNMYJ3xd0RYu/xjbFYZkj0DMCST1QVeUcPOMgkcDPp1q+o8V0w7f8/at93031CYxLFL0T33GWZRNyT53rBYO2Cos8JJSt7igVybYjmXd8OHiHyYl29v4I1NjnG5es3BcGqijcxXcfgSHrza4cCzIrC0y0Lb1ncA1bffaE7IPh0Ny+CQaUjYCmGJeQ38kxIOzWCbp73G4gXcdAQyq9K81DXpsRLKO7NDl8jpKkNl/pzDh4c/cRWLHf1H7DJ/baJJo9kxKbbpWr/WOiuMhl6rY27WhDWdQg2MNiuprw51C7HmndPW08rrPARsKG/4Ra61WNb6tDpjB2FA/V7LDR3LH/zd1HsKhvhQZ7zKJ6xo6isle1lyLGOdmbFM4Xu0ebxt1jX5BtuDKMW3PSWk2qamC6cB1zDPuy+hC0YP9uzyjCGLbBCSe08LL66SnL8+V9vhgw0nj4mpCnagFNitjtSDCkuM94E1u1EN7V6+eWY0JWO/ret923xXM4JSPDShjL/j5C+zxTDABGgKEHMOr1A7xHapZxGtq6fDkC7Z9nTrEYczM1BTj5PgLe3BV1b3tPPqUAUK49sBWVWCLiiJCWUCT9vONZfHuH2A4iUEO66kkdpZBrVVHY3dKY1wjY0H7P0LbNAdDQsJXK/i2BuZg7j+8abBMJ3n34WwBKe5Iw9P/jcI++lsxv7H9nBOBxJB6jslccFNuZamc7lrQRvyBb8DLymzYtKAAHL4Py4BlHgrFwNgt0p2hlZX4HLfaFNmm63AIL4uUAA/MRs0jk4EsiXvwy2FWMGNk1wqSu+pziFt4Ve2Vbr3OgyGK5OQ971WVp0ipGQxy78ahHxrWvC63ufCWMp5zRdXvfeatbattM0kn2beHqSAPDiCDXM7qzlOuHNx9+Pn7LhjC3p9AiK+Ehvn7hEJBk1zIfIrsQ/xDRS7DGmO9oHp8TisQNvhTifOjrDB62jzN3Tl/OkMo3d/XG4UQ39gcEbd73Gy+Ac4pKn/asvKMw5MumYxFzJHqOgCM03Nse1ZdroaG9mqP99y57l1m5aX/QEzy4VFNafqQadLHlcQ+ksHC7E9TFZKbvgRR2VKgSoSMAOs0Ea9pnHLLOCdwVvtBD6vDpN/l0nMhpEytQpau3G7u8PlXWrcqpCtfhxDlEFEHLqBAdaVMjLWvI1/v8/jf0N15pqWN79cS+QLhHYzjA0U1YhIZ5J8FjTIs/unlgIihpgEHbEknn3PaArQgHC/U6rrzn89JtIH0EI0pZh9XePRGqwjrkQA9cvvAVDuFGkK7g6aBVKUAtfohg2XcC+gO5TLV9wM8eAVsBDOaBZr94wIGIoKldmC73JQNnL87e21JT8aSATtcnxPZGBSr5D3q4156eWaCokUapJs4YCRm7gN4LmXqP1/8QovM4lpscy4IeVNurotda3MtCjdZr2jwqx0DrOtY6t7v9mgtxnQhDoMSOlNshi+NxPh979btWDjdpkCsTy6K9aNqyTtAmGbxJZZ46r3ac38CiTTodIAGqpe6xWwGJE3E+kQuq75r6DdLdo9FvzQPBydnUU3ORAf2lHCohNM3dGp534yBKSouUV9tFNHBlXve1WZGSKyLpfVL/7HjoaPkJe0IrOZQmGHa4d3x89+Fuy1ue2as2bTTb11qDME2fFmyX9t9agoroxT3VltSFH6yfkLMNCN6QpHcY/ecYSrJgsPysmrNnh/pZ9fFNFebVNgUKSpy6MGDMG5exihplOk5X+OjmgzbaW6FbF1IQOwPXmdBlAR9N3Dil7Xw7o1QjLDeAfj2kWNdtMQGU54/3+VqdfYJLuQLQmw1mDROg9c46mvSleQFeMgq7gCCaw4rmdaSppe5FD5mAMtCo8SzqU4strz2L7G+4m3k0i0aRQS0wtf/sne94lRtKm1Q2mF2uIUgFOEpm1Sz4uNT3LRhRy0bM4nisz+eqE7eGvuXDpcIQvEjOW+mNwZgaq4NXYtmCnFth8QV5LesYpGvXOxLHZ3xCiYonaPl86XtBSRM6YCKdNUN5wlBduX3Ct9A5NGlQM7KOaAqKxyo50FFMRYqsQMAVqVQ8TcsfNPJiczBOSfZJWpI0TsgLb6pItTcI3Id+XkgC187pAfh1GbdYJnvUAVGni+M0+86W1tdre/ruXbmSjCBnUnFOvWY5tr24kC3RgEYRRQuGV/1pIgruPgKD7Zs61ssKESy0Cs/NVlW6NIvgtUr3Cg+fUUWmN6RkEw5ogGBQlqmkiUS4kWbX0/jiekHrE31CIUQBkf5q5QsPUZxlBaaHBJ4s5rZnTRfelS9SRadaZs1lGUHbndPJUu3KubiJRrNLKz88k1y68B276GPdDjSuywk8XSOkjWLq+or4wKu6aBJiGcVKqqMQsdc2CQGmlTT82JZQftp+wMdFBF1uJLpC8DKAOmOpgids+FhzhQyiNmZsQJ26lQ1zUxCYDL+YxcOtqB082Jf8+h3NMWododweKr4XGwr/RVG+JRTzVW73wTnnmhTe7Nq6uF95dKGGk8E03KbJ4PCUmtfaDziw7WFwxmOqlet9y1nUohYM5/ZneX9Be+GdxPexn+tSdKY8JTibSL3IIXFoUL0UfGltV/AJpNCeuezLHnwbgb2hVMMTdnxBa+ZSiZrCZt/7yePWOc8TPAvKtVWgtgfmHpzc+LDpFPsYHcnrgS4zknHGRKVHbH5DfOJVIMKkG5Za43U74sYWG2LiMXAnlhr2efKB3mDrgAzcnjX33PKB6nzEL0III7GKL255Fnh5smAdMCXRRHVMfTgVXnjXIr69RdnODfAI87qQ7Vg0sJ/oebvX2VZhHEM0sBeDRrYBKcWVyC/YZfxqfBj8w1FEL0aAXwAPemDiL56kNKxW7P7eSCj92fJWgbAtCAdzQiqTaylHdPHm7sNva73VUWjffxb7AUvKdXr4YNwosM4eI+0mB04fA0TMSr9vf5SwzzDoS3wzt8ybc/aFzklU8PaLTwtrwZ7YB94CzNT4+WdFs94+2f7lbmKu5B234ot4I0WHxXw7poa+YPsc11+1/QfkhVuq3qxJO1wcVZOjz3pbcQ6kIdeu4SkbUWmLwedgTvfP93ydST2uKjcS8UalsFs5n4QHnXsaSTBqFz1x5edwsviuZNYXRESVfW9w81HfOOY6QzczmYrPVjYOGzb4+SaFMWEb8LseHayFwSHZmZxtQ2n28gV8QL27+SjnDa/EwgKb1ZI2nfkFpyZxVSgxLIHvuyqHCCKLebf/aOMdDhCgBgFP77P6H5PPXj5yy3dwPU35ytiQJZC1xeMRFn4oe/dlzk+b3PVoBSybpXCZjoAXicjqf3ntc86BvKfVFTxXidDb13nw6zd3VddZdcp58JdAmHbqumIZHGR9yFByGu1gjVYogX3EdVs+G41A/p4Z8DlSMaX3wGcElHrA6i+fEvwc1gJ+3srSV3H1R1ytx75qMFMGfSMN3Lj6kGSO2U1qa0e7PNNz0JJ9nqEEELbUO0OLJGmBgi3mdj0u+BuJrkdHaTIXxsfMxesZMqkj9IZiqm4mwfJZMS9Whtunv3ZbH/AIFSehID0SsMd0l0ePfWFEi+vec5PagvkBUgGccbYu9silRgR7iUuqcKE+nT/2awkFFQS9sYdPhJRXRJFF7ui+m/rnfbMO2H6rnRbaVxlzYlBAOv2rFot704IBNiPOYkFcTMcD9bumTT0FbbZRV+4bFznHdO5Z6ZRO6LLAWpAYhj17elY64V3JzC+ChixF4NO3u2o4kH4QeYIo3Fb9fBuiXLIlxsEi3MzD2ZQ22dOwuoYWAiH7pdLpiYwcklp0WPJDU6CtlDe++/APp5sGrOjl5tVKp1OybBCYMK2n18csx9q1lz1TzaLdJEgZsX0BN+jz+74Y4Lx2ew/UItghJO8zO9cBgum1x3cffhF2040I9W3iZTv9OguRwRy3ZuHK2JEs5CZy+TVVsXUrz/lJAvgvAgsDQYcv/zibvUIAzyONFlucPtnOWKI3dx9Bvq7JPBesrERMp7QHvnIf2JrQzOtp4W6eE3kt9AVtBmNsr8+wD8Nv24irAa94ODhuRYMdj/ZLPbLoR57747+5q/R+QNstXNUO3K2p7hidgqyAFTBmFT+tOF2mwbdueWf14iqWPYHzzvqnRKc4Vy24fkuu4MkPNJKrQPjZxJ/bFr6OSKzZa0ubbi8ll2MCwyJJv2dCbdN2ouKL2SLxWyRv8MQQfxTVk2oc+6uZgd3yi/T0honvPoKJcTd7TSyE0dKzI8NNS2od+x8XTo9CvsrK+KJ124ETNE6dAWNlx2B734MS9ax4PS66niDUy5TYXlbrv9b3HdIlSTJapQ7Nfvg5ifbN3Ye/n5XvNwA/AhoKrAoOj/MvIBIDEDFgEbWsxPHCiy9fUKx4x9JNa/0JHdEGYKDu/iGdOucQkFWhuSkKUCBiMW1PnmYrH5VVSPj6BHGgcfEFMc9cN6UhPVZu2958/Ul1o5t69fa1a1ogpBENLieSrVhWOlCuo5/N3mQ7s038hg/fweWd44vLFnnkkpaEffns0G8oEspfee4HshX35Wikkx3SWSJC+7xd4LXlpQMuZo3XLRVMGqoMaL5dOyRazNpuzqGyK1KCRXS/ow34XGPtZOE3pdeQjF8yrxmA5JW0YxITupkpKLFidlf50FJnsDzqgbJ9puMtkmRHCu7YS8fz3vmCXsVDnm5ZEDZAsLiMeaCFrb6dlIz4NEtUNIyH7oa27uVUuaw454eMaK+AJAvELb4U5nOhmoe/CMy0EJ2TrtvOn09C1vL4Cp6NJ3b9M57ysmMAa/uCVzeMPH/e0D4RSxTr2jwd3Odpvj9v6GZ3bYUvtZpZZ9fUCTbXWuG6dqdYQWXI69jQwOeZHmK5Pptr3abbqEnXber95WPaRicKN9Bx1mp6ITQsX0HqCBlyWcpoLX3KO999c1crAMYse3xIm+1pCqakGIs2VZiWvc1H3Q63dw1xfudKxJZUbd9OOBUj4F49gux3D06sgsEA/YAqCtkjT47vKt1HGxteNAYFWkJazwawfcqexQ5lk+Xv71uefIPed4a+vizKk1HtbwYytkGl08Rk2dcAYEkz++MtF2gs4K2CgVhoC3fCu1boIvm52PvYUVSVRoUux2VfylMt27DEjPDbQCtnRtmApWrZncbNYq0uqrDtS2QHyWYsXdozIEkdRvUXj7fQnFH4uTNC5l+KLbSuE7nvq8oP5Wrt2UcX3n0Ek1huKrlskw4ppK6iwUoQTtmnnktsTd12zY2iSZp5gasZti2l1orUXZEazFOP6XqyU4QuiOicrX81JPx3SM+VI2huqdWE1zV2dXZtri7Zu77sF2WmIrYmm2RmyZauJSZTGkMg0AeL9VsYopaHUO3giSM+L/JdBOaWExmAbF62Q6usPaUJznJNUIvFCkmq6HLWIUREyK9gs7cnmst4+fRY0JjqK8E+byV0c5GbnpODc11xuTTbtZSKckkzpiEtQbvobpasLGiYogxbnjyjIsrLJ8gieY8vBnryWDALQ0QDGcadfXGrbh4rvKt5033AhusHCTTa0uSOZYWI7Wq4wnPUmsUMLW0oBRPjEWSydhrvVtiE0R6YUMJq4XoqTiPaK6LJPFpNeBcmNzbxZJcdz69l7Ue8vUfM3CRgrOKgawHKv9Kf0nCrdNrQlr/KmcmTK8fIbyLLvjO538QK9kjxHvE+Pk90VoBVumywQqlCZrqV8TznwpuCNW0/pyW4vsOob2xzMDtNgZ7s1LLIlzZ6QQHT+I6ZdGkCl1YQslnsyERsSkWq/b9Snf8+3cb177rJb9myXNueAf6c28EOSVeaVfNzJ8oZ8UyNuB32KDaVrSkZoIa8V8STxVMxnCEap8KdJ7xB91NZxWJW5S5x47sPvwhFjYsEt1G30jF74tSmQAD6mm23C7N7EtfRDF9g/sBh8XYCiH6zX2NfaacKH2DuaLtU9tuO/xg5T74yC6LXVtm1fmqXN3elRUL1DEiqZQ2GqVuLZC9r4VRBe5yV9TtHjVwafKvpd9bUvtLFU8YI3iloHh+UrpRZ82tf+CciPC/BpOebfUoApTQ3slOEWxQ8CbSZSqGLxaG1uRtbx9ityLjRJLu2FZxH6QT8TyjZ8wR+z71sb4PZOKieJiwuzwNTx3dFSqKGZTskSlyMkdmkZMdoXCFyuczSn8eWJ4f3nVneObn4QKAHHOo69EhovxXlndtr/oqZthQeQLbPHLUwMdJpFt99+DKLm3IKKOHVR2aheZOm0ITCs0rQW0afn/JX9KPNM2O08njemacv1w3UvZGIwxd9nAR28RjFeTLqVllZvrVj+Zu7Dz/JpOldsW8ItYvljUSTCR01qDGnIAjkaExfO7OuPYuvVGSZPyG0FeBgoV7LU3d9qsByE0w6OFcMjRM2gDOVlDNa/ijPoQexFWbq8ObcCdraQI/QksrxiLd2Oe5QrOVJu76hwPJSS4V5S5SmLlsCodZ2Ijf2SKASLYPMFg7WwVZ6xzdFSO/K0EIfLMaF9CIIMJJseQKvb/SSeprgWz2mthi2f7598UnYMRYlzC2WGEk4FfL5bA0n5HNqDoWxjjZv2Hsa9arGw02cWShf0F94a5NG1nmfT0DFLw6DJjVkuQzWHpXPV2ltO1njK5yaMMkkp/yE7FXEdYWCDUfd8QUlgsst35qCB1mFXOku5BNnaB5Ex1PN3EiNJBlLaFlsfeze7wa8l9cDqV6g7Aupa5/q/oIGxUlB6HGF8dbqYLT8o2/EAKPFsIjREHA6nOFZ1WDFLhi7wxLhDaLh4x+xXsVTt5wobxtpKJDj9zO2LXRdKczHd9U9X9D0pcVKQ5GxaUjLNSewVEAT2LSHhvwHwo5B4xhkjiT8EcMNQcLkpBNb+NBbvUKyHzmberW3JvJZDpeGJqImTvlgzdhpQpe4vmEveB3lPXLitbOeBO/Nfd1X5EcK/ri096CAL1DwXljSpAokAAxAoJjbEssEASqSfAmlsbSUxuK4BN4gDYIlRtd4T9wGPG/M2Xsc/zeIaO8Bb81EKjTrW+StqhShFypYCiOotUgYGrOvW9FGOwhOnlnXFidEop1I5BMx1y7R/TkrA3bMMiwUnp1IOv3OuoV3eEgPUikLIxx/SBtAe0riBSf2lfiOB5pf7Rvt1N+gvq+be3D5i4Dt8LiRXzxItcyAfrEcfZBfj3o7xwrLFXtpg/8B+6NTz765+3CTb/rbpZpRgSHHgCi27QbJUrOS7wxpbT5jhXDO46VYBpNgAbJt7zwsN0B+Y87aY7j5wQPD4FstsoAxVDxMwDxcnaje8X/iGItQVV23HUx9wyStPMr73tmo19ZpzdVly0276h7oqP+anf1JSeqRJDdJEkvqNf/JlnBvWdBwZtCnFBDhea1tmJzZeoa+GxalFmAEPYfK+kCJH7IwLmnzhQFTnu3aTdwR491wTqLnHuN3z1RcO5GQN2a0fl7jCQsODLlthAUvaACO7N2HIyP4MhpX4I83OEU5WmeYkEFdKuO2lE6i/uauqHQLnx1UAkzW7MQUwGqJSLOsk6S+FeNWmpSnX6LL9fouFe9cLXxtqiNl3TDdWGAkiRJYeHv1QMitbdu2znHEnJVbTnPkm7sawJGRR3di6fZfcIK7mXDYq8MEVp5gre5X6nIyMQkSkyYBhu9i/kp0FrpJO7H6Zdn7XyyT5eIUiCL2D9nvFoQpfQPxXbEMcOywQmJBLk2kQSRDhcdc/0HZhrEYbX9OqyqxvSGpbPM6YJqFSMtn8MOrj1qOo4VHSEX8Vfjd4nfav8j8eSuK+l/aQSg6eBpjOyYxCNd8bv/wrhg2ezWaZm2ZpK3TfBg2gPFDdtENuXQ9n9PrZAg8OkIMM4A8XYhUXwzE5cBB8Foa9DYvX0DvhXkJKIgmx/nezgz1N3f3QAYMw5PmtyOzOfvfQj7mQ0Lma/+gXmf/+62bvn1urD2JtCqetmXXS/bX2p5amkZ9bRXZdttA27m6OyvqM37GvfXw86qbRpKWMXRetRCsOeaDRtPcxp2tKrVvj0o41mU+VW8UfsaofYDxB5ITV5/yjW54z6Hj5lDoNbF0CcNgWsIewgBqsFEujpZOO+S1FBCIy+QegWWlJQR/Gt+d9vmo2z6aOe2PqP5cSOECCbfctSCz52WeU9uhCx31U1YFExnc0GV7uEo90EA9rglpEW7tYtyB6MKXaHxBPISGvIujtDkvzM7Y1TdEAdN0BKnaAGqkdCAK35jGN0iPqbqI2vOoQMVMjFgENNAoMHnNdf7zbD0XcNA5D6uJpXoTMwXqCblwDFtj9wJgwOkO0VYF1iQbVvso13zXUhR1IIV4ho9/nNePQZxs7m+kfPEfSJ3264/vPoJhcDc1ZfZDAMSRliaUzEff1UjF/6gL9MqizBs0npy0Bpeua+yUNhCb+cI0T8b2y0e04NK5suDomf4yd4SkToNVBkrdi1vtOF3FNx/+eN+bfTMQ7l7qR4G/7LN/pTfazkAXCU1SlQAWnJMUbyjmZVr5+6afJui/cft1fvmYttnx1LA/QK7wikqjNKGnFWYoco6arfbrUK9v7j6CxSzq9VrsvoUIfub1zFr+BTNj9DBGG6P+m3CveFvrcwmZCyTQB2FBdCOBeuv2vNvD2UIvh/+Af7G0lYEZZ5yVx9vAyqrj8Za08xm+UG/mqdO+YPVV2G5cCbh0DPXq9cgt8H1kwTboqerHss4tv9zWvVhZHQixA8y7cLBqVleBPchrbf+JfM6rPnTelQJUFXS7ne31UIRWeFSVGBOI1znsMt7pYklC0fuxKvEZy4DgjKV2njTvC3i8Kx/QVFXLr69LRJQdB6KCoWe1FT2WrifMk3oOSl0VzChxVLS46ecjeW0kx43lCZ6c4XMHAI8iveUMgDooSTvYOdD2lz36ZYw59xyo0+rOqb+l7GbevJaWRWQYEBoMBOa/vlfwF1RGXgVy01IRrkCLRYV9Fi1+tH8s2z9TRZeFx7Gbvi1uQfyJwqQA/d+TaTzezuX4AkWSL186H3uCGMAHa03NrlZgPX1+3tx9BOPPbvaiQMXGXhR4k9hxrSN6YBhKVS1gUX83cFoxd8GkQi0zWF274zVqpQk6b7xGHVyH9GpRYItCsIDAejnogIAwotu3TL7Jwlw+tc2buw//MLqhIAE0tdJuXUkr73nOyDQPOG2549rDn4dFv6L6sKE24MjwgKUPOP1AneJrWb6gLvIqrxvsxLg43wyXLbuW8wbdlid1JVj7BQKxHxk1ZrVsTcLEcuoLWIuI4/DVSL506RsD1TzbwfuhYVcD8Alitb2BveSrelbw2GnxFBbCUpkq0H4vWz6Se98S2QDyjhDycI6JN/bkG8SzR0lomiwS0SYD9TaujWARz4MXMP3Trf5/DpNFJtMlwVl4r2lf9zXlgQQ9Jjw8guR8fstiaFNsVe9iGWOVynXgnDd3H4GCRPMEUT4uGcVbyGsKPgmzFXIjAwzIs+52vUTPpmsqK1/4RWlf93WIgWwxFKh4epajkK5NShI7fwvFZLaOx0Ew39x9BEfxTe8e9ApPmStZJbzdq5CDV+DzMt8rZUPYEMNhtIT6dAE9q4QN24ajNmPfGyiwEvqGRNx7wFvS8TzypevQawlfQWjWZG/1O5dri8fBmoI6PlrzrUgIReWBBj1om/a7rL+gNfPOpZue8RbV6xberFSfJgc4n7n/8UrS3M7zcPCgywjd6Cxx07IIdRq+riNSp/latmf4t0KRAR5hdAM3Kz/Df3hXsJbFPvTEsz0FCerYuBb4aPzFRHv6ks5wX7+Hw/dieufd5DIkLqMiYKvABriT8py2717tTT9QnLnpKL0dq73dnWP2yXkKhFdR9+pqPvUZ3RprJ3sJwLfODfK62G+AFIcCNU/O9vkoYcs5M7wQOtEltMezF5SduQj1nNtrGSvB5s7dgODGyb45a0Y8JpMuEJsAuiw1EtIRyFN8LYune+FVWz+o+wmh2THUX6CcjoqSTV8d1h74pOg82Rnum7uPQDekSXSAtSovg6/YJoOU0wr2rapyju4Sx/2QLMlS9DNALtBjhvrNWJbkyZi+gOW5AUnDmRonCBVU7yrGL00juLbu236bytQLLF5CRcy4XLZDVajJCiRckSTNl7A9ER0UF4zhQ8wsxrkdHO/N3cdDkaNDvolHmlYPzG3je5VOdcBFY+Inlv4Psf0bssnv2GdfCeApB34pPZQBzMXQrO/wCeCjmfSHYyhaUYcMjBEOgB/eVf8MxsKBc0LbGowjj8vRxTiBnHzA8v45KMl1ovHnCrybQ+DTQx6dtA+MtZiPowMr/+1j/YnSzCvDbprIVjaRUhw1VNomNH+0pot2ZO1heSDhM5FG6F76tTay6wK+ATwcdBj7GrYnpoGBDwzpZF4xmaKja2RjGuFdmVfjWKnthy6Cqc5DXFmMQ0JgWziB/Tgaioz6yy6jXNsvJU9VMfxh0KrXSQYcMUek/Ai2E8ihgkqI08hKfW2c+UBQ6Z5CtKsvidBJ58fuTFMGg9/IomzG2Bbk6HezohY4Dg4nC+uEVyMy32f+Q/mlJ9bcnxuTlhXCFxfZRanxmbz45u4jyLdvNnFSgczLGSexRr7iWObJjetA6RiGiMpOuBDz+uIw5P3zJddCKR1yRE4m/w17RJ/+dJeGg0Llorh8kabY/nThXeHwdkYW+okUyLVXKxuIt2iOwgU82AKOpUgU9WT69uDv7MR9DYunedkREyBF42qxpON6bX37SGL17z4T+7bQlDR+OOkvbbs1dB0W9B9iP9l+qCdsW9KBNBe1xDqdPRFt4XMcgT+AK976SFrjbTA6kdoblQQZRYsGtyJxsx2tyxArtmMtarGXeeVAKlgJIEZQdQBsh0IcR7XzBWmJVzDQkcvqcBpEoOl27sx5ouMq84zCcAyruASvY3rtJewZPqo9v4UsA4AzFKJ4spVncjKIrANaWIIZK8Z07dwkuvnwJ5oCgqRUE8klYEHMMemH/7d1QN+cWsD57AFY7Mzu9Fm0VOOy4kbYQShFiKQLntThl89TWqMJH/jHntsrv/zfYXcJGukORFTbzvOxM7OEibxTziCIEM/d+Q8rGzKhIW8atRZF7D1aPypgIyAcgN5f0/JPIEgPUr0JnY51ZQGNE/7WY+fH4AOaSjX8wjNO0o7tNvVbLhhqnPzCbRSK+ooivNbHd7/Q8ucypxqWDO+jJgDW4vjSqgUsbhXDlBOmpUDlzEqueXfu2q+xA1XHQSS5jyT6b4hZj8j9gh8dBFttLWrFIesuV15bZGDHG10xBpDZq9Wj8fY1nr5fWKw5jzTqnqZdG8aWJqVeOnTqX4aEnwwSdCwD8QUg616L2FlBKbO5horfN7nU4ReFGQhrX192Vl+ibHDi1feUTUDxhJOo/MlVXxDYeBUU/dbL1ADISetLBTS4i9iHudSSY0F71N2Ta4+GZh7KRuAfvjt4XZYy4DRDOY4n3vmT42Q2thUQDdJNpvQk2uO7qs4SCKrFd1M7mKCNSdRrCU9lL+Ke7hXq+30PnRivjfBdDw9WvLTiJ7HlJDEvrq/ewx8gcp7e92YP/AQOLHTILu8OZrCiHSP/GBbzn2EIhcMQBJgt++qEvoSt8VErfTSOy53e9QWlhZeQsuPZagwui84Zn3XuLmYoYYmhAlG89sw/QLWVVmsDiBf59BCsDpDtUJbhiTi+YLrtneNa+Jn0N5AGC2HXWfYVXqOSDlY0IBzQLcGOQUhkh0byABa+/DaS64ZZgpdUfEFp4UUlOm4DW2cgHHwi4hALCv5EEmAyUOsghIF2pSoIwQrttdc7jiqgtGJhhifjODgcVgIptWtWkutouxs72X9zV5bbix0BEg82WIjseh6S2LzHu15oX3t7HvtNXaEIMdIsRtk0Ts0q9M7qJtn7/Cl1CjskYCoqSUUis3Vqnejuwx9rDDXxgPMj87QGKKWr1gQkkQmLiHqxZ9zFC5I2KJEBTljpfG1tUCA+jsTKnrb5l09jMYQ8UIMRDhLXl3T3P6voXfXATZVAB7Ah7e5li2KrByp1D0hRcOxj+KVkhUjYaDmlJPiSy1IsQ4xki5E6wVcznLBndcBFAA5VJe33Uj+ZTnzzEcSxe5MHBR0M1DvZeficDPhPZRjXYu9qN0+oHUZJP6o+hfSliGawE3TIUL/jh7eSPrwrJXkZg0N/a0agn+1MWrHkk+lFwYrso7932XL98N/Z53sch0uJ7KQJc6QHW1FwyL6SMJ/IzDwUhmak6eLZkDjMOqkYxSu3/6S8EDayM1EMA4VInn23Aw2Mx9gz8lzOwuM3YkmaJ2B7ci8XWr3ArmCGC6O61QxHSB7ffQSm4Dcb6NEMlNSwDjhCTV3IXADl7czfzg71vcNWzwpYkSeI4OoICfvqoz58r2//l4+JFqi8m6rstb3KjD4ZouqeyZqzcI3Mbij0qUlxKhLU3vdF0Ma+MHtBe5gM8AnQDNz5UAHNw7H6VK1H68aaFE/D8gSwL7TcsKBB/zxquvHU2Ly5K3eXYucqgNQLjqBjT9nIKLcwgu+HflPXGXXkUFYhVfSGWHJZXYcD1mUwzVTSswH9dXbqJ2muqyC4Nb6QaYqUPgDWdeJhyAtsgtUWaUeWQptVe8OeuytW29JaesGhHi/Q74UKBV/R8GnzFLpzLxltom+pET64HxwQNCjwAOcCXSY1IpMECEjkRrqqbI3IQlbcNPhn5Eztly9KCQQsntrlF49hQY7MEm15+utnBoDUGNEa8/hsKdaB9MJ7j2Ar3lRNQH8na70Myks7FG/HtkbmrrOdsY9+sGu2h7L6Y6083yVPKEkJFCyRKMPVcDz55gnBAqLhLOSlYGD6NB2O7z7covOWPyJOUYTeaSGmb5rBdjF9+BCRJ1ULsl6EQGpoIoQd0f0d4RHQI4H6ypVqfUFO5SzGGwopuKfgkoWppx/PZSuUP3kxGVl7zMCw19S4QLNlaOUdMe2z2IEvkC/T+sKcSNdH8X5oBoZmXSDM2f7fxIXlm4lNMghbGYpepWfgmApc72k3irxbNsoB0BkBo9HoFX9Syxds21x/nps98rYJxu6Rt3C+jRiQxiVYumivX2lD1zCWszc+lf5bZrYnv4a981Gvvdebr+tXSUy7QQGV13P9g2LOYSJuMhHIVVmcdDrgboYm6aRQLWclcHqOz52kc6UDs9R/n+uB0j4S5kdEh0+MPCNdzmJkMHIAe5q2/DvOBfckJau5wXVhAS2zdDFtu7pe0asOKMUS6HLM6jDRLtllwsBTo38scUHDqm1uBv6lKiOS4AR6nSBVahAB2DH0Q1C1/tUh9IGIyi0ybjrBWvieGupAGRJxKwjYC72zcFhUHtsQePdFi207K6CLqtum1kX1Aw4g0Fy5Aq0viIm8MHzT7BoDFRVZoTgc29UDWk9gzhCOjPVUE1h1BVd0hWdl7pF+wdU6BMIjX6b0xKqgM8KxZd8vnaxolXAOtfiuoDr7lZigRFsWoOr1TEIHS5AIG1nIORKbyJPBt0OPpTqRtMeTAm2YwKJPV3oHDPFVTfWReu7fzSi4wqJyn9z9FnvX05fHloYFdew6yBvGYdTRyIJ9bnH4eJsFOh1f1BMq7RxZ3jNlr2gvIB9wrQ3EtOdI0PjuI5jPfVOoYaUoFRZw5pllqj2rAoegAwnPbEvBdOA39CrV48iA2YfpKDVcBUek+PAEIr98TKtkEv2OLPVDJ+Zr7/fgzE2Of13k32thgNkFa3j3EcwsvdkgCnSvymwH+Np1WjIXmsmVVhYU7vJ8gHl+X1j4sO/B5lWHaNA4GvWZen2pum5pVs+yNVogLl8r9ow9zQB+TRVmdZRnahffVcU+UGZM9nPA8nS3xVUAAyxbExozwRzsI85XM/u+Y+98ynze0+NJVbcD6uesETAWSyOkP1KfeRH5pvkvkEDJ++y8T8xHAMHBrEbBF0Mqx6bTKup1rh8rRBrT+YC/C9i+SKzmS9sOOon4j7dpCf9FT4MKe6gd7t/cffgF1k0LTHtrTQMguuVqxzDTdv9V9lyImTS+GGjVqkxZsbSvtNaWPXtYZoB8Rmo1X9v2hUlBLk180wZgwHRPKplmX4KQY9Bwtn85voudVTsQ0n8jqU+TMO2WTkb2AJGbQGTQ7hu6P0W2Vg3IxeLqc8/PwDe3RbbhXfWBWWpR8NVC3NYxwW8TE5BGgDqgufRVnweSazUXjL8IgfwI+HeJgh03bLNd0uZVyxdejdzshXS95Nxl7oDet2P38ebuw88/bzq9r8yTkPMejrcs2DrkBZoOAeRyN7kPfM+TaSnIZZ6DPn8bkb2BYMWXtzy7YqDzxjKv21sZ5pgnt31zV0keJFQ4pHHoWLq39dUJnp94fxu+T+kIB339s++x986Tz9d3eXowXbevizN4EIeuXWR8QzLvtbTelNIXuERMNqOCQdq9vgCrLd3kZfDL0pRgS1olONTSamfnUP4XSOxDRX7cMOs12H7Be9tlWTUbETr8QYjQ0vpxFIJ5Zl20M//oD7EjOvscFsnZWo/O0JUrRurGmMD1CN/z8kvD28PrnYRlkYCVnenFNx/Bu7kftFmZGMun65bZ8bnRI24bctGHZgBl0LtHU7Zl352+NYOcLSsZ/B60QlVdRyXDzxO1VxxMyj6dvGmgvU/CXNPxbHpzVxVLtcyiy0valvX2bGIJkdFthAByISc5DVf/yjF+A/3DO7WEq1UOCOwMieGogPSRAthSqK/9jR/IyVyUSTP/ClAT4d1WIe5S0xJdWGBxkReKHuohhNCbOKREsr/U8hn658qPA7FyiGF5kNdz4h/W0cVp8QzWFoPyydqjew8/ubzlCJmbuhUKTDf2zE4L9BQcsMCB8/3PtpqsifKRRfSvbmNKF6j3Uf1IduZp1L7h4ODkVjeNHbqVbQyXIDxHl9MijB0SdicuWxrc05mz3uDAW/ag1rW7VEO/h8AfIrR2cp2gvqAkc3KLW4Mayip7t1upvSUfjEczZdncg3TctCCguKpx1hY1ynGeCnnoiLeO/BF8rdo3/Cu8F3TL18IiMr20gDlRuf1LJ4mBad1DRh0F6DmvN8yde/pgtI1Lxn4XkT9GbPjhGYR8POXTtZK75a6HgSOZncT2eE8yBLlflnH4sPW5AzhStkRJTQL2+YToIs4m4nji2VreLK5TtUIdQPTVzg2S6fYB7b3vqjW++/ArS7oztlRlEoYE45LSk97Bi0FysPhK9fgtlk5HrYmEQS3nPn4dYN2B/MYX65yDDjOU2BdjdQjzU1igHvLlzd1HIBTQPMDMlDwRsdRMcYrC7QzaI9z6VjQh80twG9cpB421Nkmou4t0erEKwVMtfMGG2g1MmhdTgR0oMFm5mpXmwD3/SsAfSYGNDdkik4asezFeZUh8RY9HrHxA4sfyG0+u842eUDtPYYFeIJ2x5F5EDPIQewNwuVn8wGXrpB26KqSJQlIpUOt44h7lPh2EpWz6KyQSr7akFhkuBvWLvlbQyf2x6Xtz97Hh95X2XrNqqO2OIeRFFQGNsJFlSk9ZpF9R+h097zqAfIVylELTWTRdUrdZjiAQ41N9ibc0NSPOYrCSTftWLBVsx5MEjS74VhYbT3ffM4a+WS2Y5bFnad+eZB8IkCLB0hs9iqdf+YYdsZey31vaNevehBnl5aFf7V8vlqwJA+2GZmtkFNTgDvXzvbwadji9Bn5nQlAP+OXD04e9yGobQwTpSAXVSn+OQA7vqr7DsBhUZg09CblKQo3ptGNifhfMtAuEXWfx+0Ybrk/6O1t1n/LzKMINENpbTNKzjz1A7MlJXpAnXdpb9By3iHk9jcjDu9DP0yYoYTPbA15WRWrkhD1VRz9AJpfYYBrEdWtfEoz/qClbWAgbfWmTkHrWyAkUbPO94D4S6Dt6fl22onnwz0JzBIniyxdgJxl1Nfgtm4ejq+tTQx3cfbgaOU4KK3ZaIu2yq5amdQp9UWqN/TbxPZSVtkVTYe7P7ySPVVj9RdIkR8UUiu88pd4X9LPuHpaNCezkGWIR5+bGkVwUJAYeQpwi0uXHMcIJKU952QWbRzBDs8loH91XR10W3VSvFGZvAl0pQOLoDK5mKStgoVvg2Tevcj68b6Lmz4F5NzfGB/89smBHSCTdnfQwaov8SsZ9ICr08Afas2ZLX6BvHvAcUiMbsHRldIPOopdQiQk31cqftWR1sGKIWayA8woliJ5g8XNVobshOWMm121XAU6vzLnlITBm6RJNFFILVKMk9gdxp9aiYz7SqASKllCG6GgWP9eddMsv8mDMaeRfCrtEekMdl3azUoFTO4NOZ0MPeAqISOxTMQTAVNn2MeK7hb5imfva1nKexDjQI3vqZV6+QBEq2Mqn/4WFK1ZJ8j3S8AJPWQ8F59+C4qKR5sP7KByxNoTjVDvi1wS0gKwUkqRyFBH2DXLpc0bSqkpeKvp90S27t+ZxHI8UGqGiw1OA4Do0+IPrRvxefe2E/qBFxKm16TwNwvoMuYEebXNhDb4r+QzEWdKKkZhIVek5pkPN7VPtcnUBsxfq0DzV2lNECxUoPpAFhMx3WzOQuC2iDe/K/aJYbMMuSpiHk+fG6wvzE3zTAGos7uwgGzQweLZxsSwjknF4sg9dt8MZTRGABuw9zvLy8e3lADi9qGhl71vFPIWz1eO7Dz8O0Wn+grRHoQUL8dquPplYIy+jCV1GlBiDkkhtMDxdTUaUvjQjEnKEQjxHtfc80tgWSy3BZOsH6NrniRbdVA1jCTTKicVtMLfnCSi1gZcEkCKX/PQ8Qc+4LQAcTDST2G/XXjnqrYnZtWD09mVXbuprUwNkoBDQsC8Jtux2EJe/2gP+o2jWeTBpDC6rbtPE5Xa1dTIyq9MxC4PQfK3P4S8XyG8+broOuugr7wKdXqiwdeS4X2gBcghTzUjFnIuiOruCSFT9vYBQrlY3Utf3KMwMhVo59TfwLhVmkaw6kmHHhKzH335BVeRlWPRdRLXGCZ6FdfPazY22b5jEYBBEgwP8D0FXOEPg+IKObhIUitHcAPsNNUieYukLXKQr379peWFP0fvpr12aR0vPC4tgWe9gwmRCaqOM+Tl1o6sIRvWYWPheGJF3Rjhaz5vE95GGzgu9N92MKyFpXLYHkBONfb60pz0gxlq+M7fZ8iRlzYhsNe1Fy6GIuvR5zsAxw5XnfcHcwB3xAeEoJH7EjadMYxnjoCEdlZPMJgUEl47nAcBy0DUbuUlN53rUFxu00Xpdt798GLYpt42TzvRq6vGJiMpLtWimnplT8/Jlb2EcowrbPWUPhuq7NAGKnEoaWSlYtVI2n+s+d+lznaHqypNoPRO5PPnpAOlU7OeKtXbmRcV3hUonVPwqPFNWi2vBScfBNp3SZbFFsZLdN5GMRVeRSMsTdW2coyD9ZMncbdO9qsg+GITsOUlqECzYVoRi0O22ebaDASo1mi6BUoEX1P48HTGV5dlFx7F+HbrRpy0DljOar+XP4zqxHmosHeMWBJnFLI4OUKyP7z58gu0mkdYL5cw4wnrr+5BHuVc4BhENXLYZ9ZoTwjvmf/PnJ0q8vE9nT3Pl67Mi7s7n+p4oxQL/iSXdkUkTgDpMZHxTrVD2y+gWAayZ/TdqhSpITuHwb2cz8s33DlO+w38MZgXYlweV7bLJngB8IXwSIRl/Se8sAW4cDTMLfxGpkX6wqTd3H0FYkqP6hU4NRRoE2SdXmHG07wiUTl8vq7m6f81KZU/6jojLiOeMBRuewONDyZF3FN/yCdUYu46k2p5iq4gWBwR1jDMTxggD0qTe1AnbLiVwEYbn4n2BNslXMp3VjgZ/IuzSJFFRAUBKyz2+Kw+XYosKTZytMI2S4CgTCsVxA7AFfMIOuK7HSOBzHtI1Eb3j0kF72xRkp0TF7B397UbcthbSsg/5scK6/QA1b+4+gnmlN3tm7DRIWe0Kufet52VKd8FlLLFvOXUxRJ2JfFGmj5E3Ct1hK03UeuO16vzyMa0CS0kn5hKI+BXBiVd03JCQrCzTGGAGduCwPoNbXBEjgHEfVsxpHFqjrIEJGFb9O1grAMFccYqrY/kDRCeyqpbzTOJv4BgONhneBDoJ9D/xEVDDzwod5U3U0rYFQiLXJwBGOVGi62cWLBFw6XKYEqpoaeDYvj3gCqWcDtHMCP300FJdT3C/aiQ4rHKu47XTe7TGjicOJ+hc6NxpCvLx3UfgMHM/djUKKS11r5y4zNQbOKnF5yFdidW8qtZtxUDDtokmmIrrE4Wd4VEnudd5/svntKMtV4V5e/1qmf/YuMoVEdwazAWDcOn9LPopKiUrYKwEFSvX4RUu7AHaGIh4JIex7CsfGy5XneRLmSKHFFfP8A2pkXMC35QOrVRUjAHBWsKVkZ8mFKvq67BllZV/2XV8MJqIoiC6ts98pM8I9RyRNMmXMn1e1bH3vDHsMGOxnbe73Sc9Y1SlWv1V2zny/pXn/IZymFA+EynWQ253sJbdGRSUI3+Z+HygOHExuZuYHJCjKnmXpSnXVkrBZzhx/fOV2ldT9nUY8m1/tkRR8s/vGxF6JFqPrBR8jPB0SdQmqs2+MtWxmHVQNpjz5u4j6Hu42fdANHFftypTbRIY4ZwTXaQH2rpU9lEpC/5U0yOGRXtC8lTookirZ6pEr2qf8NsqPm/7cDp4bnaDWLrcphp+EoD28qMujgSTDU2lu6yoKH1fh+KkD17vlgvtjxl1ifhdJXGHkN9R9JQPrkZdIOxCWJDacbeOc8mbuxp7Cc4HbACykitLPJoBJ1iqZZfBxqQtgvfYipAkeEMpuNJER8ioyxmToGn2heR1vcqFwSJojAL+jxlbfprWvLn72GzDonQDLaf2WWVFB77BgjyivB2ulseNfqKWi6QE7Wix2DAQJ0bREon9oqDHkkGLmtdf/X4faCm82uqm9x8ae3g1wzlxGwVO2IAmNZ63nPJ2JrQcAfM/iCKhHXtroF3w3of6I+mFL9T4XDjlaqFuaKHGgB8/L9cBY7kfahssgkHgybrKkmI+HYb8YM5NI/VvuYmK0EB6Eeg0ApmVL8r6uEEAh5SFrH6U+oAKdkdUgpeRILje1tgATaTndS3yQj46oq89ulv7HcQmjkxY16HX/S9RxZhsW4Reo8tjLvVTrr25+3Bfzc0ZLkXYmV22UHixO8h27LSwOHQ5oSGdLxJmotzgNNgtIG9+Yjo6IK8DyY2rz3mKaOyb4GSkBq05FzRStSOiCe8+fFnMDVnMujAJlJeRybEah+/ApV4uwAVA3LouT6zgTslNs6SDuWwgKwxEiIHkxtfnfEFJ4pXRNw2tMStdnRh2Fl58Zh46OW8XaTvYz8DVbgUMDomJqqDMLYJ2GYuA34iEJ75M5fNRtn7aee8dTf8zVGPtOQMAx9akcps9dGXP5gZym8ABspnNItwfP01PRR2pruOc1suBv2Hi4NGhN80d7FwYQAXQc48ST3RoYzU65RiGDqbtymAFPp6w87q9oFnfmz5EJhHx7AFnVMEXpOENzgroESJ2WJFT3BRMZ6HJEEzDNUNIuW3oam9/bDldq0XWC7YbbSuwj78hR+97jkoopI6E155QG9dt2VXbWogSHIZYX5XRwB7UqV4zfaSt/punTI1vPoLlLCLCvu72BNa7opJf1cZl5Luy05cgRxvG215fUFJ5hxEnSVRgcTpeMHO+7bnCliLVLv22JQtiR9HWgoCU9sy7Oq53BL1P50e6K1+l9Vz3vVAk15FsE3PPVF7udR/etZMOs+1IoNJdDC2g2PcwR7KEGx8RG+NitUPxZka/fNrwPbJXXbYEKBNfx6DAS2EsEpcGUlRPuGqXEQobpohxh+T+92zP/6whc1RhEoWjj9n2NdxoNDZcyxQuqHakIfEuFLtqVTcQsQOlnYWmPt6prwKpViA4c+VpX5jj61inaV4UmG24oeF8b60eyrdt5yg0LWcLuGLIgdziXGA62+Ee9p6ZjpjscISiM3DxZZtTJWf7dY3txZMPFvXmrg75YQ+FTA2RCpDL2of8soWIbMP+E4nCOM18vnOWP9Hn3QQgn8916F8d/zUlSlvQXmCl+Otu/6+9by5vrmFpFwUji1M3NseWEBLztTnSiYNGLPviePGcN7Latk1qJL0LpXoRK+9x+GfdY8YOfefsVBwiXPr1nBUU3xUOO2hwTkrLigmMbxMOuwDeS7U/0dVytJJub1Zgl/jOXtHTsDiCl31MJiYnoHQtSI/5csB9ZNPjde7f6tAvqamxHmPWpXJCDmin2jYGsKSvjuOvgyncabJBH446b019Ig+gyBbAtxH4o5zdH6sVeU1mki5HOhvcVL9vwxjHwahuq2778cEpM6MLGex6L6OdpNw+AQwWQY8jYJ+M35IQjJVHjmsf6Dk70ZUXB2LkAAyEcsm2hj0g9AjXK/OGtcHTC2oBEi22nPpzbnl8V6ccnC2zeHU7wpqyegQhe2pUNRUeilZ2ngPNdw7zh3rEQ0B8Ot8j/xU1OwKVuikt5x8vb/0D9awLqdFwF2j5VMfRhQke2xbXXmne3itwuk6bKq6pkkkiGlKkeI+o6YDIDrS2vjL3lPEQcJJUsG9S824Td5bK+Pjuw6+1b8ptup15Q5ehHdF5diHW9r5nelhhV1WF0Z0lrz0DxGJA3j8fyHAi1U4kPvTFis9oP4lHAsRnP7v9/fm0ZQtvPvyMmz769gYmxQ527i7xEyg028WmRmTW9szcfNI3XpyF0CDdkj2qK8MJFDuh1NYT5p7NDiW0xGK5yVl24O9pr4c3ITNglwneSC5SGcp1tnIPVIoPCjhmiQyQSg+ehnARxGh1jbvk+IpC0UCC/l/5W6hJiDQMnubhlw8JwQ3KRvR+T6qXvmNk5OELtwyOEpYbPSWvtQ1rUGwicsn3yB5pe8suSrYQBMBDJQbDfd0zPop8kmLLSs/h8htGPs7z3fTNgSNqGTRaslyk7Y9jm9lqVR7MbFWUswq1jdjByhLAyLbj1+P7/kQ+QZHxk28UdeCL0jqpl1kASvNUt0+2OdY3dx9+RNLckMpgS813OhPdSDi2i5rvSrZ6CwAHEm90FOC32C8v0lWFsoRIxhDqDj2Z4hfQS08zotFwtIacW+iIqa1Ms8EyEq7lUrVzb0tPcKpNNiFDMYP6fuzrvuQ2UOiGkhRPwfKFWRLu+9GgIPANR8Ze0qzHvqPBE7vzRdRWLgkIwZ5YqZLlxGd50PaciyQ5voDnjSjFE7F8KCP950Si63CG3qryjAFIqKNnwhsG6gBctiiv+dzo5Ue/qro/7FzVbKiAvgy4zlB06ihUT2Y3gKj9cJwmOgN5BdN2ldnFdx9+9kXDWVvUtYuGtjxfCwxIh6WsQ0bikCHnPbwzg+tQUpbhT7B+QlIjYEBC2eE/CsWT1QHYp7TC1qU8xC1oHHvKN3eVzvfC5jK2NSVIQzdqNVn8sTvK4vr1B3D6v2x9yI6/I9NdpVIEAXfqEYf6cma/+it09VGQ8yAJDU2xUjEpCGPm+h7fjP1iL35y81vMunYxk1CxzW1jYdViefpN+sKjQKgUIh4+QnJWvVWCq7NiKUsFCyZnac1H9x4bmZxQd3ER55H14QFN2jvm28wo8a5ns4oHMLgtLO86XlxdR7iyBlIvQMjYl9OqytcIn21prm3BqHkhVqGgRD6jnqO7UpHVSeIShy6S6TG3imxkK126kMUmvXOki/Fdtd65cPksv6cK0PVkaUXfHePZguNf7JTlivxcUEHwP+yX/ynkw7t7ZI5t9qyC3Yqfng8/M3IjIWIFezvTjUOTEd8B/J1juI8TeLiCrtvBg61fJ2CClP7CbzBMDau7ARTC8i5/XMve3H34ZxF9Cu0v992nUJF/q6oG4F90ni0o8vblNRSvMKpyNbkjR2V/ABKEKh1P03NCfmaeiq7HNhjdC/zkd8QPbz78URc3GyWBruh8WRD3Ss2PlE3ZZaIPj14iBAcIWrJfyJaZSTgZNVD67ZZuc6auI48Zuo7eoL+YKaip+DKTMEnoxI/yJr4pzC5jygqWPsSkpW7IDr2XSFwzZab5bGDfesGfcBHj+hEP4PEGO87gJEmsZ+2X/9Uy8IHcyhNQcWaSvU05rXROjGTZhvOgLyiccZk22XtmEmY1TnW3wHyhvJPpBKKeSJzlKbk+7wH2ki858qaNM8KBYrSy6y84CXLSFq7bj+35pajd7evrJy2zJV9/3uFcES4WSVY8gcsX5Fbeq+H0FKtPMhVD6N/cqDs65EsnV2KXLactZ6gKBemZv2Tmba8VkNYBxR2rszwt1xeYuQrH9EFaBencBOBG/CpTIoWUHqc3OEd56VTOXs9n510rjX3d1g/79JEZYY6ZEKwI8ArwMQdN++XTYE4Syi1kkbn3v5D6DwRnnoSMMzAzpNAi1i23U2mGXj3opZdI+zU1GAiW4aXBr4GD56nmicWYgXQzVKd5WrYnatkG69O+WLLVRVRzg5bBPeW0eZIP6NR4pXLYCYvgbMsD9YY87qnqddv1XLvE2F0xYPxchnAnU6sTzKH+oeT6st0/MTdxG5dumkrYBTZGoXkHLZryuIBPBKK0WhosYRXdwjncMM8Eg2Yfas+JCi0xAguNcGKmP2HzJa2jWY0tOktQfuhlkZ9GvPFdZfW2GpbVawsniq3utZP6Av6OLFlNtR/j/39YvIg7C4m2QKPvKPpVyU06zC0MD0z11arsk5HenuOOhsagD31oUN2YG5PGrBf77hprGagfj3Ri2r9DKL7YW97WGQvoSzYChYc/Sc+buve0eVjCn0dhtwf+eOtPW5P4LvJZRD87xuWFNzPxWCS0CePNIK0kjAV5NB+6E79cYxexVq5qKeAfr6lJxGglkM9Y3C0bddd63bi/fJxiEYVOfvbmM4yL/z7m/qPOzD2EbyjHrMhM/PhobKxLR3ZBByeBmo7TspS0L1tokgcXma6R9/gJl8jyWa9AlOZL2L7QA+qCMWqaWVD9CYlFIvkkyhOQikp0yV7MUczjzbe1NEPFPmIrR0nj63ED+W6E9fjY0BFgNL5ZW2JXV5PXxKKS/CK69wg6utAARrZtNU0lsuqhTA24wYAfzEHg9Zm2kUcGzF1nU6dTtV1a1TEFiq0DJcR11LVTP+43jD3hiOsirgrRAhF1+yoxeWbDEeFdiGXRgghB6Y9MDS1gMnA3nKdN5cIFD99tMdZA9jFFw4/UaYnWkbmiLGnMYxZUUdzHobo2UuP+q93VVWhLNxhhS6O/Tnb9QDLpiSBvqB0tspELaiin+0jbSrOnBcdIekJfGyaFz1IH/CyBZdlW0VErQdB4EAosPTnmN+YjebtS1nuWX3EcGWfHj7791TzAOsaIY0w5kiHHu96LEl/oZ3aZs5sMWbeUhZXi4AwfSZoSYNACHIzxLbd5PGnwPfe+f01VJR+r7nyNXkTL+TTeN1pZvWbOm02bBR5LTdfBMyo0FTzutZVey8LBpWZOuFPYkleEa5advG99DTpl41ZRr7X0wBO27tTcasmZDCoSXbwET8R3HwGAoMkZFyxlhL1lkPyiAjnFZnAh4uyH2nlfXyizujYG5tbqekRMBzx2qMPxZDufMRAuUHpDH7WuSinsAHQCrdQPibFEbQ8ztJGFngLfSMTNB5W/a25uzeXnAjYvUF75Oq2PtUReVnXLtRreGfJ67vAR+yHfiWzmkjjUgmO+9uzVPonfwIgF4WTbZ7t0bEDeesojX6T0uV7SUUCKbMj2me24xh+282geBTv/dIYw0tb9nkcN7qBjSgLKNctd19OqypXSB8L7UF3paDE/7oJxLQJRj9sJjWniOk4wmUKyELQfLgwYYhS3tF3lBlarxZ+l8Ftta2/fkcjXJPJB8XxTfh+y/LFiUqdkq+TCXjKbXFhxg4QQo1Sucia2v7lrmQ3qnoGvHkJMDK8pONzQiAk9+uTlBlnf7sywlJ7wI1rzbSMwJ6nI7wpbEzMRNQqeo86RoM/E60rhZTSH5p1i2UfpX0ps3Lh7UxC0MG9N3YndPns+viPQTDDwomtxjD2zCDhZ6kOJEEa+qIaPBCeRQCUUHPkCpY9Xvvt8t2ZQjVqn/p4Fbw1eg5RnsYuQEy4hcJKuBijOTPz4HWXV1Y5OyNcbRfqkQG/jy3P+AFGLTnN2DHcWoBVmr+0JREV3VZ4m4Gkdoa2gmGq7OrUiHd3UUHPCTaTu6tGyRFTPYAUsvxnPYU7puhCsCuHSdfzCXT15oD4PUC66qyBUT0pONGHuCTyXUUUZ08GNYEF7Msvx3W2m3QedPsEgF/gf7JQemwAJLcbYlbZH+oUegf78ipiKDphrj+jeDN9YLBUr/E7ma9/jB5CUewjfIJw7kMkhZChlEU4LwpyR1+7OA9TzI8vkMjmRtCM77XUzyC4N7XLWkdjKl2Z9QUDlpVw3DV7bnrgH4OuHZNcabFMchJzLljJy6AYrL2Rho+3RbxEh5xN4gdbKF2adxQ7hBbM0sDKbNr6e8Ft8FyzThVOo4e8lhM8+1P9V7bExbNLCfJpM4bRIK+fRZbJGGf1sG2isFK8CxmYLl73kp+7ZZ6UiFstjvX75nDBexu8Hbw1buu9MbPbaem7274CMo0yam3o/xyIAnpcutz2zDQrrygJLXUBo4P6JnX4iZ6A3XUNOj9Hz7S/GMszaEDDTuHv3y49uimuww7Vt7s52UtsN/vY/VsYAKxTrCyYSJz77Zhv+OIdYgxBIFv7VN2wiAi6xRQuljfI31fKfnWuUvPeL8pcMtceJ8xjL0+EVlDiXapRy8nSfDfNb1CK9WaRO89RsOhUgzMEGgsagaHLKKdztjyQpBwos7CCVgU3KLtzjuypp7JG65Jt0oq27pKmFTW8INRYR19No138+X+AWC+ICZWaEi1VOyGSCA2O3rHmAT2XBpV4vjlhjbIOF8Yl88V19fqvL0FJLIcfs13n717JyS0grSL5x+vv9Vi3fGTWmZiMq12F+d3IxOA2XagRQk1/iHzwcToMk0Nh2CdCEk542eUIL92ABMvFOruu5Py94WrSdJ6/tPBtpTQNp6huYz4MFj7+HLYzGDs8xJqUE9qvhxy1/j/juI+CCb/pp2MIlTsPh61YFiWpGkiXcAx5iMzVB8HQMLhCfI3xj0qfSwtAPJPIPicYv+OMaPlbSuYnJTUDPsvpSJF+zemU3ul7wGbkgb6GsbfamwGDnoJ0prckllhjpAfR8oC8CBiMlkq9c+lxC6aajdN6FpABpO8I5lC7UtcMKte2BEAk2gsxdLRTau1nKXeGgzZfmY30BLhjKLT1x5heUdJ427obSqnXNLGzsQBZoNYg9sShpjWVC26OTgAHSmwlxZJs0RAKsQK4V6O58ld5TMj0X6USrrVoREUUvlC2ZDu9KLm9ZDtY5VyHO8rXl8nmV3qQcQNpVjs7dE0H4ZoKhxNrVY7vqbcVBWIciOiDVs0z/LyTrAyWd92o4Q8ViFPYGR5JiBNsPWW87KMpWSMFZPLH4sgQQQwr3XDtY5e6+TpeVDzj8UHbnifQ+F5K50rAbIjBb7nwBwNmW/KQGaTKOSsEpvy6xEIMtfvgR0rJgTrcHmyszDUSpgezM1ah9Y6a3Y7qiESLNztKsKVaWhe+GB4tTBXgCBS6WJ60zpBpyd4tkttbtV+yxtoECJ5Dr+OO03Nlbp6BDzareTqtQsJTRDX80ZG/uPoJWzlstm7Ah1vWGLXA8FqyeL4uXO3ITdWzCKzuDMUWph0pBiVBoBBH4RkSNon5j6RcmSHhIpGaHZPuOCGgCfMxJ8Skh4bcop26mbudWPjytvRwaDILcqHtAQsjfRnRvDHR6wOgXGl/dTPXe0RxiRX7QgQ9xWmNGG9Ct0kj6ykcVCb/Qa+j7skwur6Oj83U4kW4narryE+eT12E8DHP3tGtYEgf7C3hz9xFkXrIYr4MNS7hu67ZucnQgItMCHYOdqAn6EeRu6fbicKMEJFBzrWKoP6IGYgrXo3w/k9C6hxGHiBQ4WE9etrBf5p6122ytXDrRYDGpoWCQIVV2eeGMAt+/x4u4ZGZAfYbyM0+s9meUSBMbZQGd012BqqfDVcV3oUFK0JQCVicct8g73tQm1URLRbgWjL6ORKhz9i6VSdXWazuGenYO8BxOGICh9DcWLEUCJ08Q9cuHtEDCEbG1ATdSnPiCw4e7j9Uhs2ZlijMBc5X0BNb/AUBixOEdQuErfaI44YaVL4iwPFnVDVmV1TXCJwDYVo0pxHgve2GcP2+vGR2ve8L7AOx5+ETLvdnlEMjrfTF+JNnyBV4vFY04mWxptrw8el4vFU1wV2++24ZCQCroqk5N5i4glOwVgCyAP5udMHtCeWAy5g91ejcEyieEPAJp46cwdJzsNaT/+ssXYP+e03wnZgZwHpit9SM+jG8+AqThfkjoVTiwDw060IsIsQDsQC8G4NYYGa7PA0DGKttZeN2K/T1DJ7IGiZxEImNT3wj1nPi2oTgcaNJMBWc6vDCOBC2++wgOJI0TsVWDkM4t2+qGbFICjrKyDjboeyS5wIQQmIPoALNosxQqI243ooJjatujws/7t2SeRcy0l5CV1LaT8cY3H8H7uWmBAouY7blif3pbpsIDxX5Ln/RGueY2x8Z1++oyX1xG0rLye2+UyEvFt4YJnGQ+1GD9i7TQnNneOiBWzna6JIeaFOwSfoHAmZ2bclu2vVWkkO+2r2ZM8nlsYCjV8oRdT/EVBqL8cHdY0sFwhnGjR30V3kWrBAI6nXS0XlOj4z5CylVtr1UyeU/dREV/7gDGBmzBzuNd2Nl1i9yLxJxaUPTjEb8X8YEef4jibsHjreLbtgrgguPHX6gdGR3E9WtlGTiNdnz73tzV/GOYfmuwMuLPtjygnQYmoEEIYSvsJNn/qBh+I+3AG6WB03zjdeoIwIEXouVDbJiecjr53K7RzT05aCH1OtnIkXE6atITpPr0/odAaCI7/tHkBKjCladanrIY930KP+D7Y4meo+c7xbxmsaBuB7TGRKasI8Z4c/cRCP9vCv+HZVRL8lqwbPyLVtQCv6tJP2/Bf/Id4rqFOfDq+JXYpFPC2EX50CV9rX3IdYm5dRsLviAocyRiNBe256+EhuiPU+X025WCKbeGYGbty9OSMerqE965OrwiXX2gwg/lZ55Y7axfS0AX8fS8Z6FUqE2PX0V8F9UJ+oxAxLGmsmXY1SHR2XuXSKvK/F3EUic/M2UTam9CRzEWOc8W4O2WCjVt0bAtKmqj8tqufvmQqwMAwh/iHIVX9PW/g5A0sLWcfQowL0jgj6gITu5VZVW2pGsePtT3k3CdId8ZSfpspkN+7sTYguGl2QpI0F5rs6teFANbop/Zrlz6H6rlzd1HMIbxpp2DncPXnq1+Wa4i1AjMiy2ivM2FZpOCiM1qSUUrkeu6NWKB0UNkC+GYSOCyfbdWOUwd5fjp1/zsP7c6eYL/W8r+3DCxEtdHt6Pr9C5ZZj32z1u6fyJVp1cWI1VH5Zo0TCrqjIo6qaKGArf/4PMJSV4iJd9N9P1W+eusegwB2TbR2YkLO5HcD/eY1P2LF2OlgCr4kJKMKMxYi+VIt/549EwOvILGmagz9NfPMzu+q10/7TTguTg5/OA6IouLDceyvLSDuL0VAfj91u/6s30Fi6d40ba31Bju8oiecCP4S2Pz37WEXmpBu9krN1pqwui/rDNsNGNCoXIIiwSTsRf+sa0RnmbC0QTTBHRswN2GwkNHpfgN7ayjhpWnOoRntkpgeXqN54hpqzmsUqFGdlyzHN2PLamBy1gsuYwjn3FbC4JGhEBo68py/zSGKPsGkNk0nTuDsjmdIdFdEawVtYncZSxfVZtEgmSZNCxgfwCNz8Tad43ypze9m/bkCtZcgdtO3S11xX4XD7vKazfQJ+PgMogFYlyD8wqyRgHiRVioBeiL6WS9nA0f7UhX9fVOJOaLtgKIE+jwgkQAPz7gV/tqO/lB14BLJt0kjTqQCIGnI13PQfRzrEZMFZoPzPvZRZQdh5xuh25t9Bwf8ZArQgpFSwFX5VNbn7cBg7m2+A+tCrI2zNdBwLMs1L761Nfuxk2VGHkH81v5kivo9KUkFOXdhNOSEPUxRLsEzSVBJ4rXt2KX0cw5MptLACpNTTo+xh22gyb7PDuGCuPD2pK6Nufy5u4j6OS5aegxS4cJLg09MEb3OGvY3q6armsBPu0BxQvUacsy3LBguOv4yOcj8gUJByD7A5O/IKd0cxH57YLkYGXSed4owUd+1i3qaytDfjAOWbaAdikjHn0JJI5JuojUi+VXnlzrKTCx74vm+dfV57YkAoK4BSbhXXWMIDdHEl443QMVquTEkBkMoe0dI7vPWFvfQsyf9RGi9hHI75EC+9CxUolTw5kA99dWUFjOd9SwdjxX9joXYHCnLzK+q9NvXAsTHaDlo/etDj/78jHEC6VJ6htQw9DdzgU1OXP8WkdbNKEGqvjpls44iai/JujG8VEvnHVIGeYPaFgsytc0FzJ1JrL2V5XHld7/KE3Cuw83F7vp+DoxqIjZFRquGbAWxhkO5WLs25QaxC5bSKNtbOd4H024iUBbF+B1RXe+QO8LY6xdEuGWpzO43rHpxrwbmQGDXupgmHRxzfU4T2Nsl9jJBUO+o6fwZRmRjCPgKHxK47x0i8AE1EujUzU2dErP2ia+CxzaEo2rwf+TIzkzj+ub+DRmzKPiA0HCivpHiDDc0IuQ4mv1ujs+rv/R0+q0znrxMW7tw9wuKq7r9hgwOQQtg8lKr21in1gPuwH5pmrC1isRUoAOdSv48OeTrZ9LgngrNso8bNGsltIpUF/IL09rn09SBaRWqMrwVRxP2vWifsRy1rmVoqWeLyC++fCFoXTmW4iNunzVqgMZRxOU1JVMscW9Xs/ItwTvDsJT9l0WmWQH8kNXqxhrTj2F6hd0Bm7Sem9CQDkHWhv6cwQWhrJc6oRYnMHWjl70qpx3TaGB2PjfN3qkQL/0Jin2kujnSV8Eu9tzShptXxeC5z7pw7sP//XcnONR2XFAfeNMa5swXfbJ2KGMIgDD0HR56FcTaexNgG2kxwnUO4Hw1Jep/pkeNNUMMtdF8SC2UH6OxAzvolvOngkjPRIZfGA/HP+LHBsKCmbySNPznnvXEIrwAHadzf9LexJePaNSClqpz9ga+FCT4yt4PL0PriN0VejsEEXtPY706vXSwFdicdsDtG0vDYxR5V189xEY5N60CWiYsjRUUB19LAd0A5feLjVrCbREDdwsRC41eVv2Nsvp+3ftAyK3Ac+d4JePadnu3DtlQSvzuvf/+zBgfy8rx7XyVrnH+B82cB4N4b94QFyBhwV7JGGKQoUfWj63u3H7H282OgK4GmWrX6GP/5EfTYF3iES0gDBZaQMUh4t9TpprtpJO99gdJ3LT8Rssg37ML4jJPX04539fyFmLODZbFgxyAJPtvdGNKnOqb9s9FfC2IFGHKehJTxe1WgSNGaH23FOq/4l9XNJ2AFfKaZpmx57QF9wUsIXidvGTwBdlG5PCUazIZcyq/Hl0VH7HuuuFHlNdETXmUWl7r2Ui6fjorSAgv9Y3FhKolYcRJUWjg+bXu74J72pS4j8OLTcF9ogMi8NOh31Xe1Yn0oUK/29AEiDndRnzjUB/olxKB6KMZPe+SD+eo+pMXf1QR+udxLfml1TKF0HozqlAB2UzZ1DbYW61zGTByRA+GIXQ6tiw4X8CbUKkYwgUt74+9zkMtmHACIqsDDtffJcdb3UPgw3vqisSGiBkyxcK8P6cCDpRgBe2QfQplC3UgHguqW8sVd3mI7dZSZipPTgbhBBT0l99A/YzGuSNSMLghYazw9G+ufvwS+0b/N2wc5W19sUZt5uoA3yWmApZYW379Hr6HXSYKjRW4Rj6s94Rez4NGKivfKnWM7ZVjkPq0Kcwg7PUqz81GdHNhy+FvaF5hRfJJQi1ShbAdh0M+wGgiawPpnq8jIaYnuj/DqNVYIE/cT+R33wUqmw9Te6fEh4vFOTj9hJuT2ouuKVwXuxPJfm8WuhI8nWCx3/BF4PtNirpuN9YLuA3J7/pZfZZT48l1XVIc3B8dnimLHlKfEFL9W8EujmxYrJLCR/GTud+bSsTINJIsjtGdJWL4v5FHQp1JXCyyGKYIw7TJzx96xRfpPXkpq5B6HlgAjg7eu2P/OGmwrsPdwfexK3BCy51pc7BoS/CicFjN/kUAKisp63XKiKYM2Bv4it4Dn7z8ewI/464e5fq/zR/cZVUNyRTBS2jSj2sJFt8B1Sf1MEhrtDW8oSC9MTC5iXuBHGXqXwgpA9k97FGy1N0fTogKWFF9Euv1o6KY3ABMDld/I7BAll+O97uQ18e8E5O4JOdUTGUgafj7GS4x9Dc1w73DzqhXMxV3qSW5KMjmnUWhnmd3jZLU44pD0SF5Zy5hCj6xuiuss//iL8M6M4Y03Ug4FOt2ba6VI8NTkFi2X3Ek+HNh9/YeKuB0V7n2NdL2h15lgDUhTFj6o9cMwtfwsR524enEdLONgGRvhVO7JwT9016fZZP8UlWEYoJp3UQlV35IPRv7j78YEx7zmovmRoRMkoaPIxpVszlOay8oj33R46bA72VjNHFIoX6+wMSI6A8Iq2KJ2w5b90OXxJMVtISerWS4NnfH998BApYK9GhpLBsfclzKOOAZImegN0Q7WPJvdDFyeviU+VF1FDnUFcGI7oyIXWh3szS3KQf9wW23zDq8LjfmwYecJDirE3Uy1Z7qL0F7cTg27C04Jhc91UMpCuy9Vij7xl/oa1HZAMSjZBwJ048wdalRu2KACsfJgiADtga3t2sIpSQoj1XhYfLbme1bxktF5xHCGrncIKejZI7l+ndGCefs/U4XhUx7YKsk61THX4oryH8A+Wom1fIh7KS3aYQBobZPyI7+iIHAiCknQ4mqrwrxxfYyWP7Mu24HnAyEYfzhoT3SPtniq5u5QJPCrHmVz8cS3xT1ajlisgWQJm1lE6rg53SFy8Drxu5HYse11MiGMIXyq8iuZan7tIhOC6Bljg/YQbwSrF+gLa6r0cenKUJ4Mf8pdx2jypC2cg4CPGabc2kLRsqDH36NfBWfbam+4xsxODGjJzH4D01822KPLTdeIlRsLL+1CnxXXCs2KoJvw55tJUemD5+k3uFaA/Byd5oKVYfHrYT7WYoVhK2bdmTScuC2IC8QuLE0p3MR5xsyOF6nC+uo8N74eDmVlhbhPzUVBTUMxf5SRpygRV8erRFN7X+sVxtJcIMtVNnJjTGFj3Mr9H6OHbF4sgvfiPRQyiRcLuIvJYjZXnLct5G1M2+jNfBGP/ZXltDpjqM1sle2dvckyQWRGtqJ8/0PlZVTRexTAtgpCiARSSJT9Cq1SzXbFCuz5YIr68i6MJwuzZwHZ6VmW5NHc2YY/xlv/pBFztgMo52kCousfFWFAtsr8m92bawmJ+Px6zfbev6o76zU3WQbAf11umIjh4ULI1TEfqry/hH7U6e+P+Wyt/K2Ut8ScW6kfofdZrV0Vk8Sppjty8R4UBDEa6jkGeWErZHRe1Ub7oLnGaEzwWUriTyhvYRSBw8surEshGFzl6zWTajkJEMUxPZ0DmJgb34JRDJznfdVEHvVSS39LSZ3zjrvNJTsa5jZF/lWWfvuqiblpEK/U+aBbBIgu3DO3VOsWPvw6pP2ZurQohUC2Fp65fCT+idmAfaIYAr6FO3Z9yL7z78mooGvFhnhCShfu58lwvtpfjHvAqd0nVMeNF8SKRtQAm+oYoArQ7A7Vh15mnUnqt+NNYuDZ9SaqkL4Pxe9eFd6Aomp79csoqeth0Su2QYiy7CxxXIBvSMP2L4rcqceO4qk9WnIqBxSDlCJPyllNCEMoRAtuDKHHT9Qm9Z3s7V9ntesUkMjOaxhhEVRB9x7u4v4M3dR7CaVeSgFJx1z7DoEpX40FYMJcXQU8Tbx7vF213fcK3ymvJvNt/DzK3ycq752j38FRqcTrAmU/Wk4w16x4vQNa6j00tLIDK5ijyx4pZ/zyLgC+JZTw8rrNJyXgCIk+KUo6kCQNXQ/Agxkr2/eeQTBXlkgUzW0pN6mmPcDhu/HSdU2jq63M/n37EIG2m74dmWGlfan9tOVjIxSPxyrtdTOOKS327nZkjcBDSPxwrpw9snH+y6tdVgiX5/Se8/MC7xsJebhib2eJzFp/Cvw5fiH6hmFq+DltlWqzCJTczpMMoRw4n085HRSWSMElm2+havX4h77nzGm/2y0/JNsArQlkDHxywd0+fnIU0qTNPSvj7L4jQk6h5L1RcTttFGbbdem66uYx6LZrwX6HL/mur9HyWkriiUsx9ty7NHBWoo+Ib/UNTX4BgvyhQz1SnznJz8cl1yT4RIjM0CkerQlyiGclNPnPoF/aT3cJygxLmdso3M5Uptax1q3wSTrc9VWtuKC4veerphMX/LKFwdRqDZCLWWnjLzc5cabzPecq8BjS67oGYPqkAMTY1lNix56OC+W/QXBlISg6PbTR5r8wiRq03ggvPG1chzQXoKLNLiJxt9oADlOPT23Ozx3UeQhMpx2bYhpxqxv53HxS+pUDTXYjeeRvZDzaKC2OmpfbYtHgwp24jijSQZnoDjqZ27Lh7ilgcXCkVh4HaMGd/cffhquJsT1HEwbuUEijsKKoDmtLob2xZh/x9NZ68UNFAUZvt2vNGXB2r0SGnn6/I+1FH9uyNvTTFZQKhwGVUgWSUknQtINvXtzT7zmY9iSf2WMzc7T/XTgTDBlzFEoitPoPUHxKmTLtLYMqQlLBFcJ8LFdx8PCPHxURILDgsnhbwrHt8qtaE6BAaxzNo7RCoNtuaSN7cr7R7Gaj8x9EuW7RcV5kHXpN9j6XZk8jKcXvCF1Ml493ce+59NxdXuVTorU9vMdazd8p8US+VEUizkPRXCfs7li19ikj4i9aNKCWKokdUsZanNeJ0F+0kjpAvC3zJ8tZS9icjBqxeegORcPll28Kw55hnYadUFUzTIRkD0/fy+IegjQj+C+F1G4GMlmacNuyEC6+hnFMLU96q3j2tVQL0EItrXJ3zWvpuGdK9s2dlSg1MkJQ6Ex4HszBepnaOtZeq+By7zrdqaO8bq8c1HcPDIcBZeUdTxkY5oRUfMgAqT/fq2VhfY5HMd40Pw2XFQ2UlYpCkMWD2fAoyFSJ5w6TlFxx6I0FSCIJGYPEGCPUYnvPvwAzHnCFhemqsQckz2Ynhm+17qgs1rFn4InWih47kci4oOpEiU4CsYQu2ZI1R7iqKtqMXnumzvUBRr5Uo7If7NXbVB2aIlg8IAkmVDh64jWyFz/gA4saRmb0Q4PnZ7KYODPtbTGx+fxEIPdm3p5dkB5fXGBp20Ae+DtbRsr6GOByKS/jb3qGQgkJ2VLY7Mz2bX+O7Dd+C4qRFHe4O9CkiZ7Sy8zhgYy7cB32JOMYorRXcAewnzixd6VdaQdiaQjgdC82hwqDtm9AvFqrcNb5LrqGCWvCrsReyNmKiIKJx0hEattkVQMAAe9NiCh2KCJPrnHXkbkb0Rd+9z/Z+6OHmNLLcaVuz0qbJxhxlvPjZLSLRpswSUwza0GmJgBVzSvm7HnSiL2PUpcomKGmX8xpo/xnWdcjErxgsDGr0ATq0e31VikwAaNYLLsPkfB6K1ki0njS1E8JtP0Mjtv/ddcGMeL+L9PJ5QUWIizdlgNyZSvZbtIJFlKbnUyA6tzTxJbXxXEQ/G80iXbVtDeNiPHgNqfkT6zHda+ukOcO1ngpFm8QA0V+fj6oJ03XYmAn4BMYtC+CXwdY4lgewEGCRxidWecrr4rrxd7PvB0IrFyWZzm+x2Dui1Q9uOKwhl6hnc5HLmrj1m2EgRtF04TRpKAq2KJ4cN4+ErrVcd6UfuJk5f4k3TE3upaKsFymD52p5sgfrSMnpexxT6vDudkGsWzK0lWDGFJ4VWKJFzSjwz2Zux/NRRwqcJAR2QDMu1yskrW0cZ3oUKxQLbAPzAlhP73i82SECdMi+NsITK25IErdiCOrpUvh68bja36PqwiAAYFTy0FQ/yFw5VK5HKxVPF6DooPOqfkC7V8rdp53/Vjv+rBr+hBrdcCs7GuGgZV0pbDW7hGq1krCst2WaSiex3qDiDztw+d9+jX9xekqDzJFCa+7r0zx073ezzprNxX0zeO/Mt6UgXLZjQmkbrTICle3LpJF2ApBR0BftCA/o24HoDsa0vzf0GGemUpAp09sbHzmdgtjKOOqjCYWMKwx8na0uTR/pOdOydXddxCPaZ+4jpj2tep0T+wgBkgDC2a5GJFTjFWV7JcGcrGhPXQa5ioPFMG6oA3oKRBkN0sW1k4ZSNODi/ALpN26n0lr2O2G6XHcd1aKwzF2hp7Jp5XfmltEmPIouDV1JrhMXeMws4vvsIXum9S41C8e+gyflMhxb+F/QJQZZ3mIzLdocrxl9hnzMU1PPWytnV0KOtulOdTIVM3oBqxel30CdXKOW35L5r4fVZT4ck1WVYumEHgMEo7S9H+U9mKHl+sjeNBTDc9rjpYI4Jj15Mr7GM/fjJzXQd+wP4zBUNAkBCsF3LIluEyEbBs13AdabA6GpDm0mG/PyvSXl73rH9Ux1qwL+PGunN3Ycfn28yGGgzmgIrkcSrYL9QxJJwYYPbBbHpjxgGdD5UgZh2EORtThYxGxETEjWb+nKf59lXxMYgGVnSGbJbaJ994V2dAfYmFgDiBH1Fu66xDwELOAXaMmqpgTmfrNvt1vXn+b2b/+dru/9VgutqRoCp1PVakalM+PMeEq8n5GZPyITDWtvVKLrCUHXimSyV31Vny9t/OfOIwgPuOddVBmUZQ8H6Qh8MrttPqJM36Dn5gqzQEwreEApaYMc5QJpiTVauHeN6O5knsBQwFt2XxwAuh19Re5HNkN8qGLQVBgJEX674DbMOr6PrZucWFD1TaiDLFyfVTXTxsPOUqk7Ocxe1iusdBaFat0CjtffuHr4bSNgx5jeYfW4/LDCSmwJxyf7/0ChAoJGFSkc22Z7xD8Ep46tf3qllXKYnShJgAGDFBh8GMxZ7fRXTftLx6yFwcqizLUc7HfRtWhqz3VJJFVxVzG/CfhDSwDlH7B3CDEtbN+nU2y51ExA9Mb7n4YHn7aMngX3cHdQF3q9VnMet6c3dR3DK3KQrwIcnfeGUjOiU0RCfLY0viUOaxShgfp8OH4z/0McPWYyI9YjoeZ/Of2rL4GSEj3jVSTS+YkefujW+i1YCtONcwNeYZrValMU14hNsVrO8yR51jzYEK5oBnqqGs/NJMH1jsQs7LFRxVz0VTtR6ELUquK0Num6rDbMz+Wj27b8m8v/9GHPV8TfV8Sg/hq5fFwaS/6i3Mdt/97HjFsef7J7Hq+Stvi+Qh1B9H7ZORq2WkfreV+t/oZBx16hMCi25R7pL4XPNuweYfWBz7bVul8tu/cKbtnWsNQ0FXz4tUR7GH1ECMZHn8X4f68s8ydgNyZiV/UWUaWmUg1ENBbauqGEf2g+e+pAEAo9q8uSAQJZ6k0CUFUi4AjWar137gsDMe7qbQ3rs66i6bNFHdTfIo1kvcshs2NagQg4AyjDTZRwBl7ldKzyRiq9o8eVornLtmeTNQZ1ow6hDIRMJVcNO8sK7qtrteGG1Cd87eEGvMxrKcrCqOX3AG9Ix5HGbWQOH4HeOwi4D4jImyvEthII5Bf7RVl6vWuIPBFaeZOrmZG3bgXltc4kigRUalhP5SIKPa0gWjf5mK9Sb9oGVlKlv5aQrv/S1moEay9duPfVVXHicDq6PVhdK86OwCu8+/DV5c76DpX8cTwm1bNOxAg27ha+6RaC2/9L2bqmgU7Vau33PfVPzHmHvk/uBJMsXcL10RxKDTUkdIsB9/syZiG7K3QIvjUQ0aBr1hibMob6AKEyilONpG/UPXR/S5DGn7vVdOk2ayg45VaqBhib49/Ku/7u0zBWL0WJ/5czREBg3C7CdhvcwTLpUnnVgx4lrHzOfoN4quyFm7plYQT9Z0H0WCtE82do3UEkvP9dkb2jCp7qYeAwcsRRytW08MVrRAGJiGJAcZP48gOOxnq/XA7Ij4DvI//1y4QtCG2cr0mec/3lAQK5x0gO97AMJBZb9kj2uEe4CUMR3duIsvp2IvQi4jlCX46l4vjA9DECvRaVed5xt2wMC1r8tU93Y0Kc95zrAqMuNB42rIXwboL0uOqyoYdl2mUoZbAfW15nun0z4rUCVBhvVIZ0ZI6sT3Da1bRUIZkBV2LF/rUMZ4EQmCw7/TMtjznUAmFgsdoQXtG+fjjeXwggpD48i0fVcBEiWhEaMVygHigYmq6PNIsMPS/XzsxE+vPsI9rLaQwEN5z3DCHMaD+74L/IRgw0xOBExHnGs8GLLx8pKTyx5QxVpy3NtXnVamsvCYXCaE9RmfLEFrJou279bu3nX/kumJpHSPNClh0JMT7b5Rzs+q/pdk/LXNjBA44jHg5vCoZfFWCxAuO1ZKNX8NLbhrgYZMAQyZNN2aulZdPgDj+IBSZGixVPA6K13q0cQKKA+S+VVTAzpADc0an9SLpZWX8fA7M3dh6+NuGkJZFEGBTk6Fe2NTvXro5PHvrwiq6DR0RTG6xgcZeEo050H/1ANsIFVUGQsFA+h8YbWfO7f5fV43urltCogqwmzWGmmMnoBRslXUq+oncGKSUsO2yOpJdSODuFOod9X5A8WtJD6Hacn5lkRRvtFq9w6zX0sl3uGvPAmVCcQK6MmWRjdCFcZak4q5m1RJUXSaTOqVr8B0puiWTLio8YQd3xvgN8By6HJM72XqESSFk8C88uHnPbkS5IjnIOvzTLZXkaWB2drNF619ZOfnz6++/ATErqxWpU9BKxZpbud9dg41XfdQbGqEMqEaUds5cKA1Jw2XxnSdT69F6s1HGnHN5TF/2qFRT1bbLbD/ocyKkhzd+piCR4+AMrL1eczo7F81A4u9g3Xpwdv0DccdBkHM3pc1fIXpse5U2xvdoliXNlQlyh76zQiFxxcpoMoJPAYBaS2TyhGGlIbStQwmP60ifrto0G3qdec+svHtKWBedgEA5t02P/L2rslObLryKL/GkWOYBuDb84pY/6/DXcnVZmrALVZScfs2u2OyK4lKRgkAH+9S7NyqVM3OFJ2ptij+hIPpHGVQYZaEnX+aLLsObMlsTIhWV9Xdks2r8IdOpJa+LqMkJTlUbjeN6PFoZoGQVK2DS1hYWhsZV2nLLET1Mj5aTrtVt8BGyKCtXwMLKwbgY9e+RIINta1fiLNb6kivZHzzZHzEglYMubU08GRcC5MwWv2a6Vj2jUxkaj8ZxB+N47Sxwe1IhAsYK37A/APZMS6m7GMee1tTBhTYX9lPK3QIrQtbDJhaTjL1sg01F1UtMFNeOW65ZwRqBWBYDE1w6NyfMLzyKPK36LEY1woNMZquCSSAGQ/abaNXtvCuZ4eRglYlv6+p5J2RkTkkRR5KkVUfJ+6/2zusoJR7ahZm0M+MA7dzV149+EbVNyy0a5gE3Hc1o5hfMbnHuA2T56PJwvEWlXrRmzxgP57OAehACWQq4Txsk4Y7QfUku7qlLsjxwdabdjJZGgAzs1oJI7h8LPHVw6wtDCcmdoUrNjNL/GsEP+KMV0HAv6E7Yuncr+pZk+2JKdU8cCKJXaCHQwajKXrVh0Jg0AbNJB6SrKGNURaK6FNTOAqE2nofc39+25viOa6ANkRIpmSWd3QDyd8EGk+am9q4DHIgyXF5GXkGXOPh7NJhzSGQ94Ef3UslkBWHIiQXcmyXYa1SON8peKzpv5z6YPZQg7hrDzWAbOcVz6893D7zpt2KBC35G05O0EQY9+J2YKtlEWblAK3ZF7u1Lzi+7FbKMfFJHJJiVxVYgdczzH3Oc7slVoR2AbueR1QrTPODO9qmAVoBF0TuP920Kzj69iQY1wFyEEP8nR2dKUuvuts7FIbAIEucKjrCYEwIiTb5vArJzifGX2i4QoKnQEiy2lxwrsa68yMOKOxmApzQkasZ0ddjQGWfeZTkWVMatcXR0/XeLKGEmF1/C28rc4Yz5FZRprMABLCXjcgrIXBG96xn/38AALJmrYq/lsyxv2do5tCL+yRdPtnubjtY5YNXlg7Bj8523wgeJkHo3BBJc9y84U/p6tMcnRMgi2qbezWES1iYr8iZSaQMU6p5pJDNVxCD5X0xd1H8D7eNBqBhhXNCj4I+NB6TzGybGm7E3HOpUELlmDDDBxbvy1GIbOhUUpkrBK6IvkuSh9gX3qEyhvUyZzH3p0n4o6+qGap4M6MjeMh3eyL2pdrTLaiZP1j5v8Vym0CcU7E1XRonZ8wgnD6FNkg2CPl5Am274BsDmpm7TVjPdEGzHTexsbU0SQb1wVS+FGF+OBeBAbGfZDXN/0RjBYd3lb5Uh3bACA9J/bh3R2lNFupCjNs1oyXa29zwMYo/7BXwNZJek2X8AWdrwSgLijmgmgbykgCbDHot3c1/6Lh/Hsidq38L+Zjug5LGaJWIMuhEmPANWIzpGeBrBF+BXY8Zfi21Xl0Ltb7My2yICnitIIhyBWBYh6I9s2POWEOren9PHDJc4LbaW0zyiYY2lrPp7ON7j2CBa3sDVADOcPEAKYfCag3BoknD68mFT4iFr0w/gv2ZB9fygAu19SknnXMUzcZ3tUvYN3l4qx6gS9Rr2v/AiBHM/Gr4eRqm2QXyFrdwK9YcRApFDxFw94wMl4Aqi9tlZWfoO2yHYwn2kp1knmEUfSJzXtx9xGoAqAiABe14zFmDeuXNPA4xmERK617ykX63YwKaJSu/t3+4lpl/zn2s0t9um0RfJ6R5uCp/+5F3BKrjZj+hkY5PfXf4V3QabmM8Q6Dv2TPGWENN2m2tol1bnQdkU35sFo7KFGax02kLMh1FSnF9j/LUhuRgKrbQ/ZtxNb12L3f/Jh2VBYxFq3Yzb/Gs8A0OYKFqTcPattxn1aV8d2HzxO8d2AVPQMbAsnR7n6R9FSsRkHLjIizUiX2RV9baAUpSkHtghgCTlbA4Ao5iB5j8dmwjEKdF0AWVadIz33yL8K7D58byixEjKegvgFVbljFvkmP1Zq4ostIRtCn45zluXry1PA9Yl8GXM2Qd+qxVN9f8+5zobfNOtGc9onWRgyQfLJsr5v8dNaTXzzBARxeROPRTXdSOGOCTkDniWh4HmfvD5c0MVoA9aI8l+GIfJ54fPfhkyMZcQ1ZKqP4yDnm8GXCOZdidsILuWlkina+MwwItMs65yuasc9JDkmXHkXz+Bw0AOnsSpJQh5zK0+Hixd1HIEy85X9wJYa4TfaSXWiBdaT2+S8GMMNK2yowIeKDB9KSR0ED2lf3dd8YITJSCPKg/fjoJ8PsUsildX6d6xm+zvUQzKKbD39F3rT9hkl01yJrTWbgCz7G+2LqVcUklFUL+KFWbz21pw/Q+mhuxEXzmWvva/080cMtcQO05hJxNejkdb5iJU6MNDmuh+5E16FYnrMo98vWpF6OWBsYaQljUYUnwvjAuW6fEN0pKqmGUiNfx9gEg/Pt/wpXkHzIMX4f4bPfXrHlfHwvKoTRLl6lKe0e04Kfgv83nPf9qbqcnZBSTqypIuPm2ko2TVazaJFWBz2hs2rnfxaS1a2GKAeacxG7AOB7MbP3ZvzvGjt5mseb2kYrukE1x3XbyMczubxhtqPrtgZVjVG5CB3lxevY1jdaFRlBRcZRsabS02C+lQLr7Uo3EUn0D+yUoI+3FudAgPZLVtJJEu3GNaLAVxm0HeGCTcfPIYQqA2QzYqX4LJaj8rfGb5BBVXh6k0h5HXnQi7uPwB77pvp/YrDQKP+3n2vqjYWJw5TLJLQ7M3XRywbSoOpihkZFs7ZBttAXwLcR8EwHdBnTbMiEQEPBiObne/+GPNZ9QDdROevLrya72B8pGh0246w+O2gZQJm/hJo1UD3V0sM/XL4FIVoXoXsRVu1j2x8QE3jygBs6AAizOPfH0ZSEH3RSBysWKCY4trboToAsYztgk+CnggAOTjIDGbmvOQ+VB55O4VnflkpkwRoM5Xo3EOmeXJvw7sNnyN4PGVRhYKCRGs6tLwp3QHJKcsu1dZT6Nl0u2Dk1gJsomOZXKCwKZEgx+9bj6j5FsXYO8BjP/ZIMqqEz2ZrY6KZmMngN0UzDe22yMNJMZtg5Robs5Kiuv/Jd8CPvXiTkuWRdj9ur67bdg1XGWAc05T/ed9tniStmCBM0c70w6ztUk+guKJXY2JGJBQjGmqW2lCZn73hHCggAke0lXsC4IAn80om06SF2fVkDg4WTWAiO/fcRATPga/5N7vzmB6mVcCns3mr9lSn2lg+AU7AoR3DZS4EKD5W2FRfpKNhtEbHyw8FoK1zW8BeJb2Vqv8xW7e4ZfTS7j2b9QUHk10/PCjd1Vi/2szSt6vnUicU3MYZGyCdG9VzzxZr4SoZRLTQYwaYDggfiQ/jxKrqugakU5sQYQwooruQdE22xlWTF1NLkNpxbB2Nubyr+zY8DcgxI3Vj2thH9jnv/10A992kKeawX4mLYqy17Uv2kNP/VDsTld1yuR3PueLF4i+ttWqXHlLxBiQRCh9rPLjdoECjRBNEnMQqjwnZtO0SjP5+VNto4nvBi7k3a1VkEqoyAhelzNn8c7lnH93VVAYtzzR+He3BXfR34H02nZyq9ad1jy7Z1RgdSUlzzk+LosgBcuW4MV0XwlgeH7VPAth79+bD96FeyEERXkrWz7qIqqj1F4PFdHXXI/mmyR8NZnuf++pjRQbpTEJf1XOCRuMM1FI1JGRGJwyN9bFwCCTxFEqte5y/fSprkEPku/IZ2qK/0BGCjm3rtreYHicJqcnT7re+3HuMi++3BAO87nPxvPsZ3RIR4QZtwdbd/i3R1lTTrAUKdbcLj5xG/wFghdWhbdCGHpxwuZXjz4StAbik9Cud+bGvB6hMLDJ02nQBxHZvyVC8Lojqs9ZTy1UfZfj++P1DkJ/RKYeIpUj5AJ/MIYjeYYNUqz6oXviMMhkW3LQCsHCWEwqRo7YAJsJeSOGkX6or2FUuJA+FxSD7zqGqHRg3XVqkDktKyim3jcz/5F3cfbqzrTaq+bQxjSb5nT+B6Uvut/qbTJljOuaR5FAUJvuqNml574LJsiJUGkTLBUzLgOt3oaaWEF20J+fwEidgjBd8k/3YSdTmV6b3vXNOFVgMFIVemLeWidHv+SNI+VezvU8hkYAwTGcmElGOfovxDIMsyBsO6va9fzyHui7va7G0bJ0ACywWruUvZfc0uqSlXrDvkKDyMfC5EPPOMZqRBDQU38wUDa+JGtSuh732vWn80IaMbW3p9qfiDRZfoMAmj9wS/TAJKCX4VXxpKWn28dktgP0V7NfGMBqQvBh/eoOTPxtepE0Dbygds5XMdz30vuPnwSVM32FFQ711z71hVWc8DxU2jb1klr1yDdJhPWnU2tL/Z+lHbGSltfFlOYH/ss7c+waN0yJH3JobChOaL+qfNjMhsEMB/gfpplf60XUe9YsURs2DgrMPLgbDMl6EFxEuPpPkByZA7iZWzGfwzi5xGbNNd6wzQ8OZnufPYe7zLHhIkEivhjgPm4HfhoC8aDMaTXm8y/OxoIcTFkp5E0oDKrOvp9RPfffhIM72psYLJAMBXVlgCWM1W3FWh4/Ps6iBBV6qhuBlZXcFCPQD2fBAwxLAdwPu5y8NBA9+Lvv+JJM0TsxPffPiMipsBL/nCghSvwA45fmmAECNtoBnyYvEv4LxpXcMUWyNh4v4VI/cBzh+wNXxux/shqd4jkRutvfJrbXZIOQ0LyVOZDRv4OAi31nUatuDh06OqALz5eoVrRDhIBOZ60O8Plx+yDRBPS4oNsuie1g/RzYcvWb2V7JoQzY52w55M1/Aio/fmKT87W951LsM0ujITBousvZQSBcKjIEfXC919n26E1QyOYlKNUu0hyoSZrCbkdXLB9zWTHhcc16y83fgr1otqWvtf7GDgOAK1yLpksxbzswI6l8f++ubHKYNul5hf2xL52cpZ+985kbGvJaPWZpXGsft5cffh04huZvZZU700XW90IP0i9wkepdzjLgyqJf4X+wKflFSRvpvxiJzlU7kiipJPaDquDyB0s08dZCqwgM0HkX1x9xHQRG4aLSQrL3D8LJivLm0wjHYDg7zTgIHoyblu780o2yZibXeL0CUicJWIAjq8NI9P0CY9GuRNGqT9Db49mxA7WPnQMlzjgS4IMW5paBvEdWircuG/g0jTTaQAHwGubSJSDDJOQ5rlB7hUHj3qZs6sLZom9GiMIRN0zEOwqiovF9ttiHZONCy2o248qF6tbC9Bl2sXMPMC8pVH1HrfvcNT6t2U5DUKgamls+Jr11AL8+IEuRX/3n7Gfb1jV1xb2fcEiyOzj8gbJBYCOrrBT5SoXoMlWbe9+2mzWZHfNY+TqO2dGIeQ8GqPbJxYsGqVQdEujQHadp2LMJoI0wk4K26/9yxQ6VxIYw+k4yoO6gzdw5uAXOAAO/Cr0Eun1Q21MdkKlTihGOQ1SNuDHAzMBgXFWBGxpEyrmK/YIdhIzS+gfwkriSCaCNLxIKDvh3I56iIWo5i7X65F/+zI6D9OeU8vSjZwytqBsQ4m8vf0Ip4XvBgv+IhOtFb8tfUEHEGbQ8OZIGvgpBEu3wdwDO9K/GMPvdAvxp6bnXWKTLrghkseJUhFkJ6e7+NK0vxAqxf5V76uwNMhbHhyUC2GgUUDRPUrLyklFScpXUmD1tyeiFN08/FoiGGanbEvECaURFYN6eoN7QZWqVU8F48jVGGTnt+4bAtcMX4o0CvKP/4j9v8Jf44UwIFe2FMX87I9s8n/ZOVp034pHKHpwXdc3ILJFQQBZI8jwrt67NlaJzt/UVjMa5Xz1CGMsv9lcXyV03kuHjTg+WaGeshAPeloLbXeF2gBE4LIiYy3n1DTvyNtLjHmBjHG3kzurZVKBNkHwm4iV03MgUJm2WjBbQKDIf0j9q8rzScQBPriwYBy4xN0PsCi8XgxN3gxVouTCAoEEMAbywxwfDl5IfMH+13TZWsfoETGX9vurZc/IpX7DPTAy9cn6PyBlKeaLttkaEzQcJT9wZSjuwLXoDJsepdRy9c9bU6gcQ9CqCjA2pO66mJ/vsA6hmID5NYDevV2UIa6tC7TUnTiJ2p0jwR9i+zc5iFN22+RxN7ED5BXzYInppWJqe3ra7D3w99X/KS6HkmhIulURLL2SdnPrQ7uJpit2pHA72jdwHWc+V7cFeAAvD9TrH5ZN5mPug+0Vjt3gROlvLMPLg0U7Y8xKcwbDQJUjNKl8I8Bnh7A3VW8+/J4F7ltOPHsxBiYF8Ha6seyh88mwWI7DbnAaSZ+xlDRTS36VKBAoltmW9umqeIzXkwvRBxPa/+P3s7P7ImYZhEvzeOx7Z3ftopLjo7Zet5fbem/kqQ90vMtcjOTdwXkWks8RFa2E3Yp5yCjPVibIw1zUKrz8c8gUjw/nXhcR5/IASjiVPsc7KPhX2iu8P8vmrFifFb2uR7ffASK/FvKe3tFUJ7CIw/2wMK9L1A6MEBakKTNbaptRzSOizHZ4cFPTfOF0NMl8oAJBP+BQcCTODgXH2xu8PvhSWan1BlBxncffi71TT5hg83YRJlhh/RYh8Y3OrByVLMdPY5iOwttiXA44OvYmS0iSUg19GiJDoNRl/HuF5RdHVO1n9YN+OBs0m1fJksEypEDq724+wgmRTf9RK1T4sEC+0uMfeXUUhHjwAkzKqxRdvDR5ILNeFsBGVhlprFs5OwSGcH4dqW+uen7gxvsW6hKS9llRU3p2ltesgM4yUjhQgV9qDz+OexSnF4xolzMOmoSC2vwS+7V9nKWX7bb1kzzAUNw0Le9bj1FTnhT233NYFiJJwXH7/3l+8gouUGTgo1Cfn5Jl83reuO+stL12Vkem2s3dxAXyYm6gS7+s8Z7Iz3IBQ1vgoM4tLP0TF14o8Bt+7++rp1y0tNxjpugxVTOoMmPbvN4c7kQfAjZR6CkD2L+aWP7Jkc2YLxoXEqdTweL8O7DJ0PSdHpVyLPZTkCwIuqkSv2NtqPy5SE2OLUdo+yepMsYOqDURwT8kGjp0TI/4VnjbEy3rGzsEOb+hhambv/UCcmi7XuZ19HLStIzkX7IPDpwwbqVzOp8I4ub0BInsrTyLbA+ML9yMcSbWOEAhpgFlK6xqW6oWxAV33ndlrKYD7RZRLoj/5kJexn9eQTIRwB+BFH6kObRRqWemaZgSxutcGJYdt8t/Yu7j8Ar9qZmCoxH/OS2hqGN0vwWnju2mWLgx1CYtLHEAZoahcs8qNZURxRqqSLtlavV+ubnnIALJtORyRH5sf+h0CZLcjY+YvSOJ3IhvPcIlFs3BdKg71xKdB0tKZ8UrrkXoogoSMZEX20PdhBAnBf1y1bkzH4y3H3ddKSzjgJj/YDZ94mULjXyBjUSzy+p759Wm/MIRihc6twWQOK39pcHeUfJJCfdim5xTpY3kYwqEF0FtEufpPk89MckqtjB2xaP4urHj/bF3YdPFrlpds05Dq5aRb+1eaizQS1ewkDXLoRQllsjSV8CJFPb26PXPmIm+EyGgIri81Y+sel5J7h0wNafDBoONMA3O87tYheT52YF5vFHCAyTkqVgMxQz4zXGE2BCLyoEr6J4n0bpkmZuBrvAIlUFKfbwnTBju9iswg0RhiEQnWfVtWHxDMsScmYCEpLPWAroOD555wfBhrTgKlMBFrP5OcCN76LBg8dWojUUpg9gP7DDwxTPXrim8YP9BkUHL3LOGnpfjhnASe8Hf4JDJmjIGVEIcOX7eoVvRXiYh5/hOvgMAKk4UQJD7BPMKn8hSyDWKrcWdiL9auMIuP5ujOJWJG5dfDQsek381+p9qgk+bLb/TNkWa1Z1yJyxYQjduCc3mt4X9TpYwalQwd3U1ddjPQT909JqBhlcLX5IzYmoPB7155ufcw05oVnBi/nGf867f+PPuozYG9TXVDGJ00GFoRdLdxyI8g4GrHFxAMTLC4xIDZvXHBdr3UhRFeivQratx839AMnIow3dSqy7KvkTqAuK5qoLy8S2vIuXoYg5LMGk0T2zb8qViUJFDMSArxhSkjwC0/vRsJ4A4BbT336xKcmKlVxJweT5f5SAaUIJ59x1TEysoe+kWxQyVce57pukRKYqUfKsq0f4RDS4J/25H6KepFrETrFnNiR0QJ+BLDBeRo7K7Ps6NAJDdJMKkEoT2sglI3LViJLHfSXSM3ZgCZMbCCtkNXNxdrxjB8K7jyC7+KaOBhG1zC6emKd2DdbBd4Zj+w62srpk9yvYqsrcvprDulQxMUKFTaTI+Vu/o6tW/fJF7J1Jmr9newQn0MrUK2loCyeRM9sI7z58mhUjYjFvKRrVQdrCesSaEfvILHXA9kcjyssgxkFlz38E5O76gosYMRdDCpdH+PrzzasMR63GIPUKMuv655tHdzXVtFWNQBiUE8VqqHmcWbv97HgEZcCrIM3XkzdfuPhK6OiDow6WqsuIlOQo6JIZwi9n2lyYj5hgBEUegq2zIxJ8cVfcHIzqQTyw/4btku2wFC68MxegNHuP11Oq+BfQF0FsARrnSy4dfaZKoo5WI+MyqFk/czbeGObhW5MIwpElXBbFRrInUppa0TH2eCp6Ij6c/Ap+9sfkUfVIE7A69zsJ/f/P6ubf1RL+dEpGL5dVPl3M3tzbpSWPdHLrspbqMgwW54lHwBJRGbvKSRILJ7/RpDiefjnDsg/A9S5F1k67TMcFCWNR1VVhsbYdIYV+Lh3reM6XrhecFNeG07Go+/n7pMk7sck6pSYMGLhvE6w8yhRDE+wxNfKu7FgmrkUhKv6zwBnsKni/3HUhaLDaA1qNihfx6lybkSTWF9DGbCyPu/W+pbTLoGGge0Y2k96/3Df5wfaPCudB0X6mHFWU0Q5XevFt7CBr5RXvOGAph+wcj8vzAYaVx5m6QY4igqdW5NpjRIxcreG4tD5QzfG05sS1nT+2L5L6DrZy5YC+eDCmY3nkrbcjrj0R3k1NDIICocy/oDrdshW8kt3WKc41jIQFu2fs1fAZxDnT1t6bIqFMIKsJc+OclLlPsGv+5ssoESyhUOdl+AWWY5CeWagjhHRBbbyvQiBxUQOJuu8Zbu+JIH3FZMzEcXg7H5D8eONUGdLlOdrBg5+nFJqpi+ToRhX+5rqjsygYGfFfARk8HTWij9FEmE48rfWmu39mz0ODNvtnyuGFX0/EObyrGgUACbHixZX/LM0yw024bG1dP2nTPgnINZCKEeoI0XYA8F2+YPhz0RAEvJH0KVadx5K7xYaDHeC1m3V0KF9SrEA/VHTddumupnmRAZf2P2MtmchzkVAmEta8IOF5pL333Ts8BcgtqYeV6Un8IPu9pxoHAAFAn0UDmmXTKsiWWZMzBqtvWt20nMDtI3YHCRQmrh7lGRZQLqLKGTRNWRFRmLXjAsK7WvwwnBhkr9ubi9i1e5P0GTSNIQEip0975FKc3RSXkGAf0PE99r4GsPgHM8NkMwbXP8Ui/zx9dqtthaD1mmgI3zAcr3JGAvwxrfhZGsNNHPvHjcBeak3WMjGteqQvLkwTwTphOe9W/0/X5SYMGSo7WRE1zIW263J0U8/dliKwTbhP2JnTjlLEaliYNPNZ2+v/7CZ9NYOfY/Aq98Dnbf7N8tSSQIwq6ZlW6/Ra1odIJh5t5AY/BN5pe5oM+Jk/NsoM9HfbdKrb48PHQBUEmz+llIFfxR08Ypz7/PSYkuIRWN5m02I20mg9judlxQDGITehKKtaOPIiFLWKVJsVuydoYXwCtuvvUK+KXagTb8MGv2Cb//UKogogLRcC03U40QKLwMjCjp5fy966WB5oHRxA9mn2EfozVSC8+wjeY0nkLjqDsBOprZaz+/weYMQjg3jEEAFa8RbhbSmfMOxxKMI3qcD2E3Pejf9eatfJ8LRvBq0MzygMXDVPXv/LoqCIgHzpdwn9fSI7oJiA7BGWn5bbTeHVdnk1ISsdxhDbcju8+/BjOW8Sbe1Vx8wS6Mm19sCkXGjR7V9bULgs8eFQk9kqsQe+IGuHlGtfdtm3AVfXYfaiS8D/KbPbwGW2xueXcAQ8kS+qT+ZG0Il975MuuvnwEXMa7NtL0IouXyT/fZHn0LEk+wYBx+IXBGEMii39NSCyE4HuMDF82kaMxXvI/fs6Ib7ejbav7MgbfVBu4pnQ5JzJIVRKX4I/C2h5Cqa2zbxteLWSlo4SCb/fzJozxXBsBN96cC+uIx+6ZZ05thQUgXkE/RUILkrXAT0OH7Wt6/2yv7j7CPhON4X+Vl50fECQ2uvKarftzAECiFE8I2CyHFTA/OqYVEmKD3sqiYEjA4DIMCDMofBzK/4YFUFLSN5s5jluG9w8k6sXd8UwQNtmvSrMUyS5VZGTBpgRMOCwXS33E9bmzsZd18BIRxiIDh2J4jkYKnhg2HhG1cb4Z3A1VMDYmlHKWT2J9uG9h08Lu8H/QvVfNF6XhAuJ9Rd6LU4pbaVMjtA7V2cd0oy2NiToiBSEgd4w5Jt57LT3z3UXJWdmDqJHh9CAikHc5vTYusEojoibiK0IwbFeaerFzaNJlh4xjnx6UgC/+2D9n0K2iRGH3A2pmjGOexay0d3HAwk19unxKVB61b7Yv6FVaPZjScpnhcjg17bGAjEvYH5UnExWcWddXvYFh6bVeB/4ZCORcCAp9gTI3/gkDSZymX99rSqg8dQyVuQpGGf1tF1F0zhhvi/uPny9z01dT7aSDJ8a18sJk4YDBDBdsZ+B7z8dIC5rD0dhQ2/H/A5ljowhIiOJWE7kyY/eJs94dJgbvBc7b+YGAar9D3zrRmfCFl907GZbCYNZpO0J+AlB57RD/dq9h8upDxj4IdXGI+b8CbTVeW1vSuUculjrc2CYF3eFJC/KdDAGtRYh5S0QuSDB+xp447FwdhsKApQtIpB5xjozuQ4IHUAX/noga3pf9vSSgbgyQGgLEpPAnMXwFu/aTwAdBhgyCkeiBv+Hkp7c4PiuzjI7nUndLvTCBfKow8xObsoRCppx+Kt8vZgj+sqVGG+P8HkPz9eRZv8pcG2Y9my1dPm93v+VHI2uCMhM00EDW5V16ILg8IzJ3QsRVeN6+Ql9iD/EnwO02usL8aouCUYAdLT5Ozji33kjHhPkBuUDbWgSbw2+59xbFttajSsQ6HFdm+qFiUwXycTq2aYDK2CX+Vy0iGTiU1Le7Vx8rOEmpgDoZQvv8TS/BGRb1UZqSAUMYy/t8WG0TZfBL6i119w2qiHeHuHzEZLhIx/729smnPhgrbJfMhC2tuUYmry4+wgMgG/KL1JNFXsB9nA7X1RhdyTMD7qAI3M8r23b05nUCzsm2m3ZV93yjkA+EspNPHkKrncEP+DnY6gcZnafSUnzCIC3iH6tXUmDiWlv23gK8jNpLBxkWJNzzX3dFmVq+ncupEM8hf2uQUBkKBARDH1C4pGEQU/MMsbaAZoX2csC3a8kYfHdR9Bj3dTItsG8d1y3jyT0BGofe2zwhUWlUjBbV8w4HcJpBrvIISpCoULtbKS1jV3cHNO38wPMo3laWXkhMLwbu5d5cfcRiNxuitms08AxDyjluq59Li0NfLdo7ZqbIrUgy4fkipftGJvbRD0QjQca8xcSOk9y964BgMf/vMXzTO2AQdmepsZv9QRiEYKyf2gL9Bs+9NVEF00wDtP8LfALiOwFYnapx0Y9lR5GuuSD9qsxo94OlXz8Tl7cfQTZvDdZpBkVpSJbKtLptJ3hpahIHyKdE2iBWJ444wh9KNYrbSgvZJdGbFSPvfrNzzlypadlZ0rcfxhH/0698cg0N1gz3Z5LFx2kwNiC9JgOFzoezkAvrOeWTQ0ArTKmqhWrU6X2iNilARc1IOr4tJ6jA7Szk093gnPNqaz9w6fKf3H3ESgVb2oECwitlalvE73qEetZn1WBvkOUZwX0PKmlwDRxaE98+2vN1+LBQGsYh8p5IXTvks1c/tgNohjyyqa6fWs2ZX/ZcUx2lrNWf2YW3J0VTal5V8VVTJRINBhIDENimkdjO7s9HJu5r8/OWCDUZ4ceHt98BIfRTV10xYKfsmDIRYU8no9twduZwbrhvv0dAGjCpp5HhhWN6l9jvXSkrw59IjxbiffpZi6D7AZVzP6IBJJKvoUak0FSjh4Z8p+2FpPtrwA4PEmr7PmiRvKZQGwTsNN8Ltv7ghgXdLgBOiCxpGnT6X1IkYW5S6dx9d6irnN5zE4PyoZ+b21eQUhYCvhNPqTh4h/Pb27vFP087CdT9p1tienZ1od3H0HTIr+Ha2nIhu9oXaF6GfD2Ia2QgsnOLDWvCTObJO8uQKdXO5EIPmkhIjnELZHXQj1ZCIhMh4/v6GpdsaOfJR/eBBwN5nZhVpt91DJLl969TGbpVcHUtvslvdpl4VkmbEikW9Win6Xy8ODJjyFOHqplQvg6grtdePybn3NU2L18ybu0pN8E+X8+4f0HqgiNbvXoJhfAIXWb+3tTkHj2EM0pPKg7XCzu2jq17Sq5ilsGXJsdfXkycF7cfQSE75uEb9tT7TEIMIbJHtu73CBemhswrvb4NsUMzv/WkY6d0ju62rUM1SeMmtSuAUYnwBwQyt9PNiXGUEcidMKAvCwtd2P2Oc28cewOEsKE/a2RmbJbO1XhAogby92VVFdlayf05EKMMoA0PQRU1+E3xY31kt3lz6qlI/IctTh41yIOTfBHt+YhvKspZaOuGGOAsUez2JhJ4yOF2Iq+cQZuHufH91J75b3msjQ9UqeuZ/sXcdTkQUev/nNUZTUZ65POxGM+3YoW+lmxBXcfPknoBknISm9KzXnwduWNo79GJpUm8rbnFBL6pgzUth2D7ZeZ4+OIVB9Q8AMCkk9X+gSD1GGE3mJ+2tUhVac9oiH6CPQfVksOUSKRQrgt1dWcXkW8j65aJJaFRDKSiHDqE1Tfd+xywMSbaSRWXOf9BoPMhEcGeieihYWWWIdWTs6JHVI7vdA2mMV6K+JiBMyNAKf0Uc1PqFkdJuxNxiuAhNZ4HWVG03gikSoknA1RofmIUJtVmEvE2Qvkw/b1SvzqamVjnq3Py31qJC74WaHbWtY/YFe7cv0jkgjvaqurGU2/vVgZXcPYm123FWcVyg5T3hK9v0GrECx6AS25UkFHWKjL9sCHfWzbDy7sDb9xmH/iFniEgRvMACYvSgNlVYh66W4vQ870C69ok4WI9kWKB0cGSC4Zcv4P5DO+1iaiIvjEhfdl6x4P7hbfzZrwPYa2X0sRHdCV215XORGDOrlW7Ux4UnmNLG53hc2Arkc6d18WH9LsfFreM1YAREAW4qXvOhy1404ViG5qoV+lIVePxbJdvw7wVqC2aiyW7ekdH+yIyO07n8fc4oiL7FCXVdVOBGgoHtxesfHLYPyfI0097c79EL31wkMGa3ikDbvmwhIXmwKmzCrn7KId6s0q8pnFduMXjKRTvs4qSEZzc9Q+QCzxqCI3OCHlz+UrN3G1ICht/Mioe3Fczx28WYC2SHxtZQE79UAc6SspYxKKR1l5ckQXuocEY9rJHDs7YNoYhyMa3n346Uw3qaNWrpGZad2cSOuZvRjyIOCAmpF2wGYRzUEDwIIpFoEkXnbppD711COq6vKFmV6GHz0Yh7/6FrTrLFFSVXGaYQV0nnV08+HixUw4S3nSEq5ChzU1CAYKZZtV0uz5ahtkXSTwkt9dgQzSGTLiWQWcrBCJ9nDrD9ipJzT7uXQRAaCokxlFwnAg0/G1QHiJz7o3mL8ZGDHl4RVFwiUsRK29Xb/GHoPB34jQz0esZr1JmuwWEeReth+OfQwRJHHaXH0TgKywaVuIjur7Iv5dJ71lxrnu4/E+eh+P6byx3vvNukuKukGKwtS0aELerYdg+QpSqz2btXlso5fjKDpFOeaEnKV1IBcJxCUR28rnZj0VX/xFqOPNMo62X+ZoAF7cFY8GZ0qm/MoOvGtnxPBZYF4BgBSMwWO65TJX3VCLFxEYrprM0Z7pPcOEBHmmGOcAB/ip5wYKpe8EwfOXZE3PYVt8V1+9Ig+0kCtVQETtW/sxCqW1TFW/en0qz9wZgq/FfCHd9Bla0X6Ckymh+wUVa6zy02/uLeacw4ZTNH1PC4sUmAKe5Ulch7TLjnpgYuOMoCDfqSj7wJKzVmebhwVy6EA77RPtXFben41eEmb7xwdL1Qbi9HObC+9iKgdoMkPvDc8YiKirfPbodMgUQeiQMtQJXxqPtQYZvjZcO6k0U7J9KffMwI/K735pwYZTvGDq504Jv/k58Z/CxmEHCbJdf3sqX1vPBiI7lzg6tecPENx8+LgwMw3t/6rLRgKP5truQgUEUplO2IlV1o40THAauPZ4eYpD4FPNAl5ajDh7+PQnZuvOeaW83lH76HIxBZmlH4OUhSZVDOaqSbNAEetHGe9FKuvM4zUWE0A30XHoH5/vR+F5hOebzGb4m5Pas2iMtqkwJJUhqgTXrU4cWvXARFGva55zpbS90SMhdKSbjgjVLv/62bTOTrwU9VLTdm6l/pnPxHeBLZG3S/tDpbYUyX9sC2BmeGcbio1c226ZhFkwW4dABAO5a1+3XwKEJs5r8l62IRYVYlce1vXNz1NyRilPs3V4z/5Y/8O2Ffam0z4pJ3DW4x5j2fjmI2A43JQF2SvGsnci3GST1cDoa9YH8u9hB52ypJjI1rZPTcoXmpGkdi2WC0Xyoth+2bNr/gAa477Qknjb+p/0TYEwI+V2ALC/G4K4AI8L9gi7izcMb4N5nvhgueDLjlZlYlHKGczHN1XuFNEkF2avqZdT7VhZC8kxmA8NXOuvF3NE1xrshZGYK61yhFi6bK8wutwLm8P8lPOUywO9xfdM9nu0ba6QcxF/c2AGDSSIgzx4nR6rC5DL9kStd4awv7DAiBwzYpqpR0t9DjH6IkUEvTeds6v93ufAf3H3EaQsA4eErJzKzJ7/d5YlvO0RW9hJX1v2W41z3f4narMx+LXtYLODI5pdQMtzaXzf/DDWnlAuDWITZMG/Cr5/5U79xYa6wYbq2zwGJscsZb7IhoIhBDoNjK2s61F0XcMA8wShYRJIRlWglvOEdQHLyudkvT2/cTAleqdDXrdU/UBcKEwJGuNapqg9tnvuUAeIk2BApCrMSoKTF+KSbXxmToxXeejW+5IQlwJFB+HVCjhpmi+Ocm1PYO7Q2sUTZp/7MkKe1j4M7HA7aidXMhUIrEJ6lUfG+oSQ3+P63uL0Wm+xucEwbxfEgEE8NEzXqb7SBuUG/hcsDXGJpxw2Yul/4BQQUIl95vFRRrTZyfeGFryzjgM6snf4F3cfgdHrTcUELEHRvuB5W7GmZWwv78KSHlQo2APfRS+gK9uooEmGpSZ8ZHlghUqKSHnhKTV0PdnXwFQLayRdM3+mqYWa3EpNvpdoMzlnvKEHtU1qNA3i4VuetgrT3kySKtDpLoQxfFGzaTtBKnv/S2WP7QOZaCAq9SSo3/iAEC4soX/WKtffMZj/TrTwqBNMNrcTrw7tuQtVIMkQOImoXuBWPMEv/yJX2tZE12vcy+r7okugDujWISnDo3B8gi7l0Z/As+isNZrKDnvjexfPAgOc/e7NtSS8zdmK3D6uLFDR6rbJj42/tvp77mLESrh66bpPrnoWp7lxl4LiX2+pdeDrOY4K78qCCKZRduQOKhHzDrPUdA3A2oWV1eYpOEGosNJhgH6czjC9ota2Xxt/nJ6QYqD79EWiPjYPJBs6pkFzq+uXBYuV0pckK5BC4wvaos8HS47vPnyByk0hiv05bTBgLGJHtHqJVXBqwQKQfw4DvxNfOEuF1yyu40i9nvpkV+YcyaIDAYyvl3l/KOPiR7dCNpZqmMa+um/yir162uXgGbI6C3PQve09nucfYVp3SK4JmDgBNOXBWB/wv4Zk+mrA8jEbnlZKT1bkGJBZG49dpGD+acW8ZoGLfgdTO/aVGTOr67aHiXuPNqgX0ZajmWU043Rnot/8PLYHMeyh4Bca6aeU7eqrU6MGGK0fI8VTlIc31YvaKwu2FtFwe/lkRnKJ94GCisa91546RCC/7wgWcQkj5uF/WYq7mUdjn+nTCDrPz0HUW/u2x3e7RWyzAq2oxqoAucSDI8utd3Wp9oyaNmJgzBUGhtzQC+Icvl6xYiMWbcSnc+l3R8qjczFxXsDFjd3k2mOYF3cfgcr0ZkiZvWxQM1C2iAGBJDsZNkD0m4EiJO9YBlxflfoJSDNsOYuEHUt/IqlQEIIWhKadQdwqO7LUtqa5i5QTUB/ffASDslvaToSpNvrkYOu9JCa8UFjQOgHuEa3vfpw8rtSnNJ/AYDS4DDWfkUY09u3xfH7epIw5JLAbbK+UV2OZehHULVtgAgnoJcTcXiDpm8bFlbz016hRZJ0XKGACvUxIMPPoaB/Y8a1VSkA3sxIJ8hiavybMUzd6CB7uJiy72GSIBobgYUReCGebA1+a+Qg4H5rcez5wzntzhptzBluJWg+NA3F9DOClOI7VbiMb7FwHBpW2OxZokS+pCBFzIZAM+UOPD3ALPLbA/eCbV9vYa60kHjF4T9M4DZR9hnFtH0k4QDR1LrZaxVyNmOMBzzzkIvxFW/gAZ8xjgd1ggaFBzJsHYzvkURHCTqHsygSMbV6+QCGYU389rCqUcNHTOAZyyIBf5pLRPiFR93SIt/SGiW89hYLgEmt/B1TeMdzhdfyQc19HSjNejQUS2iXGcyRpjxTwoczRl0W+b9LgsV1vsVrtiEqD11vdGxpNFIB5a+SUESur6xjpVDB5Sey2JVA1PY9MHSITiJhN67FvzwKoTQL0afuHLOIXRnd7AcR3H8EBfEvPajvZ4GXoHkUXmGhOFTcMEzEEzem87kxzwAvPvmdX9qHMNVDFRo4OvgPEuxYFDqn/Jnnfygy8sAR1gWwcD4EKH2uBwLb99eNcYP9GLfpzPNUdRBU5GgQGCJFkwJcYPO1p6tjOM8y5RtvS2zjbfHxXFMJUEM1A4hCse3reFEJ4/6HLBXMITI4VNR6BIilmH/lkpah+AMbdwTFl47kQ3/dbof6vHsouU+RmdlwjjQ8nCwRq230IbsY89gGid4HOiKWzKijt/r4PmXtHJNOAkur7HfmMlSexACoNDKQGoN0vdc/HeO7FXT10O38n+gTMqlBKz/3Q7TfIm8dOZ7jnA/Zobq6v+SsbdJ9t77Hz93qwr5HloDxX+zXJ+FffOb9QkyUTphK7trHye25RKfz/7MfaY+A+dxgzKBkwlNDZDZXf06zJJ+FEpJ2wEPTqxj8kukTeTGZ7BAI4bXcPhy64+fADTG6SxgE1WMlhbwUqpM3kx6z1wvJYTE7e1vB4nRE2CM637S41vWKTu8Rzh6P+zQ9nzROiuOHigZHwT+IggWlMYBnqhiWNKPL9ncObINLAxHeAlYWf1VZCF5hcMFpnHYCnhuRQPULrauARRKILNq5atHEVlNiYMVNEDV2qYtlD4k1E1PGIPd/8nAvsJDFbB47qX63cP+LJ/hJWjtfoe+TGgmDbx7iNX9hqverMfJZK9Ib4b9R5/Nh28GRRv5AhWxvZvnr+8d1HECR7k2WASHiYwlhxbZ8kS5JrfQCSVUkzQL8ua3j+ScWvizjGCpzo0AZc+oHLVXCJDd/8iFYKrabUbntN6i9ZbyH1Ek91nvVd2rONj+9icItU6FGoR6YpfSO8TqYnEmR5rCLjUlU5FLdYCvJRrAgik0MBVoI92fHs1zXnDOe80VzYmyN/82MuK88Af1lVYIt45d/7/T+D7B5sfgMfL/Z+9Wc3pWoaJDI7NKbelStbm0E30Am2kPC2jB9cc/WIVB9Q8ENI3gPw329nXXbIDR6IPRbSWdDODijRvyg+LEmFjz1IUMJJJUFOY7uqutkJn+j2FUojAx1lSDxxWCrv13Uu5nIDc8FUQXVd6r2qJJsYlT/lWYXRE3KAH5VvBwSaI01FGfvkk4iq4sM5PvbziYTOvynsN+V/9jlRzQDw73jJeNbiJx8gJkwYgqwNs+WM1xx2U3DEqzNXqfRcVWCgIAyzwpxksT865kroxdYG861qGs/pbHxTxaztmpWaYjvz+jiojJ099pNTmGwvVz54yl+IbQSVRrBqoI/+W0y9h5kYdyz8mgUk3J+QzDsEQY/wd4vY16BB0Cxj4Bz42p4CeSopmtO6VY7XgLU1uWumAK2uGH+hxUFgiRARCn3+4XnoAHrpmzZqVp1ergPGxTf10LH5YGCByahVt9dpW63wA2UGb7t9iKew1iNvuub1L6zuPXmRJ0bSZXuvYanOhgMUx090Ly4Z5Gbqcb20va4hUcdEHNMaee0hou20J04ZyI6OJvtRMj9YoJoIJBYBzcSjpHyAKORRf25Qf6b9wtCyACewdSsyz8AJOrOGslgZrKPssh1cwFHxb9gxxn07Uv0GGuGAVeRzkN7PdfPkDLdkC0lGSXY99zST5AwAglbZf29LVZwRzq8qNF68PiCwP9cdO4vI/eKFWsITV3yCIegx/m4y+2CJVDWCA/m/aaZmD9aKlqUZHFn7Gr9i9DXREWt4Zi+l9qbA5CAyRXjBKPQYiJ/A3f/mPwF1X5D5H6MQeArwxc6FFmVpitoIry/5kKCaRjKT/p0la6Jv/jv2sds2Z8ggmMhcyudXfYIv5TCgbnKdrCHAigOgPtZ2pgTpvPNLDz0Grc9r0HLRlsXgr9LSS7FfIA0M6VV/c7EO2RMlP77RTIhBw1erDPsS2TO++wh8Wm+SQLOtTRToA48SWit2lMgeEYA+pMtQOdExJh9EvQYN7fRtQm5oxCX1uKe4XhA0OLGv4wdYIJN+YP7gguI30G9u8pOXW5qyOQIZoiGUQ0MJlh5fJCjXK53NN+Vdvkec6IBBHQLuHjx/eBOJeTww59hChasv5AyIOBHffQTMjpumrtaA0c58oDCrGgzZ07MlOrbXq5XkGqTb5clcbMiL5vbeCNVOkToq8ov1/WXfdwN1UeGbYdc5l6wfe0Ddv1mnq8yLnRVAtS6p6bQ3coIdJG4ux8ExJzZg0AaAsw9Pv8/vdaEC+lGAzUz+BnCMOjg9XAAZMvoF/kyLsqudzjOQwsY6rVR1xxGfMGAfhjCEB1o8d/jVCBHbXtVYiFa4UT71WuFdUUYQ3mgHoxIVaj2GFKjaIKqCMf2VngmjTs/k+z6F6i5fC+YpxzSqhAlyYrpVQjbvT6XqO0e1Q3m7RW2zhT+31xeqDTGb0QHbwxUuaKetWmdxmGmtwn8Gk8f+FTOhI950RKjzCXjvl+guE+IG5cGeX9nzYpToYzs7I3JyqRgHUjW2s7PVvq3q8gKD+JXEKRBE+SwLj5DxHK3CtIMz0za5oK0lgJh5j1bDu9JnwgsWeyqoTVaXtLq9bwcMWwYzakCp2wpqD22NIc5XkKjLwIrm9h1NNAXq0PDW9h8Dkn/rRd3JGT2Pi1Whl/azYm/GOPHnPYFxpQeGRSxNKV2FOPjGcNDKQ81kQkKVy7+KB3PeGO8JnJeiuTmqqg2N59UOcB7exVSdEoPJqXoDY30pzYifCeM0pqIPKJk0Pkd8ZgeBBo9+gAVR9vW1MEpVnNHImzYfjuGDqb035Md1arw41M0gRrf865W3Opqbue2maSc3jfEkiMV3tdX3LLAqM/G+j+P7O0efGAPAsbggfODrBcwbuJ69MElz6dYuPVuvSkF2c96uq/l3f/rv5gSerOGmfAFTks11SnM809isochtc5qwH6mrBgpxUb4F8eFq26869DKIvA9i1YSnsnifM+VxoG5yoADc1cbrQDw1f8SjHWQYsWm3E4/fE9etXMhFTTjmuusokX1BcySAjjhWPifrffOthsSnnhhDRgTs4tbfrEqxy5ccUOxtFgeqgcc1JEqAMM8Own0ZbXDSP5KWXtpI6xYo4zwd3Tc+SLV/eunsXdb8/fzi8Ka6GFsCTjVH6qOjC9zskfDuI4iNvYlgwvphEWO1A7mrqcQwrVbSlhvktWuIFNjgrGPPGfAoh7wbNQ6w1wip9ZBdXMeePDkgRtQVxCE/9r2G+TSbNuzDNJqq6zl5f3H3EQgrb4oE4BmDGmhiLJWq2i56WyyaRkCpNPPO42Bo7sU/x+Kol+ggoXYg0BqECVh+Yta7bDmH/naL5mYvS5IIa6otlXwWTD708tRsNaWrQG3bG1TIX8qUTKkfMa8v8o1EwRG9zqfjPY/9lVTBJtDTvg7fa5/60c0HCyl4suLH5hTOVmjffhwYgRZ5eHcw9V4fSr5UJ5L1uEy8sJYEjNsp5y/kw+T6ky73byIIv3q7Wb3NsuXkCX3bhgZJXJ18LwsgqbJ93sFrWSzO+Pf2evfDjvJZVhErK6oO/Wry2dpeOBdhzrgWg1mtmAV4sVvb8K5MZJP9v0lVJ4Y3ivECN85+etv2IAmx5ngdElwdyNiA/2/fPgm0esfq6oBC2zZ+jnShgYo0QDDJfEG7zRlX+R3c+G8P3aVC3KBCDDnn4RF2a98Ig0xaXq6muR3eUZlj4bRPzFXDwrF7musEkgFXXxCxLHxOxnnWyCPE94Fl0dJEcqanz1x8F4SxjH7MtqMv9hVpKbarQJDG/Fuu73wgEyvQM4B3MSGtVunbRxWdSOZ4F9Sp1gS6xvyyiI/m8de++Xlw/KJ0xnbZrvnzkHtD/eFih4zrTIOkUM5Jt8BuqRipGujZ+yI6IAI4C9K09W9k6LG/Yh6tS7qNUUkPw/yj+eks2+0cLxQ92OHfzrz2xd1HsG3Jcc32miLuE7jvOtzd/j9suOP+POLhxZuit4l+gDDkUIBucH2QaYpHVpglmHjSoPLA5FIFMEcBX1Sp2YskjwXsCAiM/oqFcb6MLmAX+VSkD0jaXUHLTeGKPd986fpA7p66NtqikfGOv7fHqAe2MH1alFHAKWulbe0fSeAjyXyol/HkNQemmBCx4Rtai86NHFXvU98Z330EWMJN4adVtxxaLHmKi/E40QuTzo/rQEvXCdG0Im1IJwosen/wSA8a6EdDYzbfyO0D41sXO72JnSJeue42dGwWdi7oPde1282urSTGWj/Qbnq0hhsEBvu/WmNxR7HGU5gCWiSE8FZetu+dWAOCqApiaduD1yyuW6BjC1RvMWfCIVi8fxS58MitUJDRe9lcDPsc21eh23/5ycUAQ+SLRLyacBTzr+2gVNxCxP3ziYIh8uLhNB+geLmUrVvUrAQqvpqhMsszZsYWImbzbJ76SEs4P8AtWA/p31lNRLZQpR+J+mNGmMcge5L2U0tyuISlkObn9tIf1n5497H54wWDH5a31u2MtSeMtp2gM98nansKRjwqVuDGHKlaIhGMK5rRoY6KFbUS3BpK+5WsNgdSInjuXFfWudPOoRTffAQiu5tquo79iSq4dFgexHStDurS3tnCGRq7q1ai3xN8RFCntn2Y+BrOSPMZifhczd/59qXxqU4SczhBzf1gqPHNR3Bk3FQqYkTIoxGaAmgS+THsyVq9Tm0oTeqS+lC7DvsynlR4+G1zVEMJY6B4jBwKfEeDs+21a+14Bvsb8fIH+jhte/Fd4As4huS8RpotyjXiCwUk94sjCBrPbsCTQC7misQdrMao9dDqsSdgXWTErpTypOH7eESEX3h4h64DwcNLmuFK0Gf5mWMx8CXxZRftcsHL6k/TiRd3H364COjMiKSAQRsAX8Qe7mQJZFJgvweya+eFzgMKEq3qtEWylJY5jibJ1TUFKihHM/XNT2LVMuBrnAFr/XI9/vesHo/GdouuVlijidF3jaEJd6bPPqvCBceysb05Cw3ca908vpxG+XqlXo7UzlEWkE+r+0Qsl0dkvElYnNasZ2EldmZe0kvj2EHeb9sYCmwl9nUcE13ER3sHxo4NDzS8keQ3iP3yaZXv61VcJgwzsy+EGkm1YSeuYtAmACTAYxq7wJ6Zl8f/4Hm2+yoYG22ncpcT7NGHQ4qNw8d5myHmcb5ucL7s26/dYiK28doymjRF80HnOVfZfpfW47SN8l+YyW0pjqvnCdQ/AZ3MJ58dZiD8cNlbonHiUMmqxxMY/eLuI7CivckYnHYu4KFgWFivovEfSBLWGmI7x1jQeg1tUWBJ5EFwCJS+Bfklr0dMwoh5GCXK+wn0H6COeGSQG6wP/C5do5LekkZecKm0epTEB2tsIJXeAiNsWHP/I7Nl9qmBoimQPwU8E5+V8gTQbbtlOs1iErydiqmcBR/dewQxqDexNUjggNog03kCGfkSnGW/XQOaBzjLGsR54K+O82gS/rL2ZfOcQtAtwOg8SE/XbSlh6TGRcXKP/iHfyBdHp3CLn7LPQT7n0W+Ed4WkTHvFEL9CUKPmU9pjZTF4CpQeiY8CMpdrvh2JPXxliKsjUVEPieLFwaqt3/yTMfNW5qJDU76pjbJSwP56UBMnr0IQHKy8B4qAjJ21IZSMAoL/4uDpuMMcIj2Xr/4K006caJRP0OM8vtu9eW2pbWOLYlvPtngDulZsRaq4yHn3pujwgIazFKlpG79FzPeIKR+w6Xzu3fOhJ2kVgM/wta4QLZzFHt/dEdkTERFfFIYe6Azl9UQ4HqJlrNYUNujhTCHA8wIO8uRvjlZuvwQZDw/ITtokvSc7zhZB15Y9ZZGFUuXJjgvvSnYOUjdaiQLYJiUJEhOkRLYDN7Ye9lT6/nQeuhojmjECGrHvomk9xjldxwTOyJnzbxjlX8AzdxJ1YxJlhStNO+04GdZ48qTCJmjV2NTAbvSdoUUw3dZT3cN0ePbwE/tcuoB6F425/KHY+8RvFxC6mYNny2zpywD5ubaDCnwxlnRcyw4nrmy007akNr8zwb6Yfx2wpQNudQA2+dDUB6a0Hs3nBqHHfgUGhxQ8f1v9ZP80tBMgS+MyaAyscXAy43XSTDejQXglbAtkcCGHyCEcfUKP6vG7bvG47M+XGB0NKa0nmGJiZag7hahZXqAXYiFhdMnrU53NC/1qpHd9wR/z+Gbvi/U8ft9Nfp91VKgZcd1K9KJyBHiPfQyOzQYGTUn7Ob2Krfab7GURPyJTnUDcF4sBI/6gzzd8b69zoX8mx2PcuOEGrHRSNScGDWCy8TLsELjNW9uLV3+Jx5axR+avWBcSqEhCWoFHQjjWsMh344PtOMfwXWd+EoJe3H0EdK2bwh/bcPOxeoU6SxAWKu0xiLSxpr80pkMsw+IwAVMt8c6+Y0FQIB+KfWQ939lnDzO0l9tb1PYQnpHzu4sJ76qMv2jTwoJytj/5RBWLrG9O73UK+WiG7lo9xc5QAcXYpSSrILAPxvYmo1S88i9Uri01KrZ57rDJBuu1M6UN72JKSxPTiV4Sn8QekCLKwEexJ47RU0abzumtpqUVcukvTDftPUxKokIyuP0rHKLCHWKzRuOhbjQE9obGuI7yqBNoxka6+igfIgw4HACa4y4YJmxU0p6yZi75cOp5sLW0Zy4Z8/fduzNsjG63gQwwEA2G9AKPjPAJcbLHbLzJYITRSZt75ji6pDcQLdeLlRxqvZZT1+xy4fXgPoZiLw85h4Ri5lD8HDMnPablJ/hwfzPcbpLZ7Nvj8LPLJV21n4R01D/w0mAE7o7MRX4UX3z0OkBDnjmarvI30AkH/DmHa/d+hecW6nIFto+cs2o564D/qFt6ghselTqgJ6dj71ZwjKoktL+u9VB7fN5kxLMMOwGvcXjueFVTd9uwYD/FPf2Qv+ObEjzhLccACV5ttq+1tQVPds5PbmAVk4XNUAt3ZF+VERNmI4Jt1DIiq5E5CcB05irjl5NcuZTMAx1ROv1rOez3+O7DC0G/yRdsfWPJkMusbXNXQNSqJHYhNy0j7pDXKzSaF/OEG0J7NogbEgkj4qHDU9TlVMFKglWJ9Rpj/lr8bziCe6tZedvT9qS8A4KtuiuHwPb3BCDuuF916C79LnpZ/JfrzyQnN2VN8qNR3VCPJ/iLu6p3Kny9LhgUloW0uF3v2Ntm/3HY8VutV061401bXEug2D/IE856MltdRhJ3ZnZhru36ueht38S2xS0SftkczILzIM1DfPcRGAzc1EJkDIwKw6eoTlGYlLo4jKXhyQ/DIIkbOBVHtBi4XxNTnbWvuyKJQFPxItvKy8L6QF/v8aluEKcgT8auZOtsQkJOR37s1XVVXa4IXsIqRnRgynzpiV3QaCFWwwba2cBz3Gd2vdnWedDiDRDRHko5qFyfeqnhTWA73b6cek/EiRGlbAdDvTYst2T3F5CGfYZxBFu6GOfzjEsCncC21INNdkKdwWV89xHEYd9EbTA94w8CEAw9yJdgEgjP0b012jkXnVqt4Y8IsgFWsULvaJN8MCcCfzywCNeZRbnSzgWa2/PkVLdw0M8cV/QkloUduMcg+MXdR8BvvUlkTZM8fLvcVKiTEIMesIkZNJpGcqQn5dXmtmsvWZTAWAoZKCcj8qzLtf0EVuHx6G7x5XoHfExCBV6BZ3wNbI3ljAQC//bRaWD3QjBKKWS1PlLXI+1/5BUQ8PR8Wt/7PZ0Hr9/A0ZEA24W8jgIp8Rc1GCjGrj2sBAN1xzPYn9ah/cjqRdVfgUYkUJTE0L0H9L85rvem0DfjtGzf6dpu7ezqY7tw2Ge5LqHTpTZpFxnURdNeEuWtxVvb8NElpQYU1mDC7c/DP7HeHaztPqBazproUgrJ5U6K80pHc2ddsmywQqp0DM45WN77Gg740V4XWT/sxBIKrBt63XJlam5gX5tSY63c0JVQWYiK1lpHMcEaf3kOsFBBWiXA8Wwk4w1Ev55E+Bsf0HbzTrOHibYp/ySTvCHJ9ohgNwlfIKgXiTOt6M7zxFUsyAz09xXBt4qZgDu1FNMUf/bn5NxXcEeK74hn5vPSjoqhs5wkN7YSRrcfGbMSqRjiuw9/WHpT3IBWEL/3nAw/yBq5Yhuz/1mih8SMmW+GSFW0gLoMIX0+2gZX8xBpJF74M/1l5vQBGo1HjKHV78LgU2OJicOb5SLqdggVTkMlPpNdthVB7if/kbFaLPSJVEER58Yj6LyrRvaIfzcJftjeukCUugtUqIJBW+4qMLJ14BJtAI8ul+QmsPYEKPL1Sr0cqZ1DXqFHQ9zfHVOjCyuZDEI8Xnsc65xYL+4+AuPxm6SyWgvbaMT9gjyt/ogWeDAWRwtlnV6RSR7czEkjYYJcgi/a1yuuWcRNi2PVvRj2047bcyO+gmGhJJkVzqm7HY/vygYWkZG2ew/0E6VvFtEiEmgPqE9mOWqKQAfXiUgE+3hYsE9jKbgJ29fvPMtHPjawnoI3kPv6pA1Md61wS5xvpmWb4Y8nb2dAUQVeMLVKpFqVIw0Ibz4Crv9NTv8FdddOyKl5SxqwLyFFqO7knLKncAu83VT4njTCmhqdhvK2QA73QkvgaQ+e0pCa6ZxXGo9XDCGu6+lBEd/VHBJSj7aTFex7ih0PPciVqcbBYC0fJ8SQ5+Xb9IauvpHyxFOqaDxZsYkOakms6/nFmkSUQuEhZvshTcytoZnPQVR89+H5cd9kzFtdbM+AjPQCtxp8CvD1rd20L4+xkNUm7YRt2C9sm/0kClsFQEc8+oB173D0v/npphVk9i9OMqx+n3J9olxmQsOayqaZ6cksie9i+rpobofneDUqJsWbRF1tL+7B4ZBBIaAsU82ShcNZ7bT0YlJdjr2Tc+ZkC0nj9Aifi+A8D/7TdUQLYie0smnmoTj5d2nSLnJ+AyJHrIBasGE/DI8vJoZeFIfb5Wvk45zYQW2bu7kborNGLPKAcx5g8j6C/35J7xJlbhBlkKfTVdLbZnyxMGkYjmI2w5Ie9nhlez1b50zHCPwjdWUefoFUMhJWBiQcn7JzNnqcBwpXLYUjZVvCT4u1F3cfQdV5P+T1wuQsJl3bS6GjfEIsBe0sr1e8krwsg0tmqmXWECdqzVdNRSqrWMjr6H7P129tKnludhLhYd972PHxzUfw8W6KtzJiwxqvl3U0SpM50L3oY1cMKXgZqp7CKCXMquy8XOe6L5kLFHaxZMyTmL1f07t4+Q1kHGdil7kApoR8+0giXbuitwZu7miRYp9sOw7YT6OKL1BQBHKLEIl3YPsnbTRnksU6JCTcxexY6s+8mvDuIwgCvzmVtT0n7QAtePHpsGkcSqasDNQFcfIZm9rB3kgRAtVyrHTGrP60NpruetNgXc8dRScFwX2065cAqFBiAGIkCCc8x1p+Js/GdxVR1jElu0h4HTCyrTuiDCQkbGF5Eh29DrH1b1Q2RkFfoaY+MTeC8bASCywRGeTXyy/j+3fYhB478BYLEOx/sdqsV83SomXshp25eovw2lRiJhLB4QKtkS34WP0khftS6UhaHbEPfbbi+6++O2BkhA2Sf8c+COHSz9ngsBOqED4DLAsl4ub9VmwOZcOgeSvWA65xwEwOh5feqPPtCscDkRjJmKRhpW/KVVlY4ODrdW6XFVv2jRshQhbt/zKr8JmQmL/iGQes5BCf8tCs9+mjHh30Fu3zqqINYYxlr4roPokzhQ2t9D25wzwWRncyCLHqWShyLJD0BZWvyKYeOfUTdCqPHnWLBgUrhrU/YRKjEaJUfKyi672WdCIdBtKz9M8UBFBpRhlpZANNbci+8tla7wPMLmR8AxumqWfmi431uJVqVvDxx4L7ry0EBUzD4H1kve32tiifLVLMBfq6EIz2oOunDozjXwxrSC1PlBxe+ejAwrtq5Eu9MEWkHGEbTeGEsjPJ2klE8+DP6/FacHkPrqv3Cw9wT2PmCNJ0OVnZbL8CXlE7oH6lcP5zaJXHcLupDkOzaxvdUDu9tT/AxxIg0AH3336CVpcyfSntKvboddlXjfkKsyg1w83YeC7ziqgEUIQw1eZCRhb7Webh3Yd/UN10aV67KQWYqmfNkqBsY+QFB9JrX5/AITr/2FZzWsf5z2fa+cy86BT0z8zDFG/AHbCH43XAmQ3r+TO6eHH3EXBcbpKzMdrEl0dQwcgycQeZu2YETtEg1HrvdR3ut+3BCWUnWnxkCNZ93WeWR0z0yGjUNyY9D3+y0yHQcc3tCX1e9fim1GBIyIBpmy0vW5ftqQYDZR2H0FXR7F77zYtmar7fyit/Fp+L7lDXVQNjFo4jhOFltf+SfhYgcJhKWl+4V/e1nsG78d2HH497k1BoD6VYsQXWg22B7VD7SpMPC61NESfJ6wg/IL2ZbUI6XLiQahhRE//iMeIiBF0NxzPmwdb2/86fRSAMH+qyRaSJ7DzQ3Iu7j+Blln1osXePdS7n7YfZ53VAYccRNygRLzHeK7y95QOcCo8mcYMmYWVr19Y0ZqvEpBm8iLJEUDUsqzmjg8AXU9E9qQKU/hXLaQLxTcDA8PkahzpoG4VGVHDLpCHynNeJXn5x9xEYENykFNppgwSmi/mndcfJwuRvcvsEgnrB3fJw/gYSiZqohjmPzQUMqIYhNTHKSnKjlX5QRtmkplEEwNtmicn4kzIa3BVlFCWj/Qchxe3XEchAdYgzGtqcsfmOHp4Vwkgh6OTrih0RsnbBATI5LsLg4tdB33DqEHhoq+Q9ir+ewpjwrow0oThB2wiMQOYCMtK0egJHGYjfAFzWGUm4u7Gv3Hml9PF56NGEpMIyG4wBgCQLgVA/Gpp3SDUeKeze5K+E04jsimq7wlOSfskxdHP3L4nSAWAusSsSJWLjj7TdEchHevqYc+Zx1D4wsvd4NTd4NQMp10Mb75BWoxUMYrk52lYAi0/mKtopuSbtLvFPWAUzt+DVVc0GGtuAsePzez7QyHnMihsUigqLt65Gzsp20eQwcSgnxoWeg9QyWX+F+kGB80XMxkg95WutQs6GR/A4VIQMp9UvAD2F0GuF+eEmIkT3Hq5j/03U3x4CEA3wC7ASVcDYn5TUG+pd9KbWkmjMaj2m7R5J5AHsl5s8EHEWIo6Dx4n4DsPb388B8divN1muPY/JoI6usariNTtNr3QZdKp59LptcClTMnyN+kzd9HXCka44Itf6ZNw/C36nacMvhWNpUCWf6z24+QjS328O8QvU5TtSD2WwhvVgCSbiWTB6tv1ZbCl7IbHSmxK0EzfXr1fD/QgM8MCDb35Oe6dWlhJwzf7Lp/AN0p1HorvFlqtJz5nzhKwJMzp8yDyyBloZ4Wlf0rFfcPVQfMtE1O7XK5l8JKuPSHoup++PidFk21IZFMOuDdD4cTEKbgKO5ygFuevouex4qSIg2VIAMxlPAUmbiGJgDVI5FmjsxaBMQrw4r0O6huqRxz+FboLjI/g+gPtdesA3PycNswv1xR0Tj9+2Zf9a13sgO+OYL3T+mjhYYy0ROvOXqFoGXJ2SNIkw3MSZKDpoYvPyFcspAvFFiN97aP8HmFcel+pWdna5MGyBFme0uo4W03ZcDEc6ueNjHFWofXH70ND51OsErAda0UBZGtG0HE7Xu3RDjz94iydYrz0VhxgzaYiMAUbve4u2LvfQClF+owQQO9Hq+iZDwUgiHEmKI3qiT2f8ACjl4S3MtbRzQTTnDjBte6+A/3uRVWiXrbLTOc+kyktYzgDT/XpFqA/o9wGU4wM/PwyciDheIHNwR7MSY/0wcAruanYF+wR7HvZGwT84HdUreKDWUqE37/sIDhotz2Qpkgj6ckJHe6jWBiog+3FBf2iAWT5TwXs0mht8mYT0IT3tjNVFhAD9KpSWrOERLcnzzqo0bF1Li6DjMOlfsULO19PFFB2P0PMB3sXfTIobTAowXwi9dmBlOloGd/KkNqeWJqntYNoHzTPxb1BH8RWLZQJpjU/S8BkdHwhBcFmiN9mgtuQxsFMVee0UCjKDel6bDnMogQtyg8xCFrVoyuO1SsyVlEUEVJ+werQDYCLTTntQ8UuAth3SyYu7j2B6fpOtn/BRBi1VrG7bBwwQFzzgnZqcj68mdKe1gSZHJ23bpdqJLnDFBpE2IfB9cV1iPuE17xEobhEluuQKKG+5OX5tTVrT5oCzSpXuTpglH0meuFWoeSyRiyR1ET/D53N8oG33INUb4Kkt/Cn49WpVvIreOUHhqKGBF69PbRWPlVcz7W6+di2VSGsRKDMCuNbFdp9E6nkpcX7UPYiz4vLQiMObOtfySOwuMWmzI/qaG5MBcoF6HMHCde7mNQJJXbfMV+aaPknbI3XrutWaqMcYo2R74u/e9d+lYgO/hvJ4UKIUqFLuR8U8o/A54vHmxEVckb7CNhOXkTWlcRR06R2SKvwbSKnT8CrQlfkqNFez9o0PYp8p7WnZtDdx/Vzu/24x7afLgkc9MVa49gllXWUXuNrYVOA4Zg93FfFecR12oVNOevYcVbPGbX4wFnDHCN/8PKBndDk/ZFia/Fj4b4QrOEzRm4xQNJ9dxFL4ptYjcMAzwbRhsZXJOqcmNjlE8vAMtEWwcaRIcBEJNEImqs9cfX9q4dBnbtJkCthBffN7rv60kofMc5vG2UKV59BFV45LfQ/Ax/VaVxjpEGNyjkfmeYon5qRO4EKXSRiilD8h9dHNh2+UC/FERttZcRkWK2sTqjOwcSSNo7y2D9+EptjlaS2cfUk8I/CAjkzClVoEwoy/RBzf/By25C/U83i5Zq6/J9P/WtW6qOL9YIKFLb09ZUeez3bjs09/LW09ucBM44uiAtsmy96oMFCoX6HUwJclhHClB25+AonxkJV7IyiJpwoTk/fpJF1yRS/BkRuy5aR7DvTQERLjAzfvxyN43L+bHL9kNfr2Q7DCYr9dQMytel8qpVHtF00PqvRL+nvbCrLk2qFIMtBURtRCn4r4geB1hU2QeWq/MaypUt8eRDha1raIGklsUB+JDKG/GCmMuNcRUwFICOtZED/sF5U9+fM9LthpUJbYC0ciuBUO9fwA8d2HP1e5lUOVpQpoNH8mBRh9RC+sYBkiKf7kEgi+VOLA2L9vR2CXRxywjoOZjTvg+YTYEzDPBLkMQ8SrlWcaFHyBrMEGpQBtt54LNMlwifyy2tkKtz+e8RnEtoG/too4nSgoTxka6EgjlN5qKvsPNY4i61o/aVNWs14kxdi5lMgKtEW2jsfmi7sPv3W8qblJoCbqcrETT0o9ED9mYill1+14vtbR7iwE9VxUEuGQ7S8VQ5HAKJLB+7L58/0rVJz8htYtZRZjCwHH+v7x3Yf/AW9KmmwNX1mio17FSyfHzXYv5lRdWCabJ2LX50wtb+kS8mR1PdAMRRKjSDHlCqyeo8cJFhhAi1lkJprtwZ0QtPjuI0hyuB/6X0ah2Jq8/Kal3MAyQ7D6F6BTa/U1LMMfNThkX8RF4ZgsGlwIxwbwbRDP7oe5f6Bq8UCT+8FhCQtb7lRtv8iox+kPhG0N8jT2S1juyIdWLYNYAzYdkXzA1RpEcIwP3nxg+upQIu4Ho+xH261pa5fmYg2VaZmHtlaauipbOrZXdU4NyPOo5ZU+MlBThnQLj5zx/iTGoUTcoERAfbMfd4Ij8VamJTBV9Sv1XLUT2+VpG/3QZ6uQ33JU6wrkAjFdQLbwqRknBwgaNmaswmgeT5amhftxv7j7CLwWbtLnarrYSdpHhahYLFjOoPrE/BG0OvipiF2Bj8VKfDTSApYuR6y6iIUXxwZ5MUNvk4PdRGwAyUOij0aAucD/RexVDB0HG2MAzPbi6HiHJ17/I7y2Ur++BJ4joNoFtr8feuoXlXPIP0PQwK+q7p+tNd1CjXERNVP+At5vgVDgiyR1W0tVJNhRrp2sDXBwdQ6osj0m+4E0VvOJ9B7pPi4AvXLxkOKL9VSsXqz4If8dsOfhxIc3HwF38yZV3squLtdHKDj1cCGVgNf5JIPe6k1pznAdBErO6O1oL2cRhwz6iHEfuFAGrpXncLfamBNW+4O0+TFcaTrc47sPP4bwJlO8g9i/QMOGvlAFZoGKhaHXxIdnO0RurBss7cQSek5xHiICuc8399jpumxf2k5lFket/kRUwZ1VnwZnMgVYlvZc7vHdh7uCb6zgZfUtTz0Khzbj3+v44hbrVUvmk82DF8R/nz4hb/VIQLfYPpiMq5duJe+4ImiIiiC1ie1dmxeTd4uUEJDp2Vb/TOr11bCBejYkGbmcpPe1jg4D7ibTzd7MwR8FJc/aRLeFeascZGz738ARWUyDU3fAhseAyVNFRhrKmFrnU/GeZ1xrOsYufTX738ZT2hreFCU6X+qQQE7K7FRFia5wy1s8ay4Ywl1fr+AQ31QmFsxEAhtPkKNJh708CSMdO0Mxdv353HPbLRrG1RrSWKF9mPDhzceeoJQqcYk93rbaxpouWKMOxLgBIc6HmO6yHVyL41AYGMgIHdHh/kFSQebZIl16zp+SZqvVyQgCjqnqxYrMM7AJb0rNb0u1wSAOs107TsZR89v3IA/oolPaSPPlc/GVSSF1PmLaR/Mwzr+TcnwrRHyf4ZG4zJAbFJCWas4bgIL/0BeFpsOKsqwyCNnbrN/A2J30OiUkN9BvfMVCWF81G3BOfIYKv3eQknwTP0PPUvgxqzWU5cBV04qPTfOepaUdkrywRxV1iR2BDC9RtQiFc1G7b35K21DzPsDsRCg/NWtv6bI9DttNrhrcjniUDOovnnEWYyRxRez/tFWpjhAWXKFB1N8vYNCivfo67kj2/YIi51HqPtCNOvSeGzweO8NrFhSMcAk+T4zAgHTuNY2nvE1vLyATe1SxWGwGGi9fEBbzhjyW0QcCCz0K5k3VMob9g7LgjEZIZEv8xzGCheBojKXqzPYoBMNbjQc91XUwr0jLHCifwyQQJzfkiQxi3Iuv1sckjFIWwakNDYZ3RYhodjR0aqescykatiW6n6EHxATAevN0bN/+mkhHg+AXU2NXCfaXakwnQLaCDOaDmMpceX1mlbtg382s59RAlOd4xR4mf31MUq2buXQZ2UvcjCd34FK0zhM4QbwcsJ59irQPJLqg4/snkzctZEyhrckFbjk0o5x8fpFcarViJkBZIZXTaBH9I04p/Ra2oA5v1eW+BkzZcBDpjS11MrkcpBscJGvpkQbFTh16CVKT4OIBX0Z9pzYr99NOm4u1x2e23YwdmvS3KCkQMEXkJp8K9T745ZJwbrBtrAQD81XPrMuvDKISq+uLHiVsCMgbBepex1wbKaPLWyhC8wVrIbvH4wL9iUsGoRhMRPvvSFJhH+nYRcR3H0FkwE10ACQEQHMNG0ndCRkNRpVW6QM1WCj+kkYcDe38RXF/Z7NU6kvUIEQZ4nxpL4/6EzC+xzi8RS3EoSpcevYqgR8VjxAuibNiJXR/KiSxrJIoiqAVi60fCjAjwWZEaXQZkJ/IZHDotjd5tdl+fOJdFaqYnfu8iA+Mqeu2/a0dJAmdM7dA/AndhK993dWlRTK2mM7rsH/fJyw5DKRbVKPMIThEcHW2XVXC54EPUM28vb9tXweGXw63oXc9s1CUFYm4IoaTS4j6BPTtgNm3MqE7JxjMtH+meMOwbkA10dEto8PjZWxlGcugg1I8duRWpM0JlDyBh7IHqx9aNqxFiO6CaspuOcM3Sazs8OYjGODeJGt3jCgarUvgqL1J1ti4J8CvbY0itx6wqSELQbUBcne3E1uD3YjEHZG+I4sV35LlXbmRx9y5xdCxbv3asy+rF5KmX0C47RSf+1Wtkv4lfoOapAhFeszIX6/kSYGaKeIF+TyiHw5JZKHasTXpZmxfCHzJp0VScFfzIswpLpLmrJiC7bnGZUg3xGCIYTh9ndBvp2D23A1iJwRPzOMof3TZdnxoM0DoyziYftY3U84Izf4VSQcb36Rd34R3H0Hi580W39YGI68KDIZ61oFeiffRobeAj9BlvYoRAjLyhorbBJZ3fTmhCAYa3vwD18FzFEqeYQFfyq8Z6b/X5C6kewO7zVbvNiFQl4o6imEqqBKqa21P0OmEFYC9um2YvFUi3IFWJxD2BGixhyy/X9e6CP4NqL5BtsKvN+T1ReHTQFuph1XsG7GVbBgylbbbtQQPqh0N5imzAh1XRA7wqQTvO9l7xOqbBGo7iEgygiNd2Z01iD5og+Zm3wAV4nWk3cOR90sWvL1eY1cjrkQpUjTFtG2P5n1g/zaVF2nPtfAJY1J53HFe3H0E7gY3ExlApaR7DYQuNUkvZMc/HMnwjbZPl+bfKAuQc7+Ey9va3hEOEU0gohVEkQ9uQsQTEplLEdGXytbGre1AItHNR5B3eZMOUDvzMxiXCPNdwfUD4+HB0XgG/J6KAi+ZAj3hT4g02AY07+sVTSCiFXg0hG9+TttjGeSWOHRbP4MMbJe8yF+68LLqK87n4CW8yTBZepM0xT4vDhUUJrvQUs2vbbC/UyZcJCEc3b+a9PtM2QhnxXCQRnF5EGv7OW1DWcJBYsNkit+0LtBq96YX3n24IxVGboE3zCYanfq2/Fl02aa9W8ngQ2dpfhGixXRf/rVtLDy3I96rT5INpzXebOdUNhDv0OsJAg1t54hC2ZVNfFeIkP3D1EXBgrL22ndlk7D8CNhj05tPV2YPrXKdKUOJVqTo8hRgWjtWbsKmk/hh4x79kQPeG5LfDxI9Ov6awA+URFQLXFagTUp8UejbGqYLL1geV811T4GsoNmCA1ezECgcApc1b1p/OhmMN0nhGlDxaH3bE9mtTHz3EfQaN9m9AKppw4haDmN19hTgQkBNwOsYoG3LftCOrNmQwNT2OYmFY9pvQBOOBKm+fvUDMKCH7NHhFv1203MHR+jarrX2+xPrxPtbGJ/Ey/Z/mJJyg+3/UDkLkSDTV2+GoKEHMZ4KB/FuDB6zGpzEDnt914H9X9x9BIzkm8xja3e41JbO2i0qG9AqEwRCvTN729dBR60YM6HeAV1Bk5tQnBaJ2ULGs0eQ/gGqsIzBz8w5JYYk6weoEtx9uIa0N2VYFT58mYnHV1vXkT9Z1YVhv3VW1qxqm8K5ZpWc1TezUR6lxR2JswIplyP8+ubHs8MNKUWDZtf5l1DnHVG1x9u5xc+xPqpo3GQfdPXjVg8jZpTk9HSaMx+VdAECutFN+Ph/vdJgR5rtmBbk0YgOu88aCdo3z5bkfmXd8JPU+eLuI2Cd3uT9FYIc2G6QZb95eaALwhqD18HRFMMNmFtheTOZq1PlExPSAX324AujSM9Y8rz4tIbHmw32FwlU+cxrw3uPYDu+KWYAJoOaDF2FFV8iqE54tjZU/0wLhCXzSWhptto5rgaXjbml3y9kDoEqIhR5eJqQD+A0Te9G2Y052Rg3BNeoxbIqPsQisbaDzhnp1ZVFnO2mre6gzEtQForgel37oifDDjTbnsDbLlsZYIXObontVxnjV0X774iiB40yMds26LHhqQqrWpYxqNsynZnh3ou+mNQAvIQp7x+pdw3ofWlDpIMIQVcPov2Tx8aBLOQYGsVhInjC2NxbjyBN5SZiZYdoBf0IQSz2fTYyBXHihIvbJWmB9uaGtgot7wayWtZ7EQJZEfAVZWu7Udzvcxn/Zife4iFKwksYpl4bZ0Cs84KxhbAXOLlqhoodu9fNZrRvOKtmrpF2M9J6+qkQHlfyE9wgj+tzi9NTbRMa4k9aJ9uOzhtDmg0ZjWNEjut2FNXNDap5m5SFqvNIpB5EQvjMo/c9rd2G9GYwSt0G8pjvc2hJZj0SQ2lku+hbxIkxPhK41oN/3YftAC8I/r4YIGh1/cb4E0ish6zeQlAT+Mt6MEkMAQmhKzMTAa7Z/7j+6KY9/XUExPrA7ZOF3+cl7+mCCgI8+/ZcyC/uPvzIw5vkfEwY7QMC1Gxr8yoz6ogK3AvvHgImNGpC39htRyWtfl7pGKo7lP2A3++pAb758ZDUAVoqioohm+cnqoh/k+Us3gPMCpnXt0HF6KaSN9BDDAJ8CI8QDRtTAKtcrNjsTdqYE6CJOD9bQx0n2LrSITWhwAOmaLutnXD1JG944ttIqhvQqODMvqAeIV65xq8MRft9kuZJ17U14hVhPFt7EN59+K8iQygqkkMk8IbXnIKOvBldOBSLZmi+siF8zb094QMtuMcCusH3gUZlbyBglfLoxXw5b+dk2DTVHfoGmsrQ39q67nnjIq4QL5DtBQQjh4v0/tN2Iz1vAm2orDDoyBir6amibm3QcGJp4EPI1qMCCqmTnw7l89R0KkbfIrTOQ/d03SrySttyJCSXX+607+BKDgPqBtXJ+r3c2x68Dk1XGtmbQw+8W9vBGqk1Wr4mgVDFmh3hR4HmNFCo+uQqn4n1ZNwXMSGsBLj2MTzRuGzKfXhXeRPdiklMhDIwGNiM7rwJ65n75tbbOXc9x51/azO+Qy3EK+2Ez+mPJvcX3GuhP+M8JKfyi7hsnQtJm7AypS8AHOJOcOiLu7LJsMUrS90iDu/cqgM7dRutc3lCXEf74M+Bfe+tWJwSiVmiH5hCLNb9F6C11H/Omd+w5fboT7doTlaaNkF5BfNxQYIYxFi1k3kdBZXGrSDyjMrtH+DBrDLs8mVJoYYp4Fb5VKwPzNg9WPwGLG77Oekr6L5tP1ybRg7zqSrAxW4PtqEYTCPyWZtEw9xsJ4V4JPeIEu9D7j4+/+RJzkVeRG6oBfDVrEk8temLu0JWihUk9niBA2Mk1vaitz242tsCbwpbsfOAHy65w3VUfeG/6uqXHLWTLl+wgS34gFiV8zP8OI/xdpPZVhWKYJeRSrQtt7SqtyQOPOymWD2YeFj7ognksK+8FYWBAjEQLL7g03n8uw8ccx4jgl61tva522OuZD/K2pIf24D59tpl0OCvLRACw29DUBkvMv86kCT5+qWQbOFRMw6BwH5BwQeAaJkfZcdz33yhF3cfgX3HTWIB9BQ4iDpM5MbY6QsFkcvIiMDg07qbDTIiDxAZeiIcJNvmtKOFhIOIoBDFNbjpDu8y5BzG201mm30fJHFxnDLgovsl9ZDVW3RvgHssij+NZdCJkubPAYl95vlSzBSKnyJGnc/A+0C2kMfdvCnf6Q1ECUhNuv3VpnQ2vH4IRLB6HXQEqXc6fQx0FRULL/qSnkD/Exi2e+7uz8qGOAco5VelP0CdsAo9lU149xFEQtycRBZr6yEeafBwubYZY0NHAv8qTigHXEsUFYEKti1MSBpGTXU+R4vuhDIaaMZx0l789Pshiu7Y+GY07SXDpgIl0dSmC9SgcmPWmKo0Ph2iACld+kfAQUg7O9dTufiSmGAk7Y6v39/jPSrADcz/Au9THdiEr/oWEhWryTaiYHu5MK0JusVse1SWa0s7JcEVNAXyp5Bl4HESDoo2p+jdOP84WkODf6xKX9x9BDjXTXa0/c4zycbCHqH0QSB6gcOEBwC0CaQvsaAbA7Fw7IFNnXE07us+azpiWce2Gp4Nx3nyC8Ja2r/W3a41+F7rwYc3H0Gy4U1SVrIOhy3LoNpGXHQ8FXtRwd1EQhqM0/fltRp78usiiW8dSxefUxZx0DzOGq4TqWNGLpomOxx/e1P/88J3uRA3SA+I+WhzbwNFoBJo+aA/qrix9kJ8bMRg2B64l37CMltfsTAskJGFPAuPlfEJS3qP73mT7wltURPlwb7BtvlB62Z9Lsnr+JO6rQ5Qa2PcWPj3Y/u9hBKZSFITsEl98ukn1KgYqyXb1HVgW0s6N08MrtC2YDA0s61onoy7vwa64Rg1HLoGSldHF6tuZthGYJ+Eqt2Z60dWvIsH34B+IfRigY66He6gX1Td2TtbWtu4yFAYEDR6MJ7Jej/apowHmkBfQBiBzR4w/QnCiEcAucX02D03Ck6rwbfWDFtR5k6MApUF4L4+7e1cur6wTbzWxEUauohh4hJSnmzYOtifMpt6M15R8W46bHj3EeQ93ZzhQtKxCbHWvwtHqdhyF3ZcTE0nmDRfGuIiAQkfD1PWK4u7GA53/UmwMzb+5ie0l6ITDoDNRBOadYJSOyy9sJvVTO8jgLDHAC6++QiI2jf93OwR4IlhqGPPnfszyCwYHYG8iGFKk9IMlxcgVhFueq7nyA6YNQERJ3SLc83lPmFp7AHjNwFw+69wzAqiPkAz+UNUvAU4OLi12+q8TvQRsmu7/p2GFdG/XkijIiVVjLt7OP0HsHQXG7+FgV8pqZO1n3CkIzSEZ2jR97E2TBqtSxP3pstzHh+nSA4ZqCdD3N2D6d/f7R2g6QbQNIQ509Ik7fkCW1R4cu693jY52jXaK2q/5txdQJOnWaQOCrREAYblI17vw68OoHoTObVtH/9pTGRq0fej2WDiuN2KLcR5P2POrMbBCB/V4NgpOZH+01eLxlitg+y+H7zgkVtvklit7KD/O66n3E6QAk5BvhcXT+tyrluboiWdKRUSnBAKhHw9UUid9am2zxNuJfnU2i7ZpGl59nLxTbregZ+BwRQEGaUVWjkDSyhYWASHOs+ur+8AxIpBoxhk8uUkAbLNie3iJB/G6FZQ9l+EmdH4cG2hrKo8SFoI7vc8vPvwJxH027DVmtjHXGBsbWEHAaOyIVRQJ1irIBGuTfK4aGR4aQoTqUMCLUk05fBGIn+UrJM7F47JSdit/+H+v7grLG4BFEI7bs34WhuTsHVqfwLWKdRl7VWh7Tq/BKLXQCDryGm1aAY1Wgybq0gK/vOlsV8QULd3GqMNlKsjHXrUi7uPYKxwUwhhrxYByEkNTt/ZVhNcAPz6oHgDpJVOYeHwquVosa+k/iXSR4R6iljr7WnDnxHoRad2t80w8QRL9XoWs/HdR5CBczPqFj0T2Hu1Q0yX5dPa0Lx21LBU76Kjn/u6lcoYZmKQeGjL4VQzmoJGQbp+8O4HMBmHTUAHa5rO6nJGcuvRl9pX4BuZreIqSZ4siDCG2aGqAPtWUroGAlhfLRsSFTxawyf86j0q903KNgrbvq9bo6dtntmtF7W1uA6zYZGz0aFTrkDqdy9Sq8X6kEhPElHFfWr5Bwo6D1C+gRxbVzX3qNYO3IvNtG1SGGllza37iSud2N1hQKFHDzrN9RUKwnz1WIxVe8j2U9h3oc1FtYaQD83esXtvYV94Vxs93IHxL6OHAMe87GySNjkvWmKcpbMluxix60P5wrXSVQ06GkNdBjkXFU8iB+CXZ5xVko3W5BN5SWxSLiJ4Wvbx3UewId/UGMBFlm7LgxkH+twMAhpwSZNSyXZOXQdb1VbvRQXabGXjL6FCIlJUxII4T0C3f4Fip6XI7hP/Dw8avIx94r24+whMlG5itJfVGACUGKXAI0KYqJ1roHMCZr0gmFIXj1KlU7IHnqSdIfU1dhthvXG0gxcF8QOPbHJisT2Gym073tdRAsR3H765302FFT1CJhRWKMk3DZa6L5Au7BkOKyL09TNw+GpvOwKkMIoSC9bXhQUisr8VZ2iAlqZOHb4fBRPSXyfdvwNyHth0A1ayhUlCaUHhZ1s/NzYYhl2Nm5JtZn2IBo9g76KguwxYrbGYiyQigaAkALJc1OtJrbQuSZa1OV9ikfFQ3tTK8O7DL9GZRFQbpvOcs9mDFy7DLY6WSBiz9dUvqazBC8IEh8M6FEx83SO+fMCuD8t/r1n4ACTjMUhuUEVggZc2Q9+ePcdV9t62tX06gTCt0bYQFXlaU8+22L+RXklfA6FsyE7xuCxPhlWqbMwzjSfBhi9Xeno4Rzcffr4dXvCOChQjIzbgEsrjeVqdjXoSwztAFm1fHo2bBIZotitrdwt49REL3+Hsf/OD5AXAb3JAWq9flHEKQfmF5iU1R8vrudLDuw9/7d7MRSgLHQ//w1cXscNt88PGOm7DXTp68F74b9H7NEqPFnmT/ljQ9GUOTlbfXtRM8W2I5RXQhk1WA9sLgjSmweEXUWUe66F8/VRMuvQomu9z6jyS3C0yXOMkmrPaVte247/giVjyscQbI53rnHkL1cE2KbpQKPeN5MERCc8n7X0AhoMawBqx3avZW9Gxy1XY+bacdq/WrUHbosqZkyyTMk6ASeyhwt61z13HX23n7EWSz0Ag6slJeRld49B+a3/RfgZz/DOrzKOJ3aKD5ZJI48WqJLdpC89AlRJIAQrzOoK0bvv4Uo4A/kvSbYc6uEA3F9LQfNrakz3fO5e2Pd8hdQQ86Q/DKr5LWxr7ETgSsXfAaqrdwCb5s2GTAROspOuZz/E31fw75HbHXPCInO/PQaGpsf8ZJyIqu7REaPvA6e5RKO6HhOL9zCjsOGOfDswN/q+6bD1f3ia6tkNxDMNlb91CLKrxBTgRN8NncrwPSNg/tgZm14AYUFmVbX1tPRcsBNB+wKhOqEFHR4u9wSoQ2F7sgSSFx3ZcdHoPbWuJSDwWSM0CHoP9Bih0GuALYO4/vXXfQt09FP0WWo5U3p0DsqraLQkR7SdUtKlVO23v/4H+MQbdPZD+T1me+ZE7CkdW4BcCxJ5leXT3EcQK3BxIIvsdk/bKlnH3ifA4lhQJg0r4yMsNC0JpuHFnjgbttF759aAyGmzGYeBeePhz9Joqpw32/0dmDYGUeiRf4c1HEPYFFgHkaBdRcHh+TDSGX4L6bbsjcQ3MBhB6874+U+lFuIkthHa9pB0EJAWP0/DNT2Nng3bNRaeWn1lyF4lR2KDt9+3bNy09CbLxXYmfsn2sS0w3kHy2rRhcq3GKU7MDC6j2clTkW0C9soxylUXR6QCd8VW3Uqj267f1xD934y4d6Abvx45gNUoA2ZI4NA1n0SL4lGHpqVFIg6lpqkUd2wIv/voKBXKBmi4iGnmspEMTbSiqUYt30i/sZ0TdecxW4ruPgONx0z3Ftj3MfDGig6el3kpQyoaal8nIyw0swONyTPafyIC1rW4dOqhPK41oqJE9i+vmco6vBFYE52qlK0AJte0+vsKbjyDu7CZ7tOE951TVlqFGQThQbUvGo0wsUIvWMOVIkz8iZG1ryzpCTmlEQfUoq7qeRi8gVIFLknL5OZB4yx3cYz7e5DjWod4oox/bWAEKzzqH/rrZU9hwO+Od6+ZVFgBjZbdYvjouUtPFzMq/eZgfABw8VsgN/octPbo5Yu5Sae5L9RlYu007Qap9ju0Oe4EYoMvWhKTrlTou0NKFlBOHn3JIY/YLaqyOXVIuBbZLH9ZYfPcRyHNu0snwbqC4GJg9ZuVrYD5sqx4m/nxvG4a4X2J8NWxhop9NVkMvaGYBKS02G/XMSZ8Va2oUMCLQimCafZJ5GrUXd3XSTfBlLzgm2H8tbYtoECEGtrCJQsye5UmCdxFw18s5FAcGUkJHeKjDr2OY1xlAVnr6Da7+c1yoO0RmLDIgGHoaXqS28JfGMAxT386pqS0YTQjwBagT0V+PqQokUIwE+pJ4Qu2Msw/IktFIAUYZhYzIytZQEEt07xGYAd0EXuwTo34FtFGOIAHRXrCTL4yqHlBynuvgrmOXg+sf9FR6CSI8JsBvwtAMP2TjA6WNh5LfgMOrFX+7tClLkeQNooU0u56uffqyBYoFbadCLW1l5fJCEhkIKGP83UPrFVjjwrw38FzbI0lLwGZsBYYkOfh647pECqowq/ui9MYqrWerbUtF0Ekg9gmkQT6C7MPN7w8RHabmTUqm7Z3Q+lAoboulithpBzDH6wzeUF/FHM4LHnVir9pnHuvrlYo3EP1GNFCXNfoJVq/H0r3Fxi3C31EdAOPTkHgAUL7235dU9ZvAd8A2g5k3CXh70Mdyzkj+GZCAfc7wB+QbHg/zpmjzwhF+Qb6RkLItcSVXI+JmcZIPfCZeBhx0gYc5UOFC7rEve1rOQPgZRnw4gSCHCjB7HhLm5EJvzwRV/96lX9x9BKzNm+xMYENZTBQUzv0oaOwvxpJpoe2fW5q18CZi8MUyNTVWQt8vZD6RLChmhXos0j8GDIVAUIevLw/gksoTL4rvPoKYhZsjD6vZJ89W5m/neUYkQHI4gqFp5ZbWomttmTEOlUfM7OPlyCYa8URJk24w5fsnlQt53oA87fgaewMHxY9zfPCRc8vMtbwUgLhtfcdSNwJEwXquusVprsIt0MMFcKoPvh7eo+2lZPlY6bgIe1/Narc9fXlx9xH0yTf5kGDYZ8kjmVarPnngp1xSZdr/NMe5jBwl7G443+yI1PAtoklGrMpI3OmLQZ+73hzsNeBoSn9X+Aivw4GK74oDZb88xhLjov98PhSoiUHyhT0Iu/ZmpTpT5/9j7d2SHceVJdF/jkIjOEa8wTktzv+3wz0A5srOcG2zku7H7Trk2lWSCAIR/goJ9r6BhkNDXGCfW6X6ieHX3FG31esbQc+RkO+mYM9KeQ5snuSQhiMkE4TwSfoKCiWAKHvcBNDVtlJZMY4hr+0qFMML7bzUCca6wgd2xTxNIqtnnz6eZrTnpdd3D5DQ1mwXlFZU61yV7RhjF1HMEXYF/N1WsNq/LJNkdd6QQJF2XlHwAyUD5SOZO1ROf/Vj/zkMMuywbrRS1qTkNaG+1OyNF2WYGOFNth7vtmteAIN2zEnFX6ONu9Z4glAJL3TzsnuLer3Pd/qQ9r3B72IsZPMD4CzWQJOxRXJjndM/BvqTvAYnQgjSVwdjS5wPVzg7hQ9UU8oRAf0N4igi/G8n9gt8U17z27IZj50ycVNj0Q840wklnBgYM8+/t/f3bO/tncoOqgUFkQDh0/DbWOxxu6yjJI45ZfD8VYcX4AUNyMVKG2gIKIV13erhstBCOwsuJ8Sly0+5ApWcJBKffKHGCYjfGwwvkMjpr+V1QgP8oo0MGti8Glpr93gY4WC65livif2UyWOzhM1NmOIEqRwR0N+YZBFUIDf1vwMFbed15Ch4XzMxYB21Na93FCNjXR+2EC83dljFtFz5UhcsdMTSCBIbRz7NdY8+3X14EZXK+hTw1XuPBUgRNez61BdeUF5HxlglOAGVs73yXvZJM4AyDyhVdKyi/oZVNZK73JS15MmxeXwrrSgb207aMDewepqCrQSiYUBGMkQg/rbWPue5Xamht1U4YbWYJhLfPEXO8Bl81U6r4mf5PNNDLsu7h5gpdZN1Lmg/nHU+y3TMCjwvovcvL3+g21/sMjpObF7khSHsru/ZaMVeR2z3Dz/nBK1Vqdaxz9//Gkb833UigfLjpvJj2vOx1dohfS3LXH8C4ujQj3ZkY6zZO7hsLxGw804mbtEQwuYqTLFKVhJpUL7h4sOCqFbNQWt+2n7v1T34bSvDSoPm3Wq6qz1seNR8RIkZb+I1IovgP25Cv5itWbQlhH0VNra/vYtWnWBjty6EPjVULY+lRd894jSsm1A8MpAYntWZ9+jiACTdXQnfD38CKNahdUyNA7hO5P6y1sAXu4LoBaL/ZhpAND3gC4h7IA+4oQOo1G44XgHtBvFvW7PVY/lLIqZAXqyhg6UomaXwLCzfleNN+ONi5UEsU3DAPaQ574O5EO3sXoi03LzYGgjrQ0gMdfXz9EMag1JO39NAM52sdqRlSxi8FIMa862P/qmM6qQX5BLcg0t7uDF994i7q5vj3BDWMqjhtka2O9sF9i/hh4Mqe9aaqQCBkhhDYi+KfKzaOFlLKxODsDyIzi3u8z4fqBexJjfoEeQ58ipMXNPfvUlLMUNc8OFs8yFqMoHFTXcO8JgZ5Z1rRXhcJCMT8TeP8a5cPvnaTkv/jvaCt2einrxLxepEKTEp/kDbee29+bQPZ58aofxnX0CKImvDbFbp0hOevsgC6PhF64lAHP6XqKd+k+DNFkHl0XsBssWml9ozHFzfPeIhWDetGlYWIpoHoFPb5CTkiGgiBhhpewzF68gMpuhEgh9+knFu70Vo4IjdHoE15IefDnnYtkFM7Mz9/D041t4w+w+w5EagLp5uwmQH/9pv7h7CDXdTbZCwOePsgKUkeRAf1AlWHTOPceCXhBbm5WIG205ROyTm1XOK+TuphJJWqKTUOFn1yZJIl29gD93f7Efc+5y+e8Q71+2DPyaYCPz2GFrJ9zoE5yQipvAzYXiRu2K0h/7xGTq2wgFlLLYGklYen6G6e4TxpDfdh1atgcMFeI7xtl5UYvnjeaM0SqmskViZ5RzqHEzBqiW7gUh4EmMHY+R39MtnT4DGB7wS8NP8euIJspIX+bnEPF+kCGyN35u7h5g3cJNuskI4TR9eWADvbnoHCATtFMMJtK287S76Ig2FUcCbPoppKEFbyWni8fTxrXK0rZrW0QnYgjpG23t2Ofrm7hErkm6KH+2/fUJyMTBaJOWtNRyj4c1h/kNZ2Ahe3Apm1me+2Tr3CEcpiVQSSh2rFcVwfaEcDTQdNzQdMGRzlHfCeumEnBC5XOkKphaIKkBenRgi5FwbPAUkYpRHUTgaRYJ2LC75hrwx0Cve1CXaMU5A0cpzO3uecP4C/s/je4CIOrhysfVI3flkjIhse25W5FpTLjcth4zlk5+LSP5Rhdyu/qiN7x7QzjZ9Fj1tYoA7Fw4Df8XOcEfkafXrA2MDXu9ca8LlJkUnsUjl0fV2pC8hhYm1MQv29Mgo9N0jnKF0U++bbLc/vZ6yduB8JLZIkQXcROuKHR8+n6lyChpzErBXz5T29VgJHOuGI5UxrkPnN5kkd7JMm39laXSq7k8+xbncVo+s+81dDitinnp3FCefVoX7sKILcQwXrVX2kc5nVPe/0v8fJbZ/p82PnF6KssPcKlsSF31bSBo5f2un/qsNL1AD3VT9lGu9eSdEeQ79w0QLeQBf4JGKI/+JOR0EwQn9WzX4zIqLLHvK4vdGahRJk77AqoEtp8IWm/RF6fANQyaYtNWEwf+Ph464y1rP7Bu9LeCTuxTSfAphykJkpXCFKJem8HRGDlC7XDwP2dWdDdE5zz4fiznug8kUaXa/DN9TXrnEFRns3m5a+/h436xkdoqPCsHEtzv22iljntSJRKqSx3fDswVALVJzveKe5cmplneZ7jastfK86AkofizX5InTyPOiMW46bxgvbhTjhBbp0lGmnngnwKg9K8a6m3SQ1/27Nv2IDY3YzdtZTHqheHhVQsTL/taxmpcaL7dFhirXnSJDY/L0gbnHSf4S/1nq1GzLqvvQfXPXZ8nAU9WJOqfO7Kx7wQEcQI3iKK0sfI6Bwb+mvxC7Youq7MugeWy19cyMgbJDmUP7pDBbCpEMtmzAjPiA1zl/yzgyilcm1RSOocDp0vozz1XfPUS02M2BCTDBAZsELjr20CsAvbYa8bICGbUV6IelXbeSjUk7COFCUKF3HzFGLCFlMY8hHt+w+b2rF68mS6dEC8L0shMq5c1DiBFvFx3CpOuqHLgtXaPYoLj2jGRC6GNZaSg99RoUKEmeKy1cOG+ET0cpHWNl5BcOnkigcUOJURGl5dB2Ppc1uzm3teJYMOyQL3ejkB7lvI/LOx2mF147YcwTqd6xUuTzdMoQDr05MhnVqSO7gI92Ws+A5t7zNpq3z5NzYQaKQPztPK+37gvh1RBAawzLfv7AQ2HCDQVCt9eYrRx03vPkOoU5aPiIm4Il8QTt2sZeT/8qucxJ+FsZrYQtS2geYoXEhhIu7tdQ5o3E/gkb8o42eXP3EN3+fbh3ieQOeA6rsp1/HZx4wOEHiJuzvWgFS2Jgo9XEiT5H21KmU1tK16lkoNpeGdkxnwdPABC2OJLgJ/+XeRPZ+u4Rx6HfxJisPm5rXU6r/3x7rgBZG0chojey89IbK4Thw20wF/ZU2nyLPUmsSs/SjGZvfs6WRJTXDW7Liiv4XLjCod9ZrhFQcdgXM6f5VLeNcBI3MzswqxV1+HhJ+4rwukg2LeLePnfNAdWAkawhOmnau7rqGuADhFKxBdU93S4km8PM2DcJs6EbL/Du+WVbmfDnXIwNmO13R/XBSNBwzguABGulYclNnkYyru3PPznREFUQutpaN+ZJVRyzpBO4vrzyBqXOQ+hCQh3JDz+P/RgQF6AntzKo/xYwfKDWi9R3N1V2eLs2KAYGY2fpW1t2rkplZBZsPs3MWvGyQK6WQc6/3rh3lNlHi/siMeAmjOyQ4dBH62wgEbLftp74Tk4Y6buHsPfdJJIGZjtVxi3alx3LPogwqYaqG9cvP5Sd6LHyAekGIJ5QeLpbRRJMipBScY5x/OPn0euR3PymrDxhmXVeB4+90E9ADAmua1yH/d3TXC4gb61mr3itWqyevSZdPMr1o+Xskfz9G9K1SIp2u+SsAbnldXtv5zOv0l7fM22Y19EPjrFESeuC0ithnsdLmveU00/I3GJV3Beog0icckOcYgcA47JxCtruRJCkgcHiCC5cblbk8rBHR4ecuboKvVZ5VMVWU2FLFbqXUCTzDRNeICm76c0D7XPRm2claF0zC9FkJWBp4GptRfihBPFhQ6mGy1akTE98UZY9YfATYxmiGQ7fyF8P6s+b6t2Cvfbi9dwvb1JAbPVR+prqhnzfJUhl6i1nnjB4tT9q3FDVq1TA2rYUuZy+kcIdCW9vCmytWk/dc+AHHcL8QggP91k4+EewKZ6SDTFDQcvGuGCrK5ZJR5l3lNlHC3sjIfDOhoAkjo8YSxhrOwPTXNv9m7uHEDDcZCdPvCCV1y9rJJ0jGKxDsWuyBaqn2xbAfp7DdvyLcQ+ITnYhhCRXYy5WZUmEyRN7AZw10Wpj58TJEef2zoG29QWg7x5ihd5UcCPh8/QV2u0w9mMKacM4p9f1kutSarOYgXyTOnU77tbsEKXsVkpwrWuPdPBf8CcE/O8NotdKE5rF0LGM5AAKFLQYYuDnQC5LLw1RixW1bcEO1qqVhaGHhk1h75TccsREP4xh9owj+4SZMvyKtP4nCkjePURA2U1gk4Lei5MU7FBem1PrBEI7RybwYfhlnOcnkYAGZGr0DWvGcKeCR/Wkhn/nOvyZO4HkkRPpFOxj2D/toRPhLabUAmLF14NCPCFuxFNqK4YeeAOCUUYuToyYRUnmKepPePuE2Kj5PLlCyftAYff7O4PyXcG7c5ErFAsuyae8e0RwHMNQ7LytLkqyKtLLV1SdGNI8KEpqu9olpAtNoA+Bw3fljyScerGvTyN9ES74Da8tix4c+QPtr/1CdckewT9MlhSzILZ/NeL/EBqKRpCcg7DxBqbf1eMnDlIbzvL+xq4+SCWO9B03dRzNzTvoKCbAZqd1AaRm7zNsPc++p7k1wMqOuYPLz4+9LLSpKVubVo9EapMvbOwRZ3qDHLUCmJqFcnISBKvUwXQO/Lex+ibJ5BdNY90Kvsv/JR30zxp3FvrUYleb4GNj8tbp4ZCtvsFLw9PbHG+GbYP/Kpg3O53dfKPyCroHFgnx3upasj3LZQyN3KXKiyqo8JA3/1jDE8pybtffZApuiYPYOzKedGh7fzZuYn/ikoZMKrsUlyjYquvXe3OpMqNq3U8gE/pUyxHIM27KM6x9ItSFN+pa8hNayezEANSMNzB3H7/GEYRYMf73F7B7yjCkxUxZ0lRicywXec4na6AdQ7aN1uFFKG33+STvHvGhw9FnFQcTBbxoWn2WGaRzhesywzOV12h2CO1KdVnv1ZC5+NL2BWF2kMdZdPg92nSriJqjysOnXMFosg8offcIp3ZAml5QKcGRYAf3Zb2LA272BbhoqCsvcA1sYfnEJG4CxZi9mrYKPRSyC9l7IJL/4SepSDK4EPJWc/Ld7vN8tjAj9ibnAgiAYf8TxqbpR3MFx53T2rshk3cXWaXTlcpT7LvYHNz0p8gYRd6I0bfxpNxHm16Ku2zgsF+zevP1DDqUd494Dd8+kCMzIjlnH0IzvC78t3CV5aIuLkPdu3hBwrfpC6RSQJDeYEJtL8c8Lvz+V2a1QAuUbcDIMmVhSKMKrVj2Al7VD7eEESfpJR1aws4lqdeIqP1CHmFEj93gwRp2mcTLttwWPYbsz5x8F7Iz8+LRxnlkMLG5LcrOo/OdT0m4mmLmLabpviESCmQ/tw9dz6zTe6J5Y+XXAGTKtL26e8gxthMZio0m2UJjwyqqhXdWOG2lpCgQID0ejExfDZSkDLOyyr2l7cAQ9w5Xnw4kqUEOb8dt2gxiRrmaOKTSWp7VBIjeIIzhkb5Z4bINPLlsVu3sQOWCiOG5YhK+gKFHchdGS6O7XNVogVdseTYR9jt98V8LbGhuLUsLf4Fbm7oW4R0VTlOlpIlkNzt0E58Rr61tLZ0znexv597U3tw9hE33JqWW7SRH64NBRBV2zJdTWHYWYPnzH0FoONhXOVUI4nEgS3bMpe2Riqk2Rc3ppM4o2fMxGLZJuNResXm6HMLatQ0p6btc8VaQUPEKgtqedfHBvTioUZmAvsijvGW2wyzYN8mxgXUxNDrysj1rfFgqvW0J/FZg2wdvrMww6DA7aJQhhvXvre8e8VSmm5r8gRA0/w9mjHNyUhtWqmsHX9vL7RsthQ0DOzskrQiMf6/VV9r+f50AftVaGKB6+KXmX0Fu8LZz80rQ6RI16+iN/jjfxd0jjFi8aT1jxnnCRoQP4yx/4haOlQqDmBVq5/ae4aVeO9HVFxYuLGnKwPav2w1XO+iV6h/v6n/JeOFi8HTGOpvTwJhivxo1ffcQesabukXMD6TikP7T4WkEQADrcC8Mv2J5IsOxYTBt076j7Sp9e3Bib46w8gi5ZKyu/DP7ptAm2wFn0VoBeP7xW8i7h0hWvInWIrkaY3Ib6Ju+Ahcb2QG0Tqjh06iuHmlAyBHQQwh62hHcNkgcQs0KmVajNuLRHN8YIxCxOjd1aGBBUH+i5sTh6CwQrN5WiDVet0+0foAB319HFiyTeOYcizVSMjqhulOWvNDB94UjPiK+bzDcoJmzH/GnfS2+mh1rB2L9NY3N/pyXYXDIeWnIbIH7YS4MebF7T3LqEQG/vzdUju4kysstPB62TN9kcp/t1WNpkRIApuzJffbvT2QOMoA4V2pGRgfpLJBGhNjBpFgJqwqQHNH4AW1NXr+RmY9CiiOZ0005k5WbBX0jTnGQOY72YvxSHw7qwvrnU35Qq58YdLBUVNhkX9qYJFxMQkIVK66ezQ7GRD5XqGxebh/bqJS8ecRDLW4K5UDz4wzHU8dMST/DYbOZs7tQ7uyLOYSQDY0gFFsJ2EpaSaVKQKcEd6FA74cf05bMNX0B5dn/jub+RA8U6Htu1/EgacGB/utczhxaHzGcy+HHvjQxmL9nJUpb8wetdPdqRRoxlXFTyYcirdGWB+Ag5VFekAHlJY194CUP0HcPIVe7KRvokGtOXp/Qn3stPh278ZwEcF5+FIF2aNfAKhqgOZqHMyk1gVIfyLiFOJ7hGynVkb7tpo4NeEPxwdF2MK4Q6cowDObPwdgCUGtdH2T0qOvIwOh4WflChI1Eiedisd3jVmNEgG2pvrgxSe/Z79U9mkpBGmFXAvRQYZ5zU2lD/+gWM0QI74096jlUosm7BJTICCdOE7gjzsSW4YIT+W8o/r8DdKHQ4T4o6pznOsnRaLNcRTeaBjWaQOiynUw84AdJklUl2EmeWcQqM6OwPgoRRSy5+IK1B0KzQfAVpQ2i8oBeIFccRbgDafZrNy5UeDy7+1BQ2lzZ8bXKMq3lsksbtykoD2psWA3MrbwKZLIsbPK0s+Z3eMB/J94iIu12wuzk08d10rxuTKyc/DvWOFlrSqcTb8LHqHi3mKd7HuP0iEErTXL3ACvY/fZjlHePEDxlyJMdHfzPIYJldBcdQu0GMbkTTxOk8Lp8IcvaCZ++cvJjU5MwQElUNsJwt5zRGg2KGSYaGZYnJAZczShvHqJruKkfBK4O3Hlil73Sk5Juf545fAxvon2Qsq5jzCTe55kR7Lny9JX6Uaolhbkn9gJ9A2cGTtAwg6ajJktnGitVvQy2mWgjrGtcyDG0bAmxyEjbSytyiDnpaDkr/tq6nBVXoqyrwugqVCTQWCANAqi0FQfnX8c0jBg8kCfm2OIcHnUHvuibh5Bl3odrJa04cJVdRdXleAHRDFgmcN0+xmpTcQbPhoqNik5b/AuOUCJ3IYqXss9YJvoFQimSb9zQaSSoDP1FA3J8rjxhlAjZp4ZPO9G4Sw0UHYlma2zmqK3KS7r5hPVPKkMiHckGnaGHw8sMfUHycU4ZcIaDzvruEduEb0ZJzl7J8GDQklXMXp+R3ugMIMGir1ix6/ps50nMGdj1sg9LiFpB2mqYVJxs+YtCJbgKxymPpmbvZfpFoYq7hwhjuolQ9ROzgBEha7+DV1cNPsFC+6Qd3Vby9QVEYf4eplQAt7KPfjU3WyvcSsBcat5IPJ/kC8VKJPxhrPxE8JBXJUtcDk8woIS59HVXZqsOBzGm0c2N2RCyUZbl2OCsFUWR/ujP7N5KCgVAOv3lUBGl7VLTdw+R/ntTT1BqZ1VohYhVH4s5QXDHyfqdQg/kP7tAAAQkY1CxEfTZqusgpNBACRPkrNtoNO7nRHJEid/gvu3X4qfGtnYmT/yn2eDsnLg7MRS3Lj+lNUyMQ88AmXpj56kcnLHfU7DtMTX/qaAxEijeFCLaD92BIUMQk4pP16RjL5OwwPUT5IvLHJERfq1/je39qb/e+fiU70/JH2O55C7tgGYSVAYlwuA+TK3aE3P03UMUXzetJ2AoiAnjXGsrQmFmpoHiNMN1exfKTo5HKc6zHF9uZi9kpLJfOQFUYn1ohfk0UD76cDftBVYQcVQsjDQVvkF+iM7pZji3tmRpX0chVT3tPte+bCfK1qJsMMrVELsgnso2u9/SNhxMm0N7ecLOtypbeZdYhK1CpH5YPWU/b+egKPB7V7Z3F7qsZRuRdL8Ivxbe5cjmHFmiiUHAl2Ef/WKR9tt3/l+VkKG08XYJY+YENr6N7dyYI7yxVmo5DN1HLs0ljMgLGXipKJ0s04Ve0rKoHI5aORkpLT8vZyNRxA31g32i5uVpS8AiX/QEtrPM5H97Tg8BR8A3oiHT3sd90pVyLAp/o5RbROKMbyj1Ay3PTXdiBkrboLK/gFNsT2DF+GgO7GuIQXSSGYwDdjgYCzNAlj3HLzQtCotjYIj8UYn8jx2lUxlgB0bPXruM6wnFkjcPyOyoA6w0y+cM8RNe74ovm1GEJY6obDte9l8aSpI/mioK7S5CYwg8q3pdhUd3emb555VciLzcwFhg6i2u+b2A7C+LiH3txk+HpsweHlEWa+3sJMIytb8eJ6RAL+lhiQ0vCtUJAKAvoKsRIXqDELWv1Jb+1F6Pwr20Y+Ey8iSDW1r5bFgyDRMJ2Nna86vLWxYa1ISdLaZaY172G6qJSAVxU+0AbHg6fH+2NBalh5dwsreDTBk9rI88SuQU19/b4rgcZRQOltjv8k5jEWkyvhDLG7I9N9UEkMVTBQDtyrzOHcB7AcSjpfTEyt9sv/VY0H0TSpsAml7vRAZKlKCsqbGV9Rtp5JGCzQex2/4DWgdxhE/MNP4PBkLYqWVNrhsFO7iYgpoBLJkt1HSm1zvmTTF1OogiCq54pFLII0CxDo6eYqiMUfZbKiXvHsIS6YO5Ac0RwmlUrLc9DsQWMSXcDT9Qy22DLCgRmyM+OPHfQzsCCtIBc1Ee3R9I/uTwl15BirNKZZzLhuTV3UNkHd2EcOy/TiFbwd47S6kLNrF3pOJwKBeR79IWiIOBjVjPFZNcZ/KiX4I7MRSkU7yj1O+nuhnOGGJB8hxH6bW//5u7VEc2e/k6TYEdho5Vw08IP1BnlO4xDyGOLdHjN1hz6G8M3JBe29uhPlk0WQk8fls8PlKOBEqQ2xUfmcPfMaHRfmlvt+F1gkrSCd7OT+9WpDZ836BYNI/XOwOUMEwplUksSvnCMR/Rojf4T1v/BNMB0/QleuvgjS5GAMF1ZB9jrAl1dgzzq8McgPexvqRfUbgbNeUaEbTf0IwEIpDbxR5nZZ+N6G9b93PPXszWcvc1krp3VzBzJiPkbt6/Wffm3hZt+1M2QSUyiUUpT107OPEJYojLVUH12oJgffOI69Sb00Ub2xGgllAGL/O0lSITqzhD4j8a9yG8FkDhK/8Yznj37wjbW+yRExVwXC8/OmirspgKheAQt5Cn9EQK6LtHPArlpjw6N2Bn0B7bdyouWgGSiDCbSsmEPYzTT2ZAyxmUAiUTiD33Vk3KpoXMOlJl//BDjsZxFJx5d82/ute2UlKsNUru2+rA15eLT9084pkYN719FQmsDUiK7YZpGfBAH41iK9KeRgP6ug14tufBGHg51eQCaeX5Ew7Bf+2EP/x89id2FgFLq2OW77g9QgUEQ7hBQcxNcVf+yHANT/pLufXZK5O2xxhAqbPnEJNzB1a2ZmGCluKKSIrxME+cOgEoxFbfsudhXMtinuTdI35vOUDLfmXwR95BL9tW2OLLxlq14cIYKPeEaAd5VLB0mHCVnas/H2PDNG/uHmIawE0NIrTigJwB2cy2NE0F3YW9icW1krWvQq6grre/qgzxg22nv9dQKs1lINHEZYzdmhw8cmIETe71L/rlP6fgRozKDerkJFxPYAHPA18SMHwtlVN/WIY5BW0voZ01bStR8uVDz4TnTxgEJVcTMTtfYJ0i2vwGP9442MgLF0yfJW3ekCA/poMnE+g0x/B26OFoNJ0MvKHoQng8hSE0JuRj9v4bEshI03i7ePGk2h1iBsRZOX4AiyGUSLwOUGllWkNpQWkFIHwk+ayrsTNEOUm0YjIQWH5DUxOoZG6qZGwPgDamY17XWAG9p20BmAgBkUw6rZeb6yrQm8rL1hCvkFtl9BS2UCHACeU6j5nNXtTMb9TbmodHvHSZ2eRdqv2RM2ZrC42bleN05XOojf1ImdPvOLTopZgRkdIqnG+xTS6y1BHUtWK20uFVGOz/G6H4b25VoN+9+RjVEwGZa4KK/UQ4n2ifmv3aYxOCHlIE2byJvQmMsJFrllczCu6JTzeulZb21OlXql6Ll5lW+hGq1FWoy7uHyKO9OXfYHhDPZSg/0xqXbdVEIjnMo9ZetXru6wDtVkmNdDl/HaTwQAkV1FjjeAzyF5imSBVyQ/9hXQGhR5whkC6Ra8qUOfaFktfi0CiMtpcjxij2NpAorL3CBywVJ4E8ZWOxKPpJGXdmh9p3nYiwWVisvnsIsPSmhhIzcvGh8SLgO7omEjWqPTKfYmaLZQURD7yKncUXPY0rzUprK5UWUzm+YofYFyY1R7mcNw2dVj+uKcsNMgyuZJBHdmy3+vKfaw1QSYMVgm8bTOXbI/9Co6ewhf7rIfWr1D9UWt/bdHxyn+e2nbIFg4efhZqd2Nceg/rm7iHUjzdVjgAEh7P6oE7yjuztrflUeRClj6eBsd7oJ5hVaD3f2Edx7IEQlgktrozEmE/9bhULx6/XxajaioFOcNXv8i5HYtrThsgCZbeVppXsOoTZ9sagbkH0TyaQ/xPbIKT1QPgUhEVOMJmc8jHYRlBQkX5Hgn2gH4oUQbdrf84rU0GE3xyw2csdZQyC8lKrQX/i9BO5wLM60VT68uFL05vyyCnJUSRQ+sJOH+gEbugEBuY1ebNAapu+yomY9Ll6CKvAr7HsloPtFw6FUue55hlG9k5hBlUKhFivsLc5mN5Bq5TJxVytC95Jj/LeEfuIfSw7PA34IsiaLMt1kPiRbd15lKV1r2Pu6/AHAbZsBGjSe4JGEToyEzOM0PxUQxNpYm7XviAPxeFuq6MddYOxziqlsYblIBi9uLeOpyBTHGG/Gvbc++uNz0/ZAoXkJlbobL1cTYWDlyZwe69ccWQtvZy+e4gD+KaODpv5OmhxqnhgDP+Is8d5MM/qWATGUdj/tvskkhPv/euduk6o8d5YJyKrxT7lSqNoBJp/L9xtT67rbdc3DyGAu6l0q/6z4boVFgtzBWQNp7wL7E4MQtkx81a3DQYyd4r9V7spHATKcfBGYRcI8r4xxyBSrt+koO2RQGMBsqymsUhSvBUX5Ha4jurhmYdt3wf5SPhH2/JK2fOwA2pa0NgqtyXOeXlci216THura0wHt81lW1Q3GXBr/yqGAZwAEWwfq25Tx1iNQvC89ZWRIPrLOClF5aoIR6QoHDC6jkkE6P9Rgf89qebsfJbdnXds2+qeyPbm7iHi3m7yzig61+yd0z7f3AwwTMNYC0AQq0t4eSTY/og1WQZ5Lv9rxUYL9lpO9oknAe0dzzYG1i8TOf3+lc9dz+ubh9iRbkpnm/8fNGdhiJjvYFCadKp/AEbOttKBsF1YOYoWdGKBIq5uvamxpFZJcLWeONIff4Fu/VcndR98yWdeuq5Cm8KL9lH7xAxSATiJ1B3Kp3BIldYXOFkGzzRlbxVmWCnBigRb30iwj4QvPu07505oA7jLAMv+cnlPOxFi+PKR3cPVVlAbZW789Jbbqj9Xsr1QISnRkra0Bw7457Ff19rHrjYdpElzj3B4c/eIAfYbSHoFSO+XbTd0BSdWvb2CfAzQTJfkcDwWPbAI/2u7zjJYGUOFjTQG72Ok/3PHbsSZ3+TGbesDWsm2AlmO24KbsXy80rKtu6yJ18rhqzn2iJP/nEksWCDdH+T1fz6F+j4q1UsceEbitvl7Ax+0azkyuy6fJA3PdJ+s+dDjQDixJ/FGLm3h6Y4c4D/4ILUx+pOKizp+q0Q+mNoeqxxvqhnHxZA1XAfn093AUgiiAG0jXmBfOK/r4LUZjQEEwPpwl70oI4wyzsQqylhz+TmrFOpebghc7Id3j/TACvVjYnDIG6NeMxqW5jWT7SjIa1rvXnIESdk8hSlUJIDH+pvPiRXg/YlxwhDcFkwhXPGQwBnt6TYQYbP17SdOCZNRXhgY1M7Z9uWJAqXgrzEeZ6UJCWez8EELtRk28gGhQ8crf/2dy/7fydOIF7zBAOIRJ9dlwzXurN5EzkMHimA7MCAV5wvxdo/JN9qKSJxhL+V0U7Y4RTkG9OTnxUmofLghcciYRe2L30qPRJCkws9QOM4TkprEAbzus7SDMPlfw2af1xDYyNkZukC1piJSYHxB/xcp+m5q9+xYOWveGFrfThs7EPCKca+aSE94uTPHyrhrabLnHCuiXPl+lE9IKQYjfeEzYmXSfTwSTlX0nVYsjq0IkjcP4R72CdG2RC70znYdw7vrHuE88Vs2xtjZgnSBImAje0oT/RXEqWWuCBkJVyl4S6TqxSF8XzCtdSTWWoHwIjx+YUQ7+1AMcLUfCfWSA74x5xfm0+ow28AKF9nmeDU5RgPenhMbvvKOh+zYDXbMliINlIwPHz7YB4NtSm9+vsE9yTawgQY6r7QOwyWaEB6v2A8Ws24xRff5HPBI7HBT1gASxikQ+2in9xh4THVypgAka1bE9H0dunwgKk6ZuDxKOUCUY0SrKSLtxecasDi97SatXAfp3XSBiMz+8WqmKZSCFoj4bS15wjxz1nFmgm6213is64puFuy0Hq4aDWP9RuRx5DnwaaHI6CXM5qf/gtmq/Rr2R4P5EFYEt4WkQ9XSL075RDb55eeuhuUEiqfjKoJ0i49te5lDGk8fAmXPIHN/Z2j+IFcPLnVgktHrJ2bdJNmlqDFhCRTqQpx9JBlAyAK8+ks1ULjM2IO14vlJpT01u757xF30jS76aoy/sNVqr/PpmjbMsuy9Lh2i7YveLWMolh1ZLpK2b1KpWlQeP+EIFA163M5/w6EaSJZuZtPbqgJEBPjH3phlo4bim4N0OgqA5DAxgj/PkzYODK7ol69pZWeNza8q9j4Myd96CVtpnHg8gbijeoFcYakl1L0jRoB8BHyi4Y/Xwb3MLWWoSOLuvJ4TGViXUCBeNflsQ7ThroWW0golxdA+t8gX9xDmo9KngGe2ErzHnxxAffcQEdw3hbD2GhPxPyF9r55wAmAXVXhxQaoVbGuKaelQdlSseTzta6Q1zVoJZJWgNhLg+vXkwAmg/wo12e/2xbZVCqDs49fucrczPz5dffcQiSg3MXd48TyODup4D3pCPDMYAR/ijtrG1Y4N3+KCIg6fFQept7cCilfI/ZvBLtEgmC+UdhEffoP6TtZCno5GjNndeQB9IgzVC6TAqfii2xYjhlYfCk515x0H9l5hBZZU+7+0/GPnmFTClEpdCQ/jc7du+uYRjw6CoQGh6x0jWq/uFh63KNh+VBEDSE0ipi1sD8aAmbgtb8YeKaS8H8IqEhlLfvhZim2k9m+H5mac3xkBH8k+bso7MoKr+goZZYCf+8da7xhYjerSSs7zsaFl20yKZ5iCmO/5pT1uwhGnRSWRBuUb6qhI7XRT7WQ/21mdCQag6RU3dvjGiEPMjEIUVl7XrZzj7CCc3WkVelIcLbTUSkoVS682m2LrzImywmqYxlxbLItN0XePiNi9SbFMO1jwkmKgI4I+XOQH5CXjRKZX2P5vP/c5/9r2wuUtBvnrJ5SiXgRVIz3NsQf6cz1sWKtxSKiVJrN5f3JepyNMyPa7TlI9mGtqne9ctrNqFTDBOQAr10VGVBjdYlecLgOjovEbjsVI/nJT5tLRviVHngqHIbh18LKSoTsiBRrjGQxYmIZHdU3qPqlcOxyFI1Kpa2IxzmNemxd1QNmqfkojGrfQ7V6Td4942AZ2e/xuF7o3eMns/XcQJqP1sTZy0HlmH7Nu59mVGwgdPL9a6joEhNlNWOMCI90PPwnC5Bpxn62teFr47ic2xKOrR595p7vLm0e8gm+O+rNfmYYiiG6vxOo6bPhkm6WbstAgJmyg8bv0BdolYsBvcN2I9ilpAevJPQvMHS9ncTYVz5gPHI0K5dkOYtlDo6pHWJmV8VnQ6yEXv2US1p3Qhmr/dcDkcCFc6F9cJ6HvHqLduCnFsoqrMkN9+t7wcuWWveaMSUAXMupiTSbjDiqeOv6k1b5y1GIdmZKdvdGJR7ryL8QQQNpcwe0zcTujiqbRw95WdLMdfHAtYwl+/uGoFDMkaKQo3yBKQnCwNmGse4fqpvtr/zRv50UJv/11mT7Xu/yZ36DvHiIWwuecJ+v58GpVwBX2BmyYvJKoZronJDweMNKQZnxhwjNyI61gXeCShO0VzK9DRYMM0s+jsEMK7QZZBmSHvQSU3zm3lQs5rF6ljQ6itOZVte25dVU6QFTq8GGwyt0YWiEFPRdSeZ8LICNB401BIxgBlE5QLl3Ecn6owgcKh23ZrnfM0bzW9csWzHB5k73OKwlMmgKUiUAJJmOB5Rd41ogpv0GK23nH748n1q/1bDBx7HTWoDNEgYwj3Sdz8rHj28w214TM0NspnKCSh/+Xs/8C0xooQ25IQOz1bsWPO2RekDqFO/yq/PWx+KyrZwgQvORzDU9FNI69oZSACPt67HWXopNIorLPtY5JlVjTmD5VWa7TZ+fnmr57xAfPfbisuNF7MblDno4tQSSIWCy/boUAlGWu58OXpP4PVrNz6R+lXlDpC5VCOhRU7/f9rIkCL9sPTo7kSak+w5ne3D3EB7wpXAR2eLnEGqpWD/mdAN3A1+AyOYGthIbhClCP/Wts117UhVRIK0W10kvG+sovGFbtXElMXcMRbxsYt3n4iG2J2MdgfzGuvgykETEaRXnK1M/IBxt4ZnnVdg7sa/jPZmgm/3zhT7LPQ//FzYAs+48g6DAx2fJaUaeIwUM6L5KwBn6s0yuXTm8r5RaQ0YyzPcLtmK1S7JZK4AoDu77hzQ5UQTflPwVTfwsuLxXVD53S0BGclBZ1/JBOqKMesWd1QRVkdd+awxkbuYXrW+qNAnXShz5l1Cp2lF2wENreAa8PRQUwldtLNUjCr/I1rjPDqCuVixUaoCOzNNf5KLbjcTAl5qP+trJ8pBCMFH83lX32frTivDYYJQcbTliQMQuNqBlEFMugZie77ULTkUrrV9p8b3RTxjitKIwUiN/wqgbhrTctrKiBbKGjrAEBx/c2NRz8aPhsjVgFMFyRnzAOs2G7wGCS0quDacrZKnywgWsWlwFxTBx9xP448+Ur1UykBLuhBLPVQTAWFfZ1etB0O3m+Nb8MroGMI1RA1m8mr8exg7OpV25u4f0WKrNYk/YFlyqKCU7qBld2JfRnHoprZxyhmdNeX+tZ5wqu/df0Is0mypoiHLCCueeGAAgVy9P+9q/wsI80c5EK7qbcbYzU/DW1U7R4dj3WdXeVyEUBVlupeZ2WckcorWIYl19WRj9lDFQiu1CT95Xw63+EUTckUNZ6g16kPpQQPm2jBaD76mash72WfRVg3yrrbV9wHlS5WoUHVomuAoHW862tZuQ6njRS4Hu1/gCR+u4hoiJuzqiAt7qVBwhbWiKgaX3ObT8ZK0gAGj7A0d1DuwvcL683lKxicNUIjHhkxmZeLgSfYl3bG03rQrYmcMMUb+4eghy5qT4Yg8OI8Y8ncu4cUQMB4G4Se4tXGgysKNisB00s9vFG3VqCWJOgNAzC9BJ7ZD627FUUpgVS3ZNqH0BRdOS30sgJWimFoqdVXWVHmTAyPiayAootFN9/FGoKIGs4x28Eulp9RYwZPDCjb0EUb67pzd1DiLt8tqY9bVLisE7aCnE1QOfLyYgQzLO3R+s6WMDN48RJQn8lQI+37Jxi85SnMzKA/iEeXBNpp+TJN9oZzU08iJuHsBPeRCvHSaKGsbQwUDtqaL/EYJYwxYVtDq/IkdF/NebbAeOwBextrEQxFeqpwnPjsN3PhaOREvSm4tOOhMzRYVBUXt5v0g1jH7779UdSg4ErqMcuZ4gRqrPNMLFJRplqtNA0EqY+j/86uaE1/CtXAbPzZ/TNQ0Tc3ZRq2uvI2Xh2TuPN9foSpiRrKCk0nRyC2rcS9PTIJbBJ9jo5qKqVpkKYqqYQx1OLH6IZaiPfypDugH/IGNG1iGZ594hhZmbo2WI+6faqEMG5lgLjA20fgKscXGJflSrwGcz29r+2T59ZgiiPn3AESgg7Ary/QLwF4qAbKqB25bELGU9k7QWVF0c6YK6U7eokxtCOZHZ3LBTmkgwJS6swwIaqo1ih9A12PWDLb2fFu4PuwN/tX/FYDO236F5x2s5YqlsVlbVRk+sRGf+nH62M8IWp8HTtHzCkpx9Vdw9hvfCxew0NAhCmAjqsXBsBmpntKa43TEuqCzGy6psnPJJCrGnPG5GKkSqFbOkkkii55PMiHdGdVjgsVyvSxakSKpi4crlJEqqf3DubRBhjrr4Wsn0i/zqVnAuHkHC+hou9hLUz9oFGptEffDr7bRh5j5r5POdfOsgPXt6IB79BeMPmjFPCX9Szr5BuzJ+ZS7RsbxO/CuYrQNHr4+KghmCNqqyNsRFSc+wRI/8FFjEiiG4wQZDGz5UlbQfNctENTJq5eDXl5WIcgM3GlT31jo4f8kPC4yccgYJ7ipmqz9WAkbrvpooPvc8K8+oTOPzLLWZWQI0VxGkVno8Gw3X7l87T1YAZZ6J318rxJgxyIiA/1hruKm0AouQXRLvPSqztMkXfPIS676aMDwds8kFnViasIUuYNgSKl5yHfbbkXIi1Ifb7oNLEn0MvtObQKjuQcA9p8WCgNfyCRRd2rYa5xlDYzkydyMXMeDscX7YzX2CyHOtGaB938oYdbrS+p6vZDoYFDZQB89fe2nlD82+swrgmD/mTUHw7W/+NPnU0Xp59aD8yofSLk2lc66/vHqJVvqmbGUAE2rreuseNAwK353H6uJgEGWNd14EV4YgAVG9Fp7MqSlCj9DfKHRC7CfZOBywIPYf9p9Jcxp20PV3y5iFS5m96AOyFBAzDNvi6Vvg8Mi5qqx4yndvlcR/Qq9srC/MdcErbhl0gqK0BykoQWQ9wnVAcDADYmK2//s7MipAQv0GIW4eN1D7urqOtQxln4Fmuuk6yctZlMsYksuF7sXUNnetYuZqFB1qQ7TE1/7zsyB55cTfsjrXZltB3TafvEoOZANEuqBGrHfIMQrUtJ0FeTDGiHYDeFQv+JwypFebWwAUb2GUJv1hLixQtaHNrmb9fc+ghu08FX5MJTtt6zj0yXN89hODlprAFHjc8JeTzgEzzThgJ7RdHXtqKS9xuXaFtGzstEBME9Mpel7JwoSLXappIffM494YXLFZXXcu/MEF7LuuevHtAV4l0bWw2gM/zmJT74r9nT7bTjGevluuwQypCEgCaLghtgUJTmpgMjX4Q/NQ5/nIsosCk2bpCwsVvxskHq++Wd4+4k77RMlsPXFhdAzk4p9vr+EFT8tjhfiV/XHhBbCHiOIeGF8fJcvSFRr/YFSib9Kil3/IYbDZc0eOkJxEGz60C1DcPcej49NxxMsNoQAM3lnYlMabtcofZhLbTNTAZYnCOCkIYr708HuEqtTRKeyOyBmNJ6VdSnv/lBW8QgMCOLi+8R5nFKY6CWGbGVKLUP9eUS2sgwc2W1cN1l3EIG7vwvEvGMeInN8QM1SVB5JOFIGbPWIuwVvubu4dQcNz0GwM0xMcGHgOV9o71Y4HVeR1RreeeRGdnP/Mx4KscZbmeJCStIGzlZ479z48o6DzZmCAfm2GnKAj2Pvfm7hGPjrlp7oL5BUNwoOufPkNljcTEGQQ6wR7g2ParYrt5oyvLat/iZbryfAmHWOAn++EHtPU/PQ0/4yj9tcODcF6Rd8jMxDq3qqzuidH67hHru27quDqecOX11soal32hLuO0FE68HosUAKM6G4E5KN0QwFVfb/SiSl8q5WOx3OzPaNXM5sxOR4wJYAxB749HW949Yk/lTeLBeszBAF5b7Sh0NtDfIPvOHns4pie0AjdCTgrH7VwwLi9LniQkFIGh8xODuMXPde6RgummgdvKQLzWgEAn9eo/9E1jEVrl2UG6VS+zULrbLwTUA9meY43/jm3dygMuh1wEIzG+IRaKxD+3i3ysoEjDm2crWpfIZ8IGOi9vqhPCZeq6Dn/m2GnlY03dU3ZHaY9U4qJYjLRPegyj5XdESvxcdMK5Nv03dw9xGvuw+A4tpF+vaO399LbDoCC6ntdRifiKnQSjQBpStGorfuws21A4qnSmSjgbC203kw6rE3t0lPycJAup6Drt39w9BPHpc2bBDPN0w2LFSKiXs9r2/ozm3Oe07cLRZgq384VvOlBGlzX+I2beFU2vPY+RR3K/+EhIxhdEYhFDntHM7BzYN3cPYcjwOav23S8ghxWq135de0BqsRcAzUdFwm1bkn3fNxCehE0KUosVSqLAfAH+v8lpinKdPkep49yYmxoTgNNUqnO2e11ZtQBQriulzYGtATYVaBr2SBfM2D89GpNYe6K0KnoMSjQ2hb9ArO25D0par2s4BG/rzRnPhid3pu6Q81WQQv2iY94+9K5a7Tc++UmFQz+28yvZUCwy+jS2PRJz3a7aatRO+PZqW6CPsIRme5zNiesLTcD2p9qWWIcjwjBr1Ze2rUqXq9aKBdKyhxVHhYglaWfDarxbf2hhffeIG86bg9jtZ1/BRg2fgtQtACD74S93WCKt9PLLVnH7yPsL4EvNb9zKytssmtm49X3gp7NxjphtdxcRl2an4H7sb+4e8ciUm75c8Fe2BzM4mWMxf+iGHbZ52nOEd/ZqlzvzwPWDT6pAi06Ep7y168bm3sgK7JdP+JM8jw0xRH898+FjGKxpGEveNB4Z/5u7R/wUOS3Vzh4UpwBGrF5k9FWI2yi4RGErsbtXr49oNX2BSwzY/Rs0/glTj29j9oHqiqBGEX75ZVsdrnRG+WmnSfZ/RT4910yZdYW1V+oGIpXB53nNITfI/E9bW5OClYpILF+MA8YBq0MnX0MkLfMRDmx1sNG4TgSEEh9hbF4UVkfNO0Ys5Rect5hH2az9R48xPXOZCLOtCLhdO7Lc5pWXRfb/p54U5SPpocjQG5h/HXlOZ4YDBEMYzt9zQv+zwitWbN0uzcLooMTrPKO84bBGE2i8Q8P2m9TrWtcvuIHdOYnZzckbEeVyUK4IJQkLFWRfMGBG7P8Nmh/CsL5Hv9nvxIWeKUJuXNCYiUp6CSLTy2ptX7mNwNBLuzWFt1MIC2IZwhc4pEjtcUPtAUJseCkGKRx/aGQZnqV0v2xr3ifAwD5pVV7dxd/FF1z5NYW7M1aShKqTh1KorsevMDWsk2oPv9Y3D5HhdVPpZxsp64sENHI4TlQuPGXyhgl80zUcJav4TUuB3hJKPLSLXlorAaAQDMoZuvHM3QdptJ8U67ggMy95pzn2zPM3d+nXQCsKVTJy2wZn4l6cZYUZVxdTxV18JpiuMJZVOBVjV2PggCQfYzslCG/8d5FJ8gtpsW0rEznE8KmTjTRmeSwG7c3dI2qDfX5gyWz2/bJn0JGiPhvPZHTH0H571wx1V+amB706grg2GR6T6oqE1/r2SA+/zZfIesNzHGjy/LgawOvcfKnvHkKi5gN2MMcLB3kbHBHhUjSeeZwCyga9nwtMw5HDqVg0TQIjbRtyj6F4Bd1rs2Zk7vzMhRiGNd6Hv/lIfaE7DCPnfe5hAYmE3gmzi6E6dkMaaiwkAWACqr3qy5Gh7GvC7BZY4/yydZWIiusXz6Hrb+9ld42mnYeZSgjrAja++OYuaXIEcSZObU3o6tfswGFfO3HEK1rWs+pqI8r5kJEgka0zsID6zPTcoGAakB6d87cx5yOTbaDsuansAW9hxz+DQeZSbqLKsCrVvbdWyKS2E/ntXwGkEGiClYRrNK6w5AoDr1ANhRqjj5VvoZLtdsVaqTw/7br1lnO48g28d7tWHYVJrXwCGPFmtcLlAAUa3/x6Z1oTHjctk4tkdY/98D8Pubf/ijUPAxsqdTojU6COrKfR+N87UWmkuS2C/xp4pHdGOW2EtVGoD9AtIFSGl9HT/xVanzOdlfZTZorw0YHvOubN3UM4R27CqoBSq1+3uuly4zQWNKDxylwc++gr2QgrGrTuyr+xjcnXvIJbFTwr83XiPJ6vzGr4V9V0HwQ967y86EbcPT2++KztXJOcsWAJhTXsntQFsbmf2blRYdAVdl4tmIrkVZ+LPQPx5k2RJhxSZDrtuRM4ccdMqRcFHBD+2AMa26iDcn6UpfyZzvNpA09s+NHa0FhL+jx2FA0o3eBJLg4zlif7UN89hEPyZmjtZCAb02bRoF97IhzqGTKjFRxsWy9EhiyZjV8hOLcmv0mGVTGyYj5dnKG71RIggPFgJ2hOGg5xbu6ZifruIdQMNw12gMDQKWJQoRVDT5xltvoWqBtQJHt0ix+CfyMVXkdPAgf26x3PpHgpZeCLDX+fQ3Kh8uU+mMyVGDhNRKh53HwjitMYYARixU07sA3b1tAcfUsQK1I9I5zKsa05FtWEApzHezrcUW61R/PRiCCjNgCr7zLHHqNU8eIjyAMWoeZOeySMD/eOtk2XiiYrzHgRTlVhaxVnKCAQwluoltBw/MZfOzSBtBRj/8GrbVVG25KwN3cP0WP5hFjA28M9wSciMHbiH4+Lxsl2ViAmr9ZmYmg8TmLkjmPk3x4dG6vIQs3ZG1l0JKP+hgI0UHTelG4m95tAkNJta9rJvfVkgB+uIyjF+zqsAmvBVp6RfV83ICongDIOKL1oKC/9lGOLOLPbyTF7EerydPSreAULH5m9592LUtupAf78SPua4thCRu6P0KeuEjRnQqkN/NiT2SvvHjFEfgMLr+j7PFDUjqzunFlCcDT3LNT3c11FFOsJNQr/GDv2mmgY+i6FS1Oi7xFW/4XdOqJ8b3C7yG05HXetk0QTzY1g8ZJ/OuuR8vZYnqhjnBIf2fNVhfMyNGkqKjninR93AjhPnMfJ+64GlcrWLcubh8hNv+laYNyee/qtunbwnIWM9WHTJwJkAGFuNyh8VrQzoDcvHuGj7QzC/RCZJfx6zuQqscVnyOZ/O0kxuMLTT5wNtJ0dNY+/uPLmIcRKt4uSzrXdoFisa/YhRm1ck4cxikurW1aXCRs0onvwr0EMw/XevCXMXm+0UJF26huixkimeFOOmOxzX3uO+Mxr/0SX2BnjAZERKiXfnjH8cVKJC1ESgK20rocqf2UKUKmZsWpyi7ugL+exDLiPOX6tP/r1N3cPcaj6mGOruckiD3gr+vXEGTakECZex+7TtugrQ4lw8bi1tTYcH5diMCUe09LvSCr+uXM+tvbfHCJlRSELiIxscMQWvFx8A+54+G59duh013V6iX3nq/DEcAuQYiAlHlJDquKhVnsNTIZG4SmDHfGe/EkDe3P3EM/Ih9tnONl4+bTObmzpbQP+P/goAHAtFT5mxg0X7CVURqnumfehFFgph6UcMFIPbuQ9kexDHTAmKzPYFp+hW/ruIfRnPnTrvIiAMs0D6u49LAsoMvYAtBDnGNdG5EGO4tBvWAuju4hEIvUK2Vdm9djc/jmzGqohbugerJ7h7p0xoflySBEtJXLHnVrFaVWXgboyiZHFyok67iUt28LgrZQWoSzjCx7sgCNmoq/9QtOvZmCnNFU32hyHj1XobWHnA+xJ9qwrBgIUd6oLw3bs7pbsc8RVfyPBO5Ka+yDNDMAeSGLmFMBrJ3K3dE0iiXb+2TtRNlKZKUlk9A3I0fp6B2AqwFNH60RRPFvQ21G6sinLHKyGBnfjMvrmIWCTm/JcK/9OmkZwHdPBX84FQrSJZ0w4xc6EnYFlD5MwC+S89gMsQ67iJgWVGap/Y6nwV+Kc/5UH3BAC2BeZra6yfWYfbwvqzJ6Kv9UwBG0vKaIokpvNLmhxy0vbV4XZVWoPAqHCrnQRLcYG/CJkwhDwtNHYN3cPoYe5qXtptpmvFtpWTu5bUI+EjNNbaGuaW3LglQYEoJQ4H1vKZQ8WinX/yieg5TaRPOcLhlw3WtnrOvGfALroqFRHGPAFFeLEWbayyyJKMAxkleGtkdE3MAXzKv4R5t32f8yE/fXI7QkkTlexF9Jn4xbMYN0ArL57CM7b5w/ZiXMS8KSKZu04GP4zmdmFgWG1l7RxU/u1enW3mm39Ph5I4rUK333jbovccI+E5kp8ncF6+JyZhry1raGRdzmOxT48VG/kxk/bW4ePYwHjeLrR1j6GV5ghRaeIMcWixYbfWGWKHg+MU6WmBnNGf/sUP3HlBqDMDVAG2yDl6Oj1oRJ80TkLa8HlOtWEgdPJL1tpQ8QCTfRge6IMvMLuK+CeGBx6JEN21FIUVAgE4Btasfkklsu7RzwYCOZEf+sQLp6xo2RvNAinF5isKTcY89q+Qts88eNCFVTamC5uFlZGYXwMbJI/x66R7Lf0QTzt/L3QbSFPPMkOospHao3+sMv67iEcFDc5qHpyZgSgnlFdzU9/CGaMT6Z02qdYYpiWkF9IIKNAFHKtHk5SU4LKehMOGoWJfo7dRazpDXrUqpW8tJEFycMkSRIkSKmtwr5CnPFyN/FoTABBQ5qrB9Yq+7IwO4vI5Ji//YYtMZB83Exht1MNohPs/LYAvXfFaWzbLobqYMJhXlNDTgg9QJzgsh18HjctXYzC8xhHvEdx8N8INY7kIbcLQez8YDM/iXg0N7aglSyEFSashecenwjShOPiqD6Bh/z1zgejfDNKfxKpVZ5ipvuDHXXNlbKTqO2T7c3dQ6gefFYBKFmazHBKjJz3LAGM8sRybfC0J58qggPXCrsLOwF4Y6v9nsnacZOvQAFlYotNb5+KC2K5wE1ZgC2awudGPKJWh1CxDRXmjpJWWnMBoeK24owvJoilWvP/UI8rtbmSI8Tyhc8TR+Lkn5vC4YRptonVjfV/aWwFL9YPqx4c+c1XLpTDdmaQfUEVAnhkZ3WGimIlQNYzh6MZxV+gawK6/AYvfgJBqAu0sZ2M+y9i2Zf9pAL+LGNNuoVbfp0beU/YEOY/ZRWUVHxE3H/B1BYVbJyWjtnG7iuC8pBHNGDDVoHhUP9tb/TOViEEePmMwYp+6aUdcMIvJ6vBfyvHza8XZv+C/+iNDLr9tLt90zcPgSrcVDxPKF+G+4HtMFo894WpG0QzYFjIc21UgGz7BCjEyG3rTNMOSwnZeMXeS0V1rMD+hqMvGCxx0+gHj6G9jzPxFVxi4GvPO4ZhPINqX5ftxEYFak+vncVHain/n3ALRt5CXB58P70TRhd7/c6K/K/ZxuEKvjm6NXFkd/I5Z9uU+W/HJzst3ZcFVkH1bsRv0ueB3pG66yZ4CcgO67RQ5Ny9m2nIN/NA04L336qnsa6DLIYrrYIMq8kXggQ1FQiq8jniPI8voPIRwX6DSq+Dpyh38u7mIytXrB6lhCszB+E6lxmxgnHySh//s/LO/hh7JWPuPuT5v2BnjHD2G4A6qnaGTYOCn2UnoHZ7mYdzdHbEOAphr59txaN5442n74mwwvworJISw48Q/13QtTZdIESgASXbqLt51zcPoQe6KfzB8E8qdgrer9WEIAdvrLlvBW+mW5PhXuy1LmYZuaV1B7JH8lKhRpVyo1Cc9DkTE3JKzAGms7jzgV0e3zVAzWdOhLSLdk5xPeLsq91TD2HsmLmvoYiRDVB4BiVZFTBbm3hEyD0W80BMM5vTwXQaJx713UMQgz6w4YQt4uL1y6pcr1QxXQGp+px7dlq9m7wlwSPsTHZEPvW54DyFZkrwUxmEYkPRLmjshaqefQok7sU00Odce3P3ECXHfXh8S6HUCn6rCTbr5dqAVAra8eQzpOYapQiRBWYfUdJ32rL0Sl1qFZS2QQkMY0Hix+qbUE1zUzYDHqq7VLsA1tymDdum5uU9lnWVvm0DCjidPqdap6c5Hu9H6CBRjhMl1wnVPZuHSwgCeHEGM3wmyDKokJ87EafvHgJA9xE1eFZpXUbI0ctJsQEjo/95nvwTZ9AwhAHvbfcxO74uJHGniD6tp47013vLZ1IudvVKkUkiDrJ2fHXvEFKim5IhAHXU+iSotOvSAKEIqKm6vKIAddppzSN1VoKUUTTfELXAVOhRhVIpFjZ9jtHHDtybepyGuD7U5IgxcuC0QPlcqOvGasyruqv2iltFVxzqHxDIvBfpKFGPmu8RzwP5gr0X5YptKv1F9gtj4cDMFML2Phy0Wi3pQ+tj1ixMspWpt5Fv+F+LMS+eOEiLTyJt118qI5/MCmyq1OpmTkzvWyojffcQu/FN9REY/+m7rp1AC1uffNU45hjR9Qg/quv6ZHAKlWaohfec2ViVJERMSpcW69i+obKKPqBP0B7YJ3wyvRXEye0q8OVBxpB4vdju7bsUaLqemFWNENSMMG9eV9JEIWWUsqxYxvWhwTfI+Ltp+03woQyabSuf0w/Ntpj7ag8HOogONRQvIwUMHlDYfhOx4B9tBhbW4cBojMvwECDbAh/PTorr9wmP4ro6AJ28hIVH6Bm6qG4yFTnBgejq33mdk5k0SNfpJyVGJ7UvHm0Y+kakYUPZO4ShUnC7YBmstLtokewY21P/etb/2dac0SVh7ePQtjZkLrEBLDn2v7La1E5CP0uiHBcRoiIc0LFbOnBW89cctjZ8tUCC/Hv8WM7oCfEmW3HhOXj2fs1r7+fy7iFUTz7Cxsr3kyqpTpXQ3IQB53w3XrcvtbY9tP22pjrdmXbylrYn28T8heI7tCs0cpF+QVgUSYVuaIJgVujeXNuJ18hHwHNp3xlgPBq+llzPD4dmw7jX1XM31xWFllDlHxUipFiy9Hzv82SZ2kFu+CDw/BgI5M1DqHtvRv3Z6cK5cMi+s452zXuEeLlyS2Bks32SvK4DwyOTDOO8rSx/XoKpFsS2TBKMkwe/wUNGvOLtBCL+eflNrZBbzQeyguwd7bspSW1fD81Cb4jIgLd8DCEjU/9k9fKobvDpbVsC3tw94hTmm04RzMPhpp2QW+DCND4V+28Dd2RSEiYo8DpkT7bBXdyfM37EfT12kCjHSeRQ+eHHtKXDrMcTTv3xl1P/I6FcJHy7qXCz6qIDH0Q269ncIJ5pru9nWkMF7DMVp4Tx6tAXTPG27UZtuz9CE4kynUhlXSjE+4J/k2Yb6iCQEAGQs3lUAR4nMnKgXvaBhnEJHSbkyDSd0BUqagEgFKVwCkqGo+WvZPdPyMRIEnJD+3Giny7LmQaA9UXnbIaDzjHQE6IGuvEbTPVp+F5vfXQj8yp8vcIELNUmkTblC26/CEG+D9b+yccpwG3QFzOCf5ubE2BixOy84Zev8yRAgO7RNisWm8IbGBsJFTgdQ9kbfEHQoOuc8V9CkYLNYqug9d1DoCM+l6hSQvBagsVrjfAdHpXkf9+QjLPnFVUA4oVSZXtBlqpREpCKsNSy6UhmvfHXQjkxAibHyZoEcO4Oynxz9xAaD59m0GuhpRgr3XpZP7thjreeCx0srs8lZAYoZKUz3lXYz5G976WZgGsVuqtsIrGt5Fn6J9BIZNYnV/o3W+Pns/Tl3UOo2nxmbhmDAb2l+TTPTXX1atV14vW+HQn4WHYCslOFCiJXnwqvKTlF4elAhygA4gu7XqSKuCF/qJ1iL25vKO/IAxDP5nIBNVXWsMhOPCpnp94KxLs0rQh/bOymVYqLWJ+xpdHIBCe8mPDCEmm6oGpxabS+e8TkgEean1DDe+rXsJOmugoACIHVBE4OgDJeECvQounREehTr9m3fyGGagWyq5IvYuX1Rl6tvBxexmTPLz+Rp7toxjd3D6GHul33lDLfTgJWpaxUS6gFUGU5PtqgaX25vN8uVJdb5TneWweU1UCLrSJx1he45YguZlgu0iV5GUjkPOuKxU34P7KfQdZVuONrIFXjcqYW9izuY8oeJsxkkomOeOsv0MsBeXiDJYT98lqosP0EzjTiLcfb47WBbVZ9+bWq9fdpcdH2Ts41SDN0iMV2MsVLRiTmH5f7oAJ6nGx7qYvL44/NXd09hNrhJmphvemkOgLRX6mlhR6ALwC4VAsFZU+0P8JzUQMga97Osrwj/GMwQ4Af0iIWOso21WjbLA38s/Eos4ZhbuhZ3jtEIeKzqmolrjZYqM2y40dGBnzB64hMOvewqsqpEBQ2nRhD5oixYiUVi6mFVpEw64GmiltYC2h8ByHm2Z6ZRfLuEceV33QLVNuqbAcGRFzKcmxnlgL2xyAmzjVGhJgOUpImLiPnzvX8wkIgDAeBPeGHHw9WT1sZMELV8pex9wNBRSCQuCmEsJKAfTMNIQsBhFC1IZXUYfKOuA3vPjOHrwDX4mjBq8x9PRbUKgGuFmBEgo39zmP/Z0QukDPuZXhJ1ysvbx4ieeKmbLZfk98TU26xJzj+0JED6qPprfzOV1/XoTlLrXjA7blZAqmmVepbNacznuv5Be8TLNUU0/Fz237Atx7x87anNXcz4eSrK8P+X6Re4uMaTY98VUqTh1+Q68E+H3rbv4raAj8432NE/DtAAf/LKuvl3SPuUW80owVJO5PyvVHK0sdirbu5C5pFdCYvOpdwn78SxIBjW6JCp5TwVanuN2qVv2BvTCR/rJlhQgaGojihiulOA0JNRNtySxXMQBh4KpyQsWsycFgSyrFjDO4+vN92vP+Ov/9APBKJQW6KPjARsDtKZ59xrBQloN4Z8ZS4bmdAWzFKOK8LadbJ6SR/JpWEdhFlL1Fak1ibso/0i7mw0AeNRFNXQrzyPtT13UOcuz6Wygrokzyr9WNXWRT/pJ18Xn7uYm6Ge7tgS7ByFIQBYoObvfl+Tiv+WfHVWm0UqZMejs22S5JKdvqceMi1WEe+V7y+ewhOyCOj0U3hhWw4HKwDqAtJgJMcXAycYUjW2FMUQXHgl8RUuRO49Vu8Q+Ej2jMTeWw+1c9EehifpV4AZ/fFX7OWce0i/qa+fFxoX2NYMGV4DjY3E+deWS2p0lcqOaZW20TqnC84/iIGjamqmPy50mPOnDxbDSGXJ0Zlrs7ucuMb3HpW0CQHcjOIFiK2wiAY2wklPRdQeVtHAXccH+xAL4Lvagt72wDe3D3Ee+mDKK2s4MwazDiHJntPkKSf3q9TOeFPDInsg4UXvAxQM2+9RKi7UDqNN8KTQKeyf4CrrFCq0yFakIyPjkTePMTH8znTwE2GD7sFPpN2MhVMGD7ufcLotOdMF7zCg68DvLp1D5qOVWZKlaZVJ5FK5SlvqCqBv6fMtPw9+YmV1XcP4cu6qSejkq/StWDdRV/5S/bD2IGIPgzGoJZ6dwYVTr55Va9m7DtP18FKqVmoS9NjJKKxE9/wuwaB6DdtsBkoZH2xd5/ND5+zYf8HwtxR6NnW7g5WEOYNmB8CB2r1F1m6Y4WXVoatB9Hsm7DwSFboQWEb5xFnj3gTFvruITBFHxGB0OHucQv2PnbPwETaf2KgCjF0fN1NZNjj5SiPDnPInKm/3hEcihBR8tJYjrpBW6vh2KtO27sHe/b+58B/c/eIGQXPE7btkAnGuF7qOTd6yv62OdNgpUnauRXdXmif4GAFgQ+T1hivwISVvjyWoz+GIPsvU/3/HG6tXXvpv7l7hK3KjVbFjglu7/BfWeGTV1IDZn/7JmFHX3H+jl1oXoanaw9OVCbB2FEouqCwZfoTo91ZyWOQ0nApaMfE4h2jre4eQsp6U3kCfG+5FU6E0O8hk0gWXKf0wPQ63wcnitKregxPgrrUJSNKkaIULDrPLsq/ezq77PksuUKqw0d8YnD36uzk3SMe4HHTD2ifFrPH7MCzr3wt4d9gzJs9K9Rtc2W1JJzS5GA4Frq7RlqZBIWlMDAg+mVbi8WeoF1Ga95+N/L/2fYXLGBObiyzJ/ceD6SZLw/ev1iHQhgUHBH7CeWbEb1HX2DkImXBfTDvrs3pDES3KoaJOg3THiassrhsz7qTZbLNrnrEJS5bJeAvv/JAC8d0rFqIJQ5fSMsPhV43I0msGkDXA+kQKCyPCm0I4IHtltcbOMW+rl8wTZPTPYEne4KJ4m4V16sST+KElG/IjiIZ0e1yoYKHyOt2nI/mSETGdLa2/j5xHqFfBljBAhbo9OnttjbPKLONirqNVU2fB5GGbNMNtsk2vCsvJYq1UT6yrlMLzd0cAo+SWNmh87FGY2FxUGh5lqDwSQpXpWCyYt7rC2xkRKwzeNr6gDN7z4p5HmklTNvVvr5Lt43eHbC27jMIJv41goj40itjbOyilZx9xPA/EH0+3cVsz4n/gKSAxwOj7x5CIeGzYUpzzUuBCLFUL10bJrlNZgvY9VbWEW51FiaqgjdEQ9Iwxvv1hsYTrN8bS3Rkof6C7TMilm9QyGXCOckn3DDChIoKlLmn799QYPbEw29AxdeJXsECdHL2ibKJho5STVkH/PZuZK42eXRPyB8GS5dS9rd+c/cQjYYPSjhRVPh8DkxS3YShbehsYDs8+NUd9kS3sAW8UHJPxMa/5y9julPKtGJZ1y7nPpgnH5LFN+HMAaOKk8Kj7/Bz9KJ1krLBQHTbgfKGG63jIuBT2ZflugVTMcypYFElrQ+V+N/QnkRakpuyEUA/2bFFKwCuuQWw4Femp38jILGtywOT1tyyhwNz7hT1UI8r9btKrRJIW75gfEMKc8ecW2hcTx7PFNeenY04CDpbKzyEBaESxkUKk1xsqAvMd2T1WiaFDcuNvS+/k5r+swcIKdfWu6BNPgedhTP5OG4rm+dwV4/tScVdL5H2WOp+tUo49BfFHCfTPhyu8BWSfuuo/7PfK4hOu2kDsyoXql/sfB28Dlsopl0h6hd7EFSwbu1KSCQAwwRrbmYV9KPtYbGZLHCe+dWMnirBXmTv6m9w9gNSLiLZbrJp2ZZ39utWPdfymBgKhz47rN38ZNXmCc3KBSTeI4U/nS21z3n662gFz3yk8PLuEac+QjoCKHmiW4ZqHfXQY1aAQmD68oU7aJkhyJIy6/4Ea5JXOpo0TwizReTN+OHHsYocfNtFWULpv+qz0jKl/lbunew+bBn1HUGjbx6C//L42GR7KnE4wK51ISMIirBiE7RJo4e6+sIctJzwpEbBdy1PrcTnFJ6nBcWB/HjDjZ06IKhAJ2awY1NmfJ/DjfruIQBBD8ruKZPrwlluW+b6nhW7Sqe6kzbL7Ag8p7FCeU4VJ1yDYwdlxwCtAnSVqDQWoX6qIIolQTelPxNF5HTnLNLp/IDFYVJ8RAHOszVfDdfnisoiJHWuxGglKVUSVKU4ihVKH6rmwjLSB4NYsdia15H2m9S6B4PkWcaqI+1hrklUOLmtdiUBhXyF4QIfTccr+l7J7GJZ3rP3Xcx/L3a8nK4Q4kD6tfWpm4xOhnImub2K3uDs0clQNlw08bS5dI6ingid9LFjKPQWiVoAr61VqZ17Y8WMoC9hbxFHfIMMrkQjvA1vy6/S4K/m2cy2Ky1ItTFbpHgrj4zisgbwhYYhYS+S9HNEVj/ICweiUPnYnEOw/+f54vruEWMpN0CTgrHQFy+fq84ciH+sxGOAHmO85LLvFJAeiZcvCN8YKBgbhoS9SMM0EajzqX4i0EPc1D3YXwOFmoSnSvVNCVUuxQ7MSxh16XtOqHMqTMfYMerAYfV6J6eM5ZdSbhGrMzaLDgKXBqe+ImLt7MybVnlz9xD7z005kO0tA4cbpNuYqOf7zMTJRQEjzr+rOBKO6/YrnmXlINqp7aYVJTuQMgUlN4rlSX9iNHlsd7vR2HmkUjedqm8eAhC+aeZBNVd4Ge40fz6YDozTp9GDY8/FwXMWLolNHKSfeHcWPC2QKgVsKatQbC36HHMMqQPGpyIUoznGOay+ZGnHWcqjk1ODrxc7n1+2FTyvhYgCOSDIFBuFhK1I0xIRifG5fiTQg9zUg1gB6FoYO7JWhXaBeqIEHNez/TJrmHDnq4sKjVqYcroeXGmslCRLiU1iccqfnPhO8Lwzpxs0Sn/Gvembh6A6fSJxO4t7US9s2GWRJgmI1MWroPfPPafYdj/ARda+nNk6bUdPFSGjCBzt7I+SAL6hnIq2pJtKKEQasuQCwVrPuYfdYTHi5McRaY2QjwJAuEcZrH/HYP5p3hqhUGqklEkq4CYWZn1hFHuIh3toOJVGPmkI22bdWRwdoRd+eUI0zMsFy7Pid6kVI2dXWqwEKhWwqV0zkcvm4RsAefCbpbSMThP11OIb5N1DhA/cNAvk2hP7c7zn1RvOwojc7pp9a1W8eKEJs/hkKmjo7d9a1uXYQaAcB3o2ZjRL8ws8U8Qc3ceSrVYfrIdzkOsTuJUdcyw30f0u9LHbGzKuvKZ32D8Oj1QVHjnhqJOsVMRhfW57C6mTG9QJLEpzSd1QHXB6WcZb6tQ3TpOWuR/Y5QmZl8ddN1ASpByFS0546uL0zpjD+bynidV8N9UqJ3zH/vEASLlPxV5Ee4HPueuCXZ9WuLbrnNeS287zvdhGiXNULl2cY7fJJjtqWclhIjj97Jgjtk3eb+4eAmTx3HDrPrH5diLnaxgbdm7mmPF632oIHvPXSb+PvQG1udJCclOCypISu1iSt7f8i3IyDnn2+dsVOqHtfdN3D0EG3cT2BkJwpl9PGC/zcowNhY3/uT3MFZtEgV+BKhXHf2GC9usN5CchQiWpjyX4G5CGh4UpmherDTRyiC5biLS+e8QyidvlEJlRAgSTwMg4Il0JtHe3o7Vhz9wRaWTYXCdtJQ2RTnvuh7KVKBuKlmFEso2nzSnF23fIEnyX62giV58j7x7CqXZTRwwWFGVJAkB5rsCdigk2Z2fOeQcQsSLia4IUiugjYPtztfJaXyz0yHKuRDyH4mHc7NQmWFWgFeMuB2psM27y7hGH2wPE57BpvDuwY9oG7qIB3/Zw7l0sdFcnBro8cfgDRn9dtJv9SLeosJYGRtQffhDMaLZ+F0sCGM/vkAP7URIh6hOhYsTsR95BPm/uHgJg93xZK2WR5eVRG3Nvfhixe9F/3RB8f6VnRGMC0FkoaQX845iABLwVQK4VtoEg91ML6H6PvEwD8MUJQRzPQoaIbJxtYaxUQp5SsoOKS4zdlUqfCFyrguRGwYhUsC9ZIEOM7gZGN1e2Jyc4lEy4ES0p2A/XOFrJlbd/cTaKQPm+d0rwpWFSuCsF/BeDhY9UtmGXgYwiX5xcby9nu3YKob5Lct2uYk9j1CexK+ZN9spBy9Ct1uy1SBTRqPIRZZZiYK4MfJi8ipDIk4M0UJ38NcD9Ey1FoI3wAfa26RB+gk3rTAuWTHgKtV6LirFfsvt1wA8Vg4UT9d3pWteFyFBoEt9ILyKpxhe0RGEB5hnq9j/LKNahY+o7CBA/v23YwFk7i7G53IsF0SQ0sqCmyStFVbI6igVS4qNQq/QFT0D07nLUY6HuwQeb9HW24UtenMUF9XStg43oRP+H/FsevLVfxFuEgUC4DdSmEO0g31DEB5m3N4Xy9l0xVXpwf/OJuvwCdqpg5k3CJlSfcTXwAzWOaAWP5HWL0M8LsX0gzcdlMHQd5kRyv2v84WPqtwqA38j6w77kMvXx9KubR/j4bjy+abXV6TL3bOdMXYOf/j395JmjT6hIbh8vjXAZfWNcdwCl34eba5yeQilbx5oSjwa7ow3hZWR2pHV9XhUDNzm/xt17CuBSeJjSk8b60y9QkhHJyFhCbGJkGfEQgfq8XJyPeRPe62MQmdOJiBe0HdD/Je10dFN5B4TTQBKYAdu5X/CWXeRtu2xOLg+z1meX7PruIaBEj6YrdgryiVEtuDLikE1wsq3E5WyPyK9DLzQ4uwT2H2tTnLVRXa5qirWiMlJg7mO9I8OOJzgVGTy4rx1Z8+buIaQUPqy72nGML4SjZpa6pYrDzqTqBAPisr2rRCVr5/fp/5qO+vytolIJMLVSIxB2/NFFW1X8ospiOBSZ6Wrcumh19xBcgg+/Qi7W4hLsLUlPAt+Ap2C5Mipa7JfTanVQnga0tVlJ/z/YPEH+afNI4DXZjdsYjWnJMyfP3wR/sHv2N3cP0Vh5NmVCGVV4PY+6yhHQEG5BR74ebCveh00MpkPiJUW+ZxvP7LoY5BKYmNYpRbqmLbxBS0tYxmfNgJwo2HtceqPvHqLs8lkJHC2aKcpGpJQr9HGqtR2R2Th67uWcckOuaqb2xlbDGvUjuWzFfWutTqTt2cI7O5N9gCuCp93HDMPoUt7pu4fA1W529FbikkphxAS/tHfWiNGtPpb16mVZF5CzVvnrYW3j4M9bShZ3+goZUFbaWNr3BTdQhMHfANutHekgXmE+LdV7VSiiejvXbD4grNygRuOc8OTClpTtECQ0L7xDwmkk8f2IDfgCMx9x7TdI9WIbweV0zICkl6YQ4CvZv2KCONaBeXvdbfGc0/8l5+lSSWUdEkYjSeNHpP8+9ApsIuxaTxdH209U1/fWNw+hsPGJvrXX5PESF4C3l4v+BirjystWj7Q1bxfy2hUxCWg41dFf77SJSsuo9TuR3ucLXqCIbrtBt82M4Wm8nLAo+dgnyJPsr4F1g82NWhNn4ry8AERQ7EvahpTJSPB4Mev3DXw+AtxvB9bt/7dz4ew0nDuvyfZL2u4nR3lec8/3jiXmCqCPAf0/GovB9rOfxTklQN+PxCK+dwg+7KaowTqHUlesd5tpRfsystB/bhRfp88OhmjitAYX3zIDdmyehq0UGUK/Ia3tsRX+G6qy6GT1IT/4iXe4Y5nLaX4x6wJLHddt2zv37B/oLPEz2q5sW+D8H4oMoeB4I0KLRGufi4sivZAPsbQfHxl9Pjd4nNeW99kbdg4XvdmqWvXphZGLqWbP2gF928tLqxCFaPGNHClSLz2S4VwoirbOIa1j2f5mH1367hHnYd50UQDvteYG/oTWl7TP1mR31S80xnYWpZWTiXaaUwOg8O2IxHTBhHBXKDdGZN744YecjZPZ7Ifo4Ix/P/sP9EXh6vSJdrbpTBRbiNYr7XLyHLJoUl68DtVZ3RPtUNehrh7QlORVtEk1Wqxdk2qkSLz0+BqTh2bjs597dl3ZPbu+S8V4tiLCDiIIt0GtFheM2z4GuBLFuDV9eQVIRiB5mBQoUwUjw1xgruPVEyal/qKPrI+/kan/amxD2EVFXAACglb0BwM2a8JW61Yf+7Rl8Uj/6umlmF1I34VpTlFX0HJeia8LM0v+nkT+34dbhTlJNz1vgN7Si1Mi20zbf2Y7ltU1CDMv58pPZYyAPbQGx5tVHHUBp7ERTtjmIpMdLqOjScDm0MaeFEL+IRsqugwWo9PDR+ieWNvbm7uH6Js9STkBEe68bofVvLYVGZnlq6HGwbhUI2hGMROScg9oY/w0lOSEIjO0+iQQq3wuo4q5/psqI7QpnFpCzeaoW9ZjGwxPIHRxzZcxVECogC+vSFta6IvUHimtkkoqi5PN9sJPdGYDdCTSjM5++7bFrSNGim9KISfa9ubXgQHviEh75GdaSDHQ17muWylDpAbSRqvqrh1BGQOYAu9USstYmbkBiZQ8JRv8RqY4FJPrtxVQ3z1ixNSjt2BJqH7dtqM0N17QLie8MJbtKguosbe6nI4YtozYoPXeS/xC4B1vdEeRTmlDcpm6MKgl2vCDrD2xc/rmIfCSm0DdQC9ceB283LmtffZiwnRLyX8nhevXhzXB1EWxOF+DxRWAp/A+JbyIhRp/iKfkNIsdkp4ffCLO7WGe1N1DIKYeoG8HNTHDApgQc5VfTokMrP/h11txohkUCuKUOOME4uazPgn6IW0jWB5tr4jcGB+b4SbL7ou220zcxC3s8I/aZmiFGZj0lnUJEnrrhW8u9NiJAgLVD/w0/Gj2wjs88khnOPGPNcZwtQjkMU80i7x7CGvyTQm1fY/B65y1m5f6GVuSt2yoA+ywW3Ive0NGQ2DUiR641LlF0aG0Wgix1dC4eMjcw6t3n9JI2Q6/X59bNqlvHkLKfVNLZ4UF7ImgSau9yh4FWdivoVwDnIHfakvpoAKbLmkbSNOa63oosVOSvDdh80E2/RcMgRGcegNORdNLPh9TCXthmQPxKrqrTpp/XN0hKsy5yoWjoxk+15PjpsI/GJsNBVIb47obgmSgAP7f0pk4ZMcvko4cgpQ3D6GOuamOuezpdWKBVhm3naiV7aikZQ8k1XD3Dq5fVjo4iUZdn/+5UpYqJaqQ3sRKnU26nP2kOgoak+JZ8SgXF+mi7x6i+vRAcTsYeMbZ9XYCyXg5KwLhafWczww09uUkSqosyjr2JttFN7cSUjSK0dHCm0Cn8wXUPeLOb7DkBTuFX4YykXAvzvrqs8oymBErvFfCnpVfZ3OoFU0NDzflnhNeO0nMByz+N4L3/oUUfQbaCRydlwH0OT9ayafP5c0aTH913tQ2c4RUrHOjlPR6x8sqHld5yELL2Rd8IQGMfgMxty2F2zD2okR4lyYNbNTDd0Xb+7xEQUlrn3n9S04UfYsfCk0kseVEg/T/Avpf4Boi0ugGaWRfiZBRZiRG5lNBswGnqn9BO7eeZDlbmyfj8OhM97WgbEPCZCQYqZC++oauIhJK+GxXK1Yh8MT1jNNsCxoxgzM5m5TzuPbIV9QjabFJZSVRKHWlUmMqGUas2niU8PSDQ+mKTAUe4R2d8lLCy7tHnPd6UyCPq7ZuJwWyvjWDZgRcU5EddeUze0g2WnDbGeyd5hgYWzz+10I2L0T2gST/h5/vstcDSj3Wh+W3oKQjrIXYjFVOhJ4RcXSt5/7m7hGfPp6Zb7UeCyhYsLBXvJw2qLn4KE5EKa05XKAZ7E8YCccpR2votCAxFOch1QexWmH3rnOcBOImwk6YLma/ed7Nq757xN3lTThrlEScpAN3Oy/fnSc2vUrKFRxwzQ4c4jrSnpecBFq0dV3BXAIWk/KTWK7yyMmuSeZhVCgxCcpiNtGWk8m7h4BXburDJqdIuwMVecQbXrCzq6z5bGhrvN+AeNcKJ8I3E/FuKe8koxDuUPCI0p/FcrWPjRAYNQw2hs1WQsQJVj9CjGGbuV4LuXVRcohrSzRZY8+hyUKIUjEQzEpa/4Azj/RbHv2BpCASCfiQyxNtT+F1TCN2DvnE7M28R1kkjFp32q1jaGnt7scvgMTz653sTqj0lAYh1iw8fdwYPgxi+MLGqO4dNahvHnFfxtHOkN9TMo5dsTc+SGDG4Kgme895egOGr5ug3OYfN3RrfLyxZUQYTHTLFzWIj3rqWnDsxP9HZCZff9RT8u4h0EQP7iqg1TOv24s20vY3YY4TB/dAY91Wh4M+88yOPkICWtdoJInuKTRQq60iddYz7/LszSdaQp3DXR45ZevJ67uHgNM8Y7Qibif59X71tIFjNCDdYTakWnsBj33bPjpWeLVK0VpCD2+Q+LbCw6XQ+h9R9hdUCNGB7CNirB7JlPfhfFmzh8GUAlil2gAyPvshnIW39zUtVQHGkRbPgda8reJ5lWohVjk89b1tLYRh53U2l5m0/sBX+u4hmJSb8hT7m7IE2/aQV8xQhYfNsQkMXr1oPfihgMReI+onEAK/fzClWlEqF+kSD03le9s/bUckVDNt50RtYxsjCEPf9/XdQ+gqfPgljLjJZ5cBLayuGoN9jSILXLdtoWffyLFN17M7t17hf+2vd+qzWKumVBuxymO/AK6nJSFayUnaZn/utvbN3UOsUJ8NZucj2C1czzj8XSuA0MxMGhrhgw93a7/jSZyKspqrr+BGKVtRMhclXIiFDs/BVzvPtI4qxZ1+o9dHPSrvHgJ48GBxKxNOPLiCMLfumAv4BPv5K4GNgvZ0ZUtyAHmC4pNANgDcnTge0huSDlGC81ig/rntOzrO74PTGjO8agSqCzj9F+1bJ+tj4shWsZ5pubpwqHK4E2apNbc9CBeZsJwJc2lcV3yO4EaYrE+FRNw1A2UzeuAr76mQGQ27Z0dac1Nc5inVhxrEDTDfz6d6hlm/Nw1wGHfdOJZzXGsSHR+I7Tr2mdB7gWZzsQXUERfKBaIYdU1uU7444aILPHd+GRC9/SKDBO34m3D8j063aEFy1pH1tOjd0T7Yu+L1dtjfyK5C9SDCRqcWe/RmbIlJw38WSxR58wwWta1qrlb9zd1D9NI3wXlmlZL6Rya06xjt/7B6gkIPO8/t3Jo7dHRQo0xdTCm+DBRgr/B9pUaJ1SvPrp3dz9JsW+L7aY005D9r15Z3jxhgvQGwjuEwRQJiUTwQDGmntr5Xs4GhrG0NrR/2j4ukGomMpnYICD+BAG9jqPdzwi1mBG8Kbmyb5NhB9HB2SDtAYVW0FRot+7eEis9HWNQKPwYrX/uatprPtzocJdvRkR5RBMhGqJBx51kU1imRS7fPOFan+ubuIToqT+mxl5wPGUcoBuSVBRVBRTA99PnKPqgEZVS+LgaIcsZHLitsVyBaCgHTcoxIvfEF9inik27wSQMTdvxyLcvmidJy0nXI9IRrhy7ashnTwftu1QzfYuUPid0kiqmKea1HVoRPg5rUfj8XTtnOuhOm39w9BHB2UydkTwMcFa7b0qhr5iCKNlA2LzQb07aQtDts6wQB6DSi1qnsgJK4sVdAgJIhxbKlB5G3jciVY63xu1ZbwPmZBiHvHqKR9nymClrMZ9HYm+MFC3diW3UoyTG6pvBf6YiidfsQSuNl7+g2XBClkEyFfGohWiRce5Q1nj1zXSWvhIK2OzV57wjTc0BHNBZ5EMtgL5yrAKFVoSAjzBon2Bf8G2Z8E6CUVMCM5nyTFpcLLXqgXP/hR4HuB/KaCjL7L6H8BwRcRKnd4M6y69sRomJ7FLdjLIXLz2fAZ2meK3AvowLKvgvAkr1m+UTGIOEiklxdxOx9HD8awgY+4q3DV+92FJTzjo/Yqza36WiAJSptJ43ax4b1hk+556USkux0zGXHVprYeLMpqERKCRxuHnyXsWb2Vvfm7hFXX563jLRHCho6Rj3kNW4Z6jh0Erw+Hv0DapqG/ZOvfNoHoqKsFMMl1BihduOp5pFKju85OdsSlbv93T7f9N1D9MuePEp+/fLrtt8+kaFWX/fpf48vmXw7YzgFObWCCqSn+R6/VHinSomI5YlfcEcM5rtN8qCzM8ebEsITE4QbaFDYbtldRClGKkJIOClC10Xk0PApmfZOnKR57bH8XdNiFyos34YTLbZu/2zt+i4HeMJ7A9AHk5Jbr3zbPYDEPQz0cJSxPAz/SCyVulFLIUPnheCzmNeyL1up0+rvUPlPNAaBZsDnOHZsLX4dkNzps2sS3Fie/IeqbE1ugv7LmlRCSZMDjf4McoxlZ7FITUsSAgXDp0NbQ1nnTT0l3rbLe26rQqrXYXjHMs9uAB3d/twBxgIZd9txNFYfPfrISGYpVZkqkDfM7/2GLyaYNn7TLmPnC97MjgT77eU8WbigrsNmO8uZt6nFqneaa7DOAenxcmijEZYbMcc8nHr+sMv2P/YvdF1zqYGfuIY3dw9hzLupIbaNDNUvt4A5FntUuLSh4aWGOK14xAKop18kjQeFYD7BSkqLlRRZT1WKpjB9Q14Snb6eLD7sszEh42JZ6SsTPjSrzU5XMdpBOX2BUzLesFFS9XgBIn29Y6gUoyVstaF+5XOaPaLNfZ5fL27egOTDzpiVBoepX9U/NexcKV9bDmWPsNKVe2HDcMWRFGEpzZZi5WMWf6MXVgMlamPtrSUuaS8ZziZHL/TdQ8ALHkKXr+HIGsfvzaWFxfqHipHXobhLe8aPbVJX95HyF4ii9zBfDApqOU4k3/nYHMHo9gv910Dl65YwCMkK6H00TgNTZS9ZgcT+zNhIEZsuRPUAHR1CRtHq2babrl9ole2KhWEEwBkat7jcdyCZvnmIl9FHSFjv43Qe9IvVyUWwXIj2J1sG8CDNvlmxbg+4+EtqB1Va1xUZp8g7RUfH9PVGbWw38tjoKw3OAMOrWlb3+ubuIWCVm3oJe3rIdeJcbTuufLsDp1oJ4eB6quwU/PrkcJaXK4jnWDoKge4pMFDJMWL5xhf8ERH0zFHVGae7U12INaNsuHGD7z5ZvgDco2wYYxdHcnEODHzXGlQdeimE80KC2hEE/jmvHvPkPhHO3tSZncidG0iAsunCXMLC68g5WoFiKN/s2V7898wrzfpegKUEW4qHj3n7B7ipTG6wv6g+8dHa9f6I5dXNQyAMPjTIthf85woDkU5f9xgcbasRJw4mOtoyXiwxfF1sVApgF8ybfL0joRVprdT1sRr/YSO7I3KjLulMraTtFhsp7x4CTfRYqoqZrJnX84Xe/eW46bDXHZ+kIh4KDq2X46xAs+FfrFAc22ayJxnG8K6Cg7XuMtJpfkNZEW3OPjbMuhrgBoPcmx+5RCT7xbqw2lfuu0RhV7aFQnnONRFRyVBi2YrWYYSyjT+rH7vHCQL5pHCsIXhxPMtf3T1iHumm3MiqC6cvGJ1Z6x4aAXHXMnoPO9j9c1cc13k0TxO6li5aipCUaEnbxQN3+VPmJGcjTgQ6YnnP/GRS6puHgJg8ktKWAQdVsT/N3SG2TnY90bSC8T45r7U5EB3MJc4BQG1uQD4G9hURoBR4sWLvC16ZAIa+AUMP5Dauk6nkyhWOjtaKzXOfkPYQGEB2wZ6NFCKeTDi1X9JYI2w4AuGO4fBveCb+zQOGAGMCGMfYeKRKYfyqkxH4t1V0efPinLu8L1+dg6zQgtW5RmYph0Vox4i8Gz+HS2cnKqRJDcrvxf6RECHqOTyC0Z7KSet5gXxrRVF0tDQ4uhAFSYCCl4Hb86Tja9IXbKHAbYWFS+HCvyqHz8mZiF+9QaTaoqM7A7WWFZ/XCtrDrPHiK/pabyd/gycOHzN76yJWQieV8F1J6jYiej8fiBhVH56zjAkOQMsK0wHnYgTBczCIntWHHclrlAs+tm1fFyVt9h6tYV8K0RcMgFTYxYq8XdxaW0ZA1mrKxDQLe44budQ3DwHD+qCYlUzKNt/2w2srvibqMLTbCTao188bmZnCbGOMd0MS9v0LUZeUPAwdoMV2vLy5e8Qt1E2BxER8jl+2j1TTTqqx5gGSPUoSYR261nX7fKxIMKfRfq6+tUExgqEQDyXAiAUbDyZpv6gPsauz7ISCfVjJm0xKP9G1uLWlQ/J2eVQ60rqKe1isdvY2KmQqJEOg+AThphHatAIKpxAxxZGHHfV3a/pfLR9Rr3mj1xyNEkZGs9ubOtYUXivxkMQIPN0eVuIGA1HMYC4+/jqdeSxvR+APUWYS0caGPe8GJOzWxVn0o1DaX1loOhyh7h2iZ/BollpgiKCKHdPm+gIFBkLGEq/bcVpcEGGfrSLRrlFCgj4+vccuFNahJSeBQuXTuMmoZPaBnom6aBfWW5me9izOCoOKx7gj3sgZkQZJ31UYfYu8zOLJ8ZqBV4y9NgYEPoJvkOpBIeFxk/Y/6rWtAKwttwbDiQK98zqYV88XAxp5QTjHAgNvsbtXJU4vcP03LHzE2j/VKcJ1CTsuM5P9VGMbfd7cPUTbcFMPdGGMQOL13uzF6atjZtCAtxPVSqlzBzlfiIos1PeAZl7BRKqDFx2/1BvF+qTPZx2FpOBNRSV4H2gbkaVipay3nhnlRllCy9KTi4JxfcB07bNKgO96LS6FlkqYqaanxVEwXxD6R5s4Zz3lxnkKlDNnonrU3Tfb0hb1aU2NV084tufFpwke9vQ9UdkCYhOBPCCCw+QbwvggKfCmXv50QG0wOu30KhOf/ySghw+U6jKtJ+KKyBkYnFy05LJKRi9E94FEH5cT2CyYksESZAaLf0EZHz3A+6DNFMxA8kmizopEVZCsPXSlEmruxdoIF9Kfcu6k5htzcvgP9UIR8NRz6u4h2gcP4EP4Z1vGmnquJwsNGxIBh49ygCZ6j/IAZ4QTCulJyNx/j9YodEcJjmKB0hc45vAs8nRZ/OSnn0UgHVzidOF5nty5KeYCovByOgrcEdFBbClL8ixZKsVqaUo6orB3f2YnDlF1K0ELQwZPa/PP9ca/uXsI2thnnVnbwOFiKEfH0mxB+oLYoOlJt/ZM/ChCpwfz5HQywf7p5DfVQhwh3NG0dMRif4Nmjpqum7QxSkv8MJifCEPLXLCJncWZ/BcKsJbSzlyaUMLllR5Ytz9EYDgC8VGkdExiP7iMfSFWszye2McQdFi4jLx7iGrUp8LgSKfAE2e3vfebB6nZYXNcxw7sfAo2CvhIqPHE9p/39ZiuEeyOlptG8tTPeefoDfVw8QwA0GfRDXh2NgsANZ4naFkPsBogMOR2gKDSG4zVW5Wh4CoUs6FJ6ojU/twcFCLKHOFNAYz7C4s91rzGbNtectL7BRWKb1oDRmwq4PjHGUFqL+0kEr4jiVYH0PbDOjTOsLO/rgtgb3k8kerq5hHH6twUzlujATmkrQoMpPE+w5orukuoxbDXI7sSIAOitodIzTvm1fWdjx4K6oX8Xk26DcbifoNqjqhjn4CFuJHm17F3p636aY2EmesBmi9UnBoZUFniKWCFStoZS7EGSWmWNDMdMdnfYBqj99HnoaARBu4KWQcShvwHyMAeM3ZBYA0eVO4cvB0mvIyfLp+LOlfUvKLyNTcZUJnfEJlEwIunFtmBxcnaDZq3NN3wQQHA8JANjM2rO26JnSqOSuzY9oq2J1Q7hDwVRKpFKZGG5anz0+Uxo+fZHbxpmLm4C3159xCyx5saWytNAFyjfrell/5fa++yI82SNIft6ym+pbQZRcY9tgLEtQjMC/yg7jgFggTJ55ebX7KPpt1KACtndSazv+7KyggPc3Nzc9uggn/Hkh+bCuChSjXutals5hqG4AUs9xqy2Vx8y8S61LI1MXiNDG8JXtRXLI9q5EWDeNozPH73RagHm159IO4GhQFTxHpmNHsBhCLmawl42tDGhSFdU5v2UI/GmN7PRCDhDZk0IZcyPFBvTSpLb1SWJMDDGEv5iAJf+D9aWZLPX/UyjI+3HT8TzzjqNPZCMNKOdqCsoyjvPiI1q7zCdbcNoI0Q73NUH1m7zk/XALv5Im1bb50JgrlLl7UNSIbfjG9pF0CjMncqMZ7NaoMNfREN+gRVZRuD8heXHjOlMhs5ko8ouY/7OXRkM6rQqptFJSi82j7cfZFE1KzK4O+iiSU4ttpbWIltCKKadqzI+msnrMqGpC3Yl92acno4qqcEICMMqS4hlTF8P/I0Z9zeqj1Z6Lid1pQsT+TNyhPws9ta7ujZjGECAhfNRhUscvP9SjUpTMNCWqfTRusnRl9mSYgZrWMS9LDrqAm0MEgXGKU8hNYKhkXlaWACVaqm0yOm87OkasuqvB80aYmE7YGuoQ51Bw6Zooe+jo+Ck4NsPXw4wA2t0P35K1UeM9UvUQiTZiRSEOyy/qE+0A+34Zf/t1D/ldgiybzfqp6QRPA2RJSv2Yq1B3Z/RasPVWf0tegB3BCGVPNbHMCrfz5UPViVhKkzUi3HA7XqFImZ54UskQtHK1J2icptOMMg+SukfmqbtqerBzekT0hFzWZtFp/SyWgQRpvw2nZWC/9aP6+0OHL5A6nXWqqpU1VRw+i2o10xs7o3468uQtbBR7r9cl1+vpMUXclyP0sdQv4+SuS/t1ibgS4bbIskchrqQk9LCyV43VUHcW+lRUM1UMA9N5V9orTtRSySAtCUgdV281rwTWLo8DBr73QA08tNY/O7r5SWeIOWgJ/mNtt/+UdlusHJ0UnTqEcceEL7lFJ5J/qVoK4l+FEJbKYyzyXphPDI6ZG/1ahKU5r6dFcPaTZ916jI3Rc5dcyOEHof9/uWBWDFuIkZGVdTVyz0Ml6r2uHVtX/pMu1PE3S443pO9rPiANciJdKlB8rUaQR+K6eP/KWZhg3VHPsgB96JHcIuXJ9wJginQgR7JPMQwp01YwBcTvWz0gAra+dl8Ae4+5SLt8kKKK9pdQHDLMaxRgAIoyQQq0fyVr3WMC6eqbEYd59z/T8WizbyZhzdDbpp5w9MpXdfBEe+VZKxcIJVsy6Hat0Kw1AVTm1WNGsVb1ZEALMODXBpHYeWAS8m1SDSDqqezrTWdz973VpuwBvrmokMhfrez07vvkgeYc4tsoGUP+qIJxgw4XmyHExgg5EwyOq7Rji3CHhUWgXzvArQ4adsniX/XKeQ6RpiTy9Bf3izmjdi0SIWBhv/4e6LbLq30vQoYF6m9ZijmAkuGHPZ/MiqcB10nsENnLiC2sBPyGYEB7zCZDGl7xnbz+p3abnvVp4cW9lIM63bpSMpC+UJvfvK3ePeKpeWwAJEBrh85hUqZUHfUDorpnW9pGZsG/JrTHFEo2KYw2ciaiK5TvTZdhXt17LsgSLl1/3dWvOLueQp0aJjmiVkKj2sg4gvQypzKfGuPnE477fBOAzrO6X7sYwBb/qETDRPJPaMxMkYn/vBz9VNPNj25c9Y7zkh/O6L0IVv1d9UUIreqy9ReMaQo2G9p8AvEPB6m4dKBLryiENDtRENVJmTC3m4F0DiHBApWtHWQJRX97KaS1FG01I0fvdFsgjzbwG7hKN6gK/ZLpDFS6vo3VfF8ph+xAKr93kw1wagaO/SYlJxntORFJCWarPK7s84sKYWbPL3JWP/o/XmUe4Wf3r3RSCW+VTpfIqt1zeUT0EPdQmOeM6mo6wMeeqcSvktCFMNUv561mcai9FeXK+R6Tu+L74m0fitRRr5aR1bJddBRLoz/KWntLnuHHhTR4MXRKPN+vUxti/aGPPSTV7q4aXavLT7IzLt9oIFFFwuIYaHbshM2d0XQSNvLckv+GdUvS6LeViGBve0vU3wCdZkjhKDfxZWV1eBqGzobbuZlupZaZ8JU3MhayBYwQw+vLs1ResXwonjnQ93X6S++NZC4h7KJyO3hQrEyo5aUV3FJoxLeOzX8uu7X139mMBQyo+HT0sqVmHiFlq/TMudsfzBiGrFVVaSdkLgrCt+7n24+yJr9K11RHnPSwujgHLTHXEL+tPkjBt6vULS1f06SiRXd9Nz9Qb+VL9l9V5Wv0zLnUFb7Gkl9gUzNPVqgqo2JqDyuy9CLpjJg1MRcM2UCHicRKoS5XEqYk1K5unkEvRhS1Nb7BE5wL3FiXFajANjDRt5tfPrhopLj0cImLHC0ECgLg9wYJEvxaosDRyRSwn/lcSl7CnnWtNWDSJprEgWzBFqIfIYAfB1O0XCwOgYREHhU+majqO92sAvUKjm5o5hjEW1EtoKoapd8xWWs+LSyMZ6L0inBmV3Mi7odjLSnjIQZLINjHCvIwiLD3dfefZlBg8SaiaKEx3OiDHOCUoBQXRQA8l1Cflnh4+qvNBqSdmB72vYrmasHuMAeaE2K+w+MRIvO43eWpuRAHxp7r1AUQ03DcSa00Y0tZeUeO1FEgiBIJJTJdgqdVhwIDUbWuJhurRcxxZgd6KqpsxMVfK5Qn7uZx2/+SJY1NyM+tClpwYycKsLOknSY7UeA6EnmK2GFFTito0nR7dc+I5TdouxYbx+kdU7nijCZmjUfA5gcT/tOpCWvVBgwjLVnwCzWiV6zmArLrCuU4uwmCvuk64YGcLIE1a0zYu8D3QVZMHsjWCGlifQb2DuQCt5I5lAnaua8qTL81RvGVvoRdcflievyrqTFgTSsMDiZB5VH+grSHzW3tptAFGALHHt45rDyBU8ALpX/+DzzFKde6gKZSQGAMoJ2rWUiPUgkI6FpL/BLstmh1xiAQHs/48R8X93V0H6AnVcRG3yUoaetnJ1W901AwP0EGZHdtqxQNdGspB+NKVV0eocwBT6OiGjvjWl7O4rD8RvLVdAwAyqo2ozeHguQM88lHuDHqW75Fuj5NGcQYUkZYdpMqtjkLIH66jOa/n3S5cwob7ax2vpQCz+yvNbr1wH81YLPjnIZ7FxbvhgI7Rfak9qWrTTUU/06xLW9QmR2fjBRJVoTLnGDP5yQ8DvtVU52fRW8Qls1C4DWqcta8UHdyzR8SyXGYNXMnIK7Oql9AfEKhL9b/VJKkphGhbeZZZ1pX2vKk6MJ9462vN0fFkHRJ6quP96WTnhamaNLRu5umO2MqEAepAJy4fv4ZidSpCJYJlMDU1njN5Sg9OsjV8Wnv6H7MgWHi4f7r5ImmWuFkURp16fcDa1dA0pp/55XG/VRXGg5SROq1pKwJ/k520EXZfTfoQlZNKEVMnwgIg+46PfIJ4F4GtAv5Q1KcPdWjbkM9bRhyEIWmlWwe/lKQo6g0xEnyvuc3k+Y7pzXjyKNRWTlfBmIZ4YfwwKhyfvh7svAjnNsw8lDbvcFHD9saIJJn0rAoao9zpuoAlYdLTJf6pXyVU+13ZYLYgXbJP6bpAXchSrSHihfmLCilpiHtaHu6804zI3CDnxVGKKeaMSL+9xGfItLnA3sM+6lg+oVUMSJfUG2lnXsvFelOtImREq0shFHbekrGJGA/b3Xsddh/HALimjd195n8NbpaYC6zWpBl27j080kqN9whjFRGHn8raepgTR1KOuIeB54ZUpUJli9cNggmSOwQ3lpw27mticCuIw/yqQPLv5Ihjk/bLJu0Xrxa1qQ7a9zIkAcOkSb+CeSrVCKgZDCA46JhA8Oh3rzyeinxUGmFYj13bclerT1Fsd8gxTist5HG1jH+6+SLJlBhFyWsEQHtcxiNOndUr2L68M6ggMpRSMF/QE3GZVCAuUIPEyxEI598G4ElLYzuvgTzDXGRVthuSSzs9mLVzyNqr55AJjSzoP0KFCqG6MHNdqcOo6o7qfKL1n4dZM+CS9UkNEdQnbDqAPerPW1Oi/0K1gA2jRu9KnEwsY0V52tRbOtHrDij0fKvVZYf9Gr61rFoopmSoHloiLuZiOXundV44ubbqnrCwUwFXBj+ZckzBDByuvz35etm4ZIUkBca/FlQtL5h76mSpVqLKFK6ozBfYDGmEVB20V62PjHhvvCz1nUe8h1MGgbPQpcL/klbm0kYogU+1xSnGjBQ6wU0N+R+vM32LYV9XnDFea0Yng9KIaVjgtlDmDMmvKDep1WBzMoOqKNuhr+RnjIsZnCo9QfrRcnZe3o/7UFFOB2biOnljXmLdy8sPdV74nzXlWtvDW9lSAwBZtaXCKvLRvH3NP5JmPlY06QoQ2boBXgYl5lKXychUrb/GSbVLhfaL+ln1AM1mH3ePxmu86V4kGR7BzQDHQl25Z2fZAmHo0ts0cLvvad7DO65WkvMmrdVl1797zIDUQ3gWDbSMmdC6u73l690VwhhndyPJDeVnpBVnFpu1FyJUP0uznLwhhov9Ffh6UnDa6SWCwU5wxuITxpXqFXN/wrc9TFpJtcpIEjY48sQJj125p6ECv0oKHqabSgsgtCx8ojmKMiooNxwHM/POpXM/K+1ycmIkZH6i+pjmGeR8I0tfJ4gP7uVXPSTr24cByGZcW96IXQGKIJl7yzHAw6h/TfEYLsGptXt19oiCXoUzrhpW1fS7TN25M9vJkSlL0hcYWUFdrFo/b6qak4RL2TLLQavjzZRkfSxBJAS+t9n2vms94CB0LejWTCKMyAB9w1cdXdFkog9wwg8WGk6J7Ez6L28RoAt20+Ewk9kSPzxiOjA75sbso2tk8QcZoYipoot8zIendF9mUZjZekaA235TrKlEOHDBWtGnqIMl9s6I2US81DAVwnM5m06olq3JyjU6m6bkz1+uYf/7d9Td0MpWnrvTui/DIb+1oxpAxZV3BD2KkzV8qCbzgSmcKxS6Q13ZrAzM9IJHTGswpo4YnV6pQZIpG2jCdN1h/XYdNQZk5/qAlT0EcYt5wNvFAMyFQzJxXRsM59MdYKNkG8KsFGwAycP75RHIRToxVbfMqb8S8UqsyM1ClLlOXSByNkWn87oucydYALl8yelZ09JMcsT2k5PKfc5r276CHPRrDAReHDXuDiYFpRVmiz3gBVrTNi7zfDxvI9qcZ8sJ8WKfCgns+M6pEo0EUZ56MkiE5EYMOpqXeg1W+RTm25p9PtSxS++KahUzi8IS+PDFhe6vsvMhXLo+5wWyVbUFI25sWXgLO8tO611wXNOMICWrbCitFvUzk6Ll2nY5JT4aqP1GjyMCIdYMOOcF0aK1OeCgrJkWqSUtVyZck39HHeNQevZt0bIZClqWGLJWkJY28BHIf932qnEp7VfRkx6Cy+7ind19kaZrXGwCRrUyBXE60zq4zLvw6Vkw4vQksPEpYImOEqP3PJ4KTEaK8iJsVfZ8oVmSB2YyeJAE/2wY+yQL2AximPqoANB2MHNI95MBFfg8AC9hYqKXD6Smjwzh9xqobeTXkgXJFBketIfiSpwOjKJcLHOFjbpZgZRUCdUyqn1apssn2QBNq5dGOFzRZbsBSCV7eyMoh30otF7hCeT+mqdwYzXqZwyMaMpWHgvS1G+pLuTDKROWsFRFxEpWH9oONZcLMgY6RZxpMMuD+BkLHi1OuUzbcGtWFj4KydJSZ2Wza3pMDXZYp9r+acoKu175WoswkOs48J8gTiCfKEwkKsY7oiaGil16WxR0+0kAFymeq16yA4xn2RHIQr2nSMfkWqoMfkgmyxJFVM/LqxxPEVkZUma1jmZeOt9OlsX+mAcruKNrkgEFXc60oQ6TlDMpspUTY9zX2PK14a+MTpA5Kw8vKwjs0nrxhdGedlkE2vInj1wX16ChqaFQENBg+p1oUpl1hjVV5I9aPlsy6X6ckXaaSQ9yPA5zffZEj1jxs5CV2REy5LuDfF93cNqXK3EQOah52HUi3qRq6SXCWVKF85PYoF8hrlFlN84kKVXbEmnkbzFGPdVjDKb3GwDIslGUTTvA8RqdKuIL0devJixFQLZofcnabseGkHSmvf90rYJowVs6gaqt9/dSc6c0XKYm/VXTWUKtsenagEGH96A2derLQl+u8iuEO1IHxLTeVhRUJv+7txMRoTLxGPZ8yi6gHqjUpxLZ2fwHt+gGh9d4WcpBBy9ZWSnrAQ7BOnxLbIAnSUSeYhgIF8Oc8n/ECrLiTF4OeKNZk69PMGwuKGO6Pj7Y9K7hqXKqKYOVJ2xxXdDPJGQBDba24NpQW/nwqbrBiCKvu5NWgB/TTGUDRQRyXJo2ms0UBwcdlyKFUq3noCXaxkT44oo/8lWniSpVI/uFqa6LNpuAng0q3gFr+iaYlAMGWn01JJkNATe++8rHWb9VVy7aG2w7qYtXs7/EAUDltFT8LvKgtdNUw3ZYvB71dTbH6X1RunWuz6cDsZLr2926N6St8411hhAy4VPleptqd/ZVDfAqtORDPxNlsdeRr6VaSLkvDGyS5lo90VPRdSkrvvvJu/bdKTPsEaIGyU2J3t6SpVp2uhyK7+iy6yxqqRapLV3koZp7ZTxPpaa5TpdPUktlrd0VyLDVkEjyl+jGJGO2uR5J7L4JAzP2ijq6pu5xee7k5MKKR7HuNB3CWKcDbf4yyxAvvZkQj+8oADmUyGfPJq5dJsfNmJkezaXcLhpdKv52y79oEvfsiGPStemjZ8ZdNxZgY2xEjHOXAtnYNFJQlzQszPhygxyyW5de7PpIqVpjChcitc3V2EBSSXFlaJl/jwn5uE06mTlDwu6+cQjAzADnCUcXW0qykkUGVyUaAyh9MASYWWtM7TOnmhNG5NjSPauNrOaPHGEBevkyqnXc1UoM06irb3rQSR8HN8rsvklS+bcS4xEZ068Bt5cByyakSjJkYlmwW5A7NqRVZ/GW5m4ts8NtDPid0GAFEBKt5tfMJSWmicn+r0fYBIa8SJAyBsn79Cg+epb1NsFEWSGOMk1yXrwg1brA0cJmc4S6aKVCpYJX4eKeu309YH2W78/0yX1z1fNOBnZjdaeqCC6wZ+LOq5p/bGAgl2QaMVhG65Rvc67N4gYgdqF4tlbd9X5XL0Lf5/kAPpPMogVXnaeGIj+FAiIkTw4HO8FlUsKeo6lQxsQ2Kd4JTNpexv6yMl1b9/uYFUc3t4bq6VZ6V97u9IMjdF3k/b61XQ1rS4vX4RKihAjzlZaoyqXWG5cOuVRk1nP5bUeBfH8rYrOzNtCu51uWJumR2Olt3tKDSUU37Iwe123UAw8oRov27ykRYdnMpih0YVKul6+6lLMrwMUaQljGzqucTcziyN/TWguWuPscUIKeWEqVDCVi6oquu6NFilOfW9V8hLROMG861aR2TlD2piiFXPfwYFLeqkvku351S0vKprh+DYnb3RT7gW8tWgi9Q/MVf3BOk+x8rIF2lKKMs1ye+yenXJelSdFKhLECC/+dDPYtUv1gdNy37PlGezMCJdYejhqf1QLzl002VcbAmC7IQc3OpN+kBQwNAQllPcnhdPoqPkSGEO+HVzKT4+URxLgvP5gSkMzO0kUHi9K0wP6hqmFGTYLHZQiYqmYpq7HV48R43gZfygDltyCt5eeXvicpchszeMYtZmRfVg/uMgY1qPRpE9TKkQSf66hYcVqeW5gQYVrN+o0iZAGtSyUvrfk9UppOtaSPgZSfrSNiqVmxXtMZI3NuA31Ub3px4h7emLFz3eZAQY4ZunAZntDmrZOeV7+9ZrZx5fatQq8Em2duATxsjRk9IGIRYA2SEBIdzj55AZFlGj8lDB1PLFFxE8MX7jH93JT9Ba2Y0pXlATVkV7qcKZayXqlAtR2haCvyKk5qssMVIzZwEDSDTzVEa5uZAah3mZwFj2L0XQRnWEwjPsemWEnBcCGMhfBOQR3Q4rNrAV1Sll/ZxYiDmhO3kx3yP5IcfipRZUfP7Ak0aaM3NSs6krv0L8IaflnmDKD6QplpAxZzEu20APW6AQlB+y+Gzg4jOCW1GgLOCTl4A+mn935qbTzkRVDI8CljI4Cvp3RcJNm9ltjaM8EzWIt9+3UExSfiaxUwIuuxAK9Iob16nzmmvmohZVZMyXoQhozW9vAYYadyl4LOgUopYUVS5uXw3f7j7IkjDeoKvY2czphwI4DayShIqOd/UTHuo59z2wWkT4o+J6A+k26onLDTxY4kiL+tkZaAnJHaJI8lblXeoazcVvB2BOMamYG4tCMoFdRzK15bdXPAhPTgJYeUlwKeGAWsqyCPyPTJxNZ3P+gR/l+GMtw1qFqy8rQkZpQRPprFZ5eEuvS5xw2zldBD0QCquDB6SpRFO2inoJRiZEn45QfgleZ1uzbeNKJc/rP4jXVOpGjpZbMxmrbmlL7cWXkr2omSDLYtZLj4qieW7LD9mbHdKjt8wri0DKqh4WjUG00kDxtG7LwIzbGa0wBhgaK2V1el+6ZJWy0JQE8YLhQp3I8eZhL72Y5OQYctWQ4mRKzqYAoQL0TPh+gMEbnpAWzuNfCotlHb4Ki1v7cBwYDl9kE12HfzqRL3NBr2Uk5D/FCh+4/sc95M0gfO9GT8cwX8JzFTP/d6Hdo9UDJx0JPvh7osEZ2shRiaqk9oV/iyfd3mQCABIa628y6s4nuBVSAC219ab+c2yxC9PEz9xfhlH+LVAIyOY3y/LFjRXhG5DzgsTQMq5Lnu64FMLfkEf8xXXDwDJMF2FnIAnbHtSOQdTf7ARXrnhws3grKHcxFAiXh+wIO1wBofefZH9aSOm2gImMD9FOYItQKFPX5ZqtyHmWwLGig5n+fmjQ7An8ozjM6NYuYtUx7igKxOA3QzmVlC3MJFW0b2sttWCwGQ3XyQ+v22UoRxtx64LwDtXOHNcsJm0KuLGIdT9OiKKxnN40O56RZNZkiqwxILSnSk7+uPuOItm59AUGK6ZI87+D3df5O3Y5IYmyfqw65iUYE19Xek2rbrhumDqEs2OULFaFcSQ9V+02MFqIx8qnVll9G9tZcZSmCEeHrAGf8VvvvKPZz7O8iza86Ifr7ud+pCtLMeEtncUnfdsK3+oRYfmPaitCFr3EcqM7Ce1AV7qyUpDTxhZZx/QrD1RHd5mbiBR2K1Kx9IJztOKTkWe38d2YLFUPforZpJUb4dhVDejxnmxIyuOBH0rQVKxrbyypmccJkXVGLbF775yZPq2se2SyaLtB+8KSHN5UiLHMkI5xlrLdrynwi/JrxFC0BbYMBD5Y47EcirG9ubs8E/x0qsTxz17G5qn79olufki78cc/5p+4Xpdri7LeiURw/CQY++nSMT2SUHYL5qWVy24HxeaMqqflQZ4reN3ZSRYDwF2Kj4GetQiLQxMq6OeD3dfhMYwE4GKxh5zWK1b530bjXGmNneBs9w+E5HzXZz1yFiS79n4HGaZLURte/vIeswYiVnIoxeFsTbAdK9whaj4IXOSlQA/T0x3zmkfRhNR+j5j+5+oRWULztydmqQaOoMe9uC1jKCGgag0bE1Bdd0chieiX9ftJusQlYYa0xdyBpsQ3rRylRW6HtCeZX18bx0rI/8M0xV1IN61reEVR4msUVjBSNipy2GWXD5wlW8qJ1tua0SVakTXRmbWZANugr/ovRhDsQsybTzjajEw8sPdF8mvrEewQeneVPECiyZ7dPz1cqlwqsO6Yxfv+5cPe5mRQ0c/hGQL4fuS8h2MH/lQt8nqPD/G7E3ZKWg2tENkyHGy7hye3n2RpWl+ILA1xMmEhtQrVCISkDDU+9jPy14aOwZESaAApa79rrItzMiD8Z2MH/1QvMmKPTeFg9Mfh3ZXVK1p2rqhDL/7ysWRb5UmyVKVxXpgnTwvE7sjOpwNSz3UDNvyCoo28m9zZFUZ7yohNcoVS0TgRE0/E4vQLwsXSXZhUxi2QJZpTdh6ksZchcsyN4gghi6Av3z2Z0FRGKSMJImxjhnPwXgRVuhI6yIP0PbpsrSeeImQxz2CESrNVRD9c+uo1LgBFMy4Dr5qoonLaofdmt8418e4QU7zZ2WBJ2j7DGK+ldFZBzFRIeOR1WivGtvgFB3hDSXAqTHsEJb5HQgFYF5B4vrA9HBmiNH8eVngAfI6Dc7WXtKa+mngekFv5XAwPdGBZ6Pr0ULZo7+kwTjQiuoTDOlHzM9SBMp1Z9T4t9x1tj6tXRLAzstE8gvazSJMzHWveh3tzeceCVt2OWZDKaf63S2ZUx2MGuFUd0aN3yX4vnxG6inHi+zjDgD87isn197aK6WPOc1CW1C4Kckx9xSphFfsZSdYMUeuy2aZ20rkC8pTq8Czij2r8LNerLx36wnqOgvRZuEsx3hpFqLlr5rVMKCJLGCjqCu2/L4tnDcKTRa654qDn0IlBq0Y1Z1T409w11mEemsyhD7ubeZ7YHnO9KxEgCgWihYQ2zxXeNjtpi6OWnCE6PdjkkRyKiZxypnxSPrkUxSN8RDb4j+qurtbzkdvvsjHe2uuBvXbMEvC0+cckXwOiVSX5XZwWmlhYZfnvCzny3PE79nYLOSYlh4gFdou6FzqdMUbBieUBas4LYuhmGLrGW1VXYfFoYomK/U2R0gREANMjLzNqN4n+KjksDE1dZtF7YAh5JVA4rNgkOUeeAPoKG/B05bBCu5sOG6OHkJbDvn6+fRnaIETWBnhdScyIPOVab0uV011BD9PZOjdF4m4b9VIHRSLu2qeqjxWiWIhzgWdcHmhmFQt4ip5bjasGEACHZv9PCtekmIn1WDlmq3bAeGyl9wwgjWc3FrgeX73lbb1vV/2obQmiJ1wArRcoOcK8ikUDZdWd/9ScYKgb5zicj7IbzgWhJlmgSgc6ISWZJ7LA3OmUnbRxqIfiaNw5Khqartv72wMA0ShCJL2sR3gaTw6GoIhgZfnMSjL2B5GDjH2MiU7n2AxsqPWXG03ZABbr2P8Xw2XWnnDqBvhSJVHLuWeZ35ZCwTqJn0dv86ALwPKjPXIWZJ7BeyiFs0ThJcCt4p5vbEC6N1X/oZsquoZmH6lUywvhCHnGOQEbsYLo0x4Qjd6EDmNvSsXduknyoNSJIzty9nBn2rM1CnJU+tBRWmQcCbnN1+ktvLW2goCu9Z+tiDJK4zJMMpHBf0SfzBfKK5rM+ilv2Wd0yz/otQ9ofpp6Sat9Hxp6JrW1d5aV5PDDdga1CHs3Fc0xUi8WsvKhHAVP+HViFYd1M4r0GJblt7QshUrc7G6XV7nu/OYojgdUMszFswkjTSG3XyRpWkD1mStI/tTCmpitIHTDPI0y8bAbkDYYB/ObIgwIO8airxhpp+zHowlYeLGnBx8YgBRdiq/VVIku0sxOQabSYizVQi5LIZjmBToyLJuYQZzYhCahH6JoG6+ziQLTOLAJEu5xOmJLsKsrP7Wsvpp0wbBLQQ2LwmCRLjwm6xsL0D6RLug5B+jT6uUV1RX9DorXbNSN+lSzKr831KYCSS3Hgr52jXyYbq5nDKWY28UAY868KkSovXg1uWz66xAtLjLyR1UfJ7vsvyYU54ZRfpja4mJrEhVcbLru4VgId48vfsia/OtcpoDZy0fQwReRZfgRgK1YziRwPPulw8mKpmt0Zkexplag6o7mFYn1/bcFO5aCmf6xrhp3dwb1SencOndF+HW3yrKQosyglPB3K/tL65BNF8B7mD8JoC9xdwZ+ZLXMLHWapdLCqhaKxd38V7jrDX5CQY7i802jkUQVlNGWl0HnJJfQIBb2Q5MP13TwTDGxUI1emnMltTsKkHV5YwfYwgZ450z5E8w2FlOai1kEmB3MdEDquo+67toJydiMMQQQP3G35jrA1J4dEHW2U5UoXO+J+eHPjHeGUP+PYOVf0Jrv+hVIpVdx8C0NZ17kZcGQ06VzMvittEzlPPhFFbCeAWLUaBJw0fGxFEj3X/s2T/cfZFMw6ya8V6GzTRGuB7RS1Alrxn28xJgvRZ91EJ8aR31wlDEusNqM6c9GE1CKPyc8Y9djfioPFUBeNP4JeAvKvH87ovsOvOnxxxfVEdaM0B3Oc0kUR/TIdRVdWihxK5L0N0+BmrI2ryioJazXoQlo0R+yvvfUoSjovG2lx3eA5qTiGr05ivvdnirPqFjgVaoAsrCaaSEAiC8OqmjdoKXrCFX7UCPfDRVP8l3bP41uWqBaBy4s3HigxwwBn7P2u0ur02bRFA/rkFe8rsvgjaskaIDfS2bWAxvvUillzawaWH0XCvaKOS0L/pbsHKv2T4m/Iwg+MDdZ1z/Ty1qq8uBbKvqg3Hnjw8Iu/nKNSJvdTM6AxJHOORC/2A2HQMAFt8DSonyTY24jNMQlfkNpyI33GQF+7y6T3ySUleleOs6DXfBr1xLLJjiEYal5NaL7MO3T74oW+ehDBCRxagWsHFQ+9l+m/JY3k6okzVqs14QCZA2bYliXQaNCbmdc+FP0NVZIDZvZnnl8Nsdah69S1gwyxO3ZQ08rdVgmrB7V+vW8AObgv7hpGfIgLPbORv+M0zQDJ3k5uX1xR3bnd98EWxpY4O7vKrLpP1YE4bRJYRjvOHyAb445gzSYhVv5bytOmgmu7xayaqbtNMga0x4gLFMA5LJZ+GOpec5qLlafN4WHGrl4LAiYIPtcfPzWWKjORPJB5evyIIBxQUMR3CGM2NEn+CsMw7aeuC1/9rsVmTPuxAE+sjS3YVF3qxPPJ4LvZxQqCJ4Ieu7gstMKU5CiFKCO+PDn+Brk49nTbPyNeiMc1Dk8qUY17B0NqPpftH5e9yzZqGAooFZGXi0OFrOQWguwop9IHgzQvj71CUPUOZrC6dBHOBjYOtcPQD3KkddWEBJSgq1YjxbDvRZ6pKnOg9M2UlpZXNzGSBJpl5vUN8arQyOWYezmquUHFAhch2XDoHQFgf5GmIp5iUbVuLhrHXGcn9NxGYrzlpBJTc4OshLdiqe+HhSvOXL7/bzslVqjEwdNvlIKwoD49A+5u4s1+e8bcbzBpIZ6JdHyO6ALIrVdr29nPjdV443TEdbJGdwo8WNHR3zDZuEIdX1bB1aZAcR4L3AfoW7eoY4isvhLgXHjLpLmb6fEsSwcC3fz7R2n1Jvq3J+90XKCubkBMpGa8AIbeeycxiDQTZkQHq9yUs60faCwSlaIdKZnd2OP1azySs8H4oWWZHjh4rbQ9c3LEJs/PE1bxtLfvdF1qd1wo1+1FASvP/qrg7D0D9lQZQ2w/iPSDbRXdmVicJcuBH2g2mOy3LiD8xVxnT9BL9hDyYZUTWuFSbvd/Bjd1+EUzcrt36m8gQX+nEvN2kYqoJYx65Di2zLX2I+avJqdwyD3eoeZLRsxcpcnLPPOP4fGfnyPi/v+IFVaSwAevNF8KYNGMNMq2pqN7SRGbmsIyDXXuaiC+TtXOyB7/QB4IARzWyX2RowrQbTdnxQ32VqvSeaIRNy3awcOyy2ll2X88giFAY8Svarneo6Gu+650HKs6kvKwZIrGbpD63ZkBrPB/I+4fqf4O0yvG1iYjmowSXphMMmyOOe6ax72gYiwpbp8kQMtS0dnqSDG2f7nP+RdJHTfBkt+ABvl8Yo09MPaLbNc2oMAXGXZ9Z7VoWW8KJS7s0TcXlxMJjVUQo6Jupj/s/4As7zZbzgHQGua/k8GTvs5Q3LjowQQO++yB61cR0YJqBG2heWq9eEYUQESs8m0sgDlR7jOuSMRgBx6VLYk7LKLav0cr1Wpu/6aSLz+YlLTcaxy8/+qcTSuy/yCc3MWXIge1Jg0csdGjHYe0zIX/X6XO56AWe6VnxsZkEhL+aGp/U7Uu3jheus0P0Ehfkbo5mYHpZ7qo+UQ3cjLfSMu0m4xk7vOgBqXPfwBclE8aVgJcj/ymcGgDEGTOOUU6RPyO8SD/63qvLk0QCBFzq3LjvpLqz+jiHYEgkE8loRFQsVv2LiqnyZ28I80+oRZV/u7p+OAniCyctCs6modYpt0+twkd8xQwX5zmXtDyciGU99OZeXUH83mD2XKd4xXteqDLvcrc387itnjN/a4nXsCFbTaPkqw2MappjYluhaxQzfuC6pllIZOiMMvQ4KQfIqNCta0wayvOHsO046O2OsI2DAI7vbOKDSih3WGy27ayw7S+QkmUaXb0xoQKJlbvkgHKIjIE/6WJJIOOyc8g5WclTtc11wCLmUdlQ9lpGS9OaLRBiTUMMv5th1uEaeaExC6RcHTO/qr1PDbAZK2WXzm+cVtSOKeRhGYhxmznneR3jB8VJUjaDT3wVlQpHlRzi9+yI0mzXFQdKDtAHuCqu1EvIwuaqzzyD1WzEaE5NfL/jt6e/ZRhx8YD0YSUJYvJz0uw/wZjPF5L2icRBPKInGbWpA775yjtVaYQsGk5rYb2Gbhi5U1ogyWDob0DWDMCQ86hGEXyPLfa1gH1MSk5GejMLNGd/vGazk5VhDmKC+4/7PBx6uzZNs2M5NEz9j8oo3Mm6gpHqsSf2CyPdzzk8oAsZ45QzZ94XnROBuU3Ll0Zv8HwS1Kzx1LrwaARoH9WgBgK3HONyz0byKWvISYG9HRF6mZjVt6veXuAM+QdxlQdm04xL+MbFbR6TAPuk4fjryj7BaURIs7TKZIHylo28bz9uWde5TnEdwIWH6cl7wCd4646HN+aGg83Y6WbY9gcIs73mWXx+CDlbUZxSpd/09Ev1XaL7Tsg2r8jCaO2XFn0jcs0PJNFSogxeT6uN7m5GIb2/UHKpP7DtG4GVojyfueaL/vZIgUXm8VWDQ16XeFKDMjyVgCM8YFL60rx6kig1AwlkGzwB04XcB3obcmO4gFylQ14vEI+MJBjYLr28f3TIwtEsZf3TQhw6oC/icpsjGSDd7Gp0Mg+xO4y783u/hvTlfwfgNxtmmFO8T0zQySt0cidCKgw8I4fFCm4buqAtHbVOh9oaplo/NkHgA3kTbszBerAwDtbRexepbjLLPKf7vDckyStkMuSRDxJmkpnieVoyF6k/XWaYoliyf8DlURdCGTXpCcmTfFi1YsAIHI6xzgvsGL3Eyo7/PRBPrNtT/cPeV51VvVfeic8bVvaA7bH82qPwKziIoMDCEcsV12UTKqEOBgSkQnxUYTLHB1MO52vgJBjLboaaGh+W/HvDg3yTxCcvRPobybHJd4vu+7hEB6wIzoV/SjkEYNNtj2SFnLDOG8wECKoUaJh6FiRdqxBj4Mq+yQjwiCwPt5EoK9j3De022gHWpYVB99VBH8z2WHzLGKme4flpBtg0C3gf9hNjkY9YfUzZ295VXFcyUENSPX16Y8xdmgvKprma9Kjo53YKATvFuythC/YcWVb+eV61YlYtVLfIqx/cJfPaCTFM2MUS063W5uu8JUR1TD0zlCDwfFrU59GH5e57vf0fFZJvN5KAXmvndJmb5qK+NMtNAh4gaRsgPm4r1oGf+0pFeKNFBihYkaAriGej/wNxkTM8TvS0JN27eougsNfK6IHoaZX50HHGzGoDABD9t5Ozv8m1M57rHHFE2y6pvrFjHiPecp795GMwdVZCCviermtRbG8bvvshh81a535GXhgWL6bBoI4yxHqhNFiu/1iZhPUxIoPBfNkwVo5Z7tKDn5VdWrmVywlx++ISzcFYcMmfhUsuxyyjInhhQ2YqhWVwXgGBUeDd/ZMj3LpCw2xcAq7ywQg0rPeWlqnsF0On2fz7efZE3ZM7qmI8NOxiUG2TR+ScEqX5dfl1g8frbzHr5WGY2UOF8HEWzvPjGinWsAJ8X7J/gIjNu0dqb5taZdarWnjN8gs4WzHdMBjbAUTqNJFEVWSmyt+41IMpdMa6L8JY5zfkEEZkwi9bVC5UmigHoOsZ4MTMbu7TWoEanKmzxAxvjb9apy1gG2d51fOZtGc/L5Jc50/m3AUnatYYN7nSjfL6/DUgid1/kDb19kE0/WOdyXfKU1WKqTpGN0Y0TLn3syEIFdzfVwYA2beeeq5NnvyRbpuRlTnY+QMulJ7QJpNFrc5kiX1Cg5xVHZ7oU5Usx3He44AF80tY8T7aqvKwdbU0p8mVAmXN4Gef3wGjElGUzQ4eJUbx6uUr2czsuwKx6e9J+Rg+fB7TbHsvNEajNFpgQ95TnJxxeyvg9wOWkq/NtUxzq1KAN7ls2fw9tiGQdl1Higk+vKxIw2R3KcFT9UtaKslqe+LFEkVE/OVX0RCKXLE8TE1VJNbXwhcA57vqZ1syb5mtDNsGNy3PYz/O4LO97oqKcMIc25RgOdRKTMc2iI7vH56jIoVSvjNKuwCt/P3i58v+wxQsYpcsGsfIKNClY04aopH3qAaf4lGgzcx70nCyjgoaNCfxLqW5o1FS7t4Fq/JCD6di4jlNKvWwb38YJeUbgMyIvJ/5uZmasbdxLdyMCOfDv18/vvsiGsynnmDjqG67BzD7q5Ggdrj53cA93YoBpsGAf9wKFq3v9mP2xZJEROTnx861DS8Y0mjkNrM+xylFkk1XeY5gtDj5scrkOinyGxTv0fQrxZYNI2hSO8DmNS2hfSmTmxOf3dcVEuvPWcqO8MqAUfOsTPhr4FPLEq6qef6NRfHlb4qWzSqEc2jq89+pRQUyrkKRmSSy8UsOvB3xJUnbJrHmmIM1habPAh7HCOueUOjzNVvPO0D7LQbd9eosAkFlD5Z5T2DnhzbirnOv6ug6V1Hzf2pqMYV1yZB5MozjbmjVhFdQ6Xo1qPqrjEbl8kNRt7UYdPqaaFa3yChexak9bpL9jrLIgZOOMZdXPK2whjrdowfV9q5RcbSSaJKPVrwvYKsYmY4+cIE1TfMvgMKtS54TYE4A9+YA2BHGjzNX0D6LnpAfJjL7QaUaQcnjMEn6KKcYhgD2F939LQFWtBw91bcWT0xYR8U5Ayd1XTqiZp5A8wVA6AcMILh/UhDkzskMvuw6N7O0pJB/6QvUXVoE4gqM/IWeeGVNN5PI5v3fnn/LedV+WXRRtj3HP9+A3XwRR2VyvDpzXtcjUEP2s2HOB+igKtRBPlrsmoiIqW0s9YTom7w5Ts9PiEytWUc1gJjH8oZ+qEmwS0Ypu1wFq9x4KQO++CJ1i/TwVzbEuT+jD/QUkD4Zmw4mACl42Gnrqhi5ACQWB+iXS7CxbZ8n9B7rmN7nzwz0vfbyuPpSgVzAx96aeyc0XIVPePkVxqhwPBV34k4fYDcyld2FVTB61p8GUxoEwgNiM2HDCGT6nqnJii1M1GbXzAPWSvRxrZKg4Vi79tlcry60i5NkA/+0tSEjbNexyBVs1WPdjVM9pZvNLk1WW23KmJmN2nqAeEi7BWpOR4FYDlBP56x+jwAY8LavhSQkUhkuXTlff1oCF6v/+zNQRZo8zFRmxcT/9MLvvgUZuM8yVY/cm3undF2HSzVNMFoJ1muHMlQV3z1eTL3NuJ5K79+ChQiardoQrbrs+FWpYWYfQ9DmrH08P8KeDfiR+6H9ghH0MJv9w95UvThNAS7jUjBw0X+ndEzJAU7NNQtK+Z18hgJYMdpagEeu5E7g8sWOJIGdqMmbnRwI6tEiKeoK7pqm8NDSg7O6LnExmi4/OBYj2i+AmyS/sk8OUf29Nygu+jOJpmXoIDYydQaVKvkmTwNJCFStscdVFptJ4gq3I2AezZcC8LM82JOPbFv5gbS5f6bRZlKsUPxEnlNmXzinUvPQYwGFEJaE1ObWRUSE/vgzmmqd5jc3sveq9AfjdF6kjmZ0m3MyHXZdYuezww2jNXqz6I79m3SabgAPL2jKbHBY95n/mZTpS1WNFqryo9cRA42x9moc4snFQIwX/WaZPaD3/QFDEqihwAN6ea3f9/Trioxz0ia71uUxHynofCrVZYfcJrioLUSYHbrD47Ub2ChgfoTDAkOHLrreBwKzX8d4vMxqCHrT4EqBpH0kTP3BbGRd2D3PHAtFUFZJETVVnvedi8Lsv8glNRdRO0WQDoq9ruDIbIxnLujxjlRPbaRia+dFMNsl7vyXfMjLNTDnQJ3eZKadsYD/QJprpsM+Na0GXV8iPBR9CB6Ncyz5OVVOulnG7nK1LyL0nGvMzUsmMGTB75jJkccrw+Dzk2EctwSaIC8TyXhyYWh+0v+nvmTAujwGTKVtJ2U1OWmUk1w1plMIpSiCaZkCpJUc07OYrJ4veNlBMotNR+7MLGCNKAxWwoKM0IAvfDluUwiVQ4RkLWNVh3jO8TkHKGkQ+nYqtn8hhs5z0bSM4JNJeNkNXIle9Yh6InMNreL4WxmhgNnQVqNBbVvj/T9rD0iSS8qYJ8vc5bJaTvm2cUh86ewJU5IX+H8+wYf8WQOOASvHrG54Clmfso63zn/J9xg+wnDfPkR/wY0gZKXPkkBA9XLLTu+z7MGjv2DjWLS54yAfxwtB9KcuJgHAt5bf/+sBWM3abM14ZQ/ZEHp+tUHMYlL9yfAxFOaOdcMeWM0t16eDKRzRt4kG3OqZpeFjuaE9zH5Yrkbw/pwm+HlCc5uVvn6eHviOrC+02ogVRVr4ydXD+jGoRpvUZCDSf0DNKcDU558M4Ipb2pyzBAzAuhWXWjS+5qKYxDdbF1xVjoufqy3375ZzwxJRiHobictT3RGaeLTczmNLmcLsuQLtFSbSaVwMuX33VKwSuB9bsl9FMdQT6IjCWwV6ayeeZ//dlxN92ATba50j63bSkh14CO4Mu5KqSGB81qZWT0WhUFa9KTq6OtnIgmVUMKzmSAiV1Ikh8C+4i2rK+HQkumG6oVDswm1fR6N1XXuJ8+zhgpSmwEuVdGa9eizKHWl1bU2JV1MDkUdbRTixAPftZUnPLK3S0hTPp9/x6nkvKKbxtBK4kp83AI7r6SvQhF8ySMZ19Aat2/Lpkp8vBeY0RIISxJAQnYyxSfuMJ4XdGKJqTktzr+qXAKQJjp/QA1e7B5opVSSl6iZKUoHBD5uCW5az8XKoipS3OWCb85veVpwxT20wD9H5Ba16gNTvVPh16o7f23KFSJS+vO0F2QY48EP8KtBxITPx6XqkilS2qLcq1SA9Y6aUp6FtTTUT9YeL83S/vL56CYZbuTAVWfSLu2fUlZ261jEqu+k6mhB0j+FiKm6fET9gI/ebUzETowgF4GQOHLpuQuMvTFF2IODzaChOhC0bPwzmy4TMKKF/P+H1O2WUU3wMTfVJOzXykBKzCQRbX5UDyjlKdrCPB1K8LFrhCnC/phHXmQbO7fUQToSwZwckZu4zhe4KCz7aoeUOXJrnY0euCLNzoCLSY7EfkaGWgfF5GcOoSXrR4UnSK7mWYk1L2jOJnxeq8uP0EaZORMG8lWzA4GSbNl87T8pxrwkoA/JrlaIIiS7TmLvkqq5E2ct1H0lCWi7BilOTJSaGbu8AH10cD1WyArtxol999kXdkforyr9TvtaiV4XJToY15FGNanQTD52IEpZwlBclrgQqmu26f0daU5mZlm7TK8wTaz+C7iYnkU9XLJivuOqu5IR2EuK7T1TCXYvQV6Uia7XCwnyUHD3BRCbdkem7BZPaUFcRJnzExakk6hvUJvwBBKPs279/WaVsxgETHrn7I3Fmiz6mrjOr6nozKyCXr5RCwpjNXtOrlFYIFVfLp1XNuWXUjWjw6Xr59K/Jy5u10mPB2jOX7wFxlTNcTPEzydkz8iyDkzB/IclfbCyg5232r8Qoss0ZyJle2vUy0pN52KXmiS/JiztpkLM8TPckZsfZWAm3J9zYMn8sTe6fZkBDXQA8Zbm91uMRsqdvPsKL/XMcTVcrYM4afEXc50fc9EZUwS9bG1iG8bnpZvqFbHCR55PK0Sn6tj5TF0C3BIdOyMMkU9w5pVE7cMqKXE1cZ0fV9KpulptbJBgGDPueUddg9NK9LDoRjZp4oI5R6Qu4koeUcQ+dydjsIYbwdYfl46vs7Uf6+9pIwDDbUph+0+6AkMxG5rGoiwUHCgax79Jn3vXZUTUbRExKOOfJHbHuTSg0p61DF8G958QPa0TQjf2vmLVBDIyF6SMEZ2g6GhS04I70up/eaYU+wMGvIIgHAiA+wZFQ9o/ZZxp8zBE/ksFlOat1rAq9KsRwWX4zPn4Bhu2zRY7FKUP6OIR4NNeStP3+OEgefCB9GEPGcN8uRn5CRJVnpW7PPKXnLsstVgkwJtdgBtO96HfbEnpUeVYSqgwRkz+ia/0T6MJKIZr15lvwz32caRtXx7srYnHCi4Ddf+SFuIooLh5uBD0Hm/v4xhksOA0dqcopEBxuBu/TQz0HC195CaYJlLVwNTER3zuyOp9hmyhLjOgYxlHtg+tAKlxa75Pe60yHjcBjnwxO4LOF7godOWPK3jYNbC+sKr2pXHzJygUqVH56gp5t86it8AM8eKPHCAgaj4K2OnrLWhOJmPT9ph9ATmUuWi5gksmiTCS5PwdmGouBZCA80K3S1Il/qcDhatg6El1NH/t2egVJTsMuwMUl08rzoh4pDoEBy0i8rrMjC/mEi6N0XyUVMDI0ijMKRA+lKW9Eqiz/fzQ6rXaP2GK8moKt1m7wx5WPO8ELKMz2WGeYahTwzuhtXCwSUCFAdf1YXdr/7VtnNVwoyzAd5SLwpJgepkjLZ4YOU+UCLqJRwkUV1BYU8BMeqSQj2500qEOqaUd0f5CaZPOUZE5LfzOJbGcQ5jpHfeOjjUzpgrY4ZWcOuC+zc4U4yYZloaj35MvzHCXPLiN6ct8xZzu/TliwRsQ4QiOeUI7MyYovejQYZqUEM2b2u+IXnuWRb6raP70TQblxPs3xGCrA8J8+LnmhfzPJQ61uVgKkjdC/s0lpDIDav1vzHUV21yigGAbdhc+Kbim+9fkY4S8Zxfkhzs7T4gXkOGaf4Vu5Qzqqu1OQC/3kcShUwCNpWDal2LV4RxxiG3mx7bkhAis8FZ7Q9ofkpZ5lznF9nrmkmal7YKAp3G6EiSUe3EC+Zdd3gPQyrSOLnDSJosUa77R8fudJ9gC7L9AkxQBLdPC++Aex1TON8F5zk990T+vjdFwnPZqg4QIxapbDIzr0ND3fTP4/rgn0Mwja4/TXzQZRvSNanT1dnVQtW5WCFy7zQ+QQHn31CM+ESIIPRYbje5GspYZIFHf62OsmQlMxIB8wiQmpgdZUmy9MWDOPsGcXPyjZ5mecJCV2Wl1sDN1KUZdflRTtHA2/PjfkblqwVuHvqdXjr7aHdChhNsd3enzJ9jBnkeX/GEzzgKZvm5WYIL+teB7ojGNdh8HQhpV2axcCYXQDKPXVyYcyMRgaBx6N/5roIN0az/pwluLdAn5bYmQq7qPH07anK774ImjfR1RRghjMQ7KLse2MRYRN4lMNSl2p5pT3cu/O8l8D/NFn4PovNslJz+j5oNL5sXV3RejnhYXt0o2MdlruHB2P0dLLSpf6l3VIcSuIw0oclvXmS/IS0JmNZrKtbsiDsbmBIWLH7xr3UnK4EtsQcOb2OlARTNA2LovM2fEBzIo8Rf5zFyVifn7oiJsMoNN4KYFVNe5cVyc1Xmmi/zZJbZ9yCpUXwsGxGVgLUe8qZSki4TrC0mD1yOlhaWSl7fyRvCdVLpGeZTu2BJDZNSk0IDJzhtPeBvV+MGj/4IO7RPIcnbBg8MOGk4pBd1n2MgclzfkIRsJw3z5G/z2SyzMT6AASxdw+n149O/8Dgyqil3WMqAdbtnt3QWplOrNJ8n/ADNOvJs6Qn0pgsLzFb9IMN6ofyVkWOUWsQog7bkyCS7s6gU4v9FgFJO9p/cp6P8YJMqJEnSc+MZPudkls7cwVCc6XDastifl+IuAfm1AVKAlmzdn3rVI5pch8Msm5xPSeuGdFNc/6EIXhgukWalVgjiHxoqxQMI41jRComT2m2MlTVdqIRRJLu6YyrnOvlCuOHPO1nNAHPerIs6QnmNhFD22AXIK6lhCkagc1uAOURzJ25QOhinqoTupA7CgBokP9KjuRPz3hewgpTpfVvWfYTrbxZQm6tvBiH2jzvwJy15kwSWhGaJdKQ94fQr0L/Zj8uB+HP9ZzsYuQYz/czfuAB9J7BcesAGSDhDe4dUOXVU2ktrw5nUopLZjGdaqrtBH4PTE5P+H7kCT8jCDjcz9KDJxK4LCGzkRBbd4oOx5VIHUIKwbDDQ5a8kR2djBIFdpTIJGE94dOWEl6MH2PJXp4cfs9dJ4jMLBfle19NXQ4XetLMSWfBdQGFs3N0WIMpoqosSLmo3JLSId7+Q6luRo3n1fq0tP8E4MsAnEmO5Gu3MrC8JckU7laug5FS3dGKWpP/9SHN44AvA4hP2GFn3Ir15cMEZoQ2VXBZkIIdTm5GikzZbNdtY72assvqG7F3iHlT7pJxnZy6yZieL3u40zT07XPgbDwgMJnEvR50wK5N6y1QbKMtKLpE5OVbXinJzVqlRj9IxloQjuNDlpskxQ/wkOleMy8uGFHP6ECoKxofJJbCURu0pWCQMcOKq+gIWB2vKeeF042EtWQkJ69ZZTWue+VPsDP6UuHgoTwjPEh85dO7r/wDmh+LxEuc9bgsf9k/34CqyWBqM4uIEOqiO0kDkwRG1BfGn0+cJeM4OWubsbxPiIkyDsJmmgjIx0wlHVWA2RTRfwsiqRlQl9Oo3OThhj2gTYTHHFwXEzHSkpGcjOPIOZGfU7yZXEiCjy3xVto9DILffeUZqYmH5agZRhIiZp4Q/aKGM+26/EC7a+SSUKNdz6RBgmHXx2SfkQM8400S5AeaAdKE1PqB+vGx3+jRmLOFxmRJ/NlOHi0Eqz9/+cQ9OQaMhJJwUU/0A+UsH2MFec77K0F+IoHLEjITT8s5vIuP8ZawYPFvHXBHOAaVPZQFfIVfmmyiMgytSn7VrHxG+I6cHPmQ7WXZ4RM6siwftzkwgsbgEacdCaXtdTtCyno2HykQMCUuy5kIv1MrKtYRxGROcBJClGb7OTvwRA6TJSUmH5YQNb0WoiOAh+fXMF3QvFsnkkyfEAFv57J8WQCk9NAV5/k+4wdY0pMnSV9TtlmGbT662CIwDVEq14M8bPjRp7LUA1fOEEM4kMpcOkEcFu9T3ngMbkwp3pwPZiKtRNH1hGo+ScasA0pe+lV9Acpi2KEyWKgU20Jeshnvzih5uWXZqQTLwJvNy1k+wgp+SPay5PAJ7U3CRtj8H0T0y4zfMF7uhJamDEE4Q6/LI9d1OwjCVmrpr8Fo5eszz8d4QcZ25OzIt5A/g/Cmmpdlc441XeJsr2EjAUviadcngNjlVMTl9sDye6apGz5RHYwaISlCnlE8gXkyFGOzDDFxq3v4mWuWEAaODrMtPZjKhgWPZ6p5xstQT46SnsCxGS61NpgOetgOpj0AUIwWQclsGSs2BUzO8I/CuMlpG73LOT7Dvj4lb3Kmh2PeDCM/09P7Ox+3cVarqr0pLheMQf9jXKFgohJpyd2NroaAbdnmBzwPxjElLhnPyYRKKTfwPRGVnDLmwDXApxzwU/LZe48pHFDwDzXJQpTxgw3W9EpPAb1cvloZa0U4LlKjTCuaTwD3DIi/fWzOLm36mVS9ejxh1g8XGlvCPQY8wERo1GZHUkUqHha4Oc3BaBGG8/O84AnonkFxG8ksmeLcdr1KxrxDPAzjWwvKAjrLuicvy7o4BsWKmv1+zPRIYkgKm3le8ARnl3ERb+UcoGBWrNKVlKnRZCybcpr3uUQ3j3ht67ia5Z7o8gHHR4qPUoKM6sipkQfkFlkuYm1QbatEG9cxcuQ2AlvKpGov9Rp+VmO4qjyNnwRY8O4kyIgORozwXCdJjf7W92puqbUu56YQzH76XsndVx6d3srnybdV1eq36PidGWb2G0jQ5N2IjRYWYLtUDNhhJNnxwRaU58tpQcrY5wz/E8Rd9gHfSujJooRKWx1VSvepVDoLeetgGrnet5xuYe8gkbPo+kfDsg4J/ET1EWaQEJ0pLfqAj3KaiL414ZT0xAq9Ku5yidgCadQ0f4TPzI58E1rXeVzeLBt+3u3dKc1BaRGW5+Z58QMZXJqSWc9UgXezcQt96PwG45Xk7MA4Ed3PMFOIsVfy+Sz1wriLGIpAeS7Gi7GUL08Rn9BeZDmZNQG2XnXIsFwfsi9N39jhmSoYfVn5ZHSXicGBaRrXASA3i8+xIlwPo4Y+pHxZivhlCpemZCYfl0A4i72GVqahkAV3xNmq4XfBbNeIfu0F2z2buyrnoDvJU56H8UIs48szxCeKz1kGY/0TRYLj3H6eLd/p4+Bwu1zfjxbV6oxEaYrV9HiCqKh9YjwYQ8ISpDyfegD9ZWjORHew8SsmjZITed2ZJ4ZwFev7kBNs9LDNzDNejv4ytPg9EZcIY97ugLegaAU/V72tD507ICeUnpP0rVmbZ5WTF9I2HVGFJXsTbilrl3N8THOTKnSeSGOStMQk4FMu1+m5co3yABjBpZNiAbPOdsO0BaNOCfYeZiVFKTEQJKduCNVD0548TXpCR5Ql49YFB3dLy93lDY99e/9vvEJcrgVW63pZfkbC5bYfx/xJIzoocceIPprs/2YGnsDwGSo3G+GzLsUfIBHKdbXoXZBvEO3I1r0RJjVwHTl12BmzhmT2wc/kNA9hhRjmz3OEJ2BcAstMO9vmMdCgfqTj7kSFPVYxPlgQ/Owhn20SNLpNclhLAl1UE9OUl2TIH1BfhhKfIK6SpNSa4DB/Ypn3WZnrZ0w65rhsA98Hw4FD5FYF2quBFsojy0fxUqIr58U+5LxZjvyAfDhFpdYzMeF5Mm2FKsPlbIpkIvPY9SHfzAwHCpW/O+oVMObKX0L6MI6Igd4cJH9P3iVHk1m4lKatyGfAY8tTsgpyHPYTKvdvx6cYwXxrTFV/LbR2eMLHqD5CDJJiVVraesDCJAWkJhyG2ZXjK/xBW7GYxdbkKe18A6EyQzgsC2i5jgIO6LdwOM33WHrI8W6Gj58YBZPl49b+dyGSW/4uYGZfwS/Jhrg0VMDTHa6Rf4zWAgV3rEGxjWYLn7FdjBzj2X7GDjxRec+yMfPhlcfXHi/YRErK7EeWhLhLoGDV2CRn2nVfP9iP+uOwmJhBU+V0F2HHSK6Xp4ZPpC9JOmJtExOprn2QCbel5Vk0pvMUO+DlCY6xlBiEUhfcGzQZlaPlis6JPNtn7AAr8Obp0RP0XRKezP2hbIB7XJ5AbgbWN8yB5RAG2VdWmCdXNP4pIyCXAa+uuJxyfZQbpIWO31WRe+vDkFXBjLcEYXHHyqc3X+TDWeOz/DvU+s1/oldnIiU61NK7af+QEvqWhR3VuJZrAmWVGuahRB8jBjnTmRCj33dJZgmMyearHL3FViYMf0t0oA95BI0HGNA4nJ/G4MrLPEMvnX1S22emgxAjPD/K8qkHIG+KYc3z5dikZHM83m4ovXFODXVahOBdFtSMfrY80yeYN4fIT0gpkozMDKW3ILJpGPacYNa7ziVSqhRYVUKw1cw73BXkszlWHcBnfz7RdozmYxlfniE+UXvPkjLrgxjzUsxiLfVeCR7wApXvptsTyZv0qcWQ6Xf1vMdpI6FnBeeUUVeU6eJJX5IjPgHiM1BuCnIE1WIf8AIN2J1LwEF1XNQie8EqjpgQIHGm2e9ZczuvwzgPypFQ0J/lCM+0Qv1Oy8xSfAti1tANA0y4DjjJIAt9b0NVU4LSFS1Su5/ZLI3rgtJnqIBSzoMwJCzpy5PEJ8B8Bs7NzOeYa7OOF5TIZVsRU6mGzm6xWuHVSlzH00+L6RNd7e1T2s9oAgb+81zhCRonA6emIpcMsqrQc8AYGCMYjVCRA1fHreONyku/goBR1kEDQznRB0tZH8YScfCbYOUnilEZPDURtUCXMQzOFhuoaPm0HiAWGWWnumeJDklYxdk3wd3tHlSap/2MJuDwN4PLT7gZZemZOaovgbE+4EIgtrd2wlZIshw9pdDGFt7hcl1OMuMfIQtX0vED88OYIpb/pdni16AuBWk201y+qu5E45KTbES6XdHl4ISiJEhXyItPle1taUiDIeP1MftnbAEDgTlovHmc61ieKmes1dvGGncE4HdfeUnCzB8wO3wrwQMLjlsxvCTFglZKvwl7OVVhHBoeYJhbr7LDdTelfQhJRKodaW3kiSpsBudMQY+UpJihEvza/RRCejm07wutPHB0Dwl9B7tgIVESAW8IY3k/4wk+wMUMXj7B5GQJmg3UQApR7TrcCHx2DtDwdbZJSNQk7B6cId/eNA0JRn75IAzG/DCmiCWAecL4BADOAK3JyS8cevYuJH74YpwwlJQ9ZO1f8vhthmmd5Cl12zuV7XTF5Zz8IGQJx8sZvH4C/2R4xpR46q+mwQzZbbQyYcjJsVjWTt9Rw8jzPw5+MrD0BJ7P8PnbbMzlW5sGKyRmL4/mMLo+2xUOgk+99R4u6YJCfKyHxMRWQh6ep/SEAqD4P88XniCnkpD7to7qfUHxdPCcEsJjrO2e10FteKkicEa39pTfdLT/Gn4lJaRiKZVFiC/C4qec//fcVPLZbDrY7DC/1P7yWXcL6RyWT9Bmwy2E2wWd53AjVYFb5wotWE5kEeKLsngp6fdMT8jvtMyaQjB3xKCXgK12blMVzPJzbrwe91mCB4ucQCO49OVDDCnxwYgSmvVlSeITWUyWlVgPgcTj6hJWTBGN4rJ8LWPZSS7h3J03MRmj1curiF2CtdtxMdqD0SQs60mTpCeymCwreWv2AQHbDOV+uMRPCNrlfUz/JKt7XJIHleDo0ESO93rb7ee8B+NJWNaTZ0nfo/gMlZumEvM9hqH4AhXS9nwa9IZXRxaa2cJjV0707r9nSn7mZqIs7Wc0AUf9WZbwTB/J76zM+kha7025s6oNqOU2n5Xoe+y6YFLPM9SMZhSHYII7R41Wkpz4YUQRz/qyLPGJslwGz01VLog8HAvkOHbDqYF+7d3sA84T5DTa2NepHtMEM5wTjEVOfDCihFX98mzhgcJcik3f5v2PqBls27Szf8qDwnGs+weRU7D79bVlodiPIz0zRQ5lPhhTwrBvCpUf0KOlYM6EpV0W7LAPLunFqWFfhKPsxAc5blm41GSw2PNg8MWKAUR55s+YAo4VM2z5BJOTpWfWV1IlZ9QSqWyGBQtFp1QkMdbLkIysYyGgaS+7GQ3Dn1IH+HwifhhRxLO/LFv8/hDIgrpJsrBB9fNhIWLOjwf1jQq5da7CtuaWaiW5Dz0C8iPjCX4iQ2nm0If5LcvKnmfX6x4VU10ahJYF+WQ1+IZSq1JNQIF7Lvf2IXwG5T8YCsxR4xOwLsNpb7N2lw9b7TrSgRJW85LvwObZrLCDP4B1vBwA2wdy+swMlsuz3J+iwBw1PgHrMphmEtt+ac6HvygBPcZ9Yha3H8bySTC+MIzUesekM//k1+27lma/LFv+gAIz1PgEQZXkadYpVC/km+ogeg9jHRBAqpMYDsUrmoSqDklBjGuY2z7+fGKyGPPFM8AsY/w+nU0Sc2sRk+QKLLBcPmhVap5XdkhdtK+1YD6tJ7kSteQIVhUIwmEMxs5yX5Ip85w/YQie4C9+88vWE1zWRGiXqzC1PMEltKF47kDpj+E8zmoI7IbjhFxGkc3pC0J2EGqEctcJ0/1EJTYD5GZKeaoeqVh5p/dl3Cr8FWprYayFjRwVVxhIrjilEdY+5vyEImB4P88PHsDvGR43PfnU7hP7gHJ2+6Az1AimoQ41Itv3tEqQjsdOuw14EV77ec5PKAIG9/P04An4nuFxExQ3JJNe/K6n1agsTsk1NPHAO7ycjYWr+ikN/Q745JKSz885P+MION7P8oMnAHwGyE1ZW3bVMYXoYZBc2jTiC08Kpzn7JKt2vw7nQS2Wq4xmnMjV85yfcQQM76fpwTOK+l9w3JwcJWxZwlgwTfxnzrpsgn7saJsI0pF5b/x2g9e91LVvO9k04ycMAYX7eXrwRDEmg28mLZUcqU3b6ohQMzJJwanY9xoa5OfCqFvQ6Km2oyXSeZ87TXhJfszh4W8w+QTcz+C7yYolXpRtcB9VoLvsqKo4i8QX9urlxAOOtmHp2IGKLtroU76D0CM0O8iziSfQboZeTV8JR+Bt12VPX8awLLxnbA3PR6q3jizY5c++DB3DpHTGJN8832f8ACsOpWj6CV+IBMKaoyVaO6peLcf91RsaQS40qwLGQbg5/bKc8UMXswDSXrexMSzXZ9QAw8cpnH4i9mex3IRYq9i0btBrcticmKqG8W/VXpqE4TEjTc+TfRb9s7PiidM8O53N4+Ug4nmMW5efWRO7/4rtuW4TcIy2KXX47xnhxs4yPZoZssM/BwtP5O4ZPjNpKRwBj4UzHB4l+o0HBhN7mMPAXQtbG/5ZUHwqbh0AHB9zfcYNcPyX4cVn1MW/EbrJiwU1GLS80Flddsh/5VS8PPesAq0d0S+EC10B6HedPtiU0j2MHuIJQJYwPDAnLElLzZ54YYybpqUX6LXmGba8T60hy+ZckXUv2Vtbrx4oRtunVD9jBUihN02N70dWm28tYOzL2dZ627Pxu688IzVzdTiiQGMlyxAT1cOmCiWjUm0KTouMVHnEZX5UbZ15oqqcZPmMEiDJbpoaP4DdMixmnh4of1bjBgsUPdOTCxyAuutgr1LqinbF0yUODP35ESZuNNdhuRGDejk0fEB5koIR0xFOAUnd/J8lRgV46VA5nm3tbHglJSqEc83pbW4HCtGoKOa5DsuNGNjJwdEzUvLf+YhJyWWzY24NriveC7H3go+yU2d1+hJAH/vuZjwhu3fu3iNO5YQHI0h4vpPlR08wGBkiNy21vPWihRAUPK5jxjNoTt8qsVRHJky0DGqjgoG2CN5gw/OR8WAMCQX8WX7wRAKbQFITEssxDFNFMIuwxGieR8qeBl6Qy/C5n1Eg7vJPt8JdWfGjx1tLs12WHXO8m8HjJwBfBuBMegYJ3OUEG6im4VnEkQily7MpEOwhPUPctsvyJmeJJCVPdkhyRAFiiiefwHsZfjNXm43zsfs2XD6we+KFrjVs2274jkU/54YHn8GRefUafr1prk+oAYoOczT5jKfTb/RmamI5N4xeAhipbi/etZHHel3gQHptqygMMOSnXRYUJIFxWMfSfUYPUHiYosknTsDsRDMNTl0S3f0Vydbt0Rcv69aJVMkIlyd2LOHjB2B2YD6Rjv8rIjVlNGCoxA+AV1ShPSseW2dtA5nN4iUEtKY31LXUbnR3v0oS9zzLp1A3AcZPwLgMl5mQbKAUbtclbJ4a7hWIuTb1o5yxWqSbAy24fsbIshmRnuZZLsuKOe5LYOITR3h2JNtk3wU8bUd4hZ9T86wS+n39ILAR7btEtWFD9mg/jzR8RgNlnuWyrJid+SlEeCJpzVCZKUkLyGBNr86aVg1BZ6q8xKmrdpXTR3iLF5QLpkO+utvnDJdlxAzy5RDxiZQ1ychMRlxlTV6aNi2w4tFoPkoH4sblibnDelkN39HeKLmXgP8QHWcZbp4M01QvyQsfYF5TLGLKKQn5a7kJZsPS9SQCNoLTokGD0f89+K3rBAA9XbsczdHZnic7LDniYCfBRg+AlxSMmHROd5+dlvL064oSw4JlrlkMYAZOC+1cl9fSmp+uy+eF0XSXpccU7STY6AnwkoERm38su85yK3R8yGEVHiVF3lK3sFfku21RY1iwJrOfh/ir3DZcaabDMiNW28jB0QPZa5aNmJ3VmbLVuh60spXv3BJr2PbnkmO5/ZhWYeA6fgnMc1dkqHmmyzJjluukqdETuUtyipvMSNbv9LezgGtiuoGc56fa6u9QgMe8NJjJT/s9IJPdooikOiw1oighRxXPCM1+H+MmNBOwYLU+hb3tTiOWxPLpaeRUZGBph8TtGWbKcq6MqCWmyQ5Ljj7AhAxWPJG7JxDWPJ3kKt67sot7XtGMK4uy6UG0MAzn+FV8Q0fBcUcnUBSM00Sf0AIEHmdY+gm8kyAY01jKV16PduoA7p6g4g8a3fSyPEE1pgWdm2shuqCvB0u3fUrxaErI4FEOp544+LOD3IYobTn2hh386Mlt0eUM5XHz2oLk1S3YyTzHYwd/DhSeSNoSSGYWRYKXunxaXJZ/tkM0KPsekh/APbnsxdKmY3jx0zBeKF76ZmlenhNmaC8Fhk+kbRkeebv7n4SX5uyYu2VKWoVJWj6NVQKzDyucqA5IPPcFeOTIjElwaZbHkkKGdnJ09Ix27DceMfFYqwWTirC7Ly10WvY05UVYRGqnRIsHijf7cst72b7jjrp5kseSQo52MnT0RBRL8IhpB9EnMBS9yLbo7TZrERyAmLd1qk8JRaEsTSQVwDqSg41o8ktzvDwhZFAnRUZPQJcMi9hAKFmw3URKEoLHiaYMeS4LePIThiXtusDqVuzXDNmvV5RL8kyHZUaM1c2h0RPQJYMiJpoqBcZaeD0NLeaeWEhOO+0Ag33qPaJRVkevtsJ19nxMQ8vzHJYXMZyT46JnTBx+ncgmmpIw1pfGZDkuPREduniKDQAacmT5RsY4gFqLsmyyYt2+gmY5JCv6cN4n8OCJpOU3DDPBIATZG1cFg3mXBhrvFkaO40gL80x06YE70mMKZWHTVpD0hiRDHN8laPCJwy47vUxas8qlI80QvnE+h2lXuZqe5gcW4WNET+tq5gwMv7tzlSiQpMkNTYbI2ZgfpU+cdcnhZa3OCGa2hgVw1FsOA0WvhnrJpNyZbsAqFPMfNBwfhTqf0hqWBrGDMT9In2hxSwCbSeTahjfQsZ6zHTnD3NiouIwi2QgCXgAnJOyyFQpGFLYPOQ1JgCgUTIDjA8dcem6ZvKCbZSK2wgWC3PE1iAKY/2L11VPDEziH9fyUy07FZwwLfkEQk0ahf7LoqxHc4uMU0WEmAGNq8AIfcmJuiSZJGqbagS/cpySNpHQU3iRg6AmqMTmB3+7vhbzJjiCsBofMRyJu0e9JQms7oc2fks3MZri2upaN4nqSBrDTPUcDD5zW2flrLdooYW7tJqrX3/QR8kmh4jk6QbTdLRjyf/bSVyMopM8Y+5WCepICsLM9hQJPnNW/zl/TxghG3FWDTumCnIajZVm2q2sVAh2Xt8miZA/w/cbJLsm343YC5wn4J9RligSeOK2T09dkEU0ixDUsIeg+TldwMkrBxbCErKQYBSLBaRR9h5LSh4SCgfkc+3842RMg8MRJ/fvsNUHEwKAOLfn0IhEpqMM98Kr1BWCqS8ghZEmjC0WB7PJlynB8Cvo/HOsJCnhGC/ErXtt4KzSK9+nWP70EbC6Q6mzbBKeusFvbZgaGA3lP9wcnEJ4AfnYWpCfHEzRqAjmsA/9AgqSwBQBmOXCuEtvdB0+ixg6YLRsQY7oO3IFXucc6/gbwBOvnUCbFPU8cackhZZqBKnHn6EKH0VMJwCwfE+8e4UrA5AjrWzmTR9W1W+RN9Y/gnWF9fgImB+YzgoFfZ5TpBToilgJBQUDu5DzQvSpxr2qvaVtR1prqkTP0lwj6OvsTdidAnx5/yWH5QFxPIrX16hx5pZee5LsIgIthalM+/vBwJYfUctyZolcW19Nj4BnRw6/z1uY4yUvBDEikFW7r0VVkpC6V0NtecawONJWAEIKwGjNUQ4yfIleCc8lJnp77T3BHyZljVW85LG3OytITylGhfE4UXEFeyw6N4YxVQJXhZNmWtUavXYpbCcqlp1ly9j1T7v514li1u60Jxg7LANs0vIfB1A/LLgUdtGCHujz60ncoK/dEpTvFrATh0sMsOfqeqXL/OnGsyj0kP9h6WbbnPLdSWrCp7OyDJMmzA+iq6y52lA35Cj5C1hzg5mdZeu49AUGTE8dM3vc6sw5L7SPKTJBYkBTrbhOgtqLofdBPoXC6DUkoouadAFaCbtlhlh59TxxOyXFjVW1ZxJjnqk0gY/kpBCjUV932/csHDWAqu2l33SytwsDwA15l6DY/ytJz75nWq19B2qq6FZZz1YyHl8+dgCQW/0+X/9jTtXd9w6JZK9Fo85zXbQOcwlUCbukBkBwXT2Cx31Ha3MzlWZd9ZMjfAyxd11XM4mJhTkjMfVeWqFqVcrv6hOE2gvLIAZAeF08wC0mQttaLg0nXw4B396loA+YemHmvfiKj+8hJ2S+SDs1p533bJ9jMFLQRiEcOgOy0eCK2JdHKyl9D4rd/5Dl6ACj5/NelMayopbJfTkEbC21JHHxiz/4+bayEeUmcwZ8b/4hph9B/ngJKB3Pp5bhqjswkpOr5MTA6YHvfIwFsKbijp9jvI++J+JxEXDOflm+9W7dgbd39uiZaPeRzXxa9ZuvRGSHfATwoQYl3yWVjvlYG11Jox2J5GvmfKdr9CrjWKiFXYRQJ75+5fyacSb6Gb8NU32bJKVcxs3vpcplLW9o+gLUc2rFYnkb+J6JzEnGtciUbzZoym1WTDBasPkazZQfHgciIUW7V5bwlmK+PqIVgHBrLk8j/TM3qV7y1mpXkAm3oO5Rt1a9Ih+VNXOYBVXaU1IYeoN1Q6q7TO4MYbCEghwTzLPI/U+f410hlYnqot7Hf5BDBkPnmWOFCi7peviRb9g6fCftQjDWUy3Ao8GlRBLUQjEOiYBoznylz/ApWb2/AnejRw4eWBKQFWpjDYrz8ozAsQlGvKnM//nHmcsNFhlpyiMOiYBIy9anzbWeEdZEfnRZvzm735Ke1MXkNCwc93iEDSY5ftkezDf1MseVf46bVWga6xCcuCx516kHwiXzXp+pKrXuOGlImGGtgH15737OWU/BEoBYNyEn4fiLUJMHDWPcq4cXGmcDMasSAMlmFQ59aXp4PIpxFE7J58Dvko5bz6QAmxzWPS0kUe4Z0/xU9jHTv2vOC8S6QnN3DRpaEvzlwuZ9QPkLCMo1FRIfRqjMO2+QIJuc1D0xJGHuGfv6X4GHKx2PfOf6aPOoJJaOs3Dn0+UYF4PRjUtb3bLrS667dRhexEzg/rklcSqPYE9s72bHGPEvkgWOnvNgzcKj6AdfNX1IuT3mSGRP3rnNh/Jr8kiar8oRBfnoCk/OaBITfseOJ/f17x5rabcuHROULs6TmMpJCwr88Hkq+8tQLASCw8YEowmcbLX+O/BQiJxYB42nkeGKRJwvXOKyJ0UBdN/3ubcR8wQZ3Jl39B8AmxpGkZxhZ5ummeMbp7FfsMfq1NGNQMO9HHir8zGRhwm/wyIpvKNv5cQM+devUKvkzcTE9xciZl0e1NAQ+w8b92oJmiLRWgQ2+XK4rehwxI3PrhAx5bEm3Tw+SDj5WqKTAlhNzvfk5xg49srvTWPAMJ/VrFxopNeSDHo1UbZd6+8zvdskuO83WQ6QmY+LV41esc0YMxkzDOQn+ZH8nseAZRurXujVGaqKWM3C5m6rOguXBxFe9jJbAKyaGrEuZcPyS3Xv7GM1J7Ce7ItlBz5AavxaukRqSb6pKtKqE0OwIML4brfwNl2vfriyEwFigAx4QHlYKaz7E8zz6002R7KAnlvnvhWu5vbzcDs4NRdAzZhSwZbXuo99+x0KJKngaz8k6zzbFM0XtX4vR0nU0JUPccP0DJlZ3e8S8Guz45TJe5Y5Wd4GdGEiONwt8EBrTNK6RKEgXerItIoFLltTbVW0D1i8HkynaddvZQvyDktiF5XLujt2rlLL0tclT9xP+VFlwIpGMrNZ0bfuHz75MK9mcVmFzI5ev6h9yYCZB0zIy+kn6ZbtkYOrY0SZ2HHz9eC6cbzWyMdl7St/qMyj+13swHD8PbG1wuULmESQAPP5AYOlk2NJDW5Jutvytpa/4GYj667UYRh1r6Gsp/8DcmxktGVsSZ7xaAUBw1A6MOpt68R6MFsMR9Wm5ksVNX3myQGL7JJ/HB+JiCbc/W/JdeSbL41HnGSaELpAiRZWAvDb66ZNn1c/z7//8p9f//M8//9O/q3+u+uef/8cLadYcYDQrTC0xSESeW1bRP/+31//wv/7bf/m//uNf//H//L//w7/99ec//Nf//N/+7b/81//8v/+Pf/75//z5X/75+vev/xe/5UaaCmVuZHN0cmVhbQplbmRvYmoKMTEgMCBvYmoKMTQ2NzYxCmVuZG9iagoxNiAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDg5ID4+CnN0cmVhbQp4nDWMsRHAMAgDe0/BCAiDgX1yqZL922DHbtBLOhQIYgqbB0mmThda+Ulvg+uipyGdwJOUsTNjO9Rtty65s7NX7cjar8+hv3YntV4kEiuByNI4g/cHz5odjwplbmRzdHJlYW0KZW5kb2JqCjE0IDAgb2JqCjw8IC9CYXNlRm9udCAvRGVqYVZ1U2Fucy1PYmxpcXVlIC9DaGFyUHJvY3MgMTUgMCBSCi9FbmNvZGluZyA8PCAvRGlmZmVyZW5jZXMgWyAxMTkgL3cgXSAvVHlwZSAvRW5jb2RpbmcgPj4gL0ZpcnN0Q2hhciAwCi9Gb250QkJveCBbIC0xMDE2IC0zNTEgMTY2MCAxMDY4IF0gL0ZvbnREZXNjcmlwdG9yIDEzIDAgUgovRm9udE1hdHJpeCBbIDAuMDAxIDAgMCAwLjAwMSAwIDAgXSAvTGFzdENoYXIgMjU1IC9OYW1lIC9EZWphVnVTYW5zLU9ibGlxdWUKL1N1YnR5cGUgL1R5cGUzIC9UeXBlIC9Gb250IC9XaWR0aHMgMTIgMCBSID4+CmVuZG9iagoxMyAwIG9iago8PCAvQXNjZW50IDkyOSAvQ2FwSGVpZ2h0IDAgL0Rlc2NlbnQgLTIzNiAvRmxhZ3MgOTYKL0ZvbnRCQm94IFsgLTEwMTYgLTM1MSAxNjYwIDEwNjggXSAvRm9udE5hbWUgL0RlamFWdVNhbnMtT2JsaXF1ZQovSXRhbGljQW5nbGUgMCAvTWF4V2lkdGggMTM1MCAvU3RlbVYgMCAvVHlwZSAvRm9udERlc2NyaXB0b3IgL1hIZWlnaHQgMCA+PgplbmRvYmoKMTIgMCBvYmoKWyA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMAo2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDMxOCA0MDEgNDYwIDgzOCA2MzYKOTUwIDc4MCAyNzUgMzkwIDM5MCA1MDAgODM4IDMxOCAzNjEgMzE4IDMzNyA2MzYgNjM2IDYzNiA2MzYgNjM2IDYzNiA2MzYgNjM2CjYzNiA2MzYgMzM3IDMzNyA4MzggODM4IDgzOCA1MzEgMTAwMCA2ODQgNjg2IDY5OCA3NzAgNjMyIDU3NSA3NzUgNzUyIDI5NQoyOTUgNjU2IDU1NyA4NjMgNzQ4IDc4NyA2MDMgNzg3IDY5NSA2MzUgNjExIDczMiA2ODQgOTg5IDY4NSA2MTEgNjg1IDM5MCAzMzcKMzkwIDgzOCA1MDAgNTAwIDYxMyA2MzUgNTUwIDYzNSA2MTUgMzUyIDYzNSA2MzQgMjc4IDI3OCA1NzkgMjc4IDk3NCA2MzQgNjEyCjYzNSA2MzUgNDExIDUyMSAzOTIgNjM0IDU5MiA4MTggNTkyIDU5MiA1MjUgNjM2IDMzNyA2MzYgODM4IDYwMCA2MzYgNjAwIDMxOAozNTIgNTE4IDEwMDAgNTAwIDUwMCA1MDAgMTM1MCA2MzUgNDAwIDEwNzAgNjAwIDY4NSA2MDAgNjAwIDMxOCAzMTggNTE4IDUxOAo1OTAgNTAwIDEwMDAgNTAwIDEwMDAgNTIxIDQwMCAxMDI4IDYwMCA1MjUgNjExIDMxOCA0MDEgNjM2IDYzNiA2MzYgNjM2IDMzNwo1MDAgNTAwIDEwMDAgNDcxIDYxNyA4MzggMzYxIDEwMDAgNTAwIDUwMCA4MzggNDAxIDQwMSA1MDAgNjM2IDYzNiAzMTggNTAwCjQwMSA0NzEgNjE3IDk2OSA5NjkgOTY5IDUzMSA2ODQgNjg0IDY4NCA2ODQgNjg0IDY4NCA5NzQgNjk4IDYzMiA2MzIgNjMyIDYzMgoyOTUgMjk1IDI5NSAyOTUgNzc1IDc0OCA3ODcgNzg3IDc4NyA3ODcgNzg3IDgzOCA3ODcgNzMyIDczMiA3MzIgNzMyIDYxMSA2MDgKNjMwIDYxMyA2MTMgNjEzIDYxMyA2MTMgNjEzIDk5NSA1NTAgNjE1IDYxNSA2MTUgNjE1IDI3OCAyNzggMjc4IDI3OCA2MTIgNjM0CjYxMiA2MTIgNjEyIDYxMiA2MTIgODM4IDYxMiA2MzQgNjM0IDYzNCA2MzQgNTkyIDYzNSA1OTIgXQplbmRvYmoKMTUgMCBvYmoKPDwgL3cgMTYgMCBSID4+CmVuZG9iagoyMSAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDE2NSA+PgpzdHJlYW0KeJxFjzsSAyEMQ3tOoSOAf8B5NpOKvX8byztJGiyMJT+iKzr2ysNjY8rGa7SxJ8IW7lI6DaepjK+Kp2ddoMthMlNvXM1cYKqwyG5OsfoYfKHy7OaEr1WeGMKXTAkNMJU7uYf1+lGclnwkuwuC6pSNysIwR9L3QExNm6eFgfyPL3lqQVCZ5o1rlpVHaxVTNGeYKlsLgvWBoDql+gPT/0ynvT/c9D2ACmVuZHN0cmVhbQplbmRvYmoKMjIgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAzMDQgPj4Kc3RyZWFtCnicPZI7ksMwDEN7nYIXyIz4k+TzZCeV9/7tPjLJVoBJiQAoL3WZsqY8IGkmCf/R4eFiO+V32J7NzMC1RC8TyynPoSvE3EX5spmNurI6xarDMJ1b9Kici4ZNk5rnKksZtwuew7WJ55Z9xA83NKgHdY1Lwg3d1WhZCs1wdf87vUfZdzU8F5tU6tQXjxdRFeb5IU+ih+lK4nw8KCFcezBGFhLkU9FAjrNcrfJeQvYOtxqywkFqSeezJzzYdXpPLm4XzRAPZLlU+E5R7O3QM77sSgk9ErbhWO59O5qx6RqbOOx+70bWyoyuaCF+yFcn6yVg3FMmRRJkTrZYbovVnu6hKKZzhnMZIOrZioZS5mJXq38MO28sL9ksyJTMCzJGp02eOHjIfo2a9HmV53j9AWzzczsKZW5kc3RyZWFtCmVuZG9iagoyMyAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDIzMCA+PgpzdHJlYW0KeJw1UUluwzAMvOsV84EA4i6/x0FP7f+vHdIJYGBoS5zNERsbEXiJwc9B5MZb1oya+JvJXfG7PBUeCbeCJ1EEXoZ72QkubxiX/TjMfPBeWjmTGk8yIBfZ9PBEyGCXQOjA7BrUYZtpJ/qGhM+OSDUbWU5fS9BLqxAoT9l+pwtKtK3qz+2zLrTta0842e2pJ5VPIJ5bsgKXjVdMFmMZ9ETlLsX0QaqzhZ6E8qJ8DrL5qCESXaKcgScGB6NAO7Dntp+JV4WgdXWfto2hGikdT/82NDVJIuQTJZzZ0rhb+P6ee/38A6ZUU58KZW5kc3RyZWFtCmVuZG9iagoyNCAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDI0NSA+PgpzdHJlYW0KeJxFULuNQzEM6z0FFwhg/Sx7nndIldu/PUpGcIUhWj+SWhKYiMBLDLGUb+JHRkE9C78XheIzxM8XhUHOhKRAnPUZEJl4htpGbuh2cM68wzOMOQIXxVpwptOZ9lzY5JwHJxDObZTxjEK6SVQVcVSfcUzxqrLPjdeBpbVss9OR7CGNhEtJJSaXflMq/7QpWyro2kUTsEjkgZNNNOEsP0OSYsyglFH3MLWO9HGykUd10MnZnDktmdnup+1MfA9YJplR5Smd5zI+J6nzXE597rMd0eSipVX7nP3ekZbyIrXbodXpVyVRmY3Vp5C4PP+Mn/H+A46gWT4KZW5kc3RyZWFtCmVuZG9iagoyNSAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDI0NyA+PgpzdHJlYW0KeJxNUbttRDEM698UXOAA62t5ngtSXfZvQ8kIkMIgoS8ppyUW9sZLDOEHWw++5JFVQ38ePzHsMyw9yeTUP+a5yVQUvhWqm5hQF2Lh/WgEvBZ0LyIrygffj2UMc8734KMQl2AmNGCsb0kmF9W8M2TCiaGOw0GbVBh3TRQsrhXNM8jtVjeyOrMgbHglE+LGAEQE2ReQzWCjjLGVkMVyHqgKkgVaYNfpG1GLgiuU1gl0otbEuszgq+f2djdDL/LgqLp4fQzrS7DC6KV7LHyuQh/M9Ew7d0kjvfCmExFmDwVSmZ2RlTo9Yn23QP+fZSv4+8nP8/0LFShcKgplbmRzdHJlYW0KZW5kb2JqCjI2IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggOTAgPj4Kc3RyZWFtCnicTY1BEsAgCAPvvCJPUETQ/3R60v9fq9QOvcBOAokWRYL0NWpLMO64MhVrUCmYlJfAVTBcC9ruosr+MklMnYbTe7cDg7LxcYPSSfv2cXoAq/16Bt0P0hwiWAplbmRzdHJlYW0KZW5kb2JqCjI3IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMzM4ID4+CnN0cmVhbQp4nEVSS3LFMAjb5xRcIDPmZ+PzvE5X6f23lXA63Tz0DAgJMj1lSKbcNpZkhOQc8qVXZIjVkJ9GjkTEEN8pocCu8rm8lsRcyG6JSvGhHT+XpTcyza7QqrdHpzaLRjUrI+cgQ4R6VujM7lHbZMPrdiHpOlMWh3As/0MFspR1yimUBG1B39gj6G8WPBHcBrPmcrO5TG71v+5bC57XOluxbQdACZZz3mAGAMTDCdoAxNza3hYpKB9VuopJwq3yXCc7ULbQqnS8N4AZBxg5YMOSrQ7XaG8Awz4P9KJGxfYVoKgsIP7O2WbB3jHJSLAn5gZOPXE6xZFwSTjGAkCKreIUuvEd2OIvF66ImvAJdTplTbzCntrix0KTCO9ScQLwIhtuXR1FtWxP5wm0PyqSM2KkHsTRCZHUks4RFJcG9dAa+7iJGa+NxOaevt0/wjmf6/sXFriD4AplbmRzdHJlYW0KZW5kb2JqCjI4IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMTYzID4+CnN0cmVhbQp4nEWQuXUEMQxDc1WBEniAOuoZP0ez/acLabzeQPp4hHiIPQnDcl3FhdENP962zDS8jjLcjfVlxviosUBO0AcYIhNXo0n17YozVOnh1WKuo6JcLzoiEsyS46tAI3w6ssdDW9uZfjqvf+wh7xP/KirnbmEBLqruQPlSH/HUj9lR6pqhjyorax5q2r8IuyKUtn1cTmWcunsHtMJnK1f7fQOo5zqACmVuZHN0cmVhbQplbmRvYmoKMjkgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCA2OCA+PgpzdHJlYW0KeJwzMrdQMFCwNAEShhYmCuZmBgophlxAvqmJuUIuF0gMxMoBswyAtCWcgohbQjRBlIJYEKVmJmYQSTgDIpcGAMm0FeUKZW5kc3RyZWFtCmVuZG9iagozMCAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDQ1ID4+CnN0cmVhbQp4nDMyt1AwULA0ARKGFiYK5mYGCimGXJYQVi4XTCwHzALRlnAKIp4GAJ99DLUKZW5kc3RyZWFtCmVuZG9iagozMSAwIG9iago8PCAvQkJveCBbIC0xMDIxIC00NjMgMTc5NCAxMjMzIF0gL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAzNwovU3VidHlwZSAvRm9ybSAvVHlwZSAvWE9iamVjdCA+PgpzdHJlYW0KeJzjMjQwUzA2NVXI5TI3NgKzcsAsI3MjIAski2BBZNMAAV8KCgplbmRzdHJlYW0KZW5kb2JqCjMyIDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMjE0ID4+CnN0cmVhbQp4nD1QuxFDMQjrPQUL5M587TfPy6XL/m0knKRCNkISlJpMyZSHOsqSrClPHT5LYoe8h+VuZDYlKkUvk7Al99AK8X2J5hT33dWWs0M0l2g5fgszKqobHdNLNppwKhO6oNzDM/oNbXQDVocesVsg0KRg17YgcscPGAzBmROLIgxKTQb/rXL3UtzvPRxvooiUdPCu+eX0y88tvE49jkS6vfmKa3GmOgpEcEZq8op0YcWyyEOk1QQ1PQNrtQCu3nr5N2hHdBmA7BOJ4zSlHEP/1rjH6wOHilL0CmVuZHN0cmVhbQplbmRvYmoKMzMgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCA4MCA+PgpzdHJlYW0KeJxFjLsNwDAIRHumYAR+JmafKJWzfxsgStxwT7p7uDoSMlPeYYaHBJ4MLIZT8QaZo2A1uEZSjZ3so7BuX3WB5npTq/X3BypPdnZxPc3LGfQKZW5kc3RyZWFtCmVuZG9iagozNCAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDQ5ID4+CnN0cmVhbQp4nDM2tFAwUDA0MAeSRoZAlpGJQoohF0gAxMzlggnmgFkGQBqiOAeuJocrDQDG6A0mCmVuZHN0cmVhbQplbmRvYmoKMzUgMCBvYmoKPDwgL0ZpbHRlciAvRmxhdGVEZWNvZGUgL0xlbmd0aCAxNTcgPj4Kc3RyZWFtCnicRZC5EUMxCERzVUEJErAI6rHH0Xf/qRf5SrRvAC2HryVTqh8nIqbc12j0MHkOn00lVizYJraTGnIbFkFKMZh4TjGro7ehmYfU67ioqrh1ZpXTacvKxX/zaFczkz3CNeon8E3o+J88tKnoW6CvC5R9QLU4nUlQMX2vYoGjnHZ/IpwY4D4ZR5kpI3Fibgrs9xkAZr5XuMbjBd0BN3kKZW5kc3RyZWFtCmVuZG9iagozNiAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDMzMiA+PgpzdHJlYW0KeJwtUjmOJDEMy/0KfmAA6/Lxnh5M1Pv/dElVBQWqbMs85HLDRCV+LJDbUWvi10ZmoMLwr6vMhe9I28g6iGvIRVzJlsJnRCzkMcQ8xILv2/gZHvmszMmzB8Yv2fcZVuypCctCxosztMMqjsMqyLFg6yKqe3hTpMOpJNjji/8+xXMXgha+I2jAL/nnqyN4vqRF2j1m27RbD5ZpR5UUloPtac7L5EvrLFfH4/kg2d4VO0JqV4CiMHfGeS6OMm1lRGthZ4OkxsX25tiPpQRd6MZlpDgC+ZkqwgNKmsxsoiD+yOkhpzIQpq7pSie3URV36slcs7m8nUkyW/dFis0UzuvCmfV3mDKrzTt5lhOlTkX4GXu2BA2d4+rZa5mFRrc5wSslfDZ2enLyvZpZD8mpSEgV07oKTqPIFEvYlviaiprS1Mvw35f3GX//ATPifAEKZW5kc3RyZWFtCmVuZG9iagozNyAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDE3ID4+CnN0cmVhbQp4nDM2tFAwgMMUQy4AGpQC7AplbmRzdHJlYW0KZW5kb2JqCjM4IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMTMxID4+CnN0cmVhbQp4nEWPyw0EIQxD71ThEvIZPqmH1Z7Y/q/rMJpBQvhBIjvxMAis8/I20MXw0aLDN/421atjlSwfunpSVg/pkIe88hVQaTBRxIVZTB1DYc6YysiWMrcb4bZNg6xslVStg3Y8Bg+2p2WrCH6pbWHqLPEMwlVeuMcNP5BLrXe9Vb5/QlMwlwplbmRzdHJlYW0KZW5kb2JqCjM5IDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMjQ4ID4+CnN0cmVhbQp4nC1ROZIDQQjL5xV6QnPT77HLkff/6QrKAYOGQyA6LXFQxk8Qlive8shVtOHvmRjBd8Gh38p1GxY5EBVI0hhUTahdvB69B3YcZgLzpDUsgxnrAz9jCjd6cXhMxtntdRk1BHvXa09mUDIrF3HJxAVTddjImcNPpowL7VzPDci5EdZlGKSblcaMhCNNIVJIoeomqTNBkASjq1GjjRzFfunLI51hVSNqDPtcS9vXcxPOGjQ7Fqs8OaVHV5zLycULKwf9vM3ARVQaqzwQEnC/20P9nOzkN97SubPF9Phec7K8MBVY8ea1G5BNtfg3L+L4PePr+fwDqKVbFgplbmRzdHJlYW0KZW5kb2JqCjQwIDAgb2JqCjw8IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlIC9MZW5ndGggMTcxID4+CnN0cmVhbQp4nE2QTQ5CIRCD95yiFzCh8wOP82hc6f23dvD54oL0SyFDp8MDHUfiRkeGzuh4sMkxDrwLMiZejfOfjOskjgnqFW3BurQ77s0sMScsEyNga5Tcm0cU+OGYC0GC7PLDFxhEpGuYbzWfdZN+frvTXdSldffTIwqcyI5QDBtwBdjTPQ7cEs7vmia/VCkZmziUD1QXkbLZCYWopWKXU1VojOJWPe+LXu35AcH2O/sKZW5kc3RyZWFtCmVuZG9iago0MSAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDcyID4+CnN0cmVhbQp4nDWMsRHAMAgDe6bQCDZYYO+TS0X2b0N8TgMvHQ+XosFaDbqCI3B1qfzRI125KUWXY86C4XGqX0gxRj2oI+Pex0+5X3AWEn0KZW5kc3RyZWFtCmVuZG9iago0MiAwIG9iago8PCAvRmlsdGVyIC9GbGF0ZURlY29kZSAvTGVuZ3RoIDIxMCA+PgpzdHJlYW0KeJw1UMsNQzEIu2cKFqgUAoFknla9df9rbdA7YRH/QljIlAh5qcnOKelLPjpMD7Yuv7EiC611JezKmiCeK++hmbKx0djiYHAaJl6AFjdg6GmNGjV04YKmLpVCgcUl8Jl8dXvovk8ZeGoZcnYEEUPJYAlquhZNWLQ8n5BOAeL/fsPuLeShkvPKnhv5G5zt8DuzbuEnanYi0XIVMtSzNMcYCBNFHjx5RaZw4rPWd9U0EtRmC06WAa5OP4wOAGAiXlmA7K5EOUvSjqWfb7zH9w9AAFO0CmVuZHN0cmVhbQplbmRvYmoKMTkgMCBvYmoKPDwgL0Jhc2VGb250IC9EZWphVnVTYW5zIC9DaGFyUHJvY3MgMjAgMCBSCi9FbmNvZGluZyA8PAovRGlmZmVyZW5jZXMgWyAzMiAvc3BhY2UgNDYgL3BlcmlvZCA0OCAvemVybyAvb25lIC90d28gNTIgL2ZvdXIgL2ZpdmUgODAgL1AgOTcgL2EgOTkgL2MKMTAxIC9lIDEwMyAvZyAvaCAvaSAxMDggL2wgMTExIC9vIDExNCAvciAvcyAvdCAvdSAvdiBdCi9UeXBlIC9FbmNvZGluZyA+PgovRmlyc3RDaGFyIDAgL0ZvbnRCQm94IFsgLTEwMjEgLTQ2MyAxNzk0IDEyMzMgXSAvRm9udERlc2NyaXB0b3IgMTggMCBSCi9Gb250TWF0cml4IFsgMC4wMDEgMCAwIDAuMDAxIDAgMCBdIC9MYXN0Q2hhciAyNTUgL05hbWUgL0RlamFWdVNhbnMKL1N1YnR5cGUgL1R5cGUzIC9UeXBlIC9Gb250IC9XaWR0aHMgMTcgMCBSID4+CmVuZG9iagoxOCAwIG9iago8PCAvQXNjZW50IDkyOSAvQ2FwSGVpZ2h0IDAgL0Rlc2NlbnQgLTIzNiAvRmxhZ3MgMzIKL0ZvbnRCQm94IFsgLTEwMjEgLTQ2MyAxNzk0IDEyMzMgXSAvRm9udE5hbWUgL0RlamFWdVNhbnMgL0l0YWxpY0FuZ2xlIDAKL01heFdpZHRoIDEzNDIgL1N0ZW1WIDAgL1R5cGUgL0ZvbnREZXNjcmlwdG9yIC9YSGVpZ2h0IDAgPj4KZW5kb2JqCjE3IDAgb2JqClsgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAKNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCAzMTggNDAxIDQ2MCA4MzggNjM2Cjk1MCA3ODAgMjc1IDM5MCAzOTAgNTAwIDgzOCAzMTggMzYxIDMxOCAzMzcgNjM2IDYzNiA2MzYgNjM2IDYzNiA2MzYgNjM2IDYzNgo2MzYgNjM2IDMzNyAzMzcgODM4IDgzOCA4MzggNTMxIDEwMDAgNjg0IDY4NiA2OTggNzcwIDYzMiA1NzUgNzc1IDc1MiAyOTUKMjk1IDY1NiA1NTcgODYzIDc0OCA3ODcgNjAzIDc4NyA2OTUgNjM1IDYxMSA3MzIgNjg0IDk4OSA2ODUgNjExIDY4NSAzOTAgMzM3CjM5MCA4MzggNTAwIDUwMCA2MTMgNjM1IDU1MCA2MzUgNjE1IDM1MiA2MzUgNjM0IDI3OCAyNzggNTc5IDI3OCA5NzQgNjM0IDYxMgo2MzUgNjM1IDQxMSA1MjEgMzkyIDYzNCA1OTIgODE4IDU5MiA1OTIgNTI1IDYzNiAzMzcgNjM2IDgzOCA2MDAgNjM2IDYwMCAzMTgKMzUyIDUxOCAxMDAwIDUwMCA1MDAgNTAwIDEzNDIgNjM1IDQwMCAxMDcwIDYwMCA2ODUgNjAwIDYwMCAzMTggMzE4IDUxOCA1MTgKNTkwIDUwMCAxMDAwIDUwMCAxMDAwIDUyMSA0MDAgMTAyMyA2MDAgNTI1IDYxMSAzMTggNDAxIDYzNiA2MzYgNjM2IDYzNiAzMzcKNTAwIDUwMCAxMDAwIDQ3MSA2MTIgODM4IDM2MSAxMDAwIDUwMCA1MDAgODM4IDQwMSA0MDEgNTAwIDYzNiA2MzYgMzE4IDUwMAo0MDEgNDcxIDYxMiA5NjkgOTY5IDk2OSA1MzEgNjg0IDY4NCA2ODQgNjg0IDY4NCA2ODQgOTc0IDY5OCA2MzIgNjMyIDYzMiA2MzIKMjk1IDI5NSAyOTUgMjk1IDc3NSA3NDggNzg3IDc4NyA3ODcgNzg3IDc4NyA4MzggNzg3IDczMiA3MzIgNzMyIDczMiA2MTEgNjA1CjYzMCA2MTMgNjEzIDYxMyA2MTMgNjEzIDYxMyA5ODIgNTUwIDYxNSA2MTUgNjE1IDYxNSAyNzggMjc4IDI3OCAyNzggNjEyIDYzNAo2MTIgNjEyIDYxMiA2MTIgNjEyIDgzOCA2MTIgNjM0IDYzNCA2MzQgNjM0IDU5MiA2MzUgNTkyIF0KZW5kb2JqCjIwIDAgb2JqCjw8IC9QIDIxIDAgUiAvYSAyMiAwIFIgL2MgMjMgMCBSIC9lIDI0IDAgUiAvZml2ZSAyNSAwIFIgL2ZvdXIgMjYgMCBSCi9nIDI3IDAgUiAvaCAyOCAwIFIgL2kgMjkgMCBSIC9sIDMwIDAgUiAvbyAzMiAwIFIgL29uZSAzMyAwIFIKL3BlcmlvZCAzNCAwIFIgL3IgMzUgMCBSIC9zIDM2IDAgUiAvc3BhY2UgMzcgMCBSIC90IDM4IDAgUiAvdHdvIDM5IDAgUgovdSA0MCAwIFIgL3YgNDEgMCBSIC96ZXJvIDQyIDAgUiA+PgplbmRvYmoKMyAwIG9iago8PCAvRjEgMTQgMCBSIC9GMiAxOSAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0ExIDw8IC9DQSAwIC9UeXBlIC9FeHRHU3RhdGUgL2NhIDEgPj4KL0EyIDw8IC9DQSAwLjUgL1R5cGUgL0V4dEdTdGF0ZSAvY2EgMC41ID4+Ci9BMyA8PCAvQ0EgMSAvVHlwZSAvRXh0R1N0YXRlIC9jYSAxID4+ID4+CmVuZG9iago1IDAgb2JqCjw8ID4+CmVuZG9iago2IDAgb2JqCjw8ID4+CmVuZG9iago3IDAgb2JqCjw8IC9GMi1EZWphVnVTYW5zLW1pbnVzIDMxIDAgUiA+PgplbmRvYmoKMiAwIG9iago8PCAvQ291bnQgMSAvS2lkcyBbIDEwIDAgUiBdIC9UeXBlIC9QYWdlcyA+PgplbmRvYmoKNDMgMCBvYmoKPDwgL0NyZWF0aW9uRGF0ZSAoRDoyMDIyMDkwMTE5NTgxMSswMicwMCcpCi9DcmVhdG9yIChNYXRwbG90bGliIHYzLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZykKL1Byb2R1Y2VyIChNYXRwbG90bGliIHBkZiBiYWNrZW5kIHYzLjMuMikgPj4KZW5kb2JqCnhyZWYKMCA0NAowMDAwMDAwMDAwIDY1NTM1IGYgCjAwMDAwMDAwMTYgMDAwMDAgbiAKMDAwMDE1NjUxMCAwMDAwMCBuIAowMDAwMTU2MjM0IDAwMDAwIG4gCjAwMDAxNTYyNzcgMDAwMDAgbiAKMDAwMDE1NjQxOSAwMDAwMCBuIAowMDAwMTU2NDQwIDAwMDAwIG4gCjAwMDAxNTY0NjEgMDAwMDAgbiAKMDAwMDAwMDA2NSAwMDAwMCBuIAowMDAwMDAwNDA3IDAwMDAwIG4gCjAwMDAwMDAyMDggMDAwMDAgbiAKMDAwMDE0NzI0MyAwMDAwMCBuIAowMDAwMTQ3OTUxIDAwMDAwIG4gCjAwMDAxNDc3NDMgMDAwMDAgbiAKMDAwMDE0NzQyNyAwMDAwMCBuIAowMDAwMTQ5MDA0IDAwMDAwIG4gCjAwMDAxNDcyNjYgMDAwMDAgbiAKMDAwMDE1NDkyNyAwMDAwMCBuIAowMDAwMTU0NzI3IDAwMDAwIG4gCjAwMDAxNTQzMDggMDAwMDAgbiAKMDAwMDE1NTk4MCAwMDAwMCBuIAowMDAwMTQ5MDM2IDAwMDAwIG4gCjAwMDAxNDkyNzQgMDAwMDAgbiAKMDAwMDE0OTY1MSAwMDAwMCBuIAowMDAwMTQ5OTU0IDAwMDAwIG4gCjAwMDAxNTAyNzIgMDAwMDAgbiAKMDAwMDE1MDU5MiAwMDAwMCBuIAowMDAwMTUwNzU0IDAwMDAwIG4gCjAwMDAxNTExNjUgMDAwMDAgbiAKMDAwMDE1MTQwMSAwMDAwMCBuIAowMDAwMTUxNTQxIDAwMDAwIG4gCjAwMDAxNTE2NTggMDAwMDAgbiAKMDAwMDE1MTgyOCAwMDAwMCBuIAowMDAwMTUyMTE1IDAwMDAwIG4gCjAwMDAxNTIyNjcgMDAwMDAgbiAKMDAwMDE1MjM4OCAwMDAwMCBuIAowMDAwMTUyNjE4IDAwMDAwIG4gCjAwMDAxNTMwMjMgMDAwMDAgbiAKMDAwMDE1MzExMiAwMDAwMCBuIAowMDAwMTUzMzE2IDAwMDAwIG4gCjAwMDAxNTM2MzcgMDAwMDAgbiAKMDAwMDE1Mzg4MSAwMDAwMCBuIAowMDAwMTU0MDI1IDAwMDAwIG4gCjAwMDAxNTY1NzAgMDAwMDAgbiAKdHJhaWxlcgo8PCAvSW5mbyA0MyAwIFIgL1Jvb3QgMSAwIFIgL1NpemUgNDQgPj4Kc3RhcnR4cmVmCjE1NjcyNwolJUVPRgo=\n",
"image/svg+xml": [
"\n",
"\n",
"\n",
"