Skip to content

Instantly share code, notes, and snippets.

@JonathanFly
Created June 18, 2020 09:09
Show Gist options
  • Save JonathanFly/eb61f0d31680e1b890f3a53fbaf31384 to your computer and use it in GitHub Desktop.
Save JonathanFly/eb61f0d31680e1b890f3a53fbaf31384 to your computer and use it in GitHub Desktop.
Image-GPT_Sample.ipynb
Display the source blob
Display the rendered blob
Raw
{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"name": "Image-GPT_Sample.ipynb",
"provenance": [],
"collapsed_sections": [],
"machine_shape": "hm",
"authorship_tag": "ABX9TyOE8KX7aayr+TBvEEbpclcf",
"include_colab_link": true
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"accelerator": "GPU"
},
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "view-in-github",
"colab_type": "text"
},
"source": [
"<a href=\"https://colab.research.google.com/gist/JonathanFly/eb61f0d31680e1b890f3a53fbaf31384/image-gpt_sample.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oGskUEXmJIzs",
"colab_type": "text"
},
"source": [
"Image GPT [https://openai.com/blog/image-gpt/](https://openai.com/blog/image-gpt/)\n",
"\n",
"Barebones demo, this just samples 32x32 images. That site shows lovely 64x64 images but the XL sized model isn't available. (Yet?)\n",
"\n",
"(Runtime)->(Run All) will work unless you get really unlucky with the GPU.\n",
"\n",
"Notebook by [https://twitter.com/jonathanfly](https://twitter.com/jonathanfly) "
]
},
{
"cell_type": "code",
"metadata": {
"id": "TssZNq1DXarb",
"colab_type": "code",
"colab": {}
},
"source": [
"!nvidia-smi #OpenAI says you need 16GB GPU for the large model, but it may work if you lower n_sub_batch on the others."
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"id": "e0DcaUYv8LYf",
"colab_type": "code",
"colab": {}
},
"source": [
"model_sizes = [\"s\", \"m\", \"l\"] #small medium large, xl not available\n",
"model_sizes = [\"l\"] #actually just download one"
],
"execution_count": 5,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"id": "cIn_2WK2WHI4",
"colab_type": "code",
"colab": {}
},
"source": [
"!rm /content/image-gpt/output/"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"id": "g2Dob8bTJEAA",
"colab_type": "code",
"colab": {}
},
"source": [
"n_sub_batch = 8 #8 is default, trying lowering if this doesn't work.\n",
"n_sub_batch = 8"
],
"execution_count": 57,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"id": "ylcjIJcwXsFw",
"colab_type": "code",
"colab": {}
},
"source": [
"!git clone https://github.com/openai/image-gpt.git\n",
"!pip install tensorflow-gpu==1.13.1\n",
"%cd /content/image-gpt\n",
"\n",
"!mkdir /content/image-gpt/models\n",
"!mkdir /content/image-gpt/clusters\n",
"!mkdir /content/image-gpt/datasets\n",
"\n",
"for model_size in model_sizes:\n",
" !mkdir ./models/{model_size}\n",
" !python download.py --model {model_size} --ckpt 1000000 --download_dir ./models/{model_size} #models\n",
" #!python download.py --dataset imagenet --download_dir ./datasets/{model_size} #dataset\n",
" !python download.py --clusters --download_dir ./clusters/{model_size} #color clusters"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"id": "_IrbT9AMKbnp",
"colab_type": "code",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 34
},
"cellView": "form",
"outputId": "1332a639-758a-4c95-b03d-b84f69a0e836"
},
"source": [
"#@title Update run.py to skip checking for the dataset\n",
"\n",
"%%writefile /content/image-gpt/src/run.py\n",
"import argparse\n",
"import json\n",
"import math\n",
"import os\n",
"import random\n",
"import sys\n",
"import time\n",
"\n",
"import numpy as np\n",
"import tensorflow as tf\n",
"\n",
"from imageio import imwrite\n",
"from scipy.special import softmax\n",
"from tensorflow.contrib.training import HParams\n",
"from tqdm import tqdm\n",
"\n",
"from model import model\n",
"from utils import iter_data, count_parameters\n",
"\n",
"\n",
"def parse_arguments():\n",
" parser = argparse.ArgumentParser()\n",
"\n",
" # data and I/O\n",
" parser.add_argument(\"--data_path\", type=str, default=\"/root/downloads/imagenet\")\n",
" parser.add_argument(\"--ckpt_path\", type=str, default=\"/root/downloads/model.ckpt-1000000\")\n",
" parser.add_argument(\"--color_cluster_path\", type=str, default=\"/root/downloads/kmeans_centers.npy\")\n",
" parser.add_argument(\"--save_dir\", type=str, default=\"/root/save/\")\n",
"\n",
" # model\n",
" parser.add_argument(\"--n_embd\", type=int, default=512)\n",
" parser.add_argument(\"--n_head\", type=int, default=8)\n",
" parser.add_argument(\"--n_layer\", type=int, default=24)\n",
" parser.add_argument(\"--n_px\", type=int, default=32, help=\"image height or width in pixels\")\n",
" parser.add_argument(\"--n_vocab\", type=int, default=512, help=\"possible values for each pixel\")\n",
"\n",
" parser.add_argument(\"--bert\", action=\"store_true\", help=\"use the bert objective (defaut: autoregressive)\")\n",
" parser.add_argument(\"--bert_mask_prob\", type=float, default=0.15)\n",
" parser.add_argument(\"--clf\", action=\"store_true\", help=\"add a learnable classification head\")\n",
"\n",
" # parallelism\n",
" parser.add_argument(\"--n_sub_batch\", type=int, default=8, help=\"per-gpu batch size\")\n",
" parser.add_argument(\"--n_gpu\", type=int, default=8, help=\"number of gpus to distribute training across\")\n",
"\n",
" # mode\n",
" parser.add_argument(\"--eval\", action=\"store_true\", help=\"evaluates the model, requires a checkpoint and dataset\")\n",
" parser.add_argument(\"--sample\", action=\"store_true\", help=\"samples from the model, requires a checkpoint and clusters\")\n",
"\n",
" # reproducibility\n",
" parser.add_argument(\"--seed\", type=int, default=42, help=\"seed for random, np, tf\")\n",
"\n",
" args = parser.parse_args()\n",
" print(\"input args:\\n\", json.dumps(vars(args), indent=4, separators=(\",\", \":\")))\n",
" return args\n",
"\n",
"\n",
"def set_seed(seed):\n",
" random.seed(seed)\n",
" np.random.seed(seed)\n",
" tf.set_random_seed(seed)\n",
"\n",
"\n",
"def load_data(data_path):\n",
" trX = np.load(f'{data_path}_trX.npy')\n",
" trY = np.load(f'{data_path}_trY.npy')\n",
" vaX = np.load(f'{data_path}_vaX.npy')\n",
" vaY = np.load(f'{data_path}_vaY.npy')\n",
" teX = np.load(f'{data_path}_teX.npy')\n",
" teY = np.load(f'{data_path}_teY.npy')\n",
" return (trX, trY), (vaX, vaY), (teX, teY)\n",
"\n",
"\n",
"def set_hparams(args):\n",
" return HParams(\n",
" n_ctx=args.n_px*args.n_px,\n",
" n_embd=args.n_embd,\n",
" n_head=args.n_head,\n",
" n_layer=args.n_layer,\n",
" n_vocab=args.n_vocab,\n",
" bert=args.bert,\n",
" bert_mask_prob=args.bert_mask_prob,\n",
" clf=args.clf,\n",
" )\n",
"\n",
"\n",
"def create_model(x, y, n_gpu, hparams):\n",
" gen_logits = []\n",
" gen_loss = []\n",
" clf_loss = []\n",
" tot_loss = []\n",
" accuracy = []\n",
"\n",
" trainable_params = None\n",
" for i in range(n_gpu):\n",
" with tf.device(\"/gpu:%d\" % i):\n",
" results = model(hparams, x[i], y[i], reuse=(i != 0))\n",
"\n",
" gen_logits.append(results[\"gen_logits\"])\n",
" gen_loss.append(results[\"gen_loss\"])\n",
" clf_loss.append(results[\"clf_loss\"])\n",
"\n",
" if hparams.clf:\n",
" tot_loss.append(results[\"gen_loss\"] + results[\"clf_loss\"])\n",
" else:\n",
" tot_loss.append(results[\"gen_loss\"])\n",
"\n",
" accuracy.append(results[\"accuracy\"])\n",
"\n",
" if i == 0:\n",
" trainable_params = tf.trainable_variables()\n",
" print(\"trainable parameters:\", count_parameters())\n",
"\n",
" return trainable_params, gen_logits, gen_loss, clf_loss, tot_loss, accuracy\n",
"\n",
"\n",
"def reduce_mean(gen_loss, clf_loss, tot_loss, accuracy, n_gpu):\n",
" with tf.device(\"/gpu:0\"):\n",
" for i in range(1, n_gpu):\n",
" gen_loss[0] += gen_loss[i]\n",
" clf_loss[0] += clf_loss[i]\n",
" tot_loss[0] += tot_loss[i]\n",
" accuracy[0] += accuracy[i]\n",
" gen_loss[0] /= n_gpu\n",
" clf_loss[0] /= n_gpu\n",
" tot_loss[0] /= n_gpu\n",
" accuracy[0] /= n_gpu\n",
"\n",
"\n",
"def evaluate(sess, evX, evY, X, Y, gen_loss, clf_loss, accuracy, n_batch, desc, permute=False):\n",
" metrics = []\n",
" for xmb, ymb in iter_data(evX, evY, n_batch=n_batch, truncate=True, verbose=True):\n",
" metrics.append(sess.run([gen_loss[0], clf_loss[0], accuracy[0]], {X: xmb, Y: ymb}))\n",
" eval_gen_loss, eval_clf_loss, eval_accuracy = [np.mean(m) for m in zip(*metrics)]\n",
" print(f\"{desc} gen: {eval_gen_loss:.4f} clf: {eval_clf_loss:.4f} acc: {eval_accuracy:.2f}\")\n",
"\n",
"\n",
"# naive sampler without caching\n",
"def sample(sess, X, gen_logits, n_sub_batch, n_gpu, n_px, n_vocab, clusters, save_dir):\n",
" samples = np.zeros([n_gpu * n_sub_batch, n_px * n_px], dtype=np.int32)\n",
"\n",
" for i in tqdm(range(n_px * n_px), ncols=80, leave=False):\n",
" np_gen_logits = sess.run(gen_logits, {X: samples})\n",
" for j in range(n_gpu):\n",
" p = softmax(np_gen_logits[j][:, i, :], axis=-1) # logits to probas\n",
" for k in range(n_sub_batch):\n",
" c = np.random.choice(n_vocab, p=p[k]) # choose based on probas\n",
" samples[j * n_sub_batch + k, i] = c\n",
" \n",
" # dequantize\n",
" samples = [np.reshape(np.rint(127.5 * (clusters[s] + 1.0)), [32, 32, 3]).astype(np.uint8) for s in samples]\n",
"\n",
" # write to png\n",
" for i in range(n_gpu * n_sub_batch):\n",
" imwrite(f\"{args.save_dir}/seed_{args.seed}_sample_{i}.png\", samples[i])\n",
"\n",
"\n",
"def main(args):\n",
" set_seed(args.seed)\n",
"\n",
" n_batch = args.n_sub_batch * args.n_gpu\n",
"\n",
" if args.sample:\n",
" n_class = 1000\n",
" print(\"Skipping dataset requirement for sampling.\")\n",
" else:\n",
" if args.data_path.endswith(\"cifar10\"):\n",
" n_class = 10\n",
" elif args.data_path.endswith(\"imagenet\"):\n",
" n_class = 1000\n",
" else:\n",
" raise ValueError(\"Dataset not supported.\")\n",
"\n",
" X = tf.placeholder(tf.int32, [n_batch, args.n_px * args.n_px])\n",
" Y = tf.placeholder(tf.float32, [n_batch, n_class])\n",
"\n",
" x = tf.split(X, args.n_gpu, 0)\n",
" y = tf.split(Y, args.n_gpu, 0)\n",
"\n",
" hparams = set_hparams(args)\n",
" trainable_params, gen_logits, gen_loss, clf_loss, tot_loss, accuracy = create_model(x, y, args.n_gpu, hparams)\n",
" reduce_mean(gen_loss, clf_loss, tot_loss, accuracy, args.n_gpu)\n",
"\n",
" saver = tf.train.Saver(var_list=[tp for tp in trainable_params if not 'clf' in tp.name])\n",
" with tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=False)) as sess:\n",
" sess.run(tf.global_variables_initializer())\n",
"\n",
" saver.restore(sess, args.ckpt_path)\n",
"\n",
" if args.eval:\n",
" (trX, trY), (vaX, vaY), (teX, teY) = load_data(args.data_path)\n",
" evaluate(sess, trX[:len(vaX)], trY[:len(vaY)], X, Y, gen_loss, clf_loss, accuracy, n_batch, \"train\")\n",
" evaluate(sess, vaX, vaY, X, Y, gen_loss, clf_loss, accuracy, n_batch, \"valid\")\n",
" evaluate(sess, teX, teY, X, Y, gen_loss, clf_loss, accuracy, n_batch, \"test\")\n",
"\n",
" if args.sample:\n",
" if not os.path.exists(args.save_dir):\n",
" os.makedirs(args.save_dir)\n",
" clusters = np.load(args.color_cluster_path)\n",
" sample(sess, X, gen_logits, args.n_sub_batch, args.n_gpu, args.n_px, args.n_vocab, clusters, args.save_dir)\n",
"\n",
"\n",
"if __name__ == \"__main__\":\n",
" args = parse_arguments()\n",
" main(args)\n"
],
"execution_count": 9,
"outputs": [
{
"output_type": "stream",
"text": [
"Overwriting /content/image-gpt/src/run.py\n"
],
"name": "stdout"
}
]
},
{
"cell_type": "code",
"metadata": {
"id": "rpDPICa6KRcR",
"colab_type": "code",
"colab": {}
},
"source": [
"#large model\n",
"#Generates 8 images in /content/image-gpt/output \n",
"#change seed from 42 to geneate different samples\n",
"!python src/run.py --sample --n_embd 1536 --n_head 16 --n_layer 48 \\\n",
"--ckpt_path /content/image-gpt/models/l/model.ckpt-1000000 --color_cluster_path /content/image-gpt/clusters/l/kmeans_centers.npy \\\n",
"--data_path /content/image-gpt/datasets/s/imagenet_notused --save_dir /content/image-gpt/output \\\n",
"--n_gpu 1 --n_px 32 --n_sub_batch {n_sub_batch} --seed 42"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"metadata": {
"id": "4s522c8lGqy5",
"colab_type": "code",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 191
},
"outputId": "0e532116-6727-4b7e-ec41-689a98e614b7"
},
"source": [
"%matplotlib inline\n",
"import pathlib\n",
"import matplotlib.pyplot as plt\n",
"import matplotlib.image as mpimg\n",
"import glob\n",
"\n",
"samples = pathlib.Path('/content/image-gpt/output').glob('*.png')\n",
"\n",
"f, axarr = plt.subplots(1,len(glob.glob('/content/image-gpt/output/*.png')),dpi=180)\n",
"\n",
"i = 0\n",
"for image in samples:\n",
" axarr[i].imshow(mpimg.imread(image))\n",
" i += 1"
],
"execution_count": 60,
"outputs": [
{
"output_type": "display_data",
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAA5oAAACuCAYAAABX9nKtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAbrgAAG64BjF1z+AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOy9f7Bl2VXf91l773Puj9evp6dnNDOaQaMRwhgBkiXxqwDZsSWkCIpKKH7EJGBI4qoQF5WqUHG5wh9E5K9ATOLYroQEEhLLDnasYCNIyphSSgYnYDAgNPqB0K8ZaTS/e3q6+7137z1n771W/tj73Hvf6/d63oxet7rhfKfO9H33nh/7nLXP3nut9V1riZkxYsSIESNGjBgxYsSIESNGnBXcl7oBI0aMGDFixIgRI0aMGDHiTxZGRXPEiBEjRowYMWLEiBEjRpwpRkVzxIgRI0aMGDFixIgRI0acKUZFc8SIESNGjBgxYsSIESNGnClGRXPEiBEjRowYMWLEiBEjRpwpRkVzxIgRI0aMGDFixIgRI0acKUZFc8SIESNGjBgxYsSIESNGnClGRXPEiBEjRowYMWLEiBEjRpwpRkVzxIgRI0aMGDFixIgRI0acKUZFc8SIESNGjBgxYsSIESNGnClGRXPEiBEjRowYMWLEiBEjRpwpRkVzxIgRI0aMGDFixIgRI0acKUZFc8SIESNGjBgxYsSIESNGnClGRXPEiBEjRowYMWLEiBEjRpwpRkVzxIgRI0aMGDFixIgRI0acKUZFc8SIESNGjBgxYsSIESNGnClGRXPEiBEjRowYMWLEiBEjRpwpRkVzxIgRI0aMGDFixIgRI0acKW5rRVNEdkXkJ0XkIyKyLyJXReRfi8h/JiLtl7p9IwpGOd05GGV152CU1Z2DUVZ3DkZZ3TkYZXVnYJTTiBtBzOxL3YZjISKvBf4F8Ej9agF4YFL//hDwDjN78ZY3bsQao5zuHIyyunMwyurOwSirOwejrO4cjLK6MzDKacRL4bb0aIpIAH6V0nGfBt5pZjvAHPh+YA94C/APvlRtHDHK6U7CKKs7B6Os7hyMsrpzMMrqzsEoqzsDo5xGnAa3paIJ/DDwxvr5e8zsAwBmpmb2fwA/Un/7DhF5x5eigSOAUU53EkZZ3TkYZXXnYJTVnYNRVncORlndGRjlNOIlcTsrmgAfNLPfPub3fwQ8Vj//0K1p0ohjMMrpzsEoqzsHo6zuHIyyunMwyurOwSirOwOjnEa8JG67GE0RmVPc7Q74G2b2N0/Y738A/hrwjJm9+gyue3s9iD/BMDP5Yo4fZXXrMMrqzsEoqzsHo6zuHIyyunPwxchqlNOtw/hO3Tn4YmUFt6dH8w1s2vXRG+w3/PaAiFy8uU0aMWLEiBEjRowYMWLEiBGnRfhSN+AYPLj1+ckb7Lf924PA5Rud9LQWkP/mv/3bp9ltDTMrG4b1B+jBJSx37HfGlZWRFVQVVSWEwMWL97J7/i6cc3jvEXGInN5gYAaKYAgCOJTtw80g48jmMGS9L7zUNQzBcJTH9FLHfeJjf8gv/q8/C8CP/th/zgOvfui6fcQif/SxD/O/v/fvnfr+4PSy+re/9Stf1nm/lNCcibHHVE/Yw7j+WW++M4Os0OXyb8pKnxQ1Q2NEY0LViH0m1u9XBgnoY2aZMgDB+5PbaIae2L7jcVpZ/aO//d002jDJE5w5cs7klBDnmOyeoz23g6qyvLZHt1wSvGc+n9E0ga7rOTg4IKXMdDJhNp3ixLHKZUMEHxpc8OBAGgEPFhO6WGIpM2k9O9OAEyGq0mcFA4/izDDnSE2DDu+kD4g4vBMa7xAgrVb0yyWqStf1dF1EMZIzskBwgXNuTuMaYuxYLffJmlDLqCUQ2Gkn7DQTTBy9BSIOE9CgmIcPf+QJ/uuf/+cA/K0f+24eumdCzon9g55rBz0A86nnjz73HH/n//zdmyKr//Cnv4uWzMwyXgyZRdy8BwGzCWYtMWaev7TP1b0VTqGN4DIokKyMJvPzLbsXZzgvaO7RHDFVcv2ck9EfGDmC8xAmgniwDJpLU30jhAlgQloEcucxM5SIkQ+1uw0t88kO3nt2Zp7dmQcRll1g1XkUo5eeSCLHntW1q6SuwwWHbx04YbHq2FusUDVoJhCmoCDLiHQZH4TZrqeZCM89vuK3/6/PAfA9/9E38tqvvg8fhNgtiN0+YIh3PPZHL/J//29/fFNkde3aNULwNE2Dcw4QRORlzSnbMFNy9yK5fxHtF/RPfYJ06fMslkuefPYS1/YPONd6HtydMm8OjyUy20Fm5xB3evu1mZGTkpKiCtEaonn8dJdzj7yF2X2vw/vAZDbD+7C+r5Pub5iPj+JXf/VX+a7v+i4APvShD/GmN73p0H7Dcb/yK+/ne7/3+07d/tqWU8nqP/ihH+CJLzzJRz72cQ4ODrjvvvt58MEHCSGganVTVqsFfd8jAs6Bc4I4j/ctIkKMib7rUVXMFDSXWdsMMFLOLLsVKaWy9sgZM2M63WHn3F1Mp3P+0jvewbu+/TvY3d3lrgsX2N09D+IgNJSXUCFHxA7PB1LbIgLBCd4BIpgPIA7B8DnhTMk50/dduaflguXBHlkzKStZy/POOWFZUVNSyqgqv/Vbv8V/+ZM/CcDf/rt/h9c98kh553M5p5lhGvndf/07/MzPnH69dlo5/eRP/S1UlawZ4/hDBMH7Fuc9ThxNcHjn6pppeA/BydG+angSDq19P23WkHUdqaqknOo9Z3LOVbbrG1mf0+NpLeBwNAEmU8MNMpGymkumpHq8mmIGkgWWDpKg3ohNRp3RZWORrKwF6FDrQAwNEXMZ74w2GN4Zn/n4Y/yTX/hnAPzVv/G93PfQPWCG0OGsA1Nyv+ATj36ef/qLj55aTi9HVrcbI/NPEl7pHHIcbkdFc3fr8+IG+23/tnviXjcZhpUByQzNiZwylhXDE5qAKKyWC1arJd57lssFTRPK5DmdEcLLcyobQjJPxuEwGjH8kcHQozixOsh4EicrF9so50twiuP6brn+PAmUgeU6KG3TnOratw+OU/huBY675sntMFU09ZgauU+kLqNmdFnps6ECUYSMkA4ZIkq/OG6AvpmD9ipO6JaRxd6LSCqTnZnhvENVi0lEHLNJw3zaQp1kY98Dxmw6KcdkpdtfAoI2c0KYghOkdUgrDLaRstiG4Iu5pXFFWUQE9Q05lL+DZhrLRFUWywWLnJi0E+7aPU8bGkQ2UtDQoBNQAz+ZMdPy7i9XB+TYISheOgIJ80aYTHEKwSmNVxyGJSV3CRNBvQPncN7TTKe4JpC31nW7M8/OvCh2Mm3hfMLU8CnRNjdv6Fbuop0q957LtEHpfUcfFmSFg0uBxYuBlCAvMqHvECvPxIDeYKGQAe17wsGSEIRmsstkfhGzTLe4guZ4+JoZ4spAwDfQTAUpNoStdiWypbr4u3FfzcnoOgWEPnbEZGQ1+phJOaMpogc9FntkHmgmLdIIvbSI+nIDUsZmcTDbCUx2AjkpB9cisVP2Lvfr6+1MHTsW8SZY8Jg/h6pxsFSIN28MvPzCC0xnU86f3yWEgHMekdON97cL+j6z2I+oVSNR4wFDLIH2IIbpBHNF5i+1ADru9/39/fXnnZ2dtTK+rZiKCDs7587uxo7g/M6cczsz5rMpqsp0NmU6neJ9IKVMjAokvHeEI6+3IHjnEHFk2QwSIg68lHdQ02GFpN6T9wGw8u6t9jCL7O1f5fKVF4mqTGYzzp0zjn2sR6ZD5z2hbauys/UW1oOzGn2fsZzJqSeuDtCciLGnz7ko01nJWhQtTRnTokh5ilLdd6v19Waz2YnPc9JOTvzti8E8CIYHcyeOMiICfoK4gHMw8UX5MvEYbTHyV4XxKDIBLSolxTRX1o9ZM2rFKTEooKoZzfnQcCcCVKOLOSM7w5wVpb/CxKE+FPdB1nU/z1qUecmCt+KsKAp/lc3WdTR5cmoxl0m+Q32HQyC2BDzLxcbQF9rSYQ3IEXJvYIqYEZo7azwacfa4HRXNm4KX4hm/Ys63FWXTTDcWKSujsxO/nhxVDRFFtVioROS6SeH0l5S6XX/8MFkIVixXL+O8Gx+mbR1nh/Y4HmXAPCv17PSyOs3ze7mtOt3+t0odPWR1h62rGljtd2plM0O1SsNARY4cc/05z6B9p5KVmSueqj5B3ExQqg6NCUsZ8YYPLd77tSV+8LD66onN2UhaFFWClffIuWppr20CTA2x4qG/zi8vgrlhEVH2w4ysSkwJ7zxYsUZfd7/OgYHgEA9kt/bgyHA+FGGw/AveK60vHIGUE7lalfGsrdPO+cpw2FzUCXjn0LprkCI7MXtFfe/071WDd0rTOtrGMJdR30BWzDypE3IWRClGLin3XQwYkK3oaVm1jnWOBsP7gFlZLFfny/oYKJ5MEaA4R3Be1i+a1gOGnmvr/w1tHz7U/ax4iICyWFNF1cqiKxWF39SqBd4QDz4ILjjEl0X00D5XvTetg4hhGWKva68rUNkgimcwdvjib9WE5pcvrdPKqu/76hErC1SRs4qGkev+3MwtxzRNXpo1c+y4Y2XsyklRA+crq8aKMQ3NmPPr+bVcSk4cw05SQre/31YyX+q40+C0smqCp/EeHzzOF0aT9w7vHTkbIrZmOB1tj8im3cOj3uxT1gLlnjg03snaUlY6dFFcIjFFur5nEvviMVvfzObg9WGH76WMtUfat34vKysmZ63euITmVL2v9fctDx7DNtzjdaP12c2yp5WTd5vneoOdwTtwHi+G90pwm9EfcSQM0SPLvPXKRVg3Z2vdaEc3HZ7ToYuXOavKwByYbLZ1++pYYOLqhet6Yaspg6I5tKG0dWiXYOrW36soYg41QU1Aj38+qkbO5QJeONL20+GmrddHfElwOyqae1uf5zfYb/u3vRP3utkwQ1LEcsKZQTvFhwbNjiZ7vBp5Oi3eG+eqdfGVQzC8FEuRk1e24DwJSh0c69+hUtPyerm+QTuZrj/38WS6ZYzxxN++WEzc8WONAdmEfJZD0RHN8pb5PM3I1SKpBig4A9E6kp8Gh+ZtwVUjx+DdvBW4azIlJmPV9uiWBifOccgUO8CMHDM5JlzwhDYgTqp+XSY+az02KQup4BRfaXgHi54uZoIYEzG8lBk4AGJGypGVFg+8+ADekwWEQDBDsqNb9GiveC+0wRUKVMy4amlOKmQrC7zgGtzM4bRQPrtsmPP4SVOetWb6HMuKo5lAMykKqAuI8yBgqVDK2i1q85VFYmdFoXyqEK0ouY0I6SYO3TtemIQW1wSkFc5NZ1yYd2g2mmWPW0QUh7YXsDAnp0R3sCDHyKpX9CCTMjQbBzNCRDgAUzRG0spI2egyRCtks8EhfQjDolcKjRYp4QhdD1HLcZUpjYmSXQ/O0YugdSHUJaWPhllR/pvGocFDaFA1mplnNm9wjUOC0bRFWU6xUDq9wD1Tx/mJo+s9IRj7C0fuNgv0F68ecL9NaMWR1ZPUo9lYJaVb5qN3dWbY3y9T33Q+pzWhwVG71CuHC4hvERfX3lEnjkmYstMa00Zwg0LrAxKaYuxpmsMu6CPQXLxdmhUvRuPy2iDKtNgIjIT2kMyxuvIcaoKfzMl3v5owPYf3nqYpFPhtvJSiuLu7IT0tFhsy1PZxZsZyueRm4fzdF9m5ssd0MqXvE23T0DRNNcBUj2CGmDySw9qQeHScF+cIIWCVarsOdxBXDDQITdPinKtetXwdTXh//4Bnn3uexapn99x5Lly4uyi+UGf74qFzVEWl0rJd8BsZmyLVM8lgzMmZ1PVFucyx0uVzMRqc0sA53/Jidt2GKSVOcLgyNyB0/XEsqrNHocDKFlNGanhFNXAKBOeqYVIqm6wYFl1V/ouBtJ7QMpiWsVATppmshY2UVdGspKhbyuZhbU0EWlFCfXecUeY4D9kJKoJspV9x9bfh8edqYMtOyVWBtGP0NuccoSnKq0iD1xZngqt9tZm0631Tv+W5DbDWsDPEdPPGvxF3Bm5HRfOprc8PASeRu7eDAp86YZ+bD1Mk9kiKZSBs5+AoVvO4sao7V6gO4QyopIF8UzQdRVALCEaQTFP4Y5gVCuY2zp+/e/356rV9Xv3q+zlO8bl27erZN7RiegNFs9OibJ4ZbqZmeQP36BDHkbfoM8LacXMqHFqEVYMHItXKfGtUzbunMxbZSNOOGLcVTYHgrrt/U0P7TOojDYKfFU/AcC8G5IlH2zLxN5ZpNbOKieWVffb2O9o2oOemhOARJ0xMMIEYexbdqszYs3NY0xYlRFpaBBKs9ns66Zm2jmYawIFLCR9j9Yw5Ui60tWbW4icBTUo+6Ig5FYrZtMV5R+4ifV04hFlLmLYg4BG8gCYlLTtyn9mdbuhgT15eML/rwppOa5TYqKZpubK4eZP3uSBMmxbX7iKtZ/e8cvFiBs24xVXs4Brmob13ht91xNWKq889T7dYsNhP5F6JZmtFs9jvOxwldjj3Pf2yLLwWudBtWynW7xv543xblM2YYC8Zi1iVzLWimcluhXkhA101zPTR6DvDiWfWlrhfE49zDepgMvHMzjWExjE3uKsaM5aLxGppNA4evBC495xn2RtuClcWmX61WVw9+9xVHtYZWTy9tXTJoRn63rh25eYpL3vXriHimJ87j1ZvcdvYDRW+l4JIQNwU8RmqounFM2umyMQz8YqXCFiJZZ7tcBrtNmdleRCJfab1CRciTgxCQGZNUbaWCV0lLGaWLzxNtzwgzC+Qww4NbQk7cYIcE2t+I2XzwQc3qR+efPJJ3vSmNx173JNP3igtxBeHu+65j93LV5lNZ/R9ZDppaduWEHxtR/EE9TEgrigjg9d9G0UBCMXgFdNa0RRxIA4vSguY94UmrivyEUXz2t4+X3jyac7vL3jVPfdy/30rmqZhIoKrClITigJjzqOhGdyqm+emGUmpGo86NCWyZnLfF+VWC0WdNdvrdLjnnnvWn1+4dInXPvyaen+C9zVGW4XLl198BVJ4+XAieF+ZJ95VenppiytBmEe6fpGHOSjrJ1j1kLRO2ppAE2ZaFHJTYjaWMZPUyCmTYhkrt7jJ67OXcVJxvhgVHFIUzUaIjSs0a2Qd+OSq8aF4u4uDImNEr5wchVoYJc57DMHTYHnDWhOEc+d31vvuXT0oMZoCNIZNDFRhZexfuzUGgRG3L27HrLN/xPCmwtfeYL/ht2fM7IaJgM4a29SGNaGxclbE1YHIbSgwzvs1TWYYkq5jQ5wSw1i/vb3kMeWKL7Fdf8RmkXh9S++9/8H1BP3cM0+feO1nn3kWOGxRPis4OX7beFFYk4yPbsff983FsZSz8sOJKNTCbQrNYdrRmn3EyRK9noa15Sa6RfAiRcF1rmoGg2bh6gKpdua6ICoe3Ep3HGhCIuW98htr8lrg9Rkx0Ih1eE7Htab2A9t+UkNyrWFQ3KIuqZZJc9isTqKaQQ2xcvRgdx56WT1t+W7rhbX1v8PVixDFlIdedWEtnyeeuUzKRsqKWqHiexfw3vPkc2WRdfGuzWR/Vhg8EFlL0g4dnqtVzU3KJq4svIo8NjGVm8XIkBZjeA8Lxd7MsFyebaELlp3WvXHo01uy5LCojh3/bJCZKdmUpEo0JTN4hcq/6+v50n6qVwJK9wwegheaIAQvJcY0CG0Q2kZoJ5526rn7/um60Vcvr+j7TNeVWLucjZxLe65eLh606fzmxGoOdMXjtqNUvO1jjtvK85VKuxukV+BFCM6VRe1xY0cZrLCt6x79OVcPm2ZdJ8Cx4ZqOSiHUNcWzKDD9+pybMe/6ezrpvgDe8IY31GRJ8NGPfrTe5vWJkz72sY8B8MADD7xsObwUptMpTTskkJHKcHI4t9kOt+n48XnwsK33W3vaqljWdHxXxbTltaW8WylFVqsVq+WKPkZyLnTXjWK79Vxl60P9aTMnackXoFrGjRruYMO2lsMJD+WYW3z44YfXsvrc5z5X71m2trLfE098AYALF+56yWf/cnBc/9mMN3Jo7Dkqi+3fXf3NDftuRvsNK4c6ndQtrz8XBlOJ4CyG/prJoB4j67mfSjU/9CirnNbrIKEw4GTz9yDOrd3XuO5+KJ7M4T+Ai6+6e7MGfPryus02XLRSep9/7gCA2bk7LV/HiLPCbadomtkC+P/qn+8+bh8pvfvfrH/++q1o11Go6Tp4Gy9I43Ghxl8Ej/NhvYUQmLSFJoPIVta1m99OL5lGEk0lwEIZAwLl+7Dlq3QYTf3eczIdFqBtWx5+5PUAfOqTf3TsPmbGpz5Zsi1+xZ+5dRliBQhiTN3JW/tyacevVFbrtZvgQyA0De4GmV9vBLWSdXaVoOuV2GdSl+hTZpWVlRo9kETIsjEPbC+mdKvTDYuRYYGz/f3NgDnBJgGbNJtt2uAm5d0I3qNmxBiJMdLlRJcTsSbbQgQJDWG+Q9jZwbWFumNmdFHZX2WW0Qhtw/zclNmsZdrAxCuNr0oNMAuBuydTLkynnHOOqWamlpg4ZeKVaQM7E8fu1DMJ1GQWcR3LJBhOMz71+Nihq4540JGWEavuR8tKWvXERYepEaYtYVYSGqVlR7/oWC0OWCz26LoDnEUmXtmZCl/5yH0AfPiTn2dxcMDyYEEbPPfdc5H7772HCxd2efRTxfPyDW98/ZnL6eqLz3P5hWd4/tKTPHvpC3zhqc/xmccf47OPP85Tzz/FC/vPcXnvEs8/f4XnntrjhWf32bvasTiILFaZg1wSAqkJU3PMzbFeYpiVbMCrHpciO41x4ZxwbrphUGuGuDT6EzbtjVkj6+OqQ2idUKhfGouFcfXAuLYwEkIzE8JUCg25U1KsCiyF1rZcJhYHkb7LDHaNpnHM5oHZLKyTtvng2LlrxoVXneeBh+/iVV9WFP1LXzjgiU8u+fSH93n28SXdiz1pP0JSnv58YXU88PD5M5fV7u552rYlxZ5utWC5WHBwcMDB/gGr1Yq+j8Sakfo4XK+sCeAxaTFpGOK8nBgTn5iHyMSn4okELCdseYAt9zfb6gDSJmRiOLua0muk055lVhbJs0gNfd6ks0uW6LSj1w5NKyStkNzjRYsnU6AYKw5TSm+kOJsZ8/mcb/3WbwXg137t1058Fr/+62U58c53vvO0Ijg1XvPww7zqVffRttO6LmiZTKZMpzMmk5a2bWjbZq1knYRCu/cE7/G+GEO8B+8UJwlHOtY4PGQxTTmxd/Uazzz5FE9/4SkuPX+Fy1eWXN3r6Gv8vBmkbPTZiLEwS1LXrbfY9XR9z7KPLPtI10e6WGI/tYYSqeZiWFA7NO8cuhdXM3z7DSV3Op3y1V/91QD8/u///rHHmRmPfrgYDN70phv5I14+suZDm9qN10KngSMTJOJJmEEkEM3Tq6dXR6+OLgf6FIjq11TqBKzqNvAnzATNgRxbNHvMZ6ztkBBpKhMtWMLliMuRYJkWpcVoDRqExhxtDkxyg9NANKEzIdlxPeeEe2oaXv3I/QB86uNPsJ+Mg6z0uknX1gs89ukXAHjo9Wc//o24M3DbKZoVf6/++5dE5JuO+f37gC+vn997a5p0GEP6azXDvEDjkMYhwReL5dYWQqBpAk0ICFKt3beGtugwApkgeT35DHGeDRkvmwnboQTJhC2l9EZ489d/MwCPfeZTPPH5z1/3+0cefZTLl4uz+S1f99YzuqPTIUiJ4Txpa9zLVDRfqe61du9Uz3ZoDqXpfzlQgz5Dl40+GanPpF6JsQzuvRqRI4pmvc6weBm8H0PTisX1sK/1aPzTmcE7rD2iaLYBaQKhCfgw0MEiMSX6lOg0EU3XBB8XAn42w8/muGq4UYMuKgerTJcM3wTmO1Nms6YqmkbYMixMfOD8ZMpd7YQdJ0ws01pmIpmJN6bBmLeOnamnDYLmtC4VUB4iOE2E1ONij3Y9admTu7hWXiwreRVJyx7U8NOGMCvqVlpG0qKjWy5ZLg/ouyWOVNrplbd9/esA+ORjz/LJx59iuVzSeM+9Fy/wqnvu5g8+8XmeuVSUl2//i19/5mLau/ICV648zwsvPsOlF57i6Wef5PNPPMHnnniCZ194hisHL/Di/mUuv3CNF57Z58XnFxxc61guEssus8zGsoQgMTVhbkJTMxxiQMxYF5GUmDXG+TnMp3JI0UwdxOXxm/YwDXB+Djtbx1k9rl/CcgHXFrC3LAu0MIXQUg0ZtZyGDdczulVmtUz0va4NgKEqmtNZIIT6HnnP/PyM8/ee4+L953jLXywLrUtPLvjUH17hsY8dcOnzK7prPfkg8vlPPM/+1ZJF85E3bMINzgrndndp25acIv1qxWq5ZHFwwGJxQNd1xBhJKVXF7Hoc6+0sNYJAAsMSoSiauSqaW/NDTli3rMpm3VYLbEvRlPV5jWiRzno6zSyTZ5kCUV1dmBrJMr319Nqj2kPuEC0U2+p8Ll40u37+PNFDW/HDP/zDAHzwgx/kd37nd657Fu973/v47Gc/C8AP/uAPnlYEp8ZDD30ZFy/eQ9OWbKWhKYpm2Sa0bUNowksrmlRvqPN454qS6cGJ4sg4UY7LlWKU/p9zZn9vj+effobnn3mGF164ytW9jr2DnlgDCQ1IWvK2xaRF0Ty09fR9YtknVjEVJbOO2zknTFNRarVQ5E+wc4A4xPsSq741C31bVfQ/8uij/PEfX18a6Ld/+1/x7HPPAfAX/vzbXvLZvxwcp2h+sSu1kiisGAEUIZqvmyubemL29NmTdbP6GhTNDjY5J0zQ7NHYkNWhLmMhgo8EilPBW8ZpwuVEsESL0qAEIFRFs1FPowGnnqSO3jbK7Kmek8GXv7U4EJ78zFM8/tizLJLRbw01n3j0aa5dLqEDX/7me7+oZzjizsXtrGh+hDLy/JKIvANARJyIfB/w83W/f2Zm/8+taNBAU1ATjthS2ZCMSpIEEbdewDs3UCkKZ2FY6G9PlMdNimfa9qpiXk8fPWHvI7S0bQrq+s7NePPXfRP3P/AgZsYv/v338ulPfwooSvhHHn2Uf/pLvwTAV/7ZP8tXfMWfOfP7ynb8ti2fV0I1PhWOe3wvJcITFkAv55ID1WagF2K2LZUjtGHWGUq92yiTQ3KIdbyjlYyrwDr25Kyhuaw2gjhCNb6E0BBCg4gUKttnJjQAACAASURBVF3WQ3VGxTnElRiRlJQUSwxQJUACgheHlxLjqTVpvNTYEucHKtqwyCrZ8obnNjy7Tc3YbernFm3K+0MWdyiUoCygYiiG1v8Ghbgo8QNleDhnoVGVGChb0+c2FLfSpre95XU89MAFDPjHv/4HPHnpGm3bAMoH/9Wj/M2f+xUAvunNX8Fbv/Z1Zy6rQovL5BzJOZJS8YqlmBGEJjS0oSFIiQNyZlhNhFQrFayJqjV5f13gVjopVLpq3eqzEl8caNubCxAaITRSwgCH37YoYNcdU2sPBnGEOhZvsm8aZkMtPsGygJVxumzDebepiSXxUzQh2UAlLuP313zTfdzzYEle8vjHn2P/6oKUMv0y8tmPP8dv/fqnAXjodRe4/zVnXzqjCZ4meIJ3hFA8WwNDfTPWVw+gFXqj5rT+V3MqpV6qB0orbXpNeyyDB3i3fg9k3V+3+0yl/qmQVdbK+tCXLCdES4KuIa62vAN1XslALhkrU7YSq5a1ZKPNGwq9VTp9XlOD9dB8epw3c/j3h37oh3jjG9+ImfE93/M9fOADHyhjX868733v40d+5EcAePe7383b3/72s5dV0+AH9zvXt9U5V9YPrhIU12PRMFy99LxxmvnNgJwSfd/RrVaslgsWiwOWiwV9NU7E6gmPsRjZclUg11sqdZB1K6vseqvzia7ptSfJZfOdrmVbamq+49vewSOPPIKZ8VP/1U/xoT/4UK3L2fObv/kv+dmf/TkA/tyfeyNf9YavenmCeKnnc3Setg3V9UZz/Ele9RKfuk2V3dCJhzlpMy+xRZndxJCtzzGUhTFbzzZl/qnvIPV4ZTvn0OaaCpal/L4eRLfG06P3BEAdC33NOLy1feVbvoq7H7gIBh/8Bx/g6c98AZEyfnzyD57kN/7xRwB46Cvv4f7X3sOIP524HZMBYWZJRP4t4IPAI8AHRGRB0eeGdKcfAn7gVrYr48jmqmpZllEOaCjJKMoqpymJEUggJXFIj9BnwErGy9hHzBpSjqQc1lSYm9lmABGjrTar0xIkhEK/dSiKkG0g1SqNy/zgv/9X+YX/6b/nxRcv8ws///M0TVO8Uqlc58EHH+Qvf/+/e/Y3BqxOKhsg0NQFzU3Dcee+wfUKbSkdipu6GfB2vadWAfHFS9H3xdOQci4pDrcgQLgJSibA8toBBMdd7QRzAj5ACCWOZLlitVfi2MQ7cJQC5c2U4MqEem3/oJSZ2NmhdQ3iPUEaZk1DdpnOLYnS45xnMpkRQoPXVGt2GlmF1Bdl0RHxxKKcNi3qqzVdHFBijFJKZeINDX42Bydo15O7FSZGdMKyKW+RuoShOIRAQPAEL0xbh3eCBldqmQoEZ4RQLOShmZKDx5sSUgRVNBm6gr/23W/jv/uH/4JLL+7zP//Sb/L3f/W3MTP6WN6r17/2fv76f/ydLOPq+Af+RcGKRyL25ZpJSV3GO8e52S737haFKcWMJqVTuNyVhDs1NwgAUeBAlAbB+lzuLxtJHG7aIkGKvClKZjMVth1vItC2nnZS+mTXZWJfEqENw+VxxwE02rCjDSCE0AOl/mYmkklIFsLKYy7QTI3pjuFDKXFytEKIGhxk6LUYFlLsUBeJXWK1jHzbDzzCr/yPn2a5F3nyU5d4+jOFKjbQVS/cM+cb/vwjpBtk536luOuuTfbvUlJH1lR45wznYlGWNZW5y2opkboa1ZoNuSiRAdiqLZk6CILbmWDJoVhxC+eIdaviet5CVE+XiyI6Vc+kPASsX0Hq8Vk5742dSUk44yUBQsyebiGoGauFsrfMOIFsPdMYmISOSdfjYyRnR8pWciGIVDqtrGMdj8Y3bo+zIQTe//738/a3v53HH3+cd77zncznc1SV1aq8R295y1t473vfe7jkxxlhvrNL204QtNbcjvSVBSEiJbQGaHyoJZ6G2pjF21uUt2JEcUc76cuBGavlAbFPdKt9nvzCZ9m9cJ7d3R2CPIymexAp5VekxuQOyXC2ToJq3NTutLw2vhSPplbj3tFLG5ZLLGe5p01ZD63HlfIYmR//8R/nJ37iJ3juued4z3vew2QyQVXXmexf85rX8Ff+yg/z4tV9zhI5pZprozxjNSMnQ52W72/4aAfG0GFad0paQ6aon4tRPGYhayglu+p/SvFgGkXZLE4CsFRil8ERPWSnKNAokGsMZy0R5TK4VHLP2qSMfKYQO0ixOEuSM3QCmNJqydqeEKJtrimU//nW45pNllkArw4ifMcPfie/8r/8E/Ze3OfXfu6fE9qSsCnX8e7u+8/zje9+K92Vk2uijviTjdtS0QQws8dF5E3AXwe+G3gdEIGPAf8Q+Ltm1t/gFGcONUfCg5VF5fAierP6IAVzAXOl4PSwaM1pM+lpzqRUJv+cCy2jBFo7bkZs3NBmoSiZLxV7eRwGYpMgVbUun8QSF+/e5T/5sf+Uf/kbv8nHP/ZRXrx8Gecc999/P29685v55m/5VsLR6tNnhP6ErLJiNd7rdiq1VC3n2x67m4GhPx79Tl1ReibSEGNeLwSgxmqKXBereZbolx3tbMJsFnBNgKbB2gmmxmrZ0S17RCBMG5yrCmFocU7Q1NEvl5gmJj7APONxNI2n9ZOiODhIJLyANB7fNrhE4VmmYjkukUtunaEUgRxApWYRZOP11brQ9E2Dn0yKR1OV3NXYGQd9GGrx1SQ3OHzN9eecMG0cwTt65yqV2SoFUEEcvm3IzQTRjKuJhkwhd8pdkxk//WP/Hr/5kcf4f3/3ozz17AuICI+85gH+jW96A9/+jrfSBF/KptwEmGUs94Cu6VTew2R3yt3n7wZVusUBkRUSBUtFL8lbVQwyRidlsTQU19RcEv9LG5Di1gLK4sgfyRUhIkzmjvlOKOc8MEwO11MEu/44BKeekEsG3+yVXBVNIxXDixXqmROPtNA2SpgcP14YJYt1t/6rPJHYZbpVop153vbvfBkf/o1nufJ0R1wqIjDfaXn1wxd4wxtfXTy+6ezHo515e4Nfh6UqawaE5kK5L5mTE5p6MEV8g4SG7TqclmPJPzANSBRIiuIhOiz21ymaqcaZiTma7RqBsYd+hQPmQolrgHXbLEPXe0yN2CnLLlevdcI0YtNETIk2D8m3BBHDObB1TUe/lfhm+Dw0YdNfHnnkEf7wD/+Qn/mZn+GXf/mXeeyxx2iahq/5mq/h+7//+/nRH/1RQgikm1CSYTqdFWVyzRjIxaAlgg9CCKVeqPeFEouVLJ+DF0zr39hQSuOVwczo+xWaV6TUc/nyczz73JMsl7vcc9c55pO2ZrZta33fWuJp66JmBhoxOzz+aK2de5Ihde3hrnH3WY1sxVOnOa+9mjllLl68yE/99E/z/ve/n9/7vd/j0vPP473n1Q++mre+5ev45m95G4jn4OBss5qqllXOQIEyKyVBSoLkl6QtcZTWPSifOZd7zVpKNGUTknqyObKVMRfKW9FzvfPUVNFUS5H4IcmQkMzhzBWGhqvrnyT4vq5RnSG+eDNTFFIvqIM8UcxTQjsAVz2f6YipemA5+ZZDrZIEGo177rqHH/ix7+UPfut3+cyjX+DapQPEOy4+cJ6Hv+pBXvNVr0W0IS3HGM0/rbhtFU0AM9sD3lO3W3XN8m8xI5YlpA4UhfL7QElyUlJLO1ctR1ImAzOpXpG8puYUulaGlCBGTATLpWyFd64UQ7oJEDFcbfOmlPzGo1mW3rYePgxHXt/j8N1Amt3+tp4fmE6mvPNd7+Kd73rXTbmHk3H8bDtYBZPdSNcs6dsHStJ1MSSHKLhy6PuBAg1UStpLt1Tt9HXEDlFudOv8BpYVVdYT9Hb2+9OsPUSkeC1P8FwOlsyzxpAptnD7SvIPS9XybUXLMAHzDRYcmiDlEktnaiWRkBSTh6ZC4SyxKYVg5JwjhLJAyknprcan9IWyZ85jxWGDqhFV19lGS4HumrpeXaV+DYsikJod1aiZczGc+vV7owy040K58PVNSbn0xJiNVJNABFOcD2UBI25D0/ShUG2z0M4MgjKZBL733d/CX/7Ov4ClJRYXmClRjbTsXlY8zcuBWkZUIVm590pJLR7VnsVqAXWxmmNPn2Md99baTFlMZ48mT95yARR6WDHTyaGOXehe2GF6bOMd87bE7sZVZlWf16FD66vl2MQbuy0jlOYiT4xC912Hg2k5lyuyItmaQlsWh5UmO7RNC527bRq89wRJhTUhjtm04aGvPserXj+j0ZZW21J7sp3Q9UpAOH/XjZTCVwg7ohCJACcbjGxYCKsSY89ycUDOmSyBTPEAW32mWEdYRVwUvMIkCY2U0jFJSzH39XkrDXCrIfV6ZUGtWrypA91vMFeW6wnBFQEFKfUbBUMtEVPEp46+WxJWB8WF7RugGM68LzKfTBqcFEXZOcoYY3YoEdrw9+7uLu95z3t4z3v+C7ZHu5RKXGHfdaShptAZooTR+DIWiS9U45xwTvC+wblQvNC+KHWGQ3JVOLcMAMLmnqSG6oCCc1uZnK1mGi1j1jY1tbwzA509sTjY48rlS+S+49KFC9WDGWjbSc0x4WjbcEjRBEMssSl8VkMU7KXyTxRju+WEWqVIaxnjc46VJq2FllszFH/bO9/F29/xTnKNlTc1+r5nsTioVOuzHQn7rHhqNmor1HqproVsrtSSRErIwBF20vW0W1sbCk4LEcGbr+/KJhyDgbI6hGGxoSEXw7EguWY/r++aVEOf1KE5Y2QplPgNZXmziHAC3jbnrjexjvk9mjTQVUbKpJnxjd/+Zr7hO76WFI3UFy/w/hVlsaeIBoLeHLbUiNsft7Wi+aVCsbQVakeXjS5VqhvVGCulcHFwoaR8l0RAyWJE69Hs6PvIahXLYBl7curRlNDVAg6WWIyk+bzUKQoNwd8cUXi0FhCGbI5EKAmCpCR0cBhNpTANQepQ6LKhLqAzjmRuvc+dgKglIc5JaALstA7vICUrWSi3JwyEToXrnBBbpywTYjyVAjkotKeCGTluamcOSWhUawKgVLIBdnmYKE532hMvx+a2bpZ0w7TBTVuYTsB7tO9Jy2Vd8DiY7BZ66tRhrSOuIovVHt2yxzXgpyU+LAFx0ZF9psGhraAC7aRlR86Tk7JYRGLf4zXS5iXeMmEutPMd8ELfGV1KOBPOCUwaj6hDtEGkJL9YJSVlwyfIKeOsJFEITYOZp7VMTB5FiSSUkmyr9UpbvZeLriinKfXEWKzuk505zOeIc5X5UJQXP5uVsWWq5GkiZWX/2opPfexTpJgJJAKp0kb9eoK/GUiskGSwLAuM0AphUvrh1f1rLLvV2jOhqiUh1UA11ATdAjSjTOllVgxpA0zKooNQjGBEoNDl4sqwXGplhlo55Nyk4f7z82JpXyn70pf+XjuqKqRViQ1tESbicUhJPBVqrFOCPhlejJ3gmM7L8nglkSQJ9bBaGdIXqu50Fko/6JVuldbXSBEmbcs9d+8wm81pJCJuQXaJVZM4Nxf6ANPGM20nWBb2Xkxcea7n3PkJr3n92ccoWT5co1NcA67lxDfZDMsRTSUhzBeeeZblasVB9FztQqH2Rci94SSz2+4xD6W26mvncHcDWR3L1JDi4T6oJofGknI5YZUDfTSyZXqLZFOCBFppcOJoXEkypKYsQmJR6/ultKSPPWkRaK48SyeGEVCZgLhaHqR4/86fm+N254WV4VucaxC3iTcXkUNKQDH8Dh44XdNnu64rz+gmhDa0IeCbBgszcpjRq7BcrUg5EdqmJAkSX7LPTgIpCTnX+qJbdGARQVxJLOi8IkMg3sCxEiuJZ1xR6YM2iPOkGEk51ljK4mXrUZ558nOsDvaZzeccvPgiF++5lxAaZvMdfGhoJoHJrD005ggw8ULrq2JU40tt6GMnPr6yttLq9Uy1HIqq0vc9mpWcE7HvqqJZEt+pGbFP9H0spZfSipy6EpoUz1bR3F8pTWNMxOErS0UllHJa2aNSPMqGEezka2/ycby8/uTxiJsU/oVFYvUaO+/WRlEZlP5hHAacCj4XpTiT6XwGMRIOn11RNEXJXkvstV6/JvGUJIqH7uMEJ4hzjmZSjICdTejjlKSZay8krl6K5AjdsqHvHMF5LuyM1Nk/rRgVzWNQrL7FO5my0qWh/poVap6rJXG3Ev44KanzrWYpyzkTYx1EaxY201xm8b4HkVLgOKUyQN+Eia0YvoovcqAOFlLI2j8LbKixWtTSanHeZJ8rCZDcqTx3txQ3cOUNQfFlv60fKr0qAG0opRE8IPnwZKBWeNrVfXn8rQ+JKIZCzCdi2wo4NOj6GKL1aaH2myNWdTM0lRirrMUafBYiuRWmA1/L/+AD5j1mPdqX+CRjCmECTrAgmAd1mZSV2KeaUMcjvvTNnHKhYU4TasVI4rynbSf0lkixZ7Xs8ZbAIr5wNml8SS6To9FX+rsJBOcQtPCtzSMqZaFrYCpItpo1sEz26JDUpzw9qRRAEfBiBFGSOmKuNKk+krplidGcTrHQlGwtawEIrinFv30wpr7E7Fy9esALz1+mW3a0NVuyuJJUJDSvLHPxaaCW10OECDhf+quZseo7Vv1hqpqmrbI5ppAj5ITGQI41oQxD34eARwjUSKH1YbWOOeIM6uK6DZ5zkwY1ownHKNdWFMkSylbGYS8OlYF9UZTQHIdnJ8yCkASiDL7oWo1DwPthLBZyLhmdcyolU1JXxgk53xCYIniyZLI4Wh9om2JgmEyF2cyTE1y9HDlYRJpJw2QyOVM5lee2ld1VBDO/9mgcRfEEF/es5UTf91zd22P/YMmVleOFhS9ZRldG7Eq5jIvnes7PhH4ivLoFmvKckzriMQvV69pHUUyjepIZy/LqFk+wK4m8gpR4fzUjOCW44mGJORI1IXFF1x3AYg+ThkwC8YcUzWnr0VTyIwiBEjPtcM7WSua6TVsKZ6Gvlnm66zpWy+VNmYuBGkda4oJNQonRS4lBLM4FnLd1zW0zWydEOwwpnszhX6n1TkVL8LJp8eiboa4ogWZSqchWvIZWNkvGwd5VcoxMp3PaMGW57Gjalvm5XZqmJUwaJjuTtaI5sDDmjWMWXGXJhFPHjQ7ZXEu8cFrTbfuuZEgeFM2cE0mFmGvG9S7SdX2lkC7RvKpyO1uac58NnBFMwEqqR8EhtfyHaJk3VEv6t4Jj5vHB0/gyFE2R4kUd1oQ6UN8rjbeManKIWbVJVFRGPAdkZ4XxU9c7w1ooi6KusqTs6LVZH7++h7pTvn73avSsfSJ5sjakJCwXytXLQo4QYyBHT9t40nRUN/60YpT8MRgCzgdrp9XaUjS+0loKaW4YrLOV2CsTh0ioSQqMEBKahYzHLOC84CcTLCuuaTCRYlk0u6VKnEH1v7g1dfb0qGVS7Nih55bCaT6cHfIYbC8qCkXJIa6URTi/42kDdEtjqYbmzf1kM1IWct6o5EfptbkG95dEJAPfbBvCOrOIlEyL6z+227YVLwnlQsdOTCK4UJIzhKw0Sa+rT5ZvbVc6NWIWnHkaafDOs8STbMh+V3cyQ3Iuni5NJTnLRHCtW2spJa1BYRvEFOmWJRVpMkGtxDg5Z/hgeANnDY5AaKa0kxnOB1YHS+IilZRe0wTTulgXV5IUaU2BiaGaibFDcklgEmygnummzapgCXOOiCuKshVvjiCEtqVpC7WsnU4I/jC10UntywYWM3HVkVJJUX9+d0qcNLROmfjSh5vJhDBpS99JN4FAu+WpMgH1Ruo3iuJR5FzK7iSj3n8L4lEX6K2EFfhKyRIBCbnQCIuAAGiDZ77T4MwxmXhmOw1NcNy3c567J3dhwOrCLt6twIQgAY8nJ6NbZjQZQYSJK4s1FciuKH6r7oC+XzIkMPNSvECTHBHL2JAwzYTcwcoUBGIsCzhxQjsV2laKMul7IgsSkc5WZEu4FnYvzJhrg3ctjS9JhcJEaKZgLnP50t6Zi+q5S3s4ByHU5DghExpDxBGCI/jqDRNf7kWKLuKtKPRmlYafC6tDM7QamUukEeNu6TnvErtSyiNsY8iEmWtNS61jmVMhdILzUhO7bCh+pbZiwvshve/h+3HO4YMvxgEzumRon1kuO3JYYSSy1Hjomr3aO8dyEli0JYmOb4rBpszVk8OUT4OcevpuhVkmplTrjGqhzKauGjnOnjFQ6P2B2aRlNp3gnRBjP9BdCKHkdnDOVwXyZZbgOgYDfda7GqcfimeulGdTvHNM2inz2ZzJdMZ00jCdlLqxwYEXxVk1kNvgMa3zbdiUvylKUfGqDp7twVgPbLKKmxFjT0p1fZW6NWW272NR+nOmj33tK4XWrgaxT8S+lOrR3GPaF5ZPOluas5aCcCV5ljrMF8XS1fhHp8V4Vi5blb8qq0HpK/acci+KkTKkqjCfWOplLbTNRyeeQIOY4cjX7bNZ/5Qvc819rs7W2aHXc41RcoFoNcDJ8WVb1tRcseLNFCsDxnUwoCSD6pY9V1/s6PrE3gs9y72u5Bo0BRpyyixXdwYbbsTZY1Q0j0FOmdWyUFpyLkHqZa6e40NbLKRYzUyXSVYKJJgXXFtoKiHApEmoF2KkqHNOac+BnzY11sSTsuLy2XimTgtDSANFFqXZqrF5YyjOImKJY01itxhNjLjgCMFvqCRHYGpl8kqKbxyzuug/v+N58GJg2gj7e8pVzeQtnmxS0L7Q5TJlEZ2O3G/MxfppBpIV0cihZyIOcw3m/Lp8w1rZrLtpVlKMhxXLE2i2zglh4kvcXJQad3HYC9urEm9DTXOZHY0FZn5K4wO99KVmWNZNWQkzXOxxKRJyppmCNiUxkFSjfq5TqSCwKlRiEQ/NDoQG1ZI9tJ1kPEJjMxyOyfw8OzsXcN6zd+kaq8urEkfZTmHallVEaKBpgAQuFZU2RdJiCWJYrV0nCKqbyVtiwsWIesdiCuBx5vH4Ej82mzHfuYDzgtTautso8izJVXTV0V29Rt9HAoH777sLECa+KppeCPMdwmyGaSYdLM5cVrrcap9AUi1xmyesE6LBIpWsrCYBbXcAI4ojW+mnM1f6voghbcK1tdafK3FEs7blgfkFZqFlPplw186cNnjuPvf/s/dmTZIkyZ3fT+1w94i8qrp7TuyCAFe4oOzuAwWLFz6Rwi+/FILcFQJLCghggAHm7DrziMPd7VA+qHlE5FHV0z1ZwCymVCSnazIjPDzczc1MVf/HC748ewnO88WZsKngCazdOb30lGKQu1IrVTLFz1Sp1DyT02zXaNqQ5i2pJN5tb7mb9uScYKf0WckamGpHUUeaZra3pvnoIvg2NIbLQNdZAqBhy549SQu7OpNrwa3hhy+uLEGdKtNU8bMynAurnQCJn/7k1bPfq7/621/Td47zdSB4R9+vWA1neO84W3e4dbCkxQ8gwZLf2KjSwcSbUoY0WyezFuWKPV/Iht5VvvSJK5fpnTCIcSNPo2hh0tn4dtmUVEWsEFuStV0WZIZWJafMXGZcdOiDzasA3ntiFKpU5l1iOxWCzOj1hjgHKp4iEcQ1f+poncLWvw7e0w2FrustCfWCc/e5sdO4Y3PzzlRf88zU1JWrLvZKDnHPz6cNIbAaOi4vzri6PEfzzG6/JzTYcN9FvJOWPAeqwKKE/V1D4KDMSwyodlYgXxJN7zk/v+Dq6iXDMHB5sebi3ATZQlCcayYbs4loOddso5xDgh0TrEvZJAKZq2uWHYVcsiHDpsy8n6ilMu73TOPOinjzhpL3LdE3yoBBZhcF2kqt2WC2Dc1jS959e7jnjOIMrTDX2LiYi1VWQ27k2rymHdXbtw4oIotibm0FnNIEH5VU3dEv9lucrq0hVnTwOsMD8aWlq2icXpixDrk4hwu+Abga5BohVI+U9ny5jMr9JF0aSgCBHBI1FBMfenLuL6iaSN/2Zs8vf7Jhtyvs7/Zsb0dQ6FYrur4nFeHmZv/UQT7H70F8TjSfiAVbX1uSqcXkrq1ydSIuwNKRMvEZExdxjT8iB+/CvPiOOUFCwElbgJF7PlPf/jw//veHG8N73Jmlq8ZjXo39QZ6eXNRUMX4XalNOFY9xrx5vgtv3a1wKUSWgRK/EIPQBhigMnZAD7J1SXL33bvMIPC5kCvcuui4dObUkSZb/c3KQpWYoDXn88D4feRzHy/3k/WjHWxYU5wQvx/tof9YjPO47xqeCjdUGQ3Li8eIRbDNSTr63YNfQSUG0mq9iE3c5vcEHOE+ppFyad6JVcA0iZnBPpw5pLBvngwlueI+oUOaCqKL5aPOiYmVrdTb2rULdoO+iVPUtxRW0cZaN81ZRK9+SikelKdjawEDE4WPEPQX9tItuG9xcqCmTp5k8z7godMPKLFt8ZQj2HeNZT1gNaCmk+glUZ+v90adlgbSenvL9Akeui6G4HLxHVAwca/QyOfg7eg8+LDfe7m/nPWd9x1k3cD4MvFif0fnAZX/OWbwA59t1CHgJXLhLBllRamWeJ0qtZDcz+ZEqhTJPlHmPlkLuoMzClBP7khjbprj4GVcqgidj3ZlUM3kyEY7oDOArIoToDjYrUKgUipbGoVKG4BlWsdEqcuPCmSKuj6Y4u9s8rzomwO3dnqE3uGgM1oFxBELwdBG6TFOTLgbBbGNyeeiqavPd0wM6w0thkERPZc3MWjJRfFNUvj+GF2RP0UqpmVSMCpJyIbsHHVDseTqsd/dqa1a8RRbBE9fGlT1fKWV0mlHx5GX9bPNt9d68H5Ndcxdy6wpacntvzsY6Tbl11VKaSHk6wg8bccTpp+hoGmfUfGgDc0mUUg7z3+Kpu3hxH+a+3yZat0tUj+ItCxiDY5c1xo4YIzHa2HFi+gX2zOtBYVgEg9TzeI2ysWDzQVErYuSG2EqlMCfr8E1zYhxnas3M056Sd61glM16R+vB61mr+XQazFkfOnJ9mpBFrMmEqlRaR1NoCDT7tkUbWrmt805NNXwRESuL0NGCGjiMsd/srtr9t+4jqgeng3uvaXdCGhVD2+roHEf/jfPmQAAAIABJREFU4CUUg+W2znQ78smxjrDoBUP7sBh0/x21qQdbp3m/sZ9xl0njDAghBjTampjS78Ku8XP8c8TnRPOJ8N4zDINVo1pVChFi7A5+l/URTPJ+WBXZSOOyzI5qG+5ipUq0pSGL2Mu3DYXGqbz/ALsD0/LkfFCcVII+/L0do0LzCLWoCBl/+IzfxbhaQ+iVuKqIF6pRw6BxHJx465J1gtSKD0LXO3yETivTdiLvYbybYZeRUtHoINiU3nlYBwyWWSxZXeCUliAKrraFtRRbi+/N3No8SGn3/shXW6I2wZ/TX39oOnYC0bcKtQra/KoOf1eIqVltaOMYtr9pXdTvvvm6fopkc907fGhiWbVQNROdjTwv2YzbZfGGD7hUqFMip0oMjqG34o0LwWDnCuO+st1nRCq9jJj6eiES8G5tm9BaqVSmec/25j0ijmlnqqmqyjjO3N1tcTHgsU1eqZUgFXFKEOMUghKbSixAKpV9EnIq3N7O7HajydK7kYLgxdMRcAi+C4TeFDHFwUOYt0PptOBRck5M+52pUfqMiwnnTNV0verw3tl3rQb/9J8AOivdqZkl+F7xg4Co8SiXzV4uh0KZKc3eN8F8eXbO9y9e0IXAZRe5jBHnwa0L0lcEh2dANHDe9Xz/7IJV7BiGgbPzNd4HVt2adbcG5+jEs3b2rt4JEXsOu8E6zNUFsvRUUbSu0PoCVCl5pGZTEj3/YmI7ZWpOzLstJc/s58T1uGPOhevNDW/ev6XUQhwMMuuc0DlPVIfKoiDc7AJmyLMyU/HeIME5Ca70eK24qPgzhaSkZ+aSAbz++hYf4U07zyH0rOIK5xzDEOg740YP6xVd3+FED/DhN++37PaZKVXG4thXg+LfIETxrIAvnTKETPCKl493+ZakxaDLlVkT0p4Fx+J3GZqyrD9MdFkdUzZ9gH1K7KbKXJRMoHqPk9jsWEqjqxTbTNcmwlUDWpfnQBEyrtFCjGnfikLNesiHSL86J5RMyD1dmSmlstnu2O33lix9Itsg7z3r9YqzszPQwjwt0GZp3UJtiV9AMb6mW5Kukw6eNsNE61g2f9QqH53frUjuLJGvFalm8VSLFUZyDVTnIQzmY9yZvYkTowbZZ/mDv2bsenzoLYE9WGOZIJc21NeimVpTpc6NCztaR7OUzHZ7yzhtySmxvbtlHkdyzozjZF7PzqhIxlfVBvdWeGAh8pzRrU0BPTm7PsFB13ZUxQlzK+hmzBZEqhJLxWk9FG0suTSND1XIukDMBW1FrYolssu98d7jHn2ngiye7QqiZlXnxUZ1cDxQA/54VA+IUoAiJmx0L0RYymlBHb4Gm/PEBLpsjVacU6Yxs7mdmKfE3fsd490d0y6R59SssYQ8KtQZHwKr8/NvfS8+x7+M+JxoPhGxydfDEf4ANCiOXzK8jyabi+JddYJLiglLQ61CLgtQ1SaQWuN362g2COz9RFAJCE4eb0AD5XGigyNpOHQ2lyg4UwPlnxsg++H46hLCAP15xXmY9zBvARWiCwQX8QIrX+hdPfIVBKZauLtJ5FoN93c346pS1xFtBYLeC3RiVXVVfKGZNzflPpXmPSXGFSv31fa8U3rJ+GZBkB80iR92SL8pfGsWtZq7LeanXYFmxeBVKSporZZs6rFz8ZvEQ97nc8TFKiBRGesEOAoznS8NupMQzFs2Bus85gJlVNKuEFfCuvd03uGHFWF9RkX4er7jehwR4AUQNOHE0bmIcz1JZ0bdUjSj4x1lTogK43bTBJwq+/0eJOG7jpXviD4ipRJcJYalH92UK9tPVWXOsJsq45T5xbuRd++3pKLcTYW52FaiE5PBT7WNDTCe9oPOZnDCee/og8NLJfraNnZy6PCcX11y+eISHzxnJbOadwQRzt3zF4FkdX/u8IMQ11YDn5vCK1XRVNDZIMaqM6dWGyLC91++4H/64Q857we+PDvny/UZ4pWyHqnDhNOOTl8SdEUfAhd9R/Qev+oI52uDGcvi37fImtmdsMe4CQkp2LbL2SZOjOYg/vwoBKNqz2npqSVQS6aMWzQnbnbv+dX7f2A3bfnl61dIzcxppuuFblh4TtYNKFpQZ8lmLaaUa9ekoiScF1zu8cU8YsOghCvQfaFcP/9z9YufvaNIIXnrunca6ekQjj57oXO8/HLF2WVP54WLIdIFx+0+c7udGWdlmysbta6LefMFLhD+yCtnIZlIzTf4EjtvAj00YbyxTjgcg+twYgmojyYF7J0/FFxSdZQaKapspsxmX5grzBqpIVB9Z12ilBqf1Db0UiKeDCGg+YKD9ZhmnCpOC6Jd4xb61o5z+NAznF21hC1BtW7o3TZxt7klF6POfIqIMXJ+ds7FxSUlz+w2dg2cOJy3nnGMga6zpD54T3H+IDDYSp3UeoSye2fc9PpN4mAiiLNkRklINXnAUmZSngglUl1E4xoJgbBaEbwniFpRsBUIvDdEioQO8R0irs3b1omN0TqzNPgmztRbHbZ4pXlkTntSzry7vuVuu2Uad1y/+gX7zQ3jOFEOQngeMB9dVwvO10OnUx9Vdp8n+sueuSb2daRqZfAQxVR+k0D2CxQV6zSWSpgr7kS8b+li5sZLPc5dDpXA4rx+Op/FEB58mzaGycdXqtFwejEroAYW+c1CoMbWdUYoNVAebAjNoaA2PQKHr5EqldFliph+QhcLMVSmfeL67cjmbuLdqzu21++Y9ukw3wKkuieNQjcMXL34nGj+vsbnRPMD4e5BEdpDvkAZlgV32ZC3X7V64/EgwgGCupC1bcJ5DDr5rnGcwE4/9P7pPf7r6R/sCPowA11e9YmULZ8joheixyTWPeAxkTjFYG9e8KL0HvrDfrxNgKpNSr0ipeLqcgOP16ahR+xHFm/5ZTw0f1I1iGT7031gydJCVIOEPfz7t4mDbxpW0XYNRvsweVwgMw99sNCnx8PpsT9luAZHrVqa2FHzngSOWK7mrucW40YWpHbzSHQsDozyYCRrrdbOdh6Rxks7vEYb3ye3Y1bj9KprYhIFdVZQckuncDlH5bhRaP8uFcZZ2c/KOGd2k/3MWdmOuVlpQNeqzlOujMmkMrw3QadT2FJ0Qk2BPjqCU/qoRy5vSxZcN+OHTAi1XUd7n/8EtkinU4HtzfVk/C1nLsexrWpQZ2oTHnF451jHyOXQczGsuFoNXK0HxCt5pZQOHB19XeF1Tec96y4SvUO6Dt/1SDhyRY++dO1/dJn5GhygTcBNl6bBdE0t8uhu71G/Au2sO+aC+flJ4W66wHnhfLVhPQwE74ihbeaOTSfzoGvwxuI8QRwFNYj9QqGoilS7kCLOks8mDvTcMU2ZLJlJEipK0to0A443MURH6EFdIQaH1EIfHONk0PPcIImlCqUqCWVyQteg7R+TpHmEkpD7z9wyMS4qzWbN8djnU5HmX6vmO6uLXUqDL7Znb4GZa3uOay24auig1lDj4CO5lE/V5JOP67hxDe25bt0iKdSiTCmTU2Y/zc9xex6Fa9zSEMN9258lY2jXx3jrJxDaRYjnOOOxJCgnoMePfra94lGpk8Vfsy6idI3+I8745JZgyjHRdE3x2vk237YE1plydgj2X+c9Lkbj/UkguAAKIQghO3K2bnrB5oxptYYyA45xnG1sVTV+uNqYqm2trcsD+QnCnYi1qZ7Mh4exbX/Qw7pqfsP6YDEuusBl23zZ4pCOnpz/8s/738jWuXsOqmLlNOfA/wbf/3EDY1mH4aEvetuiHMbissraqrs8V42mYhsRcirMcyGnbPZ9CxLgwRZZc2iFgc/x+xifE80HUZ54GBa47Kl8t5i7JJ5KCGYEXkRJNTeyfabmclCUFWcG7957MwE/CXdS3f02IZiVgj5QAzyFzZYG0bCabj30LReD9YoRc9zJhKOASgA8v8tx1XfG9zK7KDpM1wW1ZMuJQTNdnikPuGxV9ZjfREddR0DRaJAurUqpmZxNWdar0mMqbDVYF9MX0Gzdw2ULcJ+vdgwR8151v8XiuMjAowYx7XlQMqjCpK1yXxWZFFqX9aBufDyhtnjI8n8Pv1Pcd4ZzfzC63jYze/NgnOfEvMCcS0W0GMcydmTxzFIOTGDT2+vIGhi3lbS5sYUyKy9X68a/ncnzhHMeIlb5puLVxHuiiNmDKO1eX9j55Jn9PuFzgvWezkNJmWm3p+bMNBZ220Qple2Y2eytC76ZCru5knPhdjOyH63bMjXrGVkKERw3z4ol3Itw1eKx5p1wExzBWRcqeD10o5af7v1E//Udzjmz5WlzzirE571PwO4+ApY+2V0QETQbV0+lUEituy70Egl4vjo/4998/0suhp4ff+9H/Pc/+jFD33O2hvWZHbMUoRTbPIesuFrxyBOwsZNQ0DmhKVuhYs5oqSAZ/ARSyPvCfJfRosRuTezPrWAYOySYqo+EAXyHeI/EAdd51v6c77s/IuXE+dkXfPXykjSPjG/fML59g1BYr2HoFfWB1J9Tg+NuPfOrsmW3T9zpzHtGkpqBfJpHqhq8c+UgBqGePf9yO+Y9VZQi1u2yHOH+HJPV8X6rbMuEd8K74AneWWFkquRqRROZLGEevSN5TwqOr8c1L7pA3wkvVoGHTnhaqymIaj12NBXSPFPmTPSecC6sA0y1MtX6SNomSKXzhVwruSZup5lUhbEIcy1oJ+jQ1EsxUbaKGuRzVkI1ikt0rfjoPMH5g3DXcp6lzpa0Gr7RNsrzSJ5H9tPE12/e8vc/+5qUM7v98/NpRRy+i/RnZ6zOz7m7e39I8g6FN2mCRp2hnLwPOFdQLSDlUaXyYG3Ch5XXj6819VlVqM6TXaCKI+fCPI4EHyhzoqZsc2/Vk/e5VtwMRjoWh/MR54MpYQePD1ZgirE39d8Q6PreOrXOEb3tc6qumvCScvXyS+ZsdibbP/gB037H3d2GX/zqa7a7PdvNDTfvXpHTjCwMJDX1bdQ3tM7zrlU9TfDRKYV66GY+DJcLrhYreJRkNJiTyM06R1VbF9O367YgMk7uDWYn9JQDgDHFDVGwQJiD6Ed3Z3JSxDgq24txT3Em3tVUfUXcYY9LMEpOdUoWRxUFMcRY70uDUdtLS8mM447ddsu031KmHXVOlJIP18L7gPOeuSZuvv7dbVp8jk8bnxPNB/Ew0fRtwbofimgBTUdxC0/jjyRTXCvWIbGqqfEvEG1Vv4eJ5ncrdQsGh/1YVHUkDNcvYuI5B7Gje12l0+MaK0DldzzR7Nom+3QNvrfvrlALZZqo83RvkVbnUBcAgeDQxYz6cDFsI5OSJaitYbpcdNtgt7W41KWXLQd7kYeiBSKmJnhqev1tozS/N8U6Xg/ES6nOkjJ1Ysp4SVrGu1jxnLxY9Z5YgCwJkApo5dmZf12HjiN53KO5kIowZ+tU+FwJJYEPlLWZkc9SDlAwxVO0QzSy2225vb2lqnJ+fsHL83PQyrQfSdOO6gPivCnlYap9Hk8neoBPs+pw0RRL797fst+NuAjs9mRXmFPmZjMypcLmdubt6z3zVHhzu+fX73fkUplzMoESxHb3i8z/SZdAa2mV7ydCTSjikNA/sfFYxEGesvARsWJKF58/0dw/bIYncKWJY9nVxLZgUztXoWtLyR+cX/E//9Ef8YPLc86vvuLlVz/Gx4Bbb3GrHVoL5UaoG/MjpSEKxAnuQ3lma5vpnKi7Cc3F/jtlcDPEG3Az03Vi++uRMinDMLBarwx+uzpHhrVx5s8GpI+4fkUYfohbnbHqL+hXX4E6fvDVV5T8kjLvef3//hVvXt/gEL6MlctzhdjB+UvoV7xf7flpuuZuO/OLacNmN5NKbomm8TgdsBIoQdBPkGjuy32IZ46KHiaq4/UbdwnZ8Wic6TJfpYKkjKgwhXOmcMYUPa+mFZfTwBnKqhZWD0azIQIypRZjnjW+YJ4S03aEzhPOPKtgfrSbU+J4i+gqK59JUiglcTMmsmljUarNvPUwxypZrFNEzciUCcUsU4K3RDN4R3DhXgFXtVoCdToJqlLSxLjfst2NfP36HT/9xdfMKbMdn7+j6ZwQYqQ/WzOcnxO6CLrwnJe1WPDBE2OkFEs0RbJ5y5bTjuYSgnMB1frNiSbG71eE7B24gIrpC6RpZA6RPCdqKlS38P/lMBd5EUsyfQdiVinBW3czREfwDu9NWMj7SOwiq9Xavo931k1vnU5p71sUU2spzPs9OSXevr9huPoHbm/veP31z5j2N0xtn6MH79YmOKb6ZHPgt4mezgrCDipPJ7GiiisZn5qqbs6G1jmJnAs5FUuGBUqzrYniCA/WbidKlNKEIh9GQAQ6KQT37YUYTdiy2P7EGS+z1kpqisDe+da1NGsu7QW8aR0XQKQQPHT+lBph+hLjfst+u2Habyjzzjyj00yaJxCIsSfEjpqE63HzLc/8c/xLic+J5ncJPVmsF7iLgJwA+x6AzI6ol7ZhvA9pWDanx4RleQuPXnX8/VPryj1jatrGV5d/KcgCBj6+7vHnLBqApyaHLOnnBy7KP3087A4u1/nAEWhy9Ud+oh5hKKp41Wbs3vIrOMIjF9uSxoOUezed1jVtdiUOAkIE/JJs6gLROuliCSebgftwmm8K1aPi8cPCxHLPrZhgkJrqzLz+MVzq5HrJEVW4JC6KfuOG5TuF2mZqKcCU6mgySU2dOVibVs17z+CPJrXuFigtcoCWiS7Sh4pB347Xefk5ePgp1KBG04LDZmdRSEzFElDdzzgqcyrcbmfmVNjsZrZjYp4KuykzzibBb5DDpsTowqNncVGj/tDzchiiLI/n49c5rDBkx74/R4CNpVKf/14tn7CMsuXj9bAJagIfAqVBrBa7NaeOUMGrEBTrVtZqEHMWyHAAqSChkY4bXNobr8uUu5fnuEAtpuybZutq5kIZJ8qUUJmp84TKzLzLzGOmJvMHDM7sZAQPVZDg7SO04HC4PONKh6jDuwYSk4h3AwWli53BAGtFakUn+6/0Ct4M3dcxoIOy1o5h7owv7wq5Cb1J6zSpKN49P3TMh4bEaHP847WFQ7Fjgfo9NSa1lKacjPEWS6Y6KwbtEwRvNAOqFVDqYRWpT47dhVsshznow+vG8pSYJcai2mnnbe9tiJBWCFs454dVUluCdgI5XdRbbRlQai6klChFj3OdQs7ZEoJcyKWSixoi5RM8V2BzWhcjXRdN6bXdPyfucB2l8TXd4fuYN+VxLbp3mY9zjxyu1gEHKYfXnBYetI3LxQPThGtqKYf52ZcT/uNpoevwGQ/PQU5+2nmLO8Dol7lcFkE3bwrNIZh1iDb13Rgj6ylzcXGJ4hh3N5ydX+C9Y9xP1GqImGW821h43nslUg/ev8su7riPWl7Txp9Y4l6lmdAsRTE9hae2Pd3RMPr0t9in6OG2HeLweUcupt2305c89VwtBdrTT1tg6CxP7fGcMcTWIk75xOxw+O3pZy/iXj4EfIi40OOLJbHOJavhB0/XLHA+Blj5HP+y43Oi+S3CukIGPzX7kmDchTaBevFEIlUE52YSVvkqB5jmw2qwdTxz8eSSEScGsRAPCF4qvlXUSjMVF2hKph9ZuFUP0FiT+2nTpdaDF+Q3iQ+J5sefodqSzd/90JSoaaaosq/K5ANBlaEWAkpQ5axmqgiTOEYxhd15ykxTq0JWR4xDg6ymQ9V5Ce9gFW3yHhQytrhMnWeuTbG32ZpIW3iP8e0XR2kV8dMZW4Gay0EmPzavTo+QvGXCAuxFbByenj/GI7SE2OGCQWrSpygmTBN5nNhu95ScyT6Qg8Gu+lXP0HUowlSUtB3RoqyHNUMY8CEckutu3XM5uLYoVsa6QVBiJ/RhBT7AMEDoGPczd3cT85y5XDmGi2B8OfEE16EuM+bK+/3IXCrvv75lm00pcL8klKky7TOlKPspMc02pk6hxaoPFFftbpmdBFjBY/n7Yl0AiNMGF12gTfrgCE9HbRste6Y/zeodMF6zA8JJF6w24GIVZQqOmY5QYD0JMQu6hbtXG7ptRvbCWYnWQUw9Ts/b9yq4roAarBX1SBfx5yskNniIGNm67m8p2/dm/XJXqNtKTpnNzS3jfiTlzGYyYRGqwxW75kPas5pGRITkdmTpEe/pL1aEVU+/XvECx3C+wXVnuLWauImjnWcknl8wvDynTCM317dc/3yP6xLxZcCvZ4jCVxdrvnopxLsVJazYzoWv65Zf7Tdm0C4RlYC4TBdunv0+XX3vRwbbyyNaLZma54e+vNq8CK3DTs2PxqvWxqlEcCUT/YjLjuvbwD9mzxcr5YdD5guplFSZcmauRhV51GNzQuxNIbkLzgSAPhKperZZSLkwz4JO7TyCCep10TP0gWGIlCmR9sqcK9E7Bi9EhN4Hhq4jdpF+GOj6ztbBnCkpsd9PvL++YZoSfQyseoNHbseZ7X5iO86MWSjSo64S++f30QQYuo6vXr7EKZTNLeP1D6mlsBrW1NaZi7FDVUA9Xbcj54zLSq2eekh+LJyzKc+QIZ7irbtZ7UYYr5KCc6aSvOjVOO8JTb271EqZRsQH9vsd++0G1RW1NPEWceCifdhTRGNpirkx4HxoFimBGD0xOrx3xBiIfWcJaOzNj9w5QnAEb8WRfrVCayWszwnrc6Yp8fpHX/Hy5QW73ZZf/+Ln/Orn/9gKBrnRSJTwzPUbCRuiMwg2IpSaKeUoyAN2vbM6svNkLYy+kKqiuVJG0yEQ9U2pWU7QYYqQEGYOiszNOu9p2GxpolZ6KMDdRyvogYIhLaEHKComCNg+Udv+JqtSaqII7ANkcURVKBlfQbMipXDaWBWpeJcfQXVj1/Pii+/h4xU+jMz1K+Yxk7ZvmbevccDl5QVn52eNLpN5/frXv+3t+Rz/DcbnRPNbxAI5FbSJO7j2cIdWxTOl00UyutZsry+PO4F2rNblqeUAZW3MMqsiKvhmqFvUGKE2IX28s1i1nsBJjlCLD/dXnjyKdY2eiE9T6/3tYukPWsFeqTlRJ7OaGH1gL56OSicV0ea/2VpK6mAS43ukXNnvEyDEOOB9h3OlFQUeJJryGL6qCBOeWSMFGIH5GZKBpSLtH2JuMGGjBasbBPBmdTI5oYpQ5Ol75sRe7046r1WF6j9BMSEnyjwzTRMpZWpfUa9WuR8i3cWFmXlf7yjjjIij73vccPy+IkLsom0iRdnvN+z3O5zCEDwr16M+UIaOGiI6F7ZjZr+biS5Qz62AY5X2QBaYSmUzzWzGzN99veP17WT8laIHfvWhMlyLCQo9DNVHSaJt8qwLa2PyCI1bOgnH6rBSJbeN/pOHf1TFXhLd8txc2hZeoCGo7p8LBaVQgORhElOsluoIGdjD/nrPZsysNJLjCtd34APSDwfukDxYeVwfkVWHnCYlqtRpS7l7ZQq3t4JuhDwnttfv2Gy37KfK2+vEOFtysDpbG/8wGXxVMHjpWIwrtBrP6FY96/OJ1boj6oSuC261PjaDWCEa8MOaeLmCjXL3C2X78xHXBVZjIJ5l1i8HvvfVGf1Zh4aBXRrYToVp53jdxHlUBlR6xE0Ed/fs9+nsxZfUNJKnO7QkdKtM++neWFI1ZdGDUmeZTzxqHofUTPATznvudh25dGhWpquMdpWSlVQqc4VMeTz2gdAF6AKdMyGkj0VRoRTPXISchZqqedEGg1YG74nR03WefTLxojlZsdA7IWD8vy4G6xb2HaHvDI65GykpMe52vH/3nt1+z9nQo2drvHPsp8L2IOYlVInglN+C4fDR6GPkxfk5lMru6iXXL76g5Ezfm0oxAt5Hus5Ti7akzQEen45dzyXEgfeG2LH9SAC1NU4riKt4tcJpgYMugROH9xHV2hK3hJ9npnFkGvf4cMLTF4PZ8jGKj3cGU/ceH0yZNjQucAiOED2hi9bZjD2+GwxGGk207941OlPOLl9Sq3J5dUbfR3bbDVorN+/eME0jKQk5YwW6Z1bZEr836G8wqGsukCTfK95UFUrsKOLJKkzOkao079CKZiVKoJf4GHmlGdFiwlCnWmVPnYtWnKY2NZktymkoR66/g0OLuyLkE7s6xLw+S02UWkgOZu9IXtCshFzMH7VmXCn3EAgiakWqBxFix9nlC5yvZE1sppkwZVIQgu7xTrl6ccmLF5fUquw/Ae/5c/y3EZ8TzQ+Eqct+7O8cgLL18LMgJ/TRgnD6viOUZVHQO4JZj4mkQ07KSot6nkEs7ncl7y30T6GYvsX3/i6v/+eKLFZ5k3I/IUAN5lUyZNGDun0VIR8AfO2lnKbinOJNcKoErdSqRGj315I3bXjChx0lm/AVL3bUqLT7Jag7Jh4LVcgOs9zHjxcCnoK0LpBa55yNoXryBVggTY3TeQp7AYJrvJlTrowq5VPkLmqcUO8b9ycEtIsHoQipBst7eAUefWe7YZYQVEHUqsFVW8K9YJaqweP6PjYxBuF2n/ACUymMeWaeC+9u99zsE/upkHJtneyFw7yUL46xdKWX6vHSDX54nscClFiRojbvv6bO2C4JyxgqJR2Sg1Pz+GV4LXCxg+axLhfj+WORAXO4tgkKiES79CWZNYgqNWGQ1gxlUkoSplnZjAZNXU2FfcoU54mpEOd8T6Ti/vXy+NQ0FsuMziNaMtPNHePNxnhjd0LdOlLK3O3Mb3GcK/ucGXOheo/PpmJ56NCp3e+pgvOKm0xh2IfCvE/MYSa4GT9nHAnxDcKLDcecIGWYc2VfKj4XmDMpOHQDw5tbpm1gnh0dnhoc553nRR+YSmVfhVGtWy3xE8Ccl04lSzXi6c8wJWd/WHcOSYPWQ4HuoDy+bNyXQosa1K5UMSsSbcIimKBLXSwc/HHOOZwfkBSmCllBcAclb6n5BHpox8UJIZpgiQnNBLy3BLLvOrq5GhfQ2fOUasWVQs7GDRNRGGkdXDU/Py22sbcSrnHL5tk6mlNlMzYEQ7WukDyAST5nWBcvEkJERBps1+C7ZlnijPIQAj4c4bMPsflLQVUrB6XlBWJME6eUfz7gAAAgAElEQVSjQW2XGyzHf57ANI9QTFUlpcQ0jYQuUloBXHVRo21AzxMKxwLtda2wZglsSzKDb4mydU9DCKZA2xJQExkyisfDYRubInjf95ydnePEcXF5xeWLl0zjns3dbfM3t7n9eW9Sg5e2/dapUNPxBphfq0hFsOdvQS6JNzSGlQfuazYfROIWQWYHyAld5R5c9r7p3GEN0Pu/e/h3axJIe/+RGoQa1SE78wNdrlsVoTh7gYgcbFO+8TKJJ7gVMcBqVbh4UejnzL5uYLqx5y2uEBdxovTDP//O8huRfB8YS98GOfTcx/g25/zUa5+kU/wTx+dE84mwCdB/MNkUFk6ebXSLeoqYuMUisFObBPuj43pbZksppFSaQlfgyEdRnBSQUwUyRTTha5PaV3ecDOt94+IjD+dffuy6GT9V4lgs2Wyhqoy7wjRWqhPSmkZuF7YusH9wgYo8BgQLSlcSqwZp1La5ys4z+Uh1jlIyOc+cXnAbGwXf+A6dtATVeWoMqLMK6FyNj+Rr48OoMmP24t82fJOTVzW58Yfqd15g8O6eD56IeVOeDeHIrWm8xq5W3n2H8/imCMFzth6oVXGrAb9em/E3IPNsojAPVZQOveoWmUPC5bKj0w6lMtXCpBmv0FHxSekk8OX3Lihaub7e8Ne/fMc4Jd7fzry5nUi5cLfdsxtHU4xNJ12gaorRdm1821h5XPt33w90fY/3jmEYiN19UZ5lw2WJZqUUgxguPnRWiS6HpDbnmVJsY5dTPaAdSht/JRdKtq56ypmcs3X8nllxEeDMQRBPlM5EItwVzr9EFXbje/a7a4NrbybYF7N7KZ5cBZ8zfycz676ycxP+fGKVlHXcsmoUg6fC9+cEvcDFQL15R371j9R5x/ub17y9/tqUMXeeNDpqhSk7UoE5J+7GHXNODKrMfsB7MRRJoyZUrRS1Isc+R/q9MI3C4DeU20x/JQgXhFXGrXr8+YAC06Tc3VbGTeXtNnO9T8hczFZmNxPfZF7//Z5Aof/eV1z+4R9wtepwlx1r1oy58Mt94dU4UzVTuucXVyvT3UF06nHYsyPiCKFHvFhyYooqxlVVg9GatYlrRbATqHeLqsK+BLYJ5lqoajOVlkqZDLnjnUe7+xzvonCXlH1WwOMksHIOVxO+bEAr2QUm15EA3zvOLs8a13UNMrAezri6vOTq8gJ1nrebPZVCzZXNmBhT5vbujrvrt8QmuCbOIJurweCbgYm+MUvnaebVfqSocr0X3u+FOVe2UyWGYAJHj+ah54kQIuv1GSkriuPubsM8z8TY0Q89wQf61UDsbF6LXcCPHl/K4bqaAE5LfpxDGjxAcARnZBut8vSQaOHafK9aKe24pRQ2d7doFXLJvPzB9+hWA6E2zzAwzmWb12JLJp1zRG9ori4Ehr6n7yLD0HN1eWYJZoim/uysQx2C7a/EPdZaUKdE34b0i0uc+0PmaQZVgvPstxt++vc/Yf7Fz6yo9AnuVa2FrGNL1p8ogFLxMhElo7qUT0C8I5xFtCpdEfr8AIaqEAr45JqWAA+blA0um5tt2umaZOvBA3jLseGg2pJvKy53ztLcrI6iViCfo7AX8+Au7XOLg310OJRVqHQ0rYZvuEbBDaz7FwR6VueOL/6Vp9TK659e8Mr31JLpOwWvRCdcXT2/cN13iYfJOhyLJ9/2fc95jI+9/9uc8/La5e+n4+P09x869m/yPb5tfE40n4hFwGHhQjyuCIh1rZQDTOEgW/BE1enescUma23y6vpgUZfWDePw2cseoljf9EAoN/LfkYv5+xfJm1m8bxyWJWpVclKmGdS3RhmgIi2Re6p6IPc2awL4Woncn9iTCMUHsrjDQ3v/IQV3cj+XB0ydUIJQncfpYu9gFc/YjLi/i9LrQTW2dQqlVB4KEQtCeLDBFxG64Oijv79unRzzuWMRwlBVfN8TVyuDkU4T5JmDitKDs78Xy4VSkGIaqBUhaSFrxWvFozin+OA4O+vBw/u7Ha9uRu62I1+/3fDL13cm/lG12ZFA8K2Dt0Bh1ZAFS0f6UIF3jq7rD4qK52dr+qG/d5qnG7Ja62Hj6lsHF0z+frGsSWky5cJiXBYzpbf3qSrZZRKpJU6t2aSVRxWSZwjjZprBupOAc2uce0mtgpaJNG/QGeodsLUCTKJScWyl8rYvbDOsd5mbMZNw6Dgj4/hBhW2nPbETXHGU24n89RvyfsPN7Rte37wl5co4WufQWGcrVCKpFLZpJtdETR0hmQdqSZUyLxfHrr1zCi5TakbUMd5NxAIiA/liwqlHvD908nJSplEZJ2U3VzapILXi9w6fK27csbl5i0sTXxH44g9/RBcdZfBIieyzY1Mq16lQqLjw/M9VzR+Doy0dShNgkRM8qACiBV8m80CtDi3OIJhlfpRoqkKujqkIWUGXRFNNaKfWanYzD0KxbuaEdclX3hPEI8xImUAzlZ4sximT4OiGjqoOpUMx0ZxVP7BeDaymRBcdUxKmrIyp4IsyjiPTfkc9oRbE6OnDCgkRRzZuPrAvmc04MRfleu94t/PkYhZEVmBuNlKfIFyz/+g6u37jNDNPE3NK5Nw6ms5UZ0MMB/2H0wLNUjwBW9tsfTOMlSnaP0ZinIa0tU6E1vOiHasyTSPg6VZ9s60pbY9xfK9var7eO/MFbsJLDmc6FSHQddGSzb4ndhH1AQ1mixL94/XowQkeIPu6Guw5z4X9dsO43bDd3PH61Suc80ZN+iTrlfl3frBoL4ow42U2lIt0iATUNa4k4JPiteLqvbcZciNLK/w8dWgrAh1QScsZHeEtHz7rhuqR5iEOxukv7SjZCckdCweGKFCyt393Xhbr928MJ4EuXOLqGncW8S+slJO3I5vXd+Q0E2QEmXDBsV6vf4Ojfvr4rvvl59hnf+wYB1HHDySP3+Wzvqnb+VSu8vB9zxGfE80H4Q5mz8eoh67WfViDcwts4+MT+2momh1GrQZRXH6S+WQQvNhG+UOVDY4QutoM5X9fY3tX8GNlmiquKL6xGFQf24sAixcJ8mA/JFGQzniN7vSJCA71gvOBbnVGiJHiA30/UJxjd3fL7duZku8f8MlbZ4U9g9KoomIAaXEgwbg3oY0LsxD/2K29P95OK92n5xCjbT6kVEo6+mYuldQuOKK/P7FVAf0EG+IPxbJR1WkmVyWXSqHixeNdJfjKAa4MHC7OSZglQDT4pQS873HSMZfE3fsNKWfevLnj+m5ku5vYT9mewdNqMByhsmJWNKpqdgT9gHOePkb6vsM7z7Be0w8rvPesVgN9Ew+xauCyIXPHjuaBM9egagpVrUNZa2WeU4PPVdKcm+9pPSAWcuto1loZx5F5ntoiUfn5z37+rPeklIjSAT2VQPADrhugmgdm3iXKnMlTJs8Fp5DVjMX7Xug7x3oV6KI7PAulVPKUccHTnw3EoQMVNNtmS11HnvbNK3NEA2jnmDSwHSNzKoyTME9NHdFnq8prpRTjV1MdTgtBhS5osxJSplSYcyvUkUA8qsJcZqYEoUwoM4pH1aHVt0KgTSK1Kndj4s3GOhxuyjjv8Gmk22V8qZR3O+Qf39CtekqDSgdVrgr8KARmhGuev6KvLSk2v1zFVSFKQF01IbAFdukDeG8FtObXKlpw1SNa8epMMRIl50gu2VS1oyUS3kF0SucVqZVpyWcOJwK1VPKUjsrPch/yeYABioOaDgfQWqkUijpKMVsTBcRLU5KmQXSNGuBU8AhUbRZiZi+R5kTJmf1kXc4+elKeORsiKVkX1gXD8OYipAzTXBmnTM7KNCbSlE0Q7RNp3jnnDjzzirAfZ8ZxMpGxki15c2ZbNIdg3T8fyK4aRN/ZPXSHTenx2DaPG+XmsCZwsAxtKqjtPNo8VRW8dwQ1wbVaMzlPTNOe3WZj4nPryhCHw2eEe+np8Xv5E46mFTZ8g1zrwVccAXWO6hv81gfEh3ZOp9/DxrYTMXoHynq95sXLL4mx4+rFCy4uLsx/c/PsZlyHWKCoqg/E2nQpRJo6eCcVcRmtQi02p/lqvs33IbeghqkFbz7m8uhZaurWHNem5Vw+lm8cH7cGR8ehokwIsyil/RxefPrG9knmLV3I6FHFXQw2n4t9tzwLJQtphv1uR06ZMmXSTaZo4ebNa9K8RXOGmPC+2r66PD9H8927t+x2e25ubsg527PV9Xhnie1qNZx06IRxGnn79i373Z5FyVpEOD8/58XVC3xYkIxCzpnr6/fc3d2dIpoZVitevnxhvGq1m6dV2W63bLZbu4Zt3Y4x8sXLLzg7WxuEue05NpsNb9++ZU7zobHlvePq6gWXl5fWwCqGqpqnievra8apKS63vcTl5SUvv/gS7z3TNDGNE6Vkdtst47jHe8+wWhNCpOs6zs/XpnLdxkhV5fr9O969e3sPBdf3Pd///g+f9T59TjQfRPTHbuICIyrVVr5lohEB5wremcx7bfylbwqDNtQmpa4G/SqgGXyqRKkM6uj84RSejFILVeq9c/p9jNe/mJAKrljytkI4M5bXoYt5L4ridhl5sIvwLzxhHVEHuxFbDEWog6cOgbA64/LH/x3ry5dIDLizAbzj1U//kd3mlpK/eaFzGN9TqkFqVyiICaqkYFYbzKYwV9U6AB8+6jcngt4L68FTe5hThW22in1whM6q5EMQ87c7OVytgjySgPmEoUqaZtLtjowyOZgFOgl0MTAEIYtjcta51KRwH62MiKPvOlwfcBLw/gwnHdu37/mbn3zNze0dr693/OzrW8bZLErmvHCjT7+7UkXxztEPtlidnZ3x4uUXdLHj/Pycq6sr44z1PbHrbeMYYrNhEavwn3CZ2pdsTTI1W5Tcupuu4qQabHeyOaHWSsn5YI1iC9wRJVFr5fb2jt12d1jk/uIv/uJZb0nKZzjtKHWNEGF1iT+7QmslJWH/xvzuxt3MPGVLVErFaWW9Fq4uXvDyquPi3FS5VZU0ZXaMdEPHxQ++5OqHX0IRdOfRWdhNI++u3zGmiZg3dCuoMbB91fH1zYppypYIzBkVRboZCRljdXa2WAdPzImewtnKcbk23vLb24n3m6nNDAFQiiZ2M1TpkOR5UW9BM1oSNaXWoRut2l8rv7rZ81e/uqGihwQqUljXjKdyNr3lH97u6YLnB1fn/OjqnC56/vB84F+vBza18lfPb80IgGZFx4IWxVfHyg9WLxk8rjOYXNJAUU9wMDQBFtFlh6ugTWNAYUqVMZnqQMeeyEQMlVXMnEfjqu7q43UnTTMlZ9s0dQEXw4P9rEJpCYW2RL6hclJJzFWYZs9+tgLFECF0gvOWxKapUJPiqxDVQVHmOSEC+/3EbrenVuXnr695dbNhCIEfX625XHXEPrB+0RMGR03KmB37Wdns9tzc7E1hem/FkypCCp9maxRi5Oz8jNqQUG9vTNDs8uqMeT7HOyUEx3o9NOjhQBcnSjGRIJufj9Zpp0rmBvF3bc5YkjUruj6kv8vi/60AEe+tsFbyRE4jzsObr1+x301ML18SY88wDIDQxe7eErRskmO0TmY39HRDj/OBXIWalZJHchpBtaE9rHMb1uf4fm0eo60AYiferlfrmNbo0O99Rb86Y7fdcHP9lt3dNbvd9hu6+r991JopZUIfVDiXrr8X5dwn0+lIjpw82hBLj1ZqgRoVwtLMqM0f9XBUVAtS8z1+JtrUgcuH93vL+mO2V9i1F2GMMAZb64p8ZL/YikVzTbgG2w5dQBVS8uTsSLNw9yYw7hylKim9odTK7c1bXr/6OWmecNUh1Qomg/d03hNEIY0f/uzvGH/3k5/ws5/9jL/8r3/JZrvl6uolX3z5JUM/8If/+g/4Vz/+UUMF2M/r16/48z//P/jVL3+J98Yh9t7zx3/8x/yHf/fvWa3Me1lcYLvd8l/+8//F3/zNX6PKgTbzox//mD/9j3/KV19+aYXiYqrEP/nJ3/H//fXfMs8zKRm95cXVFX/2Z3/GH//xHy2XGFT5m7/9G/7T//6fuL6+bvY/nr7v+Xf//j/wJ3/yJ4gI4zSRcub9u3f8P//1L3n9+hWl8dEB/u2//R/50z/9j/TDwOvXr3n1+jXjfs8vfvZT3rz6NX2/4qvv/4jz8yu+/OoL/uR/+DdcXV2Y9oAqOWX+4v/+z/yX//PPmabjM/TFl1/yv/yv/9uz3qfPieaDWBbGtr/7AAz2xJnoYw/uE2FVjbap1aN3WKmKLF0WvrlV/rsOl/2nOL1xe2ogbLT3joeUhxN4iuG/LLtfkgFA1OGCtu7lyVuDQzuPDB3x8oLhiy9wXaA7G5DguH379iDs8k1hVWjraNovGgtC5MCRcU4ICAV9SNv41iEihNaZ1KoEJ2i1bsZinB19sy485VS1Suanj5NiTjHLioJSolA9qBgMzDvj2S77KSlyLK4ckYEm1x8iIiYgIi6Qq3J7t+fduw03dyOb3cSUyqGb+TCWZx6RA4+o73vO1mv6vufq6oqXL78ghEDoOmLjHHnnG5wMYnAfvH6qypQy89w8xnwlOIPuxq6Ss1Ura8kffL5LMXidPxiqP3+oBmoNaImIRCoRDdH4eJXWyczMc2FKJr3vS8a1DmyMjqH3B6EpwN6bCiVUXAh0qwGKo2ZPVYebE2memMctyERwUIMj4RmTZ5qVac7Mk4JTxJVGM3B0EvFiXplOK16V3gtnvW3V7rwJd6De/kumKuSamDPkMjcoaDp2NIuyAM6qwn7OXO/nw7gRIIoyO4NjTmViGmeid5wV0NDjOmW1UnrniSIMD6V2n++GodmEeUyp3B+8YqUznlYtAVUbmyEYfLG9+f6hsM2oF20dz4TobDYaogQpzV/wieenqhVlBU7Vx1oBvT239d6auax11gUQSrGupj3v9tyLtPWyKFr0uIHXo/pyzsXmkFq52428u9myCp4zFKbE6qJjuPKID6g0JFExlXGDrVbynMmpoOLI8mmKba5ZVMVoxekpZaY5kXKmlkzVaq/xnuCNz21FLEsikRO/Su6jUZZu1oKq+P/Ze9MmuZLrTPM57n6XiMgEUCjUIlKUWlLTbGzGpm3+/3+Q2ViPdU+LwxFZLKA2JJBLLHfx5cyH4zcyMpFAQSSSLY3VoQUTlUssd3E/y7ssB7iiKe+ESC34Kx0AqE2ueITyT8OAcw2rfkVMiVCh/g9t7kdRoEWJ3y/WIJUjHRNxmkALxTmKM7EnaVdIq1DqpA9rTB3RN2Kii+qUftWjzgTkNmfnrDcbVAv+EzcF3oUSFoom3sdTcCI4qY1AgOLQ8vD9tTCsoAoCLoiEkx8f6VD3edJ54e6/b92vSucOCkYLKWIiebOUu+/kgacQFoSRwYY01ImqGqsFhBgd4+A5bB2FSNKRopHd9pLLn74nTiN9t2bdb2z90daOD6Yz8qnj5vqa169f84c//pHr62tevPiCYZxYr1acb1Z89vQcX6fm4jzX1ze8evmKP/7xD+bx2baEENis12z/7u9QLfV3A7vdju9/+J5//dd/RRV8dZdQhd/+9res12sT+cuJlCIXFxd8++2fGMeJeY7EOfL555/zn//zPzEMX92Z1F9eXvLNN99wcXFxvMdXfc8XX37Jr379a0SEYRyZ55mLNxf86ds/8d2rV+ScmGcrCjebM/7xn/6J1bzm4s0bfvjhBw77PX/8wx/4/tWf6Fdr9sPMk6fPSWnmV1+9oAnuiKCc55kfvv+B3//+dwzDcDymX339N/zv/+X/+KTn6ZdC85FC1czUVaUaCttNW3IixdlEPh4Yux0tVE6TVf33X1g+FAXhgcb3J4spmXhiqPZSCThgqJSGenGrItH4DiUrU9YqWip18xYTO5iMmJDrWije0Z2fs/n8Cf3qjM3TZ6w350jrcBsPQejO1qyfPAU8aZ6I08iHAK9LLEg2oZgSq9hxilmtC6kGAc4oSWEs1Yv1ZyaZC1yTCvtcFI1xgmtMDCg0Bpd1VVzzHqrn0SInK54WIRxfFXgFCE1AVx1ZC1PFxhat4jylkEVJohQEyWIZiYALHkKDCXyMjNOeUhxT2pFK4KeLS15f7bnajmyHSMzF1FJPPuiiGOvEEYJxotq24cn5iqZpePr0KV999TVd37FZbzg7OzdvvzrRPKoviqv867sT4vvR5ly5WBhXyRuEJSa7PnMuxDgfuUc2Pbv9+5ILTWPcJ733WT5VGKojoukAxTFdKdNhIKfC7uINwzCRUmaaZuaYbEoWHK3zrFctT9Yrnq43nG3WrM9XBO9BreGTYub1qzdc3UzkBIetEidlGvbsLl+TppGuiazbGSjEMfNks2ZuMtvKh1Yx/7cMiAuEpqPxntA5XBsgCL5xtI1ZNJTsGA+KSqZIpEmOrlX6kAg4ypwoY6SEiBOhBH+EPW2eP2UWR1itUBcqDrEKNBVhKo6oQioQs53P/jri3A19G/jSwedOUCc8fQRIuk6FnPKJzciitiv40uNLLTSPEy4hF49pbxeQeKdofKgogVpsZ2WblDEpc8rkqjbrGn/Ho+EIDY8ZJ9AGIYipWT7kFZgV5mwCaTEqccqIKIMbjceclevumpQjlzd73t5ccxgnhjlCTqaWnSLzOFeI9kSOE3Nx3AxCzpEzF+l2Qs4NafI0riEFRXNkOBwMmn2IzJMp4UrzOD6aTfCcrzuCU77+4jn/6e9+zX63o+86druBoo5cBB86fJirQq1ZnHgPPt+1Kbn1561QVPmwCNASRuGp/yHVIrPuhVbEFw77G2KKCJm29fR9T37+OU1oaJqAC3bfiTeBrpwzh8OeYdiCGB3gsD+YiFmJUGZEYLNacbZeEdqOz776FeefvSB4j6x6pHomO+/uNEAVaL3YZLNvePHFFxz+/h+5ub7i6uryk50fgFJuoQdGUTrx0PTZ1HwUSMGMsk/CCXTe2RjiAair6l32RymnSvHLL2ViSdyRKNRbyhUsAwoT/XGV6qVg1noGHCBLNkVZCvl9HmcAzuEa987Pcy7InGyiOZlI3TzC9gqGHWSdmXVH0UQpA8+etmhxPNk848nZZ3gneCYcEScF5NNDnL999R3ff/8Dby7ecrO9IaXCOEa6riXFiavrt3jncd6oNRcXF7x89YqLizc4Z3u+947Vas3Z2Rnr1RrftITQsN/vefXyO16/fmPr3JIvNoF/+Zd/4c2bNwapLpmcEn/4wx/5/rvvmeaJGE1NOsbIv/7hjzZRPUJ44dtvX/L2zVuur66On6XrOr754zesVhtEYH84MM8jl5eX/PDDj7x9e0kpmRhnBHj16iX//b//N/qu5/XFBRevLxingYs3b9juBsa54MJPbHcDw2GPEzg/Pz86C6QU+cMfv+Hy6uZYvAKE5i2///3vP+l5+qXQfKQoimHaq0w3ULlW1pEoxyTxfvfMusL/AevKdyIVUzx7rNhHpfXGI0IMbhrrNPCs8jUpIGNCJiGrcijKhOJFCKHBOU9bFN0DKLnCMp0PrD7/nGd//yv6bs2z519ytn5KaZW8KZRQWH12zvnnXxLChv3NW1Kc3t00HgjvoWsLzttGtjQ2JxVm3LHJqcBUlDdzYfjI68E3waazpRDniGabUIbWIwEaD30QSyzu/e1jzjFjjHXqaBL3RwNSgaZvCLIm5cJhGiBZ5/YwZWZZ8AMJEPOqlcamek3At4GcI/vLK/Y3V0wRLraOwyS8vd7z7Y9XbPcjMRemWN6ZZPrKgfLes15vaNqOVd/y/PlT+r7l+fPP+fWv/5au72lCQ2jMC67ve7q+q/yKk2P4MyT6JfkQMU+9EPwtBF4hpsQwjrbJOzkKCi2Rc+b8/Jzdbms87w9Aqf7c6EOmaCLqgZJhuHzN9rKQYmZ7s2O/G8i5MM0mYLRqPN1qxaYLPN30fH7+hBdPz9icb3j6/BznHfMhMg0zcYr8+LvvuNnPTLHwejuzmxI+zjSHLS4nVj2cnVcYmH/C50+fkood26JKUqXOH/GuoVn19G1D2wRc3+C8o+mUvlVKzuTo2G0zBWGKM75V1n1m3TQ0CGmIlMNsSVquIm0i9H3Ls199Qe572vMzNJg3o8sRNJOL41CTzaUfIAL7eeL17sCq9fxvpbBW0D7w1RerT36uyiGRycxEiqvCPCkh4gi5ock2WboFdThSbiglIMw4GZET9TAFSjFzm9NICjdRuZiMFznO8ahd4Ntw5AwuT5JjIo+JxkHvPJtgTSV3fJVbREMuwpRNaGicCvPefDRjykjjGDqD3G0PHZc3B169vuQwRiteneDw5Gli3A2kkpmHA2k8UJzwpszchMCT1NJ0mc3YELWn9WtAKGlge7NlnBLbw8hhmHEI3SNBZ/u24fNnG+a55R9+8zf8l//1t9zcbLl8+5bLy0tiVFIG364IbaTtWtquIeVACAaJJFUuvVqhqVoq39H4kQjIz2y7i4iQNcdsObZTGHBZoWRuri4AYdxfE4cdXdeT5ki/Prf1sG9xoUGcI6sSY2IY9lz8+JLD/obLy0u+/dO3HIYB7w1hE4LnqxfP+erF56zWG/7htwe+TpGu7fDPPkP6FU0INL69Y8elAhKsOdz4jr/9zd+x2Zzz5uI1P/zw/Sc9Rykdbl/35P8RhXaGbrJm57CC+a7A1oIYML6rNWNOU7wiMFcUm0GVM+WeiFYpiVzmCm2/G7Z/VJuh4nCiND7XiWoweoksqJ9MAfMcXd7gA+Faj/jGxIlOYnlvOSm7q5nDLhGnzM3biWnIRJ0Yy5ZM5LyHL79a0wbHF8++5MvnX4PC9u0P7K8vjIPtPj134P/+H7/j1cuXvHz1nfEeL97Sdd8Tgufbb//I0yfn1YYn4Jxnt9/z8tuX3GxvgEVPwbHfD9zc3NB1HV3X03U94zjyL7/7Hd++fFkHPXZ8ttsdOReePDk/wqBKKXz36hUvX/7JVOFzIeXCm7dvWa1t4ignSvQv64Ryt92SciblZI1u8WxvdijKbn9jXOnDwPff/8Rut6vKw+YPXYqy28RDNbwAACAASURBVG0Jwaavu92OnDK73YHDMOKd52Y7WGO6X/HNN3+ibRdeqSEYLl7/yE8/XdwRPxvGyD//8z9/0vP0S6H5F0ftIt+HW8BtV+s9v7+wLW7zyJPn+pmE9d976L2vjxExm1hAVpBqdl0dSMn136K1vVcZFmY3j3VxKxSpKJQlYVep0B9H6DqafkXTrQhtiw8BCYqGBB58hVCGLtnPHgSULXHa8VeTdT9JBkqxyWxxd6cK1gM0qOfHXhEii0eW3PmeVHNoJ+BPu8Un1+5S9H7qOKrhyS2/6HiwRI4iF8t1b51frZCd06tJUW//lprZK7WBM82Ms3I4wHaE/WFkmhNTzFUIQ7l9iUVFdjEXD0aab1ra1vhIq1VHv1rZozdBIIOxOZqmoW3+fHEXJ0LTNDT3ElrnPbmKnCwCG3cmmqXQ9VURsoonfepwYoI7lITmQppm5t1MioU4TqRsCdSt6IEzZIF39eFpfDjaH4h3qERyLswps9+N3FwPDDHzdjuyHRNNjqzGAyFnNLujD1+7gi4EpFhTQNztDaJqGbUcOTgOnEedQ6XCv7DkfE6VluAzASE4R4qZFE1kKcdMiTatkFzQ6g0Y2oambUywRFyFvFNf3zjNtzA5u7aGWHASyaUwTIl5SjgvPIKNpvmFij3Kyf/A+He2Bp78vtg0BL3dd+5MNLm9T47fqZ81qRKrSvNy7usT3G2w1E6ZvTfjp7uTwvLo11n/+0ghKRyn+ipQUt0jxUQ8VJRhmhinmWmeUe/xTQA14QxL8BbRrAwqzMkEo9pZGMcZL0oUR5KWnB0p29Qh1unDHM1rNzyCbRBwhMXSFPq+ZbNek1Li+sr8YWNMlQ/mjte0wVFv1+9bSt/9hXqh8nz8Ar7kz7drIrd+yqkKI00T0zgY13q+tWFachtdfpfCNI5sb67Z3lzy9s0bfnr9I4f9weDarXlqNg664IgxctjvieOIo6Jeqm+ncGdIjqrxN70DrZZSZ+fnjMNA2/V/9vl4KLLm45L7TuNQFHx598Zafozt6w5qA5F3b8Djv2/3+jv5YymWz+hD51LqMMImnOqq+wEcIa6nmYLxrhesw7sh2H26/FCXQlXtjw1Kq8S5EKdEnKtnbYpkZorOFI2IBLquoWs8q3XLet0jqkxbx1CvyXxfhfETxG67ZX84ME0T8zxXq7BsNoKipGSqwEuhOQwD+8OBcbyd4IkI292Oq6ur497fdT3TNLHf2++enp/9Yc/11dUdbY5SCtvtlsMwkFIiZ0OhhRC42d6wvtzU/dzs5Ha73fE9p5wMGRTS8X2oFvaHLeM0MI4TwzAwTfNxggrK4bDn8vIK7z3jcGAYrAE8TsYRzc6wezFGU7QvSgi3OYuqst3tmGI0MaCam03zzPXNzSc9T78UmvcilfvF389FVVRDEXGIvF/JR2pySZ1mtpXu4JuG1ottcB9AOPxHCoEqr12TPf30n+q7bWLlhSfBEZzQNELX1IW+KrudquPlOhcD+3nbKt7bY9loV5uebr2h7Vc8f/Y5z598QRNamlBVRQv40YRfWteyeb7Bd46c9ozbjpwelsW3a+Num/m2R7bAaY1jWooyz5mUCnNShlHZJ8WJFaMODFpUp4KlJv2nFeKiSPqxkYptUqkow/w4SZZ5REZEHCkraa7d3pwhJ7Iar+SDz6HZ8M0CaT8Rd0aYv3iz5/IyMsyFHy5nbobCMEZTGxWxrn1oQEzMommremzf0XUd3nu6rieEls1mzdd/8yWb9ZrVZkPXb/BN8942gj7Am1EqxPLe95froEiFkqZ8O7msk4El0V/QDafXsKrSti1yfm5qtdOn570AxDGxezOQpszuZuawm0yZczJBnkUR1z4TNA5ar3gKJSbSFMnzREkesvDjxQ1/erlljoXtPrEfClPKvDlE9nOmKZlVglCAdcdn3RltG8CvmaIjlcIhmsWITTcCnTfoUwZmVUIpzCmiKlwNBkVOKfPyZuTVzYEC+CniQmDdTky5sOla9nOh26w4n1Zsnp3xZN2aUElR+lTociFgePdclDGa9YlogWJc0YDQiJVTSWFUQTN8t53A79mcdfzmxfmjnKvTEOdM8VMEcRmnE4jDmKQOpVA0WrtNU2383OUjlopCMQROQXNiJpNiJIVEzpk8p3cmMUuo6vFnRYVBBX0PskUVhiSkyTjK0zxymKc6ibGiynvH9W5PcJ79lLjajcyp0LcB+obkPa+vPXM2xMLb/cgQrZ0lcURQdvsDV1c3eC9MtAysSEX46e2eq5udqV2XTGhsOljc46yBhsqoawDGQZ6LcBgnttvrCjvOdK0ntt7WqqYjhLkmyxnvFHUcbY6WrzHlapmUb5sAp68sCy/z9N2cFHR1uiNOcApBrMFwiqooWqp/dGQaJw7ekWPk7cVrdjc3HPZbvnv1R7Y31xwOB968fUucZ1Np9jaRHPY7Lt9ecn5+Tnf2jLbfsNls6NqO4B2iLaVrUXV3Cr1l4OacsFkZbSHFiS+/+uqTnqF93BNcoPPtnbX3Y6I4JYWIqPE2Q226LFoc7wtrEyUU41ofKaFa0Kp+LRJqY3XhvlojParlBBrEeK53a9ljzqNAJJAwz8yWdKsZUSO7wORXtraNoKOhJPI4o7EgZPoniXCWTO/Bn+MddB2sVxCCo1s1+FCVuxuHdnWPjJ/eMuibb/7A9fUNMdo+mFIyQTInqGbmeaz0FpsWxjgT5wnVfEQEABz2O95cXFT6TMD7QEyZ3W5rx06t+VtyYb/b8+NPP90pxlSV7fb6WOwuxX6MkR++/579bme0nMb2lqurS8ZprufRhhuKcHNzA/otAHOcSTkTY2SaRlKKdQJr3sjDOHNx8fYOxLyU6rmdI1ocpVq2TdNo2hBYo6tpTBRvnsaq3K1VidqTcuHt20/rpP5LoXkvUjaeQ/hILQDjSZmss3OG9/65QtO7u5uuOI8PJ3j7/z9Umlih6Su3TsvDicZfEt9eJzbOcQhKI8Jm7TjfCN6DNFBMw//O3yz/5ZwJsDQnlb04Yb1a0/UbutWaF8+/4POnXyKycPAEMvhiILDOd5x9fkaz8cyHLbuLHvdeHsK7J/X+d0KA4G1KNc2RGBNzVPYjbGczPe6DdXUXOXrEuvkpvl9A5udCgVg1klJW9uPjyMUv0HGAuTjGHOt0o0I56lb74ecoZJ1RVQ7DNYfxhmnO/HQxcXEZOUyJV28O3BxMuGWBrXvnCa0ds83mjM3m3EQANmvW61VV7DMo9fn5Ob/61a85Pz9DXINrOmsSlFRtGe7GnenO8X0aL+n+OVmEikDI5FoQOCt8gyUQx+6ymvjJ/ei6jlXf28QsfHolP4A4ZravB+Z94jBO7A+TqeOmzJzvGTxjDZDWm9hVmRN5jJSVoMlsY77/6ZL/+v+8YU5K0oainjkrN2NkiJmGwqoWbCs6Qv8ZXd8yRceUHHNSDlHZxYRzjlXnqtWMI1GFrnJhyoVSYE5wPZjYyp+uJl7eHMiqSDCbj1UI7A+RTRM4xMzmSc9hXPEiCJvPn+DUCk0XM10yqL0EbzzVBMNokv1BBCeFXjyhNpKiCqWYfcbLm4nrSfl8yvzt+PgLu02+fE2uCoL5IuoRuKpknetZ0zphef9ml3IizabkO8+RGMymIk3xvYXmHaggMBTH/L71X2FIlQOWzMfxMO+JRTmUzLQgUmZFMiSEuXJOU9/gsCbRlBIXuwEzqPekYl7VOY5omYlzYr8fSSkzamCvLVnFlDwrGqbpAqE1BMFjInGkTitVPBHHrI79OHJ9c43zgmqiax2xDbStNcXC1OJdUwvNAr66dWWOMMwUq+dl0QfPjYhBZN+XXwj12lF3AnO2QnM5KFqKWd+kyDiOoIVhv+d3/+O/8erbbzjsd3z33Uu2uxsWlf3ToykivLlYsVqtePLkCU+ff8HZ2RP79/k5fdfaVVrhwKeefg4rioMXWPe0fQ+a+frrv/mEZwe2cccq9DQu3FH1/ZhQKaRgx75F8FmQyuEuH2i2K4XERKmQ/Dl6Q0qUglbhCPGG2Dj9K4AFoiXArd7YbRv7Fg8kTARGGhoynoK/Z7qdJZgXbQGNim4LJSXiuEfnhGus0KSLrEPLi35D5xuyiwaNFei6Bt8EQxW0Du2EkkCnT59X/OH//b0pRtf8Z2mCWBE14HeVG3kU8jHBK7MVu6Wp7XZboxw4d+TCWg/cjo9WaHiKqSKJkiETTo62qc9GQyQ4D+KY54nvvnuFiOJ9oOvWeO+JMTJO8zE/ETGLrqurK66vL+18igMxCPY8T9X+KFTRQ8cwTNxc7wFYr1cmTlRzrBijKUFnjwrEmNgPEzkXurZhve5xTpim6fgZXVXmzbnw+uLNJz1PvxSa78QtdO/9BZ8c4VO3u9LHJRGLeMh9z0OLx9zeHifuUXPeOQqP+YmKODJS+VtqU7JsCVTyNlm4/34MbWnfFbnLZRFsU2261qCy3gqTBeypd853VZsLDt94mzBW0Y+fjXsdx4oAZXlTrkhVxVRS5eGVbLPhRd7eCN3WlDCoZeF9deaSiGgxjkhRWWTkKnRNSYX6sOd9zDDIoYkgHOGsx5+d+MTWibg14eXODVmw9xpTYU6FaS4Mc2acDZ4ZU2aBgiHgvPGDFjP0RW2u61rarsWJq+fb0zStGaZXb847BDxZ0A5LEVv9Lk/xzlAhLvcmmgIUY5yefOCaWN2KN9317H138r1wCB8rSqwKsdGEZkrlzB7f33sutAVGp6WYqFFKTLMja+EwzuyGmTkZnFJFj76pRSvE0nnza2xaut68SYsYZNOrnihwOoLzBGf/dtzeo6WYcNQCR5tiZkqFqUKZFt80n2GIZou0GzPbw4R4YT1MxDjjRG1aWQVW/NEn0BKTXF2wdMGtiXKUQ5VFXxXmohxSYRUNRvuY8S4/eDlXluxrvXZuz9bPRJ3GGPJNb7/1PlTfQ08BNqUvd5VEYSl77UkXEbxcSp0uFuvmlwIZymyQi4wQ8cbhDM4mrmpNKo8pxma1wtoeWpEBtlbEWJgpRM1kjKguzlUqg8FUHzOOxVP9tzuxJFl4XbqgU2qR5ep1vniT3kUp16R4WeOXy1Hs6EoVO6M2sJfH+/aKZWJCfb6TV+K41tXGWpxnpGSD7R0OHPY7Dod9nZ48zMcTEVKypsU0R8ZxYhxHuq4jpWQqnvruOnP3M1eFWwEffLVd+XShxzW9HGG0tv/cels+/OHuPMnxfd9H2AqK6FIE6tEzu678FPQ4qa7AGFvvy+lrvPs+RKvs15KPCvdgtEJxisotxD5rASdksXtHjs/DyT5UveW9gitIUCRUa95gXHq4FRy7HZBXoTxvImrlEZScY4zHSfGtqqutCUeorgiuCicdj/LJAiZYPpIqtz3X9eIdNBK3969BUcsRCWevm+9ds3ajpZxQzeYn6kzRfZkiLo2U5fouOVOKCZJZU/q2kX339w3evBSJixqxLdn6zv1jOVepsHdn9xnuVuG4XuWuuhM8hIj4S+KXQvOBWCBryN3FdplqeUytLmWTj5YQjtLH90UUPhS5Jtu2t6UKq7vbxfuPEAUhVZ7SMsUErGOs1Tz4EaCzTz57iouJeRpJpUBU2Be8h5Lf1Tf0TmhNMPbhEKFdnbH57Euavsd3gaLTvXPhcDSAGO+q86jztCuh65XsP7ARLc/glnN+d2/y0uBdYCyZfUq8mSJjVMapEOeCBodgfDgpBV/9lGK1m3jfHljUiu6iaip09bWTmrBKUZjqRHNRQP1rRnBKECWXwjQW5jkjrjA3GfFmQN+5Fofx77L3FFUOJXB18BxGg8t+d7Enpsx+TKSieFeLS+9Y9T2bM5tinp2dc37+FF8nmsa/dDRNa6JAq56+CzQmWwxSlSg94I3jUEqxjj56hM4aumGRpl+gy/cmmt7O/50rqiaDxXuDveVoNifKccJpcHD7qznqcWNJ6dMXL9cvD+yvR8aDGdin9LClwRKnE/FpzgzDxOAdh6z8eFDmUvj9q0u++emKlLUeZ+M8ig803nPWtfz6yYZNE/i7v33BP/zjb1itWrbbkZubgTkmVErtIkv1P3PHibBt6pExjkBmnDKHybgvF7vITTSkSRvWBNdzwPH9aBOLKzL78hNnveO3hwPNamaz7tisnrJZPcHHjs2TDZ89fUIIA2+vBmKZEF+vXQfBZbyv8CO3wEZhn+CgMG1n/s9//emTn6sPRclLEuEpLlGoRXOFQqoqKed3EqolRDMN1AL7z9uTtBSmaabMBoHtupbgbQVdiVmdzGrNoSkVhimyH0xMY0jRJtTZFC9ztobYVBtx49STEzQhsDlr2bTLBKpqjruMI6IOFE+fHL5RGt+wCivUOSR4FviSpvL+Ke0njKXZ3LYdm80Z0xzBNQyz0k3WlBmGkZgSTdOwWq+Y40QInuQdOTlTJ892bKfZJtShqToCgjXN6iRD4Kh0LZU8qLnUaWNVH68FpvcBL6HSHGZrLpVk9KDiSCkyTvberoYtcdwxDgM//fiK6+vLo+jbql+drIfUBo+JZjWhxbmAFri6uuHVq+8Yh4m//dWviM+e0NRp2DLVXCgnD9nMNU3LF1992okmQCyJXTrgEFondE6qYvJfBv8UrGlm1aNZj3zIBTSrJ5fWoOTqPkgt8S7RZPMWVulRWXNqlKa+kFYT2u7JKIOxLBHvcM0ETuhLYZ3Mssr4RYKUTNsMNGUyj7YWJHicg7FMRE0mMpEKgqMI0Fmzo2vOOO9fUPzMFB/BMqg2AhsndapYqjC4Fd1oRXncRwrWYi3UCbGIkHLGCFa1O40VrdTCu2sburY53hulFNN2aNp7a6NU3YeGXErlXmeaxh230YVrqcXsvkJoQGEumVyK3SveRJpQoZSRFBNOvN2j3pvn6QNNI61cd4PUOpvmuofGQMvv2v0fgqfv2wr9/bQw518KzQfi2PG434kSEw9xWtBkIhPqBWkCzv3bhEGWqY6N6AuSLQF9DIjpY4cVMkthV/C1o59ViI+oOrt5ek46DMR5pmixbDeZL5gTxYW7XX5LCt+fLIkIoV+xevrcoIxtoBC5u4QE7LYRxAu+s+lK0wltqx82RP5gVEVV1+EkMeSBqxnmCNNcyHMxWy1nBW41Q7KO2ZRJ88cpFWdg6TVPpTBWu5e51ul/7Zm6YFygzitRFZ0LaW8eXioFFaWTjkYanEBxjhwqVy4HtqNnf8hcbCM/XB44Fd8SZx3v4D1d33N2fkbTtBWq9RTvA6v16sjRbNuOJjS0baBtAn5RdMCaTk7Mi0sxgn2Md7v2qiZE8CFurC+10Dy5LhfvOZsYZvPRpCbW2daKUPnGqso8J+ZH4LsssftxYDjMzIP5C+ZSPnhdqHK095hjYRpnRi/sx8j1dWRImW9/uub7N1tyUVZ9Q9cGQgis12e0wbPuGr589pRn6xW//vpLfv2bv2G16rh6e00brplmey+iBjF66C6ec2ZImVQiN4eZ693ENGcuh8Q+SoUsrxB3xlzgKlqD7Goaub65ovcZCTO/+rowP+nxXwY2z57jU8tqs+LJ+YasgnhPrhMHtxSaXnFB7wiYFJQxm2fZISf49tPyXt5zNliOTjGVHUvAXKKIO07tFgXfnPODnrIATjMNy0Tt4UTl56Ko+Z/GkmmbYNwg7wiirF3BqXKFqS7OKTPOiWG0QnOcEzElu9eTNY9iVg6zNcdSsvW4DUrTKWdiiAUloDQ2NQoBXAHxxNzgkiJth/QbxHvoGqRr7L7azsyH+OiL4FI8NU3DerVmGCaQhjHCOBemKTFNpujsg6frO9qhPTbNELNOyxnmmBiHgUXR0rsW5x1t6/He4byJjdw/dZrTsdAUqfxHsWaA+EBOiTQrWozzaV8TMUWmaca5yNXFj9y8/YFpHHnz5ie2u60hNETouu54famqmdJ7E3yzSY2nKGy3W3768TUoHIbDUWhGj4Wmuzc1Op3Imyfp8xdffPJzlDUzpMFe1QttnTqjwod4mx9zl3jNiBbTRKjg9qU9cv9vi1pTIQODmgvb+y7PJmX6kuo+2ZIJ3IHFu4T2M2yMr36/wLVpZmJNtKmo80hjRmvOjYg7pY1YXjdpBI24KITJ4VQpnR0IEaELK+gguxk3f/o9yy4Na5CAMEusEzkqsqTgkLp+3f87V33QxfbubE1box7U43ai6ty2Dd555nlmGmdiSqCdFYkn+7lUdE4IDaTMwnV3rty5fm0CWnASCN5KsRjlaG9onqjBJtClmGCPqqF5QkN0qX6Su59tUZS2Y7CIiuUHEZpWh9RC0/taSGfSJ24K/FJo3osTO3jeve0X2NsygucEYrLgGj68zNi0tPIoFm6XirmgqXEkPqpi+J8cp3X46XzmjmfbyddHmc+WjMMmmE6FIKamGu4purqKfAxeaFpHG4Smc/hGcAvXpQha9REXfFHBxA9OleKcFESqKp1qxaLWh3DvZj7ddn5+C0rZFpMpGhw0plK9NQ32p6pIVtxJIaPY1OvnRHROf385d4sAUEGr8uNHPcUnCJsCpmgFTCOYcJNY59sHhzqTR9CiiBSTRy9CLDAlU7/cHSZu9hOHwfwcH0yYjwoYCxpNqzKdbSopLVwLReiOxuNLx7M+ye1zfeBavoWvvf9AltppXaCvIrUZfKK4uCRZpoZs56qImGXbAjE8ypF/+jvLoLKlWjBVaKtStUytiXMai5Kxq+tizIk5eyZNTMUEmTQXwjLJ1aqWKzZVMRXb5WHHYZn6NF3H6myDnxObITNHg/GmunYuK64AkhJJPZKVvoW5dzifWXWRvjPjI5Eq3lao1lOQyMzJYLT7MXF5PVEKdP3A2WpPHCKihbZ6cwbvavG1wKnqOarn/db/9KQzDsyPYEVj9+4CB1vWhbrW1BGWrWnu3vtafs+webdNz5PzSqEloaQKI65TdSfm86xSedD2unb9L8iW05fR258XE2lSp1TkaoUJVm+3osQKIV0eWbUmTvb1Fr6rdZBivp7DPNn+6ZxNK7VYjYkpafpQ33vb4trWfjcEUypWyM6u0VNY3aeMO1OPY2LX0rVt5UHW/CDnqlxpQmHB+zq9XxBPkHO6FfHw3pQ1K7Tce5uWNk1AcEzjdIK6uE12Ty+D249cvTir8jrqKj0jI0mI88Q07BEnTOPAPI3E2SafS9J//JxVFVXVILxeqv9xbayJiClRz5F5nuvXSNulO1DAd44jFZaJ7fcmbPI4Yfe1oX+cgs+CTxhipWTQXN9Rvb8+6jkN5WXHwmS6TFjMfm63bZ1F+hNIpC7Z6UOvosf/X6xNRFNV315+JXP7Isv39NhLRU3pOcWTnNZHK7ak3LUwApsYlvpURY5PpZopmnG4SkXpzB3gkbxpT5e0xQ/WuUXcxq6VU4/ZxR1gafiIyJ21b4H8glLUVYShu1Wdr8J9x7W0cik5ycvEVdiwu8U73z18dW9Ycop7qQZoTV1s7ZLTx22Kevy75fWKljrBXfKp28ZiPRi3KKC6jt95HrnzJj5Z/FJo3osmFEq5hYKehkixh1qSBKAUSomUVOpJfagvZaGqxJRtYdYqCX40ZrcLoF9B23WP+RE/SRhHzpnQz0nRmfVW+GeByz5KkQnouMeXTLdyOBV6gZWr6qzh9rU7D40Xut7x2YuG1dpVqKQd92F2jGNACES53fBTLoz3JkfBKW2wRaukhAyCzA6JD7Ua5T3/ru//5LulKPspMkyZYc5c3szc7KyLP8RCzMW4E7ncSVgUS95MNObnk6Ok9lg20MwykbJi9q8V0zBxcz2hKP5pTx+6ev23qG9RrONeYgHNjHlCdWYbC1dzZoqZP333hm+/e8McM7vhXZGeRQTAuVCnkDOquW4sGe898zQw9Z3JmrctwXd4d8qDqh1B6obyoajJx6kn1b03ZL5ksiQZixJxMgn1hbNas77bwgA02CS9qDJOkaHKszv36eFI0xyZ50TMmVTykb9rSagZkp9GFxydN1h6IXE9H0gusp8j22EmpkKIM1+sbLq3j5lhLHhfKDrRzIUOuFlf4XLLOJ4fN8zz58/YfPElORc2zy/5/O01MSWu9weGacIDLda3H8eGm53BiZ+de74kMKdCaN/gwyVzzGzHmfFwRUbIxVMQ5pLZOWUswjc/ToT/6y1nq8D/8htFrg/MSXFpz2fPW4pLrDYd7balkYI4y9CyiTRaQ6sxexdE8JU/KsDuESiak0RyMcuBu3xggdBDaOu0q60TJTmqFFohNiMlMU+Z/ZCO4hQAXgq+OdCEGXVGPWjaluIrLygX5piYx2jNriykbIXJuhH6exwFLYU8JSQppQF1wkIXn7IwZtiNkevDUAU+bKqvVM4U3Hl/i21N1sLF9Za30wHnA/3qKW23wQm0ruAx/nV/vrIGQbPCdRsQT0FJtfHlGuPnm+DYhwCNf3kIsOpXvHj+HCfCZmUeq6Uowzhys9vhxNEET9sEhqGjCYHgPaUkhsOelHJFBWxwzrNarcx3s+149tlnrNcrdrs9OQvDMJDSTEqjFafOamxqgzFlswVrTrz+tOspjTUibGoKXHiKjZLZ31yx310bryyXd+yeTDTFdE29M56zrcne0Ds+ME0z19c3tG3L28srnj69JCs8/zzS5t6aOHq/gWuNDCeKD44nZ5tHPVezmsWHE6GXQr+YmOYRNAIekZ6PSacVyOKJzlPI9H4mYArOcTYtBucLTWeDh1SFnUoRdHYQPw4hJmXCqYnKHF9blKL5nSxBZsVtFYlKUtgWh6D4MOP7iGjGTTNugdfU8AptMU6olttmfcwjcxzwPtD0K1abZ5Q00T6CvQlQoeIVChtsml+qtzG1WDPbLbFjij82aEJocOJIaSYWExTy3hMag7ImLK8w7Y6epmlQcYRxpKC40EBoam6gJhhYobNN2xz3+YfetDiPU4f3jhCsibAgYgQbnLQOkhdi8KgGfOMJwVVPWuPHFqXaBzUVzutw3hr2ofE0XUPRTPBmdcw7DwAAIABJREFUIeWr1ZBzjhCTcWw/Ir35S+KXQvNe1EbtAwNpPT5sZld/qoqWZDdx8YiEe3jtu09RcoXXFZMJvw+zC037wYnIv5fQyr8s9woohUexMnnwPcQZ56BrDC67FJqnhH2DBFgS3LfC5tyzPr+XnKsjTh4kkE8+T7ZR573zmatvlaC5wCxm2pwfKjTf+865PxlTlGHOXO0zY8zsxsw4md3HXArJDuxRxOfPCa1F5qR33+oyUfhrXXeqkGJi2A+AklYB6Kx733h6J5QspDzalKN2vXOB3RB5ux0Z58SPr6949fqKnMtRVe4+V+Ko8MhCnFdEpppsOeu+lkWEIh8nmscGowgfsiy687n4meOodydGeI84myRNUzxC2ZZwTmjC0o11Nn0v1qya5ogg+I/gBP9bI8U6XayKnOXksgtOCHJ3dQxOKnzUGm+HNFNiZhgSh5uZlAsuJc5b43EeYmGO4DIgkVyEMUyM44HRReY4Haea3WZD++QZqkrwnlUbmOaIXjlk7wmirLCNrA2KJrO7kbaHdk3Mhe2Q2B0iwzQzTCMpHkwYg2DiMWIwsqjCxU3C5T2bzvFUHF+HRBFBirLeBIY5HGG/vj6LfeoKVQJEHcGF46TV16M1PgLaOYn5F5Z8j0e74CHF/J5MaOnuuicUHImikZwi4zDfEQILUkg6UnRGG4eT7liElFLsBOZM0kIqhTk7pmiJXevfvV9UoaRs00kR6wBihU4sEDOMKXOYzIM0pdtjusSpi9MC2S4oh3EiTgkXAuc0rCXgnaDe0XgBCaz6vvIYe3xrhWZMCUm2f4sXfCgUzSR9XOEmMCje+dmGOM+0bcPCm43RGk9NCDRNb1+DcZJdhdjHeTY0Rgg0bVcTWxMx67qOs7Nzzs7OAc/V5ZYYS4Xw1QZVTSy15sYLfE6oCutO0IYjHy1WvqbIzXFyMxz2DIf98RO9c32J3RlKRRr5ZSITarFp3qGHYWR/GNnvD+z2B7p+dRR5et9a6uoxdB76/nEmZUss266gBBvw1cI31UcAWd7D+yaOSwhZpA4QlcYVgmQShSx6BE/5UClVWjUACpZjfLSbVUT07i9LAdVFgfrkPSaQQ0FmGyCMddrauEzoRkQLfk7W5D55Pi2FJpXjVrAgb7JGUjEF2n7VsOrPKbFF5j2PETbBvC04bfp/u3A45/DLRLP+dy5q8Nbqa1lOKGvOOYIPR/RTUUW8N9/0piHljA8eX2y6SVWYNcjR4kXr8MEfG6bvvGcW7rFWr9za/Dv5VVeXcBVr0mTnDILubi38xBlt1nt7PSlGrVo0HY4Cet7b97P93PtlQrtMSB8JdVjjl0LzXugRKvnupGCR+nEiiDelOl1Iu7I8HjhdqlXco1DKLTwsJjNKFVe5n4+sePfnxBEOce8yLAv84yMT8Me4iM+bxb/PbshQX8cS89sbdbnPl001x5N3o5CjkpOCswV9+cxFc1WHE1O2rDyNUuXwsxYymSIZvBDalhyFOEdSWryv7hc/3DkatyqLsBuU7ahM0TwGU9EKqb5Nrt6Vl/m3hB4nmHfyt/sF0COE6cnokQCfK5wKAOcxp0LBNx4aoSSB0iPRg7PrzRWFw8w8zYxTsmOsdnU5kaOv6BLe3drSOFmgZ+4ITwM9QgaP0Lx6fnM2yK7zzsSjhCMs1jagd73qSlVbtee+C9tZNptbKxQ5cvwsqa4cxAW6IhBw5OKNc6OnynP2eoq+8x4+RcSUDb5Yz5MqxylYEGi8vUdVOf6sDl7vhIh5OjpRvIp5URbYqKkze+85W3V0bcOL844vX/Q8W7c8PfM0Ltm0LY+QD6CGUujWK6QJnOeIDw5XCiFFXCloDqRVS04O1/e41ZqYledP1+z2PftBuN4Hbg4mqmUNCE/jhVXj8E5YtUrTmDrtEAsXu0gR4WbIDLP5lmop+IqXfVdR1Y6CE5uALHtGVu7C2D5R3G0Y6RGCDKBZ0RhxYrxm7/0J7BS0RMgHVDPzGIlxsuseMcikK+SQyD6RiyeXW66QFYwV+lyMM3gKvU9ZmZKtM1MWYpHapLAjMhcYo+IdjMkQG7FUIQ9cpZFURWapcEOxZDkUuyFD09A0jfGbxVFqQW0+g1aozCWTEza9VIdi5/zxcDYfGVKhs31H19u00gYLhXmeOOz31caos7xAMRXoOYOa8I84bw0P7wjBs1r1rNdr2s68gZt6fNo2EGODamSeH0h66x5pl/Si+l3FD72zHKXCXs1GxcSHShUtOSqHL8lq/Sparc10gTHaixz9xk/2RtXCOE3sDwc2m7MKCy485L96up1qbfr+tSKr6RmIqOUW997P6XspTsnehGhKRVYqasUAxgss1GTDqZkIOzWwXG1ce6AVyCIUr+TmLpXnNJw/gnIfCEXV4aPDT55FWVdRZK6vqZWuotlutJQo0Ypdl+0tLpmxr/dkljqJqx9BFDRncpzrpLNmLCKI//Tlxi00dKEGLP++/R1rNtukvqjiVFFXXQPq3+e8oItq4efrPVeyTR0XhXPnjteyiWc52qpmnzXZ8zj7vnee7Mpxf7T7tKFpWkSiqdGWUotHa0e64+sYZD5U2IHzAV+yFYwVpbW8F61QX1+RV7IIQC0Frw8VTVDFTH0gNJ1B7ae5OitQBYwWa6xPW4v8UmjeixITBc+Rq1dDAK9CW5NA6R14RdThSoOofy++WbVuzjmR4kScB3LOjONETLGKAmz+fRaamNDPfSjx3bnhh+OxtoG/P7vlh4F1xOeqe9B66IJteAvSr2SYD6YNsYQC06xMo8HgbqdKhaQTWSccniA9Tq0TOSXr7E05MjOTJOHawGpzTpwjw3jN9uYAIoTQvdPpvX1t5TAV9uNEzMrrbebN3niZuzkzlEW63yJjgj1/CZfSrExOKteT4/CYMSRPSTN5HkwaPym+MciJup7ECu8c3coTWk9OmTF0pNkma02yKQdXB64vt+yGmeEwHmFVIQRCuNvZNouSQKjTnMWuRkshlpmcHU1oyb4lJzOMT8mKwGlOpGI+qwvfI1dup5aFV3h36pFSZo7mf2qbmK9wHk9TF/NUp5H2vm0tKbkwT+aTtXBBRIQSrHXinENSwblUi4SFE6fE/NEt7o+O3WFkzoUxZUpRgnPGexaDQ3YVEhmzqUmHowXQaYip6a1aXIFSEpITRaE/a0jJ0zWeL897zrqGF887fvuPT3n6pOXZec/KDfhUkHlGxwOIp1+f025eUHLm/OmaPE+kaWK8uSFPE+sWzhtr6jVnT+iePiOr0jWJJ33iajdwM+y53A8gjtB0iAusWs+TdUfjHb2bWbuJ4JQ3h8R/fbmjANucOOTEbp8oc6KlCt1ES9i81K65E3ps/QnOYL2NGDpiVx57SgbzPLHf76wgxPibllyYonUuSpytmeKc0gRTfh1TZD+P9v3SICWQPUySmaQwBU+chTib5U0aY4X7FaZZyMUdqRJF4ZCUKVvjZsyOWIS2iu+0fpHVzwjK1ZDYTZH9nJmyUEpjkHoP0phSdnTOOvvF0RZLqPq+Z7XeIM4xiVkwqAhFHFO00dOUzYJjU2D1xONdj0jDo+kGfGQI0K96PvvsKYpytu7oguA1s7u+5qcffuT8/IwnZ2cmdFIg7mfGmxHJns3mKarFoHGN+fC++OIFz5+/wIdA1/eEEMg5cna+xntlt0uMo4kInUaltdYJZyGVXO2eDFZIgegjmcodrfx2BZtOnn4uV1VsXZ2SJj2u0bLkTq7BSWP5zuI9GxNXV9fmGRoa5nk6NtZ+/kj+dUKBKZs+gBdYe0f7gZQtO5ham/gptxSjpc2xwGU1Y7nkKiNkdPYwesjQiSFIsoDrFAnvd5oW+RD80WzTun1LmFuyJqYykrQgWY9iullnYjmgZGQsyGyFohSgOALKWW0AFYGpJldNKXQLzD3OxMMOQkvpn9mrO49063/T8f6YaDqzJHPeBHmcTzgX4M5EUwhNoGnDEXrvcsEHXyGknqwZF41+YCiBZjlsdi8Eo0ME5ytn2h5903C+XpmXr1fG6o3dho6m6UEFHzzOG6VitVqzWq2YxoGSIznb67VthyqEMFUrrWCNptWKGD1ztJyhaTqa1lAO8xzxPtg6EFqapqPkcsw3HY7gW9rQkUMmeE/2nqbt6TfP8D4wzxnv9wimqrvue/MaHh62J/pz45dC816Uoujih3YvBOvaWPUiaCNWYCaPlBPz1vtJ/AkJv1QVt5xNwS3GWCEzj4Nf/7n4GLRkOUJkf2ZR/ytDfp+0cvdY6y2yxIvQ3F9060QzzafvU8jR5KCp4hL1V4F8FNpYLFtUb7mMWZVsblTgBN+01rUswhyzdZZU0ffQ6BRhnpXDmJlTYTdmdkMhqVbfv3f/ptQpykNxh7v5nt/5EBzpMSMXTEU1ZUo2U2ojpPs6bfAm3d0Ems6KrdSIwbXUugeuJECZx8g0zOSYWcQRli7c0lEHjh2/Y8ez8uUM5pjr+S4nU83bRy4FsuBP1OqWidECqbkv/FP0VtzGOw+i1Hd0nAiYEqPByZa/1VrAlpxsLfDV/644Fq/O02nq8TX1cSaac0xHP9Wi4NEjSsA7QxEcLYtqd/5BtoBzlgBYT44QQFVoQgslsGo8L846nq4aPn/a8eXnPU+ftqwaT5CEKzYB1aSIb/DtE0LbQyl0rqDRExsH04G5JAKBpjSgSrfpWT1Zk4vy2ZMV46FHpNB31RbF+QpHDPRtYNN3tI2jUaUh4ciMqTAmg05NGomamSfDGTqsAZTVrm0VbnkXCL4m3A3QiUHWA4+/xuecmee5+qVF82TDCk1xgZKVaVRyNh+8rjOY1ZQjceHvlYzLLc5DSnYd2P1r13dZHsk4lDm/q2mQsoEKi8KUIVZYWSqGMnCijBFATdyrCv8YNNamZOKsCDI+k2HFpDhCCZZEhZYmNIh3pDpdWraoXHX7c4xQEm1KFBVUPPqzZKS/xvooR0XZvjfhHptoKnGeGA4H2qYx6N0yPU/mbwt2D6ko3rSMqjVBz9nZGeItGRbnCI0paKdqB3R/Dz8iEWwECRUlIb6eJ+ePEyEWP7+yqHOGKooCy2BORGrhat/0D2gbLkb0y3oMtnZO08ThcDiayP+csNr/jMgsAnoG2X544cOmv3JqhqKnPzK8nBQk2ZOKgHhr+pALymKlZ7+bgcYrs/vzj4co+ORossepEgt3BH5sTypknY0MkDn5AHL8nbp7GXGgXrNebmU0tWRrKiPVE9b+XPy/zZnhY8IvaEJXr+2qlHOc6sExN1gEflxdp52T6n9+OxVdJpqG/tA6EfR16ngrqOZksYpytI01sXP0Rx7yQlXIzh/pOM652hBvSCEehX7sPgvH11smmgtSQTXc+jjX53XHh8F+nTi8C6DpNg88TjTvTmOd8/jQ4kODq80kEcV744Sj7+GV/gXxS6F5L3JNFB6qqUwRst5MqfoF1ZHTx/TVBIPLtHXRV5W6WYaaCNjY/b2L1yeOW4joh6aT7//Zw5DY6l8EFVBRE+1HSLLMp6vCMuG9yquLumqeFQ6JMBfz/qyffyr+/2PvzZojSZJsvU/VzNw9AsjMquqeXucOhXKFv4P3/7+TQrl84ctwmtPdVbkAEeFui/JBzT0WILMqu4GanpHSEiQKsfhuZrocPYdTA41ODFIoHiDWBovDLGpcHNYiivacpCiE5N5QDcrBlKUp7zP89eRXbqiV6OhPYp+U1303g4dT4ePRnay561cKq9anT97Vnnd9zuyBnwPL8LRy+R+0cKdgWPFseW2FnGGZHepS9jtacyjs6XEmz06+sJwqNXvgtiwLpVYeHo58OBx4OMwcFyehQFZpkLZBQ9YJdrs25qRdmPSkT8Xkxx2Z1pong1S2bP5K21+7TmGtpSeQjFLyFvyJiDuDbYWZdWKCGLZerNWhAnyxNKPV3BVVGmVdIOUsNJ1zpubsf78CVXDt80EQcUi6KFF0Wyylw4qsdgZtxKuBSRlTIAyRMAR0UY82DAJKkt4f1GmgxyTc3w+8uxu5uxu68HeHp1XvAQ85EHJAmhJCJYj3itWcabn0fvd+DVSdnAGv1mmbEeDt/Z72298y3Z/4394viHhlby4+N0xJuZ+c6Et6FQZW+Kt3mZ2KkJtSTDwAb/7srUHYZewS8AAzAaMKkwpVGrm+/HJ7ejx44iY7kc9SCq1X/7DgiVGkU/Z7u0foFQpVg+QSQqJegTUMSsDU9XaXBsfFA4d//SQcG9CCl2uaV3gO1YPRUjx5auYQ/bbC68xJ44aqHKz3b5pBcxjyh1Pj/azMRchhQvfd4Qt4kkKEfYfIYoJUD1DSOBJ3O0SVyRp6o/3WmrK0Sqvu0JWSWeYTKaUN/lZaoVh2/eDqLQ/NKssL68g9MYEYlGlITGMiDZGQIoJxOh358PE9GsSRDqVQrbrcU7Ce5/bEVQgQeh/34Xjk+++/d6mmcSDGyOl4cE1wPMALa+9ZdcXAc1/Gmkh18jVr6zzpTnJKY/9uxWrh/I01ke7bMRMQ75fX3j9usLWkeBImOOxdvRI7jBMxjTQJZBOyrQkcI/bD+5JL9Ew78KubCSzJiw3BhKHB17bLizhhy3r40RLaKlWhDv2aFoHq4XgS2CE0zJFNX3fEGEbpfZvNvizD9dmtGJQFFlvRZCsrceuEXUaWyiwLTSCXmVLX6tjL36gQEpc8DEG9BeIy/7pWCGNMnizT1vtsz/6pk0N6kDX05IyZ0Uql3swFIg6BNYNhGDZ5tLysBGIrKZFXVofBCbqGYegEPiuCQBHzIHVlTk5pIMahB4exJ3rqswNApbfciRGjkwSJhIvgee3VXHtXPQGVYmAc1v/vCX9A1QPPYJ6gekn7JdC8sVyl90zeDAvDJ2Bz8fZCpFXPBKjaT2Jsci2eSNCRZpCGHbWeMy6eKXkFUdsvWOtal+0zuH/4fH732SKGVXSdzCTRpGPMX4lcoTQ45h6MrVnVi/ebuRzGUgGpPCwejGSDYxMqgoaIJkgJjmVhYaERXHAyOwscE4S0EEgk2SH4gE47l1PIMfDBlGNV/jQL/+8DQGMXF1IQJy1R14xcmnA0oRo8HgqfHkuvop2PP6krdlYT5taewGW3qhrnyt2t/TTo0c9jU2gULSxtYamFZW7MDw0VZd5P5PsRqdYd58Wrz/2GLkvl8FjIpfH99+/59x8+8HBcKBKoKKJGbZVYM8TIMMTeB3HumWvNg1YvvPh2LYSnbCM3Vmqhzf6ZWr0auzISezWnMp+Orqm5YpfkXGlXUYpCrL2nQ8W1qqoTeqyLk/Q+jVYLZTnhJEVj778IlFrIxXvs8jxvGp6vwTpb2kro4k5EFCWG4AtbjGgKHmDlhdwqhgeZb8bIfhcZpkSYoqeZFr/eQQIBvaj8GftJ+dW3O37z7T27XV/ogVKF46KoBJIGkg69/7ai7dEJSk4uYF3zcg7UQ/SWBtwBj/URUeU3v37Lr3/3ew7HmRhG/uXX3/B4yvzbD5/4dFwIVJIUFGNZjHnVLtXGEIsnpIoy18Bcz7DpWhu5eUWzF522JNFOhCTCXRR2UanPsJi/hD388IOLghdnTCzq/ZgmgjKgslYRPIGpBsO41h4KjRmjoRYZGdmY0Tu50KEJ7QiHrBxNGEchaGSMI0F0k0UyMx4fH3h4dKj7LM6TJqKkEAkaiCrsk/8+nRoPBw+iVBKhw1lPMaHf7K+qkyko99PIEAK1wVxbd/JGxnHv62pb2NXM5WqVa+OTGXMJVFHm+QCtUccJuqbo0hbm5uLrS17Ic+5i9q87bwowxMib/URZJna7iTQN1JL59PiRUg60lnk8/AtvlzeUmqmh0GL1anzng3ASEE+Of/zwgU8fPxFj4P7ujmEcKDlvUNdVakIkUDrfgPfNFzB/6NdqZcPJDT1po+x2Dns086SaawZnas1dbsgTL0F6QiNEgvWKNN62Uqvf0JgCQ+pMwLs903THME1UTcwmLE0o1fvka1tD2ufHzzkp+9p2fQxN4DgKx70yVEGPuOzJF471dkuiQhwiJJzRdfY1pmhh3mcahh0dRisGk0hHRwgPNOavekQ9ab20mYyPk/Y3JP9bhflo1GzOQh1DRxIVFmsoBpZpVohW2C8HdvPBAyZ9+XAjpZGtMGR4m0dQ2gV01it1iZQmVCulGK1LCa4V9RgUmQYE2O1GdruxJ5mLi5lfmAelE6r+/N7d7QkxsCwnVgWJNER2+4GYhf1+T6uNcRxIKRCiJ4c0OBt+GhLTNAFwOs1MU+7B7IBqxOX0ngk01bV4MfPgeIjUCimGHlxr35fzG6QYsZaYhsTd5G1FD0P0SqjgVc40gVam6fSi9+mXQPPGmnn1yX2Xa7jDmv3zSkKjyVMh2C+asC0O0uh6bE8+8NV5ny/HEpdvfqbyZZ9vIb/e+E117DP7k01TdAU2GrwSNNhgE0//nK0QN3qW1MxYeqBZTIipkbQhwXuavCFetxM0WYmBDCF4BQC2+ynq0OI1GztXONa+mIgLMydxUXfD+yznJu40lcZS7Or4LxnAzK5VSi//b/urp3wvg8p/jPDybNKz56vu3iZALGy6ke68FFq+7g+oxauKy+JyCnMuzKVgzsx1kZV38/6iW5iYPR0on4UX2+aEwcpWi1eOqhMotHoBs+26dw4bi1tlEusw/BsImK7sG2Ybu+p6lXz/XUuzrYHt5Vl4Nc06TeRr0Di1XkFY4bIiKzxWzrC3FUrevxPUKeSDChJWfS5/Sn0cABdwJsTZalMKDEMgpjUhYCBOgtXE0CrE5hUpq/261JWQpnSI6KU2YOejFGeEVYGYIrrboap8+2ZPfrxjTDMfjydKdZ7p0ApiRr3QCJVe0VxrDnYJx8K2x2vrV1+rL+aQNIXeu4lD61+hB9/1Fl1s3AxacqIlOuGKyFO5rfUvv9Tl7PjS5xvzZ7D1ZFgxsCo8LMIJv8874lXvuZlxrIFDdmKgk7i4vKowoESUiGBFCCIcMnw4NUppjMHY9WCpSUAiVxl8Ce50DTGQm1HUE28ak0u2iACBcEOV5km40FlKpJMXZUKNPq5wso9mndjICrUV5xL9GYIXVa98pOjalxqC778UZoqjODrqYdPHCyv8za+XqmzPfMkul1ajV2RE7BoxcUWW0p8Rmid/LucYa9D1A11Q3pOqIF3X2H2GVY/2PH+tRGX9aZIznkm2B0zOJCyhwxJjcqdbdONx/umkd/ZskvXvsmd2bNsJdBNoKlgQtLcWnc/9xzdsrPejV9SaoX1+qdKQ0OcY7T6UcDEPgd7etJ98aoZxLVNyPqXzfP1Zn9I8N1urz3MmTgq33jek63qbIdZ8fPXkRZCXDzdErteU1X/eVlRxepz1uQc7j4Or7ciZtGfV0u5X/NYfWHU2zTqkNlxoVW7bY4PMnqGujkxaa9FnbcwV1nuWPFO99V/Odrnmb33PcpZI3H56eLqtw9KPXc5kmVe6ytszLlfn8hL2S6B5Y9bqFiatoqzSHbpGo1r2UKr1gWVfGWw+Y162dnclrNReX3vcrJC3a+da+4BHcJKjm9Lrl2Gz6/FV38bl9z7zXfFaIOAkGdUKrq708g7xsThc9kuBtggMQVBso9Gv5g34dfEqotJZO25MCf5eA8uetTXNaJpRLZS6OPyxVJY5c5oXTh3i+flFoO97Nqfmz+dpI3KWQijcQmP8PFuHC98Gle32IvyD9bd8//0jp7xQTjgSwFwHamN4uzXx/j7RQJ6PfP/wwOG08Ok4X2npQU/epOhQuhAcnrJyefUKo+u4XU+gKwV5CN5XhGWszjSUWirWurPVIUFrht3jemfPFIRI8jEs/ZyCO3G20p5LJ8ORHqyY0swZN4ekF8v72QwPIko99uN3HTBBnOl6nZteAY7UrKH48Zu4eHtTZ79VFZIKlU4SJJ5BdkKSDlvKDjZquSFdZ01C9J+O2lCUYUhb8JWXxvsfijONrs6nDrwTIe12HgTWCvNCLYXHTz8wHw8sS+Hh45G8FFJSpsnvZxpGZBq9B9gW2vEDLJlJCm/HQCvKIM3RF1apLff+pO4E4OM/WkCAu8GdykkT7Vc77nbK4VSQ9ydOSyVI79G13o9cDDVhFgOLDiN9BYxf1QlTIw69XSGoV+oRRCL6hefDCDQbuJxp1h50KdmTQCujawiuF6cJQoI0QXB9tmoVoxGmiTtr0Ix34tBjE6FqpIk/5631VgYSFgZAqQhzJ7UqwXu2L83bI1ZyoYv53irW8nlM63UPmFglxspgPjZLWTyZZY3cibcKhWodUbL0c+kB1mtbDIFxGJjGgd1+x3R/jxyV5fTI6TgzDJ/4/vu/MgyJvGR+/U+/5d0333E6nTg8Hnplce3TFmJ0yGrQs0xKa5WyJWOa+xcBqJdhhWyBnXW9UrMKduqBbECDE5PJ6k/gs1+MqxybosHZaVszLJfOvun3UnqfNgJxGEjjRIiRYdoz7fak0fttg67kbX4ezyhDbGZmL+4QAwzt2hmoGimkHmyuOwebHcrdmnLMA7k+jy4RjNAKsa8BGgN6c2Laq5vWmvsbXVajBKPuOpS5DLTic0kQYxRPCmTL2NdWJ83QkpF2DQsdrKAXSfYnVj3SFKwTCxbEFJGKdQKTJoEqAYjMuXJ4PBBjYtq9fLhRyrIlTcCTwiu6IwTnfUCEeVnIK79CPZPpmVVoUHJmyYsnHUMiJh8z8zJzmo/ee0mjlnTBHO8M7Y+HI6rayT094TzPTlaYS2aeT05uZX7/Q/REF7Q+vjx5DN56k/Pcg1mh1UwpBay5/4I56gljWZaup22MpxPj8dQh0UaKERXhdPK++3XOWHImfnpg+P59h9YftzF2PBx7MaZyPDy86H36JdC8sVa9cgUgrbnTE1a9r0ph8QxO7TjwIBD/zkBTIKh1so3P1ha/fNzmPUSXSkeCEzsEKxhKVQ80v5Csembf1uGwvdlqfbXraF4S1riz7YGyB76usSY4DO2l7bBcV1WeM8EZIIdugpOxAAAgAElEQVQglNqlTMD7y45GqebQgf3t94RIIBCxZuR5oUqlRc8yqmhnX+y9hafM4TRzPPmE9iVr1ainRi1neKjgg3EUdwCO9nTpOOs6PX39HymofM7+/c8PrD214AtZTOcm9dv8rIgShgkNA/lj5s+fTnx8OPD+cd6CgfNnne5/mHYO50nBJThUet+zwzBXNtfVPNCMhKjOTGwZqyeaKblDwKw5yyZmlCbk6hnAlAbvb0AYSBiBIK7lqMmoKJlIQxAqrXmV1oiYRV/oVRiSZ4TzjTwEZpTqi5/DOI0kHS6zuydOO/6mjNRPsGaNhjpxirpsRO2RuwQhBXcykypFAyk48+Uw+HW0pfeeLg2pBe0ZYB09W5t0IEpknNImSTMvlcPhRKkFTY04GiEmwjDw9ptvAag9qZOXE5/e/5XHh/fMp8r338/Mc2W/j3z7bSINgen+G2R373Dk04wdHyFX9lJgjLQsDFIItvR5KvegqVP+IwQLJAtEgfvBSAp5FMZ4x7wMfPg4s8wFaZ5UK51YqhSvzEtTTkC2Tnk/vDzMOYcdMUBK0n2ty6rLl9MQRoAb+QgzY6kVZHZnOgRadN1DwgAhIXGE4a4HmpnFZswqab9jjIloxhsx7sQoCB9NOCIs1fh0aiytURmxMIIEh4WWPj5kOOMtt+OEpbVL9er+RoPaIetheBJoqlRSrawMs0tZkJphOSHysG19i1v7XNxaw8rrMwSvUgLLbmR3f8fd2zegwvtPH3l8/0DQyJ///GcA9vs7fve7P5JS4q9//Qt/+rd/JWdPdDqhYCf+GUboqIdaF+8n733lWPM+ZDOfgjsKZquxGBsUurWK1cWRARKQ4DqfLlPUk3sxEcLg40Wj92t3uGHrrJ5nAhWH8MkaaE73Hnzs79nt74hDYkgjKSRiiET1uUT189WV1wgyAcZ6GWgKs+zIYX+FaADgBMxe8X9EuhTaM8dJYyyFqWRUISHosKbj16KGkIbof2eBkz+HEjMtdZ/zGMjVmUyTur9QLFNbfbIm/phJq8TlhJZrWGjEGBE+x2DYrLH0IovD7EsPztYTgUYky0gjcJwrsT1672HafdUx/hTLee6arH7tvMXE9emlM8SaOSS1djbl2KWefJx48Jfz4oEWDiEdhkJtjdPpxPH42NnqKylGRwL0nvecMw8Pj4jA4Xj0YLUHeCkduibukWU5krOyzIuTdMXANKbeV9loVvr1nJlnP47WCosz6IEZUZ3KsJSF1oR5mTkcnXk/jUdSH/vWjBR9Ljw+HjkdTszLwqeHB2fN7z5YiIFasgeaZhweH3l4fOyQ4fmZq/232y+B5o211lzjaK1S3kJH+98rJO6nFOq8vC1ga3VUvspH/CnQ2C08tdt3zp/gi4f7ef2l56tjlzCZ7ZWeJb38+REoxt9hX9qkV/muEFjb62dpli+VQv0fzyH1z7XVGVlFlPtP9Z9az1qH1/vrPxvU5PpGrIe4QqIMkPbTnq3/LJbLOQUi6+O/UupjlNa2BA8bpMi/4TISheOcyaVDSW+uzapXeckMh8gVKuFS09STInqWpehOufWKTKuu4+cwTV8EalNa8+06m17bjsP3b9u5nUFOsMLtuXytQ1lUzkDzW/Psa3WYoHUtNozQnzFZL+Zr2Qqr6WNhPfzLsbx+RLVrhcp63HSCpnXucJfKoTsrA56et9m1S1c9221u1a5T3Okrz6QjvX2hM3jXUqkValVC5Sy0vR1w64gRiFE3mO96/bnY5RnJrFtFWsXRJhaEISqYEymES5h730g1r9pBw6rRxCvEt1WMl7lH2seRfPX2n3t+WmsdWtXPe2Vs3qQo/Om+neMNn9tU1XX3Ouw44NBCWedi8Vox4r3HhnnjV09Org/UeZT29fPqlW52nlfPiOfLT/i+tueM9dn9fGJuPcTXuFXP2cZGGQIxJUKXNKrreKh1c4bHcWAYJkcCBNf+W89J5IzQMPN5y/rF8V/Xc+uK1Lhk2vY107FbWKOJy884DL6yIjiaSEcA9rHar5yTn90kN/rN2eZd8d44DdF/NCKdTfN6rn69QPLH7PJ5AdfQVrQn6c/P4jYAOI+BZ82cobvi8NqAz0ayPrywLRr+6/xfH4Rg0tFoPga3dca+hFm42P7mt65veIV7rdzLxWHA56+9mVeZnyTBt5/1+nRIbTNKrai2rqn5stZadQjv6iusup3b8dLXbm9v0d676BrQsn20NYf5+nRUuy/XCd9q3RJQrbV+n3y9r9VJAgWuYOreUtPObUKdDBBxhM+KOvDk+wWL/UW1tHUis+sLvX5WWLW8nZDQ2yfch1nTF509n5Ww0M9xq/rSq7sdJVJbdcRWa1u70EvZL4HmjR2PR2JKjIAG9X6Xblp7w7eARSfe+ynmTkDo0IveM2OGbDfZXPAaCO15KGvtFcSr7fZqoy+cLix7Oz2IrQ+ME/J8LfurAaX369y+/vxxwtyPotr5s/kLZEMvbQbk2gPhi92WBscq5AZFQSZ1jeThmcBfcAHl2BzvtdK8NYG5O19LQU4ZyZV2yuRjYTlVWjnDu3LtUDr1ySkJZFV0J8QGw9Icz2swDEpMDquU2TxV+l/EZnyBdTcK70GJBlp5nE8cfnBygf0YmMa7PuFnWll4ePjEv/31PX95/8inw8Jc3Jl/VoVIumZgimdIzQ3ENOr6I9zFxJu4I2okVsGWiolDaRBfXMrWJ7m6AZ7drCWdXeHk93gxQ6ovfJ0aATt3sHjFtVetq4pDjD7TlLSSEdTmQWYNgmoDPYJVh7Sll6eMf3JJmxE67CcvwkMnvTCrDMFIAa9ojs7aVzoNdM6VZXY5Bgn0fhZ3MmMYUAlYbpQ5Y7WRunbfbrfnzTffkoaRb371G/b/9Aefi08H2nJExJh291hpCCd26QS5EDFqEbJUTscjD58eiTEwhEjaDYShMTWncZ8p3N3vuSvGnBfyQbFakFAIQ3+2QqCql2GCGIPi1yEtjAJzPAckzpTri/772e97EEiyECkMu8hvfjW++L0ZkjML/v0+eU8EiDCmcXM0HcJ42TfkDslyOqCqLu/U0S6lupPi0i/GQfz3ybwVoJrLXQwiiCbM7rxyFpauGYtXM9XhbkpCCKgaY7Qn7KJCoLSI4PcnsOAst4FmijUBSzeBw/PmVRmH3BuQ0iuzznJ25lUDd9OeX719RzLh47BzaLEmhmFgN43c3e345t1bxmnH6fjAODpxUykVcPjwbrfjzZs31Fo5HA4secFFGs8s8M2cUOm4VB4eXG/VZA2TBLO6poZR8UlJxPkL/Do7dB7ENcdl9iplOIvcu26g64p74q6hIRHjgGhgmPYMd28IMRKnkZCccTfGSAzJf1Ik9t7Vn9uG6XJO9fGVNPfrN9G4HsfVGkvLXyDXEYomTPYIwmKKFkWtkdpMaBUNQkjhJsATkAnTO4fO9qakrylSAGhe0JoxYA6NEhz+nGNGtKLVCIszUft4/zzyQkSIIT4ZU6re19yg48B8jculcCoLtQnT8vKaz58+PXiFsSfGrBkxhJ68rCzLidYap/lEztllS1q9qGp6pT5n17U3a65b2yHg83xyRFNwAkBRo7VMKUesGSEGYvc1cs49qNYetFWvsObMMi+uuxniFmTOS94KT4IneU6nE8u89ISQuqO0QfmNUqXD/oXTyRl9zWBZThwPCQRHMPQAtNXiaJtcnNiwOfN/Kdm1jDsXhMcgraMS7EJP/mXsl0Dzxk6nE0Nr/rDimTZ69UCbEbPLXZQ1ufRTTNzBsi3YUse5S6aTjHdWQie+uHU4DQ808w3MSawRWkPX5mLqF+cg77X8ugXUzIPE5SfGPKvO1NU2cEfj57Tc47dLKwbHHjMigoyuU6XplmIYwCAZNjqtpK3BQJWeYVAkg8wVKZl2KuRjpcyVVtaF/XwMtWedSyewkVEI5q2hWgwTiEmJO6U2Q0v7LxdoJliXSiQYOjpr7nE+cXpYSCkypHeEYY/VTJkfaWXhcHjk37//yJ++f6S0nkSg913e7EcQp+iOzzTddgsCY/BAcx8Sb8Lkmc4GlEbrfS/ec2e9D9gD4dib9FsrtOILhQwBom5V9OeUEdY7mfBey7V0YgT3J8rTSLPVVQKl0aLQTHuB7YTU7NCgW8z3S1uvCkqfA3N1rVoVI6k5pDea92imQC2NZXGpl7w08tL7xwJIcB3EMEZCGAgitGLUuWzXhiDcjxPfvX3HsNvx9rtfs/vVbxEV6se/Uh99jpumu97ILIxRaKEQxGhFKAROp5nHh0d3At7cM+wmtBljM4YonKyyv9uxz87sKCeDGnpSsIM0NdA0bTn6SGezjc6e+xhlC35cHsOz0x+WxqkpijG0SmyNOxv5bnp5p/nl8gznCXBMA2N6fvyICNYqeTk+ee9Sdu8SeHVZ6znHkREseDXNEtXW7vT1aBSVCZUBlcoQFoJcDiyhtEBuqQdGC9qJjWobLnQ9nYboR89eIEUh/TwUphf79f7r/TTx3Zu3SDVimqji/bApDUxj4m4/8fbdG3a7PR8//sAwJGotLMuq26dMu4k3b9+Qcyav0j8K0tWlXfs2Ug1OS+XD4UBrbdMI/PwxNuehECGqUIIntEs1qjVnpZ0GUpc1WR11s4ZVl7uRHkBqSKRxR9rfEUIkjAOaAtq1CEOIHoCGsAWaP3dhM43Xg8r/8vajYkqxznTaLZvLz7QvwFeLJgrn7Up1ArJdaaSaCckJl+Qmm2IyYbLv8ryFzZO6SaJ/9kUztGbifKJKow2VZWVk7SKdwRpDbWg16NJgnwPdC7g8zTPB6Dr+t1XZnMGalp09f3l5L/Dh8dAPzI94SAPTMIBI73d0Run5dGRe5t7HDK253IlLiAg5F+Z5prXaYbhO6Dd3TgAsUGtDg1Fy5nQ8uF52cKmTjZTQT9tlVHoF0YkMF1JKOKrG22SWi+shHWUxn2aWZenjKKFhrXReyNH0eH1ZZmpxmbNlmTke41WiovWAsq4s6a12rW+vaAZbiQXLFmh6gOqa5y9pvwSaN7aKoq7QOw/yfLFs5hla14qCS1jZGYrTl9XeE+H5ijO8ZIVnXaInzygeO8PCbF2ezzAlsWt4xi1Bz2vMx9eVyx/bw8+7IqzX7bnpfQNw3BzSmh8wuCLCdXiYbF9Y4UbWMzxc3d8OeWjWhcvNxbRrZwisK4HMef9mPrmsUgiyHuTl8V4ctKj0oELogq0XX/rPF4AOKRLNnPJeQLRtZyKciW3WbFqrjSW7JEnOrWsX2mfR6mZniMo22jYI7vr/AEKMEIMQQ3dkdGVJvRjHxgZeUqxDwvpi4vgUzvfEn4ln4UZX9/hcObfL1zCH3V4Ds547y+3zZwj3y1detsew78/HzDW0XvAsdgzuKG/Mj9vz/hTzsNaDo7iWovdOe3V5lXcRFcZpZBgHUho6u59tg/w8ThTUe8fiMJJqdU1B9WMN1tDmP9La1nwmKhCVmAK7aeB+50QwIcxIdbbpLSEo4MKajkhB1Mf7bFRnFeuaZJG6OPvluTJ0PvtNz+yF79OlrRCxz9l2e9b57cIpeu795z5z+doXoY12CdG7/u55W9LhnmDtM6RWFwyNPjpuruAKs4Se/V8ZJi/G/fbPl22bk9fx/cp2de0EYowMw0RKp7NkkbickGvrJWdoDWfBdllhzf1eyIoYqG17z0W+z/e89T7iK0jfM8f13L3dXtn8kLMzs66VCDQ6THDd9zql9sqMs2kX981rwJo79SEoKXmQecni6dDgs1/02ev4QvZ0m+vMpVxBWrspHoC7+9Y9Pts8hadOCGe/6tIfrKY0UyrBg0IxNi3y1Se4CURVBLWA9t7yFb5/nr8bautrjqKTNR3UHQ5Zewe2f6/Pm76tSwg0cHEtzmub9GsRe5tKMPUefZFXgc5ej3NfG5t5YrRt89c6K8v53w3ldOnbsX3+vKbTfYNeMd2g6LBCTltriPn92dqfrLn+bYfTrv7H6jtezand57GLY+7vcNlmdTke6M+VbM+dj2nV6zlQRDsp2zmZ5H5O8zag7rcI0jsa5DyWX9B+CTRv7O7NG8/YdNr0gjCXhlrzXhKqT3rqTJei4cK5arRWtslUe4Nvu5hoV7KItX+pv+GZBdiCFQNMnK0PgFb9GC7Mqwyvz473t9izCbdXsIJLhVwF4MAgTp5yaQqM/fWcjcPJe8miJuJ97LpFPZtnUJfmQaOB1XUiNgoZRJxR7FDIS+HwOHN8OHCaM/NxIZ8c3hCSZymbueyJ4s7wED5/fUS8yhoRqKuj3Jc6Be/5+McnALq03/7qnWdssjv9lUKxgpoxBiEOHmzUXHj8dCTnwsPDzDIvvP+YKV+o7pp5lnE5HmEYaHuv8rl8QNz6MjybKYxRmaJDhMbdRBz99XUR98XSBZuD0KFlYK4u99NOWMQz1DdORhMh94xy2z7q/X8SDGmNIk/PNQBDb5MLF/NNnp9Wlv5e82sjJAylEcUYbkjKVOFuikyDcreLhJ/IqKoKb0fh2zthisKv98rdoMRxZHr7jpAGhvtvmL75FSENaIycHp1sQRdnBTRRCAMWjbiPvPtt4q4UZPmEnv6CtMzOCnfLjLbq4tri2pISFBkm7kLgv5fGH76741+/f+RTrpTHmbII+eTZ4xgMibMTwu0mwrhnORz48Je/cPzhQC7Cd2/23O3hh4cj5fvKUtiCbhFhHIT7KOynwO6V0JitQSl26y9tJuI6ardFq9a8KmXW5Wme8QZKeZrd1v7Zz/r48lxlxR2kUrx/aa0gglfJW751cg2zTKWT+dRIvZFHcB05d8KVyCp1EFW/yLb77CFjCKWv8T/vvKqi7O/e8O2vf0vTxDg5aUqMkfv7t7z75lfcv3nHbhwZU2JIA2mYSKURU+4SIYGUEmkYMRSNA8SOcMp+LWptnE6ZnDPznLscSqWuAboKKaUn1U2XZFvlHy4CLD33UrZayVsSovTkjBJTQoN7KbksSCvI4aMjeEIk1ntCm0gKd/uJb759x9u3d1796ezDqzzG5mBz3cP/2qYS0ZUhucQnj0cU4W0KiHgf/1Jj1yfPzC1fVfQ/Z8WUU40083WnhgEUJ3DsQZyOAbmBEktR7GjUMlAss7QZw0hWGC1Dc2i7t4wbcT4xWG9kEccYSQN5ZlkTYoevg8aChusJLLiqOMoKrQ8dRg0p9mRk9LEoGjY915e0GAfXd+49DM2cKfbykjtqINKCP3MpDgyxy5C16pqb5preIuceXRHZKqCXrQPSz0c6Z0ftElnDODCOYyeKzDw8fOwBZCP0/a2+vYr7H15d9XHZrFGqgcQtqG2tOpt917Fu5qzgZhBDI6UBekBcyuJzYkzE0OVXBCxFao1o0N4rqr1nsxJDIHW/aJVpqbVxOL6sX/FLoHlj03TJjNVL3M17KWOrJKmI+MIsK2PmNvkaq6AxrSFW+gN/nhSbXTTfb8WTnunrD5brCwpNjNq1f4JZZ379B7fuY/w8S4AXKrJdoxUFr5rdosoEtuDTzLDFmV9tL6hGQgyd9KJvu9oTHLBh3fkxcivMcyPPleWUWU4nlqVQ5kLNrnumcSUUWglC/LjSj/RVaVAiRusZNV9c16qJH+J/pkDz3Zs9LRvl5BXfpWRamWkYUdic3FYac1mYl8KnT5nTXHg8lieSJpdm5syKWWbPJvZsnC8UnjSKMTAMnkgYY2DsosZpHNDhvHivGT3lAk7df5fOovxTbIWzPXeTb+MNwYNHEe/FfM6cjKZXg7cTb6+zeHcpmIhXB6M4RPbqM0GYBmU3RqYUt4X+x0yBfRLeTR5ovpmUuyQMdwP3370lTnt095Zwdw9hoAQlz07hnlrpC5ZgGiE0VBO7ocOHHxTK90huTK0yFk9kyJxpmpHoQaaMkSkIv7V7bCkUg+nfP/FQvB+3tAhWaSyIZjQacRcIdztKLSxL4/HjgsXEm92e+xCorfH9x7AROYDf+iEp0yjsBmV4pfHaDMrz0njbcWh4WlE1ozNfA9EIJlePq1nXxLt5YAP+2c/bc9VJR5CUarTmzmgIPk7qihC6OX7rYLxmgeKg85vz8gDIj/ncy/I1XS1XVptHvD+ziQjjtOP+7TeclkLssGXVwDjt2d+9YTftuwMZzr2McSCEuDmIIUZiSo6aiQk0O7GEnAPNJRdfo9Zqy8Xz6gm58EygiZNe3cxla2UIelVmQ1f475AScRhY5WpqK9AEnY+IKC1GclJKEGwamcbE/f2O3W7aEv3PS80Y8DSJ91omGgg6YDjb6G2uMQjsordV5ObBWW2KNWMh/6S0RTXh2CJ1fcafeYAlKrdSlJIFW4zQyVsyLnUSrDG2DNZYzLtHxQxdCrGugaY+kbu7NJd3GxAxYjA0XqNUEoGJgWChqzN4wBLVP389oLVLeLyshd7zGDuce16Ws7zJBgkXRIIjXkLsSKYV+turd+a+VdsIA6VvP2zVwbNeq3jGVwx6ccnPUBhi8iJEzpQ6b1VKDU6oVlfEVYAovu3a3Jf0nkrbUArbsfU+eSdawwkKMec6iGdCp9bhtUOXNkFwRQU8YSHg8NgeHAPbtVBR0pCIKVBK9f7uF7RfAs1bu1itbYWGNEGsbdpGIvYESvZkMzfbXEvtPjnTy+uux6kdBuYl9kvn1M4wh77Fl5haVyTa7QS4cQo+qQQ6e6Bt9Rz3CpSzf7C9/rkDfKWYaHPSrzJY/rvgr6/HCb4EGlwRK6kKKXpm5yyqfs7KnyEN6/PgZ1vywpxnx/fnzHIB8+xf7BPHNSddVcg4JNEuAiirhmU7C2h3KIpDcxxidj62/1zm0J6GBesTtGcHxPqc7erPGzSltcYpZx5PC0txmaE0JKgOU/bL0zXdjM4+qq49WTI1ZwSj9UZ9kejC6KqMKTF1DceYIhq71tsGBDqbcYazOBTTCS8uP7lJ31ofHyL93rezM6TnZ2nDTV3sBTrEUhyKigaCFEL/8IoitLXC+gw09aUsWA8mOlQqKJsuqUZFQtfOnFxK5JLEwqvugjsWoF08b0jKbgqMKRCT9oVXvGekQWmVbA2s9mfF70aTgGjscCBYRebjFEi66gh2QrXlkSoTSCPJSjt1eZkN2gKt9HHn4zgG5W6InIaE5kwNPi8HE6R6QnHQgXGYsLSAqAuSC0gSNAbCGBjHtN17cDr6u7vI27vINEbkFYibmqejnNXxM5FmR5T1aev8meeIrc/i5OefW7NntrXuZ4PUemkAoFc8BKN5tesJQE+QriC8fvV6uyu5TLiaf6Wfg7NOPreifYWZzyXbOH6FoXV5f66hs0KKkf00MY3j5gR7tcTJRFp1NvzYKyExOlnOmuhWlY7aCNRau27wKlty0Y6zkQO5RFeTtdUH6EieMzx6TXAGNA6oKGb1CVx/he2t/tKG/RFBl4yGtkEbRQRZfAy1mihl7/OrCMM4cLffM47jFmTW5nrTnvw7s3o7HN26z/TC92m9Lc+8J1Rvpbh6rWFW/Nqa+0XeavHlJKAhNIlUaVQJm0fpqCe/ZrWz1X6uZ/I6lHOyQePcO/7kW6JszZnIRqi37iGiRFME7c+a9ERDJPSLv8JkowQGCQRxvco10AxqhC5nZ9vzpDyBVLyArUzba1URnNBorX6vPYcivS2uB3ZS6nmuYp3nVjbfc8LNpX68Cihr7nmd3rRLHG7uXte0Fbl6Qrakc99Prb69ZuYKF3YuNK3bXZcR33e/Q6rQmWxrX/O8tUQ2tlofoxc+pZ3h1Gv7h3VSoO36NDBdWXVXRv2XvU+/BJo31up5cjDc+dfWMxdWyFZRc2KgnzZsbMtUmPnaG2PYAgzpSsZmfitiTNukola3PsznuWj/xnMElmc0MGOHlV5OTmsVMIovvou5WLvi8NQgUDpZ0BeP8JWSj1FgJ09hY9mEg13DZSsOsy1AWZ0J8f7B+7sd035gHNbrfz7gtXpZmxMDyeKQlMeHIx8ePjLPhQ8Pj3x8yORcHf5An1Ry28iBVisCWfrEbjD0yb4tqxyC0KI7aiowqnTBYGM2e0K29J/BYj55AD2ubk7DetIshkYKfj9yUWoTcml8//HIDx8PPCyZYTdxHxOnpWCn3PsiGtIKmJAXKLVSW+P48AkthTR1p21wBML9biSlyH7ccbfb+aQczpT80euYV1aai7s3M7RCzJ7VOPem+CQa8fPKnFELdJIbCYrEvtCUhtXriVyCoENEYiQaTKG68HIoLOpN+tqLLSLuDBLXhfzlH4ahNZcB6ZIZQ4ApggYhvR1J9yNBlV2MDCEyRSH0YF1VSINrl6nWrerx7m3i19+NDDFy/2Yg7QaUSm4zh6WQUoI8E1Mg1EpsICpEGYjDG58nzYmaBGG3VyaEUhvHOVNKI7fA4YcPtPqJIJW729qxVVp5QGTBaoS2AyK7FPn9mzvuQuIHMeR0pJRGaooeA7FG3qW3fPP2n/ghB/6fOHDE4ajTfSKMib1NfDvfsSydZrpVUhT++Q/3/O43OxAl68svtzMTqoWYFj7bRmEOf70tfn8ukKz1DKl97v3WIJebRKv0vuc1vk8BST1TLgNBInnJLMsDtV4fiLBm4K1v46ZyFhQZRiQGrDRYcpfm8BYId6YyzTJ/q4ckODQ99uGVXyHSXJ3G20qcinB/d8c//fo7Wi1Mo7Oa1to4HI58+vTALo0kEyaN7NLAbrfDBE6nIzFGUoxM48h+NxFEGJOyBDB1Z7KWLtPUMq1lh+ungDShE8OC+NxFd1hDbzuIaWKY3qIaKflAWR5vEvLr3Fs3Z9vM0OA6wCqXEjlCCic/5mFgnCaG/R2EwDfffsvvf/977vc7RJRcCkuFQ3aHP0kj4gFCCtaJgp5Cwv9e+5yr4tRtR5KU60Ci39vSnF88oKjAciFH8pw1UeY4sdiI9WoawKCVu1BQjEOLHGr80ad69dMGFdfztOdCUwGGc7S0IQCE0QJqQmqRwTyp4LDK3msZHQLt1zv0xIYwDZ2tWSJBkqfFu8wX5lMMCPgAACAASURBVLJmuXq1MMWX1xGO6jDQOTvpVAiBsetJnk4z8zIjoqQ0EGLCmrO9nqyT+0VPeNbWQEJHf6iT/pmRWyPniqh5ZTucg8zVVoLW2hpLJwi8LCBo31Yzb5vzxKj0Pms6D0jtgSMMff2stfk6lAQbFdVILpllyVdEREInBsoFU91QCmZGqe63qgZiGlFVjscDpTw6uZEGYhpcUUzYkAmXyJwXuU8vurX/Avak4XxlcLGGWaXSPCvwFQvaqlkFZxhKA9S0l73PvQ7aez57nuVFA8zteHBE6DVHrfW+lqdB2zqPy0XlUPFKomtCnat/t/tZi3OvYVt2k+vdr3Da3APNDS6LVzmXBs1W6hXPCg1DZBii06kLN1khOgNpc6xZyVAqeZk5LSefuJaFefGKph9bv4Pt+SelXkJQ1s92yl5T2bBuQu/JEygir/I8/BymrSBBemDHVgaUnnwJaqh5EA4+aR+XzKfjzGKGxsiggWKg2QMI7131oK26ICcqQlkWcs/yt1Zp5pnWIQWGFNmNA/tph6iQMUp/EgJKuMgdr2xvRTpFv/kiemnr8xfMq39lfbU1d4rtIusuYLU+pUM2hcF7pIIqpoGmvoi6OHrfZ/Okh/VM6mtBx4LZVtFUlU0OJqgwjoHh3iHIg0SSOIvuRlylOPrBDGtKiJ69HcfA3S46s/AY0OiLby19TLXC0iqt1a4TCmqCSkR0YO2/M+iC16P3yZTGHGYkV2z8QNY9VQpF5g1/sV1mDNqMlSO0BDYAkaTK/ZCQJizHyBhd+zFkQbKgITCFgftxx2mYQIOjJUSQQdExEKfINA0ErT1S8yrumzcT3353RzHhh9PL36tKQKRtWrDX5wsrmqaUvoxdVKuuK1dnc2jVl5MYtzJrvnad1wEJCtGrkEEHItHlMmWlYrus6J1ZLh0Gd7PtGJAh+kOoYNUrBmuA5FxPlcbfDnv1RKsHQmYuxfJzmYgwDIm73Z79NBE32GjbGCtrKSgQEVIITppT4gZ1XbU4h5RopXb4e09Q25n8x6tuTtqzVlku9aaNPu/JSmCiiEZCnNAQPUjlumLjTvSZXKj2QFO2Kst5OyKCaaFmObNimlc/p2ni/v6e3eCSE602ShXmulbfDTrRkErbfKYXnwevy5VXb4gUVE48eYbtjKhV8UBCiAjD021Cd160t0ZdfyBgjFJRMRZ7+v7z23MkSpQVCfIcas336b2ZZ1MTonmAvFY01ZRBlNSDy6DRK9sbvDoQYmMcGyE6zDZd9ElDn0fMyYi8wPIKFU1xX2oNjkLQrhgBMFNLRdWQQQgh0GgsS/YexeBQaOmcF5vckGhvwfGhUquhfR49k2XdoDdsJYhsV8/jSlaGiENeOxlXbUZtnWjwQs9UV+mgZls/u8d8/d7RGW1L3cb9Vn1dA8y+b4NtTDqL7Zno1PVBO6N918Nt1Vn2b7XgX8J+CTRvbBNc7RC3v/mCi2DSBalFED07nX1PnRBoDTRfqeT3Fdasw00/cyiXUKtGZ+OV24D1bHLz+z/CDK+4Ct7xsyaaREGTZ/7GXeBuH9ntI8NwppFoPQvVrG3faxitVqxWD4QeZ06nzGEu5No8EBK8N+wn3NO1Cnb7ya/NJz3Zl31NKuT17eOnmRqFnJSmghaYgiDheUSN9cXDs+QOvwsqRCkd9GPeI90hktZhIUGk92sKEgJ5PoE1ym7o/QlOyGMaQIVAw6HwDku71QeTKhtU1bT59+yckPLsZv8sbJqDDajxzMS4wv2ev7Eru7G4o7YuPCqkMaG936e1Hpy/spr8mzc7dBB0chbYGNThxUFp00gNCVSRmLxHrCcKfLYTTH0MSWuoFnd8WmBZ1qrKzHwsYA2tC1IrYVlIdkBGI+0Hhof3aBwZpsowLagGUvReW1/cAyLq+pXFF+35tJCbUi1xKgsfKS6/YkdidXhpGAsafQGu8xErC/W4EMqh94AuaOxB8yqWbUZZvA+75sqQIvv9RNyPxCkQdgpHoQajqmGVruOoPC7w4dAgBOLw8jqagdKJpJ5WTqysZGZ2Ib/gYPwVWmb4+KoNcnWnqLavh456Bt6RGqggc0NqpIjQpBAkuJZbm2lWfH/FE6y1nuGbtbFlm3zeNaQqgYrGgJUKuXSmRtsCkJ9M0vW54+/nvdZE2ws7Wl80EdKQ2N/t2O13DEPaesOWZeFwOHBaFqpAiwHpxD9DLQ6f7fNW6JD2EK/7F9vmyJ7nK38/AIoGr6SIKmkYCCFwf/+GP/zhj9zd37Pf3/HNu+8IMXF4/Mjjpw/kkvnw4T0fP30k50z98J55fkRDYLffb/DfjUlbHV6JdFkqEYZp4t27b/in737Fr775lrtpYuwl8cdj4SiVpQmn0oMmbVhovZ/9DHN86VsVasDEaBv8s9J67+65X/RLc7C/F8WYtFJZg4weKkukcd2/7wnx1mWj2pZET9LY6ZoKpR8DrqvZ14vQETDS2rPSWuejEiLBxUdk7fc3IoEhOKnPECPDikRIgSE5A51X36ITRnXIdojqvZvqgabIZZrWfaCYPJuswqtoouZSus71cw+BXa3ToQePsPb9+nkFlW2eXL9zdp4ugsB+zVpHFW2w4HXfsrLTXhdwrh7QPhbFQl83vU1jvW1B1wS5+bhqhdCuC1s9R0EMyjAMiEBeFlZG29Zb/MyMFe+ruvbR9jYEVbT10lJvP3Kt20RtFfmlR/P1zTO6T2mIf7p1Yuk10NS66eFQa89geNWm1rpVMv+jg00PxOSLJcgVyNswlv5ZH57/mGbAYg6l9XyomwQh7Bwqcfcm8utvB3b7kd3OWcYMyK1QeqCzDvTWjFMt1JL58Hji//vLI8fDwg+fFg59MRn1aXVhu0By8bechcxvEqdO/vQTQ3QVx+9fTW9b38w/hv3pzx+RGAhDRIJyPybe7pwxbjEP0K/mYzNKzSxlxiQSw0RAqZIZzPlftZM0nKFA/m9ZFg45U1olRGEYBvZjIpdKiI2KUoP340ZpRFqHB0UkXJdTWo2kHM4LSn/ea/HMfcdHg/k2hhBBAkWUGZxCvBmW2/b9WzMDq80dyVooLbvjEIXd/Z5VmL2UDk2zC02tV7Df/v4dJMF2gAo1DNQ4gigtKEsQUlDYjcQhkZqRciFVo6nSQnJWbqtY8TRULZHDY0Wk0ursMiHmmqjVwCK0P73HwoHhbmF6V9DY2TWHiRADb+/33O8nwLwy3BoSEmHce7Xl8ZFaI8bEh+XIaV4IVO4OJ/bBHZ1plxjGSC2V4+EHSnads3E5IaUyakFHc5hYEVh8zM/HmccPjyzHhd008d237+AuwDcJRkVOUGJlKZWahVIjEeWvD9BSY9pFfvuHty9+r0ZOTgYzxq0nEjoEqjqU36xR20K17MA+GRECRqXZ4r8rm/bk37rutQq5b0Pm7inLKoLQe+66U7jtzz2dbX+19OSOOWGYC6AHxtmDrw4vuarW+ld/6gHfVKIuLDejbInmrz//v9VUhP1+z7fffcPxdGR/t2ccEyJweDzw/ocPvHv7jkWEmgI6Duz3EyLwaRgJmgghMaTENEZaDRu0zzBaK07Eg0sArbA9F6s3hz4GCCGx278ljTv++Z//G//7//gf/PGPf+Sbt/f87jffMQyJv37/gX//yw8cjkf+j//r/+R//t//k8PjA4fTQn7/kSkOvPv2n9jf3XsvWJmxDt3TDh1f/Zzdfs8ff//P/Mv/+t/57ttv+O7dW/ZjYl4a33+YWXLrQb9fp2UUdmMPGPrZrf2CL2nDMlJDJafFA86uJAD8yLx7/WwNWonivl6uTsDUUE5xR5PrpFOUxn3MW7Cp/QxHrSRp14FmFcocqFk9URQzFgslV+YvJIlUYJDo2pHiLSvehx/RMCISGEJgSg5lT0Ps7L+C6YCJP1djCo5iCUJMnoy8lA65vBoaoctavkrB4TifnqIQOSeLqtUN6RRVMa0I3mcsBFJnbK7V+QF8nV9rwb3a2ApoJIgHd94P6Ym1a4m8zkZ76fuZ0ahbkcl7nBvQOupAKda6/iik5DwGpTaOpyO1LtQgm3Pk0F5HDQ1jYn+3R0SY51NPKBmlta19y4NpQYPfy7BxkQRsTaS0igmEGBl3O0opnOaXhd/8Emg+Z3az2D47cJ/DwF9jLjZlPLEN/uY46G0nNxDNc8j2cyZUz8f7I8v11Tz6FcIqn1/bfxZbj/PymooIEh2qEAdlGJVh0AuZhnN26PKaeKWtUapj909z4TgX13xcdR77+X6W/AG26/HcNX9GMe7JV6+2JmdtKG5e/w94kJ6101IIzUgIIRiSoiPhVKhVuFQvsW389Wxi74mUDrFbF2HXrHp6pVqtWK9s1pypKp3Ou1eooZe0dYOAO723Z/vOx2FbZY6bcbpWvHwhWpMzK0RMaVhfgNXJMz4TZF5tc12M+n8OpY09uHUSAzokzX50sP7tNk4DNoBNYAEIAy2M2MUc0UQheF+pVEOyzwhKoEncsrsiTjjRmvriZ0ZeXFqhmnjPdBN37JYFU2PIiakdCCkTUyaNCzEEh0G3imC0vGC1onFgvMP7b5bcs2XiMONqBBpDq+5IhIDFgKlgxahLpuRMKxlps2tvYmig66Kdr0mrjbIUWnGB+2EYsKS0/kMUmuJM4TiBB02YCxwXQxLIK/Roak+SbOn2CzM6sryjMhyPIZwfnLWiWV9kmviabdj2z3NvuJOYq1crtHkVyy7wul+blL12RJ8/0PWYfvaErzhRyTAMpGG4IvkppbAsC6XUXtXz+WVl0l4/d0kItJKJ+Emtfsa5ornC3AVnzvReLyHGxDDuGKc73rx5x+9+/wf+27/8L3z77p4//u47hpS4f/OBtHvL4+OBf/vzn7n7059ouMyEV74i47hjt7+jlUxdxJ168UDz8tqOw8R+t+fN3T13e2fVXYPIeamclsv77YmiEp1E0cXlVxj2C98OC50bYx0rK4lSv6Q8585cvtrXJxxG669UrBUEPcvUXVTCVIwojXSjM7Ju47Jlw/UPFWkOcTbtRHtqzwZ0sv32SnLs+0sdiULXX0X8mYr9GYrB2yIQ9TlTgmsnx7Vdokt0fKZJ9ucYRSt76rNj9saB36CufaD7WHA0gGyfu1lY7fyaT7MXfv+TCU+2H+nJb8M1Nm1LFfRtrfuXiwJo334Iuvkeqw9kF8/K+p0VLu+IyXNiyXNxjqjrZ96DYPeXZJ0zthhmPb+uw2vt87DGv9F+CTR/zPr8IfSsyApRQQj0il6rmFw+EF1eujvMl6GK47PXhuA1qDRqyf3pcSfpC6zTL3BKZ4fxucdpff3J+32MPieT9kV7tRnn+QMROmylB8PFVvY9aNn7Zcdp4O7NjjhE9m/ukHFw8aeVXnPDghXoWaJmjeW4cHh/ZJkz7z/M/OVT5nAsHJe2XdPS07Ai3o/7UrfSzwtQrwZYnwyi+GFDZ0l7of29pA27iRj/f+rePMyS6zzv+52lqu7WMz07gMEyBLFwBQgSkiiKEheJlkiLEumIkmlJ1EJZsWzHSyLbj+3Ey/M4jhVHjpw4UeJYiy3LdiRroSWaJi2aFE2TEklwAUEBXAASxDYYYLbuvktVnXO+/PGdqnu7p2cwA/RQyofnYrpv31vbqTrnW97vfXMwb5Wps00eI1neQBwiidC0NHUgNg3eGgalp4kwX8wJydA0NR0zbUyRmMlhOo031bhSOFWKkcWiJoTAcDhltrWZyTZGuUJtsN7jfDcR66Ip+mUgJyS6Sko2HYKoPJkJYp7QO3iOcQp1KZ0nmYQYi2SKf/X8d4xQ3oexjuQ0aEqKZcvHA04aaHThiZK0qsklkVLP2tphhXiQTOwSxBGyzmGMGrSVzrHfZYiXqAOcOshw0IAmBtVKBWVZbkRJDuo20iwCSWCRcj81kalEgnH4rSn+/PkMwxszHE9wzrG1WTGsSlJK1Is5oWmx3lNUI5zzFCQGRnlYDw8arhlVlK5kWBoGpS7gxXiIq0qkDTquTUOqG6IYAhFfCvsSNFFYNIbaJ6K1LNoGplvUzQIxSfVxS4cpKigcW67ul+2YhKZRSPbmVHvQFm1ibWtzz8cqBM3Am9ReUNEMTZsrlhpkgt4/baoRaTAmYTpNV9F16XIcd2NsJifriK8y4+gVmM3buNi+RegljQQhRIX+rn7vSqxLEF68FUarCxcgUb4GZtD+8dGgZDQoKAslHYHEoq7Zms5Y1HXfg+W9ZzAYYjBUVZVlCTzWeYzxGJurVtZlzgezY38aLFSVxznPkWuOcejQIapqwKEj12iQec0xTtx4nGNHDjAeVpSlSqsMRgP2HdhHNRxw2223MB5VzKZTjh8+zKmTJ3G+YLy2RlFWtG1DPZ9m1JbtE09VqaR7w+GQ62+8gaPHjlINKuYhcur8FnWT2Jq3tFkiLCNuca2lsBZxltZpkKMayntbfZHKagXLoRVNiUiexy7u+pgdP6ufEUOWrYt9uhufYbjJWKIpSFhEVEMzbtu4YHXm3L4nK9hC55ckQgwFiAYInkg0uV0jt25UPlFIwogSdtmkydXCJYXdW4/zVdZg9FSlaql67/BFThrS9WgafGUU8WGXEl5WtNcTMSQrpF20oK+GpRi3yQyaHGkbAZulgJxdVvg1/strq7EK97XahnEp00piZnVOKbMea9JDMomQMeS1XZOsNuPUdem3tEZomnwcVgn0vPdKcGe69z3WV1iCPr8ZFt8H0iJ9XzqSA0djcfmZN5hMDlaoLmdoc5+my4z2TkmeCkVMOK/j2vXOSwqKQNjjcboqgaYx5hDwXcC3Ai8Hbsr7egr4BPDPReQ3LvLdHwZ+4TJ28wYR+Z09OeBL2UoFz1lLkRtqC2spRGsrbWq7ZXz5PUnY3P9ispRGR8Ufusmny96mrMUjos5aefWzqt2EOZ/NePDz9/PIlx/k1BOPs3H+HJISw9GYY9cd50V33sUtL3xx/yWzUk773Kc/yfve9WvPuK8/8YM/wo0333IVzuLi16gwUBjty5ynzIqbhFgnUpsYDTwHDqwznAxYWx9jhxVSeOgqWiKYNmIWDVESTdvSpshi2rDx9Bb1PHD69IzHzzVM64BHcu8gtCJ9r+YgM8fuhQlCjEmZ0FZIhlJShtAiT7i7QWeupNf4atx7w8kY74SqTLn44mlSr9Sox5gC7WLOfDol1A2lN4yGnjQLzOcz6iYuYTKiPZwhB5reWlxePJzxuRoQSdOZOjdFyebZc7SLmvFoTcm5vMEWyhran7PRCmZqBUQ16OxOJXuRXmMyJZBgUOlbDWbmizmf+Mxn+dwDX+Srjz3GmTNnSSkxmYy58fh1fMPL7uBlL3rBcnvWamXQOT5yz6f4pV955mfqT73p27np+mtprsI0UU+GfXJWRIlk2lb7Rpo60DQtlXcEX2nG3hpS4YkWUhBiHXWek0CbAhihFtfL+UzrSD1tCCIsJBFEmEXDmXqTOoKWI5VEZG3/QfYfONQzHXZVns3NTebzOmfe1TGajEccOrifQVngjw543v4ho9IxmRSMJiXWWdy4wg4KUtNCUXDuqbO8954v8ZF7HuILX32KJ89MiSmxNh5w/Og6LzpxjNtPXMO0XlBHUVizifjKcv9DT/Pen7//Ga/ntdddw6Ej+6kO7T3rYtMKtBHqneklIaYFURpWs/RJIk2oCSnhre011zrGxMuZJpyzWJMJWyTRhHDFPY2dALm56L6X85t01c15w8apx9l8+im2zp1mMZ0ikiirAWsHD3PtiVs4cv1Nu+7v8Ye+yBc+8ZFnPK47X/PHOHTN8Ss6l+dqxkBVeNZGFZNhxaBUtk9Q1llSYjqb52BcA83RaIT3nuFwqJXQwisDpS2wtsC6HHja3VlPvXcMh5ZqMOSWW2/jltteyGQy4aYTJzh8+DBrkxE3XneUyXioldK8nfFkjJQDYkocOrjGHS+8lcW85uGvPsZTT50hxEhdLzh//hyf/uQneOCB+3ji8Ue3+RU33HiCV3/La7jjrru49rrjHDx8hCSw1QbOnj7Pe//db/KP//7fesbr9i/+9b/lG1/1Tcw2t/Z0PGSovavOFFqJijUhqjDalUy3MSTaWhmSe+IthCLWFLEhWs/cG5IpSXiCVBlCQv9ZZ6Z4drApG/BVREpIwSKxJEWLlYgnKsrBKXEWook3Z1JP5KiJWaG04IzQNC0PPfgQDz/yKCdPPc358xu6Xo3HXH/Dcb7u7rt4+UtfqkR5FhiQIwfDRz/yCX7pF3/1Ga/FX/jLP8YLX3TrFVy9y7PQhixRpgzJNqOeBME7T1lWGfnUXdcOaZMTMs5rNdd23tvu85hqcnt8WRAl4bzJflbHLKzBY0qxX6ecM32F0llhYYT5XO8ga60+s4VX/dmcSzCuwBZDLC3WFX2g2VmXA0+5r12DaIt3Hu8Uo1z4kqIoiFEJK9u2ochw6E6HVzXFVT++69nUIFZlevbaB7xaFc2TO7a9QDlPjufXdxtj3gN8j4jMLrKNhAamF7N6Lw70cs2gN5IyUtkM5cvsa7Izn7sMLPv3+2CT/m9Lk34yMhnad7n9eRez3TJvO8EdBvinP/0/baMyVkpzx9bmBluf3+DBz9/PiVtu4zu/9+0UWUh6pxljGI7GFz0W5/zXBEaxPJ6V85QVQIPkN0Sr00XhKUqP8/lBy7CdXnMspf6VYtRqTqsw2aYJNG2iCYk2JJWJynAJ2F4VvsCeqSIsu/7I47PdG7Q12SG0KeJM2gb//KNiCkvVLGynKxoTLGGxOkr9dRcVXC68z70kOmkLKyzH0j1HyvInPcxJclFae62NoYegOee0VybDMIWih5J0pgRe2wPu3QL1nlFuh/2Fv/63e6cQ0J4I5zh3foNz5ze49w8e4MW33cKP/6nvpSyLDH1ZZvy7ba+Nx/190jsrosdXZBIQY/a+fp1WMyOmg+NInxzLak8arOcYRgDJ82ESnc8U0KVEAx2xSyf9EvPPsXvFRBuEJijTr8QWDBTVkGFdY1fIbto2sLk1Yz6fqwPgfIY0CePxQDP9qeznaut87r/VgF4hv4ItPK/5of+NEJfXsPQO5yxnN2ac3Zhx35ce55brj/B93/FKnPOIpEyEsRS2NwYGg4IQU75/t6OqJBlCjDQ79UX2wFbvs+0muWdnF83DHo7VhXNmOcaXsc8+2WNMj9i51Dd3XYtW9tXPt5faJ/Dp9/7mtufQZsbVej6jfuyrPP3YVzl4zXFe8qrX4XYmh3oz+Gp3UiZd490VJeX2yjo2T+dUY7ZzVmOMtG1QiGC/dnWf7RhnMyKjmz86ZEeH8ujmspWXwmw1aK2qAePxmNF4wmQyZrI2ZjQcUBYe71YqRRhN1niDFaEwQ0zpqYqKAwfmxGRp25bpdIu/9Od/lLQCdfa+wDr1K+7/3L3c/7l7+djvfYS/91P/K857JCVCI9TduQLGWvbvP9DfPIZlcbaTrIgx7bm4vKxm09G6InQKAXLBDb2TCV7y/zq1gW0tNP3nlcDKduOkYSVK0LS6pZ3kMstkvwFFvxnVvTSIJv6MkueZ/F1rBW9X4aEd07tWNv/Pn/u5bT6gz+vV+Y0Nzn9ug8997n4+9sLb+Ykf+kHKYQluGQ+vrlf71iYre9h+TYrSX1WU3mo1U9/Q92xGKWz7+8r93H24d90k/57ntlVcq8lVTGNXtrd6DCwh633XqtFCg+1gq8sb+II1H7P6HC+fu9XXMrZY3QfbPtPNJWQ/pvOJuu92MPuOtVYrp/naPEOLz7O1qxVoeuBjwC8C7xWRhwCMMSeA/x54J/BG4P8GfvAi23hERE5cpeO7pHWVidULbo1QVaVSb1uHLSqS87rAJmVQFBQ/r1kHQ0y2d3Y7WuPdmslFFArZMd36PRjo3RzgneAO0GrqNcev50V3vpybbrmV9QMHATh/7iwf+9AHuO9T9/CVL32B3/ntd/HGt75t132t7dvPO//SX3nuB30VzLDU+4weqCzRQzGyDCaG0dhQVh3sQYhtS9s0SvrT1LShJYTIfFbTNi2bWw1Pn5szm7Wcm9a0MSqZT0LZFlEo6yXn1GeIukVUf1OS9K/OvDGUTiejkJcsj5Js1NmBl5QoCodgl07c6mL3hwAPq3xJDDXTeYMkJceyVp32alhRVlXuP9JjK7zn4Po6Y4H1eWD/SIlNNudTzm1t0MbIogEypFNECBLBJGJQGnqDMhwaDNPplKdOPU1ZlfhywHA0YjAY4O0hhsNnYgPN1aCohDxI3329/VM5YIop8bwbb+CVr7iLF912C0cOHwbrePrMGf79+36Hj3z8Hj73hS/xy+96Nz/yJ9+WgyGnTlwOXg6s7+cf/M2/hi20R3O2ucl0Y5OUg5mUAwnSs5d0uLQlVPhFVBIIzZX5SsmVSmexpRBsg8ESW0foJAtSIEmilUAjLWLAtF3EDNEkTGkV3hStKt3ECKLEIW0bMkQaqsGCejFTFs4MJ26ahq3NTTY3t7DWKUuntQwKgw1DihSxqdwe7ekAIU1AYsIgDKqKEBN33H6cN37DC3nFrdczHg14enPOE0+d59c/+Gk+9rmv8KVHn+LdH76Xd7zldQiJKiozX3VyCsDa/hHf8/2v5JEvP85iVjPbSMzOaSDnfB5XD7P53geai/bi1RyRoEQUKwuZ5AAfch9kiAQTr4g4rO+fTGZbC4izy/s3xiwHxe7TXVcJNUaD5d32vTNAFRHG6wc5etPzOXDNtQzGa3oNpls8+sB9nHr4Qc6cfIz7P/5hbv26b9q2rS4gL4dD7njDm3c9r+7463C1nqndTZMllqp0DKqC4XjEcN8aJGERWuq2ZT6bQ9PiQ6QwhkGlRGplUSrzc67MOOd0DFYcZGuU8dVmeJ2ISj2UOKrBAEOkWUyxRE494ZlvnWff2oSCwNramEFVMR6Psc5ionrjIkLbBNqFVvuq4YCDhw8QQmA8HpBi5JZbb+fVr/lWXnLHyzh67BoAnn7qSX7rN36VD7z/fXzmHnKSVAAAIABJREFUU/fw0z/1P/KTf/sfkCSxaCMhRUKWrzp8+Cg/+89/E1OobMaotIwKZdYdjccMRgPmsymPPPLono9JEkObHCLKCprE63zStkjIOqRlwrgc/IeISYqgCrlY0M3VO80VeU4wBWIrvBlk7U19dpxJeKuwdmsMqhi8+9MZk6J5Upc4SAGxQjDgjAYbpTMUQQNN14XNTsl+rFPm2huOX8fXvfxOXvSC27j2mmMYYzhz9hzv+Y//if/yex/nD+7/PP/q13+TH//R78e4CJlIpsiOzqGD6/zMT/1N7ce3QjSy7eHVsHrv5z/nFf7dtb10EFiFkDowmnAsywLvVY90V3i8MRjT9Tu6zJJscTlJqYnFDpYecdbm9pbMNJv3553vg8t+05nh3tqUtyd4X+C9IhHaNvZEWSuZFH2e87594SnKgjaEleBelMTL6ss6hcZOJiPW19epm5q6WdA09Y5T1XO1FqrBkOFglAPrXEyJz5YE9eJ2tQLN14vIB3a+KSJfAX7MGBOA/xr4AWPM3xCRR67ScTwrM0Z761bNWUtVFQyHBowj2FLx9aJkCrmwqb1zouQXMab8s1bEtlEhr1gSQ0g6adh0VRIKFy2ifc873skNz7u5/0xn+9cP8Ibv+hMYa/nsPR/ngXs/zatf/wbW9q9fhaO7eqaBpv7cOogDTSCUI8twbBhNDGW1zETFtiU1LUkSddsq82EbWUxrmkXD1qYGmpuzlnOzljaoTlGwSjfeJYaeK1w2hUTaMS8fHRQIKivT5koS6MQ5KDwSIk3WagKPtbnyxB9+32bpS2ZNy3SryXCXSFEG7aMYOlw1QIzFZDKmoig4sDYGXxAbodmn/S4nzz5Nklp75tA22pSDzNifrDoqzqgmpTWG2XRG07S5v2nA2tqI4WjEZDJE1tefIfhW50qhUI1CZ51bIY5SE9H+vP/2J36c224+gQRlo5WkfSSHDx7kB7/nrTgD//lj9/CxT32Gt/zxN3H40IFM7GFYCkErZNfnzKQvwFchU+RXCIVCXMLFACHPzbQW2WjfLIZGU8SMyoJRUeCtwRRCsC1GLKEVbLJEibQS9NsSaCTolBdAOiY8A6ay2KQyNyYajO0QBIHQtszmDUlgOF/Q1HMNNLNDUdc1W5tbnDt7Hucdg6rCecfa0OLimCIlnIx2OymkDrp/7xiOKt71//xF7r79Js4/fp5m1nLy7HnqWcOoLHjra+8kxMgnH3iETz/wMN8bIwfXJ8AYEKrBk/24Yy2jyuHFU7SBso4qV+gBZ0jeMF3svaM1b6eX+OulV5IkQopXfkwKZb2wO9hlKC4CtahG2+qRrD4tl7PvnU/kba96LfsOH+t/7yrEthpw4513I8BTDz/IU498hWtf8FLK4fIeuHjll22fuZzPXQ3zXuF81aBkMB4xWlujrRtmGxu0dc18Pocm4EKkwDAoc09doTDZvsKZK6JLf1UdZw0ygzrKWLwrKHxJWVUYSbT1FhIXPBVqzp0uWF9fZzwsCGGdtbU1hqMRvq+W6njWbWA+rxGgGg0YjkfEGGjmQ/7Jz/4zXnH3118QaD3/xI3cecfLGAyGvOfd7+KD738v3/n2H+PgkWN9VTz0gb4goSWJwxhNe4XM4hpiJMTAfD7n0Uf3PtCMYmmCJ4oFCmCQ2cNnsBCMTRgrSmwngg0RG1Jei5RJezdTdnNHUXoSBYaKKINt97q1QuXbTCRkdN8XMZMEcdo+Y0hZB0ZonckoECi9p4geC5Tktg9ncaMKWzj+3E+8kxffcqsmyZ3L96JhdM0xfvwH307pPR/48Ef56Mc+wdu/9y0cOTyio4JcVeT0uULidrwPSpIWzN4ncDSR5/p+xtVeS4WTauBXlAXeOyXJ2dU5035NbBdoamLBemWldb6DmGqgaZ3DxpifLYXdFkVB4QsMkFJEhdENyrXgMC4pJ0RK2kdZlHhf4Jz2Y+poL4+/Q864wuML7cPW4Dn/3WR9a6cva8EXlvFEGaxnsxnnzp298FS7OUFgUA1ZW9sPwHw+ZbGY9wRye2lXpZi9W5C5w35u5ee7r8YxPFtbrQB1rKMxRkIImUygY5OFJdhnhYhkuaUOJ7F9+yzhfsuStuz20T21i227CzIv9pmX3LUcnicff2yb6/K1Bxhdua0ihpTSOze5e5sz2Dn7JIoJlE54Ouq4x5CUNrwJLGplmW2CQmbj6moiF47tbraEIEqvdXS5D/XgGXSoBiuBz9WUv3g25kuHL9xKdnDlXEQ0Iu7EuHtWRU/hS6rBkMm+fexbP8BoPNbJuV9Ylo/Z7vd4V71JxJgIIdI0DfP5nMViTtu2pBj7RNBOFujVnlBlmE1Z0zJmseNl1lpESCHw/BM3KeNtfqWYK0aZCOhVr3hZv4+HH31ke/JpG0zM9GSiBnVoDKKwt7z4ebf3uULJsK+UWEJlt8EjTV8tdq4Ljju92Q4emx+pDLGV1cXLoPAjeyG0yNkOOrhk1FyFsEvGpSr0T6s3HZTJW8ug8AwLT+FdRinoCUnWvpWokisSAjFEXnXXLUoogSjJhiW3SOhcftft16+M1akVlAHbHnGJCt/u1gLnDb5QRuti4PBVZnDc+9G6xGuXj+7J/i7yF1lFXm3/3Aqibcc6eaGZC/5TWw0yd7PDNz6v/3l67swz7++P0ALWQeZshoL7osR6RUypnnAiSuxJk6xRBtEl/M1esD3Yfu4G0yezlH1SdQ+bpmE6nTKdTpnN9DWfz1gsahZ1TduG/tnt11PUa4nk2AajjPp5oX3F178SfcBdfmXoez6uN7xxWVV+6EsP5LVweQ91Jvl/0s9BOdHRNizyHB7aq1CBllWvzKAd+UZhHbJyTLJEHnXnYEQd624O3/ZaYf601uKM9knaC14mvxwuv7QyrZXP7j+T5StMlhvp7gWXGWH7l1vCrZ3r1g6Ht5YX3HZr/o5buZ9Mr+n42ld/Y39ZvvLww2xjuV4W4HLwnfogfPVlrewZV8WqLe/95b21E0q62uKymk/egSbPkOTlOK1CZHtIulkWE7rtas+r6VnwtbJK3w5guna7/HwvP6PXGbNs2WLlvunh9FbXObuy1ul55H/Nch/99vvzNtvPtW//M/32Vi7dyrXZ29DwD4t1dpUm7I9UQ1ndrExaIjRNQ9MsNEgxaxTFBGsT4to+TNeMhsOYhNLFZ52/zELbJukSTdlBjRlmF7T6JIKzqc9QXM2Ac5tdpMzZvS0oXr+zJNJBvvXm/Foc4x6ad5ZJVWG8Y/94wLgqGfpC+yRqZf0NbUMbWmJMzKcL6kXLfNFy8tSUja2a2TxwdrNhUQfqkLLDbTNsOuUJZpcnd8W0IqmTkDdQ7BmUdVuaA0T+0DL0O+3AsTWqqcdVVoXbQyS0uaIhkVBPiVHwhWMwGWNciSn3YXzFaG2d9WPX48sB5v77OHn+HGxusmimkIkSrLU96VZnq26q5AqKSOTsuXPwqGE0GrO2to8D+9Zx3lMMBrjiQuKflPujJChsSpLQNh2Zl+CySxJDYDHfyvDa1JeTXVXhBiN1DlPAr0ChU9siMeiDz4rgtYHSWUqjjk2bhEWjmpTlpMCPxgoXDrv3TT8Xaxtls20xJAwxLeeEGPVYXGEZTkoOjD20yprdhkBIUEeIot/TwpdBCpbzZaHZ9pSEygg+CFEso9EQ2yZcEbF+iIhQlaWKnUsn+aMOy761NYqiyoukLqqHD67z/Ouu5eC+IUcmVYZxCtLWyHw7M2WLYbpptVIbW8QsMFXEDyKjSYVrPLUknF8uT7PpnOnGsoLczvJakYSwmZgvDE1jsd4x2K+Luh9X+GGFWAj+KjYpPaPJJeeky7dLzGspao8tbOv56qwjo7DGZomocEGs563KK6zuJ0nKrLOXjgxXNXC1T9tQrJBlgN4rhXMq8v5HaAEzxuIcFEXFeLKf9fWjbG2dZ+P8aRpZMI8LNpsFG80cbx2l9zjrGZYlw+EwJ2csMUZSzLrAzvesoECu/pfq0NoCYzwReOKJJ3jq1BMUhVYyR+MxW9MtJvv2M68DguXokSNQdmOY72PnCK5AUqKOAQmBFBNNG5RtNQqpzWMhESMtIsIiJFqz4lfsuFdW5chaMWTy695iiDz15Gnmsy0W8xn1/OqgOlZt550nAqEJxNRqAjCmnAiEMgcgyVvSSgUKdJxVF7gELE4EYXugXDhL4SuN5ZLFpQxHd4lk8mTcCkSVN2LQYiVhWouxJcSEs0UvlVJ4Q5ETYN6ofrQzhqIwCrnMEFHTB0t6wD5DMsfjldYSI1A6otVq6vLcBFsFVmVYtl8/2ZvpZ4cNq8G2Mo3NFT6tKu6uh9t9xjqyhqzJvxtl5i2UlVVE+n7Vjq3VO0foiYNyhdpp8Oa9oyj1e00KhKQtW6phWZGSxRcNSbT6WZZKBmSNEEKTA82RoneMYVANQQxlWTAcVlSDkhAavFdJOOssJkPmi6JgWFWZD8VoEnwFum2Map6WpSdFz6AtSTFhLYSg6LC0wrR/MT6WZ2t/WIHma1d+/uxFPnPEGHMPcDsajD4BfAT4ZyLywSvdobnYE7DD2nYJ5xER5os5s+mmiioPK0ZjwTrBETVrlbWjlCJYHVmRPOlYrYbEftcr2ow9nFYnA6dJMy5CEnd17CL7Wc0+P/KVL/fvHz56bNfvzWZTfvmf/h+cffppkiTGkzWuu+FGXvLyu7nhxM1cqV3uWG2z1ejY7Hgvm3OWalDgy4LxoGLgPWVXEcq9dzEEmqALZb1oqbdqZvOW0+fmnD5fU7eRrQyZbfuA2/RVSpV6uPQAJuiTD8Ya/B4F7WFlwVYiid17RC5WQX02vZuXO1aTgyN8peLObRtYzGqmWwvNCEskNm3f01YOPcaW2GKEsRX7Dx7h+ttuZzBZ4/TWBqP77qOpW7yv++tmd0vLrZooTT0JtrY2aSQwHk254dz11LMZRVnhiuKCQFO6alhKuSKmyaG2TdRBk0NV4SicIcVAPZ1SL7YHNT4mSqMObymRLzy0fKauO3IIUrxgTDa3pvytn/pHPHHqFCkJ+ydjbjx2mFe+5IXc8bJDDIaV+htXEGhe7ljFVl2f2uyAXIuikgOQLFTes29Y0drA1rQhEGkFmmh0kY+GFAzGCD0CzWTYVmGwyUCMWIGysAwqDw6sTxin925htSwqQi/nowL3Q6rBUAmFYkRIrE8mXHf4IEf2jxm6hLNpmSCQdttDFqKwWQuzKBRFYjBssYXgKhgMC4zzFIuarz5+pv/OwcmIxWw5tqFWB3E+b/jt3/o45zdnOTj2HDw44MYT6xy/YR/F2uCKH/BnNQdeeot7u7ldLHVJmYsdgTH4nJ03aKvIzvtemd23P4MxKTPtMzUObT59qv95tG8/Bp3zdZ96/m1dc+8H/gPzzQ29vwYDJgcOc/imm9l3+OiVnfDyvJ7zWHV9U84XDAYTxpN1YgxghSANTaqZhYZp2zAuSkaUOAOlL6iqsic0Szkp01dRMnEhZGhz6TXhjSehjJfnz5xmtnmOsiw5euwoa/v2EWLkyLHrEByTyUSZMengeirrgHVE44kmEmJNjK0GmkH7vFIrhIVW+0xqsWmBICzE8JlPfbI/9+tv2t1H2Ng4z9/4y+/k5GNfJaXEwUOHeclL7+Q73vhdHDt2mNOnniCE9oIetEtc42c9Tp1r0ZmiVyI7+1sKoLLaehWdJZaun7f0GCzOlzirwZumRrZvw7siE5w5PI5CFFYZTCC4mNEUkiXUIlKqpImxFps8WFnZH3gnuefT4lyFtR6HUJmEI2GcwxXFtvXTGA3GSgef/+KD/fs333QcCqvzeey0RmFjc8pf++v/hMcff5qUhPUDE17wghv41m97OS956fNyTfgKrvdljlVZFApXjl31cEWhDi7Q/+qqesZ2iJwOemrIxKs6ZxRKUOUyb4JWC7uK8grpj8kSdhlh432W8GpU91qVVDzOFXivgWvK0FlfWLxXLdsYQ4+cskYrjUVRIgJlqc94VRbUheuP1TqjsmjOqQZuUSq8t5sH0hKFpKy5ur+icFSlJ3aBZsxyOz0KTpNUe2lf80DTGLMO/PX8638Wkc9f5KMjVBrlLNoU87z8+n5jzC8APy6duNEeWsd4maRjEIxZNHf1OdTHxvSY8GVophUt/S2J9mtq6nT7cyNkJsYYMxY7MyfalarG19J2CdQWizkf//DvAnD8xhMcPHTkwu8AoW059cTj6vi1kY1zZ9k4d5YHPvsZXvyyl/Ntb37LCr30VTr4/slfefsCOAD9g2a9ISHLvj5yljIoGUFoI7N5YDoLTOeBWR2pM8tsSNqDYXLVSQwZOqO7LDpY00oAqVXu7mil/9vFRrqDcSxPxWCT4MQoxJclQK7jrZoH3YO1uv90hbfRavZrry20WpEw3uLwuCLiCwdiKStDVWoFrBGVxrCqKq7HIoJJCZMiRiT3UdjcE6nwVbt63GbbwwqwfMaspRoOGQxHVAOtmi3mC1ISytGw/77Cg+wFzq3JcF1MhCxflJIQMIpQWIUs5zEUSaQQEGPZWkx570c+BsDzb7yeQwfXCTHgO+KUfNxN0/DlRx5lMhqxiDVPnT3HU2fPcc8DX+KbvvwIP/HOd2TdvL2vWEeSMomKnoTep7rAVoVn6EtGhaW0FpvARtWJCyERkwajUVD22DyPKqusUr9br9lYUXptzSyLoXRLqFxwOXFjtFtUYUAKH4bOkdYacOkdBkdZWCASUyCYRBsjyQitjdRG895WlAgoRNQZjkIjkTY0QGKxcEr8AUwXNR/+jDpZN157iCOH9ilkrodL670RQuTsua2ssSYsFi2PP97y+OOb3PDkFne/4RZ1WK5Op8oF1k3hevvp/XTZ8iPdefUw55VZauWcM+75yo6rT8ZlmOEux9ytvdvQGfLM5BShbTj5RZWamRw8wmCyb9s+u6+nGJieO4MrSiQGmtmUM7MpZx57mEM3PI8Td959UQH6q2Wr860xUHjHoCyYFwUGSwoQg9A2SlQXndc5sNP09n45zhnar5WWJfzcWpVg6rCpStqVNb2jckykJNRNi5vXDBc1s0XNsK6p27bXNO0CBmfoYXodZDRF6Z+pFDt26Xw8kvrq0ubmFu/+tV8G4NYX3cHRa4/31RRY3npNveDhBz/PeLKPejHnySce48knHuP97/v3fPNrXsdb3/JWnHNU5c6OwOdmUSxJLnIPWAtOa6wGj7I6C0r/qgMoVn0CxYou2UKX7LDLatiqdb6kNU6BsaKf7iqMyuqdnTRrwELK71nyemlXnlH0kJylvw9W24UU75NhlDkA23aqBramM/7tv3svAC96wS1ce/wYDfn51AkVgLpueeihJ5hMBiwWLaeePMepJ8/xod/9LK//1pfxE3/uzZkJdW/NOqsB9wqk3GTfQdug9FmIKUHU4K87t04ujoxCdNmnUKRQm1tklr5lSlFbYVLKmpQrTPiiz17oWnDyGiHSKRak3Hqno9KticZcXNtXXRAd77Zp+3+7ZzFJd/x6DB0Ld4yRpq5pmmYbWiDl8xEB1RHN55dC9n0DIRO07fVYfU0DTaNP0i8B16Lw2T+/y8ceB/4u8OvA50WkNsY44Bvy+98G/AgwBf6by923yKWBMl0GJcbQZ8lSSjhJDKzCRTqIo/Y6eJwr6SaQnaYEP6q1E3fZtYgohLANVIOK4XCk2jfWKbHMM54QF1bwLvGxZ7ScAermPpHEf/iNX2W6tYnznte96c0XbGiyb41Xvub13PLCF3Pg0OE+W3PysUf46Affz1cfepDPffqTFEWp379Mu9yx2nbwl2HWWYYjz3BSUgwsTYrbSDtFhPmsZjGtqZvAoydnnDq9YNFGTm/UTBctSbQakgSG3rJ/4HUykJw9EpCQIGTHNh9aAprMCmuNocxsqKvB6OrpuBwMbzv+INBoY31iCQuJBs7WbX/PjL1TZ64LlqDvBzX5556++zna5Y7V5rkpWIOrCmxlsqOkS+5kMmY8HtGEyOLpszRpissLsgWFZM22NPxpa83aFQVRhLpulGXXGgoDGIt41UFbdYSr4YDJ/v34omCybx+TffspvCcl4cmTJxmMRhSjIdV4pIGm8xgHiWa5HeswvtCgNzQYqUGERZ2TUyH11PxYMIXFWBAJtLMtksC/efd72JhO8c7xpte+iq3ZBkVRUlQlvig5uH8f3/PHv51XvuxOrj12FOsdIQbuu/c+fuO9v8MXvvoY/+WeT3Po0AF+4kd+gOYK4szLHauaZptkhcNR4PHWcXh9wsGDYypgX0xUi0RcJNpFYDZviUkDvL63VVkqSHWgadWpGUvFIJU5yDQYbxk6dZBCEKYugglKqpFUZ9OIQZLgksrhOJsRCt6yf1xSFZYDE0cbZkwXgeAS0WnGdpEsZbRYhCo2FClQi6EJhkYMs+mcM2c2aJqWcjRmMNlPSsIvvfv32JrVeGd502teiikdkhKxDqQYmIwLvvnrbuX2W67BVJYnp1ss2pannzrHgw+c4vzpBY88eBYZPMSLv+VGxubyHeIrnwNX/pb/7aBeItDGcPkw+hggtrolX0AmxiA0mkWwTt9XJfLLWmPUGctstXE5H+085pAisU3btifApXrORYQvf/L3aesFxjpufOnLIe+vCRFrIqYoOH77Szh43fVU4zWwKlcxPXuGxx64j82nn+T0I1/GeceNL33F5V2n5f4va6x29lHuZs5a1iYjDh/cTwoLTCxpF5bFNLK5scn50QhvLQfW92GMpRxWjEcD7Q00mqAKMWCdpawKyqbQ3vjWIaIJ1JQSTb1gvtCfQ9tirCMKnD2/xbmtBXWyHLzmKRqBgwfX+3nNGSitIkgK5/C+BAKLaGjqoIiHWkhBekkfdXYTiLIU/18/8/c5f/Y0RVnyfT/6Z4lhe0Vy3/p+vvN738ErXvVabrj+BvaVFZIiX/ziffzKL/8C9376k/zn3/0A3hne/va3YybPxBp+ZeM0bwtEDGnnx42BogTnMCkiDZjggIjYOv9riKUys8jK4m5tgbMl7NBFXG7a4Z0ypDpxmbzH4q1qt4Pg6bQbjXruzmTyoQIRh9iEFGFbUsaQ2UidxRoobMfE3kmggLOGwu/Q+zZASvzMz/4CZ8+dpygKfujH3kbjEykHl8YmDh0Z87a3vY5XfuMLOX7DQcpcKfviFx7l3/zrD3LvZx7iP73/01SDkj/942+6rHG6krEqy0I1TkWfd2tdD6FP0tBkYqmQEta6PqHhnEOSMJ8vsv8GVanooBQDW5ubgCZMrPEIhnqxIAZFLZaFpfAlMak/KCmR6kYJykThqJICMUjPoN63ygEhJhZ1i2sjzUoP9PL8tMqqS2jgXNahbdpWkQ4ohHy+UMk2wVIOhiCi/BNz5Z9omw4WK4Q20rqQNb8dxhnaus0BqfY9x9DinGc8mVz2WF2Ofa2bRv4x8J355z8nIvfu/ICIvE9E/o6I3CsidX4vishHgG8H3pU/+meNMXuuAKs9lEqv3zQ1EgOF0SrV6oOoGSJ30abZLsCMyfQBwar1UgjZKfNFQVkN8H47hOGidpnJ5CsBi6x+9oPveTdf/oIWm1//xjdzJNOT9yZw0/Nv5Rtf+60cOXZN38tpreW6G27iT/zAD/P8218IwGc+8fucPf305R/IVTJroCgd1UBhC5FEm2L/amKkbVqaRcNi1nJ+o+Gpcw2nzzecnwWmTWLeJtqkFRtjDcPSMi4t48oxqTyTyjPwVif0rmppdMIIIoRcLHDG9DIoF2Y20cZ+b7e9nDf4DLUtDQysEgBN20iTq5mT0lNa08sIdxpSzlrtj1rRctpNCwouDq19LlbPG0JIGO9wlcdXBWVVUA1KhuMJo7UDDCf7MeWAaC3RmiXkKEWkrUnNQpv+rGLME8ssnMSQKWjjhQ01gPMqGzBem7C2bx/71w+wtm8/IsLm5ibTrS3aTCrRVzOznEZ3hfT9TO9mBENApCWEhqataUOzrGgaJWfAaUUztg3v+eCH+MJXvgrAG1/9Sg7sX6NuFvq9vADd+aIX8PbvfCO3XH8dZeEVpmosN994nD/z1jfx0uefAOC3f+eDnD5zhuHg8pysK7GQa5q9k4RWoQvjGY1KDhwYsH//gKFzuKAJkNAmmjbShkgMLTG0pFzhTUlJmOqmpW5Upqbr4TJGK5y+MAw9jAthWAiFT3gXMbkvKZpcHc1VUpNJM8rCsm9UcGBSMSwtMbU0YUETahahZtHWzNvANAizkKjbQNO2tG1LiErWNJ+3PP3UjCdPTtk435Bi4l/89kf5gwdPAvD6b7yVo0f3Y7xRDTlJpBR5/g0Hef033cbx6/YxHDmqgaUaOtaPjbj164+yfkwr5I/+wWnOnp0Snzl9uKdmjcJG/ap+2+VYShpsprBS0ZesFB7yM3ZhkHgp6z4TUyKkdNEKa+qSCyuvi8mfdPbIfZ/k/JOPA3DTHXcxWmFGT6LbmBw+xrW3v5hqbX+ffDPGMjl4mNu+8TWsX3McgFNffpDF1uZlnNGzt0uNhTWWQVkwHg4YlhVGLKm1hCaxWCj7bIgBcVbn0sIr22WG/IdMPGatCsx3xGsmBxeIQg5C21AvZjT1Quceo9Wc2aJhY2vGxtZUX9Mps7rux8tAJrABby3OKsRTkiIEYkjEVvQVReVKJOraB/zLf/a/85lPfBSAP/Wn/yLHbzpBSmHb6wV3vIzv+pM/zA0nbs4sxgFnErfeeht/5X/4u7zi674BgA9+4AOcPXuGcYdE2SMLyWW22Z3rslGcZVFCUWFMiZESxNPrpFtD8o7ku0Az40GMw9oSazyKhrtw29Y6nC1wxuOSwyVFQbgcKHpjKNGEamGhcIqoqoylxFIam5NLdvnyLjOb6ss7R2EtvtNRdDbLYpheJqPT1/y5f/krfPxT2tn2zh/7Xo7ffB3R5vSjAYzwsrtv5k9+/2s4cfNRylLvQecsL3jhjfytv/MDfP033A7Ae9/zcR5//PTYyMetAAAgAElEQVSejhPQS4KtkhcZq+RTXVtFjLouNW3oNZO766/62loldE7lSSQnYpq61uRcxuGGEGibmhQCzkLhtTosOcgNnf/YNDkg1bagEKKuN2HZIiNJaNug62XcPYnWVTRFIov5nK2tqaKv8udT3kYIUYsT3mO9J7SB2XSa5woNrDuZxZCZkbWi6UhJaJo2xzsNTeYo2Wv7mlU0jTH/C8sK5l8WkZ+/0m2ISDLG/CTw3agf/WbgH+3dUUJZlogohjrGSOEtg0Kx10XRTdodY5TtjmsX53xH+TyXrVPqmCqXtIVa4bJU3iBRUXmX7ZLsXLN2ppcv5QVc5LMfet97+PTHfw+A13z7m3jJy+++9Pd2Oyxj+ZY/9kYe/Pz9iAgPfeGBS3/hOZr2nfTs3ivHYXRCcBZXFD08JMWUpQ4MIaYsUyJsnp+zdX7BoolszRvaEIhJcNYoa2SGVnR4iaZNWcNKJzpMZrbd0TrnkpCiIYhQWkPlzAUSOsuDBu8NdgdLZRKDLW2v1RpFeGrWstVohmv/qGRSutynAyYo1fqqxYTqb66+bQxRlvp6e1XtXLVyoP2PzmsPgSkcdlBk+E4kNjNC0xIWc9pZDR7cSLW+isrjvC64w8mIQ0eO4aohZ89tZgfKMB5UrA1KosA8af+skhtoMmg8GnHgwAGtbK7tZ23fusJnmhppanzhtQrctnSsej2Rf+4psxi80eufYgGp0ABqXlPPa1KI1IuWGKImB8pMlx6F3/39T3HP/V8E4FtefifPv/46phtTrLekQaIdLKhcQWu078Iak51sdRxj2yBEvus138BnH/wKKQkf+fgn+e7v/I49HScACZI9SkVvpJQIKWBECIuWZlbrwtsGUohLVt0cgKVdiFtWBac1C59wYvACNjtpyrFgKRHGOEJyLKJggg5DES0uqYPkS72XBoWjcMrcKBKZtzXJOKITcOowiejCHlIiNAtsu6DBspE8tVg2Fy01idYK89jy87/1X3j/72uS7dV3neC2G49Q11pJl5gIqSWlgBFLRzjlvWM8GlDESCQyaxtuevFhzj35CAicf3iL6w9eHWkow4XVsg6ep0GaYDE9NKxLhqx+T/K49SuP9ZCdX+McJJN1o/NA9T0ius4ZHWR6VXZZ6ancwQr5bMya3ZNiD9/3KU59+UsA3PiSuzh24tnlnm96yV2cO/kYIGyceoLxvv3P+lgvZpcT7BtrqKqKyWTEaDig9C7fw4mmblgs6r4ConGPpSw8MY9BzM+iwmpV+gFnEG8gKp8EGHwBZZVhr51vIgmT2pxQSJgIJhj1R3Z5np0zlEV3/+vv2sWy+9rxK7/ws/ynf/8bAHzfj/55Xv1tbyKEC/srDYIlYvP9lVLM+IqEN8L3/9CPcM/Hfx8R4VOf+gzXXnvdlQ7FM41CRtNcoCNAMhnrYQCfK/1k5IqJmI7M0cCyvUr7b2G3pLKuh95oIk8ZZnWtM7Iqd6Xbw7gMlNRnWO8DbSNIgO2QSzmJTZczzY/fatK0K7j2f8val8bAz/3Sr/Hu930QgB95x3/F677164mm2XbslszWvXKIgoAVxClM9Pve8QY+9vufJyXh/R+8Oj6giBCiSn8ZZ/CX8l1k6a+vMsZbYzRhYHKeLUNSlRAp+4xJ23qUGV37NZNoq0YH0dUGj+X2uYgvpUiC0D+vXWuZ8j80/c+r59gdb4cEE1FOEUT6uATpWN87BNsSOabHH7YVvvRYU3/PLBlt99b/+5oEmsaY/xn47/KvPykiP/NstyUiXzLGPA0cBq6caeYZbDQa5X6GQEqR8cCxf6hU0MWwxBUqjtzp97Djhu2PM0sgaN9CIkR1xGKIpNw0333HGcOosIxLj2mFeUq7VkEvyy5nLe8CxV0++6H/+B+456MfBuBb3vBG7nrlN138e88QcK4fPMRwNGI+m3H+7JmLf3CPrBWoZXsQpQRAAwYDZflyzulD2ybCQieIrXlgY9rStImnz854+uycEBKLVklfxGiQ6b3XcQ0RUVA+s7kGJsPKMay8ZroqS7HD8QsJZddMQuEMw51QlR2mNNY73nQWKXSZaSM8fHbOuVqDzCNrFQcnlUJ4s/PQNIkUtmfL2iTUO9jYJF+7ebv3On+dra2PcxN+Xom9RQalSn40NfXWFotFy+zsOWantxiNE+UBy3jfgOFaSTlwFAPPoaNHueVFL2Zjc8q585s89OBDWGM4enAf1x3cx6INnDy/wcZ8gbMeX4xwtuDIoSPcfPPNWeh7wnC8BiLMNs6ymG5SFgVGInE+00SSV5FwJGVnzWG94ESdPmcDpRfqxYLzJ8+w9dQZ6rbl/GxK3TYqtpwTG/d+4SEe+MpjALzsthNcc2CNJ04+SWk8BY7ReMTEVZQpYpyjKZTcQ0JQVtqkgupNXLC+f8DaeMTmdMbjT55Cdoqt7oHJHCjoFQlCiMQmEa1htmGY+0g0MGwNRTS0TUsILSGqVEzbthdAHTthbQGCRGppKJJhkAw+QcJBUSDGYsVSJU8S2GoNG61BEhQh4UPCOdXALMsC72BcGLxLxNRwdp5wjWHiDDEncyrvqZwmDqeb56kXU1pxbDGgwdO0LVOJRCe898Of5WOfVVnnV915gucdO8jGuXnuQcsOQMxM4ckpxNtYRsMKv1Zp1fK0YatpMyTa0daRsBUpzNXpU7dZv3JViFxEYah1qyRIhXMUtiAmUTijJP1eZpsMrfapiiTtQSsqjLH4osgQ80QDxC7I7ALKFDGhyTCNAs2wyRJ+awz4KmcRnuX5GZNZVrfPqQ/eew8nv6TO6813vIIbbn/xs97H4MBBirKibWrCfMag2Nu+v8s15xz7961x9Ohh6tmM0aDQ3uXQsrGxRZmZYSVP4EXhGY2qHjHQNi0xqc4v5QBfLpDKE6NDpMBFwcbEwIIt1Slt6kBoM5KrPQ+xxbQB24CrDaZBGWRTopNdQIRBYVkTqF1iXjna4AkmEa1cUL3/1V/8Wd73rv8XgLf98J/lDW9+G8JFKjkieGk1ERsjbVRn2lnBW+H4sSOsra2xubnJqadO08S9d2MdlpICsw30JzS0tAS9/8sBFGUf+KlEUgN2C4i5varSkHVXuKxVuKx1ihaxJS4HnsaxLcgF8jOUeQOSajRrwG8RsfT9+iJ4C97IMrjMwX93FNZoRXRnAGot/OK/+jV+892/A8D3/9Bb+WPf9RqwCwrTsBqAaHfohWMoRUSqlpBgcGQfo8mI2daMP/jS3lc0QdmuF02jMlXWUFUXJ8gTlsUelbDTpI3FUBalJt1Tom1jLlJ4vLWqq960WnwqPNZr5TnESAhtZnDtik/Sc0eQA8+dFkJgNptp/2iMOKf6myEEZtMtHVdvc0VzqfHbJQdV9ivS1guitfiypCirZYtCSqrjnNFs+ig1tK1WM7XtQeh0vrtkYScZphqge2dXPdA0xvxD4Cfzr39VRH76au/zudiq1pBB8F4ZmpyzWbC1y1Dlwd727VXSgqy3lrXlpM8ydFVOWSaPcxWsyPCFZ5/3vUy7yA4+9L739EHmN3/bd/CKV7360t+76gd6aduZKFIndieltcIdFVbg+qx6SpLpyYV63jLdaqjbyPnNmjPn6+0VGWMyBEmnVWPo+Z1CVG3DWNh+f87pJL6avbRJiBiCZNiLX2bKrsicZsgePjvn9FQhDsf2Dziy1kEolxVbgpBW9pFBG0TZThQksp2c7WpUNItyx1TjFIaIWEKzILYLYtMS64ZQt6QqYp2lqFzuV9UsbzUcsG/9IMZXVIOhOj4YBmXJ2niIrxuKqc0QoMxy6TyDasDaZI3x2oRqOKYaTjTx08wJ7UKb30V1ME3Wo+rZ+8x2LS4RA8ljpNCqXky0i4a2bZjPZsxzH6n3Jfc//BgPPf4kAHfcfC3PO3aA2WKOEUOUgigeh6Vd1MSmUWgWGaIVWmhq7QsMLVEidgdJxVXRS42oRyIgRjJqUvskYxsIdaOsislpdbdj0e7QGjnzq9eOPvvaWSIRxSixlYBJZH05JbfwgHc5oYKlECUOKiTgBZw3VIWlKrXa42zCohXNOggmQZEsjSjczCX10WIITOc101lNwDHF0qD6hK0kfveeh7jnc5oQePXLT3D7jUfY2miUKblpaXf4Lx3bNKKwq+GgICKUhQZFKWeUyZfzak2XWp2w2wNNA6RIlERP52QsYlSCCVlWNK3J7mLKsjzO56pl1jM1NhNwRcBvnxtEllBa63XDQg/R1GSNLD/LxXPlF70+/fkt7/0vfebjPPr5zwHw/Dvu5sYXvOTKLtolDqC7nn8YZk2WMxgMqKqSwqnWIpJoW4Weh7Ds6bJWJWME0f79nWRAql+hLKEuwwpF5S281Z7JFG2udOj9Kh3DbwQTzYUwIToHVhOwKem/Nr+6+bIb6F/9xZ/lvb/5bwD4nh/6M3z7W75P/3CRG6ELYKxAkqh9dSI4Vovipv/ngl7KPTCtaGat5nywAtjMP9nDaC9Q59MKJ0TdhvHbg9WV5LzJz6SzHofDG31d4kHIm1iSZXUoEZDeL8WsSOVdKpltOiLB5UD8/L/8NX79tzTIfMc7vptvf8vrSCSciVjChdVLdhlGmxCfSBGalftm0e6tT9FZx3atEkhaSd1+3nkGzC1M0lc1lxIgq/6eJHKFMn87z5ciijCyySm6THKKIaMBkD6e7338jrdjp0mG9Xa2RJZoz7QGrT7Pqd3+ZemL5Oera71zK05vf44sPw/k9TlqYsHZleugyIF+Xfj/W0Uzw2W7SuZfFZF/uAfbfD5azQT48nPd3m6mujQVyXnKwmhQkEkrjPUY6/Ja2sHFQu9kabLbkGRJLW5WGNWMVaFkbwyGAhGV3LClgZKuZ36vx/nSJvCh/7g9yLz7m775OW/23JnTzGeqcbV//eBz3t5ultDgUoPM5ewSJTNfRtXtcm2kFSFtgV9YFk1kM8uUTBeBjVkghMS0jhdkoAwKfXVGK5LdM92x7xmzOwzWoJpYzlpSgsIttRe5SDb3cuzLT885uaHVlePrA47tu7BPL2GQwhB3OkwrrLX9WwK0iWn+vTSG7QIdz93amFQPMejE7oy+ECHWDbEJSBQKXzEaGkbj/UzWDjPZd5jhcJAhX0pnPhmPEAzD4VArkUlJGFpJBNM9v9oLEyUq7T7ap+mLKrO16rUoyorBcIJBmC0W1PUC7z3D4VAp5leo351z+KLQHKUDKRyl9awfPEgKQtPW2KGjbhZY6/nkFx7ug8y7b7+BF5+4htmipWkXpASLtqEJlpBqTp4yTOtzipaoBhjnVEqlbSAl6mZG3cyY1ZHNqT5TRw4cuEBKZS+sKDziRTXbAF9ZispTWMNkUrE2rLSyu4jMU2KRUl/BEFAStJQhXbksmkxFsDn730RiaEgOqv+vvXcNki276jt/a+99TmZW1b19bz+lbr2FxEMCJISwBYwt0AMxNiDNGBwMEWBwTDhmwniGAZuYT+P5MBEzNg6/CNvjwJrByIaZ0fDG0lg8ZiCEDbIMSIAAPVoCtehudfd9VWXmOWfvvebD2icrq25V3dvdeXVvqvcv4tybVZl56pyzzmOvtdf6r+QgiNXSabLzVhy5pHnOB89yMOGGfkj4mIqQg2PoM94rQ2P/+ySE6IuyrUMbk7vwqccneygfzOcsuyWDeObO0YvV8Lz/g3/E737MajJf96UP8bKXXuTqfseyN6Xcpne43oYsXmy9icwQLNAgmGR+RtDe43rHYn9JXzIOZrsTbkVMAErQLKVjaXl6mHqlSorWHDXroc+QSyqxACkOJ0beT0KV1XXsNK/iMZayX8Q2xnRa+zDHH2iq5qAoWIN6d/rf1ixEtRIFxPHw7/42jxSF2Ze8+it4/iu+mOHEtip66DyvI27M0169vzi4xtBZGmcz2z1lfbce65834fzuHrs7O/imBeeJWZnPD2gax3JpbaFEzMls24AMsJ8XLLu+/L4pCuthVZ8pYj1eTaDUlJpzVlJyuGQK0qpCSko/RA4W+0wOrjBfzq2EpJxjzh1rMC/Q+MAsNPQ50Tc2FgrJ8a4f+SdHnMy3vePbb+IY2GxcKGrqikV2RSwQ9eijf8q1a1cBeN4DDzKZTDduB3WCeo+KR0h4DtPKvYW1Tt52DYi2NovpDofXXk1Z26oyxgkLR3ANTgJB3Ep/4cTtwVI6Rz9VTCagpMLf/H45WVuAUfItOeV/f9f/zc/9/C8B8F3f+S180zu+joipccvxPiG2s2jIcOza1eDATXHquPbEAfN9e149//kP8qkP/dbNb+xNYFpz3tqT5UwIzcpBXPXPFSGEBhfCauZxbMOkU9v2tjWNFASaITFE6/7gnEecpTM3TWkNUyahVBPeCbPpxNLOS+2tKvhsARJXZhO19NU2IeIxvbYcRg5TVo8qUFugzweYzuxeoNmeV6haIL5pLBjobIaTEuh0boeUIsvFnEHH7AdP21hWSxysnVzjPef2dlDNLJa9CQMpFpDaILfM0TzmZP7AzcxkiojoGVMpYlYYndUM/Pyz3tAT8C4wme6AZqbTyLQd8B5yCKiflCmtMZqQSakv+c8Qk6BqNyLnPcgovTyeTL40lFUmrcdJZrbb4qaCTsqM9WlRKDU/YRPxu/Woz7qT+efe8o3Xz2Se+H09OrBZi9SN7//a+94L2H6/9JVfyK++7z0b2PKjJIWlijmVHC5Dhr40l2/6RC6RHbewqNy1ReSxK0u60g9xOaRS15hW0f4RQQlZCVh/1Fhuzl5g4oqa29qM14gTYdY0TMOogma/72LkoB9Iz2DW8BNPLHjkijmZL7lnyoN3nSwGk1RQPEM4aqugyoSjwz7NyuXFYvXz3a3jM4vNDrSWMZG6SJzbDF3rlNaX47nsSd1AjjBtZ5w7t8u58/dy8Z4XceHeBwghE4Jtz2Qy4eJdU9pmwrm9PSbTCZoGkhOWqgwovglM8oSYhOUQzdlECe2UZjIrPaLMMWinu/jQMvQ9V556nMX+VaaTCfecv4vpZEIzmawyGZq2tdR6ARdbXJrRz3pir7Q7uwz9kvNXpwzdnF/6zd/jdz9hwj9vft2r+bKX3G/ppX3H/rBvg7kDiB2EuXAwPEkzFUIzYTK1ps0pm7COKVT3DH3HBz9uolpOhNd80StYHBycdsifMdPZhCiRXgZUlOms4dzulNZ77t5puTi1puDLfsF+GuhSWp3L2fxIUpIiPGFKi8lNSH4KmonLq7hhTuMFPw3E4EyooDeBoOQ9MQSyOOaDZz5YGq0OCYaM90LXJSYTjw/KdCdZjzLnmbgGJ8Kydey3NlKNB4l0kCzVKC1IuSO6wEFQBt/woQ99ko99ygICX/TS+7j3/hmPXr5K7IS4LA25lwo+4cQxkQaPkFMZBnuHTw6vjoyDhcctHB//sK0TgfsfOI+eIvrwbMma6aNe92A4FJ7IxGRqpIhDmxbEFBj72Jsjtl5TeQM0ZYYukpMSXKLxRc06ZUtzBPDmKCBqM/NyVGAiJ8eQPFmh8RnnM6cp1ynCYPl//PFH/4DHHraWMy981Wu47+WvpDtNvCInGEzQ78izqqQGg0Aa0H7Jx39n7Oso7N33wOnrvMV459jb2eXuCwNPnjtP004hNAwpceXqZXLumB88uAoiNN6zM5nQYb3z5osFIQQm56ZMpxP2u7bMlthsY9s6RIXgGrsms5JiRxx6crIshRiVZddz+dol1ClXDx4yNdsYSyqfzTmuSnARZqFB2imdRLpJJIvwL//RP+Q9P/3jAHz793wvb/7mb71hMMPSGC3rpy2KdlpURKMKfYJ3/diPARa0/6o3/CfMZrsbt4M6R56Ykx9Y0pIQMpYYfvpsd86BmKboaiA3PneFSXZFrbctDpBD3MTGhA4m/vRyGlXrthmLNs3YPk2zldGcdumuD8sEm+Usw5HV77NT3vmv3s0v/PwvA/Ad3/V23vb2ryexJEgHp6XIuoROB3M2Vwi4GbgdyJ6fedfP2W9F+Lo3vpl////8wqnH7pkQI4gEptMdUNO2GK9178yxEhHa6YzQtnaP6hvrIVn6ZbrSKsiVTK6YrIzA0letVA5g6kM5zgqa0JQI3jGZ7FgQJJseoSpottK71Xxz6VXpxVSAczaNDQu02TPm6CRsaXXoA8EF9nyDovRdx8H+PilFvA+00xnOOVQTmu0+N52aQ9z3PX23LAEiU9WdTSYslh2LviOnzM7OlJ3zO2TNPPHUZRbLpbXRc5stHbgljuaxmsz/TlX//k1+9cUi8n8C/wJ4H/Cwqmppi/JVwN/GlGcB/tczenA+Kw7rEAQneVVMjYi1jFibJVpNkevY21AOo3CUKMXaKbRecOt9USPzNuhdSYWeumGbS786dDIPazL//Fv/U77iDV9z6nfWYwBXLl/i37z7J3jVa1/Hi1/2BZy/cLGkkmUefeQR/v3/98t86uMmfvKlr3s9F++597TVPisUE7gZ3aIxIzlnSs8kYUhKSKNl7P1FF5kvE8shMSSlKykUQfW6i6KY/lDJtazDzpPDm/5Y67C6sZcHQlivLRLr0+VK2tKRzIqzjCvw8GcXPHLZou4vvXfKQxemp38lq83sAH1U/uSJAy7uNuxNGxovq/TYRZ94/OqSg8GO4PnGMwse2OxAayWENc5sepNuUoo0eFZULYIYmkBoGkKYEJopzkWgA6x/lSnpBZpg7RsyprKoxVCmQOeuS6EWZxHCIynNzkForCi/PGRiNDXS5D3Om9AGpd9cLu06pKSLqiriHL4JqNpM6r/99d/n333Yzv1v+prX85WvfBFXr10GBFSL8EomJWWIFjGT5cCwjHz4U5d56fPv5nn33FVUVG3G7IkrB3z0kUs8ec3s/+av/rPcd/Eii5tsVv508N6hq35vdh754K3hs3c0vhxbsQDPYWbd2iAULf/bFaFrNzdNNiMmKsQhE4EUM7GzlNvklajW5zZGIcVs0fwhk4dMzmI1NM4CJz6Wzp9iA3Unzu7BJTOk7xKxiyXjxNKrokt0JD70kUf4RHEyX/HQ/Tx0/130MaJiKYVJTWUjZSWmjBcbmO3Pe37xAx/l1a98Hi9+wUXuvmdKUBvEP/H4FX7rg5/giSdNvfTFL7+X3b3JM6+7P4tVOuqxFK0TZjclp3Lz0nIq2rnImujEmD51NGy3+gus3slF7A5d5QWPteEAWmY5DgdmHD6/lJIJVM4XyeCODmSPDpztb3/6o3/IY39sSUwv+JIv54GXvdLSPE+jXLfdfJ+Pf/h3uO/Bhzh/9720e+cRb0q2B09+ls989CNcLaro9734ZUx3985e7y1Eyv2tbRpCCCVYbWnYQxwYhlB69dnnLfXSl8Gmlibsag3pR5Xxcd1l/VLuheKcXZWlVCiWWV7VIkoSB/qhJ8bBgl7JGt+OWbGqZV1i/QSDc8RSp/aj//Qf8rP/17sA+M7/8vt467f8ZbrYX7e/R/YdeOqJz/LOf/A/85a3voWv/IrX8sADD+Cc1ah99I8+yk/8+L/mQ79lQYG3fsNf5IUvfMnGbWAbI0eW8fl/uKUnk3Dk7FdumWDxE4eVCjgRAq6kyJZ7rNj8ssDpjubxLKtyLdnEw3iXheMVgUdXp6tdWudH/9VP8gs/V5zM734H3/jNX0fCVL2FdGr67eOfvcLf+1/ezdf9xVfzZa9/Mfc/eAER67LwsQ8/wrt/5H38zm9aDfWff9NbeeGLX3LqcXumHIr5uKMzgjqOs8fn/qF4pziHUyuTa0I42jdXxxTkdfMfXkHj7OR4Xxt72Y6fWaWj4sqsp91Dj1Riwdo1pEV48PiOrT5ZUl0tOuDccGSAOV7HrGpC3dG0eZG1Y3QoLpWTfV6wDCYTJLIyBy3r3iQbdzRF5EXA3yw/ZuAHReQHz/jKD6nqD639/PqyAHQicg04B6xP3fxvwN/Y0CZfx1hAO7qNOUZwDm3OfviIQHB2UolmnC9Ni0+I1FqBr9XKpXwTfTNvlmMzi2e9f/XKZT74679Wtl34wPt/lQ+8/1dP/err3vC1vPbPfLXt05B47DOP8NhnrKbJ+0DT2szQ2OcH4Iu/7LV87ZveRhxuRSqSWnP4TonZ+lQuS759zBb9c04YYqYJRz34bsj0vQ3iyYc57m7tjhDGyKETmsYG2aKKZE/G1GNn3pxN5x0uyKruATCnJzh8680h9aZO5waHNK70CLQWOCoKLpY6qLWzwQnaeBaD8uk/OnQqPn2p49OXTncyHrow4f5zE0q/XxZDYnE5AZYqNzq66+fd+UngeXut3TQ3rPAf5x1OlVljirPeORqxG3GPzYJFdWgzw4cJfjIFEqRlKReydFeNERkW+LhgrxXuv7iLpsi952bcvTOxFiWdo4kQQ6CdTskSOLc3ZeKgIZWBFIwXgnOOtm25eOEiezObdeuHRHcwRxZL3LVrWNF+JMfBZog6q+3MKZmASIxotlmH9//2HzGu/Zf+w+/wvg/89toDR1cPKVV4YG/G8+7aIfdCr4kr857f/vij8PFHbebUWZPp9QfVyx96gNd88Uv5nd//XVq/+Vjh3t0zum5AF2rXx+DoDxJ4JXpFj02iq9oMZoxijlkZsGYnRIoaZoxkrOepLhPaWSq5I5dZFaVfZFIEDZAasZ506vHaIhm6ONAPEZchd5lGwXtlOSSCU6ZBobHec84Lw8Luq12a0nlPJjIsi0Pr4Fra5xMPP7baj08+9iSffPxJyuTZkdQmgFe86F6+5KX308zsjccvHfDLv/Fx+A27tqeTttTQHd7rHnrhPbzslc9nvp9o8i2q+9PSjgRK+53r055k/bNxsNmIpKRoGThOTGwFsJnA2KPiiLI2eLrBjKd3CiExtsAb0tinL68GxmUjbNF4ZEB1/MFlrcHsd/1ysXIyAR792B+shIBO4nkv/QKe99KXM6bNzq9e4VNXr9ixcA7vgwmBrDmU9zz0Ql70RV9iIkYbTh27WaSk4p3b22Fvd2Z1mq2l7i8WS3o/YH4AACAASURBVNDMYtkxJCvTceKZhAkarQ2RpgTe4UUJvjyLindvYw61SeYcieWYTycN03bKchG4dm3CwTyYevdiHyeJa9cuc+3aVXZ3ZkxnE3ZmU3OOHARKNWPT4rMQdODyZ/+Yn/rXPwrYvfVn3/0v+Zl3/+jqsXZ4FtmrN3/Tf843vv3bmDaBuLvLwx//KP/8n36Ufw40TcNstsNiMV+1nwL4+re8jb/2X/835oxv2FYTWrwGmmTjgdZ7gptwRuvaFUIRG9RktebFyQzOFEydWLpjKKUdo5NzkgN4HCcZL5Z5kEfBSFVEE66MVV0Zf/qTxpwC0Ss5HL732See4mdKTaY44ed/6hf5+Z9639r+HF3PN7/9q3n7Ow4nIz7+B4/y8T+wkoOmDUxnExbzjrgmLPj6r/lzvOVbv53HD67c8Pg9Xfp+afXbfnTaHSmVgCZlVlBcCWhHUkz03ZIhRtqmwXvrEz1iSq4mqiVOmLQTGytpZuh7Ykol2B2K4+rIZfL6tNhU1jGrjFUdvaWsD2UG/7AWcyzBcz4TUoPPFkCysgQt4+tkYkNrnStiTAx9ydyQgDhLsU3R9jnGRExKTEI/ZJbLnpQT09l0JTIlq5v0WtnFhrgVM5ru2OsHbvD59c6gjwHfC7wBeA1wH3ARWGL1mL8OvFNV37+xrT2BcbZxFCtOMaLOrWotT7sf2EO1OCwoSS3iO4zRp2OfT0WRJeVj7SZuwLoveZ1feaNAxNr76wMHVWV+sH/mV/u+sz5ZKdO2M77269/Go3/6aZ58/DEW8wP6bon3gXN33cvzHnwBX/ilr+H5D73I1NJvUc2LJiUtMjHBQcpcSXmVxjfu3bqQy+p7cChYwvUXgmDpsI2Tkgvv8Y0jqJXSArSeo+qxcuQ/O48aR5h4k4Kf2Ox1M2SaNpCz0mWhS44sioQlEjqOnCmNQ3dacn/0BBnS2SdMympqhViT5pfdO+XqMnHQJfpktaZOrA/XrPVc3GnYmdy6ku1h3jFtHLOpJxRddcFEZrIoXVISAdodQtjBT6cgEY0L1DXAzII9acD1c/yw4NxEeOCePUiR+8/NuLjT0nVCnjvCAKkJ7EzPoc2E83s7TD20WOuT0uPZZMqdBRF27rkHT+bgYM5jjz7GfD4nxUgsinZXLz3F5Sc/S4w9B/MD5osDnMDerGHamgp1zGsPLWDenR3F7zXR6UDfmajBCy7OWA6JeR/poxaxKbPhzDvumrbcs9fwgQ//NtPQcN/O5tswnLtnRrjmSZ31+aWDrk/kkEnTfPSOTUnrSsIQhYRDS69RBaLlHDCkSEwl7XKZScuieuiSBYV66OZKGszR1Fag1NgE1yBqs55daWLbuYzTjFdloopXZa+FMLMG5+OgLYtjMd1h0c7IOrDsO4b9JUimi0frW4d49j1qMU8sDqzP58604c+99mU8cWXO40/ts+wHFsuepvFcvLDH+YvneMGLH6CdePb354hPNPkWXV85m3OUs6m+upV3cT2q9tkEOTuG6MjqLH3VWaqX9cq0NNuI1cDfDE4U522gOyRPTA4RRcZ67CPbkbAsBQVtOLyrlreBmB2xDBr7eEzF+wYz+alf2kkFNO2EF33hF7N/5TLza9eIvTUmF+eY7Oyyd+EC9zz4As5duGjHRrMp5d4GnHPMphNEhHN7u0xnE9qiojmfL4hDz3yxZEiZmBUvgamfocFmxXJOqHrcmqM5ngm5zHiKQixlJc559vZm7OzscXAQePyJKfiGpMp8fpWcFly9eokrVy6bg8l5ZtNJqfMzESARRwgtST1BA8Ed2jLnzOVLZ6uNDv1A2065a2fK3Tsz/vp/+4N85Pc+xMc++odcuXyJa9eu0rYtz3veg3zRq17NW7/hL/CqV385AKMy8iYxR9PTJsVlLb1o/U1N8mQJ5tRoZKLCTMcB8aEgjfU9Xd/mm5s9snYisVwbSsogqnhNuHEO9fp4zQoViC6ja45m5w7veZqVK5fPjjAvl4fPs7su7PI9f+NN/OFHHuGTH32Kq5cXHFyb07QNd993Hy/5gpfz6jd8Lfe84At4ouuYp83rCXTd0ko0aIqoWam9tnB6qYUFU1c1567rFnR9j+YJbWvXykguYjx931uWwG4mBBhiph86uq6jCa3Vghbn8KyKCIWi62HjrbGbgGomxgHNWlJ2LdMqZcuocupp0oBmZ+m+QyQlEwRLMZFyKmKjNnYfYir12c4UcUMoWQijs2lj5JihHxLzZUdKib1zppRnrW3suWF1v3e4o6mqn+Rmr5zrv7sAfrgst52xUHpUcQJzIK93GY9Go1ZF8pTUhnLeyyp6a/+PU/RuTGdBbMas/EE94zCunKj1/29w1FdpTOWDd124yPf9D//TkTWetIrDdFRTagUITcOrv+KreJW+/voPr14WZS096tRuCqsTObTRuP3HU1hPsheszTyuf7982YnQekfrLK3ZpKaPDna8jadPTncZUy7KiTGKKHgvaHaEoIx90YdsYYjDXoNr6RriUOc4f87xF97+EPtXlqQhwRzYBznlfjBaWbCagIcuTHlQlT7DMp4iIHCj2fBngamjyupmC5T8EUs9tV6VJcVFxqW0eBnVC8Rq7nKyejtBi3KvNU72IiWNuTj/zlnLjLa1COSYEoMcSeUb02O88ybKUFLWrCA+kga7Wfddx2J+wDCYo7lYzM3+tORs7Tum0x3e/rWvIsaBbjknpcTVReLSfiQlpfGZxh29sjUXoX+Bu/capr7FO1guE/tzi0TaMbQZzkXXw3xODC0zTpdyf6aMKtnrwaysajOJqqv7ImWbLT2pLKj1xTx+fumhAncuglpZS9q7Wh9Xe21/0DKULQixCuCMvYtdibSrgo73AEtXUjxaRE5Urd9dTJbhMKbTp3LDaJvAG77kBWXdJRthNqHZmx5Np8qKdEppzopiM5hf9orns7szI4TAffdf5EUveYDQBD7y6Sf5vU89zqIbuHz5CqPww6ajxNdx6rV7+BCyR8B4zzy05DjTvm621QyO6pnTLVrCqKtPyPh7+8HSqfWE27B9b/3+ffInoJ3u8EVf+014p7QhnTq7dNJWOu+5/4Uv5v4Xvvjodq+tws7x8sO6YtLnGLttmYCc9yXQ4j3OaRmE6lrfWl2lzzlxq0HsKnvwhEO+Ehoc0wpLml3TBJomEEIodWk2C5RzJEUbeHe91fmuj29WixRlYCe84IUv4tc++CmG3LOIC2JOpF6Jy9J2Kw/0pWZt3N7grQxip53yl77tO4DvACClSBz6E8cPh9u/4UyBVWcBVr0mxxThsxj7FnpxqHhLlV05mjb+W7X4gpta39pPjNYc+zSuMmPIq5n769dxbBUcPbfvu+9u3vWT/whKWq2no5HFketrlY1Tfh6dkLYNvPUdr+Mt3/palukC+8P9xNwSDzLDQSIl2F8m5r2lXnfp7KDrM2EsVDtyj9L1Z4as/Xq8x5Vjt3L8ZG0/14+vrtLCXRmrHCq0jm1l1kR9xjGfStHIsN85Z787PkaXko8ta9fi6lm6NhZcjSE5vF6u+87aiHd9TLM6b4+daqODao8Gt9qnlV+yAdus8znpo7lt2KDATqgoQnQNTk0RTMIAmOoheuMbnI2TheAd2ZlhU7J0y0njCV6YThsmeJro8DHh4oDETNaxJe7JeLFZNS+WK35Sr6b1fUopWr2ZONQH9NgJ5Sm9l459r0s2s3Ja+pRmtZQdNTlyzfYwst5cVnfVdZsfZM2z0IljaITolVYcd2PHuBWlucmrJQ9K7gEVwswTpqbU1zZWl6ZqMt3He4NJNgn/kdFPG3usBu9WOfHihNA4QuMJQWlaU9KUebT6Mc2WaN57a/UQLP1PkiMMJpHeJQXviGopjGfpRD6jG4XcOk+zZ8DK2cuMn/cmyhEgTB2TaDWOgYaEZ+YDk8mUye4MXIM0LSAMvdItOpbzBX3XEVM01dkTHrRN07B74QJ+tsfe+fOEyQTXNLgsqzYhjRe8O2wHIF5oZjPO330vk72e+eXLDPsL4hDpl0v25/vWZmCxZCiKojGDWyZEBnwYiqpdNrVbVfoh08ciu57z4cOxoAjJWf23E1iW/mcxwSAlBTWX8y8ry/0lYUgEcVwNmxcDeuKJy2hPEbuBRCKSUIQlE5ZlHzQIYWL3tVl0uNaREvS9HkkjUgWNmT6VGr7xga7CEIOlm8WE6gDYgHqIPeqEdvUQd0xnDdPd6WoArGrCQE1pPdQ0LTKZoeIY+p6u78iamacli26w/sXDnKwdSGk9IoEQnGUbOCG01jcSkZKepuAEv9Pi8XinJJ/p1KLRTfZoznifOD/ztJPA3m6gPdcQGyUMgo/Kqrn2rcA5m8lUPVRTXUfErjVxaLb7siZL71PtQJWsniFZIqR3+TCN9gYkdRDLnzjhe6o2M5lVEFFCSaO1Pm6mFprV0Sd35G8LEFzGidVux+xKpF0Yojtzdin4fGSW4sztz0I6ntIscnoe3K2mDGCbJpj67LlzXLxwkdgtWM4vM+TEcrkkdh2xt369YeJxBNppw2xmQbWkStdHhiEdDqC9kHGIQpCGCRO8C+yd22X33B4uOO6++wIxdpaOqR05RebzAx5//HFQxXvH3RcvmKChWlYBaiIzuRFQx3RiQUKfHGnwuAx9ziSxJ6gXvxK+mU0ck9Yc69mktWtvjZwcKRxtt7VeYyoitKdJtT5D8qQBJ4RgbWDkjASBdcwx9bR+hmBaD4HiYJJwWnoVuqfhGGtG1ZTwU7IyAy314ha4SiTrcHvDVTmFMCj+uAizz7gmgWTcmrru2kYQtSetZBCNnDxDH8hR+Oxy4E8OHqdLYuOpQdFSzjSIBRnTYvMCW03TMLYaBBBGZVcQOWxnp2rCQZrBuYamgbadsDPboWmb1SzmkeMi1r93Np3gercKaHjv2Jm1TCatpazGiKptS9u2KEq3mNN30bbNmziP9ZjuyCkRfGA2te4VTfA0jS9jR0dWK18KTYu4BidKMynjxSGsgpZt05QglKNtA2iDOMdsNjFBIFEm05YhtrRNoAliWQ5lAasHb5qmbH9rad0hMGk26xpWR/MEVK3hqqoSnRDFGnN7p4gvF6I2Nx30lLE+b4yoKITgmE0DbWPNthv1hOTwSZEYkWgpMPGMDmziLCXJcv+15H+f/Fkl0+eEljRgLTNI6ziB9ljwI6N0ORPjWfkBWuTusw3mkjVs75Y9fW/T9vsHm7/JLBV6EYYgZFUmQZh4c8BnTpm6s+aEx22HtDwUDmp3JrTnW1MkKz0cY85cW0a6Y8cgDtGUMtcivIhF0EMTSk3mYQ2GXdTrQlIQ+8Qy22yXYY5mIODFHnRt9HiEkD3JOYaQWToYbnIwdaP9tw28hdOZQJThaNCkzDaigp86JsmTs8cPDTl5JhKsPmlqrT4klMDIFaVf9nSLzpqTp4ho4qQASAgNe+fO0e5dYGd3D980lior1gMLLNW9KZOl4h3iPc3EsXfBM40ZHRJX9DF0SAx9z2KxMIGMLlqtn8AQlTSmIK1PAx5/qYpkLc7mIVmgd4504gDEeuD1ag9tVYVFjyx6BLh0C2ZeLl++RiAw0RZByGQGIorQa6Qrqap4Sw1vRJnumKMZe3CayWv5lhkLVpk4i66i71mFIZXhWBRQa4ORNNOnYTXWdwLOB2aTKZPZjg20lj25j3atTVtc8DS+gWaKIgyDsogdKWfmccmCjGpEhiVCj4WSrU7KeY+fNvjgCN567gqm8piT9YL005bQTnCaSHnOoBFRGHJEsuJcZnfimM4Csx1Ps2MzNH7pcL1aNur8Fjma4o6mZ5yEC6bgmTKpk5JpkqAMUnOekLXBanVsXvhmULXa6hHvrh/wpiwkLKDjV/dkMWdTTTwkpzESf/i3vbPXWa1WM6nNIMQzArw22LcU3pshqxCTO2Fvb9+MpncO9Y62bdjb2eWuc+fZJ7N/eSDGnm65ZBgs/VeDQ5qAaKKZBKbTgIjN6PdDIsZ8OFMroMGkY1rXMPVTvA/MdmbMdncQJ5y/6xxxWBKHJcv9nhQjy+Wcp556ChHhrgt3rYLwouCKoJ131rNWGmEysRkgiY4eB1lJa6Uf9lxzBC+cmwX2pr4IqjVHMwkATY7sj/V1FsEVNVAnysRtNiiQ2wZcGZA/rWesZcVMfbDep6vfgteIP6HNz43Qct9SLdkYycanq57FJFQGkJtwNDOECC4ffc47Iq4ZOElZ1rZBiQwMejT1NeaWvp8QXeDJecfDV64yH3L5zlFEFbfcfPlUOKZRIKI4SatMKCltslIatcFMcNB7c6wmpV/tEo7UANu6LIg5aYvWcJk08N4xmzbMplaTr2pCgpNJw87OzILeuSvVB452YqKGw9CTS124OEdwoQSWhHBd7ZbgXGM1phyWjItzpU91pgnNSgisCQHBrp/JpGEyaVDNNG1TUrUDwQvBKb7IKCilZVuwNO4QGrw357VptqS9ybaSs9UgplTk3p2uFJykPBgZUzY1l5mUs28eNn1tKRTeWfF8KMqYfmwOTwn062E6yphXftrac4aopY+RCOJiWc/hzOOYUmMRnVgGGB58OjqNj12kWlLVxhRGtBT9u1LjEdPRNCvVokA46jqXNIuyDab0mBluQTS/KT3BSmtIGqe0JZW1cdkciJtYjw+QJ+bQN63VY4q3iKYLgiar4RtT7lbPPFNrMQebcUbz7BSboy1h9DBVQi0CmNV8PpslLsqdWdEkaML+zw7ryWS1nU8nLbncf8c/z2Hr0VvnZIKJRY3KiFocLTf2dyuJjyJKaAPClMlsQmgnhKa1tLYyu9T3HYv5PvP5PnHoV4PW8RwbUiKq1ekmLVHgUS22fFactaIATKGxpKNQtk1zxmmZe82ZPg70cWCIiZiLeE3WIk8+av4dHtOzUI42h4bS87R82f63f46kUpe/NGYgjms4vq5NsBqXltQxh9V/mSgCdDFZXzhMnTs7JTtfBK0E5xOUAaaqDTJMdzYXOx+mAKmYIzo2nhcBxRFLT0rBkdQyB3TlqNog91BhsMyUuuK8OF8cq1Efekwty+X8syCdKzvpxvRDd1Sl7/C6Kvc1NUt5J/hVmrfVqMWkXOsHehEWfSRFRePh7C3jvXXTnHKvWaV0jUGw44XkJ21K6Z2lxbGTLEhWcKYQvHahwPF0PdGSfnq4PU7K9aHjNtn7dh7bjNb6ZKKM6VtrSqnjdo09qVcrgnKtjsfXbPd072Ljc4+17bzV98IbMaree+do2sYGqotQaixTEf4wRdi2Dav0PO893gebRdExyyivRMUOxxejDay9FOP91wmTyYTZzi7dUljsXyUmpe8ji8WCxXxuffZKEH59HDBmbq3aiJU0Wiel76zLOL8KMZjz5e2aD01gVAc9PE+NrBYIWqXyj+svYzITsdqsvZyY4Aty/bPczpczvnvsM+O+Orhu3066Bo/ee7SUAJTrOevacTcnExKix65FxmfEeG2Up6yYKzk+M+y8t8CePR9zcdTG50z5W2SSRrsPq6AaUBx99hxkpZfEfoRFciyVUsCQD4+TgIpaEsOGEXFl9nK89m28KSU76HAsvZb2SlFglTU1WpGijD8eGxuzZ0aBnqOCfOusd5445cZqfkJJVYXjKbLjvqyfH4eD1/XUXilj89X4YO1v2HPxcBvs+X1YjnTsCXBsH+x/t0rF3SzV0TzGfD4nj01RUXbbKbOdHULwZD9FU4M1NU7kZBGqswf6dkKNEYkm2MXsnWPWNDTelVQ7ZcjmxHlvEth9aXlw2vojmSEPRbkxk1Ypqz1xMLGEdjKjnUxXDy9XbtItAyFcf+VHsRN4Op0yaSerQXRwwjAM7M8P6JcdWbHWDGoRnhAs8rLuFo+D/36IXJ3Pn4E1zubu8ztW5zX+yWRSs4IykchE4k1dMNIG/LkGxCE7DTILNmAudWch2V61sfT5G0ohtvfk1pyEAWUoT9zjUdmTUOyzLgih9UhyLIdEF+1moUOmSVragHhcUPoIfeeIGTR5QqOm0FmUxW4G7yxhTbH+W/3nKENsd/c8zXhdpcR0Epi1dttfukRMHd5POX/POXbO3cd0Z5e77ruH6d55usWc/UuX6Lsllx79DH/y8B8x39/n6uWnTHFQhXnXoaljGBIHQ2SBNaH3B/v0Cnu7M5PzFmsu3pR+uG5MFc+J1C/JcYmqiUCIKkM/59LBFa5du8alxZyD3mYJUjRnE7EBU+NM0j6NLR/WsOG2nYkxK/F4DVipO6Q4u5YdoDYj1phIgIquVIJTGTAoEM8a9TwLxEEIprrs8bRFPn7ZZx67siSIY6/xTENDxNM7x+ASEiJhVo7nYAqvKHjNNBrxCuIyEkpgy2eiT0wV9sKEVqEj0NCQEIa0pI9LRByh6wnSg5o8O5izkboIkvCzCbq7i/oGmWRC6pA04GPEpYE8qvXF0kpRbB+bIDQl1X0czJuPdmgjzZE8WA+6ySQwDcH6doYJ3nkuLxMffvQSEjyPPXnA8mpPPwyk1QWmaLg1gminkQazAQJN63HhxvclWE91hUDEaywnRItF9jKmz7cWPFRIqUG1KUEkpQk2OIvJrWYlY3JEzEGwNNrrZ6qs0d+aw4rZKCCHiriaid1A3/UWD24mSDN92sfIl20Y03NTvjXX080y1n6JwGQ64fyFC1y8915i7Egps1x27O/v89TlS6hAExwXzs0QFSaTKbPZeTQndBggLpE00ARoW2+qTn2ZgcwZ3FBSMntiGsDB3ffdz/m7LnLpqSd58slLXJ3v8+TlAz7zmT9lMZ9z33330fd96UVcnKCx7MAJoo7oPQSrO5/5knYflGFivcYDYmml3lkfv12zm4knHsX7jKqp2pnzbcGo4BRfHIynlYp6E8yY0xBwlF6rawRnwmynMcoJgGVWWSmS3f9F/ZG1jYH44+O7XMZNWgL3WpyIMV3WAtsdKlY24tKwEqocSWQ7ngIutIgPKPa8jwIiGS89IjZ27PtIFqXxiUmICMqQI1FtOzJW3pO1ZRj2SHnGVY08oksONPHkEHgs7tCrsCdL9qRbz18CD/nc5q8t562e2AcLuPTdkq4I8E0mjrbst2qyPsZaZvTElTZCLU0zwcnSMtSGAVXwjQXGYzThnGEYrOzsGDlnhj6WVNbBfALLbQXMxjEOKyEuxOF8KO2HjtZU39T+Ouv9qWrbvwr8aUbzgOIPg4tigRxrleQ5aQIkZyVFG00IlFnPG9cjP12qo3kMi9glS8kTBUz1LYTAIA0xFVWxPKB6k7N0Y/SCUhNWonCN96sei2PetWrpf6jWkzKdUggPWAPy2EFRsOqGjpwTQ7egX84BYba7x2xnb9XCIQRPEzwSFJHrzZ8Zo0MNIVg8KGWbWZAMxI7UzYkJuqHMJDYBNxsbQ7O2P1qczXRL+v3tzo4KoaQ+EXubWZ2QaRmj76dzKIbQIs6RpwGdHk0cEydMss1wZVFLR0LtIi/O+irOf5MzTOPnxQmucaVvX7akPgWfMq70mRPv8ChxUFLvVipnY/BirNW44d8UwakymikpSL7REdoMbTvFDT0aB5JmhExTVHGdZHKO+JCZ7s04f+9dtLNdpnvnmOzskoaB1PcM8wUHVy7z1Gcf5eBgn8ViwTgnOsSeHCMxZbqcrAtoziz7jiSeoT+8jpz3+LZhfRChKaJ5Th7sISXYTFyKAwfLBdcWc+Zdt6pXHqOfIhBKdNTEa66f1RydTDs/jqodg/3Sl8GITZyVmRpnKWYiggd8mfE04aDDdd4KnAMfBC/g11LsY4Kri0hwzmZQGkvnjk5IYurKXgaLrGYllUPsyPgyI5gFtCSHqLOZPnGOqTRMcTgaMlOiQsqRISeEZP38Rgn3EYVcgix5AuomEFqkWeCbAF4t4SMnRFIZ3FkamRNKtoYNVp1z1rrmmEL2OAuvWJurxgcmjcM7a6btxDPvE5evHJCdcHCtp1+YSqCOUTABPSGt9JahVmMb+3QoZnazX1UTaBLASwKyZW6U2TKbzRw43mtX1ZFSW4KaieBySflzqxN1dOTEKd7no4MswQzir1cRXXWwGDONciYRLTCUsfT61dzakcNwZrBRxNIjLdPAUnxvN67UHoamYba7w+65Pa5cmpQgcqTrOg4O5rSTljjsWda0dzShpWmn5Gj3yxwHJEc7x0OZnik3EGcPc8uiyaZi6cSxu3cO7zxDTCQCi145mHdcunwZzYmDgwNiXM8QMexcsZZEznmcZII4GvE4gcEnXNmGBqHFyocmZcZWVZEUSfn4NVKer1LE2rw5FI0kAjZzJRtu8dRIX/7q0fHFuI/NTV5IDj2qeXF88K5ryxqWVXe0HGQcHx6my0bs+ku4lEwvYu3DyVxNQFDnV8coUZ771qUYT6LXzDwmEspUI+IGnGS63NPno3WLKTUshwkx7XE1L3g0HnBFe65mz5XcknA0JHbl2HhPQKebv7bEFT2MpkFE6PuePto9IjTj8TucBS6bsuq17YMJYAmjrkJeBTXEWQu6fhiIMV7/3IaiZJtKj/C00uxY2U7VlKAZn/tj9ozptDxdf+5Q/Mq6Iay2Q0tfb9uosp92zVh67QmOph4GO1bHRWSVabZJqqN5jFuhjnojnm30YFRePeGds//uqd95BtvzuT9sR47baXa7mWN70keOfk/XfqfXvb+u0LnRSNBabuv1+zfKZD+9A38kDWP1d7jl2WKrFJbjvzzulMnRt09lA9fpERsef2/1u/Hf23CC34hbNJt59E/c+G/c7JE5vqbTj/4muLljc0uP4OfglPkPP/t/3Po/UtkIm3o2vPe97+G9733PRtZ1Mzz+xx/hP/6G9df+4R++IxoC3FJuKgvqhrY8vPhFTl7rJsea149Wbo6NPNeOrOKUUeUtSMd8pmx6tu56TnBIj9j6aHRNTghOb5Jbv783sQ23w7G6E5Gb6cZb2Qiq+qzO/Gqrzx3VVttDtdX2UG21PVRbbQ/PxlbVos3ycQAACKtJREFUTp876jW1PTxbW0Gd0axUKpVKZatQVRkHW5sYCHw+cacdl2qrk6nHpFJ5blAdzcJ4s6s3v+u5045JfXCfzp12XKqtTudOOy7VVqdTj0ul8vlNHQOezp12TKqtTudOPCableuqVCqVSqVSqVQqlcpznupoViqVSqVSqVQqlUplo1RHs1KpVCqVSqVSqVQqG6U6mpVKpVKpVCqVSqVS2SjV0axUKpVKpVKpVCqVykapjmalUqlUKpVKpVKpVDZKbW9SqVQqlcqWcSfJ199J3InH5U7cpttNPSaVynMDUdXbvQ2VSqVSqVQqlUqlUvk8oqbOViqVSqVSqVQqlUplo1RHs1KpVCqVSqVSqVQqG6U6mpVKpVKpVCqVSqVS2SjV0axUKpVKpVKpVCqVykapjmalUqlUKpVKpVKpVDZKdTQrlUqlUqlUKpVKpbJRqqNZqVQqlUqlUqlUKpWNUh3NSqVSqVQqlUqlUqlslOpoViqVSqVSqVQqlUplo1RHExCRcyLyt0XkwyKyLyJXROQDIvL9ItLe7u3bNCJyj4h8t4i8S0R+X0QORKQTkU+LyE+LyDvO+O5fERG9ieXNt2jbq62qre5Iqq22h2qr7aHaajuodtoeqq22h2221Ui4lSvfBkTkxcD/C7yk/GoOTICvLMt3iMibVPXSbdnAW8OjHLX9EhiAh8ryLSLyHuAvqer8lHVk4LNn/I1uExu6TrUVUG11J1NttT1UW20P1VbbQbXT9lBttT1spa2OoKrP2QUz3ocABT4DvLn83gF/Gbha3vuF272tG95vBX4D+K+Al639/iXAj5T3FfixE777V8p7n6y2qraqtqq22sal2mp7lmqr7ViqnbZnqbbanmUbbXXddtzug3ibDfhX14z0hhPe//a19990u7d3g/v9dTd4/5+t7fcLj713u24y1VbVVnf0Um21PUu11fYs1VbbsVQ7bc9SbbU9yzba6vjyXK/R/K7y/6+o6r874f2fAB4ur7/zc7NJtx5V/ZUbfORfrL3+ylu5LU+DaquTqba6Q6i22h6qrbaHaqvtoNppe6i22h621FZHeM46miKyA3xN+fE9J31GLSTw3vLjWz8X23WHsFx77W/bVhSqrc6k2mp7qLbaHqqttodqq+2g2ml7qLbaHu4oW53Ec9bRBL6Yw/3/3TM+N773PBG5+9Zu0h3DG9def/iUz9wnIh8sql8LEflEUcV64ymffzZUW53OG9deV1vd2bxx7XW11Z3NG9deV1vd2bxx7XW11Z3LG9deVzvd2bxx7XW11Z3NG9de3wm2uo7nsqP54NrrR8743Pp7D576qc8TROQC8N+XH39NVf/wlI/uAF8B9Nh59FLgO4BfEZF3isgmFY2rrU6g2mp7qLbaHqqttodqq+2g2ml7qLbaHu5QW13Hc9nRPLf2+jRJ4OPvnTv1U58HiIgDfgx4PjYd/9dP+NhngP8R+HJgqqp3Yyfx1wC/WD7z3cDf3+CmVVsdo9pqe6i22h6qrbaHaqvtoNppe6i22h7uYFtdz+1UIrqdC/BfcKjU9AVnfO4tnKF09fm0AP94bV+/5xl83wE/Xb6fgFdUW1VbVVtVW23LUm21PUu11XYs1U7bs1Rbbc9yp9rqpOW5PKN5be31zhmfW3/v2qmf2nJE5Ic4jIh8n6q+8+muQ1Uz8APlRwd804Y2r9pqjWqr7aHaanuottoeqq22g2qn7aHaanu4w211Hc9lR/Mza68fOuNz6+995tRPbTEi8neA7y8//oCq/oNnui5V/RjwRPnxZc922wrVVoVqq+2h2mp7qLbaHqqttoNqp+2h2mp72AJbXcdz2dH8CJDL61ef8bnxvUdV9albu0mfe0Tk7wJ/s/z4t1T1793O7TmFaiuqrbaJaqvtodpqe6i22g6qnbaHaqvtYUtsdR3PWUdTVefA+8uPbzvpMyIiwDeUH//t52K7PpeU6fdx6vxvqerf3cA6Xw7cW358+KzP3izVVtVW20S11fZQbbU9VFttB9VO20O11fawLbY6kdtVyHonLMBfxQphM/BnTnj/2zgstn3T7d7eDe/7D63t2/ff5HfkRu8DP8lhcfEXVltVW1VbVVvdiUu11fYs1VbbsVQ7bc9SbbU9y7bZ6rq/dbsP4G02XgA+VA70p8eTE5vp/VbgSnnv39zubd3wfv+dtZP2+57G914C/Cbw17B8blk7Xn8WeO/aev9JtVW1VbVVtdWduFRbbc9SbbUdS7XT9izVVtuzbKOtrtuW230Qb/dSjPHw2gE/ABZrP/9H4OLt3s4N7u+L1vYtAY/eYPmBY8dK15Yl8Nny//rv3wmEaqtqq2qraqs7bam22p6l2mo7lmqn7VmqrbZn2WZbrS+B5ziq+kkR+TIs9/k/A14KDMDvAT8O/GNV7W/jJm4ad+z1Azf4/N7a68eA7wXeALwGuA+4iJ24DwO/DrxTVd9/fCWboNqq2uoOptpqe6i22h6qrbaDaqftodpqe9haW60zTqVWKpVKpVKpVCqVSqWyEZ6zqrOVSqVSqVQqlUqlUrk1VEezUqlUKpVKpVKpVCobpTqalUqlUqlUKpVKpVLZKNXRrFQqlUqlUqlUKpXKRqmOZqVSqVQqlUqlUqlUNkp1NCuVSqVSqVQqlUqlslGqo1mpVCqVSqVSqVQqlY1SHc1KpVKpVCqVSqVSqWyU6mhWKpVKpVKpVCqVSmWjVEezUqlUKpVKpVKpVCobpTqalUqlUqlUKpVKpVLZKNXRrFQqlUqlUqlUKpXKRqmOZqVSqVQqlUqlUqlUNkp1NCuVSqVSqVQqlUqlslGqo1mpVCqVSqVSqVQqlY1SHc1KpVKpVCqVSqVSqWyU6mhWKpVKpVKpVCqVSmWjVEezUqlUKpVKpVKpVCobpTqalUqlUqlUKpVKpVLZKNXRrFQqlUqlUqlUKpXKRqmOZqVSqVQqlUqlUqlUNsr/DwYHjcPwCUu4AAAAAElFTkSuQmCC\n",
"text/plain": [
"<Figure size 1080x720 with 8 Axes>"
]
},
"metadata": {
"tags": [],
"needs_background": "light"
}
}
]
},
{
"cell_type": "code",
"metadata": {
"id": "ixZeHMbA89k0",
"colab_type": "code",
"colab": {}
},
"source": [
"#small model\n",
"#!python src/run.py --sample --n_embd 512 --n_head 8 --n_layer 24 \\\n",
"#--ckpt_path /content/image-gpt/models/s/model.ckpt-1000000 --color_cluster_path /content/image-gpt/clusters/s/kmeans_centers.npy \\\n",
"#--data_path /content/image-gpt/datasets/s/imagenet_notused --save_dir /content/image-gpt/output \\\n",
"#--n_gpu 1"
],
"execution_count": null,
"outputs": []
}
]
}
@ucalyptus
Copy link

woah thanks

@bitcoin5000
Copy link

How to make completion of images? I want it complete my own cutted images this is posible?

@nathgilson
Copy link

same here

@yugo-harago
Copy link

Same here

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment